diff --git a/glide.lock b/glide.lock new file mode 100644 index 00000000..19750266 --- /dev/null +++ b/glide.lock @@ -0,0 +1,193 @@ +hash: 6ac0ebb0f8853fa18c2be5b1b550eb3f96b4ea1deb3a0d4ff5390af768e16a22 +updated: 2016-08-23T02:25:54.515417454-07:00 +imports: +- name: bitbucket.org/zombiezen/gopdf + version: 1c63dc69751bc45441c2ce1f56b631c55294b4d5 + subpackages: + - pdf +- name: cloud.google.com/go + version: 242ed68074e53cbb6f78a90c28d9a48bfa2d1093 + subpackages: + - compute/metadata + - internal +- name: github.com/ajstarks/svgo + version: 672fe547df4e49efc6db67a74391368bcb149b37 +- name: github.com/cheggaaa/pb + version: 6e9d17711bb763b26b68b3931d47f24c1323abab +- name: github.com/cloudfoundry-incubator/candiedyaml + version: 99c3df83b51532e3615f851d8c2dbb638f5313bf +- name: github.com/coreos/etcd + version: 959f860a4053f66a2602a5795a9ebc04eed20f0a + subpackages: + - auth/authpb + - client + - clientv3 + - etcdserver/api/v3rpc/rpctypes + - etcdserver/etcdserverpb + - mvcc/mvccpb + - pkg/pathutil + - pkg/tlsutil + - pkg/types +- name: github.com/coreos/go-systemd + version: 5c49e4850c879a0ddc061e8f4adcf307de8a8bc2 + subpackages: + - journal +- name: github.com/coreos/pkg + version: 3ac0863d7acf3bc44daf49afef8919af12f704ef + subpackages: + - capnslog +- name: github.com/dustin/go-humanize + version: 2fcb5204cdc65b4bec9fd0a87606bb0d0e3c54e8 +- name: github.com/ghodss/yaml + version: aa0c862057666179de291b67d9f093d12b5a8473 +- name: github.com/gogo/protobuf + version: 330d6892d1d39fcd6cff0b4240821bdaf30c3a3c + subpackages: + - gogoproto + - proto + - protoc-gen-gogo/descriptor +- name: github.com/golang/freetype + version: 38b4c392adc5eed94207994c4848fff99f4ac234 + subpackages: + - raster + - truetype +- name: github.com/golang/protobuf + version: f592bd283e9ef86337a432eb50e592278c3d534d + subpackages: + - jsonpb + - proto +- name: github.com/gonum/floats + version: e7dfbda930c8a40d6d1ba9107762aae3e6e47591 +- name: github.com/gonum/internal + version: 495c8ab446bf60264be32be6973302faac6a5695 + subpackages: + - asm +- name: github.com/gonum/plot + version: c1e68bf98c6ed50599f84747f929f684d49807b9 + subpackages: + - palette + - plotter + - plotutil + - vg + - vg/draw + - vg/fonts + - vg/vgeps + - vg/vgimg + - vg/vgpdf + - vg/vgsvg +- name: github.com/grpc-ecosystem/grpc-gateway + version: 5e0e028ba0a015710eaebf6e47af18812c9f2767 + subpackages: + - runtime + - runtime/internal + - utilities +- name: github.com/gyuho/dataframe + version: 573cd728a011e5473510a6a1df0f39023c305e04 +- name: github.com/gyuho/psn + version: 415d7423cced5ca6bf6dbf81c5cbe37605f1dfaa + subpackages: + - process +- name: github.com/hashicorp/consul + version: 36dc9201f2e006d4b5db1f0446b17357811297bf + subpackages: + - api +- name: github.com/hashicorp/go-cleanhttp + version: ad28ea4487f05916463e2423a55166280e8254b5 +- name: github.com/hashicorp/serf + version: 9432bc08aa8d486e497e27f84878ebbe8c1eab66 + subpackages: + - coordinate +- name: github.com/inconshreveable/mousetrap + version: 76626ae9c91c4f2a10f34cad8ce83ea42c93bb75 +- name: github.com/llgcode/draw2d + version: 13548be874707c45a83f9c2c282d76d671c7acf8 + subpackages: + - draw2dbase + - draw2dimg +- name: github.com/mattn/go-runewidth + version: d6bea18f789704b5f83375793155289da36a3c7f +- name: github.com/olekukonko/tablewriter + version: daf2955e742cf123959884fdff4685aa79b63135 +- name: github.com/samuel/go-zookeeper + version: e64db453f3512cade908163702045e0f31137843 + subpackages: + - zk +- name: github.com/spf13/cobra + version: 1f4717172e07e12150feb061b2ab847c3054f53f +- name: github.com/spf13/pflag + version: 103ce5cd2042f2fe629c1957abb64ab3e7f50235 +- name: github.com/ugorji/go + version: 4a1cb5252a6951f715a85d0e4be334c2a2dbf2a2 + subpackages: + - codec +- name: golang.org/x/image + version: 9f8d0d45877da31f672995d10677ae6a586e31a5 + subpackages: + - draw + - font + - math/f64 + - math/fixed + - tiff + - tiff/lzw +- name: golang.org/x/net + version: 7394c112eae4dba7e96bfcfe738e6373d61772b4 + subpackages: + - context + - context/ctxhttp + - http2 + - http2/hpack + - internal/timeseries + - lex/httplex + - trace +- name: golang.org/x/oauth2 + version: 3b966c7f301c0c71c53d94dc632a62df0a682cd7 + subpackages: + - google + - internal + - jws + - jwt +- name: google.golang.org/api + version: 7b2847ee16541b59d2a5004bb75794ebdc2246c4 + subpackages: + - gensupport + - googleapi + - googleapi/internal/uritemplates + - internal + - option + - storage/v1 + - transport +- name: google.golang.org/appengine + version: 4f7eeb5305a4ba1966344836ba4af9996b7b4e05 + subpackages: + - internal + - internal/app_identity + - internal/base + - internal/datastore + - internal/log + - internal/modules + - internal/remote_api + - internal/socket + - internal/urlfetch + - socket + - urlfetch +- name: google.golang.org/cloud + version: 12aa462581208c155e498dc13e14cabe6da24dc3 + subpackages: + - internal + - internal/transport + - storage +- name: google.golang.org/grpc + version: 0032a855ba5c8a3c8e0d71c2deef354b70af1584 + subpackages: + - codes + - credentials + - credentials/oauth + - grpclog + - internal + - metadata + - naming + - peer + - transport +- name: gopkg.in/yaml.v2 + version: e4d366fc3c7938e2958e662b4258c7a89e1f0e3e +testImports: [] diff --git a/glide.yaml b/glide.yaml new file mode 100644 index 00000000..037e9180 --- /dev/null +++ b/glide.yaml @@ -0,0 +1,45 @@ +package: github.com/coreos/dbtester +import: +- package: github.com/cheggaaa/pb +- package: github.com/coreos/etcd + subpackages: + - client + - clientv3 +- package: github.com/coreos/pkg + subpackages: + - capnslog +- package: github.com/dustin/go-humanize +- package: github.com/gogo/protobuf + subpackages: + - gogoproto +- package: github.com/golang/protobuf + subpackages: + - proto +- package: github.com/gonum/plot + subpackages: + - plotter + - plotutil + - vg +- package: github.com/gyuho/dataframe +- package: github.com/gyuho/psn + subpackages: + - process +- package: github.com/hashicorp/consul + subpackages: + - api +- package: github.com/samuel/go-zookeeper + subpackages: + - zk +- package: github.com/spf13/cobra +- package: golang.org/x/net + subpackages: + - context +- package: golang.org/x/oauth2 + subpackages: + - google + - jwt +- package: google.golang.org/cloud + subpackages: + - storage +- package: google.golang.org/grpc +- package: gopkg.in/yaml.v2 diff --git a/vendor/bitbucket.org/zombiezen/gopdf/LICENSE b/vendor/bitbucket.org/zombiezen/gopdf/LICENSE new file mode 100644 index 00000000..9a0b030d --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/LICENSE @@ -0,0 +1,23 @@ +Copyright (c) 2011, The gopdf Authors +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/bitbucket.org/zombiezen/gopdf/pdf/canvas.go b/vendor/bitbucket.org/zombiezen/gopdf/pdf/canvas.go new file mode 100644 index 00000000..399a4356 --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/pdf/canvas.go @@ -0,0 +1,248 @@ +// Copyright (C) 2011, Ross Light + +package pdf + +import ( + "bytes" + "fmt" + "image" + "io" + "math" +) + +// writeCommand writes a PDF graphics command. +func writeCommand(w io.Writer, op string, args ...interface{}) error { + for _, arg := range args { + // TODO: Use the same buffer for all arguments + if m, err := marshal(nil, arg); err == nil { + if _, err := w.Write(append(m, ' ')); err != nil { + return err + } + } else { + return err + } + } + if _, err := io.WriteString(w, op); err != nil { + return err + } + if _, err := w.Write([]byte{'\n'}); err != nil { + return err + } + return nil +} + +// Canvas is a two-dimensional drawing region on a single page. You can obtain +// a canvas once you have created a document. +type Canvas struct { + doc *Document + page *pageDict + ref Reference + contents *stream + imageCounter uint +} + +// Document returns the document the canvas is attached to. +func (canvas *Canvas) Document() *Document { + return canvas.doc +} + +// Close flushes the page's stream to the document. This must be called once +// drawing has completed or else the document will be inconsistent. +func (canvas *Canvas) Close() error { + return canvas.contents.Close() +} + +// Size returns the page's media box (the size of the physical medium). +func (canvas *Canvas) Size() (width, height Unit) { + mbox := canvas.page.MediaBox + return mbox.Dx(), mbox.Dy() +} + +// SetSize changes the page's media box (the size of the physical medium). +func (canvas *Canvas) SetSize(width, height Unit) { + canvas.page.MediaBox = Rectangle{Point{0, 0}, Point{width, height}} +} + +// CropBox returns the page's crop box. +func (canvas *Canvas) CropBox() Rectangle { + return canvas.page.CropBox +} + +// SetCropBox changes the page's crop box. +func (canvas *Canvas) SetCropBox(crop Rectangle) { + canvas.page.CropBox = crop +} + +// FillStroke fills then strokes the given path. This operation has the same +// effect as performing a fill then a stroke, but does not repeat the path in +// the file. +func (canvas *Canvas) FillStroke(p *Path) { + io.Copy(canvas.contents, &p.buf) + writeCommand(canvas.contents, "B") +} + +// Fill paints the area enclosed by the given path using the current fill color. +func (canvas *Canvas) Fill(p *Path) { + io.Copy(canvas.contents, &p.buf) + writeCommand(canvas.contents, "f") +} + +// Stroke paints a line along the given path using the current stroke color. +func (canvas *Canvas) Stroke(p *Path) { + io.Copy(canvas.contents, &p.buf) + writeCommand(canvas.contents, "S") +} + +// SetLineWidth changes the stroke width to the given value. +func (canvas *Canvas) SetLineWidth(w Unit) { + writeCommand(canvas.contents, "w", w) +} + +// SetLineDash changes the line dash pattern in the current graphics state. +// Examples: +// +// c.SetLineDash(0, []Unit{}) // solid line +// c.SetLineDash(0, []Unit{3}) // 3 units on, 3 units off... +// c.SetLineDash(0, []Unit{2, 1}) // 2 units on, 1 unit off... +// c.SetLineDash(1, []Unit{2}) // 1 unit on, 2 units off, 2 units on... +func (canvas *Canvas) SetLineDash(phase Unit, dash []Unit) { + writeCommand(canvas.contents, "d", dash, phase) +} + +// SetColor changes the current fill color to the given RGB triple (in device +// RGB space). +func (canvas *Canvas) SetColor(r, g, b float32) { + writeCommand(canvas.contents, "rg", r, g, b) +} + +// SetStrokeColor changes the current stroke color to the given RGB triple (in +// device RGB space). +func (canvas *Canvas) SetStrokeColor(r, g, b float32) { + writeCommand(canvas.contents, "RG", r, g, b) +} + +// Push saves a copy of the current graphics state. The state can later be +// restored using Pop. +func (canvas *Canvas) Push() { + writeCommand(canvas.contents, "q") +} + +// Pop restores the most recently saved graphics state by popping it from the +// stack. +func (canvas *Canvas) Pop() { + writeCommand(canvas.contents, "Q") +} + +// Translate moves the canvas's coordinates system by the given offset. +func (canvas *Canvas) Translate(x, y Unit) { + writeCommand(canvas.contents, "cm", 1, 0, 0, 1, x, y) +} + +// Rotate rotates the canvas's coordinate system by a given angle (in radians). +func (canvas *Canvas) Rotate(theta float32) { + s, c := math.Sin(float64(theta)), math.Cos(float64(theta)) + writeCommand(canvas.contents, "cm", c, s, -s, c, 0, 0) +} + +// Scale multiplies the canvas's coordinate system by the given scalars. +func (canvas *Canvas) Scale(x, y float32) { + writeCommand(canvas.contents, "cm", x, 0, 0, y, 0, 0) +} + +// Transform concatenates a 3x3 matrix with the current transformation matrix. +// The arguments map to values in the matrix as shown below: +// +// / a b 0 \ +// | c d 0 | +// \ e f 1 / +// +// For more information, see Section 8.3.4 of ISO 32000-1. +func (canvas *Canvas) Transform(a, b, c, d, e, f float32) { + writeCommand(canvas.contents, "cm", a, b, c, d, e, f) +} + +// DrawText paints a text object onto the canvas. +func (canvas *Canvas) DrawText(text *Text) { + for fontName := range text.fonts { + if _, ok := canvas.page.Resources.Font[fontName]; !ok { + canvas.page.Resources.Font[fontName] = canvas.doc.standardFont(fontName) + } + } + writeCommand(canvas.contents, "BT") + io.Copy(canvas.contents, &text.buf) + writeCommand(canvas.contents, "ET") +} + +// DrawImage paints a raster image at the given location and scaled to the +// given dimensions. If you want to render the same image multiple times in +// the same document, use DrawImageReference. +func (canvas *Canvas) DrawImage(img image.Image, rect Rectangle) { + canvas.DrawImageReference(canvas.doc.AddImage(img), rect) +} + +// DrawImageReference paints the raster image referenced in the document at the +// given location and scaled to the given dimensions. +func (canvas *Canvas) DrawImageReference(ref Reference, rect Rectangle) { + name := canvas.nextImageName() + canvas.page.Resources.XObject[name] = ref + + canvas.Push() + canvas.Transform(float32(rect.Dx()), 0, 0, float32(rect.Dy()), float32(rect.Min.X), float32(rect.Min.Y)) + writeCommand(canvas.contents, "Do", name) + canvas.Pop() +} + +// DrawLine paints a straight line from pt1 to pt2 using the current stroke +// color and line width. +func (canvas *Canvas) DrawLine(pt1, pt2 Point) { + var path Path + path.Move(pt1) + path.Line(pt2) + canvas.Stroke(&path) +} + +const anonymousImageFormat = "__image%d__" + +func (canvas *Canvas) nextImageName() name { + var n name + for { + n = name(fmt.Sprintf(anonymousImageFormat, canvas.imageCounter)) + canvas.imageCounter++ + if _, ok := canvas.page.Resources.XObject[n]; !ok { + break + } + } + return n +} + +// Path is a shape that can be painted on a canvas. The zero value is an empty +// path. +type Path struct { + buf bytes.Buffer +} + +// Move begins a new subpath by moving the current point to the given location. +func (path *Path) Move(pt Point) { + writeCommand(&path.buf, "m", pt.X, pt.Y) +} + +// Line appends a line segment from the current point to the given location. +func (path *Path) Line(pt Point) { + writeCommand(&path.buf, "l", pt.X, pt.Y) +} + +// Curve appends a cubic Bezier curve to the path. +func (path *Path) Curve(pt1, pt2, pt3 Point) { + writeCommand(&path.buf, "c", pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y) +} + +// Rectangle appends a complete rectangle to the path. +func (path *Path) Rectangle(rect Rectangle) { + writeCommand(&path.buf, "re", rect.Min.X, rect.Min.Y, rect.Dx(), rect.Dy()) +} + +// Close appends a line segment from the current point to the starting point of +// the subpath. +func (path *Path) Close() { + writeCommand(&path.buf, "h") +} diff --git a/vendor/bitbucket.org/zombiezen/gopdf/pdf/doc.go b/vendor/bitbucket.org/zombiezen/gopdf/pdf/doc.go new file mode 100644 index 00000000..4816beb8 --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/pdf/doc.go @@ -0,0 +1,40 @@ +// Copyright (C) 2011, Ross Light + +/* + Package pdf implements a Portable Document Format writer, as defined in ISO 32000-1. + + An example of basic usage: + + package main + + import ( + "bitbucket.org/zombiezen/gopdf/pdf" + "fmt" + "os" + ) + + func main() { + doc := pdf.New() + canvas := doc.NewPage(pdf.USLetterWidth, pdf.USLetterHeight) + canvas.Translate(100, 100) + + path := new(pdf.Path) + path.Move(pdf.Point{0, 0}) + path.Line(pdf.Point{100, 0}) + canvas.Stroke(path) + + text := new(pdf.Text) + text.SetFont(pdf.Helvetica, 14) + text.Text("Hello, World!") + canvas.DrawText(text) + + canvas.Close() + + err := doc.Encode(os.Stdout) + if err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } + } +*/ +package pdf diff --git a/vendor/bitbucket.org/zombiezen/gopdf/pdf/encode.go b/vendor/bitbucket.org/zombiezen/gopdf/pdf/encode.go new file mode 100644 index 00000000..e4fe535f --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/pdf/encode.go @@ -0,0 +1,149 @@ +// Copyright (C) 2011, Ross Light + +package pdf + +import ( + "fmt" + "io" +) + +// encoder writes the PDF file format structure. +type encoder struct { + objects []interface{} + root Reference +} + +type trailer struct { + Size int + Root Reference +} + +// add appends an object to the file. The object is marshalled only when an +// encoding is requested. +func (enc *encoder) add(v interface{}) Reference { + enc.objects = append(enc.objects, v) + return Reference{uint(len(enc.objects)), 0} +} + +const ( + header = "%PDF-1.7" + newline + "%\x93\x8c\x8b\x9e" + newline + newline = "\r\n" +) + +// Cross reference strings +const ( + crossReferenceSectionHeader = "xref" + newline + crossReferenceSubsectionFormat = "%d %d" + newline + crossReferenceFormat = "%010d %05d n" + newline + crossReferenceFreeFormat = "%010d %05d f" + newline +) + +const trailerHeader = "trailer" + newline + +const startxrefFormat = "startxref" + newline + "%d" + newline + +const eofString = "%%EOF" + newline + +// encode writes an entire PDF document by marshalling the added objects. +func (enc *encoder) encode(wr io.Writer) error { + w := &offsetWriter{Writer: wr} + if err := enc.writeHeader(w); err != nil { + return err + } + objectOffsets, err := enc.writeBody(w) + if err != nil { + return err + } + tableOffset := w.offset + if err := enc.writeXrefTable(w, objectOffsets); err != nil { + return err + } + if err := enc.writeTrailer(w); err != nil { + return err + } + if err := enc.writeStartxref(w, tableOffset); err != nil { + return err + } + if err := enc.writeEOF(w); err != nil { + return err + } + return nil +} + +func (enc *encoder) writeHeader(w *offsetWriter) error { + _, err := io.WriteString(w, header) + return err +} + +func (enc *encoder) writeBody(w *offsetWriter) ([]int64, error) { + objectOffsets := make([]int64, len(enc.objects)) + for i, obj := range enc.objects { + // TODO: Use same buffer for writing across objects + objectOffsets[i] = w.offset + data, err := marshal(nil, indirectObject{Reference{uint(i + 1), 0}, obj}) + if err != nil { + return nil, err + } + if _, err = w.Write(append(data, newline...)); err != nil { + return nil, err + } + } + return objectOffsets, nil +} + +func (enc *encoder) writeXrefTable(w *offsetWriter, objectOffsets []int64) error { + if _, err := io.WriteString(w, crossReferenceSectionHeader); err != nil { + return err + } + if _, err := fmt.Fprintf(w, crossReferenceSubsectionFormat, 0, len(enc.objects)+1); err != nil { + return err + } + if _, err := fmt.Fprintf(w, crossReferenceFreeFormat, 0, 65535); err != nil { + return err + } + for _, offset := range objectOffsets { + if _, err := fmt.Fprintf(w, crossReferenceFormat, offset, 0); err != nil { + return err + } + } + return nil +} + +func (enc *encoder) writeTrailer(w *offsetWriter) error { + var err error + dict := trailer{ + Size: len(enc.objects) + 1, + Root: enc.root, + } + data := make([]byte, 0, len(trailerHeader)+len(newline)) + data = append(data, trailerHeader...) + if data, err = marshal(data, dict); err != nil { + return err + } + data = append(data, newline...) + + _, err = w.Write(data) + return err +} + +func (enc *encoder) writeStartxref(w *offsetWriter, tableOffset int64) error { + _, err := fmt.Fprintf(w, startxrefFormat, tableOffset) + return err +} + +func (enc *encoder) writeEOF(w *offsetWriter) error { + _, err := io.WriteString(w, eofString) + return err +} + +// offsetWriter tracks how many bytes have been written to it. +type offsetWriter struct { + io.Writer + offset int64 +} + +func (w *offsetWriter) Write(p []byte) (n int, err error) { + n, err = w.Writer.Write(p) + w.offset += int64(n) + return +} diff --git a/vendor/bitbucket.org/zombiezen/gopdf/pdf/image.go b/vendor/bitbucket.org/zombiezen/gopdf/pdf/image.go new file mode 100644 index 00000000..0c712bc2 --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/pdf/image.go @@ -0,0 +1,135 @@ +// Copyright (C) 2011, Ross Light + +package pdf + +import ( + "image" + "image/color" + "io" +) + +const ( + deviceRGBColorSpace name = "DeviceRGB" +) + +type imageStream struct { + *stream + Width int + Height int + BitsPerComponent int + ColorSpace name +} + +type imageStreamInfo struct { + Type name + Subtype name + Length int + Filter name `pdf:",omitempty"` + Width int + Height int + BitsPerComponent int + ColorSpace name +} + +func newImageStream(filter name, w, h int) *imageStream { + return &imageStream{ + stream: newStream(filter), + Width: w, + Height: h, + BitsPerComponent: 8, + ColorSpace: deviceRGBColorSpace, + } +} + +func (st *imageStream) marshalPDF(dst []byte) ([]byte, error) { + return marshalStream(dst, imageStreamInfo{ + Type: xobjectType, + Subtype: imageSubtype, + Length: st.Len(), + Filter: st.filter, + Width: st.Width, + Height: st.Height, + BitsPerComponent: st.BitsPerComponent, + ColorSpace: st.ColorSpace, + }, st.Bytes()) +} + +// encodeImageStream writes RGB data from an image in PDF format. +func encodeImageStream(w io.Writer, img image.Image) error { + bd := img.Bounds() + row := make([]byte, bd.Dx()*3) + for y := bd.Min.Y; y < bd.Max.Y; y++ { + i := 0 + for x := bd.Min.X; x < bd.Max.X; x++ { + r, g, b, a := img.At(x, y).RGBA() + if a != 0 { + row[i+0] = uint8((r * 65535 / a) >> 8) + row[i+1] = uint8((g * 65535 / a) >> 8) + row[i+2] = uint8((b * 65535 / a) >> 8) + } else { + row[i+0] = 0 + row[i+1] = 0 + row[i+2] = 0 + } + i += 3 + } + if _, err := w.Write(row); err != nil { + return err + } + } + return nil +} + +func encodeRGBAStream(w io.Writer, img *image.RGBA) error { + buf := make([]byte, 3*img.Rect.Dx()*img.Rect.Dy()) + var a uint16 + for i, j := 0, 0; i < len(img.Pix); i, j = i+4, j+3 { + a = uint16(img.Pix[i+3]) + if a != 0 { + buf[j+0] = byte(uint16(img.Pix[i+0]) * 0xff / a) + buf[j+1] = byte(uint16(img.Pix[i+1]) * 0xff / a) + buf[j+2] = byte(uint16(img.Pix[i+2]) * 0xff / a) + } + } + _, err := w.Write(buf) + return err +} + +func encodeNRGBAStream(w io.Writer, img *image.NRGBA) error { + buf := make([]byte, 3*img.Rect.Dx()*img.Rect.Dy()) + for i, j := 0, 0; i < len(img.Pix); i, j = i+4, j+3 { + buf[j+0] = img.Pix[i+0] + buf[j+1] = img.Pix[i+1] + buf[j+2] = img.Pix[i+2] + } + _, err := w.Write(buf) + return err +} + +func encodeYCbCrStream(w io.Writer, img *image.YCbCr) error { + var yy, cb, cr uint8 + var i, j int + dx, dy := img.Rect.Dx(), img.Rect.Dy() + buf := make([]byte, 3*dx*dy) + bi := 0 + for y := 0; y < dy; y++ { + for x := 0; x < dx; x++ { + i, j = x, y + switch img.SubsampleRatio { + case image.YCbCrSubsampleRatio420: + j /= 2 + fallthrough + case image.YCbCrSubsampleRatio422: + i /= 2 + } + yy = img.Y[y*img.YStride+x] + cb = img.Cb[j*img.CStride+i] + cr = img.Cr[j*img.CStride+i] + + buf[bi+0], buf[bi+1], buf[bi+2] = color.YCbCrToRGB(yy, cb, cr) + bi += 3 + } + } + _, err := w.Write(buf) + return err +} diff --git a/vendor/bitbucket.org/zombiezen/gopdf/pdf/marshal.go b/vendor/bitbucket.org/zombiezen/gopdf/pdf/marshal.go new file mode 100644 index 00000000..2152aeb1 --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/pdf/marshal.go @@ -0,0 +1,202 @@ +// Copyright (C) 2011, Ross Light + +package pdf + +import ( + "errors" + "reflect" + "strconv" + "strings" +) + +// A marshaler can produce a PDF object. +type marshaler interface { + marshalPDF(dst []byte) ([]byte, error) +} + +// marshal returns the PDF encoding of v. +// +// If the value implements the marshaler interface, then its marshalPDF method +// is called. ints, strings, and floats will be marshalled according to the PDF +// standard. +func marshal(dst []byte, v interface{}) ([]byte, error) { + state := marshalState{dst} + if err := state.marshalValue(reflect.ValueOf(v)); err != nil { + return nil, err + } + return state.data, nil +} + +type marshalState struct { + data []byte +} + +const marshalFloatPrec = 5 + +func (state *marshalState) writeString(s string) { + state.data = append(state.data, s...) +} + +func (state *marshalState) marshalValue(v reflect.Value) error { + if !v.IsValid() { + state.writeString("null") + return nil + } + + if m, ok := v.Interface().(marshaler); ok { + slice, err := m.marshalPDF(state.data) + if err != nil { + return err + } + state.data = slice + return nil + } + + switch v.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + state.writeString(strconv.FormatInt(v.Int(), 10)) + return nil + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + state.writeString(strconv.FormatUint(v.Uint(), 10)) + return nil + case reflect.Float32, reflect.Float64: + state.writeString(strconv.FormatFloat(v.Float(), 'f', marshalFloatPrec, 64)) + return nil + case reflect.String: + state.writeString(quote(v.String())) + return nil + case reflect.Ptr, reflect.Interface: + return state.marshalValue(v.Elem()) + case reflect.Array, reflect.Slice: + return state.marshalSlice(v) + case reflect.Map: + return state.marshalDictionary(v) + case reflect.Struct: + return state.marshalStruct(v) + } + + return errors.New("pdf: unsupported type: " + v.Type().String()) +} + +// quote escapes a string and returns a PDF string literal. +func quote(s string) string { + r := strings.NewReplacer( + "\r", `\r`, + "\t", `\t`, + "\b", `\b`, + "\f", `\f`, + "(", `\(`, + ")", `\)`, + `\`, `\\`, + ) + return "(" + r.Replace(s) + ")" +} + +func (state *marshalState) marshalSlice(v reflect.Value) error { + state.writeString("[ ") + for i := 0; i < v.Len(); i++ { + if err := state.marshalValue(v.Index(i)); err != nil { + return err + } + state.writeString(" ") + } + state.writeString("]") + return nil +} + +func (state *marshalState) marshalDictionary(v reflect.Value) error { + if v.Type().Key() != reflect.TypeOf(name("")) { + return errors.New("pdf: cannot marshal dictionary with key type: " + v.Type().Key().String()) + } + + state.writeString("<< ") + for _, k := range v.MapKeys() { + state.marshalKeyValue(k.Interface().(name), v.MapIndex(k)) + } + state.writeString(">>") + return nil +} + +func (state *marshalState) marshalStruct(v reflect.Value) error { + state.writeString("<< ") + t := v.Type() + n := v.NumField() + for i := 0; i < n; i++ { + f := t.Field(i) + if f.PkgPath != "" { + continue + } + + tag, omitEmpty := f.Name, false + if tv := f.Tag.Get("pdf"); tv != "" { + if tv == "-" { + continue + } + + name, options := parseTag(tv) + if name != "" { + tag = name + } + omitEmpty = options.Contains("omitempty") + } + + fieldValue := v.Field(i) + if omitEmpty && isEmptyValue(fieldValue) { + continue + } + + state.marshalKeyValue(name(tag), fieldValue) + } + state.writeString(">>") + return nil +} + +func (state *marshalState) marshalKeyValue(k name, v reflect.Value) error { + slice, err := k.marshalPDF(state.data) + if err != nil { + return err + } + state.data = slice + state.writeString(" ") + + if err := state.marshalValue(v); err != nil { + return err + } + state.writeString(" ") + + return nil +} + +type tagOptions []string + +func parseTag(tag string) (name string, options tagOptions) { + result := strings.Split(tag, ",") + return result[0], tagOptions(result[1:]) +} + +func (options tagOptions) Contains(opt string) bool { + for _, o := range options { + if opt == o { + return true + } + } + return false +} + +func isEmptyValue(v reflect.Value) bool { + switch v.Kind() { + case reflect.Array, reflect.Map, reflect.Slice, reflect.String: + return v.Len() == 0 + case reflect.Bool: + return !v.Bool() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.Interface, reflect.Ptr: + return v.IsNil() + } + return false +} diff --git a/vendor/bitbucket.org/zombiezen/gopdf/pdf/metrics.go b/vendor/bitbucket.org/zombiezen/gopdf/pdf/metrics.go new file mode 100644 index 00000000..36ad827f --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/pdf/metrics.go @@ -0,0 +1,1389 @@ +package pdf + +// Courier +var courierWidths = []uint16{ + 32: 600, // space + 33: 600, // exclam + 34: 600, // quotedbl + 35: 600, // numbersign + 36: 600, // dollar + 37: 600, // percent + 38: 600, // ampersand + 39: 600, // quoteright + 40: 600, // parenleft + 41: 600, // parenright + 42: 600, // asterisk + 43: 600, // plus + 44: 600, // comma + 45: 600, // hyphen + 46: 600, // period + 47: 600, // slash + 48: 600, // zero + 49: 600, // one + 50: 600, // two + 51: 600, // three + 52: 600, // four + 53: 600, // five + 54: 600, // six + 55: 600, // seven + 56: 600, // eight + 57: 600, // nine + 58: 600, // colon + 59: 600, // semicolon + 60: 600, // less + 61: 600, // equal + 62: 600, // greater + 63: 600, // question + 64: 600, // at + 65: 600, // A + 66: 600, // B + 67: 600, // C + 68: 600, // D + 69: 600, // E + 70: 600, // F + 71: 600, // G + 72: 600, // H + 73: 600, // I + 74: 600, // J + 75: 600, // K + 76: 600, // L + 77: 600, // M + 78: 600, // N + 79: 600, // O + 80: 600, // P + 81: 600, // Q + 82: 600, // R + 83: 600, // S + 84: 600, // T + 85: 600, // U + 86: 600, // V + 87: 600, // W + 88: 600, // X + 89: 600, // Y + 90: 600, // Z + 91: 600, // bracketleft + 92: 600, // backslash + 93: 600, // bracketright + 94: 600, // asciicircum + 95: 600, // underscore + 96: 600, // quoteleft + 97: 600, // a + 98: 600, // b + 99: 600, // c + 100: 600, // d + 101: 600, // e + 102: 600, // f + 103: 600, // g + 104: 600, // h + 105: 600, // i + 106: 600, // j + 107: 600, // k + 108: 600, // l + 109: 600, // m + 110: 600, // n + 111: 600, // o + 112: 600, // p + 113: 600, // q + 114: 600, // r + 115: 600, // s + 116: 600, // t + 117: 600, // u + 118: 600, // v + 119: 600, // w + 120: 600, // x + 121: 600, // y + 122: 600, // z + 123: 600, // braceleft + 124: 600, // bar + 125: 600, // braceright + 126: 600, // asciitilde +} + +// Courier-Bold +var courierBoldWidths = []uint16{ + 32: 600, // space + 33: 600, // exclam + 34: 600, // quotedbl + 35: 600, // numbersign + 36: 600, // dollar + 37: 600, // percent + 38: 600, // ampersand + 39: 600, // quoteright + 40: 600, // parenleft + 41: 600, // parenright + 42: 600, // asterisk + 43: 600, // plus + 44: 600, // comma + 45: 600, // hyphen + 46: 600, // period + 47: 600, // slash + 48: 600, // zero + 49: 600, // one + 50: 600, // two + 51: 600, // three + 52: 600, // four + 53: 600, // five + 54: 600, // six + 55: 600, // seven + 56: 600, // eight + 57: 600, // nine + 58: 600, // colon + 59: 600, // semicolon + 60: 600, // less + 61: 600, // equal + 62: 600, // greater + 63: 600, // question + 64: 600, // at + 65: 600, // A + 66: 600, // B + 67: 600, // C + 68: 600, // D + 69: 600, // E + 70: 600, // F + 71: 600, // G + 72: 600, // H + 73: 600, // I + 74: 600, // J + 75: 600, // K + 76: 600, // L + 77: 600, // M + 78: 600, // N + 79: 600, // O + 80: 600, // P + 81: 600, // Q + 82: 600, // R + 83: 600, // S + 84: 600, // T + 85: 600, // U + 86: 600, // V + 87: 600, // W + 88: 600, // X + 89: 600, // Y + 90: 600, // Z + 91: 600, // bracketleft + 92: 600, // backslash + 93: 600, // bracketright + 94: 600, // asciicircum + 95: 600, // underscore + 96: 600, // quoteleft + 97: 600, // a + 98: 600, // b + 99: 600, // c + 100: 600, // d + 101: 600, // e + 102: 600, // f + 103: 600, // g + 104: 600, // h + 105: 600, // i + 106: 600, // j + 107: 600, // k + 108: 600, // l + 109: 600, // m + 110: 600, // n + 111: 600, // o + 112: 600, // p + 113: 600, // q + 114: 600, // r + 115: 600, // s + 116: 600, // t + 117: 600, // u + 118: 600, // v + 119: 600, // w + 120: 600, // x + 121: 600, // y + 122: 600, // z + 123: 600, // braceleft + 124: 600, // bar + 125: 600, // braceright + 126: 600, // asciitilde +} + +// Courier-BoldOblique +var courierBoldObliqueWidths = []uint16{ + 32: 600, // space + 33: 600, // exclam + 34: 600, // quotedbl + 35: 600, // numbersign + 36: 600, // dollar + 37: 600, // percent + 38: 600, // ampersand + 39: 600, // quoteright + 40: 600, // parenleft + 41: 600, // parenright + 42: 600, // asterisk + 43: 600, // plus + 44: 600, // comma + 45: 600, // hyphen + 46: 600, // period + 47: 600, // slash + 48: 600, // zero + 49: 600, // one + 50: 600, // two + 51: 600, // three + 52: 600, // four + 53: 600, // five + 54: 600, // six + 55: 600, // seven + 56: 600, // eight + 57: 600, // nine + 58: 600, // colon + 59: 600, // semicolon + 60: 600, // less + 61: 600, // equal + 62: 600, // greater + 63: 600, // question + 64: 600, // at + 65: 600, // A + 66: 600, // B + 67: 600, // C + 68: 600, // D + 69: 600, // E + 70: 600, // F + 71: 600, // G + 72: 600, // H + 73: 600, // I + 74: 600, // J + 75: 600, // K + 76: 600, // L + 77: 600, // M + 78: 600, // N + 79: 600, // O + 80: 600, // P + 81: 600, // Q + 82: 600, // R + 83: 600, // S + 84: 600, // T + 85: 600, // U + 86: 600, // V + 87: 600, // W + 88: 600, // X + 89: 600, // Y + 90: 600, // Z + 91: 600, // bracketleft + 92: 600, // backslash + 93: 600, // bracketright + 94: 600, // asciicircum + 95: 600, // underscore + 96: 600, // quoteleft + 97: 600, // a + 98: 600, // b + 99: 600, // c + 100: 600, // d + 101: 600, // e + 102: 600, // f + 103: 600, // g + 104: 600, // h + 105: 600, // i + 106: 600, // j + 107: 600, // k + 108: 600, // l + 109: 600, // m + 110: 600, // n + 111: 600, // o + 112: 600, // p + 113: 600, // q + 114: 600, // r + 115: 600, // s + 116: 600, // t + 117: 600, // u + 118: 600, // v + 119: 600, // w + 120: 600, // x + 121: 600, // y + 122: 600, // z + 123: 600, // braceleft + 124: 600, // bar + 125: 600, // braceright + 126: 600, // asciitilde +} + +// Courier-Oblique +var courierObliqueWidths = []uint16{ + 32: 600, // space + 33: 600, // exclam + 34: 600, // quotedbl + 35: 600, // numbersign + 36: 600, // dollar + 37: 600, // percent + 38: 600, // ampersand + 39: 600, // quoteright + 40: 600, // parenleft + 41: 600, // parenright + 42: 600, // asterisk + 43: 600, // plus + 44: 600, // comma + 45: 600, // hyphen + 46: 600, // period + 47: 600, // slash + 48: 600, // zero + 49: 600, // one + 50: 600, // two + 51: 600, // three + 52: 600, // four + 53: 600, // five + 54: 600, // six + 55: 600, // seven + 56: 600, // eight + 57: 600, // nine + 58: 600, // colon + 59: 600, // semicolon + 60: 600, // less + 61: 600, // equal + 62: 600, // greater + 63: 600, // question + 64: 600, // at + 65: 600, // A + 66: 600, // B + 67: 600, // C + 68: 600, // D + 69: 600, // E + 70: 600, // F + 71: 600, // G + 72: 600, // H + 73: 600, // I + 74: 600, // J + 75: 600, // K + 76: 600, // L + 77: 600, // M + 78: 600, // N + 79: 600, // O + 80: 600, // P + 81: 600, // Q + 82: 600, // R + 83: 600, // S + 84: 600, // T + 85: 600, // U + 86: 600, // V + 87: 600, // W + 88: 600, // X + 89: 600, // Y + 90: 600, // Z + 91: 600, // bracketleft + 92: 600, // backslash + 93: 600, // bracketright + 94: 600, // asciicircum + 95: 600, // underscore + 96: 600, // quoteleft + 97: 600, // a + 98: 600, // b + 99: 600, // c + 100: 600, // d + 101: 600, // e + 102: 600, // f + 103: 600, // g + 104: 600, // h + 105: 600, // i + 106: 600, // j + 107: 600, // k + 108: 600, // l + 109: 600, // m + 110: 600, // n + 111: 600, // o + 112: 600, // p + 113: 600, // q + 114: 600, // r + 115: 600, // s + 116: 600, // t + 117: 600, // u + 118: 600, // v + 119: 600, // w + 120: 600, // x + 121: 600, // y + 122: 600, // z + 123: 600, // braceleft + 124: 600, // bar + 125: 600, // braceright + 126: 600, // asciitilde +} + +// Helvetica +var helveticaWidths = []uint16{ + 32: 278, // space + 33: 278, // exclam + 34: 355, // quotedbl + 35: 556, // numbersign + 36: 556, // dollar + 37: 889, // percent + 38: 667, // ampersand + 39: 222, // quoteright + 40: 333, // parenleft + 41: 333, // parenright + 42: 389, // asterisk + 43: 584, // plus + 44: 278, // comma + 45: 333, // hyphen + 46: 278, // period + 47: 278, // slash + 48: 556, // zero + 49: 556, // one + 50: 556, // two + 51: 556, // three + 52: 556, // four + 53: 556, // five + 54: 556, // six + 55: 556, // seven + 56: 556, // eight + 57: 556, // nine + 58: 278, // colon + 59: 278, // semicolon + 60: 584, // less + 61: 584, // equal + 62: 584, // greater + 63: 556, // question + 64: 1015, // at + 65: 667, // A + 66: 667, // B + 67: 722, // C + 68: 722, // D + 69: 667, // E + 70: 611, // F + 71: 778, // G + 72: 722, // H + 73: 278, // I + 74: 500, // J + 75: 667, // K + 76: 556, // L + 77: 833, // M + 78: 722, // N + 79: 778, // O + 80: 667, // P + 81: 778, // Q + 82: 722, // R + 83: 667, // S + 84: 611, // T + 85: 722, // U + 86: 667, // V + 87: 944, // W + 88: 667, // X + 89: 667, // Y + 90: 611, // Z + 91: 278, // bracketleft + 92: 278, // backslash + 93: 278, // bracketright + 94: 469, // asciicircum + 95: 556, // underscore + 96: 222, // quoteleft + 97: 556, // a + 98: 556, // b + 99: 500, // c + 100: 556, // d + 101: 556, // e + 102: 278, // f + 103: 556, // g + 104: 556, // h + 105: 222, // i + 106: 222, // j + 107: 500, // k + 108: 222, // l + 109: 833, // m + 110: 556, // n + 111: 556, // o + 112: 556, // p + 113: 556, // q + 114: 333, // r + 115: 500, // s + 116: 278, // t + 117: 556, // u + 118: 500, // v + 119: 722, // w + 120: 500, // x + 121: 500, // y + 122: 500, // z + 123: 334, // braceleft + 124: 260, // bar + 125: 334, // braceright + 126: 584, // asciitilde +} + +// Helvetica-Bold +var helveticaBoldWidths = []uint16{ + 32: 278, // space + 33: 333, // exclam + 34: 474, // quotedbl + 35: 556, // numbersign + 36: 556, // dollar + 37: 889, // percent + 38: 722, // ampersand + 39: 278, // quoteright + 40: 333, // parenleft + 41: 333, // parenright + 42: 389, // asterisk + 43: 584, // plus + 44: 278, // comma + 45: 333, // hyphen + 46: 278, // period + 47: 278, // slash + 48: 556, // zero + 49: 556, // one + 50: 556, // two + 51: 556, // three + 52: 556, // four + 53: 556, // five + 54: 556, // six + 55: 556, // seven + 56: 556, // eight + 57: 556, // nine + 58: 333, // colon + 59: 333, // semicolon + 60: 584, // less + 61: 584, // equal + 62: 584, // greater + 63: 611, // question + 64: 975, // at + 65: 722, // A + 66: 722, // B + 67: 722, // C + 68: 722, // D + 69: 667, // E + 70: 611, // F + 71: 778, // G + 72: 722, // H + 73: 278, // I + 74: 556, // J + 75: 722, // K + 76: 611, // L + 77: 833, // M + 78: 722, // N + 79: 778, // O + 80: 667, // P + 81: 778, // Q + 82: 722, // R + 83: 667, // S + 84: 611, // T + 85: 722, // U + 86: 667, // V + 87: 944, // W + 88: 667, // X + 89: 667, // Y + 90: 611, // Z + 91: 333, // bracketleft + 92: 278, // backslash + 93: 333, // bracketright + 94: 584, // asciicircum + 95: 556, // underscore + 96: 278, // quoteleft + 97: 556, // a + 98: 611, // b + 99: 556, // c + 100: 611, // d + 101: 556, // e + 102: 333, // f + 103: 611, // g + 104: 611, // h + 105: 278, // i + 106: 278, // j + 107: 556, // k + 108: 278, // l + 109: 889, // m + 110: 611, // n + 111: 611, // o + 112: 611, // p + 113: 611, // q + 114: 389, // r + 115: 556, // s + 116: 333, // t + 117: 611, // u + 118: 556, // v + 119: 778, // w + 120: 556, // x + 121: 556, // y + 122: 500, // z + 123: 389, // braceleft + 124: 280, // bar + 125: 389, // braceright + 126: 584, // asciitilde +} + +// Helvetica-BoldOblique +var helveticaBoldObliqueWidths = []uint16{ + 32: 278, // space + 33: 333, // exclam + 34: 474, // quotedbl + 35: 556, // numbersign + 36: 556, // dollar + 37: 889, // percent + 38: 722, // ampersand + 39: 278, // quoteright + 40: 333, // parenleft + 41: 333, // parenright + 42: 389, // asterisk + 43: 584, // plus + 44: 278, // comma + 45: 333, // hyphen + 46: 278, // period + 47: 278, // slash + 48: 556, // zero + 49: 556, // one + 50: 556, // two + 51: 556, // three + 52: 556, // four + 53: 556, // five + 54: 556, // six + 55: 556, // seven + 56: 556, // eight + 57: 556, // nine + 58: 333, // colon + 59: 333, // semicolon + 60: 584, // less + 61: 584, // equal + 62: 584, // greater + 63: 611, // question + 64: 975, // at + 65: 722, // A + 66: 722, // B + 67: 722, // C + 68: 722, // D + 69: 667, // E + 70: 611, // F + 71: 778, // G + 72: 722, // H + 73: 278, // I + 74: 556, // J + 75: 722, // K + 76: 611, // L + 77: 833, // M + 78: 722, // N + 79: 778, // O + 80: 667, // P + 81: 778, // Q + 82: 722, // R + 83: 667, // S + 84: 611, // T + 85: 722, // U + 86: 667, // V + 87: 944, // W + 88: 667, // X + 89: 667, // Y + 90: 611, // Z + 91: 333, // bracketleft + 92: 278, // backslash + 93: 333, // bracketright + 94: 584, // asciicircum + 95: 556, // underscore + 96: 278, // quoteleft + 97: 556, // a + 98: 611, // b + 99: 556, // c + 100: 611, // d + 101: 556, // e + 102: 333, // f + 103: 611, // g + 104: 611, // h + 105: 278, // i + 106: 278, // j + 107: 556, // k + 108: 278, // l + 109: 889, // m + 110: 611, // n + 111: 611, // o + 112: 611, // p + 113: 611, // q + 114: 389, // r + 115: 556, // s + 116: 333, // t + 117: 611, // u + 118: 556, // v + 119: 778, // w + 120: 556, // x + 121: 556, // y + 122: 500, // z + 123: 389, // braceleft + 124: 280, // bar + 125: 389, // braceright + 126: 584, // asciitilde +} + +// Helvetica-Oblique +var helveticaObliqueWidths = []uint16{ + 32: 278, // space + 33: 278, // exclam + 34: 355, // quotedbl + 35: 556, // numbersign + 36: 556, // dollar + 37: 889, // percent + 38: 667, // ampersand + 39: 222, // quoteright + 40: 333, // parenleft + 41: 333, // parenright + 42: 389, // asterisk + 43: 584, // plus + 44: 278, // comma + 45: 333, // hyphen + 46: 278, // period + 47: 278, // slash + 48: 556, // zero + 49: 556, // one + 50: 556, // two + 51: 556, // three + 52: 556, // four + 53: 556, // five + 54: 556, // six + 55: 556, // seven + 56: 556, // eight + 57: 556, // nine + 58: 278, // colon + 59: 278, // semicolon + 60: 584, // less + 61: 584, // equal + 62: 584, // greater + 63: 556, // question + 64: 1015, // at + 65: 667, // A + 66: 667, // B + 67: 722, // C + 68: 722, // D + 69: 667, // E + 70: 611, // F + 71: 778, // G + 72: 722, // H + 73: 278, // I + 74: 500, // J + 75: 667, // K + 76: 556, // L + 77: 833, // M + 78: 722, // N + 79: 778, // O + 80: 667, // P + 81: 778, // Q + 82: 722, // R + 83: 667, // S + 84: 611, // T + 85: 722, // U + 86: 667, // V + 87: 944, // W + 88: 667, // X + 89: 667, // Y + 90: 611, // Z + 91: 278, // bracketleft + 92: 278, // backslash + 93: 278, // bracketright + 94: 469, // asciicircum + 95: 556, // underscore + 96: 222, // quoteleft + 97: 556, // a + 98: 556, // b + 99: 500, // c + 100: 556, // d + 101: 556, // e + 102: 278, // f + 103: 556, // g + 104: 556, // h + 105: 222, // i + 106: 222, // j + 107: 500, // k + 108: 222, // l + 109: 833, // m + 110: 556, // n + 111: 556, // o + 112: 556, // p + 113: 556, // q + 114: 333, // r + 115: 500, // s + 116: 278, // t + 117: 556, // u + 118: 500, // v + 119: 722, // w + 120: 500, // x + 121: 500, // y + 122: 500, // z + 123: 334, // braceleft + 124: 260, // bar + 125: 334, // braceright + 126: 584, // asciitilde +} + +// Symbol +var symbolWidths = []uint16{ + 32: 250, // space + 33: 333, // exclam + 34: 713, // universal + 35: 500, // numbersign + 36: 549, // existential + 37: 833, // percent + 38: 778, // ampersand + 39: 439, // suchthat + 40: 333, // parenleft + 41: 333, // parenright + 42: 500, // asteriskmath + 43: 549, // plus + 44: 250, // comma + 45: 549, // minus + 46: 250, // period + 47: 278, // slash + 48: 500, // zero + 49: 500, // one + 50: 500, // two + 51: 500, // three + 52: 500, // four + 53: 500, // five + 54: 500, // six + 55: 500, // seven + 56: 500, // eight + 57: 500, // nine + 58: 278, // colon + 59: 278, // semicolon + 60: 549, // less + 61: 549, // equal + 62: 549, // greater + 63: 444, // question + 64: 549, // congruent + 65: 722, // Alpha + 66: 667, // Beta + 67: 722, // Chi + 68: 612, // Delta + 69: 611, // Epsilon + 70: 763, // Phi + 71: 603, // Gamma + 72: 722, // Eta + 73: 333, // Iota + 74: 631, // theta + 75: 722, // Kappa + 76: 686, // Lambda + 77: 889, // Mu + 78: 722, // Nu + 79: 722, // Omicron + 80: 768, // Pi + 81: 741, // Theta + 82: 556, // Rho + 83: 592, // Sigma + 84: 611, // Tau + 85: 690, // Upsilon + 86: 439, // sigma + 87: 768, // Omega + 88: 645, // Xi + 89: 795, // Psi + 90: 611, // Zeta + 91: 333, // bracketleft + 92: 863, // therefore + 93: 333, // bracketright + 94: 658, // perpendicular + 95: 500, // underscore + 96: 500, // radicalex + 97: 631, // alpha + 98: 549, // beta + 99: 549, // chi + 100: 494, // delta + 101: 439, // epsilon + 102: 521, // phi + 103: 411, // gamma + 104: 603, // eta + 105: 329, // iota + 106: 603, // phi + 107: 549, // kappa + 108: 549, // lambda + 109: 576, // mu + 110: 521, // nu + 111: 549, // omicron + 112: 549, // pi + 113: 521, // theta + 114: 549, // rho + 115: 603, // sigma + 116: 439, // tau + 117: 576, // upsilon + 118: 713, // omega + 119: 686, // omega + 120: 493, // xi + 121: 686, // psi + 122: 494, // zeta + 123: 480, // braceleft + 124: 200, // bar + 125: 480, // braceright + 126: 549, // similar +} + +// Times-Bold +var timesBoldWidths = []uint16{ + 32: 250, // space + 33: 333, // exclam + 34: 555, // quotedbl + 35: 500, // numbersign + 36: 500, // dollar + 37: 1000, // percent + 38: 833, // ampersand + 39: 333, // quoteright + 40: 333, // parenleft + 41: 333, // parenright + 42: 500, // asterisk + 43: 570, // plus + 44: 250, // comma + 45: 333, // hyphen + 46: 250, // period + 47: 278, // slash + 48: 500, // zero + 49: 500, // one + 50: 500, // two + 51: 500, // three + 52: 500, // four + 53: 500, // five + 54: 500, // six + 55: 500, // seven + 56: 500, // eight + 57: 500, // nine + 58: 333, // colon + 59: 333, // semicolon + 60: 570, // less + 61: 570, // equal + 62: 570, // greater + 63: 500, // question + 64: 930, // at + 65: 722, // A + 66: 667, // B + 67: 722, // C + 68: 722, // D + 69: 667, // E + 70: 611, // F + 71: 778, // G + 72: 778, // H + 73: 389, // I + 74: 500, // J + 75: 778, // K + 76: 667, // L + 77: 944, // M + 78: 722, // N + 79: 778, // O + 80: 611, // P + 81: 778, // Q + 82: 722, // R + 83: 556, // S + 84: 667, // T + 85: 722, // U + 86: 722, // V + 87: 1000, // W + 88: 722, // X + 89: 722, // Y + 90: 667, // Z + 91: 333, // bracketleft + 92: 278, // backslash + 93: 333, // bracketright + 94: 581, // asciicircum + 95: 500, // underscore + 96: 333, // quoteleft + 97: 500, // a + 98: 556, // b + 99: 444, // c + 100: 556, // d + 101: 444, // e + 102: 333, // f + 103: 500, // g + 104: 556, // h + 105: 278, // i + 106: 333, // j + 107: 556, // k + 108: 278, // l + 109: 833, // m + 110: 556, // n + 111: 500, // o + 112: 556, // p + 113: 556, // q + 114: 444, // r + 115: 389, // s + 116: 333, // t + 117: 556, // u + 118: 500, // v + 119: 722, // w + 120: 500, // x + 121: 500, // y + 122: 444, // z + 123: 394, // braceleft + 124: 220, // bar + 125: 394, // braceright + 126: 520, // asciitilde +} + +// Times-BoldItalic +var timesBoldItalicWidths = []uint16{ + 32: 250, // space + 33: 389, // exclam + 34: 555, // quotedbl + 35: 500, // numbersign + 36: 500, // dollar + 37: 833, // percent + 38: 778, // ampersand + 39: 333, // quoteright + 40: 333, // parenleft + 41: 333, // parenright + 42: 500, // asterisk + 43: 570, // plus + 44: 250, // comma + 45: 333, // hyphen + 46: 250, // period + 47: 278, // slash + 48: 500, // zero + 49: 500, // one + 50: 500, // two + 51: 500, // three + 52: 500, // four + 53: 500, // five + 54: 500, // six + 55: 500, // seven + 56: 500, // eight + 57: 500, // nine + 58: 333, // colon + 59: 333, // semicolon + 60: 570, // less + 61: 570, // equal + 62: 570, // greater + 63: 500, // question + 64: 832, // at + 65: 667, // A + 66: 667, // B + 67: 667, // C + 68: 722, // D + 69: 667, // E + 70: 667, // F + 71: 722, // G + 72: 778, // H + 73: 389, // I + 74: 500, // J + 75: 667, // K + 76: 611, // L + 77: 889, // M + 78: 722, // N + 79: 722, // O + 80: 611, // P + 81: 722, // Q + 82: 667, // R + 83: 556, // S + 84: 611, // T + 85: 722, // U + 86: 667, // V + 87: 889, // W + 88: 667, // X + 89: 611, // Y + 90: 611, // Z + 91: 333, // bracketleft + 92: 278, // backslash + 93: 333, // bracketright + 94: 570, // asciicircum + 95: 500, // underscore + 96: 333, // quoteleft + 97: 500, // a + 98: 500, // b + 99: 444, // c + 100: 500, // d + 101: 444, // e + 102: 333, // f + 103: 500, // g + 104: 556, // h + 105: 278, // i + 106: 278, // j + 107: 500, // k + 108: 278, // l + 109: 778, // m + 110: 556, // n + 111: 500, // o + 112: 500, // p + 113: 500, // q + 114: 389, // r + 115: 389, // s + 116: 278, // t + 117: 556, // u + 118: 444, // v + 119: 667, // w + 120: 500, // x + 121: 444, // y + 122: 389, // z + 123: 348, // braceleft + 124: 220, // bar + 125: 348, // braceright + 126: 570, // asciitilde +} + +// Times-Italic +var timesItalicWidths = []uint16{ + 32: 250, // space + 33: 333, // exclam + 34: 420, // quotedbl + 35: 500, // numbersign + 36: 500, // dollar + 37: 833, // percent + 38: 778, // ampersand + 39: 333, // quoteright + 40: 333, // parenleft + 41: 333, // parenright + 42: 500, // asterisk + 43: 675, // plus + 44: 250, // comma + 45: 333, // hyphen + 46: 250, // period + 47: 278, // slash + 48: 500, // zero + 49: 500, // one + 50: 500, // two + 51: 500, // three + 52: 500, // four + 53: 500, // five + 54: 500, // six + 55: 500, // seven + 56: 500, // eight + 57: 500, // nine + 58: 333, // colon + 59: 333, // semicolon + 60: 675, // less + 61: 675, // equal + 62: 675, // greater + 63: 500, // question + 64: 920, // at + 65: 611, // A + 66: 611, // B + 67: 667, // C + 68: 722, // D + 69: 611, // E + 70: 611, // F + 71: 722, // G + 72: 722, // H + 73: 333, // I + 74: 444, // J + 75: 667, // K + 76: 556, // L + 77: 833, // M + 78: 667, // N + 79: 722, // O + 80: 611, // P + 81: 722, // Q + 82: 611, // R + 83: 500, // S + 84: 556, // T + 85: 722, // U + 86: 611, // V + 87: 833, // W + 88: 611, // X + 89: 556, // Y + 90: 556, // Z + 91: 389, // bracketleft + 92: 278, // backslash + 93: 389, // bracketright + 94: 422, // asciicircum + 95: 500, // underscore + 96: 333, // quoteleft + 97: 500, // a + 98: 500, // b + 99: 444, // c + 100: 500, // d + 101: 444, // e + 102: 278, // f + 103: 500, // g + 104: 500, // h + 105: 278, // i + 106: 278, // j + 107: 444, // k + 108: 278, // l + 109: 722, // m + 110: 500, // n + 111: 500, // o + 112: 500, // p + 113: 500, // q + 114: 389, // r + 115: 389, // s + 116: 278, // t + 117: 500, // u + 118: 444, // v + 119: 667, // w + 120: 444, // x + 121: 444, // y + 122: 389, // z + 123: 400, // braceleft + 124: 275, // bar + 125: 400, // braceright + 126: 541, // asciitilde +} + +// Times-Roman +var timesRomanWidths = []uint16{ + 32: 250, // space + 33: 333, // exclam + 34: 408, // quotedbl + 35: 500, // numbersign + 36: 500, // dollar + 37: 833, // percent + 38: 778, // ampersand + 39: 333, // quoteright + 40: 333, // parenleft + 41: 333, // parenright + 42: 500, // asterisk + 43: 564, // plus + 44: 250, // comma + 45: 333, // hyphen + 46: 250, // period + 47: 278, // slash + 48: 500, // zero + 49: 500, // one + 50: 500, // two + 51: 500, // three + 52: 500, // four + 53: 500, // five + 54: 500, // six + 55: 500, // seven + 56: 500, // eight + 57: 500, // nine + 58: 278, // colon + 59: 278, // semicolon + 60: 564, // less + 61: 564, // equal + 62: 564, // greater + 63: 444, // question + 64: 921, // at + 65: 722, // A + 66: 667, // B + 67: 667, // C + 68: 722, // D + 69: 611, // E + 70: 556, // F + 71: 722, // G + 72: 722, // H + 73: 333, // I + 74: 389, // J + 75: 722, // K + 76: 611, // L + 77: 889, // M + 78: 722, // N + 79: 722, // O + 80: 556, // P + 81: 722, // Q + 82: 667, // R + 83: 556, // S + 84: 611, // T + 85: 722, // U + 86: 722, // V + 87: 944, // W + 88: 722, // X + 89: 722, // Y + 90: 611, // Z + 91: 333, // bracketleft + 92: 278, // backslash + 93: 333, // bracketright + 94: 469, // asciicircum + 95: 500, // underscore + 96: 333, // quoteleft + 97: 444, // a + 98: 500, // b + 99: 444, // c + 100: 500, // d + 101: 444, // e + 102: 333, // f + 103: 500, // g + 104: 500, // h + 105: 278, // i + 106: 278, // j + 107: 500, // k + 108: 278, // l + 109: 778, // m + 110: 500, // n + 111: 500, // o + 112: 500, // p + 113: 500, // q + 114: 333, // r + 115: 389, // s + 116: 278, // t + 117: 500, // u + 118: 500, // v + 119: 722, // w + 120: 500, // x + 121: 500, // y + 122: 444, // z + 123: 480, // braceleft + 124: 200, // bar + 125: 480, // braceright + 126: 541, // asciitilde +} + +// ZapfDingbats +var zapfDingbatsWidths = []uint16{ + 32: 278, // space + 33: 974, // a + 34: 961, // a + 35: 974, // a + 36: 980, // a + 37: 719, // a + 38: 789, // a + 39: 790, // a + 40: 791, // a + 41: 690, // a + 42: 960, // a + 43: 939, // a + 44: 549, // a + 45: 855, // a + 46: 911, // a + 47: 933, // a + 48: 911, // a + 49: 945, // a + 50: 974, // a + 51: 755, // a + 52: 846, // a + 53: 762, // a + 54: 761, // a + 55: 571, // a + 56: 677, // a + 57: 763, // a + 58: 760, // a + 59: 759, // a + 60: 754, // a + 61: 494, // a + 62: 552, // a + 63: 537, // a + 64: 577, // a + 65: 692, // a + 66: 786, // a + 67: 788, // a + 68: 788, // a + 69: 790, // a + 70: 793, // a + 71: 794, // a + 72: 816, // a + 73: 823, // a + 74: 789, // a + 75: 841, // a + 76: 823, // a + 77: 833, // a + 78: 816, // a + 79: 831, // a + 80: 923, // a + 81: 744, // a + 82: 723, // a + 83: 749, // a + 84: 790, // a + 85: 792, // a + 86: 695, // a + 87: 776, // a + 88: 768, // a + 89: 792, // a + 90: 759, // a + 91: 707, // a + 92: 708, // a + 93: 682, // a + 94: 701, // a + 95: 826, // a + 96: 815, // a + 97: 789, // a + 98: 789, // a + 99: 707, // a + 100: 687, // a + 101: 696, // a + 102: 689, // a + 103: 786, // a + 104: 787, // a + 105: 713, // a + 106: 791, // a + 107: 785, // a + 108: 791, // a + 109: 873, // a + 110: 761, // a + 111: 762, // a + 112: 762, // a + 113: 759, // a + 114: 759, // a + 115: 892, // a + 116: 892, // a + 117: 788, // a + 118: 784, // a + 119: 438, // a + 120: 138, // a + 121: 277, // a + 122: 415, // a + 123: 392, // a + 124: 392, // a + 125: 668, // a + 126: 668, // a + 128: 390, // a + 129: 390, // a +} diff --git a/vendor/bitbucket.org/zombiezen/gopdf/pdf/objects.go b/vendor/bitbucket.org/zombiezen/gopdf/pdf/objects.go new file mode 100644 index 00000000..b1742592 --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/pdf/objects.go @@ -0,0 +1,55 @@ +// Copyright (C) 2011, Ross Light + +package pdf + +import ( + "fmt" + "strconv" +) + +// name is a PDF name object, which is used as an identifier. +type name string + +func (n name) String() string { + return string(n) +} + +func (n name) marshalPDF(dst []byte) ([]byte, error) { + // TODO: escape characters + dst = append(dst, '/') + return append(dst, []byte(n)...), nil +} + +type indirectObject struct { + Reference + Object interface{} +} + +const ( + objectBegin = " obj\r\n" + objectEnd = "\r\nendobj" +) + +func (obj indirectObject) marshalPDF(dst []byte) ([]byte, error) { + var err error + mn, mg := strconv.FormatUint(uint64(obj.Number), 10), strconv.FormatUint(uint64(obj.Generation), 10) + dst = append(dst, mn...) + dst = append(dst, ' ') + dst = append(dst, mg...) + dst = append(dst, objectBegin...) + if dst, err = marshal(dst, obj.Object); err != nil { + return nil, err + } + dst = append(dst, objectEnd...) + return dst, nil +} + +// Reference holds a PDF indirect reference. +type Reference struct { + Number uint + Generation uint +} + +func (ref Reference) marshalPDF(dst []byte) ([]byte, error) { + return append(dst, fmt.Sprintf("%d %d R", ref.Number, ref.Generation)...), nil +} diff --git a/vendor/bitbucket.org/zombiezen/gopdf/pdf/pdf.go b/vendor/bitbucket.org/zombiezen/gopdf/pdf/pdf.go new file mode 100644 index 00000000..837a680e --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/pdf/pdf.go @@ -0,0 +1,230 @@ +// Copyright (C) 2011, Ross Light + +package pdf + +import ( + "image" + "io" + "strconv" +) + +// Unit is a device-independent dimensional type. On a new canvas, this +// represents 1/72 of an inch. +type Unit float32 + +func (unit Unit) String() string { + return strconv.FormatFloat(float64(unit), 'f', marshalFloatPrec, 32) +} + +// Common unit scales +const ( + Pt Unit = 1 + Inch Unit = 72 + Cm Unit = 28.35 +) + +// Common page sizes +const ( + USLetterWidth Unit = 8.5 * Inch + USLetterHeight Unit = 11.0 * Inch + + A4Width Unit = 21.0 * Cm + A4Height Unit = 29.7 * Cm +) + +// Document provides a high-level drawing interface for the PDF format. +type Document struct { + encoder + catalog *catalog + pages []indirectObject + fonts map[name]Reference +} + +// New creates a new document with no pages. +func New() *Document { + doc := new(Document) + doc.catalog = &catalog{ + Type: catalogType, + } + doc.root = doc.add(doc.catalog) + doc.fonts = make(map[name]Reference, 14) + return doc +} + +// NewPage creates a new canvas with the given dimensions. +func (doc *Document) NewPage(width, height Unit) *Canvas { + page := &pageDict{ + Type: pageType, + MediaBox: Rectangle{Point{0, 0}, Point{width, height}}, + CropBox: Rectangle{Point{0, 0}, Point{width, height}}, + Resources: resources{ + ProcSet: []name{pdfProcSet, textProcSet, imageCProcSet}, + Font: make(map[name]interface{}), + XObject: make(map[name]interface{}), + }, + } + pageRef := doc.add(page) + doc.pages = append(doc.pages, indirectObject{pageRef, page}) + + stream := newStream(streamFlateDecode) + page.Contents = doc.add(stream) + + return &Canvas{ + doc: doc, + page: page, + ref: pageRef, + contents: stream, + } +} + +// standardFont returns a reference to a standard font dictionary. If there is +// no font dictionary for the font in the document yet, it is added +// automatically. +func (doc *Document) standardFont(fontName name) Reference { + if ref, ok := doc.fonts[fontName]; ok { + return ref + } + + // TODO: check name is standard? + ref := doc.add(standardFontDict{ + Type: fontType, + Subtype: fontType1Subtype, + BaseFont: fontName, + }) + doc.fonts[fontName] = ref + return ref +} + +// AddImage encodes an image into the document's stream and returns its PDF +// file reference. This reference can be used to draw the image multiple times +// without storing the image multiple times. +func (doc *Document) AddImage(img image.Image) Reference { + bd := img.Bounds() + st := newImageStream(streamFlateDecode, bd.Dx(), bd.Dy()) + defer st.Close() + + switch i := img.(type) { + case *image.RGBA: + encodeRGBAStream(st, i) + case *image.NRGBA: + encodeNRGBAStream(st, i) + case *image.YCbCr: + encodeYCbCrStream(st, i) + default: + encodeImageStream(st, i) + } + return doc.add(st) +} + +// Encode writes the document to a writer in the PDF format. +func (doc *Document) Encode(w io.Writer) error { + pageRoot := &pageRootNode{ + Type: pageNodeType, + Count: len(doc.pages), + } + doc.catalog.Pages = doc.add(pageRoot) + for _, p := range doc.pages { + page := p.Object.(*pageDict) + page.Parent = doc.catalog.Pages + pageRoot.Kids = append(pageRoot.Kids, p.Reference) + } + + return doc.encoder.encode(w) +} + +// PDF object types +const ( + catalogType name = "Catalog" + pageNodeType name = "Pages" + pageType name = "Page" + fontType name = "Font" + xobjectType name = "XObject" +) + +// PDF object subtypes +const ( + imageSubtype name = "Image" + + fontType1Subtype name = "Type1" +) + +type catalog struct { + Type name + Pages Reference +} + +type pageRootNode struct { + Type name + Kids []Reference + Count int +} + +type pageNode struct { + Type name + Parent Reference + Kids []Reference + Count int +} + +type pageDict struct { + Type name + Parent Reference + Resources resources + MediaBox Rectangle + CropBox Rectangle + Contents Reference +} + +// Point is a 2D point. +type Point struct { + X, Y Unit +} + +// A Rectangle defines a rectangle with two points. +type Rectangle struct { + Min, Max Point +} + +// Dx returns the rectangle's width. +func (r Rectangle) Dx() Unit { + return r.Max.X - r.Min.X +} + +// Dy returns the rectangle's height. +func (r Rectangle) Dy() Unit { + return r.Max.Y - r.Min.Y +} + +func (r Rectangle) marshalPDF(dst []byte) ([]byte, error) { + dst = append(dst, '[', ' ') + dst, _ = marshal(dst, r.Min.X) + dst = append(dst, ' ') + dst, _ = marshal(dst, r.Min.Y) + dst = append(dst, ' ') + dst, _ = marshal(dst, r.Max.X) + dst = append(dst, ' ') + dst, _ = marshal(dst, r.Max.Y) + dst = append(dst, ' ', ']') + return dst, nil +} + +type resources struct { + ProcSet []name + Font map[name]interface{} + XObject map[name]interface{} +} + +// Predefined procedure sets +const ( + pdfProcSet name = "PDF" + textProcSet name = "Text" + imageBProcSet name = "ImageB" + imageCProcSet name = "ImageC" + imageIProcSet name = "ImageI" +) + +type standardFontDict struct { + Type name + Subtype name + BaseFont name +} diff --git a/vendor/bitbucket.org/zombiezen/gopdf/pdf/stream.go b/vendor/bitbucket.org/zombiezen/gopdf/pdf/stream.go new file mode 100644 index 00000000..40f63853 --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/pdf/stream.go @@ -0,0 +1,91 @@ +package pdf + +import ( + "bytes" + "compress/lzw" + "compress/zlib" + "io" +) + +const ( + streamNoFilter name = "" + streamLZWDecode name = "LZWDecode" + streamFlateDecode name = "FlateDecode" +) + +// stream is a blob of data stored in a PDF file. +type stream struct { + bytes.Buffer + writer io.Writer + filter name +} + +type streamInfo struct { + Length int + Filter name `pdf:",omitempty"` +} + +func newStream(filter name) *stream { + st := new(stream) + st.filter = filter + switch filter { + case streamLZWDecode: + st.writer = lzw.NewWriter(&st.Buffer, lzw.MSB, 8) + case streamFlateDecode: + st.writer = zlib.NewWriter(&st.Buffer) + default: + // TODO: warn about bad filter names? + st.writer = &st.Buffer + } + return st +} + +func (st *stream) ReadFrom(r io.Reader) (n int64, err error) { + return io.Copy(st.writer, r) +} + +func (st *stream) Write(p []byte) (n int, err error) { + return st.writer.Write(p) +} + +func (st *stream) WriteByte(c byte) error { + _, err := st.writer.Write([]byte{c}) + return err +} + +func (st *stream) WriteString(s string) (n int, err error) { + return io.WriteString(st.writer, s) +} + +func (st *stream) Close() error { + if wc, ok := st.writer.(io.WriteCloser); ok { + return wc.Close() + } + return nil +} + +func (st *stream) marshalPDF(dst []byte) ([]byte, error) { + return marshalStream(dst, streamInfo{ + Length: st.Len(), + Filter: st.filter, + }, st.Bytes()) +} + +const ( + streamBegin = " stream\r\n" + streamEnd = "\r\nendstream" +) + +// marshalStream encodes a generic stream. The resulting data encodes the +// given object and a sequence of bytes. This function does not enforce any +// rules about the object being encoded. +func marshalStream(dst []byte, obj interface{}, data []byte) ([]byte, error) { + var err error + if dst, err = marshal(dst, obj); err != nil { + return nil, err + } + dst = append(dst, streamBegin...) + dst = append(dst, data...) + dst = append(dst, streamEnd...) + return dst, nil +} diff --git a/vendor/bitbucket.org/zombiezen/gopdf/pdf/text.go b/vendor/bitbucket.org/zombiezen/gopdf/pdf/text.go new file mode 100644 index 00000000..73b2d084 --- /dev/null +++ b/vendor/bitbucket.org/zombiezen/gopdf/pdf/text.go @@ -0,0 +1,138 @@ +// Copyright (C) 2011, Ross Light + +package pdf + +import ( + "bytes" +) + +// Text is a PDF text object. The zero value is an empty text object. +type Text struct { + buf bytes.Buffer + fonts map[name]bool + + x, y Unit + currFont name + currSize Unit + currLeading Unit +} + +// Text adds a string to the text object. +func (text *Text) Text(s string) { + writeCommand(&text.buf, "Tj", s) + if widths := getFontWidths(text.currFont); widths != nil { + text.x += computeStringWidth(s, widths, text.currSize) + } +} + +const defaultLeadingScalar = 1.2 + +// SetFont changes the current font to a standard font. This also changes the +// leading to 1.2 times the font size. +func (text *Text) SetFont(fontName string, size Unit) { + if text.fonts == nil { + text.fonts = make(map[name]bool) + } + text.fonts[name(fontName)] = true + text.currFont, text.currSize = name(fontName), size + writeCommand(&text.buf, "Tf", name(fontName), size) + text.SetLeading(size * defaultLeadingScalar) +} + +// SetLeading changes the amount of space between lines. +func (text *Text) SetLeading(leading Unit) { + writeCommand(&text.buf, "TL", leading) + text.currLeading = leading +} + +// NextLine advances the current text position to the next line, based on the +// current leading. +func (text *Text) NextLine() { + writeCommand(&text.buf, "T*") + text.x = 0 + text.y -= text.currLeading +} + +// NextLineOffset moves the current text position to an offset relative to the +// beginning of the line. +func (text *Text) NextLineOffset(tx, ty Unit) { + writeCommand(&text.buf, "Td", tx, ty) + text.x = tx + text.y += ty +} + +// X returns the current x position of the text cursor. +func (text *Text) X() Unit { + return text.x +} + +// Y returns the current y position of the text cursor. +func (text *Text) Y() Unit { + return text.y +} + +// Standard 14 fonts +const ( + Courier = "Courier" + CourierBold = "Courier-Bold" + CourierOblique = "Courier-Oblique" + CourierBoldOblique = "Courier-BoldOblique" + + Helvetica = "Helvetica" + HelveticaBold = "Helvetica-Bold" + HelveticaOblique = "Helvetica-Oblique" + HelveticaBoldOblique = "Helvetica-BoldOblique" + + Symbol = "Symbol" + + Times = "Times-Roman" + TimesBold = "Times-Bold" + TimesItalic = "Times-Italic" + TimesBoldItalic = "Times-BoldItalic" + + ZapfDingbats = "ZapfDingbats" +) + +func getFontWidths(fontName name) []uint16 { + switch fontName { + case Courier: + return courierWidths + case CourierBold: + return courierBoldWidths + case CourierOblique: + return courierObliqueWidths + case CourierBoldOblique: + return courierBoldObliqueWidths + case Helvetica: + return helveticaWidths + case HelveticaBold: + return helveticaBoldWidths + case HelveticaOblique: + return helveticaObliqueWidths + case HelveticaBoldOblique: + return helveticaBoldObliqueWidths + case Symbol: + return symbolWidths + case Times: + return timesRomanWidths + case TimesBold: + return timesBoldWidths + case TimesItalic: + return timesItalicWidths + case TimesBoldItalic: + return timesBoldItalicWidths + case ZapfDingbats: + return zapfDingbatsWidths + } + return nil +} + +func computeStringWidth(s string, widths []uint16, fontSize Unit) Unit { + width := Unit(0) + for _, r := range s { + if int(r) < len(widths) { + width += Unit(widths[r]) + } + } + return width * fontSize / 1000 +} diff --git a/vendor/cloud.google.com/go/LICENSE b/vendor/cloud.google.com/go/LICENSE new file mode 100644 index 00000000..a4c5efd8 --- /dev/null +++ b/vendor/cloud.google.com/go/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2014 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/cloud.google.com/go/cloud.go b/vendor/cloud.google.com/go/cloud.go new file mode 100644 index 00000000..52524b23 --- /dev/null +++ b/vendor/cloud.google.com/go/cloud.go @@ -0,0 +1,18 @@ +// Copyright 2014 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package cloud is the root of the packages used to access Google Cloud +// Services. See https://godoc.org/cloud.google.com/go for a full list +// of sub-packages. +package cloud // import "cloud.google.com/go" diff --git a/vendor/cloud.google.com/go/compute/metadata/metadata.go b/vendor/cloud.google.com/go/compute/metadata/metadata.go new file mode 100644 index 00000000..b5d6091e --- /dev/null +++ b/vendor/cloud.google.com/go/compute/metadata/metadata.go @@ -0,0 +1,438 @@ +// Copyright 2014 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package metadata provides access to Google Compute Engine (GCE) +// metadata and API service accounts. +// +// This package is a wrapper around the GCE metadata service, +// as documented at https://developers.google.com/compute/docs/metadata. +package metadata // import "cloud.google.com/go/compute/metadata" + +import ( + "encoding/json" + "fmt" + "io/ioutil" + "net" + "net/http" + "net/url" + "os" + "runtime" + "strings" + "sync" + "time" + + "golang.org/x/net/context" + "golang.org/x/net/context/ctxhttp" + + "cloud.google.com/go/internal" +) + +const ( + // metadataIP is the documented metadata server IP address. + metadataIP = "169.254.169.254" + + // metadataHostEnv is the environment variable specifying the + // GCE metadata hostname. If empty, the default value of + // metadataIP ("169.254.169.254") is used instead. + // This is variable name is not defined by any spec, as far as + // I know; it was made up for the Go package. + metadataHostEnv = "GCE_METADATA_HOST" +) + +type cachedValue struct { + k string + trim bool + mu sync.Mutex + v string +} + +var ( + projID = &cachedValue{k: "project/project-id", trim: true} + projNum = &cachedValue{k: "project/numeric-project-id", trim: true} + instID = &cachedValue{k: "instance/id", trim: true} +) + +var ( + metaClient = &http.Client{ + Transport: &internal.Transport{ + Base: &http.Transport{ + Dial: (&net.Dialer{ + Timeout: 2 * time.Second, + KeepAlive: 30 * time.Second, + }).Dial, + ResponseHeaderTimeout: 2 * time.Second, + }, + }, + } + subscribeClient = &http.Client{ + Transport: &internal.Transport{ + Base: &http.Transport{ + Dial: (&net.Dialer{ + Timeout: 2 * time.Second, + KeepAlive: 30 * time.Second, + }).Dial, + }, + }, + } +) + +// NotDefinedError is returned when requested metadata is not defined. +// +// The underlying string is the suffix after "/computeMetadata/v1/". +// +// This error is not returned if the value is defined to be the empty +// string. +type NotDefinedError string + +func (suffix NotDefinedError) Error() string { + return fmt.Sprintf("metadata: GCE metadata %q not defined", string(suffix)) +} + +// Get returns a value from the metadata service. +// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/". +// +// If the GCE_METADATA_HOST environment variable is not defined, a default of +// 169.254.169.254 will be used instead. +// +// If the requested metadata is not defined, the returned error will +// be of type NotDefinedError. +func Get(suffix string) (string, error) { + val, _, err := getETag(metaClient, suffix) + return val, err +} + +// getETag returns a value from the metadata service as well as the associated +// ETag using the provided client. This func is otherwise equivalent to Get. +func getETag(client *http.Client, suffix string) (value, etag string, err error) { + // Using a fixed IP makes it very difficult to spoof the metadata service in + // a container, which is an important use-case for local testing of cloud + // deployments. To enable spoofing of the metadata service, the environment + // variable GCE_METADATA_HOST is first inspected to decide where metadata + // requests shall go. + host := os.Getenv(metadataHostEnv) + if host == "" { + // Using 169.254.169.254 instead of "metadata" here because Go + // binaries built with the "netgo" tag and without cgo won't + // know the search suffix for "metadata" is + // ".google.internal", and this IP address is documented as + // being stable anyway. + host = metadataIP + } + url := "http://" + host + "/computeMetadata/v1/" + suffix + req, _ := http.NewRequest("GET", url, nil) + req.Header.Set("Metadata-Flavor", "Google") + res, err := client.Do(req) + if err != nil { + return "", "", err + } + defer res.Body.Close() + if res.StatusCode == http.StatusNotFound { + return "", "", NotDefinedError(suffix) + } + if res.StatusCode != 200 { + return "", "", fmt.Errorf("status code %d trying to fetch %s", res.StatusCode, url) + } + all, err := ioutil.ReadAll(res.Body) + if err != nil { + return "", "", err + } + return string(all), res.Header.Get("Etag"), nil +} + +func getTrimmed(suffix string) (s string, err error) { + s, err = Get(suffix) + s = strings.TrimSpace(s) + return +} + +func (c *cachedValue) get() (v string, err error) { + defer c.mu.Unlock() + c.mu.Lock() + if c.v != "" { + return c.v, nil + } + if c.trim { + v, err = getTrimmed(c.k) + } else { + v, err = Get(c.k) + } + if err == nil { + c.v = v + } + return +} + +var ( + onGCEOnce sync.Once + onGCE bool +) + +// OnGCE reports whether this process is running on Google Compute Engine. +func OnGCE() bool { + onGCEOnce.Do(initOnGCE) + return onGCE +} + +func initOnGCE() { + onGCE = testOnGCE() +} + +func testOnGCE() bool { + // The user explicitly said they're on GCE, so trust them. + if os.Getenv(metadataHostEnv) != "" { + return true + } + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + resc := make(chan bool, 2) + + // Try two strategies in parallel. + // See https://github.com/GoogleCloudPlatform/gcloud-golang/issues/194 + go func() { + res, err := ctxhttp.Get(ctx, metaClient, "http://"+metadataIP) + if err != nil { + resc <- false + return + } + defer res.Body.Close() + resc <- res.Header.Get("Metadata-Flavor") == "Google" + }() + + go func() { + addrs, err := net.LookupHost("metadata.google.internal") + if err != nil || len(addrs) == 0 { + resc <- false + return + } + resc <- strsContains(addrs, metadataIP) + }() + + tryHarder := systemInfoSuggestsGCE() + if tryHarder { + res := <-resc + if res { + // The first strategy succeeded, so let's use it. + return true + } + // Wait for either the DNS or metadata server probe to + // contradict the other one and say we are running on + // GCE. Give it a lot of time to do so, since the system + // info already suggests we're running on a GCE BIOS. + timer := time.NewTimer(5 * time.Second) + defer timer.Stop() + select { + case res = <-resc: + return res + case <-timer.C: + // Too slow. Who knows what this system is. + return false + } + } + + // There's no hint from the system info that we're running on + // GCE, so use the first probe's result as truth, whether it's + // true or false. The goal here is to optimize for speed for + // users who are NOT running on GCE. We can't assume that + // either a DNS lookup or an HTTP request to a blackholed IP + // address is fast. Worst case this should return when the + // metaClient's Transport.ResponseHeaderTimeout or + // Transport.Dial.Timeout fires (in two seconds). + return <-resc +} + +// systemInfoSuggestsGCE reports whether the local system (without +// doing network requests) suggests that we're running on GCE. If this +// returns true, testOnGCE tries a bit harder to reach its metadata +// server. +func systemInfoSuggestsGCE() bool { + if runtime.GOOS != "linux" { + // We don't have any non-Linux clues available, at least yet. + return false + } + slurp, _ := ioutil.ReadFile("/sys/class/dmi/id/product_name") + name := strings.TrimSpace(string(slurp)) + return name == "Google" || name == "Google Compute Engine" +} + +// Subscribe subscribes to a value from the metadata service. +// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/". +// The suffix may contain query parameters. +// +// Subscribe calls fn with the latest metadata value indicated by the provided +// suffix. If the metadata value is deleted, fn is called with the empty string +// and ok false. Subscribe blocks until fn returns a non-nil error or the value +// is deleted. Subscribe returns the error value returned from the last call to +// fn, which may be nil when ok == false. +func Subscribe(suffix string, fn func(v string, ok bool) error) error { + const failedSubscribeSleep = time.Second * 5 + + // First check to see if the metadata value exists at all. + val, lastETag, err := getETag(subscribeClient, suffix) + if err != nil { + return err + } + + if err := fn(val, true); err != nil { + return err + } + + ok := true + if strings.ContainsRune(suffix, '?') { + suffix += "&wait_for_change=true&last_etag=" + } else { + suffix += "?wait_for_change=true&last_etag=" + } + for { + val, etag, err := getETag(subscribeClient, suffix+url.QueryEscape(lastETag)) + if err != nil { + if _, deleted := err.(NotDefinedError); !deleted { + time.Sleep(failedSubscribeSleep) + continue // Retry on other errors. + } + ok = false + } + lastETag = etag + + if err := fn(val, ok); err != nil || !ok { + return err + } + } +} + +// ProjectID returns the current instance's project ID string. +func ProjectID() (string, error) { return projID.get() } + +// NumericProjectID returns the current instance's numeric project ID. +func NumericProjectID() (string, error) { return projNum.get() } + +// InternalIP returns the instance's primary internal IP address. +func InternalIP() (string, error) { + return getTrimmed("instance/network-interfaces/0/ip") +} + +// ExternalIP returns the instance's primary external (public) IP address. +func ExternalIP() (string, error) { + return getTrimmed("instance/network-interfaces/0/access-configs/0/external-ip") +} + +// Hostname returns the instance's hostname. This will be of the form +// ".c..internal". +func Hostname() (string, error) { + return getTrimmed("instance/hostname") +} + +// InstanceTags returns the list of user-defined instance tags, +// assigned when initially creating a GCE instance. +func InstanceTags() ([]string, error) { + var s []string + j, err := Get("instance/tags") + if err != nil { + return nil, err + } + if err := json.NewDecoder(strings.NewReader(j)).Decode(&s); err != nil { + return nil, err + } + return s, nil +} + +// InstanceID returns the current VM's numeric instance ID. +func InstanceID() (string, error) { + return instID.get() +} + +// InstanceName returns the current VM's instance ID string. +func InstanceName() (string, error) { + host, err := Hostname() + if err != nil { + return "", err + } + return strings.Split(host, ".")[0], nil +} + +// Zone returns the current VM's zone, such as "us-central1-b". +func Zone() (string, error) { + zone, err := getTrimmed("instance/zone") + // zone is of the form "projects//zones/". + if err != nil { + return "", err + } + return zone[strings.LastIndex(zone, "/")+1:], nil +} + +// InstanceAttributes returns the list of user-defined attributes, +// assigned when initially creating a GCE VM instance. The value of an +// attribute can be obtained with InstanceAttributeValue. +func InstanceAttributes() ([]string, error) { return lines("instance/attributes/") } + +// ProjectAttributes returns the list of user-defined attributes +// applying to the project as a whole, not just this VM. The value of +// an attribute can be obtained with ProjectAttributeValue. +func ProjectAttributes() ([]string, error) { return lines("project/attributes/") } + +func lines(suffix string) ([]string, error) { + j, err := Get(suffix) + if err != nil { + return nil, err + } + s := strings.Split(strings.TrimSpace(j), "\n") + for i := range s { + s[i] = strings.TrimSpace(s[i]) + } + return s, nil +} + +// InstanceAttributeValue returns the value of the provided VM +// instance attribute. +// +// If the requested attribute is not defined, the returned error will +// be of type NotDefinedError. +// +// InstanceAttributeValue may return ("", nil) if the attribute was +// defined to be the empty string. +func InstanceAttributeValue(attr string) (string, error) { + return Get("instance/attributes/" + attr) +} + +// ProjectAttributeValue returns the value of the provided +// project attribute. +// +// If the requested attribute is not defined, the returned error will +// be of type NotDefinedError. +// +// ProjectAttributeValue may return ("", nil) if the attribute was +// defined to be the empty string. +func ProjectAttributeValue(attr string) (string, error) { + return Get("project/attributes/" + attr) +} + +// Scopes returns the service account scopes for the given account. +// The account may be empty or the string "default" to use the instance's +// main account. +func Scopes(serviceAccount string) ([]string, error) { + if serviceAccount == "" { + serviceAccount = "default" + } + return lines("instance/service-accounts/" + serviceAccount + "/scopes") +} + +func strsContains(ss []string, s string) bool { + for _, v := range ss { + if v == s { + return true + } + } + return false +} diff --git a/vendor/cloud.google.com/go/internal/cloud.go b/vendor/cloud.google.com/go/internal/cloud.go new file mode 100644 index 00000000..8e0c8f8e --- /dev/null +++ b/vendor/cloud.google.com/go/internal/cloud.go @@ -0,0 +1,64 @@ +// Copyright 2014 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package internal provides support for the cloud packages. +// +// Users should not import this package directly. +package internal + +import ( + "fmt" + "net/http" +) + +const userAgent = "gcloud-golang/0.1" + +// Transport is an http.RoundTripper that appends Google Cloud client's +// user-agent to the original request's user-agent header. +type Transport struct { + // TODO(bradfitz): delete internal.Transport. It's too wrappy for what it does. + // Do User-Agent some other way. + + // Base is the actual http.RoundTripper + // requests will use. It must not be nil. + Base http.RoundTripper +} + +// RoundTrip appends a user-agent to the existing user-agent +// header and delegates the request to the base http.RoundTripper. +func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) { + req = cloneRequest(req) + ua := req.Header.Get("User-Agent") + if ua == "" { + ua = userAgent + } else { + ua = fmt.Sprintf("%s %s", ua, userAgent) + } + req.Header.Set("User-Agent", ua) + return t.Base.RoundTrip(req) +} + +// cloneRequest returns a clone of the provided *http.Request. +// The clone is a shallow copy of the struct and its Header map. +func cloneRequest(r *http.Request) *http.Request { + // shallow copy of the struct + r2 := new(http.Request) + *r2 = *r + // deep copy of the Header + r2.Header = make(http.Header) + for k, s := range r.Header { + r2.Header[k] = s + } + return r2 +} diff --git a/vendor/github.com/ajstarks/svgo/LICENSE b/vendor/github.com/ajstarks/svgo/LICENSE new file mode 100644 index 00000000..ea5a7726 --- /dev/null +++ b/vendor/github.com/ajstarks/svgo/LICENSE @@ -0,0 +1,3 @@ +The contents of this repository are Licensed under +the Creative Commons Attribution 3.0 license as described in +http://creativecommons.org/licenses/by/3.0/us/ diff --git a/vendor/github.com/ajstarks/svgo/doc.go b/vendor/github.com/ajstarks/svgo/doc.go new file mode 100644 index 00000000..ca5bbf31 --- /dev/null +++ b/vendor/github.com/ajstarks/svgo/doc.go @@ -0,0 +1,126 @@ +/* +Package svg generates SVG as defined by the Scalable Vector Graphics 1.1 Specification (). +Output goes to the specified io.Writer. + +Supported SVG elements and functions + +Shapes, lines, text + + circle, ellipse, polygon, polyline, rect (including roundrects), line, text + +Paths + + general, arc, cubic and quadratic bezier paths, + +Image and Gradients + + image, linearGradient, radialGradient, + +Transforms + + translate, rotate, scale, skewX, skewY + +Filter Effects + + filter, feBlend, feColorMatrix, feColorMatrix, feComponentTransfer, feComposite, feConvolveMatrix, feDiffuseLighting, + feDisplacementMap, feDistantLight, feFlood, feGaussianBlur, feImage, feMerge, feMorphology, feOffset, fePointLight, + feSpecularLighting, feSpotLight,feTile, feTurbulence + + +Metadata elements + + desc, defs, g (style, transform, id), mask, marker, pattern, title, (a)ddress, link, script, use + +Usage: (assuming GOPATH is set) + + go get github.com/ajstarks/svgo + go install github.com/ajstarks/svgo/... + + +You can use godoc to browse the documentation from the command line: + + $ godoc github.com/ajstarks/svgo + + +a minimal program, to generate SVG to standard output. + + package main + + import ( + "github.com/ajstarks/svgo" + "os" + ) + + func main() { + width := 500 + height := 500 + canvas := svg.New(os.Stdout) + canvas.Start(width, height) + canvas.Circle(width/2, height/2, 100) + canvas.Text(width/2, height/2, "Hello, SVG", "text-anchor:middle;font-size:30px;fill:white") + canvas.End() + } + +Drawing in a web server: (http://localhost:2003/circle) + + package main + + import ( + "log" + "github.com/ajstarks/svgo" + "net/http" + ) + + func main() { + http.Handle("/circle", http.HandlerFunc(circle)) + err := http.ListenAndServe(":2003", nil) + if err != nil { + log.Fatal("ListenAndServe:", err) + } + } + + func circle(w http.ResponseWriter, req *http.Request) { + w.Header().Set("Content-Type", "image/svg+xml") + s := svg.New(w) + s.Start(500, 500) + s.Circle(250, 250, 125, "fill:none;stroke:black") + s.End() + } + +Functions and types + +Many functions use x, y to specify an object's location, and w, h to specify the object's width and height. +Where applicable, a final optional argument specifies the style to be applied to the object. +The style strings follow the SVG standard; name:value pairs delimited by semicolons, or a +series of name="value" pairs. For example: `"fill:none; opacity:0.3"` or `fill="none" opacity="0.3"` (see: ) + +The SVG type: + + type SVG struct { + Writer io.Writer + } + +Most operations are methods on this type, specifying the destination io.Writer. + +The Offcolor type: + + type Offcolor struct { + Offset uint8 + Color string + Opacity float64 + } + +is used to specify the offset, color, and opacity of stop colors in linear and radial gradients + +The Filterspec type: + + type Filterspec struct { + In string + In2 string + Result string + } + +is used to specify inputs and results for filter effects + +*/ +package svg diff --git a/vendor/github.com/ajstarks/svgo/svg.go b/vendor/github.com/ajstarks/svgo/svg.go new file mode 100644 index 00000000..06f045c1 --- /dev/null +++ b/vendor/github.com/ajstarks/svgo/svg.go @@ -0,0 +1,978 @@ +// Package svg provides an API for generating Scalable Vector Graphics (SVG) +package svg + +// package main +// +// import ( +// "github.com/ajstarks/svgo" +// "os" +// ) +// +// var ( +// width = 500 +// height = 500 +// canvas = svg.New(os.Stdout) +// ) +// +// func main() { +// canvas.Start(width, height) +// canvas.Circle(width/2, height/2, 100) +// canvas.Text(width/2, height/2, "Hello, SVG", +// "text-anchor:middle;font-size:30px;fill:white") +// canvas.End() +// } +// + +import ( + "fmt" + "io" + + "encoding/xml" + "strings" +) + +// SVG defines the location of the generated SVG +type SVG struct { + Writer io.Writer +} + +// Offcolor defines the offset and color for gradients +type Offcolor struct { + Offset uint8 + Color string + Opacity float64 +} + +// Filterspec defines the specification of SVG filters +type Filterspec struct { + In, In2, Result string +} + +const ( + svgtop = ` + +` + vbfmt = `viewBox="%d %d %d %d"` + + emptyclose = "/>\n" +) + +// New is the SVG constructor, specifying the io.Writer where the generated SVG is written. +func New(w io.Writer) *SVG { return &SVG{w} } + +func (svg *SVG) print(a ...interface{}) (n int, errno error) { + return fmt.Fprint(svg.Writer, a...) +} + +func (svg *SVG) println(a ...interface{}) (n int, errno error) { + return fmt.Fprintln(svg.Writer, a...) +} + +func (svg *SVG) printf(format string, a ...interface{}) (n int, errno error) { + return fmt.Fprintf(svg.Writer, format, a...) +} + +func (svg *SVG) genattr(ns []string) { + for _, v := range ns { + svg.printf("\n %s", v) + } + svg.println(svgns) +} + +// Structure, Metadata, Scripting, Transformation, and Links + +// Start begins the SVG document with the width w and height h. +// Other attributes may be optionally added, for example viewbox or additional namespaces +// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#SVGElement +func (svg *SVG) Start(w int, h int, ns ...string) { + svg.printf(svginitfmt, svgtop, w, "", h, "") + svg.genattr(ns) +} + +// Startunit begins the SVG document, with width and height in the specified units +// Other attributes may be optionally added, for example viewbox or additional namespaces +func (svg *SVG) Startunit(w int, h int, unit string, ns ...string) { + svg.printf(svginitfmt, svgtop, w, unit, h, unit) + svg.genattr(ns) +} + +// Startpercent begins the SVG document, with width and height as percentages +// Other attributes may be optionally added, for example viewbox or additional namespaces +func (svg *SVG) Startpercent(w int, h int, ns ...string) { + svg.printf(svginitfmt, svgtop, w, "%", h, "%") + svg.genattr(ns) +} + +// Startview begins the SVG document, with the specified width, height, and viewbox +// Other attributes may be optionally added, for example viewbox or additional namespaces +func (svg *SVG) Startview(w, h, minx, miny, vw, vh int) { + svg.Start(w, h, fmt.Sprintf(vbfmt, minx, miny, vw, vh)) +} + +func (svg *SVG) StartviewUnit(w, h int, unit string, minx, miny, vw, vh int) { + svg.Startunit(w, h, unit, fmt.Sprintf(vbfmt, minx, miny, vw, vh)) +} + +// Startraw begins the SVG document, passing arbitrary attributes +func (svg *SVG) Startraw(ns ...string) { + svg.printf(svgtop) + svg.genattr(ns) +} + +// End the SVG document +func (svg *SVG) End() { svg.println("") } + +// Script defines a script with a specified type, (for example "application/javascript"). +// if the first variadic argument is a link, use only the link reference. +// Otherwise, treat those arguments as the text of the script (marked up as CDATA). +// if no data is specified, just close the script element +func (svg *SVG) Script(scriptype string, data ...string) { + svg.printf(`\n") + + default: + svg.println(`/>`) + } +} + +// Gstyle begins a group, with the specified style. +// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#GElement +func (svg *SVG) Gstyle(s string) { svg.println(group("style", s)) } + +// Gtransform begins a group, with the specified transform +// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute +func (svg *SVG) Gtransform(s string) { svg.println(group("transform", s)) } + +// Translate begins coordinate translation, end with Gend() +// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute +func (svg *SVG) Translate(x, y int) { svg.Gtransform(translate(x, y)) } + +// Scale scales the coordinate system by n, end with Gend() +// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute +func (svg *SVG) Scale(n float64) { svg.Gtransform(scale(n)) } + +// ScaleXY scales the coordinate system by dx and dy, end with Gend() +// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute +func (svg *SVG) ScaleXY(dx, dy float64) { svg.Gtransform(scaleXY(dx, dy)) } + +// SkewX skews the x coordinate system by angle a, end with Gend() +// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute +func (svg *SVG) SkewX(a float64) { svg.Gtransform(skewX(a)) } + +// SkewY skews the y coordinate system by angle a, end with Gend() +// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute +func (svg *SVG) SkewY(a float64) { svg.Gtransform(skewY(a)) } + +// SkewXY skews x and y coordinates by ax, ay respectively, end with Gend() +// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute +func (svg *SVG) SkewXY(ax, ay float64) { svg.Gtransform(skewX(ax) + " " + skewY(ay)) } + +// Rotate rotates the coordinate system by r degrees, end with Gend() +// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute +func (svg *SVG) Rotate(r float64) { svg.Gtransform(rotate(r)) } + +// TranslateRotate translates the coordinate system to (x,y), then rotates to r degrees, end with Gend() +func (svg *SVG) TranslateRotate(x, y int, r float64) { + svg.Gtransform(translate(x, y) + " " + rotate(r)) +} + +// RotateTranslate rotates the coordinate system r degrees, then translates to (x,y), end with Gend() +func (svg *SVG) RotateTranslate(x, y int, r float64) { + svg.Gtransform(rotate(r) + " " + translate(x, y)) +} + +// Group begins a group with arbitrary attributes +func (svg *SVG) Group(s ...string) { svg.printf("`)) } + +// Gid begins a group, with the specified id +func (svg *SVG) Gid(s string) { + svg.print(``) +} + +// Gend ends a group (must be paired with Gsttyle, Gtransform, Gid). +func (svg *SVG) Gend() { svg.println(``) } + +// ClipPath defines a clip path +func (svg *SVG) ClipPath(s ...string) { svg.printf(``)) } + +// ClipEnd ends a ClipPath +func (svg *SVG) ClipEnd() { + svg.println(``) +} + +// Def begins a defintion block. +// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#DefsElement +func (svg *SVG) Def() { svg.println(``) } + +// DefEnd ends a defintion block. +func (svg *SVG) DefEnd() { svg.println(``) } + +// Marker defines a marker +// Standard reference: http://www.w3.org/TR/SVG11/painting.html#MarkerElement +func (svg *SVG) Marker(id string, x, y, width, height int, s ...string) { + svg.printf(`\n")) +} + +// MarkEnd ends a marker +func (svg *SVG) MarkerEnd() { svg.println(``) } + +// Pattern defines a pattern with the specified dimensions. +// The putype can be either "user" or "obj", which sets the patternUnits +// attribute to be either userSpaceOnUse or objectBoundingBox +// Standard reference: http://www.w3.org/TR/SVG11/pservers.html#Patterns +func (svg *SVG) Pattern(id string, x, y, width, height int, putype string, s ...string) { + puattr := "userSpaceOnUse" + if putype != "user" { + puattr = "objectBoundingBox" + } + svg.printf(`\n")) +} + +// PatternEnd ends a marker +func (svg *SVG) PatternEnd() { svg.println(``) } + +// Desc specified the text of the description tag. +// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#DescElement +func (svg *SVG) Desc(s string) { svg.tt("desc", s) } + +// Title specified the text of the title tag. +// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#TitleElement +func (svg *SVG) Title(s string) { svg.tt("title", s) } + +// Link begins a link named "name", with the specified title. +// Standard Reference: http://www.w3.org/TR/SVG11/linking.html#Links +func (svg *SVG) Link(href string, title string) { + svg.printf("") +} + +// LinkEnd ends a link. +func (svg *SVG) LinkEnd() { svg.println(``) } + +// Use places the object referenced at link at the location x, y, with optional style. +// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#UseElement +func (svg *SVG) Use(x int, y int, link string, s ...string) { + svg.printf(``)) +} + +// MaskEnd ends a Mask. +func (svg *SVG) MaskEnd() { svg.println(``) } + +// Shapes + +// Circle centered at x,y, with radius r, with optional style. +// Standard Reference: http://www.w3.org/TR/SVG11/shapes.html#CircleElement +func (svg *SVG) Circle(x int, y int, r int, s ...string) { + svg.printf(`")) + xml.Escape(svg.Writer, []byte(t)) + svg.println(``) +} + +// Textpath places text optionally styled text along a previously defined path +// Standard Reference: http://www.w3.org/TR/SVG11/text.html#TextPathElement +func (svg *SVG) Textpath(t string, pathid string, s ...string) { + svg.printf("", endstyle(s, ">"), pathid) + xml.Escape(svg.Writer, []byte(t)) + svg.println(``) +} + +// Textlines places a series of lines of text starting at x,y, at the specified size, fill, and alignment. +// Each line is spaced according to the spacing argument +func (svg *SVG) Textlines(x, y int, s []string, size, spacing int, fill, align string) { + svg.Gstyle(fmt.Sprintf("font-size:%dpx;fill:%s;text-anchor:%s", size, fill, align)) + for _, t := range s { + svg.Text(x, y, t) + y += spacing + } + svg.Gend() +} + +// Colors + +// RGB specifies a fill color in terms of a (r)ed, (g)reen, (b)lue triple. +// Standard reference: http://www.w3.org/TR/css3-color/ +func (svg *SVG) RGB(r int, g int, b int) string { + return fmt.Sprintf(`fill:rgb(%d,%d,%d)`, r, g, b) +} + +// RGBA specifies a fill color in terms of a (r)ed, (g)reen, (b)lue triple and opacity. +func (svg *SVG) RGBA(r int, g int, b int, a float64) string { + return fmt.Sprintf(`fill-opacity:%.2f; %s`, a, svg.RGB(r, g, b)) +} + +// Gradients + +// LinearGradient constructs a linear color gradient identified by id, +// along the vector defined by (x1,y1), and (x2,y2). +// The stop color sequence defined in sc. Coordinates are expressed as percentages. +func (svg *SVG) LinearGradient(id string, x1, y1, x2, y2 uint8, sc []Offcolor) { + svg.printf("\n", + id, pct(x1), pct(y1), pct(x2), pct(y2)) + svg.stopcolor(sc) + svg.println("") +} + +// RadialGradient constructs a radial color gradient identified by id, +// centered at (cx,cy), with a radius of r. +// (fx, fy) define the location of the focal point of the light source. +// The stop color sequence defined in sc. +// Coordinates are expressed as percentages. +func (svg *SVG) RadialGradient(id string, cx, cy, r, fx, fy uint8, sc []Offcolor) { + svg.printf("\n", + id, pct(cx), pct(cy), pct(r), pct(fx), pct(fy)) + svg.stopcolor(sc) + svg.println("") +} + +// stopcolor is a utility function used by the gradient functions +// to define a sequence of offsets (expressed as percentages) and colors +func (svg *SVG) stopcolor(oc []Offcolor) { + for _, v := range oc { + svg.printf("\n", + pct(v.Offset), v.Color, v.Opacity) + } +} + +// Filter Effects: +// Most functions have common attributes (in, in2, result) defined in type Filterspec +// used as a common first argument. + +// Filter begins a filter set +// Standard reference: http://www.w3.org/TR/SVG11/filters.html#FilterElement +func (svg *SVG) Filter(id string, s ...string) { + svg.printf(`\n")) +} + +// Fend ends a filter set +// Standard reference: http://www.w3.org/TR/SVG11/filters.html#FilterElement +func (svg *SVG) Fend() { + svg.println(``) +} + +// FeBlend specifies a Blend filter primitive +// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feBlendElement +func (svg *SVG) FeBlend(fs Filterspec, mode string, s ...string) { + switch mode { + case "normal", "multiply", "screen", "darken", "lighten": + break + default: + mode = "normal" + } + svg.printf(` 360 { + value = 0 + } + svg.printf(` 1 { + value = 1 + } + svg.printf(``) +} + +// FeCompEnd ends a feComponent filter element +// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement +func (svg *SVG) FeCompEnd() { + svg.println(``) +} + +// FeComposite specifies a feComposite filter primitive +// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feCompositeElement +func (svg *SVG) FeComposite(fs Filterspec, operator string, k1, k2, k3, k4 int, s ...string) { + switch operator { + case "over", "in", "out", "atop", "xor", "arithmetic": + break + default: + operator = "over" + } + svg.printf(``)) +} + +// FeDiffEnd ends a diffuse lighting filter primitive container +// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feDiffuseLightingElement +func (svg *SVG) FeDiffEnd() { + svg.println(``) +} + +// FeDisplacementMap specifies a feDisplacementMap filter primitive +// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feDisplacementMapElement +func (svg *SVG) FeDisplacementMap(fs Filterspec, scale float64, xchannel, ychannel string, s ...string) { + svg.printf(``) + for _, n := range nodes { + svg.printf("\n", n) + } + svg.println(``) +} + +// FeMorphology specifies a feMorphologyLight filter primitive +// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feMorphologyElement +func (svg *SVG) FeMorphology(fs Filterspec, operator string, xradius, yradius float64, s ...string) { + switch operator { + case "erode", "dilate": + break + default: + operator = "erode" + } + svg.printf(`\n")) +} + +// FeSpecEnd ends a specular lighting filter primitive container +// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feSpecularLightingElement +func (svg *SVG) FeSpecEnd() { + svg.println(``) +} + +// FeSpotLight specifies a feSpotLight filter primitive +// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feSpotLightElement +func (svg *SVG) FeSpotLight(fs Filterspec, x, y, z, px, py, pz float64, s ...string) { + svg.printf(` 1 { + bfx = 0 + } + if bfy < 0 || bfy > 1 { + bfy = 0 + } + switch ftype[0:1] { + case "f", "F": + ftype = "fractalNoise" + case "t", "T": + ftype = "turbulence" + default: + ftype = "turbulence" + } + + var ss string + if stitch { + ss = "stitch" + } else { + ss = "noStitch" + } + svg.printf(` 0 { + svg.Gstyle(s[0]) + } + for ix := x; ix <= x+w; ix += n { + svg.Line(ix, y, ix, y+h) + } + + for iy := y; iy <= y+h; iy += n { + svg.Line(x, iy, x+w, iy) + } + if len(s) > 0 { + svg.Gend() + } + +} + +// Support functions + +// style returns a style name,attribute string +func style(s string) string { + if len(s) > 0 { + return fmt.Sprintf(`style="%s"`, s) + } + return s +} + +// pp returns a series of polygon points +func (svg *SVG) pp(x []int, y []int, tag string) { + svg.print(tag) + if len(x) != len(y) { + svg.print(" ") + return + } + lx := len(x) - 1 + for i := 0; i < lx; i++ { + svg.print(coord(x[i], y[i]) + " ") + } + svg.print(coord(x[lx], y[lx])) +} + +// endstyle modifies an SVG object, with either a series of name="value" pairs, +// or a single string containing a style +func endstyle(s []string, endtag string) string { + if len(s) > 0 { + nv := "" + for i := 0; i < len(s); i++ { + if strings.Index(s[i], "=") > 0 { + nv += (s[i]) + " " + } else { + nv += style(s[i]) + } + } + return nv + endtag + } + return endtag + +} + +// tt creates a xml element, tag containing s +func (svg *SVG) tt(tag string, s string) { + svg.print("<" + tag + ">") + xml.Escape(svg.Writer, []byte(s)) + svg.println("") +} + +// poly compiles the polygon element +func (svg *SVG) poly(x []int, y []int, tag string, s ...string) { + svg.pp(x, y, "<"+tag+" points=\"") + svg.print(`" ` + endstyle(s, "/>\n")) +} + +// onezero returns "0" or "1" +func onezero(flag bool) string { + if flag { + return "1" + } + return "0" +} + +// pct returns a percetage, capped at 100 +func pct(n uint8) uint8 { + if n > 100 { + return 100 + } + return n +} + +// islink determines if a string is a script reference +func islink(link string) bool { + return strings.HasPrefix(link, "http://") || strings.HasPrefix(link, "#") || + strings.HasPrefix(link, "../") || strings.HasPrefix(link, "./") +} + +// group returns a group element +func group(tag string, value string) string { return fmt.Sprintf(``, tag, value) } + +// scale return the scale string for the transform +func scale(n float64) string { return fmt.Sprintf(`scale(%g)`, n) } + +// scaleXY return the scale string for the transform +func scaleXY(dx, dy float64) string { return fmt.Sprintf(`scale(%g,%g)`, dx, dy) } + +// skewx returns the skewX string for the transform +func skewX(angle float64) string { return fmt.Sprintf(`skewX(%g)`, angle) } + +// skewx returns the skewX string for the transform +func skewY(angle float64) string { return fmt.Sprintf(`skewY(%g)`, angle) } + +// rotate returns the rotate string for the transform +func rotate(r float64) string { return fmt.Sprintf(`rotate(%g)`, r) } + +// translate returns the translate string for the transform +func translate(x, y int) string { return fmt.Sprintf(`translate(%d,%d)`, x, y) } + +// coord returns a coordinate string +func coord(x int, y int) string { return fmt.Sprintf(`%d,%d`, x, y) } + +// ptag returns the beginning of the path element +func ptag(x int, y int) string { return fmt.Sprintf(` 0 { + attrs += fmt.Sprintf(`in="%s" `, s.In) + } + if len(s.In2) > 0 { + attrs += fmt.Sprintf(`in2="%s" `, s.In2) + } + if len(s.Result) > 0 { + attrs += fmt.Sprintf(`result="%s" `, s.Result) + } + return attrs +} + +// tablevalues outputs a series of values as a XML attribute +func (svg *SVG) tablevalues(s string, t []float64) { + svg.printf(` %s="`, s) + for i := 0; i < len(t)-1; i++ { + svg.printf("%g ", t[i]) + } + svg.printf(`%g"%s`, t[len(t)-1], emptyclose) +} + +// imgchannel validates the image channel indicator +func imgchannel(c string) string { + switch c { + case "R", "G", "B", "A": + return c + case "r", "g", "b", "a": + return strings.ToUpper(c) + case "red", "green", "blue", "alpha": + return strings.ToUpper(c[0:1]) + case "Red", "Green", "Blue", "Alpha": + return c[0:1] + } + return "R" +} diff --git a/vendor/github.com/cheggaaa/pb/LICENSE b/vendor/github.com/cheggaaa/pb/LICENSE new file mode 100644 index 00000000..51197033 --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/LICENSE @@ -0,0 +1,12 @@ +Copyright (c) 2012-2015, Sergey Cherepanov +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +* Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/vendor/github.com/cheggaaa/pb/format.go b/vendor/github.com/cheggaaa/pb/format.go new file mode 100644 index 00000000..d5aeff79 --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/format.go @@ -0,0 +1,87 @@ +package pb + +import ( + "fmt" + "strings" + "time" +) + +type Units int + +const ( + // U_NO are default units, they represent a simple value and are not formatted at all. + U_NO Units = iota + // U_BYTES units are formatted in a human readable way (b, Bb, Mb, ...) + U_BYTES + // U_DURATION units are formatted in a human readable way (3h14m15s) + U_DURATION +) + +func Format(i int64) *formatter { + return &formatter{n: i} +} + +type formatter struct { + n int64 + unit Units + width int + perSec bool +} + +func (f *formatter) Value(n int64) *formatter { + f.n = n + return f +} + +func (f *formatter) To(unit Units) *formatter { + f.unit = unit + return f +} + +func (f *formatter) Width(width int) *formatter { + f.width = width + return f +} + +func (f *formatter) PerSec() *formatter { + f.perSec = true + return f +} + +func (f *formatter) String() (out string) { + switch f.unit { + case U_BYTES: + out = formatBytes(f.n) + case U_DURATION: + d := time.Duration(f.n) + if d > time.Hour*24 { + out = fmt.Sprintf("%dd", d/24/time.Hour) + d -= (d / time.Hour / 24) * (time.Hour * 24) + } + out = fmt.Sprintf("%s%v", out, d) + default: + out = fmt.Sprintf(fmt.Sprintf("%%%dd", f.width), f.n) + } + if f.perSec { + out += "/s" + } + return +} + +// Convert bytes to human readable string. Like a 2 MB, 64.2 KB, 52 B +func formatBytes(i int64) (result string) { + switch { + case i > (1024 * 1024 * 1024 * 1024): + result = fmt.Sprintf("%.02f TB", float64(i)/1024/1024/1024/1024) + case i > (1024 * 1024 * 1024): + result = fmt.Sprintf("%.02f GB", float64(i)/1024/1024/1024) + case i > (1024 * 1024): + result = fmt.Sprintf("%.02f MB", float64(i)/1024/1024) + case i > 1024: + result = fmt.Sprintf("%.02f KB", float64(i)/1024) + default: + result = fmt.Sprintf("%d B", i) + } + result = strings.Trim(result, " ") + return +} diff --git a/vendor/github.com/cheggaaa/pb/pb.go b/vendor/github.com/cheggaaa/pb/pb.go new file mode 100644 index 00000000..23ae327d --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/pb.go @@ -0,0 +1,441 @@ +// Simple console progress bars +package pb + +import ( + "fmt" + "io" + "math" + "strings" + "sync" + "sync/atomic" + "time" + "unicode/utf8" +) + +// Current version +const Version = "1.0.5" + +const ( + // Default refresh rate - 200ms + DEFAULT_REFRESH_RATE = time.Millisecond * 200 + FORMAT = "[=>-]" +) + +// DEPRECATED +// variables for backward compatibility, from now do not work +// use pb.Format and pb.SetRefreshRate +var ( + DefaultRefreshRate = DEFAULT_REFRESH_RATE + BarStart, BarEnd, Empty, Current, CurrentN string +) + +// Create new progress bar object +func New(total int) *ProgressBar { + return New64(int64(total)) +} + +// Create new progress bar object using int64 as total +func New64(total int64) *ProgressBar { + pb := &ProgressBar{ + Total: total, + RefreshRate: DEFAULT_REFRESH_RATE, + ShowPercent: true, + ShowCounters: true, + ShowBar: true, + ShowTimeLeft: true, + ShowFinalTime: true, + Units: U_NO, + ManualUpdate: false, + finish: make(chan struct{}), + currentValue: -1, + mu: new(sync.Mutex), + } + return pb.Format(FORMAT) +} + +// Create new object and start +func StartNew(total int) *ProgressBar { + return New(total).Start() +} + +// Callback for custom output +// For example: +// bar.Callback = func(s string) { +// mySuperPrint(s) +// } +// +type Callback func(out string) + +type ProgressBar struct { + current int64 // current must be first member of struct (https://code.google.com/p/go/issues/detail?id=5278) + + Total int64 + RefreshRate time.Duration + ShowPercent, ShowCounters bool + ShowSpeed, ShowTimeLeft, ShowBar bool + ShowFinalTime bool + Output io.Writer + Callback Callback + NotPrint bool + Units Units + Width int + ForceWidth bool + ManualUpdate bool + AutoStat bool + + // Default width for the time box. + UnitsWidth int + TimeBoxWidth int + + finishOnce sync.Once //Guards isFinish + finish chan struct{} + isFinish bool + + startTime time.Time + startValue int64 + currentValue int64 + + prefix, postfix string + + mu *sync.Mutex + lastPrint string + + BarStart string + BarEnd string + Empty string + Current string + CurrentN string + + AlwaysUpdate bool +} + +// Start print +func (pb *ProgressBar) Start() *ProgressBar { + pb.startTime = time.Now() + pb.startValue = pb.current + if pb.Total == 0 { + pb.ShowTimeLeft = false + pb.ShowPercent = false + pb.AutoStat = false + } + if !pb.ManualUpdate { + pb.Update() // Initial printing of the bar before running the bar refresher. + go pb.refresher() + } + return pb +} + +// Increment current value +func (pb *ProgressBar) Increment() int { + return pb.Add(1) +} + +// Get current value +func (pb *ProgressBar) Get() int64 { + c := atomic.LoadInt64(&pb.current) + return c +} + +// Set current value +func (pb *ProgressBar) Set(current int) *ProgressBar { + return pb.Set64(int64(current)) +} + +// Set64 sets the current value as int64 +func (pb *ProgressBar) Set64(current int64) *ProgressBar { + atomic.StoreInt64(&pb.current, current) + return pb +} + +// Add to current value +func (pb *ProgressBar) Add(add int) int { + return int(pb.Add64(int64(add))) +} + +func (pb *ProgressBar) Add64(add int64) int64 { + return atomic.AddInt64(&pb.current, add) +} + +// Set prefix string +func (pb *ProgressBar) Prefix(prefix string) *ProgressBar { + pb.prefix = prefix + return pb +} + +// Set postfix string +func (pb *ProgressBar) Postfix(postfix string) *ProgressBar { + pb.postfix = postfix + return pb +} + +// Set custom format for bar +// Example: bar.Format("[=>_]") +// Example: bar.Format("[\x00=\x00>\x00-\x00]") // \x00 is the delimiter +func (pb *ProgressBar) Format(format string) *ProgressBar { + var formatEntries []string + if len(format) == 5 { + formatEntries = strings.Split(format, "") + } else { + formatEntries = strings.Split(format, "\x00") + } + if len(formatEntries) == 5 { + pb.BarStart = formatEntries[0] + pb.BarEnd = formatEntries[4] + pb.Empty = formatEntries[3] + pb.Current = formatEntries[1] + pb.CurrentN = formatEntries[2] + } + return pb +} + +// Set bar refresh rate +func (pb *ProgressBar) SetRefreshRate(rate time.Duration) *ProgressBar { + pb.RefreshRate = rate + return pb +} + +// Set units +// bar.SetUnits(U_NO) - by default +// bar.SetUnits(U_BYTES) - for Mb, Kb, etc +func (pb *ProgressBar) SetUnits(units Units) *ProgressBar { + pb.Units = units + return pb +} + +// Set max width, if width is bigger than terminal width, will be ignored +func (pb *ProgressBar) SetMaxWidth(width int) *ProgressBar { + pb.Width = width + pb.ForceWidth = false + return pb +} + +// Set bar width +func (pb *ProgressBar) SetWidth(width int) *ProgressBar { + pb.Width = width + pb.ForceWidth = true + return pb +} + +// End print +func (pb *ProgressBar) Finish() { + //Protect multiple calls + pb.finishOnce.Do(func() { + close(pb.finish) + pb.write(atomic.LoadInt64(&pb.current)) + if !pb.NotPrint { + fmt.Println() + } + pb.isFinish = true + }) +} + +// End print and write string 'str' +func (pb *ProgressBar) FinishPrint(str string) { + pb.Finish() + fmt.Println(str) +} + +// implement io.Writer +func (pb *ProgressBar) Write(p []byte) (n int, err error) { + n = len(p) + pb.Add(n) + return +} + +// implement io.Reader +func (pb *ProgressBar) Read(p []byte) (n int, err error) { + n = len(p) + pb.Add(n) + return +} + +// Create new proxy reader over bar +// Takes io.Reader or io.ReadCloser +func (pb *ProgressBar) NewProxyReader(r io.Reader) *Reader { + return &Reader{r, pb} +} + +func (pb *ProgressBar) write(current int64) { + width := pb.GetWidth() + + var percentBox, countersBox, timeLeftBox, speedBox, barBox, end, out string + + // percents + if pb.ShowPercent { + var percent float64 + if pb.Total > 0 { + percent = float64(current) / (float64(pb.Total) / float64(100)) + } else { + percent = float64(current) / float64(100) + } + percentBox = fmt.Sprintf(" %6.02f%%", percent) + } + + // counters + if pb.ShowCounters { + current := Format(current).To(pb.Units).Width(pb.UnitsWidth) + if pb.Total > 0 { + total := Format(pb.Total).To(pb.Units).Width(pb.UnitsWidth) + countersBox = fmt.Sprintf(" %s / %s ", current, total) + } else { + countersBox = fmt.Sprintf(" %s / ? ", current) + } + } + + // time left + fromStart := time.Now().Sub(pb.startTime) + currentFromStart := current - pb.startValue + select { + case <-pb.finish: + if pb.ShowFinalTime { + var left time.Duration + if pb.Total > 0 { + left = (fromStart / time.Second) * time.Second + } else { + left = (time.Duration(currentFromStart) / time.Second) * time.Second + } + timeLeftBox = fmt.Sprintf(" %s", left.String()) + } + default: + if pb.ShowTimeLeft && currentFromStart > 0 { + perEntry := fromStart / time.Duration(currentFromStart) + var left time.Duration + if pb.Total > 0 { + left = time.Duration(pb.Total-currentFromStart) * perEntry + left = (left / time.Second) * time.Second + } else { + left = time.Duration(currentFromStart) * perEntry + left = (left / time.Second) * time.Second + } + timeLeft := Format(int64(left)).To(U_DURATION).String() + timeLeftBox = fmt.Sprintf(" %s", timeLeft) + } + } + + if len(timeLeftBox) < pb.TimeBoxWidth { + timeLeftBox = fmt.Sprintf("%s%s", strings.Repeat(" ", pb.TimeBoxWidth-len(timeLeftBox)), timeLeftBox) + } + + // speed + if pb.ShowSpeed && currentFromStart > 0 { + fromStart := time.Now().Sub(pb.startTime) + speed := float64(currentFromStart) / (float64(fromStart) / float64(time.Second)) + speedBox = " " + Format(int64(speed)).To(pb.Units).Width(pb.UnitsWidth).PerSec().String() + } + + barWidth := escapeAwareRuneCountInString(countersBox + pb.BarStart + pb.BarEnd + percentBox + timeLeftBox + speedBox + pb.prefix + pb.postfix) + // bar + if pb.ShowBar { + size := width - barWidth + if size > 0 { + if pb.Total > 0 { + curCount := int(math.Ceil((float64(current) / float64(pb.Total)) * float64(size))) + emptCount := size - curCount + barBox = pb.BarStart + if emptCount < 0 { + emptCount = 0 + } + if curCount > size { + curCount = size + } + if emptCount <= 0 { + barBox += strings.Repeat(pb.Current, curCount) + } else if curCount > 0 { + barBox += strings.Repeat(pb.Current, curCount-1) + pb.CurrentN + } + barBox += strings.Repeat(pb.Empty, emptCount) + pb.BarEnd + } else { + barBox = pb.BarStart + pos := size - int(current)%int(size) + if pos-1 > 0 { + barBox += strings.Repeat(pb.Empty, pos-1) + } + barBox += pb.Current + if size-pos-1 > 0 { + barBox += strings.Repeat(pb.Empty, size-pos-1) + } + barBox += pb.BarEnd + } + } + } + + // check len + out = pb.prefix + countersBox + barBox + percentBox + speedBox + timeLeftBox + pb.postfix + if escapeAwareRuneCountInString(out) < width { + end = strings.Repeat(" ", width-utf8.RuneCountInString(out)) + } + + // and print! + pb.mu.Lock() + pb.lastPrint = out + end + pb.mu.Unlock() + switch { + case pb.isFinish: + return + case pb.Output != nil: + fmt.Fprint(pb.Output, "\r"+out+end) + case pb.Callback != nil: + pb.Callback(out + end) + case !pb.NotPrint: + fmt.Print("\r" + out + end) + } +} + +// GetTerminalWidth - returns terminal width for all platforms. +func GetTerminalWidth() (int, error) { + return terminalWidth() +} + +func (pb *ProgressBar) GetWidth() int { + if pb.ForceWidth { + return pb.Width + } + + width := pb.Width + termWidth, _ := terminalWidth() + if width == 0 || termWidth <= width { + width = termWidth + } + + return width +} + +// Write the current state of the progressbar +func (pb *ProgressBar) Update() { + c := atomic.LoadInt64(&pb.current) + if pb.AlwaysUpdate || c != pb.currentValue { + pb.write(c) + pb.currentValue = c + } + if pb.AutoStat { + if c == 0 { + pb.startTime = time.Now() + pb.startValue = 0 + } else if c >= pb.Total && pb.isFinish != true { + pb.Finish() + } + } +} + +func (pb *ProgressBar) String() string { + return pb.lastPrint +} + +// Internal loop for refreshing the progressbar +func (pb *ProgressBar) refresher() { + for { + select { + case <-pb.finish: + return + case <-time.After(pb.RefreshRate): + pb.Update() + } + } +} + +type window struct { + Row uint16 + Col uint16 + Xpixel uint16 + Ypixel uint16 +} diff --git a/vendor/github.com/cheggaaa/pb/pb_appengine.go b/vendor/github.com/cheggaaa/pb/pb_appengine.go new file mode 100644 index 00000000..d85dbc3b --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/pb_appengine.go @@ -0,0 +1,11 @@ +// +build appengine + +package pb + +import "errors" + +// terminalWidth returns width of the terminal, which is not supported +// and should always failed on appengine classic which is a sandboxed PaaS. +func terminalWidth() (int, error) { + return 0, errors.New("Not supported") +} diff --git a/vendor/github.com/cheggaaa/pb/pb_nix.go b/vendor/github.com/cheggaaa/pb/pb_nix.go new file mode 100644 index 00000000..c06097b4 --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/pb_nix.go @@ -0,0 +1,8 @@ +// +build linux darwin freebsd netbsd openbsd dragonfly +// +build !appengine + +package pb + +import "syscall" + +const sysIoctl = syscall.SYS_IOCTL diff --git a/vendor/github.com/cheggaaa/pb/pb_solaris.go b/vendor/github.com/cheggaaa/pb/pb_solaris.go new file mode 100644 index 00000000..b7d461e1 --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/pb_solaris.go @@ -0,0 +1,6 @@ +// +build solaris +// +build !appengine + +package pb + +const sysIoctl = 54 diff --git a/vendor/github.com/cheggaaa/pb/pb_win.go b/vendor/github.com/cheggaaa/pb/pb_win.go new file mode 100644 index 00000000..72f68283 --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/pb_win.go @@ -0,0 +1,141 @@ +// +build windows + +package pb + +import ( + "errors" + "fmt" + "os" + "sync" + "syscall" + "unsafe" +) + +var tty = os.Stdin + +var ( + kernel32 = syscall.NewLazyDLL("kernel32.dll") + + // GetConsoleScreenBufferInfo retrieves information about the + // specified console screen buffer. + // http://msdn.microsoft.com/en-us/library/windows/desktop/ms683171(v=vs.85).aspx + procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo") + + // GetConsoleMode retrieves the current input mode of a console's + // input buffer or the current output mode of a console screen buffer. + // https://msdn.microsoft.com/en-us/library/windows/desktop/ms683167(v=vs.85).aspx + getConsoleMode = kernel32.NewProc("GetConsoleMode") + + // SetConsoleMode sets the input mode of a console's input buffer + // or the output mode of a console screen buffer. + // https://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx + setConsoleMode = kernel32.NewProc("SetConsoleMode") + + // SetConsoleCursorPosition sets the cursor position in the + // specified console screen buffer. + // https://msdn.microsoft.com/en-us/library/windows/desktop/ms686025(v=vs.85).aspx + setConsoleCursorPosition = kernel32.NewProc("SetConsoleCursorPosition") +) + +type ( + // Defines the coordinates of the upper left and lower right corners + // of a rectangle. + // See + // http://msdn.microsoft.com/en-us/library/windows/desktop/ms686311(v=vs.85).aspx + smallRect struct { + Left, Top, Right, Bottom int16 + } + + // Defines the coordinates of a character cell in a console screen + // buffer. The origin of the coordinate system (0,0) is at the top, left cell + // of the buffer. + // See + // http://msdn.microsoft.com/en-us/library/windows/desktop/ms682119(v=vs.85).aspx + coordinates struct { + X, Y int16 + } + + word int16 + + // Contains information about a console screen buffer. + // http://msdn.microsoft.com/en-us/library/windows/desktop/ms682093(v=vs.85).aspx + consoleScreenBufferInfo struct { + dwSize coordinates + dwCursorPosition coordinates + wAttributes word + srWindow smallRect + dwMaximumWindowSize coordinates + } +) + +// terminalWidth returns width of the terminal. +func terminalWidth() (width int, err error) { + var info consoleScreenBufferInfo + _, _, e := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, uintptr(syscall.Stdout), uintptr(unsafe.Pointer(&info)), 0) + if e != 0 { + return 0, error(e) + } + return int(info.dwSize.X) - 1, nil +} + +func getCursorPos() (pos coordinates, err error) { + var info consoleScreenBufferInfo + _, _, e := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, uintptr(syscall.Stdout), uintptr(unsafe.Pointer(&info)), 0) + if e != 0 { + return info.dwCursorPosition, error(e) + } + return info.dwCursorPosition, nil +} + +func setCursorPos(pos coordinates) error { + _, _, e := syscall.Syscall(setConsoleCursorPosition.Addr(), 2, uintptr(syscall.Stdout), uintptr(uint32(uint16(pos.Y))<<16|uint32(uint16(pos.X))), 0) + if e != 0 { + return error(e) + } + return nil +} + +var ErrPoolWasStarted = errors.New("Bar pool was started") + +var echoLocked bool +var echoLockMutex sync.Mutex + +var oldState word + +func lockEcho() (quit chan int, err error) { + echoLockMutex.Lock() + defer echoLockMutex.Unlock() + if echoLocked { + err = ErrPoolWasStarted + return + } + echoLocked = true + + if _, _, e := syscall.Syscall(getConsoleMode.Addr(), 2, uintptr(syscall.Stdout), uintptr(unsafe.Pointer(&oldState)), 0); e != 0 { + err = fmt.Errorf("Can't get terminal settings: %v", e) + return + } + + newState := oldState + const ENABLE_ECHO_INPUT = 0x0004 + const ENABLE_LINE_INPUT = 0x0002 + newState = newState & (^(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT)) + if _, _, e := syscall.Syscall(setConsoleMode.Addr(), 2, uintptr(syscall.Stdout), uintptr(newState), 0); e != 0 { + err = fmt.Errorf("Can't set terminal settings: %v", e) + return + } + return +} + +func unlockEcho() (err error) { + echoLockMutex.Lock() + defer echoLockMutex.Unlock() + if !echoLocked { + return + } + echoLocked = false + if _, _, e := syscall.Syscall(setConsoleMode.Addr(), 2, uintptr(syscall.Stdout), uintptr(oldState), 0); e != 0 { + err = fmt.Errorf("Can't set terminal settings") + } + return +} diff --git a/vendor/github.com/cheggaaa/pb/pb_x.go b/vendor/github.com/cheggaaa/pb/pb_x.go new file mode 100644 index 00000000..12e6fe6e --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/pb_x.go @@ -0,0 +1,110 @@ +// +build linux darwin freebsd netbsd openbsd solaris dragonfly +// +build !appengine + +package pb + +import ( + "errors" + "fmt" + "os" + "os/signal" + "runtime" + "sync" + "syscall" + "unsafe" +) + +const ( + TIOCGWINSZ = 0x5413 + TIOCGWINSZ_OSX = 1074295912 +) + +var tty *os.File + +var ErrPoolWasStarted = errors.New("Bar pool was started") + +var echoLocked bool +var echoLockMutex sync.Mutex + +func init() { + var err error + tty, err = os.Open("/dev/tty") + if err != nil { + tty = os.Stdin + } +} + +// terminalWidth returns width of the terminal. +func terminalWidth() (int, error) { + w := new(window) + tio := syscall.TIOCGWINSZ + if runtime.GOOS == "darwin" { + tio = TIOCGWINSZ_OSX + } + res, _, err := syscall.Syscall(sysIoctl, + tty.Fd(), + uintptr(tio), + uintptr(unsafe.Pointer(w)), + ) + if int(res) == -1 { + return 0, err + } + return int(w.Col), nil +} + +var oldState syscall.Termios + +func lockEcho() (quit chan int, err error) { + echoLockMutex.Lock() + defer echoLockMutex.Unlock() + if echoLocked { + err = ErrPoolWasStarted + return + } + echoLocked = true + + fd := tty.Fd() + if _, _, e := syscall.Syscall6(sysIoctl, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&oldState)), 0, 0, 0); e != 0 { + err = fmt.Errorf("Can't get terminal settings: %v", e) + return + } + + newState := oldState + newState.Lflag &^= syscall.ECHO + newState.Lflag |= syscall.ICANON | syscall.ISIG + newState.Iflag |= syscall.ICRNL + if _, _, e := syscall.Syscall6(sysIoctl, fd, ioctlWriteTermios, uintptr(unsafe.Pointer(&newState)), 0, 0, 0); e != 0 { + err = fmt.Errorf("Can't set terminal settings: %v", e) + return + } + quit = make(chan int, 1) + go catchTerminate(quit) + return +} + +func unlockEcho() (err error) { + echoLockMutex.Lock() + defer echoLockMutex.Unlock() + if !echoLocked { + return + } + echoLocked = false + fd := tty.Fd() + if _, _, e := syscall.Syscall6(sysIoctl, fd, ioctlWriteTermios, uintptr(unsafe.Pointer(&oldState)), 0, 0, 0); e != 0 { + err = fmt.Errorf("Can't set terminal settings") + } + return +} + +// listen exit signals and restore terminal state +func catchTerminate(quit chan int) { + sig := make(chan os.Signal, 1) + signal.Notify(sig, os.Interrupt, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGKILL) + defer signal.Stop(sig) + select { + case <-quit: + unlockEcho() + case <-sig: + unlockEcho() + } +} diff --git a/vendor/github.com/cheggaaa/pb/pool.go b/vendor/github.com/cheggaaa/pb/pool.go new file mode 100644 index 00000000..0b4a4afa --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/pool.go @@ -0,0 +1,76 @@ +// +build linux darwin freebsd netbsd openbsd solaris dragonfly windows + +package pb + +import ( + "sync" + "time" +) + +// Create and start new pool with given bars +// You need call pool.Stop() after work +func StartPool(pbs ...*ProgressBar) (pool *Pool, err error) { + pool = new(Pool) + if err = pool.start(); err != nil { + return + } + pool.Add(pbs...) + return +} + +type Pool struct { + RefreshRate time.Duration + bars []*ProgressBar + quit chan int + finishOnce sync.Once +} + +// Add progress bars. +func (p *Pool) Add(pbs ...*ProgressBar) { + for _, bar := range pbs { + bar.ManualUpdate = true + bar.NotPrint = true + bar.Start() + p.bars = append(p.bars, bar) + } +} + +func (p *Pool) start() (err error) { + p.RefreshRate = DefaultRefreshRate + quit, err := lockEcho() + if err != nil { + return + } + p.quit = make(chan int) + go p.writer(quit) + return +} + +func (p *Pool) writer(finish chan int) { + var first = true + for { + select { + case <-time.After(p.RefreshRate): + if p.print(first) { + p.print(false) + finish <- 1 + return + } + first = false + case <-p.quit: + finish <- 1 + return + } + } +} + +// Restore terminal state and close pool +func (p *Pool) Stop() error { + // Wait until one final refresh has passed. + time.Sleep(p.RefreshRate) + + p.finishOnce.Do(func() { + close(p.quit) + }) + return unlockEcho() +} diff --git a/vendor/github.com/cheggaaa/pb/pool_win.go b/vendor/github.com/cheggaaa/pb/pool_win.go new file mode 100644 index 00000000..d7a5ace4 --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/pool_win.go @@ -0,0 +1,35 @@ +// +build windows + +package pb + +import ( + "fmt" + "log" +) + +func (p *Pool) print(first bool) bool { + var out string + if !first { + coords, err := getCursorPos() + if err != nil { + log.Panic(err) + } + coords.Y -= int16(len(p.bars)) + coords.X = 0 + + err = setCursorPos(coords) + if err != nil { + log.Panic(err) + } + } + isFinished := true + for _, bar := range p.bars { + if !bar.isFinish { + isFinished = false + } + bar.Update() + out += fmt.Sprintf("\r%s\n", bar.String()) + } + fmt.Print(out) + return isFinished +} diff --git a/vendor/github.com/cheggaaa/pb/pool_x.go b/vendor/github.com/cheggaaa/pb/pool_x.go new file mode 100644 index 00000000..d95b71d8 --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/pool_x.go @@ -0,0 +1,22 @@ +// +build linux darwin freebsd netbsd openbsd solaris dragonfly + +package pb + +import "fmt" + +func (p *Pool) print(first bool) bool { + var out string + if !first { + out = fmt.Sprintf("\033[%dA", len(p.bars)) + } + isFinished := true + for _, bar := range p.bars { + if !bar.isFinish { + isFinished = false + } + bar.Update() + out += fmt.Sprintf("\r%s\n", bar.String()) + } + fmt.Print(out) + return isFinished +} diff --git a/vendor/github.com/cheggaaa/pb/reader.go b/vendor/github.com/cheggaaa/pb/reader.go new file mode 100644 index 00000000..9f3148b5 --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/reader.go @@ -0,0 +1,25 @@ +package pb + +import ( + "io" +) + +// It's proxy reader, implement io.Reader +type Reader struct { + io.Reader + bar *ProgressBar +} + +func (r *Reader) Read(p []byte) (n int, err error) { + n, err = r.Reader.Read(p) + r.bar.Add(n) + return +} + +// Close the reader when it implements io.Closer +func (r *Reader) Close() (err error) { + if closer, ok := r.Reader.(io.Closer); ok { + return closer.Close() + } + return +} diff --git a/vendor/github.com/cheggaaa/pb/runecount.go b/vendor/github.com/cheggaaa/pb/runecount.go new file mode 100644 index 00000000..c5a4925a --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/runecount.go @@ -0,0 +1,17 @@ +package pb + +import ( + "regexp" + "unicode/utf8" +) + +// Finds the control character sequences (like colors) +var ctrlFinder = regexp.MustCompile("\x1b\x5b[0-9]+\x6d") + +func escapeAwareRuneCountInString(s string) int { + n := utf8.RuneCountInString(s) + for _, sm := range ctrlFinder.FindAllString(s, -1) { + n -= len(sm) + } + return n +} diff --git a/vendor/github.com/cheggaaa/pb/termios_bsd.go b/vendor/github.com/cheggaaa/pb/termios_bsd.go new file mode 100644 index 00000000..517ea8ed --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/termios_bsd.go @@ -0,0 +1,9 @@ +// +build darwin freebsd netbsd openbsd dragonfly +// +build !appengine + +package pb + +import "syscall" + +const ioctlReadTermios = syscall.TIOCGETA +const ioctlWriteTermios = syscall.TIOCSETA diff --git a/vendor/github.com/cheggaaa/pb/termios_nix.go b/vendor/github.com/cheggaaa/pb/termios_nix.go new file mode 100644 index 00000000..ebb3fe87 --- /dev/null +++ b/vendor/github.com/cheggaaa/pb/termios_nix.go @@ -0,0 +1,7 @@ +// +build linux solaris +// +build !appengine + +package pb + +const ioctlReadTermios = 0x5401 // syscall.TCGETS +const ioctlWriteTermios = 0x5402 // syscall.TCSETS diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/LICENSE b/vendor/github.com/cloudfoundry-incubator/candiedyaml/LICENSE new file mode 100644 index 00000000..d9a10c0d --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/LICENSE @@ -0,0 +1,176 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/api.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/api.go new file mode 100644 index 00000000..87c1043e --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/api.go @@ -0,0 +1,834 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "io" +) + +/* + * Create a new parser object. + */ + +func yaml_parser_initialize(parser *yaml_parser_t) bool { + *parser = yaml_parser_t{ + raw_buffer: make([]byte, 0, INPUT_RAW_BUFFER_SIZE), + buffer: make([]byte, 0, INPUT_BUFFER_SIZE), + } + + return true +} + +/* + * Destroy a parser object. + */ +func yaml_parser_delete(parser *yaml_parser_t) { + *parser = yaml_parser_t{} +} + +/* + * String read handler. + */ + +func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (int, error) { + if parser.input_pos == len(parser.input) { + return 0, io.EOF + } + + n := copy(buffer, parser.input[parser.input_pos:]) + parser.input_pos += n + return n, nil +} + +/* + * File read handler. + */ + +func yaml_file_read_handler(parser *yaml_parser_t, buffer []byte) (int, error) { + return parser.input_reader.Read(buffer) +} + +/* + * Set a string input. + */ + +func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) { + if parser.read_handler != nil { + panic("input already set") + } + + parser.read_handler = yaml_string_read_handler + + parser.input = input + parser.input_pos = 0 +} + +/* + * Set a reader input + */ +func yaml_parser_set_input_reader(parser *yaml_parser_t, reader io.Reader) { + if parser.read_handler != nil { + panic("input already set") + } + + parser.read_handler = yaml_file_read_handler + parser.input_reader = reader +} + +/* + * Set a generic input. + */ + +func yaml_parser_set_input(parser *yaml_parser_t, handler yaml_read_handler_t) { + if parser.read_handler != nil { + panic("input already set") + } + + parser.read_handler = handler +} + +/* + * Set the source encoding. + */ + +func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) { + if parser.encoding != yaml_ANY_ENCODING { + panic("encoding already set") + } + + parser.encoding = encoding +} + +/* + * Create a new emitter object. + */ + +func yaml_emitter_initialize(emitter *yaml_emitter_t) { + *emitter = yaml_emitter_t{ + buffer: make([]byte, OUTPUT_BUFFER_SIZE), + raw_buffer: make([]byte, 0, OUTPUT_RAW_BUFFER_SIZE), + states: make([]yaml_emitter_state_t, 0, INITIAL_STACK_SIZE), + events: make([]yaml_event_t, 0, INITIAL_QUEUE_SIZE), + } +} + +func yaml_emitter_delete(emitter *yaml_emitter_t) { + *emitter = yaml_emitter_t{} +} + +/* + * String write handler. + */ + +func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error { + *emitter.output_buffer = append(*emitter.output_buffer, buffer...) + return nil +} + +/* + * File write handler. + */ + +func yaml_writer_write_handler(emitter *yaml_emitter_t, buffer []byte) error { + _, err := emitter.output_writer.Write(buffer) + return err +} + +/* + * Set a string output. + */ + +func yaml_emitter_set_output_string(emitter *yaml_emitter_t, buffer *[]byte) { + if emitter.write_handler != nil { + panic("output already set") + } + + emitter.write_handler = yaml_string_write_handler + emitter.output_buffer = buffer +} + +/* + * Set a file output. + */ + +func yaml_emitter_set_output_writer(emitter *yaml_emitter_t, w io.Writer) { + if emitter.write_handler != nil { + panic("output already set") + } + + emitter.write_handler = yaml_writer_write_handler + emitter.output_writer = w +} + +/* + * Set a generic output handler. + */ + +func yaml_emitter_set_output(emitter *yaml_emitter_t, handler yaml_write_handler_t) { + if emitter.write_handler != nil { + panic("output already set") + } + + emitter.write_handler = handler +} + +/* + * Set the output encoding. + */ + +func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) { + if emitter.encoding != yaml_ANY_ENCODING { + panic("encoding already set") + } + + emitter.encoding = encoding +} + +/* + * Set the canonical output style. + */ + +func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) { + emitter.canonical = canonical +} + +/* + * Set the indentation increment. + */ + +func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) { + if indent < 2 || indent > 9 { + indent = 2 + } + emitter.best_indent = indent +} + +/* + * Set the preferred line width. + */ + +func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) { + if width < 0 { + width = -1 + } + emitter.best_width = width +} + +/* + * Set if unescaped non-ASCII characters are allowed. + */ + +func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) { + emitter.unicode = unicode +} + +/* + * Set the preferred line break character. + */ + +func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) { + emitter.line_break = line_break +} + +/* + * Destroy a token object. + */ + +// yaml_DECLARE(void) +// yaml_token_delete(yaml_token_t *token) +// { +// assert(token); /* Non-NULL token object expected. */ +// +// switch (token.type) +// { +// case yaml_TAG_DIRECTIVE_TOKEN: +// yaml_free(token.data.tag_directive.handle); +// yaml_free(token.data.tag_directive.prefix); +// break; +// +// case yaml_ALIAS_TOKEN: +// yaml_free(token.data.alias.value); +// break; +// +// case yaml_ANCHOR_TOKEN: +// yaml_free(token.data.anchor.value); +// break; +// +// case yaml_TAG_TOKEN: +// yaml_free(token.data.tag.handle); +// yaml_free(token.data.tag.suffix); +// break; +// +// case yaml_SCALAR_TOKEN: +// yaml_free(token.data.scalar.value); +// break; +// +// default: +// break; +// } +// +// memset(token, 0, sizeof(yaml_token_t)); +// } + +/* + * Check if a string is a valid UTF-8 sequence. + * + * Check 'reader.c' for more details on UTF-8 encoding. + */ + +// static int +// yaml_check_utf8(yaml_char_t *start, size_t length) +// { +// yaml_char_t *end = start+length; +// yaml_char_t *pointer = start; +// +// while (pointer < end) { +// unsigned char octet; +// unsigned int width; +// unsigned int value; +// size_t k; +// +// octet = pointer[0]; +// width = (octet & 0x80) == 0x00 ? 1 : +// (octet & 0xE0) == 0xC0 ? 2 : +// (octet & 0xF0) == 0xE0 ? 3 : +// (octet & 0xF8) == 0xF0 ? 4 : 0; +// value = (octet & 0x80) == 0x00 ? octet & 0x7F : +// (octet & 0xE0) == 0xC0 ? octet & 0x1F : +// (octet & 0xF0) == 0xE0 ? octet & 0x0F : +// (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; +// if (!width) return 0; +// if (pointer+width > end) return 0; +// for (k = 1; k < width; k ++) { +// octet = pointer[k]; +// if ((octet & 0xC0) != 0x80) return 0; +// value = (value << 6) + (octet & 0x3F); +// } +// if (!((width == 1) || +// (width == 2 && value >= 0x80) || +// (width == 3 && value >= 0x800) || +// (width == 4 && value >= 0x10000))) return 0; +// +// pointer += width; +// } +// +// return 1; +// } + +/* + * Create STREAM-START. + */ + +func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) { + *event = yaml_event_t{ + event_type: yaml_STREAM_START_EVENT, + encoding: encoding, + } +} + +/* + * Create STREAM-END. + */ + +func yaml_stream_end_event_initialize(event *yaml_event_t) { + *event = yaml_event_t{ + event_type: yaml_STREAM_END_EVENT, + } +} + +/* + * Create DOCUMENT-START. + */ + +func yaml_document_start_event_initialize(event *yaml_event_t, + version_directive *yaml_version_directive_t, + tag_directives []yaml_tag_directive_t, + implicit bool) { + *event = yaml_event_t{ + event_type: yaml_DOCUMENT_START_EVENT, + version_directive: version_directive, + tag_directives: tag_directives, + implicit: implicit, + } +} + +/* + * Create DOCUMENT-END. + */ + +func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) { + *event = yaml_event_t{ + event_type: yaml_DOCUMENT_END_EVENT, + implicit: implicit, + } +} + +/* + * Create ALIAS. + */ + +func yaml_alias_event_initialize(event *yaml_event_t, anchor []byte) { + *event = yaml_event_t{ + event_type: yaml_ALIAS_EVENT, + anchor: anchor, + } +} + +/* + * Create SCALAR. + */ + +func yaml_scalar_event_initialize(event *yaml_event_t, + anchor []byte, tag []byte, + value []byte, + plain_implicit bool, quoted_implicit bool, + style yaml_scalar_style_t) { + + *event = yaml_event_t{ + event_type: yaml_SCALAR_EVENT, + anchor: anchor, + tag: tag, + value: value, + implicit: plain_implicit, + quoted_implicit: quoted_implicit, + style: yaml_style_t(style), + } +} + +/* + * Create SEQUENCE-START. + */ + +func yaml_sequence_start_event_initialize(event *yaml_event_t, + anchor []byte, tag []byte, implicit bool, style yaml_sequence_style_t) { + *event = yaml_event_t{ + event_type: yaml_SEQUENCE_START_EVENT, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(style), + } +} + +/* + * Create SEQUENCE-END. + */ + +func yaml_sequence_end_event_initialize(event *yaml_event_t) { + *event = yaml_event_t{ + event_type: yaml_SEQUENCE_END_EVENT, + } +} + +/* + * Create MAPPING-START. + */ + +func yaml_mapping_start_event_initialize(event *yaml_event_t, + anchor []byte, tag []byte, implicit bool, style yaml_mapping_style_t) { + *event = yaml_event_t{ + event_type: yaml_MAPPING_START_EVENT, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(style), + } +} + +/* + * Create MAPPING-END. + */ + +func yaml_mapping_end_event_initialize(event *yaml_event_t) { + *event = yaml_event_t{ + event_type: yaml_MAPPING_END_EVENT, + } +} + +/* + * Destroy an event object. + */ + +func yaml_event_delete(event *yaml_event_t) { + *event = yaml_event_t{} +} + +// /* +// * Create a document object. +// */ +// +// func yaml_document_initialize(document *yaml_document_t, +// version_directive *yaml_version_directive_t, +// tag_directives []yaml_tag_directive_t, +// start_implicit, end_implicit bool) bool { +// +// +// { +// struct { +// YAML_error_type_t error; +// } context; +// struct { +// yaml_node_t *start; +// yaml_node_t *end; +// yaml_node_t *top; +// } nodes = { NULL, NULL, NULL }; +// yaml_version_directive_t *version_directive_copy = NULL; +// struct { +// yaml_tag_directive_t *start; +// yaml_tag_directive_t *end; +// yaml_tag_directive_t *top; +// } tag_directives_copy = { NULL, NULL, NULL }; +// yaml_tag_directive_t value = { NULL, NULL }; +// YAML_mark_t mark = { 0, 0, 0 }; +// +// assert(document); /* Non-NULL document object is expected. */ +// assert((tag_directives_start && tag_directives_end) || +// (tag_directives_start == tag_directives_end)); +// /* Valid tag directives are expected. */ +// +// if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error; +// +// if (version_directive) { +// version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t)); +// if (!version_directive_copy) goto error; +// version_directive_copy.major = version_directive.major; +// version_directive_copy.minor = version_directive.minor; +// } +// +// if (tag_directives_start != tag_directives_end) { +// yaml_tag_directive_t *tag_directive; +// if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE)) +// goto error; +// for (tag_directive = tag_directives_start; +// tag_directive != tag_directives_end; tag_directive ++) { +// assert(tag_directive.handle); +// assert(tag_directive.prefix); +// if (!yaml_check_utf8(tag_directive.handle, +// strlen((char *)tag_directive.handle))) +// goto error; +// if (!yaml_check_utf8(tag_directive.prefix, +// strlen((char *)tag_directive.prefix))) +// goto error; +// value.handle = yaml_strdup(tag_directive.handle); +// value.prefix = yaml_strdup(tag_directive.prefix); +// if (!value.handle || !value.prefix) goto error; +// if (!PUSH(&context, tag_directives_copy, value)) +// goto error; +// value.handle = NULL; +// value.prefix = NULL; +// } +// } +// +// DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy, +// tag_directives_copy.start, tag_directives_copy.top, +// start_implicit, end_implicit, mark, mark); +// +// return 1; +// +// error: +// STACK_DEL(&context, nodes); +// yaml_free(version_directive_copy); +// while (!STACK_EMPTY(&context, tag_directives_copy)) { +// yaml_tag_directive_t value = POP(&context, tag_directives_copy); +// yaml_free(value.handle); +// yaml_free(value.prefix); +// } +// STACK_DEL(&context, tag_directives_copy); +// yaml_free(value.handle); +// yaml_free(value.prefix); +// +// return 0; +// } +// +// /* +// * Destroy a document object. +// */ +// +// yaml_DECLARE(void) +// yaml_document_delete(document *yaml_document_t) +// { +// struct { +// YAML_error_type_t error; +// } context; +// yaml_tag_directive_t *tag_directive; +// +// context.error = yaml_NO_ERROR; /* Eliminate a compliler warning. */ +// +// assert(document); /* Non-NULL document object is expected. */ +// +// while (!STACK_EMPTY(&context, document.nodes)) { +// yaml_node_t node = POP(&context, document.nodes); +// yaml_free(node.tag); +// switch (node.type) { +// case yaml_SCALAR_NODE: +// yaml_free(node.data.scalar.value); +// break; +// case yaml_SEQUENCE_NODE: +// STACK_DEL(&context, node.data.sequence.items); +// break; +// case yaml_MAPPING_NODE: +// STACK_DEL(&context, node.data.mapping.pairs); +// break; +// default: +// assert(0); /* Should not happen. */ +// } +// } +// STACK_DEL(&context, document.nodes); +// +// yaml_free(document.version_directive); +// for (tag_directive = document.tag_directives.start; +// tag_directive != document.tag_directives.end; +// tag_directive++) { +// yaml_free(tag_directive.handle); +// yaml_free(tag_directive.prefix); +// } +// yaml_free(document.tag_directives.start); +// +// memset(document, 0, sizeof(yaml_document_t)); +// } +// +// /** +// * Get a document node. +// */ +// +// yaml_DECLARE(yaml_node_t *) +// yaml_document_get_node(document *yaml_document_t, int index) +// { +// assert(document); /* Non-NULL document object is expected. */ +// +// if (index > 0 && document.nodes.start + index <= document.nodes.top) { +// return document.nodes.start + index - 1; +// } +// return NULL; +// } +// +// /** +// * Get the root object. +// */ +// +// yaml_DECLARE(yaml_node_t *) +// yaml_document_get_root_node(document *yaml_document_t) +// { +// assert(document); /* Non-NULL document object is expected. */ +// +// if (document.nodes.top != document.nodes.start) { +// return document.nodes.start; +// } +// return NULL; +// } +// +// /* +// * Add a scalar node to a document. +// */ +// +// yaml_DECLARE(int) +// yaml_document_add_scalar(document *yaml_document_t, +// yaml_char_t *tag, yaml_char_t *value, int length, +// yaml_scalar_style_t style) +// { +// struct { +// YAML_error_type_t error; +// } context; +// YAML_mark_t mark = { 0, 0, 0 }; +// yaml_char_t *tag_copy = NULL; +// yaml_char_t *value_copy = NULL; +// yaml_node_t node; +// +// assert(document); /* Non-NULL document object is expected. */ +// assert(value); /* Non-NULL value is expected. */ +// +// if (!tag) { +// tag = (yaml_char_t *)yaml_DEFAULT_SCALAR_TAG; +// } +// +// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; +// tag_copy = yaml_strdup(tag); +// if (!tag_copy) goto error; +// +// if (length < 0) { +// length = strlen((char *)value); +// } +// +// if (!yaml_check_utf8(value, length)) goto error; +// value_copy = yaml_malloc(length+1); +// if (!value_copy) goto error; +// memcpy(value_copy, value, length); +// value_copy[length] = '\0'; +// +// SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark); +// if (!PUSH(&context, document.nodes, node)) goto error; +// +// return document.nodes.top - document.nodes.start; +// +// error: +// yaml_free(tag_copy); +// yaml_free(value_copy); +// +// return 0; +// } +// +// /* +// * Add a sequence node to a document. +// */ +// +// yaml_DECLARE(int) +// yaml_document_add_sequence(document *yaml_document_t, +// yaml_char_t *tag, yaml_sequence_style_t style) +// { +// struct { +// YAML_error_type_t error; +// } context; +// YAML_mark_t mark = { 0, 0, 0 }; +// yaml_char_t *tag_copy = NULL; +// struct { +// yaml_node_item_t *start; +// yaml_node_item_t *end; +// yaml_node_item_t *top; +// } items = { NULL, NULL, NULL }; +// yaml_node_t node; +// +// assert(document); /* Non-NULL document object is expected. */ +// +// if (!tag) { +// tag = (yaml_char_t *)yaml_DEFAULT_SEQUENCE_TAG; +// } +// +// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; +// tag_copy = yaml_strdup(tag); +// if (!tag_copy) goto error; +// +// if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error; +// +// SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end, +// style, mark, mark); +// if (!PUSH(&context, document.nodes, node)) goto error; +// +// return document.nodes.top - document.nodes.start; +// +// error: +// STACK_DEL(&context, items); +// yaml_free(tag_copy); +// +// return 0; +// } +// +// /* +// * Add a mapping node to a document. +// */ +// +// yaml_DECLARE(int) +// yaml_document_add_mapping(document *yaml_document_t, +// yaml_char_t *tag, yaml_mapping_style_t style) +// { +// struct { +// YAML_error_type_t error; +// } context; +// YAML_mark_t mark = { 0, 0, 0 }; +// yaml_char_t *tag_copy = NULL; +// struct { +// yaml_node_pair_t *start; +// yaml_node_pair_t *end; +// yaml_node_pair_t *top; +// } pairs = { NULL, NULL, NULL }; +// yaml_node_t node; +// +// assert(document); /* Non-NULL document object is expected. */ +// +// if (!tag) { +// tag = (yaml_char_t *)yaml_DEFAULT_MAPPING_TAG; +// } +// +// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; +// tag_copy = yaml_strdup(tag); +// if (!tag_copy) goto error; +// +// if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error; +// +// MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end, +// style, mark, mark); +// if (!PUSH(&context, document.nodes, node)) goto error; +// +// return document.nodes.top - document.nodes.start; +// +// error: +// STACK_DEL(&context, pairs); +// yaml_free(tag_copy); +// +// return 0; +// } +// +// /* +// * Append an item to a sequence node. +// */ +// +// yaml_DECLARE(int) +// yaml_document_append_sequence_item(document *yaml_document_t, +// int sequence, int item) +// { +// struct { +// YAML_error_type_t error; +// } context; +// +// assert(document); /* Non-NULL document is required. */ +// assert(sequence > 0 +// && document.nodes.start + sequence <= document.nodes.top); +// /* Valid sequence id is required. */ +// assert(document.nodes.start[sequence-1].type == yaml_SEQUENCE_NODE); +// /* A sequence node is required. */ +// assert(item > 0 && document.nodes.start + item <= document.nodes.top); +// /* Valid item id is required. */ +// +// if (!PUSH(&context, +// document.nodes.start[sequence-1].data.sequence.items, item)) +// return 0; +// +// return 1; +// } +// +// /* +// * Append a pair of a key and a value to a mapping node. +// */ +// +// yaml_DECLARE(int) +// yaml_document_append_mapping_pair(document *yaml_document_t, +// int mapping, int key, int value) +// { +// struct { +// YAML_error_type_t error; +// } context; +// +// yaml_node_pair_t pair; +// +// assert(document); /* Non-NULL document is required. */ +// assert(mapping > 0 +// && document.nodes.start + mapping <= document.nodes.top); +// /* Valid mapping id is required. */ +// assert(document.nodes.start[mapping-1].type == yaml_MAPPING_NODE); +// /* A mapping node is required. */ +// assert(key > 0 && document.nodes.start + key <= document.nodes.top); +// /* Valid key id is required. */ +// assert(value > 0 && document.nodes.start + value <= document.nodes.top); +// /* Valid value id is required. */ +// +// pair.key = key; +// pair.value = value; +// +// if (!PUSH(&context, +// document.nodes.start[mapping-1].data.mapping.pairs, pair)) +// return 0; +// +// return 1; +// } +// diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/decode.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/decode.go new file mode 100644 index 00000000..dcc1b89c --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/decode.go @@ -0,0 +1,622 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "bytes" + "errors" + "fmt" + "io" + "reflect" + "runtime" + "strconv" + "strings" +) + +type Unmarshaler interface { + UnmarshalYAML(tag string, value interface{}) error +} + +// A Number represents a JSON number literal. +type Number string + +// String returns the literal text of the number. +func (n Number) String() string { return string(n) } + +// Float64 returns the number as a float64. +func (n Number) Float64() (float64, error) { + return strconv.ParseFloat(string(n), 64) +} + +// Int64 returns the number as an int64. +func (n Number) Int64() (int64, error) { + return strconv.ParseInt(string(n), 10, 64) +} + +type Decoder struct { + parser yaml_parser_t + event yaml_event_t + replay_events []yaml_event_t + useNumber bool + + anchors map[string][]yaml_event_t + tracking_anchors [][]yaml_event_t +} + +type ParserError struct { + ErrorType YAML_error_type_t + Context string + ContextMark YAML_mark_t + Problem string + ProblemMark YAML_mark_t +} + +func (e *ParserError) Error() string { + return fmt.Sprintf("yaml: [%s] %s at line %d, column %d", e.Context, e.Problem, e.ProblemMark.line+1, e.ProblemMark.column+1) +} + +type UnexpectedEventError struct { + Value string + EventType yaml_event_type_t + At YAML_mark_t +} + +func (e *UnexpectedEventError) Error() string { + return fmt.Sprintf("yaml: Unexpect event [%d]: '%s' at line %d, column %d", e.EventType, e.Value, e.At.line+1, e.At.column+1) +} + +func recovery(err *error) { + if r := recover(); r != nil { + if _, ok := r.(runtime.Error); ok { + panic(r) + } + + var tmpError error + switch r := r.(type) { + case error: + tmpError = r + case string: + tmpError = errors.New(r) + default: + tmpError = errors.New("Unknown panic: " + reflect.ValueOf(r).String()) + } + + *err = tmpError + } +} + +func Unmarshal(data []byte, v interface{}) error { + d := NewDecoder(bytes.NewBuffer(data)) + return d.Decode(v) +} + +func NewDecoder(r io.Reader) *Decoder { + d := &Decoder{ + anchors: make(map[string][]yaml_event_t), + tracking_anchors: make([][]yaml_event_t, 1), + } + yaml_parser_initialize(&d.parser) + yaml_parser_set_input_reader(&d.parser, r) + return d +} + +func (d *Decoder) Decode(v interface{}) (err error) { + defer recovery(&err) + + rv := reflect.ValueOf(v) + if rv.Kind() != reflect.Ptr || rv.IsNil() { + return fmt.Errorf("Expected a pointer or nil but was a %s at %s", rv.String(), d.event.start_mark) + } + + if d.event.event_type == yaml_NO_EVENT { + d.nextEvent() + + if d.event.event_type != yaml_STREAM_START_EVENT { + return errors.New("Invalid stream") + } + + d.nextEvent() + } + + d.document(rv) + return nil +} + +func (d *Decoder) UseNumber() { d.useNumber = true } + +func (d *Decoder) error(err error) { + panic(err) +} + +func (d *Decoder) nextEvent() { + if d.event.event_type == yaml_STREAM_END_EVENT { + d.error(errors.New("The stream is closed")) + } + + if d.replay_events != nil { + d.event = d.replay_events[0] + if len(d.replay_events) == 1 { + d.replay_events = nil + } else { + d.replay_events = d.replay_events[1:] + } + } else { + if !yaml_parser_parse(&d.parser, &d.event) { + yaml_event_delete(&d.event) + + d.error(&ParserError{ + ErrorType: d.parser.error, + Context: d.parser.context, + ContextMark: d.parser.context_mark, + Problem: d.parser.problem, + ProblemMark: d.parser.problem_mark, + }) + } + } + + last := len(d.tracking_anchors) + // skip aliases when tracking an anchor + if last > 0 && d.event.event_type != yaml_ALIAS_EVENT { + d.tracking_anchors[last-1] = append(d.tracking_anchors[last-1], d.event) + } +} + +func (d *Decoder) document(rv reflect.Value) { + if d.event.event_type != yaml_DOCUMENT_START_EVENT { + d.error(fmt.Errorf("Expected document start at %s", d.event.start_mark)) + } + + d.nextEvent() + d.parse(rv) + + if d.event.event_type != yaml_DOCUMENT_END_EVENT { + d.error(fmt.Errorf("Expected document end at %s", d.event.start_mark)) + } + + d.nextEvent() +} + +func (d *Decoder) parse(rv reflect.Value) { + if !rv.IsValid() { + // skip ahead since we cannot store + d.valueInterface() + return + } + + anchor := string(d.event.anchor) + switch d.event.event_type { + case yaml_SEQUENCE_START_EVENT: + d.begin_anchor(anchor) + d.sequence(rv) + d.end_anchor(anchor) + case yaml_MAPPING_START_EVENT: + d.begin_anchor(anchor) + d.mapping(rv) + d.end_anchor(anchor) + case yaml_SCALAR_EVENT: + d.begin_anchor(anchor) + d.scalar(rv) + d.end_anchor(anchor) + case yaml_ALIAS_EVENT: + d.alias(rv) + case yaml_DOCUMENT_END_EVENT: + default: + d.error(&UnexpectedEventError{ + Value: string(d.event.value), + EventType: d.event.event_type, + At: d.event.start_mark, + }) + } +} + +func (d *Decoder) begin_anchor(anchor string) { + if anchor != "" { + events := []yaml_event_t{d.event} + d.tracking_anchors = append(d.tracking_anchors, events) + } +} + +func (d *Decoder) end_anchor(anchor string) { + if anchor != "" { + events := d.tracking_anchors[len(d.tracking_anchors)-1] + d.tracking_anchors = d.tracking_anchors[0 : len(d.tracking_anchors)-1] + // remove the anchor, replaying events shouldn't have anchors + events[0].anchor = nil + // we went one too many, remove the extra event + events = events[:len(events)-1] + // if nested, append to all the other anchors + for i, e := range d.tracking_anchors { + d.tracking_anchors[i] = append(e, events...) + } + d.anchors[anchor] = events + } +} + +func (d *Decoder) indirect(v reflect.Value, decodingNull bool) (Unmarshaler, reflect.Value) { + // If v is a named type and is addressable, + // start with its address, so that if the type has pointer methods, + // we find them. + if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() { + v = v.Addr() + } + for { + // Load value from interface, but only if the result will be + // usefully addressable. + if v.Kind() == reflect.Interface && !v.IsNil() { + e := v.Elem() + if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) { + v = e + continue + } + } + + if v.Kind() != reflect.Ptr { + break + } + + if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() { + break + } + + if v.IsNil() { + v.Set(reflect.New(v.Type().Elem())) + } + + if v.Type().NumMethod() > 0 { + if u, ok := v.Interface().(Unmarshaler); ok { + var temp interface{} + return u, reflect.ValueOf(&temp) + } + } + + v = v.Elem() + } + + return nil, v +} + +func (d *Decoder) sequence(v reflect.Value) { + if d.event.event_type != yaml_SEQUENCE_START_EVENT { + d.error(fmt.Errorf("Expected sequence start at %s", d.event.start_mark)) + } + + u, pv := d.indirect(v, false) + if u != nil { + defer func() { + if err := u.UnmarshalYAML(yaml_SEQ_TAG, pv.Interface()); err != nil { + d.error(err) + } + }() + _, pv = d.indirect(pv, false) + } + + v = pv + + // Check type of target. + switch v.Kind() { + case reflect.Interface: + if v.NumMethod() == 0 { + // Decoding into nil interface? Switch to non-reflect code. + v.Set(reflect.ValueOf(d.sequenceInterface())) + return + } + // Otherwise it's invalid. + fallthrough + default: + d.error(fmt.Errorf("Expected an array, slice or interface{} but was a %s at %s", v, d.event.start_mark)) + case reflect.Array: + case reflect.Slice: + break + } + + d.nextEvent() + + i := 0 +done: + for { + switch d.event.event_type { + case yaml_SEQUENCE_END_EVENT, yaml_DOCUMENT_END_EVENT: + break done + } + + // Get element of array, growing if necessary. + if v.Kind() == reflect.Slice { + // Grow slice if necessary + if i >= v.Cap() { + newcap := v.Cap() + v.Cap()/2 + if newcap < 4 { + newcap = 4 + } + newv := reflect.MakeSlice(v.Type(), v.Len(), newcap) + reflect.Copy(newv, v) + v.Set(newv) + } + if i >= v.Len() { + v.SetLen(i + 1) + } + } + + if i < v.Len() { + // Decode into element. + d.parse(v.Index(i)) + } else { + // Ran out of fixed array: skip. + d.parse(reflect.Value{}) + } + i++ + } + + if i < v.Len() { + if v.Kind() == reflect.Array { + // Array. Zero the rest. + z := reflect.Zero(v.Type().Elem()) + for ; i < v.Len(); i++ { + v.Index(i).Set(z) + } + } else { + v.SetLen(i) + } + } + if i == 0 && v.Kind() == reflect.Slice { + v.Set(reflect.MakeSlice(v.Type(), 0, 0)) + } + + if d.event.event_type != yaml_DOCUMENT_END_EVENT { + d.nextEvent() + } +} + +func (d *Decoder) mapping(v reflect.Value) { + u, pv := d.indirect(v, false) + if u != nil { + defer func() { + if err := u.UnmarshalYAML(yaml_MAP_TAG, pv.Interface()); err != nil { + d.error(err) + } + }() + _, pv = d.indirect(pv, false) + } + v = pv + + // Decoding into nil interface? Switch to non-reflect code. + if v.Kind() == reflect.Interface && v.NumMethod() == 0 { + v.Set(reflect.ValueOf(d.mappingInterface())) + return + } + + // Check type of target: struct or map[X]Y + switch v.Kind() { + case reflect.Struct: + d.mappingStruct(v) + return + case reflect.Map: + default: + d.error(fmt.Errorf("Expected a struct or map but was a %s at %s ", v, d.event.start_mark)) + } + + mapt := v.Type() + if v.IsNil() { + v.Set(reflect.MakeMap(mapt)) + } + + d.nextEvent() + + keyt := mapt.Key() + mapElemt := mapt.Elem() + + var mapElem reflect.Value +done: + for { + switch d.event.event_type { + case yaml_MAPPING_END_EVENT: + break done + case yaml_DOCUMENT_END_EVENT: + return + } + + key := reflect.New(keyt) + d.parse(key.Elem()) + + if !mapElem.IsValid() { + mapElem = reflect.New(mapElemt).Elem() + } else { + mapElem.Set(reflect.Zero(mapElemt)) + } + + d.parse(mapElem) + + v.SetMapIndex(key.Elem(), mapElem) + } + + d.nextEvent() +} + +func (d *Decoder) mappingStruct(v reflect.Value) { + + structt := v.Type() + fields := cachedTypeFields(structt) + + d.nextEvent() + +done: + for { + switch d.event.event_type { + case yaml_MAPPING_END_EVENT: + break done + case yaml_DOCUMENT_END_EVENT: + return + } + + key := "" + d.parse(reflect.ValueOf(&key)) + + // Figure out field corresponding to key. + var subv reflect.Value + + var f *field + for i := range fields { + ff := &fields[i] + if ff.name == key { + f = ff + break + } + + if f == nil && strings.EqualFold(ff.name, key) { + f = ff + } + } + + if f != nil { + subv = v + for _, i := range f.index { + if subv.Kind() == reflect.Ptr { + if subv.IsNil() { + subv.Set(reflect.New(subv.Type().Elem())) + } + subv = subv.Elem() + } + subv = subv.Field(i) + } + } + d.parse(subv) + } + + d.nextEvent() +} + +func (d *Decoder) scalar(v reflect.Value) { + val := string(d.event.value) + wantptr := null_values[val] + + u, pv := d.indirect(v, wantptr) + + var tag string + if u != nil { + defer func() { + if err := u.UnmarshalYAML(tag, pv.Interface()); err != nil { + d.error(err) + } + }() + + _, pv = d.indirect(pv, wantptr) + } + v = pv + + var err error + tag, err = resolve(d.event, v, d.useNumber) + if err != nil { + d.error(err) + } + + d.nextEvent() +} + +func (d *Decoder) alias(rv reflect.Value) { + val, ok := d.anchors[string(d.event.anchor)] + if !ok { + d.error(fmt.Errorf("missing anchor: '%s' at %s", d.event.anchor, d.event.start_mark)) + } + + d.replay_events = val + d.nextEvent() + d.parse(rv) +} + +func (d *Decoder) valueInterface() interface{} { + var v interface{} + + anchor := string(d.event.anchor) + switch d.event.event_type { + case yaml_SEQUENCE_START_EVENT: + d.begin_anchor(anchor) + v = d.sequenceInterface() + case yaml_MAPPING_START_EVENT: + d.begin_anchor(anchor) + v = d.mappingInterface() + case yaml_SCALAR_EVENT: + d.begin_anchor(anchor) + v = d.scalarInterface() + case yaml_ALIAS_EVENT: + rv := reflect.ValueOf(&v) + d.alias(rv) + return v + case yaml_DOCUMENT_END_EVENT: + d.error(&UnexpectedEventError{ + Value: string(d.event.value), + EventType: d.event.event_type, + At: d.event.start_mark, + }) + + } + d.end_anchor(anchor) + + return v +} + +func (d *Decoder) scalarInterface() interface{} { + _, v := resolveInterface(d.event, d.useNumber) + + d.nextEvent() + return v +} + +// sequenceInterface is like sequence but returns []interface{}. +func (d *Decoder) sequenceInterface() []interface{} { + var v = make([]interface{}, 0) + + d.nextEvent() + +done: + for { + switch d.event.event_type { + case yaml_SEQUENCE_END_EVENT, yaml_DOCUMENT_END_EVENT: + break done + } + + v = append(v, d.valueInterface()) + } + + if d.event.event_type != yaml_DOCUMENT_END_EVENT { + d.nextEvent() + } + + return v +} + +// mappingInterface is like mapping but returns map[interface{}]interface{}. +func (d *Decoder) mappingInterface() map[interface{}]interface{} { + m := make(map[interface{}]interface{}) + + d.nextEvent() + +done: + for { + switch d.event.event_type { + case yaml_MAPPING_END_EVENT, yaml_DOCUMENT_END_EVENT: + break done + } + + key := d.valueInterface() + + // Read value. + m[key] = d.valueInterface() + } + + if d.event.event_type != yaml_DOCUMENT_END_EVENT { + d.nextEvent() + } + + return m +} diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/emitter.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/emitter.go new file mode 100644 index 00000000..bd2014f3 --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/emitter.go @@ -0,0 +1,2072 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "bytes" +) + +var default_tag_directives = []yaml_tag_directive_t{ + {[]byte("!"), []byte("!")}, + {[]byte("!!"), []byte("tag:yaml.org,2002:")}, +} + +/* + * Flush the buffer if needed. + */ + +func flush(emitter *yaml_emitter_t) bool { + if emitter.buffer_pos+5 >= len(emitter.buffer) { + return yaml_emitter_flush(emitter) + } + return true +} + +/* + * Put a character to the output buffer. + */ +func put(emitter *yaml_emitter_t, value byte) bool { + if !flush(emitter) { + return false + } + + emitter.buffer[emitter.buffer_pos] = value + emitter.buffer_pos++ + emitter.column++ + return true +} + +/* + * Put a line break to the output buffer. + */ + +func put_break(emitter *yaml_emitter_t) bool { + if !flush(emitter) { + return false + } + switch emitter.line_break { + case yaml_CR_BREAK: + emitter.buffer[emitter.buffer_pos] = '\r' + emitter.buffer_pos++ + case yaml_LN_BREAK: + emitter.buffer[emitter.buffer_pos] = '\n' + emitter.buffer_pos++ + case yaml_CRLN_BREAK: + emitter.buffer[emitter.buffer_pos] = '\r' + emitter.buffer[emitter.buffer_pos] = '\n' + emitter.buffer_pos += 2 + default: + return false + } + emitter.column = 0 + emitter.line++ + return true +} + +/* + * Copy a character from a string into buffer. + */ +func write(emitter *yaml_emitter_t, src []byte, src_pos *int) bool { + if !flush(emitter) { + return false + } + copy_bytes(emitter.buffer, &emitter.buffer_pos, src, src_pos) + emitter.column++ + return true +} + +/* + * Copy a line break character from a string into buffer. + */ + +func write_break(emitter *yaml_emitter_t, src []byte, src_pos *int) bool { + if src[*src_pos] == '\n' { + if !put_break(emitter) { + return false + } + *src_pos++ + } else { + if !write(emitter, src, src_pos) { + return false + } + emitter.column = 0 + emitter.line++ + } + + return true +} + +/* + * Set an emitter error and return 0. + */ + +func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool { + emitter.error = yaml_EMITTER_ERROR + emitter.problem = problem + return false +} + +/* + * Emit an event. + */ + +func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool { + emitter.events = append(emitter.events, *event) + for !yaml_emitter_need_more_events(emitter) { + event := &emitter.events[emitter.events_head] + if !yaml_emitter_analyze_event(emitter, event) { + return false + } + if !yaml_emitter_state_machine(emitter, event) { + return false + } + yaml_event_delete(event) + emitter.events_head++ + } + return true +} + +/* + * Check if we need to accumulate more events before emitting. + * + * We accumulate extra + * - 1 event for DOCUMENT-START + * - 2 events for SEQUENCE-START + * - 3 events for MAPPING-START + */ + +func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool { + if emitter.events_head == len(emitter.events) { + return true + } + + accumulate := 0 + switch emitter.events[emitter.events_head].event_type { + case yaml_DOCUMENT_START_EVENT: + accumulate = 1 + case yaml_SEQUENCE_START_EVENT: + accumulate = 2 + case yaml_MAPPING_START_EVENT: + accumulate = 3 + default: + return false + } + + if len(emitter.events)-emitter.events_head > accumulate { + return false + } + + level := 0 + for i := emitter.events_head; i < len(emitter.events); i++ { + switch emitter.events[i].event_type { + case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT: + level++ + case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT: + level-- + } + + if level == 0 { + return false + } + } + return true +} + +/* + * Append a directive to the directives stack. + */ + +func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, + value *yaml_tag_directive_t, allow_duplicates bool) bool { + + for i := range emitter.tag_directives { + + if bytes.Equal(value.handle, emitter.tag_directives[i].handle) { + if allow_duplicates { + return true + } + return yaml_emitter_set_emitter_error(emitter, "duplicat %TAG directive") + } + } + + tag_copy := yaml_tag_directive_t{ + handle: value.handle, + prefix: value.prefix, + } + + emitter.tag_directives = append(emitter.tag_directives, tag_copy) + + return true +} + +/* + * Increase the indentation level. + */ + +func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow bool, indentless bool) bool { + + emitter.indents = append(emitter.indents, emitter.indent) + + if emitter.indent < 0 { + if flow { + emitter.indent = emitter.best_indent + } else { + emitter.indent = 0 + } + } else if !indentless { + emitter.indent += emitter.best_indent + } + + return true +} + +/* + * State dispatcher. + */ + +func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool { + switch emitter.state { + case yaml_EMIT_STREAM_START_STATE: + return yaml_emitter_emit_stream_start(emitter, event) + + case yaml_EMIT_FIRST_DOCUMENT_START_STATE: + return yaml_emitter_emit_document_start(emitter, event, true) + + case yaml_EMIT_DOCUMENT_START_STATE: + return yaml_emitter_emit_document_start(emitter, event, false) + + case yaml_EMIT_DOCUMENT_CONTENT_STATE: + return yaml_emitter_emit_document_content(emitter, event) + + case yaml_EMIT_DOCUMENT_END_STATE: + return yaml_emitter_emit_document_end(emitter, event) + + case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE: + return yaml_emitter_emit_flow_sequence_item(emitter, event, true) + + case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE: + return yaml_emitter_emit_flow_sequence_item(emitter, event, false) + + case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE: + return yaml_emitter_emit_flow_mapping_key(emitter, event, true) + + case yaml_EMIT_FLOW_MAPPING_KEY_STATE: + return yaml_emitter_emit_flow_mapping_key(emitter, event, false) + + case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE: + return yaml_emitter_emit_flow_mapping_value(emitter, event, true) + + case yaml_EMIT_FLOW_MAPPING_VALUE_STATE: + return yaml_emitter_emit_flow_mapping_value(emitter, event, false) + + case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE: + return yaml_emitter_emit_block_sequence_item(emitter, event, true) + + case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE: + return yaml_emitter_emit_block_sequence_item(emitter, event, false) + + case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE: + return yaml_emitter_emit_block_mapping_key(emitter, event, true) + + case yaml_EMIT_BLOCK_MAPPING_KEY_STATE: + return yaml_emitter_emit_block_mapping_key(emitter, event, false) + + case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE: + return yaml_emitter_emit_block_mapping_value(emitter, event, true) + + case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE: + return yaml_emitter_emit_block_mapping_value(emitter, event, false) + + case yaml_EMIT_END_STATE: + return yaml_emitter_set_emitter_error(emitter, + "expected nothing after STREAM-END") + + } + + panic("invalid state") +} + +/* + * Expect STREAM-START. + */ + +func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool { + + if event.event_type != yaml_STREAM_START_EVENT { + return yaml_emitter_set_emitter_error(emitter, + "expected STREAM-START") + } + + if emitter.encoding == yaml_ANY_ENCODING { + emitter.encoding = event.encoding + + if emitter.encoding == yaml_ANY_ENCODING { + emitter.encoding = yaml_UTF8_ENCODING + } + } + + if emitter.best_indent < 2 || emitter.best_indent > 9 { + emitter.best_indent = 2 + } + + if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 { + emitter.best_width = 80 + } + + if emitter.best_width < 0 { + emitter.best_width = 1<<31 - 1 + } + + if emitter.line_break == yaml_ANY_BREAK { + emitter.line_break = yaml_LN_BREAK + } + + emitter.indent = -1 + + emitter.line = 0 + emitter.column = 0 + emitter.whitespace = true + emitter.indention = true + + if emitter.encoding != yaml_UTF8_ENCODING { + if !yaml_emitter_write_bom(emitter) { + return false + } + } + + emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE + + return true +} + +/* + * Expect DOCUMENT-START or STREAM-END. + */ + +func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, + event *yaml_event_t, first bool) bool { + + if event.event_type == yaml_DOCUMENT_START_EVENT { + if event.version_directive != nil { + if !yaml_emitter_analyze_version_directive(emitter, + *event.version_directive) { + return false + } + } + + for i := range event.tag_directives { + tag_directive := &event.tag_directives[i] + + if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) { + return false + } + if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) { + return false + } + } + + for i := range default_tag_directives { + if !yaml_emitter_append_tag_directive(emitter, &default_tag_directives[i], true) { + return false + } + } + + implicit := event.implicit + if !first || emitter.canonical { + implicit = false + } + + if (event.version_directive != nil || len(event.tag_directives) > 0) && + emitter.open_ended { + if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + + if event.version_directive != nil { + implicit = false + if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) { + return false + } + + if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) { + return false + } + + if !yaml_emitter_write_indent(emitter) { + return false + } + } + + if len(event.tag_directives) > 0 { + implicit = false + for i := range event.tag_directives { + tag_directive := &event.tag_directives[i] + + if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) { + return false + } + if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) { + return false + } + if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + } + + if yaml_emitter_check_empty_document(emitter) { + implicit = false + } + + if !implicit { + if !yaml_emitter_write_indent(emitter) { + return false + } + if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) { + return false + } + + if emitter.canonical { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + } + + emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE + + return true + } else if event.event_type == yaml_STREAM_END_EVENT { + if emitter.open_ended { + if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + + if !yaml_emitter_flush(emitter) { + return false + } + + emitter.state = yaml_EMIT_END_STATE + + return true + } + + return yaml_emitter_set_emitter_error(emitter, + "expected DOCUMENT-START or STREAM-END") +} + +/* + * Expect the root node. + */ + +func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool { + emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE) + + return yaml_emitter_emit_node(emitter, event, true, false, false, false) +} + +/* + * Expect DOCUMENT-END. + */ + +func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool { + + if event.event_type != yaml_DOCUMENT_END_EVENT { + return yaml_emitter_set_emitter_error(emitter, + "expected DOCUMENT-END") + } + + if !yaml_emitter_write_indent(emitter) { + return false + } + if !event.implicit { + if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !yaml_emitter_flush(emitter) { + return false + } + + emitter.state = yaml_EMIT_DOCUMENT_START_STATE + emitter.tag_directives = emitter.tag_directives[:0] + return true +} + +/* + * + * Expect a flow item node. + */ + +func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { + if first { + if !yaml_emitter_write_indicator(emitter, []byte("["), true, true, false) { + return false + } + if !yaml_emitter_increase_indent(emitter, true, false) { + return false + } + emitter.flow_level++ + } + + if event.event_type == yaml_SEQUENCE_END_EVENT { + emitter.flow_level-- + emitter.indent = emitter.indents[len(emitter.indents)-1] + emitter.indents = emitter.indents[:len(emitter.indents)-1] + if emitter.canonical && !first { + if !yaml_emitter_write_indicator(emitter, []byte(","), false, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !yaml_emitter_write_indicator(emitter, []byte("]"), false, false, false) { + return false + } + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + + return true + } + + if !first { + if !yaml_emitter_write_indicator(emitter, []byte(","), false, false, false) { + return false + } + } + + if emitter.canonical || emitter.column > emitter.best_width { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + + emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE) + return yaml_emitter_emit_node(emitter, event, false, true, false, false) +} + +/* + * Expect a flow key node. + */ + +func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, + event *yaml_event_t, first bool) bool { + + if first { + + if !yaml_emitter_write_indicator(emitter, []byte("{"), true, true, false) { + return false + } + if !yaml_emitter_increase_indent(emitter, true, false) { + return false + } + emitter.flow_level++ + } + + if event.event_type == yaml_MAPPING_END_EVENT { + emitter.flow_level-- + emitter.indent = emitter.indents[len(emitter.indents)-1] + emitter.indents = emitter.indents[:len(emitter.indents)-1] + + if emitter.canonical && !first { + if !yaml_emitter_write_indicator(emitter, []byte(","), false, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !yaml_emitter_write_indicator(emitter, []byte("}"), false, false, false) { + return false + } + + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + + return true + } + + if !first { + if !yaml_emitter_write_indicator(emitter, []byte(","), false, false, false) { + return false + } + } + if emitter.canonical || emitter.column > emitter.best_width { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + + if !emitter.canonical && yaml_emitter_check_simple_key(emitter) { + emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE) + return yaml_emitter_emit_node(emitter, event, false, false, true, true) + } else { + if !yaml_emitter_write_indicator(emitter, []byte("?"), true, false, false) { + return false + } + + emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE) + return yaml_emitter_emit_node(emitter, event, false, false, true, false) + } +} + +/* + * Expect a flow value node. + */ + +func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, + event *yaml_event_t, simple bool) bool { + + if simple { + if !yaml_emitter_write_indicator(emitter, []byte(":"), false, false, false) { + return false + } + } else { + if emitter.canonical || emitter.column > emitter.best_width { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !yaml_emitter_write_indicator(emitter, []byte(":"), true, false, false) { + return false + } + } + emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE) + return yaml_emitter_emit_node(emitter, event, false, false, true, false) +} + +/* + * Expect a block item node. + */ + +func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, + event *yaml_event_t, first bool) bool { + + if first { + if !yaml_emitter_increase_indent(emitter, false, + (emitter.mapping_context && !emitter.indention)) { + return false + } + } + + if event.event_type == yaml_SEQUENCE_END_EVENT { + + emitter.indent = emitter.indents[len(emitter.indents)-1] + emitter.indents = emitter.indents[:len(emitter.indents)-1] + + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + + return true + } + + if !yaml_emitter_write_indent(emitter) { + return false + } + if !yaml_emitter_write_indicator(emitter, []byte("-"), true, false, true) { + return false + } + + emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE) + return yaml_emitter_emit_node(emitter, event, false, true, false, false) +} + +/* + * Expect a block key node. + */ + +func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, + event *yaml_event_t, first bool) bool { + + if first { + if !yaml_emitter_increase_indent(emitter, false, false) { + return false + } + } + + if event.event_type == yaml_MAPPING_END_EVENT { + emitter.indent = emitter.indents[len(emitter.indents)-1] + emitter.indents = emitter.indents[:len(emitter.indents)-1] + + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + + return true + } + + if !yaml_emitter_write_indent(emitter) { + return false + } + + if yaml_emitter_check_simple_key(emitter) { + emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE) + + return yaml_emitter_emit_node(emitter, event, false, false, true, true) + } else { + if !yaml_emitter_write_indicator(emitter, []byte("?"), true, false, true) { + return false + } + emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE) + + return yaml_emitter_emit_node(emitter, event, false, false, true, false) + } +} + +/* + * Expect a block value node. + */ + +func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, + event *yaml_event_t, simple bool) bool { + + if simple { + if !yaml_emitter_write_indicator(emitter, []byte(":"), false, false, false) { + return false + } + } else { + if !yaml_emitter_write_indent(emitter) { + return false + } + if !yaml_emitter_write_indicator(emitter, []byte(":"), true, false, true) { + return false + } + } + emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE) + + return yaml_emitter_emit_node(emitter, event, false, false, true, false) +} + +/* + * Expect a node. + */ + +func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t, + root bool, sequence bool, mapping bool, simple_key bool) bool { + emitter.root_context = root + emitter.sequence_context = sequence + emitter.mapping_context = mapping + emitter.simple_key_context = simple_key + + switch event.event_type { + case yaml_ALIAS_EVENT: + return yaml_emitter_emit_alias(emitter, event) + + case yaml_SCALAR_EVENT: + return yaml_emitter_emit_scalar(emitter, event) + + case yaml_SEQUENCE_START_EVENT: + return yaml_emitter_emit_sequence_start(emitter, event) + + case yaml_MAPPING_START_EVENT: + return yaml_emitter_emit_mapping_start(emitter, event) + + default: + return yaml_emitter_set_emitter_error(emitter, + "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS") + } + + return false +} + +/* + * Expect ALIAS. + */ + +func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool { + if !yaml_emitter_process_anchor(emitter) { + return false + } + + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + + return true +} + +/* + * Expect SCALAR. + */ + +func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool { + if !yaml_emitter_select_scalar_style(emitter, event) { + return false + } + if !yaml_emitter_process_anchor(emitter) { + return false + } + if !yaml_emitter_process_tag(emitter) { + return false + } + if !yaml_emitter_increase_indent(emitter, true, false) { + return false + } + if !yaml_emitter_process_scalar(emitter) { + return false + } + emitter.indent = emitter.indents[len(emitter.indents)-1] + emitter.indents = emitter.indents[:len(emitter.indents)-1] + + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + + return true +} + +/* + * Expect SEQUENCE-START. + */ + +func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool { + if !yaml_emitter_process_anchor(emitter) { + return false + } + if !yaml_emitter_process_tag(emitter) { + return false + } + + if emitter.flow_level > 0 || emitter.canonical || + event.style == yaml_style_t(yaml_FLOW_SEQUENCE_STYLE) || + yaml_emitter_check_empty_sequence(emitter) { + emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE + } else { + emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE + } + + return true +} + +/* + * Expect MAPPING-START. + */ + +func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool { + if !yaml_emitter_process_anchor(emitter) { + return false + } + if !yaml_emitter_process_tag(emitter) { + return false + } + + if emitter.flow_level > 0 || emitter.canonical || + event.style == yaml_style_t(yaml_FLOW_MAPPING_STYLE) || + yaml_emitter_check_empty_mapping(emitter) { + emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE + } else { + emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE + } + + return true +} + +/* + * Check if the document content is an empty scalar. + */ + +func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool { + return false +} + +/* + * Check if the next events represent an empty sequence. + */ + +func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool { + if len(emitter.events)-emitter.events_head < 2 { + return false + } + + return (emitter.events[emitter.events_head].event_type == yaml_SEQUENCE_START_EVENT && + emitter.events[emitter.events_head+1].event_type == yaml_SEQUENCE_END_EVENT) +} + +/* + * Check if the next events represent an empty mapping. + */ + +func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool { + if len(emitter.events)-emitter.events_head < 2 { + return false + } + + return (emitter.events[emitter.events_head].event_type == yaml_MAPPING_START_EVENT && + emitter.events[emitter.events_head+1].event_type == yaml_MAPPING_END_EVENT) +} + +/* + * Check if the next node can be expressed as a simple key. + */ + +func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool { + length := 0 + + switch emitter.events[emitter.events_head].event_type { + case yaml_ALIAS_EVENT: + length += len(emitter.anchor_data.anchor) + + case yaml_SCALAR_EVENT: + if emitter.scalar_data.multiline { + return false + } + length += len(emitter.anchor_data.anchor) + + len(emitter.tag_data.handle) + + len(emitter.tag_data.suffix) + + len(emitter.scalar_data.value) + + case yaml_SEQUENCE_START_EVENT: + if !yaml_emitter_check_empty_sequence(emitter) { + return false + } + + length += len(emitter.anchor_data.anchor) + + len(emitter.tag_data.handle) + + len(emitter.tag_data.suffix) + + case yaml_MAPPING_START_EVENT: + if !yaml_emitter_check_empty_mapping(emitter) { + return false + } + + length += len(emitter.anchor_data.anchor) + + len(emitter.tag_data.handle) + + len(emitter.tag_data.suffix) + + default: + return false + } + + if length > 128 { + return false + } + + return true +} + +/* + * Determine an acceptable scalar style. + */ + +func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool { + no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 + + if no_tag && !event.implicit && !event.quoted_implicit { + return yaml_emitter_set_emitter_error(emitter, + "neither tag nor implicit flags are specified") + } + + style := yaml_scalar_style_t(event.style) + + if style == yaml_ANY_SCALAR_STYLE { + style = yaml_PLAIN_SCALAR_STYLE + } + + if emitter.canonical { + style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } + + if emitter.simple_key_context && emitter.scalar_data.multiline { + style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } + + if style == yaml_PLAIN_SCALAR_STYLE { + if (emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed) || + (emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed) { + style = yaml_SINGLE_QUOTED_SCALAR_STYLE + } + if len(emitter.scalar_data.value) == 0 && + (emitter.flow_level > 0 || emitter.simple_key_context) { + style = yaml_SINGLE_QUOTED_SCALAR_STYLE + } + if no_tag && !event.implicit { + style = yaml_SINGLE_QUOTED_SCALAR_STYLE + } + } + + if style == yaml_SINGLE_QUOTED_SCALAR_STYLE { + if !emitter.scalar_data.single_quoted_allowed { + style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } + } + + if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE { + if !emitter.scalar_data.block_allowed || + emitter.flow_level > 0 || emitter.simple_key_context { + style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } + } + + if no_tag && !event.quoted_implicit && + style != yaml_PLAIN_SCALAR_STYLE { + emitter.tag_data.handle = []byte("!") + } + + emitter.scalar_data.style = style + + return true +} + +/* + * Write an achor. + */ + +func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool { + if emitter.anchor_data.anchor == nil { + return true + } + + indicator := "*" + if !emitter.anchor_data.alias { + indicator = "&" + } + if !yaml_emitter_write_indicator(emitter, []byte(indicator), true, false, false) { + return false + } + + return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor) +} + +/* + * Write a tag. + */ + +func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool { + if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 { + return true + } + + if len(emitter.tag_data.handle) > 0 { + if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) { + return false + } + + if len(emitter.tag_data.suffix) > 0 { + if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) { + return false + } + + } + } else { + if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) { + return false + } + + if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) { + return false + } + + if !yaml_emitter_write_indicator(emitter, []byte(">"), false, false, false) { + return false + } + + } + + return true +} + +/* + * Write a scalar. + */ + +func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool { + switch emitter.scalar_data.style { + case yaml_PLAIN_SCALAR_STYLE: + return yaml_emitter_write_plain_scalar(emitter, + emitter.scalar_data.value, + !emitter.simple_key_context) + + case yaml_SINGLE_QUOTED_SCALAR_STYLE: + return yaml_emitter_write_single_quoted_scalar(emitter, + emitter.scalar_data.value, + !emitter.simple_key_context) + + case yaml_DOUBLE_QUOTED_SCALAR_STYLE: + return yaml_emitter_write_double_quoted_scalar(emitter, + emitter.scalar_data.value, + !emitter.simple_key_context) + + case yaml_LITERAL_SCALAR_STYLE: + return yaml_emitter_write_literal_scalar(emitter, + emitter.scalar_data.value) + + case yaml_FOLDED_SCALAR_STYLE: + return yaml_emitter_write_folded_scalar(emitter, + emitter.scalar_data.value) + + default: + panic("unknown scalar") + } + + return false +} + +/* + * Check if a %YAML directive is valid. + */ + +func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, + version_directive yaml_version_directive_t) bool { + if version_directive.major != 1 || version_directive.minor != 1 { + return yaml_emitter_set_emitter_error(emitter, + "incompatible %YAML directive") + } + + return true +} + +/* + * Check if a %TAG directive is valid. + */ + +func yaml_emitter_analyze_tag_directive(emitter *yaml_emitter_t, + tag_directive *yaml_tag_directive_t) bool { + handle := tag_directive.handle + prefix := tag_directive.prefix + + if len(handle) == 0 { + return yaml_emitter_set_emitter_error(emitter, + "tag handle must not be empty") + } + + if handle[0] != '!' { + return yaml_emitter_set_emitter_error(emitter, + "tag handle must start with '!'") + } + + if handle[len(handle)-1] != '!' { + return yaml_emitter_set_emitter_error(emitter, + "tag handle must end with '!'") + } + + for i := 1; i < len(handle)-1; width(handle[i]) { + if !is_alpha(handle[i]) { + return yaml_emitter_set_emitter_error(emitter, + "tag handle must contain alphanumerical characters only") + } + } + + if len(prefix) == 0 { + return yaml_emitter_set_emitter_error(emitter, + "tag prefix must not be empty") + } + + return true +} + +/* + * Check if an anchor is valid. + */ + +func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, + anchor []byte, alias bool) bool { + if len(anchor) == 0 { + errmsg := "alias value must not be empty" + if !alias { + errmsg = "anchor value must not be empty" + } + return yaml_emitter_set_emitter_error(emitter, errmsg) + } + + for i := 0; i < len(anchor); i += width(anchor[i]) { + if !is_alpha(anchor[i]) { + errmsg := "alias value must contain alphanumerical characters only" + if !alias { + errmsg = "anchor value must contain alphanumerical characters only" + } + return yaml_emitter_set_emitter_error(emitter, errmsg) + } + } + + emitter.anchor_data.anchor = anchor + emitter.anchor_data.alias = alias + + return true +} + +/* + * Check if a tag is valid. + */ + +func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool { + if len(tag) == 0 { + return yaml_emitter_set_emitter_error(emitter, + "tag value must not be empty") + } + + for i := range emitter.tag_directives { + tag_directive := &emitter.tag_directives[i] + if bytes.HasPrefix(tag, tag_directive.prefix) { + emitter.tag_data.handle = tag_directive.handle + emitter.tag_data.suffix = tag[len(tag_directive.prefix):] + return true + } + } + + emitter.tag_data.suffix = tag + + return true +} + +/* + * Check if a scalar is valid. + */ + +func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool { + block_indicators := false + flow_indicators := false + line_breaks := false + special_characters := false + + leading_space := false + leading_break := false + trailing_space := false + trailing_break := false + break_space := false + space_break := false + + preceeded_by_whitespace := false + followed_by_whitespace := false + previous_space := false + previous_break := false + + emitter.scalar_data.value = value + + if len(value) == 0 { + emitter.scalar_data.multiline = false + emitter.scalar_data.flow_plain_allowed = false + emitter.scalar_data.block_plain_allowed = true + emitter.scalar_data.single_quoted_allowed = true + emitter.scalar_data.block_allowed = false + + return true + } + + if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') || + (value[0] == '.' && value[1] == '.' && value[2] == '.')) { + block_indicators = true + flow_indicators = true + } + + preceeded_by_whitespace = true + + for i, w := 0, 0; i < len(value); i += w { + w = width(value[i]) + followed_by_whitespace = i+w >= len(value) || is_blankz_at(value, i+w) + + if i == 0 { + switch value[i] { + case '#', ',', '[', ']', '{', '}', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`': + flow_indicators = true + block_indicators = true + case '?', ':': + flow_indicators = true + if followed_by_whitespace { + block_indicators = true + } + case '-': + if followed_by_whitespace { + flow_indicators = true + block_indicators = true + } + } + } else { + switch value[i] { + case ',', '?', '[', ']', '{', '}': + flow_indicators = true + case ':': + flow_indicators = true + if followed_by_whitespace { + block_indicators = true + } + case '#': + if preceeded_by_whitespace { + flow_indicators = true + block_indicators = true + } + } + } + + if !is_printable_at(value, i) || (!is_ascii(value[i]) && !emitter.unicode) { + special_characters = true + } + + if is_break_at(value, i) { + line_breaks = true + } + + if is_space(value[i]) { + if i == 0 { + leading_space = true + } + if i+w == len(value) { + trailing_space = true + } + if previous_break { + break_space = true + } + previous_space = true + previous_break = false + } else if is_break_at(value, i) { + if i == 0 { + leading_break = true + } + if i+width(value[i]) == len(value) { + trailing_break = true + } + if previous_space { + space_break = true + } + previous_space = false + previous_break = true + } else { + previous_space = false + previous_break = false + } + + preceeded_by_whitespace = is_blankz_at(value, i) + } + + emitter.scalar_data.multiline = line_breaks + + emitter.scalar_data.flow_plain_allowed = true + emitter.scalar_data.block_plain_allowed = true + emitter.scalar_data.single_quoted_allowed = true + emitter.scalar_data.block_allowed = true + + if leading_space || leading_break || trailing_space || trailing_break { + emitter.scalar_data.flow_plain_allowed = false + emitter.scalar_data.block_plain_allowed = false + } + + if trailing_space { + emitter.scalar_data.block_allowed = false + } + + if break_space { + emitter.scalar_data.flow_plain_allowed = false + emitter.scalar_data.block_plain_allowed = false + emitter.scalar_data.single_quoted_allowed = false + } + + if space_break || special_characters { + emitter.scalar_data.flow_plain_allowed = false + emitter.scalar_data.block_plain_allowed = false + emitter.scalar_data.single_quoted_allowed = false + emitter.scalar_data.block_allowed = false + } + + if line_breaks { + emitter.scalar_data.flow_plain_allowed = false + emitter.scalar_data.block_plain_allowed = false + } + + if flow_indicators { + emitter.scalar_data.flow_plain_allowed = false + } + + if block_indicators { + emitter.scalar_data.block_plain_allowed = false + } + + return true +} + +/* + * Check if the event data is valid. + */ + +func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bool { + emitter.anchor_data.anchor = nil + emitter.tag_data.handle = nil + emitter.tag_data.suffix = nil + emitter.scalar_data.value = nil + + switch event.event_type { + case yaml_ALIAS_EVENT: + if !yaml_emitter_analyze_anchor(emitter, + event.anchor, true) { + return false + } + + case yaml_SCALAR_EVENT: + if len(event.anchor) > 0 { + if !yaml_emitter_analyze_anchor(emitter, + event.anchor, false) { + return false + } + } + if len(event.tag) > 0 && (emitter.canonical || + (!event.implicit && + !event.quoted_implicit)) { + if !yaml_emitter_analyze_tag(emitter, event.tag) { + return false + } + } + if !yaml_emitter_analyze_scalar(emitter, event.value) { + return false + } + case yaml_SEQUENCE_START_EVENT: + if len(event.anchor) > 0 { + if !yaml_emitter_analyze_anchor(emitter, + event.anchor, false) { + return false + } + } + if len(event.tag) > 0 && (emitter.canonical || + !event.implicit) { + if !yaml_emitter_analyze_tag(emitter, + event.tag) { + return false + } + } + case yaml_MAPPING_START_EVENT: + if len(event.anchor) > 0 { + if !yaml_emitter_analyze_anchor(emitter, + event.anchor, false) { + return false + } + } + if len(event.tag) > 0 && (emitter.canonical || + !event.implicit) { + if !yaml_emitter_analyze_tag(emitter, + event.tag) { + return false + } + } + + } + return true +} + +/* + * Write the BOM character. + */ + +func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool { + if !flush(emitter) { + return false + } + + pos := emitter.buffer_pos + emitter.buffer[pos] = '\xEF' + emitter.buffer[pos+1] = '\xBB' + emitter.buffer[pos+2] = '\xBF' + emitter.buffer_pos += 3 + return true +} + +func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool { + indent := emitter.indent + if indent < 0 { + indent = 0 + } + + if !emitter.indention || emitter.column > indent || + (emitter.column == indent && !emitter.whitespace) { + if !put_break(emitter) { + return false + } + } + + for emitter.column < indent { + if !put(emitter, ' ') { + return false + } + } + + emitter.whitespace = true + emitter.indention = true + + return true +} + +func yaml_emitter_write_indicator(emitter *yaml_emitter_t, + indicator []byte, need_whitespace bool, + is_whitespace bool, is_indention bool) bool { + if need_whitespace && !emitter.whitespace { + if !put(emitter, ' ') { + return false + } + } + + ind_pos := 0 + for ind_pos < len(indicator) { + if !write(emitter, indicator, &ind_pos) { + return false + } + } + + emitter.whitespace = is_whitespace + emitter.indention = (emitter.indention && is_indention) + emitter.open_ended = false + + return true +} + +func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool { + pos := 0 + for pos < len(value) { + if !write(emitter, value, &pos) { + return false + } + } + + emitter.whitespace = false + emitter.indention = false + + return true +} + +func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool { + if !emitter.whitespace { + if !put(emitter, ' ') { + return false + } + } + + pos := 0 + for pos < len(value) { + if !write(emitter, value, &pos) { + return false + } + } + + emitter.whitespace = false + emitter.indention = false + + return true +} + +func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, + need_whitespace bool) bool { + if need_whitespace && !emitter.whitespace { + if !put(emitter, ' ') { + return false + } + } + + for i := 0; i < len(value); { + write_it := false + switch value[i] { + case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', + '.', '!', '~', '*', '\'', '(', ')', '[', ']': + write_it = true + default: + write_it = is_alpha(value[i]) + } + if write_it { + if !write(emitter, value, &i) { + return false + } + } else { + w := width(value[i]) + for j := 0; j < w; j++ { + val := value[i] + i++ + + if !put(emitter, '%') { + return false + } + c := val >> 4 + if c < 10 { + c += '0' + } else { + c += 'A' - 10 + } + if !put(emitter, c) { + return false + } + + c = val & 0x0f + if c < 10 { + c += '0' + } else { + c += 'A' - 10 + } + if !put(emitter, c) { + return false + } + + } + } + } + + emitter.whitespace = false + emitter.indention = false + + return true +} + +func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, + allow_breaks bool) bool { + spaces := false + breaks := false + + if !emitter.whitespace { + if !put(emitter, ' ') { + return false + } + } + + for i := 0; i < len(value); { + if is_space(value[i]) { + if allow_breaks && !spaces && + emitter.column > emitter.best_width && + !is_space(value[i+1]) { + if !yaml_emitter_write_indent(emitter) { + return false + } + i += width(value[i]) + } else { + if !write(emitter, value, &i) { + return false + } + } + spaces = true + } else if is_break_at(value, i) { + if !breaks && value[i] == '\n' { + if !put_break(emitter) { + return false + } + } + if !write_break(emitter, value, &i) { + return false + } + emitter.indention = true + breaks = true + } else { + if breaks { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !write(emitter, value, &i) { + return false + } + emitter.indention = false + spaces = false + breaks = false + } + } + + emitter.whitespace = false + emitter.indention = false + if emitter.root_context { + emitter.open_ended = true + } + + return true +} + +func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, + allow_breaks bool) bool { + spaces := false + breaks := false + + if !yaml_emitter_write_indicator(emitter, []byte("'"), true, false, false) { + return false + } + + for i := 0; i < len(value); { + if is_space(value[i]) { + if allow_breaks && !spaces && + emitter.column > emitter.best_width && + i > 0 && i < len(value)-1 && + !is_space(value[i+1]) { + if !yaml_emitter_write_indent(emitter) { + return false + } + i += width(value[i]) + } else { + if !write(emitter, value, &i) { + return false + } + } + spaces = true + } else if is_break_at(value, i) { + if !breaks && value[i] == '\n' { + if !put_break(emitter) { + return false + } + } + if !write_break(emitter, value, &i) { + return false + } + emitter.indention = true + breaks = true + } else { + if breaks { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if value[i] == '\'' { + if !put(emitter, '\'') { + return false + } + } + if !write(emitter, value, &i) { + return false + } + emitter.indention = false + spaces = false + breaks = false + } + } + + if !yaml_emitter_write_indicator(emitter, []byte("'"), false, false, false) { + return false + } + + emitter.whitespace = false + emitter.indention = false + + return true +} + +func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, + allow_breaks bool) bool { + + spaces := false + + if !yaml_emitter_write_indicator(emitter, []byte("\""), true, false, false) { + return false + } + + for i := 0; i < len(value); { + if !is_printable_at(value, i) || (!emitter.unicode && !is_ascii(value[i])) || + is_bom_at(value, i) || is_break_at(value, i) || + value[i] == '"' || value[i] == '\\' { + octet := value[i] + + var w int + var v rune + switch { + case octet&0x80 == 0x00: + w, v = 1, rune(octet&0x7F) + case octet&0xE0 == 0xC0: + w, v = 2, rune(octet&0x1F) + case octet&0xF0 == 0xE0: + w, v = 3, rune(octet&0x0F) + case octet&0xF8 == 0xF0: + w, v = 4, rune(octet&0x07) + } + + for k := 1; k < w; k++ { + octet = value[i+k] + v = (v << 6) + (rune(octet) & 0x3F) + } + i += w + + if !put(emitter, '\\') { + return false + } + + switch v { + case 0x00: + if !put(emitter, '0') { + return false + } + case 0x07: + if !put(emitter, 'a') { + return false + } + case 0x08: + if !put(emitter, 'b') { + return false + } + case 0x09: + if !put(emitter, 't') { + return false + } + + case 0x0A: + if !put(emitter, 'n') { + return false + } + + case 0x0B: + if !put(emitter, 'v') { + return false + } + + case 0x0C: + if !put(emitter, 'f') { + return false + } + + case 0x0D: + if !put(emitter, 'r') { + return false + } + + case 0x1B: + if !put(emitter, 'e') { + return false + } + case 0x22: + if !put(emitter, '"') { + return false + } + case 0x5C: + if !put(emitter, '\\') { + return false + } + case 0x85: + if !put(emitter, 'N') { + return false + } + + case 0xA0: + if !put(emitter, '_') { + return false + } + + case 0x2028: + if !put(emitter, 'L') { + return false + } + + case 0x2029: + if !put(emitter, 'P') { + return false + } + default: + if v <= 0xFF { + if !put(emitter, 'x') { + return false + } + w = 2 + } else if v <= 0xFFFF { + if !put(emitter, 'u') { + return false + } + w = 4 + } else { + if !put(emitter, 'U') { + return false + } + w = 8 + } + for k := (w - 1) * 4; k >= 0; k -= 4 { + digit := byte((v >> uint(k)) & 0x0F) + c := digit + '0' + if c > 9 { + c = digit + 'A' - 10 + } + if !put(emitter, c) { + return false + } + } + } + spaces = false + } else if is_space(value[i]) { + if allow_breaks && !spaces && + emitter.column > emitter.best_width && + i > 0 && i < len(value)-1 { + if !yaml_emitter_write_indent(emitter) { + return false + } + if is_space(value[i+1]) { + if !put(emitter, '\\') { + return false + } + } + i += width(value[i]) + } else { + if !write(emitter, value, &i) { + return false + } + } + spaces = true + } else { + if !write(emitter, value, &i) { + return false + } + spaces = false + } + } + + if !yaml_emitter_write_indicator(emitter, []byte("\""), false, false, false) { + return false + } + + emitter.whitespace = false + emitter.indention = false + + return true +} + +func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool { + + if is_space(value[0]) || is_break_at(value, 0) { + indent_hint := []byte{'0' + byte(emitter.best_indent)} + if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) { + return false + } + } + + emitter.open_ended = false + + var chomp_hint [1]byte + if len(value) == 0 { + chomp_hint[0] = '-' + } else { + i := len(value) - 1 + for value[i]&0xC0 == 0x80 { + i-- + } + + if !is_break_at(value, i) { + chomp_hint[0] = '-' + } else if i == 0 { + chomp_hint[0] = '+' + emitter.open_ended = true + } else { + for value[i]&0xC0 == 0x80 { + i-- + } + + if is_break_at(value, i) { + chomp_hint[0] = '+' + emitter.open_ended = true + } + } + } + + if chomp_hint[0] != 0 { + if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) { + return false + } + } + + return true +} + +func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool { + + breaks := true + + if !yaml_emitter_write_indicator(emitter, []byte("|"), true, false, false) { + return false + } + + if !yaml_emitter_write_block_scalar_hints(emitter, value) { + return false + } + + if !put_break(emitter) { + return false + } + + emitter.indention = true + emitter.whitespace = true + + for i := 0; i < len(value); { + if is_break_at(value, i) { + if !write_break(emitter, value, &i) { + return false + } + emitter.indention = true + breaks = true + } else { + if breaks { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !write(emitter, value, &i) { + return false + } + emitter.indention = false + breaks = false + } + } + + return true +} + +func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool { + breaks := true + leading_spaces := true + + if !yaml_emitter_write_indicator(emitter, []byte(">"), true, false, false) { + return false + } + if !yaml_emitter_write_block_scalar_hints(emitter, value) { + return false + } + if !put_break(emitter) { + return false + } + emitter.indention = true + emitter.whitespace = true + + for i := 0; i < len(value); { + if is_break_at(value, i) { + if !breaks && !leading_spaces && value[i] == '\n' { + k := i + for is_break_at(value, k) { + k += width(value[k]) + } + if !is_blankz_at(value, k) { + if !put_break(emitter) { + return false + } + } + } + if !write_break(emitter, value, &i) { + return false + } + emitter.indention = true + breaks = true + } else { + if breaks { + if !yaml_emitter_write_indent(emitter) { + return false + } + leading_spaces = is_blank(value[i]) + } + if !breaks && is_space(value[i]) && !is_space(value[i+1]) && + emitter.column > emitter.best_width { + if !yaml_emitter_write_indent(emitter) { + return false + } + i += width(value[i]) + } else { + if !write(emitter, value, &i) { + return false + } + } + emitter.indention = false + breaks = false + } + } + + return true +} diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/encode.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/encode.go new file mode 100644 index 00000000..fd991808 --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/encode.go @@ -0,0 +1,395 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "bytes" + "encoding/base64" + "io" + "math" + "reflect" + "regexp" + "sort" + "strconv" + "time" +) + +var ( + timeTimeType = reflect.TypeOf(time.Time{}) + marshalerType = reflect.TypeOf(new(Marshaler)).Elem() + numberType = reflect.TypeOf(Number("")) + nonPrintable = regexp.MustCompile("[^\t\n\r\u0020-\u007E\u0085\u00A0-\uD7FF\uE000-\uFFFD]") + multiline = regexp.MustCompile("\n|\u0085|\u2028|\u2029") + + shortTags = map[string]string{ + yaml_NULL_TAG: "!!null", + yaml_BOOL_TAG: "!!bool", + yaml_STR_TAG: "!!str", + yaml_INT_TAG: "!!int", + yaml_FLOAT_TAG: "!!float", + yaml_TIMESTAMP_TAG: "!!timestamp", + yaml_SEQ_TAG: "!!seq", + yaml_MAP_TAG: "!!map", + yaml_BINARY_TAG: "!!binary", + } +) + +type Marshaler interface { + MarshalYAML() (tag string, value interface{}, err error) +} + +// An Encoder writes JSON objects to an output stream. +type Encoder struct { + w io.Writer + emitter yaml_emitter_t + event yaml_event_t + flow bool + err error +} + +func Marshal(v interface{}) ([]byte, error) { + b := bytes.Buffer{} + e := NewEncoder(&b) + err := e.Encode(v) + return b.Bytes(), err +} + +// NewEncoder returns a new encoder that writes to w. +func NewEncoder(w io.Writer) *Encoder { + e := &Encoder{w: w} + yaml_emitter_initialize(&e.emitter) + yaml_emitter_set_output_writer(&e.emitter, e.w) + yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING) + e.emit() + yaml_document_start_event_initialize(&e.event, nil, nil, true) + e.emit() + + return e +} + +func (e *Encoder) Encode(v interface{}) (err error) { + defer recovery(&err) + + if e.err != nil { + return e.err + } + + e.marshal("", reflect.ValueOf(v), true) + + yaml_document_end_event_initialize(&e.event, true) + e.emit() + e.emitter.open_ended = false + yaml_stream_end_event_initialize(&e.event) + e.emit() + + return nil +} + +func (e *Encoder) emit() { + if !yaml_emitter_emit(&e.emitter, &e.event) { + panic("bad emit") + } +} + +func (e *Encoder) marshal(tag string, v reflect.Value, allowAddr bool) { + vt := v.Type() + + if vt.Implements(marshalerType) { + e.emitMarshaler(tag, v) + return + } + + if vt.Kind() != reflect.Ptr && allowAddr { + if reflect.PtrTo(vt).Implements(marshalerType) { + e.emitAddrMarshaler(tag, v) + return + } + } + + switch v.Kind() { + case reflect.Interface: + if v.IsNil() { + e.emitNil() + } else { + e.marshal(tag, v.Elem(), allowAddr) + } + case reflect.Map: + e.emitMap(tag, v) + case reflect.Ptr: + if v.IsNil() { + e.emitNil() + } else { + e.marshal(tag, v.Elem(), true) + } + case reflect.Struct: + e.emitStruct(tag, v) + case reflect.Slice: + e.emitSlice(tag, v) + case reflect.String: + e.emitString(tag, v) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + e.emitInt(tag, v) + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + e.emitUint(tag, v) + case reflect.Float32, reflect.Float64: + e.emitFloat(tag, v) + case reflect.Bool: + e.emitBool(tag, v) + default: + panic("Can't marshal type yet: " + v.Type().String()) + } +} + +func (e *Encoder) emitMap(tag string, v reflect.Value) { + e.mapping(tag, func() { + var keys stringValues = v.MapKeys() + sort.Sort(keys) + for _, k := range keys { + e.marshal("", k, true) + e.marshal("", v.MapIndex(k), true) + } + }) +} + +func (e *Encoder) emitStruct(tag string, v reflect.Value) { + if v.Type() == timeTimeType { + e.emitTime(tag, v) + return + } + + fields := cachedTypeFields(v.Type()) + + e.mapping(tag, func() { + for _, f := range fields { + fv := fieldByIndex(v, f.index) + if !fv.IsValid() || f.omitEmpty && isEmptyValue(fv) { + continue + } + + e.marshal("", reflect.ValueOf(f.name), true) + e.flow = f.flow + e.marshal("", fv, true) + } + }) +} + +func (e *Encoder) emitTime(tag string, v reflect.Value) { + t := v.Interface().(time.Time) + bytes, _ := t.MarshalText() + e.emitScalar(string(bytes), "", tag, yaml_PLAIN_SCALAR_STYLE) +} + +func isEmptyValue(v reflect.Value) bool { + switch v.Kind() { + case reflect.Array, reflect.Map, reflect.Slice, reflect.String: + return v.Len() == 0 + case reflect.Bool: + return !v.Bool() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.Interface, reflect.Ptr: + return v.IsNil() + } + return false +} + +func (e *Encoder) mapping(tag string, f func()) { + implicit := tag == "" + style := yaml_BLOCK_MAPPING_STYLE + if e.flow { + e.flow = false + style = yaml_FLOW_MAPPING_STYLE + } + yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style) + e.emit() + + f() + + yaml_mapping_end_event_initialize(&e.event) + e.emit() +} + +func (e *Encoder) emitSlice(tag string, v reflect.Value) { + if v.Type() == byteSliceType { + e.emitBase64(tag, v) + return + } + + implicit := tag == "" + style := yaml_BLOCK_SEQUENCE_STYLE + if e.flow { + e.flow = false + style = yaml_FLOW_SEQUENCE_STYLE + } + yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style) + e.emit() + + n := v.Len() + for i := 0; i < n; i++ { + e.marshal("", v.Index(i), true) + } + + yaml_sequence_end_event_initialize(&e.event) + e.emit() +} + +func (e *Encoder) emitBase64(tag string, v reflect.Value) { + if v.IsNil() { + e.emitNil() + return + } + + s := v.Bytes() + + dst := make([]byte, base64.StdEncoding.EncodedLen(len(s))) + + base64.StdEncoding.Encode(dst, s) + e.emitScalar(string(dst), "", yaml_BINARY_TAG, yaml_DOUBLE_QUOTED_SCALAR_STYLE) +} + +func (e *Encoder) emitString(tag string, v reflect.Value) { + var style yaml_scalar_style_t + s := v.String() + + if nonPrintable.MatchString(s) { + e.emitBase64(tag, v) + return + } + + if v.Type() == numberType { + style = yaml_PLAIN_SCALAR_STYLE + } else { + event := yaml_event_t{ + implicit: true, + value: []byte(s), + } + + rtag, _ := resolveInterface(event, false) + if tag == "" && rtag != yaml_STR_TAG { + style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } else if multiline.MatchString(s) { + style = yaml_LITERAL_SCALAR_STYLE + } else { + style = yaml_PLAIN_SCALAR_STYLE + } + } + + e.emitScalar(s, "", tag, style) +} + +func (e *Encoder) emitBool(tag string, v reflect.Value) { + s := strconv.FormatBool(v.Bool()) + e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) +} + +func (e *Encoder) emitInt(tag string, v reflect.Value) { + s := strconv.FormatInt(v.Int(), 10) + e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) +} + +func (e *Encoder) emitUint(tag string, v reflect.Value) { + s := strconv.FormatUint(v.Uint(), 10) + e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) +} + +func (e *Encoder) emitFloat(tag string, v reflect.Value) { + f := v.Float() + + var s string + switch { + case math.IsNaN(f): + s = ".nan" + case math.IsInf(f, 1): + s = "+.inf" + case math.IsInf(f, -1): + s = "-.inf" + default: + s = strconv.FormatFloat(f, 'g', -1, v.Type().Bits()) + } + + e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) +} + +func (e *Encoder) emitNil() { + e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE) +} + +func (e *Encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) { + implicit := tag == "" + if !implicit { + style = yaml_PLAIN_SCALAR_STYLE + } + + stag := shortTags[tag] + if stag == "" { + stag = tag + } + + yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(stag), []byte(value), implicit, implicit, style) + e.emit() +} + +func (e *Encoder) emitMarshaler(tag string, v reflect.Value) { + if v.Kind() == reflect.Ptr && v.IsNil() { + e.emitNil() + return + } + + m := v.Interface().(Marshaler) + if m == nil { + e.emitNil() + return + } + t, val, err := m.MarshalYAML() + if err != nil { + panic(err) + } + if val == nil { + e.emitNil() + return + } + + e.marshal(t, reflect.ValueOf(val), false) +} + +func (e *Encoder) emitAddrMarshaler(tag string, v reflect.Value) { + if !v.CanAddr() { + e.marshal(tag, v, false) + return + } + + va := v.Addr() + if va.IsNil() { + e.emitNil() + return + } + + m := v.Interface().(Marshaler) + t, val, err := m.MarshalYAML() + if err != nil { + panic(err) + } + + if val == nil { + e.emitNil() + return + } + + e.marshal(t, reflect.ValueOf(val), false) +} diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/parser.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/parser.go new file mode 100644 index 00000000..8d38e306 --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/parser.go @@ -0,0 +1,1230 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "bytes" +) + +/* + * The parser implements the following grammar: + * + * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END + * implicit_document ::= block_node DOCUMENT-END* + * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* + * block_node_or_indentless_sequence ::= + * ALIAS + * | properties (block_content | indentless_block_sequence)? + * | block_content + * | indentless_block_sequence + * block_node ::= ALIAS + * | properties block_content? + * | block_content + * flow_node ::= ALIAS + * | properties flow_content? + * | flow_content + * properties ::= TAG ANCHOR? | ANCHOR TAG? + * block_content ::= block_collection | flow_collection | SCALAR + * flow_content ::= flow_collection | SCALAR + * block_collection ::= block_sequence | block_mapping + * flow_collection ::= flow_sequence | flow_mapping + * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END + * indentless_sequence ::= (BLOCK-ENTRY block_node?)+ + * block_mapping ::= BLOCK-MAPPING_START + * ((KEY block_node_or_indentless_sequence?)? + * (VALUE block_node_or_indentless_sequence?)?)* + * BLOCK-END + * flow_sequence ::= FLOW-SEQUENCE-START + * (flow_sequence_entry FLOW-ENTRY)* + * flow_sequence_entry? + * FLOW-SEQUENCE-END + * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + * flow_mapping ::= FLOW-MAPPING-START + * (flow_mapping_entry FLOW-ENTRY)* + * flow_mapping_entry? + * FLOW-MAPPING-END + * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + */ + +/* + * Peek the next token in the token queue. + */ +func peek_token(parser *yaml_parser_t) *yaml_token_t { + if parser.token_available || yaml_parser_fetch_more_tokens(parser) { + return &parser.tokens[parser.tokens_head] + } + return nil +} + +/* + * Remove the next token from the queue (must be called after peek_token). + */ +func skip_token(parser *yaml_parser_t) { + parser.token_available = false + parser.tokens_parsed++ + parser.stream_end_produced = parser.tokens[parser.tokens_head].token_type == yaml_STREAM_END_TOKEN + parser.tokens_head++ +} + +/* + * Get the next event. + */ + +func yaml_parser_parse(parser *yaml_parser_t, event *yaml_event_t) bool { + /* Erase the event object. */ + *event = yaml_event_t{} + + /* No events after the end of the stream or error. */ + + if parser.stream_end_produced || parser.error != yaml_NO_ERROR || + parser.state == yaml_PARSE_END_STATE { + return true + } + + /* Generate the next event. */ + + return yaml_parser_state_machine(parser, event) +} + +/* + * Set parser error. + */ + +func yaml_parser_set_parser_error(parser *yaml_parser_t, + problem string, problem_mark YAML_mark_t) bool { + parser.error = yaml_PARSER_ERROR + parser.problem = problem + parser.problem_mark = problem_mark + + return false +} + +func yaml_parser_set_parser_error_context(parser *yaml_parser_t, + context string, context_mark YAML_mark_t, + problem string, problem_mark YAML_mark_t) bool { + parser.error = yaml_PARSER_ERROR + parser.context = context + parser.context_mark = context_mark + parser.problem = problem + parser.problem_mark = problem_mark + + return false +} + +/* + * State dispatcher. + */ + +func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool { + switch parser.state { + case yaml_PARSE_STREAM_START_STATE: + return yaml_parser_parse_stream_start(parser, event) + + case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE: + return yaml_parser_parse_document_start(parser, event, true) + + case yaml_PARSE_DOCUMENT_START_STATE: + return yaml_parser_parse_document_start(parser, event, false) + + case yaml_PARSE_DOCUMENT_CONTENT_STATE: + return yaml_parser_parse_document_content(parser, event) + + case yaml_PARSE_DOCUMENT_END_STATE: + return yaml_parser_parse_document_end(parser, event) + + case yaml_PARSE_BLOCK_NODE_STATE: + return yaml_parser_parse_node(parser, event, true, false) + + case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: + return yaml_parser_parse_node(parser, event, true, true) + + case yaml_PARSE_FLOW_NODE_STATE: + return yaml_parser_parse_node(parser, event, false, false) + + case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: + return yaml_parser_parse_block_sequence_entry(parser, event, true) + + case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: + return yaml_parser_parse_block_sequence_entry(parser, event, false) + + case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: + return yaml_parser_parse_indentless_sequence_entry(parser, event) + + case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: + return yaml_parser_parse_block_mapping_key(parser, event, true) + + case yaml_PARSE_BLOCK_MAPPING_KEY_STATE: + return yaml_parser_parse_block_mapping_key(parser, event, false) + + case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE: + return yaml_parser_parse_block_mapping_value(parser, event) + + case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: + return yaml_parser_parse_flow_sequence_entry(parser, event, true) + + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE: + return yaml_parser_parse_flow_sequence_entry(parser, event, false) + + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: + return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event) + + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: + return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event) + + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: + return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event) + + case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: + return yaml_parser_parse_flow_mapping_key(parser, event, true) + + case yaml_PARSE_FLOW_MAPPING_KEY_STATE: + return yaml_parser_parse_flow_mapping_key(parser, event, false) + + case yaml_PARSE_FLOW_MAPPING_VALUE_STATE: + return yaml_parser_parse_flow_mapping_value(parser, event, false) + + case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: + return yaml_parser_parse_flow_mapping_value(parser, event, true) + } + + panic("invalid parser state") +} + +/* + * Parse the production: + * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END + * ************ + */ + +func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type != yaml_STREAM_START_TOKEN { + return yaml_parser_set_parser_error(parser, + "did not find expected ", token.start_mark) + } + + parser.state = yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE + *event = yaml_event_t{ + event_type: yaml_STREAM_START_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + encoding: token.encoding, + } + skip_token(parser) + + return true +} + +/* + * Parse the productions: + * implicit_document ::= block_node DOCUMENT-END* + * * + * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* + * ************************* + */ + +func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, + implicit bool) bool { + + token := peek_token(parser) + if token == nil { + return false + } + + /* Parse extra document end indicators. */ + + if !implicit { + for token.token_type == yaml_DOCUMENT_END_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + } + } + + /* Parse an implicit document. */ + + if implicit && token.token_type != yaml_VERSION_DIRECTIVE_TOKEN && + token.token_type != yaml_TAG_DIRECTIVE_TOKEN && + token.token_type != yaml_DOCUMENT_START_TOKEN && + token.token_type != yaml_STREAM_END_TOKEN { + if !yaml_parser_process_directives(parser, nil, nil) { + return false + } + + parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE) + parser.state = yaml_PARSE_BLOCK_NODE_STATE + + *event = yaml_event_t{ + event_type: yaml_DOCUMENT_START_EVENT, + implicit: true, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + } else if token.token_type != yaml_STREAM_END_TOKEN { + /* Parse an explicit document. */ + var version_directive *yaml_version_directive_t + var tag_directives []yaml_tag_directive_t + + start_mark := token.start_mark + if !yaml_parser_process_directives(parser, &version_directive, + &tag_directives) { + return false + } + token = peek_token(parser) + if token == nil { + return false + } + if token.token_type != yaml_DOCUMENT_START_TOKEN { + yaml_parser_set_parser_error(parser, + "did not find expected ", token.start_mark) + return false + } + + parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE) + parser.state = yaml_PARSE_DOCUMENT_CONTENT_STATE + + end_mark := token.end_mark + + *event = yaml_event_t{ + event_type: yaml_DOCUMENT_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + version_directive: version_directive, + tag_directives: tag_directives, + implicit: false, + } + skip_token(parser) + } else { + /* Parse the stream end. */ + parser.state = yaml_PARSE_END_STATE + + *event = yaml_event_t{ + event_type: yaml_STREAM_END_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + skip_token(parser) + } + return true +} + +/* + * Parse the productions: + * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* + * *********** + */ + +func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type == yaml_VERSION_DIRECTIVE_TOKEN || + token.token_type == yaml_TAG_DIRECTIVE_TOKEN || + token.token_type == yaml_DOCUMENT_START_TOKEN || + token.token_type == yaml_DOCUMENT_END_TOKEN || + token.token_type == yaml_STREAM_END_TOKEN { + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + return yaml_parser_process_empty_scalar(parser, event, + token.start_mark) + } else { + return yaml_parser_parse_node(parser, event, true, false) + } +} + +/* + * Parse the productions: + * implicit_document ::= block_node DOCUMENT-END* + * ************* + * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* + * ************* + */ + +func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool { + implicit := true + + token := peek_token(parser) + if token == nil { + return false + } + + start_mark, end_mark := token.start_mark, token.start_mark + + if token.token_type == yaml_DOCUMENT_END_TOKEN { + end_mark = token.end_mark + skip_token(parser) + implicit = false + } + + parser.tag_directives = parser.tag_directives[:0] + + parser.state = yaml_PARSE_DOCUMENT_START_STATE + *event = yaml_event_t{ + event_type: yaml_DOCUMENT_END_EVENT, + start_mark: start_mark, + end_mark: end_mark, + implicit: implicit, + } + + return true +} + +/* + * Parse the productions: + * block_node_or_indentless_sequence ::= + * ALIAS + * ***** + * | properties (block_content | indentless_block_sequence)? + * ********** * + * | block_content | indentless_block_sequence + * * + * block_node ::= ALIAS + * ***** + * | properties block_content? + * ********** * + * | block_content + * * + * flow_node ::= ALIAS + * ***** + * | properties flow_content? + * ********** * + * | flow_content + * * + * properties ::= TAG ANCHOR? | ANCHOR TAG? + * ************************* + * block_content ::= block_collection | flow_collection | SCALAR + * ****** + * flow_content ::= flow_collection | SCALAR + * ****** + */ + +func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, + block bool, indentless_sequence bool) bool { + + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type == yaml_ALIAS_TOKEN { + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + + *event = yaml_event_t{ + event_type: yaml_ALIAS_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + anchor: token.value, + } + skip_token(parser) + return true + } else { + start_mark, end_mark := token.start_mark, token.start_mark + + var tag_handle []byte + var tag_suffix, anchor []byte + var tag_mark YAML_mark_t + if token.token_type == yaml_ANCHOR_TOKEN { + anchor = token.value + start_mark = token.start_mark + end_mark = token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.token_type == yaml_TAG_TOKEN { + tag_handle = token.value + tag_suffix = token.suffix + tag_mark = token.start_mark + end_mark = token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + } + } else if token.token_type == yaml_TAG_TOKEN { + tag_handle = token.value + tag_suffix = token.suffix + start_mark, tag_mark = token.start_mark, token.start_mark + end_mark = token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.token_type == yaml_ANCHOR_TOKEN { + anchor = token.value + end_mark = token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + + } + } + + var tag []byte + if tag_handle != nil { + if len(tag_handle) == 0 { + tag = tag_suffix + tag_handle = nil + tag_suffix = nil + } else { + for i := range parser.tag_directives { + tag_directive := &parser.tag_directives[i] + if bytes.Equal(tag_directive.handle, tag_handle) { + tag = append([]byte(nil), tag_directive.prefix...) + tag = append(tag, tag_suffix...) + tag_handle = nil + tag_suffix = nil + break + } + } + if len(tag) == 0 { + yaml_parser_set_parser_error_context(parser, + "while parsing a node", start_mark, + "found undefined tag handle", tag_mark) + return false + } + } + } + + implicit := len(tag) == 0 + if indentless_sequence && token.token_type == yaml_BLOCK_ENTRY_TOKEN { + end_mark = token.end_mark + parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE + + *event = yaml_event_t{ + event_type: yaml_SEQUENCE_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE), + } + + return true + } else { + if token.token_type == yaml_SCALAR_TOKEN { + plain_implicit := false + quoted_implicit := false + end_mark = token.end_mark + if (token.style == yaml_PLAIN_SCALAR_STYLE && len(tag) == 0) || + (len(tag) == 1 && tag[0] == '!') { + plain_implicit = true + } else if len(tag) == 0 { + quoted_implicit = true + } + + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + + *event = yaml_event_t{ + event_type: yaml_SCALAR_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + value: token.value, + implicit: plain_implicit, + quoted_implicit: quoted_implicit, + style: yaml_style_t(token.style), + } + + skip_token(parser) + return true + } else if token.token_type == yaml_FLOW_SEQUENCE_START_TOKEN { + end_mark = token.end_mark + parser.state = yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE + + *event = yaml_event_t{ + event_type: yaml_SEQUENCE_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE), + } + + return true + } else if token.token_type == yaml_FLOW_MAPPING_START_TOKEN { + end_mark = token.end_mark + parser.state = yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE + + *event = yaml_event_t{ + event_type: yaml_MAPPING_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(yaml_FLOW_MAPPING_STYLE), + } + + return true + } else if block && token.token_type == yaml_BLOCK_SEQUENCE_START_TOKEN { + end_mark = token.end_mark + parser.state = yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE + + *event = yaml_event_t{ + event_type: yaml_SEQUENCE_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE), + } + + return true + } else if block && token.token_type == yaml_BLOCK_MAPPING_START_TOKEN { + end_mark = token.end_mark + parser.state = yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE + + *event = yaml_event_t{ + event_type: yaml_MAPPING_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE), + } + return true + } else if len(anchor) > 0 || len(tag) > 0 { + + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + + *event = yaml_event_t{ + event_type: yaml_SCALAR_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + quoted_implicit: false, + style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE), + } + return true + } else { + msg := "while parsing a block node" + if !block { + msg = "while parsing a flow node" + } + yaml_parser_set_parser_error_context(parser, msg, start_mark, + "did not find expected node content", token.start_mark) + return false + } + } + } + + return false +} + +/* + * Parse the productions: + * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END + * ******************** *********** * ********* + */ + +func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, + event *yaml_event_t, first bool) bool { + if first { + token := peek_token(parser) + parser.marks = append(parser.marks, token.start_mark) + skip_token(parser) + } + + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type == yaml_BLOCK_ENTRY_TOKEN { + mark := token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.token_type != yaml_BLOCK_ENTRY_TOKEN && + token.token_type != yaml_BLOCK_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE) + return yaml_parser_parse_node(parser, event, true, false) + } else { + parser.state = yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE + return yaml_parser_process_empty_scalar(parser, event, mark) + } + } else if token.token_type == yaml_BLOCK_END_TOKEN { + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + + *event = yaml_event_t{ + event_type: yaml_SEQUENCE_END_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + + skip_token(parser) + return true + } else { + mark := parser.marks[len(parser.marks)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + + return yaml_parser_set_parser_error_context(parser, + "while parsing a block collection", mark, + "did not find expected '-' indicator", token.start_mark) + } +} + +/* + * Parse the productions: + * indentless_sequence ::= (BLOCK-ENTRY block_node?)+ + * *********** * + */ + +func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, + event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type == yaml_BLOCK_ENTRY_TOKEN { + mark := token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.token_type != yaml_BLOCK_ENTRY_TOKEN && + token.token_type != yaml_KEY_TOKEN && + token.token_type != yaml_VALUE_TOKEN && + token.token_type != yaml_BLOCK_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE) + return yaml_parser_parse_node(parser, event, true, false) + } else { + parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE + return yaml_parser_process_empty_scalar(parser, event, mark) + } + } else { + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + + *event = yaml_event_t{ + event_type: yaml_SEQUENCE_END_EVENT, + start_mark: token.start_mark, + end_mark: token.start_mark, + } + return true + } +} + +/* + * Parse the productions: + * block_mapping ::= BLOCK-MAPPING_START + * ******************* + * ((KEY block_node_or_indentless_sequence?)? + * *** * + * (VALUE block_node_or_indentless_sequence?)?)* + * + * BLOCK-END + * ********* + */ + +func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, + event *yaml_event_t, first bool) bool { + if first { + token := peek_token(parser) + parser.marks = append(parser.marks, token.start_mark) + skip_token(parser) + } + + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type == yaml_KEY_TOKEN { + mark := token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.token_type != yaml_KEY_TOKEN && + token.token_type != yaml_VALUE_TOKEN && + token.token_type != yaml_BLOCK_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_VALUE_STATE) + return yaml_parser_parse_node(parser, event, true, true) + } else { + parser.state = yaml_PARSE_BLOCK_MAPPING_VALUE_STATE + return yaml_parser_process_empty_scalar(parser, event, mark) + } + } else if token.token_type == yaml_BLOCK_END_TOKEN { + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + *event = yaml_event_t{ + event_type: yaml_MAPPING_END_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + skip_token(parser) + return true + } else { + mark := parser.marks[len(parser.marks)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + + return yaml_parser_set_parser_error_context(parser, + "while parsing a block mapping", mark, + "did not find expected key", token.start_mark) + } +} + +/* + * Parse the productions: + * block_mapping ::= BLOCK-MAPPING_START + * + * ((KEY block_node_or_indentless_sequence?)? + * + * (VALUE block_node_or_indentless_sequence?)?)* + * ***** * + * BLOCK-END + * + */ + +func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, + event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type == yaml_VALUE_TOKEN { + mark := token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.token_type != yaml_KEY_TOKEN && + token.token_type != yaml_VALUE_TOKEN && + token.token_type != yaml_BLOCK_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_KEY_STATE) + return yaml_parser_parse_node(parser, event, true, true) + } else { + parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE + return yaml_parser_process_empty_scalar(parser, event, mark) + } + } else { + parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE + return yaml_parser_process_empty_scalar(parser, event, token.start_mark) + } +} + +/* + * Parse the productions: + * flow_sequence ::= FLOW-SEQUENCE-START + * ******************* + * (flow_sequence_entry FLOW-ENTRY)* + * * ********** + * flow_sequence_entry? + * * + * FLOW-SEQUENCE-END + * ***************** + * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + * * + */ + +func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, + event *yaml_event_t, first bool) bool { + if first { + token := peek_token(parser) + parser.marks = append(parser.marks, token.start_mark) + skip_token(parser) + } + + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type != yaml_FLOW_SEQUENCE_END_TOKEN { + if !first { + if token.token_type == yaml_FLOW_ENTRY_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + } else { + mark := parser.marks[len(parser.marks)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + + return yaml_parser_set_parser_error_context(parser, + "while parsing a flow sequence", mark, + "did not find expected ',' or ']'", token.start_mark) + } + } + + if token.token_type == yaml_KEY_TOKEN { + parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE + *event = yaml_event_t{ + event_type: yaml_MAPPING_START_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + implicit: true, + style: yaml_style_t(yaml_FLOW_MAPPING_STYLE), + } + + skip_token(parser) + return true + } else if token.token_type != yaml_FLOW_SEQUENCE_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } + } + + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + + *event = yaml_event_t{ + event_type: yaml_SEQUENCE_END_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + + skip_token(parser) + return true +} + +/* + * Parse the productions: + * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + * *** * + */ + +func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, + event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type != yaml_VALUE_TOKEN && + token.token_type != yaml_FLOW_ENTRY_TOKEN && + token.token_type != yaml_FLOW_SEQUENCE_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } else { + mark := token.end_mark + skip_token(parser) + parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE + return yaml_parser_process_empty_scalar(parser, event, mark) + } +} + +/* + * Parse the productions: + * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + * ***** * + */ + +func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, + event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type == yaml_VALUE_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.token_type != yaml_FLOW_ENTRY_TOKEN && + token.token_type != yaml_FLOW_SEQUENCE_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } + } + parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE + return yaml_parser_process_empty_scalar(parser, event, token.start_mark) +} + +/* + * Parse the productions: + * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + * * + */ + +func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, + event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + + parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE + *event = yaml_event_t{ + event_type: yaml_MAPPING_END_EVENT, + start_mark: token.start_mark, + end_mark: token.start_mark, + } + + return true +} + +/* + * Parse the productions: + * flow_mapping ::= FLOW-MAPPING-START + * ****************** + * (flow_mapping_entry FLOW-ENTRY)* + * * ********** + * flow_mapping_entry? + * ****************** + * FLOW-MAPPING-END + * **************** + * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + * * *** * + */ + +func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, + event *yaml_event_t, first bool) bool { + if first { + token := peek_token(parser) + parser.marks = append(parser.marks, token.start_mark) + skip_token(parser) + } + + token := peek_token(parser) + if token == nil { + return false + } + + if token.token_type != yaml_FLOW_MAPPING_END_TOKEN { + if !first { + if token.token_type == yaml_FLOW_ENTRY_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + } else { + mark := parser.marks[len(parser.marks)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + + return yaml_parser_set_parser_error_context(parser, + "while parsing a flow mapping", mark, + "did not find expected ',' or '}'", token.start_mark) + } + } + + if token.token_type == yaml_KEY_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.token_type != yaml_VALUE_TOKEN && + token.token_type != yaml_FLOW_ENTRY_TOKEN && + token.token_type != yaml_FLOW_MAPPING_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_VALUE_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } else { + parser.state = yaml_PARSE_FLOW_MAPPING_VALUE_STATE + return yaml_parser_process_empty_scalar(parser, event, + token.start_mark) + } + } else if token.token_type != yaml_FLOW_MAPPING_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } + } + + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + *event = yaml_event_t{ + event_type: yaml_MAPPING_END_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + + skip_token(parser) + return true +} + +/* + * Parse the productions: + * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + * * ***** * + */ + +func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, + event *yaml_event_t, empty bool) bool { + token := peek_token(parser) + if token == nil { + return false + } + + if empty { + parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE + return yaml_parser_process_empty_scalar(parser, event, + token.start_mark) + } + + if token.token_type == yaml_VALUE_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.token_type != yaml_FLOW_ENTRY_TOKEN && + token.token_type != yaml_FLOW_MAPPING_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_KEY_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } + } + + parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE + return yaml_parser_process_empty_scalar(parser, event, token.start_mark) +} + +/* + * Generate an empty scalar event. + */ + +func yaml_parser_process_empty_scalar(parser *yaml_parser_t, event *yaml_event_t, + mark YAML_mark_t) bool { + *event = yaml_event_t{ + event_type: yaml_SCALAR_EVENT, + start_mark: mark, + end_mark: mark, + value: nil, + implicit: true, + style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE), + } + + return true +} + +/* + * Parse directives. + */ + +func yaml_parser_process_directives(parser *yaml_parser_t, + version_directive_ref **yaml_version_directive_t, + tag_directives_ref *[]yaml_tag_directive_t) bool { + + token := peek_token(parser) + if token == nil { + return false + } + + var version_directive *yaml_version_directive_t + var tag_directives []yaml_tag_directive_t + + for token.token_type == yaml_VERSION_DIRECTIVE_TOKEN || + token.token_type == yaml_TAG_DIRECTIVE_TOKEN { + if token.token_type == yaml_VERSION_DIRECTIVE_TOKEN { + if version_directive != nil { + yaml_parser_set_parser_error(parser, + "found duplicate %YAML directive", token.start_mark) + return false + } + if token.major != 1 || + token.minor != 1 { + yaml_parser_set_parser_error(parser, + "found incompatible YAML document", token.start_mark) + return false + } + version_directive = &yaml_version_directive_t{ + major: token.major, + minor: token.minor, + } + } else if token.token_type == yaml_TAG_DIRECTIVE_TOKEN { + value := yaml_tag_directive_t{ + handle: token.value, + prefix: token.prefix, + } + + if !yaml_parser_append_tag_directive(parser, value, false, + token.start_mark) { + return false + } + tag_directives = append(tag_directives, value) + } + + skip_token(parser) + token := peek_token(parser) + if token == nil { + return false + } + } + + for i := range default_tag_directives { + if !yaml_parser_append_tag_directive(parser, default_tag_directives[i], true, token.start_mark) { + return false + } + } + + if version_directive_ref != nil { + *version_directive_ref = version_directive + } + if tag_directives_ref != nil { + *tag_directives_ref = tag_directives + } + + return true +} + +/* + * Append a tag directive to the directives stack. + */ + +func yaml_parser_append_tag_directive(parser *yaml_parser_t, + value yaml_tag_directive_t, allow_duplicates bool, mark YAML_mark_t) bool { + for i := range parser.tag_directives { + tag := &parser.tag_directives[i] + if bytes.Equal(value.handle, tag.handle) { + if allow_duplicates { + return true + } + return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark) + } + } + + parser.tag_directives = append(parser.tag_directives, value) + return true +} diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/reader.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/reader.go new file mode 100644 index 00000000..5631da2d --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/reader.go @@ -0,0 +1,465 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "io" +) + +/* + * Set the reader error and return 0. + */ + +func yaml_parser_set_reader_error(parser *yaml_parser_t, problem string, + offset int, value int) bool { + parser.error = yaml_READER_ERROR + parser.problem = problem + parser.problem_offset = offset + parser.problem_value = value + + return false +} + +/* + * Byte order marks. + */ +const ( + BOM_UTF8 = "\xef\xbb\xbf" + BOM_UTF16LE = "\xff\xfe" + BOM_UTF16BE = "\xfe\xff" +) + +/* + * Determine the input stream encoding by checking the BOM symbol. If no BOM is + * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure. + */ + +func yaml_parser_determine_encoding(parser *yaml_parser_t) bool { + /* Ensure that we had enough bytes in the raw buffer. */ + for !parser.eof && + len(parser.raw_buffer)-parser.raw_buffer_pos < 3 { + if !yaml_parser_update_raw_buffer(parser) { + return false + } + } + + /* Determine the encoding. */ + raw := parser.raw_buffer + pos := parser.raw_buffer_pos + remaining := len(raw) - pos + if remaining >= 2 && + raw[pos] == BOM_UTF16LE[0] && raw[pos+1] == BOM_UTF16LE[1] { + parser.encoding = yaml_UTF16LE_ENCODING + parser.raw_buffer_pos += 2 + parser.offset += 2 + } else if remaining >= 2 && + raw[pos] == BOM_UTF16BE[0] && raw[pos+1] == BOM_UTF16BE[1] { + parser.encoding = yaml_UTF16BE_ENCODING + parser.raw_buffer_pos += 2 + parser.offset += 2 + } else if remaining >= 3 && + raw[pos] == BOM_UTF8[0] && raw[pos+1] == BOM_UTF8[1] && raw[pos+2] == BOM_UTF8[2] { + parser.encoding = yaml_UTF8_ENCODING + parser.raw_buffer_pos += 3 + parser.offset += 3 + } else { + parser.encoding = yaml_UTF8_ENCODING + } + + return true +} + +/* + * Update the raw buffer. + */ + +func yaml_parser_update_raw_buffer(parser *yaml_parser_t) bool { + size_read := 0 + + /* Return if the raw buffer is full. */ + if parser.raw_buffer_pos == 0 && len(parser.raw_buffer) == cap(parser.raw_buffer) { + return true + } + + /* Return on EOF. */ + + if parser.eof { + return true + } + + /* Move the remaining bytes in the raw buffer to the beginning. */ + if parser.raw_buffer_pos > 0 && parser.raw_buffer_pos < len(parser.raw_buffer) { + copy(parser.raw_buffer, parser.raw_buffer[parser.raw_buffer_pos:]) + } + parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)-parser.raw_buffer_pos] + parser.raw_buffer_pos = 0 + + /* Call the read handler to fill the buffer. */ + size_read, err := parser.read_handler(parser, + parser.raw_buffer[len(parser.raw_buffer):cap(parser.raw_buffer)]) + parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)+size_read] + + if err == io.EOF { + parser.eof = true + } else if err != nil { + return yaml_parser_set_reader_error(parser, "input error: "+err.Error(), + parser.offset, -1) + } + + return true +} + +/* + * Ensure that the buffer contains at least `length` characters. + * Return 1 on success, 0 on failure. + * + * The length is supposed to be significantly less that the buffer size. + */ + +func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool { + /* Read handler must be set. */ + if parser.read_handler == nil { + panic("read handler must be set") + } + + /* If the EOF flag is set and the raw buffer is empty, do nothing. */ + + if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) { + return true + } + + /* Return if the buffer contains enough characters. */ + + if parser.unread >= length { + return true + } + + /* Determine the input encoding if it is not known yet. */ + + if parser.encoding == yaml_ANY_ENCODING { + if !yaml_parser_determine_encoding(parser) { + return false + } + } + + /* Move the unread characters to the beginning of the buffer. */ + buffer_end := len(parser.buffer) + if 0 < parser.buffer_pos && + parser.buffer_pos < buffer_end { + copy(parser.buffer, parser.buffer[parser.buffer_pos:]) + buffer_end -= parser.buffer_pos + parser.buffer_pos = 0 + } else if parser.buffer_pos == buffer_end { + buffer_end = 0 + parser.buffer_pos = 0 + } + + parser.buffer = parser.buffer[:cap(parser.buffer)] + + /* Fill the buffer until it has enough characters. */ + first := true + for parser.unread < length { + /* Fill the raw buffer if necessary. */ + + if !first || parser.raw_buffer_pos == len(parser.raw_buffer) { + if !yaml_parser_update_raw_buffer(parser) { + parser.buffer = parser.buffer[:buffer_end] + return false + } + } + first = false + + /* Decode the raw buffer. */ + for parser.raw_buffer_pos != len(parser.raw_buffer) { + var value rune + var w int + + raw_unread := len(parser.raw_buffer) - parser.raw_buffer_pos + incomplete := false + + /* Decode the next character. */ + + switch parser.encoding { + case yaml_UTF8_ENCODING: + + /* + * Decode a UTF-8 character. Check RFC 3629 + * (http://www.ietf.org/rfc/rfc3629.txt) for more details. + * + * The following table (taken from the RFC) is used for + * decoding. + * + * Char. number range | UTF-8 octet sequence + * (hexadecimal) | (binary) + * --------------------+------------------------------------ + * 0000 0000-0000 007F | 0xxxxxxx + * 0000 0080-0000 07FF | 110xxxxx 10xxxxxx + * 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx + * 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + * + * Additionally, the characters in the range 0xD800-0xDFFF + * are prohibited as they are reserved for use with UTF-16 + * surrogate pairs. + */ + + /* Determine the length of the UTF-8 sequence. */ + + octet := parser.raw_buffer[parser.raw_buffer_pos] + w = width(octet) + + /* Check if the leading octet is valid. */ + + if w == 0 { + return yaml_parser_set_reader_error(parser, + "invalid leading UTF-8 octet", + parser.offset, int(octet)) + } + + /* Check if the raw buffer contains an incomplete character. */ + + if w > raw_unread { + if parser.eof { + return yaml_parser_set_reader_error(parser, + "incomplete UTF-8 octet sequence", + parser.offset, -1) + } + incomplete = true + break + } + + /* Decode the leading octet. */ + switch { + case octet&0x80 == 0x00: + value = rune(octet & 0x7F) + case octet&0xE0 == 0xC0: + value = rune(octet & 0x1F) + case octet&0xF0 == 0xE0: + value = rune(octet & 0x0F) + case octet&0xF8 == 0xF0: + value = rune(octet & 0x07) + default: + value = 0 + } + + /* Check and decode the trailing octets. */ + + for k := 1; k < w; k++ { + octet = parser.raw_buffer[parser.raw_buffer_pos+k] + + /* Check if the octet is valid. */ + + if (octet & 0xC0) != 0x80 { + return yaml_parser_set_reader_error(parser, + "invalid trailing UTF-8 octet", + parser.offset+k, int(octet)) + } + + /* Decode the octet. */ + + value = (value << 6) + rune(octet&0x3F) + } + + /* Check the length of the sequence against the value. */ + switch { + case w == 1: + case w == 2 && value >= 0x80: + case w == 3 && value >= 0x800: + case w == 4 && value >= 0x10000: + default: + return yaml_parser_set_reader_error(parser, + "invalid length of a UTF-8 sequence", + parser.offset, -1) + } + + /* Check the range of the value. */ + + if (value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF { + return yaml_parser_set_reader_error(parser, + "invalid Unicode character", + parser.offset, int(value)) + } + case yaml_UTF16LE_ENCODING, + yaml_UTF16BE_ENCODING: + + var low, high int + if parser.encoding == yaml_UTF16LE_ENCODING { + low, high = 0, 1 + } else { + high, low = 1, 0 + } + + /* + * The UTF-16 encoding is not as simple as one might + * naively think. Check RFC 2781 + * (http://www.ietf.org/rfc/rfc2781.txt). + * + * Normally, two subsequent bytes describe a Unicode + * character. However a special technique (called a + * surrogate pair) is used for specifying character + * values larger than 0xFFFF. + * + * A surrogate pair consists of two pseudo-characters: + * high surrogate area (0xD800-0xDBFF) + * low surrogate area (0xDC00-0xDFFF) + * + * The following formulas are used for decoding + * and encoding characters using surrogate pairs: + * + * U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF) + * U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF) + * W1 = 110110yyyyyyyyyy + * W2 = 110111xxxxxxxxxx + * + * where U is the character value, W1 is the high surrogate + * area, W2 is the low surrogate area. + */ + + /* Check for incomplete UTF-16 character. */ + + if raw_unread < 2 { + if parser.eof { + return yaml_parser_set_reader_error(parser, + "incomplete UTF-16 character", + parser.offset, -1) + } + incomplete = true + break + } + + /* Get the character. */ + value = rune(parser.raw_buffer[parser.raw_buffer_pos+low]) + + (rune(parser.raw_buffer[parser.raw_buffer_pos+high]) << 8) + + /* Check for unexpected low surrogate area. */ + + if (value & 0xFC00) == 0xDC00 { + return yaml_parser_set_reader_error(parser, + "unexpected low surrogate area", + parser.offset, int(value)) + } + + /* Check for a high surrogate area. */ + + if (value & 0xFC00) == 0xD800 { + + w = 4 + + /* Check for incomplete surrogate pair. */ + + if raw_unread < 4 { + if parser.eof { + return yaml_parser_set_reader_error(parser, + "incomplete UTF-16 surrogate pair", + parser.offset, -1) + } + incomplete = true + break + } + + /* Get the next character. */ + + value2 := rune(parser.raw_buffer[parser.raw_buffer_pos+low+2]) + + (rune(parser.raw_buffer[parser.raw_buffer_pos+high+2]) << 8) + + /* Check for a low surrogate area. */ + + if (value2 & 0xFC00) != 0xDC00 { + return yaml_parser_set_reader_error(parser, + "expected low surrogate area", + parser.offset+2, int(value2)) + } + + /* Generate the value of the surrogate pair. */ + + value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF) + } else { + w = 2 + } + + break + + default: + panic("Impossible") /* Impossible. */ + } + + /* Check if the raw buffer contains enough bytes to form a character. */ + + if incomplete { + break + } + + /* + * Check if the character is in the allowed range: + * #x9 | #xA | #xD | [#x20-#x7E] (8 bit) + * | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit) + * | [#x10000-#x10FFFF] (32 bit) + */ + + if !(value == 0x09 || value == 0x0A || value == 0x0D || + (value >= 0x20 && value <= 0x7E) || + (value == 0x85) || (value >= 0xA0 && value <= 0xD7FF) || + (value >= 0xE000 && value <= 0xFFFD) || + (value >= 0x10000 && value <= 0x10FFFF)) { + return yaml_parser_set_reader_error(parser, + "control characters are not allowed", + parser.offset, int(value)) + } + + /* Move the raw pointers. */ + + parser.raw_buffer_pos += w + parser.offset += w + + /* Finally put the character into the buffer. */ + + /* 0000 0000-0000 007F . 0xxxxxxx */ + if value <= 0x7F { + parser.buffer[buffer_end] = byte(value) + } else if value <= 0x7FF { + /* 0000 0080-0000 07FF . 110xxxxx 10xxxxxx */ + parser.buffer[buffer_end] = byte(0xC0 + (value >> 6)) + parser.buffer[buffer_end+1] = byte(0x80 + (value & 0x3F)) + } else if value <= 0xFFFF { + /* 0000 0800-0000 FFFF . 1110xxxx 10xxxxxx 10xxxxxx */ + parser.buffer[buffer_end] = byte(0xE0 + (value >> 12)) + parser.buffer[buffer_end+1] = byte(0x80 + ((value >> 6) & 0x3F)) + parser.buffer[buffer_end+2] = byte(0x80 + (value & 0x3F)) + } else { + /* 0001 0000-0010 FFFF . 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ + parser.buffer[buffer_end] = byte(0xF0 + (value >> 18)) + parser.buffer[buffer_end+1] = byte(0x80 + ((value >> 12) & 0x3F)) + parser.buffer[buffer_end+2] = byte(0x80 + ((value >> 6) & 0x3F)) + parser.buffer[buffer_end+3] = byte(0x80 + (value & 0x3F)) + } + + buffer_end += w + parser.unread++ + } + + /* On EOF, put NUL into the buffer and return. */ + + if parser.eof { + parser.buffer[buffer_end] = 0 + buffer_end++ + parser.buffer = parser.buffer[:buffer_end] + parser.unread++ + return true + } + + } + + parser.buffer = parser.buffer[:buffer_end] + return true +} diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/resolver.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/resolver.go new file mode 100644 index 00000000..fb9e8be8 --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/resolver.go @@ -0,0 +1,449 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "bytes" + "encoding/base64" + "fmt" + "math" + "reflect" + "regexp" + "strconv" + "strings" + "time" +) + +var byteSliceType = reflect.TypeOf([]byte(nil)) + +var binary_tags = [][]byte{[]byte("!binary"), []byte(yaml_BINARY_TAG)} +var bool_values map[string]bool +var null_values map[string]bool + +var signs = []byte{'-', '+'} +var nulls = []byte{'~', 'n', 'N'} +var bools = []byte{'t', 'T', 'f', 'F', 'y', 'Y', 'n', 'N', 'o', 'O'} + +var timestamp_regexp *regexp.Regexp +var ymd_regexp *regexp.Regexp + +func init() { + bool_values = make(map[string]bool) + bool_values["y"] = true + bool_values["yes"] = true + bool_values["n"] = false + bool_values["no"] = false + bool_values["true"] = true + bool_values["false"] = false + bool_values["on"] = true + bool_values["off"] = false + + null_values = make(map[string]bool) + null_values["~"] = true + null_values["null"] = true + null_values["Null"] = true + null_values["NULL"] = true + + timestamp_regexp = regexp.MustCompile("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:(?:[Tt]|[ \t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \t]*(?:Z|([-+][0-9][0-9]?)(?::([0-9][0-9])?)?))?)?$") + ymd_regexp = regexp.MustCompile("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)$") +} + +func resolve(event yaml_event_t, v reflect.Value, useNumber bool) (string, error) { + val := string(event.value) + + if null_values[val] { + v.Set(reflect.Zero(v.Type())) + return yaml_NULL_TAG, nil + } + + switch v.Kind() { + case reflect.String: + if useNumber && v.Type() == numberType { + tag, i := resolveInterface(event, useNumber) + if n, ok := i.(Number); ok { + v.Set(reflect.ValueOf(n)) + return tag, nil + } + return "", fmt.Errorf("Not a number: '%s' at %s", event.value, event.start_mark) + } + + return resolve_string(val, v, event) + case reflect.Bool: + return resolve_bool(val, v, event) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return resolve_int(val, v, useNumber, event) + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + return resolve_uint(val, v, useNumber, event) + case reflect.Float32, reflect.Float64: + return resolve_float(val, v, useNumber, event) + case reflect.Interface: + _, i := resolveInterface(event, useNumber) + if i != nil { + v.Set(reflect.ValueOf(i)) + } else { + v.Set(reflect.Zero(v.Type())) + } + + case reflect.Struct: + return resolve_time(val, v, event) + case reflect.Slice: + if v.Type() != byteSliceType { + return "", fmt.Errorf("Cannot resolve %s into %s at %s", val, v.String(), event.start_mark) + } + b, err := decode_binary(event.value, event) + if err != nil { + return "", err + } + + v.Set(reflect.ValueOf(b)) + default: + return "", fmt.Errorf("Unknown resolution for '%s' using %s at %s", val, v.String(), event.start_mark) + } + + return yaml_STR_TAG, nil +} + +func hasBinaryTag(event yaml_event_t) bool { + for _, tag := range binary_tags { + if bytes.Equal(event.tag, tag) { + return true + } + } + return false +} + +func decode_binary(value []byte, event yaml_event_t) ([]byte, error) { + b := make([]byte, base64.StdEncoding.DecodedLen(len(value))) + n, err := base64.StdEncoding.Decode(b, value) + if err != nil { + return nil, fmt.Errorf("Invalid base64 text: '%s' at %s", string(b), event.start_mark) + } + return b[:n], nil +} + +func resolve_string(val string, v reflect.Value, event yaml_event_t) (string, error) { + if len(event.tag) > 0 { + if hasBinaryTag(event) { + b, err := decode_binary(event.value, event) + if err != nil { + return "", err + } + val = string(b) + } + } + v.SetString(val) + return yaml_STR_TAG, nil +} + +func resolve_bool(val string, v reflect.Value, event yaml_event_t) (string, error) { + b, found := bool_values[strings.ToLower(val)] + if !found { + return "", fmt.Errorf("Invalid boolean: '%s' at %s", val, event.start_mark) + } + + v.SetBool(b) + return yaml_BOOL_TAG, nil +} + +func resolve_int(val string, v reflect.Value, useNumber bool, event yaml_event_t) (string, error) { + original := val + val = strings.Replace(val, "_", "", -1) + var value uint64 + + isNumberValue := v.Type() == numberType + + sign := int64(1) + if val[0] == '-' { + sign = -1 + val = val[1:] + } else if val[0] == '+' { + val = val[1:] + } + + base := 0 + if val == "0" { + if isNumberValue { + v.SetString("0") + } else { + v.Set(reflect.Zero(v.Type())) + } + + return yaml_INT_TAG, nil + } + + if strings.HasPrefix(val, "0o") { + base = 8 + val = val[2:] + } + + value, err := strconv.ParseUint(val, base, 64) + if err != nil { + return "", fmt.Errorf("Invalid integer: '%s' at %s", original, event.start_mark) + } + + var val64 int64 + if value <= math.MaxInt64 { + val64 = int64(value) + if sign == -1 { + val64 = -val64 + } + } else if sign == -1 && value == uint64(math.MaxInt64)+1 { + val64 = math.MinInt64 + } else { + return "", fmt.Errorf("Invalid integer: '%s' at %s", original, event.start_mark) + } + + if isNumberValue { + v.SetString(strconv.FormatInt(val64, 10)) + } else { + if v.OverflowInt(val64) { + return "", fmt.Errorf("Invalid integer: '%s' at %s", original, event.start_mark) + } + v.SetInt(val64) + } + + return yaml_INT_TAG, nil +} + +func resolve_uint(val string, v reflect.Value, useNumber bool, event yaml_event_t) (string, error) { + original := val + val = strings.Replace(val, "_", "", -1) + var value uint64 + + isNumberValue := v.Type() == numberType + + if val[0] == '-' { + return "", fmt.Errorf("Unsigned int with negative value: '%s' at %s", original, event.start_mark) + } + + if val[0] == '+' { + val = val[1:] + } + + base := 0 + if val == "0" { + if isNumberValue { + v.SetString("0") + } else { + v.Set(reflect.Zero(v.Type())) + } + + return yaml_INT_TAG, nil + } + + if strings.HasPrefix(val, "0o") { + base = 8 + val = val[2:] + } + + value, err := strconv.ParseUint(val, base, 64) + if err != nil { + return "", fmt.Errorf("Invalid unsigned integer: '%s' at %s", val, event.start_mark) + } + + if isNumberValue { + v.SetString(strconv.FormatUint(value, 10)) + } else { + if v.OverflowUint(value) { + return "", fmt.Errorf("Invalid unsigned integer: '%s' at %s", val, event.start_mark) + } + + v.SetUint(value) + } + + return yaml_INT_TAG, nil +} + +func resolve_float(val string, v reflect.Value, useNumber bool, event yaml_event_t) (string, error) { + val = strings.Replace(val, "_", "", -1) + var value float64 + + isNumberValue := v.Type() == numberType + typeBits := 64 + if !isNumberValue { + typeBits = v.Type().Bits() + } + + sign := 1 + if val[0] == '-' { + sign = -1 + val = val[1:] + } else if val[0] == '+' { + val = val[1:] + } + + valLower := strings.ToLower(val) + if valLower == ".inf" { + value = math.Inf(sign) + } else if valLower == ".nan" { + value = math.NaN() + } else { + var err error + value, err = strconv.ParseFloat(val, typeBits) + value *= float64(sign) + + if err != nil { + return "", fmt.Errorf("Invalid float: '%s' at %s", val, event.start_mark) + } + } + + if isNumberValue { + v.SetString(strconv.FormatFloat(value, 'g', -1, typeBits)) + } else { + if v.OverflowFloat(value) { + return "", fmt.Errorf("Invalid float: '%s' at %s", val, event.start_mark) + } + + v.SetFloat(value) + } + + return yaml_FLOAT_TAG, nil +} + +func resolve_time(val string, v reflect.Value, event yaml_event_t) (string, error) { + var parsedTime time.Time + matches := ymd_regexp.FindStringSubmatch(val) + if len(matches) > 0 { + year, _ := strconv.Atoi(matches[1]) + month, _ := strconv.Atoi(matches[2]) + day, _ := strconv.Atoi(matches[3]) + parsedTime = time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC) + } else { + matches = timestamp_regexp.FindStringSubmatch(val) + if len(matches) == 0 { + return "", fmt.Errorf("Invalid timestamp: '%s' at %s", val, event.start_mark) + } + + year, _ := strconv.Atoi(matches[1]) + month, _ := strconv.Atoi(matches[2]) + day, _ := strconv.Atoi(matches[3]) + hour, _ := strconv.Atoi(matches[4]) + min, _ := strconv.Atoi(matches[5]) + sec, _ := strconv.Atoi(matches[6]) + + nsec := 0 + if matches[7] != "" { + millis, _ := strconv.Atoi(matches[7]) + nsec = int(time.Duration(millis) * time.Millisecond) + } + + loc := time.UTC + if matches[8] != "" { + sign := matches[8][0] + hr, _ := strconv.Atoi(matches[8][1:]) + min := 0 + if matches[9] != "" { + min, _ = strconv.Atoi(matches[9]) + } + + zoneOffset := (hr*60 + min) * 60 + if sign == '-' { + zoneOffset = -zoneOffset + } + + loc = time.FixedZone("", zoneOffset) + } + parsedTime = time.Date(year, time.Month(month), day, hour, min, sec, nsec, loc) + } + + v.Set(reflect.ValueOf(parsedTime)) + return "", nil +} + +func resolveInterface(event yaml_event_t, useNumber bool) (string, interface{}) { + val := string(event.value) + if len(event.tag) == 0 && !event.implicit { + return "", val + } + + if len(val) == 0 { + return yaml_NULL_TAG, nil + } + + var result interface{} + + sign := false + c := val[0] + switch { + case bytes.IndexByte(signs, c) != -1: + sign = true + fallthrough + case c >= '0' && c <= '9': + i := int64(0) + result = &i + if useNumber { + var n Number + result = &n + } + + v := reflect.ValueOf(result).Elem() + if _, err := resolve_int(val, v, useNumber, event); err == nil { + return yaml_INT_TAG, v.Interface() + } + + f := float64(0) + result = &f + if useNumber { + var n Number + result = &n + } + + v = reflect.ValueOf(result).Elem() + if _, err := resolve_float(val, v, useNumber, event); err == nil { + return yaml_FLOAT_TAG, v.Interface() + } + + if !sign { + t := time.Time{} + if _, err := resolve_time(val, reflect.ValueOf(&t).Elem(), event); err == nil { + return "", t + } + } + case bytes.IndexByte(nulls, c) != -1: + if null_values[val] { + return yaml_NULL_TAG, nil + } + b := false + if _, err := resolve_bool(val, reflect.ValueOf(&b).Elem(), event); err == nil { + return yaml_BOOL_TAG, b + } + case c == '.': + f := float64(0) + result = &f + if useNumber { + var n Number + result = &n + } + + v := reflect.ValueOf(result).Elem() + if _, err := resolve_float(val, v, useNumber, event); err == nil { + return yaml_FLOAT_TAG, v.Interface() + } + case bytes.IndexByte(bools, c) != -1: + b := false + if _, err := resolve_bool(val, reflect.ValueOf(&b).Elem(), event); err == nil { + return yaml_BOOL_TAG, b + } + } + + if hasBinaryTag(event) { + bytes, err := decode_binary(event.value, event) + if err == nil { + return yaml_BINARY_TAG, bytes + } + } + + return yaml_STR_TAG, val +} diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/run_parser.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/run_parser.go new file mode 100644 index 00000000..25c29816 --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/run_parser.go @@ -0,0 +1,62 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "fmt" + "os" +) + +func Run_parser(cmd string, args []string) { + for i := 0; i < len(args); i++ { + fmt.Printf("[%d] Scanning '%s'", i, args[i]) + file, err := os.Open(args[i]) + if err != nil { + panic(fmt.Sprintf("Invalid file '%s': %s", args[i], err.Error())) + } + + parser := yaml_parser_t{} + yaml_parser_initialize(&parser) + yaml_parser_set_input_reader(&parser, file) + + failed := false + token := yaml_token_t{} + count := 0 + for { + if !yaml_parser_scan(&parser, &token) { + failed = true + break + } + + if token.token_type == yaml_STREAM_END_TOKEN { + break + } + count++ + } + + file.Close() + + msg := "SUCCESS" + if failed { + msg = "FAILED" + if parser.error != yaml_NO_ERROR { + m := parser.problem_mark + fmt.Printf("ERROR: (%s) %s @ line: %d col: %d\n", + parser.context, parser.problem, m.line, m.column) + } + } + fmt.Printf("%s (%d tokens)\n", msg, count) + } +} diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/scanner.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/scanner.go new file mode 100644 index 00000000..5c080a06 --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/scanner.go @@ -0,0 +1,3318 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "bytes" +) + +/* + * Introduction + * ************ + * + * The following notes assume that you are familiar with the YAML specification + * (http://yaml.org/spec/cvs/current.html). We mostly follow it, although in + * some cases we are less restrictive that it requires. + * + * The process of transforming a YAML stream into a sequence of events is + * divided on two steps: Scanning and Parsing. + * + * The Scanner transforms the input stream into a sequence of tokens, while the + * parser transform the sequence of tokens produced by the Scanner into a + * sequence of parsing events. + * + * The Scanner is rather clever and complicated. The Parser, on the contrary, + * is a straightforward implementation of a recursive-descendant parser (or, + * LL(1) parser, as it is usually called). + * + * Actually there are two issues of Scanning that might be called "clever", the + * rest is quite straightforward. The issues are "block collection start" and + * "simple keys". Both issues are explained below in details. + * + * Here the Scanning step is explained and implemented. We start with the list + * of all the tokens produced by the Scanner together with short descriptions. + * + * Now, tokens: + * + * STREAM-START(encoding) # The stream start. + * STREAM-END # The stream end. + * VERSION-DIRECTIVE(major,minor) # The '%YAML' directive. + * TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive. + * DOCUMENT-START # '---' + * DOCUMENT-END # '...' + * BLOCK-SEQUENCE-START # Indentation increase denoting a block + * BLOCK-MAPPING-START # sequence or a block mapping. + * BLOCK-END # Indentation decrease. + * FLOW-SEQUENCE-START # '[' + * FLOW-SEQUENCE-END # ']' + * BLOCK-SEQUENCE-START # '{' + * BLOCK-SEQUENCE-END # '}' + * BLOCK-ENTRY # '-' + * FLOW-ENTRY # ',' + * KEY # '?' or nothing (simple keys). + * VALUE # ':' + * ALIAS(anchor) # '*anchor' + * ANCHOR(anchor) # '&anchor' + * TAG(handle,suffix) # '!handle!suffix' + * SCALAR(value,style) # A scalar. + * + * The following two tokens are "virtual" tokens denoting the beginning and the + * end of the stream: + * + * STREAM-START(encoding) + * STREAM-END + * + * We pass the information about the input stream encoding with the + * STREAM-START token. + * + * The next two tokens are responsible for tags: + * + * VERSION-DIRECTIVE(major,minor) + * TAG-DIRECTIVE(handle,prefix) + * + * Example: + * + * %YAML 1.1 + * %TAG ! !foo + * %TAG !yaml! tag:yaml.org,2002: + * --- + * + * The correspoding sequence of tokens: + * + * STREAM-START(utf-8) + * VERSION-DIRECTIVE(1,1) + * TAG-DIRECTIVE("!","!foo") + * TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:") + * DOCUMENT-START + * STREAM-END + * + * Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole + * line. + * + * The document start and end indicators are represented by: + * + * DOCUMENT-START + * DOCUMENT-END + * + * Note that if a YAML stream contains an implicit document (without '---' + * and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be + * produced. + * + * In the following examples, we present whole documents together with the + * produced tokens. + * + * 1. An implicit document: + * + * 'a scalar' + * + * Tokens: + * + * STREAM-START(utf-8) + * SCALAR("a scalar",single-quoted) + * STREAM-END + * + * 2. An explicit document: + * + * --- + * 'a scalar' + * ... + * + * Tokens: + * + * STREAM-START(utf-8) + * DOCUMENT-START + * SCALAR("a scalar",single-quoted) + * DOCUMENT-END + * STREAM-END + * + * 3. Several documents in a stream: + * + * 'a scalar' + * --- + * 'another scalar' + * --- + * 'yet another scalar' + * + * Tokens: + * + * STREAM-START(utf-8) + * SCALAR("a scalar",single-quoted) + * DOCUMENT-START + * SCALAR("another scalar",single-quoted) + * DOCUMENT-START + * SCALAR("yet another scalar",single-quoted) + * STREAM-END + * + * We have already introduced the SCALAR token above. The following tokens are + * used to describe aliases, anchors, tag, and scalars: + * + * ALIAS(anchor) + * ANCHOR(anchor) + * TAG(handle,suffix) + * SCALAR(value,style) + * + * The following series of examples illustrate the usage of these tokens: + * + * 1. A recursive sequence: + * + * &A [ *A ] + * + * Tokens: + * + * STREAM-START(utf-8) + * ANCHOR("A") + * FLOW-SEQUENCE-START + * ALIAS("A") + * FLOW-SEQUENCE-END + * STREAM-END + * + * 2. A tagged scalar: + * + * !!float "3.14" # A good approximation. + * + * Tokens: + * + * STREAM-START(utf-8) + * TAG("!!","float") + * SCALAR("3.14",double-quoted) + * STREAM-END + * + * 3. Various scalar styles: + * + * --- # Implicit empty plain scalars do not produce tokens. + * --- a plain scalar + * --- 'a single-quoted scalar' + * --- "a double-quoted scalar" + * --- |- + * a literal scalar + * --- >- + * a folded + * scalar + * + * Tokens: + * + * STREAM-START(utf-8) + * DOCUMENT-START + * DOCUMENT-START + * SCALAR("a plain scalar",plain) + * DOCUMENT-START + * SCALAR("a single-quoted scalar",single-quoted) + * DOCUMENT-START + * SCALAR("a double-quoted scalar",double-quoted) + * DOCUMENT-START + * SCALAR("a literal scalar",literal) + * DOCUMENT-START + * SCALAR("a folded scalar",folded) + * STREAM-END + * + * Now it's time to review collection-related tokens. We will start with + * flow collections: + * + * FLOW-SEQUENCE-START + * FLOW-SEQUENCE-END + * FLOW-MAPPING-START + * FLOW-MAPPING-END + * FLOW-ENTRY + * KEY + * VALUE + * + * The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and + * FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}' + * correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the + * indicators '?' and ':', which are used for denoting mapping keys and values, + * are represented by the KEY and VALUE tokens. + * + * The following examples show flow collections: + * + * 1. A flow sequence: + * + * [item 1, item 2, item 3] + * + * Tokens: + * + * STREAM-START(utf-8) + * FLOW-SEQUENCE-START + * SCALAR("item 1",plain) + * FLOW-ENTRY + * SCALAR("item 2",plain) + * FLOW-ENTRY + * SCALAR("item 3",plain) + * FLOW-SEQUENCE-END + * STREAM-END + * + * 2. A flow mapping: + * + * { + * a simple key: a value, # Note that the KEY token is produced. + * ? a complex key: another value, + * } + * + * Tokens: + * + * STREAM-START(utf-8) + * FLOW-MAPPING-START + * KEY + * SCALAR("a simple key",plain) + * VALUE + * SCALAR("a value",plain) + * FLOW-ENTRY + * KEY + * SCALAR("a complex key",plain) + * VALUE + * SCALAR("another value",plain) + * FLOW-ENTRY + * FLOW-MAPPING-END + * STREAM-END + * + * A simple key is a key which is not denoted by the '?' indicator. Note that + * the Scanner still produce the KEY token whenever it encounters a simple key. + * + * For scanning block collections, the following tokens are used (note that we + * repeat KEY and VALUE here): + * + * BLOCK-SEQUENCE-START + * BLOCK-MAPPING-START + * BLOCK-END + * BLOCK-ENTRY + * KEY + * VALUE + * + * The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation + * increase that precedes a block collection (cf. the INDENT token in Python). + * The token BLOCK-END denote indentation decrease that ends a block collection + * (cf. the DEDENT token in Python). However YAML has some syntax pecularities + * that makes detections of these tokens more complex. + * + * The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators + * '-', '?', and ':' correspondingly. + * + * The following examples show how the tokens BLOCK-SEQUENCE-START, + * BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner: + * + * 1. Block sequences: + * + * - item 1 + * - item 2 + * - + * - item 3.1 + * - item 3.2 + * - + * key 1: value 1 + * key 2: value 2 + * + * Tokens: + * + * STREAM-START(utf-8) + * BLOCK-SEQUENCE-START + * BLOCK-ENTRY + * SCALAR("item 1",plain) + * BLOCK-ENTRY + * SCALAR("item 2",plain) + * BLOCK-ENTRY + * BLOCK-SEQUENCE-START + * BLOCK-ENTRY + * SCALAR("item 3.1",plain) + * BLOCK-ENTRY + * SCALAR("item 3.2",plain) + * BLOCK-END + * BLOCK-ENTRY + * BLOCK-MAPPING-START + * KEY + * SCALAR("key 1",plain) + * VALUE + * SCALAR("value 1",plain) + * KEY + * SCALAR("key 2",plain) + * VALUE + * SCALAR("value 2",plain) + * BLOCK-END + * BLOCK-END + * STREAM-END + * + * 2. Block mappings: + * + * a simple key: a value # The KEY token is produced here. + * ? a complex key + * : another value + * a mapping: + * key 1: value 1 + * key 2: value 2 + * a sequence: + * - item 1 + * - item 2 + * + * Tokens: + * + * STREAM-START(utf-8) + * BLOCK-MAPPING-START + * KEY + * SCALAR("a simple key",plain) + * VALUE + * SCALAR("a value",plain) + * KEY + * SCALAR("a complex key",plain) + * VALUE + * SCALAR("another value",plain) + * KEY + * SCALAR("a mapping",plain) + * BLOCK-MAPPING-START + * KEY + * SCALAR("key 1",plain) + * VALUE + * SCALAR("value 1",plain) + * KEY + * SCALAR("key 2",plain) + * VALUE + * SCALAR("value 2",plain) + * BLOCK-END + * KEY + * SCALAR("a sequence",plain) + * VALUE + * BLOCK-SEQUENCE-START + * BLOCK-ENTRY + * SCALAR("item 1",plain) + * BLOCK-ENTRY + * SCALAR("item 2",plain) + * BLOCK-END + * BLOCK-END + * STREAM-END + * + * YAML does not always require to start a new block collection from a new + * line. If the current line contains only '-', '?', and ':' indicators, a new + * block collection may start at the current line. The following examples + * illustrate this case: + * + * 1. Collections in a sequence: + * + * - - item 1 + * - item 2 + * - key 1: value 1 + * key 2: value 2 + * - ? complex key + * : complex value + * + * Tokens: + * + * STREAM-START(utf-8) + * BLOCK-SEQUENCE-START + * BLOCK-ENTRY + * BLOCK-SEQUENCE-START + * BLOCK-ENTRY + * SCALAR("item 1",plain) + * BLOCK-ENTRY + * SCALAR("item 2",plain) + * BLOCK-END + * BLOCK-ENTRY + * BLOCK-MAPPING-START + * KEY + * SCALAR("key 1",plain) + * VALUE + * SCALAR("value 1",plain) + * KEY + * SCALAR("key 2",plain) + * VALUE + * SCALAR("value 2",plain) + * BLOCK-END + * BLOCK-ENTRY + * BLOCK-MAPPING-START + * KEY + * SCALAR("complex key") + * VALUE + * SCALAR("complex value") + * BLOCK-END + * BLOCK-END + * STREAM-END + * + * 2. Collections in a mapping: + * + * ? a sequence + * : - item 1 + * - item 2 + * ? a mapping + * : key 1: value 1 + * key 2: value 2 + * + * Tokens: + * + * STREAM-START(utf-8) + * BLOCK-MAPPING-START + * KEY + * SCALAR("a sequence",plain) + * VALUE + * BLOCK-SEQUENCE-START + * BLOCK-ENTRY + * SCALAR("item 1",plain) + * BLOCK-ENTRY + * SCALAR("item 2",plain) + * BLOCK-END + * KEY + * SCALAR("a mapping",plain) + * VALUE + * BLOCK-MAPPING-START + * KEY + * SCALAR("key 1",plain) + * VALUE + * SCALAR("value 1",plain) + * KEY + * SCALAR("key 2",plain) + * VALUE + * SCALAR("value 2",plain) + * BLOCK-END + * BLOCK-END + * STREAM-END + * + * YAML also permits non-indented sequences if they are included into a block + * mapping. In this case, the token BLOCK-SEQUENCE-START is not produced: + * + * key: + * - item 1 # BLOCK-SEQUENCE-START is NOT produced here. + * - item 2 + * + * Tokens: + * + * STREAM-START(utf-8) + * BLOCK-MAPPING-START + * KEY + * SCALAR("key",plain) + * VALUE + * BLOCK-ENTRY + * SCALAR("item 1",plain) + * BLOCK-ENTRY + * SCALAR("item 2",plain) + * BLOCK-END + */ + +/* + * Ensure that the buffer contains the required number of characters. + * Return 1 on success, 0 on failure (reader error or memory error). + */ +func cache(parser *yaml_parser_t, length int) bool { + if parser.unread >= length { + return true + } + + return yaml_parser_update_buffer(parser, length) +} + +/* + * Advance the buffer pointer. + */ +func skip(parser *yaml_parser_t) { + parser.mark.index++ + parser.mark.column++ + parser.unread-- + parser.buffer_pos += width(parser.buffer[parser.buffer_pos]) +} + +func skip_line(parser *yaml_parser_t) { + if is_crlf_at(parser.buffer, parser.buffer_pos) { + parser.mark.index += 2 + parser.mark.column = 0 + parser.mark.line++ + parser.unread -= 2 + parser.buffer_pos += 2 + } else if is_break_at(parser.buffer, parser.buffer_pos) { + parser.mark.index++ + parser.mark.column = 0 + parser.mark.line++ + parser.unread-- + parser.buffer_pos += width(parser.buffer[parser.buffer_pos]) + } +} + +/* + * Copy a character to a string buffer and advance pointers. + */ + +func read(parser *yaml_parser_t, s []byte) []byte { + w := width(parser.buffer[parser.buffer_pos]) + if w == 0 { + panic("invalid character sequence") + } + if len(s) == 0 { + s = make([]byte, 0, 32) + } + if w == 1 && len(s)+w <= cap(s) { + s = s[:len(s)+1] + s[len(s)-1] = parser.buffer[parser.buffer_pos] + parser.buffer_pos++ + } else { + s = append(s, parser.buffer[parser.buffer_pos:parser.buffer_pos+w]...) + parser.buffer_pos += w + } + parser.mark.index++ + parser.mark.column++ + parser.unread-- + return s +} + +/* + * Copy a line break character to a string buffer and advance pointers. + */ +func read_line(parser *yaml_parser_t, s []byte) []byte { + buf := parser.buffer + pos := parser.buffer_pos + if buf[pos] == '\r' && buf[pos+1] == '\n' { + /* CR LF . LF */ + s = append(s, '\n') + parser.buffer_pos += 2 + parser.mark.index++ + parser.unread-- + } else if buf[pos] == '\r' || buf[pos] == '\n' { + /* CR|LF . LF */ + s = append(s, '\n') + parser.buffer_pos += 1 + } else if buf[pos] == '\xC2' && buf[pos+1] == '\x85' { + /* NEL . LF */ + s = append(s, '\n') + parser.buffer_pos += 2 + } else if buf[pos] == '\xE2' && buf[pos+1] == '\x80' && + (buf[pos+2] == '\xA8' || buf[pos+2] == '\xA9') { + // LS|PS . LS|PS + s = append(s, buf[parser.buffer_pos:pos+3]...) + parser.buffer_pos += 3 + } else { + return s + } + + parser.mark.index++ + parser.mark.column = 0 + parser.mark.line++ + parser.unread-- + return s +} + +/* + * Get the next token. + */ + +func yaml_parser_scan(parser *yaml_parser_t, token *yaml_token_t) bool { + /* Erase the token object. */ + *token = yaml_token_t{} + + /* No tokens after STREAM-END or error. */ + + if parser.stream_end_produced || parser.error != yaml_NO_ERROR { + return true + } + + /* Ensure that the tokens queue contains enough tokens. */ + + if !parser.token_available { + if !yaml_parser_fetch_more_tokens(parser) { + return false + } + } + + /* Fetch the next token from the queue. */ + + *token = parser.tokens[parser.tokens_head] + parser.tokens_head++ + parser.token_available = false + parser.tokens_parsed++ + + if token.token_type == yaml_STREAM_END_TOKEN { + parser.stream_end_produced = true + } + + return true +} + +/* + * Set the scanner error and return 0. + */ + +func yaml_parser_set_scanner_error(parser *yaml_parser_t, context string, + context_mark YAML_mark_t, problem string) bool { + parser.error = yaml_SCANNER_ERROR + parser.context = context + parser.context_mark = context_mark + parser.problem = problem + parser.problem_mark = parser.mark + + return false +} + +func yaml_parser_set_scanner_tag_error(parser *yaml_parser_t, directive bool, context_mark YAML_mark_t, problem string) bool { + context := "while parsing a %TAG directive" + if directive { + context = "while parsing a tag" + } + return yaml_parser_set_scanner_error(parser, context, context_mark, "did not find URI escaped octet") +} + +/* + * Ensure that the tokens queue contains at least one token which can be + * returned to the Parser. + */ + +func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool { + /* While we need more tokens to fetch, do it. */ + + for { + /* + * Check if we really need to fetch more tokens. + */ + + need_more_tokens := false + + if parser.tokens_head == len(parser.tokens) { + /* Queue is empty. */ + + need_more_tokens = true + } else { + + /* Check if any potential simple key may occupy the head position. */ + + if !yaml_parser_stale_simple_keys(parser) { + return false + } + + for i := range parser.simple_keys { + simple_key := &parser.simple_keys[i] + + if simple_key.possible && + simple_key.token_number == parser.tokens_parsed { + need_more_tokens = true + break + } + } + } + if len(parser.simple_keys) > 0 { + + } + /* We are finished. */ + + if !need_more_tokens { + break + } + + /* Fetch the next token. */ + + if !yaml_parser_fetch_next_token(parser) { + return false + } + + } + + parser.token_available = true + + return true +} + +/* + * The dispatcher for token fetchers. + */ + +func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool { + /* Ensure that the buffer is initialized. */ + + if !cache(parser, 1) { + return false + } + + /* Check if we just started scanning. Fetch STREAM-START then. */ + + if !parser.stream_start_produced { + return yaml_parser_fetch_stream_start(parser) + } + + /* Eat whitespaces and comments until we reach the next token. */ + + if !yaml_parser_scan_to_next_token(parser) { + return false + } + + /* Remove obsolete potential simple keys. */ + + if !yaml_parser_stale_simple_keys(parser) { + return false + } + + /* Check the indentation level against the current column. */ + + if !yaml_parser_unroll_indent(parser, parser.mark.column) { + return false + } + + /* + * Ensure that the buffer contains at least 4 characters. 4 is the length + * of the longest indicators ('--- ' and '... '). + */ + + if !cache(parser, 4) { + return false + } + + /* Is it the end of the stream? */ + buf := parser.buffer + pos := parser.buffer_pos + + if is_z(buf[pos]) { + return yaml_parser_fetch_stream_end(parser) + } + + /* Is it a directive? */ + + if parser.mark.column == 0 && buf[pos] == '%' { + return yaml_parser_fetch_directive(parser) + } + + /* Is it the document start indicator? */ + + if parser.mark.column == 0 && + buf[pos] == '-' && buf[pos+1] == '-' && buf[pos+2] == '-' && + is_blankz_at(buf, pos+3) { + return yaml_parser_fetch_document_indicator(parser, + yaml_DOCUMENT_START_TOKEN) + } + + /* Is it the document end indicator? */ + + if parser.mark.column == 0 && + buf[pos] == '.' && buf[pos+1] == '.' && buf[pos+2] == '.' && + is_blankz_at(buf, pos+3) { + return yaml_parser_fetch_document_indicator(parser, + yaml_DOCUMENT_END_TOKEN) + } + + /* Is it the flow sequence start indicator? */ + + if buf[pos] == '[' { + return yaml_parser_fetch_flow_collection_start(parser, + yaml_FLOW_SEQUENCE_START_TOKEN) + } + + /* Is it the flow mapping start indicator? */ + + if buf[pos] == '{' { + return yaml_parser_fetch_flow_collection_start(parser, + yaml_FLOW_MAPPING_START_TOKEN) + } + + /* Is it the flow sequence end indicator? */ + + if buf[pos] == ']' { + return yaml_parser_fetch_flow_collection_end(parser, + yaml_FLOW_SEQUENCE_END_TOKEN) + } + + /* Is it the flow mapping end indicator? */ + + if buf[pos] == '}' { + return yaml_parser_fetch_flow_collection_end(parser, + yaml_FLOW_MAPPING_END_TOKEN) + } + + /* Is it the flow entry indicator? */ + + if buf[pos] == ',' { + return yaml_parser_fetch_flow_entry(parser) + } + + /* Is it the block entry indicator? */ + if buf[pos] == '-' && is_blankz_at(buf, pos+1) { + return yaml_parser_fetch_block_entry(parser) + } + + /* Is it the key indicator? */ + if buf[pos] == '?' && + (parser.flow_level > 0 || is_blankz_at(buf, pos+1)) { + return yaml_parser_fetch_key(parser) + } + + /* Is it the value indicator? */ + if buf[pos] == ':' && + (parser.flow_level > 0 || is_blankz_at(buf, pos+1)) { + return yaml_parser_fetch_value(parser) + } + + /* Is it an alias? */ + if buf[pos] == '*' { + return yaml_parser_fetch_anchor(parser, yaml_ALIAS_TOKEN) + } + + /* Is it an anchor? */ + + if buf[pos] == '&' { + return yaml_parser_fetch_anchor(parser, yaml_ANCHOR_TOKEN) + } + + /* Is it a tag? */ + + if buf[pos] == '!' { + return yaml_parser_fetch_tag(parser) + } + + /* Is it a literal scalar? */ + if buf[pos] == '|' && parser.flow_level == 0 { + return yaml_parser_fetch_block_scalar(parser, true) + } + + /* Is it a folded scalar? */ + if buf[pos] == '>' && parser.flow_level == 0 { + return yaml_parser_fetch_block_scalar(parser, false) + } + + /* Is it a single-quoted scalar? */ + + if buf[pos] == '\'' { + return yaml_parser_fetch_flow_scalar(parser, true) + } + + /* Is it a double-quoted scalar? */ + if buf[pos] == '"' { + return yaml_parser_fetch_flow_scalar(parser, false) + } + + /* + * Is it a plain scalar? + * + * A plain scalar may start with any non-blank characters except + * + * '-', '?', ':', ',', '[', ']', '{', '}', + * '#', '&', '*', '!', '|', '>', '\'', '\"', + * '%', '@', '`'. + * + * In the block context (and, for the '-' indicator, in the flow context + * too), it may also start with the characters + * + * '-', '?', ':' + * + * if it is followed by a non-space character. + * + * The last rule is more restrictive than the specification requires. + */ + + b := buf[pos] + if !(is_blankz_at(buf, pos) || b == '-' || + b == '?' || b == ':' || + b == ',' || b == '[' || + b == ']' || b == '{' || + b == '}' || b == '#' || + b == '&' || b == '*' || + b == '!' || b == '|' || + b == '>' || b == '\'' || + b == '"' || b == '%' || + b == '@' || b == '`') || + (b == '-' && !is_blank(buf[pos+1])) || + (parser.flow_level == 0 && + (buf[pos] == '?' || buf[pos] == ':') && + !is_blank(buf[pos+1])) { + return yaml_parser_fetch_plain_scalar(parser) + } + + /* + * If we don't determine the token type so far, it is an error. + */ + + return yaml_parser_set_scanner_error(parser, + "while scanning for the next token", parser.mark, + "found character that cannot start any token") +} + +/* + * Check the list of potential simple keys and remove the positions that + * cannot contain simple keys anymore. + */ + +func yaml_parser_stale_simple_keys(parser *yaml_parser_t) bool { + /* Check for a potential simple key for each flow level. */ + + for i := range parser.simple_keys { + /* + * The specification requires that a simple key + * + * - is limited to a single line, + * - is shorter than 1024 characters. + */ + + simple_key := &parser.simple_keys[i] + if simple_key.possible && + (simple_key.mark.line < parser.mark.line || + simple_key.mark.index+1024 < parser.mark.index) { + + /* Check if the potential simple key to be removed is required. */ + + if simple_key.required { + return yaml_parser_set_scanner_error(parser, + "while scanning a simple key", simple_key.mark, + "could not find expected ':'") + } + + simple_key.possible = false + } + } + + return true +} + +/* + * Check if a simple key may start at the current position and add it if + * needed. + */ + +func yaml_parser_save_simple_key(parser *yaml_parser_t) bool { + /* + * A simple key is required at the current position if the scanner is in + * the block context and the current column coincides with the indentation + * level. + */ + + required := (parser.flow_level == 0 && + parser.indent == parser.mark.column) + + /* + * A simple key is required only when it is the first token in the current + * line. Therefore it is always allowed. But we add a check anyway. + */ + if required && !parser.simple_key_allowed { + panic("impossible") /* Impossible. */ + } + + /* + * If the current position may start a simple key, save it. + */ + + if parser.simple_key_allowed { + simple_key := yaml_simple_key_t{ + possible: true, + required: required, + token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head), + } + simple_key.mark = parser.mark + + if !yaml_parser_remove_simple_key(parser) { + return false + } + + parser.simple_keys[len(parser.simple_keys)-1] = simple_key + } + + return true +} + +/* + * Remove a potential simple key at the current flow level. + */ + +func yaml_parser_remove_simple_key(parser *yaml_parser_t) bool { + simple_key := &parser.simple_keys[len(parser.simple_keys)-1] + + if simple_key.possible { + /* If the key is required, it is an error. */ + + if simple_key.required { + return yaml_parser_set_scanner_error(parser, + "while scanning a simple key", simple_key.mark, + "could not find expected ':'") + } + } + + /* Remove the key from the stack. */ + + simple_key.possible = false + + return true +} + +/* + * Increase the flow level and resize the simple key list if needed. + */ + +func yaml_parser_increase_flow_level(parser *yaml_parser_t) bool { + /* Reset the simple key on the next level. */ + + parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{}) + + /* Increase the flow level. */ + + parser.flow_level++ + + return true +} + +/* + * Decrease the flow level. + */ + +func yaml_parser_decrease_flow_level(parser *yaml_parser_t) bool { + if parser.flow_level > 0 { + parser.flow_level-- + parser.simple_keys = parser.simple_keys[:len(parser.simple_keys)-1] + } + + return true +} + +/* + * Push the current indentation level to the stack and set the new level + * the current column is greater than the indentation level. In this case, + * append or insert the specified token into the token queue. + * + */ + +func yaml_parser_roll_indent(parser *yaml_parser_t, column int, + number int, token_type yaml_token_type_t, mark YAML_mark_t) bool { + /* In the flow context, do nothing. */ + + if parser.flow_level > 0 { + return true + } + + if parser.indent == -1 || parser.indent < column { + /* + * Push the current indentation level to the stack and set the new + * indentation level. + */ + + parser.indents = append(parser.indents, parser.indent) + parser.indent = column + + /* Create a token and insert it into the queue. */ + token := yaml_token_t{ + token_type: token_type, + start_mark: mark, + end_mark: mark, + } + + // number == -1 -> enqueue otherwise insert + if number > -1 { + number -= parser.tokens_parsed + } + insert_token(parser, number, &token) + } + + return true +} + +/* + * Pop indentation levels from the indents stack until the current level + * becomes less or equal to the column. For each indentation level, append + * the BLOCK-END token. + */ + +func yaml_parser_unroll_indent(parser *yaml_parser_t, column int) bool { + /* In the flow context, do nothing. */ + + if parser.flow_level > 0 { + return true + } + + /* + * column is unsigned and parser->indent is signed, so if + * parser->indent is less than zero the conditional in the while + * loop below is incorrect. Guard against that. + */ + + if parser.indent < 0 { + return true + } + + /* Loop through the indentation levels in the stack. */ + + for parser.indent > column { + /* Create a token and append it to the queue. */ + token := yaml_token_t{ + token_type: yaml_BLOCK_END_TOKEN, + start_mark: parser.mark, + end_mark: parser.mark, + } + insert_token(parser, -1, &token) + + /* Pop the indentation level. */ + parser.indent = parser.indents[len(parser.indents)-1] + parser.indents = parser.indents[:len(parser.indents)-1] + + } + + return true +} + +/* + * Pop indentation levels from the indents stack until the current + * level resets to -1. For each indentation level, append the + * BLOCK-END token. + */ + +func yaml_parser_reset_indent(parser *yaml_parser_t) bool { + /* In the flow context, do nothing. */ + + if parser.flow_level > 0 { + return true + } + + /* Loop through the indentation levels in the stack. */ + + for parser.indent > -1 { + /* Create a token and append it to the queue. */ + + token := yaml_token_t{ + token_type: yaml_BLOCK_END_TOKEN, + start_mark: parser.mark, + end_mark: parser.mark, + } + insert_token(parser, -1, &token) + + /* Pop the indentation level. */ + parser.indent = parser.indents[len(parser.indents)-1] + parser.indents = parser.indents[:len(parser.indents)-1] + } + + return true +} + +/* + * Initialize the scanner and produce the STREAM-START token. + */ + +func yaml_parser_fetch_stream_start(parser *yaml_parser_t) bool { + /* Set the initial indentation. */ + + parser.indent = -1 + + /* Initialize the simple key stack. */ + parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{}) + + /* A simple key is allowed at the beginning of the stream. */ + + parser.simple_key_allowed = true + + /* We have started. */ + + parser.stream_start_produced = true + + /* Create the STREAM-START token and append it to the queue. */ + token := yaml_token_t{ + token_type: yaml_STREAM_START_TOKEN, + start_mark: parser.mark, + end_mark: parser.mark, + encoding: parser.encoding, + } + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the STREAM-END token and shut down the scanner. + */ + +func yaml_parser_fetch_stream_end(parser *yaml_parser_t) bool { + /* Force new line. */ + + if parser.mark.column != 0 { + parser.mark.column = 0 + parser.mark.line++ + } + + /* Reset the indentation level. */ + + if !yaml_parser_reset_indent(parser) { + return false + } + + /* Reset simple keys. */ + + if !yaml_parser_remove_simple_key(parser) { + return false + } + + parser.simple_key_allowed = false + + /* Create the STREAM-END token and append it to the queue. */ + token := yaml_token_t{ + token_type: yaml_STREAM_END_TOKEN, + start_mark: parser.mark, + end_mark: parser.mark, + } + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token. + */ + +func yaml_parser_fetch_directive(parser *yaml_parser_t) bool { + /* Reset the indentation level. */ + + if !yaml_parser_reset_indent(parser) { + return false + } + + /* Reset simple keys. */ + + if !yaml_parser_remove_simple_key(parser) { + return false + } + + parser.simple_key_allowed = false + + /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */ + var token yaml_token_t + if !yaml_parser_scan_directive(parser, &token) { + return false + } + + /* Append the token to the queue. */ + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the DOCUMENT-START or DOCUMENT-END token. + */ + +func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, + token_type yaml_token_type_t) bool { + + /* Reset the indentation level. */ + + if !yaml_parser_reset_indent(parser) { + return false + } + + /* Reset simple keys. */ + + if !yaml_parser_remove_simple_key(parser) { + return false + } + + parser.simple_key_allowed = false + + /* Consume the token. */ + + start_mark := parser.mark + + skip(parser) + skip(parser) + skip(parser) + + end_mark := parser.mark + + /* Create the DOCUMENT-START or DOCUMENT-END token. */ + + token := yaml_token_t{ + token_type: token_type, + start_mark: start_mark, + end_mark: end_mark, + } + + /* Append the token to the queue. */ + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token. + */ + +func yaml_parser_fetch_flow_collection_start(parser *yaml_parser_t, + token_type yaml_token_type_t) bool { + + /* The indicators '[' and '{' may start a simple key. */ + + if !yaml_parser_save_simple_key(parser) { + return false + } + + /* Increase the flow level. */ + + if !yaml_parser_increase_flow_level(parser) { + return false + } + + /* A simple key may follow the indicators '[' and '{'. */ + + parser.simple_key_allowed = true + + /* Consume the token. */ + + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + /* Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. */ + + token := yaml_token_t{ + token_type: token_type, + start_mark: start_mark, + end_mark: end_mark, + } + + /* Append the token to the queue. */ + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token. + */ + +func yaml_parser_fetch_flow_collection_end(parser *yaml_parser_t, + token_type yaml_token_type_t) bool { + + /* Reset any potential simple key on the current flow level. */ + + if !yaml_parser_remove_simple_key(parser) { + return false + } + + /* Decrease the flow level. */ + + if !yaml_parser_decrease_flow_level(parser) { + return false + } + + /* No simple keys after the indicators ']' and '}'. */ + + parser.simple_key_allowed = false + + /* Consume the token. */ + + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + /* Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token. */ + + token := yaml_token_t{ + token_type: token_type, + start_mark: start_mark, + end_mark: end_mark, + } + + /* Append the token to the queue. */ + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the FLOW-ENTRY token. + */ + +func yaml_parser_fetch_flow_entry(parser *yaml_parser_t) bool { + + /* Reset any potential simple keys on the current flow level. */ + + if !yaml_parser_remove_simple_key(parser) { + return false + } + + /* Simple keys are allowed after ','. */ + + parser.simple_key_allowed = true + + /* Consume the token. */ + + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + /* Create the FLOW-ENTRY token and append it to the queue. */ + + token := yaml_token_t{ + token_type: yaml_FLOW_ENTRY_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + } + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the BLOCK-ENTRY token. + */ + +func yaml_parser_fetch_block_entry(parser *yaml_parser_t) bool { + + /* Check if the scanner is in the block context. */ + + if parser.flow_level == 0 { + /* Check if we are allowed to start a new entry. */ + + if !parser.simple_key_allowed { + return yaml_parser_set_scanner_error(parser, "", parser.mark, + "block sequence entries are not allowed in this context") + } + + /* Add the BLOCK-SEQUENCE-START token if needed. */ + + if !yaml_parser_roll_indent(parser, parser.mark.column, -1, + yaml_BLOCK_SEQUENCE_START_TOKEN, parser.mark) { + return false + } + } else { + /* + * It is an error for the '-' indicator to occur in the flow context, + * but we let the Parser detect and report about it because the Parser + * is able to point to the context. + */ + } + + /* Reset any potential simple keys on the current flow level. */ + + if !yaml_parser_remove_simple_key(parser) { + return false + } + + /* Simple keys are allowed after '-'. */ + + parser.simple_key_allowed = true + + /* Consume the token. */ + + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + /* Create the BLOCK-ENTRY token and append it to the queue. */ + + token := yaml_token_t{ + token_type: yaml_BLOCK_ENTRY_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + } + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the KEY token. + */ + +func yaml_parser_fetch_key(parser *yaml_parser_t) bool { + /* In the block context, additional checks are required. */ + + if parser.flow_level == 0 { + /* Check if we are allowed to start a new key (not nessesary simple). */ + + if !parser.simple_key_allowed { + return yaml_parser_set_scanner_error(parser, "", parser.mark, + "mapping keys are not allowed in this context") + } + + /* Add the BLOCK-MAPPING-START token if needed. */ + + if !yaml_parser_roll_indent(parser, parser.mark.column, -1, + yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) { + return false + } + } + + /* Reset any potential simple keys on the current flow level. */ + + if !yaml_parser_remove_simple_key(parser) { + return false + } + + /* Simple keys are allowed after '?' in the block context. */ + + parser.simple_key_allowed = (parser.flow_level == 0) + + /* Consume the token. */ + + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + /* Create the KEY token and append it to the queue. */ + + token := yaml_token_t{ + token_type: yaml_KEY_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + } + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the VALUE token. + */ + +func yaml_parser_fetch_value(parser *yaml_parser_t) bool { + + simple_key := &parser.simple_keys[len(parser.simple_keys)-1] + + /* Have we found a simple key? */ + + if simple_key.possible { + + /* Create the KEY token and insert it into the queue. */ + + token := yaml_token_t{ + token_type: yaml_KEY_TOKEN, + start_mark: simple_key.mark, + end_mark: simple_key.mark, + } + + insert_token(parser, simple_key.token_number-parser.tokens_parsed, &token) + + /* In the block context, we may need to add the BLOCK-MAPPING-START token. */ + + if !yaml_parser_roll_indent(parser, simple_key.mark.column, + simple_key.token_number, + yaml_BLOCK_MAPPING_START_TOKEN, simple_key.mark) { + return false + } + + /* Remove the simple key. */ + + simple_key.possible = false + + /* A simple key cannot follow another simple key. */ + + parser.simple_key_allowed = false + } else { + /* The ':' indicator follows a complex key. */ + + /* In the block context, extra checks are required. */ + + if parser.flow_level == 0 { + /* Check if we are allowed to start a complex value. */ + + if !parser.simple_key_allowed { + return yaml_parser_set_scanner_error(parser, "", parser.mark, + "mapping values are not allowed in this context") + } + + /* Add the BLOCK-MAPPING-START token if needed. */ + + if !yaml_parser_roll_indent(parser, parser.mark.column, -1, + yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) { + return false + } + } + + /* Simple keys after ':' are allowed in the block context. */ + + parser.simple_key_allowed = (parser.flow_level == 0) + } + + /* Consume the token. */ + + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + /* Create the VALUE token and append it to the queue. */ + + token := yaml_token_t{ + token_type: yaml_VALUE_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + } + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the ALIAS or ANCHOR token. + */ + +func yaml_parser_fetch_anchor(parser *yaml_parser_t, token_type yaml_token_type_t) bool { + + /* An anchor or an alias could be a simple key. */ + + if !yaml_parser_save_simple_key(parser) { + return false + } + + /* A simple key cannot follow an anchor or an alias. */ + + parser.simple_key_allowed = false + + /* Create the ALIAS or ANCHOR token and append it to the queue. */ + var token yaml_token_t + if !yaml_parser_scan_anchor(parser, &token, token_type) { + return false + } + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the TAG token. + */ + +func yaml_parser_fetch_tag(parser *yaml_parser_t) bool { + /* A tag could be a simple key. */ + + if !yaml_parser_save_simple_key(parser) { + return false + } + + /* A simple key cannot follow a tag. */ + + parser.simple_key_allowed = false + + /* Create the TAG token and append it to the queue. */ + var token yaml_token_t + if !yaml_parser_scan_tag(parser, &token) { + return false + } + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens. + */ + +func yaml_parser_fetch_block_scalar(parser *yaml_parser_t, literal bool) bool { + /* Remove any potential simple keys. */ + + if !yaml_parser_remove_simple_key(parser) { + return false + } + + /* A simple key may follow a block scalar. */ + + parser.simple_key_allowed = true + + /* Create the SCALAR token and append it to the queue. */ + var token yaml_token_t + if !yaml_parser_scan_block_scalar(parser, &token, literal) { + return false + } + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens. + */ + +func yaml_parser_fetch_flow_scalar(parser *yaml_parser_t, single bool) bool { + + /* A plain scalar could be a simple key. */ + + if !yaml_parser_save_simple_key(parser) { + return false + } + + /* A simple key cannot follow a flow scalar. */ + + parser.simple_key_allowed = false + + /* Create the SCALAR token and append it to the queue. */ + var token yaml_token_t + if !yaml_parser_scan_flow_scalar(parser, &token, single) { + return false + } + + insert_token(parser, -1, &token) + + return true +} + +/* + * Produce the SCALAR(...,plain) token. + */ + +func yaml_parser_fetch_plain_scalar(parser *yaml_parser_t) bool { + /* A plain scalar could be a simple key. */ + + if !yaml_parser_save_simple_key(parser) { + return false + } + + /* A simple key cannot follow a flow scalar. */ + + parser.simple_key_allowed = false + + /* Create the SCALAR token and append it to the queue. */ + var token yaml_token_t + if !yaml_parser_scan_plain_scalar(parser, &token) { + return false + } + + insert_token(parser, -1, &token) + + return true +} + +/* + * Eat whitespaces and comments until the next token is found. + */ + +func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool { + /* Until the next token is not found. */ + + for { + /* Allow the BOM mark to start a line. */ + + if !cache(parser, 1) { + return false + } + + if parser.mark.column == 0 && is_bom_at(parser.buffer, parser.buffer_pos) { + skip(parser) + } + + /* + * Eat whitespaces. + * + * Tabs are allowed: + * + * - in the flow context; + * - in the block context, but not at the beginning of the line or + * after '-', '?', or ':' (complex value). + */ + + if !cache(parser, 1) { + return false + } + + for parser.buffer[parser.buffer_pos] == ' ' || + ((parser.flow_level > 0 || !parser.simple_key_allowed) && + parser.buffer[parser.buffer_pos] == '\t') { + skip(parser) + if !cache(parser, 1) { + return false + } + } + + /* Eat a comment until a line break. */ + + if parser.buffer[parser.buffer_pos] == '#' { + for !is_breakz_at(parser.buffer, parser.buffer_pos) { + skip(parser) + if !cache(parser, 1) { + return false + } + } + } + + /* If it is a line break, eat it. */ + + if is_break_at(parser.buffer, parser.buffer_pos) { + if !cache(parser, 2) { + return false + } + skip_line(parser) + + /* In the block context, a new line may start a simple key. */ + + if parser.flow_level == 0 { + parser.simple_key_allowed = true + } + } else { + /* We have found a token. */ + + break + } + } + + return true +} + +/* + * Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token. + * + * Scope: + * %YAML 1.1 # a comment \n + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * %TAG !yaml! tag:yaml.org,2002: \n + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ + +func yaml_parser_scan_directive(parser *yaml_parser_t, token *yaml_token_t) bool { + /* Eat '%'. */ + + start_mark := parser.mark + + skip(parser) + + /* Scan the directive name. */ + var name []byte + if !yaml_parser_scan_directive_name(parser, start_mark, &name) { + return false + } + + /* Is it a YAML directive? */ + var major, minor int + if bytes.Equal(name, []byte("YAML")) { + /* Scan the VERSION directive value. */ + + if !yaml_parser_scan_version_directive_value(parser, start_mark, + &major, &minor) { + return false + } + + end_mark := parser.mark + + /* Create a VERSION-DIRECTIVE token. */ + + *token = yaml_token_t{ + token_type: yaml_VERSION_DIRECTIVE_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + major: major, + minor: minor, + } + } else if bytes.Equal(name, []byte("TAG")) { + /* Is it a TAG directive? */ + /* Scan the TAG directive value. */ + var handle, prefix []byte + if !yaml_parser_scan_tag_directive_value(parser, start_mark, + &handle, &prefix) { + return false + } + + end_mark := parser.mark + + /* Create a TAG-DIRECTIVE token. */ + + *token = yaml_token_t{ + token_type: yaml_TAG_DIRECTIVE_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + value: handle, + prefix: prefix, + } + } else { + /* Unknown directive. */ + yaml_parser_set_scanner_error(parser, "while scanning a directive", + start_mark, "found uknown directive name") + return false + } + + /* Eat the rest of the line including any comments. */ + + if !cache(parser, 1) { + return false + } + + for is_blank(parser.buffer[parser.buffer_pos]) { + skip(parser) + if !cache(parser, 1) { + return false + } + } + + if parser.buffer[parser.buffer_pos] == '#' { + for !is_breakz_at(parser.buffer, parser.buffer_pos) { + skip(parser) + if !cache(parser, 1) { + return false + } + } + } + + /* Check if we are at the end of the line. */ + + if !is_breakz_at(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a directive", + start_mark, "did not find expected comment or line break") + return false + } + + /* Eat a line break. */ + + if is_break_at(parser.buffer, parser.buffer_pos) { + if !cache(parser, 2) { + return false + } + skip_line(parser) + } + + return true +} + +/* + * Scan the directive name. + * + * Scope: + * %YAML 1.1 # a comment \n + * ^^^^ + * %TAG !yaml! tag:yaml.org,2002: \n + * ^^^ + */ + +func yaml_parser_scan_directive_name(parser *yaml_parser_t, + start_mark YAML_mark_t, name *[]byte) bool { + + /* Consume the directive name. */ + + if !cache(parser, 1) { + return false + } + + var s []byte + for is_alpha(parser.buffer[parser.buffer_pos]) { + s = read(parser, s) + if !cache(parser, 1) { + return false + } + } + + /* Check if the name is empty. */ + + if len(s) == 0 { + yaml_parser_set_scanner_error(parser, "while scanning a directive", + start_mark, "could not find expected directive name") + return false + } + + /* Check for an blank character after the name. */ + + if !is_blankz_at(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a directive", + start_mark, "found unexpected non-alphabetical character") + return false + } + + *name = s + + return true +} + +/* + * Scan the value of VERSION-DIRECTIVE. + * + * Scope: + * %YAML 1.1 # a comment \n + * ^^^^^^ + */ + +func yaml_parser_scan_version_directive_value(parser *yaml_parser_t, + start_mark YAML_mark_t, major *int, minor *int) bool { + /* Eat whitespaces. */ + + if !cache(parser, 1) { + return false + } + + for is_blank(parser.buffer[parser.buffer_pos]) { + skip(parser) + if !cache(parser, 1) { + return false + } + } + + /* Consume the major version number. */ + + if !yaml_parser_scan_version_directive_number(parser, start_mark, major) { + return false + } + + /* Eat '.'. */ + + if parser.buffer[parser.buffer_pos] != '.' { + return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", + start_mark, "did not find expected digit or '.' character") + } + + skip(parser) + + /* Consume the minor version number. */ + + if !yaml_parser_scan_version_directive_number(parser, start_mark, minor) { + return false + } + + return true +} + +const MAX_NUMBER_LENGTH = 9 + +/* + * Scan the version number of VERSION-DIRECTIVE. + * + * Scope: + * %YAML 1.1 # a comment \n + * ^ + * %YAML 1.1 # a comment \n + * ^ + */ + +func yaml_parser_scan_version_directive_number(parser *yaml_parser_t, + start_mark YAML_mark_t, number *int) bool { + + /* Repeat while the next character is digit. */ + + if !cache(parser, 1) { + return false + } + + value := 0 + length := 0 + for is_digit(parser.buffer[parser.buffer_pos]) { + /* Check if the number is too long. */ + + length++ + if length > MAX_NUMBER_LENGTH { + return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", + start_mark, "found extremely long version number") + } + + value = value*10 + as_digit(parser.buffer[parser.buffer_pos]) + + skip(parser) + + if !cache(parser, 1) { + return false + } + } + + /* Check if the number was present. */ + + if length == 0 { + return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", + start_mark, "did not find expected version number") + } + + *number = value + + return true +} + +/* + * Scan the value of a TAG-DIRECTIVE token. + * + * Scope: + * %TAG !yaml! tag:yaml.org,2002: \n + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ + +func yaml_parser_scan_tag_directive_value(parser *yaml_parser_t, + start_mark YAML_mark_t, handle, prefix *[]byte) bool { + + /* Eat whitespaces. */ + + if !cache(parser, 1) { + return false + } + + for is_blank(parser.buffer[parser.buffer_pos]) { + skip(parser) + if !cache(parser, 1) { + return false + } + } + + /* Scan a handle. */ + var handle_value []byte + if !yaml_parser_scan_tag_handle(parser, true, start_mark, &handle_value) { + return false + } + + /* Expect a whitespace. */ + + if !cache(parser, 1) { + return false + } + + if !is_blank(parser.buffer[parser.buffer_pos]) { + yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", + start_mark, "did not find expected whitespace") + return false + } + + /* Eat whitespaces. */ + + for is_blank(parser.buffer[parser.buffer_pos]) { + skip(parser) + if !cache(parser, 1) { + return false + } + } + + /* Scan a prefix. */ + var prefix_value []byte + if !yaml_parser_scan_tag_uri(parser, true, nil, start_mark, &prefix_value) { + return false + } + + /* Expect a whitespace or line break. */ + + if !cache(parser, 1) { + return false + } + + if !is_blankz_at(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", + start_mark, "did not find expected whitespace or line break") + return false + } + + *handle = handle_value + *prefix = prefix_value + + return true +} + +func yaml_parser_scan_anchor(parser *yaml_parser_t, token *yaml_token_t, + token_type yaml_token_type_t) bool { + + /* Eat the indicator character. */ + + start_mark := parser.mark + + skip(parser) + + /* Consume the value. */ + + if !cache(parser, 1) { + return false + } + + var s []byte + for is_alpha(parser.buffer[parser.buffer_pos]) { + s = read(parser, s) + if !cache(parser, 1) { + return false + } + } + + end_mark := parser.mark + + /* + * Check if length of the anchor is greater than 0 and it is followed by + * a whitespace character or one of the indicators: + * + * '?', ':', ',', ']', '}', '%', '@', '`'. + */ + + b := parser.buffer[parser.buffer_pos] + if len(s) == 0 || !(is_blankz_at(parser.buffer, parser.buffer_pos) || b == '?' || + b == ':' || b == ',' || + b == ']' || b == '}' || + b == '%' || b == '@' || + b == '`') { + context := "while scanning an anchor" + if token_type != yaml_ANCHOR_TOKEN { + context = "while scanning an alias" + } + yaml_parser_set_scanner_error(parser, context, start_mark, + "did not find expected alphabetic or numeric character") + return false + } + + /* Create a token. */ + *token = yaml_token_t{ + token_type: token_type, + start_mark: start_mark, + end_mark: end_mark, + value: s, + } + + return true +} + +/* + * Scan a TAG token. + */ + +func yaml_parser_scan_tag(parser *yaml_parser_t, token *yaml_token_t) bool { + start_mark := parser.mark + + /* Check if the tag is in the canonical form. */ + + if !cache(parser, 2) { + return false + } + + var handle []byte + var suffix []byte + if parser.buffer[parser.buffer_pos+1] == '<' { + /* Set the handle to '' */ + + /* Eat '!<' */ + + skip(parser) + skip(parser) + + /* Consume the tag value. */ + + if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) { + return false + } + + /* Check for '>' and eat it. */ + + if parser.buffer[parser.buffer_pos] != '>' { + yaml_parser_set_scanner_error(parser, "while scanning a tag", + start_mark, "did not find the expected '>'") + return false + } + + skip(parser) + } else if is_blank(parser.buffer[parser.buffer_pos+1]) { + // NON-SPECIFIED + skip(parser) + } else { + /* The tag has either the '!suffix' or the '!handle!suffix' form. */ + + /* First, try to scan a handle. */ + + if !yaml_parser_scan_tag_handle(parser, false, start_mark, &handle) { + return false + } + + /* Check if it is, indeed, handle. */ + + if handle[0] == '!' && len(handle) > 1 && handle[len(handle)-1] == '!' { + /* Scan the suffix now. */ + + if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) { + return false + } + } else { + /* It wasn't a handle after all. Scan the rest of the tag. */ + + if !yaml_parser_scan_tag_uri(parser, false, handle, start_mark, &suffix) { + return false + } + + /* Set the handle to '!'. */ + + handle = []byte{'!'} + + /* + * A special case: the '!' tag. Set the handle to '' and the + * suffix to '!'. + */ + + if len(suffix) == 0 { + handle, suffix = suffix, handle + } + + } + } + + /* Check the character which ends the tag. */ + + if !cache(parser, 1) { + return false + } + + if !is_blankz_at(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a tag", + start_mark, "did not find expected whitespace or line break") + return false + } + + end_mark := parser.mark + + /* Create a token. */ + + *token = yaml_token_t{ + token_type: yaml_TAG_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + value: handle, + suffix: suffix, + } + + return true +} + +/* + * Scan a tag handle. + */ + +func yaml_parser_scan_tag_handle(parser *yaml_parser_t, directive bool, + start_mark YAML_mark_t, handle *[]byte) bool { + + /* Check the initial '!' character. */ + + if !cache(parser, 1) { + return false + } + + if parser.buffer[parser.buffer_pos] != '!' { + yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "did not find expected '!'") + return false + } + + /* Copy the '!' character. */ + var s []byte + s = read(parser, s) + + /* Copy all subsequent alphabetical and numerical characters. */ + + if !cache(parser, 1) { + return false + } + + for is_alpha(parser.buffer[parser.buffer_pos]) { + s = read(parser, s) + if !cache(parser, 1) { + return false + } + } + + /* Check if the trailing character is '!' and copy it. */ + + if parser.buffer[parser.buffer_pos] == '!' { + s = read(parser, s) + } else { + /* + * It's either the '!' tag or not really a tag handle. If it's a %TAG + * directive, it's an error. If it's a tag token, it must be a part of + * URI. + */ + + if directive && !(s[0] == '!' && len(s) == 1) { + yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "did not find expected '!'") + return false + } + } + + *handle = s + + return true +} + +/* + * Scan a tag. + */ + +func yaml_parser_scan_tag_uri(parser *yaml_parser_t, directive bool, + head []byte, start_mark YAML_mark_t, uri *[]byte) bool { + + var s []byte + /* + * Copy the head if needed. + * + * Note that we don't copy the leading '!' character. + */ + if len(head) > 1 { + s = append(s, head[1:]...) + } + + /* Scan the tag. */ + if !cache(parser, 1) { + return false + } + + /* + * The set of characters that may appear in URI is as follows: + * + * '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&', + * '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']', + * '%'. + */ + + b := parser.buffer[parser.buffer_pos] + for is_alpha(b) || b == ';' || + b == '/' || b == '?' || + b == ':' || b == '@' || + b == '&' || b == '=' || + b == '+' || b == '$' || + b == ',' || b == '.' || + b == '!' || b == '~' || + b == '*' || b == '\'' || + b == '(' || b == ')' || + b == '[' || b == ']' || + b == '%' { + /* Check if it is a URI-escape sequence. */ + + if b == '%' { + if !yaml_parser_scan_uri_escapes(parser, + directive, start_mark, &s) { + return false + } + } else { + s = read(parser, s) + } + + if !cache(parser, 1) { + return false + } + b = parser.buffer[parser.buffer_pos] + } + + /* Check if the tag is non-empty. */ + + if len(s) == 0 { + yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "did not find expected tag URI") + return false + } + + *uri = s + + return true +} + +/* + * Decode an URI-escape sequence corresponding to a single UTF-8 character. + */ + +func yaml_parser_scan_uri_escapes(parser *yaml_parser_t, directive bool, + start_mark YAML_mark_t, s *[]byte) bool { + + /* Decode the required number of characters. */ + w := 10 + for w > 0 { + + /* Check for a URI-escaped octet. */ + + if !cache(parser, 3) { + return false + } + + if !(parser.buffer[parser.buffer_pos] == '%' && + is_hex(parser.buffer[parser.buffer_pos+1]) && + is_hex(parser.buffer[parser.buffer_pos+2])) { + return yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "did not find URI escaped octet") + } + + /* Get the octet. */ + octet := byte((as_hex(parser.buffer[parser.buffer_pos+1]) << 4) + + as_hex(parser.buffer[parser.buffer_pos+2])) + + /* If it is the leading octet, determine the length of the UTF-8 sequence. */ + + if w == 10 { + w = width(octet) + if w == 0 { + return yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "found an incorrect leading UTF-8 octet") + } + } else { + /* Check if the trailing octet is correct. */ + + if (octet & 0xC0) != 0x80 { + return yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "found an incorrect trailing UTF-8 octet") + } + } + + /* Copy the octet and move the pointers. */ + + *s = append(*s, octet) + skip(parser) + skip(parser) + skip(parser) + w-- + } + + return true +} + +/* + * Scan a block scalar. + */ + +func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, + literal bool) bool { + + /* Eat the indicator '|' or '>'. */ + + start_mark := parser.mark + + skip(parser) + + /* Scan the additional block scalar indicators. */ + + if !cache(parser, 1) { + return false + } + + /* Check for a chomping indicator. */ + chomping := 0 + increment := 0 + if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' { + /* Set the chomping method and eat the indicator. */ + + if parser.buffer[parser.buffer_pos] == '+' { + chomping = +1 + } else { + chomping = -1 + } + + skip(parser) + + /* Check for an indentation indicator. */ + + if !cache(parser, 1) { + return false + } + + if is_digit(parser.buffer[parser.buffer_pos]) { + /* Check that the indentation is greater than 0. */ + + if parser.buffer[parser.buffer_pos] == '0' { + yaml_parser_set_scanner_error(parser, "while scanning a block scalar", + start_mark, "found an indentation indicator equal to 0") + return false + } + + /* Get the indentation level and eat the indicator. */ + + increment = as_digit(parser.buffer[parser.buffer_pos]) + + skip(parser) + } + } else if is_digit(parser.buffer[parser.buffer_pos]) { + + /* Do the same as above, but in the opposite order. */ + if parser.buffer[parser.buffer_pos] == '0' { + yaml_parser_set_scanner_error(parser, "while scanning a block scalar", + start_mark, "found an indentation indicator equal to 0") + return false + } + + increment = as_digit(parser.buffer[parser.buffer_pos]) + + skip(parser) + + if !cache(parser, 1) { + return false + } + + if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' { + if parser.buffer[parser.buffer_pos] == '+' { + chomping = +1 + } else { + chomping = -1 + } + + skip(parser) + } + } + + /* Eat whitespaces and comments to the end of the line. */ + + if !cache(parser, 1) { + return false + } + + for is_blank(parser.buffer[parser.buffer_pos]) { + skip(parser) + if !cache(parser, 1) { + return false + } + } + + if parser.buffer[parser.buffer_pos] == '#' { + for !is_breakz_at(parser.buffer, parser.buffer_pos) { + skip(parser) + if !cache(parser, 1) { + return false + } + } + } + + /* Check if we are at the end of the line. */ + + if !is_breakz_at(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a block scalar", + start_mark, "did not find expected comment or line break") + return false + } + + /* Eat a line break. */ + + if is_break_at(parser.buffer, parser.buffer_pos) { + if !cache(parser, 2) { + return false + } + + skip_line(parser) + } + + end_mark := parser.mark + + /* Set the indentation level if it was specified. */ + indent := 0 + if increment > 0 { + if parser.indent >= 0 { + indent = parser.indent + increment + } else { + indent = increment + } + } + + /* Scan the leading line breaks and determine the indentation level if needed. */ + var trailing_breaks []byte + if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, + start_mark, &end_mark) { + return false + } + + /* Scan the block scalar content. */ + + if !cache(parser, 1) { + return false + } + + var s []byte + var leading_break []byte + leading_blank := false + trailing_blank := false + for parser.mark.column == indent && !is_z(parser.buffer[parser.buffer_pos]) { + + /* + * We are at the beginning of a non-empty line. + */ + + /* Is it a trailing whitespace? */ + + trailing_blank = is_blank(parser.buffer[parser.buffer_pos]) + + /* Check if we need to fold the leading line break. */ + + if !literal && len(leading_break) > 0 && leading_break[0] == '\n' && + !leading_blank && !trailing_blank { + /* Do we need to join the lines by space? */ + if len(trailing_breaks) == 0 { + s = append(s, ' ') + } + leading_break = leading_break[:0] + } else { + s = append(s, leading_break...) + leading_break = leading_break[:0] + } + + /* Append the remaining line breaks. */ + s = append(s, trailing_breaks...) + trailing_breaks = trailing_breaks[:0] + + /* Is it a leading whitespace? */ + + leading_blank = is_blank(parser.buffer[parser.buffer_pos]) + + /* Consume the current line. */ + + for !is_breakz_at(parser.buffer, parser.buffer_pos) { + s = read(parser, s) + if !cache(parser, 1) { + return false + } + } + + /* Consume the line break. */ + + if !cache(parser, 2) { + return false + } + + leading_break = read_line(parser, leading_break) + + /* Eat the following indentation spaces and line breaks. */ + + if !yaml_parser_scan_block_scalar_breaks(parser, + &indent, &trailing_breaks, start_mark, &end_mark) { + return false + } + } + + /* Chomp the tail. */ + + if chomping != -1 { + s = append(s, leading_break...) + } + if chomping == 1 { + s = append(s, trailing_breaks...) + } + + /* Create a token. */ + + *token = yaml_token_t{ + token_type: yaml_SCALAR_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + value: s, + style: yaml_LITERAL_SCALAR_STYLE, + } + if !literal { + token.style = yaml_FOLDED_SCALAR_STYLE + } + + return true +} + +/* + * Scan indentation spaces and line breaks for a block scalar. Determine the + * indentation level if needed. + */ + +func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, + indent *int, breaks *[]byte, + start_mark YAML_mark_t, end_mark *YAML_mark_t) bool { + + *end_mark = parser.mark + + /* Eat the indentation spaces and line breaks. */ + max_indent := 0 + for { + /* Eat the indentation spaces. */ + + if !cache(parser, 1) { + return false + } + + for (*indent == 0 || parser.mark.column < *indent) && + is_space(parser.buffer[parser.buffer_pos]) { + skip(parser) + if !cache(parser, 1) { + return false + } + } + if parser.mark.column > max_indent { + max_indent = parser.mark.column + } + + /* Check for a tab character messing the indentation. */ + + if (*indent == 0 || parser.mark.column < *indent) && + is_tab(parser.buffer[parser.buffer_pos]) { + return yaml_parser_set_scanner_error(parser, "while scanning a block scalar", + start_mark, "found a tab character where an indentation space is expected") + } + + /* Have we found a non-empty line? */ + + if !is_break_at(parser.buffer, parser.buffer_pos) { + break + } + + /* Consume the line break. */ + + if !cache(parser, 2) { + return false + } + + *breaks = read_line(parser, *breaks) + *end_mark = parser.mark + } + + /* Determine the indentation level if needed. */ + + if *indent == 0 { + *indent = max_indent + if *indent < parser.indent+1 { + *indent = parser.indent + 1 + } + if *indent < 1 { + *indent = 1 + } + } + + return true +} + +/* + * Scan a quoted scalar. + */ + +func yaml_parser_scan_flow_scalar(parser *yaml_parser_t, token *yaml_token_t, + single bool) bool { + + /* Eat the left quote. */ + + start_mark := parser.mark + + skip(parser) + + /* Consume the content of the quoted scalar. */ + var s []byte + var leading_break []byte + var trailing_breaks []byte + var whitespaces []byte + for { + /* Check that there are no document indicators at the beginning of the line. */ + + if !cache(parser, 4) { + return false + } + + if parser.mark.column == 0 && + ((parser.buffer[parser.buffer_pos] == '-' && + parser.buffer[parser.buffer_pos+1] == '-' && + parser.buffer[parser.buffer_pos+2] == '-') || + (parser.buffer[parser.buffer_pos] == '.' && + parser.buffer[parser.buffer_pos+1] == '.' && + parser.buffer[parser.buffer_pos+2] == '.')) && + is_blankz_at(parser.buffer, parser.buffer_pos+3) { + yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", + start_mark, "found unexpected document indicator") + return false + } + + /* Check for EOF. */ + + if is_z(parser.buffer[parser.buffer_pos]) { + yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", + start_mark, "found unexpected end of stream") + return false + } + + /* Consume non-blank characters. */ + + if !cache(parser, 2) { + return false + } + + leading_blanks := false + + for !is_blankz_at(parser.buffer, parser.buffer_pos) { + /* Check for an escaped single quote. */ + + if single && parser.buffer[parser.buffer_pos] == '\'' && + parser.buffer[parser.buffer_pos+1] == '\'' { + // Is is an escaped single quote. + s = append(s, '\'') + skip(parser) + skip(parser) + } else if single && parser.buffer[parser.buffer_pos] == '\'' { + /* Check for the right quote. */ + break + } else if !single && parser.buffer[parser.buffer_pos] == '"' { + /* Check for the right quote. */ + break + } else if !single && parser.buffer[parser.buffer_pos] == '\\' && + is_break_at(parser.buffer, parser.buffer_pos+1) { + + /* Check for an escaped line break. */ + if !cache(parser, 3) { + return false + } + + skip(parser) + skip_line(parser) + leading_blanks = true + break + } else if !single && parser.buffer[parser.buffer_pos] == '\\' { + + /* Check for an escape sequence. */ + + code_length := 0 + + /* Check the escape character. */ + + switch parser.buffer[parser.buffer_pos+1] { + case '0': + s = append(s, 0) + case 'a': + s = append(s, '\x07') + case 'b': + s = append(s, '\x08') + case 't', '\t': + s = append(s, '\x09') + case 'n': + s = append(s, '\x0A') + case 'v': + s = append(s, '\x0B') + case 'f': + s = append(s, '\x0C') + case 'r': + s = append(s, '\x0D') + case 'e': + s = append(s, '\x1B') + case ' ': + s = append(s, '\x20') + case '"': + s = append(s, '"') + case '/': + s = append(s, '/') + case '\\': + s = append(s, '\\') + case 'N': /* NEL (#x85) */ + s = append(s, '\xC2') + s = append(s, '\x85') + case '_': /* #xA0 */ + s = append(s, '\xC2') + s = append(s, '\xA0') + case 'L': /* LS (#x2028) */ + s = append(s, '\xE2') + s = append(s, '\x80') + s = append(s, '\xA8') + case 'P': /* PS (#x2029) */ + s = append(s, '\xE2') + s = append(s, '\x80') + s = append(s, '\xA9') + case 'x': + code_length = 2 + case 'u': + code_length = 4 + case 'U': + code_length = 8 + default: + yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", + start_mark, "found unknown escape character") + return false + } + + skip(parser) + skip(parser) + + /* Consume an arbitrary escape code. */ + + if code_length > 0 { + value := 0 + + /* Scan the character value. */ + + if !cache(parser, code_length) { + return false + } + + for k := 0; k < code_length; k++ { + if !is_hex(parser.buffer[parser.buffer_pos+k]) { + yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", + start_mark, "did not find expected hexdecimal number") + return false + } + value = (value << 4) + as_hex(parser.buffer[parser.buffer_pos+k]) + } + + /* Check the value and write the character. */ + + if (value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF { + yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", + start_mark, "found invalid Unicode character escape code") + return false + } + + if value <= 0x7F { + s = append(s, byte(value)) + } else if value <= 0x7FF { + s = append(s, byte(0xC0+(value>>6))) + s = append(s, byte(0x80+(value&0x3F))) + } else if value <= 0xFFFF { + s = append(s, byte(0xE0+(value>>12))) + s = append(s, byte(0x80+((value>>6)&0x3F))) + s = append(s, byte(0x80+(value&0x3F))) + } else { + s = append(s, byte(0xF0+(value>>18))) + s = append(s, byte(0x80+((value>>12)&0x3F))) + s = append(s, byte(0x80+((value>>6)&0x3F))) + s = append(s, byte(0x80+(value&0x3F))) + } + + /* Advance the pointer. */ + + for k := 0; k < code_length; k++ { + skip(parser) + } + } + } else { + /* It is a non-escaped non-blank character. */ + + s = read(parser, s) + } + + if !cache(parser, 2) { + return false + } + } + + /* Check if we are at the end of the scalar. */ + b := parser.buffer[parser.buffer_pos] + if single { + if b == '\'' { + break + } + } else if b == '"' { + break + } + + /* Consume blank characters. */ + + if !cache(parser, 1) { + return false + } + + for is_blank(parser.buffer[parser.buffer_pos]) || is_break_at(parser.buffer, parser.buffer_pos) { + if is_blank(parser.buffer[parser.buffer_pos]) { + /* Consume a space or a tab character. */ + if !leading_blanks { + whitespaces = read(parser, whitespaces) + } else { + skip(parser) + } + } else { + if !cache(parser, 2) { + return false + } + + /* Check if it is a first line break. */ + if !leading_blanks { + whitespaces = whitespaces[:0] + leading_break = read_line(parser, leading_break) + leading_blanks = true + } else { + trailing_breaks = read_line(parser, trailing_breaks) + } + } + + if !cache(parser, 1) { + return false + } + } + + /* Join the whitespaces or fold line breaks. */ + + if leading_blanks { + /* Do we need to fold line breaks? */ + + if len(leading_break) > 0 && leading_break[0] == '\n' { + if len(trailing_breaks) == 0 { + s = append(s, ' ') + } else { + s = append(s, trailing_breaks...) + trailing_breaks = trailing_breaks[:0] + } + + leading_break = leading_break[:0] + } else { + s = append(s, leading_break...) + s = append(s, trailing_breaks...) + leading_break = leading_break[:0] + trailing_breaks = trailing_breaks[:0] + } + } else { + s = append(s, whitespaces...) + whitespaces = whitespaces[:0] + } + } + + /* Eat the right quote. */ + + skip(parser) + + end_mark := parser.mark + + /* Create a token. */ + + *token = yaml_token_t{ + token_type: yaml_SCALAR_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + value: s, + style: yaml_SINGLE_QUOTED_SCALAR_STYLE, + } + if !single { + token.style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } + + return true +} + +/* + * Scan a plain scalar. + */ + +func yaml_parser_scan_plain_scalar(parser *yaml_parser_t, token *yaml_token_t) bool { + var s []byte + var leading_break []byte + var trailing_breaks []byte + var whitespaces []byte + leading_blanks := false + indent := parser.indent + 1 + + start_mark := parser.mark + end_mark := parser.mark + + /* Consume the content of the plain scalar. */ + + for { + /* Check for a document indicator. */ + + if !cache(parser, 4) { + return false + } + + if parser.mark.column == 0 && + ((parser.buffer[parser.buffer_pos] == '-' && + parser.buffer[parser.buffer_pos+1] == '-' && + parser.buffer[parser.buffer_pos+2] == '-') || + (parser.buffer[parser.buffer_pos] == '.' && + parser.buffer[parser.buffer_pos+1] == '.' && + parser.buffer[parser.buffer_pos+2] == '.')) && + is_blankz_at(parser.buffer, parser.buffer_pos+3) { + break + } + + /* Check for a comment. */ + + if parser.buffer[parser.buffer_pos] == '#' { + break + } + + /* Consume non-blank characters. */ + + for !is_blankz_at(parser.buffer, parser.buffer_pos) { + /* Check for 'x:x' in the flow context. TODO: Fix the test "spec-08-13". */ + + if parser.flow_level > 0 && + parser.buffer[parser.buffer_pos] == ':' && + !is_blankz_at(parser.buffer, parser.buffer_pos+1) { + yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", + start_mark, "found unexpected ':'") + return false + } + + /* Check for indicators that may end a plain scalar. */ + b := parser.buffer[parser.buffer_pos] + if (b == ':' && is_blankz_at(parser.buffer, parser.buffer_pos+1)) || + (parser.flow_level > 0 && + (b == ',' || b == ':' || + b == '?' || b == '[' || + b == ']' || b == '{' || + b == '}')) { + break + } + + /* Check if we need to join whitespaces and breaks. */ + + if leading_blanks || len(whitespaces) > 0 { + if leading_blanks { + /* Do we need to fold line breaks? */ + + if leading_break[0] == '\n' { + if len(trailing_breaks) == 0 { + s = append(s, ' ') + } else { + s = append(s, trailing_breaks...) + trailing_breaks = trailing_breaks[:0] + } + leading_break = leading_break[:0] + } else { + s = append(s, leading_break...) + s = append(s, trailing_breaks...) + leading_break = leading_break[:0] + trailing_breaks = trailing_breaks[:0] + } + + leading_blanks = false + } else { + s = append(s, whitespaces...) + whitespaces = whitespaces[:0] + } + } + + /* Copy the character. */ + + s = read(parser, s) + end_mark = parser.mark + + if !cache(parser, 2) { + return false + } + } + + /* Is it the end? */ + + if !(is_blank(parser.buffer[parser.buffer_pos]) || + is_break_at(parser.buffer, parser.buffer_pos)) { + break + } + + /* Consume blank characters. */ + + if !cache(parser, 1) { + return false + } + + for is_blank(parser.buffer[parser.buffer_pos]) || + is_break_at(parser.buffer, parser.buffer_pos) { + + if is_blank(parser.buffer[parser.buffer_pos]) { + /* Check for tab character that abuse indentation. */ + + if leading_blanks && parser.mark.column < indent && + is_tab(parser.buffer[parser.buffer_pos]) { + yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", + start_mark, "found a tab character that violate indentation") + return false + } + + /* Consume a space or a tab character. */ + + if !leading_blanks { + whitespaces = read(parser, whitespaces) + } else { + skip(parser) + } + } else { + if !cache(parser, 2) { + return false + } + + /* Check if it is a first line break. */ + + if !leading_blanks { + whitespaces = whitespaces[:0] + leading_break = read_line(parser, leading_break) + leading_blanks = true + } else { + trailing_breaks = read_line(parser, trailing_breaks) + } + } + if !cache(parser, 1) { + return false + } + } + + /* Check indentation level. */ + + if parser.flow_level == 0 && parser.mark.column < indent { + break + } + } + + /* Create a token. */ + + *token = yaml_token_t{ + token_type: yaml_SCALAR_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + value: s, + style: yaml_PLAIN_SCALAR_STYLE, + } + + /* Note that we change the 'simple_key_allowed' flag. */ + + if leading_blanks { + parser.simple_key_allowed = true + } + + return true +} diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/tags.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/tags.go new file mode 100644 index 00000000..f153aee4 --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/tags.go @@ -0,0 +1,360 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "reflect" + "sort" + "strings" + "sync" + "unicode" +) + +// A field represents a single field found in a struct. +type field struct { + name string + tag bool + index []int + typ reflect.Type + omitEmpty bool + flow bool +} + +// byName sorts field by name, breaking ties with depth, +// then breaking ties with "name came from json tag", then +// breaking ties with index sequence. +type byName []field + +func (x byName) Len() int { return len(x) } + +func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +func (x byName) Less(i, j int) bool { + if x[i].name != x[j].name { + return x[i].name < x[j].name + } + if len(x[i].index) != len(x[j].index) { + return len(x[i].index) < len(x[j].index) + } + if x[i].tag != x[j].tag { + return x[i].tag + } + return byIndex(x).Less(i, j) +} + +// byIndex sorts field by index sequence. +type byIndex []field + +func (x byIndex) Len() int { return len(x) } + +func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +func (x byIndex) Less(i, j int) bool { + for k, xik := range x[i].index { + if k >= len(x[j].index) { + return false + } + if xik != x[j].index[k] { + return xik < x[j].index[k] + } + } + return len(x[i].index) < len(x[j].index) +} + +// typeFields returns a list of fields that JSON should recognize for the given type. +// The algorithm is breadth-first search over the set of structs to include - the top struct +// and then any reachable anonymous structs. +func typeFields(t reflect.Type) []field { + // Anonymous fields to explore at the current level and the next. + current := []field{} + next := []field{{typ: t}} + + // Count of queued names for current level and the next. + count := map[reflect.Type]int{} + nextCount := map[reflect.Type]int{} + + // Types already visited at an earlier level. + visited := map[reflect.Type]bool{} + + // Fields found. + var fields []field + + for len(next) > 0 { + current, next = next, current[:0] + count, nextCount = nextCount, map[reflect.Type]int{} + + for _, f := range current { + if visited[f.typ] { + continue + } + visited[f.typ] = true + + // Scan f.typ for fields to include. + for i := 0; i < f.typ.NumField(); i++ { + sf := f.typ.Field(i) + if sf.PkgPath != "" { // unexported + continue + } + tag := sf.Tag.Get("yaml") + if tag == "-" { + continue + } + name, opts := parseTag(tag) + if !isValidTag(name) { + name = "" + } + index := make([]int, len(f.index)+1) + copy(index, f.index) + index[len(f.index)] = i + + ft := sf.Type + if ft.Name() == "" && ft.Kind() == reflect.Ptr { + // Follow pointer. + ft = ft.Elem() + } + + // Record found field and index sequence. + if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct { + tagged := name != "" + if name == "" { + name = sf.Name + } + fields = append(fields, field{name, tagged, index, ft, + opts.Contains("omitempty"), opts.Contains("flow")}) + if count[f.typ] > 1 { + // If there were multiple instances, add a second, + // so that the annihilation code will see a duplicate. + // It only cares about the distinction between 1 or 2, + // so don't bother generating any more copies. + fields = append(fields, fields[len(fields)-1]) + } + continue + } + + // Record new anonymous struct to explore in next round. + nextCount[ft]++ + if nextCount[ft] == 1 { + next = append(next, field{name: ft.Name(), index: index, typ: ft}) + } + } + } + } + + sort.Sort(byName(fields)) + + // Delete all fields that are hidden by the Go rules for embedded fields, + // except that fields with JSON tags are promoted. + + // The fields are sorted in primary order of name, secondary order + // of field index length. Loop over names; for each name, delete + // hidden fields by choosing the one dominant field that survives. + out := fields[:0] + for advance, i := 0, 0; i < len(fields); i += advance { + // One iteration per name. + // Find the sequence of fields with the name of this first field. + fi := fields[i] + name := fi.name + for advance = 1; i+advance < len(fields); advance++ { + fj := fields[i+advance] + if fj.name != name { + break + } + } + if advance == 1 { // Only one field with this name + out = append(out, fi) + continue + } + dominant, ok := dominantField(fields[i : i+advance]) + if ok { + out = append(out, dominant) + } + } + + fields = out + sort.Sort(byIndex(fields)) + + return fields +} + +// dominantField looks through the fields, all of which are known to +// have the same name, to find the single field that dominates the +// others using Go's embedding rules, modified by the presence of +// JSON tags. If there are multiple top-level fields, the boolean +// will be false: This condition is an error in Go and we skip all +// the fields. +func dominantField(fields []field) (field, bool) { + // The fields are sorted in increasing index-length order. The winner + // must therefore be one with the shortest index length. Drop all + // longer entries, which is easy: just truncate the slice. + length := len(fields[0].index) + tagged := -1 // Index of first tagged field. + for i, f := range fields { + if len(f.index) > length { + fields = fields[:i] + break + } + if f.tag { + if tagged >= 0 { + // Multiple tagged fields at the same level: conflict. + // Return no field. + return field{}, false + } + tagged = i + } + } + if tagged >= 0 { + return fields[tagged], true + } + // All remaining fields have the same length. If there's more than one, + // we have a conflict (two fields named "X" at the same level) and we + // return no field. + if len(fields) > 1 { + return field{}, false + } + return fields[0], true +} + +var fieldCache struct { + sync.RWMutex + m map[reflect.Type][]field +} + +// cachedTypeFields is like typeFields but uses a cache to avoid repeated work. +func cachedTypeFields(t reflect.Type) []field { + fieldCache.RLock() + f := fieldCache.m[t] + fieldCache.RUnlock() + if f != nil { + return f + } + + // Compute fields without lock. + // Might duplicate effort but won't hold other computations back. + f = typeFields(t) + if f == nil { + f = []field{} + } + + fieldCache.Lock() + if fieldCache.m == nil { + fieldCache.m = map[reflect.Type][]field{} + } + fieldCache.m[t] = f + fieldCache.Unlock() + return f +} + +// tagOptions is the string following a comma in a struct field's "json" +// tag, or the empty string. It does not include the leading comma. +type tagOptions string + +func isValidTag(s string) bool { + if s == "" { + return false + } + for _, c := range s { + switch { + case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c): + // Backslash and quote chars are reserved, but + // otherwise any punctuation chars are allowed + // in a tag name. + default: + if !unicode.IsLetter(c) && !unicode.IsDigit(c) { + return false + } + } + } + return true +} + +func fieldByIndex(v reflect.Value, index []int) reflect.Value { + for _, i := range index { + if v.Kind() == reflect.Ptr { + if v.IsNil() { + return reflect.Value{} + } + v = v.Elem() + } + v = v.Field(i) + } + return v +} + +func typeByIndex(t reflect.Type, index []int) reflect.Type { + for _, i := range index { + if t.Kind() == reflect.Ptr { + t = t.Elem() + } + t = t.Field(i).Type + } + return t +} + +// stringValues is a slice of reflect.Value holding *reflect.StringValue. +// It implements the methods to sort by string. +type stringValues []reflect.Value + +func (sv stringValues) Len() int { return len(sv) } +func (sv stringValues) Swap(i, j int) { sv[i], sv[j] = sv[j], sv[i] } +func (sv stringValues) Less(i, j int) bool { + av, ak := getElem(sv[i]) + bv, bk := getElem(sv[j]) + if ak == reflect.String && bk == reflect.String { + return av.String() < bv.String() + } + + return ak < bk +} + +func getElem(v reflect.Value) (reflect.Value, reflect.Kind) { + k := v.Kind() + for k == reflect.Interface || k == reflect.Ptr && !v.IsNil() { + v = v.Elem() + k = v.Kind() + } + + return v, k +} + +// parseTag splits a struct field's json tag into its name and +// comma-separated options. +func parseTag(tag string) (string, tagOptions) { + if idx := strings.Index(tag, ","); idx != -1 { + return tag[:idx], tagOptions(tag[idx+1:]) + } + return tag, tagOptions("") +} + +// Contains reports whether a comma-separated list of options +// contains a particular substr flag. substr must be surrounded by a +// string boundary or commas. +func (o tagOptions) Contains(optionName string) bool { + if len(o) == 0 { + return false + } + s := string(o) + for s != "" { + var next string + i := strings.Index(s, ",") + if i >= 0 { + s, next = s[:i], s[i+1:] + } + if s == optionName { + return true + } + s = next + } + return false +} diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/writer.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/writer.go new file mode 100644 index 00000000..a76b6336 --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/writer.go @@ -0,0 +1,128 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +/* + * Set the writer error and return 0. + */ + +func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool { + emitter.error = yaml_WRITER_ERROR + emitter.problem = problem + + return false +} + +/* + * Flush the output buffer. + */ + +func yaml_emitter_flush(emitter *yaml_emitter_t) bool { + if emitter.write_handler == nil { + panic("Write handler must be set") /* Write handler must be set. */ + } + if emitter.encoding == yaml_ANY_ENCODING { + panic("Encoding must be set") /* Output encoding must be set. */ + } + + /* Check if the buffer is empty. */ + + if emitter.buffer_pos == 0 { + return true + } + + /* If the output encoding is UTF-8, we don't need to recode the buffer. */ + + if emitter.encoding == yaml_UTF8_ENCODING { + if err := emitter.write_handler(emitter, + emitter.buffer[:emitter.buffer_pos]); err != nil { + return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error()) + } + emitter.buffer_pos = 0 + return true + } + + /* Recode the buffer into the raw buffer. */ + + var low, high int + if emitter.encoding == yaml_UTF16LE_ENCODING { + low, high = 0, 1 + } else { + high, low = 1, 0 + } + + pos := 0 + for pos < emitter.buffer_pos { + + /* + * See the "reader.c" code for more details on UTF-8 encoding. Note + * that we assume that the buffer contains a valid UTF-8 sequence. + */ + + /* Read the next UTF-8 character. */ + + octet := emitter.buffer[pos] + + var w int + var value rune + switch { + case octet&0x80 == 0x00: + w, value = 1, rune(octet&0x7F) + case octet&0xE0 == 0xC0: + w, value = 2, rune(octet&0x1F) + case octet&0xF0 == 0xE0: + w, value = 3, rune(octet&0x0F) + case octet&0xF8 == 0xF0: + w, value = 4, rune(octet&0x07) + } + + for k := 1; k < w; k++ { + octet = emitter.buffer[pos+k] + value = (value << 6) + (rune(octet) & 0x3F) + } + + pos += w + + /* Write the character. */ + + if value < 0x10000 { + var b [2]byte + b[high] = byte(value >> 8) + b[low] = byte(value & 0xFF) + emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1]) + } else { + /* Write the character using a surrogate pair (check "reader.c"). */ + + var b [4]byte + value -= 0x10000 + b[high] = byte(0xD8 + (value >> 18)) + b[low] = byte((value >> 10) & 0xFF) + b[high+2] = byte(0xDC + ((value >> 8) & 0xFF)) + b[low+2] = byte(value & 0xFF) + emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1], b[2], b[3]) + } + } + + /* Write the raw buffer. */ + + // Write the raw buffer. + if err := emitter.write_handler(emitter, emitter.raw_buffer); err != nil { + return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error()) + } + + emitter.buffer_pos = 0 + emitter.raw_buffer = emitter.raw_buffer[:0] + return true +} diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/yaml_definesh.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/yaml_definesh.go new file mode 100644 index 00000000..de4c05ad --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/yaml_definesh.go @@ -0,0 +1,22 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +const ( + yaml_VERSION_MAJOR = 0 + yaml_VERSION_MINOR = 1 + yaml_VERSION_PATCH = 6 + yaml_VERSION_STRING = "0.1.6" +) diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/yaml_privateh.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/yaml_privateh.go new file mode 100644 index 00000000..2b3b7d74 --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/yaml_privateh.go @@ -0,0 +1,891 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +const ( + INPUT_RAW_BUFFER_SIZE = 1024 + + /* + * The size of the input buffer. + * + * It should be possible to decode the whole raw buffer. + */ + INPUT_BUFFER_SIZE = (INPUT_RAW_BUFFER_SIZE * 3) + + /* + * The size of the output buffer. + */ + + OUTPUT_BUFFER_SIZE = 512 + + /* + * The size of the output raw buffer. + * + * It should be possible to encode the whole output buffer. + */ + + OUTPUT_RAW_BUFFER_SIZE = (OUTPUT_BUFFER_SIZE*2 + 2) + + INITIAL_STACK_SIZE = 16 + INITIAL_QUEUE_SIZE = 16 +) + +func width(b byte) int { + if b&0x80 == 0 { + return 1 + } + + if b&0xE0 == 0xC0 { + return 2 + } + + if b&0xF0 == 0xE0 { + return 3 + } + + if b&0xF8 == 0xF0 { + return 4 + } + + return 0 +} + +func copy_bytes(dest []byte, dest_pos *int, src []byte, src_pos *int) { + w := width(src[*src_pos]) + switch w { + case 4: + dest[*dest_pos+3] = src[*src_pos+3] + fallthrough + case 3: + dest[*dest_pos+2] = src[*src_pos+2] + fallthrough + case 2: + dest[*dest_pos+1] = src[*src_pos+1] + fallthrough + case 1: + dest[*dest_pos] = src[*src_pos] + default: + panic("invalid width") + } + *dest_pos += w + *src_pos += w +} + +// /* +// * Check if the character at the specified position is an alphabetical +// * character, a digit, '_', or '-'. +// */ + +func is_alpha(b byte) bool { + return (b >= '0' && b <= '9') || + (b >= 'A' && b <= 'Z') || + (b >= 'a' && b <= 'z') || + b == '_' || b == '-' +} + +// /* +// * Check if the character at the specified position is a digit. +// */ +// +func is_digit(b byte) bool { + return b >= '0' && b <= '9' +} + +// /* +// * Get the value of a digit. +// */ +// +func as_digit(b byte) int { + return int(b) - '0' +} + +// /* +// * Check if the character at the specified position is a hex-digit. +// */ +// +func is_hex(b byte) bool { + return (b >= '0' && b <= '9') || + (b >= 'A' && b <= 'F') || + (b >= 'a' && b <= 'f') +} + +// +// /* +// * Get the value of a hex-digit. +// */ +// +func as_hex(b byte) int { + if b >= 'A' && b <= 'F' { + return int(b) - 'A' + 10 + } else if b >= 'a' && b <= 'f' { + return int(b) - 'a' + 10 + } + return int(b) - '0' +} + +// #define AS_HEX_AT(string,offset) \ +// (((string).pointer[offset] >= (yaml_char_t) 'A' && \ +// (string).pointer[offset] <= (yaml_char_t) 'F') ? \ +// ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \ +// ((string).pointer[offset] >= (yaml_char_t) 'a' && \ +// (string).pointer[offset] <= (yaml_char_t) 'f') ? \ +// ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \ +// ((string).pointer[offset] - (yaml_char_t) '0')) + +// /* +// * Check if the character is a line break, space, tab, or NUL. +// */ +func is_blankz_at(b []byte, i int) bool { + return is_blank(b[i]) || is_breakz_at(b, i) +} + +// /* +// * Check if the character at the specified position is a line break. +// */ +func is_break_at(b []byte, i int) bool { + return b[i] == '\r' || /* CR (#xD)*/ + b[i] == '\n' || /* LF (#xA) */ + (b[i] == 0xC2 && b[i+1] == 0x85) || /* NEL (#x85) */ + (b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8) || /* LS (#x2028) */ + (b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) /* PS (#x2029) */ +} + +func is_breakz_at(b []byte, i int) bool { + return is_break_at(b, i) || is_z(b[i]) +} + +func is_crlf_at(b []byte, i int) bool { + return b[i] == '\r' && b[i+1] == '\n' +} + +// /* +// * Check if the character at the specified position is NUL. +// */ +func is_z(b byte) bool { + return b == 0x0 +} + +// /* +// * Check if the character at the specified position is space. +// */ +func is_space(b byte) bool { + return b == ' ' +} + +// +// /* +// * Check if the character at the specified position is tab. +// */ +func is_tab(b byte) bool { + return b == '\t' +} + +// /* +// * Check if the character at the specified position is blank (space or tab). +// */ +func is_blank(b byte) bool { + return is_space(b) || is_tab(b) +} + +// /* +// * Check if the character is ASCII. +// */ +func is_ascii(b byte) bool { + return b <= '\x7f' +} + +// /* +// * Check if the character can be printed unescaped. +// */ +func is_printable_at(b []byte, i int) bool { + return ((b[i] == 0x0A) || /* . == #x0A */ + (b[i] >= 0x20 && b[i] <= 0x7E) || /* #x20 <= . <= #x7E */ + (b[i] == 0xC2 && b[i+1] >= 0xA0) || /* #0xA0 <= . <= #xD7FF */ + (b[i] > 0xC2 && b[i] < 0xED) || + (b[i] == 0xED && b[i+1] < 0xA0) || + (b[i] == 0xEE) || + (b[i] == 0xEF && /* && . != #xFEFF */ + !(b[i+1] == 0xBB && b[i+2] == 0xBF) && + !(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF)))) +} + +func insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) { + // collapse the slice + if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) { + if parser.tokens_head != len(parser.tokens) { + // move the tokens down + copy(parser.tokens, parser.tokens[parser.tokens_head:]) + } + // readjust the length + parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head] + parser.tokens_head = 0 + } + + parser.tokens = append(parser.tokens, *token) + if pos < 0 { + return + } + copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:]) + parser.tokens[parser.tokens_head+pos] = *token +} + +// /* +// * Check if the character at the specified position is BOM. +// */ +// +func is_bom_at(b []byte, i int) bool { + return b[i] == 0xEF && b[i+1] == 0xBB && b[i+2] == 0xBF +} + +// +// #ifdef HAVE_CONFIG_H +// #include +// #endif +// +// #include "./yaml.h" +// +// #include +// #include +// +// /* +// * Memory management. +// */ +// +// yaml_DECLARE(void *) +// yaml_malloc(size_t size); +// +// yaml_DECLARE(void *) +// yaml_realloc(void *ptr, size_t size); +// +// yaml_DECLARE(void) +// yaml_free(void *ptr); +// +// yaml_DECLARE(yaml_char_t *) +// yaml_strdup(const yaml_char_t *); +// +// /* +// * Reader: Ensure that the buffer contains at least `length` characters. +// */ +// +// yaml_DECLARE(int) +// yaml_parser_update_buffer(yaml_parser_t *parser, size_t length); +// +// /* +// * Scanner: Ensure that the token stack contains at least one token ready. +// */ +// +// yaml_DECLARE(int) +// yaml_parser_fetch_more_tokens(yaml_parser_t *parser); +// +// /* +// * The size of the input raw buffer. +// */ +// +// #define INPUT_RAW_BUFFER_SIZE 16384 +// +// /* +// * The size of the input buffer. +// * +// * It should be possible to decode the whole raw buffer. +// */ +// +// #define INPUT_BUFFER_SIZE (INPUT_RAW_BUFFER_SIZE*3) +// +// /* +// * The size of the output buffer. +// */ +// +// #define OUTPUT_BUFFER_SIZE 16384 +// +// /* +// * The size of the output raw buffer. +// * +// * It should be possible to encode the whole output buffer. +// */ +// +// #define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2) +// +// /* +// * The size of other stacks and queues. +// */ +// +// #define INITIAL_STACK_SIZE 16 +// #define INITIAL_QUEUE_SIZE 16 +// #define INITIAL_STRING_SIZE 16 +// +// /* +// * Buffer management. +// */ +// +// #define BUFFER_INIT(context,buffer,size) \ +// (((buffer).start = yaml_malloc(size)) ? \ +// ((buffer).last = (buffer).pointer = (buffer).start, \ +// (buffer).end = (buffer).start+(size), \ +// 1) : \ +// ((context)->error = yaml_MEMORY_ERROR, \ +// 0)) +// +// #define BUFFER_DEL(context,buffer) \ +// (yaml_free((buffer).start), \ +// (buffer).start = (buffer).pointer = (buffer).end = 0) +// +// /* +// * String management. +// */ +// +// typedef struct { +// yaml_char_t *start; +// yaml_char_t *end; +// yaml_char_t *pointer; +// } yaml_string_t; +// +// yaml_DECLARE(int) +// yaml_string_extend(yaml_char_t **start, +// yaml_char_t **pointer, yaml_char_t **end); +// +// yaml_DECLARE(int) +// yaml_string_join( +// yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end, +// yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end); +// +// #define NULL_STRING { NULL, NULL, NULL } +// +// #define STRING(string,length) { (string), (string)+(length), (string) } +// +// #define STRING_ASSIGN(value,string,length) \ +// ((value).start = (string), \ +// (value).end = (string)+(length), \ +// (value).pointer = (string)) +// +// #define STRING_INIT(context,string,size) \ +// (((string).start = yaml_malloc(size)) ? \ +// ((string).pointer = (string).start, \ +// (string).end = (string).start+(size), \ +// memset((string).start, 0, (size)), \ +// 1) : \ +// ((context)->error = yaml_MEMORY_ERROR, \ +// 0)) +// +// #define STRING_DEL(context,string) \ +// (yaml_free((string).start), \ +// (string).start = (string).pointer = (string).end = 0) +// +// #define STRING_EXTEND(context,string) \ +// (((string).pointer+5 < (string).end) \ +// || yaml_string_extend(&(string).start, \ +// &(string).pointer, &(string).end)) +// +// #define CLEAR(context,string) \ +// ((string).pointer = (string).start, \ +// memset((string).start, 0, (string).end-(string).start)) +// +// #define JOIN(context,string_a,string_b) \ +// ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ +// &(string_a).end, &(string_b).start, \ +// &(string_b).pointer, &(string_b).end)) ? \ +// ((string_b).pointer = (string_b).start, \ +// 1) : \ +// ((context)->error = yaml_MEMORY_ERROR, \ +// 0)) +// +// /* +// * String check operations. +// */ +// +// /* +// * Check the octet at the specified position. +// */ +// +// #define CHECK_AT(string,octet,offset) \ +// ((string).pointer[offset] == (yaml_char_t)(octet)) +// +// /* +// * Check the current octet in the buffer. +// */ +// +// #define CHECK(string,octet) CHECK_AT((string),(octet),0) +// +// /* +// * Check if the character at the specified position is an alphabetical +// * character, a digit, '_', or '-'. +// */ +// +// #define IS_ALPHA_AT(string,offset) \ +// (((string).pointer[offset] >= (yaml_char_t) '0' && \ +// (string).pointer[offset] <= (yaml_char_t) '9') || \ +// ((string).pointer[offset] >= (yaml_char_t) 'A' && \ +// (string).pointer[offset] <= (yaml_char_t) 'Z') || \ +// ((string).pointer[offset] >= (yaml_char_t) 'a' && \ +// (string).pointer[offset] <= (yaml_char_t) 'z') || \ +// (string).pointer[offset] == '_' || \ +// (string).pointer[offset] == '-') +// +// #define IS_ALPHA(string) IS_ALPHA_AT((string),0) +// +// /* +// * Check if the character at the specified position is a digit. +// */ +// +// #define IS_DIGIT_AT(string,offset) \ +// (((string).pointer[offset] >= (yaml_char_t) '0' && \ +// (string).pointer[offset] <= (yaml_char_t) '9')) +// +// #define IS_DIGIT(string) IS_DIGIT_AT((string),0) +// +// /* +// * Get the value of a digit. +// */ +// +// #define AS_DIGIT_AT(string,offset) \ +// ((string).pointer[offset] - (yaml_char_t) '0') +// +// #define AS_DIGIT(string) AS_DIGIT_AT((string),0) +// +// /* +// * Check if the character at the specified position is a hex-digit. +// */ +// +// #define IS_HEX_AT(string,offset) \ +// (((string).pointer[offset] >= (yaml_char_t) '0' && \ +// (string).pointer[offset] <= (yaml_char_t) '9') || \ +// ((string).pointer[offset] >= (yaml_char_t) 'A' && \ +// (string).pointer[offset] <= (yaml_char_t) 'F') || \ +// ((string).pointer[offset] >= (yaml_char_t) 'a' && \ +// (string).pointer[offset] <= (yaml_char_t) 'f')) +// +// #define IS_HEX(string) IS_HEX_AT((string),0) +// +// /* +// * Get the value of a hex-digit. +// */ +// +// #define AS_HEX_AT(string,offset) \ +// (((string).pointer[offset] >= (yaml_char_t) 'A' && \ +// (string).pointer[offset] <= (yaml_char_t) 'F') ? \ +// ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \ +// ((string).pointer[offset] >= (yaml_char_t) 'a' && \ +// (string).pointer[offset] <= (yaml_char_t) 'f') ? \ +// ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \ +// ((string).pointer[offset] - (yaml_char_t) '0')) +// +// #define AS_HEX(string) AS_HEX_AT((string),0) +// +// /* +// * Check if the character is ASCII. +// */ +// +// #define IS_ASCII_AT(string,offset) \ +// ((string).pointer[offset] <= (yaml_char_t) '\x7F') +// +// #define IS_ASCII(string) IS_ASCII_AT((string),0) +// +// /* +// * Check if the character can be printed unescaped. +// */ +// +// #define IS_PRINTABLE_AT(string,offset) \ +// (((string).pointer[offset] == 0x0A) /* . == #x0A */ \ +// || ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \ +// && (string).pointer[offset] <= 0x7E) \ +// || ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \ +// && (string).pointer[offset+1] >= 0xA0) \ +// || ((string).pointer[offset] > 0xC2 \ +// && (string).pointer[offset] < 0xED) \ +// || ((string).pointer[offset] == 0xED \ +// && (string).pointer[offset+1] < 0xA0) \ +// || ((string).pointer[offset] == 0xEE) \ +// || ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \ +// && !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \ +// && (string).pointer[offset+2] == 0xBF) \ +// && !((string).pointer[offset+1] == 0xBF \ +// && ((string).pointer[offset+2] == 0xBE \ +// || (string).pointer[offset+2] == 0xBF)))) +// +// #define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0) +// +// /* +// * Check if the character at the specified position is NUL. +// */ +// +// #define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) +// +// #define IS_Z(string) IS_Z_AT((string),0) +// +// /* +// * Check if the character at the specified position is BOM. +// */ +// +// #define IS_BOM_AT(string,offset) \ +// (CHECK_AT((string),'\xEF',(offset)) \ +// && CHECK_AT((string),'\xBB',(offset)+1) \ +// && CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */ +// +// #define IS_BOM(string) IS_BOM_AT(string,0) +// +// /* +// * Check if the character at the specified position is space. +// */ +// +// #define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) +// +// #define IS_SPACE(string) IS_SPACE_AT((string),0) +// +// /* +// * Check if the character at the specified position is tab. +// */ +// +// #define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) +// +// #define IS_TAB(string) IS_TAB_AT((string),0) +// +// /* +// * Check if the character at the specified position is blank (space or tab). +// */ +// +// #define IS_BLANK_AT(string,offset) \ +// (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) +// +// #define IS_BLANK(string) IS_BLANK_AT((string),0) +// +// /* +// * Check if the character at the specified position is a line break. +// */ +// +// #define IS_BREAK_AT(string,offset) \ +// (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ +// || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ +// || (CHECK_AT((string),'\xC2',(offset)) \ +// && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ +// || (CHECK_AT((string),'\xE2',(offset)) \ +// && CHECK_AT((string),'\x80',(offset)+1) \ +// && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ +// || (CHECK_AT((string),'\xE2',(offset)) \ +// && CHECK_AT((string),'\x80',(offset)+1) \ +// && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ +// +// #define IS_BREAK(string) IS_BREAK_AT((string),0) +// +// #define IS_CRLF_AT(string,offset) \ +// (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) +// +// #define IS_CRLF(string) IS_CRLF_AT((string),0) +// +// /* +// * Check if the character is a line break or NUL. +// */ +// +// #define IS_BREAKZ_AT(string,offset) \ +// (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) +// +// #define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) +// +// /* +// * Check if the character is a line break, space, or NUL. +// */ +// +// #define IS_SPACEZ_AT(string,offset) \ +// (IS_SPACE_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) +// +// #define IS_SPACEZ(string) IS_SPACEZ_AT((string),0) +// +// /* +// * Check if the character is a line break, space, tab, or NUL. +// */ +// +// #define IS_BLANKZ_AT(string,offset) \ +// (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) +// +// #define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) +// +// /* +// * Determine the width of the character. +// */ +// +// #define WIDTH_AT(string,offset) \ +// (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ +// ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ +// ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ +// ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) +// +// #define WIDTH(string) WIDTH_AT((string),0) +// +// /* +// * Move the string pointer to the next character. +// */ +// +// #define MOVE(string) ((string).pointer += WIDTH((string))) +// +// /* +// * Copy a character and move the pointers of both strings. +// */ +// +// #define COPY(string_a,string_b) \ +// ((*(string_b).pointer & 0x80) == 0x00 ? \ +// (*((string_a).pointer++) = *((string_b).pointer++)) : \ +// (*(string_b).pointer & 0xE0) == 0xC0 ? \ +// (*((string_a).pointer++) = *((string_b).pointer++), \ +// *((string_a).pointer++) = *((string_b).pointer++)) : \ +// (*(string_b).pointer & 0xF0) == 0xE0 ? \ +// (*((string_a).pointer++) = *((string_b).pointer++), \ +// *((string_a).pointer++) = *((string_b).pointer++), \ +// *((string_a).pointer++) = *((string_b).pointer++)) : \ +// (*(string_b).pointer & 0xF8) == 0xF0 ? \ +// (*((string_a).pointer++) = *((string_b).pointer++), \ +// *((string_a).pointer++) = *((string_b).pointer++), \ +// *((string_a).pointer++) = *((string_b).pointer++), \ +// *((string_a).pointer++) = *((string_b).pointer++)) : 0) +// +// /* +// * Stack and queue management. +// */ +// +// yaml_DECLARE(int) +// yaml_stack_extend(void **start, void **top, void **end); +// +// yaml_DECLARE(int) +// yaml_queue_extend(void **start, void **head, void **tail, void **end); +// +// #define STACK_INIT(context,stack,size) \ +// (((stack).start = yaml_malloc((size)*sizeof(*(stack).start))) ? \ +// ((stack).top = (stack).start, \ +// (stack).end = (stack).start+(size), \ +// 1) : \ +// ((context)->error = yaml_MEMORY_ERROR, \ +// 0)) +// +// #define STACK_DEL(context,stack) \ +// (yaml_free((stack).start), \ +// (stack).start = (stack).top = (stack).end = 0) +// +// #define STACK_EMPTY(context,stack) \ +// ((stack).start == (stack).top) +// +// #define PUSH(context,stack,value) \ +// (((stack).top != (stack).end \ +// || yaml_stack_extend((void **)&(stack).start, \ +// (void **)&(stack).top, (void **)&(stack).end)) ? \ +// (*((stack).top++) = value, \ +// 1) : \ +// ((context)->error = yaml_MEMORY_ERROR, \ +// 0)) +// +// #define POP(context,stack) \ +// (*(--(stack).top)) +// +// #define QUEUE_INIT(context,queue,size) \ +// (((queue).start = yaml_malloc((size)*sizeof(*(queue).start))) ? \ +// ((queue).head = (queue).tail = (queue).start, \ +// (queue).end = (queue).start+(size), \ +// 1) : \ +// ((context)->error = yaml_MEMORY_ERROR, \ +// 0)) +// +// #define QUEUE_DEL(context,queue) \ +// (yaml_free((queue).start), \ +// (queue).start = (queue).head = (queue).tail = (queue).end = 0) +// +// #define QUEUE_EMPTY(context,queue) \ +// ((queue).head == (queue).tail) +// +// #define ENQUEUE(context,queue,value) \ +// (((queue).tail != (queue).end \ +// || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ +// (void **)&(queue).tail, (void **)&(queue).end)) ? \ +// (*((queue).tail++) = value, \ +// 1) : \ +// ((context)->error = yaml_MEMORY_ERROR, \ +// 0)) +// +// #define DEQUEUE(context,queue) \ +// (*((queue).head++)) +// +// #define QUEUE_INSERT(context,queue,index,value) \ +// (((queue).tail != (queue).end \ +// || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ +// (void **)&(queue).tail, (void **)&(queue).end)) ? \ +// (memmove((queue).head+(index)+1,(queue).head+(index), \ +// ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \ +// *((queue).head+(index)) = value, \ +// (queue).tail++, \ +// 1) : \ +// ((context)->error = yaml_MEMORY_ERROR, \ +// 0)) +// +// /* +// * Token initializers. +// */ +// +// #define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark) \ +// (memset(&(token), 0, sizeof(yaml_token_t)), \ +// (token).type = (token_type), \ +// (token).start_mark = (token_start_mark), \ +// (token).end_mark = (token_end_mark)) +// +// #define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark) \ +// (TOKEN_INIT((token),yaml_STREAM_START_TOKEN,(start_mark),(end_mark)), \ +// (token).data.stream_start.encoding = (token_encoding)) +// +// #define STREAM_END_TOKEN_INIT(token,start_mark,end_mark) \ +// (TOKEN_INIT((token),yaml_STREAM_END_TOKEN,(start_mark),(end_mark))) +// +// #define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark) \ +// (TOKEN_INIT((token),yaml_ALIAS_TOKEN,(start_mark),(end_mark)), \ +// (token).data.alias.value = (token_value)) +// +// #define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark) \ +// (TOKEN_INIT((token),yaml_ANCHOR_TOKEN,(start_mark),(end_mark)), \ +// (token).data.anchor.value = (token_value)) +// +// #define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark) \ +// (TOKEN_INIT((token),yaml_TAG_TOKEN,(start_mark),(end_mark)), \ +// (token).data.tag.handle = (token_handle), \ +// (token).data.tag.suffix = (token_suffix)) +// +// #define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark) \ +// (TOKEN_INIT((token),yaml_SCALAR_TOKEN,(start_mark),(end_mark)), \ +// (token).data.scalar.value = (token_value), \ +// (token).data.scalar.length = (token_length), \ +// (token).data.scalar.style = (token_style)) +// +// #define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark) \ +// (TOKEN_INIT((token),yaml_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ +// (token).data.version_directive.major = (token_major), \ +// (token).data.version_directive.minor = (token_minor)) +// +// #define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark) \ +// (TOKEN_INIT((token),yaml_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ +// (token).data.tag_directive.handle = (token_handle), \ +// (token).data.tag_directive.prefix = (token_prefix)) +// +// /* +// * Event initializers. +// */ +// +// #define EVENT_INIT(event,event_type,event_start_mark,event_end_mark) \ +// (memset(&(event), 0, sizeof(yaml_event_t)), \ +// (event).type = (event_type), \ +// (event).start_mark = (event_start_mark), \ +// (event).end_mark = (event_end_mark)) +// +// #define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark) \ +// (EVENT_INIT((event),yaml_STREAM_START_EVENT,(start_mark),(end_mark)), \ +// (event).data.stream_start.encoding = (event_encoding)) +// +// #define STREAM_END_EVENT_INIT(event,start_mark,end_mark) \ +// (EVENT_INIT((event),yaml_STREAM_END_EVENT,(start_mark),(end_mark))) +// +// #define DOCUMENT_START_EVENT_INIT(event,event_version_directive, \ +// event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \ +// (EVENT_INIT((event),yaml_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \ +// (event).data.document_start.version_directive = (event_version_directive), \ +// (event).data.document_start.tag_directives.start = (event_tag_directives_start), \ +// (event).data.document_start.tag_directives.end = (event_tag_directives_end), \ +// (event).data.document_start.implicit = (event_implicit)) +// +// #define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark) \ +// (EVENT_INIT((event),yaml_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \ +// (event).data.document_end.implicit = (event_implicit)) +// +// #define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark) \ +// (EVENT_INIT((event),yaml_ALIAS_EVENT,(start_mark),(end_mark)), \ +// (event).data.alias.anchor = (event_anchor)) +// +// #define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length, \ +// event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark) \ +// (EVENT_INIT((event),yaml_SCALAR_EVENT,(start_mark),(end_mark)), \ +// (event).data.scalar.anchor = (event_anchor), \ +// (event).data.scalar.tag = (event_tag), \ +// (event).data.scalar.value = (event_value), \ +// (event).data.scalar.length = (event_length), \ +// (event).data.scalar.plain_implicit = (event_plain_implicit), \ +// (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ +// (event).data.scalar.style = (event_style)) +// +// #define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag, \ +// event_implicit,event_style,start_mark,end_mark) \ +// (EVENT_INIT((event),yaml_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ +// (event).data.sequence_start.anchor = (event_anchor), \ +// (event).data.sequence_start.tag = (event_tag), \ +// (event).data.sequence_start.implicit = (event_implicit), \ +// (event).data.sequence_start.style = (event_style)) +// +// #define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark) \ +// (EVENT_INIT((event),yaml_SEQUENCE_END_EVENT,(start_mark),(end_mark))) +// +// #define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag, \ +// event_implicit,event_style,start_mark,end_mark) \ +// (EVENT_INIT((event),yaml_MAPPING_START_EVENT,(start_mark),(end_mark)), \ +// (event).data.mapping_start.anchor = (event_anchor), \ +// (event).data.mapping_start.tag = (event_tag), \ +// (event).data.mapping_start.implicit = (event_implicit), \ +// (event).data.mapping_start.style = (event_style)) +// +// #define MAPPING_END_EVENT_INIT(event,start_mark,end_mark) \ +// (EVENT_INIT((event),yaml_MAPPING_END_EVENT,(start_mark),(end_mark))) +// +// /* +// * Document initializer. +// */ +// +// #define DOCUMENT_INIT(document,document_nodes_start,document_nodes_end, \ +// document_version_directive,document_tag_directives_start, \ +// document_tag_directives_end,document_start_implicit, \ +// document_end_implicit,document_start_mark,document_end_mark) \ +// (memset(&(document), 0, sizeof(yaml_document_t)), \ +// (document).nodes.start = (document_nodes_start), \ +// (document).nodes.end = (document_nodes_end), \ +// (document).nodes.top = (document_nodes_start), \ +// (document).version_directive = (document_version_directive), \ +// (document).tag_directives.start = (document_tag_directives_start), \ +// (document).tag_directives.end = (document_tag_directives_end), \ +// (document).start_implicit = (document_start_implicit), \ +// (document).end_implicit = (document_end_implicit), \ +// (document).start_mark = (document_start_mark), \ +// (document).end_mark = (document_end_mark)) +// +// /* +// * Node initializers. +// */ +// +// #define NODE_INIT(node,node_type,node_tag,node_start_mark,node_end_mark) \ +// (memset(&(node), 0, sizeof(yaml_node_t)), \ +// (node).type = (node_type), \ +// (node).tag = (node_tag), \ +// (node).start_mark = (node_start_mark), \ +// (node).end_mark = (node_end_mark)) +// +// #define SCALAR_NODE_INIT(node,node_tag,node_value,node_length, \ +// node_style,start_mark,end_mark) \ +// (NODE_INIT((node),yaml_SCALAR_NODE,(node_tag),(start_mark),(end_mark)), \ +// (node).data.scalar.value = (node_value), \ +// (node).data.scalar.length = (node_length), \ +// (node).data.scalar.style = (node_style)) +// +// #define SEQUENCE_NODE_INIT(node,node_tag,node_items_start,node_items_end, \ +// node_style,start_mark,end_mark) \ +// (NODE_INIT((node),yaml_SEQUENCE_NODE,(node_tag),(start_mark),(end_mark)), \ +// (node).data.sequence.items.start = (node_items_start), \ +// (node).data.sequence.items.end = (node_items_end), \ +// (node).data.sequence.items.top = (node_items_start), \ +// (node).data.sequence.style = (node_style)) +// +// #define MAPPING_NODE_INIT(node,node_tag,node_pairs_start,node_pairs_end, \ +// node_style,start_mark,end_mark) \ +// (NODE_INIT((node),yaml_MAPPING_NODE,(node_tag),(start_mark),(end_mark)), \ +// (node).data.mapping.pairs.start = (node_pairs_start), \ +// (node).data.mapping.pairs.end = (node_pairs_end), \ +// (node).data.mapping.pairs.top = (node_pairs_start), \ +// (node).data.mapping.style = (node_style)) +// diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/yamlh.go b/vendor/github.com/cloudfoundry-incubator/candiedyaml/yamlh.go new file mode 100644 index 00000000..d608dbb3 --- /dev/null +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/yamlh.go @@ -0,0 +1,953 @@ +/* +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package candiedyaml + +import ( + "fmt" + "io" +) + +/** The version directive data. */ +type yaml_version_directive_t struct { + major int // The major version number + minor int // The minor version number +} + +/** The tag directive data. */ +type yaml_tag_directive_t struct { + handle []byte // The tag handle + prefix []byte // The tag prefix +} + +/** The stream encoding. */ +type yaml_encoding_t int + +const ( + /** Let the parser choose the encoding. */ + yaml_ANY_ENCODING yaml_encoding_t = iota + /** The defau lt UTF-8 encoding. */ + yaml_UTF8_ENCODING + /** The UTF-16-LE encoding with BOM. */ + yaml_UTF16LE_ENCODING + /** The UTF-16-BE encoding with BOM. */ + yaml_UTF16BE_ENCODING +) + +/** Line break types. */ +type yaml_break_t int + +const ( + yaml_ANY_BREAK yaml_break_t = iota /** Let the parser choose the break type. */ + yaml_CR_BREAK /** Use CR for line breaks (Mac style). */ + yaml_LN_BREAK /** Use LN for line breaks (Unix style). */ + yaml_CRLN_BREAK /** Use CR LN for line breaks (DOS style). */ +) + +/** Many bad things could happen with the parser and emitter. */ +type YAML_error_type_t int + +const ( + /** No error is produced. */ + yaml_NO_ERROR YAML_error_type_t = iota + + /** Cannot allocate or reallocate a block of memory. */ + yaml_MEMORY_ERROR + + /** Cannot read or decode the input stream. */ + yaml_READER_ERROR + /** Cannot scan the input stream. */ + yaml_SCANNER_ERROR + /** Cannot parse the input stream. */ + yaml_PARSER_ERROR + /** Cannot compose a YAML document. */ + yaml_COMPOSER_ERROR + + /** Cannot write to the output stream. */ + yaml_WRITER_ERROR + /** Cannot emit a YAML stream. */ + yaml_EMITTER_ERROR +) + +/** The pointer position. */ +type YAML_mark_t struct { + /** The position index. */ + index int + + /** The position line. */ + line int + + /** The position column. */ + column int +} + +func (m YAML_mark_t) String() string { + return fmt.Sprintf("line %d, column %d", m.line, m.column) +} + +/** @} */ + +/** + * @defgroup styles Node Styles + * @{ + */ + +type yaml_style_t int + +/** Scalar styles. */ +type yaml_scalar_style_t yaml_style_t + +const ( + /** Let the emitter choose the style. */ + yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = iota + + /** The plain scalar style. */ + yaml_PLAIN_SCALAR_STYLE + + /** The single-quoted scalar style. */ + yaml_SINGLE_QUOTED_SCALAR_STYLE + /** The double-quoted scalar style. */ + yaml_DOUBLE_QUOTED_SCALAR_STYLE + + /** The literal scalar style. */ + yaml_LITERAL_SCALAR_STYLE + /** The folded scalar style. */ + yaml_FOLDED_SCALAR_STYLE +) + +/** Sequence styles. */ +type yaml_sequence_style_t yaml_style_t + +const ( + /** Let the emitter choose the style. */ + yaml_ANY_SEQUENCE_STYLE yaml_sequence_style_t = iota + + /** The block sequence style. */ + yaml_BLOCK_SEQUENCE_STYLE + /** The flow sequence style. */ + yaml_FLOW_SEQUENCE_STYLE +) + +/** Mapping styles. */ +type yaml_mapping_style_t yaml_style_t + +const ( + /** Let the emitter choose the style. */ + yaml_ANY_MAPPING_STYLE yaml_mapping_style_t = iota + + /** The block mapping style. */ + yaml_BLOCK_MAPPING_STYLE + /** The flow mapping style. */ + yaml_FLOW_MAPPING_STYLE + +/* yaml_FLOW_SET_MAPPING_STYLE */ +) + +/** @} */ + +/** + * @defgroup tokens Tokens + * @{ + */ + +/** Token types. */ +type yaml_token_type_t int + +const ( + /** An empty token. */ + yaml_NO_TOKEN yaml_token_type_t = iota + + /** A STREAM-START token. */ + yaml_STREAM_START_TOKEN + /** A STREAM-END token. */ + yaml_STREAM_END_TOKEN + + /** A VERSION-DIRECTIVE token. */ + yaml_VERSION_DIRECTIVE_TOKEN + /** A TAG-DIRECTIVE token. */ + yaml_TAG_DIRECTIVE_TOKEN + /** A DOCUMENT-START token. */ + yaml_DOCUMENT_START_TOKEN + /** A DOCUMENT-END token. */ + yaml_DOCUMENT_END_TOKEN + + /** A BLOCK-SEQUENCE-START token. */ + yaml_BLOCK_SEQUENCE_START_TOKEN + /** A BLOCK-SEQUENCE-END token. */ + yaml_BLOCK_MAPPING_START_TOKEN + /** A BLOCK-END token. */ + yaml_BLOCK_END_TOKEN + + /** A FLOW-SEQUENCE-START token. */ + yaml_FLOW_SEQUENCE_START_TOKEN + /** A FLOW-SEQUENCE-END token. */ + yaml_FLOW_SEQUENCE_END_TOKEN + /** A FLOW-MAPPING-START token. */ + yaml_FLOW_MAPPING_START_TOKEN + /** A FLOW-MAPPING-END token. */ + yaml_FLOW_MAPPING_END_TOKEN + + /** A BLOCK-ENTRY token. */ + yaml_BLOCK_ENTRY_TOKEN + /** A FLOW-ENTRY token. */ + yaml_FLOW_ENTRY_TOKEN + /** A KEY token. */ + yaml_KEY_TOKEN + /** A VALUE token. */ + yaml_VALUE_TOKEN + + /** An ALIAS token. */ + yaml_ALIAS_TOKEN + /** An ANCHOR token. */ + yaml_ANCHOR_TOKEN + /** A TAG token. */ + yaml_TAG_TOKEN + /** A SCALAR token. */ + yaml_SCALAR_TOKEN +) + +/** The token structure. */ +type yaml_token_t struct { + + /** The token type. */ + token_type yaml_token_type_t + + /** The token data. */ + /** The stream start (for @c yaml_STREAM_START_TOKEN). */ + encoding yaml_encoding_t + + /** The alias (for @c yaml_ALIAS_TOKEN, yaml_ANCHOR_TOKEN, yaml_SCALAR_TOKEN,yaml_TAG_TOKEN ). */ + /** The anchor (for @c ). */ + /** The scalar value (for @c ). */ + value []byte + + /** The tag suffix. */ + suffix []byte + + /** The scalar value (for @c yaml_SCALAR_TOKEN). */ + /** The scalar style. */ + style yaml_scalar_style_t + + /** The version directive (for @c yaml_VERSION_DIRECTIVE_TOKEN). */ + version_directive yaml_version_directive_t + + /** The tag directive (for @c yaml_TAG_DIRECTIVE_TOKEN). */ + prefix []byte + + /** The beginning of the token. */ + start_mark YAML_mark_t + /** The end of the token. */ + end_mark YAML_mark_t + + major, minor int +} + +/** + * @defgroup events Events + * @{ + */ + +/** Event types. */ +type yaml_event_type_t int + +const ( + /** An empty event. */ + yaml_NO_EVENT yaml_event_type_t = iota + + /** A STREAM-START event. */ + yaml_STREAM_START_EVENT + /** A STREAM-END event. */ + yaml_STREAM_END_EVENT + + /** A DOCUMENT-START event. */ + yaml_DOCUMENT_START_EVENT + /** A DOCUMENT-END event. */ + yaml_DOCUMENT_END_EVENT + + /** An ALIAS event. */ + yaml_ALIAS_EVENT + /** A SCALAR event. */ + yaml_SCALAR_EVENT + + /** A SEQUENCE-START event. */ + yaml_SEQUENCE_START_EVENT + /** A SEQUENCE-END event. */ + yaml_SEQUENCE_END_EVENT + + /** A MAPPING-START event. */ + yaml_MAPPING_START_EVENT + /** A MAPPING-END event. */ + yaml_MAPPING_END_EVENT +) + +/** The event structure. */ +type yaml_event_t struct { + + /** The event type. */ + event_type yaml_event_type_t + + /** The stream parameters (for @c yaml_STREAM_START_EVENT). */ + encoding yaml_encoding_t + + /** The document parameters (for @c yaml_DOCUMENT_START_EVENT). */ + version_directive *yaml_version_directive_t + + /** The beginning and end of the tag directives list. */ + tag_directives []yaml_tag_directive_t + + /** The document parameters (for @c yaml_DOCUMENT_START_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_START_EVENT,yaml_MAPPING_START_EVENT). */ + /** Is the document indicator implicit? */ + implicit bool + + /** The alias parameters (for @c yaml_ALIAS_EVENT,yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT). */ + /** The anchor. */ + anchor []byte + + /** The scalar parameters (for @c yaml_SCALAR_EVENT,yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT). */ + /** The tag. */ + tag []byte + /** The scalar value. */ + value []byte + + /** Is the tag optional for the plain style? */ + plain_implicit bool + /** Is the tag optional for any non-plain style? */ + quoted_implicit bool + + /** The sequence parameters (for @c yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT). */ + /** The sequence style. */ + /** The scalar style. */ + style yaml_style_t + + /** The beginning of the event. */ + start_mark, end_mark YAML_mark_t +} + +/** + * @defgroup nodes Nodes + * @{ + */ + +const ( + /** The tag @c !!null with the only possible value: @c null. */ + yaml_NULL_TAG = "tag:yaml.org,2002:null" + /** The tag @c !!bool with the values: @c true and @c falce. */ + yaml_BOOL_TAG = "tag:yaml.org,2002:bool" + /** The tag @c !!str for string values. */ + yaml_STR_TAG = "tag:yaml.org,2002:str" + /** The tag @c !!int for integer values. */ + yaml_INT_TAG = "tag:yaml.org,2002:int" + /** The tag @c !!float for float values. */ + yaml_FLOAT_TAG = "tag:yaml.org,2002:float" + /** The tag @c !!timestamp for date and time values. */ + yaml_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp" + + /** The tag @c !!seq is used to denote sequences. */ + yaml_SEQ_TAG = "tag:yaml.org,2002:seq" + /** The tag @c !!map is used to denote mapping. */ + yaml_MAP_TAG = "tag:yaml.org,2002:map" + + /** The default scalar tag is @c !!str. */ + yaml_DEFAULT_SCALAR_TAG = yaml_STR_TAG + /** The default sequence tag is @c !!seq. */ + yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG + /** The default mapping tag is @c !!map. */ + yaml_DEFAULT_MAPPING_TAG = yaml_MAP_TAG + + yaml_BINARY_TAG = "tag:yaml.org,2002:binary" +) + +/** Node types. */ +type yaml_node_type_t int + +const ( + /** An empty node. */ + yaml_NO_NODE yaml_node_type_t = iota + + /** A scalar node. */ + yaml_SCALAR_NODE + /** A sequence node. */ + yaml_SEQUENCE_NODE + /** A mapping node. */ + yaml_MAPPING_NODE +) + +/** An element of a sequence node. */ +type yaml_node_item_t int + +/** An element of a mapping node. */ +type yaml_node_pair_t struct { + /** The key of the element. */ + key int + /** The value of the element. */ + value int +} + +/** The node structure. */ +type yaml_node_t struct { + + /** The node type. */ + node_type yaml_node_type_t + + /** The node tag. */ + tag []byte + + /** The scalar parameters (for @c yaml_SCALAR_NODE). */ + scalar struct { + /** The scalar value. */ + value []byte + /** The scalar style. */ + style yaml_scalar_style_t + } + + /** The sequence parameters (for @c yaml_SEQUENCE_NODE). */ + sequence struct { + /** The stack of sequence items. */ + items []yaml_node_item_t + /** The sequence style. */ + style yaml_sequence_style_t + } + + /** The mapping parameters (for @c yaml_MAPPING_NODE). */ + mapping struct { + /** The stack of mapping pairs (key, value). */ + pairs []yaml_node_pair_t + /** The mapping style. */ + style yaml_mapping_style_t + } + + /** The beginning of the node. */ + start_mark YAML_mark_t + /** The end of the node. */ + end_mark YAML_mark_t +} + +/** The document structure. */ +type yaml_document_t struct { + + /** The document nodes. */ + nodes []yaml_node_t + + /** The version directive. */ + version_directive *yaml_version_directive_t + + /** The list of tag directives. */ + tags []yaml_tag_directive_t + + /** Is the document start indicator implicit? */ + start_implicit bool + /** Is the document end indicator implicit? */ + end_implicit bool + + /** The beginning of the document. */ + start_mark YAML_mark_t + /** The end of the document. */ + end_mark YAML_mark_t +} + +/** + * The prototype of a read handler. + * + * The read handler is called when the parser needs to read more bytes from the + * source. The handler should write not more than @a size bytes to the @a + * buffer. The number of written bytes should be set to the @a length variable. + * + * @param[in,out] data A pointer to an application data specified by + * yaml_parser_set_input(). + * @param[out] buffer The buffer to write the data from the source. + * @param[in] size The size of the buffer. + * @param[out] size_read The actual number of bytes read from the source. + * + * @returns On success, the handler should return @c 1. If the handler failed, + * the returned value should be @c 0. On EOF, the handler should set the + * @a size_read to @c 0 and return @c 1. + */ + +type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error) + +/** + * This structure holds information about a potential simple key. + */ + +type yaml_simple_key_t struct { + /** Is a simple key possible? */ + possible bool + + /** Is a simple key required? */ + required bool + + /** The number of the token. */ + token_number int + + /** The position mark. */ + mark YAML_mark_t +} + +/** + * The states of the parser. + */ +type yaml_parser_state_t int + +const ( + /** Expect STREAM-START. */ + yaml_PARSE_STREAM_START_STATE yaml_parser_state_t = iota + /** Expect the beginning of an implicit document. */ + yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE + /** Expect DOCUMENT-START. */ + yaml_PARSE_DOCUMENT_START_STATE + /** Expect the content of a document. */ + yaml_PARSE_DOCUMENT_CONTENT_STATE + /** Expect DOCUMENT-END. */ + yaml_PARSE_DOCUMENT_END_STATE + /** Expect a block node. */ + yaml_PARSE_BLOCK_NODE_STATE + /** Expect a block node or indentless sequence. */ + yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE + /** Expect a flow node. */ + yaml_PARSE_FLOW_NODE_STATE + /** Expect the first entry of a block sequence. */ + yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE + /** Expect an entry of a block sequence. */ + yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE + /** Expect an entry of an indentless sequence. */ + yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE + /** Expect the first key of a block mapping. */ + yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE + /** Expect a block mapping key. */ + yaml_PARSE_BLOCK_MAPPING_KEY_STATE + /** Expect a block mapping value. */ + yaml_PARSE_BLOCK_MAPPING_VALUE_STATE + /** Expect the first entry of a flow sequence. */ + yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE + /** Expect an entry of a flow sequence. */ + yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE + /** Expect a key of an ordered mapping. */ + yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE + /** Expect a value of an ordered mapping. */ + yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE + /** Expect the and of an ordered mapping entry. */ + yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE + /** Expect the first key of a flow mapping. */ + yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE + /** Expect a key of a flow mapping. */ + yaml_PARSE_FLOW_MAPPING_KEY_STATE + /** Expect a value of a flow mapping. */ + yaml_PARSE_FLOW_MAPPING_VALUE_STATE + /** Expect an empty value of a flow mapping. */ + yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE + /** Expect nothing. */ + yaml_PARSE_END_STATE +) + +/** + * This structure holds aliases data. + */ + +type yaml_alias_data_t struct { + /** The anchor. */ + anchor []byte + /** The node id. */ + index int + /** The anchor mark. */ + mark YAML_mark_t +} + +/** + * The parser structure. + * + * All members are internal. Manage the structure using the @c yaml_parser_ + * family of functions. + */ + +type yaml_parser_t struct { + + /** + * @name Error handling + * @{ + */ + + /** Error type. */ + error YAML_error_type_t + /** Error description. */ + problem string + /** The byte about which the problem occured. */ + problem_offset int + /** The problematic value (@c -1 is none). */ + problem_value int + /** The problem position. */ + problem_mark YAML_mark_t + /** The error context. */ + context string + /** The context position. */ + context_mark YAML_mark_t + + /** + * @} + */ + + /** + * @name Reader stuff + * @{ + */ + + /** Read handler. */ + read_handler yaml_read_handler_t + + /** Reader input data. */ + input_reader io.Reader + input []byte + input_pos int + + /** EOF flag */ + eof bool + + /** The working buffer. */ + buffer []byte + buffer_pos int + + /* The number of unread characters in the buffer. */ + unread int + + /** The raw buffer. */ + raw_buffer []byte + raw_buffer_pos int + + /** The input encoding. */ + encoding yaml_encoding_t + + /** The offset of the current position (in bytes). */ + offset int + + /** The mark of the current position. */ + mark YAML_mark_t + + /** + * @} + */ + + /** + * @name Scanner stuff + * @{ + */ + + /** Have we started to scan the input stream? */ + stream_start_produced bool + + /** Have we reached the end of the input stream? */ + stream_end_produced bool + + /** The number of unclosed '[' and '{' indicators. */ + flow_level int + + /** The tokens queue. */ + tokens []yaml_token_t + tokens_head int + + /** The number of tokens fetched from the queue. */ + tokens_parsed int + + /* Does the tokens queue contain a token ready for dequeueing. */ + token_available bool + + /** The indentation levels stack. */ + indents []int + + /** The current indentation level. */ + indent int + + /** May a simple key occur at the current position? */ + simple_key_allowed bool + + /** The stack of simple keys. */ + simple_keys []yaml_simple_key_t + + /** + * @} + */ + + /** + * @name Parser stuff + * @{ + */ + + /** The parser states stack. */ + states []yaml_parser_state_t + + /** The current parser state. */ + state yaml_parser_state_t + + /** The stack of marks. */ + marks []YAML_mark_t + + /** The list of TAG directives. */ + tag_directives []yaml_tag_directive_t + + /** + * @} + */ + + /** + * @name Dumper stuff + * @{ + */ + + /** The alias data. */ + aliases []yaml_alias_data_t + + /** The currently parsed document. */ + document *yaml_document_t + + /** + * @} + */ + +} + +/** + * The prototype of a write handler. + * + * The write handler is called when the emitter needs to flush the accumulated + * characters to the output. The handler should write @a size bytes of the + * @a buffer to the output. + * + * @param[in,out] data A pointer to an application data specified by + * yaml_emitter_set_output(). + * @param[in] buffer The buffer with bytes to be written. + * @param[in] size The size of the buffer. + * + * @returns On success, the handler should return @c 1. If the handler failed, + * the returned value should be @c 0. + */ + +type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error + +/** The emitter states. */ +type yaml_emitter_state_t int + +const ( + /** Expect STREAM-START. */ + yaml_EMIT_STREAM_START_STATE yaml_emitter_state_t = iota + /** Expect the first DOCUMENT-START or STREAM-END. */ + yaml_EMIT_FIRST_DOCUMENT_START_STATE + /** Expect DOCUMENT-START or STREAM-END. */ + yaml_EMIT_DOCUMENT_START_STATE + /** Expect the content of a document. */ + yaml_EMIT_DOCUMENT_CONTENT_STATE + /** Expect DOCUMENT-END. */ + yaml_EMIT_DOCUMENT_END_STATE + /** Expect the first item of a flow sequence. */ + yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE + /** Expect an item of a flow sequence. */ + yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE + /** Expect the first key of a flow mapping. */ + yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE + /** Expect a key of a flow mapping. */ + yaml_EMIT_FLOW_MAPPING_KEY_STATE + /** Expect a value for a simple key of a flow mapping. */ + yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE + /** Expect a value of a flow mapping. */ + yaml_EMIT_FLOW_MAPPING_VALUE_STATE + /** Expect the first item of a block sequence. */ + yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE + /** Expect an item of a block sequence. */ + yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE + /** Expect the first key of a block mapping. */ + yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE + /** Expect the key of a block mapping. */ + yaml_EMIT_BLOCK_MAPPING_KEY_STATE + /** Expect a value for a simple key of a block mapping. */ + yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE + /** Expect a value of a block mapping. */ + yaml_EMIT_BLOCK_MAPPING_VALUE_STATE + /** Expect nothing. */ + yaml_EMIT_END_STATE +) + +/** + * The emitter structure. + * + * All members are internal. Manage the structure using the @c yaml_emitter_ + * family of functions. + */ + +type yaml_emitter_t struct { + + /** + * @name Error handling + * @{ + */ + + /** Error type. */ + error YAML_error_type_t + /** Error description. */ + problem string + + /** + * @} + */ + + /** + * @name Writer stuff + * @{ + */ + + /** Write handler. */ + write_handler yaml_write_handler_t + + /** Standard (string or file) output data. */ + output_buffer *[]byte + output_writer io.Writer + + /** The working buffer. */ + buffer []byte + buffer_pos int + + /** The raw buffer. */ + raw_buffer []byte + raw_buffer_pos int + + /** The stream encoding. */ + encoding yaml_encoding_t + + /** + * @} + */ + + /** + * @name Emitter stuff + * @{ + */ + + /** If the output is in the canonical style? */ + canonical bool + /** The number of indentation spaces. */ + best_indent int + /** The preferred width of the output lines. */ + best_width int + /** Allow unescaped non-ASCII characters? */ + unicode bool + /** The preferred line break. */ + line_break yaml_break_t + + /** The stack of states. */ + states []yaml_emitter_state_t + + /** The current emitter state. */ + state yaml_emitter_state_t + + /** The event queue. */ + events []yaml_event_t + events_head int + + /** The stack of indentation levels. */ + indents []int + + /** The list of tag directives. */ + tag_directives []yaml_tag_directive_t + + /** The current indentation level. */ + indent int + + /** The current flow level. */ + flow_level int + + /** Is it the document root context? */ + root_context bool + /** Is it a sequence context? */ + sequence_context bool + /** Is it a mapping context? */ + mapping_context bool + /** Is it a simple mapping key context? */ + simple_key_context bool + + /** The current line. */ + line int + /** The current column. */ + column int + /** If the last character was a whitespace? */ + whitespace bool + /** If the last character was an indentation character (' ', '-', '?', ':')? */ + indention bool + /** If an explicit document end is required? */ + open_ended bool + + /** Anchor analysis. */ + anchor_data struct { + /** The anchor value. */ + anchor []byte + /** Is it an alias? */ + alias bool + } + + /** Tag analysis. */ + tag_data struct { + /** The tag handle. */ + handle []byte + /** The tag suffix. */ + suffix []byte + } + + /** Scalar analysis. */ + scalar_data struct { + /** The scalar value. */ + value []byte + /** Does the scalar contain line breaks? */ + multiline bool + /** Can the scalar be expessed in the flow plain style? */ + flow_plain_allowed bool + /** Can the scalar be expressed in the block plain style? */ + block_plain_allowed bool + /** Can the scalar be expressed in the single quoted style? */ + single_quoted_allowed bool + /** Can the scalar be expressed in the literal or folded styles? */ + block_allowed bool + /** The output style. */ + style yaml_scalar_style_t + } + + /** + * @} + */ + + /** + * @name Dumper stuff + * @{ + */ + + /** If the stream was already opened? */ + opened bool + /** If the stream was already closed? */ + closed bool + + /** The information associated with the document nodes. */ + anchors *struct { + /** The number of references. */ + references int + /** The anchor id. */ + anchor int + /** If the node has been emitted? */ + serialized bool + } + + /** The last assigned anchor id. */ + last_anchor_id int + + /** The currently emitted document. */ + document *yaml_document_t + + /** + * @} + */ + +} diff --git a/vendor/github.com/coreos/etcd/LICENSE b/vendor/github.com/coreos/etcd/LICENSE new file mode 100644 index 00000000..d6456956 --- /dev/null +++ b/vendor/github.com/coreos/etcd/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/coreos/etcd/NOTICE b/vendor/github.com/coreos/etcd/NOTICE new file mode 100644 index 00000000..b39ddfa5 --- /dev/null +++ b/vendor/github.com/coreos/etcd/NOTICE @@ -0,0 +1,5 @@ +CoreOS Project +Copyright 2014 CoreOS, Inc + +This product includes software developed at CoreOS, Inc. +(http://www.coreos.com/). diff --git a/vendor/github.com/coreos/etcd/auth/authpb/auth.pb.go b/vendor/github.com/coreos/etcd/auth/authpb/auth.pb.go new file mode 100644 index 00000000..448e1eaa --- /dev/null +++ b/vendor/github.com/coreos/etcd/auth/authpb/auth.pb.go @@ -0,0 +1,820 @@ +// Code generated by protoc-gen-gogo. +// source: auth.proto +// DO NOT EDIT! + +/* + Package authpb is a generated protocol buffer package. + + It is generated from these files: + auth.proto + + It has these top-level messages: + User + Permission + Role +*/ +package authpb + +import ( + "fmt" + + proto "github.com/golang/protobuf/proto" + + math "math" +) + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +const _ = proto.ProtoPackageIsVersion1 + +type Permission_Type int32 + +const ( + READ Permission_Type = 0 + WRITE Permission_Type = 1 + READWRITE Permission_Type = 2 +) + +var Permission_Type_name = map[int32]string{ + 0: "READ", + 1: "WRITE", + 2: "READWRITE", +} +var Permission_Type_value = map[string]int32{ + "READ": 0, + "WRITE": 1, + "READWRITE": 2, +} + +func (x Permission_Type) String() string { + return proto.EnumName(Permission_Type_name, int32(x)) +} +func (Permission_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorAuth, []int{1, 0} } + +// User is a single entry in the bucket authUsers +type User struct { + Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Password []byte `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"` + Roles []string `protobuf:"bytes,3,rep,name=roles" json:"roles,omitempty"` +} + +func (m *User) Reset() { *m = User{} } +func (m *User) String() string { return proto.CompactTextString(m) } +func (*User) ProtoMessage() {} +func (*User) Descriptor() ([]byte, []int) { return fileDescriptorAuth, []int{0} } + +// Permission is a single entity +type Permission struct { + PermType Permission_Type `protobuf:"varint,1,opt,name=permType,proto3,enum=authpb.Permission_Type" json:"permType,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + RangeEnd []byte `protobuf:"bytes,3,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"` +} + +func (m *Permission) Reset() { *m = Permission{} } +func (m *Permission) String() string { return proto.CompactTextString(m) } +func (*Permission) ProtoMessage() {} +func (*Permission) Descriptor() ([]byte, []int) { return fileDescriptorAuth, []int{1} } + +// Role is a single entry in the bucket authRoles +type Role struct { + Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + KeyPermission []*Permission `protobuf:"bytes,2,rep,name=keyPermission" json:"keyPermission,omitempty"` +} + +func (m *Role) Reset() { *m = Role{} } +func (m *Role) String() string { return proto.CompactTextString(m) } +func (*Role) ProtoMessage() {} +func (*Role) Descriptor() ([]byte, []int) { return fileDescriptorAuth, []int{2} } + +func init() { + proto.RegisterType((*User)(nil), "authpb.User") + proto.RegisterType((*Permission)(nil), "authpb.Permission") + proto.RegisterType((*Role)(nil), "authpb.Role") + proto.RegisterEnum("authpb.Permission_Type", Permission_Type_name, Permission_Type_value) +} +func (m *User) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *User) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintAuth(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if len(m.Password) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintAuth(data, i, uint64(len(m.Password))) + i += copy(data[i:], m.Password) + } + if len(m.Roles) > 0 { + for _, s := range m.Roles { + data[i] = 0x1a + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + return i, nil +} + +func (m *Permission) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Permission) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.PermType != 0 { + data[i] = 0x8 + i++ + i = encodeVarintAuth(data, i, uint64(m.PermType)) + } + if len(m.Key) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintAuth(data, i, uint64(len(m.Key))) + i += copy(data[i:], m.Key) + } + if len(m.RangeEnd) > 0 { + data[i] = 0x1a + i++ + i = encodeVarintAuth(data, i, uint64(len(m.RangeEnd))) + i += copy(data[i:], m.RangeEnd) + } + return i, nil +} + +func (m *Role) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Role) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintAuth(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if len(m.KeyPermission) > 0 { + for _, msg := range m.KeyPermission { + data[i] = 0x12 + i++ + i = encodeVarintAuth(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func encodeFixed64Auth(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Auth(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintAuth(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *User) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovAuth(uint64(l)) + } + l = len(m.Password) + if l > 0 { + n += 1 + l + sovAuth(uint64(l)) + } + if len(m.Roles) > 0 { + for _, s := range m.Roles { + l = len(s) + n += 1 + l + sovAuth(uint64(l)) + } + } + return n +} + +func (m *Permission) Size() (n int) { + var l int + _ = l + if m.PermType != 0 { + n += 1 + sovAuth(uint64(m.PermType)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovAuth(uint64(l)) + } + l = len(m.RangeEnd) + if l > 0 { + n += 1 + l + sovAuth(uint64(l)) + } + return n +} + +func (m *Role) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovAuth(uint64(l)) + } + if len(m.KeyPermission) > 0 { + for _, e := range m.KeyPermission { + l = e.Size() + n += 1 + l + sovAuth(uint64(l)) + } + } + return n +} + +func sovAuth(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozAuth(x uint64) (n int) { + return sovAuth(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *User) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: User: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: User: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthAuth + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = append(m.Name[:0], data[iNdEx:postIndex]...) + if m.Name == nil { + m.Name = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthAuth + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Password = append(m.Password[:0], data[iNdEx:postIndex]...) + if m.Password == nil { + m.Password = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthAuth + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Roles = append(m.Roles, string(data[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuth(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthAuth + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Permission) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Permission: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Permission: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PermType", wireType) + } + m.PermType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.PermType |= (Permission_Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthAuth + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], data[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthAuth + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RangeEnd = append(m.RangeEnd[:0], data[iNdEx:postIndex]...) + if m.RangeEnd == nil { + m.RangeEnd = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuth(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthAuth + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Role) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Role: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Role: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthAuth + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = append(m.Name[:0], data[iNdEx:postIndex]...) + if m.Name == nil { + m.Name = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KeyPermission", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuth + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuth + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.KeyPermission = append(m.KeyPermission, &Permission{}) + if err := m.KeyPermission[len(m.KeyPermission)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuth(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthAuth + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipAuth(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowAuth + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowAuth + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowAuth + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthAuth + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowAuth + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipAuth(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthAuth = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowAuth = fmt.Errorf("proto: integer overflow") +) + +var fileDescriptorAuth = []byte{ + // 288 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4a, 0xc3, 0x30, + 0x1c, 0xc6, 0x9b, 0xb6, 0x1b, 0xed, 0x5f, 0x27, 0x25, 0x0c, 0x0c, 0x13, 0x42, 0xe9, 0xa9, 0x78, + 0xa8, 0xb0, 0x5d, 0xbc, 0x2a, 0xf6, 0x20, 0x78, 0x90, 0x50, 0xf1, 0x28, 0x1d, 0x0d, 0x75, 0x6c, + 0x6d, 0x4a, 0x32, 0x91, 0xbe, 0x89, 0x07, 0x1f, 0x68, 0xc7, 0x3d, 0x82, 0xab, 0x2f, 0x22, 0x4d, + 0x64, 0x43, 0xdc, 0xed, 0xfb, 0xbe, 0xff, 0x97, 0xe4, 0x97, 0x3f, 0x40, 0xfe, 0xb6, 0x7e, 0x4d, + 0x1a, 0x29, 0xd6, 0x02, 0x0f, 0x7b, 0xdd, 0xcc, 0x27, 0xe3, 0x52, 0x94, 0x42, 0x47, 0x57, 0xbd, + 0x32, 0xd3, 0xe8, 0x01, 0xdc, 0x27, 0xc5, 0x25, 0xc6, 0xe0, 0xd6, 0x79, 0xc5, 0x09, 0x0a, 0x51, + 0x7c, 0xca, 0xb4, 0xc6, 0x13, 0xf0, 0x9a, 0x5c, 0xa9, 0x77, 0x21, 0x0b, 0x62, 0xeb, 0x7c, 0xef, + 0xf1, 0x18, 0x06, 0x52, 0xac, 0xb8, 0x22, 0x4e, 0xe8, 0xc4, 0x3e, 0x33, 0x26, 0xfa, 0x44, 0x00, + 0x8f, 0x5c, 0x56, 0x0b, 0xa5, 0x16, 0xa2, 0xc6, 0x33, 0xf0, 0x1a, 0x2e, 0xab, 0xac, 0x6d, 0xcc, + 0xc5, 0x67, 0xd3, 0xf3, 0xc4, 0xd0, 0x24, 0x87, 0x56, 0xd2, 0x8f, 0xd9, 0xbe, 0x88, 0x03, 0x70, + 0x96, 0xbc, 0xfd, 0x7d, 0xb0, 0x97, 0xf8, 0x02, 0x7c, 0x99, 0xd7, 0x25, 0x7f, 0xe1, 0x75, 0x41, + 0x1c, 0x03, 0xa2, 0x83, 0xb4, 0x2e, 0xa2, 0x4b, 0x70, 0xf5, 0x31, 0x0f, 0x5c, 0x96, 0xde, 0xdc, + 0x05, 0x16, 0xf6, 0x61, 0xf0, 0xcc, 0xee, 0xb3, 0x34, 0x40, 0x78, 0x04, 0x7e, 0x1f, 0x1a, 0x6b, + 0x47, 0x19, 0xb8, 0x4c, 0xac, 0xf8, 0xd1, 0xcf, 0x5e, 0xc3, 0x68, 0xc9, 0xdb, 0x03, 0x16, 0xb1, + 0x43, 0x27, 0x3e, 0x99, 0xe2, 0xff, 0xc0, 0xec, 0x6f, 0xf1, 0x96, 0x6c, 0x76, 0xd4, 0xda, 0xee, + 0xa8, 0xb5, 0xe9, 0x28, 0xda, 0x76, 0x14, 0x7d, 0x75, 0x14, 0x7d, 0x7c, 0x53, 0x6b, 0x3e, 0xd4, + 0x3b, 0x9e, 0xfd, 0x04, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x76, 0x8d, 0x4f, 0x8f, 0x01, 0x00, 0x00, +} diff --git a/vendor/github.com/coreos/etcd/client/auth_role.go b/vendor/github.com/coreos/etcd/client/auth_role.go new file mode 100644 index 00000000..d15e00dd --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/auth_role.go @@ -0,0 +1,237 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "bytes" + "encoding/json" + "net/http" + "net/url" + + "golang.org/x/net/context" +) + +type Role struct { + Role string `json:"role"` + Permissions Permissions `json:"permissions"` + Grant *Permissions `json:"grant,omitempty"` + Revoke *Permissions `json:"revoke,omitempty"` +} + +type Permissions struct { + KV rwPermission `json:"kv"` +} + +type rwPermission struct { + Read []string `json:"read"` + Write []string `json:"write"` +} + +type PermissionType int + +const ( + ReadPermission PermissionType = iota + WritePermission + ReadWritePermission +) + +// NewAuthRoleAPI constructs a new AuthRoleAPI that uses HTTP to +// interact with etcd's role creation and modification features. +func NewAuthRoleAPI(c Client) AuthRoleAPI { + return &httpAuthRoleAPI{ + client: c, + } +} + +type AuthRoleAPI interface { + // AddRole adds a role. + AddRole(ctx context.Context, role string) error + + // RemoveRole removes a role. + RemoveRole(ctx context.Context, role string) error + + // GetRole retrieves role details. + GetRole(ctx context.Context, role string) (*Role, error) + + // GrantRoleKV grants a role some permission prefixes for the KV store. + GrantRoleKV(ctx context.Context, role string, prefixes []string, permType PermissionType) (*Role, error) + + // RevokeRoleKV revokes some permission prefixes for a role on the KV store. + RevokeRoleKV(ctx context.Context, role string, prefixes []string, permType PermissionType) (*Role, error) + + // ListRoles lists roles. + ListRoles(ctx context.Context) ([]string, error) +} + +type httpAuthRoleAPI struct { + client httpClient +} + +type authRoleAPIAction struct { + verb string + name string + role *Role +} + +type authRoleAPIList struct{} + +func (list *authRoleAPIList) HTTPRequest(ep url.URL) *http.Request { + u := v2AuthURL(ep, "roles", "") + req, _ := http.NewRequest("GET", u.String(), nil) + req.Header.Set("Content-Type", "application/json") + return req +} + +func (l *authRoleAPIAction) HTTPRequest(ep url.URL) *http.Request { + u := v2AuthURL(ep, "roles", l.name) + if l.role == nil { + req, _ := http.NewRequest(l.verb, u.String(), nil) + return req + } + b, err := json.Marshal(l.role) + if err != nil { + panic(err) + } + body := bytes.NewReader(b) + req, _ := http.NewRequest(l.verb, u.String(), body) + req.Header.Set("Content-Type", "application/json") + return req +} + +func (r *httpAuthRoleAPI) ListRoles(ctx context.Context) ([]string, error) { + resp, body, err := r.client.Do(ctx, &authRoleAPIList{}) + if err != nil { + return nil, err + } + if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil { + return nil, err + } + var roleList struct { + Roles []Role `json:"roles"` + } + if err = json.Unmarshal(body, &roleList); err != nil { + return nil, err + } + ret := make([]string, 0, len(roleList.Roles)) + for _, r := range roleList.Roles { + ret = append(ret, r.Role) + } + return ret, nil +} + +func (r *httpAuthRoleAPI) AddRole(ctx context.Context, rolename string) error { + role := &Role{ + Role: rolename, + } + return r.addRemoveRole(ctx, &authRoleAPIAction{ + verb: "PUT", + name: rolename, + role: role, + }) +} + +func (r *httpAuthRoleAPI) RemoveRole(ctx context.Context, rolename string) error { + return r.addRemoveRole(ctx, &authRoleAPIAction{ + verb: "DELETE", + name: rolename, + }) +} + +func (r *httpAuthRoleAPI) addRemoveRole(ctx context.Context, req *authRoleAPIAction) error { + resp, body, err := r.client.Do(ctx, req) + if err != nil { + return err + } + if err := assertStatusCode(resp.StatusCode, http.StatusOK, http.StatusCreated); err != nil { + var sec authError + err := json.Unmarshal(body, &sec) + if err != nil { + return err + } + return sec + } + return nil +} + +func (r *httpAuthRoleAPI) GetRole(ctx context.Context, rolename string) (*Role, error) { + return r.modRole(ctx, &authRoleAPIAction{ + verb: "GET", + name: rolename, + }) +} + +func buildRWPermission(prefixes []string, permType PermissionType) rwPermission { + var out rwPermission + switch permType { + case ReadPermission: + out.Read = prefixes + case WritePermission: + out.Write = prefixes + case ReadWritePermission: + out.Read = prefixes + out.Write = prefixes + } + return out +} + +func (r *httpAuthRoleAPI) GrantRoleKV(ctx context.Context, rolename string, prefixes []string, permType PermissionType) (*Role, error) { + rwp := buildRWPermission(prefixes, permType) + role := &Role{ + Role: rolename, + Grant: &Permissions{ + KV: rwp, + }, + } + return r.modRole(ctx, &authRoleAPIAction{ + verb: "PUT", + name: rolename, + role: role, + }) +} + +func (r *httpAuthRoleAPI) RevokeRoleKV(ctx context.Context, rolename string, prefixes []string, permType PermissionType) (*Role, error) { + rwp := buildRWPermission(prefixes, permType) + role := &Role{ + Role: rolename, + Revoke: &Permissions{ + KV: rwp, + }, + } + return r.modRole(ctx, &authRoleAPIAction{ + verb: "PUT", + name: rolename, + role: role, + }) +} + +func (r *httpAuthRoleAPI) modRole(ctx context.Context, req *authRoleAPIAction) (*Role, error) { + resp, body, err := r.client.Do(ctx, req) + if err != nil { + return nil, err + } + if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil { + var sec authError + err = json.Unmarshal(body, &sec) + if err != nil { + return nil, err + } + return nil, sec + } + var role Role + if err = json.Unmarshal(body, &role); err != nil { + return nil, err + } + return &role, nil +} diff --git a/vendor/github.com/coreos/etcd/client/auth_user.go b/vendor/github.com/coreos/etcd/client/auth_user.go new file mode 100644 index 00000000..97c3f318 --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/auth_user.go @@ -0,0 +1,320 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "bytes" + "encoding/json" + "net/http" + "net/url" + "path" + + "golang.org/x/net/context" +) + +var ( + defaultV2AuthPrefix = "/v2/auth" +) + +type User struct { + User string `json:"user"` + Password string `json:"password,omitempty"` + Roles []string `json:"roles"` + Grant []string `json:"grant,omitempty"` + Revoke []string `json:"revoke,omitempty"` +} + +// userListEntry is the user representation given by the server for ListUsers +type userListEntry struct { + User string `json:"user"` + Roles []Role `json:"roles"` +} + +type UserRoles struct { + User string `json:"user"` + Roles []Role `json:"roles"` +} + +func v2AuthURL(ep url.URL, action string, name string) *url.URL { + if name != "" { + ep.Path = path.Join(ep.Path, defaultV2AuthPrefix, action, name) + return &ep + } + ep.Path = path.Join(ep.Path, defaultV2AuthPrefix, action) + return &ep +} + +// NewAuthAPI constructs a new AuthAPI that uses HTTP to +// interact with etcd's general auth features. +func NewAuthAPI(c Client) AuthAPI { + return &httpAuthAPI{ + client: c, + } +} + +type AuthAPI interface { + // Enable auth. + Enable(ctx context.Context) error + + // Disable auth. + Disable(ctx context.Context) error +} + +type httpAuthAPI struct { + client httpClient +} + +func (s *httpAuthAPI) Enable(ctx context.Context) error { + return s.enableDisable(ctx, &authAPIAction{"PUT"}) +} + +func (s *httpAuthAPI) Disable(ctx context.Context) error { + return s.enableDisable(ctx, &authAPIAction{"DELETE"}) +} + +func (s *httpAuthAPI) enableDisable(ctx context.Context, req httpAction) error { + resp, body, err := s.client.Do(ctx, req) + if err != nil { + return err + } + if err = assertStatusCode(resp.StatusCode, http.StatusOK, http.StatusCreated); err != nil { + var sec authError + err = json.Unmarshal(body, &sec) + if err != nil { + return err + } + return sec + } + return nil +} + +type authAPIAction struct { + verb string +} + +func (l *authAPIAction) HTTPRequest(ep url.URL) *http.Request { + u := v2AuthURL(ep, "enable", "") + req, _ := http.NewRequest(l.verb, u.String(), nil) + return req +} + +type authError struct { + Message string `json:"message"` + Code int `json:"-"` +} + +func (e authError) Error() string { + return e.Message +} + +// NewAuthUserAPI constructs a new AuthUserAPI that uses HTTP to +// interact with etcd's user creation and modification features. +func NewAuthUserAPI(c Client) AuthUserAPI { + return &httpAuthUserAPI{ + client: c, + } +} + +type AuthUserAPI interface { + // AddUser adds a user. + AddUser(ctx context.Context, username string, password string) error + + // RemoveUser removes a user. + RemoveUser(ctx context.Context, username string) error + + // GetUser retrieves user details. + GetUser(ctx context.Context, username string) (*User, error) + + // GrantUser grants a user some permission roles. + GrantUser(ctx context.Context, username string, roles []string) (*User, error) + + // RevokeUser revokes some permission roles from a user. + RevokeUser(ctx context.Context, username string, roles []string) (*User, error) + + // ChangePassword changes the user's password. + ChangePassword(ctx context.Context, username string, password string) (*User, error) + + // ListUsers lists the users. + ListUsers(ctx context.Context) ([]string, error) +} + +type httpAuthUserAPI struct { + client httpClient +} + +type authUserAPIAction struct { + verb string + username string + user *User +} + +type authUserAPIList struct{} + +func (list *authUserAPIList) HTTPRequest(ep url.URL) *http.Request { + u := v2AuthURL(ep, "users", "") + req, _ := http.NewRequest("GET", u.String(), nil) + req.Header.Set("Content-Type", "application/json") + return req +} + +func (l *authUserAPIAction) HTTPRequest(ep url.URL) *http.Request { + u := v2AuthURL(ep, "users", l.username) + if l.user == nil { + req, _ := http.NewRequest(l.verb, u.String(), nil) + return req + } + b, err := json.Marshal(l.user) + if err != nil { + panic(err) + } + body := bytes.NewReader(b) + req, _ := http.NewRequest(l.verb, u.String(), body) + req.Header.Set("Content-Type", "application/json") + return req +} + +func (u *httpAuthUserAPI) ListUsers(ctx context.Context) ([]string, error) { + resp, body, err := u.client.Do(ctx, &authUserAPIList{}) + if err != nil { + return nil, err + } + if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil { + var sec authError + err = json.Unmarshal(body, &sec) + if err != nil { + return nil, err + } + return nil, sec + } + + var userList struct { + Users []userListEntry `json:"users"` + } + + if err = json.Unmarshal(body, &userList); err != nil { + return nil, err + } + + ret := make([]string, 0, len(userList.Users)) + for _, u := range userList.Users { + ret = append(ret, u.User) + } + return ret, nil +} + +func (u *httpAuthUserAPI) AddUser(ctx context.Context, username string, password string) error { + user := &User{ + User: username, + Password: password, + } + return u.addRemoveUser(ctx, &authUserAPIAction{ + verb: "PUT", + username: username, + user: user, + }) +} + +func (u *httpAuthUserAPI) RemoveUser(ctx context.Context, username string) error { + return u.addRemoveUser(ctx, &authUserAPIAction{ + verb: "DELETE", + username: username, + }) +} + +func (u *httpAuthUserAPI) addRemoveUser(ctx context.Context, req *authUserAPIAction) error { + resp, body, err := u.client.Do(ctx, req) + if err != nil { + return err + } + if err = assertStatusCode(resp.StatusCode, http.StatusOK, http.StatusCreated); err != nil { + var sec authError + err = json.Unmarshal(body, &sec) + if err != nil { + return err + } + return sec + } + return nil +} + +func (u *httpAuthUserAPI) GetUser(ctx context.Context, username string) (*User, error) { + return u.modUser(ctx, &authUserAPIAction{ + verb: "GET", + username: username, + }) +} + +func (u *httpAuthUserAPI) GrantUser(ctx context.Context, username string, roles []string) (*User, error) { + user := &User{ + User: username, + Grant: roles, + } + return u.modUser(ctx, &authUserAPIAction{ + verb: "PUT", + username: username, + user: user, + }) +} + +func (u *httpAuthUserAPI) RevokeUser(ctx context.Context, username string, roles []string) (*User, error) { + user := &User{ + User: username, + Revoke: roles, + } + return u.modUser(ctx, &authUserAPIAction{ + verb: "PUT", + username: username, + user: user, + }) +} + +func (u *httpAuthUserAPI) ChangePassword(ctx context.Context, username string, password string) (*User, error) { + user := &User{ + User: username, + Password: password, + } + return u.modUser(ctx, &authUserAPIAction{ + verb: "PUT", + username: username, + user: user, + }) +} + +func (u *httpAuthUserAPI) modUser(ctx context.Context, req *authUserAPIAction) (*User, error) { + resp, body, err := u.client.Do(ctx, req) + if err != nil { + return nil, err + } + if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil { + var sec authError + err = json.Unmarshal(body, &sec) + if err != nil { + return nil, err + } + return nil, sec + } + var user User + if err = json.Unmarshal(body, &user); err != nil { + var userR UserRoles + if urerr := json.Unmarshal(body, &userR); urerr != nil { + return nil, err + } + user.User = userR.User + for _, r := range userR.Roles { + user.Roles = append(user.Roles, r.Role) + } + } + return &user, nil +} diff --git a/vendor/github.com/coreos/etcd/client/cancelreq.go b/vendor/github.com/coreos/etcd/client/cancelreq.go new file mode 100644 index 00000000..76d1f040 --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/cancelreq.go @@ -0,0 +1,18 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// borrowed from golang/net/context/ctxhttp/cancelreq.go + +package client + +import "net/http" + +func requestCanceler(tr CancelableTransport, req *http.Request) func() { + ch := make(chan struct{}) + req.Cancel = ch + + return func() { + close(ch) + } +} diff --git a/vendor/github.com/coreos/etcd/client/client.go b/vendor/github.com/coreos/etcd/client/client.go new file mode 100644 index 00000000..4c4d41eb --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/client.go @@ -0,0 +1,609 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "errors" + "fmt" + "io/ioutil" + "math/rand" + "net" + "net/http" + "net/url" + "reflect" + "sort" + "strconv" + "sync" + "time" + + "golang.org/x/net/context" +) + +var ( + ErrNoEndpoints = errors.New("client: no endpoints available") + ErrTooManyRedirects = errors.New("client: too many redirects") + ErrClusterUnavailable = errors.New("client: etcd cluster is unavailable or misconfigured") + ErrNoLeaderEndpoint = errors.New("client: no leader endpoint available") + errTooManyRedirectChecks = errors.New("client: too many redirect checks") + + // oneShotCtxValue is set on a context using WithValue(&oneShotValue) so + // that Do() will not retry a request + oneShotCtxValue interface{} +) + +var DefaultRequestTimeout = 5 * time.Second + +var DefaultTransport CancelableTransport = &http.Transport{ + Proxy: http.ProxyFromEnvironment, + Dial: (&net.Dialer{ + Timeout: 30 * time.Second, + KeepAlive: 30 * time.Second, + }).Dial, + TLSHandshakeTimeout: 10 * time.Second, +} + +type EndpointSelectionMode int + +const ( + // EndpointSelectionRandom is the default value of the 'SelectionMode'. + // As the name implies, the client object will pick a node from the members + // of the cluster in a random fashion. If the cluster has three members, A, B, + // and C, the client picks any node from its three members as its request + // destination. + EndpointSelectionRandom EndpointSelectionMode = iota + + // If 'SelectionMode' is set to 'EndpointSelectionPrioritizeLeader', + // requests are sent directly to the cluster leader. This reduces + // forwarding roundtrips compared to making requests to etcd followers + // who then forward them to the cluster leader. In the event of a leader + // failure, however, clients configured this way cannot prioritize among + // the remaining etcd followers. Therefore, when a client sets 'SelectionMode' + // to 'EndpointSelectionPrioritizeLeader', it must use 'client.AutoSync()' to + // maintain its knowledge of current cluster state. + // + // This mode should be used with Client.AutoSync(). + EndpointSelectionPrioritizeLeader +) + +type Config struct { + // Endpoints defines a set of URLs (schemes, hosts and ports only) + // that can be used to communicate with a logical etcd cluster. For + // example, a three-node cluster could be provided like so: + // + // Endpoints: []string{ + // "http://node1.example.com:2379", + // "http://node2.example.com:2379", + // "http://node3.example.com:2379", + // } + // + // If multiple endpoints are provided, the Client will attempt to + // use them all in the event that one or more of them are unusable. + // + // If Client.Sync is ever called, the Client may cache an alternate + // set of endpoints to continue operation. + Endpoints []string + + // Transport is used by the Client to drive HTTP requests. If not + // provided, DefaultTransport will be used. + Transport CancelableTransport + + // CheckRedirect specifies the policy for handling HTTP redirects. + // If CheckRedirect is not nil, the Client calls it before + // following an HTTP redirect. The sole argument is the number of + // requests that have already been made. If CheckRedirect returns + // an error, Client.Do will not make any further requests and return + // the error back it to the caller. + // + // If CheckRedirect is nil, the Client uses its default policy, + // which is to stop after 10 consecutive requests. + CheckRedirect CheckRedirectFunc + + // Username specifies the user credential to add as an authorization header + Username string + + // Password is the password for the specified user to add as an authorization header + // to the request. + Password string + + // HeaderTimeoutPerRequest specifies the time limit to wait for response + // header in a single request made by the Client. The timeout includes + // connection time, any redirects, and header wait time. + // + // For non-watch GET request, server returns the response body immediately. + // For PUT/POST/DELETE request, server will attempt to commit request + // before responding, which is expected to take `100ms + 2 * RTT`. + // For watch request, server returns the header immediately to notify Client + // watch start. But if server is behind some kind of proxy, the response + // header may be cached at proxy, and Client cannot rely on this behavior. + // + // Especially, wait request will ignore this timeout. + // + // One API call may send multiple requests to different etcd servers until it + // succeeds. Use context of the API to specify the overall timeout. + // + // A HeaderTimeoutPerRequest of zero means no timeout. + HeaderTimeoutPerRequest time.Duration + + // SelectionMode is an EndpointSelectionMode enum that specifies the + // policy for choosing the etcd cluster node to which requests are sent. + SelectionMode EndpointSelectionMode +} + +func (cfg *Config) transport() CancelableTransport { + if cfg.Transport == nil { + return DefaultTransport + } + return cfg.Transport +} + +func (cfg *Config) checkRedirect() CheckRedirectFunc { + if cfg.CheckRedirect == nil { + return DefaultCheckRedirect + } + return cfg.CheckRedirect +} + +// CancelableTransport mimics net/http.Transport, but requires that +// the object also support request cancellation. +type CancelableTransport interface { + http.RoundTripper + CancelRequest(req *http.Request) +} + +type CheckRedirectFunc func(via int) error + +// DefaultCheckRedirect follows up to 10 redirects, but no more. +var DefaultCheckRedirect CheckRedirectFunc = func(via int) error { + if via > 10 { + return ErrTooManyRedirects + } + return nil +} + +type Client interface { + // Sync updates the internal cache of the etcd cluster's membership. + Sync(context.Context) error + + // AutoSync periodically calls Sync() every given interval. + // The recommended sync interval is 10 seconds to 1 minute, which does + // not bring too much overhead to server and makes client catch up the + // cluster change in time. + // + // The example to use it: + // + // for { + // err := client.AutoSync(ctx, 10*time.Second) + // if err == context.DeadlineExceeded || err == context.Canceled { + // break + // } + // log.Print(err) + // } + AutoSync(context.Context, time.Duration) error + + // Endpoints returns a copy of the current set of API endpoints used + // by Client to resolve HTTP requests. If Sync has ever been called, + // this may differ from the initial Endpoints provided in the Config. + Endpoints() []string + + // SetEndpoints sets the set of API endpoints used by Client to resolve + // HTTP requests. If the given endpoints are not valid, an error will be + // returned + SetEndpoints(eps []string) error + + httpClient +} + +func New(cfg Config) (Client, error) { + c := &httpClusterClient{ + clientFactory: newHTTPClientFactory(cfg.transport(), cfg.checkRedirect(), cfg.HeaderTimeoutPerRequest), + rand: rand.New(rand.NewSource(int64(time.Now().Nanosecond()))), + selectionMode: cfg.SelectionMode, + } + if cfg.Username != "" { + c.credentials = &credentials{ + username: cfg.Username, + password: cfg.Password, + } + } + if err := c.SetEndpoints(cfg.Endpoints); err != nil { + return nil, err + } + return c, nil +} + +type httpClient interface { + Do(context.Context, httpAction) (*http.Response, []byte, error) +} + +func newHTTPClientFactory(tr CancelableTransport, cr CheckRedirectFunc, headerTimeout time.Duration) httpClientFactory { + return func(ep url.URL) httpClient { + return &redirectFollowingHTTPClient{ + checkRedirect: cr, + client: &simpleHTTPClient{ + transport: tr, + endpoint: ep, + headerTimeout: headerTimeout, + }, + } + } +} + +type credentials struct { + username string + password string +} + +type httpClientFactory func(url.URL) httpClient + +type httpAction interface { + HTTPRequest(url.URL) *http.Request +} + +type httpClusterClient struct { + clientFactory httpClientFactory + endpoints []url.URL + pinned int + credentials *credentials + sync.RWMutex + rand *rand.Rand + selectionMode EndpointSelectionMode +} + +func (c *httpClusterClient) getLeaderEndpoint() (string, error) { + mAPI := NewMembersAPI(c) + leader, err := mAPI.Leader(context.Background()) + if err != nil { + return "", err + } + + return leader.ClientURLs[0], nil // TODO: how to handle multiple client URLs? +} + +func (c *httpClusterClient) SetEndpoints(eps []string) error { + if len(eps) == 0 { + return ErrNoEndpoints + } + + neps := make([]url.URL, len(eps)) + for i, ep := range eps { + u, err := url.Parse(ep) + if err != nil { + return err + } + neps[i] = *u + } + + switch c.selectionMode { + case EndpointSelectionRandom: + c.endpoints = shuffleEndpoints(c.rand, neps) + c.pinned = 0 + case EndpointSelectionPrioritizeLeader: + c.endpoints = neps + lep, err := c.getLeaderEndpoint() + if err != nil { + return ErrNoLeaderEndpoint + } + + for i := range c.endpoints { + if c.endpoints[i].String() == lep { + c.pinned = i + break + } + } + // If endpoints doesn't have the lu, just keep c.pinned = 0. + // Forwarding between follower and leader would be required but it works. + default: + return fmt.Errorf("invalid endpoint selection mode: %d", c.selectionMode) + } + + return nil +} + +func (c *httpClusterClient) Do(ctx context.Context, act httpAction) (*http.Response, []byte, error) { + action := act + c.RLock() + leps := len(c.endpoints) + eps := make([]url.URL, leps) + n := copy(eps, c.endpoints) + pinned := c.pinned + + if c.credentials != nil { + action = &authedAction{ + act: act, + credentials: *c.credentials, + } + } + c.RUnlock() + + if leps == 0 { + return nil, nil, ErrNoEndpoints + } + + if leps != n { + return nil, nil, errors.New("unable to pick endpoint: copy failed") + } + + var resp *http.Response + var body []byte + var err error + cerr := &ClusterError{} + isOneShot := ctx.Value(&oneShotCtxValue) != nil + + for i := pinned; i < leps+pinned; i++ { + k := i % leps + hc := c.clientFactory(eps[k]) + resp, body, err = hc.Do(ctx, action) + if err != nil { + cerr.Errors = append(cerr.Errors, err) + if err == ctx.Err() { + return nil, nil, ctx.Err() + } + if err == context.Canceled || err == context.DeadlineExceeded { + return nil, nil, err + } + if isOneShot { + return nil, nil, err + } + continue + } + if resp.StatusCode/100 == 5 { + switch resp.StatusCode { + case http.StatusInternalServerError, http.StatusServiceUnavailable: + // TODO: make sure this is a no leader response + cerr.Errors = append(cerr.Errors, fmt.Errorf("client: etcd member %s has no leader", eps[k].String())) + default: + cerr.Errors = append(cerr.Errors, fmt.Errorf("client: etcd member %s returns server error [%s]", eps[k].String(), http.StatusText(resp.StatusCode))) + } + if isOneShot { + return nil, nil, cerr.Errors[0] + } + continue + } + if k != pinned { + c.Lock() + c.pinned = k + c.Unlock() + } + return resp, body, nil + } + + return nil, nil, cerr +} + +func (c *httpClusterClient) Endpoints() []string { + c.RLock() + defer c.RUnlock() + + eps := make([]string, len(c.endpoints)) + for i, ep := range c.endpoints { + eps[i] = ep.String() + } + + return eps +} + +func (c *httpClusterClient) Sync(ctx context.Context) error { + mAPI := NewMembersAPI(c) + ms, err := mAPI.List(ctx) + if err != nil { + return err + } + + c.Lock() + defer c.Unlock() + + var eps []string + for _, m := range ms { + eps = append(eps, m.ClientURLs...) + } + sort.Sort(sort.StringSlice(eps)) + + ceps := make([]string, len(c.endpoints)) + for i, cep := range c.endpoints { + ceps[i] = cep.String() + } + sort.Sort(sort.StringSlice(ceps)) + // fast path if no change happens + // this helps client to pin the endpoint when no cluster change + if reflect.DeepEqual(eps, ceps) { + return nil + } + + return c.SetEndpoints(eps) +} + +func (c *httpClusterClient) AutoSync(ctx context.Context, interval time.Duration) error { + ticker := time.NewTicker(interval) + defer ticker.Stop() + for { + err := c.Sync(ctx) + if err != nil { + return err + } + select { + case <-ctx.Done(): + return ctx.Err() + case <-ticker.C: + } + } +} + +type roundTripResponse struct { + resp *http.Response + err error +} + +type simpleHTTPClient struct { + transport CancelableTransport + endpoint url.URL + headerTimeout time.Duration +} + +func (c *simpleHTTPClient) Do(ctx context.Context, act httpAction) (*http.Response, []byte, error) { + req := act.HTTPRequest(c.endpoint) + + if err := printcURL(req); err != nil { + return nil, nil, err + } + + isWait := false + if req != nil && req.URL != nil { + ws := req.URL.Query().Get("wait") + if len(ws) != 0 { + var err error + isWait, err = strconv.ParseBool(ws) + if err != nil { + return nil, nil, fmt.Errorf("wrong wait value %s (%v for %+v)", ws, err, req) + } + } + } + + var hctx context.Context + var hcancel context.CancelFunc + if !isWait && c.headerTimeout > 0 { + hctx, hcancel = context.WithTimeout(ctx, c.headerTimeout) + } else { + hctx, hcancel = context.WithCancel(ctx) + } + defer hcancel() + + reqcancel := requestCanceler(c.transport, req) + + rtchan := make(chan roundTripResponse, 1) + go func() { + resp, err := c.transport.RoundTrip(req) + rtchan <- roundTripResponse{resp: resp, err: err} + close(rtchan) + }() + + var resp *http.Response + var err error + + select { + case rtresp := <-rtchan: + resp, err = rtresp.resp, rtresp.err + case <-hctx.Done(): + // cancel and wait for request to actually exit before continuing + reqcancel() + rtresp := <-rtchan + resp = rtresp.resp + switch { + case ctx.Err() != nil: + err = ctx.Err() + case hctx.Err() != nil: + err = fmt.Errorf("client: endpoint %s exceeded header timeout", c.endpoint.String()) + default: + panic("failed to get error from context") + } + } + + // always check for resp nil-ness to deal with possible + // race conditions between channels above + defer func() { + if resp != nil { + resp.Body.Close() + } + }() + + if err != nil { + return nil, nil, err + } + + var body []byte + done := make(chan struct{}) + go func() { + body, err = ioutil.ReadAll(resp.Body) + done <- struct{}{} + }() + + select { + case <-ctx.Done(): + resp.Body.Close() + <-done + return nil, nil, ctx.Err() + case <-done: + } + + return resp, body, err +} + +type authedAction struct { + act httpAction + credentials credentials +} + +func (a *authedAction) HTTPRequest(url url.URL) *http.Request { + r := a.act.HTTPRequest(url) + r.SetBasicAuth(a.credentials.username, a.credentials.password) + return r +} + +type redirectFollowingHTTPClient struct { + client httpClient + checkRedirect CheckRedirectFunc +} + +func (r *redirectFollowingHTTPClient) Do(ctx context.Context, act httpAction) (*http.Response, []byte, error) { + next := act + for i := 0; i < 100; i++ { + if i > 0 { + if err := r.checkRedirect(i); err != nil { + return nil, nil, err + } + } + resp, body, err := r.client.Do(ctx, next) + if err != nil { + return nil, nil, err + } + if resp.StatusCode/100 == 3 { + hdr := resp.Header.Get("Location") + if hdr == "" { + return nil, nil, fmt.Errorf("Location header not set") + } + loc, err := url.Parse(hdr) + if err != nil { + return nil, nil, fmt.Errorf("Location header not valid URL: %s", hdr) + } + next = &redirectedHTTPAction{ + action: act, + location: *loc, + } + continue + } + return resp, body, nil + } + + return nil, nil, errTooManyRedirectChecks +} + +type redirectedHTTPAction struct { + action httpAction + location url.URL +} + +func (r *redirectedHTTPAction) HTTPRequest(ep url.URL) *http.Request { + orig := r.action.HTTPRequest(ep) + orig.URL = &r.location + return orig +} + +func shuffleEndpoints(r *rand.Rand, eps []url.URL) []url.URL { + p := r.Perm(len(eps)) + neps := make([]url.URL, len(eps)) + for i, k := range p { + neps[i] = eps[k] + } + return neps +} diff --git a/vendor/github.com/coreos/etcd/client/cluster_error.go b/vendor/github.com/coreos/etcd/client/cluster_error.go new file mode 100644 index 00000000..34618cdb --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/cluster_error.go @@ -0,0 +1,37 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import "fmt" + +type ClusterError struct { + Errors []error +} + +func (ce *ClusterError) Error() string { + s := ErrClusterUnavailable.Error() + for i, e := range ce.Errors { + s += fmt.Sprintf("; error #%d: %s\n", i, e) + } + return s +} + +func (ce *ClusterError) Detail() string { + s := "" + for i, e := range ce.Errors { + s += fmt.Sprintf("error #%d: %s\n", i, e) + } + return s +} diff --git a/vendor/github.com/coreos/etcd/client/curl.go b/vendor/github.com/coreos/etcd/client/curl.go new file mode 100644 index 00000000..c8bc9fba --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/curl.go @@ -0,0 +1,70 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "bytes" + "fmt" + "io/ioutil" + "net/http" + "os" +) + +var ( + cURLDebug = false +) + +func EnablecURLDebug() { + cURLDebug = true +} + +func DisablecURLDebug() { + cURLDebug = false +} + +// printcURL prints the cURL equivalent request to stderr. +// It returns an error if the body of the request cannot +// be read. +// The caller MUST cancel the request if there is an error. +func printcURL(req *http.Request) error { + if !cURLDebug { + return nil + } + var ( + command string + b []byte + err error + ) + + if req.URL != nil { + command = fmt.Sprintf("curl -X %s %s", req.Method, req.URL.String()) + } + + if req.Body != nil { + b, err = ioutil.ReadAll(req.Body) + if err != nil { + return err + } + command += fmt.Sprintf(" -d %q", string(b)) + } + + fmt.Fprintf(os.Stderr, "cURL Command: %s\n", command) + + // reset body + body := bytes.NewBuffer(b) + req.Body = ioutil.NopCloser(body) + + return nil +} diff --git a/vendor/github.com/coreos/etcd/client/discover.go b/vendor/github.com/coreos/etcd/client/discover.go new file mode 100644 index 00000000..bfd7aec9 --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/discover.go @@ -0,0 +1,21 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +// Discoverer is an interface that wraps the Discover method. +type Discoverer interface { + // Discover looks up the etcd servers for the domain. + Discover(domain string) ([]string, error) +} diff --git a/vendor/github.com/coreos/etcd/client/doc.go b/vendor/github.com/coreos/etcd/client/doc.go new file mode 100644 index 00000000..32fdfb52 --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/doc.go @@ -0,0 +1,73 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* +Package client provides bindings for the etcd APIs. + +Create a Config and exchange it for a Client: + + import ( + "net/http" + + "github.com/coreos/etcd/client" + "golang.org/x/net/context" + ) + + cfg := client.Config{ + Endpoints: []string{"http://127.0.0.1:2379"}, + Transport: DefaultTransport, + } + + c, err := client.New(cfg) + if err != nil { + // handle error + } + +Clients are safe for concurrent use by multiple goroutines. + +Create a KeysAPI using the Client, then use it to interact with etcd: + + kAPI := client.NewKeysAPI(c) + + // create a new key /foo with the value "bar" + _, err = kAPI.Create(context.Background(), "/foo", "bar") + if err != nil { + // handle error + } + + // delete the newly created key only if the value is still "bar" + _, err = kAPI.Delete(context.Background(), "/foo", &DeleteOptions{PrevValue: "bar"}) + if err != nil { + // handle error + } + +Use a custom context to set timeouts on your operations: + + import "time" + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + // set a new key, ignoring it's previous state + _, err := kAPI.Set(ctx, "/ping", "pong", nil) + if err != nil { + if err == context.DeadlineExceeded { + // request took longer than 5s + } else { + // handle error + } + } + +*/ +package client diff --git a/vendor/github.com/coreos/etcd/client/keys.generated.go b/vendor/github.com/coreos/etcd/client/keys.generated.go new file mode 100644 index 00000000..748283aa --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/keys.generated.go @@ -0,0 +1,1000 @@ +// ************************************************************ +// DO NOT EDIT. +// THIS FILE IS AUTO-GENERATED BY codecgen. +// ************************************************************ + +package client + +import ( + "errors" + "fmt" + codec1978 "github.com/ugorji/go/codec" + "reflect" + "runtime" + time "time" +) + +const ( + // ----- content types ---- + codecSelferC_UTF81819 = 1 + codecSelferC_RAW1819 = 0 + // ----- value types used ---- + codecSelferValueTypeArray1819 = 10 + codecSelferValueTypeMap1819 = 9 + // ----- containerStateValues ---- + codecSelfer_containerMapKey1819 = 2 + codecSelfer_containerMapValue1819 = 3 + codecSelfer_containerMapEnd1819 = 4 + codecSelfer_containerArrayElem1819 = 6 + codecSelfer_containerArrayEnd1819 = 7 +) + +var ( + codecSelferBitsize1819 = uint8(reflect.TypeOf(uint(0)).Bits()) + codecSelferOnlyMapOrArrayEncodeToStructErr1819 = errors.New(`only encoded map or array can be decoded into a struct`) +) + +type codecSelfer1819 struct{} + +func init() { + if codec1978.GenVersion != 5 { + _, file, _, _ := runtime.Caller(0) + err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v", + 5, codec1978.GenVersion, file) + panic(err) + } + if false { // reference the types, but skip this branch at build/run time + var v0 time.Time + _ = v0 + } +} + +func (x *Response) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [3]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(3) + } else { + yynn2 = 3 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + yym4 := z.EncBinary() + _ = yym4 + if false { + } else { + r.EncodeString(codecSelferC_UTF81819, string(x.Action)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("action")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + r.EncodeString(codecSelferC_UTF81819, string(x.Action)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + if x.Node == nil { + r.EncodeNil() + } else { + x.Node.CodecEncodeSelf(e) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("node")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + if x.Node == nil { + r.EncodeNil() + } else { + x.Node.CodecEncodeSelf(e) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + if x.PrevNode == nil { + r.EncodeNil() + } else { + x.PrevNode.CodecEncodeSelf(e) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("prevNode")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + if x.PrevNode == nil { + r.EncodeNil() + } else { + x.PrevNode.CodecEncodeSelf(e) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1819) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1819) + } + } + } +} + +func (x *Response) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym8 := z.DecBinary() + _ = yym8 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct9 := r.ContainerType() + if yyct9 == codecSelferValueTypeMap1819 { + yyl9 := r.ReadMapStart() + if yyl9 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1819) + } else { + x.codecDecodeSelfFromMap(yyl9, d) + } + } else if yyct9 == codecSelferValueTypeArray1819 { + yyl9 := r.ReadArrayStart() + if yyl9 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + } else { + x.codecDecodeSelfFromArray(yyl9, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1819) + } + } +} + +func (x *Response) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys10Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys10Slc + var yyhl10 bool = l >= 0 + for yyj10 := 0; ; yyj10++ { + if yyhl10 { + if yyj10 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1819) + yys10Slc = r.DecodeBytes(yys10Slc, true, true) + yys10 := string(yys10Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1819) + switch yys10 { + case "action": + if r.TryDecodeAsNil() { + x.Action = "" + } else { + x.Action = string(r.DecodeString()) + } + case "node": + if r.TryDecodeAsNil() { + if x.Node != nil { + x.Node = nil + } + } else { + if x.Node == nil { + x.Node = new(Node) + } + x.Node.CodecDecodeSelf(d) + } + case "prevNode": + if r.TryDecodeAsNil() { + if x.PrevNode != nil { + x.PrevNode = nil + } + } else { + if x.PrevNode == nil { + x.PrevNode = new(Node) + } + x.PrevNode.CodecDecodeSelf(d) + } + default: + z.DecStructFieldNotFound(-1, yys10) + } // end switch yys10 + } // end for yyj10 + z.DecSendContainerState(codecSelfer_containerMapEnd1819) +} + +func (x *Response) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj14 int + var yyb14 bool + var yyhl14 bool = l >= 0 + yyj14++ + if yyhl14 { + yyb14 = yyj14 > l + } else { + yyb14 = r.CheckBreak() + } + if yyb14 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + x.Action = "" + } else { + x.Action = string(r.DecodeString()) + } + yyj14++ + if yyhl14 { + yyb14 = yyj14 > l + } else { + yyb14 = r.CheckBreak() + } + if yyb14 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + if x.Node != nil { + x.Node = nil + } + } else { + if x.Node == nil { + x.Node = new(Node) + } + x.Node.CodecDecodeSelf(d) + } + yyj14++ + if yyhl14 { + yyb14 = yyj14 > l + } else { + yyb14 = r.CheckBreak() + } + if yyb14 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + if x.PrevNode != nil { + x.PrevNode = nil + } + } else { + if x.PrevNode == nil { + x.PrevNode = new(Node) + } + x.PrevNode.CodecDecodeSelf(d) + } + for { + yyj14++ + if yyhl14 { + yyb14 = yyj14 > l + } else { + yyb14 = r.CheckBreak() + } + if yyb14 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + z.DecStructFieldNotFound(yyj14-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) +} + +func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym18 := z.EncBinary() + _ = yym18 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep19 := !z.EncBinary() + yy2arr19 := z.EncBasicHandle().StructToArray + var yyq19 [8]bool + _, _, _ = yysep19, yyq19, yy2arr19 + const yyr19 bool = false + yyq19[1] = x.Dir != false + yyq19[6] = x.Expiration != nil + yyq19[7] = x.TTL != 0 + var yynn19 int + if yyr19 || yy2arr19 { + r.EncodeArrayStart(8) + } else { + yynn19 = 5 + for _, b := range yyq19 { + if b { + yynn19++ + } + } + r.EncodeMapStart(yynn19) + yynn19 = 0 + } + if yyr19 || yy2arr19 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + yym21 := z.EncBinary() + _ = yym21 + if false { + } else { + r.EncodeString(codecSelferC_UTF81819, string(x.Key)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("key")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + yym22 := z.EncBinary() + _ = yym22 + if false { + } else { + r.EncodeString(codecSelferC_UTF81819, string(x.Key)) + } + } + if yyr19 || yy2arr19 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + if yyq19[1] { + yym24 := z.EncBinary() + _ = yym24 + if false { + } else { + r.EncodeBool(bool(x.Dir)) + } + } else { + r.EncodeBool(false) + } + } else { + if yyq19[1] { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("dir")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + yym25 := z.EncBinary() + _ = yym25 + if false { + } else { + r.EncodeBool(bool(x.Dir)) + } + } + } + if yyr19 || yy2arr19 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + yym27 := z.EncBinary() + _ = yym27 + if false { + } else { + r.EncodeString(codecSelferC_UTF81819, string(x.Value)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("value")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + yym28 := z.EncBinary() + _ = yym28 + if false { + } else { + r.EncodeString(codecSelferC_UTF81819, string(x.Value)) + } + } + if yyr19 || yy2arr19 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + if x.Nodes == nil { + r.EncodeNil() + } else { + x.Nodes.CodecEncodeSelf(e) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("nodes")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + if x.Nodes == nil { + r.EncodeNil() + } else { + x.Nodes.CodecEncodeSelf(e) + } + } + if yyr19 || yy2arr19 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + yym31 := z.EncBinary() + _ = yym31 + if false { + } else { + r.EncodeUint(uint64(x.CreatedIndex)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("createdIndex")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + yym32 := z.EncBinary() + _ = yym32 + if false { + } else { + r.EncodeUint(uint64(x.CreatedIndex)) + } + } + if yyr19 || yy2arr19 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + yym34 := z.EncBinary() + _ = yym34 + if false { + } else { + r.EncodeUint(uint64(x.ModifiedIndex)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("modifiedIndex")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + yym35 := z.EncBinary() + _ = yym35 + if false { + } else { + r.EncodeUint(uint64(x.ModifiedIndex)) + } + } + if yyr19 || yy2arr19 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + if yyq19[6] { + if x.Expiration == nil { + r.EncodeNil() + } else { + yym37 := z.EncBinary() + _ = yym37 + if false { + } else if yym38 := z.TimeRtidIfBinc(); yym38 != 0 { + r.EncodeBuiltin(yym38, x.Expiration) + } else if z.HasExtensions() && z.EncExt(x.Expiration) { + } else if yym37 { + z.EncBinaryMarshal(x.Expiration) + } else if !yym37 && z.IsJSONHandle() { + z.EncJSONMarshal(x.Expiration) + } else { + z.EncFallback(x.Expiration) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq19[6] { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("expiration")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + if x.Expiration == nil { + r.EncodeNil() + } else { + yym39 := z.EncBinary() + _ = yym39 + if false { + } else if yym40 := z.TimeRtidIfBinc(); yym40 != 0 { + r.EncodeBuiltin(yym40, x.Expiration) + } else if z.HasExtensions() && z.EncExt(x.Expiration) { + } else if yym39 { + z.EncBinaryMarshal(x.Expiration) + } else if !yym39 && z.IsJSONHandle() { + z.EncJSONMarshal(x.Expiration) + } else { + z.EncFallback(x.Expiration) + } + } + } + } + if yyr19 || yy2arr19 { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + if yyq19[7] { + yym42 := z.EncBinary() + _ = yym42 + if false { + } else { + r.EncodeInt(int64(x.TTL)) + } + } else { + r.EncodeInt(0) + } + } else { + if yyq19[7] { + z.EncSendContainerState(codecSelfer_containerMapKey1819) + r.EncodeString(codecSelferC_UTF81819, string("ttl")) + z.EncSendContainerState(codecSelfer_containerMapValue1819) + yym43 := z.EncBinary() + _ = yym43 + if false { + } else { + r.EncodeInt(int64(x.TTL)) + } + } + } + if yyr19 || yy2arr19 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1819) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1819) + } + } + } +} + +func (x *Node) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym44 := z.DecBinary() + _ = yym44 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct45 := r.ContainerType() + if yyct45 == codecSelferValueTypeMap1819 { + yyl45 := r.ReadMapStart() + if yyl45 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1819) + } else { + x.codecDecodeSelfFromMap(yyl45, d) + } + } else if yyct45 == codecSelferValueTypeArray1819 { + yyl45 := r.ReadArrayStart() + if yyl45 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + } else { + x.codecDecodeSelfFromArray(yyl45, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1819) + } + } +} + +func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys46Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys46Slc + var yyhl46 bool = l >= 0 + for yyj46 := 0; ; yyj46++ { + if yyhl46 { + if yyj46 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1819) + yys46Slc = r.DecodeBytes(yys46Slc, true, true) + yys46 := string(yys46Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1819) + switch yys46 { + case "key": + if r.TryDecodeAsNil() { + x.Key = "" + } else { + x.Key = string(r.DecodeString()) + } + case "dir": + if r.TryDecodeAsNil() { + x.Dir = false + } else { + x.Dir = bool(r.DecodeBool()) + } + case "value": + if r.TryDecodeAsNil() { + x.Value = "" + } else { + x.Value = string(r.DecodeString()) + } + case "nodes": + if r.TryDecodeAsNil() { + x.Nodes = nil + } else { + yyv50 := &x.Nodes + yyv50.CodecDecodeSelf(d) + } + case "createdIndex": + if r.TryDecodeAsNil() { + x.CreatedIndex = 0 + } else { + x.CreatedIndex = uint64(r.DecodeUint(64)) + } + case "modifiedIndex": + if r.TryDecodeAsNil() { + x.ModifiedIndex = 0 + } else { + x.ModifiedIndex = uint64(r.DecodeUint(64)) + } + case "expiration": + if r.TryDecodeAsNil() { + if x.Expiration != nil { + x.Expiration = nil + } + } else { + if x.Expiration == nil { + x.Expiration = new(time.Time) + } + yym54 := z.DecBinary() + _ = yym54 + if false { + } else if yym55 := z.TimeRtidIfBinc(); yym55 != 0 { + r.DecodeBuiltin(yym55, x.Expiration) + } else if z.HasExtensions() && z.DecExt(x.Expiration) { + } else if yym54 { + z.DecBinaryUnmarshal(x.Expiration) + } else if !yym54 && z.IsJSONHandle() { + z.DecJSONUnmarshal(x.Expiration) + } else { + z.DecFallback(x.Expiration, false) + } + } + case "ttl": + if r.TryDecodeAsNil() { + x.TTL = 0 + } else { + x.TTL = int64(r.DecodeInt(64)) + } + default: + z.DecStructFieldNotFound(-1, yys46) + } // end switch yys46 + } // end for yyj46 + z.DecSendContainerState(codecSelfer_containerMapEnd1819) +} + +func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj57 int + var yyb57 bool + var yyhl57 bool = l >= 0 + yyj57++ + if yyhl57 { + yyb57 = yyj57 > l + } else { + yyb57 = r.CheckBreak() + } + if yyb57 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + x.Key = "" + } else { + x.Key = string(r.DecodeString()) + } + yyj57++ + if yyhl57 { + yyb57 = yyj57 > l + } else { + yyb57 = r.CheckBreak() + } + if yyb57 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + x.Dir = false + } else { + x.Dir = bool(r.DecodeBool()) + } + yyj57++ + if yyhl57 { + yyb57 = yyj57 > l + } else { + yyb57 = r.CheckBreak() + } + if yyb57 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + x.Value = "" + } else { + x.Value = string(r.DecodeString()) + } + yyj57++ + if yyhl57 { + yyb57 = yyj57 > l + } else { + yyb57 = r.CheckBreak() + } + if yyb57 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + x.Nodes = nil + } else { + yyv61 := &x.Nodes + yyv61.CodecDecodeSelf(d) + } + yyj57++ + if yyhl57 { + yyb57 = yyj57 > l + } else { + yyb57 = r.CheckBreak() + } + if yyb57 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + x.CreatedIndex = 0 + } else { + x.CreatedIndex = uint64(r.DecodeUint(64)) + } + yyj57++ + if yyhl57 { + yyb57 = yyj57 > l + } else { + yyb57 = r.CheckBreak() + } + if yyb57 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + x.ModifiedIndex = 0 + } else { + x.ModifiedIndex = uint64(r.DecodeUint(64)) + } + yyj57++ + if yyhl57 { + yyb57 = yyj57 > l + } else { + yyb57 = r.CheckBreak() + } + if yyb57 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + if x.Expiration != nil { + x.Expiration = nil + } + } else { + if x.Expiration == nil { + x.Expiration = new(time.Time) + } + yym65 := z.DecBinary() + _ = yym65 + if false { + } else if yym66 := z.TimeRtidIfBinc(); yym66 != 0 { + r.DecodeBuiltin(yym66, x.Expiration) + } else if z.HasExtensions() && z.DecExt(x.Expiration) { + } else if yym65 { + z.DecBinaryUnmarshal(x.Expiration) + } else if !yym65 && z.IsJSONHandle() { + z.DecJSONUnmarshal(x.Expiration) + } else { + z.DecFallback(x.Expiration, false) + } + } + yyj57++ + if yyhl57 { + yyb57 = yyj57 > l + } else { + yyb57 = r.CheckBreak() + } + if yyb57 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + if r.TryDecodeAsNil() { + x.TTL = 0 + } else { + x.TTL = int64(r.DecodeInt(64)) + } + for { + yyj57++ + if yyhl57 { + yyb57 = yyj57 > l + } else { + yyb57 = r.CheckBreak() + } + if yyb57 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1819) + z.DecStructFieldNotFound(yyj57-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1819) +} + +func (x Nodes) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym68 := z.EncBinary() + _ = yym68 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + h.encNodes((Nodes)(x), e) + } + } +} + +func (x *Nodes) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym69 := z.DecBinary() + _ = yym69 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + h.decNodes((*Nodes)(x), d) + } +} + +func (x codecSelfer1819) encNodes(v Nodes, e *codec1978.Encoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeArrayStart(len(v)) + for _, yyv70 := range v { + z.EncSendContainerState(codecSelfer_containerArrayElem1819) + if yyv70 == nil { + r.EncodeNil() + } else { + yyv70.CodecEncodeSelf(e) + } + } + z.EncSendContainerState(codecSelfer_containerArrayEnd1819) +} + +func (x codecSelfer1819) decNodes(v *Nodes, d *codec1978.Decoder) { + var h codecSelfer1819 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + yyv71 := *v + yyh71, yyl71 := z.DecSliceHelperStart() + var yyc71 bool + if yyl71 == 0 { + if yyv71 == nil { + yyv71 = []*Node{} + yyc71 = true + } else if len(yyv71) != 0 { + yyv71 = yyv71[:0] + yyc71 = true + } + } else if yyl71 > 0 { + var yyrr71, yyrl71 int + var yyrt71 bool + if yyl71 > cap(yyv71) { + + yyrg71 := len(yyv71) > 0 + yyv271 := yyv71 + yyrl71, yyrt71 = z.DecInferLen(yyl71, z.DecBasicHandle().MaxInitLen, 8) + if yyrt71 { + if yyrl71 <= cap(yyv71) { + yyv71 = yyv71[:yyrl71] + } else { + yyv71 = make([]*Node, yyrl71) + } + } else { + yyv71 = make([]*Node, yyrl71) + } + yyc71 = true + yyrr71 = len(yyv71) + if yyrg71 { + copy(yyv71, yyv271) + } + } else if yyl71 != len(yyv71) { + yyv71 = yyv71[:yyl71] + yyc71 = true + } + yyj71 := 0 + for ; yyj71 < yyrr71; yyj71++ { + yyh71.ElemContainerState(yyj71) + if r.TryDecodeAsNil() { + if yyv71[yyj71] != nil { + *yyv71[yyj71] = Node{} + } + } else { + if yyv71[yyj71] == nil { + yyv71[yyj71] = new(Node) + } + yyw72 := yyv71[yyj71] + yyw72.CodecDecodeSelf(d) + } + + } + if yyrt71 { + for ; yyj71 < yyl71; yyj71++ { + yyv71 = append(yyv71, nil) + yyh71.ElemContainerState(yyj71) + if r.TryDecodeAsNil() { + if yyv71[yyj71] != nil { + *yyv71[yyj71] = Node{} + } + } else { + if yyv71[yyj71] == nil { + yyv71[yyj71] = new(Node) + } + yyw73 := yyv71[yyj71] + yyw73.CodecDecodeSelf(d) + } + + } + } + + } else { + yyj71 := 0 + for ; !r.CheckBreak(); yyj71++ { + + if yyj71 >= len(yyv71) { + yyv71 = append(yyv71, nil) // var yyz71 *Node + yyc71 = true + } + yyh71.ElemContainerState(yyj71) + if yyj71 < len(yyv71) { + if r.TryDecodeAsNil() { + if yyv71[yyj71] != nil { + *yyv71[yyj71] = Node{} + } + } else { + if yyv71[yyj71] == nil { + yyv71[yyj71] = new(Node) + } + yyw74 := yyv71[yyj71] + yyw74.CodecDecodeSelf(d) + } + + } else { + z.DecSwallow() + } + + } + if yyj71 < len(yyv71) { + yyv71 = yyv71[:yyj71] + yyc71 = true + } else if yyj71 == 0 && yyv71 == nil { + yyv71 = []*Node{} + yyc71 = true + } + } + yyh71.End() + if yyc71 { + *v = yyv71 + } +} diff --git a/vendor/github.com/coreos/etcd/client/keys.go b/vendor/github.com/coreos/etcd/client/keys.go new file mode 100644 index 00000000..62d5d506 --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/keys.go @@ -0,0 +1,668 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +//go:generate codecgen -d 1819 -r "Node|Response|Nodes" -o keys.generated.go keys.go + +import ( + "encoding/json" + "errors" + "fmt" + "net/http" + "net/url" + "strconv" + "strings" + "time" + + "github.com/coreos/etcd/pkg/pathutil" + "github.com/ugorji/go/codec" + "golang.org/x/net/context" +) + +const ( + ErrorCodeKeyNotFound = 100 + ErrorCodeTestFailed = 101 + ErrorCodeNotFile = 102 + ErrorCodeNotDir = 104 + ErrorCodeNodeExist = 105 + ErrorCodeRootROnly = 107 + ErrorCodeDirNotEmpty = 108 + ErrorCodeUnauthorized = 110 + + ErrorCodePrevValueRequired = 201 + ErrorCodeTTLNaN = 202 + ErrorCodeIndexNaN = 203 + ErrorCodeInvalidField = 209 + ErrorCodeInvalidForm = 210 + + ErrorCodeRaftInternal = 300 + ErrorCodeLeaderElect = 301 + + ErrorCodeWatcherCleared = 400 + ErrorCodeEventIndexCleared = 401 +) + +type Error struct { + Code int `json:"errorCode"` + Message string `json:"message"` + Cause string `json:"cause"` + Index uint64 `json:"index"` +} + +func (e Error) Error() string { + return fmt.Sprintf("%v: %v (%v) [%v]", e.Code, e.Message, e.Cause, e.Index) +} + +var ( + ErrInvalidJSON = errors.New("client: response is invalid json. The endpoint is probably not valid etcd cluster endpoint.") + ErrEmptyBody = errors.New("client: response body is empty") +) + +// PrevExistType is used to define an existence condition when setting +// or deleting Nodes. +type PrevExistType string + +const ( + PrevIgnore = PrevExistType("") + PrevExist = PrevExistType("true") + PrevNoExist = PrevExistType("false") +) + +var ( + defaultV2KeysPrefix = "/v2/keys" +) + +// NewKeysAPI builds a KeysAPI that interacts with etcd's key-value +// API over HTTP. +func NewKeysAPI(c Client) KeysAPI { + return NewKeysAPIWithPrefix(c, defaultV2KeysPrefix) +} + +// NewKeysAPIWithPrefix acts like NewKeysAPI, but allows the caller +// to provide a custom base URL path. This should only be used in +// very rare cases. +func NewKeysAPIWithPrefix(c Client, p string) KeysAPI { + return &httpKeysAPI{ + client: c, + prefix: p, + } +} + +type KeysAPI interface { + // Get retrieves a set of Nodes from etcd + Get(ctx context.Context, key string, opts *GetOptions) (*Response, error) + + // Set assigns a new value to a Node identified by a given key. The caller + // may define a set of conditions in the SetOptions. If SetOptions.Dir=true + // then value is ignored. + Set(ctx context.Context, key, value string, opts *SetOptions) (*Response, error) + + // Delete removes a Node identified by the given key, optionally destroying + // all of its children as well. The caller may define a set of required + // conditions in an DeleteOptions object. + Delete(ctx context.Context, key string, opts *DeleteOptions) (*Response, error) + + // Create is an alias for Set w/ PrevExist=false + Create(ctx context.Context, key, value string) (*Response, error) + + // CreateInOrder is used to atomically create in-order keys within the given directory. + CreateInOrder(ctx context.Context, dir, value string, opts *CreateInOrderOptions) (*Response, error) + + // Update is an alias for Set w/ PrevExist=true + Update(ctx context.Context, key, value string) (*Response, error) + + // Watcher builds a new Watcher targeted at a specific Node identified + // by the given key. The Watcher may be configured at creation time + // through a WatcherOptions object. The returned Watcher is designed + // to emit events that happen to a Node, and optionally to its children. + Watcher(key string, opts *WatcherOptions) Watcher +} + +type WatcherOptions struct { + // AfterIndex defines the index after-which the Watcher should + // start emitting events. For example, if a value of 5 is + // provided, the first event will have an index >= 6. + // + // Setting AfterIndex to 0 (default) means that the Watcher + // should start watching for events starting at the current + // index, whatever that may be. + AfterIndex uint64 + + // Recursive specifies whether or not the Watcher should emit + // events that occur in children of the given keyspace. If set + // to false (default), events will be limited to those that + // occur for the exact key. + Recursive bool +} + +type CreateInOrderOptions struct { + // TTL defines a period of time after-which the Node should + // expire and no longer exist. Values <= 0 are ignored. Given + // that the zero-value is ignored, TTL cannot be used to set + // a TTL of 0. + TTL time.Duration +} + +type SetOptions struct { + // PrevValue specifies what the current value of the Node must + // be in order for the Set operation to succeed. + // + // Leaving this field empty means that the caller wishes to + // ignore the current value of the Node. This cannot be used + // to compare the Node's current value to an empty string. + // + // PrevValue is ignored if Dir=true + PrevValue string + + // PrevIndex indicates what the current ModifiedIndex of the + // Node must be in order for the Set operation to succeed. + // + // If PrevIndex is set to 0 (default), no comparison is made. + PrevIndex uint64 + + // PrevExist specifies whether the Node must currently exist + // (PrevExist) or not (PrevNoExist). If the caller does not + // care about existence, set PrevExist to PrevIgnore, or simply + // leave it unset. + PrevExist PrevExistType + + // TTL defines a period of time after-which the Node should + // expire and no longer exist. Values <= 0 are ignored. Given + // that the zero-value is ignored, TTL cannot be used to set + // a TTL of 0. + TTL time.Duration + + // Refresh set to true means a TTL value can be updated + // without firing a watch or changing the node value. A + // value must not be provided when refreshing a key. + Refresh bool + + // Dir specifies whether or not this Node should be created as a directory. + Dir bool +} + +type GetOptions struct { + // Recursive defines whether or not all children of the Node + // should be returned. + Recursive bool + + // Sort instructs the server whether or not to sort the Nodes. + // If true, the Nodes are sorted alphabetically by key in + // ascending order (A to z). If false (default), the Nodes will + // not be sorted and the ordering used should not be considered + // predictable. + Sort bool + + // Quorum specifies whether it gets the latest committed value that + // has been applied in quorum of members, which ensures external + // consistency (or linearizability). + Quorum bool +} + +type DeleteOptions struct { + // PrevValue specifies what the current value of the Node must + // be in order for the Delete operation to succeed. + // + // Leaving this field empty means that the caller wishes to + // ignore the current value of the Node. This cannot be used + // to compare the Node's current value to an empty string. + PrevValue string + + // PrevIndex indicates what the current ModifiedIndex of the + // Node must be in order for the Delete operation to succeed. + // + // If PrevIndex is set to 0 (default), no comparison is made. + PrevIndex uint64 + + // Recursive defines whether or not all children of the Node + // should be deleted. If set to true, all children of the Node + // identified by the given key will be deleted. If left unset + // or explicitly set to false, only a single Node will be + // deleted. + Recursive bool + + // Dir specifies whether or not this Node should be removed as a directory. + Dir bool +} + +type Watcher interface { + // Next blocks until an etcd event occurs, then returns a Response + // representing that event. The behavior of Next depends on the + // WatcherOptions used to construct the Watcher. Next is designed to + // be called repeatedly, each time blocking until a subsequent event + // is available. + // + // If the provided context is cancelled, Next will return a non-nil + // error. Any other failures encountered while waiting for the next + // event (connection issues, deserialization failures, etc) will + // also result in a non-nil error. + Next(context.Context) (*Response, error) +} + +type Response struct { + // Action is the name of the operation that occurred. Possible values + // include get, set, delete, update, create, compareAndSwap, + // compareAndDelete and expire. + Action string `json:"action"` + + // Node represents the state of the relevant etcd Node. + Node *Node `json:"node"` + + // PrevNode represents the previous state of the Node. PrevNode is non-nil + // only if the Node existed before the action occurred and the action + // caused a change to the Node. + PrevNode *Node `json:"prevNode"` + + // Index holds the cluster-level index at the time the Response was generated. + // This index is not tied to the Node(s) contained in this Response. + Index uint64 `json:"-"` +} + +type Node struct { + // Key represents the unique location of this Node (e.g. "/foo/bar"). + Key string `json:"key"` + + // Dir reports whether node describes a directory. + Dir bool `json:"dir,omitempty"` + + // Value is the current data stored on this Node. If this Node + // is a directory, Value will be empty. + Value string `json:"value"` + + // Nodes holds the children of this Node, only if this Node is a directory. + // This slice of will be arbitrarily deep (children, grandchildren, great- + // grandchildren, etc.) if a recursive Get or Watch request were made. + Nodes Nodes `json:"nodes"` + + // CreatedIndex is the etcd index at-which this Node was created. + CreatedIndex uint64 `json:"createdIndex"` + + // ModifiedIndex is the etcd index at-which this Node was last modified. + ModifiedIndex uint64 `json:"modifiedIndex"` + + // Expiration is the server side expiration time of the key. + Expiration *time.Time `json:"expiration,omitempty"` + + // TTL is the time to live of the key in second. + TTL int64 `json:"ttl,omitempty"` +} + +func (n *Node) String() string { + return fmt.Sprintf("{Key: %s, CreatedIndex: %d, ModifiedIndex: %d, TTL: %d}", n.Key, n.CreatedIndex, n.ModifiedIndex, n.TTL) +} + +// TTLDuration returns the Node's TTL as a time.Duration object +func (n *Node) TTLDuration() time.Duration { + return time.Duration(n.TTL) * time.Second +} + +type Nodes []*Node + +// interfaces for sorting + +func (ns Nodes) Len() int { return len(ns) } +func (ns Nodes) Less(i, j int) bool { return ns[i].Key < ns[j].Key } +func (ns Nodes) Swap(i, j int) { ns[i], ns[j] = ns[j], ns[i] } + +type httpKeysAPI struct { + client httpClient + prefix string +} + +func (k *httpKeysAPI) Set(ctx context.Context, key, val string, opts *SetOptions) (*Response, error) { + act := &setAction{ + Prefix: k.prefix, + Key: key, + Value: val, + } + + if opts != nil { + act.PrevValue = opts.PrevValue + act.PrevIndex = opts.PrevIndex + act.PrevExist = opts.PrevExist + act.TTL = opts.TTL + act.Refresh = opts.Refresh + act.Dir = opts.Dir + } + + doCtx := ctx + if act.PrevExist == PrevNoExist { + doCtx = context.WithValue(doCtx, &oneShotCtxValue, &oneShotCtxValue) + } + resp, body, err := k.client.Do(doCtx, act) + if err != nil { + return nil, err + } + + return unmarshalHTTPResponse(resp.StatusCode, resp.Header, body) +} + +func (k *httpKeysAPI) Create(ctx context.Context, key, val string) (*Response, error) { + return k.Set(ctx, key, val, &SetOptions{PrevExist: PrevNoExist}) +} + +func (k *httpKeysAPI) CreateInOrder(ctx context.Context, dir, val string, opts *CreateInOrderOptions) (*Response, error) { + act := &createInOrderAction{ + Prefix: k.prefix, + Dir: dir, + Value: val, + } + + if opts != nil { + act.TTL = opts.TTL + } + + resp, body, err := k.client.Do(ctx, act) + if err != nil { + return nil, err + } + + return unmarshalHTTPResponse(resp.StatusCode, resp.Header, body) +} + +func (k *httpKeysAPI) Update(ctx context.Context, key, val string) (*Response, error) { + return k.Set(ctx, key, val, &SetOptions{PrevExist: PrevExist}) +} + +func (k *httpKeysAPI) Delete(ctx context.Context, key string, opts *DeleteOptions) (*Response, error) { + act := &deleteAction{ + Prefix: k.prefix, + Key: key, + } + + if opts != nil { + act.PrevValue = opts.PrevValue + act.PrevIndex = opts.PrevIndex + act.Dir = opts.Dir + act.Recursive = opts.Recursive + } + + doCtx := context.WithValue(ctx, &oneShotCtxValue, &oneShotCtxValue) + resp, body, err := k.client.Do(doCtx, act) + if err != nil { + return nil, err + } + + return unmarshalHTTPResponse(resp.StatusCode, resp.Header, body) +} + +func (k *httpKeysAPI) Get(ctx context.Context, key string, opts *GetOptions) (*Response, error) { + act := &getAction{ + Prefix: k.prefix, + Key: key, + } + + if opts != nil { + act.Recursive = opts.Recursive + act.Sorted = opts.Sort + act.Quorum = opts.Quorum + } + + resp, body, err := k.client.Do(ctx, act) + if err != nil { + return nil, err + } + + return unmarshalHTTPResponse(resp.StatusCode, resp.Header, body) +} + +func (k *httpKeysAPI) Watcher(key string, opts *WatcherOptions) Watcher { + act := waitAction{ + Prefix: k.prefix, + Key: key, + } + + if opts != nil { + act.Recursive = opts.Recursive + if opts.AfterIndex > 0 { + act.WaitIndex = opts.AfterIndex + 1 + } + } + + return &httpWatcher{ + client: k.client, + nextWait: act, + } +} + +type httpWatcher struct { + client httpClient + nextWait waitAction +} + +func (hw *httpWatcher) Next(ctx context.Context) (*Response, error) { + for { + httpresp, body, err := hw.client.Do(ctx, &hw.nextWait) + if err != nil { + return nil, err + } + + resp, err := unmarshalHTTPResponse(httpresp.StatusCode, httpresp.Header, body) + if err != nil { + if err == ErrEmptyBody { + continue + } + return nil, err + } + + hw.nextWait.WaitIndex = resp.Node.ModifiedIndex + 1 + return resp, nil + } +} + +// v2KeysURL forms a URL representing the location of a key. +// The endpoint argument represents the base URL of an etcd +// server. The prefix is the path needed to route from the +// provided endpoint's path to the root of the keys API +// (typically "/v2/keys"). +func v2KeysURL(ep url.URL, prefix, key string) *url.URL { + // We concatenate all parts together manually. We cannot use + // path.Join because it does not reserve trailing slash. + // We call CanonicalURLPath to further cleanup the path. + if prefix != "" && prefix[0] != '/' { + prefix = "/" + prefix + } + if key != "" && key[0] != '/' { + key = "/" + key + } + ep.Path = pathutil.CanonicalURLPath(ep.Path + prefix + key) + return &ep +} + +type getAction struct { + Prefix string + Key string + Recursive bool + Sorted bool + Quorum bool +} + +func (g *getAction) HTTPRequest(ep url.URL) *http.Request { + u := v2KeysURL(ep, g.Prefix, g.Key) + + params := u.Query() + params.Set("recursive", strconv.FormatBool(g.Recursive)) + params.Set("sorted", strconv.FormatBool(g.Sorted)) + params.Set("quorum", strconv.FormatBool(g.Quorum)) + u.RawQuery = params.Encode() + + req, _ := http.NewRequest("GET", u.String(), nil) + return req +} + +type waitAction struct { + Prefix string + Key string + WaitIndex uint64 + Recursive bool +} + +func (w *waitAction) HTTPRequest(ep url.URL) *http.Request { + u := v2KeysURL(ep, w.Prefix, w.Key) + + params := u.Query() + params.Set("wait", "true") + params.Set("waitIndex", strconv.FormatUint(w.WaitIndex, 10)) + params.Set("recursive", strconv.FormatBool(w.Recursive)) + u.RawQuery = params.Encode() + + req, _ := http.NewRequest("GET", u.String(), nil) + return req +} + +type setAction struct { + Prefix string + Key string + Value string + PrevValue string + PrevIndex uint64 + PrevExist PrevExistType + TTL time.Duration + Refresh bool + Dir bool +} + +func (a *setAction) HTTPRequest(ep url.URL) *http.Request { + u := v2KeysURL(ep, a.Prefix, a.Key) + + params := u.Query() + form := url.Values{} + + // we're either creating a directory or setting a key + if a.Dir { + params.Set("dir", strconv.FormatBool(a.Dir)) + } else { + // These options are only valid for setting a key + if a.PrevValue != "" { + params.Set("prevValue", a.PrevValue) + } + form.Add("value", a.Value) + } + + // Options which apply to both setting a key and creating a dir + if a.PrevIndex != 0 { + params.Set("prevIndex", strconv.FormatUint(a.PrevIndex, 10)) + } + if a.PrevExist != PrevIgnore { + params.Set("prevExist", string(a.PrevExist)) + } + if a.TTL > 0 { + form.Add("ttl", strconv.FormatUint(uint64(a.TTL.Seconds()), 10)) + } + + if a.Refresh { + form.Add("refresh", "true") + } + + u.RawQuery = params.Encode() + body := strings.NewReader(form.Encode()) + + req, _ := http.NewRequest("PUT", u.String(), body) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + + return req +} + +type deleteAction struct { + Prefix string + Key string + PrevValue string + PrevIndex uint64 + Dir bool + Recursive bool +} + +func (a *deleteAction) HTTPRequest(ep url.URL) *http.Request { + u := v2KeysURL(ep, a.Prefix, a.Key) + + params := u.Query() + if a.PrevValue != "" { + params.Set("prevValue", a.PrevValue) + } + if a.PrevIndex != 0 { + params.Set("prevIndex", strconv.FormatUint(a.PrevIndex, 10)) + } + if a.Dir { + params.Set("dir", "true") + } + if a.Recursive { + params.Set("recursive", "true") + } + u.RawQuery = params.Encode() + + req, _ := http.NewRequest("DELETE", u.String(), nil) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + + return req +} + +type createInOrderAction struct { + Prefix string + Dir string + Value string + TTL time.Duration +} + +func (a *createInOrderAction) HTTPRequest(ep url.URL) *http.Request { + u := v2KeysURL(ep, a.Prefix, a.Dir) + + form := url.Values{} + form.Add("value", a.Value) + if a.TTL > 0 { + form.Add("ttl", strconv.FormatUint(uint64(a.TTL.Seconds()), 10)) + } + body := strings.NewReader(form.Encode()) + + req, _ := http.NewRequest("POST", u.String(), body) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + return req +} + +func unmarshalHTTPResponse(code int, header http.Header, body []byte) (res *Response, err error) { + switch code { + case http.StatusOK, http.StatusCreated: + if len(body) == 0 { + return nil, ErrEmptyBody + } + res, err = unmarshalSuccessfulKeysResponse(header, body) + default: + err = unmarshalFailedKeysResponse(body) + } + + return +} + +func unmarshalSuccessfulKeysResponse(header http.Header, body []byte) (*Response, error) { + var res Response + err := codec.NewDecoderBytes(body, new(codec.JsonHandle)).Decode(&res) + if err != nil { + return nil, ErrInvalidJSON + } + if header.Get("X-Etcd-Index") != "" { + res.Index, err = strconv.ParseUint(header.Get("X-Etcd-Index"), 10, 64) + if err != nil { + return nil, err + } + } + return &res, nil +} + +func unmarshalFailedKeysResponse(body []byte) error { + var etcdErr Error + if err := json.Unmarshal(body, &etcdErr); err != nil { + return ErrInvalidJSON + } + return etcdErr +} diff --git a/vendor/github.com/coreos/etcd/client/members.go b/vendor/github.com/coreos/etcd/client/members.go new file mode 100644 index 00000000..23adf07a --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/members.go @@ -0,0 +1,304 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "bytes" + "encoding/json" + "fmt" + "net/http" + "net/url" + "path" + + "golang.org/x/net/context" + + "github.com/coreos/etcd/pkg/types" +) + +var ( + defaultV2MembersPrefix = "/v2/members" + defaultLeaderSuffix = "/leader" +) + +type Member struct { + // ID is the unique identifier of this Member. + ID string `json:"id"` + + // Name is a human-readable, non-unique identifier of this Member. + Name string `json:"name"` + + // PeerURLs represents the HTTP(S) endpoints this Member uses to + // participate in etcd's consensus protocol. + PeerURLs []string `json:"peerURLs"` + + // ClientURLs represents the HTTP(S) endpoints on which this Member + // serves it's client-facing APIs. + ClientURLs []string `json:"clientURLs"` +} + +type memberCollection []Member + +func (c *memberCollection) UnmarshalJSON(data []byte) error { + d := struct { + Members []Member + }{} + + if err := json.Unmarshal(data, &d); err != nil { + return err + } + + if d.Members == nil { + *c = make([]Member, 0) + return nil + } + + *c = d.Members + return nil +} + +type memberCreateOrUpdateRequest struct { + PeerURLs types.URLs +} + +func (m *memberCreateOrUpdateRequest) MarshalJSON() ([]byte, error) { + s := struct { + PeerURLs []string `json:"peerURLs"` + }{ + PeerURLs: make([]string, len(m.PeerURLs)), + } + + for i, u := range m.PeerURLs { + s.PeerURLs[i] = u.String() + } + + return json.Marshal(&s) +} + +// NewMembersAPI constructs a new MembersAPI that uses HTTP to +// interact with etcd's membership API. +func NewMembersAPI(c Client) MembersAPI { + return &httpMembersAPI{ + client: c, + } +} + +type MembersAPI interface { + // List enumerates the current cluster membership. + List(ctx context.Context) ([]Member, error) + + // Add instructs etcd to accept a new Member into the cluster. + Add(ctx context.Context, peerURL string) (*Member, error) + + // Remove demotes an existing Member out of the cluster. + Remove(ctx context.Context, mID string) error + + // Update instructs etcd to update an existing Member in the cluster. + Update(ctx context.Context, mID string, peerURLs []string) error + + // Leader gets current leader of the cluster + Leader(ctx context.Context) (*Member, error) +} + +type httpMembersAPI struct { + client httpClient +} + +func (m *httpMembersAPI) List(ctx context.Context) ([]Member, error) { + req := &membersAPIActionList{} + resp, body, err := m.client.Do(ctx, req) + if err != nil { + return nil, err + } + + if err := assertStatusCode(resp.StatusCode, http.StatusOK); err != nil { + return nil, err + } + + var mCollection memberCollection + if err := json.Unmarshal(body, &mCollection); err != nil { + return nil, err + } + + return []Member(mCollection), nil +} + +func (m *httpMembersAPI) Add(ctx context.Context, peerURL string) (*Member, error) { + urls, err := types.NewURLs([]string{peerURL}) + if err != nil { + return nil, err + } + + req := &membersAPIActionAdd{peerURLs: urls} + resp, body, err := m.client.Do(ctx, req) + if err != nil { + return nil, err + } + + if err := assertStatusCode(resp.StatusCode, http.StatusCreated, http.StatusConflict); err != nil { + return nil, err + } + + if resp.StatusCode != http.StatusCreated { + var merr membersError + if err := json.Unmarshal(body, &merr); err != nil { + return nil, err + } + return nil, merr + } + + var memb Member + if err := json.Unmarshal(body, &memb); err != nil { + return nil, err + } + + return &memb, nil +} + +func (m *httpMembersAPI) Update(ctx context.Context, memberID string, peerURLs []string) error { + urls, err := types.NewURLs(peerURLs) + if err != nil { + return err + } + + req := &membersAPIActionUpdate{peerURLs: urls, memberID: memberID} + resp, body, err := m.client.Do(ctx, req) + if err != nil { + return err + } + + if err := assertStatusCode(resp.StatusCode, http.StatusNoContent, http.StatusNotFound, http.StatusConflict); err != nil { + return err + } + + if resp.StatusCode != http.StatusNoContent { + var merr membersError + if err := json.Unmarshal(body, &merr); err != nil { + return err + } + return merr + } + + return nil +} + +func (m *httpMembersAPI) Remove(ctx context.Context, memberID string) error { + req := &membersAPIActionRemove{memberID: memberID} + resp, _, err := m.client.Do(ctx, req) + if err != nil { + return err + } + + return assertStatusCode(resp.StatusCode, http.StatusNoContent, http.StatusGone) +} + +func (m *httpMembersAPI) Leader(ctx context.Context) (*Member, error) { + req := &membersAPIActionLeader{} + resp, body, err := m.client.Do(ctx, req) + if err != nil { + return nil, err + } + + if err := assertStatusCode(resp.StatusCode, http.StatusOK); err != nil { + return nil, err + } + + var leader Member + if err := json.Unmarshal(body, &leader); err != nil { + return nil, err + } + + return &leader, nil +} + +type membersAPIActionList struct{} + +func (l *membersAPIActionList) HTTPRequest(ep url.URL) *http.Request { + u := v2MembersURL(ep) + req, _ := http.NewRequest("GET", u.String(), nil) + return req +} + +type membersAPIActionRemove struct { + memberID string +} + +func (d *membersAPIActionRemove) HTTPRequest(ep url.URL) *http.Request { + u := v2MembersURL(ep) + u.Path = path.Join(u.Path, d.memberID) + req, _ := http.NewRequest("DELETE", u.String(), nil) + return req +} + +type membersAPIActionAdd struct { + peerURLs types.URLs +} + +func (a *membersAPIActionAdd) HTTPRequest(ep url.URL) *http.Request { + u := v2MembersURL(ep) + m := memberCreateOrUpdateRequest{PeerURLs: a.peerURLs} + b, _ := json.Marshal(&m) + req, _ := http.NewRequest("POST", u.String(), bytes.NewReader(b)) + req.Header.Set("Content-Type", "application/json") + return req +} + +type membersAPIActionUpdate struct { + memberID string + peerURLs types.URLs +} + +func (a *membersAPIActionUpdate) HTTPRequest(ep url.URL) *http.Request { + u := v2MembersURL(ep) + m := memberCreateOrUpdateRequest{PeerURLs: a.peerURLs} + u.Path = path.Join(u.Path, a.memberID) + b, _ := json.Marshal(&m) + req, _ := http.NewRequest("PUT", u.String(), bytes.NewReader(b)) + req.Header.Set("Content-Type", "application/json") + return req +} + +func assertStatusCode(got int, want ...int) (err error) { + for _, w := range want { + if w == got { + return nil + } + } + return fmt.Errorf("unexpected status code %d", got) +} + +type membersAPIActionLeader struct{} + +func (l *membersAPIActionLeader) HTTPRequest(ep url.URL) *http.Request { + u := v2MembersURL(ep) + u.Path = path.Join(u.Path, defaultLeaderSuffix) + req, _ := http.NewRequest("GET", u.String(), nil) + return req +} + +// v2MembersURL add the necessary path to the provided endpoint +// to route requests to the default v2 members API. +func v2MembersURL(ep url.URL) *url.URL { + ep.Path = path.Join(ep.Path, defaultV2MembersPrefix) + return &ep +} + +type membersError struct { + Message string `json:"message"` + Code int `json:"-"` +} + +func (e membersError) Error() string { + return e.Message +} diff --git a/vendor/github.com/coreos/etcd/client/srv.go b/vendor/github.com/coreos/etcd/client/srv.go new file mode 100644 index 00000000..fdfa3435 --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/srv.go @@ -0,0 +1,65 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "fmt" + "net" + "net/url" +) + +var ( + // indirection for testing + lookupSRV = net.LookupSRV +) + +type srvDiscover struct{} + +// NewSRVDiscover constructs a new Discoverer that uses the stdlib to lookup SRV records. +func NewSRVDiscover() Discoverer { + return &srvDiscover{} +} + +// Discover looks up the etcd servers for the domain. +func (d *srvDiscover) Discover(domain string) ([]string, error) { + var urls []*url.URL + + updateURLs := func(service, scheme string) error { + _, addrs, err := lookupSRV(service, "tcp", domain) + if err != nil { + return err + } + for _, srv := range addrs { + urls = append(urls, &url.URL{ + Scheme: scheme, + Host: net.JoinHostPort(srv.Target, fmt.Sprintf("%d", srv.Port)), + }) + } + return nil + } + + errHTTPS := updateURLs("etcd-client-ssl", "https") + errHTTP := updateURLs("etcd-client", "http") + + if errHTTPS != nil && errHTTP != nil { + return nil, fmt.Errorf("dns lookup errors: %s and %s", errHTTPS, errHTTP) + } + + endpoints := make([]string, len(urls)) + for i := range urls { + endpoints[i] = urls[i].String() + } + return endpoints, nil +} diff --git a/vendor/github.com/coreos/etcd/client/util.go b/vendor/github.com/coreos/etcd/client/util.go new file mode 100644 index 00000000..15a8babf --- /dev/null +++ b/vendor/github.com/coreos/etcd/client/util.go @@ -0,0 +1,53 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "regexp" +) + +var ( + roleNotFoundRegExp *regexp.Regexp + userNotFoundRegExp *regexp.Regexp +) + +func init() { + roleNotFoundRegExp = regexp.MustCompile("auth: Role .* does not exist.") + userNotFoundRegExp = regexp.MustCompile("auth: User .* does not exist.") +} + +// IsKeyNotFound returns true if the error code is ErrorCodeKeyNotFound. +func IsKeyNotFound(err error) bool { + if cErr, ok := err.(Error); ok { + return cErr.Code == ErrorCodeKeyNotFound + } + return false +} + +// IsRoleNotFound returns true if the error means role not found of v2 API. +func IsRoleNotFound(err error) bool { + if ae, ok := err.(authError); ok { + return roleNotFoundRegExp.MatchString(ae.Message) + } + return false +} + +// IsUserNotFound returns true if the error means user not found of v2 API. +func IsUserNotFound(err error) bool { + if ae, ok := err.(authError); ok { + return userNotFoundRegExp.MatchString(ae.Message) + } + return false +} diff --git a/vendor/github.com/coreos/etcd/clientv3/auth.go b/vendor/github.com/coreos/etcd/clientv3/auth.go new file mode 100644 index 00000000..8c3c047f --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/auth.go @@ -0,0 +1,229 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + "fmt" + "strings" + + "github.com/coreos/etcd/auth/authpb" + pb "github.com/coreos/etcd/etcdserver/etcdserverpb" + "golang.org/x/net/context" + "google.golang.org/grpc" +) + +type ( + AuthEnableResponse pb.AuthEnableResponse + AuthDisableResponse pb.AuthDisableResponse + AuthenticateResponse pb.AuthenticateResponse + AuthUserAddResponse pb.AuthUserAddResponse + AuthUserDeleteResponse pb.AuthUserDeleteResponse + AuthUserChangePasswordResponse pb.AuthUserChangePasswordResponse + AuthUserGrantRoleResponse pb.AuthUserGrantRoleResponse + AuthUserGetResponse pb.AuthUserGetResponse + AuthUserRevokeRoleResponse pb.AuthUserRevokeRoleResponse + AuthRoleAddResponse pb.AuthRoleAddResponse + AuthRoleGrantPermissionResponse pb.AuthRoleGrantPermissionResponse + AuthRoleGetResponse pb.AuthRoleGetResponse + AuthRoleRevokePermissionResponse pb.AuthRoleRevokePermissionResponse + AuthRoleDeleteResponse pb.AuthRoleDeleteResponse + AuthUserListResponse pb.AuthUserListResponse + AuthRoleListResponse pb.AuthRoleListResponse + + PermissionType authpb.Permission_Type +) + +const ( + PermRead = authpb.READ + PermWrite = authpb.WRITE + PermReadWrite = authpb.READWRITE +) + +type Auth interface { + // AuthEnable enables auth of an etcd cluster. + AuthEnable(ctx context.Context) (*AuthEnableResponse, error) + + // AuthDisable disables auth of an etcd cluster. + AuthDisable(ctx context.Context) (*AuthDisableResponse, error) + + // UserAdd adds a new user to an etcd cluster. + UserAdd(ctx context.Context, name string, password string) (*AuthUserAddResponse, error) + + // UserDelete deletes a user from an etcd cluster. + UserDelete(ctx context.Context, name string) (*AuthUserDeleteResponse, error) + + // UserChangePassword changes a password of a user. + UserChangePassword(ctx context.Context, name string, password string) (*AuthUserChangePasswordResponse, error) + + // UserGrantRole grants a role to a user. + UserGrantRole(ctx context.Context, user string, role string) (*AuthUserGrantRoleResponse, error) + + // UserGet gets a detailed information of a user. + UserGet(ctx context.Context, name string) (*AuthUserGetResponse, error) + + // UserList gets a list of all users. + UserList(ctx context.Context) (*AuthUserListResponse, error) + + // UserRevokeRole revokes a role of a user. + UserRevokeRole(ctx context.Context, name string, role string) (*AuthUserRevokeRoleResponse, error) + + // RoleAdd adds a new role to an etcd cluster. + RoleAdd(ctx context.Context, name string) (*AuthRoleAddResponse, error) + + // RoleGrantPermission grants a permission to a role. + RoleGrantPermission(ctx context.Context, name string, key, rangeEnd string, permType PermissionType) (*AuthRoleGrantPermissionResponse, error) + + // RoleGet gets a detailed information of a role. + RoleGet(ctx context.Context, role string) (*AuthRoleGetResponse, error) + + // RoleList gets a list of all roles. + RoleList(ctx context.Context) (*AuthRoleListResponse, error) + + // RoleRevokePermission revokes a permission from a role. + RoleRevokePermission(ctx context.Context, role string, key, rangeEnd string) (*AuthRoleRevokePermissionResponse, error) + + // RoleDelete deletes a role. + RoleDelete(ctx context.Context, role string) (*AuthRoleDeleteResponse, error) +} + +type auth struct { + c *Client + + conn *grpc.ClientConn // conn in-use + remote pb.AuthClient +} + +func NewAuth(c *Client) Auth { + conn := c.ActiveConnection() + return &auth{ + conn: c.ActiveConnection(), + remote: pb.NewAuthClient(conn), + c: c, + } +} + +func (auth *auth) AuthEnable(ctx context.Context) (*AuthEnableResponse, error) { + resp, err := auth.remote.AuthEnable(ctx, &pb.AuthEnableRequest{}) + return (*AuthEnableResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) AuthDisable(ctx context.Context) (*AuthDisableResponse, error) { + resp, err := auth.remote.AuthDisable(ctx, &pb.AuthDisableRequest{}) + return (*AuthDisableResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) UserAdd(ctx context.Context, name string, password string) (*AuthUserAddResponse, error) { + resp, err := auth.remote.UserAdd(ctx, &pb.AuthUserAddRequest{Name: name, Password: password}) + return (*AuthUserAddResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) UserDelete(ctx context.Context, name string) (*AuthUserDeleteResponse, error) { + resp, err := auth.remote.UserDelete(ctx, &pb.AuthUserDeleteRequest{Name: name}) + return (*AuthUserDeleteResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) UserChangePassword(ctx context.Context, name string, password string) (*AuthUserChangePasswordResponse, error) { + resp, err := auth.remote.UserChangePassword(ctx, &pb.AuthUserChangePasswordRequest{Name: name, Password: password}) + return (*AuthUserChangePasswordResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) UserGrantRole(ctx context.Context, user string, role string) (*AuthUserGrantRoleResponse, error) { + resp, err := auth.remote.UserGrantRole(ctx, &pb.AuthUserGrantRoleRequest{User: user, Role: role}) + return (*AuthUserGrantRoleResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) UserGet(ctx context.Context, name string) (*AuthUserGetResponse, error) { + resp, err := auth.remote.UserGet(ctx, &pb.AuthUserGetRequest{Name: name}, grpc.FailFast(false)) + return (*AuthUserGetResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) UserList(ctx context.Context) (*AuthUserListResponse, error) { + resp, err := auth.remote.UserList(ctx, &pb.AuthUserListRequest{}, grpc.FailFast(false)) + return (*AuthUserListResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) UserRevokeRole(ctx context.Context, name string, role string) (*AuthUserRevokeRoleResponse, error) { + resp, err := auth.remote.UserRevokeRole(ctx, &pb.AuthUserRevokeRoleRequest{Name: name, Role: role}) + return (*AuthUserRevokeRoleResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) RoleAdd(ctx context.Context, name string) (*AuthRoleAddResponse, error) { + resp, err := auth.remote.RoleAdd(ctx, &pb.AuthRoleAddRequest{Name: name}) + return (*AuthRoleAddResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) RoleGrantPermission(ctx context.Context, name string, key, rangeEnd string, permType PermissionType) (*AuthRoleGrantPermissionResponse, error) { + perm := &authpb.Permission{ + Key: []byte(key), + RangeEnd: []byte(rangeEnd), + PermType: authpb.Permission_Type(permType), + } + resp, err := auth.remote.RoleGrantPermission(ctx, &pb.AuthRoleGrantPermissionRequest{Name: name, Perm: perm}) + return (*AuthRoleGrantPermissionResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) RoleGet(ctx context.Context, role string) (*AuthRoleGetResponse, error) { + resp, err := auth.remote.RoleGet(ctx, &pb.AuthRoleGetRequest{Role: role}, grpc.FailFast(false)) + return (*AuthRoleGetResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) RoleList(ctx context.Context) (*AuthRoleListResponse, error) { + resp, err := auth.remote.RoleList(ctx, &pb.AuthRoleListRequest{}, grpc.FailFast(false)) + return (*AuthRoleListResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) RoleRevokePermission(ctx context.Context, role string, key, rangeEnd string) (*AuthRoleRevokePermissionResponse, error) { + resp, err := auth.remote.RoleRevokePermission(ctx, &pb.AuthRoleRevokePermissionRequest{Role: role, Key: key, RangeEnd: rangeEnd}) + return (*AuthRoleRevokePermissionResponse)(resp), toErr(ctx, err) +} + +func (auth *auth) RoleDelete(ctx context.Context, role string) (*AuthRoleDeleteResponse, error) { + resp, err := auth.remote.RoleDelete(ctx, &pb.AuthRoleDeleteRequest{Role: role}) + return (*AuthRoleDeleteResponse)(resp), toErr(ctx, err) +} + +func StrToPermissionType(s string) (PermissionType, error) { + val, ok := authpb.Permission_Type_value[strings.ToUpper(s)] + if ok { + return PermissionType(val), nil + } + return PermissionType(-1), fmt.Errorf("invalid permission type: %s", s) +} + +type authenticator struct { + conn *grpc.ClientConn // conn in-use + remote pb.AuthClient +} + +func (auth *authenticator) authenticate(ctx context.Context, name string, password string) (*AuthenticateResponse, error) { + resp, err := auth.remote.Authenticate(ctx, &pb.AuthenticateRequest{Name: name, Password: password}, grpc.FailFast(false)) + return (*AuthenticateResponse)(resp), toErr(ctx, err) +} + +func (auth *authenticator) close() { + auth.conn.Close() +} + +func newAuthenticator(endpoint string, opts []grpc.DialOption) (*authenticator, error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return nil, err + } + + return &authenticator{ + conn: conn, + remote: pb.NewAuthClient(conn), + }, nil +} diff --git a/vendor/github.com/coreos/etcd/clientv3/balancer.go b/vendor/github.com/coreos/etcd/clientv3/balancer.go new file mode 100644 index 00000000..b7fba6a2 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/balancer.go @@ -0,0 +1,147 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + "net/url" + "strings" + "sync" + + "golang.org/x/net/context" + "google.golang.org/grpc" +) + +// simpleBalancer does the bare minimum to expose multiple eps +// to the grpc reconnection code path +type simpleBalancer struct { + // addrs are the client's endpoints for grpc + addrs []grpc.Address + // notifyCh notifies grpc of the set of addresses for connecting + notifyCh chan []grpc.Address + + // readyc closes once the first connection is up + readyc chan struct{} + readyOnce sync.Once + + // mu protects upEps, pinAddr, and connectingAddr + mu sync.RWMutex + // upEps holds the current endpoints that have an active connection + upEps map[string]struct{} + // upc closes when upEps transitions from empty to non-zero or the balancer closes. + upc chan struct{} + + // pinAddr is the currently pinned address; set to the empty string on + // intialization and shutdown. + pinAddr string +} + +func newSimpleBalancer(eps []string) *simpleBalancer { + notifyCh := make(chan []grpc.Address, 1) + addrs := make([]grpc.Address, len(eps)) + for i := range eps { + addrs[i].Addr = getHost(eps[i]) + } + notifyCh <- addrs + sb := &simpleBalancer{ + addrs: addrs, + notifyCh: notifyCh, + readyc: make(chan struct{}), + upEps: make(map[string]struct{}), + upc: make(chan struct{}), + } + return sb +} + +func (b *simpleBalancer) Start(target string) error { return nil } + +func (b *simpleBalancer) ConnectNotify() <-chan struct{} { + b.mu.Lock() + defer b.mu.Unlock() + return b.upc +} + +func (b *simpleBalancer) Up(addr grpc.Address) func(error) { + b.mu.Lock() + if len(b.upEps) == 0 { + // notify waiting Get()s and pin first connected address + close(b.upc) + b.pinAddr = addr.Addr + } + b.upEps[addr.Addr] = struct{}{} + b.mu.Unlock() + // notify client that a connection is up + b.readyOnce.Do(func() { close(b.readyc) }) + return func(err error) { + b.mu.Lock() + delete(b.upEps, addr.Addr) + if len(b.upEps) == 0 && b.pinAddr != "" { + b.upc = make(chan struct{}) + } else if b.pinAddr == addr.Addr { + // choose new random up endpoint + for k := range b.upEps { + b.pinAddr = k + break + } + } + b.mu.Unlock() + } +} + +func (b *simpleBalancer) Get(ctx context.Context, opts grpc.BalancerGetOptions) (grpc.Address, func(), error) { + var addr string + for { + b.mu.RLock() + ch := b.upc + b.mu.RUnlock() + select { + case <-ch: + case <-ctx.Done(): + return grpc.Address{Addr: ""}, nil, ctx.Err() + } + b.mu.RLock() + addr = b.pinAddr + upEps := len(b.upEps) + b.mu.RUnlock() + if addr == "" { + return grpc.Address{Addr: ""}, nil, grpc.ErrClientConnClosing + } + if upEps > 0 { + break + } + } + return grpc.Address{Addr: addr}, func() {}, nil +} + +func (b *simpleBalancer) Notify() <-chan []grpc.Address { return b.notifyCh } + +func (b *simpleBalancer) Close() error { + b.mu.Lock() + close(b.notifyCh) + // terminate all waiting Get()s + b.pinAddr = "" + if len(b.upEps) == 0 { + close(b.upc) + } + b.mu.Unlock() + return nil +} + +func getHost(ep string) string { + url, uerr := url.Parse(ep) + if uerr != nil || !strings.Contains(ep, "://") { + return ep + } + return url.Host +} diff --git a/vendor/github.com/coreos/etcd/clientv3/client.go b/vendor/github.com/coreos/etcd/clientv3/client.go new file mode 100644 index 00000000..e6903fc2 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/client.go @@ -0,0 +1,324 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + "crypto/tls" + "errors" + "fmt" + "io/ioutil" + "log" + "net" + "net/url" + "strings" + "time" + + "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes" + + "golang.org/x/net/context" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials" + "google.golang.org/grpc/metadata" +) + +var ( + ErrNoAvailableEndpoints = errors.New("etcdclient: no available endpoints") +) + +// Client provides and manages an etcd v3 client session. +type Client struct { + Cluster + KV + Lease + Watcher + Auth + Maintenance + + conn *grpc.ClientConn + cfg Config + creds *credentials.TransportCredentials + balancer *simpleBalancer + retryWrapper retryRpcFunc + + ctx context.Context + cancel context.CancelFunc + + // Username is a username for authentication + Username string + // Password is a password for authentication + Password string +} + +// New creates a new etcdv3 client from a given configuration. +func New(cfg Config) (*Client, error) { + if len(cfg.Endpoints) == 0 { + return nil, ErrNoAvailableEndpoints + } + + return newClient(&cfg) +} + +// NewFromURL creates a new etcdv3 client from a URL. +func NewFromURL(url string) (*Client, error) { + return New(Config{Endpoints: []string{url}}) +} + +// NewFromConfigFile creates a new etcdv3 client from a configuration file. +func NewFromConfigFile(path string) (*Client, error) { + cfg, err := configFromFile(path) + if err != nil { + return nil, err + } + return New(*cfg) +} + +// Close shuts down the client's etcd connections. +func (c *Client) Close() error { + c.cancel() + return toErr(c.ctx, c.conn.Close()) +} + +// Ctx is a context for "out of band" messages (e.g., for sending +// "clean up" message when another context is canceled). It is +// canceled on client Close(). +func (c *Client) Ctx() context.Context { return c.ctx } + +// Endpoints lists the registered endpoints for the client. +func (c *Client) Endpoints() []string { return c.cfg.Endpoints } + +type authTokenCredential struct { + token string +} + +func (cred authTokenCredential) RequireTransportSecurity() bool { + return false +} + +func (cred authTokenCredential) GetRequestMetadata(ctx context.Context, s ...string) (map[string]string, error) { + return map[string]string{ + "token": cred.token, + }, nil +} + +func (c *Client) dialTarget(endpoint string) (proto string, host string, creds *credentials.TransportCredentials) { + proto = "tcp" + host = endpoint + creds = c.creds + url, uerr := url.Parse(endpoint) + if uerr != nil || !strings.Contains(endpoint, "://") { + return + } + // strip scheme:// prefix since grpc dials by host + host = url.Host + switch url.Scheme { + case "unix": + proto = "unix" + case "http": + creds = nil + case "https": + if creds != nil { + break + } + tlsconfig := &tls.Config{} + emptyCreds := credentials.NewTLS(tlsconfig) + creds = &emptyCreds + default: + return "", "", nil + } + return +} + +// dialSetupOpts gives the dial opts prior to any authentication +func (c *Client) dialSetupOpts(endpoint string, dopts ...grpc.DialOption) (opts []grpc.DialOption) { + if c.cfg.DialTimeout > 0 { + opts = []grpc.DialOption{grpc.WithTimeout(c.cfg.DialTimeout)} + } + opts = append(opts, dopts...) + + // grpc issues TLS cert checks using the string passed into dial so + // that string must be the host. To recover the full scheme://host URL, + // have a map from hosts to the original endpoint. + host2ep := make(map[string]string) + for i := range c.cfg.Endpoints { + _, host, _ := c.dialTarget(c.cfg.Endpoints[i]) + host2ep[host] = c.cfg.Endpoints[i] + } + + f := func(host string, t time.Duration) (net.Conn, error) { + proto, host, _ := c.dialTarget(host2ep[host]) + if proto == "" { + return nil, fmt.Errorf("unknown scheme for %q", host) + } + select { + case <-c.ctx.Done(): + return nil, c.ctx.Err() + default: + } + return net.DialTimeout(proto, host, t) + } + opts = append(opts, grpc.WithDialer(f)) + + _, _, creds := c.dialTarget(endpoint) + if creds != nil { + opts = append(opts, grpc.WithTransportCredentials(*creds)) + } else { + opts = append(opts, grpc.WithInsecure()) + } + + return opts +} + +// Dial connects to a single endpoint using the client's config. +func (c *Client) Dial(endpoint string) (*grpc.ClientConn, error) { + return c.dial(endpoint) +} + +func (c *Client) dial(endpoint string, dopts ...grpc.DialOption) (*grpc.ClientConn, error) { + opts := c.dialSetupOpts(endpoint, dopts...) + host := getHost(endpoint) + if c.Username != "" && c.Password != "" { + // use dial options without dopts to avoid reusing the client balancer + auth, err := newAuthenticator(host, c.dialSetupOpts(endpoint)) + if err != nil { + return nil, err + } + defer auth.close() + + resp, err := auth.authenticate(c.ctx, c.Username, c.Password) + if err != nil { + return nil, err + } + opts = append(opts, grpc.WithPerRPCCredentials(authTokenCredential{token: resp.Token})) + } + + conn, err := grpc.Dial(host, opts...) + if err != nil { + return nil, err + } + return conn, nil +} + +// WithRequireLeader requires client requests to only succeed +// when the cluster has a leader. +func WithRequireLeader(ctx context.Context) context.Context { + md := metadata.Pairs(rpctypes.MetadataRequireLeaderKey, rpctypes.MetadataHasLeader) + return metadata.NewContext(ctx, md) +} + +func newClient(cfg *Config) (*Client, error) { + if cfg == nil { + cfg = &Config{} + } + var creds *credentials.TransportCredentials + if cfg.TLS != nil { + c := credentials.NewTLS(cfg.TLS) + creds = &c + } + + // use a temporary skeleton client to bootstrap first connection + ctx, cancel := context.WithCancel(context.TODO()) + client := &Client{ + conn: nil, + cfg: *cfg, + creds: creds, + ctx: ctx, + cancel: cancel, + } + if cfg.Username != "" && cfg.Password != "" { + client.Username = cfg.Username + client.Password = cfg.Password + } + + client.balancer = newSimpleBalancer(cfg.Endpoints) + conn, err := client.dial(cfg.Endpoints[0], grpc.WithBalancer(client.balancer)) + if err != nil { + return nil, err + } + client.conn = conn + client.retryWrapper = client.newRetryWrapper() + + // wait for a connection + if cfg.DialTimeout > 0 { + hasConn := false + waitc := time.After(cfg.DialTimeout) + select { + case <-client.balancer.readyc: + hasConn = true + case <-ctx.Done(): + case <-waitc: + } + if !hasConn { + client.cancel() + conn.Close() + return nil, grpc.ErrClientConnTimeout + } + } + + client.Cluster = NewCluster(client) + client.KV = NewKV(client) + client.Lease = NewLease(client) + client.Watcher = NewWatcher(client) + client.Auth = NewAuth(client) + client.Maintenance = NewMaintenance(client) + if cfg.Logger != nil { + logger.Set(cfg.Logger) + } else { + // disable client side grpc by default + logger.Set(log.New(ioutil.Discard, "", 0)) + } + + return client, nil +} + +// ActiveConnection returns the current in-use connection +func (c *Client) ActiveConnection() *grpc.ClientConn { return c.conn } + +// isHaltErr returns true if the given error and context indicate no forward +// progress can be made, even after reconnecting. +func isHaltErr(ctx context.Context, err error) bool { + if ctx != nil && ctx.Err() != nil { + return true + } + if err == nil { + return false + } + eErr := rpctypes.Error(err) + if _, ok := eErr.(rpctypes.EtcdError); ok { + return eErr != rpctypes.ErrStopped && eErr != rpctypes.ErrNoLeader + } + // treat etcdserver errors not recognized by the client as halting + return isConnClosing(err) || strings.Contains(err.Error(), "etcdserver:") +} + +// isConnClosing returns true if the error matches a grpc client closing error +func isConnClosing(err error) bool { + return strings.Contains(err.Error(), grpc.ErrClientConnClosing.Error()) +} + +func toErr(ctx context.Context, err error) error { + if err == nil { + return nil + } + err = rpctypes.Error(err) + switch { + case ctx.Err() != nil && strings.Contains(err.Error(), "context"): + err = ctx.Err() + case strings.Contains(err.Error(), ErrNoAvailableEndpoints.Error()): + err = ErrNoAvailableEndpoints + case strings.Contains(err.Error(), grpc.ErrClientConnClosing.Error()): + err = grpc.ErrClientConnClosing + } + return err +} diff --git a/vendor/github.com/coreos/etcd/clientv3/cluster.go b/vendor/github.com/coreos/etcd/clientv3/cluster.go new file mode 100644 index 00000000..8b981171 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/cluster.go @@ -0,0 +1,102 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + pb "github.com/coreos/etcd/etcdserver/etcdserverpb" + "golang.org/x/net/context" + "google.golang.org/grpc" +) + +type ( + Member pb.Member + MemberListResponse pb.MemberListResponse + MemberAddResponse pb.MemberAddResponse + MemberRemoveResponse pb.MemberRemoveResponse + MemberUpdateResponse pb.MemberUpdateResponse +) + +type Cluster interface { + // MemberList lists the current cluster membership. + MemberList(ctx context.Context) (*MemberListResponse, error) + + // MemberAdd adds a new member into the cluster. + MemberAdd(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error) + + // MemberRemove removes an existing member from the cluster. + MemberRemove(ctx context.Context, id uint64) (*MemberRemoveResponse, error) + + // MemberUpdate updates the peer addresses of the member. + MemberUpdate(ctx context.Context, id uint64, peerAddrs []string) (*MemberUpdateResponse, error) +} + +type cluster struct { + remote pb.ClusterClient +} + +func NewCluster(c *Client) Cluster { + return &cluster{remote: RetryClusterClient(c)} +} + +func (c *cluster) MemberAdd(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error) { + r := &pb.MemberAddRequest{PeerURLs: peerAddrs} + resp, err := c.remote.MemberAdd(ctx, r) + if err == nil { + return (*MemberAddResponse)(resp), nil + } + if isHaltErr(ctx, err) { + return nil, toErr(ctx, err) + } + return nil, toErr(ctx, err) +} + +func (c *cluster) MemberRemove(ctx context.Context, id uint64) (*MemberRemoveResponse, error) { + r := &pb.MemberRemoveRequest{ID: id} + resp, err := c.remote.MemberRemove(ctx, r) + if err == nil { + return (*MemberRemoveResponse)(resp), nil + } + if isHaltErr(ctx, err) { + return nil, toErr(ctx, err) + } + return nil, toErr(ctx, err) +} + +func (c *cluster) MemberUpdate(ctx context.Context, id uint64, peerAddrs []string) (*MemberUpdateResponse, error) { + // it is safe to retry on update. + for { + r := &pb.MemberUpdateRequest{ID: id, PeerURLs: peerAddrs} + resp, err := c.remote.MemberUpdate(ctx, r) + if err == nil { + return (*MemberUpdateResponse)(resp), nil + } + if isHaltErr(ctx, err) { + return nil, toErr(ctx, err) + } + } +} + +func (c *cluster) MemberList(ctx context.Context) (*MemberListResponse, error) { + // it is safe to retry on list. + for { + resp, err := c.remote.MemberList(ctx, &pb.MemberListRequest{}, grpc.FailFast(false)) + if err == nil { + return (*MemberListResponse)(resp), nil + } + if isHaltErr(ctx, err) { + return nil, toErr(ctx, err) + } + } +} diff --git a/vendor/github.com/coreos/etcd/clientv3/compact_op.go b/vendor/github.com/coreos/etcd/clientv3/compact_op.go new file mode 100644 index 00000000..32d97eb0 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/compact_op.go @@ -0,0 +1,53 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + pb "github.com/coreos/etcd/etcdserver/etcdserverpb" +) + +// CompactOp represents a compact operation. +type CompactOp struct { + revision int64 + physical bool +} + +// CompactOption configures compact operation. +type CompactOption func(*CompactOp) + +func (op *CompactOp) applyCompactOpts(opts []CompactOption) { + for _, opt := range opts { + opt(op) + } +} + +// OpCompact wraps slice CompactOption to create a CompactOp. +func OpCompact(rev int64, opts ...CompactOption) CompactOp { + ret := CompactOp{revision: rev} + ret.applyCompactOpts(opts) + return ret +} + +func (op CompactOp) toRequest() *pb.CompactionRequest { + return &pb.CompactionRequest{Revision: op.revision, Physical: op.physical} +} + +// WithCompactPhysical makes compact RPC call wait until +// the compaction is physically applied to the local database +// such that compacted entries are totally removed from the +// backend database. +func WithCompactPhysical() CompactOption { + return func(op *CompactOp) { op.physical = true } +} diff --git a/vendor/github.com/coreos/etcd/clientv3/compare.go b/vendor/github.com/coreos/etcd/clientv3/compare.go new file mode 100644 index 00000000..60134943 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/compare.go @@ -0,0 +1,91 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + pb "github.com/coreos/etcd/etcdserver/etcdserverpb" +) + +type CompareTarget int +type CompareResult int + +const ( + CompareVersion CompareTarget = iota + CompareCreated + CompareModified + CompareValue +) + +type Cmp pb.Compare + +func Compare(cmp Cmp, result string, v interface{}) Cmp { + var r pb.Compare_CompareResult + + switch result { + case "=": + r = pb.Compare_EQUAL + case ">": + r = pb.Compare_GREATER + case "<": + r = pb.Compare_LESS + default: + panic("Unknown result op") + } + + cmp.Result = r + switch cmp.Target { + case pb.Compare_VALUE: + val, ok := v.(string) + if !ok { + panic("bad compare value") + } + cmp.TargetUnion = &pb.Compare_Value{Value: []byte(val)} + case pb.Compare_VERSION: + cmp.TargetUnion = &pb.Compare_Version{Version: mustInt64(v)} + case pb.Compare_CREATE: + cmp.TargetUnion = &pb.Compare_CreateRevision{CreateRevision: mustInt64(v)} + case pb.Compare_MOD: + cmp.TargetUnion = &pb.Compare_ModRevision{ModRevision: mustInt64(v)} + default: + panic("Unknown compare type") + } + return cmp +} + +func Value(key string) Cmp { + return Cmp{Key: []byte(key), Target: pb.Compare_VALUE} +} + +func Version(key string) Cmp { + return Cmp{Key: []byte(key), Target: pb.Compare_VERSION} +} + +func CreateRevision(key string) Cmp { + return Cmp{Key: []byte(key), Target: pb.Compare_CREATE} +} + +func ModRevision(key string) Cmp { + return Cmp{Key: []byte(key), Target: pb.Compare_MOD} +} + +func mustInt64(val interface{}) int64 { + if v, ok := val.(int64); ok { + return v + } + if v, ok := val.(int); ok { + return int64(v) + } + panic("bad value") +} diff --git a/vendor/github.com/coreos/etcd/clientv3/config.go b/vendor/github.com/coreos/etcd/clientv3/config.go new file mode 100644 index 00000000..066b41ec --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/config.go @@ -0,0 +1,110 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + "crypto/tls" + "crypto/x509" + "io/ioutil" + "time" + + "github.com/coreos/etcd/pkg/tlsutil" + "github.com/ghodss/yaml" +) + +type Config struct { + // Endpoints is a list of URLs + Endpoints []string + + // DialTimeout is the timeout for failing to establish a connection. + DialTimeout time.Duration + + // TLS holds the client secure credentials, if any. + TLS *tls.Config + + // Logger is the logger used by client library. + Logger Logger + + // Username is a username for authentication + Username string + + // Password is a password for authentication + Password string +} + +type yamlConfig struct { + Endpoints []string `json:"endpoints"` + DialTimeout time.Duration `json:"dial-timeout"` + InsecureTransport bool `json:"insecure-transport"` + InsecureSkipTLSVerify bool `json:"insecure-skip-tls-verify"` + Certfile string `json:"cert-file"` + Keyfile string `json:"key-file"` + CAfile string `json:"ca-file"` +} + +func configFromFile(fpath string) (*Config, error) { + b, err := ioutil.ReadFile(fpath) + if err != nil { + return nil, err + } + + yc := &yamlConfig{} + + err = yaml.Unmarshal(b, yc) + if err != nil { + return nil, err + } + + cfg := &Config{ + Endpoints: yc.Endpoints, + DialTimeout: yc.DialTimeout, + } + + if yc.InsecureTransport { + cfg.TLS = nil + return cfg, nil + } + + var ( + cert *tls.Certificate + cp *x509.CertPool + ) + + if yc.Certfile != "" && yc.Keyfile != "" { + cert, err = tlsutil.NewCert(yc.Certfile, yc.Keyfile, nil) + if err != nil { + return nil, err + } + } + + if yc.CAfile != "" { + cp, err = tlsutil.NewCertPool([]string{yc.CAfile}) + if err != nil { + return nil, err + } + } + + tlscfg := &tls.Config{ + MinVersion: tls.VersionTLS10, + InsecureSkipVerify: yc.InsecureSkipTLSVerify, + RootCAs: cp, + } + if cert != nil { + tlscfg.Certificates = []tls.Certificate{*cert} + } + cfg.TLS = tlscfg + + return cfg, nil +} diff --git a/vendor/github.com/coreos/etcd/clientv3/doc.go b/vendor/github.com/coreos/etcd/clientv3/doc.go new file mode 100644 index 00000000..9ce84aa5 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/doc.go @@ -0,0 +1,64 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package clientv3 implements the official Go etcd client for v3. +// +// Create client using `clientv3.New`: +// +// cli, err := clientv3.New(clientv3.Config{ +// Endpoints: []string{"localhost:2379", "localhost:22379", "localhost:32379"}, +// DialTimeout: 5 * time.Second, +// }) +// if err != nil { +// // handle error! +// } +// defer cli.Close() +// +// Make sure to close the client after using it. If the client is not closed, the +// connection will have leaky goroutines. +// +// To specify client request timeout, pass context.WithTimeout to APIs: +// +// ctx, cancel := context.WithTimeout(context.Background(), timeout) +// resp, err := kvc.Put(ctx, "sample_key", "sample_value") +// cancel() +// if err != nil { +// // handle error! +// } +// // use the response +// +// The Client has internal state (watchers and leases), so Clients should be reused instead of created as needed. +// Clients are safe for concurrent use by multiple goroutines. +// +// etcd client returns 2 types of errors: +// +// 1. context error: canceled or deadline exceeded. +// 2. gRPC error: see https://github.com/coreos/etcd/blob/master/etcdserver/api/v3rpc/error.go. +// +// Here is the example code to handle client errors: +// +// resp, err := kvc.Put(ctx, "", "") +// if err != nil { +// if err == context.Canceled { +// // ctx is canceled by another routine +// } else if err == context.DeadlineExceeded { +// // ctx is attached with a deadline and it exceeded +// } else if verr, ok := err.(*v3rpc.ErrEmptyKey); ok { +// // process (verr.Errors) +// } else { +// // bad cluster endpoints, which are not etcd servers +// } +// } +// +package clientv3 diff --git a/vendor/github.com/coreos/etcd/clientv3/kv.go b/vendor/github.com/coreos/etcd/clientv3/kv.go new file mode 100644 index 00000000..a2bebe2a --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/kv.go @@ -0,0 +1,180 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + pb "github.com/coreos/etcd/etcdserver/etcdserverpb" + "golang.org/x/net/context" + "google.golang.org/grpc" +) + +type ( + CompactResponse pb.CompactionResponse + PutResponse pb.PutResponse + GetResponse pb.RangeResponse + DeleteResponse pb.DeleteRangeResponse + TxnResponse pb.TxnResponse +) + +type KV interface { + // Put puts a key-value pair into etcd. + // Note that key,value can be plain bytes array and string is + // an immutable representation of that bytes array. + // To get a string of bytes, do string([]byte(0x10, 0x20)). + Put(ctx context.Context, key, val string, opts ...OpOption) (*PutResponse, error) + + // Get retrieves keys. + // By default, Get will return the value for "key", if any. + // When passed WithRange(end), Get will return the keys in the range [key, end). + // When passed WithFromKey(), Get returns keys greater than or equal to key. + // When passed WithRev(rev) with rev > 0, Get retrieves keys at the given revision; + // if the required revision is compacted, the request will fail with ErrCompacted . + // When passed WithLimit(limit), the number of returned keys is bounded by limit. + // When passed WithSort(), the keys will be sorted. + Get(ctx context.Context, key string, opts ...OpOption) (*GetResponse, error) + + // Delete deletes a key, or optionally using WithRange(end), [key, end). + Delete(ctx context.Context, key string, opts ...OpOption) (*DeleteResponse, error) + + // Compact compacts etcd KV history before the given rev. + Compact(ctx context.Context, rev int64, opts ...CompactOption) (*CompactResponse, error) + + // Do applies a single Op on KV without a transaction. + // Do is useful when declaring operations to be issued at a later time + // whereas Get/Put/Delete are for better suited for when the operation + // should be immediately issued at time of declaration. + + // Do applies a single Op on KV without a transaction. + // Do is useful when creating arbitrary operations to be issued at a + // later time; the user can range over the operations, calling Do to + // execute them. Get/Put/Delete, on the other hand, are best suited + // for when the operation should be issued at the time of declaration. + Do(ctx context.Context, op Op) (OpResponse, error) + + // Txn creates a transaction. + Txn(ctx context.Context) Txn +} + +type OpResponse struct { + put *PutResponse + get *GetResponse + del *DeleteResponse +} + +func (op OpResponse) Put() *PutResponse { return op.put } +func (op OpResponse) Get() *GetResponse { return op.get } +func (op OpResponse) Del() *DeleteResponse { return op.del } + +type kv struct { + remote pb.KVClient +} + +func NewKV(c *Client) KV { + return &kv{remote: RetryKVClient(c)} +} + +func NewKVFromKVClient(remote pb.KVClient) KV { + return &kv{remote: remote} +} + +func (kv *kv) Put(ctx context.Context, key, val string, opts ...OpOption) (*PutResponse, error) { + r, err := kv.Do(ctx, OpPut(key, val, opts...)) + return r.put, toErr(ctx, err) +} + +func (kv *kv) Get(ctx context.Context, key string, opts ...OpOption) (*GetResponse, error) { + r, err := kv.Do(ctx, OpGet(key, opts...)) + return r.get, toErr(ctx, err) +} + +func (kv *kv) Delete(ctx context.Context, key string, opts ...OpOption) (*DeleteResponse, error) { + r, err := kv.Do(ctx, OpDelete(key, opts...)) + return r.del, toErr(ctx, err) +} + +func (kv *kv) Compact(ctx context.Context, rev int64, opts ...CompactOption) (*CompactResponse, error) { + resp, err := kv.remote.Compact(ctx, OpCompact(rev, opts...).toRequest(), grpc.FailFast(false)) + if err != nil { + return nil, toErr(ctx, err) + } + return (*CompactResponse)(resp), err +} + +func (kv *kv) Txn(ctx context.Context) Txn { + return &txn{ + kv: kv, + ctx: ctx, + } +} + +func (kv *kv) Do(ctx context.Context, op Op) (OpResponse, error) { + for { + resp, err := kv.do(ctx, op) + if err == nil { + return resp, nil + } + if isHaltErr(ctx, err) { + return resp, toErr(ctx, err) + } + // do not retry on modifications + if op.isWrite() { + return resp, toErr(ctx, err) + } + } +} + +func (kv *kv) do(ctx context.Context, op Op) (OpResponse, error) { + var err error + switch op.t { + // TODO: handle other ops + case tRange: + var resp *pb.RangeResponse + r := &pb.RangeRequest{ + Key: op.key, + RangeEnd: op.end, + Limit: op.limit, + Revision: op.rev, + Serializable: op.serializable, + KeysOnly: op.keysOnly, + CountOnly: op.countOnly, + } + if op.sort != nil { + r.SortOrder = pb.RangeRequest_SortOrder(op.sort.Order) + r.SortTarget = pb.RangeRequest_SortTarget(op.sort.Target) + } + + resp, err = kv.remote.Range(ctx, r, grpc.FailFast(false)) + if err == nil { + return OpResponse{get: (*GetResponse)(resp)}, nil + } + case tPut: + var resp *pb.PutResponse + r := &pb.PutRequest{Key: op.key, Value: op.val, Lease: int64(op.leaseID), PrevKv: op.prevKV} + resp, err = kv.remote.Put(ctx, r) + if err == nil { + return OpResponse{put: (*PutResponse)(resp)}, nil + } + case tDeleteRange: + var resp *pb.DeleteRangeResponse + r := &pb.DeleteRangeRequest{Key: op.key, RangeEnd: op.end, PrevKv: op.prevKV} + resp, err = kv.remote.DeleteRange(ctx, r) + if err == nil { + return OpResponse{del: (*DeleteResponse)(resp)}, nil + } + default: + panic("Unknown op") + } + return OpResponse{}, err +} diff --git a/vendor/github.com/coreos/etcd/clientv3/lease.go b/vendor/github.com/coreos/etcd/clientv3/lease.go new file mode 100644 index 00000000..e532ed46 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/lease.go @@ -0,0 +1,462 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + "sync" + "time" + + "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes" + pb "github.com/coreos/etcd/etcdserver/etcdserverpb" + "golang.org/x/net/context" + "google.golang.org/grpc" +) + +type ( + LeaseRevokeResponse pb.LeaseRevokeResponse + LeaseID int64 +) + +// LeaseGrantResponse is used to convert the protobuf grant response. +type LeaseGrantResponse struct { + *pb.ResponseHeader + ID LeaseID + TTL int64 + Error string +} + +// LeaseKeepAliveResponse is used to convert the protobuf keepalive response. +type LeaseKeepAliveResponse struct { + *pb.ResponseHeader + ID LeaseID + TTL int64 +} + +const ( + // defaultTTL is the assumed lease TTL used for the first keepalive + // deadline before the actual TTL is known to the client. + defaultTTL = 5 * time.Second + // a small buffer to store unsent lease responses. + leaseResponseChSize = 16 + // NoLease is a lease ID for the absence of a lease. + NoLease LeaseID = 0 +) + +type Lease interface { + // Grant creates a new lease. + Grant(ctx context.Context, ttl int64) (*LeaseGrantResponse, error) + + // Revoke revokes the given lease. + Revoke(ctx context.Context, id LeaseID) (*LeaseRevokeResponse, error) + + // KeepAlive keeps the given lease alive forever. + KeepAlive(ctx context.Context, id LeaseID) (<-chan *LeaseKeepAliveResponse, error) + + // KeepAliveOnce renews the lease once. In most of the cases, Keepalive + // should be used instead of KeepAliveOnce. + KeepAliveOnce(ctx context.Context, id LeaseID) (*LeaseKeepAliveResponse, error) + + // Close releases all resources Lease keeps for efficient communication + // with the etcd server. + Close() error +} + +type lessor struct { + mu sync.Mutex // guards all fields + + // donec is closed when recvKeepAliveLoop stops + donec chan struct{} + + remote pb.LeaseClient + + stream pb.Lease_LeaseKeepAliveClient + streamCancel context.CancelFunc + + stopCtx context.Context + stopCancel context.CancelFunc + + keepAlives map[LeaseID]*keepAlive + + // firstKeepAliveTimeout is the timeout for the first keepalive request + // before the actual TTL is known to the lease client + firstKeepAliveTimeout time.Duration +} + +// keepAlive multiplexes a keepalive for a lease over multiple channels +type keepAlive struct { + chs []chan<- *LeaseKeepAliveResponse + ctxs []context.Context + // deadline is the time the keep alive channels close if no response + deadline time.Time + // nextKeepAlive is when to send the next keep alive message + nextKeepAlive time.Time + // donec is closed on lease revoke, expiration, or cancel. + donec chan struct{} +} + +func NewLease(c *Client) Lease { + l := &lessor{ + donec: make(chan struct{}), + keepAlives: make(map[LeaseID]*keepAlive), + remote: RetryLeaseClient(c), + firstKeepAliveTimeout: c.cfg.DialTimeout + time.Second, + } + if l.firstKeepAliveTimeout == time.Second { + l.firstKeepAliveTimeout = defaultTTL + } + + l.stopCtx, l.stopCancel = context.WithCancel(context.Background()) + go l.recvKeepAliveLoop() + go l.deadlineLoop() + return l +} + +func (l *lessor) Grant(ctx context.Context, ttl int64) (*LeaseGrantResponse, error) { + cctx, cancel := context.WithCancel(ctx) + done := cancelWhenStop(cancel, l.stopCtx.Done()) + defer close(done) + + for { + r := &pb.LeaseGrantRequest{TTL: ttl} + resp, err := l.remote.LeaseGrant(cctx, r) + if err == nil { + gresp := &LeaseGrantResponse{ + ResponseHeader: resp.GetHeader(), + ID: LeaseID(resp.ID), + TTL: resp.TTL, + Error: resp.Error, + } + return gresp, nil + } + if isHaltErr(cctx, err) { + return nil, toErr(ctx, err) + } + if nerr := l.newStream(); nerr != nil { + return nil, nerr + } + } +} + +func (l *lessor) Revoke(ctx context.Context, id LeaseID) (*LeaseRevokeResponse, error) { + cctx, cancel := context.WithCancel(ctx) + done := cancelWhenStop(cancel, l.stopCtx.Done()) + defer close(done) + + for { + r := &pb.LeaseRevokeRequest{ID: int64(id)} + resp, err := l.remote.LeaseRevoke(cctx, r) + + if err == nil { + return (*LeaseRevokeResponse)(resp), nil + } + if isHaltErr(ctx, err) { + return nil, toErr(ctx, err) + } + if nerr := l.newStream(); nerr != nil { + return nil, nerr + } + } +} + +func (l *lessor) KeepAlive(ctx context.Context, id LeaseID) (<-chan *LeaseKeepAliveResponse, error) { + ch := make(chan *LeaseKeepAliveResponse, leaseResponseChSize) + + l.mu.Lock() + ka, ok := l.keepAlives[id] + if !ok { + // create fresh keep alive + ka = &keepAlive{ + chs: []chan<- *LeaseKeepAliveResponse{ch}, + ctxs: []context.Context{ctx}, + deadline: time.Now().Add(l.firstKeepAliveTimeout), + nextKeepAlive: time.Now(), + donec: make(chan struct{}), + } + l.keepAlives[id] = ka + } else { + // add channel and context to existing keep alive + ka.ctxs = append(ka.ctxs, ctx) + ka.chs = append(ka.chs, ch) + } + l.mu.Unlock() + + go l.keepAliveCtxCloser(id, ctx, ka.donec) + + return ch, nil +} + +func (l *lessor) KeepAliveOnce(ctx context.Context, id LeaseID) (*LeaseKeepAliveResponse, error) { + cctx, cancel := context.WithCancel(ctx) + done := cancelWhenStop(cancel, l.stopCtx.Done()) + defer close(done) + + for { + resp, err := l.keepAliveOnce(cctx, id) + if err == nil { + if resp.TTL == 0 { + err = rpctypes.ErrLeaseNotFound + } + return resp, err + } + if isHaltErr(ctx, err) { + return nil, toErr(ctx, err) + } + + if nerr := l.newStream(); nerr != nil { + return nil, nerr + } + } +} + +func (l *lessor) Close() error { + l.stopCancel() + <-l.donec + return nil +} + +func (l *lessor) keepAliveCtxCloser(id LeaseID, ctx context.Context, donec <-chan struct{}) { + select { + case <-donec: + return + case <-l.donec: + return + case <-ctx.Done(): + } + + l.mu.Lock() + defer l.mu.Unlock() + + ka, ok := l.keepAlives[id] + if !ok { + return + } + + // close channel and remove context if still associated with keep alive + for i, c := range ka.ctxs { + if c == ctx { + close(ka.chs[i]) + ka.ctxs = append(ka.ctxs[:i], ka.ctxs[i+1:]...) + ka.chs = append(ka.chs[:i], ka.chs[i+1:]...) + break + } + } + // remove if no one more listeners + if len(ka.chs) == 0 { + delete(l.keepAlives, id) + } +} + +func (l *lessor) keepAliveOnce(ctx context.Context, id LeaseID) (*LeaseKeepAliveResponse, error) { + cctx, cancel := context.WithCancel(ctx) + defer cancel() + + stream, err := l.remote.LeaseKeepAlive(cctx, grpc.FailFast(false)) + if err != nil { + return nil, toErr(ctx, err) + } + + err = stream.Send(&pb.LeaseKeepAliveRequest{ID: int64(id)}) + if err != nil { + return nil, toErr(ctx, err) + } + + resp, rerr := stream.Recv() + if rerr != nil { + return nil, toErr(ctx, rerr) + } + + karesp := &LeaseKeepAliveResponse{ + ResponseHeader: resp.GetHeader(), + ID: LeaseID(resp.ID), + TTL: resp.TTL, + } + return karesp, nil +} + +func (l *lessor) recvKeepAliveLoop() { + defer func() { + l.mu.Lock() + close(l.donec) + for _, ka := range l.keepAlives { + ka.Close() + } + l.keepAlives = make(map[LeaseID]*keepAlive) + l.mu.Unlock() + }() + + stream, serr := l.resetRecv() + for serr == nil { + resp, err := stream.Recv() + if err != nil { + if isHaltErr(l.stopCtx, err) { + return + } + stream, serr = l.resetRecv() + continue + } + l.recvKeepAlive(resp) + } +} + +// resetRecv opens a new lease stream and starts sending LeaseKeepAliveRequests +func (l *lessor) resetRecv() (pb.Lease_LeaseKeepAliveClient, error) { + if err := l.newStream(); err != nil { + return nil, err + } + stream := l.getKeepAliveStream() + go l.sendKeepAliveLoop(stream) + return stream, nil +} + +// recvKeepAlive updates a lease based on its LeaseKeepAliveResponse +func (l *lessor) recvKeepAlive(resp *pb.LeaseKeepAliveResponse) { + karesp := &LeaseKeepAliveResponse{ + ResponseHeader: resp.GetHeader(), + ID: LeaseID(resp.ID), + TTL: resp.TTL, + } + + l.mu.Lock() + defer l.mu.Unlock() + + ka, ok := l.keepAlives[karesp.ID] + if !ok { + return + } + + if karesp.TTL <= 0 { + // lease expired; close all keep alive channels + delete(l.keepAlives, karesp.ID) + ka.Close() + return + } + + // send update to all channels + nextKeepAlive := time.Now().Add(1 + time.Duration(karesp.TTL/3)*time.Second) + ka.deadline = time.Now().Add(time.Duration(karesp.TTL) * time.Second) + for _, ch := range ka.chs { + select { + case ch <- karesp: + ka.nextKeepAlive = nextKeepAlive + default: + } + } +} + +// deadlineLoop reaps any keep alive channels that have not received a response +// within the lease TTL +func (l *lessor) deadlineLoop() { + for { + select { + case <-time.After(time.Second): + case <-l.donec: + return + } + now := time.Now() + l.mu.Lock() + for id, ka := range l.keepAlives { + if ka.deadline.Before(now) { + // waited too long for response; lease may be expired + ka.Close() + delete(l.keepAlives, id) + } + } + l.mu.Unlock() + } +} + +// sendKeepAliveLoop sends LeaseKeepAliveRequests for the lifetime of a lease stream +func (l *lessor) sendKeepAliveLoop(stream pb.Lease_LeaseKeepAliveClient) { + for { + select { + case <-time.After(500 * time.Millisecond): + case <-stream.Context().Done(): + return + case <-l.donec: + return + case <-l.stopCtx.Done(): + return + } + + var tosend []LeaseID + + now := time.Now() + l.mu.Lock() + for id, ka := range l.keepAlives { + if ka.nextKeepAlive.Before(now) { + tosend = append(tosend, id) + } + } + l.mu.Unlock() + + for _, id := range tosend { + r := &pb.LeaseKeepAliveRequest{ID: int64(id)} + if err := stream.Send(r); err != nil { + // TODO do something with this error? + return + } + } + } +} + +func (l *lessor) getKeepAliveStream() pb.Lease_LeaseKeepAliveClient { + l.mu.Lock() + defer l.mu.Unlock() + return l.stream +} + +func (l *lessor) newStream() error { + sctx, cancel := context.WithCancel(l.stopCtx) + stream, err := l.remote.LeaseKeepAlive(sctx, grpc.FailFast(false)) + if err != nil { + cancel() + return toErr(sctx, err) + } + + l.mu.Lock() + defer l.mu.Unlock() + if l.stream != nil && l.streamCancel != nil { + l.stream.CloseSend() + l.streamCancel() + } + + l.streamCancel = cancel + l.stream = stream + return nil +} + +func (ka *keepAlive) Close() { + close(ka.donec) + for _, ch := range ka.chs { + close(ch) + } +} + +// cancelWhenStop calls cancel when the given stopc fires. It returns a done chan. done +// should be closed when the work is finished. When done fires, cancelWhenStop will release +// its internal resource. +func cancelWhenStop(cancel context.CancelFunc, stopc <-chan struct{}) chan<- struct{} { + done := make(chan struct{}, 1) + + go func() { + select { + case <-stopc: + case <-done: + } + cancel() + }() + + return done +} diff --git a/vendor/github.com/coreos/etcd/clientv3/logger.go b/vendor/github.com/coreos/etcd/clientv3/logger.go new file mode 100644 index 00000000..6e57c4e7 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/logger.go @@ -0,0 +1,64 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + "log" + "os" + "sync" + + "google.golang.org/grpc/grpclog" +) + +type Logger grpclog.Logger + +var ( + logger settableLogger +) + +type settableLogger struct { + l grpclog.Logger + mu sync.RWMutex +} + +func init() { + // use go's standard logger by default like grpc + logger.mu.Lock() + logger.l = log.New(os.Stderr, "", log.LstdFlags) + grpclog.SetLogger(&logger) + logger.mu.Unlock() +} + +func (s *settableLogger) Set(l Logger) { + s.mu.Lock() + logger.l = l + s.mu.Unlock() +} + +func (s *settableLogger) Get() Logger { + s.mu.RLock() + l := logger.l + s.mu.RUnlock() + return l +} + +// implement the grpclog.Logger interface + +func (s *settableLogger) Fatal(args ...interface{}) { s.Get().Fatal(args...) } +func (s *settableLogger) Fatalf(format string, args ...interface{}) { s.Get().Fatalf(format, args...) } +func (s *settableLogger) Fatalln(args ...interface{}) { s.Get().Fatalln(args...) } +func (s *settableLogger) Print(args ...interface{}) { s.Get().Print(args...) } +func (s *settableLogger) Printf(format string, args ...interface{}) { s.Get().Printf(format, args...) } +func (s *settableLogger) Println(args ...interface{}) { s.Get().Println(args...) } diff --git a/vendor/github.com/coreos/etcd/clientv3/maintenance.go b/vendor/github.com/coreos/etcd/clientv3/maintenance.go new file mode 100644 index 00000000..71835625 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/maintenance.go @@ -0,0 +1,164 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + "io" + + pb "github.com/coreos/etcd/etcdserver/etcdserverpb" + "golang.org/x/net/context" + "google.golang.org/grpc" +) + +type ( + DefragmentResponse pb.DefragmentResponse + AlarmResponse pb.AlarmResponse + AlarmMember pb.AlarmMember + StatusResponse pb.StatusResponse +) + +type Maintenance interface { + // AlarmList gets all active alarms. + AlarmList(ctx context.Context) (*AlarmResponse, error) + + // AlarmDisarm disarms a given alarm. + AlarmDisarm(ctx context.Context, m *AlarmMember) (*AlarmResponse, error) + + // Defragment defragments storage backend of the etcd member with given endpoint. + // Defragment is only needed when deleting a large number of keys and want to reclaim + // the resources. + // Defragment is an expensive operation. User should avoid defragmenting multiple members + // at the same time. + // To defragment multiple members in the cluster, user need to call defragment multiple + // times with different endpoints. + Defragment(ctx context.Context, endpoint string) (*DefragmentResponse, error) + + // Status gets the status of the endpoint. + Status(ctx context.Context, endpoint string) (*StatusResponse, error) + + // Snapshot provides a reader for a snapshot of a backend. + Snapshot(ctx context.Context) (io.ReadCloser, error) +} + +type maintenance struct { + c *Client + remote pb.MaintenanceClient +} + +func NewMaintenance(c *Client) Maintenance { + return &maintenance{c: c, remote: pb.NewMaintenanceClient(c.conn)} +} + +func (m *maintenance) AlarmList(ctx context.Context) (*AlarmResponse, error) { + req := &pb.AlarmRequest{ + Action: pb.AlarmRequest_GET, + MemberID: 0, // all + Alarm: pb.AlarmType_NONE, // all + } + for { + resp, err := m.remote.Alarm(ctx, req, grpc.FailFast(false)) + if err == nil { + return (*AlarmResponse)(resp), nil + } + if isHaltErr(ctx, err) { + return nil, toErr(ctx, err) + } + } +} + +func (m *maintenance) AlarmDisarm(ctx context.Context, am *AlarmMember) (*AlarmResponse, error) { + req := &pb.AlarmRequest{ + Action: pb.AlarmRequest_DEACTIVATE, + MemberID: am.MemberID, + Alarm: am.Alarm, + } + + if req.MemberID == 0 && req.Alarm == pb.AlarmType_NONE { + ar, err := m.AlarmList(ctx) + if err != nil { + return nil, toErr(ctx, err) + } + ret := AlarmResponse{} + for _, am := range ar.Alarms { + dresp, derr := m.AlarmDisarm(ctx, (*AlarmMember)(am)) + if derr != nil { + return nil, toErr(ctx, derr) + } + ret.Alarms = append(ret.Alarms, dresp.Alarms...) + } + return &ret, nil + } + + resp, err := m.remote.Alarm(ctx, req, grpc.FailFast(false)) + if err == nil { + return (*AlarmResponse)(resp), nil + } + return nil, toErr(ctx, err) +} + +func (m *maintenance) Defragment(ctx context.Context, endpoint string) (*DefragmentResponse, error) { + conn, err := m.c.Dial(endpoint) + if err != nil { + return nil, toErr(ctx, err) + } + defer conn.Close() + remote := pb.NewMaintenanceClient(conn) + resp, err := remote.Defragment(ctx, &pb.DefragmentRequest{}, grpc.FailFast(false)) + if err != nil { + return nil, toErr(ctx, err) + } + return (*DefragmentResponse)(resp), nil +} + +func (m *maintenance) Status(ctx context.Context, endpoint string) (*StatusResponse, error) { + conn, err := m.c.Dial(endpoint) + if err != nil { + return nil, toErr(ctx, err) + } + defer conn.Close() + remote := pb.NewMaintenanceClient(conn) + resp, err := remote.Status(ctx, &pb.StatusRequest{}, grpc.FailFast(false)) + if err != nil { + return nil, toErr(ctx, err) + } + return (*StatusResponse)(resp), nil +} + +func (m *maintenance) Snapshot(ctx context.Context) (io.ReadCloser, error) { + ss, err := m.remote.Snapshot(ctx, &pb.SnapshotRequest{}, grpc.FailFast(false)) + if err != nil { + return nil, toErr(ctx, err) + } + + pr, pw := io.Pipe() + go func() { + for { + resp, err := ss.Recv() + if err != nil { + pw.CloseWithError(err) + return + } + if resp == nil && err == nil { + break + } + if _, werr := pw.Write(resp.Blob); werr != nil { + pw.CloseWithError(werr) + return + } + } + pw.Close() + }() + return pr, nil +} diff --git a/vendor/github.com/coreos/etcd/clientv3/op.go b/vendor/github.com/coreos/etcd/clientv3/op.go new file mode 100644 index 00000000..cadea1f8 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/op.go @@ -0,0 +1,322 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import pb "github.com/coreos/etcd/etcdserver/etcdserverpb" + +type opType int + +const ( + // A default Op has opType 0, which is invalid. + tRange opType = iota + 1 + tPut + tDeleteRange +) + +var ( + noPrefixEnd = []byte{0} +) + +// Op represents an Operation that kv can execute. +type Op struct { + t opType + key []byte + end []byte + + // for range + limit int64 + sort *SortOption + serializable bool + keysOnly bool + countOnly bool + + // for range, watch + rev int64 + + // for watch, put, delete + prevKV bool + + // progressNotify is for progress updates. + progressNotify bool + // createdNotify is for created event + createdNotify bool + // filters for watchers + filterPut bool + filterDelete bool + + // for put + val []byte + leaseID LeaseID +} + +func (op Op) toRequestOp() *pb.RequestOp { + switch op.t { + case tRange: + r := &pb.RangeRequest{ + Key: op.key, + RangeEnd: op.end, + Limit: op.limit, + Revision: op.rev, + Serializable: op.serializable, + KeysOnly: op.keysOnly, + CountOnly: op.countOnly, + } + if op.sort != nil { + r.SortOrder = pb.RangeRequest_SortOrder(op.sort.Order) + r.SortTarget = pb.RangeRequest_SortTarget(op.sort.Target) + } + return &pb.RequestOp{Request: &pb.RequestOp_RequestRange{RequestRange: r}} + case tPut: + r := &pb.PutRequest{Key: op.key, Value: op.val, Lease: int64(op.leaseID), PrevKv: op.prevKV} + return &pb.RequestOp{Request: &pb.RequestOp_RequestPut{RequestPut: r}} + case tDeleteRange: + r := &pb.DeleteRangeRequest{Key: op.key, RangeEnd: op.end, PrevKv: op.prevKV} + + return &pb.RequestOp{Request: &pb.RequestOp_RequestDeleteRange{RequestDeleteRange: r}} + default: + panic("Unknown Op") + } +} + +func (op Op) isWrite() bool { + return op.t != tRange +} + +func OpGet(key string, opts ...OpOption) Op { + ret := Op{t: tRange, key: []byte(key)} + ret.applyOpts(opts) + return ret +} + +func OpDelete(key string, opts ...OpOption) Op { + ret := Op{t: tDeleteRange, key: []byte(key)} + ret.applyOpts(opts) + switch { + case ret.leaseID != 0: + panic("unexpected lease in delete") + case ret.limit != 0: + panic("unexpected limit in delete") + case ret.rev != 0: + panic("unexpected revision in delete") + case ret.sort != nil: + panic("unexpected sort in delete") + case ret.serializable: + panic("unexpected serializable in delete") + case ret.countOnly: + panic("unexpected countOnly in delete") + case ret.filterDelete, ret.filterPut: + panic("unexpected filter in delete") + case ret.createdNotify: + panic("unexpected createdNotify in delete") + } + return ret +} + +func OpPut(key, val string, opts ...OpOption) Op { + ret := Op{t: tPut, key: []byte(key), val: []byte(val)} + ret.applyOpts(opts) + switch { + case ret.end != nil: + panic("unexpected range in put") + case ret.limit != 0: + panic("unexpected limit in put") + case ret.rev != 0: + panic("unexpected revision in put") + case ret.sort != nil: + panic("unexpected sort in put") + case ret.serializable: + panic("unexpected serializable in put") + case ret.countOnly: + panic("unexpected countOnly in put") + case ret.filterDelete, ret.filterPut: + panic("unexpected filter in put") + case ret.createdNotify: + panic("unexpected createdNotify in put") + } + return ret +} + +func opWatch(key string, opts ...OpOption) Op { + ret := Op{t: tRange, key: []byte(key)} + ret.applyOpts(opts) + switch { + case ret.leaseID != 0: + panic("unexpected lease in watch") + case ret.limit != 0: + panic("unexpected limit in watch") + case ret.sort != nil: + panic("unexpected sort in watch") + case ret.serializable: + panic("unexpected serializable in watch") + case ret.countOnly: + panic("unexpected countOnly in watch") + } + return ret +} + +func (op *Op) applyOpts(opts []OpOption) { + for _, opt := range opts { + opt(op) + } +} + +// OpOption configures Operations like Get, Put, Delete. +type OpOption func(*Op) + +// WithLease attaches a lease ID to a key in 'Put' request. +func WithLease(leaseID LeaseID) OpOption { + return func(op *Op) { op.leaseID = leaseID } +} + +// WithLimit limits the number of results to return from 'Get' request. +func WithLimit(n int64) OpOption { return func(op *Op) { op.limit = n } } + +// WithRev specifies the store revision for 'Get' request. +// Or the start revision of 'Watch' request. +func WithRev(rev int64) OpOption { return func(op *Op) { op.rev = rev } } + +// WithSort specifies the ordering in 'Get' request. It requires +// 'WithRange' and/or 'WithPrefix' to be specified too. +// 'target' specifies the target to sort by: key, version, revisions, value. +// 'order' can be either 'SortNone', 'SortAscend', 'SortDescend'. +func WithSort(target SortTarget, order SortOrder) OpOption { + return func(op *Op) { + if target == SortByKey && order == SortAscend { + // If order != SortNone, server fetches the entire key-space, + // and then applies the sort and limit, if provided. + // Since current mvcc.Range implementation returns results + // sorted by keys in lexiographically ascending order, + // client should ignore SortOrder if the target is SortByKey. + order = SortNone + } + op.sort = &SortOption{target, order} + } +} + +// GetPrefixRangeEnd gets the range end of the prefix. +// 'Get(foo, WithPrefix())' is equal to 'Get(foo, WithRange(GetPrefixRangeEnd(foo))'. +func GetPrefixRangeEnd(prefix string) string { + return string(getPrefix([]byte(prefix))) +} + +func getPrefix(key []byte) []byte { + end := make([]byte, len(key)) + copy(end, key) + for i := len(end) - 1; i >= 0; i-- { + if end[i] < 0xff { + end[i] = end[i] + 1 + end = end[:i+1] + return end + } + } + // next prefix does not exist (e.g., 0xffff); + // default to WithFromKey policy + return noPrefixEnd +} + +// WithPrefix enables 'Get', 'Delete', or 'Watch' requests to operate +// on the keys with matching prefix. For example, 'Get(foo, WithPrefix())' +// can return 'foo1', 'foo2', and so on. +func WithPrefix() OpOption { + return func(op *Op) { + op.end = getPrefix(op.key) + } +} + +// WithRange specifies the range of 'Get' or 'Delete' requests. +// For example, 'Get' requests with 'WithRange(end)' returns +// the keys in the range [key, end). +func WithRange(endKey string) OpOption { + return func(op *Op) { op.end = []byte(endKey) } +} + +// WithFromKey specifies the range of 'Get' or 'Delete' requests +// to be equal or greater than the key in the argument. +func WithFromKey() OpOption { return WithRange("\x00") } + +// WithSerializable makes 'Get' request serializable. By default, +// it's linearizable. Serializable requests are better for lower latency +// requirement. +func WithSerializable() OpOption { + return func(op *Op) { op.serializable = true } +} + +// WithKeysOnly makes the 'Get' request return only the keys and the corresponding +// values will be omitted. +func WithKeysOnly() OpOption { + return func(op *Op) { op.keysOnly = true } +} + +// WithCountOnly makes the 'Get' request return only the count of keys. +func WithCountOnly() OpOption { + return func(op *Op) { op.countOnly = true } +} + +// WithFirstCreate gets the key with the oldest creation revision in the request range. +func WithFirstCreate() []OpOption { return withTop(SortByCreateRevision, SortAscend) } + +// WithLastCreate gets the key with the latest creation revision in the request range. +func WithLastCreate() []OpOption { return withTop(SortByCreateRevision, SortDescend) } + +// WithFirstKey gets the lexically first key in the request range. +func WithFirstKey() []OpOption { return withTop(SortByKey, SortAscend) } + +// WithLastKey gets the lexically last key in the request range. +func WithLastKey() []OpOption { return withTop(SortByKey, SortDescend) } + +// WithFirstRev gets the key with the oldest modification revision in the request range. +func WithFirstRev() []OpOption { return withTop(SortByModRevision, SortAscend) } + +// WithLastRev gets the key with the latest modification revision in the request range. +func WithLastRev() []OpOption { return withTop(SortByModRevision, SortDescend) } + +// withTop gets the first key over the get's prefix given a sort order +func withTop(target SortTarget, order SortOrder) []OpOption { + return []OpOption{WithPrefix(), WithSort(target, order), WithLimit(1)} +} + +// WithProgressNotify makes watch server send periodic progress updates +// every 10 minutes when there is no incoming events. +// Progress updates have zero events in WatchResponse. +func WithProgressNotify() OpOption { + return func(op *Op) { + op.progressNotify = true + } +} + +// WithCreatedNotify makes watch server sends the created event. +func WithCreatedNotify() OpOption { + return func(op *Op) { + op.createdNotify = true + } +} + +// WithFilterPut discards PUT events from the watcher. +func WithFilterPut() OpOption { + return func(op *Op) { op.filterPut = true } +} + +// WithFilterDelete discards DELETE events from the watcher. +func WithFilterDelete() OpOption { + return func(op *Op) { op.filterDelete = true } +} + +// WithPrevKV gets the previous key-value pair before the event happens. If the previous KV is already compacted, +// nothing will be returned. +func WithPrevKV() OpOption { + return func(op *Op) { + op.prevKV = true + } +} diff --git a/vendor/github.com/coreos/etcd/clientv3/retry.go b/vendor/github.com/coreos/etcd/clientv3/retry.go new file mode 100644 index 00000000..3029ed8e --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/retry.go @@ -0,0 +1,243 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + pb "github.com/coreos/etcd/etcdserver/etcdserverpb" + "golang.org/x/net/context" + "google.golang.org/grpc" +) + +type rpcFunc func(ctx context.Context) error +type retryRpcFunc func(context.Context, rpcFunc) + +func (c *Client) newRetryWrapper() retryRpcFunc { + return func(rpcCtx context.Context, f rpcFunc) { + for { + err := f(rpcCtx) + // ignore grpc conn closing on fail-fast calls; they are transient errors + if err == nil || !isConnClosing(err) { + return + } + select { + case <-c.balancer.ConnectNotify(): + case <-rpcCtx.Done(): + case <-c.ctx.Done(): + return + } + } + } +} + +type retryKVClient struct { + pb.KVClient + retryf retryRpcFunc +} + +// RetryKVClient implements a KVClient that uses the client's FailFast retry policy. +func RetryKVClient(c *Client) pb.KVClient { + return &retryKVClient{pb.NewKVClient(c.conn), c.retryWrapper} +} + +func (rkv *retryKVClient) Put(ctx context.Context, in *pb.PutRequest, opts ...grpc.CallOption) (resp *pb.PutResponse, err error) { + rkv.retryf(ctx, func(rctx context.Context) error { + resp, err = rkv.KVClient.Put(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rkv *retryKVClient) DeleteRange(ctx context.Context, in *pb.DeleteRangeRequest, opts ...grpc.CallOption) (resp *pb.DeleteRangeResponse, err error) { + rkv.retryf(ctx, func(rctx context.Context) error { + resp, err = rkv.KVClient.DeleteRange(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rkv *retryKVClient) Txn(ctx context.Context, in *pb.TxnRequest, opts ...grpc.CallOption) (resp *pb.TxnResponse, err error) { + rkv.retryf(ctx, func(rctx context.Context) error { + resp, err = rkv.KVClient.Txn(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rkv *retryKVClient) Compact(ctx context.Context, in *pb.CompactionRequest, opts ...grpc.CallOption) (resp *pb.CompactionResponse, err error) { + rkv.retryf(ctx, func(rctx context.Context) error { + resp, err = rkv.KVClient.Compact(rctx, in, opts...) + return err + }) + return resp, err +} + +type retryLeaseClient struct { + pb.LeaseClient + retryf retryRpcFunc +} + +// RetryLeaseClient implements a LeaseClient that uses the client's FailFast retry policy. +func RetryLeaseClient(c *Client) pb.LeaseClient { + return &retryLeaseClient{pb.NewLeaseClient(c.conn), c.retryWrapper} +} + +func (rlc *retryLeaseClient) LeaseGrant(ctx context.Context, in *pb.LeaseGrantRequest, opts ...grpc.CallOption) (resp *pb.LeaseGrantResponse, err error) { + rlc.retryf(ctx, func(rctx context.Context) error { + resp, err = rlc.LeaseClient.LeaseGrant(rctx, in, opts...) + return err + }) + return resp, err + +} + +func (rlc *retryLeaseClient) LeaseRevoke(ctx context.Context, in *pb.LeaseRevokeRequest, opts ...grpc.CallOption) (resp *pb.LeaseRevokeResponse, err error) { + rlc.retryf(ctx, func(rctx context.Context) error { + resp, err = rlc.LeaseClient.LeaseRevoke(rctx, in, opts...) + return err + }) + return resp, err +} + +type retryClusterClient struct { + pb.ClusterClient + retryf retryRpcFunc +} + +// RetryClusterClient implements a ClusterClient that uses the client's FailFast retry policy. +func RetryClusterClient(c *Client) pb.ClusterClient { + return &retryClusterClient{pb.NewClusterClient(c.conn), c.retryWrapper} +} + +func (rcc *retryClusterClient) MemberAdd(ctx context.Context, in *pb.MemberAddRequest, opts ...grpc.CallOption) (resp *pb.MemberAddResponse, err error) { + rcc.retryf(ctx, func(rctx context.Context) error { + resp, err = rcc.ClusterClient.MemberAdd(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rcc *retryClusterClient) MemberRemove(ctx context.Context, in *pb.MemberRemoveRequest, opts ...grpc.CallOption) (resp *pb.MemberRemoveResponse, err error) { + rcc.retryf(ctx, func(rctx context.Context) error { + resp, err = rcc.ClusterClient.MemberRemove(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rcc *retryClusterClient) MemberUpdate(ctx context.Context, in *pb.MemberUpdateRequest, opts ...grpc.CallOption) (resp *pb.MemberUpdateResponse, err error) { + rcc.retryf(ctx, func(rctx context.Context) error { + resp, err = rcc.ClusterClient.MemberUpdate(rctx, in, opts...) + return err + }) + return resp, err +} + +type retryAuthClient struct { + pb.AuthClient + retryf retryRpcFunc +} + +// RetryAuthClient implements a AuthClient that uses the client's FailFast retry policy. +func RetryAuthClient(c *Client) pb.AuthClient { + return &retryAuthClient{pb.NewAuthClient(c.conn), c.retryWrapper} +} + +func (rac *retryAuthClient) AuthEnable(ctx context.Context, in *pb.AuthEnableRequest, opts ...grpc.CallOption) (resp *pb.AuthEnableResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.AuthEnable(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rac *retryAuthClient) AuthDisable(ctx context.Context, in *pb.AuthDisableRequest, opts ...grpc.CallOption) (resp *pb.AuthDisableResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.AuthDisable(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rac *retryAuthClient) UserAdd(ctx context.Context, in *pb.AuthUserAddRequest, opts ...grpc.CallOption) (resp *pb.AuthUserAddResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.UserAdd(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rac *retryAuthClient) UserDelete(ctx context.Context, in *pb.AuthUserDeleteRequest, opts ...grpc.CallOption) (resp *pb.AuthUserDeleteResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.UserDelete(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rac *retryAuthClient) UserChangePassword(ctx context.Context, in *pb.AuthUserChangePasswordRequest, opts ...grpc.CallOption) (resp *pb.AuthUserChangePasswordResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.UserChangePassword(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rac *retryAuthClient) UserGrantRole(ctx context.Context, in *pb.AuthUserGrantRoleRequest, opts ...grpc.CallOption) (resp *pb.AuthUserGrantRoleResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.UserGrantRole(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rac *retryAuthClient) UserRevokeRole(ctx context.Context, in *pb.AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (resp *pb.AuthUserRevokeRoleResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.UserRevokeRole(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rac *retryAuthClient) RoleAdd(ctx context.Context, in *pb.AuthRoleAddRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleAddResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.RoleAdd(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rac *retryAuthClient) RoleDelete(ctx context.Context, in *pb.AuthRoleDeleteRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleDeleteResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.RoleDelete(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rac *retryAuthClient) RoleGrantPermission(ctx context.Context, in *pb.AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleGrantPermissionResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.RoleGrantPermission(rctx, in, opts...) + return err + }) + return resp, err +} + +func (rac *retryAuthClient) RoleRevokePermission(ctx context.Context, in *pb.AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleRevokePermissionResponse, err error) { + rac.retryf(ctx, func(rctx context.Context) error { + resp, err = rac.AuthClient.RoleRevokePermission(rctx, in, opts...) + return err + }) + return resp, err +} diff --git a/vendor/github.com/coreos/etcd/clientv3/sort.go b/vendor/github.com/coreos/etcd/clientv3/sort.go new file mode 100644 index 00000000..2bb9d9a1 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/sort.go @@ -0,0 +1,37 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +type SortTarget int +type SortOrder int + +const ( + SortNone SortOrder = iota + SortAscend + SortDescend +) + +const ( + SortByKey SortTarget = iota + SortByVersion + SortByCreateRevision + SortByModRevision + SortByValue +) + +type SortOption struct { + Target SortTarget + Order SortOrder +} diff --git a/vendor/github.com/coreos/etcd/clientv3/txn.go b/vendor/github.com/coreos/etcd/clientv3/txn.go new file mode 100644 index 00000000..a451e33a --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/txn.go @@ -0,0 +1,160 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + "sync" + + pb "github.com/coreos/etcd/etcdserver/etcdserverpb" + "golang.org/x/net/context" +) + +// Txn is the interface that wraps mini-transactions. +// +// Tx.If( +// Compare(Value(k1), ">", v1), +// Compare(Version(k1), "=", 2) +// ).Then( +// OpPut(k2,v2), OpPut(k3,v3) +// ).Else( +// OpPut(k4,v4), OpPut(k5,v5) +// ).Commit() +// +type Txn interface { + // If takes a list of comparison. If all comparisons passed in succeed, + // the operations passed into Then() will be executed. Or the operations + // passed into Else() will be executed. + If(cs ...Cmp) Txn + + // Then takes a list of operations. The Ops list will be executed, if the + // comparisons passed in If() succeed. + Then(ops ...Op) Txn + + // Else takes a list of operations. The Ops list will be executed, if the + // comparisons passed in If() fail. + Else(ops ...Op) Txn + + // Commit tries to commit the transaction. + Commit() (*TxnResponse, error) + + // TODO: add a Do for shortcut the txn without any condition? +} + +type txn struct { + kv *kv + ctx context.Context + + mu sync.Mutex + cif bool + cthen bool + celse bool + + isWrite bool + + cmps []*pb.Compare + + sus []*pb.RequestOp + fas []*pb.RequestOp +} + +func (txn *txn) If(cs ...Cmp) Txn { + txn.mu.Lock() + defer txn.mu.Unlock() + + if txn.cif { + panic("cannot call If twice!") + } + + if txn.cthen { + panic("cannot call If after Then!") + } + + if txn.celse { + panic("cannot call If after Else!") + } + + txn.cif = true + + for i := range cs { + txn.cmps = append(txn.cmps, (*pb.Compare)(&cs[i])) + } + + return txn +} + +func (txn *txn) Then(ops ...Op) Txn { + txn.mu.Lock() + defer txn.mu.Unlock() + + if txn.cthen { + panic("cannot call Then twice!") + } + if txn.celse { + panic("cannot call Then after Else!") + } + + txn.cthen = true + + for _, op := range ops { + txn.isWrite = txn.isWrite || op.isWrite() + txn.sus = append(txn.sus, op.toRequestOp()) + } + + return txn +} + +func (txn *txn) Else(ops ...Op) Txn { + txn.mu.Lock() + defer txn.mu.Unlock() + + if txn.celse { + panic("cannot call Else twice!") + } + + txn.celse = true + + for _, op := range ops { + txn.isWrite = txn.isWrite || op.isWrite() + txn.fas = append(txn.fas, op.toRequestOp()) + } + + return txn +} + +func (txn *txn) Commit() (*TxnResponse, error) { + txn.mu.Lock() + defer txn.mu.Unlock() + for { + resp, err := txn.commit() + if err == nil { + return resp, err + } + if isHaltErr(txn.ctx, err) { + return nil, toErr(txn.ctx, err) + } + if txn.isWrite { + return nil, toErr(txn.ctx, err) + } + } +} + +func (txn *txn) commit() (*TxnResponse, error) { + r := &pb.TxnRequest{Compare: txn.cmps, Success: txn.sus, Failure: txn.fas} + resp, err := txn.kv.remote.Txn(txn.ctx, r) + if err != nil { + return nil, err + } + return (*TxnResponse)(resp), nil +} diff --git a/vendor/github.com/coreos/etcd/clientv3/watch.go b/vendor/github.com/coreos/etcd/clientv3/watch.go new file mode 100644 index 00000000..6dd14905 --- /dev/null +++ b/vendor/github.com/coreos/etcd/clientv3/watch.go @@ -0,0 +1,755 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package clientv3 + +import ( + "fmt" + "sync" + "time" + + v3rpc "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes" + pb "github.com/coreos/etcd/etcdserver/etcdserverpb" + mvccpb "github.com/coreos/etcd/mvcc/mvccpb" + "golang.org/x/net/context" + "google.golang.org/grpc" +) + +const ( + EventTypeDelete = mvccpb.DELETE + EventTypePut = mvccpb.PUT + + closeSendErrTimeout = 250 * time.Millisecond +) + +type Event mvccpb.Event + +type WatchChan <-chan WatchResponse + +type Watcher interface { + // Watch watches on a key or prefix. The watched events will be returned + // through the returned channel. + // If the watch is slow or the required rev is compacted, the watch request + // might be canceled from the server-side and the chan will be closed. + // 'opts' can be: 'WithRev' and/or 'WithPrefix'. + Watch(ctx context.Context, key string, opts ...OpOption) WatchChan + + // Close closes the watcher and cancels all watch requests. + Close() error +} + +type WatchResponse struct { + Header pb.ResponseHeader + Events []*Event + + // CompactRevision is the minimum revision the watcher may receive. + CompactRevision int64 + + // Canceled is used to indicate watch failure. + // If the watch failed and the stream was about to close, before the channel is closed, + // the channel sends a final response that has Canceled set to true with a non-nil Err(). + Canceled bool + + // Created is used to indicate the creation of the watcher. + Created bool + + closeErr error +} + +// IsCreate returns true if the event tells that the key is newly created. +func (e *Event) IsCreate() bool { + return e.Type == EventTypePut && e.Kv.CreateRevision == e.Kv.ModRevision +} + +// IsModify returns true if the event tells that a new value is put on existing key. +func (e *Event) IsModify() bool { + return e.Type == EventTypePut && e.Kv.CreateRevision != e.Kv.ModRevision +} + +// Err is the error value if this WatchResponse holds an error. +func (wr *WatchResponse) Err() error { + switch { + case wr.closeErr != nil: + return v3rpc.Error(wr.closeErr) + case wr.CompactRevision != 0: + return v3rpc.ErrCompacted + case wr.Canceled: + return v3rpc.ErrFutureRev + } + return nil +} + +// IsProgressNotify returns true if the WatchResponse is progress notification. +func (wr *WatchResponse) IsProgressNotify() bool { + return len(wr.Events) == 0 && !wr.Canceled && !wr.Created +} + +// watcher implements the Watcher interface +type watcher struct { + remote pb.WatchClient + + // mu protects the grpc streams map + mu sync.RWMutex + + // streams holds all the active grpc streams keyed by ctx value. + streams map[string]*watchGrpcStream +} + +type watchGrpcStream struct { + owner *watcher + remote pb.WatchClient + + // ctx controls internal remote.Watch requests + ctx context.Context + // ctxKey is the key used when looking up this stream's context + ctxKey string + cancel context.CancelFunc + + // mu protects the streams map + mu sync.RWMutex + // streams holds all active watchers + streams map[int64]*watcherStream + + // reqc sends a watch request from Watch() to the main goroutine + reqc chan *watchRequest + // respc receives data from the watch client + respc chan *pb.WatchResponse + // stopc is sent to the main goroutine to stop all processing + stopc chan struct{} + // donec closes to broadcast shutdown + donec chan struct{} + // errc transmits errors from grpc Recv to the watch stream reconn logic + errc chan error + + // the error that closed the watch stream + closeErr error +} + +// watchRequest is issued by the subscriber to start a new watcher +type watchRequest struct { + ctx context.Context + key string + end string + rev int64 + // send created notification event if this field is true + createdNotify bool + // progressNotify is for progress updates + progressNotify bool + // filters is the list of events to filter out + filters []pb.WatchCreateRequest_FilterType + // get the previous key-value pair before the event happens + prevKV bool + // retc receives a chan WatchResponse once the watcher is established + retc chan chan WatchResponse +} + +// watcherStream represents a registered watcher +type watcherStream struct { + // initReq is the request that initiated this request + initReq watchRequest + + // outc publishes watch responses to subscriber + outc chan<- WatchResponse + // recvc buffers watch responses before publishing + recvc chan *WatchResponse + id int64 + + // lastRev is revision last successfully sent over outc + lastRev int64 + // resumec indicates the stream must recover at a given revision + resumec chan int64 +} + +func NewWatcher(c *Client) Watcher { + return NewWatchFromWatchClient(pb.NewWatchClient(c.conn)) +} + +func NewWatchFromWatchClient(wc pb.WatchClient) Watcher { + return &watcher{ + remote: wc, + streams: make(map[string]*watchGrpcStream), + } +} + +// never closes +var valCtxCh = make(chan struct{}) +var zeroTime = time.Unix(0, 0) + +// ctx with only the values; never Done +type valCtx struct{ context.Context } + +func (vc *valCtx) Deadline() (time.Time, bool) { return zeroTime, false } +func (vc *valCtx) Done() <-chan struct{} { return valCtxCh } +func (vc *valCtx) Err() error { return nil } + +func (w *watcher) newWatcherGrpcStream(inctx context.Context) *watchGrpcStream { + ctx, cancel := context.WithCancel(&valCtx{inctx}) + wgs := &watchGrpcStream{ + owner: w, + remote: w.remote, + ctx: ctx, + ctxKey: fmt.Sprintf("%v", inctx), + cancel: cancel, + streams: make(map[int64]*watcherStream), + + respc: make(chan *pb.WatchResponse), + reqc: make(chan *watchRequest), + stopc: make(chan struct{}), + donec: make(chan struct{}), + errc: make(chan error, 1), + } + go wgs.run() + return wgs +} + +// Watch posts a watch request to run() and waits for a new watcher channel +func (w *watcher) Watch(ctx context.Context, key string, opts ...OpOption) WatchChan { + ow := opWatch(key, opts...) + + retc := make(chan chan WatchResponse, 1) + + var filters []pb.WatchCreateRequest_FilterType + if ow.filterPut { + filters = append(filters, pb.WatchCreateRequest_NOPUT) + } + if ow.filterDelete { + filters = append(filters, pb.WatchCreateRequest_NODELETE) + } + + wr := &watchRequest{ + ctx: ctx, + createdNotify: ow.createdNotify, + key: string(ow.key), + end: string(ow.end), + rev: ow.rev, + progressNotify: ow.progressNotify, + filters: filters, + prevKV: ow.prevKV, + retc: retc, + } + + ok := false + ctxKey := fmt.Sprintf("%v", ctx) + + // find or allocate appropriate grpc watch stream + w.mu.Lock() + if w.streams == nil { + // closed + w.mu.Unlock() + ch := make(chan WatchResponse) + close(ch) + return ch + } + wgs := w.streams[ctxKey] + if wgs == nil { + wgs = w.newWatcherGrpcStream(ctx) + w.streams[ctxKey] = wgs + } + donec := wgs.donec + reqc := wgs.reqc + w.mu.Unlock() + + // couldn't create channel; return closed channel + closeCh := make(chan WatchResponse, 1) + + // submit request + select { + case reqc <- wr: + ok = true + case <-wr.ctx.Done(): + wgs.stopIfEmpty() + case <-donec: + if wgs.closeErr != nil { + closeCh <- WatchResponse{closeErr: wgs.closeErr} + break + } + // retry; may have dropped stream from no ctxs + return w.Watch(ctx, key, opts...) + } + + // receive channel + if ok { + select { + case ret := <-retc: + return ret + case <-ctx.Done(): + case <-donec: + if wgs.closeErr != nil { + closeCh <- WatchResponse{closeErr: wgs.closeErr} + break + } + // retry; may have dropped stream from no ctxs + return w.Watch(ctx, key, opts...) + } + } + + close(closeCh) + return closeCh +} + +func (w *watcher) Close() (err error) { + w.mu.Lock() + streams := w.streams + w.streams = nil + w.mu.Unlock() + for _, wgs := range streams { + if werr := wgs.Close(); werr != nil { + err = werr + } + } + return err +} + +func (w *watchGrpcStream) Close() (err error) { + w.mu.Lock() + if w.stopc != nil { + close(w.stopc) + w.stopc = nil + } + w.mu.Unlock() + <-w.donec + select { + case err = <-w.errc: + default: + } + return toErr(w.ctx, err) +} + +func (w *watchGrpcStream) addStream(resp *pb.WatchResponse, pendingReq *watchRequest) { + if pendingReq == nil { + // no pending request; ignore + return + } + if resp.Canceled || resp.CompactRevision != 0 { + // a cancel at id creation time means the start revision has + // been compacted out of the store + ret := make(chan WatchResponse, 1) + ret <- WatchResponse{ + Header: *resp.Header, + CompactRevision: resp.CompactRevision, + Canceled: true} + close(ret) + pendingReq.retc <- ret + return + } + + ret := make(chan WatchResponse) + if resp.WatchId == -1 { + // failed; no channel + close(ret) + pendingReq.retc <- ret + return + } + + ws := &watcherStream{ + initReq: *pendingReq, + id: resp.WatchId, + outc: ret, + // buffered so unlikely to block on sending while holding mu + recvc: make(chan *WatchResponse, 4), + resumec: make(chan int64), + } + + if pendingReq.rev == 0 { + // note the header revision so that a put following a current watcher + // disconnect will arrive on the watcher channel after reconnect + ws.initReq.rev = resp.Header.Revision + } + + w.mu.Lock() + w.streams[ws.id] = ws + w.mu.Unlock() + + // pass back the subscriber channel for the watcher + pendingReq.retc <- ret + + // send messages to subscriber + go w.serveStream(ws) +} + +// closeStream closes the watcher resources and removes it +func (w *watchGrpcStream) closeStream(ws *watcherStream) { + w.mu.Lock() + // cancels request stream; subscriber receives nil channel + close(ws.initReq.retc) + // close subscriber's channel + close(ws.outc) + delete(w.streams, ws.id) + w.mu.Unlock() +} + +// run is the root of the goroutines for managing a watcher client +func (w *watchGrpcStream) run() { + var wc pb.Watch_WatchClient + var closeErr error + + defer func() { + w.owner.mu.Lock() + w.closeErr = closeErr + if w.owner.streams != nil { + delete(w.owner.streams, w.ctxKey) + } + close(w.donec) + w.owner.mu.Unlock() + w.cancel() + }() + + // already stopped? + w.mu.RLock() + stopc := w.stopc + w.mu.RUnlock() + if stopc == nil { + return + } + + // start a stream with the etcd grpc server + if wc, closeErr = w.newWatchClient(); closeErr != nil { + return + } + + var pendingReq, failedReq *watchRequest + curReqC := w.reqc + cancelSet := make(map[int64]struct{}) + + for { + select { + // Watch() requested + case pendingReq = <-curReqC: + // no more watch requests until there's a response + curReqC = nil + if err := wc.Send(pendingReq.toPB()); err == nil { + // pendingReq now waits on w.respc + break + } + failedReq = pendingReq + // New events from the watch client + case pbresp := <-w.respc: + switch { + case pbresp.Created: + // response to pending req, try to add + w.addStream(pbresp, pendingReq) + pendingReq = nil + curReqC = w.reqc + w.dispatchEvent(pbresp) + case pbresp.Canceled: + delete(cancelSet, pbresp.WatchId) + // shutdown serveStream, if any + w.mu.Lock() + if ws, ok := w.streams[pbresp.WatchId]; ok { + close(ws.recvc) + delete(w.streams, ws.id) + } + numStreams := len(w.streams) + w.mu.Unlock() + if numStreams == 0 { + // don't leak watcher streams + return + } + default: + // dispatch to appropriate watch stream + if ok := w.dispatchEvent(pbresp); ok { + break + } + // watch response on unexpected watch id; cancel id + if _, ok := cancelSet[pbresp.WatchId]; ok { + break + } + cancelSet[pbresp.WatchId] = struct{}{} + cr := &pb.WatchRequest_CancelRequest{ + CancelRequest: &pb.WatchCancelRequest{ + WatchId: pbresp.WatchId, + }, + } + req := &pb.WatchRequest{RequestUnion: cr} + wc.Send(req) + } + // watch client failed to recv; spawn another if possible + // TODO report watch client errors from errc? + case err := <-w.errc: + if toErr(w.ctx, err) == v3rpc.ErrNoLeader { + closeErr = err + return + } + if wc, closeErr = w.newWatchClient(); closeErr != nil { + return + } + curReqC = w.reqc + if pendingReq != nil { + failedReq = pendingReq + } + cancelSet = make(map[int64]struct{}) + case <-stopc: + return + } + + // send failed; queue for retry + if failedReq != nil { + go func(wr *watchRequest) { + select { + case w.reqc <- wr: + case <-wr.ctx.Done(): + case <-w.donec: + } + }(pendingReq) + failedReq = nil + pendingReq = nil + } + } +} + +// dispatchEvent sends a WatchResponse to the appropriate watcher stream +func (w *watchGrpcStream) dispatchEvent(pbresp *pb.WatchResponse) bool { + w.mu.RLock() + defer w.mu.RUnlock() + ws, ok := w.streams[pbresp.WatchId] + if !ok { + return false + } + + events := make([]*Event, len(pbresp.Events)) + for i, ev := range pbresp.Events { + events[i] = (*Event)(ev) + } + wr := &WatchResponse{ + Header: *pbresp.Header, + Events: events, + CompactRevision: pbresp.CompactRevision, + Created: pbresp.Created, + Canceled: pbresp.Canceled, + } + ws.recvc <- wr + return true +} + +// serveWatchClient forwards messages from the grpc stream to run() +func (w *watchGrpcStream) serveWatchClient(wc pb.Watch_WatchClient) { + for { + resp, err := wc.Recv() + if err != nil { + select { + case w.errc <- err: + case <-w.donec: + } + return + } + select { + case w.respc <- resp: + case <-w.donec: + return + } + } +} + +// serveStream forwards watch responses from run() to the subscriber +func (w *watchGrpcStream) serveStream(ws *watcherStream) { + var closeErr error + emptyWr := &WatchResponse{} + wrs := []*WatchResponse{} + resuming := false + closing := false + for !closing { + curWr := emptyWr + outc := ws.outc + + // ignore created event if create notify is not requested or + // we already sent the initial created event (when we are on the resume path). + if len(wrs) > 0 && wrs[0].Created && + (!ws.initReq.createdNotify || ws.lastRev != 0) { + wrs = wrs[1:] + } + + if len(wrs) > 0 { + curWr = wrs[0] + } else { + outc = nil + } + select { + case outc <- *curWr: + if wrs[0].Err() != nil { + closing = true + break + } + var newRev int64 + if len(wrs[0].Events) > 0 { + newRev = wrs[0].Events[len(wrs[0].Events)-1].Kv.ModRevision + } else { + newRev = wrs[0].Header.Revision + } + if newRev != ws.lastRev { + ws.lastRev = newRev + } + wrs[0] = nil + wrs = wrs[1:] + case wr, ok := <-ws.recvc: + if !ok { + // shutdown from closeStream + return + } + // resume up to last seen event if disconnected + if resuming && wr.Err() == nil { + resuming = false + // trim events already seen + for i := 0; i < len(wr.Events); i++ { + if wr.Events[i].Kv.ModRevision > ws.lastRev { + wr.Events = wr.Events[i:] + break + } + } + // only forward new events + if wr.Events[0].Kv.ModRevision == ws.lastRev { + break + } + } + resuming = false + // TODO don't keep buffering if subscriber stops reading + wrs = append(wrs, wr) + case resumeRev := <-ws.resumec: + wrs = nil + resuming = true + if resumeRev == -1 { + // pause serving stream while resume gets set up + break + } + if resumeRev != ws.lastRev { + panic("unexpected resume revision") + } + case <-w.donec: + closing = true + closeErr = w.closeErr + case <-ws.initReq.ctx.Done(): + closing = true + } + } + + // try to send off close error + if closeErr != nil { + select { + case ws.outc <- WatchResponse{closeErr: w.closeErr}: + case <-w.donec: + case <-time.After(closeSendErrTimeout): + } + } + + w.closeStream(ws) + w.stopIfEmpty() + // lazily send cancel message if events on missing id +} + +func (wgs *watchGrpcStream) stopIfEmpty() { + wgs.mu.Lock() + if len(wgs.streams) == 0 && wgs.stopc != nil { + close(wgs.stopc) + wgs.stopc = nil + } + wgs.mu.Unlock() +} + +func (w *watchGrpcStream) newWatchClient() (pb.Watch_WatchClient, error) { + ws, rerr := w.resume() + if rerr != nil { + return nil, rerr + } + go w.serveWatchClient(ws) + return ws, nil +} + +// resume creates a new WatchClient with all current watchers reestablished +func (w *watchGrpcStream) resume() (ws pb.Watch_WatchClient, err error) { + for { + if ws, err = w.openWatchClient(); err != nil { + break + } else if err = w.resumeWatchers(ws); err == nil { + break + } + } + return ws, v3rpc.Error(err) +} + +// openWatchClient retries opening a watchclient until retryConnection fails +func (w *watchGrpcStream) openWatchClient() (ws pb.Watch_WatchClient, err error) { + for { + w.mu.Lock() + stopc := w.stopc + w.mu.Unlock() + if stopc == nil { + if err == nil { + err = context.Canceled + } + return nil, err + } + if ws, err = w.remote.Watch(w.ctx, grpc.FailFast(false)); ws != nil && err == nil { + break + } + if isHaltErr(w.ctx, err) { + return nil, v3rpc.Error(err) + } + } + return ws, nil +} + +// resumeWatchers rebuilds every registered watcher on a new client +func (w *watchGrpcStream) resumeWatchers(wc pb.Watch_WatchClient) error { + w.mu.RLock() + streams := make([]*watcherStream, 0, len(w.streams)) + for _, ws := range w.streams { + streams = append(streams, ws) + } + w.mu.RUnlock() + + for _, ws := range streams { + // pause serveStream + ws.resumec <- -1 + + // reconstruct watcher from initial request + if ws.lastRev != 0 { + ws.initReq.rev = ws.lastRev + } + if err := wc.Send(ws.initReq.toPB()); err != nil { + return err + } + + // wait for request ack + resp, err := wc.Recv() + if err != nil { + return err + } else if len(resp.Events) != 0 || !resp.Created { + return fmt.Errorf("watcher: unexpected response (%+v)", resp) + } + + // id may be different since new remote watcher; update map + w.mu.Lock() + delete(w.streams, ws.id) + ws.id = resp.WatchId + w.streams[ws.id] = ws + w.mu.Unlock() + + // unpause serveStream + ws.resumec <- ws.lastRev + } + return nil +} + +// toPB converts an internal watch request structure to its protobuf messagefunc (wr *watchRequest) +func (wr *watchRequest) toPB() *pb.WatchRequest { + req := &pb.WatchCreateRequest{ + StartRevision: wr.rev, + Key: []byte(wr.key), + RangeEnd: []byte(wr.end), + ProgressNotify: wr.progressNotify, + Filters: wr.filters, + PrevKv: wr.prevKV, + } + cr := &pb.WatchRequest_CreateRequest{CreateRequest: req} + return &pb.WatchRequest{RequestUnion: cr} +} diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/doc.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/doc.go new file mode 100644 index 00000000..f72c6a64 --- /dev/null +++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/doc.go @@ -0,0 +1,16 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package rpctypes has types and values shared by the etcd server and client for v3 RPC interaction. +package rpctypes diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/error.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/error.go new file mode 100644 index 00000000..b41d1c83 --- /dev/null +++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/error.go @@ -0,0 +1,156 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rpctypes + +import ( + "google.golang.org/grpc" + "google.golang.org/grpc/codes" +) + +var ( + // server-side error + ErrGRPCEmptyKey = grpc.Errorf(codes.InvalidArgument, "etcdserver: key is not provided") + ErrGRPCTooManyOps = grpc.Errorf(codes.InvalidArgument, "etcdserver: too many operations in txn request") + ErrGRPCDuplicateKey = grpc.Errorf(codes.InvalidArgument, "etcdserver: duplicate key given in txn request") + ErrGRPCCompacted = grpc.Errorf(codes.OutOfRange, "etcdserver: mvcc: required revision has been compacted") + ErrGRPCFutureRev = grpc.Errorf(codes.OutOfRange, "etcdserver: mvcc: required revision is a future revision") + ErrGRPCNoSpace = grpc.Errorf(codes.ResourceExhausted, "etcdserver: mvcc: database space exceeded") + + ErrGRPCLeaseNotFound = grpc.Errorf(codes.NotFound, "etcdserver: requested lease not found") + ErrGRPCLeaseExist = grpc.Errorf(codes.FailedPrecondition, "etcdserver: lease already exists") + + ErrGRPCMemberExist = grpc.Errorf(codes.FailedPrecondition, "etcdserver: member ID already exist") + ErrGRPCPeerURLExist = grpc.Errorf(codes.FailedPrecondition, "etcdserver: Peer URLs already exists") + ErrGRPCMemberBadURLs = grpc.Errorf(codes.InvalidArgument, "etcdserver: given member URLs are invalid") + ErrGRPCMemberNotFound = grpc.Errorf(codes.NotFound, "etcdserver: member not found") + + ErrGRPCRequestTooLarge = grpc.Errorf(codes.InvalidArgument, "etcdserver: request is too large") + ErrGRPCRequestTooManyRequests = grpc.Errorf(codes.ResourceExhausted, "etcdserver: too many requests") + + ErrGRPCRootUserNotExist = grpc.Errorf(codes.FailedPrecondition, "etcdserver: root user does not exist") + ErrGRPCRootRoleNotExist = grpc.Errorf(codes.FailedPrecondition, "etcdserver: root user does not have root role") + ErrGRPCUserAlreadyExist = grpc.Errorf(codes.FailedPrecondition, "etcdserver: user name already exists") + ErrGRPCUserNotFound = grpc.Errorf(codes.FailedPrecondition, "etcdserver: user name not found") + ErrGRPCRoleAlreadyExist = grpc.Errorf(codes.FailedPrecondition, "etcdserver: role name already exists") + ErrGRPCRoleNotFound = grpc.Errorf(codes.FailedPrecondition, "etcdserver: role name not found") + ErrGRPCAuthFailed = grpc.Errorf(codes.InvalidArgument, "etcdserver: authentication failed, invalid user ID or password") + ErrGRPCPermissionDenied = grpc.Errorf(codes.PermissionDenied, "etcdserver: permission denied") + ErrGRPCRoleNotGranted = grpc.Errorf(codes.FailedPrecondition, "etcdserver: role is not granted to the user") + ErrGRPCPermissionNotGranted = grpc.Errorf(codes.FailedPrecondition, "etcdserver: permission is not granted to the role") + ErrGRPCAuthNotEnabled = grpc.Errorf(codes.FailedPrecondition, "etcdserver: authentication is not enabled") + + ErrGRPCNoLeader = grpc.Errorf(codes.Unavailable, "etcdserver: no leader") + ErrGRPCNotCapable = grpc.Errorf(codes.Unavailable, "etcdserver: not capable") + ErrGRPCStopped = grpc.Errorf(codes.Unavailable, "etcdserver: server stopped") + + errStringToError = map[string]error{ + grpc.ErrorDesc(ErrGRPCEmptyKey): ErrGRPCEmptyKey, + grpc.ErrorDesc(ErrGRPCTooManyOps): ErrGRPCTooManyOps, + grpc.ErrorDesc(ErrGRPCDuplicateKey): ErrGRPCDuplicateKey, + grpc.ErrorDesc(ErrGRPCCompacted): ErrGRPCCompacted, + grpc.ErrorDesc(ErrGRPCFutureRev): ErrGRPCFutureRev, + grpc.ErrorDesc(ErrGRPCNoSpace): ErrGRPCNoSpace, + + grpc.ErrorDesc(ErrGRPCLeaseNotFound): ErrGRPCLeaseNotFound, + grpc.ErrorDesc(ErrGRPCLeaseExist): ErrGRPCLeaseExist, + + grpc.ErrorDesc(ErrGRPCMemberExist): ErrGRPCMemberExist, + grpc.ErrorDesc(ErrGRPCPeerURLExist): ErrGRPCPeerURLExist, + grpc.ErrorDesc(ErrGRPCMemberBadURLs): ErrGRPCMemberBadURLs, + grpc.ErrorDesc(ErrGRPCMemberNotFound): ErrGRPCMemberNotFound, + + grpc.ErrorDesc(ErrGRPCRequestTooLarge): ErrGRPCRequestTooLarge, + grpc.ErrorDesc(ErrGRPCRequestTooManyRequests): ErrGRPCRequestTooManyRequests, + + grpc.ErrorDesc(ErrGRPCRootUserNotExist): ErrGRPCRootUserNotExist, + grpc.ErrorDesc(ErrGRPCRootRoleNotExist): ErrGRPCRootRoleNotExist, + grpc.ErrorDesc(ErrGRPCUserAlreadyExist): ErrGRPCUserAlreadyExist, + grpc.ErrorDesc(ErrGRPCUserNotFound): ErrGRPCUserNotFound, + grpc.ErrorDesc(ErrGRPCRoleAlreadyExist): ErrGRPCRoleAlreadyExist, + grpc.ErrorDesc(ErrGRPCRoleNotFound): ErrGRPCRoleNotFound, + grpc.ErrorDesc(ErrGRPCAuthFailed): ErrGRPCAuthFailed, + grpc.ErrorDesc(ErrGRPCPermissionDenied): ErrGRPCPermissionDenied, + grpc.ErrorDesc(ErrGRPCRoleNotGranted): ErrGRPCRoleNotGranted, + grpc.ErrorDesc(ErrGRPCPermissionNotGranted): ErrGRPCPermissionNotGranted, + grpc.ErrorDesc(ErrGRPCAuthNotEnabled): ErrGRPCAuthNotEnabled, + + grpc.ErrorDesc(ErrGRPCNoLeader): ErrGRPCNoLeader, + grpc.ErrorDesc(ErrGRPCNotCapable): ErrGRPCNotCapable, + grpc.ErrorDesc(ErrGRPCStopped): ErrGRPCStopped, + } + + // client-side error + ErrEmptyKey = Error(ErrGRPCEmptyKey) + ErrTooManyOps = Error(ErrGRPCTooManyOps) + ErrDuplicateKey = Error(ErrGRPCDuplicateKey) + ErrCompacted = Error(ErrGRPCCompacted) + ErrFutureRev = Error(ErrGRPCFutureRev) + ErrNoSpace = Error(ErrGRPCNoSpace) + + ErrLeaseNotFound = Error(ErrGRPCLeaseNotFound) + ErrLeaseExist = Error(ErrGRPCLeaseExist) + + ErrMemberExist = Error(ErrGRPCMemberExist) + ErrPeerURLExist = Error(ErrGRPCPeerURLExist) + ErrMemberBadURLs = Error(ErrGRPCMemberBadURLs) + ErrMemberNotFound = Error(ErrGRPCMemberNotFound) + + ErrRequestTooLarge = Error(ErrGRPCRequestTooLarge) + ErrTooManyRequests = Error(ErrGRPCRequestTooManyRequests) + + ErrRootUserNotExist = Error(ErrGRPCRootUserNotExist) + ErrRootRoleNotExist = Error(ErrGRPCRootRoleNotExist) + ErrUserAlreadyExist = Error(ErrGRPCUserAlreadyExist) + ErrUserNotFound = Error(ErrGRPCUserNotFound) + ErrRoleAlreadyExist = Error(ErrGRPCRoleAlreadyExist) + ErrRoleNotFound = Error(ErrGRPCRoleNotFound) + ErrAuthFailed = Error(ErrGRPCAuthFailed) + ErrPermissionDenied = Error(ErrGRPCPermissionDenied) + ErrRoleNotGranted = Error(ErrGRPCRoleNotGranted) + ErrPermissionNotGranted = Error(ErrGRPCPermissionNotGranted) + ErrAuthNotEnabled = Error(ErrGRPCAuthNotEnabled) + + ErrNoLeader = Error(ErrGRPCNoLeader) + ErrNotCapable = Error(ErrGRPCNotCapable) + ErrStopped = Error(ErrGRPCStopped) +) + +// EtcdError defines gRPC server errors. +// (https://github.com/grpc/grpc-go/blob/master/rpc_util.go#L319-L323) +type EtcdError struct { + code codes.Code + desc string +} + +// Code returns grpc/codes.Code. +// TODO: define clientv3/codes.Code. +func (e EtcdError) Code() codes.Code { + return e.code +} + +func (e EtcdError) Error() string { + return e.desc +} + +func Error(err error) error { + if err == nil { + return nil + } + verr, ok := errStringToError[grpc.ErrorDesc(err)] + if !ok { // not gRPC error + return err + } + return EtcdError{code: grpc.Code(verr), desc: grpc.ErrorDesc(verr)} +} diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/md.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/md.go new file mode 100644 index 00000000..5c590e1a --- /dev/null +++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/md.go @@ -0,0 +1,20 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rpctypes + +var ( + MetadataRequireLeaderKey = "hasleader" + MetadataHasLeader = "true" +) diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.pb.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.pb.go new file mode 100644 index 00000000..746e9a11 --- /dev/null +++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.pb.go @@ -0,0 +1,1041 @@ +// Code generated by protoc-gen-gogo. +// source: etcdserver.proto +// DO NOT EDIT! + +/* + Package etcdserverpb is a generated protocol buffer package. + + It is generated from these files: + etcdserver.proto + raft_internal.proto + rpc.proto + + It has these top-level messages: + Request + Metadata + RequestHeader + InternalRaftRequest + EmptyResponse + InternalAuthenticateRequest + ResponseHeader + RangeRequest + RangeResponse + PutRequest + PutResponse + DeleteRangeRequest + DeleteRangeResponse + RequestOp + ResponseOp + Compare + TxnRequest + TxnResponse + CompactionRequest + CompactionResponse + HashRequest + HashResponse + SnapshotRequest + SnapshotResponse + WatchRequest + WatchCreateRequest + WatchCancelRequest + WatchResponse + LeaseGrantRequest + LeaseGrantResponse + LeaseRevokeRequest + LeaseRevokeResponse + LeaseKeepAliveRequest + LeaseKeepAliveResponse + Member + MemberAddRequest + MemberAddResponse + MemberRemoveRequest + MemberRemoveResponse + MemberUpdateRequest + MemberUpdateResponse + MemberListRequest + MemberListResponse + DefragmentRequest + DefragmentResponse + AlarmRequest + AlarmMember + AlarmResponse + StatusRequest + StatusResponse + AuthEnableRequest + AuthDisableRequest + AuthenticateRequest + AuthUserAddRequest + AuthUserGetRequest + AuthUserDeleteRequest + AuthUserChangePasswordRequest + AuthUserGrantRoleRequest + AuthUserRevokeRoleRequest + AuthRoleAddRequest + AuthRoleGetRequest + AuthUserListRequest + AuthRoleListRequest + AuthRoleDeleteRequest + AuthRoleGrantPermissionRequest + AuthRoleRevokePermissionRequest + AuthEnableResponse + AuthDisableResponse + AuthenticateResponse + AuthUserAddResponse + AuthUserGetResponse + AuthUserDeleteResponse + AuthUserChangePasswordResponse + AuthUserGrantRoleResponse + AuthUserRevokeRoleResponse + AuthRoleAddResponse + AuthRoleGetResponse + AuthRoleListResponse + AuthUserListResponse + AuthRoleDeleteResponse + AuthRoleGrantPermissionResponse + AuthRoleRevokePermissionResponse +*/ +package etcdserverpb + +import ( + "fmt" + + proto "github.com/golang/protobuf/proto" + + math "math" +) + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +const _ = proto.ProtoPackageIsVersion1 + +type Request struct { + ID uint64 `protobuf:"varint,1,opt,name=ID,json=iD" json:"ID"` + Method string `protobuf:"bytes,2,opt,name=Method,json=method" json:"Method"` + Path string `protobuf:"bytes,3,opt,name=Path,json=path" json:"Path"` + Val string `protobuf:"bytes,4,opt,name=Val,json=val" json:"Val"` + Dir bool `protobuf:"varint,5,opt,name=Dir,json=dir" json:"Dir"` + PrevValue string `protobuf:"bytes,6,opt,name=PrevValue,json=prevValue" json:"PrevValue"` + PrevIndex uint64 `protobuf:"varint,7,opt,name=PrevIndex,json=prevIndex" json:"PrevIndex"` + PrevExist *bool `protobuf:"varint,8,opt,name=PrevExist,json=prevExist" json:"PrevExist,omitempty"` + Expiration int64 `protobuf:"varint,9,opt,name=Expiration,json=expiration" json:"Expiration"` + Wait bool `protobuf:"varint,10,opt,name=Wait,json=wait" json:"Wait"` + Since uint64 `protobuf:"varint,11,opt,name=Since,json=since" json:"Since"` + Recursive bool `protobuf:"varint,12,opt,name=Recursive,json=recursive" json:"Recursive"` + Sorted bool `protobuf:"varint,13,opt,name=Sorted,json=sorted" json:"Sorted"` + Quorum bool `protobuf:"varint,14,opt,name=Quorum,json=quorum" json:"Quorum"` + Time int64 `protobuf:"varint,15,opt,name=Time,json=time" json:"Time"` + Stream bool `protobuf:"varint,16,opt,name=Stream,json=stream" json:"Stream"` + Refresh *bool `protobuf:"varint,17,opt,name=Refresh,json=refresh" json:"Refresh,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Request) Reset() { *m = Request{} } +func (m *Request) String() string { return proto.CompactTextString(m) } +func (*Request) ProtoMessage() {} +func (*Request) Descriptor() ([]byte, []int) { return fileDescriptorEtcdserver, []int{0} } + +type Metadata struct { + NodeID uint64 `protobuf:"varint,1,opt,name=NodeID,json=nodeID" json:"NodeID"` + ClusterID uint64 `protobuf:"varint,2,opt,name=ClusterID,json=clusterID" json:"ClusterID"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Metadata) Reset() { *m = Metadata{} } +func (m *Metadata) String() string { return proto.CompactTextString(m) } +func (*Metadata) ProtoMessage() {} +func (*Metadata) Descriptor() ([]byte, []int) { return fileDescriptorEtcdserver, []int{1} } + +func init() { + proto.RegisterType((*Request)(nil), "etcdserverpb.Request") + proto.RegisterType((*Metadata)(nil), "etcdserverpb.Metadata") +} +func (m *Request) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Request) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x8 + i++ + i = encodeVarintEtcdserver(data, i, uint64(m.ID)) + data[i] = 0x12 + i++ + i = encodeVarintEtcdserver(data, i, uint64(len(m.Method))) + i += copy(data[i:], m.Method) + data[i] = 0x1a + i++ + i = encodeVarintEtcdserver(data, i, uint64(len(m.Path))) + i += copy(data[i:], m.Path) + data[i] = 0x22 + i++ + i = encodeVarintEtcdserver(data, i, uint64(len(m.Val))) + i += copy(data[i:], m.Val) + data[i] = 0x28 + i++ + if m.Dir { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x32 + i++ + i = encodeVarintEtcdserver(data, i, uint64(len(m.PrevValue))) + i += copy(data[i:], m.PrevValue) + data[i] = 0x38 + i++ + i = encodeVarintEtcdserver(data, i, uint64(m.PrevIndex)) + if m.PrevExist != nil { + data[i] = 0x40 + i++ + if *m.PrevExist { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + data[i] = 0x48 + i++ + i = encodeVarintEtcdserver(data, i, uint64(m.Expiration)) + data[i] = 0x50 + i++ + if m.Wait { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x58 + i++ + i = encodeVarintEtcdserver(data, i, uint64(m.Since)) + data[i] = 0x60 + i++ + if m.Recursive { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x68 + i++ + if m.Sorted { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x70 + i++ + if m.Quorum { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x78 + i++ + i = encodeVarintEtcdserver(data, i, uint64(m.Time)) + data[i] = 0x80 + i++ + data[i] = 0x1 + i++ + if m.Stream { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + if m.Refresh != nil { + data[i] = 0x88 + i++ + data[i] = 0x1 + i++ + if *m.Refresh { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Metadata) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Metadata) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x8 + i++ + i = encodeVarintEtcdserver(data, i, uint64(m.NodeID)) + data[i] = 0x10 + i++ + i = encodeVarintEtcdserver(data, i, uint64(m.ClusterID)) + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Etcdserver(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Etcdserver(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintEtcdserver(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *Request) Size() (n int) { + var l int + _ = l + n += 1 + sovEtcdserver(uint64(m.ID)) + l = len(m.Method) + n += 1 + l + sovEtcdserver(uint64(l)) + l = len(m.Path) + n += 1 + l + sovEtcdserver(uint64(l)) + l = len(m.Val) + n += 1 + l + sovEtcdserver(uint64(l)) + n += 2 + l = len(m.PrevValue) + n += 1 + l + sovEtcdserver(uint64(l)) + n += 1 + sovEtcdserver(uint64(m.PrevIndex)) + if m.PrevExist != nil { + n += 2 + } + n += 1 + sovEtcdserver(uint64(m.Expiration)) + n += 2 + n += 1 + sovEtcdserver(uint64(m.Since)) + n += 2 + n += 2 + n += 2 + n += 1 + sovEtcdserver(uint64(m.Time)) + n += 3 + if m.Refresh != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Metadata) Size() (n int) { + var l int + _ = l + n += 1 + sovEtcdserver(uint64(m.NodeID)) + n += 1 + sovEtcdserver(uint64(m.ClusterID)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovEtcdserver(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozEtcdserver(x uint64) (n int) { + return sovEtcdserver(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Request) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Request: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEtcdserver + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Method = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEtcdserver + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Path = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Val", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEtcdserver + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Val = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Dir", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Dir = bool(v != 0) + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEtcdserver + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevValue = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevIndex", wireType) + } + m.PrevIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.PrevIndex |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevExist", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.PrevExist = &b + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Expiration", wireType) + } + m.Expiration = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Expiration |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Wait", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Wait = bool(v != 0) + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Since", wireType) + } + m.Since = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Since |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Recursive", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Recursive = bool(v != 0) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Sorted", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Sorted = bool(v != 0) + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Quorum", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Quorum = bool(v != 0) + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) + } + m.Time = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Time |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Stream", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Stream = bool(v != 0) + case 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Refresh", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Refresh = &b + default: + iNdEx = preIndex + skippy, err := skipEtcdserver(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthEtcdserver + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Metadata) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Metadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Metadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType) + } + m.NodeID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.NodeID |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterID", wireType) + } + m.ClusterID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ClusterID |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipEtcdserver(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthEtcdserver + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipEtcdserver(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthEtcdserver + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEtcdserver + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipEtcdserver(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthEtcdserver = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowEtcdserver = fmt.Errorf("proto: integer overflow") +) + +var fileDescriptorEtcdserver = []byte{ + // 404 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x92, 0x41, 0x6e, 0x13, 0x31, + 0x14, 0x86, 0xe3, 0xc4, 0x99, 0x64, 0x4c, 0x81, 0x62, 0x45, 0xe8, 0xa9, 0x42, 0x43, 0x14, 0xb1, + 0xc8, 0x0a, 0xee, 0x50, 0xd2, 0x45, 0x24, 0x8a, 0x4a, 0x8a, 0xca, 0xda, 0x64, 0x1e, 0x8d, 0xa5, + 0xcc, 0x78, 0x6a, 0xbf, 0x19, 0x72, 0x03, 0xae, 0xc0, 0x91, 0xb2, 0xe4, 0x04, 0x08, 0xc2, 0x45, + 0x90, 0x3d, 0x9d, 0x60, 0xba, 0xb3, 0xbe, 0xff, 0xf7, 0xef, 0xdf, 0xf6, 0x13, 0xa7, 0x48, 0xeb, + 0xdc, 0xa1, 0x6d, 0xd0, 0xbe, 0xae, 0xac, 0x21, 0x23, 0x4f, 0xfe, 0x91, 0xea, 0xf3, 0xd9, 0xe4, + 0xd6, 0xdc, 0x9a, 0x20, 0xbc, 0xf1, 0xab, 0xd6, 0x33, 0xfb, 0xc6, 0xc5, 0x68, 0x85, 0x77, 0x35, + 0x3a, 0x92, 0x13, 0xd1, 0x5f, 0x2e, 0x80, 0x4d, 0xd9, 0x9c, 0x9f, 0xf3, 0xfd, 0xcf, 0x97, 0xbd, + 0x55, 0x5f, 0x2f, 0xe4, 0x0b, 0x91, 0x5c, 0x22, 0x6d, 0x4c, 0x0e, 0xfd, 0x29, 0x9b, 0xa7, 0xf7, + 0x4a, 0x52, 0x04, 0x26, 0x41, 0xf0, 0x2b, 0x45, 0x1b, 0x18, 0x44, 0x1a, 0xaf, 0x14, 0x6d, 0xe4, + 0x73, 0x31, 0xb8, 0x51, 0x5b, 0xe0, 0x91, 0x30, 0x68, 0xd4, 0xd6, 0xf3, 0x85, 0xb6, 0x30, 0x9c, + 0xb2, 0xf9, 0xb8, 0xe3, 0xb9, 0xb6, 0x72, 0x26, 0xd2, 0x2b, 0x8b, 0xcd, 0x8d, 0xda, 0xd6, 0x08, + 0x49, 0xb4, 0x2b, 0xad, 0x3a, 0xdc, 0x79, 0x96, 0x65, 0x8e, 0x3b, 0x18, 0x45, 0x45, 0x83, 0x27, + 0xe0, 0xce, 0x73, 0xb1, 0xd3, 0x8e, 0x60, 0x7c, 0x3c, 0x85, 0xb5, 0x9e, 0x80, 0xe5, 0x2b, 0x21, + 0x2e, 0x76, 0x95, 0xb6, 0x8a, 0xb4, 0x29, 0x21, 0x9d, 0xb2, 0xf9, 0xe0, 0x3e, 0x48, 0xe0, 0x91, + 0xfb, 0xbb, 0x7d, 0x52, 0x9a, 0x40, 0x44, 0x55, 0xf9, 0x57, 0xa5, 0x49, 0x9e, 0x89, 0xe1, 0xb5, + 0x2e, 0xd7, 0x08, 0x8f, 0xa2, 0x0e, 0x43, 0xe7, 0x91, 0x3f, 0x7f, 0x85, 0xeb, 0xda, 0x3a, 0xdd, + 0x20, 0x9c, 0x44, 0x5b, 0x53, 0xdb, 0x61, 0xff, 0xa6, 0xd7, 0xc6, 0x12, 0xe6, 0xf0, 0x38, 0x32, + 0x24, 0x2e, 0x30, 0xaf, 0x7e, 0xa8, 0x8d, 0xad, 0x0b, 0x78, 0x12, 0xab, 0x77, 0x81, 0xf9, 0x56, + 0x1f, 0x75, 0x81, 0xf0, 0x34, 0x6a, 0xcd, 0x49, 0x17, 0x6d, 0x2a, 0x59, 0x54, 0x05, 0x9c, 0xfe, + 0x97, 0x1a, 0x98, 0xcc, 0xfc, 0x47, 0x7f, 0xb1, 0xe8, 0x36, 0xf0, 0x2c, 0x7a, 0x95, 0x91, 0x6d, + 0xe1, 0xec, 0x9d, 0x18, 0x5f, 0x22, 0xa9, 0x5c, 0x91, 0xf2, 0x49, 0xef, 0x4d, 0x8e, 0x0f, 0xa6, + 0x21, 0x29, 0x03, 0xf3, 0x37, 0x7c, 0xbb, 0xad, 0x1d, 0xa1, 0x5d, 0x2e, 0xc2, 0x50, 0x1c, 0x7f, + 0x61, 0xdd, 0xe1, 0xf3, 0xc9, 0xfe, 0x77, 0xd6, 0xdb, 0x1f, 0x32, 0xf6, 0xe3, 0x90, 0xb1, 0x5f, + 0x87, 0x8c, 0x7d, 0xff, 0x93, 0xf5, 0xfe, 0x06, 0x00, 0x00, 0xff, 0xff, 0x80, 0x62, 0xfc, 0x40, + 0xa4, 0x02, 0x00, 0x00, +} diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.pb.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.pb.go new file mode 100644 index 00000000..f032279b --- /dev/null +++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.pb.go @@ -0,0 +1,2092 @@ +// Code generated by protoc-gen-gogo. +// source: raft_internal.proto +// DO NOT EDIT! + +package etcdserverpb + +import ( + "fmt" + + proto "github.com/golang/protobuf/proto" + + math "math" +) + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type RequestHeader struct { + ID uint64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"` + // username is a username that is associated with an auth token of gRPC connection + Username string `protobuf:"bytes,2,opt,name=username,proto3" json:"username,omitempty"` + // auth_revision is a revision number of auth.authStore. It is not related to mvcc + AuthRevision uint64 `protobuf:"varint,3,opt,name=auth_revision,json=authRevision,proto3" json:"auth_revision,omitempty"` +} + +func (m *RequestHeader) Reset() { *m = RequestHeader{} } +func (m *RequestHeader) String() string { return proto.CompactTextString(m) } +func (*RequestHeader) ProtoMessage() {} +func (*RequestHeader) Descriptor() ([]byte, []int) { return fileDescriptorRaftInternal, []int{0} } + +// An InternalRaftRequest is the union of all requests which can be +// sent via raft. +type InternalRaftRequest struct { + Header *RequestHeader `protobuf:"bytes,100,opt,name=header" json:"header,omitempty"` + ID uint64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"` + V2 *Request `protobuf:"bytes,2,opt,name=v2" json:"v2,omitempty"` + Range *RangeRequest `protobuf:"bytes,3,opt,name=range" json:"range,omitempty"` + Put *PutRequest `protobuf:"bytes,4,opt,name=put" json:"put,omitempty"` + DeleteRange *DeleteRangeRequest `protobuf:"bytes,5,opt,name=delete_range,json=deleteRange" json:"delete_range,omitempty"` + Txn *TxnRequest `protobuf:"bytes,6,opt,name=txn" json:"txn,omitempty"` + Compaction *CompactionRequest `protobuf:"bytes,7,opt,name=compaction" json:"compaction,omitempty"` + LeaseGrant *LeaseGrantRequest `protobuf:"bytes,8,opt,name=lease_grant,json=leaseGrant" json:"lease_grant,omitempty"` + LeaseRevoke *LeaseRevokeRequest `protobuf:"bytes,9,opt,name=lease_revoke,json=leaseRevoke" json:"lease_revoke,omitempty"` + Alarm *AlarmRequest `protobuf:"bytes,10,opt,name=alarm" json:"alarm,omitempty"` + AuthEnable *AuthEnableRequest `protobuf:"bytes,1000,opt,name=auth_enable,json=authEnable" json:"auth_enable,omitempty"` + AuthDisable *AuthDisableRequest `protobuf:"bytes,1011,opt,name=auth_disable,json=authDisable" json:"auth_disable,omitempty"` + Authenticate *InternalAuthenticateRequest `protobuf:"bytes,1012,opt,name=authenticate" json:"authenticate,omitempty"` + AuthUserAdd *AuthUserAddRequest `protobuf:"bytes,1100,opt,name=auth_user_add,json=authUserAdd" json:"auth_user_add,omitempty"` + AuthUserDelete *AuthUserDeleteRequest `protobuf:"bytes,1101,opt,name=auth_user_delete,json=authUserDelete" json:"auth_user_delete,omitempty"` + AuthUserGet *AuthUserGetRequest `protobuf:"bytes,1102,opt,name=auth_user_get,json=authUserGet" json:"auth_user_get,omitempty"` + AuthUserChangePassword *AuthUserChangePasswordRequest `protobuf:"bytes,1103,opt,name=auth_user_change_password,json=authUserChangePassword" json:"auth_user_change_password,omitempty"` + AuthUserGrantRole *AuthUserGrantRoleRequest `protobuf:"bytes,1104,opt,name=auth_user_grant_role,json=authUserGrantRole" json:"auth_user_grant_role,omitempty"` + AuthUserRevokeRole *AuthUserRevokeRoleRequest `protobuf:"bytes,1105,opt,name=auth_user_revoke_role,json=authUserRevokeRole" json:"auth_user_revoke_role,omitempty"` + AuthUserList *AuthUserListRequest `protobuf:"bytes,1106,opt,name=auth_user_list,json=authUserList" json:"auth_user_list,omitempty"` + AuthRoleList *AuthRoleListRequest `protobuf:"bytes,1107,opt,name=auth_role_list,json=authRoleList" json:"auth_role_list,omitempty"` + AuthRoleAdd *AuthRoleAddRequest `protobuf:"bytes,1200,opt,name=auth_role_add,json=authRoleAdd" json:"auth_role_add,omitempty"` + AuthRoleDelete *AuthRoleDeleteRequest `protobuf:"bytes,1201,opt,name=auth_role_delete,json=authRoleDelete" json:"auth_role_delete,omitempty"` + AuthRoleGet *AuthRoleGetRequest `protobuf:"bytes,1202,opt,name=auth_role_get,json=authRoleGet" json:"auth_role_get,omitempty"` + AuthRoleGrantPermission *AuthRoleGrantPermissionRequest `protobuf:"bytes,1203,opt,name=auth_role_grant_permission,json=authRoleGrantPermission" json:"auth_role_grant_permission,omitempty"` + AuthRoleRevokePermission *AuthRoleRevokePermissionRequest `protobuf:"bytes,1204,opt,name=auth_role_revoke_permission,json=authRoleRevokePermission" json:"auth_role_revoke_permission,omitempty"` +} + +func (m *InternalRaftRequest) Reset() { *m = InternalRaftRequest{} } +func (m *InternalRaftRequest) String() string { return proto.CompactTextString(m) } +func (*InternalRaftRequest) ProtoMessage() {} +func (*InternalRaftRequest) Descriptor() ([]byte, []int) { return fileDescriptorRaftInternal, []int{1} } + +type EmptyResponse struct { +} + +func (m *EmptyResponse) Reset() { *m = EmptyResponse{} } +func (m *EmptyResponse) String() string { return proto.CompactTextString(m) } +func (*EmptyResponse) ProtoMessage() {} +func (*EmptyResponse) Descriptor() ([]byte, []int) { return fileDescriptorRaftInternal, []int{2} } + +// What is the difference between AuthenticateRequest (defined in rpc.proto) and InternalAuthenticateRequest? +// InternalAuthenticateRequest has a member that is filled by etcdserver and shouldn't be user-facing. +// For avoiding misusage the field, we have an internal version of AuthenticateRequest. +type InternalAuthenticateRequest struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"` + // simple_token is generated in API layer (etcdserver/v3_server.go) + SimpleToken string `protobuf:"bytes,3,opt,name=simple_token,json=simpleToken,proto3" json:"simple_token,omitempty"` +} + +func (m *InternalAuthenticateRequest) Reset() { *m = InternalAuthenticateRequest{} } +func (m *InternalAuthenticateRequest) String() string { return proto.CompactTextString(m) } +func (*InternalAuthenticateRequest) ProtoMessage() {} +func (*InternalAuthenticateRequest) Descriptor() ([]byte, []int) { + return fileDescriptorRaftInternal, []int{3} +} + +func init() { + proto.RegisterType((*RequestHeader)(nil), "etcdserverpb.RequestHeader") + proto.RegisterType((*InternalRaftRequest)(nil), "etcdserverpb.InternalRaftRequest") + proto.RegisterType((*EmptyResponse)(nil), "etcdserverpb.EmptyResponse") + proto.RegisterType((*InternalAuthenticateRequest)(nil), "etcdserverpb.InternalAuthenticateRequest") +} +func (m *RequestHeader) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *RequestHeader) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.ID != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.ID)) + } + if len(m.Username) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRaftInternal(data, i, uint64(len(m.Username))) + i += copy(data[i:], m.Username) + } + if m.AuthRevision != 0 { + data[i] = 0x18 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthRevision)) + } + return i, nil +} + +func (m *InternalRaftRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *InternalRaftRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.ID != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.ID)) + } + if m.V2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.V2.Size())) + n1, err := m.V2.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if m.Range != nil { + data[i] = 0x1a + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.Range.Size())) + n2, err := m.Range.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + if m.Put != nil { + data[i] = 0x22 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.Put.Size())) + n3, err := m.Put.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if m.DeleteRange != nil { + data[i] = 0x2a + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.DeleteRange.Size())) + n4, err := m.DeleteRange.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n4 + } + if m.Txn != nil { + data[i] = 0x32 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.Txn.Size())) + n5, err := m.Txn.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n5 + } + if m.Compaction != nil { + data[i] = 0x3a + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.Compaction.Size())) + n6, err := m.Compaction.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n6 + } + if m.LeaseGrant != nil { + data[i] = 0x42 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.LeaseGrant.Size())) + n7, err := m.LeaseGrant.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n7 + } + if m.LeaseRevoke != nil { + data[i] = 0x4a + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.LeaseRevoke.Size())) + n8, err := m.LeaseRevoke.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n8 + } + if m.Alarm != nil { + data[i] = 0x52 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.Alarm.Size())) + n9, err := m.Alarm.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n9 + } + if m.Header != nil { + data[i] = 0xa2 + i++ + data[i] = 0x6 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.Header.Size())) + n10, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n10 + } + if m.AuthEnable != nil { + data[i] = 0xc2 + i++ + data[i] = 0x3e + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthEnable.Size())) + n11, err := m.AuthEnable.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n11 + } + if m.AuthDisable != nil { + data[i] = 0x9a + i++ + data[i] = 0x3f + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthDisable.Size())) + n12, err := m.AuthDisable.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n12 + } + if m.Authenticate != nil { + data[i] = 0xa2 + i++ + data[i] = 0x3f + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.Authenticate.Size())) + n13, err := m.Authenticate.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n13 + } + if m.AuthUserAdd != nil { + data[i] = 0xe2 + i++ + data[i] = 0x44 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthUserAdd.Size())) + n14, err := m.AuthUserAdd.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n14 + } + if m.AuthUserDelete != nil { + data[i] = 0xea + i++ + data[i] = 0x44 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthUserDelete.Size())) + n15, err := m.AuthUserDelete.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n15 + } + if m.AuthUserGet != nil { + data[i] = 0xf2 + i++ + data[i] = 0x44 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthUserGet.Size())) + n16, err := m.AuthUserGet.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n16 + } + if m.AuthUserChangePassword != nil { + data[i] = 0xfa + i++ + data[i] = 0x44 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthUserChangePassword.Size())) + n17, err := m.AuthUserChangePassword.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n17 + } + if m.AuthUserGrantRole != nil { + data[i] = 0x82 + i++ + data[i] = 0x45 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthUserGrantRole.Size())) + n18, err := m.AuthUserGrantRole.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n18 + } + if m.AuthUserRevokeRole != nil { + data[i] = 0x8a + i++ + data[i] = 0x45 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthUserRevokeRole.Size())) + n19, err := m.AuthUserRevokeRole.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n19 + } + if m.AuthUserList != nil { + data[i] = 0x92 + i++ + data[i] = 0x45 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthUserList.Size())) + n20, err := m.AuthUserList.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n20 + } + if m.AuthRoleList != nil { + data[i] = 0x9a + i++ + data[i] = 0x45 + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthRoleList.Size())) + n21, err := m.AuthRoleList.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n21 + } + if m.AuthRoleAdd != nil { + data[i] = 0x82 + i++ + data[i] = 0x4b + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthRoleAdd.Size())) + n22, err := m.AuthRoleAdd.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n22 + } + if m.AuthRoleDelete != nil { + data[i] = 0x8a + i++ + data[i] = 0x4b + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthRoleDelete.Size())) + n23, err := m.AuthRoleDelete.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n23 + } + if m.AuthRoleGet != nil { + data[i] = 0x92 + i++ + data[i] = 0x4b + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthRoleGet.Size())) + n24, err := m.AuthRoleGet.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n24 + } + if m.AuthRoleGrantPermission != nil { + data[i] = 0x9a + i++ + data[i] = 0x4b + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthRoleGrantPermission.Size())) + n25, err := m.AuthRoleGrantPermission.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n25 + } + if m.AuthRoleRevokePermission != nil { + data[i] = 0xa2 + i++ + data[i] = 0x4b + i++ + i = encodeVarintRaftInternal(data, i, uint64(m.AuthRoleRevokePermission.Size())) + n26, err := m.AuthRoleRevokePermission.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n26 + } + return i, nil +} + +func (m *EmptyResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *EmptyResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *InternalAuthenticateRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *InternalAuthenticateRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRaftInternal(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if len(m.Password) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRaftInternal(data, i, uint64(len(m.Password))) + i += copy(data[i:], m.Password) + } + if len(m.SimpleToken) > 0 { + data[i] = 0x1a + i++ + i = encodeVarintRaftInternal(data, i, uint64(len(m.SimpleToken))) + i += copy(data[i:], m.SimpleToken) + } + return i, nil +} + +func encodeFixed64RaftInternal(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32RaftInternal(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintRaftInternal(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *RequestHeader) Size() (n int) { + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRaftInternal(uint64(m.ID)) + } + l = len(m.Username) + if l > 0 { + n += 1 + l + sovRaftInternal(uint64(l)) + } + if m.AuthRevision != 0 { + n += 1 + sovRaftInternal(uint64(m.AuthRevision)) + } + return n +} + +func (m *InternalRaftRequest) Size() (n int) { + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRaftInternal(uint64(m.ID)) + } + if m.V2 != nil { + l = m.V2.Size() + n += 1 + l + sovRaftInternal(uint64(l)) + } + if m.Range != nil { + l = m.Range.Size() + n += 1 + l + sovRaftInternal(uint64(l)) + } + if m.Put != nil { + l = m.Put.Size() + n += 1 + l + sovRaftInternal(uint64(l)) + } + if m.DeleteRange != nil { + l = m.DeleteRange.Size() + n += 1 + l + sovRaftInternal(uint64(l)) + } + if m.Txn != nil { + l = m.Txn.Size() + n += 1 + l + sovRaftInternal(uint64(l)) + } + if m.Compaction != nil { + l = m.Compaction.Size() + n += 1 + l + sovRaftInternal(uint64(l)) + } + if m.LeaseGrant != nil { + l = m.LeaseGrant.Size() + n += 1 + l + sovRaftInternal(uint64(l)) + } + if m.LeaseRevoke != nil { + l = m.LeaseRevoke.Size() + n += 1 + l + sovRaftInternal(uint64(l)) + } + if m.Alarm != nil { + l = m.Alarm.Size() + n += 1 + l + sovRaftInternal(uint64(l)) + } + if m.Header != nil { + l = m.Header.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthEnable != nil { + l = m.AuthEnable.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthDisable != nil { + l = m.AuthDisable.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.Authenticate != nil { + l = m.Authenticate.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthUserAdd != nil { + l = m.AuthUserAdd.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthUserDelete != nil { + l = m.AuthUserDelete.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthUserGet != nil { + l = m.AuthUserGet.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthUserChangePassword != nil { + l = m.AuthUserChangePassword.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthUserGrantRole != nil { + l = m.AuthUserGrantRole.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthUserRevokeRole != nil { + l = m.AuthUserRevokeRole.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthUserList != nil { + l = m.AuthUserList.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthRoleList != nil { + l = m.AuthRoleList.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthRoleAdd != nil { + l = m.AuthRoleAdd.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthRoleDelete != nil { + l = m.AuthRoleDelete.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthRoleGet != nil { + l = m.AuthRoleGet.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthRoleGrantPermission != nil { + l = m.AuthRoleGrantPermission.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + if m.AuthRoleRevokePermission != nil { + l = m.AuthRoleRevokePermission.Size() + n += 2 + l + sovRaftInternal(uint64(l)) + } + return n +} + +func (m *EmptyResponse) Size() (n int) { + var l int + _ = l + return n +} + +func (m *InternalAuthenticateRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRaftInternal(uint64(l)) + } + l = len(m.Password) + if l > 0 { + n += 1 + l + sovRaftInternal(uint64(l)) + } + l = len(m.SimpleToken) + if l > 0 { + n += 1 + l + sovRaftInternal(uint64(l)) + } + return n +} + +func sovRaftInternal(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozRaftInternal(x uint64) (n int) { + return sovRaftInternal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *RequestHeader) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RequestHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequestHeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Username = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthRevision", wireType) + } + m.AuthRevision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.AuthRevision |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRaftInternal(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRaftInternal + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InternalRaftRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: InternalRaftRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InternalRaftRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field V2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.V2 == nil { + m.V2 = &Request{} + } + if err := m.V2.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Range == nil { + m.Range = &RangeRequest{} + } + if err := m.Range.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Put", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Put == nil { + m.Put = &PutRequest{} + } + if err := m.Put.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeleteRange", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DeleteRange == nil { + m.DeleteRange = &DeleteRangeRequest{} + } + if err := m.DeleteRange.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Txn == nil { + m.Txn = &TxnRequest{} + } + if err := m.Txn.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Compaction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Compaction == nil { + m.Compaction = &CompactionRequest{} + } + if err := m.Compaction.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LeaseGrant", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LeaseGrant == nil { + m.LeaseGrant = &LeaseGrantRequest{} + } + if err := m.LeaseGrant.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LeaseRevoke", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LeaseRevoke == nil { + m.LeaseRevoke = &LeaseRevokeRequest{} + } + if err := m.LeaseRevoke.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Alarm", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Alarm == nil { + m.Alarm = &AlarmRequest{} + } + if err := m.Alarm.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 100: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1000: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthEnable", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthEnable == nil { + m.AuthEnable = &AuthEnableRequest{} + } + if err := m.AuthEnable.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1011: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthDisable", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthDisable == nil { + m.AuthDisable = &AuthDisableRequest{} + } + if err := m.AuthDisable.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1012: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authenticate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Authenticate == nil { + m.Authenticate = &InternalAuthenticateRequest{} + } + if err := m.Authenticate.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1100: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthUserAdd", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthUserAdd == nil { + m.AuthUserAdd = &AuthUserAddRequest{} + } + if err := m.AuthUserAdd.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1101: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthUserDelete", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthUserDelete == nil { + m.AuthUserDelete = &AuthUserDeleteRequest{} + } + if err := m.AuthUserDelete.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1102: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthUserGet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthUserGet == nil { + m.AuthUserGet = &AuthUserGetRequest{} + } + if err := m.AuthUserGet.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1103: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthUserChangePassword", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthUserChangePassword == nil { + m.AuthUserChangePassword = &AuthUserChangePasswordRequest{} + } + if err := m.AuthUserChangePassword.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1104: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthUserGrantRole", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthUserGrantRole == nil { + m.AuthUserGrantRole = &AuthUserGrantRoleRequest{} + } + if err := m.AuthUserGrantRole.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1105: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthUserRevokeRole", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthUserRevokeRole == nil { + m.AuthUserRevokeRole = &AuthUserRevokeRoleRequest{} + } + if err := m.AuthUserRevokeRole.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1106: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthUserList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthUserList == nil { + m.AuthUserList = &AuthUserListRequest{} + } + if err := m.AuthUserList.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1107: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthRoleList == nil { + m.AuthRoleList = &AuthRoleListRequest{} + } + if err := m.AuthRoleList.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleAdd", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthRoleAdd == nil { + m.AuthRoleAdd = &AuthRoleAddRequest{} + } + if err := m.AuthRoleAdd.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1201: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleDelete", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthRoleDelete == nil { + m.AuthRoleDelete = &AuthRoleDeleteRequest{} + } + if err := m.AuthRoleDelete.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1202: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleGet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthRoleGet == nil { + m.AuthRoleGet = &AuthRoleGetRequest{} + } + if err := m.AuthRoleGet.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1203: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleGrantPermission", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthRoleGrantPermission == nil { + m.AuthRoleGrantPermission = &AuthRoleGrantPermissionRequest{} + } + if err := m.AuthRoleGrantPermission.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1204: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleRevokePermission", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthRoleRevokePermission == nil { + m.AuthRoleRevokePermission = &AuthRoleRevokePermissionRequest{} + } + if err := m.AuthRoleRevokePermission.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRaftInternal(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRaftInternal + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EmptyResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EmptyResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EmptyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipRaftInternal(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRaftInternal + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InternalAuthenticateRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: InternalAuthenticateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InternalAuthenticateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Password = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SimpleToken", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRaftInternal + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SimpleToken = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRaftInternal(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRaftInternal + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipRaftInternal(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthRaftInternal + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRaftInternal + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipRaftInternal(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthRaftInternal = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowRaftInternal = fmt.Errorf("proto: integer overflow") +) + +var fileDescriptorRaftInternal = []byte{ + // 837 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x96, 0xdd, 0x52, 0xd3, 0x40, + 0x14, 0xc7, 0x69, 0xf9, 0xec, 0xb6, 0x54, 0x5c, 0x40, 0xd7, 0x32, 0x53, 0xa1, 0x8c, 0x8a, 0x5f, + 0xe8, 0x94, 0x07, 0xd0, 0x4a, 0x19, 0x60, 0x86, 0x61, 0x98, 0x0c, 0xce, 0x38, 0xe3, 0x45, 0x5c, + 0x9a, 0x43, 0x1b, 0x49, 0x93, 0xb8, 0xd9, 0x56, 0x7c, 0x13, 0x1f, 0xc3, 0xaf, 0x87, 0xe0, 0xc2, + 0x0f, 0xd4, 0x17, 0x50, 0xbc, 0xf1, 0xca, 0x1b, 0x7d, 0x00, 0x67, 0x3f, 0x92, 0x34, 0x6d, 0xca, + 0x5d, 0x72, 0xce, 0xff, 0xfc, 0xce, 0xd9, 0xec, 0x7f, 0xbb, 0x45, 0xb3, 0x8c, 0x1e, 0x72, 0xd3, + 0x76, 0x39, 0x30, 0x97, 0x3a, 0xab, 0x3e, 0xf3, 0xb8, 0x87, 0x0b, 0xc0, 0x1b, 0x56, 0x00, 0xac, + 0x0b, 0xcc, 0x3f, 0x28, 0xcd, 0x35, 0xbd, 0xa6, 0x27, 0x13, 0xf7, 0xc4, 0x93, 0xd2, 0x94, 0x66, + 0x62, 0x8d, 0x8e, 0xe4, 0x98, 0xdf, 0x50, 0x8f, 0x95, 0x67, 0x68, 0xda, 0x80, 0x17, 0x1d, 0x08, + 0xf8, 0x16, 0x50, 0x0b, 0x18, 0x2e, 0xa2, 0xec, 0x76, 0x9d, 0x64, 0x16, 0x33, 0x2b, 0x63, 0x46, + 0xd6, 0xae, 0xe3, 0x12, 0x9a, 0xea, 0x04, 0xa2, 0x65, 0x1b, 0x48, 0x76, 0x31, 0xb3, 0x92, 0x33, + 0xa2, 0x77, 0xbc, 0x8c, 0xa6, 0x69, 0x87, 0xb7, 0x4c, 0x06, 0x5d, 0x3b, 0xb0, 0x3d, 0x97, 0x8c, + 0xca, 0xb2, 0x82, 0x08, 0x1a, 0x3a, 0x56, 0xf9, 0x53, 0x44, 0xb3, 0xdb, 0x7a, 0x6a, 0x83, 0x1e, + 0x72, 0xdd, 0x6e, 0xa0, 0xd1, 0x35, 0x94, 0xed, 0x56, 0x65, 0x8b, 0x7c, 0x75, 0x7e, 0xb5, 0x77, + 0x5d, 0xab, 0xba, 0xc4, 0xc8, 0x76, 0xab, 0xf8, 0x3e, 0x1a, 0x67, 0xd4, 0x6d, 0x82, 0xec, 0x95, + 0xaf, 0x96, 0xfa, 0x94, 0x22, 0x15, 0xca, 0x95, 0x10, 0xdf, 0x42, 0xa3, 0x7e, 0x87, 0x93, 0x31, + 0xa9, 0x27, 0x49, 0xfd, 0x5e, 0x27, 0x9c, 0xc7, 0x10, 0x22, 0xbc, 0x8e, 0x0a, 0x16, 0x38, 0xc0, + 0xc1, 0x54, 0x4d, 0xc6, 0x65, 0xd1, 0x62, 0xb2, 0xa8, 0x2e, 0x15, 0x89, 0x56, 0x79, 0x2b, 0x8e, + 0x89, 0x86, 0xfc, 0xd8, 0x25, 0x13, 0x69, 0x0d, 0xf7, 0x8f, 0xdd, 0xa8, 0x21, 0x3f, 0x76, 0xf1, + 0x03, 0x84, 0x1a, 0x5e, 0xdb, 0xa7, 0x0d, 0x2e, 0xbe, 0xdf, 0xa4, 0x2c, 0xb9, 0x9a, 0x2c, 0x59, + 0x8f, 0xf2, 0x61, 0x65, 0x4f, 0x09, 0x7e, 0x88, 0xf2, 0x0e, 0xd0, 0x00, 0xcc, 0x26, 0xa3, 0x2e, + 0x27, 0x53, 0x69, 0x84, 0x1d, 0x21, 0xd8, 0x14, 0xf9, 0x88, 0xe0, 0x44, 0x21, 0xb1, 0x66, 0x45, + 0x60, 0xd0, 0xf5, 0x8e, 0x80, 0xe4, 0xd2, 0xd6, 0x2c, 0x11, 0x86, 0x14, 0x44, 0x6b, 0x76, 0xe2, + 0x98, 0xd8, 0x16, 0xea, 0x50, 0xd6, 0x26, 0x28, 0x6d, 0x5b, 0x6a, 0x22, 0x15, 0x6d, 0x8b, 0x14, + 0xe2, 0x35, 0x34, 0xd1, 0x92, 0x96, 0x23, 0x96, 0x2c, 0x59, 0x48, 0xdd, 0x73, 0xe5, 0x4a, 0x43, + 0x4b, 0x71, 0x0d, 0xe5, 0xa5, 0xe3, 0xc0, 0xa5, 0x07, 0x0e, 0x90, 0xdf, 0xa9, 0x1f, 0xac, 0xd6, + 0xe1, 0xad, 0x0d, 0x29, 0x88, 0x96, 0x4b, 0xa3, 0x10, 0xae, 0x23, 0xe9, 0x4f, 0xd3, 0xb2, 0x03, + 0xc9, 0xf8, 0x3b, 0x99, 0xb6, 0x5e, 0xc1, 0xa8, 0x2b, 0x45, 0xb4, 0x5e, 0x1a, 0xc7, 0xf0, 0xae, + 0xa2, 0x80, 0xcb, 0xed, 0x06, 0xe5, 0x40, 0xfe, 0x29, 0xca, 0xcd, 0x24, 0x25, 0xf4, 0x7d, 0xad, + 0x47, 0x1a, 0xe2, 0x12, 0xf5, 0x78, 0x43, 0x1f, 0x25, 0x71, 0xb6, 0x4c, 0x6a, 0x59, 0xe4, 0xe3, + 0xd4, 0xb0, 0xb1, 0x1e, 0x07, 0xc0, 0x6a, 0x96, 0x95, 0x18, 0x4b, 0xc7, 0xf0, 0x2e, 0x9a, 0x89, + 0x31, 0xca, 0x93, 0xe4, 0x93, 0x22, 0x2d, 0xa7, 0x93, 0xb4, 0x99, 0x35, 0xac, 0x48, 0x13, 0xe1, + 0xe4, 0x58, 0x4d, 0xe0, 0xe4, 0xf3, 0xb9, 0x63, 0x6d, 0x02, 0x1f, 0x18, 0x6b, 0x13, 0x38, 0x6e, + 0xa2, 0x2b, 0x31, 0xa6, 0xd1, 0x12, 0xa7, 0xc4, 0xf4, 0x69, 0x10, 0xbc, 0xf4, 0x98, 0x45, 0xbe, + 0x28, 0xe4, 0xed, 0x74, 0xe4, 0xba, 0x54, 0xef, 0x69, 0x71, 0x48, 0xbf, 0x44, 0x53, 0xd3, 0xf8, + 0x09, 0x9a, 0xeb, 0x99, 0x57, 0xd8, 0xdb, 0x64, 0x9e, 0x03, 0xe4, 0x54, 0xf5, 0xb8, 0x3e, 0x64, + 0x6c, 0x79, 0x34, 0xbc, 0x78, 0xab, 0x2f, 0xd2, 0xfe, 0x0c, 0x7e, 0x8a, 0xe6, 0x63, 0xb2, 0x3a, + 0x29, 0x0a, 0xfd, 0x55, 0xa1, 0x6f, 0xa4, 0xa3, 0xf5, 0x91, 0xe9, 0x61, 0x63, 0x3a, 0x90, 0xc2, + 0x5b, 0xa8, 0x18, 0xc3, 0x1d, 0x3b, 0xe0, 0xe4, 0x9b, 0xa2, 0x2e, 0xa5, 0x53, 0x77, 0xec, 0x80, + 0x27, 0x7c, 0x14, 0x06, 0x23, 0x92, 0x18, 0x4d, 0x91, 0xbe, 0x0f, 0x25, 0x89, 0xd6, 0x03, 0xa4, + 0x30, 0x18, 0x6d, 0xbd, 0x24, 0x09, 0x47, 0xbe, 0xc9, 0x0d, 0xdb, 0x7a, 0x51, 0xd3, 0xef, 0x48, + 0x1d, 0x8b, 0x1c, 0x29, 0x31, 0xda, 0x91, 0x6f, 0x73, 0xc3, 0x1c, 0x29, 0xaa, 0x52, 0x1c, 0x19, + 0x87, 0x93, 0x63, 0x09, 0x47, 0xbe, 0x3b, 0x77, 0xac, 0x7e, 0x47, 0xea, 0x18, 0x7e, 0x8e, 0x4a, + 0x3d, 0x18, 0x69, 0x14, 0x1f, 0x58, 0xdb, 0x0e, 0xe4, 0x3d, 0xf6, 0x5e, 0x31, 0xef, 0x0c, 0x61, + 0x0a, 0xf9, 0x5e, 0xa4, 0x0e, 0xf9, 0x97, 0x69, 0x7a, 0x1e, 0xb7, 0xd1, 0x42, 0xdc, 0x4b, 0x5b, + 0xa7, 0xa7, 0xd9, 0x07, 0xd5, 0xec, 0x6e, 0x7a, 0x33, 0xe5, 0x92, 0xc1, 0x6e, 0x84, 0x0e, 0x11, + 0x54, 0x2e, 0xa0, 0xe9, 0x8d, 0xb6, 0xcf, 0x5f, 0x19, 0x10, 0xf8, 0x9e, 0x1b, 0x40, 0xc5, 0x47, + 0x0b, 0xe7, 0xfc, 0x10, 0x61, 0x8c, 0xc6, 0xe4, 0xed, 0x9e, 0x91, 0xb7, 0xbb, 0x7c, 0x16, 0xb7, + 0x7e, 0x74, 0x3e, 0xf5, 0xad, 0x1f, 0xbe, 0xe3, 0x25, 0x54, 0x08, 0xec, 0xb6, 0xef, 0x80, 0xc9, + 0xbd, 0x23, 0x50, 0x97, 0x7e, 0xce, 0xc8, 0xab, 0xd8, 0xbe, 0x08, 0x3d, 0x9a, 0x3b, 0xf9, 0x59, + 0x1e, 0x39, 0x39, 0x2b, 0x67, 0x4e, 0xcf, 0xca, 0x99, 0x1f, 0x67, 0xe5, 0xcc, 0xeb, 0x5f, 0xe5, + 0x91, 0x83, 0x09, 0xf9, 0x97, 0x63, 0xed, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x02, 0x23, 0xd2, + 0x00, 0xca, 0x08, 0x00, 0x00, +} diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.go new file mode 100644 index 00000000..afb1d606 --- /dev/null +++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.go @@ -0,0 +1,15615 @@ +// Code generated by protoc-gen-gogo. +// source: rpc.proto +// DO NOT EDIT! + +package etcdserverpb + +import ( + "fmt" + + proto "github.com/golang/protobuf/proto" + + math "math" + + authpb "github.com/coreos/etcd/auth/authpb" + + io "io" +) + +import mvccpb "github.com/coreos/etcd/mvcc/mvccpb" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type AlarmType int32 + +const ( + AlarmType_NONE AlarmType = 0 + AlarmType_NOSPACE AlarmType = 1 +) + +var AlarmType_name = map[int32]string{ + 0: "NONE", + 1: "NOSPACE", +} +var AlarmType_value = map[string]int32{ + "NONE": 0, + "NOSPACE": 1, +} + +func (x AlarmType) String() string { + return proto.EnumName(AlarmType_name, int32(x)) +} +func (AlarmType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{0} } + +type RangeRequest_SortOrder int32 + +const ( + RangeRequest_NONE RangeRequest_SortOrder = 0 + RangeRequest_ASCEND RangeRequest_SortOrder = 1 + RangeRequest_DESCEND RangeRequest_SortOrder = 2 +) + +var RangeRequest_SortOrder_name = map[int32]string{ + 0: "NONE", + 1: "ASCEND", + 2: "DESCEND", +} +var RangeRequest_SortOrder_value = map[string]int32{ + "NONE": 0, + "ASCEND": 1, + "DESCEND": 2, +} + +func (x RangeRequest_SortOrder) String() string { + return proto.EnumName(RangeRequest_SortOrder_name, int32(x)) +} +func (RangeRequest_SortOrder) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{1, 0} } + +type RangeRequest_SortTarget int32 + +const ( + RangeRequest_KEY RangeRequest_SortTarget = 0 + RangeRequest_VERSION RangeRequest_SortTarget = 1 + RangeRequest_CREATE RangeRequest_SortTarget = 2 + RangeRequest_MOD RangeRequest_SortTarget = 3 + RangeRequest_VALUE RangeRequest_SortTarget = 4 +) + +var RangeRequest_SortTarget_name = map[int32]string{ + 0: "KEY", + 1: "VERSION", + 2: "CREATE", + 3: "MOD", + 4: "VALUE", +} +var RangeRequest_SortTarget_value = map[string]int32{ + "KEY": 0, + "VERSION": 1, + "CREATE": 2, + "MOD": 3, + "VALUE": 4, +} + +func (x RangeRequest_SortTarget) String() string { + return proto.EnumName(RangeRequest_SortTarget_name, int32(x)) +} +func (RangeRequest_SortTarget) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{1, 1} } + +type Compare_CompareResult int32 + +const ( + Compare_EQUAL Compare_CompareResult = 0 + Compare_GREATER Compare_CompareResult = 1 + Compare_LESS Compare_CompareResult = 2 +) + +var Compare_CompareResult_name = map[int32]string{ + 0: "EQUAL", + 1: "GREATER", + 2: "LESS", +} +var Compare_CompareResult_value = map[string]int32{ + "EQUAL": 0, + "GREATER": 1, + "LESS": 2, +} + +func (x Compare_CompareResult) String() string { + return proto.EnumName(Compare_CompareResult_name, int32(x)) +} +func (Compare_CompareResult) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{9, 0} } + +type Compare_CompareTarget int32 + +const ( + Compare_VERSION Compare_CompareTarget = 0 + Compare_CREATE Compare_CompareTarget = 1 + Compare_MOD Compare_CompareTarget = 2 + Compare_VALUE Compare_CompareTarget = 3 +) + +var Compare_CompareTarget_name = map[int32]string{ + 0: "VERSION", + 1: "CREATE", + 2: "MOD", + 3: "VALUE", +} +var Compare_CompareTarget_value = map[string]int32{ + "VERSION": 0, + "CREATE": 1, + "MOD": 2, + "VALUE": 3, +} + +func (x Compare_CompareTarget) String() string { + return proto.EnumName(Compare_CompareTarget_name, int32(x)) +} +func (Compare_CompareTarget) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{9, 1} } + +type WatchCreateRequest_FilterType int32 + +const ( + // filter out put event. + WatchCreateRequest_NOPUT WatchCreateRequest_FilterType = 0 + // filter out delete event. + WatchCreateRequest_NODELETE WatchCreateRequest_FilterType = 1 +) + +var WatchCreateRequest_FilterType_name = map[int32]string{ + 0: "NOPUT", + 1: "NODELETE", +} +var WatchCreateRequest_FilterType_value = map[string]int32{ + "NOPUT": 0, + "NODELETE": 1, +} + +func (x WatchCreateRequest_FilterType) String() string { + return proto.EnumName(WatchCreateRequest_FilterType_name, int32(x)) +} +func (WatchCreateRequest_FilterType) EnumDescriptor() ([]byte, []int) { + return fileDescriptorRpc, []int{19, 0} +} + +type AlarmRequest_AlarmAction int32 + +const ( + AlarmRequest_GET AlarmRequest_AlarmAction = 0 + AlarmRequest_ACTIVATE AlarmRequest_AlarmAction = 1 + AlarmRequest_DEACTIVATE AlarmRequest_AlarmAction = 2 +) + +var AlarmRequest_AlarmAction_name = map[int32]string{ + 0: "GET", + 1: "ACTIVATE", + 2: "DEACTIVATE", +} +var AlarmRequest_AlarmAction_value = map[string]int32{ + "GET": 0, + "ACTIVATE": 1, + "DEACTIVATE": 2, +} + +func (x AlarmRequest_AlarmAction) String() string { + return proto.EnumName(AlarmRequest_AlarmAction_name, int32(x)) +} +func (AlarmRequest_AlarmAction) EnumDescriptor() ([]byte, []int) { + return fileDescriptorRpc, []int{39, 0} +} + +type ResponseHeader struct { + // cluster_id is the ID of the cluster which sent the response. + ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + // member_id is the ID of the member which sent the response. + MemberId uint64 `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3" json:"member_id,omitempty"` + // revision is the key-value store revision when the request was applied. + Revision int64 `protobuf:"varint,3,opt,name=revision,proto3" json:"revision,omitempty"` + // raft_term is the raft term when the request was applied. + RaftTerm uint64 `protobuf:"varint,4,opt,name=raft_term,json=raftTerm,proto3" json:"raft_term,omitempty"` +} + +func (m *ResponseHeader) Reset() { *m = ResponseHeader{} } +func (m *ResponseHeader) String() string { return proto.CompactTextString(m) } +func (*ResponseHeader) ProtoMessage() {} +func (*ResponseHeader) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{0} } + +type RangeRequest struct { + // key is the first key for the range. If range_end is not given, the request only looks up key. + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // range_end is the upper bound on the requested range [key, range_end). + // If range_end is '\0', the range is all keys >= key. + // If the range_end is one bit larger than the given key, + // then the range requests get the all keys with the prefix (the given key). + // If both key and range_end are '\0', then range requests returns all keys. + RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"` + // limit is a limit on the number of keys returned for the request. + Limit int64 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` + // revision is the point-in-time of the key-value store to use for the range. + // If revision is less or equal to zero, the range is over the newest key-value store. + // If the revision has been compacted, ErrCompacted is returned as a response. + Revision int64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"` + // sort_order is the order for returned sorted results. + SortOrder RangeRequest_SortOrder `protobuf:"varint,5,opt,name=sort_order,json=sortOrder,proto3,enum=etcdserverpb.RangeRequest_SortOrder" json:"sort_order,omitempty"` + // sort_target is the key-value field to use for sorting. + SortTarget RangeRequest_SortTarget `protobuf:"varint,6,opt,name=sort_target,json=sortTarget,proto3,enum=etcdserverpb.RangeRequest_SortTarget" json:"sort_target,omitempty"` + // serializable sets the range request to use serializable member-local reads. + // Range requests are linearizable by default; linearizable requests have higher + // latency and lower throughput than serializable requests but reflect the current + // consensus of the cluster. For better performance, in exchange for possible stale reads, + // a serializable range request is served locally without needing to reach consensus + // with other nodes in the cluster. + Serializable bool `protobuf:"varint,7,opt,name=serializable,proto3" json:"serializable,omitempty"` + // keys_only when set returns only the keys and not the values. + KeysOnly bool `protobuf:"varint,8,opt,name=keys_only,json=keysOnly,proto3" json:"keys_only,omitempty"` + // count_only when set returns only the count of the keys in the range. + CountOnly bool `protobuf:"varint,9,opt,name=count_only,json=countOnly,proto3" json:"count_only,omitempty"` +} + +func (m *RangeRequest) Reset() { *m = RangeRequest{} } +func (m *RangeRequest) String() string { return proto.CompactTextString(m) } +func (*RangeRequest) ProtoMessage() {} +func (*RangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{1} } + +type RangeResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // kvs is the list of key-value pairs matched by the range request. + // kvs is empty when count is requested. + Kvs []*mvccpb.KeyValue `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"` + // more indicates if there are more keys to return in the requested range. + More bool `protobuf:"varint,3,opt,name=more,proto3" json:"more,omitempty"` + // count is set to the number of keys within the range when requested. + Count int64 `protobuf:"varint,4,opt,name=count,proto3" json:"count,omitempty"` +} + +func (m *RangeResponse) Reset() { *m = RangeResponse{} } +func (m *RangeResponse) String() string { return proto.CompactTextString(m) } +func (*RangeResponse) ProtoMessage() {} +func (*RangeResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{2} } + +func (m *RangeResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *RangeResponse) GetKvs() []*mvccpb.KeyValue { + if m != nil { + return m.Kvs + } + return nil +} + +type PutRequest struct { + // key is the key, in bytes, to put into the key-value store. + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // value is the value, in bytes, to associate with the key in the key-value store. + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + // lease is the lease ID to associate with the key in the key-value store. A lease + // value of 0 indicates no lease. + Lease int64 `protobuf:"varint,3,opt,name=lease,proto3" json:"lease,omitempty"` + // If prev_kv is set, etcd gets the previous key-value pair before changing it. + // The previous key-value pair will be returned in the put response. + PrevKv bool `protobuf:"varint,4,opt,name=prev_kv,json=prevKv,proto3" json:"prev_kv,omitempty"` +} + +func (m *PutRequest) Reset() { *m = PutRequest{} } +func (m *PutRequest) String() string { return proto.CompactTextString(m) } +func (*PutRequest) ProtoMessage() {} +func (*PutRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{3} } + +type PutResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // if prev_kv is set in the request, the previous key-value pair will be returned. + PrevKv *mvccpb.KeyValue `protobuf:"bytes,2,opt,name=prev_kv,json=prevKv" json:"prev_kv,omitempty"` +} + +func (m *PutResponse) Reset() { *m = PutResponse{} } +func (m *PutResponse) String() string { return proto.CompactTextString(m) } +func (*PutResponse) ProtoMessage() {} +func (*PutResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{4} } + +func (m *PutResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *PutResponse) GetPrevKv() *mvccpb.KeyValue { + if m != nil { + return m.PrevKv + } + return nil +} + +type DeleteRangeRequest struct { + // key is the first key to delete in the range. + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // range_end is the key following the last key to delete for the range [key, range_end). + // If range_end is not given, the range is defined to contain only the key argument. + // If range_end is '\0', the range is all keys greater than or equal to the key argument. + RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"` + // If prev_kv is set, etcd gets the previous key-value pairs before deleting it. + // The previous key-value pairs will be returned in the delte response. + PrevKv bool `protobuf:"varint,3,opt,name=prev_kv,json=prevKv,proto3" json:"prev_kv,omitempty"` +} + +func (m *DeleteRangeRequest) Reset() { *m = DeleteRangeRequest{} } +func (m *DeleteRangeRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteRangeRequest) ProtoMessage() {} +func (*DeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{5} } + +type DeleteRangeResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // deleted is the number of keys deleted by the delete range request. + Deleted int64 `protobuf:"varint,2,opt,name=deleted,proto3" json:"deleted,omitempty"` + // if prev_kv is set in the request, the previous key-value pairs will be returned. + PrevKvs []*mvccpb.KeyValue `protobuf:"bytes,3,rep,name=prev_kvs,json=prevKvs" json:"prev_kvs,omitempty"` +} + +func (m *DeleteRangeResponse) Reset() { *m = DeleteRangeResponse{} } +func (m *DeleteRangeResponse) String() string { return proto.CompactTextString(m) } +func (*DeleteRangeResponse) ProtoMessage() {} +func (*DeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{6} } + +func (m *DeleteRangeResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *DeleteRangeResponse) GetPrevKvs() []*mvccpb.KeyValue { + if m != nil { + return m.PrevKvs + } + return nil +} + +type RequestOp struct { + // request is a union of request types accepted by a transaction. + // + // Types that are valid to be assigned to Request: + // *RequestOp_RequestRange + // *RequestOp_RequestPut + // *RequestOp_RequestDeleteRange + Request isRequestOp_Request `protobuf_oneof:"request"` +} + +func (m *RequestOp) Reset() { *m = RequestOp{} } +func (m *RequestOp) String() string { return proto.CompactTextString(m) } +func (*RequestOp) ProtoMessage() {} +func (*RequestOp) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{7} } + +type isRequestOp_Request interface { + isRequestOp_Request() + MarshalTo([]byte) (int, error) + Size() int +} + +type RequestOp_RequestRange struct { + RequestRange *RangeRequest `protobuf:"bytes,1,opt,name=request_range,json=requestRange,oneof"` +} +type RequestOp_RequestPut struct { + RequestPut *PutRequest `protobuf:"bytes,2,opt,name=request_put,json=requestPut,oneof"` +} +type RequestOp_RequestDeleteRange struct { + RequestDeleteRange *DeleteRangeRequest `protobuf:"bytes,3,opt,name=request_delete_range,json=requestDeleteRange,oneof"` +} + +func (*RequestOp_RequestRange) isRequestOp_Request() {} +func (*RequestOp_RequestPut) isRequestOp_Request() {} +func (*RequestOp_RequestDeleteRange) isRequestOp_Request() {} + +func (m *RequestOp) GetRequest() isRequestOp_Request { + if m != nil { + return m.Request + } + return nil +} + +func (m *RequestOp) GetRequestRange() *RangeRequest { + if x, ok := m.GetRequest().(*RequestOp_RequestRange); ok { + return x.RequestRange + } + return nil +} + +func (m *RequestOp) GetRequestPut() *PutRequest { + if x, ok := m.GetRequest().(*RequestOp_RequestPut); ok { + return x.RequestPut + } + return nil +} + +func (m *RequestOp) GetRequestDeleteRange() *DeleteRangeRequest { + if x, ok := m.GetRequest().(*RequestOp_RequestDeleteRange); ok { + return x.RequestDeleteRange + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*RequestOp) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _RequestOp_OneofMarshaler, _RequestOp_OneofUnmarshaler, _RequestOp_OneofSizer, []interface{}{ + (*RequestOp_RequestRange)(nil), + (*RequestOp_RequestPut)(nil), + (*RequestOp_RequestDeleteRange)(nil), + } +} + +func _RequestOp_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*RequestOp) + // request + switch x := m.Request.(type) { + case *RequestOp_RequestRange: + _ = b.EncodeVarint(1<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.RequestRange); err != nil { + return err + } + case *RequestOp_RequestPut: + _ = b.EncodeVarint(2<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.RequestPut); err != nil { + return err + } + case *RequestOp_RequestDeleteRange: + _ = b.EncodeVarint(3<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.RequestDeleteRange); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("RequestOp.Request has unexpected type %T", x) + } + return nil +} + +func _RequestOp_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*RequestOp) + switch tag { + case 1: // request.request_range + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(RangeRequest) + err := b.DecodeMessage(msg) + m.Request = &RequestOp_RequestRange{msg} + return true, err + case 2: // request.request_put + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(PutRequest) + err := b.DecodeMessage(msg) + m.Request = &RequestOp_RequestPut{msg} + return true, err + case 3: // request.request_delete_range + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(DeleteRangeRequest) + err := b.DecodeMessage(msg) + m.Request = &RequestOp_RequestDeleteRange{msg} + return true, err + default: + return false, nil + } +} + +func _RequestOp_OneofSizer(msg proto.Message) (n int) { + m := msg.(*RequestOp) + // request + switch x := m.Request.(type) { + case *RequestOp_RequestRange: + s := proto.Size(x.RequestRange) + n += proto.SizeVarint(1<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *RequestOp_RequestPut: + s := proto.Size(x.RequestPut) + n += proto.SizeVarint(2<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *RequestOp_RequestDeleteRange: + s := proto.Size(x.RequestDeleteRange) + n += proto.SizeVarint(3<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +type ResponseOp struct { + // response is a union of response types returned by a transaction. + // + // Types that are valid to be assigned to Response: + // *ResponseOp_ResponseRange + // *ResponseOp_ResponsePut + // *ResponseOp_ResponseDeleteRange + Response isResponseOp_Response `protobuf_oneof:"response"` +} + +func (m *ResponseOp) Reset() { *m = ResponseOp{} } +func (m *ResponseOp) String() string { return proto.CompactTextString(m) } +func (*ResponseOp) ProtoMessage() {} +func (*ResponseOp) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{8} } + +type isResponseOp_Response interface { + isResponseOp_Response() + MarshalTo([]byte) (int, error) + Size() int +} + +type ResponseOp_ResponseRange struct { + ResponseRange *RangeResponse `protobuf:"bytes,1,opt,name=response_range,json=responseRange,oneof"` +} +type ResponseOp_ResponsePut struct { + ResponsePut *PutResponse `protobuf:"bytes,2,opt,name=response_put,json=responsePut,oneof"` +} +type ResponseOp_ResponseDeleteRange struct { + ResponseDeleteRange *DeleteRangeResponse `protobuf:"bytes,3,opt,name=response_delete_range,json=responseDeleteRange,oneof"` +} + +func (*ResponseOp_ResponseRange) isResponseOp_Response() {} +func (*ResponseOp_ResponsePut) isResponseOp_Response() {} +func (*ResponseOp_ResponseDeleteRange) isResponseOp_Response() {} + +func (m *ResponseOp) GetResponse() isResponseOp_Response { + if m != nil { + return m.Response + } + return nil +} + +func (m *ResponseOp) GetResponseRange() *RangeResponse { + if x, ok := m.GetResponse().(*ResponseOp_ResponseRange); ok { + return x.ResponseRange + } + return nil +} + +func (m *ResponseOp) GetResponsePut() *PutResponse { + if x, ok := m.GetResponse().(*ResponseOp_ResponsePut); ok { + return x.ResponsePut + } + return nil +} + +func (m *ResponseOp) GetResponseDeleteRange() *DeleteRangeResponse { + if x, ok := m.GetResponse().(*ResponseOp_ResponseDeleteRange); ok { + return x.ResponseDeleteRange + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*ResponseOp) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _ResponseOp_OneofMarshaler, _ResponseOp_OneofUnmarshaler, _ResponseOp_OneofSizer, []interface{}{ + (*ResponseOp_ResponseRange)(nil), + (*ResponseOp_ResponsePut)(nil), + (*ResponseOp_ResponseDeleteRange)(nil), + } +} + +func _ResponseOp_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*ResponseOp) + // response + switch x := m.Response.(type) { + case *ResponseOp_ResponseRange: + _ = b.EncodeVarint(1<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ResponseRange); err != nil { + return err + } + case *ResponseOp_ResponsePut: + _ = b.EncodeVarint(2<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ResponsePut); err != nil { + return err + } + case *ResponseOp_ResponseDeleteRange: + _ = b.EncodeVarint(3<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ResponseDeleteRange); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("ResponseOp.Response has unexpected type %T", x) + } + return nil +} + +func _ResponseOp_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*ResponseOp) + switch tag { + case 1: // response.response_range + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(RangeResponse) + err := b.DecodeMessage(msg) + m.Response = &ResponseOp_ResponseRange{msg} + return true, err + case 2: // response.response_put + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(PutResponse) + err := b.DecodeMessage(msg) + m.Response = &ResponseOp_ResponsePut{msg} + return true, err + case 3: // response.response_delete_range + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(DeleteRangeResponse) + err := b.DecodeMessage(msg) + m.Response = &ResponseOp_ResponseDeleteRange{msg} + return true, err + default: + return false, nil + } +} + +func _ResponseOp_OneofSizer(msg proto.Message) (n int) { + m := msg.(*ResponseOp) + // response + switch x := m.Response.(type) { + case *ResponseOp_ResponseRange: + s := proto.Size(x.ResponseRange) + n += proto.SizeVarint(1<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *ResponseOp_ResponsePut: + s := proto.Size(x.ResponsePut) + n += proto.SizeVarint(2<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *ResponseOp_ResponseDeleteRange: + s := proto.Size(x.ResponseDeleteRange) + n += proto.SizeVarint(3<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +type Compare struct { + // result is logical comparison operation for this comparison. + Result Compare_CompareResult `protobuf:"varint,1,opt,name=result,proto3,enum=etcdserverpb.Compare_CompareResult" json:"result,omitempty"` + // target is the key-value field to inspect for the comparison. + Target Compare_CompareTarget `protobuf:"varint,2,opt,name=target,proto3,enum=etcdserverpb.Compare_CompareTarget" json:"target,omitempty"` + // key is the subject key for the comparison operation. + Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` + // Types that are valid to be assigned to TargetUnion: + // *Compare_Version + // *Compare_CreateRevision + // *Compare_ModRevision + // *Compare_Value + TargetUnion isCompare_TargetUnion `protobuf_oneof:"target_union"` +} + +func (m *Compare) Reset() { *m = Compare{} } +func (m *Compare) String() string { return proto.CompactTextString(m) } +func (*Compare) ProtoMessage() {} +func (*Compare) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{9} } + +type isCompare_TargetUnion interface { + isCompare_TargetUnion() + MarshalTo([]byte) (int, error) + Size() int +} + +type Compare_Version struct { + Version int64 `protobuf:"varint,4,opt,name=version,proto3,oneof"` +} +type Compare_CreateRevision struct { + CreateRevision int64 `protobuf:"varint,5,opt,name=create_revision,json=createRevision,proto3,oneof"` +} +type Compare_ModRevision struct { + ModRevision int64 `protobuf:"varint,6,opt,name=mod_revision,json=modRevision,proto3,oneof"` +} +type Compare_Value struct { + Value []byte `protobuf:"bytes,7,opt,name=value,proto3,oneof"` +} + +func (*Compare_Version) isCompare_TargetUnion() {} +func (*Compare_CreateRevision) isCompare_TargetUnion() {} +func (*Compare_ModRevision) isCompare_TargetUnion() {} +func (*Compare_Value) isCompare_TargetUnion() {} + +func (m *Compare) GetTargetUnion() isCompare_TargetUnion { + if m != nil { + return m.TargetUnion + } + return nil +} + +func (m *Compare) GetVersion() int64 { + if x, ok := m.GetTargetUnion().(*Compare_Version); ok { + return x.Version + } + return 0 +} + +func (m *Compare) GetCreateRevision() int64 { + if x, ok := m.GetTargetUnion().(*Compare_CreateRevision); ok { + return x.CreateRevision + } + return 0 +} + +func (m *Compare) GetModRevision() int64 { + if x, ok := m.GetTargetUnion().(*Compare_ModRevision); ok { + return x.ModRevision + } + return 0 +} + +func (m *Compare) GetValue() []byte { + if x, ok := m.GetTargetUnion().(*Compare_Value); ok { + return x.Value + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Compare) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _Compare_OneofMarshaler, _Compare_OneofUnmarshaler, _Compare_OneofSizer, []interface{}{ + (*Compare_Version)(nil), + (*Compare_CreateRevision)(nil), + (*Compare_ModRevision)(nil), + (*Compare_Value)(nil), + } +} + +func _Compare_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*Compare) + // target_union + switch x := m.TargetUnion.(type) { + case *Compare_Version: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Version)) + case *Compare_CreateRevision: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.CreateRevision)) + case *Compare_ModRevision: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.ModRevision)) + case *Compare_Value: + _ = b.EncodeVarint(7<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Value) + case nil: + default: + return fmt.Errorf("Compare.TargetUnion has unexpected type %T", x) + } + return nil +} + +func _Compare_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*Compare) + switch tag { + case 4: // target_union.version + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TargetUnion = &Compare_Version{int64(x)} + return true, err + case 5: // target_union.create_revision + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TargetUnion = &Compare_CreateRevision{int64(x)} + return true, err + case 6: // target_union.mod_revision + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TargetUnion = &Compare_ModRevision{int64(x)} + return true, err + case 7: // target_union.value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TargetUnion = &Compare_Value{x} + return true, err + default: + return false, nil + } +} + +func _Compare_OneofSizer(msg proto.Message) (n int) { + m := msg.(*Compare) + // target_union + switch x := m.TargetUnion.(type) { + case *Compare_Version: + n += proto.SizeVarint(4<<3 | proto.WireVarint) + n += proto.SizeVarint(uint64(x.Version)) + case *Compare_CreateRevision: + n += proto.SizeVarint(5<<3 | proto.WireVarint) + n += proto.SizeVarint(uint64(x.CreateRevision)) + case *Compare_ModRevision: + n += proto.SizeVarint(6<<3 | proto.WireVarint) + n += proto.SizeVarint(uint64(x.ModRevision)) + case *Compare_Value: + n += proto.SizeVarint(7<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.Value))) + n += len(x.Value) + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// From google paxosdb paper: +// Our implementation hinges around a powerful primitive which we call MultiOp. All other database +// operations except for iteration are implemented as a single call to MultiOp. A MultiOp is applied atomically +// and consists of three components: +// 1. A list of tests called guard. Each test in guard checks a single entry in the database. It may check +// for the absence or presence of a value, or compare with a given value. Two different tests in the guard +// may apply to the same or different entries in the database. All tests in the guard are applied and +// MultiOp returns the results. If all tests are true, MultiOp executes t op (see item 2 below), otherwise +// it executes f op (see item 3 below). +// 2. A list of database operations called t op. Each operation in the list is either an insert, delete, or +// lookup operation, and applies to a single database entry. Two different operations in the list may apply +// to the same or different entries in the database. These operations are executed +// if guard evaluates to +// true. +// 3. A list of database operations called f op. Like t op, but executed if guard evaluates to false. +type TxnRequest struct { + // compare is a list of predicates representing a conjunction of terms. + // If the comparisons succeed, then the success requests will be processed in order, + // and the response will contain their respective responses in order. + // If the comparisons fail, then the failure requests will be processed in order, + // and the response will contain their respective responses in order. + Compare []*Compare `protobuf:"bytes,1,rep,name=compare" json:"compare,omitempty"` + // success is a list of requests which will be applied when compare evaluates to true. + Success []*RequestOp `protobuf:"bytes,2,rep,name=success" json:"success,omitempty"` + // failure is a list of requests which will be applied when compare evaluates to false. + Failure []*RequestOp `protobuf:"bytes,3,rep,name=failure" json:"failure,omitempty"` +} + +func (m *TxnRequest) Reset() { *m = TxnRequest{} } +func (m *TxnRequest) String() string { return proto.CompactTextString(m) } +func (*TxnRequest) ProtoMessage() {} +func (*TxnRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{10} } + +func (m *TxnRequest) GetCompare() []*Compare { + if m != nil { + return m.Compare + } + return nil +} + +func (m *TxnRequest) GetSuccess() []*RequestOp { + if m != nil { + return m.Success + } + return nil +} + +func (m *TxnRequest) GetFailure() []*RequestOp { + if m != nil { + return m.Failure + } + return nil +} + +type TxnResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // succeeded is set to true if the compare evaluated to true or false otherwise. + Succeeded bool `protobuf:"varint,2,opt,name=succeeded,proto3" json:"succeeded,omitempty"` + // responses is a list of responses corresponding to the results from applying + // success if succeeded is true or failure if succeeded is false. + Responses []*ResponseOp `protobuf:"bytes,3,rep,name=responses" json:"responses,omitempty"` +} + +func (m *TxnResponse) Reset() { *m = TxnResponse{} } +func (m *TxnResponse) String() string { return proto.CompactTextString(m) } +func (*TxnResponse) ProtoMessage() {} +func (*TxnResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{11} } + +func (m *TxnResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *TxnResponse) GetResponses() []*ResponseOp { + if m != nil { + return m.Responses + } + return nil +} + +// CompactionRequest compacts the key-value store up to a given revision. All superseded keys +// with a revision less than the compaction revision will be removed. +type CompactionRequest struct { + // revision is the key-value store revision for the compaction operation. + Revision int64 `protobuf:"varint,1,opt,name=revision,proto3" json:"revision,omitempty"` + // physical is set so the RPC will wait until the compaction is physically + // applied to the local database such that compacted entries are totally + // removed from the backend database. + Physical bool `protobuf:"varint,2,opt,name=physical,proto3" json:"physical,omitempty"` +} + +func (m *CompactionRequest) Reset() { *m = CompactionRequest{} } +func (m *CompactionRequest) String() string { return proto.CompactTextString(m) } +func (*CompactionRequest) ProtoMessage() {} +func (*CompactionRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{12} } + +type CompactionResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *CompactionResponse) Reset() { *m = CompactionResponse{} } +func (m *CompactionResponse) String() string { return proto.CompactTextString(m) } +func (*CompactionResponse) ProtoMessage() {} +func (*CompactionResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{13} } + +func (m *CompactionResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type HashRequest struct { +} + +func (m *HashRequest) Reset() { *m = HashRequest{} } +func (m *HashRequest) String() string { return proto.CompactTextString(m) } +func (*HashRequest) ProtoMessage() {} +func (*HashRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{14} } + +type HashResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // hash is the hash value computed from the responding member's key-value store. + Hash uint32 `protobuf:"varint,2,opt,name=hash,proto3" json:"hash,omitempty"` +} + +func (m *HashResponse) Reset() { *m = HashResponse{} } +func (m *HashResponse) String() string { return proto.CompactTextString(m) } +func (*HashResponse) ProtoMessage() {} +func (*HashResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{15} } + +func (m *HashResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type SnapshotRequest struct { +} + +func (m *SnapshotRequest) Reset() { *m = SnapshotRequest{} } +func (m *SnapshotRequest) String() string { return proto.CompactTextString(m) } +func (*SnapshotRequest) ProtoMessage() {} +func (*SnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{16} } + +type SnapshotResponse struct { + // header has the current key-value store information. The first header in the snapshot + // stream indicates the point in time of the snapshot. + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // remaining_bytes is the number of blob bytes to be sent after this message + RemainingBytes uint64 `protobuf:"varint,2,opt,name=remaining_bytes,json=remainingBytes,proto3" json:"remaining_bytes,omitempty"` + // blob contains the next chunk of the snapshot in the snapshot stream. + Blob []byte `protobuf:"bytes,3,opt,name=blob,proto3" json:"blob,omitempty"` +} + +func (m *SnapshotResponse) Reset() { *m = SnapshotResponse{} } +func (m *SnapshotResponse) String() string { return proto.CompactTextString(m) } +func (*SnapshotResponse) ProtoMessage() {} +func (*SnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{17} } + +func (m *SnapshotResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type WatchRequest struct { + // request_union is a request to either create a new watcher or cancel an existing watcher. + // + // Types that are valid to be assigned to RequestUnion: + // *WatchRequest_CreateRequest + // *WatchRequest_CancelRequest + RequestUnion isWatchRequest_RequestUnion `protobuf_oneof:"request_union"` +} + +func (m *WatchRequest) Reset() { *m = WatchRequest{} } +func (m *WatchRequest) String() string { return proto.CompactTextString(m) } +func (*WatchRequest) ProtoMessage() {} +func (*WatchRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{18} } + +type isWatchRequest_RequestUnion interface { + isWatchRequest_RequestUnion() + MarshalTo([]byte) (int, error) + Size() int +} + +type WatchRequest_CreateRequest struct { + CreateRequest *WatchCreateRequest `protobuf:"bytes,1,opt,name=create_request,json=createRequest,oneof"` +} +type WatchRequest_CancelRequest struct { + CancelRequest *WatchCancelRequest `protobuf:"bytes,2,opt,name=cancel_request,json=cancelRequest,oneof"` +} + +func (*WatchRequest_CreateRequest) isWatchRequest_RequestUnion() {} +func (*WatchRequest_CancelRequest) isWatchRequest_RequestUnion() {} + +func (m *WatchRequest) GetRequestUnion() isWatchRequest_RequestUnion { + if m != nil { + return m.RequestUnion + } + return nil +} + +func (m *WatchRequest) GetCreateRequest() *WatchCreateRequest { + if x, ok := m.GetRequestUnion().(*WatchRequest_CreateRequest); ok { + return x.CreateRequest + } + return nil +} + +func (m *WatchRequest) GetCancelRequest() *WatchCancelRequest { + if x, ok := m.GetRequestUnion().(*WatchRequest_CancelRequest); ok { + return x.CancelRequest + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*WatchRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _WatchRequest_OneofMarshaler, _WatchRequest_OneofUnmarshaler, _WatchRequest_OneofSizer, []interface{}{ + (*WatchRequest_CreateRequest)(nil), + (*WatchRequest_CancelRequest)(nil), + } +} + +func _WatchRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*WatchRequest) + // request_union + switch x := m.RequestUnion.(type) { + case *WatchRequest_CreateRequest: + _ = b.EncodeVarint(1<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.CreateRequest); err != nil { + return err + } + case *WatchRequest_CancelRequest: + _ = b.EncodeVarint(2<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.CancelRequest); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("WatchRequest.RequestUnion has unexpected type %T", x) + } + return nil +} + +func _WatchRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*WatchRequest) + switch tag { + case 1: // request_union.create_request + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(WatchCreateRequest) + err := b.DecodeMessage(msg) + m.RequestUnion = &WatchRequest_CreateRequest{msg} + return true, err + case 2: // request_union.cancel_request + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(WatchCancelRequest) + err := b.DecodeMessage(msg) + m.RequestUnion = &WatchRequest_CancelRequest{msg} + return true, err + default: + return false, nil + } +} + +func _WatchRequest_OneofSizer(msg proto.Message) (n int) { + m := msg.(*WatchRequest) + // request_union + switch x := m.RequestUnion.(type) { + case *WatchRequest_CreateRequest: + s := proto.Size(x.CreateRequest) + n += proto.SizeVarint(1<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *WatchRequest_CancelRequest: + s := proto.Size(x.CancelRequest) + n += proto.SizeVarint(2<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +type WatchCreateRequest struct { + // key is the key to register for watching. + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // range_end is the end of the range [key, range_end) to watch. If range_end is not given, + // only the key argument is watched. If range_end is equal to '\0', all keys greater than + // or equal to the key argument are watched. + RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"` + // start_revision is an optional revision to watch from (inclusive). No start_revision is "now". + StartRevision int64 `protobuf:"varint,3,opt,name=start_revision,json=startRevision,proto3" json:"start_revision,omitempty"` + // progress_notify is set so that the etcd server will periodically send a WatchResponse with + // no events to the new watcher if there are no recent events. It is useful when clients + // wish to recover a disconnected watcher starting from a recent known revision. + // The etcd server may decide how often it will send notifications based on current load. + ProgressNotify bool `protobuf:"varint,4,opt,name=progress_notify,json=progressNotify,proto3" json:"progress_notify,omitempty"` + // filters filter the events at server side before it sends back to the watcher. + Filters []WatchCreateRequest_FilterType `protobuf:"varint,5,rep,name=filters,enum=etcdserverpb.WatchCreateRequest_FilterType" json:"filters,omitempty"` + // If prev_kv is set, created watcher gets the previous KV before the event happens. + // If the previous KV is already compacted, nothing will be returned. + PrevKv bool `protobuf:"varint,6,opt,name=prev_kv,json=prevKv,proto3" json:"prev_kv,omitempty"` +} + +func (m *WatchCreateRequest) Reset() { *m = WatchCreateRequest{} } +func (m *WatchCreateRequest) String() string { return proto.CompactTextString(m) } +func (*WatchCreateRequest) ProtoMessage() {} +func (*WatchCreateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{19} } + +type WatchCancelRequest struct { + // watch_id is the watcher id to cancel so that no more events are transmitted. + WatchId int64 `protobuf:"varint,1,opt,name=watch_id,json=watchId,proto3" json:"watch_id,omitempty"` +} + +func (m *WatchCancelRequest) Reset() { *m = WatchCancelRequest{} } +func (m *WatchCancelRequest) String() string { return proto.CompactTextString(m) } +func (*WatchCancelRequest) ProtoMessage() {} +func (*WatchCancelRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{20} } + +type WatchResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // watch_id is the ID of the watcher that corresponds to the response. + WatchId int64 `protobuf:"varint,2,opt,name=watch_id,json=watchId,proto3" json:"watch_id,omitempty"` + // created is set to true if the response is for a create watch request. + // The client should record the watch_id and expect to receive events for + // the created watcher from the same stream. + // All events sent to the created watcher will attach with the same watch_id. + Created bool `protobuf:"varint,3,opt,name=created,proto3" json:"created,omitempty"` + // canceled is set to true if the response is for a cancel watch request. + // No further events will be sent to the canceled watcher. + Canceled bool `protobuf:"varint,4,opt,name=canceled,proto3" json:"canceled,omitempty"` + // compact_revision is set to the minimum index if a watcher tries to watch + // at a compacted index. + // + // This happens when creating a watcher at a compacted revision or the watcher cannot + // catch up with the progress of the key-value store. + // + // The client should treat the watcher as canceled and should not try to create any + // watcher with the same start_revision again. + CompactRevision int64 `protobuf:"varint,5,opt,name=compact_revision,json=compactRevision,proto3" json:"compact_revision,omitempty"` + Events []*mvccpb.Event `protobuf:"bytes,11,rep,name=events" json:"events,omitempty"` +} + +func (m *WatchResponse) Reset() { *m = WatchResponse{} } +func (m *WatchResponse) String() string { return proto.CompactTextString(m) } +func (*WatchResponse) ProtoMessage() {} +func (*WatchResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{21} } + +func (m *WatchResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *WatchResponse) GetEvents() []*mvccpb.Event { + if m != nil { + return m.Events + } + return nil +} + +type LeaseGrantRequest struct { + // TTL is the advisory time-to-live in seconds. + TTL int64 `protobuf:"varint,1,opt,name=TTL,json=tTL,proto3" json:"TTL,omitempty"` + // ID is the requested ID for the lease. If ID is set to 0, the lessor chooses an ID. + ID int64 `protobuf:"varint,2,opt,name=ID,json=iD,proto3" json:"ID,omitempty"` +} + +func (m *LeaseGrantRequest) Reset() { *m = LeaseGrantRequest{} } +func (m *LeaseGrantRequest) String() string { return proto.CompactTextString(m) } +func (*LeaseGrantRequest) ProtoMessage() {} +func (*LeaseGrantRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{22} } + +type LeaseGrantResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // ID is the lease ID for the granted lease. + ID int64 `protobuf:"varint,2,opt,name=ID,json=iD,proto3" json:"ID,omitempty"` + // TTL is the server chosen lease time-to-live in seconds. + TTL int64 `protobuf:"varint,3,opt,name=TTL,json=tTL,proto3" json:"TTL,omitempty"` + Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"` +} + +func (m *LeaseGrantResponse) Reset() { *m = LeaseGrantResponse{} } +func (m *LeaseGrantResponse) String() string { return proto.CompactTextString(m) } +func (*LeaseGrantResponse) ProtoMessage() {} +func (*LeaseGrantResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{23} } + +func (m *LeaseGrantResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type LeaseRevokeRequest struct { + // ID is the lease ID to revoke. When the ID is revoked, all associated keys will be deleted. + ID int64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"` +} + +func (m *LeaseRevokeRequest) Reset() { *m = LeaseRevokeRequest{} } +func (m *LeaseRevokeRequest) String() string { return proto.CompactTextString(m) } +func (*LeaseRevokeRequest) ProtoMessage() {} +func (*LeaseRevokeRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{24} } + +type LeaseRevokeResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *LeaseRevokeResponse) Reset() { *m = LeaseRevokeResponse{} } +func (m *LeaseRevokeResponse) String() string { return proto.CompactTextString(m) } +func (*LeaseRevokeResponse) ProtoMessage() {} +func (*LeaseRevokeResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{25} } + +func (m *LeaseRevokeResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type LeaseKeepAliveRequest struct { + // ID is the lease ID for the lease to keep alive. + ID int64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"` +} + +func (m *LeaseKeepAliveRequest) Reset() { *m = LeaseKeepAliveRequest{} } +func (m *LeaseKeepAliveRequest) String() string { return proto.CompactTextString(m) } +func (*LeaseKeepAliveRequest) ProtoMessage() {} +func (*LeaseKeepAliveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{26} } + +type LeaseKeepAliveResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // ID is the lease ID from the keep alive request. + ID int64 `protobuf:"varint,2,opt,name=ID,json=iD,proto3" json:"ID,omitempty"` + // TTL is the new time-to-live for the lease. + TTL int64 `protobuf:"varint,3,opt,name=TTL,json=tTL,proto3" json:"TTL,omitempty"` +} + +func (m *LeaseKeepAliveResponse) Reset() { *m = LeaseKeepAliveResponse{} } +func (m *LeaseKeepAliveResponse) String() string { return proto.CompactTextString(m) } +func (*LeaseKeepAliveResponse) ProtoMessage() {} +func (*LeaseKeepAliveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{27} } + +func (m *LeaseKeepAliveResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type Member struct { + // ID is the member ID for this member. + ID uint64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"` + // name is the human-readable name of the member. If the member is not started, the name will be an empty string. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + // peerURLs is the list of URLs the member exposes to the cluster for communication. + PeerURLs []string `protobuf:"bytes,3,rep,name=peerURLs" json:"peerURLs,omitempty"` + // clientURLs is the list of URLs the member exposes to clients for communication. If the member is not started, clientURLs will be empty. + ClientURLs []string `protobuf:"bytes,4,rep,name=clientURLs" json:"clientURLs,omitempty"` +} + +func (m *Member) Reset() { *m = Member{} } +func (m *Member) String() string { return proto.CompactTextString(m) } +func (*Member) ProtoMessage() {} +func (*Member) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{28} } + +type MemberAddRequest struct { + // peerURLs is the list of URLs the added member will use to communicate with the cluster. + PeerURLs []string `protobuf:"bytes,1,rep,name=peerURLs" json:"peerURLs,omitempty"` +} + +func (m *MemberAddRequest) Reset() { *m = MemberAddRequest{} } +func (m *MemberAddRequest) String() string { return proto.CompactTextString(m) } +func (*MemberAddRequest) ProtoMessage() {} +func (*MemberAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{29} } + +type MemberAddResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // member is the member information for the added member. + Member *Member `protobuf:"bytes,2,opt,name=member" json:"member,omitempty"` +} + +func (m *MemberAddResponse) Reset() { *m = MemberAddResponse{} } +func (m *MemberAddResponse) String() string { return proto.CompactTextString(m) } +func (*MemberAddResponse) ProtoMessage() {} +func (*MemberAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{30} } + +func (m *MemberAddResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *MemberAddResponse) GetMember() *Member { + if m != nil { + return m.Member + } + return nil +} + +type MemberRemoveRequest struct { + // ID is the member ID of the member to remove. + ID uint64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"` +} + +func (m *MemberRemoveRequest) Reset() { *m = MemberRemoveRequest{} } +func (m *MemberRemoveRequest) String() string { return proto.CompactTextString(m) } +func (*MemberRemoveRequest) ProtoMessage() {} +func (*MemberRemoveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{31} } + +type MemberRemoveResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *MemberRemoveResponse) Reset() { *m = MemberRemoveResponse{} } +func (m *MemberRemoveResponse) String() string { return proto.CompactTextString(m) } +func (*MemberRemoveResponse) ProtoMessage() {} +func (*MemberRemoveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{32} } + +func (m *MemberRemoveResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type MemberUpdateRequest struct { + // ID is the member ID of the member to update. + ID uint64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"` + // peerURLs is the new list of URLs the member will use to communicate with the cluster. + PeerURLs []string `protobuf:"bytes,2,rep,name=peerURLs" json:"peerURLs,omitempty"` +} + +func (m *MemberUpdateRequest) Reset() { *m = MemberUpdateRequest{} } +func (m *MemberUpdateRequest) String() string { return proto.CompactTextString(m) } +func (*MemberUpdateRequest) ProtoMessage() {} +func (*MemberUpdateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{33} } + +type MemberUpdateResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *MemberUpdateResponse) Reset() { *m = MemberUpdateResponse{} } +func (m *MemberUpdateResponse) String() string { return proto.CompactTextString(m) } +func (*MemberUpdateResponse) ProtoMessage() {} +func (*MemberUpdateResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{34} } + +func (m *MemberUpdateResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type MemberListRequest struct { +} + +func (m *MemberListRequest) Reset() { *m = MemberListRequest{} } +func (m *MemberListRequest) String() string { return proto.CompactTextString(m) } +func (*MemberListRequest) ProtoMessage() {} +func (*MemberListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{35} } + +type MemberListResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // members is a list of all members associated with the cluster. + Members []*Member `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"` +} + +func (m *MemberListResponse) Reset() { *m = MemberListResponse{} } +func (m *MemberListResponse) String() string { return proto.CompactTextString(m) } +func (*MemberListResponse) ProtoMessage() {} +func (*MemberListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{36} } + +func (m *MemberListResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *MemberListResponse) GetMembers() []*Member { + if m != nil { + return m.Members + } + return nil +} + +type DefragmentRequest struct { +} + +func (m *DefragmentRequest) Reset() { *m = DefragmentRequest{} } +func (m *DefragmentRequest) String() string { return proto.CompactTextString(m) } +func (*DefragmentRequest) ProtoMessage() {} +func (*DefragmentRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{37} } + +type DefragmentResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *DefragmentResponse) Reset() { *m = DefragmentResponse{} } +func (m *DefragmentResponse) String() string { return proto.CompactTextString(m) } +func (*DefragmentResponse) ProtoMessage() {} +func (*DefragmentResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{38} } + +func (m *DefragmentResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AlarmRequest struct { + // action is the kind of alarm request to issue. The action + // may GET alarm statuses, ACTIVATE an alarm, or DEACTIVATE a + // raised alarm. + Action AlarmRequest_AlarmAction `protobuf:"varint,1,opt,name=action,proto3,enum=etcdserverpb.AlarmRequest_AlarmAction" json:"action,omitempty"` + // memberID is the ID of the member associated with the alarm. If memberID is 0, the + // alarm request covers all members. + MemberID uint64 `protobuf:"varint,2,opt,name=memberID,proto3" json:"memberID,omitempty"` + // alarm is the type of alarm to consider for this request. + Alarm AlarmType `protobuf:"varint,3,opt,name=alarm,proto3,enum=etcdserverpb.AlarmType" json:"alarm,omitempty"` +} + +func (m *AlarmRequest) Reset() { *m = AlarmRequest{} } +func (m *AlarmRequest) String() string { return proto.CompactTextString(m) } +func (*AlarmRequest) ProtoMessage() {} +func (*AlarmRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{39} } + +type AlarmMember struct { + // memberID is the ID of the member associated with the raised alarm. + MemberID uint64 `protobuf:"varint,1,opt,name=memberID,proto3" json:"memberID,omitempty"` + // alarm is the type of alarm which has been raised. + Alarm AlarmType `protobuf:"varint,2,opt,name=alarm,proto3,enum=etcdserverpb.AlarmType" json:"alarm,omitempty"` +} + +func (m *AlarmMember) Reset() { *m = AlarmMember{} } +func (m *AlarmMember) String() string { return proto.CompactTextString(m) } +func (*AlarmMember) ProtoMessage() {} +func (*AlarmMember) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{40} } + +type AlarmResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // alarms is a list of alarms associated with the alarm request. + Alarms []*AlarmMember `protobuf:"bytes,2,rep,name=alarms" json:"alarms,omitempty"` +} + +func (m *AlarmResponse) Reset() { *m = AlarmResponse{} } +func (m *AlarmResponse) String() string { return proto.CompactTextString(m) } +func (*AlarmResponse) ProtoMessage() {} +func (*AlarmResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{41} } + +func (m *AlarmResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *AlarmResponse) GetAlarms() []*AlarmMember { + if m != nil { + return m.Alarms + } + return nil +} + +type StatusRequest struct { +} + +func (m *StatusRequest) Reset() { *m = StatusRequest{} } +func (m *StatusRequest) String() string { return proto.CompactTextString(m) } +func (*StatusRequest) ProtoMessage() {} +func (*StatusRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{42} } + +type StatusResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // version is the cluster protocol version used by the responding member. + Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` + // dbSize is the size of the backend database, in bytes, of the responding member. + DbSize int64 `protobuf:"varint,3,opt,name=dbSize,proto3" json:"dbSize,omitempty"` + // leader is the member ID which the responding member believes is the current leader. + Leader uint64 `protobuf:"varint,4,opt,name=leader,proto3" json:"leader,omitempty"` + // raftIndex is the current raft index of the responding member. + RaftIndex uint64 `protobuf:"varint,5,opt,name=raftIndex,proto3" json:"raftIndex,omitempty"` + // raftTerm is the current raft term of the responding member. + RaftTerm uint64 `protobuf:"varint,6,opt,name=raftTerm,proto3" json:"raftTerm,omitempty"` +} + +func (m *StatusResponse) Reset() { *m = StatusResponse{} } +func (m *StatusResponse) String() string { return proto.CompactTextString(m) } +func (*StatusResponse) ProtoMessage() {} +func (*StatusResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{43} } + +func (m *StatusResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthEnableRequest struct { +} + +func (m *AuthEnableRequest) Reset() { *m = AuthEnableRequest{} } +func (m *AuthEnableRequest) String() string { return proto.CompactTextString(m) } +func (*AuthEnableRequest) ProtoMessage() {} +func (*AuthEnableRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{44} } + +type AuthDisableRequest struct { +} + +func (m *AuthDisableRequest) Reset() { *m = AuthDisableRequest{} } +func (m *AuthDisableRequest) String() string { return proto.CompactTextString(m) } +func (*AuthDisableRequest) ProtoMessage() {} +func (*AuthDisableRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{45} } + +type AuthenticateRequest struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"` +} + +func (m *AuthenticateRequest) Reset() { *m = AuthenticateRequest{} } +func (m *AuthenticateRequest) String() string { return proto.CompactTextString(m) } +func (*AuthenticateRequest) ProtoMessage() {} +func (*AuthenticateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{46} } + +type AuthUserAddRequest struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"` +} + +func (m *AuthUserAddRequest) Reset() { *m = AuthUserAddRequest{} } +func (m *AuthUserAddRequest) String() string { return proto.CompactTextString(m) } +func (*AuthUserAddRequest) ProtoMessage() {} +func (*AuthUserAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{47} } + +type AuthUserGetRequest struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (m *AuthUserGetRequest) Reset() { *m = AuthUserGetRequest{} } +func (m *AuthUserGetRequest) String() string { return proto.CompactTextString(m) } +func (*AuthUserGetRequest) ProtoMessage() {} +func (*AuthUserGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{48} } + +type AuthUserDeleteRequest struct { + // name is the name of the user to delete. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (m *AuthUserDeleteRequest) Reset() { *m = AuthUserDeleteRequest{} } +func (m *AuthUserDeleteRequest) String() string { return proto.CompactTextString(m) } +func (*AuthUserDeleteRequest) ProtoMessage() {} +func (*AuthUserDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{49} } + +type AuthUserChangePasswordRequest struct { + // name is the name of the user whose password is being changed. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // password is the new password for the user. + Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"` +} + +func (m *AuthUserChangePasswordRequest) Reset() { *m = AuthUserChangePasswordRequest{} } +func (m *AuthUserChangePasswordRequest) String() string { return proto.CompactTextString(m) } +func (*AuthUserChangePasswordRequest) ProtoMessage() {} +func (*AuthUserChangePasswordRequest) Descriptor() ([]byte, []int) { + return fileDescriptorRpc, []int{50} +} + +type AuthUserGrantRoleRequest struct { + // user is the name of the user which should be granted a given role. + User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"` + // role is the name of the role to grant to the user. + Role string `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"` +} + +func (m *AuthUserGrantRoleRequest) Reset() { *m = AuthUserGrantRoleRequest{} } +func (m *AuthUserGrantRoleRequest) String() string { return proto.CompactTextString(m) } +func (*AuthUserGrantRoleRequest) ProtoMessage() {} +func (*AuthUserGrantRoleRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{51} } + +type AuthUserRevokeRoleRequest struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Role string `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"` +} + +func (m *AuthUserRevokeRoleRequest) Reset() { *m = AuthUserRevokeRoleRequest{} } +func (m *AuthUserRevokeRoleRequest) String() string { return proto.CompactTextString(m) } +func (*AuthUserRevokeRoleRequest) ProtoMessage() {} +func (*AuthUserRevokeRoleRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{52} } + +type AuthRoleAddRequest struct { + // name is the name of the role to add to the authentication system. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (m *AuthRoleAddRequest) Reset() { *m = AuthRoleAddRequest{} } +func (m *AuthRoleAddRequest) String() string { return proto.CompactTextString(m) } +func (*AuthRoleAddRequest) ProtoMessage() {} +func (*AuthRoleAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{53} } + +type AuthRoleGetRequest struct { + Role string `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"` +} + +func (m *AuthRoleGetRequest) Reset() { *m = AuthRoleGetRequest{} } +func (m *AuthRoleGetRequest) String() string { return proto.CompactTextString(m) } +func (*AuthRoleGetRequest) ProtoMessage() {} +func (*AuthRoleGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{54} } + +type AuthUserListRequest struct { +} + +func (m *AuthUserListRequest) Reset() { *m = AuthUserListRequest{} } +func (m *AuthUserListRequest) String() string { return proto.CompactTextString(m) } +func (*AuthUserListRequest) ProtoMessage() {} +func (*AuthUserListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{55} } + +type AuthRoleListRequest struct { +} + +func (m *AuthRoleListRequest) Reset() { *m = AuthRoleListRequest{} } +func (m *AuthRoleListRequest) String() string { return proto.CompactTextString(m) } +func (*AuthRoleListRequest) ProtoMessage() {} +func (*AuthRoleListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{56} } + +type AuthRoleDeleteRequest struct { + Role string `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"` +} + +func (m *AuthRoleDeleteRequest) Reset() { *m = AuthRoleDeleteRequest{} } +func (m *AuthRoleDeleteRequest) String() string { return proto.CompactTextString(m) } +func (*AuthRoleDeleteRequest) ProtoMessage() {} +func (*AuthRoleDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{57} } + +type AuthRoleGrantPermissionRequest struct { + // name is the name of the role which will be granted the permission. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // perm is the permission to grant to the role. + Perm *authpb.Permission `protobuf:"bytes,2,opt,name=perm" json:"perm,omitempty"` +} + +func (m *AuthRoleGrantPermissionRequest) Reset() { *m = AuthRoleGrantPermissionRequest{} } +func (m *AuthRoleGrantPermissionRequest) String() string { return proto.CompactTextString(m) } +func (*AuthRoleGrantPermissionRequest) ProtoMessage() {} +func (*AuthRoleGrantPermissionRequest) Descriptor() ([]byte, []int) { + return fileDescriptorRpc, []int{58} +} + +func (m *AuthRoleGrantPermissionRequest) GetPerm() *authpb.Permission { + if m != nil { + return m.Perm + } + return nil +} + +type AuthRoleRevokePermissionRequest struct { + Role string `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"` + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + RangeEnd string `protobuf:"bytes,3,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"` +} + +func (m *AuthRoleRevokePermissionRequest) Reset() { *m = AuthRoleRevokePermissionRequest{} } +func (m *AuthRoleRevokePermissionRequest) String() string { return proto.CompactTextString(m) } +func (*AuthRoleRevokePermissionRequest) ProtoMessage() {} +func (*AuthRoleRevokePermissionRequest) Descriptor() ([]byte, []int) { + return fileDescriptorRpc, []int{59} +} + +type AuthEnableResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthEnableResponse) Reset() { *m = AuthEnableResponse{} } +func (m *AuthEnableResponse) String() string { return proto.CompactTextString(m) } +func (*AuthEnableResponse) ProtoMessage() {} +func (*AuthEnableResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{60} } + +func (m *AuthEnableResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthDisableResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthDisableResponse) Reset() { *m = AuthDisableResponse{} } +func (m *AuthDisableResponse) String() string { return proto.CompactTextString(m) } +func (*AuthDisableResponse) ProtoMessage() {} +func (*AuthDisableResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{61} } + +func (m *AuthDisableResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthenticateResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + // token is an authorized token that can be used in succeeding RPCs + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` +} + +func (m *AuthenticateResponse) Reset() { *m = AuthenticateResponse{} } +func (m *AuthenticateResponse) String() string { return proto.CompactTextString(m) } +func (*AuthenticateResponse) ProtoMessage() {} +func (*AuthenticateResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{62} } + +func (m *AuthenticateResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthUserAddResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthUserAddResponse) Reset() { *m = AuthUserAddResponse{} } +func (m *AuthUserAddResponse) String() string { return proto.CompactTextString(m) } +func (*AuthUserAddResponse) ProtoMessage() {} +func (*AuthUserAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{63} } + +func (m *AuthUserAddResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthUserGetResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Roles []string `protobuf:"bytes,2,rep,name=roles" json:"roles,omitempty"` +} + +func (m *AuthUserGetResponse) Reset() { *m = AuthUserGetResponse{} } +func (m *AuthUserGetResponse) String() string { return proto.CompactTextString(m) } +func (*AuthUserGetResponse) ProtoMessage() {} +func (*AuthUserGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{64} } + +func (m *AuthUserGetResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthUserDeleteResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthUserDeleteResponse) Reset() { *m = AuthUserDeleteResponse{} } +func (m *AuthUserDeleteResponse) String() string { return proto.CompactTextString(m) } +func (*AuthUserDeleteResponse) ProtoMessage() {} +func (*AuthUserDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{65} } + +func (m *AuthUserDeleteResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthUserChangePasswordResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthUserChangePasswordResponse) Reset() { *m = AuthUserChangePasswordResponse{} } +func (m *AuthUserChangePasswordResponse) String() string { return proto.CompactTextString(m) } +func (*AuthUserChangePasswordResponse) ProtoMessage() {} +func (*AuthUserChangePasswordResponse) Descriptor() ([]byte, []int) { + return fileDescriptorRpc, []int{66} +} + +func (m *AuthUserChangePasswordResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthUserGrantRoleResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthUserGrantRoleResponse) Reset() { *m = AuthUserGrantRoleResponse{} } +func (m *AuthUserGrantRoleResponse) String() string { return proto.CompactTextString(m) } +func (*AuthUserGrantRoleResponse) ProtoMessage() {} +func (*AuthUserGrantRoleResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{67} } + +func (m *AuthUserGrantRoleResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthUserRevokeRoleResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthUserRevokeRoleResponse) Reset() { *m = AuthUserRevokeRoleResponse{} } +func (m *AuthUserRevokeRoleResponse) String() string { return proto.CompactTextString(m) } +func (*AuthUserRevokeRoleResponse) ProtoMessage() {} +func (*AuthUserRevokeRoleResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{68} } + +func (m *AuthUserRevokeRoleResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthRoleAddResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthRoleAddResponse) Reset() { *m = AuthRoleAddResponse{} } +func (m *AuthRoleAddResponse) String() string { return proto.CompactTextString(m) } +func (*AuthRoleAddResponse) ProtoMessage() {} +func (*AuthRoleAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{69} } + +func (m *AuthRoleAddResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthRoleGetResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Perm []*authpb.Permission `protobuf:"bytes,2,rep,name=perm" json:"perm,omitempty"` +} + +func (m *AuthRoleGetResponse) Reset() { *m = AuthRoleGetResponse{} } +func (m *AuthRoleGetResponse) String() string { return proto.CompactTextString(m) } +func (*AuthRoleGetResponse) ProtoMessage() {} +func (*AuthRoleGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{70} } + +func (m *AuthRoleGetResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *AuthRoleGetResponse) GetPerm() []*authpb.Permission { + if m != nil { + return m.Perm + } + return nil +} + +type AuthRoleListResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Roles []string `protobuf:"bytes,2,rep,name=roles" json:"roles,omitempty"` +} + +func (m *AuthRoleListResponse) Reset() { *m = AuthRoleListResponse{} } +func (m *AuthRoleListResponse) String() string { return proto.CompactTextString(m) } +func (*AuthRoleListResponse) ProtoMessage() {} +func (*AuthRoleListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{71} } + +func (m *AuthRoleListResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthUserListResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Users []string `protobuf:"bytes,2,rep,name=users" json:"users,omitempty"` +} + +func (m *AuthUserListResponse) Reset() { *m = AuthUserListResponse{} } +func (m *AuthUserListResponse) String() string { return proto.CompactTextString(m) } +func (*AuthUserListResponse) ProtoMessage() {} +func (*AuthUserListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{72} } + +func (m *AuthUserListResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthRoleDeleteResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthRoleDeleteResponse) Reset() { *m = AuthRoleDeleteResponse{} } +func (m *AuthRoleDeleteResponse) String() string { return proto.CompactTextString(m) } +func (*AuthRoleDeleteResponse) ProtoMessage() {} +func (*AuthRoleDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{73} } + +func (m *AuthRoleDeleteResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthRoleGrantPermissionResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthRoleGrantPermissionResponse) Reset() { *m = AuthRoleGrantPermissionResponse{} } +func (m *AuthRoleGrantPermissionResponse) String() string { return proto.CompactTextString(m) } +func (*AuthRoleGrantPermissionResponse) ProtoMessage() {} +func (*AuthRoleGrantPermissionResponse) Descriptor() ([]byte, []int) { + return fileDescriptorRpc, []int{74} +} + +func (m *AuthRoleGrantPermissionResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +type AuthRoleRevokePermissionResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` +} + +func (m *AuthRoleRevokePermissionResponse) Reset() { *m = AuthRoleRevokePermissionResponse{} } +func (m *AuthRoleRevokePermissionResponse) String() string { return proto.CompactTextString(m) } +func (*AuthRoleRevokePermissionResponse) ProtoMessage() {} +func (*AuthRoleRevokePermissionResponse) Descriptor() ([]byte, []int) { + return fileDescriptorRpc, []int{75} +} + +func (m *AuthRoleRevokePermissionResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func init() { + proto.RegisterType((*ResponseHeader)(nil), "etcdserverpb.ResponseHeader") + proto.RegisterType((*RangeRequest)(nil), "etcdserverpb.RangeRequest") + proto.RegisterType((*RangeResponse)(nil), "etcdserverpb.RangeResponse") + proto.RegisterType((*PutRequest)(nil), "etcdserverpb.PutRequest") + proto.RegisterType((*PutResponse)(nil), "etcdserverpb.PutResponse") + proto.RegisterType((*DeleteRangeRequest)(nil), "etcdserverpb.DeleteRangeRequest") + proto.RegisterType((*DeleteRangeResponse)(nil), "etcdserverpb.DeleteRangeResponse") + proto.RegisterType((*RequestOp)(nil), "etcdserverpb.RequestOp") + proto.RegisterType((*ResponseOp)(nil), "etcdserverpb.ResponseOp") + proto.RegisterType((*Compare)(nil), "etcdserverpb.Compare") + proto.RegisterType((*TxnRequest)(nil), "etcdserverpb.TxnRequest") + proto.RegisterType((*TxnResponse)(nil), "etcdserverpb.TxnResponse") + proto.RegisterType((*CompactionRequest)(nil), "etcdserverpb.CompactionRequest") + proto.RegisterType((*CompactionResponse)(nil), "etcdserverpb.CompactionResponse") + proto.RegisterType((*HashRequest)(nil), "etcdserverpb.HashRequest") + proto.RegisterType((*HashResponse)(nil), "etcdserverpb.HashResponse") + proto.RegisterType((*SnapshotRequest)(nil), "etcdserverpb.SnapshotRequest") + proto.RegisterType((*SnapshotResponse)(nil), "etcdserverpb.SnapshotResponse") + proto.RegisterType((*WatchRequest)(nil), "etcdserverpb.WatchRequest") + proto.RegisterType((*WatchCreateRequest)(nil), "etcdserverpb.WatchCreateRequest") + proto.RegisterType((*WatchCancelRequest)(nil), "etcdserverpb.WatchCancelRequest") + proto.RegisterType((*WatchResponse)(nil), "etcdserverpb.WatchResponse") + proto.RegisterType((*LeaseGrantRequest)(nil), "etcdserverpb.LeaseGrantRequest") + proto.RegisterType((*LeaseGrantResponse)(nil), "etcdserverpb.LeaseGrantResponse") + proto.RegisterType((*LeaseRevokeRequest)(nil), "etcdserverpb.LeaseRevokeRequest") + proto.RegisterType((*LeaseRevokeResponse)(nil), "etcdserverpb.LeaseRevokeResponse") + proto.RegisterType((*LeaseKeepAliveRequest)(nil), "etcdserverpb.LeaseKeepAliveRequest") + proto.RegisterType((*LeaseKeepAliveResponse)(nil), "etcdserverpb.LeaseKeepAliveResponse") + proto.RegisterType((*Member)(nil), "etcdserverpb.Member") + proto.RegisterType((*MemberAddRequest)(nil), "etcdserverpb.MemberAddRequest") + proto.RegisterType((*MemberAddResponse)(nil), "etcdserverpb.MemberAddResponse") + proto.RegisterType((*MemberRemoveRequest)(nil), "etcdserverpb.MemberRemoveRequest") + proto.RegisterType((*MemberRemoveResponse)(nil), "etcdserverpb.MemberRemoveResponse") + proto.RegisterType((*MemberUpdateRequest)(nil), "etcdserverpb.MemberUpdateRequest") + proto.RegisterType((*MemberUpdateResponse)(nil), "etcdserverpb.MemberUpdateResponse") + proto.RegisterType((*MemberListRequest)(nil), "etcdserverpb.MemberListRequest") + proto.RegisterType((*MemberListResponse)(nil), "etcdserverpb.MemberListResponse") + proto.RegisterType((*DefragmentRequest)(nil), "etcdserverpb.DefragmentRequest") + proto.RegisterType((*DefragmentResponse)(nil), "etcdserverpb.DefragmentResponse") + proto.RegisterType((*AlarmRequest)(nil), "etcdserverpb.AlarmRequest") + proto.RegisterType((*AlarmMember)(nil), "etcdserverpb.AlarmMember") + proto.RegisterType((*AlarmResponse)(nil), "etcdserverpb.AlarmResponse") + proto.RegisterType((*StatusRequest)(nil), "etcdserverpb.StatusRequest") + proto.RegisterType((*StatusResponse)(nil), "etcdserverpb.StatusResponse") + proto.RegisterType((*AuthEnableRequest)(nil), "etcdserverpb.AuthEnableRequest") + proto.RegisterType((*AuthDisableRequest)(nil), "etcdserverpb.AuthDisableRequest") + proto.RegisterType((*AuthenticateRequest)(nil), "etcdserverpb.AuthenticateRequest") + proto.RegisterType((*AuthUserAddRequest)(nil), "etcdserverpb.AuthUserAddRequest") + proto.RegisterType((*AuthUserGetRequest)(nil), "etcdserverpb.AuthUserGetRequest") + proto.RegisterType((*AuthUserDeleteRequest)(nil), "etcdserverpb.AuthUserDeleteRequest") + proto.RegisterType((*AuthUserChangePasswordRequest)(nil), "etcdserverpb.AuthUserChangePasswordRequest") + proto.RegisterType((*AuthUserGrantRoleRequest)(nil), "etcdserverpb.AuthUserGrantRoleRequest") + proto.RegisterType((*AuthUserRevokeRoleRequest)(nil), "etcdserverpb.AuthUserRevokeRoleRequest") + proto.RegisterType((*AuthRoleAddRequest)(nil), "etcdserverpb.AuthRoleAddRequest") + proto.RegisterType((*AuthRoleGetRequest)(nil), "etcdserverpb.AuthRoleGetRequest") + proto.RegisterType((*AuthUserListRequest)(nil), "etcdserverpb.AuthUserListRequest") + proto.RegisterType((*AuthRoleListRequest)(nil), "etcdserverpb.AuthRoleListRequest") + proto.RegisterType((*AuthRoleDeleteRequest)(nil), "etcdserverpb.AuthRoleDeleteRequest") + proto.RegisterType((*AuthRoleGrantPermissionRequest)(nil), "etcdserverpb.AuthRoleGrantPermissionRequest") + proto.RegisterType((*AuthRoleRevokePermissionRequest)(nil), "etcdserverpb.AuthRoleRevokePermissionRequest") + proto.RegisterType((*AuthEnableResponse)(nil), "etcdserverpb.AuthEnableResponse") + proto.RegisterType((*AuthDisableResponse)(nil), "etcdserverpb.AuthDisableResponse") + proto.RegisterType((*AuthenticateResponse)(nil), "etcdserverpb.AuthenticateResponse") + proto.RegisterType((*AuthUserAddResponse)(nil), "etcdserverpb.AuthUserAddResponse") + proto.RegisterType((*AuthUserGetResponse)(nil), "etcdserverpb.AuthUserGetResponse") + proto.RegisterType((*AuthUserDeleteResponse)(nil), "etcdserverpb.AuthUserDeleteResponse") + proto.RegisterType((*AuthUserChangePasswordResponse)(nil), "etcdserverpb.AuthUserChangePasswordResponse") + proto.RegisterType((*AuthUserGrantRoleResponse)(nil), "etcdserverpb.AuthUserGrantRoleResponse") + proto.RegisterType((*AuthUserRevokeRoleResponse)(nil), "etcdserverpb.AuthUserRevokeRoleResponse") + proto.RegisterType((*AuthRoleAddResponse)(nil), "etcdserverpb.AuthRoleAddResponse") + proto.RegisterType((*AuthRoleGetResponse)(nil), "etcdserverpb.AuthRoleGetResponse") + proto.RegisterType((*AuthRoleListResponse)(nil), "etcdserverpb.AuthRoleListResponse") + proto.RegisterType((*AuthUserListResponse)(nil), "etcdserverpb.AuthUserListResponse") + proto.RegisterType((*AuthRoleDeleteResponse)(nil), "etcdserverpb.AuthRoleDeleteResponse") + proto.RegisterType((*AuthRoleGrantPermissionResponse)(nil), "etcdserverpb.AuthRoleGrantPermissionResponse") + proto.RegisterType((*AuthRoleRevokePermissionResponse)(nil), "etcdserverpb.AuthRoleRevokePermissionResponse") + proto.RegisterEnum("etcdserverpb.AlarmType", AlarmType_name, AlarmType_value) + proto.RegisterEnum("etcdserverpb.RangeRequest_SortOrder", RangeRequest_SortOrder_name, RangeRequest_SortOrder_value) + proto.RegisterEnum("etcdserverpb.RangeRequest_SortTarget", RangeRequest_SortTarget_name, RangeRequest_SortTarget_value) + proto.RegisterEnum("etcdserverpb.Compare_CompareResult", Compare_CompareResult_name, Compare_CompareResult_value) + proto.RegisterEnum("etcdserverpb.Compare_CompareTarget", Compare_CompareTarget_name, Compare_CompareTarget_value) + proto.RegisterEnum("etcdserverpb.WatchCreateRequest_FilterType", WatchCreateRequest_FilterType_name, WatchCreateRequest_FilterType_value) + proto.RegisterEnum("etcdserverpb.AlarmRequest_AlarmAction", AlarmRequest_AlarmAction_name, AlarmRequest_AlarmAction_value) +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion3 + +// Client API for KV service + +type KVClient interface { + // Range gets the keys in the range from the key-value store. + Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error) + // Put puts the given key into the key-value store. + // A put request increments the revision of the key-value store + // and generates one event in the event history. + Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error) + // DeleteRange deletes the given range from the key-value store. + // A delete request increments the revision of the key-value store + // and generates a delete event in the event history for every deleted key. + DeleteRange(ctx context.Context, in *DeleteRangeRequest, opts ...grpc.CallOption) (*DeleteRangeResponse, error) + // Txn processes multiple requests in a single transaction. + // A txn request increments the revision of the key-value store + // and generates events with the same revision for every completed request. + // It is not allowed to modify the same key several times within one txn. + Txn(ctx context.Context, in *TxnRequest, opts ...grpc.CallOption) (*TxnResponse, error) + // Compact compacts the event history in the etcd key-value store. The key-value + // store should be periodically compacted or the event history will continue to grow + // indefinitely. + Compact(ctx context.Context, in *CompactionRequest, opts ...grpc.CallOption) (*CompactionResponse, error) +} + +type kVClient struct { + cc *grpc.ClientConn +} + +func NewKVClient(cc *grpc.ClientConn) KVClient { + return &kVClient{cc} +} + +func (c *kVClient) Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error) { + out := new(RangeResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.KV/Range", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *kVClient) Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error) { + out := new(PutResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.KV/Put", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *kVClient) DeleteRange(ctx context.Context, in *DeleteRangeRequest, opts ...grpc.CallOption) (*DeleteRangeResponse, error) { + out := new(DeleteRangeResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.KV/DeleteRange", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *kVClient) Txn(ctx context.Context, in *TxnRequest, opts ...grpc.CallOption) (*TxnResponse, error) { + out := new(TxnResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.KV/Txn", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *kVClient) Compact(ctx context.Context, in *CompactionRequest, opts ...grpc.CallOption) (*CompactionResponse, error) { + out := new(CompactionResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.KV/Compact", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for KV service + +type KVServer interface { + // Range gets the keys in the range from the key-value store. + Range(context.Context, *RangeRequest) (*RangeResponse, error) + // Put puts the given key into the key-value store. + // A put request increments the revision of the key-value store + // and generates one event in the event history. + Put(context.Context, *PutRequest) (*PutResponse, error) + // DeleteRange deletes the given range from the key-value store. + // A delete request increments the revision of the key-value store + // and generates a delete event in the event history for every deleted key. + DeleteRange(context.Context, *DeleteRangeRequest) (*DeleteRangeResponse, error) + // Txn processes multiple requests in a single transaction. + // A txn request increments the revision of the key-value store + // and generates events with the same revision for every completed request. + // It is not allowed to modify the same key several times within one txn. + Txn(context.Context, *TxnRequest) (*TxnResponse, error) + // Compact compacts the event history in the etcd key-value store. The key-value + // store should be periodically compacted or the event history will continue to grow + // indefinitely. + Compact(context.Context, *CompactionRequest) (*CompactionResponse, error) +} + +func RegisterKVServer(s *grpc.Server, srv KVServer) { + s.RegisterService(&_KV_serviceDesc, srv) +} + +func _KV_Range_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RangeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(KVServer).Range(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.KV/Range", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(KVServer).Range(ctx, req.(*RangeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _KV_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PutRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(KVServer).Put(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.KV/Put", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(KVServer).Put(ctx, req.(*PutRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _KV_DeleteRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteRangeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(KVServer).DeleteRange(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.KV/DeleteRange", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(KVServer).DeleteRange(ctx, req.(*DeleteRangeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _KV_Txn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TxnRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(KVServer).Txn(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.KV/Txn", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(KVServer).Txn(ctx, req.(*TxnRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _KV_Compact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CompactionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(KVServer).Compact(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.KV/Compact", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(KVServer).Compact(ctx, req.(*CompactionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _KV_serviceDesc = grpc.ServiceDesc{ + ServiceName: "etcdserverpb.KV", + HandlerType: (*KVServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Range", + Handler: _KV_Range_Handler, + }, + { + MethodName: "Put", + Handler: _KV_Put_Handler, + }, + { + MethodName: "DeleteRange", + Handler: _KV_DeleteRange_Handler, + }, + { + MethodName: "Txn", + Handler: _KV_Txn_Handler, + }, + { + MethodName: "Compact", + Handler: _KV_Compact_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: fileDescriptorRpc, +} + +// Client API for Watch service + +type WatchClient interface { + // Watch watches for events happening or that have happened. Both input and output + // are streams; the input stream is for creating and canceling watchers and the output + // stream sends events. One watch RPC can watch on multiple key ranges, streaming events + // for several watches at once. The entire event history can be watched starting from the + // last compaction revision. + Watch(ctx context.Context, opts ...grpc.CallOption) (Watch_WatchClient, error) +} + +type watchClient struct { + cc *grpc.ClientConn +} + +func NewWatchClient(cc *grpc.ClientConn) WatchClient { + return &watchClient{cc} +} + +func (c *watchClient) Watch(ctx context.Context, opts ...grpc.CallOption) (Watch_WatchClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Watch_serviceDesc.Streams[0], c.cc, "/etcdserverpb.Watch/Watch", opts...) + if err != nil { + return nil, err + } + x := &watchWatchClient{stream} + return x, nil +} + +type Watch_WatchClient interface { + Send(*WatchRequest) error + Recv() (*WatchResponse, error) + grpc.ClientStream +} + +type watchWatchClient struct { + grpc.ClientStream +} + +func (x *watchWatchClient) Send(m *WatchRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *watchWatchClient) Recv() (*WatchResponse, error) { + m := new(WatchResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// Server API for Watch service + +type WatchServer interface { + // Watch watches for events happening or that have happened. Both input and output + // are streams; the input stream is for creating and canceling watchers and the output + // stream sends events. One watch RPC can watch on multiple key ranges, streaming events + // for several watches at once. The entire event history can be watched starting from the + // last compaction revision. + Watch(Watch_WatchServer) error +} + +func RegisterWatchServer(s *grpc.Server, srv WatchServer) { + s.RegisterService(&_Watch_serviceDesc, srv) +} + +func _Watch_Watch_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(WatchServer).Watch(&watchWatchServer{stream}) +} + +type Watch_WatchServer interface { + Send(*WatchResponse) error + Recv() (*WatchRequest, error) + grpc.ServerStream +} + +type watchWatchServer struct { + grpc.ServerStream +} + +func (x *watchWatchServer) Send(m *WatchResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *watchWatchServer) Recv() (*WatchRequest, error) { + m := new(WatchRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +var _Watch_serviceDesc = grpc.ServiceDesc{ + ServiceName: "etcdserverpb.Watch", + HandlerType: (*WatchServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "Watch", + Handler: _Watch_Watch_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: fileDescriptorRpc, +} + +// Client API for Lease service + +type LeaseClient interface { + // LeaseGrant creates a lease which expires if the server does not receive a keepAlive + // within a given time to live period. All keys attached to the lease will be expired and + // deleted if the lease expires. Each expired key generates a delete event in the event history. + LeaseGrant(ctx context.Context, in *LeaseGrantRequest, opts ...grpc.CallOption) (*LeaseGrantResponse, error) + // LeaseRevoke revokes a lease. All keys attached to the lease will expire and be deleted. + LeaseRevoke(ctx context.Context, in *LeaseRevokeRequest, opts ...grpc.CallOption) (*LeaseRevokeResponse, error) + // LeaseKeepAlive keeps the lease alive by streaming keep alive requests from the client + // to the server and streaming keep alive responses from the server to the client. + LeaseKeepAlive(ctx context.Context, opts ...grpc.CallOption) (Lease_LeaseKeepAliveClient, error) +} + +type leaseClient struct { + cc *grpc.ClientConn +} + +func NewLeaseClient(cc *grpc.ClientConn) LeaseClient { + return &leaseClient{cc} +} + +func (c *leaseClient) LeaseGrant(ctx context.Context, in *LeaseGrantRequest, opts ...grpc.CallOption) (*LeaseGrantResponse, error) { + out := new(LeaseGrantResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Lease/LeaseGrant", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *leaseClient) LeaseRevoke(ctx context.Context, in *LeaseRevokeRequest, opts ...grpc.CallOption) (*LeaseRevokeResponse, error) { + out := new(LeaseRevokeResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Lease/LeaseRevoke", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *leaseClient) LeaseKeepAlive(ctx context.Context, opts ...grpc.CallOption) (Lease_LeaseKeepAliveClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Lease_serviceDesc.Streams[0], c.cc, "/etcdserverpb.Lease/LeaseKeepAlive", opts...) + if err != nil { + return nil, err + } + x := &leaseLeaseKeepAliveClient{stream} + return x, nil +} + +type Lease_LeaseKeepAliveClient interface { + Send(*LeaseKeepAliveRequest) error + Recv() (*LeaseKeepAliveResponse, error) + grpc.ClientStream +} + +type leaseLeaseKeepAliveClient struct { + grpc.ClientStream +} + +func (x *leaseLeaseKeepAliveClient) Send(m *LeaseKeepAliveRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *leaseLeaseKeepAliveClient) Recv() (*LeaseKeepAliveResponse, error) { + m := new(LeaseKeepAliveResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// Server API for Lease service + +type LeaseServer interface { + // LeaseGrant creates a lease which expires if the server does not receive a keepAlive + // within a given time to live period. All keys attached to the lease will be expired and + // deleted if the lease expires. Each expired key generates a delete event in the event history. + LeaseGrant(context.Context, *LeaseGrantRequest) (*LeaseGrantResponse, error) + // LeaseRevoke revokes a lease. All keys attached to the lease will expire and be deleted. + LeaseRevoke(context.Context, *LeaseRevokeRequest) (*LeaseRevokeResponse, error) + // LeaseKeepAlive keeps the lease alive by streaming keep alive requests from the client + // to the server and streaming keep alive responses from the server to the client. + LeaseKeepAlive(Lease_LeaseKeepAliveServer) error +} + +func RegisterLeaseServer(s *grpc.Server, srv LeaseServer) { + s.RegisterService(&_Lease_serviceDesc, srv) +} + +func _Lease_LeaseGrant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LeaseGrantRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LeaseServer).LeaseGrant(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Lease/LeaseGrant", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LeaseServer).LeaseGrant(ctx, req.(*LeaseGrantRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lease_LeaseRevoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LeaseRevokeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LeaseServer).LeaseRevoke(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Lease/LeaseRevoke", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LeaseServer).LeaseRevoke(ctx, req.(*LeaseRevokeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lease_LeaseKeepAlive_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(LeaseServer).LeaseKeepAlive(&leaseLeaseKeepAliveServer{stream}) +} + +type Lease_LeaseKeepAliveServer interface { + Send(*LeaseKeepAliveResponse) error + Recv() (*LeaseKeepAliveRequest, error) + grpc.ServerStream +} + +type leaseLeaseKeepAliveServer struct { + grpc.ServerStream +} + +func (x *leaseLeaseKeepAliveServer) Send(m *LeaseKeepAliveResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *leaseLeaseKeepAliveServer) Recv() (*LeaseKeepAliveRequest, error) { + m := new(LeaseKeepAliveRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +var _Lease_serviceDesc = grpc.ServiceDesc{ + ServiceName: "etcdserverpb.Lease", + HandlerType: (*LeaseServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "LeaseGrant", + Handler: _Lease_LeaseGrant_Handler, + }, + { + MethodName: "LeaseRevoke", + Handler: _Lease_LeaseRevoke_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "LeaseKeepAlive", + Handler: _Lease_LeaseKeepAlive_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: fileDescriptorRpc, +} + +// Client API for Cluster service + +type ClusterClient interface { + // MemberAdd adds a member into the cluster. + MemberAdd(ctx context.Context, in *MemberAddRequest, opts ...grpc.CallOption) (*MemberAddResponse, error) + // MemberRemove removes an existing member from the cluster. + MemberRemove(ctx context.Context, in *MemberRemoveRequest, opts ...grpc.CallOption) (*MemberRemoveResponse, error) + // MemberUpdate updates the member configuration. + MemberUpdate(ctx context.Context, in *MemberUpdateRequest, opts ...grpc.CallOption) (*MemberUpdateResponse, error) + // MemberList lists all the members in the cluster. + MemberList(ctx context.Context, in *MemberListRequest, opts ...grpc.CallOption) (*MemberListResponse, error) +} + +type clusterClient struct { + cc *grpc.ClientConn +} + +func NewClusterClient(cc *grpc.ClientConn) ClusterClient { + return &clusterClient{cc} +} + +func (c *clusterClient) MemberAdd(ctx context.Context, in *MemberAddRequest, opts ...grpc.CallOption) (*MemberAddResponse, error) { + out := new(MemberAddResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Cluster/MemberAdd", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *clusterClient) MemberRemove(ctx context.Context, in *MemberRemoveRequest, opts ...grpc.CallOption) (*MemberRemoveResponse, error) { + out := new(MemberRemoveResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Cluster/MemberRemove", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *clusterClient) MemberUpdate(ctx context.Context, in *MemberUpdateRequest, opts ...grpc.CallOption) (*MemberUpdateResponse, error) { + out := new(MemberUpdateResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Cluster/MemberUpdate", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *clusterClient) MemberList(ctx context.Context, in *MemberListRequest, opts ...grpc.CallOption) (*MemberListResponse, error) { + out := new(MemberListResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Cluster/MemberList", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for Cluster service + +type ClusterServer interface { + // MemberAdd adds a member into the cluster. + MemberAdd(context.Context, *MemberAddRequest) (*MemberAddResponse, error) + // MemberRemove removes an existing member from the cluster. + MemberRemove(context.Context, *MemberRemoveRequest) (*MemberRemoveResponse, error) + // MemberUpdate updates the member configuration. + MemberUpdate(context.Context, *MemberUpdateRequest) (*MemberUpdateResponse, error) + // MemberList lists all the members in the cluster. + MemberList(context.Context, *MemberListRequest) (*MemberListResponse, error) +} + +func RegisterClusterServer(s *grpc.Server, srv ClusterServer) { + s.RegisterService(&_Cluster_serviceDesc, srv) +} + +func _Cluster_MemberAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MemberAddRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterServer).MemberAdd(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Cluster/MemberAdd", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterServer).MemberAdd(ctx, req.(*MemberAddRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Cluster_MemberRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MemberRemoveRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterServer).MemberRemove(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Cluster/MemberRemove", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterServer).MemberRemove(ctx, req.(*MemberRemoveRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Cluster_MemberUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MemberUpdateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterServer).MemberUpdate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Cluster/MemberUpdate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterServer).MemberUpdate(ctx, req.(*MemberUpdateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Cluster_MemberList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MemberListRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterServer).MemberList(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Cluster/MemberList", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterServer).MemberList(ctx, req.(*MemberListRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Cluster_serviceDesc = grpc.ServiceDesc{ + ServiceName: "etcdserverpb.Cluster", + HandlerType: (*ClusterServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "MemberAdd", + Handler: _Cluster_MemberAdd_Handler, + }, + { + MethodName: "MemberRemove", + Handler: _Cluster_MemberRemove_Handler, + }, + { + MethodName: "MemberUpdate", + Handler: _Cluster_MemberUpdate_Handler, + }, + { + MethodName: "MemberList", + Handler: _Cluster_MemberList_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: fileDescriptorRpc, +} + +// Client API for Maintenance service + +type MaintenanceClient interface { + // Alarm activates, deactivates, and queries alarms regarding cluster health. + Alarm(ctx context.Context, in *AlarmRequest, opts ...grpc.CallOption) (*AlarmResponse, error) + // Status gets the status of the member. + Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) + // Defragment defragments a member's backend database to recover storage space. + Defragment(ctx context.Context, in *DefragmentRequest, opts ...grpc.CallOption) (*DefragmentResponse, error) + // Hash returns the hash of the local KV state for consistency checking purpose. + // This is designed for testing; do not use this in production when there + // are ongoing transactions. + Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error) + // Snapshot sends a snapshot of the entire backend from a member over a stream to a client. + Snapshot(ctx context.Context, in *SnapshotRequest, opts ...grpc.CallOption) (Maintenance_SnapshotClient, error) +} + +type maintenanceClient struct { + cc *grpc.ClientConn +} + +func NewMaintenanceClient(cc *grpc.ClientConn) MaintenanceClient { + return &maintenanceClient{cc} +} + +func (c *maintenanceClient) Alarm(ctx context.Context, in *AlarmRequest, opts ...grpc.CallOption) (*AlarmResponse, error) { + out := new(AlarmResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/Alarm", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *maintenanceClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) { + out := new(StatusResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/Status", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *maintenanceClient) Defragment(ctx context.Context, in *DefragmentRequest, opts ...grpc.CallOption) (*DefragmentResponse, error) { + out := new(DefragmentResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/Defragment", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *maintenanceClient) Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error) { + out := new(HashResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/Hash", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *maintenanceClient) Snapshot(ctx context.Context, in *SnapshotRequest, opts ...grpc.CallOption) (Maintenance_SnapshotClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Maintenance_serviceDesc.Streams[0], c.cc, "/etcdserverpb.Maintenance/Snapshot", opts...) + if err != nil { + return nil, err + } + x := &maintenanceSnapshotClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Maintenance_SnapshotClient interface { + Recv() (*SnapshotResponse, error) + grpc.ClientStream +} + +type maintenanceSnapshotClient struct { + grpc.ClientStream +} + +func (x *maintenanceSnapshotClient) Recv() (*SnapshotResponse, error) { + m := new(SnapshotResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// Server API for Maintenance service + +type MaintenanceServer interface { + // Alarm activates, deactivates, and queries alarms regarding cluster health. + Alarm(context.Context, *AlarmRequest) (*AlarmResponse, error) + // Status gets the status of the member. + Status(context.Context, *StatusRequest) (*StatusResponse, error) + // Defragment defragments a member's backend database to recover storage space. + Defragment(context.Context, *DefragmentRequest) (*DefragmentResponse, error) + // Hash returns the hash of the local KV state for consistency checking purpose. + // This is designed for testing; do not use this in production when there + // are ongoing transactions. + Hash(context.Context, *HashRequest) (*HashResponse, error) + // Snapshot sends a snapshot of the entire backend from a member over a stream to a client. + Snapshot(*SnapshotRequest, Maintenance_SnapshotServer) error +} + +func RegisterMaintenanceServer(s *grpc.Server, srv MaintenanceServer) { + s.RegisterService(&_Maintenance_serviceDesc, srv) +} + +func _Maintenance_Alarm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AlarmRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MaintenanceServer).Alarm(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Maintenance/Alarm", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MaintenanceServer).Alarm(ctx, req.(*AlarmRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Maintenance_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MaintenanceServer).Status(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Maintenance/Status", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MaintenanceServer).Status(ctx, req.(*StatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Maintenance_Defragment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DefragmentRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MaintenanceServer).Defragment(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Maintenance/Defragment", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MaintenanceServer).Defragment(ctx, req.(*DefragmentRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Maintenance_Hash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HashRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MaintenanceServer).Hash(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Maintenance/Hash", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MaintenanceServer).Hash(ctx, req.(*HashRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Maintenance_Snapshot_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(SnapshotRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(MaintenanceServer).Snapshot(m, &maintenanceSnapshotServer{stream}) +} + +type Maintenance_SnapshotServer interface { + Send(*SnapshotResponse) error + grpc.ServerStream +} + +type maintenanceSnapshotServer struct { + grpc.ServerStream +} + +func (x *maintenanceSnapshotServer) Send(m *SnapshotResponse) error { + return x.ServerStream.SendMsg(m) +} + +var _Maintenance_serviceDesc = grpc.ServiceDesc{ + ServiceName: "etcdserverpb.Maintenance", + HandlerType: (*MaintenanceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Alarm", + Handler: _Maintenance_Alarm_Handler, + }, + { + MethodName: "Status", + Handler: _Maintenance_Status_Handler, + }, + { + MethodName: "Defragment", + Handler: _Maintenance_Defragment_Handler, + }, + { + MethodName: "Hash", + Handler: _Maintenance_Hash_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "Snapshot", + Handler: _Maintenance_Snapshot_Handler, + ServerStreams: true, + }, + }, + Metadata: fileDescriptorRpc, +} + +// Client API for Auth service + +type AuthClient interface { + // AuthEnable enables authentication. + AuthEnable(ctx context.Context, in *AuthEnableRequest, opts ...grpc.CallOption) (*AuthEnableResponse, error) + // AuthDisable disables authentication. + AuthDisable(ctx context.Context, in *AuthDisableRequest, opts ...grpc.CallOption) (*AuthDisableResponse, error) + // Authenticate processes an authenticate request. + Authenticate(ctx context.Context, in *AuthenticateRequest, opts ...grpc.CallOption) (*AuthenticateResponse, error) + // UserAdd adds a new user. + UserAdd(ctx context.Context, in *AuthUserAddRequest, opts ...grpc.CallOption) (*AuthUserAddResponse, error) + // UserGet gets detailed user information. + UserGet(ctx context.Context, in *AuthUserGetRequest, opts ...grpc.CallOption) (*AuthUserGetResponse, error) + // UserList gets a list of all users. + UserList(ctx context.Context, in *AuthUserListRequest, opts ...grpc.CallOption) (*AuthUserListResponse, error) + // UserDelete deletes a specified user. + UserDelete(ctx context.Context, in *AuthUserDeleteRequest, opts ...grpc.CallOption) (*AuthUserDeleteResponse, error) + // UserChangePassword changes the password of a specified user. + UserChangePassword(ctx context.Context, in *AuthUserChangePasswordRequest, opts ...grpc.CallOption) (*AuthUserChangePasswordResponse, error) + // UserGrant grants a role to a specified user. + UserGrantRole(ctx context.Context, in *AuthUserGrantRoleRequest, opts ...grpc.CallOption) (*AuthUserGrantRoleResponse, error) + // UserRevokeRole revokes a role of specified user. + UserRevokeRole(ctx context.Context, in *AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (*AuthUserRevokeRoleResponse, error) + // RoleAdd adds a new role. + RoleAdd(ctx context.Context, in *AuthRoleAddRequest, opts ...grpc.CallOption) (*AuthRoleAddResponse, error) + // RoleGet gets detailed role information. + RoleGet(ctx context.Context, in *AuthRoleGetRequest, opts ...grpc.CallOption) (*AuthRoleGetResponse, error) + // RoleList gets lists of all roles. + RoleList(ctx context.Context, in *AuthRoleListRequest, opts ...grpc.CallOption) (*AuthRoleListResponse, error) + // RoleDelete deletes a specified role. + RoleDelete(ctx context.Context, in *AuthRoleDeleteRequest, opts ...grpc.CallOption) (*AuthRoleDeleteResponse, error) + // RoleGrantPermission grants a permission of a specified key or range to a specified role. + RoleGrantPermission(ctx context.Context, in *AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (*AuthRoleGrantPermissionResponse, error) + // RoleRevokePermission revokes a key or range permission of a specified role. + RoleRevokePermission(ctx context.Context, in *AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (*AuthRoleRevokePermissionResponse, error) +} + +type authClient struct { + cc *grpc.ClientConn +} + +func NewAuthClient(cc *grpc.ClientConn) AuthClient { + return &authClient{cc} +} + +func (c *authClient) AuthEnable(ctx context.Context, in *AuthEnableRequest, opts ...grpc.CallOption) (*AuthEnableResponse, error) { + out := new(AuthEnableResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/AuthEnable", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) AuthDisable(ctx context.Context, in *AuthDisableRequest, opts ...grpc.CallOption) (*AuthDisableResponse, error) { + out := new(AuthDisableResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/AuthDisable", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) Authenticate(ctx context.Context, in *AuthenticateRequest, opts ...grpc.CallOption) (*AuthenticateResponse, error) { + out := new(AuthenticateResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/Authenticate", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) UserAdd(ctx context.Context, in *AuthUserAddRequest, opts ...grpc.CallOption) (*AuthUserAddResponse, error) { + out := new(AuthUserAddResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserAdd", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) UserGet(ctx context.Context, in *AuthUserGetRequest, opts ...grpc.CallOption) (*AuthUserGetResponse, error) { + out := new(AuthUserGetResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserGet", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) UserList(ctx context.Context, in *AuthUserListRequest, opts ...grpc.CallOption) (*AuthUserListResponse, error) { + out := new(AuthUserListResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserList", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) UserDelete(ctx context.Context, in *AuthUserDeleteRequest, opts ...grpc.CallOption) (*AuthUserDeleteResponse, error) { + out := new(AuthUserDeleteResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserDelete", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) UserChangePassword(ctx context.Context, in *AuthUserChangePasswordRequest, opts ...grpc.CallOption) (*AuthUserChangePasswordResponse, error) { + out := new(AuthUserChangePasswordResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserChangePassword", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) UserGrantRole(ctx context.Context, in *AuthUserGrantRoleRequest, opts ...grpc.CallOption) (*AuthUserGrantRoleResponse, error) { + out := new(AuthUserGrantRoleResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserGrantRole", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) UserRevokeRole(ctx context.Context, in *AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (*AuthUserRevokeRoleResponse, error) { + out := new(AuthUserRevokeRoleResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserRevokeRole", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) RoleAdd(ctx context.Context, in *AuthRoleAddRequest, opts ...grpc.CallOption) (*AuthRoleAddResponse, error) { + out := new(AuthRoleAddResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleAdd", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) RoleGet(ctx context.Context, in *AuthRoleGetRequest, opts ...grpc.CallOption) (*AuthRoleGetResponse, error) { + out := new(AuthRoleGetResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleGet", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) RoleList(ctx context.Context, in *AuthRoleListRequest, opts ...grpc.CallOption) (*AuthRoleListResponse, error) { + out := new(AuthRoleListResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleList", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) RoleDelete(ctx context.Context, in *AuthRoleDeleteRequest, opts ...grpc.CallOption) (*AuthRoleDeleteResponse, error) { + out := new(AuthRoleDeleteResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleDelete", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) RoleGrantPermission(ctx context.Context, in *AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (*AuthRoleGrantPermissionResponse, error) { + out := new(AuthRoleGrantPermissionResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleGrantPermission", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authClient) RoleRevokePermission(ctx context.Context, in *AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (*AuthRoleRevokePermissionResponse, error) { + out := new(AuthRoleRevokePermissionResponse) + err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleRevokePermission", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for Auth service + +type AuthServer interface { + // AuthEnable enables authentication. + AuthEnable(context.Context, *AuthEnableRequest) (*AuthEnableResponse, error) + // AuthDisable disables authentication. + AuthDisable(context.Context, *AuthDisableRequest) (*AuthDisableResponse, error) + // Authenticate processes an authenticate request. + Authenticate(context.Context, *AuthenticateRequest) (*AuthenticateResponse, error) + // UserAdd adds a new user. + UserAdd(context.Context, *AuthUserAddRequest) (*AuthUserAddResponse, error) + // UserGet gets detailed user information. + UserGet(context.Context, *AuthUserGetRequest) (*AuthUserGetResponse, error) + // UserList gets a list of all users. + UserList(context.Context, *AuthUserListRequest) (*AuthUserListResponse, error) + // UserDelete deletes a specified user. + UserDelete(context.Context, *AuthUserDeleteRequest) (*AuthUserDeleteResponse, error) + // UserChangePassword changes the password of a specified user. + UserChangePassword(context.Context, *AuthUserChangePasswordRequest) (*AuthUserChangePasswordResponse, error) + // UserGrant grants a role to a specified user. + UserGrantRole(context.Context, *AuthUserGrantRoleRequest) (*AuthUserGrantRoleResponse, error) + // UserRevokeRole revokes a role of specified user. + UserRevokeRole(context.Context, *AuthUserRevokeRoleRequest) (*AuthUserRevokeRoleResponse, error) + // RoleAdd adds a new role. + RoleAdd(context.Context, *AuthRoleAddRequest) (*AuthRoleAddResponse, error) + // RoleGet gets detailed role information. + RoleGet(context.Context, *AuthRoleGetRequest) (*AuthRoleGetResponse, error) + // RoleList gets lists of all roles. + RoleList(context.Context, *AuthRoleListRequest) (*AuthRoleListResponse, error) + // RoleDelete deletes a specified role. + RoleDelete(context.Context, *AuthRoleDeleteRequest) (*AuthRoleDeleteResponse, error) + // RoleGrantPermission grants a permission of a specified key or range to a specified role. + RoleGrantPermission(context.Context, *AuthRoleGrantPermissionRequest) (*AuthRoleGrantPermissionResponse, error) + // RoleRevokePermission revokes a key or range permission of a specified role. + RoleRevokePermission(context.Context, *AuthRoleRevokePermissionRequest) (*AuthRoleRevokePermissionResponse, error) +} + +func RegisterAuthServer(s *grpc.Server, srv AuthServer) { + s.RegisterService(&_Auth_serviceDesc, srv) +} + +func _Auth_AuthEnable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthEnableRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).AuthEnable(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/AuthEnable", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).AuthEnable(ctx, req.(*AuthEnableRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_AuthDisable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthDisableRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).AuthDisable(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/AuthDisable", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).AuthDisable(ctx, req.(*AuthDisableRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_Authenticate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthenticateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).Authenticate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/Authenticate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).Authenticate(ctx, req.(*AuthenticateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_UserAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthUserAddRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).UserAdd(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/UserAdd", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).UserAdd(ctx, req.(*AuthUserAddRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_UserGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthUserGetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).UserGet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/UserGet", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).UserGet(ctx, req.(*AuthUserGetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_UserList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthUserListRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).UserList(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/UserList", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).UserList(ctx, req.(*AuthUserListRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_UserDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthUserDeleteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).UserDelete(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/UserDelete", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).UserDelete(ctx, req.(*AuthUserDeleteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_UserChangePassword_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthUserChangePasswordRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).UserChangePassword(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/UserChangePassword", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).UserChangePassword(ctx, req.(*AuthUserChangePasswordRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_UserGrantRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthUserGrantRoleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).UserGrantRole(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/UserGrantRole", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).UserGrantRole(ctx, req.(*AuthUserGrantRoleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_UserRevokeRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthUserRevokeRoleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).UserRevokeRole(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/UserRevokeRole", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).UserRevokeRole(ctx, req.(*AuthUserRevokeRoleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_RoleAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthRoleAddRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).RoleAdd(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/RoleAdd", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).RoleAdd(ctx, req.(*AuthRoleAddRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_RoleGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthRoleGetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).RoleGet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/RoleGet", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).RoleGet(ctx, req.(*AuthRoleGetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_RoleList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthRoleListRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).RoleList(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/RoleList", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).RoleList(ctx, req.(*AuthRoleListRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_RoleDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthRoleDeleteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).RoleDelete(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/RoleDelete", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).RoleDelete(ctx, req.(*AuthRoleDeleteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_RoleGrantPermission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthRoleGrantPermissionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).RoleGrantPermission(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/RoleGrantPermission", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).RoleGrantPermission(ctx, req.(*AuthRoleGrantPermissionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Auth_RoleRevokePermission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthRoleRevokePermissionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServer).RoleRevokePermission(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/etcdserverpb.Auth/RoleRevokePermission", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServer).RoleRevokePermission(ctx, req.(*AuthRoleRevokePermissionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Auth_serviceDesc = grpc.ServiceDesc{ + ServiceName: "etcdserverpb.Auth", + HandlerType: (*AuthServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "AuthEnable", + Handler: _Auth_AuthEnable_Handler, + }, + { + MethodName: "AuthDisable", + Handler: _Auth_AuthDisable_Handler, + }, + { + MethodName: "Authenticate", + Handler: _Auth_Authenticate_Handler, + }, + { + MethodName: "UserAdd", + Handler: _Auth_UserAdd_Handler, + }, + { + MethodName: "UserGet", + Handler: _Auth_UserGet_Handler, + }, + { + MethodName: "UserList", + Handler: _Auth_UserList_Handler, + }, + { + MethodName: "UserDelete", + Handler: _Auth_UserDelete_Handler, + }, + { + MethodName: "UserChangePassword", + Handler: _Auth_UserChangePassword_Handler, + }, + { + MethodName: "UserGrantRole", + Handler: _Auth_UserGrantRole_Handler, + }, + { + MethodName: "UserRevokeRole", + Handler: _Auth_UserRevokeRole_Handler, + }, + { + MethodName: "RoleAdd", + Handler: _Auth_RoleAdd_Handler, + }, + { + MethodName: "RoleGet", + Handler: _Auth_RoleGet_Handler, + }, + { + MethodName: "RoleList", + Handler: _Auth_RoleList_Handler, + }, + { + MethodName: "RoleDelete", + Handler: _Auth_RoleDelete_Handler, + }, + { + MethodName: "RoleGrantPermission", + Handler: _Auth_RoleGrantPermission_Handler, + }, + { + MethodName: "RoleRevokePermission", + Handler: _Auth_RoleRevokePermission_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: fileDescriptorRpc, +} + +func (m *ResponseHeader) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ResponseHeader) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.ClusterId != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.ClusterId)) + } + if m.MemberId != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.MemberId)) + } + if m.Revision != 0 { + data[i] = 0x18 + i++ + i = encodeVarintRpc(data, i, uint64(m.Revision)) + } + if m.RaftTerm != 0 { + data[i] = 0x20 + i++ + i = encodeVarintRpc(data, i, uint64(m.RaftTerm)) + } + return i, nil +} + +func (m *RangeRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *RangeRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Key) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Key))) + i += copy(data[i:], m.Key) + } + if len(m.RangeEnd) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.RangeEnd))) + i += copy(data[i:], m.RangeEnd) + } + if m.Limit != 0 { + data[i] = 0x18 + i++ + i = encodeVarintRpc(data, i, uint64(m.Limit)) + } + if m.Revision != 0 { + data[i] = 0x20 + i++ + i = encodeVarintRpc(data, i, uint64(m.Revision)) + } + if m.SortOrder != 0 { + data[i] = 0x28 + i++ + i = encodeVarintRpc(data, i, uint64(m.SortOrder)) + } + if m.SortTarget != 0 { + data[i] = 0x30 + i++ + i = encodeVarintRpc(data, i, uint64(m.SortTarget)) + } + if m.Serializable { + data[i] = 0x38 + i++ + if m.Serializable { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.KeysOnly { + data[i] = 0x40 + i++ + if m.KeysOnly { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.CountOnly { + data[i] = 0x48 + i++ + if m.CountOnly { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + return i, nil +} + +func (m *RangeResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *RangeResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n1, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if len(m.Kvs) > 0 { + for _, msg := range m.Kvs { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.More { + data[i] = 0x18 + i++ + if m.More { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Count != 0 { + data[i] = 0x20 + i++ + i = encodeVarintRpc(data, i, uint64(m.Count)) + } + return i, nil +} + +func (m *PutRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PutRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Key) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Key))) + i += copy(data[i:], m.Key) + } + if len(m.Value) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Value))) + i += copy(data[i:], m.Value) + } + if m.Lease != 0 { + data[i] = 0x18 + i++ + i = encodeVarintRpc(data, i, uint64(m.Lease)) + } + if m.PrevKv { + data[i] = 0x20 + i++ + if m.PrevKv { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + return i, nil +} + +func (m *PutResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PutResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n2, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + if m.PrevKv != nil { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(m.PrevKv.Size())) + n3, err := m.PrevKv.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n3 + } + return i, nil +} + +func (m *DeleteRangeRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DeleteRangeRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Key) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Key))) + i += copy(data[i:], m.Key) + } + if len(m.RangeEnd) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.RangeEnd))) + i += copy(data[i:], m.RangeEnd) + } + if m.PrevKv { + data[i] = 0x18 + i++ + if m.PrevKv { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + return i, nil +} + +func (m *DeleteRangeResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DeleteRangeResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n4, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n4 + } + if m.Deleted != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.Deleted)) + } + if len(m.PrevKvs) > 0 { + for _, msg := range m.PrevKvs { + data[i] = 0x1a + i++ + i = encodeVarintRpc(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *RequestOp) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *RequestOp) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Request != nil { + nn5, err := m.Request.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn5 + } + return i, nil +} + +func (m *RequestOp_RequestRange) MarshalTo(data []byte) (int, error) { + i := 0 + if m.RequestRange != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.RequestRange.Size())) + n6, err := m.RequestRange.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n6 + } + return i, nil +} +func (m *RequestOp_RequestPut) MarshalTo(data []byte) (int, error) { + i := 0 + if m.RequestPut != nil { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(m.RequestPut.Size())) + n7, err := m.RequestPut.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n7 + } + return i, nil +} +func (m *RequestOp_RequestDeleteRange) MarshalTo(data []byte) (int, error) { + i := 0 + if m.RequestDeleteRange != nil { + data[i] = 0x1a + i++ + i = encodeVarintRpc(data, i, uint64(m.RequestDeleteRange.Size())) + n8, err := m.RequestDeleteRange.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n8 + } + return i, nil +} +func (m *ResponseOp) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ResponseOp) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Response != nil { + nn9, err := m.Response.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn9 + } + return i, nil +} + +func (m *ResponseOp_ResponseRange) MarshalTo(data []byte) (int, error) { + i := 0 + if m.ResponseRange != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.ResponseRange.Size())) + n10, err := m.ResponseRange.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n10 + } + return i, nil +} +func (m *ResponseOp_ResponsePut) MarshalTo(data []byte) (int, error) { + i := 0 + if m.ResponsePut != nil { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(m.ResponsePut.Size())) + n11, err := m.ResponsePut.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n11 + } + return i, nil +} +func (m *ResponseOp_ResponseDeleteRange) MarshalTo(data []byte) (int, error) { + i := 0 + if m.ResponseDeleteRange != nil { + data[i] = 0x1a + i++ + i = encodeVarintRpc(data, i, uint64(m.ResponseDeleteRange.Size())) + n12, err := m.ResponseDeleteRange.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n12 + } + return i, nil +} +func (m *Compare) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Compare) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Result != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.Result)) + } + if m.Target != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.Target)) + } + if len(m.Key) > 0 { + data[i] = 0x1a + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Key))) + i += copy(data[i:], m.Key) + } + if m.TargetUnion != nil { + nn13, err := m.TargetUnion.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn13 + } + return i, nil +} + +func (m *Compare_Version) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x20 + i++ + i = encodeVarintRpc(data, i, uint64(m.Version)) + return i, nil +} +func (m *Compare_CreateRevision) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x28 + i++ + i = encodeVarintRpc(data, i, uint64(m.CreateRevision)) + return i, nil +} +func (m *Compare_ModRevision) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x30 + i++ + i = encodeVarintRpc(data, i, uint64(m.ModRevision)) + return i, nil +} +func (m *Compare_Value) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Value != nil { + data[i] = 0x3a + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Value))) + i += copy(data[i:], m.Value) + } + return i, nil +} +func (m *TxnRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *TxnRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Compare) > 0 { + for _, msg := range m.Compare { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Success) > 0 { + for _, msg := range m.Success { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Failure) > 0 { + for _, msg := range m.Failure { + data[i] = 0x1a + i++ + i = encodeVarintRpc(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *TxnResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *TxnResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n14, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n14 + } + if m.Succeeded { + data[i] = 0x10 + i++ + if m.Succeeded { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if len(m.Responses) > 0 { + for _, msg := range m.Responses { + data[i] = 0x1a + i++ + i = encodeVarintRpc(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *CompactionRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CompactionRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Revision != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.Revision)) + } + if m.Physical { + data[i] = 0x10 + i++ + if m.Physical { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + return i, nil +} + +func (m *CompactionResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CompactionResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n15, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n15 + } + return i, nil +} + +func (m *HashRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *HashRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *HashResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *HashResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n16, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n16 + } + if m.Hash != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.Hash)) + } + return i, nil +} + +func (m *SnapshotRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SnapshotRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *SnapshotResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SnapshotResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n17, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n17 + } + if m.RemainingBytes != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.RemainingBytes)) + } + if len(m.Blob) > 0 { + data[i] = 0x1a + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Blob))) + i += copy(data[i:], m.Blob) + } + return i, nil +} + +func (m *WatchRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *WatchRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.RequestUnion != nil { + nn18, err := m.RequestUnion.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn18 + } + return i, nil +} + +func (m *WatchRequest_CreateRequest) MarshalTo(data []byte) (int, error) { + i := 0 + if m.CreateRequest != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.CreateRequest.Size())) + n19, err := m.CreateRequest.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n19 + } + return i, nil +} +func (m *WatchRequest_CancelRequest) MarshalTo(data []byte) (int, error) { + i := 0 + if m.CancelRequest != nil { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(m.CancelRequest.Size())) + n20, err := m.CancelRequest.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n20 + } + return i, nil +} +func (m *WatchCreateRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *WatchCreateRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Key) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Key))) + i += copy(data[i:], m.Key) + } + if len(m.RangeEnd) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.RangeEnd))) + i += copy(data[i:], m.RangeEnd) + } + if m.StartRevision != 0 { + data[i] = 0x18 + i++ + i = encodeVarintRpc(data, i, uint64(m.StartRevision)) + } + if m.ProgressNotify { + data[i] = 0x20 + i++ + if m.ProgressNotify { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if len(m.Filters) > 0 { + for _, num := range m.Filters { + data[i] = 0x28 + i++ + i = encodeVarintRpc(data, i, uint64(num)) + } + } + if m.PrevKv { + data[i] = 0x30 + i++ + if m.PrevKv { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + return i, nil +} + +func (m *WatchCancelRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *WatchCancelRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.WatchId != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.WatchId)) + } + return i, nil +} + +func (m *WatchResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *WatchResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n21, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n21 + } + if m.WatchId != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.WatchId)) + } + if m.Created { + data[i] = 0x18 + i++ + if m.Created { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Canceled { + data[i] = 0x20 + i++ + if m.Canceled { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.CompactRevision != 0 { + data[i] = 0x28 + i++ + i = encodeVarintRpc(data, i, uint64(m.CompactRevision)) + } + if len(m.Events) > 0 { + for _, msg := range m.Events { + data[i] = 0x5a + i++ + i = encodeVarintRpc(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *LeaseGrantRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *LeaseGrantRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.TTL != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.TTL)) + } + if m.ID != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.ID)) + } + return i, nil +} + +func (m *LeaseGrantResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *LeaseGrantResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n22, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n22 + } + if m.ID != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.ID)) + } + if m.TTL != 0 { + data[i] = 0x18 + i++ + i = encodeVarintRpc(data, i, uint64(m.TTL)) + } + if len(m.Error) > 0 { + data[i] = 0x22 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Error))) + i += copy(data[i:], m.Error) + } + return i, nil +} + +func (m *LeaseRevokeRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *LeaseRevokeRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.ID != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.ID)) + } + return i, nil +} + +func (m *LeaseRevokeResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *LeaseRevokeResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n23, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n23 + } + return i, nil +} + +func (m *LeaseKeepAliveRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *LeaseKeepAliveRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.ID != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.ID)) + } + return i, nil +} + +func (m *LeaseKeepAliveResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *LeaseKeepAliveResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n24, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n24 + } + if m.ID != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.ID)) + } + if m.TTL != 0 { + data[i] = 0x18 + i++ + i = encodeVarintRpc(data, i, uint64(m.TTL)) + } + return i, nil +} + +func (m *Member) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Member) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.ID != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.ID)) + } + if len(m.Name) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if len(m.PeerURLs) > 0 { + for _, s := range m.PeerURLs { + data[i] = 0x1a + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.ClientURLs) > 0 { + for _, s := range m.ClientURLs { + data[i] = 0x22 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + return i, nil +} + +func (m *MemberAddRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MemberAddRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.PeerURLs) > 0 { + for _, s := range m.PeerURLs { + data[i] = 0xa + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + return i, nil +} + +func (m *MemberAddResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MemberAddResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n25, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n25 + } + if m.Member != nil { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(m.Member.Size())) + n26, err := m.Member.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n26 + } + return i, nil +} + +func (m *MemberRemoveRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MemberRemoveRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.ID != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.ID)) + } + return i, nil +} + +func (m *MemberRemoveResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MemberRemoveResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n27, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n27 + } + return i, nil +} + +func (m *MemberUpdateRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MemberUpdateRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.ID != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.ID)) + } + if len(m.PeerURLs) > 0 { + for _, s := range m.PeerURLs { + data[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + return i, nil +} + +func (m *MemberUpdateResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MemberUpdateResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n28, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n28 + } + return i, nil +} + +func (m *MemberListRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MemberListRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *MemberListResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MemberListResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n29, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n29 + } + if len(m.Members) > 0 { + for _, msg := range m.Members { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *DefragmentRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DefragmentRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *DefragmentResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DefragmentResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n30, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n30 + } + return i, nil +} + +func (m *AlarmRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AlarmRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Action != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.Action)) + } + if m.MemberID != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.MemberID)) + } + if m.Alarm != 0 { + data[i] = 0x18 + i++ + i = encodeVarintRpc(data, i, uint64(m.Alarm)) + } + return i, nil +} + +func (m *AlarmMember) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AlarmMember) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.MemberID != 0 { + data[i] = 0x8 + i++ + i = encodeVarintRpc(data, i, uint64(m.MemberID)) + } + if m.Alarm != 0 { + data[i] = 0x10 + i++ + i = encodeVarintRpc(data, i, uint64(m.Alarm)) + } + return i, nil +} + +func (m *AlarmResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AlarmResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n31, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n31 + } + if len(m.Alarms) > 0 { + for _, msg := range m.Alarms { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *StatusRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *StatusRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *StatusResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *StatusResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n32, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n32 + } + if len(m.Version) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Version))) + i += copy(data[i:], m.Version) + } + if m.DbSize != 0 { + data[i] = 0x18 + i++ + i = encodeVarintRpc(data, i, uint64(m.DbSize)) + } + if m.Leader != 0 { + data[i] = 0x20 + i++ + i = encodeVarintRpc(data, i, uint64(m.Leader)) + } + if m.RaftIndex != 0 { + data[i] = 0x28 + i++ + i = encodeVarintRpc(data, i, uint64(m.RaftIndex)) + } + if m.RaftTerm != 0 { + data[i] = 0x30 + i++ + i = encodeVarintRpc(data, i, uint64(m.RaftTerm)) + } + return i, nil +} + +func (m *AuthEnableRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthEnableRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *AuthDisableRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthDisableRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *AuthenticateRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthenticateRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if len(m.Password) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Password))) + i += copy(data[i:], m.Password) + } + return i, nil +} + +func (m *AuthUserAddRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserAddRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if len(m.Password) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Password))) + i += copy(data[i:], m.Password) + } + return i, nil +} + +func (m *AuthUserGetRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserGetRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + return i, nil +} + +func (m *AuthUserDeleteRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserDeleteRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + return i, nil +} + +func (m *AuthUserChangePasswordRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserChangePasswordRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if len(m.Password) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Password))) + i += copy(data[i:], m.Password) + } + return i, nil +} + +func (m *AuthUserGrantRoleRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserGrantRoleRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.User) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.User))) + i += copy(data[i:], m.User) + } + if len(m.Role) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Role))) + i += copy(data[i:], m.Role) + } + return i, nil +} + +func (m *AuthUserRevokeRoleRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserRevokeRoleRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if len(m.Role) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Role))) + i += copy(data[i:], m.Role) + } + return i, nil +} + +func (m *AuthRoleAddRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleAddRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + return i, nil +} + +func (m *AuthRoleGetRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleGetRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Role) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Role))) + i += copy(data[i:], m.Role) + } + return i, nil +} + +func (m *AuthUserListRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserListRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *AuthRoleListRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleListRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *AuthRoleDeleteRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleDeleteRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Role) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Role))) + i += copy(data[i:], m.Role) + } + return i, nil +} + +func (m *AuthRoleGrantPermissionRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleGrantPermissionRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if m.Perm != nil { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(m.Perm.Size())) + n33, err := m.Perm.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n33 + } + return i, nil +} + +func (m *AuthRoleRevokePermissionRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleRevokePermissionRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Role) > 0 { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Role))) + i += copy(data[i:], m.Role) + } + if len(m.Key) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Key))) + i += copy(data[i:], m.Key) + } + if len(m.RangeEnd) > 0 { + data[i] = 0x1a + i++ + i = encodeVarintRpc(data, i, uint64(len(m.RangeEnd))) + i += copy(data[i:], m.RangeEnd) + } + return i, nil +} + +func (m *AuthEnableResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthEnableResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n34, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n34 + } + return i, nil +} + +func (m *AuthDisableResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthDisableResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n35, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n35 + } + return i, nil +} + +func (m *AuthenticateResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthenticateResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n36, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n36 + } + if len(m.Token) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(len(m.Token))) + i += copy(data[i:], m.Token) + } + return i, nil +} + +func (m *AuthUserAddResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserAddResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n37, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n37 + } + return i, nil +} + +func (m *AuthUserGetResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserGetResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n38, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n38 + } + if len(m.Roles) > 0 { + for _, s := range m.Roles { + data[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + return i, nil +} + +func (m *AuthUserDeleteResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserDeleteResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n39, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n39 + } + return i, nil +} + +func (m *AuthUserChangePasswordResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserChangePasswordResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n40, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n40 + } + return i, nil +} + +func (m *AuthUserGrantRoleResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserGrantRoleResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n41, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n41 + } + return i, nil +} + +func (m *AuthUserRevokeRoleResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserRevokeRoleResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n42, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n42 + } + return i, nil +} + +func (m *AuthRoleAddResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleAddResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n43, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n43 + } + return i, nil +} + +func (m *AuthRoleGetResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleGetResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n44, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n44 + } + if len(m.Perm) > 0 { + for _, msg := range m.Perm { + data[i] = 0x12 + i++ + i = encodeVarintRpc(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *AuthRoleListResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleListResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n45, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n45 + } + if len(m.Roles) > 0 { + for _, s := range m.Roles { + data[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + return i, nil +} + +func (m *AuthUserListResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthUserListResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n46, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n46 + } + if len(m.Users) > 0 { + for _, s := range m.Users { + data[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + return i, nil +} + +func (m *AuthRoleDeleteResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleDeleteResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n47, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n47 + } + return i, nil +} + +func (m *AuthRoleGrantPermissionResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleGrantPermissionResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n48, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n48 + } + return i, nil +} + +func (m *AuthRoleRevokePermissionResponse) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthRoleRevokePermissionResponse) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + data[i] = 0xa + i++ + i = encodeVarintRpc(data, i, uint64(m.Header.Size())) + n49, err := m.Header.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n49 + } + return i, nil +} + +func encodeFixed64Rpc(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Rpc(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintRpc(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *ResponseHeader) Size() (n int) { + var l int + _ = l + if m.ClusterId != 0 { + n += 1 + sovRpc(uint64(m.ClusterId)) + } + if m.MemberId != 0 { + n += 1 + sovRpc(uint64(m.MemberId)) + } + if m.Revision != 0 { + n += 1 + sovRpc(uint64(m.Revision)) + } + if m.RaftTerm != 0 { + n += 1 + sovRpc(uint64(m.RaftTerm)) + } + return n +} + +func (m *RangeRequest) Size() (n int) { + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.RangeEnd) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + if m.Limit != 0 { + n += 1 + sovRpc(uint64(m.Limit)) + } + if m.Revision != 0 { + n += 1 + sovRpc(uint64(m.Revision)) + } + if m.SortOrder != 0 { + n += 1 + sovRpc(uint64(m.SortOrder)) + } + if m.SortTarget != 0 { + n += 1 + sovRpc(uint64(m.SortTarget)) + } + if m.Serializable { + n += 2 + } + if m.KeysOnly { + n += 2 + } + if m.CountOnly { + n += 2 + } + return n +} + +func (m *RangeResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if len(m.Kvs) > 0 { + for _, e := range m.Kvs { + l = e.Size() + n += 1 + l + sovRpc(uint64(l)) + } + } + if m.More { + n += 2 + } + if m.Count != 0 { + n += 1 + sovRpc(uint64(m.Count)) + } + return n +} + +func (m *PutRequest) Size() (n int) { + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + if m.Lease != 0 { + n += 1 + sovRpc(uint64(m.Lease)) + } + if m.PrevKv { + n += 2 + } + return n +} + +func (m *PutResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if m.PrevKv != nil { + l = m.PrevKv.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *DeleteRangeRequest) Size() (n int) { + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.RangeEnd) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + if m.PrevKv { + n += 2 + } + return n +} + +func (m *DeleteRangeResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if m.Deleted != 0 { + n += 1 + sovRpc(uint64(m.Deleted)) + } + if len(m.PrevKvs) > 0 { + for _, e := range m.PrevKvs { + l = e.Size() + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *RequestOp) Size() (n int) { + var l int + _ = l + if m.Request != nil { + n += m.Request.Size() + } + return n +} + +func (m *RequestOp_RequestRange) Size() (n int) { + var l int + _ = l + if m.RequestRange != nil { + l = m.RequestRange.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} +func (m *RequestOp_RequestPut) Size() (n int) { + var l int + _ = l + if m.RequestPut != nil { + l = m.RequestPut.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} +func (m *RequestOp_RequestDeleteRange) Size() (n int) { + var l int + _ = l + if m.RequestDeleteRange != nil { + l = m.RequestDeleteRange.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} +func (m *ResponseOp) Size() (n int) { + var l int + _ = l + if m.Response != nil { + n += m.Response.Size() + } + return n +} + +func (m *ResponseOp_ResponseRange) Size() (n int) { + var l int + _ = l + if m.ResponseRange != nil { + l = m.ResponseRange.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} +func (m *ResponseOp_ResponsePut) Size() (n int) { + var l int + _ = l + if m.ResponsePut != nil { + l = m.ResponsePut.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} +func (m *ResponseOp_ResponseDeleteRange) Size() (n int) { + var l int + _ = l + if m.ResponseDeleteRange != nil { + l = m.ResponseDeleteRange.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} +func (m *Compare) Size() (n int) { + var l int + _ = l + if m.Result != 0 { + n += 1 + sovRpc(uint64(m.Result)) + } + if m.Target != 0 { + n += 1 + sovRpc(uint64(m.Target)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + if m.TargetUnion != nil { + n += m.TargetUnion.Size() + } + return n +} + +func (m *Compare_Version) Size() (n int) { + var l int + _ = l + n += 1 + sovRpc(uint64(m.Version)) + return n +} +func (m *Compare_CreateRevision) Size() (n int) { + var l int + _ = l + n += 1 + sovRpc(uint64(m.CreateRevision)) + return n +} +func (m *Compare_ModRevision) Size() (n int) { + var l int + _ = l + n += 1 + sovRpc(uint64(m.ModRevision)) + return n +} +func (m *Compare_Value) Size() (n int) { + var l int + _ = l + if m.Value != nil { + l = len(m.Value) + n += 1 + l + sovRpc(uint64(l)) + } + return n +} +func (m *TxnRequest) Size() (n int) { + var l int + _ = l + if len(m.Compare) > 0 { + for _, e := range m.Compare { + l = e.Size() + n += 1 + l + sovRpc(uint64(l)) + } + } + if len(m.Success) > 0 { + for _, e := range m.Success { + l = e.Size() + n += 1 + l + sovRpc(uint64(l)) + } + } + if len(m.Failure) > 0 { + for _, e := range m.Failure { + l = e.Size() + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *TxnResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if m.Succeeded { + n += 2 + } + if len(m.Responses) > 0 { + for _, e := range m.Responses { + l = e.Size() + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *CompactionRequest) Size() (n int) { + var l int + _ = l + if m.Revision != 0 { + n += 1 + sovRpc(uint64(m.Revision)) + } + if m.Physical { + n += 2 + } + return n +} + +func (m *CompactionResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *HashRequest) Size() (n int) { + var l int + _ = l + return n +} + +func (m *HashResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if m.Hash != 0 { + n += 1 + sovRpc(uint64(m.Hash)) + } + return n +} + +func (m *SnapshotRequest) Size() (n int) { + var l int + _ = l + return n +} + +func (m *SnapshotResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if m.RemainingBytes != 0 { + n += 1 + sovRpc(uint64(m.RemainingBytes)) + } + l = len(m.Blob) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *WatchRequest) Size() (n int) { + var l int + _ = l + if m.RequestUnion != nil { + n += m.RequestUnion.Size() + } + return n +} + +func (m *WatchRequest_CreateRequest) Size() (n int) { + var l int + _ = l + if m.CreateRequest != nil { + l = m.CreateRequest.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} +func (m *WatchRequest_CancelRequest) Size() (n int) { + var l int + _ = l + if m.CancelRequest != nil { + l = m.CancelRequest.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} +func (m *WatchCreateRequest) Size() (n int) { + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.RangeEnd) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + if m.StartRevision != 0 { + n += 1 + sovRpc(uint64(m.StartRevision)) + } + if m.ProgressNotify { + n += 2 + } + if len(m.Filters) > 0 { + for _, e := range m.Filters { + n += 1 + sovRpc(uint64(e)) + } + } + if m.PrevKv { + n += 2 + } + return n +} + +func (m *WatchCancelRequest) Size() (n int) { + var l int + _ = l + if m.WatchId != 0 { + n += 1 + sovRpc(uint64(m.WatchId)) + } + return n +} + +func (m *WatchResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if m.WatchId != 0 { + n += 1 + sovRpc(uint64(m.WatchId)) + } + if m.Created { + n += 2 + } + if m.Canceled { + n += 2 + } + if m.CompactRevision != 0 { + n += 1 + sovRpc(uint64(m.CompactRevision)) + } + if len(m.Events) > 0 { + for _, e := range m.Events { + l = e.Size() + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *LeaseGrantRequest) Size() (n int) { + var l int + _ = l + if m.TTL != 0 { + n += 1 + sovRpc(uint64(m.TTL)) + } + if m.ID != 0 { + n += 1 + sovRpc(uint64(m.ID)) + } + return n +} + +func (m *LeaseGrantResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if m.ID != 0 { + n += 1 + sovRpc(uint64(m.ID)) + } + if m.TTL != 0 { + n += 1 + sovRpc(uint64(m.TTL)) + } + l = len(m.Error) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *LeaseRevokeRequest) Size() (n int) { + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRpc(uint64(m.ID)) + } + return n +} + +func (m *LeaseRevokeResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *LeaseKeepAliveRequest) Size() (n int) { + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRpc(uint64(m.ID)) + } + return n +} + +func (m *LeaseKeepAliveResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if m.ID != 0 { + n += 1 + sovRpc(uint64(m.ID)) + } + if m.TTL != 0 { + n += 1 + sovRpc(uint64(m.TTL)) + } + return n +} + +func (m *Member) Size() (n int) { + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRpc(uint64(m.ID)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + if len(m.PeerURLs) > 0 { + for _, s := range m.PeerURLs { + l = len(s) + n += 1 + l + sovRpc(uint64(l)) + } + } + if len(m.ClientURLs) > 0 { + for _, s := range m.ClientURLs { + l = len(s) + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *MemberAddRequest) Size() (n int) { + var l int + _ = l + if len(m.PeerURLs) > 0 { + for _, s := range m.PeerURLs { + l = len(s) + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *MemberAddResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if m.Member != nil { + l = m.Member.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *MemberRemoveRequest) Size() (n int) { + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRpc(uint64(m.ID)) + } + return n +} + +func (m *MemberRemoveResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *MemberUpdateRequest) Size() (n int) { + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRpc(uint64(m.ID)) + } + if len(m.PeerURLs) > 0 { + for _, s := range m.PeerURLs { + l = len(s) + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *MemberUpdateResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *MemberListRequest) Size() (n int) { + var l int + _ = l + return n +} + +func (m *MemberListResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if len(m.Members) > 0 { + for _, e := range m.Members { + l = e.Size() + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *DefragmentRequest) Size() (n int) { + var l int + _ = l + return n +} + +func (m *DefragmentResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AlarmRequest) Size() (n int) { + var l int + _ = l + if m.Action != 0 { + n += 1 + sovRpc(uint64(m.Action)) + } + if m.MemberID != 0 { + n += 1 + sovRpc(uint64(m.MemberID)) + } + if m.Alarm != 0 { + n += 1 + sovRpc(uint64(m.Alarm)) + } + return n +} + +func (m *AlarmMember) Size() (n int) { + var l int + _ = l + if m.MemberID != 0 { + n += 1 + sovRpc(uint64(m.MemberID)) + } + if m.Alarm != 0 { + n += 1 + sovRpc(uint64(m.Alarm)) + } + return n +} + +func (m *AlarmResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if len(m.Alarms) > 0 { + for _, e := range m.Alarms { + l = e.Size() + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *StatusRequest) Size() (n int) { + var l int + _ = l + return n +} + +func (m *StatusResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + if m.DbSize != 0 { + n += 1 + sovRpc(uint64(m.DbSize)) + } + if m.Leader != 0 { + n += 1 + sovRpc(uint64(m.Leader)) + } + if m.RaftIndex != 0 { + n += 1 + sovRpc(uint64(m.RaftIndex)) + } + if m.RaftTerm != 0 { + n += 1 + sovRpc(uint64(m.RaftTerm)) + } + return n +} + +func (m *AuthEnableRequest) Size() (n int) { + var l int + _ = l + return n +} + +func (m *AuthDisableRequest) Size() (n int) { + var l int + _ = l + return n +} + +func (m *AuthenticateRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.Password) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserAddRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.Password) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserGetRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserDeleteRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserChangePasswordRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.Password) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserGrantRoleRequest) Size() (n int) { + var l int + _ = l + l = len(m.User) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.Role) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserRevokeRoleRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.Role) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthRoleAddRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthRoleGetRequest) Size() (n int) { + var l int + _ = l + l = len(m.Role) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserListRequest) Size() (n int) { + var l int + _ = l + return n +} + +func (m *AuthRoleListRequest) Size() (n int) { + var l int + _ = l + return n +} + +func (m *AuthRoleDeleteRequest) Size() (n int) { + var l int + _ = l + l = len(m.Role) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthRoleGrantPermissionRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + if m.Perm != nil { + l = m.Perm.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthRoleRevokePermissionRequest) Size() (n int) { + var l int + _ = l + l = len(m.Role) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.RangeEnd) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthEnableResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthDisableResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthenticateResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + l = len(m.Token) + if l > 0 { + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserAddResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserGetResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if len(m.Roles) > 0 { + for _, s := range m.Roles { + l = len(s) + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *AuthUserDeleteResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserChangePasswordResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserGrantRoleResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthUserRevokeRoleResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthRoleAddResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthRoleGetResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if len(m.Perm) > 0 { + for _, e := range m.Perm { + l = e.Size() + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *AuthRoleListResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if len(m.Roles) > 0 { + for _, s := range m.Roles { + l = len(s) + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *AuthUserListResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + if len(m.Users) > 0 { + for _, s := range m.Users { + l = len(s) + n += 1 + l + sovRpc(uint64(l)) + } + } + return n +} + +func (m *AuthRoleDeleteResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthRoleGrantPermissionResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func (m *AuthRoleRevokePermissionResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovRpc(uint64(l)) + } + return n +} + +func sovRpc(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozRpc(x uint64) (n int) { + return sovRpc(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ResponseHeader) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) + } + m.ClusterId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ClusterId |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MemberId", wireType) + } + m.MemberId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.MemberId |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) + } + m.Revision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Revision |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RaftTerm", wireType) + } + m.RaftTerm = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.RaftTerm |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RangeRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RangeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RangeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], data[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RangeEnd = append(m.RangeEnd[:0], data[iNdEx:postIndex]...) + if m.RangeEnd == nil { + m.RangeEnd = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) + } + m.Limit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Limit |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) + } + m.Revision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Revision |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SortOrder", wireType) + } + m.SortOrder = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.SortOrder |= (RangeRequest_SortOrder(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SortTarget", wireType) + } + m.SortTarget = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.SortTarget |= (RangeRequest_SortTarget(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Serializable", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Serializable = bool(v != 0) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeysOnly", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.KeysOnly = bool(v != 0) + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CountOnly", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.CountOnly = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RangeResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RangeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RangeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Kvs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Kvs = append(m.Kvs, &mvccpb.KeyValue{}) + if err := m.Kvs[len(m.Kvs)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field More", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.More = bool(v != 0) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) + } + m.Count = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Count |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PutRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PutRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PutRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], data[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], data[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType) + } + m.Lease = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Lease |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PrevKv = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PutResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PutResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PutResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PrevKv == nil { + m.PrevKv = &mvccpb.KeyValue{} + } + if err := m.PrevKv.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeleteRangeRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeleteRangeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeleteRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], data[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RangeEnd = append(m.RangeEnd[:0], data[iNdEx:postIndex]...) + if m.RangeEnd == nil { + m.RangeEnd = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PrevKv = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeleteRangeResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeleteRangeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeleteRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType) + } + m.Deleted = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Deleted |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevKvs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevKvs = append(m.PrevKvs, &mvccpb.KeyValue{}) + if err := m.PrevKvs[len(m.PrevKvs)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RequestOp) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RequestOp: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequestOp: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestRange", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &RangeRequest{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Request = &RequestOp_RequestRange{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestPut", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &PutRequest{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Request = &RequestOp_RequestPut{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestDeleteRange", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &DeleteRangeRequest{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Request = &RequestOp_RequestDeleteRange{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResponseOp) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseOp: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseOp: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseRange", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &RangeResponse{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Response = &ResponseOp_ResponseRange{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponsePut", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &PutResponse{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Response = &ResponseOp_ResponsePut{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseDeleteRange", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &DeleteRangeResponse{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Response = &ResponseOp_ResponseDeleteRange{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Compare) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Compare: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Compare: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) + } + m.Result = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Result |= (Compare_CompareResult(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + m.Target = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Target |= (Compare_CompareTarget(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], data[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TargetUnion = &Compare_Version{v} + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CreateRevision", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TargetUnion = &Compare_CreateRevision{v} + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ModRevision", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TargetUnion = &Compare_ModRevision{v} + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.TargetUnion = &Compare_Value{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TxnRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TxnRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TxnRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Compare", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Compare = append(m.Compare, &Compare{}) + if err := m.Compare[len(m.Compare)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Success = append(m.Success, &RequestOp{}) + if err := m.Success[len(m.Success)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Failure", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Failure = append(m.Failure, &RequestOp{}) + if err := m.Failure[len(m.Failure)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TxnResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TxnResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TxnResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Succeeded = bool(v != 0) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Responses = append(m.Responses, &ResponseOp{}) + if err := m.Responses[len(m.Responses)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CompactionRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CompactionRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CompactionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) + } + m.Revision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Revision |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Physical", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Physical = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CompactionResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CompactionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CompactionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HashRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HashRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HashRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HashResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HashResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HashResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + m.Hash = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Hash |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SnapshotRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SnapshotRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SnapshotResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SnapshotResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RemainingBytes", wireType) + } + m.RemainingBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.RemainingBytes |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Blob", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Blob = append(m.Blob[:0], data[iNdEx:postIndex]...) + if m.Blob == nil { + m.Blob = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WatchRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WatchRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WatchRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CreateRequest", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &WatchCreateRequest{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.RequestUnion = &WatchRequest_CreateRequest{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CancelRequest", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &WatchCancelRequest{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.RequestUnion = &WatchRequest_CancelRequest{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WatchCreateRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WatchCreateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WatchCreateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], data[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RangeEnd = append(m.RangeEnd[:0], data[iNdEx:postIndex]...) + if m.RangeEnd == nil { + m.RangeEnd = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartRevision", wireType) + } + m.StartRevision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.StartRevision |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProgressNotify", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ProgressNotify = bool(v != 0) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) + } + var v WatchCreateRequest_FilterType + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (WatchCreateRequest_FilterType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Filters = append(m.Filters, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PrevKv = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WatchCancelRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WatchCancelRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WatchCancelRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field WatchId", wireType) + } + m.WatchId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.WatchId |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WatchResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WatchResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WatchResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field WatchId", wireType) + } + m.WatchId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.WatchId |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Created", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Created = bool(v != 0) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Canceled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Canceled = bool(v != 0) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompactRevision", wireType) + } + m.CompactRevision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.CompactRevision |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Events = append(m.Events, &mvccpb.Event{}) + if err := m.Events[len(m.Events)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LeaseGrantRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LeaseGrantRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LeaseGrantRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) + } + m.TTL = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.TTL |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LeaseGrantResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LeaseGrantResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LeaseGrantResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) + } + m.TTL = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.TTL |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Error = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LeaseRevokeRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LeaseRevokeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LeaseRevokeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LeaseRevokeResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LeaseRevokeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LeaseRevokeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LeaseKeepAliveRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LeaseKeepAliveRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LeaseKeepAliveRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LeaseKeepAliveResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LeaseKeepAliveResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LeaseKeepAliveResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) + } + m.TTL = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.TTL |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Member) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Member: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Member: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerURLs = append(m.PeerURLs, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientURLs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientURLs = append(m.ClientURLs, string(data[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemberAddRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MemberAddRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MemberAddRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerURLs = append(m.PeerURLs, string(data[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemberAddResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MemberAddResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MemberAddResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Member", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Member == nil { + m.Member = &Member{} + } + if err := m.Member.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemberRemoveRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MemberRemoveRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MemberRemoveRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemberRemoveResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MemberRemoveResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MemberRemoveResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemberUpdateRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MemberUpdateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MemberUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ID |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerURLs = append(m.PeerURLs, string(data[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemberUpdateResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MemberUpdateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MemberUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemberListRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MemberListRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MemberListRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemberListResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MemberListResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MemberListResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Members = append(m.Members, &Member{}) + if err := m.Members[len(m.Members)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DefragmentRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DefragmentRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DefragmentRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DefragmentResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DefragmentResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DefragmentResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AlarmRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AlarmRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AlarmRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType) + } + m.Action = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Action |= (AlarmRequest_AlarmAction(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType) + } + m.MemberID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.MemberID |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Alarm", wireType) + } + m.Alarm = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Alarm |= (AlarmType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AlarmMember) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AlarmMember: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AlarmMember: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType) + } + m.MemberID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.MemberID |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Alarm", wireType) + } + m.Alarm = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Alarm |= (AlarmType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AlarmResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AlarmResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AlarmResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Alarms", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Alarms = append(m.Alarms, &AlarmMember{}) + if err := m.Alarms[len(m.Alarms)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StatusRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StatusRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StatusResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StatusResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DbSize", wireType) + } + m.DbSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.DbSize |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) + } + m.Leader = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Leader |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RaftIndex", wireType) + } + m.RaftIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.RaftIndex |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RaftTerm", wireType) + } + m.RaftTerm = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.RaftTerm |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthEnableRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthEnableRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthEnableRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthDisableRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthDisableRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthDisableRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthenticateRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthenticateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthenticateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Password = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserAddRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserAddRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserAddRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Password = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserGetRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserGetRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserGetRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserDeleteRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserDeleteRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserChangePasswordRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserChangePasswordRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserChangePasswordRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Password = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserGrantRoleRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserGrantRoleRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserGrantRoleRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.User = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Role = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserRevokeRoleRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserRevokeRoleRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserRevokeRoleRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Role = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleAddRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleAddRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleAddRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleGetRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleGetRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleGetRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Role = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserListRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserListRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserListRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleListRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleListRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleListRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleDeleteRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleDeleteRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Role = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleGrantPermissionRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleGrantPermissionRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleGrantPermissionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Perm", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Perm == nil { + m.Perm = &authpb.Permission{} + } + if err := m.Perm.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleRevokePermissionRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleRevokePermissionRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleRevokePermissionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Role = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RangeEnd = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthEnableResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthEnableResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthEnableResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthDisableResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthDisableResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthDisableResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthenticateResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthenticateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthenticateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Token = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserAddResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserAddResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserAddResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserGetResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserGetResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserGetResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Roles = append(m.Roles, string(data[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserDeleteResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserDeleteResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserChangePasswordResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserChangePasswordResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserChangePasswordResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserGrantRoleResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserGrantRoleResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserGrantRoleResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserRevokeRoleResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserRevokeRoleResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserRevokeRoleResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleAddResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleAddResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleAddResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleGetResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleGetResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleGetResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Perm", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Perm = append(m.Perm, &authpb.Permission{}) + if err := m.Perm[len(m.Perm)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleListResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleListResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleListResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Roles = append(m.Roles, string(data[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthUserListResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthUserListResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthUserListResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Users", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Users = append(m.Users, string(data[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleDeleteResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleDeleteResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleGrantPermissionResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleGrantPermissionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleGrantPermissionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuthRoleRevokePermissionResponse) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AuthRoleRevokePermissionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuthRoleRevokePermissionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRpc(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRpc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipRpc(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRpc + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRpc + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRpc + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthRpc + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRpc + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipRpc(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthRpc = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowRpc = fmt.Errorf("proto: integer overflow") +) + +var fileDescriptorRpc = []byte{ + // 3256 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x5a, 0x4f, 0x73, 0x1b, 0xc7, + 0xb1, 0xe7, 0x02, 0x20, 0x40, 0x34, 0x40, 0x10, 0x1a, 0x52, 0x32, 0xb8, 0x92, 0x28, 0x6a, 0xf4, + 0x8f, 0x92, 0x6c, 0xc2, 0xa6, 0xfd, 0xde, 0x41, 0xef, 0x95, 0xab, 0x28, 0x02, 0x16, 0x19, 0xd2, + 0xa4, 0xbc, 0xa4, 0x64, 0xa7, 0xca, 0x15, 0xd6, 0x12, 0x18, 0x01, 0x28, 0x02, 0xbb, 0xf0, 0xee, + 0x02, 0x12, 0x9d, 0xa4, 0x2a, 0xe5, 0x8a, 0x0f, 0xc9, 0x31, 0x3e, 0x24, 0x71, 0x8e, 0xf9, 0x0c, + 0xb9, 0xe5, 0x03, 0xa4, 0x72, 0x89, 0xab, 0xf2, 0x05, 0x52, 0x4e, 0x0e, 0x39, 0xe4, 0x9e, 0xca, + 0x21, 0x95, 0xd4, 0xfc, 0xdb, 0x9d, 0x5d, 0xec, 0x82, 0x74, 0x36, 0xbe, 0x48, 0x98, 0x9e, 0x9e, + 0xfe, 0x75, 0xf7, 0x4c, 0xf7, 0xf4, 0xf4, 0x12, 0x8a, 0xce, 0xb0, 0xb5, 0x3e, 0x74, 0x6c, 0xcf, + 0x46, 0x65, 0xe2, 0xb5, 0xda, 0x2e, 0x71, 0xc6, 0xc4, 0x19, 0x9e, 0xe8, 0x4b, 0x1d, 0xbb, 0x63, + 0xb3, 0x89, 0x3a, 0xfd, 0xc5, 0x79, 0xf4, 0x65, 0xca, 0x53, 0x1f, 0x8c, 0x5b, 0x2d, 0xf6, 0xcf, + 0xf0, 0xa4, 0x7e, 0x3a, 0x16, 0x53, 0x57, 0xd9, 0x94, 0x39, 0xf2, 0xba, 0xec, 0x9f, 0xe1, 0x09, + 0xfb, 0x4f, 0x4c, 0x5e, 0xeb, 0xd8, 0x76, 0xa7, 0x4f, 0xea, 0xe6, 0xb0, 0x57, 0x37, 0x2d, 0xcb, + 0xf6, 0x4c, 0xaf, 0x67, 0x5b, 0x2e, 0x9f, 0xc5, 0x9f, 0x6b, 0x50, 0x31, 0x88, 0x3b, 0xb4, 0x2d, + 0x97, 0x6c, 0x13, 0xb3, 0x4d, 0x1c, 0x74, 0x1d, 0xa0, 0xd5, 0x1f, 0xb9, 0x1e, 0x71, 0x8e, 0x7b, + 0xed, 0x9a, 0xb6, 0xaa, 0xad, 0xe5, 0x8c, 0xa2, 0xa0, 0xec, 0xb4, 0xd1, 0x55, 0x28, 0x0e, 0xc8, + 0xe0, 0x84, 0xcf, 0x66, 0xd8, 0xec, 0x1c, 0x27, 0xec, 0xb4, 0x91, 0x0e, 0x73, 0x0e, 0x19, 0xf7, + 0xdc, 0x9e, 0x6d, 0xd5, 0xb2, 0xab, 0xda, 0x5a, 0xd6, 0xf0, 0xc7, 0x74, 0xa1, 0x63, 0xbe, 0xf0, + 0x8e, 0x3d, 0xe2, 0x0c, 0x6a, 0x39, 0xbe, 0x90, 0x12, 0x8e, 0x88, 0x33, 0xc0, 0x5f, 0x65, 0xa1, + 0x6c, 0x98, 0x56, 0x87, 0x18, 0xe4, 0x93, 0x11, 0x71, 0x3d, 0x54, 0x85, 0xec, 0x29, 0x39, 0x63, + 0xf0, 0x65, 0x83, 0xfe, 0xe4, 0xeb, 0xad, 0x0e, 0x39, 0x26, 0x16, 0x07, 0x2e, 0xd3, 0xf5, 0x56, + 0x87, 0x34, 0xad, 0x36, 0x5a, 0x82, 0xd9, 0x7e, 0x6f, 0xd0, 0xf3, 0x04, 0x2a, 0x1f, 0x84, 0xd4, + 0xc9, 0x45, 0xd4, 0xd9, 0x02, 0x70, 0x6d, 0xc7, 0x3b, 0xb6, 0x9d, 0x36, 0x71, 0x6a, 0xb3, 0xab, + 0xda, 0x5a, 0x65, 0xe3, 0xf6, 0xba, 0xba, 0x11, 0xeb, 0xaa, 0x42, 0xeb, 0x87, 0xb6, 0xe3, 0x1d, + 0x50, 0x5e, 0xa3, 0xe8, 0xca, 0x9f, 0xe8, 0x3d, 0x28, 0x31, 0x21, 0x9e, 0xe9, 0x74, 0x88, 0x57, + 0xcb, 0x33, 0x29, 0x77, 0xce, 0x91, 0x72, 0xc4, 0x98, 0x0d, 0x06, 0xcf, 0x7f, 0x23, 0x0c, 0x65, + 0x97, 0x38, 0x3d, 0xb3, 0xdf, 0xfb, 0xd4, 0x3c, 0xe9, 0x93, 0x5a, 0x61, 0x55, 0x5b, 0x9b, 0x33, + 0x42, 0x34, 0x6a, 0xff, 0x29, 0x39, 0x73, 0x8f, 0x6d, 0xab, 0x7f, 0x56, 0x9b, 0x63, 0x0c, 0x73, + 0x94, 0x70, 0x60, 0xf5, 0xcf, 0xd8, 0xa6, 0xd9, 0x23, 0xcb, 0xe3, 0xb3, 0x45, 0x36, 0x5b, 0x64, + 0x14, 0x3a, 0x8d, 0xd7, 0xa1, 0xe8, 0xeb, 0x8f, 0xe6, 0x20, 0xb7, 0x7f, 0xb0, 0xdf, 0xac, 0xce, + 0x20, 0x80, 0xfc, 0xe6, 0xe1, 0x56, 0x73, 0xbf, 0x51, 0xd5, 0x50, 0x09, 0x0a, 0x8d, 0x26, 0x1f, + 0x64, 0xf0, 0x63, 0x80, 0x40, 0x53, 0x54, 0x80, 0xec, 0x6e, 0xf3, 0xbb, 0xd5, 0x19, 0xca, 0xf3, + 0xbc, 0x69, 0x1c, 0xee, 0x1c, 0xec, 0x57, 0x35, 0xba, 0x78, 0xcb, 0x68, 0x6e, 0x1e, 0x35, 0xab, + 0x19, 0xca, 0xf1, 0xfe, 0x41, 0xa3, 0x9a, 0x45, 0x45, 0x98, 0x7d, 0xbe, 0xb9, 0xf7, 0xac, 0x59, + 0xcd, 0xe1, 0x2f, 0x34, 0x98, 0x17, 0xb6, 0xf3, 0xf3, 0x85, 0xde, 0x81, 0x7c, 0x97, 0x9d, 0x31, + 0xb6, 0xad, 0xa5, 0x8d, 0x6b, 0x11, 0x47, 0x85, 0xce, 0xa1, 0x21, 0x78, 0x11, 0x86, 0xec, 0xe9, + 0xd8, 0xad, 0x65, 0x56, 0xb3, 0x6b, 0xa5, 0x8d, 0xea, 0x3a, 0x3f, 0xfc, 0xeb, 0xbb, 0xe4, 0xec, + 0xb9, 0xd9, 0x1f, 0x11, 0x83, 0x4e, 0x22, 0x04, 0xb9, 0x81, 0xed, 0x10, 0xb6, 0xfb, 0x73, 0x06, + 0xfb, 0x4d, 0x8f, 0x04, 0x73, 0x80, 0xd8, 0x79, 0x3e, 0xc0, 0x2d, 0x80, 0xa7, 0x23, 0x2f, 0xf9, + 0x94, 0x2d, 0xc1, 0xec, 0x98, 0xca, 0x15, 0x27, 0x8c, 0x0f, 0xd8, 0xf1, 0x22, 0xa6, 0x4b, 0xfc, + 0xe3, 0x45, 0x07, 0xe8, 0x35, 0x28, 0x0c, 0x1d, 0x32, 0x3e, 0x3e, 0x1d, 0x33, 0x8c, 0x39, 0x23, + 0x4f, 0x87, 0xbb, 0x63, 0x6c, 0x41, 0x89, 0x81, 0xa4, 0xb2, 0xfb, 0x7e, 0x20, 0x3d, 0xc3, 0x96, + 0x4d, 0xda, 0x2e, 0xf1, 0x3e, 0x06, 0xd4, 0x20, 0x7d, 0xe2, 0x91, 0x34, 0x21, 0xa4, 0x58, 0x93, + 0x0d, 0x59, 0xf3, 0x33, 0x0d, 0x16, 0x43, 0xe2, 0x53, 0x99, 0x55, 0x83, 0x42, 0x9b, 0x09, 0xe3, + 0x1a, 0x64, 0x0d, 0x39, 0x44, 0x0f, 0x61, 0x4e, 0x28, 0xe0, 0xd6, 0xb2, 0x09, 0xbb, 0x5d, 0xe0, + 0x3a, 0xb9, 0xf8, 0x6f, 0x1a, 0x14, 0x85, 0xa1, 0x07, 0x43, 0xb4, 0x09, 0xf3, 0x0e, 0x1f, 0x1c, + 0x33, 0x7b, 0x84, 0x46, 0x7a, 0x72, 0x24, 0x6e, 0xcf, 0x18, 0x65, 0xb1, 0x84, 0x91, 0xd1, 0xff, + 0x41, 0x49, 0x8a, 0x18, 0x8e, 0x3c, 0xe1, 0xf2, 0x5a, 0x58, 0x40, 0x70, 0x72, 0xb6, 0x67, 0x0c, + 0x10, 0xec, 0x4f, 0x47, 0x1e, 0x3a, 0x82, 0x25, 0xb9, 0x98, 0x5b, 0x23, 0xd4, 0xc8, 0x32, 0x29, + 0xab, 0x61, 0x29, 0x93, 0x5b, 0xb5, 0x3d, 0x63, 0x20, 0xb1, 0x5e, 0x99, 0x7c, 0x5c, 0x84, 0x82, + 0xa0, 0xe2, 0xbf, 0x6b, 0x00, 0xd2, 0xa1, 0x07, 0x43, 0xd4, 0x80, 0x8a, 0x23, 0x46, 0x21, 0x83, + 0xaf, 0xc6, 0x1a, 0x2c, 0xf6, 0x61, 0xc6, 0x98, 0x97, 0x8b, 0xb8, 0xc9, 0xef, 0x42, 0xd9, 0x97, + 0x12, 0xd8, 0xbc, 0x1c, 0x63, 0xb3, 0x2f, 0xa1, 0x24, 0x17, 0x50, 0xab, 0x3f, 0x84, 0xcb, 0xfe, + 0xfa, 0x18, 0xb3, 0x6f, 0x4e, 0x31, 0xdb, 0x17, 0xb8, 0x28, 0x25, 0xa8, 0x86, 0x03, 0xcd, 0xdb, + 0x9c, 0x8c, 0xbf, 0xcc, 0x42, 0x61, 0xcb, 0x1e, 0x0c, 0x4d, 0x87, 0xee, 0x51, 0xde, 0x21, 0xee, + 0xa8, 0xef, 0x31, 0x73, 0x2b, 0x1b, 0xb7, 0xc2, 0x08, 0x82, 0x4d, 0xfe, 0x6f, 0x30, 0x56, 0x43, + 0x2c, 0xa1, 0x8b, 0x45, 0x9a, 0xce, 0x5c, 0x60, 0xb1, 0x48, 0xd2, 0x62, 0x89, 0x8c, 0xa5, 0x6c, + 0x10, 0x4b, 0x3a, 0x14, 0xc6, 0xc4, 0x09, 0xae, 0x96, 0xed, 0x19, 0x43, 0x12, 0xd0, 0x7d, 0x58, + 0x68, 0x39, 0xc4, 0xa4, 0xfe, 0x90, 0xd7, 0xcf, 0xac, 0xe0, 0xa9, 0xf0, 0x09, 0x43, 0x5e, 0x43, + 0xb7, 0xa0, 0x3c, 0xb0, 0xdb, 0x01, 0x5f, 0x5e, 0xf0, 0x95, 0x06, 0x76, 0xdb, 0x67, 0xba, 0x22, + 0x93, 0x12, 0xbd, 0x17, 0xca, 0xdb, 0x33, 0x22, 0x2d, 0xe1, 0xb7, 0x60, 0x3e, 0x64, 0x2b, 0x4d, + 0xbf, 0xcd, 0x0f, 0x9e, 0x6d, 0xee, 0xf1, 0x5c, 0xfd, 0x84, 0xa5, 0x67, 0xa3, 0xaa, 0xd1, 0x94, + 0xbf, 0xd7, 0x3c, 0x3c, 0xac, 0x66, 0xf0, 0xff, 0xfb, 0x4b, 0x44, 0x72, 0x57, 0x72, 0xfa, 0x8c, + 0x92, 0xd3, 0x35, 0x99, 0xd3, 0x33, 0x41, 0x4e, 0xcf, 0x3e, 0xae, 0x40, 0x99, 0x3b, 0xe4, 0x78, + 0x64, 0xf5, 0x6c, 0x0b, 0xff, 0x5a, 0x03, 0x38, 0x7a, 0x65, 0xc9, 0x8c, 0x53, 0x87, 0x42, 0x8b, + 0x0b, 0xaf, 0x69, 0x2c, 0x80, 0x2f, 0xc7, 0xfa, 0xd8, 0x90, 0x5c, 0xe8, 0x2d, 0x28, 0xb8, 0xa3, + 0x56, 0x8b, 0xb8, 0x32, 0xbf, 0xbf, 0x16, 0xcd, 0x21, 0x22, 0xc2, 0x0d, 0xc9, 0x47, 0x97, 0xbc, + 0x30, 0x7b, 0xfd, 0x11, 0xcb, 0xf6, 0xd3, 0x97, 0x08, 0x3e, 0xfc, 0x4b, 0x0d, 0x4a, 0x4c, 0xcb, + 0x54, 0x89, 0xeb, 0x1a, 0x14, 0x99, 0x0e, 0xa4, 0x2d, 0x52, 0xd7, 0x9c, 0x11, 0x10, 0xd0, 0xff, + 0x42, 0x51, 0x1e, 0x59, 0x99, 0xbd, 0x6a, 0xf1, 0x62, 0x0f, 0x86, 0x46, 0xc0, 0x8a, 0x77, 0xe1, + 0x12, 0xf3, 0x4a, 0x8b, 0x56, 0x65, 0xd2, 0x8f, 0x6a, 0xdd, 0xa2, 0x45, 0xea, 0x16, 0x1d, 0xe6, + 0x86, 0xdd, 0x33, 0xb7, 0xd7, 0x32, 0xfb, 0x42, 0x0b, 0x7f, 0x8c, 0xbf, 0x03, 0x48, 0x15, 0x96, + 0xc6, 0x5c, 0x3c, 0x0f, 0xa5, 0x6d, 0xd3, 0xed, 0x0a, 0x95, 0xf0, 0x47, 0x50, 0xe6, 0xc3, 0x54, + 0x3e, 0x44, 0x90, 0xeb, 0x9a, 0x6e, 0x97, 0x29, 0x3e, 0x6f, 0xb0, 0xdf, 0xf8, 0x12, 0x2c, 0x1c, + 0x5a, 0xe6, 0xd0, 0xed, 0xda, 0x32, 0xb9, 0xd2, 0xaa, 0xb4, 0x1a, 0xd0, 0x52, 0x21, 0xde, 0x83, + 0x05, 0x87, 0x0c, 0xcc, 0x9e, 0xd5, 0xb3, 0x3a, 0xc7, 0x27, 0x67, 0x1e, 0x71, 0x45, 0xd1, 0x5a, + 0xf1, 0xc9, 0x8f, 0x29, 0x95, 0xaa, 0x76, 0xd2, 0xb7, 0x4f, 0x44, 0x88, 0xb3, 0xdf, 0xf8, 0x37, + 0x1a, 0x94, 0x3f, 0x34, 0xbd, 0x96, 0xf4, 0x02, 0xda, 0x81, 0x8a, 0x1f, 0xd8, 0x8c, 0x22, 0x74, + 0x89, 0x64, 0x78, 0xb6, 0x66, 0x4b, 0x04, 0xba, 0xcc, 0xf0, 0xf3, 0x2d, 0x95, 0xc0, 0x44, 0x99, + 0x56, 0x8b, 0xf4, 0x7d, 0x51, 0x99, 0x64, 0x51, 0x8c, 0x51, 0x15, 0xa5, 0x12, 0x1e, 0x2f, 0x04, + 0xb7, 0x1f, 0x0f, 0xcb, 0x2f, 0x33, 0x80, 0x26, 0x75, 0xf8, 0xa6, 0x05, 0xc1, 0x1d, 0xa8, 0xb8, + 0x9e, 0xe9, 0x78, 0xc7, 0x91, 0x92, 0x7e, 0x9e, 0x51, 0xfd, 0xe4, 0x74, 0x0f, 0x16, 0x86, 0x8e, + 0xdd, 0x71, 0x88, 0xeb, 0x1e, 0x5b, 0xb6, 0xd7, 0x7b, 0x71, 0x26, 0xaa, 0xa1, 0x8a, 0x24, 0xef, + 0x33, 0x2a, 0x6a, 0x42, 0xe1, 0x45, 0xaf, 0xef, 0x11, 0xc7, 0xad, 0xcd, 0xae, 0x66, 0xd7, 0x2a, + 0x1b, 0x0f, 0xcf, 0xf3, 0xda, 0xfa, 0x7b, 0x8c, 0xff, 0xe8, 0x6c, 0x48, 0x0c, 0xb9, 0x56, 0xad, + 0x53, 0xf2, 0xa1, 0x3a, 0xe5, 0x0e, 0x40, 0xc0, 0x4f, 0xb3, 0xd6, 0xfe, 0xc1, 0xd3, 0x67, 0x47, + 0xd5, 0x19, 0x54, 0x86, 0xb9, 0xfd, 0x83, 0x46, 0x73, 0xaf, 0x49, 0xf3, 0x1a, 0xae, 0x4b, 0xdf, + 0xa8, 0x3e, 0x44, 0xcb, 0x30, 0xf7, 0x92, 0x52, 0xe5, 0x9b, 0x27, 0x6b, 0x14, 0xd8, 0x78, 0xa7, + 0x8d, 0xff, 0xaa, 0xc1, 0xbc, 0x38, 0x05, 0xa9, 0x8e, 0xa2, 0x0a, 0x91, 0x09, 0x41, 0xd0, 0xa2, + 0x88, 0x9f, 0x8e, 0xb6, 0xa8, 0xbd, 0xe4, 0x90, 0x86, 0x3b, 0xdf, 0x6c, 0xd2, 0x16, 0x6e, 0xf5, + 0xc7, 0xe8, 0x3e, 0x54, 0x5b, 0x3c, 0xdc, 0x23, 0xf7, 0x8c, 0xb1, 0x20, 0xe8, 0xfe, 0x26, 0xdd, + 0x81, 0x3c, 0x19, 0x13, 0xcb, 0x73, 0x6b, 0x25, 0x96, 0x9b, 0xe6, 0x65, 0x65, 0xd5, 0xa4, 0x54, + 0x43, 0x4c, 0xe2, 0xff, 0x81, 0x4b, 0x7b, 0xb4, 0xb4, 0x7d, 0xe2, 0x98, 0x96, 0x5a, 0x24, 0x1f, + 0x1d, 0xed, 0x09, 0xaf, 0x64, 0xbd, 0xa3, 0x3d, 0x54, 0x81, 0xcc, 0x4e, 0x43, 0xd8, 0x90, 0xe9, + 0x35, 0xf0, 0x67, 0x1a, 0x20, 0x75, 0x5d, 0x2a, 0x37, 0x45, 0x84, 0x4b, 0xf8, 0x6c, 0x00, 0xbf, + 0x04, 0xb3, 0xc4, 0x71, 0x6c, 0x87, 0x39, 0xa4, 0x68, 0xf0, 0x01, 0xbe, 0x2d, 0x74, 0x30, 0xc8, + 0xd8, 0x3e, 0xf5, 0xcf, 0x3c, 0x97, 0xa6, 0xf9, 0xaa, 0xee, 0xc2, 0x62, 0x88, 0x2b, 0x55, 0x8e, + 0xbc, 0x07, 0x97, 0x99, 0xb0, 0x5d, 0x42, 0x86, 0x9b, 0xfd, 0xde, 0x38, 0x11, 0x75, 0x08, 0x57, + 0xa2, 0x8c, 0xdf, 0xae, 0x8f, 0x70, 0x17, 0xf2, 0xef, 0xb3, 0x57, 0xb9, 0xa2, 0x4b, 0x8e, 0xf1, + 0x22, 0xc8, 0x59, 0xe6, 0x80, 0x3f, 0x70, 0x8a, 0x06, 0xfb, 0xcd, 0x2e, 0x15, 0x42, 0x9c, 0x67, + 0xc6, 0x1e, 0xbf, 0xbc, 0x8a, 0x86, 0x3f, 0x46, 0x2b, 0x00, 0xad, 0x7e, 0x8f, 0x58, 0x1e, 0x9b, + 0xcd, 0xb1, 0x59, 0x85, 0x82, 0xd7, 0xa1, 0xca, 0x91, 0x36, 0xdb, 0x6d, 0xe5, 0x02, 0xf3, 0xe5, + 0x69, 0x61, 0x79, 0xf8, 0x25, 0x5c, 0x52, 0xf8, 0x53, 0xb9, 0xe1, 0x75, 0xc8, 0xf3, 0xd6, 0x83, + 0xc8, 0x9d, 0x4b, 0xe1, 0x55, 0x1c, 0xc6, 0x10, 0x3c, 0xf8, 0x0e, 0x2c, 0x0a, 0x0a, 0x19, 0xd8, + 0x71, 0x7b, 0xc5, 0xfc, 0x83, 0xf7, 0x60, 0x29, 0xcc, 0x96, 0xea, 0x88, 0x6c, 0x4a, 0xd0, 0x67, + 0xc3, 0xb6, 0x92, 0x8a, 0xa3, 0x9b, 0xa2, 0x3a, 0x2c, 0x13, 0x71, 0x98, 0xaf, 0x90, 0x14, 0x91, + 0x4a, 0xa1, 0x45, 0xe9, 0xfe, 0xbd, 0x9e, 0xeb, 0x5f, 0xb8, 0x9f, 0x02, 0x52, 0x89, 0xa9, 0x36, + 0x65, 0x1d, 0x0a, 0xdc, 0xe1, 0xb2, 0xa6, 0x8b, 0xdf, 0x15, 0xc9, 0x44, 0x15, 0x6a, 0x90, 0x17, + 0x8e, 0xd9, 0x19, 0x10, 0x3f, 0xe7, 0xd0, 0x4a, 0x46, 0x25, 0xa6, 0xb2, 0xf8, 0x0f, 0x1a, 0x94, + 0x37, 0xfb, 0xa6, 0x33, 0x90, 0xce, 0x7f, 0x17, 0xf2, 0xbc, 0x44, 0x12, 0xcf, 0x88, 0xbb, 0x61, + 0x31, 0x2a, 0x2f, 0x1f, 0x6c, 0xf2, 0x82, 0x4a, 0xac, 0xa2, 0x9b, 0x25, 0x3a, 0x5e, 0x8d, 0x48, + 0x07, 0xac, 0x81, 0xde, 0x80, 0x59, 0x93, 0x2e, 0x61, 0xb1, 0x58, 0x89, 0x16, 0xa7, 0x4c, 0x1a, + 0xbb, 0xce, 0x38, 0x17, 0x7e, 0x07, 0x4a, 0x0a, 0x02, 0xad, 0xb9, 0x9f, 0x34, 0xc5, 0x95, 0xb5, + 0xb9, 0x75, 0xb4, 0xf3, 0x9c, 0x97, 0xe2, 0x15, 0x80, 0x46, 0xd3, 0x1f, 0x67, 0xf0, 0x47, 0x62, + 0x95, 0x88, 0x70, 0x55, 0x1f, 0x2d, 0x49, 0x9f, 0xcc, 0x85, 0xf4, 0x79, 0x05, 0xf3, 0xc2, 0xfc, + 0x54, 0x67, 0xe0, 0x2d, 0xc8, 0x33, 0x79, 0xf2, 0x08, 0x2c, 0xc7, 0xc0, 0xca, 0xe8, 0xe4, 0x8c, + 0x78, 0x01, 0xe6, 0x0f, 0x3d, 0xd3, 0x1b, 0xb9, 0xf2, 0x08, 0xfc, 0x5e, 0x83, 0x8a, 0xa4, 0xa4, + 0xed, 0x38, 0xc8, 0x97, 0x1a, 0xcf, 0x79, 0xfe, 0x3b, 0xed, 0x0a, 0xe4, 0xdb, 0x27, 0x87, 0xbd, + 0x4f, 0x65, 0x5f, 0x47, 0x8c, 0x28, 0xbd, 0xcf, 0x71, 0x78, 0x9f, 0x52, 0x8c, 0xe8, 0x13, 0xc0, + 0x31, 0x5f, 0x78, 0x3b, 0x56, 0x9b, 0xbc, 0x62, 0x37, 0x6d, 0xce, 0x08, 0x08, 0xac, 0x6a, 0x17, + 0xfd, 0x4c, 0x56, 0x99, 0xa8, 0xfd, 0xcd, 0x45, 0xb8, 0xb4, 0x39, 0xf2, 0xba, 0x4d, 0xcb, 0x3c, + 0xe9, 0xcb, 0x24, 0x80, 0x97, 0x00, 0x51, 0x62, 0xa3, 0xe7, 0xaa, 0xd4, 0x26, 0x2c, 0x52, 0x2a, + 0xb1, 0xbc, 0x5e, 0x4b, 0xc9, 0x18, 0x32, 0x6d, 0x6b, 0x91, 0xb4, 0x6d, 0xba, 0xee, 0x4b, 0xdb, + 0x69, 0x0b, 0xd3, 0xfc, 0x31, 0x6e, 0x70, 0xe1, 0xcf, 0xdc, 0x50, 0x62, 0xfe, 0xa6, 0x52, 0xd6, + 0x02, 0x29, 0x4f, 0x88, 0x37, 0x45, 0x0a, 0x7e, 0x08, 0x97, 0x25, 0xa7, 0x78, 0xca, 0x4f, 0x61, + 0x3e, 0x80, 0xeb, 0x92, 0x79, 0xab, 0x4b, 0xeb, 0xcd, 0xa7, 0x02, 0xf0, 0x3f, 0xd5, 0xf3, 0x31, + 0xd4, 0x7c, 0x3d, 0x59, 0x0d, 0x62, 0xf7, 0x55, 0x05, 0x46, 0xae, 0x38, 0x33, 0x45, 0x83, 0xfd, + 0xa6, 0x34, 0xc7, 0xee, 0xfb, 0x97, 0x20, 0xfd, 0x8d, 0xb7, 0x60, 0x59, 0xca, 0x10, 0xd5, 0x41, + 0x58, 0xc8, 0x84, 0x42, 0x71, 0x42, 0x84, 0xc3, 0xe8, 0xd2, 0xe9, 0x6e, 0x57, 0x39, 0xc3, 0xae, + 0x65, 0x32, 0x35, 0x45, 0xe6, 0x65, 0x7e, 0x22, 0xa8, 0x62, 0x6a, 0xd2, 0x16, 0x64, 0x2a, 0x40, + 0x25, 0x8b, 0x8d, 0xa0, 0xe4, 0x89, 0x8d, 0x98, 0x10, 0xfd, 0x31, 0xac, 0xf8, 0x4a, 0x50, 0xbf, + 0x3d, 0x25, 0xce, 0xa0, 0xe7, 0xba, 0xca, 0x5b, 0x34, 0xce, 0xf0, 0xbb, 0x90, 0x1b, 0x12, 0x91, + 0x53, 0x4a, 0x1b, 0x68, 0x9d, 0x7f, 0x75, 0x58, 0x57, 0x16, 0xb3, 0x79, 0xdc, 0x86, 0x1b, 0x52, + 0x3a, 0xf7, 0x68, 0xac, 0xf8, 0xa8, 0x52, 0xf2, 0x9d, 0xc2, 0xdd, 0x3a, 0xf9, 0x4e, 0xc9, 0xf2, + 0xbd, 0x97, 0xef, 0x14, 0x7a, 0x57, 0xa8, 0xb1, 0x95, 0xea, 0xae, 0xd8, 0xe5, 0x3e, 0xf5, 0x43, + 0x32, 0x95, 0xb0, 0x13, 0x58, 0x0a, 0x47, 0x72, 0xaa, 0x34, 0xb6, 0x04, 0xb3, 0x9e, 0x7d, 0x4a, + 0x64, 0x12, 0xe3, 0x03, 0xa9, 0xb0, 0x1f, 0xe6, 0xa9, 0x14, 0x36, 0x03, 0x61, 0xec, 0x48, 0xa6, + 0xd5, 0x97, 0xee, 0xa6, 0xac, 0x67, 0xf8, 0x00, 0xef, 0xc3, 0x95, 0x68, 0x9a, 0x48, 0xa5, 0xf2, + 0x73, 0x7e, 0x80, 0xe3, 0x32, 0x49, 0x2a, 0xb9, 0x1f, 0x04, 0xc9, 0x40, 0x49, 0x28, 0xa9, 0x44, + 0x1a, 0xa0, 0xc7, 0xe5, 0x97, 0xff, 0xc6, 0x79, 0xf5, 0xd3, 0x4d, 0x2a, 0x61, 0x6e, 0x20, 0x2c, + 0xfd, 0xf6, 0x07, 0x39, 0x22, 0x3b, 0x35, 0x47, 0x88, 0x20, 0x09, 0xb2, 0xd8, 0xb7, 0x70, 0xe8, + 0x04, 0x46, 0x90, 0x40, 0xd3, 0x62, 0xd0, 0x3b, 0xc4, 0xc7, 0x60, 0x03, 0x79, 0xb0, 0xd5, 0xb4, + 0x9b, 0x6a, 0x33, 0x3e, 0x0c, 0x72, 0xe7, 0x44, 0x66, 0x4e, 0x25, 0xf8, 0x23, 0x58, 0x4d, 0x4e, + 0xca, 0x69, 0x24, 0x3f, 0xc0, 0x50, 0xf4, 0x0b, 0x4a, 0xe5, 0x2b, 0x63, 0x09, 0x0a, 0xfb, 0x07, + 0x87, 0x4f, 0x37, 0xb7, 0x9a, 0x55, 0x6d, 0xe3, 0x9f, 0x59, 0xc8, 0xec, 0x3e, 0x47, 0xdf, 0x83, + 0x59, 0xfe, 0x0d, 0x62, 0xca, 0x27, 0x1a, 0x7d, 0xda, 0xd7, 0x0c, 0x7c, 0xed, 0xb3, 0x3f, 0xfe, + 0xe5, 0x8b, 0xcc, 0x15, 0x7c, 0xa9, 0x3e, 0x7e, 0xdb, 0xec, 0x0f, 0xbb, 0x66, 0xfd, 0x74, 0x5c, + 0x67, 0x77, 0xc2, 0x23, 0xed, 0x01, 0x7a, 0x0e, 0xd9, 0xa7, 0x23, 0x0f, 0x25, 0x7e, 0xbf, 0xd1, + 0x93, 0xbf, 0x72, 0x60, 0x9d, 0x49, 0x5e, 0xc2, 0x0b, 0xaa, 0xe4, 0xe1, 0xc8, 0xa3, 0x72, 0xc7, + 0x50, 0x52, 0x3e, 0x54, 0xa0, 0x73, 0xbf, 0xec, 0xe8, 0xe7, 0x7f, 0x04, 0xc1, 0x98, 0xe1, 0x5d, + 0xc3, 0xaf, 0xa9, 0x78, 0xfc, 0x7b, 0x8a, 0x6a, 0xcf, 0xd1, 0x2b, 0x2b, 0x6a, 0x4f, 0xd0, 0x7a, + 0x8f, 0xda, 0xa3, 0xb4, 0xbb, 0xe3, 0xed, 0xf1, 0x5e, 0x59, 0x54, 0xae, 0x2d, 0x3e, 0xae, 0xb4, + 0x3c, 0x74, 0x23, 0xa6, 0x57, 0xaf, 0x76, 0xa5, 0xf5, 0xd5, 0x64, 0x06, 0x81, 0x74, 0x93, 0x21, + 0x5d, 0xc5, 0x57, 0x54, 0xa4, 0x96, 0xcf, 0xf7, 0x48, 0x7b, 0xb0, 0xd1, 0x85, 0x59, 0xd6, 0x4b, + 0x43, 0xc7, 0xf2, 0x87, 0x1e, 0xd3, 0x05, 0x4c, 0x38, 0x01, 0xa1, 0x2e, 0x1c, 0x5e, 0x66, 0x68, + 0x8b, 0xb8, 0xe2, 0xa3, 0xb1, 0x76, 0xda, 0x23, 0xed, 0xc1, 0x9a, 0xf6, 0xa6, 0xb6, 0xf1, 0x8f, + 0x0c, 0xcc, 0xb2, 0xa6, 0x0b, 0x1a, 0x02, 0x04, 0xdd, 0xa9, 0xa8, 0x9d, 0x13, 0xfd, 0xae, 0xa8, + 0x9d, 0x93, 0x8d, 0x2d, 0x7c, 0x83, 0x21, 0x2f, 0xe3, 0x25, 0x1f, 0x99, 0x7d, 0x10, 0xae, 0x77, + 0x28, 0x17, 0x75, 0xeb, 0x4b, 0x28, 0x29, 0x5d, 0x26, 0x14, 0x27, 0x31, 0xd4, 0xa6, 0x8a, 0x1e, + 0x93, 0x98, 0x16, 0x15, 0xbe, 0xc5, 0x40, 0xaf, 0xe3, 0x9a, 0xea, 0x5c, 0x8e, 0xeb, 0x30, 0x4e, + 0x0a, 0xfc, 0x63, 0x0d, 0x2a, 0xe1, 0x4e, 0x13, 0xba, 0x15, 0x23, 0x3a, 0xda, 0xb0, 0xd2, 0x6f, + 0x4f, 0x67, 0x4a, 0x54, 0x81, 0xe3, 0x9f, 0x12, 0x32, 0x34, 0x29, 0xa7, 0xf4, 0xfd, 0xbf, 0xb2, + 0x50, 0xd8, 0xe2, 0x7f, 0x32, 0x82, 0x3c, 0x28, 0xfa, 0xfd, 0x1e, 0xb4, 0x12, 0xd7, 0x0b, 0x08, + 0x0a, 0x65, 0xfd, 0x46, 0xe2, 0xbc, 0x50, 0xe1, 0x2e, 0x53, 0x61, 0x15, 0x5f, 0xf5, 0x55, 0x10, + 0x7f, 0x9a, 0x52, 0xe7, 0x4f, 0xde, 0xba, 0xd9, 0x6e, 0x53, 0x47, 0xfc, 0x48, 0x83, 0xb2, 0xda, + 0xc6, 0x41, 0x37, 0x63, 0xbb, 0x10, 0x6a, 0x27, 0x48, 0xc7, 0xd3, 0x58, 0x04, 0xfe, 0x7d, 0x86, + 0x7f, 0x0b, 0xaf, 0x24, 0xe1, 0x3b, 0x8c, 0x3f, 0xac, 0x02, 0x6f, 0xdc, 0xc4, 0xab, 0x10, 0xea, + 0x0b, 0xc5, 0xab, 0x10, 0xee, 0xfb, 0x9c, 0xaf, 0xc2, 0x88, 0xf1, 0x53, 0x15, 0x5e, 0x01, 0x04, + 0x7d, 0x1d, 0x14, 0xeb, 0x5c, 0xe5, 0xe9, 0x10, 0x3d, 0xf9, 0x93, 0x2d, 0x21, 0x7c, 0x8f, 0x61, + 0xdf, 0xc4, 0xd7, 0x92, 0xb0, 0xfb, 0x3d, 0x97, 0x46, 0xc0, 0xc6, 0x6f, 0x73, 0x50, 0x7a, 0xdf, + 0xec, 0x59, 0x1e, 0xb1, 0x4c, 0xab, 0x45, 0x50, 0x07, 0x66, 0xd9, 0xdd, 0x10, 0x0d, 0x77, 0xb5, + 0xd9, 0x12, 0x0d, 0xf7, 0x50, 0x27, 0x02, 0xdf, 0x61, 0xd0, 0x37, 0xb0, 0xee, 0x43, 0x0f, 0x02, + 0xf9, 0x75, 0xd6, 0x45, 0xa0, 0x26, 0x9f, 0x42, 0x9e, 0x77, 0x0d, 0x50, 0x44, 0x5a, 0xa8, 0xbb, + 0xa0, 0x5f, 0x8b, 0x9f, 0x4c, 0x3c, 0x65, 0x2a, 0x96, 0xcb, 0x98, 0x29, 0xd8, 0xf7, 0x01, 0x82, + 0x36, 0x55, 0xd4, 0xbf, 0x13, 0x5d, 0x2d, 0x7d, 0x35, 0x99, 0x41, 0x00, 0x3f, 0x60, 0xc0, 0xb7, + 0xf1, 0x8d, 0x58, 0xe0, 0xb6, 0xbf, 0x80, 0x82, 0xb7, 0x20, 0xb7, 0x6d, 0xba, 0x5d, 0x14, 0x49, + 0xfd, 0xca, 0x57, 0x3b, 0x5d, 0x8f, 0x9b, 0x12, 0x50, 0xb7, 0x19, 0xd4, 0x0a, 0x5e, 0x8e, 0x85, + 0xea, 0x9a, 0x2e, 0xcd, 0xa4, 0x68, 0x04, 0x73, 0xf2, 0x4b, 0x1c, 0xba, 0x1e, 0xf1, 0x59, 0xf8, + 0xab, 0x9d, 0xbe, 0x92, 0x34, 0x2d, 0x00, 0xd7, 0x18, 0x20, 0xc6, 0xd7, 0xe3, 0x9d, 0x2a, 0xd8, + 0x1f, 0x69, 0x0f, 0xde, 0xd4, 0x36, 0x7e, 0x5a, 0x85, 0x1c, 0xad, 0x52, 0x68, 0xee, 0x0e, 0x1e, + 0x77, 0x51, 0x0f, 0x4f, 0xb4, 0x54, 0xa2, 0x1e, 0x9e, 0x7c, 0x17, 0xc6, 0xe4, 0x6e, 0xf6, 0x87, + 0x73, 0x84, 0x71, 0x51, 0x8b, 0x3d, 0x28, 0x29, 0x4f, 0x40, 0x14, 0x23, 0x31, 0xdc, 0xb0, 0x89, + 0xe6, 0xee, 0x98, 0xf7, 0x23, 0x5e, 0x65, 0xa0, 0x3a, 0xbe, 0x1c, 0x06, 0x6d, 0x73, 0x36, 0x8a, + 0xfa, 0x03, 0x28, 0xab, 0x6f, 0x45, 0x14, 0x23, 0x34, 0xd2, 0x11, 0x8a, 0xe6, 0x8a, 0xb8, 0xa7, + 0x66, 0x4c, 0xd0, 0xf8, 0x7f, 0x26, 0x28, 0x79, 0x29, 0xfa, 0x27, 0x50, 0x10, 0x2f, 0xc8, 0x38, + 0x7b, 0xc3, 0x3d, 0xa4, 0x38, 0x7b, 0x23, 0xcf, 0xcf, 0x98, 0x42, 0x80, 0xc1, 0xd2, 0x4a, 0x59, + 0x26, 0x68, 0x01, 0xf9, 0x84, 0x78, 0x49, 0x90, 0x41, 0x57, 0x24, 0x09, 0x52, 0x79, 0xa5, 0x4c, + 0x85, 0xec, 0x10, 0x4f, 0x9c, 0x65, 0xf9, 0x04, 0x40, 0x09, 0x12, 0xd5, 0x6c, 0x88, 0xa7, 0xb1, + 0x24, 0xd6, 0x6e, 0x01, 0xaa, 0x48, 0x85, 0xe8, 0x87, 0x00, 0xc1, 0x73, 0x37, 0x7a, 0x1d, 0xc7, + 0xf6, 0xcc, 0xa2, 0xd7, 0x71, 0xfc, 0x8b, 0x39, 0x26, 0x82, 0x03, 0x70, 0x5e, 0x3f, 0x52, 0xf8, + 0x9f, 0x6b, 0x80, 0x26, 0x9f, 0xc7, 0xe8, 0x61, 0x3c, 0x44, 0x6c, 0x3b, 0x4e, 0x7f, 0xfd, 0x62, + 0xcc, 0x89, 0xd9, 0x33, 0xd0, 0xab, 0xc5, 0x96, 0x0c, 0x5f, 0x52, 0xcd, 0x3e, 0xd7, 0x60, 0x3e, + 0xf4, 0xc0, 0x46, 0x77, 0x13, 0xf6, 0x39, 0xd2, 0xd2, 0xd3, 0xef, 0x9d, 0xcb, 0x97, 0x58, 0xb1, + 0x28, 0xa7, 0x42, 0x56, 0x6b, 0x3f, 0xd1, 0xa0, 0x12, 0x7e, 0x95, 0xa3, 0x04, 0x80, 0x89, 0xbe, + 0xa0, 0xbe, 0x76, 0x3e, 0xe3, 0x05, 0x76, 0x2b, 0x28, 0xe0, 0x3e, 0x81, 0x82, 0x78, 0xcc, 0xc7, + 0x85, 0x45, 0xb8, 0xad, 0x18, 0x17, 0x16, 0x91, 0x4e, 0x40, 0x52, 0x58, 0xd0, 0x77, 0xb1, 0x12, + 0x89, 0xe2, 0xc9, 0x9f, 0x04, 0x39, 0x3d, 0x12, 0x23, 0xfd, 0x82, 0xa9, 0x90, 0x41, 0x24, 0xca, + 0x07, 0x3f, 0x4a, 0x90, 0x78, 0x4e, 0x24, 0x46, 0xfb, 0x05, 0x49, 0x91, 0xc8, 0x50, 0x95, 0x48, + 0x0c, 0xde, 0xe7, 0x71, 0x91, 0x38, 0xd1, 0x34, 0x8d, 0x8b, 0xc4, 0xc9, 0x27, 0x7e, 0xd2, 0xde, + 0x32, 0xf0, 0x50, 0x24, 0x2e, 0xc6, 0xbc, 0xe7, 0xd1, 0xeb, 0x09, 0x3e, 0x8d, 0x6d, 0xc8, 0xea, + 0x6f, 0x5c, 0x90, 0x7b, 0x7a, 0x04, 0xf0, 0xdd, 0x90, 0x11, 0xf0, 0x2b, 0x0d, 0x96, 0xe2, 0x1a, + 0x02, 0x28, 0x01, 0x2c, 0xa1, 0x9b, 0xab, 0xaf, 0x5f, 0x94, 0xfd, 0x02, 0x7e, 0xf3, 0x63, 0xe2, + 0x71, 0xf5, 0x77, 0x5f, 0xaf, 0x68, 0x5f, 0x7d, 0xbd, 0xa2, 0xfd, 0xe9, 0xeb, 0x15, 0xed, 0x17, + 0x7f, 0x5e, 0x99, 0x39, 0xc9, 0xb3, 0xbf, 0x5e, 0x7f, 0xfb, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, + 0x66, 0x40, 0x0b, 0xdf, 0x44, 0x2f, 0x00, 0x00, +} diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.gw.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.gw.go new file mode 100644 index 00000000..a2efbcd9 --- /dev/null +++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.gw.go @@ -0,0 +1,1866 @@ +// Code generated by protoc-gen-grpc-gateway +// source: etcdserver/etcdserverpb/rpc.proto +// DO NOT EDIT! + +/* +Package etcdserverpb is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package etcdserverpb + +import ( + "io" + "net/http" + + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "golang.org/x/net/context" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" +) + +var _ codes.Code +var _ io.Reader +var _ = runtime.String +var _ = utilities.NewDoubleArray + +func request_KV_Range_0(ctx context.Context, marshaler runtime.Marshaler, client KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq RangeRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Range(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_KV_Put_0(ctx context.Context, marshaler runtime.Marshaler, client KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq PutRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Put(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_KV_DeleteRange_0(ctx context.Context, marshaler runtime.Marshaler, client KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq DeleteRangeRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.DeleteRange(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_KV_Txn_0(ctx context.Context, marshaler runtime.Marshaler, client KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq TxnRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Txn(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_KV_Compact_0(ctx context.Context, marshaler runtime.Marshaler, client KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq CompactionRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Compact(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Watch_Watch_0(ctx context.Context, marshaler runtime.Marshaler, client WatchClient, req *http.Request, pathParams map[string]string) (Watch_WatchClient, runtime.ServerMetadata, error) { + var metadata runtime.ServerMetadata + stream, err := client.Watch(ctx) + if err != nil { + grpclog.Printf("Failed to start streaming: %v", err) + return nil, metadata, err + } + dec := marshaler.NewDecoder(req.Body) + handleSend := func() error { + var protoReq WatchRequest + err = dec.Decode(&protoReq) + if err == io.EOF { + return err + } + if err != nil { + grpclog.Printf("Failed to decode request: %v", err) + return err + } + if err = stream.Send(&protoReq); err != nil { + grpclog.Printf("Failed to send request: %v", err) + return err + } + return nil + } + if err := handleSend(); err != nil { + if cerr := stream.CloseSend(); cerr != nil { + grpclog.Printf("Failed to terminate client stream: %v", cerr) + } + if err == io.EOF { + return stream, metadata, nil + } + return nil, metadata, err + } + go func() { + for { + if err := handleSend(); err != nil { + break + } + } + if err := stream.CloseSend(); err != nil { + grpclog.Printf("Failed to terminate client stream: %v", err) + } + }() + header, err := stream.Header() + if err != nil { + grpclog.Printf("Failed to get header from client: %v", err) + return nil, metadata, err + } + metadata.HeaderMD = header + return stream, metadata, nil +} + +func request_Lease_LeaseGrant_0(ctx context.Context, marshaler runtime.Marshaler, client LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq LeaseGrantRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.LeaseGrant(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Lease_LeaseRevoke_0(ctx context.Context, marshaler runtime.Marshaler, client LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq LeaseRevokeRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.LeaseRevoke(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Lease_LeaseKeepAlive_0(ctx context.Context, marshaler runtime.Marshaler, client LeaseClient, req *http.Request, pathParams map[string]string) (Lease_LeaseKeepAliveClient, runtime.ServerMetadata, error) { + var metadata runtime.ServerMetadata + stream, err := client.LeaseKeepAlive(ctx) + if err != nil { + grpclog.Printf("Failed to start streaming: %v", err) + return nil, metadata, err + } + dec := marshaler.NewDecoder(req.Body) + handleSend := func() error { + var protoReq LeaseKeepAliveRequest + err = dec.Decode(&protoReq) + if err == io.EOF { + return err + } + if err != nil { + grpclog.Printf("Failed to decode request: %v", err) + return err + } + if err = stream.Send(&protoReq); err != nil { + grpclog.Printf("Failed to send request: %v", err) + return err + } + return nil + } + if err := handleSend(); err != nil { + if cerr := stream.CloseSend(); cerr != nil { + grpclog.Printf("Failed to terminate client stream: %v", cerr) + } + if err == io.EOF { + return stream, metadata, nil + } + return nil, metadata, err + } + go func() { + for { + if err := handleSend(); err != nil { + break + } + } + if err := stream.CloseSend(); err != nil { + grpclog.Printf("Failed to terminate client stream: %v", err) + } + }() + header, err := stream.Header() + if err != nil { + grpclog.Printf("Failed to get header from client: %v", err) + return nil, metadata, err + } + metadata.HeaderMD = header + return stream, metadata, nil +} + +func request_Cluster_MemberAdd_0(ctx context.Context, marshaler runtime.Marshaler, client ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MemberAddRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.MemberAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Cluster_MemberRemove_0(ctx context.Context, marshaler runtime.Marshaler, client ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MemberRemoveRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.MemberRemove(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Cluster_MemberUpdate_0(ctx context.Context, marshaler runtime.Marshaler, client ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MemberUpdateRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.MemberUpdate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Cluster_MemberList_0(ctx context.Context, marshaler runtime.Marshaler, client ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MemberListRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.MemberList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Maintenance_Alarm_0(ctx context.Context, marshaler runtime.Marshaler, client MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AlarmRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Alarm(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Maintenance_Status_0(ctx context.Context, marshaler runtime.Marshaler, client MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq StatusRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Status(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Maintenance_Defragment_0(ctx context.Context, marshaler runtime.Marshaler, client MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq DefragmentRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Defragment(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Maintenance_Hash_0(ctx context.Context, marshaler runtime.Marshaler, client MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq HashRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Hash(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Maintenance_Snapshot_0(ctx context.Context, marshaler runtime.Marshaler, client MaintenanceClient, req *http.Request, pathParams map[string]string) (Maintenance_SnapshotClient, runtime.ServerMetadata, error) { + var protoReq SnapshotRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + stream, err := client.Snapshot(ctx, &protoReq) + if err != nil { + return nil, metadata, err + } + header, err := stream.Header() + if err != nil { + return nil, metadata, err + } + metadata.HeaderMD = header + return stream, metadata, nil + +} + +func request_Auth_AuthEnable_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthEnableRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.AuthEnable(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_AuthDisable_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthDisableRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.AuthDisable(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_Authenticate_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthenticateRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Authenticate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_UserAdd_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthUserAddRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.UserAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_UserGet_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthUserGetRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.UserGet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_UserList_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthUserListRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.UserList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_UserDelete_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthUserDeleteRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.UserDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_UserChangePassword_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthUserChangePasswordRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.UserChangePassword(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_UserGrantRole_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthUserGrantRoleRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.UserGrantRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_UserRevokeRole_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthUserRevokeRoleRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.UserRevokeRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_RoleAdd_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthRoleAddRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.RoleAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_RoleGet_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthRoleGetRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.RoleGet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_RoleList_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthRoleListRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.RoleList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_RoleDelete_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthRoleDeleteRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.RoleDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_RoleGrantPermission_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthRoleGrantPermissionRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.RoleGrantPermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Auth_RoleRevokePermission_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq AuthRoleRevokePermissionRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.RoleRevokePermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +// RegisterKVHandlerFromEndpoint is same as RegisterKVHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterKVHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterKVHandler(ctx, mux, conn) +} + +// RegisterKVHandler registers the http handlers for service KV to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterKVHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + client := NewKVClient(conn) + + mux.Handle("POST", pattern_KV_Range_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_KV_Range_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_KV_Range_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_KV_Put_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_KV_Put_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_KV_Put_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_KV_DeleteRange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_KV_DeleteRange_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_KV_DeleteRange_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_KV_Txn_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_KV_Txn_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_KV_Txn_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_KV_Compact_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_KV_Compact_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_KV_Compact_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_KV_Range_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "range"}, "")) + + pattern_KV_Put_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "put"}, "")) + + pattern_KV_DeleteRange_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "deleterange"}, "")) + + pattern_KV_Txn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "txn"}, "")) + + pattern_KV_Compact_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "compaction"}, "")) +) + +var ( + forward_KV_Range_0 = runtime.ForwardResponseMessage + + forward_KV_Put_0 = runtime.ForwardResponseMessage + + forward_KV_DeleteRange_0 = runtime.ForwardResponseMessage + + forward_KV_Txn_0 = runtime.ForwardResponseMessage + + forward_KV_Compact_0 = runtime.ForwardResponseMessage +) + +// RegisterWatchHandlerFromEndpoint is same as RegisterWatchHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterWatchHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterWatchHandler(ctx, mux, conn) +} + +// RegisterWatchHandler registers the http handlers for service Watch to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterWatchHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + client := NewWatchClient(conn) + + mux.Handle("POST", pattern_Watch_Watch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Watch_Watch_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Watch_Watch_0(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Watch_Watch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v3alpha", "watch"}, "")) +) + +var ( + forward_Watch_Watch_0 = runtime.ForwardResponseStream +) + +// RegisterLeaseHandlerFromEndpoint is same as RegisterLeaseHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterLeaseHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterLeaseHandler(ctx, mux, conn) +} + +// RegisterLeaseHandler registers the http handlers for service Lease to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterLeaseHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + client := NewLeaseClient(conn) + + mux.Handle("POST", pattern_Lease_LeaseGrant_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Lease_LeaseGrant_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Lease_LeaseGrant_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Lease_LeaseRevoke_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Lease_LeaseRevoke_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Lease_LeaseRevoke_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Lease_LeaseKeepAlive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Lease_LeaseKeepAlive_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Lease_LeaseKeepAlive_0(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Lease_LeaseGrant_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "lease", "grant"}, "")) + + pattern_Lease_LeaseRevoke_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "kv", "lease", "revoke"}, "")) + + pattern_Lease_LeaseKeepAlive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "lease", "keepalive"}, "")) +) + +var ( + forward_Lease_LeaseGrant_0 = runtime.ForwardResponseMessage + + forward_Lease_LeaseRevoke_0 = runtime.ForwardResponseMessage + + forward_Lease_LeaseKeepAlive_0 = runtime.ForwardResponseStream +) + +// RegisterClusterHandlerFromEndpoint is same as RegisterClusterHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterClusterHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterClusterHandler(ctx, mux, conn) +} + +// RegisterClusterHandler registers the http handlers for service Cluster to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterClusterHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + client := NewClusterClient(conn) + + mux.Handle("POST", pattern_Cluster_MemberAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Cluster_MemberAdd_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Cluster_MemberAdd_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Cluster_MemberRemove_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Cluster_MemberRemove_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Cluster_MemberRemove_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Cluster_MemberUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Cluster_MemberUpdate_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Cluster_MemberUpdate_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Cluster_MemberList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Cluster_MemberList_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Cluster_MemberList_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Cluster_MemberAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "add"}, "")) + + pattern_Cluster_MemberRemove_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "remove"}, "")) + + pattern_Cluster_MemberUpdate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "update"}, "")) + + pattern_Cluster_MemberList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "list"}, "")) +) + +var ( + forward_Cluster_MemberAdd_0 = runtime.ForwardResponseMessage + + forward_Cluster_MemberRemove_0 = runtime.ForwardResponseMessage + + forward_Cluster_MemberUpdate_0 = runtime.ForwardResponseMessage + + forward_Cluster_MemberList_0 = runtime.ForwardResponseMessage +) + +// RegisterMaintenanceHandlerFromEndpoint is same as RegisterMaintenanceHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterMaintenanceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterMaintenanceHandler(ctx, mux, conn) +} + +// RegisterMaintenanceHandler registers the http handlers for service Maintenance to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterMaintenanceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + client := NewMaintenanceClient(conn) + + mux.Handle("POST", pattern_Maintenance_Alarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Maintenance_Alarm_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Maintenance_Alarm_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Maintenance_Status_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Maintenance_Status_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Maintenance_Status_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Maintenance_Defragment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Maintenance_Defragment_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Maintenance_Defragment_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Maintenance_Hash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Maintenance_Hash_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Maintenance_Hash_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Maintenance_Snapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Maintenance_Snapshot_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Maintenance_Snapshot_0(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Maintenance_Alarm_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "alarm"}, "")) + + pattern_Maintenance_Status_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "status"}, "")) + + pattern_Maintenance_Defragment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "defragment"}, "")) + + pattern_Maintenance_Hash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "hash"}, "")) + + pattern_Maintenance_Snapshot_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "snapshot"}, "")) +) + +var ( + forward_Maintenance_Alarm_0 = runtime.ForwardResponseMessage + + forward_Maintenance_Status_0 = runtime.ForwardResponseMessage + + forward_Maintenance_Defragment_0 = runtime.ForwardResponseMessage + + forward_Maintenance_Hash_0 = runtime.ForwardResponseMessage + + forward_Maintenance_Snapshot_0 = runtime.ForwardResponseStream +) + +// RegisterAuthHandlerFromEndpoint is same as RegisterAuthHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterAuthHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterAuthHandler(ctx, mux, conn) +} + +// RegisterAuthHandler registers the http handlers for service Auth to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterAuthHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + client := NewAuthClient(conn) + + mux.Handle("POST", pattern_Auth_AuthEnable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_AuthEnable_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_AuthEnable_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_AuthDisable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_AuthDisable_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_AuthDisable_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_Authenticate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_Authenticate_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_Authenticate_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_UserAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_UserAdd_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_UserAdd_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_UserGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_UserGet_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_UserGet_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_UserList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_UserList_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_UserList_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_UserDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_UserDelete_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_UserDelete_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_UserChangePassword_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_UserChangePassword_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_UserChangePassword_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_UserGrantRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_UserGrantRole_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_UserGrantRole_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_UserRevokeRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_UserRevokeRole_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_UserRevokeRole_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_RoleAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_RoleAdd_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_RoleAdd_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_RoleGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_RoleGet_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_RoleGet_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_RoleList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_RoleList_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_RoleList_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_RoleDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_RoleDelete_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_RoleDelete_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_RoleGrantPermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_RoleGrantPermission_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_RoleGrantPermission_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Auth_RoleRevokePermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Auth_RoleRevokePermission_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Auth_RoleRevokePermission_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Auth_AuthEnable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "auth", "enable"}, "")) + + pattern_Auth_AuthDisable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "auth", "disable"}, "")) + + pattern_Auth_Authenticate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "auth", "authenticate"}, "")) + + pattern_Auth_UserAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "add"}, "")) + + pattern_Auth_UserGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "get"}, "")) + + pattern_Auth_UserList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "list"}, "")) + + pattern_Auth_UserDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "delete"}, "")) + + pattern_Auth_UserChangePassword_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "changepw"}, "")) + + pattern_Auth_UserGrantRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "grant"}, "")) + + pattern_Auth_UserRevokeRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "revoke"}, "")) + + pattern_Auth_RoleAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "add"}, "")) + + pattern_Auth_RoleGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "get"}, "")) + + pattern_Auth_RoleList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "list"}, "")) + + pattern_Auth_RoleDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "delete"}, "")) + + pattern_Auth_RoleGrantPermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "grant"}, "")) + + pattern_Auth_RoleRevokePermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "revoke"}, "")) +) + +var ( + forward_Auth_AuthEnable_0 = runtime.ForwardResponseMessage + + forward_Auth_AuthDisable_0 = runtime.ForwardResponseMessage + + forward_Auth_Authenticate_0 = runtime.ForwardResponseMessage + + forward_Auth_UserAdd_0 = runtime.ForwardResponseMessage + + forward_Auth_UserGet_0 = runtime.ForwardResponseMessage + + forward_Auth_UserList_0 = runtime.ForwardResponseMessage + + forward_Auth_UserDelete_0 = runtime.ForwardResponseMessage + + forward_Auth_UserChangePassword_0 = runtime.ForwardResponseMessage + + forward_Auth_UserGrantRole_0 = runtime.ForwardResponseMessage + + forward_Auth_UserRevokeRole_0 = runtime.ForwardResponseMessage + + forward_Auth_RoleAdd_0 = runtime.ForwardResponseMessage + + forward_Auth_RoleGet_0 = runtime.ForwardResponseMessage + + forward_Auth_RoleList_0 = runtime.ForwardResponseMessage + + forward_Auth_RoleDelete_0 = runtime.ForwardResponseMessage + + forward_Auth_RoleGrantPermission_0 = runtime.ForwardResponseMessage + + forward_Auth_RoleRevokePermission_0 = runtime.ForwardResponseMessage +) diff --git a/vendor/github.com/coreos/etcd/main.go b/vendor/github.com/coreos/etcd/main.go new file mode 100644 index 00000000..0b735737 --- /dev/null +++ b/vendor/github.com/coreos/etcd/main.go @@ -0,0 +1,29 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package main is a simple wrapper of the real etcd entrypoint package +// (located at github.com/coreos/etcd/etcdmain) to ensure that etcd is still +// "go getable"; e.g. `go get github.com/coreos/etcd` works as expected and +// builds a binary in $GOBIN/etcd +// +// This package should NOT be extended or modified in any way; to modify the +// etcd binary, work in the `github.com/coreos/etcd/etcdmain` package. +// +package main + +import "github.com/coreos/etcd/etcdmain" + +func main() { + etcdmain.Main() +} diff --git a/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.pb.go b/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.pb.go new file mode 100644 index 00000000..e7575ca1 --- /dev/null +++ b/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.pb.go @@ -0,0 +1,731 @@ +// Code generated by protoc-gen-gogo. +// source: kv.proto +// DO NOT EDIT! + +/* + Package mvccpb is a generated protocol buffer package. + + It is generated from these files: + kv.proto + + It has these top-level messages: + KeyValue + Event +*/ +package mvccpb + +import ( + "fmt" + + proto "github.com/golang/protobuf/proto" + + math "math" +) + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +const _ = proto.ProtoPackageIsVersion1 + +type Event_EventType int32 + +const ( + PUT Event_EventType = 0 + DELETE Event_EventType = 1 +) + +var Event_EventType_name = map[int32]string{ + 0: "PUT", + 1: "DELETE", +} +var Event_EventType_value = map[string]int32{ + "PUT": 0, + "DELETE": 1, +} + +func (x Event_EventType) String() string { + return proto.EnumName(Event_EventType_name, int32(x)) +} +func (Event_EventType) EnumDescriptor() ([]byte, []int) { return fileDescriptorKv, []int{1, 0} } + +type KeyValue struct { + // key is the key in bytes. An empty key is not allowed. + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // create_revision is the revision of last creation on this key. + CreateRevision int64 `protobuf:"varint,2,opt,name=create_revision,json=createRevision,proto3" json:"create_revision,omitempty"` + // mod_revision is the revision of last modification on this key. + ModRevision int64 `protobuf:"varint,3,opt,name=mod_revision,json=modRevision,proto3" json:"mod_revision,omitempty"` + // version is the version of the key. A deletion resets + // the version to zero and any modification of the key + // increases its version. + Version int64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"` + // value is the value held by the key, in bytes. + Value []byte `protobuf:"bytes,5,opt,name=value,proto3" json:"value,omitempty"` + // lease is the ID of the lease that attached to key. + // When the attached lease expires, the key will be deleted. + // If lease is 0, then no lease is attached to the key. + Lease int64 `protobuf:"varint,6,opt,name=lease,proto3" json:"lease,omitempty"` +} + +func (m *KeyValue) Reset() { *m = KeyValue{} } +func (m *KeyValue) String() string { return proto.CompactTextString(m) } +func (*KeyValue) ProtoMessage() {} +func (*KeyValue) Descriptor() ([]byte, []int) { return fileDescriptorKv, []int{0} } + +type Event struct { + // type is the kind of event. If type is a PUT, it indicates + // new data has been stored to the key. If type is a DELETE, + // it indicates the key was deleted. + Type Event_EventType `protobuf:"varint,1,opt,name=type,proto3,enum=mvccpb.Event_EventType" json:"type,omitempty"` + // kv holds the KeyValue for the event. + // A PUT event contains current kv pair. + // A PUT event with kv.Version=1 indicates the creation of a key. + // A DELETE/EXPIRE event contains the deleted key with + // its modification revision set to the revision of deletion. + Kv *KeyValue `protobuf:"bytes,2,opt,name=kv" json:"kv,omitempty"` + // prev_kv holds the key-value pair before the event happens. + PrevKv *KeyValue `protobuf:"bytes,3,opt,name=prev_kv,json=prevKv" json:"prev_kv,omitempty"` +} + +func (m *Event) Reset() { *m = Event{} } +func (m *Event) String() string { return proto.CompactTextString(m) } +func (*Event) ProtoMessage() {} +func (*Event) Descriptor() ([]byte, []int) { return fileDescriptorKv, []int{1} } + +func init() { + proto.RegisterType((*KeyValue)(nil), "mvccpb.KeyValue") + proto.RegisterType((*Event)(nil), "mvccpb.Event") + proto.RegisterEnum("mvccpb.Event_EventType", Event_EventType_name, Event_EventType_value) +} +func (m *KeyValue) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *KeyValue) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Key) > 0 { + data[i] = 0xa + i++ + i = encodeVarintKv(data, i, uint64(len(m.Key))) + i += copy(data[i:], m.Key) + } + if m.CreateRevision != 0 { + data[i] = 0x10 + i++ + i = encodeVarintKv(data, i, uint64(m.CreateRevision)) + } + if m.ModRevision != 0 { + data[i] = 0x18 + i++ + i = encodeVarintKv(data, i, uint64(m.ModRevision)) + } + if m.Version != 0 { + data[i] = 0x20 + i++ + i = encodeVarintKv(data, i, uint64(m.Version)) + } + if len(m.Value) > 0 { + data[i] = 0x2a + i++ + i = encodeVarintKv(data, i, uint64(len(m.Value))) + i += copy(data[i:], m.Value) + } + if m.Lease != 0 { + data[i] = 0x30 + i++ + i = encodeVarintKv(data, i, uint64(m.Lease)) + } + return i, nil +} + +func (m *Event) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Event) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Type != 0 { + data[i] = 0x8 + i++ + i = encodeVarintKv(data, i, uint64(m.Type)) + } + if m.Kv != nil { + data[i] = 0x12 + i++ + i = encodeVarintKv(data, i, uint64(m.Kv.Size())) + n1, err := m.Kv.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if m.PrevKv != nil { + data[i] = 0x1a + i++ + i = encodeVarintKv(data, i, uint64(m.PrevKv.Size())) + n2, err := m.PrevKv.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + return i, nil +} + +func encodeFixed64Kv(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Kv(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintKv(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *KeyValue) Size() (n int) { + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovKv(uint64(l)) + } + if m.CreateRevision != 0 { + n += 1 + sovKv(uint64(m.CreateRevision)) + } + if m.ModRevision != 0 { + n += 1 + sovKv(uint64(m.ModRevision)) + } + if m.Version != 0 { + n += 1 + sovKv(uint64(m.Version)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovKv(uint64(l)) + } + if m.Lease != 0 { + n += 1 + sovKv(uint64(m.Lease)) + } + return n +} + +func (m *Event) Size() (n int) { + var l int + _ = l + if m.Type != 0 { + n += 1 + sovKv(uint64(m.Type)) + } + if m.Kv != nil { + l = m.Kv.Size() + n += 1 + l + sovKv(uint64(l)) + } + if m.PrevKv != nil { + l = m.PrevKv.Size() + n += 1 + l + sovKv(uint64(l)) + } + return n +} + +func sovKv(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozKv(x uint64) (n int) { + return sovKv(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *KeyValue) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: KeyValue: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KeyValue: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKv + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], data[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CreateRevision", wireType) + } + m.CreateRevision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.CreateRevision |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ModRevision", wireType) + } + m.ModRevision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ModRevision |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Version |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKv + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], data[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType) + } + m.Lease = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Lease |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipKv(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthKv + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Event) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Event: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Type |= (Event_EventType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Kv", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKv + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Kv == nil { + m.Kv = &KeyValue{} + } + if err := m.Kv.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKv + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKv + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PrevKv == nil { + m.PrevKv = &KeyValue{} + } + if err := m.PrevKv.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKv(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthKv + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipKv(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowKv + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowKv + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowKv + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthKv + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowKv + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipKv(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthKv = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowKv = fmt.Errorf("proto: integer overflow") +) + +var fileDescriptorKv = []byte{ + // 303 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0x41, 0x4e, 0xc2, 0x40, + 0x14, 0x86, 0x3b, 0x14, 0x0a, 0x3e, 0x08, 0x36, 0x13, 0x12, 0x27, 0x2e, 0x26, 0x95, 0x8d, 0x18, + 0x13, 0x4c, 0xf0, 0x06, 0xc6, 0xae, 0x70, 0x61, 0x1a, 0x74, 0x4b, 0x4a, 0x79, 0x21, 0xa4, 0x94, + 0x69, 0x4a, 0x9d, 0xa4, 0x37, 0x71, 0xef, 0xde, 0x73, 0xb0, 0xe4, 0x08, 0x52, 0x2f, 0x62, 0xfa, + 0xc6, 0xe2, 0xc6, 0xcd, 0xe4, 0xfd, 0xff, 0xff, 0x65, 0xe6, 0x7f, 0x03, 0x9d, 0x58, 0x8f, 0xd3, + 0x4c, 0xe5, 0x8a, 0x3b, 0x89, 0x8e, 0xa2, 0x74, 0x71, 0x39, 0x58, 0xa9, 0x95, 0x22, 0xeb, 0xae, + 0x9a, 0x4c, 0x3a, 0xfc, 0x64, 0xd0, 0x99, 0x62, 0xf1, 0x1a, 0x6e, 0xde, 0x90, 0xbb, 0x60, 0xc7, + 0x58, 0x08, 0xe6, 0xb1, 0x51, 0x2f, 0xa8, 0x46, 0x7e, 0x0d, 0xe7, 0x51, 0x86, 0x61, 0x8e, 0xf3, + 0x0c, 0xf5, 0x7a, 0xb7, 0x56, 0x5b, 0xd1, 0xf0, 0xd8, 0xc8, 0x0e, 0xfa, 0xc6, 0x0e, 0x7e, 0x5d, + 0x7e, 0x05, 0xbd, 0x44, 0x2d, 0xff, 0x28, 0x9b, 0xa8, 0x6e, 0xa2, 0x96, 0x27, 0x44, 0x40, 0x5b, + 0x63, 0x46, 0x69, 0x93, 0xd2, 0x5a, 0xf2, 0x01, 0xb4, 0x74, 0x55, 0x40, 0xb4, 0xe8, 0x65, 0x23, + 0x2a, 0x77, 0x83, 0xe1, 0x0e, 0x85, 0x43, 0xb4, 0x11, 0xc3, 0x0f, 0x06, 0x2d, 0x5f, 0xe3, 0x36, + 0xe7, 0xb7, 0xd0, 0xcc, 0x8b, 0x14, 0xa9, 0x6e, 0x7f, 0x72, 0x31, 0x36, 0x7b, 0x8e, 0x29, 0x34, + 0xe7, 0xac, 0x48, 0x31, 0x20, 0x88, 0x7b, 0xd0, 0x88, 0x35, 0x75, 0xef, 0x4e, 0xdc, 0x1a, 0xad, + 0x17, 0x0f, 0x1a, 0xb1, 0xe6, 0x37, 0xd0, 0x4e, 0x33, 0xd4, 0xf3, 0x58, 0x53, 0xf9, 0xff, 0x30, + 0xa7, 0x02, 0xa6, 0x7a, 0xe8, 0xc1, 0xd9, 0xe9, 0x7e, 0xde, 0x06, 0xfb, 0xf9, 0x65, 0xe6, 0x5a, + 0x1c, 0xc0, 0x79, 0xf4, 0x9f, 0xfc, 0x99, 0xef, 0xb2, 0x07, 0xb1, 0x3f, 0x4a, 0xeb, 0x70, 0x94, + 0xd6, 0xbe, 0x94, 0xec, 0x50, 0x4a, 0xf6, 0x55, 0x4a, 0xf6, 0xfe, 0x2d, 0xad, 0x85, 0x43, 0xff, + 0x7e, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0xb5, 0x45, 0x92, 0x5d, 0xa1, 0x01, 0x00, 0x00, +} diff --git a/vendor/github.com/coreos/etcd/pkg/pathutil/path.go b/vendor/github.com/coreos/etcd/pkg/pathutil/path.go new file mode 100644 index 00000000..f26254ba --- /dev/null +++ b/vendor/github.com/coreos/etcd/pkg/pathutil/path.go @@ -0,0 +1,31 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package pathutil implements utility functions for handling slash-separated +// paths. +package pathutil + +import "path" + +// CanonicalURLPath returns the canonical url path for p, which follows the rules: +// 1. the path always starts with "/" +// 2. replace multiple slashes with a single slash +// 3. replace each '.' '..' path name element with equivalent one +// 4. keep the trailing slash +// The function is borrowed from stdlib http.cleanPath in server.go. +func CanonicalURLPath(p string) string { + if p == "" { + return "/" + } + if p[0] != '/' { + p = "/" + p + } + np := path.Clean(p) + // path.Clean removes trailing slash except for root, + // put the trailing slash back if necessary. + if p[len(p)-1] == '/' && np != "/" { + np += "/" + } + return np +} diff --git a/vendor/github.com/coreos/etcd/pkg/tlsutil/doc.go b/vendor/github.com/coreos/etcd/pkg/tlsutil/doc.go new file mode 100644 index 00000000..3b6aa670 --- /dev/null +++ b/vendor/github.com/coreos/etcd/pkg/tlsutil/doc.go @@ -0,0 +1,16 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package tlsutil provides utility functions for handling TLS. +package tlsutil diff --git a/vendor/github.com/coreos/etcd/pkg/tlsutil/tlsutil.go b/vendor/github.com/coreos/etcd/pkg/tlsutil/tlsutil.go new file mode 100644 index 00000000..79b1f632 --- /dev/null +++ b/vendor/github.com/coreos/etcd/pkg/tlsutil/tlsutil.go @@ -0,0 +1,72 @@ +// Copyright 2016 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package tlsutil + +import ( + "crypto/tls" + "crypto/x509" + "encoding/pem" + "io/ioutil" +) + +// NewCertPool creates x509 certPool with provided CA files. +func NewCertPool(CAFiles []string) (*x509.CertPool, error) { + certPool := x509.NewCertPool() + + for _, CAFile := range CAFiles { + pemByte, err := ioutil.ReadFile(CAFile) + if err != nil { + return nil, err + } + + for { + var block *pem.Block + block, pemByte = pem.Decode(pemByte) + if block == nil { + break + } + cert, err := x509.ParseCertificate(block.Bytes) + if err != nil { + return nil, err + } + certPool.AddCert(cert) + } + } + + return certPool, nil +} + +// NewCert generates TLS cert by using the given cert,key and parse function. +func NewCert(certfile, keyfile string, parseFunc func([]byte, []byte) (tls.Certificate, error)) (*tls.Certificate, error) { + cert, err := ioutil.ReadFile(certfile) + if err != nil { + return nil, err + } + + key, err := ioutil.ReadFile(keyfile) + if err != nil { + return nil, err + } + + if parseFunc == nil { + parseFunc = tls.X509KeyPair + } + + tlsCert, err := parseFunc(cert, key) + if err != nil { + return nil, err + } + return &tlsCert, nil +} diff --git a/vendor/github.com/coreos/etcd/pkg/types/doc.go b/vendor/github.com/coreos/etcd/pkg/types/doc.go new file mode 100644 index 00000000..de8ef0bd --- /dev/null +++ b/vendor/github.com/coreos/etcd/pkg/types/doc.go @@ -0,0 +1,17 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package types declares various data types and implements type-checking +// functions. +package types diff --git a/vendor/github.com/coreos/etcd/pkg/types/id.go b/vendor/github.com/coreos/etcd/pkg/types/id.go new file mode 100644 index 00000000..1b042d9c --- /dev/null +++ b/vendor/github.com/coreos/etcd/pkg/types/id.go @@ -0,0 +1,41 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package types + +import ( + "strconv" +) + +// ID represents a generic identifier which is canonically +// stored as a uint64 but is typically represented as a +// base-16 string for input/output +type ID uint64 + +func (i ID) String() string { + return strconv.FormatUint(uint64(i), 16) +} + +// IDFromString attempts to create an ID from a base-16 string. +func IDFromString(s string) (ID, error) { + i, err := strconv.ParseUint(s, 16, 64) + return ID(i), err +} + +// IDSlice implements the sort interface +type IDSlice []ID + +func (p IDSlice) Len() int { return len(p) } +func (p IDSlice) Less(i, j int) bool { return uint64(p[i]) < uint64(p[j]) } +func (p IDSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } diff --git a/vendor/github.com/coreos/etcd/pkg/types/set.go b/vendor/github.com/coreos/etcd/pkg/types/set.go new file mode 100644 index 00000000..73ef431b --- /dev/null +++ b/vendor/github.com/coreos/etcd/pkg/types/set.go @@ -0,0 +1,178 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package types + +import ( + "reflect" + "sort" + "sync" +) + +type Set interface { + Add(string) + Remove(string) + Contains(string) bool + Equals(Set) bool + Length() int + Values() []string + Copy() Set + Sub(Set) Set +} + +func NewUnsafeSet(values ...string) *unsafeSet { + set := &unsafeSet{make(map[string]struct{})} + for _, v := range values { + set.Add(v) + } + return set +} + +func NewThreadsafeSet(values ...string) *tsafeSet { + us := NewUnsafeSet(values...) + return &tsafeSet{us, sync.RWMutex{}} +} + +type unsafeSet struct { + d map[string]struct{} +} + +// Add adds a new value to the set (no-op if the value is already present) +func (us *unsafeSet) Add(value string) { + us.d[value] = struct{}{} +} + +// Remove removes the given value from the set +func (us *unsafeSet) Remove(value string) { + delete(us.d, value) +} + +// Contains returns whether the set contains the given value +func (us *unsafeSet) Contains(value string) (exists bool) { + _, exists = us.d[value] + return +} + +// ContainsAll returns whether the set contains all given values +func (us *unsafeSet) ContainsAll(values []string) bool { + for _, s := range values { + if !us.Contains(s) { + return false + } + } + return true +} + +// Equals returns whether the contents of two sets are identical +func (us *unsafeSet) Equals(other Set) bool { + v1 := sort.StringSlice(us.Values()) + v2 := sort.StringSlice(other.Values()) + v1.Sort() + v2.Sort() + return reflect.DeepEqual(v1, v2) +} + +// Length returns the number of elements in the set +func (us *unsafeSet) Length() int { + return len(us.d) +} + +// Values returns the values of the Set in an unspecified order. +func (us *unsafeSet) Values() (values []string) { + values = make([]string, 0) + for val := range us.d { + values = append(values, val) + } + return +} + +// Copy creates a new Set containing the values of the first +func (us *unsafeSet) Copy() Set { + cp := NewUnsafeSet() + for val := range us.d { + cp.Add(val) + } + + return cp +} + +// Sub removes all elements in other from the set +func (us *unsafeSet) Sub(other Set) Set { + oValues := other.Values() + result := us.Copy().(*unsafeSet) + + for _, val := range oValues { + if _, ok := result.d[val]; !ok { + continue + } + delete(result.d, val) + } + + return result +} + +type tsafeSet struct { + us *unsafeSet + m sync.RWMutex +} + +func (ts *tsafeSet) Add(value string) { + ts.m.Lock() + defer ts.m.Unlock() + ts.us.Add(value) +} + +func (ts *tsafeSet) Remove(value string) { + ts.m.Lock() + defer ts.m.Unlock() + ts.us.Remove(value) +} + +func (ts *tsafeSet) Contains(value string) (exists bool) { + ts.m.RLock() + defer ts.m.RUnlock() + return ts.us.Contains(value) +} + +func (ts *tsafeSet) Equals(other Set) bool { + ts.m.RLock() + defer ts.m.RUnlock() + return ts.us.Equals(other) +} + +func (ts *tsafeSet) Length() int { + ts.m.RLock() + defer ts.m.RUnlock() + return ts.us.Length() +} + +func (ts *tsafeSet) Values() (values []string) { + ts.m.RLock() + defer ts.m.RUnlock() + return ts.us.Values() +} + +func (ts *tsafeSet) Copy() Set { + ts.m.RLock() + defer ts.m.RUnlock() + usResult := ts.us.Copy().(*unsafeSet) + return &tsafeSet{usResult, sync.RWMutex{}} +} + +func (ts *tsafeSet) Sub(other Set) Set { + ts.m.RLock() + defer ts.m.RUnlock() + usResult := ts.us.Sub(other).(*unsafeSet) + return &tsafeSet{usResult, sync.RWMutex{}} +} diff --git a/vendor/github.com/coreos/etcd/pkg/types/slice.go b/vendor/github.com/coreos/etcd/pkg/types/slice.go new file mode 100644 index 00000000..0dd9ca79 --- /dev/null +++ b/vendor/github.com/coreos/etcd/pkg/types/slice.go @@ -0,0 +1,22 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package types + +// Uint64Slice implements sort interface +type Uint64Slice []uint64 + +func (p Uint64Slice) Len() int { return len(p) } +func (p Uint64Slice) Less(i, j int) bool { return p[i] < p[j] } +func (p Uint64Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } diff --git a/vendor/github.com/coreos/etcd/pkg/types/urls.go b/vendor/github.com/coreos/etcd/pkg/types/urls.go new file mode 100644 index 00000000..9e5d03ff --- /dev/null +++ b/vendor/github.com/coreos/etcd/pkg/types/urls.go @@ -0,0 +1,82 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package types + +import ( + "errors" + "fmt" + "net" + "net/url" + "sort" + "strings" +) + +type URLs []url.URL + +func NewURLs(strs []string) (URLs, error) { + all := make([]url.URL, len(strs)) + if len(all) == 0 { + return nil, errors.New("no valid URLs given") + } + for i, in := range strs { + in = strings.TrimSpace(in) + u, err := url.Parse(in) + if err != nil { + return nil, err + } + if u.Scheme != "http" && u.Scheme != "https" && u.Scheme != "unix" && u.Scheme != "unixs" { + return nil, fmt.Errorf("URL scheme must be http, https, unix, or unixs: %s", in) + } + if _, _, err := net.SplitHostPort(u.Host); err != nil { + return nil, fmt.Errorf(`URL address does not have the form "host:port": %s`, in) + } + if u.Path != "" { + return nil, fmt.Errorf("URL must not contain a path: %s", in) + } + all[i] = *u + } + us := URLs(all) + us.Sort() + + return us, nil +} + +func MustNewURLs(strs []string) URLs { + urls, err := NewURLs(strs) + if err != nil { + panic(err) + } + return urls +} + +func (us URLs) String() string { + return strings.Join(us.StringSlice(), ",") +} + +func (us *URLs) Sort() { + sort.Sort(us) +} +func (us URLs) Len() int { return len(us) } +func (us URLs) Less(i, j int) bool { return us[i].String() < us[j].String() } +func (us URLs) Swap(i, j int) { us[i], us[j] = us[j], us[i] } + +func (us URLs) StringSlice() []string { + out := make([]string, len(us)) + for i := range us { + out[i] = us[i].String() + } + + return out +} diff --git a/vendor/github.com/coreos/etcd/pkg/types/urlsmap.go b/vendor/github.com/coreos/etcd/pkg/types/urlsmap.go new file mode 100644 index 00000000..47690cc3 --- /dev/null +++ b/vendor/github.com/coreos/etcd/pkg/types/urlsmap.go @@ -0,0 +1,107 @@ +// Copyright 2015 The etcd Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package types + +import ( + "fmt" + "sort" + "strings" +) + +// URLsMap is a map from a name to its URLs. +type URLsMap map[string]URLs + +// NewURLsMap returns a URLsMap instantiated from the given string, +// which consists of discovery-formatted names-to-URLs, like: +// mach0=http://1.1.1.1:2380,mach0=http://2.2.2.2::2380,mach1=http://3.3.3.3:2380,mach2=http://4.4.4.4:2380 +func NewURLsMap(s string) (URLsMap, error) { + m := parse(s) + + cl := URLsMap{} + for name, urls := range m { + us, err := NewURLs(urls) + if err != nil { + return nil, err + } + cl[name] = us + } + return cl, nil +} + +// NewURLsMapFromStringMap takes a map of strings and returns a URLsMap. The +// string values in the map can be multiple values separated by the sep string. +func NewURLsMapFromStringMap(m map[string]string, sep string) (URLsMap, error) { + var err error + um := URLsMap{} + for k, v := range m { + um[k], err = NewURLs(strings.Split(v, sep)) + if err != nil { + return nil, err + } + } + return um, nil +} + +// String turns URLsMap into discovery-formatted name-to-URLs sorted by name. +func (c URLsMap) String() string { + var pairs []string + for name, urls := range c { + for _, url := range urls { + pairs = append(pairs, fmt.Sprintf("%s=%s", name, url.String())) + } + } + sort.Strings(pairs) + return strings.Join(pairs, ",") +} + +// URLs returns a list of all URLs. +// The returned list is sorted in ascending lexicographical order. +func (c URLsMap) URLs() []string { + var urls []string + for _, us := range c { + for _, u := range us { + urls = append(urls, u.String()) + } + } + sort.Strings(urls) + return urls +} + +// Len returns the size of URLsMap. +func (c URLsMap) Len() int { + return len(c) +} + +// parse parses the given string and returns a map listing the values specified for each key. +func parse(s string) map[string][]string { + m := make(map[string][]string) + for s != "" { + key := s + if i := strings.IndexAny(key, ","); i >= 0 { + key, s = key[:i], key[i+1:] + } else { + s = "" + } + if key == "" { + continue + } + value := "" + if i := strings.Index(key, "="); i >= 0 { + key, value = key[:i], key[i+1:] + } + m[key] = append(m[key], value) + } + return m +} diff --git a/vendor/github.com/coreos/go-systemd/LICENSE b/vendor/github.com/coreos/go-systemd/LICENSE new file mode 100644 index 00000000..37ec93a1 --- /dev/null +++ b/vendor/github.com/coreos/go-systemd/LICENSE @@ -0,0 +1,191 @@ +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and +distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, "control" means (i) the power, direct or +indirect, to cause the direction or management of such entity, whether by +contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the +outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising +permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + +"Object" form shall mean any form resulting from mechanical transformation or +translation of a Source form, including but not limited to compiled object code, +generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made +available under the License, as indicated by a copyright notice that is included +in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that +is based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative Works +shall not include works that remain separable from, or merely link (or bind by +name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative Works +thereof, that is intentionally submitted to Licensor for inclusion in the Work +by the copyright owner or by an individual or Legal Entity authorized to submit +on behalf of the copyright owner. For the purposes of this definition, +"submitted" means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, and +issue tracking systems that are managed by, or on behalf of, the Licensor for +the purpose of discussing and improving the Work, but excluding communication +that is conspicuously marked or otherwise designated in writing by the copyright +owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf +of whom a Contribution has been received by Licensor and subsequently +incorporated within the Work. + +2. Grant of Copyright License. + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the Work and such +Derivative Works in Source or Object form. + +3. Grant of Patent License. + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable (except as stated in this section) patent license to make, have +made, use, offer to sell, sell, import, and otherwise transfer the Work, where +such license applies only to those patent claims licensable by such Contributor +that are necessarily infringed by their Contribution(s) alone or by combination +of their Contribution(s) with the Work to which such Contribution(s) was +submitted. If You institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work or a +Contribution incorporated within the Work constitutes direct or contributory +patent infringement, then any patent licenses granted to You under this License +for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. + +You may reproduce and distribute copies of the Work or Derivative Works thereof +in any medium, with or without modifications, and in Source or Object form, +provided that You meet the following conditions: + +You must give any other recipients of the Work or Derivative Works a copy of +this License; and +You must cause any modified files to carry prominent notices stating that You +changed the files; and +You must retain, in the Source form of any Derivative Works that You distribute, +all copyright, patent, trademark, and attribution notices from the Source form +of the Work, excluding those notices that do not pertain to any part of the +Derivative Works; and +If the Work includes a "NOTICE" text file as part of its distribution, then any +Derivative Works that You distribute must include a readable copy of the +attribution notices contained within such NOTICE file, excluding those notices +that do not pertain to any part of the Derivative Works, in at least one of the +following places: within a NOTICE text file distributed as part of the +Derivative Works; within the Source form or documentation, if provided along +with the Derivative Works; or, within a display generated by the Derivative +Works, if and wherever such third-party notices normally appear. The contents of +the NOTICE file are for informational purposes only and do not modify the +License. You may add Your own attribution notices within Derivative Works that +You distribute, alongside or as an addendum to the NOTICE text from the Work, +provided that such additional attribution notices cannot be construed as +modifying the License. +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, or +distribution of Your modifications, or for any such Derivative Works as a whole, +provided Your use, reproduction, and distribution of the Work otherwise complies +with the conditions stated in this License. + +5. Submission of Contributions. + +Unless You explicitly state otherwise, any Contribution intentionally submitted +for inclusion in the Work by You to the Licensor shall be under the terms and +conditions of this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify the terms of +any separate license agreement you may have executed with Licensor regarding +such Contributions. + +6. Trademarks. + +This License does not grant permission to use the trade names, trademarks, +service marks, or product names of the Licensor, except as required for +reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. + +Unless required by applicable law or agreed to in writing, Licensor provides the +Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, +including, without limitation, any warranties or conditions of TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are +solely responsible for determining the appropriateness of using or +redistributing the Work and assume any risks associated with Your exercise of +permissions under this License. + +8. Limitation of Liability. + +In no event and under no legal theory, whether in tort (including negligence), +contract, or otherwise, unless required by applicable law (such as deliberate +and grossly negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, incidental, +or consequential damages of any character arising as a result of this License or +out of the use or inability to use the Work (including but not limited to +damages for loss of goodwill, work stoppage, computer failure or malfunction, or +any and all other commercial damages or losses), even if such Contributor has +been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. + +While redistributing the Work or Derivative Works thereof, You may choose to +offer, and charge a fee for, acceptance of support, warranty, indemnity, or +other liability obligations and/or rights consistent with this License. However, +in accepting such obligations, You may act only on Your own behalf and on Your +sole responsibility, not on behalf of any other Contributor, and only if You +agree to indemnify, defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason of your +accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets "[]" replaced with your own +identifying information. (Don't include the brackets!) The text should be +enclosed in the appropriate comment syntax for the file format. We also +recommend that a file or class name and description of purpose be included on +the same "printed page" as the copyright notice for easier identification within +third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/coreos/go-systemd/journal/journal.go b/vendor/github.com/coreos/go-systemd/journal/journal.go new file mode 100644 index 00000000..7f434990 --- /dev/null +++ b/vendor/github.com/coreos/go-systemd/journal/journal.go @@ -0,0 +1,179 @@ +// Copyright 2015 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package journal provides write bindings to the local systemd journal. +// It is implemented in pure Go and connects to the journal directly over its +// unix socket. +// +// To read from the journal, see the "sdjournal" package, which wraps the +// sd-journal a C API. +// +// http://www.freedesktop.org/software/systemd/man/systemd-journald.service.html +package journal + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "io" + "io/ioutil" + "net" + "os" + "strconv" + "strings" + "syscall" +) + +// Priority of a journal message +type Priority int + +const ( + PriEmerg Priority = iota + PriAlert + PriCrit + PriErr + PriWarning + PriNotice + PriInfo + PriDebug +) + +var conn net.Conn + +func init() { + var err error + conn, err = net.Dial("unixgram", "/run/systemd/journal/socket") + if err != nil { + conn = nil + } +} + +// Enabled returns true if the local systemd journal is available for logging +func Enabled() bool { + return conn != nil +} + +// Send a message to the local systemd journal. vars is a map of journald +// fields to values. Fields must be composed of uppercase letters, numbers, +// and underscores, but must not start with an underscore. Within these +// restrictions, any arbitrary field name may be used. Some names have special +// significance: see the journalctl documentation +// (http://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html) +// for more details. vars may be nil. +func Send(message string, priority Priority, vars map[string]string) error { + if conn == nil { + return journalError("could not connect to journald socket") + } + + data := new(bytes.Buffer) + appendVariable(data, "PRIORITY", strconv.Itoa(int(priority))) + appendVariable(data, "MESSAGE", message) + for k, v := range vars { + appendVariable(data, k, v) + } + + _, err := io.Copy(conn, data) + if err != nil && isSocketSpaceError(err) { + file, err := tempFd() + if err != nil { + return journalError(err.Error()) + } + defer file.Close() + _, err = io.Copy(file, data) + if err != nil { + return journalError(err.Error()) + } + + rights := syscall.UnixRights(int(file.Fd())) + + /* this connection should always be a UnixConn, but better safe than sorry */ + unixConn, ok := conn.(*net.UnixConn) + if !ok { + return journalError("can't send file through non-Unix connection") + } + unixConn.WriteMsgUnix([]byte{}, rights, nil) + } else if err != nil { + return journalError(err.Error()) + } + return nil +} + +// Print prints a message to the local systemd journal using Send(). +func Print(priority Priority, format string, a ...interface{}) error { + return Send(fmt.Sprintf(format, a...), priority, nil) +} + +func appendVariable(w io.Writer, name, value string) { + if !validVarName(name) { + journalError("variable name contains invalid character, ignoring") + } + if strings.ContainsRune(value, '\n') { + /* When the value contains a newline, we write: + * - the variable name, followed by a newline + * - the size (in 64bit little endian format) + * - the data, followed by a newline + */ + fmt.Fprintln(w, name) + binary.Write(w, binary.LittleEndian, uint64(len(value))) + fmt.Fprintln(w, value) + } else { + /* just write the variable and value all on one line */ + fmt.Fprintf(w, "%s=%s\n", name, value) + } +} + +func validVarName(name string) bool { + /* The variable name must be in uppercase and consist only of characters, + * numbers and underscores, and may not begin with an underscore. (from the docs) + */ + + valid := name[0] != '_' + for _, c := range name { + valid = valid && ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || c == '_' + } + return valid +} + +func isSocketSpaceError(err error) bool { + opErr, ok := err.(*net.OpError) + if !ok { + return false + } + + sysErr, ok := opErr.Err.(syscall.Errno) + if !ok { + return false + } + + return sysErr == syscall.EMSGSIZE || sysErr == syscall.ENOBUFS +} + +func tempFd() (*os.File, error) { + file, err := ioutil.TempFile("/dev/shm/", "journal.XXXXX") + if err != nil { + return nil, err + } + syscall.Unlink(file.Name()) + if err != nil { + return nil, err + } + return file, nil +} + +func journalError(s string) error { + s = "journal error: " + s + fmt.Fprintln(os.Stderr, s) + return errors.New(s) +} diff --git a/vendor/github.com/coreos/pkg/LICENSE b/vendor/github.com/coreos/pkg/LICENSE new file mode 100644 index 00000000..e06d2081 --- /dev/null +++ b/vendor/github.com/coreos/pkg/LICENSE @@ -0,0 +1,202 @@ +Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/vendor/github.com/coreos/pkg/NOTICE b/vendor/github.com/coreos/pkg/NOTICE new file mode 100644 index 00000000..b39ddfa5 --- /dev/null +++ b/vendor/github.com/coreos/pkg/NOTICE @@ -0,0 +1,5 @@ +CoreOS Project +Copyright 2014 CoreOS, Inc + +This product includes software developed at CoreOS, Inc. +(http://www.coreos.com/). diff --git a/vendor/github.com/coreos/pkg/capnslog/formatters.go b/vendor/github.com/coreos/pkg/capnslog/formatters.go new file mode 100644 index 00000000..b305a845 --- /dev/null +++ b/vendor/github.com/coreos/pkg/capnslog/formatters.go @@ -0,0 +1,157 @@ +// Copyright 2015 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package capnslog + +import ( + "bufio" + "fmt" + "io" + "log" + "runtime" + "strings" + "time" +) + +type Formatter interface { + Format(pkg string, level LogLevel, depth int, entries ...interface{}) + Flush() +} + +func NewStringFormatter(w io.Writer) Formatter { + return &StringFormatter{ + w: bufio.NewWriter(w), + } +} + +type StringFormatter struct { + w *bufio.Writer +} + +func (s *StringFormatter) Format(pkg string, l LogLevel, i int, entries ...interface{}) { + now := time.Now().UTC() + s.w.WriteString(now.Format(time.RFC3339)) + s.w.WriteByte(' ') + writeEntries(s.w, pkg, l, i, entries...) + s.Flush() +} + +func writeEntries(w *bufio.Writer, pkg string, _ LogLevel, _ int, entries ...interface{}) { + if pkg != "" { + w.WriteString(pkg + ": ") + } + str := fmt.Sprint(entries...) + endsInNL := strings.HasSuffix(str, "\n") + w.WriteString(str) + if !endsInNL { + w.WriteString("\n") + } +} + +func (s *StringFormatter) Flush() { + s.w.Flush() +} + +func NewPrettyFormatter(w io.Writer, debug bool) Formatter { + return &PrettyFormatter{ + w: bufio.NewWriter(w), + debug: debug, + } +} + +type PrettyFormatter struct { + w *bufio.Writer + debug bool +} + +func (c *PrettyFormatter) Format(pkg string, l LogLevel, depth int, entries ...interface{}) { + now := time.Now() + ts := now.Format("2006-01-02 15:04:05") + c.w.WriteString(ts) + ms := now.Nanosecond() / 1000 + c.w.WriteString(fmt.Sprintf(".%06d", ms)) + if c.debug { + _, file, line, ok := runtime.Caller(depth) // It's always the same number of frames to the user's call. + if !ok { + file = "???" + line = 1 + } else { + slash := strings.LastIndex(file, "/") + if slash >= 0 { + file = file[slash+1:] + } + } + if line < 0 { + line = 0 // not a real line number + } + c.w.WriteString(fmt.Sprintf(" [%s:%d]", file, line)) + } + c.w.WriteString(fmt.Sprint(" ", l.Char(), " | ")) + writeEntries(c.w, pkg, l, depth, entries...) + c.Flush() +} + +func (c *PrettyFormatter) Flush() { + c.w.Flush() +} + +// LogFormatter emulates the form of the traditional built-in logger. +type LogFormatter struct { + logger *log.Logger + prefix string +} + +// NewLogFormatter is a helper to produce a new LogFormatter struct. It uses the +// golang log package to actually do the logging work so that logs look similar. +func NewLogFormatter(w io.Writer, prefix string, flag int) Formatter { + return &LogFormatter{ + logger: log.New(w, "", flag), // don't use prefix here + prefix: prefix, // save it instead + } +} + +// Format builds a log message for the LogFormatter. The LogLevel is ignored. +func (lf *LogFormatter) Format(pkg string, _ LogLevel, _ int, entries ...interface{}) { + str := fmt.Sprint(entries...) + prefix := lf.prefix + if pkg != "" { + prefix = fmt.Sprintf("%s%s: ", prefix, pkg) + } + lf.logger.Output(5, fmt.Sprintf("%s%v", prefix, str)) // call depth is 5 +} + +// Flush is included so that the interface is complete, but is a no-op. +func (lf *LogFormatter) Flush() { + // noop +} + +// NilFormatter is a no-op log formatter that does nothing. +type NilFormatter struct { +} + +// NewNilFormatter is a helper to produce a new LogFormatter struct. It logs no +// messages so that you can cause part of your logging to be silent. +func NewNilFormatter() Formatter { + return &NilFormatter{} +} + +// Format does nothing. +func (_ *NilFormatter) Format(_ string, _ LogLevel, _ int, _ ...interface{}) { + // noop +} + +// Flush is included so that the interface is complete, but is a no-op. +func (_ *NilFormatter) Flush() { + // noop +} diff --git a/vendor/github.com/coreos/pkg/capnslog/glog_formatter.go b/vendor/github.com/coreos/pkg/capnslog/glog_formatter.go new file mode 100644 index 00000000..426603ef --- /dev/null +++ b/vendor/github.com/coreos/pkg/capnslog/glog_formatter.go @@ -0,0 +1,96 @@ +// Copyright 2015 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package capnslog + +import ( + "bufio" + "bytes" + "io" + "os" + "runtime" + "strconv" + "strings" + "time" +) + +var pid = os.Getpid() + +type GlogFormatter struct { + StringFormatter +} + +func NewGlogFormatter(w io.Writer) *GlogFormatter { + g := &GlogFormatter{} + g.w = bufio.NewWriter(w) + return g +} + +func (g GlogFormatter) Format(pkg string, level LogLevel, depth int, entries ...interface{}) { + g.w.Write(GlogHeader(level, depth+1)) + g.StringFormatter.Format(pkg, level, depth+1, entries...) +} + +func GlogHeader(level LogLevel, depth int) []byte { + // Lmmdd hh:mm:ss.uuuuuu threadid file:line] + now := time.Now().UTC() + _, file, line, ok := runtime.Caller(depth) // It's always the same number of frames to the user's call. + if !ok { + file = "???" + line = 1 + } else { + slash := strings.LastIndex(file, "/") + if slash >= 0 { + file = file[slash+1:] + } + } + if line < 0 { + line = 0 // not a real line number + } + buf := &bytes.Buffer{} + buf.Grow(30) + _, month, day := now.Date() + hour, minute, second := now.Clock() + buf.WriteString(level.Char()) + twoDigits(buf, int(month)) + twoDigits(buf, day) + buf.WriteByte(' ') + twoDigits(buf, hour) + buf.WriteByte(':') + twoDigits(buf, minute) + buf.WriteByte(':') + twoDigits(buf, second) + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(now.Nanosecond() / 1000)) + buf.WriteByte('Z') + buf.WriteByte(' ') + buf.WriteString(strconv.Itoa(pid)) + buf.WriteByte(' ') + buf.WriteString(file) + buf.WriteByte(':') + buf.WriteString(strconv.Itoa(line)) + buf.WriteByte(']') + buf.WriteByte(' ') + return buf.Bytes() +} + +const digits = "0123456789" + +func twoDigits(b *bytes.Buffer, d int) { + c2 := digits[d%10] + d /= 10 + c1 := digits[d%10] + b.WriteByte(c1) + b.WriteByte(c2) +} diff --git a/vendor/github.com/coreos/pkg/capnslog/init.go b/vendor/github.com/coreos/pkg/capnslog/init.go new file mode 100644 index 00000000..44b8cd36 --- /dev/null +++ b/vendor/github.com/coreos/pkg/capnslog/init.go @@ -0,0 +1,49 @@ +// Copyright 2015 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// +build !windows + +package capnslog + +import ( + "io" + "os" + "syscall" +) + +// Here's where the opinionation comes in. We need some sensible defaults, +// especially after taking over the log package. Your project (whatever it may +// be) may see things differently. That's okay; there should be no defaults in +// the main package that cannot be controlled or overridden programatically, +// otherwise it's a bug. Doing so is creating your own init_log.go file much +// like this one. + +func init() { + initHijack() + + // Go `log` pacakge uses os.Stderr. + SetFormatter(NewDefaultFormatter(os.Stderr)) + SetGlobalLogLevel(INFO) +} + +func NewDefaultFormatter(out io.Writer) Formatter { + if syscall.Getppid() == 1 { + // We're running under init, which may be systemd. + f, err := NewJournaldFormatter() + if err == nil { + return f + } + } + return NewPrettyFormatter(out, false) +} diff --git a/vendor/github.com/coreos/pkg/capnslog/init_windows.go b/vendor/github.com/coreos/pkg/capnslog/init_windows.go new file mode 100644 index 00000000..45530506 --- /dev/null +++ b/vendor/github.com/coreos/pkg/capnslog/init_windows.go @@ -0,0 +1,25 @@ +// Copyright 2015 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package capnslog + +import "os" + +func init() { + initHijack() + + // Go `log` package uses os.Stderr. + SetFormatter(NewPrettyFormatter(os.Stderr, false)) + SetGlobalLogLevel(INFO) +} diff --git a/vendor/github.com/coreos/pkg/capnslog/journald_formatter.go b/vendor/github.com/coreos/pkg/capnslog/journald_formatter.go new file mode 100644 index 00000000..72e05207 --- /dev/null +++ b/vendor/github.com/coreos/pkg/capnslog/journald_formatter.go @@ -0,0 +1,68 @@ +// Copyright 2015 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// +build !windows + +package capnslog + +import ( + "errors" + "fmt" + "os" + "path/filepath" + + "github.com/coreos/go-systemd/journal" +) + +func NewJournaldFormatter() (Formatter, error) { + if !journal.Enabled() { + return nil, errors.New("No systemd detected") + } + return &journaldFormatter{}, nil +} + +type journaldFormatter struct{} + +func (j *journaldFormatter) Format(pkg string, l LogLevel, _ int, entries ...interface{}) { + var pri journal.Priority + switch l { + case CRITICAL: + pri = journal.PriCrit + case ERROR: + pri = journal.PriErr + case WARNING: + pri = journal.PriWarning + case NOTICE: + pri = journal.PriNotice + case INFO: + pri = journal.PriInfo + case DEBUG: + pri = journal.PriDebug + case TRACE: + pri = journal.PriDebug + default: + panic("Unhandled loglevel") + } + msg := fmt.Sprint(entries...) + tags := map[string]string{ + "PACKAGE": pkg, + "SYSLOG_IDENTIFIER": filepath.Base(os.Args[0]), + } + err := journal.Send(msg, pri, tags) + if err != nil { + fmt.Fprintln(os.Stderr, err) + } +} + +func (j *journaldFormatter) Flush() {} diff --git a/vendor/github.com/coreos/pkg/capnslog/log_hijack.go b/vendor/github.com/coreos/pkg/capnslog/log_hijack.go new file mode 100644 index 00000000..970086b9 --- /dev/null +++ b/vendor/github.com/coreos/pkg/capnslog/log_hijack.go @@ -0,0 +1,39 @@ +// Copyright 2015 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package capnslog + +import ( + "log" +) + +func initHijack() { + pkg := NewPackageLogger("log", "") + w := packageWriter{pkg} + log.SetFlags(0) + log.SetPrefix("") + log.SetOutput(w) +} + +type packageWriter struct { + pl *PackageLogger +} + +func (p packageWriter) Write(b []byte) (int, error) { + if p.pl.level < INFO { + return 0, nil + } + p.pl.internalLog(calldepth+2, INFO, string(b)) + return len(b), nil +} diff --git a/vendor/github.com/coreos/pkg/capnslog/logmap.go b/vendor/github.com/coreos/pkg/capnslog/logmap.go new file mode 100644 index 00000000..84954488 --- /dev/null +++ b/vendor/github.com/coreos/pkg/capnslog/logmap.go @@ -0,0 +1,240 @@ +// Copyright 2015 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package capnslog + +import ( + "errors" + "strings" + "sync" +) + +// LogLevel is the set of all log levels. +type LogLevel int8 + +const ( + // CRITICAL is the lowest log level; only errors which will end the program will be propagated. + CRITICAL LogLevel = iota - 1 + // ERROR is for errors that are not fatal but lead to troubling behavior. + ERROR + // WARNING is for errors which are not fatal and not errors, but are unusual. Often sourced from misconfigurations. + WARNING + // NOTICE is for normal but significant conditions. + NOTICE + // INFO is a log level for common, everyday log updates. + INFO + // DEBUG is the default hidden level for more verbose updates about internal processes. + DEBUG + // TRACE is for (potentially) call by call tracing of programs. + TRACE +) + +// Char returns a single-character representation of the log level. +func (l LogLevel) Char() string { + switch l { + case CRITICAL: + return "C" + case ERROR: + return "E" + case WARNING: + return "W" + case NOTICE: + return "N" + case INFO: + return "I" + case DEBUG: + return "D" + case TRACE: + return "T" + default: + panic("Unhandled loglevel") + } +} + +// String returns a multi-character representation of the log level. +func (l LogLevel) String() string { + switch l { + case CRITICAL: + return "CRITICAL" + case ERROR: + return "ERROR" + case WARNING: + return "WARNING" + case NOTICE: + return "NOTICE" + case INFO: + return "INFO" + case DEBUG: + return "DEBUG" + case TRACE: + return "TRACE" + default: + panic("Unhandled loglevel") + } +} + +// Update using the given string value. Fulfills the flag.Value interface. +func (l *LogLevel) Set(s string) error { + value, err := ParseLevel(s) + if err != nil { + return err + } + + *l = value + return nil +} + +// ParseLevel translates some potential loglevel strings into their corresponding levels. +func ParseLevel(s string) (LogLevel, error) { + switch s { + case "CRITICAL", "C": + return CRITICAL, nil + case "ERROR", "0", "E": + return ERROR, nil + case "WARNING", "1", "W": + return WARNING, nil + case "NOTICE", "2", "N": + return NOTICE, nil + case "INFO", "3", "I": + return INFO, nil + case "DEBUG", "4", "D": + return DEBUG, nil + case "TRACE", "5", "T": + return TRACE, nil + } + return CRITICAL, errors.New("couldn't parse log level " + s) +} + +type RepoLogger map[string]*PackageLogger + +type loggerStruct struct { + sync.Mutex + repoMap map[string]RepoLogger + formatter Formatter +} + +// logger is the global logger +var logger = new(loggerStruct) + +// SetGlobalLogLevel sets the log level for all packages in all repositories +// registered with capnslog. +func SetGlobalLogLevel(l LogLevel) { + logger.Lock() + defer logger.Unlock() + for _, r := range logger.repoMap { + r.setRepoLogLevelInternal(l) + } +} + +// GetRepoLogger may return the handle to the repository's set of packages' loggers. +func GetRepoLogger(repo string) (RepoLogger, error) { + logger.Lock() + defer logger.Unlock() + r, ok := logger.repoMap[repo] + if !ok { + return nil, errors.New("no packages registered for repo " + repo) + } + return r, nil +} + +// MustRepoLogger returns the handle to the repository's packages' loggers. +func MustRepoLogger(repo string) RepoLogger { + r, err := GetRepoLogger(repo) + if err != nil { + panic(err) + } + return r +} + +// SetRepoLogLevel sets the log level for all packages in the repository. +func (r RepoLogger) SetRepoLogLevel(l LogLevel) { + logger.Lock() + defer logger.Unlock() + r.setRepoLogLevelInternal(l) +} + +func (r RepoLogger) setRepoLogLevelInternal(l LogLevel) { + for _, v := range r { + v.level = l + } +} + +// ParseLogLevelConfig parses a comma-separated string of "package=loglevel", in +// order, and returns a map of the results, for use in SetLogLevel. +func (r RepoLogger) ParseLogLevelConfig(conf string) (map[string]LogLevel, error) { + setlist := strings.Split(conf, ",") + out := make(map[string]LogLevel) + for _, setstring := range setlist { + setting := strings.Split(setstring, "=") + if len(setting) != 2 { + return nil, errors.New("oddly structured `pkg=level` option: " + setstring) + } + l, err := ParseLevel(setting[1]) + if err != nil { + return nil, err + } + out[setting[0]] = l + } + return out, nil +} + +// SetLogLevel takes a map of package names within a repository to their desired +// loglevel, and sets the levels appropriately. Unknown packages are ignored. +// "*" is a special package name that corresponds to all packages, and will be +// processed first. +func (r RepoLogger) SetLogLevel(m map[string]LogLevel) { + logger.Lock() + defer logger.Unlock() + if l, ok := m["*"]; ok { + r.setRepoLogLevelInternal(l) + } + for k, v := range m { + l, ok := r[k] + if !ok { + continue + } + l.level = v + } +} + +// SetFormatter sets the formatting function for all logs. +func SetFormatter(f Formatter) { + logger.Lock() + defer logger.Unlock() + logger.formatter = f +} + +// NewPackageLogger creates a package logger object. +// This should be defined as a global var in your package, referencing your repo. +func NewPackageLogger(repo string, pkg string) (p *PackageLogger) { + logger.Lock() + defer logger.Unlock() + if logger.repoMap == nil { + logger.repoMap = make(map[string]RepoLogger) + } + r, rok := logger.repoMap[repo] + if !rok { + logger.repoMap[repo] = make(RepoLogger) + r = logger.repoMap[repo] + } + p, pok := r[pkg] + if !pok { + r[pkg] = &PackageLogger{ + pkg: pkg, + level: INFO, + } + p = r[pkg] + } + return +} diff --git a/vendor/github.com/coreos/pkg/capnslog/pkg_logger.go b/vendor/github.com/coreos/pkg/capnslog/pkg_logger.go new file mode 100644 index 00000000..612d55c6 --- /dev/null +++ b/vendor/github.com/coreos/pkg/capnslog/pkg_logger.go @@ -0,0 +1,177 @@ +// Copyright 2015 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package capnslog + +import ( + "fmt" + "os" +) + +type PackageLogger struct { + pkg string + level LogLevel +} + +const calldepth = 2 + +func (p *PackageLogger) internalLog(depth int, inLevel LogLevel, entries ...interface{}) { + logger.Lock() + defer logger.Unlock() + if inLevel != CRITICAL && p.level < inLevel { + return + } + if logger.formatter != nil { + logger.formatter.Format(p.pkg, inLevel, depth+1, entries...) + } +} + +func (p *PackageLogger) LevelAt(l LogLevel) bool { + logger.Lock() + defer logger.Unlock() + return p.level >= l +} + +// Log a formatted string at any level between ERROR and TRACE +func (p *PackageLogger) Logf(l LogLevel, format string, args ...interface{}) { + p.internalLog(calldepth, l, fmt.Sprintf(format, args...)) +} + +// Log a message at any level between ERROR and TRACE +func (p *PackageLogger) Log(l LogLevel, args ...interface{}) { + p.internalLog(calldepth, l, fmt.Sprint(args...)) +} + +// log stdlib compatibility + +func (p *PackageLogger) Println(args ...interface{}) { + p.internalLog(calldepth, INFO, fmt.Sprintln(args...)) +} + +func (p *PackageLogger) Printf(format string, args ...interface{}) { + p.Logf(INFO, format, args...) +} + +func (p *PackageLogger) Print(args ...interface{}) { + p.internalLog(calldepth, INFO, fmt.Sprint(args...)) +} + +// Panic and fatal + +func (p *PackageLogger) Panicf(format string, args ...interface{}) { + s := fmt.Sprintf(format, args...) + p.internalLog(calldepth, CRITICAL, s) + panic(s) +} + +func (p *PackageLogger) Panic(args ...interface{}) { + s := fmt.Sprint(args...) + p.internalLog(calldepth, CRITICAL, s) + panic(s) +} + +func (p *PackageLogger) Fatalf(format string, args ...interface{}) { + p.Logf(CRITICAL, format, args...) + os.Exit(1) +} + +func (p *PackageLogger) Fatal(args ...interface{}) { + s := fmt.Sprint(args...) + p.internalLog(calldepth, CRITICAL, s) + os.Exit(1) +} + +func (p *PackageLogger) Fatalln(args ...interface{}) { + s := fmt.Sprintln(args...) + p.internalLog(calldepth, CRITICAL, s) + os.Exit(1) +} + +// Error Functions + +func (p *PackageLogger) Errorf(format string, args ...interface{}) { + p.Logf(ERROR, format, args...) +} + +func (p *PackageLogger) Error(entries ...interface{}) { + p.internalLog(calldepth, ERROR, entries...) +} + +// Warning Functions + +func (p *PackageLogger) Warningf(format string, args ...interface{}) { + p.Logf(WARNING, format, args...) +} + +func (p *PackageLogger) Warning(entries ...interface{}) { + p.internalLog(calldepth, WARNING, entries...) +} + +// Notice Functions + +func (p *PackageLogger) Noticef(format string, args ...interface{}) { + p.Logf(NOTICE, format, args...) +} + +func (p *PackageLogger) Notice(entries ...interface{}) { + p.internalLog(calldepth, NOTICE, entries...) +} + +// Info Functions + +func (p *PackageLogger) Infof(format string, args ...interface{}) { + p.Logf(INFO, format, args...) +} + +func (p *PackageLogger) Info(entries ...interface{}) { + p.internalLog(calldepth, INFO, entries...) +} + +// Debug Functions + +func (p *PackageLogger) Debugf(format string, args ...interface{}) { + if p.level < DEBUG { + return + } + p.Logf(DEBUG, format, args...) +} + +func (p *PackageLogger) Debug(entries ...interface{}) { + if p.level < DEBUG { + return + } + p.internalLog(calldepth, DEBUG, entries...) +} + +// Trace Functions + +func (p *PackageLogger) Tracef(format string, args ...interface{}) { + if p.level < TRACE { + return + } + p.Logf(TRACE, format, args...) +} + +func (p *PackageLogger) Trace(entries ...interface{}) { + if p.level < TRACE { + return + } + p.internalLog(calldepth, TRACE, entries...) +} + +func (p *PackageLogger) Flush() { + logger.Lock() + defer logger.Unlock() + logger.formatter.Flush() +} diff --git a/vendor/github.com/coreos/pkg/capnslog/syslog_formatter.go b/vendor/github.com/coreos/pkg/capnslog/syslog_formatter.go new file mode 100644 index 00000000..4be5a1f2 --- /dev/null +++ b/vendor/github.com/coreos/pkg/capnslog/syslog_formatter.go @@ -0,0 +1,65 @@ +// Copyright 2015 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// +build !windows + +package capnslog + +import ( + "fmt" + "log/syslog" +) + +func NewSyslogFormatter(w *syslog.Writer) Formatter { + return &syslogFormatter{w} +} + +func NewDefaultSyslogFormatter(tag string) (Formatter, error) { + w, err := syslog.New(syslog.LOG_DEBUG, tag) + if err != nil { + return nil, err + } + return NewSyslogFormatter(w), nil +} + +type syslogFormatter struct { + w *syslog.Writer +} + +func (s *syslogFormatter) Format(pkg string, l LogLevel, _ int, entries ...interface{}) { + for _, entry := range entries { + str := fmt.Sprint(entry) + switch l { + case CRITICAL: + s.w.Crit(str) + case ERROR: + s.w.Err(str) + case WARNING: + s.w.Warning(str) + case NOTICE: + s.w.Notice(str) + case INFO: + s.w.Info(str) + case DEBUG: + s.w.Debug(str) + case TRACE: + s.w.Debug(str) + default: + panic("Unhandled loglevel") + } + } +} + +func (s *syslogFormatter) Flush() { +} diff --git a/vendor/github.com/dustin/go-humanize/LICENSE b/vendor/github.com/dustin/go-humanize/LICENSE new file mode 100644 index 00000000..8d9a94a9 --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/LICENSE @@ -0,0 +1,21 @@ +Copyright (c) 2005-2008 Dustin Sallings + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + diff --git a/vendor/github.com/dustin/go-humanize/big.go b/vendor/github.com/dustin/go-humanize/big.go new file mode 100644 index 00000000..f49dc337 --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/big.go @@ -0,0 +1,31 @@ +package humanize + +import ( + "math/big" +) + +// order of magnitude (to a max order) +func oomm(n, b *big.Int, maxmag int) (float64, int) { + mag := 0 + m := &big.Int{} + for n.Cmp(b) >= 0 { + n.DivMod(n, b, m) + mag++ + if mag == maxmag && maxmag >= 0 { + break + } + } + return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag +} + +// total order of magnitude +// (same as above, but with no upper limit) +func oom(n, b *big.Int) (float64, int) { + mag := 0 + m := &big.Int{} + for n.Cmp(b) >= 0 { + n.DivMod(n, b, m) + mag++ + } + return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag +} diff --git a/vendor/github.com/dustin/go-humanize/bigbytes.go b/vendor/github.com/dustin/go-humanize/bigbytes.go new file mode 100644 index 00000000..67ea5c82 --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/bigbytes.go @@ -0,0 +1,164 @@ +package humanize + +import ( + "fmt" + "math/big" + "strings" + "unicode" +) + +var ( + bigIECExp = big.NewInt(1024) + + // BigByte is one byte in bit.Ints + BigByte = big.NewInt(1) + // BigKiByte is 1,024 bytes in bit.Ints + BigKiByte = (&big.Int{}).Mul(BigByte, bigIECExp) + // BigMiByte is 1,024 k bytes in bit.Ints + BigMiByte = (&big.Int{}).Mul(BigKiByte, bigIECExp) + // BigGiByte is 1,024 m bytes in bit.Ints + BigGiByte = (&big.Int{}).Mul(BigMiByte, bigIECExp) + // BigTiByte is 1,024 g bytes in bit.Ints + BigTiByte = (&big.Int{}).Mul(BigGiByte, bigIECExp) + // BigPiByte is 1,024 t bytes in bit.Ints + BigPiByte = (&big.Int{}).Mul(BigTiByte, bigIECExp) + // BigEiByte is 1,024 p bytes in bit.Ints + BigEiByte = (&big.Int{}).Mul(BigPiByte, bigIECExp) + // BigZiByte is 1,024 e bytes in bit.Ints + BigZiByte = (&big.Int{}).Mul(BigEiByte, bigIECExp) + // BigYiByte is 1,024 z bytes in bit.Ints + BigYiByte = (&big.Int{}).Mul(BigZiByte, bigIECExp) +) + +var ( + bigSIExp = big.NewInt(1000) + + // BigSIByte is one SI byte in big.Ints + BigSIByte = big.NewInt(1) + // BigKByte is 1,000 SI bytes in big.Ints + BigKByte = (&big.Int{}).Mul(BigSIByte, bigSIExp) + // BigMByte is 1,000 SI k bytes in big.Ints + BigMByte = (&big.Int{}).Mul(BigKByte, bigSIExp) + // BigGByte is 1,000 SI m bytes in big.Ints + BigGByte = (&big.Int{}).Mul(BigMByte, bigSIExp) + // BigTByte is 1,000 SI g bytes in big.Ints + BigTByte = (&big.Int{}).Mul(BigGByte, bigSIExp) + // BigPByte is 1,000 SI t bytes in big.Ints + BigPByte = (&big.Int{}).Mul(BigTByte, bigSIExp) + // BigEByte is 1,000 SI p bytes in big.Ints + BigEByte = (&big.Int{}).Mul(BigPByte, bigSIExp) + // BigZByte is 1,000 SI e bytes in big.Ints + BigZByte = (&big.Int{}).Mul(BigEByte, bigSIExp) + // BigYByte is 1,000 SI z bytes in big.Ints + BigYByte = (&big.Int{}).Mul(BigZByte, bigSIExp) +) + +var bigBytesSizeTable = map[string]*big.Int{ + "b": BigByte, + "kib": BigKiByte, + "kb": BigKByte, + "mib": BigMiByte, + "mb": BigMByte, + "gib": BigGiByte, + "gb": BigGByte, + "tib": BigTiByte, + "tb": BigTByte, + "pib": BigPiByte, + "pb": BigPByte, + "eib": BigEiByte, + "eb": BigEByte, + "zib": BigZiByte, + "zb": BigZByte, + "yib": BigYiByte, + "yb": BigYByte, + // Without suffix + "": BigByte, + "ki": BigKiByte, + "k": BigKByte, + "mi": BigMiByte, + "m": BigMByte, + "gi": BigGiByte, + "g": BigGByte, + "ti": BigTiByte, + "t": BigTByte, + "pi": BigPiByte, + "p": BigPByte, + "ei": BigEiByte, + "e": BigEByte, + "z": BigZByte, + "zi": BigZiByte, + "y": BigYByte, + "yi": BigYiByte, +} + +var ten = big.NewInt(10) + +func humanateBigBytes(s, base *big.Int, sizes []string) string { + if s.Cmp(ten) < 0 { + return fmt.Sprintf("%d B", s) + } + c := (&big.Int{}).Set(s) + val, mag := oomm(c, base, len(sizes)-1) + suffix := sizes[mag] + f := "%.0f %s" + if val < 10 { + f = "%.1f %s" + } + + return fmt.Sprintf(f, val, suffix) + +} + +// BigBytes produces a human readable representation of an SI size. +// +// See also: ParseBigBytes. +// +// BigBytes(82854982) -> 83MB +func BigBytes(s *big.Int) string { + sizes := []string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"} + return humanateBigBytes(s, bigSIExp, sizes) +} + +// BigIBytes produces a human readable representation of an IEC size. +// +// See also: ParseBigBytes. +// +// BigIBytes(82854982) -> 79MiB +func BigIBytes(s *big.Int) string { + sizes := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"} + return humanateBigBytes(s, bigIECExp, sizes) +} + +// ParseBigBytes parses a string representation of bytes into the number +// of bytes it represents. +// +// See also: BigBytes, BigIBytes. +// +// ParseBigBytes("42MB") -> 42000000, nil +// ParseBigBytes("42mib") -> 44040192, nil +func ParseBigBytes(s string) (*big.Int, error) { + lastDigit := 0 + for _, r := range s { + if !(unicode.IsDigit(r) || r == '.') { + break + } + lastDigit++ + } + + val := &big.Rat{} + _, err := fmt.Sscanf(s[:lastDigit], "%f", val) + if err != nil { + return nil, err + } + + extra := strings.ToLower(strings.TrimSpace(s[lastDigit:])) + if m, ok := bigBytesSizeTable[extra]; ok { + mv := (&big.Rat{}).SetInt(m) + val.Mul(val, mv) + rv := &big.Int{} + rv.Div(val.Num(), val.Denom()) + return rv, nil + } + + return nil, fmt.Errorf("unhandled size name: %v", extra) +} diff --git a/vendor/github.com/dustin/go-humanize/bytes.go b/vendor/github.com/dustin/go-humanize/bytes.go new file mode 100644 index 00000000..dacbb9c1 --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/bytes.go @@ -0,0 +1,134 @@ +package humanize + +import ( + "fmt" + "math" + "strconv" + "strings" + "unicode" +) + +// IEC Sizes. +// kibis of bits +const ( + Byte = 1 << (iota * 10) + KiByte + MiByte + GiByte + TiByte + PiByte + EiByte +) + +// SI Sizes. +const ( + IByte = 1 + KByte = IByte * 1000 + MByte = KByte * 1000 + GByte = MByte * 1000 + TByte = GByte * 1000 + PByte = TByte * 1000 + EByte = PByte * 1000 +) + +var bytesSizeTable = map[string]uint64{ + "b": Byte, + "kib": KiByte, + "kb": KByte, + "mib": MiByte, + "mb": MByte, + "gib": GiByte, + "gb": GByte, + "tib": TiByte, + "tb": TByte, + "pib": PiByte, + "pb": PByte, + "eib": EiByte, + "eb": EByte, + // Without suffix + "": Byte, + "ki": KiByte, + "k": KByte, + "mi": MiByte, + "m": MByte, + "gi": GiByte, + "g": GByte, + "ti": TiByte, + "t": TByte, + "pi": PiByte, + "p": PByte, + "ei": EiByte, + "e": EByte, +} + +func logn(n, b float64) float64 { + return math.Log(n) / math.Log(b) +} + +func humanateBytes(s uint64, base float64, sizes []string) string { + if s < 10 { + return fmt.Sprintf("%d B", s) + } + e := math.Floor(logn(float64(s), base)) + suffix := sizes[int(e)] + val := math.Floor(float64(s)/math.Pow(base, e)*10+0.5) / 10 + f := "%.0f %s" + if val < 10 { + f = "%.1f %s" + } + + return fmt.Sprintf(f, val, suffix) +} + +// Bytes produces a human readable representation of an SI size. +// +// See also: ParseBytes. +// +// Bytes(82854982) -> 83MB +func Bytes(s uint64) string { + sizes := []string{"B", "kB", "MB", "GB", "TB", "PB", "EB"} + return humanateBytes(s, 1000, sizes) +} + +// IBytes produces a human readable representation of an IEC size. +// +// See also: ParseBytes. +// +// IBytes(82854982) -> 79MiB +func IBytes(s uint64) string { + sizes := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"} + return humanateBytes(s, 1024, sizes) +} + +// ParseBytes parses a string representation of bytes into the number +// of bytes it represents. +// +// See Also: Bytes, IBytes. +// +// ParseBytes("42MB") -> 42000000, nil +// ParseBytes("42mib") -> 44040192, nil +func ParseBytes(s string) (uint64, error) { + lastDigit := 0 + for _, r := range s { + if !(unicode.IsDigit(r) || r == '.') { + break + } + lastDigit++ + } + + f, err := strconv.ParseFloat(s[:lastDigit], 64) + if err != nil { + return 0, err + } + + extra := strings.ToLower(strings.TrimSpace(s[lastDigit:])) + if m, ok := bytesSizeTable[extra]; ok { + f *= float64(m) + if f >= math.MaxUint64 { + return 0, fmt.Errorf("too large: %v", s) + } + return uint64(f), nil + } + + return 0, fmt.Errorf("unhandled size name: %v", extra) +} diff --git a/vendor/github.com/dustin/go-humanize/comma.go b/vendor/github.com/dustin/go-humanize/comma.go new file mode 100644 index 00000000..74f446b6 --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/comma.go @@ -0,0 +1,101 @@ +package humanize + +import ( + "bytes" + "math/big" + "strconv" + "strings" +) + +// Comma produces a string form of the given number in base 10 with +// commas after every three orders of magnitude. +// +// e.g. Comma(834142) -> 834,142 +func Comma(v int64) string { + sign := "" + if v < 0 { + sign = "-" + v = 0 - v + } + + parts := []string{"", "", "", "", "", "", ""} + j := len(parts) - 1 + + for v > 999 { + parts[j] = strconv.FormatInt(v%1000, 10) + switch len(parts[j]) { + case 2: + parts[j] = "0" + parts[j] + case 1: + parts[j] = "00" + parts[j] + } + v = v / 1000 + j-- + } + parts[j] = strconv.Itoa(int(v)) + return sign + strings.Join(parts[j:], ",") +} + +// Commaf produces a string form of the given number in base 10 with +// commas after every three orders of magnitude. +// +// e.g. Commaf(834142.32) -> 834,142.32 +func Commaf(v float64) string { + buf := &bytes.Buffer{} + if v < 0 { + buf.Write([]byte{'-'}) + v = 0 - v + } + + comma := []byte{','} + + parts := strings.Split(strconv.FormatFloat(v, 'f', -1, 64), ".") + pos := 0 + if len(parts[0])%3 != 0 { + pos += len(parts[0]) % 3 + buf.WriteString(parts[0][:pos]) + buf.Write(comma) + } + for ; pos < len(parts[0]); pos += 3 { + buf.WriteString(parts[0][pos : pos+3]) + buf.Write(comma) + } + buf.Truncate(buf.Len() - 1) + + if len(parts) > 1 { + buf.Write([]byte{'.'}) + buf.WriteString(parts[1]) + } + return buf.String() +} + +// BigComma produces a string form of the given big.Int in base 10 +// with commas after every three orders of magnitude. +func BigComma(b *big.Int) string { + sign := "" + if b.Sign() < 0 { + sign = "-" + b.Abs(b) + } + + athousand := big.NewInt(1000) + c := (&big.Int{}).Set(b) + _, m := oom(c, athousand) + parts := make([]string, m+1) + j := len(parts) - 1 + + mod := &big.Int{} + for b.Cmp(athousand) >= 0 { + b.DivMod(b, athousand, mod) + parts[j] = strconv.FormatInt(mod.Int64(), 10) + switch len(parts[j]) { + case 2: + parts[j] = "0" + parts[j] + case 1: + parts[j] = "00" + parts[j] + } + j-- + } + parts[j] = strconv.Itoa(int(b.Int64())) + return sign + strings.Join(parts[j:], ",") +} diff --git a/vendor/github.com/dustin/go-humanize/commaf.go b/vendor/github.com/dustin/go-humanize/commaf.go new file mode 100644 index 00000000..620690de --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/commaf.go @@ -0,0 +1,40 @@ +// +build go1.6 + +package humanize + +import ( + "bytes" + "math/big" + "strings" +) + +// BigCommaf produces a string form of the given big.Float in base 10 +// with commas after every three orders of magnitude. +func BigCommaf(v *big.Float) string { + buf := &bytes.Buffer{} + if v.Sign() < 0 { + buf.Write([]byte{'-'}) + v.Abs(v) + } + + comma := []byte{','} + + parts := strings.Split(v.Text('f', -1), ".") + pos := 0 + if len(parts[0])%3 != 0 { + pos += len(parts[0]) % 3 + buf.WriteString(parts[0][:pos]) + buf.Write(comma) + } + for ; pos < len(parts[0]); pos += 3 { + buf.WriteString(parts[0][pos : pos+3]) + buf.Write(comma) + } + buf.Truncate(buf.Len() - 1) + + if len(parts) > 1 { + buf.Write([]byte{'.'}) + buf.WriteString(parts[1]) + } + return buf.String() +} diff --git a/vendor/github.com/dustin/go-humanize/ftoa.go b/vendor/github.com/dustin/go-humanize/ftoa.go new file mode 100644 index 00000000..c76190b1 --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/ftoa.go @@ -0,0 +1,23 @@ +package humanize + +import "strconv" + +func stripTrailingZeros(s string) string { + offset := len(s) - 1 + for offset > 0 { + if s[offset] == '.' { + offset-- + break + } + if s[offset] != '0' { + break + } + offset-- + } + return s[:offset+1] +} + +// Ftoa converts a float to a string with no trailing zeros. +func Ftoa(num float64) string { + return stripTrailingZeros(strconv.FormatFloat(num, 'f', 6, 64)) +} diff --git a/vendor/github.com/dustin/go-humanize/humanize.go b/vendor/github.com/dustin/go-humanize/humanize.go new file mode 100644 index 00000000..a69540a0 --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/humanize.go @@ -0,0 +1,8 @@ +/* +Package humanize converts boring ugly numbers to human-friendly strings and back. + +Durations can be turned into strings such as "3 days ago", numbers +representing sizes like 82854982 into useful strings like, "83MB" or +"79MiB" (whichever you prefer). +*/ +package humanize diff --git a/vendor/github.com/dustin/go-humanize/number.go b/vendor/github.com/dustin/go-humanize/number.go new file mode 100644 index 00000000..32141348 --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/number.go @@ -0,0 +1,192 @@ +package humanize + +/* +Slightly adapted from the source to fit go-humanize. + +Author: https://github.com/gorhill +Source: https://gist.github.com/gorhill/5285193 + +*/ + +import ( + "math" + "strconv" +) + +var ( + renderFloatPrecisionMultipliers = [...]float64{ + 1, + 10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000, + } + + renderFloatPrecisionRounders = [...]float64{ + 0.5, + 0.05, + 0.005, + 0.0005, + 0.00005, + 0.000005, + 0.0000005, + 0.00000005, + 0.000000005, + 0.0000000005, + } +) + +// FormatFloat produces a formatted number as string based on the following user-specified criteria: +// * thousands separator +// * decimal separator +// * decimal precision +// +// Usage: s := RenderFloat(format, n) +// The format parameter tells how to render the number n. +// +// See examples: http://play.golang.org/p/LXc1Ddm1lJ +// +// Examples of format strings, given n = 12345.6789: +// "#,###.##" => "12,345.67" +// "#,###." => "12,345" +// "#,###" => "12345,678" +// "#\u202F###,##" => "12 345,68" +// "#.###,###### => 12.345,678900 +// "" (aka default format) => 12,345.67 +// +// The highest precision allowed is 9 digits after the decimal symbol. +// There is also a version for integer number, FormatInteger(), +// which is convenient for calls within template. +func FormatFloat(format string, n float64) string { + // Special cases: + // NaN = "NaN" + // +Inf = "+Infinity" + // -Inf = "-Infinity" + if math.IsNaN(n) { + return "NaN" + } + if n > math.MaxFloat64 { + return "Infinity" + } + if n < -math.MaxFloat64 { + return "-Infinity" + } + + // default format + precision := 2 + decimalStr := "." + thousandStr := "," + positiveStr := "" + negativeStr := "-" + + if len(format) > 0 { + format := []rune(format) + + // If there is an explicit format directive, + // then default values are these: + precision = 9 + thousandStr = "" + + // collect indices of meaningful formatting directives + formatIndx := []int{} + for i, char := range format { + if char != '#' && char != '0' { + formatIndx = append(formatIndx, i) + } + } + + if len(formatIndx) > 0 { + // Directive at index 0: + // Must be a '+' + // Raise an error if not the case + // index: 0123456789 + // +0.000,000 + // +000,000.0 + // +0000.00 + // +0000 + if formatIndx[0] == 0 { + if format[formatIndx[0]] != '+' { + panic("RenderFloat(): invalid positive sign directive") + } + positiveStr = "+" + formatIndx = formatIndx[1:] + } + + // Two directives: + // First is thousands separator + // Raise an error if not followed by 3-digit + // 0123456789 + // 0.000,000 + // 000,000.00 + if len(formatIndx) == 2 { + if (formatIndx[1] - formatIndx[0]) != 4 { + panic("RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers") + } + thousandStr = string(format[formatIndx[0]]) + formatIndx = formatIndx[1:] + } + + // One directive: + // Directive is decimal separator + // The number of digit-specifier following the separator indicates wanted precision + // 0123456789 + // 0.00 + // 000,0000 + if len(formatIndx) == 1 { + decimalStr = string(format[formatIndx[0]]) + precision = len(format) - formatIndx[0] - 1 + } + } + } + + // generate sign part + var signStr string + if n >= 0.000000001 { + signStr = positiveStr + } else if n <= -0.000000001 { + signStr = negativeStr + n = -n + } else { + signStr = "" + n = 0.0 + } + + // split number into integer and fractional parts + intf, fracf := math.Modf(n + renderFloatPrecisionRounders[precision]) + + // generate integer part string + intStr := strconv.Itoa(int(intf)) + + // add thousand separator if required + if len(thousandStr) > 0 { + for i := len(intStr); i > 3; { + i -= 3 + intStr = intStr[:i] + thousandStr + intStr[i:] + } + } + + // no fractional part, we can leave now + if precision == 0 { + return signStr + intStr + } + + // generate fractional part + fracStr := strconv.Itoa(int(fracf * renderFloatPrecisionMultipliers[precision])) + // may need padding + if len(fracStr) < precision { + fracStr = "000000000000000"[:precision-len(fracStr)] + fracStr + } + + return signStr + intStr + decimalStr + fracStr +} + +// FormatInteger produces a formatted number as string. +// See FormatFloat. +func FormatInteger(format string, n int) string { + return FormatFloat(format, float64(n)) +} diff --git a/vendor/github.com/dustin/go-humanize/ordinals.go b/vendor/github.com/dustin/go-humanize/ordinals.go new file mode 100644 index 00000000..43d88a86 --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/ordinals.go @@ -0,0 +1,25 @@ +package humanize + +import "strconv" + +// Ordinal gives you the input number in a rank/ordinal format. +// +// Ordinal(3) -> 3rd +func Ordinal(x int) string { + suffix := "th" + switch x % 10 { + case 1: + if x%100 != 11 { + suffix = "st" + } + case 2: + if x%100 != 12 { + suffix = "nd" + } + case 3: + if x%100 != 13 { + suffix = "rd" + } + } + return strconv.Itoa(x) + suffix +} diff --git a/vendor/github.com/dustin/go-humanize/si.go b/vendor/github.com/dustin/go-humanize/si.go new file mode 100644 index 00000000..9cce4e8d --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/si.go @@ -0,0 +1,113 @@ +package humanize + +import ( + "errors" + "math" + "regexp" + "strconv" +) + +var siPrefixTable = map[float64]string{ + -24: "y", // yocto + -21: "z", // zepto + -18: "a", // atto + -15: "f", // femto + -12: "p", // pico + -9: "n", // nano + -6: "µ", // micro + -3: "m", // milli + 0: "", + 3: "k", // kilo + 6: "M", // mega + 9: "G", // giga + 12: "T", // tera + 15: "P", // peta + 18: "E", // exa + 21: "Z", // zetta + 24: "Y", // yotta +} + +var revSIPrefixTable = revfmap(siPrefixTable) + +// revfmap reverses the map and precomputes the power multiplier +func revfmap(in map[float64]string) map[string]float64 { + rv := map[string]float64{} + for k, v := range in { + rv[v] = math.Pow(10, k) + } + return rv +} + +var riParseRegex *regexp.Regexp + +func init() { + ri := `^([\-0-9.]+)\s?([` + for _, v := range siPrefixTable { + ri += v + } + ri += `]?)(.*)` + + riParseRegex = regexp.MustCompile(ri) +} + +// ComputeSI finds the most appropriate SI prefix for the given number +// and returns the prefix along with the value adjusted to be within +// that prefix. +// +// See also: SI, ParseSI. +// +// e.g. ComputeSI(2.2345e-12) -> (2.2345, "p") +func ComputeSI(input float64) (float64, string) { + if input == 0 { + return 0, "" + } + mag := math.Abs(input) + exponent := math.Floor(logn(mag, 10)) + exponent = math.Floor(exponent/3) * 3 + + value := mag / math.Pow(10, exponent) + + // Handle special case where value is exactly 1000.0 + // Should return 1M instead of 1000k + if value == 1000.0 { + exponent += 3 + value = mag / math.Pow(10, exponent) + } + + value = math.Copysign(value, input) + + prefix := siPrefixTable[exponent] + return value, prefix +} + +// SI returns a string with default formatting. +// +// SI uses Ftoa to format float value, removing trailing zeros. +// +// See also: ComputeSI, ParseSI. +// +// e.g. SI(1000000, B) -> 1MB +// e.g. SI(2.2345e-12, "F") -> 2.2345pF +func SI(input float64, unit string) string { + value, prefix := ComputeSI(input) + return Ftoa(value) + " " + prefix + unit +} + +var errInvalid = errors.New("invalid input") + +// ParseSI parses an SI string back into the number and unit. +// +// See also: SI, ComputeSI. +// +// e.g. ParseSI(2.2345pF) -> (2.2345e-12, "F", nil) +func ParseSI(input string) (float64, string, error) { + found := riParseRegex.FindStringSubmatch(input) + if len(found) != 4 { + return 0, "", errInvalid + } + mag := revSIPrefixTable[found[2]] + unit := found[3] + + base, err := strconv.ParseFloat(found[1], 64) + return base * mag, unit, err +} diff --git a/vendor/github.com/dustin/go-humanize/times.go b/vendor/github.com/dustin/go-humanize/times.go new file mode 100644 index 00000000..815f6307 --- /dev/null +++ b/vendor/github.com/dustin/go-humanize/times.go @@ -0,0 +1,114 @@ +package humanize + +import ( + "fmt" + "math" + "sort" + "time" +) + +// Seconds-based time units +const ( + Day = 24 * time.Hour + Week = 7 * Day + Month = 30 * Day + Year = 12 * Month + LongTime = 37 * Year +) + +// Time formats a time into a relative string. +// +// Time(someT) -> "3 weeks ago" +func Time(then time.Time) string { + return RelTime(then, time.Now(), "ago", "from now") +} + +// A RelTimeMagnitude struct contains a relative time point at which +// the relative format of time will switch to a new format string. A +// slice of these in ascending order by their "D" field is passed to +// CustomRelTime to format durations. +// +// The Format field is a string that may contain a "%s" which will be +// replaced with the appropriate signed label (e.g. "ago" or "from +// now") and a "%d" that will be replaced by the quantity. +// +// The DivBy field is the amount of time the time difference must be +// divided by in order to display correctly. +// +// e.g. if D is 2*time.Minute and you want to display "%d minutes %s" +// DivBy should be time.Minute so whatever the duration is will be +// expressed in minutes. +type RelTimeMagnitude struct { + D time.Duration + Format string + DivBy time.Duration +} + +var defaultMagnitudes = []RelTimeMagnitude{ + {time.Second, "now", time.Second}, + {2 * time.Second, "1 second %s", 1}, + {time.Minute, "%d seconds %s", time.Second}, + {2 * time.Minute, "1 minute %s", 1}, + {time.Hour, "%d minutes %s", time.Minute}, + {2 * time.Hour, "1 hour %s", 1}, + {Day, "%d hours %s", time.Hour}, + {2 * Day, "1 day %s", 1}, + {Week, "%d days %s", Day}, + {2 * Week, "1 week %s", 1}, + {Month, "%d weeks %s", Week}, + {2 * Month, "1 month %s", 1}, + {Year, "%d months %s", Month}, + {18 * Month, "1 year %s", 1}, + {2 * Year, "2 years %s", 1}, + {LongTime, "%d years %s", Year}, + {math.MaxInt64, "a long while %s", 1}, +} + +// RelTime formats a time into a relative string. +// +// It takes two times and two labels. In addition to the generic time +// delta string (e.g. 5 minutes), the labels are used applied so that +// the label corresponding to the smaller time is applied. +// +// RelTime(timeInPast, timeInFuture, "earlier", "later") -> "3 weeks earlier" +func RelTime(a, b time.Time, albl, blbl string) string { + return CustomRelTime(a, b, albl, blbl, defaultMagnitudes) +} + +// CustomRelTime formats a time into a relative string. +// +// It takes two times two labels and a table of relative time formats. +// In addition to the generic time delta string (e.g. 5 minutes), the +// labels are used applied so that the label corresponding to the +// smaller time is applied. +func CustomRelTime(a, b time.Time, albl, blbl string, magnitudes []RelTimeMagnitude) string { + lbl := albl + diff := b.Sub(a) + + if a.After(b) { + lbl = blbl + diff = a.Sub(b) + } + + n := sort.Search(len(magnitudes), func(i int) bool { + return magnitudes[i].D >= diff + }) + + mag := magnitudes[n] + args := []interface{}{} + escaped := false + for _, ch := range mag.Format { + if escaped { + switch ch { + case 's': + args = append(args, lbl) + case 'd': + args = append(args, diff/mag.DivBy) + } + escaped = false + } else { + escaped = ch == '%' + } + } + return fmt.Sprintf(mag.Format, args...) +} diff --git a/vendor/github.com/ghodss/yaml/LICENSE b/vendor/github.com/ghodss/yaml/LICENSE new file mode 100644 index 00000000..7805d36d --- /dev/null +++ b/vendor/github.com/ghodss/yaml/LICENSE @@ -0,0 +1,50 @@ +The MIT License (MIT) + +Copyright (c) 2014 Sam Ghods + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +Copyright (c) 2012 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/ghodss/yaml/fields.go b/vendor/github.com/ghodss/yaml/fields.go new file mode 100644 index 00000000..0bd3c2b4 --- /dev/null +++ b/vendor/github.com/ghodss/yaml/fields.go @@ -0,0 +1,497 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +package yaml + +import ( + "bytes" + "encoding" + "encoding/json" + "reflect" + "sort" + "strings" + "sync" + "unicode" + "unicode/utf8" +) + +// indirect walks down v allocating pointers as needed, +// until it gets to a non-pointer. +// if it encounters an Unmarshaler, indirect stops and returns that. +// if decodingNull is true, indirect stops at the last pointer so it can be set to nil. +func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) { + // If v is a named type and is addressable, + // start with its address, so that if the type has pointer methods, + // we find them. + if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() { + v = v.Addr() + } + for { + // Load value from interface, but only if the result will be + // usefully addressable. + if v.Kind() == reflect.Interface && !v.IsNil() { + e := v.Elem() + if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) { + v = e + continue + } + } + + if v.Kind() != reflect.Ptr { + break + } + + if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() { + break + } + if v.IsNil() { + v.Set(reflect.New(v.Type().Elem())) + } + if v.Type().NumMethod() > 0 { + if u, ok := v.Interface().(json.Unmarshaler); ok { + return u, nil, reflect.Value{} + } + if u, ok := v.Interface().(encoding.TextUnmarshaler); ok { + return nil, u, reflect.Value{} + } + } + v = v.Elem() + } + return nil, nil, v +} + +// A field represents a single field found in a struct. +type field struct { + name string + nameBytes []byte // []byte(name) + equalFold func(s, t []byte) bool // bytes.EqualFold or equivalent + + tag bool + index []int + typ reflect.Type + omitEmpty bool + quoted bool +} + +func fillField(f field) field { + f.nameBytes = []byte(f.name) + f.equalFold = foldFunc(f.nameBytes) + return f +} + +// byName sorts field by name, breaking ties with depth, +// then breaking ties with "name came from json tag", then +// breaking ties with index sequence. +type byName []field + +func (x byName) Len() int { return len(x) } + +func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +func (x byName) Less(i, j int) bool { + if x[i].name != x[j].name { + return x[i].name < x[j].name + } + if len(x[i].index) != len(x[j].index) { + return len(x[i].index) < len(x[j].index) + } + if x[i].tag != x[j].tag { + return x[i].tag + } + return byIndex(x).Less(i, j) +} + +// byIndex sorts field by index sequence. +type byIndex []field + +func (x byIndex) Len() int { return len(x) } + +func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +func (x byIndex) Less(i, j int) bool { + for k, xik := range x[i].index { + if k >= len(x[j].index) { + return false + } + if xik != x[j].index[k] { + return xik < x[j].index[k] + } + } + return len(x[i].index) < len(x[j].index) +} + +// typeFields returns a list of fields that JSON should recognize for the given type. +// The algorithm is breadth-first search over the set of structs to include - the top struct +// and then any reachable anonymous structs. +func typeFields(t reflect.Type) []field { + // Anonymous fields to explore at the current level and the next. + current := []field{} + next := []field{{typ: t}} + + // Count of queued names for current level and the next. + count := map[reflect.Type]int{} + nextCount := map[reflect.Type]int{} + + // Types already visited at an earlier level. + visited := map[reflect.Type]bool{} + + // Fields found. + var fields []field + + for len(next) > 0 { + current, next = next, current[:0] + count, nextCount = nextCount, map[reflect.Type]int{} + + for _, f := range current { + if visited[f.typ] { + continue + } + visited[f.typ] = true + + // Scan f.typ for fields to include. + for i := 0; i < f.typ.NumField(); i++ { + sf := f.typ.Field(i) + if sf.PkgPath != "" { // unexported + continue + } + tag := sf.Tag.Get("json") + if tag == "-" { + continue + } + name, opts := parseTag(tag) + if !isValidTag(name) { + name = "" + } + index := make([]int, len(f.index)+1) + copy(index, f.index) + index[len(f.index)] = i + + ft := sf.Type + if ft.Name() == "" && ft.Kind() == reflect.Ptr { + // Follow pointer. + ft = ft.Elem() + } + + // Record found field and index sequence. + if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct { + tagged := name != "" + if name == "" { + name = sf.Name + } + fields = append(fields, fillField(field{ + name: name, + tag: tagged, + index: index, + typ: ft, + omitEmpty: opts.Contains("omitempty"), + quoted: opts.Contains("string"), + })) + if count[f.typ] > 1 { + // If there were multiple instances, add a second, + // so that the annihilation code will see a duplicate. + // It only cares about the distinction between 1 or 2, + // so don't bother generating any more copies. + fields = append(fields, fields[len(fields)-1]) + } + continue + } + + // Record new anonymous struct to explore in next round. + nextCount[ft]++ + if nextCount[ft] == 1 { + next = append(next, fillField(field{name: ft.Name(), index: index, typ: ft})) + } + } + } + } + + sort.Sort(byName(fields)) + + // Delete all fields that are hidden by the Go rules for embedded fields, + // except that fields with JSON tags are promoted. + + // The fields are sorted in primary order of name, secondary order + // of field index length. Loop over names; for each name, delete + // hidden fields by choosing the one dominant field that survives. + out := fields[:0] + for advance, i := 0, 0; i < len(fields); i += advance { + // One iteration per name. + // Find the sequence of fields with the name of this first field. + fi := fields[i] + name := fi.name + for advance = 1; i+advance < len(fields); advance++ { + fj := fields[i+advance] + if fj.name != name { + break + } + } + if advance == 1 { // Only one field with this name + out = append(out, fi) + continue + } + dominant, ok := dominantField(fields[i : i+advance]) + if ok { + out = append(out, dominant) + } + } + + fields = out + sort.Sort(byIndex(fields)) + + return fields +} + +// dominantField looks through the fields, all of which are known to +// have the same name, to find the single field that dominates the +// others using Go's embedding rules, modified by the presence of +// JSON tags. If there are multiple top-level fields, the boolean +// will be false: This condition is an error in Go and we skip all +// the fields. +func dominantField(fields []field) (field, bool) { + // The fields are sorted in increasing index-length order. The winner + // must therefore be one with the shortest index length. Drop all + // longer entries, which is easy: just truncate the slice. + length := len(fields[0].index) + tagged := -1 // Index of first tagged field. + for i, f := range fields { + if len(f.index) > length { + fields = fields[:i] + break + } + if f.tag { + if tagged >= 0 { + // Multiple tagged fields at the same level: conflict. + // Return no field. + return field{}, false + } + tagged = i + } + } + if tagged >= 0 { + return fields[tagged], true + } + // All remaining fields have the same length. If there's more than one, + // we have a conflict (two fields named "X" at the same level) and we + // return no field. + if len(fields) > 1 { + return field{}, false + } + return fields[0], true +} + +var fieldCache struct { + sync.RWMutex + m map[reflect.Type][]field +} + +// cachedTypeFields is like typeFields but uses a cache to avoid repeated work. +func cachedTypeFields(t reflect.Type) []field { + fieldCache.RLock() + f := fieldCache.m[t] + fieldCache.RUnlock() + if f != nil { + return f + } + + // Compute fields without lock. + // Might duplicate effort but won't hold other computations back. + f = typeFields(t) + if f == nil { + f = []field{} + } + + fieldCache.Lock() + if fieldCache.m == nil { + fieldCache.m = map[reflect.Type][]field{} + } + fieldCache.m[t] = f + fieldCache.Unlock() + return f +} + +func isValidTag(s string) bool { + if s == "" { + return false + } + for _, c := range s { + switch { + case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c): + // Backslash and quote chars are reserved, but + // otherwise any punctuation chars are allowed + // in a tag name. + default: + if !unicode.IsLetter(c) && !unicode.IsDigit(c) { + return false + } + } + } + return true +} + +const ( + caseMask = ^byte(0x20) // Mask to ignore case in ASCII. + kelvin = '\u212a' + smallLongEss = '\u017f' +) + +// foldFunc returns one of four different case folding equivalence +// functions, from most general (and slow) to fastest: +// +// 1) bytes.EqualFold, if the key s contains any non-ASCII UTF-8 +// 2) equalFoldRight, if s contains special folding ASCII ('k', 'K', 's', 'S') +// 3) asciiEqualFold, no special, but includes non-letters (including _) +// 4) simpleLetterEqualFold, no specials, no non-letters. +// +// The letters S and K are special because they map to 3 runes, not just 2: +// * S maps to s and to U+017F 'ſ' Latin small letter long s +// * k maps to K and to U+212A 'K' Kelvin sign +// See http://play.golang.org/p/tTxjOc0OGo +// +// The returned function is specialized for matching against s and +// should only be given s. It's not curried for performance reasons. +func foldFunc(s []byte) func(s, t []byte) bool { + nonLetter := false + special := false // special letter + for _, b := range s { + if b >= utf8.RuneSelf { + return bytes.EqualFold + } + upper := b & caseMask + if upper < 'A' || upper > 'Z' { + nonLetter = true + } else if upper == 'K' || upper == 'S' { + // See above for why these letters are special. + special = true + } + } + if special { + return equalFoldRight + } + if nonLetter { + return asciiEqualFold + } + return simpleLetterEqualFold +} + +// equalFoldRight is a specialization of bytes.EqualFold when s is +// known to be all ASCII (including punctuation), but contains an 's', +// 'S', 'k', or 'K', requiring a Unicode fold on the bytes in t. +// See comments on foldFunc. +func equalFoldRight(s, t []byte) bool { + for _, sb := range s { + if len(t) == 0 { + return false + } + tb := t[0] + if tb < utf8.RuneSelf { + if sb != tb { + sbUpper := sb & caseMask + if 'A' <= sbUpper && sbUpper <= 'Z' { + if sbUpper != tb&caseMask { + return false + } + } else { + return false + } + } + t = t[1:] + continue + } + // sb is ASCII and t is not. t must be either kelvin + // sign or long s; sb must be s, S, k, or K. + tr, size := utf8.DecodeRune(t) + switch sb { + case 's', 'S': + if tr != smallLongEss { + return false + } + case 'k', 'K': + if tr != kelvin { + return false + } + default: + return false + } + t = t[size:] + + } + if len(t) > 0 { + return false + } + return true +} + +// asciiEqualFold is a specialization of bytes.EqualFold for use when +// s is all ASCII (but may contain non-letters) and contains no +// special-folding letters. +// See comments on foldFunc. +func asciiEqualFold(s, t []byte) bool { + if len(s) != len(t) { + return false + } + for i, sb := range s { + tb := t[i] + if sb == tb { + continue + } + if ('a' <= sb && sb <= 'z') || ('A' <= sb && sb <= 'Z') { + if sb&caseMask != tb&caseMask { + return false + } + } else { + return false + } + } + return true +} + +// simpleLetterEqualFold is a specialization of bytes.EqualFold for +// use when s is all ASCII letters (no underscores, etc) and also +// doesn't contain 'k', 'K', 's', or 'S'. +// See comments on foldFunc. +func simpleLetterEqualFold(s, t []byte) bool { + if len(s) != len(t) { + return false + } + for i, b := range s { + if b&caseMask != t[i]&caseMask { + return false + } + } + return true +} + +// tagOptions is the string following a comma in a struct field's "json" +// tag, or the empty string. It does not include the leading comma. +type tagOptions string + +// parseTag splits a struct field's json tag into its name and +// comma-separated options. +func parseTag(tag string) (string, tagOptions) { + if idx := strings.Index(tag, ","); idx != -1 { + return tag[:idx], tagOptions(tag[idx+1:]) + } + return tag, tagOptions("") +} + +// Contains reports whether a comma-separated list of options +// contains a particular substr flag. substr must be surrounded by a +// string boundary or commas. +func (o tagOptions) Contains(optionName string) bool { + if len(o) == 0 { + return false + } + s := string(o) + for s != "" { + var next string + i := strings.Index(s, ",") + if i >= 0 { + s, next = s[:i], s[i+1:] + } + if s == optionName { + return true + } + s = next + } + return false +} diff --git a/vendor/github.com/ghodss/yaml/yaml.go b/vendor/github.com/ghodss/yaml/yaml.go new file mode 100644 index 00000000..0bb015b4 --- /dev/null +++ b/vendor/github.com/ghodss/yaml/yaml.go @@ -0,0 +1,277 @@ +package yaml + +import ( + "bytes" + "encoding/json" + "fmt" + "reflect" + "strconv" + + yaml "github.com/cloudfoundry-incubator/candiedyaml" +) + +// Marshals the object into JSON then converts JSON to YAML and returns the +// YAML. +func Marshal(o interface{}) ([]byte, error) { + j, err := json.Marshal(o) + if err != nil { + return nil, fmt.Errorf("error marshaling into JSON: %v", err) + } + + y, err := JSONToYAML(j) + if err != nil { + return nil, fmt.Errorf("error converting JSON to YAML: %v", err) + } + + return y, nil +} + +// Converts YAML to JSON then uses JSON to unmarshal into an object. +func Unmarshal(y []byte, o interface{}) error { + vo := reflect.ValueOf(o) + j, err := yamlToJSON(y, &vo) + if err != nil { + return fmt.Errorf("error converting YAML to JSON: %v", err) + } + + err = json.Unmarshal(j, o) + if err != nil { + return fmt.Errorf("error unmarshaling JSON: %v", err) + } + + return nil +} + +// Convert JSON to YAML. +func JSONToYAML(j []byte) ([]byte, error) { + // Convert the JSON to an object. + var jsonObj interface{} + // We are using yaml.Unmarshal here (instead of json.Unmarshal) because the + // Go JSON library doesn't try to pick the right number type (int, float, + // etc.) when unmarshalling to interface{}, it just picks float64 + // universally. go-yaml does go through the effort of picking the right + // number type, so we can preserve number type throughout this process. + err := yaml.Unmarshal(j, &jsonObj) + if err != nil { + return nil, err + } + + // Marshal this object into YAML. + return yaml.Marshal(jsonObj) +} + +// Convert YAML to JSON. Since JSON is a subset of YAML, passing JSON through +// this method should be a no-op. +// +// Things YAML can do that are not supported by JSON: +// * In YAML you can have binary and null keys in your maps. These are invalid +// in JSON. (int and float keys are converted to strings.) +// * Binary data in YAML with the !!binary tag is not supported. If you want to +// use binary data with this library, encode the data as base64 as usual but do +// not use the !!binary tag in your YAML. This will ensure the original base64 +// encoded data makes it all the way through to the JSON. +func YAMLToJSON(y []byte) ([]byte, error) { + return yamlToJSON(y, nil) +} + +func yamlToJSON(y []byte, jsonTarget *reflect.Value) ([]byte, error) { + // Convert the YAML to an object. + var yamlObj interface{} + err := yaml.Unmarshal(y, &yamlObj) + if err != nil { + return nil, err + } + + // YAML objects are not completely compatible with JSON objects (e.g. you + // can have non-string keys in YAML). So, convert the YAML-compatible object + // to a JSON-compatible object, failing with an error if irrecoverable + // incompatibilties happen along the way. + jsonObj, err := convertToJSONableObject(yamlObj, jsonTarget) + if err != nil { + return nil, err + } + + // Convert this object to JSON and return the data. + return json.Marshal(jsonObj) +} + +func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (interface{}, error) { + var err error + + // Resolve jsonTarget to a concrete value (i.e. not a pointer or an + // interface). We pass decodingNull as false because we're not actually + // decoding into the value, we're just checking if the ultimate target is a + // string. + if jsonTarget != nil { + ju, tu, pv := indirect(*jsonTarget, false) + // We have a JSON or Text Umarshaler at this level, so we can't be trying + // to decode into a string. + if ju != nil || tu != nil { + jsonTarget = nil + } else { + jsonTarget = &pv + } + } + + // If yamlObj is a number or a boolean, check if jsonTarget is a string - + // if so, coerce. Else return normal. + // If yamlObj is a map or array, find the field that each key is + // unmarshaling to, and when you recurse pass the reflect.Value for that + // field back into this function. + switch typedYAMLObj := yamlObj.(type) { + case map[interface{}]interface{}: + // JSON does not support arbitrary keys in a map, so we must convert + // these keys to strings. + // + // From my reading of go-yaml v2 (specifically the resolve function), + // keys can only have the types string, int, int64, float64, binary + // (unsupported), or null (unsupported). + strMap := make(map[string]interface{}) + for k, v := range typedYAMLObj { + // Resolve the key to a string first. + var keyString string + switch typedKey := k.(type) { + case string: + keyString = typedKey + case int: + keyString = strconv.Itoa(typedKey) + case int64: + // go-yaml will only return an int64 as a key if the system + // architecture is 32-bit and the key's value is between 32-bit + // and 64-bit. Otherwise the key type will simply be int. + keyString = strconv.FormatInt(typedKey, 10) + case float64: + // Stolen from go-yaml to use the same conversion to string as + // the go-yaml library uses to convert float to string when + // Marshaling. + s := strconv.FormatFloat(typedKey, 'g', -1, 32) + switch s { + case "+Inf": + s = ".inf" + case "-Inf": + s = "-.inf" + case "NaN": + s = ".nan" + } + keyString = s + case bool: + if typedKey { + keyString = "true" + } else { + keyString = "false" + } + default: + return nil, fmt.Errorf("Unsupported map key of type: %s, key: %+#v, value: %+#v", + reflect.TypeOf(k), k, v) + } + + // jsonTarget should be a struct or a map. If it's a struct, find + // the field it's going to map to and pass its reflect.Value. If + // it's a map, find the element type of the map and pass the + // reflect.Value created from that type. If it's neither, just pass + // nil - JSON conversion will error for us if it's a real issue. + if jsonTarget != nil { + t := *jsonTarget + if t.Kind() == reflect.Struct { + keyBytes := []byte(keyString) + // Find the field that the JSON library would use. + var f *field + fields := cachedTypeFields(t.Type()) + for i := range fields { + ff := &fields[i] + if bytes.Equal(ff.nameBytes, keyBytes) { + f = ff + break + } + // Do case-insensitive comparison. + if f == nil && ff.equalFold(ff.nameBytes, keyBytes) { + f = ff + } + } + if f != nil { + // Find the reflect.Value of the most preferential + // struct field. + jtf := t.Field(f.index[0]) + strMap[keyString], err = convertToJSONableObject(v, &jtf) + if err != nil { + return nil, err + } + continue + } + } else if t.Kind() == reflect.Map { + // Create a zero value of the map's element type to use as + // the JSON target. + jtv := reflect.Zero(t.Type().Elem()) + strMap[keyString], err = convertToJSONableObject(v, &jtv) + if err != nil { + return nil, err + } + continue + } + } + strMap[keyString], err = convertToJSONableObject(v, nil) + if err != nil { + return nil, err + } + } + return strMap, nil + case []interface{}: + // We need to recurse into arrays in case there are any + // map[interface{}]interface{}'s inside and to convert any + // numbers to strings. + + // If jsonTarget is a slice (which it really should be), find the + // thing it's going to map to. If it's not a slice, just pass nil + // - JSON conversion will error for us if it's a real issue. + var jsonSliceElemValue *reflect.Value + if jsonTarget != nil { + t := *jsonTarget + if t.Kind() == reflect.Slice { + // By default slices point to nil, but we need a reflect.Value + // pointing to a value of the slice type, so we create one here. + ev := reflect.Indirect(reflect.New(t.Type().Elem())) + jsonSliceElemValue = &ev + } + } + + // Make and use a new array. + arr := make([]interface{}, len(typedYAMLObj)) + for i, v := range typedYAMLObj { + arr[i], err = convertToJSONableObject(v, jsonSliceElemValue) + if err != nil { + return nil, err + } + } + return arr, nil + default: + // If the target type is a string and the YAML type is a number, + // convert the YAML type to a string. + if jsonTarget != nil && (*jsonTarget).Kind() == reflect.String { + // Based on my reading of go-yaml, it may return int, int64, + // float64, or uint64. + var s string + switch typedVal := typedYAMLObj.(type) { + case int: + s = strconv.FormatInt(int64(typedVal), 10) + case int64: + s = strconv.FormatInt(typedVal, 10) + case float64: + s = strconv.FormatFloat(typedVal, 'g', -1, 32) + case uint64: + s = strconv.FormatUint(typedVal, 10) + case bool: + if typedVal { + s = "true" + } else { + s = "false" + } + } + if len(s) > 0 { + yamlObj = interface{}(s) + } + } + return yamlObj, nil + } + + return nil, nil +} diff --git a/vendor/github.com/gogo/protobuf/LICENSE b/vendor/github.com/gogo/protobuf/LICENSE new file mode 100644 index 00000000..7be0cc7b --- /dev/null +++ b/vendor/github.com/gogo/protobuf/LICENSE @@ -0,0 +1,36 @@ +Protocol Buffers for Go with Gadgets + +Copyright (c) 2013, The GoGo Authors. All rights reserved. +http://github.com/gogo/protobuf + +Go support for Protocol Buffers - Google's data interchange format + +Copyright 2010 The Go Authors. All rights reserved. +https://github.com/golang/protobuf + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/vendor/github.com/gogo/protobuf/gogoproto/doc.go b/vendor/github.com/gogo/protobuf/gogoproto/doc.go new file mode 100644 index 00000000..5ecfae11 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/gogoproto/doc.go @@ -0,0 +1,168 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* +Package gogoproto provides extensions for protocol buffers to achieve: + + - fast marshalling and unmarshalling. + - peace of mind by optionally generating test and benchmark code. + - more canonical Go structures. + - less typing by optionally generating extra helper code. + - goprotobuf compatibility + +More Canonical Go Structures + +A lot of time working with a goprotobuf struct will lead you to a place where you create another struct that is easier to work with and then have a function to copy the values between the two structs. +You might also find that basic structs that started their life as part of an API need to be sent over the wire. With gob, you could just send it. With goprotobuf, you need to make a parallel struct. +Gogoprotobuf tries to fix these problems with the nullable, embed, customtype and customname field extensions. + + - nullable, if false, a field is generated without a pointer (see warning below). + - embed, if true, the field is generated as an embedded field. + - customtype, It works with the Marshal and Unmarshal methods, to allow you to have your own types in your struct, but marshal to bytes. For example, custom.Uuid or custom.Fixed128 + - customname (beta), Changes the generated fieldname. This is especially useful when generated methods conflict with fieldnames. + - casttype (beta), Changes the generated fieldtype. All generated code assumes that this type is castable to the protocol buffer field type. It does not work for structs or enums. + - castkey (beta), Changes the generated fieldtype for a map key. All generated code assumes that this type is castable to the protocol buffer field type. Only supported on maps. + - castvalue (beta), Changes the generated fieldtype for a map value. All generated code assumes that this type is castable to the protocol buffer field type. Only supported on maps. + +Warning about nullable: According to the Protocol Buffer specification, you should be able to tell whether a field is set or unset. With the option nullable=false this feature is lost, since your non-nullable fields will always be set. It can be seen as a layer on top of Protocol Buffers, where before and after marshalling all non-nullable fields are set and they cannot be unset. + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +for a quicker overview. + +The following message: + + package test; + + import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + + message A { + optional string Description = 1 [(gogoproto.nullable) = false]; + optional int64 Number = 2 [(gogoproto.nullable) = false]; + optional bytes Id = 3 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uuid", (gogoproto.nullable) = false]; + } + +Will generate a go struct which looks a lot like this: + + type A struct { + Description string + Number int64 + Id github_com_gogo_protobuf_test_custom.Uuid + } + +You will see there are no pointers, since all fields are non-nullable. +You will also see a custom type which marshals to a string. +Be warned it is your responsibility to test your custom types thoroughly. +You should think of every possible empty and nil case for your marshaling, unmarshaling and size methods. + +Next we will embed the message A in message B. + + message B { + optional A A = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + repeated bytes G = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; + } + +See below that A is embedded in B. + + type B struct { + A + G []github_com_gogo_protobuf_test_custom.Uint128 + } + +Also see the repeated custom type. + + type Uint128 [2]uint64 + +Next we will create a custom name for one of our fields. + + message C { + optional int64 size = 1 [(gogoproto.customname) = "MySize"]; + } + +See below that the field's name is MySize and not Size. + + type C struct { + MySize *int64 + } + +The is useful when having a protocol buffer message with a field name which conflicts with a generated method. +As an example, having a field name size and using the sizer plugin to generate a Size method will cause a go compiler error. +Using customname you can fix this error without changing the field name. +This is typically useful when working with a protocol buffer that was designed before these methods and/or the go language were avialable. + +Gogoprotobuf also has some more subtle changes, these could be changed back: + + - the generated package name for imports do not have the extra /filename.pb, + but are actually the imports specified in the .proto file. + +Gogoprotobuf also has lost some features which should be brought back with time: + + - Marshalling and unmarshalling with reflect and without the unsafe package, + this requires work in pointer_reflect.go + +Why does nullable break protocol buffer specifications: + +The protocol buffer specification states, somewhere, that you should be able to tell whether a +field is set or unset. With the option nullable=false this feature is lost, +since your non-nullable fields will always be set. It can be seen as a layer on top of +protocol buffers, where before and after marshalling all non-nullable fields are set +and they cannot be unset. + +Goprotobuf Compatibility: + +Gogoprotobuf is compatible with Goprotobuf, because it is compatible with protocol buffers. +Gogoprotobuf generates the same code as goprotobuf if no extensions are used. +The enumprefix, getters and stringer extensions can be used to remove some of the unnecessary code generated by goprotobuf: + + - gogoproto_import, if false, the generated code imports github.com/golang/protobuf/proto instead of github.com/gogo/protobuf/proto. + - goproto_enum_prefix, if false, generates the enum constant names without the messagetype prefix + - goproto_enum_stringer (experimental), if false, the enum is generated without the default string method, this is useful for rather using enum_stringer, or allowing you to write your own string method. + - goproto_getters, if false, the message is generated without get methods, this is useful when you would rather want to use face + - goproto_stringer, if false, the message is generated without the default string method, this is useful for rather using stringer, or allowing you to write your own string method. + - goproto_extensions_map (beta), if false, the extensions field is generated as type []byte instead of type map[int32]proto.Extension + - goproto_unrecognized (beta), if false, XXX_unrecognized field is not generated. This is useful in conjunction with gogoproto.nullable=false, to generate structures completely devoid of pointers and reduce GC pressure at the cost of losing information about unrecognized fields. + +Less Typing and Peace of Mind is explained in their specific plugin folders godoc: + + - github.com/gogo/protobuf/plugin/ + +If you do not use any of these extension the code that is generated +will be the same as if goprotobuf has generated it. + +The most complete way to see examples is to look at + + github.com/gogo/protobuf/test/thetest.proto + +Gogoprototest is a seperate project, +because we want to keep gogoprotobuf independant of goprotobuf, +but we still want to test it thoroughly. + +*/ +package gogoproto diff --git a/vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go b/vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go new file mode 100644 index 00000000..6da0e3e7 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go @@ -0,0 +1,665 @@ +// Code generated by protoc-gen-gogo. +// source: gogo.proto +// DO NOT EDIT! + +/* +Package gogoproto is a generated protocol buffer package. + +It is generated from these files: + gogo.proto + +It has these top-level messages: +*/ +package gogoproto + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" +import google_protobuf "github.com/gogo/protobuf/protoc-gen-gogo/descriptor" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +var E_GoprotoEnumPrefix = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.EnumOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 62001, + Name: "gogoproto.goproto_enum_prefix", + Tag: "varint,62001,opt,name=goproto_enum_prefix,json=goprotoEnumPrefix", +} + +var E_GoprotoEnumStringer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.EnumOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 62021, + Name: "gogoproto.goproto_enum_stringer", + Tag: "varint,62021,opt,name=goproto_enum_stringer,json=goprotoEnumStringer", +} + +var E_EnumStringer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.EnumOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 62022, + Name: "gogoproto.enum_stringer", + Tag: "varint,62022,opt,name=enum_stringer,json=enumStringer", +} + +var E_EnumCustomname = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.EnumOptions)(nil), + ExtensionType: (*string)(nil), + Field: 62023, + Name: "gogoproto.enum_customname", + Tag: "bytes,62023,opt,name=enum_customname,json=enumCustomname", +} + +var E_EnumvalueCustomname = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.EnumValueOptions)(nil), + ExtensionType: (*string)(nil), + Field: 66001, + Name: "gogoproto.enumvalue_customname", + Tag: "bytes,66001,opt,name=enumvalue_customname,json=enumvalueCustomname", +} + +var E_GoprotoGettersAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63001, + Name: "gogoproto.goproto_getters_all", + Tag: "varint,63001,opt,name=goproto_getters_all,json=goprotoGettersAll", +} + +var E_GoprotoEnumPrefixAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63002, + Name: "gogoproto.goproto_enum_prefix_all", + Tag: "varint,63002,opt,name=goproto_enum_prefix_all,json=goprotoEnumPrefixAll", +} + +var E_GoprotoStringerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63003, + Name: "gogoproto.goproto_stringer_all", + Tag: "varint,63003,opt,name=goproto_stringer_all,json=goprotoStringerAll", +} + +var E_VerboseEqualAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63004, + Name: "gogoproto.verbose_equal_all", + Tag: "varint,63004,opt,name=verbose_equal_all,json=verboseEqualAll", +} + +var E_FaceAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63005, + Name: "gogoproto.face_all", + Tag: "varint,63005,opt,name=face_all,json=faceAll", +} + +var E_GostringAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63006, + Name: "gogoproto.gostring_all", + Tag: "varint,63006,opt,name=gostring_all,json=gostringAll", +} + +var E_PopulateAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63007, + Name: "gogoproto.populate_all", + Tag: "varint,63007,opt,name=populate_all,json=populateAll", +} + +var E_StringerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63008, + Name: "gogoproto.stringer_all", + Tag: "varint,63008,opt,name=stringer_all,json=stringerAll", +} + +var E_OnlyoneAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63009, + Name: "gogoproto.onlyone_all", + Tag: "varint,63009,opt,name=onlyone_all,json=onlyoneAll", +} + +var E_EqualAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63013, + Name: "gogoproto.equal_all", + Tag: "varint,63013,opt,name=equal_all,json=equalAll", +} + +var E_DescriptionAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63014, + Name: "gogoproto.description_all", + Tag: "varint,63014,opt,name=description_all,json=descriptionAll", +} + +var E_TestgenAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63015, + Name: "gogoproto.testgen_all", + Tag: "varint,63015,opt,name=testgen_all,json=testgenAll", +} + +var E_BenchgenAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63016, + Name: "gogoproto.benchgen_all", + Tag: "varint,63016,opt,name=benchgen_all,json=benchgenAll", +} + +var E_MarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63017, + Name: "gogoproto.marshaler_all", + Tag: "varint,63017,opt,name=marshaler_all,json=marshalerAll", +} + +var E_UnmarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63018, + Name: "gogoproto.unmarshaler_all", + Tag: "varint,63018,opt,name=unmarshaler_all,json=unmarshalerAll", +} + +var E_StableMarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63019, + Name: "gogoproto.stable_marshaler_all", + Tag: "varint,63019,opt,name=stable_marshaler_all,json=stableMarshalerAll", +} + +var E_SizerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63020, + Name: "gogoproto.sizer_all", + Tag: "varint,63020,opt,name=sizer_all,json=sizerAll", +} + +var E_GoprotoEnumStringerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63021, + Name: "gogoproto.goproto_enum_stringer_all", + Tag: "varint,63021,opt,name=goproto_enum_stringer_all,json=goprotoEnumStringerAll", +} + +var E_EnumStringerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63022, + Name: "gogoproto.enum_stringer_all", + Tag: "varint,63022,opt,name=enum_stringer_all,json=enumStringerAll", +} + +var E_UnsafeMarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63023, + Name: "gogoproto.unsafe_marshaler_all", + Tag: "varint,63023,opt,name=unsafe_marshaler_all,json=unsafeMarshalerAll", +} + +var E_UnsafeUnmarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63024, + Name: "gogoproto.unsafe_unmarshaler_all", + Tag: "varint,63024,opt,name=unsafe_unmarshaler_all,json=unsafeUnmarshalerAll", +} + +var E_GoprotoExtensionsMapAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63025, + Name: "gogoproto.goproto_extensions_map_all", + Tag: "varint,63025,opt,name=goproto_extensions_map_all,json=goprotoExtensionsMapAll", +} + +var E_GoprotoUnrecognizedAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63026, + Name: "gogoproto.goproto_unrecognized_all", + Tag: "varint,63026,opt,name=goproto_unrecognized_all,json=goprotoUnrecognizedAll", +} + +var E_GogoprotoImport = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63027, + Name: "gogoproto.gogoproto_import", + Tag: "varint,63027,opt,name=gogoproto_import,json=gogoprotoImport", +} + +var E_ProtosizerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63028, + Name: "gogoproto.protosizer_all", + Tag: "varint,63028,opt,name=protosizer_all,json=protosizerAll", +} + +var E_CompareAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63029, + Name: "gogoproto.compare_all", + Tag: "varint,63029,opt,name=compare_all,json=compareAll", +} + +var E_GoprotoGetters = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64001, + Name: "gogoproto.goproto_getters", + Tag: "varint,64001,opt,name=goproto_getters,json=goprotoGetters", +} + +var E_GoprotoStringer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64003, + Name: "gogoproto.goproto_stringer", + Tag: "varint,64003,opt,name=goproto_stringer,json=goprotoStringer", +} + +var E_VerboseEqual = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64004, + Name: "gogoproto.verbose_equal", + Tag: "varint,64004,opt,name=verbose_equal,json=verboseEqual", +} + +var E_Face = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64005, + Name: "gogoproto.face", + Tag: "varint,64005,opt,name=face", +} + +var E_Gostring = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64006, + Name: "gogoproto.gostring", + Tag: "varint,64006,opt,name=gostring", +} + +var E_Populate = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64007, + Name: "gogoproto.populate", + Tag: "varint,64007,opt,name=populate", +} + +var E_Stringer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 67008, + Name: "gogoproto.stringer", + Tag: "varint,67008,opt,name=stringer", +} + +var E_Onlyone = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64009, + Name: "gogoproto.onlyone", + Tag: "varint,64009,opt,name=onlyone", +} + +var E_Equal = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64013, + Name: "gogoproto.equal", + Tag: "varint,64013,opt,name=equal", +} + +var E_Description = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64014, + Name: "gogoproto.description", + Tag: "varint,64014,opt,name=description", +} + +var E_Testgen = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64015, + Name: "gogoproto.testgen", + Tag: "varint,64015,opt,name=testgen", +} + +var E_Benchgen = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64016, + Name: "gogoproto.benchgen", + Tag: "varint,64016,opt,name=benchgen", +} + +var E_Marshaler = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64017, + Name: "gogoproto.marshaler", + Tag: "varint,64017,opt,name=marshaler", +} + +var E_Unmarshaler = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64018, + Name: "gogoproto.unmarshaler", + Tag: "varint,64018,opt,name=unmarshaler", +} + +var E_StableMarshaler = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64019, + Name: "gogoproto.stable_marshaler", + Tag: "varint,64019,opt,name=stable_marshaler,json=stableMarshaler", +} + +var E_Sizer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64020, + Name: "gogoproto.sizer", + Tag: "varint,64020,opt,name=sizer", +} + +var E_UnsafeMarshaler = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64023, + Name: "gogoproto.unsafe_marshaler", + Tag: "varint,64023,opt,name=unsafe_marshaler,json=unsafeMarshaler", +} + +var E_UnsafeUnmarshaler = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64024, + Name: "gogoproto.unsafe_unmarshaler", + Tag: "varint,64024,opt,name=unsafe_unmarshaler,json=unsafeUnmarshaler", +} + +var E_GoprotoExtensionsMap = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64025, + Name: "gogoproto.goproto_extensions_map", + Tag: "varint,64025,opt,name=goproto_extensions_map,json=goprotoExtensionsMap", +} + +var E_GoprotoUnrecognized = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64026, + Name: "gogoproto.goproto_unrecognized", + Tag: "varint,64026,opt,name=goproto_unrecognized,json=goprotoUnrecognized", +} + +var E_Protosizer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64028, + Name: "gogoproto.protosizer", + Tag: "varint,64028,opt,name=protosizer", +} + +var E_Compare = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64029, + Name: "gogoproto.compare", + Tag: "varint,64029,opt,name=compare", +} + +var E_Nullable = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 65001, + Name: "gogoproto.nullable", + Tag: "varint,65001,opt,name=nullable", +} + +var E_Embed = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 65002, + Name: "gogoproto.embed", + Tag: "varint,65002,opt,name=embed", +} + +var E_Customtype = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65003, + Name: "gogoproto.customtype", + Tag: "bytes,65003,opt,name=customtype", +} + +var E_Customname = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65004, + Name: "gogoproto.customname", + Tag: "bytes,65004,opt,name=customname", +} + +var E_Jsontag = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65005, + Name: "gogoproto.jsontag", + Tag: "bytes,65005,opt,name=jsontag", +} + +var E_Moretags = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65006, + Name: "gogoproto.moretags", + Tag: "bytes,65006,opt,name=moretags", +} + +var E_Casttype = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65007, + Name: "gogoproto.casttype", + Tag: "bytes,65007,opt,name=casttype", +} + +var E_Castkey = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65008, + Name: "gogoproto.castkey", + Tag: "bytes,65008,opt,name=castkey", +} + +var E_Castvalue = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65009, + Name: "gogoproto.castvalue", + Tag: "bytes,65009,opt,name=castvalue", +} + +func init() { + proto.RegisterExtension(E_GoprotoEnumPrefix) + proto.RegisterExtension(E_GoprotoEnumStringer) + proto.RegisterExtension(E_EnumStringer) + proto.RegisterExtension(E_EnumCustomname) + proto.RegisterExtension(E_EnumvalueCustomname) + proto.RegisterExtension(E_GoprotoGettersAll) + proto.RegisterExtension(E_GoprotoEnumPrefixAll) + proto.RegisterExtension(E_GoprotoStringerAll) + proto.RegisterExtension(E_VerboseEqualAll) + proto.RegisterExtension(E_FaceAll) + proto.RegisterExtension(E_GostringAll) + proto.RegisterExtension(E_PopulateAll) + proto.RegisterExtension(E_StringerAll) + proto.RegisterExtension(E_OnlyoneAll) + proto.RegisterExtension(E_EqualAll) + proto.RegisterExtension(E_DescriptionAll) + proto.RegisterExtension(E_TestgenAll) + proto.RegisterExtension(E_BenchgenAll) + proto.RegisterExtension(E_MarshalerAll) + proto.RegisterExtension(E_UnmarshalerAll) + proto.RegisterExtension(E_StableMarshalerAll) + proto.RegisterExtension(E_SizerAll) + proto.RegisterExtension(E_GoprotoEnumStringerAll) + proto.RegisterExtension(E_EnumStringerAll) + proto.RegisterExtension(E_UnsafeMarshalerAll) + proto.RegisterExtension(E_UnsafeUnmarshalerAll) + proto.RegisterExtension(E_GoprotoExtensionsMapAll) + proto.RegisterExtension(E_GoprotoUnrecognizedAll) + proto.RegisterExtension(E_GogoprotoImport) + proto.RegisterExtension(E_ProtosizerAll) + proto.RegisterExtension(E_CompareAll) + proto.RegisterExtension(E_GoprotoGetters) + proto.RegisterExtension(E_GoprotoStringer) + proto.RegisterExtension(E_VerboseEqual) + proto.RegisterExtension(E_Face) + proto.RegisterExtension(E_Gostring) + proto.RegisterExtension(E_Populate) + proto.RegisterExtension(E_Stringer) + proto.RegisterExtension(E_Onlyone) + proto.RegisterExtension(E_Equal) + proto.RegisterExtension(E_Description) + proto.RegisterExtension(E_Testgen) + proto.RegisterExtension(E_Benchgen) + proto.RegisterExtension(E_Marshaler) + proto.RegisterExtension(E_Unmarshaler) + proto.RegisterExtension(E_StableMarshaler) + proto.RegisterExtension(E_Sizer) + proto.RegisterExtension(E_UnsafeMarshaler) + proto.RegisterExtension(E_UnsafeUnmarshaler) + proto.RegisterExtension(E_GoprotoExtensionsMap) + proto.RegisterExtension(E_GoprotoUnrecognized) + proto.RegisterExtension(E_Protosizer) + proto.RegisterExtension(E_Compare) + proto.RegisterExtension(E_Nullable) + proto.RegisterExtension(E_Embed) + proto.RegisterExtension(E_Customtype) + proto.RegisterExtension(E_Customname) + proto.RegisterExtension(E_Jsontag) + proto.RegisterExtension(E_Moretags) + proto.RegisterExtension(E_Casttype) + proto.RegisterExtension(E_Castkey) + proto.RegisterExtension(E_Castvalue) +} + +func init() { proto.RegisterFile("gogo.proto", fileDescriptorGogo) } + +var fileDescriptorGogo = []byte{ + // 1098 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x97, 0xc9, 0x6f, 0x1c, 0x45, + 0x14, 0x87, 0x85, 0x70, 0xe4, 0x99, 0xe7, 0x0d, 0x8f, 0x8d, 0x09, 0x11, 0x88, 0xe4, 0xc6, 0xc9, + 0x39, 0x45, 0x28, 0x65, 0x45, 0x96, 0x63, 0x39, 0xa3, 0x20, 0x0c, 0x23, 0x13, 0x07, 0x10, 0x87, + 0x51, 0xcf, 0xb8, 0xdc, 0x19, 0xe8, 0xee, 0x6a, 0xba, 0xba, 0xa3, 0x38, 0x37, 0x14, 0x16, 0x21, + 0xc4, 0x8e, 0x04, 0x09, 0x09, 0xcb, 0x81, 0x7d, 0x0d, 0xcb, 0x9d, 0x0b, 0x70, 0xe6, 0x7f, 0xe0, + 0x02, 0x98, 0x4d, 0xf2, 0xcd, 0x17, 0xf4, 0xba, 0xdf, 0xeb, 0xa9, 0x1e, 0x8f, 0x54, 0x35, 0xb7, + 0xf6, 0xb8, 0xbe, 0x6f, 0xaa, 0xdf, 0xeb, 0x7a, 0xbf, 0x69, 0x00, 0x5f, 0xf9, 0x6a, 0x31, 0x4e, + 0x54, 0xaa, 0x1a, 0x75, 0xbc, 0xce, 0x2f, 0x8f, 0x1c, 0xf5, 0x95, 0xf2, 0x03, 0x79, 0x3c, 0xff, + 0xab, 0x93, 0x6d, 0x1f, 0xdf, 0x92, 0xba, 0x9b, 0xf4, 0xe2, 0x54, 0x25, 0xc5, 0x62, 0xf1, 0x20, + 0xcc, 0xd1, 0xe2, 0xb6, 0x8c, 0xb2, 0xb0, 0x1d, 0x27, 0x72, 0xbb, 0x77, 0xa9, 0x71, 0xd7, 0x62, + 0x41, 0x2e, 0x32, 0xb9, 0xb8, 0x16, 0x65, 0xe1, 0x43, 0x71, 0xda, 0x53, 0x91, 0x3e, 0x7c, 0xf3, + 0xb7, 0x5b, 0x8f, 0xde, 0x72, 0x6f, 0x6d, 0x63, 0x96, 0x50, 0xfc, 0x5f, 0x2b, 0x07, 0xc5, 0x06, + 0xdc, 0x5e, 0xf1, 0xe9, 0x34, 0xe9, 0x45, 0xbe, 0x4c, 0x2c, 0xc6, 0x9f, 0xc8, 0x38, 0x67, 0x18, + 0x1f, 0x26, 0x54, 0xac, 0xc2, 0xd4, 0x28, 0xae, 0x9f, 0xc9, 0x35, 0x29, 0x4d, 0x49, 0x13, 0x66, + 0x72, 0x49, 0x37, 0xd3, 0xa9, 0x0a, 0x23, 0x2f, 0x94, 0x16, 0xcd, 0x2f, 0xb9, 0xa6, 0xbe, 0x31, + 0x8d, 0xd8, 0x6a, 0x49, 0x89, 0xf3, 0x30, 0x8f, 0x9f, 0x5c, 0xf4, 0x82, 0x4c, 0x9a, 0xb6, 0x63, + 0x43, 0x6d, 0xe7, 0x71, 0x19, 0x2b, 0x7f, 0xbd, 0x32, 0x96, 0x2b, 0xe7, 0x4a, 0x81, 0xe1, 0x35, + 0x3a, 0xe1, 0xcb, 0x34, 0x95, 0x89, 0x6e, 0x7b, 0x41, 0x30, 0x64, 0x93, 0x67, 0x7a, 0x41, 0x69, + 0xbc, 0xba, 0x5b, 0xed, 0x44, 0xb3, 0x20, 0x57, 0x82, 0x40, 0x6c, 0xc2, 0x1d, 0x43, 0x3a, 0xeb, + 0xe0, 0xbc, 0x46, 0xce, 0xf9, 0x03, 0xdd, 0x45, 0x6d, 0x0b, 0xf8, 0xf3, 0xb2, 0x1f, 0x0e, 0xce, + 0x77, 0xc8, 0xd9, 0x20, 0x96, 0xdb, 0x82, 0xc6, 0xfb, 0x61, 0xf6, 0xa2, 0x4c, 0x3a, 0x4a, 0xcb, + 0xb6, 0x7c, 0x2a, 0xf3, 0x02, 0x07, 0xdd, 0x75, 0xd2, 0xcd, 0x10, 0xb8, 0x86, 0x1c, 0xba, 0x4e, + 0x42, 0x6d, 0xdb, 0xeb, 0x4a, 0x07, 0xc5, 0x0d, 0x52, 0x8c, 0xe3, 0x7a, 0x44, 0x57, 0x60, 0xd2, + 0x57, 0xc5, 0x2d, 0x39, 0xe0, 0xef, 0x12, 0x3e, 0xc1, 0x0c, 0x29, 0x62, 0x15, 0x67, 0x81, 0x97, + 0xba, 0xec, 0xe0, 0x3d, 0x56, 0x30, 0x43, 0x8a, 0x11, 0xca, 0xfa, 0x3e, 0x2b, 0xb4, 0x51, 0xcf, + 0x65, 0x98, 0x50, 0x51, 0xb0, 0xa3, 0x22, 0x97, 0x4d, 0x7c, 0x40, 0x06, 0x20, 0x04, 0x05, 0x4b, + 0x50, 0x77, 0x6d, 0xc4, 0x87, 0x84, 0xd7, 0x24, 0x77, 0xa0, 0x09, 0x33, 0x3c, 0x64, 0x7a, 0x2a, + 0x72, 0x50, 0x7c, 0x44, 0x8a, 0x69, 0x03, 0xa3, 0xdb, 0x48, 0xa5, 0x4e, 0x7d, 0xe9, 0x22, 0xf9, + 0x98, 0x6f, 0x83, 0x10, 0x2a, 0x65, 0x47, 0x46, 0xdd, 0x0b, 0x6e, 0x86, 0x4f, 0xb8, 0x94, 0xcc, + 0xa0, 0x62, 0x15, 0xa6, 0x42, 0x2f, 0xd1, 0x17, 0xbc, 0xc0, 0xa9, 0x1d, 0x9f, 0x92, 0x63, 0xb2, + 0x84, 0xa8, 0x22, 0x59, 0x34, 0x8a, 0xe6, 0x33, 0xae, 0x88, 0x81, 0xd1, 0xd1, 0xd3, 0xa9, 0xd7, + 0x09, 0x64, 0x7b, 0x14, 0xdb, 0xe7, 0x7c, 0xf4, 0x0a, 0x76, 0xdd, 0x34, 0x2e, 0x41, 0x5d, 0xf7, + 0x2e, 0x3b, 0x69, 0xbe, 0xe0, 0x4e, 0xe7, 0x00, 0xc2, 0x8f, 0xc1, 0x9d, 0x43, 0x47, 0xbd, 0x83, + 0xec, 0x4b, 0x92, 0x2d, 0x0c, 0x19, 0xf7, 0x34, 0x12, 0x46, 0x55, 0x7e, 0xc5, 0x23, 0x41, 0x0e, + 0xb8, 0x5a, 0x30, 0x9f, 0x45, 0xda, 0xdb, 0x1e, 0xad, 0x6a, 0x5f, 0x73, 0xd5, 0x0a, 0xb6, 0x52, + 0xb5, 0x73, 0xb0, 0x40, 0xc6, 0xd1, 0xfa, 0xfa, 0x0d, 0x0f, 0xd6, 0x82, 0xde, 0xac, 0x76, 0xf7, + 0x71, 0x38, 0x52, 0x96, 0xf3, 0x52, 0x2a, 0x23, 0x8d, 0x4c, 0x3b, 0xf4, 0x62, 0x07, 0xf3, 0x4d, + 0x32, 0xf3, 0xc4, 0x5f, 0x2b, 0x05, 0xeb, 0x5e, 0x8c, 0xf2, 0x47, 0xe1, 0x30, 0xcb, 0xb3, 0x28, + 0x91, 0x5d, 0xe5, 0x47, 0xbd, 0xcb, 0x72, 0xcb, 0x41, 0xfd, 0xed, 0x40, 0xab, 0x36, 0x0d, 0x1c, + 0xcd, 0x67, 0xe1, 0xb6, 0xf2, 0xf7, 0x46, 0xbb, 0x17, 0xc6, 0x2a, 0x49, 0x2d, 0xc6, 0xef, 0xb8, + 0x53, 0x25, 0x77, 0x36, 0xc7, 0xc4, 0x1a, 0x4c, 0xe7, 0x7f, 0xba, 0x3e, 0x92, 0xdf, 0x93, 0x68, + 0xaa, 0x4f, 0xd1, 0xe0, 0xe8, 0xaa, 0x30, 0xf6, 0x12, 0x97, 0xf9, 0xf7, 0x03, 0x0f, 0x0e, 0x42, + 0x8a, 0xa7, 0x6f, 0x66, 0x20, 0x89, 0x1b, 0xf7, 0x1c, 0x90, 0xac, 0x4b, 0xad, 0x3d, 0xbf, 0xf4, + 0x3c, 0xbd, 0x47, 0x67, 0xb6, 0x1a, 0xc4, 0xe2, 0x01, 0x2c, 0x4f, 0x35, 0x2e, 0xed, 0xb2, 0x2b, + 0x7b, 0x65, 0x85, 0x2a, 0x69, 0x29, 0xce, 0xc0, 0x54, 0x25, 0x2a, 0xed, 0xaa, 0x67, 0x48, 0x35, + 0x69, 0x26, 0xa5, 0x38, 0x01, 0x63, 0x18, 0x7b, 0x76, 0xfc, 0x59, 0xc2, 0xf3, 0xe5, 0xe2, 0x14, + 0xd4, 0x38, 0xee, 0xec, 0xe8, 0x73, 0x84, 0x96, 0x08, 0xe2, 0x1c, 0x75, 0x76, 0xfc, 0x79, 0xc6, + 0x19, 0x41, 0xdc, 0xbd, 0x84, 0x3f, 0xbe, 0x38, 0x46, 0xe3, 0x8a, 0x6b, 0xb7, 0x04, 0xe3, 0x94, + 0x71, 0x76, 0xfa, 0x05, 0xfa, 0x72, 0x26, 0xc4, 0x7d, 0x70, 0xc8, 0xb1, 0xe0, 0x2f, 0x11, 0x5a, + 0xac, 0x17, 0xab, 0x30, 0x61, 0xe4, 0x9a, 0x1d, 0x7f, 0x99, 0x70, 0x93, 0xc2, 0xad, 0x53, 0xae, + 0xd9, 0x05, 0xaf, 0xf0, 0xd6, 0x89, 0xc0, 0xb2, 0x71, 0xa4, 0xd9, 0xe9, 0x57, 0xb9, 0xea, 0x8c, + 0x88, 0x65, 0xa8, 0x97, 0x63, 0xca, 0xce, 0xbf, 0x46, 0x7c, 0x9f, 0xc1, 0x0a, 0x18, 0x63, 0xd2, + 0xae, 0x78, 0x9d, 0x2b, 0x60, 0x50, 0x78, 0x8c, 0x06, 0xa3, 0xcf, 0x6e, 0x7a, 0x83, 0x8f, 0xd1, + 0x40, 0xf2, 0x61, 0x37, 0xf3, 0x69, 0x61, 0x57, 0xbc, 0xc9, 0xdd, 0xcc, 0xd7, 0xe3, 0x36, 0x06, + 0xb3, 0xc4, 0xee, 0x78, 0x8b, 0xb7, 0x31, 0x10, 0x25, 0xa2, 0x05, 0x8d, 0x83, 0x39, 0x62, 0xf7, + 0xbd, 0x4d, 0xbe, 0xd9, 0x03, 0x31, 0x22, 0x1e, 0x81, 0x85, 0xe1, 0x19, 0x62, 0xb7, 0x5e, 0xdd, + 0x1b, 0xf8, 0xd5, 0x6f, 0x46, 0x88, 0x38, 0xd7, 0xff, 0xd5, 0x6f, 0xe6, 0x87, 0x5d, 0x7b, 0x6d, + 0xaf, 0xfa, 0x62, 0x67, 0xc6, 0x87, 0x58, 0x01, 0xe8, 0x8f, 0x6e, 0xbb, 0xeb, 0x3a, 0xb9, 0x0c, + 0x08, 0x8f, 0x06, 0x4d, 0x6e, 0x3b, 0x7f, 0x83, 0x8f, 0x06, 0x11, 0x62, 0x09, 0x6a, 0x51, 0x16, + 0x04, 0xf8, 0x70, 0x34, 0xee, 0x1e, 0x12, 0x13, 0x32, 0xd8, 0x62, 0xf6, 0xf7, 0x7d, 0x3a, 0x18, + 0x0c, 0x88, 0x13, 0x70, 0x48, 0x86, 0x1d, 0xb9, 0x65, 0x23, 0xff, 0xd8, 0xe7, 0x81, 0x80, 0xab, + 0xc5, 0x32, 0x40, 0xf1, 0xd2, 0x98, 0xee, 0xc4, 0xd6, 0x6f, 0xfd, 0x73, 0xbf, 0x78, 0x07, 0x35, + 0x90, 0xbe, 0x20, 0x7f, 0xeb, 0xb4, 0x08, 0x76, 0xab, 0x82, 0xfc, 0x45, 0xf3, 0x24, 0x8c, 0x3f, + 0xa1, 0x55, 0x94, 0x7a, 0xbe, 0x8d, 0xfe, 0x8b, 0x68, 0x5e, 0x8f, 0x05, 0x0b, 0x55, 0x22, 0x53, + 0xcf, 0xd7, 0x36, 0xf6, 0x6f, 0x62, 0x4b, 0x00, 0xe1, 0xae, 0xa7, 0x53, 0x97, 0xfb, 0xfe, 0x87, + 0x61, 0x06, 0x70, 0xd3, 0x78, 0xfd, 0xa4, 0xdc, 0xb1, 0xb1, 0xff, 0xf2, 0xa6, 0x69, 0xbd, 0x38, + 0x05, 0x75, 0xbc, 0xcc, 0xdf, 0xb7, 0x6d, 0xf0, 0x7f, 0x04, 0xf7, 0x89, 0xd3, 0xc7, 0x60, 0xae, + 0xab, 0xc2, 0x41, 0xec, 0x34, 0x34, 0x55, 0x53, 0xb5, 0xf2, 0x07, 0xf1, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x87, 0x5c, 0xee, 0x2b, 0x7e, 0x11, 0x00, 0x00, +} diff --git a/vendor/github.com/gogo/protobuf/gogoproto/helper.go b/vendor/github.com/gogo/protobuf/gogoproto/helper.go new file mode 100644 index 00000000..670021fe --- /dev/null +++ b/vendor/github.com/gogo/protobuf/gogoproto/helper.go @@ -0,0 +1,310 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package gogoproto + +import google_protobuf "github.com/gogo/protobuf/protoc-gen-gogo/descriptor" +import proto "github.com/gogo/protobuf/proto" + +func IsEmbed(field *google_protobuf.FieldDescriptorProto) bool { + return proto.GetBoolExtension(field.Options, E_Embed, false) +} + +func IsNullable(field *google_protobuf.FieldDescriptorProto) bool { + return proto.GetBoolExtension(field.Options, E_Nullable, true) +} + +func NeedsNilCheck(proto3 bool, field *google_protobuf.FieldDescriptorProto) bool { + nullable := IsNullable(field) + if field.IsMessage() || IsCustomType(field) { + return nullable + } + if proto3 { + return false + } + return nullable || *field.Type == google_protobuf.FieldDescriptorProto_TYPE_BYTES +} + +func IsCustomType(field *google_protobuf.FieldDescriptorProto) bool { + typ := GetCustomType(field) + if len(typ) > 0 { + return true + } + return false +} + +func IsCastType(field *google_protobuf.FieldDescriptorProto) bool { + typ := GetCastType(field) + if len(typ) > 0 { + return true + } + return false +} + +func IsCastKey(field *google_protobuf.FieldDescriptorProto) bool { + typ := GetCastKey(field) + if len(typ) > 0 { + return true + } + return false +} + +func IsCastValue(field *google_protobuf.FieldDescriptorProto) bool { + typ := GetCastValue(field) + if len(typ) > 0 { + return true + } + return false +} + +func GetCustomType(field *google_protobuf.FieldDescriptorProto) string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Customtype) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetCastType(field *google_protobuf.FieldDescriptorProto) string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Casttype) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetCastKey(field *google_protobuf.FieldDescriptorProto) string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Castkey) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetCastValue(field *google_protobuf.FieldDescriptorProto) string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Castvalue) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func IsCustomName(field *google_protobuf.FieldDescriptorProto) bool { + name := GetCustomName(field) + if len(name) > 0 { + return true + } + return false +} + +func IsEnumCustomName(field *google_protobuf.EnumDescriptorProto) bool { + name := GetEnumCustomName(field) + if len(name) > 0 { + return true + } + return false +} + +func IsEnumValueCustomName(field *google_protobuf.EnumValueDescriptorProto) bool { + name := GetEnumValueCustomName(field) + if len(name) > 0 { + return true + } + return false +} + +func GetCustomName(field *google_protobuf.FieldDescriptorProto) string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Customname) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetEnumCustomName(field *google_protobuf.EnumDescriptorProto) string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_EnumCustomname) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetEnumValueCustomName(field *google_protobuf.EnumValueDescriptorProto) string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_EnumvalueCustomname) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetJsonTag(field *google_protobuf.FieldDescriptorProto) *string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Jsontag) + if err == nil && v.(*string) != nil { + return (v.(*string)) + } + } + return nil +} + +func GetMoreTags(field *google_protobuf.FieldDescriptorProto) *string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Moretags) + if err == nil && v.(*string) != nil { + return (v.(*string)) + } + } + return nil +} + +type EnableFunc func(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool + +func EnabledGoEnumPrefix(file *google_protobuf.FileDescriptorProto, enum *google_protobuf.EnumDescriptorProto) bool { + return proto.GetBoolExtension(enum.Options, E_GoprotoEnumPrefix, proto.GetBoolExtension(file.Options, E_GoprotoEnumPrefixAll, true)) +} + +func EnabledGoStringer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_GoprotoStringer, proto.GetBoolExtension(file.Options, E_GoprotoStringerAll, true)) +} + +func HasGoGetters(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_GoprotoGetters, proto.GetBoolExtension(file.Options, E_GoprotoGettersAll, true)) +} + +func IsUnion(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Onlyone, proto.GetBoolExtension(file.Options, E_OnlyoneAll, false)) +} + +func HasGoString(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Gostring, proto.GetBoolExtension(file.Options, E_GostringAll, false)) +} + +func HasEqual(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Equal, proto.GetBoolExtension(file.Options, E_EqualAll, false)) +} + +func HasVerboseEqual(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_VerboseEqual, proto.GetBoolExtension(file.Options, E_VerboseEqualAll, false)) +} + +func IsStringer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Stringer, proto.GetBoolExtension(file.Options, E_StringerAll, false)) +} + +func IsFace(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Face, proto.GetBoolExtension(file.Options, E_FaceAll, false)) +} + +func HasDescription(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Description, proto.GetBoolExtension(file.Options, E_DescriptionAll, false)) +} + +func HasPopulate(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Populate, proto.GetBoolExtension(file.Options, E_PopulateAll, false)) +} + +func HasTestGen(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Testgen, proto.GetBoolExtension(file.Options, E_TestgenAll, false)) +} + +func HasBenchGen(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Benchgen, proto.GetBoolExtension(file.Options, E_BenchgenAll, false)) +} + +func IsMarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Marshaler, proto.GetBoolExtension(file.Options, E_MarshalerAll, false)) +} + +func IsUnmarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Unmarshaler, proto.GetBoolExtension(file.Options, E_UnmarshalerAll, false)) +} + +func IsStableMarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_StableMarshaler, proto.GetBoolExtension(file.Options, E_StableMarshalerAll, false)) +} + +func IsSizer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Sizer, proto.GetBoolExtension(file.Options, E_SizerAll, false)) +} + +func IsProtoSizer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Protosizer, proto.GetBoolExtension(file.Options, E_ProtosizerAll, false)) +} + +func IsGoEnumStringer(file *google_protobuf.FileDescriptorProto, enum *google_protobuf.EnumDescriptorProto) bool { + return proto.GetBoolExtension(enum.Options, E_GoprotoEnumStringer, proto.GetBoolExtension(file.Options, E_GoprotoEnumStringerAll, true)) +} + +func IsEnumStringer(file *google_protobuf.FileDescriptorProto, enum *google_protobuf.EnumDescriptorProto) bool { + return proto.GetBoolExtension(enum.Options, E_EnumStringer, proto.GetBoolExtension(file.Options, E_EnumStringerAll, false)) +} + +func IsUnsafeMarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_UnsafeMarshaler, proto.GetBoolExtension(file.Options, E_UnsafeMarshalerAll, false)) +} + +func IsUnsafeUnmarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_UnsafeUnmarshaler, proto.GetBoolExtension(file.Options, E_UnsafeUnmarshalerAll, false)) +} + +func HasExtensionsMap(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_GoprotoExtensionsMap, proto.GetBoolExtension(file.Options, E_GoprotoExtensionsMapAll, true)) +} + +func HasUnrecognized(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + if IsProto3(file) { + return false + } + return proto.GetBoolExtension(message.Options, E_GoprotoUnrecognized, proto.GetBoolExtension(file.Options, E_GoprotoUnrecognizedAll, true)) +} + +func IsProto3(file *google_protobuf.FileDescriptorProto) bool { + return file.GetSyntax() == "proto3" +} + +func ImportsGoGoProto(file *google_protobuf.FileDescriptorProto) bool { + return proto.GetBoolExtension(file.Options, E_GogoprotoImport, true) +} + +func HasCompare(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Compare, proto.GetBoolExtension(file.Options, E_CompareAll, false)) +} diff --git a/vendor/github.com/gogo/protobuf/proto/clone.go b/vendor/github.com/gogo/protobuf/proto/clone.go new file mode 100644 index 00000000..5d4cba4b --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/clone.go @@ -0,0 +1,234 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Protocol buffer deep copy and merge. +// TODO: RawMessage. + +package proto + +import ( + "log" + "reflect" + "strings" +) + +// Clone returns a deep copy of a protocol buffer. +func Clone(pb Message) Message { + in := reflect.ValueOf(pb) + if in.IsNil() { + return pb + } + + out := reflect.New(in.Type().Elem()) + // out is empty so a merge is a deep copy. + mergeStruct(out.Elem(), in.Elem()) + return out.Interface().(Message) +} + +// Merge merges src into dst. +// Required and optional fields that are set in src will be set to that value in dst. +// Elements of repeated fields will be appended. +// Merge panics if src and dst are not the same type, or if dst is nil. +func Merge(dst, src Message) { + in := reflect.ValueOf(src) + out := reflect.ValueOf(dst) + if out.IsNil() { + panic("proto: nil destination") + } + if in.Type() != out.Type() { + // Explicit test prior to mergeStruct so that mistyped nils will fail + panic("proto: type mismatch") + } + if in.IsNil() { + // Merging nil into non-nil is a quiet no-op + return + } + mergeStruct(out.Elem(), in.Elem()) +} + +func mergeStruct(out, in reflect.Value) { + sprop := GetProperties(in.Type()) + for i := 0; i < in.NumField(); i++ { + f := in.Type().Field(i) + if strings.HasPrefix(f.Name, "XXX_") { + continue + } + mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i]) + } + + if emIn, ok := in.Addr().Interface().(extensionsBytes); ok { + emOut := out.Addr().Interface().(extensionsBytes) + bIn := emIn.GetExtensions() + bOut := emOut.GetExtensions() + *bOut = append(*bOut, *bIn...) + } else if emIn, ok := extendable(in.Addr().Interface()); ok { + emOut, _ := extendable(out.Addr().Interface()) + mIn, muIn := emIn.extensionsRead() + if mIn != nil { + mOut := emOut.extensionsWrite() + muIn.Lock() + mergeExtension(mOut, mIn) + muIn.Unlock() + } + } + + uf := in.FieldByName("XXX_unrecognized") + if !uf.IsValid() { + return + } + uin := uf.Bytes() + if len(uin) > 0 { + out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...)) + } +} + +// mergeAny performs a merge between two values of the same type. +// viaPtr indicates whether the values were indirected through a pointer (implying proto2). +// prop is set if this is a struct field (it may be nil). +func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) { + if in.Type() == protoMessageType { + if !in.IsNil() { + if out.IsNil() { + out.Set(reflect.ValueOf(Clone(in.Interface().(Message)))) + } else { + Merge(out.Interface().(Message), in.Interface().(Message)) + } + } + return + } + switch in.Kind() { + case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, + reflect.String, reflect.Uint32, reflect.Uint64: + if !viaPtr && isProto3Zero(in) { + return + } + out.Set(in) + case reflect.Interface: + // Probably a oneof field; copy non-nil values. + if in.IsNil() { + return + } + // Allocate destination if it is not set, or set to a different type. + // Otherwise we will merge as normal. + if out.IsNil() || out.Elem().Type() != in.Elem().Type() { + out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T) + } + mergeAny(out.Elem(), in.Elem(), false, nil) + case reflect.Map: + if in.Len() == 0 { + return + } + if out.IsNil() { + out.Set(reflect.MakeMap(in.Type())) + } + // For maps with value types of *T or []byte we need to deep copy each value. + elemKind := in.Type().Elem().Kind() + for _, key := range in.MapKeys() { + var val reflect.Value + switch elemKind { + case reflect.Ptr: + val = reflect.New(in.Type().Elem().Elem()) + mergeAny(val, in.MapIndex(key), false, nil) + case reflect.Slice: + val = in.MapIndex(key) + val = reflect.ValueOf(append([]byte{}, val.Bytes()...)) + default: + val = in.MapIndex(key) + } + out.SetMapIndex(key, val) + } + case reflect.Ptr: + if in.IsNil() { + return + } + if out.IsNil() { + out.Set(reflect.New(in.Elem().Type())) + } + mergeAny(out.Elem(), in.Elem(), true, nil) + case reflect.Slice: + if in.IsNil() { + return + } + if in.Type().Elem().Kind() == reflect.Uint8 { + // []byte is a scalar bytes field, not a repeated field. + + // Edge case: if this is in a proto3 message, a zero length + // bytes field is considered the zero value, and should not + // be merged. + if prop != nil && prop.proto3 && in.Len() == 0 { + return + } + + // Make a deep copy. + // Append to []byte{} instead of []byte(nil) so that we never end up + // with a nil result. + out.SetBytes(append([]byte{}, in.Bytes()...)) + return + } + n := in.Len() + if out.IsNil() { + out.Set(reflect.MakeSlice(in.Type(), 0, n)) + } + switch in.Type().Elem().Kind() { + case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, + reflect.String, reflect.Uint32, reflect.Uint64: + out.Set(reflect.AppendSlice(out, in)) + default: + for i := 0; i < n; i++ { + x := reflect.Indirect(reflect.New(in.Type().Elem())) + mergeAny(x, in.Index(i), false, nil) + out.Set(reflect.Append(out, x)) + } + } + case reflect.Struct: + mergeStruct(out, in) + default: + // unknown type, so not a protocol buffer + log.Printf("proto: don't know how to copy %v", in) + } +} + +func mergeExtension(out, in map[int32]Extension) { + for extNum, eIn := range in { + eOut := Extension{desc: eIn.desc} + if eIn.value != nil { + v := reflect.New(reflect.TypeOf(eIn.value)).Elem() + mergeAny(v, reflect.ValueOf(eIn.value), false, nil) + eOut.value = v.Interface() + } + if eIn.enc != nil { + eOut.enc = make([]byte, len(eIn.enc)) + copy(eOut.enc, eIn.enc) + } + + out[extNum] = eOut + } +} diff --git a/vendor/github.com/gogo/protobuf/proto/decode.go b/vendor/github.com/gogo/protobuf/proto/decode.go new file mode 100644 index 00000000..0d6634cc --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/decode.go @@ -0,0 +1,882 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Routines for decoding protocol buffer data to construct in-memory representations. + */ + +import ( + "errors" + "fmt" + "io" + "os" + "reflect" +) + +// errOverflow is returned when an integer is too large to be represented. +var errOverflow = errors.New("proto: integer overflow") + +// ErrInternalBadWireType is returned by generated code when an incorrect +// wire type is encountered. It does not get returned to user code. +var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof") + +// The fundamental decoders that interpret bytes on the wire. +// Those that take integer types all return uint64 and are +// therefore of type valueDecoder. + +// DecodeVarint reads a varint-encoded integer from the slice. +// It returns the integer and the number of bytes consumed, or +// zero if there is not enough. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func DecodeVarint(buf []byte) (x uint64, n int) { + // x, n already 0 + for shift := uint(0); shift < 64; shift += 7 { + if n >= len(buf) { + return 0, 0 + } + b := uint64(buf[n]) + n++ + x |= (b & 0x7F) << shift + if (b & 0x80) == 0 { + return x, n + } + } + + // The number is too large to represent in a 64-bit value. + return 0, 0 +} + +// DecodeVarint reads a varint-encoded integer from the Buffer. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func (p *Buffer) DecodeVarint() (x uint64, err error) { + // x, err already 0 + + i := p.index + l := len(p.buf) + + for shift := uint(0); shift < 64; shift += 7 { + if i >= l { + err = io.ErrUnexpectedEOF + return + } + b := p.buf[i] + i++ + x |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + p.index = i + return + } + } + + // The number is too large to represent in a 64-bit value. + err = errOverflow + return +} + +// DecodeFixed64 reads a 64-bit integer from the Buffer. +// This is the format for the +// fixed64, sfixed64, and double protocol buffer types. +func (p *Buffer) DecodeFixed64() (x uint64, err error) { + // x, err already 0 + i := p.index + 8 + if i < 0 || i > len(p.buf) { + err = io.ErrUnexpectedEOF + return + } + p.index = i + + x = uint64(p.buf[i-8]) + x |= uint64(p.buf[i-7]) << 8 + x |= uint64(p.buf[i-6]) << 16 + x |= uint64(p.buf[i-5]) << 24 + x |= uint64(p.buf[i-4]) << 32 + x |= uint64(p.buf[i-3]) << 40 + x |= uint64(p.buf[i-2]) << 48 + x |= uint64(p.buf[i-1]) << 56 + return +} + +// DecodeFixed32 reads a 32-bit integer from the Buffer. +// This is the format for the +// fixed32, sfixed32, and float protocol buffer types. +func (p *Buffer) DecodeFixed32() (x uint64, err error) { + // x, err already 0 + i := p.index + 4 + if i < 0 || i > len(p.buf) { + err = io.ErrUnexpectedEOF + return + } + p.index = i + + x = uint64(p.buf[i-4]) + x |= uint64(p.buf[i-3]) << 8 + x |= uint64(p.buf[i-2]) << 16 + x |= uint64(p.buf[i-1]) << 24 + return +} + +// DecodeZigzag64 reads a zigzag-encoded 64-bit integer +// from the Buffer. +// This is the format used for the sint64 protocol buffer type. +func (p *Buffer) DecodeZigzag64() (x uint64, err error) { + x, err = p.DecodeVarint() + if err != nil { + return + } + x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63) + return +} + +// DecodeZigzag32 reads a zigzag-encoded 32-bit integer +// from the Buffer. +// This is the format used for the sint32 protocol buffer type. +func (p *Buffer) DecodeZigzag32() (x uint64, err error) { + x, err = p.DecodeVarint() + if err != nil { + return + } + x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31)) + return +} + +// These are not ValueDecoders: they produce an array of bytes or a string. +// bytes, embedded messages + +// DecodeRawBytes reads a count-delimited byte buffer from the Buffer. +// This is the format used for the bytes protocol buffer +// type and for embedded messages. +func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) { + n, err := p.DecodeVarint() + if err != nil { + return nil, err + } + + nb := int(n) + if nb < 0 { + return nil, fmt.Errorf("proto: bad byte length %d", nb) + } + end := p.index + nb + if end < p.index || end > len(p.buf) { + return nil, io.ErrUnexpectedEOF + } + + if !alloc { + // todo: check if can get more uses of alloc=false + buf = p.buf[p.index:end] + p.index += nb + return + } + + buf = make([]byte, nb) + copy(buf, p.buf[p.index:]) + p.index += nb + return +} + +// DecodeStringBytes reads an encoded string from the Buffer. +// This is the format used for the proto2 string type. +func (p *Buffer) DecodeStringBytes() (s string, err error) { + buf, err := p.DecodeRawBytes(false) + if err != nil { + return + } + return string(buf), nil +} + +// Skip the next item in the buffer. Its wire type is decoded and presented as an argument. +// If the protocol buffer has extensions, and the field matches, add it as an extension. +// Otherwise, if the XXX_unrecognized field exists, append the skipped data there. +func (o *Buffer) skipAndSave(t reflect.Type, tag, wire int, base structPointer, unrecField field) error { + oi := o.index + + err := o.skip(t, tag, wire) + if err != nil { + return err + } + + if !unrecField.IsValid() { + return nil + } + + ptr := structPointer_Bytes(base, unrecField) + + // Add the skipped field to struct field + obuf := o.buf + + o.buf = *ptr + o.EncodeVarint(uint64(tag<<3 | wire)) + *ptr = append(o.buf, obuf[oi:o.index]...) + + o.buf = obuf + + return nil +} + +// Skip the next item in the buffer. Its wire type is decoded and presented as an argument. +func (o *Buffer) skip(t reflect.Type, tag, wire int) error { + + var u uint64 + var err error + + switch wire { + case WireVarint: + _, err = o.DecodeVarint() + case WireFixed64: + _, err = o.DecodeFixed64() + case WireBytes: + _, err = o.DecodeRawBytes(false) + case WireFixed32: + _, err = o.DecodeFixed32() + case WireStartGroup: + for { + u, err = o.DecodeVarint() + if err != nil { + break + } + fwire := int(u & 0x7) + if fwire == WireEndGroup { + break + } + ftag := int(u >> 3) + err = o.skip(t, ftag, fwire) + if err != nil { + break + } + } + default: + err = fmt.Errorf("proto: can't skip unknown wire type %d for %s", wire, t) + } + return err +} + +// Unmarshaler is the interface representing objects that can +// unmarshal themselves. The method should reset the receiver before +// decoding starts. The argument points to data that may be +// overwritten, so implementations should not keep references to the +// buffer. +type Unmarshaler interface { + Unmarshal([]byte) error +} + +// Unmarshal parses the protocol buffer representation in buf and places the +// decoded result in pb. If the struct underlying pb does not match +// the data in buf, the results can be unpredictable. +// +// Unmarshal resets pb before starting to unmarshal, so any +// existing data in pb is always removed. Use UnmarshalMerge +// to preserve and append to existing data. +func Unmarshal(buf []byte, pb Message) error { + pb.Reset() + return UnmarshalMerge(buf, pb) +} + +// UnmarshalMerge parses the protocol buffer representation in buf and +// writes the decoded result to pb. If the struct underlying pb does not match +// the data in buf, the results can be unpredictable. +// +// UnmarshalMerge merges into existing data in pb. +// Most code should use Unmarshal instead. +func UnmarshalMerge(buf []byte, pb Message) error { + // If the object can unmarshal itself, let it. + if u, ok := pb.(Unmarshaler); ok { + return u.Unmarshal(buf) + } + return NewBuffer(buf).Unmarshal(pb) +} + +// DecodeMessage reads a count-delimited message from the Buffer. +func (p *Buffer) DecodeMessage(pb Message) error { + enc, err := p.DecodeRawBytes(false) + if err != nil { + return err + } + return NewBuffer(enc).Unmarshal(pb) +} + +// DecodeGroup reads a tag-delimited group from the Buffer. +func (p *Buffer) DecodeGroup(pb Message) error { + typ, base, err := getbase(pb) + if err != nil { + return err + } + return p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), true, base) +} + +// Unmarshal parses the protocol buffer representation in the +// Buffer and places the decoded result in pb. If the struct +// underlying pb does not match the data in the buffer, the results can be +// unpredictable. +func (p *Buffer) Unmarshal(pb Message) error { + // If the object can unmarshal itself, let it. + if u, ok := pb.(Unmarshaler); ok { + err := u.Unmarshal(p.buf[p.index:]) + p.index = len(p.buf) + return err + } + + typ, base, err := getbase(pb) + if err != nil { + return err + } + + err = p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), false, base) + + if collectStats { + stats.Decode++ + } + + return err +} + +// unmarshalType does the work of unmarshaling a structure. +func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group bool, base structPointer) error { + var state errorState + required, reqFields := prop.reqCount, uint64(0) + + var err error + for err == nil && o.index < len(o.buf) { + oi := o.index + var u uint64 + u, err = o.DecodeVarint() + if err != nil { + break + } + wire := int(u & 0x7) + if wire == WireEndGroup { + if is_group { + if required > 0 { + // Not enough information to determine the exact field. + // (See below.) + return &RequiredNotSetError{"{Unknown}"} + } + return nil // input is satisfied + } + return fmt.Errorf("proto: %s: wiretype end group for non-group", st) + } + tag := int(u >> 3) + if tag <= 0 { + return fmt.Errorf("proto: %s: illegal tag %d (wire type %d)", st, tag, wire) + } + fieldnum, ok := prop.decoderTags.get(tag) + if !ok { + // Maybe it's an extension? + if prop.extendable { + if e, eok := structPointer_Interface(base, st).(extensionsBytes); eok { + if isExtensionField(e, int32(tag)) { + if err = o.skip(st, tag, wire); err == nil { + ext := e.GetExtensions() + *ext = append(*ext, o.buf[oi:o.index]...) + } + continue + } + } else if e, _ := extendable(structPointer_Interface(base, st)); isExtensionField(e, int32(tag)) { + if err = o.skip(st, tag, wire); err == nil { + extmap := e.extensionsWrite() + ext := extmap[int32(tag)] // may be missing + ext.enc = append(ext.enc, o.buf[oi:o.index]...) + extmap[int32(tag)] = ext + } + continue + } + } + // Maybe it's a oneof? + if prop.oneofUnmarshaler != nil { + m := structPointer_Interface(base, st).(Message) + // First return value indicates whether tag is a oneof field. + ok, err = prop.oneofUnmarshaler(m, tag, wire, o) + if err == ErrInternalBadWireType { + // Map the error to something more descriptive. + // Do the formatting here to save generated code space. + err = fmt.Errorf("bad wiretype for oneof field in %T", m) + } + if ok { + continue + } + } + err = o.skipAndSave(st, tag, wire, base, prop.unrecField) + continue + } + p := prop.Prop[fieldnum] + + if p.dec == nil { + fmt.Fprintf(os.Stderr, "proto: no protobuf decoder for %s.%s\n", st, st.Field(fieldnum).Name) + continue + } + dec := p.dec + if wire != WireStartGroup && wire != p.WireType { + if wire == WireBytes && p.packedDec != nil { + // a packable field + dec = p.packedDec + } else { + err = fmt.Errorf("proto: bad wiretype for field %s.%s: got wiretype %d, want %d", st, st.Field(fieldnum).Name, wire, p.WireType) + continue + } + } + decErr := dec(o, p, base) + if decErr != nil && !state.shouldContinue(decErr, p) { + err = decErr + } + if err == nil && p.Required { + // Successfully decoded a required field. + if tag <= 64 { + // use bitmap for fields 1-64 to catch field reuse. + var mask uint64 = 1 << uint64(tag-1) + if reqFields&mask == 0 { + // new required field + reqFields |= mask + required-- + } + } else { + // This is imprecise. It can be fooled by a required field + // with a tag > 64 that is encoded twice; that's very rare. + // A fully correct implementation would require allocating + // a data structure, which we would like to avoid. + required-- + } + } + } + if err == nil { + if is_group { + return io.ErrUnexpectedEOF + } + if state.err != nil { + return state.err + } + if required > 0 { + // Not enough information to determine the exact field. If we use extra + // CPU, we could determine the field only if the missing required field + // has a tag <= 64 and we check reqFields. + return &RequiredNotSetError{"{Unknown}"} + } + } + return err +} + +// Individual type decoders +// For each, +// u is the decoded value, +// v is a pointer to the field (pointer) in the struct + +// Sizes of the pools to allocate inside the Buffer. +// The goal is modest amortization and allocation +// on at least 16-byte boundaries. +const ( + boolPoolSize = 16 + uint32PoolSize = 8 + uint64PoolSize = 4 +) + +// Decode a bool. +func (o *Buffer) dec_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + if len(o.bools) == 0 { + o.bools = make([]bool, boolPoolSize) + } + o.bools[0] = u != 0 + *structPointer_Bool(base, p.field) = &o.bools[0] + o.bools = o.bools[1:] + return nil +} + +func (o *Buffer) dec_proto3_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + *structPointer_BoolVal(base, p.field) = u != 0 + return nil +} + +// Decode an int32. +func (o *Buffer) dec_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word32_Set(structPointer_Word32(base, p.field), o, uint32(u)) + return nil +} + +func (o *Buffer) dec_proto3_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word32Val_Set(structPointer_Word32Val(base, p.field), uint32(u)) + return nil +} + +// Decode an int64. +func (o *Buffer) dec_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word64_Set(structPointer_Word64(base, p.field), o, u) + return nil +} + +func (o *Buffer) dec_proto3_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word64Val_Set(structPointer_Word64Val(base, p.field), o, u) + return nil +} + +// Decode a string. +func (o *Buffer) dec_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + *structPointer_String(base, p.field) = &s + return nil +} + +func (o *Buffer) dec_proto3_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + *structPointer_StringVal(base, p.field) = s + return nil +} + +// Decode a slice of bytes ([]byte). +func (o *Buffer) dec_slice_byte(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + *structPointer_Bytes(base, p.field) = b + return nil +} + +// Decode a slice of bools ([]bool). +func (o *Buffer) dec_slice_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + v := structPointer_BoolSlice(base, p.field) + *v = append(*v, u != 0) + return nil +} + +// Decode a slice of bools ([]bool) in packed format. +func (o *Buffer) dec_slice_packed_bool(p *Properties, base structPointer) error { + v := structPointer_BoolSlice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded bools + fin := o.index + nb + if fin < o.index { + return errOverflow + } + + y := *v + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + y = append(y, u != 0) + } + + *v = y + return nil +} + +// Decode a slice of int32s ([]int32). +func (o *Buffer) dec_slice_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + structPointer_Word32Slice(base, p.field).Append(uint32(u)) + return nil +} + +// Decode a slice of int32s ([]int32) in packed format. +func (o *Buffer) dec_slice_packed_int32(p *Properties, base structPointer) error { + v := structPointer_Word32Slice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded int32s + + fin := o.index + nb + if fin < o.index { + return errOverflow + } + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + v.Append(uint32(u)) + } + return nil +} + +// Decode a slice of int64s ([]int64). +func (o *Buffer) dec_slice_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + + structPointer_Word64Slice(base, p.field).Append(u) + return nil +} + +// Decode a slice of int64s ([]int64) in packed format. +func (o *Buffer) dec_slice_packed_int64(p *Properties, base structPointer) error { + v := structPointer_Word64Slice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded int64s + + fin := o.index + nb + if fin < o.index { + return errOverflow + } + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + v.Append(u) + } + return nil +} + +// Decode a slice of strings ([]string). +func (o *Buffer) dec_slice_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + v := structPointer_StringSlice(base, p.field) + *v = append(*v, s) + return nil +} + +// Decode a slice of slice of bytes ([][]byte). +func (o *Buffer) dec_slice_slice_byte(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + v := structPointer_BytesSlice(base, p.field) + *v = append(*v, b) + return nil +} + +// Decode a map field. +func (o *Buffer) dec_new_map(p *Properties, base structPointer) error { + raw, err := o.DecodeRawBytes(false) + if err != nil { + return err + } + oi := o.index // index at the end of this map entry + o.index -= len(raw) // move buffer back to start of map entry + + mptr := structPointer_NewAt(base, p.field, p.mtype) // *map[K]V + if mptr.Elem().IsNil() { + mptr.Elem().Set(reflect.MakeMap(mptr.Type().Elem())) + } + v := mptr.Elem() // map[K]V + + // Prepare addressable doubly-indirect placeholders for the key and value types. + // See enc_new_map for why. + keyptr := reflect.New(reflect.PtrTo(p.mtype.Key())).Elem() // addressable *K + keybase := toStructPointer(keyptr.Addr()) // **K + + var valbase structPointer + var valptr reflect.Value + switch p.mtype.Elem().Kind() { + case reflect.Slice: + // []byte + var dummy []byte + valptr = reflect.ValueOf(&dummy) // *[]byte + valbase = toStructPointer(valptr) // *[]byte + case reflect.Ptr: + // message; valptr is **Msg; need to allocate the intermediate pointer + valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V + valptr.Set(reflect.New(valptr.Type().Elem())) + valbase = toStructPointer(valptr) + default: + // everything else + valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V + valbase = toStructPointer(valptr.Addr()) // **V + } + + // Decode. + // This parses a restricted wire format, namely the encoding of a message + // with two fields. See enc_new_map for the format. + for o.index < oi { + // tagcode for key and value properties are always a single byte + // because they have tags 1 and 2. + tagcode := o.buf[o.index] + o.index++ + switch tagcode { + case p.mkeyprop.tagcode[0]: + if err := p.mkeyprop.dec(o, p.mkeyprop, keybase); err != nil { + return err + } + case p.mvalprop.tagcode[0]: + if err := p.mvalprop.dec(o, p.mvalprop, valbase); err != nil { + return err + } + default: + // TODO: Should we silently skip this instead? + return fmt.Errorf("proto: bad map data tag %d", raw[0]) + } + } + keyelem, valelem := keyptr.Elem(), valptr.Elem() + if !keyelem.IsValid() { + keyelem = reflect.Zero(p.mtype.Key()) + } + if !valelem.IsValid() { + valelem = reflect.Zero(p.mtype.Elem()) + } + + v.SetMapIndex(keyelem, valelem) + return nil +} + +// Decode a group. +func (o *Buffer) dec_struct_group(p *Properties, base structPointer) error { + bas := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(bas) { + // allocate new nested message + bas = toStructPointer(reflect.New(p.stype)) + structPointer_SetStructPointer(base, p.field, bas) + } + return o.unmarshalType(p.stype, p.sprop, true, bas) +} + +// Decode an embedded message. +func (o *Buffer) dec_struct_message(p *Properties, base structPointer) (err error) { + raw, e := o.DecodeRawBytes(false) + if e != nil { + return e + } + + bas := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(bas) { + // allocate new nested message + bas = toStructPointer(reflect.New(p.stype)) + structPointer_SetStructPointer(base, p.field, bas) + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + iv := structPointer_Interface(bas, p.stype) + return iv.(Unmarshaler).Unmarshal(raw) + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + err = o.unmarshalType(p.stype, p.sprop, false, bas) + o.buf = obuf + o.index = oi + + return err +} + +// Decode a slice of embedded messages. +func (o *Buffer) dec_slice_struct_message(p *Properties, base structPointer) error { + return o.dec_slice_struct(p, false, base) +} + +// Decode a slice of embedded groups. +func (o *Buffer) dec_slice_struct_group(p *Properties, base structPointer) error { + return o.dec_slice_struct(p, true, base) +} + +// Decode a slice of structs ([]*struct). +func (o *Buffer) dec_slice_struct(p *Properties, is_group bool, base structPointer) error { + v := reflect.New(p.stype) + bas := toStructPointer(v) + structPointer_StructPointerSlice(base, p.field).Append(bas) + + if is_group { + err := o.unmarshalType(p.stype, p.sprop, is_group, bas) + return err + } + + raw, err := o.DecodeRawBytes(false) + if err != nil { + return err + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + iv := v.Interface() + return iv.(Unmarshaler).Unmarshal(raw) + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + err = o.unmarshalType(p.stype, p.sprop, is_group, bas) + + o.buf = obuf + o.index = oi + + return err +} diff --git a/vendor/github.com/gogo/protobuf/proto/decode_gogo.go b/vendor/github.com/gogo/protobuf/proto/decode_gogo.go new file mode 100644 index 00000000..ecc63873 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/decode_gogo.go @@ -0,0 +1,171 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +import ( + "reflect" +) + +// Decode a reference to a struct pointer. +func (o *Buffer) dec_ref_struct_message(p *Properties, base structPointer) (err error) { + raw, e := o.DecodeRawBytes(false) + if e != nil { + return e + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + panic("not supported, since this is a pointer receiver") + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + bas := structPointer_FieldPointer(base, p.field) + + err = o.unmarshalType(p.stype, p.sprop, false, bas) + o.buf = obuf + o.index = oi + + return err +} + +// Decode a slice of references to struct pointers ([]struct). +func (o *Buffer) dec_slice_ref_struct(p *Properties, is_group bool, base structPointer) error { + newBas := appendStructPointer(base, p.field, p.sstype) + + if is_group { + panic("not supported, maybe in future, if requested.") + } + + raw, err := o.DecodeRawBytes(false) + if err != nil { + return err + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + panic("not supported, since this is not a pointer receiver.") + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + err = o.unmarshalType(p.stype, p.sprop, is_group, newBas) + + o.buf = obuf + o.index = oi + + return err +} + +// Decode a slice of references to struct pointers. +func (o *Buffer) dec_slice_ref_struct_message(p *Properties, base structPointer) error { + return o.dec_slice_ref_struct(p, false, base) +} + +func setPtrCustomType(base structPointer, f field, v interface{}) { + if v == nil { + return + } + structPointer_SetStructPointer(base, f, structPointer(reflect.ValueOf(v).Pointer())) +} + +func setCustomType(base structPointer, f field, value interface{}) { + if value == nil { + return + } + v := reflect.ValueOf(value).Elem() + t := reflect.TypeOf(value).Elem() + kind := t.Kind() + switch kind { + case reflect.Slice: + slice := reflect.MakeSlice(t, v.Len(), v.Cap()) + reflect.Copy(slice, v) + oldHeader := structPointer_GetSliceHeader(base, f) + oldHeader.Data = slice.Pointer() + oldHeader.Len = v.Len() + oldHeader.Cap = v.Cap() + default: + size := reflect.TypeOf(value).Elem().Size() + structPointer_Copy(toStructPointer(reflect.ValueOf(value)), structPointer_Add(base, f), int(size)) + } +} + +func (o *Buffer) dec_custom_bytes(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + i := reflect.New(p.ctype.Elem()).Interface() + custom := (i).(Unmarshaler) + if err := custom.Unmarshal(b); err != nil { + return err + } + setPtrCustomType(base, p.field, custom) + return nil +} + +func (o *Buffer) dec_custom_ref_bytes(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + i := reflect.New(p.ctype).Interface() + custom := (i).(Unmarshaler) + if err := custom.Unmarshal(b); err != nil { + return err + } + if custom != nil { + setCustomType(base, p.field, custom) + } + return nil +} + +// Decode a slice of bytes ([]byte) into a slice of custom types. +func (o *Buffer) dec_custom_slice_bytes(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + i := reflect.New(p.ctype.Elem()).Interface() + custom := (i).(Unmarshaler) + if err := custom.Unmarshal(b); err != nil { + return err + } + newBas := appendStructPointer(base, p.field, p.ctype) + + setCustomType(newBas, 0, custom) + + return nil +} diff --git a/vendor/github.com/gogo/protobuf/proto/encode.go b/vendor/github.com/gogo/protobuf/proto/encode.go new file mode 100644 index 00000000..8c1b8fd1 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/encode.go @@ -0,0 +1,1363 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Routines for encoding data into the wire format for protocol buffers. + */ + +import ( + "errors" + "fmt" + "reflect" + "sort" +) + +// RequiredNotSetError is the error returned if Marshal is called with +// a protocol buffer struct whose required fields have not +// all been initialized. It is also the error returned if Unmarshal is +// called with an encoded protocol buffer that does not include all the +// required fields. +// +// When printed, RequiredNotSetError reports the first unset required field in a +// message. If the field cannot be precisely determined, it is reported as +// "{Unknown}". +type RequiredNotSetError struct { + field string +} + +func (e *RequiredNotSetError) Error() string { + return fmt.Sprintf("proto: required field %q not set", e.field) +} + +var ( + // errRepeatedHasNil is the error returned if Marshal is called with + // a struct with a repeated field containing a nil element. + errRepeatedHasNil = errors.New("proto: repeated field has nil element") + + // errOneofHasNil is the error returned if Marshal is called with + // a struct with a oneof field containing a nil element. + errOneofHasNil = errors.New("proto: oneof field has nil value") + + // ErrNil is the error returned if Marshal is called with nil. + ErrNil = errors.New("proto: Marshal called with nil") + + // ErrTooLarge is the error returned if Marshal is called with a + // message that encodes to >2GB. + ErrTooLarge = errors.New("proto: message encodes to over 2 GB") +) + +// The fundamental encoders that put bytes on the wire. +// Those that take integer types all accept uint64 and are +// therefore of type valueEncoder. + +const maxVarintBytes = 10 // maximum length of a varint + +// maxMarshalSize is the largest allowed size of an encoded protobuf, +// since C++ and Java use signed int32s for the size. +const maxMarshalSize = 1<<31 - 1 + +// EncodeVarint returns the varint encoding of x. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +// Not used by the package itself, but helpful to clients +// wishing to use the same encoding. +func EncodeVarint(x uint64) []byte { + var buf [maxVarintBytes]byte + var n int + for n = 0; x > 127; n++ { + buf[n] = 0x80 | uint8(x&0x7F) + x >>= 7 + } + buf[n] = uint8(x) + n++ + return buf[0:n] +} + +// EncodeVarint writes a varint-encoded integer to the Buffer. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func (p *Buffer) EncodeVarint(x uint64) error { + for x >= 1<<7 { + p.buf = append(p.buf, uint8(x&0x7f|0x80)) + x >>= 7 + } + p.buf = append(p.buf, uint8(x)) + return nil +} + +// SizeVarint returns the varint encoding size of an integer. +func SizeVarint(x uint64) int { + return sizeVarint(x) +} + +func sizeVarint(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} + +// EncodeFixed64 writes a 64-bit integer to the Buffer. +// This is the format for the +// fixed64, sfixed64, and double protocol buffer types. +func (p *Buffer) EncodeFixed64(x uint64) error { + p.buf = append(p.buf, + uint8(x), + uint8(x>>8), + uint8(x>>16), + uint8(x>>24), + uint8(x>>32), + uint8(x>>40), + uint8(x>>48), + uint8(x>>56)) + return nil +} + +func sizeFixed64(x uint64) int { + return 8 +} + +// EncodeFixed32 writes a 32-bit integer to the Buffer. +// This is the format for the +// fixed32, sfixed32, and float protocol buffer types. +func (p *Buffer) EncodeFixed32(x uint64) error { + p.buf = append(p.buf, + uint8(x), + uint8(x>>8), + uint8(x>>16), + uint8(x>>24)) + return nil +} + +func sizeFixed32(x uint64) int { + return 4 +} + +// EncodeZigzag64 writes a zigzag-encoded 64-bit integer +// to the Buffer. +// This is the format used for the sint64 protocol buffer type. +func (p *Buffer) EncodeZigzag64(x uint64) error { + // use signed number to get arithmetic right shift. + return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func sizeZigzag64(x uint64) int { + return sizeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +// EncodeZigzag32 writes a zigzag-encoded 32-bit integer +// to the Buffer. +// This is the format used for the sint32 protocol buffer type. +func (p *Buffer) EncodeZigzag32(x uint64) error { + // use signed number to get arithmetic right shift. + return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) +} + +func sizeZigzag32(x uint64) int { + return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) +} + +// EncodeRawBytes writes a count-delimited byte buffer to the Buffer. +// This is the format used for the bytes protocol buffer +// type and for embedded messages. +func (p *Buffer) EncodeRawBytes(b []byte) error { + p.EncodeVarint(uint64(len(b))) + p.buf = append(p.buf, b...) + return nil +} + +func sizeRawBytes(b []byte) int { + return sizeVarint(uint64(len(b))) + + len(b) +} + +// EncodeStringBytes writes an encoded string to the Buffer. +// This is the format used for the proto2 string type. +func (p *Buffer) EncodeStringBytes(s string) error { + p.EncodeVarint(uint64(len(s))) + p.buf = append(p.buf, s...) + return nil +} + +func sizeStringBytes(s string) int { + return sizeVarint(uint64(len(s))) + + len(s) +} + +// Marshaler is the interface representing objects that can marshal themselves. +type Marshaler interface { + Marshal() ([]byte, error) +} + +// Marshal takes the protocol buffer +// and encodes it into the wire format, returning the data. +func Marshal(pb Message) ([]byte, error) { + // Can the object marshal itself? + if m, ok := pb.(Marshaler); ok { + return m.Marshal() + } + p := NewBuffer(nil) + err := p.Marshal(pb) + var state errorState + if err != nil && !state.shouldContinue(err, nil) { + return nil, err + } + if p.buf == nil && err == nil { + // Return a non-nil slice on success. + return []byte{}, nil + } + return p.buf, err +} + +// EncodeMessage writes the protocol buffer to the Buffer, +// prefixed by a varint-encoded length. +func (p *Buffer) EncodeMessage(pb Message) error { + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return ErrNil + } + if err == nil { + var state errorState + err = p.enc_len_struct(GetProperties(t.Elem()), base, &state) + } + return err +} + +// Marshal takes the protocol buffer +// and encodes it into the wire format, writing the result to the +// Buffer. +func (p *Buffer) Marshal(pb Message) error { + // Can the object marshal itself? + if m, ok := pb.(Marshaler); ok { + data, err := m.Marshal() + if err != nil { + return err + } + p.buf = append(p.buf, data...) + return nil + } + + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return ErrNil + } + if err == nil { + err = p.enc_struct(GetProperties(t.Elem()), base) + } + + if collectStats { + stats.Encode++ + } + + if len(p.buf) > maxMarshalSize { + return ErrTooLarge + } + return err +} + +// Size returns the encoded size of a protocol buffer. +func Size(pb Message) (n int) { + // Can the object marshal itself? If so, Size is slow. + // TODO: add Size to Marshaler, or add a Sizer interface. + if m, ok := pb.(Marshaler); ok { + b, _ := m.Marshal() + return len(b) + } + + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return 0 + } + if err == nil { + n = size_struct(GetProperties(t.Elem()), base) + } + + if collectStats { + stats.Size++ + } + + return +} + +// Individual type encoders. + +// Encode a bool. +func (o *Buffer) enc_bool(p *Properties, base structPointer) error { + v := *structPointer_Bool(base, p.field) + if v == nil { + return ErrNil + } + x := 0 + if *v { + x = 1 + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_bool(p *Properties, base structPointer) error { + v := *structPointer_BoolVal(base, p.field) + if !v { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, 1) + return nil +} + +func size_bool(p *Properties, base structPointer) int { + v := *structPointer_Bool(base, p.field) + if v == nil { + return 0 + } + return len(p.tagcode) + 1 // each bool takes exactly one byte +} + +func size_proto3_bool(p *Properties, base structPointer) int { + v := *structPointer_BoolVal(base, p.field) + if !v && !p.oneof { + return 0 + } + return len(p.tagcode) + 1 // each bool takes exactly one byte +} + +// Encode an int32. +func (o *Buffer) enc_int32(p *Properties, base structPointer) error { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return ErrNil + } + x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_int32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return 0 + } + x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +func size_proto3_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +// Encode a uint32. +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_uint32(p *Properties, base structPointer) error { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return ErrNil + } + x := word32_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_uint32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return 0 + } + x := word32_Get(v) + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +func size_proto3_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +// Encode an int64. +func (o *Buffer) enc_int64(p *Properties, base structPointer) error { + v := structPointer_Word64(base, p.field) + if word64_IsNil(v) { + return ErrNil + } + x := word64_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, x) + return nil +} + +func (o *Buffer) enc_proto3_int64(p *Properties, base structPointer) error { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, x) + return nil +} + +func size_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64(base, p.field) + if word64_IsNil(v) { + return 0 + } + x := word64_Get(v) + n += len(p.tagcode) + n += p.valSize(x) + return +} + +func size_proto3_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(x) + return +} + +// Encode a string. +func (o *Buffer) enc_string(p *Properties, base structPointer) error { + v := *structPointer_String(base, p.field) + if v == nil { + return ErrNil + } + x := *v + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(x) + return nil +} + +func (o *Buffer) enc_proto3_string(p *Properties, base structPointer) error { + v := *structPointer_StringVal(base, p.field) + if v == "" { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(v) + return nil +} + +func size_string(p *Properties, base structPointer) (n int) { + v := *structPointer_String(base, p.field) + if v == nil { + return 0 + } + x := *v + n += len(p.tagcode) + n += sizeStringBytes(x) + return +} + +func size_proto3_string(p *Properties, base structPointer) (n int) { + v := *structPointer_StringVal(base, p.field) + if v == "" && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeStringBytes(v) + return +} + +// All protocol buffer fields are nillable, but be careful. +func isNil(v reflect.Value) bool { + switch v.Kind() { + case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + return v.IsNil() + } + return false +} + +// Encode a message struct. +func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error { + var state errorState + structp := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return ErrNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + return state.err + } + + o.buf = append(o.buf, p.tagcode...) + return o.enc_len_struct(p.sprop, structp, &state) +} + +func size_struct_message(p *Properties, base structPointer) int { + structp := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return 0 + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n0 := len(p.tagcode) + n1 := sizeRawBytes(data) + return n0 + n1 + } + + n0 := len(p.tagcode) + n1 := size_struct(p.sprop, structp) + n2 := sizeVarint(uint64(n1)) // size of encoded length + return n0 + n1 + n2 +} + +// Encode a group struct. +func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error { + var state errorState + b := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(b) { + return ErrNil + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup)) + err := o.enc_struct(p.sprop, b) + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup)) + return state.err +} + +func size_struct_group(p *Properties, base structPointer) (n int) { + b := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(b) { + return 0 + } + + n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup)) + n += size_struct(p.sprop, b) + n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup)) + return +} + +// Encode a slice of bools ([]bool). +func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return ErrNil + } + for _, x := range s { + o.buf = append(o.buf, p.tagcode...) + v := uint64(0) + if x { + v = 1 + } + p.valEnc(o, v) + } + return nil +} + +func size_slice_bool(p *Properties, base structPointer) int { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return 0 + } + return l * (len(p.tagcode) + 1) // each bool takes exactly one byte +} + +// Encode a slice of bools ([]bool) in packed format. +func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(l)) // each bool takes exactly one byte + for _, x := range s { + v := uint64(0) + if x { + v = 1 + } + p.valEnc(o, v) + } + return nil +} + +func size_slice_packed_bool(p *Properties, base structPointer) (n int) { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return 0 + } + n += len(p.tagcode) + n += sizeVarint(uint64(l)) + n += l // each bool takes exactly one byte + return +} + +// Encode a slice of bytes ([]byte). +func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error { + s := *structPointer_Bytes(base, p.field) + if s == nil { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(s) + return nil +} + +func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error { + s := *structPointer_Bytes(base, p.field) + if len(s) == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(s) + return nil +} + +func size_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) + if s == nil && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeRawBytes(s) + return +} + +func size_proto3_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) + if len(s) == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeRawBytes(s) + return +} + +// Encode a slice of int32s ([]int32). +func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + p.valEnc(o, uint64(x)) + } + return nil +} + +func size_slice_int32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + n += p.valSize(uint64(x)) + } + return +} + +// Encode a slice of int32s ([]int32) in packed format. +func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + p.valEnc(buf, uint64(x)) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_int32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + bufSize += p.valSize(uint64(x)) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of uint32s ([]uint32). +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_slice_uint32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + x := s.Index(i) + p.valEnc(o, uint64(x)) + } + return nil +} + +func size_slice_uint32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + x := s.Index(i) + n += p.valSize(uint64(x)) + } + return +} + +// Encode a slice of uint32s ([]uint32) in packed format. +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_slice_packed_uint32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + p.valEnc(buf, uint64(s.Index(i))) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_uint32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + bufSize += p.valSize(uint64(s.Index(i))) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of int64s ([]int64). +func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, s.Index(i)) + } + return nil +} + +func size_slice_int64(p *Properties, base structPointer) (n int) { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + n += p.valSize(s.Index(i)) + } + return +} + +// Encode a slice of int64s ([]int64) in packed format. +func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + p.valEnc(buf, s.Index(i)) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_int64(p *Properties, base structPointer) (n int) { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + bufSize += p.valSize(s.Index(i)) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of slice of bytes ([][]byte). +func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error { + ss := *structPointer_BytesSlice(base, p.field) + l := len(ss) + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(ss[i]) + } + return nil +} + +func size_slice_slice_byte(p *Properties, base structPointer) (n int) { + ss := *structPointer_BytesSlice(base, p.field) + l := len(ss) + if l == 0 { + return 0 + } + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + n += sizeRawBytes(ss[i]) + } + return +} + +// Encode a slice of strings ([]string). +func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error { + ss := *structPointer_StringSlice(base, p.field) + l := len(ss) + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(ss[i]) + } + return nil +} + +func size_slice_string(p *Properties, base structPointer) (n int) { + ss := *structPointer_StringSlice(base, p.field) + l := len(ss) + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + n += sizeStringBytes(ss[i]) + } + return +} + +// Encode a slice of message structs ([]*struct). +func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error { + var state errorState + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + for i := 0; i < l; i++ { + structp := s.Index(i) + if structPointer_IsNil(structp) { + return errRepeatedHasNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + continue + } + + o.buf = append(o.buf, p.tagcode...) + err := o.enc_len_struct(p.sprop, structp, &state) + if err != nil && !state.shouldContinue(err, nil) { + if err == ErrNil { + return errRepeatedHasNil + } + return err + } + } + return state.err +} + +func size_slice_struct_message(p *Properties, base structPointer) (n int) { + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + structp := s.Index(i) + if structPointer_IsNil(structp) { + return // return the size up to this point + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n += len(p.tagcode) + n += sizeRawBytes(data) + continue + } + + n0 := size_struct(p.sprop, structp) + n1 := sizeVarint(uint64(n0)) // size of encoded length + n += n0 + n1 + } + return +} + +// Encode a slice of group structs ([]*struct). +func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error { + var state errorState + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + for i := 0; i < l; i++ { + b := s.Index(i) + if structPointer_IsNil(b) { + return errRepeatedHasNil + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup)) + + err := o.enc_struct(p.sprop, b) + + if err != nil && !state.shouldContinue(err, nil) { + if err == ErrNil { + return errRepeatedHasNil + } + return err + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup)) + } + return state.err +} + +func size_slice_struct_group(p *Properties, base structPointer) (n int) { + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup)) + n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup)) + for i := 0; i < l; i++ { + b := s.Index(i) + if structPointer_IsNil(b) { + return // return size up to this point + } + + n += size_struct(p.sprop, b) + } + return +} + +// Encode an extension map. +func (o *Buffer) enc_map(p *Properties, base structPointer) error { + exts := structPointer_ExtMap(base, p.field) + if err := encodeExtensionsMap(*exts); err != nil { + return err + } + + return o.enc_map_body(*exts) +} + +func (o *Buffer) enc_exts(p *Properties, base structPointer) error { + exts := structPointer_Extensions(base, p.field) + if err := encodeExtensions(exts); err != nil { + return err + } + v, _ := exts.extensionsRead() + + return o.enc_map_body(v) +} + +func (o *Buffer) enc_map_body(v map[int32]Extension) error { + // Fast-path for common cases: zero or one extensions. + if len(v) <= 1 { + for _, e := range v { + o.buf = append(o.buf, e.enc...) + } + return nil + } + + // Sort keys to provide a deterministic encoding. + keys := make([]int, 0, len(v)) + for k := range v { + keys = append(keys, int(k)) + } + sort.Ints(keys) + + for _, k := range keys { + o.buf = append(o.buf, v[int32(k)].enc...) + } + return nil +} + +func size_map(p *Properties, base structPointer) int { + v := structPointer_ExtMap(base, p.field) + return extensionsMapSize(*v) +} + +func size_exts(p *Properties, base structPointer) int { + v := structPointer_Extensions(base, p.field) + return extensionsSize(v) +} + +// Encode a map field. +func (o *Buffer) enc_new_map(p *Properties, base structPointer) error { + var state errorState // XXX: or do we need to plumb this through? + + /* + A map defined as + map map_field = N; + is encoded in the same way as + message MapFieldEntry { + key_type key = 1; + value_type value = 2; + } + repeated MapFieldEntry map_field = N; + */ + + v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V + if v.Len() == 0 { + return nil + } + + keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype) + + enc := func() error { + if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil { + return err + } + if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil { + return err + } + return nil + } + + // Don't sort map keys. It is not required by the spec, and C++ doesn't do it. + for _, key := range v.MapKeys() { + val := v.MapIndex(key) + + keycopy.Set(key) + valcopy.Set(val) + + o.buf = append(o.buf, p.tagcode...) + if err := o.enc_len_thing(enc, &state); err != nil { + return err + } + } + return nil +} + +func size_new_map(p *Properties, base structPointer) int { + v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V + + keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype) + + n := 0 + for _, key := range v.MapKeys() { + val := v.MapIndex(key) + keycopy.Set(key) + valcopy.Set(val) + + // Tag codes for key and val are the responsibility of the sub-sizer. + keysize := p.mkeyprop.size(p.mkeyprop, keybase) + valsize := p.mvalprop.size(p.mvalprop, valbase) + entry := keysize + valsize + // Add on tag code and length of map entry itself. + n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry + } + return n +} + +// mapEncodeScratch returns a new reflect.Value matching the map's value type, +// and a structPointer suitable for passing to an encoder or sizer. +func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) { + // Prepare addressable doubly-indirect placeholders for the key and value types. + // This is needed because the element-type encoders expect **T, but the map iteration produces T. + + keycopy = reflect.New(mapType.Key()).Elem() // addressable K + keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K + keyptr.Set(keycopy.Addr()) // + keybase = toStructPointer(keyptr.Addr()) // **K + + // Value types are more varied and require special handling. + switch mapType.Elem().Kind() { + case reflect.Slice: + // []byte + var dummy []byte + valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte + valbase = toStructPointer(valcopy.Addr()) + case reflect.Ptr: + // message; the generated field type is map[K]*Msg (so V is *Msg), + // so we only need one level of indirection. + valcopy = reflect.New(mapType.Elem()).Elem() // addressable V + valbase = toStructPointer(valcopy.Addr()) + default: + // everything else + valcopy = reflect.New(mapType.Elem()).Elem() // addressable V + valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V + valptr.Set(valcopy.Addr()) // + valbase = toStructPointer(valptr.Addr()) // **V + } + return +} + +// Encode a struct. +func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error { + var state errorState + // Encode fields in tag order so that decoders may use optimizations + // that depend on the ordering. + // https://developers.google.com/protocol-buffers/docs/encoding#order + for _, i := range prop.order { + p := prop.Prop[i] + if p.enc != nil { + err := p.enc(o, p, base) + if err != nil { + if err == ErrNil { + if p.Required && state.err == nil { + state.err = &RequiredNotSetError{p.Name} + } + } else if err == errRepeatedHasNil { + // Give more context to nil values in repeated fields. + return errors.New("repeated field " + p.OrigName + " has nil element") + } else if !state.shouldContinue(err, p) { + return err + } + } + if len(o.buf) > maxMarshalSize { + return ErrTooLarge + } + } + } + + // Do oneof fields. + if prop.oneofMarshaler != nil { + m := structPointer_Interface(base, prop.stype).(Message) + if err := prop.oneofMarshaler(m, o); err == ErrNil { + return errOneofHasNil + } else if err != nil { + return err + } + } + + // Add unrecognized fields at the end. + if prop.unrecField.IsValid() { + v := *structPointer_Bytes(base, prop.unrecField) + if len(o.buf)+len(v) > maxMarshalSize { + return ErrTooLarge + } + if len(v) > 0 { + o.buf = append(o.buf, v...) + } + } + + return state.err +} + +func size_struct(prop *StructProperties, base structPointer) (n int) { + for _, i := range prop.order { + p := prop.Prop[i] + if p.size != nil { + n += p.size(p, base) + } + } + + // Add unrecognized fields at the end. + if prop.unrecField.IsValid() { + v := *structPointer_Bytes(base, prop.unrecField) + n += len(v) + } + + // Factor in any oneof fields. + if prop.oneofSizer != nil { + m := structPointer_Interface(base, prop.stype).(Message) + n += prop.oneofSizer(m) + } + + return +} + +var zeroes [20]byte // longer than any conceivable sizeVarint + +// Encode a struct, preceded by its encoded length (as a varint). +func (o *Buffer) enc_len_struct(prop *StructProperties, base structPointer, state *errorState) error { + return o.enc_len_thing(func() error { return o.enc_struct(prop, base) }, state) +} + +// Encode something, preceded by its encoded length (as a varint). +func (o *Buffer) enc_len_thing(enc func() error, state *errorState) error { + iLen := len(o.buf) + o.buf = append(o.buf, 0, 0, 0, 0) // reserve four bytes for length + iMsg := len(o.buf) + err := enc() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + lMsg := len(o.buf) - iMsg + lLen := sizeVarint(uint64(lMsg)) + switch x := lLen - (iMsg - iLen); { + case x > 0: // actual length is x bytes larger than the space we reserved + // Move msg x bytes right. + o.buf = append(o.buf, zeroes[:x]...) + copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg]) + case x < 0: // actual length is x bytes smaller than the space we reserved + // Move msg x bytes left. + copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg]) + o.buf = o.buf[:len(o.buf)+x] // x is negative + } + // Encode the length in the reserved space. + o.buf = o.buf[:iLen] + o.EncodeVarint(uint64(lMsg)) + o.buf = o.buf[:len(o.buf)+lMsg] + return state.err +} + +// errorState maintains the first error that occurs and updates that error +// with additional context. +type errorState struct { + err error +} + +// shouldContinue reports whether encoding should continue upon encountering the +// given error. If the error is RequiredNotSetError, shouldContinue returns true +// and, if this is the first appearance of that error, remembers it for future +// reporting. +// +// If prop is not nil, it may update any error with additional context about the +// field with the error. +func (s *errorState) shouldContinue(err error, prop *Properties) bool { + // Ignore unset required fields. + reqNotSet, ok := err.(*RequiredNotSetError) + if !ok { + return false + } + if s.err == nil { + if prop != nil { + err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field} + } + s.err = err + } + return true +} diff --git a/vendor/github.com/gogo/protobuf/proto/encode_gogo.go b/vendor/github.com/gogo/protobuf/proto/encode_gogo.go new file mode 100644 index 00000000..66e7e163 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/encode_gogo.go @@ -0,0 +1,354 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// http://github.com/golang/protobuf/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +import ( + "reflect" +) + +func NewRequiredNotSetError(field string) *RequiredNotSetError { + return &RequiredNotSetError{field} +} + +type Sizer interface { + Size() int +} + +func (o *Buffer) enc_ext_slice_byte(p *Properties, base structPointer) error { + s := *structPointer_Bytes(base, p.field) + if s == nil { + return ErrNil + } + o.buf = append(o.buf, s...) + return nil +} + +func size_ext_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) + if s == nil { + return 0 + } + n += len(s) + return +} + +// Encode a reference to bool pointer. +func (o *Buffer) enc_ref_bool(p *Properties, base structPointer) error { + v := *structPointer_BoolVal(base, p.field) + x := 0 + if v { + x = 1 + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_ref_bool(p *Properties, base structPointer) int { + return len(p.tagcode) + 1 // each bool takes exactly one byte +} + +// Encode a reference to int32 pointer. +func (o *Buffer) enc_ref_int32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_ref_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +func (o *Buffer) enc_ref_uint32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_ref_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +// Encode a reference to an int64 pointer. +func (o *Buffer) enc_ref_int64(p *Properties, base structPointer) error { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, x) + return nil +} + +func size_ref_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + n += len(p.tagcode) + n += p.valSize(x) + return +} + +// Encode a reference to a string pointer. +func (o *Buffer) enc_ref_string(p *Properties, base structPointer) error { + v := *structPointer_StringVal(base, p.field) + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(v) + return nil +} + +func size_ref_string(p *Properties, base structPointer) (n int) { + v := *structPointer_StringVal(base, p.field) + n += len(p.tagcode) + n += sizeStringBytes(v) + return +} + +// Encode a reference to a message struct. +func (o *Buffer) enc_ref_struct_message(p *Properties, base structPointer) error { + var state errorState + structp := structPointer_GetRefStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return ErrNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + return nil + } + + o.buf = append(o.buf, p.tagcode...) + return o.enc_len_struct(p.sprop, structp, &state) +} + +//TODO this is only copied, please fix this +func size_ref_struct_message(p *Properties, base structPointer) int { + structp := structPointer_GetRefStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return 0 + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n0 := len(p.tagcode) + n1 := sizeRawBytes(data) + return n0 + n1 + } + + n0 := len(p.tagcode) + n1 := size_struct(p.sprop, structp) + n2 := sizeVarint(uint64(n1)) // size of encoded length + return n0 + n1 + n2 +} + +// Encode a slice of references to message struct pointers ([]struct). +func (o *Buffer) enc_slice_ref_struct_message(p *Properties, base structPointer) error { + var state errorState + ss := structPointer_GetStructPointer(base, p.field) + ss1 := structPointer_GetRefStructPointer(ss, field(0)) + size := p.stype.Size() + l := structPointer_Len(base, p.field) + for i := 0; i < l; i++ { + structp := structPointer_Add(ss1, field(uintptr(i)*size)) + if structPointer_IsNil(structp) { + return errRepeatedHasNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + continue + } + + o.buf = append(o.buf, p.tagcode...) + err := o.enc_len_struct(p.sprop, structp, &state) + if err != nil && !state.shouldContinue(err, nil) { + if err == ErrNil { + return errRepeatedHasNil + } + return err + } + + } + return state.err +} + +//TODO this is only copied, please fix this +func size_slice_ref_struct_message(p *Properties, base structPointer) (n int) { + ss := structPointer_GetStructPointer(base, p.field) + ss1 := structPointer_GetRefStructPointer(ss, field(0)) + size := p.stype.Size() + l := structPointer_Len(base, p.field) + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + structp := structPointer_Add(ss1, field(uintptr(i)*size)) + if structPointer_IsNil(structp) { + return // return the size up to this point + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n += len(p.tagcode) + n += sizeRawBytes(data) + continue + } + + n0 := size_struct(p.sprop, structp) + n1 := sizeVarint(uint64(n0)) // size of encoded length + n += n0 + n1 + } + return +} + +func (o *Buffer) enc_custom_bytes(p *Properties, base structPointer) error { + i := structPointer_InterfaceRef(base, p.field, p.ctype) + if i == nil { + return ErrNil + } + custom := i.(Marshaler) + data, err := custom.Marshal() + if err != nil { + return err + } + if data == nil { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + return nil +} + +func size_custom_bytes(p *Properties, base structPointer) (n int) { + n += len(p.tagcode) + i := structPointer_InterfaceRef(base, p.field, p.ctype) + if i == nil { + return 0 + } + custom := i.(Marshaler) + data, _ := custom.Marshal() + n += sizeRawBytes(data) + return +} + +func (o *Buffer) enc_custom_ref_bytes(p *Properties, base structPointer) error { + custom := structPointer_InterfaceAt(base, p.field, p.ctype).(Marshaler) + data, err := custom.Marshal() + if err != nil { + return err + } + if data == nil { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + return nil +} + +func size_custom_ref_bytes(p *Properties, base structPointer) (n int) { + n += len(p.tagcode) + i := structPointer_InterfaceAt(base, p.field, p.ctype) + if i == nil { + return 0 + } + custom := i.(Marshaler) + data, _ := custom.Marshal() + n += sizeRawBytes(data) + return +} + +func (o *Buffer) enc_custom_slice_bytes(p *Properties, base structPointer) error { + inter := structPointer_InterfaceRef(base, p.field, p.ctype) + if inter == nil { + return ErrNil + } + slice := reflect.ValueOf(inter) + l := slice.Len() + for i := 0; i < l; i++ { + v := slice.Index(i) + custom := v.Interface().(Marshaler) + data, err := custom.Marshal() + if err != nil { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + } + return nil +} + +func size_custom_slice_bytes(p *Properties, base structPointer) (n int) { + inter := structPointer_InterfaceRef(base, p.field, p.ctype) + if inter == nil { + return 0 + } + slice := reflect.ValueOf(inter) + l := slice.Len() + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + v := slice.Index(i) + custom := v.Interface().(Marshaler) + data, _ := custom.Marshal() + n += sizeRawBytes(data) + } + return +} diff --git a/vendor/github.com/gogo/protobuf/proto/equal.go b/vendor/github.com/gogo/protobuf/proto/equal.go new file mode 100644 index 00000000..8b16f951 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/equal.go @@ -0,0 +1,296 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Protocol buffer comparison. + +package proto + +import ( + "bytes" + "log" + "reflect" + "strings" +) + +/* +Equal returns true iff protocol buffers a and b are equal. +The arguments must both be pointers to protocol buffer structs. + +Equality is defined in this way: + - Two messages are equal iff they are the same type, + corresponding fields are equal, unknown field sets + are equal, and extensions sets are equal. + - Two set scalar fields are equal iff their values are equal. + If the fields are of a floating-point type, remember that + NaN != x for all x, including NaN. If the message is defined + in a proto3 .proto file, fields are not "set"; specifically, + zero length proto3 "bytes" fields are equal (nil == {}). + - Two repeated fields are equal iff their lengths are the same, + and their corresponding elements are equal (a "bytes" field, + although represented by []byte, is not a repeated field) + - Two unset fields are equal. + - Two unknown field sets are equal if their current + encoded state is equal. + - Two extension sets are equal iff they have corresponding + elements that are pairwise equal. + - Every other combination of things are not equal. + +The return value is undefined if a and b are not protocol buffers. +*/ +func Equal(a, b Message) bool { + if a == nil || b == nil { + return a == b + } + v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b) + if v1.Type() != v2.Type() { + return false + } + if v1.Kind() == reflect.Ptr { + if v1.IsNil() { + return v2.IsNil() + } + if v2.IsNil() { + return false + } + v1, v2 = v1.Elem(), v2.Elem() + } + if v1.Kind() != reflect.Struct { + return false + } + return equalStruct(v1, v2) +} + +// v1 and v2 are known to have the same type. +func equalStruct(v1, v2 reflect.Value) bool { + sprop := GetProperties(v1.Type()) + for i := 0; i < v1.NumField(); i++ { + f := v1.Type().Field(i) + if strings.HasPrefix(f.Name, "XXX_") { + continue + } + f1, f2 := v1.Field(i), v2.Field(i) + if f.Type.Kind() == reflect.Ptr { + if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 { + // both unset + continue + } else if n1 != n2 { + // set/unset mismatch + return false + } + b1, ok := f1.Interface().(raw) + if ok { + b2 := f2.Interface().(raw) + // RawMessage + if !bytes.Equal(b1.Bytes(), b2.Bytes()) { + return false + } + continue + } + f1, f2 = f1.Elem(), f2.Elem() + } + if !equalAny(f1, f2, sprop.Prop[i]) { + return false + } + } + + if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() { + em2 := v2.FieldByName("XXX_InternalExtensions") + if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) { + return false + } + } + + if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() { + em2 := v2.FieldByName("XXX_extensions") + if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) { + return false + } + } + + uf := v1.FieldByName("XXX_unrecognized") + if !uf.IsValid() { + return true + } + + u1 := uf.Bytes() + u2 := v2.FieldByName("XXX_unrecognized").Bytes() + if !bytes.Equal(u1, u2) { + return false + } + + return true +} + +// v1 and v2 are known to have the same type. +// prop may be nil. +func equalAny(v1, v2 reflect.Value, prop *Properties) bool { + if v1.Type() == protoMessageType { + m1, _ := v1.Interface().(Message) + m2, _ := v2.Interface().(Message) + return Equal(m1, m2) + } + switch v1.Kind() { + case reflect.Bool: + return v1.Bool() == v2.Bool() + case reflect.Float32, reflect.Float64: + return v1.Float() == v2.Float() + case reflect.Int32, reflect.Int64: + return v1.Int() == v2.Int() + case reflect.Interface: + // Probably a oneof field; compare the inner values. + n1, n2 := v1.IsNil(), v2.IsNil() + if n1 || n2 { + return n1 == n2 + } + e1, e2 := v1.Elem(), v2.Elem() + if e1.Type() != e2.Type() { + return false + } + return equalAny(e1, e2, nil) + case reflect.Map: + if v1.Len() != v2.Len() { + return false + } + for _, key := range v1.MapKeys() { + val2 := v2.MapIndex(key) + if !val2.IsValid() { + // This key was not found in the second map. + return false + } + if !equalAny(v1.MapIndex(key), val2, nil) { + return false + } + } + return true + case reflect.Ptr: + // Maps may have nil values in them, so check for nil. + if v1.IsNil() && v2.IsNil() { + return true + } + if v1.IsNil() != v2.IsNil() { + return false + } + return equalAny(v1.Elem(), v2.Elem(), prop) + case reflect.Slice: + if v1.Type().Elem().Kind() == reflect.Uint8 { + // short circuit: []byte + + // Edge case: if this is in a proto3 message, a zero length + // bytes field is considered the zero value. + if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 { + return true + } + if v1.IsNil() != v2.IsNil() { + return false + } + return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte)) + } + + if v1.Len() != v2.Len() { + return false + } + for i := 0; i < v1.Len(); i++ { + if !equalAny(v1.Index(i), v2.Index(i), prop) { + return false + } + } + return true + case reflect.String: + return v1.Interface().(string) == v2.Interface().(string) + case reflect.Struct: + return equalStruct(v1, v2) + case reflect.Uint32, reflect.Uint64: + return v1.Uint() == v2.Uint() + } + + // unknown type, so not a protocol buffer + log.Printf("proto: don't know how to compare %v", v1) + return false +} + +// base is the struct type that the extensions are based on. +// x1 and x2 are InternalExtensions. +func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool { + em1, _ := x1.extensionsRead() + em2, _ := x2.extensionsRead() + return equalExtMap(base, em1, em2) +} + +func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool { + if len(em1) != len(em2) { + return false + } + + for extNum, e1 := range em1 { + e2, ok := em2[extNum] + if !ok { + return false + } + + m1, m2 := e1.value, e2.value + + if m1 != nil && m2 != nil { + // Both are unencoded. + if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) { + return false + } + continue + } + + // At least one is encoded. To do a semantically correct comparison + // we need to unmarshal them first. + var desc *ExtensionDesc + if m := extensionMaps[base]; m != nil { + desc = m[extNum] + } + if desc == nil { + log.Printf("proto: don't know how to compare extension %d of %v", extNum, base) + continue + } + var err error + if m1 == nil { + m1, err = decodeExtension(e1.enc, desc) + } + if m2 == nil && err == nil { + m2, err = decodeExtension(e2.enc, desc) + } + if err != nil { + // The encoded form is invalid. + log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err) + return false + } + if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) { + return false + } + } + + return true +} diff --git a/vendor/github.com/gogo/protobuf/proto/extensions.go b/vendor/github.com/gogo/protobuf/proto/extensions.go new file mode 100644 index 00000000..f7384baa --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/extensions.go @@ -0,0 +1,689 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Types and routines for supporting protocol buffer extensions. + */ + +import ( + "errors" + "fmt" + "reflect" + "strconv" + "sync" +) + +// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message. +var ErrMissingExtension = errors.New("proto: missing extension") + +// ExtensionRange represents a range of message extensions for a protocol buffer. +// Used in code generated by the protocol compiler. +type ExtensionRange struct { + Start, End int32 // both inclusive +} + +// extendableProto is an interface implemented by any protocol buffer generated by the current +// proto compiler that may be extended. +type extendableProto interface { + Message + ExtensionRangeArray() []ExtensionRange + extensionsWrite() map[int32]Extension + extensionsRead() (map[int32]Extension, sync.Locker) +} + +// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous +// version of the proto compiler that may be extended. +type extendableProtoV1 interface { + Message + ExtensionRangeArray() []ExtensionRange + ExtensionMap() map[int32]Extension +} + +type extensionsBytes interface { + Message + ExtensionRangeArray() []ExtensionRange + GetExtensions() *[]byte +} + +// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto. +type extensionAdapter struct { + extendableProtoV1 +} + +func (e extensionAdapter) extensionsWrite() map[int32]Extension { + return e.ExtensionMap() +} + +func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) { + return e.ExtensionMap(), notLocker{} +} + +// notLocker is a sync.Locker whose Lock and Unlock methods are nops. +type notLocker struct{} + +func (n notLocker) Lock() {} +func (n notLocker) Unlock() {} + +// extendable returns the extendableProto interface for the given generated proto message. +// If the proto message has the old extension format, it returns a wrapper that implements +// the extendableProto interface. +func extendable(p interface{}) (extendableProto, bool) { + if ep, ok := p.(extendableProto); ok { + return ep, ok + } + if ep, ok := p.(extendableProtoV1); ok { + return extensionAdapter{ep}, ok + } + return nil, false +} + +// XXX_InternalExtensions is an internal representation of proto extensions. +// +// Each generated message struct type embeds an anonymous XXX_InternalExtensions field, +// thus gaining the unexported 'extensions' method, which can be called only from the proto package. +// +// The methods of XXX_InternalExtensions are not concurrency safe in general, +// but calls to logically read-only methods such as has and get may be executed concurrently. +type XXX_InternalExtensions struct { + // The struct must be indirect so that if a user inadvertently copies a + // generated message and its embedded XXX_InternalExtensions, they + // avoid the mayhem of a copied mutex. + // + // The mutex serializes all logically read-only operations to p.extensionMap. + // It is up to the client to ensure that write operations to p.extensionMap are + // mutually exclusive with other accesses. + p *struct { + mu sync.Mutex + extensionMap map[int32]Extension + } +} + +// extensionsWrite returns the extension map, creating it on first use. +func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension { + if e.p == nil { + e.p = new(struct { + mu sync.Mutex + extensionMap map[int32]Extension + }) + e.p.extensionMap = make(map[int32]Extension) + } + return e.p.extensionMap +} + +// extensionsRead returns the extensions map for read-only use. It may be nil. +// The caller must hold the returned mutex's lock when accessing Elements within the map. +func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) { + if e.p == nil { + return nil, nil + } + return e.p.extensionMap, &e.p.mu +} + +type extensionRange interface { + Message + ExtensionRangeArray() []ExtensionRange +} + +var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem() +var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem() +var extendableBytesType = reflect.TypeOf((*extensionsBytes)(nil)).Elem() +var extensionRangeType = reflect.TypeOf((*extensionRange)(nil)).Elem() + +// ExtensionDesc represents an extension specification. +// Used in generated code from the protocol compiler. +type ExtensionDesc struct { + ExtendedType Message // nil pointer to the type that is being extended + ExtensionType interface{} // nil pointer to the extension type + Field int32 // field number + Name string // fully-qualified name of extension, for text formatting + Tag string // protobuf tag style +} + +func (ed *ExtensionDesc) repeated() bool { + t := reflect.TypeOf(ed.ExtensionType) + return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 +} + +// Extension represents an extension in a message. +type Extension struct { + // When an extension is stored in a message using SetExtension + // only desc and value are set. When the message is marshaled + // enc will be set to the encoded form of the message. + // + // When a message is unmarshaled and contains extensions, each + // extension will have only enc set. When such an extension is + // accessed using GetExtension (or GetExtensions) desc and value + // will be set. + desc *ExtensionDesc + value interface{} + enc []byte +} + +// SetRawExtension is for testing only. +func SetRawExtension(base Message, id int32, b []byte) { + if ebase, ok := base.(extensionsBytes); ok { + clearExtension(base, id) + ext := ebase.GetExtensions() + *ext = append(*ext, b...) + return + } + epb, ok := extendable(base) + if !ok { + return + } + extmap := epb.extensionsWrite() + extmap[id] = Extension{enc: b} +} + +// isExtensionField returns true iff the given field number is in an extension range. +func isExtensionField(pb extensionRange, field int32) bool { + for _, er := range pb.ExtensionRangeArray() { + if er.Start <= field && field <= er.End { + return true + } + } + return false +} + +// checkExtensionTypes checks that the given extension is valid for pb. +func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error { + var pbi interface{} = pb + // Check the extended type. + if ea, ok := pbi.(extensionAdapter); ok { + pbi = ea.extendableProtoV1 + } + if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b { + return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String()) + } + // Check the range. + if !isExtensionField(pb, extension.Field) { + return errors.New("proto: bad extension number; not in declared ranges") + } + return nil +} + +// extPropKey is sufficient to uniquely identify an extension. +type extPropKey struct { + base reflect.Type + field int32 +} + +var extProp = struct { + sync.RWMutex + m map[extPropKey]*Properties +}{ + m: make(map[extPropKey]*Properties), +} + +func extensionProperties(ed *ExtensionDesc) *Properties { + key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field} + + extProp.RLock() + if prop, ok := extProp.m[key]; ok { + extProp.RUnlock() + return prop + } + extProp.RUnlock() + + extProp.Lock() + defer extProp.Unlock() + // Check again. + if prop, ok := extProp.m[key]; ok { + return prop + } + + prop := new(Properties) + prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil) + extProp.m[key] = prop + return prop +} + +// encode encodes any unmarshaled (unencoded) extensions in e. +func encodeExtensions(e *XXX_InternalExtensions) error { + m, mu := e.extensionsRead() + if m == nil { + return nil // fast path + } + mu.Lock() + defer mu.Unlock() + return encodeExtensionsMap(m) +} + +// encode encodes any unmarshaled (unencoded) extensions in e. +func encodeExtensionsMap(m map[int32]Extension) error { + for k, e := range m { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. + continue + } + + // We don't skip extensions that have an encoded form set, + // because the extension value may have been mutated after + // the last time this function was called. + + et := reflect.TypeOf(e.desc.ExtensionType) + props := extensionProperties(e.desc) + + p := NewBuffer(nil) + // If e.value has type T, the encoder expects a *struct{ X T }. + // Pass a *T with a zero field and hope it all works out. + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(e.value)) + if err := props.enc(p, props, toStructPointer(x)); err != nil { + return err + } + e.enc = p.buf + m[k] = e + } + return nil +} + +func extensionsSize(e *XXX_InternalExtensions) (n int) { + m, mu := e.extensionsRead() + if m == nil { + return 0 + } + mu.Lock() + defer mu.Unlock() + return extensionsMapSize(m) +} + +func extensionsMapSize(m map[int32]Extension) (n int) { + for _, e := range m { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. + n += len(e.enc) + continue + } + + // We don't skip extensions that have an encoded form set, + // because the extension value may have been mutated after + // the last time this function was called. + + et := reflect.TypeOf(e.desc.ExtensionType) + props := extensionProperties(e.desc) + + // If e.value has type T, the encoder expects a *struct{ X T }. + // Pass a *T with a zero field and hope it all works out. + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(e.value)) + n += props.size(props, toStructPointer(x)) + } + return +} + +// HasExtension returns whether the given extension is present in pb. +func HasExtension(pb Message, extension *ExtensionDesc) bool { + if epb, doki := pb.(extensionsBytes); doki { + ext := epb.GetExtensions() + buf := *ext + o := 0 + for o < len(buf) { + tag, n := DecodeVarint(buf[o:]) + fieldNum := int32(tag >> 3) + if int32(fieldNum) == extension.Field { + return true + } + wireType := int(tag & 0x7) + o += n + l, err := size(buf[o:], wireType) + if err != nil { + return false + } + o += l + } + return false + } + // TODO: Check types, field numbers, etc.? + epb, ok := extendable(pb) + if !ok { + return false + } + extmap, mu := epb.extensionsRead() + if extmap == nil { + return false + } + mu.Lock() + _, ok = extmap[extension.Field] + mu.Unlock() + return ok +} + +func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int { + ext := pb.GetExtensions() + for offset < len(*ext) { + tag, n1 := DecodeVarint((*ext)[offset:]) + fieldNum := int32(tag >> 3) + wireType := int(tag & 0x7) + n2, err := size((*ext)[offset+n1:], wireType) + if err != nil { + panic(err) + } + newOffset := offset + n1 + n2 + if fieldNum == theFieldNum { + *ext = append((*ext)[:offset], (*ext)[newOffset:]...) + return offset + } + offset = newOffset + } + return -1 +} + +// ClearExtension removes the given extension from pb. +func ClearExtension(pb Message, extension *ExtensionDesc) { + clearExtension(pb, extension.Field) +} + +func clearExtension(pb Message, fieldNum int32) { + if epb, doki := pb.(extensionsBytes); doki { + offset := 0 + for offset != -1 { + offset = deleteExtension(epb, fieldNum, offset) + } + return + } + epb, ok := extendable(pb) + if !ok { + return + } + // TODO: Check types, field numbers, etc.? + extmap := epb.extensionsWrite() + delete(extmap, fieldNum) +} + +// GetExtension parses and returns the given extension of pb. +// If the extension is not present and has no default value it returns ErrMissingExtension. +func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) { + if epb, doki := pb.(extensionsBytes); doki { + ext := epb.GetExtensions() + o := 0 + for o < len(*ext) { + tag, n := DecodeVarint((*ext)[o:]) + fieldNum := int32(tag >> 3) + wireType := int(tag & 0x7) + l, err := size((*ext)[o+n:], wireType) + if err != nil { + return nil, err + } + if int32(fieldNum) == extension.Field { + v, err := decodeExtension((*ext)[o:o+n+l], extension) + if err != nil { + return nil, err + } + return v, nil + } + o += n + l + } + return defaultExtensionValue(extension) + } + epb, ok := extendable(pb) + if !ok { + return nil, errors.New("proto: not an extendable proto") + } + if err := checkExtensionTypes(epb, extension); err != nil { + return nil, err + } + + emap, mu := epb.extensionsRead() + if emap == nil { + return defaultExtensionValue(extension) + } + mu.Lock() + defer mu.Unlock() + e, ok := emap[extension.Field] + if !ok { + // defaultExtensionValue returns the default value or + // ErrMissingExtension if there is no default. + return defaultExtensionValue(extension) + } + + if e.value != nil { + // Already decoded. Check the descriptor, though. + if e.desc != extension { + // This shouldn't happen. If it does, it means that + // GetExtension was called twice with two different + // descriptors with the same field number. + return nil, errors.New("proto: descriptor conflict") + } + return e.value, nil + } + + v, err := decodeExtension(e.enc, extension) + if err != nil { + return nil, err + } + + // Remember the decoded version and drop the encoded version. + // That way it is safe to mutate what we return. + e.value = v + e.desc = extension + e.enc = nil + emap[extension.Field] = e + return e.value, nil +} + +// defaultExtensionValue returns the default value for extension. +// If no default for an extension is defined ErrMissingExtension is returned. +func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) { + t := reflect.TypeOf(extension.ExtensionType) + props := extensionProperties(extension) + + sf, _, err := fieldDefault(t, props) + if err != nil { + return nil, err + } + + if sf == nil || sf.value == nil { + // There is no default value. + return nil, ErrMissingExtension + } + + if t.Kind() != reflect.Ptr { + // We do not need to return a Ptr, we can directly return sf.value. + return sf.value, nil + } + + // We need to return an interface{} that is a pointer to sf.value. + value := reflect.New(t).Elem() + value.Set(reflect.New(value.Type().Elem())) + if sf.kind == reflect.Int32 { + // We may have an int32 or an enum, but the underlying data is int32. + // Since we can't set an int32 into a non int32 reflect.value directly + // set it as a int32. + value.Elem().SetInt(int64(sf.value.(int32))) + } else { + value.Elem().Set(reflect.ValueOf(sf.value)) + } + return value.Interface(), nil +} + +// decodeExtension decodes an extension encoded in b. +func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) { + o := NewBuffer(b) + + t := reflect.TypeOf(extension.ExtensionType) + + props := extensionProperties(extension) + + // t is a pointer to a struct, pointer to basic type or a slice. + // Allocate a "field" to store the pointer/slice itself; the + // pointer/slice will be stored here. We pass + // the address of this field to props.dec. + // This passes a zero field and a *t and lets props.dec + // interpret it as a *struct{ x t }. + value := reflect.New(t).Elem() + + for { + // Discard wire type and field number varint. It isn't needed. + if _, err := o.DecodeVarint(); err != nil { + return nil, err + } + + if err := props.dec(o, props, toStructPointer(value.Addr())); err != nil { + return nil, err + } + + if o.index >= len(o.buf) { + break + } + } + return value.Interface(), nil +} + +// GetExtensions returns a slice of the extensions present in pb that are also listed in es. +// The returned slice has the same length as es; missing extensions will appear as nil elements. +func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) { + extensions = make([]interface{}, len(es)) + for i, e := range es { + extensions[i], err = GetExtension(pb, e) + if err == ErrMissingExtension { + err = nil + } + if err != nil { + return + } + } + return +} + +// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order. +// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing +// just the Field field, which defines the extension's field number. +func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) { + epb, ok := extendable(pb) + if !ok { + return nil, fmt.Errorf("proto: %T is not an extendable proto.Message", pb) + } + registeredExtensions := RegisteredExtensions(pb) + + emap, mu := epb.extensionsRead() + mu.Lock() + defer mu.Unlock() + extensions := make([]*ExtensionDesc, 0, len(emap)) + for extid, e := range emap { + desc := e.desc + if desc == nil { + desc = registeredExtensions[extid] + if desc == nil { + desc = &ExtensionDesc{Field: extid} + } + } + + extensions = append(extensions, desc) + } + return extensions, nil +} + +// SetExtension sets the specified extension of pb to the specified value. +func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error { + if epb, doki := pb.(extensionsBytes); doki { + ClearExtension(pb, extension) + ext := epb.GetExtensions() + et := reflect.TypeOf(extension.ExtensionType) + props := extensionProperties(extension) + p := NewBuffer(nil) + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(value)) + if err := props.enc(p, props, toStructPointer(x)); err != nil { + return err + } + *ext = append(*ext, p.buf...) + return nil + } + epb, ok := extendable(pb) + if !ok { + return errors.New("proto: not an extendable proto") + } + if err := checkExtensionTypes(epb, extension); err != nil { + return err + } + typ := reflect.TypeOf(extension.ExtensionType) + if typ != reflect.TypeOf(value) { + return errors.New("proto: bad extension value type") + } + // nil extension values need to be caught early, because the + // encoder can't distinguish an ErrNil due to a nil extension + // from an ErrNil due to a missing field. Extensions are + // always optional, so the encoder would just swallow the error + // and drop all the extensions from the encoded message. + if reflect.ValueOf(value).IsNil() { + return fmt.Errorf("proto: SetExtension called with nil value of type %T", value) + } + + extmap := epb.extensionsWrite() + extmap[extension.Field] = Extension{desc: extension, value: value} + return nil +} + +// ClearAllExtensions clears all extensions from pb. +func ClearAllExtensions(pb Message) { + if epb, doki := pb.(extensionsBytes); doki { + ext := epb.GetExtensions() + *ext = []byte{} + return + } + epb, ok := extendable(pb) + if !ok { + return + } + m := epb.extensionsWrite() + for k := range m { + delete(m, k) + } +} + +// A global registry of extensions. +// The generated code will register the generated descriptors by calling RegisterExtension. + +var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc) + +// RegisterExtension is called from the generated code. +func RegisterExtension(desc *ExtensionDesc) { + st := reflect.TypeOf(desc.ExtendedType).Elem() + m := extensionMaps[st] + if m == nil { + m = make(map[int32]*ExtensionDesc) + extensionMaps[st] = m + } + if _, ok := m[desc.Field]; ok { + panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field))) + } + m[desc.Field] = desc +} + +// RegisteredExtensions returns a map of the registered extensions of a +// protocol buffer struct, indexed by the extension number. +// The argument pb should be a nil pointer to the struct type. +func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc { + return extensionMaps[reflect.TypeOf(pb).Elem()] +} diff --git a/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go b/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go new file mode 100644 index 00000000..ea6478f0 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go @@ -0,0 +1,294 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +import ( + "bytes" + "errors" + "fmt" + "reflect" + "sort" + "strings" + "sync" +) + +func GetBoolExtension(pb Message, extension *ExtensionDesc, ifnotset bool) bool { + if reflect.ValueOf(pb).IsNil() { + return ifnotset + } + value, err := GetExtension(pb, extension) + if err != nil { + return ifnotset + } + if value == nil { + return ifnotset + } + if value.(*bool) == nil { + return ifnotset + } + return *(value.(*bool)) +} + +func (this *Extension) Equal(that *Extension) bool { + return bytes.Equal(this.enc, that.enc) +} + +func (this *Extension) Compare(that *Extension) int { + return bytes.Compare(this.enc, that.enc) +} + +func SizeOfInternalExtension(m extendableProto) (n int) { + return SizeOfExtensionMap(m.extensionsWrite()) +} + +func SizeOfExtensionMap(m map[int32]Extension) (n int) { + return extensionsMapSize(m) +} + +type sortableMapElem struct { + field int32 + ext Extension +} + +func newSortableExtensionsFromMap(m map[int32]Extension) sortableExtensions { + s := make(sortableExtensions, 0, len(m)) + for k, v := range m { + s = append(s, &sortableMapElem{field: k, ext: v}) + } + return s +} + +type sortableExtensions []*sortableMapElem + +func (this sortableExtensions) Len() int { return len(this) } + +func (this sortableExtensions) Swap(i, j int) { this[i], this[j] = this[j], this[i] } + +func (this sortableExtensions) Less(i, j int) bool { return this[i].field < this[j].field } + +func (this sortableExtensions) String() string { + sort.Sort(this) + ss := make([]string, len(this)) + for i := range this { + ss[i] = fmt.Sprintf("%d: %v", this[i].field, this[i].ext) + } + return "map[" + strings.Join(ss, ",") + "]" +} + +func StringFromInternalExtension(m extendableProto) string { + return StringFromExtensionsMap(m.extensionsWrite()) +} + +func StringFromExtensionsMap(m map[int32]Extension) string { + return newSortableExtensionsFromMap(m).String() +} + +func StringFromExtensionsBytes(ext []byte) string { + m, err := BytesToExtensionsMap(ext) + if err != nil { + panic(err) + } + return StringFromExtensionsMap(m) +} + +func EncodeInternalExtension(m extendableProto, data []byte) (n int, err error) { + return EncodeExtensionMap(m.extensionsWrite(), data) +} + +func EncodeExtensionMap(m map[int32]Extension, data []byte) (n int, err error) { + if err := encodeExtensionsMap(m); err != nil { + return 0, err + } + keys := make([]int, 0, len(m)) + for k := range m { + keys = append(keys, int(k)) + } + sort.Ints(keys) + for _, k := range keys { + n += copy(data[n:], m[int32(k)].enc) + } + return n, nil +} + +func GetRawExtension(m map[int32]Extension, id int32) ([]byte, error) { + if m[id].value == nil || m[id].desc == nil { + return m[id].enc, nil + } + if err := encodeExtensionsMap(m); err != nil { + return nil, err + } + return m[id].enc, nil +} + +func size(buf []byte, wire int) (int, error) { + switch wire { + case WireVarint: + _, n := DecodeVarint(buf) + return n, nil + case WireFixed64: + return 8, nil + case WireBytes: + v, n := DecodeVarint(buf) + return int(v) + n, nil + case WireFixed32: + return 4, nil + case WireStartGroup: + offset := 0 + for { + u, n := DecodeVarint(buf[offset:]) + fwire := int(u & 0x7) + offset += n + if fwire == WireEndGroup { + return offset, nil + } + s, err := size(buf[offset:], wire) + if err != nil { + return 0, err + } + offset += s + } + } + return 0, fmt.Errorf("proto: can't get size for unknown wire type %d", wire) +} + +func BytesToExtensionsMap(buf []byte) (map[int32]Extension, error) { + m := make(map[int32]Extension) + i := 0 + for i < len(buf) { + tag, n := DecodeVarint(buf[i:]) + if n <= 0 { + return nil, fmt.Errorf("unable to decode varint") + } + fieldNum := int32(tag >> 3) + wireType := int(tag & 0x7) + l, err := size(buf[i+n:], wireType) + if err != nil { + return nil, err + } + end := i + int(l) + n + m[int32(fieldNum)] = Extension{enc: buf[i:end]} + i = end + } + return m, nil +} + +func NewExtension(e []byte) Extension { + ee := Extension{enc: make([]byte, len(e))} + copy(ee.enc, e) + return ee +} + +func AppendExtension(e Message, tag int32, buf []byte) { + if ee, eok := e.(extensionsBytes); eok { + ext := ee.GetExtensions() + *ext = append(*ext, buf...) + return + } + if ee, eok := e.(extendableProto); eok { + m := ee.extensionsWrite() + ext := m[int32(tag)] // may be missing + ext.enc = append(ext.enc, buf...) + m[int32(tag)] = ext + } +} + +func encodeExtension(e *Extension) error { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. + return nil + } + // We don't skip extensions that have an encoded form set, + // because the extension value may have been mutated after + // the last time this function was called. + + et := reflect.TypeOf(e.desc.ExtensionType) + props := extensionProperties(e.desc) + + p := NewBuffer(nil) + // If e.value has type T, the encoder expects a *struct{ X T }. + // Pass a *T with a zero field and hope it all works out. + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(e.value)) + if err := props.enc(p, props, toStructPointer(x)); err != nil { + return err + } + e.enc = p.buf + return nil +} + +func (this Extension) GoString() string { + if this.enc == nil { + if err := encodeExtension(&this); err != nil { + panic(err) + } + } + return fmt.Sprintf("proto.NewExtension(%#v)", this.enc) +} + +func SetUnsafeExtension(pb Message, fieldNum int32, value interface{}) error { + typ := reflect.TypeOf(pb).Elem() + ext, ok := extensionMaps[typ] + if !ok { + return fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String()) + } + desc, ok := ext[fieldNum] + if !ok { + return errors.New("proto: bad extension number; not in declared ranges") + } + return SetExtension(pb, desc, value) +} + +func GetUnsafeExtension(pb Message, fieldNum int32) (interface{}, error) { + typ := reflect.TypeOf(pb).Elem() + ext, ok := extensionMaps[typ] + if !ok { + return nil, fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String()) + } + desc, ok := ext[fieldNum] + if !ok { + return nil, fmt.Errorf("unregistered field number %d", fieldNum) + } + return GetExtension(pb, desc) +} + +func NewUnsafeXXX_InternalExtensions(m map[int32]Extension) XXX_InternalExtensions { + x := &XXX_InternalExtensions{ + p: new(struct { + mu sync.Mutex + extensionMap map[int32]Extension + }), + } + x.p.extensionMap = m + return *x +} + +func GetUnsafeExtensionsMap(extendable Message) map[int32]Extension { + pb := extendable.(extendableProto) + return pb.extensionsWrite() +} diff --git a/vendor/github.com/gogo/protobuf/proto/lib.go b/vendor/github.com/gogo/protobuf/proto/lib.go new file mode 100644 index 00000000..2c30d709 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/lib.go @@ -0,0 +1,898 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* +Package proto converts data structures to and from the wire format of +protocol buffers. It works in concert with the Go source code generated +for .proto files by the protocol compiler. + +A summary of the properties of the protocol buffer interface +for a protocol buffer variable v: + + - Names are turned from camel_case to CamelCase for export. + - There are no methods on v to set fields; just treat + them as structure fields. + - There are getters that return a field's value if set, + and return the field's default value if unset. + The getters work even if the receiver is a nil message. + - The zero value for a struct is its correct initialization state. + All desired fields must be set before marshaling. + - A Reset() method will restore a protobuf struct to its zero state. + - Non-repeated fields are pointers to the values; nil means unset. + That is, optional or required field int32 f becomes F *int32. + - Repeated fields are slices. + - Helper functions are available to aid the setting of fields. + msg.Foo = proto.String("hello") // set field + - Constants are defined to hold the default values of all fields that + have them. They have the form Default_StructName_FieldName. + Because the getter methods handle defaulted values, + direct use of these constants should be rare. + - Enums are given type names and maps from names to values. + Enum values are prefixed by the enclosing message's name, or by the + enum's type name if it is a top-level enum. Enum types have a String + method, and a Enum method to assist in message construction. + - Nested messages, groups and enums have type names prefixed with the name of + the surrounding message type. + - Extensions are given descriptor names that start with E_, + followed by an underscore-delimited list of the nested messages + that contain it (if any) followed by the CamelCased name of the + extension field itself. HasExtension, ClearExtension, GetExtension + and SetExtension are functions for manipulating extensions. + - Oneof field sets are given a single field in their message, + with distinguished wrapper types for each possible field value. + - Marshal and Unmarshal are functions to encode and decode the wire format. + +When the .proto file specifies `syntax="proto3"`, there are some differences: + + - Non-repeated fields of non-message type are values instead of pointers. + - Getters are only generated for message and oneof fields. + - Enum types do not get an Enum method. + +The simplest way to describe this is to see an example. +Given file test.proto, containing + + package example; + + enum FOO { X = 17; } + + message Test { + required string label = 1; + optional int32 type = 2 [default=77]; + repeated int64 reps = 3; + optional group OptionalGroup = 4 { + required string RequiredField = 5; + } + oneof union { + int32 number = 6; + string name = 7; + } + } + +The resulting file, test.pb.go, is: + + package example + + import proto "github.com/gogo/protobuf/proto" + import math "math" + + type FOO int32 + const ( + FOO_X FOO = 17 + ) + var FOO_name = map[int32]string{ + 17: "X", + } + var FOO_value = map[string]int32{ + "X": 17, + } + + func (x FOO) Enum() *FOO { + p := new(FOO) + *p = x + return p + } + func (x FOO) String() string { + return proto.EnumName(FOO_name, int32(x)) + } + func (x *FOO) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FOO_value, data) + if err != nil { + return err + } + *x = FOO(value) + return nil + } + + type Test struct { + Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"` + Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"` + Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"` + Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"` + // Types that are valid to be assigned to Union: + // *Test_Number + // *Test_Name + Union isTest_Union `protobuf_oneof:"union"` + XXX_unrecognized []byte `json:"-"` + } + func (m *Test) Reset() { *m = Test{} } + func (m *Test) String() string { return proto.CompactTextString(m) } + func (*Test) ProtoMessage() {} + + type isTest_Union interface { + isTest_Union() + } + + type Test_Number struct { + Number int32 `protobuf:"varint,6,opt,name=number"` + } + type Test_Name struct { + Name string `protobuf:"bytes,7,opt,name=name"` + } + + func (*Test_Number) isTest_Union() {} + func (*Test_Name) isTest_Union() {} + + func (m *Test) GetUnion() isTest_Union { + if m != nil { + return m.Union + } + return nil + } + const Default_Test_Type int32 = 77 + + func (m *Test) GetLabel() string { + if m != nil && m.Label != nil { + return *m.Label + } + return "" + } + + func (m *Test) GetType() int32 { + if m != nil && m.Type != nil { + return *m.Type + } + return Default_Test_Type + } + + func (m *Test) GetOptionalgroup() *Test_OptionalGroup { + if m != nil { + return m.Optionalgroup + } + return nil + } + + type Test_OptionalGroup struct { + RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"` + } + func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} } + func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) } + + func (m *Test_OptionalGroup) GetRequiredField() string { + if m != nil && m.RequiredField != nil { + return *m.RequiredField + } + return "" + } + + func (m *Test) GetNumber() int32 { + if x, ok := m.GetUnion().(*Test_Number); ok { + return x.Number + } + return 0 + } + + func (m *Test) GetName() string { + if x, ok := m.GetUnion().(*Test_Name); ok { + return x.Name + } + return "" + } + + func init() { + proto.RegisterEnum("example.FOO", FOO_name, FOO_value) + } + +To create and play with a Test object: + + package main + + import ( + "log" + + "github.com/gogo/protobuf/proto" + pb "./example.pb" + ) + + func main() { + test := &pb.Test{ + Label: proto.String("hello"), + Type: proto.Int32(17), + Reps: []int64{1, 2, 3}, + Optionalgroup: &pb.Test_OptionalGroup{ + RequiredField: proto.String("good bye"), + }, + Union: &pb.Test_Name{"fred"}, + } + data, err := proto.Marshal(test) + if err != nil { + log.Fatal("marshaling error: ", err) + } + newTest := &pb.Test{} + err = proto.Unmarshal(data, newTest) + if err != nil { + log.Fatal("unmarshaling error: ", err) + } + // Now test and newTest contain the same data. + if test.GetLabel() != newTest.GetLabel() { + log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) + } + // Use a type switch to determine which oneof was set. + switch u := test.Union.(type) { + case *pb.Test_Number: // u.Number contains the number. + case *pb.Test_Name: // u.Name contains the string. + } + // etc. + } +*/ +package proto + +import ( + "encoding/json" + "fmt" + "log" + "reflect" + "sort" + "strconv" + "sync" +) + +// Message is implemented by generated protocol buffer messages. +type Message interface { + Reset() + String() string + ProtoMessage() +} + +// Stats records allocation details about the protocol buffer encoders +// and decoders. Useful for tuning the library itself. +type Stats struct { + Emalloc uint64 // mallocs in encode + Dmalloc uint64 // mallocs in decode + Encode uint64 // number of encodes + Decode uint64 // number of decodes + Chit uint64 // number of cache hits + Cmiss uint64 // number of cache misses + Size uint64 // number of sizes +} + +// Set to true to enable stats collection. +const collectStats = false + +var stats Stats + +// GetStats returns a copy of the global Stats structure. +func GetStats() Stats { return stats } + +// A Buffer is a buffer manager for marshaling and unmarshaling +// protocol buffers. It may be reused between invocations to +// reduce memory usage. It is not necessary to use a Buffer; +// the global functions Marshal and Unmarshal create a +// temporary Buffer and are fine for most applications. +type Buffer struct { + buf []byte // encode/decode byte stream + index int // write point + + // pools of basic types to amortize allocation. + bools []bool + uint32s []uint32 + uint64s []uint64 + + // extra pools, only used with pointer_reflect.go + int32s []int32 + int64s []int64 + float32s []float32 + float64s []float64 +} + +// NewBuffer allocates a new Buffer and initializes its internal data to +// the contents of the argument slice. +func NewBuffer(e []byte) *Buffer { + return &Buffer{buf: e} +} + +// Reset resets the Buffer, ready for marshaling a new protocol buffer. +func (p *Buffer) Reset() { + p.buf = p.buf[0:0] // for reading/writing + p.index = 0 // for reading +} + +// SetBuf replaces the internal buffer with the slice, +// ready for unmarshaling the contents of the slice. +func (p *Buffer) SetBuf(s []byte) { + p.buf = s + p.index = 0 +} + +// Bytes returns the contents of the Buffer. +func (p *Buffer) Bytes() []byte { return p.buf } + +/* + * Helper routines for simplifying the creation of optional fields of basic type. + */ + +// Bool is a helper routine that allocates a new bool value +// to store v and returns a pointer to it. +func Bool(v bool) *bool { + return &v +} + +// Int32 is a helper routine that allocates a new int32 value +// to store v and returns a pointer to it. +func Int32(v int32) *int32 { + return &v +} + +// Int is a helper routine that allocates a new int32 value +// to store v and returns a pointer to it, but unlike Int32 +// its argument value is an int. +func Int(v int) *int32 { + p := new(int32) + *p = int32(v) + return p +} + +// Int64 is a helper routine that allocates a new int64 value +// to store v and returns a pointer to it. +func Int64(v int64) *int64 { + return &v +} + +// Float32 is a helper routine that allocates a new float32 value +// to store v and returns a pointer to it. +func Float32(v float32) *float32 { + return &v +} + +// Float64 is a helper routine that allocates a new float64 value +// to store v and returns a pointer to it. +func Float64(v float64) *float64 { + return &v +} + +// Uint32 is a helper routine that allocates a new uint32 value +// to store v and returns a pointer to it. +func Uint32(v uint32) *uint32 { + return &v +} + +// Uint64 is a helper routine that allocates a new uint64 value +// to store v and returns a pointer to it. +func Uint64(v uint64) *uint64 { + return &v +} + +// String is a helper routine that allocates a new string value +// to store v and returns a pointer to it. +func String(v string) *string { + return &v +} + +// EnumName is a helper function to simplify printing protocol buffer enums +// by name. Given an enum map and a value, it returns a useful string. +func EnumName(m map[int32]string, v int32) string { + s, ok := m[v] + if ok { + return s + } + return strconv.Itoa(int(v)) +} + +// UnmarshalJSONEnum is a helper function to simplify recovering enum int values +// from their JSON-encoded representation. Given a map from the enum's symbolic +// names to its int values, and a byte buffer containing the JSON-encoded +// value, it returns an int32 that can be cast to the enum type by the caller. +// +// The function can deal with both JSON representations, numeric and symbolic. +func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) { + if data[0] == '"' { + // New style: enums are strings. + var repr string + if err := json.Unmarshal(data, &repr); err != nil { + return -1, err + } + val, ok := m[repr] + if !ok { + return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr) + } + return val, nil + } + // Old style: enums are ints. + var val int32 + if err := json.Unmarshal(data, &val); err != nil { + return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName) + } + return val, nil +} + +// DebugPrint dumps the encoded data in b in a debugging format with a header +// including the string s. Used in testing but made available for general debugging. +func (p *Buffer) DebugPrint(s string, b []byte) { + var u uint64 + + obuf := p.buf + sindex := p.index + p.buf = b + p.index = 0 + depth := 0 + + fmt.Printf("\n--- %s ---\n", s) + +out: + for { + for i := 0; i < depth; i++ { + fmt.Print(" ") + } + + index := p.index + if index == len(p.buf) { + break + } + + op, err := p.DecodeVarint() + if err != nil { + fmt.Printf("%3d: fetching op err %v\n", index, err) + break out + } + tag := op >> 3 + wire := op & 7 + + switch wire { + default: + fmt.Printf("%3d: t=%3d unknown wire=%d\n", + index, tag, wire) + break out + + case WireBytes: + var r []byte + + r, err = p.DecodeRawBytes(false) + if err != nil { + break out + } + fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r)) + if len(r) <= 6 { + for i := 0; i < len(r); i++ { + fmt.Printf(" %.2x", r[i]) + } + } else { + for i := 0; i < 3; i++ { + fmt.Printf(" %.2x", r[i]) + } + fmt.Printf(" ..") + for i := len(r) - 3; i < len(r); i++ { + fmt.Printf(" %.2x", r[i]) + } + } + fmt.Printf("\n") + + case WireFixed32: + u, err = p.DecodeFixed32() + if err != nil { + fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u) + + case WireFixed64: + u, err = p.DecodeFixed64() + if err != nil { + fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u) + + case WireVarint: + u, err = p.DecodeVarint() + if err != nil { + fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u) + + case WireStartGroup: + fmt.Printf("%3d: t=%3d start\n", index, tag) + depth++ + + case WireEndGroup: + depth-- + fmt.Printf("%3d: t=%3d end\n", index, tag) + } + } + + if depth != 0 { + fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth) + } + fmt.Printf("\n") + + p.buf = obuf + p.index = sindex +} + +// SetDefaults sets unset protocol buffer fields to their default values. +// It only modifies fields that are both unset and have defined defaults. +// It recursively sets default values in any non-nil sub-messages. +func SetDefaults(pb Message) { + setDefaults(reflect.ValueOf(pb), true, false) +} + +// v is a pointer to a struct. +func setDefaults(v reflect.Value, recur, zeros bool) { + v = v.Elem() + + defaultMu.RLock() + dm, ok := defaults[v.Type()] + defaultMu.RUnlock() + if !ok { + dm = buildDefaultMessage(v.Type()) + defaultMu.Lock() + defaults[v.Type()] = dm + defaultMu.Unlock() + } + + for _, sf := range dm.scalars { + f := v.Field(sf.index) + if !f.IsNil() { + // field already set + continue + } + dv := sf.value + if dv == nil && !zeros { + // no explicit default, and don't want to set zeros + continue + } + fptr := f.Addr().Interface() // **T + // TODO: Consider batching the allocations we do here. + switch sf.kind { + case reflect.Bool: + b := new(bool) + if dv != nil { + *b = dv.(bool) + } + *(fptr.(**bool)) = b + case reflect.Float32: + f := new(float32) + if dv != nil { + *f = dv.(float32) + } + *(fptr.(**float32)) = f + case reflect.Float64: + f := new(float64) + if dv != nil { + *f = dv.(float64) + } + *(fptr.(**float64)) = f + case reflect.Int32: + // might be an enum + if ft := f.Type(); ft != int32PtrType { + // enum + f.Set(reflect.New(ft.Elem())) + if dv != nil { + f.Elem().SetInt(int64(dv.(int32))) + } + } else { + // int32 field + i := new(int32) + if dv != nil { + *i = dv.(int32) + } + *(fptr.(**int32)) = i + } + case reflect.Int64: + i := new(int64) + if dv != nil { + *i = dv.(int64) + } + *(fptr.(**int64)) = i + case reflect.String: + s := new(string) + if dv != nil { + *s = dv.(string) + } + *(fptr.(**string)) = s + case reflect.Uint8: + // exceptional case: []byte + var b []byte + if dv != nil { + db := dv.([]byte) + b = make([]byte, len(db)) + copy(b, db) + } else { + b = []byte{} + } + *(fptr.(*[]byte)) = b + case reflect.Uint32: + u := new(uint32) + if dv != nil { + *u = dv.(uint32) + } + *(fptr.(**uint32)) = u + case reflect.Uint64: + u := new(uint64) + if dv != nil { + *u = dv.(uint64) + } + *(fptr.(**uint64)) = u + default: + log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind) + } + } + + for _, ni := range dm.nested { + f := v.Field(ni) + // f is *T or []*T or map[T]*T + switch f.Kind() { + case reflect.Ptr: + if f.IsNil() { + continue + } + setDefaults(f, recur, zeros) + + case reflect.Slice: + for i := 0; i < f.Len(); i++ { + e := f.Index(i) + if e.IsNil() { + continue + } + setDefaults(e, recur, zeros) + } + + case reflect.Map: + for _, k := range f.MapKeys() { + e := f.MapIndex(k) + if e.IsNil() { + continue + } + setDefaults(e, recur, zeros) + } + } + } +} + +var ( + // defaults maps a protocol buffer struct type to a slice of the fields, + // with its scalar fields set to their proto-declared non-zero default values. + defaultMu sync.RWMutex + defaults = make(map[reflect.Type]defaultMessage) + + int32PtrType = reflect.TypeOf((*int32)(nil)) +) + +// defaultMessage represents information about the default values of a message. +type defaultMessage struct { + scalars []scalarField + nested []int // struct field index of nested messages +} + +type scalarField struct { + index int // struct field index + kind reflect.Kind // element type (the T in *T or []T) + value interface{} // the proto-declared default value, or nil +} + +// t is a struct type. +func buildDefaultMessage(t reflect.Type) (dm defaultMessage) { + sprop := GetProperties(t) + for _, prop := range sprop.Prop { + fi, ok := sprop.decoderTags.get(prop.Tag) + if !ok { + // XXX_unrecognized + continue + } + ft := t.Field(fi).Type + + sf, nested, err := fieldDefault(ft, prop) + switch { + case err != nil: + log.Print(err) + case nested: + dm.nested = append(dm.nested, fi) + case sf != nil: + sf.index = fi + dm.scalars = append(dm.scalars, *sf) + } + } + + return dm +} + +// fieldDefault returns the scalarField for field type ft. +// sf will be nil if the field can not have a default. +// nestedMessage will be true if this is a nested message. +// Note that sf.index is not set on return. +func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) { + var canHaveDefault bool + switch ft.Kind() { + case reflect.Ptr: + if ft.Elem().Kind() == reflect.Struct { + nestedMessage = true + } else { + canHaveDefault = true // proto2 scalar field + } + + case reflect.Slice: + switch ft.Elem().Kind() { + case reflect.Ptr: + nestedMessage = true // repeated message + case reflect.Uint8: + canHaveDefault = true // bytes field + } + + case reflect.Map: + if ft.Elem().Kind() == reflect.Ptr { + nestedMessage = true // map with message values + } + } + + if !canHaveDefault { + if nestedMessage { + return nil, true, nil + } + return nil, false, nil + } + + // We now know that ft is a pointer or slice. + sf = &scalarField{kind: ft.Elem().Kind()} + + // scalar fields without defaults + if !prop.HasDefault { + return sf, false, nil + } + + // a scalar field: either *T or []byte + switch ft.Elem().Kind() { + case reflect.Bool: + x, err := strconv.ParseBool(prop.Default) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err) + } + sf.value = x + case reflect.Float32: + x, err := strconv.ParseFloat(prop.Default, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err) + } + sf.value = float32(x) + case reflect.Float64: + x, err := strconv.ParseFloat(prop.Default, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err) + } + sf.value = x + case reflect.Int32: + x, err := strconv.ParseInt(prop.Default, 10, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err) + } + sf.value = int32(x) + case reflect.Int64: + x, err := strconv.ParseInt(prop.Default, 10, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err) + } + sf.value = x + case reflect.String: + sf.value = prop.Default + case reflect.Uint8: + // []byte (not *uint8) + sf.value = []byte(prop.Default) + case reflect.Uint32: + x, err := strconv.ParseUint(prop.Default, 10, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err) + } + sf.value = uint32(x) + case reflect.Uint64: + x, err := strconv.ParseUint(prop.Default, 10, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err) + } + sf.value = x + default: + return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind()) + } + + return sf, false, nil +} + +// Map fields may have key types of non-float scalars, strings and enums. +// The easiest way to sort them in some deterministic order is to use fmt. +// If this turns out to be inefficient we can always consider other options, +// such as doing a Schwartzian transform. + +func mapKeys(vs []reflect.Value) sort.Interface { + s := mapKeySorter{ + vs: vs, + // default Less function: textual comparison + less: func(a, b reflect.Value) bool { + return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface()) + }, + } + + // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps; + // numeric keys are sorted numerically. + if len(vs) == 0 { + return s + } + switch vs[0].Kind() { + case reflect.Int32, reflect.Int64: + s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() } + case reflect.Uint32, reflect.Uint64: + s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() } + } + + return s +} + +type mapKeySorter struct { + vs []reflect.Value + less func(a, b reflect.Value) bool +} + +func (s mapKeySorter) Len() int { return len(s.vs) } +func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] } +func (s mapKeySorter) Less(i, j int) bool { + return s.less(s.vs[i], s.vs[j]) +} + +// isProto3Zero reports whether v is a zero proto3 value. +func isProto3Zero(v reflect.Value) bool { + switch v.Kind() { + case reflect.Bool: + return !v.Bool() + case reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint32, reflect.Uint64: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.String: + return v.String() == "" + } + return false +} + +// ProtoPackageIsVersion2 is referenced from generated protocol buffer files +// to assert that that code is compatible with this version of the proto package. +const GoGoProtoPackageIsVersion2 = true + +// ProtoPackageIsVersion1 is referenced from generated protocol buffer files +// to assert that that code is compatible with this version of the proto package. +const GoGoProtoPackageIsVersion1 = true diff --git a/vendor/github.com/gogo/protobuf/proto/lib_gogo.go b/vendor/github.com/gogo/protobuf/proto/lib_gogo.go new file mode 100644 index 00000000..4b4f7c90 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/lib_gogo.go @@ -0,0 +1,42 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +import ( + "encoding/json" + "strconv" +) + +func MarshalJSONEnum(m map[int32]string, value int32) ([]byte, error) { + s, ok := m[value] + if !ok { + s = strconv.Itoa(int(value)) + } + return json.Marshal(s) +} diff --git a/vendor/github.com/gogo/protobuf/proto/message_set.go b/vendor/github.com/gogo/protobuf/proto/message_set.go new file mode 100644 index 00000000..fd982dec --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/message_set.go @@ -0,0 +1,311 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Support for message sets. + */ + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "reflect" + "sort" +) + +// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID. +// A message type ID is required for storing a protocol buffer in a message set. +var errNoMessageTypeID = errors.New("proto does not have a message type ID") + +// The first two types (_MessageSet_Item and messageSet) +// model what the protocol compiler produces for the following protocol message: +// message MessageSet { +// repeated group Item = 1 { +// required int32 type_id = 2; +// required string message = 3; +// }; +// } +// That is the MessageSet wire format. We can't use a proto to generate these +// because that would introduce a circular dependency between it and this package. + +type _MessageSet_Item struct { + TypeId *int32 `protobuf:"varint,2,req,name=type_id"` + Message []byte `protobuf:"bytes,3,req,name=message"` +} + +type messageSet struct { + Item []*_MessageSet_Item `protobuf:"group,1,rep"` + XXX_unrecognized []byte + // TODO: caching? +} + +// Make sure messageSet is a Message. +var _ Message = (*messageSet)(nil) + +// messageTypeIder is an interface satisfied by a protocol buffer type +// that may be stored in a MessageSet. +type messageTypeIder interface { + MessageTypeId() int32 +} + +func (ms *messageSet) find(pb Message) *_MessageSet_Item { + mti, ok := pb.(messageTypeIder) + if !ok { + return nil + } + id := mti.MessageTypeId() + for _, item := range ms.Item { + if *item.TypeId == id { + return item + } + } + return nil +} + +func (ms *messageSet) Has(pb Message) bool { + if ms.find(pb) != nil { + return true + } + return false +} + +func (ms *messageSet) Unmarshal(pb Message) error { + if item := ms.find(pb); item != nil { + return Unmarshal(item.Message, pb) + } + if _, ok := pb.(messageTypeIder); !ok { + return errNoMessageTypeID + } + return nil // TODO: return error instead? +} + +func (ms *messageSet) Marshal(pb Message) error { + msg, err := Marshal(pb) + if err != nil { + return err + } + if item := ms.find(pb); item != nil { + // reuse existing item + item.Message = msg + return nil + } + + mti, ok := pb.(messageTypeIder) + if !ok { + return errNoMessageTypeID + } + + mtid := mti.MessageTypeId() + ms.Item = append(ms.Item, &_MessageSet_Item{ + TypeId: &mtid, + Message: msg, + }) + return nil +} + +func (ms *messageSet) Reset() { *ms = messageSet{} } +func (ms *messageSet) String() string { return CompactTextString(ms) } +func (*messageSet) ProtoMessage() {} + +// Support for the message_set_wire_format message option. + +func skipVarint(buf []byte) []byte { + i := 0 + for ; buf[i]&0x80 != 0; i++ { + } + return buf[i+1:] +} + +// MarshalMessageSet encodes the extension map represented by m in the message set wire format. +// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option. +func MarshalMessageSet(exts interface{}) ([]byte, error) { + var m map[int32]Extension + switch exts := exts.(type) { + case *XXX_InternalExtensions: + if err := encodeExtensions(exts); err != nil { + return nil, err + } + m, _ = exts.extensionsRead() + case map[int32]Extension: + if err := encodeExtensionsMap(exts); err != nil { + return nil, err + } + m = exts + default: + return nil, errors.New("proto: not an extension map") + } + + // Sort extension IDs to provide a deterministic encoding. + // See also enc_map in encode.go. + ids := make([]int, 0, len(m)) + for id := range m { + ids = append(ids, int(id)) + } + sort.Ints(ids) + + ms := &messageSet{Item: make([]*_MessageSet_Item, 0, len(m))} + for _, id := range ids { + e := m[int32(id)] + // Remove the wire type and field number varint, as well as the length varint. + msg := skipVarint(skipVarint(e.enc)) + + ms.Item = append(ms.Item, &_MessageSet_Item{ + TypeId: Int32(int32(id)), + Message: msg, + }) + } + return Marshal(ms) +} + +// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format. +// It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option. +func UnmarshalMessageSet(buf []byte, exts interface{}) error { + var m map[int32]Extension + switch exts := exts.(type) { + case *XXX_InternalExtensions: + m = exts.extensionsWrite() + case map[int32]Extension: + m = exts + default: + return errors.New("proto: not an extension map") + } + + ms := new(messageSet) + if err := Unmarshal(buf, ms); err != nil { + return err + } + for _, item := range ms.Item { + id := *item.TypeId + msg := item.Message + + // Restore wire type and field number varint, plus length varint. + // Be careful to preserve duplicate items. + b := EncodeVarint(uint64(id)<<3 | WireBytes) + if ext, ok := m[id]; ok { + // Existing data; rip off the tag and length varint + // so we join the new data correctly. + // We can assume that ext.enc is set because we are unmarshaling. + o := ext.enc[len(b):] // skip wire type and field number + _, n := DecodeVarint(o) // calculate length of length varint + o = o[n:] // skip length varint + msg = append(o, msg...) // join old data and new data + } + b = append(b, EncodeVarint(uint64(len(msg)))...) + b = append(b, msg...) + + m[id] = Extension{enc: b} + } + return nil +} + +// MarshalMessageSetJSON encodes the extension map represented by m in JSON format. +// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option. +func MarshalMessageSetJSON(exts interface{}) ([]byte, error) { + var m map[int32]Extension + switch exts := exts.(type) { + case *XXX_InternalExtensions: + m, _ = exts.extensionsRead() + case map[int32]Extension: + m = exts + default: + return nil, errors.New("proto: not an extension map") + } + var b bytes.Buffer + b.WriteByte('{') + + // Process the map in key order for deterministic output. + ids := make([]int32, 0, len(m)) + for id := range m { + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) // int32Slice defined in text.go + + for i, id := range ids { + ext := m[id] + if i > 0 { + b.WriteByte(',') + } + + msd, ok := messageSetMap[id] + if !ok { + // Unknown type; we can't render it, so skip it. + continue + } + fmt.Fprintf(&b, `"[%s]":`, msd.name) + + x := ext.value + if x == nil { + x = reflect.New(msd.t.Elem()).Interface() + if err := Unmarshal(ext.enc, x.(Message)); err != nil { + return nil, err + } + } + d, err := json.Marshal(x) + if err != nil { + return nil, err + } + b.Write(d) + } + b.WriteByte('}') + return b.Bytes(), nil +} + +// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format. +// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option. +func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error { + // Common-case fast path. + if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) { + return nil + } + + // This is fairly tricky, and it's not clear that it is needed. + return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented") +} + +// A global registry of types that can be used in a MessageSet. + +var messageSetMap = make(map[int32]messageSetDesc) + +type messageSetDesc struct { + t reflect.Type // pointer to struct + name string +} + +// RegisterMessageSetType is called from the generated code. +func RegisterMessageSetType(m Message, fieldNum int32, name string) { + messageSetMap[fieldNum] = messageSetDesc{ + t: reflect.TypeOf(m), + name: name, + } +} diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go b/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go new file mode 100644 index 00000000..fb512e2e --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go @@ -0,0 +1,484 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// +build appengine js + +// This file contains an implementation of proto field accesses using package reflect. +// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can +// be used on App Engine. + +package proto + +import ( + "math" + "reflect" +) + +// A structPointer is a pointer to a struct. +type structPointer struct { + v reflect.Value +} + +// toStructPointer returns a structPointer equivalent to the given reflect value. +// The reflect value must itself be a pointer to a struct. +func toStructPointer(v reflect.Value) structPointer { + return structPointer{v} +} + +// IsNil reports whether p is nil. +func structPointer_IsNil(p structPointer) bool { + return p.v.IsNil() +} + +// Interface returns the struct pointer as an interface value. +func structPointer_Interface(p structPointer, _ reflect.Type) interface{} { + return p.v.Interface() +} + +// A field identifies a field in a struct, accessible from a structPointer. +// In this implementation, a field is identified by the sequence of field indices +// passed to reflect's FieldByIndex. +type field []int + +// toField returns a field equivalent to the given reflect field. +func toField(f *reflect.StructField) field { + return f.Index +} + +// invalidField is an invalid field identifier. +var invalidField = field(nil) + +// IsValid reports whether the field identifier is valid. +func (f field) IsValid() bool { return f != nil } + +// field returns the given field in the struct as a reflect value. +func structPointer_field(p structPointer, f field) reflect.Value { + // Special case: an extension map entry with a value of type T + // passes a *T to the struct-handling code with a zero field, + // expecting that it will be treated as equivalent to *struct{ X T }, + // which has the same memory layout. We have to handle that case + // specially, because reflect will panic if we call FieldByIndex on a + // non-struct. + if f == nil { + return p.v.Elem() + } + + return p.v.Elem().FieldByIndex(f) +} + +// ifield returns the given field in the struct as an interface value. +func structPointer_ifield(p structPointer, f field) interface{} { + return structPointer_field(p, f).Addr().Interface() +} + +// Bytes returns the address of a []byte field in the struct. +func structPointer_Bytes(p structPointer, f field) *[]byte { + return structPointer_ifield(p, f).(*[]byte) +} + +// BytesSlice returns the address of a [][]byte field in the struct. +func structPointer_BytesSlice(p structPointer, f field) *[][]byte { + return structPointer_ifield(p, f).(*[][]byte) +} + +// Bool returns the address of a *bool field in the struct. +func structPointer_Bool(p structPointer, f field) **bool { + return structPointer_ifield(p, f).(**bool) +} + +// BoolVal returns the address of a bool field in the struct. +func structPointer_BoolVal(p structPointer, f field) *bool { + return structPointer_ifield(p, f).(*bool) +} + +// BoolSlice returns the address of a []bool field in the struct. +func structPointer_BoolSlice(p structPointer, f field) *[]bool { + return structPointer_ifield(p, f).(*[]bool) +} + +// String returns the address of a *string field in the struct. +func structPointer_String(p structPointer, f field) **string { + return structPointer_ifield(p, f).(**string) +} + +// StringVal returns the address of a string field in the struct. +func structPointer_StringVal(p structPointer, f field) *string { + return structPointer_ifield(p, f).(*string) +} + +// StringSlice returns the address of a []string field in the struct. +func structPointer_StringSlice(p structPointer, f field) *[]string { + return structPointer_ifield(p, f).(*[]string) +} + +// Extensions returns the address of an extension map field in the struct. +func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions { + return structPointer_ifield(p, f).(*XXX_InternalExtensions) +} + +// ExtMap returns the address of an extension map field in the struct. +func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { + return structPointer_ifield(p, f).(*map[int32]Extension) +} + +// NewAt returns the reflect.Value for a pointer to a field in the struct. +func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { + return structPointer_field(p, f).Addr() +} + +// SetStructPointer writes a *struct field in the struct. +func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { + structPointer_field(p, f).Set(q.v) +} + +// GetStructPointer reads a *struct field in the struct. +func structPointer_GetStructPointer(p structPointer, f field) structPointer { + return structPointer{structPointer_field(p, f)} +} + +// StructPointerSlice the address of a []*struct field in the struct. +func structPointer_StructPointerSlice(p structPointer, f field) structPointerSlice { + return structPointerSlice{structPointer_field(p, f)} +} + +// A structPointerSlice represents the address of a slice of pointers to structs +// (themselves messages or groups). That is, v.Type() is *[]*struct{...}. +type structPointerSlice struct { + v reflect.Value +} + +func (p structPointerSlice) Len() int { return p.v.Len() } +func (p structPointerSlice) Index(i int) structPointer { return structPointer{p.v.Index(i)} } +func (p structPointerSlice) Append(q structPointer) { + p.v.Set(reflect.Append(p.v, q.v)) +} + +var ( + int32Type = reflect.TypeOf(int32(0)) + uint32Type = reflect.TypeOf(uint32(0)) + float32Type = reflect.TypeOf(float32(0)) + int64Type = reflect.TypeOf(int64(0)) + uint64Type = reflect.TypeOf(uint64(0)) + float64Type = reflect.TypeOf(float64(0)) +) + +// A word32 represents a field of type *int32, *uint32, *float32, or *enum. +// That is, v.Type() is *int32, *uint32, *float32, or *enum and v is assignable. +type word32 struct { + v reflect.Value +} + +// IsNil reports whether p is nil. +func word32_IsNil(p word32) bool { + return p.v.IsNil() +} + +// Set sets p to point at a newly allocated word with bits set to x. +func word32_Set(p word32, o *Buffer, x uint32) { + t := p.v.Type().Elem() + switch t { + case int32Type: + if len(o.int32s) == 0 { + o.int32s = make([]int32, uint32PoolSize) + } + o.int32s[0] = int32(x) + p.v.Set(reflect.ValueOf(&o.int32s[0])) + o.int32s = o.int32s[1:] + return + case uint32Type: + if len(o.uint32s) == 0 { + o.uint32s = make([]uint32, uint32PoolSize) + } + o.uint32s[0] = x + p.v.Set(reflect.ValueOf(&o.uint32s[0])) + o.uint32s = o.uint32s[1:] + return + case float32Type: + if len(o.float32s) == 0 { + o.float32s = make([]float32, uint32PoolSize) + } + o.float32s[0] = math.Float32frombits(x) + p.v.Set(reflect.ValueOf(&o.float32s[0])) + o.float32s = o.float32s[1:] + return + } + + // must be enum + p.v.Set(reflect.New(t)) + p.v.Elem().SetInt(int64(int32(x))) +} + +// Get gets the bits pointed at by p, as a uint32. +func word32_Get(p word32) uint32 { + elem := p.v.Elem() + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32 returns a reference to a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32(p structPointer, f field) word32 { + return word32{structPointer_field(p, f)} +} + +// A word32Val represents a field of type int32, uint32, float32, or enum. +// That is, v.Type() is int32, uint32, float32, or enum and v is assignable. +type word32Val struct { + v reflect.Value +} + +// Set sets *p to x. +func word32Val_Set(p word32Val, x uint32) { + switch p.v.Type() { + case int32Type: + p.v.SetInt(int64(x)) + return + case uint32Type: + p.v.SetUint(uint64(x)) + return + case float32Type: + p.v.SetFloat(float64(math.Float32frombits(x))) + return + } + + // must be enum + p.v.SetInt(int64(int32(x))) +} + +// Get gets the bits pointed at by p, as a uint32. +func word32Val_Get(p word32Val) uint32 { + elem := p.v + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32Val returns a reference to a int32, uint32, float32, or enum field in the struct. +func structPointer_Word32Val(p structPointer, f field) word32Val { + return word32Val{structPointer_field(p, f)} +} + +// A word32Slice is a slice of 32-bit values. +// That is, v.Type() is []int32, []uint32, []float32, or []enum. +type word32Slice struct { + v reflect.Value +} + +func (p word32Slice) Append(x uint32) { + n, m := p.v.Len(), p.v.Cap() + if n < m { + p.v.SetLen(n + 1) + } else { + t := p.v.Type().Elem() + p.v.Set(reflect.Append(p.v, reflect.Zero(t))) + } + elem := p.v.Index(n) + switch elem.Kind() { + case reflect.Int32: + elem.SetInt(int64(int32(x))) + case reflect.Uint32: + elem.SetUint(uint64(x)) + case reflect.Float32: + elem.SetFloat(float64(math.Float32frombits(x))) + } +} + +func (p word32Slice) Len() int { + return p.v.Len() +} + +func (p word32Slice) Index(i int) uint32 { + elem := p.v.Index(i) + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32Slice returns a reference to a []int32, []uint32, []float32, or []enum field in the struct. +func structPointer_Word32Slice(p structPointer, f field) word32Slice { + return word32Slice{structPointer_field(p, f)} +} + +// word64 is like word32 but for 64-bit values. +type word64 struct { + v reflect.Value +} + +func word64_Set(p word64, o *Buffer, x uint64) { + t := p.v.Type().Elem() + switch t { + case int64Type: + if len(o.int64s) == 0 { + o.int64s = make([]int64, uint64PoolSize) + } + o.int64s[0] = int64(x) + p.v.Set(reflect.ValueOf(&o.int64s[0])) + o.int64s = o.int64s[1:] + return + case uint64Type: + if len(o.uint64s) == 0 { + o.uint64s = make([]uint64, uint64PoolSize) + } + o.uint64s[0] = x + p.v.Set(reflect.ValueOf(&o.uint64s[0])) + o.uint64s = o.uint64s[1:] + return + case float64Type: + if len(o.float64s) == 0 { + o.float64s = make([]float64, uint64PoolSize) + } + o.float64s[0] = math.Float64frombits(x) + p.v.Set(reflect.ValueOf(&o.float64s[0])) + o.float64s = o.float64s[1:] + return + } + panic("unreachable") +} + +func word64_IsNil(p word64) bool { + return p.v.IsNil() +} + +func word64_Get(p word64) uint64 { + elem := p.v.Elem() + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return elem.Uint() + case reflect.Float64: + return math.Float64bits(elem.Float()) + } + panic("unreachable") +} + +func structPointer_Word64(p structPointer, f field) word64 { + return word64{structPointer_field(p, f)} +} + +// word64Val is like word32Val but for 64-bit values. +type word64Val struct { + v reflect.Value +} + +func word64Val_Set(p word64Val, o *Buffer, x uint64) { + switch p.v.Type() { + case int64Type: + p.v.SetInt(int64(x)) + return + case uint64Type: + p.v.SetUint(x) + return + case float64Type: + p.v.SetFloat(math.Float64frombits(x)) + return + } + panic("unreachable") +} + +func word64Val_Get(p word64Val) uint64 { + elem := p.v + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return elem.Uint() + case reflect.Float64: + return math.Float64bits(elem.Float()) + } + panic("unreachable") +} + +func structPointer_Word64Val(p structPointer, f field) word64Val { + return word64Val{structPointer_field(p, f)} +} + +type word64Slice struct { + v reflect.Value +} + +func (p word64Slice) Append(x uint64) { + n, m := p.v.Len(), p.v.Cap() + if n < m { + p.v.SetLen(n + 1) + } else { + t := p.v.Type().Elem() + p.v.Set(reflect.Append(p.v, reflect.Zero(t))) + } + elem := p.v.Index(n) + switch elem.Kind() { + case reflect.Int64: + elem.SetInt(int64(int64(x))) + case reflect.Uint64: + elem.SetUint(uint64(x)) + case reflect.Float64: + elem.SetFloat(float64(math.Float64frombits(x))) + } +} + +func (p word64Slice) Len() int { + return p.v.Len() +} + +func (p word64Slice) Index(i int) uint64 { + elem := p.v.Index(i) + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return uint64(elem.Uint()) + case reflect.Float64: + return math.Float64bits(float64(elem.Float())) + } + panic("unreachable") +} + +func structPointer_Word64Slice(p structPointer, f field) word64Slice { + return word64Slice{structPointer_field(p, f)} +} diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go new file mode 100644 index 00000000..6b5567d4 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go @@ -0,0 +1,270 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// +build !appengine,!js + +// This file contains the implementation of the proto field accesses using package unsafe. + +package proto + +import ( + "reflect" + "unsafe" +) + +// NOTE: These type_Foo functions would more idiomatically be methods, +// but Go does not allow methods on pointer types, and we must preserve +// some pointer type for the garbage collector. We use these +// funcs with clunky names as our poor approximation to methods. +// +// An alternative would be +// type structPointer struct { p unsafe.Pointer } +// but that does not registerize as well. + +// A structPointer is a pointer to a struct. +type structPointer unsafe.Pointer + +// toStructPointer returns a structPointer equivalent to the given reflect value. +func toStructPointer(v reflect.Value) structPointer { + return structPointer(unsafe.Pointer(v.Pointer())) +} + +// IsNil reports whether p is nil. +func structPointer_IsNil(p structPointer) bool { + return p == nil +} + +// Interface returns the struct pointer, assumed to have element type t, +// as an interface value. +func structPointer_Interface(p structPointer, t reflect.Type) interface{} { + return reflect.NewAt(t, unsafe.Pointer(p)).Interface() +} + +// A field identifies a field in a struct, accessible from a structPointer. +// In this implementation, a field is identified by its byte offset from the start of the struct. +type field uintptr + +// toField returns a field equivalent to the given reflect field. +func toField(f *reflect.StructField) field { + return field(f.Offset) +} + +// invalidField is an invalid field identifier. +const invalidField = ^field(0) + +// IsValid reports whether the field identifier is valid. +func (f field) IsValid() bool { + return f != ^field(0) +} + +// Bytes returns the address of a []byte field in the struct. +func structPointer_Bytes(p structPointer, f field) *[]byte { + return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BytesSlice returns the address of a [][]byte field in the struct. +func structPointer_BytesSlice(p structPointer, f field) *[][]byte { + return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// Bool returns the address of a *bool field in the struct. +func structPointer_Bool(p structPointer, f field) **bool { + return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BoolVal returns the address of a bool field in the struct. +func structPointer_BoolVal(p structPointer, f field) *bool { + return (*bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BoolSlice returns the address of a []bool field in the struct. +func structPointer_BoolSlice(p structPointer, f field) *[]bool { + return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// String returns the address of a *string field in the struct. +func structPointer_String(p structPointer, f field) **string { + return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StringVal returns the address of a string field in the struct. +func structPointer_StringVal(p structPointer, f field) *string { + return (*string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StringSlice returns the address of a []string field in the struct. +func structPointer_StringSlice(p structPointer, f field) *[]string { + return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// ExtMap returns the address of an extension map field in the struct. +func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions { + return (*XXX_InternalExtensions)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { + return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// NewAt returns the reflect.Value for a pointer to a field in the struct. +func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { + return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f))) +} + +// SetStructPointer writes a *struct field in the struct. +func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { + *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q +} + +// GetStructPointer reads a *struct field in the struct. +func structPointer_GetStructPointer(p structPointer, f field) structPointer { + return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StructPointerSlice the address of a []*struct field in the struct. +func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice { + return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups). +type structPointerSlice []structPointer + +func (v *structPointerSlice) Len() int { return len(*v) } +func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] } +func (v *structPointerSlice) Append(p structPointer) { *v = append(*v, p) } + +// A word32 is the address of a "pointer to 32-bit value" field. +type word32 **uint32 + +// IsNil reports whether *v is nil. +func word32_IsNil(p word32) bool { + return *p == nil +} + +// Set sets *v to point at a newly allocated word set to x. +func word32_Set(p word32, o *Buffer, x uint32) { + if len(o.uint32s) == 0 { + o.uint32s = make([]uint32, uint32PoolSize) + } + o.uint32s[0] = x + *p = &o.uint32s[0] + o.uint32s = o.uint32s[1:] +} + +// Get gets the value pointed at by *v. +func word32_Get(p word32) uint32 { + return **p +} + +// Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32(p structPointer, f field) word32 { + return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// A word32Val is the address of a 32-bit value field. +type word32Val *uint32 + +// Set sets *p to x. +func word32Val_Set(p word32Val, x uint32) { + *p = x +} + +// Get gets the value pointed at by p. +func word32Val_Get(p word32Val) uint32 { + return *p +} + +// Word32Val returns the address of a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32Val(p structPointer, f field) word32Val { + return word32Val((*uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// A word32Slice is a slice of 32-bit values. +type word32Slice []uint32 + +func (v *word32Slice) Append(x uint32) { *v = append(*v, x) } +func (v *word32Slice) Len() int { return len(*v) } +func (v *word32Slice) Index(i int) uint32 { return (*v)[i] } + +// Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct. +func structPointer_Word32Slice(p structPointer, f field) *word32Slice { + return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// word64 is like word32 but for 64-bit values. +type word64 **uint64 + +func word64_Set(p word64, o *Buffer, x uint64) { + if len(o.uint64s) == 0 { + o.uint64s = make([]uint64, uint64PoolSize) + } + o.uint64s[0] = x + *p = &o.uint64s[0] + o.uint64s = o.uint64s[1:] +} + +func word64_IsNil(p word64) bool { + return *p == nil +} + +func word64_Get(p word64) uint64 { + return **p +} + +func structPointer_Word64(p structPointer, f field) word64 { + return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// word64Val is like word32Val but for 64-bit values. +type word64Val *uint64 + +func word64Val_Set(p word64Val, o *Buffer, x uint64) { + *p = x +} + +func word64Val_Get(p word64Val) uint64 { + return *p +} + +func structPointer_Word64Val(p structPointer, f field) word64Val { + return word64Val((*uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// word64Slice is like word32Slice but for 64-bit values. +type word64Slice []uint64 + +func (v *word64Slice) Append(x uint64) { *v = append(*v, x) } +func (v *word64Slice) Len() int { return len(*v) } +func (v *word64Slice) Index(i int) uint64 { return (*v)[i] } + +func structPointer_Word64Slice(p structPointer, f field) *word64Slice { + return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go new file mode 100644 index 00000000..ad7c8517 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go @@ -0,0 +1,107 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// +build !appengine + +// This file contains the implementation of the proto field accesses using package unsafe. + +package proto + +import ( + "reflect" + "unsafe" +) + +func structPointer_InterfaceAt(p structPointer, f field, t reflect.Type) interface{} { + point := unsafe.Pointer(uintptr(p) + uintptr(f)) + r := reflect.NewAt(t, point) + return r.Interface() +} + +func structPointer_InterfaceRef(p structPointer, f field, t reflect.Type) interface{} { + point := unsafe.Pointer(uintptr(p) + uintptr(f)) + r := reflect.NewAt(t, point) + if r.Elem().IsNil() { + return nil + } + return r.Elem().Interface() +} + +func copyUintPtr(oldptr, newptr uintptr, size int) { + oldbytes := make([]byte, 0) + oldslice := (*reflect.SliceHeader)(unsafe.Pointer(&oldbytes)) + oldslice.Data = oldptr + oldslice.Len = size + oldslice.Cap = size + newbytes := make([]byte, 0) + newslice := (*reflect.SliceHeader)(unsafe.Pointer(&newbytes)) + newslice.Data = newptr + newslice.Len = size + newslice.Cap = size + copy(newbytes, oldbytes) +} + +func structPointer_Copy(oldptr structPointer, newptr structPointer, size int) { + copyUintPtr(uintptr(oldptr), uintptr(newptr), size) +} + +func appendStructPointer(base structPointer, f field, typ reflect.Type) structPointer { + size := typ.Elem().Size() + + oldHeader := structPointer_GetSliceHeader(base, f) + oldSlice := reflect.NewAt(typ, unsafe.Pointer(oldHeader)).Elem() + newLen := oldHeader.Len + 1 + newSlice := reflect.MakeSlice(typ, newLen, newLen) + reflect.Copy(newSlice, oldSlice) + bas := toStructPointer(newSlice) + oldHeader.Data = uintptr(bas) + oldHeader.Len = newLen + oldHeader.Cap = newLen + + return structPointer(unsafe.Pointer(uintptr(unsafe.Pointer(bas)) + uintptr(uintptr(newLen-1)*size))) +} + +func structPointer_FieldPointer(p structPointer, f field) structPointer { + return structPointer(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +func structPointer_GetRefStructPointer(p structPointer, f field) structPointer { + return structPointer((*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +func structPointer_GetSliceHeader(p structPointer, f field) *reflect.SliceHeader { + return (*reflect.SliceHeader)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +func structPointer_Add(p structPointer, size field) structPointer { + return structPointer(unsafe.Pointer(uintptr(p) + uintptr(size))) +} + +func structPointer_Len(p structPointer, f field) int { + return len(*(*[]interface{})(unsafe.Pointer(structPointer_GetRefStructPointer(p, f)))) +} diff --git a/vendor/github.com/gogo/protobuf/proto/properties.go b/vendor/github.com/gogo/protobuf/proto/properties.go new file mode 100644 index 00000000..3e4cad03 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/properties.go @@ -0,0 +1,940 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Routines for encoding data into the wire format for protocol buffers. + */ + +import ( + "fmt" + "log" + "os" + "reflect" + "sort" + "strconv" + "strings" + "sync" +) + +const debug bool = false + +// Constants that identify the encoding of a value on the wire. +const ( + WireVarint = 0 + WireFixed64 = 1 + WireBytes = 2 + WireStartGroup = 3 + WireEndGroup = 4 + WireFixed32 = 5 +) + +const startSize = 10 // initial slice/string sizes + +// Encoders are defined in encode.go +// An encoder outputs the full representation of a field, including its +// tag and encoder type. +type encoder func(p *Buffer, prop *Properties, base structPointer) error + +// A valueEncoder encodes a single integer in a particular encoding. +type valueEncoder func(o *Buffer, x uint64) error + +// Sizers are defined in encode.go +// A sizer returns the encoded size of a field, including its tag and encoder +// type. +type sizer func(prop *Properties, base structPointer) int + +// A valueSizer returns the encoded size of a single integer in a particular +// encoding. +type valueSizer func(x uint64) int + +// Decoders are defined in decode.go +// A decoder creates a value from its wire representation. +// Unrecognized subelements are saved in unrec. +type decoder func(p *Buffer, prop *Properties, base structPointer) error + +// A valueDecoder decodes a single integer in a particular encoding. +type valueDecoder func(o *Buffer) (x uint64, err error) + +// A oneofMarshaler does the marshaling for all oneof fields in a message. +type oneofMarshaler func(Message, *Buffer) error + +// A oneofUnmarshaler does the unmarshaling for a oneof field in a message. +type oneofUnmarshaler func(Message, int, int, *Buffer) (bool, error) + +// A oneofSizer does the sizing for all oneof fields in a message. +type oneofSizer func(Message) int + +// tagMap is an optimization over map[int]int for typical protocol buffer +// use-cases. Encoded protocol buffers are often in tag order with small tag +// numbers. +type tagMap struct { + fastTags []int + slowTags map[int]int +} + +// tagMapFastLimit is the upper bound on the tag number that will be stored in +// the tagMap slice rather than its map. +const tagMapFastLimit = 1024 + +func (p *tagMap) get(t int) (int, bool) { + if t > 0 && t < tagMapFastLimit { + if t >= len(p.fastTags) { + return 0, false + } + fi := p.fastTags[t] + return fi, fi >= 0 + } + fi, ok := p.slowTags[t] + return fi, ok +} + +func (p *tagMap) put(t int, fi int) { + if t > 0 && t < tagMapFastLimit { + for len(p.fastTags) < t+1 { + p.fastTags = append(p.fastTags, -1) + } + p.fastTags[t] = fi + return + } + if p.slowTags == nil { + p.slowTags = make(map[int]int) + } + p.slowTags[t] = fi +} + +// StructProperties represents properties for all the fields of a struct. +// decoderTags and decoderOrigNames should only be used by the decoder. +type StructProperties struct { + Prop []*Properties // properties for each field + reqCount int // required count + decoderTags tagMap // map from proto tag to struct field number + decoderOrigNames map[string]int // map from original name to struct field number + order []int // list of struct field numbers in tag order + unrecField field // field id of the XXX_unrecognized []byte field + extendable bool // is this an extendable proto + + oneofMarshaler oneofMarshaler + oneofUnmarshaler oneofUnmarshaler + oneofSizer oneofSizer + stype reflect.Type + + // OneofTypes contains information about the oneof fields in this message. + // It is keyed by the original name of a field. + OneofTypes map[string]*OneofProperties +} + +// OneofProperties represents information about a specific field in a oneof. +type OneofProperties struct { + Type reflect.Type // pointer to generated struct type for this oneof field + Field int // struct field number of the containing oneof in the message + Prop *Properties +} + +// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec. +// See encode.go, (*Buffer).enc_struct. + +func (sp *StructProperties) Len() int { return len(sp.order) } +func (sp *StructProperties) Less(i, j int) bool { + return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag +} +func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] } + +// Properties represents the protocol-specific behavior of a single struct field. +type Properties struct { + Name string // name of the field, for error messages + OrigName string // original name before protocol compiler (always set) + JSONName string // name to use for JSON; determined by protoc + Wire string + WireType int + Tag int + Required bool + Optional bool + Repeated bool + Packed bool // relevant for repeated primitives only + Enum string // set for enum types only + proto3 bool // whether this is known to be a proto3 field; set for []byte only + oneof bool // whether this is a oneof field + + Default string // default value + HasDefault bool // whether an explicit default was provided + CustomType string + def_uint64 uint64 + + enc encoder + valEnc valueEncoder // set for bool and numeric types only + field field + tagcode []byte // encoding of EncodeVarint((Tag<<3)|WireType) + tagbuf [8]byte + stype reflect.Type // set for struct types only + sstype reflect.Type // set for slices of structs types only + ctype reflect.Type // set for custom types only + sprop *StructProperties // set for struct types only + isMarshaler bool + isUnmarshaler bool + + mtype reflect.Type // set for map types only + mkeyprop *Properties // set for map types only + mvalprop *Properties // set for map types only + + size sizer + valSize valueSizer // set for bool and numeric types only + + dec decoder + valDec valueDecoder // set for bool and numeric types only + + // If this is a packable field, this will be the decoder for the packed version of the field. + packedDec decoder +} + +// String formats the properties in the protobuf struct field tag style. +func (p *Properties) String() string { + s := p.Wire + s = "," + s += strconv.Itoa(p.Tag) + if p.Required { + s += ",req" + } + if p.Optional { + s += ",opt" + } + if p.Repeated { + s += ",rep" + } + if p.Packed { + s += ",packed" + } + s += ",name=" + p.OrigName + if p.JSONName != p.OrigName { + s += ",json=" + p.JSONName + } + if p.proto3 { + s += ",proto3" + } + if p.oneof { + s += ",oneof" + } + if len(p.Enum) > 0 { + s += ",enum=" + p.Enum + } + if p.HasDefault { + s += ",def=" + p.Default + } + return s +} + +// Parse populates p by parsing a string in the protobuf struct field tag style. +func (p *Properties) Parse(s string) { + // "bytes,49,opt,name=foo,def=hello!" + fields := strings.Split(s, ",") // breaks def=, but handled below. + if len(fields) < 2 { + fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s) + return + } + + p.Wire = fields[0] + switch p.Wire { + case "varint": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeVarint + p.valDec = (*Buffer).DecodeVarint + p.valSize = sizeVarint + case "fixed32": + p.WireType = WireFixed32 + p.valEnc = (*Buffer).EncodeFixed32 + p.valDec = (*Buffer).DecodeFixed32 + p.valSize = sizeFixed32 + case "fixed64": + p.WireType = WireFixed64 + p.valEnc = (*Buffer).EncodeFixed64 + p.valDec = (*Buffer).DecodeFixed64 + p.valSize = sizeFixed64 + case "zigzag32": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeZigzag32 + p.valDec = (*Buffer).DecodeZigzag32 + p.valSize = sizeZigzag32 + case "zigzag64": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeZigzag64 + p.valDec = (*Buffer).DecodeZigzag64 + p.valSize = sizeZigzag64 + case "bytes", "group": + p.WireType = WireBytes + // no numeric converter for non-numeric types + default: + fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s) + return + } + + var err error + p.Tag, err = strconv.Atoi(fields[1]) + if err != nil { + return + } + + for i := 2; i < len(fields); i++ { + f := fields[i] + switch { + case f == "req": + p.Required = true + case f == "opt": + p.Optional = true + case f == "rep": + p.Repeated = true + case f == "packed": + p.Packed = true + case strings.HasPrefix(f, "name="): + p.OrigName = f[5:] + case strings.HasPrefix(f, "json="): + p.JSONName = f[5:] + case strings.HasPrefix(f, "enum="): + p.Enum = f[5:] + case f == "proto3": + p.proto3 = true + case f == "oneof": + p.oneof = true + case strings.HasPrefix(f, "def="): + p.HasDefault = true + p.Default = f[4:] // rest of string + if i+1 < len(fields) { + // Commas aren't escaped, and def is always last. + p.Default += "," + strings.Join(fields[i+1:], ",") + break + } + case strings.HasPrefix(f, "embedded="): + p.OrigName = strings.Split(f, "=")[1] + case strings.HasPrefix(f, "customtype="): + p.CustomType = strings.Split(f, "=")[1] + } + } +} + +func logNoSliceEnc(t1, t2 reflect.Type) { + fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2) +} + +var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem() + +// Initialize the fields for encoding and decoding. +func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lockGetProp bool) { + p.enc = nil + p.dec = nil + p.size = nil + if len(p.CustomType) > 0 { + p.setCustomEncAndDec(typ) + p.setTag(lockGetProp) + return + } + switch t1 := typ; t1.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no coders for %v\n", t1) + + // proto3 scalar types + + case reflect.Bool: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_bool + p.dec = (*Buffer).dec_proto3_bool + p.size = size_proto3_bool + } else { + p.enc = (*Buffer).enc_ref_bool + p.dec = (*Buffer).dec_proto3_bool + p.size = size_ref_bool + } + case reflect.Int32: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_int32 + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_proto3_int32 + } else { + p.enc = (*Buffer).enc_ref_int32 + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_ref_int32 + } + case reflect.Uint32: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_uint32 + p.dec = (*Buffer).dec_proto3_int32 // can reuse + p.size = size_proto3_uint32 + } else { + p.enc = (*Buffer).enc_ref_uint32 + p.dec = (*Buffer).dec_proto3_int32 // can reuse + p.size = size_ref_uint32 + } + case reflect.Int64, reflect.Uint64: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_int64 + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_proto3_int64 + } else { + p.enc = (*Buffer).enc_ref_int64 + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_ref_int64 + } + case reflect.Float32: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_uint32 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_proto3_uint32 + } else { + p.enc = (*Buffer).enc_ref_uint32 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_ref_uint32 + } + case reflect.Float64: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_int64 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_proto3_int64 + } else { + p.enc = (*Buffer).enc_ref_int64 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_ref_int64 + } + case reflect.String: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_string + p.dec = (*Buffer).dec_proto3_string + p.size = size_proto3_string + } else { + p.enc = (*Buffer).enc_ref_string + p.dec = (*Buffer).dec_proto3_string + p.size = size_ref_string + } + case reflect.Struct: + p.stype = typ + p.isMarshaler = isMarshaler(typ) + p.isUnmarshaler = isUnmarshaler(typ) + if p.Wire == "bytes" { + p.enc = (*Buffer).enc_ref_struct_message + p.dec = (*Buffer).dec_ref_struct_message + p.size = size_ref_struct_message + } else { + fmt.Fprintf(os.Stderr, "proto: no coders for struct %T\n", typ) + } + + case reflect.Ptr: + switch t2 := t1.Elem(); t2.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no encoder function for %v -> %v\n", t1, t2) + break + case reflect.Bool: + p.enc = (*Buffer).enc_bool + p.dec = (*Buffer).dec_bool + p.size = size_bool + case reflect.Int32: + p.enc = (*Buffer).enc_int32 + p.dec = (*Buffer).dec_int32 + p.size = size_int32 + case reflect.Uint32: + p.enc = (*Buffer).enc_uint32 + p.dec = (*Buffer).dec_int32 // can reuse + p.size = size_uint32 + case reflect.Int64, reflect.Uint64: + p.enc = (*Buffer).enc_int64 + p.dec = (*Buffer).dec_int64 + p.size = size_int64 + case reflect.Float32: + p.enc = (*Buffer).enc_uint32 // can just treat them as bits + p.dec = (*Buffer).dec_int32 + p.size = size_uint32 + case reflect.Float64: + p.enc = (*Buffer).enc_int64 // can just treat them as bits + p.dec = (*Buffer).dec_int64 + p.size = size_int64 + case reflect.String: + p.enc = (*Buffer).enc_string + p.dec = (*Buffer).dec_string + p.size = size_string + case reflect.Struct: + p.stype = t1.Elem() + p.isMarshaler = isMarshaler(t1) + p.isUnmarshaler = isUnmarshaler(t1) + if p.Wire == "bytes" { + p.enc = (*Buffer).enc_struct_message + p.dec = (*Buffer).dec_struct_message + p.size = size_struct_message + } else { + p.enc = (*Buffer).enc_struct_group + p.dec = (*Buffer).dec_struct_group + p.size = size_struct_group + } + } + + case reflect.Slice: + switch t2 := t1.Elem(); t2.Kind() { + default: + logNoSliceEnc(t1, t2) + break + case reflect.Bool: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_bool + p.size = size_slice_packed_bool + } else { + p.enc = (*Buffer).enc_slice_bool + p.size = size_slice_bool + } + p.dec = (*Buffer).dec_slice_bool + p.packedDec = (*Buffer).dec_slice_packed_bool + case reflect.Int32: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int32 + p.size = size_slice_packed_int32 + } else { + p.enc = (*Buffer).enc_slice_int32 + p.size = size_slice_int32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case reflect.Uint32: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_uint32 + p.size = size_slice_packed_uint32 + } else { + p.enc = (*Buffer).enc_slice_uint32 + p.size = size_slice_uint32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case reflect.Int64, reflect.Uint64: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int64 + p.size = size_slice_packed_int64 + } else { + p.enc = (*Buffer).enc_slice_int64 + p.size = size_slice_int64 + } + p.dec = (*Buffer).dec_slice_int64 + p.packedDec = (*Buffer).dec_slice_packed_int64 + case reflect.Uint8: + p.dec = (*Buffer).dec_slice_byte + if p.proto3 { + p.enc = (*Buffer).enc_proto3_slice_byte + p.size = size_proto3_slice_byte + } else { + p.enc = (*Buffer).enc_slice_byte + p.size = size_slice_byte + } + case reflect.Float32, reflect.Float64: + switch t2.Bits() { + case 32: + // can just treat them as bits + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_uint32 + p.size = size_slice_packed_uint32 + } else { + p.enc = (*Buffer).enc_slice_uint32 + p.size = size_slice_uint32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case 64: + // can just treat them as bits + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int64 + p.size = size_slice_packed_int64 + } else { + p.enc = (*Buffer).enc_slice_int64 + p.size = size_slice_int64 + } + p.dec = (*Buffer).dec_slice_int64 + p.packedDec = (*Buffer).dec_slice_packed_int64 + default: + logNoSliceEnc(t1, t2) + break + } + case reflect.String: + p.enc = (*Buffer).enc_slice_string + p.dec = (*Buffer).dec_slice_string + p.size = size_slice_string + case reflect.Ptr: + switch t3 := t2.Elem(); t3.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3) + break + case reflect.Struct: + p.stype = t2.Elem() + p.isMarshaler = isMarshaler(t2) + p.isUnmarshaler = isUnmarshaler(t2) + if p.Wire == "bytes" { + p.enc = (*Buffer).enc_slice_struct_message + p.dec = (*Buffer).dec_slice_struct_message + p.size = size_slice_struct_message + } else { + p.enc = (*Buffer).enc_slice_struct_group + p.dec = (*Buffer).dec_slice_struct_group + p.size = size_slice_struct_group + } + } + case reflect.Slice: + switch t2.Elem().Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem()) + break + case reflect.Uint8: + p.enc = (*Buffer).enc_slice_slice_byte + p.dec = (*Buffer).dec_slice_slice_byte + p.size = size_slice_slice_byte + } + case reflect.Struct: + p.setSliceOfNonPointerStructs(t1) + } + + case reflect.Map: + p.enc = (*Buffer).enc_new_map + p.dec = (*Buffer).dec_new_map + p.size = size_new_map + + p.mtype = t1 + p.mkeyprop = &Properties{} + p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp) + p.mvalprop = &Properties{} + vtype := p.mtype.Elem() + if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice { + // The value type is not a message (*T) or bytes ([]byte), + // so we need encoders for the pointer to this type. + vtype = reflect.PtrTo(vtype) + } + p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp) + } + p.setTag(lockGetProp) +} + +func (p *Properties) setTag(lockGetProp bool) { + // precalculate tag code + wire := p.WireType + if p.Packed { + wire = WireBytes + } + x := uint32(p.Tag)<<3 | uint32(wire) + i := 0 + for i = 0; x > 127; i++ { + p.tagbuf[i] = 0x80 | uint8(x&0x7F) + x >>= 7 + } + p.tagbuf[i] = uint8(x) + p.tagcode = p.tagbuf[0 : i+1] + + if p.stype != nil { + if lockGetProp { + p.sprop = GetProperties(p.stype) + } else { + p.sprop = getPropertiesLocked(p.stype) + } + } +} + +var ( + marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem() + unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem() +) + +// isMarshaler reports whether type t implements Marshaler. +func isMarshaler(t reflect.Type) bool { + return t.Implements(marshalerType) +} + +// isUnmarshaler reports whether type t implements Unmarshaler. +func isUnmarshaler(t reflect.Type) bool { + return t.Implements(unmarshalerType) +} + +// Init populates the properties from a protocol buffer struct tag. +func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) { + p.init(typ, name, tag, f, true) +} + +func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) { + // "bytes,49,opt,def=hello!" + p.Name = name + p.OrigName = name + if f != nil { + p.field = toField(f) + } + if tag == "" { + return + } + p.Parse(tag) + p.setEncAndDec(typ, f, lockGetProp) +} + +var ( + propertiesMu sync.RWMutex + propertiesMap = make(map[reflect.Type]*StructProperties) +) + +// GetProperties returns the list of properties for the type represented by t. +// t must represent a generated struct type of a protocol message. +func GetProperties(t reflect.Type) *StructProperties { + if t.Kind() != reflect.Struct { + panic("proto: type must have kind struct") + } + + // Most calls to GetProperties in a long-running program will be + // retrieving details for types we have seen before. + propertiesMu.RLock() + sprop, ok := propertiesMap[t] + propertiesMu.RUnlock() + if ok { + if collectStats { + stats.Chit++ + } + return sprop + } + + propertiesMu.Lock() + sprop = getPropertiesLocked(t) + propertiesMu.Unlock() + return sprop +} + +// getPropertiesLocked requires that propertiesMu is held. +func getPropertiesLocked(t reflect.Type) *StructProperties { + if prop, ok := propertiesMap[t]; ok { + if collectStats { + stats.Chit++ + } + return prop + } + if collectStats { + stats.Cmiss++ + } + + prop := new(StructProperties) + // in case of recursive protos, fill this in now. + propertiesMap[t] = prop + + // build properties + prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) || + reflect.PtrTo(t).Implements(extendableProtoV1Type) || + reflect.PtrTo(t).Implements(extendableBytesType) + prop.unrecField = invalidField + prop.Prop = make([]*Properties, t.NumField()) + prop.order = make([]int, t.NumField()) + + isOneofMessage := false + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + p := new(Properties) + name := f.Name + p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false) + + if f.Name == "XXX_InternalExtensions" { // special case + p.enc = (*Buffer).enc_exts + p.dec = nil // not needed + p.size = size_exts + } else if f.Name == "XXX_extensions" { // special case + if len(f.Tag.Get("protobuf")) > 0 { + p.enc = (*Buffer).enc_ext_slice_byte + p.dec = nil // not needed + p.size = size_ext_slice_byte + } else { + p.enc = (*Buffer).enc_map + p.dec = nil // not needed + p.size = size_map + } + } else if f.Name == "XXX_unrecognized" { // special case + prop.unrecField = toField(&f) + } + oneof := f.Tag.Get("protobuf_oneof") // special case + if oneof != "" { + isOneofMessage = true + // Oneof fields don't use the traditional protobuf tag. + p.OrigName = oneof + } + prop.Prop[i] = p + prop.order[i] = i + if debug { + print(i, " ", f.Name, " ", t.String(), " ") + if p.Tag > 0 { + print(p.String()) + } + print("\n") + } + if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && oneof == "" { + fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]") + } + } + + // Re-order prop.order. + sort.Sort(prop) + + type oneofMessage interface { + XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{}) + } + if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); isOneofMessage && ok { + var oots []interface{} + prop.oneofMarshaler, prop.oneofUnmarshaler, prop.oneofSizer, oots = om.XXX_OneofFuncs() + prop.stype = t + + // Interpret oneof metadata. + prop.OneofTypes = make(map[string]*OneofProperties) + for _, oot := range oots { + oop := &OneofProperties{ + Type: reflect.ValueOf(oot).Type(), // *T + Prop: new(Properties), + } + sft := oop.Type.Elem().Field(0) + oop.Prop.Name = sft.Name + oop.Prop.Parse(sft.Tag.Get("protobuf")) + // There will be exactly one interface field that + // this new value is assignable to. + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + if f.Type.Kind() != reflect.Interface { + continue + } + if !oop.Type.AssignableTo(f.Type) { + continue + } + oop.Field = i + break + } + prop.OneofTypes[oop.Prop.OrigName] = oop + } + } + + // build required counts + // build tags + reqCount := 0 + prop.decoderOrigNames = make(map[string]int) + for i, p := range prop.Prop { + if strings.HasPrefix(p.Name, "XXX_") { + // Internal fields should not appear in tags/origNames maps. + // They are handled specially when encoding and decoding. + continue + } + if p.Required { + reqCount++ + } + prop.decoderTags.put(p.Tag, i) + prop.decoderOrigNames[p.OrigName] = i + } + prop.reqCount = reqCount + + return prop +} + +// Return the Properties object for the x[0]'th field of the structure. +func propByIndex(t reflect.Type, x []int) *Properties { + if len(x) != 1 { + fmt.Fprintf(os.Stderr, "proto: field index dimension %d (not 1) for type %s\n", len(x), t) + return nil + } + prop := GetProperties(t) + return prop.Prop[x[0]] +} + +// Get the address and type of a pointer to a struct from an interface. +func getbase(pb Message) (t reflect.Type, b structPointer, err error) { + if pb == nil { + err = ErrNil + return + } + // get the reflect type of the pointer to the struct. + t = reflect.TypeOf(pb) + // get the address of the struct. + value := reflect.ValueOf(pb) + b = toStructPointer(value) + return +} + +// A global registry of enum types. +// The generated code will register the generated maps by calling RegisterEnum. + +var enumValueMaps = make(map[string]map[string]int32) +var enumStringMaps = make(map[string]map[int32]string) + +// RegisterEnum is called from the generated code to install the enum descriptor +// maps into the global table to aid parsing text format protocol buffers. +func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) { + if _, ok := enumValueMaps[typeName]; ok { + panic("proto: duplicate enum registered: " + typeName) + } + enumValueMaps[typeName] = valueMap + if _, ok := enumStringMaps[typeName]; ok { + panic("proto: duplicate enum registered: " + typeName) + } + enumStringMaps[typeName] = unusedNameMap +} + +// EnumValueMap returns the mapping from names to integers of the +// enum type enumType, or a nil if not found. +func EnumValueMap(enumType string) map[string]int32 { + return enumValueMaps[enumType] +} + +// A registry of all linked message types. +// The string is a fully-qualified proto name ("pkg.Message"). +var ( + protoTypes = make(map[string]reflect.Type) + revProtoTypes = make(map[reflect.Type]string) +) + +// RegisterType is called from generated code and maps from the fully qualified +// proto name to the type (pointer to struct) of the protocol buffer. +func RegisterType(x Message, name string) { + if _, ok := protoTypes[name]; ok { + // TODO: Some day, make this a panic. + log.Printf("proto: duplicate proto type registered: %s", name) + return + } + t := reflect.TypeOf(x) + protoTypes[name] = t + revProtoTypes[t] = name +} + +// MessageName returns the fully-qualified proto name for the given message type. +func MessageName(x Message) string { return revProtoTypes[reflect.TypeOf(x)] } + +// MessageType returns the message type (pointer to struct) for a named message. +func MessageType(name string) reflect.Type { return protoTypes[name] } + +// A registry of all linked proto files. +var ( + protoFiles = make(map[string][]byte) // file name => fileDescriptor +) + +// RegisterFile is called from generated code and maps from the +// full file name of a .proto file to its compressed FileDescriptorProto. +func RegisterFile(filename string, fileDescriptor []byte) { + protoFiles[filename] = fileDescriptor +} + +// FileDescriptor returns the compressed FileDescriptorProto for a .proto file. +func FileDescriptor(filename string) []byte { return protoFiles[filename] } diff --git a/vendor/github.com/gogo/protobuf/proto/properties_gogo.go b/vendor/github.com/gogo/protobuf/proto/properties_gogo.go new file mode 100644 index 00000000..4607a975 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/properties_gogo.go @@ -0,0 +1,66 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +import ( + "fmt" + "os" + "reflect" +) + +func (p *Properties) setCustomEncAndDec(typ reflect.Type) { + p.ctype = typ + if p.Repeated { + p.enc = (*Buffer).enc_custom_slice_bytes + p.dec = (*Buffer).dec_custom_slice_bytes + p.size = size_custom_slice_bytes + } else if typ.Kind() == reflect.Ptr { + p.enc = (*Buffer).enc_custom_bytes + p.dec = (*Buffer).dec_custom_bytes + p.size = size_custom_bytes + } else { + p.enc = (*Buffer).enc_custom_ref_bytes + p.dec = (*Buffer).dec_custom_ref_bytes + p.size = size_custom_ref_bytes + } +} + +func (p *Properties) setSliceOfNonPointerStructs(typ reflect.Type) { + t2 := typ.Elem() + p.sstype = typ + p.stype = t2 + p.isMarshaler = isMarshaler(t2) + p.isUnmarshaler = isUnmarshaler(t2) + p.enc = (*Buffer).enc_slice_ref_struct_message + p.dec = (*Buffer).dec_slice_ref_struct_message + p.size = size_slice_ref_struct_message + if p.Wire != "bytes" { + fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T \n", typ, t2) + } +} diff --git a/vendor/github.com/gogo/protobuf/proto/skip_gogo.go b/vendor/github.com/gogo/protobuf/proto/skip_gogo.go new file mode 100644 index 00000000..5a5fd93f --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/skip_gogo.go @@ -0,0 +1,119 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +import ( + "fmt" + "io" +) + +func Skip(data []byte) (n int, err error) { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for { + if index >= l { + return 0, io.ErrUnexpectedEOF + } + index++ + if data[index-1] < 0x80 { + break + } + } + return index, nil + case 1: + index += 8 + return index, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if index >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[index] + index++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + index += length + return index, nil + case 3: + for { + var innerWire uint64 + var start int = index + for shift := uint(0); ; shift += 7 { + if index >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[index] + index++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := Skip(data[start:]) + if err != nil { + return 0, err + } + index = start + next + } + return index, nil + case 4: + return index, nil + case 5: + index += 4 + return index, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} diff --git a/vendor/github.com/gogo/protobuf/proto/text.go b/vendor/github.com/gogo/protobuf/proto/text.go new file mode 100644 index 00000000..b3e12e26 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/text.go @@ -0,0 +1,815 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +// Functions for writing the text protocol buffer format. + +import ( + "bufio" + "bytes" + "encoding" + "errors" + "fmt" + "io" + "log" + "math" + "reflect" + "sort" + "strings" + "sync" +) + +var ( + newline = []byte("\n") + spaces = []byte(" ") + gtNewline = []byte(">\n") + endBraceNewline = []byte("}\n") + backslashN = []byte{'\\', 'n'} + backslashR = []byte{'\\', 'r'} + backslashT = []byte{'\\', 't'} + backslashDQ = []byte{'\\', '"'} + backslashBS = []byte{'\\', '\\'} + posInf = []byte("inf") + negInf = []byte("-inf") + nan = []byte("nan") +) + +type writer interface { + io.Writer + WriteByte(byte) error +} + +// textWriter is an io.Writer that tracks its indentation level. +type textWriter struct { + ind int + complete bool // if the current position is a complete line + compact bool // whether to write out as a one-liner + w writer +} + +func (w *textWriter) WriteString(s string) (n int, err error) { + if !strings.Contains(s, "\n") { + if !w.compact && w.complete { + w.writeIndent() + } + w.complete = false + return io.WriteString(w.w, s) + } + // WriteString is typically called without newlines, so this + // codepath and its copy are rare. We copy to avoid + // duplicating all of Write's logic here. + return w.Write([]byte(s)) +} + +func (w *textWriter) Write(p []byte) (n int, err error) { + newlines := bytes.Count(p, newline) + if newlines == 0 { + if !w.compact && w.complete { + w.writeIndent() + } + n, err = w.w.Write(p) + w.complete = false + return n, err + } + + frags := bytes.SplitN(p, newline, newlines+1) + if w.compact { + for i, frag := range frags { + if i > 0 { + if err := w.w.WriteByte(' '); err != nil { + return n, err + } + n++ + } + nn, err := w.w.Write(frag) + n += nn + if err != nil { + return n, err + } + } + return n, nil + } + + for i, frag := range frags { + if w.complete { + w.writeIndent() + } + nn, err := w.w.Write(frag) + n += nn + if err != nil { + return n, err + } + if i+1 < len(frags) { + if err := w.w.WriteByte('\n'); err != nil { + return n, err + } + n++ + } + } + w.complete = len(frags[len(frags)-1]) == 0 + return n, nil +} + +func (w *textWriter) WriteByte(c byte) error { + if w.compact && c == '\n' { + c = ' ' + } + if !w.compact && w.complete { + w.writeIndent() + } + err := w.w.WriteByte(c) + w.complete = c == '\n' + return err +} + +func (w *textWriter) indent() { w.ind++ } + +func (w *textWriter) unindent() { + if w.ind == 0 { + log.Print("proto: textWriter unindented too far") + return + } + w.ind-- +} + +func writeName(w *textWriter, props *Properties) error { + if _, err := w.WriteString(props.OrigName); err != nil { + return err + } + if props.Wire != "group" { + return w.WriteByte(':') + } + return nil +} + +// raw is the interface satisfied by RawMessage. +type raw interface { + Bytes() []byte +} + +func writeStruct(w *textWriter, sv reflect.Value) error { + st := sv.Type() + sprops := GetProperties(st) + for i := 0; i < sv.NumField(); i++ { + fv := sv.Field(i) + props := sprops.Prop[i] + name := st.Field(i).Name + + if strings.HasPrefix(name, "XXX_") { + // There are two XXX_ fields: + // XXX_unrecognized []byte + // XXX_extensions map[int32]proto.Extension + // The first is handled here; + // the second is handled at the bottom of this function. + if name == "XXX_unrecognized" && !fv.IsNil() { + if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil { + return err + } + } + continue + } + if fv.Kind() == reflect.Ptr && fv.IsNil() { + // Field not filled in. This could be an optional field or + // a required field that wasn't filled in. Either way, there + // isn't anything we can show for it. + continue + } + if fv.Kind() == reflect.Slice && fv.IsNil() { + // Repeated field that is empty, or a bytes field that is unused. + continue + } + + if props.Repeated && fv.Kind() == reflect.Slice { + // Repeated field. + for j := 0; j < fv.Len(); j++ { + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + v := fv.Index(j) + if v.Kind() == reflect.Ptr && v.IsNil() { + // A nil message in a repeated field is not valid, + // but we can handle that more gracefully than panicking. + if _, err := w.Write([]byte("\n")); err != nil { + return err + } + continue + } + if len(props.Enum) > 0 { + if err := writeEnum(w, v, props); err != nil { + return err + } + } else if err := writeAny(w, v, props); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + continue + } + if fv.Kind() == reflect.Map { + // Map fields are rendered as a repeated struct with key/value fields. + keys := fv.MapKeys() + sort.Sort(mapKeys(keys)) + for _, key := range keys { + val := fv.MapIndex(key) + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + // open struct + if err := w.WriteByte('<'); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + // key + if _, err := w.WriteString("key:"); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := writeAny(w, key, props.mkeyprop); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + // nil values aren't legal, but we can avoid panicking because of them. + if val.Kind() != reflect.Ptr || !val.IsNil() { + // value + if _, err := w.WriteString("value:"); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := writeAny(w, val, props.mvalprop); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + // close struct + w.unindent() + if err := w.WriteByte('>'); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + continue + } + if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 { + // empty bytes field + continue + } + if props.proto3 && fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice { + // proto3 non-repeated scalar field; skip if zero value + if isProto3Zero(fv) { + continue + } + } + + if fv.Kind() == reflect.Interface { + // Check if it is a oneof. + if st.Field(i).Tag.Get("protobuf_oneof") != "" { + // fv is nil, or holds a pointer to generated struct. + // That generated struct has exactly one field, + // which has a protobuf struct tag. + if fv.IsNil() { + continue + } + inner := fv.Elem().Elem() // interface -> *T -> T + tag := inner.Type().Field(0).Tag.Get("protobuf") + props = new(Properties) // Overwrite the outer props var, but not its pointee. + props.Parse(tag) + // Write the value in the oneof, not the oneof itself. + fv = inner.Field(0) + + // Special case to cope with malformed messages gracefully: + // If the value in the oneof is a nil pointer, don't panic + // in writeAny. + if fv.Kind() == reflect.Ptr && fv.IsNil() { + // Use errors.New so writeAny won't render quotes. + msg := errors.New("/* nil */") + fv = reflect.ValueOf(&msg).Elem() + } + } + } + + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if b, ok := fv.Interface().(raw); ok { + if err := writeRaw(w, b.Bytes()); err != nil { + return err + } + continue + } + + if len(props.Enum) > 0 { + if err := writeEnum(w, fv, props); err != nil { + return err + } + } else if err := writeAny(w, fv, props); err != nil { + return err + } + + if err := w.WriteByte('\n'); err != nil { + return err + } + } + + // Extensions (the XXX_extensions field). + pv := sv + if pv.CanAddr() { + pv = sv.Addr() + } else { + pv = reflect.New(sv.Type()) + pv.Elem().Set(sv) + } + if pv.Type().Implements(extensionRangeType) { + if err := writeExtensions(w, pv); err != nil { + return err + } + } + + return nil +} + +// writeRaw writes an uninterpreted raw message. +func writeRaw(w *textWriter, b []byte) error { + if err := w.WriteByte('<'); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + if err := writeUnknownStruct(w, b); err != nil { + return err + } + w.unindent() + if err := w.WriteByte('>'); err != nil { + return err + } + return nil +} + +// writeAny writes an arbitrary field. +func writeAny(w *textWriter, v reflect.Value, props *Properties) error { + v = reflect.Indirect(v) + + if props != nil && len(props.CustomType) > 0 { + custom, ok := v.Interface().(Marshaler) + if ok { + data, err := custom.Marshal() + if err != nil { + return err + } + if err := writeString(w, string(data)); err != nil { + return err + } + return nil + } + } + + // Floats have special cases. + if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 { + x := v.Float() + var b []byte + switch { + case math.IsInf(x, 1): + b = posInf + case math.IsInf(x, -1): + b = negInf + case math.IsNaN(x): + b = nan + } + if b != nil { + _, err := w.Write(b) + return err + } + // Other values are handled below. + } + + // We don't attempt to serialise every possible value type; only those + // that can occur in protocol buffers. + switch v.Kind() { + case reflect.Slice: + // Should only be a []byte; repeated fields are handled in writeStruct. + if err := writeString(w, string(v.Bytes())); err != nil { + return err + } + case reflect.String: + if err := writeString(w, v.String()); err != nil { + return err + } + case reflect.Struct: + // Required/optional group/message. + var bra, ket byte = '<', '>' + if props != nil && props.Wire == "group" { + bra, ket = '{', '}' + } + if err := w.WriteByte(bra); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + if tm, ok := v.Interface().(encoding.TextMarshaler); ok { + text, err := tm.MarshalText() + if err != nil { + return err + } + if _, err = w.Write(text); err != nil { + return err + } + } else if err := writeStruct(w, v); err != nil { + return err + } + w.unindent() + if err := w.WriteByte(ket); err != nil { + return err + } + default: + _, err := fmt.Fprint(w, v.Interface()) + return err + } + return nil +} + +// equivalent to C's isprint. +func isprint(c byte) bool { + return c >= 0x20 && c < 0x7f +} + +// writeString writes a string in the protocol buffer text format. +// It is similar to strconv.Quote except we don't use Go escape sequences, +// we treat the string as a byte sequence, and we use octal escapes. +// These differences are to maintain interoperability with the other +// languages' implementations of the text format. +func writeString(w *textWriter, s string) error { + // use WriteByte here to get any needed indent + if err := w.WriteByte('"'); err != nil { + return err + } + // Loop over the bytes, not the runes. + for i := 0; i < len(s); i++ { + var err error + // Divergence from C++: we don't escape apostrophes. + // There's no need to escape them, and the C++ parser + // copes with a naked apostrophe. + switch c := s[i]; c { + case '\n': + _, err = w.w.Write(backslashN) + case '\r': + _, err = w.w.Write(backslashR) + case '\t': + _, err = w.w.Write(backslashT) + case '"': + _, err = w.w.Write(backslashDQ) + case '\\': + _, err = w.w.Write(backslashBS) + default: + if isprint(c) { + err = w.w.WriteByte(c) + } else { + _, err = fmt.Fprintf(w.w, "\\%03o", c) + } + } + if err != nil { + return err + } + } + return w.WriteByte('"') +} + +func writeUnknownStruct(w *textWriter, data []byte) (err error) { + if !w.compact { + if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil { + return err + } + } + b := NewBuffer(data) + for b.index < len(b.buf) { + x, err := b.DecodeVarint() + if err != nil { + _, ferr := fmt.Fprintf(w, "/* %v */\n", err) + return ferr + } + wire, tag := x&7, x>>3 + if wire == WireEndGroup { + w.unindent() + if _, werr := w.Write(endBraceNewline); werr != nil { + return werr + } + continue + } + if _, ferr := fmt.Fprint(w, tag); ferr != nil { + return ferr + } + if wire != WireStartGroup { + if err = w.WriteByte(':'); err != nil { + return err + } + } + if !w.compact || wire == WireStartGroup { + if err = w.WriteByte(' '); err != nil { + return err + } + } + switch wire { + case WireBytes: + buf, e := b.DecodeRawBytes(false) + if e == nil { + _, err = fmt.Fprintf(w, "%q", buf) + } else { + _, err = fmt.Fprintf(w, "/* %v */", e) + } + case WireFixed32: + x, err = b.DecodeFixed32() + err = writeUnknownInt(w, x, err) + case WireFixed64: + x, err = b.DecodeFixed64() + err = writeUnknownInt(w, x, err) + case WireStartGroup: + err = w.WriteByte('{') + w.indent() + case WireVarint: + x, err = b.DecodeVarint() + err = writeUnknownInt(w, x, err) + default: + _, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire) + } + if err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + return nil +} + +func writeUnknownInt(w *textWriter, x uint64, err error) error { + if err == nil { + _, err = fmt.Fprint(w, x) + } else { + _, err = fmt.Fprintf(w, "/* %v */", err) + } + return err +} + +type int32Slice []int32 + +func (s int32Slice) Len() int { return len(s) } +func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] } +func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + +// writeExtensions writes all the extensions in pv. +// pv is assumed to be a pointer to a protocol message struct that is extendable. +func writeExtensions(w *textWriter, pv reflect.Value) error { + emap := extensionMaps[pv.Type().Elem()] + e := pv.Interface().(Message) + + var m map[int32]Extension + var mu sync.Locker + if em, ok := e.(extensionsBytes); ok { + eb := em.GetExtensions() + var err error + m, err = BytesToExtensionsMap(*eb) + if err != nil { + return err + } + mu = notLocker{} + } else if _, ok := e.(extendableProto); ok { + ep, _ := extendable(e) + m, mu = ep.extensionsRead() + if m == nil { + return nil + } + } + + // Order the extensions by ID. + // This isn't strictly necessary, but it will give us + // canonical output, which will also make testing easier. + + mu.Lock() + ids := make([]int32, 0, len(m)) + for id := range m { + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) + mu.Unlock() + + for _, extNum := range ids { + ext := m[extNum] + var desc *ExtensionDesc + if emap != nil { + desc = emap[extNum] + } + if desc == nil { + // Unknown extension. + if err := writeUnknownStruct(w, ext.enc); err != nil { + return err + } + continue + } + + pb, err := GetExtension(e, desc) + if err != nil { + return fmt.Errorf("failed getting extension: %v", err) + } + + // Repeated extensions will appear as a slice. + if !desc.repeated() { + if err := writeExtension(w, desc.Name, pb); err != nil { + return err + } + } else { + v := reflect.ValueOf(pb) + for i := 0; i < v.Len(); i++ { + if err := writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil { + return err + } + } + } + } + return nil +} + +func writeExtension(w *textWriter, name string, pb interface{}) error { + if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := writeAny(w, reflect.ValueOf(pb), nil); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + return nil +} + +func (w *textWriter) writeIndent() { + if !w.complete { + return + } + remain := w.ind * 2 + for remain > 0 { + n := remain + if n > len(spaces) { + n = len(spaces) + } + w.w.Write(spaces[:n]) + remain -= n + } + w.complete = false +} + +// TextMarshaler is a configurable text format marshaler. +type TextMarshaler struct { + Compact bool // use compact text format (one line). +} + +// Marshal writes a given protocol buffer in text format. +// The only errors returned are from w. +func (m *TextMarshaler) Marshal(w io.Writer, pb Message) error { + val := reflect.ValueOf(pb) + if pb == nil || val.IsNil() { + w.Write([]byte("")) + return nil + } + var bw *bufio.Writer + ww, ok := w.(writer) + if !ok { + bw = bufio.NewWriter(w) + ww = bw + } + aw := &textWriter{ + w: ww, + complete: true, + compact: m.Compact, + } + + if tm, ok := pb.(encoding.TextMarshaler); ok { + text, err := tm.MarshalText() + if err != nil { + return err + } + if _, err = aw.Write(text); err != nil { + return err + } + if bw != nil { + return bw.Flush() + } + return nil + } + // Dereference the received pointer so we don't have outer < and >. + v := reflect.Indirect(val) + if err := writeStruct(aw, v); err != nil { + return err + } + if bw != nil { + return bw.Flush() + } + return nil +} + +// Text is the same as Marshal, but returns the string directly. +func (m *TextMarshaler) Text(pb Message) string { + var buf bytes.Buffer + m.Marshal(&buf, pb) + return buf.String() +} + +var ( + defaultTextMarshaler = TextMarshaler{} + compactTextMarshaler = TextMarshaler{Compact: true} +) + +// TODO: consider removing some of the Marshal functions below. + +// MarshalText writes a given protocol buffer in text format. +// The only errors returned are from w. +func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) } + +// MarshalTextString is the same as MarshalText, but returns the string directly. +func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) } + +// CompactText writes a given protocol buffer in compact text format (one line). +func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) } + +// CompactTextString is the same as CompactText, but returns the string directly. +func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) } diff --git a/vendor/github.com/gogo/protobuf/proto/text_gogo.go b/vendor/github.com/gogo/protobuf/proto/text_gogo.go new file mode 100644 index 00000000..58926741 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/text_gogo.go @@ -0,0 +1,57 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +import ( + "fmt" + "reflect" +) + +func writeEnum(w *textWriter, v reflect.Value, props *Properties) error { + m, ok := enumStringMaps[props.Enum] + if !ok { + if err := writeAny(w, v, props); err != nil { + return err + } + } + key := int32(0) + if v.Kind() == reflect.Ptr { + key = int32(v.Elem().Int()) + } else { + key = int32(v.Int()) + } + s, ok := m[key] + if !ok { + if err := writeAny(w, v, props); err != nil { + return err + } + } + _, err := fmt.Fprint(w, s) + return err +} diff --git a/vendor/github.com/gogo/protobuf/proto/text_parser.go b/vendor/github.com/gogo/protobuf/proto/text_parser.go new file mode 100644 index 00000000..bcd732c3 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/proto/text_parser.go @@ -0,0 +1,858 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +// Functions for parsing the Text protocol buffer format. +// TODO: message sets. + +import ( + "encoding" + "errors" + "fmt" + "reflect" + "strconv" + "strings" + "unicode/utf8" +) + +type ParseError struct { + Message string + Line int // 1-based line number + Offset int // 0-based byte offset from start of input +} + +func (p *ParseError) Error() string { + if p.Line == 1 { + // show offset only for first line + return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message) + } + return fmt.Sprintf("line %d: %v", p.Line, p.Message) +} + +type token struct { + value string + err *ParseError + line int // line number + offset int // byte number from start of input, not start of line + unquoted string // the unquoted version of value, if it was a quoted string +} + +func (t *token) String() string { + if t.err == nil { + return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset) + } + return fmt.Sprintf("parse error: %v", t.err) +} + +type textParser struct { + s string // remaining input + done bool // whether the parsing is finished (success or error) + backed bool // whether back() was called + offset, line int + cur token +} + +func newTextParser(s string) *textParser { + p := new(textParser) + p.s = s + p.line = 1 + p.cur.line = 1 + return p +} + +func (p *textParser) errorf(format string, a ...interface{}) *ParseError { + pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset} + p.cur.err = pe + p.done = true + return pe +} + +// Numbers and identifiers are matched by [-+._A-Za-z0-9] +func isIdentOrNumberChar(c byte) bool { + switch { + case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z': + return true + case '0' <= c && c <= '9': + return true + } + switch c { + case '-', '+', '.', '_': + return true + } + return false +} + +func isWhitespace(c byte) bool { + switch c { + case ' ', '\t', '\n', '\r': + return true + } + return false +} + +func isQuote(c byte) bool { + switch c { + case '"', '\'': + return true + } + return false +} + +func (p *textParser) skipWhitespace() { + i := 0 + for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') { + if p.s[i] == '#' { + // comment; skip to end of line or input + for i < len(p.s) && p.s[i] != '\n' { + i++ + } + if i == len(p.s) { + break + } + } + if p.s[i] == '\n' { + p.line++ + } + i++ + } + p.offset += i + p.s = p.s[i:len(p.s)] + if len(p.s) == 0 { + p.done = true + } +} + +func (p *textParser) advance() { + // Skip whitespace + p.skipWhitespace() + if p.done { + return + } + + // Start of non-whitespace + p.cur.err = nil + p.cur.offset, p.cur.line = p.offset, p.line + p.cur.unquoted = "" + switch p.s[0] { + case '<', '>', '{', '}', ':', '[', ']', ';', ',': + // Single symbol + p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)] + case '"', '\'': + // Quoted string + i := 1 + for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' { + if p.s[i] == '\\' && i+1 < len(p.s) { + // skip escaped char + i++ + } + i++ + } + if i >= len(p.s) || p.s[i] != p.s[0] { + p.errorf("unmatched quote") + return + } + unq, err := unquoteC(p.s[1:i], rune(p.s[0])) + if err != nil { + p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err) + return + } + p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)] + p.cur.unquoted = unq + default: + i := 0 + for i < len(p.s) && isIdentOrNumberChar(p.s[i]) { + i++ + } + if i == 0 { + p.errorf("unexpected byte %#x", p.s[0]) + return + } + p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)] + } + p.offset += len(p.cur.value) +} + +var ( + errBadUTF8 = errors.New("proto: bad UTF-8") + errBadHex = errors.New("proto: bad hexadecimal") +) + +func unquoteC(s string, quote rune) (string, error) { + // This is based on C++'s tokenizer.cc. + // Despite its name, this is *not* parsing C syntax. + // For instance, "\0" is an invalid quoted string. + + // Avoid allocation in trivial cases. + simple := true + for _, r := range s { + if r == '\\' || r == quote { + simple = false + break + } + } + if simple { + return s, nil + } + + buf := make([]byte, 0, 3*len(s)/2) + for len(s) > 0 { + r, n := utf8.DecodeRuneInString(s) + if r == utf8.RuneError && n == 1 { + return "", errBadUTF8 + } + s = s[n:] + if r != '\\' { + if r < utf8.RuneSelf { + buf = append(buf, byte(r)) + } else { + buf = append(buf, string(r)...) + } + continue + } + + ch, tail, err := unescape(s) + if err != nil { + return "", err + } + buf = append(buf, ch...) + s = tail + } + return string(buf), nil +} + +func unescape(s string) (ch string, tail string, err error) { + r, n := utf8.DecodeRuneInString(s) + if r == utf8.RuneError && n == 1 { + return "", "", errBadUTF8 + } + s = s[n:] + switch r { + case 'a': + return "\a", s, nil + case 'b': + return "\b", s, nil + case 'f': + return "\f", s, nil + case 'n': + return "\n", s, nil + case 'r': + return "\r", s, nil + case 't': + return "\t", s, nil + case 'v': + return "\v", s, nil + case '?': + return "?", s, nil // trigraph workaround + case '\'', '"', '\\': + return string(r), s, nil + case '0', '1', '2', '3', '4', '5', '6', '7', 'x', 'X': + if len(s) < 2 { + return "", "", fmt.Errorf(`\%c requires 2 following digits`, r) + } + base := 8 + ss := s[:2] + s = s[2:] + if r == 'x' || r == 'X' { + base = 16 + } else { + ss = string(r) + ss + } + i, err := strconv.ParseUint(ss, base, 8) + if err != nil { + return "", "", err + } + return string([]byte{byte(i)}), s, nil + case 'u', 'U': + n := 4 + if r == 'U' { + n = 8 + } + if len(s) < n { + return "", "", fmt.Errorf(`\%c requires %d digits`, r, n) + } + + bs := make([]byte, n/2) + for i := 0; i < n; i += 2 { + a, ok1 := unhex(s[i]) + b, ok2 := unhex(s[i+1]) + if !ok1 || !ok2 { + return "", "", errBadHex + } + bs[i/2] = a<<4 | b + } + s = s[n:] + return string(bs), s, nil + } + return "", "", fmt.Errorf(`unknown escape \%c`, r) +} + +// Adapted from src/pkg/strconv/quote.go. +func unhex(b byte) (v byte, ok bool) { + switch { + case '0' <= b && b <= '9': + return b - '0', true + case 'a' <= b && b <= 'f': + return b - 'a' + 10, true + case 'A' <= b && b <= 'F': + return b - 'A' + 10, true + } + return 0, false +} + +// Back off the parser by one token. Can only be done between calls to next(). +// It makes the next advance() a no-op. +func (p *textParser) back() { p.backed = true } + +// Advances the parser and returns the new current token. +func (p *textParser) next() *token { + if p.backed || p.done { + p.backed = false + return &p.cur + } + p.advance() + if p.done { + p.cur.value = "" + } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) { + // Look for multiple quoted strings separated by whitespace, + // and concatenate them. + cat := p.cur + for { + p.skipWhitespace() + if p.done || !isQuote(p.s[0]) { + break + } + p.advance() + if p.cur.err != nil { + return &p.cur + } + cat.value += " " + p.cur.value + cat.unquoted += p.cur.unquoted + } + p.done = false // parser may have seen EOF, but we want to return cat + p.cur = cat + } + return &p.cur +} + +func (p *textParser) consumeToken(s string) error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != s { + p.back() + return p.errorf("expected %q, found %q", s, tok.value) + } + return nil +} + +// Return a RequiredNotSetError indicating which required field was not set. +func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError { + st := sv.Type() + sprops := GetProperties(st) + for i := 0; i < st.NumField(); i++ { + if !isNil(sv.Field(i)) { + continue + } + + props := sprops.Prop[i] + if props.Required { + return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)} + } + } + return &RequiredNotSetError{fmt.Sprintf("%v.", st)} // should not happen +} + +// Returns the index in the struct for the named field, as well as the parsed tag properties. +func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) { + i, ok := sprops.decoderOrigNames[name] + if ok { + return i, sprops.Prop[i], true + } + return -1, nil, false +} + +// Consume a ':' from the input stream (if the next token is a colon), +// returning an error if a colon is needed but not present. +func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != ":" { + // Colon is optional when the field is a group or message. + needColon := true + switch props.Wire { + case "group": + needColon = false + case "bytes": + // A "bytes" field is either a message, a string, or a repeated field; + // those three become *T, *string and []T respectively, so we can check for + // this field being a pointer to a non-string. + if typ.Kind() == reflect.Ptr { + // *T or *string + if typ.Elem().Kind() == reflect.String { + break + } + } else if typ.Kind() == reflect.Slice { + // []T or []*T + if typ.Elem().Kind() != reflect.Ptr { + break + } + } else if typ.Kind() == reflect.String { + // The proto3 exception is for a string field, + // which requires a colon. + break + } + needColon = false + } + if needColon { + return p.errorf("expected ':', found %q", tok.value) + } + p.back() + } + return nil +} + +func (p *textParser) readStruct(sv reflect.Value, terminator string) error { + st := sv.Type() + sprops := GetProperties(st) + reqCount := sprops.reqCount + var reqFieldErr error + fieldSet := make(map[string]bool) + // A struct is a sequence of "name: value", terminated by one of + // '>' or '}', or the end of the input. A name may also be + // "[extension]". + for { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == terminator { + break + } + if tok.value == "[" { + // Looks like an extension. + // + // TODO: Check whether we need to handle + // namespace rooted names (e.g. ".something.Foo"). + tok = p.next() + if tok.err != nil { + return tok.err + } + var desc *ExtensionDesc + // This could be faster, but it's functional. + // TODO: Do something smarter than a linear scan. + for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) { + if d.Name == tok.value { + desc = d + break + } + } + if desc == nil { + return p.errorf("unrecognized extension %q", tok.value) + } + // Check the extension terminator. + tok = p.next() + if tok.err != nil { + return tok.err + } + if tok.value != "]" { + return p.errorf("unrecognized extension terminator %q", tok.value) + } + + props := &Properties{} + props.Parse(desc.Tag) + + typ := reflect.TypeOf(desc.ExtensionType) + if err := p.checkForColon(props, typ); err != nil { + return err + } + + rep := desc.repeated() + + // Read the extension structure, and set it in + // the value we're constructing. + var ext reflect.Value + if !rep { + ext = reflect.New(typ).Elem() + } else { + ext = reflect.New(typ.Elem()).Elem() + } + if err := p.readAny(ext, props); err != nil { + if _, ok := err.(*RequiredNotSetError); !ok { + return err + } + reqFieldErr = err + } + ep := sv.Addr().Interface().(Message) + if !rep { + SetExtension(ep, desc, ext.Interface()) + } else { + old, err := GetExtension(ep, desc) + var sl reflect.Value + if err == nil { + sl = reflect.ValueOf(old) // existing slice + } else { + sl = reflect.MakeSlice(typ, 0, 1) + } + sl = reflect.Append(sl, ext) + SetExtension(ep, desc, sl.Interface()) + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + continue + } + + // This is a normal, non-extension field. + name := tok.value + var dst reflect.Value + fi, props, ok := structFieldByName(sprops, name) + if ok { + dst = sv.Field(fi) + } else if oop, ok := sprops.OneofTypes[name]; ok { + // It is a oneof. + props = oop.Prop + nv := reflect.New(oop.Type.Elem()) + dst = nv.Elem().Field(0) + sv.Field(oop.Field).Set(nv) + } + if !dst.IsValid() { + return p.errorf("unknown field name %q in %v", name, st) + } + + if dst.Kind() == reflect.Map { + // Consume any colon. + if err := p.checkForColon(props, dst.Type()); err != nil { + return err + } + + // Construct the map if it doesn't already exist. + if dst.IsNil() { + dst.Set(reflect.MakeMap(dst.Type())) + } + key := reflect.New(dst.Type().Key()).Elem() + val := reflect.New(dst.Type().Elem()).Elem() + + // The map entry should be this sequence of tokens: + // < key : KEY value : VALUE > + // However, implementations may omit key or value, and technically + // we should support them in any order. See b/28924776 for a time + // this went wrong. + + tok := p.next() + var terminator string + switch tok.value { + case "<": + terminator = ">" + case "{": + terminator = "}" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + for { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == terminator { + break + } + switch tok.value { + case "key": + if err := p.consumeToken(":"); err != nil { + return err + } + if err := p.readAny(key, props.mkeyprop); err != nil { + return err + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + case "value": + if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil { + return err + } + if err := p.readAny(val, props.mvalprop); err != nil { + return err + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + default: + p.back() + return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value) + } + } + + dst.SetMapIndex(key, val) + continue + } + + // Check that it's not already set if it's not a repeated field. + if !props.Repeated && fieldSet[name] { + return p.errorf("non-repeated field %q was repeated", name) + } + + if err := p.checkForColon(props, dst.Type()); err != nil { + return err + } + + // Parse into the field. + fieldSet[name] = true + if err := p.readAny(dst, props); err != nil { + if _, ok := err.(*RequiredNotSetError); !ok { + return err + } + reqFieldErr = err + } + if props.Required { + reqCount-- + } + + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + + } + + if reqCount > 0 { + return p.missingRequiredFieldError(sv) + } + return reqFieldErr +} + +// consumeOptionalSeparator consumes an optional semicolon or comma. +// It is used in readStruct to provide backward compatibility. +func (p *textParser) consumeOptionalSeparator() error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != ";" && tok.value != "," { + p.back() + } + return nil +} + +func (p *textParser) readAny(v reflect.Value, props *Properties) error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == "" { + return p.errorf("unexpected EOF") + } + if len(props.CustomType) > 0 { + if props.Repeated { + t := reflect.TypeOf(v.Interface()) + if t.Kind() == reflect.Slice { + tc := reflect.TypeOf(new(Marshaler)) + ok := t.Elem().Implements(tc.Elem()) + if ok { + fv := v + flen := fv.Len() + if flen == fv.Cap() { + nav := reflect.MakeSlice(v.Type(), flen, 2*flen+1) + reflect.Copy(nav, fv) + fv.Set(nav) + } + fv.SetLen(flen + 1) + + // Read one. + p.back() + return p.readAny(fv.Index(flen), props) + } + } + } + if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr { + custom := reflect.New(props.ctype.Elem()).Interface().(Unmarshaler) + err := custom.Unmarshal([]byte(tok.unquoted)) + if err != nil { + return p.errorf("%v %v: %v", err, v.Type(), tok.value) + } + v.Set(reflect.ValueOf(custom)) + } else { + custom := reflect.New(reflect.TypeOf(v.Interface())).Interface().(Unmarshaler) + err := custom.Unmarshal([]byte(tok.unquoted)) + if err != nil { + return p.errorf("%v %v: %v", err, v.Type(), tok.value) + } + v.Set(reflect.Indirect(reflect.ValueOf(custom))) + } + return nil + } + switch fv := v; fv.Kind() { + case reflect.Slice: + at := v.Type() + if at.Elem().Kind() == reflect.Uint8 { + // Special case for []byte + if tok.value[0] != '"' && tok.value[0] != '\'' { + // Deliberately written out here, as the error after + // this switch statement would write "invalid []byte: ...", + // which is not as user-friendly. + return p.errorf("invalid string: %v", tok.value) + } + bytes := []byte(tok.unquoted) + fv.Set(reflect.ValueOf(bytes)) + return nil + } + // Repeated field. + if tok.value == "[" { + // Repeated field with list notation, like [1,2,3]. + for { + fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem())) + err := p.readAny(fv.Index(fv.Len()-1), props) + if err != nil { + return err + } + ntok := p.next() + if ntok.err != nil { + return ntok.err + } + if ntok.value == "]" { + break + } + if ntok.value != "," { + return p.errorf("Expected ']' or ',' found %q", ntok.value) + } + } + return nil + } + // One value of the repeated field. + p.back() + fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem())) + return p.readAny(fv.Index(fv.Len()-1), props) + case reflect.Bool: + // Either "true", "false", 1 or 0. + switch tok.value { + case "true", "1": + fv.SetBool(true) + return nil + case "false", "0": + fv.SetBool(false) + return nil + } + case reflect.Float32, reflect.Float64: + v := tok.value + // Ignore 'f' for compatibility with output generated by C++, but don't + // remove 'f' when the value is "-inf" or "inf". + if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" { + v = v[:len(v)-1] + } + if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil { + fv.SetFloat(f) + return nil + } + case reflect.Int32: + if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { + fv.SetInt(x) + return nil + } + + if len(props.Enum) == 0 { + break + } + m, ok := enumValueMaps[props.Enum] + if !ok { + break + } + x, ok := m[tok.value] + if !ok { + break + } + fv.SetInt(int64(x)) + return nil + case reflect.Int64: + if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil { + fv.SetInt(x) + return nil + } + + case reflect.Ptr: + // A basic field (indirected through pointer), or a repeated message/group + p.back() + fv.Set(reflect.New(fv.Type().Elem())) + return p.readAny(fv.Elem(), props) + case reflect.String: + if tok.value[0] == '"' || tok.value[0] == '\'' { + fv.SetString(tok.unquoted) + return nil + } + case reflect.Struct: + var terminator string + switch tok.value { + case "{": + terminator = "}" + case "<": + terminator = ">" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + // TODO: Handle nested messages which implement encoding.TextUnmarshaler. + return p.readStruct(fv, terminator) + case reflect.Uint32: + if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { + fv.SetUint(uint64(x)) + return nil + } + case reflect.Uint64: + if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { + fv.SetUint(x) + return nil + } + } + return p.errorf("invalid %v: %v", v.Type(), tok.value) +} + +// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb +// before starting to unmarshal, so any existing data in pb is always removed. +// If a required field is not set and no other error occurs, +// UnmarshalText returns *RequiredNotSetError. +func UnmarshalText(s string, pb Message) error { + if um, ok := pb.(encoding.TextUnmarshaler); ok { + err := um.UnmarshalText([]byte(s)) + return err + } + pb.Reset() + v := reflect.ValueOf(pb) + if pe := newTextParser(s).readStruct(v.Elem(), ""); pe != nil { + return pe + } + return nil +} diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go new file mode 100644 index 00000000..341b59c5 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go @@ -0,0 +1,1981 @@ +// Code generated by protoc-gen-gogo. +// source: descriptor.proto +// DO NOT EDIT! + +/* +Package descriptor is a generated protocol buffer package. + +It is generated from these files: + descriptor.proto + +It has these top-level messages: + FileDescriptorSet + FileDescriptorProto + DescriptorProto + FieldDescriptorProto + OneofDescriptorProto + EnumDescriptorProto + EnumValueDescriptorProto + ServiceDescriptorProto + MethodDescriptorProto + FileOptions + MessageOptions + FieldOptions + EnumOptions + EnumValueOptions + ServiceOptions + MethodOptions + UninterpretedOption + SourceCodeInfo +*/ +package descriptor + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +type FieldDescriptorProto_Type int32 + +const ( + // 0 is reserved for errors. + // Order is weird for historical reasons. + FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1 + FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2 + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3 + FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4 + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5 + FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6 + FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7 + FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8 + FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9 + FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10 + FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11 + // New in version 2. + FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12 + FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13 + FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14 + FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15 + FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16 + FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17 + FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18 +) + +var FieldDescriptorProto_Type_name = map[int32]string{ + 1: "TYPE_DOUBLE", + 2: "TYPE_FLOAT", + 3: "TYPE_INT64", + 4: "TYPE_UINT64", + 5: "TYPE_INT32", + 6: "TYPE_FIXED64", + 7: "TYPE_FIXED32", + 8: "TYPE_BOOL", + 9: "TYPE_STRING", + 10: "TYPE_GROUP", + 11: "TYPE_MESSAGE", + 12: "TYPE_BYTES", + 13: "TYPE_UINT32", + 14: "TYPE_ENUM", + 15: "TYPE_SFIXED32", + 16: "TYPE_SFIXED64", + 17: "TYPE_SINT32", + 18: "TYPE_SINT64", +} +var FieldDescriptorProto_Type_value = map[string]int32{ + "TYPE_DOUBLE": 1, + "TYPE_FLOAT": 2, + "TYPE_INT64": 3, + "TYPE_UINT64": 4, + "TYPE_INT32": 5, + "TYPE_FIXED64": 6, + "TYPE_FIXED32": 7, + "TYPE_BOOL": 8, + "TYPE_STRING": 9, + "TYPE_GROUP": 10, + "TYPE_MESSAGE": 11, + "TYPE_BYTES": 12, + "TYPE_UINT32": 13, + "TYPE_ENUM": 14, + "TYPE_SFIXED32": 15, + "TYPE_SFIXED64": 16, + "TYPE_SINT32": 17, + "TYPE_SINT64": 18, +} + +func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type { + p := new(FieldDescriptorProto_Type) + *p = x + return p +} +func (x FieldDescriptorProto_Type) String() string { + return proto.EnumName(FieldDescriptorProto_Type_name, int32(x)) +} +func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type") + if err != nil { + return err + } + *x = FieldDescriptorProto_Type(value) + return nil +} +func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) { + return fileDescriptorDescriptor, []int{3, 0} +} + +type FieldDescriptorProto_Label int32 + +const ( + // 0 is reserved for errors + FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1 + FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2 + FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3 +) + +var FieldDescriptorProto_Label_name = map[int32]string{ + 1: "LABEL_OPTIONAL", + 2: "LABEL_REQUIRED", + 3: "LABEL_REPEATED", +} +var FieldDescriptorProto_Label_value = map[string]int32{ + "LABEL_OPTIONAL": 1, + "LABEL_REQUIRED": 2, + "LABEL_REPEATED": 3, +} + +func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label { + p := new(FieldDescriptorProto_Label) + *p = x + return p +} +func (x FieldDescriptorProto_Label) String() string { + return proto.EnumName(FieldDescriptorProto_Label_name, int32(x)) +} +func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label") + if err != nil { + return err + } + *x = FieldDescriptorProto_Label(value) + return nil +} +func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) { + return fileDescriptorDescriptor, []int{3, 1} +} + +// Generated classes can be optimized for speed or code size. +type FileOptions_OptimizeMode int32 + +const ( + FileOptions_SPEED FileOptions_OptimizeMode = 1 + // etc. + FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2 + FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 +) + +var FileOptions_OptimizeMode_name = map[int32]string{ + 1: "SPEED", + 2: "CODE_SIZE", + 3: "LITE_RUNTIME", +} +var FileOptions_OptimizeMode_value = map[string]int32{ + "SPEED": 1, + "CODE_SIZE": 2, + "LITE_RUNTIME": 3, +} + +func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode { + p := new(FileOptions_OptimizeMode) + *p = x + return p +} +func (x FileOptions_OptimizeMode) String() string { + return proto.EnumName(FileOptions_OptimizeMode_name, int32(x)) +} +func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode") + if err != nil { + return err + } + *x = FileOptions_OptimizeMode(value) + return nil +} +func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) { + return fileDescriptorDescriptor, []int{9, 0} +} + +type FieldOptions_CType int32 + +const ( + // Default mode. + FieldOptions_STRING FieldOptions_CType = 0 + FieldOptions_CORD FieldOptions_CType = 1 + FieldOptions_STRING_PIECE FieldOptions_CType = 2 +) + +var FieldOptions_CType_name = map[int32]string{ + 0: "STRING", + 1: "CORD", + 2: "STRING_PIECE", +} +var FieldOptions_CType_value = map[string]int32{ + "STRING": 0, + "CORD": 1, + "STRING_PIECE": 2, +} + +func (x FieldOptions_CType) Enum() *FieldOptions_CType { + p := new(FieldOptions_CType) + *p = x + return p +} +func (x FieldOptions_CType) String() string { + return proto.EnumName(FieldOptions_CType_name, int32(x)) +} +func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType") + if err != nil { + return err + } + *x = FieldOptions_CType(value) + return nil +} +func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) { + return fileDescriptorDescriptor, []int{11, 0} +} + +type FieldOptions_JSType int32 + +const ( + // Use the default type. + FieldOptions_JS_NORMAL FieldOptions_JSType = 0 + // Use JavaScript strings. + FieldOptions_JS_STRING FieldOptions_JSType = 1 + // Use JavaScript numbers. + FieldOptions_JS_NUMBER FieldOptions_JSType = 2 +) + +var FieldOptions_JSType_name = map[int32]string{ + 0: "JS_NORMAL", + 1: "JS_STRING", + 2: "JS_NUMBER", +} +var FieldOptions_JSType_value = map[string]int32{ + "JS_NORMAL": 0, + "JS_STRING": 1, + "JS_NUMBER": 2, +} + +func (x FieldOptions_JSType) Enum() *FieldOptions_JSType { + p := new(FieldOptions_JSType) + *p = x + return p +} +func (x FieldOptions_JSType) String() string { + return proto.EnumName(FieldOptions_JSType_name, int32(x)) +} +func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldOptions_JSType_value, data, "FieldOptions_JSType") + if err != nil { + return err + } + *x = FieldOptions_JSType(value) + return nil +} +func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) { + return fileDescriptorDescriptor, []int{11, 1} +} + +// The protocol compiler can output a FileDescriptorSet containing the .proto +// files it parses. +type FileDescriptorSet struct { + File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FileDescriptorSet) Reset() { *m = FileDescriptorSet{} } +func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) } +func (*FileDescriptorSet) ProtoMessage() {} +func (*FileDescriptorSet) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{0} } + +func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto { + if m != nil { + return m.File + } + return nil +} + +// Describes a complete .proto file. +type FileDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"` + // Names of files imported by this file. + Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"` + // Indexes of the public imported files in the dependency list above. + PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"` + // Indexes of the weak imported files in the dependency list. + // For Google-internal migration only. Do not use. + WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"` + // All top-level definitions in this file. + MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"` + EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"` + Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"` + Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"` + Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` + // This field contains optional information about the original source code. + // You may safely remove this entire field without harming runtime + // functionality of the descriptors -- the information is needed only by + // development tools. + SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"` + // The syntax of the proto file. + // The supported values are "proto2" and "proto3". + Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FileDescriptorProto) Reset() { *m = FileDescriptorProto{} } +func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*FileDescriptorProto) ProtoMessage() {} +func (*FileDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{1} } + +func (m *FileDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *FileDescriptorProto) GetPackage() string { + if m != nil && m.Package != nil { + return *m.Package + } + return "" +} + +func (m *FileDescriptorProto) GetDependency() []string { + if m != nil { + return m.Dependency + } + return nil +} + +func (m *FileDescriptorProto) GetPublicDependency() []int32 { + if m != nil { + return m.PublicDependency + } + return nil +} + +func (m *FileDescriptorProto) GetWeakDependency() []int32 { + if m != nil { + return m.WeakDependency + } + return nil +} + +func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto { + if m != nil { + return m.MessageType + } + return nil +} + +func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto { + if m != nil { + return m.EnumType + } + return nil +} + +func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto { + if m != nil { + return m.Service + } + return nil +} + +func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto { + if m != nil { + return m.Extension + } + return nil +} + +func (m *FileDescriptorProto) GetOptions() *FileOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo { + if m != nil { + return m.SourceCodeInfo + } + return nil +} + +func (m *FileDescriptorProto) GetSyntax() string { + if m != nil && m.Syntax != nil { + return *m.Syntax + } + return "" +} + +// Describes a message type. +type DescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"` + Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"` + NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"` + EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"` + ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"` + OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"` + Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"` + ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"` + // Reserved field names, which may not be used by fields in the same message. + // A given name may only be reserved once. + ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescriptorProto) Reset() { *m = DescriptorProto{} } +func (m *DescriptorProto) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto) ProtoMessage() {} +func (*DescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{2} } + +func (m *DescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *DescriptorProto) GetField() []*FieldDescriptorProto { + if m != nil { + return m.Field + } + return nil +} + +func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto { + if m != nil { + return m.Extension + } + return nil +} + +func (m *DescriptorProto) GetNestedType() []*DescriptorProto { + if m != nil { + return m.NestedType + } + return nil +} + +func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto { + if m != nil { + return m.EnumType + } + return nil +} + +func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange { + if m != nil { + return m.ExtensionRange + } + return nil +} + +func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto { + if m != nil { + return m.OneofDecl + } + return nil +} + +func (m *DescriptorProto) GetOptions() *MessageOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange { + if m != nil { + return m.ReservedRange + } + return nil +} + +func (m *DescriptorProto) GetReservedName() []string { + if m != nil { + return m.ReservedName + } + return nil +} + +type DescriptorProto_ExtensionRange struct { + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescriptorProto_ExtensionRange) Reset() { *m = DescriptorProto_ExtensionRange{} } +func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto_ExtensionRange) ProtoMessage() {} +func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) { + return fileDescriptorDescriptor, []int{2, 0} +} + +func (m *DescriptorProto_ExtensionRange) GetStart() int32 { + if m != nil && m.Start != nil { + return *m.Start + } + return 0 +} + +func (m *DescriptorProto_ExtensionRange) GetEnd() int32 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +// Range of reserved tag numbers. Reserved tag numbers may not be used by +// fields or extension ranges in the same message. Reserved ranges may +// not overlap. +type DescriptorProto_ReservedRange struct { + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescriptorProto_ReservedRange) Reset() { *m = DescriptorProto_ReservedRange{} } +func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto_ReservedRange) ProtoMessage() {} +func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) { + return fileDescriptorDescriptor, []int{2, 1} +} + +func (m *DescriptorProto_ReservedRange) GetStart() int32 { + if m != nil && m.Start != nil { + return *m.Start + } + return 0 +} + +func (m *DescriptorProto_ReservedRange) GetEnd() int32 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +// Describes a field within a message. +type FieldDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"` + Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"` + // If type_name is set, this need not be set. If both this and type_name + // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"` + // For message and enum types, this is the name of the type. If the name + // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + // rules are used to find the type (i.e. first the nested types within this + // message are searched, then within the parent, on up to the root + // namespace). + TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"` + // For extensions, this is the name of the type being extended. It is + // resolved in the same manner as type_name. + Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"` + // For numeric types, contains the original text representation of the value. + // For booleans, "true" or "false". + // For strings, contains the default text contents (not escaped in any way). + // For bytes, contains the C escaped value. All bytes >= 128 are escaped. + // TODO(kenton): Base-64 encode? + DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"` + // If set, gives the index of a oneof in the containing type's oneof_decl + // list. This field is a member of that oneof. + OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"` + // JSON name of this field. The value is set by protocol compiler. If the + // user has set a "json_name" option on this field, that option's value + // will be used. Otherwise, it's deduced from the field's name by converting + // it to camelCase. + JsonName *string `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"` + Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FieldDescriptorProto) Reset() { *m = FieldDescriptorProto{} } +func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*FieldDescriptorProto) ProtoMessage() {} +func (*FieldDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{3} } + +func (m *FieldDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *FieldDescriptorProto) GetNumber() int32 { + if m != nil && m.Number != nil { + return *m.Number + } + return 0 +} + +func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label { + if m != nil && m.Label != nil { + return *m.Label + } + return FieldDescriptorProto_LABEL_OPTIONAL +} + +func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type { + if m != nil && m.Type != nil { + return *m.Type + } + return FieldDescriptorProto_TYPE_DOUBLE +} + +func (m *FieldDescriptorProto) GetTypeName() string { + if m != nil && m.TypeName != nil { + return *m.TypeName + } + return "" +} + +func (m *FieldDescriptorProto) GetExtendee() string { + if m != nil && m.Extendee != nil { + return *m.Extendee + } + return "" +} + +func (m *FieldDescriptorProto) GetDefaultValue() string { + if m != nil && m.DefaultValue != nil { + return *m.DefaultValue + } + return "" +} + +func (m *FieldDescriptorProto) GetOneofIndex() int32 { + if m != nil && m.OneofIndex != nil { + return *m.OneofIndex + } + return 0 +} + +func (m *FieldDescriptorProto) GetJsonName() string { + if m != nil && m.JsonName != nil { + return *m.JsonName + } + return "" +} + +func (m *FieldDescriptorProto) GetOptions() *FieldOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a oneof. +type OneofDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OneofDescriptorProto) Reset() { *m = OneofDescriptorProto{} } +func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*OneofDescriptorProto) ProtoMessage() {} +func (*OneofDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{4} } + +func (m *OneofDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +// Describes an enum type. +type EnumDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"` + Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumDescriptorProto) Reset() { *m = EnumDescriptorProto{} } +func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*EnumDescriptorProto) ProtoMessage() {} +func (*EnumDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{5} } + +func (m *EnumDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto { + if m != nil { + return m.Value + } + return nil +} + +func (m *EnumDescriptorProto) GetOptions() *EnumOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a value within an enum. +type EnumValueDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"` + Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumValueDescriptorProto) Reset() { *m = EnumValueDescriptorProto{} } +func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*EnumValueDescriptorProto) ProtoMessage() {} +func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) { + return fileDescriptorDescriptor, []int{6} +} + +func (m *EnumValueDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *EnumValueDescriptorProto) GetNumber() int32 { + if m != nil && m.Number != nil { + return *m.Number + } + return 0 +} + +func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a service. +type ServiceDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"` + Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ServiceDescriptorProto) Reset() { *m = ServiceDescriptorProto{} } +func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*ServiceDescriptorProto) ProtoMessage() {} +func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{7} } + +func (m *ServiceDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto { + if m != nil { + return m.Method + } + return nil +} + +func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a method of a service. +type MethodDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // Input and output type names. These are resolved in the same way as + // FieldDescriptorProto.type_name, but must refer to a message type. + InputType *string `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"` + OutputType *string `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"` + Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"` + // Identifies if client streams multiple client messages + ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"` + // Identifies if server streams multiple server messages + ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MethodDescriptorProto) Reset() { *m = MethodDescriptorProto{} } +func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*MethodDescriptorProto) ProtoMessage() {} +func (*MethodDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{8} } + +const Default_MethodDescriptorProto_ClientStreaming bool = false +const Default_MethodDescriptorProto_ServerStreaming bool = false + +func (m *MethodDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *MethodDescriptorProto) GetInputType() string { + if m != nil && m.InputType != nil { + return *m.InputType + } + return "" +} + +func (m *MethodDescriptorProto) GetOutputType() string { + if m != nil && m.OutputType != nil { + return *m.OutputType + } + return "" +} + +func (m *MethodDescriptorProto) GetOptions() *MethodOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *MethodDescriptorProto) GetClientStreaming() bool { + if m != nil && m.ClientStreaming != nil { + return *m.ClientStreaming + } + return Default_MethodDescriptorProto_ClientStreaming +} + +func (m *MethodDescriptorProto) GetServerStreaming() bool { + if m != nil && m.ServerStreaming != nil { + return *m.ServerStreaming + } + return Default_MethodDescriptorProto_ServerStreaming +} + +type FileOptions struct { + // Sets the Java package where classes generated from this .proto will be + // placed. By default, the proto package is used, but this is often + // inappropriate because proto packages do not normally start with backwards + // domain names. + JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"` + // If set, all the classes from the .proto file are wrapped in a single + // outer class with the given name. This applies to both Proto1 + // (equivalent to the old "--one_java_file" option) and Proto2 (where + // a .proto always translates to a single class, but you may want to + // explicitly choose the class name). + JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"` + // If set true, then the Java code generator will generate a separate .java + // file for each top-level message, enum, and service defined in the .proto + // file. Thus, these types will *not* be nested inside the outer class + // named by java_outer_classname. However, the outer class will still be + // generated to contain the file's getDescriptor() method as well as any + // top-level extensions defined in the file. + JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"` + // If set true, then the Java code generator will generate equals() and + // hashCode() methods for all messages defined in the .proto file. + // This increases generated code size, potentially substantially for large + // protos, which may harm a memory-constrained application. + // - In the full runtime this is a speed optimization, as the + // AbstractMessage base class includes reflection-based implementations of + // these methods. + // - In the lite runtime, setting this option changes the semantics of + // equals() and hashCode() to more closely match those of the full runtime; + // the generated methods compute their results based on field values rather + // than object identity. (Implementations should not assume that hashcodes + // will be consistent across runtimes or versions of the protocol compiler.) + JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash,def=0" json:"java_generate_equals_and_hash,omitempty"` + // If set true, then the Java2 code generator will generate code that + // throws an exception whenever an attempt is made to assign a non-UTF-8 + // byte sequence to a string field. + // Message reflection will do the same. + // However, an extension field still accepts non-UTF-8 byte sequences. + // This option has no effect on when used with the lite runtime. + JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"` + OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"` + // Sets the Go package where structs generated from this .proto will be + // placed. If omitted, the Go package will be derived from the following: + // - The basename of the package import path, if provided. + // - Otherwise, the package statement in the .proto file, if present. + // - Otherwise, the basename of the .proto file, without extension. + GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"` + // Should generic services be generated in each language? "Generic" services + // are not specific to any particular RPC system. They are generated by the + // main code generators in each language (without additional plugins). + // Generic services were the only kind of service generation supported by + // early versions of google.protobuf. + // + // Generic services are now considered deprecated in favor of using plugins + // that generate code specific to your particular RPC system. Therefore, + // these default to false. Old code which depends on generic services should + // explicitly set them to true. + CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"` + JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"` + PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"` + // Is this file deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for everything in the file, or it will be completely ignored; in the very + // least, this is a formalization for deprecating files. + Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Enables the use of arenas for the proto messages in this file. This applies + // only to generated classes for C++. + CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=0" json:"cc_enable_arenas,omitempty"` + // Sets the objective c class prefix which is prepended to all objective c + // generated classes from this .proto. There is no default. + ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"` + // Namespace for generated classes; defaults to the package. + CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"` + // Whether the nano proto compiler should generate in the deprecated non-nano + // suffixed package. + JavananoUseDeprecatedPackage *bool `protobuf:"varint,38,opt,name=javanano_use_deprecated_package,json=javananoUseDeprecatedPackage" json:"javanano_use_deprecated_package,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FileOptions) Reset() { *m = FileOptions{} } +func (m *FileOptions) String() string { return proto.CompactTextString(m) } +func (*FileOptions) ProtoMessage() {} +func (*FileOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{9} } + +var extRange_FileOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_FileOptions +} + +const Default_FileOptions_JavaMultipleFiles bool = false +const Default_FileOptions_JavaGenerateEqualsAndHash bool = false +const Default_FileOptions_JavaStringCheckUtf8 bool = false +const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED +const Default_FileOptions_CcGenericServices bool = false +const Default_FileOptions_JavaGenericServices bool = false +const Default_FileOptions_PyGenericServices bool = false +const Default_FileOptions_Deprecated bool = false +const Default_FileOptions_CcEnableArenas bool = false + +func (m *FileOptions) GetJavaPackage() string { + if m != nil && m.JavaPackage != nil { + return *m.JavaPackage + } + return "" +} + +func (m *FileOptions) GetJavaOuterClassname() string { + if m != nil && m.JavaOuterClassname != nil { + return *m.JavaOuterClassname + } + return "" +} + +func (m *FileOptions) GetJavaMultipleFiles() bool { + if m != nil && m.JavaMultipleFiles != nil { + return *m.JavaMultipleFiles + } + return Default_FileOptions_JavaMultipleFiles +} + +func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool { + if m != nil && m.JavaGenerateEqualsAndHash != nil { + return *m.JavaGenerateEqualsAndHash + } + return Default_FileOptions_JavaGenerateEqualsAndHash +} + +func (m *FileOptions) GetJavaStringCheckUtf8() bool { + if m != nil && m.JavaStringCheckUtf8 != nil { + return *m.JavaStringCheckUtf8 + } + return Default_FileOptions_JavaStringCheckUtf8 +} + +func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode { + if m != nil && m.OptimizeFor != nil { + return *m.OptimizeFor + } + return Default_FileOptions_OptimizeFor +} + +func (m *FileOptions) GetGoPackage() string { + if m != nil && m.GoPackage != nil { + return *m.GoPackage + } + return "" +} + +func (m *FileOptions) GetCcGenericServices() bool { + if m != nil && m.CcGenericServices != nil { + return *m.CcGenericServices + } + return Default_FileOptions_CcGenericServices +} + +func (m *FileOptions) GetJavaGenericServices() bool { + if m != nil && m.JavaGenericServices != nil { + return *m.JavaGenericServices + } + return Default_FileOptions_JavaGenericServices +} + +func (m *FileOptions) GetPyGenericServices() bool { + if m != nil && m.PyGenericServices != nil { + return *m.PyGenericServices + } + return Default_FileOptions_PyGenericServices +} + +func (m *FileOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_FileOptions_Deprecated +} + +func (m *FileOptions) GetCcEnableArenas() bool { + if m != nil && m.CcEnableArenas != nil { + return *m.CcEnableArenas + } + return Default_FileOptions_CcEnableArenas +} + +func (m *FileOptions) GetObjcClassPrefix() string { + if m != nil && m.ObjcClassPrefix != nil { + return *m.ObjcClassPrefix + } + return "" +} + +func (m *FileOptions) GetCsharpNamespace() string { + if m != nil && m.CsharpNamespace != nil { + return *m.CsharpNamespace + } + return "" +} + +func (m *FileOptions) GetJavananoUseDeprecatedPackage() bool { + if m != nil && m.JavananoUseDeprecatedPackage != nil { + return *m.JavananoUseDeprecatedPackage + } + return false +} + +func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type MessageOptions struct { + // Set true to use the old proto1 MessageSet wire format for extensions. + // This is provided for backwards-compatibility with the MessageSet wire + // format. You should not use this for any other reason: It's less + // efficient, has fewer features, and is more complicated. + // + // The message must be defined exactly as follows: + // message Foo { + // option message_set_wire_format = true; + // extensions 4 to max; + // } + // Note that the message cannot have any defined fields; MessageSets only + // have extensions. + // + // All extensions of your type must be singular messages; e.g. they cannot + // be int32s, enums, or repeated messages. + // + // Because this is an option, the above two restrictions are not enforced by + // the protocol compiler. + MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"` + // Disables the generation of the standard "descriptor()" accessor, which can + // conflict with a field of the same name. This is meant to make migration + // from proto1 easier; new code should avoid fields named "descriptor". + NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"` + // Is this message deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the message, or it will be completely ignored; in the very least, + // this is a formalization for deprecating messages. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Whether the message is an automatically generated map entry type for the + // maps field. + // + // For maps fields: + // map map_field = 1; + // The parsed descriptor looks like: + // message MapFieldEntry { + // option map_entry = true; + // optional KeyType key = 1; + // optional ValueType value = 2; + // } + // repeated MapFieldEntry map_field = 1; + // + // Implementations may choose not to generate the map_entry=true message, but + // use a native map in the target language to hold the keys and values. + // The reflection APIs in such implementions still need to work as + // if the field is a repeated message field. + // + // NOTE: Do not set the option in .proto files. Always use the maps syntax + // instead. The option should only be implicitly set by the proto compiler + // parser. + MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MessageOptions) Reset() { *m = MessageOptions{} } +func (m *MessageOptions) String() string { return proto.CompactTextString(m) } +func (*MessageOptions) ProtoMessage() {} +func (*MessageOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{10} } + +var extRange_MessageOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MessageOptions +} + +const Default_MessageOptions_MessageSetWireFormat bool = false +const Default_MessageOptions_NoStandardDescriptorAccessor bool = false +const Default_MessageOptions_Deprecated bool = false + +func (m *MessageOptions) GetMessageSetWireFormat() bool { + if m != nil && m.MessageSetWireFormat != nil { + return *m.MessageSetWireFormat + } + return Default_MessageOptions_MessageSetWireFormat +} + +func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool { + if m != nil && m.NoStandardDescriptorAccessor != nil { + return *m.NoStandardDescriptorAccessor + } + return Default_MessageOptions_NoStandardDescriptorAccessor +} + +func (m *MessageOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_MessageOptions_Deprecated +} + +func (m *MessageOptions) GetMapEntry() bool { + if m != nil && m.MapEntry != nil { + return *m.MapEntry + } + return false +} + +func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type FieldOptions struct { + // The ctype option instructs the C++ code generator to use a different + // representation of the field than it normally would. See the specific + // options below. This option is not yet implemented in the open source + // release -- sorry, we'll try to include it in a future version! + Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"` + // The packed option can be enabled for repeated primitive fields to enable + // a more efficient representation on the wire. Rather than repeatedly + // writing the tag and type for each element, the entire array is encoded as + // a single length-delimited blob. In proto3, only explicit setting it to + // false will avoid using packed encoding. + Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"` + // The jstype option determines the JavaScript type used for values of the + // field. The option is permitted only for 64 bit integral and fixed types + // (int64, uint64, sint64, fixed64, sfixed64). By default these types are + // represented as JavaScript strings. This avoids loss of precision that can + // happen when a large value is converted to a floating point JavaScript + // numbers. Specifying JS_NUMBER for the jstype causes the generated + // JavaScript code to use the JavaScript "number" type instead of strings. + // This option is an enum to permit additional types to be added, + // e.g. goog.math.Integer. + Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"` + // Should this field be parsed lazily? Lazy applies only to message-type + // fields. It means that when the outer message is initially parsed, the + // inner message's contents will not be parsed but instead stored in encoded + // form. The inner message will actually be parsed when it is first accessed. + // + // This is only a hint. Implementations are free to choose whether to use + // eager or lazy parsing regardless of the value of this option. However, + // setting this option true suggests that the protocol author believes that + // using lazy parsing on this field is worth the additional bookkeeping + // overhead typically needed to implement it. + // + // This option does not affect the public interface of any generated code; + // all method signatures remain the same. Furthermore, thread-safety of the + // interface is not affected by this option; const methods remain safe to + // call from multiple threads concurrently, while non-const methods continue + // to require exclusive access. + // + // + // Note that implementations may choose not to check required fields within + // a lazy sub-message. That is, calling IsInitialized() on the outher message + // may return true even if the inner message has missing required fields. + // This is necessary because otherwise the inner message would have to be + // parsed in order to perform the check, defeating the purpose of lazy + // parsing. An implementation which chooses not to check required fields + // must be consistent about it. That is, for any particular sub-message, the + // implementation must either *always* check its required fields, or *never* + // check its required fields, regardless of whether or not the message has + // been parsed. + Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"` + // Is this field deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for accessors, or it will be completely ignored; in the very least, this + // is a formalization for deprecating fields. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // For Google-internal migration only. Do not use. + Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FieldOptions) Reset() { *m = FieldOptions{} } +func (m *FieldOptions) String() string { return proto.CompactTextString(m) } +func (*FieldOptions) ProtoMessage() {} +func (*FieldOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{11} } + +var extRange_FieldOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_FieldOptions +} + +const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING +const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL +const Default_FieldOptions_Lazy bool = false +const Default_FieldOptions_Deprecated bool = false +const Default_FieldOptions_Weak bool = false + +func (m *FieldOptions) GetCtype() FieldOptions_CType { + if m != nil && m.Ctype != nil { + return *m.Ctype + } + return Default_FieldOptions_Ctype +} + +func (m *FieldOptions) GetPacked() bool { + if m != nil && m.Packed != nil { + return *m.Packed + } + return false +} + +func (m *FieldOptions) GetJstype() FieldOptions_JSType { + if m != nil && m.Jstype != nil { + return *m.Jstype + } + return Default_FieldOptions_Jstype +} + +func (m *FieldOptions) GetLazy() bool { + if m != nil && m.Lazy != nil { + return *m.Lazy + } + return Default_FieldOptions_Lazy +} + +func (m *FieldOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_FieldOptions_Deprecated +} + +func (m *FieldOptions) GetWeak() bool { + if m != nil && m.Weak != nil { + return *m.Weak + } + return Default_FieldOptions_Weak +} + +func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type EnumOptions struct { + // Set this option to true to allow mapping different tag names to the same + // value. + AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"` + // Is this enum deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum, or it will be completely ignored; in the very least, this + // is a formalization for deprecating enums. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumOptions) Reset() { *m = EnumOptions{} } +func (m *EnumOptions) String() string { return proto.CompactTextString(m) } +func (*EnumOptions) ProtoMessage() {} +func (*EnumOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{12} } + +var extRange_EnumOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_EnumOptions +} + +const Default_EnumOptions_Deprecated bool = false + +func (m *EnumOptions) GetAllowAlias() bool { + if m != nil && m.AllowAlias != nil { + return *m.AllowAlias + } + return false +} + +func (m *EnumOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_EnumOptions_Deprecated +} + +func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type EnumValueOptions struct { + // Is this enum value deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum value, or it will be completely ignored; in the very least, + // this is a formalization for deprecating enum values. + Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumValueOptions) Reset() { *m = EnumValueOptions{} } +func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) } +func (*EnumValueOptions) ProtoMessage() {} +func (*EnumValueOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{13} } + +var extRange_EnumValueOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_EnumValueOptions +} + +const Default_EnumValueOptions_Deprecated bool = false + +func (m *EnumValueOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_EnumValueOptions_Deprecated +} + +func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type ServiceOptions struct { + // Is this service deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the service, or it will be completely ignored; in the very least, + // this is a formalization for deprecating services. + Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ServiceOptions) Reset() { *m = ServiceOptions{} } +func (m *ServiceOptions) String() string { return proto.CompactTextString(m) } +func (*ServiceOptions) ProtoMessage() {} +func (*ServiceOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{14} } + +var extRange_ServiceOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_ServiceOptions +} + +const Default_ServiceOptions_Deprecated bool = false + +func (m *ServiceOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_ServiceOptions_Deprecated +} + +func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type MethodOptions struct { + // Is this method deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the method, or it will be completely ignored; in the very least, + // this is a formalization for deprecating methods. + Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MethodOptions) Reset() { *m = MethodOptions{} } +func (m *MethodOptions) String() string { return proto.CompactTextString(m) } +func (*MethodOptions) ProtoMessage() {} +func (*MethodOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{15} } + +var extRange_MethodOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MethodOptions +} + +const Default_MethodOptions_Deprecated bool = false + +func (m *MethodOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_MethodOptions_Deprecated +} + +func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +// A message representing a option the parser does not recognize. This only +// appears in options protos created by the compiler::Parser class. +// DescriptorPool resolves these when building Descriptor objects. Therefore, +// options protos in descriptor objects (e.g. returned by Descriptor::options(), +// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions +// in them. +type UninterpretedOption struct { + Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"` + // The value of the uninterpreted option, in whatever type the tokenizer + // identified it as during parsing. Exactly one of these should be set. + IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"` + PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"` + NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"` + DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"` + StringValue []byte `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"` + AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UninterpretedOption) Reset() { *m = UninterpretedOption{} } +func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) } +func (*UninterpretedOption) ProtoMessage() {} +func (*UninterpretedOption) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{16} } + +func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart { + if m != nil { + return m.Name + } + return nil +} + +func (m *UninterpretedOption) GetIdentifierValue() string { + if m != nil && m.IdentifierValue != nil { + return *m.IdentifierValue + } + return "" +} + +func (m *UninterpretedOption) GetPositiveIntValue() uint64 { + if m != nil && m.PositiveIntValue != nil { + return *m.PositiveIntValue + } + return 0 +} + +func (m *UninterpretedOption) GetNegativeIntValue() int64 { + if m != nil && m.NegativeIntValue != nil { + return *m.NegativeIntValue + } + return 0 +} + +func (m *UninterpretedOption) GetDoubleValue() float64 { + if m != nil && m.DoubleValue != nil { + return *m.DoubleValue + } + return 0 +} + +func (m *UninterpretedOption) GetStringValue() []byte { + if m != nil { + return m.StringValue + } + return nil +} + +func (m *UninterpretedOption) GetAggregateValue() string { + if m != nil && m.AggregateValue != nil { + return *m.AggregateValue + } + return "" +} + +// The name of the uninterpreted option. Each string represents a segment in +// a dot-separated name. is_extension is true iff a segment represents an +// extension (denoted with parentheses in options specs in .proto files). +// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents +// "foo.(bar.baz).qux". +type UninterpretedOption_NamePart struct { + NamePart *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"` + IsExtension *bool `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UninterpretedOption_NamePart) Reset() { *m = UninterpretedOption_NamePart{} } +func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) } +func (*UninterpretedOption_NamePart) ProtoMessage() {} +func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) { + return fileDescriptorDescriptor, []int{16, 0} +} + +func (m *UninterpretedOption_NamePart) GetNamePart() string { + if m != nil && m.NamePart != nil { + return *m.NamePart + } + return "" +} + +func (m *UninterpretedOption_NamePart) GetIsExtension() bool { + if m != nil && m.IsExtension != nil { + return *m.IsExtension + } + return false +} + +// Encapsulates information about the original source file from which a +// FileDescriptorProto was generated. +type SourceCodeInfo struct { + // A Location identifies a piece of source code in a .proto file which + // corresponds to a particular definition. This information is intended + // to be useful to IDEs, code indexers, documentation generators, and similar + // tools. + // + // For example, say we have a file like: + // message Foo { + // optional string foo = 1; + // } + // Let's look at just the field definition: + // optional string foo = 1; + // ^ ^^ ^^ ^ ^^^ + // a bc de f ghi + // We have the following locations: + // span path represents + // [a,i) [ 4, 0, 2, 0 ] The whole field definition. + // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + // + // Notes: + // - A location may refer to a repeated field itself (i.e. not to any + // particular index within it). This is used whenever a set of elements are + // logically enclosed in a single code segment. For example, an entire + // extend block (possibly containing multiple extension definitions) will + // have an outer location whose path refers to the "extensions" repeated + // field without an index. + // - Multiple locations may have the same path. This happens when a single + // logical declaration is spread out across multiple places. The most + // obvious example is the "extend" block again -- there may be multiple + // extend blocks in the same scope, each of which will have the same path. + // - A location's span is not always a subset of its parent's span. For + // example, the "extendee" of an extension declaration appears at the + // beginning of the "extend" block and is shared by all extensions within + // the block. + // - Just because a location's span is a subset of some other location's span + // does not mean that it is a descendent. For example, a "group" defines + // both a type and a field in a single declaration. Thus, the locations + // corresponding to the type and field and their components will overlap. + // - Code which tries to interpret locations should probably be designed to + // ignore those that it doesn't understand, as more types of locations could + // be recorded in the future. + Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SourceCodeInfo) Reset() { *m = SourceCodeInfo{} } +func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) } +func (*SourceCodeInfo) ProtoMessage() {} +func (*SourceCodeInfo) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{17} } + +func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location { + if m != nil { + return m.Location + } + return nil +} + +type SourceCodeInfo_Location struct { + // Identifies which part of the FileDescriptorProto was defined at this + // location. + // + // Each element is a field number or an index. They form a path from + // the root FileDescriptorProto to the place where the definition. For + // example, this path: + // [ 4, 3, 2, 7, 1 ] + // refers to: + // file.message_type(3) // 4, 3 + // .field(7) // 2, 7 + // .name() // 1 + // This is because FileDescriptorProto.message_type has field number 4: + // repeated DescriptorProto message_type = 4; + // and DescriptorProto.field has field number 2: + // repeated FieldDescriptorProto field = 2; + // and FieldDescriptorProto.name has field number 1: + // optional string name = 1; + // + // Thus, the above path gives the location of a field name. If we removed + // the last element: + // [ 4, 3, 2, 7 ] + // this path refers to the whole field declaration (from the beginning + // of the label to the terminating semicolon). + Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"` + // Always has exactly three or four elements: start line, start column, + // end line (optional, otherwise assumed same as start line), end column. + // These are packed into a single field for efficiency. Note that line + // and column numbers are zero-based -- typically you will want to add + // 1 to each before displaying to a user. + Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"` + // If this SourceCodeInfo represents a complete declaration, these are any + // comments appearing before and after the declaration which appear to be + // attached to the declaration. + // + // A series of line comments appearing on consecutive lines, with no other + // tokens appearing on those lines, will be treated as a single comment. + // + // leading_detached_comments will keep paragraphs of comments that appear + // before (but not connected to) the current element. Each paragraph, + // separated by empty lines, will be one comment element in the repeated + // field. + // + // Only the comment content is provided; comment markers (e.g. //) are + // stripped out. For block comments, leading whitespace and an asterisk + // will be stripped from the beginning of each line other than the first. + // Newlines are included in the output. + // + // Examples: + // + // optional int32 foo = 1; // Comment attached to foo. + // // Comment attached to bar. + // optional int32 bar = 2; + // + // optional string baz = 3; + // // Comment attached to baz. + // // Another line attached to baz. + // + // // Comment attached to qux. + // // + // // Another line attached to qux. + // optional double qux = 4; + // + // // Detached comment for corge. This is not leading or trailing comments + // // to qux or corge because there are blank lines separating it from + // // both. + // + // // Detached comment for corge paragraph 2. + // + // optional string corge = 5; + // /* Block comment attached + // * to corge. Leading asterisks + // * will be removed. */ + // /* Block comment attached to + // * grault. */ + // optional int32 grault = 6; + // + // // ignored detached comments. + LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"` + TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"` + LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SourceCodeInfo_Location) Reset() { *m = SourceCodeInfo_Location{} } +func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) } +func (*SourceCodeInfo_Location) ProtoMessage() {} +func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) { + return fileDescriptorDescriptor, []int{17, 0} +} + +func (m *SourceCodeInfo_Location) GetPath() []int32 { + if m != nil { + return m.Path + } + return nil +} + +func (m *SourceCodeInfo_Location) GetSpan() []int32 { + if m != nil { + return m.Span + } + return nil +} + +func (m *SourceCodeInfo_Location) GetLeadingComments() string { + if m != nil && m.LeadingComments != nil { + return *m.LeadingComments + } + return "" +} + +func (m *SourceCodeInfo_Location) GetTrailingComments() string { + if m != nil && m.TrailingComments != nil { + return *m.TrailingComments + } + return "" +} + +func (m *SourceCodeInfo_Location) GetLeadingDetachedComments() []string { + if m != nil { + return m.LeadingDetachedComments + } + return nil +} + +func init() { + proto.RegisterType((*FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet") + proto.RegisterType((*FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto") + proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto") + proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange") + proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange") + proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto") + proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto") + proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto") + proto.RegisterType((*EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto") + proto.RegisterType((*ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto") + proto.RegisterType((*MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto") + proto.RegisterType((*FileOptions)(nil), "google.protobuf.FileOptions") + proto.RegisterType((*MessageOptions)(nil), "google.protobuf.MessageOptions") + proto.RegisterType((*FieldOptions)(nil), "google.protobuf.FieldOptions") + proto.RegisterType((*EnumOptions)(nil), "google.protobuf.EnumOptions") + proto.RegisterType((*EnumValueOptions)(nil), "google.protobuf.EnumValueOptions") + proto.RegisterType((*ServiceOptions)(nil), "google.protobuf.ServiceOptions") + proto.RegisterType((*MethodOptions)(nil), "google.protobuf.MethodOptions") + proto.RegisterType((*UninterpretedOption)(nil), "google.protobuf.UninterpretedOption") + proto.RegisterType((*UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart") + proto.RegisterType((*SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo") + proto.RegisterType((*SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location") + proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value) + proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value) + proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value) + proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value) + proto.RegisterEnum("google.protobuf.FieldOptions_JSType", FieldOptions_JSType_name, FieldOptions_JSType_value) +} + +func init() { proto.RegisterFile("descriptor.proto", fileDescriptorDescriptor) } + +var fileDescriptorDescriptor = []byte{ + // 2211 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x58, 0x4f, 0x73, 0xdb, 0xc6, + 0x15, 0x0f, 0xf8, 0x4f, 0xe4, 0x23, 0x45, 0xad, 0x56, 0x8a, 0x03, 0xcb, 0x76, 0x2c, 0x33, 0x76, + 0x2c, 0xdb, 0xad, 0x9c, 0x91, 0xff, 0x44, 0x51, 0x3a, 0xe9, 0x50, 0x24, 0xac, 0xd0, 0x43, 0x89, + 0x2c, 0x28, 0xb6, 0x4e, 0x2e, 0x98, 0x15, 0xb0, 0xa4, 0x60, 0x83, 0x0b, 0x14, 0x00, 0x6d, 0x2b, + 0x27, 0xcf, 0xf4, 0xd4, 0x6f, 0xd0, 0x69, 0x3b, 0x3d, 0xe4, 0x92, 0x99, 0x7e, 0x80, 0x1e, 0x7a, + 0xef, 0xb5, 0x87, 0x9e, 0x7b, 0xec, 0x4c, 0xfb, 0x0d, 0x7a, 0xed, 0xec, 0x2e, 0x00, 0x82, 0x7f, + 0x14, 0xab, 0x99, 0x49, 0xd3, 0x93, 0xb4, 0xbf, 0xf7, 0x7b, 0x8f, 0x6f, 0xdf, 0xfe, 0xb0, 0xef, + 0x01, 0x80, 0x2c, 0x1a, 0x98, 0xbe, 0xed, 0x85, 0xae, 0xbf, 0xed, 0xf9, 0x6e, 0xe8, 0xe2, 0x95, + 0xa1, 0xeb, 0x0e, 0x1d, 0x2a, 0x57, 0x27, 0xe3, 0x41, 0xed, 0x10, 0x56, 0x9f, 0xd8, 0x0e, 0x6d, + 0x26, 0xc4, 0x1e, 0x0d, 0xf1, 0x2e, 0xe4, 0x06, 0xb6, 0x43, 0x55, 0x65, 0x33, 0xbb, 0x55, 0xde, + 0xb9, 0xb9, 0x3d, 0xe3, 0xb4, 0x3d, 0xed, 0xd1, 0xe5, 0xb0, 0x2e, 0x3c, 0x6a, 0xff, 0xc8, 0xc1, + 0xda, 0x02, 0x2b, 0xc6, 0x90, 0x63, 0x64, 0xc4, 0x23, 0x2a, 0x5b, 0x25, 0x5d, 0xfc, 0x8f, 0x55, + 0x58, 0xf2, 0x88, 0xf9, 0x82, 0x0c, 0xa9, 0x9a, 0x11, 0x70, 0xbc, 0xc4, 0xef, 0x03, 0x58, 0xd4, + 0xa3, 0xcc, 0xa2, 0xcc, 0x3c, 0x53, 0xb3, 0x9b, 0xd9, 0xad, 0x92, 0x9e, 0x42, 0xf0, 0x3d, 0x58, + 0xf5, 0xc6, 0x27, 0x8e, 0x6d, 0x1a, 0x29, 0x1a, 0x6c, 0x66, 0xb7, 0xf2, 0x3a, 0x92, 0x86, 0xe6, + 0x84, 0x7c, 0x1b, 0x56, 0x5e, 0x51, 0xf2, 0x22, 0x4d, 0x2d, 0x0b, 0x6a, 0x95, 0xc3, 0x29, 0x62, + 0x03, 0x2a, 0x23, 0x1a, 0x04, 0x64, 0x48, 0x8d, 0xf0, 0xcc, 0xa3, 0x6a, 0x4e, 0xec, 0x7e, 0x73, + 0x6e, 0xf7, 0xb3, 0x3b, 0x2f, 0x47, 0x5e, 0xc7, 0x67, 0x1e, 0xc5, 0x75, 0x28, 0x51, 0x36, 0x1e, + 0xc9, 0x08, 0xf9, 0x73, 0xea, 0xa7, 0xb1, 0xf1, 0x68, 0x36, 0x4a, 0x91, 0xbb, 0x45, 0x21, 0x96, + 0x02, 0xea, 0xbf, 0xb4, 0x4d, 0xaa, 0x16, 0x44, 0x80, 0xdb, 0x73, 0x01, 0x7a, 0xd2, 0x3e, 0x1b, + 0x23, 0xf6, 0xc3, 0x0d, 0x28, 0xd1, 0xd7, 0x21, 0x65, 0x81, 0xed, 0x32, 0x75, 0x49, 0x04, 0xb9, + 0xb5, 0xe0, 0x14, 0xa9, 0x63, 0xcd, 0x86, 0x98, 0xf8, 0xe1, 0xc7, 0xb0, 0xe4, 0x7a, 0xa1, 0xed, + 0xb2, 0x40, 0x2d, 0x6e, 0x2a, 0x5b, 0xe5, 0x9d, 0xab, 0x0b, 0x85, 0xd0, 0x91, 0x1c, 0x3d, 0x26, + 0xe3, 0x16, 0xa0, 0xc0, 0x1d, 0xfb, 0x26, 0x35, 0x4c, 0xd7, 0xa2, 0x86, 0xcd, 0x06, 0xae, 0x5a, + 0x12, 0x01, 0xae, 0xcf, 0x6f, 0x44, 0x10, 0x1b, 0xae, 0x45, 0x5b, 0x6c, 0xe0, 0xea, 0xd5, 0x60, + 0x6a, 0x8d, 0x2f, 0x41, 0x21, 0x38, 0x63, 0x21, 0x79, 0xad, 0x56, 0x84, 0x42, 0xa2, 0x55, 0xed, + 0xdf, 0x79, 0x58, 0xb9, 0x88, 0xc4, 0x3e, 0x85, 0xfc, 0x80, 0xef, 0x52, 0xcd, 0xfc, 0x37, 0x35, + 0x90, 0x3e, 0xd3, 0x45, 0x2c, 0x7c, 0xc7, 0x22, 0xd6, 0xa1, 0xcc, 0x68, 0x10, 0x52, 0x4b, 0x2a, + 0x22, 0x7b, 0x41, 0x4d, 0x81, 0x74, 0x9a, 0x97, 0x54, 0xee, 0x3b, 0x49, 0xea, 0x19, 0xac, 0x24, + 0x29, 0x19, 0x3e, 0x61, 0xc3, 0x58, 0x9b, 0xf7, 0xdf, 0x96, 0xc9, 0xb6, 0x16, 0xfb, 0xe9, 0xdc, + 0x4d, 0xaf, 0xd2, 0xa9, 0x35, 0x6e, 0x02, 0xb8, 0x8c, 0xba, 0x03, 0xc3, 0xa2, 0xa6, 0xa3, 0x16, + 0xcf, 0xa9, 0x52, 0x87, 0x53, 0xe6, 0xaa, 0xe4, 0x4a, 0xd4, 0x74, 0xf0, 0x27, 0x13, 0xa9, 0x2d, + 0x9d, 0xa3, 0x94, 0x43, 0xf9, 0x90, 0xcd, 0xa9, 0xad, 0x0f, 0x55, 0x9f, 0x72, 0xdd, 0x53, 0x2b, + 0xda, 0x59, 0x49, 0x24, 0xb1, 0xfd, 0xd6, 0x9d, 0xe9, 0x91, 0x9b, 0xdc, 0xd8, 0xb2, 0x9f, 0x5e, + 0xe2, 0x0f, 0x20, 0x01, 0x0c, 0x21, 0x2b, 0x10, 0xb7, 0x50, 0x25, 0x06, 0x8f, 0xc8, 0x88, 0x6e, + 0xec, 0x42, 0x75, 0xba, 0x3c, 0x78, 0x1d, 0xf2, 0x41, 0x48, 0xfc, 0x50, 0xa8, 0x30, 0xaf, 0xcb, + 0x05, 0x46, 0x90, 0xa5, 0xcc, 0x12, 0xb7, 0x5c, 0x5e, 0xe7, 0xff, 0x6e, 0x7c, 0x0c, 0xcb, 0x53, + 0x3f, 0x7f, 0x51, 0xc7, 0xda, 0x6f, 0x0a, 0xb0, 0xbe, 0x48, 0x73, 0x0b, 0xe5, 0x7f, 0x09, 0x0a, + 0x6c, 0x3c, 0x3a, 0xa1, 0xbe, 0x9a, 0x15, 0x11, 0xa2, 0x15, 0xae, 0x43, 0xde, 0x21, 0x27, 0xd4, + 0x51, 0x73, 0x9b, 0xca, 0x56, 0x75, 0xe7, 0xde, 0x85, 0x54, 0xbd, 0xdd, 0xe6, 0x2e, 0xba, 0xf4, + 0xc4, 0x9f, 0x41, 0x2e, 0xba, 0xe2, 0x78, 0x84, 0xbb, 0x17, 0x8b, 0xc0, 0xb5, 0xa8, 0x0b, 0x3f, + 0x7c, 0x05, 0x4a, 0xfc, 0xaf, 0xac, 0x6d, 0x41, 0xe4, 0x5c, 0xe4, 0x00, 0xaf, 0x2b, 0xde, 0x80, + 0xa2, 0x90, 0x99, 0x45, 0xe3, 0xd6, 0x90, 0xac, 0xf9, 0xc1, 0x58, 0x74, 0x40, 0xc6, 0x4e, 0x68, + 0xbc, 0x24, 0xce, 0x98, 0x0a, 0xc1, 0x94, 0xf4, 0x4a, 0x04, 0xfe, 0x9c, 0x63, 0xf8, 0x3a, 0x94, + 0xa5, 0x2a, 0x6d, 0x66, 0xd1, 0xd7, 0xe2, 0xf6, 0xc9, 0xeb, 0x52, 0xa8, 0x2d, 0x8e, 0xf0, 0x9f, + 0x7f, 0x1e, 0xb8, 0x2c, 0x3e, 0x5a, 0xf1, 0x13, 0x1c, 0x10, 0x3f, 0xff, 0xf1, 0xec, 0xc5, 0x77, + 0x6d, 0xf1, 0xf6, 0x66, 0xb5, 0x58, 0xfb, 0x53, 0x06, 0x72, 0xe2, 0x79, 0x5b, 0x81, 0xf2, 0xf1, + 0x17, 0x5d, 0xcd, 0x68, 0x76, 0xfa, 0xfb, 0x6d, 0x0d, 0x29, 0xb8, 0x0a, 0x20, 0x80, 0x27, 0xed, + 0x4e, 0xfd, 0x18, 0x65, 0x92, 0x75, 0xeb, 0xe8, 0xf8, 0xf1, 0x43, 0x94, 0x4d, 0x1c, 0xfa, 0x12, + 0xc8, 0xa5, 0x09, 0x0f, 0x76, 0x50, 0x1e, 0x23, 0xa8, 0xc8, 0x00, 0xad, 0x67, 0x5a, 0xf3, 0xf1, + 0x43, 0x54, 0x98, 0x46, 0x1e, 0xec, 0xa0, 0x25, 0xbc, 0x0c, 0x25, 0x81, 0xec, 0x77, 0x3a, 0x6d, + 0x54, 0x4c, 0x62, 0xf6, 0x8e, 0xf5, 0xd6, 0xd1, 0x01, 0x2a, 0x25, 0x31, 0x0f, 0xf4, 0x4e, 0xbf, + 0x8b, 0x20, 0x89, 0x70, 0xa8, 0xf5, 0x7a, 0xf5, 0x03, 0x0d, 0x95, 0x13, 0xc6, 0xfe, 0x17, 0xc7, + 0x5a, 0x0f, 0x55, 0xa6, 0xd2, 0x7a, 0xb0, 0x83, 0x96, 0x93, 0x9f, 0xd0, 0x8e, 0xfa, 0x87, 0xa8, + 0x8a, 0x57, 0x61, 0x59, 0xfe, 0x44, 0x9c, 0xc4, 0xca, 0x0c, 0xf4, 0xf8, 0x21, 0x42, 0x93, 0x44, + 0x64, 0x94, 0xd5, 0x29, 0xe0, 0xf1, 0x43, 0x84, 0x6b, 0x0d, 0xc8, 0x0b, 0x75, 0x61, 0x0c, 0xd5, + 0x76, 0x7d, 0x5f, 0x6b, 0x1b, 0x9d, 0xee, 0x71, 0xab, 0x73, 0x54, 0x6f, 0x23, 0x65, 0x82, 0xe9, + 0xda, 0xcf, 0xfa, 0x2d, 0x5d, 0x6b, 0xa2, 0x4c, 0x1a, 0xeb, 0x6a, 0xf5, 0x63, 0xad, 0x89, 0xb2, + 0xb5, 0xbb, 0xb0, 0xbe, 0xe8, 0x9e, 0x59, 0xf4, 0x64, 0xd4, 0xbe, 0x56, 0x60, 0x6d, 0xc1, 0x95, + 0xb9, 0xf0, 0x29, 0xfa, 0x29, 0xe4, 0xa5, 0xd2, 0x64, 0x13, 0xb9, 0xb3, 0xf0, 0xee, 0x15, 0xba, + 0x9b, 0x6b, 0x24, 0xc2, 0x2f, 0xdd, 0x48, 0xb3, 0xe7, 0x34, 0x52, 0x1e, 0x62, 0x4e, 0x4e, 0xbf, + 0x52, 0x40, 0x3d, 0x2f, 0xf6, 0x5b, 0x9e, 0xf7, 0xcc, 0xd4, 0xf3, 0xfe, 0xe9, 0x6c, 0x02, 0x37, + 0xce, 0xdf, 0xc3, 0x5c, 0x16, 0xdf, 0x28, 0x70, 0x69, 0xf1, 0xbc, 0xb1, 0x30, 0x87, 0xcf, 0xa0, + 0x30, 0xa2, 0xe1, 0xa9, 0x1b, 0xf7, 0xdc, 0x0f, 0x17, 0xdc, 0xe4, 0xdc, 0x3c, 0x5b, 0xab, 0xc8, + 0x2b, 0xdd, 0x0a, 0xb2, 0xe7, 0x0d, 0x0d, 0x32, 0x9b, 0xb9, 0x4c, 0x7f, 0x9d, 0x81, 0x77, 0x17, + 0x06, 0x5f, 0x98, 0xe8, 0x35, 0x00, 0x9b, 0x79, 0xe3, 0x50, 0xf6, 0x55, 0x79, 0xcd, 0x94, 0x04, + 0x22, 0x1e, 0x61, 0x7e, 0x85, 0x8c, 0xc3, 0xc4, 0x9e, 0x15, 0x76, 0x90, 0x90, 0x20, 0xec, 0x4e, + 0x12, 0xcd, 0x89, 0x44, 0xdf, 0x3f, 0x67, 0xa7, 0x73, 0x2d, 0xeb, 0x23, 0x40, 0xa6, 0x63, 0x53, + 0x16, 0x1a, 0x41, 0xe8, 0x53, 0x32, 0xb2, 0xd9, 0x50, 0xdc, 0xa3, 0xc5, 0xbd, 0xfc, 0x80, 0x38, + 0x01, 0xd5, 0x57, 0xa4, 0xb9, 0x17, 0x5b, 0xb9, 0x87, 0x68, 0x16, 0x7e, 0xca, 0xa3, 0x30, 0xe5, + 0x21, 0xcd, 0x89, 0x47, 0xed, 0x6f, 0x4b, 0x50, 0x4e, 0x4d, 0x67, 0xf8, 0x06, 0x54, 0x9e, 0x93, + 0x97, 0xc4, 0x88, 0x27, 0x6e, 0x59, 0x89, 0x32, 0xc7, 0xba, 0xd1, 0xd4, 0xfd, 0x11, 0xac, 0x0b, + 0x8a, 0x3b, 0x0e, 0xa9, 0x6f, 0x98, 0x0e, 0x09, 0x02, 0x51, 0xb4, 0xa2, 0xa0, 0x62, 0x6e, 0xeb, + 0x70, 0x53, 0x23, 0xb6, 0xe0, 0x47, 0xb0, 0x26, 0x3c, 0x46, 0x63, 0x27, 0xb4, 0x3d, 0x87, 0x1a, + 0xfc, 0x1d, 0x20, 0x10, 0xf7, 0x69, 0x92, 0xd9, 0x2a, 0x67, 0x1c, 0x46, 0x04, 0x9e, 0x51, 0x80, + 0x0f, 0xe0, 0x9a, 0x70, 0x1b, 0x52, 0x46, 0x7d, 0x12, 0x52, 0x83, 0xfe, 0x72, 0x4c, 0x9c, 0xc0, + 0x20, 0xcc, 0x32, 0x4e, 0x49, 0x70, 0xaa, 0xae, 0xa7, 0x03, 0x5c, 0xe6, 0xdc, 0x83, 0x88, 0xaa, + 0x09, 0x66, 0x9d, 0x59, 0x9f, 0x93, 0xe0, 0x14, 0xef, 0xc1, 0x25, 0x11, 0x28, 0x08, 0x7d, 0x9b, + 0x0d, 0x0d, 0xf3, 0x94, 0x9a, 0x2f, 0x8c, 0x71, 0x38, 0xd8, 0x55, 0xaf, 0xa4, 0x23, 0x88, 0x24, + 0x7b, 0x82, 0xd3, 0xe0, 0x94, 0x7e, 0x38, 0xd8, 0xc5, 0x3d, 0xa8, 0xf0, 0xf3, 0x18, 0xd9, 0x5f, + 0x51, 0x63, 0xe0, 0xfa, 0xa2, 0x47, 0x54, 0x17, 0x3c, 0xdc, 0xa9, 0x22, 0x6e, 0x77, 0x22, 0x87, + 0x43, 0xd7, 0xa2, 0x7b, 0xf9, 0x5e, 0x57, 0xd3, 0x9a, 0x7a, 0x39, 0x8e, 0xf2, 0xc4, 0xf5, 0xb9, + 0xa6, 0x86, 0x6e, 0x52, 0xe3, 0xb2, 0xd4, 0xd4, 0xd0, 0x8d, 0x2b, 0xfc, 0x08, 0xd6, 0x4c, 0x53, + 0x6e, 0xdb, 0x36, 0x8d, 0x68, 0x58, 0x0f, 0x54, 0x34, 0x55, 0x2f, 0xd3, 0x3c, 0x90, 0x84, 0x48, + 0xe6, 0x01, 0xfe, 0x04, 0xde, 0x9d, 0xd4, 0x2b, 0xed, 0xb8, 0x3a, 0xb7, 0xcb, 0x59, 0xd7, 0x47, + 0xb0, 0xe6, 0x9d, 0xcd, 0x3b, 0xe2, 0xa9, 0x5f, 0xf4, 0xce, 0x66, 0xdd, 0x6e, 0x89, 0x17, 0x30, + 0x9f, 0x9a, 0x24, 0xa4, 0x96, 0xfa, 0x5e, 0x9a, 0x9d, 0x32, 0xe0, 0xfb, 0x80, 0x4c, 0xd3, 0xa0, + 0x8c, 0x9c, 0x38, 0xd4, 0x20, 0x3e, 0x65, 0x24, 0x50, 0xaf, 0xa7, 0xc9, 0x55, 0xd3, 0xd4, 0x84, + 0xb5, 0x2e, 0x8c, 0xf8, 0x2e, 0xac, 0xba, 0x27, 0xcf, 0x4d, 0x29, 0x2e, 0xc3, 0xf3, 0xe9, 0xc0, + 0x7e, 0xad, 0xde, 0x14, 0x65, 0x5a, 0xe1, 0x06, 0x21, 0xad, 0xae, 0x80, 0xf1, 0x1d, 0x40, 0x66, + 0x70, 0x4a, 0x7c, 0x4f, 0x34, 0xe9, 0xc0, 0x23, 0x26, 0x55, 0x6f, 0x49, 0xaa, 0xc4, 0x8f, 0x62, + 0x18, 0x6b, 0x70, 0x9d, 0x6f, 0x9e, 0x11, 0xe6, 0x1a, 0xe3, 0x80, 0x1a, 0x93, 0x14, 0x93, 0xb3, + 0xf8, 0x90, 0xa7, 0xa5, 0x5f, 0x8d, 0x69, 0xfd, 0x80, 0x36, 0x13, 0x52, 0x7c, 0x3c, 0xcf, 0x60, + 0x7d, 0xcc, 0x6c, 0x16, 0x52, 0xdf, 0xf3, 0x29, 0x77, 0x96, 0x0f, 0xac, 0xfa, 0xcf, 0xa5, 0x73, + 0x86, 0xee, 0x7e, 0x9a, 0x2d, 0x45, 0xa2, 0xaf, 0x8d, 0xe7, 0xc1, 0xda, 0x1e, 0x54, 0xd2, 0xda, + 0xc1, 0x25, 0x90, 0xea, 0x41, 0x0a, 0xef, 0xa8, 0x8d, 0x4e, 0x93, 0xf7, 0xc2, 0x2f, 0x35, 0x94, + 0xe1, 0x3d, 0xb9, 0xdd, 0x3a, 0xd6, 0x0c, 0xbd, 0x7f, 0x74, 0xdc, 0x3a, 0xd4, 0x50, 0xf6, 0x6e, + 0xa9, 0xf8, 0xaf, 0x25, 0xf4, 0xe6, 0xcd, 0x9b, 0x37, 0x99, 0xda, 0x5f, 0x32, 0x50, 0x9d, 0x9e, + 0x83, 0xf1, 0x4f, 0xe0, 0xbd, 0xf8, 0xa5, 0x35, 0xa0, 0xa1, 0xf1, 0xca, 0xf6, 0x85, 0x9c, 0x47, + 0x44, 0x4e, 0x92, 0xc9, 0x49, 0xac, 0x47, 0xac, 0x1e, 0x0d, 0x7f, 0x61, 0xfb, 0x5c, 0xac, 0x23, + 0x12, 0xe2, 0x36, 0x5c, 0x67, 0xae, 0x11, 0x84, 0x84, 0x59, 0xc4, 0xb7, 0x8c, 0xc9, 0xe7, 0x02, + 0x83, 0x98, 0x26, 0x0d, 0x02, 0x57, 0x76, 0x92, 0x24, 0xca, 0x55, 0xe6, 0xf6, 0x22, 0xf2, 0xe4, + 0x8a, 0xad, 0x47, 0xd4, 0x19, 0xd5, 0x64, 0xcf, 0x53, 0xcd, 0x15, 0x28, 0x8d, 0x88, 0x67, 0x50, + 0x16, 0xfa, 0x67, 0x62, 0x7a, 0x2b, 0xea, 0xc5, 0x11, 0xf1, 0x34, 0xbe, 0xfe, 0xfe, 0xce, 0x20, + 0x5d, 0xc7, 0xbf, 0x67, 0xa1, 0x92, 0x9e, 0xe0, 0xf8, 0x40, 0x6c, 0x8a, 0x6b, 0x5e, 0x11, 0xb7, + 0xc0, 0x07, 0xdf, 0x3a, 0xef, 0x6d, 0x37, 0xf8, 0xfd, 0xbf, 0x57, 0x90, 0x73, 0x95, 0x2e, 0x3d, + 0x79, 0xef, 0xe5, 0x5a, 0xa3, 0x72, 0x5a, 0x2f, 0xea, 0xd1, 0x0a, 0x1f, 0x40, 0xe1, 0x79, 0x20, + 0x62, 0x17, 0x44, 0xec, 0x9b, 0xdf, 0x1e, 0xfb, 0x69, 0x4f, 0x04, 0x2f, 0x3d, 0xed, 0x19, 0x47, + 0x1d, 0xfd, 0xb0, 0xde, 0xd6, 0x23, 0x77, 0x7c, 0x19, 0x72, 0x0e, 0xf9, 0xea, 0x6c, 0xba, 0x53, + 0x08, 0xe8, 0xa2, 0x85, 0xbf, 0x0c, 0xb9, 0x57, 0x94, 0xbc, 0x98, 0xbe, 0x9f, 0x05, 0xf4, 0x3d, + 0x4a, 0xff, 0x3e, 0xe4, 0x45, 0xbd, 0x30, 0x40, 0x54, 0x31, 0xf4, 0x0e, 0x2e, 0x42, 0xae, 0xd1, + 0xd1, 0xb9, 0xfc, 0x11, 0x54, 0x24, 0x6a, 0x74, 0x5b, 0x5a, 0x43, 0x43, 0x99, 0xda, 0x23, 0x28, + 0xc8, 0x22, 0xf0, 0x47, 0x23, 0x29, 0x03, 0x7a, 0x27, 0x5a, 0x46, 0x31, 0x94, 0xd8, 0xda, 0x3f, + 0xdc, 0xd7, 0x74, 0x94, 0x49, 0x1f, 0xef, 0x9f, 0x15, 0x28, 0xa7, 0x06, 0x2a, 0xde, 0xca, 0x89, + 0xe3, 0xb8, 0xaf, 0x0c, 0xe2, 0xd8, 0x24, 0x88, 0xce, 0x07, 0x04, 0x54, 0xe7, 0xc8, 0x45, 0xeb, + 0xf7, 0x3f, 0xd1, 0xe6, 0x1f, 0x14, 0x40, 0xb3, 0xc3, 0xd8, 0x4c, 0x82, 0xca, 0x0f, 0x9a, 0xe0, + 0xef, 0x15, 0xa8, 0x4e, 0x4f, 0x60, 0x33, 0xe9, 0xdd, 0xf8, 0x41, 0xd3, 0xfb, 0x9d, 0x02, 0xcb, + 0x53, 0x73, 0xd7, 0xff, 0x55, 0x76, 0xbf, 0xcd, 0xc2, 0xda, 0x02, 0x3f, 0x5c, 0x8f, 0x06, 0x54, + 0x39, 0x33, 0xff, 0xf8, 0x22, 0xbf, 0xb5, 0xcd, 0xfb, 0x5f, 0x97, 0xf8, 0x61, 0x34, 0xcf, 0xde, + 0x01, 0x64, 0x5b, 0x94, 0x85, 0xf6, 0xc0, 0xa6, 0x7e, 0xf4, 0x6e, 0x2c, 0xa7, 0xd6, 0x95, 0x09, + 0x2e, 0x5f, 0x8f, 0x7f, 0x04, 0xd8, 0x73, 0x03, 0x3b, 0xb4, 0x5f, 0x52, 0xc3, 0x66, 0xf1, 0x8b, + 0x34, 0x9f, 0x62, 0x73, 0x3a, 0x8a, 0x2d, 0x2d, 0x16, 0x26, 0x6c, 0x46, 0x87, 0x64, 0x86, 0xcd, + 0xaf, 0xa1, 0xac, 0x8e, 0x62, 0x4b, 0xc2, 0xbe, 0x01, 0x15, 0xcb, 0x1d, 0xf3, 0x81, 0x40, 0xf2, + 0xf8, 0xad, 0xa7, 0xe8, 0x65, 0x89, 0x25, 0x94, 0x68, 0x62, 0x9b, 0xbc, 0xc1, 0x57, 0xf4, 0xb2, + 0xc4, 0x24, 0xe5, 0x36, 0xac, 0x90, 0xe1, 0xd0, 0xe7, 0xc1, 0xe3, 0x40, 0x72, 0x0c, 0xad, 0x26, + 0xb0, 0x20, 0x6e, 0x3c, 0x85, 0x62, 0x5c, 0x07, 0xde, 0x58, 0x78, 0x25, 0x0c, 0x4f, 0x7e, 0x47, + 0xc9, 0xf0, 0x97, 0x7a, 0x16, 0x1b, 0x6f, 0x40, 0xc5, 0x0e, 0x8c, 0xc9, 0x07, 0xbd, 0xcc, 0x66, + 0x66, 0xab, 0xa8, 0x97, 0xed, 0x20, 0xf9, 0x82, 0x53, 0xfb, 0x26, 0x03, 0xd5, 0xe9, 0x0f, 0x92, + 0xb8, 0x09, 0x45, 0xc7, 0x35, 0x89, 0x10, 0x82, 0xfc, 0x1a, 0xbe, 0xf5, 0x96, 0x6f, 0x98, 0xdb, + 0xed, 0x88, 0xaf, 0x27, 0x9e, 0x1b, 0x7f, 0x55, 0xa0, 0x18, 0xc3, 0xf8, 0x12, 0xe4, 0x3c, 0x12, + 0x9e, 0x8a, 0x70, 0xf9, 0xfd, 0x0c, 0x52, 0x74, 0xb1, 0xe6, 0x78, 0xe0, 0x11, 0x26, 0x24, 0x10, + 0xe1, 0x7c, 0xcd, 0xcf, 0xd5, 0xa1, 0xc4, 0x12, 0x03, 0xae, 0x3b, 0x1a, 0x51, 0x16, 0x06, 0xf1, + 0xb9, 0x46, 0x78, 0x23, 0x82, 0xf1, 0x3d, 0x58, 0x0d, 0x7d, 0x62, 0x3b, 0x53, 0xdc, 0x9c, 0xe0, + 0xa2, 0xd8, 0x90, 0x90, 0xf7, 0xe0, 0x72, 0x1c, 0xd7, 0xa2, 0x21, 0x31, 0x4f, 0xa9, 0x35, 0x71, + 0x2a, 0x88, 0xaf, 0x5d, 0xef, 0x45, 0x84, 0x66, 0x64, 0x8f, 0x7d, 0xf7, 0x9f, 0xc1, 0x9a, 0xe9, + 0x8e, 0x66, 0x2b, 0xb1, 0x8f, 0x66, 0xde, 0xbb, 0x82, 0xcf, 0x95, 0x2f, 0x61, 0x32, 0x54, 0x7c, + 0x9d, 0xc9, 0x1e, 0x74, 0xf7, 0xff, 0x98, 0xd9, 0x38, 0x90, 0x7e, 0xdd, 0xb8, 0x82, 0x3a, 0x1d, + 0x38, 0xd4, 0xe4, 0xd5, 0xf9, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x42, 0x69, 0x71, 0xb3, + 0x18, 0x00, 0x00, +} diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go new file mode 100644 index 00000000..b175f555 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go @@ -0,0 +1,658 @@ +// Code generated by protoc-gen-gogo. +// source: descriptor.proto +// DO NOT EDIT! + +/* +Package descriptor is a generated protocol buffer package. + +It is generated from these files: + descriptor.proto + +It has these top-level messages: + FileDescriptorSet + FileDescriptorProto + DescriptorProto + FieldDescriptorProto + OneofDescriptorProto + EnumDescriptorProto + EnumValueDescriptorProto + ServiceDescriptorProto + MethodDescriptorProto + FileOptions + MessageOptions + FieldOptions + EnumOptions + EnumValueOptions + ServiceOptions + MethodOptions + UninterpretedOption + SourceCodeInfo +*/ +package descriptor + +import fmt "fmt" +import strings "strings" +import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" +import proto "github.com/gogo/protobuf/proto" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func (this *FileDescriptorSet) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&descriptor.FileDescriptorSet{") + if this.File != nil { + s = append(s, "File: "+fmt.Sprintf("%#v", this.File)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FileDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 16) + s = append(s, "&descriptor.FileDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Package != nil { + s = append(s, "Package: "+valueToGoStringDescriptor(this.Package, "string")+",\n") + } + if this.Dependency != nil { + s = append(s, "Dependency: "+fmt.Sprintf("%#v", this.Dependency)+",\n") + } + if this.PublicDependency != nil { + s = append(s, "PublicDependency: "+fmt.Sprintf("%#v", this.PublicDependency)+",\n") + } + if this.WeakDependency != nil { + s = append(s, "WeakDependency: "+fmt.Sprintf("%#v", this.WeakDependency)+",\n") + } + if this.MessageType != nil { + s = append(s, "MessageType: "+fmt.Sprintf("%#v", this.MessageType)+",\n") + } + if this.EnumType != nil { + s = append(s, "EnumType: "+fmt.Sprintf("%#v", this.EnumType)+",\n") + } + if this.Service != nil { + s = append(s, "Service: "+fmt.Sprintf("%#v", this.Service)+",\n") + } + if this.Extension != nil { + s = append(s, "Extension: "+fmt.Sprintf("%#v", this.Extension)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.SourceCodeInfo != nil { + s = append(s, "SourceCodeInfo: "+fmt.Sprintf("%#v", this.SourceCodeInfo)+",\n") + } + if this.Syntax != nil { + s = append(s, "Syntax: "+valueToGoStringDescriptor(this.Syntax, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&descriptor.DescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Field != nil { + s = append(s, "Field: "+fmt.Sprintf("%#v", this.Field)+",\n") + } + if this.Extension != nil { + s = append(s, "Extension: "+fmt.Sprintf("%#v", this.Extension)+",\n") + } + if this.NestedType != nil { + s = append(s, "NestedType: "+fmt.Sprintf("%#v", this.NestedType)+",\n") + } + if this.EnumType != nil { + s = append(s, "EnumType: "+fmt.Sprintf("%#v", this.EnumType)+",\n") + } + if this.ExtensionRange != nil { + s = append(s, "ExtensionRange: "+fmt.Sprintf("%#v", this.ExtensionRange)+",\n") + } + if this.OneofDecl != nil { + s = append(s, "OneofDecl: "+fmt.Sprintf("%#v", this.OneofDecl)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.ReservedRange != nil { + s = append(s, "ReservedRange: "+fmt.Sprintf("%#v", this.ReservedRange)+",\n") + } + if this.ReservedName != nil { + s = append(s, "ReservedName: "+fmt.Sprintf("%#v", this.ReservedName)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DescriptorProto_ExtensionRange) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.DescriptorProto_ExtensionRange{") + if this.Start != nil { + s = append(s, "Start: "+valueToGoStringDescriptor(this.Start, "int32")+",\n") + } + if this.End != nil { + s = append(s, "End: "+valueToGoStringDescriptor(this.End, "int32")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DescriptorProto_ReservedRange) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.DescriptorProto_ReservedRange{") + if this.Start != nil { + s = append(s, "Start: "+valueToGoStringDescriptor(this.Start, "int32")+",\n") + } + if this.End != nil { + s = append(s, "End: "+valueToGoStringDescriptor(this.End, "int32")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FieldDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&descriptor.FieldDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Number != nil { + s = append(s, "Number: "+valueToGoStringDescriptor(this.Number, "int32")+",\n") + } + if this.Label != nil { + s = append(s, "Label: "+valueToGoStringDescriptor(this.Label, "descriptor.FieldDescriptorProto_Label")+",\n") + } + if this.Type != nil { + s = append(s, "Type: "+valueToGoStringDescriptor(this.Type, "descriptor.FieldDescriptorProto_Type")+",\n") + } + if this.TypeName != nil { + s = append(s, "TypeName: "+valueToGoStringDescriptor(this.TypeName, "string")+",\n") + } + if this.Extendee != nil { + s = append(s, "Extendee: "+valueToGoStringDescriptor(this.Extendee, "string")+",\n") + } + if this.DefaultValue != nil { + s = append(s, "DefaultValue: "+valueToGoStringDescriptor(this.DefaultValue, "string")+",\n") + } + if this.OneofIndex != nil { + s = append(s, "OneofIndex: "+valueToGoStringDescriptor(this.OneofIndex, "int32")+",\n") + } + if this.JsonName != nil { + s = append(s, "JsonName: "+valueToGoStringDescriptor(this.JsonName, "string")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OneofDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&descriptor.OneofDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&descriptor.EnumDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumValueDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&descriptor.EnumValueDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Number != nil { + s = append(s, "Number: "+valueToGoStringDescriptor(this.Number, "int32")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ServiceDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&descriptor.ServiceDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Method != nil { + s = append(s, "Method: "+fmt.Sprintf("%#v", this.Method)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MethodDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&descriptor.MethodDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.InputType != nil { + s = append(s, "InputType: "+valueToGoStringDescriptor(this.InputType, "string")+",\n") + } + if this.OutputType != nil { + s = append(s, "OutputType: "+valueToGoStringDescriptor(this.OutputType, "string")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.ClientStreaming != nil { + s = append(s, "ClientStreaming: "+valueToGoStringDescriptor(this.ClientStreaming, "bool")+",\n") + } + if this.ServerStreaming != nil { + s = append(s, "ServerStreaming: "+valueToGoStringDescriptor(this.ServerStreaming, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FileOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&descriptor.FileOptions{") + if this.JavaPackage != nil { + s = append(s, "JavaPackage: "+valueToGoStringDescriptor(this.JavaPackage, "string")+",\n") + } + if this.JavaOuterClassname != nil { + s = append(s, "JavaOuterClassname: "+valueToGoStringDescriptor(this.JavaOuterClassname, "string")+",\n") + } + if this.JavaMultipleFiles != nil { + s = append(s, "JavaMultipleFiles: "+valueToGoStringDescriptor(this.JavaMultipleFiles, "bool")+",\n") + } + if this.JavaGenerateEqualsAndHash != nil { + s = append(s, "JavaGenerateEqualsAndHash: "+valueToGoStringDescriptor(this.JavaGenerateEqualsAndHash, "bool")+",\n") + } + if this.JavaStringCheckUtf8 != nil { + s = append(s, "JavaStringCheckUtf8: "+valueToGoStringDescriptor(this.JavaStringCheckUtf8, "bool")+",\n") + } + if this.OptimizeFor != nil { + s = append(s, "OptimizeFor: "+valueToGoStringDescriptor(this.OptimizeFor, "descriptor.FileOptions_OptimizeMode")+",\n") + } + if this.GoPackage != nil { + s = append(s, "GoPackage: "+valueToGoStringDescriptor(this.GoPackage, "string")+",\n") + } + if this.CcGenericServices != nil { + s = append(s, "CcGenericServices: "+valueToGoStringDescriptor(this.CcGenericServices, "bool")+",\n") + } + if this.JavaGenericServices != nil { + s = append(s, "JavaGenericServices: "+valueToGoStringDescriptor(this.JavaGenericServices, "bool")+",\n") + } + if this.PyGenericServices != nil { + s = append(s, "PyGenericServices: "+valueToGoStringDescriptor(this.PyGenericServices, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.CcEnableArenas != nil { + s = append(s, "CcEnableArenas: "+valueToGoStringDescriptor(this.CcEnableArenas, "bool")+",\n") + } + if this.ObjcClassPrefix != nil { + s = append(s, "ObjcClassPrefix: "+valueToGoStringDescriptor(this.ObjcClassPrefix, "string")+",\n") + } + if this.CsharpNamespace != nil { + s = append(s, "CsharpNamespace: "+valueToGoStringDescriptor(this.CsharpNamespace, "string")+",\n") + } + if this.JavananoUseDeprecatedPackage != nil { + s = append(s, "JavananoUseDeprecatedPackage: "+valueToGoStringDescriptor(this.JavananoUseDeprecatedPackage, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MessageOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 9) + s = append(s, "&descriptor.MessageOptions{") + if this.MessageSetWireFormat != nil { + s = append(s, "MessageSetWireFormat: "+valueToGoStringDescriptor(this.MessageSetWireFormat, "bool")+",\n") + } + if this.NoStandardDescriptorAccessor != nil { + s = append(s, "NoStandardDescriptorAccessor: "+valueToGoStringDescriptor(this.NoStandardDescriptorAccessor, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.MapEntry != nil { + s = append(s, "MapEntry: "+valueToGoStringDescriptor(this.MapEntry, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FieldOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&descriptor.FieldOptions{") + if this.Ctype != nil { + s = append(s, "Ctype: "+valueToGoStringDescriptor(this.Ctype, "descriptor.FieldOptions_CType")+",\n") + } + if this.Packed != nil { + s = append(s, "Packed: "+valueToGoStringDescriptor(this.Packed, "bool")+",\n") + } + if this.Jstype != nil { + s = append(s, "Jstype: "+valueToGoStringDescriptor(this.Jstype, "descriptor.FieldOptions_JSType")+",\n") + } + if this.Lazy != nil { + s = append(s, "Lazy: "+valueToGoStringDescriptor(this.Lazy, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.Weak != nil { + s = append(s, "Weak: "+valueToGoStringDescriptor(this.Weak, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&descriptor.EnumOptions{") + if this.AllowAlias != nil { + s = append(s, "AllowAlias: "+valueToGoStringDescriptor(this.AllowAlias, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumValueOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.EnumValueOptions{") + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ServiceOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.ServiceOptions{") + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MethodOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.MethodOptions{") + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UninterpretedOption) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&descriptor.UninterpretedOption{") + if this.Name != nil { + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + } + if this.IdentifierValue != nil { + s = append(s, "IdentifierValue: "+valueToGoStringDescriptor(this.IdentifierValue, "string")+",\n") + } + if this.PositiveIntValue != nil { + s = append(s, "PositiveIntValue: "+valueToGoStringDescriptor(this.PositiveIntValue, "uint64")+",\n") + } + if this.NegativeIntValue != nil { + s = append(s, "NegativeIntValue: "+valueToGoStringDescriptor(this.NegativeIntValue, "int64")+",\n") + } + if this.DoubleValue != nil { + s = append(s, "DoubleValue: "+valueToGoStringDescriptor(this.DoubleValue, "float64")+",\n") + } + if this.StringValue != nil { + s = append(s, "StringValue: "+valueToGoStringDescriptor(this.StringValue, "byte")+",\n") + } + if this.AggregateValue != nil { + s = append(s, "AggregateValue: "+valueToGoStringDescriptor(this.AggregateValue, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UninterpretedOption_NamePart) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.UninterpretedOption_NamePart{") + if this.NamePart != nil { + s = append(s, "NamePart: "+valueToGoStringDescriptor(this.NamePart, "string")+",\n") + } + if this.IsExtension != nil { + s = append(s, "IsExtension: "+valueToGoStringDescriptor(this.IsExtension, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SourceCodeInfo) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&descriptor.SourceCodeInfo{") + if this.Location != nil { + s = append(s, "Location: "+fmt.Sprintf("%#v", this.Location)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SourceCodeInfo_Location) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 9) + s = append(s, "&descriptor.SourceCodeInfo_Location{") + if this.Path != nil { + s = append(s, "Path: "+fmt.Sprintf("%#v", this.Path)+",\n") + } + if this.Span != nil { + s = append(s, "Span: "+fmt.Sprintf("%#v", this.Span)+",\n") + } + if this.LeadingComments != nil { + s = append(s, "LeadingComments: "+valueToGoStringDescriptor(this.LeadingComments, "string")+",\n") + } + if this.TrailingComments != nil { + s = append(s, "TrailingComments: "+valueToGoStringDescriptor(this.TrailingComments, "string")+",\n") + } + if this.LeadingDetachedComments != nil { + s = append(s, "LeadingDetachedComments: "+fmt.Sprintf("%#v", this.LeadingDetachedComments)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringDescriptor(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringDescriptor(m github_com_gogo_protobuf_proto.Message) string { + e := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(m) + if e == nil { + return "nil" + } + s := "proto.NewUnsafeXXX_InternalExtensions(map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "})" + return s +} diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/helper.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/helper.go new file mode 100644 index 00000000..861f4d02 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/helper.go @@ -0,0 +1,357 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package descriptor + +import ( + "strings" +) + +func (msg *DescriptorProto) GetMapFields() (*FieldDescriptorProto, *FieldDescriptorProto) { + if !msg.GetOptions().GetMapEntry() { + return nil, nil + } + return msg.GetField()[0], msg.GetField()[1] +} + +func dotToUnderscore(r rune) rune { + if r == '.' { + return '_' + } + return r +} + +func (field *FieldDescriptorProto) WireType() (wire int) { + switch *field.Type { + case FieldDescriptorProto_TYPE_DOUBLE: + return 1 + case FieldDescriptorProto_TYPE_FLOAT: + return 5 + case FieldDescriptorProto_TYPE_INT64: + return 0 + case FieldDescriptorProto_TYPE_UINT64: + return 0 + case FieldDescriptorProto_TYPE_INT32: + return 0 + case FieldDescriptorProto_TYPE_UINT32: + return 0 + case FieldDescriptorProto_TYPE_FIXED64: + return 1 + case FieldDescriptorProto_TYPE_FIXED32: + return 5 + case FieldDescriptorProto_TYPE_BOOL: + return 0 + case FieldDescriptorProto_TYPE_STRING: + return 2 + case FieldDescriptorProto_TYPE_GROUP: + return 2 + case FieldDescriptorProto_TYPE_MESSAGE: + return 2 + case FieldDescriptorProto_TYPE_BYTES: + return 2 + case FieldDescriptorProto_TYPE_ENUM: + return 0 + case FieldDescriptorProto_TYPE_SFIXED32: + return 5 + case FieldDescriptorProto_TYPE_SFIXED64: + return 1 + case FieldDescriptorProto_TYPE_SINT32: + return 0 + case FieldDescriptorProto_TYPE_SINT64: + return 0 + } + panic("unreachable") +} + +func (field *FieldDescriptorProto) GetKeyUint64() (x uint64) { + packed := field.IsPacked() + wireType := field.WireType() + fieldNumber := field.GetNumber() + if packed { + wireType = 2 + } + x = uint64(uint32(fieldNumber)<<3 | uint32(wireType)) + return x +} + +func (field *FieldDescriptorProto) GetKey() []byte { + x := field.GetKeyUint64() + i := 0 + keybuf := make([]byte, 0) + for i = 0; x > 127; i++ { + keybuf = append(keybuf, 0x80|uint8(x&0x7F)) + x >>= 7 + } + keybuf = append(keybuf, uint8(x)) + return keybuf +} + +func (desc *FileDescriptorSet) GetField(packageName, messageName, fieldName string) *FieldDescriptorProto { + msg := desc.GetMessage(packageName, messageName) + if msg == nil { + return nil + } + for _, field := range msg.GetField() { + if field.GetName() == fieldName { + return field + } + } + return nil +} + +func (file *FileDescriptorProto) GetMessage(typeName string) *DescriptorProto { + for _, msg := range file.GetMessageType() { + if msg.GetName() == typeName { + return msg + } + nes := file.GetNestedMessage(msg, strings.TrimPrefix(typeName, msg.GetName()+".")) + if nes != nil { + return nes + } + } + return nil +} + +func (file *FileDescriptorProto) GetNestedMessage(msg *DescriptorProto, typeName string) *DescriptorProto { + for _, nes := range msg.GetNestedType() { + if nes.GetName() == typeName { + return nes + } + res := file.GetNestedMessage(nes, strings.TrimPrefix(typeName, nes.GetName()+".")) + if res != nil { + return res + } + } + return nil +} + +func (desc *FileDescriptorSet) GetMessage(packageName string, typeName string) *DescriptorProto { + for _, file := range desc.GetFile() { + if strings.Map(dotToUnderscore, file.GetPackage()) != strings.Map(dotToUnderscore, packageName) { + continue + } + for _, msg := range file.GetMessageType() { + if msg.GetName() == typeName { + return msg + } + } + for _, msg := range file.GetMessageType() { + for _, nes := range msg.GetNestedType() { + if nes.GetName() == typeName { + return nes + } + if msg.GetName()+"."+nes.GetName() == typeName { + return nes + } + } + } + } + return nil +} + +func (desc *FileDescriptorSet) IsProto3(packageName string, typeName string) bool { + for _, file := range desc.GetFile() { + if strings.Map(dotToUnderscore, file.GetPackage()) != strings.Map(dotToUnderscore, packageName) { + continue + } + for _, msg := range file.GetMessageType() { + if msg.GetName() == typeName { + return file.GetSyntax() == "proto3" + } + } + for _, msg := range file.GetMessageType() { + for _, nes := range msg.GetNestedType() { + if nes.GetName() == typeName { + return file.GetSyntax() == "proto3" + } + if msg.GetName()+"."+nes.GetName() == typeName { + return file.GetSyntax() == "proto3" + } + } + } + } + return false +} + +func (msg *DescriptorProto) IsExtendable() bool { + return len(msg.GetExtensionRange()) > 0 +} + +func (desc *FileDescriptorSet) FindExtension(packageName string, typeName string, fieldName string) (extPackageName string, field *FieldDescriptorProto) { + parent := desc.GetMessage(packageName, typeName) + if parent == nil { + return "", nil + } + if !parent.IsExtendable() { + return "", nil + } + extendee := "." + packageName + "." + typeName + for _, file := range desc.GetFile() { + for _, ext := range file.GetExtension() { + if strings.Map(dotToUnderscore, file.GetPackage()) == strings.Map(dotToUnderscore, packageName) { + if !(ext.GetExtendee() == typeName || ext.GetExtendee() == extendee) { + continue + } + } else { + if ext.GetExtendee() != extendee { + continue + } + } + if ext.GetName() == fieldName { + return file.GetPackage(), ext + } + } + } + return "", nil +} + +func (desc *FileDescriptorSet) FindExtensionByFieldNumber(packageName string, typeName string, fieldNum int32) (extPackageName string, field *FieldDescriptorProto) { + parent := desc.GetMessage(packageName, typeName) + if parent == nil { + return "", nil + } + if !parent.IsExtendable() { + return "", nil + } + extendee := "." + packageName + "." + typeName + for _, file := range desc.GetFile() { + for _, ext := range file.GetExtension() { + if strings.Map(dotToUnderscore, file.GetPackage()) == strings.Map(dotToUnderscore, packageName) { + if !(ext.GetExtendee() == typeName || ext.GetExtendee() == extendee) { + continue + } + } else { + if ext.GetExtendee() != extendee { + continue + } + } + if ext.GetNumber() == fieldNum { + return file.GetPackage(), ext + } + } + } + return "", nil +} + +func (desc *FileDescriptorSet) FindMessage(packageName string, typeName string, fieldName string) (msgPackageName string, msgName string) { + parent := desc.GetMessage(packageName, typeName) + if parent == nil { + return "", "" + } + field := parent.GetFieldDescriptor(fieldName) + if field == nil { + var extPackageName string + extPackageName, field = desc.FindExtension(packageName, typeName, fieldName) + if field == nil { + return "", "" + } + packageName = extPackageName + } + typeNames := strings.Split(field.GetTypeName(), ".") + if len(typeNames) == 1 { + msg := desc.GetMessage(packageName, typeName) + if msg == nil { + return "", "" + } + return packageName, msg.GetName() + } + if len(typeNames) > 2 { + for i := 1; i < len(typeNames)-1; i++ { + packageName = strings.Join(typeNames[1:len(typeNames)-i], ".") + typeName = strings.Join(typeNames[len(typeNames)-i:], ".") + msg := desc.GetMessage(packageName, typeName) + if msg != nil { + typeNames := strings.Split(msg.GetName(), ".") + if len(typeNames) == 1 { + return packageName, msg.GetName() + } + return strings.Join(typeNames[1:len(typeNames)-1], "."), typeNames[len(typeNames)-1] + } + } + } + return "", "" +} + +func (msg *DescriptorProto) GetFieldDescriptor(fieldName string) *FieldDescriptorProto { + for _, field := range msg.GetField() { + if field.GetName() == fieldName { + return field + } + } + return nil +} + +func (desc *FileDescriptorSet) GetEnum(packageName string, typeName string) *EnumDescriptorProto { + for _, file := range desc.GetFile() { + if strings.Map(dotToUnderscore, file.GetPackage()) != strings.Map(dotToUnderscore, packageName) { + continue + } + for _, enum := range file.GetEnumType() { + if enum.GetName() == typeName { + return enum + } + } + } + return nil +} + +func (f *FieldDescriptorProto) IsEnum() bool { + return *f.Type == FieldDescriptorProto_TYPE_ENUM +} + +func (f *FieldDescriptorProto) IsMessage() bool { + return *f.Type == FieldDescriptorProto_TYPE_MESSAGE +} + +func (f *FieldDescriptorProto) IsBytes() bool { + return *f.Type == FieldDescriptorProto_TYPE_BYTES +} + +func (f *FieldDescriptorProto) IsRepeated() bool { + return f.Label != nil && *f.Label == FieldDescriptorProto_LABEL_REPEATED +} + +func (f *FieldDescriptorProto) IsString() bool { + return *f.Type == FieldDescriptorProto_TYPE_STRING +} + +func (f *FieldDescriptorProto) IsBool() bool { + return *f.Type == FieldDescriptorProto_TYPE_BOOL +} + +func (f *FieldDescriptorProto) IsRequired() bool { + return f.Label != nil && *f.Label == FieldDescriptorProto_LABEL_REQUIRED +} + +func (f *FieldDescriptorProto) IsPacked() bool { + return f.Options != nil && f.GetOptions().GetPacked() +} + +func (m *DescriptorProto) HasExtension() bool { + return len(m.ExtensionRange) > 0 +} diff --git a/vendor/github.com/golang/freetype/LICENSE b/vendor/github.com/golang/freetype/LICENSE new file mode 100644 index 00000000..e854ba5d --- /dev/null +++ b/vendor/github.com/golang/freetype/LICENSE @@ -0,0 +1,12 @@ +Use of the Freetype-Go software is subject to your choice of exactly one of +the following two licenses: + * The FreeType License, which is similar to the original BSD license with + an advertising clause, or + * The GNU General Public License (GPL), version 2 or later. + +The text of these licenses are available in the licenses/ftl.txt and the +licenses/gpl.txt files respectively. They are also available at +http://freetype.sourceforge.net/license.html + +The Luxi fonts in the testdata directory are licensed separately. See the +testdata/COPYING file for details. diff --git a/vendor/github.com/golang/freetype/freetype.go b/vendor/github.com/golang/freetype/freetype.go new file mode 100644 index 00000000..96035866 --- /dev/null +++ b/vendor/github.com/golang/freetype/freetype.go @@ -0,0 +1,341 @@ +// Copyright 2010 The Freetype-Go Authors. All rights reserved. +// Use of this source code is governed by your choice of either the +// FreeType License or the GNU General Public License version 2 (or +// any later version), both of which can be found in the LICENSE file. + +// The freetype package provides a convenient API to draw text onto an image. +// Use the freetype/raster and freetype/truetype packages for lower level +// control over rasterization and TrueType parsing. +package freetype // import "github.com/golang/freetype" + +import ( + "errors" + "image" + "image/draw" + + "github.com/golang/freetype/raster" + "github.com/golang/freetype/truetype" + "golang.org/x/image/font" + "golang.org/x/image/math/fixed" +) + +// These constants determine the size of the glyph cache. The cache is keyed +// primarily by the glyph index modulo nGlyphs, and secondarily by sub-pixel +// position for the mask image. Sub-pixel positions are quantized to +// nXFractions possible values in both the x and y directions. +const ( + nGlyphs = 256 + nXFractions = 4 + nYFractions = 1 +) + +// An entry in the glyph cache is keyed explicitly by the glyph index and +// implicitly by the quantized x and y fractional offset. It maps to a mask +// image and an offset. +type cacheEntry struct { + valid bool + glyph truetype.Index + advanceWidth fixed.Int26_6 + mask *image.Alpha + offset image.Point +} + +// ParseFont just calls the Parse function from the freetype/truetype package. +// It is provided here so that code that imports this package doesn't need +// to also include the freetype/truetype package. +func ParseFont(b []byte) (*truetype.Font, error) { + return truetype.Parse(b) +} + +// Pt converts from a co-ordinate pair measured in pixels to a fixed.Point26_6 +// co-ordinate pair measured in fixed.Int26_6 units. +func Pt(x, y int) fixed.Point26_6 { + return fixed.Point26_6{ + X: fixed.Int26_6(x << 6), + Y: fixed.Int26_6(y << 6), + } +} + +// A Context holds the state for drawing text in a given font and size. +type Context struct { + r *raster.Rasterizer + f *truetype.Font + glyphBuf truetype.GlyphBuf + // clip is the clip rectangle for drawing. + clip image.Rectangle + // dst and src are the destination and source images for drawing. + dst draw.Image + src image.Image + // fontSize and dpi are used to calculate scale. scale is the number of + // 26.6 fixed point units in 1 em. hinting is the hinting policy. + fontSize, dpi float64 + scale fixed.Int26_6 + hinting font.Hinting + // cache is the glyph cache. + cache [nGlyphs * nXFractions * nYFractions]cacheEntry +} + +// PointToFixed converts the given number of points (as in "a 12 point font") +// into a 26.6 fixed point number of pixels. +func (c *Context) PointToFixed(x float64) fixed.Int26_6 { + return fixed.Int26_6(x * float64(c.dpi) * (64.0 / 72.0)) +} + +// drawContour draws the given closed contour with the given offset. +func (c *Context) drawContour(ps []truetype.Point, dx, dy fixed.Int26_6) { + if len(ps) == 0 { + return + } + + // The low bit of each point's Flags value is whether the point is on the + // curve. Truetype fonts only have quadratic Bézier curves, not cubics. + // Thus, two consecutive off-curve points imply an on-curve point in the + // middle of those two. + // + // See http://chanae.walon.org/pub/ttf/ttf_glyphs.htm for more details. + + // ps[0] is a truetype.Point measured in FUnits and positive Y going + // upwards. start is the same thing measured in fixed point units and + // positive Y going downwards, and offset by (dx, dy). + start := fixed.Point26_6{ + X: dx + ps[0].X, + Y: dy - ps[0].Y, + } + others := []truetype.Point(nil) + if ps[0].Flags&0x01 != 0 { + others = ps[1:] + } else { + last := fixed.Point26_6{ + X: dx + ps[len(ps)-1].X, + Y: dy - ps[len(ps)-1].Y, + } + if ps[len(ps)-1].Flags&0x01 != 0 { + start = last + others = ps[:len(ps)-1] + } else { + start = fixed.Point26_6{ + X: (start.X + last.X) / 2, + Y: (start.Y + last.Y) / 2, + } + others = ps + } + } + c.r.Start(start) + q0, on0 := start, true + for _, p := range others { + q := fixed.Point26_6{ + X: dx + p.X, + Y: dy - p.Y, + } + on := p.Flags&0x01 != 0 + if on { + if on0 { + c.r.Add1(q) + } else { + c.r.Add2(q0, q) + } + } else { + if on0 { + // No-op. + } else { + mid := fixed.Point26_6{ + X: (q0.X + q.X) / 2, + Y: (q0.Y + q.Y) / 2, + } + c.r.Add2(q0, mid) + } + } + q0, on0 = q, on + } + // Close the curve. + if on0 { + c.r.Add1(start) + } else { + c.r.Add2(q0, start) + } +} + +// rasterize returns the advance width, glyph mask and integer-pixel offset +// to render the given glyph at the given sub-pixel offsets. +// The 26.6 fixed point arguments fx and fy must be in the range [0, 1). +func (c *Context) rasterize(glyph truetype.Index, fx, fy fixed.Int26_6) ( + fixed.Int26_6, *image.Alpha, image.Point, error) { + + if err := c.glyphBuf.Load(c.f, c.scale, glyph, c.hinting); err != nil { + return 0, nil, image.Point{}, err + } + // Calculate the integer-pixel bounds for the glyph. + xmin := int(fx+c.glyphBuf.Bounds.Min.X) >> 6 + ymin := int(fy-c.glyphBuf.Bounds.Max.Y) >> 6 + xmax := int(fx+c.glyphBuf.Bounds.Max.X+0x3f) >> 6 + ymax := int(fy-c.glyphBuf.Bounds.Min.Y+0x3f) >> 6 + if xmin > xmax || ymin > ymax { + return 0, nil, image.Point{}, errors.New("freetype: negative sized glyph") + } + // A TrueType's glyph's nodes can have negative co-ordinates, but the + // rasterizer clips anything left of x=0 or above y=0. xmin and ymin are + // the pixel offsets, based on the font's FUnit metrics, that let a + // negative co-ordinate in TrueType space be non-negative in rasterizer + // space. xmin and ymin are typically <= 0. + fx -= fixed.Int26_6(xmin << 6) + fy -= fixed.Int26_6(ymin << 6) + // Rasterize the glyph's vectors. + c.r.Clear() + e0 := 0 + for _, e1 := range c.glyphBuf.Ends { + c.drawContour(c.glyphBuf.Points[e0:e1], fx, fy) + e0 = e1 + } + a := image.NewAlpha(image.Rect(0, 0, xmax-xmin, ymax-ymin)) + c.r.Rasterize(raster.NewAlphaSrcPainter(a)) + return c.glyphBuf.AdvanceWidth, a, image.Point{xmin, ymin}, nil +} + +// glyph returns the advance width, glyph mask and integer-pixel offset to +// render the given glyph at the given sub-pixel point. It is a cache for the +// rasterize method. Unlike rasterize, p's co-ordinates do not have to be in +// the range [0, 1). +func (c *Context) glyph(glyph truetype.Index, p fixed.Point26_6) ( + fixed.Int26_6, *image.Alpha, image.Point, error) { + + // Split p.X and p.Y into their integer and fractional parts. + ix, fx := int(p.X>>6), p.X&0x3f + iy, fy := int(p.Y>>6), p.Y&0x3f + // Calculate the index t into the cache array. + tg := int(glyph) % nGlyphs + tx := int(fx) / (64 / nXFractions) + ty := int(fy) / (64 / nYFractions) + t := ((tg*nXFractions)+tx)*nYFractions + ty + // Check for a cache hit. + if e := c.cache[t]; e.valid && e.glyph == glyph { + return e.advanceWidth, e.mask, e.offset.Add(image.Point{ix, iy}), nil + } + // Rasterize the glyph and put the result into the cache. + advanceWidth, mask, offset, err := c.rasterize(glyph, fx, fy) + if err != nil { + return 0, nil, image.Point{}, err + } + c.cache[t] = cacheEntry{true, glyph, advanceWidth, mask, offset} + return advanceWidth, mask, offset.Add(image.Point{ix, iy}), nil +} + +// DrawString draws s at p and returns p advanced by the text extent. The text +// is placed so that the left edge of the em square of the first character of s +// and the baseline intersect at p. The majority of the affected pixels will be +// above and to the right of the point, but some may be below or to the left. +// For example, drawing a string that starts with a 'J' in an italic font may +// affect pixels below and left of the point. +// +// p is a fixed.Point26_6 and can therefore represent sub-pixel positions. +func (c *Context) DrawString(s string, p fixed.Point26_6) (fixed.Point26_6, error) { + if c.f == nil { + return fixed.Point26_6{}, errors.New("freetype: DrawText called with a nil font") + } + prev, hasPrev := truetype.Index(0), false + for _, rune := range s { + index := c.f.Index(rune) + if hasPrev { + kern := c.f.Kern(c.scale, prev, index) + if c.hinting != font.HintingNone { + kern = (kern + 32) &^ 63 + } + p.X += kern + } + advanceWidth, mask, offset, err := c.glyph(index, p) + if err != nil { + return fixed.Point26_6{}, err + } + p.X += advanceWidth + glyphRect := mask.Bounds().Add(offset) + dr := c.clip.Intersect(glyphRect) + if !dr.Empty() { + mp := image.Point{0, dr.Min.Y - glyphRect.Min.Y} + draw.DrawMask(c.dst, dr, c.src, image.ZP, mask, mp, draw.Over) + } + prev, hasPrev = index, true + } + return p, nil +} + +// recalc recalculates scale and bounds values from the font size, screen +// resolution and font metrics, and invalidates the glyph cache. +func (c *Context) recalc() { + c.scale = fixed.Int26_6(c.fontSize * c.dpi * (64.0 / 72.0)) + if c.f == nil { + c.r.SetBounds(0, 0) + } else { + // Set the rasterizer's bounds to be big enough to handle the largest glyph. + b := c.f.Bounds(c.scale) + xmin := +int(b.Min.X) >> 6 + ymin := -int(b.Max.Y) >> 6 + xmax := +int(b.Max.X+63) >> 6 + ymax := -int(b.Min.Y-63) >> 6 + c.r.SetBounds(xmax-xmin, ymax-ymin) + } + for i := range c.cache { + c.cache[i] = cacheEntry{} + } +} + +// SetDPI sets the screen resolution in dots per inch. +func (c *Context) SetDPI(dpi float64) { + if c.dpi == dpi { + return + } + c.dpi = dpi + c.recalc() +} + +// SetFont sets the font used to draw text. +func (c *Context) SetFont(f *truetype.Font) { + if c.f == f { + return + } + c.f = f + c.recalc() +} + +// SetFontSize sets the font size in points (as in "a 12 point font"). +func (c *Context) SetFontSize(fontSize float64) { + if c.fontSize == fontSize { + return + } + c.fontSize = fontSize + c.recalc() +} + +// SetHinting sets the hinting policy. +func (c *Context) SetHinting(hinting font.Hinting) { + c.hinting = hinting + for i := range c.cache { + c.cache[i] = cacheEntry{} + } +} + +// SetDst sets the destination image for draw operations. +func (c *Context) SetDst(dst draw.Image) { + c.dst = dst +} + +// SetSrc sets the source image for draw operations. This is typically an +// image.Uniform. +func (c *Context) SetSrc(src image.Image) { + c.src = src +} + +// SetClip sets the clip rectangle for drawing. +func (c *Context) SetClip(clip image.Rectangle) { + c.clip = clip +} + +// TODO(nigeltao): implement Context.SetGamma. + +// NewContext creates a new Context. +func NewContext() *Context { + return &Context{ + r: raster.NewRasterizer(0, 0), + fontSize: 12, + dpi: 72, + scale: 12 << 6, + } +} diff --git a/vendor/github.com/golang/freetype/raster/geom.go b/vendor/github.com/golang/freetype/raster/geom.go new file mode 100644 index 00000000..f3696ea9 --- /dev/null +++ b/vendor/github.com/golang/freetype/raster/geom.go @@ -0,0 +1,245 @@ +// Copyright 2010 The Freetype-Go Authors. All rights reserved. +// Use of this source code is governed by your choice of either the +// FreeType License or the GNU General Public License version 2 (or +// any later version), both of which can be found in the LICENSE file. + +package raster + +import ( + "fmt" + "math" + + "golang.org/x/image/math/fixed" +) + +// maxAbs returns the maximum of abs(a) and abs(b). +func maxAbs(a, b fixed.Int26_6) fixed.Int26_6 { + if a < 0 { + a = -a + } + if b < 0 { + b = -b + } + if a < b { + return b + } + return a +} + +// pNeg returns the vector -p, or equivalently p rotated by 180 degrees. +func pNeg(p fixed.Point26_6) fixed.Point26_6 { + return fixed.Point26_6{-p.X, -p.Y} +} + +// pDot returns the dot product p·q. +func pDot(p fixed.Point26_6, q fixed.Point26_6) fixed.Int52_12 { + px, py := int64(p.X), int64(p.Y) + qx, qy := int64(q.X), int64(q.Y) + return fixed.Int52_12(px*qx + py*qy) +} + +// pLen returns the length of the vector p. +func pLen(p fixed.Point26_6) fixed.Int26_6 { + // TODO(nigeltao): use fixed point math. + x := float64(p.X) + y := float64(p.Y) + return fixed.Int26_6(math.Sqrt(x*x + y*y)) +} + +// pNorm returns the vector p normalized to the given length, or zero if p is +// degenerate. +func pNorm(p fixed.Point26_6, length fixed.Int26_6) fixed.Point26_6 { + d := pLen(p) + if d == 0 { + return fixed.Point26_6{} + } + s, t := int64(length), int64(d) + x := int64(p.X) * s / t + y := int64(p.Y) * s / t + return fixed.Point26_6{fixed.Int26_6(x), fixed.Int26_6(y)} +} + +// pRot45CW returns the vector p rotated clockwise by 45 degrees. +// +// Note that the Y-axis grows downwards, so {1, 0}.Rot45CW is {1/√2, 1/√2}. +func pRot45CW(p fixed.Point26_6) fixed.Point26_6 { + // 181/256 is approximately 1/√2, or sin(π/4). + px, py := int64(p.X), int64(p.Y) + qx := (+px - py) * 181 / 256 + qy := (+px + py) * 181 / 256 + return fixed.Point26_6{fixed.Int26_6(qx), fixed.Int26_6(qy)} +} + +// pRot90CW returns the vector p rotated clockwise by 90 degrees. +// +// Note that the Y-axis grows downwards, so {1, 0}.Rot90CW is {0, 1}. +func pRot90CW(p fixed.Point26_6) fixed.Point26_6 { + return fixed.Point26_6{-p.Y, p.X} +} + +// pRot135CW returns the vector p rotated clockwise by 135 degrees. +// +// Note that the Y-axis grows downwards, so {1, 0}.Rot135CW is {-1/√2, 1/√2}. +func pRot135CW(p fixed.Point26_6) fixed.Point26_6 { + // 181/256 is approximately 1/√2, or sin(π/4). + px, py := int64(p.X), int64(p.Y) + qx := (-px - py) * 181 / 256 + qy := (+px - py) * 181 / 256 + return fixed.Point26_6{fixed.Int26_6(qx), fixed.Int26_6(qy)} +} + +// pRot45CCW returns the vector p rotated counter-clockwise by 45 degrees. +// +// Note that the Y-axis grows downwards, so {1, 0}.Rot45CCW is {1/√2, -1/√2}. +func pRot45CCW(p fixed.Point26_6) fixed.Point26_6 { + // 181/256 is approximately 1/√2, or sin(π/4). + px, py := int64(p.X), int64(p.Y) + qx := (+px + py) * 181 / 256 + qy := (-px + py) * 181 / 256 + return fixed.Point26_6{fixed.Int26_6(qx), fixed.Int26_6(qy)} +} + +// pRot90CCW returns the vector p rotated counter-clockwise by 90 degrees. +// +// Note that the Y-axis grows downwards, so {1, 0}.Rot90CCW is {0, -1}. +func pRot90CCW(p fixed.Point26_6) fixed.Point26_6 { + return fixed.Point26_6{p.Y, -p.X} +} + +// pRot135CCW returns the vector p rotated counter-clockwise by 135 degrees. +// +// Note that the Y-axis grows downwards, so {1, 0}.Rot135CCW is {-1/√2, -1/√2}. +func pRot135CCW(p fixed.Point26_6) fixed.Point26_6 { + // 181/256 is approximately 1/√2, or sin(π/4). + px, py := int64(p.X), int64(p.Y) + qx := (-px + py) * 181 / 256 + qy := (-px - py) * 181 / 256 + return fixed.Point26_6{fixed.Int26_6(qx), fixed.Int26_6(qy)} +} + +// An Adder accumulates points on a curve. +type Adder interface { + // Start starts a new curve at the given point. + Start(a fixed.Point26_6) + // Add1 adds a linear segment to the current curve. + Add1(b fixed.Point26_6) + // Add2 adds a quadratic segment to the current curve. + Add2(b, c fixed.Point26_6) + // Add3 adds a cubic segment to the current curve. + Add3(b, c, d fixed.Point26_6) +} + +// A Path is a sequence of curves, and a curve is a start point followed by a +// sequence of linear, quadratic or cubic segments. +type Path []fixed.Int26_6 + +// String returns a human-readable representation of a Path. +func (p Path) String() string { + s := "" + for i := 0; i < len(p); { + if i != 0 { + s += " " + } + switch p[i] { + case 0: + s += "S0" + fmt.Sprint([]fixed.Int26_6(p[i+1:i+3])) + i += 4 + case 1: + s += "A1" + fmt.Sprint([]fixed.Int26_6(p[i+1:i+3])) + i += 4 + case 2: + s += "A2" + fmt.Sprint([]fixed.Int26_6(p[i+1:i+5])) + i += 6 + case 3: + s += "A3" + fmt.Sprint([]fixed.Int26_6(p[i+1:i+7])) + i += 8 + default: + panic("freetype/raster: bad path") + } + } + return s +} + +// Clear cancels any previous calls to p.Start or p.AddXxx. +func (p *Path) Clear() { + *p = (*p)[:0] +} + +// Start starts a new curve at the given point. +func (p *Path) Start(a fixed.Point26_6) { + *p = append(*p, 0, a.X, a.Y, 0) +} + +// Add1 adds a linear segment to the current curve. +func (p *Path) Add1(b fixed.Point26_6) { + *p = append(*p, 1, b.X, b.Y, 1) +} + +// Add2 adds a quadratic segment to the current curve. +func (p *Path) Add2(b, c fixed.Point26_6) { + *p = append(*p, 2, b.X, b.Y, c.X, c.Y, 2) +} + +// Add3 adds a cubic segment to the current curve. +func (p *Path) Add3(b, c, d fixed.Point26_6) { + *p = append(*p, 3, b.X, b.Y, c.X, c.Y, d.X, d.Y, 3) +} + +// AddPath adds the Path q to p. +func (p *Path) AddPath(q Path) { + *p = append(*p, q...) +} + +// AddStroke adds a stroked Path. +func (p *Path) AddStroke(q Path, width fixed.Int26_6, cr Capper, jr Joiner) { + Stroke(p, q, width, cr, jr) +} + +// firstPoint returns the first point in a non-empty Path. +func (p Path) firstPoint() fixed.Point26_6 { + return fixed.Point26_6{p[1], p[2]} +} + +// lastPoint returns the last point in a non-empty Path. +func (p Path) lastPoint() fixed.Point26_6 { + return fixed.Point26_6{p[len(p)-3], p[len(p)-2]} +} + +// addPathReversed adds q reversed to p. +// For example, if q consists of a linear segment from A to B followed by a +// quadratic segment from B to C to D, then the values of q looks like: +// index: 01234567890123 +// value: 0AA01BB12CCDD2 +// So, when adding q backwards to p, we want to Add2(C, B) followed by Add1(A). +func addPathReversed(p Adder, q Path) { + if len(q) == 0 { + return + } + i := len(q) - 1 + for { + switch q[i] { + case 0: + return + case 1: + i -= 4 + p.Add1( + fixed.Point26_6{q[i-2], q[i-1]}, + ) + case 2: + i -= 6 + p.Add2( + fixed.Point26_6{q[i+2], q[i+3]}, + fixed.Point26_6{q[i-2], q[i-1]}, + ) + case 3: + i -= 8 + p.Add3( + fixed.Point26_6{q[i+4], q[i+5]}, + fixed.Point26_6{q[i+2], q[i+3]}, + fixed.Point26_6{q[i-2], q[i-1]}, + ) + default: + panic("freetype/raster: bad path") + } + } +} diff --git a/vendor/github.com/golang/freetype/raster/paint.go b/vendor/github.com/golang/freetype/raster/paint.go new file mode 100644 index 00000000..652256cc --- /dev/null +++ b/vendor/github.com/golang/freetype/raster/paint.go @@ -0,0 +1,287 @@ +// Copyright 2010 The Freetype-Go Authors. All rights reserved. +// Use of this source code is governed by your choice of either the +// FreeType License or the GNU General Public License version 2 (or +// any later version), both of which can be found in the LICENSE file. + +package raster + +import ( + "image" + "image/color" + "image/draw" + "math" +) + +// A Span is a horizontal segment of pixels with constant alpha. X0 is an +// inclusive bound and X1 is exclusive, the same as for slices. A fully opaque +// Span has Alpha == 0xffff. +type Span struct { + Y, X0, X1 int + Alpha uint32 +} + +// A Painter knows how to paint a batch of Spans. Rasterization may involve +// Painting multiple batches, and done will be true for the final batch. The +// Spans' Y values are monotonically increasing during a rasterization. Paint +// may use all of ss as scratch space during the call. +type Painter interface { + Paint(ss []Span, done bool) +} + +// The PainterFunc type adapts an ordinary function to the Painter interface. +type PainterFunc func(ss []Span, done bool) + +// Paint just delegates the call to f. +func (f PainterFunc) Paint(ss []Span, done bool) { f(ss, done) } + +// An AlphaOverPainter is a Painter that paints Spans onto a *image.Alpha using +// the Over Porter-Duff composition operator. +type AlphaOverPainter struct { + Image *image.Alpha +} + +// Paint satisfies the Painter interface. +func (r AlphaOverPainter) Paint(ss []Span, done bool) { + b := r.Image.Bounds() + for _, s := range ss { + if s.Y < b.Min.Y { + continue + } + if s.Y >= b.Max.Y { + return + } + if s.X0 < b.Min.X { + s.X0 = b.Min.X + } + if s.X1 > b.Max.X { + s.X1 = b.Max.X + } + if s.X0 >= s.X1 { + continue + } + base := (s.Y-r.Image.Rect.Min.Y)*r.Image.Stride - r.Image.Rect.Min.X + p := r.Image.Pix[base+s.X0 : base+s.X1] + a := int(s.Alpha >> 8) + for i, c := range p { + v := int(c) + p[i] = uint8((v*255 + (255-v)*a) / 255) + } + } +} + +// NewAlphaOverPainter creates a new AlphaOverPainter for the given image. +func NewAlphaOverPainter(m *image.Alpha) AlphaOverPainter { + return AlphaOverPainter{m} +} + +// An AlphaSrcPainter is a Painter that paints Spans onto a *image.Alpha using +// the Src Porter-Duff composition operator. +type AlphaSrcPainter struct { + Image *image.Alpha +} + +// Paint satisfies the Painter interface. +func (r AlphaSrcPainter) Paint(ss []Span, done bool) { + b := r.Image.Bounds() + for _, s := range ss { + if s.Y < b.Min.Y { + continue + } + if s.Y >= b.Max.Y { + return + } + if s.X0 < b.Min.X { + s.X0 = b.Min.X + } + if s.X1 > b.Max.X { + s.X1 = b.Max.X + } + if s.X0 >= s.X1 { + continue + } + base := (s.Y-r.Image.Rect.Min.Y)*r.Image.Stride - r.Image.Rect.Min.X + p := r.Image.Pix[base+s.X0 : base+s.X1] + color := uint8(s.Alpha >> 8) + for i := range p { + p[i] = color + } + } +} + +// NewAlphaSrcPainter creates a new AlphaSrcPainter for the given image. +func NewAlphaSrcPainter(m *image.Alpha) AlphaSrcPainter { + return AlphaSrcPainter{m} +} + +// An RGBAPainter is a Painter that paints Spans onto a *image.RGBA. +type RGBAPainter struct { + // Image is the image to compose onto. + Image *image.RGBA + // Op is the Porter-Duff composition operator. + Op draw.Op + // cr, cg, cb and ca are the 16-bit color to paint the spans. + cr, cg, cb, ca uint32 +} + +// Paint satisfies the Painter interface. +func (r *RGBAPainter) Paint(ss []Span, done bool) { + b := r.Image.Bounds() + for _, s := range ss { + if s.Y < b.Min.Y { + continue + } + if s.Y >= b.Max.Y { + return + } + if s.X0 < b.Min.X { + s.X0 = b.Min.X + } + if s.X1 > b.Max.X { + s.X1 = b.Max.X + } + if s.X0 >= s.X1 { + continue + } + // This code mimics drawGlyphOver in $GOROOT/src/image/draw/draw.go. + ma := s.Alpha + const m = 1<<16 - 1 + i0 := (s.Y-r.Image.Rect.Min.Y)*r.Image.Stride + (s.X0-r.Image.Rect.Min.X)*4 + i1 := i0 + (s.X1-s.X0)*4 + if r.Op == draw.Over { + for i := i0; i < i1; i += 4 { + dr := uint32(r.Image.Pix[i+0]) + dg := uint32(r.Image.Pix[i+1]) + db := uint32(r.Image.Pix[i+2]) + da := uint32(r.Image.Pix[i+3]) + a := (m - (r.ca * ma / m)) * 0x101 + r.Image.Pix[i+0] = uint8((dr*a + r.cr*ma) / m >> 8) + r.Image.Pix[i+1] = uint8((dg*a + r.cg*ma) / m >> 8) + r.Image.Pix[i+2] = uint8((db*a + r.cb*ma) / m >> 8) + r.Image.Pix[i+3] = uint8((da*a + r.ca*ma) / m >> 8) + } + } else { + for i := i0; i < i1; i += 4 { + r.Image.Pix[i+0] = uint8(r.cr * ma / m >> 8) + r.Image.Pix[i+1] = uint8(r.cg * ma / m >> 8) + r.Image.Pix[i+2] = uint8(r.cb * ma / m >> 8) + r.Image.Pix[i+3] = uint8(r.ca * ma / m >> 8) + } + } + } +} + +// SetColor sets the color to paint the spans. +func (r *RGBAPainter) SetColor(c color.Color) { + r.cr, r.cg, r.cb, r.ca = c.RGBA() +} + +// NewRGBAPainter creates a new RGBAPainter for the given image. +func NewRGBAPainter(m *image.RGBA) *RGBAPainter { + return &RGBAPainter{Image: m} +} + +// A MonochromePainter wraps another Painter, quantizing each Span's alpha to +// be either fully opaque or fully transparent. +type MonochromePainter struct { + Painter Painter + y, x0, x1 int +} + +// Paint delegates to the wrapped Painter after quantizing each Span's alpha +// value and merging adjacent fully opaque Spans. +func (m *MonochromePainter) Paint(ss []Span, done bool) { + // We compact the ss slice, discarding any Spans whose alpha quantizes to zero. + j := 0 + for _, s := range ss { + if s.Alpha >= 0x8000 { + if m.y == s.Y && m.x1 == s.X0 { + m.x1 = s.X1 + } else { + ss[j] = Span{m.y, m.x0, m.x1, 1<<16 - 1} + j++ + m.y, m.x0, m.x1 = s.Y, s.X0, s.X1 + } + } + } + if done { + // Flush the accumulated Span. + finalSpan := Span{m.y, m.x0, m.x1, 1<<16 - 1} + if j < len(ss) { + ss[j] = finalSpan + j++ + m.Painter.Paint(ss[:j], true) + } else if j == len(ss) { + m.Painter.Paint(ss, false) + if cap(ss) > 0 { + ss = ss[:1] + } else { + ss = make([]Span, 1) + } + ss[0] = finalSpan + m.Painter.Paint(ss, true) + } else { + panic("unreachable") + } + // Reset the accumulator, so that this Painter can be re-used. + m.y, m.x0, m.x1 = 0, 0, 0 + } else { + m.Painter.Paint(ss[:j], false) + } +} + +// NewMonochromePainter creates a new MonochromePainter that wraps the given +// Painter. +func NewMonochromePainter(p Painter) *MonochromePainter { + return &MonochromePainter{Painter: p} +} + +// A GammaCorrectionPainter wraps another Painter, performing gamma-correction +// on each Span's alpha value. +type GammaCorrectionPainter struct { + // Painter is the wrapped Painter. + Painter Painter + // a is the precomputed alpha values for linear interpolation, with fully + // opaque == 0xffff. + a [256]uint16 + // gammaIsOne is whether gamma correction is a no-op. + gammaIsOne bool +} + +// Paint delegates to the wrapped Painter after performing gamma-correction on +// each Span. +func (g *GammaCorrectionPainter) Paint(ss []Span, done bool) { + if !g.gammaIsOne { + const n = 0x101 + for i, s := range ss { + if s.Alpha == 0 || s.Alpha == 0xffff { + continue + } + p, q := s.Alpha/n, s.Alpha%n + // The resultant alpha is a linear interpolation of g.a[p] and g.a[p+1]. + a := uint32(g.a[p])*(n-q) + uint32(g.a[p+1])*q + ss[i].Alpha = (a + n/2) / n + } + } + g.Painter.Paint(ss, done) +} + +// SetGamma sets the gamma value. +func (g *GammaCorrectionPainter) SetGamma(gamma float64) { + g.gammaIsOne = gamma == 1 + if g.gammaIsOne { + return + } + for i := 0; i < 256; i++ { + a := float64(i) / 0xff + a = math.Pow(a, gamma) + g.a[i] = uint16(0xffff * a) + } +} + +// NewGammaCorrectionPainter creates a new GammaCorrectionPainter that wraps +// the given Painter. +func NewGammaCorrectionPainter(p Painter, gamma float64) *GammaCorrectionPainter { + g := &GammaCorrectionPainter{Painter: p} + g.SetGamma(gamma) + return g +} diff --git a/vendor/github.com/golang/freetype/raster/raster.go b/vendor/github.com/golang/freetype/raster/raster.go new file mode 100644 index 00000000..7e6cd4e2 --- /dev/null +++ b/vendor/github.com/golang/freetype/raster/raster.go @@ -0,0 +1,601 @@ +// Copyright 2010 The Freetype-Go Authors. All rights reserved. +// Use of this source code is governed by your choice of either the +// FreeType License or the GNU General Public License version 2 (or +// any later version), both of which can be found in the LICENSE file. + +// Package raster provides an anti-aliasing 2-D rasterizer. +// +// It is part of the larger Freetype suite of font-related packages, but the +// raster package is not specific to font rasterization, and can be used +// standalone without any other Freetype package. +// +// Rasterization is done by the same area/coverage accumulation algorithm as +// the Freetype "smooth" module, and the Anti-Grain Geometry library. A +// description of the area/coverage algorithm is at +// http://projects.tuxee.net/cl-vectors/section-the-cl-aa-algorithm +package raster // import "github.com/golang/freetype/raster" + +import ( + "strconv" + + "golang.org/x/image/math/fixed" +) + +// A cell is part of a linked list (for a given yi co-ordinate) of accumulated +// area/coverage for the pixel at (xi, yi). +type cell struct { + xi int + area, cover int + next int +} + +type Rasterizer struct { + // If false, the default behavior is to use the even-odd winding fill + // rule during Rasterize. + UseNonZeroWinding bool + // An offset (in pixels) to the painted spans. + Dx, Dy int + + // The width of the Rasterizer. The height is implicit in len(cellIndex). + width int + // splitScaleN is the scaling factor used to determine how many times + // to decompose a quadratic or cubic segment into a linear approximation. + splitScale2, splitScale3 int + + // The current pen position. + a fixed.Point26_6 + // The current cell and its area/coverage being accumulated. + xi, yi int + area, cover int + + // Saved cells. + cell []cell + // Linked list of cells, one per row. + cellIndex []int + // Buffers. + cellBuf [256]cell + cellIndexBuf [64]int + spanBuf [64]Span +} + +// findCell returns the index in r.cell for the cell corresponding to +// (r.xi, r.yi). The cell is created if necessary. +func (r *Rasterizer) findCell() int { + if r.yi < 0 || r.yi >= len(r.cellIndex) { + return -1 + } + xi := r.xi + if xi < 0 { + xi = -1 + } else if xi > r.width { + xi = r.width + } + i, prev := r.cellIndex[r.yi], -1 + for i != -1 && r.cell[i].xi <= xi { + if r.cell[i].xi == xi { + return i + } + i, prev = r.cell[i].next, i + } + c := len(r.cell) + if c == cap(r.cell) { + buf := make([]cell, c, 4*c) + copy(buf, r.cell) + r.cell = buf[0 : c+1] + } else { + r.cell = r.cell[0 : c+1] + } + r.cell[c] = cell{xi, 0, 0, i} + if prev == -1 { + r.cellIndex[r.yi] = c + } else { + r.cell[prev].next = c + } + return c +} + +// saveCell saves any accumulated r.area/r.cover for (r.xi, r.yi). +func (r *Rasterizer) saveCell() { + if r.area != 0 || r.cover != 0 { + i := r.findCell() + if i != -1 { + r.cell[i].area += r.area + r.cell[i].cover += r.cover + } + r.area = 0 + r.cover = 0 + } +} + +// setCell sets the (xi, yi) cell that r is accumulating area/coverage for. +func (r *Rasterizer) setCell(xi, yi int) { + if r.xi != xi || r.yi != yi { + r.saveCell() + r.xi, r.yi = xi, yi + } +} + +// scan accumulates area/coverage for the yi'th scanline, going from +// x0 to x1 in the horizontal direction (in 26.6 fixed point co-ordinates) +// and from y0f to y1f fractional vertical units within that scanline. +func (r *Rasterizer) scan(yi int, x0, y0f, x1, y1f fixed.Int26_6) { + // Break the 26.6 fixed point X co-ordinates into integral and fractional parts. + x0i := int(x0) / 64 + x0f := x0 - fixed.Int26_6(64*x0i) + x1i := int(x1) / 64 + x1f := x1 - fixed.Int26_6(64*x1i) + + // A perfectly horizontal scan. + if y0f == y1f { + r.setCell(x1i, yi) + return + } + dx, dy := x1-x0, y1f-y0f + // A single cell scan. + if x0i == x1i { + r.area += int((x0f + x1f) * dy) + r.cover += int(dy) + return + } + // There are at least two cells. Apart from the first and last cells, + // all intermediate cells go through the full width of the cell, + // or 64 units in 26.6 fixed point format. + var ( + p, q, edge0, edge1 fixed.Int26_6 + xiDelta int + ) + if dx > 0 { + p, q = (64-x0f)*dy, dx + edge0, edge1, xiDelta = 0, 64, 1 + } else { + p, q = x0f*dy, -dx + edge0, edge1, xiDelta = 64, 0, -1 + } + yDelta, yRem := p/q, p%q + if yRem < 0 { + yDelta -= 1 + yRem += q + } + // Do the first cell. + xi, y := x0i, y0f + r.area += int((x0f + edge1) * yDelta) + r.cover += int(yDelta) + xi, y = xi+xiDelta, y+yDelta + r.setCell(xi, yi) + if xi != x1i { + // Do all the intermediate cells. + p = 64 * (y1f - y + yDelta) + fullDelta, fullRem := p/q, p%q + if fullRem < 0 { + fullDelta -= 1 + fullRem += q + } + yRem -= q + for xi != x1i { + yDelta = fullDelta + yRem += fullRem + if yRem >= 0 { + yDelta += 1 + yRem -= q + } + r.area += int(64 * yDelta) + r.cover += int(yDelta) + xi, y = xi+xiDelta, y+yDelta + r.setCell(xi, yi) + } + } + // Do the last cell. + yDelta = y1f - y + r.area += int((edge0 + x1f) * yDelta) + r.cover += int(yDelta) +} + +// Start starts a new curve at the given point. +func (r *Rasterizer) Start(a fixed.Point26_6) { + r.setCell(int(a.X/64), int(a.Y/64)) + r.a = a +} + +// Add1 adds a linear segment to the current curve. +func (r *Rasterizer) Add1(b fixed.Point26_6) { + x0, y0 := r.a.X, r.a.Y + x1, y1 := b.X, b.Y + dx, dy := x1-x0, y1-y0 + // Break the 26.6 fixed point Y co-ordinates into integral and fractional + // parts. + y0i := int(y0) / 64 + y0f := y0 - fixed.Int26_6(64*y0i) + y1i := int(y1) / 64 + y1f := y1 - fixed.Int26_6(64*y1i) + + if y0i == y1i { + // There is only one scanline. + r.scan(y0i, x0, y0f, x1, y1f) + + } else if dx == 0 { + // This is a vertical line segment. We avoid calling r.scan and instead + // manipulate r.area and r.cover directly. + var ( + edge0, edge1 fixed.Int26_6 + yiDelta int + ) + if dy > 0 { + edge0, edge1, yiDelta = 0, 64, 1 + } else { + edge0, edge1, yiDelta = 64, 0, -1 + } + x0i, yi := int(x0)/64, y0i + x0fTimes2 := (int(x0) - (64 * x0i)) * 2 + // Do the first pixel. + dcover := int(edge1 - y0f) + darea := int(x0fTimes2 * dcover) + r.area += darea + r.cover += dcover + yi += yiDelta + r.setCell(x0i, yi) + // Do all the intermediate pixels. + dcover = int(edge1 - edge0) + darea = int(x0fTimes2 * dcover) + for yi != y1i { + r.area += darea + r.cover += dcover + yi += yiDelta + r.setCell(x0i, yi) + } + // Do the last pixel. + dcover = int(y1f - edge0) + darea = int(x0fTimes2 * dcover) + r.area += darea + r.cover += dcover + + } else { + // There are at least two scanlines. Apart from the first and last + // scanlines, all intermediate scanlines go through the full height of + // the row, or 64 units in 26.6 fixed point format. + var ( + p, q, edge0, edge1 fixed.Int26_6 + yiDelta int + ) + if dy > 0 { + p, q = (64-y0f)*dx, dy + edge0, edge1, yiDelta = 0, 64, 1 + } else { + p, q = y0f*dx, -dy + edge0, edge1, yiDelta = 64, 0, -1 + } + xDelta, xRem := p/q, p%q + if xRem < 0 { + xDelta -= 1 + xRem += q + } + // Do the first scanline. + x, yi := x0, y0i + r.scan(yi, x, y0f, x+xDelta, edge1) + x, yi = x+xDelta, yi+yiDelta + r.setCell(int(x)/64, yi) + if yi != y1i { + // Do all the intermediate scanlines. + p = 64 * dx + fullDelta, fullRem := p/q, p%q + if fullRem < 0 { + fullDelta -= 1 + fullRem += q + } + xRem -= q + for yi != y1i { + xDelta = fullDelta + xRem += fullRem + if xRem >= 0 { + xDelta += 1 + xRem -= q + } + r.scan(yi, x, edge0, x+xDelta, edge1) + x, yi = x+xDelta, yi+yiDelta + r.setCell(int(x)/64, yi) + } + } + // Do the last scanline. + r.scan(yi, x, edge0, x1, y1f) + } + // The next lineTo starts from b. + r.a = b +} + +// Add2 adds a quadratic segment to the current curve. +func (r *Rasterizer) Add2(b, c fixed.Point26_6) { + // Calculate nSplit (the number of recursive decompositions) based on how + // 'curvy' it is. Specifically, how much the middle point b deviates from + // (a+c)/2. + dev := maxAbs(r.a.X-2*b.X+c.X, r.a.Y-2*b.Y+c.Y) / fixed.Int26_6(r.splitScale2) + nsplit := 0 + for dev > 0 { + dev /= 4 + nsplit++ + } + // dev is 32-bit, and nsplit++ every time we shift off 2 bits, so maxNsplit + // is 16. + const maxNsplit = 16 + if nsplit > maxNsplit { + panic("freetype/raster: Add2 nsplit too large: " + strconv.Itoa(nsplit)) + } + // Recursively decompose the curve nSplit levels deep. + var ( + pStack [2*maxNsplit + 3]fixed.Point26_6 + sStack [maxNsplit + 1]int + i int + ) + sStack[0] = nsplit + pStack[0] = c + pStack[1] = b + pStack[2] = r.a + for i >= 0 { + s := sStack[i] + p := pStack[2*i:] + if s > 0 { + // Split the quadratic curve p[:3] into an equivalent set of two + // shorter curves: p[:3] and p[2:5]. The new p[4] is the old p[2], + // and p[0] is unchanged. + mx := p[1].X + p[4].X = p[2].X + p[3].X = (p[4].X + mx) / 2 + p[1].X = (p[0].X + mx) / 2 + p[2].X = (p[1].X + p[3].X) / 2 + my := p[1].Y + p[4].Y = p[2].Y + p[3].Y = (p[4].Y + my) / 2 + p[1].Y = (p[0].Y + my) / 2 + p[2].Y = (p[1].Y + p[3].Y) / 2 + // The two shorter curves have one less split to do. + sStack[i] = s - 1 + sStack[i+1] = s - 1 + i++ + } else { + // Replace the level-0 quadratic with a two-linear-piece + // approximation. + midx := (p[0].X + 2*p[1].X + p[2].X) / 4 + midy := (p[0].Y + 2*p[1].Y + p[2].Y) / 4 + r.Add1(fixed.Point26_6{midx, midy}) + r.Add1(p[0]) + i-- + } + } +} + +// Add3 adds a cubic segment to the current curve. +func (r *Rasterizer) Add3(b, c, d fixed.Point26_6) { + // Calculate nSplit (the number of recursive decompositions) based on how + // 'curvy' it is. + dev2 := maxAbs(r.a.X-3*(b.X+c.X)+d.X, r.a.Y-3*(b.Y+c.Y)+d.Y) / fixed.Int26_6(r.splitScale2) + dev3 := maxAbs(r.a.X-2*b.X+d.X, r.a.Y-2*b.Y+d.Y) / fixed.Int26_6(r.splitScale3) + nsplit := 0 + for dev2 > 0 || dev3 > 0 { + dev2 /= 8 + dev3 /= 4 + nsplit++ + } + // devN is 32-bit, and nsplit++ every time we shift off 2 bits, so + // maxNsplit is 16. + const maxNsplit = 16 + if nsplit > maxNsplit { + panic("freetype/raster: Add3 nsplit too large: " + strconv.Itoa(nsplit)) + } + // Recursively decompose the curve nSplit levels deep. + var ( + pStack [3*maxNsplit + 4]fixed.Point26_6 + sStack [maxNsplit + 1]int + i int + ) + sStack[0] = nsplit + pStack[0] = d + pStack[1] = c + pStack[2] = b + pStack[3] = r.a + for i >= 0 { + s := sStack[i] + p := pStack[3*i:] + if s > 0 { + // Split the cubic curve p[:4] into an equivalent set of two + // shorter curves: p[:4] and p[3:7]. The new p[6] is the old p[3], + // and p[0] is unchanged. + m01x := (p[0].X + p[1].X) / 2 + m12x := (p[1].X + p[2].X) / 2 + m23x := (p[2].X + p[3].X) / 2 + p[6].X = p[3].X + p[5].X = m23x + p[1].X = m01x + p[2].X = (m01x + m12x) / 2 + p[4].X = (m12x + m23x) / 2 + p[3].X = (p[2].X + p[4].X) / 2 + m01y := (p[0].Y + p[1].Y) / 2 + m12y := (p[1].Y + p[2].Y) / 2 + m23y := (p[2].Y + p[3].Y) / 2 + p[6].Y = p[3].Y + p[5].Y = m23y + p[1].Y = m01y + p[2].Y = (m01y + m12y) / 2 + p[4].Y = (m12y + m23y) / 2 + p[3].Y = (p[2].Y + p[4].Y) / 2 + // The two shorter curves have one less split to do. + sStack[i] = s - 1 + sStack[i+1] = s - 1 + i++ + } else { + // Replace the level-0 cubic with a two-linear-piece approximation. + midx := (p[0].X + 3*(p[1].X+p[2].X) + p[3].X) / 8 + midy := (p[0].Y + 3*(p[1].Y+p[2].Y) + p[3].Y) / 8 + r.Add1(fixed.Point26_6{midx, midy}) + r.Add1(p[0]) + i-- + } + } +} + +// AddPath adds the given Path. +func (r *Rasterizer) AddPath(p Path) { + for i := 0; i < len(p); { + switch p[i] { + case 0: + r.Start( + fixed.Point26_6{p[i+1], p[i+2]}, + ) + i += 4 + case 1: + r.Add1( + fixed.Point26_6{p[i+1], p[i+2]}, + ) + i += 4 + case 2: + r.Add2( + fixed.Point26_6{p[i+1], p[i+2]}, + fixed.Point26_6{p[i+3], p[i+4]}, + ) + i += 6 + case 3: + r.Add3( + fixed.Point26_6{p[i+1], p[i+2]}, + fixed.Point26_6{p[i+3], p[i+4]}, + fixed.Point26_6{p[i+5], p[i+6]}, + ) + i += 8 + default: + panic("freetype/raster: bad path") + } + } +} + +// AddStroke adds a stroked Path. +func (r *Rasterizer) AddStroke(q Path, width fixed.Int26_6, cr Capper, jr Joiner) { + Stroke(r, q, width, cr, jr) +} + +// areaToAlpha converts an area value to a uint32 alpha value. A completely +// filled pixel corresponds to an area of 64*64*2, and an alpha of 0xffff. The +// conversion of area values greater than this depends on the winding rule: +// even-odd or non-zero. +func (r *Rasterizer) areaToAlpha(area int) uint32 { + // The C Freetype implementation (version 2.3.12) does "alpha := area>>1" + // without the +1. Round-to-nearest gives a more symmetric result than + // round-down. The C implementation also returns 8-bit alpha, not 16-bit + // alpha. + a := (area + 1) >> 1 + if a < 0 { + a = -a + } + alpha := uint32(a) + if r.UseNonZeroWinding { + if alpha > 0x0fff { + alpha = 0x0fff + } + } else { + alpha &= 0x1fff + if alpha > 0x1000 { + alpha = 0x2000 - alpha + } else if alpha == 0x1000 { + alpha = 0x0fff + } + } + // alpha is now in the range [0x0000, 0x0fff]. Convert that 12-bit alpha to + // 16-bit alpha. + return alpha<<4 | alpha>>8 +} + +// Rasterize converts r's accumulated curves into Spans for p. The Spans passed +// to p are non-overlapping, and sorted by Y and then X. They all have non-zero +// width (and 0 <= X0 < X1 <= r.width) and non-zero A, except for the final +// Span, which has Y, X0, X1 and A all equal to zero. +func (r *Rasterizer) Rasterize(p Painter) { + r.saveCell() + s := 0 + for yi := 0; yi < len(r.cellIndex); yi++ { + xi, cover := 0, 0 + for c := r.cellIndex[yi]; c != -1; c = r.cell[c].next { + if cover != 0 && r.cell[c].xi > xi { + alpha := r.areaToAlpha(cover * 64 * 2) + if alpha != 0 { + xi0, xi1 := xi, r.cell[c].xi + if xi0 < 0 { + xi0 = 0 + } + if xi1 >= r.width { + xi1 = r.width + } + if xi0 < xi1 { + r.spanBuf[s] = Span{yi + r.Dy, xi0 + r.Dx, xi1 + r.Dx, alpha} + s++ + } + } + } + cover += r.cell[c].cover + alpha := r.areaToAlpha(cover*64*2 - r.cell[c].area) + xi = r.cell[c].xi + 1 + if alpha != 0 { + xi0, xi1 := r.cell[c].xi, xi + if xi0 < 0 { + xi0 = 0 + } + if xi1 >= r.width { + xi1 = r.width + } + if xi0 < xi1 { + r.spanBuf[s] = Span{yi + r.Dy, xi0 + r.Dx, xi1 + r.Dx, alpha} + s++ + } + } + if s > len(r.spanBuf)-2 { + p.Paint(r.spanBuf[:s], false) + s = 0 + } + } + } + p.Paint(r.spanBuf[:s], true) +} + +// Clear cancels any previous calls to r.Start or r.AddXxx. +func (r *Rasterizer) Clear() { + r.a = fixed.Point26_6{} + r.xi = 0 + r.yi = 0 + r.area = 0 + r.cover = 0 + r.cell = r.cell[:0] + for i := 0; i < len(r.cellIndex); i++ { + r.cellIndex[i] = -1 + } +} + +// SetBounds sets the maximum width and height of the rasterized image and +// calls Clear. The width and height are in pixels, not fixed.Int26_6 units. +func (r *Rasterizer) SetBounds(width, height int) { + if width < 0 { + width = 0 + } + if height < 0 { + height = 0 + } + // Use the same ssN heuristic as the C Freetype (version 2.4.0) + // implementation. + ss2, ss3 := 32, 16 + if width > 24 || height > 24 { + ss2, ss3 = 2*ss2, 2*ss3 + if width > 120 || height > 120 { + ss2, ss3 = 2*ss2, 2*ss3 + } + } + r.width = width + r.splitScale2 = ss2 + r.splitScale3 = ss3 + r.cell = r.cellBuf[:0] + if height > len(r.cellIndexBuf) { + r.cellIndex = make([]int, height) + } else { + r.cellIndex = r.cellIndexBuf[:height] + } + r.Clear() +} + +// NewRasterizer creates a new Rasterizer with the given bounds. +func NewRasterizer(width, height int) *Rasterizer { + r := new(Rasterizer) + r.SetBounds(width, height) + return r +} diff --git a/vendor/github.com/golang/freetype/raster/stroke.go b/vendor/github.com/golang/freetype/raster/stroke.go new file mode 100644 index 00000000..bcc66b26 --- /dev/null +++ b/vendor/github.com/golang/freetype/raster/stroke.go @@ -0,0 +1,483 @@ +// Copyright 2010 The Freetype-Go Authors. All rights reserved. +// Use of this source code is governed by your choice of either the +// FreeType License or the GNU General Public License version 2 (or +// any later version), both of which can be found in the LICENSE file. + +package raster + +import ( + "golang.org/x/image/math/fixed" +) + +// Two points are considered practically equal if the square of the distance +// between them is less than one quarter (i.e. 1024 / 4096). +const epsilon = fixed.Int52_12(1024) + +// A Capper signifies how to begin or end a stroked path. +type Capper interface { + // Cap adds a cap to p given a pivot point and the normal vector of a + // terminal segment. The normal's length is half of the stroke width. + Cap(p Adder, halfWidth fixed.Int26_6, pivot, n1 fixed.Point26_6) +} + +// The CapperFunc type adapts an ordinary function to be a Capper. +type CapperFunc func(Adder, fixed.Int26_6, fixed.Point26_6, fixed.Point26_6) + +func (f CapperFunc) Cap(p Adder, halfWidth fixed.Int26_6, pivot, n1 fixed.Point26_6) { + f(p, halfWidth, pivot, n1) +} + +// A Joiner signifies how to join interior nodes of a stroked path. +type Joiner interface { + // Join adds a join to the two sides of a stroked path given a pivot + // point and the normal vectors of the trailing and leading segments. + // Both normals have length equal to half of the stroke width. + Join(lhs, rhs Adder, halfWidth fixed.Int26_6, pivot, n0, n1 fixed.Point26_6) +} + +// The JoinerFunc type adapts an ordinary function to be a Joiner. +type JoinerFunc func(lhs, rhs Adder, halfWidth fixed.Int26_6, pivot, n0, n1 fixed.Point26_6) + +func (f JoinerFunc) Join(lhs, rhs Adder, halfWidth fixed.Int26_6, pivot, n0, n1 fixed.Point26_6) { + f(lhs, rhs, halfWidth, pivot, n0, n1) +} + +// RoundCapper adds round caps to a stroked path. +var RoundCapper Capper = CapperFunc(roundCapper) + +func roundCapper(p Adder, halfWidth fixed.Int26_6, pivot, n1 fixed.Point26_6) { + // The cubic Bézier approximation to a circle involves the magic number + // (√2 - 1) * 4/3, which is approximately 35/64. + const k = 35 + e := pRot90CCW(n1) + side := pivot.Add(e) + start, end := pivot.Sub(n1), pivot.Add(n1) + d, e := n1.Mul(k), e.Mul(k) + p.Add3(start.Add(e), side.Sub(d), side) + p.Add3(side.Add(d), end.Add(e), end) +} + +// ButtCapper adds butt caps to a stroked path. +var ButtCapper Capper = CapperFunc(buttCapper) + +func buttCapper(p Adder, halfWidth fixed.Int26_6, pivot, n1 fixed.Point26_6) { + p.Add1(pivot.Add(n1)) +} + +// SquareCapper adds square caps to a stroked path. +var SquareCapper Capper = CapperFunc(squareCapper) + +func squareCapper(p Adder, halfWidth fixed.Int26_6, pivot, n1 fixed.Point26_6) { + e := pRot90CCW(n1) + side := pivot.Add(e) + p.Add1(side.Sub(n1)) + p.Add1(side.Add(n1)) + p.Add1(pivot.Add(n1)) +} + +// RoundJoiner adds round joins to a stroked path. +var RoundJoiner Joiner = JoinerFunc(roundJoiner) + +func roundJoiner(lhs, rhs Adder, haflWidth fixed.Int26_6, pivot, n0, n1 fixed.Point26_6) { + dot := pDot(pRot90CW(n0), n1) + if dot >= 0 { + addArc(lhs, pivot, n0, n1) + rhs.Add1(pivot.Sub(n1)) + } else { + lhs.Add1(pivot.Add(n1)) + addArc(rhs, pivot, pNeg(n0), pNeg(n1)) + } +} + +// BevelJoiner adds bevel joins to a stroked path. +var BevelJoiner Joiner = JoinerFunc(bevelJoiner) + +func bevelJoiner(lhs, rhs Adder, haflWidth fixed.Int26_6, pivot, n0, n1 fixed.Point26_6) { + lhs.Add1(pivot.Add(n1)) + rhs.Add1(pivot.Sub(n1)) +} + +// addArc adds a circular arc from pivot+n0 to pivot+n1 to p. The shorter of +// the two possible arcs is taken, i.e. the one spanning <= 180 degrees. The +// two vectors n0 and n1 must be of equal length. +func addArc(p Adder, pivot, n0, n1 fixed.Point26_6) { + // r2 is the square of the length of n0. + r2 := pDot(n0, n0) + if r2 < epsilon { + // The arc radius is so small that we collapse to a straight line. + p.Add1(pivot.Add(n1)) + return + } + // We approximate the arc by 0, 1, 2 or 3 45-degree quadratic segments plus + // a final quadratic segment from s to n1. Each 45-degree segment has + // control points {1, 0}, {1, tan(π/8)} and {1/√2, 1/√2} suitably scaled, + // rotated and translated. tan(π/8) is approximately 27/64. + const tpo8 = 27 + var s fixed.Point26_6 + // We determine which octant the angle between n0 and n1 is in via three + // dot products. m0, m1 and m2 are n0 rotated clockwise by 45, 90 and 135 + // degrees. + m0 := pRot45CW(n0) + m1 := pRot90CW(n0) + m2 := pRot90CW(m0) + if pDot(m1, n1) >= 0 { + if pDot(n0, n1) >= 0 { + if pDot(m2, n1) <= 0 { + // n1 is between 0 and 45 degrees clockwise of n0. + s = n0 + } else { + // n1 is between 45 and 90 degrees clockwise of n0. + p.Add2(pivot.Add(n0).Add(m1.Mul(tpo8)), pivot.Add(m0)) + s = m0 + } + } else { + pm1, n0t := pivot.Add(m1), n0.Mul(tpo8) + p.Add2(pivot.Add(n0).Add(m1.Mul(tpo8)), pivot.Add(m0)) + p.Add2(pm1.Add(n0t), pm1) + if pDot(m0, n1) >= 0 { + // n1 is between 90 and 135 degrees clockwise of n0. + s = m1 + } else { + // n1 is between 135 and 180 degrees clockwise of n0. + p.Add2(pm1.Sub(n0t), pivot.Add(m2)) + s = m2 + } + } + } else { + if pDot(n0, n1) >= 0 { + if pDot(m0, n1) >= 0 { + // n1 is between 0 and 45 degrees counter-clockwise of n0. + s = n0 + } else { + // n1 is between 45 and 90 degrees counter-clockwise of n0. + p.Add2(pivot.Add(n0).Sub(m1.Mul(tpo8)), pivot.Sub(m2)) + s = pNeg(m2) + } + } else { + pm1, n0t := pivot.Sub(m1), n0.Mul(tpo8) + p.Add2(pivot.Add(n0).Sub(m1.Mul(tpo8)), pivot.Sub(m2)) + p.Add2(pm1.Add(n0t), pm1) + if pDot(m2, n1) <= 0 { + // n1 is between 90 and 135 degrees counter-clockwise of n0. + s = pNeg(m1) + } else { + // n1 is between 135 and 180 degrees counter-clockwise of n0. + p.Add2(pm1.Sub(n0t), pivot.Sub(m0)) + s = pNeg(m0) + } + } + } + // The final quadratic segment has two endpoints s and n1 and the middle + // control point is a multiple of s.Add(n1), i.e. it is on the angle + // bisector of those two points. The multiple ranges between 128/256 and + // 150/256 as the angle between s and n1 ranges between 0 and 45 degrees. + // + // When the angle is 0 degrees (i.e. s and n1 are coincident) then + // s.Add(n1) is twice s and so the middle control point of the degenerate + // quadratic segment should be half s.Add(n1), and half = 128/256. + // + // When the angle is 45 degrees then 150/256 is the ratio of the lengths of + // the two vectors {1, tan(π/8)} and {1 + 1/√2, 1/√2}. + // + // d is the normalized dot product between s and n1. Since the angle ranges + // between 0 and 45 degrees then d ranges between 256/256 and 181/256. + d := 256 * pDot(s, n1) / r2 + multiple := fixed.Int26_6(150-(150-128)*(d-181)/(256-181)) >> 2 + p.Add2(pivot.Add(s.Add(n1).Mul(multiple)), pivot.Add(n1)) +} + +// midpoint returns the midpoint of two Points. +func midpoint(a, b fixed.Point26_6) fixed.Point26_6 { + return fixed.Point26_6{(a.X + b.X) / 2, (a.Y + b.Y) / 2} +} + +// angleGreaterThan45 returns whether the angle between two vectors is more +// than 45 degrees. +func angleGreaterThan45(v0, v1 fixed.Point26_6) bool { + v := pRot45CCW(v0) + return pDot(v, v1) < 0 || pDot(pRot90CW(v), v1) < 0 +} + +// interpolate returns the point (1-t)*a + t*b. +func interpolate(a, b fixed.Point26_6, t fixed.Int52_12) fixed.Point26_6 { + s := 1<<12 - t + x := s*fixed.Int52_12(a.X) + t*fixed.Int52_12(b.X) + y := s*fixed.Int52_12(a.Y) + t*fixed.Int52_12(b.Y) + return fixed.Point26_6{fixed.Int26_6(x >> 12), fixed.Int26_6(y >> 12)} +} + +// curviest2 returns the value of t for which the quadratic parametric curve +// (1-t)²*a + 2*t*(1-t).b + t²*c has maximum curvature. +// +// The curvature of the parametric curve f(t) = (x(t), y(t)) is +// |x′y″-y′x″| / (x′²+y′²)^(3/2). +// +// Let d = b-a and e = c-2*b+a, so that f′(t) = 2*d+2*e*t and f″(t) = 2*e. +// The curvature's numerator is (2*dx+2*ex*t)*(2*ey)-(2*dy+2*ey*t)*(2*ex), +// which simplifies to 4*dx*ey-4*dy*ex, which is constant with respect to t. +// +// Thus, curvature is extreme where the denominator is extreme, i.e. where +// (x′²+y′²) is extreme. The first order condition is that +// 2*x′*x″+2*y′*y″ = 0, or (dx+ex*t)*ex + (dy+ey*t)*ey = 0. +// Solving for t gives t = -(dx*ex+dy*ey) / (ex*ex+ey*ey). +func curviest2(a, b, c fixed.Point26_6) fixed.Int52_12 { + dx := int64(b.X - a.X) + dy := int64(b.Y - a.Y) + ex := int64(c.X - 2*b.X + a.X) + ey := int64(c.Y - 2*b.Y + a.Y) + if ex == 0 && ey == 0 { + return 2048 + } + return fixed.Int52_12(-4096 * (dx*ex + dy*ey) / (ex*ex + ey*ey)) +} + +// A stroker holds state for stroking a path. +type stroker struct { + // p is the destination that records the stroked path. + p Adder + // u is the half-width of the stroke. + u fixed.Int26_6 + // cr and jr specify how to end and connect path segments. + cr Capper + jr Joiner + // r is the reverse path. Stroking a path involves constructing two + // parallel paths 2*u apart. The first path is added immediately to p, + // the second path is accumulated in r and eventually added in reverse. + r Path + // a is the most recent segment point. anorm is the segment normal of + // length u at that point. + a, anorm fixed.Point26_6 +} + +// addNonCurvy2 adds a quadratic segment to the stroker, where the segment +// defined by (k.a, b, c) achieves maximum curvature at either k.a or c. +func (k *stroker) addNonCurvy2(b, c fixed.Point26_6) { + // We repeatedly divide the segment at its middle until it is straight + // enough to approximate the stroke by just translating the control points. + // ds and ps are stacks of depths and points. t is the top of the stack. + const maxDepth = 5 + var ( + ds [maxDepth + 1]int + ps [2*maxDepth + 3]fixed.Point26_6 + t int + ) + // Initially the ps stack has one quadratic segment of depth zero. + ds[0] = 0 + ps[2] = k.a + ps[1] = b + ps[0] = c + anorm := k.anorm + var cnorm fixed.Point26_6 + + for { + depth := ds[t] + a := ps[2*t+2] + b := ps[2*t+1] + c := ps[2*t+0] + ab := b.Sub(a) + bc := c.Sub(b) + abIsSmall := pDot(ab, ab) < fixed.Int52_12(1<<12) + bcIsSmall := pDot(bc, bc) < fixed.Int52_12(1<<12) + if abIsSmall && bcIsSmall { + // Approximate the segment by a circular arc. + cnorm = pRot90CCW(pNorm(bc, k.u)) + mac := midpoint(a, c) + addArc(k.p, mac, anorm, cnorm) + addArc(&k.r, mac, pNeg(anorm), pNeg(cnorm)) + } else if depth < maxDepth && angleGreaterThan45(ab, bc) { + // Divide the segment in two and push both halves on the stack. + mab := midpoint(a, b) + mbc := midpoint(b, c) + t++ + ds[t+0] = depth + 1 + ds[t-1] = depth + 1 + ps[2*t+2] = a + ps[2*t+1] = mab + ps[2*t+0] = midpoint(mab, mbc) + ps[2*t-1] = mbc + continue + } else { + // Translate the control points. + bnorm := pRot90CCW(pNorm(c.Sub(a), k.u)) + cnorm = pRot90CCW(pNorm(bc, k.u)) + k.p.Add2(b.Add(bnorm), c.Add(cnorm)) + k.r.Add2(b.Sub(bnorm), c.Sub(cnorm)) + } + if t == 0 { + k.a, k.anorm = c, cnorm + return + } + t-- + anorm = cnorm + } + panic("unreachable") +} + +// Add1 adds a linear segment to the stroker. +func (k *stroker) Add1(b fixed.Point26_6) { + bnorm := pRot90CCW(pNorm(b.Sub(k.a), k.u)) + if len(k.r) == 0 { + k.p.Start(k.a.Add(bnorm)) + k.r.Start(k.a.Sub(bnorm)) + } else { + k.jr.Join(k.p, &k.r, k.u, k.a, k.anorm, bnorm) + } + k.p.Add1(b.Add(bnorm)) + k.r.Add1(b.Sub(bnorm)) + k.a, k.anorm = b, bnorm +} + +// Add2 adds a quadratic segment to the stroker. +func (k *stroker) Add2(b, c fixed.Point26_6) { + ab := b.Sub(k.a) + bc := c.Sub(b) + abnorm := pRot90CCW(pNorm(ab, k.u)) + if len(k.r) == 0 { + k.p.Start(k.a.Add(abnorm)) + k.r.Start(k.a.Sub(abnorm)) + } else { + k.jr.Join(k.p, &k.r, k.u, k.a, k.anorm, abnorm) + } + + // Approximate nearly-degenerate quadratics by linear segments. + abIsSmall := pDot(ab, ab) < epsilon + bcIsSmall := pDot(bc, bc) < epsilon + if abIsSmall || bcIsSmall { + acnorm := pRot90CCW(pNorm(c.Sub(k.a), k.u)) + k.p.Add1(c.Add(acnorm)) + k.r.Add1(c.Sub(acnorm)) + k.a, k.anorm = c, acnorm + return + } + + // The quadratic segment (k.a, b, c) has a point of maximum curvature. + // If this occurs at an end point, we process the segment as a whole. + t := curviest2(k.a, b, c) + if t <= 0 || 4096 <= t { + k.addNonCurvy2(b, c) + return + } + + // Otherwise, we perform a de Casteljau decomposition at the point of + // maximum curvature and process the two straighter parts. + mab := interpolate(k.a, b, t) + mbc := interpolate(b, c, t) + mabc := interpolate(mab, mbc, t) + + // If the vectors ab and bc are close to being in opposite directions, + // then the decomposition can become unstable, so we approximate the + // quadratic segment by two linear segments joined by an arc. + bcnorm := pRot90CCW(pNorm(bc, k.u)) + if pDot(abnorm, bcnorm) < -fixed.Int52_12(k.u)*fixed.Int52_12(k.u)*2047/2048 { + pArc := pDot(abnorm, bc) < 0 + + k.p.Add1(mabc.Add(abnorm)) + if pArc { + z := pRot90CW(abnorm) + addArc(k.p, mabc, abnorm, z) + addArc(k.p, mabc, z, bcnorm) + } + k.p.Add1(mabc.Add(bcnorm)) + k.p.Add1(c.Add(bcnorm)) + + k.r.Add1(mabc.Sub(abnorm)) + if !pArc { + z := pRot90CW(abnorm) + addArc(&k.r, mabc, pNeg(abnorm), z) + addArc(&k.r, mabc, z, pNeg(bcnorm)) + } + k.r.Add1(mabc.Sub(bcnorm)) + k.r.Add1(c.Sub(bcnorm)) + + k.a, k.anorm = c, bcnorm + return + } + + // Process the decomposed parts. + k.addNonCurvy2(mab, mabc) + k.addNonCurvy2(mbc, c) +} + +// Add3 adds a cubic segment to the stroker. +func (k *stroker) Add3(b, c, d fixed.Point26_6) { + panic("freetype/raster: stroke unimplemented for cubic segments") +} + +// stroke adds the stroked Path q to p, where q consists of exactly one curve. +func (k *stroker) stroke(q Path) { + // Stroking is implemented by deriving two paths each k.u apart from q. + // The left-hand-side path is added immediately to k.p; the right-hand-side + // path is accumulated in k.r. Once we've finished adding the LHS to k.p, + // we add the RHS in reverse order. + k.r = make(Path, 0, len(q)) + k.a = fixed.Point26_6{q[1], q[2]} + for i := 4; i < len(q); { + switch q[i] { + case 1: + k.Add1( + fixed.Point26_6{q[i+1], q[i+2]}, + ) + i += 4 + case 2: + k.Add2( + fixed.Point26_6{q[i+1], q[i+2]}, + fixed.Point26_6{q[i+3], q[i+4]}, + ) + i += 6 + case 3: + k.Add3( + fixed.Point26_6{q[i+1], q[i+2]}, + fixed.Point26_6{q[i+3], q[i+4]}, + fixed.Point26_6{q[i+5], q[i+6]}, + ) + i += 8 + default: + panic("freetype/raster: bad path") + } + } + if len(k.r) == 0 { + return + } + // TODO(nigeltao): if q is a closed curve then we should join the first and + // last segments instead of capping them. + k.cr.Cap(k.p, k.u, q.lastPoint(), pNeg(k.anorm)) + addPathReversed(k.p, k.r) + pivot := q.firstPoint() + k.cr.Cap(k.p, k.u, pivot, pivot.Sub(fixed.Point26_6{k.r[1], k.r[2]})) +} + +// Stroke adds q stroked with the given width to p. The result is typically +// self-intersecting and should be rasterized with UseNonZeroWinding. +// cr and jr may be nil, which defaults to a RoundCapper or RoundJoiner. +func Stroke(p Adder, q Path, width fixed.Int26_6, cr Capper, jr Joiner) { + if len(q) == 0 { + return + } + if cr == nil { + cr = RoundCapper + } + if jr == nil { + jr = RoundJoiner + } + if q[0] != 0 { + panic("freetype/raster: bad path") + } + s := stroker{p: p, u: width / 2, cr: cr, jr: jr} + i := 0 + for j := 4; j < len(q); { + switch q[j] { + case 0: + s.stroke(q[i:j]) + i, j = j, j+4 + case 1: + j += 4 + case 2: + j += 6 + case 3: + j += 8 + default: + panic("freetype/raster: bad path") + } + } + s.stroke(q[i:]) +} diff --git a/vendor/github.com/golang/freetype/truetype/face.go b/vendor/github.com/golang/freetype/truetype/face.go new file mode 100644 index 00000000..099006f0 --- /dev/null +++ b/vendor/github.com/golang/freetype/truetype/face.go @@ -0,0 +1,507 @@ +// Copyright 2015 The Freetype-Go Authors. All rights reserved. +// Use of this source code is governed by your choice of either the +// FreeType License or the GNU General Public License version 2 (or +// any later version), both of which can be found in the LICENSE file. + +package truetype + +import ( + "image" + "math" + + "github.com/golang/freetype/raster" + "golang.org/x/image/font" + "golang.org/x/image/math/fixed" +) + +func powerOf2(i int) bool { + return i != 0 && (i&(i-1)) == 0 +} + +// Options are optional arguments to NewFace. +type Options struct { + // Size is the font size in points, as in "a 10 point font size". + // + // A zero value means to use a 12 point font size. + Size float64 + + // DPI is the dots-per-inch resolution. + // + // A zero value means to use 72 DPI. + DPI float64 + + // Hinting is how to quantize the glyph nodes. + // + // A zero value means to use no hinting. + Hinting font.Hinting + + // GlyphCacheEntries is the number of entries in the glyph mask image + // cache. + // + // If non-zero, it must be a power of 2. + // + // A zero value means to use 512 entries. + GlyphCacheEntries int + + // SubPixelsX is the number of sub-pixel locations a glyph's dot is + // quantized to, in the horizontal direction. For example, a value of 8 + // means that the dot is quantized to 1/8th of a pixel. This quantization + // only affects the glyph mask image, not its bounding box or advance + // width. A higher value gives a more faithful glyph image, but reduces the + // effectiveness of the glyph cache. + // + // If non-zero, it must be a power of 2, and be between 1 and 64 inclusive. + // + // A zero value means to use 4 sub-pixel locations. + SubPixelsX int + + // SubPixelsY is the number of sub-pixel locations a glyph's dot is + // quantized to, in the vertical direction. For example, a value of 8 + // means that the dot is quantized to 1/8th of a pixel. This quantization + // only affects the glyph mask image, not its bounding box or advance + // width. A higher value gives a more faithful glyph image, but reduces the + // effectiveness of the glyph cache. + // + // If non-zero, it must be a power of 2, and be between 1 and 64 inclusive. + // + // A zero value means to use 1 sub-pixel location. + SubPixelsY int +} + +func (o *Options) size() float64 { + if o != nil && o.Size > 0 { + return o.Size + } + return 12 +} + +func (o *Options) dpi() float64 { + if o != nil && o.DPI > 0 { + return o.DPI + } + return 72 +} + +func (o *Options) hinting() font.Hinting { + if o != nil { + switch o.Hinting { + case font.HintingVertical, font.HintingFull: + // TODO: support vertical hinting. + return font.HintingFull + } + } + return font.HintingNone +} + +func (o *Options) glyphCacheEntries() int { + if o != nil && powerOf2(o.GlyphCacheEntries) { + return o.GlyphCacheEntries + } + // 512 is 128 * 4 * 1, which lets us cache 128 glyphs at 4 * 1 subpixel + // locations in the X and Y direction. + return 512 +} + +func (o *Options) subPixelsX() (value uint32, halfQuantum, mask fixed.Int26_6) { + if o != nil { + switch o.SubPixelsX { + case 1, 2, 4, 8, 16, 32, 64: + return subPixels(o.SubPixelsX) + } + } + // This default value of 4 isn't based on anything scientific, merely as + // small a number as possible that looks almost as good as no quantization, + // or returning subPixels(64). + return subPixels(4) +} + +func (o *Options) subPixelsY() (value uint32, halfQuantum, mask fixed.Int26_6) { + if o != nil { + switch o.SubPixelsX { + case 1, 2, 4, 8, 16, 32, 64: + return subPixels(o.SubPixelsX) + } + } + // This default value of 1 isn't based on anything scientific, merely that + // vertical sub-pixel glyph rendering is pretty rare. Baseline locations + // can usually afford to snap to the pixel grid, so the vertical direction + // doesn't have the deal with the horizontal's fractional advance widths. + return subPixels(1) +} + +// subPixels returns q and the bias and mask that leads to q quantized +// sub-pixel locations per full pixel. +// +// For example, q == 4 leads to a bias of 8 and a mask of 0xfffffff0, or -16, +// because we want to round fractions of fixed.Int26_6 as: +// - 0 to 7 rounds to 0. +// - 8 to 23 rounds to 16. +// - 24 to 39 rounds to 32. +// - 40 to 55 rounds to 48. +// - 56 to 63 rounds to 64. +// which means to add 8 and then bitwise-and with -16, in two's complement +// representation. +// +// When q == 1, we want bias == 32 and mask == -64. +// When q == 2, we want bias == 16 and mask == -32. +// When q == 4, we want bias == 8 and mask == -16. +// ... +// When q == 64, we want bias == 0 and mask == -1. (The no-op case). +// The pattern is clear. +func subPixels(q int) (value uint32, bias, mask fixed.Int26_6) { + return uint32(q), 32 / fixed.Int26_6(q), -64 / fixed.Int26_6(q) +} + +// glyphCacheEntry caches the arguments and return values of rasterize. +type glyphCacheEntry struct { + key glyphCacheKey + val glyphCacheVal +} + +type glyphCacheKey struct { + index Index + fx, fy uint8 +} + +type glyphCacheVal struct { + advanceWidth fixed.Int26_6 + offset image.Point + gw int + gh int +} + +type indexCacheEntry struct { + rune rune + index Index +} + +// NewFace returns a new font.Face for the given Font. +func NewFace(f *Font, opts *Options) font.Face { + a := &face{ + f: f, + hinting: opts.hinting(), + scale: fixed.Int26_6(0.5 + (opts.size() * opts.dpi() * 64 / 72)), + glyphCache: make([]glyphCacheEntry, opts.glyphCacheEntries()), + } + a.subPixelX, a.subPixelBiasX, a.subPixelMaskX = opts.subPixelsX() + a.subPixelY, a.subPixelBiasY, a.subPixelMaskY = opts.subPixelsY() + + // Fill the cache with invalid entries. Valid glyph cache entries have fx + // and fy in the range [0, 64). Valid index cache entries have rune >= 0. + for i := range a.glyphCache { + a.glyphCache[i].key.fy = 0xff + } + for i := range a.indexCache { + a.indexCache[i].rune = -1 + } + + // Set the rasterizer's bounds to be big enough to handle the largest glyph. + b := f.Bounds(a.scale) + xmin := +int(b.Min.X) >> 6 + ymin := -int(b.Max.Y) >> 6 + xmax := +int(b.Max.X+63) >> 6 + ymax := -int(b.Min.Y-63) >> 6 + a.maxw = xmax - xmin + a.maxh = ymax - ymin + a.masks = image.NewAlpha(image.Rect(0, 0, a.maxw, a.maxh*len(a.glyphCache))) + a.r.SetBounds(a.maxw, a.maxh) + a.p = facePainter{a} + + return a +} + +type face struct { + f *Font + hinting font.Hinting + scale fixed.Int26_6 + subPixelX uint32 + subPixelBiasX fixed.Int26_6 + subPixelMaskX fixed.Int26_6 + subPixelY uint32 + subPixelBiasY fixed.Int26_6 + subPixelMaskY fixed.Int26_6 + masks *image.Alpha + glyphCache []glyphCacheEntry + r raster.Rasterizer + p raster.Painter + paintOffset int + maxw int + maxh int + glyphBuf GlyphBuf + indexCache [indexCacheLen]indexCacheEntry + + // TODO: clip rectangle? +} + +const indexCacheLen = 256 + +func (a *face) index(r rune) Index { + const mask = indexCacheLen - 1 + c := &a.indexCache[r&mask] + if c.rune == r { + return c.index + } + i := a.f.Index(r) + c.rune = r + c.index = i + return i +} + +// Close satisfies the font.Face interface. +func (a *face) Close() error { return nil } + +// Metrics satisfies the font.Face interface. +func (a *face) Metrics() font.Metrics { + scale := float64(a.scale) + fupe := float64(a.f.FUnitsPerEm()) + return font.Metrics{ + Height: a.scale, + Ascent: fixed.Int26_6(math.Ceil(scale * float64(+a.f.ascent) / fupe)), + Descent: fixed.Int26_6(math.Ceil(scale * float64(-a.f.descent) / fupe)), + } +} + +// Kern satisfies the font.Face interface. +func (a *face) Kern(r0, r1 rune) fixed.Int26_6 { + i0 := a.index(r0) + i1 := a.index(r1) + kern := a.f.Kern(a.scale, i0, i1) + if a.hinting != font.HintingNone { + kern = (kern + 32) &^ 63 + } + return kern +} + +// Glyph satisfies the font.Face interface. +func (a *face) Glyph(dot fixed.Point26_6, r rune) ( + dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool) { + + // Quantize to the sub-pixel granularity. + dotX := (dot.X + a.subPixelBiasX) & a.subPixelMaskX + dotY := (dot.Y + a.subPixelBiasY) & a.subPixelMaskY + + // Split the coordinates into their integer and fractional parts. + ix, fx := int(dotX>>6), dotX&0x3f + iy, fy := int(dotY>>6), dotY&0x3f + + index := a.index(r) + cIndex := uint32(index) + cIndex = cIndex*a.subPixelX - uint32(fx/a.subPixelMaskX) + cIndex = cIndex*a.subPixelY - uint32(fy/a.subPixelMaskY) + cIndex &= uint32(len(a.glyphCache) - 1) + a.paintOffset = a.maxh * int(cIndex) + k := glyphCacheKey{ + index: index, + fx: uint8(fx), + fy: uint8(fy), + } + var v glyphCacheVal + if a.glyphCache[cIndex].key != k { + var ok bool + v, ok = a.rasterize(index, fx, fy) + if !ok { + return image.Rectangle{}, nil, image.Point{}, 0, false + } + a.glyphCache[cIndex] = glyphCacheEntry{k, v} + } else { + v = a.glyphCache[cIndex].val + } + + dr.Min = image.Point{ + X: ix + v.offset.X, + Y: iy + v.offset.Y, + } + dr.Max = image.Point{ + X: dr.Min.X + v.gw, + Y: dr.Min.Y + v.gh, + } + return dr, a.masks, image.Point{Y: a.paintOffset}, v.advanceWidth, true +} + +func (a *face) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) { + if err := a.glyphBuf.Load(a.f, a.scale, a.index(r), a.hinting); err != nil { + return fixed.Rectangle26_6{}, 0, false + } + xmin := +a.glyphBuf.Bounds.Min.X + ymin := -a.glyphBuf.Bounds.Max.Y + xmax := +a.glyphBuf.Bounds.Max.X + ymax := -a.glyphBuf.Bounds.Min.Y + if xmin > xmax || ymin > ymax { + return fixed.Rectangle26_6{}, 0, false + } + return fixed.Rectangle26_6{ + Min: fixed.Point26_6{ + X: xmin, + Y: ymin, + }, + Max: fixed.Point26_6{ + X: xmax, + Y: ymax, + }, + }, a.glyphBuf.AdvanceWidth, true +} + +func (a *face) GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) { + if err := a.glyphBuf.Load(a.f, a.scale, a.index(r), a.hinting); err != nil { + return 0, false + } + return a.glyphBuf.AdvanceWidth, true +} + +// rasterize returns the advance width, integer-pixel offset to render at, and +// the width and height of the given glyph at the given sub-pixel offsets. +// +// The 26.6 fixed point arguments fx and fy must be in the range [0, 1). +func (a *face) rasterize(index Index, fx, fy fixed.Int26_6) (v glyphCacheVal, ok bool) { + if err := a.glyphBuf.Load(a.f, a.scale, index, a.hinting); err != nil { + return glyphCacheVal{}, false + } + // Calculate the integer-pixel bounds for the glyph. + xmin := int(fx+a.glyphBuf.Bounds.Min.X) >> 6 + ymin := int(fy-a.glyphBuf.Bounds.Max.Y) >> 6 + xmax := int(fx+a.glyphBuf.Bounds.Max.X+0x3f) >> 6 + ymax := int(fy-a.glyphBuf.Bounds.Min.Y+0x3f) >> 6 + if xmin > xmax || ymin > ymax { + return glyphCacheVal{}, false + } + // A TrueType's glyph's nodes can have negative co-ordinates, but the + // rasterizer clips anything left of x=0 or above y=0. xmin and ymin are + // the pixel offsets, based on the font's FUnit metrics, that let a + // negative co-ordinate in TrueType space be non-negative in rasterizer + // space. xmin and ymin are typically <= 0. + fx -= fixed.Int26_6(xmin << 6) + fy -= fixed.Int26_6(ymin << 6) + // Rasterize the glyph's vectors. + a.r.Clear() + pixOffset := a.paintOffset * a.maxw + clear(a.masks.Pix[pixOffset : pixOffset+a.maxw*a.maxh]) + e0 := 0 + for _, e1 := range a.glyphBuf.Ends { + a.drawContour(a.glyphBuf.Points[e0:e1], fx, fy) + e0 = e1 + } + a.r.Rasterize(a.p) + return glyphCacheVal{ + a.glyphBuf.AdvanceWidth, + image.Point{xmin, ymin}, + xmax - xmin, + ymax - ymin, + }, true +} + +func clear(pix []byte) { + for i := range pix { + pix[i] = 0 + } +} + +// drawContour draws the given closed contour with the given offset. +func (a *face) drawContour(ps []Point, dx, dy fixed.Int26_6) { + if len(ps) == 0 { + return + } + + // The low bit of each point's Flags value is whether the point is on the + // curve. Truetype fonts only have quadratic Bézier curves, not cubics. + // Thus, two consecutive off-curve points imply an on-curve point in the + // middle of those two. + // + // See http://chanae.walon.org/pub/ttf/ttf_glyphs.htm for more details. + + // ps[0] is a truetype.Point measured in FUnits and positive Y going + // upwards. start is the same thing measured in fixed point units and + // positive Y going downwards, and offset by (dx, dy). + start := fixed.Point26_6{ + X: dx + ps[0].X, + Y: dy - ps[0].Y, + } + var others []Point + if ps[0].Flags&0x01 != 0 { + others = ps[1:] + } else { + last := fixed.Point26_6{ + X: dx + ps[len(ps)-1].X, + Y: dy - ps[len(ps)-1].Y, + } + if ps[len(ps)-1].Flags&0x01 != 0 { + start = last + others = ps[:len(ps)-1] + } else { + start = fixed.Point26_6{ + X: (start.X + last.X) / 2, + Y: (start.Y + last.Y) / 2, + } + others = ps + } + } + a.r.Start(start) + q0, on0 := start, true + for _, p := range others { + q := fixed.Point26_6{ + X: dx + p.X, + Y: dy - p.Y, + } + on := p.Flags&0x01 != 0 + if on { + if on0 { + a.r.Add1(q) + } else { + a.r.Add2(q0, q) + } + } else { + if on0 { + // No-op. + } else { + mid := fixed.Point26_6{ + X: (q0.X + q.X) / 2, + Y: (q0.Y + q.Y) / 2, + } + a.r.Add2(q0, mid) + } + } + q0, on0 = q, on + } + // Close the curve. + if on0 { + a.r.Add1(start) + } else { + a.r.Add2(q0, start) + } +} + +// facePainter is like a raster.AlphaSrcPainter, with an additional Y offset +// (face.paintOffset) to the painted spans. +type facePainter struct { + a *face +} + +func (p facePainter) Paint(ss []raster.Span, done bool) { + m := p.a.masks + b := m.Bounds() + b.Min.Y = p.a.paintOffset + b.Max.Y = p.a.paintOffset + p.a.maxh + for _, s := range ss { + s.Y += p.a.paintOffset + if s.Y < b.Min.Y { + continue + } + if s.Y >= b.Max.Y { + return + } + if s.X0 < b.Min.X { + s.X0 = b.Min.X + } + if s.X1 > b.Max.X { + s.X1 = b.Max.X + } + if s.X0 >= s.X1 { + continue + } + base := (s.Y-m.Rect.Min.Y)*m.Stride - m.Rect.Min.X + p := m.Pix[base+s.X0 : base+s.X1] + color := uint8(s.Alpha >> 8) + for i := range p { + p[i] = color + } + } +} diff --git a/vendor/github.com/golang/freetype/truetype/glyph.go b/vendor/github.com/golang/freetype/truetype/glyph.go new file mode 100644 index 00000000..c2935a58 --- /dev/null +++ b/vendor/github.com/golang/freetype/truetype/glyph.go @@ -0,0 +1,517 @@ +// Copyright 2010 The Freetype-Go Authors. All rights reserved. +// Use of this source code is governed by your choice of either the +// FreeType License or the GNU General Public License version 2 (or +// any later version), both of which can be found in the LICENSE file. + +package truetype + +import ( + "golang.org/x/image/font" + "golang.org/x/image/math/fixed" +) + +// TODO: implement VerticalHinting. + +// A Point is a co-ordinate pair plus whether it is 'on' a contour or an 'off' +// control point. +type Point struct { + X, Y fixed.Int26_6 + // The Flags' LSB means whether or not this Point is 'on' the contour. + // Other bits are reserved for internal use. + Flags uint32 +} + +// A GlyphBuf holds a glyph's contours. A GlyphBuf can be re-used to load a +// series of glyphs from a Font. +type GlyphBuf struct { + // AdvanceWidth is the glyph's advance width. + AdvanceWidth fixed.Int26_6 + // Bounds is the glyph's bounding box. + Bounds fixed.Rectangle26_6 + // Points contains all Points from all contours of the glyph. If hinting + // was used to load a glyph then Unhinted contains those Points before they + // were hinted, and InFontUnits contains those Points before they were + // hinted and scaled. + Points, Unhinted, InFontUnits []Point + // Ends is the point indexes of the end point of each contour. The length + // of Ends is the number of contours in the glyph. The i'th contour + // consists of points Points[Ends[i-1]:Ends[i]], where Ends[-1] is + // interpreted to mean zero. + Ends []int + + font *Font + scale fixed.Int26_6 + hinting font.Hinting + hinter hinter + // phantomPoints are the co-ordinates of the synthetic phantom points + // used for hinting and bounding box calculations. + phantomPoints [4]Point + // pp1x is the X co-ordinate of the first phantom point. The '1' is + // using 1-based indexing; pp1x is almost always phantomPoints[0].X. + // TODO: eliminate this and consistently use phantomPoints[0].X. + pp1x fixed.Int26_6 + // metricsSet is whether the glyph's metrics have been set yet. For a + // compound glyph, a sub-glyph may override the outer glyph's metrics. + metricsSet bool + // tmp is a scratch buffer. + tmp []Point +} + +// Flags for decoding a glyph's contours. These flags are documented at +// http://developer.apple.com/fonts/TTRefMan/RM06/Chap6glyf.html. +const ( + flagOnCurve = 1 << iota + flagXShortVector + flagYShortVector + flagRepeat + flagPositiveXShortVector + flagPositiveYShortVector + + // The remaining flags are for internal use. + flagTouchedX + flagTouchedY +) + +// The same flag bits (0x10 and 0x20) are overloaded to have two meanings, +// dependent on the value of the flag{X,Y}ShortVector bits. +const ( + flagThisXIsSame = flagPositiveXShortVector + flagThisYIsSame = flagPositiveYShortVector +) + +// Load loads a glyph's contours from a Font, overwriting any previously loaded +// contours for this GlyphBuf. scale is the number of 26.6 fixed point units in +// 1 em, i is the glyph index, and h is the hinting policy. +func (g *GlyphBuf) Load(f *Font, scale fixed.Int26_6, i Index, h font.Hinting) error { + g.Points = g.Points[:0] + g.Unhinted = g.Unhinted[:0] + g.InFontUnits = g.InFontUnits[:0] + g.Ends = g.Ends[:0] + g.font = f + g.hinting = h + g.scale = scale + g.pp1x = 0 + g.phantomPoints = [4]Point{} + g.metricsSet = false + + if h != font.HintingNone { + if err := g.hinter.init(f, scale); err != nil { + return err + } + } + if err := g.load(0, i, true); err != nil { + return err + } + // TODO: this selection of either g.pp1x or g.phantomPoints[0].X isn't ideal, + // and should be cleaned up once we have all the testScaling tests passing, + // plus additional tests for Freetype-Go's bounding boxes matching C Freetype's. + pp1x := g.pp1x + if h != font.HintingNone { + pp1x = g.phantomPoints[0].X + } + if pp1x != 0 { + for i := range g.Points { + g.Points[i].X -= pp1x + } + } + + advanceWidth := g.phantomPoints[1].X - g.phantomPoints[0].X + if h != font.HintingNone { + if len(f.hdmx) >= 8 { + if n := u32(f.hdmx, 4); n > 3+uint32(i) { + for hdmx := f.hdmx[8:]; uint32(len(hdmx)) >= n; hdmx = hdmx[n:] { + if fixed.Int26_6(hdmx[0]) == scale>>6 { + advanceWidth = fixed.Int26_6(hdmx[2+i]) << 6 + break + } + } + } + } + advanceWidth = (advanceWidth + 32) &^ 63 + } + g.AdvanceWidth = advanceWidth + + // Set g.Bounds to the 'control box', which is the bounding box of the + // Bézier curves' control points. This is easier to calculate, no smaller + // than and often equal to the tightest possible bounding box of the curves + // themselves. This approach is what C Freetype does. We can't just scale + // the nominal bounding box in the glyf data as the hinting process and + // phantom point adjustment may move points outside of that box. + if len(g.Points) == 0 { + g.Bounds = fixed.Rectangle26_6{} + } else { + p := g.Points[0] + g.Bounds.Min.X = p.X + g.Bounds.Max.X = p.X + g.Bounds.Min.Y = p.Y + g.Bounds.Max.Y = p.Y + for _, p := range g.Points[1:] { + if g.Bounds.Min.X > p.X { + g.Bounds.Min.X = p.X + } else if g.Bounds.Max.X < p.X { + g.Bounds.Max.X = p.X + } + if g.Bounds.Min.Y > p.Y { + g.Bounds.Min.Y = p.Y + } else if g.Bounds.Max.Y < p.Y { + g.Bounds.Max.Y = p.Y + } + } + // Snap the box to the grid, if hinting is on. + if h != font.HintingNone { + g.Bounds.Min.X &^= 63 + g.Bounds.Min.Y &^= 63 + g.Bounds.Max.X += 63 + g.Bounds.Max.X &^= 63 + g.Bounds.Max.Y += 63 + g.Bounds.Max.Y &^= 63 + } + } + return nil +} + +func (g *GlyphBuf) load(recursion uint32, i Index, useMyMetrics bool) (err error) { + // The recursion limit here is arbitrary, but defends against malformed glyphs. + if recursion >= 32 { + return UnsupportedError("excessive compound glyph recursion") + } + // Find the relevant slice of g.font.glyf. + var g0, g1 uint32 + if g.font.locaOffsetFormat == locaOffsetFormatShort { + g0 = 2 * uint32(u16(g.font.loca, 2*int(i))) + g1 = 2 * uint32(u16(g.font.loca, 2*int(i)+2)) + } else { + g0 = u32(g.font.loca, 4*int(i)) + g1 = u32(g.font.loca, 4*int(i)+4) + } + + // Decode the contour count and nominal bounding box, from the first + // 10 bytes of the glyf data. boundsYMin and boundsXMax, at offsets 4 + // and 6, are unused. + glyf, ne, boundsXMin, boundsYMax := []byte(nil), 0, fixed.Int26_6(0), fixed.Int26_6(0) + if g0+10 <= g1 { + glyf = g.font.glyf[g0:g1] + ne = int(int16(u16(glyf, 0))) + boundsXMin = fixed.Int26_6(int16(u16(glyf, 2))) + boundsYMax = fixed.Int26_6(int16(u16(glyf, 8))) + } + + // Create the phantom points. + uhm, pp1x := g.font.unscaledHMetric(i), fixed.Int26_6(0) + uvm := g.font.unscaledVMetric(i, boundsYMax) + g.phantomPoints = [4]Point{ + {X: boundsXMin - uhm.LeftSideBearing}, + {X: boundsXMin - uhm.LeftSideBearing + uhm.AdvanceWidth}, + {X: uhm.AdvanceWidth / 2, Y: boundsYMax + uvm.TopSideBearing}, + {X: uhm.AdvanceWidth / 2, Y: boundsYMax + uvm.TopSideBearing - uvm.AdvanceHeight}, + } + if len(glyf) == 0 { + g.addPhantomsAndScale(len(g.Points), len(g.Points), true, true) + copy(g.phantomPoints[:], g.Points[len(g.Points)-4:]) + g.Points = g.Points[:len(g.Points)-4] + return nil + } + + // Load and hint the contours. + if ne < 0 { + if ne != -1 { + // http://developer.apple.com/fonts/TTRefMan/RM06/Chap6glyf.html says that + // "the values -2, -3, and so forth, are reserved for future use." + return UnsupportedError("negative number of contours") + } + pp1x = g.font.scale(g.scale * (boundsXMin - uhm.LeftSideBearing)) + if err := g.loadCompound(recursion, uhm, i, glyf, useMyMetrics); err != nil { + return err + } + } else { + np0, ne0 := len(g.Points), len(g.Ends) + program := g.loadSimple(glyf, ne) + g.addPhantomsAndScale(np0, np0, true, true) + pp1x = g.Points[len(g.Points)-4].X + if g.hinting != font.HintingNone { + if len(program) != 0 { + err := g.hinter.run( + program, + g.Points[np0:], + g.Unhinted[np0:], + g.InFontUnits[np0:], + g.Ends[ne0:], + ) + if err != nil { + return err + } + } + // Drop the four phantom points. + g.InFontUnits = g.InFontUnits[:len(g.InFontUnits)-4] + g.Unhinted = g.Unhinted[:len(g.Unhinted)-4] + } + if useMyMetrics { + copy(g.phantomPoints[:], g.Points[len(g.Points)-4:]) + } + g.Points = g.Points[:len(g.Points)-4] + if np0 != 0 { + // The hinting program expects the []Ends values to be indexed + // relative to the inner glyph, not the outer glyph, so we delay + // adding np0 until after the hinting program (if any) has run. + for i := ne0; i < len(g.Ends); i++ { + g.Ends[i] += np0 + } + } + } + if useMyMetrics && !g.metricsSet { + g.metricsSet = true + g.pp1x = pp1x + } + return nil +} + +// loadOffset is the initial offset for loadSimple and loadCompound. The first +// 10 bytes are the number of contours and the bounding box. +const loadOffset = 10 + +func (g *GlyphBuf) loadSimple(glyf []byte, ne int) (program []byte) { + offset := loadOffset + for i := 0; i < ne; i++ { + g.Ends = append(g.Ends, 1+int(u16(glyf, offset))) + offset += 2 + } + + // Note the TrueType hinting instructions. + instrLen := int(u16(glyf, offset)) + offset += 2 + program = glyf[offset : offset+instrLen] + offset += instrLen + + np0 := len(g.Points) + np1 := np0 + int(g.Ends[len(g.Ends)-1]) + + // Decode the flags. + for i := np0; i < np1; { + c := uint32(glyf[offset]) + offset++ + g.Points = append(g.Points, Point{Flags: c}) + i++ + if c&flagRepeat != 0 { + count := glyf[offset] + offset++ + for ; count > 0; count-- { + g.Points = append(g.Points, Point{Flags: c}) + i++ + } + } + } + + // Decode the co-ordinates. + var x int16 + for i := np0; i < np1; i++ { + f := g.Points[i].Flags + if f&flagXShortVector != 0 { + dx := int16(glyf[offset]) + offset++ + if f&flagPositiveXShortVector == 0 { + x -= dx + } else { + x += dx + } + } else if f&flagThisXIsSame == 0 { + x += int16(u16(glyf, offset)) + offset += 2 + } + g.Points[i].X = fixed.Int26_6(x) + } + var y int16 + for i := np0; i < np1; i++ { + f := g.Points[i].Flags + if f&flagYShortVector != 0 { + dy := int16(glyf[offset]) + offset++ + if f&flagPositiveYShortVector == 0 { + y -= dy + } else { + y += dy + } + } else if f&flagThisYIsSame == 0 { + y += int16(u16(glyf, offset)) + offset += 2 + } + g.Points[i].Y = fixed.Int26_6(y) + } + + return program +} + +func (g *GlyphBuf) loadCompound(recursion uint32, uhm HMetric, i Index, + glyf []byte, useMyMetrics bool) error { + + // Flags for decoding a compound glyph. These flags are documented at + // http://developer.apple.com/fonts/TTRefMan/RM06/Chap6glyf.html. + const ( + flagArg1And2AreWords = 1 << iota + flagArgsAreXYValues + flagRoundXYToGrid + flagWeHaveAScale + flagUnused + flagMoreComponents + flagWeHaveAnXAndYScale + flagWeHaveATwoByTwo + flagWeHaveInstructions + flagUseMyMetrics + flagOverlapCompound + ) + np0, ne0 := len(g.Points), len(g.Ends) + offset := loadOffset + for { + flags := u16(glyf, offset) + component := Index(u16(glyf, offset+2)) + dx, dy, transform, hasTransform := fixed.Int26_6(0), fixed.Int26_6(0), [4]int16{}, false + if flags&flagArg1And2AreWords != 0 { + dx = fixed.Int26_6(int16(u16(glyf, offset+4))) + dy = fixed.Int26_6(int16(u16(glyf, offset+6))) + offset += 8 + } else { + dx = fixed.Int26_6(int16(int8(glyf[offset+4]))) + dy = fixed.Int26_6(int16(int8(glyf[offset+5]))) + offset += 6 + } + if flags&flagArgsAreXYValues == 0 { + return UnsupportedError("compound glyph transform vector") + } + if flags&(flagWeHaveAScale|flagWeHaveAnXAndYScale|flagWeHaveATwoByTwo) != 0 { + hasTransform = true + switch { + case flags&flagWeHaveAScale != 0: + transform[0] = int16(u16(glyf, offset+0)) + transform[3] = transform[0] + offset += 2 + case flags&flagWeHaveAnXAndYScale != 0: + transform[0] = int16(u16(glyf, offset+0)) + transform[3] = int16(u16(glyf, offset+2)) + offset += 4 + case flags&flagWeHaveATwoByTwo != 0: + transform[0] = int16(u16(glyf, offset+0)) + transform[1] = int16(u16(glyf, offset+2)) + transform[2] = int16(u16(glyf, offset+4)) + transform[3] = int16(u16(glyf, offset+6)) + offset += 8 + } + } + savedPP := g.phantomPoints + np0 := len(g.Points) + componentUMM := useMyMetrics && (flags&flagUseMyMetrics != 0) + if err := g.load(recursion+1, component, componentUMM); err != nil { + return err + } + if flags&flagUseMyMetrics == 0 { + g.phantomPoints = savedPP + } + if hasTransform { + for j := np0; j < len(g.Points); j++ { + p := &g.Points[j] + newX := 0 + + fixed.Int26_6((int64(p.X)*int64(transform[0])+1<<13)>>14) + + fixed.Int26_6((int64(p.Y)*int64(transform[2])+1<<13)>>14) + newY := 0 + + fixed.Int26_6((int64(p.X)*int64(transform[1])+1<<13)>>14) + + fixed.Int26_6((int64(p.Y)*int64(transform[3])+1<<13)>>14) + p.X, p.Y = newX, newY + } + } + dx = g.font.scale(g.scale * dx) + dy = g.font.scale(g.scale * dy) + if flags&flagRoundXYToGrid != 0 { + dx = (dx + 32) &^ 63 + dy = (dy + 32) &^ 63 + } + for j := np0; j < len(g.Points); j++ { + p := &g.Points[j] + p.X += dx + p.Y += dy + } + // TODO: also adjust g.InFontUnits and g.Unhinted? + if flags&flagMoreComponents == 0 { + break + } + } + + instrLen := 0 + if g.hinting != font.HintingNone && offset+2 <= len(glyf) { + instrLen = int(u16(glyf, offset)) + offset += 2 + } + + g.addPhantomsAndScale(np0, len(g.Points), false, instrLen > 0) + points, ends := g.Points[np0:], g.Ends[ne0:] + g.Points = g.Points[:len(g.Points)-4] + for j := range points { + points[j].Flags &^= flagTouchedX | flagTouchedY + } + + if instrLen == 0 { + if !g.metricsSet { + copy(g.phantomPoints[:], points[len(points)-4:]) + } + return nil + } + + // Hint the compound glyph. + program := glyf[offset : offset+instrLen] + // Temporarily adjust the ends to be relative to this compound glyph. + if np0 != 0 { + for i := range ends { + ends[i] -= np0 + } + } + // Hinting instructions of a composite glyph completely refer to the + // (already) hinted subglyphs. + g.tmp = append(g.tmp[:0], points...) + if err := g.hinter.run(program, points, g.tmp, g.tmp, ends); err != nil { + return err + } + if np0 != 0 { + for i := range ends { + ends[i] += np0 + } + } + if !g.metricsSet { + copy(g.phantomPoints[:], points[len(points)-4:]) + } + return nil +} + +func (g *GlyphBuf) addPhantomsAndScale(np0, np1 int, simple, adjust bool) { + // Add the four phantom points. + g.Points = append(g.Points, g.phantomPoints[:]...) + // Scale the points. + if simple && g.hinting != font.HintingNone { + g.InFontUnits = append(g.InFontUnits, g.Points[np1:]...) + } + for i := np1; i < len(g.Points); i++ { + p := &g.Points[i] + p.X = g.font.scale(g.scale * p.X) + p.Y = g.font.scale(g.scale * p.Y) + } + if g.hinting == font.HintingNone { + return + } + // Round the 1st phantom point to the grid, shifting all other points equally. + // Note that "all other points" starts from np0, not np1. + // TODO: delete this adjustment and the np0/np1 distinction, when + // we update the compatibility tests to C Freetype 2.5.3. + // See http://git.savannah.gnu.org/cgit/freetype/freetype2.git/commit/?id=05c786d990390a7ca18e62962641dac740bacb06 + if adjust { + pp1x := g.Points[len(g.Points)-4].X + if dx := ((pp1x + 32) &^ 63) - pp1x; dx != 0 { + for i := np0; i < len(g.Points); i++ { + g.Points[i].X += dx + } + } + } + if simple { + g.Unhinted = append(g.Unhinted, g.Points[np1:]...) + } + // Round the 2nd and 4th phantom point to the grid. + p := &g.Points[len(g.Points)-3] + p.X = (p.X + 32) &^ 63 + p = &g.Points[len(g.Points)-1] + p.Y = (p.Y + 32) &^ 63 +} diff --git a/vendor/github.com/golang/freetype/truetype/hint.go b/vendor/github.com/golang/freetype/truetype/hint.go new file mode 100644 index 00000000..13f785bc --- /dev/null +++ b/vendor/github.com/golang/freetype/truetype/hint.go @@ -0,0 +1,1770 @@ +// Copyright 2012 The Freetype-Go Authors. All rights reserved. +// Use of this source code is governed by your choice of either the +// FreeType License or the GNU General Public License version 2 (or +// any later version), both of which can be found in the LICENSE file. + +package truetype + +// This file implements a Truetype bytecode interpreter. +// The opcodes are described at https://developer.apple.com/fonts/TTRefMan/RM05/Chap5.html + +import ( + "errors" + "math" + + "golang.org/x/image/math/fixed" +) + +const ( + twilightZone = 0 + glyphZone = 1 + numZone = 2 +) + +type pointType uint32 + +const ( + current pointType = 0 + unhinted pointType = 1 + inFontUnits pointType = 2 + numPointType = 3 +) + +// callStackEntry is a bytecode call stack entry. +type callStackEntry struct { + program []byte + pc int + loopCount int32 +} + +// hinter implements bytecode hinting. A hinter can be re-used to hint a series +// of glyphs from a Font. +type hinter struct { + stack, store []int32 + + // functions is a map from function number to bytecode. + functions map[int32][]byte + + // font and scale are the font and scale last used for this hinter. + // Changing the font will require running the new font's fpgm bytecode. + // Changing either will require running the font's prep bytecode. + font *Font + scale fixed.Int26_6 + + // gs and defaultGS are the current and default graphics state. The + // default graphics state is the global default graphics state after + // the font's fpgm and prep programs have been run. + gs, defaultGS graphicsState + + // points and ends are the twilight zone's points, glyph's points + // and glyph's contour boundaries. + points [numZone][numPointType][]Point + ends []int + + // scaledCVT is the lazily initialized scaled Control Value Table. + scaledCVTInitialized bool + scaledCVT []fixed.Int26_6 +} + +// graphicsState is described at https://developer.apple.com/fonts/TTRefMan/RM04/Chap4.html +type graphicsState struct { + // Projection vector, freedom vector and dual projection vector. + pv, fv, dv [2]f2dot14 + // Reference points and zone pointers. + rp, zp [3]int32 + // Control Value / Single Width Cut-In. + controlValueCutIn, singleWidthCutIn, singleWidth fixed.Int26_6 + // Delta base / shift. + deltaBase, deltaShift int32 + // Minimum distance. + minDist fixed.Int26_6 + // Loop count. + loop int32 + // Rounding policy. + roundPeriod, roundPhase, roundThreshold fixed.Int26_6 + roundSuper45 bool + // Auto-flip. + autoFlip bool +} + +var globalDefaultGS = graphicsState{ + pv: [2]f2dot14{0x4000, 0}, // Unit vector along the X axis. + fv: [2]f2dot14{0x4000, 0}, + dv: [2]f2dot14{0x4000, 0}, + zp: [3]int32{1, 1, 1}, + controlValueCutIn: (17 << 6) / 16, // 17/16 as a fixed.Int26_6. + deltaBase: 9, + deltaShift: 3, + minDist: 1 << 6, // 1 as a fixed.Int26_6. + loop: 1, + roundPeriod: 1 << 6, // 1 as a fixed.Int26_6. + roundThreshold: 1 << 5, // 1/2 as a fixed.Int26_6. + roundSuper45: false, + autoFlip: true, +} + +func resetTwilightPoints(f *Font, p []Point) []Point { + if n := int(f.maxTwilightPoints) + 4; n <= cap(p) { + p = p[:n] + for i := range p { + p[i] = Point{} + } + } else { + p = make([]Point, n) + } + return p +} + +func (h *hinter) init(f *Font, scale fixed.Int26_6) error { + h.points[twilightZone][0] = resetTwilightPoints(f, h.points[twilightZone][0]) + h.points[twilightZone][1] = resetTwilightPoints(f, h.points[twilightZone][1]) + h.points[twilightZone][2] = resetTwilightPoints(f, h.points[twilightZone][2]) + + rescale := h.scale != scale + if h.font != f { + h.font, rescale = f, true + if h.functions == nil { + h.functions = make(map[int32][]byte) + } else { + for k := range h.functions { + delete(h.functions, k) + } + } + + if x := int(f.maxStackElements); x > len(h.stack) { + x += 255 + x &^= 255 + h.stack = make([]int32, x) + } + if x := int(f.maxStorage); x > len(h.store) { + x += 15 + x &^= 15 + h.store = make([]int32, x) + } + if len(f.fpgm) != 0 { + if err := h.run(f.fpgm, nil, nil, nil, nil); err != nil { + return err + } + } + } + + if rescale { + h.scale = scale + h.scaledCVTInitialized = false + + h.defaultGS = globalDefaultGS + + if len(f.prep) != 0 { + if err := h.run(f.prep, nil, nil, nil, nil); err != nil { + return err + } + h.defaultGS = h.gs + // The MS rasterizer doesn't allow the following graphics state + // variables to be modified by the CVT program. + h.defaultGS.pv = globalDefaultGS.pv + h.defaultGS.fv = globalDefaultGS.fv + h.defaultGS.dv = globalDefaultGS.dv + h.defaultGS.rp = globalDefaultGS.rp + h.defaultGS.zp = globalDefaultGS.zp + h.defaultGS.loop = globalDefaultGS.loop + } + } + return nil +} + +func (h *hinter) run(program []byte, pCurrent, pUnhinted, pInFontUnits []Point, ends []int) error { + h.gs = h.defaultGS + h.points[glyphZone][current] = pCurrent + h.points[glyphZone][unhinted] = pUnhinted + h.points[glyphZone][inFontUnits] = pInFontUnits + h.ends = ends + + if len(program) > 50000 { + return errors.New("truetype: hinting: too many instructions") + } + var ( + steps, pc, top int + opcode uint8 + + callStack [32]callStackEntry + callStackTop int + ) + + for 0 <= pc && pc < len(program) { + steps++ + if steps == 100000 { + return errors.New("truetype: hinting: too many steps") + } + opcode = program[pc] + if top < int(popCount[opcode]) { + return errors.New("truetype: hinting: stack underflow") + } + switch opcode { + + case opSVTCA0: + h.gs.pv = [2]f2dot14{0, 0x4000} + h.gs.fv = [2]f2dot14{0, 0x4000} + h.gs.dv = [2]f2dot14{0, 0x4000} + + case opSVTCA1: + h.gs.pv = [2]f2dot14{0x4000, 0} + h.gs.fv = [2]f2dot14{0x4000, 0} + h.gs.dv = [2]f2dot14{0x4000, 0} + + case opSPVTCA0: + h.gs.pv = [2]f2dot14{0, 0x4000} + h.gs.dv = [2]f2dot14{0, 0x4000} + + case opSPVTCA1: + h.gs.pv = [2]f2dot14{0x4000, 0} + h.gs.dv = [2]f2dot14{0x4000, 0} + + case opSFVTCA0: + h.gs.fv = [2]f2dot14{0, 0x4000} + + case opSFVTCA1: + h.gs.fv = [2]f2dot14{0x4000, 0} + + case opSPVTL0, opSPVTL1, opSFVTL0, opSFVTL1: + top -= 2 + p1 := h.point(0, current, h.stack[top+0]) + p2 := h.point(0, current, h.stack[top+1]) + if p1 == nil || p2 == nil { + return errors.New("truetype: hinting: point out of range") + } + dx := f2dot14(p1.X - p2.X) + dy := f2dot14(p1.Y - p2.Y) + if dx == 0 && dy == 0 { + dx = 0x4000 + } else if opcode&1 != 0 { + // Counter-clockwise rotation. + dx, dy = -dy, dx + } + v := normalize(dx, dy) + if opcode < opSFVTL0 { + h.gs.pv = v + h.gs.dv = v + } else { + h.gs.fv = v + } + + case opSPVFS: + top -= 2 + h.gs.pv = normalize(f2dot14(h.stack[top]), f2dot14(h.stack[top+1])) + h.gs.dv = h.gs.pv + + case opSFVFS: + top -= 2 + h.gs.fv = normalize(f2dot14(h.stack[top]), f2dot14(h.stack[top+1])) + + case opGPV: + if top+1 >= len(h.stack) { + return errors.New("truetype: hinting: stack overflow") + } + h.stack[top+0] = int32(h.gs.pv[0]) + h.stack[top+1] = int32(h.gs.pv[1]) + top += 2 + + case opGFV: + if top+1 >= len(h.stack) { + return errors.New("truetype: hinting: stack overflow") + } + h.stack[top+0] = int32(h.gs.fv[0]) + h.stack[top+1] = int32(h.gs.fv[1]) + top += 2 + + case opSFVTPV: + h.gs.fv = h.gs.pv + + case opISECT: + top -= 5 + p := h.point(2, current, h.stack[top+0]) + a0 := h.point(1, current, h.stack[top+1]) + a1 := h.point(1, current, h.stack[top+2]) + b0 := h.point(0, current, h.stack[top+3]) + b1 := h.point(0, current, h.stack[top+4]) + if p == nil || a0 == nil || a1 == nil || b0 == nil || b1 == nil { + return errors.New("truetype: hinting: point out of range") + } + + dbx := b1.X - b0.X + dby := b1.Y - b0.Y + dax := a1.X - a0.X + day := a1.Y - a0.Y + dx := b0.X - a0.X + dy := b0.Y - a0.Y + discriminant := mulDiv(int64(dax), int64(-dby), 0x40) + + mulDiv(int64(day), int64(dbx), 0x40) + dotProduct := mulDiv(int64(dax), int64(dbx), 0x40) + + mulDiv(int64(day), int64(dby), 0x40) + // The discriminant above is actually a cross product of vectors + // da and db. Together with the dot product, they can be used as + // surrogates for sine and cosine of the angle between the vectors. + // Indeed, + // dotproduct = |da||db|cos(angle) + // discriminant = |da||db|sin(angle) + // We use these equations to reject grazing intersections by + // thresholding abs(tan(angle)) at 1/19, corresponding to 3 degrees. + absDisc, absDotP := discriminant, dotProduct + if absDisc < 0 { + absDisc = -absDisc + } + if absDotP < 0 { + absDotP = -absDotP + } + if 19*absDisc > absDotP { + val := mulDiv(int64(dx), int64(-dby), 0x40) + + mulDiv(int64(dy), int64(dbx), 0x40) + rx := mulDiv(val, int64(dax), discriminant) + ry := mulDiv(val, int64(day), discriminant) + p.X = a0.X + fixed.Int26_6(rx) + p.Y = a0.Y + fixed.Int26_6(ry) + } else { + p.X = (a0.X + a1.X + b0.X + b1.X) / 4 + p.Y = (a0.Y + a1.Y + b0.Y + b1.Y) / 4 + } + p.Flags |= flagTouchedX | flagTouchedY + + case opSRP0, opSRP1, opSRP2: + top-- + h.gs.rp[opcode-opSRP0] = h.stack[top] + + case opSZP0, opSZP1, opSZP2: + top-- + h.gs.zp[opcode-opSZP0] = h.stack[top] + + case opSZPS: + top-- + h.gs.zp[0] = h.stack[top] + h.gs.zp[1] = h.stack[top] + h.gs.zp[2] = h.stack[top] + + case opSLOOP: + top-- + // https://developer.apple.com/fonts/TrueType-Reference-Manual/RM05/Chap5.html#SLOOP + // says that "Setting the loop variable to zero is an error". In + // theory, the inequality on the next line should be "<=" instead + // of "<". In practice, some font files' bytecode, such as the '2' + // glyph in the DejaVuSansMono.ttf that comes with Ubuntu 14.04, + // issue SLOOP with a zero on top of the stack. Just like the C + // Freetype code, we allow the zero. + if h.stack[top] < 0 { + return errors.New("truetype: hinting: invalid data") + } + h.gs.loop = h.stack[top] + + case opRTG: + h.gs.roundPeriod = 1 << 6 + h.gs.roundPhase = 0 + h.gs.roundThreshold = 1 << 5 + h.gs.roundSuper45 = false + + case opRTHG: + h.gs.roundPeriod = 1 << 6 + h.gs.roundPhase = 1 << 5 + h.gs.roundThreshold = 1 << 5 + h.gs.roundSuper45 = false + + case opSMD: + top-- + h.gs.minDist = fixed.Int26_6(h.stack[top]) + + case opELSE: + opcode = 1 + goto ifelse + + case opJMPR: + top-- + pc += int(h.stack[top]) + continue + + case opSCVTCI: + top-- + h.gs.controlValueCutIn = fixed.Int26_6(h.stack[top]) + + case opSSWCI: + top-- + h.gs.singleWidthCutIn = fixed.Int26_6(h.stack[top]) + + case opSSW: + top-- + h.gs.singleWidth = h.font.scale(h.scale * fixed.Int26_6(h.stack[top])) + + case opDUP: + if top >= len(h.stack) { + return errors.New("truetype: hinting: stack overflow") + } + h.stack[top] = h.stack[top-1] + top++ + + case opPOP: + top-- + + case opCLEAR: + top = 0 + + case opSWAP: + h.stack[top-1], h.stack[top-2] = h.stack[top-2], h.stack[top-1] + + case opDEPTH: + if top >= len(h.stack) { + return errors.New("truetype: hinting: stack overflow") + } + h.stack[top] = int32(top) + top++ + + case opCINDEX, opMINDEX: + x := int(h.stack[top-1]) + if x <= 0 || x >= top { + return errors.New("truetype: hinting: invalid data") + } + h.stack[top-1] = h.stack[top-1-x] + if opcode == opMINDEX { + copy(h.stack[top-1-x:top-1], h.stack[top-x:top]) + top-- + } + + case opALIGNPTS: + top -= 2 + p := h.point(1, current, h.stack[top]) + q := h.point(0, current, h.stack[top+1]) + if p == nil || q == nil { + return errors.New("truetype: hinting: point out of range") + } + d := dotProduct(fixed.Int26_6(q.X-p.X), fixed.Int26_6(q.Y-p.Y), h.gs.pv) / 2 + h.move(p, +d, true) + h.move(q, -d, true) + + case opUTP: + top-- + p := h.point(0, current, h.stack[top]) + if p == nil { + return errors.New("truetype: hinting: point out of range") + } + p.Flags &^= flagTouchedX | flagTouchedY + + case opLOOPCALL, opCALL: + if callStackTop >= len(callStack) { + return errors.New("truetype: hinting: call stack overflow") + } + top-- + f, ok := h.functions[h.stack[top]] + if !ok { + return errors.New("truetype: hinting: undefined function") + } + callStack[callStackTop] = callStackEntry{program, pc, 1} + if opcode == opLOOPCALL { + top-- + if h.stack[top] == 0 { + break + } + callStack[callStackTop].loopCount = h.stack[top] + } + callStackTop++ + program, pc = f, 0 + continue + + case opFDEF: + // Save all bytecode up until the next ENDF. + startPC := pc + 1 + fdefloop: + for { + pc++ + if pc >= len(program) { + return errors.New("truetype: hinting: unbalanced FDEF") + } + switch program[pc] { + case opFDEF: + return errors.New("truetype: hinting: nested FDEF") + case opENDF: + top-- + h.functions[h.stack[top]] = program[startPC : pc+1] + break fdefloop + default: + var ok bool + pc, ok = skipInstructionPayload(program, pc) + if !ok { + return errors.New("truetype: hinting: unbalanced FDEF") + } + } + } + + case opENDF: + if callStackTop == 0 { + return errors.New("truetype: hinting: call stack underflow") + } + callStackTop-- + callStack[callStackTop].loopCount-- + if callStack[callStackTop].loopCount != 0 { + callStackTop++ + pc = 0 + continue + } + program, pc = callStack[callStackTop].program, callStack[callStackTop].pc + + case opMDAP0, opMDAP1: + top-- + i := h.stack[top] + p := h.point(0, current, i) + if p == nil { + return errors.New("truetype: hinting: point out of range") + } + distance := fixed.Int26_6(0) + if opcode == opMDAP1 { + distance = dotProduct(p.X, p.Y, h.gs.pv) + // TODO: metrics compensation. + distance = h.round(distance) - distance + } + h.move(p, distance, true) + h.gs.rp[0] = i + h.gs.rp[1] = i + + case opIUP0, opIUP1: + iupY, mask := opcode == opIUP0, uint32(flagTouchedX) + if iupY { + mask = flagTouchedY + } + prevEnd := 0 + for _, end := range h.ends { + for i := prevEnd; i < end; i++ { + for i < end && h.points[glyphZone][current][i].Flags&mask == 0 { + i++ + } + if i == end { + break + } + firstTouched, curTouched := i, i + i++ + for ; i < end; i++ { + if h.points[glyphZone][current][i].Flags&mask != 0 { + h.iupInterp(iupY, curTouched+1, i-1, curTouched, i) + curTouched = i + } + } + if curTouched == firstTouched { + h.iupShift(iupY, prevEnd, end, curTouched) + } else { + h.iupInterp(iupY, curTouched+1, end-1, curTouched, firstTouched) + if firstTouched > 0 { + h.iupInterp(iupY, prevEnd, firstTouched-1, curTouched, firstTouched) + } + } + } + prevEnd = end + } + + case opSHP0, opSHP1: + if top < int(h.gs.loop) { + return errors.New("truetype: hinting: stack underflow") + } + _, _, d, ok := h.displacement(opcode&1 == 0) + if !ok { + return errors.New("truetype: hinting: point out of range") + } + for ; h.gs.loop != 0; h.gs.loop-- { + top-- + p := h.point(2, current, h.stack[top]) + if p == nil { + return errors.New("truetype: hinting: point out of range") + } + h.move(p, d, true) + } + h.gs.loop = 1 + + case opSHC0, opSHC1: + top-- + zonePointer, i, d, ok := h.displacement(opcode&1 == 0) + if !ok { + return errors.New("truetype: hinting: point out of range") + } + if h.gs.zp[2] == 0 { + // TODO: implement this when we have a glyph that does this. + return errors.New("hinting: unimplemented SHC instruction") + } + contour := h.stack[top] + if contour < 0 || len(ends) <= int(contour) { + return errors.New("truetype: hinting: contour out of range") + } + j0, j1 := int32(0), int32(h.ends[contour]) + if contour > 0 { + j0 = int32(h.ends[contour-1]) + } + move := h.gs.zp[zonePointer] != h.gs.zp[2] + for j := j0; j < j1; j++ { + if move || j != i { + h.move(h.point(2, current, j), d, true) + } + } + + case opSHZ0, opSHZ1: + top-- + zonePointer, i, d, ok := h.displacement(opcode&1 == 0) + if !ok { + return errors.New("truetype: hinting: point out of range") + } + + // As per C Freetype, SHZ doesn't move the phantom points, or mark + // the points as touched. + limit := int32(len(h.points[h.gs.zp[2]][current])) + if h.gs.zp[2] == glyphZone { + limit -= 4 + } + for j := int32(0); j < limit; j++ { + if i != j || h.gs.zp[zonePointer] != h.gs.zp[2] { + h.move(h.point(2, current, j), d, false) + } + } + + case opSHPIX: + top-- + d := fixed.Int26_6(h.stack[top]) + if top < int(h.gs.loop) { + return errors.New("truetype: hinting: stack underflow") + } + for ; h.gs.loop != 0; h.gs.loop-- { + top-- + p := h.point(2, current, h.stack[top]) + if p == nil { + return errors.New("truetype: hinting: point out of range") + } + h.move(p, d, true) + } + h.gs.loop = 1 + + case opIP: + if top < int(h.gs.loop) { + return errors.New("truetype: hinting: stack underflow") + } + pointType := inFontUnits + twilight := h.gs.zp[0] == 0 || h.gs.zp[1] == 0 || h.gs.zp[2] == 0 + if twilight { + pointType = unhinted + } + p := h.point(1, pointType, h.gs.rp[2]) + oldP := h.point(0, pointType, h.gs.rp[1]) + oldRange := dotProduct(p.X-oldP.X, p.Y-oldP.Y, h.gs.dv) + + p = h.point(1, current, h.gs.rp[2]) + curP := h.point(0, current, h.gs.rp[1]) + curRange := dotProduct(p.X-curP.X, p.Y-curP.Y, h.gs.pv) + for ; h.gs.loop != 0; h.gs.loop-- { + top-- + i := h.stack[top] + p = h.point(2, pointType, i) + oldDist := dotProduct(p.X-oldP.X, p.Y-oldP.Y, h.gs.dv) + p = h.point(2, current, i) + curDist := dotProduct(p.X-curP.X, p.Y-curP.Y, h.gs.pv) + newDist := fixed.Int26_6(0) + if oldDist != 0 { + if oldRange != 0 { + newDist = fixed.Int26_6(mulDiv(int64(oldDist), int64(curRange), int64(oldRange))) + } else { + newDist = -oldDist + } + } + h.move(p, newDist-curDist, true) + } + h.gs.loop = 1 + + case opMSIRP0, opMSIRP1: + top -= 2 + i := h.stack[top] + distance := fixed.Int26_6(h.stack[top+1]) + + // TODO: special case h.gs.zp[1] == 0 in C Freetype. + ref := h.point(0, current, h.gs.rp[0]) + p := h.point(1, current, i) + if ref == nil || p == nil { + return errors.New("truetype: hinting: point out of range") + } + curDist := dotProduct(p.X-ref.X, p.Y-ref.Y, h.gs.pv) + + // Set-RP0 bit. + if opcode == opMSIRP1 { + h.gs.rp[0] = i + } + h.gs.rp[1] = h.gs.rp[0] + h.gs.rp[2] = i + + // Move the point. + h.move(p, distance-curDist, true) + + case opALIGNRP: + if top < int(h.gs.loop) { + return errors.New("truetype: hinting: stack underflow") + } + ref := h.point(0, current, h.gs.rp[0]) + if ref == nil { + return errors.New("truetype: hinting: point out of range") + } + for ; h.gs.loop != 0; h.gs.loop-- { + top-- + p := h.point(1, current, h.stack[top]) + if p == nil { + return errors.New("truetype: hinting: point out of range") + } + h.move(p, -dotProduct(p.X-ref.X, p.Y-ref.Y, h.gs.pv), true) + } + h.gs.loop = 1 + + case opRTDG: + h.gs.roundPeriod = 1 << 5 + h.gs.roundPhase = 0 + h.gs.roundThreshold = 1 << 4 + h.gs.roundSuper45 = false + + case opMIAP0, opMIAP1: + top -= 2 + i := h.stack[top] + distance := h.getScaledCVT(h.stack[top+1]) + if h.gs.zp[0] == 0 { + p := h.point(0, unhinted, i) + q := h.point(0, current, i) + p.X = fixed.Int26_6((int64(distance) * int64(h.gs.fv[0])) >> 14) + p.Y = fixed.Int26_6((int64(distance) * int64(h.gs.fv[1])) >> 14) + *q = *p + } + p := h.point(0, current, i) + oldDist := dotProduct(p.X, p.Y, h.gs.pv) + if opcode == opMIAP1 { + if fabs(distance-oldDist) > h.gs.controlValueCutIn { + distance = oldDist + } + // TODO: metrics compensation. + distance = h.round(distance) + } + h.move(p, distance-oldDist, true) + h.gs.rp[0] = i + h.gs.rp[1] = i + + case opNPUSHB: + opcode = 0 + goto push + + case opNPUSHW: + opcode = 0x80 + goto push + + case opWS: + top -= 2 + i := int(h.stack[top]) + if i < 0 || len(h.store) <= i { + return errors.New("truetype: hinting: invalid data") + } + h.store[i] = h.stack[top+1] + + case opRS: + i := int(h.stack[top-1]) + if i < 0 || len(h.store) <= i { + return errors.New("truetype: hinting: invalid data") + } + h.stack[top-1] = h.store[i] + + case opWCVTP: + top -= 2 + h.setScaledCVT(h.stack[top], fixed.Int26_6(h.stack[top+1])) + + case opRCVT: + h.stack[top-1] = int32(h.getScaledCVT(h.stack[top-1])) + + case opGC0, opGC1: + i := h.stack[top-1] + if opcode == opGC0 { + p := h.point(2, current, i) + h.stack[top-1] = int32(dotProduct(p.X, p.Y, h.gs.pv)) + } else { + p := h.point(2, unhinted, i) + // Using dv as per C Freetype. + h.stack[top-1] = int32(dotProduct(p.X, p.Y, h.gs.dv)) + } + + case opSCFS: + top -= 2 + i := h.stack[top] + p := h.point(2, current, i) + if p == nil { + return errors.New("truetype: hinting: point out of range") + } + c := dotProduct(p.X, p.Y, h.gs.pv) + h.move(p, fixed.Int26_6(h.stack[top+1])-c, true) + if h.gs.zp[2] != 0 { + break + } + q := h.point(2, unhinted, i) + if q == nil { + return errors.New("truetype: hinting: point out of range") + } + q.X = p.X + q.Y = p.Y + + case opMD0, opMD1: + top-- + pt, v, scale := pointType(0), [2]f2dot14{}, false + if opcode == opMD0 { + pt = current + v = h.gs.pv + } else if h.gs.zp[0] == 0 || h.gs.zp[1] == 0 { + pt = unhinted + v = h.gs.dv + } else { + pt = inFontUnits + v = h.gs.dv + scale = true + } + p := h.point(0, pt, h.stack[top-1]) + q := h.point(1, pt, h.stack[top]) + if p == nil || q == nil { + return errors.New("truetype: hinting: point out of range") + } + d := int32(dotProduct(p.X-q.X, p.Y-q.Y, v)) + if scale { + d = int32(int64(d*int32(h.scale)) / int64(h.font.fUnitsPerEm)) + } + h.stack[top-1] = d + + case opMPPEM, opMPS: + if top >= len(h.stack) { + return errors.New("truetype: hinting: stack overflow") + } + // For MPS, point size should be irrelevant; we return the PPEM. + h.stack[top] = int32(h.scale) >> 6 + top++ + + case opFLIPON, opFLIPOFF: + h.gs.autoFlip = opcode == opFLIPON + + case opDEBUG: + // No-op. + + case opLT: + top-- + h.stack[top-1] = bool2int32(h.stack[top-1] < h.stack[top]) + + case opLTEQ: + top-- + h.stack[top-1] = bool2int32(h.stack[top-1] <= h.stack[top]) + + case opGT: + top-- + h.stack[top-1] = bool2int32(h.stack[top-1] > h.stack[top]) + + case opGTEQ: + top-- + h.stack[top-1] = bool2int32(h.stack[top-1] >= h.stack[top]) + + case opEQ: + top-- + h.stack[top-1] = bool2int32(h.stack[top-1] == h.stack[top]) + + case opNEQ: + top-- + h.stack[top-1] = bool2int32(h.stack[top-1] != h.stack[top]) + + case opODD, opEVEN: + i := h.round(fixed.Int26_6(h.stack[top-1])) >> 6 + h.stack[top-1] = int32(i&1) ^ int32(opcode-opODD) + + case opIF: + top-- + if h.stack[top] == 0 { + opcode = 0 + goto ifelse + } + + case opEIF: + // No-op. + + case opAND: + top-- + h.stack[top-1] = bool2int32(h.stack[top-1] != 0 && h.stack[top] != 0) + + case opOR: + top-- + h.stack[top-1] = bool2int32(h.stack[top-1]|h.stack[top] != 0) + + case opNOT: + h.stack[top-1] = bool2int32(h.stack[top-1] == 0) + + case opDELTAP1: + goto delta + + case opSDB: + top-- + h.gs.deltaBase = h.stack[top] + + case opSDS: + top-- + h.gs.deltaShift = h.stack[top] + + case opADD: + top-- + h.stack[top-1] += h.stack[top] + + case opSUB: + top-- + h.stack[top-1] -= h.stack[top] + + case opDIV: + top-- + if h.stack[top] == 0 { + return errors.New("truetype: hinting: division by zero") + } + h.stack[top-1] = int32(fdiv(fixed.Int26_6(h.stack[top-1]), fixed.Int26_6(h.stack[top]))) + + case opMUL: + top-- + h.stack[top-1] = int32(fmul(fixed.Int26_6(h.stack[top-1]), fixed.Int26_6(h.stack[top]))) + + case opABS: + if h.stack[top-1] < 0 { + h.stack[top-1] = -h.stack[top-1] + } + + case opNEG: + h.stack[top-1] = -h.stack[top-1] + + case opFLOOR: + h.stack[top-1] &^= 63 + + case opCEILING: + h.stack[top-1] += 63 + h.stack[top-1] &^= 63 + + case opROUND00, opROUND01, opROUND10, opROUND11: + // The four flavors of opROUND are equivalent. See the comment below on + // opNROUND for the rationale. + h.stack[top-1] = int32(h.round(fixed.Int26_6(h.stack[top-1]))) + + case opNROUND00, opNROUND01, opNROUND10, opNROUND11: + // No-op. The spec says to add one of four "compensations for the engine + // characteristics", to cater for things like "different dot-size printers". + // https://developer.apple.com/fonts/TTRefMan/RM02/Chap2.html#engine_compensation + // This code does not implement engine compensation, as we don't expect to + // be used to output on dot-matrix printers. + + case opWCVTF: + top -= 2 + h.setScaledCVT(h.stack[top], h.font.scale(h.scale*fixed.Int26_6(h.stack[top+1]))) + + case opDELTAP2, opDELTAP3, opDELTAC1, opDELTAC2, opDELTAC3: + goto delta + + case opSROUND, opS45ROUND: + top-- + switch (h.stack[top] >> 6) & 0x03 { + case 0: + h.gs.roundPeriod = 1 << 5 + case 1, 3: + h.gs.roundPeriod = 1 << 6 + case 2: + h.gs.roundPeriod = 1 << 7 + } + h.gs.roundSuper45 = opcode == opS45ROUND + if h.gs.roundSuper45 { + // The spec says to multiply by √2, but the C Freetype code says 1/√2. + // We go with 1/√2. + h.gs.roundPeriod *= 46341 + h.gs.roundPeriod /= 65536 + } + h.gs.roundPhase = h.gs.roundPeriod * fixed.Int26_6((h.stack[top]>>4)&0x03) / 4 + if x := h.stack[top] & 0x0f; x != 0 { + h.gs.roundThreshold = h.gs.roundPeriod * fixed.Int26_6(x-4) / 8 + } else { + h.gs.roundThreshold = h.gs.roundPeriod - 1 + } + + case opJROT: + top -= 2 + if h.stack[top+1] != 0 { + pc += int(h.stack[top]) + continue + } + + case opJROF: + top -= 2 + if h.stack[top+1] == 0 { + pc += int(h.stack[top]) + continue + } + + case opROFF: + h.gs.roundPeriod = 0 + h.gs.roundPhase = 0 + h.gs.roundThreshold = 0 + h.gs.roundSuper45 = false + + case opRUTG: + h.gs.roundPeriod = 1 << 6 + h.gs.roundPhase = 0 + h.gs.roundThreshold = 1<<6 - 1 + h.gs.roundSuper45 = false + + case opRDTG: + h.gs.roundPeriod = 1 << 6 + h.gs.roundPhase = 0 + h.gs.roundThreshold = 0 + h.gs.roundSuper45 = false + + case opSANGW, opAA: + // These ops are "anachronistic" and no longer used. + top-- + + case opFLIPPT: + if top < int(h.gs.loop) { + return errors.New("truetype: hinting: stack underflow") + } + points := h.points[glyphZone][current] + for ; h.gs.loop != 0; h.gs.loop-- { + top-- + i := h.stack[top] + if i < 0 || len(points) <= int(i) { + return errors.New("truetype: hinting: point out of range") + } + points[i].Flags ^= flagOnCurve + } + h.gs.loop = 1 + + case opFLIPRGON, opFLIPRGOFF: + top -= 2 + i, j, points := h.stack[top], h.stack[top+1], h.points[glyphZone][current] + if i < 0 || len(points) <= int(i) || j < 0 || len(points) <= int(j) { + return errors.New("truetype: hinting: point out of range") + } + for ; i <= j; i++ { + if opcode == opFLIPRGON { + points[i].Flags |= flagOnCurve + } else { + points[i].Flags &^= flagOnCurve + } + } + + case opSCANCTRL: + // We do not support dropout control, as we always rasterize grayscale glyphs. + top-- + + case opSDPVTL0, opSDPVTL1: + top -= 2 + for i := 0; i < 2; i++ { + pt := unhinted + if i != 0 { + pt = current + } + p := h.point(1, pt, h.stack[top]) + q := h.point(2, pt, h.stack[top+1]) + if p == nil || q == nil { + return errors.New("truetype: hinting: point out of range") + } + dx := f2dot14(p.X - q.X) + dy := f2dot14(p.Y - q.Y) + if dx == 0 && dy == 0 { + dx = 0x4000 + } else if opcode&1 != 0 { + // Counter-clockwise rotation. + dx, dy = -dy, dx + } + if i == 0 { + h.gs.dv = normalize(dx, dy) + } else { + h.gs.pv = normalize(dx, dy) + } + } + + case opGETINFO: + res := int32(0) + if h.stack[top-1]&(1<<0) != 0 { + // Set the engine version. We hard-code this to 35, the same as + // the C freetype code, which says that "Version~35 corresponds + // to MS rasterizer v.1.7 as used e.g. in Windows~98". + res |= 35 + } + if h.stack[top-1]&(1<<5) != 0 { + // Set that we support grayscale. + res |= 1 << 12 + } + // We set no other bits, as we do not support rotated or stretched glyphs. + h.stack[top-1] = res + + case opIDEF: + // IDEF is for ancient versions of the bytecode interpreter, and is no longer used. + return errors.New("truetype: hinting: unsupported IDEF instruction") + + case opROLL: + h.stack[top-1], h.stack[top-3], h.stack[top-2] = + h.stack[top-3], h.stack[top-2], h.stack[top-1] + + case opMAX: + top-- + if h.stack[top-1] < h.stack[top] { + h.stack[top-1] = h.stack[top] + } + + case opMIN: + top-- + if h.stack[top-1] > h.stack[top] { + h.stack[top-1] = h.stack[top] + } + + case opSCANTYPE: + // We do not support dropout control, as we always rasterize grayscale glyphs. + top-- + + case opINSTCTRL: + // TODO: support instruction execution control? It seems rare, and even when + // nominally used (e.g. Source Sans Pro), it seems conditional on extreme or + // unusual rasterization conditions. For example, the code snippet at + // https://developer.apple.com/fonts/TTRefMan/RM05/Chap5.html#INSTCTRL + // uses INSTCTRL when grid-fitting a rotated or stretched glyph, but + // freetype-go does not support rotated or stretched glyphs. + top -= 2 + + default: + if opcode < opPUSHB000 { + return errors.New("truetype: hinting: unrecognized instruction") + } + + if opcode < opMDRP00000 { + // PUSHxxxx opcode. + + if opcode < opPUSHW000 { + opcode -= opPUSHB000 - 1 + } else { + opcode -= opPUSHW000 - 1 - 0x80 + } + goto push + } + + if opcode < opMIRP00000 { + // MDRPxxxxx opcode. + + top-- + i := h.stack[top] + ref := h.point(0, current, h.gs.rp[0]) + p := h.point(1, current, i) + if ref == nil || p == nil { + return errors.New("truetype: hinting: point out of range") + } + + oldDist := fixed.Int26_6(0) + if h.gs.zp[0] == 0 || h.gs.zp[1] == 0 { + p0 := h.point(1, unhinted, i) + p1 := h.point(0, unhinted, h.gs.rp[0]) + oldDist = dotProduct(p0.X-p1.X, p0.Y-p1.Y, h.gs.dv) + } else { + p0 := h.point(1, inFontUnits, i) + p1 := h.point(0, inFontUnits, h.gs.rp[0]) + oldDist = dotProduct(p0.X-p1.X, p0.Y-p1.Y, h.gs.dv) + oldDist = h.font.scale(h.scale * oldDist) + } + + // Single-width cut-in test. + if x := fabs(oldDist - h.gs.singleWidth); x < h.gs.singleWidthCutIn { + if oldDist >= 0 { + oldDist = +h.gs.singleWidth + } else { + oldDist = -h.gs.singleWidth + } + } + + // Rounding bit. + // TODO: metrics compensation. + distance := oldDist + if opcode&0x04 != 0 { + distance = h.round(oldDist) + } + + // Minimum distance bit. + if opcode&0x08 != 0 { + if oldDist >= 0 { + if distance < h.gs.minDist { + distance = h.gs.minDist + } + } else { + if distance > -h.gs.minDist { + distance = -h.gs.minDist + } + } + } + + // Set-RP0 bit. + h.gs.rp[1] = h.gs.rp[0] + h.gs.rp[2] = i + if opcode&0x10 != 0 { + h.gs.rp[0] = i + } + + // Move the point. + oldDist = dotProduct(p.X-ref.X, p.Y-ref.Y, h.gs.pv) + h.move(p, distance-oldDist, true) + + } else { + // MIRPxxxxx opcode. + + top -= 2 + i := h.stack[top] + cvtDist := h.getScaledCVT(h.stack[top+1]) + if fabs(cvtDist-h.gs.singleWidth) < h.gs.singleWidthCutIn { + if cvtDist >= 0 { + cvtDist = +h.gs.singleWidth + } else { + cvtDist = -h.gs.singleWidth + } + } + + if h.gs.zp[1] == 0 { + // TODO: implement once we have a .ttf file that triggers + // this, so that we can step through C's freetype. + return errors.New("truetype: hinting: unimplemented twilight point adjustment") + } + + ref := h.point(0, unhinted, h.gs.rp[0]) + p := h.point(1, unhinted, i) + if ref == nil || p == nil { + return errors.New("truetype: hinting: point out of range") + } + oldDist := dotProduct(p.X-ref.X, p.Y-ref.Y, h.gs.dv) + + ref = h.point(0, current, h.gs.rp[0]) + p = h.point(1, current, i) + if ref == nil || p == nil { + return errors.New("truetype: hinting: point out of range") + } + curDist := dotProduct(p.X-ref.X, p.Y-ref.Y, h.gs.pv) + + if h.gs.autoFlip && oldDist^cvtDist < 0 { + cvtDist = -cvtDist + } + + // Rounding bit. + // TODO: metrics compensation. + distance := cvtDist + if opcode&0x04 != 0 { + // The CVT value is only used if close enough to oldDist. + if (h.gs.zp[0] == h.gs.zp[1]) && + (fabs(cvtDist-oldDist) > h.gs.controlValueCutIn) { + + distance = oldDist + } + distance = h.round(distance) + } + + // Minimum distance bit. + if opcode&0x08 != 0 { + if oldDist >= 0 { + if distance < h.gs.minDist { + distance = h.gs.minDist + } + } else { + if distance > -h.gs.minDist { + distance = -h.gs.minDist + } + } + } + + // Set-RP0 bit. + h.gs.rp[1] = h.gs.rp[0] + h.gs.rp[2] = i + if opcode&0x10 != 0 { + h.gs.rp[0] = i + } + + // Move the point. + h.move(p, distance-curDist, true) + } + } + pc++ + continue + + ifelse: + // Skip past bytecode until the next ELSE (if opcode == 0) or the + // next EIF (for all opcodes). Opcode == 0 means that we have come + // from an IF. Opcode == 1 means that we have come from an ELSE. + { + ifelseloop: + for depth := 0; ; { + pc++ + if pc >= len(program) { + return errors.New("truetype: hinting: unbalanced IF or ELSE") + } + switch program[pc] { + case opIF: + depth++ + case opELSE: + if depth == 0 && opcode == 0 { + break ifelseloop + } + case opEIF: + depth-- + if depth < 0 { + break ifelseloop + } + default: + var ok bool + pc, ok = skipInstructionPayload(program, pc) + if !ok { + return errors.New("truetype: hinting: unbalanced IF or ELSE") + } + } + } + pc++ + continue + } + + push: + // Push n elements from the program to the stack, where n is the low 7 bits of + // opcode. If the low 7 bits are zero, then n is the next byte from the program. + // The high bit being 0 means that the elements are zero-extended bytes. + // The high bit being 1 means that the elements are sign-extended words. + { + width := 1 + if opcode&0x80 != 0 { + opcode &^= 0x80 + width = 2 + } + if opcode == 0 { + pc++ + if pc >= len(program) { + return errors.New("truetype: hinting: insufficient data") + } + opcode = program[pc] + } + pc++ + if top+int(opcode) > len(h.stack) { + return errors.New("truetype: hinting: stack overflow") + } + if pc+width*int(opcode) > len(program) { + return errors.New("truetype: hinting: insufficient data") + } + for ; opcode > 0; opcode-- { + if width == 1 { + h.stack[top] = int32(program[pc]) + } else { + h.stack[top] = int32(int8(program[pc]))<<8 | int32(program[pc+1]) + } + top++ + pc += width + } + continue + } + + delta: + { + if opcode >= opDELTAC1 && !h.scaledCVTInitialized { + h.initializeScaledCVT() + } + top-- + n := h.stack[top] + if int32(top) < 2*n { + return errors.New("truetype: hinting: stack underflow") + } + for ; n > 0; n-- { + top -= 2 + b := h.stack[top] + c := (b & 0xf0) >> 4 + switch opcode { + case opDELTAP2, opDELTAC2: + c += 16 + case opDELTAP3, opDELTAC3: + c += 32 + } + c += h.gs.deltaBase + if ppem := (int32(h.scale) + 1<<5) >> 6; ppem != c { + continue + } + b = (b & 0x0f) - 8 + if b >= 0 { + b++ + } + b = b * 64 / (1 << uint32(h.gs.deltaShift)) + if opcode >= opDELTAC1 { + a := h.stack[top+1] + if a < 0 || len(h.scaledCVT) <= int(a) { + return errors.New("truetype: hinting: index out of range") + } + h.scaledCVT[a] += fixed.Int26_6(b) + } else { + p := h.point(0, current, h.stack[top+1]) + if p == nil { + return errors.New("truetype: hinting: point out of range") + } + h.move(p, fixed.Int26_6(b), true) + } + } + pc++ + continue + } + } + return nil +} + +func (h *hinter) initializeScaledCVT() { + h.scaledCVTInitialized = true + if n := len(h.font.cvt) / 2; n <= cap(h.scaledCVT) { + h.scaledCVT = h.scaledCVT[:n] + } else { + if n < 32 { + n = 32 + } + h.scaledCVT = make([]fixed.Int26_6, len(h.font.cvt)/2, n) + } + for i := range h.scaledCVT { + unscaled := uint16(h.font.cvt[2*i])<<8 | uint16(h.font.cvt[2*i+1]) + h.scaledCVT[i] = h.font.scale(h.scale * fixed.Int26_6(int16(unscaled))) + } +} + +// getScaledCVT returns the scaled value from the font's Control Value Table. +func (h *hinter) getScaledCVT(i int32) fixed.Int26_6 { + if !h.scaledCVTInitialized { + h.initializeScaledCVT() + } + if i < 0 || len(h.scaledCVT) <= int(i) { + return 0 + } + return h.scaledCVT[i] +} + +// setScaledCVT overrides the scaled value from the font's Control Value Table. +func (h *hinter) setScaledCVT(i int32, v fixed.Int26_6) { + if !h.scaledCVTInitialized { + h.initializeScaledCVT() + } + if i < 0 || len(h.scaledCVT) <= int(i) { + return + } + h.scaledCVT[i] = v +} + +func (h *hinter) point(zonePointer uint32, pt pointType, i int32) *Point { + points := h.points[h.gs.zp[zonePointer]][pt] + if i < 0 || len(points) <= int(i) { + return nil + } + return &points[i] +} + +func (h *hinter) move(p *Point, distance fixed.Int26_6, touch bool) { + fvx := int64(h.gs.fv[0]) + pvx := int64(h.gs.pv[0]) + if fvx == 0x4000 && pvx == 0x4000 { + p.X += fixed.Int26_6(distance) + if touch { + p.Flags |= flagTouchedX + } + return + } + + fvy := int64(h.gs.fv[1]) + pvy := int64(h.gs.pv[1]) + if fvy == 0x4000 && pvy == 0x4000 { + p.Y += fixed.Int26_6(distance) + if touch { + p.Flags |= flagTouchedY + } + return + } + + fvDotPv := (fvx*pvx + fvy*pvy) >> 14 + + if fvx != 0 { + p.X += fixed.Int26_6(mulDiv(fvx, int64(distance), fvDotPv)) + if touch { + p.Flags |= flagTouchedX + } + } + + if fvy != 0 { + p.Y += fixed.Int26_6(mulDiv(fvy, int64(distance), fvDotPv)) + if touch { + p.Flags |= flagTouchedY + } + } +} + +func (h *hinter) iupInterp(interpY bool, p1, p2, ref1, ref2 int) { + if p1 > p2 { + return + } + if ref1 >= len(h.points[glyphZone][current]) || + ref2 >= len(h.points[glyphZone][current]) { + return + } + + var ifu1, ifu2 fixed.Int26_6 + if interpY { + ifu1 = h.points[glyphZone][inFontUnits][ref1].Y + ifu2 = h.points[glyphZone][inFontUnits][ref2].Y + } else { + ifu1 = h.points[glyphZone][inFontUnits][ref1].X + ifu2 = h.points[glyphZone][inFontUnits][ref2].X + } + if ifu1 > ifu2 { + ifu1, ifu2 = ifu2, ifu1 + ref1, ref2 = ref2, ref1 + } + + var unh1, unh2, delta1, delta2 fixed.Int26_6 + if interpY { + unh1 = h.points[glyphZone][unhinted][ref1].Y + unh2 = h.points[glyphZone][unhinted][ref2].Y + delta1 = h.points[glyphZone][current][ref1].Y - unh1 + delta2 = h.points[glyphZone][current][ref2].Y - unh2 + } else { + unh1 = h.points[glyphZone][unhinted][ref1].X + unh2 = h.points[glyphZone][unhinted][ref2].X + delta1 = h.points[glyphZone][current][ref1].X - unh1 + delta2 = h.points[glyphZone][current][ref2].X - unh2 + } + + var xy, ifuXY fixed.Int26_6 + if ifu1 == ifu2 { + for i := p1; i <= p2; i++ { + if interpY { + xy = h.points[glyphZone][unhinted][i].Y + } else { + xy = h.points[glyphZone][unhinted][i].X + } + + if xy <= unh1 { + xy += delta1 + } else { + xy += delta2 + } + + if interpY { + h.points[glyphZone][current][i].Y = xy + } else { + h.points[glyphZone][current][i].X = xy + } + } + return + } + + scale, scaleOK := int64(0), false + for i := p1; i <= p2; i++ { + if interpY { + xy = h.points[glyphZone][unhinted][i].Y + ifuXY = h.points[glyphZone][inFontUnits][i].Y + } else { + xy = h.points[glyphZone][unhinted][i].X + ifuXY = h.points[glyphZone][inFontUnits][i].X + } + + if xy <= unh1 { + xy += delta1 + } else if xy >= unh2 { + xy += delta2 + } else { + if !scaleOK { + scaleOK = true + scale = mulDiv(int64(unh2+delta2-unh1-delta1), 0x10000, int64(ifu2-ifu1)) + } + numer := int64(ifuXY-ifu1) * scale + if numer >= 0 { + numer += 0x8000 + } else { + numer -= 0x8000 + } + xy = unh1 + delta1 + fixed.Int26_6(numer/0x10000) + } + + if interpY { + h.points[glyphZone][current][i].Y = xy + } else { + h.points[glyphZone][current][i].X = xy + } + } +} + +func (h *hinter) iupShift(interpY bool, p1, p2, p int) { + var delta fixed.Int26_6 + if interpY { + delta = h.points[glyphZone][current][p].Y - h.points[glyphZone][unhinted][p].Y + } else { + delta = h.points[glyphZone][current][p].X - h.points[glyphZone][unhinted][p].X + } + if delta == 0 { + return + } + for i := p1; i < p2; i++ { + if i == p { + continue + } + if interpY { + h.points[glyphZone][current][i].Y += delta + } else { + h.points[glyphZone][current][i].X += delta + } + } +} + +func (h *hinter) displacement(useZP1 bool) (zonePointer uint32, i int32, d fixed.Int26_6, ok bool) { + zonePointer, i = uint32(0), h.gs.rp[1] + if useZP1 { + zonePointer, i = 1, h.gs.rp[2] + } + p := h.point(zonePointer, current, i) + q := h.point(zonePointer, unhinted, i) + if p == nil || q == nil { + return 0, 0, 0, false + } + d = dotProduct(p.X-q.X, p.Y-q.Y, h.gs.pv) + return zonePointer, i, d, true +} + +// skipInstructionPayload increments pc by the extra data that follows a +// variable length PUSHB or PUSHW instruction. +func skipInstructionPayload(program []byte, pc int) (newPC int, ok bool) { + switch program[pc] { + case opNPUSHB: + pc++ + if pc >= len(program) { + return 0, false + } + pc += int(program[pc]) + case opNPUSHW: + pc++ + if pc >= len(program) { + return 0, false + } + pc += 2 * int(program[pc]) + case opPUSHB000, opPUSHB001, opPUSHB010, opPUSHB011, + opPUSHB100, opPUSHB101, opPUSHB110, opPUSHB111: + pc += int(program[pc] - (opPUSHB000 - 1)) + case opPUSHW000, opPUSHW001, opPUSHW010, opPUSHW011, + opPUSHW100, opPUSHW101, opPUSHW110, opPUSHW111: + pc += 2 * int(program[pc]-(opPUSHW000-1)) + } + return pc, true +} + +// f2dot14 is a 2.14 fixed point number. +type f2dot14 int16 + +func normalize(x, y f2dot14) [2]f2dot14 { + fx, fy := float64(x), float64(y) + l := 0x4000 / math.Hypot(fx, fy) + fx *= l + if fx >= 0 { + fx += 0.5 + } else { + fx -= 0.5 + } + fy *= l + if fy >= 0 { + fy += 0.5 + } else { + fy -= 0.5 + } + return [2]f2dot14{f2dot14(fx), f2dot14(fy)} +} + +// fabs returns abs(x) in 26.6 fixed point arithmetic. +func fabs(x fixed.Int26_6) fixed.Int26_6 { + if x < 0 { + return -x + } + return x +} + +// fdiv returns x/y in 26.6 fixed point arithmetic. +func fdiv(x, y fixed.Int26_6) fixed.Int26_6 { + return fixed.Int26_6((int64(x) << 6) / int64(y)) +} + +// fmul returns x*y in 26.6 fixed point arithmetic. +func fmul(x, y fixed.Int26_6) fixed.Int26_6 { + return fixed.Int26_6((int64(x)*int64(y) + 1<<5) >> 6) +} + +// dotProduct returns the dot product of [x, y] and q. It is almost the same as +// px := int64(x) +// py := int64(y) +// qx := int64(q[0]) +// qy := int64(q[1]) +// return fixed.Int26_6((px*qx + py*qy + 1<<13) >> 14) +// except that the computation is done with 32-bit integers to produce exactly +// the same rounding behavior as C Freetype. +func dotProduct(x, y fixed.Int26_6, q [2]f2dot14) fixed.Int26_6 { + // Compute x*q[0] as 64-bit value. + l := uint32((int32(x) & 0xFFFF) * int32(q[0])) + m := (int32(x) >> 16) * int32(q[0]) + + lo1 := l + (uint32(m) << 16) + hi1 := (m >> 16) + (int32(l) >> 31) + bool2int32(lo1 < l) + + // Compute y*q[1] as 64-bit value. + l = uint32((int32(y) & 0xFFFF) * int32(q[1])) + m = (int32(y) >> 16) * int32(q[1]) + + lo2 := l + (uint32(m) << 16) + hi2 := (m >> 16) + (int32(l) >> 31) + bool2int32(lo2 < l) + + // Add them. + lo := lo1 + lo2 + hi := hi1 + hi2 + bool2int32(lo < lo1) + + // Divide the result by 2^14 with rounding. + s := hi >> 31 + l = lo + uint32(s) + hi += s + bool2int32(l < lo) + lo = l + + l = lo + 0x2000 + hi += bool2int32(l < lo) + + return fixed.Int26_6((uint32(hi) << 18) | (l >> 14)) +} + +// mulDiv returns x*y/z, rounded to the nearest integer. +func mulDiv(x, y, z int64) int64 { + xy := x * y + if z < 0 { + xy, z = -xy, -z + } + if xy >= 0 { + xy += z / 2 + } else { + xy -= z / 2 + } + return xy / z +} + +// round rounds the given number. The rounding algorithm is described at +// https://developer.apple.com/fonts/TTRefMan/RM02/Chap2.html#rounding +func (h *hinter) round(x fixed.Int26_6) fixed.Int26_6 { + if h.gs.roundPeriod == 0 { + // Rounding is off. + return x + } + if x >= 0 { + ret := x - h.gs.roundPhase + h.gs.roundThreshold + if h.gs.roundSuper45 { + ret /= h.gs.roundPeriod + ret *= h.gs.roundPeriod + } else { + ret &= -h.gs.roundPeriod + } + if x != 0 && ret < 0 { + ret = 0 + } + return ret + h.gs.roundPhase + } + ret := -x - h.gs.roundPhase + h.gs.roundThreshold + if h.gs.roundSuper45 { + ret /= h.gs.roundPeriod + ret *= h.gs.roundPeriod + } else { + ret &= -h.gs.roundPeriod + } + if ret < 0 { + ret = 0 + } + return -ret - h.gs.roundPhase +} + +func bool2int32(b bool) int32 { + if b { + return 1 + } + return 0 +} diff --git a/vendor/github.com/golang/freetype/truetype/opcodes.go b/vendor/github.com/golang/freetype/truetype/opcodes.go new file mode 100644 index 00000000..1880e1e6 --- /dev/null +++ b/vendor/github.com/golang/freetype/truetype/opcodes.go @@ -0,0 +1,289 @@ +// Copyright 2012 The Freetype-Go Authors. All rights reserved. +// Use of this source code is governed by your choice of either the +// FreeType License or the GNU General Public License version 2 (or +// any later version), both of which can be found in the LICENSE file. + +package truetype + +// The Truetype opcodes are summarized at +// https://developer.apple.com/fonts/TTRefMan/RM07/appendixA.html + +const ( + opSVTCA0 = 0x00 // Set freedom and projection Vectors To Coordinate Axis + opSVTCA1 = 0x01 // . + opSPVTCA0 = 0x02 // Set Projection Vector To Coordinate Axis + opSPVTCA1 = 0x03 // . + opSFVTCA0 = 0x04 // Set Freedom Vector to Coordinate Axis + opSFVTCA1 = 0x05 // . + opSPVTL0 = 0x06 // Set Projection Vector To Line + opSPVTL1 = 0x07 // . + opSFVTL0 = 0x08 // Set Freedom Vector To Line + opSFVTL1 = 0x09 // . + opSPVFS = 0x0a // Set Projection Vector From Stack + opSFVFS = 0x0b // Set Freedom Vector From Stack + opGPV = 0x0c // Get Projection Vector + opGFV = 0x0d // Get Freedom Vector + opSFVTPV = 0x0e // Set Freedom Vector To Projection Vector + opISECT = 0x0f // moves point p to the InterSECTion of two lines + opSRP0 = 0x10 // Set Reference Point 0 + opSRP1 = 0x11 // Set Reference Point 1 + opSRP2 = 0x12 // Set Reference Point 2 + opSZP0 = 0x13 // Set Zone Pointer 0 + opSZP1 = 0x14 // Set Zone Pointer 1 + opSZP2 = 0x15 // Set Zone Pointer 2 + opSZPS = 0x16 // Set Zone PointerS + opSLOOP = 0x17 // Set LOOP variable + opRTG = 0x18 // Round To Grid + opRTHG = 0x19 // Round To Half Grid + opSMD = 0x1a // Set Minimum Distance + opELSE = 0x1b // ELSE clause + opJMPR = 0x1c // JuMP Relative + opSCVTCI = 0x1d // Set Control Value Table Cut-In + opSSWCI = 0x1e // Set Single Width Cut-In + opSSW = 0x1f // Set Single Width + opDUP = 0x20 // DUPlicate top stack element + opPOP = 0x21 // POP top stack element + opCLEAR = 0x22 // CLEAR the stack + opSWAP = 0x23 // SWAP the top two elements on the stack + opDEPTH = 0x24 // DEPTH of the stack + opCINDEX = 0x25 // Copy the INDEXed element to the top of the stack + opMINDEX = 0x26 // Move the INDEXed element to the top of the stack + opALIGNPTS = 0x27 // ALIGN PoinTS + op_0x28 = 0x28 // deprecated + opUTP = 0x29 // UnTouch Point + opLOOPCALL = 0x2a // LOOP and CALL function + opCALL = 0x2b // CALL function + opFDEF = 0x2c // Function DEFinition + opENDF = 0x2d // END Function definition + opMDAP0 = 0x2e // Move Direct Absolute Point + opMDAP1 = 0x2f // . + opIUP0 = 0x30 // Interpolate Untouched Points through the outline + opIUP1 = 0x31 // . + opSHP0 = 0x32 // SHift Point using reference point + opSHP1 = 0x33 // . + opSHC0 = 0x34 // SHift Contour using reference point + opSHC1 = 0x35 // . + opSHZ0 = 0x36 // SHift Zone using reference point + opSHZ1 = 0x37 // . + opSHPIX = 0x38 // SHift point by a PIXel amount + opIP = 0x39 // Interpolate Point + opMSIRP0 = 0x3a // Move Stack Indirect Relative Point + opMSIRP1 = 0x3b // . + opALIGNRP = 0x3c // ALIGN to Reference Point + opRTDG = 0x3d // Round To Double Grid + opMIAP0 = 0x3e // Move Indirect Absolute Point + opMIAP1 = 0x3f // . + opNPUSHB = 0x40 // PUSH N Bytes + opNPUSHW = 0x41 // PUSH N Words + opWS = 0x42 // Write Store + opRS = 0x43 // Read Store + opWCVTP = 0x44 // Write Control Value Table in Pixel units + opRCVT = 0x45 // Read Control Value Table entry + opGC0 = 0x46 // Get Coordinate projected onto the projection vector + opGC1 = 0x47 // . + opSCFS = 0x48 // Sets Coordinate From the Stack using projection vector and freedom vector + opMD0 = 0x49 // Measure Distance + opMD1 = 0x4a // . + opMPPEM = 0x4b // Measure Pixels Per EM + opMPS = 0x4c // Measure Point Size + opFLIPON = 0x4d // set the auto FLIP Boolean to ON + opFLIPOFF = 0x4e // set the auto FLIP Boolean to OFF + opDEBUG = 0x4f // DEBUG call + opLT = 0x50 // Less Than + opLTEQ = 0x51 // Less Than or EQual + opGT = 0x52 // Greater Than + opGTEQ = 0x53 // Greater Than or EQual + opEQ = 0x54 // EQual + opNEQ = 0x55 // Not EQual + opODD = 0x56 // ODD + opEVEN = 0x57 // EVEN + opIF = 0x58 // IF test + opEIF = 0x59 // End IF + opAND = 0x5a // logical AND + opOR = 0x5b // logical OR + opNOT = 0x5c // logical NOT + opDELTAP1 = 0x5d // DELTA exception P1 + opSDB = 0x5e // Set Delta Base in the graphics state + opSDS = 0x5f // Set Delta Shift in the graphics state + opADD = 0x60 // ADD + opSUB = 0x61 // SUBtract + opDIV = 0x62 // DIVide + opMUL = 0x63 // MULtiply + opABS = 0x64 // ABSolute value + opNEG = 0x65 // NEGate + opFLOOR = 0x66 // FLOOR + opCEILING = 0x67 // CEILING + opROUND00 = 0x68 // ROUND value + opROUND01 = 0x69 // . + opROUND10 = 0x6a // . + opROUND11 = 0x6b // . + opNROUND00 = 0x6c // No ROUNDing of value + opNROUND01 = 0x6d // . + opNROUND10 = 0x6e // . + opNROUND11 = 0x6f // . + opWCVTF = 0x70 // Write Control Value Table in Funits + opDELTAP2 = 0x71 // DELTA exception P2 + opDELTAP3 = 0x72 // DELTA exception P3 + opDELTAC1 = 0x73 // DELTA exception C1 + opDELTAC2 = 0x74 // DELTA exception C2 + opDELTAC3 = 0x75 // DELTA exception C3 + opSROUND = 0x76 // Super ROUND + opS45ROUND = 0x77 // Super ROUND 45 degrees + opJROT = 0x78 // Jump Relative On True + opJROF = 0x79 // Jump Relative On False + opROFF = 0x7a // Round OFF + op_0x7b = 0x7b // deprecated + opRUTG = 0x7c // Round Up To Grid + opRDTG = 0x7d // Round Down To Grid + opSANGW = 0x7e // Set ANGle Weight + opAA = 0x7f // Adjust Angle + opFLIPPT = 0x80 // FLIP PoinT + opFLIPRGON = 0x81 // FLIP RanGe ON + opFLIPRGOFF = 0x82 // FLIP RanGe OFF + op_0x83 = 0x83 // deprecated + op_0x84 = 0x84 // deprecated + opSCANCTRL = 0x85 // SCAN conversion ConTRoL + opSDPVTL0 = 0x86 // Set Dual Projection Vector To Line + opSDPVTL1 = 0x87 // . + opGETINFO = 0x88 // GET INFOrmation + opIDEF = 0x89 // Instruction DEFinition + opROLL = 0x8a // ROLL the top three stack elements + opMAX = 0x8b // MAXimum of top two stack elements + opMIN = 0x8c // MINimum of top two stack elements + opSCANTYPE = 0x8d // SCANTYPE + opINSTCTRL = 0x8e // INSTRuction execution ConTRoL + op_0x8f = 0x8f + op_0x90 = 0x90 + op_0x91 = 0x91 + op_0x92 = 0x92 + op_0x93 = 0x93 + op_0x94 = 0x94 + op_0x95 = 0x95 + op_0x96 = 0x96 + op_0x97 = 0x97 + op_0x98 = 0x98 + op_0x99 = 0x99 + op_0x9a = 0x9a + op_0x9b = 0x9b + op_0x9c = 0x9c + op_0x9d = 0x9d + op_0x9e = 0x9e + op_0x9f = 0x9f + op_0xa0 = 0xa0 + op_0xa1 = 0xa1 + op_0xa2 = 0xa2 + op_0xa3 = 0xa3 + op_0xa4 = 0xa4 + op_0xa5 = 0xa5 + op_0xa6 = 0xa6 + op_0xa7 = 0xa7 + op_0xa8 = 0xa8 + op_0xa9 = 0xa9 + op_0xaa = 0xaa + op_0xab = 0xab + op_0xac = 0xac + op_0xad = 0xad + op_0xae = 0xae + op_0xaf = 0xaf + opPUSHB000 = 0xb0 // PUSH Bytes + opPUSHB001 = 0xb1 // . + opPUSHB010 = 0xb2 // . + opPUSHB011 = 0xb3 // . + opPUSHB100 = 0xb4 // . + opPUSHB101 = 0xb5 // . + opPUSHB110 = 0xb6 // . + opPUSHB111 = 0xb7 // . + opPUSHW000 = 0xb8 // PUSH Words + opPUSHW001 = 0xb9 // . + opPUSHW010 = 0xba // . + opPUSHW011 = 0xbb // . + opPUSHW100 = 0xbc // . + opPUSHW101 = 0xbd // . + opPUSHW110 = 0xbe // . + opPUSHW111 = 0xbf // . + opMDRP00000 = 0xc0 // Move Direct Relative Point + opMDRP00001 = 0xc1 // . + opMDRP00010 = 0xc2 // . + opMDRP00011 = 0xc3 // . + opMDRP00100 = 0xc4 // . + opMDRP00101 = 0xc5 // . + opMDRP00110 = 0xc6 // . + opMDRP00111 = 0xc7 // . + opMDRP01000 = 0xc8 // . + opMDRP01001 = 0xc9 // . + opMDRP01010 = 0xca // . + opMDRP01011 = 0xcb // . + opMDRP01100 = 0xcc // . + opMDRP01101 = 0xcd // . + opMDRP01110 = 0xce // . + opMDRP01111 = 0xcf // . + opMDRP10000 = 0xd0 // . + opMDRP10001 = 0xd1 // . + opMDRP10010 = 0xd2 // . + opMDRP10011 = 0xd3 // . + opMDRP10100 = 0xd4 // . + opMDRP10101 = 0xd5 // . + opMDRP10110 = 0xd6 // . + opMDRP10111 = 0xd7 // . + opMDRP11000 = 0xd8 // . + opMDRP11001 = 0xd9 // . + opMDRP11010 = 0xda // . + opMDRP11011 = 0xdb // . + opMDRP11100 = 0xdc // . + opMDRP11101 = 0xdd // . + opMDRP11110 = 0xde // . + opMDRP11111 = 0xdf // . + opMIRP00000 = 0xe0 // Move Indirect Relative Point + opMIRP00001 = 0xe1 // . + opMIRP00010 = 0xe2 // . + opMIRP00011 = 0xe3 // . + opMIRP00100 = 0xe4 // . + opMIRP00101 = 0xe5 // . + opMIRP00110 = 0xe6 // . + opMIRP00111 = 0xe7 // . + opMIRP01000 = 0xe8 // . + opMIRP01001 = 0xe9 // . + opMIRP01010 = 0xea // . + opMIRP01011 = 0xeb // . + opMIRP01100 = 0xec // . + opMIRP01101 = 0xed // . + opMIRP01110 = 0xee // . + opMIRP01111 = 0xef // . + opMIRP10000 = 0xf0 // . + opMIRP10001 = 0xf1 // . + opMIRP10010 = 0xf2 // . + opMIRP10011 = 0xf3 // . + opMIRP10100 = 0xf4 // . + opMIRP10101 = 0xf5 // . + opMIRP10110 = 0xf6 // . + opMIRP10111 = 0xf7 // . + opMIRP11000 = 0xf8 // . + opMIRP11001 = 0xf9 // . + opMIRP11010 = 0xfa // . + opMIRP11011 = 0xfb // . + opMIRP11100 = 0xfc // . + opMIRP11101 = 0xfd // . + opMIRP11110 = 0xfe // . + opMIRP11111 = 0xff // . +) + +// popCount is the number of stack elements that each opcode pops. +var popCount = [256]uint8{ + // 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f + 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 5, // 0x00 - 0x0f + 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, // 0x10 - 0x1f + 1, 1, 0, 2, 0, 1, 1, 2, 0, 1, 2, 1, 1, 0, 1, 1, // 0x20 - 0x2f + 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 2, 2, 0, 0, 2, 2, // 0x30 - 0x3f + 0, 0, 2, 1, 2, 1, 1, 1, 2, 2, 2, 0, 0, 0, 0, 0, // 0x40 - 0x4f + 2, 2, 2, 2, 2, 2, 1, 1, 1, 0, 2, 2, 1, 1, 1, 1, // 0x50 - 0x5f + 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 - 0x6f + 2, 1, 1, 1, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 1, 1, // 0x70 - 0x7f + 0, 2, 2, 0, 0, 1, 2, 2, 1, 1, 3, 2, 2, 1, 2, 0, // 0x80 - 0x8f + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x90 - 0x9f + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xa0 - 0xaf + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xb0 - 0xbf + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xc0 - 0xcf + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xd0 - 0xdf + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xe0 - 0xef + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xf0 - 0xff +} diff --git a/vendor/github.com/golang/freetype/truetype/truetype.go b/vendor/github.com/golang/freetype/truetype/truetype.go new file mode 100644 index 00000000..613fc17e --- /dev/null +++ b/vendor/github.com/golang/freetype/truetype/truetype.go @@ -0,0 +1,643 @@ +// Copyright 2010 The Freetype-Go Authors. All rights reserved. +// Use of this source code is governed by your choice of either the +// FreeType License or the GNU General Public License version 2 (or +// any later version), both of which can be found in the LICENSE file. + +// Package truetype provides a parser for the TTF and TTC file formats. +// Those formats are documented at http://developer.apple.com/fonts/TTRefMan/ +// and http://www.microsoft.com/typography/otspec/ +// +// Some of a font's methods provide lengths or co-ordinates, e.g. bounds, font +// metrics and control points. All these methods take a scale parameter, which +// is the number of pixels in 1 em, expressed as a 26.6 fixed point value. For +// example, if 1 em is 10 pixels then scale is fixed.I(10), which is equal to +// fixed.Int26_6(10 << 6). +// +// To measure a TrueType font in ideal FUnit space, use scale equal to +// font.FUnitsPerEm(). +package truetype // import "github.com/golang/freetype/truetype" + +import ( + "fmt" + + "golang.org/x/image/math/fixed" +) + +// An Index is a Font's index of a rune. +type Index uint16 + +// A NameID identifies a name table entry. +// +// See https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6name.html +type NameID uint16 + +const ( + NameIDCopyright NameID = 0 + NameIDFontFamily = 1 + NameIDFontSubfamily = 2 + NameIDUniqueSubfamilyID = 3 + NameIDFontFullName = 4 + NameIDNameTableVersion = 5 + NameIDPostscriptName = 6 + NameIDTrademarkNotice = 7 + NameIDManufacturerName = 8 + NameIDDesignerName = 9 + NameIDFontDescription = 10 + NameIDFontVendorURL = 11 + NameIDFontDesignerURL = 12 + NameIDFontLicense = 13 + NameIDFontLicenseURL = 14 + NameIDPreferredFamily = 16 + NameIDPreferredSubfamily = 17 + NameIDCompatibleName = 18 + NameIDSampleText = 19 +) + +const ( + // A 32-bit encoding consists of a most-significant 16-bit Platform ID and a + // least-significant 16-bit Platform Specific ID. The magic numbers are + // specified at https://www.microsoft.com/typography/otspec/name.htm + unicodeEncoding = 0x00000003 // PID = 0 (Unicode), PSID = 3 (Unicode 2.0) + microsoftSymbolEncoding = 0x00030000 // PID = 3 (Microsoft), PSID = 0 (Symbol) + microsoftUCS2Encoding = 0x00030001 // PID = 3 (Microsoft), PSID = 1 (UCS-2) + microsoftUCS4Encoding = 0x0003000a // PID = 3 (Microsoft), PSID = 10 (UCS-4) +) + +// An HMetric holds the horizontal metrics of a single glyph. +type HMetric struct { + AdvanceWidth, LeftSideBearing fixed.Int26_6 +} + +// A VMetric holds the vertical metrics of a single glyph. +type VMetric struct { + AdvanceHeight, TopSideBearing fixed.Int26_6 +} + +// A FormatError reports that the input is not a valid TrueType font. +type FormatError string + +func (e FormatError) Error() string { + return "freetype: invalid TrueType format: " + string(e) +} + +// An UnsupportedError reports that the input uses a valid but unimplemented +// TrueType feature. +type UnsupportedError string + +func (e UnsupportedError) Error() string { + return "freetype: unsupported TrueType feature: " + string(e) +} + +// u32 returns the big-endian uint32 at b[i:]. +func u32(b []byte, i int) uint32 { + return uint32(b[i])<<24 | uint32(b[i+1])<<16 | uint32(b[i+2])<<8 | uint32(b[i+3]) +} + +// u16 returns the big-endian uint16 at b[i:]. +func u16(b []byte, i int) uint16 { + return uint16(b[i])<<8 | uint16(b[i+1]) +} + +// readTable returns a slice of the TTF data given by a table's directory entry. +func readTable(ttf []byte, offsetLength []byte) ([]byte, error) { + offset := int(u32(offsetLength, 0)) + if offset < 0 { + return nil, FormatError(fmt.Sprintf("offset too large: %d", uint32(offset))) + } + length := int(u32(offsetLength, 4)) + if length < 0 { + return nil, FormatError(fmt.Sprintf("length too large: %d", uint32(length))) + } + end := offset + length + if end < 0 || end > len(ttf) { + return nil, FormatError(fmt.Sprintf("offset + length too large: %d", uint32(offset)+uint32(length))) + } + return ttf[offset:end], nil +} + +// parseSubtables returns the offset and platformID of the best subtable in +// table, where best favors a Unicode cmap encoding, and failing that, a +// Microsoft cmap encoding. offset is the offset of the first subtable in +// table, and size is the size of each subtable. +// +// If pred is non-nil, then only subtables that satisfy that predicate will be +// considered. +func parseSubtables(table []byte, name string, offset, size int, pred func([]byte) bool) ( + bestOffset int, bestPID uint32, retErr error) { + + if len(table) < 4 { + return 0, 0, FormatError(name + " too short") + } + nSubtables := int(u16(table, 2)) + if len(table) < size*nSubtables+offset { + return 0, 0, FormatError(name + " too short") + } + ok := false + for i := 0; i < nSubtables; i, offset = i+1, offset+size { + if pred != nil && !pred(table[offset:]) { + continue + } + // We read the 16-bit Platform ID and 16-bit Platform Specific ID as a single uint32. + // All values are big-endian. + pidPsid := u32(table, offset) + // We prefer the Unicode cmap encoding. Failing to find that, we fall + // back onto the Microsoft cmap encoding. + if pidPsid == unicodeEncoding { + bestOffset, bestPID, ok = offset, pidPsid>>16, true + break + + } else if pidPsid == microsoftSymbolEncoding || + pidPsid == microsoftUCS2Encoding || + pidPsid == microsoftUCS4Encoding { + + bestOffset, bestPID, ok = offset, pidPsid>>16, true + // We don't break out of the for loop, so that Unicode can override Microsoft. + } + } + if !ok { + return 0, 0, UnsupportedError(name + " encoding") + } + return bestOffset, bestPID, nil +} + +const ( + locaOffsetFormatUnknown int = iota + locaOffsetFormatShort + locaOffsetFormatLong +) + +// A cm holds a parsed cmap entry. +type cm struct { + start, end, delta, offset uint32 +} + +// A Font represents a Truetype font. +type Font struct { + // Tables sliced from the TTF data. The different tables are documented + // at http://developer.apple.com/fonts/TTRefMan/RM06/Chap6.html + cmap, cvt, fpgm, glyf, hdmx, head, hhea, hmtx, kern, loca, maxp, name, os2, prep, vmtx []byte + + cmapIndexes []byte + + // Cached values derived from the raw ttf data. + cm []cm + locaOffsetFormat int + nGlyph, nHMetric, nKern int + fUnitsPerEm int32 + ascent int32 // In FUnits. + descent int32 // In FUnits; typically negative. + bounds fixed.Rectangle26_6 // In FUnits. + // Values from the maxp section. + maxTwilightPoints, maxStorage, maxFunctionDefs, maxStackElements uint16 +} + +func (f *Font) parseCmap() error { + const ( + cmapFormat4 = 4 + cmapFormat12 = 12 + languageIndependent = 0 + ) + + offset, _, err := parseSubtables(f.cmap, "cmap", 4, 8, nil) + if err != nil { + return err + } + offset = int(u32(f.cmap, offset+4)) + if offset <= 0 || offset > len(f.cmap) { + return FormatError("bad cmap offset") + } + + cmapFormat := u16(f.cmap, offset) + switch cmapFormat { + case cmapFormat4: + language := u16(f.cmap, offset+4) + if language != languageIndependent { + return UnsupportedError(fmt.Sprintf("language: %d", language)) + } + segCountX2 := int(u16(f.cmap, offset+6)) + if segCountX2%2 == 1 { + return FormatError(fmt.Sprintf("bad segCountX2: %d", segCountX2)) + } + segCount := segCountX2 / 2 + offset += 14 + f.cm = make([]cm, segCount) + for i := 0; i < segCount; i++ { + f.cm[i].end = uint32(u16(f.cmap, offset)) + offset += 2 + } + offset += 2 + for i := 0; i < segCount; i++ { + f.cm[i].start = uint32(u16(f.cmap, offset)) + offset += 2 + } + for i := 0; i < segCount; i++ { + f.cm[i].delta = uint32(u16(f.cmap, offset)) + offset += 2 + } + for i := 0; i < segCount; i++ { + f.cm[i].offset = uint32(u16(f.cmap, offset)) + offset += 2 + } + f.cmapIndexes = f.cmap[offset:] + return nil + + case cmapFormat12: + if u16(f.cmap, offset+2) != 0 { + return FormatError(fmt.Sprintf("cmap format: % x", f.cmap[offset:offset+4])) + } + length := u32(f.cmap, offset+4) + language := u32(f.cmap, offset+8) + if language != languageIndependent { + return UnsupportedError(fmt.Sprintf("language: %d", language)) + } + nGroups := u32(f.cmap, offset+12) + if length != 12*nGroups+16 { + return FormatError("inconsistent cmap length") + } + offset += 16 + f.cm = make([]cm, nGroups) + for i := uint32(0); i < nGroups; i++ { + f.cm[i].start = u32(f.cmap, offset+0) + f.cm[i].end = u32(f.cmap, offset+4) + f.cm[i].delta = u32(f.cmap, offset+8) - f.cm[i].start + offset += 12 + } + return nil + } + return UnsupportedError(fmt.Sprintf("cmap format: %d", cmapFormat)) +} + +func (f *Font) parseHead() error { + if len(f.head) != 54 { + return FormatError(fmt.Sprintf("bad head length: %d", len(f.head))) + } + f.fUnitsPerEm = int32(u16(f.head, 18)) + f.bounds.Min.X = fixed.Int26_6(int16(u16(f.head, 36))) + f.bounds.Min.Y = fixed.Int26_6(int16(u16(f.head, 38))) + f.bounds.Max.X = fixed.Int26_6(int16(u16(f.head, 40))) + f.bounds.Max.Y = fixed.Int26_6(int16(u16(f.head, 42))) + switch i := u16(f.head, 50); i { + case 0: + f.locaOffsetFormat = locaOffsetFormatShort + case 1: + f.locaOffsetFormat = locaOffsetFormatLong + default: + return FormatError(fmt.Sprintf("bad indexToLocFormat: %d", i)) + } + return nil +} + +func (f *Font) parseHhea() error { + if len(f.hhea) != 36 { + return FormatError(fmt.Sprintf("bad hhea length: %d", len(f.hhea))) + } + f.ascent = int32(int16(u16(f.hhea, 4))) + f.descent = int32(int16(u16(f.hhea, 6))) + f.nHMetric = int(u16(f.hhea, 34)) + if 4*f.nHMetric+2*(f.nGlyph-f.nHMetric) != len(f.hmtx) { + return FormatError(fmt.Sprintf("bad hmtx length: %d", len(f.hmtx))) + } + return nil +} + +func (f *Font) parseKern() error { + // Apple's TrueType documentation (http://developer.apple.com/fonts/TTRefMan/RM06/Chap6kern.html) says: + // "Previous versions of the 'kern' table defined both the version and nTables fields in the header + // as UInt16 values and not UInt32 values. Use of the older format on the Mac OS is discouraged + // (although AAT can sense an old kerning table and still make correct use of it). Microsoft + // Windows still uses the older format for the 'kern' table and will not recognize the newer one. + // Fonts targeted for the Mac OS only should use the new format; fonts targeted for both the Mac OS + // and Windows should use the old format." + // Since we expect that almost all fonts aim to be Windows-compatible, we only parse the "older" format, + // just like the C Freetype implementation. + if len(f.kern) == 0 { + if f.nKern != 0 { + return FormatError("bad kern table length") + } + return nil + } + if len(f.kern) < 18 { + return FormatError("kern data too short") + } + version, offset := u16(f.kern, 0), 2 + if version != 0 { + return UnsupportedError(fmt.Sprintf("kern version: %d", version)) + } + n, offset := u16(f.kern, offset), offset+2 + if n != 1 { + return UnsupportedError(fmt.Sprintf("kern nTables: %d", n)) + } + offset += 2 + length, offset := int(u16(f.kern, offset)), offset+2 + coverage, offset := u16(f.kern, offset), offset+2 + if coverage != 0x0001 { + // We only support horizontal kerning. + return UnsupportedError(fmt.Sprintf("kern coverage: 0x%04x", coverage)) + } + f.nKern, offset = int(u16(f.kern, offset)), offset+2 + if 6*f.nKern != length-14 { + return FormatError("bad kern table length") + } + return nil +} + +func (f *Font) parseMaxp() error { + if len(f.maxp) != 32 { + return FormatError(fmt.Sprintf("bad maxp length: %d", len(f.maxp))) + } + f.nGlyph = int(u16(f.maxp, 4)) + f.maxTwilightPoints = u16(f.maxp, 16) + f.maxStorage = u16(f.maxp, 18) + f.maxFunctionDefs = u16(f.maxp, 20) + f.maxStackElements = u16(f.maxp, 24) + return nil +} + +// scale returns x divided by f.fUnitsPerEm, rounded to the nearest integer. +func (f *Font) scale(x fixed.Int26_6) fixed.Int26_6 { + if x >= 0 { + x += fixed.Int26_6(f.fUnitsPerEm) / 2 + } else { + x -= fixed.Int26_6(f.fUnitsPerEm) / 2 + } + return x / fixed.Int26_6(f.fUnitsPerEm) +} + +// Bounds returns the union of a Font's glyphs' bounds. +func (f *Font) Bounds(scale fixed.Int26_6) fixed.Rectangle26_6 { + b := f.bounds + b.Min.X = f.scale(scale * b.Min.X) + b.Min.Y = f.scale(scale * b.Min.Y) + b.Max.X = f.scale(scale * b.Max.X) + b.Max.Y = f.scale(scale * b.Max.Y) + return b +} + +// FUnitsPerEm returns the number of FUnits in a Font's em-square's side. +func (f *Font) FUnitsPerEm() int32 { + return f.fUnitsPerEm +} + +// Index returns a Font's index for the given rune. +func (f *Font) Index(x rune) Index { + c := uint32(x) + for i, j := 0, len(f.cm); i < j; { + h := i + (j-i)/2 + cm := &f.cm[h] + if c < cm.start { + j = h + } else if cm.end < c { + i = h + 1 + } else if cm.offset == 0 { + return Index(c + cm.delta) + } else { + offset := int(cm.offset) + 2*(h-len(f.cm)+int(c-cm.start)) + return Index(u16(f.cmapIndexes, offset)) + } + } + return 0 +} + +// Name returns the Font's name value for the given NameID. It returns "" if +// there was an error, or if that name was not found. +func (f *Font) Name(id NameID) string { + x, platformID, err := parseSubtables(f.name, "name", 6, 12, func(b []byte) bool { + return NameID(u16(b, 6)) == id + }) + if err != nil { + return "" + } + offset, length := u16(f.name, 4)+u16(f.name, x+10), u16(f.name, x+8) + // Return the ASCII value of the encoded string. + // The string is encoded as UTF-16 on non-Apple platformIDs; Apple is platformID 1. + src := f.name[offset : offset+length] + var dst []byte + if platformID != 1 { // UTF-16. + if len(src)&1 != 0 { + return "" + } + dst = make([]byte, len(src)/2) + for i := range dst { + dst[i] = printable(u16(src, 2*i)) + } + } else { // ASCII. + dst = make([]byte, len(src)) + for i, c := range src { + dst[i] = printable(uint16(c)) + } + } + return string(dst) +} + +func printable(r uint16) byte { + if 0x20 <= r && r < 0x7f { + return byte(r) + } + return '?' +} + +// unscaledHMetric returns the unscaled horizontal metrics for the glyph with +// the given index. +func (f *Font) unscaledHMetric(i Index) (h HMetric) { + j := int(i) + if j < 0 || f.nGlyph <= j { + return HMetric{} + } + if j >= f.nHMetric { + p := 4 * (f.nHMetric - 1) + return HMetric{ + AdvanceWidth: fixed.Int26_6(u16(f.hmtx, p)), + LeftSideBearing: fixed.Int26_6(int16(u16(f.hmtx, p+2*(j-f.nHMetric)+4))), + } + } + return HMetric{ + AdvanceWidth: fixed.Int26_6(u16(f.hmtx, 4*j)), + LeftSideBearing: fixed.Int26_6(int16(u16(f.hmtx, 4*j+2))), + } +} + +// HMetric returns the horizontal metrics for the glyph with the given index. +func (f *Font) HMetric(scale fixed.Int26_6, i Index) HMetric { + h := f.unscaledHMetric(i) + h.AdvanceWidth = f.scale(scale * h.AdvanceWidth) + h.LeftSideBearing = f.scale(scale * h.LeftSideBearing) + return h +} + +// unscaledVMetric returns the unscaled vertical metrics for the glyph with +// the given index. yMax is the top of the glyph's bounding box. +func (f *Font) unscaledVMetric(i Index, yMax fixed.Int26_6) (v VMetric) { + j := int(i) + if j < 0 || f.nGlyph <= j { + return VMetric{} + } + if 4*j+4 <= len(f.vmtx) { + return VMetric{ + AdvanceHeight: fixed.Int26_6(u16(f.vmtx, 4*j)), + TopSideBearing: fixed.Int26_6(int16(u16(f.vmtx, 4*j+2))), + } + } + // The OS/2 table has grown over time. + // https://developer.apple.com/fonts/TTRefMan/RM06/Chap6OS2.html + // says that it was originally 68 bytes. Optional fields, including + // the ascender and descender, are described at + // http://www.microsoft.com/typography/otspec/os2.htm + if len(f.os2) >= 72 { + sTypoAscender := fixed.Int26_6(int16(u16(f.os2, 68))) + sTypoDescender := fixed.Int26_6(int16(u16(f.os2, 70))) + return VMetric{ + AdvanceHeight: sTypoAscender - sTypoDescender, + TopSideBearing: sTypoAscender - yMax, + } + } + return VMetric{ + AdvanceHeight: fixed.Int26_6(f.fUnitsPerEm), + TopSideBearing: 0, + } +} + +// VMetric returns the vertical metrics for the glyph with the given index. +func (f *Font) VMetric(scale fixed.Int26_6, i Index) VMetric { + // TODO: should 0 be bounds.YMax? + v := f.unscaledVMetric(i, 0) + v.AdvanceHeight = f.scale(scale * v.AdvanceHeight) + v.TopSideBearing = f.scale(scale * v.TopSideBearing) + return v +} + +// Kern returns the horizontal adjustment for the given glyph pair. A positive +// kern means to move the glyphs further apart. +func (f *Font) Kern(scale fixed.Int26_6, i0, i1 Index) fixed.Int26_6 { + if f.nKern == 0 { + return 0 + } + g := uint32(i0)<<16 | uint32(i1) + lo, hi := 0, f.nKern + for lo < hi { + i := (lo + hi) / 2 + ig := u32(f.kern, 18+6*i) + if ig < g { + lo = i + 1 + } else if ig > g { + hi = i + } else { + return f.scale(scale * fixed.Int26_6(int16(u16(f.kern, 22+6*i)))) + } + } + return 0 +} + +// Parse returns a new Font for the given TTF or TTC data. +// +// For TrueType Collections, the first font in the collection is parsed. +func Parse(ttf []byte) (font *Font, err error) { + return parse(ttf, 0) +} + +func parse(ttf []byte, offset int) (font *Font, err error) { + if len(ttf)-offset < 12 { + err = FormatError("TTF data is too short") + return + } + originalOffset := offset + magic, offset := u32(ttf, offset), offset+4 + switch magic { + case 0x00010000: + // No-op. + case 0x74746366: // "ttcf" as a big-endian uint32. + if originalOffset != 0 { + err = FormatError("recursive TTC") + return + } + ttcVersion, offset := u32(ttf, offset), offset+4 + if ttcVersion != 0x00010000 { + // TODO: support TTC version 2.0, once I have such a .ttc file to test with. + err = FormatError("bad TTC version") + return + } + numFonts, offset := int(u32(ttf, offset)), offset+4 + if numFonts <= 0 { + err = FormatError("bad number of TTC fonts") + return + } + if len(ttf[offset:])/4 < numFonts { + err = FormatError("TTC offset table is too short") + return + } + // TODO: provide an API to select which font in a TrueType collection to return, + // not just the first one. This may require an API to parse a TTC's name tables, + // so users of this package can select the font in a TTC by name. + offset = int(u32(ttf, offset)) + if offset <= 0 || offset > len(ttf) { + err = FormatError("bad TTC offset") + return + } + return parse(ttf, offset) + default: + err = FormatError("bad TTF version") + return + } + n, offset := int(u16(ttf, offset)), offset+2 + if len(ttf) < 16*n+12 { + err = FormatError("TTF data is too short") + return + } + f := new(Font) + // Assign the table slices. + for i := 0; i < n; i++ { + x := 16*i + 12 + switch string(ttf[x : x+4]) { + case "cmap": + f.cmap, err = readTable(ttf, ttf[x+8:x+16]) + case "cvt ": + f.cvt, err = readTable(ttf, ttf[x+8:x+16]) + case "fpgm": + f.fpgm, err = readTable(ttf, ttf[x+8:x+16]) + case "glyf": + f.glyf, err = readTable(ttf, ttf[x+8:x+16]) + case "hdmx": + f.hdmx, err = readTable(ttf, ttf[x+8:x+16]) + case "head": + f.head, err = readTable(ttf, ttf[x+8:x+16]) + case "hhea": + f.hhea, err = readTable(ttf, ttf[x+8:x+16]) + case "hmtx": + f.hmtx, err = readTable(ttf, ttf[x+8:x+16]) + case "kern": + f.kern, err = readTable(ttf, ttf[x+8:x+16]) + case "loca": + f.loca, err = readTable(ttf, ttf[x+8:x+16]) + case "maxp": + f.maxp, err = readTable(ttf, ttf[x+8:x+16]) + case "name": + f.name, err = readTable(ttf, ttf[x+8:x+16]) + case "OS/2": + f.os2, err = readTable(ttf, ttf[x+8:x+16]) + case "prep": + f.prep, err = readTable(ttf, ttf[x+8:x+16]) + case "vmtx": + f.vmtx, err = readTable(ttf, ttf[x+8:x+16]) + } + if err != nil { + return + } + } + // Parse and sanity-check the TTF data. + if err = f.parseHead(); err != nil { + return + } + if err = f.parseMaxp(); err != nil { + return + } + if err = f.parseCmap(); err != nil { + return + } + if err = f.parseKern(); err != nil { + return + } + if err = f.parseHhea(); err != nil { + return + } + font = f + return +} diff --git a/vendor/github.com/golang/protobuf/LICENSE b/vendor/github.com/golang/protobuf/LICENSE new file mode 100644 index 00000000..1b1b1921 --- /dev/null +++ b/vendor/github.com/golang/protobuf/LICENSE @@ -0,0 +1,31 @@ +Go support for Protocol Buffers - Google's data interchange format + +Copyright 2010 The Go Authors. All rights reserved. +https://github.com/golang/protobuf + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go b/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go new file mode 100644 index 00000000..38f86c5f --- /dev/null +++ b/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go @@ -0,0 +1,832 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2015 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* +Package jsonpb provides marshaling and unmarshaling between protocol buffers and JSON. +It follows the specification at https://developers.google.com/protocol-buffers/docs/proto3#json. + +This package produces a different output than the standard "encoding/json" package, +which does not operate correctly on protocol buffers. +*/ +package jsonpb + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "io" + "reflect" + "sort" + "strconv" + "strings" + "time" + + "github.com/golang/protobuf/proto" +) + +// Marshaler is a configurable object for converting between +// protocol buffer objects and a JSON representation for them. +type Marshaler struct { + // Whether to render enum values as integers, as opposed to string values. + EnumsAsInts bool + + // Whether to render fields with zero values. + EmitDefaults bool + + // A string to indent each level by. The presence of this field will + // also cause a space to appear between the field separator and + // value, and for newlines to be appear between fields and array + // elements. + Indent string + + // Whether to use the original (.proto) name for fields. + OrigName bool +} + +// Marshal marshals a protocol buffer into JSON. +func (m *Marshaler) Marshal(out io.Writer, pb proto.Message) error { + writer := &errWriter{writer: out} + return m.marshalObject(writer, pb, "", "") +} + +// MarshalToString converts a protocol buffer object to JSON string. +func (m *Marshaler) MarshalToString(pb proto.Message) (string, error) { + var buf bytes.Buffer + if err := m.Marshal(&buf, pb); err != nil { + return "", err + } + return buf.String(), nil +} + +type int32Slice []int32 + +// For sorting extensions ids to ensure stable output. +func (s int32Slice) Len() int { return len(s) } +func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] } +func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + +type wkt interface { + XXX_WellKnownType() string +} + +// marshalObject writes a struct to the Writer. +func (m *Marshaler) marshalObject(out *errWriter, v proto.Message, indent, typeURL string) error { + s := reflect.ValueOf(v).Elem() + + // Handle well-known types. + if wkt, ok := v.(wkt); ok { + switch wkt.XXX_WellKnownType() { + case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value", + "Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue": + // "Wrappers use the same representation in JSON + // as the wrapped primitive type, ..." + sprop := proto.GetProperties(s.Type()) + return m.marshalValue(out, sprop.Prop[0], s.Field(0), indent) + case "Any": + // Any is a bit more involved. + return m.marshalAny(out, v, indent) + case "Duration": + // "Generated output always contains 3, 6, or 9 fractional digits, + // depending on required precision." + s, ns := s.Field(0).Int(), s.Field(1).Int() + d := time.Duration(s)*time.Second + time.Duration(ns)*time.Nanosecond + x := fmt.Sprintf("%.9f", d.Seconds()) + x = strings.TrimSuffix(x, "000") + x = strings.TrimSuffix(x, "000") + out.write(`"`) + out.write(x) + out.write(`s"`) + return out.err + case "Struct": + // Let marshalValue handle the `fields` map. + // TODO: pass the correct Properties if needed. + return m.marshalValue(out, &proto.Properties{}, s.Field(0), indent) + case "Timestamp": + // "RFC 3339, where generated output will always be Z-normalized + // and uses 3, 6 or 9 fractional digits." + s, ns := s.Field(0).Int(), s.Field(1).Int() + t := time.Unix(s, ns).UTC() + // time.RFC3339Nano isn't exactly right (we need to get 3/6/9 fractional digits). + x := t.Format("2006-01-02T15:04:05.000000000") + x = strings.TrimSuffix(x, "000") + x = strings.TrimSuffix(x, "000") + out.write(`"`) + out.write(x) + out.write(`Z"`) + return out.err + case "Value": + // Value has a single oneof. + kind := s.Field(0) + if kind.IsNil() { + // "absence of any variant indicates an error" + return errors.New("nil Value") + } + // oneof -> *T -> T -> T.F + x := kind.Elem().Elem().Field(0) + // TODO: pass the correct Properties if needed. + return m.marshalValue(out, &proto.Properties{}, x, indent) + } + } + + out.write("{") + if m.Indent != "" { + out.write("\n") + } + + firstField := true + + if typeURL != "" { + if err := m.marshalTypeURL(out, indent, typeURL); err != nil { + return err + } + firstField = false + } + + for i := 0; i < s.NumField(); i++ { + value := s.Field(i) + valueField := s.Type().Field(i) + if strings.HasPrefix(valueField.Name, "XXX_") { + continue + } + + // IsNil will panic on most value kinds. + switch value.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + if value.IsNil() { + continue + } + } + + if !m.EmitDefaults { + switch value.Kind() { + case reflect.Bool: + if !value.Bool() { + continue + } + case reflect.Int32, reflect.Int64: + if value.Int() == 0 { + continue + } + case reflect.Uint32, reflect.Uint64: + if value.Uint() == 0 { + continue + } + case reflect.Float32, reflect.Float64: + if value.Float() == 0 { + continue + } + case reflect.String: + if value.Len() == 0 { + continue + } + } + } + + // Oneof fields need special handling. + if valueField.Tag.Get("protobuf_oneof") != "" { + // value is an interface containing &T{real_value}. + sv := value.Elem().Elem() // interface -> *T -> T + value = sv.Field(0) + valueField = sv.Type().Field(0) + } + prop := jsonProperties(valueField, m.OrigName) + if !firstField { + m.writeSep(out) + } + if err := m.marshalField(out, prop, value, indent); err != nil { + return err + } + firstField = false + } + + // Handle proto2 extensions. + if ep, ok := v.(proto.Message); ok { + extensions := proto.RegisteredExtensions(v) + // Sort extensions for stable output. + ids := make([]int32, 0, len(extensions)) + for id, desc := range extensions { + if !proto.HasExtension(ep, desc) { + continue + } + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) + for _, id := range ids { + desc := extensions[id] + if desc == nil { + // unknown extension + continue + } + ext, extErr := proto.GetExtension(ep, desc) + if extErr != nil { + return extErr + } + value := reflect.ValueOf(ext) + var prop proto.Properties + prop.Parse(desc.Tag) + prop.JSONName = fmt.Sprintf("[%s]", desc.Name) + if !firstField { + m.writeSep(out) + } + if err := m.marshalField(out, &prop, value, indent); err != nil { + return err + } + firstField = false + } + + } + + if m.Indent != "" { + out.write("\n") + out.write(indent) + } + out.write("}") + return out.err +} + +func (m *Marshaler) writeSep(out *errWriter) { + if m.Indent != "" { + out.write(",\n") + } else { + out.write(",") + } +} + +func (m *Marshaler) marshalAny(out *errWriter, any proto.Message, indent string) error { + // "If the Any contains a value that has a special JSON mapping, + // it will be converted as follows: {"@type": xxx, "value": yyy}. + // Otherwise, the value will be converted into a JSON object, + // and the "@type" field will be inserted to indicate the actual data type." + v := reflect.ValueOf(any).Elem() + turl := v.Field(0).String() + val := v.Field(1).Bytes() + + // Only the part of type_url after the last slash is relevant. + mname := turl + if slash := strings.LastIndex(mname, "/"); slash >= 0 { + mname = mname[slash+1:] + } + mt := proto.MessageType(mname) + if mt == nil { + return fmt.Errorf("unknown message type %q", mname) + } + msg := reflect.New(mt.Elem()).Interface().(proto.Message) + if err := proto.Unmarshal(val, msg); err != nil { + return err + } + + if _, ok := msg.(wkt); ok { + out.write("{") + if m.Indent != "" { + out.write("\n") + } + if err := m.marshalTypeURL(out, indent, turl); err != nil { + return err + } + m.writeSep(out) + if m.Indent != "" { + out.write(indent) + out.write(m.Indent) + out.write(`"value": `) + } else { + out.write(`"value":`) + } + if err := m.marshalObject(out, msg, indent+m.Indent, ""); err != nil { + return err + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + } + out.write("}") + return out.err + } + + return m.marshalObject(out, msg, indent, turl) +} + +func (m *Marshaler) marshalTypeURL(out *errWriter, indent, typeURL string) error { + if m.Indent != "" { + out.write(indent) + out.write(m.Indent) + } + out.write(`"@type":`) + if m.Indent != "" { + out.write(" ") + } + b, err := json.Marshal(typeURL) + if err != nil { + return err + } + out.write(string(b)) + return out.err +} + +// marshalField writes field description and value to the Writer. +func (m *Marshaler) marshalField(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error { + if m.Indent != "" { + out.write(indent) + out.write(m.Indent) + } + out.write(`"`) + out.write(prop.JSONName) + out.write(`":`) + if m.Indent != "" { + out.write(" ") + } + if err := m.marshalValue(out, prop, v, indent); err != nil { + return err + } + return nil +} + +// marshalValue writes the value to the Writer. +func (m *Marshaler) marshalValue(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error { + + var err error + v = reflect.Indirect(v) + + // Handle repeated elements. + if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 { + out.write("[") + comma := "" + for i := 0; i < v.Len(); i++ { + sliceVal := v.Index(i) + out.write(comma) + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + out.write(m.Indent) + } + if err := m.marshalValue(out, prop, sliceVal, indent+m.Indent); err != nil { + return err + } + comma = "," + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + } + out.write("]") + return out.err + } + + // Handle well-known types. + // Most are handled up in marshalObject (because 99% are messages). + type wkt interface { + XXX_WellKnownType() string + } + if wkt, ok := v.Interface().(wkt); ok { + switch wkt.XXX_WellKnownType() { + case "NullValue": + out.write("null") + return out.err + } + } + + // Handle enumerations. + if !m.EnumsAsInts && prop.Enum != "" { + // Unknown enum values will are stringified by the proto library as their + // value. Such values should _not_ be quoted or they will be interpreted + // as an enum string instead of their value. + enumStr := v.Interface().(fmt.Stringer).String() + var valStr string + if v.Kind() == reflect.Ptr { + valStr = strconv.Itoa(int(v.Elem().Int())) + } else { + valStr = strconv.Itoa(int(v.Int())) + } + isKnownEnum := enumStr != valStr + if isKnownEnum { + out.write(`"`) + } + out.write(enumStr) + if isKnownEnum { + out.write(`"`) + } + return out.err + } + + // Handle nested messages. + if v.Kind() == reflect.Struct { + return m.marshalObject(out, v.Addr().Interface().(proto.Message), indent+m.Indent, "") + } + + // Handle maps. + // Since Go randomizes map iteration, we sort keys for stable output. + if v.Kind() == reflect.Map { + out.write(`{`) + keys := v.MapKeys() + sort.Sort(mapKeys(keys)) + for i, k := range keys { + if i > 0 { + out.write(`,`) + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + out.write(m.Indent) + } + + b, err := json.Marshal(k.Interface()) + if err != nil { + return err + } + s := string(b) + + // If the JSON is not a string value, encode it again to make it one. + if !strings.HasPrefix(s, `"`) { + b, err := json.Marshal(s) + if err != nil { + return err + } + s = string(b) + } + + out.write(s) + out.write(`:`) + if m.Indent != "" { + out.write(` `) + } + + if err := m.marshalValue(out, prop, v.MapIndex(k), indent+m.Indent); err != nil { + return err + } + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + } + out.write(`}`) + return out.err + } + + // Default handling defers to the encoding/json library. + b, err := json.Marshal(v.Interface()) + if err != nil { + return err + } + needToQuote := string(b[0]) != `"` && (v.Kind() == reflect.Int64 || v.Kind() == reflect.Uint64) + if needToQuote { + out.write(`"`) + } + out.write(string(b)) + if needToQuote { + out.write(`"`) + } + return out.err +} + +// Unmarshaler is a configurable object for converting from a JSON +// representation to a protocol buffer object. +type Unmarshaler struct { + // Whether to allow messages to contain unknown fields, as opposed to + // failing to unmarshal. + AllowUnknownFields bool +} + +// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream. +// This function is lenient and will decode any options permutations of the +// related Marshaler. +func (u *Unmarshaler) UnmarshalNext(dec *json.Decoder, pb proto.Message) error { + inputValue := json.RawMessage{} + if err := dec.Decode(&inputValue); err != nil { + return err + } + return u.unmarshalValue(reflect.ValueOf(pb).Elem(), inputValue, nil) +} + +// Unmarshal unmarshals a JSON object stream into a protocol +// buffer. This function is lenient and will decode any options +// permutations of the related Marshaler. +func (u *Unmarshaler) Unmarshal(r io.Reader, pb proto.Message) error { + dec := json.NewDecoder(r) + return u.UnmarshalNext(dec, pb) +} + +// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream. +// This function is lenient and will decode any options permutations of the +// related Marshaler. +func UnmarshalNext(dec *json.Decoder, pb proto.Message) error { + return new(Unmarshaler).UnmarshalNext(dec, pb) +} + +// Unmarshal unmarshals a JSON object stream into a protocol +// buffer. This function is lenient and will decode any options +// permutations of the related Marshaler. +func Unmarshal(r io.Reader, pb proto.Message) error { + return new(Unmarshaler).Unmarshal(r, pb) +} + +// UnmarshalString will populate the fields of a protocol buffer based +// on a JSON string. This function is lenient and will decode any options +// permutations of the related Marshaler. +func UnmarshalString(str string, pb proto.Message) error { + return new(Unmarshaler).Unmarshal(strings.NewReader(str), pb) +} + +// unmarshalValue converts/copies a value into the target. +// prop may be nil. +func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMessage, prop *proto.Properties) error { + targetType := target.Type() + + // Allocate memory for pointer fields. + if targetType.Kind() == reflect.Ptr { + target.Set(reflect.New(targetType.Elem())) + return u.unmarshalValue(target.Elem(), inputValue, prop) + } + + // Handle well-known types. + type wkt interface { + XXX_WellKnownType() string + } + if wkt, ok := target.Addr().Interface().(wkt); ok { + switch wkt.XXX_WellKnownType() { + case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value", + "Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue": + // "Wrappers use the same representation in JSON + // as the wrapped primitive type, except that null is allowed." + // encoding/json will turn JSON `null` into Go `nil`, + // so we don't have to do any extra work. + return u.unmarshalValue(target.Field(0), inputValue, prop) + case "Any": + return fmt.Errorf("unmarshaling Any not supported yet") + case "Duration": + unq, err := strconv.Unquote(string(inputValue)) + if err != nil { + return err + } + d, err := time.ParseDuration(unq) + if err != nil { + return fmt.Errorf("bad Duration: %v", err) + } + ns := d.Nanoseconds() + s := ns / 1e9 + ns %= 1e9 + target.Field(0).SetInt(s) + target.Field(1).SetInt(ns) + return nil + case "Timestamp": + unq, err := strconv.Unquote(string(inputValue)) + if err != nil { + return err + } + t, err := time.Parse(time.RFC3339Nano, unq) + if err != nil { + return fmt.Errorf("bad Timestamp: %v", err) + } + ns := t.UnixNano() + s := ns / 1e9 + ns %= 1e9 + target.Field(0).SetInt(s) + target.Field(1).SetInt(ns) + return nil + } + } + + // Handle enums, which have an underlying type of int32, + // and may appear as strings. + // The case of an enum appearing as a number is handled + // at the bottom of this function. + if inputValue[0] == '"' && prop != nil && prop.Enum != "" { + vmap := proto.EnumValueMap(prop.Enum) + // Don't need to do unquoting; valid enum names + // are from a limited character set. + s := inputValue[1 : len(inputValue)-1] + n, ok := vmap[string(s)] + if !ok { + return fmt.Errorf("unknown value %q for enum %s", s, prop.Enum) + } + if target.Kind() == reflect.Ptr { // proto2 + target.Set(reflect.New(targetType.Elem())) + target = target.Elem() + } + target.SetInt(int64(n)) + return nil + } + + // Handle nested messages. + if targetType.Kind() == reflect.Struct { + var jsonFields map[string]json.RawMessage + if err := json.Unmarshal(inputValue, &jsonFields); err != nil { + return err + } + + consumeField := func(prop *proto.Properties) (json.RawMessage, bool) { + // Be liberal in what names we accept; both orig_name and camelName are okay. + fieldNames := acceptedJSONFieldNames(prop) + + vOrig, okOrig := jsonFields[fieldNames.orig] + vCamel, okCamel := jsonFields[fieldNames.camel] + if !okOrig && !okCamel { + return nil, false + } + // If, for some reason, both are present in the data, favour the camelName. + var raw json.RawMessage + if okOrig { + raw = vOrig + delete(jsonFields, fieldNames.orig) + } + if okCamel { + raw = vCamel + delete(jsonFields, fieldNames.camel) + } + return raw, true + } + + sprops := proto.GetProperties(targetType) + for i := 0; i < target.NumField(); i++ { + ft := target.Type().Field(i) + if strings.HasPrefix(ft.Name, "XXX_") { + continue + } + + valueForField, ok := consumeField(sprops.Prop[i]) + if !ok { + continue + } + + if err := u.unmarshalValue(target.Field(i), valueForField, sprops.Prop[i]); err != nil { + return err + } + } + // Check for any oneof fields. + if len(jsonFields) > 0 { + for _, oop := range sprops.OneofTypes { + raw, ok := consumeField(oop.Prop) + if !ok { + continue + } + nv := reflect.New(oop.Type.Elem()) + target.Field(oop.Field).Set(nv) + if err := u.unmarshalValue(nv.Elem().Field(0), raw, oop.Prop); err != nil { + return err + } + } + } + if !u.AllowUnknownFields && len(jsonFields) > 0 { + // Pick any field to be the scapegoat. + var f string + for fname := range jsonFields { + f = fname + break + } + return fmt.Errorf("unknown field %q in %v", f, targetType) + } + return nil + } + + // Handle arrays (which aren't encoded bytes) + if targetType.Kind() == reflect.Slice && targetType.Elem().Kind() != reflect.Uint8 { + var slc []json.RawMessage + if err := json.Unmarshal(inputValue, &slc); err != nil { + return err + } + len := len(slc) + target.Set(reflect.MakeSlice(targetType, len, len)) + for i := 0; i < len; i++ { + if err := u.unmarshalValue(target.Index(i), slc[i], prop); err != nil { + return err + } + } + return nil + } + + // Handle maps (whose keys are always strings) + if targetType.Kind() == reflect.Map { + var mp map[string]json.RawMessage + if err := json.Unmarshal(inputValue, &mp); err != nil { + return err + } + target.Set(reflect.MakeMap(targetType)) + var keyprop, valprop *proto.Properties + if prop != nil { + // These could still be nil if the protobuf metadata is broken somehow. + // TODO: This won't work because the fields are unexported. + // We should probably just reparse them. + //keyprop, valprop = prop.mkeyprop, prop.mvalprop + } + for ks, raw := range mp { + // Unmarshal map key. The core json library already decoded the key into a + // string, so we handle that specially. Other types were quoted post-serialization. + var k reflect.Value + if targetType.Key().Kind() == reflect.String { + k = reflect.ValueOf(ks) + } else { + k = reflect.New(targetType.Key()).Elem() + if err := u.unmarshalValue(k, json.RawMessage(ks), keyprop); err != nil { + return err + } + } + + // Unmarshal map value. + v := reflect.New(targetType.Elem()).Elem() + if err := u.unmarshalValue(v, raw, valprop); err != nil { + return err + } + target.SetMapIndex(k, v) + } + return nil + } + + // 64-bit integers can be encoded as strings. In this case we drop + // the quotes and proceed as normal. + isNum := targetType.Kind() == reflect.Int64 || targetType.Kind() == reflect.Uint64 + if isNum && strings.HasPrefix(string(inputValue), `"`) { + inputValue = inputValue[1 : len(inputValue)-1] + } + + // Use the encoding/json for parsing other value types. + return json.Unmarshal(inputValue, target.Addr().Interface()) +} + +// jsonProperties returns parsed proto.Properties for the field and corrects JSONName attribute. +func jsonProperties(f reflect.StructField, origName bool) *proto.Properties { + var prop proto.Properties + prop.Init(f.Type, f.Name, f.Tag.Get("protobuf"), &f) + if origName || prop.JSONName == "" { + prop.JSONName = prop.OrigName + } + return &prop +} + +type fieldNames struct { + orig, camel string +} + +func acceptedJSONFieldNames(prop *proto.Properties) fieldNames { + opts := fieldNames{orig: prop.OrigName, camel: prop.OrigName} + if prop.JSONName != "" { + opts.camel = prop.JSONName + } + return opts +} + +// Writer wrapper inspired by https://blog.golang.org/errors-are-values +type errWriter struct { + writer io.Writer + err error +} + +func (w *errWriter) write(str string) { + if w.err != nil { + return + } + _, w.err = w.writer.Write([]byte(str)) +} + +// Map fields may have key types of non-float scalars, strings and enums. +// The easiest way to sort them in some deterministic order is to use fmt. +// If this turns out to be inefficient we can always consider other options, +// such as doing a Schwartzian transform. +// +// Numeric keys are sorted in numeric order per +// https://developers.google.com/protocol-buffers/docs/proto#maps. +type mapKeys []reflect.Value + +func (s mapKeys) Len() int { return len(s) } +func (s mapKeys) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s mapKeys) Less(i, j int) bool { + if k := s[i].Kind(); k == s[j].Kind() { + switch k { + case reflect.Int32, reflect.Int64: + return s[i].Int() < s[j].Int() + case reflect.Uint32, reflect.Uint64: + return s[i].Uint() < s[j].Uint() + } + } + return fmt.Sprint(s[i].Interface()) < fmt.Sprint(s[j].Interface()) +} diff --git a/vendor/github.com/golang/protobuf/proto/clone.go b/vendor/github.com/golang/protobuf/proto/clone.go new file mode 100644 index 00000000..e392575b --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/clone.go @@ -0,0 +1,229 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Protocol buffer deep copy and merge. +// TODO: RawMessage. + +package proto + +import ( + "log" + "reflect" + "strings" +) + +// Clone returns a deep copy of a protocol buffer. +func Clone(pb Message) Message { + in := reflect.ValueOf(pb) + if in.IsNil() { + return pb + } + + out := reflect.New(in.Type().Elem()) + // out is empty so a merge is a deep copy. + mergeStruct(out.Elem(), in.Elem()) + return out.Interface().(Message) +} + +// Merge merges src into dst. +// Required and optional fields that are set in src will be set to that value in dst. +// Elements of repeated fields will be appended. +// Merge panics if src and dst are not the same type, or if dst is nil. +func Merge(dst, src Message) { + in := reflect.ValueOf(src) + out := reflect.ValueOf(dst) + if out.IsNil() { + panic("proto: nil destination") + } + if in.Type() != out.Type() { + // Explicit test prior to mergeStruct so that mistyped nils will fail + panic("proto: type mismatch") + } + if in.IsNil() { + // Merging nil into non-nil is a quiet no-op + return + } + mergeStruct(out.Elem(), in.Elem()) +} + +func mergeStruct(out, in reflect.Value) { + sprop := GetProperties(in.Type()) + for i := 0; i < in.NumField(); i++ { + f := in.Type().Field(i) + if strings.HasPrefix(f.Name, "XXX_") { + continue + } + mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i]) + } + + if emIn, ok := extendable(in.Addr().Interface()); ok { + emOut, _ := extendable(out.Addr().Interface()) + mIn, muIn := emIn.extensionsRead() + if mIn != nil { + mOut := emOut.extensionsWrite() + muIn.Lock() + mergeExtension(mOut, mIn) + muIn.Unlock() + } + } + + uf := in.FieldByName("XXX_unrecognized") + if !uf.IsValid() { + return + } + uin := uf.Bytes() + if len(uin) > 0 { + out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...)) + } +} + +// mergeAny performs a merge between two values of the same type. +// viaPtr indicates whether the values were indirected through a pointer (implying proto2). +// prop is set if this is a struct field (it may be nil). +func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) { + if in.Type() == protoMessageType { + if !in.IsNil() { + if out.IsNil() { + out.Set(reflect.ValueOf(Clone(in.Interface().(Message)))) + } else { + Merge(out.Interface().(Message), in.Interface().(Message)) + } + } + return + } + switch in.Kind() { + case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, + reflect.String, reflect.Uint32, reflect.Uint64: + if !viaPtr && isProto3Zero(in) { + return + } + out.Set(in) + case reflect.Interface: + // Probably a oneof field; copy non-nil values. + if in.IsNil() { + return + } + // Allocate destination if it is not set, or set to a different type. + // Otherwise we will merge as normal. + if out.IsNil() || out.Elem().Type() != in.Elem().Type() { + out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T) + } + mergeAny(out.Elem(), in.Elem(), false, nil) + case reflect.Map: + if in.Len() == 0 { + return + } + if out.IsNil() { + out.Set(reflect.MakeMap(in.Type())) + } + // For maps with value types of *T or []byte we need to deep copy each value. + elemKind := in.Type().Elem().Kind() + for _, key := range in.MapKeys() { + var val reflect.Value + switch elemKind { + case reflect.Ptr: + val = reflect.New(in.Type().Elem().Elem()) + mergeAny(val, in.MapIndex(key), false, nil) + case reflect.Slice: + val = in.MapIndex(key) + val = reflect.ValueOf(append([]byte{}, val.Bytes()...)) + default: + val = in.MapIndex(key) + } + out.SetMapIndex(key, val) + } + case reflect.Ptr: + if in.IsNil() { + return + } + if out.IsNil() { + out.Set(reflect.New(in.Elem().Type())) + } + mergeAny(out.Elem(), in.Elem(), true, nil) + case reflect.Slice: + if in.IsNil() { + return + } + if in.Type().Elem().Kind() == reflect.Uint8 { + // []byte is a scalar bytes field, not a repeated field. + + // Edge case: if this is in a proto3 message, a zero length + // bytes field is considered the zero value, and should not + // be merged. + if prop != nil && prop.proto3 && in.Len() == 0 { + return + } + + // Make a deep copy. + // Append to []byte{} instead of []byte(nil) so that we never end up + // with a nil result. + out.SetBytes(append([]byte{}, in.Bytes()...)) + return + } + n := in.Len() + if out.IsNil() { + out.Set(reflect.MakeSlice(in.Type(), 0, n)) + } + switch in.Type().Elem().Kind() { + case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, + reflect.String, reflect.Uint32, reflect.Uint64: + out.Set(reflect.AppendSlice(out, in)) + default: + for i := 0; i < n; i++ { + x := reflect.Indirect(reflect.New(in.Type().Elem())) + mergeAny(x, in.Index(i), false, nil) + out.Set(reflect.Append(out, x)) + } + } + case reflect.Struct: + mergeStruct(out, in) + default: + // unknown type, so not a protocol buffer + log.Printf("proto: don't know how to copy %v", in) + } +} + +func mergeExtension(out, in map[int32]Extension) { + for extNum, eIn := range in { + eOut := Extension{desc: eIn.desc} + if eIn.value != nil { + v := reflect.New(reflect.TypeOf(eIn.value)).Elem() + mergeAny(v, reflect.ValueOf(eIn.value), false, nil) + eOut.value = v.Interface() + } + if eIn.enc != nil { + eOut.enc = make([]byte, len(eIn.enc)) + copy(eOut.enc, eIn.enc) + } + + out[extNum] = eOut + } +} diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go new file mode 100644 index 00000000..04dcb881 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/decode.go @@ -0,0 +1,874 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Routines for decoding protocol buffer data to construct in-memory representations. + */ + +import ( + "errors" + "fmt" + "io" + "os" + "reflect" +) + +// errOverflow is returned when an integer is too large to be represented. +var errOverflow = errors.New("proto: integer overflow") + +// ErrInternalBadWireType is returned by generated code when an incorrect +// wire type is encountered. It does not get returned to user code. +var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof") + +// The fundamental decoders that interpret bytes on the wire. +// Those that take integer types all return uint64 and are +// therefore of type valueDecoder. + +// DecodeVarint reads a varint-encoded integer from the slice. +// It returns the integer and the number of bytes consumed, or +// zero if there is not enough. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func DecodeVarint(buf []byte) (x uint64, n int) { + // x, n already 0 + for shift := uint(0); shift < 64; shift += 7 { + if n >= len(buf) { + return 0, 0 + } + b := uint64(buf[n]) + n++ + x |= (b & 0x7F) << shift + if (b & 0x80) == 0 { + return x, n + } + } + + // The number is too large to represent in a 64-bit value. + return 0, 0 +} + +// DecodeVarint reads a varint-encoded integer from the Buffer. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func (p *Buffer) DecodeVarint() (x uint64, err error) { + // x, err already 0 + + i := p.index + l := len(p.buf) + + for shift := uint(0); shift < 64; shift += 7 { + if i >= l { + err = io.ErrUnexpectedEOF + return + } + b := p.buf[i] + i++ + x |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + p.index = i + return + } + } + + // The number is too large to represent in a 64-bit value. + err = errOverflow + return +} + +// DecodeFixed64 reads a 64-bit integer from the Buffer. +// This is the format for the +// fixed64, sfixed64, and double protocol buffer types. +func (p *Buffer) DecodeFixed64() (x uint64, err error) { + // x, err already 0 + i := p.index + 8 + if i < 0 || i > len(p.buf) { + err = io.ErrUnexpectedEOF + return + } + p.index = i + + x = uint64(p.buf[i-8]) + x |= uint64(p.buf[i-7]) << 8 + x |= uint64(p.buf[i-6]) << 16 + x |= uint64(p.buf[i-5]) << 24 + x |= uint64(p.buf[i-4]) << 32 + x |= uint64(p.buf[i-3]) << 40 + x |= uint64(p.buf[i-2]) << 48 + x |= uint64(p.buf[i-1]) << 56 + return +} + +// DecodeFixed32 reads a 32-bit integer from the Buffer. +// This is the format for the +// fixed32, sfixed32, and float protocol buffer types. +func (p *Buffer) DecodeFixed32() (x uint64, err error) { + // x, err already 0 + i := p.index + 4 + if i < 0 || i > len(p.buf) { + err = io.ErrUnexpectedEOF + return + } + p.index = i + + x = uint64(p.buf[i-4]) + x |= uint64(p.buf[i-3]) << 8 + x |= uint64(p.buf[i-2]) << 16 + x |= uint64(p.buf[i-1]) << 24 + return +} + +// DecodeZigzag64 reads a zigzag-encoded 64-bit integer +// from the Buffer. +// This is the format used for the sint64 protocol buffer type. +func (p *Buffer) DecodeZigzag64() (x uint64, err error) { + x, err = p.DecodeVarint() + if err != nil { + return + } + x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63) + return +} + +// DecodeZigzag32 reads a zigzag-encoded 32-bit integer +// from the Buffer. +// This is the format used for the sint32 protocol buffer type. +func (p *Buffer) DecodeZigzag32() (x uint64, err error) { + x, err = p.DecodeVarint() + if err != nil { + return + } + x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31)) + return +} + +// These are not ValueDecoders: they produce an array of bytes or a string. +// bytes, embedded messages + +// DecodeRawBytes reads a count-delimited byte buffer from the Buffer. +// This is the format used for the bytes protocol buffer +// type and for embedded messages. +func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) { + n, err := p.DecodeVarint() + if err != nil { + return nil, err + } + + nb := int(n) + if nb < 0 { + return nil, fmt.Errorf("proto: bad byte length %d", nb) + } + end := p.index + nb + if end < p.index || end > len(p.buf) { + return nil, io.ErrUnexpectedEOF + } + + if !alloc { + // todo: check if can get more uses of alloc=false + buf = p.buf[p.index:end] + p.index += nb + return + } + + buf = make([]byte, nb) + copy(buf, p.buf[p.index:]) + p.index += nb + return +} + +// DecodeStringBytes reads an encoded string from the Buffer. +// This is the format used for the proto2 string type. +func (p *Buffer) DecodeStringBytes() (s string, err error) { + buf, err := p.DecodeRawBytes(false) + if err != nil { + return + } + return string(buf), nil +} + +// Skip the next item in the buffer. Its wire type is decoded and presented as an argument. +// If the protocol buffer has extensions, and the field matches, add it as an extension. +// Otherwise, if the XXX_unrecognized field exists, append the skipped data there. +func (o *Buffer) skipAndSave(t reflect.Type, tag, wire int, base structPointer, unrecField field) error { + oi := o.index + + err := o.skip(t, tag, wire) + if err != nil { + return err + } + + if !unrecField.IsValid() { + return nil + } + + ptr := structPointer_Bytes(base, unrecField) + + // Add the skipped field to struct field + obuf := o.buf + + o.buf = *ptr + o.EncodeVarint(uint64(tag<<3 | wire)) + *ptr = append(o.buf, obuf[oi:o.index]...) + + o.buf = obuf + + return nil +} + +// Skip the next item in the buffer. Its wire type is decoded and presented as an argument. +func (o *Buffer) skip(t reflect.Type, tag, wire int) error { + + var u uint64 + var err error + + switch wire { + case WireVarint: + _, err = o.DecodeVarint() + case WireFixed64: + _, err = o.DecodeFixed64() + case WireBytes: + _, err = o.DecodeRawBytes(false) + case WireFixed32: + _, err = o.DecodeFixed32() + case WireStartGroup: + for { + u, err = o.DecodeVarint() + if err != nil { + break + } + fwire := int(u & 0x7) + if fwire == WireEndGroup { + break + } + ftag := int(u >> 3) + err = o.skip(t, ftag, fwire) + if err != nil { + break + } + } + default: + err = fmt.Errorf("proto: can't skip unknown wire type %d for %s", wire, t) + } + return err +} + +// Unmarshaler is the interface representing objects that can +// unmarshal themselves. The method should reset the receiver before +// decoding starts. The argument points to data that may be +// overwritten, so implementations should not keep references to the +// buffer. +type Unmarshaler interface { + Unmarshal([]byte) error +} + +// Unmarshal parses the protocol buffer representation in buf and places the +// decoded result in pb. If the struct underlying pb does not match +// the data in buf, the results can be unpredictable. +// +// Unmarshal resets pb before starting to unmarshal, so any +// existing data in pb is always removed. Use UnmarshalMerge +// to preserve and append to existing data. +func Unmarshal(buf []byte, pb Message) error { + pb.Reset() + return UnmarshalMerge(buf, pb) +} + +// UnmarshalMerge parses the protocol buffer representation in buf and +// writes the decoded result to pb. If the struct underlying pb does not match +// the data in buf, the results can be unpredictable. +// +// UnmarshalMerge merges into existing data in pb. +// Most code should use Unmarshal instead. +func UnmarshalMerge(buf []byte, pb Message) error { + // If the object can unmarshal itself, let it. + if u, ok := pb.(Unmarshaler); ok { + return u.Unmarshal(buf) + } + return NewBuffer(buf).Unmarshal(pb) +} + +// DecodeMessage reads a count-delimited message from the Buffer. +func (p *Buffer) DecodeMessage(pb Message) error { + enc, err := p.DecodeRawBytes(false) + if err != nil { + return err + } + return NewBuffer(enc).Unmarshal(pb) +} + +// DecodeGroup reads a tag-delimited group from the Buffer. +func (p *Buffer) DecodeGroup(pb Message) error { + typ, base, err := getbase(pb) + if err != nil { + return err + } + return p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), true, base) +} + +// Unmarshal parses the protocol buffer representation in the +// Buffer and places the decoded result in pb. If the struct +// underlying pb does not match the data in the buffer, the results can be +// unpredictable. +func (p *Buffer) Unmarshal(pb Message) error { + // If the object can unmarshal itself, let it. + if u, ok := pb.(Unmarshaler); ok { + err := u.Unmarshal(p.buf[p.index:]) + p.index = len(p.buf) + return err + } + + typ, base, err := getbase(pb) + if err != nil { + return err + } + + err = p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), false, base) + + if collectStats { + stats.Decode++ + } + + return err +} + +// unmarshalType does the work of unmarshaling a structure. +func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group bool, base structPointer) error { + var state errorState + required, reqFields := prop.reqCount, uint64(0) + + var err error + for err == nil && o.index < len(o.buf) { + oi := o.index + var u uint64 + u, err = o.DecodeVarint() + if err != nil { + break + } + wire := int(u & 0x7) + if wire == WireEndGroup { + if is_group { + if required > 0 { + // Not enough information to determine the exact field. + // (See below.) + return &RequiredNotSetError{"{Unknown}"} + } + return nil // input is satisfied + } + return fmt.Errorf("proto: %s: wiretype end group for non-group", st) + } + tag := int(u >> 3) + if tag <= 0 { + return fmt.Errorf("proto: %s: illegal tag %d (wire type %d)", st, tag, wire) + } + fieldnum, ok := prop.decoderTags.get(tag) + if !ok { + // Maybe it's an extension? + if prop.extendable { + if e, _ := extendable(structPointer_Interface(base, st)); isExtensionField(e, int32(tag)) { + if err = o.skip(st, tag, wire); err == nil { + extmap := e.extensionsWrite() + ext := extmap[int32(tag)] // may be missing + ext.enc = append(ext.enc, o.buf[oi:o.index]...) + extmap[int32(tag)] = ext + } + continue + } + } + // Maybe it's a oneof? + if prop.oneofUnmarshaler != nil { + m := structPointer_Interface(base, st).(Message) + // First return value indicates whether tag is a oneof field. + ok, err = prop.oneofUnmarshaler(m, tag, wire, o) + if err == ErrInternalBadWireType { + // Map the error to something more descriptive. + // Do the formatting here to save generated code space. + err = fmt.Errorf("bad wiretype for oneof field in %T", m) + } + if ok { + continue + } + } + err = o.skipAndSave(st, tag, wire, base, prop.unrecField) + continue + } + p := prop.Prop[fieldnum] + + if p.dec == nil { + fmt.Fprintf(os.Stderr, "proto: no protobuf decoder for %s.%s\n", st, st.Field(fieldnum).Name) + continue + } + dec := p.dec + if wire != WireStartGroup && wire != p.WireType { + if wire == WireBytes && p.packedDec != nil { + // a packable field + dec = p.packedDec + } else { + err = fmt.Errorf("proto: bad wiretype for field %s.%s: got wiretype %d, want %d", st, st.Field(fieldnum).Name, wire, p.WireType) + continue + } + } + decErr := dec(o, p, base) + if decErr != nil && !state.shouldContinue(decErr, p) { + err = decErr + } + if err == nil && p.Required { + // Successfully decoded a required field. + if tag <= 64 { + // use bitmap for fields 1-64 to catch field reuse. + var mask uint64 = 1 << uint64(tag-1) + if reqFields&mask == 0 { + // new required field + reqFields |= mask + required-- + } + } else { + // This is imprecise. It can be fooled by a required field + // with a tag > 64 that is encoded twice; that's very rare. + // A fully correct implementation would require allocating + // a data structure, which we would like to avoid. + required-- + } + } + } + if err == nil { + if is_group { + return io.ErrUnexpectedEOF + } + if state.err != nil { + return state.err + } + if required > 0 { + // Not enough information to determine the exact field. If we use extra + // CPU, we could determine the field only if the missing required field + // has a tag <= 64 and we check reqFields. + return &RequiredNotSetError{"{Unknown}"} + } + } + return err +} + +// Individual type decoders +// For each, +// u is the decoded value, +// v is a pointer to the field (pointer) in the struct + +// Sizes of the pools to allocate inside the Buffer. +// The goal is modest amortization and allocation +// on at least 16-byte boundaries. +const ( + boolPoolSize = 16 + uint32PoolSize = 8 + uint64PoolSize = 4 +) + +// Decode a bool. +func (o *Buffer) dec_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + if len(o.bools) == 0 { + o.bools = make([]bool, boolPoolSize) + } + o.bools[0] = u != 0 + *structPointer_Bool(base, p.field) = &o.bools[0] + o.bools = o.bools[1:] + return nil +} + +func (o *Buffer) dec_proto3_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + *structPointer_BoolVal(base, p.field) = u != 0 + return nil +} + +// Decode an int32. +func (o *Buffer) dec_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word32_Set(structPointer_Word32(base, p.field), o, uint32(u)) + return nil +} + +func (o *Buffer) dec_proto3_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word32Val_Set(structPointer_Word32Val(base, p.field), uint32(u)) + return nil +} + +// Decode an int64. +func (o *Buffer) dec_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word64_Set(structPointer_Word64(base, p.field), o, u) + return nil +} + +func (o *Buffer) dec_proto3_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word64Val_Set(structPointer_Word64Val(base, p.field), o, u) + return nil +} + +// Decode a string. +func (o *Buffer) dec_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + *structPointer_String(base, p.field) = &s + return nil +} + +func (o *Buffer) dec_proto3_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + *structPointer_StringVal(base, p.field) = s + return nil +} + +// Decode a slice of bytes ([]byte). +func (o *Buffer) dec_slice_byte(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + *structPointer_Bytes(base, p.field) = b + return nil +} + +// Decode a slice of bools ([]bool). +func (o *Buffer) dec_slice_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + v := structPointer_BoolSlice(base, p.field) + *v = append(*v, u != 0) + return nil +} + +// Decode a slice of bools ([]bool) in packed format. +func (o *Buffer) dec_slice_packed_bool(p *Properties, base structPointer) error { + v := structPointer_BoolSlice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded bools + fin := o.index + nb + if fin < o.index { + return errOverflow + } + + y := *v + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + y = append(y, u != 0) + } + + *v = y + return nil +} + +// Decode a slice of int32s ([]int32). +func (o *Buffer) dec_slice_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + structPointer_Word32Slice(base, p.field).Append(uint32(u)) + return nil +} + +// Decode a slice of int32s ([]int32) in packed format. +func (o *Buffer) dec_slice_packed_int32(p *Properties, base structPointer) error { + v := structPointer_Word32Slice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded int32s + + fin := o.index + nb + if fin < o.index { + return errOverflow + } + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + v.Append(uint32(u)) + } + return nil +} + +// Decode a slice of int64s ([]int64). +func (o *Buffer) dec_slice_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + + structPointer_Word64Slice(base, p.field).Append(u) + return nil +} + +// Decode a slice of int64s ([]int64) in packed format. +func (o *Buffer) dec_slice_packed_int64(p *Properties, base structPointer) error { + v := structPointer_Word64Slice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded int64s + + fin := o.index + nb + if fin < o.index { + return errOverflow + } + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + v.Append(u) + } + return nil +} + +// Decode a slice of strings ([]string). +func (o *Buffer) dec_slice_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + v := structPointer_StringSlice(base, p.field) + *v = append(*v, s) + return nil +} + +// Decode a slice of slice of bytes ([][]byte). +func (o *Buffer) dec_slice_slice_byte(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + v := structPointer_BytesSlice(base, p.field) + *v = append(*v, b) + return nil +} + +// Decode a map field. +func (o *Buffer) dec_new_map(p *Properties, base structPointer) error { + raw, err := o.DecodeRawBytes(false) + if err != nil { + return err + } + oi := o.index // index at the end of this map entry + o.index -= len(raw) // move buffer back to start of map entry + + mptr := structPointer_NewAt(base, p.field, p.mtype) // *map[K]V + if mptr.Elem().IsNil() { + mptr.Elem().Set(reflect.MakeMap(mptr.Type().Elem())) + } + v := mptr.Elem() // map[K]V + + // Prepare addressable doubly-indirect placeholders for the key and value types. + // See enc_new_map for why. + keyptr := reflect.New(reflect.PtrTo(p.mtype.Key())).Elem() // addressable *K + keybase := toStructPointer(keyptr.Addr()) // **K + + var valbase structPointer + var valptr reflect.Value + switch p.mtype.Elem().Kind() { + case reflect.Slice: + // []byte + var dummy []byte + valptr = reflect.ValueOf(&dummy) // *[]byte + valbase = toStructPointer(valptr) // *[]byte + case reflect.Ptr: + // message; valptr is **Msg; need to allocate the intermediate pointer + valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V + valptr.Set(reflect.New(valptr.Type().Elem())) + valbase = toStructPointer(valptr) + default: + // everything else + valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V + valbase = toStructPointer(valptr.Addr()) // **V + } + + // Decode. + // This parses a restricted wire format, namely the encoding of a message + // with two fields. See enc_new_map for the format. + for o.index < oi { + // tagcode for key and value properties are always a single byte + // because they have tags 1 and 2. + tagcode := o.buf[o.index] + o.index++ + switch tagcode { + case p.mkeyprop.tagcode[0]: + if err := p.mkeyprop.dec(o, p.mkeyprop, keybase); err != nil { + return err + } + case p.mvalprop.tagcode[0]: + if err := p.mvalprop.dec(o, p.mvalprop, valbase); err != nil { + return err + } + default: + // TODO: Should we silently skip this instead? + return fmt.Errorf("proto: bad map data tag %d", raw[0]) + } + } + keyelem, valelem := keyptr.Elem(), valptr.Elem() + if !keyelem.IsValid() { + keyelem = reflect.Zero(p.mtype.Key()) + } + if !valelem.IsValid() { + valelem = reflect.Zero(p.mtype.Elem()) + } + + v.SetMapIndex(keyelem, valelem) + return nil +} + +// Decode a group. +func (o *Buffer) dec_struct_group(p *Properties, base structPointer) error { + bas := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(bas) { + // allocate new nested message + bas = toStructPointer(reflect.New(p.stype)) + structPointer_SetStructPointer(base, p.field, bas) + } + return o.unmarshalType(p.stype, p.sprop, true, bas) +} + +// Decode an embedded message. +func (o *Buffer) dec_struct_message(p *Properties, base structPointer) (err error) { + raw, e := o.DecodeRawBytes(false) + if e != nil { + return e + } + + bas := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(bas) { + // allocate new nested message + bas = toStructPointer(reflect.New(p.stype)) + structPointer_SetStructPointer(base, p.field, bas) + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + iv := structPointer_Interface(bas, p.stype) + return iv.(Unmarshaler).Unmarshal(raw) + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + err = o.unmarshalType(p.stype, p.sprop, false, bas) + o.buf = obuf + o.index = oi + + return err +} + +// Decode a slice of embedded messages. +func (o *Buffer) dec_slice_struct_message(p *Properties, base structPointer) error { + return o.dec_slice_struct(p, false, base) +} + +// Decode a slice of embedded groups. +func (o *Buffer) dec_slice_struct_group(p *Properties, base structPointer) error { + return o.dec_slice_struct(p, true, base) +} + +// Decode a slice of structs ([]*struct). +func (o *Buffer) dec_slice_struct(p *Properties, is_group bool, base structPointer) error { + v := reflect.New(p.stype) + bas := toStructPointer(v) + structPointer_StructPointerSlice(base, p.field).Append(bas) + + if is_group { + err := o.unmarshalType(p.stype, p.sprop, is_group, bas) + return err + } + + raw, err := o.DecodeRawBytes(false) + if err != nil { + return err + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + iv := v.Interface() + return iv.(Unmarshaler).Unmarshal(raw) + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + err = o.unmarshalType(p.stype, p.sprop, is_group, bas) + + o.buf = obuf + o.index = oi + + return err +} diff --git a/vendor/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/golang/protobuf/proto/encode.go new file mode 100644 index 00000000..8c1b8fd1 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/encode.go @@ -0,0 +1,1363 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Routines for encoding data into the wire format for protocol buffers. + */ + +import ( + "errors" + "fmt" + "reflect" + "sort" +) + +// RequiredNotSetError is the error returned if Marshal is called with +// a protocol buffer struct whose required fields have not +// all been initialized. It is also the error returned if Unmarshal is +// called with an encoded protocol buffer that does not include all the +// required fields. +// +// When printed, RequiredNotSetError reports the first unset required field in a +// message. If the field cannot be precisely determined, it is reported as +// "{Unknown}". +type RequiredNotSetError struct { + field string +} + +func (e *RequiredNotSetError) Error() string { + return fmt.Sprintf("proto: required field %q not set", e.field) +} + +var ( + // errRepeatedHasNil is the error returned if Marshal is called with + // a struct with a repeated field containing a nil element. + errRepeatedHasNil = errors.New("proto: repeated field has nil element") + + // errOneofHasNil is the error returned if Marshal is called with + // a struct with a oneof field containing a nil element. + errOneofHasNil = errors.New("proto: oneof field has nil value") + + // ErrNil is the error returned if Marshal is called with nil. + ErrNil = errors.New("proto: Marshal called with nil") + + // ErrTooLarge is the error returned if Marshal is called with a + // message that encodes to >2GB. + ErrTooLarge = errors.New("proto: message encodes to over 2 GB") +) + +// The fundamental encoders that put bytes on the wire. +// Those that take integer types all accept uint64 and are +// therefore of type valueEncoder. + +const maxVarintBytes = 10 // maximum length of a varint + +// maxMarshalSize is the largest allowed size of an encoded protobuf, +// since C++ and Java use signed int32s for the size. +const maxMarshalSize = 1<<31 - 1 + +// EncodeVarint returns the varint encoding of x. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +// Not used by the package itself, but helpful to clients +// wishing to use the same encoding. +func EncodeVarint(x uint64) []byte { + var buf [maxVarintBytes]byte + var n int + for n = 0; x > 127; n++ { + buf[n] = 0x80 | uint8(x&0x7F) + x >>= 7 + } + buf[n] = uint8(x) + n++ + return buf[0:n] +} + +// EncodeVarint writes a varint-encoded integer to the Buffer. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func (p *Buffer) EncodeVarint(x uint64) error { + for x >= 1<<7 { + p.buf = append(p.buf, uint8(x&0x7f|0x80)) + x >>= 7 + } + p.buf = append(p.buf, uint8(x)) + return nil +} + +// SizeVarint returns the varint encoding size of an integer. +func SizeVarint(x uint64) int { + return sizeVarint(x) +} + +func sizeVarint(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} + +// EncodeFixed64 writes a 64-bit integer to the Buffer. +// This is the format for the +// fixed64, sfixed64, and double protocol buffer types. +func (p *Buffer) EncodeFixed64(x uint64) error { + p.buf = append(p.buf, + uint8(x), + uint8(x>>8), + uint8(x>>16), + uint8(x>>24), + uint8(x>>32), + uint8(x>>40), + uint8(x>>48), + uint8(x>>56)) + return nil +} + +func sizeFixed64(x uint64) int { + return 8 +} + +// EncodeFixed32 writes a 32-bit integer to the Buffer. +// This is the format for the +// fixed32, sfixed32, and float protocol buffer types. +func (p *Buffer) EncodeFixed32(x uint64) error { + p.buf = append(p.buf, + uint8(x), + uint8(x>>8), + uint8(x>>16), + uint8(x>>24)) + return nil +} + +func sizeFixed32(x uint64) int { + return 4 +} + +// EncodeZigzag64 writes a zigzag-encoded 64-bit integer +// to the Buffer. +// This is the format used for the sint64 protocol buffer type. +func (p *Buffer) EncodeZigzag64(x uint64) error { + // use signed number to get arithmetic right shift. + return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func sizeZigzag64(x uint64) int { + return sizeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +// EncodeZigzag32 writes a zigzag-encoded 32-bit integer +// to the Buffer. +// This is the format used for the sint32 protocol buffer type. +func (p *Buffer) EncodeZigzag32(x uint64) error { + // use signed number to get arithmetic right shift. + return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) +} + +func sizeZigzag32(x uint64) int { + return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) +} + +// EncodeRawBytes writes a count-delimited byte buffer to the Buffer. +// This is the format used for the bytes protocol buffer +// type and for embedded messages. +func (p *Buffer) EncodeRawBytes(b []byte) error { + p.EncodeVarint(uint64(len(b))) + p.buf = append(p.buf, b...) + return nil +} + +func sizeRawBytes(b []byte) int { + return sizeVarint(uint64(len(b))) + + len(b) +} + +// EncodeStringBytes writes an encoded string to the Buffer. +// This is the format used for the proto2 string type. +func (p *Buffer) EncodeStringBytes(s string) error { + p.EncodeVarint(uint64(len(s))) + p.buf = append(p.buf, s...) + return nil +} + +func sizeStringBytes(s string) int { + return sizeVarint(uint64(len(s))) + + len(s) +} + +// Marshaler is the interface representing objects that can marshal themselves. +type Marshaler interface { + Marshal() ([]byte, error) +} + +// Marshal takes the protocol buffer +// and encodes it into the wire format, returning the data. +func Marshal(pb Message) ([]byte, error) { + // Can the object marshal itself? + if m, ok := pb.(Marshaler); ok { + return m.Marshal() + } + p := NewBuffer(nil) + err := p.Marshal(pb) + var state errorState + if err != nil && !state.shouldContinue(err, nil) { + return nil, err + } + if p.buf == nil && err == nil { + // Return a non-nil slice on success. + return []byte{}, nil + } + return p.buf, err +} + +// EncodeMessage writes the protocol buffer to the Buffer, +// prefixed by a varint-encoded length. +func (p *Buffer) EncodeMessage(pb Message) error { + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return ErrNil + } + if err == nil { + var state errorState + err = p.enc_len_struct(GetProperties(t.Elem()), base, &state) + } + return err +} + +// Marshal takes the protocol buffer +// and encodes it into the wire format, writing the result to the +// Buffer. +func (p *Buffer) Marshal(pb Message) error { + // Can the object marshal itself? + if m, ok := pb.(Marshaler); ok { + data, err := m.Marshal() + if err != nil { + return err + } + p.buf = append(p.buf, data...) + return nil + } + + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return ErrNil + } + if err == nil { + err = p.enc_struct(GetProperties(t.Elem()), base) + } + + if collectStats { + stats.Encode++ + } + + if len(p.buf) > maxMarshalSize { + return ErrTooLarge + } + return err +} + +// Size returns the encoded size of a protocol buffer. +func Size(pb Message) (n int) { + // Can the object marshal itself? If so, Size is slow. + // TODO: add Size to Marshaler, or add a Sizer interface. + if m, ok := pb.(Marshaler); ok { + b, _ := m.Marshal() + return len(b) + } + + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return 0 + } + if err == nil { + n = size_struct(GetProperties(t.Elem()), base) + } + + if collectStats { + stats.Size++ + } + + return +} + +// Individual type encoders. + +// Encode a bool. +func (o *Buffer) enc_bool(p *Properties, base structPointer) error { + v := *structPointer_Bool(base, p.field) + if v == nil { + return ErrNil + } + x := 0 + if *v { + x = 1 + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_bool(p *Properties, base structPointer) error { + v := *structPointer_BoolVal(base, p.field) + if !v { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, 1) + return nil +} + +func size_bool(p *Properties, base structPointer) int { + v := *structPointer_Bool(base, p.field) + if v == nil { + return 0 + } + return len(p.tagcode) + 1 // each bool takes exactly one byte +} + +func size_proto3_bool(p *Properties, base structPointer) int { + v := *structPointer_BoolVal(base, p.field) + if !v && !p.oneof { + return 0 + } + return len(p.tagcode) + 1 // each bool takes exactly one byte +} + +// Encode an int32. +func (o *Buffer) enc_int32(p *Properties, base structPointer) error { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return ErrNil + } + x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_int32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return 0 + } + x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +func size_proto3_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +// Encode a uint32. +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_uint32(p *Properties, base structPointer) error { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return ErrNil + } + x := word32_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_uint32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return 0 + } + x := word32_Get(v) + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +func size_proto3_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +// Encode an int64. +func (o *Buffer) enc_int64(p *Properties, base structPointer) error { + v := structPointer_Word64(base, p.field) + if word64_IsNil(v) { + return ErrNil + } + x := word64_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, x) + return nil +} + +func (o *Buffer) enc_proto3_int64(p *Properties, base structPointer) error { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, x) + return nil +} + +func size_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64(base, p.field) + if word64_IsNil(v) { + return 0 + } + x := word64_Get(v) + n += len(p.tagcode) + n += p.valSize(x) + return +} + +func size_proto3_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(x) + return +} + +// Encode a string. +func (o *Buffer) enc_string(p *Properties, base structPointer) error { + v := *structPointer_String(base, p.field) + if v == nil { + return ErrNil + } + x := *v + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(x) + return nil +} + +func (o *Buffer) enc_proto3_string(p *Properties, base structPointer) error { + v := *structPointer_StringVal(base, p.field) + if v == "" { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(v) + return nil +} + +func size_string(p *Properties, base structPointer) (n int) { + v := *structPointer_String(base, p.field) + if v == nil { + return 0 + } + x := *v + n += len(p.tagcode) + n += sizeStringBytes(x) + return +} + +func size_proto3_string(p *Properties, base structPointer) (n int) { + v := *structPointer_StringVal(base, p.field) + if v == "" && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeStringBytes(v) + return +} + +// All protocol buffer fields are nillable, but be careful. +func isNil(v reflect.Value) bool { + switch v.Kind() { + case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + return v.IsNil() + } + return false +} + +// Encode a message struct. +func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error { + var state errorState + structp := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return ErrNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + return state.err + } + + o.buf = append(o.buf, p.tagcode...) + return o.enc_len_struct(p.sprop, structp, &state) +} + +func size_struct_message(p *Properties, base structPointer) int { + structp := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return 0 + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n0 := len(p.tagcode) + n1 := sizeRawBytes(data) + return n0 + n1 + } + + n0 := len(p.tagcode) + n1 := size_struct(p.sprop, structp) + n2 := sizeVarint(uint64(n1)) // size of encoded length + return n0 + n1 + n2 +} + +// Encode a group struct. +func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error { + var state errorState + b := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(b) { + return ErrNil + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup)) + err := o.enc_struct(p.sprop, b) + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup)) + return state.err +} + +func size_struct_group(p *Properties, base structPointer) (n int) { + b := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(b) { + return 0 + } + + n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup)) + n += size_struct(p.sprop, b) + n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup)) + return +} + +// Encode a slice of bools ([]bool). +func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return ErrNil + } + for _, x := range s { + o.buf = append(o.buf, p.tagcode...) + v := uint64(0) + if x { + v = 1 + } + p.valEnc(o, v) + } + return nil +} + +func size_slice_bool(p *Properties, base structPointer) int { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return 0 + } + return l * (len(p.tagcode) + 1) // each bool takes exactly one byte +} + +// Encode a slice of bools ([]bool) in packed format. +func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(l)) // each bool takes exactly one byte + for _, x := range s { + v := uint64(0) + if x { + v = 1 + } + p.valEnc(o, v) + } + return nil +} + +func size_slice_packed_bool(p *Properties, base structPointer) (n int) { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return 0 + } + n += len(p.tagcode) + n += sizeVarint(uint64(l)) + n += l // each bool takes exactly one byte + return +} + +// Encode a slice of bytes ([]byte). +func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error { + s := *structPointer_Bytes(base, p.field) + if s == nil { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(s) + return nil +} + +func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error { + s := *structPointer_Bytes(base, p.field) + if len(s) == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(s) + return nil +} + +func size_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) + if s == nil && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeRawBytes(s) + return +} + +func size_proto3_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) + if len(s) == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeRawBytes(s) + return +} + +// Encode a slice of int32s ([]int32). +func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + p.valEnc(o, uint64(x)) + } + return nil +} + +func size_slice_int32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + n += p.valSize(uint64(x)) + } + return +} + +// Encode a slice of int32s ([]int32) in packed format. +func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + p.valEnc(buf, uint64(x)) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_int32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + bufSize += p.valSize(uint64(x)) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of uint32s ([]uint32). +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_slice_uint32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + x := s.Index(i) + p.valEnc(o, uint64(x)) + } + return nil +} + +func size_slice_uint32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + x := s.Index(i) + n += p.valSize(uint64(x)) + } + return +} + +// Encode a slice of uint32s ([]uint32) in packed format. +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_slice_packed_uint32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + p.valEnc(buf, uint64(s.Index(i))) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_uint32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + bufSize += p.valSize(uint64(s.Index(i))) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of int64s ([]int64). +func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, s.Index(i)) + } + return nil +} + +func size_slice_int64(p *Properties, base structPointer) (n int) { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + n += p.valSize(s.Index(i)) + } + return +} + +// Encode a slice of int64s ([]int64) in packed format. +func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + p.valEnc(buf, s.Index(i)) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_int64(p *Properties, base structPointer) (n int) { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + bufSize += p.valSize(s.Index(i)) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of slice of bytes ([][]byte). +func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error { + ss := *structPointer_BytesSlice(base, p.field) + l := len(ss) + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(ss[i]) + } + return nil +} + +func size_slice_slice_byte(p *Properties, base structPointer) (n int) { + ss := *structPointer_BytesSlice(base, p.field) + l := len(ss) + if l == 0 { + return 0 + } + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + n += sizeRawBytes(ss[i]) + } + return +} + +// Encode a slice of strings ([]string). +func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error { + ss := *structPointer_StringSlice(base, p.field) + l := len(ss) + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(ss[i]) + } + return nil +} + +func size_slice_string(p *Properties, base structPointer) (n int) { + ss := *structPointer_StringSlice(base, p.field) + l := len(ss) + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + n += sizeStringBytes(ss[i]) + } + return +} + +// Encode a slice of message structs ([]*struct). +func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error { + var state errorState + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + for i := 0; i < l; i++ { + structp := s.Index(i) + if structPointer_IsNil(structp) { + return errRepeatedHasNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + continue + } + + o.buf = append(o.buf, p.tagcode...) + err := o.enc_len_struct(p.sprop, structp, &state) + if err != nil && !state.shouldContinue(err, nil) { + if err == ErrNil { + return errRepeatedHasNil + } + return err + } + } + return state.err +} + +func size_slice_struct_message(p *Properties, base structPointer) (n int) { + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + structp := s.Index(i) + if structPointer_IsNil(structp) { + return // return the size up to this point + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n += len(p.tagcode) + n += sizeRawBytes(data) + continue + } + + n0 := size_struct(p.sprop, structp) + n1 := sizeVarint(uint64(n0)) // size of encoded length + n += n0 + n1 + } + return +} + +// Encode a slice of group structs ([]*struct). +func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error { + var state errorState + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + for i := 0; i < l; i++ { + b := s.Index(i) + if structPointer_IsNil(b) { + return errRepeatedHasNil + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup)) + + err := o.enc_struct(p.sprop, b) + + if err != nil && !state.shouldContinue(err, nil) { + if err == ErrNil { + return errRepeatedHasNil + } + return err + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup)) + } + return state.err +} + +func size_slice_struct_group(p *Properties, base structPointer) (n int) { + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup)) + n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup)) + for i := 0; i < l; i++ { + b := s.Index(i) + if structPointer_IsNil(b) { + return // return size up to this point + } + + n += size_struct(p.sprop, b) + } + return +} + +// Encode an extension map. +func (o *Buffer) enc_map(p *Properties, base structPointer) error { + exts := structPointer_ExtMap(base, p.field) + if err := encodeExtensionsMap(*exts); err != nil { + return err + } + + return o.enc_map_body(*exts) +} + +func (o *Buffer) enc_exts(p *Properties, base structPointer) error { + exts := structPointer_Extensions(base, p.field) + if err := encodeExtensions(exts); err != nil { + return err + } + v, _ := exts.extensionsRead() + + return o.enc_map_body(v) +} + +func (o *Buffer) enc_map_body(v map[int32]Extension) error { + // Fast-path for common cases: zero or one extensions. + if len(v) <= 1 { + for _, e := range v { + o.buf = append(o.buf, e.enc...) + } + return nil + } + + // Sort keys to provide a deterministic encoding. + keys := make([]int, 0, len(v)) + for k := range v { + keys = append(keys, int(k)) + } + sort.Ints(keys) + + for _, k := range keys { + o.buf = append(o.buf, v[int32(k)].enc...) + } + return nil +} + +func size_map(p *Properties, base structPointer) int { + v := structPointer_ExtMap(base, p.field) + return extensionsMapSize(*v) +} + +func size_exts(p *Properties, base structPointer) int { + v := structPointer_Extensions(base, p.field) + return extensionsSize(v) +} + +// Encode a map field. +func (o *Buffer) enc_new_map(p *Properties, base structPointer) error { + var state errorState // XXX: or do we need to plumb this through? + + /* + A map defined as + map map_field = N; + is encoded in the same way as + message MapFieldEntry { + key_type key = 1; + value_type value = 2; + } + repeated MapFieldEntry map_field = N; + */ + + v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V + if v.Len() == 0 { + return nil + } + + keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype) + + enc := func() error { + if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil { + return err + } + if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil { + return err + } + return nil + } + + // Don't sort map keys. It is not required by the spec, and C++ doesn't do it. + for _, key := range v.MapKeys() { + val := v.MapIndex(key) + + keycopy.Set(key) + valcopy.Set(val) + + o.buf = append(o.buf, p.tagcode...) + if err := o.enc_len_thing(enc, &state); err != nil { + return err + } + } + return nil +} + +func size_new_map(p *Properties, base structPointer) int { + v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V + + keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype) + + n := 0 + for _, key := range v.MapKeys() { + val := v.MapIndex(key) + keycopy.Set(key) + valcopy.Set(val) + + // Tag codes for key and val are the responsibility of the sub-sizer. + keysize := p.mkeyprop.size(p.mkeyprop, keybase) + valsize := p.mvalprop.size(p.mvalprop, valbase) + entry := keysize + valsize + // Add on tag code and length of map entry itself. + n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry + } + return n +} + +// mapEncodeScratch returns a new reflect.Value matching the map's value type, +// and a structPointer suitable for passing to an encoder or sizer. +func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) { + // Prepare addressable doubly-indirect placeholders for the key and value types. + // This is needed because the element-type encoders expect **T, but the map iteration produces T. + + keycopy = reflect.New(mapType.Key()).Elem() // addressable K + keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K + keyptr.Set(keycopy.Addr()) // + keybase = toStructPointer(keyptr.Addr()) // **K + + // Value types are more varied and require special handling. + switch mapType.Elem().Kind() { + case reflect.Slice: + // []byte + var dummy []byte + valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte + valbase = toStructPointer(valcopy.Addr()) + case reflect.Ptr: + // message; the generated field type is map[K]*Msg (so V is *Msg), + // so we only need one level of indirection. + valcopy = reflect.New(mapType.Elem()).Elem() // addressable V + valbase = toStructPointer(valcopy.Addr()) + default: + // everything else + valcopy = reflect.New(mapType.Elem()).Elem() // addressable V + valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V + valptr.Set(valcopy.Addr()) // + valbase = toStructPointer(valptr.Addr()) // **V + } + return +} + +// Encode a struct. +func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error { + var state errorState + // Encode fields in tag order so that decoders may use optimizations + // that depend on the ordering. + // https://developers.google.com/protocol-buffers/docs/encoding#order + for _, i := range prop.order { + p := prop.Prop[i] + if p.enc != nil { + err := p.enc(o, p, base) + if err != nil { + if err == ErrNil { + if p.Required && state.err == nil { + state.err = &RequiredNotSetError{p.Name} + } + } else if err == errRepeatedHasNil { + // Give more context to nil values in repeated fields. + return errors.New("repeated field " + p.OrigName + " has nil element") + } else if !state.shouldContinue(err, p) { + return err + } + } + if len(o.buf) > maxMarshalSize { + return ErrTooLarge + } + } + } + + // Do oneof fields. + if prop.oneofMarshaler != nil { + m := structPointer_Interface(base, prop.stype).(Message) + if err := prop.oneofMarshaler(m, o); err == ErrNil { + return errOneofHasNil + } else if err != nil { + return err + } + } + + // Add unrecognized fields at the end. + if prop.unrecField.IsValid() { + v := *structPointer_Bytes(base, prop.unrecField) + if len(o.buf)+len(v) > maxMarshalSize { + return ErrTooLarge + } + if len(v) > 0 { + o.buf = append(o.buf, v...) + } + } + + return state.err +} + +func size_struct(prop *StructProperties, base structPointer) (n int) { + for _, i := range prop.order { + p := prop.Prop[i] + if p.size != nil { + n += p.size(p, base) + } + } + + // Add unrecognized fields at the end. + if prop.unrecField.IsValid() { + v := *structPointer_Bytes(base, prop.unrecField) + n += len(v) + } + + // Factor in any oneof fields. + if prop.oneofSizer != nil { + m := structPointer_Interface(base, prop.stype).(Message) + n += prop.oneofSizer(m) + } + + return +} + +var zeroes [20]byte // longer than any conceivable sizeVarint + +// Encode a struct, preceded by its encoded length (as a varint). +func (o *Buffer) enc_len_struct(prop *StructProperties, base structPointer, state *errorState) error { + return o.enc_len_thing(func() error { return o.enc_struct(prop, base) }, state) +} + +// Encode something, preceded by its encoded length (as a varint). +func (o *Buffer) enc_len_thing(enc func() error, state *errorState) error { + iLen := len(o.buf) + o.buf = append(o.buf, 0, 0, 0, 0) // reserve four bytes for length + iMsg := len(o.buf) + err := enc() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + lMsg := len(o.buf) - iMsg + lLen := sizeVarint(uint64(lMsg)) + switch x := lLen - (iMsg - iLen); { + case x > 0: // actual length is x bytes larger than the space we reserved + // Move msg x bytes right. + o.buf = append(o.buf, zeroes[:x]...) + copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg]) + case x < 0: // actual length is x bytes smaller than the space we reserved + // Move msg x bytes left. + copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg]) + o.buf = o.buf[:len(o.buf)+x] // x is negative + } + // Encode the length in the reserved space. + o.buf = o.buf[:iLen] + o.EncodeVarint(uint64(lMsg)) + o.buf = o.buf[:len(o.buf)+lMsg] + return state.err +} + +// errorState maintains the first error that occurs and updates that error +// with additional context. +type errorState struct { + err error +} + +// shouldContinue reports whether encoding should continue upon encountering the +// given error. If the error is RequiredNotSetError, shouldContinue returns true +// and, if this is the first appearance of that error, remembers it for future +// reporting. +// +// If prop is not nil, it may update any error with additional context about the +// field with the error. +func (s *errorState) shouldContinue(err error, prop *Properties) bool { + // Ignore unset required fields. + reqNotSet, ok := err.(*RequiredNotSetError) + if !ok { + return false + } + if s.err == nil { + if prop != nil { + err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field} + } + s.err = err + } + return true +} diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.go new file mode 100644 index 00000000..8b16f951 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/equal.go @@ -0,0 +1,296 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Protocol buffer comparison. + +package proto + +import ( + "bytes" + "log" + "reflect" + "strings" +) + +/* +Equal returns true iff protocol buffers a and b are equal. +The arguments must both be pointers to protocol buffer structs. + +Equality is defined in this way: + - Two messages are equal iff they are the same type, + corresponding fields are equal, unknown field sets + are equal, and extensions sets are equal. + - Two set scalar fields are equal iff their values are equal. + If the fields are of a floating-point type, remember that + NaN != x for all x, including NaN. If the message is defined + in a proto3 .proto file, fields are not "set"; specifically, + zero length proto3 "bytes" fields are equal (nil == {}). + - Two repeated fields are equal iff their lengths are the same, + and their corresponding elements are equal (a "bytes" field, + although represented by []byte, is not a repeated field) + - Two unset fields are equal. + - Two unknown field sets are equal if their current + encoded state is equal. + - Two extension sets are equal iff they have corresponding + elements that are pairwise equal. + - Every other combination of things are not equal. + +The return value is undefined if a and b are not protocol buffers. +*/ +func Equal(a, b Message) bool { + if a == nil || b == nil { + return a == b + } + v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b) + if v1.Type() != v2.Type() { + return false + } + if v1.Kind() == reflect.Ptr { + if v1.IsNil() { + return v2.IsNil() + } + if v2.IsNil() { + return false + } + v1, v2 = v1.Elem(), v2.Elem() + } + if v1.Kind() != reflect.Struct { + return false + } + return equalStruct(v1, v2) +} + +// v1 and v2 are known to have the same type. +func equalStruct(v1, v2 reflect.Value) bool { + sprop := GetProperties(v1.Type()) + for i := 0; i < v1.NumField(); i++ { + f := v1.Type().Field(i) + if strings.HasPrefix(f.Name, "XXX_") { + continue + } + f1, f2 := v1.Field(i), v2.Field(i) + if f.Type.Kind() == reflect.Ptr { + if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 { + // both unset + continue + } else if n1 != n2 { + // set/unset mismatch + return false + } + b1, ok := f1.Interface().(raw) + if ok { + b2 := f2.Interface().(raw) + // RawMessage + if !bytes.Equal(b1.Bytes(), b2.Bytes()) { + return false + } + continue + } + f1, f2 = f1.Elem(), f2.Elem() + } + if !equalAny(f1, f2, sprop.Prop[i]) { + return false + } + } + + if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() { + em2 := v2.FieldByName("XXX_InternalExtensions") + if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) { + return false + } + } + + if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() { + em2 := v2.FieldByName("XXX_extensions") + if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) { + return false + } + } + + uf := v1.FieldByName("XXX_unrecognized") + if !uf.IsValid() { + return true + } + + u1 := uf.Bytes() + u2 := v2.FieldByName("XXX_unrecognized").Bytes() + if !bytes.Equal(u1, u2) { + return false + } + + return true +} + +// v1 and v2 are known to have the same type. +// prop may be nil. +func equalAny(v1, v2 reflect.Value, prop *Properties) bool { + if v1.Type() == protoMessageType { + m1, _ := v1.Interface().(Message) + m2, _ := v2.Interface().(Message) + return Equal(m1, m2) + } + switch v1.Kind() { + case reflect.Bool: + return v1.Bool() == v2.Bool() + case reflect.Float32, reflect.Float64: + return v1.Float() == v2.Float() + case reflect.Int32, reflect.Int64: + return v1.Int() == v2.Int() + case reflect.Interface: + // Probably a oneof field; compare the inner values. + n1, n2 := v1.IsNil(), v2.IsNil() + if n1 || n2 { + return n1 == n2 + } + e1, e2 := v1.Elem(), v2.Elem() + if e1.Type() != e2.Type() { + return false + } + return equalAny(e1, e2, nil) + case reflect.Map: + if v1.Len() != v2.Len() { + return false + } + for _, key := range v1.MapKeys() { + val2 := v2.MapIndex(key) + if !val2.IsValid() { + // This key was not found in the second map. + return false + } + if !equalAny(v1.MapIndex(key), val2, nil) { + return false + } + } + return true + case reflect.Ptr: + // Maps may have nil values in them, so check for nil. + if v1.IsNil() && v2.IsNil() { + return true + } + if v1.IsNil() != v2.IsNil() { + return false + } + return equalAny(v1.Elem(), v2.Elem(), prop) + case reflect.Slice: + if v1.Type().Elem().Kind() == reflect.Uint8 { + // short circuit: []byte + + // Edge case: if this is in a proto3 message, a zero length + // bytes field is considered the zero value. + if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 { + return true + } + if v1.IsNil() != v2.IsNil() { + return false + } + return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte)) + } + + if v1.Len() != v2.Len() { + return false + } + for i := 0; i < v1.Len(); i++ { + if !equalAny(v1.Index(i), v2.Index(i), prop) { + return false + } + } + return true + case reflect.String: + return v1.Interface().(string) == v2.Interface().(string) + case reflect.Struct: + return equalStruct(v1, v2) + case reflect.Uint32, reflect.Uint64: + return v1.Uint() == v2.Uint() + } + + // unknown type, so not a protocol buffer + log.Printf("proto: don't know how to compare %v", v1) + return false +} + +// base is the struct type that the extensions are based on. +// x1 and x2 are InternalExtensions. +func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool { + em1, _ := x1.extensionsRead() + em2, _ := x2.extensionsRead() + return equalExtMap(base, em1, em2) +} + +func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool { + if len(em1) != len(em2) { + return false + } + + for extNum, e1 := range em1 { + e2, ok := em2[extNum] + if !ok { + return false + } + + m1, m2 := e1.value, e2.value + + if m1 != nil && m2 != nil { + // Both are unencoded. + if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) { + return false + } + continue + } + + // At least one is encoded. To do a semantically correct comparison + // we need to unmarshal them first. + var desc *ExtensionDesc + if m := extensionMaps[base]; m != nil { + desc = m[extNum] + } + if desc == nil { + log.Printf("proto: don't know how to compare extension %d of %v", extNum, base) + continue + } + var err error + if m1 == nil { + m1, err = decodeExtension(e1.enc, desc) + } + if m2 == nil && err == nil { + m2, err = decodeExtension(e2.enc, desc) + } + if err != nil { + // The encoded form is invalid. + log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err) + return false + } + if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) { + return false + } + } + + return true +} diff --git a/vendor/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.go new file mode 100644 index 00000000..6b9b3637 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/extensions.go @@ -0,0 +1,586 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Types and routines for supporting protocol buffer extensions. + */ + +import ( + "errors" + "fmt" + "reflect" + "strconv" + "sync" +) + +// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message. +var ErrMissingExtension = errors.New("proto: missing extension") + +// ExtensionRange represents a range of message extensions for a protocol buffer. +// Used in code generated by the protocol compiler. +type ExtensionRange struct { + Start, End int32 // both inclusive +} + +// extendableProto is an interface implemented by any protocol buffer generated by the current +// proto compiler that may be extended. +type extendableProto interface { + Message + ExtensionRangeArray() []ExtensionRange + extensionsWrite() map[int32]Extension + extensionsRead() (map[int32]Extension, sync.Locker) +} + +// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous +// version of the proto compiler that may be extended. +type extendableProtoV1 interface { + Message + ExtensionRangeArray() []ExtensionRange + ExtensionMap() map[int32]Extension +} + +// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto. +type extensionAdapter struct { + extendableProtoV1 +} + +func (e extensionAdapter) extensionsWrite() map[int32]Extension { + return e.ExtensionMap() +} + +func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) { + return e.ExtensionMap(), notLocker{} +} + +// notLocker is a sync.Locker whose Lock and Unlock methods are nops. +type notLocker struct{} + +func (n notLocker) Lock() {} +func (n notLocker) Unlock() {} + +// extendable returns the extendableProto interface for the given generated proto message. +// If the proto message has the old extension format, it returns a wrapper that implements +// the extendableProto interface. +func extendable(p interface{}) (extendableProto, bool) { + if ep, ok := p.(extendableProto); ok { + return ep, ok + } + if ep, ok := p.(extendableProtoV1); ok { + return extensionAdapter{ep}, ok + } + return nil, false +} + +// XXX_InternalExtensions is an internal representation of proto extensions. +// +// Each generated message struct type embeds an anonymous XXX_InternalExtensions field, +// thus gaining the unexported 'extensions' method, which can be called only from the proto package. +// +// The methods of XXX_InternalExtensions are not concurrency safe in general, +// but calls to logically read-only methods such as has and get may be executed concurrently. +type XXX_InternalExtensions struct { + // The struct must be indirect so that if a user inadvertently copies a + // generated message and its embedded XXX_InternalExtensions, they + // avoid the mayhem of a copied mutex. + // + // The mutex serializes all logically read-only operations to p.extensionMap. + // It is up to the client to ensure that write operations to p.extensionMap are + // mutually exclusive with other accesses. + p *struct { + mu sync.Mutex + extensionMap map[int32]Extension + } +} + +// extensionsWrite returns the extension map, creating it on first use. +func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension { + if e.p == nil { + e.p = new(struct { + mu sync.Mutex + extensionMap map[int32]Extension + }) + e.p.extensionMap = make(map[int32]Extension) + } + return e.p.extensionMap +} + +// extensionsRead returns the extensions map for read-only use. It may be nil. +// The caller must hold the returned mutex's lock when accessing Elements within the map. +func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) { + if e.p == nil { + return nil, nil + } + return e.p.extensionMap, &e.p.mu +} + +var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem() +var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem() + +// ExtensionDesc represents an extension specification. +// Used in generated code from the protocol compiler. +type ExtensionDesc struct { + ExtendedType Message // nil pointer to the type that is being extended + ExtensionType interface{} // nil pointer to the extension type + Field int32 // field number + Name string // fully-qualified name of extension, for text formatting + Tag string // protobuf tag style +} + +func (ed *ExtensionDesc) repeated() bool { + t := reflect.TypeOf(ed.ExtensionType) + return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 +} + +// Extension represents an extension in a message. +type Extension struct { + // When an extension is stored in a message using SetExtension + // only desc and value are set. When the message is marshaled + // enc will be set to the encoded form of the message. + // + // When a message is unmarshaled and contains extensions, each + // extension will have only enc set. When such an extension is + // accessed using GetExtension (or GetExtensions) desc and value + // will be set. + desc *ExtensionDesc + value interface{} + enc []byte +} + +// SetRawExtension is for testing only. +func SetRawExtension(base Message, id int32, b []byte) { + epb, ok := extendable(base) + if !ok { + return + } + extmap := epb.extensionsWrite() + extmap[id] = Extension{enc: b} +} + +// isExtensionField returns true iff the given field number is in an extension range. +func isExtensionField(pb extendableProto, field int32) bool { + for _, er := range pb.ExtensionRangeArray() { + if er.Start <= field && field <= er.End { + return true + } + } + return false +} + +// checkExtensionTypes checks that the given extension is valid for pb. +func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error { + var pbi interface{} = pb + // Check the extended type. + if ea, ok := pbi.(extensionAdapter); ok { + pbi = ea.extendableProtoV1 + } + if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b { + return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String()) + } + // Check the range. + if !isExtensionField(pb, extension.Field) { + return errors.New("proto: bad extension number; not in declared ranges") + } + return nil +} + +// extPropKey is sufficient to uniquely identify an extension. +type extPropKey struct { + base reflect.Type + field int32 +} + +var extProp = struct { + sync.RWMutex + m map[extPropKey]*Properties +}{ + m: make(map[extPropKey]*Properties), +} + +func extensionProperties(ed *ExtensionDesc) *Properties { + key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field} + + extProp.RLock() + if prop, ok := extProp.m[key]; ok { + extProp.RUnlock() + return prop + } + extProp.RUnlock() + + extProp.Lock() + defer extProp.Unlock() + // Check again. + if prop, ok := extProp.m[key]; ok { + return prop + } + + prop := new(Properties) + prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil) + extProp.m[key] = prop + return prop +} + +// encode encodes any unmarshaled (unencoded) extensions in e. +func encodeExtensions(e *XXX_InternalExtensions) error { + m, mu := e.extensionsRead() + if m == nil { + return nil // fast path + } + mu.Lock() + defer mu.Unlock() + return encodeExtensionsMap(m) +} + +// encode encodes any unmarshaled (unencoded) extensions in e. +func encodeExtensionsMap(m map[int32]Extension) error { + for k, e := range m { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. + continue + } + + // We don't skip extensions that have an encoded form set, + // because the extension value may have been mutated after + // the last time this function was called. + + et := reflect.TypeOf(e.desc.ExtensionType) + props := extensionProperties(e.desc) + + p := NewBuffer(nil) + // If e.value has type T, the encoder expects a *struct{ X T }. + // Pass a *T with a zero field and hope it all works out. + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(e.value)) + if err := props.enc(p, props, toStructPointer(x)); err != nil { + return err + } + e.enc = p.buf + m[k] = e + } + return nil +} + +func extensionsSize(e *XXX_InternalExtensions) (n int) { + m, mu := e.extensionsRead() + if m == nil { + return 0 + } + mu.Lock() + defer mu.Unlock() + return extensionsMapSize(m) +} + +func extensionsMapSize(m map[int32]Extension) (n int) { + for _, e := range m { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. + n += len(e.enc) + continue + } + + // We don't skip extensions that have an encoded form set, + // because the extension value may have been mutated after + // the last time this function was called. + + et := reflect.TypeOf(e.desc.ExtensionType) + props := extensionProperties(e.desc) + + // If e.value has type T, the encoder expects a *struct{ X T }. + // Pass a *T with a zero field and hope it all works out. + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(e.value)) + n += props.size(props, toStructPointer(x)) + } + return +} + +// HasExtension returns whether the given extension is present in pb. +func HasExtension(pb Message, extension *ExtensionDesc) bool { + // TODO: Check types, field numbers, etc.? + epb, ok := extendable(pb) + if !ok { + return false + } + extmap, mu := epb.extensionsRead() + if extmap == nil { + return false + } + mu.Lock() + _, ok = extmap[extension.Field] + mu.Unlock() + return ok +} + +// ClearExtension removes the given extension from pb. +func ClearExtension(pb Message, extension *ExtensionDesc) { + epb, ok := extendable(pb) + if !ok { + return + } + // TODO: Check types, field numbers, etc.? + extmap := epb.extensionsWrite() + delete(extmap, extension.Field) +} + +// GetExtension parses and returns the given extension of pb. +// If the extension is not present and has no default value it returns ErrMissingExtension. +func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) { + epb, ok := extendable(pb) + if !ok { + return nil, errors.New("proto: not an extendable proto") + } + + if err := checkExtensionTypes(epb, extension); err != nil { + return nil, err + } + + emap, mu := epb.extensionsRead() + if emap == nil { + return defaultExtensionValue(extension) + } + mu.Lock() + defer mu.Unlock() + e, ok := emap[extension.Field] + if !ok { + // defaultExtensionValue returns the default value or + // ErrMissingExtension if there is no default. + return defaultExtensionValue(extension) + } + + if e.value != nil { + // Already decoded. Check the descriptor, though. + if e.desc != extension { + // This shouldn't happen. If it does, it means that + // GetExtension was called twice with two different + // descriptors with the same field number. + return nil, errors.New("proto: descriptor conflict") + } + return e.value, nil + } + + v, err := decodeExtension(e.enc, extension) + if err != nil { + return nil, err + } + + // Remember the decoded version and drop the encoded version. + // That way it is safe to mutate what we return. + e.value = v + e.desc = extension + e.enc = nil + emap[extension.Field] = e + return e.value, nil +} + +// defaultExtensionValue returns the default value for extension. +// If no default for an extension is defined ErrMissingExtension is returned. +func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) { + t := reflect.TypeOf(extension.ExtensionType) + props := extensionProperties(extension) + + sf, _, err := fieldDefault(t, props) + if err != nil { + return nil, err + } + + if sf == nil || sf.value == nil { + // There is no default value. + return nil, ErrMissingExtension + } + + if t.Kind() != reflect.Ptr { + // We do not need to return a Ptr, we can directly return sf.value. + return sf.value, nil + } + + // We need to return an interface{} that is a pointer to sf.value. + value := reflect.New(t).Elem() + value.Set(reflect.New(value.Type().Elem())) + if sf.kind == reflect.Int32 { + // We may have an int32 or an enum, but the underlying data is int32. + // Since we can't set an int32 into a non int32 reflect.value directly + // set it as a int32. + value.Elem().SetInt(int64(sf.value.(int32))) + } else { + value.Elem().Set(reflect.ValueOf(sf.value)) + } + return value.Interface(), nil +} + +// decodeExtension decodes an extension encoded in b. +func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) { + o := NewBuffer(b) + + t := reflect.TypeOf(extension.ExtensionType) + + props := extensionProperties(extension) + + // t is a pointer to a struct, pointer to basic type or a slice. + // Allocate a "field" to store the pointer/slice itself; the + // pointer/slice will be stored here. We pass + // the address of this field to props.dec. + // This passes a zero field and a *t and lets props.dec + // interpret it as a *struct{ x t }. + value := reflect.New(t).Elem() + + for { + // Discard wire type and field number varint. It isn't needed. + if _, err := o.DecodeVarint(); err != nil { + return nil, err + } + + if err := props.dec(o, props, toStructPointer(value.Addr())); err != nil { + return nil, err + } + + if o.index >= len(o.buf) { + break + } + } + return value.Interface(), nil +} + +// GetExtensions returns a slice of the extensions present in pb that are also listed in es. +// The returned slice has the same length as es; missing extensions will appear as nil elements. +func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) { + epb, ok := extendable(pb) + if !ok { + return nil, errors.New("proto: not an extendable proto") + } + extensions = make([]interface{}, len(es)) + for i, e := range es { + extensions[i], err = GetExtension(epb, e) + if err == ErrMissingExtension { + err = nil + } + if err != nil { + return + } + } + return +} + +// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order. +// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing +// just the Field field, which defines the extension's field number. +func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) { + epb, ok := extendable(pb) + if !ok { + return nil, fmt.Errorf("proto: %T is not an extendable proto.Message", pb) + } + registeredExtensions := RegisteredExtensions(pb) + + emap, mu := epb.extensionsRead() + if emap == nil { + return nil, nil + } + mu.Lock() + defer mu.Unlock() + extensions := make([]*ExtensionDesc, 0, len(emap)) + for extid, e := range emap { + desc := e.desc + if desc == nil { + desc = registeredExtensions[extid] + if desc == nil { + desc = &ExtensionDesc{Field: extid} + } + } + + extensions = append(extensions, desc) + } + return extensions, nil +} + +// SetExtension sets the specified extension of pb to the specified value. +func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error { + epb, ok := extendable(pb) + if !ok { + return errors.New("proto: not an extendable proto") + } + if err := checkExtensionTypes(epb, extension); err != nil { + return err + } + typ := reflect.TypeOf(extension.ExtensionType) + if typ != reflect.TypeOf(value) { + return errors.New("proto: bad extension value type") + } + // nil extension values need to be caught early, because the + // encoder can't distinguish an ErrNil due to a nil extension + // from an ErrNil due to a missing field. Extensions are + // always optional, so the encoder would just swallow the error + // and drop all the extensions from the encoded message. + if reflect.ValueOf(value).IsNil() { + return fmt.Errorf("proto: SetExtension called with nil value of type %T", value) + } + + extmap := epb.extensionsWrite() + extmap[extension.Field] = Extension{desc: extension, value: value} + return nil +} + +// ClearAllExtensions clears all extensions from pb. +func ClearAllExtensions(pb Message) { + epb, ok := extendable(pb) + if !ok { + return + } + m := epb.extensionsWrite() + for k := range m { + delete(m, k) + } +} + +// A global registry of extensions. +// The generated code will register the generated descriptors by calling RegisterExtension. + +var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc) + +// RegisterExtension is called from the generated code. +func RegisterExtension(desc *ExtensionDesc) { + st := reflect.TypeOf(desc.ExtendedType).Elem() + m := extensionMaps[st] + if m == nil { + m = make(map[int32]*ExtensionDesc) + extensionMaps[st] = m + } + if _, ok := m[desc.Field]; ok { + panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field))) + } + m[desc.Field] = desc +} + +// RegisteredExtensions returns a map of the registered extensions of a +// protocol buffer struct, indexed by the extension number. +// The argument pb should be a nil pointer to the struct type. +func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc { + return extensionMaps[reflect.TypeOf(pb).Elem()] +} diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go new file mode 100644 index 00000000..ac4ddbc0 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/lib.go @@ -0,0 +1,898 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* +Package proto converts data structures to and from the wire format of +protocol buffers. It works in concert with the Go source code generated +for .proto files by the protocol compiler. + +A summary of the properties of the protocol buffer interface +for a protocol buffer variable v: + + - Names are turned from camel_case to CamelCase for export. + - There are no methods on v to set fields; just treat + them as structure fields. + - There are getters that return a field's value if set, + and return the field's default value if unset. + The getters work even if the receiver is a nil message. + - The zero value for a struct is its correct initialization state. + All desired fields must be set before marshaling. + - A Reset() method will restore a protobuf struct to its zero state. + - Non-repeated fields are pointers to the values; nil means unset. + That is, optional or required field int32 f becomes F *int32. + - Repeated fields are slices. + - Helper functions are available to aid the setting of fields. + msg.Foo = proto.String("hello") // set field + - Constants are defined to hold the default values of all fields that + have them. They have the form Default_StructName_FieldName. + Because the getter methods handle defaulted values, + direct use of these constants should be rare. + - Enums are given type names and maps from names to values. + Enum values are prefixed by the enclosing message's name, or by the + enum's type name if it is a top-level enum. Enum types have a String + method, and a Enum method to assist in message construction. + - Nested messages, groups and enums have type names prefixed with the name of + the surrounding message type. + - Extensions are given descriptor names that start with E_, + followed by an underscore-delimited list of the nested messages + that contain it (if any) followed by the CamelCased name of the + extension field itself. HasExtension, ClearExtension, GetExtension + and SetExtension are functions for manipulating extensions. + - Oneof field sets are given a single field in their message, + with distinguished wrapper types for each possible field value. + - Marshal and Unmarshal are functions to encode and decode the wire format. + +When the .proto file specifies `syntax="proto3"`, there are some differences: + + - Non-repeated fields of non-message type are values instead of pointers. + - Getters are only generated for message and oneof fields. + - Enum types do not get an Enum method. + +The simplest way to describe this is to see an example. +Given file test.proto, containing + + package example; + + enum FOO { X = 17; } + + message Test { + required string label = 1; + optional int32 type = 2 [default=77]; + repeated int64 reps = 3; + optional group OptionalGroup = 4 { + required string RequiredField = 5; + } + oneof union { + int32 number = 6; + string name = 7; + } + } + +The resulting file, test.pb.go, is: + + package example + + import proto "github.com/golang/protobuf/proto" + import math "math" + + type FOO int32 + const ( + FOO_X FOO = 17 + ) + var FOO_name = map[int32]string{ + 17: "X", + } + var FOO_value = map[string]int32{ + "X": 17, + } + + func (x FOO) Enum() *FOO { + p := new(FOO) + *p = x + return p + } + func (x FOO) String() string { + return proto.EnumName(FOO_name, int32(x)) + } + func (x *FOO) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FOO_value, data) + if err != nil { + return err + } + *x = FOO(value) + return nil + } + + type Test struct { + Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"` + Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"` + Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"` + Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"` + // Types that are valid to be assigned to Union: + // *Test_Number + // *Test_Name + Union isTest_Union `protobuf_oneof:"union"` + XXX_unrecognized []byte `json:"-"` + } + func (m *Test) Reset() { *m = Test{} } + func (m *Test) String() string { return proto.CompactTextString(m) } + func (*Test) ProtoMessage() {} + + type isTest_Union interface { + isTest_Union() + } + + type Test_Number struct { + Number int32 `protobuf:"varint,6,opt,name=number"` + } + type Test_Name struct { + Name string `protobuf:"bytes,7,opt,name=name"` + } + + func (*Test_Number) isTest_Union() {} + func (*Test_Name) isTest_Union() {} + + func (m *Test) GetUnion() isTest_Union { + if m != nil { + return m.Union + } + return nil + } + const Default_Test_Type int32 = 77 + + func (m *Test) GetLabel() string { + if m != nil && m.Label != nil { + return *m.Label + } + return "" + } + + func (m *Test) GetType() int32 { + if m != nil && m.Type != nil { + return *m.Type + } + return Default_Test_Type + } + + func (m *Test) GetOptionalgroup() *Test_OptionalGroup { + if m != nil { + return m.Optionalgroup + } + return nil + } + + type Test_OptionalGroup struct { + RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"` + } + func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} } + func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) } + + func (m *Test_OptionalGroup) GetRequiredField() string { + if m != nil && m.RequiredField != nil { + return *m.RequiredField + } + return "" + } + + func (m *Test) GetNumber() int32 { + if x, ok := m.GetUnion().(*Test_Number); ok { + return x.Number + } + return 0 + } + + func (m *Test) GetName() string { + if x, ok := m.GetUnion().(*Test_Name); ok { + return x.Name + } + return "" + } + + func init() { + proto.RegisterEnum("example.FOO", FOO_name, FOO_value) + } + +To create and play with a Test object: + + package main + + import ( + "log" + + "github.com/golang/protobuf/proto" + pb "./example.pb" + ) + + func main() { + test := &pb.Test{ + Label: proto.String("hello"), + Type: proto.Int32(17), + Reps: []int64{1, 2, 3}, + Optionalgroup: &pb.Test_OptionalGroup{ + RequiredField: proto.String("good bye"), + }, + Union: &pb.Test_Name{"fred"}, + } + data, err := proto.Marshal(test) + if err != nil { + log.Fatal("marshaling error: ", err) + } + newTest := &pb.Test{} + err = proto.Unmarshal(data, newTest) + if err != nil { + log.Fatal("unmarshaling error: ", err) + } + // Now test and newTest contain the same data. + if test.GetLabel() != newTest.GetLabel() { + log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) + } + // Use a type switch to determine which oneof was set. + switch u := test.Union.(type) { + case *pb.Test_Number: // u.Number contains the number. + case *pb.Test_Name: // u.Name contains the string. + } + // etc. + } +*/ +package proto + +import ( + "encoding/json" + "fmt" + "log" + "reflect" + "sort" + "strconv" + "sync" +) + +// Message is implemented by generated protocol buffer messages. +type Message interface { + Reset() + String() string + ProtoMessage() +} + +// Stats records allocation details about the protocol buffer encoders +// and decoders. Useful for tuning the library itself. +type Stats struct { + Emalloc uint64 // mallocs in encode + Dmalloc uint64 // mallocs in decode + Encode uint64 // number of encodes + Decode uint64 // number of decodes + Chit uint64 // number of cache hits + Cmiss uint64 // number of cache misses + Size uint64 // number of sizes +} + +// Set to true to enable stats collection. +const collectStats = false + +var stats Stats + +// GetStats returns a copy of the global Stats structure. +func GetStats() Stats { return stats } + +// A Buffer is a buffer manager for marshaling and unmarshaling +// protocol buffers. It may be reused between invocations to +// reduce memory usage. It is not necessary to use a Buffer; +// the global functions Marshal and Unmarshal create a +// temporary Buffer and are fine for most applications. +type Buffer struct { + buf []byte // encode/decode byte stream + index int // read point + + // pools of basic types to amortize allocation. + bools []bool + uint32s []uint32 + uint64s []uint64 + + // extra pools, only used with pointer_reflect.go + int32s []int32 + int64s []int64 + float32s []float32 + float64s []float64 +} + +// NewBuffer allocates a new Buffer and initializes its internal data to +// the contents of the argument slice. +func NewBuffer(e []byte) *Buffer { + return &Buffer{buf: e} +} + +// Reset resets the Buffer, ready for marshaling a new protocol buffer. +func (p *Buffer) Reset() { + p.buf = p.buf[0:0] // for reading/writing + p.index = 0 // for reading +} + +// SetBuf replaces the internal buffer with the slice, +// ready for unmarshaling the contents of the slice. +func (p *Buffer) SetBuf(s []byte) { + p.buf = s + p.index = 0 +} + +// Bytes returns the contents of the Buffer. +func (p *Buffer) Bytes() []byte { return p.buf } + +/* + * Helper routines for simplifying the creation of optional fields of basic type. + */ + +// Bool is a helper routine that allocates a new bool value +// to store v and returns a pointer to it. +func Bool(v bool) *bool { + return &v +} + +// Int32 is a helper routine that allocates a new int32 value +// to store v and returns a pointer to it. +func Int32(v int32) *int32 { + return &v +} + +// Int is a helper routine that allocates a new int32 value +// to store v and returns a pointer to it, but unlike Int32 +// its argument value is an int. +func Int(v int) *int32 { + p := new(int32) + *p = int32(v) + return p +} + +// Int64 is a helper routine that allocates a new int64 value +// to store v and returns a pointer to it. +func Int64(v int64) *int64 { + return &v +} + +// Float32 is a helper routine that allocates a new float32 value +// to store v and returns a pointer to it. +func Float32(v float32) *float32 { + return &v +} + +// Float64 is a helper routine that allocates a new float64 value +// to store v and returns a pointer to it. +func Float64(v float64) *float64 { + return &v +} + +// Uint32 is a helper routine that allocates a new uint32 value +// to store v and returns a pointer to it. +func Uint32(v uint32) *uint32 { + return &v +} + +// Uint64 is a helper routine that allocates a new uint64 value +// to store v and returns a pointer to it. +func Uint64(v uint64) *uint64 { + return &v +} + +// String is a helper routine that allocates a new string value +// to store v and returns a pointer to it. +func String(v string) *string { + return &v +} + +// EnumName is a helper function to simplify printing protocol buffer enums +// by name. Given an enum map and a value, it returns a useful string. +func EnumName(m map[int32]string, v int32) string { + s, ok := m[v] + if ok { + return s + } + return strconv.Itoa(int(v)) +} + +// UnmarshalJSONEnum is a helper function to simplify recovering enum int values +// from their JSON-encoded representation. Given a map from the enum's symbolic +// names to its int values, and a byte buffer containing the JSON-encoded +// value, it returns an int32 that can be cast to the enum type by the caller. +// +// The function can deal with both JSON representations, numeric and symbolic. +func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) { + if data[0] == '"' { + // New style: enums are strings. + var repr string + if err := json.Unmarshal(data, &repr); err != nil { + return -1, err + } + val, ok := m[repr] + if !ok { + return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr) + } + return val, nil + } + // Old style: enums are ints. + var val int32 + if err := json.Unmarshal(data, &val); err != nil { + return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName) + } + return val, nil +} + +// DebugPrint dumps the encoded data in b in a debugging format with a header +// including the string s. Used in testing but made available for general debugging. +func (p *Buffer) DebugPrint(s string, b []byte) { + var u uint64 + + obuf := p.buf + index := p.index + p.buf = b + p.index = 0 + depth := 0 + + fmt.Printf("\n--- %s ---\n", s) + +out: + for { + for i := 0; i < depth; i++ { + fmt.Print(" ") + } + + index := p.index + if index == len(p.buf) { + break + } + + op, err := p.DecodeVarint() + if err != nil { + fmt.Printf("%3d: fetching op err %v\n", index, err) + break out + } + tag := op >> 3 + wire := op & 7 + + switch wire { + default: + fmt.Printf("%3d: t=%3d unknown wire=%d\n", + index, tag, wire) + break out + + case WireBytes: + var r []byte + + r, err = p.DecodeRawBytes(false) + if err != nil { + break out + } + fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r)) + if len(r) <= 6 { + for i := 0; i < len(r); i++ { + fmt.Printf(" %.2x", r[i]) + } + } else { + for i := 0; i < 3; i++ { + fmt.Printf(" %.2x", r[i]) + } + fmt.Printf(" ..") + for i := len(r) - 3; i < len(r); i++ { + fmt.Printf(" %.2x", r[i]) + } + } + fmt.Printf("\n") + + case WireFixed32: + u, err = p.DecodeFixed32() + if err != nil { + fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u) + + case WireFixed64: + u, err = p.DecodeFixed64() + if err != nil { + fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u) + + case WireVarint: + u, err = p.DecodeVarint() + if err != nil { + fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u) + + case WireStartGroup: + fmt.Printf("%3d: t=%3d start\n", index, tag) + depth++ + + case WireEndGroup: + depth-- + fmt.Printf("%3d: t=%3d end\n", index, tag) + } + } + + if depth != 0 { + fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth) + } + fmt.Printf("\n") + + p.buf = obuf + p.index = index +} + +// SetDefaults sets unset protocol buffer fields to their default values. +// It only modifies fields that are both unset and have defined defaults. +// It recursively sets default values in any non-nil sub-messages. +func SetDefaults(pb Message) { + setDefaults(reflect.ValueOf(pb), true, false) +} + +// v is a pointer to a struct. +func setDefaults(v reflect.Value, recur, zeros bool) { + v = v.Elem() + + defaultMu.RLock() + dm, ok := defaults[v.Type()] + defaultMu.RUnlock() + if !ok { + dm = buildDefaultMessage(v.Type()) + defaultMu.Lock() + defaults[v.Type()] = dm + defaultMu.Unlock() + } + + for _, sf := range dm.scalars { + f := v.Field(sf.index) + if !f.IsNil() { + // field already set + continue + } + dv := sf.value + if dv == nil && !zeros { + // no explicit default, and don't want to set zeros + continue + } + fptr := f.Addr().Interface() // **T + // TODO: Consider batching the allocations we do here. + switch sf.kind { + case reflect.Bool: + b := new(bool) + if dv != nil { + *b = dv.(bool) + } + *(fptr.(**bool)) = b + case reflect.Float32: + f := new(float32) + if dv != nil { + *f = dv.(float32) + } + *(fptr.(**float32)) = f + case reflect.Float64: + f := new(float64) + if dv != nil { + *f = dv.(float64) + } + *(fptr.(**float64)) = f + case reflect.Int32: + // might be an enum + if ft := f.Type(); ft != int32PtrType { + // enum + f.Set(reflect.New(ft.Elem())) + if dv != nil { + f.Elem().SetInt(int64(dv.(int32))) + } + } else { + // int32 field + i := new(int32) + if dv != nil { + *i = dv.(int32) + } + *(fptr.(**int32)) = i + } + case reflect.Int64: + i := new(int64) + if dv != nil { + *i = dv.(int64) + } + *(fptr.(**int64)) = i + case reflect.String: + s := new(string) + if dv != nil { + *s = dv.(string) + } + *(fptr.(**string)) = s + case reflect.Uint8: + // exceptional case: []byte + var b []byte + if dv != nil { + db := dv.([]byte) + b = make([]byte, len(db)) + copy(b, db) + } else { + b = []byte{} + } + *(fptr.(*[]byte)) = b + case reflect.Uint32: + u := new(uint32) + if dv != nil { + *u = dv.(uint32) + } + *(fptr.(**uint32)) = u + case reflect.Uint64: + u := new(uint64) + if dv != nil { + *u = dv.(uint64) + } + *(fptr.(**uint64)) = u + default: + log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind) + } + } + + for _, ni := range dm.nested { + f := v.Field(ni) + // f is *T or []*T or map[T]*T + switch f.Kind() { + case reflect.Ptr: + if f.IsNil() { + continue + } + setDefaults(f, recur, zeros) + + case reflect.Slice: + for i := 0; i < f.Len(); i++ { + e := f.Index(i) + if e.IsNil() { + continue + } + setDefaults(e, recur, zeros) + } + + case reflect.Map: + for _, k := range f.MapKeys() { + e := f.MapIndex(k) + if e.IsNil() { + continue + } + setDefaults(e, recur, zeros) + } + } + } +} + +var ( + // defaults maps a protocol buffer struct type to a slice of the fields, + // with its scalar fields set to their proto-declared non-zero default values. + defaultMu sync.RWMutex + defaults = make(map[reflect.Type]defaultMessage) + + int32PtrType = reflect.TypeOf((*int32)(nil)) +) + +// defaultMessage represents information about the default values of a message. +type defaultMessage struct { + scalars []scalarField + nested []int // struct field index of nested messages +} + +type scalarField struct { + index int // struct field index + kind reflect.Kind // element type (the T in *T or []T) + value interface{} // the proto-declared default value, or nil +} + +// t is a struct type. +func buildDefaultMessage(t reflect.Type) (dm defaultMessage) { + sprop := GetProperties(t) + for _, prop := range sprop.Prop { + fi, ok := sprop.decoderTags.get(prop.Tag) + if !ok { + // XXX_unrecognized + continue + } + ft := t.Field(fi).Type + + sf, nested, err := fieldDefault(ft, prop) + switch { + case err != nil: + log.Print(err) + case nested: + dm.nested = append(dm.nested, fi) + case sf != nil: + sf.index = fi + dm.scalars = append(dm.scalars, *sf) + } + } + + return dm +} + +// fieldDefault returns the scalarField for field type ft. +// sf will be nil if the field can not have a default. +// nestedMessage will be true if this is a nested message. +// Note that sf.index is not set on return. +func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) { + var canHaveDefault bool + switch ft.Kind() { + case reflect.Ptr: + if ft.Elem().Kind() == reflect.Struct { + nestedMessage = true + } else { + canHaveDefault = true // proto2 scalar field + } + + case reflect.Slice: + switch ft.Elem().Kind() { + case reflect.Ptr: + nestedMessage = true // repeated message + case reflect.Uint8: + canHaveDefault = true // bytes field + } + + case reflect.Map: + if ft.Elem().Kind() == reflect.Ptr { + nestedMessage = true // map with message values + } + } + + if !canHaveDefault { + if nestedMessage { + return nil, true, nil + } + return nil, false, nil + } + + // We now know that ft is a pointer or slice. + sf = &scalarField{kind: ft.Elem().Kind()} + + // scalar fields without defaults + if !prop.HasDefault { + return sf, false, nil + } + + // a scalar field: either *T or []byte + switch ft.Elem().Kind() { + case reflect.Bool: + x, err := strconv.ParseBool(prop.Default) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err) + } + sf.value = x + case reflect.Float32: + x, err := strconv.ParseFloat(prop.Default, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err) + } + sf.value = float32(x) + case reflect.Float64: + x, err := strconv.ParseFloat(prop.Default, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err) + } + sf.value = x + case reflect.Int32: + x, err := strconv.ParseInt(prop.Default, 10, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err) + } + sf.value = int32(x) + case reflect.Int64: + x, err := strconv.ParseInt(prop.Default, 10, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err) + } + sf.value = x + case reflect.String: + sf.value = prop.Default + case reflect.Uint8: + // []byte (not *uint8) + sf.value = []byte(prop.Default) + case reflect.Uint32: + x, err := strconv.ParseUint(prop.Default, 10, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err) + } + sf.value = uint32(x) + case reflect.Uint64: + x, err := strconv.ParseUint(prop.Default, 10, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err) + } + sf.value = x + default: + return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind()) + } + + return sf, false, nil +} + +// Map fields may have key types of non-float scalars, strings and enums. +// The easiest way to sort them in some deterministic order is to use fmt. +// If this turns out to be inefficient we can always consider other options, +// such as doing a Schwartzian transform. + +func mapKeys(vs []reflect.Value) sort.Interface { + s := mapKeySorter{ + vs: vs, + // default Less function: textual comparison + less: func(a, b reflect.Value) bool { + return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface()) + }, + } + + // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps; + // numeric keys are sorted numerically. + if len(vs) == 0 { + return s + } + switch vs[0].Kind() { + case reflect.Int32, reflect.Int64: + s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() } + case reflect.Uint32, reflect.Uint64: + s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() } + } + + return s +} + +type mapKeySorter struct { + vs []reflect.Value + less func(a, b reflect.Value) bool +} + +func (s mapKeySorter) Len() int { return len(s.vs) } +func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] } +func (s mapKeySorter) Less(i, j int) bool { + return s.less(s.vs[i], s.vs[j]) +} + +// isProto3Zero reports whether v is a zero proto3 value. +func isProto3Zero(v reflect.Value) bool { + switch v.Kind() { + case reflect.Bool: + return !v.Bool() + case reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint32, reflect.Uint64: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.String: + return v.String() == "" + } + return false +} + +// ProtoPackageIsVersion2 is referenced from generated protocol buffer files +// to assert that that code is compatible with this version of the proto package. +const ProtoPackageIsVersion2 = true + +// ProtoPackageIsVersion1 is referenced from generated protocol buffer files +// to assert that that code is compatible with this version of the proto package. +const ProtoPackageIsVersion1 = true diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.go new file mode 100644 index 00000000..fd982dec --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/message_set.go @@ -0,0 +1,311 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Support for message sets. + */ + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "reflect" + "sort" +) + +// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID. +// A message type ID is required for storing a protocol buffer in a message set. +var errNoMessageTypeID = errors.New("proto does not have a message type ID") + +// The first two types (_MessageSet_Item and messageSet) +// model what the protocol compiler produces for the following protocol message: +// message MessageSet { +// repeated group Item = 1 { +// required int32 type_id = 2; +// required string message = 3; +// }; +// } +// That is the MessageSet wire format. We can't use a proto to generate these +// because that would introduce a circular dependency between it and this package. + +type _MessageSet_Item struct { + TypeId *int32 `protobuf:"varint,2,req,name=type_id"` + Message []byte `protobuf:"bytes,3,req,name=message"` +} + +type messageSet struct { + Item []*_MessageSet_Item `protobuf:"group,1,rep"` + XXX_unrecognized []byte + // TODO: caching? +} + +// Make sure messageSet is a Message. +var _ Message = (*messageSet)(nil) + +// messageTypeIder is an interface satisfied by a protocol buffer type +// that may be stored in a MessageSet. +type messageTypeIder interface { + MessageTypeId() int32 +} + +func (ms *messageSet) find(pb Message) *_MessageSet_Item { + mti, ok := pb.(messageTypeIder) + if !ok { + return nil + } + id := mti.MessageTypeId() + for _, item := range ms.Item { + if *item.TypeId == id { + return item + } + } + return nil +} + +func (ms *messageSet) Has(pb Message) bool { + if ms.find(pb) != nil { + return true + } + return false +} + +func (ms *messageSet) Unmarshal(pb Message) error { + if item := ms.find(pb); item != nil { + return Unmarshal(item.Message, pb) + } + if _, ok := pb.(messageTypeIder); !ok { + return errNoMessageTypeID + } + return nil // TODO: return error instead? +} + +func (ms *messageSet) Marshal(pb Message) error { + msg, err := Marshal(pb) + if err != nil { + return err + } + if item := ms.find(pb); item != nil { + // reuse existing item + item.Message = msg + return nil + } + + mti, ok := pb.(messageTypeIder) + if !ok { + return errNoMessageTypeID + } + + mtid := mti.MessageTypeId() + ms.Item = append(ms.Item, &_MessageSet_Item{ + TypeId: &mtid, + Message: msg, + }) + return nil +} + +func (ms *messageSet) Reset() { *ms = messageSet{} } +func (ms *messageSet) String() string { return CompactTextString(ms) } +func (*messageSet) ProtoMessage() {} + +// Support for the message_set_wire_format message option. + +func skipVarint(buf []byte) []byte { + i := 0 + for ; buf[i]&0x80 != 0; i++ { + } + return buf[i+1:] +} + +// MarshalMessageSet encodes the extension map represented by m in the message set wire format. +// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option. +func MarshalMessageSet(exts interface{}) ([]byte, error) { + var m map[int32]Extension + switch exts := exts.(type) { + case *XXX_InternalExtensions: + if err := encodeExtensions(exts); err != nil { + return nil, err + } + m, _ = exts.extensionsRead() + case map[int32]Extension: + if err := encodeExtensionsMap(exts); err != nil { + return nil, err + } + m = exts + default: + return nil, errors.New("proto: not an extension map") + } + + // Sort extension IDs to provide a deterministic encoding. + // See also enc_map in encode.go. + ids := make([]int, 0, len(m)) + for id := range m { + ids = append(ids, int(id)) + } + sort.Ints(ids) + + ms := &messageSet{Item: make([]*_MessageSet_Item, 0, len(m))} + for _, id := range ids { + e := m[int32(id)] + // Remove the wire type and field number varint, as well as the length varint. + msg := skipVarint(skipVarint(e.enc)) + + ms.Item = append(ms.Item, &_MessageSet_Item{ + TypeId: Int32(int32(id)), + Message: msg, + }) + } + return Marshal(ms) +} + +// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format. +// It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option. +func UnmarshalMessageSet(buf []byte, exts interface{}) error { + var m map[int32]Extension + switch exts := exts.(type) { + case *XXX_InternalExtensions: + m = exts.extensionsWrite() + case map[int32]Extension: + m = exts + default: + return errors.New("proto: not an extension map") + } + + ms := new(messageSet) + if err := Unmarshal(buf, ms); err != nil { + return err + } + for _, item := range ms.Item { + id := *item.TypeId + msg := item.Message + + // Restore wire type and field number varint, plus length varint. + // Be careful to preserve duplicate items. + b := EncodeVarint(uint64(id)<<3 | WireBytes) + if ext, ok := m[id]; ok { + // Existing data; rip off the tag and length varint + // so we join the new data correctly. + // We can assume that ext.enc is set because we are unmarshaling. + o := ext.enc[len(b):] // skip wire type and field number + _, n := DecodeVarint(o) // calculate length of length varint + o = o[n:] // skip length varint + msg = append(o, msg...) // join old data and new data + } + b = append(b, EncodeVarint(uint64(len(msg)))...) + b = append(b, msg...) + + m[id] = Extension{enc: b} + } + return nil +} + +// MarshalMessageSetJSON encodes the extension map represented by m in JSON format. +// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option. +func MarshalMessageSetJSON(exts interface{}) ([]byte, error) { + var m map[int32]Extension + switch exts := exts.(type) { + case *XXX_InternalExtensions: + m, _ = exts.extensionsRead() + case map[int32]Extension: + m = exts + default: + return nil, errors.New("proto: not an extension map") + } + var b bytes.Buffer + b.WriteByte('{') + + // Process the map in key order for deterministic output. + ids := make([]int32, 0, len(m)) + for id := range m { + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) // int32Slice defined in text.go + + for i, id := range ids { + ext := m[id] + if i > 0 { + b.WriteByte(',') + } + + msd, ok := messageSetMap[id] + if !ok { + // Unknown type; we can't render it, so skip it. + continue + } + fmt.Fprintf(&b, `"[%s]":`, msd.name) + + x := ext.value + if x == nil { + x = reflect.New(msd.t.Elem()).Interface() + if err := Unmarshal(ext.enc, x.(Message)); err != nil { + return nil, err + } + } + d, err := json.Marshal(x) + if err != nil { + return nil, err + } + b.Write(d) + } + b.WriteByte('}') + return b.Bytes(), nil +} + +// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format. +// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option. +func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error { + // Common-case fast path. + if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) { + return nil + } + + // This is fairly tricky, and it's not clear that it is needed. + return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented") +} + +// A global registry of types that can be used in a MessageSet. + +var messageSetMap = make(map[int32]messageSetDesc) + +type messageSetDesc struct { + t reflect.Type // pointer to struct + name string +} + +// RegisterMessageSetType is called from the generated code. +func RegisterMessageSetType(m Message, fieldNum int32, name string) { + messageSetMap[fieldNum] = messageSetDesc{ + t: reflect.TypeOf(m), + name: name, + } +} diff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go new file mode 100644 index 00000000..fb512e2e --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go @@ -0,0 +1,484 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// +build appengine js + +// This file contains an implementation of proto field accesses using package reflect. +// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can +// be used on App Engine. + +package proto + +import ( + "math" + "reflect" +) + +// A structPointer is a pointer to a struct. +type structPointer struct { + v reflect.Value +} + +// toStructPointer returns a structPointer equivalent to the given reflect value. +// The reflect value must itself be a pointer to a struct. +func toStructPointer(v reflect.Value) structPointer { + return structPointer{v} +} + +// IsNil reports whether p is nil. +func structPointer_IsNil(p structPointer) bool { + return p.v.IsNil() +} + +// Interface returns the struct pointer as an interface value. +func structPointer_Interface(p structPointer, _ reflect.Type) interface{} { + return p.v.Interface() +} + +// A field identifies a field in a struct, accessible from a structPointer. +// In this implementation, a field is identified by the sequence of field indices +// passed to reflect's FieldByIndex. +type field []int + +// toField returns a field equivalent to the given reflect field. +func toField(f *reflect.StructField) field { + return f.Index +} + +// invalidField is an invalid field identifier. +var invalidField = field(nil) + +// IsValid reports whether the field identifier is valid. +func (f field) IsValid() bool { return f != nil } + +// field returns the given field in the struct as a reflect value. +func structPointer_field(p structPointer, f field) reflect.Value { + // Special case: an extension map entry with a value of type T + // passes a *T to the struct-handling code with a zero field, + // expecting that it will be treated as equivalent to *struct{ X T }, + // which has the same memory layout. We have to handle that case + // specially, because reflect will panic if we call FieldByIndex on a + // non-struct. + if f == nil { + return p.v.Elem() + } + + return p.v.Elem().FieldByIndex(f) +} + +// ifield returns the given field in the struct as an interface value. +func structPointer_ifield(p structPointer, f field) interface{} { + return structPointer_field(p, f).Addr().Interface() +} + +// Bytes returns the address of a []byte field in the struct. +func structPointer_Bytes(p structPointer, f field) *[]byte { + return structPointer_ifield(p, f).(*[]byte) +} + +// BytesSlice returns the address of a [][]byte field in the struct. +func structPointer_BytesSlice(p structPointer, f field) *[][]byte { + return structPointer_ifield(p, f).(*[][]byte) +} + +// Bool returns the address of a *bool field in the struct. +func structPointer_Bool(p structPointer, f field) **bool { + return structPointer_ifield(p, f).(**bool) +} + +// BoolVal returns the address of a bool field in the struct. +func structPointer_BoolVal(p structPointer, f field) *bool { + return structPointer_ifield(p, f).(*bool) +} + +// BoolSlice returns the address of a []bool field in the struct. +func structPointer_BoolSlice(p structPointer, f field) *[]bool { + return structPointer_ifield(p, f).(*[]bool) +} + +// String returns the address of a *string field in the struct. +func structPointer_String(p structPointer, f field) **string { + return structPointer_ifield(p, f).(**string) +} + +// StringVal returns the address of a string field in the struct. +func structPointer_StringVal(p structPointer, f field) *string { + return structPointer_ifield(p, f).(*string) +} + +// StringSlice returns the address of a []string field in the struct. +func structPointer_StringSlice(p structPointer, f field) *[]string { + return structPointer_ifield(p, f).(*[]string) +} + +// Extensions returns the address of an extension map field in the struct. +func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions { + return structPointer_ifield(p, f).(*XXX_InternalExtensions) +} + +// ExtMap returns the address of an extension map field in the struct. +func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { + return structPointer_ifield(p, f).(*map[int32]Extension) +} + +// NewAt returns the reflect.Value for a pointer to a field in the struct. +func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { + return structPointer_field(p, f).Addr() +} + +// SetStructPointer writes a *struct field in the struct. +func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { + structPointer_field(p, f).Set(q.v) +} + +// GetStructPointer reads a *struct field in the struct. +func structPointer_GetStructPointer(p structPointer, f field) structPointer { + return structPointer{structPointer_field(p, f)} +} + +// StructPointerSlice the address of a []*struct field in the struct. +func structPointer_StructPointerSlice(p structPointer, f field) structPointerSlice { + return structPointerSlice{structPointer_field(p, f)} +} + +// A structPointerSlice represents the address of a slice of pointers to structs +// (themselves messages or groups). That is, v.Type() is *[]*struct{...}. +type structPointerSlice struct { + v reflect.Value +} + +func (p structPointerSlice) Len() int { return p.v.Len() } +func (p structPointerSlice) Index(i int) structPointer { return structPointer{p.v.Index(i)} } +func (p structPointerSlice) Append(q structPointer) { + p.v.Set(reflect.Append(p.v, q.v)) +} + +var ( + int32Type = reflect.TypeOf(int32(0)) + uint32Type = reflect.TypeOf(uint32(0)) + float32Type = reflect.TypeOf(float32(0)) + int64Type = reflect.TypeOf(int64(0)) + uint64Type = reflect.TypeOf(uint64(0)) + float64Type = reflect.TypeOf(float64(0)) +) + +// A word32 represents a field of type *int32, *uint32, *float32, or *enum. +// That is, v.Type() is *int32, *uint32, *float32, or *enum and v is assignable. +type word32 struct { + v reflect.Value +} + +// IsNil reports whether p is nil. +func word32_IsNil(p word32) bool { + return p.v.IsNil() +} + +// Set sets p to point at a newly allocated word with bits set to x. +func word32_Set(p word32, o *Buffer, x uint32) { + t := p.v.Type().Elem() + switch t { + case int32Type: + if len(o.int32s) == 0 { + o.int32s = make([]int32, uint32PoolSize) + } + o.int32s[0] = int32(x) + p.v.Set(reflect.ValueOf(&o.int32s[0])) + o.int32s = o.int32s[1:] + return + case uint32Type: + if len(o.uint32s) == 0 { + o.uint32s = make([]uint32, uint32PoolSize) + } + o.uint32s[0] = x + p.v.Set(reflect.ValueOf(&o.uint32s[0])) + o.uint32s = o.uint32s[1:] + return + case float32Type: + if len(o.float32s) == 0 { + o.float32s = make([]float32, uint32PoolSize) + } + o.float32s[0] = math.Float32frombits(x) + p.v.Set(reflect.ValueOf(&o.float32s[0])) + o.float32s = o.float32s[1:] + return + } + + // must be enum + p.v.Set(reflect.New(t)) + p.v.Elem().SetInt(int64(int32(x))) +} + +// Get gets the bits pointed at by p, as a uint32. +func word32_Get(p word32) uint32 { + elem := p.v.Elem() + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32 returns a reference to a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32(p structPointer, f field) word32 { + return word32{structPointer_field(p, f)} +} + +// A word32Val represents a field of type int32, uint32, float32, or enum. +// That is, v.Type() is int32, uint32, float32, or enum and v is assignable. +type word32Val struct { + v reflect.Value +} + +// Set sets *p to x. +func word32Val_Set(p word32Val, x uint32) { + switch p.v.Type() { + case int32Type: + p.v.SetInt(int64(x)) + return + case uint32Type: + p.v.SetUint(uint64(x)) + return + case float32Type: + p.v.SetFloat(float64(math.Float32frombits(x))) + return + } + + // must be enum + p.v.SetInt(int64(int32(x))) +} + +// Get gets the bits pointed at by p, as a uint32. +func word32Val_Get(p word32Val) uint32 { + elem := p.v + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32Val returns a reference to a int32, uint32, float32, or enum field in the struct. +func structPointer_Word32Val(p structPointer, f field) word32Val { + return word32Val{structPointer_field(p, f)} +} + +// A word32Slice is a slice of 32-bit values. +// That is, v.Type() is []int32, []uint32, []float32, or []enum. +type word32Slice struct { + v reflect.Value +} + +func (p word32Slice) Append(x uint32) { + n, m := p.v.Len(), p.v.Cap() + if n < m { + p.v.SetLen(n + 1) + } else { + t := p.v.Type().Elem() + p.v.Set(reflect.Append(p.v, reflect.Zero(t))) + } + elem := p.v.Index(n) + switch elem.Kind() { + case reflect.Int32: + elem.SetInt(int64(int32(x))) + case reflect.Uint32: + elem.SetUint(uint64(x)) + case reflect.Float32: + elem.SetFloat(float64(math.Float32frombits(x))) + } +} + +func (p word32Slice) Len() int { + return p.v.Len() +} + +func (p word32Slice) Index(i int) uint32 { + elem := p.v.Index(i) + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32Slice returns a reference to a []int32, []uint32, []float32, or []enum field in the struct. +func structPointer_Word32Slice(p structPointer, f field) word32Slice { + return word32Slice{structPointer_field(p, f)} +} + +// word64 is like word32 but for 64-bit values. +type word64 struct { + v reflect.Value +} + +func word64_Set(p word64, o *Buffer, x uint64) { + t := p.v.Type().Elem() + switch t { + case int64Type: + if len(o.int64s) == 0 { + o.int64s = make([]int64, uint64PoolSize) + } + o.int64s[0] = int64(x) + p.v.Set(reflect.ValueOf(&o.int64s[0])) + o.int64s = o.int64s[1:] + return + case uint64Type: + if len(o.uint64s) == 0 { + o.uint64s = make([]uint64, uint64PoolSize) + } + o.uint64s[0] = x + p.v.Set(reflect.ValueOf(&o.uint64s[0])) + o.uint64s = o.uint64s[1:] + return + case float64Type: + if len(o.float64s) == 0 { + o.float64s = make([]float64, uint64PoolSize) + } + o.float64s[0] = math.Float64frombits(x) + p.v.Set(reflect.ValueOf(&o.float64s[0])) + o.float64s = o.float64s[1:] + return + } + panic("unreachable") +} + +func word64_IsNil(p word64) bool { + return p.v.IsNil() +} + +func word64_Get(p word64) uint64 { + elem := p.v.Elem() + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return elem.Uint() + case reflect.Float64: + return math.Float64bits(elem.Float()) + } + panic("unreachable") +} + +func structPointer_Word64(p structPointer, f field) word64 { + return word64{structPointer_field(p, f)} +} + +// word64Val is like word32Val but for 64-bit values. +type word64Val struct { + v reflect.Value +} + +func word64Val_Set(p word64Val, o *Buffer, x uint64) { + switch p.v.Type() { + case int64Type: + p.v.SetInt(int64(x)) + return + case uint64Type: + p.v.SetUint(x) + return + case float64Type: + p.v.SetFloat(math.Float64frombits(x)) + return + } + panic("unreachable") +} + +func word64Val_Get(p word64Val) uint64 { + elem := p.v + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return elem.Uint() + case reflect.Float64: + return math.Float64bits(elem.Float()) + } + panic("unreachable") +} + +func structPointer_Word64Val(p structPointer, f field) word64Val { + return word64Val{structPointer_field(p, f)} +} + +type word64Slice struct { + v reflect.Value +} + +func (p word64Slice) Append(x uint64) { + n, m := p.v.Len(), p.v.Cap() + if n < m { + p.v.SetLen(n + 1) + } else { + t := p.v.Type().Elem() + p.v.Set(reflect.Append(p.v, reflect.Zero(t))) + } + elem := p.v.Index(n) + switch elem.Kind() { + case reflect.Int64: + elem.SetInt(int64(int64(x))) + case reflect.Uint64: + elem.SetUint(uint64(x)) + case reflect.Float64: + elem.SetFloat(float64(math.Float64frombits(x))) + } +} + +func (p word64Slice) Len() int { + return p.v.Len() +} + +func (p word64Slice) Index(i int) uint64 { + elem := p.v.Index(i) + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return uint64(elem.Uint()) + case reflect.Float64: + return math.Float64bits(float64(elem.Float())) + } + panic("unreachable") +} + +func structPointer_Word64Slice(p structPointer, f field) word64Slice { + return word64Slice{structPointer_field(p, f)} +} diff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go new file mode 100644 index 00000000..6b5567d4 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go @@ -0,0 +1,270 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// +build !appengine,!js + +// This file contains the implementation of the proto field accesses using package unsafe. + +package proto + +import ( + "reflect" + "unsafe" +) + +// NOTE: These type_Foo functions would more idiomatically be methods, +// but Go does not allow methods on pointer types, and we must preserve +// some pointer type for the garbage collector. We use these +// funcs with clunky names as our poor approximation to methods. +// +// An alternative would be +// type structPointer struct { p unsafe.Pointer } +// but that does not registerize as well. + +// A structPointer is a pointer to a struct. +type structPointer unsafe.Pointer + +// toStructPointer returns a structPointer equivalent to the given reflect value. +func toStructPointer(v reflect.Value) structPointer { + return structPointer(unsafe.Pointer(v.Pointer())) +} + +// IsNil reports whether p is nil. +func structPointer_IsNil(p structPointer) bool { + return p == nil +} + +// Interface returns the struct pointer, assumed to have element type t, +// as an interface value. +func structPointer_Interface(p structPointer, t reflect.Type) interface{} { + return reflect.NewAt(t, unsafe.Pointer(p)).Interface() +} + +// A field identifies a field in a struct, accessible from a structPointer. +// In this implementation, a field is identified by its byte offset from the start of the struct. +type field uintptr + +// toField returns a field equivalent to the given reflect field. +func toField(f *reflect.StructField) field { + return field(f.Offset) +} + +// invalidField is an invalid field identifier. +const invalidField = ^field(0) + +// IsValid reports whether the field identifier is valid. +func (f field) IsValid() bool { + return f != ^field(0) +} + +// Bytes returns the address of a []byte field in the struct. +func structPointer_Bytes(p structPointer, f field) *[]byte { + return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BytesSlice returns the address of a [][]byte field in the struct. +func structPointer_BytesSlice(p structPointer, f field) *[][]byte { + return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// Bool returns the address of a *bool field in the struct. +func structPointer_Bool(p structPointer, f field) **bool { + return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BoolVal returns the address of a bool field in the struct. +func structPointer_BoolVal(p structPointer, f field) *bool { + return (*bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BoolSlice returns the address of a []bool field in the struct. +func structPointer_BoolSlice(p structPointer, f field) *[]bool { + return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// String returns the address of a *string field in the struct. +func structPointer_String(p structPointer, f field) **string { + return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StringVal returns the address of a string field in the struct. +func structPointer_StringVal(p structPointer, f field) *string { + return (*string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StringSlice returns the address of a []string field in the struct. +func structPointer_StringSlice(p structPointer, f field) *[]string { + return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// ExtMap returns the address of an extension map field in the struct. +func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions { + return (*XXX_InternalExtensions)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { + return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// NewAt returns the reflect.Value for a pointer to a field in the struct. +func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { + return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f))) +} + +// SetStructPointer writes a *struct field in the struct. +func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { + *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q +} + +// GetStructPointer reads a *struct field in the struct. +func structPointer_GetStructPointer(p structPointer, f field) structPointer { + return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StructPointerSlice the address of a []*struct field in the struct. +func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice { + return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups). +type structPointerSlice []structPointer + +func (v *structPointerSlice) Len() int { return len(*v) } +func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] } +func (v *structPointerSlice) Append(p structPointer) { *v = append(*v, p) } + +// A word32 is the address of a "pointer to 32-bit value" field. +type word32 **uint32 + +// IsNil reports whether *v is nil. +func word32_IsNil(p word32) bool { + return *p == nil +} + +// Set sets *v to point at a newly allocated word set to x. +func word32_Set(p word32, o *Buffer, x uint32) { + if len(o.uint32s) == 0 { + o.uint32s = make([]uint32, uint32PoolSize) + } + o.uint32s[0] = x + *p = &o.uint32s[0] + o.uint32s = o.uint32s[1:] +} + +// Get gets the value pointed at by *v. +func word32_Get(p word32) uint32 { + return **p +} + +// Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32(p structPointer, f field) word32 { + return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// A word32Val is the address of a 32-bit value field. +type word32Val *uint32 + +// Set sets *p to x. +func word32Val_Set(p word32Val, x uint32) { + *p = x +} + +// Get gets the value pointed at by p. +func word32Val_Get(p word32Val) uint32 { + return *p +} + +// Word32Val returns the address of a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32Val(p structPointer, f field) word32Val { + return word32Val((*uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// A word32Slice is a slice of 32-bit values. +type word32Slice []uint32 + +func (v *word32Slice) Append(x uint32) { *v = append(*v, x) } +func (v *word32Slice) Len() int { return len(*v) } +func (v *word32Slice) Index(i int) uint32 { return (*v)[i] } + +// Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct. +func structPointer_Word32Slice(p structPointer, f field) *word32Slice { + return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// word64 is like word32 but for 64-bit values. +type word64 **uint64 + +func word64_Set(p word64, o *Buffer, x uint64) { + if len(o.uint64s) == 0 { + o.uint64s = make([]uint64, uint64PoolSize) + } + o.uint64s[0] = x + *p = &o.uint64s[0] + o.uint64s = o.uint64s[1:] +} + +func word64_IsNil(p word64) bool { + return *p == nil +} + +func word64_Get(p word64) uint64 { + return **p +} + +func structPointer_Word64(p structPointer, f field) word64 { + return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// word64Val is like word32Val but for 64-bit values. +type word64Val *uint64 + +func word64Val_Set(p word64Val, o *Buffer, x uint64) { + *p = x +} + +func word64Val_Get(p word64Val) uint64 { + return *p +} + +func structPointer_Word64Val(p structPointer, f field) word64Val { + return word64Val((*uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// word64Slice is like word32Slice but for 64-bit values. +type word64Slice []uint64 + +func (v *word64Slice) Append(x uint64) { *v = append(*v, x) } +func (v *word64Slice) Len() int { return len(*v) } +func (v *word64Slice) Index(i int) uint64 { return (*v)[i] } + +func structPointer_Word64Slice(p structPointer, f field) *word64Slice { + return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go new file mode 100644 index 00000000..69ddda8d --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/properties.go @@ -0,0 +1,864 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Routines for encoding data into the wire format for protocol buffers. + */ + +import ( + "fmt" + "log" + "os" + "reflect" + "sort" + "strconv" + "strings" + "sync" +) + +const debug bool = false + +// Constants that identify the encoding of a value on the wire. +const ( + WireVarint = 0 + WireFixed64 = 1 + WireBytes = 2 + WireStartGroup = 3 + WireEndGroup = 4 + WireFixed32 = 5 +) + +const startSize = 10 // initial slice/string sizes + +// Encoders are defined in encode.go +// An encoder outputs the full representation of a field, including its +// tag and encoder type. +type encoder func(p *Buffer, prop *Properties, base structPointer) error + +// A valueEncoder encodes a single integer in a particular encoding. +type valueEncoder func(o *Buffer, x uint64) error + +// Sizers are defined in encode.go +// A sizer returns the encoded size of a field, including its tag and encoder +// type. +type sizer func(prop *Properties, base structPointer) int + +// A valueSizer returns the encoded size of a single integer in a particular +// encoding. +type valueSizer func(x uint64) int + +// Decoders are defined in decode.go +// A decoder creates a value from its wire representation. +// Unrecognized subelements are saved in unrec. +type decoder func(p *Buffer, prop *Properties, base structPointer) error + +// A valueDecoder decodes a single integer in a particular encoding. +type valueDecoder func(o *Buffer) (x uint64, err error) + +// A oneofMarshaler does the marshaling for all oneof fields in a message. +type oneofMarshaler func(Message, *Buffer) error + +// A oneofUnmarshaler does the unmarshaling for a oneof field in a message. +type oneofUnmarshaler func(Message, int, int, *Buffer) (bool, error) + +// A oneofSizer does the sizing for all oneof fields in a message. +type oneofSizer func(Message) int + +// tagMap is an optimization over map[int]int for typical protocol buffer +// use-cases. Encoded protocol buffers are often in tag order with small tag +// numbers. +type tagMap struct { + fastTags []int + slowTags map[int]int +} + +// tagMapFastLimit is the upper bound on the tag number that will be stored in +// the tagMap slice rather than its map. +const tagMapFastLimit = 1024 + +func (p *tagMap) get(t int) (int, bool) { + if t > 0 && t < tagMapFastLimit { + if t >= len(p.fastTags) { + return 0, false + } + fi := p.fastTags[t] + return fi, fi >= 0 + } + fi, ok := p.slowTags[t] + return fi, ok +} + +func (p *tagMap) put(t int, fi int) { + if t > 0 && t < tagMapFastLimit { + for len(p.fastTags) < t+1 { + p.fastTags = append(p.fastTags, -1) + } + p.fastTags[t] = fi + return + } + if p.slowTags == nil { + p.slowTags = make(map[int]int) + } + p.slowTags[t] = fi +} + +// StructProperties represents properties for all the fields of a struct. +// decoderTags and decoderOrigNames should only be used by the decoder. +type StructProperties struct { + Prop []*Properties // properties for each field + reqCount int // required count + decoderTags tagMap // map from proto tag to struct field number + decoderOrigNames map[string]int // map from original name to struct field number + order []int // list of struct field numbers in tag order + unrecField field // field id of the XXX_unrecognized []byte field + extendable bool // is this an extendable proto + + oneofMarshaler oneofMarshaler + oneofUnmarshaler oneofUnmarshaler + oneofSizer oneofSizer + stype reflect.Type + + // OneofTypes contains information about the oneof fields in this message. + // It is keyed by the original name of a field. + OneofTypes map[string]*OneofProperties +} + +// OneofProperties represents information about a specific field in a oneof. +type OneofProperties struct { + Type reflect.Type // pointer to generated struct type for this oneof field + Field int // struct field number of the containing oneof in the message + Prop *Properties +} + +// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec. +// See encode.go, (*Buffer).enc_struct. + +func (sp *StructProperties) Len() int { return len(sp.order) } +func (sp *StructProperties) Less(i, j int) bool { + return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag +} +func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] } + +// Properties represents the protocol-specific behavior of a single struct field. +type Properties struct { + Name string // name of the field, for error messages + OrigName string // original name before protocol compiler (always set) + JSONName string // name to use for JSON; determined by protoc + Wire string + WireType int + Tag int + Required bool + Optional bool + Repeated bool + Packed bool // relevant for repeated primitives only + Enum string // set for enum types only + proto3 bool // whether this is known to be a proto3 field; set for []byte only + oneof bool // whether this is a oneof field + + Default string // default value + HasDefault bool // whether an explicit default was provided + def_uint64 uint64 + + enc encoder + valEnc valueEncoder // set for bool and numeric types only + field field + tagcode []byte // encoding of EncodeVarint((Tag<<3)|WireType) + tagbuf [8]byte + stype reflect.Type // set for struct types only + sprop *StructProperties // set for struct types only + isMarshaler bool + isUnmarshaler bool + + mtype reflect.Type // set for map types only + mkeyprop *Properties // set for map types only + mvalprop *Properties // set for map types only + + size sizer + valSize valueSizer // set for bool and numeric types only + + dec decoder + valDec valueDecoder // set for bool and numeric types only + + // If this is a packable field, this will be the decoder for the packed version of the field. + packedDec decoder +} + +// String formats the properties in the protobuf struct field tag style. +func (p *Properties) String() string { + s := p.Wire + s = "," + s += strconv.Itoa(p.Tag) + if p.Required { + s += ",req" + } + if p.Optional { + s += ",opt" + } + if p.Repeated { + s += ",rep" + } + if p.Packed { + s += ",packed" + } + s += ",name=" + p.OrigName + if p.JSONName != p.OrigName { + s += ",json=" + p.JSONName + } + if p.proto3 { + s += ",proto3" + } + if p.oneof { + s += ",oneof" + } + if len(p.Enum) > 0 { + s += ",enum=" + p.Enum + } + if p.HasDefault { + s += ",def=" + p.Default + } + return s +} + +// Parse populates p by parsing a string in the protobuf struct field tag style. +func (p *Properties) Parse(s string) { + // "bytes,49,opt,name=foo,def=hello!" + fields := strings.Split(s, ",") // breaks def=, but handled below. + if len(fields) < 2 { + fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s) + return + } + + p.Wire = fields[0] + switch p.Wire { + case "varint": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeVarint + p.valDec = (*Buffer).DecodeVarint + p.valSize = sizeVarint + case "fixed32": + p.WireType = WireFixed32 + p.valEnc = (*Buffer).EncodeFixed32 + p.valDec = (*Buffer).DecodeFixed32 + p.valSize = sizeFixed32 + case "fixed64": + p.WireType = WireFixed64 + p.valEnc = (*Buffer).EncodeFixed64 + p.valDec = (*Buffer).DecodeFixed64 + p.valSize = sizeFixed64 + case "zigzag32": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeZigzag32 + p.valDec = (*Buffer).DecodeZigzag32 + p.valSize = sizeZigzag32 + case "zigzag64": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeZigzag64 + p.valDec = (*Buffer).DecodeZigzag64 + p.valSize = sizeZigzag64 + case "bytes", "group": + p.WireType = WireBytes + // no numeric converter for non-numeric types + default: + fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s) + return + } + + var err error + p.Tag, err = strconv.Atoi(fields[1]) + if err != nil { + return + } + + for i := 2; i < len(fields); i++ { + f := fields[i] + switch { + case f == "req": + p.Required = true + case f == "opt": + p.Optional = true + case f == "rep": + p.Repeated = true + case f == "packed": + p.Packed = true + case strings.HasPrefix(f, "name="): + p.OrigName = f[5:] + case strings.HasPrefix(f, "json="): + p.JSONName = f[5:] + case strings.HasPrefix(f, "enum="): + p.Enum = f[5:] + case f == "proto3": + p.proto3 = true + case f == "oneof": + p.oneof = true + case strings.HasPrefix(f, "def="): + p.HasDefault = true + p.Default = f[4:] // rest of string + if i+1 < len(fields) { + // Commas aren't escaped, and def is always last. + p.Default += "," + strings.Join(fields[i+1:], ",") + break + } + } + } +} + +func logNoSliceEnc(t1, t2 reflect.Type) { + fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2) +} + +var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem() + +// Initialize the fields for encoding and decoding. +func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lockGetProp bool) { + p.enc = nil + p.dec = nil + p.size = nil + + switch t1 := typ; t1.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no coders for %v\n", t1) + + // proto3 scalar types + + case reflect.Bool: + p.enc = (*Buffer).enc_proto3_bool + p.dec = (*Buffer).dec_proto3_bool + p.size = size_proto3_bool + case reflect.Int32: + p.enc = (*Buffer).enc_proto3_int32 + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_proto3_int32 + case reflect.Uint32: + p.enc = (*Buffer).enc_proto3_uint32 + p.dec = (*Buffer).dec_proto3_int32 // can reuse + p.size = size_proto3_uint32 + case reflect.Int64, reflect.Uint64: + p.enc = (*Buffer).enc_proto3_int64 + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_proto3_int64 + case reflect.Float32: + p.enc = (*Buffer).enc_proto3_uint32 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_proto3_uint32 + case reflect.Float64: + p.enc = (*Buffer).enc_proto3_int64 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_proto3_int64 + case reflect.String: + p.enc = (*Buffer).enc_proto3_string + p.dec = (*Buffer).dec_proto3_string + p.size = size_proto3_string + + case reflect.Ptr: + switch t2 := t1.Elem(); t2.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no encoder function for %v -> %v\n", t1, t2) + break + case reflect.Bool: + p.enc = (*Buffer).enc_bool + p.dec = (*Buffer).dec_bool + p.size = size_bool + case reflect.Int32: + p.enc = (*Buffer).enc_int32 + p.dec = (*Buffer).dec_int32 + p.size = size_int32 + case reflect.Uint32: + p.enc = (*Buffer).enc_uint32 + p.dec = (*Buffer).dec_int32 // can reuse + p.size = size_uint32 + case reflect.Int64, reflect.Uint64: + p.enc = (*Buffer).enc_int64 + p.dec = (*Buffer).dec_int64 + p.size = size_int64 + case reflect.Float32: + p.enc = (*Buffer).enc_uint32 // can just treat them as bits + p.dec = (*Buffer).dec_int32 + p.size = size_uint32 + case reflect.Float64: + p.enc = (*Buffer).enc_int64 // can just treat them as bits + p.dec = (*Buffer).dec_int64 + p.size = size_int64 + case reflect.String: + p.enc = (*Buffer).enc_string + p.dec = (*Buffer).dec_string + p.size = size_string + case reflect.Struct: + p.stype = t1.Elem() + p.isMarshaler = isMarshaler(t1) + p.isUnmarshaler = isUnmarshaler(t1) + if p.Wire == "bytes" { + p.enc = (*Buffer).enc_struct_message + p.dec = (*Buffer).dec_struct_message + p.size = size_struct_message + } else { + p.enc = (*Buffer).enc_struct_group + p.dec = (*Buffer).dec_struct_group + p.size = size_struct_group + } + } + + case reflect.Slice: + switch t2 := t1.Elem(); t2.Kind() { + default: + logNoSliceEnc(t1, t2) + break + case reflect.Bool: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_bool + p.size = size_slice_packed_bool + } else { + p.enc = (*Buffer).enc_slice_bool + p.size = size_slice_bool + } + p.dec = (*Buffer).dec_slice_bool + p.packedDec = (*Buffer).dec_slice_packed_bool + case reflect.Int32: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int32 + p.size = size_slice_packed_int32 + } else { + p.enc = (*Buffer).enc_slice_int32 + p.size = size_slice_int32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case reflect.Uint32: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_uint32 + p.size = size_slice_packed_uint32 + } else { + p.enc = (*Buffer).enc_slice_uint32 + p.size = size_slice_uint32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case reflect.Int64, reflect.Uint64: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int64 + p.size = size_slice_packed_int64 + } else { + p.enc = (*Buffer).enc_slice_int64 + p.size = size_slice_int64 + } + p.dec = (*Buffer).dec_slice_int64 + p.packedDec = (*Buffer).dec_slice_packed_int64 + case reflect.Uint8: + p.dec = (*Buffer).dec_slice_byte + if p.proto3 { + p.enc = (*Buffer).enc_proto3_slice_byte + p.size = size_proto3_slice_byte + } else { + p.enc = (*Buffer).enc_slice_byte + p.size = size_slice_byte + } + case reflect.Float32, reflect.Float64: + switch t2.Bits() { + case 32: + // can just treat them as bits + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_uint32 + p.size = size_slice_packed_uint32 + } else { + p.enc = (*Buffer).enc_slice_uint32 + p.size = size_slice_uint32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case 64: + // can just treat them as bits + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int64 + p.size = size_slice_packed_int64 + } else { + p.enc = (*Buffer).enc_slice_int64 + p.size = size_slice_int64 + } + p.dec = (*Buffer).dec_slice_int64 + p.packedDec = (*Buffer).dec_slice_packed_int64 + default: + logNoSliceEnc(t1, t2) + break + } + case reflect.String: + p.enc = (*Buffer).enc_slice_string + p.dec = (*Buffer).dec_slice_string + p.size = size_slice_string + case reflect.Ptr: + switch t3 := t2.Elem(); t3.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3) + break + case reflect.Struct: + p.stype = t2.Elem() + p.isMarshaler = isMarshaler(t2) + p.isUnmarshaler = isUnmarshaler(t2) + if p.Wire == "bytes" { + p.enc = (*Buffer).enc_slice_struct_message + p.dec = (*Buffer).dec_slice_struct_message + p.size = size_slice_struct_message + } else { + p.enc = (*Buffer).enc_slice_struct_group + p.dec = (*Buffer).dec_slice_struct_group + p.size = size_slice_struct_group + } + } + case reflect.Slice: + switch t2.Elem().Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem()) + break + case reflect.Uint8: + p.enc = (*Buffer).enc_slice_slice_byte + p.dec = (*Buffer).dec_slice_slice_byte + p.size = size_slice_slice_byte + } + } + + case reflect.Map: + p.enc = (*Buffer).enc_new_map + p.dec = (*Buffer).dec_new_map + p.size = size_new_map + + p.mtype = t1 + p.mkeyprop = &Properties{} + p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp) + p.mvalprop = &Properties{} + vtype := p.mtype.Elem() + if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice { + // The value type is not a message (*T) or bytes ([]byte), + // so we need encoders for the pointer to this type. + vtype = reflect.PtrTo(vtype) + } + p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp) + } + + // precalculate tag code + wire := p.WireType + if p.Packed { + wire = WireBytes + } + x := uint32(p.Tag)<<3 | uint32(wire) + i := 0 + for i = 0; x > 127; i++ { + p.tagbuf[i] = 0x80 | uint8(x&0x7F) + x >>= 7 + } + p.tagbuf[i] = uint8(x) + p.tagcode = p.tagbuf[0 : i+1] + + if p.stype != nil { + if lockGetProp { + p.sprop = GetProperties(p.stype) + } else { + p.sprop = getPropertiesLocked(p.stype) + } + } +} + +var ( + marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem() + unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem() +) + +// isMarshaler reports whether type t implements Marshaler. +func isMarshaler(t reflect.Type) bool { + // We're checking for (likely) pointer-receiver methods + // so if t is not a pointer, something is very wrong. + // The calls above only invoke isMarshaler on pointer types. + if t.Kind() != reflect.Ptr { + panic("proto: misuse of isMarshaler") + } + return t.Implements(marshalerType) +} + +// isUnmarshaler reports whether type t implements Unmarshaler. +func isUnmarshaler(t reflect.Type) bool { + // We're checking for (likely) pointer-receiver methods + // so if t is not a pointer, something is very wrong. + // The calls above only invoke isUnmarshaler on pointer types. + if t.Kind() != reflect.Ptr { + panic("proto: misuse of isUnmarshaler") + } + return t.Implements(unmarshalerType) +} + +// Init populates the properties from a protocol buffer struct tag. +func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) { + p.init(typ, name, tag, f, true) +} + +func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) { + // "bytes,49,opt,def=hello!" + p.Name = name + p.OrigName = name + if f != nil { + p.field = toField(f) + } + if tag == "" { + return + } + p.Parse(tag) + p.setEncAndDec(typ, f, lockGetProp) +} + +var ( + propertiesMu sync.RWMutex + propertiesMap = make(map[reflect.Type]*StructProperties) +) + +// GetProperties returns the list of properties for the type represented by t. +// t must represent a generated struct type of a protocol message. +func GetProperties(t reflect.Type) *StructProperties { + if t.Kind() != reflect.Struct { + panic("proto: type must have kind struct") + } + + // Most calls to GetProperties in a long-running program will be + // retrieving details for types we have seen before. + propertiesMu.RLock() + sprop, ok := propertiesMap[t] + propertiesMu.RUnlock() + if ok { + if collectStats { + stats.Chit++ + } + return sprop + } + + propertiesMu.Lock() + sprop = getPropertiesLocked(t) + propertiesMu.Unlock() + return sprop +} + +// getPropertiesLocked requires that propertiesMu is held. +func getPropertiesLocked(t reflect.Type) *StructProperties { + if prop, ok := propertiesMap[t]; ok { + if collectStats { + stats.Chit++ + } + return prop + } + if collectStats { + stats.Cmiss++ + } + + prop := new(StructProperties) + // in case of recursive protos, fill this in now. + propertiesMap[t] = prop + + // build properties + prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) || + reflect.PtrTo(t).Implements(extendableProtoV1Type) + prop.unrecField = invalidField + prop.Prop = make([]*Properties, t.NumField()) + prop.order = make([]int, t.NumField()) + + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + p := new(Properties) + name := f.Name + p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false) + + if f.Name == "XXX_InternalExtensions" { // special case + p.enc = (*Buffer).enc_exts + p.dec = nil // not needed + p.size = size_exts + } else if f.Name == "XXX_extensions" { // special case + p.enc = (*Buffer).enc_map + p.dec = nil // not needed + p.size = size_map + } else if f.Name == "XXX_unrecognized" { // special case + prop.unrecField = toField(&f) + } + oneof := f.Tag.Get("protobuf_oneof") // special case + if oneof != "" { + // Oneof fields don't use the traditional protobuf tag. + p.OrigName = oneof + } + prop.Prop[i] = p + prop.order[i] = i + if debug { + print(i, " ", f.Name, " ", t.String(), " ") + if p.Tag > 0 { + print(p.String()) + } + print("\n") + } + if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && oneof == "" { + fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]") + } + } + + // Re-order prop.order. + sort.Sort(prop) + + type oneofMessage interface { + XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{}) + } + if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok { + var oots []interface{} + prop.oneofMarshaler, prop.oneofUnmarshaler, prop.oneofSizer, oots = om.XXX_OneofFuncs() + prop.stype = t + + // Interpret oneof metadata. + prop.OneofTypes = make(map[string]*OneofProperties) + for _, oot := range oots { + oop := &OneofProperties{ + Type: reflect.ValueOf(oot).Type(), // *T + Prop: new(Properties), + } + sft := oop.Type.Elem().Field(0) + oop.Prop.Name = sft.Name + oop.Prop.Parse(sft.Tag.Get("protobuf")) + // There will be exactly one interface field that + // this new value is assignable to. + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + if f.Type.Kind() != reflect.Interface { + continue + } + if !oop.Type.AssignableTo(f.Type) { + continue + } + oop.Field = i + break + } + prop.OneofTypes[oop.Prop.OrigName] = oop + } + } + + // build required counts + // build tags + reqCount := 0 + prop.decoderOrigNames = make(map[string]int) + for i, p := range prop.Prop { + if strings.HasPrefix(p.Name, "XXX_") { + // Internal fields should not appear in tags/origNames maps. + // They are handled specially when encoding and decoding. + continue + } + if p.Required { + reqCount++ + } + prop.decoderTags.put(p.Tag, i) + prop.decoderOrigNames[p.OrigName] = i + } + prop.reqCount = reqCount + + return prop +} + +// Return the Properties object for the x[0]'th field of the structure. +func propByIndex(t reflect.Type, x []int) *Properties { + if len(x) != 1 { + fmt.Fprintf(os.Stderr, "proto: field index dimension %d (not 1) for type %s\n", len(x), t) + return nil + } + prop := GetProperties(t) + return prop.Prop[x[0]] +} + +// Get the address and type of a pointer to a struct from an interface. +func getbase(pb Message) (t reflect.Type, b structPointer, err error) { + if pb == nil { + err = ErrNil + return + } + // get the reflect type of the pointer to the struct. + t = reflect.TypeOf(pb) + // get the address of the struct. + value := reflect.ValueOf(pb) + b = toStructPointer(value) + return +} + +// A global registry of enum types. +// The generated code will register the generated maps by calling RegisterEnum. + +var enumValueMaps = make(map[string]map[string]int32) + +// RegisterEnum is called from the generated code to install the enum descriptor +// maps into the global table to aid parsing text format protocol buffers. +func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) { + if _, ok := enumValueMaps[typeName]; ok { + panic("proto: duplicate enum registered: " + typeName) + } + enumValueMaps[typeName] = valueMap +} + +// EnumValueMap returns the mapping from names to integers of the +// enum type enumType, or a nil if not found. +func EnumValueMap(enumType string) map[string]int32 { + return enumValueMaps[enumType] +} + +// A registry of all linked message types. +// The string is a fully-qualified proto name ("pkg.Message"). +var ( + protoTypes = make(map[string]reflect.Type) + revProtoTypes = make(map[reflect.Type]string) +) + +// RegisterType is called from generated code and maps from the fully qualified +// proto name to the type (pointer to struct) of the protocol buffer. +func RegisterType(x Message, name string) { + if _, ok := protoTypes[name]; ok { + // TODO: Some day, make this a panic. + log.Printf("proto: duplicate proto type registered: %s", name) + return + } + t := reflect.TypeOf(x) + protoTypes[name] = t + revProtoTypes[t] = name +} + +// MessageName returns the fully-qualified proto name for the given message type. +func MessageName(x Message) string { return revProtoTypes[reflect.TypeOf(x)] } + +// MessageType returns the message type (pointer to struct) for a named message. +func MessageType(name string) reflect.Type { return protoTypes[name] } + +// A registry of all linked proto files. +var ( + protoFiles = make(map[string][]byte) // file name => fileDescriptor +) + +// RegisterFile is called from generated code and maps from the +// full file name of a .proto file to its compressed FileDescriptorProto. +func RegisterFile(filename string, fileDescriptor []byte) { + protoFiles[filename] = fileDescriptor +} + +// FileDescriptor returns the compressed FileDescriptorProto for a .proto file. +func FileDescriptor(filename string) []byte { return protoFiles[filename] } diff --git a/vendor/github.com/golang/protobuf/proto/text.go b/vendor/github.com/golang/protobuf/proto/text.go new file mode 100644 index 00000000..965876bf --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/text.go @@ -0,0 +1,854 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +// Functions for writing the text protocol buffer format. + +import ( + "bufio" + "bytes" + "encoding" + "errors" + "fmt" + "io" + "log" + "math" + "reflect" + "sort" + "strings" +) + +var ( + newline = []byte("\n") + spaces = []byte(" ") + gtNewline = []byte(">\n") + endBraceNewline = []byte("}\n") + backslashN = []byte{'\\', 'n'} + backslashR = []byte{'\\', 'r'} + backslashT = []byte{'\\', 't'} + backslashDQ = []byte{'\\', '"'} + backslashBS = []byte{'\\', '\\'} + posInf = []byte("inf") + negInf = []byte("-inf") + nan = []byte("nan") +) + +type writer interface { + io.Writer + WriteByte(byte) error +} + +// textWriter is an io.Writer that tracks its indentation level. +type textWriter struct { + ind int + complete bool // if the current position is a complete line + compact bool // whether to write out as a one-liner + w writer +} + +func (w *textWriter) WriteString(s string) (n int, err error) { + if !strings.Contains(s, "\n") { + if !w.compact && w.complete { + w.writeIndent() + } + w.complete = false + return io.WriteString(w.w, s) + } + // WriteString is typically called without newlines, so this + // codepath and its copy are rare. We copy to avoid + // duplicating all of Write's logic here. + return w.Write([]byte(s)) +} + +func (w *textWriter) Write(p []byte) (n int, err error) { + newlines := bytes.Count(p, newline) + if newlines == 0 { + if !w.compact && w.complete { + w.writeIndent() + } + n, err = w.w.Write(p) + w.complete = false + return n, err + } + + frags := bytes.SplitN(p, newline, newlines+1) + if w.compact { + for i, frag := range frags { + if i > 0 { + if err := w.w.WriteByte(' '); err != nil { + return n, err + } + n++ + } + nn, err := w.w.Write(frag) + n += nn + if err != nil { + return n, err + } + } + return n, nil + } + + for i, frag := range frags { + if w.complete { + w.writeIndent() + } + nn, err := w.w.Write(frag) + n += nn + if err != nil { + return n, err + } + if i+1 < len(frags) { + if err := w.w.WriteByte('\n'); err != nil { + return n, err + } + n++ + } + } + w.complete = len(frags[len(frags)-1]) == 0 + return n, nil +} + +func (w *textWriter) WriteByte(c byte) error { + if w.compact && c == '\n' { + c = ' ' + } + if !w.compact && w.complete { + w.writeIndent() + } + err := w.w.WriteByte(c) + w.complete = c == '\n' + return err +} + +func (w *textWriter) indent() { w.ind++ } + +func (w *textWriter) unindent() { + if w.ind == 0 { + log.Print("proto: textWriter unindented too far") + return + } + w.ind-- +} + +func writeName(w *textWriter, props *Properties) error { + if _, err := w.WriteString(props.OrigName); err != nil { + return err + } + if props.Wire != "group" { + return w.WriteByte(':') + } + return nil +} + +// raw is the interface satisfied by RawMessage. +type raw interface { + Bytes() []byte +} + +func requiresQuotes(u string) bool { + // When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted. + for _, ch := range u { + switch { + case ch == '.' || ch == '/' || ch == '_': + continue + case '0' <= ch && ch <= '9': + continue + case 'A' <= ch && ch <= 'Z': + continue + case 'a' <= ch && ch <= 'z': + continue + default: + return true + } + } + return false +} + +// isAny reports whether sv is a google.protobuf.Any message +func isAny(sv reflect.Value) bool { + type wkt interface { + XXX_WellKnownType() string + } + t, ok := sv.Addr().Interface().(wkt) + return ok && t.XXX_WellKnownType() == "Any" +} + +// writeProto3Any writes an expanded google.protobuf.Any message. +// +// It returns (false, nil) if sv value can't be unmarshaled (e.g. because +// required messages are not linked in). +// +// It returns (true, error) when sv was written in expanded format or an error +// was encountered. +func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) { + turl := sv.FieldByName("TypeUrl") + val := sv.FieldByName("Value") + if !turl.IsValid() || !val.IsValid() { + return true, errors.New("proto: invalid google.protobuf.Any message") + } + + b, ok := val.Interface().([]byte) + if !ok { + return true, errors.New("proto: invalid google.protobuf.Any message") + } + + parts := strings.Split(turl.String(), "/") + mt := MessageType(parts[len(parts)-1]) + if mt == nil { + return false, nil + } + m := reflect.New(mt.Elem()) + if err := Unmarshal(b, m.Interface().(Message)); err != nil { + return false, nil + } + w.Write([]byte("[")) + u := turl.String() + if requiresQuotes(u) { + writeString(w, u) + } else { + w.Write([]byte(u)) + } + if w.compact { + w.Write([]byte("]:<")) + } else { + w.Write([]byte("]: <\n")) + w.ind++ + } + if err := tm.writeStruct(w, m.Elem()); err != nil { + return true, err + } + if w.compact { + w.Write([]byte("> ")) + } else { + w.ind-- + w.Write([]byte(">\n")) + } + return true, nil +} + +func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error { + if tm.ExpandAny && isAny(sv) { + if canExpand, err := tm.writeProto3Any(w, sv); canExpand { + return err + } + } + st := sv.Type() + sprops := GetProperties(st) + for i := 0; i < sv.NumField(); i++ { + fv := sv.Field(i) + props := sprops.Prop[i] + name := st.Field(i).Name + + if strings.HasPrefix(name, "XXX_") { + // There are two XXX_ fields: + // XXX_unrecognized []byte + // XXX_extensions map[int32]proto.Extension + // The first is handled here; + // the second is handled at the bottom of this function. + if name == "XXX_unrecognized" && !fv.IsNil() { + if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil { + return err + } + } + continue + } + if fv.Kind() == reflect.Ptr && fv.IsNil() { + // Field not filled in. This could be an optional field or + // a required field that wasn't filled in. Either way, there + // isn't anything we can show for it. + continue + } + if fv.Kind() == reflect.Slice && fv.IsNil() { + // Repeated field that is empty, or a bytes field that is unused. + continue + } + + if props.Repeated && fv.Kind() == reflect.Slice { + // Repeated field. + for j := 0; j < fv.Len(); j++ { + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + v := fv.Index(j) + if v.Kind() == reflect.Ptr && v.IsNil() { + // A nil message in a repeated field is not valid, + // but we can handle that more gracefully than panicking. + if _, err := w.Write([]byte("\n")); err != nil { + return err + } + continue + } + if err := tm.writeAny(w, v, props); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + continue + } + if fv.Kind() == reflect.Map { + // Map fields are rendered as a repeated struct with key/value fields. + keys := fv.MapKeys() + sort.Sort(mapKeys(keys)) + for _, key := range keys { + val := fv.MapIndex(key) + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + // open struct + if err := w.WriteByte('<'); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + // key + if _, err := w.WriteString("key:"); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := tm.writeAny(w, key, props.mkeyprop); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + // nil values aren't legal, but we can avoid panicking because of them. + if val.Kind() != reflect.Ptr || !val.IsNil() { + // value + if _, err := w.WriteString("value:"); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := tm.writeAny(w, val, props.mvalprop); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + // close struct + w.unindent() + if err := w.WriteByte('>'); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + continue + } + if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 { + // empty bytes field + continue + } + if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice { + // proto3 non-repeated scalar field; skip if zero value + if isProto3Zero(fv) { + continue + } + } + + if fv.Kind() == reflect.Interface { + // Check if it is a oneof. + if st.Field(i).Tag.Get("protobuf_oneof") != "" { + // fv is nil, or holds a pointer to generated struct. + // That generated struct has exactly one field, + // which has a protobuf struct tag. + if fv.IsNil() { + continue + } + inner := fv.Elem().Elem() // interface -> *T -> T + tag := inner.Type().Field(0).Tag.Get("protobuf") + props = new(Properties) // Overwrite the outer props var, but not its pointee. + props.Parse(tag) + // Write the value in the oneof, not the oneof itself. + fv = inner.Field(0) + + // Special case to cope with malformed messages gracefully: + // If the value in the oneof is a nil pointer, don't panic + // in writeAny. + if fv.Kind() == reflect.Ptr && fv.IsNil() { + // Use errors.New so writeAny won't render quotes. + msg := errors.New("/* nil */") + fv = reflect.ValueOf(&msg).Elem() + } + } + } + + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if b, ok := fv.Interface().(raw); ok { + if err := writeRaw(w, b.Bytes()); err != nil { + return err + } + continue + } + + // Enums have a String method, so writeAny will work fine. + if err := tm.writeAny(w, fv, props); err != nil { + return err + } + + if err := w.WriteByte('\n'); err != nil { + return err + } + } + + // Extensions (the XXX_extensions field). + pv := sv.Addr() + if _, ok := extendable(pv.Interface()); ok { + if err := tm.writeExtensions(w, pv); err != nil { + return err + } + } + + return nil +} + +// writeRaw writes an uninterpreted raw message. +func writeRaw(w *textWriter, b []byte) error { + if err := w.WriteByte('<'); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + if err := writeUnknownStruct(w, b); err != nil { + return err + } + w.unindent() + if err := w.WriteByte('>'); err != nil { + return err + } + return nil +} + +// writeAny writes an arbitrary field. +func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error { + v = reflect.Indirect(v) + + // Floats have special cases. + if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 { + x := v.Float() + var b []byte + switch { + case math.IsInf(x, 1): + b = posInf + case math.IsInf(x, -1): + b = negInf + case math.IsNaN(x): + b = nan + } + if b != nil { + _, err := w.Write(b) + return err + } + // Other values are handled below. + } + + // We don't attempt to serialise every possible value type; only those + // that can occur in protocol buffers. + switch v.Kind() { + case reflect.Slice: + // Should only be a []byte; repeated fields are handled in writeStruct. + if err := writeString(w, string(v.Bytes())); err != nil { + return err + } + case reflect.String: + if err := writeString(w, v.String()); err != nil { + return err + } + case reflect.Struct: + // Required/optional group/message. + var bra, ket byte = '<', '>' + if props != nil && props.Wire == "group" { + bra, ket = '{', '}' + } + if err := w.WriteByte(bra); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + if etm, ok := v.Interface().(encoding.TextMarshaler); ok { + text, err := etm.MarshalText() + if err != nil { + return err + } + if _, err = w.Write(text); err != nil { + return err + } + } else if err := tm.writeStruct(w, v); err != nil { + return err + } + w.unindent() + if err := w.WriteByte(ket); err != nil { + return err + } + default: + _, err := fmt.Fprint(w, v.Interface()) + return err + } + return nil +} + +// equivalent to C's isprint. +func isprint(c byte) bool { + return c >= 0x20 && c < 0x7f +} + +// writeString writes a string in the protocol buffer text format. +// It is similar to strconv.Quote except we don't use Go escape sequences, +// we treat the string as a byte sequence, and we use octal escapes. +// These differences are to maintain interoperability with the other +// languages' implementations of the text format. +func writeString(w *textWriter, s string) error { + // use WriteByte here to get any needed indent + if err := w.WriteByte('"'); err != nil { + return err + } + // Loop over the bytes, not the runes. + for i := 0; i < len(s); i++ { + var err error + // Divergence from C++: we don't escape apostrophes. + // There's no need to escape them, and the C++ parser + // copes with a naked apostrophe. + switch c := s[i]; c { + case '\n': + _, err = w.w.Write(backslashN) + case '\r': + _, err = w.w.Write(backslashR) + case '\t': + _, err = w.w.Write(backslashT) + case '"': + _, err = w.w.Write(backslashDQ) + case '\\': + _, err = w.w.Write(backslashBS) + default: + if isprint(c) { + err = w.w.WriteByte(c) + } else { + _, err = fmt.Fprintf(w.w, "\\%03o", c) + } + } + if err != nil { + return err + } + } + return w.WriteByte('"') +} + +func writeUnknownStruct(w *textWriter, data []byte) (err error) { + if !w.compact { + if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil { + return err + } + } + b := NewBuffer(data) + for b.index < len(b.buf) { + x, err := b.DecodeVarint() + if err != nil { + _, err := fmt.Fprintf(w, "/* %v */\n", err) + return err + } + wire, tag := x&7, x>>3 + if wire == WireEndGroup { + w.unindent() + if _, err := w.Write(endBraceNewline); err != nil { + return err + } + continue + } + if _, err := fmt.Fprint(w, tag); err != nil { + return err + } + if wire != WireStartGroup { + if err := w.WriteByte(':'); err != nil { + return err + } + } + if !w.compact || wire == WireStartGroup { + if err := w.WriteByte(' '); err != nil { + return err + } + } + switch wire { + case WireBytes: + buf, e := b.DecodeRawBytes(false) + if e == nil { + _, err = fmt.Fprintf(w, "%q", buf) + } else { + _, err = fmt.Fprintf(w, "/* %v */", e) + } + case WireFixed32: + x, err = b.DecodeFixed32() + err = writeUnknownInt(w, x, err) + case WireFixed64: + x, err = b.DecodeFixed64() + err = writeUnknownInt(w, x, err) + case WireStartGroup: + err = w.WriteByte('{') + w.indent() + case WireVarint: + x, err = b.DecodeVarint() + err = writeUnknownInt(w, x, err) + default: + _, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire) + } + if err != nil { + return err + } + if err = w.WriteByte('\n'); err != nil { + return err + } + } + return nil +} + +func writeUnknownInt(w *textWriter, x uint64, err error) error { + if err == nil { + _, err = fmt.Fprint(w, x) + } else { + _, err = fmt.Fprintf(w, "/* %v */", err) + } + return err +} + +type int32Slice []int32 + +func (s int32Slice) Len() int { return len(s) } +func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] } +func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + +// writeExtensions writes all the extensions in pv. +// pv is assumed to be a pointer to a protocol message struct that is extendable. +func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error { + emap := extensionMaps[pv.Type().Elem()] + ep, _ := extendable(pv.Interface()) + + // Order the extensions by ID. + // This isn't strictly necessary, but it will give us + // canonical output, which will also make testing easier. + m, mu := ep.extensionsRead() + if m == nil { + return nil + } + mu.Lock() + ids := make([]int32, 0, len(m)) + for id := range m { + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) + mu.Unlock() + + for _, extNum := range ids { + ext := m[extNum] + var desc *ExtensionDesc + if emap != nil { + desc = emap[extNum] + } + if desc == nil { + // Unknown extension. + if err := writeUnknownStruct(w, ext.enc); err != nil { + return err + } + continue + } + + pb, err := GetExtension(ep, desc) + if err != nil { + return fmt.Errorf("failed getting extension: %v", err) + } + + // Repeated extensions will appear as a slice. + if !desc.repeated() { + if err := tm.writeExtension(w, desc.Name, pb); err != nil { + return err + } + } else { + v := reflect.ValueOf(pb) + for i := 0; i < v.Len(); i++ { + if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil { + return err + } + } + } + } + return nil +} + +func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error { + if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + return nil +} + +func (w *textWriter) writeIndent() { + if !w.complete { + return + } + remain := w.ind * 2 + for remain > 0 { + n := remain + if n > len(spaces) { + n = len(spaces) + } + w.w.Write(spaces[:n]) + remain -= n + } + w.complete = false +} + +// TextMarshaler is a configurable text format marshaler. +type TextMarshaler struct { + Compact bool // use compact text format (one line). + ExpandAny bool // expand google.protobuf.Any messages of known types +} + +// Marshal writes a given protocol buffer in text format. +// The only errors returned are from w. +func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error { + val := reflect.ValueOf(pb) + if pb == nil || val.IsNil() { + w.Write([]byte("")) + return nil + } + var bw *bufio.Writer + ww, ok := w.(writer) + if !ok { + bw = bufio.NewWriter(w) + ww = bw + } + aw := &textWriter{ + w: ww, + complete: true, + compact: tm.Compact, + } + + if etm, ok := pb.(encoding.TextMarshaler); ok { + text, err := etm.MarshalText() + if err != nil { + return err + } + if _, err = aw.Write(text); err != nil { + return err + } + if bw != nil { + return bw.Flush() + } + return nil + } + // Dereference the received pointer so we don't have outer < and >. + v := reflect.Indirect(val) + if err := tm.writeStruct(aw, v); err != nil { + return err + } + if bw != nil { + return bw.Flush() + } + return nil +} + +// Text is the same as Marshal, but returns the string directly. +func (tm *TextMarshaler) Text(pb Message) string { + var buf bytes.Buffer + tm.Marshal(&buf, pb) + return buf.String() +} + +var ( + defaultTextMarshaler = TextMarshaler{} + compactTextMarshaler = TextMarshaler{Compact: true} +) + +// TODO: consider removing some of the Marshal functions below. + +// MarshalText writes a given protocol buffer in text format. +// The only errors returned are from w. +func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) } + +// MarshalTextString is the same as MarshalText, but returns the string directly. +func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) } + +// CompactText writes a given protocol buffer in compact text format (one line). +func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) } + +// CompactTextString is the same as CompactText, but returns the string directly. +func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) } diff --git a/vendor/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/golang/protobuf/proto/text_parser.go new file mode 100644 index 00000000..7e6f145a --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/text_parser.go @@ -0,0 +1,891 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +// Functions for parsing the Text protocol buffer format. +// TODO: message sets. + +import ( + "encoding" + "errors" + "fmt" + "reflect" + "strconv" + "strings" + "unicode/utf8" +) + +// Error string emitted when deserializing Any and fields are already set +const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set" + +type ParseError struct { + Message string + Line int // 1-based line number + Offset int // 0-based byte offset from start of input +} + +func (p *ParseError) Error() string { + if p.Line == 1 { + // show offset only for first line + return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message) + } + return fmt.Sprintf("line %d: %v", p.Line, p.Message) +} + +type token struct { + value string + err *ParseError + line int // line number + offset int // byte number from start of input, not start of line + unquoted string // the unquoted version of value, if it was a quoted string +} + +func (t *token) String() string { + if t.err == nil { + return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset) + } + return fmt.Sprintf("parse error: %v", t.err) +} + +type textParser struct { + s string // remaining input + done bool // whether the parsing is finished (success or error) + backed bool // whether back() was called + offset, line int + cur token +} + +func newTextParser(s string) *textParser { + p := new(textParser) + p.s = s + p.line = 1 + p.cur.line = 1 + return p +} + +func (p *textParser) errorf(format string, a ...interface{}) *ParseError { + pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset} + p.cur.err = pe + p.done = true + return pe +} + +// Numbers and identifiers are matched by [-+._A-Za-z0-9] +func isIdentOrNumberChar(c byte) bool { + switch { + case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z': + return true + case '0' <= c && c <= '9': + return true + } + switch c { + case '-', '+', '.', '_': + return true + } + return false +} + +func isWhitespace(c byte) bool { + switch c { + case ' ', '\t', '\n', '\r': + return true + } + return false +} + +func isQuote(c byte) bool { + switch c { + case '"', '\'': + return true + } + return false +} + +func (p *textParser) skipWhitespace() { + i := 0 + for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') { + if p.s[i] == '#' { + // comment; skip to end of line or input + for i < len(p.s) && p.s[i] != '\n' { + i++ + } + if i == len(p.s) { + break + } + } + if p.s[i] == '\n' { + p.line++ + } + i++ + } + p.offset += i + p.s = p.s[i:len(p.s)] + if len(p.s) == 0 { + p.done = true + } +} + +func (p *textParser) advance() { + // Skip whitespace + p.skipWhitespace() + if p.done { + return + } + + // Start of non-whitespace + p.cur.err = nil + p.cur.offset, p.cur.line = p.offset, p.line + p.cur.unquoted = "" + switch p.s[0] { + case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/': + // Single symbol + p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)] + case '"', '\'': + // Quoted string + i := 1 + for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' { + if p.s[i] == '\\' && i+1 < len(p.s) { + // skip escaped char + i++ + } + i++ + } + if i >= len(p.s) || p.s[i] != p.s[0] { + p.errorf("unmatched quote") + return + } + unq, err := unquoteC(p.s[1:i], rune(p.s[0])) + if err != nil { + p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err) + return + } + p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)] + p.cur.unquoted = unq + default: + i := 0 + for i < len(p.s) && isIdentOrNumberChar(p.s[i]) { + i++ + } + if i == 0 { + p.errorf("unexpected byte %#x", p.s[0]) + return + } + p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)] + } + p.offset += len(p.cur.value) +} + +var ( + errBadUTF8 = errors.New("proto: bad UTF-8") + errBadHex = errors.New("proto: bad hexadecimal") +) + +func unquoteC(s string, quote rune) (string, error) { + // This is based on C++'s tokenizer.cc. + // Despite its name, this is *not* parsing C syntax. + // For instance, "\0" is an invalid quoted string. + + // Avoid allocation in trivial cases. + simple := true + for _, r := range s { + if r == '\\' || r == quote { + simple = false + break + } + } + if simple { + return s, nil + } + + buf := make([]byte, 0, 3*len(s)/2) + for len(s) > 0 { + r, n := utf8.DecodeRuneInString(s) + if r == utf8.RuneError && n == 1 { + return "", errBadUTF8 + } + s = s[n:] + if r != '\\' { + if r < utf8.RuneSelf { + buf = append(buf, byte(r)) + } else { + buf = append(buf, string(r)...) + } + continue + } + + ch, tail, err := unescape(s) + if err != nil { + return "", err + } + buf = append(buf, ch...) + s = tail + } + return string(buf), nil +} + +func unescape(s string) (ch string, tail string, err error) { + r, n := utf8.DecodeRuneInString(s) + if r == utf8.RuneError && n == 1 { + return "", "", errBadUTF8 + } + s = s[n:] + switch r { + case 'a': + return "\a", s, nil + case 'b': + return "\b", s, nil + case 'f': + return "\f", s, nil + case 'n': + return "\n", s, nil + case 'r': + return "\r", s, nil + case 't': + return "\t", s, nil + case 'v': + return "\v", s, nil + case '?': + return "?", s, nil // trigraph workaround + case '\'', '"', '\\': + return string(r), s, nil + case '0', '1', '2', '3', '4', '5', '6', '7', 'x', 'X': + if len(s) < 2 { + return "", "", fmt.Errorf(`\%c requires 2 following digits`, r) + } + base := 8 + ss := s[:2] + s = s[2:] + if r == 'x' || r == 'X' { + base = 16 + } else { + ss = string(r) + ss + } + i, err := strconv.ParseUint(ss, base, 8) + if err != nil { + return "", "", err + } + return string([]byte{byte(i)}), s, nil + case 'u', 'U': + n := 4 + if r == 'U' { + n = 8 + } + if len(s) < n { + return "", "", fmt.Errorf(`\%c requires %d digits`, r, n) + } + + bs := make([]byte, n/2) + for i := 0; i < n; i += 2 { + a, ok1 := unhex(s[i]) + b, ok2 := unhex(s[i+1]) + if !ok1 || !ok2 { + return "", "", errBadHex + } + bs[i/2] = a<<4 | b + } + s = s[n:] + return string(bs), s, nil + } + return "", "", fmt.Errorf(`unknown escape \%c`, r) +} + +// Adapted from src/pkg/strconv/quote.go. +func unhex(b byte) (v byte, ok bool) { + switch { + case '0' <= b && b <= '9': + return b - '0', true + case 'a' <= b && b <= 'f': + return b - 'a' + 10, true + case 'A' <= b && b <= 'F': + return b - 'A' + 10, true + } + return 0, false +} + +// Back off the parser by one token. Can only be done between calls to next(). +// It makes the next advance() a no-op. +func (p *textParser) back() { p.backed = true } + +// Advances the parser and returns the new current token. +func (p *textParser) next() *token { + if p.backed || p.done { + p.backed = false + return &p.cur + } + p.advance() + if p.done { + p.cur.value = "" + } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) { + // Look for multiple quoted strings separated by whitespace, + // and concatenate them. + cat := p.cur + for { + p.skipWhitespace() + if p.done || !isQuote(p.s[0]) { + break + } + p.advance() + if p.cur.err != nil { + return &p.cur + } + cat.value += " " + p.cur.value + cat.unquoted += p.cur.unquoted + } + p.done = false // parser may have seen EOF, but we want to return cat + p.cur = cat + } + return &p.cur +} + +func (p *textParser) consumeToken(s string) error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != s { + p.back() + return p.errorf("expected %q, found %q", s, tok.value) + } + return nil +} + +// Return a RequiredNotSetError indicating which required field was not set. +func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError { + st := sv.Type() + sprops := GetProperties(st) + for i := 0; i < st.NumField(); i++ { + if !isNil(sv.Field(i)) { + continue + } + + props := sprops.Prop[i] + if props.Required { + return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)} + } + } + return &RequiredNotSetError{fmt.Sprintf("%v.", st)} // should not happen +} + +// Returns the index in the struct for the named field, as well as the parsed tag properties. +func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) { + i, ok := sprops.decoderOrigNames[name] + if ok { + return i, sprops.Prop[i], true + } + return -1, nil, false +} + +// Consume a ':' from the input stream (if the next token is a colon), +// returning an error if a colon is needed but not present. +func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != ":" { + // Colon is optional when the field is a group or message. + needColon := true + switch props.Wire { + case "group": + needColon = false + case "bytes": + // A "bytes" field is either a message, a string, or a repeated field; + // those three become *T, *string and []T respectively, so we can check for + // this field being a pointer to a non-string. + if typ.Kind() == reflect.Ptr { + // *T or *string + if typ.Elem().Kind() == reflect.String { + break + } + } else if typ.Kind() == reflect.Slice { + // []T or []*T + if typ.Elem().Kind() != reflect.Ptr { + break + } + } else if typ.Kind() == reflect.String { + // The proto3 exception is for a string field, + // which requires a colon. + break + } + needColon = false + } + if needColon { + return p.errorf("expected ':', found %q", tok.value) + } + p.back() + } + return nil +} + +func (p *textParser) readStruct(sv reflect.Value, terminator string) error { + st := sv.Type() + sprops := GetProperties(st) + reqCount := sprops.reqCount + var reqFieldErr error + fieldSet := make(map[string]bool) + // A struct is a sequence of "name: value", terminated by one of + // '>' or '}', or the end of the input. A name may also be + // "[extension]" or "[type/url]". + // + // The whole struct can also be an expanded Any message, like: + // [type/url] < ... struct contents ... > + for { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == terminator { + break + } + if tok.value == "[" { + // Looks like an extension or an Any. + // + // TODO: Check whether we need to handle + // namespace rooted names (e.g. ".something.Foo"). + extName, err := p.consumeExtName() + if err != nil { + return err + } + + if s := strings.LastIndex(extName, "/"); s >= 0 { + // If it contains a slash, it's an Any type URL. + messageName := extName[s+1:] + mt := MessageType(messageName) + if mt == nil { + return p.errorf("unrecognized message %q in google.protobuf.Any", messageName) + } + tok = p.next() + if tok.err != nil { + return tok.err + } + // consume an optional colon + if tok.value == ":" { + tok = p.next() + if tok.err != nil { + return tok.err + } + } + var terminator string + switch tok.value { + case "<": + terminator = ">" + case "{": + terminator = "}" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + v := reflect.New(mt.Elem()) + if pe := p.readStruct(v.Elem(), terminator); pe != nil { + return pe + } + b, err := Marshal(v.Interface().(Message)) + if err != nil { + return p.errorf("failed to marshal message of type %q: %v", messageName, err) + } + if fieldSet["type_url"] { + return p.errorf(anyRepeatedlyUnpacked, "type_url") + } + if fieldSet["value"] { + return p.errorf(anyRepeatedlyUnpacked, "value") + } + sv.FieldByName("TypeUrl").SetString(extName) + sv.FieldByName("Value").SetBytes(b) + fieldSet["type_url"] = true + fieldSet["value"] = true + continue + } + + var desc *ExtensionDesc + // This could be faster, but it's functional. + // TODO: Do something smarter than a linear scan. + for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) { + if d.Name == extName { + desc = d + break + } + } + if desc == nil { + return p.errorf("unrecognized extension %q", extName) + } + + props := &Properties{} + props.Parse(desc.Tag) + + typ := reflect.TypeOf(desc.ExtensionType) + if err := p.checkForColon(props, typ); err != nil { + return err + } + + rep := desc.repeated() + + // Read the extension structure, and set it in + // the value we're constructing. + var ext reflect.Value + if !rep { + ext = reflect.New(typ).Elem() + } else { + ext = reflect.New(typ.Elem()).Elem() + } + if err := p.readAny(ext, props); err != nil { + if _, ok := err.(*RequiredNotSetError); !ok { + return err + } + reqFieldErr = err + } + ep := sv.Addr().Interface().(Message) + if !rep { + SetExtension(ep, desc, ext.Interface()) + } else { + old, err := GetExtension(ep, desc) + var sl reflect.Value + if err == nil { + sl = reflect.ValueOf(old) // existing slice + } else { + sl = reflect.MakeSlice(typ, 0, 1) + } + sl = reflect.Append(sl, ext) + SetExtension(ep, desc, sl.Interface()) + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + continue + } + + // This is a normal, non-extension field. + name := tok.value + var dst reflect.Value + fi, props, ok := structFieldByName(sprops, name) + if ok { + dst = sv.Field(fi) + } else if oop, ok := sprops.OneofTypes[name]; ok { + // It is a oneof. + props = oop.Prop + nv := reflect.New(oop.Type.Elem()) + dst = nv.Elem().Field(0) + sv.Field(oop.Field).Set(nv) + } + if !dst.IsValid() { + return p.errorf("unknown field name %q in %v", name, st) + } + + if dst.Kind() == reflect.Map { + // Consume any colon. + if err := p.checkForColon(props, dst.Type()); err != nil { + return err + } + + // Construct the map if it doesn't already exist. + if dst.IsNil() { + dst.Set(reflect.MakeMap(dst.Type())) + } + key := reflect.New(dst.Type().Key()).Elem() + val := reflect.New(dst.Type().Elem()).Elem() + + // The map entry should be this sequence of tokens: + // < key : KEY value : VALUE > + // However, implementations may omit key or value, and technically + // we should support them in any order. See b/28924776 for a time + // this went wrong. + + tok := p.next() + var terminator string + switch tok.value { + case "<": + terminator = ">" + case "{": + terminator = "}" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + for { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == terminator { + break + } + switch tok.value { + case "key": + if err := p.consumeToken(":"); err != nil { + return err + } + if err := p.readAny(key, props.mkeyprop); err != nil { + return err + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + case "value": + if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil { + return err + } + if err := p.readAny(val, props.mvalprop); err != nil { + return err + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + default: + p.back() + return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value) + } + } + + dst.SetMapIndex(key, val) + continue + } + + // Check that it's not already set if it's not a repeated field. + if !props.Repeated && fieldSet[name] { + return p.errorf("non-repeated field %q was repeated", name) + } + + if err := p.checkForColon(props, dst.Type()); err != nil { + return err + } + + // Parse into the field. + fieldSet[name] = true + if err := p.readAny(dst, props); err != nil { + if _, ok := err.(*RequiredNotSetError); !ok { + return err + } + reqFieldErr = err + } + if props.Required { + reqCount-- + } + + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + + } + + if reqCount > 0 { + return p.missingRequiredFieldError(sv) + } + return reqFieldErr +} + +// consumeExtName consumes extension name or expanded Any type URL and the +// following ']'. It returns the name or URL consumed. +func (p *textParser) consumeExtName() (string, error) { + tok := p.next() + if tok.err != nil { + return "", tok.err + } + + // If extension name or type url is quoted, it's a single token. + if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] { + name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0])) + if err != nil { + return "", err + } + return name, p.consumeToken("]") + } + + // Consume everything up to "]" + var parts []string + for tok.value != "]" { + parts = append(parts, tok.value) + tok = p.next() + if tok.err != nil { + return "", p.errorf("unrecognized type_url or extension name: %s", tok.err) + } + } + return strings.Join(parts, ""), nil +} + +// consumeOptionalSeparator consumes an optional semicolon or comma. +// It is used in readStruct to provide backward compatibility. +func (p *textParser) consumeOptionalSeparator() error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != ";" && tok.value != "," { + p.back() + } + return nil +} + +func (p *textParser) readAny(v reflect.Value, props *Properties) error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == "" { + return p.errorf("unexpected EOF") + } + + switch fv := v; fv.Kind() { + case reflect.Slice: + at := v.Type() + if at.Elem().Kind() == reflect.Uint8 { + // Special case for []byte + if tok.value[0] != '"' && tok.value[0] != '\'' { + // Deliberately written out here, as the error after + // this switch statement would write "invalid []byte: ...", + // which is not as user-friendly. + return p.errorf("invalid string: %v", tok.value) + } + bytes := []byte(tok.unquoted) + fv.Set(reflect.ValueOf(bytes)) + return nil + } + // Repeated field. + if tok.value == "[" { + // Repeated field with list notation, like [1,2,3]. + for { + fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem())) + err := p.readAny(fv.Index(fv.Len()-1), props) + if err != nil { + return err + } + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == "]" { + break + } + if tok.value != "," { + return p.errorf("Expected ']' or ',' found %q", tok.value) + } + } + return nil + } + // One value of the repeated field. + p.back() + fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem())) + return p.readAny(fv.Index(fv.Len()-1), props) + case reflect.Bool: + // Either "true", "false", 1 or 0. + switch tok.value { + case "true", "1": + fv.SetBool(true) + return nil + case "false", "0": + fv.SetBool(false) + return nil + } + case reflect.Float32, reflect.Float64: + v := tok.value + // Ignore 'f' for compatibility with output generated by C++, but don't + // remove 'f' when the value is "-inf" or "inf". + if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" { + v = v[:len(v)-1] + } + if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil { + fv.SetFloat(f) + return nil + } + case reflect.Int32: + if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { + fv.SetInt(x) + return nil + } + + if len(props.Enum) == 0 { + break + } + m, ok := enumValueMaps[props.Enum] + if !ok { + break + } + x, ok := m[tok.value] + if !ok { + break + } + fv.SetInt(int64(x)) + return nil + case reflect.Int64: + if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil { + fv.SetInt(x) + return nil + } + + case reflect.Ptr: + // A basic field (indirected through pointer), or a repeated message/group + p.back() + fv.Set(reflect.New(fv.Type().Elem())) + return p.readAny(fv.Elem(), props) + case reflect.String: + if tok.value[0] == '"' || tok.value[0] == '\'' { + fv.SetString(tok.unquoted) + return nil + } + case reflect.Struct: + var terminator string + switch tok.value { + case "{": + terminator = "}" + case "<": + terminator = ">" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + // TODO: Handle nested messages which implement encoding.TextUnmarshaler. + return p.readStruct(fv, terminator) + case reflect.Uint32: + if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { + fv.SetUint(uint64(x)) + return nil + } + case reflect.Uint64: + if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { + fv.SetUint(x) + return nil + } + } + return p.errorf("invalid %v: %v", v.Type(), tok.value) +} + +// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb +// before starting to unmarshal, so any existing data in pb is always removed. +// If a required field is not set and no other error occurs, +// UnmarshalText returns *RequiredNotSetError. +func UnmarshalText(s string, pb Message) error { + if um, ok := pb.(encoding.TextUnmarshaler); ok { + err := um.UnmarshalText([]byte(s)) + return err + } + pb.Reset() + v := reflect.ValueOf(pb) + if pe := newTextParser(s).readStruct(v.Elem(), ""); pe != nil { + return pe + } + return nil +} diff --git a/vendor/github.com/gonum/floats/floats.go b/vendor/github.com/gonum/floats/floats.go new file mode 100644 index 00000000..0ec94847 --- /dev/null +++ b/vendor/github.com/gonum/floats/floats.go @@ -0,0 +1,776 @@ +// Copyright 2013 The Gonum Authors. All rights reserved. +// Use of this code is governed by a BSD-style +// license that can be found in the LICENSE file + +// Package floats provides a set of helper routines for dealing with slices +// of float64. The functions avoid allocations to allow for use within tight +// loops without garbage collection overhead. +// +// The convention used is that when a slice is being modified in place, it has +// the name dst. +package floats + +import ( + "errors" + "math" + "sort" + + "github.com/gonum/internal/asm" +) + +// Add adds, element-wise, the elements of s and dst, and stores in dst. +// Panics if the lengths of dst and s do not match. +func Add(dst, s []float64) { + if len(dst) != len(s) { + panic("floats: length of the slices do not match") + } + asm.DaxpyUnitaryTo(dst, 1, s, dst) +} + +// AddTo adds, element-wise, the elements of s and t and +// stores the result in dst. Panics if the lengths of s, t and dst do not match. +func AddTo(dst, s, t []float64) []float64 { + if len(s) != len(t) { + panic("floats: length of adders do not match") + } + if len(dst) != len(s) { + panic("floats: length of destination does not match length of adder") + } + asm.DaxpyUnitaryTo(dst, 1, s, t) + return dst +} + +// AddConst adds the scalar c to all of the values in dst. +func AddConst(c float64, dst []float64) { + for i := range dst { + dst[i] += c + } +} + +// AddScaled performs dst = dst + alpha * s. +// It panics if the lengths of dst and s are not equal. +func AddScaled(dst []float64, alpha float64, s []float64) { + if len(dst) != len(s) { + panic("floats: length of destination and source to not match") + } + asm.DaxpyUnitaryTo(dst, alpha, s, dst) +} + +// AddScaledTo performs dst = y + alpha * s, where alpha is a scalar, +// and dst, y and s are all slices. +// It panics if the lengths of dst, y, and s are not equal. +// +// At the return of the function, dst[i] = y[i] + alpha * s[i] +func AddScaledTo(dst, y []float64, alpha float64, s []float64) []float64 { + if len(dst) != len(s) || len(dst) != len(y) { + panic("floats: lengths of slices do not match") + } + asm.DaxpyUnitaryTo(dst, alpha, s, y) + return dst +} + +// argsort is a helper that implements sort.Interface, as used by +// Argsort. +type argsort struct { + s []float64 + inds []int +} + +func (a argsort) Len() int { + return len(a.s) +} + +func (a argsort) Less(i, j int) bool { + return a.s[i] < a.s[j] +} + +func (a argsort) Swap(i, j int) { + a.s[i], a.s[j] = a.s[j], a.s[i] + a.inds[i], a.inds[j] = a.inds[j], a.inds[i] +} + +// Argsort sorts the elements of s while tracking their original order. +// At the conclusion of Argsort, s will contain the original elements of s +// but sorted in increasing order, and inds will contain the original position +// of the elements in the slice such that dst[i] = origDst[inds[i]]. +// It panics if the lengths of dst and inds do not match. +func Argsort(dst []float64, inds []int) { + if len(dst) != len(inds) { + panic("floats: length of inds does not match length of slice") + } + for i := range dst { + inds[i] = i + } + + a := argsort{s: dst, inds: inds} + sort.Sort(a) +} + +// Count applies the function f to every element of s and returns the number +// of times the function returned true. +func Count(f func(float64) bool, s []float64) int { + var n int + for _, val := range s { + if f(val) { + n++ + } + } + return n +} + +// CumProd finds the cumulative product of the first i elements in +// s and puts them in place into the ith element of the +// destination dst. A panic will occur if the lengths of arguments +// do not match. +// +// At the return of the function, dst[i] = s[i] * s[i-1] * s[i-2] * ... +func CumProd(dst, s []float64) []float64 { + if len(dst) != len(s) { + panic("floats: length of destination does not match length of the source") + } + if len(dst) == 0 { + return dst + } + dst[0] = s[0] + for i := 1; i < len(s); i++ { + dst[i] = dst[i-1] * s[i] + } + return dst +} + +// CumSum finds the cumulative sum of the first i elements in +// s and puts them in place into the ith element of the +// destination dst. A panic will occur if the lengths of arguments +// do not match. +// +// At the return of the function, dst[i] = s[i] + s[i-1] + s[i-2] + ... +func CumSum(dst, s []float64) []float64 { + if len(dst) != len(s) { + panic("floats: length of destination does not match length of the source") + } + if len(dst) == 0 { + return dst + } + dst[0] = s[0] + for i := 1; i < len(s); i++ { + dst[i] = dst[i-1] + s[i] + } + return dst +} + +// Distance computes the L-norm of s - t. See Norm for special cases. +// A panic will occur if the lengths of s and t do not match. +func Distance(s, t []float64, L float64) float64 { + if len(s) != len(t) { + panic("floats: slice lengths do not match") + } + if len(s) == 0 { + return 0 + } + var norm float64 + if L == 2 { + for i, v := range s { + diff := t[i] - v + norm = math.Hypot(norm, diff) + } + return norm + } + if L == 1 { + for i, v := range s { + norm += math.Abs(t[i] - v) + } + return norm + } + if math.IsInf(L, 1) { + for i, v := range s { + absDiff := math.Abs(t[i] - v) + if absDiff > norm { + norm = absDiff + } + } + return norm + } + for i, v := range s { + norm += math.Pow(math.Abs(t[i]-v), L) + } + return math.Pow(norm, 1/L) +} + +// Div performs element-wise division dst / s +// and stores the value in dst. It panics if the +// lengths of s and t are not equal. +func Div(dst, s []float64) { + if len(dst) != len(s) { + panic("floats: slice lengths do not match") + } + for i, val := range s { + dst[i] /= val + } +} + +// DivTo performs element-wise division s / t +// and stores the value in dst. It panics if the +// lengths of s, t, and dst are not equal. +func DivTo(dst, s, t []float64) []float64 { + if len(s) != len(t) || len(dst) != len(t) { + panic("floats: slice lengths do not match") + } + for i, val := range t { + dst[i] = s[i] / val + } + return dst +} + +// Dot computes the dot product of s1 and s2, i.e. +// sum_{i = 1}^N s1[i]*s2[i]. +// A panic will occur if lengths of arguments do not match. +func Dot(s1, s2 []float64) float64 { + if len(s1) != len(s2) { + panic("floats: lengths of the slices do not match") + } + return asm.DdotUnitary(s1, s2) +} + +// Equal returns true if the slices have equal lengths and +// all elements are numerically identical. +func Equal(s1, s2 []float64) bool { + if len(s1) != len(s2) { + return false + } + for i, val := range s1 { + if s2[i] != val { + return false + } + } + return true +} + +// EqualApprox returns true if the slices have equal lengths and +// all element pairs have an absolute tolerance less than tol or a +// relative tolerance less than tol. +func EqualApprox(s1, s2 []float64, tol float64) bool { + if len(s1) != len(s2) { + return false + } + for i, a := range s1 { + if !EqualWithinAbsOrRel(a, s2[i], tol, tol) { + return false + } + } + return true +} + +// EqualFunc returns true if the slices have the same lengths +// and the function returns true for all element pairs. +func EqualFunc(s1, s2 []float64, f func(float64, float64) bool) bool { + if len(s1) != len(s2) { + return false + } + for i, val := range s1 { + if !f(val, s2[i]) { + return false + } + } + return true +} + +// EqualWithinAbs returns true if a and b have an absolute +// difference of less than tol. +func EqualWithinAbs(a, b, tol float64) bool { + return a == b || math.Abs(a-b) <= tol +} + +const minNormalFloat64 = 2.2250738585072014e-308 + +// EqualWithinRel returns true if the difference between a and b +// is not greater than tol times the greater value. +func EqualWithinRel(a, b, tol float64) bool { + if a == b { + return true + } + delta := math.Abs(a - b) + if delta <= minNormalFloat64 { + return delta <= tol*minNormalFloat64 + } + // We depend on the division in this relationship to identify + // infinities (we rely on the NaN to fail the test) otherwise + // we compare Infs of the same sign and evaluate Infs as equal + // independent of sign. + return delta/math.Max(math.Abs(a), math.Abs(b)) <= tol +} + +// EqualWithinAbsOrRel returns true if a and b are equal to within +// the absolute tolerance. +func EqualWithinAbsOrRel(a, b, absTol, relTol float64) bool { + if EqualWithinAbs(a, b, absTol) { + return true + } + return EqualWithinRel(a, b, relTol) +} + +// EqualWithinULP returns true if a and b are equal to within +// the specified number of floating point units in the last place. +func EqualWithinULP(a, b float64, ulp uint) bool { + if a == b { + return true + } + if math.IsNaN(a) || math.IsNaN(b) { + return false + } + if math.Signbit(a) != math.Signbit(b) { + return math.Float64bits(math.Abs(a))+math.Float64bits(math.Abs(b)) <= uint64(ulp) + } + return ulpDiff(math.Float64bits(a), math.Float64bits(b)) <= uint64(ulp) +} + +func ulpDiff(a, b uint64) uint64 { + if a > b { + return a - b + } + return b - a +} + +// EqualLengths returns true if all of the slices have equal length, +// and false otherwise. Returns true if there are no input slices. +func EqualLengths(slices ...[]float64) bool { + // This length check is needed: http://play.golang.org/p/sdty6YiLhM + if len(slices) == 0 { + return true + } + l := len(slices[0]) + for i := 1; i < len(slices); i++ { + if len(slices[i]) != l { + return false + } + } + return true +} + +// Find applies f to every element of s and returns the indices of the first +// k elements for which the f returns true, or all such elements +// if k < 0. +// Find will reslice inds to have 0 length, and will append +// found indices to inds. +// If k > 0 and there are fewer than k elements in s satisfying f, +// all of the found elements will be returned along with an error. +// At the return of the function, the input inds will be in an undetermined state. +func Find(inds []int, f func(float64) bool, s []float64, k int) ([]int, error) { + + // inds is also returned to allow for calling with nil + + // Reslice inds to have zero length + inds = inds[:0] + + // If zero elements requested, can just return + if k == 0 { + return inds, nil + } + + // If k < 0, return all of the found indices + if k < 0 { + for i, val := range s { + if f(val) { + inds = append(inds, i) + } + } + return inds, nil + } + + // Otherwise, find the first k elements + nFound := 0 + for i, val := range s { + if f(val) { + inds = append(inds, i) + nFound++ + if nFound == k { + return inds, nil + } + } + } + // Finished iterating over the loop, which means k elements were not found + return inds, errors.New("floats: insufficient elements found") +} + +// HasNaN returns true if the slice s has any values that are NaN and false +// otherwise. +func HasNaN(s []float64) bool { + for _, v := range s { + if math.IsNaN(v) { + return true + } + } + return false +} + +// LogSpan returns a set of n equally spaced points in log space between, +// l and u where N is equal to len(dst). The first element of the +// resulting dst will be l and the final element of dst will be u. +// Panics if len(dst) < 2 +// Note that this call will return NaNs if either l or u are negative, and +// will return all zeros if l or u is zero. +// Also returns the mutated slice dst, so that it can be used in range, like: +// +// for i, x := range LogSpan(dst, l, u) { ... } +func LogSpan(dst []float64, l, u float64) []float64 { + Span(dst, math.Log(l), math.Log(u)) + for i := range dst { + dst[i] = math.Exp(dst[i]) + } + return dst +} + +// LogSumExp returns the log of the sum of the exponentials of the values in s. +// Panics if s is an empty slice. +func LogSumExp(s []float64) float64 { + // Want to do this in a numerically stable way which avoids + // overflow and underflow + // First, find the maximum value in the slice. + maxval := Max(s) + if math.IsInf(maxval, 0) { + // If it's infinity either way, the logsumexp will be infinity as well + // returning now avoids NaNs + return maxval + } + var lse float64 + // Compute the sumexp part + for _, val := range s { + lse += math.Exp(val - maxval) + } + // Take the log and add back on the constant taken out + return math.Log(lse) + maxval +} + +// Max returns the maximum value in the input slice. If the slice is empty, Max will panic. +func Max(s []float64) float64 { + return s[MaxIdx(s)] +} + +// MaxIdx returns the index of the maximum value in the input slice. If several +// entries have the maximum value, the first such index is returned. If the slice +// is empty, MaxIdx will panic. +func MaxIdx(s []float64) int { + if len(s) == 0 { + panic("floats: zero slice length") + } + max := s[0] + var ind int + for i, v := range s { + if v > max { + max = v + ind = i + } + } + return ind +} + +// Min returns the maximum value in the input slice. If the slice is empty, Min will panic. +func Min(s []float64) float64 { + return s[MinIdx(s)] +} + +// MinIdx returns the index of the minimum value in the input slice. If several +// entries have the maximum value, the first such index is returned. If the slice +// is empty, MinIdx will panic. +func MinIdx(s []float64) int { + min := s[0] + var ind int + for i, v := range s { + if v < min { + min = v + ind = i + } + } + return ind +} + +// Mul performs element-wise multiplication between dst +// and s and stores the value in dst. Panics if the +// lengths of s and t are not equal. +func Mul(dst, s []float64) { + if len(dst) != len(s) { + panic("floats: slice lengths do not match") + } + for i, val := range s { + dst[i] *= val + } +} + +// MulTo performs element-wise multiplication between s +// and t and stores the value in dst. Panics if the +// lengths of s, t, and dst are not equal. +func MulTo(dst, s, t []float64) []float64 { + if len(s) != len(t) || len(dst) != len(t) { + panic("floats: slice lengths do not match") + } + for i, val := range t { + dst[i] = val * s[i] + } + return dst +} + +// Nearest returns the index of the element in s +// whose value is nearest to v. If several such +// elements exist, the lowest index is returned. +// Panics if len(s) == 0. +func Nearest(s []float64, v float64) int { + var ind int + dist := math.Abs(v - s[0]) + for i, val := range s { + newDist := math.Abs(v - val) + if newDist < dist { + dist = newDist + ind = i + } + } + return ind +} + +// NearestWithinSpan return the index of a hypothetical vector created +// by Span with length n and bounds l and u whose value is closest +// to v. NearestWithinSpan panics if u < l. If the value is greater than u or +// less than l, the function returns -1. +func NearestWithinSpan(n int, l, u float64, v float64) int { + if u < l { + panic("floats: upper bound greater than lower bound") + } + if v < l || v > u { + return -1 + } + // Can't guarantee anything about exactly halfway between + // because of floating point weirdness. + return int((float64(n)-1)/(u-l)*(v-l) + 0.5) +} + +// Norm returns the L norm of the slice S, defined as +// (sum_{i=1}^N s[i]^L)^{1/L} +// Special cases: +// L = math.Inf(1) gives the maximum absolute value. +// Does not correctly compute the zero norm (use Count). +func Norm(s []float64, L float64) float64 { + // Should this complain if L is not positive? + // Should this be done in log space for better numerical stability? + // would be more cost + // maybe only if L is high? + if len(s) == 0 { + return 0 + } + if L == 2 { + twoNorm := math.Abs(s[0]) + for i := 1; i < len(s); i++ { + twoNorm = math.Hypot(twoNorm, s[i]) + } + return twoNorm + } + var norm float64 + if L == 1 { + for _, val := range s { + norm += math.Abs(val) + } + return norm + } + if math.IsInf(L, 1) { + for _, val := range s { + norm = math.Max(norm, math.Abs(val)) + } + return norm + } + for _, val := range s { + norm += math.Pow(math.Abs(val), L) + } + return math.Pow(norm, 1/L) +} + +// Prod returns the product of the elements of the slice. +// Returns 1 if len(s) = 0. +func Prod(s []float64) float64 { + prod := 1.0 + for _, val := range s { + prod *= val + } + return prod +} + +// Reverse reverses the order of elements in the slice. +func Reverse(s []float64) { + for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 { + s[i], s[j] = s[j], s[i] + } +} + +// Round returns the half away from zero rounded value of x with prec precision. +// +// Special cases are: +// Round(±0) = +0 +// Round(±Inf) = ±Inf +// Round(NaN) = NaN +func Round(x float64, prec int) float64 { + if x == 0 { + // Make sure zero is returned + // without the negative bit set. + return 0 + } + // Fast path for positive precision on integers. + if prec >= 0 && x == math.Trunc(x) { + return x + } + pow := math.Pow10(prec) + intermed := x * pow + if math.IsInf(intermed, 0) { + return x + } + if x < 0 { + x = math.Ceil(intermed - 0.5) + } else { + x = math.Floor(intermed + 0.5) + } + + if x == 0 { + return 0 + } + + return x / pow +} + +// RoundEven returns the half even rounded value of x with prec precision. +// +// Special cases are: +// RoundEven(±0) = +0 +// RoundEven(±Inf) = ±Inf +// RoundEven(NaN) = NaN +func RoundEven(x float64, prec int) float64 { + if x == 0 { + // Make sure zero is returned + // without the negative bit set. + return 0 + } + // Fast path for positive precision on integers. + if prec >= 0 && x == math.Trunc(x) { + return x + } + pow := math.Pow10(prec) + intermed := x * pow + if math.IsInf(intermed, 0) { + return x + } + if isHalfway(intermed) { + correction, _ := math.Modf(math.Mod(intermed, 2)) + intermed += correction + if intermed > 0 { + x = math.Floor(intermed) + } else { + x = math.Ceil(intermed) + } + } else { + if x < 0 { + x = math.Ceil(intermed - 0.5) + } else { + x = math.Floor(intermed + 0.5) + } + } + + if x == 0 { + return 0 + } + + return x / pow +} + +func isHalfway(x float64) bool { + _, frac := math.Modf(x) + frac = math.Abs(frac) + return frac == 0.5 || (math.Nextafter(frac, math.Inf(-1)) < 0.5 && math.Nextafter(frac, math.Inf(1)) > 0.5) +} + +// Same returns true if the input slices have the same length and the all elements +// have the same value with NaN treated as the same. +func Same(s, t []float64) bool { + if len(s) != len(t) { + return false + } + for i, v := range s { + w := t[i] + if v != w && !math.IsNaN(v) && !math.IsNaN(w) { + return false + } + } + return true +} + +// Scale multiplies every element in dst by the scalar c. +func Scale(c float64, dst []float64) { + if len(dst) > 0 { + asm.DscalUnitary(c, dst) + } +} + +// Span returns a set of N equally spaced points between l and u, where N +// is equal to the length of the destination. The first element of the destination +// is l, the final element of the destination is u. +// Panics if len(dst) < 2. +// +// Also returns the mutated slice dst, so that it can be used in range expressions, like: +// +// for i, x := range Span(dst, l, u) { ... } +func Span(dst []float64, l, u float64) []float64 { + n := len(dst) + if n < 2 { + panic("floats: destination must have length >1") + } + step := (u - l) / float64(n-1) + for i := range dst { + dst[i] = l + step*float64(i) + } + return dst +} + +// Sub subtracts, element-wise, the elements of s from dst. Panics if +// the lengths of dst and s do not match. +func Sub(dst, s []float64) { + if len(dst) != len(s) { + panic("floats: length of the slices do not match") + } + asm.DaxpyUnitaryTo(dst, -1, s, dst) +} + +// SubTo subtracts, element-wise, the elements of t from s and +// stores the result in dst. Panics if the lengths of s, t and dst do not match. +func SubTo(dst, s, t []float64) []float64 { + if len(s) != len(t) { + panic("floats: length of subtractor and subtractee do not match") + } + if len(dst) != len(s) { + panic("floats: length of destination does not match length of subtractor") + } + asm.DaxpyUnitaryTo(dst, -1, t, s) + return dst +} + +// Sum returns the sum of the elements of the slice. +func Sum(s []float64) float64 { + var sum float64 + for _, val := range s { + sum += val + } + return sum +} + +// Within returns the first index i where s[i] <= v < s[i+1]. Within panics if: +// - len(s) < 2 +// - s is not sorted +func Within(s []float64, v float64) int { + if len(s) < 2 { + panic("floats: slice length less than 2") + } + if !sort.Float64sAreSorted(s) { + panic("floats: input slice not sorted") + } + if v < s[0] || v >= s[len(s)-1] || math.IsNaN(v) { + return -1 + } + for i, f := range s[1:] { + if v < f { + return i + } + } + return -1 +} diff --git a/vendor/github.com/gonum/internal/asm/caxpy.go b/vendor/github.com/gonum/internal/asm/caxpy.go new file mode 100644 index 00000000..529b1c42 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/caxpy.go @@ -0,0 +1,36 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func CaxpyUnitary(alpha complex64, x, y []complex64) { + for i, v := range x { + y[i] += alpha * v + } +} + +func CaxpyUnitaryTo(dst []complex64, alpha complex64, x, y []complex64) { + for i, v := range x { + dst[i] = alpha*v + y[i] + } +} + +func CaxpyInc(alpha complex64, x, y []complex64, n, incX, incY, ix, iy uintptr) { + for i := 0; i < int(n); i++ { + y[iy] += alpha * x[ix] + ix += incX + iy += incY + } +} + +func CaxpyIncTo(dst []complex64, incDst, idst uintptr, alpha complex64, x, y []complex64, n, incX, incY, ix, iy uintptr) { + for i := 0; i < int(n); i++ { + dst[idst] = alpha*x[ix] + y[iy] + ix += incX + iy += incY + idst += incDst + } +} diff --git a/vendor/github.com/gonum/internal/asm/cdotc.go b/vendor/github.com/gonum/internal/asm/cdotc.go new file mode 100644 index 00000000..ed999e5f --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/cdotc.go @@ -0,0 +1,23 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func CdotcUnitary(x, y []complex64) (sum complex64) { + for i, v := range x { + sum += y[i] * conj(v) + } + return +} + +func CdotcInc(x, y []complex64, n, incX, incY, ix, iy uintptr) (sum complex64) { + for i := 0; i < int(n); i++ { + sum += y[iy] * conj(x[ix]) + ix += incX + iy += incY + } + return +} diff --git a/vendor/github.com/gonum/internal/asm/cdotu.go b/vendor/github.com/gonum/internal/asm/cdotu.go new file mode 100644 index 00000000..3392ee25 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/cdotu.go @@ -0,0 +1,23 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func CdotuUnitary(x, y []complex64) (sum complex64) { + for i, v := range x { + sum += y[i] * v + } + return +} + +func CdotuInc(x, y []complex64, n, incX, incY, ix, iy uintptr) (sum complex64) { + for i := 0; i < int(n); i++ { + sum += y[iy] * x[ix] + ix += incX + iy += incY + } + return +} diff --git a/vendor/github.com/gonum/internal/asm/conj.go b/vendor/github.com/gonum/internal/asm/conj.go new file mode 100644 index 00000000..1cadb2a5 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/conj.go @@ -0,0 +1,7 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func conj(c complex64) complex64 { return complex(real(c), -imag(c)) } diff --git a/vendor/github.com/gonum/internal/asm/cscal.go b/vendor/github.com/gonum/internal/asm/cscal.go new file mode 100644 index 00000000..894e8c55 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/cscal.go @@ -0,0 +1,38 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func CscalUnitary(alpha complex64, x []complex64) { + for i := range x { + x[i] *= alpha + } +} + +func CscalUnitaryTo(dst []complex64, alpha complex64, x []complex64) { + for i, v := range x { + dst[i] = alpha * v + } +} + +// incX must be positive. +func CscalInc(alpha complex64, x []complex64, n, incX uintptr) { + var ix uintptr + for i := 0; i < int(n); i++ { + x[ix] *= alpha + ix += incX + } +} + +// incDst and incX must be positive. +func CscalIncTo(dst []complex64, incDst uintptr, alpha complex64, x []complex64, n, incX uintptr) { + var idst, ix uintptr + for i := 0; i < int(n); i++ { + dst[idst] = alpha * x[ix] + ix += incX + idst += incDst + } +} diff --git a/vendor/github.com/gonum/internal/asm/daxpy.go b/vendor/github.com/gonum/internal/asm/daxpy.go new file mode 100644 index 00000000..97fc7bde --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/daxpy.go @@ -0,0 +1,36 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//+build !amd64 noasm appengine + +package asm + +func DaxpyUnitary(alpha float64, x, y []float64) { + for i, v := range x { + y[i] += alpha * v + } +} + +func DaxpyUnitaryTo(dst []float64, alpha float64, x, y []float64) { + for i, v := range x { + dst[i] = alpha*v + y[i] + } +} + +func DaxpyInc(alpha float64, x, y []float64, n, incX, incY, ix, iy uintptr) { + for i := 0; i < int(n); i++ { + y[iy] += alpha * x[ix] + ix += incX + iy += incY + } +} + +func DaxpyIncTo(dst []float64, incDst, idst uintptr, alpha float64, x, y []float64, n, incX, incY, ix, iy uintptr) { + for i := 0; i < int(n); i++ { + dst[idst] = alpha*x[ix] + y[iy] + ix += incX + iy += incY + idst += incDst + } +} diff --git a/vendor/github.com/gonum/internal/asm/daxpyinc_amd64.s b/vendor/github.com/gonum/internal/asm/daxpyinc_amd64.s new file mode 100644 index 00000000..863bf07f --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/daxpyinc_amd64.s @@ -0,0 +1,98 @@ +// Generated by running +// go generate github.com/gonum/internal/asm +// DO NOT EDIT. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Some of the loop unrolling code is copied from: +// http://golang.org/src/math/big/arith_amd64.s +// which is distributed under these terms: +// +// Copyright (c) 2012 The Go Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//+build !noasm,!appengine + +#include "textflag.h" + +// func DaxpyInc(alpha float64, x, y []float64, n, incX, incY, ix, iy uintptr) +TEXT ·DaxpyInc(SB), NOSPLIT, $0 + MOVHPD alpha+0(FP), X7 + MOVLPD alpha+0(FP), X7 + MOVQ x+8(FP), R8 + MOVQ y+32(FP), R9 + MOVQ n+56(FP), DX + MOVQ incX+64(FP), R11 + MOVQ incY+72(FP), R12 + MOVQ ix+80(FP), SI + MOVQ iy+88(FP), DI + + MOVQ SI, AX // nextX = ix + MOVQ DI, BX // nextY = iy + ADDQ R11, AX // nextX += incX + ADDQ R12, BX // nextY += incY + SHLQ $1, R11 // incX *= 2 + SHLQ $1, R12 // incY *= 2 + + SUBQ $2, DX // n -= 2 + JL tail // if n < 0 + +loop: // n >= 0 + // y[i] += alpha * x[i] unrolled 2x. + MOVHPD 0(R8)(SI*8), X0 + MOVHPD 0(R9)(DI*8), X1 + MOVLPD 0(R8)(AX*8), X0 + MOVLPD 0(R9)(BX*8), X1 + MULPD X7, X0 + ADDPD X0, X1 + MOVHPD X1, 0(R9)(DI*8) + MOVLPD X1, 0(R9)(BX*8) + + ADDQ R11, SI // ix += incX + ADDQ R12, DI // iy += incY + ADDQ R11, AX // nextX += incX + ADDQ R12, BX // nextY += incY + + SUBQ $2, DX // n -= 2 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $2, DX // n += 2 + JLE end // if n <= 0 + + // y[i] += alpha * x[i] for the last iteration if n is odd. + MOVSD 0(R8)(SI*8), X0 + MOVSD 0(R9)(DI*8), X1 + MULSD X7, X0 + ADDSD X0, X1 + MOVSD X1, 0(R9)(DI*8) + +end: + RET diff --git a/vendor/github.com/gonum/internal/asm/daxpyincto_amd64.s b/vendor/github.com/gonum/internal/asm/daxpyincto_amd64.s new file mode 100644 index 00000000..45d2988a --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/daxpyincto_amd64.s @@ -0,0 +1,106 @@ +// Generated by running +// go generate github.com/gonum/internal/asm +// DO NOT EDIT. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Some of the loop unrolling code is copied from: +// http://golang.org/src/math/big/arith_amd64.s +// which is distributed under these terms: +// +// Copyright (c) 2012 The Go Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//+build !noasm,!appengine + +#include "textflag.h" + +// func DaxpyIncTo(dst []float64, incDst, idst uintptr, alpha float64, x, y []float64, n, incX, incY, ix, iy uintptr) +TEXT ·DaxpyIncTo(SB), NOSPLIT, $0 + MOVQ dst+0(FP), R10 + MOVQ incDst+24(FP), R13 + MOVQ idst+32(FP), BP + MOVHPD alpha+40(FP), X7 + MOVLPD alpha+40(FP), X7 + MOVQ x+48(FP), R8 + MOVQ y+72(FP), R9 + MOVQ n+96(FP), DX + MOVQ incX+104(FP), R11 + MOVQ incY+112(FP), R12 + MOVQ ix+120(FP), SI + MOVQ iy+128(FP), DI + + MOVQ SI, AX // nextX = ix + MOVQ DI, BX // nextY = iy + MOVQ BP, CX // nextDst = idst + ADDQ R11, AX // nextX += incX + ADDQ R12, BX // nextY += incY + ADDQ R13, CX // nextDst += incDst + SHLQ $1, R11 // incX *= 2 + SHLQ $1, R12 // incY *= 2 + SHLQ $1, R13 // incDst *= 2 + + SUBQ $2, DX // n -= 2 + JL tail // if n < 0 + +loop: // n >= 0 + // dst[i] = alpha * x[i] + y[i] unrolled 2x. + MOVHPD 0(R8)(SI*8), X0 + MOVHPD 0(R9)(DI*8), X1 + MOVLPD 0(R8)(AX*8), X0 + MOVLPD 0(R9)(BX*8), X1 + MULPD X7, X0 + ADDPD X0, X1 + MOVHPD X1, 0(R10)(BP*8) + MOVLPD X1, 0(R10)(CX*8) + + ADDQ R11, SI // ix += incX + ADDQ R12, DI // iy += incY + ADDQ R13, BP // idst += incDst + ADDQ R11, AX // nextX += incX + ADDQ R12, BX // nextY += incY + ADDQ R13, CX // nextDst += incDst + + SUBQ $2, DX // n -= 2 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $2, DX // n += 2 + JLE end // if n <= 0 + + // dst[i] = alpha * x[i] + y[i] for the last iteration if n is odd. + MOVSD 0(R8)(SI*8), X0 + MOVSD 0(R9)(DI*8), X1 + MULSD X7, X0 + ADDSD X0, X1 + MOVSD X1, 0(R10)(BP*8) + +end: + RET diff --git a/vendor/github.com/gonum/internal/asm/daxpyunitary_amd64.s b/vendor/github.com/gonum/internal/asm/daxpyunitary_amd64.s new file mode 100644 index 00000000..205c9a89 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/daxpyunitary_amd64.s @@ -0,0 +1,82 @@ +// Generated by running +// go generate github.com/gonum/internal/asm +// DO NOT EDIT. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Some of the loop unrolling code is copied from: +// http://golang.org/src/math/big/arith_amd64.s +// which is distributed under these terms: +// +// Copyright (c) 2012 The Go Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//+build !noasm,!appengine + +#include "textflag.h" + +// func DaxpyUnitary(alpha float64, x, y []float64) +// This function assumes len(y) >= len(x). +TEXT ·DaxpyUnitary(SB), NOSPLIT, $0 + MOVHPD alpha+0(FP), X7 + MOVLPD alpha+0(FP), X7 + MOVQ x+8(FP), R8 + MOVQ x_len+16(FP), DI // n = len(x) + MOVQ y+32(FP), R9 + + MOVQ $0, SI // i = 0 + SUBQ $2, DI // n -= 2 + JL tail // if n < 0 goto tail + +loop: + // y[i] += alpha * x[i] unrolled 2x. + MOVUPD 0(R8)(SI*8), X0 + MOVUPD 0(R9)(SI*8), X1 + MULPD X7, X0 + ADDPD X0, X1 + MOVUPD X1, 0(R9)(SI*8) + + ADDQ $2, SI // i += 2 + SUBQ $2, DI // n -= 2 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $2, DI // n += 2 + JLE end // if n <= 0 goto end + + // y[i] += alpha * x[i] for the last iteration if n is odd. + MOVSD 0(R8)(SI*8), X0 + MOVSD 0(R9)(SI*8), X1 + MULSD X7, X0 + ADDSD X0, X1 + MOVSD X1, 0(R9)(SI*8) + +end: + RET diff --git a/vendor/github.com/gonum/internal/asm/daxpyunitaryto_amd64.s b/vendor/github.com/gonum/internal/asm/daxpyunitaryto_amd64.s new file mode 100644 index 00000000..fbfe1055 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/daxpyunitaryto_amd64.s @@ -0,0 +1,83 @@ +// Generated by running +// go generate github.com/gonum/internal/asm +// DO NOT EDIT. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Some of the loop unrolling code is copied from: +// http://golang.org/src/math/big/arith_amd64.s +// which is distributed under these terms: +// +// Copyright (c) 2012 The Go Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//+build !noasm,!appengine + +#include "textflag.h" + +// func DaxpyUnitaryTo(dst []float64, alpha float64, x, y []float64) +// This function assumes len(y) >= len(x) and len(dst) >= len(x). +TEXT ·DaxpyUnitaryTo(SB), NOSPLIT, $0 + MOVQ dst+0(FP), R10 + MOVHPD alpha+24(FP), X7 + MOVLPD alpha+24(FP), X7 + MOVQ x+32(FP), R8 + MOVQ x_len+40(FP), DI // n = len(x) + MOVQ y+56(FP), R9 + + MOVQ $0, SI // i = 0 + SUBQ $2, DI // n -= 2 + JL tail // if n < 0 goto tail + +loop: + // dst[i] = alpha * x[i] + y[i] unrolled 2x. + MOVUPD 0(R8)(SI*8), X0 + MOVUPD 0(R9)(SI*8), X1 + MULPD X7, X0 + ADDPD X0, X1 + MOVUPD X1, 0(R10)(SI*8) + + ADDQ $2, SI // i += 2 + SUBQ $2, DI // n -= 2 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $2, DI // n += 2 + JLE end // if n <= 0 goto end + + // dst[i] = alpha * x[i] + y[i] for the last iteration if n is odd. + MOVSD 0(R8)(SI*8), X0 + MOVSD 0(R9)(SI*8), X1 + MULSD X7, X0 + ADDSD X0, X1 + MOVSD X1, 0(R10)(SI*8) + +end: + RET diff --git a/vendor/github.com/gonum/internal/asm/ddot.go b/vendor/github.com/gonum/internal/asm/ddot.go new file mode 100644 index 00000000..b59c344a --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/ddot.go @@ -0,0 +1,23 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//+build !amd64 noasm appengine + +package asm + +func DdotUnitary(x, y []float64) (sum float64) { + for i, v := range x { + sum += y[i] * v + } + return +} + +func DdotInc(x, y []float64, n, incX, incY, ix, iy uintptr) (sum float64) { + for i := 0; i < int(n); i++ { + sum += y[iy] * x[ix] + ix += incX + iy += incY + } + return +} diff --git a/vendor/github.com/gonum/internal/asm/ddot_amd64.s b/vendor/github.com/gonum/internal/asm/ddot_amd64.s new file mode 100644 index 00000000..ba5c2aa3 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/ddot_amd64.s @@ -0,0 +1,145 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Some of the loop unrolling code is copied from: +// http://golang.org/src/math/big/arith_amd64.s +// which is distributed under these terms: +// +// Copyright (c) 2012 The Go Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//+build !noasm,!appengine + +#include "textflag.h" + +// func DdotUnitary(x, y []float64) (sum float64) +// This function assumes len(y) >= len(x). +TEXT ·DdotUnitary(SB), NOSPLIT, $0 + MOVQ x+0(FP), R8 + MOVQ x_len+8(FP), DI // n = len(x) + MOVQ y+24(FP), R9 + + MOVSD $(0.0), X7 // sum = 0 + MOVSD $(0.0), X8 // sum = 0 + + MOVQ $0, SI // i = 0 + SUBQ $4, DI // n -= 4 + JL tail_uni // if n < 0 goto tail_uni + +loop_uni: + // sum += x[i] * y[i] unrolled 4x. + MOVUPD 0(R8)(SI*8), X0 + MOVUPD 0(R9)(SI*8), X1 + MOVUPD 16(R8)(SI*8), X2 + MOVUPD 16(R9)(SI*8), X3 + MULPD X1, X0 + MULPD X3, X2 + ADDPD X0, X7 + ADDPD X2, X8 + + ADDQ $4, SI // i += 4 + SUBQ $4, DI // n -= 4 + JGE loop_uni // if n >= 0 goto loop_uni + +tail_uni: + ADDQ $4, DI // n += 4 + JLE end_uni // if n <= 0 goto end_uni + +onemore_uni: + // sum += x[i] * y[i] for the remaining 1-3 elements. + MOVSD 0(R8)(SI*8), X0 + MOVSD 0(R9)(SI*8), X1 + MULSD X1, X0 + ADDSD X0, X7 + + ADDQ $1, SI // i++ + SUBQ $1, DI // n-- + JNZ onemore_uni // if n != 0 goto onemore_uni + +end_uni: + // Add the four sums together. + ADDPD X8, X7 + MOVSD X7, X0 + UNPCKHPD X7, X7 + ADDSD X0, X7 + MOVSD X7, sum+48(FP) // Return final sum. + RET + +// func DdotInc(x, y []float64, n, incX, incY, ix, iy uintptr) (sum float64) +TEXT ·DdotInc(SB), NOSPLIT, $0 + MOVQ x+0(FP), R8 + MOVQ y+24(FP), R9 + MOVQ n+48(FP), CX + MOVQ incX+56(FP), R11 + MOVQ incY+64(FP), R12 + MOVQ ix+72(FP), R13 + MOVQ iy+80(FP), R14 + + MOVSD $(0.0), X7 // sum = 0 + LEAQ (R8)(R13*8), SI // p = &x[ix] + LEAQ (R9)(R14*8), DI // q = &y[ix] + SHLQ $3, R11 // incX *= sizeof(float64) + SHLQ $3, R12 // indY *= sizeof(float64) + + SUBQ $2, CX // n -= 2 + JL tail_inc // if n < 0 goto tail_inc + +loop_inc: + // sum += *p * *q unrolled 2x. + MOVHPD (SI), X0 + MOVHPD (DI), X1 + ADDQ R11, SI // p += incX + ADDQ R12, DI // q += incY + MOVLPD (SI), X0 + MOVLPD (DI), X1 + ADDQ R11, SI // p += incX + ADDQ R12, DI // q += incY + + MULPD X1, X0 + ADDPD X0, X7 + + SUBQ $2, CX // n -= 2 + JGE loop_inc // if n >= 0 goto loop_inc + +tail_inc: + ADDQ $2, CX // n += 2 + JLE end_inc // if n <= 0 goto end_inc + + // sum += *p * *q for the last iteration if n is odd. + MOVSD (SI), X0 + MULSD (DI), X0 + ADDSD X0, X7 + +end_inc: + // Add the two sums together. + MOVSD X7, X0 + UNPCKHPD X7, X7 + ADDSD X0, X7 + MOVSD X7, sum+88(FP) // Return final sum. + RET diff --git a/vendor/github.com/gonum/internal/asm/dscal.go b/vendor/github.com/gonum/internal/asm/dscal.go new file mode 100644 index 00000000..beb82205 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/dscal.go @@ -0,0 +1,38 @@ +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//+build !amd64 noasm appengine + +package asm + +func DscalUnitary(alpha float64, x []float64) { + for i := range x { + x[i] *= alpha + } +} + +func DscalUnitaryTo(dst []float64, alpha float64, x []float64) { + for i, v := range x { + dst[i] = alpha * v + } +} + +// incX must be positive. +func DscalInc(alpha float64, x []float64, n, incX uintptr) { + var ix uintptr + for i := 0; i < int(n); i++ { + x[ix] *= alpha + ix += incX + } +} + +// incDst and incX must be positive. +func DscalIncTo(dst []float64, incDst uintptr, alpha float64, x []float64, n, incX uintptr) { + var idst, ix uintptr + for i := 0; i < int(n); i++ { + dst[idst] = alpha * x[ix] + ix += incX + idst += incDst + } +} diff --git a/vendor/github.com/gonum/internal/asm/dscalinc_amd64.s b/vendor/github.com/gonum/internal/asm/dscalinc_amd64.s new file mode 100644 index 00000000..7cfce955 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/dscalinc_amd64.s @@ -0,0 +1,85 @@ +// Generated by running +// go generate github.com/gonum/internal/asm +// DO NOT EDIT. + +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Some of the loop unrolling code is copied from: +// http://golang.org/src/math/big/arith_amd64.s +// which is distributed under these terms: +// +// Copyright (c) 2012 The Go Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//+build !noasm,!appengine + +#include "textflag.h" + +// func DscalInc(alpha float64, x []float64, n, incX uintptr) +// This function assumes that incX is positive. +TEXT ·DscalInc(SB), NOSPLIT, $0 + MOVHPD alpha+0(FP), X7 + MOVLPD alpha+0(FP), X7 + MOVQ x+8(FP), R8 + MOVQ n+32(FP), DX + MOVQ incX+40(FP), R10 + + MOVQ $0, SI + MOVQ R10, AX // nextX = incX + SHLQ $1, R10 // incX *= 2 + + SUBQ $2, DX // n -= 2 + JL tail // if n < 0 + +loop: + // x[i] *= alpha unrolled 2x. + MOVHPD 0(R8)(SI*8), X0 + MOVLPD 0(R8)(AX*8), X0 + MULPD X7, X0 + MOVHPD X0, 0(R8)(SI*8) + MOVLPD X0, 0(R8)(AX*8) + + ADDQ R10, SI // ix += incX + ADDQ R10, AX // nextX += incX + + SUBQ $2, DX // n -= 2 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $2, DX // n += 2 + JLE end // if n <= 0 + + // x[i] *= alpha for the last iteration if n is odd. + MOVSD 0(R8)(SI*8), X0 + MULSD X7, X0 + MOVSD X0, 0(R8)(SI*8) + +end: + RET diff --git a/vendor/github.com/gonum/internal/asm/dscalincto_amd64.s b/vendor/github.com/gonum/internal/asm/dscalincto_amd64.s new file mode 100644 index 00000000..156b38ad --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/dscalincto_amd64.s @@ -0,0 +1,92 @@ +// Generated by running +// go generate github.com/gonum/internal/asm +// DO NOT EDIT. + +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Some of the loop unrolling code is copied from: +// http://golang.org/src/math/big/arith_amd64.s +// which is distributed under these terms: +// +// Copyright (c) 2012 The Go Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//+build !noasm,!appengine + +#include "textflag.h" + +// func DscalIncTo(dst []float64, incDst uintptr, alpha float64, x []float64, n, incX uintptr) +// This function assumes that incDst and incX are positive. +TEXT ·DscalIncTo(SB), NOSPLIT, $0 + MOVQ dst+0(FP), R9 + MOVQ incDst+24(FP), R11 + MOVHPD alpha+32(FP), X7 + MOVLPD alpha+32(FP), X7 + MOVQ x+40(FP), R8 + MOVQ n+64(FP), DX + MOVQ incX+72(FP), R10 + + MOVQ $0, SI + MOVQ $0, DI + MOVQ R10, AX // nextX = incX + MOVQ R11, BX // nextDst = incDst + SHLQ $1, R10 // incX *= 2 + SHLQ $1, R11 // incDst *= 2 + + SUBQ $2, DX // n -= 2 + JL tail // if n < 0 + +loop: + // dst[i] = alpha * x[i] unrolled 2x. + MOVHPD 0(R8)(SI*8), X0 + MOVLPD 0(R8)(AX*8), X0 + MULPD X7, X0 + MOVHPD X0, 0(R9)(DI*8) + MOVLPD X0, 0(R9)(BX*8) + + ADDQ R10, SI // ix += incX + ADDQ R10, AX // nextX += incX + ADDQ R11, DI // idst += incDst + ADDQ R11, BX // nextDst += incDst + + SUBQ $2, DX // n -= 2 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $2, DX // n += 2 + JLE end // if n <= 0 + + // dst[i] = alpha * x[i] for the last iteration if n is odd. + MOVSD 0(R8)(SI*8), X0 + MULSD X7, X0 + MOVSD X0, 0(R9)(DI*8) + +end: + RET diff --git a/vendor/github.com/gonum/internal/asm/dscalunitary_amd64.s b/vendor/github.com/gonum/internal/asm/dscalunitary_amd64.s new file mode 100644 index 00000000..b61a8e99 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/dscalunitary_amd64.s @@ -0,0 +1,84 @@ +// Generated by running +// go generate github.com/gonum/internal/asm +// DO NOT EDIT. + +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Some of the loop unrolling code is copied from: +// http://golang.org/src/math/big/arith_amd64.s +// which is distributed under these terms: +// +// Copyright (c) 2012 The Go Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//+build !noasm,!appengine + +#include "textflag.h" + +// func DscalUnitary(alpha float64, x []float64) +TEXT ·DscalUnitary(SB), NOSPLIT, $0 + MOVHPD alpha+0(FP), X7 + MOVLPD alpha+0(FP), X7 + MOVQ x+8(FP), R8 + MOVQ x_len+16(FP), DI // n = len(x) + + MOVQ $0, SI // i = 0 + SUBQ $4, DI // n -= 4 + JL tail // if n < 0 goto tail + +loop: + // x[i] *= alpha unrolled 4x. + MOVUPD 0(R8)(SI*8), X0 + MOVUPD 16(R8)(SI*8), X1 + MULPD X7, X0 + MULPD X7, X1 + MOVUPD X0, 0(R8)(SI*8) + MOVUPD X1, 16(R8)(SI*8) + + ADDQ $4, SI // i += 4 + SUBQ $4, DI // n -= 4 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $4, DI // n += 4 + JZ end // if n == 0 goto end + +onemore: + // x[i] *= alpha for the remaining 1-3 elements. + MOVSD 0(R8)(SI*8), X0 + MULSD X7, X0 + MOVSD X0, 0(R8)(SI*8) + + ADDQ $1, SI // i++ + SUBQ $1, DI // n-- + JNZ onemore // if n != 0 goto onemore + +end: + RET diff --git a/vendor/github.com/gonum/internal/asm/dscalunitaryto_amd64.s b/vendor/github.com/gonum/internal/asm/dscalunitaryto_amd64.s new file mode 100644 index 00000000..c50ee2b3 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/dscalunitaryto_amd64.s @@ -0,0 +1,86 @@ +// Generated by running +// go generate github.com/gonum/internal/asm +// DO NOT EDIT. + +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Some of the loop unrolling code is copied from: +// http://golang.org/src/math/big/arith_amd64.s +// which is distributed under these terms: +// +// Copyright (c) 2012 The Go Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//+build !noasm,!appengine + +#include "textflag.h" + +// func DscalUnitaryTo(dst []float64, alpha float64, x []float64) +// This function assumes len(dst) >= len(x). +TEXT ·DscalUnitaryTo(SB), NOSPLIT, $0 + MOVQ dst+0(FP), R9 + MOVHPD alpha+24(FP), X7 + MOVLPD alpha+24(FP), X7 + MOVQ x+32(FP), R8 + MOVQ x_len+40(FP), DI // n = len(x) + + MOVQ $0, SI // i = 0 + SUBQ $4, DI // n -= 4 + JL tail // if n < 0 goto tail + +loop: + // dst[i] = alpha * x[i] unrolled 4x. + MOVUPD 0(R8)(SI*8), X0 + MOVUPD 16(R8)(SI*8), X1 + MULPD X7, X0 + MULPD X7, X1 + MOVUPD X0, 0(R9)(SI*8) + MOVUPD X1, 16(R9)(SI*8) + + ADDQ $4, SI // i += 4 + SUBQ $4, DI // n -= 4 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $4, DI // n += 4 + JZ end // if n == 0 goto end + +onemore: + // dst[i] = alpha * x[i] for the remaining 1-3 elements. + MOVSD 0(R8)(SI*8), X0 + MULSD X7, X0 + MOVSD X0, 0(R9)(SI*8) + + ADDQ $1, SI // i++ + SUBQ $1, DI // n-- + JNZ onemore // if n != 0 goto onemore + +end: + RET diff --git a/vendor/github.com/gonum/internal/asm/dsdot.go b/vendor/github.com/gonum/internal/asm/dsdot.go new file mode 100644 index 00000000..84506890 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/dsdot.go @@ -0,0 +1,23 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func DsdotUnitary(x, y []float32) (sum float64) { + for i, v := range x { + sum += float64(y[i]) * float64(v) + } + return +} + +func DsdotInc(x, y []float32, n, incX, incY, ix, iy uintptr) (sum float64) { + for i := 0; i < int(n); i++ { + sum += float64(y[iy]) * float64(x[ix]) + ix += incX + iy += incY + } + return +} diff --git a/vendor/github.com/gonum/internal/asm/genasm.go b/vendor/github.com/gonum/internal/asm/genasm.go new file mode 100644 index 00000000..9d6abc93 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/genasm.go @@ -0,0 +1,451 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//+build ignore + +package main + +import ( + "fmt" + "log" + "os" + "strings" + "text/template" +) + +const asmSrc = `{{define "header"}}// Generated by running +// go generate github.com/gonum/internal/asm +// DO NOT EDIT. + +// Copyright ©{{.Year}} The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Some of the loop unrolling code is copied from: +// http://golang.org/src/math/big/arith_amd64.s +// which is distributed under these terms: +// +// Copyright (c) 2012 The Go Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//+build !noasm,!appengine + +#include "textflag.h" +{{end}} + +{{define "daxpyunitary_preamble"}} +{{if not .To}}\ +// func {{.Name}}(alpha float64, x, y []float64) +// This function assumes len(y) >= len(x). +TEXT ·{{.Name}}(SB), NOSPLIT, $0 + MOVHPD alpha+0(FP), X7 + MOVLPD alpha+0(FP), X7 + MOVQ x+8(FP), R8 + MOVQ x_len+16(FP), DI // n = len(x) + MOVQ y+32(FP), R9 +{{else}}\ +// func {{.Name}}(dst []float64, alpha float64, x, y []float64) +// This function assumes len(y) >= len(x) and len(dst) >= len(x). +TEXT ·{{.Name}}(SB), NOSPLIT, $0 + MOVQ dst+0(FP), R10 + MOVHPD alpha+24(FP), X7 + MOVLPD alpha+24(FP), X7 + MOVQ x+32(FP), R8 + MOVQ x_len+40(FP), DI // n = len(x) + MOVQ y+56(FP), R9 +{{end}}\ +{{end}} + +{{define "daxpyunitary_body"}} + MOVQ $0, SI // i = 0 + SUBQ $2, DI // n -= 2 + JL tail // if n < 0 goto tail + +loop: +{{if .To}}\ + // dst[i] = alpha * x[i] + y[i] unrolled 2x. +{{else}}\ + // y[i] += alpha * x[i] unrolled 2x. +{{end}}\ + MOVUPD 0(R8)(SI*8), X0 + MOVUPD 0(R9)(SI*8), X1 + MULPD X7, X0 + ADDPD X0, X1 + MOVUPD X1, 0({{if .To}}R10{{else}}R9{{end}})(SI*8) + + ADDQ $2, SI // i += 2 + SUBQ $2, DI // n -= 2 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $2, DI // n += 2 + JLE end // if n <= 0 goto end + +{{if .To}}\ + // dst[i] = alpha * x[i] + y[i] for the last iteration if n is odd. +{{else}}\ + // y[i] += alpha * x[i] for the last iteration if n is odd. +{{end}}\ + MOVSD 0(R8)(SI*8), X0 + MOVSD 0(R9)(SI*8), X1 + MULSD X7, X0 + ADDSD X0, X1 + MOVSD X1, 0({{if .To}}R10{{else}}R9{{end}})(SI*8) + +end: + RET +{{end}} + +{{define "daxpyinc_preamble"}} +{{if not .To}}\ +// func {{.Name}}(alpha float64, x, y []float64, n, incX, incY, ix, iy uintptr) +TEXT ·{{.Name}}(SB), NOSPLIT, $0 + MOVHPD alpha+0(FP), X7 + MOVLPD alpha+0(FP), X7 + MOVQ x+8(FP), R8 + MOVQ y+32(FP), R9 + MOVQ n+56(FP), DX + MOVQ incX+64(FP), R11 + MOVQ incY+72(FP), R12 + MOVQ ix+80(FP), SI + MOVQ iy+88(FP), DI +{{else}}\ +// func {{.Name}}(dst []float64, incDst, idst uintptr, alpha float64, x, y []float64, n, incX, incY, ix, iy uintptr) +TEXT ·{{.Name}}(SB), NOSPLIT, $0 + MOVQ dst+0(FP), R10 + MOVQ incDst+24(FP), R13 + MOVQ idst+32(FP), BP + MOVHPD alpha+40(FP), X7 + MOVLPD alpha+40(FP), X7 + MOVQ x+48(FP), R8 + MOVQ y+72(FP), R9 + MOVQ n+96(FP), DX + MOVQ incX+104(FP), R11 + MOVQ incY+112(FP), R12 + MOVQ ix+120(FP), SI + MOVQ iy+128(FP), DI +{{end}}\ +{{end}} + +{{define "daxpyinc_body"}} + MOVQ SI, AX // nextX = ix + MOVQ DI, BX // nextY = iy +{{if .To}}\ + MOVQ BP, CX // nextDst = idst +{{end}}\ + ADDQ R11, AX // nextX += incX + ADDQ R12, BX // nextY += incY +{{if .To}}\ + ADDQ R13, CX // nextDst += incDst +{{end}}\ + SHLQ $1, R11 // incX *= 2 + SHLQ $1, R12 // incY *= 2 +{{if .To}}\ + SHLQ $1, R13 // incDst *= 2 +{{end}}\ + + SUBQ $2, DX // n -= 2 + JL tail // if n < 0 + +loop: // n >= 0 +{{if .To}}\ + // dst[i] = alpha * x[i] + y[i] unrolled 2x. +{{else}}\ + // y[i] += alpha * x[i] unrolled 2x. +{{end}}\ + MOVHPD 0(R8)(SI*8), X0 + MOVHPD 0(R9)(DI*8), X1 + MOVLPD 0(R8)(AX*8), X0 + MOVLPD 0(R9)(BX*8), X1 + MULPD X7, X0 + ADDPD X0, X1 + MOVHPD X1, 0({{if .To}}R10)(BP*8{{else}}R9)(DI*8{{end}}) + MOVLPD X1, 0({{if .To}}R10)(CX*8{{else}}R9)(BX*8{{end}}) + + ADDQ R11, SI // ix += incX + ADDQ R12, DI // iy += incY +{{if .To}}\ + ADDQ R13, BP // idst += incDst +{{end}}\ + ADDQ R11, AX // nextX += incX + ADDQ R12, BX // nextY += incY +{{if .To}}\ + ADDQ R13, CX // nextDst += incDst +{{end}}\ + + SUBQ $2, DX // n -= 2 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $2, DX // n += 2 + JLE end // if n <= 0 + +{{if .To}}\ + // dst[i] = alpha * x[i] + y[i] for the last iteration if n is odd. +{{else}}\ + // y[i] += alpha * x[i] for the last iteration if n is odd. +{{end}}\ + MOVSD 0(R8)(SI*8), X0 + MOVSD 0(R9)(DI*8), X1 + MULSD X7, X0 + ADDSD X0, X1 + MOVSD X1, 0({{if .To}}R10)(BP*8{{else}}R9)(DI*8{{end}}) + +end: + RET +{{end}} + +{{define "dscalunitary_preamble"}} +{{if not .To}}\ +// func {{.Name}}(alpha float64, x []float64) +TEXT ·{{.Name}}(SB), NOSPLIT, $0 + MOVHPD alpha+0(FP), X7 + MOVLPD alpha+0(FP), X7 + MOVQ x+8(FP), R8 + MOVQ x_len+16(FP), DI // n = len(x) +{{else}}\ +// func {{.Name}}(dst []float64, alpha float64, x []float64) +// This function assumes len(dst) >= len(x). +TEXT ·{{.Name}}(SB), NOSPLIT, $0 + MOVQ dst+0(FP), R9 + MOVHPD alpha+24(FP), X7 + MOVLPD alpha+24(FP), X7 + MOVQ x+32(FP), R8 + MOVQ x_len+40(FP), DI // n = len(x) +{{end}}\ +{{end}} + +{{define "dscalunitary_body"}} + MOVQ $0, SI // i = 0 + SUBQ $4, DI // n -= 4 + JL tail // if n < 0 goto tail + +loop: +{{if .To}}\ + // dst[i] = alpha * x[i] unrolled 4x. +{{else}}\ + // x[i] *= alpha unrolled 4x. +{{end}}\ + MOVUPD 0(R8)(SI*8), X0 + MOVUPD 16(R8)(SI*8), X1 + MULPD X7, X0 + MULPD X7, X1 + MOVUPD X0, 0({{if .To}}R9{{else}}R8{{end}})(SI*8) + MOVUPD X1, 16({{if .To}}R9{{else}}R8{{end}})(SI*8) + + ADDQ $4, SI // i += 4 + SUBQ $4, DI // n -= 4 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $4, DI // n += 4 + JZ end // if n == 0 goto end + +onemore: +{{if .To}}\ + // dst[i] = alpha * x[i] for the remaining 1-3 elements. +{{else}}\ + // x[i] *= alpha for the remaining 1-3 elements. +{{end}}\ + MOVSD 0(R8)(SI*8), X0 + MULSD X7, X0 + MOVSD X0, 0({{if .To}}R9{{else}}R8{{end}})(SI*8) + + ADDQ $1, SI // i++ + SUBQ $1, DI // n-- + JNZ onemore // if n != 0 goto onemore + +end: + RET +{{end}} + +{{define "dscalinc_preamble"}} +{{if not .To}}\ +// func {{.Name}}(alpha float64, x []float64, n, incX uintptr) +// This function assumes that incX is positive. +TEXT ·{{.Name}}(SB), NOSPLIT, $0 + MOVHPD alpha+0(FP), X7 + MOVLPD alpha+0(FP), X7 + MOVQ x+8(FP), R8 + MOVQ n+32(FP), DX + MOVQ incX+40(FP), R10 +{{else}}\ +// func {{.Name}}(dst []float64, incDst uintptr, alpha float64, x []float64, n, incX uintptr) +// This function assumes that incDst and incX are positive. +TEXT ·{{.Name}}(SB), NOSPLIT, $0 + MOVQ dst+0(FP), R9 + MOVQ incDst+24(FP), R11 + MOVHPD alpha+32(FP), X7 + MOVLPD alpha+32(FP), X7 + MOVQ x+40(FP), R8 + MOVQ n+64(FP), DX + MOVQ incX+72(FP), R10 +{{end}}\ +{{end}} + +{{define "dscalinc_body"}} + MOVQ $0, SI +{{if .To}}\ + MOVQ $0, DI +{{end}}\ + MOVQ R10, AX // nextX = incX +{{if .To}}\ + MOVQ R11, BX // nextDst = incDst +{{end}}\ + SHLQ $1, R10 // incX *= 2 +{{if .To}}\ + SHLQ $1, R11 // incDst *= 2 +{{end}}\ + + SUBQ $2, DX // n -= 2 + JL tail // if n < 0 + +loop: +{{if .To}}\ + // dst[i] = alpha * x[i] unrolled 2x. +{{else}}\ + // x[i] *= alpha unrolled 2x. +{{end}}\ + MOVHPD 0(R8)(SI*8), X0 + MOVLPD 0(R8)(AX*8), X0 + MULPD X7, X0 + MOVHPD X0, 0({{if .To}}R9)(DI*8{{else}}R8)(SI*8{{end}}) + MOVLPD X0, 0({{if .To}}R9)(BX*8{{else}}R8)(AX*8{{end}}) + + ADDQ R10, SI // ix += incX + ADDQ R10, AX // nextX += incX +{{if .To}}\ + ADDQ R11, DI // idst += incDst + ADDQ R11, BX // nextDst += incDst +{{end}}\ + + SUBQ $2, DX // n -= 2 + JGE loop // if n >= 0 goto loop + +tail: + ADDQ $2, DX // n += 2 + JLE end // if n <= 0 + +{{if .To}}\ + // dst[i] = alpha * x[i] for the last iteration if n is odd. +{{else}}\ + // x[i] *= alpha for the last iteration if n is odd. +{{end}}\ + MOVSD 0(R8)(SI*8), X0 + MULSD X7, X0 + MOVSD X0, 0({{if .To}}R9)(DI*8{{else}}R8)(SI*8{{end}}) + +end: + RET +{{end}}` + +func cont(s string) string { + return strings.Replace(s, "\\\n", "", -1) +} + +var asmTemplate = template.Must(template.New("").Parse(cont(asmSrc))) + +type Function struct { + Name string + To bool + Year int + + template string +} + +var funcs = []Function{ + { + Name: "DaxpyUnitary", + To: false, + Year: 2015, + template: `{{template "header" .}}{{template "daxpyunitary_preamble" .}}{{template "daxpyunitary_body" .}}`, + }, + { + Name: "DaxpyUnitaryTo", + To: true, + Year: 2015, + template: `{{template "header" .}}{{template "daxpyunitary_preamble" .}}{{template "daxpyunitary_body" .}}`, + }, + { + Name: "DaxpyInc", + To: false, + Year: 2015, + template: `{{template "header" .}}{{template "daxpyinc_preamble" .}}{{template "daxpyinc_body" .}}`, + }, + { + Name: "DaxpyIncTo", + To: true, + Year: 2015, + template: `{{template "header" .}}{{template "daxpyinc_preamble" .}}{{template "daxpyinc_body" .}}`, + }, + { + Name: "DscalUnitary", + To: false, + Year: 2016, + template: `{{template "header" .}}{{template "dscalunitary_preamble" .}}{{template "dscalunitary_body" .}}`, + }, + { + Name: "DscalUnitaryTo", + To: true, + Year: 2016, + template: `{{template "header" .}}{{template "dscalunitary_preamble" .}}{{template "dscalunitary_body" .}}`, + }, + { + Name: "DscalInc", + To: false, + Year: 2016, + template: `{{template "header" .}}{{template "dscalinc_preamble" .}}{{template "dscalinc_body" .}}`, + }, + { + Name: "DscalIncTo", + To: true, + Year: 2016, + template: `{{template "header" .}}{{template "dscalinc_preamble" .}}{{template "dscalinc_body" .}}`, + }, +} + +func main() { + for _, fn := range funcs { + t, err := template.Must(asmTemplate.Clone()).Parse(fn.template) + if err != nil { + log.Fatalf("failed to parse template: %v", err) + } + file := strings.ToLower(fn.Name) + "_amd64.s" + fmt.Println("Generating", file) + f, err := os.Create(file) + if err != nil { + log.Fatalf("failed to create %q: %v", file, err) + } + err = t.Execute(f, fn) + if err != nil { + log.Fatalf("failed to execute template: %v", err) + } + f.Close() + } +} diff --git a/vendor/github.com/gonum/internal/asm/generate.go b/vendor/github.com/gonum/internal/asm/generate.go new file mode 100644 index 00000000..bd41927a --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/generate.go @@ -0,0 +1,9 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:generate ./single_precision +//go:generate ./complex +//go:generate go run genasm.go + +package asm diff --git a/vendor/github.com/gonum/internal/asm/saxpy.go b/vendor/github.com/gonum/internal/asm/saxpy.go new file mode 100644 index 00000000..cc0b8529 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/saxpy.go @@ -0,0 +1,36 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func SaxpyUnitary(alpha float32, x, y []float32) { + for i, v := range x { + y[i] += alpha * v + } +} + +func SaxpyUnitaryTo(dst []float32, alpha float32, x, y []float32) { + for i, v := range x { + dst[i] = alpha*v + y[i] + } +} + +func SaxpyInc(alpha float32, x, y []float32, n, incX, incY, ix, iy uintptr) { + for i := 0; i < int(n); i++ { + y[iy] += alpha * x[ix] + ix += incX + iy += incY + } +} + +func SaxpyIncTo(dst []float32, incDst, idst uintptr, alpha float32, x, y []float32, n, incX, incY, ix, iy uintptr) { + for i := 0; i < int(n); i++ { + dst[idst] = alpha*x[ix] + y[iy] + ix += incX + iy += incY + idst += incDst + } +} diff --git a/vendor/github.com/gonum/internal/asm/sdot.go b/vendor/github.com/gonum/internal/asm/sdot.go new file mode 100644 index 00000000..0cef5de4 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/sdot.go @@ -0,0 +1,23 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func SdotUnitary(x, y []float32) (sum float32) { + for i, v := range x { + sum += y[i] * v + } + return +} + +func SdotInc(x, y []float32, n, incX, incY, ix, iy uintptr) (sum float32) { + for i := 0; i < int(n); i++ { + sum += y[iy] * x[ix] + ix += incX + iy += incY + } + return +} diff --git a/vendor/github.com/gonum/internal/asm/sscal.go b/vendor/github.com/gonum/internal/asm/sscal.go new file mode 100644 index 00000000..2a1c7afc --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/sscal.go @@ -0,0 +1,38 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func SscalUnitary(alpha float32, x []float32) { + for i := range x { + x[i] *= alpha + } +} + +func SscalUnitaryTo(dst []float32, alpha float32, x []float32) { + for i, v := range x { + dst[i] = alpha * v + } +} + +// incX must be positive. +func SscalInc(alpha float32, x []float32, n, incX uintptr) { + var ix uintptr + for i := 0; i < int(n); i++ { + x[ix] *= alpha + ix += incX + } +} + +// incDst and incX must be positive. +func SscalIncTo(dst []float32, incDst uintptr, alpha float32, x []float32, n, incX uintptr) { + var idst, ix uintptr + for i := 0; i < int(n); i++ { + dst[idst] = alpha * x[ix] + ix += incX + idst += incDst + } +} diff --git a/vendor/github.com/gonum/internal/asm/stubs_amd64.go b/vendor/github.com/gonum/internal/asm/stubs_amd64.go new file mode 100644 index 00000000..9a4645a0 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/stubs_amd64.go @@ -0,0 +1,29 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//+build !noasm,!appengine + +package asm + +func DaxpyUnitary(alpha float64, x, y []float64) + +func DaxpyUnitaryTo(dst []float64, alpha float64, x, y []float64) + +func DaxpyInc(alpha float64, x, y []float64, n, incX, incY, ix, iy uintptr) + +func DaxpyIncTo(dst []float64, incDst, idst uintptr, alpha float64, x, y []float64, n, incX, incY, ix, iy uintptr) + +func DdotUnitary(x, y []float64) (sum float64) + +func DdotInc(x, y []float64, n, incX, incY, ix, iy uintptr) (sum float64) + +func DscalUnitary(alpha float64, x []float64) + +func DscalUnitaryTo(dst []float64, alpha float64, x []float64) + +// incX must be positive. +func DscalInc(alpha float64, x []float64, n, incX uintptr) + +// incDst and incX must be positive. +func DscalIncTo(dst []float64, incDst uintptr, alpha float64, x []float64, n, incX uintptr) diff --git a/vendor/github.com/gonum/internal/asm/zaxpy.go b/vendor/github.com/gonum/internal/asm/zaxpy.go new file mode 100644 index 00000000..3d825f47 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/zaxpy.go @@ -0,0 +1,36 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func ZaxpyUnitary(alpha complex128, x, y []complex128) { + for i, v := range x { + y[i] += alpha * v + } +} + +func ZaxpyUnitaryTo(dst []complex128, alpha complex128, x, y []complex128) { + for i, v := range x { + dst[i] = alpha*v + y[i] + } +} + +func ZaxpyInc(alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr) { + for i := 0; i < int(n); i++ { + y[iy] += alpha * x[ix] + ix += incX + iy += incY + } +} + +func ZaxpyIncTo(dst []complex128, incDst, idst uintptr, alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr) { + for i := 0; i < int(n); i++ { + dst[idst] = alpha*x[ix] + y[iy] + ix += incX + iy += incY + idst += incDst + } +} diff --git a/vendor/github.com/gonum/internal/asm/zdotc.go b/vendor/github.com/gonum/internal/asm/zdotc.go new file mode 100644 index 00000000..7b8febcc --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/zdotc.go @@ -0,0 +1,25 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +import "math/cmplx" + +func ZdotcUnitary(x, y []complex128) (sum complex128) { + for i, v := range x { + sum += y[i] * cmplx.Conj(v) + } + return +} + +func ZdotcInc(x, y []complex128, n, incX, incY, ix, iy uintptr) (sum complex128) { + for i := 0; i < int(n); i++ { + sum += y[iy] * cmplx.Conj(x[ix]) + ix += incX + iy += incY + } + return +} diff --git a/vendor/github.com/gonum/internal/asm/zdotu.go b/vendor/github.com/gonum/internal/asm/zdotu.go new file mode 100644 index 00000000..82c1fe2c --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/zdotu.go @@ -0,0 +1,23 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func ZdotuUnitary(x, y []complex128) (sum complex128) { + for i, v := range x { + sum += y[i] * v + } + return +} + +func ZdotuInc(x, y []complex128, n, incX, incY, ix, iy uintptr) (sum complex128) { + for i := 0; i < int(n); i++ { + sum += y[iy] * x[ix] + ix += incX + iy += incY + } + return +} diff --git a/vendor/github.com/gonum/internal/asm/zscal.go b/vendor/github.com/gonum/internal/asm/zscal.go new file mode 100644 index 00000000..e89ab1a3 --- /dev/null +++ b/vendor/github.com/gonum/internal/asm/zscal.go @@ -0,0 +1,38 @@ +// Generated code do not edit. Run `go generate`. + +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package asm + +func ZscalUnitary(alpha complex128, x []complex128) { + for i := range x { + x[i] *= alpha + } +} + +func ZscalUnitaryTo(dst []complex128, alpha complex128, x []complex128) { + for i, v := range x { + dst[i] = alpha * v + } +} + +// incX must be positive. +func ZscalInc(alpha complex128, x []complex128, n, incX uintptr) { + var ix uintptr + for i := 0; i < int(n); i++ { + x[ix] *= alpha + ix += incX + } +} + +// incDst and incX must be positive. +func ZscalIncTo(dst []complex128, incDst uintptr, alpha complex128, x []complex128, n, incX uintptr) { + var idst, ix uintptr + for i := 0; i < int(n); i++ { + dst[idst] = alpha * x[ix] + ix += incX + idst += incDst + } +} diff --git a/vendor/github.com/gonum/plot/LICENSE b/vendor/github.com/gonum/plot/LICENSE new file mode 100644 index 00000000..259dfce7 --- /dev/null +++ b/vendor/github.com/gonum/plot/LICENSE @@ -0,0 +1 @@ +See the gonum LICENSE file at https://github.com/gonum/license. diff --git a/vendor/github.com/gonum/plot/axis.go b/vendor/github.com/gonum/plot/axis.go new file mode 100644 index 00000000..4eacdd78 --- /dev/null +++ b/vendor/github.com/gonum/plot/axis.go @@ -0,0 +1,575 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plot + +import ( + "image/color" + "math" + "strconv" + "time" + + "github.com/gonum/floats" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// displayPrecision is a sane level of float precision for a plot. +const displayPrecision = 4 + +// Ticker creates Ticks in a specified range +type Ticker interface { + // Ticks returns Ticks in a specified range + Ticks(min, max float64) []Tick +} + +// Normalizer rescales values from the data coordinate system to the +// normalized coordinate system. +type Normalizer interface { + // Normalize transforms a value x in the data coordinate system to + // the normalized coordinate system. + Normalize(min, max, x float64) float64 +} + +// An Axis represents either a horizontal or vertical +// axis of a plot. +type Axis struct { + // Min and Max are the minimum and maximum data + // values represented by the axis. + Min, Max float64 + + Label struct { + // Text is the axis label string. + Text string + + // TextStyle is the style of the axis label text. + // For the vertical axis, one quarter turn + // counterclockwise will be added to the label + // text before drawing. + draw.TextStyle + } + + // LineStyle is the style of the axis line. + draw.LineStyle + + // Padding between the axis line and the data. Having + // non-zero padding ensures that the data is never drawn + // on the axis, thus making it easier to see. + Padding vg.Length + + Tick struct { + // Label is the TextStyle on the tick labels. + Label draw.TextStyle + + // LineStyle is the LineStyle of the tick lines. + draw.LineStyle + + // Length is the length of a major tick mark. + // Minor tick marks are half of the length of major + // tick marks. + Length vg.Length + + // Marker returns the tick marks. Any tick marks + // returned by the Marker function that are not in + // range of the axis are not drawn. + Marker Ticker + } + + // Scale transforms a value given in the data coordinate system + // to the normalized coordinate system of the axis—its distance + // along the axis as a fraction of the axis range. + Scale Normalizer +} + +// makeAxis returns a default Axis. +// +// The default range is (∞, ­∞), and thus any finite +// value is less than Min and greater than Max. +func makeAxis(orientation bool) (Axis, error) { + labelFont, err := vg.MakeFont(DefaultFont, vg.Points(12)) + if err != nil { + return Axis{}, err + } + + tickFont, err := vg.MakeFont(DefaultFont, vg.Points(10)) + if err != nil { + return Axis{}, err + } + + a := Axis{ + Min: math.Inf(1), + Max: math.Inf(-1), + LineStyle: draw.LineStyle{ + Color: color.Black, + Width: vg.Points(0.5), + }, + Padding: vg.Points(5), + Scale: LinearScale{}, + } + a.Label.TextStyle = draw.TextStyle{ + Color: color.Black, + Font: labelFont, + XAlign: draw.XCenter, + YAlign: draw.YBottom, + } + var xalign, yalign = draw.XCenter, draw.YTop + if orientation == vertical { + xalign, yalign = draw.XRight, draw.YCenter + } + a.Tick.Label = draw.TextStyle{ + Color: color.Black, + Font: tickFont, + XAlign: xalign, + YAlign: yalign, + } + a.Tick.LineStyle = draw.LineStyle{ + Color: color.Black, + Width: vg.Points(0.5), + } + a.Tick.Length = vg.Points(8) + a.Tick.Marker = DefaultTicks{} + + return a, nil +} + +// sanitizeRange ensures that the range of the +// axis makes sense. +func (a *Axis) sanitizeRange() { + if math.IsInf(a.Min, 0) { + a.Min = 0 + } + if math.IsInf(a.Max, 0) { + a.Max = 0 + } + if a.Min > a.Max { + a.Min, a.Max = a.Max, a.Min + } + if a.Min == a.Max { + a.Min-- + a.Max++ + } +} + +// LinearScale an be used as the value of an Axis.Scale function to +// set the axis to a standard linear scale. +type LinearScale struct{} + +var _ Normalizer = LinearScale{} + +// Normalize returns the fractional distance of x between min and max. +func (LinearScale) Normalize(min, max, x float64) float64 { + return (x - min) / (max - min) +} + +// LogScale can be used as the value of an Axis.Scale function to +// set the axis to a log scale. +type LogScale struct{} + +var _ Normalizer = LogScale{} + +// Normalize returns the fractional logarithmic distance of +// x between min and max. +func (LogScale) Normalize(min, max, x float64) float64 { + logMin := log(min) + return (log(x) - logMin) / (log(max) - logMin) +} + +// Norm returns the value of x, given in the data coordinate +// system, normalized to its distance as a fraction of the +// range of this axis. For example, if x is a.Min then the return +// value is 0, and if x is a.Max then the return value is 1. +func (a *Axis) Norm(x float64) float64 { + return a.Scale.Normalize(a.Min, a.Max, x) +} + +// drawTicks returns true if the tick marks should be drawn. +func (a *Axis) drawTicks() bool { + return a.Tick.Width > 0 && a.Tick.Length > 0 +} + +// A horizontalAxis draws horizontally across the bottom +// of a plot. +type horizontalAxis struct { + Axis +} + +// size returns the height of the axis. +func (a *horizontalAxis) size() (h vg.Length) { + if a.Label.Text != "" { + h -= a.Label.Font.Extents().Descent + h += a.Label.Height(a.Label.Text) + } + if marks := a.Tick.Marker.Ticks(a.Min, a.Max); len(marks) > 0 { + if a.drawTicks() { + h += a.Tick.Length + } + h += tickLabelHeight(a.Tick.Label, marks) + } + h += a.Width / 2 + h += a.Padding + return +} + +// draw draws the axis along the lower edge of a draw.Canvas. +func (a *horizontalAxis) draw(c draw.Canvas) { + y := c.Min.Y + if a.Label.Text != "" { + y -= a.Label.Font.Extents().Descent + c.FillText(a.Label.TextStyle, vg.Point{X: c.Center().X, Y: y}, a.Label.Text) + y += a.Label.Height(a.Label.Text) + } + + marks := a.Tick.Marker.Ticks(a.Min, a.Max) + ticklabelheight := tickLabelHeight(a.Tick.Label, marks) + for _, t := range marks { + x := c.X(a.Norm(t.Value)) + if !c.ContainsX(x) || t.IsMinor() { + continue + } + c.FillText(a.Tick.Label, vg.Point{X: x, Y: y + ticklabelheight}, t.Label) + } + + if len(marks) > 0 { + y += ticklabelheight + } else { + y += a.Width / 2 + } + + if len(marks) > 0 && a.drawTicks() { + len := a.Tick.Length + for _, t := range marks { + x := c.X(a.Norm(t.Value)) + if !c.ContainsX(x) { + continue + } + start := t.lengthOffset(len) + c.StrokeLine2(a.Tick.LineStyle, x, y+start, x, y+len) + } + y += len + } + + c.StrokeLine2(a.LineStyle, c.Min.X, y, c.Max.X, y) +} + +// GlyphBoxes returns the GlyphBoxes for the tick labels. +func (a *horizontalAxis) GlyphBoxes(*Plot) (boxes []GlyphBox) { + for _, t := range a.Tick.Marker.Ticks(a.Min, a.Max) { + if t.IsMinor() { + continue + } + w := a.Tick.Label.Width(t.Label) + box := GlyphBox{ + X: a.Norm(t.Value), + Rectangle: vg.Rectangle{ + Min: vg.Point{X: -w / 2}, + Max: vg.Point{X: w / 2}, + }, + } + boxes = append(boxes, box) + } + return +} + +// A verticalAxis is drawn vertically up the left side of a plot. +type verticalAxis struct { + Axis +} + +// size returns the width of the axis. +func (a *verticalAxis) size() (w vg.Length) { + if a.Label.Text != "" { + w -= a.Label.Font.Extents().Descent + w += a.Label.Height(a.Label.Text) + } + if marks := a.Tick.Marker.Ticks(a.Min, a.Max); len(marks) > 0 { + if lwidth := tickLabelWidth(a.Tick.Label, marks); lwidth > 0 { + w += lwidth + w += a.Label.Width(" ") + } + if a.drawTicks() { + w += a.Tick.Length + } + } + w += a.Width / 2 + w += a.Padding + return +} + +// draw draws the axis along the left side of a draw.Canvas. +func (a *verticalAxis) draw(c draw.Canvas) { + x := c.Min.X + if a.Label.Text != "" { + sty := a.Label.TextStyle + sty.Rotation += math.Pi / 2 + x += a.Label.Height(a.Label.Text) + c.FillText(sty, vg.Point{X: x, Y: c.Center().Y}, a.Label.Text) + x += -a.Label.Font.Extents().Descent + } + marks := a.Tick.Marker.Ticks(a.Min, a.Max) + if w := tickLabelWidth(a.Tick.Label, marks); len(marks) > 0 && w > 0 { + x += w + } + major := false + for _, t := range marks { + y := c.Y(a.Norm(t.Value)) + if !c.ContainsY(y) || t.IsMinor() { + continue + } + c.FillText(a.Tick.Label, vg.Point{X: x, Y: y}, t.Label) + major = true + } + if major { + x += a.Tick.Label.Width(" ") + } + if a.drawTicks() && len(marks) > 0 { + len := a.Tick.Length + for _, t := range marks { + y := c.Y(a.Norm(t.Value)) + if !c.ContainsY(y) { + continue + } + start := t.lengthOffset(len) + c.StrokeLine2(a.Tick.LineStyle, x+start, y, x+len, y) + } + x += len + } + c.StrokeLine2(a.LineStyle, x, c.Min.Y, x, c.Max.Y) +} + +// GlyphBoxes returns the GlyphBoxes for the tick labels +func (a *verticalAxis) GlyphBoxes(*Plot) (boxes []GlyphBox) { + for _, t := range a.Tick.Marker.Ticks(a.Min, a.Max) { + if t.IsMinor() { + continue + } + h := a.Tick.Label.Height(t.Label) + box := GlyphBox{ + Y: a.Norm(t.Value), + Rectangle: vg.Rectangle{ + Min: vg.Point{Y: -h / 2}, + Max: vg.Point{Y: h / 2}, + }, + } + boxes = append(boxes, box) + } + return +} + +// DefaultTicks is suitable for the Tick.Marker field of an Axis, +// it returns a resonable default set of tick marks. +type DefaultTicks struct{} + +var _ Ticker = DefaultTicks{} + +// Ticks returns Ticks in a specified range +func (DefaultTicks) Ticks(min, max float64) (ticks []Tick) { + const SuggestedTicks = 3 + if max < min { + panic("illegal range") + } + tens := math.Pow10(int(math.Floor(math.Log10(max - min)))) + n := (max - min) / tens + for n < SuggestedTicks { + tens /= 10 + n = (max - min) / tens + } + + majorMult := int(n / SuggestedTicks) + switch majorMult { + case 7: + majorMult = 6 + case 9: + majorMult = 8 + } + majorDelta := float64(majorMult) * tens + val := math.Floor(min/majorDelta) * majorDelta + prec := precisionOf(majorDelta) + for val <= max { + if val >= min && val <= max { + ticks = append(ticks, Tick{Value: val, Label: formatFloatTick(val, prec)}) + } + if math.Nextafter(val, val+majorDelta) == val { + break + } + val += majorDelta + } + + minorDelta := majorDelta / 2 + switch majorMult { + case 3, 6: + minorDelta = majorDelta / 3 + case 5: + minorDelta = majorDelta / 5 + } + + val = math.Floor(min/minorDelta) * minorDelta + for val <= max { + found := false + for _, t := range ticks { + if t.Value == val { + found = true + } + } + if val >= min && val <= max && !found { + ticks = append(ticks, Tick{Value: val}) + } + if math.Nextafter(val, val+minorDelta) == val { + break + } + val += minorDelta + } + return +} + +// LogTicks is suitable for the Tick.Marker field of an Axis, +// it returns tick marks suitable for a log-scale axis. +type LogTicks struct{} + +var _ Ticker = LogTicks{} + +// Ticks returns Ticks in a specified range +func (LogTicks) Ticks(min, max float64) []Tick { + var ticks []Tick + val := math.Pow10(int(math.Floor(math.Log10(min)))) + if min <= 0 { + panic("Values must be greater than 0 for a log scale.") + } + prec := precisionOf(max) + for val < max*10 { + for i := 1; i < 10; i++ { + tick := Tick{Value: val * float64(i)} + if i == 1 { + tick.Label = formatFloatTick(val*float64(i), prec) + } + ticks = append(ticks, tick) + } + val *= 10 + } + tick := Tick{Value: val, Label: formatFloatTick(val, prec)} + ticks = append(ticks, tick) + return ticks +} + +// ConstantTicks is suitable for the Tick.Marker field of an Axis. +// This function returns the given set of ticks. +type ConstantTicks []Tick + +var _ Ticker = ConstantTicks{} + +// Ticks returns Ticks in a specified range +func (ts ConstantTicks) Ticks(float64, float64) []Tick { + return ts +} + +// UnixTimeTicks is suitable for axes representing time values. +// UnixTimeTicks expects values in Unix time seconds. +type UnixTimeTicks struct { + // Ticker is used to generate a set of ticks. + // If nil, DefaultTicks will be used. + Ticker Ticker + + // Format is the textual representation of the time value. + // If empty, time.RFC3339 will be used + Format string +} + +var _ Ticker = UnixTimeTicks{} + +// Ticks implements plot.Ticker. +func (utt UnixTimeTicks) Ticks(min, max float64) []Tick { + if utt.Ticker == nil { + utt.Ticker = DefaultTicks{} + } + if utt.Format == "" { + utt.Format = time.RFC3339 + } + + ticks := utt.Ticker.Ticks(min, max) + for i := range ticks { + tick := &ticks[i] + if tick.Label == "" { + continue + } + t := time.Unix(int64(tick.Value), 0) + tick.Label = t.Format(utt.Format) + } + return ticks +} + +// A Tick is a single tick mark on an axis. +type Tick struct { + // Value is the data value marked by this Tick. + Value float64 + + // Label is the text to display at the tick mark. + // If Label is an empty string then this is a minor + // tick mark. + Label string +} + +// IsMinor returns true if this is a minor tick mark. +func (t Tick) IsMinor() bool { + return t.Label == "" +} + +// lengthOffset returns an offset that should be added to the +// tick mark's line to accout for its length. I.e., the start of +// the line for a minor tick mark must be shifted by half of +// the length. +func (t Tick) lengthOffset(len vg.Length) vg.Length { + if t.IsMinor() { + return len / 2 + } + return 0 +} + +// tickLabelHeight returns height of the tick mark labels. +func tickLabelHeight(sty draw.TextStyle, ticks []Tick) vg.Length { + maxHeight := vg.Length(0) + for _, t := range ticks { + if t.IsMinor() { + continue + } + r := sty.Rectangle(t.Label) + h := r.Max.Y - r.Min.Y + if h > maxHeight { + maxHeight = h + } + } + return maxHeight +} + +// tickLabelWidth returns the width of the widest tick mark label. +func tickLabelWidth(sty draw.TextStyle, ticks []Tick) vg.Length { + maxWidth := vg.Length(0) + for _, t := range ticks { + if t.IsMinor() { + continue + } + r := sty.Rectangle(t.Label) + w := r.Max.X - r.Min.X + if w > maxWidth { + maxWidth = w + } + } + return maxWidth +} + +func log(x float64) float64 { + if x <= 0 { + panic("Values must be greater than 0 for a log scale.") + } + return math.Log(x) +} + +// formatFloatTick returns a g-formated string representation of v +// to the specified precision. +func formatFloatTick(v float64, prec int) string { + return strconv.FormatFloat(floats.Round(v, prec), 'g', displayPrecision, 64) +} + +// precisionOf returns the precision needed to display x without e notation. +func precisionOf(x float64) int { + return int(math.Max(math.Ceil(-math.Log10(math.Abs(x))), displayPrecision)) +} diff --git a/vendor/github.com/gonum/plot/legend.go b/vendor/github.com/gonum/plot/legend.go new file mode 100644 index 00000000..11ff492e --- /dev/null +++ b/vendor/github.com/gonum/plot/legend.go @@ -0,0 +1,137 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plot + +import ( + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// A Legend gives a description of the meaning of different +// data elements of the plot. Each legend entry has a name +// and a thumbnail, where the thumbnail shows a small +// sample of the display style of the corresponding data. +type Legend struct { + // TextStyle is the style given to the legend + // entry texts. + draw.TextStyle + + // Padding is the amount of padding to add + // betweeneach entry of the legend. If Padding + // is zero then entries are spaced based on the + // font size. + Padding vg.Length + + // Top and Left specify the location of the legend. + // If Top is true the legend is located along the top + // edge of the plot, otherwise it is located along + // the bottom edge. If Left is true then the legend + // is located along the left edge of the plot, and the + // text is positioned after the icons, otherwise it is + // located along the right edge and the text is + // positioned before the icons. + Top, Left bool + + // XOffs and YOffs are added to the legend's + // final position. + XOffs, YOffs vg.Length + + // ThumbnailWidth is the width of legend thumbnails. + ThumbnailWidth vg.Length + + // entries are all of the legendEntries described + // by this legend. + entries []legendEntry +} + +// A legendEntry represents a single line of a legend, it +// has a name and an icon. +type legendEntry struct { + // text is the text associated with this entry. + text string + + // thumbs is a slice of all of the thumbnails styles + thumbs []Thumbnailer +} + +// Thumbnailer wraps the Thumbnail method, which +// draws the small image in a legend representing the +// style of data. +type Thumbnailer interface { + // Thumbnail draws an thumbnail representing + // a legend entry. The thumbnail will usually show + // a smaller representation of the style used + // to plot the corresponding data. + Thumbnail(c *draw.Canvas) +} + +// makeLegend returns a legend with the default +// parameter settings. +func makeLegend() (Legend, error) { + font, err := vg.MakeFont(DefaultFont, vg.Points(12)) + if err != nil { + return Legend{}, err + } + return Legend{ + ThumbnailWidth: vg.Points(20), + TextStyle: draw.TextStyle{Font: font}, + }, nil +} + +// draw draws the legend to the given draw.Canvas. +func (l *Legend) draw(c draw.Canvas) { + iconx := c.Min.X + sty := l.TextStyle + textx := iconx + l.ThumbnailWidth + sty.Rectangle(" ").Max.X + if !l.Left { + iconx = c.Max.X - l.ThumbnailWidth + textx = iconx - l.TextStyle.Rectangle(" ").Max.X + sty.XAlign-- + } + textx += l.XOffs + iconx += l.XOffs + + enth := l.entryHeight() + y := c.Max.Y - enth + if !l.Top { + y = c.Min.Y + (enth+l.Padding)*(vg.Length(len(l.entries))-1) + } + y += l.YOffs + + icon := &draw.Canvas{ + Canvas: c.Canvas, + Rectangle: vg.Rectangle{ + Min: vg.Point{X: iconx, Y: y}, + Max: vg.Point{X: iconx + l.ThumbnailWidth, Y: y + enth}, + }, + } + for _, e := range l.entries { + for _, t := range e.thumbs { + t.Thumbnail(icon) + } + yoffs := (enth - sty.Rectangle(e.text).Max.Y) / 2 + c.FillText(sty, vg.Point{X: textx, Y: icon.Min.Y + yoffs}, e.text) + icon.Min.Y -= enth + l.Padding + icon.Max.Y -= enth + l.Padding + } +} + +// entryHeight returns the height of the tallest legend +// entry text. +func (l *Legend) entryHeight() (height vg.Length) { + for _, e := range l.entries { + if h := l.TextStyle.Rectangle(e.text).Max.Y; h > height { + height = h + } + } + return +} + +// Add adds an entry to the legend with the given name. +// The entry's thumbnail is drawn as the composite of all of the +// thumbnails. +func (l *Legend) Add(name string, thumbs ...Thumbnailer) { + l.entries = append(l.entries, legendEntry{text: name, thumbs: thumbs}) +} diff --git a/vendor/github.com/gonum/plot/palette/hsva.go b/vendor/github.com/gonum/plot/palette/hsva.go new file mode 100644 index 00000000..cefa1ed1 --- /dev/null +++ b/vendor/github.com/gonum/plot/palette/hsva.go @@ -0,0 +1,116 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Copyright ©2011-2013 The bíogo Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package palette + +import ( + "image/color" + "math" +) + +// HSVA represents a Hue/Saturation/Value/Alpha color. +// H, S, V and A are valid within [0, 1]. +type HSVA struct { + H, S, V, A float64 +} + +// HSVAModel converts any color.Color to an HSVA color. +var HSVAModel = color.ModelFunc(hsvaModel) + +func hsvaModel(c color.Color) color.Color { + if _, ok := c.(HSVA); ok { + return c + } + return rgbaToHsva(c.RGBA()) +} + +// Convert r, g, b, a to HSVA +func rgbaToHsva(r, g, b, a uint32) HSVA { + red := float64(r) + blue := float64(b) + green := float64(g) + + max := math.Max(red, green) + max = math.Max(max, blue) + min := math.Min(red, green) + min = math.Min(min, blue) + chroma := max - min + + var hue float64 + switch { + case chroma == 0: + // This should really be math.NaN() since we have a 0 length vector, + // but 0 seems to be the convention and it may simplify imports in + // dependent packages. + hue = 0 + case max == red: + hue = math.Mod((green-blue)/chroma, 6) + case max == green: + hue = (blue-red)/chroma + 2 + case max == blue: + hue = (red-green)/chroma + 4 + } + + hue /= 6 + + var s float64 + if chroma != 0 { + s = chroma / max + } + + return HSVA{ + H: math.Mod(math.Mod(hue, 1)+1, 1), + S: s, + V: max / math.MaxUint16, + A: float64(a) / math.MaxUint16, + } +} + +// RGBA allows HSVAColor to satisfy the color.Color interface. +func (c HSVA) RGBA() (r, g, b, a uint32) { + var red, green, blue float64 + + a = uint32(math.MaxUint16 * c.A) + + if c.V == 0 { + return + } + + if c.S == 0 { + r, g, b = uint32(math.MaxUint16*c.V), uint32(math.MaxUint16*c.V), uint32(math.MaxUint16*c.V) + return + } + + chroma := c.V * c.S + m := c.V - chroma + + if !math.IsNaN(c.H) { + hue := math.Mod(c.H, 1) * 6 + x := chroma * (1 - math.Abs(math.Mod(hue, 2)-1)) + switch math.Floor(hue) { + case 0: + red, green = chroma, x + case 1: + red, green = x, chroma + case 2: + green, blue = chroma, x + case 3: + green, blue = x, chroma + case 4: + red, blue = x, chroma + case 5: + red, blue = chroma, x + } + } else { + red, green, blue = 0, 0, 0 + } + + r, g, b = uint32(math.MaxUint16*(red+m)), uint32(math.MaxUint16*(green+m)), uint32(math.MaxUint16*(blue+m)) + + return +} diff --git a/vendor/github.com/gonum/plot/palette/palette.go b/vendor/github.com/gonum/plot/palette/palette.go new file mode 100644 index 00000000..10b98e8a --- /dev/null +++ b/vendor/github.com/gonum/plot/palette/palette.go @@ -0,0 +1,123 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Copyright ©2013 The bíogo Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package palette provides basic color palette handling. +package palette + +import ( + "image/color" + "math" +) + +// Palette is a collection of colors ordered into a palette. +type Palette interface { + Colors() []color.Color +} + +// DivergingPalette is a collection of colors ordered into a palette with +// a critical class or break in the middle of the color range. +type DivergingPalette interface { + Palette + + // CriticalIndex returns the indices of the lightest + // (median) color or colors in the DivergingPalette. + // The low and high index values will be equal when + // there is a single median color. + CriticalIndex() (low, high int) +} + +// Hue represents a hue in HSV color space. Valid Hues are within [0, 1]. +type Hue float64 + +const ( + Red Hue = Hue(iota) / 6 + Yellow + Green + Cyan + Blue + Magenta +) + +// Complement returns the complementary hue of a Hue. +func (h Hue) Complement() Hue { return Hue(math.Mod(float64(h+0.5), 1)) } + +type palette []color.Color + +func (p palette) Colors() []color.Color { return p } + +type divergingPalette []color.Color + +func (p divergingPalette) Colors() []color.Color { return p } + +func (d divergingPalette) CriticalIndex() (low, high int) { + l := len(d) + return (l - 1) / 2, l / 2 +} + +// Rainbow returns a rainbow palette with the specified number of colors, saturation +// value and alpha, and hues in the specified range. +func Rainbow(colors int, start, end Hue, sat, val, alpha float64) Palette { + p := make(palette, colors) + hd := float64(end-start) / float64(colors-1) + c := HSVA{V: val, S: sat, A: alpha} + for i := range p { + c.H = float64(start) + float64(i)*hd + p[i] = color.NRGBAModel.Convert(c) + } + + return p +} + +// Heat returns a red to yellow palette with the specified number of colors and alpha. +func Heat(colors int, alpha float64) Palette { + p := make(palette, colors) + j := colors / 4 + i := colors - j + + hd := float64(Yellow-Red) / float64(i-1) + c := HSVA{V: 1, S: 1, A: alpha} + for k := range p[:i] { + c.H = float64(Red) + float64(k)*hd + p[k] = color.NRGBAModel.Convert(c) + } + if j == 0 { + return p + } + + c.H = float64(Yellow) + start, end := 1-1/(2*float64(j)), 1/(2*float64(j)) + c.S = start + sd := (end - start) / float64(j-1) + for k := range p[i:] { + c.S = start + float64(k)*sd + p[k+i] = color.NRGBAModel.Convert(c) + } + + return p +} + +// Radial return a diverging palette across the specified range, through white and with +// the specified alpha. +func Radial(colors int, start, end Hue, alpha float64) DivergingPalette { + p := make(divergingPalette, colors) + h := colors / 2 + c := HSVA{V: 1, A: alpha} + ds := 0.5 / float64(h) + for i := range p[:h] { + c.H = float64(start) + c.S = 0.5 - float64(i)*ds + p[i] = color.NRGBAModel.Convert(c) + c.H = float64(end) + p[len(p)-1-i] = color.NRGBAModel.Convert(c) + } + if colors%2 != 0 { + p[colors/2] = color.NRGBA{0xff, 0xff, 0xff, byte(math.MaxUint8 * alpha)} + } + + return p +} diff --git a/vendor/github.com/gonum/plot/plot.go b/vendor/github.com/gonum/plot/plot.go new file mode 100644 index 00000000..27b86530 --- /dev/null +++ b/vendor/github.com/gonum/plot/plot.go @@ -0,0 +1,488 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package plot provides an API for setting up plots, and primitives for +// drawing on plots. +// +// Plot is the basic type for creating a plot, setting the title, axis +// labels, legend, tick marks, etc. Types implementing the Plotter +// interface can draw to the data area of a plot using the primitives +// made available by this package. Some standard implementations +// of the Plotter interface can be found in the +// github.com/gonum/plot/plotter package +// which is documented here: +// http://godoc.org/github.com/gonum/plot/plotter +package plot + +import ( + "image/color" + "io" + "math" + "os" + "path/filepath" + "strings" + + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +var ( + // DefaultFont is the name of the default font for plot text. + DefaultFont = "Times-Roman" +) + +// Plot is the basic type representing a plot. +type Plot struct { + Title struct { + // Text is the text of the plot title. If + // Text is the empty string then the plot + // will not have a title. + Text string + + // Padding is the amount of padding + // between the bottom of the title and + // the top of the plot. + Padding vg.Length + + draw.TextStyle + } + + // BackgroundColor is the background color of the plot. + // The default is White. + BackgroundColor color.Color + + // X and Y are the horizontal and vertical axes + // of the plot respectively. + X, Y Axis + + // Legend is the plot's legend. + Legend Legend + + // plotters are drawn by calling their Plot method + // after the axes are drawn. + plotters []Plotter +} + +// Plotter is an interface that wraps the Plot method. +// Some standard implementations of Plotter can be +// found in the github.com/gonum/plot/plotter +// package, documented here: +// http://godoc.org/github.com/gonum/plot/plotter +type Plotter interface { + // Plot draws the data to a draw.Canvas. + Plot(draw.Canvas, *Plot) +} + +// DataRanger wraps the DataRange method. +type DataRanger interface { + // DataRange returns the range of X and Y values. + DataRange() (xmin, xmax, ymin, ymax float64) +} + +const ( + vertical = true + horizontal = false +) + +// New returns a new plot with some reasonable +// default settings. +func New() (*Plot, error) { + titleFont, err := vg.MakeFont(DefaultFont, 12) + if err != nil { + return nil, err + } + x, err := makeAxis(horizontal) + if err != nil { + return nil, err + } + y, err := makeAxis(vertical) + if err != nil { + return nil, err + } + legend, err := makeLegend() + if err != nil { + return nil, err + } + p := &Plot{ + BackgroundColor: color.White, + X: x, + Y: y, + Legend: legend, + } + p.Title.TextStyle = draw.TextStyle{ + Color: color.Black, + Font: titleFont, + XAlign: draw.XCenter, + YAlign: draw.YTop, + } + return p, nil +} + +// Add adds a Plotters to the plot. +// +// If the plotters implements DataRanger then the +// minimum and maximum values of the X and Y +// axes are changed if necessary to fit the range of +// the data. +// +// When drawing the plot, Plotters are drawn in the +// order in which they were added to the plot. +func (p *Plot) Add(ps ...Plotter) { + for _, d := range ps { + if x, ok := d.(DataRanger); ok { + xmin, xmax, ymin, ymax := x.DataRange() + p.X.Min = math.Min(p.X.Min, xmin) + p.X.Max = math.Max(p.X.Max, xmax) + p.Y.Min = math.Min(p.Y.Min, ymin) + p.Y.Max = math.Max(p.Y.Max, ymax) + } + } + + p.plotters = append(p.plotters, ps...) +} + +// Draw draws a plot to a draw.Canvas. +// +// Plotters are drawn in the order in which they were +// added to the plot. Plotters that implement the +// GlyphBoxer interface will have their GlyphBoxes +// taken into account when padding the plot so that +// none of their glyphs are clipped. +func (p *Plot) Draw(c draw.Canvas) { + if p.BackgroundColor != nil { + c.SetColor(p.BackgroundColor) + c.Fill(c.Rectangle.Path()) + } + if p.Title.Text != "" { + c.FillText(p.Title.TextStyle, vg.Point{X: c.Center().X, Y: c.Max.Y}, p.Title.Text) + c.Max.Y -= p.Title.Height(p.Title.Text) - p.Title.Font.Extents().Descent + c.Max.Y -= p.Title.Padding + } + + p.X.sanitizeRange() + x := horizontalAxis{p.X} + p.Y.sanitizeRange() + y := verticalAxis{p.Y} + + ywidth := y.size() + x.draw(padX(p, draw.Crop(c, ywidth, 0, 0, 0))) + xheight := x.size() + y.draw(padY(p, draw.Crop(c, 0, 0, xheight, 0))) + + dataC := padY(p, padX(p, draw.Crop(c, ywidth, 0, xheight, 0))) + for _, data := range p.plotters { + data.Plot(dataC, p) + } + + p.Legend.draw(draw.Crop(draw.Crop(c, ywidth, 0, 0, 0), 0, 0, xheight, 0)) +} + +// DataCanvas returns a new draw.Canvas that +// is the subset of the given draw area into which +// the plot data will be drawn. +func (p *Plot) DataCanvas(da draw.Canvas) draw.Canvas { + if p.Title.Text != "" { + da.Max.Y -= p.Title.Height(p.Title.Text) - p.Title.Font.Extents().Descent + da.Max.Y -= p.Title.Padding + } + p.X.sanitizeRange() + x := horizontalAxis{p.X} + p.Y.sanitizeRange() + y := verticalAxis{p.Y} + return padY(p, padX(p, draw.Crop(da, y.size(), x.size(), 0, 0))) +} + +// DrawGlyphBoxes draws red outlines around the plot's +// GlyphBoxes. This is intended for debugging. +func (p *Plot) DrawGlyphBoxes(c *draw.Canvas) { + c.SetColor(color.RGBA{R: 255, A: 255}) + for _, b := range p.GlyphBoxes(p) { + b.Rectangle.Min.X += c.X(b.X) + b.Rectangle.Min.Y += c.Y(b.Y) + c.Stroke(b.Rectangle.Path()) + } +} + +// padX returns a draw.Canvas that is padded horizontally +// so that glyphs will no be clipped. +func padX(p *Plot, c draw.Canvas) draw.Canvas { + glyphs := p.GlyphBoxes(p) + l := leftMost(&c, glyphs) + xAxis := horizontalAxis{p.X} + glyphs = append(glyphs, xAxis.GlyphBoxes(p)...) + r := rightMost(&c, glyphs) + + minx := c.Min.X - l.Min.X + maxx := c.Max.X - (r.Min.X + r.Size().X) + lx := vg.Length(l.X) + rx := vg.Length(r.X) + n := (lx*maxx - rx*minx) / (lx - rx) + m := ((lx-1)*maxx - rx*minx + minx) / (lx - rx) + return draw.Canvas{ + Canvas: vg.Canvas(c), + Rectangle: vg.Rectangle{ + Min: vg.Point{X: n, Y: c.Min.Y}, + Max: vg.Point{X: m, Y: c.Max.Y}, + }, + } +} + +// rightMost returns the right-most GlyphBox. +func rightMost(c *draw.Canvas, boxes []GlyphBox) GlyphBox { + maxx := c.Max.X + r := GlyphBox{X: 1} + for _, b := range boxes { + if b.Size().X <= 0 { + continue + } + if x := c.X(b.X) + b.Min.X + b.Size().X; x > maxx && b.X <= 1 { + maxx = x + r = b + } + } + return r +} + +// leftMost returns the left-most GlyphBox. +func leftMost(c *draw.Canvas, boxes []GlyphBox) GlyphBox { + minx := c.Min.X + l := GlyphBox{} + for _, b := range boxes { + if b.Size().X <= 0 { + continue + } + if x := c.X(b.X) + b.Min.X; x < minx && b.X >= 0 { + minx = x + l = b + } + } + return l +} + +// padY returns a draw.Canvas that is padded vertically +// so that glyphs will no be clipped. +func padY(p *Plot, c draw.Canvas) draw.Canvas { + glyphs := p.GlyphBoxes(p) + b := bottomMost(&c, glyphs) + yAxis := verticalAxis{p.Y} + glyphs = append(glyphs, yAxis.GlyphBoxes(p)...) + t := topMost(&c, glyphs) + + miny := c.Min.Y - b.Min.Y + maxy := c.Max.Y - (t.Min.Y + t.Size().Y) + by := vg.Length(b.Y) + ty := vg.Length(t.Y) + n := (by*maxy - ty*miny) / (by - ty) + m := ((by-1)*maxy - ty*miny + miny) / (by - ty) + return draw.Canvas{ + Canvas: vg.Canvas(c), + Rectangle: vg.Rectangle{ + Min: vg.Point{Y: n, X: c.Min.X}, + Max: vg.Point{Y: m, X: c.Max.X}, + }, + } +} + +// topMost returns the top-most GlyphBox. +func topMost(c *draw.Canvas, boxes []GlyphBox) GlyphBox { + maxy := c.Max.Y + t := GlyphBox{Y: 1} + for _, b := range boxes { + if b.Size().Y <= 0 { + continue + } + if y := c.Y(b.Y) + b.Min.Y + b.Size().Y; y > maxy && b.Y <= 1 { + maxy = y + t = b + } + } + return t +} + +// bottomMost returns the bottom-most GlyphBox. +func bottomMost(c *draw.Canvas, boxes []GlyphBox) GlyphBox { + miny := c.Min.Y + l := GlyphBox{} + for _, b := range boxes { + if b.Size().Y <= 0 { + continue + } + if y := c.Y(b.Y) + b.Min.Y; y < miny && b.Y >= 0 { + miny = y + l = b + } + } + return l +} + +// Transforms returns functions to transfrom +// from the x and y data coordinate system to +// the draw coordinate system of the given +// draw area. +func (p *Plot) Transforms(c *draw.Canvas) (x, y func(float64) vg.Length) { + x = func(x float64) vg.Length { return c.X(p.X.Norm(x)) } + y = func(y float64) vg.Length { return c.Y(p.Y.Norm(y)) } + return +} + +// GlyphBoxer wraps the GlyphBoxes method. +// It should be implemented by things that meet +// the Plotter interface that draw glyphs so that +// their glyphs are not clipped if drawn near the +// edge of the draw.Canvas. +// +// When computing padding, the plot ignores +// GlyphBoxes as follows: +// If the Size.X > 0 and the X value is not in range +// of the X axis then the box is ignored. +// If Size.Y > 0 and the Y value is not in range of +// the Y axis then the box is ignored. +// +// Also, GlyphBoxes with Size.X <= 0 are ignored +// when computing horizontal padding and +// GlyphBoxes with Size.Y <= 0 are ignored when +// computing vertical padding. This is useful +// for things like box plots and bar charts where +// the boxes and bars are considered to be glyphs +// in the X direction (and thus need padding), but +// may be clipped in the Y direction (and do not +// need padding). +type GlyphBoxer interface { + GlyphBoxes(*Plot) []GlyphBox +} + +// A GlyphBox describes the location of a glyph +// and the offset/size of its bounding box. +// +// If the Rectangle.Size().X is non-positive (<= 0) then +// the GlyphBox is ignored when computing the +// horizontal padding, and likewise with +// Rectangle.Size().Y and the vertical padding. +type GlyphBox struct { + // The glyph location in normalized coordinates. + X, Y float64 + + // Rectangle is the offset of the glyph's minimum drawing + // point relative to the glyph location and its size. + vg.Rectangle +} + +// GlyphBoxes returns the GlyphBoxes for all plot +// data that meet the GlyphBoxer interface. +func (p *Plot) GlyphBoxes(*Plot) (boxes []GlyphBox) { + for _, d := range p.plotters { + gb, ok := d.(GlyphBoxer) + if !ok { + continue + } + for _, b := range gb.GlyphBoxes(p) { + if b.Size().X > 0 && (b.X < 0 || b.X > 1) { + continue + } + if b.Size().Y > 0 && (b.Y < 0 || b.Y > 1) { + continue + } + boxes = append(boxes, b) + } + } + return +} + +// NominalX configures the plot to have a nominal X +// axis—an X axis with names instead of numbers. The +// X location corresponding to each name are the integers, +// e.g., the x value 0 is centered above the first name and +// 1 is above the second name, etc. Labels for x values +// that do not end up in range of the X axis will not have +// tick marks. +func (p *Plot) NominalX(names ...string) { + p.X.Tick.Width = 0 + p.X.Tick.Length = 0 + p.X.Width = 0 + p.Y.Padding = p.X.Tick.Label.Width(names[0]) / 2 + ticks := make([]Tick, len(names)) + for i, name := range names { + ticks[i] = Tick{float64(i), name} + } + p.X.Tick.Marker = ConstantTicks(ticks) +} + +// HideX configures the X axis so that it will not be drawn. +func (p *Plot) HideX() { + p.X.Tick.Length = 0 + p.X.Width = 0 + p.X.Tick.Marker = ConstantTicks([]Tick{}) +} + +// HideY configures the Y axis so that it will not be drawn. +func (p *Plot) HideY() { + p.Y.Tick.Length = 0 + p.Y.Width = 0 + p.Y.Tick.Marker = ConstantTicks([]Tick{}) +} + +// HideAxes hides the X and Y axes. +func (p *Plot) HideAxes() { + p.HideX() + p.HideY() +} + +// NominalY is like NominalX, but for the Y axis. +func (p *Plot) NominalY(names ...string) { + p.Y.Tick.Width = 0 + p.Y.Tick.Length = 0 + p.Y.Width = 0 + p.X.Padding = p.Y.Tick.Label.Height(names[0]) / 2 + ticks := make([]Tick, len(names)) + for i, name := range names { + ticks[i] = Tick{float64(i), name} + } + p.Y.Tick.Marker = ConstantTicks(ticks) +} + +// WriterTo returns an io.WriterTo that will write the plot as +// the specified image format. +// +// Supported formats are: +// +// eps, jpg|jpeg, pdf, png, svg, and tif|tiff. +func (p *Plot) WriterTo(w, h vg.Length, format string) (io.WriterTo, error) { + c, err := draw.NewFormattedCanvas(w, h, format) + if err != nil { + return nil, err + } + p.Draw(draw.New(c)) + return c, nil +} + +// Save saves the plot to an image file. The file format is determined +// by the extension. +// +// Supported extensions are: +// +// .eps, .jpg, .jpeg, .pdf, .png, .svg, .tif and .tiff. +func (p *Plot) Save(w, h vg.Length, file string) (err error) { + f, err := os.Create(file) + if err != nil { + return err + } + defer func() { + e := f.Close() + if err == nil { + err = e + } + }() + + format := strings.ToLower(filepath.Ext(file)) + if len(format) != 0 { + format = format[1:] + } + c, err := p.WriterTo(w, h, format) + if err != nil { + return err + } + + _, err = c.WriteTo(f) + return err +} diff --git a/vendor/github.com/gonum/plot/plotter/barchart.go b/vendor/github.com/gonum/plot/plotter/barchart.go new file mode 100644 index 00000000..b0ba36e6 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/barchart.go @@ -0,0 +1,211 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "errors" + "image/color" + "math" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// A BarChart presents grouped data with rectangular bars +// with lengths proportional to the data values. +type BarChart struct { + Values + + // Width is the width of the bars. + Width vg.Length + + // Color is the fill color of the bars. + Color color.Color + + // LineStyle is the style of the outline of the bars. + draw.LineStyle + + // Offset is added to the X location of each bar. + // When the Offset is zero, the bars are drawn + // centered at their X location. + Offset vg.Length + + // XMin is the X location of the first bar. XMin + // can be changed to move groups of bars + // down the X axis in order to make grouped + // bar charts. + XMin float64 + + // Horizontal dictates whether the bars should be in the vertical + // (default) or horizontal direction. If Horizontal is true, all + // X locations and distances referred to here will actually be Y + // locations and distances. + Horizontal bool + + // stackedOn is the bar chart upon which + // this bar chart is stacked. + stackedOn *BarChart +} + +// NewBarChart returns a new bar chart with a single bar for each value. +// The bars heights correspond to the values and their x locations correspond +// to the index of their value in the Valuer. +func NewBarChart(vs Valuer, width vg.Length) (*BarChart, error) { + if width <= 0 { + return nil, errors.New("Width parameter was not positive") + } + values, err := CopyValues(vs) + if err != nil { + return nil, err + } + return &BarChart{ + Values: values, + Width: width, + Color: color.Black, + LineStyle: DefaultLineStyle, + }, nil +} + +// BarHeight returns the maximum y value of the +// ith bar, taking into account any bars upon +// which it is stacked. +func (b *BarChart) BarHeight(i int) float64 { + ht := 0.0 + if b == nil { + return 0 + } + if i >= 0 && i < len(b.Values) { + ht += b.Values[i] + } + if b.stackedOn != nil { + ht += b.stackedOn.BarHeight(i) + } + return ht +} + +// StackOn stacks a bar chart on top of another, +// and sets the XMin and Offset to that of the +// chart upon which it is being stacked. +func (b *BarChart) StackOn(on *BarChart) { + b.XMin = on.XMin + b.Offset = on.Offset + b.stackedOn = on +} + +// Plot implements the plot.Plotter interface. +func (b *BarChart) Plot(c draw.Canvas, plt *plot.Plot) { + trCat, trVal := plt.Transforms(&c) + if b.Horizontal { + trCat, trVal = trVal, trCat + } + + for i, ht := range b.Values { + catVal := b.XMin + float64(i) + catMin := trCat(float64(catVal)) + if !b.Horizontal { + if !c.ContainsX(catMin) { + continue + } + } else { + if !c.ContainsY(catMin) { + continue + } + } + catMin = catMin - b.Width/2 + b.Offset + catMax := catMin + b.Width + bottom := b.stackedOn.BarHeight(i) + valMin := trVal(bottom) + valMax := trVal(bottom + ht) + + var pts []vg.Point + var poly []vg.Point + if !b.Horizontal { + pts = []vg.Point{ + {catMin, valMin}, + {catMin, valMax}, + {catMax, valMax}, + {catMax, valMin}, + } + poly = c.ClipPolygonY(pts) + } else { + pts = []vg.Point{ + {valMin, catMin}, + {valMin, catMax}, + {valMax, catMax}, + {valMax, catMin}, + } + poly = c.ClipPolygonX(pts) + } + c.FillPolygon(b.Color, poly) + + var outline [][]vg.Point + if !b.Horizontal { + pts = append(pts, vg.Point{X: catMin, Y: valMin}) + outline = c.ClipLinesY(pts) + } else { + pts = append(pts, vg.Point{X: valMin, Y: catMin}) + outline = c.ClipLinesX(pts) + } + c.StrokeLines(b.LineStyle, outline...) + } +} + +// DataRange implements the plot.DataRanger interface. +func (b *BarChart) DataRange() (xmin, xmax, ymin, ymax float64) { + catMin := b.XMin + catMax := catMin + float64(len(b.Values)-1) + + valMin := math.Inf(1) + valMax := math.Inf(-1) + for i, val := range b.Values { + valBot := b.stackedOn.BarHeight(i) + valTop := valBot + val + valMin = math.Min(valMin, math.Min(valBot, valTop)) + valMax = math.Max(valMax, math.Max(valBot, valTop)) + } + if !b.Horizontal { + return catMin, catMax, valMin, valMax + } + return valMin, valMax, catMin, catMax +} + +// GlyphBoxes implements the GlyphBoxer interface. +func (b *BarChart) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + boxes := make([]plot.GlyphBox, len(b.Values)) + for i := range b.Values { + cat := b.XMin + float64(i) + if !b.Horizontal { + boxes[i].X = plt.X.Norm(cat) + boxes[i].Rectangle = vg.Rectangle{ + Min: vg.Point{X: b.Offset - b.Width/2}, + Max: vg.Point{X: b.Offset + b.Width/2}, + } + } else { + boxes[i].Y = plt.Y.Norm(cat) + boxes[i].Rectangle = vg.Rectangle{ + Min: vg.Point{Y: b.Offset - b.Width/2}, + Max: vg.Point{Y: b.Offset + b.Width/2}, + } + } + } + return boxes +} + +// Thumbnail fulfills the plot.Thumbnailer interface. +func (b *BarChart) Thumbnail(c *draw.Canvas) { + pts := []vg.Point{ + {c.Min.X, c.Min.Y}, + {c.Min.X, c.Max.Y}, + {c.Max.X, c.Max.Y}, + {c.Max.X, c.Min.Y}, + } + poly := c.ClipPolygonY(pts) + c.FillPolygon(b.Color, poly) + + pts = append(pts, vg.Point{X: c.Min.X, Y: c.Min.Y}) + outline := c.ClipLinesY(pts) + c.StrokeLines(b.LineStyle, outline...) +} diff --git a/vendor/github.com/gonum/plot/plotter/boxplot.go b/vendor/github.com/gonum/plot/plotter/boxplot.go new file mode 100644 index 00000000..76985d85 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/boxplot.go @@ -0,0 +1,440 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "errors" + "math" + "sort" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// fiveStatPlot contains the shared fields for quartile +// and box-whisker plots. +type fiveStatPlot struct { + // Values is a copy of the values of the values used to + // create this box plot. + Values + + // Location is the location of the box along its axis. + Location float64 + + // Median is the median value of the data. + Median float64 + + // Quartile1 and Quartile3 are the first and + // third quartiles of the data respectively. + Quartile1, Quartile3 float64 + + // AdjLow and AdjHigh are the `adjacent' values + // on the low and high ends of the data. The + // adjacent values are the points to which the + // whiskers are drawn. + AdjLow, AdjHigh float64 + + // Min and Max are the extreme values of the data. + Min, Max float64 + + // Outside are the indices of Vs for the outside points. + Outside []int +} + +// BoxPlot implements the Plotter interface, drawing +// a boxplot to represent the distribution of values. +type BoxPlot struct { + fiveStatPlot + + // Offset is added to the x location of each box. + // When the Offset is zero, the boxes are drawn + // centered at their x location. + Offset vg.Length + + // Width is the width used to draw the box. + Width vg.Length + + // CapWidth is the width of the cap used to top + // off a whisker. + CapWidth vg.Length + + // GlyphStyle is the style of the outside point glyphs. + GlyphStyle draw.GlyphStyle + + // BoxStyle is the line style for the box. + BoxStyle draw.LineStyle + + // MedianStyle is the line style for the median line. + MedianStyle draw.LineStyle + + // WhiskerStyle is the line style used to draw the + // whiskers. + WhiskerStyle draw.LineStyle + + // Horizontal dictates whether the BoxPlot should be in the vertical + // (default) or horizontal direction. + Horizontal bool +} + +// NewBoxPlot returns a new BoxPlot that represents +// the distribution of the given values. The style of +// the box plot is that used for Tukey's schematic +// plots is ``Exploratory Data Analysis.'' +// +// An error is returned if the boxplot is created with +// no values. +// +// The fence values are 1.5x the interquartile before +// the first quartile and after the third quartile. Any +// value that is outside of the fences are drawn as +// Outside points. The adjacent values (to which the +// whiskers stretch) are the minimum and maximum +// values that are not outside the fences. +func NewBoxPlot(w vg.Length, loc float64, values Valuer) (*BoxPlot, error) { + if w < 0 { + return nil, errors.New("Negative boxplot width") + } + + b := new(BoxPlot) + var err error + if b.fiveStatPlot, err = newFiveStat(w, loc, values); err != nil { + return nil, err + } + + b.Width = w + b.CapWidth = 3 * w / 4 + + b.GlyphStyle = DefaultGlyphStyle + b.BoxStyle = DefaultLineStyle + b.MedianStyle = DefaultLineStyle + b.WhiskerStyle = draw.LineStyle{ + Width: vg.Points(0.5), + Dashes: []vg.Length{vg.Points(4), vg.Points(2)}, + } + + if len(b.Values) == 0 { + b.Width = 0 + b.GlyphStyle.Radius = 0 + b.BoxStyle.Width = 0 + b.MedianStyle.Width = 0 + b.WhiskerStyle.Width = 0 + } + + return b, nil +} + +func newFiveStat(w vg.Length, loc float64, values Valuer) (fiveStatPlot, error) { + var b fiveStatPlot + b.Location = loc + + var err error + if b.Values, err = CopyValues(values); err != nil { + return fiveStatPlot{}, err + } + + sorted := make(Values, len(b.Values)) + copy(sorted, b.Values) + sort.Float64s(sorted) + + if len(sorted) == 1 { + b.Median = sorted[0] + b.Quartile1 = sorted[0] + b.Quartile3 = sorted[0] + } else { + b.Median = median(sorted) + b.Quartile1 = median(sorted[:len(sorted)/2]) + b.Quartile3 = median(sorted[len(sorted)/2:]) + } + b.Min = sorted[0] + b.Max = sorted[len(sorted)-1] + + low := b.Quartile1 - 1.5*(b.Quartile3-b.Quartile1) + high := b.Quartile3 + 1.5*(b.Quartile3-b.Quartile1) + b.AdjLow = math.Inf(1) + b.AdjHigh = math.Inf(-1) + for i, v := range b.Values { + if v > high || v < low { + b.Outside = append(b.Outside, i) + continue + } + if v < b.AdjLow { + b.AdjLow = v + } + if v > b.AdjHigh { + b.AdjHigh = v + } + } + + return b, nil +} + +// median returns the median value from a +// sorted Values. +func median(vs Values) float64 { + if len(vs) == 1 { + return vs[0] + } + med := vs[len(vs)/2] + if len(vs)%2 == 0 { + med += vs[len(vs)/2-1] + med /= 2 + } + return med +} + +// Plot draws the BoxPlot on Canvas c and Plot plt. +func (b *BoxPlot) Plot(c draw.Canvas, plt *plot.Plot) { + if b.Horizontal { + b := &horizBoxPlot{b} + b.Plot(c, plt) + return + } + + trX, trY := plt.Transforms(&c) + x := trX(b.Location) + if !c.ContainsX(x) { + return + } + x += b.Offset + + med := trY(b.Median) + q1 := trY(b.Quartile1) + q3 := trY(b.Quartile3) + aLow := trY(b.AdjLow) + aHigh := trY(b.AdjHigh) + + box := c.ClipLinesY([]vg.Point{ + {x - b.Width/2, q1}, + {x - b.Width/2, q3}, + {x + b.Width/2, q3}, + {x + b.Width/2, q1}, + {x - b.Width/2 - b.BoxStyle.Width/2, q1}, + }) + c.StrokeLines(b.BoxStyle, box...) + + medLine := c.ClipLinesY([]vg.Point{ + {x - b.Width/2, med}, + {x + b.Width/2, med}, + }) + c.StrokeLines(b.MedianStyle, medLine...) + + cap := b.CapWidth / 2 + whisks := c.ClipLinesY([]vg.Point{{x, q3}, {x, aHigh}}, + []vg.Point{{x - cap, aHigh}, {x + cap, aHigh}}, + []vg.Point{{x, q1}, {x, aLow}}, + []vg.Point{{x - cap, aLow}, {x + cap, aLow}}) + c.StrokeLines(b.WhiskerStyle, whisks...) + + for _, out := range b.Outside { + y := trY(b.Value(out)) + if c.ContainsY(y) { + c.DrawGlyphNoClip(b.GlyphStyle, vg.Point{X: x, Y: y}) + } + } +} + +// DataRange returns the minimum and maximum x +// and y values, implementing the plot.DataRanger +// interface. +func (b *BoxPlot) DataRange() (float64, float64, float64, float64) { + if b.Horizontal { + b := &horizBoxPlot{b} + return b.DataRange() + } + return b.Location, b.Location, b.Min, b.Max +} + +// GlyphBoxes returns a slice of GlyphBoxes for the +// points and for the median line of the boxplot, +// implementing the plot.GlyphBoxer interface +func (b *BoxPlot) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + if b.Horizontal { + b := &horizBoxPlot{b} + return b.GlyphBoxes(plt) + } + + bs := make([]plot.GlyphBox, len(b.Outside)+1) + for i, out := range b.Outside { + bs[i].X = plt.X.Norm(b.Location) + bs[i].Y = plt.Y.Norm(b.Value(out)) + bs[i].Rectangle = b.GlyphStyle.Rectangle() + } + bs[len(bs)-1].X = plt.X.Norm(b.Location) + bs[len(bs)-1].Y = plt.Y.Norm(b.Median) + bs[len(bs)-1].Rectangle = vg.Rectangle{ + Min: vg.Point{X: b.Offset - (b.Width/2 + b.BoxStyle.Width/2)}, + Max: vg.Point{X: b.Offset + (b.Width/2 + b.BoxStyle.Width/2)}, + } + return bs +} + +// OutsideLabels returns a *Labels that will plot +// a label for each of the outside points. The +// labels are assumed to correspond to the +// points used to create the box plot. +func (b *BoxPlot) OutsideLabels(labels Labeller) (*Labels, error) { + if b.Horizontal { + b := &horizBoxPlot{b} + return b.OutsideLabels(labels) + } + + strs := make([]string, len(b.Outside)) + for i, out := range b.Outside { + strs[i] = labels.Label(out) + } + o := boxPlotOutsideLabels{b, strs} + ls, err := NewLabels(o) + if err != nil { + return nil, err + } + ls.XOffset += b.GlyphStyle.Radius / 2 + ls.YOffset += b.GlyphStyle.Radius / 2 + return ls, nil +} + +type boxPlotOutsideLabels struct { + box *BoxPlot + labels []string +} + +func (o boxPlotOutsideLabels) Len() int { + return len(o.box.Outside) +} + +func (o boxPlotOutsideLabels) XY(i int) (float64, float64) { + return o.box.Location, o.box.Value(o.box.Outside[i]) +} + +func (o boxPlotOutsideLabels) Label(i int) string { + return o.labels[i] +} + +// horizBoxPlot is like a regular BoxPlot, however, +// it draws horizontally instead of Vertically. +// TODO: Merge code for horizontal and vertical box plots as has been done for +// bar charts. +type horizBoxPlot struct{ *BoxPlot } + +func (b horizBoxPlot) Plot(c draw.Canvas, plt *plot.Plot) { + trX, trY := plt.Transforms(&c) + y := trY(b.Location) + if !c.ContainsY(y) { + return + } + y += b.Offset + + med := trX(b.Median) + q1 := trX(b.Quartile1) + q3 := trX(b.Quartile3) + aLow := trX(b.AdjLow) + aHigh := trX(b.AdjHigh) + + box := c.ClipLinesX([]vg.Point{ + {q1, y - b.Width/2}, + {q3, y - b.Width/2}, + {q3, y + b.Width/2}, + {q1, y + b.Width/2}, + {q1, y - b.Width/2 - b.BoxStyle.Width/2}, + }) + c.StrokeLines(b.BoxStyle, box...) + + medLine := c.ClipLinesX([]vg.Point{ + {med, y - b.Width/2}, + {med, y + b.Width/2}, + }) + c.StrokeLines(b.MedianStyle, medLine...) + + cap := b.CapWidth / 2 + whisks := c.ClipLinesX([]vg.Point{{q3, y}, {aHigh, y}}, + []vg.Point{{aHigh, y - cap}, {aHigh, y + cap}}, + []vg.Point{{q1, y}, {aLow, y}}, + []vg.Point{{aLow, y - cap}, {aLow, y + cap}}) + c.StrokeLines(b.WhiskerStyle, whisks...) + + for _, out := range b.Outside { + x := trX(b.Value(out)) + if c.ContainsX(x) { + c.DrawGlyphNoClip(b.GlyphStyle, vg.Point{X: x, Y: y}) + } + } +} + +// DataRange returns the minimum and maximum x +// and y values, implementing the plot.DataRanger +// interface. +func (b horizBoxPlot) DataRange() (float64, float64, float64, float64) { + return b.Min, b.Max, b.Location, b.Location +} + +// GlyphBoxes returns a slice of GlyphBoxes for the +// points and for the median line of the boxplot, +// implementing the plot.GlyphBoxer interface +func (b horizBoxPlot) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + bs := make([]plot.GlyphBox, len(b.Outside)+1) + for i, out := range b.Outside { + bs[i].X = plt.X.Norm(b.Value(out)) + bs[i].Y = plt.Y.Norm(b.Location) + bs[i].Rectangle = b.GlyphStyle.Rectangle() + } + bs[len(bs)-1].X = plt.X.Norm(b.Median) + bs[len(bs)-1].Y = plt.Y.Norm(b.Location) + bs[len(bs)-1].Rectangle = vg.Rectangle{ + Min: vg.Point{Y: b.Offset - (b.Width/2 + b.BoxStyle.Width/2)}, + Max: vg.Point{Y: b.Offset + (b.Width/2 + b.BoxStyle.Width/2)}, + } + return bs +} + +// OutsideLabels returns a *Labels that will plot +// a label for each of the outside points. The +// labels are assumed to correspond to the +// points used to create the box plot. +func (b *horizBoxPlot) OutsideLabels(labels Labeller) (*Labels, error) { + strs := make([]string, len(b.Outside)) + for i, out := range b.Outside { + strs[i] = labels.Label(out) + } + o := horizBoxPlotOutsideLabels{ + boxPlotOutsideLabels{b.BoxPlot, strs}, + } + ls, err := NewLabels(o) + if err != nil { + return nil, err + } + ls.XOffset += b.GlyphStyle.Radius / 2 + ls.YOffset += b.GlyphStyle.Radius / 2 + return ls, nil +} + +type horizBoxPlotOutsideLabels struct { + boxPlotOutsideLabels +} + +func (o horizBoxPlotOutsideLabels) XY(i int) (float64, float64) { + return o.box.Value(o.box.Outside[i]), o.box.Location +} + +// ValueLabels implements both the Valuer +// and Labeller interfaces. +type ValueLabels []struct { + Value float64 + Label string +} + +// Len returns the number of items. +func (vs ValueLabels) Len() int { + return len(vs) +} + +// Value returns the value of item i. +func (vs ValueLabels) Value(i int) float64 { + return vs[i].Value +} + +// Label returns the label of item i. +func (vs ValueLabels) Label(i int) string { + return vs[i].Label +} diff --git a/vendor/github.com/gonum/plot/plotter/bubbles.go b/vendor/github.com/gonum/plot/plotter/bubbles.go new file mode 100644 index 00000000..6ee0300c --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/bubbles.go @@ -0,0 +1,118 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "errors" + "image/color" + "math" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// Bubbles implements the Plotter interface, drawing +// a bubble plot of x, y, z triples where the z value +// determines the radius of the bubble. +type Bubbles struct { + XYZs + + // Color is the color of the bubbles. + color.Color + + // MinRadius and MaxRadius give the minimum + // and maximum bubble radius respectively. + // The radii of each bubble is interpolated linearly + // between these two values. + MinRadius, MaxRadius vg.Length + + // MinZ and MaxZ are the minimum and + // maximum Z values from the data. + MinZ, MaxZ float64 +} + +// NewBubbles creates as new bubble plot plotter for +// the given data, with a minimum and maximum +// bubble radius. +func NewBubbles(xyz XYZer, min, max vg.Length) (*Bubbles, error) { + cpy, err := CopyXYZs(xyz) + if err != nil { + return nil, err + } + if min > max { + return nil, errors.New("Min bubble radius is greater than the max radius") + } + minz := cpy[0].Z + maxz := cpy[0].Z + for _, d := range cpy { + minz = math.Min(minz, d.Z) + maxz = math.Max(maxz, d.Z) + } + return &Bubbles{ + XYZs: cpy, + MinRadius: min, + MaxRadius: max, + MinZ: minz, + MaxZ: maxz, + }, nil +} + +// Plot implements the Plot method of the plot.Plotter interface. +func (bs *Bubbles) Plot(c draw.Canvas, plt *plot.Plot) { + trX, trY := plt.Transforms(&c) + + c.SetColor(bs.Color) + + for _, d := range bs.XYZs { + x := trX(d.X) + y := trY(d.Y) + pt := vg.Point{X: x, Y: y} + if !c.Contains(pt) { + continue + } + + rad := bs.radius(d.Z) + + // draw a circle centered at x, y + var p vg.Path + p.Move(vg.Point{X: x + rad, Y: y}) + p.Arc(pt, rad, 0, 2*math.Pi) + p.Close() + c.Fill(p) + } +} + +// radius returns the radius of a bubble by linear interpolation. +func (bs *Bubbles) radius(z float64) vg.Length { + rng := bs.MaxRadius - bs.MinRadius + if bs.MaxZ == bs.MinZ { + return rng/2 + bs.MinRadius + } + d := (z - bs.MinZ) / (bs.MaxZ - bs.MinZ) + return vg.Length(d)*rng + bs.MinRadius +} + +// DataRange implements the DataRange method +// of the plot.DataRanger interface. +func (bs *Bubbles) DataRange() (xmin, xmax, ymin, ymax float64) { + return XYRange(XYValues{bs.XYZs}) +} + +// GlyphBoxes implements the GlyphBoxes method +// of the plot.GlyphBoxer interface. +func (bs *Bubbles) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + boxes := make([]plot.GlyphBox, len(bs.XYZs)) + for i, d := range bs.XYZs { + boxes[i].X = plt.X.Norm(d.X) + boxes[i].Y = plt.Y.Norm(d.Y) + r := bs.radius(d.Z) + boxes[i].Rectangle = vg.Rectangle{ + Min: vg.Point{X: -r, Y: -r}, + Max: vg.Point{X: +r, Y: +r}, + } + } + return boxes +} diff --git a/vendor/github.com/gonum/plot/plotter/conrec.go b/vendor/github.com/gonum/plot/plotter/conrec.go new file mode 100644 index 00000000..1d3e7277 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/conrec.go @@ -0,0 +1,202 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "math" +) + +type point struct { + X, Y float64 +} + +type line struct { + p1, p2 point +} + +func sect(h, p [5]float64, v1, v2 int) float64 { + return (h[v2]*p[v1] - h[v1]*p[v2]) / (h[v2] - h[v1]) +} + +// conrecLine performs an operation with a line at a given height derived +// from data over the 2D box interval (i, j) to (i+1, j+1). +type conrecLine func(i, j int, l line, height float64) + +// conrec is a Go translation of the C version of CONREC by Paul Bourke: +// http://paulbourke.net/papers/conrec/conrec.c +// +// conrec takes g, an m×n grid function, a sorted slice of contour heights +// and a conrecLine function. +// +// For full details of the algorithm, see the paper at +// http://paulbourke.net/papers/conrec/ +func conrec(g GridXYZ, heights []float64, fn conrecLine) { + var ( + p1, p2 point + + h [5]float64 + sh [5]int + xh, yh [5]float64 + + im = [4]int{0, 1, 1, 0} + jm = [4]int{0, 0, 1, 1} + + // We differ from conrec.c in the assignment of a single value + // in cases (castab in conrec.c). The value of castab[1][1][1] is + // 3, but we set cases[1][1][1] to 0. + // + // axiom: When we have a section of the grid where all the + // Z values are equal, and equal to a contour height we would + // expect to have no internal segments to draw. + // + // This is covered by case g) in Paul Bourke's description of + // the CONREC algorithm (a triangle with three vertices the lie + // on the contour level). He says, "... case g above has no really + // satisfactory solution and fortunately will occur rarely with + // real arithmetic." and then goes on to show the following image: + // + // http://paulbourke.net/papers/conrec/conrec3.gif + // + // which shows case g) in the set where no edge is drawn, agreeing + // with our axiom above. + // + // However, in the iteration over sh at conrec.c +44, a triangle + // with all vertices on the plane is given sh = {0,0,0,0,0} and + // then when the switch at conrec.c +93 happens, castab resolves + // that to case 3 for all values of m. + // + // This is fixed by replacing castab/cases[1][1][1] with 0. + cases = [3][3][3]int{ + {{0, 0, 8}, {0, 2, 5}, {7, 6, 9}}, + {{0, 3, 4}, {1, 0, 1}, {4, 3, 0}}, + {{9, 6, 7}, {5, 2, 0}, {8, 0, 0}}, + } + ) + + c, r := g.Dims() + for i := 0; i < c-1; i++ { + for j := 0; j < r-1; j++ { + dmin := math.Min( + math.Min(g.Z(i, j), g.Z(i, j+1)), + math.Min(g.Z(i+1, j), g.Z(i+1, j+1)), + ) + + dmax := math.Max( + math.Max(g.Z(i, j), g.Z(i, j+1)), + math.Max(g.Z(i+1, j), g.Z(i+1, j+1)), + ) + + if dmax < heights[0] || heights[len(heights)-1] < dmin { + continue + } + + for k := 0; k < len(heights); k++ { + if heights[k] < dmin || dmax < heights[k] { + continue + } + for m := 4; m >= 0; m-- { + if m > 0 { + h[m] = g.Z(i+im[m-1], j+jm[m-1]) - heights[k] + xh[m] = g.X(i + im[m-1]) + yh[m] = g.Y(j + jm[m-1]) + } else { + h[0] = 0.25 * (h[1] + h[2] + h[3] + h[4]) + xh[0] = 0.50 * (g.X(i) + g.X(i+1)) + yh[0] = 0.50 * (g.Y(j) + g.Y(j+1)) + } + if h[m] > 0 { + sh[m] = 1 + } else if h[m] < 0 { + sh[m] = -1 + } else { + sh[m] = 0 + } + } + + /* + Note: at this stage the relative heights of the corners and the + centre are in the h array, and the corresponding coordinates are + in the xh and yh arrays. The centre of the box is indexed by 0 + and the 4 corners by 1 to 4 as shown below. + Each triangle is then indexed by the parameter m, and the 3 + vertices of each triangle are indexed by parameters m1,m2,and m3. + It is assumed that the centre of the box is always vertex 2 + though this isimportant only when all 3 vertices lie exactly on + the same contour level, in which case only the side of the box + is drawn. + + vertex 4 +-------------------+ vertex 3 + | \ / | + | \ m-3 / | + | \ / | + | \ / | + | m=2 X m=2 | the centre is vertex 0 + | / \ | + | / \ | + | / m=1 \ | + | / \ | + vertex 1 +-------------------+ vertex 2 + */ + + // Scan each triangle in the box. + for m := 1; m <= 4; m++ { + m1 := m + const m2 = 0 + var m3 int + if m != 4 { + m3 = m + 1 + } else { + m3 = 1 + } + switch cases[sh[m1]+1][sh[m2]+1][sh[m3]+1] { + case 0: + continue + + case 1: // Line between vertices 1 and 2 + p1 = point{X: xh[m1], Y: yh[m1]} + p2 = point{X: xh[m2], Y: yh[m2]} + + case 2: // Line between vertices 2 and 3 + p1 = point{X: xh[m2], Y: yh[m2]} + p2 = point{X: xh[m3], Y: yh[m3]} + + case 3: // Line between vertices 3 and 1 + p1 = point{X: xh[m3], Y: yh[m3]} + p2 = point{X: xh[m1], Y: yh[m1]} + + case 4: // Line between vertex 1 and side 2-3 + p1 = point{X: xh[m1], Y: yh[m1]} + p2 = point{X: sect(h, xh, m2, m3), Y: sect(h, yh, m2, m3)} + + case 5: // Line between vertex 2 and side 3-1 + p1 = point{X: xh[m2], Y: yh[m2]} + p2 = point{X: sect(h, xh, m3, m1), Y: sect(h, yh, m3, m1)} + + case 6: // Line between vertex 3 and side 1-2 + p1 = point{X: xh[m3], Y: yh[m3]} + p2 = point{X: sect(h, xh, m1, m2), Y: sect(h, yh, m1, m2)} + + case 7: // Line between sides 1-2 and 2-3 + p1 = point{X: sect(h, xh, m1, m2), Y: sect(h, yh, m1, m2)} + p2 = point{X: sect(h, xh, m2, m3), Y: sect(h, yh, m2, m3)} + + case 8: // Line between sides 2-3 and 3-1 + p1 = point{X: sect(h, xh, m2, m3), Y: sect(h, yh, m2, m3)} + p2 = point{X: sect(h, xh, m3, m1), Y: sect(h, yh, m3, m1)} + + case 9: // Line between sides 3-1 and 1-2 + p1 = point{X: sect(h, xh, m3, m1), Y: sect(h, yh, m3, m1)} + p2 = point{X: sect(h, xh, m1, m2), Y: sect(h, yh, m1, m2)} + + default: + panic("cannot reach") + } + + fn(i, j, line{p1: p1, p2: p2}, heights[k]) + } + } + } + } +} diff --git a/vendor/github.com/gonum/plot/plotter/contour.go b/vendor/github.com/gonum/plot/plotter/contour.go new file mode 100644 index 00000000..d7d6c5c3 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/contour.go @@ -0,0 +1,660 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "image/color" + "math" + "sort" + + "github.com/gonum/plot" + "github.com/gonum/plot/palette" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// Contour implements the Plotter interface, drawing +// a contour plot of the values in the GridXYZ field. +type Contour struct { + GridXYZ GridXYZ + + // Levels describes the contour heights to plot. + Levels []float64 + + // LineStyles is the set of styles for contour + // lines. Line styles are are applied to each level + // in order, modulo the length of LineStyles. + LineStyles []draw.LineStyle + + // Palette is the color palette used to render + // the heat map. If Palette is nil or has no + // defined color, the Contour LineStyle color + // is used. + Palette palette.Palette + + // Underflow and Overflow are colors used to draw + // contours outside the dynamic range defined + // by Min and Max. + Underflow color.Color + Overflow color.Color + + // Min and Max define the dynamic range of the + // heat map. + Min, Max float64 +} + +// NewContour creates as new contour plotter for the given data, using +// the provided palette. If levels is nil, contours are generated for +// the 0.01, 0.05, 0.25, 0.5, 0.75, 0.95 and 0.99 quantiles. +// If g has Min and Max methods that return a float, those returned +// values are used to set the respective Contour fields. +func NewContour(g GridXYZ, levels []float64, p palette.Palette) *Contour { + var min, max float64 + type minMaxer interface { + Min() float64 + Max() float64 + } + switch g := g.(type) { + case minMaxer: + min, max = g.Min(), g.Max() + default: + min, max = math.Inf(1), math.Inf(-1) + c, r := g.Dims() + for i := 0; i < c; i++ { + for j := 0; j < r; j++ { + v := g.Z(i, j) + if math.IsNaN(v) { + continue + } + min = math.Min(min, v) + max = math.Max(max, v) + } + } + } + + if len(levels) == 0 { + levels = quantilesR7(g, defaultQuantiles) + } + + return &Contour{ + GridXYZ: g, + Levels: levels, + LineStyles: []draw.LineStyle{DefaultLineStyle}, + Palette: p, + Min: min, + Max: max, + } +} + +// Default quantiles for case where levels is not explicitly set. +var defaultQuantiles = []float64{0.01, 0.05, 0.25, 0.5, 0.75, 0.95, 0.99} + +// quantilesR7 returns the pth quantiles of the data in g according the the R-7 method. +// http://en.wikipedia.org/wiki/Quantile#Estimating_the_quantiles_of_a_population +func quantilesR7(g GridXYZ, p []float64) []float64 { + c, r := g.Dims() + data := make([]float64, 0, c*r) + for i := 0; i < c; i++ { + for j := 0; j < r; j++ { + if v := g.Z(i, j); !math.IsNaN(v) { + data = append(data, v) + } + } + } + sort.Float64s(data) + v := make([]float64, len(p)) + for j, q := range p { + if q == 1 { + v[j] = data[len(data)-1] + } + h := float64(len(data)-1) * q + i := int(h) + v[j] = data[i] + (h-math.Floor(h))*(data[i+1]-data[i]) + } + return v +} + +// naive is a debugging constant. If true, Plot performs no contour path +// reconstruction, instead rendering each path segment individually. +const naive = false + +// Plot implements the Plot method of the plot.Plotter interface. +func (h *Contour) Plot(c draw.Canvas, plt *plot.Plot) { + if naive { + h.naivePlot(c, plt) + return + } + + var pal []color.Color + if h.Palette != nil { + pal = h.Palette.Colors() + } + + trX, trY := plt.Transforms(&c) + + // Collate contour paths and draw them. + // + // The alternative naive approach is to draw each line segment as + // conrec returns it. The integrated path approach allows graphical + // optimisations and is necessary for contour fill shading. + cp := contourPaths(h.GridXYZ, h.Levels, trX, trY) + + // ps is a palette scaling factor to scale the palette uniformly + // across the given levels. This enables a discordance between the + // number of colours and the number of levels. Sorting is not + // necessary since contourPaths sorts the levels as a side effect. + ps := float64(len(pal)-1) / (h.Levels[len(h.Levels)-1] - h.Levels[0]) + if len(h.Levels) == 1 { + ps = 0 + } + + for i, z := range h.Levels { + if math.IsNaN(z) { + continue + } + for _, pa := range cp[z] { + if isLoop(pa) { + pa.Close() + } + + style := h.LineStyles[i%len(h.LineStyles)] + var col color.Color + switch { + case z < h.Min: + col = h.Underflow + case z > h.Max: + col = h.Overflow + case len(pal) == 0: + col = style.Color + default: + col = pal[int((z-h.Levels[0])*ps+0.5)] // Apply palette scaling. + } + if col != nil && style.Width != 0 { + c.SetLineStyle(style) + c.SetColor(col) + c.Stroke(pa) + } + } + } +} + +// naivePlot implements the a naive rendering approach for contours. +// It is here as a debugging mode since it simply draws line segments +// generated by conrec without further computation. +func (h *Contour) naivePlot(c draw.Canvas, plt *plot.Plot) { + var pal []color.Color + if h.Palette != nil { + pal = h.Palette.Colors() + } + + trX, trY := plt.Transforms(&c) + + // Sort levels prior to palette scaling since we can't depend on + // sorting as a side effect from calling contourPaths. + sort.Float64s(h.Levels) + // ps is a palette scaling factor to scale the palette uniformly + // across the given levels. This enables a discordance between the + // number of colours and the number of levels. + ps := float64(len(pal)-1) / (h.Levels[len(h.Levels)-1] - h.Levels[0]) + if len(h.Levels) == 1 { + ps = 0 + } + + levelMap := make(map[float64]int) + for i, z := range h.Levels { + levelMap[z] = i + } + + // Draw each line segment as conrec generates it. + var pa vg.Path + conrec(h.GridXYZ, h.Levels, func(_, _ int, l line, z float64) { + if math.IsNaN(z) { + return + } + + pa = pa[:0] + + x1, y1 := trX(l.p1.X), trY(l.p1.Y) + x2, y2 := trX(l.p2.X), trY(l.p2.Y) + + pt1 := vg.Point{X: x1, Y: y1} + pt2 := vg.Point{X: x2, Y: y2} + if !c.Contains(pt1) || !c.Contains(pt2) { + return + } + + pa.Move(pt1) + pa.Line(pt2) + pa.Close() + + style := h.LineStyles[levelMap[z]%len(h.LineStyles)] + var col color.Color + switch { + case z < h.Min: + col = h.Underflow + case z > h.Max: + col = h.Overflow + case len(pal) == 0: + col = style.Color + default: + col = pal[int((z-h.Levels[0])*ps+0.5)] // Apply palette scaling. + } + if col != nil && style.Width != 0 { + c.SetLineStyle(style) + c.SetColor(col) + c.Stroke(pa) + } + }) +} + +// DataRange implements the DataRange method +// of the plot.DataRanger interface. +func (h *Contour) DataRange() (xmin, xmax, ymin, ymax float64) { + c, r := h.GridXYZ.Dims() + return h.GridXYZ.X(0), h.GridXYZ.X(c - 1), h.GridXYZ.Y(0), h.GridXYZ.Y(r - 1) +} + +// GlyphBoxes implements the GlyphBoxes method +// of the plot.GlyphBoxer interface. +func (h *Contour) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + c, r := h.GridXYZ.Dims() + b := make([]plot.GlyphBox, 0, r*c) + for i := 0; i < c; i++ { + for j := 0; j < r; j++ { + b = append(b, plot.GlyphBox{ + X: plt.X.Norm(h.GridXYZ.X(i)), + Y: plt.Y.Norm(h.GridXYZ.Y(j)), + Rectangle: vg.Rectangle{ + Min: vg.Point{X: -2.5, Y: -2.5}, + Max: vg.Point{X: +2.5, Y: +2.5}, + }, + }) + } + } + return b +} + +// isLoop returns true iff a vg.Path is a closed loop. +func isLoop(p vg.Path) bool { + s := p[0] + e := p[len(p)-1] + return s.Pos == e.Pos +} + +// contourPaths returns a collection of vg.Paths describing contour lines based +// on the input data in m cut at the given levels. The trX and trY function +// are coordinate transforms. The returned map contains slices of paths keyed +// on the value of the contour level. contouPaths sorts levels ascending as a +// side effect. +func contourPaths(m GridXYZ, levels []float64, trX, trY func(float64) vg.Length) map[float64][]vg.Path { + sort.Float64s(levels) + + ends := make(map[float64]endMap) + conts := make(contourSet) + conrec(m, levels, func(_, _ int, l line, z float64) { + paths(l, z, ends, conts) + }) + ends = nil + + // TODO(kortschak): Check that all non-loop paths have + // both ends at boundary. If any end is not at a boundary + // it may have a partner near by. Find this partner and join + // the two conts by merging the near by ends at the mean + // location. This operation is done level by level to ensure + // close contours of different heights are not joined. + // A partner should be a float error different end, but I + // suspect that is is possible for a bi- or higher order + // furcation so it may be that the path ends at middle node + // of another path. This needs to be investigated. + + // Excise loops from crossed paths. + for c := range conts { + // Always try to do quick excision in production if possible. + c.exciseLoops(conts, true) + } + + // Build vg.Paths. + paths := make(map[float64][]vg.Path) + for c := range conts { + paths[c.z] = append(paths[c.z], c.path(trX, trY)) + } + + return paths +} + +// contourSet hold a working collection of contours. +type contourSet map[*contour]struct{} + +// endMap holds a working collection of available ends. +type endMap map[point]*contour + +// paths extends a conrecLine function to build a set of contours that represent +// paths along contour lines. It is used as the engine for a closure where ends +// and conts are closed around in a conrecLine function, and l and z are the +// line and height values provided by conrec. At the end of a conrec call, +// conts will contain a map keyed on the set of paths. +func paths(l line, z float64, ends map[float64]endMap, conts contourSet) { + zEnds, ok := ends[z] + if !ok { + zEnds = make(endMap) + ends[z] = zEnds + c := newContour(l, z) + zEnds[l.p1] = c + zEnds[l.p2] = c + conts[c] = struct{}{} + return + } + + c1, ok1 := zEnds[l.p1] + c2, ok2 := zEnds[l.p2] + + // New segment. + if !ok1 && !ok2 { + c := newContour(l, z) + zEnds[l.p1] = c + zEnds[l.p2] = c + conts[c] = struct{}{} + return + } + + if ok1 { + // Add l.p2 to end of l.p1's contour. + if !c1.extend(l, zEnds) { + panic("internal link") + } + } else if ok2 { + // Add l.p1 to end of l.p2's contour. + if !c2.extend(l, zEnds) { + panic("internal link") + } + } + + if c1 == c2 { + return + } + + // Join conts. + if ok1 && ok2 { + if !c1.connect(c2, zEnds) { + panic("internal link") + } + delete(conts, c2) + } +} + +// path is a set of points forming a path. +type path []point + +// contour holds a set of point lying sequentially along a contour line +// at height z. +type contour struct { + z float64 + + // backward and forward must each always have at least one entry. + backward path + forward path +} + +// newContour returns a contour starting with the end points of l for the +// height z. +func newContour(l line, z float64) *contour { + return &contour{z: z, forward: path{l.p1}, backward: path{l.p2}} +} + +func (c *contour) path(trX, trY func(float64) vg.Length) vg.Path { + var pa vg.Path + p := c.front() + pa.Move(vg.Point{X: trX(p.X), Y: trY(p.Y)}) + for i := len(c.backward) - 2; i >= 0; i-- { + p = c.backward[i] + pa.Line(vg.Point{X: trX(p.X), Y: trY(p.Y)}) + } + for _, p := range c.forward { + pa.Line(vg.Point{X: trX(p.X), Y: trY(p.Y)}) + } + + return pa +} + +// front returns the first point in the contour. +func (c *contour) front() point { return c.backward[len(c.backward)-1] } + +// back returns the last point in the contour +func (c *contour) back() point { return c.forward[len(c.forward)-1] } + +// extend adds the line l to the contour, updating the ends map. It returns +// a boolean indicating whether the extension was successful. +func (c *contour) extend(l line, ends endMap) (ok bool) { + switch c.front() { + case l.p1: + c.backward = append(c.backward, l.p2) + delete(ends, l.p1) + ends[l.p2] = c + return true + case l.p2: + c.backward = append(c.backward, l.p1) + delete(ends, l.p2) + ends[l.p1] = c + return true + } + + switch c.back() { + case l.p1: + c.forward = append(c.forward, l.p2) + delete(ends, l.p1) + ends[l.p2] = c + return true + case l.p2: + c.forward = append(c.forward, l.p1) + delete(ends, l.p2) + ends[l.p1] = c + return true + } + + return false +} + +// reverse reverses the order of the point in a path and returns it. +func (p path) reverse() path { + for i, j := 0, len(p)-1; i < j; i, j = i+1, j-1 { + p[i], p[j] = p[j], p[i] + } + return p +} + +// connect connects the contour b with the receiver, updating the ends map. +// It returns a boolean indicating whether the connection was successful. +func (c *contour) connect(b *contour, ends endMap) (ok bool) { + switch c.front() { + case b.front(): + delete(ends, c.front()) + ends[b.back()] = c + c.backward = append(c.backward, b.backward.reverse()[1:]...) + c.backward = append(c.backward, b.forward...) + return true + case b.back(): + delete(ends, c.front()) + ends[b.front()] = c + c.backward = append(c.backward, b.forward.reverse()[1:]...) + c.backward = append(c.backward, b.backward...) + return true + } + + switch c.back() { + case b.front(): + delete(ends, c.back()) + ends[b.back()] = c + c.forward = append(c.forward, b.backward.reverse()[1:]...) + c.forward = append(c.forward, b.forward...) + return true + case b.back(): + delete(ends, c.back()) + ends[b.front()] = c + c.forward = append(c.forward, b.forward.reverse()[1:]...) + c.forward = append(c.forward, b.backward...) + return true + } + + return false +} + +// exciseLoops finds loops within the contour that do not include the +// start and end. Loops are removed from the contour and added to the +// contour set. Loop detection is performed by Johnson's algorithm for +// finding elementary cycles. +func (c *contour) exciseLoops(conts contourSet, quick bool) { + if quick { + // Find cases we can guarantee don't need + // a complete analysis. + seen := make(map[point]struct{}) + var crossOvers int + for _, p := range c.backward { + if _, ok := seen[p]; ok { + crossOvers++ + } + seen[p] = struct{}{} + } + for _, p := range c.forward[:len(c.forward)-1] { + if _, ok := seen[p]; ok { + crossOvers++ + } + seen[p] = struct{}{} + } + switch crossOvers { + case 0: + return + case 1: + c.exciseQuick(conts) + return + } + } + + wp := append(c.backward.reverse(), c.forward...) + g := graphFrom(wp) + cycles := cyclesIn(g) + if len(cycles) == 0 { + // No further work to do but clean up after ourselves. + // We should not have reached here. + c.backward.reverse() + return + } + delete(conts, c) + + // Put loops into the contour set. + for _, cyc := range cycles { + loop := wp.subpath(cyc) + conts[&contour{ + z: c.z, + backward: loop[:1:1], + forward: loop[1:], + }] = struct{}{} + } + + // Find non-loop paths and keep them. + g.remove(cycles) + paths := wp.linearPathsIn(g) + for _, p := range paths { + conts[&contour{ + z: c.z, + backward: p[:1:1], + forward: p[1:], + }] = struct{}{} + } +} + +// graphFrom returns a graph representing the point path p. +func graphFrom(p path) graph { + g := make([]set, len(p)) + seen := make(map[point]int) + for i, v := range p { + if _, ok := seen[v]; !ok { + seen[v] = i + } + } + + for i, v := range p { + e, ok := seen[v] + if ok && g[e] == nil { + g[e] = make(set) + } + if i < len(p)-1 { + g[e][seen[p[i+1]]] = struct{}{} + } + } + + return g +} + +// subpath returns a subpath given the slice of point indices +// into the path. +func (p path) subpath(i []int) path { + pa := make(path, 0, len(i)) + for _, n := range i { + pa = append(pa, p[n]) + } + return pa +} + +// linearPathsIn returns the linear paths in g created from p. +// If g contains any cycles linearPaths will panic. +func (p path) linearPathsIn(g graph) []path { + var pa []path + + var u int + for u < len(g) { + for ; u < len(g) && len(g[u]) == 0; u++ { + } + if u == len(g) { + return pa + } + var curr path + for { + if len(g[u]) == 0 { + curr = append(curr, p[u]) + pa = append(pa, curr) + if u == len(g)-1 { + return pa + } + break + } + if len(g[u]) > 1 { + panic("contour: not a linear path") + } + for v := range g[u] { + curr = append(curr, p[u]) + u = v + break + } + } + } + + return pa +} + +// exciseQuick is a heuristic approach to loop excision. It does not +// correctly identify loops in all cases, but those cases are likely +// to be rare. +func (c *contour) exciseQuick(conts contourSet) { + wp := append(c.backward.reverse(), c.forward...) + seen := make(map[point]int) + for j := 0; j < len(wp); { + p := wp[j] + if i, ok := seen[p]; ok && p != wp[0] && p != wp[len(wp)-1] { + conts[&contour{ + z: c.z, + backward: path{wp[i]}, + forward: append(path(nil), wp[i+1:j+1]...), + }] = struct{}{} + wp = append(wp[:i], wp[j:]...) + j = i + 1 + } else { + seen[p] = j + j++ + } + } + c.backward = c.backward[:1] + c.backward[0] = wp[0] + c.forward = wp[1:] +} diff --git a/vendor/github.com/gonum/plot/plotter/errbars.go b/vendor/github.com/gonum/plot/plotter/errbars.go new file mode 100644 index 00000000..23ba3905 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/errbars.go @@ -0,0 +1,232 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "math" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// DefaultCapWidth is the default width of error bar caps. +var DefaultCapWidth = vg.Points(5) + +// YErrorBars implements the plot.Plotter, plot.DataRanger, +// and plot.GlyphBoxer interfaces, drawing vertical error +// bars, denoting error in Y values. +type YErrorBars struct { + XYs + + // YErrors is a copy of the Y errors for each point. + YErrors + + // LineStyle is the style used to draw the error bars. + draw.LineStyle + + // CapWidth is the width of the caps drawn at the top + // of each error bar. + CapWidth vg.Length +} + +// NewYErrorBars returns a new YErrorBars plotter, or an error on failure. +// The error values from the YErrorer interface are interpreted as relative +// to the corresponding Y value. The errors for a given Y value are computed +// by taking the absolute value of the error returned by the YErrorer +// and subtracting the first and adding the second to the Y value. +func NewYErrorBars(yerrs interface { + XYer + YErrorer +}) (*YErrorBars, error) { + + errors := make(YErrors, yerrs.Len()) + for i := range errors { + errors[i].Low, errors[i].High = yerrs.YError(i) + if err := CheckFloats(errors[i].Low, errors[i].High); err != nil { + return nil, err + } + } + xys, err := CopyXYs(yerrs) + if err != nil { + return nil, err + } + + return &YErrorBars{ + XYs: xys, + YErrors: errors, + LineStyle: DefaultLineStyle, + CapWidth: DefaultCapWidth, + }, nil +} + +// Plot implements the Plotter interface, drawing labels. +func (e *YErrorBars) Plot(c draw.Canvas, p *plot.Plot) { + trX, trY := p.Transforms(&c) + for i, err := range e.YErrors { + x := trX(e.XYs[i].X) + ylow := trY(e.XYs[i].Y - math.Abs(err.Low)) + yhigh := trY(e.XYs[i].Y + math.Abs(err.High)) + + bar := c.ClipLinesY([]vg.Point{{x, ylow}, {x, yhigh}}) + c.StrokeLines(e.LineStyle, bar...) + e.drawCap(&c, x, ylow) + e.drawCap(&c, x, yhigh) + } +} + +// drawCap draws the cap if it is not clipped. +func (e *YErrorBars) drawCap(c *draw.Canvas, x, y vg.Length) { + if !c.Contains(vg.Point{X: x, Y: y}) { + return + } + c.StrokeLine2(e.LineStyle, x-e.CapWidth/2, y, x+e.CapWidth/2, y) +} + +// DataRange implements the plot.DataRanger interface. +func (e *YErrorBars) DataRange() (xmin, xmax, ymin, ymax float64) { + xmin, xmax = Range(XValues{e}) + ymin = math.Inf(1) + ymax = math.Inf(-1) + for i, err := range e.YErrors { + y := e.XYs[i].Y + ylow := y - math.Abs(err.Low) + yhigh := y + math.Abs(err.High) + ymin = math.Min(math.Min(math.Min(ymin, y), ylow), yhigh) + ymax = math.Max(math.Max(math.Max(ymax, y), ylow), yhigh) + } + return +} + +// GlyphBoxes implements the plot.GlyphBoxer interface. +func (e *YErrorBars) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + rect := vg.Rectangle{ + Min: vg.Point{ + X: -e.CapWidth / 2, + Y: -e.LineStyle.Width / 2, + }, + Max: vg.Point{ + X: +e.CapWidth / 2, + Y: +e.LineStyle.Width / 2, + }, + } + var bs []plot.GlyphBox + for i, err := range e.YErrors { + x := plt.X.Norm(e.XYs[i].X) + y := e.XYs[i].Y + bs = append(bs, + plot.GlyphBox{X: x, Y: plt.Y.Norm(y - err.Low), Rectangle: rect}, + plot.GlyphBox{X: x, Y: plt.Y.Norm(y + err.High), Rectangle: rect}) + } + return bs +} + +// XErrorBars implements the plot.Plotter, plot.DataRanger, +// and plot.GlyphBoxer interfaces, drawing horizontal error +// bars, denoting error in Y values. +type XErrorBars struct { + XYs + + // XErrors is a copy of the X errors for each point. + XErrors + + // LineStyle is the style used to draw the error bars. + draw.LineStyle + + // CapWidth is the width of the caps drawn at the top + // of each error bar. + CapWidth vg.Length +} + +// Returns a new XErrorBars plotter, or an error on failure. The error values +// from the XErrorer interface are interpreted as relative to the corresponding +// X value. The errors for a given X value are computed by taking the absolute +// value of the error returned by the XErrorer and subtracting the first and +// adding the second to the X value. +func NewXErrorBars(xerrs interface { + XYer + XErrorer +}) (*XErrorBars, error) { + + errors := make(XErrors, xerrs.Len()) + for i := range errors { + errors[i].Low, errors[i].High = xerrs.XError(i) + if err := CheckFloats(errors[i].Low, errors[i].High); err != nil { + return nil, err + } + } + xys, err := CopyXYs(xerrs) + if err != nil { + return nil, err + } + + return &XErrorBars{ + XYs: xys, + XErrors: errors, + LineStyle: DefaultLineStyle, + CapWidth: DefaultCapWidth, + }, nil +} + +// Plot implements the Plotter interface, drawing labels. +func (e *XErrorBars) Plot(c draw.Canvas, p *plot.Plot) { + trX, trY := p.Transforms(&c) + for i, err := range e.XErrors { + y := trY(e.XYs[i].Y) + xlow := trX(e.XYs[i].X - math.Abs(err.Low)) + xhigh := trX(e.XYs[i].X + math.Abs(err.High)) + + bar := c.ClipLinesX([]vg.Point{{xlow, y}, {xhigh, y}}) + c.StrokeLines(e.LineStyle, bar...) + e.drawCap(&c, xlow, y) + e.drawCap(&c, xhigh, y) + } +} + +// drawCap draws the cap if it is not clipped. +func (e *XErrorBars) drawCap(c *draw.Canvas, x, y vg.Length) { + if !c.Contains(vg.Point{X: x, Y: y}) { + return + } + c.StrokeLine2(e.LineStyle, x, y-e.CapWidth/2, x, y+e.CapWidth/2) +} + +// DataRange implements the plot.DataRanger interface. +func (e *XErrorBars) DataRange() (xmin, xmax, ymin, ymax float64) { + ymin, ymax = Range(YValues{e}) + xmin = math.Inf(1) + xmax = math.Inf(-1) + for i, err := range e.XErrors { + x := e.XYs[i].X + xlow := x - math.Abs(err.Low) + xhigh := x + math.Abs(err.High) + xmin = math.Min(math.Min(math.Min(xmin, x), xlow), xhigh) + xmax = math.Max(math.Max(math.Max(xmax, x), xlow), xhigh) + } + return +} + +// GlyphBoxes implements the plot.GlyphBoxer interface. +func (e *XErrorBars) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + rect := vg.Rectangle{ + Min: vg.Point{ + X: -e.LineStyle.Width / 2, + Y: -e.CapWidth / 2, + }, + Max: vg.Point{ + X: +e.LineStyle.Width / 2, + Y: +e.CapWidth / 2, + }, + } + var bs []plot.GlyphBox + for i, err := range e.XErrors { + x := e.XYs[i].X + y := plt.Y.Norm(e.XYs[i].Y) + bs = append(bs, + plot.GlyphBox{X: plt.X.Norm(x - err.Low), Y: y, Rectangle: rect}, + plot.GlyphBox{X: plt.X.Norm(x + err.High), Y: y, Rectangle: rect}) + } + return bs +} diff --git a/vendor/github.com/gonum/plot/plotter/functions.go b/vendor/github.com/gonum/plot/plotter/functions.go new file mode 100644 index 00000000..9c52886c --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/functions.go @@ -0,0 +1,52 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// Function implements the Plotter interface, +// drawing a line for the given function. +type Function struct { + F func(float64) float64 + Samples int + draw.LineStyle +} + +// NewFunction returns a Function that plots F using +// the default line style with 50 samples. +func NewFunction(f func(float64) float64) *Function { + return &Function{ + F: f, + Samples: 50, + LineStyle: DefaultLineStyle, + } +} + +// Plot implements the Plotter interface, drawing a line +// that connects each point in the Line. +func (f *Function) Plot(c draw.Canvas, p *plot.Plot) { + trX, trY := p.Transforms(&c) + + d := (p.X.Max - p.X.Min) / float64(f.Samples-1) + line := make([]vg.Point, f.Samples) + for i := range line { + x := p.X.Min + float64(i)*d + line[i].X = trX(x) + line[i].Y = trY(f.F(x)) + } + c.StrokeLines(f.LineStyle, c.ClipLinesXY(line)...) +} + +// Thumbnail draws a line in the given style down the +// center of a DrawArea as a thumbnail representation +// of the LineStyle of the function. +func (f Function) Thumbnail(c *draw.Canvas) { + y := c.Center().Y + c.StrokeLine2(f.LineStyle, c.Min.X, y, c.Max.X, y) +} diff --git a/vendor/github.com/gonum/plot/plotter/glyphbox.go b/vendor/github.com/gonum/plot/plotter/glyphbox.go new file mode 100644 index 00000000..275460d8 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/glyphbox.go @@ -0,0 +1,41 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "image/color" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// GlyphBoxes implements the Plotter interface, drawing +// all of the glyph boxes of the plot. This is intended for +// debugging. +type GlyphBoxes struct { + draw.LineStyle +} + +func NewGlyphBoxes() *GlyphBoxes { + g := new(GlyphBoxes) + g.Color = color.RGBA{R: 255, A: 255} + g.Width = vg.Points(0.25) + return g +} + +func (g GlyphBoxes) Plot(c draw.Canvas, plt *plot.Plot) { + for _, b := range plt.GlyphBoxes(plt) { + x := c.X(b.X) + b.Rectangle.Min.X + y := c.Y(b.Y) + b.Rectangle.Min.Y + c.StrokeLines(g.LineStyle, []vg.Point{ + {x, y}, + {x + b.Rectangle.Size().X, y}, + {x + b.Rectangle.Size().X, y + b.Rectangle.Size().Y}, + {x, y + b.Rectangle.Size().Y}, + {x, y}, + }) + } +} diff --git a/vendor/github.com/gonum/plot/plotter/grid.go b/vendor/github.com/gonum/plot/plotter/grid.go new file mode 100644 index 00000000..e56001e0 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/grid.go @@ -0,0 +1,68 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "image/color" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +var ( + // DefaultGridLineStyle is the default style for grid lines. + DefaultGridLineStyle = draw.LineStyle{ + Color: color.Gray{128}, + Width: vg.Points(0.25), + } +) + +// Grid implements the plot.Plotter interface, drawing +// a set of grid lines at the major tick marks. +type Grid struct { + // Vertical is the style of the vertical lines. + Vertical draw.LineStyle + + // Horizontal is the style of the horizontal lines. + Horizontal draw.LineStyle +} + +// NewGrid returns a new grid with both vertical and +// horizontal lines using the default grid line style. +func NewGrid() *Grid { + return &Grid{ + Vertical: DefaultGridLineStyle, + Horizontal: DefaultGridLineStyle, + } +} + +// Plot implements the plot.Plotter interface. +func (g *Grid) Plot(c draw.Canvas, plt *plot.Plot) { + trX, trY := plt.Transforms(&c) + + if g.Vertical.Color == nil { + goto horiz + } + for _, tk := range plt.X.Tick.Marker.Ticks(plt.X.Min, plt.X.Max) { + if tk.IsMinor() { + continue + } + x := trX(tk.Value) + c.StrokeLine2(g.Vertical, x, c.Min.Y, x, c.Min.Y+c.Size().Y) + } + +horiz: + if g.Horizontal.Color == nil { + return + } + for _, tk := range plt.Y.Tick.Marker.Ticks(plt.Y.Min, plt.Y.Max) { + if tk.IsMinor() { + continue + } + y := trY(tk.Value) + c.StrokeLine2(g.Horizontal, c.Min.X, y, c.Min.X+c.Size().X, y) + } +} diff --git a/vendor/github.com/gonum/plot/plotter/heat.go b/vendor/github.com/gonum/plot/plotter/heat.go new file mode 100644 index 00000000..0a0a4f0d --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/heat.go @@ -0,0 +1,213 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "image/color" + "math" + + "github.com/gonum/plot" + "github.com/gonum/plot/palette" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// GridXYZ describes three dimensional data where the X and Y +// coordinates are arranged on a rectangular grid. +type GridXYZ interface { + // Dims returns the dimensions of the grid. + Dims() (c, r int) + + // Z returns the value of a grid value at (c, r). + // It will panic if c or r are out of bounds for the grid. + Z(c, r int) float64 + + // X returns the coordinate for the column at the index x. + // It will panic if c is out of bounds for the grid. + X(c int) float64 + + // Y returns the coordinate for the row at the index r. + // It will panic if r is out of bounds for the grid. + Y(r int) float64 +} + +// HeatMap implements the Plotter interface, drawing +// a heat map of the values in the GridXYZ field. +type HeatMap struct { + GridXYZ GridXYZ + + // Palette is the color palette used to render + // the heat map. Palette must not be nil or + // return a zero length []color.Color. + Palette palette.Palette + + // Underflow and Overflow are colors used to fill + // heat map elements outside the dynamic range + // defined by Min and Max. + Underflow color.Color + Overflow color.Color + + // Min and Max define the dynamic range of the + // heat map. + Min, Max float64 +} + +// NewHeatMap creates as new heat map plotter for the given data, +// using the provided palette. If g has Min and Max methods that return +// a float, those returned values are used to set the respective HeatMap +// fields. +func NewHeatMap(g GridXYZ, p palette.Palette) *HeatMap { + var min, max float64 + type minMaxer interface { + Min() float64 + Max() float64 + } + switch g := g.(type) { + case minMaxer: + min, max = g.Min(), g.Max() + default: + min, max = math.Inf(1), math.Inf(-1) + c, r := g.Dims() + for i := 0; i < c; i++ { + for j := 0; j < r; j++ { + v := g.Z(i, j) + if math.IsNaN(v) { + continue + } + min = math.Min(min, v) + max = math.Max(max, v) + } + } + } + + return &HeatMap{ + GridXYZ: g, + Palette: p, + Min: min, + Max: max, + } +} + +// Plot implements the Plot method of the plot.Plotter interface. +func (h *HeatMap) Plot(c draw.Canvas, plt *plot.Plot) { + pal := h.Palette.Colors() + if len(pal) == 0 { + panic("heatmap: empty palette") + } + // ps scales the palette uniformly across the data range. + ps := float64(len(pal)-1) / (h.Max - h.Min) + + trX, trY := plt.Transforms(&c) + + var pa vg.Path + cols, rows := h.GridXYZ.Dims() + for i := 0; i < cols; i++ { + + var right, left float64 + switch i { + case 0: + right = (h.GridXYZ.X(i+1) - h.GridXYZ.X(i)) / 2 + left = -right + case cols - 1: + right = (h.GridXYZ.X(i) - h.GridXYZ.X(i-1)) / 2 + left = -right + default: + right = (h.GridXYZ.X(i+1) - h.GridXYZ.X(i)) / 2 + left = -(h.GridXYZ.X(i) - h.GridXYZ.X(i-1)) / 2 + } + + for j := 0; j < rows; j++ { + v := h.GridXYZ.Z(i, j) + if math.IsNaN(v) || math.IsInf(v, 0) { + continue + } + + pa = pa[:0] + + var up, down float64 + switch j { + case 0: + up = (h.GridXYZ.Y(j+1) - h.GridXYZ.Y(j)) / 2 + down = -up + case rows - 1: + up = (h.GridXYZ.Y(j) - h.GridXYZ.Y(j-1)) / 2 + down = -up + default: + up = (h.GridXYZ.Y(j+1) - h.GridXYZ.Y(j)) / 2 + down = -(h.GridXYZ.Y(j) - h.GridXYZ.Y(j-1)) / 2 + } + + x, y := trX(h.GridXYZ.X(i)+left), trY(h.GridXYZ.Y(j)+down) + dx, dy := trX(h.GridXYZ.X(i)+right), trY(h.GridXYZ.Y(j)+up) + + if !c.Contains(vg.Point{X: x, Y: y}) || !c.Contains(vg.Point{X: dx, Y: dy}) { + continue + } + + pa.Move(vg.Point{X: x, Y: y}) + pa.Line(vg.Point{X: dx, Y: y}) + pa.Line(vg.Point{X: dx, Y: dy}) + pa.Line(vg.Point{X: x, Y: dy}) + pa.Close() + + var col color.Color + switch { + case v < h.Min: + col = h.Underflow + case v > h.Max: + col = h.Overflow + default: + col = pal[int((v-h.Min)*ps+0.5)] // Apply palette scaling. + } + if col != nil { + c.SetColor(col) + c.Fill(pa) + } + } + } +} + +// DataRange implements the DataRange method +// of the plot.DataRanger interface. +func (h *HeatMap) DataRange() (xmin, xmax, ymin, ymax float64) { + c, r := h.GridXYZ.Dims() + switch c { + case 1: // Make a unit length when there is no neighbour. + xmax = 0.5 + xmin = -0.5 + default: + xmax = h.GridXYZ.X(c-1) + (h.GridXYZ.X(c-1)-h.GridXYZ.X(c-2))/2 + xmin = h.GridXYZ.X(0) - (h.GridXYZ.X(1)-h.GridXYZ.X(0))/2 + } + switch r { + case 1: // Make a unit length when there is no neighbour. + ymax = 0.5 + ymin = -0.5 + default: + ymax = h.GridXYZ.Y(r-1) + (h.GridXYZ.Y(r-1)-h.GridXYZ.Y(r-2))/2 + ymin = h.GridXYZ.Y(0) - (h.GridXYZ.Y(1)-h.GridXYZ.Y(0))/2 + } + return xmin, xmax, ymin, ymax +} + +// GlyphBoxes implements the GlyphBoxes method +// of the plot.GlyphBoxer interface. +func (h *HeatMap) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + c, r := h.GridXYZ.Dims() + b := make([]plot.GlyphBox, 0, r*c) + for i := 0; i < c; i++ { + for j := 0; j < r; j++ { + b = append(b, plot.GlyphBox{ + X: plt.X.Norm(h.GridXYZ.X(i)), + Y: plt.Y.Norm(h.GridXYZ.Y(j)), + Rectangle: vg.Rectangle{ + Min: vg.Point{X: -5, Y: -5}, + Max: vg.Point{X: +5, Y: +5}, + }, + }) + } + } + return b +} diff --git a/vendor/github.com/gonum/plot/plotter/histogram.go b/vendor/github.com/gonum/plot/plotter/histogram.go new file mode 100644 index 00000000..b8664af5 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/histogram.go @@ -0,0 +1,195 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "errors" + "fmt" + "image/color" + "math" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// Histogram implements the Plotter interface, +// drawing a histogram of the data. +type Histogram struct { + // Bins is the set of bins for this histogram. + Bins []HistogramBin + + // Width is the width of each bin. + Width float64 + + // FillColor is the color used to fill each + // bar of the histogram. If the color is nil + // then the bars are not filled. + FillColor color.Color + + // LineStyle is the style of the outline of each + // bar of the histogram. + draw.LineStyle +} + +// NewHistogram returns a new histogram +// that represents the distribution of values +// using the given number of bins. +// +// Each y value is assumed to be the frequency +// count for the corresponding x. +// +// If the number of bins is non-positive than +// a reasonable default is used. +func NewHistogram(xy XYer, n int) (*Histogram, error) { + if n <= 0 { + return nil, errors.New("Histogram with non-positive number of bins") + } + bins, width := binPoints(xy, n) + return &Histogram{ + Bins: bins, + Width: width, + FillColor: color.Gray{128}, + LineStyle: DefaultLineStyle, + }, nil +} + +// NewHist returns a new histogram, as in +// NewHistogram, except that it accepts a Valuer +// instead of an XYer. +func NewHist(vs Valuer, n int) (*Histogram, error) { + return NewHistogram(unitYs{vs}, n) +} + +type unitYs struct { + Valuer +} + +func (u unitYs) XY(i int) (float64, float64) { + return u.Value(i), 1.0 +} + +// Plot implements the Plotter interface, drawing a line +// that connects each point in the Line. +func (h *Histogram) Plot(c draw.Canvas, p *plot.Plot) { + trX, trY := p.Transforms(&c) + + for _, bin := range h.Bins { + pts := []vg.Point{ + {trX(bin.Min), trY(0)}, + {trX(bin.Max), trY(0)}, + {trX(bin.Max), trY(bin.Weight)}, + {trX(bin.Min), trY(bin.Weight)}, + } + if h.FillColor != nil { + c.FillPolygon(h.FillColor, c.ClipPolygonXY(pts)) + } + pts = append(pts, vg.Point{X: trX(bin.Min), Y: trY(0)}) + c.StrokeLines(h.LineStyle, c.ClipLinesXY(pts)...) + } +} + +// DataRange returns the minimum and maximum X and Y values +func (h *Histogram) DataRange() (xmin, xmax, ymin, ymax float64) { + xmin = math.Inf(1) + xmax = math.Inf(-1) + ymax = math.Inf(-1) + for _, bin := range h.Bins { + if bin.Max > xmax { + xmax = bin.Max + } + if bin.Min < xmin { + xmin = bin.Min + } + if bin.Weight > ymax { + ymax = bin.Weight + } + } + return +} + +// Normalize normalizes the histogram so that the +// total area beneath it sums to a given value. +func (h *Histogram) Normalize(sum float64) { + mass := 0.0 + for _, b := range h.Bins { + mass += b.Weight + } + for i := range h.Bins { + h.Bins[i].Weight *= sum / (h.Width * mass) + } +} + +// Thumbnail draws a rectangle in the given style of the histogram. +func (h *Histogram) Thumbnail(c *draw.Canvas) { + ymin := c.Min.Y + ymax := c.Max.Y + xmin := c.Min.X + xmax := c.Max.X + + pts := []vg.Point{ + {xmin, ymin}, + {xmax, ymin}, + {xmax, ymax}, + {xmin, ymax}, + } + if h.FillColor != nil { + c.FillPolygon(h.FillColor, c.ClipPolygonXY(pts)) + } + pts = append(pts, vg.Point{X: xmin, Y: ymin}) + c.StrokeLines(h.LineStyle, c.ClipLinesXY(pts)...) +} + +// binPoints returns a slice containing the +// given number of bins, and the width of +// each bin. +// +// If the given number of bins is not positive +// then a reasonable default is used. The +// default is the square root of the sum of +// the y values. +func binPoints(xys XYer, n int) ([]HistogramBin, float64) { + xmin, xmax := Range(XValues{xys}) + if n <= 0 { + m := 0.0 + for i := 0; i < xys.Len(); i++ { + _, y := xys.XY(i) + m += math.Max(y, 1.0) + } + n = int(math.Ceil(math.Sqrt(m))) + } + if n < 1 || xmax <= xmin { + n = 1 + } + + bins := make([]HistogramBin, n) + + w := (xmax - xmin) / float64(n) + for i := range bins { + bins[i].Min = xmin + float64(i)*w + bins[i].Max = xmin + float64(i+1)*w + } + + for i := 0; i < xys.Len(); i++ { + x, y := xys.XY(i) + bin := int((x - xmin) / w) + if x == xmax { + bin = n - 1 + } + if bin < 0 || bin >= n { + panic(fmt.Sprintf("%g, xmin=%g, xmax=%g, w=%g, bin=%d, n=%d\n", + x, xmin, xmax, w, bin, n)) + } + bins[bin].Weight += y + } + return bins, w +} + +// A HistogramBin approximates the number of values +// within a range by a single number (the weight). +type HistogramBin struct { + Min, Max float64 + Weight float64 +} diff --git a/vendor/github.com/gonum/plot/plotter/image.go b/vendor/github.com/gonum/plot/plotter/image.go new file mode 100644 index 00000000..ce26b6ec --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/image.go @@ -0,0 +1,86 @@ +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "image" + "math" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// Image is a plotter that draws a scaled, raster image. +type Image struct { + img image.Image + cols int + rows int + xmin, xmax, dx float64 + ymin, ymax, dy float64 +} + +// NewImage creates a new image plotter. +// Image will plot img inside the rectangle defined by the +// (xmin, ymin) and (xmax, ymax) points given in the data space. +// The img will be scaled to fit inside the rectangle. +func NewImage(img image.Image, xmin, ymin, xmax, ymax float64) *Image { + bounds := img.Bounds() + cols := bounds.Dx() + rows := bounds.Dy() + dx := math.Abs(xmax-xmin) / float64(cols) + dy := math.Abs(ymax-ymin) / float64(rows) + return &Image{ + img: img, + cols: cols, + rows: rows, + xmin: xmin, + xmax: xmax, + dx: dx, + ymin: ymin, + ymax: ymax, + dy: dy, + } +} + +// Plot implements the Plot method of the plot.Plotter interface. +func (img *Image) Plot(c draw.Canvas, p *plot.Plot) { + trX, trY := p.Transforms(&c) + xmin := trX(img.xmin) + ymin := trY(img.ymin) + xmax := trX(img.xmax) + ymax := trY(img.ymax) + rect := vg.Rectangle{ + Min: vg.Point{X: xmin, Y: ymin}, + Max: vg.Point{X: xmax, Y: ymax}, + } + c.DrawImage(rect, img.img) +} + +// DataRange implements the DataRange method +// of the plot.DataRanger interface. +func (img *Image) DataRange() (xmin, xmax, ymin, ymax float64) { + return img.xmin, img.xmax, img.ymin, img.ymax +} + +// GlyphBoxes implements the GlyphBoxes method +// of the plot.GlyphBoxer interface. +func (img *Image) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + return nil +} + +func (img *Image) x(c int) float64 { + if c >= img.cols || c < 0 { + panic("plotter/image: illegal range") + } + return img.xmin + float64(c)*img.dx +} + +func (img *Image) y(r int) float64 { + if r >= img.rows || r < 0 { + panic("plotter/image: illegal range") + } + return img.ymin + float64(r)*img.dy +} diff --git a/vendor/github.com/gonum/plot/plotter/johnson.go b/vendor/github.com/gonum/plot/plotter/johnson.go new file mode 100644 index 00000000..ef3bb225 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/johnson.go @@ -0,0 +1,280 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +// johnson implements Johnson's "Finding all the elementary +// circuits of a directed graph" algorithm. SIAM J. Comput. 4(1):1975. +// +// Comments in the johnson methods are kept in sync with the comments +// and labels from the paper. +type johnson struct { + adjacent graph // SCC adjacency list. + b []set // Johnson's "B-list". + blocked []bool + s int + + stack []int + + result [][]int +} + +// cyclesIn returns the set of elementary cycles in the graph g. +func cyclesIn(g graph) [][]int { + j := johnson{ + adjacent: g.clone(), + b: make([]set, len(g)), + blocked: make([]bool, len(g)), + } + + // len(j.adjacent) will be the order of g until Tarjan's analysis + // finds no SCC, at which point t.sccSubGraph returns nil and the + // loop breaks. + for j.s < len(j.adjacent)-1 { + // We use the previous SCC adjacency to reduce the work needed. + t := newTarjan(j.adjacent.subgraph(j.s)) + // A_k = adjacency structure of strong component K with least + // vertex in subgraph of G induced by {s, s+1, ... ,n}. + j.adjacent = t.sccSubGraph(2) // Only allow SCCs with >= 2 vertices. + if len(j.adjacent) == 0 { + break + } + + // s = least vertex in V_k + for _, v := range j.adjacent { + s := len(j.adjacent) + for n := range v { + if n < s { + s = n + } + } + if s < j.s { + j.s = s + } + } + for i, v := range j.adjacent { + if len(v) > 0 { + j.blocked[i] = false + j.b[i] = make(set) + } + } + + //L3: + _ = j.circuit(j.s) + j.s++ + } + + return j.result +} + +// circuit is the CIRCUIT sub-procedure in the paper. +func (j *johnson) circuit(v int) bool { + f := false + j.stack = append(j.stack, v) + j.blocked[v] = true + + //L1: + for w := range j.adjacent[v] { + if w == j.s { + // Output circuit composed of stack followed by s. + r := make([]int, len(j.stack)+1) + copy(r, j.stack) + r[len(r)-1] = j.s + j.result = append(j.result, r) + f = true + } else if !j.blocked[w] { + if j.circuit(w) { + f = true + } + } + } + + //L2: + if f { + j.unblock(v) + } else { + for w := range j.adjacent[v] { + j.b[w][v] = struct{}{} + } + } + j.stack = j.stack[:len(j.stack)-1] + + return f +} + +// unblock is the UNBLOCK sub-procedure in the paper. +func (j *johnson) unblock(u int) { + j.blocked[u] = false + for w := range j.b[u] { + delete(j.b[u], w) + if j.blocked[w] { + j.unblock(w) + } + } +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} + +// tarjan implements Tarjan's strongly connected component finding +// algorithm. The implementation is from the pseudocode at +// +// http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm?oldid=642744644 +// +type tarjan struct { + g graph + + index int + indexTable []int + lowLink []int + onStack []bool + + stack []int + + sccs [][]int +} + +// newTarjan returns a tarjan with the sccs field filled with the +// strongly connected components of the directed graph g. +func newTarjan(g graph) *tarjan { + t := tarjan{ + g: g, + + indexTable: make([]int, len(g)), + lowLink: make([]int, len(g)), + onStack: make([]bool, len(g)), + } + for v := range t.g { + if t.indexTable[v] == 0 { + t.strongconnect(v) + } + } + return &t +} + +// strongconnect is the strongconnect function described in the +// wikipedia article. +func (t *tarjan) strongconnect(v int) { + // Set the depth index for v to the smallest unused index. + t.index++ + t.indexTable[v] = t.index + t.lowLink[v] = t.index + t.stack = append(t.stack, v) + t.onStack[v] = true + + // Consider successors of v. + for w := range t.g[v] { + if t.indexTable[w] == 0 { + // Successor w has not yet been visited; recur on it. + t.strongconnect(w) + t.lowLink[v] = min(t.lowLink[v], t.lowLink[w]) + } else if t.onStack[w] { + // Successor w is in stack s and hence in the current SCC. + t.lowLink[v] = min(t.lowLink[v], t.indexTable[w]) + } + } + + // If v is a root node, pop the stack and generate an SCC. + if t.lowLink[v] == t.indexTable[v] { + // Start a new strongly connected component. + var ( + scc []int + w int + ) + for { + w, t.stack = t.stack[len(t.stack)-1], t.stack[:len(t.stack)-1] + t.onStack[w] = false + // Add w to current strongly connected component. + scc = append(scc, w) + if w == v { + break + } + } + // Output the current strongly connected component. + t.sccs = append(t.sccs, scc) + } +} + +// sccSubGraph returns the graph of the tarjan's strongly connected +// components with each SCC containing at least min vertices. +// sccSubGraph returns nil if there is no SCC with at least min +// members. +func (t *tarjan) sccSubGraph(min int) graph { + if len(t.g) == 0 { + return nil + } + sub := make(graph, len(t.g)) + + var n int + for _, scc := range t.sccs { + if len(scc) < min { + continue + } + n++ + for _, u := range scc { + for _, v := range scc { + if _, ok := t.g[u][v]; ok { + if sub[u] == nil { + sub[u] = make(set) + } + sub[u][v] = struct{}{} + } + } + } + } + if n == 0 { + return nil + } + + return sub +} + +// set is an integer set. +type set map[int]struct{} + +// graph is an edge list representation of a graph. +type graph []set + +// remove deletes edges that make up the given paths from the graph. +func (g graph) remove(paths [][]int) { + for _, p := range paths { + for i, u := range p[:len(p)-1] { + delete(g[u], p[i+1]) + } + } +} + +// subgraph returns a subgraph of g induced by {s, s+1, ... , n}. The +// subgraph is destructively generated in g. +func (g graph) subgraph(s int) graph { + for u := range g[:s] { + g[u] = nil + } + for u, e := range g[s:] { + for v := range e { + if v < s { + delete(g[u+s], v) + } + } + } + return g +} + +// clone returns a deep copy of the graph g. +func (g graph) clone() graph { + c := make(graph, len(g)) + for u, e := range g { + for v := range e { + if c[u] == nil { + c[u] = make(set) + } + c[u][v] = struct{}{} + } + } + return c +} diff --git a/vendor/github.com/gonum/plot/plotter/labels.go b/vendor/github.com/gonum/plot/plotter/labels.go new file mode 100644 index 00000000..57c81d44 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/labels.go @@ -0,0 +1,124 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "errors" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +var ( + // DefaultFont is the default font for label text. + DefaultFont = plot.DefaultFont + + // DefaultFontSize is the default font. + DefaultFontSize = vg.Points(10) +) + +// Labels implements the Plotter interface, +// drawing a set of labels at specified points. +type Labels struct { + XYs + + // Labels is the set of labels corresponding + // to each point. + Labels []string + + // TextStyle is the style of the label text. Each label + // can have a different text style. + TextStyle []draw.TextStyle + + // XOffset and YOffset are added directly to the final + // label X and Y location respectively. + XOffset, YOffset vg.Length +} + +// NewLabels returns a new Labels using the DefaultFont and +// the DefaultFontSize. +func NewLabels(d XYLabeller) (*Labels, error) { + xys, err := CopyXYs(d) + if err != nil { + return nil, err + } + + if d.Len() != len(xys) { + return nil, errors.New("Number of points does not match the number of labels") + } + + strs := make([]string, d.Len()) + for i := range strs { + strs[i] = d.Label(i) + } + + fnt, err := vg.MakeFont(DefaultFont, DefaultFontSize) + if err != nil { + return nil, err + } + + styles := make([]draw.TextStyle, d.Len()) + for i := range styles { + styles[i] = draw.TextStyle{Font: fnt} + } + + return &Labels{ + XYs: xys, + Labels: strs, + TextStyle: styles, + }, nil +} + +// Plot implements the Plotter interface, drawing labels. +func (l *Labels) Plot(c draw.Canvas, p *plot.Plot) { + trX, trY := p.Transforms(&c) + for i, label := range l.Labels { + pt := vg.Point{X: trX(l.XYs[i].X), Y: trY(l.XYs[i].Y)} + if !c.Contains(pt) { + continue + } + pt.X += l.XOffset + pt.Y += l.YOffset + c.FillText(l.TextStyle[i], pt, label) + } +} + +// DataRange returns the minimum and maximum X and Y values +func (l *Labels) DataRange() (xmin, xmax, ymin, ymax float64) { + return XYRange(l) +} + +// GlyphBoxes returns a slice of GlyphBoxes, +// one for each of the labels, implementing the +// plot.GlyphBoxer interface. +func (l *Labels) GlyphBoxes(p *plot.Plot) []plot.GlyphBox { + bs := make([]plot.GlyphBox, len(l.Labels)) + for i, label := range l.Labels { + bs[i].X = p.X.Norm(l.XYs[i].X) + bs[i].Y = p.Y.Norm(l.XYs[i].Y) + sty := l.TextStyle[i] + bs[i].Rectangle = sty.Rectangle(label) + } + return bs +} + +// XYLabeller combines the XYer and Labeller types. +type XYLabeller interface { + XYer + Labeller +} + +// XYLabels holds XY data with labels. +// The ith label corresponds to the ith XY. +type XYLabels struct { + XYs + Labels []string +} + +// Label returns the label for point index i. +func (l XYLabels) Label(i int) string { + return l.Labels[i] +} diff --git a/vendor/github.com/gonum/plot/plotter/line.go b/vendor/github.com/gonum/plot/plotter/line.go new file mode 100644 index 00000000..208af0ba --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/line.go @@ -0,0 +1,107 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "image/color" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// Line implements the Plotter interface, drawing a line. +type Line struct { + // XYs is a copy of the points for this line. + XYs + + // LineStyle is the style of the line connecting + // the points. + draw.LineStyle + + // ShadeColor is the color of the shaded area. + ShadeColor *color.Color +} + +// NewLine returns a Line that uses the default line style and +// does not draw glyphs. +func NewLine(xys XYer) (*Line, error) { + data, err := CopyXYs(xys) + if err != nil { + return nil, err + } + return &Line{ + XYs: data, + LineStyle: DefaultLineStyle, + }, nil +} + +// Plot draws the Line, implementing the plot.Plotter +// interface. +func (pts *Line) Plot(c draw.Canvas, plt *plot.Plot) { + trX, trY := plt.Transforms(&c) + ps := make([]vg.Point, len(pts.XYs)) + + for i, p := range pts.XYs { + ps[i].X = trX(p.X) + ps[i].Y = trY(p.Y) + } + + if pts.ShadeColor != nil && len(ps) > 0 { + c.SetColor(*pts.ShadeColor) + minY := trY(plt.Y.Min) + var pa vg.Path + pa.Move(vg.Point{X: ps[0].X, Y: minY}) + for i := range pts.XYs { + pa.Line(ps[i]) + } + pa.Line(vg.Point{X: ps[len(pts.XYs)-1].X, Y: minY}) + pa.Close() + c.Fill(pa) + } + + c.StrokeLines(pts.LineStyle, c.ClipLinesXY(ps)...) +} + +// DataRange returns the minimum and maximum +// x and y values, implementing the plot.DataRanger +// interface. +func (pts *Line) DataRange() (xmin, xmax, ymin, ymax float64) { + return XYRange(pts) +} + +// Thumbnail the thumbnail for the Line, +// implementing the plot.Thumbnailer interface. +func (pts *Line) Thumbnail(c *draw.Canvas) { + if pts.ShadeColor != nil { + points := []vg.Point{ + {c.Min.X, c.Min.Y}, + {c.Min.X, c.Max.Y}, + {c.Max.X, c.Max.Y}, + {c.Max.X, c.Min.Y}, + } + poly := c.ClipPolygonY(points) + c.FillPolygon(*pts.ShadeColor, poly) + + points = append(points, vg.Point{X: c.Min.X, Y: c.Min.Y}) + } else { + y := c.Center().Y + c.StrokeLine2(pts.LineStyle, c.Min.X, y, c.Max.X, y) + } +} + +// NewLinePoints returns both a Line and a +// Points for the given point data. +func NewLinePoints(xys XYer) (*Line, *Scatter, error) { + s, err := NewScatter(xys) + if err != nil { + return nil, nil, err + } + l := &Line{ + XYs: s.XYs, + LineStyle: DefaultLineStyle, + } + return l, s, nil +} diff --git a/vendor/github.com/gonum/plot/plotter/plotter.go b/vendor/github.com/gonum/plot/plotter/plotter.go new file mode 100644 index 00000000..1b4fe904 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/plotter.go @@ -0,0 +1,256 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package plotter defines a variety of standard Plotters for the +plot package. + +Plotters use the primitives provided by the plot package to draw to +the data area of a plot. This package provides some standard data +styles such as lines, scatter plots, box plots, labels, and more. + +New* functions return an error if the data contains Inf, NaN, or is +empty. Some of the New* functions return other plotter-specific errors +too. +*/ +package plotter + +import ( + "errors" + "image/color" + "math" + + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +var ( + // DefaultLineStyle is the default style for drawing + // lines. + DefaultLineStyle = draw.LineStyle{ + Color: color.Black, + Width: vg.Points(1), + Dashes: []vg.Length{}, + DashOffs: 0, + } + + // DefaultGlyphStyle is the default style used + // for gyph marks. + DefaultGlyphStyle = draw.GlyphStyle{ + Color: color.Black, + Radius: vg.Points(2.5), + Shape: draw.RingGlyph{}, + } +) + +// Valuer wraps the Len and Value methods. +type Valuer interface { + // Len returns the number of values. + Len() int + + // Value returns a value. + Value(int) float64 +} + +// Range returns the minimum and maximum values. +func Range(vs Valuer) (min, max float64) { + min = math.Inf(1) + max = math.Inf(-1) + for i := 0; i < vs.Len(); i++ { + v := vs.Value(i) + min = math.Min(min, v) + max = math.Max(max, v) + } + return +} + +// Values implements the Valuer interface. +type Values []float64 + +var ( + ErrInfinity = errors.New("Infinite data point") + ErrNaN = errors.New("NaN data point") + ErrNoData = errors.New("No data points") +) + +// CheckFloats returns an error if any of the arguments are NaN or Infinity. +func CheckFloats(fs ...float64) error { + for _, f := range fs { + switch { + case math.IsNaN(f): + return ErrNaN + case math.IsInf(f, 0): + return ErrInfinity + } + } + return nil +} + +// CopyValues returns a Values that is a copy of the values +// from a Valuer, or an error if there are no values, or if one of +// the copied values is a NaN or Infinity. +func CopyValues(vs Valuer) (Values, error) { + if vs.Len() == 0 { + return nil, ErrNoData + } + cpy := make(Values, vs.Len()) + for i := 0; i < vs.Len(); i++ { + cpy[i] = vs.Value(i) + if err := CheckFloats(cpy[i]); err != nil { + return nil, err + } + } + return cpy, nil +} + +func (vs Values) Len() int { + return len(vs) +} + +func (vs Values) Value(i int) float64 { + return vs[i] +} + +// XYer wraps the Len and XY methods. +type XYer interface { + // Len returns the number of x, y pairs. + Len() int + + // XY returns an x, y pair. + XY(int) (x, y float64) +} + +// XYRange returns the minimum and maximum +// x and y values. +func XYRange(xys XYer) (xmin, xmax, ymin, ymax float64) { + xmin, xmax = Range(XValues{xys}) + ymin, ymax = Range(YValues{xys}) + return +} + +// XYs implements the XYer interface. +type XYs []struct{ X, Y float64 } + +// CopyXYs returns an XYs that is a copy of the x and y values from +// an XYer, or an error if one of the data points contains a NaN or +// Infinity. +func CopyXYs(data XYer) (XYs, error) { + cpy := make(XYs, data.Len()) + for i := range cpy { + cpy[i].X, cpy[i].Y = data.XY(i) + if err := CheckFloats(cpy[i].X, cpy[i].Y); err != nil { + return nil, err + } + } + return cpy, nil +} + +func (xys XYs) Len() int { + return len(xys) +} + +func (xys XYs) XY(i int) (float64, float64) { + return xys[i].X, xys[i].Y +} + +// XValues implements the Valuer interface, +// returning the x value from an XYer. +type XValues struct { + XYer +} + +func (xs XValues) Value(i int) float64 { + x, _ := xs.XY(i) + return x +} + +// YValues implements the Valuer interface, +// returning the y value from an XYer. +type YValues struct { + XYer +} + +func (ys YValues) Value(i int) float64 { + _, y := ys.XY(i) + return y +} + +// XYZer wraps the Len and XYZ methods. +type XYZer interface { + // Len returns the number of x, y, z triples. + Len() int + + // XYZ returns an x, y, z triple. + XYZ(int) (float64, float64, float64) +} + +// XYZs implements the XYZer interface using a slice. +type XYZs []struct{ X, Y, Z float64 } + +// Len implements the Len method of the XYZer interface. +func (xyz XYZs) Len() int { + return len(xyz) +} + +// XYZ implements the XYZ method of the XYZer interface. +func (xyz XYZs) XYZ(i int) (float64, float64, float64) { + return xyz[i].X, xyz[i].Y, xyz[i].Z +} + +// CopyXYZs copies an XYZer. +func CopyXYZs(data XYZer) (XYZs, error) { + cpy := make(XYZs, data.Len()) + for i := range cpy { + cpy[i].X, cpy[i].Y, cpy[i].Z = data.XYZ(i) + if err := CheckFloats(cpy[i].X, cpy[i].Y, cpy[i].Z); err != nil { + return nil, err + } + } + return cpy, nil +} + +// XYValues implements the XYer interface, returning +// the x and y values from an XYZer. +type XYValues struct{ XYZer } + +// XY implements the XY method of the XYer interface. +func (xy XYValues) XY(i int) (float64, float64) { + x, y, _ := xy.XYZ(i) + return x, y +} + +// Labeller wraps the Label methods. +type Labeller interface { + // Label returns a label. + Label(int) string +} + +// XErrorer wraps the XError method. +type XErrorer interface { + // XError returns two error values for X data. + XError(int) (float64, float64) +} + +// Errors is a slice of low and high error values. +type Errors []struct{ Low, High float64 } + +// XErrors implements the XErrorer interface. +type XErrors Errors + +func (xe XErrors) XError(i int) (float64, float64) { + return xe[i].Low, xe[i].High +} + +// YErrorer wraps the YError method. +type YErrorer interface { + // YError returns two error values for Y data. + YError(int) (float64, float64) +} + +// YErrors implements the YErrorer interface. +type YErrors Errors + +func (ye YErrors) YError(i int) (float64, float64) { + return ye[i].Low, ye[i].High +} diff --git a/vendor/github.com/gonum/plot/plotter/quartile.go b/vendor/github.com/gonum/plot/plotter/quartile.go new file mode 100644 index 00000000..3d052a27 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/quartile.go @@ -0,0 +1,283 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "image/color" + + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +var ( + // DefaultQuartMedianStyle is a fat dot. + DefaultQuartMedianStyle = draw.GlyphStyle{ + Color: color.Black, + Radius: vg.Points(1.5), + Shape: draw.CircleGlyph{}, + } + + // DefaultQuartWhiskerStyle is a hairline. + DefaultQuartWhiskerStyle = draw.LineStyle{ + Color: color.Black, + Width: vg.Points(0.5), + Dashes: []vg.Length{}, + DashOffs: 0, + } +) + +// QuartPlot implements the Plotter interface, drawing +// a plot to represent the distribution of values. +// +// This style of the plot appears in Tufte's "The Visual +// Display of Quantitative Information". +type QuartPlot struct { + fiveStatPlot + + // Offset is added to the x location of each plot. + // When the Offset is zero, the plot is drawn + // centered at its x location. + Offset vg.Length + + // MedianStyle is the line style for the median point. + MedianStyle draw.GlyphStyle + + // WhiskerStyle is the line style used to draw the + // whiskers. + WhiskerStyle draw.LineStyle + + // Horizontal dictates whether the QuartPlot should be in the vertical + // (default) or horizontal direction. + Horizontal bool +} + +// NewQuartPlot returns a new QuartPlot that represents +// the distribution of the given values. +// +// An error is returned if the plot is created with +// no values. +// +// The fence values are 1.5x the interquartile before +// the first quartile and after the third quartile. Any +// value that is outside of the fences are drawn as +// Outside points. The adjacent values (to which the +// whiskers stretch) are the minimum and maximum +// values that are not outside the fences. +func NewQuartPlot(loc float64, values Valuer) (*QuartPlot, error) { + b := new(QuartPlot) + var err error + if b.fiveStatPlot, err = newFiveStat(0, loc, values); err != nil { + return nil, err + } + + b.MedianStyle = DefaultQuartMedianStyle + b.WhiskerStyle = DefaultQuartWhiskerStyle + + return b, err +} + +// Plot draws the QuartPlot on Canvas c and Plot plt. +func (b *QuartPlot) Plot(c draw.Canvas, plt *plot.Plot) { + if b.Horizontal { + b := &horizQuartPlot{b} + b.Plot(c, plt) + return + } + + trX, trY := plt.Transforms(&c) + x := trX(b.Location) + if !c.ContainsX(x) { + return + } + x += b.Offset + + med := vg.Point{X: x, Y: trY(b.Median)} + q1 := trY(b.Quartile1) + q3 := trY(b.Quartile3) + aLow := trY(b.AdjLow) + aHigh := trY(b.AdjHigh) + + c.StrokeLine2(b.WhiskerStyle, x, aHigh, x, q3) + if c.ContainsY(med.Y) { + c.DrawGlyphNoClip(b.MedianStyle, med) + } + c.StrokeLine2(b.WhiskerStyle, x, aLow, x, q1) + + ostyle := b.MedianStyle + ostyle.Radius = b.MedianStyle.Radius / 2 + for _, out := range b.Outside { + y := trY(b.Value(out)) + if c.ContainsY(y) { + c.DrawGlyphNoClip(ostyle, vg.Point{X: x, Y: y}) + } + } +} + +// DataRange returns the minimum and maximum x +// and y values, implementing the plot.DataRanger +// interface. +func (b *QuartPlot) DataRange() (float64, float64, float64, float64) { + if b.Horizontal { + b := &horizQuartPlot{b} + return b.DataRange() + } + return b.Location, b.Location, b.Min, b.Max +} + +// GlyphBoxes returns a slice of GlyphBoxes for the plot, +// implementing the plot.GlyphBoxer interface. +func (b *QuartPlot) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + if b.Horizontal { + b := &horizQuartPlot{b} + return b.GlyphBoxes(plt) + } + + bs := make([]plot.GlyphBox, len(b.Outside)+1) + + ostyle := b.MedianStyle + ostyle.Radius = b.MedianStyle.Radius / 2 + for i, out := range b.Outside { + bs[i].X = plt.X.Norm(b.Location) + bs[i].Y = plt.Y.Norm(b.Value(out)) + bs[i].Rectangle = ostyle.Rectangle() + bs[i].Rectangle.Min.X += b.Offset + } + bs[len(bs)-1].X = plt.X.Norm(b.Location) + bs[len(bs)-1].Y = plt.Y.Norm(b.Median) + bs[len(bs)-1].Rectangle = b.MedianStyle.Rectangle() + bs[len(bs)-1].Rectangle.Min.X += b.Offset + return bs +} + +// OutsideLabels returns a *Labels that will plot +// a label for each of the outside points. The +// labels are assumed to correspond to the +// points used to create the plot. +func (b *QuartPlot) OutsideLabels(labels Labeller) (*Labels, error) { + if b.Horizontal { + b := &horizQuartPlot{b} + return b.OutsideLabels(labels) + } + strs := make([]string, len(b.Outside)) + for i, out := range b.Outside { + strs[i] = labels.Label(out) + } + o := quartPlotOutsideLabels{b, strs} + ls, err := NewLabels(o) + if err != nil { + return nil, err + } + ls.XOffset += b.MedianStyle.Radius / 2 + ls.YOffset += b.MedianStyle.Radius / 2 + return ls, nil +} + +type quartPlotOutsideLabels struct { + qp *QuartPlot + labels []string +} + +func (o quartPlotOutsideLabels) Len() int { + return len(o.qp.Outside) +} + +func (o quartPlotOutsideLabels) XY(i int) (float64, float64) { + return o.qp.Location, o.qp.Value(o.qp.Outside[i]) +} + +func (o quartPlotOutsideLabels) Label(i int) string { + return o.labels[i] +} + +// horizQuartPlot is like a regular QuartPlot, however, +// it draws horizontally instead of Vertically. +type horizQuartPlot struct{ *QuartPlot } + +func (b horizQuartPlot) Plot(c draw.Canvas, plt *plot.Plot) { + trX, trY := plt.Transforms(&c) + y := trY(b.Location) + if !c.ContainsY(y) { + return + } + y += b.Offset + + med := vg.Point{X: trX(b.Median), Y: y} + q1 := trX(b.Quartile1) + q3 := trX(b.Quartile3) + aLow := trX(b.AdjLow) + aHigh := trX(b.AdjHigh) + + c.StrokeLine2(b.WhiskerStyle, aHigh, y, q3, y) + if c.ContainsX(med.X) { + c.DrawGlyphNoClip(b.MedianStyle, med) + } + c.StrokeLine2(b.WhiskerStyle, aLow, y, q1, y) + + ostyle := b.MedianStyle + ostyle.Radius = b.MedianStyle.Radius / 2 + for _, out := range b.Outside { + x := trX(b.Value(out)) + if c.ContainsX(x) { + c.DrawGlyphNoClip(ostyle, vg.Point{X: x, Y: y}) + } + } +} + +// DataRange returns the minimum and maximum x +// and y values, implementing the plot.DataRanger +// interface. +func (b horizQuartPlot) DataRange() (float64, float64, float64, float64) { + return b.Min, b.Max, b.Location, b.Location +} + +// GlyphBoxes returns a slice of GlyphBoxes for the plot, +// implementing the plot.GlyphBoxer interface. +func (b horizQuartPlot) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + bs := make([]plot.GlyphBox, len(b.Outside)+1) + + ostyle := b.MedianStyle + ostyle.Radius = b.MedianStyle.Radius / 2 + for i, out := range b.Outside { + bs[i].X = plt.X.Norm(b.Value(out)) + bs[i].Y = plt.Y.Norm(b.Location) + bs[i].Rectangle = ostyle.Rectangle() + bs[i].Rectangle.Min.Y += b.Offset + } + bs[len(bs)-1].X = plt.X.Norm(b.Median) + bs[len(bs)-1].Y = plt.Y.Norm(b.Location) + bs[len(bs)-1].Rectangle = b.MedianStyle.Rectangle() + bs[len(bs)-1].Rectangle.Min.Y += b.Offset + return bs +} + +// OutsideLabels returns a *Labels that will plot +// a label for each of the outside points. The +// labels are assumed to correspond to the +// points used to create the plot. +func (b *horizQuartPlot) OutsideLabels(labels Labeller) (*Labels, error) { + strs := make([]string, len(b.Outside)) + for i, out := range b.Outside { + strs[i] = labels.Label(out) + } + o := horizQuartPlotOutsideLabels{ + quartPlotOutsideLabels{b.QuartPlot, strs}, + } + ls, err := NewLabels(o) + if err != nil { + return nil, err + } + ls.XOffset += b.MedianStyle.Radius / 2 + ls.YOffset += b.MedianStyle.Radius / 2 + return ls, nil +} + +type horizQuartPlotOutsideLabels struct { + quartPlotOutsideLabels +} + +func (o horizQuartPlotOutsideLabels) XY(i int) (float64, float64) { + return o.qp.Value(o.qp.Outside[i]), o.qp.Location +} diff --git a/vendor/github.com/gonum/plot/plotter/scatter.go b/vendor/github.com/gonum/plot/plotter/scatter.go new file mode 100644 index 00000000..e613ce3a --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/scatter.go @@ -0,0 +1,69 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotter + +import ( + "github.com/gonum/plot" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// Scatter implements the Plotter interface, drawing +// a glyph for each of a set of points. +type Scatter struct { + // XYs is a copy of the points for this scatter. + XYs + + // GlyphStyle is the style of the glyphs drawn + // at each point. + draw.GlyphStyle +} + +// NewScatter returns a Scatter that uses the +// default glyph style. +func NewScatter(xys XYer) (*Scatter, error) { + data, err := CopyXYs(xys) + if err != nil { + return nil, err + } + return &Scatter{ + XYs: data, + GlyphStyle: DefaultGlyphStyle, + }, err +} + +// Plot draws the Scatter, implementing the plot.Plotter +// interface. +func (pts *Scatter) Plot(c draw.Canvas, plt *plot.Plot) { + trX, trY := plt.Transforms(&c) + for _, p := range pts.XYs { + c.DrawGlyph(pts.GlyphStyle, vg.Point{X: trX(p.X), Y: trY(p.Y)}) + } +} + +// DataRange returns the minimum and maximum +// x and y values, implementing the plot.DataRanger +// interface. +func (pts *Scatter) DataRange() (xmin, xmax, ymin, ymax float64) { + return XYRange(pts) +} + +// GlyphBoxes returns a slice of plot.GlyphBoxes, +// implementing the plot.GlyphBoxer interface. +func (pts *Scatter) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox { + bs := make([]plot.GlyphBox, len(pts.XYs)) + for i, p := range pts.XYs { + bs[i].X = plt.X.Norm(p.X) + bs[i].Y = plt.Y.Norm(p.Y) + bs[i].Rectangle = pts.GlyphStyle.Rectangle() + } + return bs +} + +// Thumbnail the thumbnail for the Scatter, +// implementing the plot.Thumbnailer interface. +func (pts *Scatter) Thumbnail(c *draw.Canvas) { + c.DrawGlyph(pts.GlyphStyle, c.Center()) +} diff --git a/vendor/github.com/gonum/plot/plotter/volcano_example.go b/vendor/github.com/gonum/plot/plotter/volcano_example.go new file mode 100644 index 00000000..85c5b87c --- /dev/null +++ b/vendor/github.com/gonum/plot/plotter/volcano_example.go @@ -0,0 +1,181 @@ +// Generated code do not edit. Run `go generate volcano_example.go`. + +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:generate ./volcano + +//+build ignore + +package main + +import ( + "image/color" + + "github.com/gonum/matrix/mat64" + "github.com/gonum/plot" + "github.com/gonum/plot/palette" + "github.com/gonum/plot/plotter" + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +type deciGrid struct{ mat64.Matrix } + +func (g deciGrid) Dims() (c, r int) { r, c = g.Matrix.Dims(); return c, r } +func (g deciGrid) Z(c, r int) float64 { return g.Matrix.At(r, c) } +func (g deciGrid) X(c int) float64 { + _, n := g.Matrix.Dims() + if c < 0 || c >= n { + panic("index out of range") + } + return 10 * float64(c) +} +func (g deciGrid) Y(r int) float64 { + m, _ := g.Matrix.Dims() + if r < 0 || r >= m { + panic("index out of range") + } + return 10 * float64(r) +} + +func main() { + var levels []float64 + for l := 100.5; l < volcano.Matrix.(*mat64.Dense).Max(); l += 5 { + levels = append(levels, l) + } + c := plotter.NewContour(volcano, levels, palette.Rainbow(len(levels), (palette.Yellow+palette.Red)/2, palette.Blue, 1, 1, 1)) + quarterStyle := draw.LineStyle{ + Color: color.Black, + Width: vg.Points(0.5), + Dashes: []vg.Length{0.2, 0.4}, + } + halfStyle := draw.LineStyle{ + Color: color.Black, + Width: vg.Points(0.5), + Dashes: []vg.Length{5, 2, 1, 2}, + } + c.LineStyles = append(c.LineStyles, quarterStyle, halfStyle, quarterStyle) + + h := plotter.NewHeatMap(volcano, palette.Heat(len(levels)*2, 1)) + + p, err := plot.New() + if err != nil { + panic(err) + } + p.Title.Text = "Maunga Whau Volcano" + + p.Add(h) + p.Add(c) + + p.X.Padding = 0 + p.Y.Padding = 0 + _, p.X.Max, _, p.Y.Max = h.DataRange() + + name := "example_volcano" + + for _, ext := range []string{ + ".eps", + ".pdf", + ".svg", + ".png", + ".tiff", + ".jpg", + } { + if err := p.Save(4, 4, name+ext); err != nil { + panic(err) + } + } +} + +// Data extracted from RDatasets volcano data for the Maunga Whau volcano topographic data. +var volcano = deciGrid{mat64.NewDense(87, 61, []float64{ + 100, 100, 101, 101, 101, 101, 101, 100, 100, 100, 101, 101, 102, 102, 102, 102, 103, 104, 103, 102, 101, 101, 102, 103, 104, 104, 105, 107, 107, 107, 108, 108, 110, 110, 110, 110, 110, 110, 110, 110, 108, 108, 108, 107, 107, 108, 108, 108, 108, 108, 107, 107, 107, 107, 106, 106, 105, 105, 104, 104, 103, + 101, 101, 102, 102, 102, 102, 102, 101, 101, 101, 102, 102, 103, 103, 103, 103, 104, 105, 104, 103, 102, 102, 103, 105, 106, 106, 107, 109, 110, 110, 110, 110, 111, 112, 113, 114, 116, 115, 114, 112, 110, 110, 110, 109, 108, 109, 109, 109, 109, 108, 108, 108, 108, 107, 107, 106, 106, 105, 105, 104, 104, + 102, 102, 103, 103, 103, 103, 103, 102, 102, 102, 103, 103, 104, 104, 104, 104, 105, 106, 105, 104, 104, 105, 106, 107, 108, 110, 111, 113, 114, 115, 114, 115, 116, 118, 119, 119, 121, 121, 120, 118, 116, 114, 112, 111, 110, 110, 110, 110, 109, 109, 109, 109, 108, 108, 107, 107, 106, 106, 105, 105, 104, + 103, 103, 104, 104, 104, 104, 104, 103, 103, 103, 103, 104, 104, 104, 105, 105, 106, 107, 106, 106, 106, 107, 108, 110, 111, 114, 117, 118, 117, 119, 120, 121, 122, 124, 125, 126, 127, 127, 126, 124, 122, 120, 117, 116, 113, 111, 110, 110, 110, 109, 109, 109, 109, 108, 108, 107, 107, 106, 106, 105, 105, + 104, 104, 105, 105, 105, 105, 105, 104, 104, 103, 104, 104, 105, 105, 105, 106, 107, 108, 108, 108, 109, 110, 112, 114, 115, 118, 121, 122, 121, 123, 128, 131, 129, 130, 131, 131, 132, 132, 131, 130, 128, 126, 122, 119, 115, 114, 112, 110, 110, 110, 110, 110, 109, 109, 108, 107, 107, 107, 106, 106, 105, + 105, 105, 105, 106, 106, 106, 106, 105, 105, 104, 104, 105, 105, 106, 106, 107, 109, 110, 110, 112, 113, 115, 116, 118, 119, 121, 124, 126, 126, 129, 134, 137, 137, 136, 136, 135, 136, 136, 136, 135, 133, 129, 126, 122, 118, 116, 115, 113, 111, 110, 110, 110, 110, 109, 108, 108, 108, 107, 107, 106, 106, + 105, 106, 106, 107, 107, 107, 107, 106, 106, 105, 105, 106, 106, 107, 108, 109, 111, 113, 114, 116, 118, 120, 121, 122, 123, 125, 127, 129, 130, 135, 140, 142, 142, 142, 141, 140, 140, 140, 140, 139, 137, 134, 129, 125, 121, 118, 116, 114, 112, 110, 110, 110, 111, 110, 109, 109, 108, 108, 107, 107, 106, + 106, 107, 107, 108, 108, 108, 108, 107, 107, 106, 106, 107, 108, 108, 110, 113, 115, 117, 118, 120, 122, 124, 125, 127, 128, 129, 131, 134, 135, 141, 146, 147, 146, 146, 145, 144, 144, 144, 143, 142, 141, 139, 135, 130, 126, 122, 118, 116, 114, 112, 112, 113, 112, 110, 110, 109, 109, 108, 108, 107, 106, + 107, 108, 108, 109, 109, 109, 109, 108, 108, 107, 108, 108, 110, 111, 113, 116, 118, 120, 123, 125, 127, 129, 130, 132, 134, 135, 137, 139, 142, 146, 152, 152, 151, 151, 150, 149, 148, 148, 146, 145, 143, 142, 139, 135, 131, 127, 122, 119, 117, 115, 115, 115, 114, 112, 110, 110, 109, 109, 108, 107, 107, + 108, 109, 109, 110, 110, 110, 110, 109, 109, 108, 110, 110, 113, 116, 118, 120, 122, 125, 127, 129, 133, 136, 138, 140, 141, 142, 148, 150, 151, 156, 158, 159, 158, 157, 158, 158, 154, 151, 149, 148, 146, 144, 141, 137, 134, 130, 125, 122, 120, 118, 117, 117, 115, 113, 111, 110, 110, 109, 108, 107, 107, + 109, 110, 110, 111, 111, 111, 111, 110, 110, 110, 112, 114, 118, 121, 123, 125, 127, 129, 133, 137, 141, 143, 145, 146, 148, 150, 154, 156, 159, 161, 162, 163, 164, 163, 164, 164, 160, 157, 154, 151, 149, 146, 144, 140, 137, 133, 129, 126, 124, 121, 119, 118, 116, 114, 112, 111, 110, 109, 108, 107, 106, + 110, 110, 111, 113, 112, 111, 113, 112, 112, 114, 116, 119, 121, 124, 127, 129, 133, 138, 143, 146, 149, 149, 151, 153, 154, 157, 159, 160, 163, 165, 166, 167, 168, 168, 168, 168, 166, 162, 159, 157, 154, 152, 149, 144, 140, 136, 133, 131, 128, 125, 122, 119, 117, 115, 113, 111, 110, 109, 108, 107, 106, + 110, 111, 113, 115, 114, 113, 114, 114, 115, 117, 119, 121, 124, 126, 129, 133, 140, 145, 150, 154, 155, 155, 157, 159, 161, 162, 164, 165, 167, 168, 169, 170, 172, 174, 172, 172, 171, 169, 166, 163, 161, 158, 153, 148, 143, 140, 137, 134, 131, 128, 125, 120, 118, 116, 114, 112, 110, 109, 108, 107, 105, + 111, 113, 115, 117, 116, 115, 116, 117, 117, 119, 121, 124, 126, 128, 132, 137, 143, 151, 156, 161, 161, 162, 163, 165, 166, 167, 168, 170, 171, 173, 175, 177, 179, 178, 177, 176, 176, 174, 171, 169, 165, 161, 156, 152, 148, 144, 140, 138, 135, 131, 127, 123, 119, 117, 115, 113, 111, 110, 108, 106, 105, + 114, 115, 117, 117, 117, 118, 119, 119, 120, 121, 124, 126, 128, 131, 137, 143, 150, 156, 160, 163, 165, 168, 170, 171, 172, 173, 174, 175, 177, 179, 180, 182, 183, 183, 183, 183, 180, 178, 177, 172, 168, 164, 160, 156, 152, 148, 144, 141, 138, 134, 130, 126, 121, 117, 114, 112, 110, 110, 108, 106, 104, + 116, 118, 118, 118, 120, 121, 121, 122, 122, 123, 125, 128, 130, 134, 141, 147, 152, 156, 160, 165, 168, 170, 174, 176, 179, 180, 181, 181, 182, 182, 183, 184, 186, 187, 187, 184, 184, 181, 180, 176, 172, 168, 165, 161, 157, 153, 149, 145, 142, 138, 133, 129, 125, 120, 115, 111, 110, 110, 108, 106, 104, + 118, 120, 120, 121, 122, 123, 124, 124, 125, 126, 127, 129, 132, 135, 142, 149, 153, 157, 161, 166, 170, 174, 178, 180, 182, 183, 184, 184, 185, 186, 186, 187, 189, 189, 189, 189, 189, 186, 182, 179, 175, 171, 168, 165, 162, 157, 152, 149, 145, 141, 137, 131, 125, 120, 116, 111, 110, 110, 108, 106, 104, + 120, 121, 122, 123, 124, 125, 126, 127, 127, 128, 130, 132, 134, 137, 142, 151, 155, 158, 162, 169, 172, 176, 181, 183, 184, 186, 187, 188, 189, 189, 189, 189, 190, 190, 191, 190, 190, 188, 186, 183, 180, 175, 171, 168, 165, 161, 157, 152, 149, 145, 141, 134, 127, 121, 116, 112, 110, 110, 108, 106, 104, + 120, 122, 125, 126, 126, 127, 128, 129, 130, 130, 132, 134, 136, 139, 145, 152, 157, 160, 167, 172, 175, 178, 181, 185, 186, 188, 190, 191, 192, 193, 193, 192, 192, 191, 192, 191, 191, 190, 190, 187, 184, 181, 177, 172, 169, 165, 161, 156, 152, 147, 143, 139, 131, 123, 119, 115, 111, 110, 108, 106, 105, + 121, 124, 126, 128, 129, 129, 130, 131, 132, 133, 135, 137, 139, 143, 150, 154, 159, 164, 170, 173, 176, 179, 184, 186, 189, 190, 191, 192, 193, 194, 195, 194, 193, 192, 191, 191, 191, 191, 190, 190, 188, 184, 181, 177, 173, 169, 165, 160, 155, 149, 145, 142, 136, 129, 123, 118, 114, 110, 108, 108, 107, + 122, 125, 127, 130, 130, 131, 133, 134, 135, 136, 137, 140, 143, 147, 154, 158, 162, 166, 171, 174, 177, 181, 186, 189, 190, 190, 191, 192, 191, 191, 190, 189, 188, 189, 190, 190, 191, 190, 190, 190, 189, 186, 184, 181, 177, 173, 169, 164, 158, 152, 148, 144, 140, 134, 125, 118, 115, 111, 110, 108, 107, + 122, 125, 128, 130, 132, 133, 135, 136, 137, 139, 140, 143, 147, 152, 157, 161, 164, 168, 172, 175, 179, 182, 186, 190, 190, 190, 190, 189, 187, 184, 184, 183, 182, 182, 183, 183, 183, 184, 185, 186, 187, 186, 185, 184, 181, 177, 173, 169, 163, 157, 149, 145, 141, 136, 130, 119, 116, 112, 110, 108, 106, + 123, 126, 129, 131, 133, 135, 137, 138, 139, 141, 143, 147, 150, 156, 161, 164, 167, 170, 173, 177, 181, 184, 187, 188, 190, 189, 187, 185, 183, 179, 176, 174, 174, 174, 174, 174, 176, 177, 179, 180, 182, 183, 182, 181, 181, 180, 176, 171, 166, 160, 152, 147, 142, 138, 133, 126, 121, 115, 110, 106, 105, + 124, 127, 130, 132, 135, 137, 138, 140, 142, 144, 147, 149, 154, 157, 161, 165, 168, 171, 175, 178, 181, 184, 186, 187, 187, 184, 184, 181, 179, 175, 171, 169, 168, 168, 168, 169, 170, 172, 174, 177, 178, 179, 180, 181, 181, 180, 179, 174, 167, 161, 155, 148, 144, 139, 134, 128, 121, 115, 110, 106, 105, + 123, 128, 131, 133, 136, 138, 140, 142, 144, 146, 149, 151, 154, 157, 160, 164, 168, 172, 175, 178, 181, 183, 184, 184, 185, 183, 180, 177, 174, 170, 167, 165, 164, 164, 164, 165, 166, 168, 171, 175, 176, 178, 180, 181, 180, 180, 179, 177, 170, 163, 157, 150, 144, 139, 134, 128, 121, 115, 110, 108, 107, + 123, 127, 131, 134, 136, 138, 140, 142, 144, 147, 149, 151, 154, 157, 160, 164, 168, 171, 174, 178, 180, 181, 181, 182, 183, 181, 178, 173, 169, 166, 163, 161, 161, 160, 160, 161, 163, 165, 168, 173, 176, 178, 179, 180, 181, 180, 180, 175, 173, 166, 159, 152, 145, 139, 134, 127, 121, 115, 110, 109, 108, + 120, 124, 128, 131, 134, 137, 139, 142, 144, 146, 149, 151, 153, 156, 160, 163, 167, 171, 174, 178, 180, 180, 180, 180, 180, 180, 175, 171, 167, 162, 160, 158, 157, 157, 157, 158, 159, 162, 166, 170, 175, 177, 178, 180, 181, 181, 180, 178, 175, 169, 160, 154, 148, 140, 134, 128, 121, 115, 110, 110, 109, + 118, 121, 125, 129, 132, 134, 137, 140, 142, 145, 147, 149, 151, 155, 159, 163, 166, 169, 173, 177, 179, 180, 180, 180, 180, 179, 174, 169, 166, 161, 158, 156, 154, 153, 153, 154, 156, 159, 163, 169, 173, 175, 178, 180, 181, 180, 180, 179, 175, 170, 160, 154, 149, 142, 135, 128, 122, 116, 111, 110, 110, + 117, 120, 121, 125, 129, 132, 135, 138, 140, 143, 145, 147, 149, 153, 157, 160, 163, 166, 171, 174, 177, 179, 180, 180, 180, 179, 172, 168, 164, 160, 157, 154, 151, 149, 150, 150, 154, 158, 164, 169, 174, 178, 180, 180, 180, 180, 178, 177, 175, 170, 161, 153, 148, 142, 135, 129, 123, 116, 113, 112, 110, + 115, 118, 120, 122, 126, 130, 133, 136, 138, 141, 143, 145, 148, 151, 154, 157, 160, 163, 168, 171, 174, 177, 179, 179, 179, 176, 171, 167, 164, 160, 156, 153, 149, 148, 149, 151, 155, 158, 163, 170, 173, 177, 179, 180, 180, 180, 178, 175, 173, 171, 162, 154, 147, 141, 136, 130, 124, 117, 115, 112, 110, + 114, 116, 118, 120, 122, 127, 131, 133, 136, 138, 141, 143, 146, 148, 151, 154, 157, 160, 164, 168, 171, 174, 178, 178, 179, 177, 173, 169, 165, 161, 157, 154, 151, 149, 150, 152, 155, 159, 166, 171, 175, 177, 179, 180, 180, 179, 176, 174, 171, 168, 159, 151, 146, 141, 135, 129, 124, 119, 116, 113, 110, + 115, 114, 116, 118, 120, 122, 127, 129, 132, 136, 139, 141, 143, 146, 148, 151, 153, 156, 160, 164, 167, 172, 174, 176, 177, 176, 173, 170, 166, 162, 159, 157, 154, 153, 154, 155, 158, 161, 169, 172, 174, 176, 178, 178, 178, 178, 175, 172, 169, 162, 156, 149, 144, 140, 134, 128, 123, 118, 115, 112, 110, + 113, 113, 114, 116, 118, 120, 122, 125, 129, 133, 136, 138, 141, 143, 146, 149, 150, 153, 156, 160, 165, 170, 173, 176, 176, 176, 173, 172, 169, 165, 163, 160, 158, 157, 158, 159, 161, 166, 170, 170, 173, 175, 176, 178, 176, 173, 171, 168, 164, 158, 153, 146, 140, 137, 132, 127, 121, 117, 113, 111, 110, + 111, 112, 113, 114, 116, 118, 120, 122, 126, 130, 133, 136, 139, 142, 145, 147, 148, 151, 155, 158, 163, 168, 173, 176, 177, 177, 176, 174, 171, 169, 166, 164, 161, 161, 162, 164, 165, 167, 170, 170, 171, 173, 173, 173, 170, 168, 165, 163, 160, 155, 149, 143, 138, 134, 130, 125, 119, 116, 112, 110, 109, + 110, 112, 113, 113, 114, 116, 118, 120, 123, 127, 131, 134, 137, 141, 143, 145, 148, 150, 154, 157, 161, 166, 171, 176, 178, 178, 178, 176, 174, 172, 170, 167, 167, 167, 166, 168, 170, 169, 168, 167, 168, 168, 168, 168, 167, 165, 163, 160, 156, 152, 146, 140, 136, 131, 128, 122, 118, 114, 110, 110, 109, + 109, 110, 111, 112, 114, 116, 118, 119, 120, 124, 128, 131, 136, 140, 142, 145, 147, 150, 153, 157, 160, 165, 170, 174, 178, 179, 179, 178, 178, 176, 174, 171, 170, 170, 170, 168, 167, 166, 164, 163, 161, 162, 163, 163, 163, 161, 160, 157, 153, 148, 142, 136, 130, 127, 124, 120, 117, 113, 110, 110, 109, + 108, 109, 111, 112, 114, 116, 117, 118, 120, 121, 125, 128, 132, 138, 142, 144, 147, 149, 153, 156, 160, 164, 170, 174, 178, 180, 180, 179, 179, 178, 176, 172, 170, 170, 170, 168, 166, 164, 162, 160, 157, 156, 157, 158, 158, 156, 153, 151, 149, 144, 139, 130, 127, 124, 121, 118, 115, 112, 110, 110, 109, + 108, 109, 111, 113, 114, 116, 117, 118, 119, 120, 122, 126, 130, 135, 139, 143, 147, 149, 152, 156, 160, 164, 169, 173, 177, 180, 180, 180, 180, 179, 178, 174, 170, 170, 168, 167, 165, 163, 161, 157, 154, 153, 152, 152, 152, 149, 148, 147, 144, 140, 134, 128, 125, 122, 119, 117, 114, 110, 110, 109, 109, + 107, 108, 111, 112, 114, 115, 116, 117, 119, 120, 121, 124, 128, 133, 137, 141, 145, 149, 152, 156, 160, 164, 168, 172, 176, 179, 180, 180, 180, 179, 178, 174, 170, 168, 166, 165, 163, 161, 158, 154, 150, 149, 148, 146, 145, 143, 143, 143, 140, 136, 130, 126, 123, 120, 118, 115, 112, 110, 110, 109, 109, + 107, 108, 110, 112, 113, 113, 115, 116, 118, 120, 122, 125, 128, 132, 136, 140, 145, 148, 150, 155, 160, 164, 167, 170, 174, 177, 179, 179, 178, 176, 176, 173, 169, 166, 164, 163, 161, 159, 155, 152, 148, 145, 143, 141, 140, 139, 139, 138, 136, 132, 128, 124, 121, 118, 116, 114, 111, 110, 110, 109, 108, + 107, 108, 109, 111, 113, 114, 116, 117, 119, 120, 122, 125, 128, 132, 137, 141, 144, 146, 149, 152, 157, 162, 166, 168, 171, 173, 175, 175, 173, 172, 172, 171, 168, 165, 162, 160, 158, 156, 153, 149, 145, 142, 139, 138, 137, 136, 135, 133, 131, 129, 126, 122, 119, 117, 114, 112, 110, 110, 109, 108, 107, + 108, 109, 110, 112, 114, 115, 116, 117, 119, 120, 122, 126, 129, 133, 137, 141, 143, 146, 148, 151, 155, 160, 164, 167, 168, 169, 170, 170, 169, 168, 167, 168, 166, 163, 160, 158, 155, 153, 150, 147, 143, 140, 137, 136, 134, 133, 132, 130, 129, 127, 125, 121, 118, 115, 112, 110, 110, 110, 108, 107, 107, + 109, 110, 111, 113, 115, 116, 117, 118, 120, 121, 123, 126, 129, 133, 138, 141, 143, 146, 148, 150, 155, 159, 163, 165, 166, 167, 168, 168, 166, 165, 164, 161, 160, 159, 158, 155, 152, 149, 147, 144, 141, 138, 135, 134, 132, 130, 129, 128, 126, 124, 122, 120, 117, 113, 111, 110, 110, 110, 108, 107, 107, + 110, 111, 112, 113, 116, 117, 118, 119, 120, 122, 125, 127, 130, 133, 138, 141, 143, 146, 148, 150, 154, 159, 162, 163, 164, 166, 166, 166, 165, 163, 161, 159, 157, 156, 155, 153, 150, 146, 143, 140, 138, 136, 133, 132, 130, 129, 128, 125, 124, 122, 120, 119, 117, 114, 111, 110, 110, 109, 108, 107, 107, + 111, 112, 113, 114, 116, 117, 118, 119, 120, 123, 125, 128, 130, 134, 139, 141, 144, 146, 148, 151, 154, 158, 161, 164, 166, 167, 168, 166, 165, 163, 161, 158, 156, 154, 152, 150, 146, 142, 139, 137, 135, 133, 131, 130, 129, 128, 127, 125, 123, 121, 120, 118, 116, 113, 111, 110, 110, 109, 108, 107, 106, + 111, 112, 113, 115, 117, 118, 118, 120, 121, 124, 126, 128, 131, 135, 139, 142, 144, 146, 148, 151, 155, 160, 164, 165, 168, 169, 169, 168, 166, 163, 160, 158, 156, 153, 151, 148, 145, 142, 139, 137, 135, 132, 130, 129, 127, 126, 125, 124, 123, 120, 120, 117, 116, 114, 112, 110, 110, 108, 107, 106, 106, + 112, 113, 114, 116, 117, 118, 119, 120, 122, 124, 127, 129, 132, 135, 139, 142, 144, 146, 149, 152, 157, 162, 167, 169, 170, 170, 170, 168, 165, 163, 161, 159, 157, 155, 151, 148, 145, 141, 139, 136, 134, 132, 130, 128, 127, 126, 124, 123, 122, 120, 119, 117, 116, 114, 112, 111, 109, 107, 106, 106, 105, + 113, 114, 115, 116, 117, 119, 119, 120, 122, 125, 127, 129, 132, 135, 139, 142, 144, 147, 149, 154, 159, 164, 169, 170, 170, 170, 170, 170, 168, 165, 163, 161, 158, 155, 151, 148, 145, 142, 139, 137, 135, 132, 131, 128, 126, 125, 124, 122, 121, 120, 119, 117, 115, 113, 111, 110, 109, 106, 105, 105, 104, + 113, 114, 115, 117, 118, 119, 120, 121, 123, 125, 127, 130, 132, 135, 139, 142, 145, 148, 150, 156, 161, 166, 170, 170, 170, 170, 170, 170, 169, 166, 163, 161, 159, 155, 151, 148, 146, 143, 140, 138, 135, 134, 132, 130, 127, 125, 123, 121, 120, 120, 119, 116, 114, 112, 110, 110, 108, 106, 105, 104, 104, + 114, 115, 116, 117, 118, 119, 120, 121, 123, 126, 128, 130, 133, 136, 139, 142, 145, 148, 152, 157, 161, 166, 168, 170, 170, 170, 170, 168, 166, 164, 163, 160, 159, 155, 151, 148, 146, 143, 141, 138, 136, 134, 132, 130, 128, 125, 123, 121, 120, 120, 118, 116, 113, 111, 110, 110, 109, 106, 105, 104, 104, + 115, 116, 117, 118, 119, 120, 121, 121, 123, 126, 128, 131, 134, 136, 139, 142, 145, 149, 152, 157, 161, 163, 164, 166, 168, 167, 166, 164, 163, 161, 160, 158, 156, 152, 149, 147, 144, 143, 141, 139, 136, 134, 132, 130, 128, 125, 122, 120, 120, 119, 117, 115, 113, 110, 110, 109, 107, 106, 105, 104, 104, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 125, 128, 131, 134, 137, 139, 142, 145, 149, 152, 156, 159, 159, 160, 162, 162, 161, 161, 160, 159, 158, 157, 155, 153, 150, 148, 146, 145, 143, 142, 140, 137, 134, 131, 129, 126, 124, 122, 120, 119, 117, 115, 113, 111, 110, 109, 109, 107, 106, 105, 104, 104, + 114, 115, 116, 116, 118, 119, 120, 121, 122, 126, 129, 132, 135, 137, 140, 143, 146, 149, 152, 155, 156, 157, 158, 159, 159, 159, 158, 158, 157, 155, 153, 151, 150, 149, 147, 146, 145, 144, 142, 141, 138, 135, 132, 128, 125, 122, 120, 118, 117, 115, 113, 112, 110, 109, 108, 108, 106, 105, 105, 104, 104, + 113, 114, 115, 116, 117, 118, 119, 120, 123, 126, 129, 132, 135, 138, 140, 143, 146, 148, 151, 153, 154, 156, 157, 157, 157, 157, 156, 155, 154, 152, 150, 149, 148, 147, 146, 145, 144, 142, 141, 140, 139, 136, 132, 129, 125, 121, 118, 116, 115, 113, 111, 110, 109, 108, 108, 107, 106, 105, 104, 104, 104, + 112, 113, 114, 115, 116, 117, 119, 120, 122, 126, 130, 133, 136, 138, 141, 143, 146, 148, 150, 152, 154, 155, 155, 155, 155, 155, 154, 152, 152, 150, 148, 147, 146, 145, 145, 143, 142, 141, 140, 140, 140, 137, 133, 129, 125, 120, 117, 115, 111, 110, 110, 109, 108, 107, 107, 106, 105, 105, 104, 104, 103, + 111, 112, 114, 115, 116, 117, 118, 120, 122, 125, 131, 134, 137, 139, 142, 144, 146, 148, 150, 152, 153, 153, 153, 153, 153, 153, 153, 151, 149, 147, 146, 144, 144, 143, 143, 142, 141, 140, 140, 140, 140, 138, 134, 130, 123, 120, 118, 111, 110, 110, 110, 108, 107, 106, 108, 105, 105, 104, 104, 103, 103, + 111, 112, 113, 115, 115, 116, 117, 119, 121, 126, 131, 135, 138, 140, 142, 144, 146, 148, 150, 151, 151, 151, 151, 151, 151, 151, 151, 150, 148, 146, 144, 142, 141, 141, 142, 141, 140, 140, 140, 140, 140, 140, 136, 132, 126, 120, 115, 110, 110, 110, 109, 107, 106, 105, 107, 105, 104, 104, 104, 103, 103, + 112, 113, 113, 114, 115, 116, 117, 119, 122, 127, 132, 135, 139, 141, 143, 145, 147, 149, 150, 150, 150, 150, 150, 150, 150, 150, 150, 149, 147, 144, 142, 141, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 137, 133, 128, 120, 117, 110, 110, 110, 108, 106, 105, 105, 106, 105, 104, 104, 103, 103, 103, + 112, 113, 114, 114, 116, 117, 118, 120, 122, 128, 132, 136, 139, 141, 144, 146, 147, 149, 150, 150, 150, 150, 150, 150, 150, 150, 150, 149, 146, 143, 141, 140, 140, 139, 139, 139, 140, 140, 140, 140, 140, 140, 137, 133, 129, 121, 118, 110, 110, 109, 107, 106, 105, 105, 105, 104, 104, 103, 103, 103, 102, + 112, 114, 114, 115, 116, 117, 119, 120, 122, 128, 133, 136, 140, 142, 144, 146, 148, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 148, 145, 142, 140, 138, 138, 138, 137, 138, 140, 140, 140, 140, 140, 140, 137, 134, 130, 122, 118, 110, 110, 108, 106, 105, 103, 104, 104, 104, 104, 103, 103, 102, 102, + 113, 114, 115, 116, 116, 117, 118, 120, 123, 129, 133, 137, 140, 142, 144, 146, 149, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 147, 143, 141, 139, 137, 136, 136, 135, 136, 138, 140, 140, 140, 140, 139, 136, 134, 130, 123, 119, 113, 109, 108, 106, 104, 103, 104, 104, 104, 103, 103, 102, 102, 101, + 114, 115, 115, 116, 117, 118, 118, 120, 123, 129, 133, 137, 140, 143, 145, 147, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 148, 145, 142, 139, 138, 136, 135, 134, 134, 134, 136, 138, 137, 138, 139, 137, 134, 132, 125, 122, 117, 114, 109, 107, 105, 103, 102, 104, 104, 103, 103, 102, 102, 101, 101, + 114, 115, 116, 117, 117, 119, 118, 120, 123, 128, 132, 136, 139, 142, 145, 148, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 147, 144, 141, 139, 136, 135, 134, 133, 132, 132, 134, 134, 134, 134, 135, 133, 131, 128, 124, 120, 116, 113, 110, 107, 104, 102, 102, 103, 103, 103, 102, 102, 102, 101, 100, + 115, 116, 116, 117, 118, 119, 119, 120, 124, 128, 132, 136, 139, 142, 145, 148, 150, 150, 150, 150, 150, 150, 150, 150, 150, 149, 146, 143, 140, 138, 135, 134, 133, 131, 131, 131, 131, 131, 131, 131, 130, 127, 124, 122, 119, 117, 115, 112, 109, 106, 104, 101, 102, 103, 103, 102, 102, 102, 101, 100, 100, + 115, 116, 117, 118, 118, 119, 120, 123, 125, 128, 131, 135, 138, 141, 145, 148, 150, 150, 150, 150, 150, 150, 150, 150, 150, 147, 145, 142, 139, 137, 134, 132, 131, 130, 129, 128, 128, 128, 128, 128, 126, 123, 121, 119, 116, 114, 112, 110, 108, 105, 103, 101, 103, 103, 103, 102, 102, 101, 100, 100, 100, + 116, 117, 118, 118, 119, 120, 122, 123, 125, 128, 131, 134, 137, 141, 145, 148, 149, 150, 150, 150, 150, 150, 150, 150, 148, 145, 143, 141, 138, 135, 133, 130, 129, 128, 127, 126, 125, 125, 125, 124, 123, 120, 118, 116, 114, 111, 109, 107, 106, 104, 102, 100, 101, 101, 102, 102, 101, 100, 100, 100, 100, + 116, 117, 118, 119, 120, 121, 123, 124, 126, 128, 130, 133, 137, 140, 144, 145, 147, 148, 149, 150, 149, 149, 147, 146, 144, 141, 139, 136, 133, 131, 129, 128, 127, 126, 125, 124, 123, 123, 122, 121, 120, 118, 116, 114, 112, 108, 107, 105, 103, 102, 100, 100, 100, 100, 101, 101, 100, 100, 100, 100, 100, + 117, 118, 119, 119, 120, 121, 123, 124, 126, 128, 129, 131, 135, 139, 142, 143, 145, 146, 147, 147, 147, 146, 144, 142, 140, 138, 135, 133, 130, 128, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 115, 114, 112, 110, 106, 105, 102, 101, 100, 100, 100, 100, 100, 100, 100, 100, 99, 99, 99, 99, + 117, 118, 119, 120, 120, 121, 123, 124, 125, 126, 128, 129, 132, 137, 140, 142, 143, 143, 144, 144, 144, 143, 141, 139, 137, 135, 133, 130, 128, 127, 126, 125, 123, 122, 121, 120, 119, 117, 116, 115, 114, 112, 111, 108, 107, 105, 100, 100, 100, 100, 100, 100, 100, 99, 99, 99, 99, 99, 99, 99, 98, + 116, 117, 118, 120, 120, 121, 122, 123, 124, 125, 126, 128, 130, 134, 139, 140, 141, 141, 141, 141, 141, 140, 138, 136, 134, 133, 131, 129, 127, 125, 124, 123, 122, 120, 119, 118, 117, 116, 114, 112, 111, 108, 109, 106, 106, 100, 100, 100, 100, 100, 99, 99, 99, 99, 99, 99, 99, 98, 98, 98, 97, + 114, 115, 116, 117, 119, 119, 120, 121, 122, 123, 125, 127, 129, 133, 136, 134, 134, 136, 138, 138, 137, 137, 135, 133, 132, 130, 129, 127, 125, 124, 122, 121, 120, 119, 117, 116, 115, 114, 112, 110, 109, 108, 107, 105, 105, 100, 100, 100, 100, 99, 99, 99, 98, 98, 98, 98, 98, 97, 97, 97, 97, + 112, 113, 114, 115, 116, 116, 117, 119, 120, 122, 124, 126, 127, 129, 129, 128, 127, 129, 132, 133, 133, 133, 133, 131, 129, 127, 126, 125, 124, 122, 121, 119, 118, 117, 116, 114, 113, 112, 110, 109, 108, 106, 106, 105, 100, 100, 100, 98, 98, 98, 98, 98, 98, 97, 97, 97, 97, 97, 97, 97, 96, + 109, 111, 112, 112, 113, 113, 113, 114, 116, 119, 121, 123, 124, 125, 124, 123, 123, 123, 125, 127, 129, 129, 128, 128, 127, 125, 124, 123, 122, 121, 119, 118, 117, 116, 114, 113, 112, 110, 109, 108, 107, 106, 105, 100, 100, 100, 97, 97, 97, 97, 97, 97, 97, 96, 96, 96, 96, 96, 96, 96, 96, + 106, 107, 108, 108, 109, 110, 110, 112, 113, 114, 117, 119, 120, 121, 119, 117, 117, 117, 118, 120, 123, 124, 125, 125, 125, 123, 121, 120, 120, 119, 118, 117, 116, 115, 114, 113, 111, 109, 109, 107, 106, 105, 100, 100, 100, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, + 104, 105, 105, 106, 106, 107, 108, 108, 109, 109, 111, 115, 116, 114, 113, 112, 111, 110, 111, 113, 116, 119, 122, 122, 122, 121, 120, 119, 118, 118, 117, 116, 115, 114, 113, 112, 111, 108, 108, 106, 105, 100, 100, 100, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, + 102, 103, 103, 104, 104, 105, 106, 106, 107, 108, 109, 111, 112, 110, 109, 108, 108, 108, 108, 109, 110, 112, 116, 117, 117, 118, 118, 118, 117, 116, 116, 115, 114, 113, 112, 111, 110, 107, 107, 105, 100, 100, 100, 97, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, + 101, 102, 103, 103, 104, 105, 105, 106, 106, 107, 108, 109, 109, 107, 106, 106, 105, 105, 105, 106, 107, 108, 109, 110, 111, 113, 114, 115, 115, 115, 114, 113, 112, 111, 110, 108, 108, 106, 105, 100, 100, 100, 97, 97, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, + 100, 101, 102, 102, 103, 103, 104, 104, 105, 106, 106, 107, 106, 106, 106, 105, 105, 104, 103, 103, 104, 105, 107, 108, 110, 111, 111, 112, 112, 113, 113, 112, 111, 110, 108, 107, 106, 105, 100, 100, 100, 98, 97, 97, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, + 100, 101, 101, 102, 102, 103, 103, 104, 104, 105, 105, 105, 105, 106, 105, 105, 104, 103, 102, 101, 102, 103, 104, 106, 107, 110, 111, 111, 111, 112, 112, 112, 110, 107, 107, 106, 105, 102, 100, 100, 99, 98, 97, 97, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 95, + 99, 100, 101, 102, 102, 103, 103, 103, 104, 104, 104, 104, 103, 104, 104, 104, 104, 102, 101, 101, 102, 103, 104, 105, 107, 110, 111, 111, 111, 111, 111, 111, 108, 106, 105, 105, 102, 101, 100, 99, 99, 98, 97, 97, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 95, 95, + 99, 100, 100, 101, 101, 102, 102, 102, 103, 103, 103, 103, 102, 103, 103, 104, 103, 102, 101, 101, 101, 102, 103, 104, 106, 109, 110, 111, 111, 111, 110, 110, 107, 105, 103, 104, 100, 100, 99, 99, 98, 98, 97, 97, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 95, 95, 95, 95, 95, 95, 95, + 99, 100, 100, 100, 101, 101, 101, 102, 102, 103, 102, 102, 101, 102, 102, 103, 103, 101, 101, 100, 101, 101, 102, 103, 105, 109, 110, 110, 111, 110, 110, 109, 106, 105, 100, 102, 100, 99, 99, 99, 98, 98, 97, 97, 96, 96, 96, 96, 96, 96, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 94, + 99, 99, 99, 99, 100, 100, 101, 101, 102, 102, 101, 101, 101, 101, 101, 102, 102, 101, 100, 100, 101, 101, 101, 103, 104, 107, 109, 109, 110, 110, 109, 108, 105, 102, 100, 100, 99, 99, 99, 98, 98, 98, 97, 96, 96, 96, 96, 96, 95, 95, 95, 95, 95, 95, 95, 94, 94, 94, 94, 94, 94, + 98, 99, 99, 99, 99, 100, 100, 101, 101, 102, 101, 100, 100, 100, 101, 101, 101, 100, 100, 100, 100, 101, 101, 101, 103, 106, 107, 109, 109, 109, 109, 107, 104, 101, 100, 99, 99, 99, 98, 98, 98, 97, 96, 96, 96, 96, 95, 95, 95, 95, 95, 95, 95, 94, 94, 94, 94, 94, 94, 94, 94, + 98, 98, 98, 99, 99, 99, 100, 100, 101, 101, 100, 100, 99, 99, 100, 100, 100, 100, 100, 100, 100, 101, 101, 101, 102, 105, 106, 109, 108, 109, 107, 105, 102, 100, 100, 99, 99, 98, 98, 98, 97, 96, 96, 96, 96, 95, 95, 95, 95, 95, 95, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, + 97, 98, 98, 98, 99, 99, 99, 100, 100, 100, 100, 100, 99, 99, 99, 100, 100, 100, 100, 100, 100, 100, 101, 101, 101, 103, 104, 105, 106, 105, 104, 101, 100, 100, 99, 99, 98, 98, 97, 97, 97, 96, 96, 96, 95, 95, 95, 95, 95, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, + 97, 97, 97, 98, 98, 99, 99, 99, 100, 100, 100, 99, 99, 99, 99, 99, 100, 100, 100, 100, 100, 100, 101, 101, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 99, 99, 98, 97, 97, 97, 96, 96, 96, 95, 95, 95, 95, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, +})} diff --git a/vendor/github.com/gonum/plot/plotutil/add.go b/vendor/github.com/gonum/plot/plotutil/add.go new file mode 100644 index 00000000..bb5627e8 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotutil/add.go @@ -0,0 +1,370 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotutil + +import ( + "errors" + "fmt" + + "github.com/gonum/plot" + "github.com/gonum/plot/plotter" + "github.com/gonum/plot/vg" +) + +type combineXYs struct{ xs, ys plotter.Valuer } + +func (c combineXYs) Len() int { return c.xs.Len() } +func (c combineXYs) XY(i int) (float64, float64) { return c.xs.Value(i), c.ys.Value(i) } + +type item struct { + name string + value plot.Thumbnailer +} + +// AddStackedAreaPlots adds stacked area plot plotters to a plot. +// The variadic arguments must be either strings +// or plotter.Valuers. Each valuer adds a stacked area +// plot to the plot below the stacked area plots added +// before it. If a plotter.Valuer is immediately +// preceeded by a string then the string value is used to +// label the legend. +// Plots should be added in order of tallest to shortest, +// because they will be drawn in the order they are added +// (i.e. later plots will be painted over earlier plots). +// +// If an error occurs then none of the plotters are added +// to the plot, and the error is returned. +func AddStackedAreaPlots(plt *plot.Plot, xs plotter.Valuer, vs ...interface{}) error { + var ps []plot.Plotter + var names []item + name := "" + var i int + + for _, v := range vs { + switch t := v.(type) { + case string: + name = t + + case plotter.Valuer: + if xs.Len() != t.Len() { + return errors.New("X/Y length mismatch") + } + + // Make a line plotter and set its style. + l, err := plotter.NewLine(combineXYs{xs: xs, ys: t}) + if err != nil { + return err + } + + l.LineStyle.Width = vg.Points(0) + color := Color(i) + i++ + l.ShadeColor = &color + + ps = append(ps, l) + + if name != "" { + names = append(names, item{name: name, value: l}) + name = "" + } + + default: + panic(fmt.Sprintf("AddStackedAreaPlots handles strings and plotter.Valuers, got %T", t)) + } + } + + plt.Add(ps...) + for _, v := range names { + plt.Legend.Add(v.name, v.value) + } + + return nil +} + +// AddBoxPlots adds box plot plotters to a plot and +// sets the X axis of the plot to be nominal. +// The variadic arguments must be either strings +// or plotter.Valuers. Each valuer adds a box plot +// to the plot at the X location corresponding to +// the number of box plots added before it. If a +// plotter.Valuer is immediately preceeded by a +// string then the string value is used to label the +// tick mark for the box plot's X location. +// +// If an error occurs then none of the plotters are added +// to the plot, and the error is returned. +func AddBoxPlots(plt *plot.Plot, width vg.Length, vs ...interface{}) error { + var ps []plot.Plotter + var names []string + name := "" + for _, v := range vs { + switch t := v.(type) { + case string: + name = t + + case plotter.Valuer: + b, err := plotter.NewBoxPlot(width, float64(len(names)), t) + if err != nil { + return err + } + ps = append(ps, b) + names = append(names, name) + name = "" + + default: + panic(fmt.Sprintf("AddBoxPlots handles strings and plotter.Valuers, got %T", t)) + } + } + plt.Add(ps...) + plt.NominalX(names...) + return nil +} + +// AddScatters adds Scatter plotters to a plot. +// The variadic arguments must be either strings +// or plotter.XYers. Each plotter.XYer is added to +// the plot using the next color, and glyph shape +// via the Color and Shape functions. If a +// plotter.XYer is immediately preceeded by +// a string then a legend entry is added to the plot +// using the string as the name. +// +// If an error occurs then none of the plotters are added +// to the plot, and the error is returned. +func AddScatters(plt *plot.Plot, vs ...interface{}) error { + var ps []plot.Plotter + var items []item + name := "" + var i int + for _, v := range vs { + switch t := v.(type) { + case string: + name = t + + case plotter.XYer: + s, err := plotter.NewScatter(t) + if err != nil { + return err + } + s.Color = Color(i) + s.Shape = Shape(i) + i++ + ps = append(ps, s) + if name != "" { + items = append(items, item{name: name, value: s}) + name = "" + } + + default: + panic(fmt.Sprintf("AddScatters handles strings and plotter.XYers, got %T", t)) + } + } + plt.Add(ps...) + for _, v := range items { + plt.Legend.Add(v.name, v.value) + } + return nil +} + +// AddLines adds Line plotters to a plot. +// The variadic arguments must be either strings +// or plotter.XYers. Each plotter.XYer is added to +// the plot using the next color and dashes +// shape via the Color and Dashes functions. +// If a plotter.XYer is immediately preceeded by +// a string then a legend entry is added to the plot +// using the string as the name. +// +// If an error occurs then none of the plotters are added +// to the plot, and the error is returned. +func AddLines(plt *plot.Plot, vs ...interface{}) error { + var ps []plot.Plotter + var items []item + name := "" + var i int + for _, v := range vs { + switch t := v.(type) { + case string: + name = t + + case plotter.XYer: + l, err := plotter.NewLine(t) + if err != nil { + return err + } + l.Color = Color(i) + l.Dashes = Dashes(i) + i++ + ps = append(ps, l) + if name != "" { + items = append(items, item{name: name, value: l}) + name = "" + } + + default: + panic(fmt.Sprintf("AddLines handles strings and plotter.XYers, got %T", t)) + } + } + plt.Add(ps...) + for _, v := range items { + plt.Legend.Add(v.name, v.value) + } + return nil +} + +// AddLinePoints adds Line and Scatter plotters to a +// plot. The variadic arguments must be either strings +// or plotter.XYers. Each plotter.XYer is added to +// the plot using the next color, dashes, and glyph +// shape via the Color, Dashes, and Shape functions. +// If a plotter.XYer is immediately preceeded by +// a string then a legend entry is added to the plot +// using the string as the name. +// +// If an error occurs then none of the plotters are added +// to the plot, and the error is returned. +func AddLinePoints(plt *plot.Plot, vs ...interface{}) error { + var ps []plot.Plotter + type item struct { + name string + value [2]plot.Thumbnailer + } + var items []item + name := "" + var i int + for _, v := range vs { + switch t := v.(type) { + case string: + name = t + + case plotter.XYer: + l, s, err := plotter.NewLinePoints(t) + if err != nil { + return err + } + l.Color = Color(i) + l.Dashes = Dashes(i) + s.Color = Color(i) + s.Shape = Shape(i) + i++ + ps = append(ps, l, s) + if name != "" { + items = append(items, item{name: name, value: [2]plot.Thumbnailer{l, s}}) + name = "" + } + + default: + panic(fmt.Sprintf("AddLinePoints handles strings and plotter.XYers, got %T", t)) + } + } + plt.Add(ps...) + for _, item := range items { + v := item.value[:] + plt.Legend.Add(item.name, v[0], v[1]) + } + return nil +} + +// AddErrorBars adds XErrorBars and YErrorBars +// to a plot. The variadic arguments must be +// of type plotter.XYer, and must be either a +// plotter.XErrorer, plotter.YErrorer, or both. +// Each errorer is added to the plot the color from +// the Colors function corresponding to its position +// in the argument list. +// +// If an error occurs then none of the plotters are added +// to the plot, and the error is returned. +func AddErrorBars(plt *plot.Plot, vs ...interface{}) error { + var ps []plot.Plotter + for i, v := range vs { + added := false + + if xerr, ok := v.(interface { + plotter.XYer + plotter.XErrorer + }); ok { + e, err := plotter.NewXErrorBars(xerr) + if err != nil { + return err + } + e.Color = Color(i) + ps = append(ps, e) + added = true + } + + if yerr, ok := v.(interface { + plotter.XYer + plotter.YErrorer + }); ok { + e, err := plotter.NewYErrorBars(yerr) + if err != nil { + return err + } + e.Color = Color(i) + ps = append(ps, e) + added = true + } + + if added { + continue + } + panic(fmt.Sprintf("AddErrorBars expects plotter.XErrorer or plotter.YErrorer, got %T", v)) + } + plt.Add(ps...) + return nil +} + +// AddXErrorBars adds XErrorBars to a plot. +// The variadic arguments must be +// of type plotter.XYer, and plotter.XErrorer. +// Each errorer is added to the plot the color from +// the Colors function corresponding to its position +// in the argument list. +// +// If an error occurs then none of the plotters are added +// to the plot, and the error is returned. +func AddXErrorBars(plt *plot.Plot, es ...interface { + plotter.XYer + plotter.XErrorer +}) error { + var ps []plot.Plotter + for i, e := range es { + bars, err := plotter.NewXErrorBars(e) + if err != nil { + return err + } + bars.Color = Color(i) + ps = append(ps, bars) + } + plt.Add(ps...) + return nil +} + +// AddYErrorBars adds YErrorBars to a plot. +// The variadic arguments must be +// of type plotter.XYer, and plotter.YErrorer. +// Each errorer is added to the plot the color from +// the Colors function corresponding to its position +// in the argument list. +// +// If an error occurs then none of the plotters are added +// to the plot, and the error is returned. +func AddYErrorBars(plt *plot.Plot, es ...interface { + plotter.XYer + plotter.YErrorer +}) error { + var ps []plot.Plotter + for i, e := range es { + bars, err := plotter.NewYErrorBars(e) + if err != nil { + return err + } + bars.Color = Color(i) + ps = append(ps, bars) + } + plt.Add(ps...) + return nil +} diff --git a/vendor/github.com/gonum/plot/plotutil/errorpoints.go b/vendor/github.com/gonum/plot/plotutil/errorpoints.go new file mode 100644 index 00000000..694ba593 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotutil/errorpoints.go @@ -0,0 +1,119 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plotutil + +import ( + "math" + "sort" + + "github.com/gonum/plot/plotter" +) + +// ErrorPoints holds a set of x, y pairs along +// with their X and Y errors. +type ErrorPoints struct { + plotter.XYs + plotter.XErrors + plotter.YErrors +} + +// NewErrorPoints returns a new ErrorPoints where each +// point in the ErrorPoints is given by evaluating the +// center function on the Xs and Ys for the corresponding +// set of XY values in the pts parameter. The XError +// and YError are computed likewise, using the err +// function. +// +// This function can be useful for summarizing sets of +// scatter points using a single point and error bars for +// each element of the scatter. +func NewErrorPoints(f func([]float64) (c, l, h float64), pts ...plotter.XYer) (*ErrorPoints, error) { + + c := &ErrorPoints{ + XYs: make(plotter.XYs, len(pts)), + XErrors: make(plotter.XErrors, len(pts)), + YErrors: make(plotter.YErrors, len(pts)), + } + + for i, xy := range pts { + xs := make([]float64, xy.Len()) + ys := make([]float64, xy.Len()) + for j := 0; j < xy.Len(); j++ { + xs[j], ys[j] = xy.XY(j) + if err := plotter.CheckFloats(xs[j], ys[j]); err != nil { + return nil, err + } + } + c.XYs[i].X, c.XErrors[i].Low, c.XErrors[i].High = f(xs) + if err := plotter.CheckFloats(c.XYs[i].X, c.XErrors[i].Low, c.XErrors[i].High); err != nil { + return nil, err + } + c.XYs[i].Y, c.YErrors[i].Low, c.YErrors[i].High = f(ys) + if err := plotter.CheckFloats(c.XYs[i].Y, c.YErrors[i].Low, c.YErrors[i].High); err != nil { + return nil, err + } + } + + return c, nil +} + +// MeanAndConf95 returns the mean +// and the magnitude of the 95% confidence +// interval on the mean as low and high +// error values. +// +// MeanAndConf95 may be used as +// the f argument to NewErrorPoints. +func MeanAndConf95(vls []float64) (mean, lowerr, higherr float64) { + n := float64(len(vls)) + + sum := 0.0 + for _, v := range vls { + sum += v + } + mean = sum / n + + sum = 0.0 + for _, v := range vls { + diff := v - mean + sum += diff * diff + } + stdev := math.Sqrt(sum / n) + + conf := 1.96 * stdev / math.Sqrt(n) + return mean, conf, conf +} + +// MedianAndMinMax returns the median +// value and error on the median given +// by the minimum and maximum data +// values. +// +// MedianAndMinMax may be used as +// the f argument to NewErrorPoints. +func MedianAndMinMax(vls []float64) (med, lowerr, higherr float64) { + n := len(vls) + if n == 0 { + panic("MedianAndMinMax: No values") + } + if n == 1 { + return vls[0], 0, 0 + } + sort.Float64s(vls) + if n%2 == 0 { + med = (vls[n/2+1]-vls[n/2])/2 + vls[n/2] + } else { + med = vls[n/2] + } + + min := vls[0] + max := vls[0] + for _, v := range vls { + min = math.Min(min, v) + max = math.Max(max, v) + } + + return med, med - min, max - med +} diff --git a/vendor/github.com/gonum/plot/plotutil/main.go b/vendor/github.com/gonum/plot/plotutil/main.go new file mode 100644 index 00000000..edde4b23 --- /dev/null +++ b/vendor/github.com/gonum/plot/plotutil/main.go @@ -0,0 +1,172 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build ignore + +package main + +import ( + "math/rand" + + "github.com/gonum/plot" + "github.com/gonum/plot/plotter" + "github.com/gonum/plot/plotutil" +) + +var examples = []struct { + name string + mkplot func() *plot.Plot +}{ + {"example_errpoints", Example_errpoints}, + {"example_stackedAreaChart", Example_stackedAreaChart}, +} + +func main() { + for _, ex := range examples { + drawEps(ex.name, ex.mkplot) + drawSvg(ex.name, ex.mkplot) + drawPng(ex.name, ex.mkplot) + drawTiff(ex.name, ex.mkplot) + drawJpg(ex.name, ex.mkplot) + drawPdf(ex.name, ex.mkplot) + } +} + +func drawEps(name string, mkplot func() *plot.Plot) { + if err := mkplot().Save(4, 4, name+".eps"); err != nil { + panic(err) + } +} + +func drawPdf(name string, mkplot func() *plot.Plot) { + if err := mkplot().Save(4, 4, name+".pdf"); err != nil { + panic(err) + } +} + +func drawSvg(name string, mkplot func() *plot.Plot) { + if err := mkplot().Save(4, 4, name+".svg"); err != nil { + panic(err) + } +} + +func drawPng(name string, mkplot func() *plot.Plot) { + if err := mkplot().Save(4, 4, name+".png"); err != nil { + panic(err) + } +} + +func drawTiff(name string, mkplot func() *plot.Plot) { + if err := mkplot().Save(4, 4, name+".tiff"); err != nil { + panic(err) + } +} + +func drawJpg(name string, mkplot func() *plot.Plot) { + if err := mkplot().Save(4, 4, name+".jpg"); err != nil { + panic(err) + } +} + +// Example_errpoints draws some error points. +func Example_errpoints() *plot.Plot { + rnd := rand.New(rand.NewSource(1)) + + // Get some random data. + n, m := 5, 10 + pts := make([]plotter.XYer, n) + for i := range pts { + xys := make(plotter.XYs, m) + pts[i] = xys + center := float64(i) + for j := range xys { + xys[j].X = center + (rnd.Float64() - 0.5) + xys[j].Y = center + (rnd.Float64() - 0.5) + } + } + + plt, err := plot.New() + if err != nil { + panic(err) + } + + mean95, err := plotutil.NewErrorPoints(plotutil.MeanAndConf95, pts...) + if err != nil { + panic(err) + } + medMinMax, err := plotutil.NewErrorPoints(plotutil.MedianAndMinMax, pts...) + if err != nil { + panic(err) + } + plotutil.AddLinePoints(plt, + "mean and 95% confidence", mean95, + "median and minimum and maximum", medMinMax) + if err := plotutil.AddErrorBars(plt, mean95, medMinMax); err != nil { + panic(err) + } + if err := plotutil.AddScatters(plt, pts[0], pts[1], pts[2], pts[3], pts[4]); err != nil { + panic(err) + } + + return plt +} + +type stackValues struct{ vs []plotter.Values } + +func (n stackValues) Len() int { return n.vs[0].Len() } +func (n stackValues) Value(i int) float64 { + sum := 0.0 + for _, v := range n.vs { + sum += v.Value(i) + } + return sum +} + +// An example of making a stacked area chart. +func Example_stackedAreaChart() *plot.Plot { + p, err := plot.New() + if err != nil { + panic(err) + } + + p.Title.Text = "Example: Software Version Comparison" + p.X.Label.Text = "Date" + p.Y.Label.Text = "Users (in thousands)" + + p.Legend.Top = true + p.Legend.Left = true + + vals := []plotter.Values{ + plotter.Values{0.02, 0.015, 0, 0, 0, 0, 0}, + plotter.Values{0, 0.48, 0.36, 0.34, 0.32, 0.32, 0.28}, + plotter.Values{0, 0, 0.87, 1.4, 0.64, 0.32, 0.28}, + plotter.Values{0, 0, 0, 1.26, 0.34, 0.12, 0.09}, + plotter.Values{0, 0, 0, 0, 2.48, 2.68, 2.13}, + plotter.Values{0, 0, 0, 0, 0, 1.32, 0.54}, + plotter.Values{0, 0, 0, 0, 0, 0.68, 5.67}, + } + + err = plotutil.AddStackedAreaPlots(p, plotter.Values{2007, 2008, 2009, 2010, 2011, 2012, 2013}, + "Version 3.0", + stackValues{vs: vals[0:7]}, + "Version 2.1", + stackValues{vs: vals[0:6]}, + "Version 2.0.1", + stackValues{vs: vals[0:5]}, + "Version 2.0", + stackValues{vs: vals[0:4]}, + "Version 1.1", + stackValues{vs: vals[0:3]}, + "Version 1.0", + stackValues{vs: vals[0:2]}, + "Beta", + stackValues{vs: vals[0:1]}, + ) + + if err != nil { + panic(err) + } + + return p +} diff --git a/vendor/github.com/gonum/plot/plotutil/plotutil.go b/vendor/github.com/gonum/plot/plotutil/plotutil.go new file mode 100644 index 00000000..4fa9da1f --- /dev/null +++ b/vendor/github.com/gonum/plot/plotutil/plotutil.go @@ -0,0 +1,120 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package plotutil contains a small number of utilites for creating +plots. + + +This package is under active development so portions of it may change. +*/ +package plotutil + +import ( + "image/color" + + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/draw" +) + +// DefaultColors is a set of colors used by the Color function. +var DefaultColors = SoftColors + +var DarkColors = []color.Color{ + rgb(238, 46, 47), + rgb(0, 140, 72), + rgb(24, 90, 169), + rgb(244, 125, 35), + rgb(102, 44, 145), + rgb(162, 29, 33), + rgb(180, 56, 148), +} + +var SoftColors = []color.Color{ + rgb(241, 90, 96), + rgb(122, 195, 106), + rgb(90, 155, 212), + rgb(250, 167, 91), + rgb(158, 103, 171), + rgb(206, 112, 88), + rgb(215, 127, 180), +} + +func rgb(r, g, b uint8) color.RGBA { + return color.RGBA{r, g, b, 255} +} + +// Color returns the ith default color, wrapping +// if i is less than zero or greater than the max +// number of colors in the DefaultColors slice. +func Color(i int) color.Color { + n := len(DefaultColors) + if i < 0 { + return DefaultColors[i%n+n] + } + return DefaultColors[i%n] +} + +// DefaultGlyphShapes is a set of GlyphDrawers used by +// the Shape function. +var DefaultGlyphShapes = []draw.GlyphDrawer{ + draw.RingGlyph{}, + draw.SquareGlyph{}, + draw.TriangleGlyph{}, + draw.CrossGlyph{}, + draw.PlusGlyph{}, + draw.CircleGlyph{}, + draw.BoxGlyph{}, + draw.PyramidGlyph{}, +} + +// Shape returns the ith default glyph shape, +// wrapping if i is less than zero or greater +// than the max number of GlyphDrawers +// in the DefaultGlyphShapes slice. +func Shape(i int) draw.GlyphDrawer { + n := len(DefaultGlyphShapes) + if i < 0 { + return DefaultGlyphShapes[i%n+n] + } + return DefaultGlyphShapes[i%n] +} + +// DefaultDashes is a set of dash patterns used by +// the Dashes function. +var DefaultDashes = [][]vg.Length{ + {}, + + {vg.Points(6), vg.Points(2)}, + + {vg.Points(2), vg.Points(2)}, + + {vg.Points(1), vg.Points(1)}, + + {vg.Points(5), vg.Points(2), vg.Points(1), vg.Points(2)}, + + {vg.Points(10), vg.Points(2), vg.Points(2), vg.Points(2), + vg.Points(2), vg.Points(2), vg.Points(2), vg.Points(2)}, + + {vg.Points(10), vg.Points(2), vg.Points(2), vg.Points(2)}, + + {vg.Points(5), vg.Points(2), vg.Points(5), vg.Points(2), + vg.Points(2), vg.Points(2), vg.Points(2), vg.Points(2)}, + + {vg.Points(4), vg.Points(2), vg.Points(4), vg.Points(1), + vg.Points(1), vg.Points(1), vg.Points(1), vg.Points(1), + vg.Points(1), vg.Points(1)}, +} + +// Dashes returns the ith default dash pattern, +// wrapping if i is less than zero or greater +// than the max number of dash patters +// in the DefaultDashes slice. +func Dashes(i int) []vg.Length { + n := len(DefaultDashes) + if i < 0 { + return DefaultDashes[i%n+n] + } + return DefaultDashes[i%n] +} diff --git a/vendor/github.com/gonum/plot/vg/draw/canvas.go b/vendor/github.com/gonum/plot/vg/draw/canvas.go new file mode 100644 index 00000000..666aed32 --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/draw/canvas.go @@ -0,0 +1,745 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package draw + +import ( + "fmt" + "image/color" + "math" + "strings" + + "github.com/gonum/plot/vg" + "github.com/gonum/plot/vg/vgeps" + "github.com/gonum/plot/vg/vgimg" + "github.com/gonum/plot/vg/vgpdf" + "github.com/gonum/plot/vg/vgsvg" +) + +// A Canvas is a vector graphics canvas along with +// an associated Rectangle defining a section of the canvas +// to which drawing should take place. +type Canvas struct { + vg.Canvas + vg.Rectangle +} + +// TextStyle describes what text will look like. +type TextStyle struct { + // Color is the text color. + Color color.Color + + // Font is the font description. + Font vg.Font + + // Rotation is the text rotation in radians, performed around the axis + // defined by XAlign and YAlign. + Rotation float64 + + // XAlign and YAlign specify the alignment of the text. + XAlign XAlignment + YAlign YAlignment +} + +// XAlignment specifies text alignment in the X direction. Three preset +// options are available, but an arbitrary alignment +// can also be specified using XAlignment(desired number). +type XAlignment float64 + +const ( + // XLeft aligns the left edge of the text with the specified location. + XLeft XAlignment = 0 + // XCenter aligns the horizontal center of the text with the specified location. + XCenter XAlignment = -0.5 + // XRight aligns the right edge of the text with the specified location. + XRight XAlignment = -1 +) + +// YAlignment specifies text alignment in the Y direction. Three preset +// options are available, but an arbitrary alignment +// can also be specified using YAlignment(desired number). +type YAlignment float64 + +const ( + // YTop aligns the top of of the text with the specified location. + YTop YAlignment = -1 + // YCenter aligns the vertical center of the text with the specified location. + YCenter YAlignment = -0.5 + // YBottom aligns the bottom of the text with the specified location. + YBottom YAlignment = 0 +) + +// LineStyle describes what a line will look like. +type LineStyle struct { + // Color is the color of the line. + Color color.Color + + // Width is the width of the line. + Width vg.Length + + Dashes []vg.Length + DashOffs vg.Length +} + +// A GlyphStyle specifies the look of a glyph used to draw +// a point on a plot. +type GlyphStyle struct { + // Color is the color used to draw the glyph. + color.Color + + // Radius specifies the size of the glyph's radius. + Radius vg.Length + + // Shape draws the shape of the glyph. + Shape GlyphDrawer +} + +// A GlyphDrawer wraps the DrawGlyph function. +type GlyphDrawer interface { + // DrawGlyph draws the glyph at the given + // point, with the given color and radius. + DrawGlyph(*Canvas, GlyphStyle, vg.Point) +} + +// DrawGlyph draws the given glyph to the draw +// area. If the point is not within the Canvas +// or the sty.Shape is nil then nothing is drawn. +func (c *Canvas) DrawGlyph(sty GlyphStyle, pt vg.Point) { + if sty.Shape == nil || !c.Contains(pt) { + return + } + c.SetColor(sty.Color) + sty.Shape.DrawGlyph(c, sty, pt) +} + +// DrawGlyphNoClip draws the given glyph to the draw +// area. If the sty.Shape is nil then nothing is drawn. +func (c *Canvas) DrawGlyphNoClip(sty GlyphStyle, pt vg.Point) { + if sty.Shape == nil { + return + } + c.SetColor(sty.Color) + sty.Shape.DrawGlyph(c, sty, pt) +} + +// Rectangle returns the rectangle surrounding this glyph, +// assuming that it is drawn centered at 0,0 +func (g GlyphStyle) Rectangle() vg.Rectangle { + return vg.Rectangle{ + Min: vg.Point{X: -g.Radius, Y: -g.Radius}, + Max: vg.Point{X: +g.Radius, Y: +g.Radius}, + } +} + +// CircleGlyph is a glyph that draws a solid circle. +type CircleGlyph struct{} + +// DrawGlyph implements the GlyphDrawer interface. +func (CircleGlyph) DrawGlyph(c *Canvas, sty GlyphStyle, pt vg.Point) { + var p vg.Path + p.Move(vg.Point{X: pt.X + sty.Radius, Y: pt.Y}) + p.Arc(pt, sty.Radius, 0, 2*math.Pi) + p.Close() + c.Fill(p) +} + +// RingGlyph is a glyph that draws the outline of a circle. +type RingGlyph struct{} + +// DrawGlyph implements the Glyph interface. +func (RingGlyph) DrawGlyph(c *Canvas, sty GlyphStyle, pt vg.Point) { + c.SetLineStyle(LineStyle{Color: sty.Color, Width: vg.Points(0.5)}) + var p vg.Path + p.Move(vg.Point{X: pt.X + sty.Radius, Y: pt.Y}) + p.Arc(pt, sty.Radius, 0, 2*math.Pi) + p.Close() + c.Stroke(p) +} + +const ( + cosπover4 = vg.Length(.707106781202420) + sinπover6 = vg.Length(.500000000025921) + cosπover6 = vg.Length(.866025403769473) +) + +// SquareGlyph is a glyph that draws the outline of a square. +type SquareGlyph struct{} + +// DrawGlyph implements the Glyph interface. +func (SquareGlyph) DrawGlyph(c *Canvas, sty GlyphStyle, pt vg.Point) { + c.SetLineStyle(LineStyle{Color: sty.Color, Width: vg.Points(0.5)}) + x := (sty.Radius-sty.Radius*cosπover4)/2 + sty.Radius*cosπover4 + var p vg.Path + p.Move(vg.Point{X: pt.X - x, Y: pt.Y - x}) + p.Line(vg.Point{X: pt.X + x, Y: pt.Y - x}) + p.Line(vg.Point{X: pt.X + x, Y: pt.Y + x}) + p.Line(vg.Point{X: pt.X - x, Y: pt.Y + x}) + p.Close() + c.Stroke(p) +} + +// BoxGlyph is a glyph that draws a filled square. +type BoxGlyph struct{} + +// DrawGlyph implements the Glyph interface. +func (BoxGlyph) DrawGlyph(c *Canvas, sty GlyphStyle, pt vg.Point) { + x := (sty.Radius-sty.Radius*cosπover4)/2 + sty.Radius*cosπover4 + var p vg.Path + p.Move(vg.Point{X: pt.X - x, Y: pt.Y - x}) + p.Line(vg.Point{X: pt.X + x, Y: pt.Y - x}) + p.Line(vg.Point{X: pt.X + x, Y: pt.Y + x}) + p.Line(vg.Point{X: pt.X - x, Y: pt.Y + x}) + p.Close() + c.Fill(p) +} + +// TriangleGlyph is a glyph that draws the outline of a triangle. +type TriangleGlyph struct{} + +// DrawGlyph implements the Glyph interface. +func (TriangleGlyph) DrawGlyph(c *Canvas, sty GlyphStyle, pt vg.Point) { + c.SetLineStyle(LineStyle{Color: sty.Color, Width: vg.Points(0.5)}) + r := sty.Radius + (sty.Radius-sty.Radius*sinπover6)/2 + var p vg.Path + p.Move(vg.Point{X: pt.X, Y: pt.Y + r}) + p.Line(vg.Point{X: pt.X - r*cosπover6, Y: pt.Y - r*sinπover6}) + p.Line(vg.Point{X: pt.X + r*cosπover6, Y: pt.Y - r*sinπover6}) + p.Close() + c.Stroke(p) +} + +// PyramidGlyph is a glyph that draws a filled triangle. +type PyramidGlyph struct{} + +// DrawGlyph implements the Glyph interface. +func (PyramidGlyph) DrawGlyph(c *Canvas, sty GlyphStyle, pt vg.Point) { + r := sty.Radius + (sty.Radius-sty.Radius*sinπover6)/2 + var p vg.Path + p.Move(vg.Point{X: pt.X, Y: pt.Y + r}) + p.Line(vg.Point{X: pt.X - r*cosπover6, Y: pt.Y - r*sinπover6}) + p.Line(vg.Point{X: pt.X + r*cosπover6, Y: pt.Y - r*sinπover6}) + p.Close() + c.Fill(p) +} + +// PlusGlyph is a glyph that draws a plus sign +type PlusGlyph struct{} + +// DrawGlyph implements the Glyph interface. +func (PlusGlyph) DrawGlyph(c *Canvas, sty GlyphStyle, pt vg.Point) { + c.SetLineStyle(LineStyle{Color: sty.Color, Width: vg.Points(0.5)}) + r := sty.Radius + var p vg.Path + p.Move(vg.Point{X: pt.X, Y: pt.Y + r}) + p.Line(vg.Point{X: pt.X, Y: pt.Y - r}) + c.Stroke(p) + p = vg.Path{} + p.Move(vg.Point{X: pt.X - r, Y: pt.Y}) + p.Line(vg.Point{X: pt.X + r, Y: pt.Y}) + c.Stroke(p) +} + +// CrossGlyph is a glyph that draws a big X. +type CrossGlyph struct{} + +// DrawGlyph implements the Glyph interface. +func (CrossGlyph) DrawGlyph(c *Canvas, sty GlyphStyle, pt vg.Point) { + c.SetLineStyle(LineStyle{Color: sty.Color, Width: vg.Points(0.5)}) + r := sty.Radius * cosπover4 + var p vg.Path + p.Move(vg.Point{X: pt.X - r, Y: pt.Y - r}) + p.Line(vg.Point{X: pt.X + r, Y: pt.Y + r}) + c.Stroke(p) + p = vg.Path{} + p.Move(vg.Point{X: pt.X - r, Y: pt.Y + r}) + p.Line(vg.Point{X: pt.X + r, Y: pt.Y - r}) + c.Stroke(p) +} + +// New returns a new (bounded) draw.Canvas. +func New(c vg.CanvasSizer) Canvas { + w, h := c.Size() + return NewCanvas(c, w, h) +} + +// NewFormattedCanvas creates a new vg.CanvasWriterTo with the specified +// image format. +// +// Supported formats are: +// +// eps, jpg|jpeg, pdf, png, svg, and tif|tiff. +func NewFormattedCanvas(w, h vg.Length, format string) (vg.CanvasWriterTo, error) { + var c vg.CanvasWriterTo + switch format { + case "eps": + c = vgeps.New(w, h) + + case "jpg", "jpeg": + c = vgimg.JpegCanvas{Canvas: vgimg.New(w, h)} + + case "pdf": + c = vgpdf.New(w, h) + + case "png": + c = vgimg.PngCanvas{Canvas: vgimg.New(w, h)} + + case "svg": + c = vgsvg.New(w, h) + + case "tif", "tiff": + c = vgimg.TiffCanvas{Canvas: vgimg.New(w, h)} + + default: + return nil, fmt.Errorf("unsupported format: %q", format) + } + return c, nil +} + +// NewCanvas returns a new (bounded) draw.Canvas of the given size. +func NewCanvas(c vg.Canvas, w, h vg.Length) Canvas { + return Canvas{ + Canvas: c, + Rectangle: vg.Rectangle{ + Min: vg.Point{X: 0, Y: 0}, + Max: vg.Point{X: w, Y: h}, + }, + } +} + +// Center returns the center point of the area +func (c *Canvas) Center() vg.Point { + return vg.Point{ + X: (c.Max.X-c.Min.X)/2 + c.Min.X, + Y: (c.Max.Y-c.Min.Y)/2 + c.Min.Y, + } +} + +// Contains returns true if the Canvas contains the point. +func (c *Canvas) Contains(p vg.Point) bool { + return c.ContainsX(p.X) && c.ContainsY(p.Y) +} + +// ContainsX returns true if the Canvas contains the +// x coordinate. +func (c *Canvas) ContainsX(x vg.Length) bool { + return x <= c.Max.X+slop && x >= c.Min.X-slop +} + +// ContainsY returns true if the Canvas contains the +// y coordinate. +func (c *Canvas) ContainsY(y vg.Length) bool { + return y <= c.Max.Y+slop && y >= c.Min.Y-slop +} + +// X returns the value of x, given in the unit range, +// in the drawing coordinates of this draw area. +// A value of 0, for example, will return the minimum +// x value of the draw area and a value of 1 will +// return the maximum. +func (c *Canvas) X(x float64) vg.Length { + return vg.Length(x)*(c.Max.X-c.Min.X) + c.Min.X +} + +// Y returns the value of x, given in the unit range, +// in the drawing coordinates of this draw area. +// A value of 0, for example, will return the minimum +// y value of the draw area and a value of 1 will +// return the maximum. +func (c *Canvas) Y(y float64) vg.Length { + return vg.Length(y)*(c.Max.Y-c.Min.Y) + c.Min.Y +} + +// Crop returns a new Canvas corresponding to the Canvas +// c with the given lengths added to the minimum +// and maximum x and y values of the Canvas's Rectangle. +// Note that cropping the right and top sides of the canvas +// requires specifying negative values of right and top. +func Crop(c Canvas, left, right, bottom, top vg.Length) Canvas { + minpt := vg.Point{ + X: c.Min.X + left, + Y: c.Min.Y + bottom, + } + maxpt := vg.Point{ + X: c.Max.X + right, + Y: c.Max.Y + top, + } + return Canvas{ + Canvas: c, + Rectangle: vg.Rectangle{Min: minpt, Max: maxpt}, + } +} + +// Tiles creates regular subcanvases from a Canvas. +type Tiles struct { + // Cols and Rows specify the number of rows and columns of tiles. + Cols, Rows int + // PadTop, PadBottom, PadRight, and PadLeft specify the padding + // on the corresponding side of each tile. + PadTop, PadBottom, PadRight, PadLeft vg.Length + // PadX and PadY specify the padding between columns and rows + // of tiles respectively.. + PadX, PadY vg.Length +} + +// At returns the subcanvas within c that corresponds to the +// tile at column x, row y. +func (ts Tiles) At(c Canvas, x, y int) Canvas { + tileH := (c.Max.Y - c.Min.Y - ts.PadTop - ts.PadBottom - + vg.Length(ts.Rows-1)*ts.PadY) / vg.Length(ts.Rows) + tileW := (c.Max.X - c.Min.X - ts.PadLeft - ts.PadRight - + vg.Length(ts.Cols-1)*ts.PadX) / vg.Length(ts.Cols) + + ymax := c.Max.Y - ts.PadTop - vg.Length(y)*(ts.PadY+tileH) + ymin := ymax - tileH + xmin := c.Min.X + ts.PadLeft + vg.Length(x)*(ts.PadX+tileW) + xmax := xmin + tileW + + return Canvas{ + Canvas: vg.Canvas(c), + Rectangle: vg.Rectangle{ + Min: vg.Point{X: xmin, Y: ymin}, + Max: vg.Point{X: xmax, Y: ymax}, + }, + } +} + +// SetLineStyle sets the current line style +func (c *Canvas) SetLineStyle(sty LineStyle) { + c.SetColor(sty.Color) + c.SetLineWidth(sty.Width) + var dashDots []vg.Length + for _, dash := range sty.Dashes { + dashDots = append(dashDots, dash) + } + c.SetLineDash(dashDots, sty.DashOffs) +} + +// StrokeLines draws a line connecting a set of points +// in the given Canvas. +func (c *Canvas) StrokeLines(sty LineStyle, lines ...[]vg.Point) { + if len(lines) == 0 { + return + } + + c.SetLineStyle(sty) + + for _, l := range lines { + if len(l) == 0 { + continue + } + var p vg.Path + p.Move(l[0]) + for _, pt := range l[1:] { + p.Line(pt) + } + c.Stroke(p) + } +} + +// StrokeLine2 draws a line between two points in the given +// Canvas. +func (c *Canvas) StrokeLine2(sty LineStyle, x0, y0, x1, y1 vg.Length) { + c.StrokeLines(sty, []vg.Point{{x0, y0}, {x1, y1}}) +} + +// ClipLinesXY returns a slice of lines that +// represent the given line clipped in both +// X and Y directions. +func (c *Canvas) ClipLinesXY(lines ...[]vg.Point) [][]vg.Point { + return c.ClipLinesY(c.ClipLinesX(lines...)...) +} + +// ClipLinesX returns a slice of lines that +// represent the given line clipped in the +// X direction. +func (c *Canvas) ClipLinesX(lines ...[]vg.Point) (clipped [][]vg.Point) { + var lines1 [][]vg.Point + for _, line := range lines { + ls := clipLine(isLeft, vg.Point{X: c.Max.X, Y: c.Min.Y}, vg.Point{X: -1, Y: 0}, line) + lines1 = append(lines1, ls...) + } + for _, line := range lines1 { + ls := clipLine(isRight, vg.Point{X: c.Min.X, Y: c.Min.Y}, vg.Point{X: 1, Y: 0}, line) + clipped = append(clipped, ls...) + } + return +} + +// ClipLinesY returns a slice of lines that +// represent the given line clipped in the +// Y direction. +func (c *Canvas) ClipLinesY(lines ...[]vg.Point) (clipped [][]vg.Point) { + var lines1 [][]vg.Point + for _, line := range lines { + ls := clipLine(isAbove, vg.Point{X: c.Min.X, Y: c.Min.Y}, vg.Point{X: 0, Y: -1}, line) + lines1 = append(lines1, ls...) + } + for _, line := range lines1 { + ls := clipLine(isBelow, vg.Point{X: c.Min.X, Y: c.Max.Y}, vg.Point{X: 0, Y: 1}, line) + clipped = append(clipped, ls...) + } + return +} + +// clipLine performs clipping of a line by a single +// clipping line specified by the norm, clip point, +// and in function. +func clipLine(in func(vg.Point, vg.Point) bool, clip, norm vg.Point, pts []vg.Point) (lines [][]vg.Point) { + var l []vg.Point + for i := 1; i < len(pts); i++ { + cur, next := pts[i-1], pts[i] + curIn, nextIn := in(cur, clip), in(next, clip) + switch { + case curIn && nextIn: + l = append(l, cur) + + case curIn && !nextIn: + l = append(l, cur, isect(cur, next, clip, norm)) + lines = append(lines, l) + l = []vg.Point{} + + case !curIn && !nextIn: + // do nothing + + default: // !curIn && nextIn + l = append(l, isect(cur, next, clip, norm)) + } + if nextIn && i == len(pts)-1 { + l = append(l, next) + } + } + if len(l) > 1 { + lines = append(lines, l) + } + return +} + +// FillPolygon fills a polygon with the given color. +func (c *Canvas) FillPolygon(clr color.Color, pts []vg.Point) { + if len(pts) == 0 { + return + } + + c.SetColor(clr) + var p vg.Path + p.Move(pts[0]) + for _, pt := range pts[1:] { + p.Line(pt) + } + p.Close() + c.Fill(p) +} + +// ClipPolygonXY returns a slice of lines that +// represent the given polygon clipped in both +// X and Y directions. +func (c *Canvas) ClipPolygonXY(pts []vg.Point) []vg.Point { + return c.ClipPolygonY(c.ClipPolygonX(pts)) +} + +// ClipPolygonX returns a slice of lines that +// represent the given polygon clipped in the +// X direction. +func (c *Canvas) ClipPolygonX(pts []vg.Point) []vg.Point { + return clipPoly(isLeft, vg.Point{X: c.Max.X, Y: c.Min.Y}, vg.Point{X: -1, Y: 0}, + clipPoly(isRight, vg.Point{X: c.Min.X, Y: c.Min.Y}, vg.Point{X: 1, Y: 0}, pts)) +} + +// ClipPolygonY returns a slice of lines that +// represent the given polygon clipped in the +// Y direction. +func (c *Canvas) ClipPolygonY(pts []vg.Point) []vg.Point { + return clipPoly(isBelow, vg.Point{X: c.Min.X, Y: c.Max.Y}, vg.Point{X: 0, Y: 1}, + clipPoly(isAbove, vg.Point{X: c.Min.X, Y: c.Min.Y}, vg.Point{X: 0, Y: -1}, pts)) +} + +// clipPoly performs clipping of a polygon by a single +// clipping line specified by the norm, clip point, +// and in function. +func clipPoly(in func(vg.Point, vg.Point) bool, clip, norm vg.Point, pts []vg.Point) (clipped []vg.Point) { + for i := 0; i < len(pts); i++ { + j := i + 1 + if i == len(pts)-1 { + j = 0 + } + cur, next := pts[i], pts[j] + curIn, nextIn := in(cur, clip), in(next, clip) + switch { + case curIn && nextIn: + clipped = append(clipped, cur) + + case curIn && !nextIn: + clipped = append(clipped, cur, isect(cur, next, clip, norm)) + + case !curIn && !nextIn: + // do nothing + + default: // !curIn && nextIn + clipped = append(clipped, isect(cur, next, clip, norm)) + } + } + return +} + +// slop is some slop for floating point equality +const slop = 3e-8 // ≈ √1⁻¹⁵ + +func isLeft(p, clip vg.Point) bool { + return p.X <= clip.X+slop +} + +func isRight(p, clip vg.Point) bool { + return p.X >= clip.X-slop +} + +func isBelow(p, clip vg.Point) bool { + return p.Y <= clip.Y+slop +} + +func isAbove(p, clip vg.Point) bool { + return p.Y >= clip.Y-slop +} + +// isect returns the intersection of a line p0→p1 with the +// clipping line specified by the clip point and normal. +func isect(p0, p1, clip, norm vg.Point) vg.Point { + // t = (norm · (p0 - clip)) / (norm · (p0 - p1)) + t := p0.Sub(clip).Dot(norm) / p0.Sub(p1).Dot(norm) + + // p = p0 + t*(p1 - p0) + return p1.Sub(p0).Scale(t).Add(p0) +} + +// FillText fills lines of text in the draw area. +// pt specifies the location where the text is to be drawn. +func (c *Canvas) FillText(sty TextStyle, pt vg.Point, txt string) { + txt = strings.TrimRight(txt, "\n") + if len(txt) == 0 { + return + } + + c.SetColor(sty.Color) + + if sty.Rotation != 0 { + c.Push() + c.Rotate(sty.Rotation) + } + + cos := vg.Length(math.Cos(sty.Rotation)) + sin := vg.Length(math.Sin(sty.Rotation)) + pt.X, pt.Y = pt.Y*sin+pt.X*cos, pt.Y*cos-pt.X*sin + + nl := textNLines(txt) + ht := sty.Height(txt) + pt.Y += ht*vg.Length(sty.YAlign) - sty.Font.Extents().Ascent + for i, line := range strings.Split(txt, "\n") { + xoffs := vg.Length(sty.XAlign) * sty.Font.Width(line) + n := vg.Length(nl - i) + c.FillString(sty.Font, pt.Add(vg.Point{X: xoffs, Y: n * sty.Font.Size}), line) + } + + if sty.Rotation != 0 { + c.Pop() + } +} + +// rotatePoint applies rotation theta (in radians) about the origin to point p. +func rotatePoint(theta float64, p vg.Point) vg.Point { + if theta == 0 { + return p + } + x := float64(p.X) + y := float64(p.Y) + + return vg.Point{ + X: vg.Length(x*math.Cos(theta) - y*math.Sin(theta)), + Y: vg.Length(y*math.Cos(theta) + x*math.Sin(theta)), + } +} + +// Width returns the width of lines of text +// when using the given font before any text rotation is applied. +func (sty TextStyle) Width(txt string) (max vg.Length) { + txt = strings.TrimRight(txt, "\n") + for _, line := range strings.Split(txt, "\n") { + if w := sty.Font.Width(line); w > max { + max = w + } + } + return +} + +// Height returns the height of the text when using +// the given font before any text rotation is applied. +func (sty TextStyle) Height(txt string) vg.Length { + nl := textNLines(txt) + if nl == 0 { + return vg.Length(0) + } + e := sty.Font.Extents() + return e.Height*vg.Length(nl-1) + e.Ascent +} + +// Rectangle returns a rectangle giving the bounds of +// this text assuming that it is drawn at (0, 0). +func (sty TextStyle) Rectangle(txt string) vg.Rectangle { + w := sty.Width(txt) + h := sty.Height(txt) + xoff := vg.Length(sty.XAlign) * w + yoff := vg.Length(sty.YAlign) * h + // lower left corner + p1 := rotatePoint(sty.Rotation, vg.Point{X: xoff, Y: yoff}) + // upper left corner + p2 := rotatePoint(sty.Rotation, vg.Point{X: xoff, Y: h + yoff}) + // lower right corner + p3 := rotatePoint(sty.Rotation, vg.Point{X: w + xoff, Y: yoff}) + // upper right corner + p4 := rotatePoint(sty.Rotation, vg.Point{X: w + xoff, Y: h + yoff}) + + return vg.Rectangle{ + Max: vg.Point{ + X: max(p1.X, p2.X, p3.X, p4.X), + Y: max(p1.Y, p2.Y, p3.Y, p4.Y), + }, + Min: vg.Point{ + X: min(p1.X, p2.X, p3.X, p4.X), + Y: min(p1.Y, p2.Y, p3.Y, p4.Y), + }, + } +} + +func max(d ...vg.Length) vg.Length { + o := vg.Length(math.Inf(-1)) + for _, dd := range d { + if dd > o { + o = dd + } + } + return o +} + +func min(d ...vg.Length) vg.Length { + o := vg.Length(math.Inf(1)) + for _, dd := range d { + if dd < o { + o = dd + } + } + return o +} + +// textNLines returns the number of lines in the text. +func textNLines(txt string) int { + txt = strings.TrimRight(txt, "\n") + if len(txt) == 0 { + return 0 + } + n := 1 + for _, r := range txt { + if r == '\n' { + n++ + } + } + return n +} diff --git a/vendor/github.com/gonum/plot/vg/font.go b/vendor/github.com/gonum/plot/vg/font.go new file mode 100644 index 00000000..989b8380 --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/font.go @@ -0,0 +1,280 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Some of this code (namely the code for computing the +// width of a string in a given font) was copied from +// github.com/golang/freetype/ which includes +// the following copyright notice: +// Copyright 2010 The Freetype-Go Authors. All rights reserved. + +package vg + +import ( + "errors" + "go/build" + "io/ioutil" + "os" + "path/filepath" + "sync" + + "golang.org/x/image/math/fixed" + + "github.com/golang/freetype" + "github.com/golang/freetype/truetype" + "github.com/gonum/plot/vg/fonts" +) + +const ( + // importString is the import string expected for + // this package. It is used to find the font + // directory included with the package source. + importString = "github.com/gonum/plot/vg" +) + +var ( + // FontMap maps Postscript/PDF font names to compatible + // free fonts (TrueType converted ghostscript fonts). + // Fonts that are not keys of this map are not supported. + FontMap = map[string]string{ + + // We use fonts from RedHat's Liberation project: + // https://fedorahosted.org/liberation-fonts/ + + "Courier": "LiberationMono-Regular", + "Courier-Bold": "LiberationMono-Bold", + "Courier-Oblique": "LiberationMono-Italic", + "Courier-BoldOblique": "LiberationMono-BoldItalic", + + "Helvetica": "LiberationSans-Regular", + "Helvetica-Bold": "LiberationSans-Bold", + "Helvetica-Oblique": "LiberationSans-Italic", + "Helvetica-BoldOblique": "LiberationSans-BoldItalic", + + "Times-Roman": "LiberationSerif-Regular", + "Times-Bold": "LiberationSerif-Bold", + "Times-Italic": "LiberationSerif-Italic", + "Times-BoldItalic": "LiberationSerif-BoldItalic", + } + + // loadedFonts is indexed by a font name and it + // caches the associated *truetype.Font. + loadedFonts = make(map[string]*truetype.Font) + + // FontLock protects access to the loadedFonts map. + fontLock sync.RWMutex +) + +// A Font represents one of the supported font +// faces. +type Font struct { + // Size is the size of the font. The font size can + // be used as a reasonable value for the vertical + // distance between two successive lines of text. + Size Length + + // name is the name of this font. + name string + + // This is a little bit of a hack, but the truetype + // font is currently only needed to determine the + // dimensions of strings drawn in this font. + // The actual drawing of the strings is handled + // separately by different back-ends: + // Both Postscript and PDF are capable of drawing + // their own fonts and draw2d loads its own copy of + // the truetype fonts for its own output. + // + // This isn't a necessity--some future backend is + // free to use this field--however it is a consequence + // of the fact that the current backends were + // developed independently of this package. + + // font is the truetype font pointer for this + // font. + font *truetype.Font +} + +// MakeFont returns a font object. The name of the font must +// be a key of the FontMap. The font file is located by searching +// the FontDirs slice for a directory containing the relevant font +// file. The font file name is name mapped by FontMap with the +// .ttf extension. For example, the font file for the font name +// Courier is LiberationMono-Regular.ttf. +func MakeFont(name string, size Length) (font Font, err error) { + font.Size = size + font.name = name + font.font, err = getFont(name) + return +} + +// Name returns the name of the font. +func (f *Font) Name() string { + return f.name +} + +// Font returns the corresponding truetype.Font. +func (f *Font) Font() *truetype.Font { + return f.font +} + +// SetName sets the name of the font, effectively +// changing the font. If an error is returned then +// the font is left unchanged. +func (f *Font) SetName(name string) error { + font, err := getFont(name) + if err != nil { + return err + } + f.name = name + f.font = font + return nil +} + +// FontExtents contains font metric information. +type FontExtents struct { + // Ascent is the distance that the text + // extends above the baseline. + Ascent Length + + // Descent is the distance that the text + // extends below the baseline. The descent + // is given as a negative value. + Descent Length + + // Height is the distance from the lowest + // descending point to the highest ascending + // point. + Height Length +} + +// Extents returns the FontExtents for a font. +func (f *Font) Extents() FontExtents { + bounds := f.font.Bounds(fixed.Int26_6(f.Font().FUnitsPerEm())) + scale := f.Size / Points(float64(f.Font().FUnitsPerEm())) + return FontExtents{ + Ascent: Points(float64(bounds.Max.Y)) * scale, + Descent: Points(float64(bounds.Min.Y)) * scale, + Height: Points(float64(bounds.Max.Y-bounds.Min.Y)) * scale, + } +} + +// Width returns width of a string when drawn using the font. +func (f *Font) Width(s string) Length { + // scale converts truetype.FUnit to float64 + scale := f.Size / Points(float64(f.font.FUnitsPerEm())) + + width := 0 + prev, hasPrev := truetype.Index(0), false + for _, rune := range s { + index := f.font.Index(rune) + if hasPrev { + width += int(f.font.Kern(fixed.Int26_6(f.font.FUnitsPerEm()), prev, index)) + } + width += int(f.font.HMetric(fixed.Int26_6(f.font.FUnitsPerEm()), index).AdvanceWidth) + prev, hasPrev = index, true + } + return Points(float64(width)) * scale +} + +// AddFont associates a truetype.Font with the given name. +func AddFont(name string, font *truetype.Font) { + fontLock.Lock() + loadedFonts[name] = font + fontLock.Unlock() +} + +// getFont returns the truetype.Font for the given font name or an error. +func getFont(name string) (*truetype.Font, error) { + fontLock.RLock() + f, ok := loadedFonts[name] + fontLock.RUnlock() + if ok { + return f, nil + } + + bytes, err := fontData(name) + if err != nil { + return nil, err + } + + font, err := freetype.ParseFont(bytes) + if err == nil { + fontLock.Lock() + loadedFonts[name] = font + fontLock.Unlock() + } else { + err = errors.New("Failed to parse font file: " + err.Error()) + } + + return font, err +} + +// fontData returns the []byte data for a font name or an error if it is not found. +func fontData(name string) ([]byte, error) { + fname, err := fontFile(name) + if err != nil { + return nil, err + } + + for _, d := range FontDirs { + p := filepath.Join(d, fname) + data, err := ioutil.ReadFile(p) + if err != nil { + continue + } + return data, nil + } + + data, err := fonts.Asset(fname) + if err == nil { + return data, nil + } + + return nil, errors.New("vg: failed to locate a font file " + fname + " for font name " + name) +} + +// FontDirs is a slice of directories searched for font data files. +// If the first font file found is unreadable or cannot be parsed, then +// subsequent directories are not tried, and the font will fail to load. +// +// The default slice contains, in the following order, the values of the +// environment variable VGFONTPATH if it is defined, then the vg +// source fonts directory if it is found (i.e., if vg was installed by +// go get). If the resulting FontDirs slice is empty then the current +// directory is added to it. This slice may be changed to load fonts +// from different locations. +var FontDirs = initFontDirs() + +// InitFontDirs returns the initial value for the FontDirectories variable. +func initFontDirs() []string { + dirs := filepath.SplitList(os.Getenv("VGFONTPATH")) + + if pkg, err := build.Import(importString, "", build.FindOnly); err == nil { + p := filepath.Join(pkg.Dir, "fonts") + if _, err := os.Stat(p); err == nil { + dirs = append(dirs, p) + } + } + + if len(dirs) == 0 { + dirs = []string{"./fonts"} + } + + return dirs +} + +// FontFile returns the font file name for a font name or an error +// if it is an unknown font (i.e., not in the FontMap). +func fontFile(name string) (string, error) { + var err error + n, ok := FontMap[name] + if !ok { + errStr := "Unknown font: " + name + ". Available fonts are:" + for n := range FontMap { + errStr += " " + n + } + err = errors.New(errStr) + } + return n + ".ttf", err +} diff --git a/vendor/github.com/gonum/plot/vg/fonts/fonts.go b/vendor/github.com/gonum/plot/vg/fonts/fonts.go new file mode 100644 index 00000000..bae035e5 --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/fonts/fonts.go @@ -0,0 +1,8 @@ +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package fonts provides the Liberation fonts from https://fedorahosted.org/liberation-fonts/ +package fonts + +//go:generate go run mk-fonts.go diff --git a/vendor/github.com/gonum/plot/vg/fonts/liberation_fonts_generated.go b/vendor/github.com/gonum/plot/vg/fonts/liberation_fonts_generated.go new file mode 100644 index 00000000..a30d5810 --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/fonts/liberation_fonts_generated.go @@ -0,0 +1,618 @@ +// Automatically generated by vg/fonts/mk-fonts.go +// DO NOT EDIT. + +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Digitized data copyright (c) 2010 Google Corporation +// with Reserved Font Arimo, Tinos and Cousine. +// Copyright (c) 2012 Red Hat, Inc. +// with Reserved Font Name Liberation. +// +// This Font Software is licensed under the SIL Open Font License, +// Version 1.1. + +// Code generated by go-bindata. +// sources: +// AUTHORS +// ChangeLog +// LICENSE +// LiberationMono-Bold.ttf +// LiberationMono-BoldItalic.ttf +// LiberationMono-Italic.ttf +// LiberationMono-Regular.ttf +// LiberationSans-Bold.ttf +// LiberationSans-BoldItalic.ttf +// LiberationSans-Italic.ttf +// LiberationSans-Regular.ttf +// LiberationSerif-Bold.ttf +// LiberationSerif-BoldItalic.ttf +// LiberationSerif-Italic.ttf +// LiberationSerif-Regular.ttf +// README +// TODO +// DO NOT EDIT! + +package fonts + +import ( + "bytes" + "compress/gzip" + "fmt" + "io" + "io/ioutil" + "os" + "path/filepath" + "strings" + "time" +) + +func bindataRead(data []byte, name string) ([]byte, error) { + gz, err := gzip.NewReader(bytes.NewBuffer(data)) + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + + var buf bytes.Buffer + _, err = io.Copy(&buf, gz) + clErr := gz.Close() + + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + if clErr != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +type asset struct { + bytes []byte + info os.FileInfo +} + +type bindataFileInfo struct { + name string + size int64 + mode os.FileMode + modTime time.Time +} + +func (fi bindataFileInfo) Name() string { + return fi.name +} +func (fi bindataFileInfo) Size() int64 { + return fi.size +} +func (fi bindataFileInfo) Mode() os.FileMode { + return fi.mode +} +func (fi bindataFileInfo) ModTime() time.Time { + return fi.modTime +} +func (fi bindataFileInfo) IsDir() bool { + return false +} +func (fi bindataFileInfo) Sys() interface{} { + return nil +} + +var _authors = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x54\x8e\xc1\x4a\x03\x41\x0c\x86\xef\xf3\x14\xff\xb1\x05\xf5\x01\x44\x84\x52\x0f\xf5\x20\xbb\x74\xf5\x01\xd2\xd9\xd0\x1d\x19\x93\x25\x93\x59\xf1\xed\x1d\x65\x2e\xcd\x25\x21\xe1\xcb\xf7\x1f\x3e\xde\x4f\xc3\x79\x0a\xe1\x58\xcd\x58\x1c\x47\x15\xb7\x74\xa9\xae\x56\xb0\x2b\x6a\xce\x33\x28\xaf\x0b\x5d\xd8\x53\xa4\x9c\x7f\xf6\x8f\x01\xb8\xc7\x68\xb4\x25\xc1\x44\xbe\x56\x67\xe0\x69\x2d\x7d\x24\x87\xf1\xbc\xb4\x36\xab\x23\xea\xd7\x73\x03\xfe\x6a\x34\xfd\xe4\xe8\x18\xbe\x85\x0d\xbb\xee\xdc\xf7\xeb\xb9\x99\x4e\xe4\x77\x78\x95\xf8\x10\xc2\x68\xbc\x25\xad\xe5\x26\x52\xf8\x57\x4f\xce\x1b\xe3\x8d\xdc\xb9\xa8\x74\x7c\xb0\x74\x4d\x42\x19\x2f\x5c\xd2\xb5\x09\xfa\xfe\x50\x22\xcb\xcc\xd6\xff\xfe\x06\x00\x00\xff\xff\x6b\x62\x5b\x06\xf2\x00\x00\x00") + +func authorsBytes() ([]byte, error) { + return bindataRead( + _authors, + "AUTHORS", + ) +} + +func authors() (*asset, error) { + bytes, err := authorsBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "AUTHORS", size: 242, mode: os.FileMode(420), modTime: time.Unix(1459927769, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _changelog = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x9c\x52\xc1\x6e\xdb\x3a\x10\xbc\xfb\x2b\x16\xc9\xe5\xbd\x20\x71\x25\xc3\x76\x1c\xa0\x28\x20\xc4\x75\x92\x22\x41\x8c\x5a\xfd\x00\x8a\x5c\x5b\x8b\xd2\x24\x41\xae\xec\xb8\x5f\xdf\xa5\xe4\xa6\x39\xf7\x20\x88\x5c\xee\x0c\x67\x67\x78\x05\x75\xdb\xc1\xab\x66\x28\xa6\x30\x29\xca\x09\xac\xa3\x3a\x90\x83\x8d\xe2\xd0\x31\xc2\xe7\x90\xce\xab\xaa\x86\x88\xa6\x55\x0c\xcb\xd7\x1a\xb4\xdf\x7f\x19\xdd\xc0\x77\x4c\xde\x1e\xd0\xc0\xc5\x83\x3d\x85\x36\xc1\x91\xb8\x85\x7d\x67\x99\x82\x45\xe8\x1c\x69\x6f\x10\xd0\xc9\x8f\xdc\x2e\x01\xb9\x96\x1a\x62\x48\x5d\x93\x90\x59\x6a\x17\x70\xb9\x98\x95\xb7\x77\xc5\x47\xba\xa1\x54\x5e\xe7\xc5\x74\x5e\x94\xa0\xdc\x50\x5c\x4c\x66\xd2\xb7\xf2\xd6\xfa\xa3\x80\xe1\xa1\xda\xac\x81\x55\x23\x97\x1d\x30\x26\xf2\x0e\x54\x82\x80\x11\x9e\xa9\xc1\xa8\x38\x57\xbc\x35\x7f\x4e\xc7\xf0\x5f\xe5\x98\x6e\x94\x25\x95\x32\x81\xa1\x94\xd1\xe6\x7f\xa1\xad\x8c\x91\xbb\x53\x17\x82\x8f\x0c\x5b\x1f\x61\x83\xb1\x21\xe5\x60\x37\x4c\x97\x4b\x47\xfa\x49\x01\x0d\x29\xb8\x9c\xcf\x6e\x17\xd3\x3b\x01\x3e\x39\x78\xf1\xce\xa7\xa0\x34\x4a\x93\xe3\x74\x0d\x94\x56\xf4\x86\x66\x4d\xac\x5b\xe8\x47\x46\x86\x83\xc0\x92\x8e\x14\x06\xfa\xdd\x60\x01\xc8\x69\x44\xed\x77\x8e\x7e\x89\x00\x19\xe0\x2f\x9b\x64\x21\xf6\xf3\x69\x8c\x6f\x38\x1a\x5d\xc1\x2a\x12\x7c\xeb\x2c\x14\xf3\x7f\xc9\xeb\xc9\x11\x93\xb2\xef\x5e\xf9\xed\x47\x9f\x7a\xe5\xd0\xa8\x24\x22\x64\xab\xa3\x4f\xda\xc7\xf3\x44\xef\x98\x72\x3c\x29\xc7\x39\xad\x7b\xef\xa4\xc6\xd2\x5c\xd7\x2b\xd8\x92\xc5\x9c\x2f\x7b\xd8\xac\x96\xe7\xad\x6c\x1a\x04\x1f\xd0\x41\xf2\x5d\xd4\x38\x16\xdc\x8f\x60\x94\x08\xbc\xf7\xe1\x14\x69\xd7\x72\x1f\xee\x33\x69\x74\x09\x7b\x9c\xf4\x64\xb3\xb6\xa9\x3e\x05\xec\xbd\x13\x9e\xe2\x5a\xd4\x27\x56\xd6\xf6\x69\x7f\xdd\x37\x68\x4c\x6f\x5e\x02\x95\x9f\x03\x9a\x4c\x5e\x35\xf2\x84\xf2\xfc\x07\x65\xbb\xde\xbe\xc7\x47\x54\xa6\x4a\x42\xcf\x9f\x96\xd8\xff\x87\xc3\x21\xcf\xbd\x12\xcd\xf2\x65\xaa\x17\xe4\x48\x3a\x9b\x15\xc4\x91\x86\x2c\x89\xf1\xa3\xd1\xef\x00\x00\x00\xff\xff\xa0\xa2\xfc\xc6\x26\x03\x00\x00") + +func changelogBytes() ([]byte, error) { + return bindataRead( + _changelog, + "ChangeLog", + ) +} + +func changelog() (*asset, error) { + bytes, err := changelogBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ChangeLog", size: 806, mode: os.FileMode(420), modTime: time.Unix(1459927769, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _license = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x94\x57\x5d\x8f\xdb\xba\x11\x7d\x2e\x7f\xc5\x20\x0f\x45\x16\x50\x36\x1f\xfd\x02\xf2\x72\xa1\xd8\xf2\xae\x70\xbd\xb2\xaf\xac\x4d\x9a\x47\x59\xa2\x6d\x36\x92\xa8\x52\x94\x1d\xf7\xd7\xf7\x0c\x29\xf9\x6b\xb7\xb7\x2d\x10\x20\x5e\x89\x33\x73\xe6\xcc\xcc\x19\x6a\xaa\xb6\xca\xaa\x7f\xc9\x92\xca\xdc\xe6\x54\xe8\xf6\x68\xd4\x76\x67\xe9\x6d\x71\x47\x9f\x3e\x7c\xfc\x40\x0f\x5a\x6f\x2b\x49\x13\x6d\x5a\x6d\x72\xab\x74\x23\xfe\x70\x50\x76\x47\xa9\xec\xa4\xd9\xc3\x72\xa6\x1b\x4b\xa1\x51\xb5\x0e\x28\x53\x8d\xee\x28\x6f\x4a\x18\xf4\x9d\x6a\xe4\xbd\x98\xdc\xfa\xfc\x04\xd3\x92\x1e\x73\x1b\x50\xdc\x14\xf7\xaf\xba\x4b\xf2\x5a\xd2\x5c\xad\xa5\x0f\x79\x2f\x44\xb6\x53\x9d\x7f\xb7\xd2\x1b\x7b\xc8\x8d\x24\x3c\xa8\x54\x21\x9b\x0e\x56\x7d\x53\x4a\x43\x76\x27\x69\x15\xcf\x69\xd1\xca\xc6\x1f\x9e\xfb\x03\x81\xf8\x2a\x4d\x07\x4f\xf4\xf1\xfe\xe3\xe8\x6d\x30\x66\x3f\x48\x5c\xc1\xcb\x5a\x56\xfa\x10\x38\xfc\x78\x98\x57\x9d\xa6\x7c\x9f\xab\x2a\x5f\x83\x02\x07\x33\xa7\x59\xf8\x1b\xe5\xf6\xb3\xd8\x59\xdb\x7e\x7e\xff\xbe\x2b\x8c\x6a\x6d\x77\xdf\xa9\xea\x5e\x9b\xed\xfb\xc5\x6c\x2e\x84\xc3\xb0\x8c\x12\x9a\x2d\x92\x8c\xe6\xf1\x24\x4a\x56\x11\x5d\x40\xa0\x77\xf4\xe9\xaf\x34\x93\x6b\xd3\xe7\xe6\x08\x56\x3e\xfc\x4d\x88\x65\x1a\x85\x4f\x5f\xe6\x11\x65\x48\x63\xab\x11\x9e\xf4\xc6\xe5\xf4\x22\x1f\x7a\x8b\x38\x77\xc4\x2c\x58\x4d\x9d\x55\x75\x5f\xe5\x56\x8a\x83\x36\x55\x79\x50\xa5\xa4\x52\xee\x91\x4c\x5b\x4b\x18\xc1\x4b\xa1\x2b\x64\xe1\x2a\xb8\x97\xb4\x61\x57\xad\xd1\xff\x90\x85\xed\x02\xe7\xa2\x6f\x51\x5f\xeb\xa2\xf1\x5b\x51\x18\xe9\xa8\x27\xb9\xd9\xe0\x85\x83\x92\x17\x79\x29\x6b\x55\x38\x82\x2a\xd5\x6c\x7b\x85\xd0\x05\x9c\xd7\x75\xdf\xa0\x91\x64\xe7\xc9\x83\x43\x78\xdf\x03\x87\xc8\x69\x63\xa4\x74\x4f\x35\x67\xb1\x31\x28\x2d\x60\xfe\x20\xd5\xd0\x61\xa7\x8a\x9d\x8b\xd7\x51\x9d\x1f\xc1\x3f\x75\x3b\x24\x55\xfa\x12\xd4\xec\x04\x7f\xa8\x46\xb4\xb9\xb1\x0d\xf8\xdb\xa9\xd6\x17\x42\x03\xa9\xe9\x5c\x29\xc1\xcf\x6c\x8e\x6a\xa1\x76\x9d\x4b\xe0\xd4\x15\xde\x33\xd0\xc0\x71\x8f\x07\x01\xa8\xea\x4b\xc5\x3f\x6a\x5d\xaa\x8d\xf2\x91\x04\x22\x22\x13\xa3\xd6\xbd\x65\x2b\x00\xae\x8e\x94\xa3\x43\x74\xb3\xe5\xff\xe1\xf4\xe8\xc8\x6e\xb4\xa5\x4e\x57\xe8\x94\x23\x3f\xac\x3b\x59\xed\x25\x50\x64\x03\x6d\xc8\x5f\x35\x45\x85\x18\x6c\xd8\x1c\x51\x06\xa3\xf6\x9e\x74\x4e\x1a\xef\x8b\xbc\x61\x38\x6b\x74\x6c\xc5\x40\x64\xbd\x96\x65\x89\x5f\x37\x28\x80\xeb\xbd\x36\x3e\x9a\x6f\x3d\xb8\xeb\xc6\xde\x1f\xe8\x05\xd5\xbb\xdc\xba\x57\x66\x18\x20\xd1\x80\xe0\xee\x84\x96\xd3\x66\xb4\xb7\x40\xee\x89\x4e\xa0\x1d\xdb\xe7\x03\x5d\x20\x76\xfa\x80\xfe\x31\x0e\x2d\x7b\x01\x60\x23\x2b\x99\x9f\x47\x8d\x43\xba\x1a\x90\x3d\xb6\x92\xbb\x63\x60\xdd\x3b\x46\x32\xff\xec\x95\x91\xae\xff\xd0\x40\xe7\x52\xe0\x59\x8e\xd2\x8f\x03\x7b\x31\x87\xa5\x06\x6e\x8e\x96\xb7\x2d\xf8\xb7\x5a\x38\x06\x75\xd1\x3b\x2f\xae\x23\x39\x7e\xc7\xe4\xda\x13\x78\xed\xe6\x5e\x99\xcb\x0c\xd0\x17\x24\xc4\x34\x9a\xc5\x49\x9c\xc5\x8b\x64\x25\xde\x5c\x69\xc7\x1b\xc0\xd8\xa0\x7f\x18\x10\x7b\xea\xa4\x9b\x92\x8d\xaa\x00\xe1\x94\xa9\x2f\x32\x9d\x14\x4c\x3c\xa2\x18\xd2\xbc\xed\xee\x5e\x83\xcf\x24\x16\xb0\x34\xc0\x5e\xe7\xe6\x07\xd7\xb0\xc3\x60\x15\xbb\x7b\xaf\x37\xdc\xe1\xbe\x3b\x10\x50\xf7\xa6\x90\x3e\x60\x80\x66\x50\xa8\xf2\x20\x25\xbe\x1a\x43\xd6\xa3\xfc\xbd\x79\xa9\x8f\x97\x39\x30\x51\xbe\xee\x5d\x2b\x8b\xa1\xb1\x7d\x70\xca\x37\xd6\x4b\xa3\x38\xcb\x7b\x07\xc7\xae\x36\xc8\x85\xbd\x2f\xf0\x58\x35\x79\x35\x6a\xd4\x2d\x3f\x2c\x1f\xd0\x0a\xd6\x03\xd0\x74\x2d\xc3\x98\xfe\x56\x37\xf0\xd5\x09\x84\xbc\x6c\xe1\x5b\xfe\xe8\xc4\x1f\xc7\x7c\x1a\x27\xf0\x95\x98\x37\xa3\x53\x43\x77\xd8\x5b\x5e\xba\xc1\xb2\xd8\x34\x25\x8a\x64\xf1\x47\x20\x78\x48\xfa\x35\x84\xc8\xf6\xfc\x80\x7e\x61\x65\x61\xbd\xe0\xce\x70\x22\xa3\xa1\xde\xbf\xb8\x66\x1a\xf4\xf4\x0c\xf9\xa4\xb0\x37\x04\x04\x1c\xae\xd8\xe5\xcd\x96\x5d\xa2\x81\xeb\xdc\xb5\x9a\xc0\x63\x16\xca\xb1\x05\xaf\xa9\x60\xe4\xd4\xc8\x03\xc9\x66\xaf\x8c\x6e\x98\x61\x4e\x35\xec\xed\x4e\x9b\x97\x09\x76\x6a\xdb\xf0\x94\x49\x0e\x23\xf9\x17\xe6\x7a\x0b\x85\xac\xf9\xb7\x95\xc5\xae\x51\x05\x40\x1d\x8c\x42\x0d\x39\x53\x3f\x72\x2d\xbc\x68\x97\x19\x52\x69\x4e\x7c\x0f\xc5\xba\xc2\x84\xf0\x62\x19\xa5\x4f\xf1\x6a\x85\x39\xa0\x3f\xd2\x64\x91\x4c\x87\x99\x10\x4b\x69\x6a\xd5\xb9\xa5\x84\xfe\x84\x67\x89\xf4\x10\xbf\xb1\xac\x4c\x4e\xb8\x79\x77\x40\x92\xb7\x32\x18\x61\x0f\xc1\xf5\xda\x62\x8e\x9d\xce\xb9\xc6\x1a\x99\xbc\x8a\xee\x8c\x20\x41\x5e\x78\x8f\x81\xbb\x61\x40\x7c\xa5\x73\xe8\xa4\x6f\x90\xe2\xe3\xb5\xfe\xf9\x3d\x02\x79\xad\xae\x94\x1a\x73\x77\xfa\xd3\xed\xec\xee\x32\xac\x38\x87\x45\x47\xf0\x72\x1b\x29\xd9\x68\xde\x0e\x0c\x16\x7c\x95\x8a\x1b\xb9\xfb\x2c\xc4\xc7\x3b\x4a\xa4\xf2\x2a\xf6\xa2\x98\x8d\x1e\x54\x6e\x43\x0a\xb5\x57\xb0\x83\xe4\xf6\x28\xc7\xb9\x7d\x02\xac\x26\xa2\x73\xf7\xc0\xe4\xb6\xad\x31\xde\xe3\x6a\x1b\x16\x07\xbc\xc9\x6a\x83\xc2\x7c\xba\xfb\x7d\xcb\x57\x29\x1d\xbd\x8d\x0b\x84\xe3\xff\x1f\x9b\x23\xb8\x59\x1d\x32\x87\x44\x70\x55\xd8\x0f\x37\x13\x8a\xea\xb7\x28\xae\x0b\x7b\x79\x71\x25\x84\x32\x43\xe9\xfc\x7e\xbf\xd0\xbd\x7b\x96\x7b\xc8\x9f\xdf\x6b\xec\x65\xd0\xb8\x92\x06\x6a\x59\x88\x2c\xcc\xde\xe5\xd8\xa7\x18\x12\xf9\xd3\x8e\xc2\xb7\xeb\xeb\xbc\x79\x07\x61\x2f\xdd\x15\x6b\x87\x1f\x3c\x20\x98\x33\xe7\xc7\xe3\x68\x81\xb8\x35\x0a\x8a\x85\xdc\x8b\x1d\x26\xe5\x6c\x51\x4b\x9b\xbb\xab\x2b\x88\xab\xca\xce\xe5\xcb\x76\x1c\xc3\x7b\x59\x83\x5e\x5c\xb1\xbc\xb4\x5f\xed\x74\xdd\xc9\xd1\x6c\x58\xca\x90\x7d\x05\xf5\xde\x2b\x79\x38\xcb\x17\xda\xd7\xa0\x58\x7f\x42\xaf\xe8\x17\x35\xfa\xcf\x25\x82\x99\x7b\x73\x25\xdc\x0c\x88\xb5\xdb\xaf\x10\x20\xea\x48\xfe\x6c\xc1\xa4\xb2\x6e\xc8\x2d\x6e\x48\xed\xd5\x50\x0e\xd3\x38\x80\xf1\x45\x32\xd8\xf5\x2d\xf7\x31\x32\xb9\x15\x57\x2e\x87\xe2\x1d\xc6\xfd\x30\x28\x76\xc3\xb7\x19\xec\x54\x1e\x17\x3f\x10\xec\x07\x94\xd6\x8e\x19\x86\xce\xcb\x83\x59\x69\xf9\x1a\xd1\x5c\x88\x09\x67\xcf\xeb\xf4\xcf\x77\xee\xbe\xd0\x0c\xe0\x87\xb4\x5f\x91\xf6\x61\x1f\x93\xd7\xbc\x8b\xb3\x63\xfe\x27\x96\x70\xd5\xc3\x78\x0f\xd7\x0b\x77\x4f\xf1\xf7\xc6\x5a\xf3\xfc\xcb\xa6\xd4\x06\x1c\xf2\x14\x96\xb8\x8b\x58\xe5\x76\xac\xeb\xd3\xdb\x2a\xe0\xf4\xcf\x42\xb6\x6e\xdc\xf3\xe2\x47\xa3\x0f\x98\x8c\xad\x1c\xb4\x7e\x10\x48\x9c\x3b\xa3\x61\x2f\xaf\x81\xf7\xdd\x7d\x85\xde\xf8\x21\xf2\x77\x8c\xdb\x6a\x39\x22\x4f\x05\x03\x4f\x7f\xf1\x3c\xdd\xa8\xe0\x49\xb4\xe0\xed\x2c\x61\xc1\x6b\x9b\x0a\x87\xfb\xce\x11\x05\x56\x2e\xc7\x1a\x65\xc1\x85\x0a\xa5\x7c\x79\xf7\xf0\x6a\xc9\x76\x23\x9d\x17\x86\xec\xea\xf6\xce\x76\x39\xbb\xf4\x3f\x5d\xd5\xd8\xcb\xef\xdf\xd6\xe8\xbf\xdc\xd6\x6e\xeb\xcf\x9b\x89\x44\xc6\xbb\x29\x09\x79\x21\x5d\x7f\x95\xad\x25\x64\x96\x43\xf4\x68\x12\x4e\x6f\xaf\x15\x3e\x05\x36\x74\xb1\xc7\x47\x89\x1a\x25\xfd\x74\xeb\x85\x2c\x0c\x57\xc0\x78\x35\x99\x87\xf1\x53\x94\x8a\xec\x31\xf2\xdf\x63\xab\xc5\x2c\xfb\x16\xa6\x11\xc5\x2b\x5a\xa6\x8b\xaf\xf1\x34\x9a\xd2\x9b\x70\x85\xbf\xdf\x04\xf4\x2d\xce\x1e\x17\xcf\x19\xe1\x44\x1a\x26\xd9\x77\x7c\x5c\x50\x98\x7c\xa7\x5f\xe3\x64\x1a\x88\xe8\xef\xf8\x4a\x5b\xad\x68\x91\x52\xfc\xb4\x9c\xc7\xd1\x14\x5f\xb1\xc9\x64\xfe\x3c\x8d\x93\x07\xfa\x02\xbb\x64\xc1\x5f\x7c\x4f\x71\x06\xa7\xd9\xc2\x99\x0e\xae\xe2\x08\x76\x33\x01\x2c\x93\x47\xfc\x19\x7e\x89\xe7\x71\xf6\x3d\xa0\x59\x9c\x25\xec\x73\x06\xa7\x21\x2d\xc3\x34\x8b\x27\xcf\xf3\x30\xa5\xe5\x73\xba\x5c\xe0\xc3\x31\x4c\xa6\x70\x9b\xc4\xc9\x2c\x45\x94\xe8\x29\x4a\x32\x01\x54\x93\xc5\xf2\x7b\x1a\x3f\x3c\x66\x01\x8c\x32\x3c\xc4\xf7\x77\x1a\x4e\xa3\xa7\x30\xfd\x35\x60\x84\x0b\xa4\x9c\x92\x3b\x82\x5b\x79\x9c\xc0\x09\x45\x5f\x23\xa6\xe0\x31\x9c\xcf\x09\xaf\xc5\xc9\x09\x3d\x2e\xe6\x53\x1c\xff\x12\x01\x7e\xc8\x9f\xa1\x0e\x0f\xe0\x3b\x02\x03\x9a\x86\x4f\xe1\x43\xb4\x3a\x3b\xe6\x63\x3e\x05\x71\xa6\x80\x0d\x1e\xa2\x24\x4a\xc3\x79\x40\xab\x65\x34\x89\xf9\x07\xb8\x8b\xd3\x68\x92\x39\xb2\xc0\x37\xb2\x9f\x3b\x88\xb8\x8d\xac\xa2\xdf\x9e\xf1\x00\xe7\xc4\x10\x02\x45\x78\x8c\x5c\x08\x60\x0e\xf1\x6f\xc2\xed\x41\x2e\xe5\x04\x29\xb2\x9f\x6c\x91\x66\x27\x28\xdf\xe2\x55\x14\x50\x98\xc6\x2b\x40\x10\xb3\x74\x01\xb8\x5c\x43\x58\x70\xd5\x9f\xc1\x21\x17\x2c\x19\xf0\x72\x5d\xf8\xd9\xcb\x8e\xc0\x29\xb6\xf6\x5e\xf1\xfd\x10\xce\xe1\x70\xc5\x30\x5e\x9c\x45\x7f\xfd\x3b\x00\x00\xff\xff\x68\xbf\x26\x59\x3e\x11\x00\x00") + +func licenseBytes() ([]byte, error) { + return bindataRead( + _license, + "LICENSE", + ) +} + +func license() (*asset, error) { + bytes, err := licenseBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LICENSE", size: 4414, mode: os.FileMode(420), modTime: time.Unix(1459927769, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationmonoBoldTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xbd\x77\x60\x54\xc5\xfa\xff\x3f\x73\xce\xd9\xdd\xf4\x64\xd3\x43\x42\x76\x37\x21\xa1\x04\x08\x10\xba\x94\x05\x92\x10\x40\x3a\x48\x96\x96\x84\x26\x22\x55\x8a\x15\x09\x8a\x52\x04\x41\x01\x45\x41\x8a\xa2\xa0\x82\x84\x5e\xa4\x89\xa8\xa0\x22\x28\x36\x14\x05\x01\x89\x5e\x15\x50\xd1\xeb\x15\xd8\xfc\x5e\xb3\x7b\x96\x44\x3e\x78\xef\xfd\x7c\xbf\xbf\xff\xbe\x5c\x9f\xcc\x39\x33\xf3\xb4\xf7\xf3\xcc\xcc\x33\x87\x72\x85\x14\x42\x44\xf3\xc3\x10\xce\xfc\xfc\x3e\x5d\x4b\x9c\x25\xbf\x08\x63\xe8\x68\x7a\x53\x3a\xe6\xe6\xe5\xdf\xfb\xe5\xf8\x0f\x79\x9f\xc5\xfb\xac\x8e\x3d\xba\xf7\x3e\x7e\xee\x93\x0e\xc2\x18\x16\x25\x44\x4e\x9b\x8e\xbd\xfb\xb6\xaf\xb5\xf9\xce\x22\x61\x3c\xdd\x43\x08\x3d\xad\x7b\xef\xec\x46\xf2\xe0\x9e\x56\x42\xc8\xb5\xcc\x2f\x1e\x3a\xa6\x64\x7c\x87\x94\x94\x4f\x84\xa8\x39\x52\x08\x6b\xfd\xa1\x53\x26\x39\x67\x77\x78\xa0\x99\x10\xb7\x14\x08\xa1\xbd\x36\x62\xfc\xed\x63\x1e\x2c\xd9\x66\x17\xa2\xde\x12\x21\x6c\x5b\x6e\x2f\x99\x38\x5e\xc4\x8b\x60\xf4\x0d\x84\x3f\xea\xf6\xd1\xf7\x8e\x68\x3a\xf3\x5a\x98\x10\xbc\xeb\x4b\x96\x8c\x1c\x5e\x32\xec\xaa\x7d\xc6\x04\xe4\xd7\x65\xbc\xe9\x48\x3a\x82\x86\x59\x5b\xf0\x3e\x8c\xf7\x1a\x23\xc7\x4c\xba\xe7\x4b\xcb\xd6\xf6\xc8\x0e\x12\x22\xa3\x78\xf4\xb8\xa1\x25\xf6\x87\xa6\x3b\x85\x68\xfd\x07\xef\xc3\xc6\x94\xdc\x33\x3e\xfc\xa2\x71\x80\xf9\xca\x1f\xe7\xd8\x92\x31\xc3\xfb\x2c\x5c\x74\x54\xe8\x57\x2e\x0b\x11\xfa\xfa\xf8\x71\x13\x27\xb5\x3a\xb4\xb8\x8e\x30\x6c\x65\x42\x0c\x78\x75\xfc\x5d\xc3\xc7\x47\xd6\x5c\x3d\x5b\x88\x26\xb7\x0a\x61\xf9\xd3\x87\x95\x26\xc4\xaf\x0d\x33\x9f\x2c\x8a\x6c\xf5\x9b\xe6\x40\x0d\xbf\xde\x5f\x58\xbd\x63\xa0\xbd\x9a\x71\xf5\x9a\x65\xa1\xed\x3b\xe6\xaa\x41\xe9\x9b\xc0\x4f\xeb\xcb\xd7\x9e\x01\xe4\x23\x57\x33\xfe\xbc\xcf\xb2\xd0\xec\xbf\xfe\x2b\xb8\x50\xf5\x04\x17\xca\x34\x51\x20\x06\x09\x2b\x5a\xa2\x44\xb6\x00\x05\xfd\x84\x6e\x17\x3a\xa3\xba\x71\x44\xdb\x2d\x2c\xd8\xf1\xac\x25\x07\x91\xd5\xfd\xad\x5e\x22\x46\x68\xd1\x41\x16\xcd\x66\x0b\xd6\x34\x8b\x66\x18\xa7\x45\x48\x85\x5b\xdc\x53\x11\xd0\xde\xb0\x5d\xef\x0e\xc2\x29\x9c\xde\x74\x8b\xdd\xdb\x47\x59\xa2\xdd\x5e\x2c\xe4\xbe\x53\xff\xc4\x9e\x96\x96\x3c\x85\x84\x88\x30\x8e\x88\x69\x6a\x36\xad\x49\xf2\x63\xda\x3f\xa1\x5b\xa0\x3c\xb3\x3f\x91\xfe\xaf\xa1\x42\x28\x87\xf7\x93\xd0\x70\x9e\x35\x28\x17\xfa\x94\x77\x0f\x34\x19\x9a\x03\xdd\x0f\x0d\x82\x3a\x42\x23\xa1\xa9\xd0\xc3\xd0\x18\xe8\x2e\xff\x7c\x99\xef\x97\x71\x9d\x3a\x43\x75\x4d\x7d\xb3\xa1\x1e\xd0\x4c\xf3\x79\x8d\xf9\xae\x64\x3f\x07\x8d\x80\x66\x41\xc7\xa1\xa1\xe6\xbc\x02\xb3\xaf\xc0\xe4\xc9\x84\x5a\x43\xd3\x21\xbd\xd2\x3f\xdf\x73\x3f\xf4\x2b\x5b\x07\x40\x5e\xa8\x9e\x71\xa4\xe2\x0a\x7d\xea\x7d\x14\x34\x17\x1a\x0b\x95\x40\xc3\x4c\xbf\x1e\x80\xe6\x43\x53\xcc\xf7\xf5\xe6\x73\x9e\xa9\x7f\xa0\xc9\xa7\x78\xde\x86\xee\x85\x56\x99\x63\x0e\x28\x14\x6a\x68\xda\xa5\xfc\x38\x80\xbe\xb3\xb4\x3b\xa0\xa2\x2a\xd8\x0f\x81\x3a\x99\x3e\xba\xcc\x39\x77\xd2\xba\x4c\x39\xef\x42\x33\xa0\x3e\x7e\xec\x55\x9f\xcf\xf6\x4c\x33\x26\x71\x50\x10\x34\xce\xf4\x7d\x62\x65\x7c\x64\x0c\xed\x59\x93\x5f\x42\x9a\x69\xd7\x03\x55\xf0\xb9\x19\xf5\x30\x31\xad\x4a\xcf\xdd\x40\x11\x55\xe2\x70\x23\x29\x5f\xea\x9b\xf6\x54\x25\xdd\x94\x55\x6a\xe2\x7e\x33\x8a\x35\x63\x31\xec\x06\x9a\x72\x03\xf5\xa9\x12\x87\x1b\x69\xb8\xd9\xce\xbc\x81\x32\xcd\x98\x66\x9a\x7e\x8e\xba\x49\xdb\xc3\xd4\xff\x77\xad\x92\x93\x62\xfa\x3f\xd0\xf4\x67\xd8\x7f\xd1\xf6\x30\x71\xff\xbb\x76\x8e\x69\x9b\x8a\x51\xb0\x89\xf1\x94\xff\xa2\x55\xb9\xf3\x8a\x89\xf9\x66\xc3\xbf\x26\xd6\x9b\x74\xdc\x9c\x53\xb5\xcd\xab\xf2\x2e\xcc\xf6\x46\x9c\x02\xa4\xc6\x27\x54\x89\xf3\xc0\x9b\xb4\xa9\x26\x1e\xca\xcf\xb7\xcd\xf6\x85\x2a\xef\x0a\xeb\x7b\xff\x4d\xab\xd6\xec\x2a\xb3\x6d\x0c\xb5\x81\x36\x18\xfe\x7c\x99\xf9\xbf\x68\x95\xad\x2a\xb7\x75\x53\xb6\xb9\xee\x7d\xb8\xde\xd0\xfa\xf6\x82\x48\xa3\x72\xef\x99\x6b\x3e\x5b\xcc\x78\x28\x1a\x62\xc6\x58\x98\x98\x95\x98\x6d\x6f\xd3\xf7\xce\xe6\xd8\x46\x73\xbe\xd2\xd7\xc5\xa8\x5c\x1f\x81\x38\x04\xf6\x0c\x78\x2a\x8e\x19\x7f\x5d\x33\x03\x4d\x9f\xb3\x4c\x59\x8b\x4c\x7b\xdc\x86\x7f\x0f\x55\x79\xb3\xcb\xc4\x47\x54\xc1\x29\xe0\x73\x23\xc3\xbf\x1f\x2a\xdd\x51\x50\x37\xe8\x51\xa8\x9a\x39\xa6\xf2\xf5\x21\xe8\x3e\xc3\xbf\x26\xa6\x99\x63\xf4\xc9\x1f\xa1\x04\xbf\x9f\xbe\x7d\x28\xcd\xa4\x84\x2a\x18\x58\xcd\x56\xe9\x6b\x61\x54\xae\x91\x40\xee\x05\x7c\xf8\x6f\x63\x34\xcc\xb8\xf9\xba\x8b\x35\xf5\x64\x18\x95\xeb\x21\x80\xdf\x8d\xf9\x56\xcd\x94\xb3\xf9\x26\x36\x2b\x3e\x8f\x89\x61\xd5\x1c\xae\xaa\xa7\xbe\x29\x47\xbd\xe7\x54\x19\x57\xfb\x67\x4f\xa3\x72\xbd\xe6\x9b\x54\xd5\xd7\x9c\x2a\x76\x74\x35\xdf\x03\x79\x5e\x74\x43\x6c\x6e\xcc\x6f\x25\x4b\x9d\x6b\x81\x75\x3e\xc7\x9c\xe3\x36\xb1\x0d\xe4\x68\xc0\x9e\x80\x1d\x7f\xb7\xee\x02\x6d\x20\xdf\x55\xbe\xaa\x33\x78\xa9\x89\x51\x35\xa3\x72\x2f\xaf\x69\xf8\xf7\xcb\x20\xd3\x3e\xa5\x27\xde\x9c\x1b\xc0\x25\xd6\xd4\xa9\xf6\x1e\xb5\x97\x4c\x36\x75\x94\x98\x73\x1e\x35\xdb\x4c\xd3\x6f\xd5\x3f\xd7\xa4\x7b\xcc\xfe\x12\xa3\xf2\x0c\x55\xd4\xc0\xf0\xd7\x01\xc5\x50\xb6\x69\xdf\x9d\x66\x9c\x1e\x30\xed\x6f\x02\xd9\x0c\x7f\xbe\xcf\x37\x2a\xcf\xdc\xbb\xab\x60\xaf\xe8\x94\xe1\xcf\xe5\x2e\x26\xb1\xa6\x2a\x5e\x34\xb1\x9e\x65\xca\x52\x39\xdf\xc6\x7c\x5e\x54\x85\xde\x36\xe9\x0f\x68\x61\x15\xec\xd5\xba\x38\x69\xd2\x59\xb3\xef\x80\x19\x2f\xb5\xa7\x75\x36\xfe\x7a\x9e\xd7\x34\xed\x55\xfc\xb9\xa6\x8f\xf7\x98\xf1\x1a\x6f\xea\xbd\xcb\xc4\x6d\xbe\x69\x6f\x0f\x13\xbb\xdb\xa1\x96\xd0\xe7\x26\x46\x01\x1e\x85\x65\x1d\xc3\xbf\x0f\xa8\x7a\xa1\x2f\x54\xcb\xf4\xe3\x36\x53\x3f\x75\x98\x6f\x2d\xb0\x3e\x2a\xa8\xd5\x64\x92\x49\xef\x41\x0b\x4c\xea\x00\x05\xf6\xaa\x1f\xfd\xf5\x9b\xaa\xeb\xe4\x27\x55\xe8\xb2\x49\x0e\x3f\x5d\xaf\xc5\xda\x98\xf4\xbb\x9f\x34\x7c\x97\xd8\x23\xe7\xfb\xe9\xc6\x77\x9f\xde\xf7\xaa\xc8\x2b\xab\x42\x35\x20\x03\xfa\x02\x9a\x04\xad\x46\xe6\x69\x7f\xee\x48\xce\x0a\xa9\xf2\xec\x7b\x64\x12\x73\x49\x9d\x29\x2e\x98\xf6\x4c\xba\x09\x4d\xf4\x93\xb2\x49\xe9\x57\x7c\xd7\xd7\xf5\x5b\x26\x2d\x86\xda\x81\xcb\x3e\x93\x2e\x9b\xfd\x2f\xdf\x40\xa9\x26\xb5\x14\xe2\x1a\x77\x15\x6f\x89\x10\x15\x33\x85\xb8\x3a\x98\x67\xac\xbb\xc6\x5d\xc6\xbb\x9c\xbe\x89\xb4\xaf\x43\x91\x3c\xbb\x69\xeb\xfa\xe7\x55\x6c\x83\x9a\xfb\xdf\xbd\x6a\xee\x3a\xde\xc7\x56\x92\x88\xa5\xad\x6d\x52\x2e\x54\xcc\x1c\xc5\xf7\x23\x34\x0f\xea\x64\x12\x77\x08\x6f\x6f\xda\x78\xff\x9d\xc0\xa7\x6f\x97\x5f\x57\xc5\x23\x3c\x5f\xa1\x2d\xf0\xeb\x53\xfc\xde\x8d\xd0\x13\x26\x3d\xed\xd7\x5d\x71\x07\xed\x51\x6c\x3e\x48\xfb\x96\xf9\x8e\xcd\xd7\x14\x4f\x2a\xef\x56\x68\xae\xa9\x1f\x5b\xbc\xdc\x73\x2a\xb2\xa1\x65\xcc\xd9\xcc\x7b\x2f\xbf\x6e\xef\x4a\xbf\xed\x5e\x35\xf6\x82\xa9\x2f\x9c\xe7\xd6\x26\xdf\xf3\xd0\xb7\xfe\x79\x5e\x2f\x7d\xdc\x8f\xae\x61\x77\xc5\x38\xbf\x4f\xde\x37\x4d\xb9\xe3\xfc\xe4\x3d\x45\xfb\x38\x82\x95\x0f\x1d\x4c\x8c\x1a\x42\xbd\xff\x9e\xbc\x8f\xfb\x7d\xac\x58\x45\x3b\xdf\xf4\xf7\x35\x53\x37\xb6\x5e\xbb\xc8\x58\x1d\x3f\x79\x67\xf8\x6d\x14\x27\xa0\xfe\xd0\x51\x73\xfd\x8d\xf5\xb7\xea\x8e\x21\xbf\xe4\xf9\x5f\x66\xbe\x51\x07\x57\x1c\x36\xe9\xdd\x2a\xcf\x87\xcd\xfd\x25\x70\xfe\xab\x33\x3c\xda\x7c\x0e\xec\xc3\x6d\x8c\xca\x73\x5c\xe5\x6c\xe0\xde\x31\xd1\x5c\xdf\x73\xcc\x31\xb5\x07\xa8\x3d\x5e\xed\xc3\xc1\xa6\xcc\xfa\xe6\x5e\xf4\x9c\xd9\xaf\xf6\x7e\xb5\x0f\x8e\x33\xf5\x3e\x6e\xf6\xa9\x96\xf5\x22\x6e\x35\xc7\xd7\x9a\x73\x1e\x32\xe7\xa9\x35\xdf\xc1\xdc\x3f\xd4\x9e\xb0\xcc\xdc\x63\x92\x0d\x7f\x0d\xbd\xc2\xdc\x5f\x4a\x4d\x59\xb5\x4d\x52\x35\x61\x76\x15\x5d\x03\xcd\x36\xdb\xdc\x87\xd4\xba\xa3\xfe\xf1\xce\xf2\xb7\xbe\xf1\xfa\xa6\x2d\x81\x73\x25\x50\xef\xaa\x33\x4b\xed\xf1\xdc\x33\x7c\x7b\x9f\x3a\x43\xd4\xde\xd1\xd1\xbf\xee\xae\xd7\xe1\x4f\x40\x4e\xc3\x7f\x9e\x0d\x86\x42\x20\xc3\xf4\x6d\x80\xe9\xd7\xbb\xa6\x0e\x8f\x29\x7b\x72\x15\x7d\x77\x9b\xf8\xcf\x37\x75\x2b\xbc\x5b\x19\x95\x67\x58\x80\x02\xf7\x91\xaa\xb5\x57\xa6\x51\x59\x77\xa9\xb3\x4b\xd5\x71\x5d\xcd\x39\x81\x38\x59\x8d\xca\xf3\x75\x4e\x95\xb8\x47\x99\xcf\x16\x13\xd7\x59\x26\xa9\x39\x11\xa6\x1d\x73\x6e\x88\x79\x0f\x33\xe6\xd6\x2a\x31\x9f\x63\xe2\xe1\x31\x49\xd5\xf1\xdd\x4d\xd9\xea\x7c\x57\x7b\xb9\xba\x83\x8d\x32\x6d\x54\xf3\x7f\x35\x75\x0c\x33\xe7\x0f\x31\xfb\x03\x14\x5d\x45\xff\x40\xb3\x0d\xdc\x55\xc7\x9a\x7e\x37\x34\xe9\x31\x13\xe3\xee\x26\x05\x99\xbc\xb3\x4d\x7d\xf9\x66\x7c\x02\x67\x73\x88\xa9\x5f\xe5\x8e\xaa\x53\x02\xe7\xec\x64\x13\x8b\x81\xa6\x6f\x01\x5b\x02\xf7\xd8\xb6\x7e\x5b\x2b\xbc\x66\x9f\xd2\xd1\xc5\xc4\x40\xe5\x87\x5a\x37\xb9\x26\x06\xca\x8e\x96\xa6\x6e\x85\xd9\x72\xa3\xb2\xce\xae\x5a\xbf\x04\x55\x69\x23\x4d\x0a\x8c\xb7\x35\xe5\x99\x7a\x7d\x35\xac\xca\xb5\xea\xec\x05\x6a\xcf\x60\xdf\xaa\x78\xd4\x4f\xd7\x0e\xb3\x9f\x67\x40\x77\x56\x89\x61\xac\x89\xe3\x2c\x13\x3b\x75\x36\xa8\x5a\x42\xad\xa7\x49\xe6\x9c\x99\xa6\x4d\x9a\x99\x03\x37\xc6\x21\x90\x37\x1e\xb3\xb5\x57\xe9\x57\x98\x4d\x30\x2a\x6b\x7a\xb5\x2e\xee\x36\x2a\xd7\x4f\x6b\xb3\xd5\x4d\x7c\x02\xad\x30\xb1\x51\x6b\x44\xe5\x91\xca\x9d\xde\x66\x3b\xc6\xb8\x5e\x27\xaa\xbb\xbe\xaa\x3d\x02\xad\x2f\xc7\x03\xb6\x2a\xbb\xd5\xba\x56\x39\x14\x57\xc5\xc7\x39\x66\x3e\x04\xd6\xe7\x50\x93\x02\x77\xbe\x9b\xd5\xdf\x55\xeb\xcd\xaa\xed\x8d\xb8\xd4\x37\xfb\x03\xf8\x06\xda\xbf\xab\x4f\x55\xee\x8f\x30\x7d\xcc\xbc\x49\xab\x6c\x54\x79\xab\xd6\xa2\xca\xc7\xee\xa6\xad\x81\xf8\x28\xfb\x1a\x56\x69\xd5\xbe\x5a\x62\xe6\x48\x8c\x89\x9f\x6e\xca\x53\xb9\x2b\x4d\x52\xfa\xbb\x98\x71\x50\x76\x84\x9b\x79\xa0\x6a\xba\x87\x4d\xcc\xa2\x8d\xbf\xd6\xb8\xa1\xfe\x6f\x9a\x72\x35\x74\x5c\x08\x8d\x33\x5d\x6e\x82\x38\xe7\x24\xe7\xad\xbc\xc5\x7c\xe6\xcc\x95\x65\xe6\xb3\x22\x07\x67\xd1\x40\x5a\xf5\xcd\xf2\x0d\x53\x46\x60\x9e\x39\x2e\x0f\x9b\xcf\x13\xcc\xf1\xb7\xaa\xf0\x2b\xb9\x9c\x7d\x5a\x02\xad\xfa\xce\x79\x9b\x9f\x7c\xef\xab\x4d\x32\xe7\xaa\x3e\x5f\xff\xdd\xe6\x33\x7b\xba\x2c\x50\x63\xd4\x54\x49\x81\x71\x55\xef\x55\x79\x4e\x67\x5c\xad\x1b\x6a\x46\xdf\x7e\xbc\xcd\xf0\xd7\xb2\x60\x23\x4f\xf9\x6b\x49\x5f\xce\x0d\xf1\xbf\xfb\xee\x91\xf3\xcd\xbc\x1e\xe3\x5f\xeb\xbe\x7e\x55\x3f\x47\x99\xf9\x3b\xc1\x8c\x6b\x5b\x33\x06\xf7\x9b\x7c\xea\x2e\xd6\x0c\xfa\xb8\x92\xe4\x12\xc3\xff\xdd\x2b\xac\x4a\xbe\xa9\xb3\x48\xad\x8b\x17\xcc\x1c\xa1\x3e\x15\xcf\x98\x39\xaa\xd6\xb7\x3a\xfb\xd4\x77\x80\x56\x46\xe5\x19\xb6\xc2\xd4\xdd\xc4\x94\xa1\x6a\xf4\xd1\x86\xbf\xe6\x55\xa4\x72\xbf\xba\x49\xaf\x98\x7c\x2a\xde\xbd\x0c\xff\x99\x18\xa8\xe3\x03\x79\xab\xea\x42\xb5\xc7\x5d\x33\x71\x79\xcc\x94\x11\x66\xce\xe3\xae\x50\x41\x9d\x2b\x3e\x32\xe7\xaa\x7a\xe3\x1f\x90\xfa\xbe\x46\xcd\x2d\x8e\x80\xb9\xfa\x26\xaa\x64\x7c\x63\xd6\xd4\xd3\xfc\xfd\x3e\x52\x79\x76\xc9\x5f\x0f\xfb\xce\xbe\xf7\xa1\x83\xc8\xfc\x8c\x3e\x75\xe7\x39\x65\xb6\xf5\xfd\xad\x8f\xe2\x4d\x6a\x62\x52\x90\x59\x2b\xab\xef\xb3\x7d\xfc\x63\xe2\xb2\xf9\x6d\xef\xb2\xf9\x6c\x33\xeb\x72\x35\x76\xd1\x3f\xcf\x57\x2b\xab\x1a\xdd\x62\x3e\xff\x69\x62\xf2\x95\x29\x6f\x91\x39\xff\xfb\x2a\x73\xfe\x59\x39\x47\x7d\x93\xa8\xd8\x6e\xae\x0d\xd6\x55\xc5\x21\x68\xb7\xd9\xa7\xf0\x55\xfb\x81\xba\xdf\xa9\x3d\x44\xdd\xa3\x26\x9a\xf5\x7c\x81\x3f\xcf\x64\xb1\x9f\x7c\x71\xca\x34\x31\x9d\x5b\x29\xcf\xb7\xbe\x89\xb1\xbc\xcf\xa8\xfc\xa6\xaa\xc6\xd5\x7d\x41\x9d\x47\x1d\xcd\x78\x35\x34\xe3\xa5\xf4\x34\x35\x49\xed\x3f\xea\xbe\x5d\xea\xcf\x0f\x75\xd7\xf0\xd5\x81\xca\x87\xbe\xfe\x71\x1f\x26\x31\xa6\xdf\x97\x4d\x2c\x67\x9b\x14\x64\xde\x9f\xb6\xf8\xb1\xf0\xe1\xc1\xb3\x54\x6b\x09\xff\xe4\xdb\xe6\xbd\x43\xe1\xa8\xea\x41\x55\x2f\xbe\x63\xae\x13\x85\xf9\x93\x7e\x5f\x65\x7f\x3f\xee\x0a\x67\x1f\x8e\xe9\x50\x8a\xf9\xac\xd6\xc5\xb7\xd0\x6b\x3c\xe3\xbb\xcc\xe2\xac\x7a\xd2\x4f\x15\xf7\xd2\xae\x80\xde\xbe\x81\x0a\xfd\xe4\xbb\x2f\xf8\xea\x69\xe3\xaf\xdf\x03\xe6\xde\xa4\xad\xfa\x5d\xb2\xe4\xbf\x68\xff\xdb\xef\x95\x6b\xcc\x38\xdd\xf8\x7d\xf2\x3f\xb5\x37\x7e\x9f\x0c\x7c\xc7\xb9\xb1\xbd\xd9\xb7\xc9\xaa\xed\x50\x33\x2f\x6e\x6c\xff\xee\x5b\x65\x80\xfe\xd3\xf7\x92\xc0\x19\x39\xab\x0a\x8e\x6f\xff\x9b\xf6\x3f\x7d\xbf\xbc\xd9\x77\xcc\x9b\xb5\xff\xed\x37\x32\x75\x96\x39\xaa\xb4\x81\xef\x9a\xff\x4d\x5b\xf5\x9c\x0c\x7c\x17\xfa\x9b\x6f\xa0\xbe\x58\xad\x32\x79\xd5\xbc\x51\xe6\x77\xd1\xc0\x59\x78\xb3\x6f\xe3\x37\x7e\x33\xfb\x3f\x6d\xff\x53\xee\xa9\x3b\x4a\xdb\x7f\x33\x7e\x63\x8e\xfd\xbb\x98\xe7\xfc\x87\xf1\xff\xa6\xfd\xdf\x7e\x8b\xae\x1a\xcb\xcc\x7f\xd3\xe6\xff\x07\x32\x7f\x3f\xc6\xfb\x82\x49\xdb\x4d\xfa\xd9\x4f\xbe\xf3\xe5\x26\x54\x91\xed\xa7\x6b\x2f\xff\x95\x7c\x75\xd6\xbf\xa1\xbf\xe3\xf3\xa6\xf9\xc9\x57\xd7\xfe\x1b\xaa\x68\xfd\x1f\xf8\x6f\xf6\x7b\x35\x50\x05\x71\xad\xe0\xdc\xbc\xf6\xad\x9f\xbc\x13\xfc\xe4\x3b\xbf\xff\x0d\x79\xa9\x19\xae\x51\xc7\x5c\xe3\x6c\xbc\xa6\x72\x21\xfb\xdf\x93\xd2\x71\x33\x3d\xde\xe1\x7e\xba\x8e\x7b\x00\xcb\x00\x36\x01\x1f\x03\x36\x07\x6c\x08\xc8\xfe\xbf\x8d\xe3\xff\x6d\x5c\xfe\xff\xf2\xfb\xdf\xd8\x5e\x71\xa2\xf2\xd9\x57\x03\xfd\xee\x6f\xd5\xf7\x36\xdf\x37\xb7\x9b\xd8\xed\x55\x35\x43\xb3\xca\xf6\xfa\x3d\x4a\x98\x3c\x7f\x97\x4b\xe6\x5d\xfe\x3a\x5f\x55\x9e\x1b\xf3\xa0\xd4\xa8\xfc\xfe\xa1\x48\xf7\x93\xf7\x29\xe6\x5b\xfc\xb8\xf9\xf6\x38\x45\x2b\xfe\x06\x9f\xae\xd0\x96\xca\xd6\x77\xc7\xa0\x46\x13\x27\x39\x87\x3f\x85\x9c\xd0\x67\x9c\xc7\xaa\x46\xac\x07\x3d\xcf\xbc\xdf\x4d\xba\xe2\xff\xbd\x57\x39\xc1\x7f\xe6\x4b\xf5\x4d\x77\xb6\x51\x79\x3f\x54\xf5\xcd\x3a\x3f\x49\x75\xd7\xb9\xc5\x94\xd5\x95\x36\x3a\x40\x7e\xff\x02\xdf\x6c\x7d\xbf\xaf\xab\x6a\x18\x55\xd3\x6c\x33\xef\x7e\x9c\xc7\xf2\xb3\x2a\x3c\x51\x26\xd9\xfd\xfc\xb2\x63\x65\xfd\xe8\xab\x51\x7e\x32\x9f\xd5\x59\x10\xf8\x76\xa2\x7e\x7f\x45\x7d\x8b\x09\xfc\x3e\xbf\xf2\x25\x70\xc6\xb8\xcc\xdc\x56\x75\x97\xaa\x73\x5a\x57\x99\x13\x6d\xf2\x5f\xff\xfd\x61\x74\x06\x7e\x0f\x45\x7d\x93\x8a\xaf\x22\x47\x61\xa7\xbe\xff\xa8\x7a\xef\x35\x53\xbf\xfa\x26\xc0\x9d\xac\xe2\x73\x08\xbb\x7c\xdf\xfb\x95\x6f\xaa\x0e\x9b\xf2\x3f\x5b\xdf\x73\x57\x53\xef\x48\x53\xfe\x70\x13\x03\x55\x7b\xab\x3b\x81\xaa\xed\x1a\x9b\xfa\xa9\xcd\x7c\xf5\xa0\xf2\x6d\x92\x51\xf9\xbd\x49\xe1\x4f\x1d\xa7\xa9\xef\xbe\xef\xf9\xe3\xa5\x9e\x15\x05\x9e\xab\xb6\x37\x92\x1c\xe5\x1f\x53\xad\xa2\xaa\x63\xff\xdb\xfe\xff\x86\x6e\xfc\x7d\x78\x6d\xc4\x0d\x7d\x6a\x6d\xa8\xfb\xc6\x48\x3f\x5d\xff\x5e\xd2\xd8\x6c\xd5\x3d\x3d\x70\xa7\x1a\x69\xe2\x9f\xe1\x27\xa9\xfa\x93\x4d\xaa\xc6\xbb\xc2\x50\xd5\xda\x4a\x47\x89\xd9\xce\xa0\x5f\xfd\xbe\x91\xca\x61\xf5\x5d\x9d\xbb\x93\x24\x96\x15\x3f\x1a\x95\xdf\x4a\xd5\xf9\x7d\x87\x51\x59\x43\x04\xea\xb9\x40\x5d\x51\x60\xfc\xb5\x6e\xc9\xf5\xf7\xfb\xee\x39\xb5\x69\x87\x90\x3b\x6d\xa1\xf5\xac\x81\x3f\x14\xd1\x5f\xe1\x27\x79\x3c\x40\xf4\xaf\x56\x84\xee\x3f\x54\xde\x43\xf5\xcd\xb1\x8f\x2b\xfd\x90\xa7\xb8\xd7\xaa\x7b\xfc\xab\x86\xff\x4e\xa8\xf2\xb6\xbd\x99\xab\x55\xee\xaf\xbe\x7b\xa9\xda\x47\x54\x3d\x9f\x70\x03\x25\x55\xa1\xc0\xdd\xd8\x94\x21\xd5\x1a\x28\x37\xfc\xf7\x62\xf5\x3c\xb5\x52\xae\xef\xfb\x57\xe0\x3e\x1c\xb8\x0b\xdf\xe4\x1e\xec\xbb\x37\xdf\x6a\xf2\xa9\x39\x35\x85\xb8\xfa\x3d\xfe\x5f\xa3\xbd\xea\xff\xb3\x38\x52\xfd\x5e\xe6\x51\x7f\x2b\xf7\x18\xbe\xdf\xdb\x94\xac\x51\xd9\xcb\x6c\x15\x6e\xca\x1e\x37\xd4\xc1\xfc\x1e\xcf\x5d\x43\x4c\xa1\xfd\x00\xfa\x97\xd9\xfe\x64\xb6\x07\x20\xe5\xef\x51\xf3\x3d\xd0\x77\xa0\xca\xdc\x0f\x0c\x7f\xed\xf4\x9f\xce\xae\xff\x70\xe6\xff\xfb\x33\x5a\xfc\x87\x5f\xa6\x0d\x81\x6f\x70\x05\xe6\xef\x21\xe4\xd1\xb2\xf7\x7a\x55\x1e\xec\x86\x3e\x82\xbe\x84\xce\x42\x1f\x43\x5f\x40\xdb\x85\xb8\x76\xc1\xdf\xfa\xfc\x7a\xa7\x0a\xa9\xf7\x05\x8c\x1f\xf1\xb7\x3e\x5a\x0e\x95\x9a\xad\xfa\x0e\xd9\xd7\x9f\xb3\x15\xdf\xfa\x49\xad\x9f\x0a\xee\xec\x15\x2a\xe7\xd4\x77\xa8\xc0\xb7\x25\xc3\x8c\xbb\xa2\x9a\x55\x48\xc5\x3c\x09\x17\x0e\x42\x67\x15\xf1\xde\x89\x56\x37\x29\xc5\xff\xe7\xb2\x8c\x1a\xbe\x3f\xd7\xa5\xde\x0d\x43\xfd\x59\x31\xaf\x28\x15\x56\xf1\xa0\x78\x50\x6b\xaa\x8f\xd3\x27\xeb\x0f\xea\x73\xf4\xb9\xfa\x2a\xfd\x03\x4b\x8c\xa5\xba\xe5\x1d\xcb\x3f\x2c\x97\xab\xbf\x9b\xba\x34\x75\x79\xea\xbf\x1c\x71\x8e\xea\x8e\x3c\x47\x57\x47\x3f\x87\xc7\x31\xc0\x31\xc8\x31\xd5\xb1\xc5\x71\xd0\x71\xdc\xf1\xa5\xe3\xa2\xe3\xb2\xc3\xeb\x8c\x74\xc6\x39\xd3\x9c\x99\xce\xfa\xce\x06\xce\xc6\xce\x96\xce\x56\xce\x36\xce\x5c\xe7\x60\xe7\x38\xe7\x34\xe7\x22\xe7\x56\xe7\x25\x97\xc5\x15\xe3\x4a\x70\xa5\xb9\x32\x5d\xf5\x5d\xdd\x5c\x7d\x5c\x83\x5d\x33\x5c\x8b\x5d\x6b\xd3\xb4\x34\x6b\x5a\x64\x5a\x74\x5a\x5c\x5a\xb5\x34\x47\x5a\xed\xb4\xac\xb4\x82\xb4\x92\xb4\xe1\xe9\x5a\x7a\x54\xba\x2b\x43\x64\x68\x19\x61\x19\x51\x19\xb1\x19\x89\x19\x29\x19\x35\x32\xea\x66\x34\xce\x68\x95\x31\x3a\xa3\x34\x63\x46\xc6\xac\x8c\xb9\x19\x0b\x33\x56\x65\xac\xcb\xd8\x94\xb1\x2b\x63\x77\xc6\xc1\x8c\xf7\x33\x8e\x66\x9c\xc8\x38\x9f\xd9\x2a\xd3\x9d\xd9\x3e\xb3\x38\x73\x68\xe6\x88\xcc\x3b\x33\xc7\xd5\x1d\x53\xf7\xee\xfa\x09\x6b\x5c\x6b\xe6\x5e\xd1\xae\x34\xbd\xd2\xea\x4a\x9b\x2b\xed\xae\xe4\x5e\xe9\xee\x4d\xaf\xa8\xf0\xfd\x69\xb4\x95\x5a\x73\x7d\x92\x7e\x9f\x3e\x03\xff\x1f\xd7\x5f\xd0\x8f\x59\xaa\x59\x9e\xb0\x1c\xb3\x5c\xaa\x2e\xaa\x7b\xf1\x7f\xa5\x43\x38\x12\x1d\x4e\x47\x81\xa3\x87\xe9\x7f\x91\xa3\xd4\xb1\xcd\xf1\xb6\xe3\x53\xc7\x57\x8e\x5f\x1c\xbf\x3b\xc3\x9c\xd1\xce\x04\xfc\xaf\x83\xff\x8d\x9c\x2d\xae\xfb\x3f\x0a\xff\x17\x38\x57\x9a\xfe\xc7\x9b\xfe\x77\x75\xf5\x76\x0d\xc0\xff\x05\xd7\xfd\xb7\xe3\x7f\x52\x5a\xaa\xe9\x7f\x71\xda\x30\x9f\xff\xce\xbf\xf1\xbf\xc7\x75\xff\x17\x64\xac\xcc\x78\xe5\xba\xff\xef\xe2\xff\xe7\xf8\xdf\xf2\xba\xff\xc3\x33\x47\xe1\x7f\x71\xdd\x09\xf8\x9f\xb0\x66\xd6\x15\x79\xa5\xfa\x95\xe6\xf8\xef\xbe\xd2\xe1\x4a\xbe\xd7\x59\x51\x51\x71\xb6\xe2\x40\xc5\x1b\x15\x7b\x2a\x76\x56\x6c\xa9\xd8\x5c\xb1\xa9\x62\x63\x45\x59\xc5\x2b\x15\xcd\x2a\xb2\x2b\xea\x7c\xe7\x28\xff\xb1\xfc\x1f\xe5\xdf\x97\x9f\x2d\xff\xa6\xfc\x54\xf9\x57\xe5\x5f\x96\x7f\x51\x7e\xa2\xfc\xf3\xf2\xcf\xca\x3f\x29\xff\xb8\xfc\x78\xf9\x87\xe5\xc7\xca\x3f\x28\x3f\x52\xbe\xbf\x7c\x6f\xf9\x9e\xf2\x5d\xe5\xdb\xcb\xb7\x95\x6f\x2d\xdf\x58\x5e\x56\xbe\xa1\xfc\x95\xf2\x27\xca\x1f\x2d\xbf\xbb\xfc\xf6\xf2\x81\xe5\x69\xe5\x11\xe5\xf2\x7c\xc5\xf9\xdf\xce\xff\x72\xfe\x87\xf3\x47\xce\x1f\x3e\xff\xe6\xf9\xe5\xe7\x17\x9e\x9f\x7e\xbe\xd6\xf9\x8c\xf3\xd5\xcf\xa7\x9c\xaf\x76\x3e\xe1\x7c\xec\xf9\xd0\xf3\x21\xdf\x5e\xf8\xf6\xb3\x6f\x3f\xf9\xb6\xc5\xb7\x75\xbf\xad\x7e\xb6\xed\xd9\x36\x67\x9b\x9c\x6d\x74\x36\xfb\x6c\xdd\xb3\xb5\xcf\xa6\x9d\x4d\x3e\x1b\x7b\x36\xfc\xcc\x9f\x67\xca\xcf\x9c\x3b\xf3\xcd\x99\xaf\xcf\x7c\x79\xe6\xe8\x99\x77\xce\x1c\x38\xf3\xfa\x99\x5d\x67\x36\x9f\x79\xed\xcc\xba\x33\xab\xcf\x2c\x39\x93\x77\xa6\xfd\x99\x76\x67\x6a\x9c\x49\x3b\xe3\x3a\x93\x7a\x26\xf9\x64\xd6\xc9\x5a\x5f\xcc\x2e\x99\x53\x52\x23\xbc\x2c\xfc\xa9\xf0\xc5\xe1\x8b\xc2\x17\x86\x3f\x19\xfe\x44\xc8\x1b\x37\xfe\xa9\xc8\xff\xe7\x7e\x59\xb5\x10\xd5\x48\xf1\x3f\x90\x90\xea\xcf\x9d\xfa\x7e\x69\xff\x41\x86\x9f\x53\x17\x86\xb0\xb0\x9b\xd8\x44\x90\x08\x16\x21\x22\x54\x84\x89\x70\x11\x21\x22\x45\x94\xb0\x8b\x68\x11\x23\x62\x45\x9c\x88\x17\x09\x22\x91\xbd\xaa\x9a\x48\x66\x17\xaa\x2e\x52\x85\x83\xd5\xe7\x12\x69\x22\x5d\xd4\x10\x19\x22\x93\x33\xa9\x96\xa8\x2d\xea\x88\x2c\x51\x57\xd4\x13\xf5\x45\xb6\x68\x20\x1a\x8a\x46\x22\x47\x34\x16\x4d\x44\x53\xd1\x4c\x34\x17\x2d\x44\x4b\x6a\xd7\x56\xa2\xb5\x68\x23\xda\x0a\xb7\x68\x27\xda\x8b\x0e\x22\x57\xe4\x89\x7c\xd1\x91\x9d\xbb\x93\xe8\x2c\xba\x88\x5b\x45\x57\xd1\x4d\x74\xa7\x42\xec\x29\x7a\x89\xde\xa2\x8f\xe8\x2b\x6e\x13\xfd\x44\xa1\xf0\x88\xfe\x62\x80\x18\x28\x06\x89\xc1\xa2\x48\x14\x8b\x12\xec\x7f\x54\xcc\x14\xb3\xc5\x63\x62\xa1\x58\x22\x96\x8b\x17\xc4\xf3\x62\xb5\x78\x49\xbc\x28\xd6\x88\x97\xc5\xab\xe2\x15\xb1\x4e\xac\x17\x1b\xc4\x6b\xa2\x4c\x6c\x14\x9b\xc5\x56\xb1\x45\x6c\x13\x3b\xc4\x76\xb1\x5b\xbc\x2e\xf6\x88\xbd\xb6\xaf\xc4\x5d\x62\x98\x18\x2e\xee\xb0\x9d\x12\xf7\x88\x55\x62\xbc\xb8\x33\x28\x81\x53\x71\x54\x50\x33\x31\x4b\x3c\x1b\xd4\x48\x4c\x0c\x6a\x11\xd4\x52\xdc\x2e\xee\x0e\xaa\x13\x54\x2f\xa8\xae\x3e\x21\xa8\x89\x18\x2d\x1e\xd0\xfb\x8b\xb5\x62\x97\x98\x2e\x86\x8a\xb1\x41\x0d\x65\x9f\xa0\xa6\x41\x59\x62\x8c\x98\x6a\x3b\x2d\x86\x88\x87\xc4\x23\xe2\x69\x19\x2b\xe3\x6c\x1f\xda\x3e\xb2\x9d\xb0\x7d\x61\xfb\xc4\xf6\xa9\xd8\x19\x74\x8f\x78\x43\xb6\xb4\x5d\x08\x0a\xb2\xfd\xc3\xf6\x43\xd0\xc6\xa0\x4d\xb6\xaf\xc5\xbd\xb6\xcf\x6c\x5f\xda\xce\x8b\x19\x62\xae\x78\x58\xcc\x13\x73\xc4\x7c\xb1\x40\x3c\xc1\xc9\xb7\x58\x3c\x85\x87\x8b\xc4\x32\xf1\x9c\x58\x2a\x7e\xd5\x66\x6a\xcf\x89\x09\xda\x33\xda\xb3\xda\x52\x71\x9f\xb6\x5c\x5b\xa6\xcd\x12\xc2\xdd\x71\x40\x7f\x4f\x61\xdf\x3e\xbd\x7b\xf5\xec\xd1\xbd\x5b\xd7\x5b\xbb\x74\xee\x54\xd0\x31\x3f\x2f\xb7\x43\xfb\x76\xee\xb6\x6d\x5a\xb7\xba\xa5\x65\x8b\xe6\xcd\x9a\x36\x69\xd8\x20\xbb\x7e\xbd\xba\xb5\x6a\x66\x66\xd4\x48\x4f\x73\x39\x12\x63\xed\x51\x91\x11\xe1\xa1\x21\xc1\x41\x36\xab\xc5\xd0\x35\x29\xea\x3a\xcb\x64\x71\x5e\x99\x9e\xe1\xb4\xe7\x97\xa4\xe7\xa5\x97\x14\xd4\xab\xeb\xcc\x4b\x1c\x99\x5b\xaf\x6e\x5e\x7a\x7e\x71\x99\xb3\xc4\x59\x46\x63\x64\xa6\x17\x14\xf8\xba\xd2\x4b\xca\x9c\xc5\xce\xb2\x4c\x9a\x92\x2a\xdd\xc5\x65\x6e\x66\x8e\xb8\x61\xa6\xdb\x3f\xd3\x7d\x7d\xa6\x8c\x72\xb6\x12\xad\x94\x8a\x74\x67\xd9\x91\xdc\x74\xe7\x0e\xd9\xbf\x67\x21\xcf\xf3\x72\xd3\x3d\xce\xb2\x9f\x7c\xcf\x5d\x7d\xcf\x46\xa6\xef\x25\x9c\x17\x97\x0b\x0e\x9f\x55\xca\x5a\x67\x5e\x59\xfe\x94\x91\x73\xf2\x8a\xb1\x51\x6e\x0c\x0d\xe9\x90\xde\x61\x78\x48\xbd\xba\x62\x63\x48\x28\x8f\xa1\x3c\x95\xd5\x4a\x1f\xbf\x51\xd6\x6a\x23\x7d\x0f\x5a\xad\xbc\x96\x1b\x35\x11\x14\xae\xd4\xe2\x69\x5e\xc9\xb0\xb2\x1e\x3d\x0b\xf3\x72\x93\x5d\x2e\x4f\xbd\xba\x9d\xca\x22\xd2\x73\x7d\x43\xa2\x83\x4f\x64\x99\xb5\x43\x99\xcd\x27\xd2\x79\x87\x32\x5d\x3c\xe6\xdc\x58\x77\xff\x9c\xb9\x3b\xa2\xc4\x90\xe2\xac\xb0\x61\xe9\xc3\x4a\x06\x16\x96\xe9\x25\xf0\xce\xd1\xf3\xe6\xcc\x99\x59\x66\xcf\x2a\xab\x9d\x9e\x5b\x56\xfb\xbe\x73\x89\x78\x3e\xbc\xac\x6e\x7a\x6e\x5e\x59\x96\x92\xda\xa5\xd7\x75\x3d\x5d\x2a\x55\xca\x32\x4b\x06\xc7\xc5\x9c\xdf\x04\xee\xa4\xff\xf4\xe3\x5f\x7b\x4a\xcc\x1e\x6b\x46\xd4\x6f\x42\x3d\x96\x69\x1d\xca\x64\xaf\x42\x97\xfa\x95\x9c\x0f\xd6\x73\xe6\xe4\xa7\x3b\xf3\xe7\x14\xcf\x29\xd9\x51\x51\x3a\x24\xdd\x19\x95\x3e\x67\x63\x58\xd8\x9c\xf1\x79\xc0\x2d\x7a\x14\x22\x62\x47\xc5\xae\xc7\x92\xcb\xf2\xe7\x7a\xca\xa2\x8a\x47\xca\x96\x1e\xd3\xf5\xfc\x5e\x5d\xca\x62\x7a\x0e\x28\x2c\xd3\x32\xf2\x9d\x23\x4b\xe8\xe1\xbf\xb6\xe9\xae\xe6\xc9\x2e\xfb\xf5\x39\x3d\xfe\x6e\x58\x00\x0b\xe0\x80\xb0\xcb\xa5\x60\x78\x6c\x87\x5b\x0c\xe1\xa5\xac\xb4\x67\xa1\xff\xdd\x29\x86\x24\x6f\x12\xee\xec\x2c\x4f\x99\x56\xac\x46\xf6\x07\x46\xe2\xfa\xaa\x91\xd2\xc0\xc8\x75\xf6\xe2\x74\x62\xdb\xa5\x77\xe1\x9c\x32\x23\xa3\xd3\xb0\xf4\x3c\x10\x7f\xac\xa4\xac\x74\x08\xd9\x35\x4a\x05\x26\x3d\xaa\x2c\xe2\xf7\x64\x57\xfa\x9c\x68\xbb\xb3\x45\xb6\xc7\x37\xd7\x89\x55\x9d\x86\xdd\xe1\x2c\xb3\x64\x02\x12\x5c\x55\x19\xc8\x1b\xc5\x32\x27\xca\xf7\x12\xf1\xbb\xbf\xf9\x29\x19\x05\x99\xf6\x68\x67\x8b\x74\xc4\x28\x39\x79\xe9\x79\xc5\xe6\x7f\x53\x46\x26\x22\xc0\x09\xd0\x05\x59\xfe\x44\xe8\x53\x58\xe6\xce\xe5\xc1\x5d\x62\x46\x2c\x6f\x63\x83\x6c\x38\x4a\x8a\x09\xd8\x1d\xb9\xbe\x60\x96\x65\xa7\x8f\x2f\x8b\x4d\x6f\x7f\x3d\xba\xca\xac\xbc\x3b\x7a\x17\xfa\x58\x4c\xb6\xb2\xd8\x0e\x65\xa2\x78\xa8\xc9\x55\x96\x9d\xe7\x5b\x57\xce\xbc\x39\xc5\xb9\x7e\x13\x94\xac\xf4\x9e\x85\x3b\x45\x4e\xc5\xe9\x8d\x8d\x9d\xc9\x9b\xd5\xd6\xe9\xc9\x55\x93\xe3\x3b\x90\x65\x99\x79\x73\x0a\x87\x8d\x28\x73\x14\x27\x0f\x63\xdd\x8d\x70\x16\x26\xbb\xca\xdc\x1e\x22\xec\x49\x2f\x1c\xee\x51\x69\x07\x42\xb5\x4f\x27\xfb\x92\xc3\xe3\xcb\x95\x3e\x85\x5d\x7a\xa7\x77\xe9\xd9\xbf\xb0\xb9\x69\x88\x7f\x40\x89\x33\x32\xf2\x6e\x10\x93\x5e\x98\xec\x17\x43\x02\x96\x05\x65\x04\x39\x0b\xb5\x64\xdd\xc3\xc4\x28\x3a\x9c\xf9\x3c\xa4\xb7\x6f\xc5\xcf\x32\x5b\x46\x10\x14\x05\xe0\xbe\x5e\x95\xb8\xed\x5b\x39\x0b\x65\xb2\x08\xcc\xc6\x8c\xb2\xda\xce\xbc\xe1\xb9\xe6\x3c\xf5\xfe\x17\xa1\x16\x95\x4e\x1d\x0a\x02\xd2\xac\xea\x15\x39\x1d\x0a\x92\x5d\x1e\x97\xff\x57\xbd\xba\x1a\xc3\x4e\x53\x31\x1c\x41\x0a\xd4\x82\xc0\x10\xdb\x14\x03\x41\xe4\x67\x87\x02\x5f\x97\xc2\x32\x51\x25\xbd\xb3\x30\x7d\x78\xba\x27\x7d\xa4\xb3\xcc\xdd\xa3\x50\xf9\xa6\xe0\xf1\xa1\x6c\x82\xe1\xc3\xdc\x8c\x55\x9f\xbf\xbc\x55\x01\x0b\x98\x84\x8b\xe1\xc0\x8b\x02\xb3\x2c\x3f\x2b\xb9\x2a\xb8\x65\x1d\x7d\xef\xd7\x5f\x0b\x6e\x18\xee\x14\x18\x76\xce\x09\x4a\xef\xd2\x7b\x8e\x12\x9e\x6e\x0a\x14\x58\xde\xa9\x4c\xa8\x14\x76\x37\xb7\x27\xfb\xf6\x02\xb5\xa0\xd3\xd9\x7b\x9d\x51\x2c\x69\xdf\x82\x9e\xb3\xd1\xed\x56\x8b\x79\x64\x4b\x25\x24\xbd\xd3\xb0\x39\xe9\xbd\x0b\x5b\xf9\x66\xb3\x9f\x4c\x4d\xbe\x4f\xe9\x8a\x16\x5d\x64\x97\x3e\xed\xeb\xd5\x65\x6b\x6b\xbf\x31\x5d\xce\xea\xb9\xd1\x2d\x67\xf5\xee\x5f\xb8\x33\x8a\x1a\x79\x56\x9f\xc2\x4d\x9a\xd4\x3a\x14\xb7\xf7\x6c\xac\xc1\x58\xe1\x4e\x27\x87\x86\xaf\x57\x53\xbd\xaa\x53\xbd\x38\xd5\x8b\x92\xd4\x8b\x97\x20\xdf\xfc\xe4\x9d\x6e\x21\x4a\x7d\xa3\x86\xaf\xc3\xf7\x3e\x74\x87\x14\xbe\xbe\xa0\x40\x9f\x14\x43\x77\x68\xfe\xbe\x28\xbf\xa2\x4c\x9f\x22\x37\x35\xc8\xd0\x1d\x86\x7f\xc4\x1d\x98\x6d\xd0\x17\xe4\xef\x2b\xf5\xf5\xf9\x7e\x6d\x14\x0a\x32\x77\x88\xc5\x1d\xe4\x0e\x76\x87\x69\xe1\x5a\xf2\x46\xa9\xba\x36\xd1\xb3\x4b\xfd\x9d\x17\x29\x36\x87\xc9\x70\x99\xbc\x11\xae\x5e\xbe\xee\x1d\xb2\x74\x63\xb0\x3b\xd9\x3f\xa3\x94\x19\x6e\xbf\x85\xb3\xfa\x56\xaa\xee\xdb\xbf\x70\x33\x15\x8d\x4c\xf6\xfd\x44\x51\x7b\xf5\x8b\x74\x49\x1c\x49\xb0\x39\x56\xf2\x9c\xc3\x54\xa2\x3c\xe0\x19\x39\xa7\xd8\xa3\x16\x9b\x88\x27\x34\xfc\x27\xcb\x64\x7a\x1b\xc2\x94\xde\x06\x43\xac\x61\x65\x21\xe9\xc3\xdb\x97\x85\xa6\xb7\x57\xfd\x6d\x55\x7f\x5b\x7f\xbf\x55\xf5\xdb\x48\x51\x19\x2f\x61\x2f\x25\xf6\x3d\xca\xa4\xca\x80\x01\x85\x2e\x96\xa4\xb3\xda\xe1\xe4\x39\x51\x3f\xa9\x48\x79\xd8\x54\xe6\x44\x7d\x5b\xaf\x5d\x96\xec\x2d\xa4\xec\x2a\xfa\xca\x5e\x66\x7b\x9b\xec\x43\xa5\xe5\x90\x7d\x69\xb9\xb4\xc8\xee\x22\x47\x76\xa3\xff\x56\x5a\xc6\xc5\x6a\x7e\x5e\x86\x34\xd9\x5a\xb4\x96\xad\x18\x69\x05\x67\x4b\xda\x5b\x78\x57\x6d\x13\xd9\x78\x53\xa9\x43\xb4\xab\x27\x1b\x8b\x28\x48\xf3\x51\x7d\x46\x72\x44\x81\x6c\x84\x8c\x52\x7e\x4a\xc8\xdf\xdb\x10\xbe\x06\xf4\x46\xf2\x53\x42\xfe\xde\x6c\x7a\x69\x85\x93\x9f\xc5\x10\x55\x24\x3f\xd5\x1b\xe3\x9b\xa4\xe8\xbb\x43\xd6\xdb\xd4\x5a\x35\x75\x37\x8b\x52\x47\x69\xbb\x24\x99\x0b\xbb\xa2\x36\xb0\x77\x90\xed\x45\x05\xe6\xb7\x37\xdf\xdb\xc1\xe6\xa6\x75\x9b\xef\x6d\x11\xdf\xc6\x9d\xdc\x37\xea\x9a\xfc\x39\xbf\x95\xe3\x52\x7e\x85\xa3\xed\xc5\x71\x17\xb5\xee\x3f\x16\xfd\xa8\x65\xff\xd0\xf6\x07\x6d\x97\xcc\x62\x4e\x9d\x6d\x7d\xff\xd1\xfa\xfb\xbe\xdf\xc9\x76\x76\x59\x1b\x73\x04\x3f\xa5\xd8\xe0\xfb\xe9\xe4\x67\x0f\xa8\x18\xd2\x31\xbf\xb6\x3b\x5e\x96\x95\xcb\x69\xe7\xe7\x9f\x5f\x71\x5e\x3f\xfa\xad\x74\x7f\xeb\xac\x91\x7f\xf1\x9c\xdc\x21\x6b\xb9\x13\xcf\x46\x39\x8a\xcf\xca\x33\xa7\xab\x39\xbe\x39\x5d\xcb\x71\xaa\xf5\xd7\x7d\xbf\x6a\xad\xf7\xfd\x5e\xb6\x0b\x97\x75\x7c\x7e\xd6\x41\x58\x1d\xb0\xa9\xc3\x81\x5b\x87\xec\x8c\x94\x75\xdc\x0e\xb9\xe1\x6b\x79\x52\xaf\x70\xac\x38\xbe\xe1\xb8\x76\xf8\x50\x2b\x47\xe4\x21\xc7\x21\xed\xe0\x9b\xd5\x1c\xee\x37\x63\x12\xf3\x77\x48\xd7\xa6\x03\xad\x1c\x3b\xa4\xd3\x1d\xbc\x9f\xc1\x7d\xb2\x78\x1f\xea\xac\xee\xea\x7b\x6b\x39\xb2\xf7\xca\x3d\xbb\xab\x39\x22\x77\x3b\x76\x4f\xdb\x3d\x7f\xb7\xb1\x6b\x67\x35\x47\xf7\xed\xd3\xb6\x6b\x91\x7b\xa5\x05\x6c\x2c\x62\x05\xb4\x41\x5a\xdc\xa1\xc6\xb1\xcd\x32\x72\xb3\xdc\xa4\x37\x42\x56\xf2\xe6\x57\x0a\x1c\x8e\x76\x09\x32\x45\x64\x43\x9a\xe8\xce\xcf\x22\x68\x1c\xb4\x01\xda\x07\x1d\x85\x2e\x42\x15\x50\x90\x70\xcb\x14\xb7\xbd\x7a\xcd\xfc\xb2\xf5\xad\x1c\x3d\xd6\x17\xaf\x3f\xbd\xfe\xd2\x7a\xc3\xbd\x43\xa6\x6e\x8a\x8a\xc9\xdf\x59\xb1\x5f\x56\x77\xc7\x85\x45\xe6\xbf\xfa\x0a\xc3\xaf\x14\xbf\x72\xfa\x95\x4b\xaf\x18\x2f\x37\x5a\xdb\x17\x13\x6b\x8a\xf9\xd0\x0a\x68\x83\xac\xe9\x4e\x33\xc4\xda\xa8\xb5\xce\xb5\xfa\xca\x65\xb5\x1c\x3d\x56\x14\xaf\xd0\x96\x2f\xe5\xe2\xbc\xac\xc7\x32\xad\x74\xe9\x82\xa5\x97\x96\xea\x0d\xda\x45\xc8\x1a\x28\xac\x01\x5c\xea\x83\x44\x91\x4c\x27\x16\xd3\x7c\x3f\x37\xc8\x74\x77\x8a\x8c\x7a\xb6\xf4\xd9\x05\xcf\xea\x0b\x9e\x91\x4b\x9e\xae\xe5\x28\x7e\x5a\x8e\x7b\xea\xe8\x53\xa7\x9e\xd2\x17\x3c\x25\xf7\xc8\x8e\x32\x8f\xca\xdf\x21\xf3\x65\xde\xa6\x61\xa4\x4d\xb2\x8c\x82\xb1\x3b\x3f\xa7\x41\x9a\x68\xe0\x7b\xdf\xe7\xfb\x39\x9e\x9f\x0b\x7c\xbd\xc7\x7c\xef\x91\xe6\xac\x0d\x32\xca\x1d\xaf\x47\x2e\x6e\xbb\x58\x8b\x5c\x24\x23\x17\x65\x2f\x6a\xbb\x68\xda\xa2\x15\x8b\x2e\x2e\xb2\xee\x90\xd1\xee\xea\x73\x6b\x3a\x16\x3e\x59\xd3\xb1\x80\xf6\xe2\x3c\x19\x39\xd7\x31\x57\x53\x3f\xb2\xe7\xae\x98\x6b\x44\xee\x96\x76\xd4\xdb\x85\x56\xb1\xdf\x1d\x32\x27\x32\x3a\xbf\xfb\x4c\x59\xf4\x10\x41\xab\xe6\x8e\xb9\xbb\xae\x63\xca\xc4\x5a\x8e\xc9\x13\x93\x1c\x93\xa0\x89\x3d\xa2\x1d\x7b\x64\x92\x8c\xe7\x2e\xe3\x90\x89\x32\x7e\x53\x5d\xc7\xb4\x7d\xbc\xce\x87\x56\x40\x3a\x38\xc4\x6d\x4a\x4a\x21\x0f\x62\xdd\x0d\xf2\xeb\x3a\xc6\xe7\x37\x72\x8c\x83\xc6\x92\xcf\xd5\x64\x62\xdf\xa4\x9c\xc4\xbe\xb6\x1c\xbd\xaf\x95\x14\x1a\x52\x54\xc3\x51\x02\x15\x43\x45\x3d\x92\x1c\xe3\x77\xc9\x10\xd2\x2d\x64\xab\x36\x38\xbf\x86\xa3\xfb\x0e\x19\xe3\x4e\x92\x03\xf3\x93\x1c\x03\xfa\x37\x72\xf4\xcf\xaf\xe6\x88\x69\x14\xdd\xd7\x22\xf5\xbe\x46\x23\x9d\x65\x16\xe4\x76\x25\x3b\x1d\x91\xba\xec\x8d\x55\xbd\xa0\x9e\x3d\x52\x1d\xdd\xf2\x53\x1d\xb7\xe6\xd7\x77\x4c\x63\xbf\x86\x73\x87\x8c\xd8\x9c\x5f\xcb\x41\xe0\xc3\xdc\xe3\x42\x23\xf2\x3b\xe7\xa7\x38\x2e\x76\xaa\xe8\xa4\xf5\xe8\x24\x3b\xe5\x87\x3a\xda\x16\x74\x2f\xd0\x0a\xf2\xe3\x1d\x1d\xf3\x63\x1c\x91\xf9\xd3\xf2\x2f\xe6\x57\xe4\x1b\x29\xc3\x92\xfb\x26\xc8\xb8\xbe\xf1\x8d\xe2\xfa\xda\x65\x64\xdf\xa8\x46\x91\x7d\xb9\x07\xf4\x55\x7b\x85\x23\xb2\x6d\x64\x51\xe4\xb4\x48\x23\x32\x32\x3b\xb2\x7b\xe4\xb8\xc8\xf9\x91\xa7\x22\x2b\x22\x6d\x6d\xe9\xbb\x18\xa9\x8f\x13\x6c\x50\xb2\x34\x5e\x5a\x00\x70\xc1\xc6\x3e\xbd\xb3\xb2\xba\xec\xb0\x55\x50\x53\x06\xf7\x18\x50\x26\x67\x95\x65\xf4\x56\x3f\xdd\x3d\xfb\x97\x59\x67\x95\x89\xbe\xfd\x07\x14\x6e\x94\xf2\x71\xcf\x23\xf3\xe6\x89\xf6\xd5\xbb\x94\x35\xea\x5d\x58\x56\x5c\xdd\xd3\xa5\x6c\x18\x0f\x6e\xf5\x50\xca\x43\x54\xf5\x8d\xf1\xa2\xbd\x67\xe2\xa4\x89\x93\x26\x67\xf9\x7f\xc9\x49\x59\x59\x93\xb2\x26\xf2\x33\x4b\x64\x4d\xf2\x75\x4d\xf4\xf5\xab\x07\xe1\x7f\x0e\xbc\xfb\x86\x84\xff\x75\xe2\x44\x86\x11\xa4\x3a\x27\x4d\x9c\x38\x71\xd2\xa4\xc9\x93\x27\xab\x7e\xba\xd4\xeb\x64\x46\x79\xe2\x99\x3e\x25\x7c\x62\x96\x4f\xcb\xc4\x89\x92\x91\x2c\x5f\x2f\xfc\xec\x45\x4a\xb4\x98\xc4\xbb\x50\x8c\x7e\x55\x6a\xcc\x2f\xd7\x67\x19\xda\xc4\x44\xe9\x17\x12\xb0\xd0\x27\x2c\xf0\x5f\x56\xc0\xd0\x44\x21\x2c\xef\x73\x7b\x9e\x6a\xc9\xe3\x56\xdd\xcd\xf7\xf3\x2f\xbf\x8c\x96\x9c\x02\x77\xfb\xff\xcc\xb7\xfa\x59\x31\xc4\xff\xec\xed\x57\xf1\xcf\xff\xf3\xcf\x05\xff\xf3\x97\xff\xef\xa3\x92\xe3\x99\xe2\x67\xf1\xb5\xd4\xc4\x49\x69\x70\x57\xbe\x24\xfe\x10\x6f\x70\x63\x3e\xae\xbe\xfb\x56\xf9\x54\x50\x53\x3a\xa4\x14\x97\x98\x73\x4e\x5c\x16\x27\xc5\xa1\x9b\x4b\x45\x5e\x98\xcc\xf0\x3d\x7e\x28\xbe\x16\xe5\xe2\x6d\x6e\xb2\x37\x9b\xe7\xe5\x3c\xd3\xc4\x37\x62\x96\x9c\x21\xb6\xc9\x45\xb2\x3f\xf8\xc5\x8a\x2f\x99\xfd\x0a\x65\xe4\x72\x51\x2a\x26\x1b\x2b\x8d\x37\xa5\x4b\x9e\x93\x17\xc4\x7a\x79\x8b\x6c\xa8\x3d\xa5\x8d\x95\x11\xe2\x8c\x36\xfd\xaf\xb2\xbc\xbf\x54\x5c\x40\xd2\x05\xb9\x80\x9f\xdf\xcb\x25\xca\x72\xcb\x74\x3d\x89\x13\xba\x8d\x98\xa9\xbd\xa8\xf5\x15\xef\x61\x73\xb1\x36\x4f\x1b\xc3\xd1\xf4\x3e\x67\xa5\x90\x03\xc4\x34\xf1\xb4\x29\x60\xa2\x98\x7a\x83\x79\x99\xdc\xde\x97\x8a\xe1\x7f\xed\x27\x56\x61\x5a\xd7\x8a\x5f\xc5\x36\xb1\x5f\xbc\x2b\xbe\xe0\x8e\x3f\x97\xfb\xf9\xca\xab\x67\xae\x6e\xac\xb8\x8c\xfe\x8b\x58\x20\xb4\x24\x19\x27\x43\x4c\x96\xbd\x01\x5e\xeb\xcb\xfa\x78\x6d\xb7\x16\x74\xed\x19\xee\xf5\x4f\x88\xae\xfc\x6f\x98\x18\x26\x8f\x89\xcf\xa4\xd3\x3b\x06\xeb\xf6\x73\xd7\x3f\x26\xee\xa5\xbc\x19\x6a\x70\x5d\x65\x53\x3d\x05\x3e\x63\xc4\xf3\x62\xb4\x78\x52\x6c\x15\xaf\x88\xcf\x65\x1f\x69\x15\xcf\x8a\x45\x32\x57\xe6\x55\xd4\x15\x4b\xcd\xbf\x30\xac\x8b\xf3\x96\x55\x96\x87\x44\x98\xe5\x3d\x11\x75\x35\xb5\xe2\x57\xed\x8a\x88\x34\xe2\x85\xcd\x7b\x5c\xec\xf3\x8e\xf4\xeb\xd7\x87\x8a\xd0\x6b\x91\x15\xbf\x55\xdc\x53\x71\xc9\xfb\x7b\xc5\x19\x5d\xd7\xee\x37\x92\x2c\x2f\x5a\x36\x59\xde\xf4\xd9\x37\xdd\xb8\x5b\xc4\x19\x27\x7c\x19\xf7\x96\x77\x9a\x78\x98\x58\xfc\x82\x05\x9f\x5c\x77\xbf\xe0\x06\x52\x7f\x6f\xfb\x2a\xfe\x36\x47\xfa\x5c\xf2\xb6\x14\x84\x96\xf8\xb2\x5b\x58\xeb\x42\xf4\xd9\x6a\x41\x8b\xa0\x63\xfe\x7c\x0b\x6a\x0c\x8d\xa7\x92\x6b\x00\xad\x16\x22\xa4\x50\x88\xd0\x1e\xd0\x49\x21\xc2\xe0\x0d\x1f\x06\x91\x59\x11\xc8\x8e\x9c\x04\xf1\x1c\xe5\x84\x66\x09\x61\x37\x20\xbc\x89\x46\x46\x0c\x32\x63\x6b\x40\xdf\x09\x11\xc7\x58\xdc\x1f\x42\xc4\xd3\x26\xa0\x23\x01\xde\x44\xc6\x12\x89\x45\x12\x3c\x49\x33\xa0\x83\x42\x54\x43\x6f\x35\xf4\x24\x17\x43\xa7\x85\x48\x41\x46\x75\x64\xa5\x32\x27\x15\x1b\x52\x77\x08\xe1\x48\x81\x90\xe9\xbc\x07\xba\x24\x84\xab\x0f\x84\x9d\x2e\xe6\xa7\x61\x73\x1a\x3a\xd2\x98\x97\x76\x59\x88\x74\xe6\xd5\x40\x46\x06\x32\x32\xce\x91\x32\x2b\x85\xa8\x09\x7f\x4d\x30\xa9\xf5\x00\x04\x7f\x6d\x74\xd6\x66\xed\xd6\xc9\x15\x22\x0b\x00\xb2\xe0\xaf\x4b\x5b\x77\xbf\x10\xf5\x18\xab\x07\x5f\x7d\xe4\x65\xbb\xa1\xdd\x42\x34\xc0\xee\x06\xf8\xdc\x70\x99\x10\x8d\xb0\xa9\x51\x99\x10\x39\xf8\x9c\x03\x36\x8d\x6f\x85\x98\xdf\xf8\xb2\xff\xef\x98\x37\x05\xdb\x66\xd8\xd4\x0c\xdb\x9a\xe3\x73\x73\xf4\xb6\x44\x4e\x4b\x70\xbf\x05\xbe\x56\xe8\x6a\xcd\x9c\xd6\xf0\xb7\xc6\x9f\x36\xeb\x20\xf4\xb6\x25\x76\x6d\xcf\xa9\x0b\x80\x10\xed\xc0\xb8\x1d\x73\xdb\x63\x5f\x7b\xc6\xdb\x63\x43\x87\x56\xd0\x16\x21\x72\xe1\xcd\xc5\x96\xbc\x30\x08\x7d\x79\xd8\x94\x3f\x10\x42\x7e\x3e\xf3\xf2\xf1\xab\x23\xfe\x76\xc4\xce\x8e\xf0\x16\xe0\x4f\x01\x76\x16\xc0\x53\x40\x3c\x3a\xc1\xdf\x89\xf9\x9d\x98\xdf\x89\xf9\x9d\x98\xdf\x99\x58\x76\x26\x3f\x3a\x63\x6b\x17\x72\xa4\x0b\xe3\x5d\x18\xef\xc2\x78\x17\xf0\xba\x95\x7c\xe8\x4a\x3e\x75\xc5\xe6\xae\xc8\xea\x8a\xac\xae\xcc\xed\xc6\xdc\x6e\xd8\xd9\x1d\x9b\xbb\x83\x57\x77\xec\xef\x11\x0b\x61\x77\x0f\x7c\xeb\x81\xfe\x9e\xf0\xf7\x62\x77\xed\x85\x7f\xbd\xf0\xab\x17\xf1\xe8\x45\xde\xf5\x26\x27\x7a\xc3\xdf\x1b\x5d\xbd\xd1\xd5\x87\xf9\x7d\x88\x69\x9f\x8f\x85\xaa\x2a\x45\x5f\xc6\xfa\xa2\xb7\x2f\xb2\xfb\x62\xf7\x6d\xf0\xf4\xa3\xbf\x1f\xfd\xfd\xe8\xef\x47\x7f\x3f\xf0\x28\xe4\xb9\x90\xe7\x42\xf4\x17\x12\x7b\x0f\xba\x3c\xe8\xf2\xa0\xcb\x03\x36\x1e\xfc\xf2\xc0\xdf\x1f\xbf\xfb\x93\x37\xfd\xc9\xbb\xfe\xd8\xdc\x9f\xf8\x0c\x00\xc3\x01\xe0\x3a\x90\xeb\xd8\x40\x30\x18\x84\xed\x83\xb0\x7d\x10\x98\x0d\xc2\xce\x41\xf0\x0e\xc2\xcf\xc1\xf0\x0e\x06\xcf\xc1\xd8\x38\x98\x98\x0e\xfe\x5c\x88\x22\xf2\xa5\x08\x4c\x8a\xc0\xa4\x08\x4c\x8a\xc0\xa4\x08\x3d\xc5\x60\x5f\x4c\x5c\x8a\xc9\xb5\x12\xf2\xa6\x04\x19\x43\xb0\x6f\x08\xf6\x0d\xc1\xbe\xa1\xd8\x37\x14\xfb\x86\x22\x6b\x28\xfe\x0e\x85\x6f\x28\x31\x18\x06\xdf\x30\x6c\x1e\x4e\xde\x0f\xc7\xbe\xe1\xd8\x37\x02\xfb\x46\x90\xc7\x23\xc0\x68\x04\xb8\xdc\xce\xd8\xed\xc8\xba\x9d\xf1\xdb\xb1\x61\x24\x36\x8c\x24\xd7\x46\x82\xc1\x48\xd6\xf9\x1d\xbc\xdf\x81\xcc\x3b\x98\x3b\x8a\xb9\xa3\xc0\x6a\x14\x3e\x8f\xc2\xe7\x51\x60\x75\x27\x6b\x6c\x34\x7a\x46\x13\xd7\xd1\xe8\x1c\x83\x2d\x63\xb0\x65\x0c\x7a\xc7\xe0\xd7\x18\xd6\xe1\x58\xe6\x8d\x63\x7c\x1c\xe3\xe3\x19\x1f\x4f\xee\x8e\xc7\xc7\xf1\xf8\x38\x1e\x5b\xc7\xe3\xe3\x04\xfc\x9a\x80\xdc\x09\xe8\x9c\x00\xdf\x04\x62\x73\x17\xb1\xb9\x0b\x7d\x77\xd1\x7f\x17\xbe\xdd\x45\xff\x5d\xd8\x38\x11\xdb\x26\x81\xed\x24\xf0\x9b\x04\x26\x93\xc8\x89\x49\xf4\x4f\xc6\xd6\xc9\xf8\x36\x99\xd8\x4f\x46\xdf\x64\xf2\x64\x0a\x72\xa7\x60\xcf\x14\xf0\x9f\x02\xfe\x53\xc0\x6e\x0a\xf8\xdf\x0d\xfe\x77\x83\xc1\xdd\xcc\xbd\x1b\x1c\xef\x06\xc7\x7b\x88\xd5\x3d\xc4\xea\x1e\xe6\xde\xc3\x3e\x72\x2f\x72\xef\x43\xfe\xfd\xc8\xbd\x1f\x7b\x1e\xc0\x8e\xa9\xd8\x3f\x15\x3c\x1e\x1c\x2d\xc4\x34\x6c\x9b\x46\xac\xa7\x81\x6b\x29\xef\xd3\xd1\x3d\x9d\x79\x0f\x21\xe3\x21\x74\x3f\x8c\x0d\x33\xf0\x75\x06\xb6\x3d\x02\xcf\xa3\xd8\xf1\x28\xba\x67\x12\x83\x99\xbc\xcf\x62\xfe\x2c\xfc\x9f\x8d\xdc\xd9\xac\xf5\x39\xe0\xf4\x18\xbc\x8f\x61\xe3\x63\xe0\x36\x17\xdb\xe6\x91\x0f\xf3\x58\x03\x8f\xb3\xff\xcc\x47\xd7\x02\xb0\x5e\x40\xac\x9e\x00\xff\x27\xb1\xff\x49\xf4\x2e\xa4\x6f\x21\xf1\x59\x04\xef\x62\x62\xb4\x18\xec\x9f\xa2\xef\x29\xf8\x9e\x86\x6f\x09\x18\x2c\x01\xeb\x67\x18\x7f\x86\x79\xcf\xc2\xb7\x14\x6c\x97\x82\xe7\x32\x64\x3e\xc7\xf3\x73\xe8\x5e\x8e\x1d\xcb\xb1\x63\x05\xfd\x2b\xb1\x7b\x25\x38\xac\xa4\x7f\x15\xb9\xb7\x0a\x9e\x55\xc4\x66\x15\x76\xaf\xc2\xe6\xe7\xe1\x7b\x1e\xbf\x5f\x60\x3d\xac\x06\x87\xd5\xe0\xf7\x22\x7b\xce\x8b\xe8\x7c\x09\x1b\x5e\x02\xdf\x97\xf0\xf7\x25\xec\x7b\x09\x3f\x5e\xc2\xe6\x97\xc0\xe6\x25\x62\xbd\x06\x0c\xd7\x20\x7f\x0d\xb9\xb3\x86\xdc\x5b\x83\xbe\x35\x8c\xad\xb9\xe4\x3f\x6a\xd6\xc2\xbb\x96\x58\xad\x25\x06\x2f\xf3\xfc\x32\xfa\x5f\xc6\x96\x57\xe0\x79\x15\x1b\x5f\x25\x17\x5e\xc5\x9f\x57\xc1\x77\x1d\xe7\xc8\x3a\x62\xb4\x0e\x3f\xd7\xa9\x77\xb0\x5e\x07\xc6\xeb\xf1\x7f\x3d\x36\xae\x27\xe7\x5e\xc3\xe6\x0d\xe8\xd9\x40\x3c\x37\x80\x6d\x19\x3c\x65\xe8\xda\x48\xbc\x37\x12\x83\x4d\xf8\xb6\x09\xc5\x9b\xe0\xdd\x8c\xed\x9b\xe9\xdb\x8c\x6d\x9b\xc1\x78\x33\xfd\x9b\xe1\xd9\xcc\xfc\x2d\xcc\xdf\x42\x3c\xb6\x30\x7f\x0b\x58\x6c\x41\xee\x16\xb0\xd8\x82\x8e\xad\xac\xf7\xad\xf0\x6d\x25\x37\xb7\x62\xcf\x56\xec\xdf\x8a\xfd\x5b\xc1\x65\x1b\xf1\xde\xc6\x9a\xda\x86\xed\xdb\xb0\x7d\x1b\x98\x6d\x03\xab\x6d\x8c\x6d\x87\x6f\x3b\x32\xb7\xa3\x6f\x07\xbe\xee\x00\xff\x9d\xe0\xb3\x13\xb9\xbb\xb0\xff\x75\x6c\xdd\x4d\x9e\xef\x61\xce\x1e\x62\xb1\x17\x39\x7b\x91\xb3\x97\x18\xef\x05\xd7\xbd\xd8\xb0\x17\xfb\xf6\x81\xcd\x3e\xe6\xee\x23\x97\xf7\x91\x3b\xfb\xc0\x60\x3f\x6b\x64\x3f\x3e\xec\xc7\x87\xfd\xcc\x79\x83\xe7\x03\x9c\x95\x6f\x12\x93\x83\xe0\xf9\x16\x32\xde\x46\xe7\xdb\xf8\xf6\x0e\xf8\x1f\x42\xc6\x21\xf4\x1e\x06\x87\x77\xb1\xe7\x5d\x6c\x79\x8f\x79\xef\xe3\xef\x11\x7c\x38\x02\xa6\x1f\xd0\x1e\x65\x3d\x1c\x45\xe6\x31\xfa\x3f\xc4\xd6\x0f\xf1\xe3\x23\xe4\x1e\xc7\xb6\xe3\xe8\xfe\x98\x58\x7f\x82\x8f\x9f\x62\xf7\x67\xcc\xfd\x8c\x3c\xf9\x1c\x39\x27\xc0\xe7\x04\x76\x7d\x41\x0e\x7e\x89\x2d\x27\x99\xff\x15\x32\xbf\x22\x67\xbe\x26\x36\xa7\xc0\xec\x34\x3e\x9c\x66\xfe\x37\xd8\xf0\x0d\x72\xcf\xe0\xe3\x59\xf2\xf7\x2c\xcf\xe7\xb0\xfb\x5b\xf0\xfa\x16\xfe\xf3\x60\x7c\x1e\xbe\x72\x72\xa3\x9c\x9c\xfa\x0e\x6c\xbe\x27\x3e\xdf\xe3\xe7\x3f\x88\xf5\x0f\xf8\xf2\x23\xfe\xff\x48\x0c\x7e\x82\xef\x27\x78\x2e\x10\xb3\x8b\xd8\x74\x89\x79\x97\x98\xf7\x33\x73\x7e\x86\xef\x17\xf2\xf4\x17\x72\xe7\x57\x70\xfd\x95\xf7\xcb\xe8\xb8\x4c\x7e\xfd\x06\x36\xbf\x23\xe3\x77\xec\xfa\x27\x6b\xe7\x9f\xc8\xfa\x03\x7b\xfe\x85\xcd\xff\x02\xf7\x3f\x91\x7b\x05\x9f\xae\xd0\x7f\x95\xbe\xab\xf4\x5d\xc3\xd6\x6b\xe0\xea\x25\x8f\xbc\x07\x7d\x7f\xaf\x53\x72\x17\x96\xe2\xa0\x90\xf2\x56\xe8\x63\x21\xb5\xd1\xd0\x6a\xca\xb9\x61\x42\x1a\x4e\xe8\x92\x90\x16\xe6\x59\x63\xa1\x52\x68\xbf\x90\xb6\x05\x42\x06\x0d\x14\x92\xfa\x49\x95\x98\x32\xb4\xae\x90\x61\x7d\x84\x0c\xef\x21\x64\x44\x73\x21\x23\x91\x15\x45\x6b\x67\xcc\x3e\x49\xc8\x68\x64\x46\x23\x27\x06\xbe\xd8\x02\x08\xde\xd8\xab\x42\xc6\x8d\x84\x1e\x80\x78\xa6\x6e\x92\x09\x41\x10\x3a\x12\x98\x4b\xe8\x64\x22\x77\xee\x44\xe6\x26\xae\x85\x2e\x53\xd4\x63\x2b\x75\x94\xac\xc6\x58\x35\xf8\xaa\xcd\x85\x96\x41\x3f\x0a\x99\xcc\x58\x32\xbc\xc9\xf8\x92\xcc\xdc\x94\x5a\x10\xf2\x53\xe0\x4d\xf9\x5c\xc8\xea\x06\x84\x4d\xd5\xb1\xa5\x3a\x73\xaa\xa3\x33\x35\x17\x42\x46\xea\x31\x21\x1d\xf8\xe7\x60\xbe\x63\x11\x84\x3c\x27\xbe\x3b\xdf\x17\xd2\x05\x8f\x6b\x87\x90\x69\x61\x10\x98\xa4\x21\x2f\xbd\x31\xc4\xdc\x1a\x89\x10\xbe\xd7\x40\x77\x0d\xfc\xac\xc1\xbc\x1a\xc8\xcd\x70\x43\xf7\x40\x65\xd0\x1f\x42\x66\xc2\x9b\x09\x3e\x99\xc8\xab\xc9\x73\x4d\xf0\xa9\x89\xde\x9a\xbc\xd7\x42\x7e\x2d\x6c\xaa\xb5\x5b\xc8\xda\xf8\x5b\x1b\xbf\x6a\xd3\x5f\x07\x7b\xeb\x20\xb7\x0e\x72\xeb\xac\x83\xc0\x24\x0b\x9f\xb2\x18\xcf\xe2\x3d\xeb\x34\x84\x9f\x75\xc1\xa7\x2e\x7e\xd7\x25\x66\x75\xbf\x13\xb2\x1e\xf2\xeb\xa1\xbf\xde\x12\x88\xf1\xfa\xd8\x5a\x1f\xcc\xeb\xa3\xa3\xfe\x4a\x08\xbe\x6c\x74\x66\x23\x27\x7b\x0b\x84\xaf\x0d\x88\x63\x03\xfc\x69\x80\xef\x0d\x88\x6f\x03\xfa\x1a\xe2\x5b\x43\xf0\x69\xc8\xbc\x86\xcc\x6b\x78\x4e\xc8\x46\x60\xd4\x08\x3f\x1a\xe1\x5b\x23\xfa\x1a\x61\x53\x0e\x76\xe6\x20\x2f\x87\xd8\xe6\x80\x6b\xe3\x14\x08\x9c\x1a\x13\xcf\xc6\xe0\xd1\x04\x9e\x26\xd8\xdd\x04\x9e\x26\xf8\xd5\x14\x1f\x9b\x12\xc3\xa6\xf8\xdb\x14\xdc\x9b\xc1\xdf\x0c\x5d\xcd\xf0\xb5\x19\x79\xd6\x0c\xbe\x66\xe0\xd6\x0c\x5f\x9a\xd3\xdf\x1c\xac\x9a\xf3\xde\x1c\x9b\x5a\x60\x4f\x0b\xec\x69\x81\xaf\x2d\x90\xd5\x12\xbb\x5b\x62\x77\x4b\x6c\x69\x89\x2d\xb7\x10\xb3\x5b\xb0\xef\x16\x64\xdc\x42\x5f\x2b\xec\x6a\x85\x4d\xd4\x9d\xb2\x35\x32\x5a\xe3\xbb\x1b\x39\xed\xb0\xb1\x1d\xf3\xda\x81\x63\x3b\xe2\xd3\x1e\xfb\xda\x17\x42\xc4\xb6\x3d\x73\x3a\x30\xde\x01\x9e\x5c\x62\x9b\x0b\xfe\xb9\xc8\xa0\xfe\x94\x79\xe8\xcb\x83\x2f\x0f\xdb\xf3\xc9\xd5\x7c\xe4\xe7\x63\x5f\x3e\x76\xe7\x93\x87\xf9\xe8\xc8\x67\x6e\x3e\xf9\x46\x5d\x2a\x3b\x32\xb7\x23\xf6\x75\x3c\x04\x9d\x84\xb0\xb1\x00\x1f\xa8\x51\x65\x01\xf3\x0b\x98\x5f\x00\xde\x9d\xc0\xa3\x33\x31\xea\x8c\x0d\x9d\x89\x41\x17\x30\xe9\xc2\x7b\x17\x30\xbd\x95\xf6\x56\x72\x8a\x7a\x54\x76\x45\x66\x37\x62\xdd\x1d\x9b\xba\xe3\x5f\x77\x74\x75\x67\xcd\x52\x83\xca\x1e\xe4\x53\x0f\x64\x52\x83\xca\x1e\xd8\xd7\x13\x1d\x3d\x99\xdb\x13\x19\x3d\xe1\xeb\x89\x8c\x5e\xf8\xd0\x0b\xfc\x7a\x31\xb7\x17\x36\xf6\x02\xe3\xde\xcc\xeb\xcd\xbc\xde\xcc\xeb\x43\xdc\xfa\x20\xbb\x2f\xf3\xfa\x62\x73\x5f\x78\x6e\xc3\xe7\xdb\xc8\xb1\xdb\xc0\xf4\x36\x74\xde\x06\x3e\xfd\x88\x4b\x3f\xf8\x0b\x79\xf7\x90\x6b\xd4\x9b\xb2\x3f\xfe\x0d\x60\xce\x40\x6c\x1f\x08\x8e\x83\x88\xf3\x20\xe2\x31\x08\x39\x83\xe1\x1f\x8c\x9f\x45\xf4\x17\x83\x75\x31\x36\x97\x90\x8f\x43\x98\x33\x04\x7b\x87\x82\xf3\x50\xc6\x86\xd1\x37\x1c\x3f\x87\x13\xdb\x11\xe4\x2f\x35\xa0\xbc\x1d\x9c\x6f\x27\x87\xd5\x3f\x00\x75\x3b\x76\x8f\x04\xab\x3b\x68\x47\xd1\x3f\x0a\xf9\xa3\xc0\x93\x9a\x4f\xde\xc9\xf3\x68\xe4\x8d\x26\x37\xc6\x30\x7f\x0c\x18\x8c\x25\x86\x63\xc9\xdb\x71\xec\x4b\xe3\x19\x1f\x8f\xef\x13\xb0\x7d\x02\xeb\xe0\x2e\x7c\x9d\x88\xde\x89\xd8\x35\x09\xdc\x27\x81\xd1\x64\x7c\x9a\x82\x1d\x77\xa3\xeb\x9e\x1a\x10\x7d\xf7\xf2\x7e\x1f\xfc\xf7\x81\xc5\xfd\xe8\x7e\x80\x78\x4c\xc5\xc7\xa9\x60\x3e\x95\x39\x53\xd1\x35\x15\x7b\x1f\x84\xe7\x41\xb0\x7c\x10\x2c\x1f\x04\xcb\x07\xd1\x31\x8d\x71\xea\x2f\x39\x8d\xb8\x97\x32\xaf\x14\x7b\x4a\x89\x51\x29\x79\x3f\x1d\xb9\xd3\xd1\xf7\x10\x7e\x3e\xc4\xf3\x43\xac\x95\x87\xd0\xf7\x10\x7a\xa8\xcd\xe4\x0c\xe4\xcd\x80\xef\x11\xec\x7e\x04\x1f\x1f\x21\x2e\x8f\x80\xf1\x23\xcc\x79\x14\x39\x8f\x82\xf5\xa3\xf0\xce\x44\xee\x4c\xc6\xa9\xd7\xe4\x6c\xf2\x76\x36\xf9\x33\x9b\xbc\x98\x83\x4f\x73\x90\x3f\x87\x18\xcf\x21\x3e\x8f\x81\xd7\x63\xe0\xf4\x18\x7e\x3f\x86\xac\xc7\xf0\x85\xe3\x42\xce\x05\xb3\xb9\xe8\x98\x8b\xbc\xb9\xe8\x9b\x87\xaf\xf3\xe0\x7f\x9c\xb9\x8f\x83\xdd\x7c\x62\xb7\x80\xf1\x05\xc8\x7a\x02\xff\x9e\xc0\xbf\x27\xc9\xf9\x85\xc8\x5b\x08\x16\x0b\xb1\x69\x21\x36\x2d\x82\x77\x31\xf3\x9f\x82\xef\x29\xe6\x3c\x0d\xcf\xd3\xd8\xb7\x04\x8c\x97\xe0\xf3\x12\xe2\xbc\x04\x3b\x9e\x81\xef\x19\x62\xf0\x0c\xb1\x7e\x86\x78\x3c\x4b\xfe\x3c\x8b\xce\x67\xf1\x7f\x29\xb9\xb1\x94\xd8\x2e\x63\xce\x32\x30\x7c\x0e\xfc\x9e\x83\x77\x39\xfe\xae\x40\xce\x0a\xe6\xac\xc0\x8e\x95\x8c\xaf\xc4\xaf\x55\xc8\x59\x05\x5e\xcf\x93\xaf\xcf\xe3\xfb\xf3\xd8\xf5\x3c\xf6\xbe\x40\xff\x0b\x60\xb8\x1a\xbe\xd5\xe4\xc3\x6a\xfc\x59\x8d\x7d\x2f\x82\xc9\x4b\xe8\x7b\x89\x98\x50\xdb\xc9\xb5\xe4\xf6\x5a\x9e\x5f\x26\x8f\x5f\x01\xc3\x57\xf0\xe5\x55\xf4\xae\xc3\x9e\xf5\xc8\x5c\x8f\x8c\xd7\x78\xdf\x00\x5f\x19\x79\xbc\x89\x39\x9b\xf0\x71\x33\x72\xb7\xe0\xe7\x56\x72\x75\x2b\xf9\xb3\x8d\x7e\x6a\x27\xb9\x0d\x1f\xb7\x63\xff\x0e\xd6\xfc\x4e\x6c\xdf\x89\x8d\xaf\x33\x6f\x37\xba\x76\x63\xfb\x6e\xde\xf7\x80\xfd\x5e\xf2\x87\xfa\x48\xee\xc5\xa6\x7d\x8c\xef\x03\x27\xea\x22\xb9\x1f\xdb\xde\x40\x27\x35\x90\x3c\xc8\xf3\x5b\xe4\xd8\x5b\xf0\xbd\x8d\xfe\x77\xe0\x79\x87\xf9\x87\xf0\xf1\x10\x98\x1c\x26\x6e\x87\xc1\xf9\x5d\x70\x79\x17\x4c\xde\x63\xde\xfb\xe4\xd1\x11\xf8\x3f\x20\x1f\x8f\x22\xe3\x18\x38\x1d\xa3\xff\x43\x9e\x3f\x02\x9f\x8f\xf0\xe1\x38\x79\x75\x9c\x73\xe1\x63\xec\xfd\x98\x78\x7c\x42\x4c\x3f\xe1\xfd\x53\x78\x3f\x43\xcf\xe7\xd8\x73\x02\xdd\x5f\xe0\x3f\xb5\x90\xfc\x92\xe7\x2f\x19\xfb\x12\x39\x27\x91\x71\x12\xdd\x5f\x11\xa7\xaf\xd8\xbb\xbe\x66\xcf\xfe\x1a\x7d\xa7\x68\x4f\x21\xfb\x34\xbc\xa7\x91\xf9\x0d\x98\x9f\x21\xfe\x67\xc0\xf7\x2c\x76\x9e\x25\x3f\xce\x81\x1b\xb5\x91\xfc\x96\xf6\x3c\x7e\x9d\x47\xee\x79\xfc\x29\x47\xde\x77\xe4\xee\x77\xd8\xfc\x3d\xb6\x7d\x0f\xff\x3f\xc8\x8b\x1f\xd0\xff\x03\x6b\xe8\x47\x30\xfe\x91\xbe\x9f\x78\xfe\x09\x9d\x3f\x11\xaf\x0b\xc8\xbc\x00\xe6\x17\xf0\xe1\x02\xd8\x5e\x00\xbf\x0b\xe8\xbf\x80\x1f\x17\xc1\xe9\x22\xf2\x2f\x92\x9b\x17\x19\xbf\x48\x4c\x2e\x82\xed\x25\x78\x2e\xc1\x73\x09\xfd\x97\x98\xf7\x33\xf1\xf9\x19\x7b\x7f\x66\x1d\x50\x67\xc9\x9f\x89\xcd\x2f\xe4\xcd\x2f\xc4\xf3\x57\xf0\xfa\x15\x7d\xbf\xb2\x4e\x2f\x23\xef\x32\x36\x5c\x26\xa6\xd4\x5d\xf2\x32\x76\x5e\x26\xe7\x7e\xc3\xb7\xdf\x58\x4b\xbf\xd1\xf7\x1b\xba\x7f\x47\xde\xef\xc4\xe3\x77\x64\xfd\x8e\x8e\x7f\x92\x37\x7f\xa0\xef\x0f\x74\xfd\x0b\x59\x7f\x12\xb7\x3f\x79\xbe\x02\xde\x57\x98\x77\x15\xcc\xae\x61\xe7\x35\xe6\x7a\xc1\xb7\x62\xa4\xd0\x84\x13\xfa\x58\x68\xf2\x1e\xa1\x69\x41\xd0\x4a\xa8\x0c\xda\x2f\x34\xdd\x0d\x1d\x84\x18\xd7\xcf\x09\xcd\x98\x25\x34\x4b\x5d\xa8\x15\x74\x2b\x34\x10\x1a\x0d\x1d\x13\x9a\x75\x18\xb4\x5a\x68\xb6\x58\x68\x11\x04\x9f\xed\x47\xa1\x05\x4d\x82\xd6\x42\xcc\x09\xae\x01\x15\x42\xe8\x0d\xde\x21\xb4\x90\x07\x20\xe6\x84\xa2\x27\x14\xbd\xa1\xef\x43\x97\x85\x16\x56\x0b\xc2\x9e\xb0\x75\xd0\x6e\xa1\x85\xa3\x33\x1c\x9d\xe1\xf0\x85\x2f\x81\x90\x17\x0e\x7f\x04\xba\x22\x98\x17\x59\x00\x31\x2f\x8a\x39\x51\xe8\x8b\x42\x97\x1d\x3d\xf6\x52\x88\xb9\x76\x74\x44\xa3\x3b\x1a\x79\xd1\xdf\x09\x2d\x26\x0c\x6a\x0e\x61\x73\x0c\xb6\xc6\x30\x3f\x16\xdf\x63\xfb\x40\x73\x21\x6c\x8f\x43\x67\x1c\xfe\xc5\xd3\x1f\x8f\x8e\x04\x78\x12\x78\x4f\x60\x6e\x22\x7d\x89\xd8\x9e\x08\x26\x49\xb4\x49\x5b\x84\x56\x8d\xf1\x6a\x33\xa0\xab\x42\x4b\x1e\x2f\x34\x6a\x41\x2d\xa5\x18\x3a\x24\xb4\xea\xf0\x53\xfb\x69\xa9\xb4\xd4\x7c\x9a\x03\x9c\x9c\x0d\x20\x30\x76\x25\x42\xcc\x49\x43\x76\x1a\xe3\x69\xd8\x93\x06\xfe\x69\xa7\x85\x96\x8e\xcd\xe9\xc8\xac\xc1\xdc\x8c\x1e\x42\xcb\xc4\xa6\x4c\x7c\xcc\xc4\xa7\x9a\xbc\xd7\xc4\xce\x5a\xcc\xaf\x6d\x40\xf8\x5d\x9b\xb9\xb5\xc1\xaf\x0e\x72\xea\x60\x5b\x1d\x9e\xb3\x18\xcb\x02\x07\xae\xa4\x5a\x5d\xe2\x58\x0f\x5d\xf5\xf1\xb1\x3e\xe3\xd9\xc8\xca\x06\xc7\x06\xe0\xd7\xe0\x73\xa1\x35\xc4\xe6\x86\xe0\x42\xed\xa5\x35\x22\xae\x39\xbc\x53\x67\x69\x39\x8c\xe7\x80\x27\xa5\xbd\x46\x7d\xa5\x51\x57\x69\x4d\x54\x8b\xac\xa6\xf8\xd3\x14\x3b\x9b\xe2\x4b\xb3\xc6\x10\xb6\x35\xcf\x85\x90\xdf\x82\x98\xb6\x04\x2b\xea\x25\xad\x25\xb1\xbd\x05\x3c\x6e\x81\xe7\x16\xb0\x68\x05\xf6\xad\xd0\xd9\x1a\xff\xa9\x93\xb4\x36\xc8\x68\x43\x6c\xdb\x46\x41\x8c\xbb\xd1\xef\xfe\x43\x68\xed\xd0\x4d\xcd\xa4\xb5\xa7\xed\xc0\x1c\xae\x1d\x5a\x2e\xf8\xe5\xc1\x43\x1d\xa4\x51\xf3\x68\x1d\xf1\xaf\x00\xfc\x0b\xc0\xa3\x13\x7c\x9d\xb1\xbb\x33\x78\x74\x26\xd6\x5d\xc0\xe7\x56\xf0\xbb\x75\x99\xd0\xba\xa2\xab\x2b\xb6\x74\xc5\xf6\x6e\xc4\xba\x1b\xb1\xec\x8e\xdc\xee\xe4\x4e\x0f\xfa\x7b\xe0\x77\x4f\xf8\x7b\x31\xbf\x17\xb6\xf4\xc6\x9f\xde\xc4\xa1\x0f\x31\xee\xb3\x00\x42\x6f\x1f\x78\xfb\xe0\x4b\x5f\xd6\x42\x5f\x64\xde\x46\xee\xde\x86\xac\xdb\xe0\xef\x07\x56\x85\xbc\x7b\x88\x4d\x7f\x64\x0c\x00\xb3\x81\x8c\x0d\x42\xe6\x60\xb0\x1e\x4c\x3c\x8a\xb0\xa9\x18\xbf\x4b\xd0\x35\x04\x99\x43\xf0\x75\x28\xf2\x86\xa1\x67\x38\xb8\x0d\x67\xfe\x08\xda\x11\x97\x84\x76\x3b\xfd\x23\x99\x77\x07\x7a\xa8\x37\xb4\x3b\xd1\x31\x1a\xbc\x47\xe3\xef\x18\x72\x6c\x2c\x3a\xc6\xb1\x7e\xc7\x21\x6f\x3c\xf8\x4f\xc0\xa6\xbb\x52\x20\x30\x9e\x88\xee\x49\xe4\xd4\x64\x6c\x9a\x02\x6e\x53\xd0\x73\x0f\xb9\x70\x2f\x38\xdd\x0b\x66\xf7\x81\xcf\xfd\xf0\xdf\x0f\xef\x03\xd8\x31\x95\xb9\x53\x99\xf3\x20\xfd\xd3\xe8\x9f\x06\xf6\xa5\xc4\xae\x14\x99\xd3\xe1\x9b\x8e\xde\xe9\xe4\xcd\x43\xf4\x3d\x84\x2f\x0f\xa1\xff\x21\xf2\xe9\x61\xb0\x79\x18\x1c\x67\x80\xd5\x0c\x78\x1f\xc1\xff\x47\x88\xfd\xa3\xe4\xe2\x4c\xf4\xce\x04\xff\x59\xc4\x63\x16\x7d\xb3\xf1\x65\x0e\xcf\x73\xb0\xef\x31\x74\xce\x25\x7e\x73\x89\xe3\x3c\xf4\xcd\x43\xce\x3c\xe4\x51\x03\x68\xea\xaf\xf2\xcf\x87\x6f\x01\xf9\xbe\x00\x99\x0b\x88\xcf\x13\x60\xf2\x04\x7d\x4f\x10\xe3\x27\xc0\xf1\x49\x64\x3f\xc9\xdc\x27\xc1\xe6\x49\x64\x2f\x64\xee\x42\x7c\x5e\x48\xae\x2c\x44\xce\x22\x64\x2c\x42\xee\x22\xe2\xbb\x08\x5b\x17\x11\xcf\x45\x60\xb4\x08\xfc\x17\x63\xc3\x62\xfc\x5d\x8c\x3f\x8b\x89\xe9\x62\x70\x5e\x8c\xcc\xa7\xc0\xee\x29\xf4\x3c\x45\xbc\x9e\x42\xd7\x53\xe8\x7d\x0a\xd9\x4f\x93\x37\x4f\xa3\xeb\x69\xb0\x78\x1a\xfd\x4f\x83\xdf\x12\xf0\x58\x02\x0e\x4b\xc8\x63\x6a\x0d\x6d\x09\x18\x3c\x83\xce\x67\xc8\xf9\x67\x78\x7e\x96\xe7\x67\xd1\xff\x2c\xb2\x9f\x45\xf6\x52\x64\x2f\x25\x2f\x96\xd1\xbf\x0c\x79\xcb\x18\x5b\x86\xbd\xcb\x88\xe5\x32\xd6\xcc\x32\x78\x9e\x03\xdb\xe7\xe8\x7b\x0e\x3d\xcb\x89\xeb\x72\x6c\x5f\x8e\xed\xcb\xb1\x7d\x39\xb6\x2f\xc7\xf6\x15\xac\x8f\x15\xf4\xaf\x20\x5f\xa8\x49\xb4\x95\xc8\x59\x09\xcf\x4a\xe4\xac\x04\xcb\x95\xf4\xaf\x62\xce\x2a\x7c\x5c\x45\x2c\x56\x31\xb6\x0a\x79\xab\xc8\xdb\x55\xe8\x58\x85\x8c\xe7\xb1\xe1\x79\x6c\x78\x1e\xde\xe7\x91\xf5\x3c\xfe\x3e\x8f\x8e\xe7\xd1\x41\x1d\xa3\xbd\x80\x5f\x2f\x10\x8f\x17\x90\xf7\x02\x79\xb8\x1a\x5b\x56\x13\xab\xd5\xf4\xad\xc6\xd6\xd5\xe4\xcc\x8b\xe4\xc4\x8b\x60\xfe\x22\xb8\xbc\x88\xee\x17\xc1\xfd\x45\x70\x7f\x91\x1c\x7a\x89\xfe\x97\xd0\xfb\x12\xfd\x2f\x31\xff\xa5\x93\x42\x5b\x83\x4d\x6b\xc0\x76\x0d\xb8\xae\x41\xcf\x1a\xec\x58\x8b\xae\xb5\xe8\x5f\x8b\x8f\x6b\xd1\xbf\x96\xfe\xb5\xf4\xbf\xcc\xdc\x97\xc9\xdb\x97\xd9\x2f\x5e\xc6\xf6\x97\xb1\xe3\x65\x74\xbe\x82\xdd\xaf\xe0\xd7\x2b\xc4\xee\x15\x30\x7f\x05\x7d\xaf\xd2\xf7\x2a\x7e\xbc\x4a\xdf\xab\xe4\xdc\xab\xd8\xf1\x2a\xfa\xd6\x91\xe7\xeb\xf0\x63\x1d\x6b\x66\x1d\x73\xd7\x11\x87\x75\xd8\xb6\x1e\xfe\xf5\xc4\x61\x3d\x7b\xd8\x7a\x6c\x5b\x8f\x8c\xd7\xc0\xf1\x35\xf4\xbd\xc6\xdc\xd7\xb0\xef\x35\x62\xfc\x1a\x7e\x6f\xc0\xbe\x0d\x60\xb8\x81\xfe\x0d\xe4\xeb\x06\x30\xdc\x40\xec\xcb\x88\x65\x19\x78\x94\x81\x47\x19\xef\x1b\xc9\xa1\x8d\xe4\xca\x46\x64\x6d\x64\xdd\x6c\x62\x7c\x13\x7c\x9b\xc8\x8d\x4d\xd8\xbf\x09\x9b\x36\x81\xfd\x26\xf2\x60\x33\x32\x37\x63\xd7\x66\x64\x6e\x66\x6c\x33\x63\x9b\x19\xdb\xcc\xd8\x16\xc6\xb6\x30\xb6\x05\xbf\xb7\xe0\xcb\x16\xec\xdb\x82\xcc\x2d\x8c\x6d\xc5\x9f\xad\xe4\xfc\x56\xf0\xda\x4a\xbc\xb6\x62\xcf\x56\x70\xd9\xca\xf8\x56\x74\x6e\x43\xe7\x36\x74\x6e\x43\xe7\x36\xe4\x52\x17\x6a\xdb\x90\xbb\x0d\x9f\xb7\x33\xb6\x9d\xb1\xed\x8c\x6d\xc7\xe6\xed\xf8\xb8\x9d\xf1\xed\xf8\xb9\x1d\xbc\x77\x20\x7b\x07\x18\xee\x20\x96\x3b\xc0\x65\x07\x78\xed\x20\x16\x3b\xc8\xfd\x9d\x60\xb3\x93\x78\xee\x24\x9e\x3b\x19\xdb\xc9\xd8\x4e\x7c\xdd\x49\x9e\xed\x02\xfb\x5d\xd8\xb4\x0b\x9b\x76\x61\xd3\x2e\xd6\xd3\x2e\xb0\xd8\xc5\xf8\x2e\xec\xda\x05\x36\xaf\x13\xcb\xd7\xd9\x1b\x5e\x87\xff\x75\xf8\x5f\x27\xce\xaf\x33\xfe\x3a\xfc\xbb\xc9\xa1\xdd\xc4\x63\x37\xfc\xbb\xf1\x79\x37\xe3\xbb\xf1\x79\x37\xb1\xde\x0d\xfe\x7b\xd0\xbd\x07\xdd\x7b\x88\x17\x35\xac\xb6\x07\xbb\xf7\x10\x83\x3d\xc4\x77\x2f\xba\xf7\xa2\x7b\x2f\xbc\x7b\xd1\xbd\x17\x3c\xf6\xb2\xbf\xec\x25\xce\x7b\xb1\x7b\x2f\x7e\xef\x63\x8d\xee\x83\x7f\x1f\x79\xb7\x8f\xfc\xd8\x87\x0c\xea\x5e\x6d\x1f\xfa\xf7\xa1\x7f\x3f\xfa\xf7\xa3\x7f\x3f\xb1\xdc\x0f\x36\xfb\xc1\x66\x3f\x3a\xf6\x83\xcd\x7e\xb0\xd9\x8f\x9e\x37\xd0\xf3\x06\x7a\xde\x40\xcf\x1b\xe8\x79\x03\x3d\x6f\xa0\xe7\x0d\x6c\x7c\x03\x1d\x07\xd0\x71\x00\x1d\x07\xd0\x71\x00\x1d\x07\xd0\x71\x00\x1c\x0e\x80\xc3\x01\xf4\x1c\x40\xcf\x9b\xe8\x79\x13\x3d\x6f\xa2\xe7\x4d\x72\xfd\x4d\x74\xbc\x89\x1f\x6f\x22\xff\x4d\x62\x7b\x10\xfc\x0f\xa2\xe3\x20\xb1\x3f\x48\x0c\x0e\xa2\xe7\x20\xf1\x3f\x08\xd6\x07\x89\xc3\x41\xfc\x79\x0b\x2c\xde\x42\xcf\x5b\x60\xf1\x16\x3a\xde\x42\xc7\x5b\xe8\x78\x0b\x1d\x6f\x81\xf5\x5b\x60\xfd\x36\x7a\xde\x46\xcf\xdb\xe8\x79\x1b\x3d\x6f\xa3\xe7\x6d\xf4\xbc\x8d\x9e\x77\xf0\xe3\x1d\x74\xbc\x83\x8e\x77\xd0\xf1\x0e\x3a\xde\x41\xc7\x3b\xe0\xfd\x0e\x98\x51\xe7\x6b\x87\xf0\xe5\x10\xeb\xe0\x10\x7e\x1c\x62\xed\x1e\x42\xfe\x21\xe4\x1f\x42\xfe\x21\xe4\x1f\x46\xfe\x61\x72\xe9\x30\xf1\x3c\x8c\x8e\xc3\x60\x76\x98\x5c\x3b\x8c\x8c\xc3\xc8\x38\xcc\x9c\x77\x89\xf7\xbb\xe4\xd2\xbb\xe8\x78\x17\x3b\xdf\x05\xef\x77\xb1\xe1\x5d\x6c\x78\x17\xbc\xde\x63\x2f\x79\x8f\x5c\x7c\x0f\xfd\xef\x31\xf6\x1e\x38\xbf\x87\xee\xf7\x91\xfb\x3e\x18\xbf\x0f\xcf\xfb\xec\xa1\xef\xe3\xf7\xfb\x60\x77\x04\xbb\x8f\xc0\x73\x04\x9e\x23\xe4\xc8\x11\xec\x3a\xc2\xf8\x11\xf4\x1d\x21\xef\x3f\xc0\xa7\x0f\xc0\xe4\x03\x62\xf7\x01\x76\x7c\x80\xad\x47\xe1\x39\x0a\xcf\x51\x78\x8e\xc2\x73\x14\x9e\xa3\xf0\x1c\x45\xe6\x51\x64\x1e\x63\xfc\x18\x58\x1e\x23\x27\x8f\x81\xc1\x31\xd6\xd1\x31\xec\xfb\x10\x8c\x3f\xc4\xb7\x0f\xe1\xf9\x10\x9e\x0f\xe1\xf9\x10\x9e\x0f\xe1\xf9\x08\x9e\x8f\x90\xf9\x11\x32\x3f\x62\xfc\x23\xc6\x3f\x02\x9f\x8f\x58\x63\x1f\xb1\x86\x8e\xe3\xf7\x71\xfc\x3e\x8e\xcc\xe3\xd8\x72\x1c\xde\xe3\xf8\x7d\x9c\xf1\xe3\x8c\x7f\xcc\xd8\xc7\xc4\xec\x63\xec\xfb\x84\x5c\xf9\x84\x98\x7e\x0a\xcf\xa7\xc4\xeb\x53\xec\xff\x94\x78\x7d\x0a\x1e\x9f\x62\xcb\xa7\x9c\x8f\x9f\xa2\xf3\x53\xfc\xfb\x8c\x39\x9f\xb1\x2e\x3e\x63\xfe\xe7\xf0\x7f\x4e\x6e\x7e\x8e\xcc\xcf\xc1\xf2\x04\xbc\x27\xc0\xec\x04\xbc\x27\x88\xf5\x09\xf4\x9d\x60\xec\x04\xfa\xbe\x00\xff\x2f\xb0\xfd\x4b\x62\xf4\x25\x3e\x72\x9f\xd2\xbe\x44\xf7\x49\xfc\x38\x09\x66\x27\xe1\x3b\xc9\x1e\x74\x92\x7c\x3e\x49\x3e\x9f\x24\x9f\x4f\x12\x87\xaf\xc0\xe0\x2b\xfc\xfc\x0a\xff\xbe\x42\xe7\xd7\x3c\x7f\x4d\xac\xbf\x46\xce\xd7\xe8\xff\x1a\xfd\x5f\x23\xe7\x6b\x62\x7d\x8a\x7c\x38\x45\xdc\x4e\x81\xd9\x29\xe6\x9c\x82\x87\x3b\x99\x76\x8a\x9c\x3e\x8d\xcd\xa7\x91\xf9\x0d\x63\xdf\xc0\xfb\x0d\xf6\x7d\x43\xac\xbf\x61\xec\x0c\xfe\x9e\x21\x6f\xce\x60\xdf\x19\xfc\x38\xcb\x9c\xb3\xc8\x3e\x8b\xbe\x73\xe4\xe7\x39\x30\x3c\x87\x9c\x6f\xb1\xfb\x5b\x64\x70\x6f\xd3\xce\x93\x17\xe7\xd1\xcd\xfd\x4d\x2b\x47\x57\x39\xcf\xdf\xe3\xff\xf7\xe4\xea\xf7\xea\x99\x7c\xf8\x07\x31\xfd\x07\x72\x7e\xc0\xa6\x1f\xc0\xfb\x07\xfc\xfb\x11\x7f\x7f\x24\x1e\x3f\x82\xe7\x4f\xec\xaf\x3f\x31\xff\x27\x70\xba\xc0\x9c\x0b\x60\x72\x81\xfc\xbe\x00\x66\x17\xd0\x7d\x01\xbc\x2f\xb2\x16\x2f\x22\x8b\xfb\x9a\xf6\x33\x7e\xfe\x42\x9e\xfe\x8a\xed\x97\xf1\xe1\x37\xb0\xfa\x27\x78\xfc\x81\x7d\xff\xc2\x97\x3f\xb1\xef\x4f\x64\x5c\x81\xf7\x2a\x3a\xae\x61\xbb\x97\xe7\x8a\xcf\x85\x2e\x7e\x14\xba\xfc\x58\xe8\xdc\xa3\x74\x9d\x77\xa3\x0c\x3a\x28\x74\x6b\x10\xc4\xbb\x8d\xfe\xa0\xdd\x42\x0f\x9e\x21\xf4\x90\x02\xa1\x87\x86\x09\x3d\xac\x39\xb4\x08\x62\x2c\x0c\xfe\x70\x37\xf4\x00\xb4\x43\xe8\x11\x89\x50\x2d\x68\x01\xc4\x58\x64\x1f\x08\x99\x51\xb9\x10\x7a\xec\x73\x85\x1e\x3d\x0c\xba\x24\xf4\x98\x56\x10\xba\x62\x2e\x0b\x3d\xd6\x80\x6e\x85\xd6\x0a\x3d\x6e\x19\x84\xee\x78\xc6\xe3\xe1\x4d\x60\x3c\x71\x9d\xd0\x93\x78\x4f\x42\x67\x35\x64\x55\xdb\x22\xf4\x64\x01\x15\x43\xd8\x97\x8c\xbc\x14\x27\x84\xec\x14\x64\xa4\x7c\x27\xf4\xea\x75\x21\xec\xaa\x7e\x48\xe8\xa9\xd8\x95\x3a\x12\x7a\x5f\xe8\x8e\x1a\xd0\x68\xe8\x98\xd0\x9d\xd8\xea\x5c\x02\xfd\x21\x74\x57\x0f\x08\xf9\x69\x8c\x73\xc7\xd1\xd3\x90\x91\x8e\xcf\xe9\x2b\x85\x5e\x23\x0a\x2a\x85\xce\x09\x3d\x03\xde\x0c\xec\xe3\x8e\xa3\x67\x62\x7f\x4d\xf0\xa8\x89\xcd\xb5\xe0\xab\x85\xac\x5a\x57\x85\x5e\x7b\x96\xd0\xeb\xf0\x5e\x07\x3b\xb3\xc6\x43\xc8\xc8\x42\x1f\xf7\x1b\xbd\x6e\x03\x08\xbb\xb3\x91\xd5\x14\x9b\x5b\x35\x86\x78\x6f\x05\x7e\xad\xd0\xd9\x1a\xff\x5a\xc3\xd3\x1a\x9e\xd6\xf0\xb4\x01\x9b\x36\xf0\xb4\x01\x83\xb6\x60\xdd\x6e\x35\x04\xb6\xed\xb1\xb7\x3d\x6d\x07\xe6\xe6\x62\x77\x1e\xbe\xe5\xe3\x6b\x47\xb0\x2f\xc0\xc6\x4e\xf0\x75\x02\xbf\xce\x29\x10\xb8\x74\x46\x5f\x17\xe6\xdc\xca\xdc\xae\x8c\x77\xc3\x96\x6e\xe8\xe8\x0e\xee\x3d\x88\x6b\xcf\x81\x42\xef\x05\x66\xbd\x88\x53\x6f\x64\xf6\x06\x93\x3e\xc4\xbd\x0f\xf8\xf7\xc5\xbe\xbe\x60\x7c\xdb\x24\xa1\xf7\x03\xb3\x7e\xf8\x5f\x88\x1d\x1e\xf8\x3c\x8c\xf5\x27\x5f\xfa\x17\x42\xc8\xeb\x8f\x4d\x03\xb0\x77\x00\x3a\x06\xa0\x6b\x60\x2c\xc4\xf3\x40\x9e\x07\x11\x87\x41\xd8\x32\x08\x5c\x06\x21\x8f\xfb\x86\x3e\x18\x1d\x83\x79\x1f\x8c\x7d\x45\xe4\x55\x31\x36\x14\xa3\xa7\x18\x3c\x8a\xc1\xb2\x04\x1d\x25\xf8\x50\x42\x7f\x09\xf3\x4b\xb0\xb7\x04\x5b\x4b\x90\x59\x42\x7c\x4b\xc8\xa9\x92\x93\x42\x1f\x02\x96\x43\x90\x3d\x94\xb9\x43\xf1\x61\x28\xbc\xc3\x88\xcd\x30\x6c\x1a\xc6\xf8\x70\x7c\x1a\x4e\x6e\x0c\xe7\x79\x04\x98\x8f\x40\xef\x08\x6c\xba\x1d\xbe\xdb\x91\x77\x3b\xfa\x6e\xc7\xd7\x91\xc4\x7c\x24\x32\x47\x32\xef\x0e\xf0\xbe\x83\xfe\x51\xc4\x72\x14\x31\x1d\x45\xbc\xef\x44\xff\x9d\xd8\x7b\x27\x58\xde\xc9\xfc\xd1\xe8\x1b\x4d\xcc\x46\xa3\x73\x0c\x79\x32\x86\xf1\x31\xe4\xc1\x18\x62\x39\x16\xac\xc6\xe2\xd3\x58\xe2\x38\x0e\x3f\xc6\xe1\xd7\x38\x9e\xc7\xd3\x4e\xc0\xfe\x09\xf0\xdf\x45\x5c\x27\x32\x36\x91\xe7\x49\xd8\x32\x89\xdc\x9b\x84\xac\xc9\x60\x35\x99\x9c\x9b\x0c\x9e\x53\xb0\x69\x0a\x36\xdd\x0d\x96\x77\xe3\xe3\xdd\xc4\xf5\x1e\xc6\xef\x61\xee\xbd\xf4\xdd\xcb\xfb\x7d\xc4\xf3\x3e\x64\xde\x47\x6c\xee\xc7\xd7\xfb\xb1\xfb\x01\xfa\x1e\x80\x97\xbb\x93\xfe\x00\xf6\x4e\x25\x4e\x53\xb1\x75\x2a\x72\xa7\x92\x2b\x0f\x62\xef\x83\xc4\xed\x41\x30\x7a\x10\x7f\xa7\x21\x73\x1a\x6b\x76\x1a\xf3\xa7\x21\xa7\x14\x7b\x4a\x59\x37\xa5\xc8\x2f\xc5\x8e\xe9\xf8\x33\x1d\xfd\xd3\x57\xfe\x17\x04\x56\x0f\x91\x1b\x0f\xe1\xd7\xc3\x60\x30\x83\x7c\x9c\x81\x2d\x33\xb0\xe3\x11\xec\x7b\x04\x79\x8f\x62\xff\x4c\x74\xce\xe4\x7d\x16\xb1\x9a\x85\xdf\xb3\xb1\x6f\x36\xfa\xe6\x80\xfd\x1c\x6c\x7a\x0c\x3c\x1f\x63\x8d\x73\x0f\xd3\xe7\x82\xe9\x3c\xf2\x7e\x1e\xbe\x3d\xce\xf8\xe3\xd8\x38\x9f\x76\x3e\x71\x5d\x00\xff\x02\xe6\x3f\x01\x1e\x4f\x30\xf7\x09\x7c\x78\x02\x79\x4f\xe2\xc3\x93\xc4\xe3\x49\x78\x17\x92\x3f\x0b\xf1\x67\x21\x36\x2d\xc2\xef\x45\x60\xbf\x88\x3c\x5c\x4c\x7c\x17\xd3\xbf\x18\x39\x8b\x91\xfd\x14\x3c\x4f\x91\x3f\x4f\x93\x5f\x4b\x0c\xf5\xff\x57\x21\x34\xf5\xff\xa9\xa0\x4f\xd7\x98\x2d\x6c\x22\xd5\x1d\x66\x15\x36\x9d\xdd\x31\xd8\x22\xad\x42\x64\x1f\xc9\x3e\x62\x8f\x96\x2d\x5a\xd8\x73\xec\x39\x0d\x1b\xe4\xd8\x5d\x76\xdd\x65\x77\x4d\xd3\xb5\xe9\x5e\x58\xb5\x4b\xd7\xa2\xb4\x71\xde\x68\xc1\x3e\xcf\x7e\xcb\x86\x6c\xc9\xf3\xc9\xc9\x71\x27\xe9\x36\x9b\x66\x18\x41\xc1\x91\x52\x86\xea\x52\xf2\x6c\x59\x3e\xc0\x88\xd6\x74\xd1\xb6\x6d\x96\x3d\x5a\xb4\x48\xcc\x2e\x1a\x3c\x48\x09\xb7\xe7\xf8\x84\xcb\x74\xdd\x25\x51\xa0\x7d\x71\xde\x29\x33\xbd\x5f\x48\xa7\x7c\x45\x5f\xfa\xe7\xeb\x32\xc2\xfb\x8b\xfa\x3b\x85\x7f\xea\xb7\xea\x9f\x58\x8e\xf8\xe4\x67\xb8\xed\xba\xa6\xd9\xac\xd6\xa0\x60\x8e\x41\xf1\xdc\x00\xab\x26\x44\xdb\x9c\x2c\xbb\xc8\xb9\x51\x22\xa4\xbf\xf6\x4e\x86\x8c\xf1\xda\xf9\x69\xd7\x6f\xd5\xa6\x5f\x9b\xe6\xff\xa3\x7c\x9a\xfa\xf7\x2c\x8c\x05\xd8\x9c\x2c\x1c\xe2\xb0\xbb\x59\x50\xf5\x94\x38\x23\x36\x38\x3a\x32\x22\xd4\x08\x89\x89\x77\xa4\xda\x0c\x6b\x82\x21\x45\x92\x91\x68\x89\x89\xb5\x58\x63\xad\x21\x2e\x7b\x58\x58\x70\x88\x5e\x2d\x41\x4f\x0c\x49\x74\xba\x82\x8c\xb0\xf0\xb0\x1d\xd2\xe1\x0e\xf6\x54\x97\xe1\x29\x22\xca\x1e\xa5\xde\x9a\x7a\x92\xe2\xec\xd3\xc2\xe7\x87\xaf\x08\xdf\x17\x7e\x34\xfc\x54\xb8\xb5\x7b\x78\x51\xb8\x16\xee\x8e\xab\x5e\xb0\xcf\x7e\xd4\x7e\xca\xae\xdb\xdd\x8e\xb4\x02\xbb\x3b\xa6\x7a\x41\xb8\x3d\xdc\x6e\x49\x88\xd1\x43\x2c\x22\x3b\xa7\x6d\x4e\x74\x8b\x16\xd9\xd9\x59\x59\x13\xb2\x06\x4d\xc0\x0f\xe5\x52\xce\xf5\xd6\x17\x8a\x84\x1c\x9f\x7f\xf6\x68\x7f\x58\xec\xd1\x09\x2d\xaa\x12\x7e\xeb\x39\x71\x2e\x3d\x3d\x46\x51\x7a\x93\x1c\xc8\x15\x93\xa3\x2b\x52\xfd\xae\x18\x7d\x7b\xde\x4f\xde\x5f\xba\x2d\xed\xee\x7d\xaf\xdb\x33\xdd\x5e\xfb\x20\xff\xac\xd4\xbb\x3f\xd3\x4d\x36\xe6\xc7\xce\x6b\x85\xf9\xb2\x49\xbe\xde\xc1\xbb\x7b\xb1\xf7\x29\x39\x4a\xd1\x62\x99\xbb\x48\x8e\xf5\x3e\xa9\x68\x91\x77\xb7\xcc\x55\x7f\xb0\x4f\xe4\x55\xf4\x35\x4a\x2d\x5f\x89\x4c\x51\x4f\x34\x16\x6b\xdc\xd9\xc9\x69\x39\xba\x11\x9e\x58\x8f\x48\x5b\xe2\x44\x48\x70\x70\xed\x38\x47\x6a\x6a\x7d\x11\x27\x9a\x34\x8d\x74\x38\x1c\xd9\x8e\x22\x87\x11\xee\x70\x58\x45\x88\xac\xae\x87\xec\xa8\xd8\xef\xce\x0a\x8b\x2e\x08\x09\x49\xb4\x36\x8a\xa8\x17\x31\xd9\x93\x56\xaf\x5e\xed\xfa\x89\x56\x57\xcd\xc4\x9a\x53\x3c\xc9\x89\x49\x49\x89\xb6\x9c\x70\x6b\xf8\x44\x8f\xc5\xa2\x5b\x13\x89\x6f\x4e\xb6\x82\x21\xb1\x6d\x4e\xb6\xdd\x8c\x75\x0b\x85\x81\xf9\x98\x98\x9d\xa5\x32\xaa\x45\xb6\x3f\xad\xfc\x59\x10\x80\x4a\xa1\x96\xa0\x72\x22\xd6\x6a\x8b\x4b\x6f\x52\x5f\xd6\xcc\x48\x95\x09\xf6\xfa\x32\xbd\xbe\xd6\xa4\x71\xd3\x66\x4d\x72\xe2\x78\xb7\x64\xd6\xb4\x27\x34\x32\xe2\xa5\x35\x2e\x96\x57\xd9\x98\x79\xf6\xa6\x46\xe9\xaf\x17\xc6\x7c\x76\x29\x53\x8a\x98\x09\x77\xe8\x89\xc6\xaa\xd5\x9e\x33\x5f\x8e\x79\xf3\xa3\xfa\xde\x3f\x52\x9f\x0b\xad\x2e\x6b\x3e\x79\x6d\xd3\xf6\xd4\x56\x83\x64\xe7\x1a\x79\x93\xbe\x92\xb3\xb7\xbe\x13\xbc\x61\x5d\xd0\xeb\x6f\x64\x4f\xb8\x23\x44\xce\xd4\x2c\x19\xc3\x97\x8e\x7f\x69\x6b\xf0\xa3\x8f\xda\x56\xec\xa8\xb9\x2e\xce\xbb\x52\x2b\x7e\x5d\x9b\x1e\xf1\x64\xbd\x16\xb5\x52\xbd\x2d\x1b\xb5\xad\xe5\xf2\x3e\x11\xa9\xfe\xa0\xa7\x10\x15\x97\x8d\x0f\x2c\x3d\x41\x37\x42\x24\x89\x1a\x22\x5b\x0c\x76\x37\x15\x52\xd3\xa5\x1e\x96\x92\x95\x96\x96\x91\x12\x69\xb5\xc6\x85\xa5\x34\x0c\x6b\x50\xad\xd6\x36\x8f\xa3\xda\xf6\x01\x8e\xfa\xb4\x49\xc1\x89\xdb\x3c\x46\xf0\x76\x16\x18\xad\x4d\xb3\x0a\xe0\x62\x9d\x65\x65\x89\x44\xf5\xd3\x2e\xaf\x43\x51\x35\x75\x58\xd1\xe9\x32\x27\xc3\x69\x8f\xb5\xa6\xa7\x65\x02\x83\x6c\x9c\x99\x9e\x86\xef\xf1\x39\x8d\x2c\x37\xed\xfd\x71\x83\xbe\x7a\xe3\xd5\x27\x64\xf2\x93\xf3\xe6\x3d\x39\x57\x6a\x4d\x9a\x37\x6f\xd1\xb2\xd9\x18\x2d\xe3\xc6\x1e\x4b\xa7\x20\x6f\xd9\x9a\xd7\xd6\xbd\xbc\xe6\x65\x6f\xd9\x9d\x83\x07\x8c\x1d\x3d\x68\xc5\x8d\x1d\xbe\x3f\x20\x2a\x12\x2b\x7e\x32\xde\xb2\x74\x15\x69\xa2\xae\x68\x2e\xc6\xbb\x5b\xe9\x19\xe9\x7a\xaa\x25\x2e\x35\x2a\xbd\x49\x84\x35\xa7\x5e\x68\x8e\xc5\x12\x1a\x53\x4b\x44\xc7\x88\x98\x16\x2d\x53\xd3\xe3\xa2\x0c\x67\x46\x44\x96\xde\x24\x28\x3a\xda\x19\x94\x90\xe5\xcc\xea\xe9\x49\x71\xc6\x07\x35\xe8\xe9\x09\x32\x44\x5b\xe5\x71\x65\x46\xe0\xa8\xfa\x4f\xad\x0c\x73\x17\x0b\xac\x9a\xc0\x62\x89\x21\xf8\xca\xc9\x9c\x46\xf1\x71\xe4\x46\x7c\x42\xd3\x66\x09\x34\x39\x8d\x9a\xc5\xe1\x7e\x4d\x05\x41\x46\x66\xcd\x08\xe9\x73\x3f\xc6\x44\x22\xa1\x8d\x96\xb8\x6a\x5e\xc7\xd7\x5f\x7b\x66\xc7\xca\x23\x45\x77\x77\x71\xbd\x5f\x67\x42\xdf\x3e\x2d\x6a\x64\xb6\x58\x39\x77\xf5\x9b\x1f\x97\x6b\x33\x57\xdc\x9e\xdb\x79\xec\xb0\x91\xcb\xdb\xb4\xed\xdc\xb5\xf1\xb0\x1e\x75\xe5\x84\x69\x9f\x77\x78\x7c\xea\xa2\x17\x9e\x7d\x68\xc4\x6b\x45\x2f\xcd\x5a\xbc\x21\xf9\xa7\xb7\x3b\xd9\x0f\xc6\x4d\xbc\xff\x70\x8b\xb2\x1d\xb5\x26\xe5\x0f\x19\xaf\xcf\x6d\x96\xd7\x3b\xb7\xb0\x24\xbb\xa5\xfa\x4b\x2c\x5f\xb3\x55\x5d\xf4\xed\x77\x89\xee\x50\x76\x3b\xc3\xa2\x36\x3a\xb5\xcf\x65\xf9\xf7\x38\xff\x06\xa7\xbd\x1b\xd8\xd6\xe0\x29\xf4\xf6\xd3\x9f\xb5\xbc\x2f\xc2\x45\x9a\x3b\x52\x84\x87\x5b\x6d\xb6\x10\x5d\x8f\x88\x64\x2b\x4f\x26\x21\xae\xef\x8d\xfe\xed\x31\x53\xb3\x47\x45\x37\x73\x59\x55\x93\xa0\x4d\x7f\x6e\xee\xdc\xe7\x64\xd2\xf2\xf9\x8f\xaf\xf0\xf6\x3b\x23\x0f\xc8\x44\x16\xc0\x1b\xdf\x9c\xf3\xb6\xf2\x5e\xf0\x5e\xf4\xb6\xfd\x1e\xf9\x39\xc8\x9f\x1c\x90\xcf\xf6\x1b\x4e\x00\x43\x42\xfe\x4e\x7e\xd3\x68\x7b\x94\x56\xd3\x15\xaf\x1a\x9b\xcc\x59\x39\x6f\x81\x92\xff\xd8\x63\xcb\xbd\xfd\xfe\x21\xf7\xc9\x68\x19\x23\xdf\x3a\x73\xd6\xdb\xc6\xfb\xa3\xf7\x1f\xde\x36\xe7\x84\x14\x27\xb5\x0f\xf5\x9f\x2d\xef\x91\xfd\x45\xee\x16\xd6\x70\x2d\x22\x24\x22\x3c\x3c\x32\x4a\x0b\x09\x91\xa1\x22\x6c\x72\xd8\x23\x61\x9a\x1e\x6c\x04\x4d\x0b\x9d\x1f\xaa\x85\x06\x59\x83\xc3\x42\x2d\xe1\x16\x61\x73\xda\x1a\xd8\xc6\xdb\x4a\x6d\x0b\x6c\x38\x1c\xae\x4e\x82\xec\x41\x39\x44\x37\x7b\x90\x0a\xf5\xa0\xeb\x59\x6f\x5a\x17\xad\xf6\xc8\x66\x09\xb6\x04\x5b\x4d\x5b\xcd\x66\x35\x9b\x25\xe8\x39\xda\x81\x1f\x72\xff\xdc\xb5\xe3\xc9\xc5\xbb\xf6\xfe\x99\x7b\x31\xfa\x33\x63\xe7\xc8\xb7\x5a\x7f\x72\xef\xd5\xab\xf7\x1f\x6f\xfd\xd6\x48\x19\x8d\x6d\xc3\xc5\x2a\x63\xa4\xb1\x51\x84\x8a\x96\xee\xd4\x60\x29\xad\x9a\x66\x09\xb1\x84\x84\x85\x1b\xda\x06\x8f\x30\x2c\xc6\x7a\x4f\xb0\xc5\x62\xdb\xe0\xb1\x6c\x56\x21\x12\x39\x7e\xf2\xe5\x5d\xf4\xf5\x23\xc9\x9e\x6e\x77\x35\x71\x61\x8c\x2b\x4e\xfb\xf4\x8c\x77\x82\x9c\x7f\x46\x3e\xa9\xb5\xf0\x8e\x94\x4b\x4e\xcb\x25\xde\x91\xa7\xd5\x1f\xad\x96\x9a\x77\xb1\x76\x5e\x66\x11\xfb\x6a\xee\x70\x42\x6e\x58\xa4\xbe\x6c\x80\x21\x97\x0e\x10\x59\x95\xd1\x8f\x71\x31\xf3\x65\x79\x8b\xf7\x30\xd3\x9f\xba\x36\xca\xf7\xc7\xb2\x65\xae\x7c\x46\x9f\xa5\xcd\x83\x37\xde\x1d\xc2\xbd\xc7\x22\xc5\x2e\x8f\xdc\x6d\xa6\x8d\x72\xbd\x89\x2b\x4e\xe6\x6a\xcc\xbb\x7c\x99\xf9\x9f\x72\x10\xfe\x53\x36\x34\xf3\x4c\xe9\x12\x4a\x4f\x74\x95\x3c\xe3\xc8\xb7\xcb\x4f\xa5\x4b\x36\x54\xff\x72\x3b\x58\x78\x2a\x7e\x34\xee\x22\x0f\x74\x91\xe2\x0e\xd3\xd9\xa0\x84\xa6\xf4\x88\x18\x33\x09\xcc\xdd\x25\x41\xe6\x48\x8f\xde\xe4\xdc\xd5\xa3\xb1\x96\xd3\x7f\x3a\xfd\xeb\x7d\x32\xbc\xfd\x2c\xfd\xc1\xb1\x9a\x48\x15\x7d\xdc\x0d\xaa\xa7\x84\xc5\xc6\x5a\xc3\x84\x55\x38\x9c\x91\xc9\x32\xd9\x1d\x99\xe2\x48\x99\x9f\xb2\x22\x65\x5f\xca\xd1\x14\x6b\xb8\x9e\x92\xa2\x07\x07\x47\x4d\xf2\x04\xdb\xf4\xc4\x49\x1e\x3d\xc9\xbf\xc6\x2b\x6b\x88\x6a\x47\x26\x5c\xd7\xa9\x76\xb6\x86\xea\x6f\xf4\xa4\xa7\xa9\xac\x76\x35\x8a\x56\x7b\x78\x7a\x9a\x5a\xbf\xa9\x32\xa7\x51\xd3\x0c\x36\x7a\xa3\x5f\x85\xb8\xfc\xdb\xbf\x7e\x95\xfa\x9f\xbf\x78\xcf\xd7\x29\xec\x75\xdb\xc0\xda\x59\xfd\x7b\x4d\x1a\xe6\xdd\xf3\x99\xf6\x82\x77\xbd\x77\x99\x1c\x2a\xfb\xc8\x62\xd9\xcf\xbb\xda\xfb\x62\xd9\x91\xc1\x83\x8f\x94\xbd\xf6\xc1\xe0\x2f\x66\xfd\xeb\x5f\xf8\x3e\x07\x88\xa6\x50\x33\x44\x88\xd6\x6e\x47\x78\x98\x55\x86\xc8\x30\x96\x67\x64\x94\x6e\x0d\xb1\x59\x27\x7a\x58\x72\xd6\x30\x29\xe4\x44\x8f\xda\x84\x03\x07\x96\xcf\x5c\x1f\x9e\x09\x39\xe6\xd6\x4b\x1a\x44\xc8\xf4\x26\x8d\x9a\x36\x03\xdf\xb8\xc5\xf2\x91\x9a\xdf\x97\x3e\x76\xb2\x39\xf2\x3a\x7c\xa8\xdf\xdf\x6b\xfc\xa7\xf7\xdd\x79\x65\xee\x87\x3e\xbc\xef\x47\x67\x5f\x30\xab\xae\xf0\x4a\x96\x32\x22\x32\x25\x28\x2e\x32\x2e\xd5\x11\x19\xe1\x88\xc8\x8e\x28\x8a\x18\x17\x61\x89\xd6\x23\xdc\x61\x91\x05\x11\x11\xd1\xc9\xd1\xa1\x93\x3c\xd1\x36\x99\x2c\x92\x27\x57\x31\xc2\x44\x2c\xab\xa8\xea\xf9\x68\x9a\xd2\x46\x36\x6b\xc3\x39\xa8\x76\x37\x5b\x46\x1b\x69\x6e\x86\x11\xd2\xe6\x8a\xbb\xbf\xd1\xce\x8d\x73\x7a\x65\x0f\x1e\xd0\xbf\x28\xc2\xfb\x6d\xe2\x6f\xc7\xbf\xf0\xce\x9e\x7d\xe0\xd1\x54\xed\xf1\x37\xc7\x7e\xb5\x60\xc2\x6d\x3d\xeb\x14\xf4\x2a\x29\x89\x3a\xf8\xc1\x3b\x6b\xc6\x1c\xbd\xf3\xa9\x19\xb9\xe5\xbe\x3c\x14\x83\x2a\xbe\x37\x86\x63\x73\x6d\x71\x8f\x3b\x37\x33\xdd\x6e\xb7\x8a\xe4\x94\x14\x9b\x35\x2e\x3d\x5d\xc5\xba\x4e\x96\x4d\xcf\x8c\x4a\x76\xd8\xed\x51\x93\x3d\x6d\xed\xdd\xed\xf3\xed\x2b\xec\xaa\x36\xb2\xea\xe1\xf6\xea\x76\x2d\xdc\xb0\xdb\x75\x87\x83\x88\x3b\x6c\x7a\xf0\xe4\x9b\xc4\xbd\x68\x90\xef\x99\xb5\xd5\xe2\x26\xe7\xbd\x6f\x91\xc7\x1a\xe9\x69\x35\x6a\x66\xb0\x73\x37\xc5\xb9\x2c\xd9\xc4\xff\xe0\xf3\xb2\x69\x8d\x9c\x46\xa9\x52\xb9\xc9\xc9\x6f\x0c\xf7\xfe\x7c\xf1\xbc\xf7\xd7\x04\x99\x9a\xf4\xd1\x1d\x53\x9e\x98\x39\x64\xe0\x7d\x0f\x8f\x19\x70\xdb\xf8\x20\x6f\x79\xbc\xd4\x8f\x2f\x3a\x31\x71\xd9\x13\xcf\x6d\x91\xf7\xec\xf9\xe8\xf0\xde\xa4\xdd\xc3\xfb\xf5\x1b\x78\x76\x50\xef\x2e\xc5\x3d\x0b\x63\x37\x1f\xe8\xff\xc2\x9d\xf7\xaf\x4e\x31\xa2\x5f\xf6\xd5\x94\x1d\xcd\x9a\x32\x84\x25\xd4\xca\x5d\xdd\x6e\x89\x66\xa7\x08\x92\x16\x19\x13\x2b\x0c\xbb\x31\xd1\x13\x64\x89\xb0\xda\xed\xd2\x6a\x95\xea\x90\x8e\x6e\xc1\x21\x95\x73\xbd\x74\xad\xba\x7f\xb2\xea\x5c\x4d\x24\x9b\x45\x9c\xe4\x90\xb2\xda\xa4\x4b\xff\xd8\x7b\x99\xea\xb5\xb7\x6c\xb9\xdb\xdb\xdc\xa6\x55\xcb\xf5\xee\x97\x8b\xa5\xc3\xfb\x8d\x74\x1c\xd7\x7b\x5f\x7d\xf5\x43\x6d\x74\xd3\x07\xa3\x9b\x8f\xf2\xb6\xf3\xc7\x60\x24\x6b\x6d\x28\xb6\x54\x17\x1e\x77\xdd\x04\x9b\x48\x4a\x8c\x89\x89\x8b\x8d\x0d\xb2\x45\xa8\x62\xdf\x11\x1b\x14\x1b\x64\x24\x27\xdb\x27\x7b\x92\x93\x8d\xb8\xb8\xc4\x89\x9e\x38\xab\x41\xee\x18\x7f\xc5\xda\xd7\xd0\x66\x5f\x5f\x66\x81\xff\xfc\x20\x93\xc5\x69\x99\xaa\x9e\x0a\xa0\x6b\x73\xc5\xb8\xa8\x34\xd5\x99\x6a\x0c\x9d\xfa\xd3\xca\x8f\x2b\x52\x65\x52\xfc\xf8\xbe\xa3\xef\x9b\x32\x6a\x72\x67\xef\x85\x86\x7a\xf7\x6b\x65\x09\x23\x9e\x39\xfc\xb3\x7c\x7b\xee\x67\x77\xef\xdb\x9a\xd0\xbf\x57\xe9\xe4\x91\x53\x07\x68\x57\x3e\xf4\xee\xea\xff\x4f\x1f\x8e\x53\xb1\x7d\x00\xf9\x93\x20\xd2\x45\x3f\x77\xfd\xe8\xd4\x54\x6b\x78\x58\x58\x22\xa9\x53\x23\x83\x43\x21\x2e\x2e\x99\x15\x16\x17\x15\xe7\x8c\xd3\x83\xf5\x38\x7e\x04\x47\xfa\xf6\x08\xd7\xcd\xf6\x08\xf3\xa9\x6a\x9e\xd8\xfd\xd5\x60\x7a\x9a\xb0\x47\x09\x2c\xa5\xf8\x53\x67\xbb\x2f\xf9\x2d\x95\x15\x4f\x53\x63\x80\xf7\xe4\x6f\xde\x9f\x65\xe4\xd5\xcd\x47\xb3\xbc\xff\xcc\x9c\x71\x57\x69\xbd\x95\xc3\x77\x9e\xf6\x9e\x1f\x57\xd2\x7f\xe2\x94\xc1\x83\x46\xcb\xbd\x27\xfe\x25\xc7\xc9\x3c\x39\x44\x16\x2e\x7f\x29\xe3\xb1\x13\x1f\x76\xe9\xf1\xfd\x07\x63\xee\x1f\x37\x60\xc2\xb2\x52\x5f\x1c\x1e\x26\x27\x72\x7d\x39\x51\xd7\x1d\xa7\x73\x2d\xb2\xa9\x7f\xf5\x24\x34\x4c\x04\x05\x07\x4d\xf6\x04\x5b\xf5\x44\xdf\xad\xe8\x7a\x0a\xf8\x0e\x0c\xcc\x0b\x21\x07\xa2\xa2\x25\x27\x86\x91\x5b\x71\xcc\xfb\xe5\x45\x29\xae\xe5\xea\x6f\x18\x23\xbc\xab\xaf\xfd\x5e\x21\xa4\xa1\xa5\xcb\x66\xe5\xfe\x7d\x75\x0c\x78\x15\x83\x57\x12\x95\x54\x3d\x71\x9b\x3b\x2b\x3e\x24\xbc\x5a\x4c\x6a\x78\x4c\xb8\xa8\x6d\x4d\x07\xb6\xfa\xd9\xf1\x21\x21\xae\x4c\x57\xe6\x14\x8f\xcb\xa5\x47\x45\xa5\x4c\xf1\x44\xd9\xf4\xac\x29\x37\xc2\xe5\xdf\xaa\x72\x6e\xac\x98\xfc\x3b\xab\x6f\x45\xf9\x0a\xe6\xfa\xb2\xb2\x6a\x62\x05\xc9\xc6\xe9\x69\x7f\xa9\x91\x14\x74\xc5\xde\xdf\x2f\xfe\xe4\xfd\x75\x45\xe9\x84\x79\xff\x3a\x79\xf6\x9f\x8f\xdf\x35\x73\x99\x77\xf7\xce\x6d\x45\x9e\xed\xae\x71\x63\x86\x8f\xfd\x72\xd4\x28\xf9\xe0\xee\x4f\x3f\xde\x5d\xba\x29\xce\x48\x7a\x69\xec\xea\x03\xbb\xd7\x8d\x5a\x9b\x60\xc4\xbf\x26\xcf\x6c\xda\x34\xa0\xd8\x3b\x66\xf8\x1d\xe3\x86\x9e\x1a\xed\xcb\x87\xbb\xf0\xaf\x57\x65\x3e\x50\x7d\xa4\x46\x87\x25\x26\xb2\xca\x6a\x64\xd8\x6c\xc1\x91\x91\xae\x89\x9e\xc8\x48\x47\x64\x76\x24\xf9\x10\x19\x19\xa7\xc7\x25\x4f\xf2\xc4\xb1\x77\xfc\xe7\x7c\xb0\x5f\x5f\x72\xea\xe0\xc8\xf4\x6f\x18\xcd\x7c\x69\xdd\xa4\x31\xdb\x84\xf8\x4b\x3e\xf4\xf2\xfe\x5c\xb1\xeb\x78\x5d\x19\x54\x73\xde\x5d\x0f\x6b\x99\xeb\x87\x6d\xff\x5a\x1a\xdf\x5d\x96\xc2\xfb\xd9\x94\x81\x03\xc6\x8c\x19\x38\x60\x8a\xb6\xd3\xfb\xa2\xf7\xf1\x15\xeb\x32\x16\x7e\xf8\x61\x97\xbe\xbf\x1f\xfb\xe4\xb2\x77\xcb\x8a\xfb\x16\x4f\x1f\x3b\x7a\xe6\x64\x75\x57\xf6\x9d\xb9\x46\x6b\xdf\x5d\xb6\x96\x3b\xd6\xa6\xeb\x86\x20\x17\x2c\xc6\xd2\x01\x96\xc8\xeb\xc7\xaf\xdf\xe2\xeb\xd7\x59\xdf\x29\x6c\x9e\xc4\xde\x53\xfe\xd3\x58\x0f\x33\xcf\x64\x4d\xe6\x7b\x17\xeb\x75\xae\xcb\x8c\xb7\x1a\x86\xee\x93\x69\x5b\x36\x20\xc8\xb2\x74\x80\x14\x50\xa4\xf0\xdd\x06\xaa\x5c\x91\x95\x3c\x55\x47\x20\xcf\x9b\xef\xab\x25\xfc\x22\xaf\xcc\xf6\x57\x14\xaa\xee\x99\x6a\xa8\x7f\x8f\xcf\x2a\xda\xba\x6b\x70\xdb\xb6\x0a\xab\x2d\x48\x0a\xc3\xd0\x2c\x6d\xad\xe3\xac\xf3\xad\x1b\xac\xfb\xac\x47\xad\x56\xab\xee\xd4\x64\xa4\x46\x2d\x90\x3d\x68\x90\xaf\x00\x6b\xd1\x3a\x3b\x27\xa7\x4a\x39\x10\x63\x97\x71\xc1\x32\x6e\xb8\xa1\x5f\xdd\xa7\xb7\xd3\x0c\xd9\x5e\xce\x3c\xe7\x7d\xdd\xbb\xfb\xac\x8a\xef\x70\x99\x8e\x9e\xda\x3e\xfb\x7b\xb9\x9b\x1b\xe6\x77\x08\xc3\xb2\xde\x53\x64\x8c\x33\x4e\x19\x7a\xa4\xe1\xe0\x61\xbe\x61\x04\xeb\x5c\xca\xd7\x7b\xa2\xa4\x53\x8e\x97\x0b\xa4\xe1\x94\x6e\xb9\x52\xee\x97\xc7\xd8\x65\xd1\x3e\x01\xe4\x54\x90\x27\x64\x55\x55\xae\xaa\x1e\x08\xed\x57\xae\x19\xba\xde\xf9\xd4\xa9\x6b\x27\xbe\xfa\xca\xbf\x4f\x56\xfa\xd8\xda\x9d\x1e\xf0\xd1\x6a\xd1\x34\xdd\x69\xc8\x48\x43\x1a\xb2\xad\x18\x27\xe6\x8b\x0d\x62\x9f\x38\x2a\xd4\x87\x91\x41\x8d\x94\x97\x37\x7a\xd8\xac\x49\xb0\x6c\x22\xed\xc3\x75\xf7\xd5\xfd\x86\x3e\xf5\xac\xfa\x2b\x73\xe7\xbc\xf7\x7a\xf7\xe2\x5f\x67\xf6\x00\x8f\x6f\x7d\x56\x17\xc5\xee\xc6\x54\xaa\xd5\xab\x55\x8b\x0d\x17\x1c\x0b\xb1\xa9\x8e\xf1\x36\x19\x69\x73\xd8\xb4\x50\xdd\x66\x4b\xa8\x56\x2d\x79\xf9\x80\x6a\xd1\xee\x18\x19\x19\x43\x71\x11\x13\x93\x90\x10\x55\xe4\x49\x30\xcc\x93\x5c\xf9\x36\xa8\x4a\x32\x0f\xaa\xb2\x54\x03\x71\x65\x53\xa6\x18\x76\xa9\x73\x5d\x56\x3d\xf1\x0c\x15\x71\xc3\x53\xaf\xef\x92\x47\x2c\xde\xdf\xac\xa3\x4a\x26\xf4\xba\x6f\xe8\xf0\xd9\x61\xde\xb3\xc9\x32\xf1\xf4\x77\x32\xf6\x5a\x27\x8e\x99\x2f\xda\x8d\x2e\x1a\x5b\x3c\xea\xf6\x17\x3a\x74\x1d\x7a\x4b\xd7\x41\x53\x4a\xc2\xde\x3b\x73\xec\xca\x14\xff\xa7\x18\x7c\xa9\xeb\xfd\xd6\x78\x91\xfa\xaf\xb5\xe8\x24\x1e\x72\x77\xaa\xd5\x34\x37\x22\x31\x39\xb9\x4d\x82\xc5\x05\x34\x96\x88\xa6\x96\xce\x5d\x52\xf3\x43\xf3\x3f\xf1\xd4\xaf\xcf\x31\x1f\x1a\xed\xfe\xc4\x93\x10\x1f\x1d\x19\xea\x08\x2d\x0a\x1d\x17\x3a\x2d\xd4\x12\x2a\xa2\x71\x2c\x34\x3a\x34\xba\x51\xcb\x96\x35\x3e\xf1\xb4\x14\x8d\xb2\x3e\xf1\x34\x12\xd9\xd7\x97\xa9\x3a\x6f\xf0\x8d\x5a\xc5\xfc\xf8\xe1\xbb\xe0\xfb\xb7\xc8\x04\xff\x21\x54\xb9\x8d\x47\x69\xe9\x69\xad\x65\xb3\x74\x73\xc9\x46\xab\x7d\x29\x21\xa7\x59\x8e\xee\x5f\xb3\xd1\x4d\xd4\x04\xab\x16\x17\x15\xad\x16\x76\x82\x6f\x9a\xd6\x24\x2a\x1a\x40\xe2\xa3\x2d\x8d\x7d\xf5\x61\x14\x43\xd1\xc6\x8b\x2f\xce\x9d\xaf\x59\x6b\x3c\xd8\x69\xd4\xdd\x25\x6b\x6e\x6f\xdf\x27\xc2\xe2\x9a\x39\xb4\x56\x6c\xf5\xce\x83\x3e\x2e\x5b\xfc\xf5\xdd\xdf\xbe\x39\xf8\xb5\xe1\x1d\x27\x7e\x7e\xf7\x8b\x57\x1e\x7d\x56\xa6\xee\x5e\xfe\xfd\x83\xde\x6e\x63\x5a\x0d\x69\x3e\x38\xff\xf6\xe6\xda\xaf\xde\x4f\xbd\x2b\x9e\x0b\xae\x39\x78\xdc\xa1\x9d\xab\x64\xea\x8b\xfd\x6e\x7b\xda\x6b\xf9\x28\x37\x2d\x4d\x3a\x2e\xc9\x48\xd9\xed\x84\xf7\x81\x8b\xde\xf7\xbd\x4f\xe7\x17\x96\x0c\xed\x7f\x40\x8e\xb9\x20\x53\xe5\xeb\x3f\x6f\xf5\x6e\xdd\xfd\xe6\xec\xf3\xf7\x7a\xaf\xac\x53\x7f\x45\xd4\xfc\xf7\xb3\x8c\x23\x9c\x17\x36\xaa\xcc\xae\xee\xe4\x50\x8e\x0c\x8b\xcd\x1a\x46\x19\x41\x91\x1d\x64\xd1\x23\xa3\x42\xf5\x12\xcf\xf0\x20\x19\xb4\xa3\xe2\x98\x3b\x2c\x38\xa2\x20\xc8\x1a\x1a\x6a\x65\x17\x61\xdf\x68\xd4\x56\x95\x14\x59\x6a\x8f\xf3\x23\xc5\xce\xdd\xa8\x11\xad\xda\xc0\x6b\x4b\xdd\xa5\xbb\xa4\x8b\xda\x8e\xbb\x63\xa6\x71\xc4\xfb\xc5\x40\x6f\xf3\x81\xde\x13\xf2\x75\x59\xb8\x2e\x28\x6b\xa2\xbc\x75\x72\x6d\xd9\xd9\xbb\xcd\x92\xb7\xad\xce\x1a\xef\x28\xb9\xec\x79\x56\xe4\x6c\xec\x79\xde\x57\xf3\xc6\xf9\xb3\x37\x2c\x39\x32\x38\xd8\x10\x31\xd4\x0d\xf1\xc2\xa0\x94\x08\x8b\xa9\x16\x53\xad\xc4\xf3\x58\xcc\xd2\x18\x2d\x3c\xa6\x3a\x3f\x8c\x98\x18\xc3\x62\x89\x2e\xf1\x58\x74\x23\xb9\xc4\x63\x44\xdf\xb8\x07\x0f\xba\x5e\x13\x9b\x5b\xb0\xef\xd4\xf3\x97\x14\xd6\x74\x76\x3b\xff\xd9\xa2\x8e\x96\x2c\x69\xf7\x1d\x2c\xb4\xae\x46\xc6\xf3\x7f\x7c\x79\x6d\x97\x16\xfe\xc5\x37\x33\x66\xbf\xba\xd9\xfb\xe8\x9a\x0f\x8f\xbf\xd8\x73\xd4\xf0\x3f\xa5\x3c\x24\xa7\x6f\x7d\xdf\x92\xb7\x61\xf5\xc4\xe7\xaa\x47\xaf\x95\xfb\x56\x7a\xdf\xf0\x8e\x2b\x2c\xf2\xce\x51\x6b\xbc\x07\xe7\xc7\x22\xd6\x5f\x9c\xe8\xe6\xae\x27\x42\xed\x51\x51\x16\x6b\xa8\x35\x3e\x21\x3c\xb6\xc8\xe3\x60\x63\xb5\x87\x1b\x51\x6c\x1f\x96\x28\xcb\x02\xcb\x31\x8b\x11\xaa\x5b\x2c\x41\x41\x7a\x91\x27\x28\xa6\xca\xb2\x9b\xa0\xae\x96\x59\x55\xcb\x08\x65\xad\xfa\x5a\x60\xd1\x5c\x4e\x2a\x09\x97\x2a\x24\xb8\x71\x38\xe5\x03\x73\x1f\x7b\xbe\x9b\xb4\x3f\xe2\x9d\xee\x2d\xf7\x9e\xd0\x9a\xef\xba\x72\x8b\xf7\x52\xf5\x49\x5d\xbc\x97\xb4\x97\xbf\xb9\x7c\xb9\xb1\xb7\x50\x0e\x97\x85\xda\xc6\x83\x6f\xb4\x1f\x35\x99\x98\xcf\x04\x63\xf5\xb7\xb3\x83\x44\x94\x3a\x13\x22\x8c\x60\x80\xb5\x47\x5b\xc2\x8b\x14\x82\x11\x45\x55\x11\xbc\xbe\xe1\x70\x60\xd5\x06\x13\xa7\x90\x3e\x70\x72\x9c\xc6\x54\x12\xec\xac\x77\x80\xbc\x43\x16\xc8\x3c\xef\x67\xaf\xee\x6d\x3d\x42\xba\xb5\xf5\xde\x6d\xde\xe7\x2c\x79\xde\xed\xde\x8d\x67\x3f\xbc\xfa\xb0\xc2\x43\xc5\xf4\x3e\xf4\x85\x8a\x12\x77\x0b\x9b\x1e\x62\x09\x0e\x16\x82\xeb\xac\x25\xa8\xc8\x93\x6d\x91\xa7\x2c\x17\x2d\x9a\xbe\xde\xb2\xc7\xa2\xb5\xb6\xc8\xfa\x16\x69\x44\x5a\x64\xa8\xc5\xc2\xed\x50\x1a\x45\x1e\xa9\x8b\xe0\x22\x8f\xf8\x1f\x41\x2d\x1a\x34\x08\xaa\xb2\xf3\xfa\xca\x06\x75\xdd\x75\x99\x34\x5b\x3f\x74\xad\x48\x1b\x76\x6d\x99\xf6\xae\x85\xcd\x71\xf7\x39\xef\xab\xe7\x94\x3d\x6b\xb0\xa7\x17\xf6\x04\x8b\x5b\xdd\xf5\x55\xc1\x6c\xb1\x5a\x83\x42\x42\x95\xb2\x48\xd9\x56\x76\x97\x45\x72\x9a\x9c\x2f\xad\x61\xba\x74\x27\x54\x2f\x90\xd2\x42\x11\x55\xe4\xb1\xe9\x96\xe8\xca\x4f\xca\x59\xfe\xb3\xfd\xba\x6e\xdf\x09\xa7\xd4\xf2\x53\x7e\xa0\x8d\xb9\xb6\xd0\x7b\x42\x7f\xd5\x28\xf1\x96\x9e\xf3\xea\xa8\x37\xf3\x62\x24\x79\x51\x8d\x95\x56\x3b\xca\x12\x1a\x12\x12\x2f\x2c\x5c\x55\x92\x12\x4b\x3c\x49\x49\x9a\xcd\x46\x00\xdc\xa1\x32\x32\x54\x6d\x58\xa1\x36\x43\x8b\x29\xf2\x68\x31\xe6\x87\xa6\xca\x3c\xf6\xd5\x4d\x55\xd3\x22\xc3\x9a\x7e\x3d\x21\x2a\xab\x87\x66\x4d\x54\x31\x37\xf2\xd7\x3f\xbd\x57\xbc\x5f\x68\xf5\xb7\x9c\x6b\xea\xbd\xd0\x64\xc6\xcc\x69\x8f\xce\x6e\x32\xa1\x8e\xf7\x82\xe6\xdc\x79\x84\x52\xb2\x9b\xb6\x71\xd7\x9e\xa6\x6f\x7d\xfe\xf3\xa9\x5f\x6a\xa5\xfd\xf0\x85\xef\x8c\x52\xf7\xce\x0e\xbe\x78\x75\x72\xd7\x09\x12\x22\x54\x55\x0d\xa1\x46\x78\x98\x4d\x2b\xf6\x9c\xb4\xc9\xf7\x6c\x72\x89\x4d\x0e\xb4\xc9\x2e\x36\x59\xc7\x26\x29\x89\x2c\x81\xfd\x20\xa7\x05\x87\x95\xfa\x95\x55\x75\xb5\x99\x25\x45\xe0\x7f\x7a\x8a\x77\x31\xdb\x40\x4d\x79\xa7\xac\xa9\xb5\xb9\x76\xc0\x92\x77\xed\x27\x2d\xe6\xcf\xd7\x95\xee\xe7\xd0\xdd\xd0\xa7\xbb\x85\x3b\x45\xa8\xd8\x18\x41\x46\x70\x70\x58\x38\x95\x2c\xe9\x62\x8b\xd6\x43\x45\x28\xe9\xa0\x57\xde\x35\xab\x7c\x89\x37\x0f\x60\x33\x05\xb8\xf6\xba\x9e\xd3\x17\x79\x0f\xcb\x66\x57\x47\xcb\x66\xde\xc3\x84\xe1\xea\xc3\xe7\xce\xe9\x53\xfd\x67\xf1\x88\x8a\x1f\xf5\x2b\xe8\xb2\x8b\x46\xee\x64\x43\x0f\x8d\xd0\x23\xa2\x63\xc2\xc3\x8a\x3c\xe1\x54\x06\x45\x1e\xa7\xd1\xc0\xd0\x0c\x43\x7d\x6a\xe0\x08\xbe\x71\x3d\x58\x2a\x2f\x22\xbe\xef\x2c\xb1\x56\xad\xf1\xc1\x1f\x53\x65\x7a\x6c\xff\xb6\x9d\x6e\xf3\x1e\xd7\x7a\xff\x12\xfb\xc5\xfb\x59\x53\x26\x4d\x19\xab\xad\x29\xbf\x7a\xef\x17\x7f\xf8\x74\xce\x32\xf7\xdb\x50\xd1\xc1\x9d\x1e\x22\x83\xf5\xe0\x50\x9b\xe6\x83\x37\x2c\xbc\x48\x93\x5d\xa9\x6a\xa4\x2d\x84\xc2\x83\xbd\x37\x54\xa8\x85\x98\x93\xc3\x7f\xd1\x09\x2d\xaa\x1c\xbe\xd7\x3f\x3f\xb8\xa4\xcd\x87\xa8\x74\x05\x4b\x7d\x82\x77\xcf\x34\x1f\xac\x5b\x64\x3f\x6f\x63\x79\x4a\xab\xf7\xb8\xb7\x04\x6c\x5f\xd6\xfa\x5d\xdb\x73\xd5\xeb\xf7\xf9\x38\xfa\x87\xa0\xdf\x22\x1c\xee\x08\xca\x36\x0b\x97\x3d\xaa\x9f\xca\x05\x66\x2a\xf1\xff\x16\x8c\x2b\xee\x38\x21\x1a\x69\xc9\xbb\xb2\xe2\x9c\x9f\x7f\x28\xfc\xa3\xe0\x4f\x62\x6f\xab\x1d\xcf\x66\x16\x12\x11\x11\x69\xb3\xc6\x26\x25\xc8\x04\xc4\x25\x25\xc5\x46\xea\xd5\x92\xf5\x90\x90\xa8\xf8\x58\x19\x4b\x85\x11\xa5\x47\x5e\x4f\x0d\xff\x07\xb2\xca\x63\x75\x50\xe0\x22\x3d\x48\x25\x48\xe3\x66\x9a\x4d\x4f\xd7\x33\x6b\x26\xc4\xc7\xa9\x8f\x57\x31\xea\x0b\x69\x0c\xe9\x32\x37\xea\x96\xa8\x07\xbe\x78\xb0\x7a\xb6\xcd\x76\x52\x0e\x98\x19\x99\x10\x1b\x3b\x4b\x76\xd7\x87\xdd\x71\xd0\xfb\x75\x8e\xb7\xae\xfc\x78\xf4\xf7\xc3\xee\x28\xbe\xba\x8c\x5d\x27\x3c\x7b\xc7\xd2\x2e\xf2\xb2\x3f\x97\xd4\x3e\x97\x8f\xad\xe1\xa2\x81\x3b\xde\x26\x39\xd9\xb8\x09\x85\x86\x59\xc2\x22\x58\x62\x56\x3d\xc8\xe2\x33\x0c\xcb\x72\xfe\x82\x6c\x8e\x4a\x57\x89\x0d\xf8\x2f\x33\x9b\xa8\xdf\x28\xfa\xd1\x5b\x9a\xe2\xad\x90\x3d\xe5\xec\x14\x29\xf5\x5f\xae\x8e\xb8\x36\x1e\x4c\x7e\xfd\xe1\x21\x6d\xa5\x52\xc5\x9e\x5a\xc0\xda\x7e\xc4\xf7\xad\x29\x4e\xed\xa9\x51\xbe\xaf\x4c\xf1\x09\xc1\xec\xa6\xc1\x86\xce\x42\xd6\x63\x6e\xba\xa7\xfa\xb6\x72\xf5\x53\x46\xa5\xa7\xd9\xfd\x65\xff\x23\xde\xef\xbc\x7f\xf2\xbf\x72\x99\x24\xad\xfc\x2f\xd1\xfb\xc9\xaf\x97\xef\xbf\xf7\xde\xfb\xb4\x35\xde\x35\xde\xe5\x5c\xfe\x3c\xfc\xaf\xbf\xf7\x25\xef\x1a\xf9\x9e\xb7\xc9\xf9\x9f\x7e\xf2\x9f\xe5\xb3\xcc\xef\x45\xa1\x22\x56\x34\x76\x57\xb3\x5b\xad\xb6\x30\x0e\xf6\xb8\x78\x8b\x9d\x9d\xdd\x62\x0d\x0a\xa2\xb6\x0b\xd2\xad\x55\x77\xb1\x2a\xcb\xd4\x5f\xcb\x65\xf9\x3e\x06\x38\x0d\x8b\x7f\x9b\xc7\x9c\x29\xf7\x95\xaf\x7a\x8b\xc4\x3a\x2d\xa5\x0c\xf7\x7e\xf6\xf0\xc3\x4b\x56\xce\xb8\x4f\x5f\xfa\xe8\x7b\x63\xbd\x35\x2c\x79\x27\x3e\x1d\x33\xc8\x5b\x34\xc6\x87\x81\x77\x8c\xb1\x00\x0c\xe2\x85\x93\x0a\xde\xa5\x47\x44\x88\x64\x7b\x02\x1b\x48\x84\x5d\x77\xa5\xc5\x26\x15\x79\x62\x8d\x88\xd4\x12\x8f\x1e\x11\x13\x6a\x2d\xf1\x84\xfa\x6b\xb0\x9c\x00\x2a\x09\x81\x6f\xa6\x66\xa1\x65\x53\xab\xcb\xf7\x6d\x3c\xb3\xa6\xfa\x80\x7c\x23\x4a\x6f\xec\x4c\x7f\xf0\x8e\x7a\xdd\x1e\x9c\xb4\xfa\xd3\xf6\x87\x3e\xba\x09\x56\xa7\xbd\xeb\x72\x4a\x3c\xe1\xef\xa6\xec\x3c\x5e\x47\x16\xca\xba\xff\x13\x34\xcd\x77\x36\xbd\xe7\xcb\x91\x38\x76\xe5\xcc\x30\x56\xa4\x08\x0f\x8f\x08\x8e\x61\x4d\x06\x1b\x09\xf1\x61\x31\x5a\x8c\x56\xe4\x89\x89\x11\x54\x18\xea\x7c\x0c\x37\xcc\xac\xf9\xcb\x1d\xf6\x2f\xb7\xbb\xc0\xda\x4c\xf7\x23\xa9\x4a\x8b\x60\xf3\xd4\x6c\xa4\x4f\xf3\x7e\xbd\x1e\x30\x2f\xc8\x20\x69\x5d\xf4\xb0\x1c\xe4\x7d\xe2\x81\x59\x6b\xcb\xae\x6a\xfa\xb5\x6b\x96\xbc\x0f\x0e\xcc\xde\x5f\xf3\xda\xeb\xfa\xcb\x83\x3d\xde\x59\xbe\xf5\x96\x49\x5e\xcd\x03\xd3\x5a\xa2\x87\x3b\x2b\x5c\xa4\x24\xbb\xe2\xb8\x8f\xc6\x25\x0b\xa3\x4e\xed\x70\x97\x9e\x98\x98\x3a\xc4\x23\x52\xa4\xfa\x76\x99\x68\xe8\x21\x25\x9e\x52\xb5\x21\xab\x64\xcb\xf1\xef\x59\x39\xd7\x2f\xa1\x2d\xae\x2f\xbc\x40\xb4\x0d\x97\xfa\x66\x15\xf8\x9a\x52\xb3\xbe\xee\xbb\x83\x5e\x3f\x45\x52\x65\x42\xaa\x66\xcc\xf3\x7e\xe9\xbd\xf2\x83\xf7\xf3\x3a\xb2\x7a\xc2\x93\xd3\x66\x4c\x1b\x7f\xe7\x67\x1b\x47\xb5\x90\x49\xe7\x4f\x5f\xcd\xf0\x9e\xa9\xbb\x67\xd4\xf8\xa6\x83\xe6\xef\x7e\x77\xb0\x9c\xb9\xff\xcb\xb7\xf7\x64\x0c\x1e\xd3\xc7\xd3\x7e\x40\xb5\xc6\x5d\x8b\xa7\xf7\xd8\xf0\xfe\xc6\x5d\xd5\xb7\x77\xef\xdc\xb0\x5d\xbd\x8c\xfa\x13\x56\x2a\x7f\x5a\x9b\xdf\xac\x6c\x22\xd3\x1d\x6d\xe5\x16\xa5\x69\xc1\x41\xea\x9b\xb6\xc2\x56\x46\x57\xf9\x38\xf1\x97\x6f\x53\xae\x38\xed\x4f\xef\x09\xef\x28\xa3\xb7\x51\x72\x65\x85\x51\xa2\xfe\xce\x87\x98\x0e\x36\xb7\xfa\xf6\xef\x0c\xb7\xdd\x62\x84\x47\x18\x6a\xff\x36\xfc\xf5\x42\xe0\xdc\xfc\xcb\x96\xad\x25\x49\x97\x3f\x7d\xd4\xb2\x8e\xd2\xb4\x7e\xbf\x9f\x96\x35\x7b\x8e\x18\x39\x58\xd6\xfc\x67\xac\x0c\x93\x89\x7a\x93\xab\x1f\x6c\x78\xe2\xd9\x32\xbd\xd6\xd5\x2f\xbc\x67\xbc\x3f\x28\x9b\x75\x33\x47\x42\xd4\x3e\x22\x85\xd5\x1a\xa2\x6b\xc1\x21\x5a\x48\x68\x98\x35\x24\x58\xd7\x74\x69\x6e\x70\x39\x39\x2d\xfe\x7a\x3f\x52\x45\xb0\x54\xfb\x58\x5b\x6e\xbe\x9a\xd7\xfb\x89\xb7\x81\x6c\xfc\x7d\x72\x76\x5c\xce\x77\x92\x43\xee\xea\xbf\x0a\x37\xdd\xb6\x45\xb7\x99\xff\x4e\xad\x41\x41\x49\x6d\x30\xd2\x7d\x4b\x42\x88\x0c\x09\x0e\x4a\x20\x92\xe1\x09\x6c\xb1\x89\x51\x32\xca\x48\x64\xf5\x89\xb8\xc4\x24\x99\x54\xad\x5a\x9c\x11\x1e\x6c\x49\x4e\x89\x0b\xb7\x1b\xb1\xe1\x32\x3c\x2a\xaa\x5a\x12\x86\x04\xd9\xfc\x86\x34\xf2\x9b\x92\xdd\x62\x50\x4e\xe5\x6e\x3b\xc8\xbf\xdd\x0e\xf2\xff\xb0\xfb\x76\x5c\xb5\xd7\x46\x4a\xb6\x5c\xd3\xc4\x9c\x18\x22\xde\x4c\xed\xb9\xfa\x9f\x7f\xb8\x1b\xd5\x4a\xaf\xdb\xed\x8f\xe3\x52\xf7\x84\x19\x91\xb5\x86\xbe\x39\x34\x3c\x26\x41\xb3\x86\xf4\x91\xba\x0c\xdd\xb3\x65\xe1\x46\xef\x21\xce\x96\x4e\xc5\xaf\xdc\xba\x56\xf6\xf6\xae\xaf\xd7\x6f\x7c\xf2\xaa\x6e\xda\xf6\x80\x2f\xfe\x33\xae\x8b\xbb\x66\x88\x2d\xd4\x2a\x0d\x61\x09\xa2\xe8\x0b\xb5\x5a\xa8\xf4\x42\xf5\xf0\x30\x69\x84\xd8\x0c\x6b\x50\xb0\xfe\xff\x31\xf6\x1d\x80\x55\x14\xe9\xe3\x33\x3b\x5b\x5e\xdf\x7d\xfb\x7a\x49\x79\x29\x2f\x81\x00\x81\xbc\x84\x10\x5a\x1e\x4a\xaf\x09\x7d\x09\x10\x12\x20\x20\x1d\x94\x2a\x0a\xa2\x54\x05\xec\x4a\x15\x3c\x95\x72\x54\x09\x82\xa8\xd8\x4e\x45\x05\x04\xeb\xd9\x4e\x4f\x8a\x05\x29\xbf\xb3\x0b\x59\xfe\x33\xb3\xfb\x5a\x88\x77\x7f\x23\x31\xc4\xd9\xef\x7d\x3b\xf3\xcd\xd7\x0b\x87\xc8\x2f\x08\xde\x9e\xa2\x72\x4f\xc4\xd3\x84\x83\xb5\x4c\xbf\x4f\x46\x18\xff\x17\x3d\xa6\x9e\x56\x4f\xa9\xc7\xf0\x4d\x1e\x0d\xdb\x41\x01\x5f\xfc\xb6\xea\x60\xf8\x11\xbc\xa8\x3a\x98\xb7\x98\x3b\xd5\x81\x70\x4f\xc3\x92\x86\x32\x4d\x66\x91\xf3\x7b\x9b\xea\xbb\x5d\x31\xcd\x61\xf9\x6a\xc0\x7a\x05\xcb\x62\xd2\x33\x19\x79\x04\x48\x78\xd8\x66\x96\xc9\x74\x38\x4e\x30\x20\x56\x23\x43\x0f\x3e\xc2\xc2\x82\x48\xaa\x6e\x61\xd7\xf5\x3c\x2a\x70\x43\xcc\x1f\xea\x67\xf8\x44\x4b\x30\x67\xc1\xdf\x99\x16\x0d\x1f\x32\x2d\x90\xaf\xe1\x1d\xa6\xad\xf6\xb9\xc3\xf0\xe7\xce\xa2\x7a\x66\x49\xd4\x6f\xc0\x6f\x0e\x04\x46\x30\x61\xc5\x4e\xa3\x76\xac\x79\x62\x8d\x06\xca\x8d\x35\x19\xdd\x31\x4b\x88\xa7\x84\x38\xe4\x5c\x30\xc4\xce\xba\x7a\x8e\x79\xa2\x61\x37\x7a\xa6\xa1\x86\x39\x76\x1a\xad\xfe\xf6\xc4\xb5\xe9\x34\x06\x33\x5b\x1d\x86\xde\xc3\xf6\x31\xf5\xee\x70\x80\x11\x80\x60\x30\x42\xf6\x17\x05\x1f\x03\xf7\x8b\x42\x82\x65\x37\x48\x1d\x5d\x3d\x86\xb3\x99\x11\xea\x3e\x58\xa1\x0e\x13\x66\x1f\xfd\xd3\xf0\x32\xc5\xb9\x0a\xdf\xa9\xdb\x62\xf1\x16\x80\x18\x7c\xda\x1c\x7b\x63\xbc\x85\x83\x11\x88\xee\xbb\xf6\xde\x59\x54\x12\x0b\xb8\x40\xa0\x62\x5c\x86\x37\xc6\x85\xc3\xb8\x70\xf8\xff\x36\x8d\x8b\xa3\x84\xde\x6e\xbb\x8a\xd1\xd8\x87\xd1\x19\xf6\x32\xf7\xfb\xd1\xdf\xef\xd5\xf6\xaf\x25\xc3\xb0\x8b\xb8\xbb\xb0\x20\x2d\x88\x3a\x30\x16\x90\xc7\x5b\xc8\x23\x1e\x1f\x12\xfe\xdf\xec\xb3\x34\x4e\x5f\xd4\xf8\xca\x19\x99\x6c\x18\x82\x68\xbd\x7a\x44\x7d\xf1\x0c\x5c\x0e\x6f\x82\x2b\x19\x86\xe4\x8f\xa0\x45\xd7\x48\x32\x06\xbc\x7e\xf5\x7a\x0e\x7b\xfa\xfa\x3d\xf8\x1d\x5d\x51\x4c\x81\x00\xbf\xdf\x0b\x78\xbf\x0a\xb5\xe0\x75\x9b\xd6\x02\xde\x73\x8e\xfd\xf8\x8b\x31\x63\xb4\x38\x57\x15\xbb\x05\x29\xdc\xb3\x58\x67\xf2\x46\xcd\x04\x0d\x01\xa0\xfb\xaa\xc0\xc3\xc9\xf1\xd1\xdc\x92\x90\xc7\xc5\xec\x55\x77\x41\xe6\x1a\xbb\xe5\xdb\x82\x9f\x32\x34\x99\x3c\x09\xef\xe7\x7a\xb6\x3f\x08\x83\x36\xd8\x9a\x95\x72\x84\x36\x6d\x5c\x36\xb1\x05\x42\xa2\x0b\x45\x8a\xf2\x08\xed\x65\x4a\x8e\x9e\x79\x42\x54\xb4\x41\x33\xb2\x09\x36\xc1\x0e\xec\xe6\x4a\xc5\x2e\x79\x5b\x81\x56\x15\x4a\x26\x16\xa7\xe5\x45\x49\x71\x15\xdd\x5d\xe1\x97\x4e\x14\xa4\x30\x74\x4d\x27\x2d\x29\x6e\x5b\x1e\x77\xc3\xc8\xc4\xb0\xa5\xfc\xae\xd4\x65\x43\x44\x8e\x66\xdb\xa0\x43\xb0\x31\xd4\x67\x5a\x02\x0f\x6d\xda\x77\xfa\xd4\x57\xdd\xfb\xf7\xea\x66\x50\x3f\x6f\x0b\x1f\x78\xe7\x93\x66\xad\x33\xd3\x7d\xf9\xf9\x2d\xd3\x27\x8d\x37\xf1\xe5\x5b\x5f\x5f\x36\xa2\xb2\xf9\xbc\x9a\x25\xce\xbf\x6f\xd8\xbe\x17\xb1\xa5\x13\x26\xf5\xaa\xb0\xc1\x2e\x6f\xbe\xa2\xce\xab\xea\xc6\x3f\xce\x9b\x78\x76\xe2\xf8\x99\xe3\x18\x23\xc3\x84\x7a\x95\x3f\xbe\x6e\x36\x7d\xe7\xfb\xf0\x3b\x4f\xc1\x74\xe0\x01\x39\xa0\x5d\x34\xcd\xeb\x60\x59\x94\x61\x45\xd6\xdc\xb0\x14\xac\x50\x1c\x92\xdb\x94\x55\xa1\xf0\x26\x09\x9f\xa2\x8b\x24\x0f\x44\xf4\x48\x7a\x92\x10\xc5\xea\x27\x65\xd1\x42\x84\x78\xc9\x65\xbb\x93\xa1\xd8\x63\x49\xea\x70\x26\xbc\xff\xfc\x7d\x06\xe8\x63\x98\x66\x4f\x4f\x3f\x72\xec\xc3\x43\x13\x37\xb5\x64\x8d\xbc\xb5\xa4\xa6\x7c\xcc\x2d\x13\xc6\xd5\xce\x5c\x31\x8e\xfd\x5a\x9d\xf3\x6c\xd5\x38\x7c\x4b\x7f\x52\xd5\x93\x63\x6b\x42\xb3\xfd\x4c\xf6\xbc\x67\x94\xc3\x87\x0f\xbd\xf4\x8a\x46\x63\xd3\x30\xae\x43\xf0\xf9\x78\x41\xf7\x68\x58\x44\x26\xa7\xd3\xe8\x42\x2e\x9f\x9f\xb7\x56\x28\x19\x98\x0d\x9b\x78\x09\x38\x25\x27\x63\x45\x4e\x27\x00\xf6\x0a\x85\x1c\x47\xdc\x48\x6f\xc2\x46\xe7\x12\x5e\x7e\x12\x0e\xb4\x13\x67\x4f\x29\x67\x63\x98\x19\xbf\xaa\x3f\x43\xdb\xef\x2f\xff\x99\xa9\x9e\xb3\x8c\x19\xfe\xe9\x97\x15\x53\xac\xd0\x2f\xde\xf5\xbe\x13\xe6\x62\xfe\x65\x81\x05\xaf\xec\xb0\x0d\x1a\x8b\x4d\xa3\x55\xe3\xc7\x59\xa7\xef\xa9\xa6\x7b\x59\x83\xf1\xeb\xa2\xef\x65\xfb\x68\x5a\xba\xc9\x8b\x1c\x0e\xa7\xc9\x99\x1b\x76\x00\x6b\xa0\x42\x91\xac\x92\x10\xaa\x50\x90\xe0\xa6\x7b\x19\x89\x6b\x54\xc9\x2a\x2d\x66\x9e\xad\x60\x09\xf5\x59\x91\x58\x25\x75\x59\xe5\xe1\xdd\x75\x7a\x92\x12\x2e\x3a\x43\xd4\x06\x9b\x21\x25\x1b\x27\x1f\x38\xf9\xde\x4b\x93\x37\x37\x67\x18\xe8\x33\xa8\x67\x66\x8c\x1d\x37\xe1\x96\x31\x9d\x6b\x4b\xc4\xf9\xf9\x93\x15\xcc\xeb\x10\x34\xc2\xfc\x9a\xd1\xcf\xc2\xd5\x57\x33\xc7\xad\x60\xb2\x76\x1f\x7d\xe1\xd0\xe1\x43\xca\x33\x14\xdf\x71\x18\xdf\x5b\xf0\x7e\xba\x40\x10\x0c\x89\xb6\xf4\x59\x2c\x48\x76\xf8\xcd\x66\xac\x4f\xa5\xa5\xcb\xb2\x00\x7c\x96\x4a\x45\xf4\x65\xf8\x18\x09\xf9\x7c\x40\x10\xdc\x95\x8a\x20\x01\x51\xdf\xd8\xbf\x70\x9d\x27\xab\x2d\x64\x83\x8b\x09\x55\x00\xbb\x2b\xa4\x59\xba\x1c\xcf\x22\x4c\xef\xf8\x25\x99\x59\xd7\xd4\x4b\x77\x5d\xfa\xdb\x45\xc8\x37\x64\xdd\x3d\xab\xf7\x2c\x27\x34\x96\x5e\x07\xfb\x26\x2c\x60\xe1\x71\xe1\x76\x27\x6c\x06\xad\xf5\xbf\x2f\x56\xff\xa1\x7e\x69\x78\x68\x57\xf9\x4d\x9e\xd5\xeb\xd0\xfe\x7b\x6f\x9f\xb7\x86\xd0\xc2\x6c\x6a\x1b\xfd\x80\x71\x8f\x44\xfd\x0e\x1a\x77\xb7\xb8\x3d\x26\x8c\x9b\x09\x12\x15\x05\xd3\x2e\x27\x42\x6d\x9b\x63\xf7\x31\x76\xf4\x71\x45\x85\x86\x2a\x3c\x2e\xb2\xad\x69\x10\xab\x2d\xab\xd5\xef\xae\x63\xd8\x9f\xbf\xfb\xc4\xf6\x47\x17\xd7\x8e\x82\x2f\xa0\x85\xd7\xee\x41\x0b\x8f\x0e\xda\xb3\x37\x78\xd8\x51\x39\xbe\xec\x28\xdd\xb7\x85\x6a\x7f\x76\x04\xdb\x07\x64\x81\x56\x60\x40\x34\x9f\x45\xa8\x99\x9c\xed\x35\x99\x32\xe5\xcc\xc2\xd6\x41\xd1\x15\xae\x50\xbc\x2e\x89\x65\x45\x20\xb6\xa8\x50\x2c\xa2\x0b\x08\x95\x58\xf1\x8b\x67\xa1\xd0\x9d\xba\xf1\xe4\x35\xcc\xe2\xa6\x2a\xf1\x5c\xf2\x49\x44\x50\xdc\xb6\x34\xc4\x63\x0e\xc1\xa3\xa4\xb0\x03\x33\xf1\xc8\x0f\x01\xe8\x13\x47\x77\x19\x3f\x91\x61\x46\x5d\x38\xf0\xe6\xc9\x57\x6e\xd9\xdc\x82\x33\x72\xd0\xc4\x5f\x77\xcf\xa8\x19\x77\xcb\x94\xea\xba\xa9\x6a\xff\xf5\x2b\x43\x5d\xfa\x3e\xb0\xb6\xc3\xad\x6f\x41\x0f\xa6\x0a\x1e\x66\xd4\x8c\xce\x9e\xe7\x98\xb2\xe6\xda\xbf\xcf\x5c\x41\xff\x7a\xea\xc8\xc1\xbd\x7b\x76\xbc\xa8\xdd\xb3\xb5\x78\x6f\x2b\x30\x1d\xbb\xb1\x0e\xe5\x71\x4a\x92\xdd\x20\x08\x76\x8f\x57\x06\x76\xc1\x05\x2c\xc8\x32\x50\x41\x52\x3c\x86\x5d\x9e\x6a\x95\x68\x51\x62\xbc\xbd\x1a\x92\xd4\xe2\x75\x0a\xf0\xa9\xb2\x5d\x73\xb7\x6f\x57\xbf\xab\x1c\x59\x77\x07\xb1\x95\x0c\xa8\x76\xe1\x8c\xe3\x1f\x36\x0c\x64\xa6\x3e\x36\x77\xef\xca\x86\x97\xb8\xe3\xea\xe4\xa9\x13\x35\x3e\x3c\x07\x7f\xfe\xed\xf8\xf3\x8d\x58\xd3\x6f\x1f\xcd\xb0\xe2\x03\x35\x01\xc4\x71\xd8\x14\x34\x0d\xaa\x32\x03\x83\x50\xa1\x18\x44\xc0\x22\x7c\xca\xc8\x15\x17\xc9\xf1\xc0\x88\x47\xe3\x4a\xb9\xba\x5b\xa1\x24\x84\x19\xbe\x0b\xf9\x61\xcd\xd5\xab\xf0\x5e\xf5\x5f\x4c\x07\x82\xc1\xd1\xa3\x47\x99\xa3\x47\x5f\x7f\xef\x3d\xed\x33\x89\x6c\x1e\x83\x3f\xd3\x8e\x29\xaa\x38\x1a\x90\xad\x56\x7c\x6a\xd8\x28\x74\xc8\x83\xaa\x1c\x40\xc2\x74\x25\x89\xac\x69\xa0\xc2\xc6\x04\x23\x68\x44\x52\x9c\x1e\xf0\x2c\x71\xc7\xdc\x0c\xf4\x53\xc7\xcc\x3c\xbd\x72\xc0\x53\x2d\x57\x2c\x9a\x36\x52\xdd\xcc\x2c\x24\x9f\x6c\xbd\xeb\xf9\x5a\xbf\xfd\xfd\xac\xc9\x53\xd1\x2c\x1d\x01\x08\x76\xe3\x77\x7e\x08\x7f\xbe\x19\x44\xa3\x99\x98\x95\x21\xaa\x83\xc5\x9c\x39\x26\x01\x32\xac\xd1\x20\x72\xc0\x8c\x55\x66\x97\xa6\x38\x96\x47\x3c\x8d\x8c\x19\xcd\x1c\x4b\x71\x34\x8c\x51\xbf\x9a\x4f\x8d\xd3\x25\xb0\x95\x7a\x0f\x5c\x07\x7f\x18\xac\x4e\xe2\x8e\x5f\xdb\x03\x5f\x51\x47\x34\x4c\xa1\x9f\x9d\xd8\xef\x16\x44\x67\xc6\xd7\x87\x33\x99\xe9\x26\x83\x1b\x36\x39\x49\xdb\x4f\xec\x6f\xf2\xde\xe2\x7d\x65\x2b\x8e\x52\xb8\xdd\xf0\xe3\x4b\x30\x7f\xc9\x23\xb7\xc4\x9d\x97\x07\x40\xba\x51\x34\x18\x8c\x19\xe9\xc6\xf4\xfc\x66\xfe\xec\x4a\xc5\xef\x77\xb8\x45\xd1\xe1\x60\x2b\xb1\xa8\xb1\x88\x19\x46\xed\xdd\x74\xc3\x02\x7f\xa5\x5a\xbd\x71\x57\x70\x9c\xbc\xb2\xed\xc5\x79\x11\x8f\x8b\x4a\x1e\x7c\x47\x74\xea\xcb\x8e\xfd\x6f\xf8\x4b\x6e\x51\xa4\xc3\x39\xfe\x34\xcf\x64\x4d\xec\x3f\x7c\x98\x83\xc9\x9f\x3e\x64\x4e\xdd\x59\xf2\x5b\xe6\xc1\x47\x6e\x7b\x71\x5d\xc3\x11\x34\xe8\xa5\xe6\x8b\x5a\xd7\x8d\x1a\x33\x6e\xd2\x88\x5d\xa7\x1b\x0a\xc9\xef\xb7\x6e\x6d\xd8\xa6\xdd\x05\xe2\x97\xa8\x60\x07\x60\x99\x53\x18\xf5\xd8\x31\xf2\xc0\x6b\xf4\xfa\xfc\x76\xd6\xc5\x0e\x54\x5c\x92\x55\xd4\x50\x4e\x8d\xd3\xea\x5e\xb4\xf8\x15\xc0\xf6\x5a\x28\x1d\x52\x2c\x33\x7d\x10\xb5\xeb\x37\x7a\x22\xbe\x05\xd8\x86\xb2\x20\x13\x8b\x6f\x06\xac\x60\x26\xaf\xbe\x67\xff\xf2\x86\x17\x51\xcf\x61\xd3\x5b\x38\x9e\xce\x58\x38\x43\x1d\xd3\x50\x89\xe9\x72\x24\xe6\xd1\x33\xf1\x1e\x9a\xf0\x6d\xc4\x9a\x9a\x9d\x37\x63\x15\xcb\xe3\x35\xda\x2a\x14\xa3\x84\x9c\xf8\x6c\xdc\x4d\xfa\x2a\xf4\x00\x76\x26\x4c\x8e\x51\xce\x54\xaf\x5c\xff\x55\xbd\x02\x6d\x2a\x63\x54\x3f\xab\x9b\xbf\x70\xea\xf4\xa9\x0b\x67\x30\xe9\x58\xe4\x7e\x8e\x05\x9b\x15\x0b\xb6\x9c\x86\x53\xaf\xec\xdd\xf7\xf2\xab\xfb\xf7\x6a\xf7\xe2\x3e\x75\x18\x3b\x05\xbf\xbf\x07\xe4\x82\xce\xd1\x8c\x0c\x93\x97\xa5\x32\x2d\x2f\xec\x11\x1d\x01\x29\x68\xc5\x5a\x82\xd5\x8d\xb2\x04\xac\x26\x08\x52\xb2\x7a\xec\x2d\x6f\x24\xd7\xa0\xbe\x05\x45\x24\xf3\x8b\xaa\x08\x1e\xb2\x37\x79\x30\x49\x4b\xb0\x41\xb8\x91\x37\xb2\xad\xb7\x4e\xae\x3f\xa1\x0b\x36\xf5\x5b\x03\x4c\x2b\xae\x8e\x8e\xaf\xa3\x92\x8d\x6d\xef\xba\x33\xad\xba\x4e\x7d\x5f\x55\xd5\xdf\xd4\x8f\xb1\x6c\x53\x47\xb3\xbf\x8d\x5b\xd1\xf0\xaf\xb9\x5b\x87\x1c\x7d\xee\xf0\x61\x22\xdc\xb0\x2c\xc6\x78\x77\xc1\x78\xbb\x41\x36\xe8\x18\x4d\xf7\xc8\x58\xaf\x41\xb9\xe9\x56\x6b\x4e\xae\x5b\x94\xb0\x30\x96\x25\xc9\x14\x22\xaa\x8d\x1b\x05\x6e\x10\xc6\xda\x55\xa2\x5c\x04\xd2\x13\x2c\x4d\x12\xc8\x94\x15\x23\x9a\x40\x14\xdb\xd8\x2e\x06\xf5\x5b\x5d\xb7\xf9\xf8\xe0\xa9\x5a\xd6\x82\x12\xaa\x0d\xdb\x7e\xc5\xb8\xab\x46\xf8\x24\x56\x6e\x60\x18\x5a\xc1\x75\xd8\xe6\x8d\x16\x73\xad\x0d\xff\x4a\x52\x6e\x20\x78\x13\xd3\x59\x19\x3e\x67\x27\x68\x16\x75\xda\x78\x5e\x10\x9c\x2e\xb7\x4d\x96\x99\x81\x18\x53\xb3\xc8\x53\xe5\x2b\x85\xc6\x48\xaa\x5e\x12\x7d\xe9\xd4\xef\x61\xcb\x66\x8c\xdb\x78\x48\xfd\x2e\xe0\x83\x62\x8e\x89\x2d\xda\xb9\x62\x62\x1d\xaa\x70\xfc\xf8\xaa\xda\x9b\x79\xa9\xef\xc9\xb1\x4b\x6a\x57\xcc\xb0\x6b\xb4\x3d\x1f\xd3\x16\xa1\xed\x7c\x30\x3c\x5a\x24\xf0\x21\x67\xc0\x6f\x05\xc0\xef\xe4\xd9\x66\xcd\x43\x56\x0f\xf2\xa4\x57\x28\x63\x02\x50\x0c\x64\x04\x18\x13\x0a\x04\x3c\x12\x32\x61\x3e\x28\x64\x62\xd3\x48\x20\x74\x97\xec\xb6\xf8\x4b\xbf\x05\x39\xe9\xd2\x84\xdf\x82\xd1\xf2\x03\x3c\x42\x6c\xff\x3c\xe9\x98\xc5\xa8\xd7\xcf\x7c\x75\x31\xef\x37\xd7\x84\xc5\x73\xa6\x0c\x9b\x78\xe9\x99\x61\x97\x3f\x7f\xf5\x42\xda\x1f\x96\xd1\x75\xe3\xc6\xf5\xab\x5a\xf4\xc6\xdc\x1e\xb0\xe3\xa6\x03\xab\x1f\xc9\xed\x17\xed\x18\x2d\xee\xe4\x2a\xac\xbc\x6b\xf4\x86\xdd\x8f\xae\xf1\xdf\xd4\x25\xd2\xb1\xb0\x54\xf6\x97\xf6\x9d\x4b\xdf\x69\xeb\xf5\x9f\x58\x33\x37\x18\xdf\xd7\xb6\xd1\x00\x8f\xf9\xa8\xd7\x6b\xf7\xf9\x9d\xf8\xba\x38\xdd\x46\xc8\x40\x7c\xe2\x0c\xcb\x32\x22\x88\xa7\x0b\x37\x56\x0d\x48\x6e\xb4\x16\x99\x70\x6a\x4e\x2d\x72\xf2\x58\x25\x83\x3d\xb7\x1d\x1c\xbe\x0f\xde\xa5\x2e\x0a\xf5\xbe\x79\xe1\xdd\x6b\xe6\x44\x17\xfd\x7d\x18\x56\x0e\xa0\x5f\x3d\x7f\xb4\xe1\xd2\xf0\x4e\xd9\x81\x23\x1e\x63\xb7\x87\x96\x6a\x7c\x03\xef\x6d\x47\xb6\x3d\xa6\x3f\xcc\x37\x80\x9b\xb0\x3d\xb7\xd1\xe3\x15\x65\x19\xf3\x0d\xd9\x6d\x75\x19\x80\xd8\x34\xdf\x80\x09\xa7\x87\xd3\x13\x0a\x97\x64\xd3\x7c\x5b\x3b\xdc\xa2\x0c\x1a\x31\x9b\x68\x79\x3f\x5b\xb8\xc9\x5f\x3e\xb5\x8b\x6d\xdf\xb0\x75\xd5\x43\xfb\x97\x33\x5d\xaf\x1d\x5e\x35\xf1\xfe\x1e\x17\x4e\x9f\x64\xf6\xd2\xcf\xc6\xe6\x0c\xbb\x03\x7f\xb6\x09\x14\x45\x3d\xc4\x07\xc2\x18\x4d\x88\xa1\x3e\x10\x48\x9c\x20\x22\x20\x8a\x11\x71\x55\x13\x32\x6f\xda\x0b\xd2\x19\x3a\x42\x88\x57\xf7\xa9\xb7\xc0\x66\xa7\xc5\x76\x7c\xa7\xaf\x61\x18\x7f\xe2\x83\x45\xc7\xbc\xef\x69\x79\xf2\x90\xcc\x96\x67\x5f\xc3\x9f\xe3\x01\x7d\xa3\xb9\x58\xed\x72\x60\x11\x69\x10\xac\x56\xd6\x81\x8c\x6e\x0f\x7e\x5b\x9f\xc3\x8a\x39\xa4\xe8\x71\x9b\x30\xdf\x17\x60\x4c\x70\x69\x1e\x8f\x48\x3c\x99\x44\xf6\xc4\xf3\x9b\x22\x45\xba\xaf\xc3\x46\x7c\x1d\x11\x87\xdb\x55\xea\xc0\xdf\x3d\xc5\x6d\x1d\x11\x96\xfd\x79\xad\x8f\x81\xce\x8d\x3f\x1d\x3a\x3b\xc8\xe1\xdc\xf4\xea\x7d\xa2\xcd\x39\xf2\x1b\xf8\x49\x85\xdb\xd8\x47\xf5\x90\xfd\x78\xbc\x77\x6f\x78\x49\x2d\x2b\x2a\xef\xfc\x24\x53\x43\x71\x6c\x83\x71\xdc\x80\x71\x34\x83\x07\xa2\xa3\x9a\xf6\x6f\xfc\x2c\xc0\xe7\x84\xf3\x02\xf3\x88\x00\xe7\x08\xcb\x04\x66\xa0\x00\xbb\x0b\xb0\x58\x80\x6e\x01\x5e\x85\xf0\x79\xf8\x3d\x64\xd6\x43\x38\x1f\xae\x84\x4c\x07\x58\x85\x89\x88\x38\x44\x8c\x06\xbe\x3b\x37\x94\xab\xe3\x10\x27\x9a\x11\x13\x7b\xb7\x51\xf8\xe5\x88\xff\x3f\xe9\x9f\xff\xe5\x25\x09\x50\x41\x3d\x49\xfd\x53\xfd\x5d\xfd\x08\x3e\xaa\xde\x01\x0b\xff\xef\x0a\x6c\x83\xff\xbb\x0e\xae\x50\xe7\x31\x85\x8c\x99\x38\x92\x1b\x7e\x6f\x38\xa9\xed\x7b\x18\xf3\xb6\x67\xf0\x3b\xb9\x40\x55\xd4\xc9\x18\x1d\xc8\x66\x93\xcd\x26\xbb\x6c\x92\xdd\x9e\x45\x78\xe3\x6c\xc4\x52\x0d\x88\x72\x4f\xc6\x26\xdb\x18\x23\x6b\x33\x19\x8d\x0e\xb7\x6c\x37\x9b\x44\xc0\x0d\x8a\xdb\xf6\x91\x58\xb6\x16\x51\xdf\xab\x67\x26\x13\x02\xcd\x89\xcf\xca\x2b\xc9\x80\xd8\xd4\x28\xa5\x04\x51\x8a\xd1\x84\x98\x3d\x77\x9b\xd4\x37\x12\xe9\x38\xa0\x3c\x4f\x8d\xc2\x66\x47\xf3\x3b\x19\x2b\xeb\x61\x58\x8d\x56\x1c\x55\x87\x59\x8f\x71\x28\x3c\xfc\x16\xb6\xb0\xe1\xff\xa6\xfe\x3b\x17\xe6\x32\x8e\xab\xab\x4f\x3e\x09\xe2\x71\x2a\xcc\xbb\x35\xff\x8a\xc0\x42\x23\xc3\x43\xde\x44\x82\xd3\x08\x2b\x55\x22\x14\x80\x30\x50\x01\xae\xbf\xf4\xaf\x44\x62\xee\x15\xd7\x2a\xa6\x7d\xc3\x65\x54\xd9\xf0\x36\x33\xf1\x2d\x66\xfb\xbb\x6f\x37\x8c\x3c\x81\xe1\xbf\x86\xf7\xc4\x85\x75\x98\x6c\x4c\x8b\x79\x3e\xe4\x76\xa7\x1b\xcc\xe9\x08\x65\x4b\x48\xca\xc9\xf5\x19\x04\x83\xf0\x8b\x62\xc0\x4a\xa3\x28\xff\xa2\x88\x00\x84\x52\x5c\x1c\x37\xf8\x86\x3d\x71\xff\x11\xb9\x7a\x98\x6d\x95\x74\x86\xf8\xbf\x6d\x23\x21\x17\x65\xb9\x5a\x72\x13\x31\xd7\x3b\x40\x17\x73\x72\xd9\xd6\x69\x73\xe7\x4f\xd9\xb4\x0a\xf6\x78\xb1\xaa\xf2\xd6\x91\xd5\x33\x2a\xab\x5e\x54\x87\x6d\x5a\x03\x7b\xce\x9a\xc9\xbc\xce\xcd\x9c\x09\x7b\x3e\xb8\xee\xe8\xc4\x5b\xd4\x0f\xaa\x57\x39\x58\xf7\xca\x51\xea\x07\x93\x26\x50\x1f\x0e\x3c\xa3\x96\x31\xdf\x53\x1f\x8e\xf3\x10\x03\x21\xcd\x97\x05\x85\xe5\x71\x5f\x05\xd1\xe3\xce\x40\x5e\x2d\x13\x1e\xfa\x7d\x2a\x7e\xcf\xc3\xf8\x3d\xcd\xf4\x3d\x7b\x47\xc3\x46\xaf\x95\xf3\x06\x38\x94\x29\x03\x90\x99\x93\x6b\x0a\x04\x03\xc1\x5f\x94\x40\xc0\x01\x1c\xf8\x35\x1d\x8d\x3d\x39\x4d\xbe\x26\x79\x4b\x07\xcd\x80\xb4\xeb\xf9\x5b\x76\x9a\x13\xa9\xbb\x23\x3c\x98\xfd\x91\xf7\xcd\x3e\x8c\x5f\x6d\x46\xf5\xa8\x59\xf8\xd5\x60\x8f\x55\x9b\xa6\xcc\x9f\x3b\x6d\xcb\x72\x75\xd8\xcb\x13\x26\xc1\x96\xa3\x56\xba\x59\xe7\xaa\xd1\xb0\xe5\x2d\x13\x8f\xae\x7b\x50\x3d\x3c\x73\x26\xf7\x3a\x33\x73\x96\x7a\x78\xf5\x66\x72\xf6\xd5\x98\xe3\x4e\x45\x3d\x69\x8c\xbd\x04\x53\xa2\x07\x48\xfb\x88\x6e\x19\x05\x15\x60\x0c\x38\x05\x38\x23\x02\x40\x36\x9b\xb9\x7d\x8a\x68\xae\x36\xef\x35\x23\x92\x13\x32\xdd\xbc\xd6\xfc\x84\xf9\x65\xf3\x65\xb3\x60\xa6\xe9\x3b\x24\xdd\x83\xda\x9a\x91\x78\xce\x32\x89\x36\x10\xef\x49\x09\xb1\xe3\x62\xdc\x1a\xd5\xf6\x79\xa0\xcf\xf2\xa1\x3d\xe6\x76\x99\xb9\xf9\x96\x95\xf7\x8c\x6b\xb9\x6c\x56\x74\x36\xc3\x36\xf7\x17\x16\xb4\xfc\x68\x70\x61\x2b\xef\xc8\xcf\x5b\xe4\x00\x3a\xb1\x8f\xfe\x23\xf1\x74\xba\x21\x03\x3f\x54\xff\xc3\xfc\xc9\x96\xd2\x5c\xa3\x02\x7c\xb3\xb0\xca\x20\x08\x58\xe3\x03\x02\x12\xf8\xcd\x55\x82\x88\xb6\x27\xa2\x31\xc9\x6e\xef\x88\x83\xd6\x28\xc1\x9f\xcf\x67\xaa\x9f\xe1\xdb\xf0\x35\xb3\xfa\xda\x78\xae\x9b\xfa\x1f\x68\x23\xef\x5f\x7b\xfd\x1f\xec\xad\xdc\x38\xcc\x97\x67\x47\xbb\x38\x0c\x06\xc9\xe8\x71\xbb\x91\x91\x4d\xb3\xb2\xd6\xcc\xd0\x0c\x0f\x14\x31\x97\x46\x51\x54\x81\xb6\xa0\x7d\x08\xef\x06\x16\xbd\x48\x12\x24\xff\x1c\x7c\x86\x12\xc4\x24\x2c\xd9\x05\x93\x20\x80\x39\x0a\xc6\x07\x14\x26\x0a\x5e\xf4\xcd\x88\x3b\x9a\xe2\xcc\x46\xd6\x72\x3b\x74\xfc\xa8\x57\x03\x92\x0a\x97\x30\x16\xbf\x72\xac\xac\x25\x26\x81\x99\xdb\x87\xcf\xb5\xc1\x80\xfb\xeb\x67\x9f\xfc\xe4\xca\x85\x2f\x9e\xdc\xf1\x59\x50\x3d\x2f\xce\x18\xbe\x70\xf1\x52\x58\x3a\x75\x9c\x65\xdd\xbb\xae\x97\x5f\x72\x41\xe9\xc2\x77\xd0\xef\x3b\x7c\xd8\xf1\xc2\x63\xb6\xaa\xb1\x87\x9f\xda\xf3\x1c\x7e\xb7\x5e\xf8\x5e\x6f\xe4\x46\x80\x30\x78\x24\x9a\x19\x74\x04\x32\x32\x2c\x86\x30\x00\x4e\x87\xc1\x91\x97\x0f\xc2\x52\xb8\x75\x38\x1a\xae\x08\x2f\x0e\xf3\x12\x0a\x13\xbe\x64\x32\xda\x7a\x86\xc3\x59\xe9\x26\xb3\x89\xcc\x3a\x68\xa6\x04\xca\xcd\x70\x86\x73\xb1\xf3\x15\x27\x12\x9d\x19\xce\x42\x27\x32\x22\xb3\xd3\xec\x64\x25\xc9\x43\x72\x11\xb9\x2c\x36\xeb\x56\x85\x4d\x4d\x58\x8e\xbf\x2f\x15\xe1\xf2\x0d\x09\xcc\x89\x8c\x7e\x2c\xbd\x43\xf8\xf6\x76\x22\x72\x3d\x45\xf5\x20\x16\x7f\x88\xc4\x7b\x42\x78\x7b\xd8\x8d\x19\xef\x3f\xd6\x10\xad\xeb\xf3\xe2\xb3\x1f\x7f\xb8\xe3\xb5\x16\xdf\xbb\x06\xde\x54\x55\x01\xd3\xd5\x6f\x06\x8e\x83\xcb\x26\x4e\xb6\xc3\xc9\xbb\x5e\x3e\xd1\xfe\xfe\x5b\x06\xee\x7c\xf3\xed\xf7\x56\xad\x2b\xec\xd7\xfd\xd6\x3b\xf6\xee\xac\x98\xf0\x60\xbb\xb1\xa3\x89\xbe\x59\x07\x76\xb2\x75\xec\x2e\x7c\xdb\xf2\x30\x87\xf3\xf9\x10\x0a\x02\xbb\xd9\x9c\x65\x03\xb6\xfc\x66\xae\x8c\xdd\x8a\x4b\x10\x72\x77\x2b\x02\x8d\xa3\x49\xff\x88\xab\x1c\xde\xc2\xd8\x29\x39\x8a\x49\xd1\x01\x21\xe4\x52\x8f\xe0\x76\x39\x49\x21\x02\xa9\x35\x11\xf2\x4a\xc3\xa5\x4e\x77\xdc\x8f\x76\xa0\xe3\xd2\x4d\x77\x8f\x9f\x3b\xbf\x76\xf9\xe6\x15\x1d\xdb\x2f\xdb\xbc\x74\xdc\xfc\x05\xb5\xcb\x37\x2d\x6f\xff\xcd\x82\x61\x43\x6e\x5f\x30\x74\xe8\xed\xcc\xae\x79\xe3\x97\x6e\x5c\xda\xa1\xc3\xf2\xcd\xcb\xc7\xce\x9b\x33\x76\xe9\x96\xe5\x1d\xca\x56\x6e\x5e\x39\x76\xc1\xd0\xdb\x17\x0e\x19\x7a\xfb\x02\x7c\x6e\x21\x7c\x6e\x7f\xe7\xba\x61\xfd\x64\x76\xb4\x33\xc3\xf3\xb2\x5b\x34\x9b\x65\x97\xdb\xed\x34\x1a\x1c\x32\x0b\x0c\x06\xab\x5d\x66\x8d\x46\xaf\x47\x30\x5b\xcc\x73\x15\xac\xd2\x8a\x92\x38\x57\x71\x02\x69\x86\x04\x2d\x92\x45\x32\x38\x5c\x6e\x24\xf3\x06\xaf\xee\x80\x2f\x2b\x2c\x8c\x65\x65\xd9\x13\x35\x77\x89\xb2\x34\xf2\x3d\x29\x89\x95\x6c\x3e\xfd\x2a\xd1\xbf\xa8\x2c\x44\x05\xd0\xa9\xee\x81\x03\xd5\x3d\xea\x15\xea\xef\xde\x87\xff\xbe\x18\x4b\x9e\x2c\xac\x3b\x87\x98\x03\x0f\x3e\xf9\xd0\x8f\x3f\x3e\xf4\xe4\x83\xcc\x83\x0d\xdf\x31\x5e\x7c\x67\x35\xfe\xb9\x47\xaf\xff\x93\x04\x86\x61\x21\x34\x18\x39\xc0\x01\x48\x7c\xe1\xe5\x85\x14\xb3\xc6\xc9\x8d\x31\xb6\xfa\x27\xe4\x99\xa7\x90\xe9\xda\xaf\x57\x1f\x41\xe6\x6b\xbf\x68\x36\xcf\xe4\xeb\x43\xd8\xa1\xdc\x09\x10\x01\x9d\xc1\xf2\x68\x5f\x57\x27\x4f\x41\xab\x52\xb9\x4d\x7a\x1a\x8b\x72\x3c\xa6\x36\x6d\xd2\x3c\x88\x2d\x28\x96\xcb\x0a\x0a\xe4\xf2\x68\xa7\x7c\x57\xa9\xad\x95\xab\x55\x08\xf8\x43\x95\x0a\x48\x97\xd2\x5f\x49\x3f\x95\xfe\x75\x3a\x67\x42\xe9\xe9\x7e\xe2\xf9\xb9\x8d\xbd\x87\x65\x0a\x59\xc8\xb2\x18\x3a\x49\x4f\x20\x4a\x73\x61\x72\xac\x4f\x17\xc4\x31\xf9\x9b\x50\xa0\x13\xba\x02\x4c\x52\x99\x69\xac\x8f\x96\x25\xb9\x68\x31\x56\x5c\xbd\x6e\x05\xf3\x68\xfe\x6d\x29\xfd\x8e\x4d\xbf\x3c\x6d\x75\x5b\x66\xf6\x6b\x17\x02\x97\xad\xb3\x46\xcc\xb8\xa5\xed\xd8\xbb\xb7\x6f\x1d\x32\x6d\xd8\xc1\xab\xdf\x7f\xf5\x7f\x79\x17\x9d\xb7\xdf\xbe\xe0\xce\xd6\x13\x9e\x3f\xf9\xf7\x69\x13\x46\xd4\x5e\x80\x1f\xcc\xdd\xfd\x6a\xdb\x71\x2b\x5e\xe7\x4e\xac\x5e\xea\xeb\x7c\x73\x87\x2e\xcd\xca\x0a\xd2\xc2\x03\x17\x0c\x1b\xb5\x36\x30\x60\xff\xb6\xfd\xf7\x3e\x92\x5b\xd1\xa7\x4b\x45\xeb\x8e\x2d\x5b\xb4\xd9\x38\x63\xd4\xe2\xec\xf0\x8a\xc1\x8f\x3c\x75\xed\x8d\x1e\x7d\x43\x9e\x25\xcd\x4a\x9b\x67\xd0\x61\x03\x0c\x0c\xb1\xaf\xa3\x5d\xdc\xe6\x78\x5d\x26\x66\xa2\xa4\xee\x13\x8b\x37\xb8\xba\x8a\x05\x8f\xe8\x7e\xf2\xe4\x73\xc1\x5c\x29\x84\xff\x30\x6f\x9f\x69\x98\xfd\x35\xfb\xfa\xe7\xf8\x1f\x2d\x87\x39\x03\x84\xd9\xdd\xd4\x1f\x15\x06\x45\x60\x51\xb4\x1f\x26\x51\x83\xd3\x86\x9c\xc8\xd3\x32\x23\xcf\x93\xe1\x29\x8e\x60\x59\x67\x7f\x5b\xe1\xcd\x6f\x2b\x46\x5e\xc4\x0f\x5c\x06\xd7\x01\x0b\xa2\x56\x7b\x4f\xc0\x4b\xfc\x0c\x7e\x31\xff\x35\x7f\x85\xe7\xb1\xa0\xe1\x01\x1f\xc8\xce\x6e\x7e\x4c\xc9\x06\x81\xd6\xc7\x94\xc0\xe9\x24\xf1\xa8\x73\x95\x02\x4c\xc7\x05\x29\x7a\xb9\x9c\x6c\xc6\x66\x69\x85\x61\x1e\x21\x6e\x59\x93\xdc\x41\x88\xe5\x45\x76\x56\x0e\xe1\xaf\x24\xa1\x52\x16\x88\x8d\xab\x19\x8c\x32\x73\xdb\xf6\xe7\x9f\xdd\xfe\xe9\xd0\x55\x6d\x66\x55\x8f\x9b\x3c\x6a\x66\xfb\xbb\x72\x37\xc0\x13\x6b\xd4\xdf\xf7\xef\x57\xff\x58\xbb\x06\x1a\xf7\xed\x83\xc6\x35\x77\x5e\xfe\xec\x93\xcb\x57\x3e\xfe\xf4\x0a\xec\x77\xe6\xdd\x77\xfe\x75\xba\x60\xd1\xba\x07\xd7\x3c\xb5\xbe\xf9\xcc\xdb\xe1\xae\x33\xea\xf3\x3b\xfe\x0e\xbb\x7f\xf3\x0d\xec\xfe\xf7\x9d\xea\x0b\x67\x61\x26\x2c\x57\x5f\x55\xbf\x56\xbf\x54\x5f\x87\x9d\x30\xcd\xbe\xc3\xdc\x8d\x1a\xb8\xad\xf8\x5e\x17\x80\x61\xd1\x2c\xab\xcd\xd6\x1c\x65\x08\xb9\xb9\x2e\xe4\x6a\xd1\x52\x08\x9f\x55\xac\x51\x8b\xd4\xd3\x2a\x58\x49\xc8\xc2\x74\x4e\xb1\x1f\x86\xcd\xa2\x46\x6f\x16\xc8\x3a\xaf\x04\xc1\x77\x37\x86\x2d\x0a\x0a\x9a\xf2\x4d\xea\x21\x0b\x22\x73\xf3\x74\x67\x0b\xde\x00\x3d\xf0\x9f\xcd\xe7\x11\xb7\xa5\x40\xca\x6a\xe0\x4b\x33\xee\x7e\xea\xc9\x1d\x73\x3b\x75\x12\x3e\x77\x3e\x77\xff\xc6\x3d\xae\x70\xbb\x9b\xbb\x55\x8e\xe6\xd1\xa0\xaa\xee\xe3\x26\x8d\xef\xc1\xdc\xbd\x60\xda\x6d\x77\x30\x4c\xeb\x95\x25\xa5\xe6\xe9\x0b\x56\x2e\x55\x2f\x97\xb6\xe3\xee\x70\x0d\xee\xbe\xe9\xb1\xa9\x7d\x33\x10\x2a\x6d\x5f\x83\xdf\xeb\x1e\xb0\x9a\xed\x85\x76\x01\x03\xb0\x83\x81\xd1\x7c\xa3\xdd\x6e\xb1\x5a\x4d\x98\x3d\x21\x96\xe5\x21\x14\x4d\x26\xd9\x61\x41\x3c\xba\x58\x65\xc4\x47\x7b\xb1\x4a\x34\x9b\x18\xc8\x5f\x06\x9d\x88\x7a\x1b\x89\xc4\x2a\xae\x92\x6b\xd0\x22\x49\xa9\xdd\xb9\xd8\xae\x8b\xb8\x10\x74\x85\x62\x3f\x20\x85\xb8\x80\x2f\xa9\x10\x34\x74\x52\x55\xc8\xfc\x88\x7f\x5a\x0d\x6f\xe9\x01\xa7\xe7\xaa\x0f\xaa\x8f\x65\x27\xfd\x48\x64\xfb\x60\x8c\xdf\x30\xe4\xa3\x39\x3a\x12\xe0\x18\x92\xa3\x03\xf6\x2a\x2c\xdc\xad\xb0\xa4\xe2\xab\x20\x9e\xa3\x93\x4b\x83\x67\x68\xee\xb5\x2f\x59\xb4\x1a\xee\xfa\xba\xe1\x36\xac\x83\xc4\xea\xb2\xb0\x0e\x22\x91\x50\x6c\x9c\xd6\x45\x90\x06\x72\xb1\xf5\x72\x6f\xb4\x32\x68\xb7\x3b\x7c\x52\x5a\x5a\xba\x2f\xcb\xe1\x70\xfa\x9c\xa0\x05\x96\xb0\x06\x50\x14\x91\x9c\x41\x39\x4b\x3e\xa6\xb8\x42\xc7\x14\x22\x3a\x07\x38\xab\x9d\xd3\x9d\xdc\x80\xac\xea\x2c\x86\xd4\x40\x30\x46\xe4\xcc\x72\xb9\xb2\x9c\x88\xb5\x58\x9a\x1d\x53\x2c\x80\x2d\x3c\xa6\xb0\x49\x14\xef\x21\x27\xad\x09\xd2\x02\xdd\xe5\xd6\xb8\x22\x32\x56\x39\x43\x8d\xf9\x54\x12\xc7\x26\x1a\xc9\xfd\xd1\x12\x32\x1d\x48\xcb\xc7\x6c\xcb\x25\x11\x3e\xbb\xbb\x31\x91\xab\x13\x8f\xde\xf6\x18\x8c\xac\x79\x6c\xfc\x90\xcf\x0e\xed\x5b\xb0\xac\x62\x30\xcc\x8a\xd1\x3d\xf3\x47\x23\x32\x6f\x58\x00\x7b\xa9\x87\x50\xf9\x9d\xd3\xeb\x96\x38\xd4\x1d\x4c\xc5\x22\xf5\xbb\xfe\x63\x53\x69\xff\xfa\xf5\xeb\x57\xb9\x5d\xec\x69\xde\x22\x0b\xe0\x26\x00\xf8\x15\x94\xff\x84\x51\x00\x6d\xe3\x1e\x00\x16\xe0\x05\x65\x51\x93\x15\x00\x07\xcf\xfb\xfc\xc8\x4d\x0a\xb1\x2d\x0a\x40\xad\x11\xe3\x42\x24\xf7\x09\xff\x62\xbf\x62\xd2\xe5\x72\x2c\x51\x30\x9e\x30\xad\x15\xbb\x52\x52\x17\x92\x5c\x69\x68\xdb\x0b\xcb\xee\x79\x71\xc8\x43\xc3\x97\x1f\xd9\x3c\xaa\x7b\x8f\xea\xda\xae\x37\x8f\x61\x87\x2e\x79\xfe\xb9\xa5\x43\x1f\x1c\xf4\xfc\x92\xee\x63\x6a\xba\x75\x1b\x5b\x4b\xf2\xd7\xf1\xa1\x4e\x64\x7f\xc5\xf6\xa7\x08\x46\x45\x3d\x5a\x85\xa0\xd9\xc2\x8a\x66\xd6\x2c\x61\x5a\xde\xad\x58\xbc\x2c\x73\x18\x06\xa3\xe6\xa4\x72\x41\xf2\x77\x8b\xf2\x0a\x99\x1c\xcd\xa1\x45\x1c\xe4\x48\xf6\x7c\xbc\x7a\x30\xc5\xdb\xd7\x64\x11\x21\x49\x69\x67\x3e\xfe\x5a\x9d\x0e\x1f\xf8\x1a\x3e\x48\x32\xdb\x99\xd7\xd5\xbf\xc3\x21\x5f\xc1\xc1\xea\xae\xaf\x1a\x3a\x7d\x45\xc6\xcc\x63\xcb\x25\x82\xde\xe2\xd6\xe0\x1d\x1a\x14\xcd\xf6\xf0\x76\x37\x84\x26\xb3\xdd\xec\xf3\x6f\x31\xed\x33\x31\xa2\x29\xc3\xf4\x84\x09\x5b\xc8\x26\x93\xcd\x6d\x33\x9c\x57\x6c\x87\x61\xc1\x21\xe8\x06\xee\x6f\x15\xf0\x7d\xa3\xf2\xb1\xa4\x7c\xf3\x58\x50\x10\x96\xb4\xa5\x59\xe6\xd9\x59\x31\x56\xe1\xd4\x4a\xc7\xa0\xab\xfc\xdd\xea\x81\x63\xc6\x5a\xce\x8a\x07\xd7\x6e\xdc\x55\xbf\xb4\xc2\x0e\x77\x30\x91\x35\x2b\x17\x75\x1c\x51\x38\xf9\x56\x7e\xce\x7d\x4b\x66\x3f\x74\xeb\x90\x2e\xe1\x27\x31\x8e\x06\x26\x0f\xbd\xc6\xad\xc6\x77\x61\x61\xb4\x63\x56\x86\xcd\xc6\x01\xaf\xcf\xc7\x73\x26\x7c\xe3\xc2\x79\x5e\xaf\x2d\x18\x74\x9d\x57\x30\xbf\x23\x7c\x3e\x93\xc7\xe8\xf2\x3c\xb6\x87\xad\xe7\x15\x8b\x2d\x68\x3b\x6e\xfb\xc2\xc6\x1a\xf1\xdf\x51\x10\x23\x7f\x10\xe1\xb7\x40\x3f\x68\xe4\x2f\x97\x25\x85\xad\xa8\xee\x58\xd6\xb8\xfc\x23\x92\x5c\x33\xc6\x67\x67\xe6\x95\xe2\xa3\x2f\x29\x4e\x29\x18\xcb\x8b\x97\xc5\x61\x95\x1a\xbd\xb6\xef\x49\xf5\xf9\xd0\xbf\x2c\x0b\xe6\xfd\xed\xa6\x8e\x7d\x7a\xb7\x8d\xb4\xe9\xc4\x7d\x86\xdf\xf2\xe1\xbf\x0f\x1d\x55\x3d\x09\x65\xdc\x76\xcf\xcf\xe2\xb4\x99\x53\x1e\x6e\xd7\xa6\x55\x71\x49\xb1\x6d\xe6\xa2\x05\x63\xfb\x4c\x72\x30\xe6\x89\xd4\x16\x9c\xce\x6e\x41\x53\x63\xb1\x6b\x2c\x31\x79\x81\x63\xee\xab\xe2\x52\x62\xd7\x25\xa5\x21\x17\x07\xa7\x5f\x83\x8c\xba\x8b\xdd\x92\xf1\x53\x81\x5e\x57\x77\x97\x3a\x86\xed\x8f\xed\xeb\x34\x50\x4a\x4c\x7f\xd9\xce\xf9\x7c\x7e\xbb\x3f\x3d\xc3\x67\x17\xc5\x80\xc1\x35\x50\x31\x73\x06\x3d\xee\x48\x29\xa8\x3c\xd2\x38\xeb\xb3\x15\xd2\x7c\x4d\x79\xd9\x5a\x3e\x1d\x0d\x87\x6a\x6e\x28\x74\x13\xe4\x58\x84\xfa\x6f\x2f\x1e\xe6\x61\x59\x12\x4f\x38\x5c\xb3\x00\xfa\x0c\x96\x16\x25\x6d\x5d\xc7\x5b\x37\x2f\xe8\xa9\xae\xe6\x3e\x6b\xf8\x9b\x7a\x76\xdb\xfd\xcc\x4d\xd7\x0e\x2f\x99\x41\x70\xba\x55\x7d\x91\xad\xc2\x3a\xa6\x08\x0a\xa3\x6e\x8e\xe7\x4d\x0c\x03\x4d\x50\xb2\x03\x96\x95\x48\xbe\x0c\xe2\x21\xe9\x6d\x70\x62\x54\x12\xdf\xd1\x39\x8d\x3d\x9b\x7e\x69\xa2\x36\xe4\x42\xff\xdc\xf8\xfa\x86\x1d\xaf\xbd\xb1\x87\x99\xcd\x3e\xf7\x27\xcf\xfd\xf9\x27\x8f\x8e\x3e\xbf\x73\xc7\xcb\x6b\x09\x0f\xfd\x18\x6e\x65\x7e\x65\xde\xc7\xba\x68\x6b\xad\x0e\x55\xbd\x19\x92\x8c\x31\x27\x68\x1f\xf5\xda\x25\x49\x16\x45\x0e\x13\x0c\x70\xb9\x25\x64\x78\x48\x91\x50\x26\x62\x10\xb6\x45\x0e\x58\xa5\x9e\x08\x5f\x7c\xaa\x8f\x25\xe5\x8e\xe8\xf1\x1c\xa2\x7c\x97\xd0\x13\x27\xc5\x6b\xa5\x11\x92\x73\x7e\x71\xe3\x43\x2d\xdb\x65\xb7\x59\xd9\xee\xa6\xb0\xad\xdb\xda\xfc\xd1\x55\xd7\x47\x8f\xe1\xe7\x08\xdd\x30\xc7\x7b\xa5\x8e\x1b\xa8\xe5\x20\x38\xf0\xbd\xda\xcf\x2d\x01\x36\x70\x53\xd4\x6d\xb5\x58\x18\x2c\xa8\x4c\xf1\x5a\xd0\xf3\xa4\x16\xf4\x30\x6c\x7e\x88\x94\x83\x9e\x4b\xba\x4a\xc9\xe5\xa0\x49\x55\x0c\x25\x91\x58\x41\x68\x84\xd4\xfc\x39\x7e\xf4\xdc\x1f\xed\xb9\x2a\xe3\xf8\x17\xf8\xca\x30\x72\x61\xd7\xf5\x7d\x3b\x36\x94\xaf\x21\x7a\xeb\x19\xac\x03\x5c\xc0\x3a\x80\x19\x6b\x4a\x05\x51\xab\x4c\xf3\x1a\x3d\x5e\xa3\xf8\xad\x62\xc4\xe2\xfe\x20\x72\x7e\xab\xa0\xef\x9a\x08\x17\xc4\x4a\xfa\x93\x98\x1c\xe1\x71\x17\x4e\x1f\x3e\x70\xfc\xc4\xa1\x23\xef\x9c\xef\x3e\x74\x48\xbf\xf5\xc3\xfa\xb1\x8e\x23\x1f\x7f\xf2\xfc\x0b\x1f\x9c\x7c\x65\xde\xac\x5b\xe7\x5e\xbe\xad\x91\x7c\x1e\x1c\x6d\x66\x16\x45\xa3\xcd\x6a\xb5\x1b\x19\xde\xc8\x03\x0e\xab\x7c\xd8\xb2\x77\xd8\x0d\x8c\xe1\x62\x95\x0d\x4b\xc7\x8b\x55\x92\x68\x16\x78\xe6\xaf\x05\x74\xf2\x37\xad\x78\x06\xa2\x92\x08\x74\xc1\x48\xec\x87\x7b\x20\x50\x2f\x41\xac\xe0\x9d\xc3\x3f\xfc\x88\x2f\x82\xba\x1a\x4b\x65\x38\x2d\x57\x7d\xa0\x07\x15\xd0\xb1\x1f\x89\x8d\x4f\xc2\x59\x4f\x73\xdd\xe4\x3c\xc3\x0f\xea\x8b\xd8\xd6\x0f\x0b\x97\xbe\x07\x76\xc1\x70\x11\xba\x1b\x9e\x03\x99\x51\x19\x31\x76\x2f\x62\x16\x39\xa0\x03\x8c\x01\xb0\x02\x3f\x60\x1f\x35\xaa\xc4\x3e\xaa\xa4\x04\x94\xe3\x3f\x04\x06\x29\xb5\x7e\x5e\x87\xf1\x92\x06\xe3\x33\x02\xe3\x02\x8c\x36\xd4\x83\x60\x54\x62\x44\x2f\x23\x16\xc0\x82\x46\x10\x30\x00\xfa\xbc\x99\xe6\x8b\x55\xe2\xe7\x7f\x54\xdf\xd4\x9e\x2f\xd1\x70\xe8\x84\x71\x68\x11\xf5\x23\xa6\x90\xe0\x50\x08\xa5\x42\x58\x08\xeb\x9b\xc3\x27\x9a\xc3\xe6\x60\x06\x85\x54\xa2\x01\x8b\xe3\x43\xe3\xcf\x5f\xb3\xf7\xe2\xbb\x4e\x6a\x86\x86\x47\x5b\x59\xb5\xa2\x21\xbd\x64\x08\xf0\x90\xf0\x40\x4f\x5a\x5a\x70\x73\x55\x9a\x38\xc0\x01\x41\x72\xb5\xd0\x8e\xbf\xa8\x16\x8a\xfb\x0d\xe8\xd6\x17\xe1\x7d\xc7\x42\xaf\xb4\x6d\x69\xc8\xa6\xe9\x73\xb1\xd8\x3d\x96\xff\xc4\x78\x5a\xd8\x72\xc8\xba\x7b\x38\x68\xe6\x27\x8e\xd5\x4b\x85\x60\x5a\x50\xfd\xee\xab\xef\xd4\x1f\x99\x43\xea\x57\x63\xb4\x4a\xa1\xba\x27\xbb\xc5\x2a\x85\x8e\xff\xfb\x14\xbb\x8a\x38\x44\x34\xbf\x0b\x7b\x82\x7f\x5a\x0e\x83\x1c\xac\xb6\x0b\xe0\xe6\xeb\x7f\x03\x3f\x01\x57\x3d\x23\x72\x61\xe6\xf0\xf5\xc7\xea\x25\x07\x07\x72\x61\x41\x09\xc0\xff\xc6\xd7\x3f\x13\x5f\x3f\x07\x8c\x02\x3f\x03\x47\xd4\x4c\x1f\x18\x27\xca\x89\xd5\x20\xb1\x7e\x47\x6c\x3d\xb3\x1c\xff\x42\x5b\x2f\xe1\xf5\xc0\x25\xfe\x8f\xf5\x64\xd8\xcc\xe5\x38\x7c\xe0\xcd\x69\x72\xfd\xe2\x38\x3e\xa4\xc4\xfe\x1b\xe0\x89\x5a\x11\x79\x00\x31\xc0\x61\xd7\x9e\x20\x8f\xa4\x3c\xb3\x26\xfe\x19\x1b\xb0\x5d\x73\x37\xb8\xe9\x59\xc4\xc8\xd4\x2b\xe2\x4e\xeb\xb9\x4f\x86\x8b\x65\xa8\xfd\x55\x92\x7b\xb6\x96\x61\xa6\xfe\x57\x52\xca\x83\x09\x95\x89\x61\x8e\xa9\xa7\x00\xeb\x03\xf8\x5f\xfc\xa3\x56\x17\xf4\x32\xe5\xb3\x4e\x70\x5b\xb4\xbb\xc1\x62\x71\x8a\x0e\x68\x67\x18\x84\xec\xa2\x89\xb7\xf1\x6e\x97\x60\x67\xed\xb5\x8a\x03\xd6\x2a\x06\x73\xad\x52\x6e\x80\xe5\x86\x01\x86\x97\x0d\xef\x19\x58\xbf\x01\x22\xd1\x00\xad\x9c\x03\x1b\x55\x22\x8b\x44\x4b\xad\x22\x32\x88\x26\xb3\x6b\x72\xb2\xac\x50\x2f\xe1\x98\x59\x50\x90\x5c\x6a\x25\x27\xc5\x4c\x48\xf1\x50\xbc\x96\x23\x64\xcf\x16\x50\x84\x99\xd8\x50\xa7\x5e\x85\xb7\xa1\x1c\xf5\x5d\xd8\x4c\xfd\x04\x8e\x6c\xd8\xd1\xbe\x55\xed\x3b\xf0\x6e\xf5\x0e\xae\xdb\x3b\xea\xa6\x63\xea\x82\x77\xd8\xc5\xc7\xd4\x07\xc9\xfe\x54\xa8\x37\x93\x3a\x1c\xbc\x3f\x61\xba\xa7\x0b\x60\x2d\x7e\x2d\xf3\x73\xd0\x11\x70\x9b\x79\xba\xfd\x74\x1f\x69\x7d\x0a\xa5\x85\x7c\x9d\x76\x9e\xc7\x67\xeb\xaa\x87\x16\x2e\x0c\x0f\x5f\x7f\xb0\xde\x2a\x01\x53\x12\xed\x34\x5e\x3f\x07\x54\x69\xb4\x40\x1f\xe8\x61\x11\x13\xab\x93\xe0\xef\x88\xad\xd7\x69\x07\xc3\xb7\x52\xf8\xe7\xea\x65\x4b\x13\xf0\x17\xc7\xe1\x4f\xc2\x67\xf0\x0d\xf0\x3d\xc7\x10\xf8\x0c\x7e\xe2\x8f\x7a\xc9\xa6\x3d\xa1\x51\x03\x7e\x86\xd6\x4d\x50\x9c\x5a\xe8\xef\xb0\x37\xf9\x1d\x9e\x24\xef\x00\x93\x3e\xa3\xf1\xfa\x39\x60\x42\xd2\x3b\x4c\xc3\xef\x00\x53\xde\x41\x5b\xbf\x23\xb6\x3e\x41\xff\xf4\x25\x00\x7e\x83\xa6\xd6\x2f\x8e\xc3\x8f\xd3\xb3\xfe\x12\x00\xbf\x01\x4c\xa6\x67\x4c\x73\x36\xfc\xcc\x2a\x32\x83\x10\x6b\x8f\x03\xa3\x05\x0e\xab\xec\x76\x1b\x58\x2b\xb6\x60\x7c\x7e\x17\x2f\xf0\x35\x8a\x4c\x2b\x17\x25\x24\x08\xac\xd1\x68\xaf\x56\x8c\x88\x75\x57\x37\x51\xf0\x15\x49\xb1\xb4\x63\x6e\x3b\x5a\xc1\x94\x8d\x65\x5f\xa2\x8a\xc9\x95\x4d\x2a\x99\x56\x69\x95\x4c\xcb\x96\x25\xd5\x32\xbd\xf7\x5e\xbc\x9a\x89\x29\xfe\x9c\x69\xab\x15\x34\xa9\x7b\x3e\x57\xf7\x91\xf7\xa3\xb5\x05\x74\x3f\xda\xa4\xde\x6f\x68\x23\xfb\xe1\xc9\xe6\x2c\x29\xfb\x41\xeb\x03\xe8\x7e\x17\xe9\xe7\xb3\x93\x9e\x0f\xe3\xa6\xfc\x69\x73\xbd\xc7\xcf\x27\xf3\xa7\xc6\xeb\xe7\x80\x5a\x9d\xdf\x90\x07\x6e\x71\xfb\x78\xd0\x04\xfc\x1d\xb1\xf5\x49\xfc\xc9\x43\xf8\x4d\xd0\xfd\x3f\xd6\x27\xf8\x13\x81\x0f\x32\x0a\x9a\x5c\xbf\x38\x8e\xcf\x24\xcc\x6b\x74\xfe\xe4\x26\xfc\x09\xf9\xbd\x7c\x0a\x7f\x22\xf5\x35\x60\x3b\x5b\xc7\xee\xc4\xb2\x2a\x37\x2a\x33\xbc\x89\xc5\x12\xdd\x60\xb1\x92\x42\xda\x57\x20\x82\xc0\x57\x38\x2a\xd6\xb4\xa4\x8c\x88\x07\x87\x11\x96\x1a\x21\xb6\x67\x04\x23\xac\x83\xe3\xd4\x2d\x9b\xe1\x18\x38\x66\xb3\xba\x85\x7e\x53\x37\xc2\xee\xf8\xd7\x63\x36\xaa\x4f\x92\xbf\x6f\x56\x9f\xdc\x02\x6b\xd5\xf5\x18\x8f\x56\xd7\x3f\x62\x37\x72\xb3\x81\x03\x04\x40\x16\xa8\x8e\x96\xb8\x3d\xe9\x19\x6c\xd0\x29\x8b\x9c\x81\x05\x41\xc1\xe4\xb4\x03\x13\xc8\xce\xf1\xa4\xbb\x33\xd8\x90\xcf\x1a\xaa\x56\x38\x83\x2c\xb2\x56\x24\x49\x56\x16\xf9\xaa\x15\xac\xdf\xd3\x8c\x79\x2d\xf2\x4c\xda\xf5\x68\x96\x6c\x52\xb8\x28\xd1\xf3\x4a\x02\x21\xcd\x83\x4a\x4a\x12\x34\xcf\x2a\x2c\xce\x83\x44\x9a\xe5\x3a\x3d\x24\x80\xae\x55\x70\x7c\xb2\x6c\xd2\xac\xbb\x6f\x21\x75\x09\x1f\x2e\x9d\x34\x6b\xc9\x64\xf5\x23\x9b\x3a\xb1\xf3\xec\xf9\x0b\x54\x9f\x0d\x3e\xd6\x71\xf6\xcf\x5a\x39\xc7\xdc\x35\x7d\xb0\x15\x9b\x47\x8a\x13\x6e\x5d\xd3\x67\xf7\x1e\xf5\x9f\x53\x07\x37\xfc\x6b\xd6\xc5\xf3\x73\x7b\x33\xa1\xc9\x64\xef\x69\x9e\x3b\xa5\x85\x76\x3a\xed\x3c\xa1\xdd\x6d\x99\xde\xed\x87\xea\x1d\x6e\x64\x4b\xa2\x9d\xc6\xeb\xe7\x80\xa1\xfa\x5d\x25\x0f\x8c\x92\x5d\x89\xd5\x20\xb1\x7e\x47\x6c\x7d\xd2\xdd\x76\x10\x5a\xf6\xca\x4d\xae\x5f\x1c\x87\x9f\x74\xb7\x65\x7a\xb7\xdd\x4e\xed\x89\x24\x59\x45\x73\xb0\x29\x4e\x1d\x75\x9c\xc6\xeb\x9f\x61\xc4\x9f\x31\xd5\x68\x61\x0d\x89\xcf\xd0\xeb\x32\x56\xd2\xba\x0c\x37\x68\x1b\x0d\x3a\x4c\x3c\x4f\x5b\x49\x78\xbc\x9c\xa3\x56\x31\xc9\xb5\x0a\x69\x89\xc3\xeb\xd5\x2c\x7a\x27\xb3\xd4\x0c\xd2\x44\x35\x8b\x2b\x52\x94\x54\xcf\xb2\xf2\x8e\xef\x37\x7e\x42\x0a\xa5\xde\xfd\x13\x3a\xd5\x4f\xee\xbd\x7d\xe7\xb3\xb7\xde\xcb\x1c\xbc\xf3\xd8\xf4\xeb\x80\xeb\x76\xe1\xcb\xe3\xe3\x6f\x55\x7b\xce\xc3\xf4\xbb\x98\xe4\xee\x72\xc7\xf1\x0d\xef\x19\xcd\xe5\xd2\x5b\xda\x3d\x61\x7b\x38\xc3\x02\xb0\x42\x94\x51\x14\xb1\xb4\xf4\xa0\x6c\x94\xed\x1f\xa4\x64\x83\x0c\x17\x32\x26\xd2\x66\xca\x53\x88\x27\xa9\xad\x81\xae\x16\xe7\x95\xc4\x53\x17\x88\x86\x1c\xaf\x9b\xa6\x69\x17\x39\xd4\xf4\xb3\xb1\x24\x8b\xc1\xcd\xae\x7f\xfb\xc8\x83\xb7\x15\x2d\x2f\xac\xec\xdd\x77\xd4\x8e\xd2\xb2\x4e\x45\xa3\x86\x4f\x98\xa2\x7e\x0b\xae\x5f\x39\x79\x29\x54\xd4\xa1\x28\xd4\x6c\xd1\x76\xd8\xee\xc9\x9d\x05\x27\x3d\x39\xdd\xca\x8a\x95\x4e\x53\xd7\xb5\x1d\x5d\xd4\xb6\xb2\x65\x97\xfe\x8b\x56\x5f\x33\xa3\xcb\x3f\xfc\x54\xbf\xa1\xed\x90\xae\x6d\x5b\x36\x73\xfa\x5a\x8e\xbe\x83\x9e\x05\xcd\x49\xe6\x9e\xc5\x67\xd1\x15\x9f\x05\x0f\x6e\xc6\x9a\x3e\xe6\x44\x45\x76\xc2\x89\xea\xea\x23\x6d\x91\x3f\xe5\xbc\x1b\xaf\x9f\xd3\x0f\x50\x4e\x41\x1e\x28\x2b\x2a\x49\xac\x8e\xaf\x3d\x18\x5b\xcb\x2c\xbf\x44\x61\x47\x28\xec\x0f\xea\xdb\x15\x35\x09\xfb\x48\x7c\xfd\xa6\xdf\x93\x70\xf9\xa2\xbe\x43\x8f\x26\xd7\x6f\x8e\xe3\x32\xe9\x0a\xc0\x92\x11\x91\x07\x10\x7e\xe2\xa3\xfa\xb6\xc5\xda\x13\x49\xb4\x47\x9f\xe1\xcd\xf1\xcf\xd8\xf0\xbb\xf6\x4c\x89\xf6\xcc\x17\x71\xac\xe2\xbc\x0b\x01\x27\x7e\xe6\x30\xdb\x1f\x34\x07\x25\xa0\x13\x58\x1e\xed\x91\x91\x99\x59\xe0\xcc\xb1\x15\xb5\x07\xc0\x5b\x24\x18\x0c\x1d\x9a\x37\x2f\x72\xa2\xce\xe5\x82\xd0\xaa\x08\xb4\x07\x95\x8a\xb7\x7d\x75\xfb\xe9\xed\x19\x31\x03\xeb\xca\x19\xed\x33\xda\x67\xd9\xdb\x06\xb3\x82\x95\x4a\x38\x27\x4b\x62\x5b\xd9\x5b\x55\x2a\x36\xb3\xdd\x4d\x55\x20\xcd\x34\x8b\x37\x96\xd3\xe3\x4e\xf6\x78\xdc\x29\x51\x0c\xa5\x0b\xaf\xb8\x52\xa4\x2b\xcd\x5a\x5d\x79\x9e\x5e\x84\x9e\xc8\xf8\xce\x93\x31\x43\x6a\x4b\xb2\xa1\x5c\x1c\x5d\x49\x3d\xa7\x30\x8b\xf8\x48\x5a\x41\xe6\x05\xa5\x6f\xc7\xa8\xf4\x6c\xee\xd6\xdb\x6e\x5d\x9a\x55\xb4\x79\xdc\xed\xcb\x9f\x7a\xe6\xa1\x8e\xed\xda\x44\x0c\xa7\xf2\xa0\x73\x5f\x8f\x21\x5b\x9f\xd9\x71\xad\x65\xb3\x70\xff\xe9\x75\xa3\x7a\x31\x73\xf2\x7b\xb6\x60\x60\x4b\x43\x37\x78\x96\x79\x64\x77\xdf\x2e\x2d\xef\x5b\x31\x6d\xc1\x9c\x59\xbb\x1f\xd9\x75\x08\xb1\xa5\xa3\xa6\xf4\xee\x65\x87\xed\xee\xbd\x57\x3d\xa7\x7e\x51\xf0\x7c\xb4\xd7\xae\xe9\x6d\x11\x1a\xc5\x58\xba\xcc\x1e\xb8\xf4\x6e\xba\xef\xd3\xb0\xfe\x35\x84\xed\x8f\xf7\xbd\xbb\xae\x7f\x55\x6a\xfa\x97\x9c\xee\x43\xae\x84\xfe\x45\x73\x86\x29\x7d\xf5\xd4\xe8\x71\x3f\xa5\x81\x34\x4a\x03\x4f\xd7\xa7\x87\x50\xaa\x3e\xd5\x78\xfd\x9c\xe9\x1a\x3d\x92\x07\xe6\xa4\x65\xa2\x64\x5d\x4a\x5b\x7b\x30\xb6\x96\x59\x2e\x68\x6b\xd3\xf1\x5a\x21\x3b\xad\x89\xb5\x9b\xe3\x70\x27\x61\x43\x93\x4a\xb8\x34\x42\x28\x86\x50\x06\x4a\xd5\xb9\xb4\x1c\x47\x82\xc7\x4f\x1a\xde\x2f\x11\xbc\xa1\xc9\x4e\xb8\xf2\x13\xf5\x66\x1b\x4a\xd5\x89\x1a\xaf\x9f\x33\x91\xe2\x42\x1f\x18\x65\xb2\xa2\x64\xfd\x4c\x5b\x7b\x30\xb6\x96\x59\x6e\xa2\xb0\xcd\x14\xf6\xef\xf5\x92\xa9\x49\xd8\x9b\xe3\xb0\x27\x35\x03\x1a\x47\xc6\xc0\x19\xe8\xb1\x59\x50\xb2\xb6\xc5\x80\xc1\xf8\x5d\xa7\x73\x9f\x03\x3f\xc8\x05\x93\xa2\x1d\x80\x57\x72\xb0\xb2\xdf\x25\x1b\xfd\x8c\x2d\x10\x60\x42\x46\x23\x13\xce\x93\x80\xc3\xcb\xda\x7d\x3e\x97\x25\xbd\x42\x01\x16\xc9\x12\xb5\x54\x58\x58\x23\xb2\xd8\x2d\xf6\x6c\x17\xe0\xb3\x2b\x14\xde\x1d\x73\x7d\x69\x2a\xbd\x66\x08\xca\x29\x59\xa4\x72\x19\x0d\x39\x51\xe1\x09\xec\x2e\x22\x3f\x41\x49\x31\x88\x14\x79\xc2\x54\x8e\x92\x44\xb3\x52\x8f\x9e\x82\x4c\x1c\x44\xa8\x18\x76\x50\xaf\x5c\x07\xbf\x61\x53\xdc\x71\xad\x7f\xbb\xb2\xc1\x17\xfa\x1d\x19\xbe\x13\xe6\x8e\x89\xfe\x31\xe8\xa9\x49\xf3\xee\x98\xfe\xd5\xa2\x19\xec\x7f\xd4\x57\xd4\xc9\xac\xfa\x8b\xfa\x2f\x68\xb8\x70\x09\xf2\xce\xb9\xb5\x75\x1b\x06\xf4\xb8\xa5\x75\xab\xa9\xeb\xaf\x6d\xdc\xf2\xc8\x63\x9b\xd5\x13\x0f\xc7\x74\xb5\x0a\xca\x63\x2a\x35\x1e\x63\xd2\xf6\xdd\x87\x37\x93\xcd\x6a\x65\xf5\x24\xed\x3b\xcd\x8d\xa4\x67\x34\x50\x3b\xd3\x23\x94\x16\x3d\x94\x16\xf7\xd4\x7b\x03\x8d\xf4\xa2\xc6\xeb\xe7\x8c\xd7\xe8\x8b\x3c\x30\xa5\x91\x4e\xa7\xad\x3d\x18\x5b\x4b\xe5\x2c\x59\xeb\xc5\x6b\x41\x9a\xa7\x89\xb5\x47\xe2\x6b\x37\x81\x04\x5c\x90\xd9\xa2\x89\xb5\x9b\xe3\x38\x10\x79\x4c\xe9\xd6\x43\xe8\x16\x04\x7c\x29\x9a\x19\xc2\x92\x77\x27\x3b\x11\xeb\x65\x24\x8e\x46\x7a\xcc\x65\x21\xb3\x19\x18\x0c\x3c\xc7\x73\x16\xab\xc1\xb8\x47\x61\x0d\x7b\x15\xe2\x36\x86\x60\x8f\xc2\x41\xbd\xcf\x5c\x41\x41\xc1\x0d\x3d\xe6\x4a\x22\xd4\x2d\x4c\xff\x7b\xe9\x52\xc3\x4a\x16\x35\x2c\xbb\x84\x5e\xfd\xfe\x7b\x75\xde\xd7\x5f\xab\x33\xbf\xff\x9e\xf2\x52\x2d\xdf\xb4\x82\xea\x67\xd9\x40\x89\x16\xb9\x33\x3c\xe9\x37\xe8\x67\x39\xb9\x71\xfd\xac\x42\xd3\xcf\x90\x64\x95\x90\x0f\xd3\x18\xcd\x0b\xa4\xba\xd9\xff\xd2\xcc\xf4\xd8\x76\x09\xa9\xc0\xa0\x9a\x19\x97\xaa\x99\xf1\x34\x5f\xf5\xd8\xe2\x21\x63\xaa\x27\x42\x9b\x7a\x62\xe1\x80\xda\x61\x75\xea\x67\x66\xf5\xf6\xd2\xa9\x0b\x67\xa8\xed\x4c\xf0\xee\x92\xe9\x0b\xa7\x6a\xe9\xab\x35\x35\xfd\x27\xaf\xfd\x81\x24\xb0\x0e\x53\xfa\xd7\xde\xf7\xeb\xa0\x5e\x6a\xaf\x61\x7b\x5f\x1f\x1c\x85\xcf\xf5\xdb\x47\xe8\x8a\xe4\xe3\xd1\xb3\x1f\xae\xd1\xca\x93\xf4\x8e\x7a\xe8\x1d\xdd\x80\x69\xc5\x95\x6a\x03\x34\x5e\x3f\x67\x84\x46\x87\xe4\x81\x3a\x8f\x3f\xb1\x3a\xbe\xf6\x60\x6c\x6d\x8c\x56\x20\xa6\x15\xc8\xa5\x79\x9a\x58\xbb\x39\x0e\x57\x3f\x7f\x86\x00\x66\x20\x17\xf0\x69\xab\xe3\x7c\x8b\xe6\x7a\x51\x3c\x46\x6a\x78\x4c\xd6\x60\xbb\x31\xec\x5b\xdd\x3e\x93\x1c\xc7\x9a\x01\x6b\xf1\xda\x09\x58\x07\x72\x82\x0c\x52\x7f\xe2\x87\x0e\x87\xd3\x65\x74\x1a\x33\x43\x8e\x80\x25\xad\x42\x11\x2d\x6e\xde\x83\x55\x1f\x9e\x84\x9a\x9a\xac\x3f\xa1\xba\x98\x83\x94\xf2\xb4\x4d\x4a\xd3\x25\xee\x60\x52\xcc\xab\xc7\x3e\xd6\x42\x1f\xcb\x4e\x7f\xff\xc0\xbb\x1f\xbc\x34\xf6\x89\x96\x3c\xaf\x7e\xcb\xbc\x74\x6a\xfc\xad\xb7\x8e\x9d\x3a\x9e\x3b\xae\x8e\xdb\xfe\x96\xfa\x99\xfa\xbb\xfa\xab\xfa\xd1\xf8\xaa\xf4\xc7\xd5\x1a\xf4\x0e\x9c\xfc\xfa\xbe\xbd\x47\x5f\x02\x89\xf7\xd9\x1c\x7f\x9f\x49\x9c\xfe\xfe\x6e\xfa\xfe\x7e\xaf\xf6\x46\xf1\xf7\xd7\xfc\x26\x75\x71\xbf\xc9\x2a\xc0\x40\x33\xbd\x5d\x76\xa2\xbe\x8a\x52\x23\xdf\x8c\xa6\x73\x54\xc5\xf5\x87\x55\x7f\x50\x9e\x50\x4c\x79\xc2\x97\xf5\x45\x91\x46\x3a\x4a\x63\xdf\xcf\xba\xb8\x2d\x46\x7d\x3f\xb2\xaf\x49\xf8\x09\x9d\x69\xdd\xc5\x24\x1d\xe8\x74\x7d\x49\xc7\xc6\xf0\xd5\x5a\x52\x5f\x19\x87\xbf\x11\x3e\x85\xef\xb1\x14\x35\x31\x92\x0b\x96\xbb\x5c\x90\xb0\xfa\x51\x9a\x9f\x70\x12\xde\x9b\xf5\x54\x06\x77\xd5\xd7\xe2\xc3\x06\xb6\xe7\x01\x73\x7d\x57\x7d\x59\x99\x9f\x42\x26\xbe\x12\xd2\xb3\x84\xea\xe7\x61\x5d\x3f\xbf\x47\xd7\xcf\xb1\x79\x07\x17\xbb\x7d\xba\xc3\x24\x86\x03\xad\x9b\xa2\x34\xd4\x5d\xa3\xa1\xba\x04\x4f\x9d\xe5\x0b\xea\xe2\x5d\xa3\x4f\x0d\xf6\x8e\x18\x6c\x4c\xcb\x4e\x1d\x36\xb6\x4d\xa1\x21\xe8\x6e\x12\xf6\xc1\x18\xec\x38\xed\xfb\x09\xed\x67\xf8\x9a\x80\x3d\x32\x0e\x7b\x3d\x48\x07\xeb\xe3\x78\xcb\x6e\x6f\x93\xb0\x5f\x8b\xc3\x5e\xef\x4c\xe0\xed\xf3\x05\xfe\x2b\xde\x2b\x80\x3d\x69\x4f\x38\x6f\xfa\xff\xc0\x7b\xc5\xb5\x04\x6c\x18\x08\xa5\xc0\xa6\x3d\x58\x28\xec\x3c\x0d\xf6\xf5\x33\x9a\x3f\xc0\x4e\xfd\x01\xc7\xea\x1d\x3e\x36\x41\x25\x08\x04\x31\xec\xf7\x68\xbe\x42\x0e\xd6\x49\xfb\x44\xc3\xb9\x8e\xfc\xfc\x16\xe9\x26\x0f\x92\x65\x87\xc9\x51\xd0\xa2\x79\x34\x0f\xc8\xb4\x24\x4c\xfc\xab\x92\xb0\x72\xff\x89\xd4\x46\x07\x34\x0c\x95\x28\x0d\x2b\xd1\x32\xd1\x63\x95\x61\x89\x64\xf4\xce\x10\x96\x38\x22\x2e\xc4\x2c\x26\x05\x62\x77\x0d\x7e\xf8\xc0\xc1\x4d\x7f\x1f\xca\xe0\xab\x62\x50\x2f\x36\xef\xd5\xaa\x67\x65\x45\x8f\x96\x7d\x0a\xe0\xf0\xb4\x6f\xe7\x6b\x55\x62\xc5\x57\xb1\x81\xdf\xea\xe5\x78\x8d\xd8\x9c\xad\x83\x5f\xdb\xb7\xe3\xcd\x91\x4f\x33\x2f\x86\xe0\x4d\xb9\xea\x6b\x64\x0f\x74\x7f\x8f\xcc\x83\x07\xa9\xcd\x47\xe4\xc4\xf3\xf8\x1d\x33\xf0\x1b\xce\x8a\x16\xf9\x33\x45\x83\x37\x13\x05\xc3\x62\x10\xa6\x89\x69\x05\x2d\xa0\xcf\xef\xab\x54\xd2\xfd\x7e\x39\x08\x64\xac\x7b\xb8\x81\x2c\xc9\x99\xf2\x3e\xf9\x15\xf9\x94\xcc\x4b\x88\xfa\x35\x6d\x46\x4b\x4f\x59\xb2\xe4\x57\x28\x06\x8b\x9b\x8d\x6f\x40\x01\xf5\x0a\x69\x31\xba\x46\x2d\x10\x49\x3e\x11\xb5\xcd\xb2\x49\x72\x74\xea\x6e\x90\x42\x39\x2d\x95\xc8\x15\x81\x09\x05\x85\x7d\x7e\xa9\x41\xbd\xa2\x55\xcb\x1d\x3c\x7e\xe2\x65\xad\xa8\xe0\x3c\xf4\x43\xdf\x52\xb5\x6e\xf2\xc4\x09\xe3\xde\x1e\x3f\x83\xdd\x78\xad\x62\xdc\x0a\x6d\x3f\x42\x2a\xe4\x61\xa0\x66\xf4\xfb\xa3\x76\x2c\x5f\x7e\xed\xc4\xf6\x03\x7b\x0f\xa8\x5b\x8f\xc4\x7d\x7d\x75\x71\xdf\xe0\x2a\x20\x63\x5e\x84\xa5\x88\x8d\xda\xf6\xbf\xd5\x5b\xac\xe0\x46\x1d\xb5\x2a\xae\xcf\xae\x62\x34\xbd\x20\x83\xb0\xba\xb4\x74\x74\xa3\x1f\x31\xe1\x77\x5c\x17\xf3\x3b\x5a\x74\xbf\xa3\xe8\x6e\x02\x76\x42\x57\x5e\xc7\x26\xf4\x6a\x94\x99\xd7\x04\xec\x91\x71\xd8\xeb\x31\xec\xf5\xc9\xb0\x2d\xb6\x26\x60\x1f\x8b\xc3\x5e\xcf\xf0\x71\xd8\x4c\x5a\x46\x2a\x6c\xcc\xb3\x16\x50\xfe\x96\xaf\xf3\xac\x3e\x1a\xcf\x82\x98\x67\x39\x1c\x26\x93\xce\xb3\xc6\xe1\x75\xb7\x50\xde\xa6\xc1\xdc\xd8\x59\xe3\x6c\xea\x2b\xf5\x39\x39\x0e\x87\x66\x60\x34\xb1\x0f\x2b\x30\xb7\x4c\xda\x87\x2b\xf5\x36\xe7\x7f\xdd\x87\x15\x7f\x24\xd9\x23\x7f\xd4\x67\xe4\x36\xb2\x47\x68\x5f\x1f\x0a\xbf\x79\x23\xff\x49\x10\x7f\x80\x29\x14\x68\xc4\xef\x69\xad\x1f\x85\xdf\x5b\xe3\x6f\xbf\x51\xf8\xad\x29\xfc\x9f\xea\x4b\x0a\xe5\xb4\xff\x0a\x7f\x1d\xe6\x07\x1a\xfc\x00\x86\x6f\x4d\xcf\xfd\x1f\xf0\xd7\x69\xf0\x0b\x29\xfc\xff\xd4\x17\x95\x35\x09\x7f\x64\x1c\xfe\x7a\xac\x8d\xad\x8f\xc3\x77\x06\xd2\x9a\x84\xff\x5a\x1c\xfe\xfa\x64\xf8\x3f\xd5\x17\xb6\x69\x0c\x5f\xed\x40\xfa\x1e\xe9\xf0\x79\xc3\x39\xcd\x0a\x64\x03\xe9\x3a\xe0\x18\x4c\x3e\x3d\x06\xd3\xf0\xdd\x75\x0a\xb3\x0d\x85\xa9\xd6\x17\x35\xde\x13\xda\xa3\x88\xee\x49\x41\xd3\xfe\x68\xd6\x94\xe2\x4f\xa2\xf5\x87\xfc\x0e\xda\x9b\xa4\x53\x34\xa4\x57\x20\x7a\xd3\xec\x6c\x28\x2b\x2d\xe3\xbe\x2a\x5f\x1a\x27\xa3\x26\x6b\x11\xb5\xca\x64\xcf\xff\x2c\x47\x74\x65\xe7\x65\x0b\xd9\x25\xb9\x91\x1b\x0b\x13\x99\xd2\x27\xde\x65\x3f\xd8\x02\x99\x73\x37\x94\x28\x76\x53\xff\x33\x75\x22\xd3\x2f\xb8\x6c\x59\xf0\x4f\x82\x27\x89\x0b\xbe\xc3\x75\xc3\xba\xb2\x07\x0c\x8b\x06\x3c\x66\x84\x0c\x02\xeb\xb4\x00\x20\x89\x0e\xd6\xe1\xf5\x79\x98\x31\x8a\x5b\xe6\x05\xfe\x30\x34\x47\x6d\x8a\x68\x16\x48\x7b\x69\xab\x31\xd1\x81\x89\xa4\x26\xea\x9d\xec\xe2\x29\xa1\x7a\x96\x92\xa6\x8c\x69\x5d\x98\x48\xee\x2a\x4d\x95\x74\x11\x2f\x38\x51\xe3\xb5\xbe\x4c\x2b\x56\x68\x9d\x99\x96\x2f\x57\x3f\x55\x1f\x21\xfd\x99\xd0\x8f\xdb\xf7\xe3\x7f\xb6\x5f\x73\xa2\xa2\x23\x47\x34\xdf\xae\x51\xaf\xe7\x4c\x07\xa3\xa3\xc5\x3e\x43\xc0\xab\x6d\x68\xa6\xcb\x69\xb7\x67\x64\x06\x1c\x4e\x47\xa5\xe2\x75\x92\xbd\xc4\xc4\x8a\x48\x78\x7c\x06\x5a\x8c\x38\x27\x72\x12\xb9\x44\x36\x1a\x6f\x6d\x2c\xc1\xb3\x51\xc0\x56\x8e\xe9\x8d\x94\x2b\xdf\xb8\xdd\x3a\xe6\x24\xd3\xb6\x71\x15\xe8\xb2\x65\xd0\x07\x5b\xa8\x1f\x1a\x50\x7b\xba\xd1\x0b\x98\x6e\x74\xa3\xcf\xb1\x1b\x31\xe3\xdd\xb1\x7a\xea\xc4\x26\x62\x19\x9a\xef\x3b\xce\x0f\xae\xd7\xbb\x42\xe0\x46\x5b\xfc\x48\xdc\x16\xdf\x04\x93\xec\xfc\xcb\xf5\x8e\x0c\xd4\x54\xec\xa3\x2e\x0e\x3f\xae\x5f\x52\xa6\x0e\x31\x47\x6f\xca\x76\xaf\x8a\xc3\x5f\x65\xa0\xf0\x2d\x14\xfe\xd7\xf5\x26\x33\x6f\xfc\xaf\xb1\x98\x46\x7c\xfd\x3a\xe1\xeb\xff\xcd\x97\xb0\xce\x99\xf0\x3b\x40\xab\x33\xc5\xef\xb0\x09\xf3\xd4\x36\x94\xf7\xb6\xd0\x78\xaa\x95\xde\x55\x8b\x18\xd0\x41\x12\x78\x78\xcd\xed\xdc\x71\xbc\xa6\xaf\xb6\xa6\x1d\x59\xc3\xe4\xda\xd3\x50\x7c\x8d\x86\xe3\xc8\x38\x8e\x9a\x7c\x88\xc5\x97\x80\xc5\x96\xbc\x07\xb1\x7a\x51\x5a\xcb\xd1\xb8\x5e\xf4\xc6\xa2\xdc\xff\x9f\x7a\x51\xe6\xa8\x56\x57\xdd\x0b\xf3\xb6\xe5\x74\x56\x88\x13\xdc\x1c\xcd\x21\x55\xc7\x50\x14\x65\xd2\x29\x05\x13\x95\x54\xad\x00\x3b\x62\xcd\xd5\xca\x22\xc3\x5a\x03\x63\x30\xb0\x0e\x86\xf8\x93\x63\x45\x68\x05\x29\xed\xbe\xb5\xde\x62\xf6\x50\x72\xeb\xaf\x6c\xfc\xe9\x52\x2f\x18\x54\xcf\x32\x6f\xed\xde\x6f\x87\x06\x73\x61\x71\xab\x1c\x95\x09\x72\xdd\xfe\x7c\xc1\xf9\xec\x3b\xe1\xba\x21\xa3\xa7\x32\xaf\x7c\x7b\x6d\xbe\xda\x8a\xe4\xe2\xed\xc4\x7b\x97\x46\x6b\x33\x04\x7c\xc3\x03\xa0\x57\x34\xd7\xe7\x96\xdc\x4c\x1a\x8f\x10\xc7\xf8\x3d\x8c\x27\x98\xc6\x7a\x7d\xde\x41\x0a\xe7\x03\x8c\x5b\xb4\xc8\x03\x15\x4b\x80\x16\x9d\x53\x8c\xca\x6f\x08\x6d\xc5\x30\x23\xdd\xf9\x48\x79\x30\x6c\x54\x34\x4c\x7f\xf7\x3a\xe1\x43\xe4\x0f\x33\x22\x51\x3c\x0c\xfd\xe4\x37\x6c\xfb\xd7\xdf\x7b\xef\xcf\x5f\xe3\x05\xc4\x6c\x6b\x5a\x3f\x8c\xcf\xb0\x0e\xef\xdd\x00\x4a\x67\x2d\x75\x1e\x3b\x2f\x29\x2e\xb0\xe7\x86\xb8\xc0\x01\xfc\x6e\x9d\x09\x9d\x19\xbe\xd7\xe4\xda\x04\x8d\xce\x1c\x98\xce\x9e\xf6\xca\x42\xb2\xcf\x62\x05\x96\x09\x9a\x0d\xd3\x2a\x2e\x13\xa8\x84\x7f\xae\xde\x22\xb2\xe6\xb8\xec\xde\x8d\xd7\x3d\x44\x69\xad\x7f\xea\xba\x57\x92\xd6\xc5\x6a\x9d\x69\x4d\x56\xa7\x68\x06\x34\x19\x10\xad\x73\x36\x02\x33\x6b\xb6\x58\x69\xa9\xb3\xc1\x60\xe4\xc4\xa4\x52\xe7\x88\x36\x99\x21\x91\x5f\x46\x7d\x08\xff\xbd\xd0\xf9\xe3\xc1\xea\x9d\x6c\x7b\xd2\x72\x4c\xed\xde\xb0\x98\xe0\x47\xfb\xa9\xf1\xdb\x30\x7e\x85\x9a\xdd\x74\x7d\x33\xf8\x85\xdc\x45\x9e\xde\xc5\x59\xf5\xbc\x11\xb0\x49\xf6\x34\xa5\x73\x2c\x87\x8c\x40\x04\xdd\xa2\x59\x56\x93\x49\xe0\x58\x96\x23\xdd\x36\x39\x4e\xb2\x5b\x16\x8b\x1c\xa5\x7a\xd4\x54\x29\xba\xa6\xbf\x13\x5c\x31\x87\x2f\x94\xcb\x8a\x0a\x1b\x95\xa4\x93\x44\xae\x94\xa2\xf4\x8f\x69\x52\x17\xbe\x0f\xe8\xed\xa3\x03\x69\x66\x17\xc1\x19\xef\x69\x2d\xdd\xfb\x42\x6d\x4f\x4d\xfa\x9e\x9e\x4a\x60\xab\xdd\xf3\x0e\xfa\x3d\x1f\x90\xba\xf7\xdf\xd5\xc7\xbd\x95\xf1\x3d\x88\xc3\x13\x0c\xe7\x60\x94\xdb\x06\x9c\x07\xa0\x01\xc1\xc3\x90\x4b\x00\xd5\x73\x57\x48\x0d\xf7\x7e\x0d\xee\x7b\x64\xfd\xb7\xd8\x7e\xd5\x20\xc3\x17\xe3\x90\x6f\x84\x8b\x79\xc8\x91\x86\xc1\x84\x1b\x2d\xe3\x0d\x31\x34\x63\xfc\xed\xa1\x38\x9e\x78\x1d\xdc\xa2\xad\x1b\x63\xc2\x6f\xa6\xaf\xd3\xfb\x12\x4d\xa1\x31\xa5\x7e\xd1\x3c\x24\x08\xc0\x64\x32\xda\x44\x33\x6f\xe1\x38\xbc\xdd\x56\xab\xc5\x12\x35\x8a\x3d\x59\x0b\x6b\x81\xf8\x58\xaa\x15\x93\x0c\xe3\x33\x84\x68\xfa\xb2\x76\xd9\x8a\xb4\x0c\xfa\x44\x79\xa7\x83\x14\xf3\x7a\x38\x9a\xa5\x20\xe4\x7d\x09\xf3\x7e\x1d\xa9\xee\x61\x26\x5e\x9b\xb9\xb0\x86\x79\x80\xa9\x6f\x38\xb7\xf8\xe0\x7e\x75\xcb\x59\xb8\x33\x7a\x10\x24\xd7\xc6\xdb\xb1\x84\x2f\xe2\x00\x6b\xb0\xb2\xc8\x68\x94\x1d\xc0\x8a\x4c\x2c\x24\x75\x4a\x03\x68\xf7\x5a\xce\x88\xcc\xd0\x0c\x05\x89\xb6\x0a\x00\xa4\x03\x62\x85\x22\xb8\x9a\x2a\x5a\xd1\x1d\xae\xb1\x36\x05\x50\x47\xa7\x84\x20\x94\xab\xb1\xc7\x0f\x06\xa9\x9f\x69\x94\xf1\x8f\x21\x98\x17\x60\xea\x40\xcf\xcd\xdf\xb0\xbd\xe1\xfd\xa3\x47\xe1\xea\x19\xeb\xb7\xc0\x3f\x8e\xc6\xe3\xda\xdb\x62\x71\x6d\x8c\xeb\x02\x4c\xcf\x31\xd9\x75\x97\xcd\xde\x28\xae\xad\xf9\x56\x9f\xd5\x7d\xab\x64\xfd\x4a\x90\xb0\x7a\xef\xf5\x05\x13\xde\x55\x6d\x3d\xa6\xa9\xee\xf4\x4c\xdb\x68\x34\xf5\x6f\x9d\xa6\x3e\xaf\x8f\xc3\x8e\xad\xab\x60\x07\xc4\x7c\xb6\x86\x73\xe7\xf4\x75\x9f\xd5\xc7\x61\x36\x15\x87\x5f\x71\xfd\x9a\x26\x0b\x35\xfb\xe9\x5a\xbd\xe4\xe6\x2c\x8d\xec\xee\x0a\x2a\x0b\x35\x5f\x30\xc9\xec\xc5\xab\x7d\x54\xd6\x5e\xad\x0f\x84\x92\xf1\xd5\xf3\x60\xb6\x72\xdd\x81\x17\x6b\x3a\x3d\xa2\xd9\x81\x60\x30\xdd\xe7\x33\x02\xaf\xd7\x48\x0a\xf7\x8d\x99\x19\xbe\x68\x00\xd9\x59\x27\x3b\x50\x71\x36\xaa\xdc\x4f\xbe\xaf\xf6\xb2\xa4\x04\xf1\x26\xaa\xf8\x69\x7b\x73\xac\x84\x39\xb0\x16\x86\x56\xf6\x1c\x30\x62\x6e\xbc\x96\x7f\xea\xe7\x1b\xb6\x5e\xad\x56\x20\x3c\xc8\x4c\x5e\x73\xf7\x81\xa5\x89\x82\xfe\x1f\x3f\x3c\xde\x50\x89\xce\xe8\x06\x35\x04\x33\xa9\x4f\x5f\x01\xd9\xa0\x4f\xb4\x19\x8b\x90\xc9\x47\xca\xea\x43\xce\x50\x4e\xae\x2f\x2d\xcd\x56\xad\xa4\xb1\x6e\xe4\x94\x81\x50\xa3\x48\x2c\xe9\x6e\x89\x52\xba\x5b\xde\x50\x37\xac\xe5\x4d\x72\x89\x62\x10\xbb\x56\x4e\xef\xa2\xc3\xb9\xdc\x7a\x87\x04\x1f\x94\x18\xc4\x2f\x78\x3c\xef\xb4\x94\x97\x55\x98\xd7\x7d\x64\xf9\x92\xfe\xea\xa7\x2c\xcc\x34\xb3\xc5\x27\xa6\x1f\xd8\xb5\xdf\x39\x77\x79\xd7\xf6\xcd\xe7\x3f\x0e\x67\x6f\x5f\xb8\xf0\xcd\xa9\x0d\x1d\x58\x03\xec\x34\x7f\xc9\xfc\x47\x7f\x52\xaf\xab\x0f\xa8\xbf\xa9\x24\xa3\x6e\x39\x96\x1d\xa4\x6e\x3c\x04\xda\x45\xd3\x43\x1e\x49\x10\x0c\x06\x4f\x10\x65\x67\xf9\xd3\x07\x29\xfe\x80\xe4\x74\x22\xb2\xc3\x16\xd1\x10\xaf\x5a\x4f\x74\x0d\xd4\x15\xf3\xbf\xe8\x8d\xa0\x85\x5c\x3d\x18\xff\xa6\xba\x24\x3c\xb0\x66\x5c\xf7\x48\xef\xe2\xa6\x9a\x25\x5c\x3b\xbd\x76\xbd\xf1\x4d\xb6\x4b\x4d\x3c\xff\xa1\x2e\x9e\x2f\x91\xf0\x19\x7a\x89\xcf\xd0\xed\x69\x32\x2e\x50\x15\xf7\xdf\xc7\xec\x74\x1f\x0d\xc7\x78\x9b\xc8\xf5\x48\xe4\x62\x24\xfc\x85\x34\x17\xc3\x97\xd9\x24\xec\x44\x1c\x61\x5d\x72\x6c\xc0\x1f\xba\x01\xf6\xda\x24\xd8\x9b\x61\x4b\x0c\x3b\x91\xb7\x31\xd7\x93\xc9\x37\xce\x2b\x23\xf0\x9f\x8c\xc3\x27\xcf\x44\x53\x22\x0a\xab\xbc\xa1\x46\xb9\x1e\x0c\x48\xbf\x7e\x95\x7d\x81\xeb\x83\xc9\x29\x1d\x4c\x8f\xde\x1c\x64\xad\x76\xbb\xdb\x61\x16\xdd\x2c\x97\x91\x69\x95\x6a\x95\x72\x2b\x2c\xb7\x0e\xa0\x43\xca\x58\xbf\x15\x22\xd1\x8a\x2d\x35\xab\x15\x18\x8d\x96\x5a\xc5\x88\x04\x5f\xad\x22\x20\xe8\xac\x25\x0d\xd1\xec\xb5\x89\x7e\xbf\x89\xbe\x28\x89\xbe\xbf\x33\x53\x0f\x3e\x24\xe8\x23\x58\x3c\x89\x7c\xb1\xdc\xa2\x52\xbb\x9e\x5a\xcf\x0c\xeb\x7f\xfd\xc7\x8b\x10\x84\x23\x4c\x2b\xf5\x2d\x3a\xc3\xa2\xb6\x61\x40\xbb\x60\xb8\xe5\xc2\xc9\x33\x39\x38\x10\x8e\x84\xa3\x61\x57\x5e\xcf\x1e\x3b\xca\xa3\x97\xf8\xf3\xbf\xff\xf9\x7f\x5a\x1c\x98\xf8\xdd\xea\xd9\xfe\xb4\x06\xaf\x25\x98\x1b\xed\x94\x65\x77\x5b\x82\xd8\x8e\x0d\x06\xed\x05\x05\x01\x5e\x10\x02\xf6\x40\xab\x42\x9e\xb7\x39\x9b\x83\x4a\x45\x6c\x9e\xd1\x9c\x91\x50\xf3\xe6\x36\x67\x7e\x86\x33\xa3\x42\xf1\xba\x9d\x12\xca\xb5\xe5\x56\x28\x16\x93\xad\xa9\xe8\xef\x5f\x0c\x09\xb0\xcb\x89\xd4\x01\xbd\xf1\xb3\x1e\xf6\xcd\x8b\x37\xf0\xf1\xb4\x8d\x64\xda\x5d\xb9\x49\x25\x04\x30\x8b\xc6\x79\xbf\xe8\xdf\x3d\x52\x6c\x7b\x36\xeb\xf1\xc9\xcf\x55\x0e\x3a\xb4\x69\xfb\xce\x27\x5f\x18\x30\x64\x0f\x2c\x6f\x18\xd6\xb3\x7f\xaf\xf2\xf2\x9b\x07\xf6\x86\x63\x96\xf3\xd0\x60\x68\x0b\xcf\x3e\xb4\xed\x26\x12\xd9\x3d\x74\x08\x86\xa0\x1d\x7a\xa0\x6f\xff\xfe\x86\x57\x0b\xda\xbf\x74\xe8\xf9\x17\x5e\x3c\xf2\x0a\xd3\x5c\xbd\x6f\x56\xcc\x87\xf2\x2e\x95\x0b\x25\x3a\x9f\xef\xa9\xc9\x05\x4a\xa3\x16\xb7\x8f\xb5\xa6\xd0\x28\xed\x3d\x41\xe5\xc2\x10\xcd\x3f\xac\x68\x52\xc1\x85\x19\x6d\x0f\x97\xd7\x0c\x52\xfc\x3d\x1d\x48\x7f\x45\x1d\x36\xe6\xf5\x0d\xba\x87\xfa\x40\x7d\x1c\x2e\x59\xf7\x37\xbc\xae\x8c\xfa\x7b\x86\x68\x7a\x86\x7a\x45\xd7\x1b\xd4\xd3\xf5\x31\x98\x71\x5c\x77\xc4\x70\xc5\x32\xe1\x62\x72\xae\xd5\xce\x7a\x6f\x7a\x02\xdb\x38\xae\x07\x63\xb8\x32\x2b\x9c\x54\x26\xb8\x74\x99\xe0\x49\x33\xa7\xde\x3f\xda\x93\x93\xee\x45\x5b\x7d\x2f\xe6\xe9\x32\xb2\x19\x16\x3a\xf7\x35\x6b\xd1\xe8\xbe\xd2\x9e\x18\x74\x2f\x86\x6a\x7b\x31\x54\xdb\x8b\x66\xf8\x03\xaa\x9b\xa5\xc6\xf2\x34\xd8\x3b\x62\xb0\xb1\xce\xcd\xea\x3a\x77\x73\x0c\xdb\x5e\xd8\xac\x49\xd8\x07\x63\xb0\x99\xe5\xa2\x06\xbb\xb9\xbd\xd1\x6a\x1a\x27\xb9\x99\xf4\x12\x8d\xe3\xbd\x00\xf6\xd5\x3c\x31\xae\x56\xb1\x85\x1a\x4c\xbc\x4e\x93\xbd\x43\xf5\x75\x43\xb5\x75\xce\xd4\x75\x8d\x71\x5d\x11\xf7\xc1\x90\x7d\xb0\x16\xb4\xf9\x1f\xb8\xae\xe0\x12\xfb\x20\x24\xaf\xc6\x6b\x3b\xe1\xb3\xbe\x9f\xd2\x44\xa9\x46\x13\xff\xd4\xe5\xff\xfb\xf5\x06\x33\xcb\xc7\x69\x62\x2b\x5e\x67\xe6\x06\xe3\x75\xc3\xb4\x75\x1c\xc5\x54\xf4\x05\xa1\x14\xb3\x45\x69\xcf\x51\x8a\x67\x69\x23\x3c\x0d\xc4\x16\x35\x49\x6c\xaa\x1f\xbf\xf8\xfa\x4f\xc4\xd7\x4e\x60\x3e\xa4\xe9\xa7\xaf\x25\x69\x09\x4c\x59\x7d\x1c\x38\x79\x02\x82\xce\x7a\x4f\x53\x11\x74\x8f\x66\x1b\xad\x56\x9e\xb1\xd9\x20\xb6\x5f\x79\x5e\xb2\x03\x0b\x69\x28\xcd\x1a\x8c\x06\xcc\xd9\x8c\x46\xce\xaa\x35\x11\x8f\x79\xa1\x53\xeb\xc8\xe2\x5d\xe9\x69\x62\x62\x48\xcb\x55\xa4\xbd\x4f\xcf\x9e\x55\x3f\x3d\x73\x46\x9d\xcc\x0e\x64\x6b\xd4\x6d\x47\x1b\x9e\x63\x7a\x1f\x85\xca\xd9\xb3\x54\x9f\xdc\x8b\xf1\xf5\x71\x83\x41\x26\xa8\x8b\x16\x8b\x66\xb3\xcf\x66\x92\xe5\x4c\x86\xcc\xc9\xf0\x65\x86\xb2\xec\xb4\x45\x89\x0d\x0b\x2c\x37\x62\x18\x37\x1f\x74\x57\x28\x41\xb7\x95\xe3\xb9\x0a\xc5\xc4\x1b\x0c\x7c\xe3\xc6\x25\x4d\x24\x51\x26\xea\xdb\x62\xfd\x4c\x4a\xe2\x3d\x4d\x34\x4f\x4c\x6a\x5f\x93\xc1\x4f\x3f\xfd\xb4\xde\xd9\xa4\x51\x77\x13\xf8\xe3\xd1\xf7\xb5\xfe\x26\xef\x1f\x5d\x92\xd4\xe0\xa4\x89\x3c\xb4\x44\x4e\x25\xc9\x5b\x03\x81\xbc\x46\xf6\xa6\x16\xf7\x3c\x12\x8f\x91\x12\xbf\x4c\x2c\x9e\xca\x65\xb6\x48\x89\x91\x6a\xb0\xeb\xe2\xb0\x13\x3e\x19\x27\xf1\xc9\xc8\x8e\x26\x61\x57\xc5\x61\xeb\xf2\x9b\x92\x00\xef\xf1\x36\x01\x3b\x81\x77\x5c\x7e\x6b\x78\xbb\x82\x4d\xc2\x4e\xc4\x76\x75\xf9\x4d\xf1\x66\xfd\xa1\xff\x0a\x7b\x03\x5e\xbb\x19\x74\x7c\x96\x81\x4d\xe5\x78\xbb\xe2\x39\xde\x00\xff\x86\x49\xe4\xee\x95\x90\xfa\x81\x58\x76\x77\x1c\x07\x9a\x13\xa5\xe1\xb0\x21\x16\x33\xf6\x13\x05\x85\x8d\x45\x98\xe3\x31\x53\x82\xc7\xa4\x24\x3c\x36\x43\x83\xa6\x47\xe8\x39\x7f\x03\x1d\xc1\x1b\x72\xfe\xc8\x67\x4c\x88\xbf\x27\x79\x86\x4b\x89\x4c\x0f\xf6\x86\x92\x3f\x45\xcb\x2d\xc4\x7a\x60\x5f\x7a\xef\xdb\x69\xbe\xa5\x0e\xf4\x3e\xb7\x77\x85\xf4\x4d\xa4\xb6\xc1\x30\xb6\x17\xdb\x3e\x0e\x77\x23\x0c\x11\x39\x70\x08\xc2\x48\x5a\x9a\x55\xe3\xec\x25\x7a\x1c\xf6\x38\xc5\xb9\x7d\x13\x7e\x79\x10\x0a\x18\x53\xe3\xaa\xb4\xf7\x0c\xc5\x77\x44\x4a\xdc\x91\x9c\x39\x48\xf7\x1a\x93\xf3\x44\xb4\x7c\xc6\x1d\xb1\x7c\xc6\x24\xd8\x26\x02\x5b\x34\x26\xe7\x33\xc6\x63\xd4\x07\x63\x31\xea\x38\x6c\x72\xe6\x20\xe8\x4e\xc4\xdc\xe3\xb0\x17\xc7\x73\x25\x93\xf2\x2b\x8d\x34\xbf\xd2\x6a\xd6\xa0\x27\xed\x1b\xed\x35\x4b\x65\x52\x27\x5d\x26\xd5\xe9\x32\x89\xe0\x33\xdd\x64\x85\xe0\x06\xff\x79\x09\x95\x49\xa3\x34\x99\x34\x24\xe1\x13\x1c\x6b\xb2\x02\x43\x12\x3e\x1a\xec\x91\x31\xd8\xd8\x0e\xb7\xea\xbe\x3c\x02\x5b\x34\x59\x9a\x84\xfd\x5a\x0c\x36\xb3\xbe\x21\x01\x9b\x35\x59\x9a\x80\xbd\x23\x0e\x7b\x05\x30\x25\xed\xa3\xc5\x22\x37\x09\xfb\x60\x1c\xf6\x0a\x98\x80\x6d\xb0\xc8\x09\xd8\xa4\x37\xae\xde\xcf\xd1\x4a\x7a\xdd\x5b\xac\x56\x4e\xb4\x59\x5c\x08\xdb\xd0\x08\x36\xea\x75\x0f\x13\x4d\x1b\x49\x5e\xc2\xec\x58\xb7\x46\xf5\x3b\x76\xb5\xde\xa7\xf1\xea\x6a\xaa\xe7\x8a\x7a\x6f\xd3\x0c\x50\x00\xc6\x46\x8b\xf9\xcc\x4c\x29\x6c\x34\xb0\x1e\x4f\x46\x1a\x0c\x48\x81\x96\x2d\x4c\x46\x6b\x36\xb6\xd2\x33\x40\x46\xa5\xc2\x02\x8f\xd1\x0a\x80\xd5\xe8\x61\x99\x80\xcb\xd1\xac\x42\x71\xb8\xc9\x58\x4d\x2d\x63\xca\x53\x56\x58\x58\x58\x98\xea\xfd\xa6\xbe\xfa\x88\xfe\x8d\xfa\x16\x62\xae\x6e\x21\xb5\xcd\x19\xe9\x31\x41\xdc\x8f\xc9\xbd\xd8\xc4\xa5\xd0\x47\x26\x2a\xb1\x6c\x9b\xa7\x66\x3c\xff\xea\xbb\xaf\x4c\xdd\xd0\x8c\x33\x72\xea\x65\xc3\x52\xd4\xae\x76\xd2\xb4\xf1\x75\x93\xa7\xd4\x72\x5d\xee\xbd\x77\xe7\x03\xfb\x66\x8c\x51\x2f\xa8\xd7\xd4\x3f\xd4\xf3\xe3\x47\x65\x2f\xb0\x8f\x5a\x8f\xb6\x34\xcc\x79\xf6\xa9\x67\x77\xef\xda\xb5\x1b\xd0\xde\x25\x80\x7d\x84\xf6\xf9\x0f\x81\x7c\x30\x28\xda\xdc\x64\x08\x67\x64\xb0\x1e\x67\x16\x9b\x65\xf5\xe3\x2d\x6d\xd6\x3c\x9c\x5e\xa3\x84\xcd\x61\x33\x2b\xe5\xf2\x12\x8f\x6d\x4a\xc4\x66\x24\x4f\x5f\x89\x27\x37\x16\xc4\x0b\x81\x62\x92\xa4\xa8\x28\x36\x7a\x85\x8c\xf2\xf2\x08\x5a\x49\x5e\x6c\x0a\x4b\x2c\x55\x57\xaf\xfe\x65\x1f\xf9\xfd\x73\x75\x5a\xb0\x3c\xe3\xe3\xf4\x75\x8f\x41\x45\x1f\xc6\xf2\xc9\xa4\xf1\xdd\xfb\x1d\xab\xdc\x96\x96\xf1\x34\x99\xc5\xc2\x4e\x9f\x16\x19\x64\xbf\x65\xcc\x5d\x0f\xe8\x33\x59\x66\x92\x69\x2c\xcc\xe5\x2d\xea\xab\x20\x96\x4f\xbc\x82\xce\x95\x71\x83\xce\xd1\x4c\xd1\x68\x44\x00\x79\xbc\x9c\xd3\x69\xe3\x1c\x35\x0a\xc7\xd9\xa0\xcd\x59\xa3\xd8\x64\x7d\xe4\x48\x4a\x7f\x1b\x48\x3b\x6a\xd0\xb1\xc7\xa4\x7a\x8c\x9a\x18\x5a\x9a\x2e\xcc\x0e\xc5\xe6\xa1\xac\x42\x8f\x34\x3c\x78\xe9\xe2\xb5\xdb\x2f\x6e\x55\x4d\xcc\x87\xab\x56\x3d\xbe\x19\xda\x10\x77\xd3\x59\xf5\xbb\x4f\x5e\x5f\xfc\xfa\x14\xb8\x63\xd4\x2d\xea\x94\xe4\xfe\xb8\x3e\x10\x06\x95\xd1\x02\xbf\x41\x70\x63\xb2\x08\x89\x22\x07\x50\x5e\xbe\x9c\x5e\xa1\xc8\x6e\xa3\xc1\x8d\xbf\x80\xc5\x92\x83\x2d\x07\x09\xf1\x03\x15\xbd\x5b\x6e\x4a\x63\x01\x7b\x24\xc9\x06\xa6\x64\xa3\x37\xce\x4d\x22\x98\xbf\x6c\x9d\x8b\xba\x35\x7c\x18\x6f\x30\x47\x9a\xe7\x26\x77\x98\x23\xcd\x73\x3f\x3a\xa8\x37\xcf\xbd\xae\xbe\x37\xb6\xa6\xc5\x5c\x6b\x4a\xf3\x5c\xcd\x37\x12\xdb\xd3\xe2\xa8\xdf\xec\x74\x0a\x9c\x08\x38\xe0\xf1\x9a\xf1\x96\x9a\x89\xff\x8a\xc3\x7b\xca\xc9\xf1\xea\xd8\x82\x46\xdd\xfb\xe8\x06\xda\xf3\x4a\x72\x09\x4d\xb8\xb9\xd8\x64\x99\x15\x74\x0f\x57\xc2\xf1\x7d\x2e\x5f\xbc\xa6\x7e\xb4\x6a\xd5\xba\x27\xa0\x0d\xee\xc5\x9b\x88\xf6\xae\xcd\x39\xa3\xb2\x9f\xbc\x1d\xdb\x4b\x4e\xdf\x4b\x3f\xb6\xcf\x7a\x47\xc3\x01\xa3\xc1\x83\x2f\x1b\xc8\x92\x80\x94\xdf\xcc\x91\x41\x6e\x9c\xc9\xe8\xc1\x5f\x00\x0b\x86\x0a\xc5\x2a\xf1\x7a\xd3\xe1\xc6\x7b\xa8\xa3\x95\xb4\x89\x14\xad\xff\xb9\x8b\x6b\xe1\xa8\x3e\xff\x65\x17\xd1\xa8\xb5\x39\xa7\xe2\x5d\x88\x9b\xda\xc8\xc4\xbc\x20\x92\xe9\xee\x07\xbc\xdd\x6c\xb6\x7b\x3d\x32\x27\x73\x36\xa3\xcd\x59\xad\xd8\x1c\x46\x86\x4c\x91\x68\xd4\x54\x22\x96\x8b\x47\x7b\x33\x86\xf4\x69\x9a\x99\xa4\x26\x21\x36\x57\x0e\x4d\x54\xaf\xf4\xbd\x35\x4d\xbd\xd2\xfe\xea\x0b\x4c\x3b\xf5\x0b\xf5\xff\xbe\xbc\x5a\x06\xed\x5d\x8f\xde\xb9\x9c\xd9\x01\xdf\x9e\x3d\xe9\xa6\x97\xdf\x6c\x18\xa0\xee\x55\x1f\x3e\xf1\x79\xf1\xcf\xbf\x82\x18\x2e\x27\xf8\x69\x78\x37\xfb\x44\xf3\x81\xd5\x11\x0a\x18\x42\x56\x36\xbf\x59\x20\xcd\x93\x56\xab\x78\x24\x21\xcb\xe1\xc8\x12\x90\x59\x92\x72\xab\x15\x89\x35\xa3\x6a\xc5\xec\x68\x5c\xfc\x4f\x7a\xd1\x24\x8d\xcf\xd2\xed\xd7\xce\x90\x74\x0c\xca\xa6\x28\x16\xb9\x3d\x7a\xe3\x1c\x9d\xe9\x6a\x8d\x83\xe0\xc2\x3b\x97\xb6\xe9\x59\x9a\x05\xed\xdd\x7f\x78\xae\xe1\x43\x7c\xe8\xee\x0e\xc3\xda\xde\xbe\xb2\x55\xa5\x2d\x23\x27\x3f\xa8\x5e\xc9\x1a\xde\x75\xf9\x6c\x66\xc7\xc5\xef\x5a\x8e\x9a\x54\xfc\xd5\xdb\xcc\x4b\x70\x14\x1c\xec\x0a\x64\x6d\x58\x6e\xe1\x8e\x5b\xda\x0d\x51\xdf\xb8\x69\xe1\xd8\xef\x69\x7f\x24\xfc\x1e\x5c\x6b\x90\x8b\xa9\xa2\xb9\x2f\x97\x77\x38\x72\xad\x19\x6c\x5e\x38\x18\x1a\xa4\x64\x04\x07\x2a\x19\x92\x05\xf8\x7c\xc0\x82\x24\xb7\x1b\x55\x28\x6e\x49\x32\x56\x28\x92\xbb\xf1\x9b\x68\xcd\x16\xe2\xaf\x91\xd4\x9f\x91\xbe\x4b\xbc\x93\x2e\x6d\x93\xa8\x37\xfd\x65\x7e\x10\x07\xf4\x1c\x3b\x5c\xa9\xab\xe8\x6f\x85\x7e\xef\xa5\x57\x2f\xfd\xfa\xe7\xa5\xfc\x89\xf9\x86\x4d\x6b\xfa\xf4\x6b\x9f\xde\xa1\x84\xf9\x64\xc2\x80\xcd\x27\x4e\xec\x18\x3f\xce\x7a\xf0\x2d\xe8\xa7\x66\x77\xa6\xcb\x7e\xf7\x52\xfb\xdb\x96\x6e\x3d\xaf\x80\xa6\x72\x63\xc8\x5d\xdb\x43\xe3\xc2\x41\x50\x1e\xcd\x34\x19\x7c\x2c\x6b\x75\x62\x3e\x9c\x96\x6e\xc6\x1c\x58\xf2\xe2\xd3\xd0\x78\xb0\x2f\xa9\x20\x2a\xd5\xaf\x40\xcc\x0b\xca\x79\x25\xd0\x88\xf3\xc6\xeb\xa1\x8a\xda\xb2\x7b\xd4\x5f\x7f\x53\xef\x8e\xb1\xdb\x2e\x30\x03\xa6\xab\x9f\x2c\x7d\xd8\xd5\x79\xe1\x6d\xcc\x6e\xf5\xa0\xba\x39\xc1\x6a\xd5\x23\xea\x9e\xf3\x27\xaf\xdd\x7d\x5e\xf3\x01\x75\xd3\x67\x4f\x92\x59\x1a\xe5\xd1\x90\x8d\x35\xd8\xed\x58\xfc\x99\x58\xe4\xf6\x08\x98\x23\x08\x02\x34\x9b\x4d\x98\x60\x10\x94\x6a\xb4\xc6\xf7\x29\x4d\xc4\x12\x49\xef\x24\x9a\x45\x87\x3f\x76\x80\xb4\xff\x00\x74\x86\x22\x76\x92\xbd\xd9\x55\x35\x5d\x56\xcf\x37\xfc\x78\xa9\xe1\x57\xd4\xa6\xa1\x25\xb4\x6d\x7e\x7c\xd5\xaa\xef\xde\x7a\xfd\x13\xe8\x3d\xfb\xe7\x51\xf8\xcc\x49\xf8\xf0\x2d\x20\xb9\x6f\x36\xe1\xb1\xfd\xa2\xcd\x32\x4d\x7e\xd9\x8e\x90\xc7\xe3\x34\x61\x16\xeb\x72\x0e\x54\x5c\x00\xb1\x76\xd6\x8e\xd9\x42\x1a\x61\x0b\x02\x11\xda\xee\x1b\x39\x6c\x0a\x83\x8d\xfc\x45\x2b\xed\x12\x3a\x00\xa8\x71\x33\x6d\xde\xc8\x96\x6c\x9a\x14\x6f\xa6\xad\x46\x98\xf3\xc9\xed\xb4\x5d\x77\xa6\xa5\xb4\xd3\x3e\xfc\x91\x96\x2a\xb5\xeb\xe5\x78\x3b\x6d\xb2\xa7\xea\x70\x76\x05\xdb\x1f\xc8\x20\x00\x4a\xa3\x19\x0e\xe0\xb1\x58\x78\x03\xe2\x00\x9f\x16\x94\x5c\x98\x64\x25\x5e\x18\xa4\xf0\x01\xe4\xaf\xd4\x82\x45\x49\x7d\x84\x13\xb7\x8f\x11\x38\x12\x0c\x80\xa4\x87\x0f\xe1\x12\x64\x8e\x4a\x26\xe9\xb2\x82\x79\xed\x57\x27\x61\xd5\xb5\xf1\x8c\x4f\xad\x19\x33\xe3\xae\xdf\x77\x42\x03\xf4\xaa\x9f\xfd\x7a\x1d\x2c\xba\x0d\x22\x26\xff\x5f\xea\x37\xd9\x0d\xf5\xef\xc2\x82\x6e\x3f\xee\xd8\xf6\xc7\x32\xf5\x9c\xfa\x0b\x1c\xaf\x6e\xd8\x77\x18\xdf\xb1\x41\xfa\x79\x9b\x41\x97\x68\x88\xe1\x4d\xd0\x64\xb1\x1a\x58\x16\x42\xab\xc0\x57\xe3\xd3\x66\xf4\xd3\x66\x30\x93\x60\x1a\x9f\x36\x8c\xbb\xb9\xb4\x5e\x44\x76\x3d\x88\x85\xff\xb0\x5d\xaf\xb5\x63\xb6\x36\x6c\x64\xc6\x35\xb4\x25\x61\xd4\xb3\xb0\xeb\x59\x38\xe4\x2c\x88\xcd\xd9\x59\x86\x79\x25\x87\xf7\xa3\x4b\x34\xcb\xc7\x30\x12\x72\xbb\x4d\x12\x4a\x0b\x7a\xf1\xc7\x78\x8d\x5e\xa3\xc3\xea\x00\x64\x62\x8b\x15\x23\x61\x6d\xcc\x35\x53\x3d\x87\xb9\x45\x8e\x50\x3a\x74\xc4\x98\xa7\x3e\x8a\xc7\x5e\x5c\x4a\xbc\x68\x13\x4f\xa5\xab\x59\xe2\x1d\x43\x07\x4e\xc8\x56\x7f\xef\xfc\xf5\x6b\x98\x1b\x65\xa9\xe7\xb1\xca\x74\x55\xfd\x4e\x40\x06\xeb\x8a\x0f\xe1\xb0\x9d\xbb\xd1\xe6\xda\x09\xbd\x5e\xdc\xa5\xde\xab\x6e\x57\x5f\x51\x9f\x80\x35\x30\xda\xbf\xc3\x8e\x03\x84\x97\xf6\xc6\xb8\xae\xe3\x14\xac\x3f\xf5\x8f\xb6\x74\x1b\x33\x10\x32\xf2\x01\x31\xcc\x37\x6f\xe6\x0b\x56\xc7\x9a\xa0\xe7\xfa\x24\xc9\x97\x8b\xb0\xa4\xc7\x37\xc4\xc2\x82\xac\xc4\xec\x92\x94\x6e\x2a\xc9\x07\xca\x69\x83\x51\xc9\x69\x92\xa6\x29\x89\xae\x6b\x1d\xa0\x2b\x89\x41\xf1\x2c\x33\xe8\xaa\xfa\x9f\x8d\x5b\x1e\xbb\x0b\x72\xe7\x3f\x86\xa0\xbb\xfa\x73\xde\xc2\x89\x53\x26\x2c\x58\xd7\xa1\xc3\xb3\x4b\x6e\x5d\x7c\xeb\x83\x85\xd0\xd0\x4d\xfd\xde\xf9\xcf\xd7\xee\xd8\xe4\x0d\x3f\x30\x7f\xc7\xb1\x67\x4f\x74\xba\x73\xfc\xd0\xaa\x9a\x01\x67\x7a\x8f\x19\x53\x3b\xeb\xae\x51\x6f\xef\xd7\x62\x67\xd8\x7e\x19\x48\xf9\x4f\xe7\x68\x08\x72\x9c\x24\x23\xc9\xc4\x3a\x5d\x54\x5d\x82\xf8\xa2\xe3\x2d\xb7\x23\xb3\xd5\x60\xad\x56\x0c\x81\xc6\x83\xa0\x93\x89\x51\x6b\x83\x1a\x6b\x84\x40\x95\x15\x6d\x5e\xda\x63\xcf\x94\x0d\x6f\xe7\x68\x97\xa3\x4f\x4d\x6b\x38\x73\xec\x55\xe7\x17\xd6\x6e\xc3\xb8\xe9\xfa\xec\xa9\xfd\x18\x07\x85\xce\x65\xbd\x39\x1a\xb2\x4a\x16\x93\x20\x98\x25\xb3\xc5\xe2\xf1\xfa\x4c\x56\xc9\x3a\x47\x11\x24\x09\x2b\x21\x68\x8e\xe2\x14\xcc\x81\x44\x5b\xbd\x46\x8e\x8c\x58\xfb\x0d\xba\x69\x22\x0c\x09\x21\x14\x72\x64\x97\x46\x4a\xb5\x86\xcf\x6c\xf3\xc0\x98\xcc\x8a\xee\x36\x27\x6c\x95\xa3\x9e\xfe\x4e\xfd\xf6\xbb\x53\xb9\xa7\x02\x81\x7f\xec\xed\xf9\x80\x8f\x5d\x66\xb4\xb6\xed\x35\xf9\xe8\xd5\xb1\xec\xa6\xa3\xcb\x1f\xbd\xd7\x67\x4a\xc8\xcc\xd1\x98\xd3\x0c\x8b\x16\x66\x01\xa3\x3b\xc8\x71\x39\x6e\x20\x71\xf9\x79\x92\x6c\x95\x6b\x15\xab\x90\x9b\x53\xa3\xe4\x7a\x8c\xd8\x84\x44\x8c\x20\x60\x16\x2d\xb0\x4c\x46\x62\xba\x5b\xe2\xa4\xf5\x4e\x6e\x49\xd2\x33\x65\xc2\x9b\xa7\x24\xd9\x52\xf9\xeb\x69\x6f\xd3\x86\xce\x5b\x59\x55\x98\x11\xca\xf3\x93\xa1\x6f\x2b\xee\xbc\x61\xe8\x5b\x36\xb7\x71\x99\xfd\xb8\xa5\x58\x51\xcf\xb4\x7d\xe3\x8b\x8b\xfa\xf4\x37\x06\x20\xbc\xc7\xef\xd2\x99\x3a\xe9\x64\x02\x9b\xcf\xc6\xd9\x0d\xb2\x6c\xb7\x21\xc0\x02\x17\xe3\x62\xcc\xc0\x1c\xc4\xba\x5d\x00\x91\x09\x6c\x45\x89\x7b\x05\x0b\x0b\xe5\x04\xbe\x0e\xd2\x77\x0d\xd2\x99\xd7\x5a\x85\x52\xa9\xa3\x38\x9c\x47\xe6\x4e\x50\xbd\x04\x16\xc3\x12\xbc\xfd\x6d\xd4\x92\xba\x2e\x4f\x3f\xfa\xf0\x33\x1d\x26\x9e\x4b\x6b\xd3\xd2\x65\x2e\xc8\xca\x6a\xc1\x75\xbb\x76\x0a\xb5\xbe\xfa\xf6\xf3\xcf\xb6\x5f\xba\xfa\x81\x25\xe5\xdb\x5f\x52\xe7\xe7\x2a\x23\x06\x96\xb5\x09\xb4\x6e\xd9\x82\xd2\x41\x1f\xbc\xdf\x4b\x30\x6f\xcf\x25\x33\xd4\xec\x92\x68\x36\x5b\x7c\x2c\xca\xcc\xce\x46\x16\x14\xce\x0b\x89\x2e\x03\x6d\xa3\x0d\x2c\x2e\x80\x25\x7d\x6c\xae\x40\x79\xcc\xe4\xf3\x24\x12\x60\xf5\xa1\x19\x9d\x60\x29\x61\xdd\x3e\x98\x8d\x7f\x29\x42\x2d\xae\x95\xa6\x2b\x2d\x25\xf8\x77\x4e\x1e\x75\x7c\x62\x3b\xca\xcd\xbf\xfd\xdc\x39\x06\xa1\x82\x11\x3d\xa7\x4f\x6f\x55\x92\x53\xe0\x38\xbb\xdd\x79\xf9\xe2\xa3\x0f\x0e\xe8\xa8\x1e\xd3\xfa\xcd\xdf\x31\x7c\x55\xed\xdb\x9f\x5c\x7a\xfc\x96\x36\x35\xd3\x99\x05\x0d\x6b\xce\xfe\x9e\x94\xb3\x43\xe5\xb9\xf6\x0e\xb1\x39\x77\x0e\x30\x34\xda\x02\x9b\xf3\x06\xbb\x95\xb7\x8a\x08\x98\x20\x80\x4e\x97\x20\x4a\x22\x16\xe3\x98\x9c\x81\xc1\x62\xb6\x60\x26\x2a\x23\x07\x70\xdc\x38\xf7\xae\x11\x75\xc7\xba\xde\x16\xe9\x43\xf0\xa8\x1b\x91\x86\x81\xa9\x2b\x91\x0c\xc3\xfb\xc7\x7f\xfe\x03\x3b\x5e\x9b\x02\x3b\xfe\xf4\x93\xfa\x8f\xf8\x58\x44\xc2\x5f\x61\xd7\xf8\x7c\xba\x11\xc0\x09\xa2\xd1\x90\x84\x10\xeb\xc0\xe2\xdb\x25\x3b\x25\x58\xab\x48\x0e\xc9\xc1\xda\x91\xc9\x22\x58\x08\x01\x6b\xd3\xe9\x74\x74\xb4\x0a\x4c\x62\x28\xc9\xb1\x9b\xae\xa5\x52\x10\xa2\xd5\xc9\x35\x79\x4a\x5d\xdf\x1e\x23\xba\x06\x22\xc5\x29\xb3\xea\xd0\x87\x70\x19\xbe\xf1\xc5\x3d\xd5\x9f\xf4\x91\x75\xb1\x1e\xf6\x1f\xe1\x43\x8c\x46\x45\x19\xe3\xe3\x76\xba\xcc\x90\xe5\x3d\x5e\x19\x1e\x86\xd6\xa8\x5d\x91\x65\xd6\x21\x9a\x6d\x06\xdb\x20\xda\x5b\xde\x95\x8c\x53\x0a\xe7\xd1\xf0\xd1\xee\x8f\xc6\x30\x93\xb3\x3c\xf6\xae\xaf\x19\x22\xf7\x71\x75\x2a\x4d\xe9\x6a\xcf\x1e\x58\xf5\xb8\xfd\x6d\x4e\xe8\xde\x03\x23\xa3\x75\xb7\x4f\x8e\xdf\x0f\x88\x36\x03\x58\x0f\x33\x32\x46\xb3\xc8\x0a\x9c\xc0\xc9\x0e\x64\xb6\x98\x49\xb1\x94\xe5\xbf\x86\xed\x53\x8e\x2d\x76\x6a\xa4\xeb\x67\xea\x81\x91\xb8\xfd\xbf\xff\xad\x45\xed\xbf\xfa\x8a\xc6\xec\xdb\xbf\xa0\x96\x1f\x3d\x0a\x5f\x7d\x01\x7e\x78\x54\xef\x87\xbf\x89\xf6\xf6\x1a\x16\x6d\xc9\x40\xc1\xca\x63\x7c\x6c\x10\x70\x16\x83\xc1\x62\x97\x4c\xa2\x49\xb4\xd8\x58\xa1\x52\x61\x39\x96\xb3\x31\x36\x58\xa9\xd8\x24\xa3\xc5\x45\xdd\x10\x91\x14\xb9\x98\x62\x56\x24\xdd\xe5\xdc\xbc\x10\x29\xa5\xa1\xbd\x14\x61\x1e\x37\x19\x06\x07\xc2\xe6\xb9\x07\x7b\xbf\x00\x3f\xc2\x36\xcd\x6f\xd7\x81\xfa\x09\x7c\x5c\x54\xbf\x65\x97\xcf\x3f\x3e\xa6\xff\xee\x8a\xab\x37\xa3\xb4\x6b\x67\xd8\xc2\x6c\x52\x43\xab\xcd\xc5\xeb\x86\xed\x89\x5e\xd1\x6c\xc9\x04\xc3\x82\x2d\x6c\xb3\x64\xa6\x59\xd2\x9a\xe5\xbb\x25\xd1\xe3\xf1\xe7\x19\xd2\x11\x9b\xed\xcf\xae\x55\x1c\x56\xbf\x9c\x1c\x21\x23\x4e\xf2\x78\x0f\x43\xbd\x88\x96\xea\xaf\xb1\x6e\xd6\xf8\x62\x7a\xb2\x0b\xa1\x36\x8c\x37\x4f\x9f\xc9\x4b\x7e\xab\xfd\x6f\xe6\x9f\xd9\xd8\x5a\xff\x91\x3f\xcd\x41\xda\xaa\x7f\x84\x83\x69\x36\x75\xd0\x9c\xba\x0b\x59\xad\x22\xed\x30\x9f\x19\xbb\x6e\xc6\xfe\xa7\x50\xe5\xd5\x27\x63\xcd\xfa\xa7\x0c\xdf\x75\x1a\x7d\x71\x6d\xec\xa6\x29\x5b\xb7\xa2\x71\xe4\x9e\x5e\x3f\x85\xf9\x21\x99\x21\xe8\x21\x1d\xdf\x65\x8f\x91\x85\xa2\xe8\xf4\x20\x1f\x26\x3f\x19\x02\x97\x44\x6f\xc3\x18\x45\x08\x80\xd8\xec\x32\x52\xa5\xa4\xb7\x87\xf4\x94\xc5\x95\x46\x32\x4f\x30\x45\xe8\x25\x4d\x16\x9c\xbf\xbe\x77\x15\xbe\x0c\xb9\xc9\xf3\x05\xdb\x9e\xde\xec\x3c\x6f\xed\x38\x86\x1b\x9f\x34\x66\x90\xc6\xc9\x87\xd3\x38\xb9\x07\x94\x44\x03\xc0\x23\xe1\x53\xc6\xc6\xad\xcf\xab\x25\x20\xd8\xb1\x19\x63\x11\x8d\x2e\xd2\xa0\x57\x0b\x32\x94\x37\x1e\x21\x9b\x94\x7b\xd0\xd4\x00\x01\x43\x22\x32\x8e\x3f\xc9\x11\x0b\x8a\xaf\x9a\xa8\xc7\xc4\xaf\xee\x00\x89\x7e\x00\xdc\x08\x99\x67\x1f\x8f\xe9\x65\x1c\xe4\xee\xc2\x7c\x23\x13\xdc\x14\xcd\x74\x39\x80\x55\x0a\x70\x80\xcb\x0a\x59\x24\x93\xd5\x64\xc5\x52\x0f\x9b\x28\x36\x2c\xf6\xd2\x13\x62\xef\xcd\x24\xf1\xa1\xe7\xb1\xe9\x1d\xc3\xb1\x45\x9b\xa9\x8f\x34\x6d\x5b\x82\xb9\x32\xed\x4c\x99\x32\x1b\x7d\x54\xc3\xaf\x2a\x16\x76\x8c\xf9\xad\x2b\x91\x3e\x23\x3f\x1a\x36\x58\x50\x3f\x9a\x30\x6f\xde\xc4\x89\xf3\xe6\x4d\x60\xb6\x35\x90\x11\xf9\x0a\x73\xe0\x9d\x77\xba\xcf\x84\xec\xfb\x77\xbe\xdc\x71\x40\xf4\xbb\x33\xe7\xcf\x9d\xbb\x74\x49\xd3\xab\x49\x8c\xfb\x37\xac\x57\x3b\x40\x06\xd1\x26\x9c\x66\x86\x33\xf8\xed\x0c\x99\xd7\x67\x60\x38\x86\xb3\xf1\x36\x6c\x17\xd8\xdc\xbc\x08\x3c\xf8\x3a\x4b\x49\x95\xdd\x4d\x23\x9c\xe9\x88\x23\x1a\x33\x0e\x92\x7d\x73\x4c\x6f\x78\x32\x30\x78\xdc\x87\xd5\x75\x76\xf5\xab\xef\xaf\xab\xf0\xa0\x72\xcb\x94\xd1\xa3\x6a\xa7\x8f\x66\xfb\xab\xf6\xe8\x63\x18\xc9\x27\xde\x6a\xf5\x83\x0a\x73\xb0\x9a\x69\x85\xd9\x0d\xa7\x5e\xde\xb7\xef\xe5\x97\x0e\x1e\xc0\xb8\x16\x63\x3e\x74\x27\xd6\x23\xed\xd8\xf6\xeb\x11\xb5\x78\xc4\x60\x10\x59\xcc\xc8\x9c\x96\x6e\x39\x0c\xdb\x46\x5d\x06\x5b\xad\x62\x30\x00\x23\xcb\x3b\x6b\x15\x9e\x05\xfe\xda\x84\x0a\xa9\xfb\x5d\x12\xce\x4e\x6a\x04\xd2\x59\x78\x5a\x0c\x39\x37\x42\xbb\x62\x09\x3c\xc2\xc8\x62\x01\x8d\x7f\x57\xca\x98\xbe\xbf\xf8\xf3\x3f\xef\x98\x0a\x7b\xf6\x3d\x5f\x67\x5c\x3e\x24\xb3\xcd\xf8\x19\xf3\x26\x87\xd3\x1c\x70\x22\x1c\x0c\xcb\xe1\xcc\x9b\x3a\xfe\xe1\xe1\x2e\x5f\x33\x3a\x6a\xd9\x7b\x7c\xd7\xc1\xbf\xcf\xa9\xbf\x49\xda\xbe\x16\xa8\x53\xd9\xfb\xd8\x7e\x78\xc3\x02\x58\xeb\x6d\x0e\x90\xcf\x27\x39\x8d\x92\x31\x2d\x68\xb5\xf2\x36\x1b\x33\x10\xb3\x1f\xb3\xbf\x42\x31\xdb\xf1\x1f\x89\x27\xd5\x7d\x64\x7f\x49\x19\xe9\x9b\x05\x9a\xcd\x9a\xb0\x12\x52\x51\x26\x0d\xbc\xf4\xad\x0d\x51\xbc\x61\xac\x55\x26\x0a\xa3\xdd\x33\xca\xb7\x54\xfe\xf8\x2b\xfc\xee\xd1\x05\x30\xa3\x77\xc3\xaa\x65\xf3\x66\xdf\xd9\x26\x17\xfa\x31\x3a\xbf\x5f\x3b\x5b\xd0\x06\x06\xa1\x8b\x29\xec\xda\xf1\xcf\x7c\x2e\xbf\xfe\xf5\x97\x5e\x34\x33\x5f\x18\x63\x76\xf5\x3a\x7c\xbf\x5d\x58\xdf\xe9\x16\xcd\x71\x07\xc8\x30\x60\x60\x31\x89\x40\xcc\xcc\x08\x60\xe5\x36\x60\x0d\x58\x79\x59\xf6\x57\x2b\xb2\xa1\x46\x91\xf5\xe9\x99\x29\xf6\x44\x59\x22\x69\x99\xfa\x35\x59\xda\x75\x20\xc5\xb3\x99\xd4\x7e\x60\x9d\xfa\xdb\xe5\x3e\xea\x99\x5c\x62\x60\xff\xed\x31\x58\xa5\x42\x5e\xfd\x64\xfe\xdd\xe9\xe1\xbb\x67\xa2\x0d\xa7\x2f\xa9\x39\x09\xfb\xfa\xe3\x4f\xc9\x6c\xcd\x69\x04\xcf\x87\xc9\xcc\x0c\x2c\x07\xd3\xb1\xfe\x30\x34\xda\x32\x43\x26\x63\xa0\xc2\x26\x53\xd0\x89\x5a\xb6\x0a\xa6\xdb\xbd\x60\xa0\xe2\x05\xce\x00\x8b\xec\xf8\xcb\x2a\x10\x27\xb4\xd5\x2d\x34\xd3\x27\x68\x34\x72\x1a\xc6\x47\x23\xc6\xd8\x3c\x25\xe1\xac\x34\xd8\xc4\x2c\x0d\xcd\x4b\xd3\x0a\xa2\x94\x91\x1a\x4c\xe1\x3d\x8d\x26\x6a\xec\xdd\xd8\x66\x81\x47\xee\xb3\x21\x69\xac\x46\xc3\xdd\x57\x1a\x4d\xd5\xe0\x47\xae\x5c\x67\xe1\x3e\xe0\x84\x86\x40\xd2\x68\x0d\xe2\x9f\x55\xdf\x61\x5f\xa4\x31\x54\x0f\xe8\x10\xcd\x94\xcc\x2e\x92\xbf\xc9\xda\xb0\x5c\xf5\x79\x5d\x0c\xd6\x37\x9c\xd5\x8a\x4b\x70\x09\x2c\xc9\xd5\xc3\x67\xf0\x66\x52\xd3\x07\x4f\xc2\xa5\x68\xd4\xa6\x6e\xba\x22\x8d\xe7\x6e\xde\xa1\xbe\xf1\x20\x69\xfa\xf0\x16\x19\xbc\xf9\xb7\x87\xe1\x34\x75\x0b\x1d\xbc\xa9\xbe\xc3\x3c\xa4\xfe\x8d\xeb\xf6\xcc\x7b\xaf\xde\xff\x46\x4e\x43\x31\x5b\x16\x9f\xbd\x19\xc5\x3c\x62\x1b\xd6\x85\x9a\x13\x2f\xad\xc9\x9d\x0e\x80\xe4\xce\x65\x5b\x14\xa4\x9b\xf2\x1d\x20\x07\xda\x51\x4e\x4e\x7e\x7e\xa8\x46\xc1\x7f\x13\xa1\x15\x91\xa1\x33\x56\x2c\xc5\x92\x87\xe7\x27\x7e\xd2\x93\x06\x63\xca\x88\xa3\xb8\x33\x2a\xed\xcc\x68\x7d\xe0\x88\xf1\x59\x84\xf1\xb5\x31\xa9\x7d\xb1\x32\x73\xa2\x05\xbd\xc7\x2f\xb8\xff\xa1\x11\x25\xd3\x27\xbf\xd4\x42\xfd\x26\xf7\xda\xd7\xe7\xa1\xaf\x6c\xf2\x81\x0f\xa7\x4e\x5b\x74\xcf\xa2\x07\x3d\x30\xad\xb9\xfa\xcf\x0b\x58\xe7\xff\x1c\x2e\xef\x35\x73\x48\x79\xeb\xbc\x70\x8b\x2e\x6d\x7a\x0f\x38\x94\x76\x64\xff\xf1\xbd\x15\x4b\xaa\xfb\x47\x02\x55\x5d\x94\xc1\x53\x47\xe7\xbe\xf4\xe6\xe7\xf8\x9d\xee\xc0\xef\x34\x98\xce\xe7\x50\xa2\x45\x41\x60\x70\x65\xbb\x44\xc0\x36\x6b\x6e\x08\xca\x61\x90\x25\x65\x31\x26\x94\x95\x15\x0e\x67\x54\x28\x61\xf7\x18\x1b\x14\x6d\x19\x36\xfc\x2b\x9b\x4d\x96\xcd\x64\xbe\x49\xa3\x4e\x5f\x7f\xf9\x6e\x98\x49\x74\x86\x8d\xda\x19\x26\x77\xfd\xa2\x99\x2c\x39\x77\x0c\x7c\x74\xe7\xcc\x11\xfd\xc6\x8d\xab\x1b\x6d\xf9\x23\xed\xc2\xab\x9f\x5f\x1e\xfe\xcc\x8f\xe3\xab\xa6\xce\x5e\x34\xd1\xf5\x5b\xf8\xc7\x7f\x7f\xa3\xaa\xb0\xe3\x98\xc5\x83\x72\xfc\x72\x69\x61\xc7\xc8\x4d\x5d\xfc\x6b\x1e\xdd\xbd\xa1\xfa\xae\x8a\x42\x57\xa7\xe2\x2e\x1d\xca\xfb\xe7\x3e\xbc\xe6\x59\x4d\x1e\x61\x69\x4d\xf4\x0c\x99\x47\x83\x29\x3d\x1d\x51\x87\xa1\xcf\xb8\xf7\xb1\xde\x98\x05\x7a\x46\xa5\x34\xbb\x5d\xf0\x00\x20\x58\x51\x4e\xb6\x53\x94\xfd\x44\x75\xb4\xe2\xf7\xb1\x18\x45\xe3\x40\x45\x0c\xa0\x4c\xfc\x9b\x67\x89\x8f\x3d\x1e\xbc\xf0\xa6\xda\x0b\xda\x8b\x69\x79\x7a\xa4\x93\x1d\xe9\x4f\x8b\xe5\x26\xb1\x6f\x92\x3b\x69\x1f\xb9\x73\xf2\xb6\x6d\x73\x1d\xfd\xe4\xae\xb3\xd4\x43\x2d\x8a\x95\x89\xf3\x22\x39\x39\x45\x45\x39\x39\x11\x8e\x1f\x3d\xed\xb5\xa3\x57\x27\xad\x16\xb8\x0f\xec\xb0\x17\xbb\xdf\x3d\xa3\x2a\xbf\xb0\x30\x1f\xff\x21\x33\x46\xd4\x3a\x3a\x63\x24\x04\x06\x45\x5b\x90\x19\x23\xa1\x80\xdd\x6e\x70\x63\x53\x3b\x2b\xdb\xe3\x73\xfa\x06\x29\xce\x34\xb7\x24\x05\x99\xa0\x8d\x44\xef\xf5\xb1\x23\x74\xe8\xc8\x9b\xa9\x91\xfb\xf2\x54\xf3\x31\xd2\xe4\x00\x92\x84\x2e\xd2\x09\x0a\xa9\x93\x48\x32\x7b\x77\x5d\x78\xf7\xe3\x1b\xfb\x56\xf5\x0c\xcf\xe9\x77\xef\xb6\x01\x49\xe3\x48\x3a\x67\x05\xd4\x63\x6b\xb7\x38\xdf\x16\x57\x17\x33\xfd\xd7\xdc\xa5\xe7\xd4\x92\xdc\x07\x09\x44\xa2\x5e\x9b\x28\x9a\x59\x46\x30\x0b\xb2\x9d\xe3\x4c\xa2\x6c\x05\x26\x50\xad\x98\xe2\x36\x0b\x96\x44\xc9\xec\x92\xb0\x9c\x04\x8f\xa4\xb3\xd3\xe1\x88\xa5\x98\x2d\x6e\x7b\x18\x0d\x51\x27\xa9\x9f\xb2\x35\x63\x28\x27\xbc\xf3\xe1\xb3\x64\xe8\x6b\x62\x16\xcb\x47\x20\x07\xef\x53\x81\x39\x28\xbb\xdd\x28\x07\xe6\x38\x83\x6c\x38\x37\x18\xcc\x64\x32\xb1\x68\xc9\x74\x9b\xcd\x64\x98\x3a\x66\x7d\xc0\x45\xf7\x49\xa6\xb3\x59\x52\x77\x29\x75\xb8\x5c\x72\x62\x43\xc2\x2f\x6d\x83\xb4\xa1\xfb\x8d\x43\x5b\x9e\x3a\xfa\x7a\xf9\xcc\x87\xef\x5e\x18\xed\x9d\x1d\xdf\xb2\x35\x73\xa2\xda\x6e\xf5\x38\xb0\xd5\xe0\x3d\x12\xc8\xec\xd0\x25\xaa\x6f\xda\x11\x8f\x91\xec\x16\x9d\x7f\x8b\xf9\xf8\xfd\xd4\xbe\x6e\x1d\xf5\x41\x8b\x0d\x9b\x09\xac\x43\x06\x36\xd1\x56\xad\x88\x88\x67\x8d\x58\xe4\x18\x03\x8d\x46\x56\x78\xca\x12\x43\x5c\xb4\xbe\xc8\x25\x7a\x5e\x48\xdb\x68\xa0\x6b\x55\xef\x9d\xbb\xf5\xc9\xb8\xb3\x07\xf4\xb3\x7e\xe1\x3c\xfc\x0f\x76\xcd\x59\xdd\x67\x72\x17\xd6\xcb\x72\xb1\x5e\x16\x04\x7d\xa2\x76\x87\x9b\x47\xa2\xc5\x8f\xfc\x69\xe9\x78\xe3\xd2\x45\x1f\xa9\x21\x92\x15\x51\x04\x56\x47\xd4\x69\x45\xa9\xa3\x73\xcb\x3f\x26\xf9\xab\x65\x31\x5f\x9d\x1c\x77\x9f\x50\x9b\x39\x65\x92\x2e\xbe\xeb\xba\xee\xe3\x92\x18\xa6\xec\x87\x93\x30\xaf\xeb\x10\x65\x00\xcc\x1b\x34\xb0\xee\xe3\x65\x6b\xbf\x72\xaa\x30\x4c\x26\xeb\x1e\x58\xbd\x69\x37\xca\x57\xcb\x1d\x4b\xc6\x61\x85\xe7\xc8\xe7\xe9\x5f\xaa\x5f\x92\x24\x2e\x3a\xdb\x86\x0b\xb2\xed\xf1\xb9\x0e\x8f\xba\x84\x60\xd0\xe4\xb2\xd9\x61\xb6\x2b\x3b\x9c\x6b\xb5\xdb\xc3\xc1\x34\x93\x93\x5c\x59\x97\x92\x66\xb2\xd9\x4c\x69\xc8\x27\x1a\x72\xc4\x4c\xac\xf3\x66\xba\x7d\xf1\xda\x88\x88\x16\x52\xa5\x9b\x96\x40\x39\xa9\x99\x6d\x53\xf8\x3a\xdd\xa4\xe6\x33\x6e\x3c\xc0\x2d\xdd\x7b\x0e\x1a\x0d\x7d\x43\xc6\x8c\xff\x70\xcd\xa3\x1c\x52\x7f\x66\x05\xc8\xb5\x5b\x35\x71\xfd\xe3\x64\x18\xcc\x53\xf3\xb7\x3d\xc0\x74\x6d\xf8\x5d\x5a\x35\x09\xbf\xc0\x4b\x5f\xa4\xbd\x32\x6c\x7a\x0b\xdf\xfd\xad\x6e\x9f\x71\xf4\xdf\xcc\x5e\xfc\x1e\x45\xd7\x2f\xb0\xeb\xf1\xf9\x66\x63\x7b\x35\x0b\xd9\x2c\x7c\xba\x37\xe4\x0e\xb8\xbd\xbc\xcd\xc8\xe7\xe6\x78\x2d\x64\x9e\x06\x16\x66\x41\x24\xe3\x9b\x21\x3b\xe2\xf3\xfb\x80\x66\xe9\x24\xcf\x39\xca\xd5\x5a\x04\xd9\xc9\x7c\x90\x3c\xd6\xee\x64\xc8\xc1\x33\x25\x52\x2e\x4f\x46\x69\xd8\x29\x2f\x65\xea\xe6\xad\x19\x36\x09\x5e\x9e\x11\x9d\x05\xa5\x35\x57\xd7\x3d\x7e\x6d\x0d\x94\xa6\x45\x6f\x83\x97\x27\x0d\x5b\x73\xf2\xe4\xa1\x65\x27\xa7\xc1\xd6\x67\xcd\x9f\xaa\x0f\xef\x50\xaf\xae\x59\x03\xf9\xed\x70\xca\xa7\xe6\xb3\xea\xa9\x69\xc7\x57\x1c\x3a\x49\xe6\xb9\x63\x79\xb0\x99\x1b\x0e\xfc\x64\xe6\xa1\xd7\xc5\xda\x6c\x46\x17\x0a\x04\xdd\x3a\x7e\x46\xc1\x22\x54\x13\xb7\x64\x53\x2c\x91\xa2\x28\x53\x83\x82\x4c\xcb\xc8\xc4\x6a\x03\xc9\x4d\xd4\x28\x83\x19\xb2\x6c\x56\x41\xcf\x61\x05\x5d\x47\xac\x81\x7d\x67\xa8\x67\xaf\x5e\x82\x79\x63\x3e\x98\x85\xb5\x5b\xff\xaa\x3b\x31\x91\xaa\x39\xea\x32\xf5\xfe\x67\xa0\x08\x5d\x84\x32\xb6\xad\xd3\xe8\x55\x9b\xd5\x3b\x02\x5b\x53\xf9\x51\x19\x32\x0c\x6b\x61\xad\x22\x8f\xbf\x18\x13\xcb\x6a\xb5\x39\x54\xee\xcb\x65\xc4\xe3\x54\x16\x6f\xbe\x1f\x0a\xd0\x42\x31\xad\x81\xba\xc0\x3c\x81\x2d\xd3\x55\xb0\xe4\xfd\xd5\x2d\xe7\x8c\xdf\xb4\x7a\x6a\xf7\xf6\xcd\xcb\x5c\xf0\x4f\x95\x87\x7f\xa2\x3e\x0d\xef\xc0\x99\x77\x8c\xba\xeb\xf9\xce\xc5\xa5\xda\x67\x4a\xea\x30\x8e\xf8\x18\x32\x89\xc7\xcb\xe6\x62\xdc\x4c\x20\x60\x71\x23\x04\xdc\xa2\x68\xb7\xd8\x07\x29\x96\x00\xe0\x06\x2a\x20\x45\x38\x50\x5e\x56\x46\xfd\x5e\x5a\x2f\x7d\xfd\xa3\x21\xcd\xd1\xa4\x56\x5e\x39\x1d\x7b\x24\x93\x31\x37\x9d\x21\xbb\xe9\xce\x79\xd5\xed\xda\xb6\x88\x48\xea\xf8\x7e\x47\x1f\x1d\xdf\xb7\xa4\xc5\xf0\xda\x5c\x59\x1d\x0c\x9b\xed\xb4\xf4\x37\x1b\x2b\xdf\x6f\xf1\x08\xf7\x51\xef\x7f\xe4\x74\x28\xbc\xda\xfd\xc4\xdf\xac\xc7\x0c\x83\xc6\xb5\x66\x0b\x55\x2e\x4b\x6d\x68\x46\x06\xdf\x3c\x70\xdf\x1d\x18\xd7\xfe\xfa\x4c\x61\x3b\xb6\xa7\xf3\xa0\xd9\x46\x18\x08\x32\x60\xa5\x9f\x05\xb2\x43\xc4\x46\x7e\xad\x62\xe1\x38\x68\x34\x1a\x48\x77\x3c\x28\x55\x37\x8e\xb3\x34\xf6\x3b\x14\xc5\xe7\x0c\x3b\x08\x4b\x41\x98\xdf\x69\xf3\x86\x61\x58\x3d\x0d\x5f\xfd\x96\x0c\x1d\xfe\x03\x5c\x57\x67\xa8\x17\x98\x63\xa7\xe1\xda\x37\x60\xd9\xb7\x27\xd4\xdd\x6f\xa8\xcb\xe9\xde\x2d\xd3\x67\xf0\x50\x7c\x4c\x56\xab\x19\x9f\x94\xc0\x4b\xa4\xe4\xcf\x21\xdb\x30\x47\xa9\x54\xcc\x2c\x19\xfd\x20\x0c\x22\xa5\x5c\xe2\x20\x6d\x20\x4f\x93\xf8\x44\xf4\x00\x7b\xa4\xc4\x91\x5d\x12\x2a\x25\xe8\x08\x11\x57\x48\x08\xb9\x56\x7d\xf2\x39\x9c\x71\x92\x8c\xe8\x39\xf5\x2f\x75\xf5\xfb\xcc\xc4\xb7\x20\xdc\xff\xeb\xbb\x6f\xff\xbe\xff\xea\x09\xed\x0c\xfd\x6a\x2d\xbb\x01\xef\x4b\x80\x44\x9e\x4c\x3e\x9f\xcb\xee\x16\x65\x24\x04\xd3\xdc\x62\x8d\xc2\xba\x59\x37\x70\x38\xe4\x6a\xc5\x81\x00\xa6\x67\x80\xcd\xa6\xbf\x88\x0b\x10\x99\x94\x98\x89\xde\x0a\x16\xc4\x66\x30\xb3\xd8\xd8\x07\x4c\xe5\x27\xea\x85\x3e\x90\x69\xbb\x76\xc2\xd6\x07\x86\x3c\xf3\xf8\x62\xb8\xb5\xa1\x3f\xeb\x57\xc3\x10\x41\x46\x3d\xae\xd6\x3e\xf7\xea\xf8\xbb\x67\x6e\xdb\x39\x6d\x45\xf9\xb7\x70\x1b\xde\xa7\x96\x16\xf5\x8f\x1f\xd5\x8b\xea\x7b\x04\xc7\x22\x8c\xe3\x01\x8a\xe3\x4d\xd1\x2c\x6c\x54\x20\x24\x98\x79\x93\x8f\x4f\x0b\xf2\xb6\x1a\xc5\xcb\x7b\x79\xbc\x4f\x66\x32\xa2\x1f\xb8\xfe\x2b\x92\x14\x4d\x12\xa7\x00\xb9\xa4\x6e\x33\x44\xbc\xfe\xc9\x8a\x23\xb3\x50\xfd\x41\x3d\x0e\x59\x08\xd5\x30\xeb\x6f\xe8\x0f\xb7\x2e\x7e\xfc\xe9\xa1\x0f\x6c\x9d\x70\x7f\x09\x64\xfa\xa8\x17\xd4\x5a\x88\xcd\x94\x4b\x90\xb3\xc0\x0f\x4e\x7c\xab\x2a\xdf\x96\x2f\x9f\xfe\xf7\x67\x66\x2d\x19\xff\xea\x73\x74\x26\xae\xda\x9f\x9d\x48\x7b\xc1\xb6\x8b\xa6\x7b\x4d\x26\x9b\x6c\x75\xda\x59\x21\xe0\x47\x2e\xe4\x12\x44\x51\x1e\x84\x45\x86\x00\xb0\x7c\x0d\xde\x18\x93\xd6\x36\x91\x8b\x75\x76\x05\xc4\xf9\x1b\x47\x92\xc7\xe2\x61\xd1\xb0\x5b\x4d\xd0\xe5\x55\x1b\x4e\xfd\xac\x9e\xfb\xd7\x3b\xea\xc3\x68\x59\xc3\xbb\xb0\xa2\xee\xd0\x93\xff\x57\x3d\xc9\xfa\xdc\x5b\x90\xff\xea\xd8\x7f\x9c\x70\xce\xeb\xef\xaa\x1b\x5f\x7a\x60\x83\x7a\x91\x9e\xef\x12\x3a\x1f\xb5\x3d\xd6\xc5\x3b\x45\x43\xb6\xb4\x1c\x41\x70\x3b\x5c\x7e\x5f\x1a\x30\xb4\x28\x68\xee\x68\xee\x40\x1e\x8f\x7b\x90\xe2\x11\x51\x5e\x85\x82\xfe\x02\x2d\x8a\x18\x41\x4a\x0b\x83\xd1\xbe\x6b\x49\x27\x4c\xdc\xd5\xc9\x3a\x2a\x3b\x22\x4b\x3d\xf3\xe9\xe2\x13\xb7\x8e\x39\x70\x64\xda\x84\xa2\x49\xcf\xd4\xc1\xc2\x86\xf3\x68\x99\xfa\xcc\xa9\x83\xca\xbe\xf7\xe6\x8c\x9f\x36\xae\x76\x81\x79\xec\xc6\x03\x7d\xd7\x8e\x1b\xb6\xa8\xa2\xb9\xb7\x53\x8b\x96\x85\xce\xfb\xa1\xfd\xdd\xbf\xa9\x9f\x72\xcb\xee\xad\x9c\x3b\xb8\x28\xad\x53\xb3\x76\x37\x8d\x1c\xae\xd1\xe8\x02\x7c\x57\x86\x60\xde\x96\x45\xea\x33\x4c\x1e\xd2\xb3\x1a\x65\xf2\xbe\x80\x27\xcb\x90\x93\x1d\xa4\x77\xd7\xc7\x49\x9c\x04\x9c\x4e\x6b\x8d\xe2\x64\x41\x66\x75\x22\x0f\x3e\x1e\x90\x4c\xd2\x09\x22\xda\x6d\x69\x4b\xae\x8a\x6e\x4b\x68\x91\x2c\xda\x18\x1d\x5f\x1d\x6c\x50\x84\x5c\xb7\x57\x3c\xaf\xfe\x0a\x2f\x0c\xbd\x39\x67\x74\xd5\x88\x6a\x9b\x7a\xce\xfb\xcb\x07\x9f\xa9\x33\x26\xaa\x6f\x3c\x3a\xa8\x83\x9d\x59\xf3\xfa\xde\xdd\x2f\xf7\xea\xdb\x2b\xa7\xe7\xc0\x9a\x1a\xe9\x1f\x27\xdf\xda\x76\xdf\x92\x97\xe7\x0e\xe8\x9d\xff\x2d\xc1\x79\x3c\x96\x0f\xa3\xb8\xee\x58\x3e\x74\x8f\xe6\xfa\x6d\xac\xd7\x69\x30\x30\x5e\x1b\x1b\x08\xb2\xde\x1a\x45\x64\x45\xd6\x0c\xcc\xf6\x1a\xc5\xec\x40\x7e\xe0\xaf\x49\x71\x50\x37\x19\x72\x23\x7e\x69\xcd\x3a\x63\x43\xe4\xa6\xc5\x54\x67\x6c\x30\x4f\x43\x1f\x35\x5c\xcc\xc1\x1a\x9b\xa0\xfe\xa9\x5e\x3b\xa5\x5e\xf5\x41\x7f\x7e\xfd\xdc\xc9\xf3\xef\x55\xcf\xec\xe1\xba\x9f\xfb\xe6\xcb\x8f\x2e\xfd\xf4\xce\x73\xd6\x3d\xf3\xee\x9c\x37\x8b\xe6\xe4\x42\xb0\x08\xe3\x57\x85\xe9\x22\x40\xf0\x0b\x60\x63\xd1\x85\xf1\xf3\x89\x6c\x30\x8d\xf5\x55\x28\x12\x2b\xb1\x16\x60\x91\x2b\x14\x0b\x19\xc9\x18\xc0\xdc\x47\xfc\xff\xc2\x4f\x4f\xee\x69\x84\xe0\x7d\xe8\x7e\x95\xab\xf8\xcf\xef\xb7\x7e\xba\xf9\x4d\xf5\xf7\x1c\x28\x66\xbf\x3b\x66\xe6\xe2\x25\xea\xd7\x4f\xb0\xed\xdf\x3d\x7c\x78\xdf\xe4\x2d\xc3\x0f\x6c\x90\xb7\xf4\x1f\x32\x72\x10\x9c\xa9\xf3\x25\x9a\xf3\xdc\x0e\x84\x49\xac\x22\x43\xc6\x9a\x7d\x18\x7a\xc3\xc8\x20\xf3\xf9\x79\x98\x4b\x31\xae\x60\x85\xe2\xfa\x6f\xea\x7c\x2a\x72\x58\x3f\x2d\x8d\x90\x82\xed\xf8\xc4\x96\x1b\x67\x21\xfe\x6d\xe5\x63\xc3\xf7\x9d\x38\x91\x57\xb9\x7a\xcf\xc3\x49\x43\x10\x67\x4f\x1d\x36\xf1\xc2\x76\x05\x2b\xa8\xaa\x7a\xb4\x5f\x5e\x51\x76\x66\xfe\xc0\x3b\xab\xf5\x01\x88\x1d\xba\x14\x77\x72\xb5\x1a\x76\xff\x64\x62\x3b\x2d\xc1\x3a\xea\x22\xb6\x12\xeb\xf4\x3e\xd2\xf9\xdd\x0e\x3c\x46\x96\xe5\x00\x17\xf0\x9b\x8c\x46\xde\xe3\xb2\x3a\x68\x22\x8d\xc8\x51\x2f\x63\xac\xa9\x46\xa3\xd4\x1e\x09\x70\x44\xa3\xd7\x47\x48\xa6\x43\x8e\x36\xfb\xb1\xb7\x95\xd9\x45\xea\x93\xea\x02\xf5\x5b\x68\x14\x38\x36\xb2\x63\xe6\x92\xe7\xaa\xd5\x6f\x3e\x9b\xb1\xf0\x87\x2f\x98\x8d\xea\x1b\x6a\xcd\xa6\x93\xdc\x99\x92\xe9\x55\x63\xa6\xbd\xb5\x09\x8a\x7b\xef\x6b\xd8\x3d\x0f\x6a\x73\xfc\xe1\x8f\x18\xb9\x7f\xeb\x73\xcd\xb0\x9e\x40\xe6\xd2\xe3\xdb\x71\x22\xd6\xc7\x9e\x8c\x29\x80\x3f\xfe\xc2\x1d\xff\xb3\x98\xfa\xa2\x20\x36\xf8\xd0\x73\x7a\xad\x6d\x46\xd4\x8a\x00\xab\x4d\xa4\x87\x5a\xa9\xfc\x89\xa2\xa4\x7e\xe5\x21\x5d\xef\x82\x9e\x2b\x2f\x5f\x21\x20\x28\x18\x08\x6a\xf1\x9d\x9d\x8c\x61\x38\xc0\x80\x68\x9e\x68\x60\x2d\x16\x3b\xb4\x62\xbb\x06\x6f\x87\xd3\x25\x38\x80\xa3\x56\x61\x81\x59\x94\xc4\x5a\xc5\x20\xe1\x1d\x93\x18\x2b\x71\x4e\x68\x45\xf8\xa9\x73\x8b\x62\xba\x68\x44\x1b\x49\xe8\xd0\xc6\x2a\xe8\xcd\x8d\xb5\xd0\x77\x2d\x5c\xf5\x0b\x5c\xa5\xce\x21\x7f\x7e\xd1\xfe\xc3\x76\x80\x0f\xa8\xd3\x4f\xab\xbf\x9e\x56\x67\xc2\xb5\xa7\xa1\x89\xda\xbb\xf0\x43\xfc\x82\x7f\xd2\x78\x12\x4b\xed\xdf\x2c\xbc\x1f\x32\xbf\x43\xca\x33\x76\x63\x68\x55\x36\x3c\x80\x17\x1a\xf0\x37\x2e\x0c\xf4\x5c\x79\xb2\x86\xe1\x0e\x4a\x79\xcc\x0a\x58\x40\xd7\xd4\xeb\x6b\xec\xf1\x35\x1e\xac\x87\xb7\xe2\x8e\xd3\x35\x34\xa3\x1e\x1e\x4c\x5d\x83\xe9\xa3\xe2\xfa\x15\xf6\x0e\x2c\xc7\x38\xbc\x2b\xad\xa3\x7e\xb3\x8d\x1c\x86\x83\xb4\xac\xb4\x63\xad\xc3\xee\xb0\x40\x04\x50\x82\x75\x45\x52\x92\x11\x22\xf4\xad\x4b\xe3\x0e\x7c\x62\x87\x56\x5c\x84\x25\x3d\x73\x5a\x0d\xee\xf1\xf1\x33\xfb\x07\xfa\xb9\x6e\x57\x9f\x38\x7b\xd6\x3e\x7f\x32\x5a\x73\x6d\xfe\x7f\xbe\x60\x69\x1d\x4e\x05\xa6\xc9\x71\x34\xce\xe1\xc0\x54\xd9\x2f\x5a\x20\x99\xcd\x0e\xe0\x71\x3a\x39\x9f\x95\x50\xa6\x5d\xaa\xad\xb2\x03\x17\x72\x7a\xaa\x15\xa7\x6c\xb3\xd6\x2a\x36\x91\x37\x20\x43\x8d\x82\x02\x29\xd3\x9c\x75\x2f\x6e\xb2\x75\xcc\x25\x3b\xe6\xb1\xe6\x91\x47\xda\x99\x51\x34\xd9\x71\xdb\x9e\x9c\xd6\xad\xcf\xe0\xf6\x9d\x3f\x84\xcf\x9f\x3d\x7b\xf5\x47\x8c\xa8\xf5\xd8\x87\x99\x9f\x65\xcc\xaa\xd3\x06\x2d\x5f\x45\x14\x5d\x8a\x23\x8f\x71\xbc\x4d\x9f\x31\x9d\x06\x46\x46\x8b\xb1\x1e\x62\x03\x9c\xd5\x66\x0b\x38\x38\x01\x31\x42\x7a\x86\xd9\x54\x5b\x65\x06\xc1\x00\xb6\xe1\x45\xa7\xdb\xee\x1e\xa8\xd8\x03\x7f\x31\x15\x39\xc5\x0d\x51\xd0\xd8\x36\xa0\x73\x8d\x08\xb2\x1c\x46\x16\x35\x7a\x01\xf8\xcf\x0f\x1b\x46\x5c\xfc\x7f\xa4\xfd\x07\x7c\x14\xd5\xfa\x3f\x8e\x9f\x33\x67\x66\xb6\x97\xd9\xdd\xd9\xde\x37\xc9\xa6\x87\x64\x53\x48\x20\x64\x09\x84\x5e\x52\x40\x58\x11\xe9\x45\x7a\xef\x88\x74\x50\x8a\x52\x54\x8a\xa2\xa2\x82\x0a\x52\x6d\x20\x45\xe4\x82\x0a\x28\xb6\xcb\x55\xaf\xe5\x2a\x5e\xef\xb5\x7b\xf5\x5a\x20\x19\xfe\xe7\xcc\xcc\xb6\x04\xef\xf7\xf3\x7f\xfd\xcc\xcb\x10\x96\xc9\x99\xe7\x9c\xf3\x9c\xa7\x9d\xe7\x79\x3f\xcf\xc2\xcd\xf0\x85\x2f\x61\xca\x0c\xa4\x3e\xca\x6f\x91\x72\xef\xe4\x24\x40\xda\x9e\xaa\x80\x8d\x58\x50\x0c\x45\x21\x15\x6b\x30\x99\x6c\x2c\xa2\xed\x0e\xb5\x96\xd7\x0e\x8b\xf1\x66\x16\x1a\x15\x34\xc2\xbe\x81\x49\xec\xdb\x1f\xa9\xac\xac\x69\x75\x57\x2d\x9e\x25\x84\xf9\x39\x62\xc6\x7f\x49\xdf\x66\xb8\x79\xc9\xd9\xef\x56\xbc\x5a\x9e\xd8\x69\xea\xf3\x16\x2f\x53\xd7\x82\x97\xee\xda\xf1\xb4\x0d\x47\x62\x1e\x78\x03\x5e\x4b\xac\x0c\x81\x17\xdc\x12\x2d\x74\xda\x6c\x76\xaf\x8b\xd3\x6a\x2d\x00\xe8\x59\x97\x9d\xf1\xf9\xb1\x5b\xe5\x76\x20\xde\x6e\x32\x71\x23\x87\x98\x80\x41\x3f\x12\xdb\x25\x48\x25\x6f\x79\x4a\xf1\x58\x44\x74\x1a\x52\x5d\x7d\x2e\xb9\xf1\x59\xad\x77\x3e\x41\x3d\xdd\x70\xf8\xfe\xca\x05\xe1\xa5\x3d\xda\x17\x2e\x83\xb3\x7f\xfe\xb9\x65\xa6\x48\xbf\xee\xd4\xc7\x6e\xdb\x07\xc5\x93\x26\xc5\x39\x20\x75\x1a\x84\xf6\x4a\x99\x57\xcd\xd8\x0b\x0c\x13\x3c\x62\xbd\x52\xa9\x32\x83\x0c\x9f\x2f\x6c\xb1\x04\x1c\x40\xc5\x64\xe7\x64\x66\x34\x0d\xc9\x04\x36\x77\x63\xcc\xe6\xc4\xff\xbb\x8c\x46\xec\x79\x69\x03\xd8\xdd\xa9\x8f\x05\xb5\x06\xa0\x92\xba\xa9\x26\x6e\x79\x6b\x12\x81\xf1\xd6\x93\x68\xd5\xb7\xba\x3c\x52\xe2\x80\x37\xe5\xe8\x3f\x32\x0a\x4a\xbb\xfc\x87\xfd\x86\xed\xb6\xfc\x77\x38\x3f\xce\x16\x1b\xe0\xcc\xab\x57\x49\x65\xe9\xd3\x1b\xc8\x45\xcf\xe3\xfd\x86\x88\x6d\xa2\xd3\xb9\x1c\xdc\x0c\xd7\x4c\x55\x07\x39\x51\x36\x10\x08\xfc\xb8\xfc\x68\x8d\x65\xb6\x46\x7a\x22\x22\x4a\x8f\xb6\xd8\x15\x89\x31\x08\x6c\x4b\x7c\x0c\xe9\x7e\xf5\x48\x02\xaf\x62\x8d\x55\x20\x4f\x68\xe2\x63\xb4\xaa\x97\x4c\xd2\x61\x4b\x8e\xd1\xba\x46\x52\xa6\xc3\x1e\x1f\xa3\x55\x5d\x45\x92\x0e\x73\x72\x8c\xd6\x75\x1a\x6b\x7e\x13\x9f\x48\x1f\x43\x91\x17\x1f\x43\xf9\x0b\x35\x16\x8f\xa1\x7d\x0e\x51\x50\xa2\x24\xad\xd6\x62\xbb\x34\x8e\x31\x0b\x4c\xf8\x0d\x18\x15\xaa\x5e\xd0\x03\x4b\x93\x78\xca\x29\xe3\xfc\x57\xec\x33\x2b\x8e\xe3\x69\x3b\xce\x17\xc9\x71\x00\x19\xa7\x0b\x9c\x4c\xea\x04\x6e\x32\xce\xaf\xff\x93\x9e\x8f\x5a\x8d\x53\x07\x75\x64\x3d\x6f\x32\xce\x6f\xd4\xe4\xf8\x38\xbe\xb6\xe3\xfc\xad\xd5\x38\xb5\xe0\x94\x3c\x8e\x88\xa3\x44\xf7\x33\xb1\x94\x33\xc9\x3f\xe2\xb8\x19\x69\xeb\x45\x23\xca\x92\x3a\xae\x84\xd7\xbb\x5d\xe2\x21\x32\xee\x8f\x64\x87\x7a\x41\x33\x5e\xaf\x5b\xa2\x15\x74\x75\x34\x2f\xaf\x47\x75\xd4\xe3\xc1\xdf\x9c\x2e\xfc\xcd\x66\xc3\xdf\x78\xbe\x47\xf5\x5d\x46\x23\xfe\x49\x6f\xc0\xdf\xb4\x5a\xfc\x4d\xa5\xea\x51\x8d\xa8\x72\x2e\x8b\x6e\x05\x0e\x2c\x56\x4e\x70\x79\xf1\xff\xca\x6e\x4a\xdf\xef\x22\x7d\xea\xa3\x48\x66\xf0\xb2\xb6\xb4\x51\xdb\x7f\x7a\x5d\xa4\xcd\x84\x69\xeb\x12\x8d\xa0\x4a\x42\x5b\x25\xa1\xad\x92\xd0\x56\x49\x68\xab\x24\xb4\x55\x12\xda\x2a\x09\x6d\x95\x84\xb6\x4a\x42\x5b\x25\xc1\xf8\xc3\x03\xa7\x12\x22\xd3\x71\x8a\x9d\x8c\xdf\xb1\x06\x48\x33\x7f\x11\x2a\x44\xee\x4d\xf2\xa6\x88\x4f\xcc\x90\x7a\xa6\xbd\xf2\x33\xed\x44\xfe\x45\x9d\xe3\x7a\x5a\xca\x4b\x7a\x55\xf4\x37\x46\x47\x79\xbf\xdb\x6d\xb1\xa8\xbc\x2e\x97\x9e\x02\xb4\x8a\x0e\x65\x20\xb7\xc7\x4d\xe2\x7f\xee\x18\xf0\x04\xfc\x23\x62\x9e\x80\xc1\x10\xf0\x20\x56\xa3\xe1\x86\x61\x9f\x9d\xc5\x8a\x94\x6d\x9b\x9e\x74\x93\x5a\x85\x44\xfd\x35\x31\x4b\xe3\x89\x4a\x56\x5b\xeb\xe4\x24\x29\x41\x69\xc8\x90\x78\x8a\xd2\xd1\xab\xe5\xa9\xb9\x49\xdf\x42\x0b\xc9\x4f\x82\xaf\x6c\x99\x25\xa7\x28\x1d\x3b\x11\xcf\x4c\xd2\x6c\xe9\x43\x72\x93\x32\xb1\x0f\xb8\x97\xee\x8d\x7d\xc0\x72\x30\x25\x5a\x56\xac\xc9\xcb\xe1\x28\xca\xe1\x76\x78\x82\x9a\x5c\xb6\xa2\x7d\x08\xbf\xdb\x9f\xd5\x10\xf3\x63\x5f\x4a\x59\x2a\x82\x88\x9a\x94\x0c\x76\xa6\x0d\xfa\xc2\xfa\x98\xde\xe8\xc9\x05\xb9\x2f\x42\xdd\x91\x98\x53\xac\xd2\x4f\x6a\xd7\x64\xdc\xb0\xad\xd9\x2d\x3b\x59\x81\x8a\xb2\x8a\x74\x5c\x38\xec\xd7\x06\xb0\xd4\xc5\x6e\x16\xf9\xdc\x8f\xa4\x98\x41\x45\x20\xf5\xd6\x37\x13\xd9\x20\x45\x15\xef\x9b\x78\xe8\xb5\x37\x4f\xdf\xf1\x70\x3e\x83\x8d\x4f\x35\x0b\x07\x0e\x0f\xfc\xfa\xba\x30\xbb\x14\x3a\x34\x4d\xf5\x3d\x47\x9a\x9b\x7f\x43\xce\x69\x23\x46\xdf\x31\x71\xf8\xa8\x69\x99\x1d\x66\xf6\x1e\x00\x35\x5f\x41\x16\xfa\x46\xdc\x1e\x9a\x67\x9e\xb4\xa1\xf9\x1f\x81\xa1\x4f\xed\x03\x37\x02\xa5\x65\xf5\xfd\xa8\xb5\x8f\x1f\x7b\xee\xc0\x7d\x0f\xef\x05\x37\xc3\x06\x4b\xca\x31\x77\x92\x57\x5a\xe3\x81\x49\x72\x8c\xe0\x8d\x49\x72\x4c\xcc\xf9\x61\xf7\xca\x58\x2c\xe2\x18\xf8\xd3\x14\x99\x8c\xd7\x5e\xcc\xc3\x61\x9f\x02\x1a\xbc\x74\xfd\xa3\x39\x50\xad\x46\x62\xc7\x6b\xf1\x96\x4e\xa3\xe7\x69\x9b\xd5\x64\x36\xde\xa5\x63\x44\xac\x15\x95\xd2\xc0\xa0\x14\xac\x95\x9a\x88\xad\xd2\xf8\x89\xf3\x52\x5a\x2f\xf7\x04\xc2\x40\x0a\xe6\x0a\x15\xca\x2c\x8b\xd8\x88\x8f\xd3\x06\x7c\x45\xb8\xfd\x4b\x41\x78\xe4\x5d\xfa\xc2\x2e\x31\x33\x07\x2b\xdc\x32\x29\x23\x87\xd9\xfc\x87\x67\xd5\x2a\x8f\x9c\x97\x80\x75\xef\x4a\xb1\xc6\xb5\x84\x74\xe1\xa5\x76\x8e\x96\x3e\xbf\x0d\x7f\x3e\x5d\xac\x1d\x6e\x4c\xfb\x5c\x7c\x9e\x1d\x8b\x4f\x32\xfe\xc4\x98\x5e\xdd\x8f\x4f\x53\x2e\x23\xaf\x91\xf8\xfb\xcc\x90\xc4\x73\xd2\x28\x77\x53\x64\x0c\x31\xf6\x44\xf6\x00\xce\x4f\xdf\x03\x4f\x72\x0f\x08\x56\xdd\xed\x64\x0f\xa8\xa6\x44\xed\x2b\xd9\xa5\xf8\x1e\x10\xec\x9c\x9a\x14\xec\x9c\x35\xe3\x25\x6d\x24\x9d\x66\x44\x6c\x77\xfa\x75\x6c\x9f\x91\x9e\x48\x2e\xd0\x2b\x1a\xd6\xd3\x4e\xb3\x0a\xf0\x0e\x93\xc3\x0a\xcc\x34\xeb\xf6\x38\xac\x56\x1d\xa3\x1b\x16\xb3\x31\xc8\xe2\xc4\x9e\xba\x7e\x58\xcc\x2c\x66\x68\x49\x5e\x88\x3d\xfe\x43\x2b\x63\x0d\x1a\x29\xf1\x82\xd4\x84\xe2\x37\xd4\x30\x10\xef\x8b\x4d\xcd\x38\xf8\x78\xf3\xdf\x8f\x1d\xfb\x47\xa7\x7e\xd0\xde\xa5\x04\xb5\x6f\xd9\x09\xfb\x0a\x1f\x51\x59\xc2\x11\x38\x8a\xda\x2f\xbc\x20\xec\x64\xea\x84\x97\x84\x03\x3f\x9e\x6d\x5e\xfe\xa5\x50\x71\x11\x6d\xfa\xea\x7c\xf3\x1d\x40\xa6\xf7\x99\x04\xbd\x8d\xd1\x02\x3d\xad\x02\x0e\x93\xc5\xee\xb2\xf3\x26\x40\xe8\xb5\xf3\x56\x7e\x64\xcc\x6a\x20\x34\x33\xc8\x8c\x27\x32\x32\x66\xa2\x09\xd9\x62\xfa\xba\x2c\x68\xec\x29\xc5\x44\xad\xe9\x0e\x05\xd2\xe8\x36\x27\xda\x79\x53\x33\xf6\xec\x16\xae\x7d\xf5\xd2\xc1\xcf\x3b\xf5\x85\xb6\x2e\x25\x3f\x41\x87\x20\xc0\x3f\x84\xaf\x61\x3b\x4c\xf5\x01\xe1\x71\x4c\xf5\x71\x61\xff\x6f\x27\x9a\x97\xff\x53\x28\x3f\x43\xed\xbf\x70\xb6\x65\xd0\x25\xd1\x86\xc7\xfe\x0f\x7d\x58\xb4\x3b\x5d\x20\x13\xcb\xcd\x0a\x2b\xcb\x69\xa0\x3e\xe4\xf6\x06\x33\x83\x3e\xb7\x9e\x65\xb3\xc2\x41\x9f\xdf\xd7\x14\xf3\x1b\x3c\x21\x77\xa8\x29\xe6\xe6\xb5\x00\x6a\x90\x4a\x65\xa9\x8f\xa9\x44\xbc\x62\xd4\x26\x8f\xbc\xa6\xed\x7d\x4e\x4a\x42\x79\x4a\x45\xbf\x98\xd2\x24\x22\x61\x4b\x97\x15\x30\x31\x27\x78\x2f\x1d\x19\x32\x71\xd1\xc2\x19\x7d\x2b\x2e\x32\x6f\xe5\x67\xd6\xe7\x64\x84\x0b\x08\xc8\x26\x3e\x23\xbf\x0a\xef\xc2\xee\xe5\xbd\x60\x0e\x16\x1a\x0a\x98\x5b\x0b\xcf\x5c\xf7\x3f\x30\x90\x0a\xee\x3f\x29\x6c\x78\xf1\x85\x4b\xc2\xea\x57\xa8\x67\x2f\x9c\x69\x19\x78\x29\x55\x66\x3c\x19\x97\x19\x32\xd6\x2b\xe6\x36\x7f\x6b\x99\x71\x38\x2e\x33\xc0\x9c\xd9\xa2\xcc\x28\x95\xf8\x11\x82\xd8\x8d\xef\xc4\xda\x1f\x17\x89\x6b\xb0\x2a\xbb\xc5\xc2\x3b\x00\xc7\x73\x2a\x92\x88\x6d\x1e\x1e\xb3\x2b\xec\x0a\xde\x69\x45\xbc\x49\x87\x46\xc4\x74\xf1\x2b\x25\x29\x78\xdf\xca\x8a\x8d\xe3\x1b\x88\x8e\x82\x74\xc9\x56\x0d\x49\x52\x8a\xf8\xaf\xd4\x8f\xd9\xf9\xf9\xe1\x9f\x3a\xaf\x5f\xbc\x60\x65\xe5\xf1\x9f\x7e\x3a\xfe\x0d\x3c\xbd\x6e\xd6\xe8\x9d\xd4\x6d\x2d\xfb\x9e\x7f\x63\xc8\xad\xe7\x8f\xcd\x69\x39\x83\xa5\xc1\x77\x94\x59\xcc\x23\xd8\x82\xfd\x98\x5b\xc5\xfd\xcb\x8f\x5a\xec\xa4\x6f\x04\x87\xfd\x7f\xb7\x47\x67\x21\xe9\xe0\x4a\xa4\x78\x11\x2a\xe5\x02\xa0\xf4\x6e\x11\x14\x69\x67\x4d\xdc\x71\x39\x60\x21\x9b\xd5\x9d\x28\x7a\x71\xff\x1d\xc2\xbf\x85\x8f\xa1\xb1\x76\xdb\xd4\xf9\xc7\xc7\x0a\x57\x86\x4c\x1c\xb7\xf0\xc4\xf6\x06\xd4\xe5\x49\xe1\xc7\xbf\x9f\x9e\xf3\x15\x7b\xe8\xc9\xb1\x03\xd7\xfc\xf6\xe2\x53\x4f\x3e\xb4\xb4\x25\x63\xce\x81\xab\x29\xd8\x34\x7b\xb0\x4f\x5e\x0b\x8e\x02\x88\x57\xb1\xb8\x8d\x4f\x9e\x8e\x9f\xc3\x82\x2e\x4f\x8b\xe7\xde\x2b\xad\x33\x1d\xb7\xb9\xf1\x7c\x6c\xd8\xa7\xcc\x01\x5b\xa2\x7e\xa7\xcb\xe5\xb1\xdb\xbd\x1a\x2f\x20\xf7\x57\x0c\x47\x67\x68\x14\x4a\x1a\x29\x35\x1c\x40\x4c\x5e\x6e\x98\x14\x02\x7b\x4d\x7c\x8f\x70\x38\xa0\x0f\x6c\x8a\x79\xf4\x1e\xbd\xca\xc9\xb0\x16\x76\x44\x8c\xb7\x58\xd0\x18\x0e\x72\x2f\xde\xb8\x2c\x36\x80\xe2\x28\x95\x41\x89\x3d\x3a\x31\xed\x2e\x42\x52\xef\x86\xc6\x2b\xd3\xed\x45\xf2\x56\x91\x1f\xd3\xdc\x4f\xe2\x4a\x25\xfa\xea\xc9\xdb\xa7\x80\x01\x84\xbf\xa0\xdc\xf1\x0d\x19\x20\xfe\x6b\x16\x12\x01\xa9\x6c\xa9\x3d\x2e\x07\xb7\x83\x4f\x08\x1f\x0e\x16\x0a\x6f\x11\x3e\x80\x4f\x14\xaf\x9c\x3c\x75\xf9\x4f\x8a\xc8\x38\xd8\x79\x6c\xfe\xdc\x7f\x11\xac\xaa\xca\xf6\x45\x85\x55\x55\x85\x45\xed\xe9\x33\x3d\xcb\xaf\x9f\x80\x0a\xe1\x0f\xba\x36\xd2\x37\x36\x65\xaa\x70\xce\xfb\xb4\x70\x09\x46\x56\x53\x16\xdf\x95\xbc\x0b\x3f\xf9\xc3\x59\x81\x40\x56\x18\xa4\xd8\x8c\x4f\xc9\x76\x59\x98\xda\x71\xe3\xb7\x1b\x93\x45\xde\x9e\x05\x7e\x03\x39\x51\x8e\xee\x65\xed\x80\xa8\xee\x46\x7a\x78\xaf\xbe\xd8\x08\x24\xf6\xe0\x47\xc9\xc6\x0f\x22\x38\x55\x99\xf1\xd7\xd2\xa4\xfd\xb5\x27\x6e\x7f\xe1\x31\xfe\x2b\x62\x7a\x51\x3c\xc1\x8f\x80\xe8\x28\x6f\x47\xa9\xf8\x11\x92\x2d\x76\x58\xb6\xc5\xf0\x59\x99\x22\xd6\xa4\xa2\x4e\x5c\x16\x9a\xd3\xa9\xb3\x25\x27\xe5\x59\xb1\x57\x8d\x38\xf6\x76\x79\xec\xd1\x52\x9d\x2e\x0a\x31\x59\x68\x72\x28\x4b\xc1\xfd\x09\xbe\xfc\x31\x69\xec\xd1\xd2\xd8\x19\x78\xec\x89\x19\x61\x75\xdb\x9e\x66\x27\xe2\xf6\x2b\x75\x99\x72\x80\x9f\x44\xfb\xd5\x92\xb0\x5f\x23\x52\x4f\x13\x53\x1c\x0f\xfa\x32\xa5\x90\x6d\xdc\x6a\x2e\xfe\x4c\x2b\x3f\x8f\x7a\x07\xdb\xc1\x7f\x25\xa7\xdf\xd9\xda\xcf\x7b\x37\x31\xce\x3b\x54\xa3\xe4\x61\x55\x27\x63\x49\x53\x45\xdc\xd5\x13\x09\xdc\xd5\xcb\x54\x17\x91\x9e\x84\x3b\x82\x9f\x69\x10\xb1\x56\x2f\xca\x58\xab\xe4\x99\x4c\x99\x9e\xec\x04\x3d\xad\xf1\x5b\xdf\xa1\x16\x88\xf4\xc0\x14\x7f\x4f\xc2\x6c\x7d\x2b\x31\xce\x3b\xd4\x84\x1b\xcd\x84\x9e\xec\x24\x3d\xdd\x44\xdf\xf3\x04\xe6\x8e\xcb\xd8\x23\xf9\x89\x93\x72\xb1\xd5\xf8\x68\xd2\x09\x7a\xba\x49\xb9\xbd\xf2\x33\x64\xc5\x7f\x8e\x3f\x93\xa0\xa7\x35\xfe\x62\x7c\x7d\x52\xe9\x91\x7c\xd8\xb7\x64\x1f\x56\xa4\x59\xa4\x87\xa0\x8a\xc4\x9f\x91\xfc\xd8\x13\x09\x6c\x9e\xcb\x54\x40\xde\xaf\x40\xda\x7e\x4d\x17\xd7\xa7\xb1\xd5\x7e\x05\x13\xf4\xc8\xfe\x30\xa6\x59\xa4\x04\xd3\x5c\x22\xc9\x19\xd4\xda\x1f\x7e\x37\x31\xce\x3b\xa2\x6f\x83\xd7\x27\x98\xa4\xa7\xaf\x88\x9b\x72\x22\x81\x9b\x72\x53\x7a\x44\xac\x94\x8b\x71\x0c\x96\x04\x3d\x14\xf4\xa7\xed\x57\x2a\xfe\x4a\x82\x7f\x02\x49\x7a\x24\xcc\x95\xb7\x12\xe3\xbc\x23\x22\x77\x11\x1d\x94\xa4\x67\x98\xe8\xa3\x4b\xfb\x15\x11\xf7\xab\x7d\x9b\xfd\xaa\x16\x7d\xf4\x8b\x09\x2c\x80\xcb\x14\x27\xd3\x93\x5c\x1f\xd9\xd7\x4f\x59\x9f\xf6\xd2\xfa\xd0\xad\x7d\xfd\x77\xc5\x67\x62\xe2\xbe\x0f\x96\x9f\x49\xd2\x93\x25\x64\xa6\xe2\xa7\x50\x5f\x51\x33\x6e\x7c\x4b\xd0\x09\x8c\xc5\x25\xe9\xf8\x29\x99\xa9\xf8\x29\xf8\xb9\x59\xd2\x73\x6c\xfa\x73\xd5\x42\x65\x0a\xc6\x09\x79\x8e\x18\xa5\xf8\x39\xc6\xc8\x31\x8a\xe4\x73\x8f\xe2\xf1\x92\x18\x27\xe4\xb9\x45\xf2\x7b\x03\x41\xc8\x25\xf1\xed\xba\x09\xb3\xe9\x69\x58\xf7\x91\x5c\xeb\x2c\x8e\xcd\x32\xd8\xb4\xda\x10\x00\x06\xd6\x43\x67\xe7\x70\xa6\x11\x31\x43\x96\x8f\xe3\x58\x9f\xcf\x39\x2c\xe6\xa3\x59\xc5\xf0\x18\x2b\xb6\x28\x8e\xfb\x3c\x58\xb0\xdf\x44\x33\xeb\x29\x9a\x29\xeb\x84\xc8\xe5\x02\xcb\x94\x95\x67\xc8\x79\x5d\x8a\x70\x79\xa0\x44\xac\xf0\x50\x58\xe9\x69\x3d\xd7\x7c\x24\xbc\x23\xfc\xfa\xf5\xaf\x9b\x1b\xfc\xae\x07\x05\xc3\x33\xd0\xf2\x6c\xaf\x55\xf3\x8e\x2f\x7a\xed\x0c\xac\x7f\xec\xe7\xe5\x15\x0d\x6b\x60\xbb\xd1\x4f\x6f\x58\x32\xae\xf2\xbb\xb2\xa1\x77\x2c\xab\xef\x3c\x33\x38\x68\xf5\x67\xc5\xc3\x07\x8c\x6f\x1a\x36\x79\xd7\xc6\xdf\x46\xbe\x34\x77\xd8\xc2\xfe\x52\xde\xdd\x1e\xa1\x81\xee\x4a\xf7\xc3\xa7\xbd\x77\x34\x1c\xb4\x2b\x8c\x7e\xe0\xf1\xe8\xcc\x66\xbf\x02\xe5\xe4\x06\x43\x8d\x31\xbf\x51\x1d\x0c\xda\xd5\x76\x47\x63\xcc\xee\x56\xa3\xfa\x98\xda\x98\x76\xa7\xdc\x76\x22\x09\x78\xb0\x94\xe6\xba\xd2\x7d\x1f\x4d\xe6\x54\x2e\xcf\xae\x13\x8d\x4a\x27\x8c\x6c\x9a\xc5\x7f\xe9\xf8\xed\xc4\x87\xbf\x76\xae\xed\xd8\x7d\xf2\x79\xe1\x45\xe1\x9f\xaf\xc1\xf0\x7a\x8f\xed\x69\x61\xe4\xb4\x27\x27\xbd\xd8\x87\xba\xda\x30\x62\xd0\x80\xf2\x0d\xbb\x4e\xef\x1b\xb9\xac\x22\x7b\xd7\x98\x45\x27\xef\x1e\xeb\xff\xc0\x30\xea\xe1\x3b\x8a\x87\xba\xea\xba\xff\xd5\xec\x77\xd7\x8d\xbd\x19\x4e\x71\xdb\x78\x57\x2b\x6c\xe2\xba\x68\x48\xa9\xb0\x12\x78\x62\xbf\x83\x53\xd0\xc1\x00\xb0\x5a\x91\x92\xe3\xdd\x5e\xe7\x5d\xf6\xa8\x09\x25\xd0\x89\x09\x1c\x24\xf6\xa8\x4a\x2a\x6b\x22\xf2\xed\x4b\x6a\xbe\xd7\x9f\x60\x14\x27\xbc\xab\xb6\x18\xc5\x70\x70\xdc\xbd\x22\x18\xc5\x97\xde\x6d\x83\x51\x5c\x2c\x7b\x59\x10\xdc\x8d\x7d\x95\x2e\x62\x8e\x46\x71\x54\x34\xb0\x4c\x9c\x82\x33\x5b\x4c\x2e\x1d\x22\x26\x96\x5a\x81\x8d\x2c\x09\xe4\xa6\xa6\x55\x27\x08\x79\x17\x44\x77\x8f\x8f\xd3\x88\xdc\x03\x06\x4f\x6a\x22\xb9\x99\x15\x9b\xfa\x1d\x3f\x2d\x7c\x40\xdd\xb8\xfc\xf8\xa2\x66\x15\x53\x37\xbe\x43\xed\x2f\xdf\x5f\xfb\x94\xd8\xe5\x04\x3f\x83\xdc\xe5\x04\xb1\xcc\xad\x04\xf3\xa2\xd1\x6c\xbb\x5a\x17\xf2\xfb\xbc\x26\x10\x89\xe8\x0b\x18\x46\x6f\xd2\xd9\x99\xaa\x0e\x91\x0a\x75\xa9\xd5\xe4\x6d\xe7\x6a\x47\x35\xc5\xda\x59\x03\xc0\x95\x55\x1f\x73\x19\xb5\x7a\xad\x5e\xc9\xf3\xb9\xe4\xb2\x4d\x59\x51\x2f\x95\xa8\xa5\x5e\xab\xa6\xa5\x77\xd7\x10\xbc\xbe\x54\x77\x23\x01\xc7\x90\x59\x2e\x31\x4f\x28\x18\x36\x60\x7a\x43\x85\xb0\x2c\xb5\x14\xb4\x2c\xcc\x45\x24\xeb\x9d\xa0\xc4\xcb\x1c\x17\x11\x03\x03\x48\xdf\xe5\xb6\x45\xeb\xb7\xdf\x79\xff\xbc\xc2\xc0\x8e\xad\x50\xa5\xf6\xcc\xec\x7b\xcf\xb6\x47\x36\xf5\x18\x99\x09\xff\xf5\xcf\x6e\x75\xab\x56\x76\xe9\x09\xff\x92\xef\xf3\xf7\x70\x40\x4d\xef\x5c\x5f\xfe\xfa\xc8\x9e\x7b\xee\x7b\x72\x79\xf7\x92\xd9\xff\x0c\xee\xcf\x18\x3e\x0a\x66\x40\x2d\xd4\xc1\xcc\x01\xd3\xdd\xb5\xf0\xcb\xe6\x41\x07\x4e\x08\xeb\x85\x7b\xcf\x0b\x7c\x65\xa4\xa4\x20\xd2\x5d\xba\xf3\x12\x73\x56\xd7\x33\x5b\xb1\xef\xd2\x0e\x0c\x89\x96\xe4\xb9\x50\x50\x69\xc8\xe2\x79\x83\x49\x03\xbc\x41\x97\xb2\xb8\x44\xab\x19\x19\xd3\x66\x9a\xbc\x5e\x26\x9b\xc9\x1e\x19\x63\x18\x7b\x66\x26\x18\x19\xcb\x44\xf6\xc2\x91\x31\xbb\xb9\x75\x51\x2e\xc0\x8b\x60\x37\x9e\x6b\x7d\x01\x01\xe5\x86\xbe\x44\x16\x94\x89\xd7\xcd\x3c\x39\x4f\x74\xc0\x2f\x96\x26\x96\x91\x2b\xf6\xf2\x08\x2c\x0d\x24\x12\xe0\x43\x4d\xf5\x5f\x4e\x9f\xd9\x34\xf0\xef\xdf\x7d\xbb\x76\x95\xf0\xb9\xf0\xbb\xf0\x9b\xf0\xf9\xdd\x4b\xe7\xcd\xf8\xee\x7d\xd8\x5d\xf8\x75\xd1\xf2\x65\xab\x57\x2c\xa2\x57\x75\xef\xfd\xec\xd0\xc9\xe3\x06\x9f\x3b\x73\xf4\xdf\xfd\x69\xcf\xb3\xf7\x9c\xff\xf0\xef\xaf\xae\x39\xec\xa6\x33\xb6\x8d\x7d\x70\x7f\xf3\xa0\x8f\x67\x4c\x5d\x38\x73\x86\x34\xd7\x4a\x3c\xd7\xcd\xcc\x4a\x90\x85\xe7\xda\x18\xcd\x2f\x42\x46\xb5\xcd\x93\x93\x91\xe1\xf1\x3b\x75\xac\x1a\xe1\xb9\x06\x58\xd6\x9c\x6f\xce\xaf\x8f\x99\xcd\x5a\xe0\xd4\xe9\x5c\x5a\x04\xc2\xf5\x89\x92\x30\x19\x3e\x37\x3e\xcd\x56\x53\x64\x52\xa6\x92\x69\x93\xd3\x02\x44\xe9\x17\xae\xa0\xe5\xee\xdc\x78\xc6\x99\x7e\xb9\x7b\x9b\x85\x1a\x2b\x5c\x13\x3e\xb8\x67\xc5\xcc\xf9\x30\x77\x42\xb7\x76\x77\xce\x6c\x1a\xdd\xae\xa8\xfb\x04\x98\xbb\x60\xc6\x8a\x7b\x84\x0f\x84\x6b\x50\xbd\x7a\xf9\xd2\xb5\x96\x8f\x4e\xad\x3a\xe2\xa4\xf3\x1f\x9b\xf4\xdf\xf9\xf7\x56\x0c\xeb\x3a\x6f\x52\xf9\x6d\x8d\xb5\xc3\xdb\xdf\x3b\xff\xbf\x93\x76\xe7\xd1\xce\xa3\x2b\x4f\x7d\xf4\xf2\x2f\x53\x66\x4c\x9b\xf6\x8b\x24\xd7\x07\x09\xdf\xd0\xbb\xb0\xaf\x65\x02\x55\x51\xaf\x02\x50\xac\x51\xa3\x61\x11\xa0\xcd\x16\x16\xd1\xf8\xc8\xd1\x08\x2a\x48\x5a\x8b\x8e\x5c\xcb\x9c\xbd\xa9\xa7\x49\xd2\x04\x64\x4f\x52\xdc\xac\x30\xde\xb8\xd0\x20\x6a\x17\xc9\xee\x69\x19\x01\xf7\x6c\x3f\x9a\xfb\x85\x6f\xe5\xdb\x68\xfd\x57\x97\x9a\xa7\xde\xbb\x62\xc2\x9d\x81\xa6\xc8\x14\xe9\xac\x7f\x43\x2f\xa6\xab\xfe\xe4\xdd\x4d\x31\xda\x40\xde\xdd\x14\x13\x6b\xbe\xff\xff\x78\xf7\xdd\x54\x15\x49\xe7\x69\x79\x1d\x8e\x7c\xfc\xe9\xd0\xc7\xbe\x95\xe7\xa9\xbd\x17\x5e\x6f\xb9\xed\xce\x45\xf2\xbb\x13\x76\xe8\xe4\x84\x1d\x4a\x30\xa4\x9f\x21\x76\x84\xa9\xb5\x1d\x7a\x26\x71\xdf\xb0\xfd\x3b\xd1\xaa\x29\x8b\xc7\x55\xd6\x0a\x5d\x92\xbd\x04\x8c\x04\xcb\xec\xa8\x1c\x8f\xe9\x92\xec\x1d\x20\x7e\xde\x2b\x69\x93\x89\x31\xe0\x92\xd6\x31\x6a\x57\x6a\x8c\x5a\xb4\xa7\xc4\x38\x70\x63\x3c\xf6\x2d\x46\x61\x03\xb0\x14\x34\x45\xab\xe9\x20\x89\x03\x07\x49\x1c\x38\x48\xe2\xc0\x41\x12\x07\x0e\x92\x38\x70\x90\xc4\x81\x83\x24\x0e\x1c\x24\x71\xe0\x20\x89\x03\x07\xf1\xe0\x62\x8c\x3a\xd9\xab\xa9\x4d\x80\xfa\x26\xb4\xfd\x91\x88\x4f\x07\x13\xf6\x50\x3a\x5d\x61\xea\x2c\xbd\x47\x98\x93\xa0\xac\x38\x1a\x44\x91\xa8\xd3\xd3\x23\x12\xc5\x54\x44\x08\x01\x11\x42\x40\x44\x6e\x15\x15\x6f\x2c\x55\x16\x0f\x4a\xa7\xe0\x53\x6e\x49\xd8\xa9\x64\x1f\xde\x21\xab\xec\x68\x6d\x5f\x9e\x49\xdc\xb7\x6c\x97\xac\x4b\x67\xda\x9d\x4d\x0a\xed\xc9\xd8\xba\xed\x4f\x68\xcf\xc2\x63\xbc\x9e\xa0\x9c\xc4\xd6\xbd\x64\x4d\xbd\x64\x4d\xbd\x64\x4d\xbd\x64\x4d\xbd\x64\x4d\xbd\x64\x4d\xbd\x64\x4d\xbd\x64\x4a\x5e\x32\x25\x2f\x99\x52\xdb\xd8\xba\x84\xad\x34\x39\x8e\xad\x24\x8e\x4e\x62\xeb\x04\x96\x3c\x69\xe7\x11\xac\xa6\xb1\x32\x56\x13\x79\x26\x4f\xd2\xd9\x8e\xe4\x1d\xf8\x48\xfc\xcc\x4c\xf1\x8e\xcf\x07\xfa\x46\xb3\x2c\xd0\xe9\x34\x19\x8d\xac\x56\xcf\xea\x03\x7e\xa3\xd3\x89\x74\x2a\x08\x6d\x66\x1b\x3e\x22\x36\xab\x19\xa8\x3c\xf5\x52\x5a\x6f\x42\xcb\xd8\x8b\xa4\xf0\x67\x9b\x26\xd9\x90\x4b\xe8\x18\xd2\x1e\xad\xbc\x82\x64\xa5\x4a\x9a\x44\x54\x24\x94\x76\xe6\xbd\x7b\x5f\x7e\xeb\x99\xb1\x2f\x8e\x98\xb6\xb7\x78\x91\x9b\xda\xd2\xbb\x53\x87\xb9\x19\xdc\xc2\x9e\x35\xbd\x99\x8b\xd7\x76\x37\xec\xb9\x67\xe3\xde\x68\x9f\x55\x0f\x74\x5f\xda\x6b\x09\xd3\xfd\x8f\x97\x23\x95\x91\xfc\x48\xf7\x4a\x49\x66\x0e\x15\x06\xd0\xaf\x8a\xf9\xff\xa5\x60\x72\xb4\x4a\xa7\x50\x68\x54\x4a\x5f\x00\x84\x2d\x85\x85\x19\x39\x0e\x47\x46\x38\xa0\xc4\x16\x51\x61\x46\x61\x86\x3b\x3f\xdf\xda\x14\xcb\xb7\xfa\x5d\xbe\x12\x77\x49\x7d\xcc\xed\xd2\x19\x8d\xa8\x31\x66\x34\x6a\x5a\xa1\xb0\x92\xef\x37\xc9\xb6\x4a\x6a\x4f\x29\x4d\xd3\x28\x5f\x53\x16\xc1\x88\x4d\x56\xfe\x69\x53\xed\x04\x2b\x42\x59\xd5\x50\x32\x11\x24\xad\x49\x75\x99\xde\xb1\xf7\xbf\x29\xf4\xa9\xd2\xbc\xb8\xdf\x5d\x6b\x3a\x0c\xc4\x2a\x74\x71\xef\x99\xe5\xdd\x9e\x41\xce\x59\x94\x05\xbe\x90\xe7\xab\x2e\x83\xda\xce\x21\x5f\x3e\x6c\x07\x8b\xa0\xe7\x99\xf5\xe4\x16\x73\xe3\xa8\x57\x63\x4b\xde\xbd\xd4\xf2\x45\x21\xd1\xa1\xe5\x9d\xe6\x2e\x50\xe6\xbe\xdc\xf3\xae\x67\x84\xc1\x95\x91\x61\xed\x6b\x65\x5d\xb9\x03\x30\xf4\x83\xcc\x00\xe0\xc1\xab\x71\x5b\xb4\xc8\xed\xf5\x62\x8f\xcf\xc6\x99\x39\x96\x27\x39\xa7\xb9\x39\x5c\x28\x84\xf4\x2a\x0f\x6f\xe5\xeb\x63\x28\xd0\x14\x43\x48\xe5\xb4\x5b\x0d\x2a\x6c\x52\xa8\xe4\x2c\xc6\x73\xc4\xfa\x92\x5a\x58\xa7\x6e\x67\x02\xeb\xa8\x24\xc5\x1c\x23\xf3\x2c\x84\xf1\x3d\x4d\xa4\xe4\x4b\xf3\x95\xa6\xdb\xb5\x7a\x5e\xd3\xf6\xc3\xe7\x76\xd4\x2f\x1e\x57\x4f\x76\xd7\x49\x72\x79\xe0\x56\x61\x22\x1c\xdf\xad\x64\x65\x3f\xd3\x94\xfa\xb2\x6e\x94\x27\x3f\xf3\xa9\xb5\xeb\x9f\x76\x97\x74\x22\x9b\x5c\x37\x1c\x4e\x96\x33\xf4\x8f\x45\x2a\x87\x55\x74\xe9\x40\xec\x25\x92\x77\x74\x44\xb6\x97\x2a\xb0\x25\x50\x94\x6d\xf4\xb2\x6c\xc4\xe3\x56\x2a\x43\x0e\xbb\xcd\xaa\x2a\x00\x40\xa5\x31\xd2\xed\x2b\x9d\xa0\x5d\x96\x19\xcf\xc8\x6f\x36\x96\xe7\xea\xb0\x85\x84\x74\x56\x95\xd4\x37\x47\xaa\x66\x94\xfe\x48\xb9\x10\x49\x47\xa8\x82\x72\xb1\x10\x1f\x2a\x0b\xb1\x29\xa8\x18\xc4\x16\x92\x9b\x7e\xc1\x84\x49\x94\x02\x56\x4a\x1f\xb9\x77\x65\xbf\xd9\x5e\x78\x80\xea\x74\xe0\xce\x55\xeb\x57\x76\x9b\xed\x87\xf0\x38\x45\x75\xde\xb3\x74\x4d\x4b\x53\x8f\xee\xf7\xac\xad\xeb\x03\xff\xde\xb5\x47\xcf\xde\xbd\x7b\xac\xa7\x02\xc2\x7f\x85\xbf\x8e\xbe\xfd\xd9\x83\x67\x61\x26\xd4\x10\x3b\xe8\xd6\x31\xde\xe1\xf0\x94\x30\xf2\xe0\x65\xe1\x43\xe1\xfa\xfe\x53\xc4\x1a\x3a\x77\xe0\xc5\xc3\xa7\x8f\x1c\x38\x01\xc4\x58\xae\x53\x98\x42\x1f\xc1\x7e\x44\x7c\x0d\x0a\x0b\x80\x87\x61\x4a\xdc\x0a\x71\x0d\x74\x1a\xb5\x2a\xdb\x6c\x56\x01\x54\xd9\xde\x69\x28\xca\xb2\x92\x35\xb0\x1a\xcb\x72\x8d\x78\x0d\x54\x88\x60\xc1\x44\xce\xfd\x8f\x25\x68\xb3\x06\xa4\x5e\x2a\xc4\x55\xa4\x82\x83\xe0\x55\x88\x48\x30\xc9\xa9\x6b\x90\x6c\x7b\x46\x1f\x59\xb3\x74\x4f\x67\x8a\x3a\x0e\xa1\x7f\x76\xb7\x95\xeb\x57\xdd\x79\xa0\x13\x75\x00\x7a\x66\xf7\x5f\x79\x6f\x4b\x53\x9f\xba\xb5\xf7\x74\xeb\x09\xff\xbe\xbe\x47\xef\x3e\x3d\x7a\x74\xa5\x1c\xd8\x66\xfa\xe8\xf2\x41\x61\x24\x3c\x35\xc2\x33\xe6\x56\xb1\x54\x50\x03\x33\xcf\x1e\x7c\x76\xe8\x18\xe1\x8a\xf0\x9f\x43\xe7\x84\x7b\x85\xf5\x27\x0e\xc1\xd9\x27\x0e\x3c\x77\xf2\xb0\xb8\x06\xe0\xc6\x7d\xf4\x25\xcc\x07\x3a\x60\x01\x36\xd0\x3f\x9a\x6d\xe5\xf4\xc8\x6c\xd6\xab\x55\xb4\x86\xd2\xd8\x6d\xf8\x1c\x50\x34\xed\xe0\xac\x56\x76\x44\xcc\x6a\xd5\x00\x3d\xd4\x22\x15\xa3\x21\x11\xc1\x37\x31\x77\x8b\xec\x9d\x48\xa8\x97\x03\x80\xf2\x2a\xe0\x79\x9b\x23\x48\x8c\xfc\x85\x2a\x42\x30\xa0\xd0\x43\x14\x31\x67\x99\x15\x11\xd4\x71\xc3\xee\x9f\x61\x93\xf0\xe1\x6d\xc2\xe1\xef\x77\x77\xdc\x0b\x8f\xc3\xc1\xfb\xd8\xbc\xd9\xdc\x9b\xb9\xa3\x46\x3f\x48\x9f\x83\xac\xd0\xe9\xfa\xaf\xb0\x97\xd0\x7d\x2a\x53\xf7\xbc\x6f\xbf\x30\x06\x2e\x7e\x40\x78\xfc\xc5\x78\x2e\xca\x7d\xf4\x16\x11\xbb\xc5\x0f\x1a\xa2\xb9\x6a\x9a\x02\x36\x3d\xe7\x34\x9b\x8d\x9c\xc7\x46\xb1\xc1\x80\x9e\xd3\xaa\x90\x0a\xf1\x06\x6d\x94\xf7\x0d\x8b\xd9\x79\x5a\xcc\x52\x4f\x54\x95\x02\xa7\xdd\xf8\xa6\x54\x84\x5b\xd9\xca\x90\xc7\x34\x5b\x6d\x8c\xd8\x13\xb0\x82\xa1\x48\x23\xe7\x10\x69\xe4\x4c\xfa\x38\x47\xa0\xd8\x23\xd0\x8f\xbe\x1a\x5e\x2c\xfc\x68\x12\x36\xd6\x4e\x7a\xac\x1f\xe4\x56\x0a\x4b\x0f\x2d\xb8\x65\xf7\xea\xdd\x54\xfb\xe5\x63\x63\xbb\x5b\x0c\x2e\x38\xaa\xb8\x5a\xf8\x91\x7e\x6f\xf8\xae\xda\xb2\x96\x5b\x7a\xfd\x52\x2a\x0c\xae\x7b\xe4\xda\x61\x38\x89\x3a\x54\xf2\x78\xf3\xc7\xeb\x46\x51\x9b\xb2\xc8\x3c\xc2\x58\x47\x4c\x16\x7b\xa4\x64\x82\x5b\xa3\x05\x01\x8a\x62\x0c\x5a\x6d\x90\x41\x9c\x8f\x56\xe8\x5d\x0a\x57\x56\xd8\xc2\x71\x61\x1a\x38\x4d\x4e\x13\x50\xab\x33\xea\x63\x3a\xec\xc9\xda\x92\x06\x6a\xb2\x40\xd6\x78\x36\xa5\xa4\x41\x6e\x7a\x18\xb7\x53\x83\x61\x14\x32\x93\x6e\xd4\x98\xe1\xf0\x86\x90\xab\x57\xa9\xe9\x61\x05\xa3\xa7\xa4\x49\x05\xa9\x69\x33\x87\xfe\x75\xf7\x1f\x87\xa1\xfe\xf7\xfe\x5d\x5f\xdd\xfd\xc9\xf6\x0c\xe1\x4b\xc6\x20\xfc\xa3\xb0\xae\x7e\x92\x0e\x3a\x0d\x77\x5d\x16\x76\x99\x20\xeb\x09\x7e\x60\x09\x08\xbd\xa0\xb0\x01\x96\x62\x77\x23\x8f\x83\x1b\x85\xca\x11\xa7\xf4\xa1\x8c\x96\xc3\x19\x63\x46\xeb\xa6\x3e\x3b\x8c\x2a\x9f\xd8\x87\x72\xa8\xb0\x6d\x38\x40\xc2\xe7\xc7\xbc\x55\x8d\x6d\x43\x8d\x86\xa6\x54\x40\x0b\xb4\x7a\x83\x9a\x42\x14\x81\x73\x46\x80\x41\x40\x93\xcc\x04\x4b\xef\xbd\x65\xaa\x2c\x29\x29\x91\x52\xc2\xc4\x62\x77\x39\x19\xee\xdd\x25\x4b\x60\x18\x4e\x11\x36\x51\xe3\xa9\x86\x0b\x54\x4e\xcb\x95\x0b\xc2\xe6\xab\x64\x3d\x95\x98\x2f\xce\x8b\x77\x33\x66\x50\x11\xf5\x98\x38\x8a\x52\x20\x9d\x51\x8f\x54\x2c\x6b\xe1\xb1\x92\x55\xab\x86\xc5\xf4\x5a\x35\x62\x49\x40\xfb\xa2\x9c\x49\x99\x92\x2c\x4b\x76\x1f\x91\x8b\xc6\x90\x08\x37\x53\x11\x51\x44\x78\xa6\x22\x84\xae\x7c\x8c\xad\xf3\xbf\xed\x86\x17\x84\x09\x68\x43\x6c\x77\x2c\x28\x4c\xa8\xaa\xa2\x47\x08\x07\x9b\x7f\x80\x8d\x42\x0d\xf5\x22\x65\xbf\xba\x7a\xf5\xd5\x58\x4c\xae\xa9\x21\xb9\x49\x58\x87\xb6\x07\x13\xa2\x55\x45\x0a\x85\x25\x18\x76\xb9\x80\x3e\xa8\xaf\xaa\x54\xb8\xc2\x5c\x61\x5e\x71\x5e\x53\xac\xd8\x55\xc4\x43\x00\x8d\xd0\x0f\x31\xab\x42\x1e\xf2\x61\xbc\xd5\xf5\xb1\xb0\x35\xcb\xca\xd9\xeb\x63\x5c\x9b\x92\xe2\x44\x4d\x5d\x7a\x7f\x01\xd9\xa5\xaf\x81\xa9\x39\x9e\x52\x8d\x92\x22\x8e\xfb\x62\xa3\x45\x57\x24\x0f\x86\x6d\xd2\x2d\x34\x2f\xa9\x9a\xac\x70\xd6\xd2\xdd\x15\x7b\x27\x90\xdc\xcf\xab\xcf\xc6\x7e\xf8\xe8\x95\x6f\x3c\x7f\x68\x6f\x1f\x3b\x7a\x74\xdf\x5b\x21\xf5\xd4\x60\xe1\xc6\x17\x66\x4b\xfb\x9a\x58\x95\xb9\xaf\x69\x50\xb4\x71\xf5\x9d\x8b\xfa\x8f\xe6\x9f\x7e\xa0\xdb\x40\x31\x1f\xb4\xa0\x61\xe9\xf0\x1d\xfb\xef\xdf\xe0\xac\xed\x1c\xe9\xd8\xae\xc2\x54\x3e\x60\xc5\xc8\x87\x8e\xc0\xce\xbd\xaa\x15\xcc\xeb\x5c\xa7\xb9\x7b\xc7\x8f\xb1\xc4\xe3\x01\x35\xd8\x47\xb0\x83\xd2\xa8\x07\x20\x05\xc5\x1a\x58\xa7\xc3\xa0\x33\xe9\x1a\x63\x26\x97\xe4\x25\x10\x1f\x01\xa4\xe1\x13\xc9\x3e\x42\xd2\x3b\x20\x09\xad\x30\x5e\xe0\x14\xc6\x53\x4b\xf8\x08\xb5\xcb\xeb\xfb\xcd\xaa\xcc\xae\x1a\x14\xbd\x75\xf7\xa0\x21\xeb\x7a\xca\xbe\x82\x7e\xc2\x98\xd1\x03\xb5\x1f\x71\xe3\x27\x4f\x1b\x4d\xe8\xb0\x62\x7e\x3c\xc2\xdc\x8f\xe9\xa8\x8a\x62\xa5\x8d\x8c\x46\xab\x1a\x39\x9c\x58\xc6\x59\x46\xc4\x54\x24\x2d\xcf\x2a\x62\x02\x59\x25\x37\x29\x91\xfe\x9b\x0e\x55\x16\xaf\xe4\x53\x64\x96\x67\x44\xfc\x40\xcc\x09\xc7\x3c\x63\xa5\xda\x3d\xf1\xdc\x8e\x1d\x8b\x77\x06\x84\xe6\x2a\x98\xfd\x77\x4c\x6e\xe7\xe9\x97\xd7\x08\x1f\x54\x52\xc1\x23\x7b\xee\x7b\x74\xf2\x82\xee\x2f\x5f\x14\x3e\x6e\x5e\xf5\xcd\x2e\x97\x70\x94\x2a\xd2\x49\xbc\xb2\x03\xd3\xc4\x61\x1d\xc4\x83\xa2\xa8\x95\x66\x18\xa3\x0a\xb3\xaf\xd5\x66\x30\x30\xd8\x25\xc5\x7e\xa9\x91\xe1\x93\x40\x35\x29\xb6\xa0\x88\x8f\xa8\x90\x4a\x95\x52\xf3\xba\x69\xee\xfe\x4d\xc2\x57\xbb\x16\x76\x1b\x50\x3b\x50\x25\x7c\xe3\xfc\xcf\xa1\x77\xbe\xa2\x1e\x5b\xf7\x6a\x81\xf0\x21\xdc\xc7\xcc\x5f\x32\x75\xf6\xa8\x26\xfd\x63\xe7\xff\x11\xc7\x70\x7c\x4c\xf4\x1b\x89\x04\x5a\x10\xed\x12\x72\xda\xdd\x6e\x13\x54\xb1\x3e\x9f\xd1\xac\x35\x6a\xb3\xc2\x2a\x5b\xc8\x65\x02\x26\xec\xf8\x83\x90\x6d\x44\x6c\x6d\x68\x5b\x88\x52\x87\x9c\x21\x0a\x93\x0f\x4d\x08\x84\x40\xc8\x48\x19\xdd\x23\x62\x46\x13\x15\x1c\x11\xa3\x50\xab\xb0\x09\xe6\x59\xcc\xb5\xc9\xac\x90\xca\x54\x73\x56\x3c\xde\xe4\xd0\x91\x5c\xca\x64\xcc\x4d\x84\x7d\xcc\x24\xb7\xb6\x62\x22\x73\x20\x8e\xf3\xb8\x96\xd2\x49\xd8\x8e\xbf\x7f\xd4\x72\x6c\x2d\x9a\x3f\x61\xcc\xb5\xfd\xfb\x21\x7c\xad\x61\xcf\xdb\xef\x3e\x41\x29\x51\xb5\x8c\xec\x78\xf7\x73\x17\x61\xd7\x5b\x06\x0f\xeb\x79\xf6\x8e\x24\xbe\xa3\x45\xec\x1d\x58\x87\xb5\x9c\x87\xd8\xe3\xb4\xcb\x65\x81\x26\xc6\x6e\x57\x2b\xb5\x26\xad\xd7\xe7\xd4\x58\x80\x65\x64\x4c\x49\x03\x60\xa0\x0c\xfc\xb0\x98\xc1\xcc\x92\xc9\x44\x12\x65\x28\x09\x59\x11\xef\x97\x15\xb7\x5b\xcd\xa2\x68\xe2\x44\x30\x15\x9e\xe8\x79\x8a\x2b\x0b\x41\xd2\x5a\x3b\x80\x4f\x9e\x65\x32\x16\x56\x8b\x61\x78\xf2\xe4\xdf\x84\x5f\x3f\x9b\x4c\xf5\x1e\x7f\xbb\xb0\xbc\x01\x95\x50\x66\x72\x21\xd9\xf2\xdd\x85\x1e\xc2\xe7\xc2\x37\x58\x94\xda\x07\x09\x93\xb6\x1f\xec\x35\xe0\xc0\x7d\x52\xfe\x0e\xde\x9b\x97\xc4\x7a\xd5\xbe\xa2\x9e\x5e\x7b\x63\x13\xf6\x53\x2f\x8a\x7d\xbf\x9c\xe0\xde\x68\x83\x41\xa5\xc2\xea\x58\x69\x36\x6b\x2c\x76\x3b\x47\x21\x9d\x03\x39\x68\x2c\x63\xdd\x2e\xad\x8d\xb1\x0d\x8b\x19\x9d\x16\x27\xe6\xe5\x22\x0b\xfc\xd4\xf2\x83\x85\x42\xfb\x2d\x27\x2c\x54\xb5\x05\x16\x5a\x20\x6d\xb0\x40\x0d\x63\xb1\x00\x95\x82\x41\xb4\x09\x70\xc3\x62\x94\x98\x29\x2d\xca\x1b\xd1\x62\x95\x70\xf4\xf1\xff\xd3\x5b\xc1\x8f\xc6\xf5\x4b\x49\xaa\x01\x4f\x20\xf6\xb1\x86\xe7\x24\x89\x19\x42\x11\x1e\xeb\x7c\x1e\x46\xcc\x01\x0e\xeb\xfd\xc7\xca\x76\x97\xcd\x41\xaa\xda\xdd\xb5\xee\x75\x0f\x7f\x27\x3c\xfe\x24\x35\xbe\xa5\xfc\xbd\x87\x85\x0d\x63\xc6\x4c\x99\xc2\xd4\x61\xc1\x29\x61\xcc\x20\x0f\xec\xda\xa2\xbc\x2c\xb2\x25\x50\x91\xde\x7d\xa2\x6e\xcc\xc0\xd6\x77\x3e\x18\x16\x2d\x0d\xe6\xe4\x28\x32\x2d\x16\xb7\xc2\x40\x33\x05\x85\x7a\xc0\xe7\x04\x73\x1a\x62\xd9\x41\x43\xd0\x17\xa4\x8c\xc8\x15\x74\x05\x81\x46\xe3\x6b\x88\x19\xb1\xdd\xea\x02\xf6\xa4\x9a\x14\x1b\x35\x25\x18\x92\x6b\x6d\xae\x25\x94\x24\xcc\xe2\x4a\xc5\x2a\x31\xa2\x25\x4d\x1e\x6c\xb9\xc4\x91\xfc\x10\x89\xd3\xb9\x20\xf6\x42\x18\x8b\xad\x82\x9a\xb1\x6a\xec\x87\xbb\x21\x78\x62\xe9\xf7\xbb\x3b\xb5\x3f\xbd\xfb\x83\xf9\x0b\x04\xb0\xb4\x7a\x48\xaf\x19\x16\xa8\x2a\xbb\x71\x64\xdc\x02\x7a\xe3\x9d\xa7\x94\xed\x6f\x15\x2e\xaa\x4a\x2c\x79\x42\x94\xd2\x6f\x81\x39\x47\x7f\xbf\x4b\x0b\xef\x16\xba\x74\x17\xfe\x7d\x46\x29\xfc\x5e\x51\x53\x6b\xbb\x67\x07\x3a\x74\xcf\x42\x88\x84\x96\xe9\x3d\x5e\x3a\x58\x51\x38\x46\x94\x09\x63\xc5\x3e\xa1\x04\x5b\xb5\x3e\x9a\x6d\x44\x36\xac\xb2\xd4\x3c\x76\x15\x6d\x4e\x97\x55\xab\xd3\x12\x20\x14\x1a\x7f\x01\x8e\xf4\xa7\xe2\xa4\x8a\x25\x73\x9b\x22\xfe\xb4\x34\x2c\xa2\x24\xe4\xc2\x4c\xb9\x78\xa9\x5a\xac\x65\x25\x59\xe5\x62\xb5\x00\x4b\x95\x9e\xfb\xb7\x0f\x86\x2c\xb7\xd6\xf4\xbc\xe5\xa7\x9f\x84\x77\xa9\xa6\x5b\x6f\xfd\x8f\xe5\xa3\x0b\x79\x73\x66\xcd\x99\xf2\xed\x85\x1f\xbf\x12\x72\x2e\x7c\xf9\xe1\xef\xe4\x2c\xcd\x16\x06\xa1\x0f\x44\xfb\xcb\x43\x50\x65\x6c\x1a\xda\xc9\x9b\x39\xce\x43\x01\x5a\x43\x7b\x7d\x2e\x67\xd3\x10\x17\x40\x66\x8b\x19\x8b\x74\x8b\x45\x69\xb7\x63\x8b\xc5\x6e\x50\xea\x1b\xd3\xc3\xaa\x72\x6d\x97\x3d\x09\x41\x22\xf7\xa0\x13\xd1\xb7\x08\xd2\x4d\x7a\xa7\x2a\x99\x5e\xd2\xaf\x0a\x0d\x9f\x3f\x7f\xd6\xe5\xd5\x72\x9f\xaa\x05\x0b\x84\x87\xa9\x45\x62\xf7\xaa\x4d\x17\x84\xfc\xa5\xc7\x46\x48\x9d\xaa\xe0\x89\x0b\x5f\x4b\xd9\xa9\x14\xc9\xe3\x61\x6c\xcc\xad\x98\xe6\x4c\x82\x46\xe7\x41\x08\x1b\xe3\x2a\x4e\x15\xce\x32\x20\xad\x9f\x94\x30\xb2\xce\x11\x31\xd6\x6c\xc5\x72\x60\x78\x0c\xb4\xc9\x09\x6f\x55\xbd\x40\x30\xa1\xb0\x1a\x12\x01\xe1\x88\x69\x28\x97\xde\xea\x21\x3e\xf8\x89\xc6\x12\xf4\xd0\x9d\x0f\x0c\x5b\xfc\x5f\xe1\x07\xe8\x83\xcc\x53\x77\x2e\x29\x2e\xab\xf6\x76\xcd\x9a\xd9\x72\xb9\x66\x62\xa8\x76\xce\xec\xc5\x73\x84\x41\x2f\x9c\x1c\x54\x01\x27\xc1\xee\xb0\x1f\x9c\x3c\xaa\xdf\xb5\x1d\xfd\xfb\xea\xfe\xa9\xd2\x50\xd3\x4b\xda\x51\x3f\xc4\x7e\xb8\xfa\xa9\xb8\xde\x23\x30\xed\x3a\x6c\x4f\xf8\x41\x01\x89\xff\x07\x3c\x06\x03\xf6\x4a\xb2\x31\x43\x14\x15\xfa\x0d\xce\xcc\xfa\x98\xd3\x68\xc9\xab\x8f\x59\xac\x4a\x56\xcb\x92\x7e\x60\x7f\x4e\xbd\x6c\xe5\x60\x3f\x3b\x4e\x31\x29\x6b\x95\x53\xd7\xb8\x52\xd1\x27\x29\x2d\xaf\x40\x29\xdd\x5d\xcb\xe9\xce\xca\xf2\x8e\x84\xf2\xc0\xde\x7b\x64\x28\xd3\xf7\x5e\xb8\x3c\x92\x56\xb1\x49\x24\x53\xba\x6a\xcd\xe8\xe6\xfb\xea\x7b\x13\xf2\x0f\x9c\xfd\xc7\x90\xd1\x30\x0b\xea\x04\x58\xf2\x97\xc0\x6c\x67\xcb\x27\x29\xb0\xb0\x32\xa6\x86\x84\x21\xe6\x00\xbd\xa3\x99\x2a\x93\x89\xb5\xe9\xf5\xa4\xef\x9a\x53\xad\x66\x59\x97\x4a\xc7\x11\x99\x44\x7c\x0f\x8d\xc1\x44\x59\x87\x25\xf4\x4a\x24\x6e\x21\x26\x0a\x78\xb9\x48\xf2\x2e\x8a\xa8\x11\x09\xd6\x01\x06\x44\x98\x87\x50\x1c\xdd\x61\x2d\xfc\x9e\xc0\x3a\x6c\x59\x0e\x87\x0a\x47\x85\x4f\xf6\x0b\x1f\xac\x45\xb7\x89\xf0\x0e\xd4\xbf\xa8\xa1\x6f\xbd\xb2\xf6\x74\xb8\xe5\x38\x85\x5a\x5a\x28\x04\x9f\x4c\xe0\x3b\x90\xda\xc5\x4a\xb1\xb7\x47\xf7\x68\x86\x82\xe7\xf5\x8c\x4a\xa5\x56\x9b\xb4\x7a\x3d\x70\x7b\x1c\x54\x63\xcc\x61\x54\xe2\xf3\xd8\x14\x63\x74\x3a\xb5\xc9\xa0\xe6\x53\x80\xfb\x53\xb9\x3a\x25\x2a\x2e\x05\xfc\xe3\xe0\xfd\xc4\x58\x8b\x57\xc0\xd8\xe8\xca\x69\xa3\x97\xec\x73\x6f\xdc\x21\xfc\x6b\xd6\x2c\x97\x03\x1a\x32\xd4\x74\xc9\xd3\x6b\xc6\x8f\x45\xf5\xe6\x47\xef\xc6\x36\x2e\x9c\x7c\x61\x65\x9f\x37\x47\x2d\x1b\xb9\x66\x1a\x97\x58\xc7\x4b\xe2\x3a\x5a\xb0\xf7\x6a\xd1\x9a\x19\xc6\xc2\x6a\x58\x15\x07\x21\xc0\xde\x8f\xd5\xa4\xa0\x49\xae\x87\x5d\x63\xea\x41\xd3\xac\xd6\x82\xb0\x01\x3c\x32\xa6\xc7\x9e\x04\x6b\xd4\x4a\x40\x25\x12\x86\x92\xac\xda\x48\x40\x3f\x61\x0e\x27\x02\x14\xd2\x59\x14\x8b\x68\x31\xc9\xe1\x80\x2d\x50\x11\x80\x15\x21\x7a\xce\xa0\x37\x85\x6b\xd8\xb5\xfe\xe3\xe2\xc0\x46\x58\xd6\x0b\x9e\xeb\x03\xcb\x5a\x76\xcc\xfd\x8e\x7e\xf1\x82\x50\xd3\xf2\x1e\x95\x0f\x5f\xb9\xb0\x7e\xfd\xfa\x96\x37\x3e\x21\xb4\x8a\x31\x33\xb1\x0e\x2b\x80\x65\x79\x3b\xca\xe5\xe7\xec\x76\xb3\x9a\xb7\xf2\x2e\x14\xf4\x39\x1c\x00\x84\x82\x6e\x8e\x0b\xfa\x25\xb9\x61\x27\x82\xc3\x69\x35\x10\xc0\xc0\xa6\x14\xc0\xc0\x54\x7a\xa5\x5c\x35\x49\x82\xdb\x12\x52\x4e\x4e\x34\x45\x7a\xe2\x71\x97\xf9\x20\x81\x95\x45\x98\x70\x14\x30\xe3\x2f\x58\x6e\xaa\x08\x59\xe9\xc2\x69\xa7\x7f\xef\x30\x75\xf3\xe8\x09\x7d\x22\x91\x8e\xfd\x6b\xc2\xdf\x5e\x98\xb3\x04\xe6\x4c\x86\x43\xc7\xc1\xac\x96\x8b\x74\x3f\xe3\x9b\xa5\x48\x7d\xa1\x65\xcd\xe6\xad\x3d\x74\xaf\x31\x28\x6b\xf0\x1d\x54\xe9\x05\xd8\x4e\xb8\x0c\xdb\x35\xef\xb6\x43\x6b\xe9\x16\x32\x27\x72\xf7\x3e\x0a\xf3\x07\xe9\x2d\x15\x8b\x16\xe5\xa3\xb0\x52\x19\xb2\x38\x2d\x06\x44\x47\x4a\xf4\x9c\x22\xac\x68\x88\x65\x84\x42\xfe\x70\x98\xf3\xfb\xed\x0d\x31\xbf\x91\xd3\x34\xc4\x38\x2b\x28\x4c\x22\x06\xa5\xdd\x4a\x72\x92\x9e\x6a\x85\x39\x20\x5a\x46\x86\x44\xf9\x26\x76\x4a\xb3\xca\xe4\xa2\xea\x4e\x48\x0c\xa5\x74\x82\x12\x56\x08\x39\xb1\xc8\xfa\xd0\xc1\xb7\x2f\x7f\xda\xad\x5f\xcf\x3a\x25\xcc\x2c\x17\xa6\xbe\x71\x25\xa7\x9d\xdf\xeb\xc8\xce\x2e\xf0\x4e\x18\xa3\x66\x6b\x1e\x7d\x75\xd5\xad\x0d\xb9\xf3\x46\x2c\xa3\xfb\x3d\xb3\x63\xef\x01\x44\x57\x8c\x9b\xd0\xb3\x5e\x2f\x9c\x3a\x77\x1a\xae\x19\x52\xc7\x3e\xc8\xaa\x59\x7a\xfc\x98\xe9\xa3\x5b\x7e\xa3\xa8\x40\xcf\x9a\x07\xb7\xcd\x8e\xe3\xa5\xe2\xb9\xda\x41\x90\x64\x74\x79\xcd\x0e\xa0\xd3\x29\x54\x0a\x33\x0a\x65\xe8\xf0\x81\x30\x5a\xad\x6e\x11\x26\xd7\x4f\x60\x72\xd5\x3c\x32\xc4\x6b\xbf\x24\x95\xc4\xb5\xbe\x81\x94\xd3\x63\xe5\x8e\xca\xc9\x0c\x37\x73\x22\x0e\x82\x32\xd5\x2c\x54\xb3\x4a\xe1\x47\x46\x45\x0f\xfe\xf1\xc8\xab\x6f\x1d\xff\xec\x16\x34\x71\xfc\x85\x37\xc6\x4e\x41\x1b\xf3\x26\xf2\x77\xdc\xd7\xb2\x6f\xf4\x1a\xe3\x5d\xfe\xb3\xd8\xc6\x52\x41\x03\x0c\x9d\x12\xb6\x1c\x3a\x4e\x02\x3d\x67\x13\x38\xda\x98\x66\x07\x36\x53\x6b\xa3\x01\xa7\x43\xab\x35\xf9\x58\x13\x9b\x91\xc9\x1b\x8c\x3c\x70\x68\x1d\x2a\x24\x06\x5e\xad\x88\xf4\xc3\x4e\xc3\xc1\x21\x09\x91\xad\x7a\xd4\xc3\x24\xf6\x4d\x02\x5f\x5d\xc2\xc8\x32\x93\xad\x11\xc3\x97\x70\x5f\xf6\xae\xa9\x2f\xbf\xf9\xea\x91\x1f\x07\xd3\x2a\x46\xf8\x51\x49\x66\xa0\x86\x53\xc6\xbe\x71\x61\xfc\x44\xb4\x71\xe8\x48\xe1\xef\xc2\x7f\x84\x5f\x85\x0f\xcf\x86\x16\x1b\xd7\x8c\xa6\x06\xdc\x77\x87\x79\x6a\x8e\xb0\xe5\xc8\x59\x38\x0d\xce\x7c\x59\x92\x8f\x12\xfe\xf7\xfb\x78\xa5\x8b\xc8\x4d\x7d\x48\xaf\x73\xbb\x83\xb9\x3c\xaf\x08\xa2\x76\xc5\x7e\xde\xad\xb7\x9b\xec\x61\xd2\x3a\xc8\x54\x40\x30\x57\x90\xba\x31\x09\x4c\x92\x92\x53\xd8\x0a\xbe\xc7\x9c\x40\xea\x09\x05\x3d\xb0\x2d\x6e\x35\x9e\x0e\x4c\x85\xae\xde\x72\x70\xa7\x73\x45\xc8\xd4\x60\x5c\xda\x0a\xbe\x1a\xcf\x0a\xf2\x49\xc1\x7f\x64\xed\x36\xb5\xe2\x5d\x46\xb1\xb8\x53\x2b\x10\xeb\x35\xa3\x61\x45\x8a\xe0\x87\x60\x1e\x9e\xd7\x30\x91\x87\xca\xa3\x4e\xb5\xd5\x48\x5b\x69\xa7\x83\x31\x30\x06\x20\xfb\x3a\x40\x99\xb4\xd9\x5a\x01\xce\xc9\x46\x1a\xf6\x59\x45\xf3\x45\x5c\x6c\xc9\xe5\x21\x3a\x98\x1a\xba\xf2\xed\xbb\x0c\xd0\xa9\x9b\x54\xff\xf1\x07\x83\x87\x6b\x85\x2f\x7d\xcd\x27\x7f\x87\x7a\xe1\x17\xcb\xb0\x67\xa7\xea\x46\x8f\x81\x73\xe0\x44\xec\xf8\x3c\x75\x5a\x78\x5f\xf8\x05\x8b\xad\x8f\x44\x99\x74\xe3\x0c\x3d\x10\xd3\xe3\x11\x51\xa0\xb3\x83\x46\x23\xed\xb5\x5a\xd5\x2e\x8a\x06\x6c\x56\xd8\xec\x6f\x8a\xb9\x38\xb3\xc6\xac\x71\x28\x1c\x19\xf5\x31\x8f\xc3\xaa\xd0\x27\xe1\x92\x92\xa1\x97\x64\x32\x81\x44\x65\x05\x09\xdf\x92\x60\x8b\x55\x02\x5e\xe5\x6c\xc9\x4b\x61\xac\x9a\xf0\x29\x55\x60\x76\xc9\xaa\xea\xd5\x11\xea\x7f\x3f\x75\xcd\x2f\x7c\xa9\x1d\x3e\xf8\x03\xea\xa9\x27\x8f\xbc\xfc\xdb\x95\x93\x1b\x8b\xaa\xa9\xfb\x76\x4f\x5a\xd0\x79\xfd\xf1\x58\xac\x69\xce\x4e\x12\x65\x39\xfd\x94\xbe\x69\x94\xb0\xb5\xdb\xcc\x8d\x2b\x1e\x3a\x32\xb1\x7a\x30\xbc\x6d\xd4\x9c\x61\x12\xaf\x10\xdb\x20\x84\x6d\x31\x0f\xc8\xc5\x5a\x2a\x33\x43\xe1\x35\xe8\x3d\x1e\x9b\x49\x61\xca\xcb\x77\x5a\x1a\x49\x6b\x34\x00\xf5\xb4\x5a\x1d\x20\x59\x10\x34\x66\x1b\x3a\x7d\x81\x6b\x52\x11\xe0\xe4\xa6\xa9\xad\xe0\x8b\x49\x6e\x40\xd2\x56\x30\xa7\xa1\x18\x07\xd3\x30\x8c\xa1\x63\x69\x51\x95\x6b\x5a\xd9\x93\x3b\xa8\x04\x8e\xf1\xc1\x34\x14\x63\xb8\xfe\x8f\xcf\x16\x6b\xdf\x65\xb4\xfb\x0f\x50\x53\x13\x50\xc6\x92\x7c\xf9\x09\xf3\x7c\x00\x14\x8a\x59\x1d\x04\x8d\xd9\xe1\xcb\x56\xfb\xd4\xed\x8a\xac\xae\xc6\x98\x15\x20\x9a\xe6\x14\x32\x48\xbb\x22\xef\x26\x68\xcc\x5c\x8a\xd2\x4d\xa0\xdd\xdf\x0c\x8d\x39\x15\x22\xf5\xff\x85\xca\xbc\x6d\x6b\x9f\x41\x55\xae\xf2\x82\xff\x85\xcc\x3c\x6b\xe3\x66\xee\x5d\x6d\x79\x97\xe6\xf1\x6d\xf1\x99\xe5\x1a\x17\x4c\xaa\x1b\x9f\xe5\x6c\x87\x16\x9b\x38\x66\x33\xd2\x22\x8f\xd7\x81\x95\x01\x2d\xa3\xfc\x62\x05\x68\x30\x58\x1b\x62\x06\x23\x50\xb4\x3a\x03\x22\x82\x52\x2b\x16\x63\x92\x18\x04\x01\x91\xd5\xb0\x10\x32\x02\xe2\xa4\x10\x60\xe2\x21\x87\x6e\x80\x72\xa8\xb2\xcc\xe8\x35\x63\x79\x4b\x10\xb2\xdf\x3d\xfe\xfd\x5d\xc2\x0f\x2d\x63\x16\x2a\xe0\x45\xb4\xc0\xb2\x7d\x9d\xad\xb6\x66\xdf\x66\x25\x0c\xc1\x8e\x4b\xff\x38\x8c\xcf\xc3\x5f\xd1\xa1\x8d\x73\x17\xac\x6b\x4d\x6f\x6d\x34\xa8\x75\x38\x10\x32\xab\x31\xb5\x4e\x8d\xc6\xd9\x10\xd3\x98\x34\x26\x05\x50\x60\x4a\xf1\xf2\x1b\x52\xd4\x58\x22\x5a\x22\xf6\x42\x30\x25\xa3\x25\x40\xb2\xe2\x01\x57\x16\x48\x84\x4d\xcc\xa4\x0e\xc2\x8b\x09\x6d\x86\x26\xec\x42\x7d\x27\x5c\xa3\x3e\x59\x8e\xa9\xb5\x08\xbf\x55\x40\x70\x10\xbb\x4f\x42\xa9\x62\x21\xdd\x4f\xb8\x22\xfc\x8c\xbd\x26\xd8\x11\x86\x94\x9b\xf7\x61\x7f\x69\xfd\xb6\xe6\xfe\xf7\x2c\x9c\xb7\x41\x5a\xdb\x76\x98\xd6\x37\xc5\xf8\x7d\x0e\x18\x19\x8d\xd8\x73\xf3\x9c\x59\x59\x34\xe2\xfc\x1c\x96\xf4\x79\x61\x87\x12\x1f\xd7\x2c\x0e\x71\xd8\x3e\xa6\x91\x12\xf9\x7c\xf8\x1b\x0f\xf8\x10\x49\xf2\x00\x9e\x86\x34\xe2\xa5\xf2\x15\xb9\x2f\x76\xa2\xa1\x43\xc2\x7e\x13\x5d\x12\xcc\x3d\x15\x72\xfc\xcc\x26\xc6\xa0\xe2\xee\x7e\x26\x39\xe6\xe4\x7e\x0a\x4f\xac\x8c\xf1\x42\xb8\x6b\xdd\xf1\xcc\x67\xed\xda\x02\xbf\x3f\xe2\x29\x1d\x3a\x7a\xfc\x64\xe7\xeb\x2f\x1d\x3e\x06\xbf\x31\x76\x29\x6d\xf0\x7f\x55\xf4\xdc\x92\x6e\x5d\x84\x5f\x94\x51\xba\xdf\xd3\x07\xb2\xb6\xf4\x28\xb5\x59\x8e\xb6\x9f\x3d\xdd\x2e\xfc\x57\xf8\x14\x96\xc3\x1c\xe5\x98\xbb\x46\xdf\x63\xdb\xbe\xae\x39\xf6\xc8\xfe\xce\x6b\x97\x8b\xb2\x73\x39\x9e\xeb\x64\x3c\xd7\x4c\x30\x30\x5a\xe4\x36\x86\x54\x2a\xa3\xd6\xcf\x23\x36\x9c\xa5\xf5\xf9\x7d\xfe\x86\x18\xc5\x5a\xcd\x06\x9f\xcf\x87\x99\xc9\xe7\x63\xcd\x66\x47\x03\x16\xa8\x2c\xa8\x8f\xb1\x6d\x98\xc9\x54\x69\xaa\x4c\x35\x34\x24\xa4\x16\x3c\x27\x3a\x14\x4c\xa6\x34\x64\x44\xfc\xc9\x00\x62\x84\x97\x5a\xe5\xcd\x79\xf9\xc1\xdd\xa3\x85\x3f\xb6\xfe\x53\x68\x3e\xbe\xfe\xae\x3d\x50\xfb\x0f\x58\xfa\xe0\xf3\x45\x0f\x0c\x98\x30\xeb\xd5\xf7\x5f\xfb\x68\xfa\xde\x87\xd6\x8d\x1b\xbb\x77\xeb\x84\x7b\x35\x94\x6e\xe3\xf0\x65\x8f\x9c\x58\xd8\xa9\x7b\x97\x8a\x5e\xbd\x0f\x35\xf6\xaf\xeb\x4b\xe6\x31\x1c\xcf\xa3\x57\x7c\x1e\xc8\xa3\xb6\x86\x38\xd6\x61\xf5\xe0\x79\x38\x14\xac\x82\xc5\x06\x93\xdf\x68\x36\x28\x7c\x0a\x3c\x0f\x85\xc2\x6f\xf6\x03\x72\xeb\x62\xd6\x91\xd9\xfc\xdf\xe6\x21\xa7\x9c\xc4\xa3\x74\x24\x0d\x2d\x25\x1b\x83\x94\xec\x57\x58\xa9\x41\x23\xa6\x7f\x7c\xee\x9d\x73\xb3\x26\x0c\x7c\xa0\xf0\xf9\x07\x61\xe9\xa7\x50\xff\xe4\xd2\x0d\xc7\x84\xeb\x5f\xde\x2f\x5c\x1b\xbd\xfb\xc1\xbd\x7d\xeb\xfa\x37\x1e\xea\xd5\xbb\xa2\x4b\xf7\x4e\x0b\x4f\xec\x5a\x3e\x62\x83\x8e\xd2\xdc\x77\xc7\xd6\xbd\x63\xc7\xad\x7b\x88\xcc\xa3\x08\xcf\x03\x1b\x8a\xa0\x1d\x18\x13\x6d\xaf\x2c\xcc\x36\xb8\x10\xaf\xc9\x75\x15\x06\x15\x25\xc5\xd9\xf6\xdc\x5c\xad\x46\x8b\x8f\xb7\x0f\x4b\x2b\x1a\x68\x2d\x3e\xb7\xd6\xe7\x76\xfb\xb4\x08\xd8\xed\xa6\x86\x98\xdd\x08\xd8\xf4\x53\x2e\xb3\x9f\x08\x3d\x9d\x27\xcf\xa9\x32\x15\xc5\x41\xec\xb2\x89\x45\x54\xea\xe4\xe4\x5c\x35\xcc\x94\xc4\x95\xb3\x49\xce\xb2\x3c\x51\x16\xee\xdd\x76\x22\xf4\x45\xc6\xb4\xc5\x63\x97\x2f\x1c\x5d\x54\xbd\x48\xff\xa9\xf9\xfc\x43\x33\x1e\xcb\xba\xdf\xe4\xbc\xad\x7d\x5d\xc7\x9c\x95\x1d\x07\xcf\x77\x97\xac\x9c\xb2\xfc\x2d\xcb\x23\x5b\xf2\x1f\xdf\x78\x4b\xaf\x43\x5d\xeb\x3b\x76\xb9\xd7\x7a\xdf\xce\x81\x3d\xbd\xf3\xee\xcf\x3b\x6a\x0d\x0d\x1f\x7c\x7b\x80\xd2\x6f\xb8\xe3\x81\xfd\xd2\xdd\xb0\xbc\x77\x26\x90\x01\xea\xa3\xf9\x28\x68\xb4\xaa\x5c\x2e\xab\x5d\x1b\x64\x32\xb3\xec\x3a\xec\x0a\x61\x01\xa6\xf3\xe9\xf0\xd6\xe9\x74\x66\xcc\x85\xf5\x31\x9f\xd5\x0c\x6e\xb6\x75\xe9\xdb\x96\x48\x18\xb2\x46\x52\xb7\x2f\x2c\xa6\x83\x48\x69\x78\x92\xaf\x4d\x2d\x5f\xbc\x6e\xcd\x82\xfa\xa1\x43\x57\xcc\x19\xd6\xd8\xe7\xd8\x8f\x57\x17\xaf\x99\xf1\xee\xba\x66\xe1\x33\xe8\x45\x3b\x4e\x9c\x3e\x70\xbe\x7f\x74\x40\xf7\xe7\xeb\xfa\x77\xec\x72\x64\xd7\x82\x0b\x65\xba\x15\x13\x46\x6d\x6f\x80\x05\x90\x81\x34\x94\x70\x95\x27\x0a\xf5\xf4\x60\xec\x87\xf0\xd8\x06\x71\x03\x93\x09\x29\x2c\x0a\x06\xd9\xac\x88\xb7\xf0\xf8\xac\x58\x78\x35\x96\x6a\x6a\x37\x34\xc4\x41\xa3\x5a\xc3\x69\x64\x4a\x17\x11\x7c\xb2\x82\xb6\x1a\x06\xca\xa8\x28\xb4\x43\x70\x03\x24\x1a\x03\xd5\x9d\x44\x8b\x9a\x57\x9c\x6c\x92\xbb\x03\x55\x9e\xc4\xeb\xb7\x48\xe8\xc7\x68\xb1\x8e\x23\x77\xeb\xb7\x46\xdb\x15\x99\x73\xb0\x50\xf5\x67\x65\x21\x33\x2a\x2b\xf7\x04\x1b\x63\x1e\xa0\xd5\xe9\x9c\xd8\x94\xce\x27\xa6\x34\x4d\x03\xa3\xb1\x04\x9b\xd3\x3c\xc0\x8e\x04\x70\xa7\xad\x61\x2b\x9d\x17\xbf\xc0\x90\x83\x13\x89\x18\x4f\x45\xba\xee\x4b\x45\x5b\xb6\xb0\x28\x15\x7f\x74\xfc\xb1\xaf\x5d\xd0\x61\xb8\xbd\xf3\x98\xf1\x14\x95\xbf\x67\xf6\x91\x73\x52\x45\x1a\x0c\x4b\x0a\xf0\x86\x95\x54\xa0\x4d\x1a\x36\x76\xb2\xd0\x6f\xfb\xda\x40\xe7\x3e\xf7\x6d\xec\x30\x73\xf8\x38\x68\xc3\x6a\x50\x2c\x45\xc3\x36\x78\x50\x54\x83\xd7\x1f\xfa\xe2\x47\xf4\x09\xa9\x42\x7b\xf6\xa9\x97\x13\xb5\x22\x74\x6f\x13\x4b\x6a\x45\xf0\x1e\x90\x3c\x8e\xde\xa2\xdd\xd5\x29\x1a\xb0\x69\x3c\x58\xb1\x43\x12\x38\xa2\x60\x53\xcc\xa4\xa7\x28\xa5\x5e\xcf\x13\x1c\x50\xa5\x13\xbb\x7e\xd6\x56\x99\x9b\x69\x18\x37\xa4\xbb\x3a\x76\xf4\x44\x60\xfe\xa4\xbd\x25\x39\x4a\xa8\xd3\xf3\xf0\xd5\x61\x4b\xb7\xde\x2a\x5c\x17\xbe\x84\xb6\x3f\x5e\xfe\x2e\x4f\xf8\x5a\x7b\xcb\xe0\xef\x96\x2f\x2b\xeb\x5a\x0d\xc7\xbc\x2d\x54\xb5\x2f\x76\xc1\x20\x56\xe2\x1a\x98\xff\xd4\x9e\x70\x53\x83\xb0\xe7\xd8\x41\xbd\x57\xe4\xf5\x32\xcc\x27\x0f\x88\xb8\x45\x6e\x50\x1c\x75\xda\x54\x26\xc4\x21\xc0\x6b\x55\x3a\x85\xc7\xcb\x1b\x58\xa3\xce\xc0\x3a\x31\xc3\xb8\x13\x81\x89\x54\x29\x04\x6d\xd6\x24\xb4\xb9\x04\x8c\x4c\x12\x48\xe5\x1a\x07\x6b\x97\x91\xfb\x77\x3d\x7c\xb8\x73\xa3\xb0\x1c\xe6\x60\xce\x34\xc0\x2c\x21\xbb\x28\xfb\x96\xfc\xdc\xdc\x02\x68\x98\x7f\x68\xcc\xa6\x87\x77\xaf\xaf\x3a\xb4\x05\x75\x68\xd9\x46\x8d\xbb\x5e\x57\xbc\xba\xdb\xa3\x43\x4b\x3b\x54\x11\xba\x14\x04\x4b\x1e\xaf\x9d\x06\x14\x80\xaa\xa8\x4f\xa5\x47\xf9\xc1\xfc\x6c\x4e\x6f\x63\x0b\x8b\x32\x2d\x0e\x6c\xf1\xb1\x6e\xad\xdf\x61\xd4\x02\x82\x69\x92\x24\xae\xd5\x2d\x86\x8c\x1d\x26\x26\xad\xd9\xfc\x84\xca\xb0\x94\xb3\x1b\x29\xf1\xc1\x8a\x04\x52\x96\x01\x12\x08\x11\x6a\x42\x66\x61\xa8\x5d\x71\xb0\x20\x4b\x78\xa3\x64\xf4\x80\x9c\x58\xfd\x2d\xdd\x17\x6f\x7a\xa9\xa9\x67\xf7\xbc\xe5\xb7\x6f\x5a\xdc\xfd\x96\xfa\x58\xce\x80\x5e\x25\xce\x7d\xed\x72\x42\x43\xfb\xd4\x0f\x09\xe4\xb4\x3b\xfd\x7b\xc7\xf5\x87\x9e\x19\xdc\xfd\xdc\x94\x47\xd6\xac\x69\xea\x3b\xe5\x5c\xf7\xc1\xcf\x2c\x9b\x34\xac\xe0\x77\xb2\xff\x8b\x85\x29\x74\x27\xbc\xb6\x62\x3f\x1b\x15\x6b\x35\x98\xcd\x26\xd6\x64\xb3\x9b\x5d\x56\x00\x90\x51\x61\x10\x93\x58\x93\xc4\x73\x91\x56\xe1\xb7\x4c\x19\x8c\x2d\x05\x61\x2e\xc0\x95\x56\xa0\x1c\x31\x69\x15\xda\x49\xd2\x2a\x69\x67\xaf\xfc\xdb\xa2\x69\x17\xdf\xa3\x9e\x6d\xd9\x4c\x32\x55\xa9\x2e\xd7\x4a\xe1\xd6\xc9\xe3\x45\x1e\x14\x73\x6a\x45\x7b\xb3\x3a\xea\xd7\xa8\x29\xec\x82\x58\x2c\x6e\x35\x0a\x05\xed\x3e\x82\x94\x8a\x28\x8a\xd5\x58\x78\xd6\x80\x17\xd4\x98\x4a\x49\x2b\x6c\x08\x68\x91\x3c\xa9\xf4\x64\xda\x14\x57\x8b\x87\x7b\x95\x74\x5a\x32\xed\xe1\xed\xb2\x5f\x45\x57\x4c\x1e\x9f\x9e\x4a\x4b\x1f\x5d\xfb\xa0\xe4\x4c\x89\x34\x92\x9e\xc7\x98\xc6\x3c\xd0\x2d\x9a\x45\x01\x0f\x66\x3c\xb5\x3a\xcb\xe8\xa5\xf3\x0b\x82\x39\x8d\xb1\xa0\x48\xa4\x97\xd7\x99\x1b\x63\x3a\x17\xeb\x48\x52\x2a\xdd\xa5\xa6\x11\x2b\xd7\x30\x25\x88\x4d\x22\x1b\x94\xfd\x3f\xc8\xde\xf9\x44\xbb\x59\xee\xaa\xa2\xbb\xfe\x8c\x78\xf4\xec\x3e\x0d\xfb\xae\x76\x11\x75\xa6\xed\x1c\xa8\x14\x2c\x74\x1e\xdc\x16\x2d\xe6\x01\x4d\x9b\x52\xf0\xd0\xad\x36\xb3\xa9\x29\x66\x06\x04\x15\xbd\x29\x05\x15\xdd\xf0\xbf\x50\xd1\x13\x66\xbe\x29\x11\xf6\x69\x0d\x8d\x9e\x08\x14\x3b\x3f\xf9\x44\x82\x47\xff\xe4\x13\xb1\xe1\xbd\x1c\x24\xfe\xed\xe4\x49\xa8\x8a\x47\x87\xc9\x5a\xcf\xbd\xf1\x2d\xfa\x50\xcc\x63\xcc\x8a\x5a\x54\x34\x4b\x1b\x90\xc5\xac\xc0\x1a\x4c\x61\x00\xba\xc6\x54\x5d\x1d\x47\xb0\x22\x28\x51\x22\x2a\x4b\x02\xfd\x11\xd1\xcb\x77\xf7\x16\xae\x52\xa5\xb6\x48\x51\xe3\xe8\xda\x61\x96\xa6\xdd\x1b\x29\xcd\xc9\x96\xba\xbe\x51\xaf\xed\x6f\x0e\x7d\x02\xd7\x1f\xbf\x47\x43\x90\x73\x14\xb4\x4a\x05\x58\x08\xa0\x56\x47\xe6\xdb\x88\xe7\x8b\x34\x40\xd3\x98\x86\x42\x94\x06\x0e\x13\x07\xee\x97\x7b\xfa\x8b\x80\xfd\x12\x5c\xbf\x70\x96\xae\xba\xda\xb2\xe1\xea\x55\x6a\x46\x6a\x0f\x79\x07\x18\x14\x2d\x04\x4a\x25\xaf\x53\xd1\x3a\x93\x4d\xc3\x3a\x5d\x26\x85\x02\xeb\x64\x05\x1f\xe5\xf5\xa4\x27\x0c\xaf\x91\x02\xf4\x62\x27\x81\xfa\x98\xa6\xf5\x92\x9f\x15\xd3\x25\x2e\x89\x8d\x27\x52\x15\x21\x01\x70\x8d\x88\x77\x90\x22\x2d\x58\x94\x84\xb0\x18\x91\x30\xe9\xc3\xc1\x25\xc3\xee\x90\xd6\x3d\xd7\xbd\x74\xe4\x18\x11\x99\x5e\x43\xe5\x57\xde\x3f\x87\x11\x86\x9e\x3c\x49\x79\xa8\x82\x8a\x7b\x17\xb0\x70\xed\xc9\x14\x1e\xc1\x46\x39\x18\x16\x8d\xb8\xf4\x98\x49\x6c\x26\x15\x43\xa9\xf4\x16\x05\xeb\xf5\x21\xb5\x4d\x8d\x15\xa0\xcd\xee\xe0\xb0\x55\x6b\xe3\x6c\x9c\x82\xe7\x2d\xd8\x8a\xff\xf3\x96\xf7\x69\xc8\x3a\xb6\x44\x14\x36\x9d\x4d\x44\xf1\x2c\x75\x10\xc2\x4e\x62\x90\xb7\x44\x90\x73\xee\x5c\x89\x6c\xd3\xbc\xad\x9b\x67\xdb\x24\x96\x31\x0d\x1f\x4e\x3d\x78\x48\xb8\x82\x79\x26\x77\xd3\xb4\x19\x9b\xa0\xff\x64\xf3\xc5\xc7\xeb\x07\x90\x75\xfe\x14\x9f\x51\x5a\xc4\x9d\xc1\x7c\xa3\x01\x3a\xc0\x20\xce\xa8\xd7\x91\x7e\xaa\x4a\x2a\xed\xc2\x23\xce\x37\x29\xae\xb4\xb4\x58\x92\xcb\xfc\xc4\xc3\xe4\x65\x03\x44\xdf\xf8\x99\x43\xcc\x90\x93\x12\x5f\x2e\x13\x6e\xa1\x77\x89\xfe\x7d\x13\xb6\xb8\x3c\x1e\xc0\x3a\x5c\x0c\xaf\x52\x31\x0e\x03\x60\xbc\xa4\x4b\x95\x88\x5e\xe5\x62\xdc\xc8\xdd\x14\x73\xb2\x2c\x76\xd8\x0c\x50\xee\x61\x46\xf2\xfe\x53\xd1\xa2\x5a\x65\xde\x91\xcc\x0a\xc2\x4a\x22\xb2\x19\x08\xc5\xdb\x82\x95\x91\xa0\x79\x19\x0c\x70\xcb\xf0\x59\x79\x4d\xb8\xf2\xd4\xcb\xc2\x07\xbf\x1e\xba\x56\x0e\x61\xdf\xed\xcb\xe6\xec\x38\xe4\x80\x36\x61\x3c\x73\x51\x98\xf2\xaa\xb0\xc9\xf3\xef\xe7\xff\x2d\xfc\x67\xcd\xd2\x8e\xf7\x6c\xda\xb1\x79\xd5\x09\x78\x5b\xf3\x7d\x12\xdd\xa4\x07\xc7\x1a\xcc\xe7\x61\xd2\xf3\xd6\xef\x21\xb8\xfe\x46\xb5\x5a\x9f\x45\x4a\x4d\x12\xb8\xfe\x06\x82\xeb\xdf\x40\x70\xfd\xf9\x74\x5c\x7f\xae\x2d\xda\xe5\xff\x1d\xd4\x3f\xb3\x24\xd2\xe1\xcb\x04\xa8\xff\x20\x33\x95\x3d\x75\xe0\x9c\xb1\x57\xc9\xc7\x74\x55\xcb\x94\xad\xb3\x5e\xde\x46\x75\x6b\xde\x1f\x07\xf5\x9f\x70\xeb\xbe\xb7\xa9\xb7\xc9\xe7\x8f\x3e\x4a\x4a\x7b\x30\xed\x78\x4f\x97\x89\x58\xa3\x3d\xa2\x19\x1e\x27\x0c\xe9\x14\x1a\x8d\x5a\x1d\x72\xa2\xcc\x2c\xb3\x4e\x6b\xb1\xd8\x32\x94\x2e\x03\xed\xb7\x61\xb7\xcb\x68\xb3\x8a\xad\x64\xfe\x8c\xf8\xb6\xd4\x87\xb8\xff\x07\xe9\x6f\xff\x2f\xba\xaf\x79\xa8\xc1\x37\xa3\x9a\xd0\x5d\x27\xd2\xdd\x0f\x14\x13\x5e\x31\x10\xe4\xff\x62\x60\xcd\xc8\xf1\x7a\x33\x80\x8a\x2e\x89\x04\xc2\xf5\xb1\x80\xab\x80\x36\xd3\x0d\x31\xa7\x19\x13\x6e\x34\x18\x54\x09\x28\x19\x89\xee\x14\x14\xdc\xd4\xac\xa8\x9b\xe0\xc8\xc8\xdd\xfd\x6d\xff\x43\xa1\xc0\xff\xca\x5b\xc1\x52\xc1\x3b\xfa\x26\x66\xb4\x72\xad\xa8\x50\x96\x92\x7f\xa4\x36\x6d\x9e\xf3\xf2\xb6\x96\x63\xa8\x29\x75\x3b\x9a\xdf\xda\xf3\x98\x86\x3d\xa5\x5d\x4c\x5d\xdb\x3c\xe7\xd1\x47\x5b\xf6\x88\xf3\xbb\xf1\x04\xd1\x87\x74\x7f\xac\xb3\x3b\x45\xfd\xac\xd5\xea\xa6\x02\x7a\x5d\x40\x17\x0c\x39\xb0\xca\x76\xb8\x14\x2c\x4b\xe9\x79\xb5\xa9\x31\xa6\x36\x52\x71\xfb\x3d\xa1\x06\x2b\x53\xd0\x1a\xcc\x69\xad\x0d\x12\x13\x4b\x99\xc2\xc6\xd4\x3e\x07\xff\x22\xad\x0f\x1e\xd9\x2d\x51\x9d\xd2\xeb\xa0\xa5\x81\x9a\x28\x36\x40\x18\xb7\x7f\x0f\x51\x81\x8b\xc5\xfe\x0b\x83\x98\xaa\x38\x8d\x01\x97\xd5\xa0\x50\x68\x94\x56\x65\x28\xe8\xb5\x37\xc6\xbc\x2e\x33\x6a\xc4\xde\x10\x5e\x78\xa5\x9c\x23\x2b\xd1\x07\xec\xe9\x7d\x18\x12\xe5\x48\x6d\xfa\x30\xa4\x48\x8f\x9b\xb4\x64\x90\xa3\x6f\x3b\x65\xba\x52\x1b\x33\x34\xb7\x88\xa2\x65\xdf\x41\x89\x57\x08\xa6\x43\x37\xcc\xe3\x3a\x50\x18\xe5\x35\x58\x0d\x51\x0c\xc3\x02\xd6\xa0\x57\x51\xac\x56\x61\x80\xac\x84\x2f\x94\xcc\x34\x8a\x9f\xc3\x1c\x48\x5a\x55\x84\xa4\x06\x15\x11\xba\x9b\xf0\x1f\x21\xaa\xbe\x06\xb3\xe1\x93\xea\x6b\xd4\x6f\xe3\xc7\xb6\x5c\xc1\xcc\xca\xaf\x6e\xa4\x4c\x62\xde\x82\x98\xb3\x8d\x79\x52\x8d\x2d\x00\x3b\xc1\x00\x35\xf0\x3c\xd0\x5b\xad\xf8\x5d\x4e\x87\xde\x5a\x1f\x13\x11\xc4\x8d\x48\xaf\x47\x2a\x95\x46\xac\x90\x37\xd5\x27\x8c\xbf\x34\x87\x31\x8d\x0c\xd2\xa3\x4e\x74\x09\x23\x7e\x46\x0a\x7b\x21\x29\xa8\x44\x4f\x17\x7e\xbc\xf1\xab\xf0\x23\xd4\x0b\x94\xaa\xe5\xfa\xe4\x29\x1a\x78\x46\x33\x7e\xce\x84\xa9\x7a\xa1\x56\x3f\x89\xf2\x0a\x3f\x0b\x1f\xc1\x4c\xa8\x83\x5a\x98\xf1\xca\xca\x7b\xef\x5b\xd1\xe2\x5b\x74\xf7\x5a\xd1\x56\x29\xc1\xb4\x3e\x81\x69\x25\x75\x56\x77\x44\x3b\x60\xb3\xd4\xa6\x26\xbd\x9a\xac\x1c\xaf\x65\x82\x01\x82\x6b\x09\xac\x6a\x8d\xc1\xe0\x33\x60\x8a\x0d\x06\xab\xc6\x6a\x6e\x8a\x59\x79\x8d\xbe\x29\x86\xb7\xd3\x51\x1f\x53\x1a\x29\x5f\x7d\x8c\xb2\xa6\xc3\x4b\xb5\x89\x58\xa4\x41\x87\x64\x26\xef\x3e\xca\xe2\xdd\xb2\xf1\x97\x39\x91\x05\x4a\x8d\xbd\x65\xfa\x81\x93\x27\x8e\x4e\x1d\x40\xd5\x08\x4f\xc1\x22\xe1\x6d\x38\xa8\xe5\x15\xf8\x64\xbf\xae\xb5\x3d\x9e\x2d\xeb\x09\xb3\xf0\x54\xf0\x64\xba\x14\x5d\xf8\xf4\xc2\xef\x97\x28\x2f\x9c\xba\xf7\xfc\x89\xe7\xf0\x7c\x3a\xe1\xf9\x6c\xc4\xf3\xb1\x80\x1c\xd0\x35\x1a\x44\x61\xad\xca\x64\xb7\xab\xc2\x28\x37\xcf\xe7\xf7\x63\x81\x86\xfd\x98\x10\x36\x71\xdc\x21\x2b\x8f\xdd\x05\xde\x08\x52\x5d\x5e\x4c\x71\x7a\xcd\x4b\x8a\x8f\x5e\x8d\xd5\x68\xdc\x59\x0f\xfb\x41\xfc\xa2\x3e\x24\x23\x60\x63\x47\x7d\xdc\x5d\x8f\xe4\x67\x86\xcb\xaf\x46\x72\x33\x0a\x76\xac\x82\x6a\xe8\xeb\xbf\x69\xd8\xa8\xc9\x36\x64\x9b\x3c\xea\xf6\x4d\xf5\xd0\x89\xee\xfe\xe4\xe8\x43\x07\x9e\x5c\xf1\xd0\x43\xcb\xf6\xbe\x7c\xef\xcb\x7f\x3d\x2b\xbc\x26\x7c\xfe\xe8\xf7\x8b\x17\xce\x9c\xb9\xf0\xae\x1f\x77\x62\xbf\xac\x54\xe4\x1f\x11\x57\x83\xe4\xf4\x91\xa6\x25\x7d\xa2\x59\x9c\xc5\x40\xd3\x0e\x2d\xc3\x00\xab\x0a\x90\xb6\x11\xc0\xec\xd4\x62\x4f\xcc\xa0\x35\x5a\x1c\xa4\x5f\x04\x62\xad\x8c\xeb\x66\xe9\xc9\xad\x01\xf6\x48\xdb\x3b\xcc\xc8\x59\x54\x59\xa9\xa9\x02\x4f\x90\x86\xc6\x30\x57\x0e\xb1\x43\xc4\xb1\xf4\xf4\x2b\x6f\xbc\x7f\xee\x83\xf7\xdf\x78\x1f\x3e\x2a\xfc\xbe\x6d\x5b\x4b\x73\x63\xd7\xfb\x29\xef\xf7\xc2\xe7\x5e\x61\x14\xdc\xe9\x86\x81\xef\xbf\x83\x1e\x2f\x5c\x25\x2c\x2c\x17\x74\xb0\xa8\x73\x8b\xbf\x0e\xe6\x3d\x74\x38\x40\xfd\xbd\xbb\x78\xbe\xb6\xe0\xb5\x57\xe0\xf3\x65\x01\xf9\x51\x2b\xa3\xd7\x2b\x81\x92\xb7\x9a\xb0\x45\x60\xb2\xea\x0d\x06\x56\xcb\x93\xae\xea\xad\xa5\x53\x71\xbb\x8a\xb8\x3f\x43\x60\xa7\xe5\x05\x0d\x6f\x99\x36\x7a\xe7\x0b\xd0\xee\x72\x08\x3f\xc5\xef\x84\xbf\x36\x7f\xfb\x0a\x7c\xbe\xa5\x4b\xca\x7d\xb0\xfc\x4e\xbc\x56\x89\x77\x2a\x81\x95\x4f\x7b\x27\xf8\xff\xfa\x4e\xd4\xe3\xfa\xa1\xf4\x77\xe2\xfd\x39\x81\xe7\xe9\x24\x59\x15\x8c\xd9\x8c\xe7\xa9\x43\x6e\x97\x85\xc7\xfb\x65\x67\xed\xf8\xe5\x76\xab\x56\x6d\x54\x37\xc6\x8c\x2e\x71\xca\xad\x0c\xb5\x54\xa7\x34\x49\x48\x8a\x89\x94\x46\x8e\x24\xdf\x1e\xdd\x94\xba\x08\xd7\xa7\x2e\x20\x82\xed\xc9\xa3\x30\x22\x12\x05\xc1\x39\x4c\x53\xa5\xc8\xf7\x78\x1d\xf4\x2c\x8b\xed\x5d\x79\xed\x8d\x06\xbd\x5e\xa1\x31\x28\x5c\x37\x5b\x07\x98\x10\xb8\xad\x6e\xe5\x77\xbe\x20\xfc\xab\xd5\x85\xfc\xb7\xaf\x34\x3f\x4a\x8f\x4d\xac\x44\xf2\x9d\x5e\x6c\xd7\xbb\xed\x1a\x16\x0f\x04\x38\xbf\xcf\x8d\xdf\xea\x36\x3a\xec\x76\x3d\x6f\xd0\x63\x03\x5f\xef\x02\x6d\xd5\x92\x2c\xf0\x65\x25\x94\x32\xf7\xb6\x84\xc4\x05\x7c\x1b\x72\x5a\x7e\x95\xc5\x3b\x52\xa7\xed\x0f\x76\xb8\xe9\x2a\x4c\x97\x16\x84\xa3\x26\x86\x65\xb5\x3a\xec\x86\xb0\x6a\x35\x45\xb4\x24\xdb\x36\xb7\x50\xa4\x43\x54\x8a\x62\x66\x0b\x5d\x39\x70\xbd\x70\x0c\x7b\x4d\x6e\x58\xb0\x7d\x18\xea\x6b\x13\xce\xb7\xbc\x4f\xe5\x42\x13\x34\x39\xc4\xf1\x37\x0b\x83\xd0\xfb\xe2\xf8\x99\x51\x0e\x6b\x60\xa0\xd7\x69\xb5\x94\xc2\x45\xe1\x1d\xa7\x8c\x89\xb4\xde\xc4\xe8\xe6\xf2\x88\x1f\x88\xc3\x07\x82\x8a\xcd\xc3\xb6\xc3\x02\xe8\x16\xbe\x12\x8e\xad\x1f\x48\x97\x39\x84\xef\x85\xef\x9b\x0b\xd0\x7b\xb0\x92\xe4\x7e\x88\xb5\xb1\x7b\x44\x1d\x65\x01\x95\x51\x2f\xa7\xd0\x43\x48\x51\x6a\x85\x86\xb6\xf2\x7a\xec\xc2\xe8\xf5\x14\x42\x16\xec\xc3\x18\xb4\x14\x9f\x92\xab\x97\x7e\x57\x42\x32\x17\xe4\xec\x42\xd2\x9f\x8a\x84\x50\xf3\x20\x7c\x5c\xf8\x27\xfc\xea\x87\x6f\x66\x4f\x87\xb5\xc2\x1b\xc2\x8f\xa7\x2e\x9f\xb8\x74\x1a\x1e\x11\xfa\xd2\x55\x3b\x1f\x9e\x7b\xbf\x5b\xc8\x81\x47\xf6\x6d\x7d\x40\xba\x67\xc8\x22\x35\xba\x32\x1d\x9d\xa3\x19\x9c\x02\x58\x2c\x08\x11\x3a\x78\xab\xce\x90\x12\xf3\xa4\x21\x76\x6b\xcd\x0d\x31\x9a\x4f\xa6\xab\xa4\xb5\x66\x4c\xd0\x13\x8f\x0c\x41\x1b\xf1\x3b\x3a\x40\x94\x03\x9d\x82\x83\xd0\x23\x9c\x84\xe5\xd0\x28\xd2\x43\xad\x86\x47\xae\x9f\x13\xe9\x81\x57\x84\xbe\x32\x3d\x10\x2c\x90\xf3\x8b\x4b\xc0\xa8\x68\x65\xb8\xd8\xa9\x63\x03\x01\x73\xbe\xae\x98\x89\x94\xe6\xe5\x14\xe6\x34\xc6\x0a\x5d\xac\x33\xc3\x98\x81\xea\xb1\x61\x88\x65\xb1\x1a\x01\x90\x61\x35\x62\x27\x6f\x9a\x05\xfa\x2c\x45\x16\xca\x62\x31\xe2\xbd\x89\x14\x0d\x1d\x2a\x92\x99\x88\xc8\x56\xde\xa4\x38\xef\xff\x90\x57\x8c\x0f\x28\x6f\x49\xb6\x1e\x80\xd3\x65\x38\xd9\x3f\x49\x29\xde\x3a\x02\xb3\xf1\xa0\xfe\x4f\xee\x80\x11\x19\x59\xf6\xe6\x99\xc4\x85\xb3\x16\x6b\x2f\x71\xfb\x0f\xc0\x21\xd2\xbc\xff\x8e\x79\xed\x67\xe6\x3d\x6c\x47\x14\x45\xed\x2a\x2b\xb2\x1a\x91\xd3\x41\x3a\x28\x36\xc6\x74\x80\xc6\x16\x45\x63\x6a\xe2\x56\x5a\x6b\x84\x64\x16\x59\xda\xe5\x1f\x0b\xe7\xe6\xdd\x66\xa9\xe8\x51\x5b\xfd\xf2\x99\x58\x6d\x6e\xdf\xee\xb5\xc7\x84\x41\x7a\xc5\xfb\x7c\xfd\x6c\x7a\xec\x6b\xcf\x99\xaf\xf0\x83\x27\x5e\x7f\xf0\xfc\xf3\xe9\xef\xf7\x83\xee\xd1\x2c\xe8\xf3\xe9\x4d\x4a\xa3\xc9\x6f\x67\x02\x41\x3d\x20\xf7\x14\x9c\x9f\x77\xb8\x78\x57\x63\x8c\x77\x29\xd5\x0c\x3e\x00\x0c\x00\x69\x35\x50\x6d\x83\xc9\x91\x34\x7a\xa4\x4c\xbc\x44\xca\x5b\x35\x0c\x41\xc5\xbb\x71\xca\x76\xec\x38\x76\x46\x26\xf6\xdd\x93\x68\x9b\x4c\x5d\xf3\xb2\x93\xf9\xe7\x9f\x97\x48\x36\x60\x1a\xbf\xc0\x34\xfe\x48\xf7\x95\xd6\x08\x19\x6d\x46\x15\x72\x38\x09\x4a\x7f\x63\x4c\x6b\x24\xc9\x6d\xff\x6b\x8d\xca\x12\x58\xfd\xa2\x45\x2f\x67\x5b\xa3\x5b\x5f\x39\xde\xa5\x5b\x8f\xdc\x2e\x4d\xaf\x9c\x70\x54\x14\x75\xa9\xe8\x2c\x0c\x7a\xee\x35\xea\x1f\x13\x07\xf3\x57\xcc\x47\x5f\x6f\x09\x0c\xea\x91\xc5\xbf\xcf\xcb\x67\x45\xac\x8d\x7b\x4f\xc4\xa2\xe9\x11\xcd\xf2\xda\xb5\x7a\xbd\x27\xc3\x64\x64\x8d\x19\x76\x3a\x37\xcf\x15\x6e\x8a\x71\x1e\x97\x8b\x47\x7c\x00\x5b\x1c\x2e\xa4\x4c\xc9\x5d\x90\x4e\x6f\xea\x75\x7a\x9c\x05\xd3\x36\x4d\x81\x19\x30\x2c\x49\x48\xf1\x73\x46\x8a\xf7\x8a\x3c\x49\xad\x8f\x2f\x97\x7b\x51\xf1\xde\x69\x23\x5f\x1a\xbd\xef\xcd\x97\xf7\xde\x3b\x53\x58\xd9\xa7\x53\x8f\x45\x5c\xc6\xdc\x0e\x35\xbd\xe8\x41\xf1\xb5\xeb\x39\xaf\x61\x69\xf7\x07\x56\xf5\xad\xd9\xbb\x71\xdd\x93\x0d\x5f\x95\xb5\xef\x56\x5a\x50\x52\x29\xee\xf5\x19\x7c\xe6\xf3\x99\x11\x78\x1d\xb1\x1d\xaf\x62\x00\x42\x14\xc5\x28\x8c\xb4\xc3\x89\x14\x04\x90\x15\x28\x95\x16\xc6\xa2\xaf\x8f\x59\xe8\xd4\x0c\xed\x48\xdb\xe3\x43\x92\x91\x24\xf8\x5e\x31\xa7\x4e\x51\x26\xc1\x07\xf1\x68\x25\xe9\xa8\x22\x2c\x81\x4b\x03\xbd\xba\x88\xed\x41\x96\xec\x1b\x00\xff\x76\x12\x0b\x26\xe7\x49\xca\x34\xb8\x3a\x44\xfa\x82\xd4\xdd\xbf\x4c\xa4\xe7\x51\x61\xb0\xd8\xff\xc5\x0e\xca\xa2\x6e\xd2\xff\xc5\x6e\x54\xda\x21\x26\x47\xa4\xc1\xf5\x27\x00\xd1\x29\xd1\x9a\xd6\x1d\x5e\x52\xba\x95\xa4\x36\x76\x49\x74\x29\x11\x2b\xc6\x9a\x9b\xd2\xda\x93\xe0\xfd\x75\x63\x1b\x63\x9f\x98\xc7\x15\x02\x03\xa3\xf9\x30\x10\x70\x5a\x29\x9f\xcf\xc8\xa8\x14\x2a\xab\x9d\xce\xc8\x34\x72\x7e\xa5\xdd\x61\x6f\x88\x31\x90\x73\x38\x74\xc8\x65\x30\xbb\xb1\xcf\x63\xd5\x25\xda\x70\x60\xa1\x58\x99\xcc\xe1\x4a\x0d\xcf\x24\xe5\xa3\x74\x14\xe4\xd6\x1b\xe4\x44\x88\xe9\xaa\x1c\xc9\xae\x24\x59\xd5\xf0\x11\xb8\x10\x3a\xe6\xcd\x8b\xf7\xdf\x98\xf8\xf1\xe3\xfb\x26\x4e\x84\x7f\x89\xcd\xa2\x84\x95\x31\xba\x4a\x18\x07\xb7\x09\xe3\x0e\x09\x52\xf3\x8d\x6f\xde\x7e\x73\xcc\x21\xb8\xad\x79\xc5\xfe\x95\xfc\xdd\x9b\xa5\xb3\x4c\x7a\xef\xae\xc0\xf3\x28\x01\x1d\xa3\xfe\x90\xd1\x6b\x2d\x44\x39\xd8\x76\xc1\x32\xc5\xc1\x46\x4a\xa1\xc3\xe9\x68\x8a\x15\x3b\x0d\xda\xac\x94\x30\xfa\xcd\x50\xc6\x88\xf8\x26\x31\x72\x79\x35\x09\x6c\x7c\x39\x51\x30\x65\x12\x44\x38\x15\x37\x93\x45\xd9\xd9\x01\xd2\x2b\x46\xd4\x16\xb6\x2f\x5c\xf9\x9f\xed\x3b\xbf\x5b\x66\xcb\x28\xcd\xaa\x1d\xf9\xc6\x6d\x33\x43\xb9\xa1\x15\xd3\xa7\x2d\x0f\xe5\x84\x66\x0c\x7d\x1d\x4d\x2d\xe2\xfb\x8e\xbb\xb3\x6e\xdd\x5b\x93\x27\x5d\xbc\xb7\xf4\xb6\xc6\x01\xd5\x8e\xa2\x0b\x13\x86\x16\x0d\x1f\x37\xab\x76\xc9\xce\x6d\xcb\xa2\x33\xef\x18\x59\x18\x9b\x22\xcd\x83\xe0\x92\x34\x62\xfd\xeb\x04\xed\xa3\x1e\x0e\x69\x55\x2a\x1b\xc2\xf6\x97\x95\x37\xa8\x0d\xac\xa1\x29\xc6\x5a\x6d\xd2\xa1\x37\xa6\xe6\x84\xd6\xa4\x57\x34\x58\x79\xe2\x4d\x25\x02\xea\x92\x3f\x4c\x18\x15\x29\x76\xef\x15\x7e\xfb\xe3\xbb\xbf\x43\xc7\xed\xa3\xfe\xd1\xb5\xce\xdc\xcf\x94\x79\x27\xdd\xef\xf2\x57\xc2\x73\xc2\x23\x1f\x7e\x43\xad\x6d\xd9\xb4\x69\x09\x3c\xbf\x6a\xba\x92\xbe\xac\x10\x7b\xdd\xfa\xf0\xb9\x79\x0a\xaf\xab\x1a\x04\xa3\x46\xb5\x8a\x06\xb4\x12\x69\xb4\xb4\x52\x65\x80\xca\x78\x9c\x41\xde\x72\xe2\x4b\xa2\xac\x30\x81\x82\x82\x01\xfa\x29\xe1\xc3\x0f\x8a\x1d\x86\xf6\x6f\x0b\x57\xe0\x03\xb0\x9e\x9a\xbe\x79\x74\xfb\x33\x2d\x9b\xf0\x50\xe2\x3c\x35\x78\xdc\x33\xe2\x9d\x41\x49\xd4\xae\xb5\xa9\x4c\x34\x02\x3a\x08\x68\x95\x49\xa5\x57\x28\x74\xbc\xde\x00\x75\x71\x97\xb5\x48\xbc\xb7\x87\x45\x91\x22\xb9\x61\x44\x20\x84\xb2\xca\x14\x28\x84\xc2\x16\x16\x85\xcc\x11\x33\x69\xc8\x6e\x8e\xd0\x67\x3e\x1f\xc2\x7b\xd6\xbd\xf2\x90\xc5\x78\xcb\xd5\x17\x7e\xde\xe2\x44\xd0\xb8\xed\x17\x6a\xd8\xb6\x9e\xd3\x85\x4a\xf8\x43\xcf\x8e\x1b\x5b\xee\xc6\xbc\x54\xd0\xe0\x50\x77\x80\xbf\x4b\x74\x84\x89\x4d\xc2\x7c\x81\xad\xdb\xdc\x28\xaf\x46\x98\x0e\xab\x4d\xaf\x02\x1a\x13\x8f\x18\xc0\x60\x07\x11\xa6\xa4\x2a\x56\xca\x15\x2c\xb0\x44\x6e\x17\x44\x60\xb0\xe4\x19\xe3\xc5\x5d\x33\xa1\x4f\xbd\xb5\x63\xff\x4e\xd9\xf0\xb4\x70\xe5\x64\x76\xb5\xbd\xf6\xa8\xf0\x21\x3c\x5d\x7f\x92\xf9\x42\xf7\x9a\x32\x6b\xd0\x84\xeb\x6f\x53\x86\xc9\xff\xb8\xfd\xdb\x96\xef\xe8\x99\x6f\x3e\x26\xbe\xbf\x0c\xbf\x9f\xdc\x4b\x29\x81\x37\x8a\x9d\x0a\x0a\xb0\x08\xaf\x32\x83\xcf\xbd\x58\x92\x59\x99\x10\xe7\x22\x5c\x22\x36\x30\x38\xf8\x91\x70\x2b\xcc\x81\x2a\xec\x83\x65\x09\x43\xe1\x8b\xd4\x32\x61\x00\xdc\xd7\x72\xa7\xd0\x43\xae\xcd\x61\x7c\xa2\x9f\x82\xa5\xb5\x59\xab\x37\xa9\xb1\xd2\x32\x19\xb4\xd8\xb4\x31\x19\x8c\x98\x81\x8c\x06\x9d\x59\x8b\xdd\x5c\x2d\x4f\x53\x0a\x6c\x35\x2a\x5c\xe9\x3a\x2d\x5d\xa5\x25\x23\x9c\xd2\xa1\x4d\x40\x05\xd2\x65\xb2\xce\x6f\x69\x8c\x57\xed\x50\xe3\x6f\x95\xf4\x7b\x5f\xb9\x5e\x87\xc8\x97\xae\x37\xca\xe8\x97\x31\x3d\x36\x10\x20\x77\xcc\x6a\xc4\xa8\xec\x1c\xa7\xf2\x6a\xc8\x4c\x95\xc1\x90\xde\x55\x8f\xed\x3e\xa4\x50\xb1\x0a\xb6\x29\xa6\x30\x78\x69\x35\x52\x37\xc5\x6c\x3c\x41\xc6\x96\xea\x31\x53\x9b\xdf\xb6\x4a\x9b\x21\x9d\x10\x24\x82\x22\xf1\x92\xdb\x3c\x48\x72\xb2\xa4\xbc\xdc\x92\x72\x18\x53\x16\x08\xcf\xc3\xaf\x85\x1a\xea\x03\xc1\x71\x60\xe5\xa1\x29\x8b\xd7\x3f\xf7\xec\xc7\xc5\x15\xf0\x9d\x2c\x97\xab\xaa\xc7\xb4\x48\x87\xe1\xe6\x38\xbd\x6f\x6e\x59\xb7\xe4\x9e\x6d\xb7\xcc\x86\xdf\x84\x32\x2b\x46\xe7\x89\xfb\x23\xe2\x38\x8a\xfe\x50\x34\x1a\xd0\x2b\x54\x3a\xc4\x71\x3a\x85\xda\xc6\xb8\xdc\x98\x4f\x2d\x1a\x0b\x20\xe2\x5a\xa7\xd6\xa8\x49\xcc\xa0\xf5\xed\x46\x3a\xb5\xc9\x50\x6c\x59\x32\x48\x2b\x26\xfe\x50\x4d\xcb\x26\x3e\xfe\xdc\x58\xd8\xd4\xf2\x1a\x5a\x25\x6c\xfd\xcb\xe7\xc2\xbf\xff\xf3\x8e\xf0\x87\x1d\xf2\x9a\xb9\xff\x5a\xfb\xd0\x7d\x6b\x4e\xc0\x21\x17\x5e\x15\x36\x9b\xbf\x39\xf9\x9d\xf0\xeb\x1b\x47\x74\x43\xa6\xe0\xb5\x9d\x87\x69\xdb\x88\x69\xf3\x61\xdd\x3c\x38\x5a\x8c\xe5\x34\x67\xb6\xe9\x5c\x58\x7c\xbb\x6c\x99\x9c\x45\xa9\xc8\xcd\xb3\x59\x78\x0b\x26\x0c\x6b\x69\x3b\xa7\xa3\x00\xd2\x70\x1a\x8e\xe6\x0d\x74\xa8\x3e\x46\x27\x5c\x97\xca\xa2\x22\x42\x65\x5e\x1b\x79\x28\xb9\x0f\x61\x56\x12\x85\x44\x37\xb7\xa2\x1f\xab\xee\x4c\x31\xef\x9c\xac\x37\xba\xe0\xc8\xbc\xff\xec\xdd\xe7\x27\x9c\x3f\xb5\xfb\xe8\xb3\xcf\x4f\x4b\xce\xa6\x7d\xfb\xe2\xe6\x0f\xa7\x36\xde\xdf\xf7\xee\x95\x0d\x5d\x85\x51\x45\x95\xb3\x1a\xee\x1b\x72\xef\xb6\xbb\xd6\x6d\x48\xce\xeb\x8e\x09\xdd\x7a\x3d\xde\xbe\x76\xc0\xca\x0a\x71\xdd\x27\xe0\x73\x31\x9d\xb9\x15\xeb\xc7\x92\xa8\xd3\x0e\x14\x16\x0b\xd0\x63\xcb\x87\xb6\x35\xc6\x68\x1a\xbb\x62\xd8\x1a\xe3\x68\x90\xa2\xa9\xd3\x3a\xff\x72\x29\x79\x8f\x62\x5d\x57\x09\xe0\x49\x74\x00\x5e\x2a\xec\x18\x98\xb3\x6c\xde\xa2\x41\x77\x69\x85\x9f\xbc\xd0\xf8\x97\xdf\xa1\xfb\xca\x61\x2a\xa2\x65\x9f\x78\x68\xcd\xea\x69\x03\xba\xec\x3e\x27\xfc\xfb\xda\x79\xe1\x6b\xaf\x70\x58\xa4\x63\x1a\xa6\x63\x6e\x9c\x0e\x8e\xb6\x63\x41\x48\x63\x3a\x2c\xb0\x31\x66\xb1\x28\x80\x42\xdf\x48\x3a\x23\xff\x29\x1d\x24\x18\x01\xd2\x5a\xb6\x13\xd3\x86\x83\x7f\x1c\xfa\x1b\x74\xfd\x71\x16\x72\x5e\xe1\x27\xed\xd2\x5b\x16\xcf\x5d\x36\x27\x58\x9d\x0f\xfb\x79\xa1\xed\xdc\x1f\xd0\x7e\x6e\x77\x97\xa6\xe9\x6b\x56\x3f\xf4\x04\xab\x6d\xb9\x94\xb8\x63\x1f\xc5\xd4\x61\x3a\x48\x1f\x31\x1b\x47\xd3\x36\x52\xeb\x06\xb1\x2a\x80\x50\x61\x47\x22\x21\xd6\x84\x7f\x96\x76\xab\xce\x59\x4d\x49\x56\x4b\xae\x0b\x47\x7d\x78\xe8\x6f\xc2\x97\x7f\x9c\x15\x7e\xf0\x42\x43\x92\x0a\xa6\x4e\x38\xe2\x15\xbe\x3e\xff\x87\xf0\xaf\x14\x3a\xa8\x12\x91\x8e\x19\x98\xe7\x48\x8e\xa5\x9b\xdc\xf5\xea\xdd\x2c\xef\xe6\x3d\x5e\x8b\xc2\xa2\x70\x20\x07\x57\x1f\x73\xb8\x90\xba\x75\xea\x6d\x7a\xce\xa7\x39\xe5\x66\x5f\xae\x5a\x10\xeb\x56\x49\xf4\x6f\x06\xd4\xff\x12\x4f\xa0\x9c\x3e\x7d\xea\xdc\x78\xa9\xea\xaa\x5f\x85\xdf\x29\x1b\x34\xc2\xb0\x98\x39\xf9\xd0\x41\xa1\x68\xff\x33\x52\x75\x2a\xcc\x84\xac\x84\x59\xf1\x0d\xbd\x92\x89\x89\x88\xae\x37\xb0\x47\x87\xbd\x65\xca\x09\x5c\x51\x8e\xba\x61\x83\x1b\x6d\x70\x89\x0d\xf6\xb7\x41\x83\x0d\xda\x00\x37\x94\xfc\x57\x26\xd5\x8c\x93\x7b\x63\x82\x77\xa2\x07\x0e\x10\x04\x4d\xd1\x02\xaf\xda\x42\x1b\x9c\x4e\xbd\x5e\x41\xab\xe9\x8c\x90\xc2\x10\x34\x04\xb1\x4b\x18\x8f\x11\xea\x81\xde\x89\x3d\x55\x1e\x38\xea\xa5\x5b\xbd\xff\x99\x06\x23\x35\x18\x49\x2b\x85\x83\x12\xa6\x0c\xe9\x43\xc3\xc5\x2f\x67\x36\x52\x1d\x4f\x5c\x1e\xd9\x34\x71\xea\xfb\xcf\xb6\x6c\x85\xe6\x77\x06\xf7\xcd\xcb\xed\x71\xfb\x3b\x1f\xcf\x1e\x37\x6c\xf1\xc7\x74\xd5\xdd\xf7\x0c\x5b\xe0\x74\xaf\x1e\x7d\xf7\xa3\xd4\x52\x47\x79\xbb\xa2\x32\x7b\x4b\xfb\xee\x3d\xbb\xd5\x8a\xbd\x3b\x30\x5f\x4c\x95\x73\x78\xba\x45\x33\xd5\x1e\x92\xc5\x63\x55\xf8\x83\x1e\x26\x33\xcb\x8f\x85\xaa\xa2\x21\xc6\xb2\x66\x6c\xb9\xe1\xcd\xb9\x59\xf2\xce\x9f\x66\xee\xf0\x29\x09\x3c\x61\x31\x23\x43\x16\x03\x15\xc4\x4e\xa7\x7a\xf6\x68\xbc\x7d\xee\xca\xdb\x86\xd6\x2f\x58\xb3\x6e\x3e\xa4\xa1\x57\xf8\xf4\xfa\xc6\xb7\xa7\xaf\x5d\x74\xf5\x27\xb4\xa3\x4b\xc7\xfe\x75\xcf\xf7\x68\x8a\xf6\xff\xcb\xa1\xd3\x27\x8e\x08\xef\x0b\xd7\x85\x6b\xc2\x7b\x4d\xdb\x47\x4c\x58\xa1\x2b\xbb\xb0\xf0\x61\x49\xf7\xd6\xdf\xf8\x96\xc9\x60\xda\x61\x7f\x1c\x5b\x9e\x8c\xd5\xa5\xd1\x64\xf9\x8d\x46\x9d\x15\x85\xb3\x31\xfd\xc1\xa6\x98\x47\xaf\xc3\x1a\xd8\xe5\xd0\xeb\xf1\x04\xc4\xfa\x0c\xb3\xb2\x09\xdb\x9e\x6d\xc0\xbf\x80\xbd\xe8\x66\x77\x83\xa9\x88\xd4\x62\x6a\x09\x8c\xa7\x96\xd8\x4c\xf1\xc4\x19\x0f\x44\xdd\xec\xcf\x2f\x5e\xb1\xf1\xee\x2e\x43\xf2\xdf\x80\x57\x16\x7c\xb5\x4c\xf8\x5d\x78\x0f\x66\x37\x2f\x1e\x6f\x80\x19\xbd\xfb\x56\x79\x3b\x94\x51\x57\x1e\x3f\xb4\xf7\xe0\x31\xde\xb6\xf4\x6d\xa1\xaa\x47\x47\xc2\x74\x50\x09\x8b\x2a\xa0\x83\x7b\x5d\x5b\xd7\xe3\x0a\x48\xd4\x97\x74\x17\xef\x82\x2b\xa3\x5e\xa8\x52\xa9\x29\x96\x65\xd4\x8c\x56\x07\x95\xf5\xb1\x25\x70\x23\xb6\xe9\xa1\x1a\x69\x0c\xac\x3a\x61\xd9\xb4\x8d\x83\xcb\xc5\x87\x22\x3e\xf2\x23\xf8\x77\xec\xc2\xbf\x84\xe9\xc2\x3f\xb1\xdd\x82\xb5\xfc\xf5\x73\xf0\x2d\xa1\x58\xb2\xa1\x10\x18\x87\x7d\xc3\x66\xe6\x22\xde\x7b\x12\xe1\xae\x8f\xe6\x79\xd5\x66\xbd\xd3\x69\x05\x88\x42\x46\x35\x1d\x08\x02\x9d\x1b\x2f\x20\x72\xf3\x16\x73\xd3\x10\x0b\x9e\x39\xf6\x69\x0d\x0a\x5b\xbd\xa4\xf4\x53\x1b\x26\xb4\x5a\x3d\xd9\x99\x8d\xbb\xaf\x89\x6b\x55\x72\x05\x2f\x96\x42\x12\x33\xd9\x8a\x86\xef\xdc\xf9\xe6\xd9\x27\xce\x9c\x7e\x69\x6c\xbc\x60\x4b\x18\xd6\xaf\x6a\xc6\xc6\x8e\x97\x2e\x99\xce\xbd\x7d\x60\xcb\x7d\x8f\x51\x07\xc8\x95\xfc\x35\xff\xc0\x01\x55\xb3\xda\xd5\xe0\x35\xaa\x12\xa6\xd0\x7e\x71\x8d\x0a\xa2\x56\xb2\x3e\x50\xad\x51\xa9\x19\x5a\xa7\x55\x40\x15\x59\x1b\x72\x7b\x75\x2e\x3d\xff\x46\xea\xf3\x5a\x11\xc7\x8c\x86\x70\x32\x0c\xcc\x27\xf9\x20\xc2\x9d\xc2\x3b\x70\x91\x30\x0e\x2f\x8e\x75\x00\xbc\xff\x5a\x29\x6a\x14\xa2\xf0\x49\x6a\x8b\xb4\x1f\x7f\x03\x04\xf9\xbc\x0a\x30\xc0\x17\xd5\xd3\x10\x02\x56\x41\x19\x20\xdd\x14\x83\x72\x3c\x27\x11\xc5\xca\x11\x97\x9d\x56\x35\xbf\x05\x1d\x94\x9d\xae\x6a\xde\x1c\xcf\xc5\x86\xcc\xfb\x58\xd6\xe5\x80\x7e\xd1\x6c\x8f\x11\x62\xe9\x91\xa1\x06\xea\xbc\x5c\xb9\x45\x27\x49\x62\x36\x2a\x74\xba\x80\x98\xc4\x1c\x26\x49\xcc\xd0\x75\x93\x24\x66\x90\xd6\x2d\x87\x6c\x33\xa9\xa4\x4c\xad\xd1\x4a\x89\x1b\x60\xf3\x25\xb5\x58\xab\x52\xf8\x2a\xb5\x48\xeb\x99\x9d\x84\x25\x23\x1d\xa1\xf0\x4d\x22\x67\x5f\x18\x04\x1f\x3b\x9c\x2c\xd1\x82\x05\xab\x1f\xc0\x7c\x59\xd5\xaf\x65\x5b\x5a\xbe\x7e\x5c\xa7\xfa\xc1\xc8\x68\x07\x25\xef\xf0\x78\xa0\xd7\xe0\xf7\xba\x78\x26\x18\x60\xec\x8d\x31\xb7\x1f\xf8\xb1\x94\x00\xfa\x25\xcc\x46\x62\x81\xfa\x40\x11\x58\x82\x25\x24\xa3\x22\xb6\x30\x30\x79\x79\x93\xa6\x31\x66\xa2\x53\xec\x06\x52\xc3\x5e\xc9\xc9\x35\xa5\x69\x56\xa3\xf9\xcf\x94\xb0\x74\x1d\x52\x16\xb8\x13\xf6\xbf\xa9\x32\x86\xfd\x84\xc3\xc2\x97\xc2\x21\x18\x84\x5c\x5b\xb5\x9c\x7f\x6c\xfc\xf8\x54\xbd\xec\x07\xe3\xa3\xd5\x76\x46\xe3\x23\xd8\x00\x80\xe3\x90\x06\x05\x82\x2e\x25\xd6\x8a\x0c\xcb\xd4\xc7\x7c\xac\x69\x89\x6b\xa3\x8b\x32\xb0\x3e\xb6\x88\x5d\xc2\x6e\x64\xf1\x64\x5c\xac\x8b\xd5\x23\x31\x27\x8d\x46\x09\xd5\x1d\x2f\xc9\x6f\x35\x9d\xe4\x0d\x5e\xa6\x48\x36\xfe\xfa\x13\xa5\x1e\xa0\x47\x09\x87\x30\xe5\x78\x06\x37\xd7\xee\xfd\xc7\x8f\x1f\x7f\x2c\xbf\xad\x8a\x17\x7e\x90\xce\x33\xa9\x3f\x7a\x44\xac\x09\xf6\xe0\x79\x0d\x8d\x46\xfc\x46\x4e\xef\xf3\x69\xa0\xc5\xc1\xb2\x16\xa3\x99\x0e\x06\x8c\x5e\xbd\x17\xdb\x73\x3e\x88\x80\xde\xa0\x05\x2a\x9b\x78\xc3\xe6\x12\x1b\xc9\x70\xad\x2a\xee\x89\x5f\x88\x1d\xa6\xf4\xee\xb0\x89\xdb\xdf\x74\x10\x6a\x09\x72\x3a\x51\xaa\x63\xe6\x20\x7c\x9f\xad\x9c\x33\x63\xe1\x8a\xd9\xa3\x3b\x9c\x85\xbf\x0a\x07\xe1\xc4\x96\xc2\xf2\xb2\x71\x63\x23\x95\xaf\xc0\xac\x01\xe3\xc5\x0a\x1d\x23\x0c\x0e\xc5\xee\xc8\x94\xbf\xb4\x0c\xbe\x44\x85\xf6\x9d\x26\x95\x3a\xa7\x29\xd4\xb2\x87\xdc\x60\x53\x20\x57\xb8\x85\x7e\x00\xcf\xa7\x08\x54\x82\xbb\xa2\xdd\xcb\xd8\x76\x5a\x0d\x2c\xc8\x33\x14\x15\xb9\xcd\xe1\x1c\x2e\x64\xb5\x72\x61\x37\x64\xd9\xaa\x0e\x1e\x6c\x3d\x10\xd6\x73\x71\xb9\x86\xdc\xa6\x58\xb6\xd9\x1c\x6e\x88\x69\xcc\x78\x96\x06\x83\x0e\xa8\x22\xe2\x2c\x2b\xd2\x91\xb6\x53\xa6\xf7\xe7\x29\x11\xc9\x22\x88\xd4\x09\x87\xc5\x19\xa3\x10\x51\xc9\x54\x5a\x3f\x2d\x6c\xdd\x9a\x43\x9c\xc5\x07\xf9\x14\x58\xbf\x5f\x15\x9d\x56\x2c\x5c\xb3\x61\xd9\xac\x1a\xf8\x0e\x3c\xfa\x9c\x6e\xca\xfc\x93\x0f\xcf\x7a\xcc\x7f\xca\xd9\x31\xb3\xae\x53\xd3\xc8\x8c\x7d\x57\x68\xf8\x7e\xc7\x0e\xb3\x66\x56\xd6\xc4\x26\xc3\x6c\xac\x19\x74\x30\x73\x4c\x3e\x7c\x41\x98\x72\x4a\xd8\xe0\xff\xfa\xf0\xbf\x85\xff\xac\xbe\xab\x5b\xbf\xba\xcd\xdb\x37\xde\xfd\x12\x1c\xde\xb2\x78\x5e\x0f\x1b\x4f\x85\x9e\x79\x85\x2c\xd8\x19\xb1\x3e\xba\xf4\x46\x0e\xbd\x57\xac\x8f\x0e\x83\x5c\x10\x01\x4b\xa3\xdd\xf3\x1c\xb9\x5c\x3b\xb3\x1b\x7b\x6f\x39\x39\x5a\x5f\x48\xa1\xf0\x79\x81\x99\x73\x28\xca\x4a\xb9\x6c\x43\x76\x53\xcc\x5a\x50\x1f\xa3\x72\xa0\xd6\x60\xb5\x42\xb2\x4c\x72\x49\x48\x66\x7d\xcc\x43\x5b\x8b\xdb\x99\xa0\xa9\x29\xe6\x26\xa2\x2e\x22\x7b\x51\x67\x93\xeb\x46\x7c\x6a\xa2\x38\x5b\xb7\x0e\x8e\xa4\x5e\x0c\xb7\x61\x11\xd9\xc9\x32\xe6\x41\x45\x18\x1a\x13\xbc\xe2\x22\x35\x30\xa2\xbb\x45\x7d\x2e\xbc\xc0\x94\xdd\x3e\x62\xd2\xd4\xf1\x03\x4a\x9e\x81\x4f\x0a\xdf\xd4\x57\xcc\xeb\xda\xbd\xe1\xbb\x9a\x8a\xad\xc2\xe7\x83\x07\x34\xe5\x15\x3e\xfd\xdd\xcf\x66\x73\x86\xd3\x54\xe2\xef\x71\x9b\x08\x71\xa8\x82\x39\x4d\xf0\x6d\x61\xca\xf9\x96\x5b\x8f\x3e\xbb\x65\xae\xf0\xf7\x2b\xb9\xd4\x65\x38\x89\x2c\xcd\x1b\xf0\x8f\x96\xe7\xa8\xde\x2d\x87\x7a\x34\xf4\xca\x93\xe2\x55\xc5\x78\xb1\x76\x31\xed\xb1\x37\x59\x0a\x86\x47\xcb\x40\x71\xb1\xcf\xa5\x2b\xc8\xe4\x79\x16\x16\xb8\x3c\x6c\x59\x79\x3b\x8f\xd7\x83\xa5\x71\xa6\xd7\xee\x07\x51\xe0\x35\xd8\x4b\xb1\xef\xc3\x13\xab\xd4\xa7\x28\x52\x50\x0a\x05\x92\x22\xe5\x09\xd5\xe7\x34\x92\xae\xb7\x95\xad\xa1\xda\x45\x65\x1c\x48\x0b\x8f\x4b\x1d\xd8\x8c\x39\x62\x64\x55\xec\xcc\x06\xa5\xa6\x91\x62\x24\xbd\x22\x44\x8c\x59\x38\x0d\x76\xec\xda\x73\xd3\x7e\xfe\x35\x65\xe7\x2e\x5d\xba\xf0\x39\xbd\x9f\x99\x17\x15\x9e\x12\x8c\xb7\x8f\x1d\x35\x39\xba\x09\x7e\xd2\xa7\xc2\xdf\xe9\xce\xb9\xa3\xcb\x0d\xcb\xc3\x39\x74\x15\xff\xc0\x3a\x77\x6d\x6d\xa4\x63\x20\xdb\x69\x2d\x1e\xb8\x6a\xb4\x70\x76\xf5\x5a\x6a\xd2\x49\xe1\xfa\xd6\xc2\xf2\x50\x51\x28\x23\xb3\xcf\xec\x41\x35\xe5\x2d\x9f\xf5\x8f\xe2\xb9\x0f\xc4\xb6\xf7\x9b\xcc\x7b\x80\xf4\x6d\x18\x19\x2d\x55\xe7\xe7\x2b\x50\x8e\x26\x23\xc3\x64\xb7\x7b\x11\x43\x17\xb5\xf3\x05\x5c\x81\xc6\x98\xcb\x65\xb2\x18\xb0\x5f\xa0\x54\xb2\x06\x90\x27\x8a\x41\x35\xfe\x29\x9c\xcc\x7a\x8b\x24\x5a\x9a\xde\xcc\xe7\x8f\x24\x53\xd4\xe5\x69\xf2\x91\xf4\x1a\x9b\xd4\x90\x36\x5b\x51\x52\xc1\x91\xa9\xc3\xcf\x16\xad\x22\xe8\x55\xaf\xbc\x7c\x66\x70\x17\x31\xf4\x1e\x0f\x6f\x0f\x77\x66\x04\x5f\xe9\x68\xc2\x33\xbb\xf3\xa4\x20\x78\x52\xe2\xf0\x52\x9c\xdb\xe6\xfc\xab\x92\x3a\xd8\xf2\x79\xff\xde\xd2\x1e\x67\x63\x39\xb8\x13\xef\xb1\x12\xcb\x8d\x19\xd1\x1a\x50\x42\xe7\xe7\xfb\xcd\x36\x1b\x41\xf5\xf4\x7b\xf8\x8a\xac\x12\x65\x87\xaa\x22\x0a\xdb\x87\x05\x65\x61\x2c\x4d\xca\x0c\x65\x8a\xfa\x58\x99\x35\x94\x8b\xed\x9b\x90\xd1\xaa\x37\xe8\xeb\x63\x66\x83\x41\xe5\x6c\x8c\xa9\xd2\xa7\x7c\x36\xcd\x70\x6c\x8b\x1b\x2b\x45\xa7\x09\x1c\x19\x9e\x5d\xea\x02\xf0\x21\xd9\x55\x09\x65\xc9\x0d\x41\x44\xae\xe0\xf8\x64\x2d\x98\x1e\xa2\x37\x6e\xad\x18\x00\x0b\xfa\x4e\x68\xd9\x39\x6e\xc1\xd0\x71\x1d\x1f\x5d\xbf\xde\x6e\x32\xe4\xdb\xa0\xf7\x2f\x87\x37\x3c\x6f\xfe\x46\xd9\xbe\x78\xc9\x1d\xe3\x57\xde\x7d\xf8\xe1\xbb\xa7\x95\x4c\x82\xde\x51\x73\x86\x9d\xbe\x7f\x91\xb8\x2a\x27\x5b\xfe\x56\xd7\xa9\x28\xff\xf6\xf5\xd0\x00\xb3\xff\xb2\xdb\x38\x60\x94\xb0\x35\x3f\x76\xef\xf2\x1d\xcf\x4d\xab\x8e\x60\x7d\xd7\x09\xef\xfd\x52\x2c\x1f\x8a\xf1\xce\x97\x15\xfb\x7c\x19\x7e\xca\xe5\x72\x5b\x54\x2a\x43\x9e\xdb\x1f\x64\x4b\x22\x79\x05\xd9\x58\x1e\x64\x03\xaf\x2d\x18\x0a\x62\xc1\xe0\x2f\x0e\x19\xdc\x7e\xde\x68\xd2\x9a\x48\x05\x39\x63\x4c\xdc\xd5\x8a\x96\x67\x5a\x60\xa5\x75\x6a\x10\xb4\xda\x6e\x92\x05\x14\x87\x73\x13\xbf\xca\x52\x59\xc2\x03\xa9\x7d\x34\x9d\x35\xae\x6e\xd1\x92\x69\xb3\xbd\xc3\xcc\xd5\xae\x9a\x3b\x3a\xd4\x7d\x3a\xf8\x93\x71\xe3\xa6\x4d\xab\xee\x5d\xca\x87\x9d\x74\x95\x7b\x58\x9f\xae\x57\x5e\x6f\xa1\x0f\x3d\x63\x60\xff\xc6\x2f\xa6\x8e\x40\xcf\xe1\x55\x2d\x2f\x93\xb4\x7a\xb4\xe8\xe4\xf4\x2d\xeb\x2d\xc7\x4c\xd1\xce\x03\xf1\x5c\x6f\xc1\xfb\xbf\x03\xcf\x35\x0f\xf4\x8e\xe6\xa2\xbc\x3c\xe0\xe1\x54\x99\x99\xa4\x7f\x66\x7e\x41\x36\x8b\x27\x69\x55\x79\x80\xc5\x82\xb5\x9e\xcf\x5e\x64\xa7\xec\x76\x8b\x31\x9e\x21\x17\x29\x4a\xb9\xf8\x4a\xf7\xc3\xc8\x1f\x89\x36\xaf\xad\xee\xbe\x48\x68\xda\x8b\xa4\x6d\xe4\x6f\xf9\xa3\xf7\x3b\x93\xa7\x8d\xc8\xec\x3d\x65\xc9\x8c\xe8\xeb\xfb\xb7\x9d\xf1\x7d\x6a\xac\xed\xb9\xa6\xbc\xe3\xf8\xcd\x93\xdb\x5f\xbd\xfc\xed\x3e\xe6\xe2\xf5\x21\xd5\x5d\x2b\xea\xb2\x22\x61\x7f\x56\xfd\xdc\xc1\x0f\x1e\xdc\xba\xd1\xd9\xad\x7a\x6a\x51\x99\x29\x50\xd6\x7f\x71\xc3\xa3\x07\x46\xf5\x27\x7c\x4c\xb0\xfe\x49\x7f\x38\x25\xb6\x76\x3b\x46\x7d\x2c\x52\xab\x81\x86\x51\x32\x00\x69\x75\xd8\x0c\x51\x61\xd3\xdc\x00\x81\x9a\x05\xac\xac\xb9\xe3\xc0\x7a\xe9\x92\x28\xde\x43\x8f\x68\x68\x0e\xae\xfe\x92\xfa\x4c\xb0\x53\xc6\xe6\xdf\xe1\x17\x24\x69\xef\xf5\x96\xdb\x2e\xa1\xa9\x2d\xb7\x50\x4f\x8b\x67\x67\xb0\xfc\x4e\x1e\x6b\x91\xa1\xd1\x76\x3e\x95\x26\x40\x3b\xcd\xd9\xb9\x3c\x9f\xed\x0c\xa8\x98\xbc\xfc\xec\x40\x8e\x0f\x2a\xcd\x9a\x80\xd3\xeb\xa3\x35\x4a\x94\xe1\xc3\x5f\x06\x9b\x97\x37\x00\x8b\x0a\x10\xbf\x44\x6e\xda\x40\x6a\xb0\x4d\x49\xd7\xa4\x6d\x60\x28\x24\x85\x3e\x43\x28\x62\xae\x20\xe1\x57\xb3\x8f\xc0\x83\xa5\x7c\x5a\x93\xf8\xf0\xf4\xf9\x99\x66\xad\xc6\x3e\xeb\xfc\xa1\x43\x93\x55\x8c\x62\xce\x1b\x53\x4d\xaa\xe9\xcf\x1e\x3d\x3f\x53\x63\x91\x3f\xe5\x54\xd3\xa5\x0f\x91\x15\x2e\xaf\x19\x58\x3e\x5c\x58\x42\x3d\x2f\xa8\x8a\x5d\x7e\x78\x8f\xb0\xa6\xbe\x08\xfe\x76\xad\x14\x2e\xcf\x9a\x12\xff\x87\x21\x19\x70\x9e\xf4\xb9\x24\x33\x48\xbf\x1a\x1f\x9e\xb7\x02\x3b\xe5\x5d\xa3\x41\x5a\xab\x65\x74\xd8\x05\x03\x4a\x9d\x12\x1b\x51\x1a\x62\x0f\xea\xf1\x17\xab\xd2\xf1\x2c\x6a\x8c\xb1\x30\x99\x4a\x2f\x81\x6b\xb4\xc6\x5f\x92\x00\x07\x92\xff\xd3\xbe\xef\x85\x09\xdf\xa3\x19\xd2\x77\xf4\x25\x54\x09\xbf\xc1\xaf\x30\x51\xe2\x9f\xa2\x7d\x9d\x49\x7a\xbd\xd3\x75\x58\x87\x47\xa3\x7e\x27\xf0\x7a\x3d\x16\x85\x42\xe7\xf1\xe8\xfc\x3e\xaf\xcb\x65\xd0\x49\x69\x13\x46\xc6\xd6\x18\x63\xac\xa9\xbd\xa5\x6b\xe2\x58\x2c\x89\x1d\x67\x4a\x2b\x88\xb3\xea\x20\xb2\xc8\x00\xc5\x0b\x3c\x0f\x4c\x26\xc7\xa3\xbb\xe9\x82\xe5\xe3\x85\x4b\xeb\x4a\xa2\xfe\x19\x83\x9f\x3a\xd0\xb3\x67\xe3\x30\xc8\x0a\xd7\x2c\x77\x74\x1d\xda\x1f\xbb\x8d\x75\xdb\x8d\xca\xf7\x3c\x1f\xbc\x7f\x6c\xcb\xda\x67\xd6\x53\xb5\xd7\x3c\x62\xbe\xdd\x35\x4c\xdf\x45\x4c\x5f\x26\x3e\x57\x59\x3e\x37\x42\xea\x50\x28\x9c\x65\x53\xab\x8d\x59\x1e\x83\x51\x67\xd6\x91\x5c\x36\x85\x83\x04\x92\x42\x01\x10\x68\x6c\x0d\x9b\x21\x25\xde\x40\xb9\x80\x4e\x02\x6b\x90\xb1\x33\xe2\x09\x0e\x29\xd4\x1a\xe3\xd9\x9d\x62\xf4\x98\xce\xb8\x7f\x77\xce\xac\x7e\xab\x37\x4c\xc8\x8a\x06\x26\xf5\xdc\xba\x6d\x6e\x6d\xff\xff\xcc\x2d\xe9\x33\x44\x18\xf4\xe1\xdb\x93\x7a\x55\xfc\xed\x35\x4c\xb4\x59\x7d\xc5\xf7\xe1\x7b\xc7\x84\x2f\x0e\xac\xa5\x6a\xaf\x7f\xf6\xb5\xef\x03\x1f\xe9\x7d\xe9\x80\x5f\xa3\xa3\x2c\x30\x2a\x50\x9e\x88\x22\x4a\x7a\x83\x4a\x9f\x29\xb0\x8f\xd2\x39\xca\x29\xb1\x69\xe4\x31\x18\x8c\x46\xbb\x02\x05\xfc\x4e\xbb\xe5\x45\x18\x79\x0e\x90\xfa\x40\xe3\x71\x58\x88\x4f\x1f\x82\xc5\xb2\xc7\xcd\x91\xae\x17\xad\x32\xb6\xe2\xe8\xd9\x21\xae\x34\x9e\x10\x29\x25\xce\x67\x91\xca\x6a\x03\x36\x85\xc3\xb3\x1b\xe6\x2e\x3c\xb9\xa2\xdb\x80\x53\xf3\xef\xb0\x0d\xb6\x64\x65\x0f\xa6\x10\xdd\x77\x50\xff\x07\x36\x08\x6e\xf8\xcc\xeb\x8b\x87\x09\xe3\x51\xfd\xf0\xc9\x4a\x7a\xab\x2a\x16\x89\x55\x03\x0a\x5e\x00\x27\x11\xc5\x10\xfc\x51\x23\x28\x8a\xe2\x73\xaf\x41\x7a\x56\xcf\x99\xb4\x2f\xc2\x76\x87\x95\x0a\xfa\x38\x14\x7b\x76\xc1\x12\x91\xae\x44\x41\x84\x44\x0f\x69\xf1\x18\x0c\x97\xd9\xe2\xbd\x14\xa9\x2e\xa7\x5e\xed\x95\x1b\x2a\x09\x9d\x1a\xc5\x4c\xde\xb4\xe9\x7a\x03\xbb\x0e\x15\x75\x41\x99\xcd\xcf\x8c\x9e\x8c\xd7\xe7\x5e\xbc\x16\xd5\xf4\xcf\x78\x7d\x0a\x12\xeb\x73\x2f\xfc\x08\x7f\x76\x15\x58\x40\xfb\xa8\x51\x01\x91\x59\xa9\xd4\x21\x9d\x95\x57\x28\x95\xb4\x85\xd0\x60\xd4\x6b\x8e\xc1\x22\x40\xe3\xf5\x21\x9d\x1d\x6b\x52\xc0\x2c\xe3\x19\x8b\x24\x31\x37\xde\x2a\x3f\x7e\xdd\x8e\xda\x33\xcf\xd3\x34\x44\x99\xbd\xa3\x19\xb6\xec\xdc\xee\xf5\xf4\xd5\x96\x97\x56\x17\xe8\xe7\xbb\x27\xd5\xa9\x9f\xd4\xcc\x9b\x03\xe7\x88\xef\xef\x02\x4e\x60\x26\xbd\x0a\x9c\xa0\x22\x6a\x74\xe8\xb5\x5a\xc8\x42\x33\x72\xb9\x75\x7a\x3d\xe7\xc4\xef\x7f\x8e\x41\x2a\xab\x85\x7b\x11\x93\x80\xdf\x7e\xb6\xa4\x24\x4e\x40\x12\x6b\x30\x25\x75\xa6\x1a\xa6\x11\x41\x7d\x33\x28\x2b\xc8\x37\xb9\x26\x8e\x41\x81\xfa\xba\xb0\xa5\x5d\x90\xd0\xd1\xfc\xc6\x60\xe5\x56\x5a\x39\x73\xf9\xfb\x23\xfb\x68\x9e\x50\xcf\x9b\x0d\xe7\x8a\xb2\x01\x02\xbc\x3e\x97\x30\x2d\x24\xdf\xa3\x3c\x6a\xc1\x24\xa8\x39\x96\xc2\xe2\x98\xe6\xad\x16\xa4\xd3\xa9\xa1\xe6\x38\x6c\x07\xf4\x40\x4d\x16\x23\x22\x83\x52\xa4\xc7\xc4\xb0\x10\x8b\x63\x59\x45\x38\x24\x25\x9d\x50\x9d\x5f\x7a\xf7\xa3\x5e\x8d\x7b\xb7\x0b\x47\x4f\xc3\x65\xeb\x96\xae\x47\x87\x61\x89\x70\x94\x9b\x38\x70\xf6\x78\xea\x9a\xf0\xa6\x70\x64\xc2\x1d\x62\x1e\x2f\xfc\x9a\x5e\x83\xdf\x6f\x06\xb9\xcf\xa9\xcc\x16\x9e\xd1\x91\xd7\x99\x80\x0a\xb6\x3b\x6a\xd4\x68\xa0\xf2\x45\xf1\xbd\x11\xc2\x9b\x35\xd2\x26\x88\xe2\xb5\x10\x8a\x97\x5c\x58\xbc\x62\x39\x6a\xc3\xdf\xd0\xb9\x37\x66\x6b\x2c\x8e\xa5\x6f\x9c\x3a\x3a\xdf\x35\xf3\xd2\x74\xb7\x7a\xe6\x21\xf8\x35\x7c\xbb\x68\x1c\x3b\x45\x80\xd4\x35\xbc\x13\xf0\xb4\x10\x5d\x15\xa1\xcc\xe4\xbd\xdf\xe2\x3d\xf8\x4c\x7c\x6f\x30\xaa\x37\x2a\x28\xbc\xf3\xbc\x42\x4b\x63\xa7\x0a\xbf\xb1\x1d\x7e\x23\x5e\xf6\xc4\x9d\x56\xa6\xc4\x70\x15\x90\xdc\xa6\x11\xc9\x8d\xcf\x34\x7c\xb4\x5b\x49\x6d\xa7\xae\x41\xe1\xe3\x37\x66\xe6\xb8\x15\xe5\x93\x5f\x13\x3e\x6e\x7f\xe7\x09\xd5\x7a\xa6\x76\x04\xf5\xb3\xb0\x7d\xe1\x34\xe7\x9b\xf0\x8e\xe6\x8f\xef\x9d\x25\xf6\xa8\xfd\x04\xf5\xa1\x7e\x60\x2e\x99\x58\xa0\x16\x31\xaf\xae\xa1\x3e\xe8\x7d\xf1\xef\x8c\xc8\x13\xef\xa3\x1a\xea\x77\x66\x29\xfe\x57\x5f\x54\xa7\x52\xe2\x4f\xb5\x1a\xb5\x92\xfc\x09\x6a\x2e\x92\xd6\xfa\x72\x81\x2e\x39\x01\xa5\xe5\x15\x11\x3d\xe4\x23\x1c\x7c\xbf\xb4\xfd\x0b\x9d\xea\x96\xa0\x9a\x57\xe7\xbf\xd4\xb7\xdf\x9e\x1e\xc2\xf5\xf4\xb1\x3c\x51\xad\x3c\x96\x52\x49\xde\x43\x86\x8a\x9f\x26\x3c\x12\x09\xbd\x86\x3a\xc1\xb2\x10\x47\xfd\x2e\x8d\xc4\x2c\x95\x47\x82\x0c\x00\x6d\xc6\xa2\x80\x8a\x51\x69\x35\x14\x25\x8e\xf5\x66\xda\x58\x5c\x08\xdb\x09\x21\xd2\xad\x88\xfa\x65\x49\x5d\xa7\x17\xda\x97\x32\x4b\x85\xeb\x3d\xf6\xf6\xed\xf7\xfc\xc2\x57\xa5\xb1\x7e\xa1\xe7\x52\x1f\x60\xed\xa2\x05\xce\xa8\x9a\xd1\x22\x95\x56\xa5\xd3\xb3\x5a\x50\xf4\x66\x6a\x66\x1a\x31\x42\x24\x18\x75\x36\x04\x7f\x29\x2b\x1e\x7b\xc7\xa2\x85\x13\xe8\x6f\x0a\x32\xfa\xcf\x19\x3f\xf4\xf6\x71\xad\xc7\x51\x21\x05\x16\x24\x78\x1c\xd0\x6a\x1c\x29\x65\x82\x27\xf6\x4b\x84\xfa\x60\xc2\xc2\xc5\xe3\xc7\x16\x97\xd1\x73\xc7\xdd\x7e\xfb\xb8\x39\xfd\x33\x0a\xf0\x38\x3e\xcc\xfb\xfb\x99\x3d\xe2\x3d\xab\x59\xa3\xb5\x02\xc6\x64\x02\x5a\x64\xc3\x2e\x11\xd2\x68\x94\x86\x63\xa4\x8e\x52\x96\x01\x45\x95\xad\x6e\xac\x20\x27\x57\xa8\xa6\xf5\x51\xe0\x61\x73\x4e\xc9\x03\x3d\x7b\x97\xf5\x56\x1d\xb6\x3c\x7d\xe7\xee\x03\x2b\x66\x62\x26\xdc\xa6\xfb\x68\xcc\x80\x9e\xd5\x85\x33\x96\x1f\xdb\x7f\xcf\x31\x4b\x4b\xda\xbb\xdb\x45\x4d\x1c\x6d\x15\xef\x4e\x6c\x76\x48\x30\x18\xcc\x7a\x45\xca\xab\x25\x25\x9c\x7a\x67\x21\x03\xca\xa7\x78\x5f\x58\x18\x70\x94\x75\xc6\xca\x03\xbb\xef\x7c\xda\x72\x58\x85\x5f\xdf\xf3\x81\x92\x1c\xf8\x75\x8b\xf9\xf8\x3d\xfb\x8f\x2d\x9f\x51\xd8\xa9\xc7\x80\x31\x1f\xe9\x84\x71\x22\xef\x8d\x01\x8b\xe9\xf1\x34\xe1\x3d\x5f\xab\xbf\x07\x44\x5d\xdd\x09\xbc\x49\x6f\xa0\xdf\x06\x2c\xc8\x8a\x72\x88\x66\x19\x2c\x26\x00\x45\x23\x85\x92\x62\x69\x08\x8a\x22\x62\xb7\xe8\x94\xc2\xb0\xcc\x90\x0a\x86\x60\x80\xde\xf0\x85\xf0\xb2\x70\xfc\x2a\x5c\x0d\x6b\xdf\x44\xd1\xe6\xd3\x34\xba\xc9\x78\x78\x30\x9a\x61\x59\x9a\xc2\xe3\x31\xe8\xe6\xe3\x05\x60\x44\x05\x23\x48\x21\x9c\x14\xe6\x5f\x85\x75\xb0\xeb\x17\x6f\xd2\xa8\xf9\x34\x8a\x8a\xe3\xfd\x4a\xef\x42\x57\x98\xe7\x80\x0a\xd8\xa3\x1a\xc8\xb2\x6a\x0d\xa5\x5a\x37\x84\xda\x02\xa4\x2c\x43\x71\x8d\xf8\x50\x38\xa4\x08\x95\x65\x46\xd0\x95\x5d\x17\xe8\x77\x1f\x81\xd4\x97\xf4\x71\xf7\xaa\x55\xee\x6b\xa0\xed\x18\x2a\x8a\x52\x6b\x80\x62\xdd\x10\x90\x36\x46\xa2\x43\x04\xf5\x71\xbc\x1f\x04\xbd\x2b\xde\x5f\x0f\x40\xca\x4d\x8f\xa1\x0e\x8a\x3d\xb5\xad\xcf\x43\xb1\x07\x37\xf5\x22\xec\x9e\xd2\x85\x1b\xdb\x49\x11\xea\xe0\x96\x2d\xf4\x18\x48\xf8\xb6\x94\x3e\x82\x1e\x64\x86\x90\xe7\xb1\xd6\x83\x34\x83\xc0\xc6\x18\xda\x2a\xbf\x92\xc8\x35\x11\x01\x99\x1a\xdd\xb2\x93\x19\xb2\x57\x3a\x33\x1b\xe9\xc3\xa8\x1a\xbf\x83\xc1\xe7\x4f\x4d\x21\x84\x4f\x1e\xab\x60\xd2\xde\x23\x33\x85\x39\xc0\x33\x70\xe3\x3e\x48\x09\x5f\xd1\x87\x5d\xe0\x46\xd6\x2f\x6d\x7e\x1f\x30\x0c\x29\xa3\xc3\x07\xa6\xed\xef\x67\x96\x05\x6c\x3c\xb5\x57\xf8\x8a\xf8\x2b\x87\x7f\xc9\xba\xe1\x92\xe6\x28\x0c\xa2\x0e\xde\x38\x89\x69\x36\xcb\x73\x44\xa0\xa8\xcd\x04\x85\x41\x78\x82\x22\xbd\xa5\xc2\x4b\xe8\xc1\x1b\x23\xf0\xf3\xdc\x73\xe2\x14\xc9\xfe\xca\xd3\x63\x12\xd3\xdb\xb5\x57\xa4\x4d\x98\x84\xaa\x6f\xac\xc2\xb4\x71\xcf\x41\x9a\x90\x25\x0f\x5d\xd9\x8a\x1e\x61\x52\x9c\x9e\xb4\xdf\x01\xa8\xd5\xef\xa4\xae\x81\x30\x49\x5e\x03\x62\x6f\x60\x23\x87\xae\x12\x7b\x9f\x67\x47\x4d\x0c\x84\x58\x66\xe0\xe3\x86\x94\x2a\xc8\xd2\x3c\xb9\xaa\xaa\x91\x72\xff\x53\x1a\x31\x12\x33\x1d\x06\x08\xa6\xef\xf0\x39\xc3\x61\xb9\xf0\xc6\xf0\x39\x74\x95\xf0\x1e\xcc\xbf\x7e\x4e\x2c\xaf\xc6\xb4\x5c\x40\x7a\x79\x5c\x47\x54\x8d\x17\x07\x21\x9a\x81\x64\xb4\x12\x69\x2c\x11\x48\x01\x0f\x23\x0e\x21\xfd\xb2\x24\x07\xc1\x28\xea\x03\xf8\xdd\xff\x96\x83\x99\x37\x95\x83\x57\x12\x62\xb0\xf5\x38\x2a\x44\x26\xa5\xd7\x25\xe4\x60\xfc\x2c\xdd\x54\x0e\x8e\x4a\x88\x41\x3c\xce\x41\xf0\x2c\xf2\x50\x6a\xbc\x3a\xfe\xa8\x8e\xc5\x1b\x0c\x81\x52\xc5\x62\x29\x8f\xf7\xee\x62\x24\xc5\xf4\x21\x27\xb3\x4c\x84\x71\x46\x1e\x61\xf3\xfc\x45\xf3\x9e\x5d\xf4\xd9\x67\xd2\x5a\xa4\x8d\x41\x61\xce\x66\xf0\x18\x90\x61\x14\x78\x7f\x2e\x96\xa4\x8d\x01\x45\x78\xec\xb2\x00\xf2\xcc\x5b\x34\x1f\x4e\x86\x1b\x3e\xfb\x6c\x51\xda\x18\x1a\x90\x1b\x35\xab\x01\xc5\x28\x30\xc3\x63\x7f\x10\x0f\xa3\x66\x59\x15\xd9\x69\xd1\xf8\x90\xa0\xb0\x6c\xb2\x29\x24\x8d\x26\x53\x85\x47\xc4\x64\x41\xeb\xf8\xf1\x8b\xe6\xcd\x23\x63\x66\x60\x4d\xbb\x17\x7e\x28\xf1\x23\x45\xf6\x07\x14\x95\xc8\xfc\x22\xde\xd8\x64\x50\x2b\xae\x89\x93\x80\x90\xc6\x32\xe1\x35\x2c\x13\x34\x98\x4b\x2c\x34\x52\xa9\x91\x5a\xab\xc3\xaf\x45\x58\x30\xb0\xf7\xc5\x44\xe1\x90\x76\x5f\x21\x25\x5b\x46\xc4\xd8\x47\x84\xa2\x46\x3f\x7a\x54\xb3\xdb\x70\x70\xf0\x60\xfd\xe3\x41\x7a\xd7\x7d\x2b\xe7\x57\xd5\x08\x5f\xe3\x71\x3f\xa4\x7f\xa6\x7e\x66\xce\x60\x1a\xb0\xac\x21\xa0\xfb\x98\x8a\xa6\x18\x04\xa9\xb2\x86\x90\xf2\x21\x74\xd0\x3f\x8b\x45\x9a\x14\x9c\x45\x2f\x42\x83\x59\x0d\xa6\xc5\x06\x6e\x8f\xd6\x6a\x01\x30\xb1\xac\xdd\xa1\x32\x6c\x8a\x19\x54\x3e\x55\x91\x6a\x98\x6a\xaa\x6a\x89\x8a\x35\x20\x55\x54\xa5\xed\x81\x77\x9f\xdf\x14\x2b\x42\xfd\x11\x65\x40\x45\xa8\x06\xff\xb0\x04\x6d\x44\xbb\xd0\x29\xa4\x44\x51\xab\xa3\x07\x5e\xbc\xbc\xa1\xd3\xc5\xc2\xc6\xbc\x78\x89\x49\xa2\xac\x97\x8d\xe7\x17\x5a\x15\x69\xfd\xe9\x96\x4f\x9d\xb6\x8c\x74\xa5\xbb\x47\xea\x43\x57\x58\xc9\x74\x1d\x34\x7d\xfa\xa0\xd8\x94\xa9\x83\x93\x0d\xe7\x48\x7e\xf1\x20\x94\x8d\xbd\x6a\x0e\x14\x46\x8d\xac\x42\x61\x34\xaa\x11\x32\x99\x59\xa0\xdb\x10\x03\x2f\xde\x38\x7d\x44\x6d\xec\x81\x97\x9d\x34\xed\x2e\x4a\xbc\x37\xa9\xa3\x45\x63\x46\x42\xe8\x63\xa9\xfb\xa6\xde\x39\xa8\xfb\xb6\x9a\xda\xe2\x82\x72\xbc\x7a\x83\x26\xdd\xd6\x7b\x55\x66\xee\xcc\xb2\xdc\x88\x6b\x6d\x80\xc8\xed\xcf\xf0\x1e\x7d\xcb\x1c\x13\x73\x3e\x1d\x4a\x95\x85\x57\xf1\x0e\xa7\x05\x7b\xb4\x1b\x63\x40\x7b\xef\x10\xc0\x6d\x8c\x29\xc9\x46\x95\xe4\xb5\xdd\xaa\x42\x8a\x28\xeb\x90\x98\x93\x48\x89\x7b\xa6\xa7\x90\x2e\x3f\x36\xa0\xb7\xb7\x20\x5f\xb5\x56\x3b\x75\x6c\xc1\xad\x03\x7a\x7a\x8a\xf2\x95\xab\x95\xa5\xc3\xe8\x5d\xa1\xbc\x50\x51\xed\xce\x25\xf8\x8f\xb2\x8e\x53\x67\x54\x89\xbe\x34\xa0\x1f\x46\x23\x31\x8f\x30\x78\x67\x32\xa3\x9c\x5a\xa1\xa0\x21\x8c\x73\x89\x42\x7a\xb3\xfc\x5e\x79\x79\xcd\xa1\x32\xac\x42\x6c\xe2\xf7\x0d\xff\x3f\xd2\xde\x03\xbe\xe9\xe2\x7d\x1c\xbf\x7b\xcf\xec\xbd\x9a\x74\xa5\xe9\x2e\x50\x68\x3a\x59\x0d\xa3\xec\xd1\x16\x04\x02\x42\x29\x7b\xef\x3d\x64\xcb\x10\x01\x71\x7c\x50\xa6\x38\xc0\x81\xca\x10\x51\x11\x14\x11\x07\x28\x4e\x14\x54\x44\x41\x1c\x38\x50\x71\xd2\x5c\xfe\xcf\xdd\x3b\x49\xd3\x82\x9f\xcf\xff\xfb\xfa\xd1\x57\xd3\x24\xdc\xfb\xee\xb9\xbb\xe7\x9e\x75\xcf\x58\xf7\xe5\x95\x01\xf0\x2b\x6c\x4b\xfb\x3d\xef\x07\xf8\x65\xeb\x97\x8c\xc7\xf0\x4f\xf3\x65\x34\xee\xe3\x39\x35\xb2\x98\x8d\x58\xd4\x02\xd5\x3c\x55\x10\xa3\x85\xf1\x99\x58\xf2\xb1\x4c\xd3\x03\x27\x9a\x4a\xca\x73\x3b\x64\x56\x2c\x58\x3a\x6f\x59\x82\xba\x3b\xcf\x95\xac\xee\xd9\x92\x26\x57\x19\x56\xeb\x33\x29\x67\xd2\xc6\xfb\xf9\x43\xe2\x8f\x00\xa9\x09\x54\x44\xbd\x0e\xa3\x84\xfc\x68\x97\x25\x59\x25\xce\x12\xa7\xec\x94\xb3\x64\x6c\xbb\xf2\xdd\xd8\x6f\xbf\x1d\xfb\x1d\xbc\x5e\xe1\xb7\xff\xf6\xf3\xf8\x9f\x7e\x9e\x70\xf5\xa7\x89\xbf\x5c\x83\xf9\x7e\x87\x0e\xf1\x17\x41\x4e\x36\x83\xb6\xd2\x2c\x60\x77\x20\x1b\xd0\x2b\x9a\x1f\x40\xad\x17\x3c\x89\x36\xa3\x4b\x32\xe9\xa3\x02\x73\xec\x5a\xd2\xe2\x2c\x2b\x60\xce\xd4\x71\x89\x01\xfc\x1e\xec\xc7\x85\x59\x4a\xa5\x1c\xee\x7c\xa7\xdc\x99\x13\xc7\xcd\xcb\x6c\x4b\x42\x6f\xee\x7d\xfe\x75\xf2\x72\xeb\x96\x2d\x93\x52\xb8\xdd\x4b\xa7\xa7\x8f\x9a\x3a\x6d\x64\xf6\xd4\x99\x5c\x67\xd2\x0b\xef\xab\x7b\xbc\xd3\xc4\x19\xe5\xbd\x72\x18\x2f\x92\xf1\x15\xee\x04\xc8\x7d\x40\x6f\x81\xf6\xf3\xc0\x8b\x5e\x00\x1d\x51\x11\x93\x62\x07\x09\x36\x9b\x93\x8f\xe2\x2b\x82\xe3\x3a\x3d\x7b\x2e\xd0\xf5\x9e\x15\x7e\x45\x39\x20\xe3\x99\xbd\x36\x3d\x42\x6e\x9b\x24\xe4\xe6\x79\xf5\x7c\xb2\xc7\x79\x08\xb7\xd8\xa7\x91\xf9\x88\xa6\x55\xee\x6f\x9c\xda\x40\x31\xf1\x95\xfc\xbb\x57\x78\x32\xe7\x4c\xe6\xf8\x67\xf7\xfd\x67\xd3\x4e\xf7\x6e\x43\x97\x7e\x7d\x2b\xda\x54\x6c\x9e\xd9\x66\xfb\xa6\x15\xdb\x6c\x8f\xab\x03\x1d\x3b\x76\x4c\xf4\x57\xe4\x4e\x1a\x5f\xc6\xbd\x31\x75\xc1\xb0\x71\xee\xe2\xa6\x4d\xf2\x32\xf2\x0c\xa9\xa5\xb7\x76\x9c\x38\x6f\xfc\x70\x4b\xf3\xa6\xe9\x79\xee\x14\x9b\x49\xe3\x6a\x39\x88\xc9\x62\x3f\x81\x5c\x08\x7a\x09\xe8\xab\xcd\x39\xc6\x52\x41\x77\x88\xc8\x8a\x16\x89\x63\xfe\xb1\x18\x34\x0a\x7e\x00\xe3\xe9\xae\x00\x20\x1e\xc6\x92\xcc\xe4\xa8\xfc\x28\xda\x51\x2f\x40\x16\x6f\x3b\x60\x3f\x39\x8d\x2f\x89\xde\x27\x1a\x3c\x47\x69\xb4\x01\xf1\xc0\x9b\xb1\x4a\xcd\x83\xc6\x2a\xd3\x87\x23\x95\xb3\x28\x61\x8d\x3e\x6f\xf6\x2b\x3d\xb4\xd8\xcf\xbf\xfb\x04\xae\x6a\xdc\x87\x5e\xa4\x83\xdf\xac\x0b\xbf\xff\x26\x7d\x70\xb7\x3f\xc1\x6d\xfe\x7f\xec\x03\xb7\x7b\x82\xbf\x70\xc3\x1a\x70\x80\x0d\x54\x2a\xa2\xb2\x46\x7e\x6c\x0d\x72\xb0\xf2\x24\x49\x84\x07\x9f\x10\x99\x6c\x8b\xa7\xc3\x73\x03\xf9\x29\xca\x73\xb0\x68\x58\x96\x14\x19\x34\x3f\xfe\xc2\xdb\x6f\xf6\xf2\x03\x49\xc2\x4c\x3c\x8d\x9f\x12\xe2\xe2\x9f\x93\xa9\xbe\x08\xbc\x11\xce\xbb\x5a\x05\xb2\x27\xac\x62\x1c\xd0\x51\xbc\xf1\xb2\x82\xad\xb4\x8f\x75\x33\xa1\x13\xbc\x88\x2c\xe1\xa7\x90\x25\xb0\xbf\x7f\x84\x7e\xe1\x3f\x0e\xcb\xac\xc6\xbc\xf9\xaf\x21\x8c\xd6\x17\x0a\x8f\xf3\x9b\xa4\x44\x26\x9f\x24\x07\x74\x02\x02\xfe\x80\xa1\x77\x5e\x12\xeb\xc9\x40\xb4\x67\x1a\x0a\x0f\x3b\xbb\x29\xb4\x85\x0a\x52\xdc\x08\x71\xe3\x1a\xb2\x6e\x0d\xa3\x4d\xdf\x01\xdd\xbf\x08\xba\x9a\x1a\xb4\xda\x66\x01\x40\x73\x18\x06\x81\x3e\x8f\xcc\x76\x9b\x6c\x36\x5b\xd4\x06\x81\xf5\x57\x0f\xac\x92\xf9\xb2\x40\x49\xb0\xed\x2b\x06\x45\xd0\x2b\xc6\xde\xf1\x17\x5b\xb4\x3e\xb4\x62\x11\x4e\x21\x39\x05\xad\x0e\x2e\x83\x37\xc2\x2b\xb3\x0e\xf6\xdb\x7d\x1f\x16\x5e\x5e\xb8\xbf\x9a\xfe\x8d\xf8\xe5\x92\xcd\x9c\x2f\x7c\x18\xe4\x7b\x90\x43\x78\x51\xc4\x2a\xe0\xfa\x02\x17\x15\xec\x23\xa1\x36\xbc\xdf\x59\x02\xd2\x54\xe9\xde\x45\xbd\x7b\x2f\xda\x4b\x36\x63\xef\xb6\x6d\xe4\x8b\x1b\x9f\xc7\x22\x06\xc5\x00\x16\x18\x18\x75\xdc\xf3\xa2\xd5\x97\x25\xfb\xac\x78\x9a\xf2\x7c\x47\xf2\xc5\xb6\x6d\x58\xd1\x57\x5e\x03\xf1\xf3\x72\xf8\x37\x78\x3e\x31\xa0\x05\xd9\x43\x12\x25\x95\xac\x48\x9e\xf1\x12\x95\x33\xc3\x2e\x3b\xed\x19\xaf\x29\x03\x1f\x51\xfa\xb9\xe1\x79\x80\x1c\x56\x1f\x66\x00\x1a\x70\xfe\x3b\xf1\xbb\xaa\xc7\x45\x25\x59\x45\x22\xbe\xac\x0c\xfd\x57\xa4\x03\x0e\xdd\x0b\x32\xb2\x2d\x7c\x86\xf1\x6a\xd8\x3f\x0b\x88\x72\x12\x72\x25\xd8\x79\xa3\xba\xf1\xfe\x89\xff\xc2\x6b\x39\xdb\xc4\xea\xca\x29\x53\x2a\xab\x26\x0d\xf3\xe7\xe6\xb6\x68\x91\x9b\xeb\xff\xae\x7a\xd2\x84\xbe\x7d\x26\x4c\xac\xce\x2d\x2c\xcc\xcd\x2b\x2e\x56\xd6\xba\x1d\x7a\x15\xff\x8c\x3f\x8f\xc9\xcc\x74\x99\xa2\xf2\x6f\x53\x4c\x65\x66\x3c\x90\xc9\xcc\xaf\x46\x44\x66\xc4\x85\x8f\xa2\x57\xb9\x2f\xd8\x33\x5a\x0a\x9f\x2c\x62\x8d\x46\x8f\x75\x2a\x5e\x8a\xac\x31\xf6\x33\x93\x25\x74\x51\xc2\xc4\x6e\x3f\x7b\xfd\x84\xf5\xf3\x79\x7d\x6f\x4a\x8f\x37\xf4\x87\x34\x12\xcf\xeb\xa5\x9b\xf6\x97\xc1\x44\x72\xaf\x22\x98\xb7\x60\x82\x79\xe8\x6f\xf6\xe7\x55\x26\x9e\x47\xf5\x94\xf0\x35\x72\x27\xf7\x6c\xf8\x5e\x94\x40\x71\xc0\xe1\x51\xbb\x2d\x6a\x64\x17\xf5\xb0\x7e\xc7\x3f\x3f\xee\x67\x3d\xc6\xb3\x70\x2e\x8e\x85\xe3\x2b\xd9\x95\x3d\x3a\x7a\x32\x72\x34\x0b\x54\x79\x7d\x3b\xe6\x54\x77\xef\xe0\x6e\x92\xae\x9e\x27\x36\xe9\x4b\xee\xf4\xe5\xf8\xf2\x03\xa3\x46\xb7\x4a\xcb\x4d\x6b\x59\x38\x6c\x6c\x1b\x7a\x4e\x5e\xc3\xc7\xf0\xd7\x4c\x6f\x63\xa7\x19\x09\xa0\xda\xca\x2a\x35\xf5\xe3\xe0\xe0\x84\x9c\x62\x1a\x77\x1c\x03\xa7\xae\x35\xf0\xfb\x1a\x4e\x25\x17\x70\xaa\xb0\x8f\x86\x0b\x84\x4c\xd4\xc9\x46\xd9\x93\xc7\x84\xc5\x9c\xc4\x68\x11\xc0\x2e\x00\xfe\xc3\xb6\xe0\xc5\x80\x3e\xee\x53\xf5\xf8\x0b\x2b\x00\x92\xea\x63\x78\xf0\x77\x33\xc4\x53\x53\x3f\xbd\xe1\x39\xca\xd6\xe0\x39\x71\x31\xa0\xad\x3b\xfe\xdc\x30\x59\x99\x93\x66\x7c\x87\x07\x0b\x8b\x3f\x9d\x4a\x9f\x23\x63\x39\x29\xfc\xac\xf2\x1c\x07\x3a\x9d\x24\x73\x37\x3c\xe7\xa4\x17\x73\xde\xc7\x66\x7c\x47\x1e\xea\x0e\x4f\xa1\xc6\xcf\x51\x29\x1f\x9e\xbb\x01\x4e\xcc\x24\x7c\x4e\x22\x0f\x7d\x37\x83\x8c\x05\x40\x31\x4a\x06\xf9\xce\x14\xfe\x30\x42\x9d\xe0\x5c\x50\xfd\x40\xc0\x12\x1f\x7f\xc2\x23\x74\x0f\xc6\x2c\xf2\xf3\xa6\x90\x61\x27\xde\xf3\x10\x9c\xab\x85\xe7\xcf\xb3\xb1\xa3\x7d\x44\xe8\x2e\x1d\x5b\x51\x25\xe3\x47\xa6\x4f\xb3\x67\xb9\x4a\xf6\x28\xf3\x89\xea\xcf\x4d\x45\x9b\x81\xa6\x65\x07\xcc\x2a\x8c\x65\x6a\x7c\x12\x91\x46\x8b\x55\x2a\x50\x78\x60\xb3\xf2\xfd\xf5\x37\x04\xac\x84\x86\xe8\x75\xfa\xf8\x22\xab\x5f\xf6\x72\x53\xc9\xe0\x47\x67\xbe\xf6\xda\xcc\x47\xf1\x43\x2f\xfc\x8c\x3d\x06\xec\xf9\x19\xe1\xd0\x47\x52\x7a\x78\x99\xdc\x16\xba\x31\x1e\x00\x20\x16\x23\xba\x72\x38\x3f\xa6\x05\x93\x9f\x18\xce\x4b\xe9\x0c\xe1\x31\xa9\x95\xd2\x91\x31\xd2\x1e\x38\x4d\xb4\x7d\x41\x54\xe3\x24\xb5\x0c\xa3\xa5\xf4\x08\x36\x03\xcf\x0e\xaf\x14\xb6\x73\x63\xc4\x67\x4d\x32\xb7\x92\xdc\xa5\xd8\x9d\xeb\x86\x48\xbe\x70\x8a\x9c\x07\x38\x0e\x72\x9e\x03\xb0\x1b\x70\x1c\xe5\x1f\xf7\x7f\x5e\x70\x5c\x19\xfd\xa6\xe8\x4d\x6e\xf9\x57\xf4\x96\x7c\x37\xa2\x37\xc0\xfb\xb6\x98\x8e\x5b\x30\xfc\x56\xed\xa5\xfa\xb1\x5f\xb1\x2c\x90\xb7\x99\x65\xe1\x14\xd5\xbd\x43\xbb\xa5\x00\xd7\x4e\x5a\xc7\xda\x30\x9d\x48\xd1\x41\x42\xbb\x85\xfb\xa5\x40\xaf\x5e\xac\x9f\x6d\xc2\x63\x78\x98\xf8\x03\xd2\x23\xc3\x01\x8d\xb0\x58\xa6\xcd\x00\x55\x5a\x34\xe7\xa9\xd6\xa3\x88\xa4\x20\xbb\x73\xff\x39\xa2\x7d\xc8\x34\xa6\x73\xe7\xb1\x86\x87\x2d\xcf\x0b\x8f\x1d\xbc\xb3\x67\xb0\x7f\xef\x7b\x9e\x66\xf7\x2a\xd3\x85\xdf\xd0\x5a\xa6\xfb\xc4\xc6\xe1\x61\x9c\x3b\x63\xaa\x0e\xe2\xc8\x8b\xc2\x2f\xb8\x53\xe4\x3c\x1a\x0e\x80\xb6\x27\xd0\x86\x6c\x2f\xad\x45\x0c\xa1\xec\x13\xcf\x86\x66\x9e\x11\x7e\xf9\x14\xfe\xb1\xb5\x24\x46\xf1\xc1\xf0\xc7\xd2\xdf\x20\x97\x02\x4e\x1a\x01\x21\x0c\xa2\xc0\x71\xb2\xde\xc8\x28\xae\xe9\x04\x8d\x88\x60\x34\x83\x2f\x8c\xe4\x7a\x52\xec\x73\xa0\x51\x7f\x73\x77\x61\xa9\xb6\x64\xca\x9d\xf7\x0c\x18\x72\xdf\x3a\xa9\xba\xad\x6a\x94\xb6\x77\xd7\xa2\x2e\x72\xeb\x39\x40\xdb\x02\xc2\x22\x74\x54\x24\x8c\x96\x1b\x0e\x18\xd5\x2f\xdb\xe9\x02\xb2\x59\x5b\xff\x85\x76\x1f\xbd\x81\x74\x8b\xe5\x37\xa1\xdd\x1c\x69\x22\xec\xc0\xeb\xd8\x79\xd7\x42\xdf\x6a\x58\x51\xca\xa2\xe0\xd0\xb2\x53\x6e\xf5\xdb\xad\xec\x95\xbc\x10\xd5\x12\x76\xa4\x61\x4d\x1e\x09\xd3\xd7\x86\x38\xb5\x2a\x8a\x53\xe1\x83\xc2\x48\xd4\x2d\xb2\xd7\x94\xe3\xbd\x4d\x15\x0e\xb3\xbf\x5b\xc4\xe8\xc4\xe8\x7f\x29\xb4\x79\x23\xb2\xbe\xba\xfd\x20\xb2\x28\x36\x37\x58\x1b\x68\x49\x4d\x38\xa5\x1b\x36\x60\xb4\x61\x03\x7d\x82\xdc\x4f\x9f\x6a\x0c\xab\xcc\x2d\xd6\x8a\x51\x58\xf9\x22\xbf\xd5\xee\xc3\xec\xb5\xed\x95\x2f\xd7\x85\x9a\xc0\x8b\xf8\x60\x1e\xf9\x23\x0d\x63\xfa\x4a\x9f\xdf\x2d\x6c\xc1\x03\xa4\xa7\xa9\xde\x8d\x6c\xcf\x19\x64\x59\x8b\xb8\x97\x05\x46\x6a\xfc\x65\x14\x23\x29\x16\x34\xc4\xa3\x55\xd8\xb6\xf6\x9e\xe7\x01\x95\x86\x56\x74\x19\x02\xa8\xb4\x57\xbc\x70\xfa\x34\x39\xbc\x67\x7d\x2f\xf8\xb7\xe9\x61\x65\xdf\x9f\x14\x1e\xc6\x7d\xc5\x0f\x18\x4e\x22\x79\xb1\xa0\x8d\xee\x8e\x39\xaa\xda\x31\x2b\x74\xc7\x91\x86\xad\x96\x7d\x1b\x36\xec\xb3\x6c\x35\x8c\x10\x03\x55\xdd\x37\x6c\xdf\xbe\xa1\x7b\x95\xb2\x66\x93\xf8\x72\x74\x17\xb3\x69\xeb\xf6\x33\xbb\x38\xa5\x22\x14\xa2\x98\x61\x7d\xe3\xcd\xec\xea\x0d\x9e\x53\xab\x61\x69\x94\xe7\xac\xf5\x66\xf4\xbb\x6e\x62\x45\x8f\x7f\x8e\xca\xaa\x6a\xb5\x88\x39\x0e\x24\x84\x7c\x66\xd7\x8f\xf2\x98\x98\xf9\xfc\xce\x9b\x58\xcf\x31\xb2\xf1\xe5\xb8\xe4\xc6\xb1\xe3\x4c\xf8\xb8\xe4\xc6\xc1\x71\x38\x87\x4c\x40\x1f\x33\x7b\x99\x66\x1f\x5a\xcc\x53\xca\x05\xa3\x31\x32\xd7\xbe\x91\x6d\xed\xe6\x6d\x79\x46\xe2\x3e\x6e\x68\x53\xc3\xe1\x8e\xa4\x3f\xda\x11\x3e\xce\x30\x4a\xe4\x04\x85\xf1\x03\xd7\x31\x2b\xc6\x98\x1d\x0b\x2e\x5c\x68\xcd\x4c\x44\xd0\x76\x28\xb4\x3d\x1c\x69\x8b\xa5\x58\x5b\x99\x95\x3c\xf1\x99\xd3\x2f\x5c\x58\xd0\x9a\x99\x82\x60\x7f\x57\x0a\x2f\xe0\xb9\xd2\x46\x06\x03\x43\x54\xe5\x74\xb0\xbc\x45\x73\x1f\x0a\xed\xe5\x7e\x85\x06\x65\xdb\x19\xbc\x3f\x70\x7f\x03\x2e\x28\x6b\x22\x08\x92\x26\xba\x8f\x6c\x39\x68\xd6\x42\xd9\x36\x7e\xfa\x42\x2c\x3f\x79\x98\x5f\x62\x58\x36\x1e\x0b\xef\x1f\xfe\x3c\x09\x9e\xbb\x93\xf4\x42\xd3\xc2\x9f\x20\x1d\xa5\x8f\xb0\x0f\xef\xc0\x8a\xc4\x5b\xc9\xa6\x45\x8c\x64\xa4\x57\xbd\x95\x8c\x8e\xd7\x15\xe6\x71\x30\xbc\x9f\x51\x29\x50\x01\xa8\x80\x78\x4a\xa1\x52\x11\xab\xd8\x41\x72\xf7\xbc\x05\xb3\x49\x7f\x66\x15\x6b\xd8\x1e\xa8\x1a\x63\x57\x8a\x24\x1a\xb1\x80\x1d\x9c\xbd\x60\x1e\x9e\xf8\x66\xc4\xfe\x15\xee\x0c\xed\x0f\x41\x7b\xa0\x3d\x01\x6a\x3b\x53\x6b\x40\xbf\x50\x33\x1e\x19\x75\x1c\x8d\x33\x76\x1d\x9a\xcf\xfe\x91\x37\xa7\x4d\x9b\x3a\x77\x2e\x3d\x1b\x7d\xc8\x19\xbc\x27\xbc\x5e\xa1\xfb\x9c\x42\xf7\xe1\x94\x91\x3e\xa0\x87\x9c\x79\xfe\x79\x36\x86\x03\x18\xab\x0b\x8d\x80\xf3\xa3\xd9\xa7\xa1\x5b\x41\xd7\x37\x23\x2e\x12\xb7\x0d\xe8\xcc\x5b\x95\x34\x68\x4b\x46\xec\xdd\xfb\x04\x4b\xf6\x72\x88\xf1\x70\x04\xbc\x98\x8b\x3c\xcb\x53\xd6\x75\x4a\x79\x36\xee\x2a\x32\x9a\xb6\xe0\xd1\x2d\x23\x0e\x45\x82\xf4\xf7\x32\x7e\x38\x9d\x6c\x44\x6b\xc3\xb5\x26\x59\xf5\x0b\xfa\x00\x29\xf4\xf0\x05\x32\x0d\x57\x84\x7b\x46\xe8\x3e\x88\x61\x22\x05\xda\x1f\x4f\xf7\x27\x50\xba\x4f\xa6\x45\xe9\x3e\xd0\x67\x58\xa3\xa3\x11\x59\xdb\x70\x80\x8a\xd8\x2e\x64\x3a\x5f\x40\x21\x71\xfe\xff\xa6\xcf\x37\x88\xd6\x38\xbc\x82\x94\xa1\x79\xe1\x7d\x20\x67\xe8\xf6\xcb\x82\x5a\x03\x9d\x9e\xf2\xb3\x3e\x99\x36\x54\xe4\x9f\x97\xe7\x5f\x3d\x64\xc2\xef\xa7\xba\xce\x6c\x33\xa2\xd3\x69\x46\x8b\xae\x93\xc1\xd8\x12\xfe\x15\x20\x01\x3a\xc2\xeb\xed\x8c\xf5\x44\x64\xfc\xc8\x75\x2c\x65\x3e\x25\x2c\x73\x3d\xb6\x1c\x79\xf2\xd6\xaa\x9e\x3d\xfb\xd5\xce\x2f\xef\x98\x6c\x4b\xcf\xcc\x4d\x98\xbb\xf6\xd4\xc8\x69\xfa\xf9\xda\x66\x79\x7d\x6d\xe3\x05\x95\xc8\x8f\x52\xf0\xac\x0b\xcc\xf1\x14\xbc\x33\xc3\x3a\xeb\x91\xac\xac\xb3\xf5\x06\x5b\x59\xd1\xe4\xdb\x2a\x4a\xb7\x15\xf8\x63\xa6\xb2\xf6\x73\x33\x73\x46\xe6\x47\x4c\x65\x94\x37\x40\x3f\xdd\x98\xed\x1e\x78\x2f\x1f\xcf\x1b\x62\xf6\x7a\xb2\x12\xde\xce\x65\xb2\x1d\x9c\x63\x6a\x17\x57\x38\x03\xcd\x36\x49\x93\x87\xc1\x99\x23\x7d\x76\x72\xbf\x92\xfe\xe7\xcf\xe3\x85\xd0\x7e\x2f\xd9\x8e\x7b\x87\x17\x21\x1b\xf2\x04\xb4\x16\xbd\x9e\x07\xd1\xd9\x48\xe3\xe8\x40\x8e\xa9\xaf\x4e\x21\xb2\x1b\x69\xb6\x1d\x7e\x40\x0f\xe5\x05\xf7\xe6\x86\x0f\x18\x58\x52\x32\x68\xe0\x88\x31\xb7\x0e\x1c\x7e\xeb\xc0\x25\x63\x67\xb7\x69\xb3\x60\xc4\x54\xf8\x47\x71\x84\xdc\x45\x24\x3c\x2d\x9c\x48\x75\x63\xf2\xe4\x5f\xd3\x19\x7c\x77\x11\x15\x7c\x97\x0c\xfb\x92\x1e\xb0\x22\x2d\x2d\x65\xbc\x58\xe4\x02\x46\x4b\x17\xc4\x99\x38\x40\xc7\xfc\xc1\x79\xc0\x96\xca\x58\x8d\x8c\xf8\x7b\x1f\x3c\x2d\x7a\xef\x43\xd2\xeb\xef\x7d\xc8\x7f\x88\x19\x0f\x0a\x67\x01\xfe\x40\x7f\x1a\x3d\xaf\x93\xd4\x20\xd0\xb1\xfe\x68\xfa\x00\x44\xfb\xa3\x95\xc4\x23\xfd\xf1\x71\xf6\x5d\x75\x9c\x79\x97\x98\xa3\xe6\x5d\xe8\x73\x37\x19\x8b\x07\x84\x57\x33\x9e\xa4\x8d\x97\x93\x64\x85\x19\x45\xac\x8e\xdc\xfa\x43\xd6\x87\x0d\x43\xba\x54\x0c\x35\x3d\xa4\x7d\x61\xf6\xa6\x55\x81\x2e\x5d\x02\x8b\x1e\x54\xf6\x7c\x2c\xb9\x9d\x9b\x19\x7e\x10\xb9\x50\x46\x40\x6b\x77\xab\x13\xcc\xa2\x4d\xb7\x58\xc5\xcc\xa7\x6a\x3d\x33\x9f\x16\x50\xb8\x62\x13\xbd\xa9\x35\x13\xdf\xf7\x6f\xd6\x4c\x72\x7b\x63\x6b\x26\x26\xa7\xc9\x0b\xd8\x1f\x1e\x06\xf8\x91\x18\x30\x62\x24\x20\xc5\x64\xcc\x23\x9e\x62\xcb\xe0\xc1\x6f\xc3\x58\x05\xca\xb5\x0d\x39\x4d\x65\xc7\x6d\xbb\xe9\x3e\x85\x8e\x87\xd3\xb9\x07\xc2\xcb\x4d\x32\x6a\x1f\x7a\x33\x72\x96\x5f\xab\x0b\xe1\xd2\x70\x9b\x88\x8c\x01\x12\x1c\x17\x39\x0d\xcc\xb2\x4d\xa9\xd0\x6b\xdc\xf4\xd0\x9d\xdc\x74\x32\xed\xe4\x49\x72\xc7\x9b\x6f\x02\x4d\x18\x8b\xde\xe6\x66\xe2\x6f\x41\x9e\xd9\x4a\x56\xd7\x35\x63\xfb\xf3\x22\x0a\xe3\x0a\xfc\x3e\xc3\x59\x66\xcf\x51\x6c\x1e\xb8\x22\x34\x8b\x5b\x83\xc2\x1f\x50\xd9\xf5\x20\x0a\x73\x37\x69\xc3\x55\x5c\x9f\x2a\xac\x57\xda\x90\xe4\xf0\xf7\xf8\x6b\xfe\xc9\x78\xdc\xcf\xc0\x4e\xf8\x9e\x2f\xbe\xab\xee\xd4\x52\x3e\xf7\xde\x3a\xda\x2e\x2c\x85\x3f\x46\xff\x44\xe4\x27\xba\xfb\xd0\x4e\xc6\x7e\xfc\x0f\xf6\xbd\x47\xbe\xca\x11\x7f\xff\x47\xab\xec\xcf\x5a\xe0\x19\x53\x23\x3c\x43\xa7\xf0\x0c\x3e\xfe\x86\x66\x46\xe4\x82\x86\x1c\xab\xbf\xa1\x69\x7c\xbe\x62\x2a\x53\xbd\xa6\x84\xe7\x36\xd0\x94\x38\xc6\x57\x0f\x87\x4f\x47\xd6\x51\x56\x9e\x60\xe7\x9f\xba\x36\x15\xf9\xec\x87\xc9\x2a\x3c\x67\xd8\x01\x78\x60\x0e\xf9\xfe\xc0\x01\x3a\xc6\x33\x64\x27\xae\x0c\x2f\x45\x0e\x7a\x0f\x85\x74\xbc\x4a\x65\x96\x16\x5b\xa9\x24\xec\xfe\xac\x00\xb0\xe5\x04\x7d\x9c\xb9\xf2\xf9\x0a\x63\x38\xc3\x12\xf5\x3b\xbf\x54\xe7\x78\x6f\x1d\x3e\x30\x2d\x57\x3d\xc5\x30\xb2\xc7\xa0\x92\x92\x7e\x3d\xc7\xe8\xc9\xc7\x69\xee\xa9\x53\xdd\x69\x95\x83\xda\xb4\x19\x18\x91\x99\xf2\x85\x79\xe8\x7d\x29\x19\xce\x8d\xfc\x8c\x88\x12\xa8\xd8\x23\x67\xc9\x59\x11\x33\xf2\xfb\x83\x67\xce\x18\x3c\x67\xce\xe0\x19\x33\x07\xcf\x12\x3e\x1e\x3c\x77\xee\xe0\x99\x33\x07\xcf\x9e\x3d\x78\x26\x7b\x76\x8b\x30\x09\x8d\x90\xa6\x02\x6e\xab\xf6\x0a\x26\x20\x67\x54\x2a\x6f\x8b\x29\xd3\x50\x02\xca\x59\xfc\x35\x8d\x1b\x1f\xd1\xac\x67\xcf\xcc\xe6\x9e\x54\x4f\x70\x72\x66\x53\x77\x8a\x5b\xfc\xbc\xa0\x4d\xaa\x18\x94\xdd\xa9\xd6\x16\x25\xad\x93\xdb\x75\x57\x0d\x92\x5c\x69\xb6\x16\xa5\x34\x3f\x6c\x68\xbf\x94\xce\xf5\x90\x93\x23\xfc\x43\x90\x16\xe3\xd8\xc9\xa3\x18\x47\xaf\x77\x42\xfb\x85\xfb\xaf\x8f\x06\x9d\x26\xbd\x57\xaf\x27\x99\x5a\x03\xeb\x55\x2d\xec\x43\x88\xc9\xb6\x20\x33\x2b\x7b\xce\x33\x89\xe8\xde\xf8\xdb\x4f\xe8\x0c\x54\xfd\xa7\x1a\xb6\x33\x33\x69\xa8\xc1\x25\x2b\x26\x3b\x84\x27\x71\xad\x78\x00\xf4\x3a\xcb\x41\xd0\xea\x16\x47\xd4\x3a\x37\xe8\x75\x94\x6e\xdf\x4c\xa9\xfb\xcf\xbf\xea\x74\xc2\x93\x37\xd3\xe9\x40\x86\x5c\x03\x32\xe4\x29\x5a\xb8\xef\x80\x0c\x0c\x4a\xf1\xe5\x60\x4a\x49\xc4\x5c\x77\x57\x8b\xd6\xcc\x48\x27\xaa\xe7\xee\xeb\x1b\x31\xce\xf1\x24\x5f\xd8\x8e\xdf\x13\x2f\xc1\x1c\xd4\xd4\xc7\xe7\x39\x9a\xdd\x4f\x8a\xa8\xb0\x11\x17\x2f\x26\xe1\xc1\x02\x28\x1c\x77\x6d\x05\xc6\x9f\x63\xcf\xd9\xba\x21\x67\x84\xed\x5e\x9c\x9e\x41\x2e\x98\x18\xfb\xc5\x61\xc0\x52\xf4\x60\x78\x09\xf4\xa3\xdb\x0f\x64\x58\xcf\x0c\x0e\x94\x47\x3a\xea\x83\xa0\xfd\x15\x76\x97\xc1\xdb\xa4\xa8\xcb\x2d\x3b\xbf\xf5\x3a\xa5\xe5\xda\xaa\xce\x1b\xd9\x39\x10\x1e\x07\xb9\x2e\x8b\x61\x35\x2f\xc7\x34\x90\xc6\x7c\x46\x78\x9c\xf1\x19\x8e\xe8\x01\xc1\xaf\x86\x6f\x8b\xec\xad\x28\x2c\x66\x04\x85\xed\xad\x08\x8f\xd0\x5f\xa2\xe7\x2f\xd6\x25\xf1\x17\x7f\x18\x37\xee\xa5\x71\xe3\xe0\xec\xb4\x01\xf8\x5e\x65\xfc\x4e\xe1\x66\xb1\xd3\x46\xf5\x1c\xca\xf9\xca\xd6\xac\xa9\x5b\xb3\x86\x32\x3f\x45\xcd\x61\x72\xec\x58\x98\x13\xb5\x89\x00\x5c\x8a\x31\xe4\x6d\xe5\xd2\x06\x20\x7b\x90\x1a\x5d\xc8\x58\x66\x3e\x81\x39\xec\x14\x66\xe1\xe1\x92\x1a\x25\x51\x3f\x06\x9d\x51\x63\x36\x7b\x10\xc7\xd9\xf4\x9a\xc5\x89\x62\xc2\xbd\xf4\x06\x01\xd6\xa3\xa0\xc0\x52\x56\xe6\x57\xac\x5f\x7c\x66\x6c\xe7\xe9\x29\x71\x44\x36\x1f\x58\xa3\x9c\x55\x99\x61\x8f\x6e\x7f\x49\x9f\x56\x35\x2d\xd3\x9c\x11\x04\xa8\x28\x18\x50\x31\x44\xf4\x99\x18\x0e\xe4\x8d\x29\x1a\x65\x62\x58\xd0\x64\x5e\x31\xdd\xcf\xaf\x85\x2b\x38\x41\xce\x83\x39\x26\x21\x2f\xf2\x05\x8c\x0e\x9d\x90\xa0\x36\x0b\xf0\x93\x92\x82\xb8\x64\x2a\x2c\xf8\xcd\x8a\xcf\x88\x72\x41\x0a\xea\x9a\xdd\x79\x53\x24\x94\xe1\x7f\x2a\xd6\xf8\x53\x03\x6d\x8a\x1d\xa9\x29\xf2\x08\x95\xaf\x7d\xb1\xb7\x5d\x9b\x22\xbb\x2f\x51\x55\x2b\xfa\x3a\xfc\xb6\x46\xba\xeb\x81\x07\xae\x26\x7a\x13\xb3\x0a\xfa\xf7\xca\x4f\xf4\x7a\x9a\xe5\xf6\xa9\x6a\x7e\xf0\x81\x07\x14\x9a\xbf\x03\x70\xab\x56\xfa\x0c\xf0\xde\x4f\xbd\x83\x14\x83\x46\x7e\x4a\x56\x13\x9f\x5b\x31\x6b\x7c\x78\x9e\x19\x37\xfe\xed\x10\xf0\xff\xc7\xa3\x51\xf1\xaf\xff\x23\x7e\xd8\xf8\xd0\x90\x93\x37\x39\x46\xb0\x87\x84\x0c\xc3\x5c\x98\x9e\x23\xd3\xb3\xb2\x80\xd5\xbc\x44\x45\xce\x53\x05\x14\xaf\x64\x20\xaf\x59\x25\x76\x7f\x11\xe6\xd6\x7d\xbb\x6e\xdd\xb7\xdf\x1f\x58\xb0\xe0\xc0\xc1\x05\x0b\x28\x9e\xf4\x60\xb2\xfc\x29\x50\x17\x00\x1b\x41\xec\xa0\x2c\x25\x72\x7a\x7c\x25\x20\xcf\x97\xd2\x96\xa4\xff\x37\xeb\xd6\x51\xa3\xa0\x2b\xe4\x80\x05\xfa\x9e\xd1\x0e\x7a\xee\xec\xac\xee\x4a\x53\x54\x84\xda\xa0\x0a\xd4\x1d\x55\xa1\x20\xaa\x45\x63\xd1\x54\x34\x17\x2d\x41\xab\xd1\x5d\xe8\x7e\xb4\x15\x3d\x88\x76\xe1\xd6\x81\x5d\x0f\x74\x79\xf4\xd1\x87\xa6\xcd\x1a\xb7\x74\xe9\xa4\xdb\x3b\xed\xac\xde\xb8\xb1\xdf\x7d\xc5\x6b\xd6\xb4\x5c\x27\x6f\x6f\x36\x6f\x5e\xc1\x6d\x8e\x61\xc3\xdc\xa3\xa4\x6d\x86\x81\x03\x2d\x43\x92\xdb\xb6\x4d\x6b\x9f\x99\xcb\xf7\xec\x99\xdb\x7e\xc8\xb6\x51\xb7\x6d\x5f\x77\xdf\xce\xdb\x67\xe9\x7b\x6c\xee\xfa\x90\x16\xf7\x46\x9a\xde\x7c\x8f\x87\x7a\xec\xd6\x6e\x7e\x74\xc1\xe2\xca\x87\x47\xac\x5d\x3b\x66\xc3\xad\xf7\xdc\x33\x74\x53\x60\xf9\xf2\x8e\xab\xb2\x67\xcc\x68\x32\x27\x75\xc2\x84\xf4\x29\xa6\xbe\x7d\x6d\x03\x70\x57\x57\x69\x69\x62\xeb\xe6\x85\x8b\x1f\xde\xb0\x69\xd5\x9c\x29\x03\xba\xb6\x2e\x2c\x6c\xdd\x75\xc0\x94\x39\xab\x36\x6d\x78\x78\xb1\xb6\xdb\x8e\x5e\x8f\x3e\xba\xbd\xe7\x43\xba\x2d\x32\xdf\xb9\xb3\x4a\xe8\x46\xd7\x8d\x62\xd8\x89\x82\xc8\x1b\x8b\x13\xb0\x2e\xf6\xcf\x5c\x1f\x31\xf3\xdf\x5f\xcc\x7e\xd3\xf1\x02\xe6\x39\xeb\x8c\x04\x58\x58\xe2\x02\x4d\x6e\xd2\xc9\x4d\xde\x47\xdd\x22\xd9\xa9\x15\xa9\xbc\x00\xa7\x3d\xc3\xe6\x4b\x2b\x2a\xf4\x17\x64\x45\xfe\x5a\x23\x7f\x9d\x91\xbf\x38\xf2\x57\x6e\xf4\x99\x7a\x14\x00\x45\x62\x3a\x1d\xfe\x1f\x6d\x1b\x7f\xce\x68\x34\x56\x74\xec\x0c\x6a\x69\xf1\x52\xd8\x80\xef\xfb\xb9\xef\x27\x5e\xc0\x3d\x43\x2f\xd1\x70\x38\xae\xc3\xc4\x89\xe4\xae\xc2\xd2\xd2\xc2\x7b\x0b\xcb\xca\x0a\xff\x2e\x29\x2e\x2d\x4a\xa7\x1f\x09\x48\xfb\x25\xc5\x4f\x95\x16\x15\x95\x72\xfd\x4a\x8a\x8b\x4b\xea\x96\x5f\x98\x88\x7b\x0a\x2b\xc9\xfe\x0b\x13\xeb\xd4\xc5\xf0\x8f\x5b\x43\x5f\xef\x2b\x2a\x2d\x2d\x0a\x3d\x56\x54\x5a\x5c\xe2\xa3\x9f\xf1\x5b\xf4\x41\x12\xa4\xcf\xfc\x4d\x1f\xbf\x8f\x7e\x4b\x36\x4c\x9c\xc8\xa7\xd3\x11\x43\x87\xc9\xfe\x89\x17\x84\x65\x9f\x4d\x9c\x38\xb1\x6e\x3a\xee\x75\x37\xb4\x6b\x02\xbf\xe4\x3d\xe8\xe7\x6b\x78\x83\xef\x83\x37\x03\xe1\x4d\x68\x1a\x1d\xfc\xfa\x67\xb8\xeb\x3f\x85\x13\x3f\xe3\x3e\x2e\xf6\xb7\x0c\xb5\x2d\x2a\x2a\x79\xa0\xb0\xb0\x8c\x4b\x8d\xb4\x0e\x85\x4b\x4a\x8a\x2e\x43\x43\xf2\x7e\x69\x61\x59\x2e\xfc\x37\xf4\x59\x37\x7d\xe2\x44\xdc\xf5\x33\x45\x76\x98\x2c\x8c\x47\x1b\x24\x19\xce\x8e\x66\x5f\xe4\x5a\x06\x48\x82\xc8\x6e\x53\x36\x28\x97\x29\x62\x62\xf4\x3a\x86\xea\xe7\xc2\x6c\x34\x8d\xf9\xf7\xa9\xf6\x32\x77\x96\x7f\xd1\xcf\xe3\x9c\xf9\x18\x3d\x7a\x55\xf8\x08\xb7\x03\x7a\x44\x6d\x4e\xa0\x41\xab\x8c\x46\xac\x15\x5e\x8e\x0a\x05\xe6\x7a\xb3\x13\x15\xcb\x15\x05\x11\x44\xa1\x35\x38\x61\xfd\xfa\xc7\x55\xf7\x0c\xed\xde\x6d\xd8\xdd\xdc\x53\xc2\x47\xa7\x4f\x73\xf2\xe6\x55\x9d\x2a\xab\x2a\x96\x3e\xa8\xc8\x3e\xa4\x1a\xbd\x1f\xfe\x03\x64\x1f\x90\xaf\x54\x2a\x59\x0b\xba\x3c\x56\x2b\xaa\x12\xf3\x17\xfa\x2f\xd2\x10\x79\x3a\x5e\x1a\x82\xb5\x00\x3a\xb2\x81\xdd\x35\xc5\xad\x85\xac\xdc\x4c\xdd\xd5\xe8\x66\x0a\x35\x6a\x1f\xb9\x92\x02\x8e\xdb\x60\xed\xfe\xaa\x6f\xcf\x91\x2f\x80\xbb\x6d\x66\xed\x29\xb7\xd7\xe8\xf5\xa2\x4e\x4d\x1f\x3b\x7f\xa2\xc0\xc2\x16\xc0\xae\x3c\x5b\xa2\x5c\xa7\x29\x3d\x7c\xbf\xf7\xb6\xca\x5e\x8b\xf7\x46\x3a\x9a\x15\xbb\x5a\x83\xf1\xd7\xc1\x5e\x4c\x8f\xee\x85\xee\x46\xb9\x77\xda\x8d\x0e\x9a\xcc\x56\x70\x5d\xd8\x84\x9f\x16\x7b\xc0\x9a\xe9\xf7\x4b\x88\xf9\xee\x28\x36\xee\x38\x25\x1d\x3f\x5d\x98\x99\x59\x48\x7f\x85\x5f\x95\xbf\x85\x6c\xcc\x0e\x30\xe7\x23\xe1\xd7\x90\x01\x79\x03\x66\x41\xe4\x0d\x7a\xb5\xac\x52\x69\x38\x8d\x91\x33\x89\x06\xe0\x70\x91\x82\x88\xd4\x35\x37\xea\xc4\xc0\xd6\x3e\xcb\xdf\x64\xaa\x77\x4e\x70\x40\xa7\x2e\xc1\x41\x73\xbc\xd3\x54\xa3\x8f\x16\xd4\x24\x8d\x6a\x39\x77\x6e\xab\x91\x49\x35\x05\xcb\x29\xff\x7c\x12\xd6\xa7\x2a\x7c\x06\x59\x51\x0a\xca\x43\x05\x01\x87\x51\x14\xdd\xa9\xa9\x28\x53\x63\x43\x4e\x9f\x4f\x9f\x94\x93\x23\xf3\x66\x3d\xdb\xdb\x88\xd9\x25\x62\x4a\x8e\x46\x7e\x29\xb5\xad\x62\x19\xb9\x1a\x5b\x1b\xe2\xaa\xfa\x17\xe3\xaa\x89\xd5\xb7\x96\x94\xdc\x4a\xcd\x0f\x83\x8b\x8b\x07\xc7\x99\x20\xc8\xb9\x38\x63\x44\xfb\xf6\xd4\x1c\xd1\xbe\x7d\xcc\x20\x91\x17\x7f\xe7\x17\x6e\x01\xd2\xcf\x69\x69\x54\xc4\xb7\x0a\xa4\x3f\x09\x74\x34\x41\x96\x25\x4e\xb9\xff\xc0\x34\xf5\x75\xbe\x62\x37\xe1\x7d\x25\x5e\xab\x5f\x3e\x5d\x33\xb5\x35\xf9\x03\x5e\xc4\xc7\xc8\xc7\x2f\xe1\x9c\x97\x68\x3f\x7d\x48\x7f\xf1\x76\xd0\x45\x80\x1f\x3d\x27\x4b\x7a\xa4\x89\x5e\xd8\xb1\x19\xc2\xd4\x24\xc1\x9b\x9a\x0e\xfa\xae\xe0\x2f\x48\x2f\x11\x6f\x1f\x46\x26\x92\xcf\xc8\x39\x32\xb1\xf6\xb9\x11\x58\x73\xed\x07\x9c\xdb\xb3\xc9\xd1\x23\x2f\xbf\x74\xdb\x84\x99\x33\x59\x7f\xc2\x71\xf1\x76\xa9\x1d\x93\x07\x01\x3f\x63\xba\xcd\xff\xee\x46\x6a\xd7\xb0\x9f\x83\x82\x47\x1c\x10\x7f\x5f\xc1\x83\xce\xb9\x47\x78\xe3\x7a\xa9\x38\x80\xe5\x02\x02\xd8\x0f\x0b\x9e\xf0\x90\x98\x9d\x1b\xda\xc8\xd1\x36\x3b\x77\x2a\xeb\x44\xe1\x59\x21\x89\x34\x7b\x6a\x40\x8b\x8c\x82\xd6\x08\x3f\x56\x50\xa2\xf3\xdd\xa7\x22\x5e\xb4\x4c\x73\xce\x48\x8f\x69\x41\xa2\x10\x31\x3e\x0b\xf6\x79\xe4\x13\xf2\xf1\xbc\x81\xb7\x9a\x9e\x33\xbf\xbd\x71\x1e\xce\xc1\xd9\xf3\x82\x83\xe9\x07\xe1\x9d\x8e\x1d\x3b\x77\x5f\xf5\xb4\xf2\xda\x60\xde\x86\x03\xbc\x26\x4e\xdf\xc7\x99\xd0\xb3\x00\xf2\x78\xba\x37\x55\x70\x0a\xa7\x2b\xc9\xc7\xdf\xff\x4a\x7e\x1f\xf9\x5c\x2d\xbe\x07\x67\xe0\x74\x7c\xf7\x30\xe1\xf8\xec\xe9\xe3\x17\xbd\xf4\xf2\xd1\x23\x11\x98\xc9\x30\xfe\xbd\x88\x5c\x01\xbb\x41\x6f\xcd\xdf\x2e\x53\x66\x57\xe4\x94\x8b\xbc\x7b\xf8\xab\xeb\xd6\xd5\x99\x9e\x59\x70\xf0\xc0\x02\x6a\x23\x59\x87\x3f\xc5\x33\x68\x3c\x83\x38\x2c\xb4\x52\xf1\x0f\x21\x7b\xe1\xbb\x6a\xf6\xdd\x98\xd0\x66\x45\x1f\x0f\x3f\x88\xbf\x47\x43\x59\x8c\x85\x8c\x1c\x47\x90\x88\x9b\xb3\x70\x86\x58\x58\x45\xb9\x22\x18\xf2\xb0\x26\x35\x47\x8f\x1e\xa5\xa1\x13\x75\x0b\xb9\x7f\x42\x12\xf4\xb7\x3e\x36\xc6\x54\xa5\x3f\x36\xc6\x67\x30\xc6\x25\xf8\x6e\x76\xec\xbb\xa7\xa0\xdd\x2d\xac\xdd\x8b\xb1\xef\x76\x42\xbb\xa1\x34\x1e\x45\x1c\x1d\x81\x05\x93\xfd\xf8\x7b\xdc\x0b\x26\x67\x43\xde\xe7\x91\x19\x17\x3c\x4b\x73\x4a\xde\x34\xfc\x84\x19\x6f\x1b\xc5\x9b\xf8\xcd\xf2\x5d\xf5\x31\x26\x47\x45\xa1\xc7\x80\xf8\xd8\x12\xc1\x41\x2e\xfe\x87\x8d\x1d\xfa\x19\x7f\xcf\xd9\x18\x3c\x93\xa3\x63\x87\x73\x61\x1d\x3e\x16\x7e\x83\xf3\x9e\xb8\xd7\xa8\x39\x84\x5b\xec\x97\x25\x89\x7f\x01\x96\x43\xf1\x1b\x62\x41\x2f\x30\x2c\xcd\xf3\xed\x50\xf2\x7c\x47\x43\x39\xdf\x13\x0f\xaa\x69\x2c\x47\x86\x83\xc6\x72\x40\xdf\x9d\x57\x36\xed\x32\x28\x12\xca\x41\xd6\x28\xf7\x7c\xb9\xf8\x73\xf4\x89\xf8\x1f\x18\x73\x56\x6c\x0d\x96\xc3\x7c\x6f\x63\x6b\x35\x2f\xb6\x06\x2b\xe1\xbb\xb9\xc2\x25\xca\x43\x0e\x60\x99\x57\x89\x34\xcc\x81\xfa\xa5\x46\xa3\x2a\x80\x96\x59\xb5\xd8\xa7\xc6\xd4\x4d\x42\x8d\x1f\x7f\x62\xcf\x49\xac\x0f\xa3\x77\xb6\x6e\x39\x1d\x46\xd8\x08\x8f\xdb\xc8\x0f\xc0\xac\xa6\xfc\xfd\x37\xd9\x48\x66\x50\x1a\x7b\x56\xd8\xc7\x55\x2b\x77\x34\xfb\xc5\xc5\x1c\xa8\x84\xcc\xb8\x4f\xd5\x39\xf9\xec\x6c\xcc\x5d\xaa\xf7\x03\x46\x03\xc9\x04\xfc\x41\xc4\xb6\x1f\x51\xff\xe0\xc0\xdb\x01\xcb\x4a\xf0\x07\xb3\x09\xb9\x34\xcf\x13\xbd\xbb\x44\xa7\x81\x46\xbe\x1d\x5e\x62\x92\x79\x49\x71\x75\x85\xef\x22\xf5\x0c\x2d\x12\x47\x93\x1f\x72\x68\x12\xad\xdb\x2c\xf4\xa2\xb6\x23\x34\x28\x50\x6c\x05\xfd\x58\xd6\x27\xc8\x09\x49\xc9\x18\x6d\x1b\x64\xc4\x8b\x30\x67\xc4\x29\x38\x1f\xde\x84\xb1\xa8\xe3\x5d\xd8\x60\xc0\x2e\x5e\xd0\x68\xcc\x2c\x12\xdb\xde\xb0\x38\x9f\x52\x13\xaa\x66\xc8\xe0\xa9\x79\xe6\x06\x15\x20\xe8\xc5\x3b\x9f\xd6\xb0\xe6\x8d\x29\x92\x16\x87\xe3\x30\x77\xcf\x1f\xe4\x5a\x7c\x69\xc1\xcf\xa3\x79\x71\xf0\x36\x6c\x22\x57\x49\x2f\x96\x8f\xa4\xbe\xae\x20\x59\xa3\xe4\xc6\xa1\x73\x88\xd6\x68\x8c\xcc\xc1\xc0\x53\xe7\x30\x95\x5b\x95\x9c\x74\xf3\x39\xa8\xb1\xd5\x0a\x1a\x83\xe0\x74\x9a\x2a\x83\x4e\x93\xa0\xfb\x3f\xcd\xe1\x5f\xca\x39\xe2\x0f\x30\x37\xe7\xdf\x2a\x3a\x46\x27\xf1\x2f\x85\x1d\xc3\x61\xdc\x89\xdc\xcb\xe7\x0a\x6d\x4c\x12\x4a\x66\x87\xfb\x53\x61\x2f\x6f\x91\x6c\xf4\x8e\xff\x59\x38\xfb\x92\xc8\xbd\x88\x8d\x68\x10\x10\x00\x53\x9c\x9f\x39\xd3\xf8\xf1\xa7\xc5\x18\xbf\x23\xec\xf5\xe2\xf6\x19\x84\xde\xd0\xfe\x0d\xcf\x7e\x24\x0d\x8d\xe8\x2c\x25\x01\x97\x1a\x34\x68\xa4\x91\x34\x7a\x49\x6f\x30\xea\x64\x49\xbe\x73\x90\x5e\x92\x38\xf1\x10\xed\xec\xed\xb2\xfc\xf8\xba\xdb\x91\x08\x3d\xd6\xb9\xbf\xde\x9c\xc0\x09\xad\x7e\x7c\x96\x2c\x7d\x03\xf7\x78\x83\x8e\xb4\x2e\x83\xcc\x4a\x3e\x0f\xff\x28\x4e\x21\x56\xd3\xb7\x93\x25\x13\xa5\x23\x64\x96\xf9\x52\x92\x1d\x2e\x40\x39\x01\x2b\x67\xe6\xb9\x1d\x16\xbc\xd8\x82\xa7\x58\xb0\xc9\x82\x91\x05\x1f\x0a\x2f\x3a\x60\xb1\x48\x52\x06\xce\x8b\xa4\x28\x2a\x2f\xa2\xf3\x3d\x83\x1f\xe4\xfe\xe0\xa8\x2d\x30\x27\xe0\xe6\xa8\x83\x3a\xc2\x9b\x07\xe5\xa3\x72\x34\x59\xc9\xcf\x81\x02\x56\x27\x33\x9f\x0e\xae\x77\xb6\xa5\x0e\x1d\x67\x70\x2a\x7e\x10\xb7\x20\xca\x1d\x74\xf8\x4d\x80\x65\x93\x58\x01\xe7\xd3\x8c\xa6\x04\x12\x0c\x46\x23\x32\xeb\x74\x48\xe6\xd5\x1a\x0d\xb2\x8a\x6a\x35\x42\x5a\x8b\xd5\x60\x3e\x84\x8d\x81\x94\x41\x80\xcb\xa2\xaa\x26\x68\x14\x6b\x44\xce\xc5\x8b\xa2\x1a\x63\xa1\x26\x88\x79\xa4\xae\x09\xd2\xea\xf2\x8d\x33\x1f\x21\xbf\x92\xfc\x2a\x12\x41\x66\x89\x45\x8f\x5a\x22\xf9\xeb\x22\x75\x4e\x68\x24\xab\xb2\x37\x9d\xf9\xec\x50\x18\x1f\x27\xad\xb9\xdc\xeb\x2d\xe8\x3e\x89\x15\xd1\xd2\xf1\x5f\x45\x36\x2c\x06\xf7\xc6\x08\xdc\xe3\x02\x34\xf7\x35\x80\xad\x02\x60\xb5\x82\x55\xe6\x79\x41\x88\x02\x9d\x06\x40\x8b\x32\x37\x34\xf8\x99\x8c\x4f\xca\x78\x93\x8c\x6f\x95\x71\x77\x19\xe7\xca\x58\x96\xd5\x22\x2f\x50\xb8\x0b\xca\xfd\x65\xf9\x6c\x7d\xe3\x81\x8e\xc2\xec\x67\x0e\x16\x51\x88\xeb\x53\xf1\x30\x88\xf9\x79\xe4\x6b\xf2\x2d\x76\x61\x0f\x76\x5d\x2f\xa1\x10\x73\x6d\x43\xc7\xc4\x0a\x5a\xfa\xff\x9f\x17\xeb\x81\x06\x9a\xf9\x16\xc0\xfc\x94\xd8\xc9\x94\x89\x9a\x2c\x64\xfb\x1e\xfa\x19\xf6\xdd\x1b\xd0\x63\x03\x8f\xb7\x1b\xf1\x64\x23\xae\x31\xc2\x8e\x7f\x73\xc0\x68\xd4\xe9\x94\x1d\x57\xf6\x9b\x0f\xbf\x09\x67\x76\xaf\x38\x10\xe6\xeb\x80\x53\xdb\x31\x60\xd6\xa1\x04\xb7\xdb\x9c\xe8\x74\x9a\x25\x24\x25\x27\x25\x24\xd2\xc9\x1a\x07\x25\xf0\x6a\x43\x4d\x50\x2d\xf0\xb6\x9a\x20\x6f\x6d\x50\x30\x36\x1a\x4c\x18\x43\xd8\x58\x7a\xfd\x02\x84\x4d\xf5\xc2\x1b\x9b\x96\xb0\x97\x84\x7e\xbb\x46\x42\x98\xbf\xf6\x2b\x16\xc8\x47\x27\x87\x8d\x1b\x37\x6c\xd8\xd8\xba\x0e\x6c\x86\xbb\x40\x9e\xbc\x1f\x8f\xc6\x7d\xe1\xa7\x86\xec\x24\x4f\xe0\x93\x5f\x5f\xbe\xfc\xe3\x8f\x9c\xb7\xf1\x1e\xd1\xda\xd5\x2a\x90\x68\x7b\x06\x4c\x3a\xb5\x5a\x10\x24\x4e\x45\x13\x3c\x9b\x8c\x5a\x03\x05\xd8\x3e\x08\x36\x4c\xe2\x03\xa8\x92\xde\x41\x60\x95\x2c\x0a\x3c\x66\x45\xab\xfd\x2c\x15\x12\x85\xb7\x7e\x33\x2c\x65\x05\x91\xe8\x02\x96\xf5\xc7\x83\xbd\x91\x3d\x58\x4c\xbe\x02\x6e\x9b\xf2\xe2\x51\x9c\xf2\x4f\x1d\x85\x10\x1f\x21\xed\xf1\x11\x7e\x65\xe8\x51\x6e\x20\xd9\x1a\x03\x4a\x81\xe9\x14\xac\x63\x06\x48\xc1\x63\x03\x1e\x59\xe7\x4e\xd1\xa5\xa8\x93\x92\x9c\x20\x04\x1b\x9b\xe6\x64\xf2\x99\x6a\xde\x68\x6c\x92\x9c\x9d\x47\xc1\x73\x0e\xca\xe6\x53\x25\xc9\xaa\xb6\xa2\x9a\xa0\x55\x48\x52\xab\x00\xd1\x53\x54\x16\x54\xee\x6f\x98\xd4\xaf\x9c\x96\x93\x8c\x96\x05\x89\x45\xed\x5a\xea\x7d\xb0\x59\x26\x65\x33\x50\x86\x02\x27\x4b\x46\x4f\xc5\x67\x0b\x4d\x7d\x53\xdc\x0a\x03\xfe\x53\x33\x70\xa6\xc8\x26\xc3\xbd\x3c\x61\x49\xf5\x50\x92\x3f\xae\x7c\xf4\x82\x95\xcb\xae\xdc\xb5\xfe\x87\xe5\xb7\x2f\x1c\x17\x18\x45\xf2\x87\x56\x2f\xae\xdb\xc2\x68\xd7\xec\xb7\x0f\xdd\xf5\xf1\x08\x72\xee\x92\x76\x12\xf6\x1c\x7e\x1c\x0b\xeb\xee\x24\x75\x4f\x1c\x26\x5f\x4f\xd2\x5e\xc2\x99\x23\xce\x6c\x3c\x78\xfa\xde\xc8\xa4\x81\xde\xcc\x06\xdc\x59\x26\x0d\xb5\x64\xf2\xe3\x80\xde\x48\x7c\xd9\x6f\x08\x65\x05\x5c\x3c\x87\x8d\xe6\x4c\x78\xdd\x60\xc7\x26\x3b\x46\x76\xdc\xca\xee\x11\xe4\x08\xde\x15\x15\xa1\x3c\xfa\x12\xa3\x57\x15\x16\x89\xd2\x2b\xf8\xbc\x1a\x3e\xef\x64\x9f\x33\x98\xce\xb3\x17\x61\x61\x0e\xec\x33\x8d\xb5\x31\xf0\x02\x16\x28\xf9\xad\x09\x8a\x3c\x6f\x41\xf5\xa5\x67\xe9\x25\x15\x3d\x36\xc2\x9c\xd0\x50\x72\x16\x8e\xf5\xf5\x1d\x62\x47\xc6\x53\x2d\xd0\xdf\x61\xf6\xbc\x01\x15\x1d\x44\xbc\x86\x37\x81\xc8\x12\x7e\x37\x60\x55\x1b\xbb\x68\x04\x38\x1d\x48\x12\xa4\xa1\x41\xc1\xc2\x01\xa9\x61\x39\xc0\x91\xb2\xd0\x79\x91\x40\x45\x9a\x65\xdb\xee\xcd\xe0\x33\xf3\xb1\x01\xa4\x0c\x0b\x7e\x12\x07\xf1\x23\xd7\xfb\xf1\xcb\xbf\x68\xe2\x56\xe3\x12\xe7\x67\x5f\x09\xc3\xaf\x6f\xfd\xea\x1a\x37\x6e\xcd\x9c\x2c\xcd\x27\x5d\x43\x9b\x22\xf3\x98\xc7\xe6\x91\xcd\xe6\xd5\x1f\x3e\x4f\x63\x9f\xdb\xb0\xcf\x34\x37\x79\x07\xf6\x99\xfa\xab\xf3\x4a\xad\x05\xc0\x1d\x1e\x19\x91\x87\xd6\xb9\xe0\x91\xc3\xe4\x00\xa6\xae\x11\x12\x93\x78\xae\x36\xa8\xe3\x13\x79\xce\xc4\xf3\xbc\xac\xd7\x5b\x6b\x82\x7a\x41\x4e\xa8\x09\xca\xd6\xff\x52\xe7\x82\xc9\x3f\x00\x7a\x91\x68\x42\x5e\x96\x87\x0c\x5e\x71\x7c\x30\x82\x8b\x6c\xe5\xce\x01\x7a\xff\x41\x7e\x27\x5f\xe1\x64\xac\xc5\x1a\x9a\x57\x6d\xcd\xc2\x85\x77\xdc\xb1\x70\xfe\x5a\xde\x7a\xe6\xcc\x04\x76\x1a\xc7\xe2\x6a\x5c\x85\x87\x91\x07\xc9\x93\xe7\x7f\xbc\xfa\xe9\xa7\x7f\xfd\x46\xe7\xc0\x6a\x51\xb1\x39\x34\x61\x73\x5a\x15\xdb\x4b\x26\x14\x83\x6c\x8a\x84\xe7\x61\xed\x35\x28\x3b\xe0\x40\xbc\xcc\xeb\xb4\x9c\x6c\x91\xd3\x64\x5e\x86\xc5\xd6\x08\x3c\x23\x8f\x05\x94\x40\x0e\x8e\x2c\xb6\x1f\x16\x9b\xa6\x38\x95\x64\xde\x86\x41\x9c\xc3\x2f\x90\x77\xff\xf2\xc9\x26\xf7\x5f\x62\x05\x50\xbc\xda\x85\xed\x6a\x07\xd7\x6d\x87\xb1\x86\x43\xdf\xe3\xd8\x58\xcd\xd9\xd8\x34\xf7\x41\x27\xf6\xb9\x05\x5b\xcf\xe9\xf0\x79\x20\x8c\x4d\x65\x75\x2d\xad\x74\xc7\xcb\x48\x10\x64\xb5\x46\xd0\xeb\xb4\x9a\x9a\x20\x90\x06\x2c\x88\x74\xdf\x31\x1a\x4a\xb9\x4c\xa3\x1c\x75\x31\x7f\x75\x6b\xe4\xae\x8d\x87\x85\x5c\xc9\x1f\xad\x6b\xca\x7f\x73\x57\xa8\x95\x50\x75\xed\xda\xf5\xa7\xaf\x5d\xe3\xb3\x2f\x5d\x42\x4a\x3e\xc0\x1f\x84\x15\xe2\x40\x18\x5f\xc9\x5b\x18\xd9\x5f\x18\xdd\x17\x30\x03\xcb\x13\x64\x41\xad\x12\x81\x55\xc4\xb8\x42\x7c\xe9\x80\x28\xd9\xe7\x13\x41\x9a\x3a\xcb\x3f\x2f\x54\x5d\x7f\x9a\x4e\x18\xc5\xd6\x75\x16\x9b\x9b\x9f\xf5\x3d\x02\x3e\xaf\x80\xbe\x75\xa8\x57\x20\x4b\xd6\x68\x30\xa7\xe2\xb1\xa4\xd5\xaa\x30\xaf\x37\x00\x82\x08\xf2\xd0\xa0\x5a\xc5\x71\xb0\xc2\x18\x6b\x90\x66\xa8\xc2\x3f\x19\xf3\x51\xea\xf4\x28\xef\x6f\x48\xb1\xe0\x2f\x52\xd3\xa9\x02\xbe\x63\xaf\x7d\x04\x7e\x8b\x74\xe6\x3f\x08\xdd\x86\xc7\x92\x59\xdc\x85\xef\xf1\xe7\xf8\xde\xef\xae\x91\xe7\x6f\x27\x53\x22\x32\x2d\x60\xb2\xb0\x81\xc1\x55\xc2\x3e\xd3\x30\x9c\x37\xd9\xe7\xd6\x6c\x0f\xd4\xe1\xdf\x85\xd7\xc4\xde\x40\xa3\x53\xe0\x14\xf4\x0b\xe4\xd9\xc5\x94\x94\x74\x9a\x43\x04\x84\xc2\x54\xa3\xdb\x98\x9b\x93\xac\x49\xd7\x0c\x0b\x8a\xe9\x0e\x6b\x86\x75\x58\x50\xc8\x48\x87\x1f\xb5\x4d\x00\x9a\x58\x5e\x1e\x4b\x95\x10\x57\x8a\xab\x9e\xd9\xc7\xea\xb6\xd1\x24\x4a\x66\xc6\x5b\x94\x7c\x81\x96\x56\x34\x9e\xdd\x5f\x40\x73\x50\xe6\xc1\x4c\x6c\x8e\x56\xd8\x4c\xd3\x85\x1e\x9f\x56\x6b\x75\x0f\x9a\x4a\x9a\xb8\x56\x7c\x34\x33\x74\x5e\xf7\x93\xee\x7c\x88\x84\x4e\xb9\x48\x93\xa9\x83\xdc\xd6\xa1\xd3\xb9\xc3\x2b\xb6\x87\xf6\x3c\x16\x3a\xfa\xde\x92\xef\x36\x7c\x85\xc5\xdd\xbb\xc9\xf5\xaf\xce\x93\x4b\xef\x71\xaf\xaf\xdc\xcd\xf5\xd9\x86\x1a\xd2\xab\x56\x6c\x2f\x9a\xb1\xfc\x40\x15\x70\x66\xdb\x06\x52\x34\xb2\x19\x63\x03\x67\x77\xb9\x38\x99\x4f\x4c\x42\xbc\x81\xaf\x0d\x9a\x41\xb0\x71\x18\x55\x51\xd6\x63\x29\x6b\x94\xe4\x3b\x16\xfb\xea\x03\x28\x39\xa5\x9c\x53\x2b\xcc\x04\x03\x25\x1c\x9f\xf3\x71\xe7\x7f\xd6\x7c\x7e\xee\xe7\x5b\x27\xaa\x7f\x56\x4f\xbc\xf5\xe7\x73\x9f\xe3\x3b\xc9\x74\x7c\x27\xd6\x84\xf0\x5e\xd2\x7d\xcb\x1a\xee\xd3\x50\xc6\x9a\x2d\xf8\x59\xd2\x3b\x44\xfe\x50\x6c\x45\x80\x85\xc2\x03\x40\x4f\x7c\x2c\xa7\x89\xc1\xeb\xf0\x38\x5c\x49\xb2\xce\xa0\x52\xa5\x67\x24\x23\xc9\x24\x01\x2d\x91\x24\xb5\xc5\x02\xcc\xc7\x22\x78\x18\xf3\x49\xba\x91\xf9\x00\x45\x69\x10\x26\x1b\xcf\x6b\xd2\xcd\x51\x56\x63\x12\xe3\x38\x0d\x37\x6a\xce\xba\xfe\xe3\x88\x79\x46\x60\x12\xb9\xba\xee\xfa\xfd\x9b\xea\xd6\x91\xab\xd3\x02\x53\x88\x79\x5c\xff\x75\xc2\xec\x77\x9e\xbb\xfd\x9d\x49\xe4\xdd\x4b\xda\xb3\x78\xc2\x63\x58\x5c\xb7\x8e\xfc\xb3\x9b\xdc\x73\x16\x78\x4b\xf3\x49\xa7\x56\x3d\xf7\x4e\x94\xae\x48\x8f\x81\x0c\xdb\x84\xca\xb0\x34\x8f\x1c\xa6\xfe\x3b\x7a\x0e\xeb\xc4\x4c\x0e\x23\x93\x01\x81\x0a\x92\xa7\xb0\x11\x54\x8f\x7b\xec\x99\xd6\x8d\x9f\x51\xb3\x67\xf4\x5a\x41\xd5\xe8\x99\x4e\xb4\x06\xaf\x64\x03\xde\x35\x8c\xf1\xae\x52\x78\xd4\x1a\xd0\x72\x19\xe6\x4c\x2e\x27\x23\x5b\x32\xd1\xf6\xd0\x9c\xb6\x65\xf5\x93\x59\xdb\x51\x4a\xdb\x4a\xd6\x16\x67\x9a\x33\x71\xaf\xcc\x1c\x50\x6a\xeb\xdb\x4e\x26\x03\x84\xbe\xac\xed\x98\x06\x6d\x13\xa0\xed\xc8\x84\x44\x9d\x33\xae\xad\xc2\x3f\x6d\x31\xfe\x59\x9a\xac\xb4\x05\xee\x89\x9d\x46\x8b\xa8\x8f\x6b\xbb\x8e\xe6\x64\x65\xbc\x76\x96\xc2\x6b\x7f\x41\x28\x39\xa0\x06\x2e\xeb\x60\xbc\xf6\x50\xf8\xc2\x81\xc4\x34\xe0\x9c\x38\x2f\xc6\x62\x29\x0f\xec\x14\xa9\x35\xec\x02\x1e\xdb\x31\x90\xe6\xb0\x5b\x75\x28\xc5\x68\x4a\x31\x25\x48\x76\x29\x33\xc3\x61\x37\x1a\xd5\x69\x95\x41\x9d\xda\xc4\x27\x56\x06\x11\x2d\x9e\xe4\x57\x72\x18\xa1\x58\xae\x10\x7f\x7c\xfd\xab\x8c\x06\x45\x61\x8b\x4b\xbc\x12\xd0\x75\x5a\xfb\x05\xc7\xa5\xd2\xe7\xab\xdb\x3e\xb9\xf0\xc3\xf7\x2e\x7e\xb6\xec\xa5\xe6\x7c\x42\x01\x56\x17\x8c\xd7\xa5\x8e\x21\xbf\xb6\x70\x10\xe7\x2d\x43\x83\x8b\x2d\x8e\x99\x03\x46\xf5\xff\x71\xe5\x3c\x6c\xc5\x09\x38\x11\xbb\x57\xcc\x5b\x30\x79\x10\x79\x79\x3a\x39\xf9\xe7\x9c\x99\xb8\xd9\xf1\xc7\xdf\xda\xb5\xef\xf0\x3e\x80\x7f\x1d\xe9\x2f\xdc\xcd\xea\xfb\xe5\x82\x4e\xd9\xcc\x89\xac\x1e\xb3\x39\xd9\x93\xac\xc9\x50\xab\x81\xbc\x35\xc9\xb3\x7a\xdc\x1e\x77\x65\xd0\xe3\x31\x64\x1b\xbc\x7d\x82\x06\xa4\xf6\x64\x64\xf3\xd9\x95\x40\x6c\x1d\x31\x8c\x6e\x9c\x80\x34\x42\x4a\x62\x7a\x56\xc4\x8e\x9a\xe5\x73\xc4\x4a\x59\xd2\xea\xc1\x9c\x48\xeb\x09\x33\xcc\x66\x16\x0c\xe6\x5a\x29\xdc\x7d\xf9\xa3\xc7\x57\xa8\x55\xe4\xf2\xdf\x7f\x7e\xf0\xc5\x47\xb7\xae\xeb\x45\x7e\xda\xf5\xc0\x9c\x49\xfd\xfa\x4c\x1d\x91\xbf\xaa\xdd\xe4\x69\xf8\xde\x93\xe7\x87\x0c\x9a\x4c\x3e\x16\x9f\xfc\xf1\xb3\xfd\x8f\xff\x3d\xc8\x3a\x76\xc7\xad\x0b\x97\x9f\x70\x4c\x1d\xd1\x27\xb8\x66\x53\x28\x35\x3d\x7f\x09\x3b\xa7\xe9\x80\x2b\x8f\x08\x2d\x91\x09\xb5\x0f\x64\x82\x42\xa4\x13\x45\x9d\xc5\x1c\xcd\x84\xb8\x1d\xfd\x8c\xa4\x0d\xd0\x4c\x00\xf2\x6e\x56\x79\xf4\x3a\x51\x30\xd2\x4b\x51\x7f\xb9\x22\xb3\x0e\x9e\x5a\xef\xa8\x0d\xfb\xd2\x16\x97\x58\xbd\x58\x92\xbd\xb4\x36\x88\x35\x19\x73\xa3\xa5\x2c\xcb\x27\x38\x8b\x8c\x1a\x94\x4a\xce\x7b\x3b\x92\x2a\x9c\x7b\xd1\x90\x79\xb8\xd9\xf6\x62\x6e\xfe\xf5\xba\x8b\xd7\x3f\x3f\x23\xe4\x87\x16\xe7\x3e\xc1\xf0\xa4\x07\xe0\xc9\x3c\x58\x67\x2d\xe8\xbd\xdd\x02\x4e\x37\x8f\xf4\x1e\x4f\xb2\x19\x50\xcd\xe5\x4a\x4d\xf1\x24\x27\x25\x57\x06\xdd\xfc\x21\xac\x0f\xe8\x82\xbc\x5b\x9d\x84\xec\x6a\x56\x0a\x3d\x9a\x9e\x31\xaf\x3e\x4a\xaf\xac\xcc\xa2\x28\xeb\x65\x8c\x42\x67\x45\x3c\xac\x8a\xf9\x2c\x1c\xab\xc7\x5c\x04\xe7\x8b\x32\xd6\x01\x83\x26\xdc\x79\xdf\x82\x29\x0b\x96\x2e\xbf\x1b\x77\x58\x36\x7d\xc9\x1f\x0f\xd7\x91\xef\xf0\x7b\xe4\x0d\xfe\x16\xfc\xcd\xa4\x13\x13\x0a\x3e\xde\x7a\xd7\x8e\x2d\xfc\x31\x99\x7c\x3a\x3b\x74\xff\x3d\x5f\xdf\x86\xd5\x3f\xe0\xdb\x76\xe0\x96\x77\x47\x6a\x1c\xd6\xd7\x36\x9f\x1c\x68\xe9\xb0\xdb\x39\x3e\xd1\x64\xd2\xa5\xf8\xd4\xbc\x3a\x2b\x53\x9f\x92\xca\xbc\x9a\xe0\x98\x70\x88\x55\x3a\x47\x0e\xac\xe5\x1d\x8e\x84\x94\x14\x2b\xfa\xd7\x32\xe7\xb1\xca\x2b\x11\x2a\xa8\x94\xd3\x56\x0e\x82\xbf\x3e\xa8\xfe\xff\xb9\xea\xf9\xf1\x0f\xff\x77\xd5\x73\x3a\xc7\xdd\x64\xb2\x30\x1e\xf6\x26\x0d\x64\x99\x24\x59\xef\x4e\x45\xf6\x54\x7d\x92\x5d\xf0\xa5\xa7\xb2\x04\x74\x66\xa1\x3a\x68\x36\x6b\x92\x91\xe6\x10\x56\x31\xe6\x99\xdf\x38\xbf\x36\x45\x70\x9a\x52\x8e\xf9\xb7\x66\xd5\xa7\xa5\x6a\xcb\x95\x14\xc9\x34\xc5\x36\x68\x4f\xef\xe6\x0d\x7f\xf0\xf5\x47\x5a\xf9\x9e\x2b\x69\x36\x7e\xcd\xf3\xcf\x04\xbb\xae\xff\xfa\xcc\x59\xb2\x8b\x2f\x27\xaf\x91\x57\xf1\xa3\x6d\xbb\xb4\xf0\xe5\xad\x9f\xd3\xe1\x99\xd2\x6e\xb7\x96\x67\x35\xcd\x4c\xc9\xad\xbd\x6b\xdc\xd0\xd7\xdf\xff\x65\xaf\x2c\x1f\x39\x42\xae\x91\x4e\x14\x56\x46\xff\x18\xbd\xc9\x0e\x58\x91\xcb\xa4\x52\xa9\x5d\xea\x04\xb7\xc9\x66\xd2\x19\xd5\xb4\x0c\x57\x79\x79\x79\x79\x7c\xf2\x17\xca\xfd\x6e\x52\xae\x8e\xda\x2c\xf9\x36\xdd\x6e\x9d\x3c\x9f\x5c\x4e\xc7\x7a\xb3\x9d\x0f\xec\x9e\xff\x04\xad\x64\x91\x74\xf7\x8c\x5d\x1b\x42\x2f\xf2\x7d\xe6\x4f\xc8\x1a\x9b\x33\x65\xf0\xb3\x6f\x5c\x67\x86\x5b\x9e\xe5\x27\xee\x2a\x9e\x04\x99\xd3\x82\x12\x50\x79\x20\xd5\x69\x30\x20\x87\xd1\x08\x8a\xac\xc7\xed\x30\x56\x06\x1d\x0e\xad\x5a\x6d\xad\x0a\xaa\x11\xaf\xad\x6a\x5c\x28\xee\xc6\x2a\x71\x5c\x84\xd0\xa5\xb2\xd2\x11\xc9\x9c\x55\x29\x16\x27\x74\xfd\xfb\xe7\x4b\xd7\xff\xfa\x11\x7f\x45\x12\x46\x4c\xe2\x49\x0d\x57\x1c\x6c\x3f\x7c\x12\x8f\x77\xf2\xe3\xb8\xcf\xc9\xdd\x64\x01\x5e\x86\x27\xe1\x89\x78\xc9\x3f\x1f\x5f\xff\x66\xf3\x27\x93\x85\x69\xbf\x7f\xfe\x59\x84\x37\x33\x9a\xcf\x72\x40\x37\x0f\xb8\x74\x7a\x95\xc4\xeb\x41\x2b\xa1\x79\xf3\x24\xd0\xcd\x11\xd2\xf4\x51\x32\xe7\x29\x02\x5b\x5e\x7c\xaa\x1e\x31\x52\xf5\x93\xe5\xaa\x71\x4a\x7c\xda\xf1\x93\xb4\x60\xec\xb2\x89\x5d\xb7\xcf\xb3\xbd\xf4\x06\xad\x16\xdb\xe4\x89\x09\x8b\x0e\x33\xfe\x46\x73\x54\xdd\x2d\xb4\x04\x59\xe5\x1f\x36\x6e\x07\xf8\x4c\xfd\xcf\x5d\xa0\x31\xe7\x5a\x44\x20\x9d\xa0\xe7\x6b\x5b\x89\xdd\x45\x2e\x5f\xc4\xbc\x51\x4c\x11\x39\xb5\x20\x22\x97\xcb\x86\x6c\x46\x9a\x6e\x56\xa3\xc6\x34\x51\x18\x95\xd1\x63\xe7\x02\x0e\x43\xcd\xe0\xc1\xb1\x00\x91\x32\x56\x86\x01\x50\x89\x2a\x47\x5e\xc0\x28\x1c\x89\x0d\x00\x54\x13\xd6\x91\x73\x6b\xdd\x39\xb2\xb1\xab\xeb\x20\xf9\x18\x9f\xd3\xb5\xed\x5a\xd6\xbc\x69\xf3\x5b\x46\x8d\x5a\x39\xa2\x10\xbf\xdd\xef\xb1\xbc\x96\x9f\x94\x92\x3e\xfc\x4f\xce\x6d\xb7\x5a\x8f\x25\x77\xda\x74\x1f\x83\xf3\x76\xa0\xf7\x7d\x60\x7d\x92\x68\x8d\x5b\x31\x21\xc1\x6d\xb4\x58\xcc\x6e\x73\x4a\x72\x82\xd9\x68\xf4\xa8\xec\xd5\x41\xad\xa8\x52\x32\x73\xfa\xfd\xb1\x72\x14\xf1\xfb\xe6\x6d\xc6\x17\xb1\xb2\x1f\x11\x6a\xee\x35\x9b\xa2\xa5\xc1\x9c\x7c\x67\x2c\x0a\x3c\xdf\x6b\x77\x61\x7f\xa7\x20\xd0\x24\xc2\x87\x6a\xe7\xe1\x04\x95\xae\x49\x51\xb1\xfd\x54\xf3\xdc\xbc\x2e\x64\xb9\x78\x31\xf4\x10\xb9\xb4\x6b\x03\xd7\xbe\xee\xd0\xd2\x29\x14\x26\xd0\xe2\x84\x1e\x6c\xcf\xd2\x03\x26\x8d\x2c\x22\x24\x9a\x8c\xb2\xa0\x93\x44\xa3\x60\x8f\x08\x76\xd1\x25\xf1\x2b\xb5\xe1\x40\x93\xc1\xc5\x96\x22\xc0\x67\x87\xd0\xe3\xcc\x33\xa0\x63\x4d\xc4\x39\xd8\x32\xb9\xb6\x05\x76\x15\xf0\xbd\xf6\x93\xd2\x0f\x84\x96\x75\xcf\x6e\xc3\xee\x6d\x2b\x27\x0d\x83\x31\xb6\x44\xce\x78\x3e\x0a\x06\x9a\x64\xa7\x25\x26\xe4\xe5\xa5\x64\x24\x66\xd8\xf5\xb4\x00\x99\x9d\xa6\x1d\xa0\x99\xf6\x5c\x79\x4d\xf2\x9a\x28\x07\x3e\xcf\x9c\x67\xd6\xf8\xea\x8f\x3c\xc8\xcb\x4a\xf1\xff\x38\x42\x6c\x56\xe2\x11\x81\xd1\x45\x4a\x38\xdf\x8c\x04\xa4\x2b\xc4\x0b\x68\x98\x48\x9d\x87\x94\xb2\xde\x76\x03\x87\x8f\x15\x4e\x5c\xf2\xd6\x4b\x8c\x1e\x8c\xde\xf7\xc4\xae\x01\x58\xf3\xd3\x9e\x0f\xf6\x6c\x21\x97\x86\xf2\x49\xbf\x7d\x7e\xf0\xe7\x73\xa7\xc7\xe0\x5d\x6d\x7b\x17\x38\x52\x37\x2d\x56\xa8\x42\x46\x41\x66\xba\x77\xe0\x9d\xe3\x9e\xb8\x92\x26\xeb\x56\x0e\xef\xb3\x38\x59\x25\x1f\x79\xde\x3c\xfa\xd6\xea\x5b\xf4\x47\x93\xbb\xd2\x3a\x02\xf5\x35\x1d\x1d\x34\x2b\x80\x59\xd2\x22\x09\x39\x5d\x6a\x03\x4b\xbb\x6a\x6b\x50\xbe\xb1\x3e\x0e\xaa\xbe\x60\x63\xbc\x0e\xdb\xa0\x5c\x23\x39\x37\x6a\xee\x82\x89\x93\x27\x2e\x98\xd2\xb0\x4e\x63\xe8\xdd\x97\x9f\x7e\xe6\xe8\x2b\x7b\x9f\x56\xce\x9f\x27\x52\x83\x26\x15\x55\x04\xd2\x90\x5e\x4e\xd1\xa7\x38\xd3\x40\x78\x70\x3a\xbd\x69\x16\xab\x01\x39\x93\x9d\x95\xc1\x64\xa3\xd5\xae\x16\x2a\x63\x09\x1d\x15\xc3\x00\x66\x45\x16\xe8\x52\xe6\xc7\x59\x60\x58\xaa\x46\x25\x92\xbc\xc8\xec\xa3\x96\x17\x6f\xb1\xa5\x0d\x56\x6a\xa0\xf8\x81\xc5\xfd\x99\xde\x3c\x35\x3d\xa9\x76\xec\x8a\x85\xbf\x65\xe4\x90\x2f\x9b\xe7\x95\x8d\x4b\x4a\x1a\x97\xcf\x7f\xc0\x2f\x08\xed\xef\x52\xa2\x7d\xca\xbb\xf6\x2e\x6e\xfa\x82\x3f\xc9\xbd\xdb\x5e\xc1\xb5\x67\x96\xdb\x4d\x27\x0c\xc6\x23\x94\x27\x2f\x86\xb3\x30\x56\xe8\x0d\xf2\x81\x07\x15\x05\x3c\x66\xe4\x00\x6a\xca\xea\x16\x5a\x69\x0e\x68\xb5\xc7\x91\xc0\x27\xdc\x28\xe8\xc4\x93\x56\x9a\x72\x36\xcb\xe7\xa4\xa4\x95\x1a\xfc\x2d\xa2\xc9\x97\x96\xa0\x54\xe5\x12\xc6\xfe\xf4\xe2\xee\xa9\x5a\x2d\x39\x8b\x0d\xdf\x6d\xbc\xb8\x90\x9c\x7b\xeb\xfd\x16\xf3\x5a\x57\x8d\xe0\x84\x9f\xc8\x99\xd5\xcf\x90\x8d\xfc\x4f\xbf\x61\xe7\x3a\x72\x6d\x17\x5e\x44\x9e\x26\x57\x5b\x75\x38\xaa\xac\xe1\x76\xc0\xd5\xfe\xb0\x87\x5e\x54\x1a\x70\x7b\x14\x0c\xf5\xa5\x99\x79\xca\x85\x12\x34\x09\x20\x29\x24\x26\x26\x98\x22\x98\xe9\xcf\x8f\xa7\xaf\x0c\x29\x19\x60\x0e\xa7\xe2\xa9\x18\x87\x89\x54\xa3\x60\xa5\xe3\x0d\x18\x3f\x3c\xef\xd1\x17\xd7\x77\x0d\xb4\xd8\xd7\xba\x68\xc2\xae\x8d\xbb\x2a\x37\xfc\xb2\xf5\xfb\xad\x1b\x17\xac\xe8\x31\xb7\x0b\xfe\x74\xf4\x8c\xac\x26\x3d\x66\x0c\x6a\xf9\x50\xa7\x6e\x43\x5b\x66\x15\x67\xa7\x7a\xa6\xef\xbb\x6d\x1f\xee\xb8\xf3\x89\x2d\x4b\xc7\xbd\xc3\xe4\x99\x4a\xd8\xe7\xd7\x98\x6c\x45\x29\x49\x92\xd5\x6c\x4e\x71\x49\x7a\x0d\x20\x5b\x72\x8a\x1a\xd0\x8c\xd5\x0b\x35\xb2\x6c\xc6\x51\x84\x6b\x64\xca\xa4\x40\x0a\x0a\xda\xe5\x50\x37\x68\x7b\x32\x16\x0b\xb3\x28\x70\x11\xec\x1b\x47\xbe\xfd\xb5\x8e\xfc\x80\xdb\xe0\x66\x9c\x66\xe5\x82\x01\x95\x80\x82\xc5\x03\xd6\xf6\x9c\x33\x6e\xda\x5c\xfc\xd6\x17\x61\xec\xc1\x22\x60\x60\xda\x11\x49\x98\x7a\xa6\xfb\x27\x87\x82\xbb\xa6\x3c\xbd\xf7\x09\x58\xbf\xc5\xe1\x2b\x42\x33\x80\x8d\xd6\x57\x70\x99\xd5\x6a\xad\x96\x77\x3a\x23\xd5\x98\x1c\x34\xe5\x07\xab\x1c\x5e\x1e\x57\xae\x3c\x02\x14\x53\xc2\x22\x78\xa5\x94\xdb\x89\x95\xfb\xc3\x0b\xaa\xef\x71\xb8\xc6\x17\x72\x7f\x92\x5d\xa5\x15\x59\x81\xd4\x45\x99\x0f\x6d\xe4\x17\xb8\xf4\x27\x74\xe6\x23\xa1\xc3\x5d\xca\x55\xcf\xa9\x0d\x2b\xee\xe0\x96\xc0\xf8\x4c\x97\x80\xf1\xed\xa8\x69\xc0\x6e\xb5\x58\x8c\x46\xa4\x92\x91\xec\x74\x58\x68\xf9\xfc\x3e\xf5\xe5\xf3\x6f\xe0\x88\xa8\x41\xe9\xfc\x42\x0e\xc8\x9b\x45\x18\x4e\x42\xe1\xab\x17\x71\x42\xcd\x84\x19\x23\xba\xb7\xc0\xc9\x85\x1d\xb8\x56\xe4\x33\xf2\xd1\xe7\xdf\xd2\x1a\x3f\xab\x56\x1f\xf9\x6a\x0a\x76\xf5\x1f\x43\xbe\xa5\xfb\x92\x03\x38\xfd\x90\x50\x0d\xfc\xd9\x07\x72\x66\x86\xc9\x2b\x08\x56\xbd\x28\xaa\xdd\x6e\xea\x92\x9e\xa1\x4f\x72\x26\x55\x05\x75\x3a\xa7\xc9\x6b\x95\xac\xac\x20\xa7\x10\x5f\x90\x33\xbf\xf1\x0d\x09\x5d\x98\x02\xc6\xac\x95\x7a\x9c\xa0\x97\x96\x38\x15\x1a\xc6\xe4\x78\x4b\xc4\x97\x00\xf4\x53\xe1\xa1\xdf\xbf\x3a\xf7\xf9\x0f\x27\x3e\xb0\x0f\x1e\x35\x65\xd2\x13\x0f\xef\x38\x76\x25\xd0\xaa\xac\x74\xee\x74\xae\x88\xfc\x4a\x3e\x32\x90\xb1\xf8\x5e\x2d\x4e\xc3\xf2\xb7\xd8\x51\xb8\xdf\xf5\xe6\xb6\x17\x9e\x53\x71\xce\x13\xa7\xc8\xe7\x7f\xec\x39\x32\x61\x7e\xe8\x8a\xf4\x86\x82\xff\x39\x20\x85\xec\x11\x2a\x41\x52\x1e\x10\x30\xa8\xd4\x82\xd1\x2e\x68\x92\x6c\x1a\x5b\x6a\x8a\x70\x28\xfc\x72\xc0\xa7\x33\x76\x41\x02\x36\x06\xe0\x2f\x73\x99\x01\xc1\x47\x10\x64\x9b\x55\xab\xf1\xc0\xbe\xba\xfb\x28\x05\x95\x18\xef\x62\xce\x59\x54\xd8\x8c\x19\xef\x22\xb9\x1e\xe0\xac\x3a\x8b\x41\xa0\x57\x63\x6f\x3c\x83\xe5\x18\x83\xc5\xe2\xe8\x59\x0f\xe8\xdc\xde\xcd\x38\x87\xac\xc6\x5b\xc9\x87\xaf\xea\x8b\x45\x75\xa1\xe1\x0c\xf9\x10\x1f\x9f\x5d\x14\x28\xce\xc8\xc9\xce\xbe\x45\xa8\x9c\x48\xf6\x37\xe9\xd6\x0e\x57\x84\x7a\xd5\xbd\x8b\x9f\xf1\xac\xb3\x27\x2d\x4a\x22\xdd\xf9\x36\xbf\x4d\x18\x95\x63\x3a\x9a\x4c\xe7\xd2\x15\xf6\x63\xb9\xd8\x1a\x70\xb1\x5d\x20\x15\x69\xb5\x0e\x9d\xce\x04\xc0\x5a\x4d\xb2\xc9\x9d\xe0\xe4\x45\xb3\x11\x39\xf4\x8e\xca\xa0\x46\xdf\xb0\x56\x75\x79\x23\x83\x8c\xa2\x82\x28\x26\x0c\x89\x6e\x05\xad\x70\x4f\xcd\x19\x4e\xb3\x9f\x3b\xd3\xbd\xb7\xef\x97\x77\x3f\xbb\xf0\xe9\x87\xbf\xf4\x1d\x77\xfe\x19\xdc\x66\xc9\x78\x6e\x68\x68\xc3\xdf\x17\x39\x32\x1e\xdf\xcb\x7f\x73\x8d\x9b\x12\x7a\xf0\x3f\xeb\x44\xe1\x0e\xb6\xbe\xf9\x34\x37\x39\xd0\xbd\x2c\xd4\x37\x90\x63\xd2\xf0\x0e\x6f\x42\x82\xc1\xe1\xd0\xa4\xa4\x64\x68\x32\xb2\x73\x9c\x4e\xab\xde\x6b\xd0\x1b\xaa\x82\x69\x7a\x53\xa2\x55\xa6\x68\x82\x68\x3d\x12\xbf\xbf\x41\xa9\xbc\xfa\xc2\x94\x51\x10\x95\x63\x2d\x46\xab\xcd\xb2\xe2\xad\x4e\xc9\xdc\xa8\x2c\xad\x29\xab\x84\x99\xd0\xf9\x71\x23\x97\x26\x88\x09\x4b\x47\xae\xdb\x7d\xf4\x91\x94\x7b\xda\x14\xe5\x97\x7d\x51\x96\x5f\xd4\xe6\x9e\x94\x47\x8e\xee\xb6\xad\x9a\x3b\x77\x15\x4e\xf9\xe7\x17\x5c\x96\xfa\x54\x1e\x59\xb3\xeb\xc9\x83\x0f\x9c\x3f\x7f\xff\x73\x4f\xee\xc2\xb3\xf2\x9e\xf2\x92\x37\x7f\xfd\x87\x7c\x19\xd5\xf1\xc5\x6d\x51\x1d\x1f\x8d\xbb\x84\x90\x2f\xe0\x60\x26\x72\x0e\x6f\xb0\xe2\xc5\x56\x1c\xb0\xe2\x7c\xab\xb9\xde\x42\xce\xac\x14\x51\x9d\x9f\x3d\x3b\x2b\xf6\x6c\xc2\x41\xa6\xf1\x53\x85\xff\xfd\x03\x6e\x57\x44\xe1\xaf\xb7\x6b\x30\xfe\xca\x6c\x0a\x53\x1a\xd8\x35\x9c\xf0\x4c\x0f\xa7\x5b\x69\xdf\xc0\xa6\x60\x8b\xd9\x14\xa2\xf6\x07\xe8\x1f\x27\x3a\x12\x1a\xb4\x65\x7b\xc2\xda\xce\x53\xda\x96\x28\x6d\xb3\xa1\x6d\xa7\xec\x3c\x4d\x46\xb4\x2d\xad\x15\x01\x6d\x6f\x13\x3f\x02\xca\x9b\x8d\x0a\x61\x0f\x9b\x5a\xf3\xf3\x7d\x0e\x87\x4b\x4a\xd6\xe7\x20\xa4\x97\xf8\xa2\x62\x4f\x93\xea\xa0\x29\xb3\x2a\xe8\xf2\x98\x3c\x26\x5e\xa3\x01\xd5\x4c\x83\xf8\x82\x3e\x0d\x85\x72\x7a\x01\x5c\x96\x97\xd7\x30\x55\xb6\x3f\x4a\x9a\x53\x11\x1c\xf6\xf4\x68\x4a\x64\x45\xcf\x54\x72\x09\x2b\x39\xc2\x19\x97\xb3\xc6\xcb\x0b\xb7\x91\x5f\x2f\x93\x7f\xc8\xc5\x7b\x70\xf6\x0b\x9b\x9e\x39\xf2\x50\xd5\xd6\x7c\x97\x4f\x28\xd9\x33\xf8\xf3\xab\xe4\xb3\x05\x81\x69\x29\xf6\xe1\x5d\xca\x7b\x25\xcc\x9e\x38\x72\xe1\xfc\xd1\x93\x67\xe2\xcd\x27\x2f\xe1\xdb\xf1\xf8\xcb\xb8\xea\x95\xd9\x13\xe6\xae\xce\x4c\x6e\xbe\xa3\x65\x45\x5a\x69\xd7\x2f\xb9\x25\x6d\x9a\xa5\x5b\xdc\xbe\xba\xd3\x63\x66\xcc\x1c\x3d\x72\xf6\x54\xc6\x73\x5c\x30\xef\xdd\x30\xef\x26\xa8\x08\x8d\x0f\xb4\xf2\xa8\x9c\x3a\x7f\x66\xd3\xb4\xb4\x3c\x8c\x70\xa6\x4e\x65\x96\x8a\x4b\xcc\x06\x9b\xa1\x4f\x10\xa7\x35\x4d\x03\x09\xae\x29\xb2\x99\x6c\xa0\x9c\xda\x9a\xda\x9a\x8a\x39\x39\xcd\xab\x83\x39\x48\x4c\xee\x13\x97\xb0\xb5\xbe\x54\x40\xb4\x50\x40\xc3\x82\x59\xd1\x04\x50\x12\xa7\x38\x50\x95\xb0\x08\x29\x29\x52\x85\xd1\x26\x2b\x13\x6f\x8b\x4b\xd2\xd2\x99\x7b\x55\xaa\xd9\xef\x8d\x2e\x88\xb0\x7b\xba\x6e\xdd\x37\xf7\x3f\x7f\xc4\x68\x6c\x69\xef\xe8\xec\x3f\x61\xcc\x34\xa3\xb1\x53\x79\xaf\x05\x3d\x85\x47\xc9\x5f\x4b\xce\xed\xc1\x8f\x4e\x27\x77\x57\xdf\xd2\xb1\xe7\x4e\xee\xf5\x4b\xe4\xa9\x47\xee\x58\x91\xdb\xad\x6b\x7a\x81\xc3\x7c\xa2\x60\x74\xb0\x49\xf7\xee\x4d\x2b\x8a\x6f\xfb\xfb\x81\x31\x2f\x2d\xde\xf9\x7a\xe8\xf8\xb1\xdd\x9d\x3a\x8d\x9a\xa3\xd0\x47\x23\xc8\xcb\x1f\x89\x41\x64\x43\xb9\x01\x07\xe6\x04\xce\xae\x77\x68\xcc\x43\x83\x1a\x41\xa2\xb5\x10\x05\x9e\xa3\xe6\x50\x20\x74\x30\x43\xac\x88\xa8\xd1\xab\x37\x6c\x55\x42\x4e\x15\x35\x5a\xe6\x5e\x27\xe7\xc8\x24\xf8\x9a\x7b\xb4\xcd\xc2\x7e\x5d\xc6\xb4\x99\x93\x94\x6e\x73\xe7\x25\x73\xcd\x42\xef\x73\xcd\x78\x67\xe8\x2d\x3c\x6a\xc9\xf0\x92\xea\x6d\x29\x96\x7c\x76\xb7\x42\x56\xb1\xb1\x4f\x01\x9e\x2e\x45\x34\x8b\x6b\x8b\xd0\xd3\xec\x5c\x30\x98\xa4\xbb\x95\xef\x15\x1b\x21\xfa\x1d\x69\x0e\x70\x38\x51\xcc\xa4\xc7\x87\x9e\x1d\xa5\x5e\xb4\x45\xe2\xca\xd8\x7e\x36\x83\xfd\xdc\xce\xf8\x24\xcd\x0e\x9d\x95\x21\xa6\x24\x3a\x2c\x16\x7b\x22\x27\x8a\x4d\x9b\xa4\x25\x18\x41\xf6\xd2\xea\x74\xc6\xa4\x24\xa4\x32\x3a\x72\x78\x3b\xb2\xf7\x51\xea\xf4\x28\xf9\xae\x95\x6a\x72\xe6\x1b\xcb\x3a\xd2\xd4\x05\x8e\x48\x35\x80\x28\x21\x2a\xf1\x59\x6f\xac\x8e\xed\x35\xe0\x16\xc2\xd8\xda\x51\xbb\xd6\x47\x28\xd1\xfa\x5d\xa3\x47\xfc\x10\x23\x44\xad\xfc\xa4\x8b\xbf\xa5\xd0\xf2\xe4\x43\xef\xfd\x45\xbe\x63\x04\xc9\xf9\xd7\x07\x0f\x92\xbb\x28\x31\x5a\xbe\x9c\x12\xa3\x79\x47\x8b\x8b\x8f\x2a\xb6\xa6\xfe\xc2\x6e\xa1\x1d\x2a\x40\xb7\x04\xf2\xcd\x62\x73\x77\x93\xd4\x54\xa7\x3b\x53\xe4\xb4\xb2\xbf\x30\x25\xa9\x69\x52\x75\xb0\xa9\x3d\x2b\xc7\x97\x53\x1d\xf4\x79\xec\x88\x73\x18\x35\x2a\x56\x74\xd8\xc8\xd9\x63\xd9\xbc\x61\xab\x6e\xac\xdc\xa6\xcc\x09\xf8\x14\xd5\x77\x68\x09\xd0\xfa\xec\x8d\x4e\xec\x95\x94\x2a\x86\x25\x0d\x13\xb9\x53\x85\xa3\x84\xbf\x85\xb8\xc8\x27\x03\x86\x97\x94\x66\x67\x27\x39\x86\xe6\x2c\x5a\x93\x5e\x2c\xe2\x2f\x70\xd9\x80\xf1\x25\xad\x72\xda\xad\xdc\xc6\x82\x26\x3b\x75\x1f\x34\x2c\xc8\x1d\x0d\xb5\xbb\x1d\x07\x1f\x9d\x3c\xc2\xf0\xa5\xca\xb0\x7f\x77\xf7\xc7\x96\x72\xdc\xa9\x95\xe4\xfe\x87\xa7\x0c\x4f\x20\xaf\x3d\xff\x10\x8d\xaa\x6c\xd7\xba\x9b\xf3\xa9\xb5\x8f\x9f\x62\x7b\xd7\x05\xe6\xbb\x42\x1c\x08\x3a\x9b\x0b\xf9\x03\x6e\xa3\x20\x8a\xc8\x0a\xc2\xb3\x3b\x41\x67\xae\x09\xea\x04\xc9\x51\x0b\xc2\x85\x25\x52\xed\x3b\x4e\xdf\x88\xfa\x98\x50\x81\x82\xd6\xd4\x8a\x5c\x9d\xd1\x0a\x04\x0a\x11\x59\xf1\xe6\xcb\xe4\xec\xb1\x93\x38\x01\x4b\xf0\xe3\x22\x1f\xfd\x76\x6d\xfe\xdc\xb9\xf3\xb8\x5d\x80\xaa\x8f\x37\x23\x03\xf1\x23\x4d\x71\x7f\x9c\x85\x83\x78\x20\x79\x94\xec\xc2\x27\x49\xd1\xe5\x1f\x7f\xa4\x30\x31\xfc\x02\xb9\x59\x4f\x3d\xfc\x03\x6e\x9a\x3c\x49\x30\xa8\x05\xb5\xdb\x23\x9b\x41\xe4\x33\x61\x27\x88\x3e\x58\x31\x92\xdc\x14\x26\x5a\xe2\x8b\x2a\x41\x66\x5a\x5f\x2c\x9e\xb2\xe1\x4f\x0f\xbd\xce\xb4\xa0\x57\x5f\xe8\x4f\xd5\xa0\xf1\x53\x17\x4e\xa6\x85\x5a\xd2\x71\xf2\x45\x45\x09\xfa\x8a\x7c\x9d\x45\x06\xf3\xaf\xbf\xfc\xf4\xd3\x2f\x1f\x3e\xf8\x14\x3b\xa7\x95\x30\xfe\x9d\xb0\x46\x0e\x54\x1c\x48\x34\xc5\x72\x66\x5a\x71\x6d\x50\x2b\x5b\xad\x48\x96\xf5\x35\xb4\xe2\x98\xa5\xbe\xe2\x58\x7c\x09\xfa\x48\xcd\x31\x5a\xeb\x59\x70\x8a\x31\x60\x4a\xcc\x9c\xfa\xdd\xef\x70\x26\x0a\x7f\x80\xc5\x00\xa9\x6b\xfb\xce\xac\xb5\x0f\xde\xd7\xa6\x1d\x0a\x7b\x71\xe6\x97\x18\xe3\x82\x17\xde\xe9\xfc\xcd\xc1\x7b\xb7\x3f\x66\x23\x7a\x06\xc7\x24\x58\x97\x9e\xb0\x2e\x4d\x00\x8e\x24\xbb\x0a\xa5\x18\x52\x32\x55\x42\xd3\x66\x46\x3b\xe2\xd3\xb5\xe9\xb9\xd5\xc1\x74\x8f\xd6\x02\x87\xcd\x14\xef\x1c\x14\x07\x87\x48\x53\x49\xf1\x45\x0d\xaa\x7d\xb1\x54\x52\x3c\x2d\xa3\x49\x83\x47\x19\x2f\xe0\x5b\x04\xfa\xef\xd9\xbf\xa8\x67\x9c\x7f\xd3\xf8\x49\xb9\x95\x53\x3b\x77\x5b\x33\x3e\xd0\x65\xf1\xfe\x59\x47\x3e\xec\xf6\xc9\xa0\xf9\xb3\x46\xe4\x36\x77\xe6\x76\x9a\xfc\xf4\x32\xac\xc2\xd9\xcc\xcf\xe9\xb1\x9d\xb7\x4c\xa8\x68\xe2\x70\xe6\x77\x99\x74\x4b\xbb\x65\x83\x5b\x34\xff\x36\x31\xa3\x35\x83\x7d\x17\xac\x61\x35\xf3\x17\x69\x19\x48\x46\x5a\x35\x75\x11\xd1\x4a\xbc\x5e\xa7\xe6\x6a\x82\x20\xd2\xaa\x01\xf1\x54\xf4\xce\x5a\xb0\xc4\x17\x7f\x69\x54\xd6\xb9\x88\x5d\x01\xb2\x6b\x6c\xde\x46\x5e\x20\x67\xf9\x27\x42\x0b\xb8\x89\xb8\xfd\x8b\x84\xa7\x8e\x2a\x8b\x49\x2d\x8c\xb5\x16\xd6\xa9\x2d\xab\x67\x04\x63\xd1\x91\x90\x56\xd6\x0a\xbc\x4e\xaf\xe6\x2a\x63\x63\x01\xfb\x30\x32\x91\xf9\x5f\xc6\xca\x88\x1f\xab\x37\xe9\x4d\x7e\xe2\xf7\x85\x86\x72\x33\x07\x1c\x0d\x05\xc4\x8b\x27\xc9\x64\x32\x8f\xce\xcb\x0e\xb4\x6f\x1f\xe0\x46\x1e\xad\xf4\x95\xe5\x31\x8b\x5a\x24\x7a\x1c\xa9\x52\x93\xa6\xa9\xc9\xe9\xc9\xb5\xc1\x5c\x5b\x9e\x1d\x7e\x0c\xe9\x02\xa5\x13\xb5\x41\x83\x15\xd5\x13\x89\xfc\xfc\xc6\x45\x2e\xa8\x17\xab\x1c\x0b\xb5\x8d\x14\xe0\xb5\x96\xe0\xac\xe2\x92\x28\xd9\x28\x8a\x91\x0d\x2c\x4c\xf7\x38\x72\x3d\x4d\x9b\xa6\xb4\xf6\xce\x4c\x99\xb9\xae\x58\x1d\xea\x96\x6e\xf7\x38\xd3\x23\xdf\xcc\x5e\x6b\x49\xe2\xf6\x09\x67\x5f\x5e\x1a\xfe\xa3\x5b\x65\x47\xcb\x47\x1a\xed\xe2\x51\x77\xe3\xaa\xe2\xd0\x9b\xc6\xad\x0f\xac\xc6\x78\x6c\xe4\xcb\x11\x6d\x9f\x7e\x86\x33\xb1\x7d\x2a\x62\xfe\x48\x34\x4e\x05\x78\x92\x8a\x26\x52\xe5\x64\x41\xd0\x68\x55\x02\x2d\x5e\xc1\x49\x88\x91\xb9\x46\xd5\xec\xd4\xd8\x67\xf5\x16\x61\x3f\xef\x15\x36\x91\x73\xdf\x5f\xa8\x7b\x1b\xe7\x7c\xff\x3d\xdf\x92\x4f\xae\xfb\x8a\x1b\xd7\x02\x98\xcb\x32\xda\xb7\x8a\x04\x41\x86\x1e\x08\xfa\x40\x7e\xc0\xe3\x34\x18\xdc\x28\xc1\x9c\x2c\xc9\x29\xa9\x48\x74\x27\xb9\x44\x8d\xd9\xa3\xe1\x29\xf7\x8b\x18\xcb\x9d\xf5\x85\x36\xb1\x62\x31\xa3\xf1\x3a\x82\x85\x52\x9a\x92\xb6\x5c\x1b\x2c\x66\x65\x64\x66\x89\x59\xdc\x9e\xec\xf1\xdd\xd7\x6e\xd9\x3e\xf5\xde\xad\xc1\x97\x70\xfa\x76\xb2\x90\x6c\x96\x9e\x79\x65\x20\x79\x62\x08\xde\xe6\x68\x4a\xba\x8c\xe4\xdf\xe8\x5e\xf1\xc8\xfe\x51\x83\xfc\xbf\x91\x0a\xf2\x3d\x99\x4a\xaa\x3f\xb0\x2c\xfa\xf5\xb8\x70\xea\xe0\xcf\x93\xfa\xff\xbd\x8f\xc2\x96\x42\xfa\x09\xeb\xc4\x0f\xe0\x8c\xe7\x04\x5c\xc8\x6c\xe6\x44\xbb\xac\x11\xd4\x3a\xb5\xd3\xa5\x11\x55\xbc\xa0\xb7\x7b\xf4\x48\xe1\xc6\x31\xa8\x32\x0a\xb3\x22\x20\x64\x64\x66\x94\xc0\xf9\xa7\xf4\x46\xb4\xf0\xcb\x9c\x64\x79\x0d\xde\x91\xd6\x92\xd4\x0e\xc1\xd3\xde\x20\x5b\x77\xe1\xb1\x78\xeb\xb1\x54\x37\xf9\xac\xcf\xc2\xf5\xcb\x5f\x7c\xe3\x9d\x41\x43\x4e\x1d\x7d\xfe\xf8\xbc\xd7\xd6\x91\x1d\x24\x8d\x3c\x35\x91\x7c\x31\xad\x06\xbb\x29\x1c\x9d\x01\x77\x17\xc1\x39\xc9\x45\x9d\x03\x19\x36\x73\x92\x5b\xcc\xcc\xf4\xb9\xcd\x48\xcc\x6b\x22\x69\xb5\x86\x74\x8f\x85\x4f\x75\x1a\x9c\xc3\x82\x6a\xc0\x24\x5c\xa3\xa4\x83\xaf\xaf\xa5\xe1\xf7\x37\x48\xd9\x1d\xb9\x9c\xa7\xac\x84\x45\x46\x47\x94\x60\x7f\x44\x31\x6d\xf0\x06\xfe\xaf\x33\x6f\x6d\xd7\x3c\x6b\x54\xd5\xfa\xe2\x82\xe9\xd5\x33\x66\x5e\xc9\x69\xd6\xb4\xe4\xfb\xac\xe6\x4d\x4a\x7f\x68\x3a\x38\x48\xfa\x7f\x53\xbd\x6c\x46\x55\xb7\x9d\x95\xd5\xc7\xde\xe1\xdf\xac\x9b\x74\xf7\x92\x6d\xcb\xf8\x15\x75\x93\xd6\xaf\xa0\x7f\xff\x79\x79\xfb\x0b\xb7\x28\x72\x4d\x3b\x98\xc3\x52\x38\x7f\xb9\xa8\x67\x20\xdb\xe3\xf2\xa5\xea\x34\x1a\x84\xb2\x53\x5d\x22\xcc\x02\x24\x01\x8b\x3d\xc7\x9b\x60\xcc\x48\xb2\x03\x33\x35\xda\x1d\xa2\x04\x67\xf1\xc6\x69\x34\x9c\x07\x5b\x6f\x0a\xa3\x57\x99\x0e\x93\x07\x32\xeb\x27\x14\xcd\x6c\x1f\xf9\x2b\x2c\xf5\x8f\x1f\x5d\x77\x9c\x57\x75\x03\x24\x1c\x77\x6b\xbf\x61\xd6\xf4\xc9\xb7\x4e\x9c\xf1\xf5\xa0\xfc\x56\x97\x06\x35\x6f\x79\x49\xb3\xe3\xa5\x7e\x6f\x8f\xbb\x7d\xe7\xa8\x91\xe3\xa6\xcf\x18\xfb\xd1\x49\xee\xe9\xd0\x83\xe4\xe2\xee\x65\x5c\x15\xfd\xfb\xd4\x1a\xae\x23\xcc\xa3\x2f\xf3\x4f\xe8\x87\xdc\xb4\x3e\x35\x32\x8a\x6a\xb5\x4a\x65\x37\xf2\x9e\x44\x87\xcb\xea\xaa\x0d\x5a\x05\x1d\x5f\x1b\xd4\xe8\x74\x92\xda\x22\xf1\xca\xa9\x28\x8b\x26\xe5\x6f\x74\xa7\xc0\xe8\x3d\x25\x25\x8a\xfc\xc9\xdc\x7d\xa9\x05\x47\xc2\x0b\x47\xce\x1b\x3a\x14\x67\x91\xb3\xf7\x2d\x7f\xf7\xfc\xd8\x97\x67\xb7\xee\xe9\xcb\x74\x0c\xe8\xca\x3f\xb2\x68\x41\x31\x37\xf2\x9f\x17\x39\x63\xe0\xea\xe5\x15\xc7\xc6\x99\xdf\x97\xc7\xd1\x9c\x65\x00\x53\xa1\xf8\x21\x4a\x44\x6d\x02\xa9\x56\x29\x01\xa1\xc4\x44\xd0\x14\x92\x92\xdd\x48\x6f\x54\x1b\xab\x83\x82\xa3\x3a\x88\xd5\x02\x8d\xd4\xa4\x27\x95\x8a\x56\x79\x91\x2a\x01\xf1\x20\x29\x85\xf7\x12\xb0\xc9\x1b\x49\xaa\x2f\xc5\xd5\x32\xe0\x3d\x6d\xb7\x0f\x23\x4f\xe0\x76\x9e\x25\xe9\x2d\xf3\x03\xe5\xfd\xfa\xd5\x4c\xc1\x09\xdc\xb0\xd9\x13\xf1\x0e\xdc\x09\x4f\xd1\xc8\x1f\xeb\x7a\x76\x3c\xb7\xeb\xbe\x43\xf7\x72\xf9\xff\x14\xd2\x3d\xbf\x8b\xe9\xc7\x15\xc0\xb1\xcb\x02\x49\x6a\x51\x94\xac\xc8\x68\x35\xba\x3d\x56\xdb\xb0\xa0\xd5\xa3\xe3\x6a\x83\x6a\x58\x28\x19\x44\x89\x06\x0b\x15\x57\x81\x8d\xca\x12\x70\xc8\xd9\x2a\xd1\xf5\xb1\x30\x83\x12\xec\x76\x5b\x8e\x1f\x78\x71\xe4\x40\x72\x16\x67\x75\x5f\x52\x79\xf2\x6b\xf2\x0e\xf9\x80\x4c\xc0\xd5\xd3\x56\x55\xe7\xe1\x76\x78\x8e\x3f\x34\x4f\xac\x20\x96\xd4\x24\x72\x82\x5c\x24\x1b\xc9\xaa\xb7\xdb\x2d\x7a\x8f\xca\x11\xa9\x40\x9b\x9f\x13\x66\xa3\x1c\xe4\x47\x55\x81\x66\xb9\x5e\x8f\x80\x04\x2e\x2b\xdf\x6b\x94\x0b\x8b\xac\xba\xea\x60\x72\xd3\x3e\xc1\xac\xe4\x74\x6b\xb2\x35\xd9\x98\x9e\x5e\x50\x19\xcc\x49\x37\x19\xed\xb2\xab\xbe\x6c\x67\xf9\x89\xb8\x7a\x99\xf1\x2a\x16\x23\xd4\x0e\x3b\xbd\xfb\xc8\x8a\x84\x38\xc7\x22\xe2\x8b\xea\xc3\x34\x1c\xce\xe2\x12\x65\xf7\x69\x23\xe1\xb9\x66\x7d\x5b\x5f\xfe\x74\xde\xf0\x56\xc5\xce\xaa\x73\x15\xf3\xbb\xb6\x1a\x58\x59\xed\x1f\xda\x9f\x7b\xec\xd1\x3d\xc7\xfe\x3a\x33\x78\x4f\x87\xe2\xe2\xd0\xe4\x6e\xdd\x57\x8f\x4f\x9d\x52\x71\x80\x3f\xdb\x79\xc8\xac\x2d\xe4\x0a\xf9\xa2\x2c\xcd\x39\x64\xe0\x86\xea\x8c\xa6\x19\x0f\x3d\xd3\x69\xfa\x5d\x4b\xb6\x1e\x68\xd5\xbc\x53\x2f\xf2\x48\xb3\xb2\x79\x4d\x0b\x94\x33\x17\x80\xb9\x6e\x05\xda\xda\x1c\xb5\x0a\xa4\xa6\xe7\x69\x1c\xa0\xa3\x9a\x1c\x79\x42\x41\x0b\x8d\x31\x3b\x59\x68\x66\x6d\xe6\xad\x0d\x36\xb3\x5a\xf5\xb0\x1d\xc2\x4d\xc5\x03\x46\x2b\x0a\xdb\xf2\x40\x5a\x15\x46\xc3\x5c\x85\x05\x2a\x19\x44\x39\x12\x13\xb6\x33\xa8\x65\x9c\x46\x5a\x04\xf2\xba\x8d\x9c\xb7\xe1\xee\x81\x45\x93\xc7\xbf\xd4\x84\x7c\x95\x51\x77\xe1\x32\x4e\x28\x1b\xbf\xff\xc3\x89\x93\x16\x2d\x5f\xbf\xde\x90\x86\xb9\x5c\x2f\xf9\x84\xfc\x4e\xae\x93\x4f\xf1\xca\xae\x53\x6f\x29\x6f\x9e\x95\xd9\xa4\x5d\x8b\x6e\xbd\x9f\x4b\x7a\x61\xef\xa9\xa7\x2b\x97\xd6\xf4\xf2\x7b\x06\xb5\x0b\xf6\xed\x3f\x24\xa5\xb0\x4d\xf7\x0e\x33\xcb\x0e\xbc\xa1\xe4\x59\x42\x43\x98\x3d\x60\x20\xd0\x90\x92\x40\x72\xba\x64\x4a\x4c\x44\x0e\x49\xc8\x6b\x92\x9b\x6e\x37\x09\x09\x7c\x82\xb5\x4f\x30\x41\xe0\xb3\xaa\x1b\x28\xc2\x0d\x84\x1d\x7a\x01\x9f\x9a\x5e\xf4\x3f\x66\x54\x22\x0c\x58\xf8\xcc\x7c\xc0\x9b\x93\xff\x3e\x9b\xf5\x5b\xa6\xbd\x3a\xbf\x4d\x73\xef\xd9\x63\xff\x3e\x87\xc1\x95\x79\x85\x14\xe7\x80\xd0\x09\xc7\x59\x0d\x3c\x1f\xea\x12\xc8\xf6\x99\xbd\x26\xc9\x64\x40\x69\x56\xb3\x47\x95\x9e\xa1\x71\x26\x39\x6b\x83\xb2\x1b\xb9\xd3\x78\xb3\x90\x24\x58\x8c\x3e\xb3\xaf\x36\x68\xb6\xc4\x29\x43\xce\xc6\xaa\x10\xcd\x9a\xaa\x10\x0c\x26\xb1\x19\x31\xf5\x57\x53\x2e\x91\x24\x25\xc3\x94\xd3\xaa\xc5\xdc\x68\x4f\x60\xd9\xec\x0d\x73\x3a\xfb\xaa\xf2\x8a\x5a\x79\x87\xe2\xda\xba\x02\x3c\xb4\x26\xb5\x75\x51\x5e\x95\xaf\xf3\x9c\x0d\xb3\x96\xb5\xfb\xfd\xdc\x39\xa1\x4b\xd1\x6d\x35\xa3\x8e\x25\xe6\x67\x97\xbf\x14\x9a\xfa\xd6\x5b\xdc\xfa\x97\xca\xb3\xf3\x13\x8f\x8d\x1a\xb2\xa8\xae\x1f\x7e\x90\x30\xff\x74\x01\xe6\xf0\x2e\xc8\x99\xc9\xc8\x0b\xe7\x26\x2f\x35\xc1\x94\xa2\xf7\x4a\xb4\x9c\x99\xc5\x24\xa6\xf9\xd4\x0e\x0f\xd0\x18\xd9\x85\x5c\x29\xbc\x49\xf0\x98\xf4\x16\xb3\x21\xd5\x94\x5a\x19\x34\xd9\xa3\xd3\xc8\xf7\xdf\x38\x91\x58\xb0\x64\x49\x3d\xf5\x8b\x9f\x4b\x74\x2a\xbc\x97\x1b\xd7\xbd\xed\xc2\xaa\x4d\xb3\x3b\xf7\xeb\x5a\xda\x3d\xad\x0a\xf7\xad\xeb\x88\xfb\x54\xa6\xf6\x2c\xed\xda\xaf\xf3\xec\x4d\x55\x0b\xdb\x76\x7f\x09\xcf\xe3\xbb\x8c\xea\xdb\x63\xec\xc9\xce\x85\xcd\xa7\x11\xff\x91\x23\xf8\xed\x69\xcd\x8a\x3b\x9f\x1c\xdb\xa3\x2f\x71\x2b\xfe\x3d\xca\x5d\xfd\x32\x90\x65\x9c\x28\x0d\xb5\x0b\xa4\x89\xc9\xc9\x66\x97\x56\x8b\xcc\xbc\x2f\x5d\xe5\x01\x59\xd3\xa0\x52\x39\x0c\x0e\x3c\x34\xe8\x40\x06\x6f\x8d\x22\x9a\xc5\xdf\x6e\x37\x12\x3e\x59\x71\x71\xe6\x3e\x6f\x8f\x38\x0b\x5a\x8a\xd3\xbd\x7e\x3e\xa6\x5f\xa4\x0a\xb6\xbb\x8e\x7f\x39\xd5\x52\xb2\x7d\xc8\x8f\x58\x26\x5f\x93\x10\x09\x93\x6f\x07\xbc\x80\x5b\x63\x4f\xcd\x03\xab\xd7\xac\x5d\xbd\x76\x25\xb6\x0b\x9f\xfb\xa7\x4d\xcb\xf3\x93\xef\x68\xfd\xd5\x0b\xb8\x1a\x97\xa1\x30\xee\x78\xb8\x5f\x5d\xc5\xb6\xbb\xef\xd9\xba\xe3\x21\x05\xff\x07\xb1\x18\x81\x3e\xb0\x03\xe5\x01\xe0\x1a\x4e\x10\x66\x13\x25\x21\xcd\x97\xe8\x4e\x71\x57\x06\x53\x52\x78\xb5\x5a\xd7\xe7\xc6\xab\x20\xe5\x02\xa1\x21\xf2\x44\xad\xf3\x5e\xbf\x1d\xa6\x10\xab\x96\xcf\x64\x49\xba\xe4\x42\x0d\xf9\xe5\xef\x6b\xe4\x2f\xbc\x0b\xaf\x3b\x7d\xf4\xc4\xcb\xd3\xcb\x16\xde\x36\x65\xce\xf0\x21\x1d\x3b\x0c\xaf\x3d\xfe\x0e\x9e\x7f\xe4\x3d\x9c\x86\x05\x9c\x82\xd3\x4e\xe7\x0f\xdf\x32\xf1\x81\x47\x86\x0c\xa9\xea\x6f\x7f\xc3\xfe\x2c\xbb\xc7\x06\x5c\x19\x2c\x2e\x01\x38\x3b\x06\x00\xc9\x9d\xc9\x5a\xad\x47\x27\x21\xa4\x73\xf2\x69\x3e\x8d\xc1\x6d\xa8\x09\x26\xbb\x79\x9b\xcd\xed\xd6\x25\x0a\xba\x28\xf1\x37\xfb\xcd\x37\x71\xf0\x52\xdc\x4b\xd8\x4d\x07\xf5\x57\xf3\x9a\xd9\xba\x52\xb4\x8f\x14\x3b\x35\x53\x68\x07\x1b\xd4\x7b\x0c\x6d\x7b\x65\x90\x2f\x33\x7b\x96\x1b\xf6\x68\xf4\xbb\xef\xcf\xc2\x29\x99\x5b\x1f\xe6\x9d\xa9\x13\x93\x72\x4a\x93\xca\x4b\xeb\xb6\xf1\xc3\xca\xda\x26\x95\xe6\x78\x27\x24\x3d\xb0\x11\xb7\x25\xc7\x1e\xa0\xb0\x52\xff\x6f\x8e\xf9\x6e\xf4\x0a\x64\x4a\x3c\xaf\x92\x65\x41\x4b\x1d\xec\x05\xad\x4e\x2f\xc3\x1f\xc4\xd3\x3a\x44\x6a\x49\x80\x1f\x4e\x23\x2a\x2a\xbd\xbf\x81\x8f\x9d\xab\x91\x41\xb7\x20\x9a\xb3\x5d\x2c\x12\x79\x2f\x9f\x61\xe7\x7e\x70\x7c\xe9\x20\x57\xb0\xdb\x89\x5b\x38\xb1\x87\xef\x5f\xf7\x18\xdf\xdf\x41\xac\x78\x07\x19\x6a\x25\x8a\x3f\x0b\xb5\x7f\x09\xed\x50\x36\x6a\x1f\x48\x37\x8b\x99\xee\x54\xa7\x5b\xe4\xb4\x52\x4e\x6e\x4a\x92\x0f\x64\x22\x9f\xe3\x7f\x19\x16\x1a\xc8\xde\xff\xdd\xa0\xe0\x8c\x28\x11\xff\xd5\x8c\x40\xbf\x72\x0e\xcf\x58\xb4\xe6\xbf\x58\x10\xa2\xdf\x50\xc3\x01\x87\x40\x1c\x14\x16\x00\x8d\x48\x42\x59\xa8\x34\x90\x24\xf9\x7c\x2e\xe0\x38\x06\x17\x9f\x9d\x23\xf1\x1e\x8f\xb7\x32\xe8\x31\x19\x3d\x7c\x26\xab\x82\x19\xbd\x1c\xbc\xa1\xaa\x31\xad\x80\x9d\x99\x45\x99\x66\x32\x76\xfa\x58\x89\xd5\x66\x98\x63\x17\x98\x8a\x17\x2e\x93\x4f\x85\x05\xe4\xda\xe5\x71\xbb\x9b\x18\xfb\x3f\xf9\xfc\xcc\xbb\xbb\xab\xaf\x35\xa9\xed\xb5\xeb\xcb\xe5\xe5\xd8\x52\x87\x39\x6c\x25\x17\xe6\xcf\xba\xbe\x60\x1a\xe1\x72\x43\xe4\x93\xee\x6d\x67\xce\x6c\x51\x3a\x7d\x6a\xa2\x43\x3d\xf8\x39\x9c\x8f\x5d\x80\xb7\xed\xc9\xb7\xe4\xda\x8b\xbb\xc9\xd6\x67\x9e\x65\x36\xae\x48\x0c\x91\x45\x42\x9d\xd8\xe7\x99\xa4\x3f\x3f\x94\xda\xb3\x50\xcf\x86\x7e\xaa\xc2\x26\xb6\x5f\xb7\x02\xde\xf4\x63\xf5\xfb\x3b\x07\xb2\x78\x49\x32\xda\x34\x80\x1c\xbc\xdd\xc1\x83\xe4\x6a\xe4\x53\x14\x9f\x63\x9d\xc5\x82\xfa\x04\x2d\x46\x9d\x9a\x16\xf2\xbf\x99\xcf\x71\x83\x72\xce\x34\x8a\x30\x99\x5d\x50\xa5\x46\xae\xce\xb8\xff\xac\x5c\xaa\xe7\xbc\xa1\x0b\xc6\x25\x2b\xf0\x51\x92\x43\x7e\x23\xdf\x63\x27\xd6\xe1\x8f\xf9\xc9\x73\xe6\x9c\x9c\x35\xfd\x24\xb6\x60\x2d\xfc\x58\x4e\x46\x7c\x24\x68\xed\xd8\x28\x5c\x6a\x64\x36\x18\x44\xd1\x88\x00\x2e\x93\x11\xe0\x32\xa5\x98\x00\x2e\x93\x49\x8d\xd5\x1a\xa0\x14\x76\x96\xfb\xfd\x66\xd5\xb1\x1b\xea\x0a\x11\x68\xa8\x94\x5d\x02\xb2\x36\x6c\xc9\x6c\xfc\x31\xd6\x63\x07\xf9\x8e\x5c\x23\x39\xf8\xe8\x8a\x25\xc6\xd0\x05\xce\xab\x5f\xba\x92\x9f\x7c\x92\xfc\x04\xec\xfd\x77\xf2\xd3\xc9\xe9\xb3\x4e\xce\x9d\x1d\xf1\xe9\x5e\xcd\x7c\x3f\x77\xb0\xb5\x5c\x0f\x78\x32\x9a\xad\xed\xcb\xec\x33\xbd\x6f\xbc\x87\xf9\x00\x67\xb2\xcf\x0d\x7c\x94\x61\x4e\xad\xa1\xfd\x5d\xcc\x96\x58\x10\x70\x71\x20\x47\xda\x2d\x16\xb3\x64\x76\x38\x2d\x76\x3b\x67\x94\x8d\x92\x47\xc7\xca\x67\x96\x2b\x0e\x5e\x8d\x5c\x1a\x7c\x3c\x0b\xe1\xa3\x6e\x5d\x4e\x4b\x89\x95\xa6\x43\x2e\x2c\xe1\x3e\xfe\xe8\x7b\xd3\x0f\x78\xdc\x52\x63\x13\x75\x46\xca\x42\x3c\xe2\x07\x0b\x3f\x73\xf3\xa8\xeb\x17\xc5\x8b\x24\x25\xff\x4a\x5f\xac\x1d\x8e\xbf\xbc\x7e\x82\x9b\x31\x7a\x8b\xc2\x37\x10\xc0\xb0\x53\xe8\x0d\xb2\x6c\x3a\xea\x11\xc8\x72\xa3\x54\xad\x5a\xd2\xeb\x2d\xc0\xc7\x0d\x99\x19\x8e\xa4\xca\xa0\xc3\xa4\x33\xd1\xca\xcd\x6a\xb3\x99\x37\x78\xf8\xb4\x7a\x1a\x1c\x75\x5d\x8d\x8b\xf8\x60\x2e\x81\xf1\xd7\xcc\x8e\x24\x4c\x33\xd0\x79\x69\x7a\xaf\xe8\x7d\x33\x45\xf6\x04\xcc\x0c\x67\x3b\xaf\xbf\x77\x78\xbe\x20\xec\xdf\x4f\xce\xce\x99\x83\x6d\x3f\x6e\x23\x77\x92\x73\x6b\x67\x7e\x36\x7d\xe3\xe8\xa9\x9c\xf0\x0b\x39\xbb\xba\x75\xd9\x9c\xe3\x13\x27\x1e\xe7\x5e\xba\x86\x1d\x77\x93\xdf\x1e\xdc\xfb\x0e\xbd\x77\xbe\xed\x85\xf8\xf5\xc5\x5d\x1a\xac\x77\x26\x5d\x6f\x56\x83\x3d\x9b\x73\xa3\xec\xbd\xd8\x45\xaf\xe0\x5c\x09\x09\x5d\x5c\x01\x97\x0b\x5e\x4c\x66\x78\xd1\xeb\xe1\x45\xad\xee\x02\x1a\x70\x1e\xfd\x57\xd4\xb0\x0f\xda\x27\xed\x23\x7c\x95\x4b\xfc\x3f\xf6\xc1\x7c\xfd\xa5\x47\x01\x8e\x6c\xd6\x47\x87\xf0\xf3\xe8\x1a\x52\xed\xc7\x66\x66\x56\x8e\x6b\xb3\x38\xd6\x86\xda\x9e\xbf\x62\x37\x39\xcc\xa5\xf5\x50\xf8\xeb\x03\xb0\x05\x9a\xb8\x9b\x1c\x0c\xcf\xfd\x20\x3c\x08\x7a\x87\x17\x4d\x09\x04\x04\x9e\x37\x6b\xb5\x29\x29\x16\x5f\x82\xd3\x6c\xb6\x59\x2c\xc0\x2f\x0d\xb5\x41\x94\xb8\x23\x91\x43\x89\xa6\x44\x38\x0f\x89\x89\xb2\xdd\x65\xb3\xdb\x6a\x82\x76\x1e\x0e\xac\x5c\x1b\x34\x09\xa9\x42\x73\x81\x17\x04\x04\xfc\xbf\x40\x29\x42\x5a\x1e\xbb\x19\x8b\x85\xd5\x45\xee\x54\x2c\xf5\xae\x90\x62\x2c\x45\x7b\x1b\x46\xab\x98\xea\x42\x5d\xc3\x99\xfa\x42\xab\xad\xf1\xf3\xe7\x6d\xca\x7a\xcf\x94\x99\x92\xe1\x28\xeb\x31\x6d\x03\xf9\x93\xfc\xc8\xf7\x22\xef\x74\x3b\xd8\xf3\x91\xbb\x6d\xb3\x57\x76\x6c\x99\x3b\x61\x6e\xc6\xfa\x21\x81\xd0\x22\xa1\xf6\xd2\x25\xf2\x49\x5e\xcb\x53\xe7\xbb\x91\xf6\x74\x2d\x58\x4c\x87\xb4\xcb\x92\xc9\x57\xb0\xb5\x98\x85\xd6\xa2\xdf\xd9\x4d\x92\x24\x66\xe2\x91\x92\x5a\x88\xdd\x3a\x29\x36\x4a\x65\x8f\x90\x0b\x0d\x0b\xb4\x14\x25\xb3\xc9\x41\x63\xb1\x5c\x26\x49\x70\x27\x38\x50\x4d\xd0\xe1\xe0\xf5\x7a\x98\xb5\xd1\x8c\x75\xbc\xd9\xac\x17\x54\x7c\x4d\xb0\xb9\x18\x10\xb9\x54\xb1\xb9\xf8\x8c\x78\x55\xa4\x46\x31\x2b\x2b\xc3\x3a\x95\x69\xe2\x71\xbe\x7d\x8d\xcb\x36\x32\xc7\x88\x12\x91\x63\xc4\xc2\x1b\xb5\x25\xf2\x5e\x3b\x5e\x60\xbe\x73\xee\xce\x5e\xd8\xbc\x82\x2c\x21\xdf\x90\xb3\x5c\xe9\x0b\xd7\x5b\x91\xab\x49\x33\xba\xff\x94\x86\x57\x73\xa5\x7b\x9e\xbb\x56\x48\x06\xe0\x91\x78\x00\xb7\xf7\xf8\x2b\xed\xc7\xcd\x24\x8f\x5f\x52\xee\xe3\x32\x01\xfe\x3b\x19\x5d\x28\x46\x37\x8b\x9b\x50\xfc\x9d\x17\xc7\xfb\x3b\x03\x6e\xfc\x77\x7f\xe7\x51\xe1\x1f\xf8\xeb\xac\x8f\xa6\xec\x5c\x8b\xe1\xab\xc2\x51\xc0\x15\x17\x60\xcb\x2d\x81\x3c\x7b\x72\xb2\x20\x59\xad\x69\x82\xa0\x4b\x00\x3d\x3a\xcd\xa7\xb3\x27\x0d\x0b\xda\xed\xc9\x56\xab\x04\xda\x3d\xaf\x31\x0e\x0d\x6a\xac\x42\xf2\xb0\xa0\x80\xf2\xe3\xe2\xb8\xd8\x8a\x60\x7a\x69\x5a\x66\x8e\x8f\x36\x52\xc4\x17\x10\x5c\x7c\x7c\x7d\x61\x34\x4a\x84\x94\x48\x7d\xc5\x03\x5f\x38\xfa\xed\xf1\x73\xab\xb2\x0c\x1b\xd7\xb6\x4a\x36\x64\x15\x95\xca\x7e\xae\x58\x7f\xe8\xe2\x97\xc3\xfb\x98\x9d\x95\x43\xf1\x8e\xe7\xbf\x11\x26\x87\x5a\xff\xf2\x96\xf9\xa2\x3c\x7f\x39\x3f\x36\xf4\xe3\xb9\xc3\x23\xa6\x91\xaa\xf1\x14\x7e\xe0\x4e\xc2\x73\x00\xbf\x05\xb9\x51\xcf\x40\xa6\x56\x96\x8d\x2e\x97\x4e\x10\x54\x56\x95\x27\xd1\x8a\x50\xa2\x53\xd2\x4a\xc3\x82\x46\xd8\x77\xbd\x9a\x57\xb9\x00\x70\xc5\x5b\x5d\x29\xaa\x18\xf1\xa9\xc7\xfe\x7a\xa8\xfd\x51\x01\x46\x81\x9b\x45\x3d\xb3\x9f\x7a\x88\x85\xe7\xae\x9d\xfd\xf0\xe2\xe5\xcb\x17\x2f\x1b\x4e\x7e\xf5\xc5\x94\x1a\xbd\xf5\x4d\xbc\xe3\x95\x2f\xb8\x09\xa1\x7b\x94\x20\xbb\xd0\x8f\x9f\x1c\xa9\x9d\x42\x46\x2a\x78\x48\x7d\xff\xe9\x79\x74\xa0\x0e\x81\x0c\x07\x06\xf6\xe3\xb2\x9a\xcd\x4e\x95\x0b\x59\x6d\xd6\x9a\xa0\xa0\xaf\x0d\x36\x17\xa6\x08\x8b\xe9\x81\x53\xd9\x78\x33\x03\xb0\x9c\x55\xdd\x8f\x40\x67\x61\x86\xfc\x88\x38\x68\xae\x0f\xcb\x8e\x3b\x61\x5c\x22\x3b\x42\xa4\xac\xc7\xc2\x15\xca\xa1\x12\x6a\xc9\x39\x38\x3d\x17\x88\x0e\x9f\x59\x3f\xa4\x5b\x68\x25\x3d\x50\xd1\x18\xa2\x37\xd8\x39\x7a\x2b\x72\x8e\x16\x45\xce\x91\x15\xce\x51\x47\xab\x03\x69\xeb\xcf\x51\x24\x8e\xa4\x33\xa5\x53\xfc\x1b\x0d\xe9\x94\xb5\x9e\x4e\x49\x80\xab\xc7\xa8\x1f\x3d\xff\x01\x6d\xa3\xba\x0c\x5a\xdf\xe5\x58\x9f\x3a\xa7\x57\x63\x68\x70\x36\xd7\x00\x3f\xe9\xc0\x6c\xdf\xc0\xd3\x64\x2d\x42\x2a\x91\x53\x71\x7a\x9d\xcc\xf3\x1a\x8e\x13\x87\x06\x39\x0b\xf2\xd4\x97\x82\xbd\x31\x88\x37\x16\xf1\xf8\x3d\xd9\x81\xb3\xf0\x78\x9c\x45\x1e\x24\xfd\xf1\x63\x62\xc5\xf5\xa7\x85\xaa\x7f\x5e\x24\xfd\xd1\x0d\x71\x62\x80\x2f\x74\xee\x9b\x59\x0c\x8c\x9d\x7a\x79\x4a\x48\x6d\xb1\x08\x7a\x50\xef\x1c\x4e\xb5\xb9\x26\xa8\x56\x5b\x62\x36\x77\xd8\x19\xcb\xbf\x7a\x79\x32\x87\x1a\xd0\x22\x22\xe6\xf0\x02\x87\x18\xc3\xe6\xcd\xe4\xca\xb5\xd0\x5f\xfc\xbe\xd0\x4c\x8c\xaf\xfe\x4d\xce\xdc\xb1\xe6\x89\xbd\x6b\x97\xe1\x1d\xc7\xce\x8b\x15\x17\xc9\xbb\xef\x9e\x18\xdc\x8f\xfc\xa7\x5f\xe3\x98\xb5\x28\x7d\xa3\x9f\x29\x7d\x03\x58\x4d\x64\x8c\xf0\x0c\xc0\x6a\x00\x58\x3b\x07\x7c\x3c\x67\x57\x9b\xf5\xb4\xd2\xb8\x9a\x66\x19\x97\x9d\x0e\xbd\xb9\x36\xa8\x07\x59\x52\x25\xaa\x6a\x83\xa2\x45\xe6\x98\xdb\x94\xbf\x3c\x56\x34\x57\x81\xb7\x81\xbd\xd0\x1f\x29\x14\xea\x2f\xa6\xc2\x00\x0f\x07\x53\xe2\x64\x01\x3f\x7d\x35\x14\xb8\xba\xa8\x77\x1f\x7b\x29\xb7\xec\xf7\xa3\x29\xa6\x76\xed\x2e\x84\x56\xe1\x4d\x64\x0c\x37\x67\x06\x4e\x3e\xc1\xe9\xaf\x6f\xe6\x57\x90\x7d\x4f\x92\x6f\xa6\xd5\xf3\xa5\x68\x9c\x1a\xec\xa7\x48\x71\x0a\x60\x4d\x43\x33\x03\xad\x12\x53\x52\x92\xac\x69\x69\x48\x16\x04\x93\x09\x21\x29\x39\x39\xc9\xe9\x72\x25\x25\xa5\xeb\xb4\x5a\x51\x4a\x94\x53\x04\x59\x30\x79\xb1\x09\x0f\x0b\x5a\x17\x99\xd6\x83\x4c\x66\x72\x9a\xb5\x7c\xb2\xa4\x04\x76\x81\x18\x43\xc3\x2c\xe9\x2c\x22\xbe\x72\xd4\x7d\xce\x5f\x1f\x71\xa4\x50\x97\xd8\x4e\x28\xb6\x3b\xe0\x3c\xbc\xd7\xda\x0c\x67\xf1\x7e\x2a\xea\xc0\x7f\x51\xaf\x76\x3f\xd0\x1d\x19\xe6\x29\xf9\xcc\xf8\x4f\xb1\x50\xda\x1f\x46\xa1\xcc\xae\xce\xc9\x57\x07\xa4\x77\x2e\xf9\xa2\xb8\x4b\xfa\x80\xab\x93\x9d\x5d\x33\x43\x61\xb4\xbf\xb9\x91\x6b\x6f\x91\x42\x8f\x72\x6f\xe5\xac\xae\xc4\x73\xc9\x89\x45\xd3\x4c\x5c\xab\xd0\x6b\xa6\x29\x4b\x70\x4b\xb2\xb2\x6a\x55\x4e\xa8\x98\x1b\xe8\x0a\x1d\x89\xfa\x02\xce\x11\x83\x20\xe9\x4f\x08\x94\xc2\xe4\x78\x6f\xb2\x21\xd9\x62\xb0\xe4\x08\xbc\x26\x9d\x4f\xcf\xce\xf1\x1a\x0d\x46\x50\xf4\x8c\x46\xd9\x63\x04\x81\x95\x77\x3a\x3d\x1e\x7b\x6d\xd0\x23\x20\x19\x98\x8c\x80\x1b\xf0\x56\xc5\x65\x57\x71\x17\x6f\x14\x68\x60\x69\x10\xd0\x2d\xa6\xa5\x2b\x91\xeb\x91\x22\xf0\xfe\xd4\x88\x15\xa7\x38\x9d\x59\x71\xa8\xe7\x02\x75\x93\xe7\x86\x5c\x20\xe7\xdb\x61\x55\xce\x03\x73\xe6\x2e\xd9\xfe\x58\x45\x05\xce\x9a\x3d\xea\x54\x37\x72\xad\x2d\x4e\x78\xf7\x73\xec\x5a\xbf\xfa\x9e\xdd\x2b\xff\xb0\x3d\xbf\x67\xf0\xd4\x49\x63\x6e\x19\x78\xcb\xc5\x67\x7b\xd6\x9c\x6f\x73\xe8\xd8\x89\x07\x66\xef\xf2\x39\x1e\x9d\x3f\xe3\x45\x25\xff\xa9\x72\xf6\x61\x5f\xf5\xa8\x75\x20\x4d\x52\xab\x55\x7a\x8e\xc3\x2a\x6c\x34\x78\x74\xdd\x75\x83\x74\xbc\x4e\xc2\xbc\xda\x26\x76\x14\xfb\x8a\xbc\xc8\xb6\x6f\x30\xdd\xbf\xc1\x8d\xa4\x50\x3f\x75\xfc\x92\x31\x3d\xb0\x85\x25\x78\x15\xc6\x89\x78\x35\xae\x22\xe1\x44\xb2\x18\x28\xe6\xd0\xa5\x57\x04\xfd\x3f\x2f\x72\x1b\x46\xd5\xd5\x19\xe2\x69\xce\x63\x51\x9a\x03\xf4\x04\x01\x3d\xb1\x1f\xc0\x06\x20\x27\x87\xc2\xe1\x03\x96\x44\x24\xc7\x28\x8a\x12\x37\xf7\x06\xe3\x03\x15\x01\xaf\x46\xaf\xd7\x72\x66\xb3\xc5\x62\x05\x74\x93\xb4\x5a\x9b\x46\xcf\x01\x92\xd5\x04\x39\xce\xa2\xb5\x88\x88\x8f\x44\x57\x2b\x76\x4c\xa0\xaf\xd4\x3b\x33\xba\xc8\x0a\x3e\x01\x8b\x2a\xf0\x60\x2f\xc5\x1e\xec\xa5\x17\x05\x66\xef\x1a\x9c\xb9\x70\xd3\x33\xb8\xc5\x95\xdc\xe9\x49\xf8\x75\xf2\x2c\x79\xcc\xd2\x3d\x81\x9c\x03\xf8\x3f\x45\x61\x9c\x49\x56\xb7\x5f\x6d\x0f\x59\xb8\x41\x3a\x7b\xe8\x04\x5b\x3b\x03\xf0\xd6\x2e\x00\x93\x0d\xe5\x07\x9c\x18\x84\x2f\x9b\xd5\x6a\x77\xd8\x2c\x66\x3c\x34\x68\xe6\x25\xdd\xd0\xa0\x14\x17\x0d\x1d\x09\x28\x56\xee\x76\x7c\xbc\x06\xd7\x5f\x7a\x33\xb1\xdd\xcb\x37\x79\xaf\x45\xd6\xc8\x6d\x77\xf8\x5a\xa9\x0d\xde\x96\x15\x6d\x12\x3b\x70\x57\xc9\x25\xa1\x8a\xdc\x4e\xde\x27\x6f\xdf\xae\x95\xfe\x94\xa7\x61\xeb\x27\xf8\xcf\x68\xfc\x5f\xe3\x58\xc7\x06\xb1\xa3\xff\x3b\xf6\x50\x06\x76\x74\xb3\xd8\xc3\x46\x61\xe7\xff\x3f\x62\x0f\x6f\xa2\xe3\x34\x88\x01\xa4\xe5\x0f\x28\xff\x60\xfb\x97\x1f\x70\xf0\x3a\x8d\xc1\xa0\xb1\x59\x41\x6f\x54\x23\xbd\x86\x47\xd2\xd0\x20\xb2\xc6\x2a\x21\x2b\x45\x4f\xa3\x5e\xe4\x4c\xe4\x64\x62\x05\xa6\x1e\x6f\xd8\xc0\xe1\x56\x9d\xd7\xe6\x56\x07\x3b\x77\x0a\xb6\x0a\xd5\x61\x3f\x0e\x62\x11\xe7\x91\xf4\xf6\xd3\x36\xda\x7c\x09\x7f\xe4\x0e\x58\xc8\x2f\x08\xcd\xe5\x56\x5e\xff\x7b\xfd\x8a\xb6\x14\x96\x48\xbc\x21\xd0\xdd\xc6\x3c\xa3\x55\x8c\x57\xbd\xcd\x78\x55\x61\x20\x01\x24\x48\xb5\x5a\x92\x44\x4e\x61\x56\x6a\xf1\xe6\xcc\x8a\x2d\x52\xd4\xcd\x37\xba\x54\x7e\x33\xff\x41\xdd\x73\xc0\xad\xda\xe2\xac\xe7\xea\x99\xd5\xf5\xa7\x43\xc3\xd9\x1d\x51\x64\xfd\x2d\x28\x33\x60\x31\x23\x93\xc9\x06\xc7\x4d\x00\x12\xaf\x37\xa9\x58\xcc\x2b\xc3\x59\x4a\x0b\x23\x25\x8d\xd9\x85\x45\xbd\x57\x65\x09\xdb\x8d\xf6\x2f\xd5\xbc\x72\x18\x27\x0e\x1a\xfd\x9f\x51\x30\xd2\x37\x9e\xf4\x2b\x57\xf1\x31\xd2\x67\xc3\x0a\x2f\xf7\x20\xdd\x1d\x8c\x82\xac\xf6\x36\x9d\x4f\x8b\x80\x53\xa5\x05\x2a\xcd\xd3\xdc\x50\x3a\x35\x4d\x3a\xcc\x23\xbe\xb6\x3e\xee\xb3\x3c\xba\xd4\xfe\xb2\xe8\x41\xae\xff\x09\xfe\xb2\xeb\xca\xae\x5f\x60\x0e\x9b\x85\x91\xf4\x97\xed\x3d\xed\x9f\xd6\x6f\x86\xfe\x8d\xa8\x6d\x20\x59\x16\x0c\x70\x1a\xb5\x2a\x10\xae\xe1\x20\x9b\x0c\x1e\x3a\x8a\xb6\xe1\x30\x6c\x9c\xf2\x68\x04\x50\x3c\xd5\x88\xff\xf1\x45\x06\x1c\x70\xbe\x7e\xc8\xeb\x2b\x43\x77\xe0\xc7\x80\x57\xd2\x6a\x60\x0f\x33\x3a\xe5\x40\x6d\x02\x29\x7a\xab\x55\xa3\x32\xf0\x2a\xde\xe9\xd2\x5b\xe8\x0a\x5a\xb5\x2c\x7a\x97\x57\x59\x6b\x83\xaa\x7f\x63\xeb\xca\x76\xa5\x0a\x2c\xd0\x88\x89\x55\xe6\x58\x98\x28\xb7\x18\x23\x9c\xbe\x2a\xfc\x38\x59\x1f\x46\x5c\x16\xae\x5a\xb4\xb4\xb2\xf7\xc2\x15\x7c\xa7\xcf\x5e\xbe\xed\xd5\xb1\x20\x5a\x11\x4c\x86\xde\x3a\x9e\x4c\x1e\xc7\xe2\x49\x7a\x03\x3c\xb7\xb1\x18\x66\x2b\x72\xd2\x18\x4f\xe0\x71\x1a\x20\x45\x76\x8d\x4d\x93\xe0\xe2\x8c\xc3\x80\x16\x99\x90\xc6\x04\xc2\xb5\xc6\xe2\x88\x50\xa4\x86\x00\xd5\xbb\x62\x5b\x99\xf4\xc9\xaa\xfa\xd6\x87\xad\x02\x0b\xef\xfd\x4f\xf1\xc9\xaf\xae\x9d\x25\x57\xf1\xf7\xb5\x03\x8b\x5a\x0d\x1e\xc0\x55\xfc\xf3\x0f\x95\x40\x3f\x79\xe1\x95\x2f\xf0\x96\xd1\xe3\xc8\xc8\x1a\x72\x1a\xa0\xe0\x18\xbf\xde\xcc\xf6\xdc\x02\x12\x57\x82\xca\x64\x12\x75\xc0\xb4\xad\x36\x95\xb1\x26\xa8\x52\x99\x24\x5e\x04\xfa\x28\x5a\x62\x1a\x7b\x63\x67\x70\x65\x45\xa8\xf0\x2b\x16\x7a\x61\xec\x54\x61\xf3\xd2\x7f\x9e\x20\x76\x9c\x75\xee\x3a\x76\x90\x33\xe4\xca\x93\xfb\xb0\x11\x3f\xb2\xe8\xc8\x18\x80\xe0\xcf\x0f\x5f\x3f\x44\xee\x04\x5c\x28\x83\x73\xbd\x90\xe9\x60\xa3\x03\xad\x38\x97\x8b\xfa\x86\xe8\x55\x16\xbd\xc5\x9d\x80\x41\x05\xc3\xd8\xae\x35\xd9\x6b\x82\x26\x6b\xaa\x95\x43\x56\x93\x75\x83\xf5\x5d\xab\xa0\xb5\xc2\x3b\xa3\x0c\x5c\x53\x96\xb5\x5a\x01\xf6\x4d\x40\xf5\x3c\x12\xd4\x30\x45\x01\x8d\xdf\x3c\x26\x1d\x17\x44\x1c\x22\xb8\x68\x56\x97\x54\xe6\x81\xc3\x67\x28\xe4\xe1\x0d\xbc\x3a\xed\xa7\x1e\xd3\x93\xc8\xd5\x56\x75\xcf\x73\xa5\xe4\x2c\xa8\x63\x4b\x56\x60\x73\xaf\x9d\x73\xef\x34\x73\xa5\x97\x70\xbf\x99\xe3\xda\x1f\x7b\x35\xd4\x9b\xec\x26\x9b\xf1\xee\xc2\x6b\xcf\xed\x61\x72\x18\xad\xf3\xbf\x11\xe6\x60\x41\xc9\xa0\x63\x64\x25\xe8\x10\xb2\x5a\x0c\x06\xa3\x55\x32\x4a\xa9\x29\x26\xde\x68\xb1\xe8\x87\x05\x2d\x96\x44\x5e\x9d\x38\x2c\xa8\xb6\xf2\x8e\x61\x41\x5e\x68\x88\x63\x71\x11\x91\x51\x26\x43\x61\x75\x2b\x97\x7a\x34\x5a\x88\x57\x54\x0d\xd1\x44\x4d\xe7\xa0\xab\xd2\x3d\xde\x66\x3a\xb6\xfb\xc0\x89\x63\x87\xf6\x1c\xd5\x0d\xff\xe6\x1b\x6e\x74\xc7\x2e\xdd\xda\x57\x74\xea\xdc\x89\x26\x03\xc2\xd9\x00\xe6\x2e\xb2\x97\x6c\xc4\x01\xec\x0d\xed\x87\x55\x7f\x65\x30\x56\x5f\xfa\x8e\xd4\x91\xeb\xbf\xff\x0e\x70\xe3\x08\x3d\xa1\x39\x2f\xbb\x04\xd2\xf5\xb0\x9e\xc8\xac\xd1\xa8\xd5\x4e\x84\x0c\x02\x36\xe9\x4c\x3a\x58\x79\x13\x50\x7a\xd0\x42\x64\x5e\xaf\x89\x88\x5f\xf1\x01\x8f\x4c\xf2\xca\x8f\x00\xad\x44\xda\xb3\x70\xb5\x1c\x66\x8b\xc6\x56\x9b\x12\x24\x8d\xf1\xe0\x65\xf7\x60\x09\x24\x83\x9f\xc8\xd9\x3d\xe4\xbc\xaf\xee\x99\xdd\xab\x16\x70\x15\x59\x2f\xaf\x3e\xf6\x0e\x70\x76\x3e\x14\xe2\x1f\x7b\x05\xcf\x09\x52\xfa\x3a\x0e\xd6\xf3\x01\x66\x6b\x54\x72\x2d\x80\x4e\x2a\x2c\x16\xcf\xc3\x59\xf1\xa1\x5e\x81\x6c\x8f\x0d\x19\x0c\x19\x5e\x51\xb4\xd9\x32\xd2\xbd\x5a\x2d\x5f\x09\xea\x1b\x36\xd2\x32\xc0\x6e\xb7\xa7\x3a\xe8\xc6\x66\x55\x65\xd0\xec\xb8\x59\x6a\x17\x73\xa4\xd8\xa7\xa2\x30\xb1\x18\xc2\xa8\xf3\x15\x0f\x0b\x6d\x8b\xde\x51\x94\x14\xd3\x5a\xef\x06\x4e\x6e\x8b\xf9\x81\x63\xa6\xff\x32\x79\xea\x82\x29\x7b\x7e\xbc\x4c\xfe\x20\x7f\x91\xbf\xc2\x68\x16\xf9\xe4\xed\x37\x7e\x26\x2f\xaf\xaf\xce\x16\x9a\x7f\x84\x7f\x7f\x64\x37\xd9\xbf\xfd\xf1\x9d\xdc\xb3\xb0\xb6\x7f\x87\xc9\x6f\xb8\x13\xee\x86\x79\xdc\xfe\xc5\xcc\x6c\xdb\x15\x57\xbb\x8a\xf1\x3b\x17\x6d\xd9\xc6\xce\x3d\xe5\xa1\x93\x58\xbc\x8f\x13\xa5\xa2\xca\x40\xb6\x55\x2d\x1a\x39\x2e\x29\x49\x9f\x40\x05\x77\x7d\x9a\x57\x4c\x70\x26\x38\xab\x82\x09\x09\x46\x83\xc1\x55\x15\x34\x18\xf5\xc6\xaa\xa0\xde\xde\x98\x24\x35\x88\x35\x8d\xd9\x57\x70\x2a\x75\x91\xb6\x47\x4b\x7c\xc7\x04\xc1\x84\xc8\x3b\x1f\x37\x0f\x9f\x59\x3c\xfd\xf6\x3b\x7e\xfe\x34\x74\x19\xbb\x5f\x5c\x3e\x61\xda\xea\x67\x76\xcf\x1b\x39\x74\x9a\xd0\x92\xfc\x32\x64\xbe\x5d\x36\x2d\x9d\xb0\x75\xb3\xd0\xb2\x6e\x66\x87\xca\x5b\x3a\xe2\x67\x48\x5d\xcb\xae\x1d\xda\x2a\x74\xfb\x37\x80\xbd\x09\xc0\x1e\xc9\x99\x21\xb0\x94\x45\x95\x41\x6a\xd6\xbd\x59\xce\x8c\x26\xa1\x2f\xc9\x65\xa1\xe5\x91\xba\xe5\x82\x52\x8f\xd1\x00\xfa\xca\x36\x78\x4f\x85\x85\x2e\x01\x37\xaf\xc6\x3a\x83\x60\x36\x99\x04\x9d\x5a\x90\x64\xd9\x66\xd5\xe1\xca\xa0\xce\x68\x96\x40\x4d\x09\xa8\x81\x3a\x8b\xb0\x8f\xa2\xbd\x9e\x07\x44\xe5\x8b\x06\x76\x15\x1f\x27\x7b\x45\x45\x61\xa1\x76\x03\x78\xc7\xfd\xf3\x64\x87\x91\xb8\x2f\x51\xff\xbe\xb0\xcb\x98\x7c\x6e\xe7\xc6\xdf\x81\xa1\x87\x5f\x3a\x02\xca\x4a\xbf\x29\xf8\x31\x3c\xbc\x6e\x79\xe8\x71\xbc\x89\xf1\xf2\x11\x80\x5b\x63\x19\xae\x75\x61\x73\xa4\x7c\xe2\x14\xc0\xe8\x45\x77\x06\x2a\x13\x12\x13\xdd\xe6\xd4\x54\xaf\xc4\xf3\x06\x83\xd7\x2b\x7a\x3c\x6e\xad\xc6\x66\xd7\xd8\xd3\xdc\x6e\x9f\x20\x26\x48\x89\xbc\xc4\x1b\x52\x60\x33\xab\x82\xe6\xde\x86\x1a\xc3\x17\x86\x9f\x0d\x42\xb9\x81\xbe\x5d\x64\x58\x6f\x38\x6a\x38\x6d\x90\x0d\x06\xc1\x66\xd4\x18\xbd\x1e\x1a\xcf\x15\x29\x5c\x98\x3f\x78\x6a\x63\xf5\xc5\xec\xcf\xb7\xc4\x78\xdb\x8d\xfa\x0b\x2d\x5e\xca\xfb\x30\x53\x5f\x9c\xd4\xf1\xdd\x5c\x5c\x8e\x99\xf2\x82\x99\xe9\x04\xce\x5a\xc8\xed\x31\xbc\xf2\x27\xe6\x5c\x1d\xec\xab\xae\xf5\xeb\x3a\xe4\xc3\x21\x5d\xfb\x5d\x5b\x65\xef\x64\xc7\xdc\x9f\xaf\x18\x3c\xee\x0f\xf1\x39\x93\x48\xcc\x5c\x85\x65\xa4\x1f\x77\xff\xf1\xa4\x80\x0f\x93\x8e\xc2\xc9\x1f\xc9\xb3\xc5\x23\x4c\xa1\x17\xf1\xcf\xa2\x89\x64\xd2\x35\x18\x06\x6b\xd2\x49\xe8\x05\x92\xd8\xc2\x40\x85\xc3\xe9\xe4\x52\x93\x74\x49\x40\x0d\xb2\x79\x4e\x9d\xce\xa5\x67\x65\x1b\x1d\x29\x0e\x4e\xcd\x3b\x1c\x56\xbd\xdb\x5a\x15\x4c\xd5\x23\xde\xc4\x0f\xe5\x9f\xe1\x5f\xe6\x45\x35\x35\xeb\x4b\x7a\x1d\xe0\xac\x5e\x72\x9b\x90\x54\xa9\x04\x1d\xc6\xb8\x46\x34\xf0\xb5\x2c\x3e\x08\xf6\xe6\xca\x4c\x2a\x1f\x2b\xe7\xe8\x2b\x8a\xdc\xbf\x35\xa8\xe0\xcd\xae\xd5\xb9\x1e\x64\x42\xbf\x5f\xcc\xb7\x0f\x1d\x35\x73\xcb\x4b\xfb\x36\x8f\x1b\x32\x61\x96\xea\x47\x77\xe8\xbd\xd3\xd7\x16\xce\x5f\x7c\x3f\xf9\xdd\x86\x0b\x9b\x74\x1b\xd8\x3b\xd0\xb7\xc7\xde\xce\x3d\x5b\x77\xe8\x5e\xe1\xb8\xe7\xfe\x07\x16\x0d\x5b\xea\xe6\x0c\xeb\xc7\xdc\xff\x04\xaa\x97\x6d\x61\xdf\x8d\xb4\x72\xa6\xa8\x52\xc9\xb2\x51\x8f\x40\x97\x36\x9b\x74\x82\x5e\xb6\x8b\xac\x54\x30\x2d\xf0\x1d\x4b\xb2\x54\x1f\xa4\x25\x45\x14\x17\x2a\x61\x9a\xf1\x06\x83\x84\x1f\xc7\x49\xa4\xce\x20\x91\xe1\xe4\x43\x38\x57\xe9\xcd\xde\xca\xe2\xae\x5f\x3f\xc1\x25\x16\x6c\xf4\x84\x44\xa1\x65\x4c\xd6\x7e\x15\xf4\x97\x6f\xa9\xcf\x3b\xd3\x5f\xa8\x35\xc4\xe4\xcc\xc2\xc8\x96\x6c\x94\x1a\xe9\x2e\x6b\x00\x36\x33\xea\x17\x28\xd0\x80\xea\x02\x34\x19\xce\x8b\x4e\x4b\xd3\x5c\x81\xea\x62\xe4\x8c\x95\xc1\xde\x5c\x0d\xf7\x05\xf7\x33\x27\x2c\xe2\xd6\x73\x47\xb9\xd3\x9c\xc0\x71\x66\xad\x5d\x8a\x02\x9e\x1f\x61\x89\x65\xf5\x91\x48\x91\x15\x57\x94\x19\x6a\x75\xe3\xe9\x4c\x40\xaf\xa0\xba\x8c\x7b\xd8\xc4\x4e\x3b\x70\xf2\x0f\x45\x9d\xf1\x7c\xd0\x1f\x3e\xef\xd5\x99\x1e\x66\xd2\xb1\x62\x1a\x16\xc9\xb2\x5b\xfc\xa1\x93\xf8\x4c\x02\xe9\x40\xe1\xb3\x00\xbe\xd0\xb5\xb3\x82\x6c\xee\xe2\xcc\xc8\x6a\xb6\x6a\xe0\x98\x98\x81\x36\x98\x8d\xb2\xbe\x92\x7a\x86\x30\x0a\x11\x75\x5f\xb1\xd4\xe7\x27\xf1\x69\xb0\xe2\x95\xa4\x28\x32\x00\x09\x9f\xf3\x47\x51\x79\x97\x49\x83\xd3\x6b\x9c\x09\x79\xa5\xad\x5a\x75\xe4\xae\xf3\x0b\xc8\x1c\xf2\xe1\xfd\x1d\x54\xe2\x51\xf5\x18\xdc\x1c\xff\x76\xfd\x04\x1d\x97\xe9\x2f\xec\xde\xa3\x63\x20\x95\xc6\x72\x62\x10\xbe\x25\xb3\x4a\x14\x25\xb3\xe4\x74\xd8\x39\x4e\x2b\x19\x55\xb2\xd1\x02\xea\x83\x5d\x89\x6e\xaf\x77\x92\x6a\x18\x60\xd2\xf0\x26\xc4\xe1\x2c\x29\x8e\xdd\x84\xbc\xfd\xca\x15\xd3\x3b\xb8\xf3\x9d\x09\x89\x5a\xab\x73\x15\x6e\xf7\x8e\x85\xbf\x7b\xf3\xa8\x10\x10\xf1\xd0\xc5\x41\x5f\x76\xbb\x67\x08\x97\x04\x5b\xbb\x91\x5d\x84\xd4\xe3\x91\x16\x95\x05\x92\xa9\x4f\x8f\x06\xf4\x61\x2c\xc1\x81\xa0\x41\x7f\x8b\xd4\xeb\x69\x51\x21\x09\xdb\xe5\xfa\x7d\x51\x88\x5a\x3c\x49\x8b\x33\x5f\x09\x1d\xc8\x65\x32\x9f\x00\xad\xc6\x2b\x84\x96\xd7\x4f\xe0\xd3\xa4\x05\x6c\x43\x5f\xfc\x64\x5c\x4c\x06\xa3\x5f\xd5\x0d\xc6\x67\x3a\x1a\x8c\x0c\xfa\xad\x5a\x25\x0b\x34\xea\x4b\x52\x2e\x81\xe2\x75\x34\xdc\x68\x14\x3a\x02\xbf\x80\x11\x6c\xe8\x9b\xfa\x84\x4e\x10\x40\xef\x41\x7d\x6e\xbc\x03\xa4\xbe\xb5\x30\xd6\x10\x36\x56\xb3\x80\x83\x13\x04\x51\x16\x0d\xb2\x28\xaa\x55\x82\x9d\x97\x91\x5c\x19\x73\x58\x8f\x2a\xaf\x79\x91\x82\x18\x56\xc5\x45\xd4\x3b\x89\xbf\x0a\xba\xe1\x65\x72\x2f\xe3\x12\xfc\x02\x6a\xd3\x86\x31\x1f\x65\xb1\xc5\xb7\x32\x7e\xd9\x02\x3e\x6f\x11\x69\xce\x4d\x17\x4a\xa1\xfc\x32\xc9\xec\x72\x19\xa8\xdc\x97\x90\x60\x43\x5a\x9b\xd6\x9b\x6a\x44\x89\x82\x41\x00\x0a\x6c\x30\x25\x81\x44\x5f\x15\x74\xaa\x1c\x72\x7c\x3c\x51\x3d\x08\x71\x7b\xee\x8f\xc5\x0a\x82\x92\x64\x35\xb3\x04\x57\x25\xf0\x9f\x4a\x86\x2b\xea\x01\x9d\x65\x6e\x8b\x71\xea\x94\xc9\x33\xc6\x7f\xf1\xc9\x1f\xd7\xce\x9d\x3e\xfb\xfb\x1f\x9f\x7c\x31\x61\xfa\xe4\x29\x5c\xf2\x96\xe3\x89\xdc\x6f\xc9\x87\xaf\x6f\xc1\xf7\xdb\x70\xe6\xb5\x5f\xb1\xcf\x89\x97\x92\xdb\x9c\xe4\xfc\x6f\xd7\xc8\x39\x1b\x19\xcd\xbf\xbe\xf5\xa5\xa4\x90\x3e\xf1\x55\xba\x6e\x2d\xa8\x6c\xcd\xe6\x34\x88\xad\xdb\x1d\xc0\x07\x0f\x32\x1c\x29\x0e\xe8\x34\x6a\xa6\x5f\x81\x1e\xab\xa3\x51\x8d\x01\xad\x88\x8d\x54\xfb\x81\xd5\xb3\xc7\x94\xac\xf2\xc6\x4a\x56\x54\x5f\xf4\x99\xef\x00\xcc\x18\x89\xdd\x1b\x7f\x07\x9e\xbd\x9c\xee\x9d\xc2\xda\xa2\x7e\x06\x14\x17\x2c\xa8\x69\xc0\xa1\x95\x65\x95\xca\x86\x2c\x16\xab\xcd\xc0\x57\x07\x0d\x06\x75\x14\x07\xcb\xa2\xe1\x93\x96\x7a\x92\x46\xe5\x61\x36\x84\xac\x04\x9f\xe2\x95\xdb\x5a\x8e\x1e\x41\xcb\x28\xde\x72\xff\xe6\x8d\x3b\x00\x03\x6f\xdb\x62\x4a\xc2\xbf\x00\x42\x6e\x4f\x2e\x7d\xe4\x3e\x7c\x10\xc6\x63\x3a\x0d\x9b\x57\x51\x20\x01\x66\x85\x54\x2a\x2d\xad\xa1\xcd\x34\x47\x36\xa9\xaa\xf8\x49\xc5\xe9\xc1\x0a\x8f\x8b\x57\xe6\x7a\x7f\xf6\xf6\x67\xef\x7c\x06\x73\x9a\xcf\xaf\xa0\xbf\xff\x1f\x67\x7f\x02\x18\x55\x91\xfd\x8f\xa3\xb7\xee\xd6\x7b\xdf\xbe\xb7\xfb\xf6\x9e\x4e\x3a\x9d\x4e\x67\x21\xe9\x24\x9d\x85\x24\x90\x34\xfb\x1e\x92\xb0\x36\x5b\x12\x44\x40\x16\x05\x11\x51\x76\x45\x50\x14\x05\x77\x41\x44\x60\x40\x05\x37\x40\x54\xc6\x05\x57\xc0\x0d\x57\x1c\x45\x9d\x41\xbf\xa3\xa2\xb8\x01\xe3\x36\x40\x17\xaf\xaa\xee\xed\x2d\x01\x7f\xf3\xfe\x93\x31\xe9\x0e\xe9\x5b\xa7\x4e\x9d\x3a\x75\x4e\x9d\x73\x3e\x07\xef\x78\x3c\xa7\xe1\x88\x77\xaf\x11\x3d\xdd\x37\x2a\x9a\x4d\xa9\x51\x4c\xd8\x79\xc4\x0c\x34\xe1\xc1\x0c\x99\xa3\xa5\x1c\xc8\xb4\x01\x2f\xe4\x41\x2a\xc3\xf6\xfb\x38\x35\xf0\xb9\x45\xf1\xa7\x08\x43\x69\x4a\x8b\xb1\x6f\xd0\xd8\xf8\x6e\x18\xf9\x90\x22\x63\x34\x99\xf4\x1a\x46\xe3\xb0\x1b\x65\x5c\x58\x68\x42\xb6\x73\x73\x4c\x8f\x54\x5e\x4b\x4c\xd3\xc5\x60\x4b\x69\x5d\x52\x82\xa7\x18\x68\xc8\x85\x74\x25\x8d\x34\xfa\xd0\x0f\xdf\x9d\xfa\x0a\xb6\xc0\x5f\xe8\xe2\xb1\x8b\xaf\xba\x6c\x55\x8c\x5e\x75\xd7\xb6\x2d\x8f\x33\x8b\xf7\xc3\xa1\x30\x34\x78\xd4\x90\x5e\x64\x4f\x24\xf4\x5e\xd2\x77\xb4\x39\x18\x41\xd0\xe8\x0d\x06\x8d\x43\xe3\x72\xea\xd1\x91\xac\xd7\x1b\x64\xad\xa0\x31\xb4\xc4\x6c\x98\x92\x64\x38\xa3\x38\xd3\x68\x4c\x27\x25\x92\x22\x84\xd4\xcb\xac\xfe\xf0\xc0\xe1\x37\xe1\xd1\xd3\x39\x93\x5b\x87\x4d\xf5\xd3\x16\xc0\xd1\x37\x6e\xd8\xf6\x37\xb4\x39\xe1\x30\x98\xdf\x38\x7e\x44\x23\x0c\x61\x7d\xa1\xc4\x7f\xb1\xff\xb8\x40\xa5\x09\xf9\x8f\x02\x83\xa9\x61\x34\xb2\x4d\xa5\x46\x21\x26\xc1\x95\xae\xfe\x63\x92\x21\x69\xec\xd8\xf0\x9f\x13\x67\xfe\x2f\xfe\x33\x32\x53\x97\x2f\x9c\xb7\xea\x05\x7a\xd5\xfa\x07\x37\x3f\x81\x86\x47\xbc\x68\x1a\x31\x38\x4a\xe4\x01\xfb\x06\xc3\x48\x4e\xc5\xfc\x68\x3f\xbd\x46\xe3\xb0\x88\xa2\x0e\x20\xb6\x64\xfb\x94\x68\xbe\xc5\xa4\x8b\x82\x66\x80\xbc\x1d\x0b\x68\x07\xbb\xc0\xcb\xe0\x4b\x70\x12\x68\x74\xb8\xa1\x32\xab\x43\x06\xa6\x4e\xc7\xda\xdc\x48\x41\xba\xed\x36\x74\x54\xd9\x2c\x5d\x0d\x6d\x25\xa2\x89\xaf\x5e\x13\x96\x4a\x6d\x52\x57\x5b\x95\xdb\x56\x35\xec\x9f\x0e\x16\x8a\xd3\x32\xa6\x12\xa0\xd0\xcb\x2e\xd3\xc0\xb7\x41\x95\x66\xfa\xd4\x0c\xc0\xd0\xdf\x6f\xf8\x70\x39\x98\x6e\x9a\x72\xe9\xf5\xf7\xee\xbf\x75\x49\x06\x58\x68\xfb\xe3\x09\x7c\x9d\xed\x68\x6e\xd8\xaf\x1c\x8e\x3c\x05\x13\x00\x2e\x64\x92\x58\x2c\xd9\x2e\x8d\x26\x27\x5b\x14\x2c\x32\x65\x46\x7a\x82\xb2\xb3\x7a\x5c\x46\x69\x67\xbd\xcd\x31\xd6\x72\x61\xc7\x32\xb1\xe2\x09\xcf\x32\xd2\x90\x74\x2d\xf3\x43\xc4\xb5\x04\xa9\x24\x27\x1e\x54\xaf\x74\xbc\xba\xe9\xb1\x43\x2f\xef\x7d\xf8\x80\x71\xc5\xc9\x93\x60\x56\xe3\xb0\x61\x0d\xf5\x83\x87\xf7\xa1\x6f\xfb\xfc\x1b\xe4\xcd\xff\x09\x7f\x83\x9f\x9f\xf9\x1e\x1f\x46\xf1\xff\x7b\x69\xd7\x53\x2f\xbc\xb2\x6b\x1f\xc9\x1f\x55\x75\x8e\x89\xb2\xe1\xf8\x89\x48\xf3\x36\xa3\xd1\x60\xa0\x78\x9c\xfa\x81\x64\xa3\x25\x86\x71\x59\x75\xc8\xa5\xd1\x09\xc6\xe4\x81\xd4\x25\x05\x8b\xd0\x88\x6f\xeb\x48\x1e\x53\x04\x6b\x22\x6b\x20\x57\x46\xde\x24\x7d\x09\x3c\x09\x0f\x83\xde\x57\x2e\xf8\xcf\x09\xf0\x13\xfc\x96\x3e\x78\xf8\xc5\x7f\x80\xa7\xe0\x30\xf0\x89\x67\xe3\xd5\x1b\x36\x22\x8d\xf4\x14\xf8\xf4\xde\xbb\x13\xb6\x3d\xb7\x47\xca\xc7\xb6\xbd\xc8\x53\x7d\x76\x53\x94\xf6\x29\x3a\x57\xc4\x51\xa9\xe4\xbf\x6f\x4a\xfe\x3b\xbe\x99\x71\x44\x4d\x0c\x9d\x85\x61\x8f\x28\x7f\x36\x93\x19\x37\xd7\xa3\xb3\xa8\x19\x9d\x45\xf8\x4e\xbf\x07\xed\x14\x34\x9a\x60\xd0\xe2\x76\x08\x82\xcd\x6a\xb1\x14\x16\xb8\x25\xab\x84\x0e\x1f\x6b\x96\xdf\x6f\x68\x8d\x51\x7e\x8b\x3f\xc7\x3f\xc7\xbf\xdc\x8f\x4c\x62\xab\xdf\xea\x47\x8b\x85\xfe\xcf\x8e\x48\xa6\x9f\x2b\xd5\x0c\x09\xc7\x34\x92\xd6\x8a\x3e\xa2\xe2\x2a\xa8\x50\x7b\xb9\xa1\x2a\x07\x4e\x32\x4e\x42\x99\xe0\xae\x72\xe8\x08\x45\x5f\x36\x4d\x02\xd0\xc4\xc6\x33\xe5\x53\xfa\x47\x06\x57\x8e\x8c\x4d\x5d\x02\x8f\xaf\x5c\x89\x7c\xbe\x6e\xf0\x88\x96\xad\x7d\x6c\xc1\x23\x8f\xdc\x0e\xc7\xe8\x0e\xb2\xbd\x3a\xe8\x2b\x1f\x58\xfe\xe4\xea\xf8\x37\xec\xfd\x3b\x6f\xbc\x71\xe7\x9a\xd9\xd3\x17\xcf\x79\xe7\xc8\xb9\x33\x6b\x37\xe0\x73\x8a\xf8\x77\x98\x5f\xcc\xbf\xd5\xb8\xdf\x9d\xaa\x55\xca\x8b\xf9\x60\x6e\x97\xf8\xf9\x72\xc4\xbf\x69\x64\xef\x2d\x8a\x0e\x74\xb1\x4e\x8f\xc7\x60\xf0\x49\xa2\x88\x5c\xc3\x6c\x5f\x94\x69\x46\x3c\x4c\xfa\x05\x5f\x32\x27\x19\x0d\xf6\x0d\x3c\x94\xd3\x83\x1c\x76\x29\x5b\x42\x1e\x84\x24\xc9\x4e\x27\xf2\xe6\xe5\xe6\x98\xd9\xa2\xa5\x9a\x63\xda\xbf\x46\xcb\x99\x9b\xcc\x2a\x48\x08\x33\xc6\xca\x21\x00\xc3\x81\x4c\xe0\x61\x35\x57\x88\xbe\x41\xc1\x18\xbe\xee\xc3\x15\x99\xe0\xc3\x53\xa7\x6b\x40\x15\x7c\x5b\x33\xfd\x31\x05\x63\x38\x03\x7a\x78\xf1\x6d\xfb\xef\x59\xa1\xd8\x57\xd7\xa2\x39\x36\x13\x1b\x68\x34\x79\x7f\x35\xe2\xd1\x22\x92\x9b\x33\x34\xed\x3d\x96\xa1\xff\x28\x32\x54\x48\x29\x11\x76\x3d\x2e\xa4\x75\x98\x8d\x4c\x5a\x84\xbd\x73\xde\x14\x89\xaf\xff\x48\xfc\x4d\x37\x15\xa0\x86\x46\x0b\x28\x41\xf4\x78\x5c\xd9\xb2\x8c\x34\x68\x50\xe3\xf2\xb4\xc4\x5c\xc8\x24\x6d\xc1\x10\x3c\x82\x80\xf8\x23\x08\x9c\xbe\x25\xb3\x88\x53\xd9\xe3\x04\xcb\x33\xc3\x2f\x66\x94\xea\x24\xa5\x46\x53\x89\xa8\x2b\x2a\xd6\x9a\x54\xf3\x3b\x0a\xac\x75\xb3\xaf\x09\x06\xad\x59\xc5\x05\x1e\x53\x15\xed\xad\xfc\xf0\xc0\xbb\x6f\x24\x75\x3e\x32\xbb\x1b\xde\x7f\x6a\x88\x61\xa7\xb6\xfb\xcd\xeb\xe8\xe1\x70\xe8\x86\x6d\xdb\xb6\x21\x57\xba\xbc\x71\xdc\x88\x46\x5c\x73\xa6\xfa\xca\xf8\x72\x7b\x58\x34\xdf\x8c\xd4\xbc\x64\xb5\x6a\x1c\x0c\x23\xe0\x7b\xb9\x2c\xaf\x47\x67\xd6\xb5\xc4\x24\xb3\xd9\x6a\x31\x0a\x1a\x74\x10\x18\x32\x0e\xa3\x94\xc8\x2b\x49\x81\x69\xc4\x27\x68\x4d\x86\xd7\x53\xc7\x02\x53\xa5\x10\xf9\xca\xe9\xd3\xaf\x24\x0e\xa7\x55\x98\x32\xf0\x19\xcc\xc7\xa7\x03\x56\x06\x30\x44\x68\x04\xc8\xae\xa2\xc8\x9e\xf5\x51\x13\xa2\x11\x97\xd6\xe3\xb4\x58\x44\xe4\xdc\xc9\x36\x51\xcc\xc9\xf6\x58\x6d\x88\x28\xa7\x8d\x31\xa2\xfd\xca\x60\x61\xcd\x61\xe6\x30\xcb\x19\xce\xc6\xd8\x18\xe4\xb4\x88\x84\x5c\x65\x9f\x66\x56\xc9\x62\x21\x4c\x28\x2a\x72\x8f\xa4\xee\x42\xff\x85\x37\x29\xd8\x46\x76\x21\xfc\xae\x65\x02\xde\x9c\xab\x56\xa9\x9b\x93\xa9\xc3\xfb\x2f\xbe\x90\xee\x77\xef\x02\xb2\x2d\x37\xee\xb8\xf1\xc6\x1d\xb7\xce\x9e\x9e\x8c\xc7\xdc\x4c\xf6\xe3\x09\x22\x5b\x57\x4f\x51\x76\xa3\x84\x76\xe3\x40\x49\x4e\x45\xe1\x93\xfe\xe4\x9e\x84\x3f\x49\xf5\xd9\x84\x75\x1d\x90\x13\xba\x8e\xd8\xd5\xd8\xdf\xc4\xab\x86\xfd\x4d\x63\xaa\x1e\xdb\xe8\xce\xd3\x4b\xe9\xfe\x26\xb2\xb1\xfa\xa8\x76\x9c\x91\xd3\xea\x31\xa6\xa5\x16\x98\x8c\x06\x6c\x5e\xe9\x79\x5a\xc0\x10\xca\xcd\x31\x40\x85\x2f\x6c\x9e\x16\xa6\x1c\x98\x00\xf8\x11\x6e\xc2\xbe\x0b\x70\xc3\x4d\xd8\x44\x5d\xc9\x2c\x3a\x7b\x10\x4e\x27\xfa\xa3\x11\xc9\xfe\x6d\x5c\x0c\xd9\xc7\xc3\xa3\x85\xd6\x1c\xb3\x81\x2f\x2a\x32\x94\xbb\x73\x38\xc4\x4a\xa6\x94\x69\x8b\xb9\xa8\x60\x88\x2a\x35\x1a\x43\x59\xa5\xac\x45\x17\xd2\xb5\xc5\x02\x21\x6b\x12\x8f\x44\xa9\x81\xbd\x60\x15\x2c\x50\xeb\xf4\x24\x1c\xf4\x40\x36\x3d\x3a\xe9\xaa\x2c\xa9\xcb\x03\xe5\xd8\xc3\x15\x07\x18\x83\x89\xa4\x50\x83\x57\xdd\x5e\xb3\x3f\xab\xbc\x38\x92\x77\x3c\x2f\x52\x5c\x9e\x9d\x6d\xf6\xba\x57\x16\xcd\x18\xb2\x7e\xdd\xc3\x9b\xae\xeb\xe8\x58\xbe\xf9\xe1\xde\x2b\x27\x0f\x99\x51\xc4\x36\x7a\x9c\x5f\xfc\x74\x04\xc2\x05\x20\x00\xff\xb9\x00\xf0\xaf\x01\xd3\x9b\x4e\xcf\x9d\x3d\x86\xc0\x97\xe1\x3a\xb8\x15\x6e\x59\xb2\x04\x5c\x02\xc6\xe1\xb8\xe0\x4d\x43\x7a\x24\xee\x94\x16\x23\x7e\x3a\xa8\xfe\xd1\x3c\xa3\x41\xaf\x33\x49\x22\xcf\x59\x1d\x32\xf2\x50\xad\x1a\x8b\x68\x32\x68\x9c\x2e\xab\xc9\xa4\xd1\x3b\x44\x83\xc0\xeb\x89\xd0\x75\x2d\xe7\x89\xa4\x42\x10\xb8\xc2\x57\x13\x40\xee\x7a\x00\x44\xac\x68\x7b\x33\x11\x6b\xb5\x58\x19\x62\xc7\xe6\xcd\x5a\xfd\x71\x53\x8f\x61\x47\xe0\xd9\x1f\xfe\xd6\xad\xa7\x69\xf4\xf7\x5b\x67\x04\xd8\xba\xe5\x6b\x5e\x80\x37\x9d\x01\x7d\xdf\x40\x54\x9c\xfb\x70\xca\x2f\x57\x80\x59\xe7\x3e\x38\x06\xfc\xf7\x12\xbb\xf6\x3c\x54\xf2\x0c\xc8\x3e\x6e\x8e\x16\x6a\x59\xa7\x53\x02\x16\xde\x6a\x35\x5a\x8c\xde\x2c\xad\xa3\x2d\xa6\x91\x28\x09\xa7\xf4\x68\xd1\x17\xb2\xa9\x9c\x6d\x31\x8b\x44\x33\xe9\x85\x80\x89\xdd\x91\x32\xea\x12\x2d\xad\xf0\x2e\xc0\xa9\x7b\x44\xff\xe0\x84\x88\x40\x2a\x66\x72\x14\x84\xbe\xfa\xea\xf9\x93\xff\x85\x3f\xfc\x0a\x1b\x8e\x32\x0b\x6f\xb9\xf9\xd2\x99\x6b\x56\xb0\x8f\xdf\x77\xdf\xfe\x17\xdf\x7f\xf5\xd5\x7f\x31\xbf\xc4\x1f\x27\xd9\x10\x44\x57\xe6\x13\x7c\xd2\x77\x28\x11\x69\xcb\xa6\x68\x81\x96\xc5\x2e\xbf\xc0\xdb\xed\x06\xc1\xe0\xf1\x6a\xdd\x2d\x31\xad\x56\xa0\x04\x74\x08\x0b\x32\x4d\x69\x44\x4a\x44\xe6\x10\xf1\x71\xba\x20\xf5\x75\xa6\xd2\xaa\x16\x2e\xca\xb8\x00\x96\xd8\xa1\x49\x7d\x93\x0f\x68\x24\xc0\x75\xf0\xe0\x54\xf0\xcf\x3f\xbe\x81\xcb\x20\xa4\xbd\x45\xd7\x5f\x73\xd5\xca\x62\xb6\x0e\xdc\x01\x2f\xdf\xff\x1b\x7c\xf5\xc1\x9d\x48\x2d\x46\x06\xb5\x0c\x25\x38\x65\x97\x9c\x3f\xc1\x3e\xcb\x8d\x45\xe7\xe2\xd0\x68\x91\x44\x19\x44\x93\xc9\x6c\x36\x38\x79\x74\x2a\xca\xde\xb6\x98\xcc\x8a\xc6\xf6\x18\x27\xba\x5c\x22\xc7\x98\x05\xc6\x2c\xe1\xbc\x32\xad\x35\x61\x15\x90\xd6\x4c\x89\xbb\x92\x34\x73\x48\xa9\x89\x71\xd0\xfe\x64\x2c\x20\xe2\x4e\x15\xb4\xd3\xf7\x4d\x18\x37\xa5\xe6\xdd\x71\xf0\xe7\x67\x0f\x0b\x57\x1f\x3b\x76\xad\x74\x68\xcf\xca\xa7\xf2\x0f\x5b\x87\x94\xef\xa2\x1f\xfe\xea\xd7\x3f\x6a\xe1\x38\x10\x06\x41\x05\xe7\x1b\x08\xc0\xf1\xfa\x4b\x03\xa7\xe1\x7e\x59\xd4\x10\xb4\x0f\xef\x43\xe7\x78\x80\x9a\x16\xad\x65\x02\x01\xca\x2a\xda\x6c\xac\xdf\xa0\xd7\xbb\x3d\x1e\x3f\xc5\xe4\x05\x09\x70\x91\x5d\x63\xc6\x95\xc4\xb6\x5c\x9c\xbb\x29\x32\xb8\x01\x25\xed\x66\x90\xef\xe5\x66\x80\x40\x2e\x78\x08\xe5\xaa\xa2\x4c\x41\x78\xa7\x0a\x19\x92\xfe\x0f\xf9\x91\x51\x8d\x8f\x24\x44\x31\xa4\x49\xee\x35\x8d\x2c\xd2\x21\xdf\x74\xd8\x3f\x7a\xe8\x9e\xd7\x5c\x3f\xea\xfa\xf6\xec\x3f\x94\x3b\x71\x82\x6b\xea\x5f\x3b\x4c\xf7\x83\xf4\xee\xfd\xdb\x3f\xb4\xb7\x23\x55\x3f\xe8\xe8\xe9\xfd\x3b\x2d\x23\x2f\xb9\x79\xf9\xfe\xd5\xeb\x2e\xbd\x54\x78\xec\x3d\xea\xfc\x67\xb0\x9e\xe4\xa3\xaa\x38\xde\x18\x6b\xbd\x6f\xd4\x6f\xa2\x69\x23\xc3\x31\x1a\x34\x27\x2b\xaf\xd1\x48\x80\x33\x72\x1d\x31\x41\x6b\x34\x6a\xb4\x8c\x81\xd1\x48\xe4\x6a\x96\x28\x94\x54\xc2\x57\x24\x89\x71\x45\xee\x99\xf1\x61\xc4\x60\xf0\x2d\x24\x1b\x74\xc8\x0c\x98\x9c\xbe\xc7\x07\xdc\x08\x8f\x82\xe7\xc1\x58\xf0\x1c\xfc\x0c\xf6\xfb\x6d\x96\x99\x2f\x02\x5f\xc1\x6c\xfc\x1f\x8e\x75\xd3\x2f\x81\xeb\x86\x67\x3f\x8c\xe8\xc1\x35\xa2\xf7\x12\x9d\x2a\x22\xa9\x08\xd2\xc8\x57\x34\x1a\x80\x81\xe1\x19\xc9\xaa\xc1\x68\xdd\x00\x5f\x7e\xe3\xcb\x46\xa3\xc9\xc8\xb0\xd8\x81\x95\x55\x9a\x6a\x95\x3a\xaa\xcc\x3c\x34\x35\x11\x8d\xa4\x02\x10\x9a\xb0\x48\x30\x91\x52\x10\xe2\x69\x6a\xe0\x2c\xf8\x3d\x58\x8b\xbc\x9e\x15\xf0\xfb\x99\x03\x0f\xf3\x9f\x17\x74\x73\x68\xc1\x78\xb8\x9d\xdc\x20\xa1\x9f\xb4\xfd\xea\x65\xed\x7e\xcc\xa7\x06\x95\x4f\x56\xca\x45\x8d\x89\x96\x20\xe7\x82\xb1\x5a\x29\x1b\x2b\x1b\x0c\x46\x2d\xbe\x9e\xa7\x38\xb7\x46\xe3\x31\xeb\x25\x46\xea\x88\xd9\x1c\x1c\x83\xd8\x08\x18\x8b\x51\x9b\x00\x59\x26\xe5\x72\x64\xc9\x09\x7d\x48\x7c\xd3\x5c\xea\xd4\x6a\x5b\x23\x88\x52\x85\x87\x01\x6b\x00\xfd\x25\x13\xd2\xf0\x0d\x47\x7e\x5c\xff\x07\x68\x3c\xd2\x51\xf6\x48\x64\xf2\x47\x73\x9f\x05\x8f\xec\xaa\xcf\xe2\x4c\x48\x42\x17\xd2\xab\xce\x3c\x9f\x60\x25\xfe\x0f\xb1\x32\xbc\x25\x30\x16\xd3\xdc\x17\xd1\xbc\x83\xdc\x37\xba\xa8\xc9\xd1\x0a\x85\x66\x85\x64\x4c\x31\x4b\x69\x28\xb7\x47\x9b\xa0\x1a\xf9\x74\x4e\x86\x93\x19\x99\xe1\x04\x20\x60\xc2\xe5\x04\xe1\x0a\x67\x2b\x92\xb4\x2b\xbc\x4d\x6c\xb9\x8a\x0c\xf2\xfd\x9d\xc8\xc7\x9c\xee\xfb\xf1\x07\xeb\x31\xfe\xc6\x47\xad\x35\x1b\xab\x47\x1c\x99\xfc\x00\xb8\xeb\xa1\xee\x36\xce\x82\x7c\xa2\x2f\xe8\x3c\x85\xd5\x89\xff\x68\xfb\xd1\x09\x39\x43\x88\x1e\x4b\xc4\xd7\x5d\x94\x17\xf3\x5c\x16\x6c\x1e\x8b\xc5\x0d\x68\xaf\xc9\xac\xd5\xe9\x4c\xb4\xdb\xc6\xf9\xb2\x18\x8a\xc5\xb1\x7d\xb7\xc5\x64\xd2\x99\xcd\xde\x8e\x98\x99\x91\x69\x9d\x22\xa7\x09\x04\x77\x95\xeb\x9d\x40\x3b\xd4\x2c\xc0\x80\xa8\x36\x65\x21\xf7\xd2\x18\x1e\x53\xc9\x08\x44\xce\x08\xfd\xc5\x0f\x86\x21\x2d\xa7\x1e\x7f\x00\x1e\x62\xce\xc0\x43\x9b\x1e\x3d\x35\x62\xf0\xf5\x8f\xc0\xdd\x74\x28\x7e\x94\x0e\x5d\x3f\x1f\xbe\x0f\x22\xef\x9f\xd6\xd2\x03\xe3\xfb\x74\xa7\xdf\x43\xde\x56\xd9\xfc\xeb\x91\x79\x5c\x8b\x68\x4f\xdc\xf1\x38\xd1\x59\x31\x32\xda\x8d\xe3\x3d\x46\x0a\xb8\xcd\x66\x97\xcd\x64\xb5\xba\x80\xc1\xc8\xf3\xde\x2c\x27\x6d\xa0\x91\xe5\x6a\x36\x18\x78\xa3\xd1\x33\x22\x66\x14\x6c\x40\xb9\x81\xcd\x24\xbd\x2b\xe5\xf8\x16\x56\xcc\xcd\x02\x01\x5c\xef\x49\xc8\xa6\xc9\x9b\x7c\x74\xf0\xfb\xe9\x23\x5f\x1c\xfe\x62\xf8\xdd\x33\xe1\x2f\xcc\xd3\xf0\xe7\x19\x77\x35\x7f\x31\x7d\xea\x9c\xc7\xe0\xa3\xe0\xbe\xef\x9f\x3c\xda\xb1\xfd\x32\x3d\xf8\x0e\x3a\xf5\xd3\xb7\x5e\x7a\xf4\xc9\xb9\xd7\xec\x06\xf9\x98\xd7\x75\x6a\xfe\x27\xae\xcb\xba\x24\x5a\x45\x67\x65\xf9\x1c\x4e\xbf\x87\x15\x25\x4d\x36\x97\x83\x3c\xd3\x9c\x6c\x89\x61\x9d\x3e\x6d\x6e\xc0\x62\xf5\xd2\x48\x3d\xf3\xd9\x34\xcd\x3a\x25\xa3\x4f\x62\xfd\x1d\x31\x96\xa1\x18\xf5\xea\x5a\x81\xf7\xcf\x64\x7a\x9a\x9c\x27\x43\xf1\x7e\x06\x6d\xc6\x24\xbb\xd1\x77\x75\x19\x6a\x70\x90\xc6\x1a\xa8\x7b\x17\x74\x7c\xcb\xe4\x9f\xd2\x2e\x5d\xfd\x6e\x7d\xe4\xad\xca\xda\x77\x43\x77\xbf\x4b\x1f\x5d\x78\x0a\x49\xfd\x67\x74\x7e\x92\xe5\xf3\x6e\x48\x2d\xc6\x9d\xf3\xe3\x07\x98\x3e\x20\xa0\xdc\xb5\xf4\xc7\xdd\x4e\x09\x8e\x61\x0e\x92\xff\x2a\x01\xc9\x3d\xc7\xe7\x88\x14\x90\xb2\xdd\x2e\x97\x2d\xdb\x07\x2c\x22\x6f\xd4\xf9\x73\xb3\x68\xbd\xcf\x26\x08\xfa\x11\xc8\x6f\x30\x22\x83\x77\x44\x4c\x14\x4c\x82\x1b\x39\x3a\xea\x75\x78\xba\xef\x4d\x66\x91\x39\xab\xe4\x8a\xf0\x64\x11\x6a\x94\x53\x47\x99\x9f\xb2\x2e\x61\x34\x21\x66\xda\x8b\xb7\xec\xf7\x2d\xda\xbf\x1f\x4c\x3e\x42\x9f\x3c\xa2\x1d\xb5\x20\xba\xff\xd6\xf6\xc5\xbf\x81\xfb\xf4\xc7\x9e\x3c\x3a\x6e\x24\xbc\x16\xa9\x6a\x27\x59\x9b\x69\xdb\x2f\x39\xfa\xe4\x31\xfd\x41\x20\x92\xfc\x6b\xd8\xc1\xde\xce\x3f\x85\x64\xea\xf6\x68\x56\x96\x7e\x40\x4d\xaf\x5e\x7d\xf3\x1b\xca\xfd\xa5\x61\x8a\xea\x26\xcb\xa5\xe5\xf9\x03\xb8\x96\xe6\xee\x75\x55\x75\xfb\x80\x21\x5a\x12\xab\x12\xc2\x40\xc7\x84\xa3\xe5\xac\xc6\xd4\x11\xeb\xeb\xcf\xcd\xf5\x63\x34\x89\xdc\xe2\xe2\x5c\x8d\x81\x95\x1a\x4a\x4b\x0b\x27\xc7\x4a\x59\x89\x6e\x8b\x49\xfb\x40\x75\xc2\x47\xa2\x70\x60\x1a\xb7\x7b\x51\x6e\x73\xf0\x2f\xdd\xff\x44\xce\xe4\xeb\x17\x12\xc1\xc4\xfe\xe1\x6c\xc8\x6f\xa2\xf1\x01\xe5\xaf\xc4\x15\x60\x6a\x09\xb2\x52\x16\x89\x13\xeb\x12\xe5\x60\x41\x29\x88\xac\xaf\x8c\xfa\x3c\x05\x06\x91\x24\xda\xd1\x1a\x33\x0d\x86\x5d\x59\x36\x75\xf6\x95\xf5\xab\xef\x61\xe0\xc9\x41\xb9\xe3\x67\x2f\xea\x75\xc7\xae\xd1\xdb\x0f\x6d\x5e\x10\xdd\xf0\xb7\xda\xda\x3b\x6e\x59\x30\xfd\xed\x21\x30\x3e\x1d\x78\x76\xbf\xbc\x66\xaa\xaf\xb5\xa1\xbd\x6e\x98\xe4\x94\x5c\xa6\x49\x0f\x3c\x79\xd3\xaa\xb5\x5b\xeb\x67\xfd\xfd\x95\xeb\x3b\x4a\xa7\x8d\xcc\xce\xcf\xde\x7a\xe7\xc4\x40\x51\xe0\x91\x35\x33\xae\xef\x27\x99\x43\x7d\xbb\x4f\x1e\xfd\xf9\xc4\xf6\xb1\x13\x7f\xa9\x07\x35\x8d\x60\x0c\x7c\xf1\x93\xc6\xda\x21\xa3\x5d\xb2\xf3\x09\xff\x9e\xe5\x8b\x76\xf8\x6d\x0f\x2d\x1f\xbf\x62\x74\x95\x49\xef\x28\x42\xfc\xde\x84\x7c\x80\xa1\xdc\xad\x54\x33\xb5\x21\xda\x58\xe7\x71\x50\x46\x77\x61\x56\x37\x4b\xb8\xac\x4c\xab\xed\x17\x88\x44\x2c\x59\x6e\x8a\x6b\x69\x0d\x1b\x4d\xbd\x07\x8d\x88\xe1\x10\x9e\xd0\x1b\x58\x98\xfe\xbd\x4d\x76\xbb\xa9\x77\x7f\xb6\xc9\xdd\xd4\x73\x44\xac\xc9\x93\x97\xef\xcf\xc7\x68\xbd\xd6\x98\x5f\xf0\xa0\x15\xf1\x44\xb3\x2c\x85\x6e\x1c\x09\x74\x27\x2f\xfc\x53\x1c\x4e\x6f\xb8\x43\xbc\xf9\xf4\x9a\xa6\x8c\xac\xcd\x08\x66\xbc\x23\xc1\x65\x64\x17\x64\xc4\xfc\x6a\x32\xd8\x9c\xe0\xb2\xac\xe4\x33\x26\x6a\x53\x95\x25\x23\x7d\xbc\xc9\x9a\x6d\xea\xbf\x68\xfd\xc2\xe1\x25\xd5\xb3\x56\xde\xb3\xb2\x69\xe0\xf0\x0e\xed\x4f\xd6\xb5\x57\xec\x39\x78\xfb\x8c\xfc\xa6\xfa\x69\x0d\xcd\xa2\x27\xdb\x33\x7e\xe6\xb5\x4b\x16\xad\xba\xb3\xe5\xb1\x87\x57\x4f\xec\x59\x5b\x3e\xa2\x65\x4c\xf5\x15\x0b\xf9\x13\xc8\x04\x09\x35\x0c\x9c\xd0\x67\xd5\x43\x37\x4c\x9a\xdf\xcf\xeb\xc8\xad\x2a\xaa\xe9\xe9\x21\x11\xc4\x61\x7d\xec\x73\xd7\x64\x81\xfe\xf0\xf0\x6b\xfd\xab\x9b\x62\xee\xd2\xfb\xb3\x57\x4d\x24\xf1\xc4\xeb\xa7\x8c\xbb\xae\xd9\x25\xd7\x57\xe6\x95\x79\x73\xbd\x6b\x57\x07\x42\xe8\xc7\xa6\x44\x8e\x37\xc6\x73\xcf\xa2\xa2\xd1\x6c\x87\xdb\x0a\x00\xc6\x0e\x76\xbb\x75\xd9\x3e\xec\x77\xa2\xa3\xd5\x6a\xb1\xd0\x4e\x51\xa7\x00\x18\xa5\xa9\x9a\x14\x10\x73\x32\x3c\x84\x55\x7b\x29\xa0\x43\x11\xab\x8f\xbe\x00\xa4\xfb\x15\x77\x76\x8c\x0f\xfd\x32\xda\x9b\x1f\xe9\x96\x09\xec\xde\xfe\x36\x38\x78\x08\x0e\xb9\x6d\x46\x69\x0a\xd9\x1d\xc2\x3f\x48\x7e\x2e\x92\x8d\xd5\x44\xaf\xf7\x88\x66\xb1\x1a\x05\xad\x4d\xd4\x68\x44\xb7\xcb\x91\x0e\xd4\x66\x4c\x0f\xac\x74\xa5\xad\x13\x4c\x5b\x32\xd7\x96\xfe\x7c\x70\x53\x10\xc3\xb4\x1d\x78\xd7\x3b\xe8\xd4\x20\x69\xcc\xa8\x7f\xed\x02\x75\x8b\xe7\xa5\x41\xb5\xd1\x5f\xff\x89\xa1\xda\x36\xdc\x46\x33\xab\x15\xcc\x5d\x35\xff\x10\xd9\x4c\x4e\x2a\x48\xb5\x46\x8b\xf2\x90\x69\x92\xe3\x70\xf0\x14\x9f\x1f\x72\x18\x7d\xc8\x8a\xce\x43\x46\x74\x7b\xcc\xe7\xf2\xb9\x74\x8c\x4e\x6e\xc3\xc9\x35\xb9\x6d\x99\xc9\x35\x0a\x4c\x09\xd5\x09\xe9\x5f\x51\xd6\x69\x0d\x2c\x82\xa4\xc1\xad\x06\x79\x8c\x56\x1e\x90\x9a\xf4\x1a\xf4\x9e\xa9\x1e\x08\x9c\x04\x8c\xc7\x05\x8f\xc3\x33\xe8\xeb\x3b\xfa\xa9\xc2\xc1\xfd\xa2\xbe\xca\x3a\xf7\xc7\xef\xe4\x96\xc2\x97\x8a\xa3\x3d\x7a\x97\x96\x94\x7a\xfe\xf1\xb6\xbf\x3b\xfd\x70\x02\x9a\x07\x7d\x6d\x02\x93\x9f\xf6\x05\x7d\x7e\x78\x3b\x18\xe4\x06\x4d\xe8\xa5\x17\x4c\x85\x2f\x67\x93\xb9\xa5\xb0\x4a\x5d\x54\x01\x35\x2e\x5a\xea\xf4\xfb\xa9\x90\x24\x71\x14\x57\x58\x24\x59\xdc\x96\xe6\x58\xc8\xed\xcf\x36\x64\x37\xc7\x9c\x06\x37\xfa\xd2\xd2\xda\x3c\x7c\x3f\x46\xcb\xcd\x31\xda\xd2\x69\x7e\x17\xee\x66\xa0\xce\xd1\xaf\x5e\x47\x53\xea\xb4\x14\x83\xbb\x5a\xe9\x4a\xaf\x20\x99\xd5\xf0\x13\x68\x1d\x04\x66\x78\xf2\x77\x08\x7f\x01\xd7\x97\x36\xd4\xf6\xaa\x08\x15\xeb\x2e\x9f\x73\xc9\x74\x73\x19\x68\x2c\x1b\xd8\xd0\x3d\xa7\xbc\x52\x3f\x67\xce\xf8\x19\x96\x02\xda\x47\x97\xc1\x2f\xe0\xaf\x2a\x14\xea\x5d\x4e\x9f\xd3\xb4\x61\xed\x82\xe5\x02\x3c\xe5\xcc\x72\x5a\xee\x5f\x73\xf5\xf5\x66\x2c\x53\x0c\x45\x71\x45\x1c\x0e\xff\x57\x45\xdd\x14\xe0\x79\x81\x16\x9c\x0c\x4d\x3b\x2c\x56\xa3\x95\x00\x25\x01\x5a\x69\x5f\x20\xa9\x25\x9a\xaa\xd9\xad\xde\x51\x17\x02\x80\x63\xb1\xd5\x35\x9d\x80\xbb\x5e\x85\x1f\xc3\x59\xa0\xf2\x71\x7f\x61\x41\xce\xd8\xfc\x75\x2b\x5b\x56\x0f\x58\xe7\x2e\xf1\x66\x85\xec\xe8\x08\x5d\xb4\xe4\xf8\xb1\x95\x60\xe6\xa6\x75\xfd\x5b\xd7\xe7\x14\xd5\x36\x61\x0c\x15\x44\x47\x2e\xe2\xb5\x8d\xaa\x56\xe8\x30\xd3\x66\x3b\xa2\x43\x46\xe3\x0b\xa2\x51\x6c\x8d\x19\x69\x0b\x90\x13\x82\x8d\x87\xbf\x20\x21\x8d\x0a\x82\x98\xa2\xe6\x35\xf4\xe7\x70\x17\x5c\x02\x0a\x5f\x14\xba\xe7\x16\x5c\xd6\xfd\xee\x55\xb3\x16\x5d\x55\x11\x2c\xa9\xb2\x23\xeb\xef\x6f\x15\x6f\x5c\x7d\x1d\xe8\xfd\xe8\x8d\xfd\x3e\xca\xea\x19\x55\xfb\x08\x70\x45\xfc\x8b\x52\x3e\x4b\xfa\x67\xd1\xef\xd3\xd9\xd4\x29\xca\xbd\x1b\x97\x68\x4d\x8d\xea\x7d\x1e\x5a\x08\xd2\x20\x57\xc1\x0b\x03\x0a\x66\x18\xa1\x1b\xe3\x8d\xb1\x41\xf5\x33\x2e\x24\x3b\xca\x67\x3a\xa2\x7a\xaf\x8b\x36\xa3\xcf\xe4\x88\xc9\xcf\xe0\x2e\x2f\x68\x1f\xef\x47\x7b\x46\x46\xf6\x4e\x37\x6a\x48\xb4\xc0\x28\xe9\xf4\xb4\x3d\xb7\xc0\xeb\xcd\x45\xe6\x23\x57\x5a\x22\xea\x85\xec\x60\x5b\x2c\x9b\x75\x15\xb5\xc5\x5c\x56\x06\x49\xdc\x64\xe5\x4e\x3a\xe5\xb5\xa9\x00\x9d\x8e\x54\x3e\x8a\x72\x0d\xad\x5c\x26\x62\x45\x8c\x33\xa4\x70\xfa\x49\x0a\xc9\xba\x42\x52\xab\xba\x31\x9c\x08\x63\xad\xeb\x1e\x71\x58\xb3\x9c\x8e\x57\x0f\x8d\xb3\xea\x65\x9b\xfe\xc0\x0b\xa1\xf9\xf0\xbf\xeb\xd7\xad\xbb\xf7\xde\xdb\xef\xb8\xe7\xf5\x8a\x48\x55\xd9\xa5\x95\xe5\x70\x8c\xf4\x8e\x18\x18\xb4\x88\x0d\xc7\xcd\xeb\x86\x7e\xf3\xcd\xd0\xb3\x7b\x3f\x7f\x81\x6d\x85\x4f\xc1\x75\xb8\xe2\x09\xed\xa6\xb1\x68\x27\x3d\xf2\xc3\xbf\xbe\xfa\x0e\x16\x7f\x9b\x98\x1f\x5a\x4b\x11\x69\xd2\x42\x6a\x78\xb4\xd8\x68\x46\xf3\x93\x7c\x79\x4e\xa7\x8f\xd6\x99\xb9\xe2\x22\xa5\x8e\xd6\x48\xe9\xe5\x10\x46\x91\x37\xe9\x05\x3c\xc5\x11\x69\x53\x4c\x58\xa1\x19\x0e\x76\x97\x39\x7a\x48\x7a\x0d\xd3\x75\x7e\x24\x4c\x42\x3f\xd1\xbb\x22\xe8\x29\x8c\x84\x3c\xe7\x5f\x5b\x7f\xd3\x2b\xbf\x97\xaf\xfe\xe4\xae\xeb\x97\xde\x75\xd7\x75\x37\xac\xdd\x1b\x29\xee\x56\x55\x55\x50\x52\x05\xc7\x98\xde\xd0\x06\xc7\xcc\x64\xc3\xe7\x3e\x67\x82\x67\xf7\x7e\xf2\x32\x73\x08\xc6\xe1\x07\xa0\x0c\xd0\x80\x01\x25\x78\x0f\x3d\xf4\xe6\x81\x9d\x8f\x1f\x78\x5b\xc1\x15\x3b\x7f\x33\xd2\x77\x2f\xa0\xb5\x0b\x52\xb5\x51\xb7\xdd\x99\x97\xe7\xcd\xc9\xa1\x7c\x06\xca\x10\xca\xcf\x75\xe7\xba\x6d\x3c\xa3\x13\xcd\x36\xdc\x4f\xe8\x70\x38\x72\x58\x75\x0d\x93\x95\x2f\x91\x24\xba\x98\x92\x52\x91\x87\xc8\xae\x51\xb6\x0e\x0b\x2c\x21\xd2\x0b\x55\xb4\x38\x48\x27\x54\x76\xe5\xee\x9d\xae\xcb\x7a\xf7\x9e\xe1\x82\x0f\xef\x79\x04\xbf\x9a\xee\x02\x13\xe0\xc7\x6d\x0d\x63\xc6\xf4\x6c\x6b\x6f\x18\x35\xb2\xb1\x83\x7e\x18\xfe\x08\x77\xd7\xd5\x0e\x18\x58\x7b\x0d\x9d\x07\x44\x30\xa4\xb6\xfb\xc0\xfe\xb5\x57\xc5\xff\x05\x0a\x96\xf4\xa8\x5f\x02\x8f\xc2\x4f\xae\xaf\xab\x5f\x41\xf0\xc7\xce\xdf\x8d\xf4\xd9\x5d\x18\x0b\x88\xaa\x8b\xba\x1d\xee\x50\xc8\x17\x08\x50\x7e\x23\x65\x2c\x2e\x92\x05\x6f\x10\x7d\x49\xbc\x8e\x91\xa8\x70\x92\xf2\x64\x2e\x4a\x1a\xf1\xb6\x04\xf1\x4a\x40\x3e\x41\x7d\x65\x3e\x21\x9f\xc0\x30\x62\xfa\x1b\x00\x3b\xf7\xe9\xc7\x1d\xe3\xba\xd7\xc6\x1c\x3b\xf6\x3d\xbb\xd7\x35\x22\x52\xde\xea\x02\x57\xc0\xcf\x0a\x4b\x6a\x47\x8f\xec\x5e\x5a\xd8\x56\x33\x6c\x68\x4d\x24\x4c\xfb\x3e\x83\x27\x4a\xcb\xea\xeb\xcb\x8a\x81\xf3\xf3\x2f\x80\xbd\x5b\x41\x59\x38\x7f\x28\x2c\x5e\xfc\x40\x61\xef\xc6\xa2\x8d\xd7\x9e\x1d\x5e\x53\x53\xb0\x85\xe8\x64\x72\x1f\xa9\xf9\x0e\xe9\x09\x1f\x35\x8c\xba\x29\x9a\x13\xec\xef\x75\x85\x7b\xf4\xa0\xaa\x87\xb9\x0c\xfd\x35\x4d\xc3\x2b\x72\x07\xa3\xd3\xa5\x2a\xbb\x08\x7d\xf5\x19\xec\x76\x21\xb3\x74\x6f\xcc\x3d\xd8\xac\xc1\xf6\x69\x4e\xcc\x3c\x18\x83\x2e\xe6\xd8\x18\x89\xb1\x81\x28\x30\xd4\xca\x83\xd9\x5e\x7d\xba\x15\xf4\x29\x68\x8b\x35\xf6\x49\x5c\x5c\x4a\x48\xf0\x0e\x46\x0e\x56\xb8\x2d\x87\x91\x35\x64\x79\x1d\x6d\x36\xcb\xc1\xce\x9a\xbc\x13\x88\x42\xbe\x82\x5c\x21\x07\x48\x1b\x5b\x1f\xed\x00\x0d\x00\x57\xc2\xca\x36\x0d\x93\x6c\x0a\x50\x51\xa3\x40\x8c\xfe\xe5\x3d\x27\xdb\x20\x0d\x58\x35\x7c\xd4\xa2\xe8\x94\xf6\x3d\x6f\x6c\x58\xb1\x3d\x32\x7e\x74\xff\xf8\x93\x0e\xd7\x8c\x6f\x8b\x1e\x27\x37\xa0\x75\xd5\x13\x63\xb1\x49\xd5\x75\x17\xbd\x00\xe5\xa7\x57\xd6\xf6\x28\x9f\x37\x6d\xe7\x3f\xa6\xe4\x94\x78\x59\x38\x25\x30\xa1\xe8\xb1\x35\x0b\x5a\xe1\xeb\xf8\x62\xf4\xf8\x2f\xef\xbf\xff\xcb\x67\xff\x8f\x2b\x51\xc4\xeb\xbe\x88\xd7\xab\xf9\x13\x54\x80\xea\x4e\xf5\xa6\xae\x8a\xf6\xd4\x19\x8d\x61\x2e\x5a\xdb\xc3\xe3\x74\xe6\x65\x67\xf7\xe8\xc9\xb1\x7d\xfa\x56\x14\xb7\xc4\x2a\x1a\x82\xe1\x5a\xf4\xa5\x6d\x68\xe8\xd9\x12\x6b\xa0\x70\x4b\x99\xd6\x98\x57\x6b\xa1\x68\x49\x46\x07\x4a\x6b\x2c\x97\x4e\x60\x54\x13\xde\xa6\x37\x9a\x51\x38\x8a\x78\xdc\xf5\x1a\x0a\xd9\x2a\x98\x2f\x55\x68\x67\xcb\x89\x4d\x9d\x9e\x6d\x86\x81\xa9\x02\xb9\x7f\xcd\x7b\x7a\xea\xd0\x49\x3b\xde\xfb\xe2\xc5\x8e\xe6\x41\xcd\x79\xbd\xeb\x2b\x06\x85\x9a\x07\xb5\xb6\xed\xff\xfc\xbd\x1d\x6d\x60\xcd\x45\xf9\x5c\xdc\x08\x22\x7f\xe2\x58\xd3\xb7\xf7\xec\x7a\x6e\x47\x4e\x75\x59\xfe\x8e\xe7\x76\xdf\xfd\x2d\x3c\x02\x7f\xfb\x2f\x7c\x97\x5b\x7a\x61\xf6\xa2\xf3\x80\xc8\x27\xbf\x00\x9d\x07\x16\x52\xf3\x72\x86\x9e\x0a\x9c\xe4\x16\x9f\xea\x59\x51\x94\x13\x04\x3d\xc8\xf1\x01\x12\x75\x79\xe4\xde\x99\x6b\x43\x7f\x2f\xaa\x7f\xdf\xaa\xc6\xf3\xac\x01\xa7\x81\x0e\x02\x25\x12\x0a\x12\xf1\xbc\x65\x48\xb7\x3e\x4c\xce\x8e\x9e\x51\x1f\xaf\xd1\x58\x28\x83\xc5\xe0\xb0\x73\x8c\x28\x6a\x49\x21\x2c\xae\x80\xc5\xe9\xf1\x24\xbb\x26\x2d\x00\x25\xa6\xd7\xdf\xa5\x41\x37\x61\x84\xc3\x44\xa9\x6b\x0e\x78\x74\xcd\x2d\x03\x7a\xc2\xa3\x87\x3f\xa2\xbb\x3f\x7f\xb6\x8e\x54\xb8\xc2\x93\xf4\x8e\xaf\x7e\x75\xc4\x67\x81\x87\xc2\x60\x3c\xc8\xa5\x77\x1f\xda\xdf\x7b\xc6\x7c\x15\x1b\x69\x0e\xd2\xf3\x38\x5b\xdf\x87\x0b\x73\x59\x3d\xab\x77\x38\x65\xab\xc1\x00\x34\xca\x45\x24\xb0\x36\xc7\x54\x44\xc3\x0b\xd0\xd2\x09\xd7\x30\xd9\x90\x54\x85\x11\xb4\xfe\xfd\xcd\xf4\x56\xa4\x8b\xe6\x0d\xad\x83\x63\xc0\xe6\x5c\xe0\xf9\x77\x5a\x07\xd2\x27\x5e\xb4\xc7\x6f\x26\xbc\xc9\x42\x14\x3c\xc9\xbd\x43\x59\xa9\xb2\xa8\x4b\xb2\x5a\x2d\xb4\x89\x31\x6a\x79\x9d\xde\xac\x33\x9a\x2c\x2c\xa5\x95\x6d\xa4\x2e\x33\x7c\x01\x08\x55\x4d\x50\xc3\x69\x82\x4c\xc0\x1a\xac\xe1\x6a\xd0\x7f\xd6\x08\xc3\x3e\x59\x01\x17\x75\x07\x37\x44\xe0\xe2\xf1\xff\x9d\x01\x17\x56\x80\x1b\xbb\xe3\xef\xab\x66\x9e\x59\xc8\xac\xfe\xa4\xe3\x93\x8e\x4f\x3b\xe0\x46\xb0\x05\xfd\xc0\x6f\xc0\x76\xe8\x23\x6b\x04\xb7\xb0\xe3\x40\x1b\xa2\x43\xa6\x7c\x51\x23\x06\x1e\x45\x86\x3a\x6b\x5d\x6e\xd6\x52\xe1\x08\x6e\x9c\x0e\x92\x31\x02\x7c\x8d\x2d\x27\x3b\x78\xfb\xd5\x36\xde\x6d\x03\x2a\xe0\xe3\xfd\x23\x55\x7d\xfb\x54\x83\x11\xfd\x23\x15\x03\xb8\x11\x55\xfd\x8c\x35\x3d\xfa\x54\xd7\xf4\x31\x56\xf7\xec\x87\xc7\xf8\x1b\xfb\x06\xb8\x94\xfb\x37\x25\x51\xc1\x3d\x92\x56\x87\x0b\xd6\x8d\xa2\x6d\xa0\x4e\xab\xa5\xe8\xa8\xb0\x1c\x37\xa4\xfd\xc2\x7d\x18\xed\xab\xc3\xc5\xa4\x4f\xb8\x15\xc3\xaa\xd3\xc4\x29\x56\xfc\xaf\x73\xe6\x6b\x43\x4d\xb1\xa9\x8d\x6d\x53\xab\xc6\x8f\x1c\x15\x9e\xbf\x90\x63\xdf\xb8\xa1\xb0\xa2\xf0\xef\xd9\x79\xd9\x2b\x49\x2f\x86\xf3\xab\xd8\x11\xd4\x22\x82\x99\xe7\x8d\x1a\x18\x9d\x8e\xa3\x69\x03\x03\x96\xf3\xb8\xff\x73\xda\x2c\x98\x88\x1c\xb0\x61\x7f\xae\x6a\xe1\x6f\xb3\x26\xad\x8e\x14\x73\xef\xbc\xd7\x7f\x4a\xc3\xfc\x81\x5d\x9e\x81\x7b\x6c\x53\x94\x41\xa3\x5b\xce\x76\x7a\x86\x15\x79\x23\x81\x6a\xbc\x65\x17\x15\x47\x56\x4f\x9a\xf5\x1b\xd7\x34\x68\x7e\xcf\x29\xfd\xdf\x43\xcf\x88\xbf\xc9\x5d\x4e\x37\xf0\x3f\x63\x9d\x1f\x35\xea\x0d\x06\xd9\x40\x51\x76\x8d\xd9\x00\x48\x83\xec\xe4\x3d\x70\x57\x2d\x6c\x77\x20\xc7\x86\x6e\xb0\xc7\x1e\x9d\x39\x67\xdd\xa0\x25\xd7\xec\x39\xf1\xf7\xa1\xdb\xaf\xba\x6a\x73\x8c\xbb\x3c\x52\xa7\x6c\xe0\xd2\xea\xea\x08\x92\x8c\x73\x41\xb8\x93\xf9\x9c\x7b\x16\xd1\x69\x25\xd8\x1f\xe5\x54\x3d\xd5\x8f\x1a\x4e\x6d\x89\x8e\x2a\x1f\x5e\x32\xc4\xd5\xab\xd7\x90\xe1\x4c\xbd\x50\x63\xad\x69\xce\xea\xa7\x0b\xf5\x0b\x59\xb9\x40\xc0\x6a\x6d\xf1\x05\xfa\x33\x43\x1a\xfa\xe4\x0c\x1c\x18\x1c\xa6\x17\x2a\x98\x1a\x63\x65\xa5\x58\x4b\x71\x05\x4c\x89\xcd\x45\x17\x15\x69\xc2\x43\xfa\x0c\xab\xa9\x2d\x71\x85\xc3\xae\x92\xda\x9a\x61\x7d\x86\x68\x3d\xbd\x7a\xd8\x3d\x14\x69\x82\x4e\x2e\xe3\xc9\xff\x12\xd2\xe8\x50\xef\x37\x1c\x91\xb4\xdf\x80\xcc\x1b\x2c\x7c\xb5\xec\xa8\x48\x4e\xba\x12\xa3\x74\x21\x83\x4e\xb6\x26\x5f\x81\xbf\x7c\xc5\x5c\xe0\x77\xc1\xe4\x2b\xfa\xdc\x95\x57\x4e\x3b\x7a\x54\x24\xdf\xcf\xdd\x4a\x7e\xd0\x25\xe4\xc7\x99\x95\xe4\xc7\x31\xe5\x77\xb7\x93\x1f\x71\x17\xf9\xc1\xbc\x7e\xf7\xdd\x18\x7f\x97\x27\x3f\xe8\x9f\xc9\x8f\x33\xdf\x92\x1f\x6c\x7e\xfa\xbf\x9d\xfb\x92\xfc\xf8\x95\x7c\x47\x72\xa6\x3d\x37\x13\x5e\xc7\x3c\xc8\x1d\xef\xc2\xfb\xdd\xd1\x0e\x9b\xa7\xbe\x47\x8f\xbe\xb5\x7d\x38\xad\x20\x8a\x7a\xe4\x91\x6b\xfa\x97\x77\x1b\x32\xac\x89\x0d\xe7\x87\x42\xe1\x72\x8d\x5e\xdb\xa7\xda\xd3\x4b\xef\xcc\xcd\x6d\x71\x36\x6b\x75\xd1\x3e\x65\xd1\x92\x70\xb8\xc0\x2b\xbb\x62\x81\x60\xd0\x57\x57\x53\x51\x3b\x7c\x98\x5e\xd4\xf5\xe9\x57\xe0\xf1\xfa\x6a\x87\x0d\x16\xc5\xc1\xc3\x6a\x7d\x5e\x4f\x41\xbf\x3e\x3a\x03\x27\x70\xc8\xd4\x49\x5b\x85\x70\x38\x9c\x0a\x39\xe1\x13\x1f\x9d\x52\x96\x83\x78\x1f\x89\x91\x64\x93\x7c\x75\x75\x32\x2f\x45\x94\xb5\x70\xc8\x09\x39\x16\x71\x47\x8d\x08\x2f\x47\xe4\x44\xe6\x6c\x55\x24\x18\x51\x30\xe9\xe4\x00\x83\x05\x53\x93\x1f\xd2\x84\x30\x46\x54\xa8\xc6\xee\xa8\x71\x30\xc8\xa8\xd2\x84\xaa\x6b\x42\x35\x18\x49\xaa\xc6\xc1\x6b\x1c\x9a\x7e\x6e\xef\x94\xde\x43\xc8\xb7\xf8\x8c\x85\x7d\x27\x16\x8e\x6d\xb9\x9f\x7d\x4c\x7d\xd1\x73\x74\x59\x58\x3f\x40\xa8\xad\xba\xfc\x5c\x3f\xf4\x52\xd7\x1f\xbd\xbc\xc2\x38\xba\x7c\x44\xf9\x80\x59\x75\x55\x97\x33\x1f\x8d\x2e\x1b\x59\x3e\xe0\xf2\xda\xaa\xd9\xf5\xe4\x13\xcd\x1b\xd9\x7f\xa9\x2f\xe2\x5e\xf2\xcc\x4a\xf2\x1d\xfe\x31\x06\xfd\x61\xff\xd9\xdd\xd1\x67\x34\xe4\x33\xb3\xf1\x33\x1b\x94\xc7\xe3\x27\xdd\x34\xba\xbc\x14\x8f\x54\x3d\x9b\xd8\xc0\x37\xc1\xe9\xec\xcb\xfc\x0e\x64\xdf\x07\xa8\x09\xd1\x2c\x74\xf8\x18\x2d\x16\xad\xc1\x64\xa2\x72\x74\x5a\x4a\x9b\x17\xe4\x2c\x26\x60\xd2\xb6\xc7\x4c\x92\xe1\x79\x50\x8d\x63\x96\xc8\xf6\xd2\xc7\x24\x29\xdb\xce\x03\xb5\x0a\xee\x60\x45\x6d\x38\x05\x9f\x93\xcc\x78\x4e\x60\x0e\x54\x54\x54\xa4\x55\x9c\x46\xc8\x85\x7e\x65\x0d\xb0\xe2\xb6\xcf\x11\xec\x22\x23\x16\x45\xcc\x74\xa2\x0a\xf5\xda\x6f\xcf\x6c\xac\xf6\xc2\xe5\x2b\x6f\xdd\x3d\x8a\xfb\x92\x09\xf4\x6d\x1a\xd6\x37\x97\xf9\x92\x1b\xb9\x2b\x51\x9a\x7a\xf6\xc9\xf8\x55\xe0\x3e\xa5\x3c\x95\x5b\xd5\x63\xfe\x95\xb5\xbd\xbc\xde\xde\xdd\xe7\x5e\xdd\x43\xa9\x29\x47\x73\x7a\x95\x7b\x0d\x49\x20\xb9\xc5\x70\xb2\x40\xd2\x1b\x35\x96\x5c\x83\x56\x6b\x31\x4a\x6c\x7e\x28\x2b\x6a\xb3\x59\xfd\x4e\x8a\xb5\x18\x39\xab\x20\xc9\x7a\xa3\x51\xd3\x9c\x00\xc4\xb1\x1c\x54\xf0\x94\x48\xbc\x1b\x89\x4b\xc6\xf9\x12\x49\xcb\x40\x57\x27\x42\xb2\xd0\x83\x9d\xe6\x92\xc8\x4a\x5f\xf6\xe9\xa9\xbf\x4d\x54\x12\xd3\xc1\x3f\xbb\xcc\x27\x99\xab\xae\x64\x91\x26\xf3\xd5\xa7\x76\x9a\x12\x9a\x93\x8d\x9c\x87\x4a\xcc\x78\x68\x34\x24\x98\x0c\x4e\xa7\x96\x67\xad\x14\x4b\x79\xb3\x04\x47\x5b\xcc\xcc\x6b\xf8\xc9\x31\x83\x46\x40\x5f\xac\x8e\x61\x9d\xa9\x72\xf9\x34\x70\xa8\xb4\xda\xba\xc4\x6c\x94\x18\x71\x55\x22\x6c\x9c\x51\x3a\xff\x24\x2e\x9d\xff\xf7\xfc\xf9\x20\x84\x2c\x4a\xbb\x52\x3c\xff\xf2\x41\xa5\x78\x9e\x39\xb2\xeb\x95\x57\x76\x6d\x55\xcb\xe7\x13\x3d\x5a\xef\x51\xe3\xc5\x88\x46\x3b\x2d\x0a\x26\x49\xd2\x6b\x79\x9a\xf7\x7a\x44\x77\x4b\xcc\xa2\xd5\x69\x5b\x62\x26\x9d\x88\xbe\x70\xb3\x18\xa9\x25\xc6\xcb\x17\xa5\x31\x12\x49\xf4\xa9\x03\x6a\x90\x38\x49\x65\x5a\xd2\xe2\xdf\x71\x94\x38\xfe\x31\xa2\xcf\xbd\x66\xcd\x11\x1c\x27\xfe\x98\xbe\x11\x47\x88\xd9\x7b\x77\xde\x72\xcb\xce\xf8\x49\x58\xa0\xc4\x89\x69\x52\x03\x7b\x0b\xa9\xdf\xf7\x20\x4f\x3d\x68\xd3\xe9\x1c\x4e\xda\xed\x74\x23\x8f\x95\xd2\x23\x36\xb2\x2e\xbd\xc1\xa6\x6d\x8b\xd9\x6c\xe8\x60\xb2\xe2\xea\x44\x7d\x1a\x5c\x72\x67\xd9\xae\x55\x63\x56\x98\x85\x68\x7b\x87\x78\x02\x07\xe6\xcf\x61\x13\xec\x43\xbb\x1f\xf9\x7d\x57\x8f\x9a\x71\xff\xd2\x59\x77\x1c\x80\x47\xc1\x97\x00\x00\x13\xfc\x64\xc5\x8a\xfb\x36\x77\x2f\x5a\x7d\xff\x2a\x96\xb9\x7f\xd3\xdc\x19\xf7\x2e\x2d\x81\x79\x5c\xbf\xa3\xff\x98\x3d\x11\xb6\xe9\x6f\xbe\xf7\x46\x27\xa6\x15\xe7\x82\x6f\x61\x87\x23\x4a\x4b\xa8\x71\xd1\xb0\xd7\x8e\x0b\xd6\x9d\xb9\x41\x7d\xc8\x28\x08\x26\x53\x28\x18\x70\x72\xa5\x61\x8f\x60\x76\x7a\xf2\x44\x8d\x2d\x47\xcc\xc1\x25\x58\x4c\x91\xa6\x08\x9b\x6a\x54\x06\xb4\x37\x32\xd2\x6b\x1b\xbb\x06\x50\x22\x0a\x4a\x8a\xac\x66\x26\x2a\x93\x20\xd9\x89\xa4\xc7\x4c\x08\xb7\x18\x52\x67\x41\x6e\x85\xcd\x00\x6c\x64\x0d\x6c\xd9\x96\x99\x7b\x0f\x8f\xbe\xe5\xa6\x5b\x9b\x26\xcd\xdc\x54\x44\xd3\xf0\xb8\x16\x64\x55\xb6\x45\xab\x0a\x57\xdf\xd4\x6e\xbe\xac\xbd\x61\x72\x15\x5b\x27\x5c\x5b\xd0\x36\x15\x7e\x08\xe1\xa9\xdb\x6f\xb9\x79\x4d\x41\xc7\xa4\x3d\x70\x12\xfb\xc7\x94\x9b\xe2\xff\x5a\xb0\x65\x94\x77\xf5\xcd\x1d\xfd\xdb\xf7\xed\x8b\x3d\xa4\xd8\xc1\x07\x28\xc0\x2e\x40\x3a\x48\x43\x55\xe0\xfe\xb2\x8c\x9a\x43\x8f\xf1\xaa\x39\xa9\x1d\xcc\x01\xf8\x02\xe6\xe5\xa7\x72\xf3\x07\xe2\x14\x98\xb9\x8d\x9d\x52\xea\x95\xec\x6c\x66\xc9\x99\xf8\x7c\xdc\x33\x18\x4c\x89\xef\x53\xdb\x06\xa3\x67\x1f\x43\x6b\x2e\x73\x1f\xa2\x67\xe7\x47\xad\xf8\xc1\xe8\xf9\x5a\x9d\x92\xa0\xcf\xc9\x00\xc3\xe5\x26\x1e\x27\x66\x3e\x2f\xe7\xb7\xf8\xd7\x38\x43\x1f\xdc\x17\xdf\xa9\x96\x54\x91\xfe\x51\x4a\x1f\x63\x13\xce\x48\x66\x34\x1a\xa3\x5e\xab\xe5\x28\x46\x30\xf3\x7a\x83\x7e\x72\x0c\x17\xc5\x99\x4c\x34\x32\xdd\x19\x6d\x9a\xec\x64\x44\xdf\x22\xc9\x9a\x2d\x92\x95\x8f\x01\x96\x70\xbf\x63\x50\x0f\x91\x90\xac\x5e\x8d\x31\xa2\xb7\xbf\x11\x7f\x8d\xee\xf9\x06\xdd\x48\xc6\xbc\x4a\xad\x03\xc3\x63\xfa\x38\x75\x50\xca\x2c\xe0\x21\x9b\x13\x43\x36\xc7\x4c\x82\x56\xee\x3a\x64\x6d\x5a\xf2\x3d\x1a\x0f\x6d\x9e\xc4\x98\xdd\xe2\x5f\xbd\xf8\x22\xfc\x76\xd9\x32\xb6\x6e\x3f\x3c\xf1\x12\x8c\x81\x87\x5f\x02\x47\xd4\xfa\x6a\xdc\x97\x36\x9b\xea\x17\x0d\x38\x68\x03\xeb\xf3\x49\xd9\x86\x6c\x7f\x8e\x55\xd6\xba\x71\x75\x2a\x95\x2d\x09\x72\x47\x4c\xf0\x50\x4c\x1b\x4e\xe4\x4a\x5e\x62\x91\x3c\xe3\xd4\xb0\x6a\x6c\x87\x94\x1f\x60\x4b\x15\xfb\x78\x44\xc2\xb0\xe7\xac\x64\x6e\x69\x44\xff\xcd\xcc\x9a\xf8\xfd\x7d\xfb\xb7\x56\x7c\xf2\xcb\xe2\x6f\xef\x5f\xfe\xfe\xf0\x67\x07\x5f\x7d\xe6\xb2\x05\x3d\xc7\x97\xe3\xe5\xfc\x37\x7c\x3f\xdf\x25\xc0\x5d\xf0\xdd\x8f\xe0\xe1\x2d\xcd\x97\x2c\x1e\x09\xde\x7a\xef\xbd\xa0\x3f\xfe\x18\xe1\xcd\x8d\x04\x87\xbd\x8e\xf2\x51\x03\xa3\x41\x07\x3a\xb6\x5c\x56\x2b\x6f\xa3\x6c\x39\xd9\x1e\xe4\xaa\x7a\x3c\x36\x59\x76\xb6\xc6\x64\xc1\x26\x6b\xf4\x8c\x7e\x44\x8c\x49\xde\x4a\x5d\x30\x55\x5c\x81\xf0\x25\x88\x6f\xaa\x73\x6a\x51\x88\x24\x8b\x45\xba\xa1\xb1\x73\xe1\xef\xbf\xdc\xff\x51\xbf\x83\x95\x93\xfb\xcc\xbb\xea\xf3\xda\x85\x5e\xf8\x2d\x63\x87\xec\x9c\x65\x77\x7e\x7a\xf5\x25\x7f\xc2\x1f\x47\x8f\x5a\x58\x91\xb7\x7e\x1b\xe8\x86\xc8\x5e\xcf\xd6\x9d\x80\x3f\x14\x2c\xf8\x46\xb9\xf3\x9f\xce\x7e\x81\xf8\x9a\x4f\x4d\x8c\x5a\x9d\x2c\x92\xcb\xac\x5c\x3f\xe0\x74\x46\x74\xe0\x06\xf3\x0c\xc1\x7d\xa0\x3a\x9a\x05\x74\xb2\x0e\xc9\x11\x2f\x23\x6d\xee\x94\x65\xca\x6b\xb7\x30\x9c\x41\xa2\x72\xdb\x93\xdd\xf3\x23\x69\xed\x67\x95\xb9\x80\x70\x58\xc1\xb2\x54\x02\x88\x18\x5d\x23\xf0\x97\x00\x1c\x38\xf7\x9e\x79\xe3\xa9\x32\xe1\x58\x06\x06\x47\x60\x70\xd5\xb1\xca\x21\x01\x05\x83\xe3\xa1\x99\x6f\x11\x78\x8d\xce\x28\x1c\x57\x99\x31\x0a\x87\x69\x5e\x02\x85\x03\x16\xe1\xd3\x18\xe7\x5d\xe1\xf9\xa1\xb5\x08\x52\x73\xa2\x6e\x31\x2f\xcf\x1c\x74\xe5\xe4\x04\x19\x9e\xe5\xb2\x64\xaf\x37\xa4\xe7\x5c\x7c\x0e\x63\x26\x8d\x27\xb3\x62\x01\xa5\x8a\xcf\xcc\xa3\x2f\x7d\x56\x36\x41\x8c\x94\x71\xe1\x5e\x90\x53\xf3\xb1\x94\xc3\x38\xe3\x60\xc0\x77\xee\x4a\xf1\x9e\x18\x89\x48\x8e\xb4\x22\xf1\x8b\x96\xeb\x91\xa9\xfe\x75\xc9\x9e\x3b\x6a\x7f\xfc\xd2\xb7\x7a\xfe\x75\xcd\x5e\xc3\x38\x09\x2e\x8c\xef\x00\xf7\xa5\xea\xf6\x3c\x48\xf6\x30\xe6\x48\x25\x75\x4d\xb4\xa7\xdb\x18\xd1\x97\x14\xf9\x7c\x7a\x23\x97\xc7\x09\xf6\x32\xa1\xac\xaa\xba\xc4\xed\xf1\xa0\x0d\x23\x78\xb2\x3d\x18\xe6\xce\x13\x08\x78\x2c\x4c\x24\x14\xb1\x76\xc4\x22\xd6\x90\xbf\x23\x16\x62\x8d\x56\x5e\x4b\x6b\xf7\x01\xc3\x9e\x18\x9d\x26\x9a\x54\x7a\x14\x2f\x91\x92\x9b\xea\x2a\x94\x8c\xff\x70\x36\xbf\x5a\xcb\x55\x55\x19\xca\xff\x5f\xb0\x48\x78\x8d\x9d\xfe\x1e\xfe\xda\xad\x23\xa7\x6f\xd3\x0a\xd3\xfb\xf0\x54\x03\xd0\x16\xdc\xbd\xf4\xa2\xa8\x24\x5f\x1f\xf4\xec\x3b\x25\x89\xb7\x65\xdd\x5f\xdc\x43\xbb\x6f\xfb\xc4\xcb\xe7\x5e\x08\x9f\xe4\xfe\x4f\xdd\x4a\x8e\xe1\x64\xc4\x13\x5c\xcb\x58\x49\x2d\x88\xf6\x36\xd3\x85\x48\x55\xe4\x06\x02\x06\x43\x7e\xbe\x44\xd1\x65\x2e\x56\x53\x55\x9d\x6b\x16\x4a\x22\x2d\xb1\x12\x0f\xe7\xe4\x9c\x85\xde\x42\x64\x12\x14\xda\x05\x73\x4b\x4c\x10\xb2\x05\xc4\x27\x41\xa0\xbd\x5e\xb9\x25\xe6\xb5\xe0\x8b\xa6\xf4\x82\xe2\xf4\x10\x4c\x17\xa8\xc6\xc4\xf6\xe5\x2a\x43\x79\xff\x4b\x1d\x23\x86\x46\x4e\x72\x8f\xee\x69\x82\x2b\x5a\xd2\x8b\x1a\xa7\x2d\xd4\xa5\x8a\x1a\xdf\x7c\xd6\x93\x60\xd9\xc2\xe2\x1e\x7a\x50\x98\x5e\xe0\x38\xb8\x7f\x7a\x81\xe3\x0d\xdb\x6d\x33\x7a\x11\x86\x51\x89\xdc\xce\xc3\x04\x6b\x6a\x70\x34\x60\x36\xd1\xb2\x6c\xb7\x8b\x7a\xde\xc4\x39\x1d\x76\x89\xb6\xb5\xc5\x68\x51\x81\x1e\xb0\x18\x26\xc7\x2c\x92\x19\xe9\x80\x3d\x2a\x20\x4a\x52\x41\xa9\x68\x24\xe9\x4d\x47\x52\x60\x28\x44\xbc\x3b\x01\xa2\x04\xae\xf5\x81\x11\xd7\x9e\x19\x0d\x77\xc8\xfd\x3d\xe9\x88\x28\xdd\xef\xb0\xc7\x3f\xc0\x42\x4c\x8f\x37\xd9\xe2\x07\x55\xfa\x9e\x46\x7b\xd6\x4e\xf5\x8f\xe6\x63\xea\x04\xb3\x59\x63\x90\xec\x9c\xc3\x69\x97\x69\x5b\x73\x8c\x46\x46\x1a\x4d\x53\xc8\x65\x33\x22\x0b\x23\x51\xdf\xa8\x6e\xcd\x8b\xd0\x46\x6a\x1b\x93\x7b\xaf\x53\x81\xa3\xab\xb6\xe8\xec\xa3\x6f\xad\xed\x5c\xe1\x58\xd0\xdb\x07\x6f\x26\xfb\x4b\x29\x73\x4c\xc3\x90\x71\x21\x2b\xbe\x44\xc1\x2a\x60\x6d\x36\x83\xcb\xe2\xf2\xb8\x2d\x34\xb2\x79\x69\x79\x32\x3a\xc6\x27\xc7\x6c\x12\xad\xe1\x38\x0d\x2d\xd9\x38\xd1\x25\xe9\x55\xf4\x06\xd5\x15\x2c\x2e\x4e\x00\xa1\x25\xb3\xb8\x12\x74\xd6\x10\x9d\x68\x4d\xa0\xca\xa0\xa3\x51\x21\x35\xbf\x22\x7c\x99\x35\xf4\x8a\xca\x49\x0c\x2d\x13\xbf\x2c\x52\xaa\x30\x32\x00\xd6\xc1\xcf\xdd\xb5\xa0\xaf\xc2\x4d\x09\x1c\xfa\x03\x2c\xb7\x2b\xbc\x54\xeb\x46\x33\xe9\x45\xe4\xba\x3d\x06\x44\x2f\xe2\xa5\xac\xf0\xd3\x46\xb3\x98\x5e\x96\xc6\xf4\xca\x7a\xb5\x34\x31\x83\xde\x2e\xf0\x67\x09\x7a\x13\xbc\x45\xf4\x8a\x09\x7a\xdd\xdd\xbc\x23\xaa\xfa\xa9\xcc\x25\xe5\xa3\xff\x1e\xe1\x0f\x29\xdc\xe5\x40\x25\xfc\xc1\x9f\x60\x71\xfc\x6d\xf0\x0e\x7c\x01\xd4\xf3\x84\xc5\x6a\x9c\x1c\xcb\xa7\x9b\x1a\x11\x2d\xd2\xb2\x0e\x87\x13\x27\xa2\x9a\x44\x37\x70\x3a\x3d\xa2\xe8\xd5\x5a\xac\x76\xd6\x49\x63\x38\x68\x9c\x90\x4a\xd1\x92\x53\x32\xe2\x54\xd4\x48\x7a\x4a\xb9\x83\x44\xf0\xa4\xa4\x61\x9c\x38\xf9\x45\xd5\x5e\x4f\x2f\x77\x25\xa2\x2a\x06\x56\x83\xd0\xed\xb7\x57\xcc\x99\xfe\x0a\xe8\x76\x6e\x71\x18\x1c\x86\x2f\xc1\xad\x52\x73\x16\xfc\x6c\x35\xfb\xcc\xda\xb5\xbb\xe0\xb9\x39\x7f\x03\x65\x70\xd9\x8b\x81\xb8\x97\x1e\x6b\x70\xc6\xdf\x66\xf9\x04\x56\xca\x20\xe4\x63\xb8\x71\x85\x8e\x9e\x77\xb9\x18\x60\xd5\xda\xed\x6e\x8b\xcd\x6d\xf3\x78\xf5\x56\xa7\x9d\x15\x64\xb7\xac\x43\x36\x23\x72\x2e\x68\x9a\x15\x04\x96\x52\x10\x7d\x93\x69\xcc\x8e\x8c\x38\x08\xf2\x4e\x15\x2b\x25\xe9\x5d\x20\x5b\x25\x41\x2d\x3e\x49\xfd\x1f\x2f\x5e\x02\x9c\xb7\xdd\x56\x5e\xda\xbd\x68\x29\x90\xde\xed\x56\x07\x1a\xe0\x57\xdf\x67\x57\xc2\xe3\xaa\x8f\xf1\x11\x9d\x37\x72\x14\x00\x70\x45\x6b\x59\xfc\x00\x78\xcb\x00\x7b\x65\xf0\x56\xa6\xfa\x44\x73\x91\x24\xc8\x26\x8b\xc5\x0c\x64\xd9\x61\xd7\x99\xcd\x0e\xd6\x64\xb1\xb2\xb4\x20\x4b\x5a\x86\x06\x48\x96\x99\x44\x1f\x39\x95\x9b\x0a\x3f\x53\xb8\x7d\x88\xbe\xb4\xad\x95\x60\xe4\xd9\xb3\x34\x5b\xb7\xa8\xef\x83\x40\xfa\x28\x30\x3d\x0b\x6c\x80\xff\x80\x6f\x0b\x7d\x9c\xf0\x0f\xb6\xe3\xeb\xf8\xe7\xd7\x2d\xc5\xbb\xbe\xe7\x1a\x47\x06\x0e\x92\x88\xe8\x7a\x97\x60\xb2\xf6\x8a\xfa\x11\x4d\xc0\xcc\x5a\xad\x36\x60\x93\xf5\x66\xb3\xcc\x9a\x24\x0b\x22\xcb\x26\xeb\x04\x1a\xb4\xc6\x68\xa1\x33\x59\x52\x5a\x55\x27\x3a\x78\x31\x28\x4b\x27\x7e\x81\x71\xf0\x59\xfa\x92\xb2\x70\xf7\xc2\x74\x76\x45\x90\x99\xd4\x7c\x02\x96\xd1\xc1\x51\x23\xba\xf2\x0a\xeb\xa1\x17\x08\x46\x4d\xdf\xa8\x1f\xa3\x06\x62\xcc\x40\x8c\x6c\x65\x11\x0d\x7c\x7b\xcc\x60\x60\x31\x5c\xa0\xc4\xa2\xdd\xce\x4a\x34\xc9\x36\x4a\xd0\x55\x1b\x2e\xce\x58\x4f\x62\xc3\x91\x4a\x86\xb4\xb2\xde\x17\xce\x3c\x84\x61\x91\x14\x64\xba\x97\x88\x0a\x6c\x50\x52\x73\x69\xeb\xd9\x85\x54\x92\x86\x7d\xa4\xd6\xb1\x57\x57\x1a\x9a\x15\x1a\x90\x8d\xcd\x0a\x68\x17\x63\x70\x81\x83\xff\xff\x10\xb0\xef\xd4\xa6\x44\x5d\x31\x70\xef\xc7\xee\x7e\xaa\xb4\xf8\xdc\x0d\x64\x7c\x5c\xdb\xf2\x77\xe2\x5b\x34\x46\x73\x34\x0c\xc3\x6a\x29\xca\x60\x62\x4d\x66\x41\x43\xb7\xc7\x34\xc8\xad\xd7\x19\xdb\x62\x3a\x86\x63\x28\x96\x40\x12\x5e\xd4\x84\x4d\x8d\xeb\x47\xe2\x4c\x6f\x83\xff\x25\x53\xd7\xd0\xf2\xcf\xa9\x69\x7f\x7d\xf6\x41\x65\xde\x73\xd1\xb8\x2f\x10\xff\x62\x50\x34\x1f\x18\x0c\x46\x1a\xf9\x34\x1a\xa3\x06\x43\x61\x00\xe4\x61\x08\x20\x1b\xa0\x73\x19\x00\x46\x6b\x94\x19\xbe\x35\xc6\x08\x29\xec\x27\xf5\x5c\xee\x4c\x01\x50\xc7\x56\x41\x01\x6f\x01\xd9\xb4\xf4\x27\xfc\x16\x12\x88\x0a\x3c\xe7\x13\xe7\x76\x29\x0c\x50\x68\xc0\x3d\x9e\x9e\x24\x3e\xc7\xb0\x68\x01\xc3\x6a\x70\x53\x6f\x17\x32\xe7\x59\x26\xc7\x6f\xb3\x5b\xec\xe8\x70\xf4\xe8\xbd\x93\x63\x7a\x3d\xcb\x71\xf4\xe4\x58\x92\x07\xe9\x35\x39\x5d\xd0\xba\x49\xc5\x3b\x59\x87\xf4\xea\xbb\x1a\xb5\xe3\x25\x06\x6b\x04\x3f\x3f\xff\x03\xbd\x2e\x67\x58\xcd\xda\x6d\xef\xef\x9d\xfc\x40\xcf\x67\xca\x86\x0e\x6f\xe9\xd7\xb3\x32\xc2\xde\x7a\x76\x1e\xd7\x0f\xba\xdc\xf9\x70\x3d\x3c\x04\x5f\x85\xf7\x36\x5f\x32\x7d\xe4\xaf\x27\xfe\x0d\x40\x4d\x7c\x4c\x92\x66\xdc\x7f\x36\x1b\x57\x12\x39\x9c\x1e\xab\x55\x83\xfb\x40\xd9\x9c\x88\xe6\x2c\x4b\x73\x2c\x2b\xcb\xe9\x72\xd9\x9b\x63\x2e\xc1\xe6\x94\xb5\x7a\x16\xb1\x92\xed\x12\x14\x4f\x03\x2e\x4d\xfa\x1f\x4a\x44\xb6\x26\x85\x81\x4e\x26\x81\xa7\x81\xbb\x60\xb2\x8f\x4d\xde\x7b\xf5\xe4\x1b\xba\x3f\x14\x1e\x3c\x62\xd0\xe0\x5e\xc5\xf5\x5f\x3f\xff\x0d\x7d\x43\x5b\xf4\x9e\x47\xdb\xb7\xfe\xb0\xb8\xd7\x90\xa5\x03\x9f\xda\x79\xdf\x06\x37\xbc\x52\xa9\x2c\x87\x42\x16\x3c\x49\xee\x90\x06\x9c\xff\x91\xfd\x83\xbb\x07\xe3\x66\x51\x93\xa2\xe5\x46\xc6\xab\xd3\x85\xca\x29\x2a\x18\x62\x4a\x73\xed\xa5\xf6\xea\xaa\x62\xbe\x2d\x56\x5c\xec\x96\xdc\xd9\x6d\x31\xb7\x44\x05\xa5\x60\x47\x4c\xb2\x56\x96\x9b\xcb\xdb\xd2\xba\x02\x29\x57\xa9\xaf\x77\x46\xfc\x49\xe6\xf1\x56\x90\xfa\x9c\xaa\x44\xf4\x1e\xf0\x4a\x4c\x34\x3f\xbd\x2d\x2c\x29\x16\x51\xbb\x8c\x10\x9b\x2c\x52\x51\xc3\x4c\xc9\xad\x2c\x28\xed\x56\x59\x07\xfe\xde\x7b\xe6\x0d\xed\xd3\xd7\x6d\x3f\x73\xd3\xb2\x1f\xb6\x4e\x1c\x3d\xba\xbc\x62\xe1\xb2\x1d\x0f\xce\x19\x76\xdb\xe4\xb5\x77\x77\x0f\x3b\xe6\x0e\x04\x5c\xf5\x97\x53\xd6\x2f\xbc\x61\xed\xb4\xcf\xe0\x87\x79\x95\x95\x4f\x81\xde\x6f\x7d\x0d\xc6\xec\xca\xff\xd8\xf2\xc7\xb9\x93\xe7\xa9\xcf\x4e\xac\xff\x76\x2e\x3c\x3d\xfd\x64\x5b\x58\xb9\x3f\xc3\xbd\x1b\x1f\x67\x87\x21\xdf\xab\x8c\x8a\x45\xc3\xa1\x3c\x63\x71\xb1\x33\xa7\xb4\x54\x76\x32\x3e\x49\xe3\xd3\x54\x94\x7b\x0a\x5b\x90\xbf\xc8\xea\xf5\xc8\x6f\xd4\x5b\x4a\x65\x16\x99\xa0\xac\x9d\xca\x49\xe1\x69\xa4\x05\x3a\x2f\x32\x6d\x8e\x4c\x14\xf7\x32\x4c\x4d\xd3\x1e\x51\x6a\x2a\x49\x13\x3f\xa4\xbf\x35\x66\x40\x2e\xed\x6d\x76\x47\x03\x60\xbe\x1c\xd9\x34\x66\xda\x9f\xf0\x97\xef\xde\x1d\x35\x72\xb0\xab\x6c\xe4\xe4\x35\xcb\x8a\x6b\x6e\x59\xba\x7c\xf5\xd8\x6e\x57\x66\x83\x8a\x91\x9b\x06\x0d\x2c\xf2\x67\x87\x6c\x81\x00\xc8\x03\x9a\x38\xa8\x0d\xbc\x66\x7d\x75\xcb\xee\xd7\xa2\xcf\x36\x3f\xf9\xdc\x2b\x3b\x77\xde\x61\xb5\xec\x77\x98\x69\xcd\xdf\x9f\x1d\xb0\xad\x9b\xff\x61\x4a\xc9\xf3\x1c\x43\x70\x76\x03\xd4\xa8\x68\xbe\xd6\xe6\xb3\xd9\x19\x17\x2f\x50\x94\x8b\x77\x05\xf3\xb8\x6c\x2e\xdb\xee\xf1\xe4\xb6\xc5\x3c\x2c\x3a\x38\x91\x03\x6f\xb7\x1a\x25\xe2\x80\x18\x3d\x5d\xe6\xa9\x34\x15\x49\x16\xf2\x3b\xd2\xe2\x8d\x1c\xcd\xa5\x19\xd0\xd8\xfd\xc8\x88\x3e\x2e\x5e\x73\x0b\x06\xd9\xbd\x06\xbe\x9a\x34\x9d\x2d\x7f\xc6\x3b\x87\x22\x7f\xad\x84\x2b\xf2\x67\x34\x2a\x0e\x46\xce\x60\x07\x98\x02\x1a\x12\x41\x49\x2a\xd1\x4f\x6c\x14\xf2\x27\x82\x58\x2f\xf8\x45\xd1\x8d\x6b\xf8\x0c\x0e\xce\x91\x1f\xf2\xe5\xb5\xc4\x7c\x1e\xbb\xd1\x6e\x74\x6b\x49\x32\xa4\xac\x45\x9a\x59\xab\x7a\x0d\x9d\x7d\x05\x55\x3f\xd7\xaa\xe6\x14\x87\xe9\xcd\x08\x54\xe2\x34\x9a\x1a\x0e\x1d\xad\xe9\x6e\x41\x9b\xf9\xdb\x78\x7a\xdc\xf2\x9f\xa4\xbc\x51\x7c\x6d\x7d\xca\x1f\x28\xaf\xd6\x83\x5c\x98\x16\xc4\x84\x37\x5f\x3a\xc5\x74\xcb\x5b\xde\xc9\xc3\x12\x6e\x00\x9a\x47\x4f\x74\xb6\xac\x53\x7b\x8b\x79\x00\xcf\xb0\x3c\xab\xd5\x6b\xf5\x46\x13\xa5\xd5\x69\xb1\x52\xe7\x41\x7b\x8c\x97\xd8\xd4\xc9\x96\x9e\x8b\x98\x04\x0a\x88\x28\x7a\x00\xe3\xcb\x9e\x59\x7c\x66\x07\x9c\xc1\x8e\x60\x3b\xce\xdd\x89\x1d\x70\x82\x26\xab\xf2\x6c\x3a\xc1\x89\x30\x50\xf5\x51\x59\x8b\xd4\xb6\x41\xaf\xe7\x19\xde\x68\xd2\x30\x2c\x83\x74\x90\x60\x40\xa3\x3c\x0d\xb4\x24\x9c\xdb\x98\x86\x25\x9d\x44\x85\x51\xd3\x90\x15\xa4\x68\x34\x26\xbd\xf8\x6f\xf0\x6e\x0c\x1e\xb1\xf0\x14\xb3\x78\xff\xfe\x78\xef\xf8\x4e\x25\xc7\x8a\x7d\x93\xe0\xf2\x29\xfd\xd3\xaa\xd0\x5a\xdd\x4b\xea\xf5\xf3\xa2\x16\x23\xda\x75\x7a\x3d\x6d\x36\xf1\xbc\x0e\x19\x11\x1e\x05\x2d\x2f\x15\x2b\xc6\xb3\x21\x59\x5e\xd8\x00\x47\x2f\x8f\xc0\x0e\x92\xdb\x65\x6c\x7c\x1d\xd9\x2c\xa3\x31\x1a\x1f\x5b\x17\xdf\x5d\xf1\x46\xd9\xfb\xf4\xa0\xb3\x07\x31\x7c\xac\x9a\xe3\x86\xc7\xa4\xcc\xb8\xdf\x11\xcb\x51\x46\xda\xc8\xe9\x34\x9c\xde\xac\x37\x0b\x16\x46\xa3\xd5\xb4\xc5\x8c\x14\x3a\xbe\x4c\x7a\x86\x93\x94\xce\x08\x99\x79\x9d\xc9\x96\x13\x11\x05\x13\xa3\x2a\x42\x60\x0a\x99\x6b\x4e\xc1\x75\xf0\x33\x78\xe7\x4f\x70\x17\xa8\x02\xdd\x40\x19\xa8\x62\xf8\x6f\xe2\xc7\x68\xff\x37\x74\x63\xfc\x2d\xba\x9a\xca\x98\xa3\x44\x45\xa3\x39\x06\x41\x00\x16\x93\x45\x62\xf0\x4c\x6d\x56\x8b\x87\xe7\x29\x34\x59\xb3\x44\xe1\x0e\x77\xa4\xee\x21\x55\x3a\xd7\x98\x46\x00\xa1\x20\xe2\x4f\xcd\x9f\x14\x2e\x56\xf9\x37\x82\xee\x99\x6c\x40\xef\xdf\x80\xc7\xe1\x1b\xe9\xac\x78\xe5\xbb\xef\x54\xdb\x1d\xad\xf3\x87\xc4\x66\xaa\x8d\x66\x99\x04\x33\x67\xd0\xea\x34\xe8\x90\x07\x9c\x81\x33\xb0\x46\x1d\xa3\x41\xf6\x52\x7b\x57\x7b\x09\xf9\x19\x20\x1c\x09\x13\xf8\x30\x62\xa7\xe8\x08\x0b\xc8\xff\xd9\x0f\xcf\xf4\x82\x1f\xc0\xf7\xe1\x1b\xe0\x6d\x38\x09\x74\x47\x96\x26\x0f\xaa\xd1\x81\x5d\xf9\x2b\x16\x32\xf0\x13\xb4\xd2\x87\xe8\xa5\xb0\x15\x3c\x11\xbf\x1e\x96\x10\x3a\xea\x10\x1d\xb7\xa8\x18\x11\xf9\x82\x99\xe5\x39\x2d\x6d\x30\xea\xcd\x3a\xd1\x62\x40\x87\x75\x4b\x8c\xd3\x72\x5a\xa0\xe3\x05\x56\x16\x00\x30\x26\xc5\x2e\x11\x69\x09\xa7\xd7\xa2\x63\xc1\x33\x10\x62\x3c\xf8\x3b\x12\x3e\x66\x43\xfd\x39\x08\x3f\x06\x6b\xe0\x8d\x20\x7c\xfc\x5b\x50\x8e\x7e\x6a\xaf\x3f\x05\x6e\x82\xd7\xd0\x61\xda\x80\xf3\x3e\xe3\x7f\xc2\x35\xf1\x9d\x98\x16\x16\xd1\x72\x40\xb5\x23\xed\x06\x2d\xcd\x71\x7a\x81\x35\xe9\x4d\xa2\x45\xcb\x9a\x58\x12\xc6\xc2\xd7\x6c\x3a\x64\xc2\x08\x6d\x31\x9e\xb8\x8a\xc9\xfb\xc0\xd4\xcd\xa5\x62\xc8\x29\xed\x3d\x93\xd0\x1f\xc8\x96\x60\xe9\xe7\xf6\x03\x07\xc8\xba\xfd\x4c\xdc\xfc\x31\xd7\xef\xeb\x73\x77\x12\xb8\x48\xb2\xfd\x14\xdc\x4c\x34\xfe\x2b\x2a\x2f\x6c\x02\x8b\x09\x30\x19\xf4\x26\xbd\x45\xc4\xe3\x23\xa9\xc0\xa3\x1b\x4c\x32\x1e\xbf\x39\xc6\x67\x56\xcb\x51\x91\x4c\xc7\xa4\xeb\xf8\x3c\x7d\xc3\xd3\x20\x8a\xe1\x47\xce\xfd\x82\xdc\x76\xb4\x13\x13\x10\x24\xcc\x62\x4a\xe9\x6b\x36\x9d\xe0\x87\xe3\x3c\x8e\x2c\xb3\xdd\xca\xb2\x06\x1a\x18\x80\xc3\x29\x6a\x3b\x62\xa2\xc8\xda\x8c\x0c\x6b\xef\x24\x13\x5d\x2d\xd8\x84\xfd\xda\x05\xce\x92\x7d\xe9\xcc\x8e\xa6\xe7\x47\xbd\xf6\x1c\xf0\x8e\x9b\xbe\x79\x22\x08\x29\x52\x71\x3c\x3b\xe7\xa7\x9f\x93\xa8\x96\x67\xd5\xfe\xfc\x23\x10\x2d\xb7\x93\xbb\x85\x86\xa8\x03\xad\x3f\xf2\x2e\x8c\x06\xd9\xe0\x70\x32\x12\xb2\x21\x19\xb3\xc6\x2e\x18\xb1\x26\x32\xeb\x9a\x63\x66\x99\xba\x98\x3d\x9f\x0e\x90\xa2\xe8\xbf\x04\x48\xca\xcc\x4d\xa5\xa3\xae\x04\xae\x85\xa7\xb6\x8e\xde\xb0\x5a\x45\x49\x31\xe5\x80\x53\x0a\x47\x92\x48\x29\xe9\x58\x9e\x4e\xe4\x37\x76\x93\x29\x0a\x31\xc6\xc2\x71\x4e\x93\xde\xa9\x77\xbb\x2c\x18\x62\x9f\x47\xff\x31\xc8\xb0\x04\x16\xab\x28\x5a\x2d\x80\xe3\xec\x06\x35\xbe\x99\xf2\xcc\x3b\x25\xd0\x29\x16\x26\x4e\xbe\xae\xd2\x24\x18\x45\x2e\x1f\x15\xe8\xcf\x41\xb1\xcb\x46\x60\x56\x8d\x6c\xbf\xec\x92\x46\x0c\xfe\x99\x65\x81\xf1\x5f\x19\x85\x55\x6b\x56\xb2\xe0\x14\x94\x34\x0e\x05\x06\x14\xd1\x38\x1b\xd1\xd8\x8b\xdc\x1f\x8c\x8e\x96\xeb\x4c\x26\x0d\x5a\x2f\x49\x32\x02\xa7\xd1\xe9\x71\x5b\xa4\x11\x31\x56\x6e\x8d\xb1\xd6\x11\x31\x9d\xb9\x25\x66\x61\x35\x3a\x0e\xa9\x3e\x34\x0d\x93\xde\x25\x98\x94\x36\x30\x29\x4a\x2f\x44\x2a\x48\x27\xcf\x2f\x0a\x40\x0e\x54\xa9\xac\x5c\x39\x7c\xe8\x15\x91\xa9\x38\xeb\x7a\x48\xd3\x15\x95\xc3\x14\x66\x0e\x19\x4e\x83\x18\x7c\x42\xeb\x53\x80\x67\xbc\xee\xb7\xf7\xea\x54\xec\x19\x7c\xd7\xb1\x86\xc4\x23\xab\xa3\x5e\x60\xb1\x88\x3a\xad\xa8\x45\x4e\x24\xf6\xcf\x4c\x1d\x31\xc0\x02\x56\x94\x18\x9d\x28\x25\x0b\xba\x8b\x3b\x21\x90\x88\x19\x25\xdc\xf8\x8a\x1d\xec\x26\x58\xa9\xf0\x6b\x8c\x95\x8a\xef\xfe\xa1\x0b\xa3\xa5\xc2\x06\xf0\x38\x92\xab\x78\x1b\xd7\x4f\xc9\xb3\x5a\xab\xd4\x98\xa3\x73\x87\xd4\x77\x9d\x3f\x8b\x6c\xbb\x17\x90\xbd\x93\x8d\xac\xbb\x09\xd1\x70\x80\xa2\x1c\x46\xa3\x90\xc7\x67\x65\x15\x84\x6c\x92\x20\x84\x28\xa3\xc3\xd8\x1e\x0b\x20\xab\x41\x14\x1d\x1c\xa3\x73\xbb\x73\x90\x7d\xcb\xe2\xb6\x9e\x3a\x2b\xd5\xe9\xb6\x55\x4c\x41\xd0\x27\xaf\x34\x12\xb7\xcc\x92\x6a\x23\x60\x78\x48\xd2\xf7\xd6\x81\x0d\x3c\x87\x5b\x0d\xa0\x91\x96\x29\xa5\x80\xce\x66\x77\x0d\x1e\xe3\x05\xfa\x8a\x0f\xf7\x9e\x38\x6d\x59\xb2\xd4\xf1\x82\xd5\x99\xef\xfa\xf3\xf0\x71\x68\x84\x25\x23\x26\x9a\xc1\x4a\x7e\x32\xdd\x1d\xde\xd7\x32\xb7\xe4\x8d\xdd\x20\x00\xca\xe4\x87\x57\x8f\x68\xcb\xae\xef\x5e\xd2\xc3\x8c\x0c\x09\x3f\x7c\x19\x7e\x75\x7d\x2f\xba\x6e\xdb\x9e\x27\x1e\x41\xf6\x8e\x01\xcd\x6f\x15\xc1\x7d\xc8\xa3\x26\x47\x2b\x73\x3d\x7e\x59\x36\x31\x26\x9b\x5e\xcb\xd9\xb8\xfc\xa0\xcc\x98\x98\x96\x98\xdf\x24\x98\xb2\x4d\xc8\x4d\x73\x9b\x34\x1a\x93\x9b\xa1\x2c\x16\x5f\x0b\x46\x93\x74\xa6\x1b\xb0\x69\x57\xca\x19\xd9\xeb\xc9\x78\x26\x31\x62\xe9\x50\x5e\x72\x6e\x8a\xe3\x24\xfb\x15\x9b\x0f\xd9\xae\xea\x1c\x8f\x7c\xf0\xbd\x11\xc6\x83\x7b\xb3\x02\x25\xae\xef\x5e\xf9\xe0\x8b\xf8\xae\x31\x23\xe7\x66\x01\x5d\xcd\xc7\x77\x0f\x69\x61\x40\x23\x3f\xd2\x06\xb8\xdf\x35\x47\x47\x2e\x2c\xeb\x5d\x5e\x5c\xc2\x1c\xf9\x37\x7c\x07\x7e\xac\xdd\xb0\xfd\x3a\xc7\xfa\x5b\x99\xdd\xab\x96\xaf\x58\x41\xd6\x0e\x9e\x22\x6b\x97\x4b\x15\x52\x97\x45\xab\xf3\x29\xca\x2d\xe8\x0d\x82\x41\x0a\xf1\x39\x39\xc5\x45\x0e\x59\x92\x8a\x28\xc1\x8d\x8e\xb1\x7c\x37\xe7\xb6\xd9\xdc\x68\xf9\xb2\xb2\x02\x6d\xb1\x2c\xd6\x10\x35\x5a\x75\xb8\x69\x9f\x1a\x16\x71\x1f\xfe\x7f\xac\x62\x5a\xb8\x20\xb1\x90\xd8\xb3\xca\xff\x9f\xd6\xb2\xe0\xce\xa5\x47\xf6\xbf\xf9\xd7\x8b\xf9\xc0\x5e\x0f\xfc\x13\xa0\xf3\xc1\x07\x9c\x7f\xb5\xa4\x78\x4d\xd1\xbc\xf1\x9a\x62\x99\xbd\x32\xda\x33\xcf\x13\x40\x6b\xea\xcb\xce\x36\x31\x8c\xb2\xae\x05\x21\x65\x5d\x03\x5d\xd7\x35\x07\xaf\x6b\x36\x15\x45\xa6\xa5\x33\x85\xb9\xe4\x76\x5a\x0e\xff\xe5\x0a\x67\x38\x2a\xa5\xe0\xa2\x6b\x8c\xd5\x99\x55\x9d\xfd\xbc\xad\xcf\x5e\x70\x95\x47\xfe\xdf\x7b\x53\xd4\x65\x36\x7a\xe0\x67\x17\x5c\xe6\x53\xc5\xf0\x2c\xfb\x18\x5e\xe8\x0b\xf4\xca\x20\xf8\xf4\xfc\x2f\x52\x3e\x73\x90\xe4\x4a\x9e\x45\x3b\xf9\xac\x92\x5b\x19\x2a\xe1\xb3\x82\x20\xd0\x35\xb7\xf2\x1d\xee\x57\xf4\xf7\xdf\x12\x3c\x85\xb3\x6a\x66\x25\x95\xdf\x8d\x73\x67\x64\x56\x2a\x31\xc1\x57\x90\xb2\xc8\xc1\xf7\x28\x46\x8f\x47\x8b\xaf\x00\x81\x2c\xc8\xb9\x7e\xc9\x89\x1c\x5a\x0f\x8b\xb6\x3f\xcb\x22\x4b\x49\xa9\x86\x20\x47\x4e\x5a\xab\xc7\x48\x52\x4e\x08\xb2\x42\xe2\xaa\xdd\x2e\xe1\x9e\x6a\x29\xc7\xbc\x14\x14\x03\xb0\x0b\x7e\x96\xb8\x75\x2f\xbe\xb1\xf8\xc4\x7f\x91\xb9\xf6\xf5\x3d\xff\x99\x78\xbc\xed\xee\x6d\xf7\x4d\x7e\xf4\xaa\xd9\xa9\xbb\xf7\xbe\xb7\xdb\xbd\xf0\xc7\x1f\xe1\xa7\x70\x1f\x8e\x62\xbe\x75\xe0\xda\xed\xa3\x95\x73\xf2\x36\x44\xef\x7d\x48\xef\x13\x7a\x7d\x94\x20\xd0\x4e\x9b\x4d\x27\xd3\x88\x5e\x27\xc6\xcb\x70\xca\x59\x76\x41\x96\x79\x64\x39\xf1\x9e\x0b\x1c\x93\x89\x90\x3e\x92\x6b\x56\xec\x74\x79\xa0\x24\x25\x24\x6e\xe8\xe8\xaf\xc0\xb3\x37\xfe\xbe\x79\xc9\x4b\xc3\x9e\x19\x79\xf5\xda\x95\xf7\x6d\xdb\x8a\x6f\xa4\x12\x37\x75\xb9\xf4\xe8\x4a\xd8\xb0\xf5\x87\xc5\xbd\x5b\xe7\x0f\xd8\xf3\xe8\xd6\x87\x21\x3a\x8d\x52\x17\x76\x3d\x09\x86\x3a\x3a\xd3\xdf\x26\xe7\x68\xcf\xa8\xe8\xb0\x3b\x9d\x36\xab\xd6\xea\x72\x3b\xad\xed\x31\xa7\x64\xc7\xc6\x8d\x31\x0d\x4e\x5d\x4a\x85\x86\xd3\xb9\x7b\x11\x44\x75\x92\x50\x73\x21\x54\xf5\x15\xdf\x9e\xd9\x38\xfe\x02\xc0\xea\x8a\xe5\x45\x78\x28\x63\xbb\x8f\xd4\x53\xf5\x8d\xba\x28\xbb\x53\x46\x86\xa6\x1d\x79\x86\x2e\x2b\xf2\x78\xac\x04\xea\x75\x44\xcc\x89\xe8\x7b\x56\x67\x07\x72\x27\xcf\x27\xb9\xf4\x49\x4d\x8f\x9c\x9f\x00\x6d\x66\x32\x80\x12\x11\x79\xcc\x83\xd7\x9e\xac\x0b\x57\xf6\x6f\xeb\x97\x42\x4b\xfc\x6d\xe5\xa7\xc8\x29\x82\x97\x1e\xbf\x6b\x74\x5e\x12\x30\x11\x5b\x20\x84\xae\x9b\xd4\xbe\x1a\x0e\x9c\x2f\xc0\xd3\x34\x63\xd1\x38\x1c\x7a\x8b\xde\xe9\x32\xd9\x3a\x62\x26\x0f\x71\xfb\x78\x46\xcb\x32\xcc\x85\x44\x31\xa5\xb1\x52\x57\x7a\xaa\x10\x2a\x11\x2e\x05\xed\x5d\x6d\xb8\x71\x1a\xc2\x15\xff\x68\x3d\xe1\x9f\x5e\xbb\x60\x6e\xda\xf5\xe6\x76\xa4\x7c\x1e\x6f\xbe\x64\x69\x41\xe9\x27\x9f\x53\x6a\xef\xe9\x3e\xc4\x2e\xeb\x13\xcd\xd3\xd8\xed\x7a\x44\x97\x85\xd1\x33\x4e\x87\xc9\xda\x4c\x68\x6a\x8e\x2d\xe3\xd7\xf2\x34\x21\x4c\x41\x9b\x25\x20\xaa\x5d\x36\x49\x27\xca\x6c\x69\xdb\x83\x29\x84\x4b\xc8\x75\xe7\x0a\xe0\x86\x27\xe0\x9f\x8a\xcc\xdd\xba\x3c\xed\xd6\x33\xff\x3c\xfc\x1d\x8b\xda\x13\x4f\xa6\xee\x5f\x8f\x12\xdb\xbd\x7f\x34\xd7\xc4\x32\x1c\x07\x28\xa3\x56\xab\xa3\x90\x23\x61\xd4\xb4\xc7\x8c\x46\xce\xac\x67\x74\x12\x47\xb5\xc7\x38\x89\xb9\xc8\x25\x70\x5a\x76\x4b\x50\x49\xd1\x4a\x12\xc8\xf6\xb9\x07\x49\xd2\xb5\x29\x8e\x11\xeb\x35\xc5\x29\x15\x2b\xf0\x10\xb1\xdf\x47\x44\xf3\x28\x93\x96\x65\x05\xa3\x0e\x00\xce\x64\xe2\x90\x0b\x81\xa1\x8f\xb5\xd9\x5a\xc4\x2d\xad\x16\xe8\x79\x81\x93\x05\xe2\x4a\x1b\xd3\x04\x2a\x79\x2b\x9a\x26\x52\x0a\xda\x8e\xe2\x53\xa7\xd0\xe7\x91\x3c\x6d\xb9\x36\xc5\x25\x24\x47\xe9\x57\xc2\x8a\x3f\x83\xed\xf9\x3e\xc4\x9e\x1f\x10\x15\x74\x66\xbb\x5d\xb4\xda\x6c\xbc\xc8\x8b\x0e\xa7\x0d\xef\x36\x11\xf7\xf7\x35\x1a\x25\x8d\x24\xb7\xc7\x24\x09\xa3\xfe\x65\x5e\x8a\xa6\xa8\x20\xba\x1f\xad\x57\x17\xa3\x9e\x94\x19\x33\xde\x0c\xbb\x7e\xc7\x99\xc5\x9d\xac\xfa\x33\xcf\xc3\xe9\xf4\x1a\x4c\xd3\x48\x44\x93\x93\xc8\xcf\xd0\x68\x9e\x19\x59\xd2\x76\x40\xd3\x06\xbb\xc1\xee\x70\x5a\xb4\xad\xa9\xae\x6e\x94\xcd\x28\x60\x60\x45\xec\x6a\xec\x4e\x22\x92\x76\x65\x8f\x4a\x18\xe9\x82\x52\xa5\xda\xf6\xfe\xa4\xc9\xcf\x5c\x7d\x6a\x21\x31\xef\x81\x53\x31\xf7\x31\xac\xf0\x57\x8a\x69\xaf\xda\xfb\x67\x95\xb8\xc6\x25\x70\x3a\x47\x91\x3e\x5b\xc3\xa2\x76\x3f\x4b\x01\x90\xed\x33\x89\xa2\xe4\x93\x02\xb9\x4e\x23\xcb\xe8\xac\x7e\xcc\x32\xb3\x4e\x07\xbc\x56\x46\x92\x80\xaf\x3d\x06\xa4\x34\x85\xda\x28\xa6\x62\x43\x69\x62\xe4\xc7\xe9\x8a\x1a\x5e\x83\xd6\x2b\x3f\x0c\x1c\x09\xd0\xd2\x6c\xa0\xa0\x96\xe2\x75\x7c\xa1\x4c\xe0\xb3\x42\x8b\x3f\x5b\xea\x2b\xe4\x68\xe3\x17\x60\xfc\x8d\x82\x95\xe5\x6c\xc2\x4d\x60\x38\x12\x39\x66\xca\x8a\xed\xbe\x07\xee\x86\xdd\xc0\x91\x29\x9f\xb8\xb2\x1f\x9d\x7c\x6e\x23\x32\x6e\x4d\x55\xeb\xfc\xfe\xd5\xf5\xe0\x57\xac\xc6\x54\xfa\xd9\x5f\x88\xfd\xdf\x14\x75\xba\x6c\xa2\xdd\x8e\x3b\xcb\x79\x70\x87\x39\xde\xed\xa1\x5d\x06\x06\x68\xc8\xa2\x9b\xec\x62\x73\xcc\x2e\xe3\x56\x73\x32\xa9\xa3\x6b\x8c\xa8\x2d\x2b\x1c\x29\xbc\x5c\xf5\x22\x27\x72\x41\xa4\xd5\x44\x12\x66\x17\xb4\x55\x24\x84\x7f\x2b\xe9\x8a\xb8\xaa\x26\x28\xde\x31\x6d\x63\x06\x26\xd7\xf0\x54\x7f\x06\x7e\xa7\x94\x4f\x91\x5a\x3b\xdd\x20\x20\xa2\xdf\xa2\xd3\x99\xa6\x24\x17\x47\x05\x69\x21\xf3\x2c\x27\x78\xe3\xdc\xd3\xe8\xef\xfb\xe2\xb3\x9c\x5e\xff\x13\x45\xd9\xff\x8e\x8c\xc1\x0f\xa2\xba\xaa\x1e\x8c\x27\x48\x57\xa4\x8e\xf3\xe4\xf3\x97\x27\x9e\x9f\xea\xab\xc5\xd0\x94\x0d\x69\x83\x20\x43\xdb\x53\x85\x7c\xe9\x63\x6c\x4a\x8c\x41\xcd\x38\x89\x2b\xf9\x18\x7a\xdf\xf9\x23\x51\x7d\x4d\x15\x1a\x84\xa1\x6b\xd3\x2a\xf9\x12\xe3\xbc\x44\x6c\x94\x9b\xc8\x7b\x1b\x7a\xc6\x3e\x82\xbf\xfa\x48\x5a\xef\xb7\x1d\x89\xde\x6f\xf4\x7a\xf4\x81\x5f\x31\xe5\xe0\xfc\x37\x51\x9d\x60\x07\x86\x20\x6e\xf4\xa5\x50\x9e\xc4\xbb\x7b\x3a\x81\x77\x47\xaf\x67\x89\xcd\x42\xb3\x39\x21\xc6\x10\xc4\xa8\x77\xea\x24\xd5\xde\x1f\xab\xb8\x71\x16\x1e\xb4\xa4\xe3\x64\x5b\x78\xda\x9d\xec\x0d\xb2\x8a\x9f\x23\xe5\xe3\x7f\x47\x3c\xee\x8f\x04\x57\x45\xcf\xa3\xfc\xd9\x76\x0b\x9a\x4e\xa0\x33\x0f\x92\x78\x7b\xf8\x19\xe9\x78\x7b\x54\x6e\x8e\x81\x41\x9f\xc8\x4b\x63\x40\xd2\x26\x9b\x93\xb0\xc9\x52\x63\xd0\x80\x2a\xc8\x47\x46\x19\x0d\x8a\x3a\x8f\xa1\xd8\x65\x9b\x12\x76\x59\x62\x0c\xf4\x89\x50\x10\x19\x66\x34\x28\xcc\x1c\x83\xf4\xe9\x21\x63\x1c\x52\xc7\xd0\x26\x3e\x61\x2d\x29\x66\xf2\xd0\x27\xc2\x9d\xc7\x20\xf8\xd8\x64\x8c\xe3\xca\x18\x27\x12\x55\x99\xe7\xa2\xfa\x6e\x45\x34\xfe\x50\x69\xfa\x5a\xa2\xbd\x54\x8a\xb1\x1c\x49\xee\xc0\x80\x68\xd0\x89\x36\x3b\xcd\x1b\x5d\x76\x9e\xf5\xb8\x1d\x8c\x1d\xb9\xf9\x26\xbb\xc9\x8e\x0e\x16\x81\x78\x80\xae\xb4\x2c\xb6\xf4\x12\xe6\x54\xee\xaf\x92\xc5\x46\x6a\xe0\xa9\x00\xee\xf9\x93\x34\xaf\xaa\x80\x7f\x35\xf3\x3b\x7c\xe7\xb1\x27\xe0\xa7\xe7\x7f\x84\x5f\xf5\x03\xda\x09\x3f\x5e\xb3\xf6\xc1\x1d\xf5\xc0\x15\xbf\x9c\xeb\x77\x00\x7e\xea\x3b\xbc\xf9\x18\x84\x2f\x1e\x9a\x18\xbf\x76\xda\xbc\x79\xbb\x81\x03\xaf\x0d\x3a\x83\x27\x61\x8c\x5a\x7a\xc4\x85\xfa\xeb\xe8\x06\x03\x3f\xe8\xa3\x58\xb8\xa2\x05\x68\x83\x6a\x0f\xc2\xe4\x1e\x52\xf0\xc7\xa6\xaa\xf8\x63\xf8\xef\xcb\x54\x8b\x58\xb0\xa2\x53\x20\x88\x21\x76\xd3\xff\x5e\x79\xfe\x1c\x4b\x48\x59\x55\x91\xc7\xe3\x50\x72\xd4\x48\x53\x3a\x0b\xc7\x04\x01\xc5\x26\xd9\x9e\x7a\xfe\xa6\x24\xbe\x59\x6a\x5d\x65\x2b\x7a\x3c\x0d\x1c\x99\xeb\x4a\x6a\xc7\xf1\xba\xe2\xde\x35\x9d\xe4\xd3\xe3\xe2\xf1\x1e\xcd\xea\xbc\xae\xa4\x26\x9b\xec\xd1\xd6\x4e\xf2\xe9\x75\x93\x4f\xf8\xd2\x17\x35\xbd\x3e\xdd\xa2\xc4\xd4\x6d\x66\x33\x85\x6c\x3b\x9e\xe2\x1d\x76\x2b\x5a\x4a\xab\xcd\x6a\x63\x74\xa4\x6f\x18\xcb\x18\xdb\x62\x8c\xb5\xcb\xa2\x66\x16\x6b\x83\xb4\x82\x74\x50\x61\xf5\x4b\xd6\x5c\xc6\x4f\xb3\x2b\xe1\x77\xa4\xf6\xfc\x38\x70\x91\x5a\x74\x67\xfc\xff\x3e\x76\xc3\x1c\xf7\x27\x87\xfd\xe0\x73\x3f\xad\x16\x9b\x83\x98\x52\x7c\x7e\xee\x08\x98\x03\xd7\x31\x9b\xe0\xf3\xa0\x5f\xa7\x5a\x73\x11\xd9\xa3\x83\xa2\x21\x19\xd1\x68\x47\xb4\xf2\x94\xcb\x2d\x0b\xc8\x86\x90\xb3\x65\x74\x42\xca\x32\x22\x56\x6a\xc6\x1d\x92\x0d\x5d\x3a\x24\xa7\x8e\xc8\x74\x6a\x55\xd4\xc5\x1c\x80\x21\x50\x7d\x40\x75\xd3\xd8\xb9\xf0\xe4\xf9\xdf\xe1\x49\x60\x86\xb4\x2e\xfe\xf3\xac\x39\x46\x18\x35\xcd\x9a\x35\x73\xb6\x09\xbc\x6c\x9c\x4e\xfb\xd4\xc2\x71\x13\x72\x44\xf3\xce\x4d\x5a\x71\xc7\xba\x95\xf4\x57\xcb\x6f\xbe\x65\x59\x6a\xdd\x52\x72\x41\xfa\xc9\xba\xa2\x66\x16\x2d\x83\x59\x8b\x24\x83\x02\x29\xc9\x50\xd6\x3a\xb9\x6e\xec\xfa\xf4\x75\x63\x19\xca\xe7\x45\xeb\xc6\x32\x39\x99\xb2\x41\x7a\x8e\x90\x3d\xff\xcf\xce\x7a\xc5\xe0\xf3\x4a\x26\x5c\x54\xdd\x59\x36\x08\xce\x2c\x91\xbf\xb8\x32\xc6\x2f\x69\x7b\x3e\xe0\xa7\x1c\xe8\x43\xc1\x4e\xfa\x5b\xe9\x79\x37\x35\xd1\xf3\x8e\xbe\x99\x42\x03\x90\x3d\xc1\xda\x65\xdc\xef\xce\x9e\xb9\x87\x14\x8c\xbe\xa9\x2a\x46\x1f\xd9\x73\x09\xaf\xd2\xe5\xc4\x08\x7d\xae\xcc\x3d\xa4\x3c\x7f\x4e\xe2\xf9\xaa\xee\x52\xa8\xfa\x33\xaa\x77\xda\xf5\xb8\x3e\xdc\x9d\x51\x53\xae\x8c\xb1\x29\x81\x03\x48\xcd\xe0\xd4\x99\x73\x1e\x17\x1a\x82\x06\x59\x99\xbc\x52\xc6\x78\x28\x39\xc6\x40\x30\x3b\xc1\xab\x49\xb2\xaf\xf3\x00\xe9\xf3\x78\x3a\x31\x0f\x7a\x13\xf5\x5b\xe2\x33\x51\xa7\xbf\xcb\x28\xe4\x33\xe4\x3e\x94\xcc\xe5\x13\x65\x2e\xd4\x0f\xc9\xb9\xc4\xf1\x5c\xb4\x52\x97\xb9\x5c\x91\xd4\x09\x7f\x64\xea\x04\x93\xd3\x2e\xe9\xf0\x9f\xa7\x8f\x02\xa8\xdd\xc8\x9e\xc1\xb9\xd2\x3a\xaa\x22\xea\x40\x36\x0c\x85\xac\x66\xbd\x81\x22\xd7\x6e\x8c\x96\x69\x8f\x69\x25\x3e\x2d\xde\x95\x68\x57\xa9\x46\x87\xe4\xc4\x6d\x2f\x4e\x8e\xbe\xfb\xcc\xab\xe4\xb6\x1d\xd9\xeb\xeb\xb9\xbe\xb8\x37\x06\x7a\x36\xce\x89\xd6\x51\xe5\x51\xa7\x56\x87\xe3\x67\x40\x6f\x60\x68\x0e\x99\x9b\x18\x2f\x91\x4f\x8f\x32\x74\x7a\x34\xb6\xc2\x95\xa7\x83\xfb\x1f\x61\x6a\xe3\x5f\x2d\x3b\x45\xae\xd2\x89\xcb\x86\xe6\x49\x30\x97\x08\x6f\x3e\xcf\x94\x57\x24\xe1\x59\x1e\xbd\x03\x49\x78\x76\xe7\x35\x50\x7a\x7b\x61\xde\x9c\xed\xb4\x27\xb2\x3c\x5a\xf2\x89\x4c\xde\x14\x90\xdc\xd1\x7e\x94\x87\x1a\x1d\x2d\xf1\x48\x92\x8b\xd7\xeb\x81\x8b\xd1\x3a\x5c\xac\x37\x4b\xe7\xa1\x3c\x93\x63\x3c\x52\x20\x7a\x8a\x76\x49\x56\x59\xc9\xb6\xa6\xb9\x54\x9a\x50\xb2\xd7\x76\xa7\x12\xe6\xa4\xb2\xc0\xc0\x48\x6a\x8e\x79\x44\x29\x4b\x24\x9e\x6c\x4f\x9c\x07\x5b\xb0\x9a\x39\xa4\x24\x9c\x5f\xf1\xc0\xf6\xb2\xab\xbc\x75\xe1\x5b\x6e\x5a\x4d\x9f\xa3\x07\x7d\x0d\xef\x7f\x03\x96\xed\xde\xfd\xa8\x81\x7f\xd7\xb8\x64\x1c\x1d\x51\xf2\xcf\x11\xad\x98\xd7\x1e\x8c\x7e\xe4\x14\x04\x3b\xa3\xd1\xb8\xed\x14\x67\xb3\x23\x5a\x79\xa7\xcb\x89\x94\x97\x4b\xd0\x64\x6b\x68\x1d\xa3\x71\x69\x5c\x76\x8f\x87\x6e\x8e\x79\x04\xbb\x6c\x91\x8c\x48\xbf\x19\x3b\xe5\x5c\x63\x4d\x9c\x7e\x3d\x95\x41\x77\x22\x49\xbd\x0b\xd1\xc9\x94\xf5\x51\x2b\x37\x12\x9a\xaf\xbb\x26\x99\xba\xfe\xe2\xee\xe7\xb6\x1a\xf8\xe7\x8c\x4b\x66\x27\x72\xd8\x71\x7f\xe4\x0f\x09\x7f\xfb\x45\x03\x48\xff\x72\x4e\xa7\x64\x95\x1c\x06\x8a\xca\x12\xbd\xb2\xe4\x14\x58\xd1\x6e\x65\x44\x89\xd7\x32\xda\x8e\xf4\xac\xf0\x54\xfa\x55\x24\x92\x76\x63\xc8\x61\x6a\x94\xbb\x00\x74\xec\x87\x98\x54\xc4\xcc\x07\xd8\x0f\xb7\xaf\x9b\x37\xaa\x2e\x3c\xa0\xae\xa4\xc7\xcf\x17\x08\x9d\x5d\xd6\xa7\x74\xdd\xca\xbb\xc4\x8f\x8c\x45\x25\xa5\xd3\x27\x82\xab\xd2\x43\x68\xf1\xff\xbb\xec\x66\xcc\x63\x8c\xbb\x7f\x3f\xe1\x71\xbf\x68\x90\xa5\x79\xca\xaa\x73\xb9\xb4\xe8\xcc\x60\x68\xcc\x64\x1d\x43\xb1\x34\x6b\xb3\x8b\xf6\xd6\x98\xe8\xd1\xb0\x6a\xdb\xf7\xc6\x64\xfa\x5d\xca\x52\x51\xd8\xa8\x4b\x84\xd0\x80\xd5\x47\xcb\xe9\xc4\x87\xe8\x29\xf0\x4f\xf8\x31\xb8\x07\x2e\x01\xe1\x53\x27\x41\x39\x5c\x72\xbc\xb9\x3e\xf4\xd0\xdd\x1d\x68\x0a\xfd\x2a\x86\x76\x8a\xab\xbd\x36\x7b\xea\x15\xd5\xb7\xae\x47\xd4\x57\xf6\xa8\xbe\x3c\x23\xaf\x4d\xa4\xc6\x46\x4b\xf4\x26\x0d\x0b\x44\x9a\x11\x2c\x3a\x9e\x65\x4d\x16\x46\x30\x08\x92\xc1\x6a\x12\x05\x96\xa2\xf5\x22\x25\x4e\x8e\x69\x28\x8a\x36\x0a\x12\xd7\x25\x6d\xb0\x36\x09\xfd\x81\xa6\x20\xa5\x47\x67\x71\x48\x14\xc3\x51\x23\xf1\x55\x5f\x5c\x09\x74\xf0\x89\x24\x53\xb7\x03\x09\x7e\x04\x1e\x84\x6f\xa9\xb1\xca\x7b\xe0\x17\x4c\x94\xe6\x08\x4f\xcf\xbe\x1d\xbf\x85\xc4\x29\x71\x5d\xb3\xda\x0b\x00\xd1\x3a\x22\x5a\x44\x03\x8b\x46\xaf\x67\x4d\x3a\x93\x45\x64\x05\x1e\x5f\x33\xa7\x11\x3a\x42\x25\x54\xe6\x70\xd2\x5b\x57\x42\x3b\x67\x5f\x57\x28\x64\x7a\x32\xc8\x5c\x08\x58\x78\x50\xe5\xeb\xeb\x40\x0f\xff\x0b\x86\xc3\xf7\x90\x29\x81\x39\x3e\x0c\x9e\xa3\xef\x02\x0f\x61\xc6\xc2\x71\x6f\xc3\x1a\xcc\x69\xf0\xa6\x92\x9f\x82\xac\x26\xb6\xaf\xda\x0f\xac\x32\xea\x36\x52\xac\x20\x68\x28\x0d\xb2\x67\x90\x35\xc3\xe0\xd6\x3c\xe6\x36\xa4\x2f\x39\x86\xba\x20\xac\x26\x22\xa5\x32\xaf\x9e\xdc\xf5\xe5\x96\x82\xa0\xcd\x8f\x94\x5b\x4e\x05\xb0\x9f\xfd\x0c\x84\xa0\xfc\xe8\x99\xeb\x41\x11\x10\xf6\x3c\x06\x7f\x00\xdb\x5f\x3b\x42\xeb\xce\x3c\x3f\x7d\xff\xa2\xe7\xc1\x3c\x45\x77\x75\xa0\x33\xa7\x17\xf1\xe7\x06\x10\x5a\x84\xf3\xdf\x11\x7c\x52\x3d\x15\xc4\x55\x15\x94\xc3\xc6\xf3\xa2\xc7\x27\xfa\xf2\x43\x7e\x57\x47\xcc\x6f\xb5\x6a\x27\xc7\xbc\x56\xaf\xd5\x2c\x33\x06\xc6\x8c\xac\x69\x73\xb2\x3f\x9d\x12\xea\x49\xbb\x27\x4a\x46\x52\x49\xc5\x7f\x4f\x5c\xd0\xab\xde\x40\x58\xfc\x98\x74\x4b\xa4\xc2\x05\x30\x82\x51\x20\xb7\x94\x8e\xd7\x37\xf6\x1f\x39\x31\x36\x09\xd4\xd4\x5f\xde\x74\xc7\x46\xf0\xcc\xd0\x13\x13\x27\xfd\xb8\x65\xc7\xc8\xe9\x0d\xd9\xe0\xd1\x25\x73\xee\xb8\xe6\x8d\x85\xf0\xbe\x4b\x07\x7d\xf9\x1e\xd8\x02\x7e\x3b\xb7\x08\x9e\x07\x00\x2c\x81\xb7\xfc\xf1\x7d\x51\x4f\xa5\x47\xab\x15\xcd\xe5\x2d\xee\x1d\xca\x4f\x95\xe2\x8c\x91\x02\x49\x30\x9b\x72\x73\x79\xa7\x87\xf7\x84\xcb\x7c\x72\x6b\xcc\x67\xb7\x50\x2e\x17\x32\xbc\x82\xd8\xf0\xa2\x8a\x99\x62\xd5\xf4\x4a\x4f\xee\x69\xcc\x24\x5f\x89\x88\x92\xb0\x0f\x41\x26\xb1\x3b\x22\x55\x21\x31\x92\x98\x92\xa2\xaa\x4a\x41\x1a\x5e\x49\x03\xa0\x3b\x8a\xd6\x4f\x5a\xbb\xe9\x81\xf5\x63\x6f\xc8\x03\xe0\x04\x5d\xd8\x2d\x5c\xf2\xf5\x3d\x5b\x47\x5d\x3e\xa0\x61\xfc\xe8\xe1\x83\xfb\xb7\x44\x5a\xc2\x6f\x4f\xbd\x16\x64\x03\x0b\xb0\x02\x5f\x7b\x9b\xaf\x1d\xbc\x72\xf6\xd7\x3b\x2f\x5f\x72\xc3\x4f\xdf\xfc\x78\xb2\x68\x38\x38\xf4\xf0\x73\x8f\x1d\xdc\xf7\xec\xb8\x47\x49\x5c\x1b\xad\xc9\x9b\x5c\x8c\x2a\xc2\x88\xb1\x79\x82\xdf\x26\xd8\xd0\x79\xe0\xe1\x8a\xbb\xe5\x09\x16\x0b\xb2\x7d\x2d\x8c\xdb\xcd\x58\x18\xad\xcf\xe7\xe8\x88\xf9\x58\x2d\xd5\x91\x84\x38\x4d\x05\x05\x32\xca\x08\x12\x59\x25\xc1\xe4\x02\xe0\x82\xeb\x34\xac\xb5\xf4\x94\x79\x1f\x70\xf8\x68\x66\x19\x5e\x8c\xad\xf7\x99\xb8\xa1\x97\x84\xfd\xfd\x47\xf6\xaa\xe9\x3f\xd2\xf7\x45\xf8\xe0\x83\x7b\x5f\x9c\x36\x6d\xfe\x65\x3a\xad\x1c\x78\x29\xb1\x20\x2f\x9f\x98\x38\xec\xdf\x33\xc7\x0f\x6a\x9d\x32\x27\xb2\xff\x85\xdd\x8f\xcf\xdb\x92\xe7\x5c\x70\xd5\x35\xe3\x4b\xd5\x3c\x8e\xf3\x3f\xb0\xcf\x90\x9e\x47\x2d\x51\x44\x95\x44\x99\x59\x8f\xcf\xc7\x52\x3a\x36\x54\x20\x52\x00\x50\x2d\x31\xe0\xd5\x6a\xbd\x80\xf1\x1b\xfc\xce\xd6\x98\xdf\x6e\xe0\x5b\x62\x06\xcb\xc5\x66\x94\x01\xc5\x4d\x72\xfe\x03\xb9\x9a\x90\xe4\x4f\x26\xfc\x3b\xd4\x2e\xe8\x89\x73\xa5\x14\x80\xc0\x75\x93\xae\x59\xe6\xf9\x29\x02\x2e\x7d\xfc\xe0\x92\x45\x4b\x97\x09\x62\xb0\xa8\x30\xf4\xf5\xba\xad\x8f\x6c\xf2\xd9\x2e\x03\x9f\xec\xee\x39\x66\xd9\x3a\x3b\x28\xb9\x67\x05\xce\xed\x37\x4e\x1e\x77\xc9\x90\x05\x37\xa3\xc5\x39\x75\xf3\xc3\x97\x0f\x53\x63\xfd\x6f\xa1\x35\xf1\x23\x3d\x18\xcc\xf6\x39\x65\x9d\xd7\xef\x47\x9e\x87\xe0\xf3\x09\x81\x5c\x27\xcb\x71\x6c\x5b\x8c\x33\x73\x66\xbf\xe4\xf7\xb6\xc7\xfc\x52\x36\xbe\x2c\x94\x8c\x1d\x31\x89\x4d\xde\x3e\xa7\x3c\x93\xc4\xca\x64\xd4\xb5\x74\x02\xbf\x4b\x2b\xe5\xc8\x52\x52\xff\x99\x3a\xe4\x6a\xd6\xdf\xbb\x6e\xd1\xac\x23\x43\xe1\xaf\xfd\x81\xfc\x8f\xe3\xc0\x79\xdb\xcd\x77\x3d\x3c\xf7\xcc\x3d\xa0\xfd\xd2\xd8\xbf\xdb\xa7\x8c\x6f\xff\xa3\xe7\xbb\x07\x0e\x3d\x72\xdd\x63\x01\xfb\xce\x55\xed\xc9\x3b\xf3\xf9\x88\x7e\xdc\xcb\xc1\x8f\x6d\x10\x97\xdb\xcd\xd9\x75\x3e\xe0\xcf\xc9\x01\x3a\xce\xc2\xe5\x06\x5c\xc8\x64\xe3\x5a\x62\xbc\xc0\x0b\xc0\x6a\x35\xb6\xc4\xac\x16\x3f\x00\xbe\x0c\xc3\xaa\x33\xf9\xe9\xc5\x18\xca\xc5\xd9\x45\x2b\x30\x08\xfd\xcc\x84\xcd\xab\xb6\x24\xa0\xe2\x5c\xc7\x9f\xd9\xfb\xcf\x25\x8b\x96\xdc\xbd\xe0\x14\xa8\x51\x8b\x2b\x86\xf5\xb1\xdf\xb9\xe1\xfe\xa5\x78\x01\x4c\xb7\xce\xbc\x12\x99\x68\x80\x02\x68\x2f\x1c\x42\xfa\x29\x80\x73\x70\x28\x41\x70\xf3\x3a\x5d\x5e\xd0\xad\xd1\x38\x72\x73\xc5\xf6\x58\x2e\xe3\xc8\x6a\x8f\x39\xac\xe4\x66\x34\xad\xa1\xab\xba\xb7\x41\x86\x95\xa9\xf4\x60\x10\x55\xf9\x77\x81\x00\x43\x13\x20\x3b\x15\x97\x08\x87\x7e\x2a\x0b\x8a\x4b\x42\x3f\xae\x7f\xf8\xd1\x3b\xda\x43\x79\xe1\x7e\xb3\xc6\x90\xd0\x44\xa4\x7b\xa9\xbf\x96\x16\xc1\xcb\x77\x5e\x3e\x7f\x0d\x16\xf9\xb3\xdf\x7c\x0a\xb4\xf4\x6a\xb8\x0a\x6e\xfb\x72\x41\x25\x0e\x52\x4c\xf8\x06\x78\xc1\x1f\x8a\xbc\x03\xa4\x97\x5e\x26\x31\x9e\x1e\x51\x9f\x98\xe3\x70\xe7\xb8\xfd\xb9\x4e\x27\x2f\x08\x00\xa3\xcc\x67\xd9\x5a\x63\x59\x3c\x8f\xdc\x40\x5e\xd5\x45\xe9\x10\x1b\x09\x3d\x8f\xc3\x26\x4a\xff\xa6\x54\x54\x22\x43\x07\xe5\x57\xd1\x03\xc6\xe4\xd5\xf6\x9e\xdc\xd1\x5a\xef\x2a\xae\xad\x2b\xaf\xa3\xb5\xaa\xe2\x79\xf4\x1e\x66\x31\xdc\x0f\x9f\xda\x3b\xcc\xf4\x92\xee\x32\x90\x4d\x33\xf1\x55\x09\x65\xf3\xcf\xdf\x94\x7c\x56\xc4\xd7\x65\x24\x56\x81\x7d\x6b\x8b\x45\xa6\x4c\x26\x91\xd5\x88\x1a\xa7\xcb\x26\xb4\xc7\x6c\x9c\x8d\x13\xed\x12\x32\x9a\xf4\x74\x47\x4c\x6f\xa5\xd2\x13\x8a\xba\x66\x40\x83\x34\xcd\x9e\x2f\x56\x25\x91\xe5\xe9\x4f\x89\x4a\x7f\x62\xfd\xf3\x3f\xfc\xf0\xfc\x09\xf0\x72\x4a\x87\xff\x13\x30\x57\x27\xaf\xe2\x55\x9c\xe4\xeb\x09\x8e\xf7\xb0\x68\x21\x90\xd1\xb9\x6c\xb5\xda\xf5\x26\xbb\xc9\xe9\x02\xb6\x54\x5a\xb2\x01\x18\xec\x8c\x43\xc0\xf7\xa1\xad\x31\xc1\x9e\x41\x56\x9a\x17\x9d\x46\x99\xa8\x1e\x3c\x84\x6f\x16\x7f\x6e\x3e\x31\x30\x45\x50\x76\xe0\xeb\xb6\xf2\xaa\xaf\xe1\xfe\x27\x37\x1e\xf8\x46\xb9\x87\x8f\xaf\x82\xe7\x6f\x58\xf2\xd3\x37\x30\xef\xcb\xd3\x22\xbe\x9c\x57\x7b\xe7\x4e\x27\xbd\x73\x8b\x92\xf7\x18\x43\xf0\x3d\x21\x1d\x20\x7c\x34\xa1\xf7\x9b\x49\x6e\x44\x7d\x34\x4b\x02\xc0\x64\x12\x38\xad\xa0\xb5\xda\x28\x01\x6b\x6a\x9e\xd7\xe3\x68\x4b\x8a\x85\x99\x55\x93\xa9\xae\x40\x84\x81\x7e\x11\x13\x58\xa5\xe4\xfc\x5d\xb1\xe6\x56\xe0\x84\xe3\x8e\x7d\x04\x0f\x30\x9b\xd8\x8e\x78\x5b\x82\x79\x30\xef\xdb\xdf\xe9\xf5\x24\x01\x50\xe9\x0f\xb6\x92\xdc\xcf\xf7\x88\x66\x19\xcc\x34\xcb\xda\x6d\x66\x9b\xd3\x61\x34\x22\x2b\x47\xdb\x8a\xeb\x84\xed\x94\x3d\xbd\x5d\x54\xa6\xa0\x25\x2b\x79\x90\x19\x6e\x53\xd5\x66\x02\xda\x44\x0c\x48\x0c\xf5\x9f\xec\x7e\x3d\xc6\xb5\x00\xcf\x91\x6f\x4e\x7e\xf2\x1f\x6c\x82\xf7\x9d\x79\x69\xf9\xbc\xdb\x7e\xfa\xe6\xb7\xe3\xff\x82\x60\x2f\xe6\xc9\x60\x44\xc3\x7a\x2e\x26\xf1\xa0\x95\xf0\x68\x05\x7a\x3f\x9b\xf0\xc8\x4b\x29\x71\xc4\x31\xa4\x17\x73\x36\xe2\x91\x0f\xb8\x5c\xd9\xd9\x56\xab\xce\x9f\xe3\xf6\xda\x91\xa6\xb4\x7b\x2e\xdc\x92\xb9\x13\xdc\xde\x85\xa3\x88\x29\xb7\xa1\xba\xea\x42\xc1\xc4\xb5\x0f\x07\xaf\x0c\xf4\xf5\xf5\xac\xba\x50\xa7\xe6\x1b\x5e\x7f\xc2\xa8\xfd\xd6\x34\x6c\x38\xe1\xa3\x1a\x27\xcb\xc6\x71\x59\xca\xe9\xf4\xf9\x24\x49\xeb\xcf\x71\x79\x64\x4f\x6b\x4c\xf6\x58\xa8\xe6\x98\x45\xd0\x1b\x49\x5c\xd6\x9e\x81\xe7\xd6\x85\xce\xce\xb1\xc4\x74\x22\x45\x3a\xd2\x39\xa6\x78\xf6\x9e\xcd\x0a\x91\x35\x5d\x22\x8b\x67\x1f\x7a\xf7\x79\xa3\xf6\x43\x53\x53\x13\xb3\x0b\xdf\xdf\xc0\xd9\xec\x3a\x22\x8b\x95\x8a\x2d\x87\x68\xee\x45\xfa\x67\x8c\x4c\xde\x69\xbf\x43\xee\xb4\xeb\xc8\x7b\xe4\x00\xb1\xaf\x92\xde\x58\xe3\xf0\x3a\x80\x47\xe0\x32\x26\x70\xfe\x6d\xca\x46\xf9\xa3\x56\x91\x33\x9b\xf5\xc7\xd0\xe1\x0b\x70\x0b\x9f\x76\xc0\x02\x0b\x15\x7e\x67\xe2\xc4\x0a\x9c\x43\x89\xb9\xad\xe8\x71\x82\x44\x5b\x5d\x53\x15\xc1\x75\x74\x4c\x60\x5a\x7e\x59\x24\x34\xa5\xf7\x80\x69\x03\xfb\xc0\x65\xe1\xea\xd2\xd2\xea\x70\xf9\xa8\x89\x86\x49\x93\x0c\x13\x47\xe1\xfb\x30\xb0\x8d\x6b\x62\x42\xfc\x0b\x68\x6c\x07\xd2\xd9\x05\x51\xbb\xac\xd3\x09\x02\x03\x9e\x64\x7e\x61\xce\x33\x0c\x13\xd5\x99\x06\x32\x1e\xff\x3e\x24\x2a\x8d\x91\x77\x8a\x27\xce\xad\x50\xb6\xa9\x9a\x34\x8d\x59\x55\x93\xf6\x5a\x93\xf6\x1a\x6c\x2b\xcd\xc9\x2d\x2d\xcd\xcd\x29\xfd\x26\xf1\xe2\xca\x12\xf4\xa2\x2c\x27\xa7\x84\xbf\x22\xa7\xa4\x44\xf9\xa5\xf2\xf3\x49\xfc\x1a\xfd\x1b\x9e\xf7\x47\x5c\x13\x7d\x86\x3f\x87\x68\x32\xec\xa6\x78\x32\xf4\x3b\x18\x3a\xc8\x81\xbe\x02\x35\x21\xf4\x45\x9f\xd9\x88\xfe\xb7\x6b\x01\xfe\xbe\x91\x3f\x37\x3a\xf9\x3f\x6c\x67\xd2\x36\xf4\xf9\x67\xd4\x39\xe5\x46\xad\xba\xce\xd3\x11\xe4\xb4\xe9\x64\xce\x25\x9d\x7e\xda\x81\x28\x2b\x0b\x07\x72\x4a\x18\x44\x72\x59\x18\x59\xef\xfc\xec\xdc\x92\x12\x34\x0f\x4c\x2e\xfe\x5d\x29\xe1\xe1\x1e\xc4\x43\x97\x3a\x9e\x07\xf3\xd0\xc5\x38\xff\x7a\xd0\xd7\x2d\xaf\x67\x8e\x2b\xa7\xd3\x80\xe4\x92\xbe\x16\x71\xa6\xac\x0c\x73\x26\xc7\x1f\xc6\xac\x3b\x74\x45\x6a\x70\x85\x98\xd2\x52\x70\x39\xbc\x03\xf1\xeb\x35\x24\x27\xfa\xf3\x4f\x50\x1a\xca\xfc\x0c\xc5\x5a\x90\x33\x4a\x61\xd1\xc0\x8e\xb1\x3d\x22\xe3\x83\xa7\xfc\xca\x69\x0f\xec\x6c\x1d\x3f\x63\xc6\x96\xdb\xd0\xdf\xbf\xc7\x8d\xa5\x21\xff\x08\xc5\x20\xfe\x32\x80\x90\x75\x18\xf3\x17\xf1\x15\xde\x77\xef\xbd\x3c\xf5\xc8\x23\x8f\xe0\x75\xa8\xe7\x9a\x99\xdb\xf9\x15\xc8\x06\xc9\x89\x9a\x44\x2f\x65\xf0\xa2\x2f\xc1\x01\x1c\xea\x9a\x4c\x54\x6e\x38\x94\x1a\x5f\x64\x5b\x3b\x34\xf9\x55\x09\x38\x20\xc5\x9d\xad\xb1\xa7\x2c\xba\xb7\xbd\xf9\x75\x9e\xd9\xad\xbd\x2b\x46\x96\x16\xd4\xe4\xe0\x37\xb3\x5a\x1a\x2a\x9a\xab\x4b\xcb\xf9\xda\xfc\x60\xd4\x3e\x30\xff\x9a\x5e\xad\xf5\x7d\x6b\xc3\xe4\x4d\xc1\xd5\xbd\x5a\x2b\x87\x34\x16\x62\x3a\x5e\x43\xfc\xd5\xf3\xcb\xd0\xfc\xc4\x67\x04\x36\x1b\xcf\x4f\x25\x40\x69\x5a\x5b\x85\x38\x47\x6f\x9c\x3b\xfd\xfe\xc7\xb8\xa6\x09\xd3\x67\x6f\xbe\x1d\x7d\xe6\x00\xe2\x09\x7f\xfe\x38\xc5\x51\xda\xdd\x80\x45\xec\xc0\x5b\x24\x54\x13\xd1\x30\xfc\xda\x3d\x7b\xd6\xee\x81\xcb\xf6\xee\xdd\x4b\xd1\x60\x17\xfa\xbb\xac\xf3\xa7\xd1\xb3\xad\x94\xf4\xac\x46\x13\x65\x00\x23\x1a\xa8\x70\x04\xcd\x2e\xac\x5c\x2d\x60\x1b\x89\x4b\x5b\x1f\x26\x6b\xe7\xa6\x69\x57\x9d\xa7\x12\x2b\xd3\x7a\xeb\xd6\x19\x97\x4d\x30\xaa\x8b\xd2\x99\x5e\x26\x9b\x41\xbe\xb5\xc2\xe4\x89\xca\xa2\x63\x8c\x35\xf0\xda\xa3\x1b\xa7\x5d\xc9\x35\xad\xdb\x32\x7b\xfa\x84\xf3\xe7\x13\x9f\xb1\xf0\xec\x47\x58\x86\x41\x36\x7a\xff\x04\x79\x86\x40\xd9\xa3\x3a\x83\xf2\x1c\xad\xf2\xa0\x8a\xc3\x13\x2b\x52\x8f\xf2\xab\x3f\xe9\xa9\x8f\x6d\x9c\x3a\x0f\x0e\x56\x1e\xbc\x76\xeb\xec\x4b\xdb\xc8\xd3\xb1\x9a\xa1\x26\x70\xf5\xec\x5c\x4d\x21\x85\xb3\xbd\x8b\xa9\x1a\xa4\x51\x2c\x2e\x86\x09\x87\x0b\x41\xa1\xb5\xaa\x4a\xd7\x1c\x00\x01\x2a\x3c\x11\x1f\x2f\xaf\x4f\xec\xb2\xc5\x43\x48\x34\xf2\x6b\xd2\x5a\x62\x71\x49\x40\x0a\x65\xc1\x35\xe9\x68\x90\xaf\x2c\x8d\xc5\x96\x2f\x1d\x5f\x5f\x3a\xb6\x75\xac\xf7\x9a\x9a\x82\x82\xba\x1e\xf9\xc1\x3a\xf8\x91\x17\xbd\x0f\xd7\x4d\x58\xb2\x74\x7c\x6c\xe9\xb5\x75\x79\xf9\x3d\xea\x0a\xf2\xbb\xf3\xad\xb1\xa5\x4b\xc6\x8d\x5b\xe2\x1c\x3b\x72\x6c\x59\x7d\x41\xf7\xda\x50\xa8\xb6\x7b\x41\x7d\x19\x7a\xeb\x5c\x32\x2e\xb6\x74\x69\xac\xa0\x7b\x5d\x3e\xfa\x1d\xe2\xc9\x5c\xae\x9e\x99\xa0\xce\x41\x8e\xea\x5d\x61\xb4\x56\xd6\x66\x1d\xd0\x61\xca\x5f\x9f\x58\xf1\xd7\x34\x83\x27\x10\x5d\x4b\x17\x8f\xaf\x2b\x1b\x3d\x72\xac\x67\x41\xf7\x02\xfc\xe0\xfc\x3a\x4c\x00\xfe\x07\x4c\x40\xb7\xc6\x82\xee\xf8\xf7\xdd\x89\x5d\x08\x5e\x41\x6b\x60\xe4\x37\xe0\x48\x01\xda\xc2\x2c\xab\x13\x30\x80\xaa\x2a\x7a\x58\xef\xe2\x1b\x31\x32\x16\xb9\x13\x53\x8c\x3d\xc6\x38\x66\x4c\xae\x63\xca\x14\xbd\xbf\x2c\x9f\xdf\x50\x31\x76\xaa\x7e\x2a\x18\x7a\xb3\xb1\xa4\xa6\x22\x43\xa7\x5b\xb1\x4e\xa7\xcd\x1c\x77\x8c\x45\x0e\x64\x94\x6d\x66\xdb\x59\x96\x95\xf4\x44\xf2\x26\x2a\x3a\x1d\x71\x59\x0e\x54\x95\x02\x62\x41\xaa\xa6\x24\x13\xb8\x65\x5a\x53\xfd\x94\x50\xa4\x2c\x7f\xda\xd4\x9d\xf2\x84\x09\xa6\x29\x4d\xe5\xe5\x55\x65\x65\x55\xe5\xe4\xf9\xaf\xc1\x6d\x48\x17\xfc\x13\xc9\xbd\xf9\x69\x06\xf1\x8c\x26\xaa\x00\x67\x95\xe1\x74\xfa\x2a\x46\x0f\xff\xfe\x79\x00\x1e\x9a\xf1\x9e\xba\x47\xb4\x17\xdc\x23\xda\xb5\x7b\xf7\xae\xdd\xab\xec\x91\x74\xfd\x62\x79\x96\xc5\x08\xcd\x48\xa0\xa9\x30\x91\xc1\xc4\xfe\x60\xf4\x58\xea\x5a\xd7\x6e\x9e\x31\x63\xbc\x22\xbf\xe8\x33\x4f\x90\xcf\x08\x94\x2b\x6a\x34\xb2\xac\x41\xf9\xa4\x80\x3e\x8a\xe5\xb7\x22\x71\x73\x87\x3f\xee\x57\x7f\xd2\x53\xf1\x63\xc0\x33\x8f\x3e\x90\x78\x18\xfa\x36\x73\x1c\xa2\xe1\x4d\xf4\x3c\xfa\xfc\x9f\xe8\x79\xc6\xbd\x51\x64\x57\x71\x8a\x86\x03\x5c\x55\x4d\x28\x28\x6b\x18\x1a\xfe\xfb\xb6\x9d\xc0\xb7\x16\xee\x89\x34\xdb\xbf\x8c\x0c\x75\x65\xec\xa9\xf7\x09\x4d\x9d\xe4\xc7\x1a\x36\x01\x93\xab\x59\x03\x34\x29\xf9\xf9\x0b\xb9\x66\xb2\x3d\x63\x47\x8e\xae\xe8\x3e\x7e\xf1\xd2\xd8\x98\xe5\x0b\x90\x50\xd6\x75\x2f\x2c\x40\x02\xdc\xd8\x0d\x0b\x2b\x96\x21\x2c\xac\xb5\x21\x45\x7e\xd0\xf8\xea\x5a\xa3\xf1\x8f\x92\xb5\x39\x80\xe8\xd1\xf2\xcf\x20\x7e\x1b\x76\xb3\x20\x79\xae\xa5\xb3\x9c\x6b\xc2\x2c\x4f\xea\x90\x1b\xd1\xdf\x8a\x4f\x63\xb1\x63\x68\xf5\xf8\x98\x48\xea\xf7\x12\x4b\xc9\xdf\x88\xd7\x12\xcf\x55\x59\x23\x34\xd6\x61\x32\xb6\xaa\xbb\xd1\xfb\xf7\xc8\xdc\xd7\x72\x8b\x98\x9e\x68\xee\xf8\x8c\xb2\x3c\x23\xe3\xad\x23\xe8\x88\xb0\x75\x3a\x01\x33\xb6\xcc\x5a\x65\xcb\x8c\x5f\x8c\xb6\x4b\x61\xf7\xba\x50\x6a\xbb\xe0\xa9\x2a\x5b\x85\xa6\x1d\x70\x19\xfd\xcc\xf9\x9f\xc9\xb3\x1d\x18\x89\x4f\x06\x51\x79\xb3\x4c\xcb\x3a\x86\x8c\x80\x0f\x59\xee\x22\x87\x1d\xed\x08\x2b\x26\x41\x18\x1d\x6d\x58\x83\x96\x4c\x26\x6f\xc9\x29\x97\x38\x62\x29\x0e\xd4\xa2\xf9\xdd\xa9\x8e\x81\x34\x15\x55\x4f\x85\xa2\x72\xc4\xe3\xa9\xa5\xfc\x20\xea\xdf\xec\xa7\xfd\x25\xb2\x4e\x08\xe9\x18\x34\x24\xc1\x74\x7b\x27\x61\xaa\x70\xff\x83\xa9\x12\xbc\x98\x09\x53\x9b\xb0\x5c\xbe\x45\x2f\xc8\xe9\x3b\xaf\x54\xa1\xb7\x14\x0c\x4e\xfc\x8a\x2e\xcb\xf1\x97\xe2\x69\xb4\x23\xb2\xd5\xbf\x2f\x4d\x37\x6a\x7e\x51\x7f\x47\xac\x06\x7c\x46\x30\x60\x34\x9a\xcf\x7c\x34\x1f\x86\x48\x63\x56\x14\xad\x31\xb0\x52\x2e\x10\x75\x6d\x76\xd1\x2e\x93\x46\x65\x1c\x51\x32\x1c\x72\x2f\x6a\x2e\xc2\x3f\x30\x1a\x0c\xac\x21\x83\xa4\xd9\x0a\x5b\x67\xcf\x8e\xa6\xb8\xa8\x1c\x4b\x69\x63\xe2\xb3\x2e\x1b\xe9\x1f\x11\xe7\xbc\x31\x0e\x2a\x0b\x44\xb3\x36\x67\xd1\x59\xea\xb9\x47\x46\x55\xee\x6a\x02\x68\xe4\xc0\xc5\xc7\x3e\x70\x05\x18\x38\x73\x6b\xe7\xd1\xe1\x8f\x57\xce\x9e\x7d\xe5\x9e\xce\x04\x00\x24\x27\xdb\x90\x9c\xf4\x46\x6b\xa8\xdd\x4d\x44\x23\x53\xf2\x52\xa2\x00\x4f\xab\x1f\x26\xf7\xaf\x60\x1b\xd2\x69\x85\xe7\xfb\x92\xb5\x37\xef\xc5\x06\x2a\xfe\x70\xe4\xaf\xec\x50\xb0\x2d\x61\xb2\x1d\x4f\x92\xf5\xab\x6a\xb3\xe5\x26\x59\x82\xed\x5f\xc4\x93\xc2\xa4\x5c\xa1\x75\xf0\x24\x05\x2a\x6d\xa0\xae\x32\xfc\x17\x46\x6f\xae\x32\xce\xf1\x84\xa0\x5c\x15\x26\xa4\xe4\x84\x15\xc9\x56\x06\xc7\x7f\xf4\x24\x16\x13\x22\xe1\x68\xbf\x9f\x77\xa1\xfd\xbb\x02\xc9\x83\x71\x2f\xa3\x41\x0a\x0e\xeb\x24\x34\x24\xbe\xbd\x7e\x0d\x0c\x80\x7f\x5f\x32\x23\x4d\xbf\xaf\x40\x6b\xc8\xef\xa2\xa9\x70\x6a\x91\xe8\xf2\xcb\xc1\x80\x19\x70\xdb\xfc\x19\x18\x33\x94\x76\x70\x4e\xfa\x19\x6e\x1f\x9e\x57\xd4\xcc\x0c\xd7\x2d\xd3\x3d\xa8\x7b\x4f\xc7\x52\xca\x69\x39\xf1\x02\xac\x57\x68\xe4\xa6\x67\x97\x2b\xdb\x0e\x3f\xe3\x21\x64\x47\xf7\x27\x76\x38\xa3\xdb\x07\x46\x20\xfd\x73\xd1\xcf\xfd\x9e\xf8\x1c\x03\x16\x20\x9e\x8e\x3c\x7f\x52\xe5\xa9\x27\x6a\x92\x05\xc1\xe3\x51\x98\xaa\xaa\x84\x0a\x49\x91\xec\xb4\x67\x39\x2e\xf2\x1a\x2c\x48\xec\xb3\x07\x12\xdc\xdb\x9c\x78\xd1\xae\x6e\xac\x41\x8a\xae\x28\x1b\x98\x32\xcb\x31\xfd\xf4\x5c\xfa\x19\xc6\x8c\xe8\x30\x3f\xc3\x50\xba\x32\x1d\xad\x53\xb8\xda\x75\x0a\x58\xea\xe8\xfd\x81\x92\x12\x64\xed\x97\xe0\xcf\x86\x91\xac\x6e\x22\xeb\xa1\xdd\x4d\xd1\x8a\xac\x22\xa7\x8a\x0e\x5f\x01\xb7\x1d\x3b\xa6\xd8\x07\x03\xd9\x6b\x99\x15\xdc\x50\xf4\x37\xe2\xd3\x34\xc3\xa1\xa3\x91\x0a\x2b\xbe\x25\xce\xbc\x44\x0b\x37\x10\x83\xf1\x70\x43\x3f\x22\xfa\x7c\x00\xa3\xe7\x76\xa3\x3f\xb1\x3c\x4b\x21\xed\xab\x45\x0a\x38\xb1\x10\xc9\x35\xe6\x76\xcf\xc0\x63\xbb\x60\x3b\xbd\x47\xf3\x09\xfa\x5b\xeb\x33\x14\xc3\xb0\x1c\x40\x67\x66\x58\x49\x1e\x53\x6e\x48\x68\xd7\x7a\xd8\xae\x5b\xf0\xfb\x6a\x65\x9e\x5c\x2f\xb4\xd6\x5f\xa1\x79\x22\xd9\x09\xab\xf6\xd0\x45\x17\xea\xf6\xc4\x42\xa9\x9f\xfd\xff\xb2\xc6\x34\xf8\x18\x6d\xcc\x3f\xd9\x9e\x88\x46\x0d\xd2\x24\x46\xdc\x67\x88\x61\x74\x5a\x4c\xeb\x3e\xd0\x84\x4c\xd4\x83\x15\xc9\xfe\x94\x4a\xcd\x3b\x69\xa4\xfb\x31\x6e\x14\x07\x02\xa0\x1c\xbe\xc7\x18\xf1\x77\x42\x03\xef\x40\x34\x3c\x43\xf4\x02\xa3\xbb\xa0\x5e\x50\x56\x88\x9f\x8a\x09\xc8\xc5\x2b\x44\x3e\x07\x67\x20\x7d\xa2\xfd\x1f\xf4\xc9\xbe\x34\x7d\x02\x70\xeb\x18\xe6\x23\x74\x26\x9b\xa9\x8a\xa8\xde\x60\x36\xf3\x26\xc6\x22\xb0\x9a\x5e\x7a\x30\x92\x8a\x51\x2c\x18\x86\xfe\xc5\x40\x5e\x9b\xf1\x54\xd2\x7b\x77\xe1\x11\x1a\x40\x3d\x90\x95\xc6\x86\x68\xe1\x02\x4d\x8f\xec\x7b\xf3\xc5\xa9\xfd\xc1\xd6\x78\x33\x7d\xf2\xc5\x0f\xc6\x9f\xbe\xea\x59\x58\x7d\x1a\x8f\xb3\x0c\x4e\x66\x86\x9e\xdf\x44\xe9\xd0\x5e\xe5\xf1\x5e\xe5\x02\x0e\x64\xd0\xd5\xa0\x0d\xcb\x0c\xdd\x2b\xad\xb6\xec\x01\x87\xbf\xdf\x2c\xcb\x9b\x6f\x54\xee\x21\x5d\xc8\x50\xdf\x87\xe8\x72\x51\x83\xa3\x3e\xc1\x65\xa6\xcc\xbc\xc6\x48\x9b\x90\x2e\xb0\xda\x6c\x94\xc6\xc4\x7a\xdc\x46\x5a\xc0\xc7\x83\xed\x79\x44\x18\xc6\xdc\x18\x96\xe8\xc4\x4f\x02\x75\x89\x2b\x5e\xb5\x94\x56\xed\x67\x0f\x1a\x40\x23\xf0\x6b\xcc\x34\x01\xa6\xa0\x19\xbf\xb5\x81\xae\x69\x42\x93\x98\x5d\x5a\x6e\xb2\x02\xa3\x4d\x5f\x39\x69\x1a\x68\x82\x87\x60\xa3\xd3\xe3\x1e\x08\x4f\x0e\xca\xab\x6e\x1a\xc8\x1e\x8d\xbf\x57\x71\xff\xea\xcf\x7f\xba\x74\xc3\x2d\x53\x21\x4b\xef\xb5\x44\x57\xc1\x5c\xb0\x69\xef\xad\x23\x03\x88\xd6\xa1\x88\xd6\x65\x88\x56\x81\xaa\x8e\x1a\x0c\x3c\x9a\xa2\x96\x15\x2d\x80\x7a\x9e\xf0\x0d\x80\x61\x4f\xf1\x7a\x9d\x5e\x79\xa7\x23\x5c\x4c\xe6\x72\x2b\x7c\xb4\x56\xf9\x73\x58\x17\xae\xf4\xac\x22\x55\x46\x8b\xc0\x48\x5c\x45\xbd\xf2\xec\x61\x7a\xf3\x8a\x4d\xcc\xf1\xd3\xbf\xc2\x13\x30\x70\xfa\x34\x78\xee\xc9\x35\x68\xbc\x67\xd0\x78\x0e\x34\x9e\x9b\xea\x1e\x15\x4d\x66\x0d\x6f\x76\xd9\x78\xd6\xeb\xd1\xda\x6c\x6e\x8d\x79\x3f\x1a\xc1\x8d\x4e\x4f\x3c\x9a\x1b\x33\x25\xd9\x56\x33\xc9\x14\xdc\x48\xd3\x47\x3b\x30\x42\x07\xa3\xf1\xd7\x34\xd0\x8d\xa0\x14\xe3\xf4\x82\xd7\x2e\x5b\xd8\x1a\x2d\xdd\x0d\xff\x33\xa5\xba\x3c\xe8\xad\x82\x3f\x15\xe6\x0d\x9e\x3f\xad\x39\x2b\xd2\x6b\xf0\x8d\xec\xd1\xfc\x31\x7f\x7b\x29\xce\x83\xfd\x82\xbf\x6e\xc2\x9f\x7b\xb7\x6f\x9c\x98\xed\x5c\xb5\xa1\xe1\x34\x59\xaf\x10\xa2\xe9\x0a\x44\x93\x86\x2a\x89\xea\x70\xf9\x2b\x8f\x76\x00\xb2\xeb\x9a\x9e\xc2\xc5\xbc\xcf\x27\xa5\x29\xd5\xf7\x5d\x99\x3a\xae\x5c\xc0\x3a\x9b\xf9\x18\x9e\x8e\xb7\xb3\x03\x37\xa0\xd9\x9e\x46\x4a\xa6\x19\x3d\x6f\x09\x7a\x1e\xb6\x09\xaa\xb0\x45\xc0\xb1\x7a\xc0\x32\xa2\x85\xa6\x0d\x1c\xc0\x73\x34\x50\x8a\x8c\x1a\xd2\xe7\x98\x36\x45\xfc\x64\x40\xd8\x89\x06\xc8\xb1\x8b\x60\x1e\x3c\x05\x04\x64\x29\x9e\xbe\x7e\x0b\x5a\x43\x23\x08\x9d\xa1\x4f\xc7\xcd\xf4\x07\xeb\x97\x9c\x3e\x0d\xbf\x43\xeb\x84\x54\x19\xfd\x33\x19\xd3\xf5\x34\x43\xd3\x48\x89\x3d\x87\x9e\xcd\xe0\x15\x6b\x4c\x6a\x1c\xdc\x02\xf0\x18\x10\xe0\x29\xf6\xe8\xd9\x90\xb2\x87\x90\xac\x32\x7b\xd9\x33\x94\x89\xaa\x8b\xda\x71\x57\x7f\x23\xb2\xa3\x79\x5e\x23\x98\x69\x83\x11\xfd\xbb\xc6\x68\xc2\x0f\xd2\x90\x07\x91\x95\x90\x52\x00\x8d\xa9\x3a\x33\x8c\x62\x8f\xab\xcc\xaa\x6b\x82\x22\xb3\x77\x56\xff\x1a\x78\x6a\x64\x07\x7c\x84\x75\xc1\xb3\x81\x40\xc7\xc4\xf8\x4e\x7a\xec\xac\x3b\x8b\xe6\x01\x3e\x51\x83\x37\x15\xd1\x6a\x42\xfc\xd6\x73\xbc\xc9\x68\xe4\x05\xb3\x89\xc7\x8c\xd1\x20\x46\x63\xc6\x68\x92\x8c\x49\xbf\x98\x4f\x94\x5a\x60\x81\xf3\x33\x63\xaf\x7f\xf0\x05\x78\x1a\xbc\x05\x0a\x80\x06\x9e\xa6\x9f\xd8\xb1\xee\x9c\x8b\x3d\xfa\x1b\xfc\x21\x5e\xae\xec\x43\x9c\xd3\xb8\x8c\xfd\x99\xf2\x52\xf5\x51\xa3\xc9\xc5\x33\x8c\xe4\x62\x7c\x59\xb2\xa5\x97\x91\x0c\x22\x83\xa1\x64\x5d\x29\x24\xd9\xf8\x3d\x05\x86\xa7\x42\x46\xc9\xb5\xe0\x72\xf2\xf1\x0d\xb1\x12\x71\x54\x42\x44\x55\x58\x39\x49\xb2\x85\xe6\xe9\x56\xf8\xdf\xef\x81\x70\xc9\xf2\x99\x57\x47\x9a\x62\xb1\x49\x13\x6f\xbc\x63\xe7\xa8\x39\xbf\xd9\x7e\x07\x76\xfa\xab\x78\x70\xcb\xd2\xa6\xad\x1f\xed\x7a\xa4\xf6\xb7\xee\xd7\x40\xf8\x3e\x3c\x0b\x3f\xbb\x15\xaf\x15\xdd\x5f\x5d\x2b\x4f\x54\x4f\x16\x4b\xc0\xa7\xc8\x3e\x3c\xe7\xc3\x13\x2f\xb4\x5a\xf1\xd9\x78\x3e\x4d\x70\x19\x9b\x8d\x3e\x67\xa0\xf2\x9f\x41\x47\x09\x62\x1c\x12\xa6\x16\x6c\x42\x64\xf2\x4c\x65\x19\x79\x44\x52\x84\xd8\x6c\x78\x6a\xe5\x03\x10\xb7\x0b\x0f\x9d\x41\x0f\x6a\xbd\x7f\xd1\xe9\x53\xf0\x38\x7e\x2e\xae\xf5\xab\x47\xcf\xc5\x51\x71\xbd\x99\xc5\xed\x65\x6d\x56\xc1\xac\xea\x51\x01\x3d\x96\x45\x96\xbb\xb2\x0b\xd2\xf4\x68\x72\x59\x2c\x54\x21\xa8\xf2\x63\xb7\x56\x1d\x4d\x64\xeb\xe1\x7b\xf0\x03\xb8\x17\x34\xec\xdd\xb9\x73\x17\xdc\x0f\xc6\xd1\xad\xf4\x48\xf8\x29\x3c\x72\xfa\xe9\x67\x3d\xcf\xed\x3d\x1d\x7f\x02\x63\xa2\x9c\x3f\xc0\x4e\xe0\xaf\x23\xbb\xc4\xc0\x18\x75\x02\x6f\xe4\x45\x0b\x25\xf4\xd2\x81\x66\x34\x9b\xc1\x58\xe1\xaa\x8a\x67\x58\x22\xe2\x90\x12\xbd\xf2\xb2\x9a\x3c\xaa\xaa\x32\x40\x12\xfd\x73\xd0\xe7\xb8\x1f\x41\x0e\x88\x1e\x83\x2c\xb0\x01\x19\xbc\x0a\x4b\xe1\xe4\xe3\x93\x40\xf5\x73\x7b\xe8\x0d\x70\x2c\x5c\x00\xdf\x82\xf9\x8b\x48\xfc\x3a\x21\x7f\x3c\x3a\x1f\xd0\x8c\x75\x94\x16\x50\xc0\x22\xd0\x89\x93\x83\x06\x38\xf2\xa8\x55\x35\xe0\x05\x66\x8c\xb7\x67\x0e\x4b\x4e\x42\xdc\xd2\x89\x9d\x7a\x4e\xa3\x88\x61\x5c\x06\xff\xec\xbe\x10\xe9\x92\xff\xc0\xef\x81\x33\x6e\x00\xfb\xe7\xaf\xec\x89\x65\x91\xf4\x23\x9d\xce\x1e\x43\xda\x6d\x74\xd4\xee\xb2\x3b\xb4\x9c\x64\x75\x3a\x1c\x56\x2b\xcf\x31\x5e\x8f\xdd\xe5\xe2\x1d\x68\x74\x2c\x8b\x26\x55\x16\x87\x22\xfa\x34\x60\xe4\x9e\x98\x95\x27\x27\x71\x24\x05\x00\x29\x66\x36\x35\x53\x3a\x6a\x63\x89\x14\x89\x12\x26\x9d\xa2\x80\x01\xf8\xad\xd5\x35\x8c\xdf\x51\x4d\x7f\x74\xdf\x13\xc3\xe3\xdb\xc0\x50\x77\x43\x63\xe3\x88\x5e\x7d\xaf\x85\xc7\x6e\xaa\xe8\xf6\x27\x28\x1e\x37\x8b\x3d\x76\x0d\xfc\xf3\xbb\xf8\xea\xd3\x60\xce\x93\x1b\x7a\x0d\xd9\x0a\xbf\x83\x2e\x9a\x7f\x61\x26\xd8\xb4\x6d\x1f\xd1\x0f\xc7\x90\x4f\x78\x21\xbd\xd2\x72\x11\xbd\xf2\x5f\x15\x6f\xf4\x4f\xa4\x57\x76\x92\x73\x05\x9d\xcd\x0c\x85\x6c\x19\xa4\xff\xf4\x3a\x95\xc3\x7a\xc2\x61\xba\x2b\x87\x13\x8a\x55\x99\x06\x09\xcb\xe2\xfb\xef\x9d\xf1\x26\xb0\x2d\x6f\x64\xcb\xd6\x8f\x1f\xdb\xd9\x84\xb6\xfc\x8d\xf3\xca\x4f\x4f\xf8\xf0\x79\xb4\x96\x16\xb4\xc7\x91\x7a\xa7\x44\x2a\x87\xea\x17\x95\x24\x86\x91\x59\xd1\xab\x97\x45\xbd\x98\xeb\x97\x58\x8e\x55\x47\xe4\x88\x35\xe0\x54\xad\x81\xe1\xd4\x85\x62\x08\x4a\xb8\xd2\x8a\x94\x58\x00\x1f\x6a\xa2\x8c\x91\x34\x73\x68\x11\xf0\x59\x40\xd9\xfe\x44\xc2\x27\xd7\x97\xbd\x48\xf7\x40\xc4\x59\x66\x7e\xf7\x22\x3c\x7e\x0e\x8c\xee\x79\xed\xea\xb6\x4b\xbb\xdd\xbe\x9d\x9e\x77\xc9\x27\x75\xa7\xe3\xf0\x9b\xe6\x5f\xe0\xc9\x55\x20\x04\x7a\x81\x3b\x67\x9c\x29\x79\xfb\x89\x01\x5b\xf6\x0e\xde\x78\x13\xc1\x36\x38\xff\x01\x7b\x1f\xd1\x7d\xd1\xa8\xcc\xd1\xb4\xce\xc4\x32\x5a\x9d\x89\xd1\x31\x82\x19\x27\xef\x98\xa8\xfd\x60\x14\xa2\xd1\x84\xb6\x80\x16\xf1\x79\x58\xb2\xd4\xa4\x36\xdd\x2e\x50\xc4\x1f\x37\x13\xac\x96\x44\xbf\x85\xa6\xb8\x2a\x00\x6e\x87\x0f\x80\x20\x08\xcd\x9b\x04\x1c\x47\x60\x00\x36\x7d\xce\x86\x99\xb7\xcf\x3d\x31\x11\xdc\x02\x66\xc0\xbc\xf8\xb7\xe7\x31\x7a\x30\xde\x77\x68\xfb\x4f\x20\x6b\xd3\x13\xe9\x45\x33\xc7\x1a\xcc\xac\x59\xb4\x18\xcc\xfb\xc0\xc8\xbd\x31\x83\x41\xe0\xb0\x5a\x11\xa8\xd4\xfe\x4f\x85\xd0\x52\xf8\x15\x18\x32\x18\xeb\x61\x51\x81\xe2\x95\xfd\x22\x1d\x00\x95\x80\x83\xa7\x6f\xd8\xfe\xd0\xaf\x71\xc8\x1e\xfd\x09\xfe\x74\xf6\x21\x36\xf8\xe4\x5d\xf0\xed\x53\x8c\x53\x91\x8b\xa9\x68\x1f\xcc\x47\x63\xcb\x54\x53\xd4\xac\xd1\xca\x66\x4e\xab\x15\xcd\xa2\xc3\xce\x69\xd1\xe8\xcf\xc4\x38\x4e\xd4\xe9\x12\x8b\x86\xf7\xbd\x48\x49\xe4\xb5\x98\x26\x26\x9d\x33\x73\x08\x31\x49\x32\x70\xb6\xb1\x6c\xc1\x32\x94\x23\x32\x53\xee\x78\x60\xff\x7f\xe2\xe7\xc0\x07\x20\x1f\x6d\xc8\xfb\x61\x07\x58\x8f\x94\xd1\xce\xcd\x0f\xc0\x5f\x4f\xd3\x27\xe1\xcf\xf0\x58\x6b\xfc\xb1\xd3\x60\x0a\xe9\xdd\x8c\xf8\x32\x03\xd1\x86\xbb\xfc\x4b\x06\xf4\x1b\xc1\x82\x8e\x42\x60\x61\xec\x32\x6d\x30\xd8\xf6\x81\xd1\x4f\x23\xee\x00\x81\xc7\x5b\x00\x90\x2d\x10\x49\xc5\x15\x1d\xe9\xc4\x10\xf1\x45\x7b\xcf\x07\x1c\xc4\x6a\xc3\xb5\x8d\xf4\x3d\xf0\x54\xb0\xe3\x55\x50\xdd\x34\xed\xff\xc7\xda\x7b\xc0\x47\x55\x65\x8f\xe3\xef\xbe\x3a\x7d\xe6\x4d\x6f\xc9\xb4\xcc\xa4\x17\x32\x29\x84\x96\x01\xe9\x25\x24\xa1\x0e\x20\xbd\x48\x91\x5e\xa4\x37\x41\x94\xa2\x02\x0a\x58\x50\x50\x41\x50\x91\x0e\xd2\xb1\x50\x44\x6c\xab\xb8\xbb\xba\xba\x2e\xba\xae\xac\xae\xee\x82\x9d\x79\xf9\x9f\x7b\xdf\x9b\xc9\x24\xe0\x7e\xf7\xf3\xff\xfc\x76\x74\x91\xe4\xcd\x7d\xe7\x9e\x7b\xfa\x3d\xa5\xaf\xb1\x5f\x8d\xd1\x86\xec\x4e\xdb\xf9\xab\xe0\x64\x6d\x1d\xbb\x64\x3f\xca\x9a\xb5\xed\xec\x9c\xcc\xd5\x2f\xfd\x2c\x7d\x79\xed\x1f\x45\x24\x1f\x05\x70\x35\x87\xd0\x76\x87\x98\xdd\x04\x82\x42\xd4\x68\x39\x96\x45\x5a\x91\xb5\x98\x4d\x00\x99\x86\x3d\x75\x3b\x46\x8a\x36\x93\x10\x44\x3e\x60\x7c\xa0\x74\x1b\x92\xbd\xfb\xb7\xaf\xe8\xa7\x13\x26\xd4\x11\xcd\x6f\xdf\x56\x6b\x47\x36\x9b\xa1\xdd\xec\x51\xa8\xe4\x3f\xcc\x57\x09\xc9\xb7\x6c\xde\x57\x5f\xaf\x7d\xec\xae\x1c\x69\x16\x91\x99\xf3\x01\x37\x73\x89\x1c\xb0\x00\x76\xac\x5a\xda\xa8\x42\xb4\x85\x56\x31\x36\xab\x4e\xab\xa5\xc1\xbb\xa1\x31\xd1\xb0\x94\x25\xcd\x5c\x92\x89\x46\x4c\x37\xdf\x08\x76\x70\xc5\x11\xce\x1a\x01\x99\x2d\x56\x98\xb1\x4e\x0d\x20\x50\xe5\x51\xda\x09\xf2\xe7\xcf\xd2\xa7\x5b\xb7\x4c\x5d\x2d\x19\xe8\x5f\x7f\x5b\xc1\xce\x47\x9f\x9d\xfd\x58\x3a\x21\xf5\x9d\x8d\x7c\xdd\x11\xf7\xc7\xa9\x83\x64\x3a\xaa\x01\xdc\xdc\xa2\x0b\x6b\xfe\x8b\x2e\x04\x99\x7d\x7b\x5d\x48\xbf\x97\xd4\x84\x78\x5d\x47\xc3\x8f\xc4\x76\xf7\x82\xed\xee\xb6\x58\x39\x5e\x47\xe9\xbd\x7a\xb7\xd7\xe3\x71\xf3\x56\x36\x33\x43\x47\x51\x6e\x0b\xe7\xc1\x78\x77\x2b\xa2\xda\x9d\xc2\x7b\x53\x4b\x35\xad\xa7\x0c\xb6\x52\xa3\x8c\x81\x36\x22\x87\x3c\xba\x3e\xca\xd0\x06\xc4\x06\x98\x28\x1a\xdb\xae\x65\xa6\x4a\x77\xc3\xa5\x69\x79\xd7\xd8\xda\x80\xe5\x99\x13\xc3\x2d\x65\x3f\x44\xdd\x63\xcf\x48\x47\xa4\x3f\x9d\xfa\x85\x5e\xab\xef\xb0\x7a\xc3\x67\xd2\xee\x07\x9f\xbf\xd3\x69\xfe\xb4\xff\xc9\xd7\x69\x4f\xe2\x1b\xe9\xb7\x86\x35\xd5\xec\x55\x80\xb7\x12\xf0\x30\x0d\xe0\xc5\x35\x99\x26\x64\xb1\x38\x55\x82\xc1\x29\x38\xdd\x2e\x95\xc5\x62\x95\x4d\x57\x0b\x18\xb2\x7a\x44\xa3\xe3\x29\xe5\xd6\xa4\x73\x75\xd3\xc9\x6a\x58\xf2\xd9\x53\x5c\x6d\x35\x24\x73\x95\x3e\x7a\x84\xb6\x22\xff\x6f\xd2\xbf\x97\x3d\x36\xa2\xc3\x86\x47\x3a\x8a\x35\xed\xc1\xda\xbd\x2e\x7d\x95\x88\xd2\x17\x9f\x5e\x94\xb8\x71\xf4\xd2\xc0\xff\xdc\xfd\x14\xb9\xff\xfc\x00\x64\xff\xaf\xec\x9f\x4c\xd9\x1c\x8b\x00\x5f\x26\x81\x63\x25\x9c\xfd\x70\xfb\xdf\xa9\x1a\x7f\x47\x77\x66\x7e\x26\xbf\x53\x21\x4d\xfa\xef\x80\xb4\x37\xb3\x3c\x13\x05\x5b\x81\xa1\xcc\x07\xc1\x45\x47\xf4\x51\xb0\x0f\xaa\x71\xe7\x78\x4c\x50\x21\x4b\x80\xee\x79\xf0\x7e\x64\x66\x79\x5a\xd6\xf1\x47\x59\x9e\x35\x93\xe7\x05\xca\x79\x44\x40\x6a\x15\x87\x78\xf9\x4b\x78\x06\x86\xe2\xdc\xc3\xf7\x2c\xf0\x2f\xba\xfb\xd0\x03\xc8\xfc\x51\x72\x81\xc4\x0a\xbc\x08\x4d\x01\x7c\xa4\xcf\x88\x40\x69\xa8\xfc\x98\x4d\xa3\xe2\x28\x0e\x7c\x73\x0d\xd3\x27\xae\xd1\x70\x6a\xde\x88\x94\x36\xba\x44\x08\x28\xed\x04\x09\xab\x65\x07\x04\x60\x36\x2d\xcd\x9e\x95\xae\xdd\x29\x45\x06\x4a\xdf\xa3\x9d\x68\xb0\x61\xfb\x53\x3f\xfd\xc4\xb6\x4a\xac\x43\xfb\xa5\x1a\x65\x9e\xf3\xbb\xa4\x0e\xd2\x42\x0d\x8b\x95\xab\xf5\x7a\x60\x6b\x4a\xd0\x52\x0c\x8b\x9b\x04\x5a\x2d\x74\x7d\x5c\xad\xeb\x13\x37\xaa\x7d\x6a\xda\xc4\x58\xd4\x16\x35\x65\xe6\x38\x55\x9f\x38\x67\x64\x6d\x94\xbe\x8f\x5c\x97\x9e\xac\xb0\x35\x27\x93\x7e\xf3\xf3\xd3\x66\x2f\x44\x93\x9e\x3b\x99\xa9\x6c\x4b\x7e\x10\xfc\x9d\xee\xf1\xe6\x40\xe9\x23\xb4\x9a\xc9\x96\x9e\x47\xf9\xd2\x87\x68\x76\x62\xbe\xfe\x3e\xa4\x96\x00\xc8\xb7\xae\x5e\xba\x7e\x19\xfd\x05\x74\xca\x14\x52\x6f\xa1\xd4\x69\x51\x79\x54\x39\xd5\x96\x1a\x15\x8b\xe6\xfb\x4b\x5d\x2e\x44\xb5\x6a\x65\x6d\xad\xca\xb5\xe6\x56\xb7\xf3\x56\x44\x2a\xea\xe2\xce\xd6\x79\xad\xeb\xe2\xa5\x79\xbe\x3c\x41\xc8\xf3\x31\xda\x60\xc4\x5e\xc4\x6a\xd9\xba\xb8\x88\xf3\xca\xd2\xda\x43\x16\x37\xe9\x38\x9c\xde\x12\x46\x29\x9f\x47\x4d\x12\x9a\x1c\xc9\xb4\x26\x23\x52\xe6\x1a\xe1\xa1\xe1\xf2\x18\xa8\xf2\xb0\x72\x65\x5e\xd9\x0e\x21\xcc\x5e\x81\x4c\x44\x8b\xf1\x9e\x6d\x62\xa6\xfd\xe1\x6d\x33\x67\xac\x08\x96\x6e\x1d\x3d\xff\xbe\x67\x77\x6c\x68\xd3\xb2\x45\x54\xf5\x6e\xb6\xf4\xcd\xde\x2e\xfd\xb6\xed\xd8\xc5\xfc\x21\x37\x52\x33\x65\xec\x9d\xdd\x12\x0f\xe4\x74\x2d\xa0\xa5\x3f\xa8\x3a\xd1\xfd\xe9\x47\x5e\xea\xd9\xbe\x70\xcd\xaa\xc9\xf3\x66\x4f\x7f\xe9\x91\x17\x8f\x30\x6c\xe5\x9d\x93\xba\x77\x13\xa5\x0b\xab\x57\x23\x0f\xca\xca\x7f\x25\xd6\xed\xc5\x29\x15\x0c\x73\x67\xe2\x46\xfb\x59\xf5\x2b\x96\x13\xfc\x14\xe3\xbe\xfc\xa4\xdf\x23\x9e\xc8\x31\x32\x16\x45\x99\x99\x94\x3b\x2b\x4b\xb0\xd8\x6c\x8c\x56\x2d\x30\x42\x6e\x4e\x08\xa9\x35\xea\x3e\x71\xb7\xc5\xa8\xf1\x69\x70\x35\xb0\x46\xd0\xe9\x5c\xb5\x71\x9d\x51\xc8\xaa\x8d\x0b\xb6\xe6\xb5\x29\x8d\x63\x79\x9b\x8d\x7a\x90\xd3\x32\x48\x78\x44\xee\x33\xae\xa4\xe0\x45\xc3\x98\x6b\x6d\x80\x1d\x0b\xb1\x9e\xc8\x7c\x81\x8d\x27\x66\x1f\xde\x9f\x38\x39\x73\x26\xcd\x5c\x3e\x52\x99\xff\xb6\x34\xbf\x66\xec\xfe\xfd\x23\xeb\x3d\x39\xfd\x87\x3e\xf7\xec\xd2\x21\xe8\x4c\x8b\xe5\xf7\xae\x42\x67\x2e\xa1\x97\xe7\x2d\x69\xdb\x3f\xb4\xa0\x43\xf4\x87\x36\xd2\xbd\xa5\x2d\x1d\xd2\x2f\x6d\x09\x5f\x4e\x86\xb3\xef\x47\x6a\xf4\x3a\x13\xde\x7a\x06\xf6\x3a\x1a\xf6\xaa\x02\xcd\x94\x13\xb3\xea\x38\x91\xe2\x28\x8b\x19\x99\x6a\xe3\xc8\x88\x73\x7c\x29\xdb\xad\x36\x73\x94\xe8\x65\x2b\x15\xca\x4e\xd6\xcc\x3f\x83\x0e\x80\x54\xd2\x49\xff\xb8\x69\x5e\xb5\x6c\xc1\xd2\x2d\x6c\x2b\xe9\x9f\xe0\x22\x49\x9f\x5e\x7c\x69\xf7\x8b\x3b\x48\xff\x3f\x9a\xaa\x82\x77\x4d\x26\xfd\xae\x70\xc7\xd7\x7c\x87\xcd\xe5\xd2\x21\x8d\x89\xd7\xf0\x6e\x8f\x53\x47\x01\x77\xd8\x8c\x94\x8f\x02\x6c\x52\x94\x86\xd6\xb8\x80\x35\xe5\x96\xba\xc6\x5b\xb0\xd9\x44\xdc\x25\x0b\xce\x52\x60\x01\x22\x39\x05\x32\x32\xa3\xa1\x6a\x66\x0a\x3c\xa9\xcf\x4c\xda\x48\x40\x3c\x76\x8c\x5e\x8d\x5e\x56\xc0\x44\x67\x7e\xc2\x80\x7e\x75\xe9\x27\x90\xc3\x1f\x02\x9c\x66\xd2\x0f\xac\x4b\x2c\xc2\xa9\xe1\xc0\x29\x8d\x86\xd2\xeb\x30\xb7\x1a\x39\x1f\x07\x00\x72\x1c\xc8\x31\xb6\x0f\xc6\x91\xba\x09\x8e\x9a\x96\x22\x01\x1b\x97\x2a\x08\x4b\x71\xeb\x87\x8c\x2f\xf1\x3d\xba\x2a\x65\xd0\x45\x0a\x6b\x62\x5d\xb5\x05\xce\xc5\x05\x3c\x99\x4d\x0d\x89\x45\x03\xc1\xa0\x3e\x53\xd4\x84\xc3\xa2\xde\xc9\x70\x39\xb9\x41\xbd\xc1\xa0\xaf\x8b\x1b\x0d\x3e\x03\xbc\x9b\x35\x38\x1c\x06\x16\x1c\x4e\x8f\xb5\x2e\xee\x01\x21\xf3\x3b\x0d\x4b\x6e\x97\xea\xc9\x35\x56\xc2\xff\xd7\x5e\xcf\x74\xdd\x81\x4f\x72\xff\x2d\x4e\xec\x56\x1b\xbf\x25\xdf\x70\xc9\x96\x7f\x5b\x9f\xde\x98\xde\xd1\x39\x2d\xe9\xd0\xf0\xe0\x5d\x9b\x5e\x82\xb3\x9e\x2d\x4d\x66\xe7\x93\x7a\x13\x3d\x55\x19\xf3\xf1\x88\x51\xe9\xb5\xbc\x5a\x6d\x34\xe8\xf4\x7d\x06\xeb\xc0\x86\xa7\x11\x29\x3d\xe1\x6b\xe3\x6a\x5b\xb3\x3e\x7a\xe0\x8a\x38\x94\x5e\xa9\x72\x49\x06\x67\x0b\x94\xa3\x8f\xa4\xa7\x58\x4e\x9a\x85\x82\x89\x37\x70\xdf\x1d\xb9\xb1\xda\xa9\xd7\xde\xc1\xf1\x4a\xea\xe1\x86\x6f\x98\x0f\xe1\x7d\x26\xf0\x51\x9c\x5a\xb5\xda\xc0\x18\x44\x33\xcb\x52\x3a\x9d\x16\xcf\xf7\x6e\x8e\xa4\xa6\x59\x82\x18\x2b\xa4\x13\x78\xb9\x88\x9b\xc6\xc2\xf6\x73\x0e\xbf\x96\x89\xac\xc6\x3b\xda\xac\xfa\x91\x36\x7d\x6c\x7d\x72\x77\x60\x70\xf7\xe3\x34\xfb\x56\x22\x74\xf4\x15\xc2\x47\x2f\x01\x8d\x6c\x20\x79\x41\xbf\x12\x5b\xe3\x65\x10\x1c\x3f\x90\x9e\xa0\x2d\x63\x5e\x95\x4e\xc7\x21\x30\xb9\xe1\xa8\x8c\xb4\x4a\x0d\x0e\x81\x1a\x81\xb0\x03\x02\x47\xe9\xe3\x3b\xcc\x55\x69\x75\x08\xc4\xaa\x11\xca\x71\x05\x77\xa5\x4d\x10\x03\xcc\x0f\x89\x56\x4b\x96\x20\xe3\xf5\xeb\xe8\x08\x7a\xb8\xf7\xdf\x6a\xd1\x39\xe9\xf0\x83\x7f\x5f\x27\xbd\x4a\xde\xd7\x06\xde\x8f\x7b\x45\xd9\xa8\x68\xcc\x69\x33\x9b\x45\x5c\xf5\x2c\xf2\x0e\x30\x6f\x69\xa3\x60\x34\xf3\x36\x1d\x92\x15\x5a\x75\x54\x8e\x43\xa6\x9b\x06\x8d\x05\xce\x60\xd4\x92\x2c\x30\x52\xdc\xfc\xd1\x87\xd7\x4c\xdf\xa0\x09\xcb\x8c\x05\xea\xb0\x6f\x21\x1a\xfd\x8d\x99\x99\xf5\xf8\xd8\xc4\x1a\xe0\x66\x5f\xf1\x3f\xfb\x22\xed\x28\xf4\xf9\x6f\xe7\xe8\x99\xe3\x9e\x20\x30\xac\x03\x18\xee\x24\x3a\x2f\x2f\x66\xd1\x23\x83\x8e\x13\x0c\x82\x49\x64\x75\x06\xce\x68\x54\x19\x92\xfa\xb4\xaa\x69\x23\x0b\x65\x1a\x4c\x40\x99\x04\x83\x36\x1a\x78\x74\x06\x65\x48\x37\x0d\xbc\xd4\x4b\xfa\x00\xde\xe5\x2e\x7a\x33\x9b\xe1\xe0\x45\x91\xd2\xf5\x9e\x9b\xbf\x91\x1c\x42\xa5\x46\x10\xf0\x2d\xe7\xc7\x3d\x25\xf7\xf8\x31\xf1\xb4\x2d\x1b\xcb\x96\xf2\x86\xdf\xd8\x4d\x6c\x3b\x0a\x77\x91\xf3\xc7\x0c\x46\xb5\x15\xb0\x6e\x77\x88\x80\x07\xa5\x5d\x74\x7a\x94\x83\x88\x09\xb9\x92\x11\x67\xc9\x98\x02\x78\x70\x01\x3d\x06\x09\xa0\x3a\x3f\x90\x7e\x05\x91\xf0\x21\xd8\xd7\xc6\xb3\x7b\xd0\x94\x43\x27\xd9\x76\xd2\x27\x92\x94\x90\xfe\x8a\xfc\x88\x41\x6a\xe4\x90\xfe\xbc\xe8\x9e\x06\x6a\xe1\x6c\xc4\xc8\x76\x66\x39\x95\x0b\xef\x36\xe1\x29\xc0\x31\x51\xa4\x34\x7a\x3d\xcf\x5b\x29\xc6\xe5\x56\xdb\x8c\xb8\xf5\x6b\xb4\xb8\xe9\xc0\x44\x4b\x19\x7e\x37\x66\x36\x06\x47\xa1\x02\x7e\xdc\x53\x86\x29\xa2\xcb\xc1\xe3\xe3\x9b\x37\x46\x9c\xb2\x67\x18\x6d\xf8\x11\x64\xd7\x7f\x70\x57\x45\xe4\x49\x76\x55\x94\xfe\x6e\x5c\x82\xaf\xd0\x89\x3e\xdf\x03\xfa\xfc\x3e\xb0\x3c\xdc\x54\x10\x4f\xbd\xb7\x67\x1a\x1d\x8e\x8c\x4c\x8e\xe5\xcd\xa2\x98\xa5\xe2\xfd\x8c\x4b\xaf\x67\x78\x26\x94\x65\x36\x82\x8f\x96\xe9\x30\xb2\x94\x55\xd0\x18\x3d\x22\xe6\x89\x73\x51\xf8\x27\xd9\xed\xa6\x69\x4a\xb2\xb9\x31\x70\x46\x01\x81\x64\x97\x3b\x2a\xa2\x18\x77\x82\xc3\x96\xcd\x33\x41\x01\x01\xda\x50\x69\x25\xc2\xd7\xf1\xf4\x78\xe9\x17\xe9\xc3\xf8\x82\x8f\xd6\x7f\x83\x38\x94\xdf\x67\xfa\xdb\xeb\xae\x0f\xe9\x82\x2e\x77\x92\x1e\x1e\xda\x51\x2a\xeb\x7a\x44\x8b\xb2\x10\x7d\xe6\xde\x69\x47\xde\x98\x2d\xfd\x55\x4a\x9c\x5f\x3e\xe6\xe8\xd1\x69\x8c\x57\x94\xc6\xb7\x99\x84\x28\x49\x63\x42\x9b\xda\x8d\xbd\x77\xb1\xbc\x27\x2f\x9c\xef\x41\x90\x87\x1e\x90\x88\x85\xa0\x83\x4b\x83\x3a\xbb\xdd\xeb\xa5\xf2\xf2\xc4\x7c\xc1\x2d\xba\x8b\x8b\xec\x56\x9f\x2e\x6c\xf0\xe5\x38\x73\x6a\xe3\x9e\x7c\x90\x84\xbc\x87\xd7\x58\x9d\xf6\x30\xa3\x61\x6a\xe3\x06\x4d\xba\x89\xa2\xf4\xd3\x6a\x56\x9a\x12\x35\xa7\x95\xa6\xa0\x34\x41\x88\x47\x78\xa6\x66\x53\xfa\xc5\x72\x2e\xfd\xfe\xbd\x14\x9b\x24\xe8\x46\x4d\xe7\x68\x99\x61\x7f\x70\xf3\xc4\xc3\x75\x7d\x8e\x3c\xf9\xfc\xee\xed\xc7\x7b\xf7\xdb\x23\x9d\xa5\x77\x75\xad\xe9\x56\x5d\x7d\x47\x7d\x77\xe9\xe9\xfb\x78\xe9\x67\x55\x05\xdd\x7f\xc3\xce\x0e\xd8\x08\x39\x72\x44\xfa\x4c\xfa\x4e\xfa\x5a\xfa\x6a\xdf\x3e\xba\x3a\xbf\xd5\xc9\x23\xaf\x1c\x3f\x71\xec\x4c\xe2\x8a\xb4\x66\x3a\xd1\x8f\x93\x60\xcf\x23\xc8\xdc\xfc\x5c\xaa\x5b\x2c\x4b\x25\x08\xd9\xd9\x5a\xd6\x11\x08\x58\xdc\xac\x3b\x2f\xdf\x2e\x64\x19\x8d\x59\xb8\xed\x3f\x65\xd6\x1a\xa9\xcc\x46\x89\xa6\xb4\xf3\xa0\x9a\x46\x73\x53\x22\x9f\xf4\x53\xad\x2c\x87\x3f\x02\xf2\x46\x02\x8d\x83\xc9\xb3\x93\xfb\xc2\x27\x38\xf6\xf1\x2f\xe7\xad\x9c\x3a\xf4\x1e\xa4\x9a\x3e\x66\xe4\x24\xa4\x9a\x3b\x74\xfa\x8a\x79\x5f\x3c\x39\x75\xe1\xa2\x29\x53\x17\x2c\xb0\x8e\x3b\x39\x6f\xc5\x61\x17\x1b\x79\x75\xea\xb2\xc5\x8b\x97\x4d\x3f\x1b\x66\x5d\x47\xee\x9d\x77\x72\xdc\xf1\x25\xf3\xa6\xcc\x9e\x33\x79\xfe\x62\xe0\x85\x4e\x74\x26\xbb\x0a\xce\x4d\x47\x65\xc6\xf4\xe0\xca\x19\xf0\x1d\x14\x9e\xba\x22\x57\x22\x98\x5e\x4f\xda\xeb\xca\x6c\xeb\x00\xbc\xdc\x2f\x76\x6a\xca\x5a\x74\x26\xa6\x20\xc0\xd6\xbf\xcf\xee\x91\x1e\x26\x3c\xd6\x09\x70\xb3\x8a\xf6\xca\xeb\xea\x60\x5d\x4e\xa7\x56\xd3\xa0\x3b\xec\xcd\xd6\x45\x84\x99\x03\xf2\xea\x08\x08\xeb\x1e\xdc\xd3\xfb\x2b\xa0\x4d\xe0\x60\xda\x2b\x3d\xbc\xe7\xac\xf4\x3d\xf0\x72\x1e\x8e\x5f\xd3\xd4\x1a\x90\x61\xab\x00\xe7\x1a\xe0\x9e\xb2\x98\xdb\x28\x68\x11\xa2\x05\xda\x66\xd5\x52\x75\x71\xe2\x0c\x5b\xea\xe2\x8c\x5c\x3e\x76\xdb\x3a\x22\x12\xc4\x96\xaf\xb7\xc2\x01\xc5\xe8\x40\x3b\xa4\xbf\xd3\xbe\xaf\x7e\xbc\x7e\x4d\xfa\x05\xa9\x46\x0c\x19\x37\xf6\x67\xb4\x1e\x14\x62\xab\x3d\x3b\x9f\xdb\xf3\xf2\x90\xae\x35\x03\xc9\x79\xe3\x99\x8d\xad\x88\xce\xb0\x52\x77\xc4\x02\x8c\x28\xd2\xbc\x15\x14\x16\xaf\xb5\xd9\x19\x0b\x00\x54\x17\xb7\x58\x68\xd0\x99\x75\x71\xb5\x51\x47\xdb\xa8\x26\x4d\x90\xa9\xaa\xe6\x3d\x6f\x70\x41\x95\xdc\x3b\x17\x8b\x57\x0b\xee\x99\xdb\x1a\xd1\xc3\x61\xbb\x97\x51\x87\xe9\x73\xae\x5f\x43\x5f\x01\x5c\x67\x2e\x9f\x7c\x17\x1d\x90\x7a\xa1\x8f\x3c\x4f\xcc\x7e\xec\x89\xdf\xce\x81\x6d\xf4\xc7\x4d\x8f\x34\x83\xa7\x7d\xcc\x4f\x59\xad\x8c\x46\x14\xb5\x60\xef\xda\x6d\x1a\xa3\x5e\x0f\x70\xe8\xf5\x2c\xd2\x1a\x59\xc0\x09\x6b\x6b\x46\x7b\xb7\xed\x68\x4d\x92\x76\x70\x68\xcb\x21\x43\xc3\xf8\x91\x5b\x72\x7d\x7d\xe3\x9e\x69\xd2\x29\x14\x45\xa6\x57\xdf\x3d\x79\xf9\x0c\x7d\x1f\x3a\xf0\xdb\xb9\x27\x1e\x9b\xf3\xb8\x07\x94\x7c\xaf\x17\x1f\xd9\x24\xcb\xd5\xdd\x00\x4f\x90\xf8\x6c\xb9\x31\x0b\x8b\x4d\x2e\x0a\xa9\xd4\x9c\x8d\x11\x88\x3a\x37\xa6\x5d\xe2\xa4\x9a\xa4\x5a\xe4\x21\x41\x81\xdd\xcc\x3d\xd2\x7b\xd2\xdf\xa5\xf7\xd8\x56\xa7\x6e\xde\xcb\x2c\xc0\x3a\x63\x1d\xd0\xd0\x28\xac\xb3\x99\xd9\x64\xfd\xee\x54\x01\xbb\x85\x55\x83\xdc\xce\x8f\x59\x05\x4a\xd4\x9b\x18\xab\xd5\x84\x05\x37\xe5\xb4\x99\x04\x01\xcf\xac\x14\xa3\xd5\x4d\x7a\x64\xe3\x37\x90\x39\x21\xf8\xd4\x2b\x2a\x71\xc7\x47\xd9\x62\x0a\x05\xba\xd3\xc3\x50\xc6\xcb\xf7\x27\x4e\x30\x5d\x07\x4c\x29\xb0\x3c\xe7\x5b\x30\xf5\x83\xb7\x12\x75\xa8\xe3\xd9\xb1\x0b\x91\x8b\x63\xa4\x1b\x8c\x86\xad\x7a\x71\xce\x8b\x47\x41\xbe\xd5\xc3\xbb\xb7\x91\x77\x7b\x29\x3f\xd5\x33\x16\x61\x7c\x1e\x8f\x57\x70\x02\x10\x4e\x93\xd5\xef\xb5\x7a\x83\x81\x0c\x7f\x7d\xdc\xeb\xaa\x8f\x67\x78\x33\xbc\x2a\xca\x29\x26\x21\x2a\x8e\x36\x6d\x10\x68\x4e\xc3\x3b\x96\x64\xbf\x07\x20\x92\xeb\x44\x43\x68\x11\xa0\x1e\x20\x95\xfe\x41\x7b\x1b\x21\x95\x16\x4a\x1f\x7c\x0c\xff\xbb\x0d\xbc\xe8\xee\x3f\xd1\xab\xaf\x10\x9c\x75\x6b\x70\xb0\x9b\xb9\x22\x2a\x42\x75\x8c\xf9\x99\x60\xd0\xea\xb6\x8b\x0e\x87\xde\x94\x29\x80\x93\xef\x66\x72\xb2\xed\x91\x08\x45\xa9\x7c\x99\x4d\xa0\x2d\x6e\x54\x2d\xd1\xb4\x7f\x7e\x0f\x99\x42\x12\x62\x91\xfc\x3a\x3b\xd0\x0d\xa3\x76\xcf\x03\xe9\xa8\xfd\x66\xd1\xe4\x8f\x2e\x26\xea\xf0\x2f\x9e\x5a\x93\x78\x99\xde\xf5\x6c\xff\x09\x29\xa8\xcb\x1e\x9f\xf4\x73\x39\x5f\xf9\xd8\x9c\xad\x3b\x90\xe3\xd9\xfa\xf1\x1c\xb1\x19\x7c\x40\x4f\xbb\x88\xcd\x16\xbf\x35\xb7\x5b\xe9\xe1\x50\x4e\xfe\x7e\x27\xd9\xeb\x2a\xa0\x17\x15\xdb\x06\x74\x50\xaf\x58\x8e\x55\xe3\x34\xd9\x6c\x06\x46\x34\x38\xd9\x0c\xaf\xd1\x66\xc0\xed\xae\x0d\xac\x81\x32\x5b\x45\x33\xf8\x49\xe6\x66\x36\x26\xd1\x35\xcd\x1a\x63\x88\xb2\x09\xd4\xc4\x08\xcf\x47\xe5\x95\xd8\xce\xe5\x64\x79\x4c\xc7\x14\xc3\x3b\x3e\x7a\xd4\x9c\x11\x5f\x4b\x36\xa6\x5c\xfa\x6a\xfb\x9a\x29\x97\x65\x93\xbb\x6f\xcd\xe0\xda\x27\x3f\x79\xfb\xd8\x75\xc7\x93\x9b\xc6\x6c\xed\x27\xf3\xc9\xae\x86\x6f\xd9\x2c\xb6\x37\x15\xa2\x6a\x62\xd9\x3e\xb3\x57\xad\xe6\xf5\x94\x93\x77\x66\x85\xbd\x9a\x98\x5e\xe3\x63\x6c\xb8\x5a\x83\xb1\xe1\x56\x0a\x36\x13\x13\x68\xd6\x3b\x81\xf4\xac\x76\x54\xb9\x4d\x97\xd3\xf5\x62\x69\x63\xeb\x23\xac\x3c\x92\x15\x62\x8d\x7e\x02\x56\x19\xd1\xd2\x4a\x36\x2b\xe3\xe3\x03\x7f\xf8\x70\xcd\xc2\x2d\xf7\xed\x78\xd4\xfb\x0b\xf9\xcb\xda\x05\xeb\xd7\xc1\x5f\x90\xb8\x76\xd3\xf6\x8d\x13\x1e\xd0\x8c\x69\x5b\xb3\x7c\xb9\x1b\xff\x65\xe2\x1a\xcd\x98\x76\xdd\x71\x2b\x43\x80\x5b\x0d\xf8\x7d\x0d\x74\x45\x3e\xd5\x2a\x96\x91\x09\x4e\xa1\xc1\xc2\xf2\x11\x3e\x52\x50\x98\x69\xa0\x0c\xac\xdd\x14\xd4\xb0\x9a\xfa\x78\x0e\x6b\x4f\xa9\x72\x39\x0c\xd7\x58\xf6\xd5\xa2\x24\x4c\xe6\x71\x2b\xf8\xac\x46\xd9\x60\x46\x29\xf9\x06\x06\x64\x54\xaa\xd8\x2a\x1d\x24\xe1\x99\x1e\x9b\x5b\xf2\xe8\xe0\x47\x17\xc6\xb2\x86\x16\x95\xc6\x5c\x15\x53\x2a\x0b\xbc\x9f\x1d\x3f\xfe\x59\x46\x61\xf9\x94\x0a\x57\xac\xb4\x68\x58\x28\xb6\x60\xd3\xa0\x47\x5b\xbc\xd3\xbe\x57\xbf\x2e\x7f\xca\xc8\x2b\x0a\xf5\xb8\xef\x8e\xde\x03\x4b\x37\x1c\x39\xba\xbe\x74\x50\x6d\xec\xbe\x1e\xa1\xa2\xbc\x8c\x3f\x75\xe9\x5b\x43\xe0\x4f\x00\xbd\xb0\x20\x9f\x38\x2a\x23\x66\x60\x58\x8a\x15\x78\x0e\x54\x12\x09\xe8\x34\x56\x44\x2a\xb3\xcb\x44\x96\x95\x2c\xb8\x99\xff\x29\x79\x38\x1a\xd0\x1b\xbe\xaf\xbf\xc2\xb6\x02\x1b\xb6\x17\xce\x6f\xa1\x56\xc3\xdf\x3b\x10\x79\x17\x8a\x89\x34\xe2\x78\x44\xe6\xba\xe1\xd1\x6b\x34\x9f\x94\xfe\x8d\x46\x6c\x72\x52\x42\x07\x10\x73\x0b\xf1\xca\xbf\x9d\x93\x3b\xd8\xe3\xb5\x15\xbd\x66\xe6\xb9\x4a\x02\xab\x4e\xa6\x75\xb0\x10\xdb\xc5\x32\xb1\x5b\xe4\xd4\xeb\x05\xab\x28\x88\x5e\x8f\xd6\xe0\x34\x00\xe5\x3a\x9d\x7a\x17\x67\x56\x1a\xa3\xa6\xd5\xf2\x36\x9f\x80\xde\x8e\x26\xdd\xa6\x70\x2f\xc8\x80\x58\x84\xc8\x7d\x2a\x1e\x97\x15\xa0\xff\xd1\xb7\x2e\x88\x2c\x43\x2e\xbf\x0c\xaa\xf6\x2f\xc8\x12\xaa\xef\x83\x75\x29\x2a\xbe\x7b\x2d\x52\x4b\x5f\x1d\x3d\x37\x94\x96\x4e\xa2\x3b\xe8\x3f\x22\x16\xfc\xb7\x9f\x97\xcc\x2c\x47\x74\x29\x86\x0d\xf7\xeb\x8c\x91\x78\x4b\x7e\xcc\x4e\x59\xb5\x56\x9b\xdd\x0c\x78\x34\x1b\x75\x06\x15\x40\xa6\xb2\xcb\xbd\xb0\xd2\x1b\xcf\xc9\x51\xb0\xe6\x55\x22\x4c\xe4\xd7\xe6\x95\x21\x0d\xb7\x16\x84\x9c\xc3\xba\x77\x03\xba\xc6\x56\x71\x97\x70\xee\x2a\x55\x1e\x33\x6b\x68\x9a\x05\xcd\x2f\xb0\x82\xde\x40\x6b\x34\xac\x8a\x3b\x8e\x0a\x70\x4c\x0f\x15\xa5\x4a\x9b\x9b\x77\x17\xc9\x0e\x08\x21\x14\x55\x23\x81\x09\xd0\xcc\x8c\x7e\xd2\xfa\x7e\x17\xd0\x9d\xdf\xa2\x21\x52\x51\xfe\x30\x64\x7d\x00\x5d\x93\x24\xe6\xf3\x9b\x3e\xa6\xeb\x43\xd2\xdf\xd0\x53\x14\xdd\x70\x09\xfd\x93\x63\xb8\xb7\x40\x71\x59\x41\xa2\x64\xa8\xf5\x7a\x2b\x8e\x10\x5a\x58\xd6\x60\xb0\xb3\x36\x95\x28\x72\xb4\x45\xa7\xc6\xb1\x41\xee\x24\xbc\x1e\xbf\x5c\x0f\x08\x2a\x22\xd3\x8d\x92\x89\xfd\xe4\x93\x16\x13\x94\xb3\x02\x31\x2c\x4a\x84\x01\x1c\x66\x14\x12\x98\x28\xdd\x41\x7a\x7b\xd6\xbb\xe8\x13\x26\x26\x85\x88\xc2\xff\x25\x51\x9d\xd7\x7e\xd9\xb7\xe8\x9f\x18\xb0\xa7\x7f\x7d\x42\xfa\xe1\x69\xa6\xeb\x06\xe9\x4b\x6c\x6f\xbf\x0f\xf8\x08\x01\x3e\xf4\x20\xc1\x32\xa8\xb6\x31\xbb\xc5\xe3\xd1\xaa\x0c\x06\xd6\x41\xb1\x54\xa6\x4f\xeb\x76\x5b\x2c\xac\x99\x60\xc5\xd3\x04\x2b\xe6\xaa\x5b\xeb\xc5\x14\xd1\x2d\xd7\x5d\xa2\xc6\x38\x16\xbe\xf1\x2f\x65\x43\xaf\xef\x91\x02\xe8\x30\x1a\x3d\xe8\xce\x99\xf3\xa4\x86\xfa\xba\x2f\xff\xde\xaf\x57\xcb\xb3\x0d\x88\x3f\xc6\x70\xf7\x6d\x64\x3e\xff\xa5\xdf\x4c\x9b\x61\x3e\xea\xde\xb1\xe5\x8f\x6d\xa5\x27\xd7\x48\x57\x01\xbe\x5d\x00\x5f\x0f\x80\xcf\x0c\x62\x22\x08\xd8\xcb\xf4\x39\x1c\xa2\xc5\x62\x52\xb1\x06\x30\x8e\x79\x13\x6f\x0a\x65\xd9\x45\x9e\xf7\x19\x04\x81\xcd\x54\x63\x38\x1d\x4d\xe0\x94\x55\x4e\x7a\x7f\x78\xa2\x2e\x1b\xe1\x25\xb1\x37\x80\x59\x00\x0d\x69\x17\xca\xb2\xb1\x4e\x62\x92\xb0\xb3\x2d\x30\xd0\x95\x95\x18\xec\xf2\x95\x3d\x4b\x2f\x2e\x91\xce\x00\xbc\x2d\x65\xe0\x31\xd8\x68\xff\x56\xf4\xf0\x2f\x77\xb6\xde\xda\xa6\xc7\x54\x07\x68\xd6\x16\x18\x7a\xb9\x56\xfd\x1d\x80\x3d\x0c\xb0\xe3\x18\x5b\x58\xbe\x95\x67\x29\xb3\x45\x4f\xb0\x69\x48\x41\x99\xce\xdb\x56\x9a\xe8\x44\x56\x48\x8d\x16\x0d\xdf\xbc\x22\x2d\x40\x83\x6f\x20\xe1\xcd\x6d\x1b\xd7\xed\x5e\xb2\x85\xf9\xdb\x57\xd2\x77\xcc\xe7\xd2\x3f\x9f\x7e\x3e\x31\xe2\x28\xe6\xa3\x6b\xe8\x1a\xf3\x13\xbc\x47\x4b\xb5\x88\x99\x94\xb8\x15\xa5\xd1\xe9\x55\x1c\xc7\x22\xfc\x2e\x75\x92\x98\xa2\x29\x72\x4e\x46\xa8\x2c\x62\x23\xf5\x5c\xa3\xff\x9d\xf8\x88\xa6\x24\x8a\xee\x04\x2b\x7e\xbe\xed\x97\x6d\xd2\x6f\xdb\x60\xfd\x2b\xf0\xb7\xab\x64\xfd\x68\x4c\x54\xb1\x94\x96\xa7\x69\x2d\xa5\xd5\xe9\xc1\x36\x53\x11\x94\xa3\x5b\x5f\x90\x8a\xa4\x5b\xca\x71\xf7\x78\xf2\x11\xaf\xd0\x9d\x60\x75\x0a\xde\xf2\x6f\x74\x6d\x1b\xe2\xe0\x15\x37\x7d\x44\x4e\x3d\x84\x3e\x66\xdb\x70\xf8\xce\x06\xb8\xd2\xcd\x19\x2c\x8c\xca\xa0\x02\x57\x96\xb7\xf2\x56\xad\x43\x3c\x8e\x70\x9e\x99\x16\x15\x27\x63\x0b\xc5\xc5\x69\x31\x55\x2c\x9e\x40\xda\xe3\xec\x4b\xd2\x8a\x1b\x0f\xd0\x88\xfa\x2d\x82\x3c\x16\x1b\x1c\x9c\xf9\xbd\x36\xe4\x5e\x43\xdb\xbb\xfd\xb0\xea\xda\xcd\xc4\xb7\xa8\x6e\xc8\xd1\x8c\x45\x83\x56\x3f\xf2\x28\xbd\xa8\x28\x72\xff\x63\xd2\x86\xda\x3b\x91\xfe\xc7\x1f\x10\x2f\x25\xaa\xba\xf7\xde\xfb\xfc\xce\x57\x08\x4c\x97\x61\xdf\x0d\x64\xdf\x00\x53\x72\xce\x0c\x0b\xfb\xa6\xf1\x8c\x99\xff\x41\x52\x90\x9e\x81\x51\xd2\x8e\x9b\xa9\x94\x86\x5e\xb8\x80\xb6\x5f\x40\xd7\xd0\x6e\xa9\x3f\x9c\xdf\x2c\xb4\x5a\xde\x3b\x4d\xa3\x6b\xf4\x25\x78\x0f\xbe\x9f\x97\x73\x0c\x8f\xe1\xa5\xf1\xc2\xd5\x4d\x32\x0d\xe9\x8b\xf8\x5c\xe0\x5b\x08\x7c\xa6\x4f\x98\xc7\xe1\x3b\x26\xb0\x91\x75\x8d\x71\x2f\xad\x0e\x43\x85\x33\x74\x8a\x95\xe3\x48\xa7\xae\x54\xd3\xc9\x64\xb8\x6b\xe0\xa3\x4f\xbb\xce\x3b\xa7\xb5\x69\x77\x1a\xdd\xf7\x02\xfa\x64\xd5\x06\xdf\xa6\xfa\x1a\x5a\xfd\x4c\x22\xfe\xc4\x8b\xb2\x8d\xf1\x39\xd0\xf0\x68\x82\x83\x96\x31\x1b\xe0\x40\x03\xaf\x66\xf1\x84\x1f\x9d\xa0\x41\x34\x7b\xab\xc0\x4c\x36\x06\x6c\x1c\x21\xa1\x26\xdd\x83\xb1\xec\x52\x23\xb0\xce\x9f\x9f\x03\x78\xd8\x7b\x4d\x1a\x07\xbb\xbc\x86\x2e\x0c\x95\x1e\x05\x64\xb4\x43\xaf\x4a\x43\x12\xaf\xc9\xf7\x44\x3e\xd8\xe5\x35\x78\x27\x47\x65\x1e\xc6\x73\x0c\x78\x81\x50\x31\x93\x24\xb2\x46\x05\x8b\x91\x6b\x43\xbe\x8b\x18\x85\x80\x98\x63\x8f\x13\x98\x17\x03\xcc\xbd\xe0\xfb\x4e\xaa\x2a\x66\x01\x69\x6b\x60\x29\xca\x69\x70\xba\xdc\x16\x60\x41\xb5\xdd\x78\x14\x15\xec\x17\x28\xc3\x51\x02\xb2\x12\x27\xbb\xf5\xec\xca\xaa\x91\x16\x85\xb4\xa9\x3e\x86\x3e\x54\x8d\xb0\xae\x79\x9c\x47\x5d\x5f\x5a\xf7\x52\x37\x9a\xdf\x8f\xf4\x2f\x18\x03\x66\xff\x2e\x78\xf0\x1a\x3d\x68\x66\x2f\x87\xf4\x73\xe2\x0a\x9d\x87\x54\x9e\xbb\xfa\x25\x76\x30\x9f\x27\x3e\xac\x58\xd1\x79\x1a\x5d\xac\xd0\x78\x92\x9e\xf4\x00\x97\x1e\xb1\x2c\xa7\x51\xa9\xf4\x9c\xde\x60\xd4\xb6\x57\x13\x26\xe2\xe1\xff\x39\x80\x4a\x95\x12\xfe\xd1\xea\x66\x70\xa9\x11\x01\x27\x8a\x22\xb8\x18\x9b\xb1\x4a\xc3\x74\xfb\xbf\x44\x3b\x75\xfb\x01\x82\xc4\x82\xca\xc4\x61\x40\x43\x62\x66\x0d\xdd\xfe\x76\xef\xc4\xe1\x6b\x70\x9f\x55\x94\xca\x60\x54\xc3\x3b\x8b\x40\x09\xe2\x77\x22\xfc\xde\xdf\x7f\xa7\x05\x97\x7d\xcb\x13\xf4\xca\x2a\xd1\xe5\xfd\x3a\xb4\xf3\xcb\xfd\x3a\x69\x18\xc6\x79\xe2\x74\xcd\x4c\x86\xb9\xe9\xa3\xbb\x57\x2e\x48\x30\xb2\xdc\x5b\x8e\xfe\xc2\x76\xe7\x3e\x26\x39\xc7\x20\xf7\xcc\x3c\xbc\x85\x72\xba\x8c\x6a\xcc\xc5\x36\x8a\x51\xb8\xb8\x89\xdc\xa3\x08\xd7\x52\xd1\x52\x2a\xbd\xce\x83\xed\x2e\xdd\xfc\xfc\x6a\x03\xd5\xf0\xc5\x55\x84\xde\xda\x78\xef\x8a\x8d\x8f\x2c\xbf\x6f\x3d\xf3\xd7\x6f\xa5\x6b\xc8\xfa\xdd\xf7\x48\x2b\x5d\xff\xd7\x33\x87\x0e\x3c\xf7\xec\x89\x23\xf0\xde\xef\x81\x27\xfe\xc2\x7d\x0a\x3e\x4a\x0b\x6a\x78\x2c\xd7\x6c\xb1\x64\x67\xdb\xfd\x3e\x5f\x61\x21\x70\x55\xc8\xa8\x55\x87\xd4\x5e\xbb\xdd\x1b\x2d\xb5\xf8\x7c\x66\xbf\x3f\x2f\x0f\x1b\x9d\xba\x62\xd7\x31\x00\x48\x07\xa0\x25\x8b\xa1\x53\xf1\xa1\x46\x42\x4e\x2a\x8d\x34\x02\x49\xc2\x08\xf6\x71\x79\x7a\x08\x3d\x69\x39\xcb\x1e\xb9\x45\xd9\x0d\x2e\xc6\xaa\xae\x6a\x53\xdf\xad\x47\xed\xdc\x47\x76\xd5\xd6\xf5\x1b\xfd\xda\x81\xbd\xe7\x47\xf6\xad\xaf\xd9\xf5\xd0\x1f\x87\x0e\xe8\x3b\xe8\xd0\xc0\xfe\x5c\xb8\xaa\xac\xba\x7d\xa7\x9a\x35\xf7\xad\x5d\xd0\xe3\x1e\x0f\x6d\x9e\x37\xee\xfe\x27\x9f\x5c\x35\x62\xb1\x99\x71\x4d\xeb\x3c\x7e\x51\x62\x4c\x6d\x6d\xbf\x9a\x17\xfb\xe2\x3c\x7c\x16\x68\xdc\x05\xe7\xaa\x01\xcd\x58\x14\x33\x19\x39\x0e\x0f\x8a\xa6\x2c\x56\xd6\x68\xe4\x0d\x02\x16\x20\x3c\x11\x20\xcd\x05\x13\x51\x7b\xf9\x78\x26\x5e\x00\xd7\xd4\x28\x5a\xc6\x75\xfc\x99\x7f\x5d\x44\x2f\xbf\x78\xec\xcd\x03\xef\x7c\x18\xef\xcb\x3e\xbc\xe1\xb0\xb4\x9d\xf9\xfc\xd9\xc7\x9e\x94\x4e\x0d\xc6\x67\xfa\x26\xbc\xaf\x1d\xa1\x23\x1b\x9e\x96\xa2\x33\x18\xf4\x6a\x33\xc8\x2a\x35\xeb\xb0\xeb\x68\xda\x6c\x66\xc5\xdb\x09\xc4\xe8\x2d\xfd\x79\x99\x90\xfc\x6a\x8c\x30\x3c\xe0\x87\xb8\x80\xcc\x90\x4f\xff\x79\x11\x7d\xf6\xd2\xd1\xa9\xa3\x10\xf3\xeb\x5e\x09\x6c\x82\x78\x3d\x48\x87\xb9\xd2\x7d\xcc\xe7\x5b\x1e\x1c\xb7\xc9\x2d\x0d\xa3\xf7\x3d\x28\xfd\xb9\x2f\xa6\xe9\xb7\x00\x16\x8a\xd8\x70\x39\xc0\x47\x60\xc1\xf1\x3c\x0b\x44\x0d\x0c\x85\xb7\x4d\xcb\xdb\x6e\x3c\x3e\x99\x9d\x95\x69\x30\x6f\x5e\x94\x2e\x31\x65\x5c\xde\xcd\x33\x4c\x6c\xdb\x36\x59\xc6\xbd\x8e\x3e\x01\x71\x7e\x49\xd6\xd2\x3c\xa3\x33\x32\x46\xd0\xd2\x6c\x52\x73\x16\xdf\x12\x46\x0e\x12\xe6\x4b\x6b\x89\x40\x0f\x39\xf7\xfe\xc5\x19\x23\xee\x9e\x7e\xf1\x73\xf4\xc9\xf9\xe3\xf4\xdd\x89\x67\x16\x4e\x5f\x3a\x8b\xee\x9f\xd8\x7a\xf2\x5d\x92\x3b\xf6\x11\xc0\xfc\x23\xbc\xc3\x0d\xd8\x33\xea\x59\x3b\xa3\x71\xb9\xdd\x5e\xad\x46\xe3\xe1\x4c\xf8\x45\x2e\x4a\x83\x0a\x0e\x3a\xf4\x7a\xa4\x56\xe4\x92\x48\x62\xf8\x4a\x8b\x25\x12\x92\x25\x75\xdc\x40\x56\x46\x40\x22\x13\xb5\xe0\x89\x28\x51\x4b\x26\x63\xc3\xa9\x08\x0d\xff\x5a\xa6\xf6\x99\xdc\xcb\xfe\xf5\xe3\xa5\x7b\x4a\x99\xc2\x85\x7f\x9d\x2b\x88\x06\x4d\xf9\xcc\x4b\x20\x17\xda\x45\x76\xa8\xfa\x2e\x49\xbc\x0a\xdc\xfa\xd1\x75\xf3\x67\x74\x7e\xe2\xbb\xe0\xc0\xda\x36\xdc\x75\x3a\x97\xd4\x74\x08\xe8\x63\xe6\x5b\xf6\x3a\xe1\x9b\x1e\x31\x97\x3d\x2b\x4b\x68\xd1\xc2\x9b\x6f\x64\xbc\x4c\xb4\xd4\x60\x30\xe7\xf0\x61\x33\xcf\x6b\xcd\x47\x51\x8b\x43\x1e\x57\x51\x51\x80\x3a\x4a\x90\x82\xe7\x01\x12\x15\x43\xac\xc0\xe2\x26\x5e\x64\x12\x4f\x65\xe0\x9b\x35\xbd\x6b\x92\xdb\xe9\xda\x64\x13\x3e\xc4\x5b\xc0\x8f\x53\x18\x09\x7d\x3d\xe1\x9e\x87\x1f\x7e\xaa\x65\x59\x45\x0b\xfe\xbc\x79\xdb\xfd\xf7\x3f\x66\x8f\x58\xed\xa2\xc7\xe3\xb3\x76\xed\x04\xfe\x50\xdb\x91\xf1\xea\x92\x9c\xce\x43\xd0\xc7\x73\xa6\xcc\x5c\xc8\x30\xd9\xf5\xed\x4b\x5b\x69\xa6\xce\x58\xb3\x52\xba\x56\xd1\x9a\x9b\xc4\x0a\x2c\xd3\xad\xeb\x26\x34\x95\x66\xaa\xda\x54\x94\x4f\xe9\x0d\x74\xfb\x19\xec\xed\x0d\x65\x6f\xdd\x62\x9e\xec\x2c\x9b\x07\x36\xe6\x61\x4a\xa3\x42\x76\x38\x2b\x2b\x90\x9d\x6d\x0e\x14\x79\x3c\x2e\x2a\x00\xbb\xdb\x6f\xc0\x9b\x2c\x56\xb4\x82\x6c\xc1\x90\xdd\x89\xe9\xc6\x06\xb1\x36\x9a\x5e\x63\x2b\xad\x82\xe5\xc4\xd2\x76\x0c\xe9\x7c\x53\xc1\x54\xa6\x86\x7b\xd1\x57\xc9\xce\xca\x5a\xfe\x1f\x3b\x63\xaf\x2b\x3b\xab\xe9\xa4\xec\x0c\xd9\xd3\x76\x26\x3d\x94\xda\x59\xf2\xdc\xf0\xde\x9c\x60\x19\x57\xc5\x8c\x2e\x0a\x5c\x3b\x56\x9d\x09\x7e\x44\x56\xc8\x6b\x3f\x8d\x5a\x50\x7e\xca\x04\xdb\xd1\x20\x5c\x09\x52\x22\xf7\xbf\xbd\xe5\xfa\x14\x81\xb0\x8a\xf2\x70\x2c\x8e\x10\xd0\x56\x28\x55\x70\xe7\x20\xa2\x8b\xb4\x7f\x60\x18\x15\x7b\x88\xe3\x5f\x61\x04\xa6\xdd\x4b\x8b\xd7\xad\xbf\x7f\x7b\x1b\xa6\xb6\xd7\xe6\x4d\x3d\xfa\xb0\x93\xc4\xa1\xea\x36\x33\xa5\x21\xde\x07\x84\xc1\xee\xd5\xef\x9c\x38\xf6\x87\xfb\xa4\x86\x05\x2b\xa4\x5f\xa5\xc4\x03\xd8\xbf\x28\x02\xbb\x6e\x2b\xc1\x7f\x29\x55\x45\x0d\x8b\x05\x2b\xc3\xf9\x3a\x9d\xaf\xa2\x22\xb3\xc4\x22\x64\x0a\xad\x5a\x3b\x8d\xd1\xa8\xdb\x6c\xb7\xbb\xb5\xf9\x95\x99\xf9\xf0\x71\xc3\x09\x1c\xa6\xb3\x83\xc1\x2c\x5c\x5a\xdc\x02\xd3\x19\x21\xb4\x26\x7e\x50\xa3\x51\x9f\x8a\xe6\xcb\xe7\xe2\xa8\x68\x9e\x62\x40\xc2\x04\x78\x57\x6d\x51\x80\x1c\x50\x76\x05\x87\x13\x0d\xda\x31\x70\x38\x4a\x7f\x48\x34\xe7\xfd\x7e\x03\xcf\x4e\x9a\xbf\x79\xc3\xb3\x2d\x5b\x57\x95\x73\xe7\xcd\xcf\x3e\xb0\xb1\x26\xbe\xf6\xa9\x9d\xe8\x8f\x7d\x3a\x8f\x75\x1f\xec\x49\xdf\xe8\x32\xea\xde\xea\x42\x67\x59\xe2\x83\x58\x77\x56\xfa\x1b\xdf\x83\xbd\xbe\x7d\xfb\x9c\x29\xb3\x17\xd0\xf8\xb4\xca\x5a\x6a\xa6\x4d\xef\xd9\xf3\xe3\xf7\x0c\x13\xa6\x0c\x36\xbd\xbb\x7a\x66\x9d\x9f\x51\x79\x8a\xc3\x15\xe5\x89\xef\x07\x0f\xbd\x73\x88\x72\x5e\x9f\x30\x6f\x80\x6d\x66\x83\x73\x81\xf3\xf2\x9a\x8c\x78\x44\xb9\x1d\x64\x78\x20\xe8\xb2\xe0\xf3\xd2\xa3\x52\x72\x5a\xbe\xa4\x92\xac\x4e\x3f\x2f\x65\x14\xbd\x5c\xc5\x1d\xb2\x0a\x21\x22\x7d\x84\x68\xb3\xea\x48\xe6\x8d\xf5\xab\x6a\xa7\x67\xd0\xea\x63\xfc\x69\x86\x69\xbf\x7b\xe9\xda\xf3\xdd\x7b\xf5\xaa\x83\x03\x63\x26\x1c\xff\x43\xd7\xf6\x35\x85\x3d\x46\x31\x77\x49\x9f\x2c\xd8\x70\xf9\xc4\xb2\x85\x2b\x96\xcc\x5f\xd9\x04\x36\xdc\x69\xc2\xe0\x51\xdb\x4d\x46\x86\xb1\xd8\xd4\x36\x7f\x40\x04\x53\xa1\x14\x24\x94\x0e\x20\xcc\x00\xb5\x52\xac\xd8\xa6\xd1\x46\x53\x21\x9a\x9a\xd7\xde\x94\x86\xa2\xd9\x58\x3e\x3a\x98\x46\x52\xd2\xa5\x11\x11\x4d\x9f\xe6\x5f\xed\x5d\x83\x09\x09\x5d\x03\xfa\x79\xe0\x9d\x13\xc7\xdf\xbb\x6f\x11\xb2\xdf\x7c\xc8\xfe\x10\x5a\x36\x6f\xa5\xf4\x9b\x74\x73\x0d\xc1\x9d\x1d\x68\xfd\x08\xd0\x11\xf6\x03\x5b\xc7\xec\x76\xad\x96\x61\x3c\x6e\x87\xa8\x56\x7b\xb4\x76\xbf\x5a\xd7\xd5\x6e\xc7\x39\xb6\x2d\xf6\x9b\x0c\x49\xe9\x84\x45\x53\x7e\xfa\x68\x8b\x46\x99\x04\x08\xcb\x40\xf2\x18\x07\x07\x9f\x9c\xd4\x31\x79\xe7\xbe\x83\x3b\x9f\xda\x29\xe5\xf4\xea\x39\xc6\x73\xb0\xe7\x7f\x3a\x74\xa7\x51\x26\xdf\x03\x7d\x7c\xf9\xb5\x13\x6f\x7d\xfc\x1e\x3f\x71\x36\x9c\x2c\xfd\xf8\xf0\x38\x39\xce\x66\x30\x95\xc7\x44\xad\xdd\xce\x30\x6e\x0f\x86\xc9\xed\xd0\x68\x30\x38\xc5\x32\x38\x2d\x92\xe0\xdc\x02\x4d\xb2\x3e\xa6\x91\x36\x2d\x32\x45\xd2\xc3\x64\x68\xd0\x1f\x15\x68\x52\x54\x97\x0e\x4d\x62\x8c\x4c\x5c\x08\x95\x03\x2c\x9b\x08\x9f\x75\x8a\x79\xe0\xed\x9e\x4c\x26\xcc\xe4\x64\x0b\x3c\x6f\xf2\xf0\x1e\x37\xc6\x90\xdb\x6d\x15\xf5\x18\x45\x59\x81\x46\x14\x61\x1c\x5d\xae\x42\xc5\x98\xc7\x64\x53\x47\x51\x98\x4d\xac\x18\x90\x67\x29\x67\x8a\xd4\xb7\x2b\xbc\xc5\xd3\x13\x1f\x7e\x6e\x54\x7d\x4d\xed\xa3\xf3\x16\x3e\x21\x6e\xe3\x62\x2d\x5b\x94\x0f\x1e\x33\x79\x50\xdb\x8a\xe2\xee\xfa\x67\x5b\xa1\x8f\x67\x4c\xec\x71\x97\x96\x31\x0e\xea\x30\x68\xe6\xe4\x71\xc6\xe2\x8a\xe2\xbc\x8a\xe8\x82\x8a\xd6\x85\x2d\xdb\xb4\xf4\xfd\x39\x1d\xee\x30\x70\x84\xd5\xe7\xf7\xeb\x32\x4c\x26\x9d\x83\xa1\xd5\x21\x3a\x14\xc9\xb6\x5b\xdc\x18\x60\x9e\x49\x03\x58\x6c\x36\x4f\x10\xc3\xfa\x5f\x73\x1b\x92\xa9\x0d\x23\xfe\xd3\xea\x59\x7d\xf7\xe2\x8a\xb6\xf1\x29\xe3\xe2\xe5\x2d\x5a\xc6\xb8\x6d\xe6\xc7\x17\xce\x7f\xe4\xf9\xbe\x13\x9f\x43\x1f\xff\xd9\x07\x30\x15\xb6\xaa\x5c\x10\xad\xc8\x2b\x2e\x2f\x31\x8e\x9b\x3c\x65\xe0\xda\x08\x52\x8f\xe9\x3e\x71\x1e\x9c\xb5\x8a\x3a\xca\xbc\x0e\x70\xfa\xa9\x3c\xaa\x6d\xcc\x18\x61\x02\x4e\x9d\x4e\x63\xce\xc8\x34\x67\xe6\x17\x78\x8e\x83\x74\xcd\xa2\x6c\xa8\xc5\x41\x81\xa5\x72\x8c\xb2\x06\x7f\x1d\x83\x5b\x9d\x8a\x92\x44\x95\x51\x55\xe1\x54\x14\xb8\x2d\xaa\x4c\x67\x15\x2c\x87\x05\x30\x26\x08\xb3\xc8\x16\xe3\xe8\x55\xdb\xad\xa7\xb5\x77\x54\xd4\xf4\xa0\xe9\x76\x7b\x96\xad\xd9\x70\xff\xb6\xb6\x2c\xc7\x1e\x62\x0f\xf3\x75\x3d\xb6\x6c\xee\x59\x77\x74\xe2\x48\x47\x51\xd9\xa8\x71\x39\x3d\xd6\x5c\x38\x76\xf2\xe2\xfd\xe2\x70\xf5\xde\xc4\xe5\x1d\xcf\xd0\xc7\xe6\x2c\x93\x7e\x5e\x46\xe8\x94\x16\xa8\x77\xe8\x73\xec\x17\x24\x8f\x2e\x1c\x53\x83\xf7\xce\x81\x17\xa7\x12\x8e\xa2\x92\xfd\x0c\xcd\x13\x68\xaf\x5c\xae\x4e\xab\x11\xc3\x03\x8f\x2c\x60\x32\xd1\xe7\x4e\x9f\x3e\x8d\x46\xac\x5f\xcf\x2c\x4f\xf0\xf4\xaf\xb8\x0f\x05\x36\xfa\x41\x4e\x68\xa9\x36\xe0\x5b\x69\x65\x8f\x50\x76\x08\x11\x78\xc5\xaa\x93\x80\x09\x0e\x95\x36\xda\x81\xc9\x54\x77\xc5\x14\x53\x1a\xfc\x23\x26\xcd\x27\x14\xdf\xa8\x87\xb7\xf0\x6f\x4b\x09\x60\xa9\x6b\x28\xde\x5a\xfa\x1b\x6b\x4f\xec\x42\x6d\xa4\x2b\x52\x31\xee\xa3\x0f\xb6\xd3\x5c\xc0\x7d\x16\xd5\x2e\x66\x31\x08\x82\x36\x8b\xa2\x54\x19\x5e\x95\x37\x1c\xf1\x33\x8c\xd3\x7c\x0c\x18\x4c\x0b\x7b\xc9\xc0\x0d\x01\x64\x9f\x2e\x3d\xf9\x41\x8e\x6a\x2b\x4e\x1d\xa9\x15\x03\x3f\x26\x3b\x6a\xb7\x45\xc9\x9d\x6f\x54\x31\x4b\x42\xe4\x97\x82\x48\x6b\xa7\xb4\xee\x7a\x9a\x3f\xa2\xa6\x43\x13\xba\x3d\x1f\x66\x83\xe3\xfb\xde\x3d\xf5\xd4\xd4\x96\x5d\xc1\xc7\x44\x2f\x5e\x9c\x37\x52\x1a\x47\xd7\xce\xaa\xe8\x5a\x3b\xb0\x66\x47\x9f\x3e\x9b\xd7\x4a\x5e\xf8\xe9\xf4\x11\xd2\x50\xe2\xbb\xda\xa9\x53\x20\x13\x6e\x10\x29\x6a\xb4\x81\xf1\x64\xa4\x05\x21\xc3\x98\xe1\x0f\x68\x5c\x27\x00\x4e\x33\xe0\xc7\x88\x8a\xf6\xb3\x98\xa4\xcb\x09\x49\xa7\xcb\x78\x05\xff\xe1\x60\x76\xb9\x03\x1b\x97\xb7\xc2\x8b\x0d\x28\x9e\xbe\x71\x47\x8b\x50\x69\x68\x79\xc7\xfe\xa7\xf9\xc3\x6a\x26\x7b\x56\xdd\xac\x85\x63\x4f\x09\xab\x99\xe2\x8e\xe8\xca\xc5\xb9\xa3\x52\x20\xf6\x7e\xf4\xa1\xc4\xab\x63\x27\xc9\x7e\xd9\x0d\xe0\xb5\x3f\x01\x1e\x71\xae\x04\x58\xba\x22\xf1\xcb\xec\x0e\xec\x97\xb5\xa0\xac\xb7\xf7\xcb\x9a\xd5\xdf\x13\xe3\x8d\xf9\xd3\x1b\xfb\x5e\x78\xfd\x8d\x97\x0f\x9c\x3a\xdf\xbf\x7e\x4f\xdf\xba\x7d\xcc\x5d\xaf\x7c\xf0\xe1\xd1\xa3\x7f\x78\xf3\xec\xaa\x79\x92\xb4\x70\x15\xae\x9f\x86\x77\x1d\x83\x77\xd9\xa9\xc2\x98\xc1\xc0\xa8\xad\x8c\xd5\xe1\x64\xf5\xac\x5e\x2b\xe2\xb7\x09\x8d\x11\x8a\xaa\xe2\x5b\x62\x14\x98\x3b\x44\x53\xfa\xb5\x03\x7d\xe7\x7d\x07\x4c\x67\x54\xdd\x2b\x36\x6d\x9c\x29\x9e\xb5\xec\x5e\xb1\xe3\xd8\x11\xf4\xf1\xfa\x79\x9a\x2e\x5d\x80\x35\x1b\x96\x68\x66\x3d\xf0\xee\x99\xe3\x97\x65\x7b\xfe\x06\x33\x1a\xf6\xf9\x2f\x70\x6e\x03\x31\x9d\x8e\x12\x78\xf9\x3e\x5a\xc3\x10\x49\x1c\x55\xae\x8c\x93\x39\x19\xc4\x60\x08\x91\xcd\xdd\x78\x7d\xaf\xbc\x27\x66\xf4\xd1\xf7\xdf\x3c\x83\x37\x43\xd6\xc3\x78\x63\xc6\xc8\xeb\x51\x3a\x8e\x97\xef\xa1\x69\xb5\x6c\x2b\x36\x59\x0f\x77\xf3\xaa\x28\x8f\xca\x78\x43\x27\xf6\xd4\xf7\x3f\x7f\xea\xc0\xbe\xd7\x98\x31\x92\x34\x6f\xd5\x99\x37\xdf\x3f\x8a\x75\x2d\xd0\xc8\x1b\x40\x23\x58\xd7\x82\x1d\xe0\x31\x09\x6a\xb5\x9e\xd8\x01\xfe\x80\x53\xb1\x03\x4a\xc0\x0e\x28\xa7\x32\xff\x07\x3b\xc0\x91\x22\x0f\x72\x4a\xa6\x46\x33\x60\xe3\x4a\x30\x03\x58\xf6\x34\x7f\x4c\xc5\xc4\x5e\x58\xb6\xe6\x3c\x08\x8c\xda\x9e\x5b\x98\x09\x27\xdf\xef\x1a\x5b\x2a\x7d\xc2\xcc\x19\x51\x93\xd3\x77\xcd\x3b\xc7\x11\x5a\x33\x6f\xc1\x4a\x42\xbf\x0f\xa2\xbf\x30\x6d\xb9\x4d\x94\x05\xe8\xd7\xa2\x35\x9b\xf5\x3c\x8b\x0b\x1c\xf4\x56\x9b\x8e\x65\xd5\x02\x07\x32\xe3\x80\x68\x34\x2a\xf2\x58\xc4\x29\x24\x0a\xa7\xa5\x77\x55\x45\x41\x1c\x62\x8a\x56\x46\xc9\x98\x70\x7c\x5d\x64\xe3\xe9\x27\xf6\xde\x39\xae\xcd\x9c\x35\x6b\xfa\xda\xf3\x3a\xa3\xbf\x9c\x46\xaf\xae\x3c\x70\x60\xa5\x34\xf3\x6e\xcd\x3c\xb9\xae\x00\x98\xff\x13\xe0\x9d\x2f\x00\x2f\x25\x31\x3d\x6f\x30\xa8\xb5\xc8\xaa\xb5\x3a\xec\x82\x0d\x4b\x15\x86\x12\x89\x9f\xae\x58\x1e\xe9\xe8\x48\x4e\xbe\x23\xce\x98\x23\x14\x51\x2c\x10\x11\x7d\x98\xe4\x90\xae\xcf\xcd\x5c\xc4\x7e\x21\xf5\x03\xde\x40\x9b\x13\x7b\x67\x56\x74\xed\xfd\xdc\xc6\x87\x90\xdc\x07\xec\x3b\xd4\xc0\x7c\xca\x1e\x05\x5a\x2d\x88\x59\x18\x23\xf8\xb6\x66\x01\x94\xba\xd3\x41\xd9\xb1\xb4\x51\xc9\x75\xe7\xc5\xd1\xe6\x9d\x3a\x03\xa5\xe5\x72\x3a\x3a\xde\x5e\xea\xb6\xf5\x3b\xf4\xe4\xab\xb3\x86\x49\xb3\xe8\x36\x93\x2b\xba\x76\xef\xd7\xf3\xa1\xd5\x52\x01\xfd\xfa\xaa\x2e\xf1\x73\xfc\x49\x35\x93\x33\xb7\xef\xdc\x65\x44\xa6\x7d\x0c\x32\xed\x0b\x90\x69\xb1\x98\x39\x13\x85\x42\x1e\x2d\xd9\xb1\x47\x1b\x8e\x64\x09\x5e\x40\xf3\x41\xc6\xef\x37\x3b\x8f\x35\xee\x99\x78\x84\x69\xc5\x53\xb2\x3c\xbd\x75\xef\xc4\xe0\x0d\x29\x2e\x49\x54\x99\x0f\x42\xbf\x3a\xa5\xaa\x7b\x9a\x54\x0b\x8f\xaf\x53\xa4\x1a\xa0\xa5\x2f\x46\xcb\x96\xc4\x5e\x45\xaa\x0d\xac\xd9\xbc\x16\xe1\x9f\x4e\x1f\x81\xb6\x03\xac\x5f\xe3\xf8\x2f\xc0\xaa\xa6\xbc\x87\x68\xb5\x46\xab\xa2\xb1\xbe\xc3\x99\x90\x69\x01\x6c\xec\x9c\x22\xc5\x29\xa5\x3f\xf8\x42\xfa\xe5\xe2\xd2\x12\xce\xb2\xed\x3c\xf8\x9f\xbf\x4a\xfd\xf7\xda\xdb\xe3\x46\x25\x88\xba\x04\xfb\x46\x44\xdf\xb7\x8f\x99\xdc\x80\x72\x9d\x89\xe5\xfd\xbc\x3f\x92\xed\xd6\x59\x80\x3f\x63\x5a\x2a\x43\xad\x66\x75\x3e\x41\x08\xb2\x8a\x2f\x96\xcc\x6b\xa9\x6e\x76\x05\x88\x94\x2b\x40\x20\x76\x7c\x01\x98\x9a\x1e\x0c\xc6\xbf\x43\x36\xed\xe4\xdb\x3f\x6f\x64\x7c\xf9\xd8\x7e\xf9\xb1\x96\x95\xd9\xe1\x1e\xa5\xe1\x2d\x8b\x16\x6d\x09\x97\xf6\x08\x67\x57\xb6\x6d\x9d\xdf\x77\x5c\xf9\xf8\x08\xbd\xa0\xa8\x6d\x45\x74\x4b\xb4\x55\xd9\xf0\xb6\x43\x0b\xef\x5a\xba\xf4\xae\xc2\x21\xd5\xc3\xcb\x5a\xc1\x8f\x2a\xe4\x58\x3e\xe2\x80\x67\x2f\x70\x0d\x40\x9b\xb9\x54\x57\xf0\x91\x79\xb5\xda\xe2\x13\x43\xbe\x90\xc6\x0b\x7c\x9b\x97\x6f\xf1\x81\xf1\xc2\x44\x0c\x27\x89\x05\x5f\x0e\x16\x61\x92\x73\x9b\xdf\x96\x54\x29\xa1\xa4\x24\x0b\x67\x87\xc0\x16\x05\x16\x56\x26\x1f\x67\x22\xae\xd1\x96\x49\x39\x90\xcc\x85\xed\xeb\x67\x0e\xe2\xb9\x33\xbb\x76\x6d\xdc\xb2\xe9\xae\x19\x89\x44\xe6\xe0\x92\x9a\xba\x69\x53\x07\xf4\x6a\x5d\xdd\xbd\x0b\x23\xac\x7d\xaa\xc3\x1d\x3d\xde\x63\x1a\x9e\x7f\x6c\xe9\xac\xbd\xd5\xb6\x87\x3f\x72\x86\x86\xd5\xf6\x1f\xb6\xda\x54\xdb\x39\xda\x79\xc8\x54\x42\xe7\x5f\xc3\x1e\xbe\x80\x73\x34\x91\xdb\x08\x13\x4e\x6e\x35\x8b\x9c\xe1\x38\x80\x8b\xe3\x1c\x25\x58\x1e\x37\x46\x6f\x71\x62\x2d\x4e\x13\x6c\x47\x5b\xa2\x88\x07\x67\xa3\xf2\xeb\x37\x1f\xd2\xb8\x68\xc6\x60\xdc\x78\x41\xba\x11\xb3\xbe\xe1\x2a\x00\xda\x69\xeb\x9b\xe9\x77\xb4\xaf\x42\x5f\x26\xf2\x5f\x7a\x76\xe7\x1a\xac\x67\x7e\x05\x79\xf9\x3e\xe0\x4a\x8d\xa7\xd9\xc6\x1c\x9c\x43\xab\x75\x3a\x6d\x1e\xca\x68\x33\x7a\x33\x18\x87\xc3\xec\xd2\x68\xb5\xae\xe3\x80\x29\x15\xe8\x43\x45\xe9\x28\x46\x71\x93\x3c\x69\x39\x3d\x2b\x5b\x91\x67\xd9\x8e\x54\x7c\xcd\x14\xce\x2e\x0f\xd8\x18\x7d\xfb\x2e\xe7\xfa\xf6\x7a\x69\xd0\xe8\x4f\x7a\x0f\xbc\xb0\xf3\xa5\x13\xa8\xcd\x07\x74\x47\x26\xd6\x7b\x6d\xf7\x9e\x9f\x8e\x9d\xc6\x58\xb9\xb7\x7b\xec\x9b\xf3\xf4\xab\xc7\x77\x20\xc3\xd4\x4f\xc7\xad\xc4\xb0\xed\xa6\x4e\xb0\x41\xa0\x3f\x17\x58\x72\xb1\x98\x68\xf2\xb1\xac\x45\xcf\x71\x6a\x37\x40\x1b\x08\x7a\x1d\xd8\x96\x00\x3f\xe7\x90\xcf\x62\xe1\x18\x5e\x26\xc0\xcb\x98\xf3\xaa\x9b\xb0\xbf\x02\x9c\x15\xcf\x80\x13\xe5\x3c\x2b\x07\x89\x63\x38\xe4\x83\xc4\x62\xd8\x26\x56\xb0\xc1\x53\xfb\xb7\xef\x3d\xbc\xfe\x29\x63\x75\xe7\xc1\xb5\xb3\x17\x2f\x79\xf2\xf8\x88\xbe\x87\x98\xd9\x67\xdf\x53\x4b\x9f\xa3\x0c\xf5\xc5\x13\x2f\x9f\xf5\x2e\x32\xad\x9d\xb6\x7c\x19\x87\xe6\xae\x79\xe8\xad\x97\x11\xf5\x8c\xb4\x4a\x23\xeb\xb1\xbf\xc0\x79\x7d\x07\x7a\xc2\x43\xb5\x04\x5e\x51\x59\x2c\x66\x41\x6d\x56\x7b\x33\xf4\x2c\xaf\x01\xa3\xa7\x1c\x5c\xb1\x92\xfd\x2e\x47\xca\xc1\x48\x4f\xba\x4c\xca\x86\x52\x38\x41\x5c\xb7\x82\x42\x4c\x31\x2e\x38\x0f\xa1\x22\x9a\xf8\x19\x68\x46\xf5\x80\x71\x9a\x9c\xf1\x6f\x36\x20\xd7\x5b\x2b\x5c\x4e\x36\x24\xae\x79\x0b\x45\x67\xe5\x45\x5c\x5e\x8f\xa7\x15\x7b\xa3\xf7\xa7\x79\x23\xbf\x94\xdc\x89\x33\xa8\x45\x87\x8e\xc6\xc1\x21\xe9\x0a\xdd\xed\xa7\xce\x3e\xed\x4a\x3b\xd5\xd0\x40\x0b\x0d\xf7\xd0\xe7\x98\xb5\x26\x81\x89\xd0\x63\x13\xeb\x48\x9f\x9b\x8d\x0d\xf7\x30\xed\xe9\xa5\xf0\xb3\x42\x7a\x82\xf2\x33\x7b\xc3\x04\xe6\x08\x3d\xdd\x24\x70\x73\x28\x4a\xfe\x19\xf5\x35\x3c\x77\x95\xfc\x6c\x9e\xfc\x33\xcc\x5f\x52\x2d\x73\x81\x79\x98\xf0\x57\x2c\x66\xf3\x52\x0a\x77\x51\x98\xd3\x34\x94\x26\x3f\x0f\xf3\x56\x47\xe0\xad\xf6\x84\xb7\xaa\x65\xde\x4a\xd3\x02\xe6\xc6\x08\x67\xf8\xff\x15\x5f\x6d\xf9\xbf\xd9\x0a\xef\x47\xea\xc9\x7c\x41\xf6\xb3\x30\xb9\x1f\xea\x27\x69\x32\x73\x85\x9e\x0f\x67\x17\x01\x6d\x26\x7a\xf5\x14\x1f\x0c\xda\x29\x7b\x4e\x36\x13\x0e\x1b\x7c\xae\x63\xe8\x0e\xca\x80\x62\xb7\x09\xd0\x36\xaa\xf6\x4c\x1a\x3b\x5e\x21\x52\x0b\x9a\x94\x6e\xe9\x7e\xfe\x95\x57\x9e\xee\x36\x3b\x53\xdd\x6e\xce\xd2\x39\x33\x84\x5d\x99\x5d\xa2\x1b\x0e\xd4\x9f\x7d\xf1\xd0\xc9\x0b\x75\xfd\xfb\xc5\xfb\xd6\xed\x45\xaa\x17\x2e\x95\xe5\xd5\xf6\x0e\x0e\x98\x60\x31\xf2\xe3\xaf\xfd\x70\xfe\xca\xc9\xc3\x73\x66\x4c\x5a\x34\x7b\x21\x81\x7b\xb7\xd4\x8b\x0d\xd2\xf7\x02\xdc\x8b\x01\xee\x87\xc9\xcf\xfe\x02\x7b\xf9\x8e\x5e\x06\x3f\x5b\x92\xda\x4b\xbe\x52\x37\xe2\x87\xbd\xf4\x8d\x15\xa8\x45\x83\x81\xcf\xca\xb4\xf3\xf6\xec\x1c\x4b\xa0\x36\x6e\x31\x85\x1c\x75\xf1\x8c\x50\x46\x88\x32\x0a\x46\x5a\xc7\xea\xea\xf1\x40\x78\x77\xf3\x81\xf0\xd1\x5b\x7a\x5e\x27\xa9\x94\x8c\x83\xf7\x93\x26\xa8\x76\xd2\x0c\xd5\x56\x11\xf5\x2b\x73\x16\x09\x63\x31\x41\xec\xa1\x33\xb3\x5f\xac\xef\xf2\xba\x74\xea\xed\x56\xad\x96\x1e\xaf\x59\x86\xaa\xa5\x9c\x64\x36\xe6\xf4\xfb\x78\xa4\x52\xb5\xb4\x3e\xf3\x0c\x7a\x8a\x7e\x39\xb1\xed\xb1\xe5\x28\x83\x1e\xd6\x73\x78\xe2\x6c\xbe\x92\x85\xc9\xec\x90\xd6\x4e\x23\xb2\xbc\xe1\x08\xec\x67\x12\xf7\x16\x55\x44\xb5\xa6\xee\x8c\x15\xdb\x2a\x2a\xb2\x8a\x33\xbc\xa6\xfc\x7c\xbd\x8a\x06\x85\xdc\xb6\x4d\x5e\x34\x3b\x5a\x1b\xcf\xb6\x67\x54\x05\xaa\x6a\xe3\x2e\x95\xde\xaa\x82\x8f\x21\x00\xce\x3c\x49\x49\x48\xce\x13\x10\xa3\xb7\x14\x61\xc9\x51\xb5\xa4\x1d\x14\x05\xb5\x9c\x0d\x4e\x45\xa8\x1d\x1d\x75\x80\xc4\x02\x9b\xbe\x32\x6a\xa0\xf3\x51\xb6\x4d\x88\xca\xd3\x24\xad\xb4\x1c\xcd\xe1\x05\x8b\x35\x45\xa0\x41\x7e\x8d\x4a\x1d\xce\xd5\x2c\x50\xe5\xf7\xed\x68\x46\x2e\x5d\x41\x96\x7a\x1e\x57\xd0\xb7\x93\x46\x4b\xd3\xb9\xcf\x4d\x39\x76\xe1\xca\xa1\xbb\x9e\x2c\x64\x75\x8c\xbe\x7c\x44\xf5\xf0\xf1\xe3\x46\x8f\x9c\xb6\x6a\x34\xf3\x1b\x2a\x8e\x8d\x1d\xd7\x1a\xf5\x3c\x8a\x5a\x95\x8d\x1c\xdf\x16\xb5\xdc\x3f\x78\xb4\xf4\x67\xe9\x7a\x83\xf4\xce\xa8\x11\x05\x73\xf4\x74\xe8\x9e\x1d\xf1\xa3\x47\x8f\x9c\x3c\x83\xcf\x75\x44\xc3\x37\x9c\x03\xf0\x50\x42\xb5\xa5\x86\xc6\x8a\x5d\x95\x95\x9a\x16\x3e\xb3\xc8\x30\x45\xd9\xc1\x12\x4d\x49\xbb\xea\x7c\x57\x46\xc4\x05\x1f\xbd\x9f\x32\x95\xe9\xcb\x6a\xe3\x7a\x13\xd3\x4a\x68\x55\x1b\x17\x9a\xa6\x66\xa4\x8d\x58\x10\x6f\x8f\x88\x00\x0e\x0b\x35\x69\x0c\x9e\x5d\x5e\x8c\x14\xcc\xf8\x10\xa0\x26\x9a\x42\x0d\x98\x31\x28\xbd\x43\x38\xd3\x82\x57\xb3\xe5\x4f\x4e\x38\xf0\xf6\x3b\x27\x27\x6e\xcd\xa3\x69\x94\x86\x1a\xe4\xd2\xa6\x70\xa3\x51\x49\x57\xa7\x8e\x1a\x3d\x6e\xfc\xf0\x76\x23\xcb\x6d\x8b\x32\x26\xc6\x51\x01\x49\x2f\xcd\x19\x31\x74\xff\x4e\xa4\x20\x07\xf5\x7a\x45\x46\xce\xcd\xe9\xa3\x57\xd1\xc1\x17\x4f\x1f\x3f\x72\xf4\x48\x7c\x07\xee\xf3\x0c\x4e\xeb\x48\xee\x1a\xd0\x45\x3c\x56\x58\x20\x20\xa3\xd1\x97\xe1\xb1\x9b\xc2\x45\x26\xa6\xb8\x44\x74\xbb\x79\xa4\xd3\xd9\x79\xde\x67\x0a\xe5\xd4\xc6\x43\x88\xf2\xfa\xbc\xb5\xf1\x02\x9f\xd1\x44\x52\x67\x9a\x74\x88\x7d\x3d\x79\x57\xa4\x24\xbf\x45\x53\x56\xbb\x18\x6d\x24\x02\x3c\xe5\x2e\x45\x1e\xe4\x92\x9c\x44\x02\x6c\x72\x25\x54\xc0\x46\xaf\x45\x69\x27\x8f\xa4\x7f\x34\x6e\xbc\x01\xe0\xfd\xf8\xd2\x53\xcf\x3f\xba\x64\xe4\x9d\xe8\x38\xb3\x40\xba\x47\x39\x72\x69\x07\x3a\x9f\xdc\xa9\xf7\x54\x9f\x3d\x2f\x7b\x8f\x5a\xea\xc6\x54\x9d\xa2\x98\x86\x0b\x14\xc5\x71\xc0\xc7\x05\x54\x39\xd5\x8e\x9a\x16\x6b\x55\x94\x9b\x9b\x15\xc8\x29\x2c\x28\x68\x49\x55\x98\xc9\x04\x3f\x8e\xa3\x72\x98\x58\x75\x69\x9b\xec\xbc\xba\x40\x51\x86\xdd\xc4\xf0\xb5\xba\x0a\x97\x59\x67\x54\x87\x74\xba\x90\x9a\xe1\x8c\xc6\x5c\x8a\x94\xcc\x45\xab\x95\x0a\x30\x9c\x4a\x60\xfa\xb6\x14\xa7\xbb\x7f\x5b\x5a\x9c\xb6\xe5\x46\x8f\x20\x59\xbf\x16\xc9\x06\x75\x09\xfb\xc5\x91\x25\xf0\x59\x1c\x8a\x4b\xab\xf8\xe0\x19\x08\x23\x86\xdc\x16\x67\xbb\x90\x43\x11\xd1\x61\xbb\xf2\x5f\xe8\x87\x05\xdd\xbe\xb4\xa0\x29\x9d\xdb\xf2\xef\xf1\x74\x70\x7c\xaf\x81\x03\x2c\x74\xce\x94\x7e\xb3\xc7\x5a\xe8\xc9\x5c\xc7\x56\x5f\xbc\xf1\x46\xb8\x34\xda\x5a\x8a\x0f\xbe\x2b\x5c\x9a\xd7\x0a\x5d\xb2\xab\x25\x3b\xfa\xd0\x5b\x32\x79\x9d\xed\x95\x93\x79\x8b\x4b\xc6\xde\x39\x7c\xf4\x84\x41\x2f\xbe\xf7\x5c\x66\xf4\xee\x87\xac\xd2\x46\x34\x2f\x22\x0d\xa7\x6b\xb3\xc7\x6f\x98\xbd\x6d\x5b\x3b\x8d\xd9\xb1\x61\xf6\x2a\x2c\x1f\x4e\x00\x9e\x7c\x6c\x6f\xb0\x51\x8b\xa9\xf1\xb1\xca\x08\x9c\xb9\xd9\xa8\x13\x72\x29\x2a\x98\x19\x16\xc2\x25\x2d\xec\x85\xf5\x6e\x53\x56\x5d\x26\xaa\xcb\xe5\xea\x22\xaa\x3a\x63\x6e\x66\x24\x60\xd4\x65\x06\x8c\xc6\x40\xa6\x8e\x15\x70\x4e\x20\xc9\xdb\x52\xe6\x4c\x63\xd3\xa6\xca\xf4\xad\xfc\xa9\xfe\xb6\x34\xc5\x22\x62\x92\x47\x14\xec\x00\x7e\x02\x62\x30\x85\xa0\x00\x18\x3c\x49\xd4\xb4\x43\x95\x51\x93\x20\x82\x65\xab\xa0\x83\x69\x39\xf4\xee\x07\x5a\x4b\x5f\xf9\xcb\xe9\x05\x77\x8f\x55\x21\x1d\xce\xda\xdc\x3e\x67\xf7\xde\xcc\x28\xbd\xe0\x9d\xc4\xe0\x11\xe7\xc6\x0e\x1e\x32\x68\x2a\x1a\x68\xc8\x8b\x9a\xa4\x42\xf4\x73\x59\xeb\xc5\xeb\xd5\xcf\x3d\x70\x97\xe5\x39\xdf\xfc\x69\xef\xbe\x7b\x00\x95\x57\x49\x37\xed\xd2\xcb\xf4\x22\x6f\x07\x73\xdd\xa3\xf7\xad\x26\xb2\x51\x1a\xc0\x4e\x82\xbd\x17\x51\x6d\xa8\xb1\xb1\x68\xb1\xc5\xcc\xf8\x7c\x45\xf9\x11\xbf\xb3\xa2\x42\xe3\xd7\xb4\x6d\x67\xc9\xcc\x8c\x04\xf3\xf2\x1c\x11\xf8\xe8\xfd\x1e\x53\x54\x0f\xa2\x52\x6f\x67\xaa\x04\x10\x95\x82\x09\x67\xe7\xfe\x8e\x5c\x68\x76\x1b\xa8\xc8\x07\x60\x89\xe4\x2e\xe5\xd4\x7b\xec\xd2\xa6\x0b\xca\x40\x79\x23\x8b\x94\x65\xa3\x34\x21\x69\x40\xe8\x09\x56\xcb\x96\x6c\x9b\x78\xf0\xb2\x22\x1a\xd2\xd8\x45\xfa\xaa\x91\x5b\x54\x28\xa3\x6c\x58\x6c\xcc\x58\x22\x19\xd8\x56\xc6\xb9\x39\xc3\xc6\x4a\xef\x4b\x92\xf4\x93\x74\x05\x64\xc3\x11\x85\x77\xea\x4e\x29\x9c\xc3\x3c\x3d\x7a\x55\xe2\xd3\x39\xdb\xfa\x9d\x3a\x7c\xf4\x28\x91\x0d\x38\x47\xba\x8a\xe4\x2c\xf6\x88\xe5\x86\x35\x9c\xd9\x1c\xcc\x74\x59\x2c\x54\x41\x61\x2e\x5d\x1f\xcf\x35\x19\xb8\xba\x78\xa6\xb5\x2e\xee\x32\x80\xfb\x92\x61\x70\xb1\x96\xa0\xd1\x82\xe5\x82\x42\x02\xf9\x4d\xf4\x5e\x4a\x1a\x90\x40\x65\xf4\xf6\x02\x81\x64\xc0\x2a\xbc\xe1\x60\xab\xa6\x8e\x5e\x7b\xc0\xa4\xf9\x1d\x71\xe0\x71\x21\x63\x96\x86\x2d\xdd\xbd\xea\xae\xb1\x4c\xad\xe5\x8d\x17\x6e\x11\x06\x77\xf6\x7c\x7b\xd4\xb2\x91\xab\xa6\x8a\xb2\x6d\xe9\x21\x39\xdf\x35\x54\x90\xea\x1c\x8b\xf8\xdc\x0c\x63\xd4\xb0\xac\x35\x94\x45\x79\xea\xe2\x06\xbe\x2e\xae\xa1\x0c\x99\x99\x06\x0a\x7e\x68\x36\x3b\xea\xe3\x66\x53\x32\xb7\x51\xa9\x33\x6b\xcc\x42\x4e\x0d\xaa\xcd\x4e\x07\xde\x4c\x05\x4a\x1d\x02\xce\xf1\x4f\x9e\x25\x1d\x69\x7a\x26\x02\xf2\xa2\xc8\x63\xc3\x50\xbf\xb5\xd2\xb1\xe4\xb1\x21\x00\xf9\x55\xf4\x42\x52\x7e\xb1\x88\x77\xfd\xc3\x21\x9d\xef\x23\x9f\x0f\x86\xbb\x04\x74\xf7\xc3\x40\x9f\x15\x54\x6d\x2c\x2f\xcf\xc9\x67\x84\xca\xcb\xf5\xfa\x28\x45\x79\x32\x98\xca\x96\x7a\xa6\xd4\x53\x62\x71\x72\x42\x5e\x96\x5f\xc8\x12\xb2\x98\xec\x5a\xbf\x49\x53\x8b\xd3\x5e\x81\xef\x64\x52\x04\x5e\xc4\x43\x54\xc4\x26\xf3\x74\x64\xab\x8b\x0d\xa5\x67\xe8\x82\x47\x99\x0d\x34\x46\x98\x31\xd2\x3c\x0a\x8e\xbb\x02\x94\x56\x46\xad\x82\x9d\xad\x95\x1a\xae\x7e\xf6\x6d\xf6\x4f\xb6\x71\x4b\x66\xdd\x3d\x68\xcc\xc6\x1d\x55\xa1\x3c\x9b\xb0\xbc\x75\x37\xd3\x77\x1f\x9f\xfd\x67\xc6\x2f\xba\xa1\x63\x47\x8f\xee\x7e\xe7\x9a\x83\x55\x1d\xd9\xe5\x03\x1d\xa8\xcd\x93\x07\xd6\x3e\x12\xee\x15\x6b\xdd\xbe\xac\xad\x2d\xa3\x2c\x68\xc9\x6e\x35\x74\x89\xbb\xa0\xcd\xe3\x2f\x3d\xba\xce\xdd\xa1\x7d\xb4\x4d\x51\xa5\x35\xb3\x45\x68\xf2\x4b\x77\x54\xc8\x67\x35\xa1\xe1\x3a\xab\xe5\xfa\x82\x9e\x1e\x16\x8b\xda\xc4\x60\xd0\x63\xc9\x31\xe8\x34\x5c\x49\x4e\x49\x69\x0b\x1f\xd8\x5e\x6a\xaa\x2e\xce\xf9\xd4\x6e\xb7\xda\xc7\xb1\x05\xfa\x82\x08\xa8\x25\xbb\x55\xa7\xd7\xd5\xc6\x45\xa3\xde\x88\x4b\x7d\x1a\xb5\xd3\xad\xe7\x87\x0d\x33\xe5\x10\x53\xe7\x67\x09\x95\x47\x95\xd1\x48\x3e\x94\xa4\xcf\x62\x99\xfb\x2a\x6d\x06\xd9\x22\x45\x9d\x55\x8d\x9a\x78\xe7\xa1\x81\x7b\xd1\x52\x69\x71\x3a\x0f\xd2\xc1\x1e\xed\x17\x2c\x5f\x37\x3b\xb6\x7a\x67\xef\x74\xb5\x84\xdc\xd2\xdf\x4f\x49\x73\x91\xc2\x77\xa8\x7b\xb5\xdf\x73\xcc\xa1\xae\x59\xb7\x14\xef\x77\x9e\x9c\x8f\x4d\x85\xa8\x49\x31\x8f\xc5\x6a\x0c\xd0\x26\x5e\xe5\x0e\x06\xa9\xb0\x2a\xcb\x62\x12\x4d\x7d\xe2\xf6\xcc\xba\xb8\xd5\x7f\x14\xe9\xf7\xc7\x0d\x34\xfc\x11\xcb\x88\xeb\xd8\xba\xb8\xca\x6e\x35\xb8\x74\x3a\x97\xc1\x6a\x57\xf1\x94\x68\x44\x01\x2a\xd0\x27\x35\xf8\xdb\x99\xe4\x45\x79\xee\xbf\x32\xf7\xdc\xac\x5c\x26\x80\xb1\x56\x2e\xb3\x23\xde\x7f\xa9\x83\x24\x67\x23\xbb\xc2\x9b\xb8\x87\x6d\xc0\xf6\x00\x12\x0a\x1c\xc9\x1d\x57\xcf\x7f\x23\xf1\x1d\x53\x27\x25\xda\x04\x93\x1b\xee\xb2\xf6\x3c\x7d\xd7\x79\xd4\x5a\x43\x36\x1a\xf8\xe7\xa5\x8b\xd2\x5b\x26\xb2\xc5\x9c\x7f\x5d\x96\x63\xb0\x33\xa4\x3a\xb6\x8e\xcc\x92\x28\xc4\x59\xdb\x39\x8c\x18\x04\xe7\x38\xd3\x2b\x7a\x8b\x8b\xbc\x1e\x47\xd8\x1a\xae\x8d\x5b\xbd\xda\x7c\x43\x7e\x6d\x9c\x65\x29\x03\x25\xd4\xc5\x29\xb9\x86\xa6\x58\xe9\x53\xe1\x6c\x52\xfe\x90\x54\xb3\xe4\x32\xc9\xc1\xc9\xf4\x49\xee\x04\x53\xe2\x14\x6c\xcb\x00\x8e\x25\x67\x59\xd2\xea\x99\xe8\x31\xc7\xae\x79\xa4\xaf\x8c\x43\xdb\x8f\xb9\x8b\xa6\xef\xfc\xe7\x81\x73\x6f\x9f\x19\xbf\xb5\x80\x53\x73\xd2\x8f\x3c\xd5\x60\x9f\x3a\x62\xf4\xf8\x49\xc3\xc6\xde\xcd\xd6\x3c\x76\x7f\xa0\x7d\xcf\x87\x1f\xdc\x73\x5e\xfa\x5a\x4a\x48\xbf\x4a\x9f\x8f\x18\x1a\xba\xc7\x32\x69\x1d\xe3\xbb\xfa\xfd\xcd\xe0\xb3\xc7\x0e\xbd\xbc\x67\xd7\x09\x1c\xbf\x73\xa2\x3f\x31\x87\xd8\x63\x94\x16\xdf\x20\xe2\x5c\x39\x9c\x33\x47\x52\xc5\xc8\x19\x19\xe2\x3e\xa1\x58\xa8\x16\x18\x41\x50\xf3\xb8\x2d\x36\x18\x0b\x78\x58\xf2\x7f\xc9\x9a\xa3\x6f\x4a\x1f\x1c\x3d\x8a\x0a\x5e\x41\x7f\x42\x51\xe9\x32\xfd\xb9\xf4\x25\xf2\x24\x7c\x80\xc7\xae\xa0\xa7\x56\x02\x8d\x78\xa9\x1c\x8c\xc7\x90\xc0\xeb\xf5\x0c\x45\xb9\x33\x34\x66\xb7\x39\x37\xcf\x64\xa7\x28\x3f\x60\x8e\xb2\xab\xec\xc0\x0d\x76\x8f\x4a\xe8\x13\x57\x19\x9b\x77\x1f\xa1\x9a\x97\x84\x91\x4b\x64\xec\x6b\x55\x93\x22\x54\x0e\x77\xd2\xb6\x9b\x6d\x56\x85\xe0\xcb\xcc\x28\xbd\xbb\xb2\xde\x97\x51\xfe\xc7\xc4\x05\x66\xa5\xf4\x73\xa0\xc5\x13\x87\x57\xfe\xb2\x7d\xfb\xcf\xcb\x6f\xd0\x6d\xee\x5f\xb5\xea\xfe\x35\x2b\xee\x5d\x4b\x77\x51\x17\x58\x0b\x42\x0f\x5d\x7a\xed\xb0\x23\x23\x60\xed\x28\x7d\xbf\x7d\xcb\xf7\xcb\x56\x7c\xbb\xe5\x04\xf8\xbb\xed\x9e\x7c\xf6\xb9\x27\x9e\xde\xf5\xbc\xd2\x6f\xae\xe1\x4d\x76\x37\xf7\x2b\x55\x46\xcd\x8e\xc5\x4a\x55\x2a\xa1\xac\xc4\x68\x2c\x34\xe5\x39\x9d\xde\x70\xc0\xec\xcb\x29\x28\x08\x85\x32\x7d\x5e\x93\xc0\x57\x94\x97\x44\x22\x59\x2d\x8a\xa8\xfc\x50\x2d\x55\x56\x26\x16\x78\x59\x55\x4e\x96\x31\xd3\x5a\xeb\xb6\x99\x54\x36\x6d\x2d\x2e\xb9\xfa\x16\x8c\x8f\x6f\x5f\x97\xd3\xf1\xc0\x2a\xab\x3e\x07\xb4\x93\x5e\x13\x9c\x92\x7b\x8d\x21\xdb\xd4\x35\x88\x49\xb9\x73\x60\x08\xf1\xdb\x48\xff\xe6\x50\x65\x24\x3d\xa2\x8b\x33\xc2\x2c\x51\x24\xd0\xa7\x73\xa6\xf5\x9d\xbf\xfc\xc2\xfd\x5d\x7b\x5f\x38\xa2\xef\x6a\x71\x98\x7b\xf6\xef\x5a\x98\x3f\x73\x9c\x76\xc4\xc4\xea\x85\xab\x57\x1f\xbb\xb0\x6f\x96\xf4\x47\x96\x19\x39\x7f\xda\x87\x97\x12\xf5\xf4\x50\x94\xf1\xc2\xda\xc4\x49\x7a\xac\xf4\xd2\x28\x15\xbf\x27\x58\x58\x77\xb6\xb2\x0d\xbd\xe8\x94\x24\x9d\x92\xc6\xa3\x81\xf4\x83\x70\xbe\xdd\x12\x7f\x99\x25\xc7\x83\x87\x53\x14\x73\x37\xa9\xc7\xc6\xb5\xbd\x48\x0d\x54\xa3\x52\xe9\xf4\x82\x96\xd2\xf6\x89\x03\x01\xd1\x6a\x1b\x2e\x11\xaf\x4e\xcf\x59\x6f\xd4\x47\x84\x82\x6c\x58\xa3\x86\xd0\xf0\xb9\xc8\x35\x7f\xbe\xf4\xd5\x5c\x7a\x3d\x7a\x5e\x1a\x78\x49\xaa\x42\xe7\x89\xef\x9e\x7c\x87\x99\xe7\x1e\x93\x6b\x2a\x81\xae\x8e\x81\x7e\xc9\x04\x47\x30\x9f\x1a\x13\x2b\xd3\xe8\xf5\xba\xdc\x40\x4e\xd0\xc6\xd8\xed\x99\x1e\x97\xc3\x11\xd0\x31\x85\x05\x99\xc6\xa0\xde\xe5\x76\xf5\x89\xe7\x68\xdc\x0e\x8f\xc5\x67\xf2\xd5\xc6\x4d\x76\x06\xac\x43\x62\x04\x35\xb1\x80\x8a\x95\x1e\x00\xa9\xae\x73\xe9\xae\x91\x98\x6e\x00\x81\xb2\xb7\xc9\x81\x5b\x1c\xd6\x27\xa9\xc9\x60\x05\xe2\x81\x9b\xa9\x11\x96\x49\x8b\x67\xfb\x05\x73\x9f\x3e\xd6\x4b\xcf\x13\xab\x47\xfa\x6a\xc9\x12\x15\xfa\xfe\x05\x8f\x34\xc9\x38\x61\x40\xcd\x54\x11\x6d\x30\x8c\x51\xcc\x9c\x9f\x3f\xb8\xf4\x97\xef\xc0\xc6\x91\x86\x32\x23\x2e\x5d\x1a\xbd\xea\xe6\x34\xa4\x5f\xbc\x8e\xfe\x62\xcd\x92\x95\x2b\x81\x8f\x22\xa0\x4f\x77\x90\x1c\x7c\x0f\xd5\x3b\x96\x6d\x41\xc8\xe8\x72\xa9\x4d\x4e\x27\xa5\xd3\xa8\x29\x75\x86\xd7\x85\x34\x5a\x4d\x9f\xb8\xc5\xa8\xd5\x72\xa2\xde\xc8\xd9\xea\xe3\x5c\x5a\xf9\xe1\xef\xf5\x37\x90\xdb\x1b\x24\x2f\xb7\x49\x8e\xb5\x3c\xcc\x9b\x64\x5c\x58\xed\xec\x8e\xc1\x37\xbf\xfa\x32\x31\x7c\x38\x72\xa1\x0d\xc8\x35\x38\xf1\xda\x5d\xc3\x91\x74\xf7\x38\x74\xc5\xf8\xd7\xdf\x7e\xbe\x6a\xbc\x84\xb6\x48\xe3\xf0\xbf\x52\xee\x43\x0b\x96\xdf\x4f\x64\xa7\x2e\x35\x1b\x06\x57\xcb\x97\xda\xc2\x61\xa3\x46\x6d\x36\x64\xb8\x10\x45\xf9\xec\x59\x2e\x83\x4e\xad\xca\xc9\xcd\x30\x9a\x8c\x7d\xe2\x61\x19\x6c\x9f\x0d\xc0\x76\x9b\x8c\x5c\xa0\xf6\x76\x60\x37\xab\xd1\x49\x25\x31\x84\xb0\xc4\x07\xf5\x0f\x70\x93\x46\x52\xa0\xf0\x30\xf2\x71\xd0\x31\x04\x87\xa4\x64\x8d\xb0\x67\x6a\xe8\x65\xff\x79\xe4\x89\x6b\xf7\xa2\xda\x29\x2d\xee\xbd\x8a\xde\xee\xdd\x43\x8f\xfe\x6e\xe8\x51\x83\xde\xbe\x7a\x6f\x8b\xbb\x13\x3b\xc6\x2d\xd0\x4a\x59\x9a\x25\x68\xcf\xea\xb7\x26\x4e\x78\x73\xdd\xa5\x75\xe3\xde\x3a\x5f\x75\x4f\xb7\x6e\xf7\x54\x9d\x7f\x6b\xdc\x3a\x29\x7a\xff\xdc\xb9\xf7\xcb\x7a\x01\xcf\x9a\xc7\x31\x89\x10\x68\xf9\x78\xac\x38\xcb\xc6\x73\x7e\x3f\x4d\x99\xdc\xf9\x7a\xbd\x9b\x62\x5a\x94\xfa\x72\xbc\xb8\xe0\xd5\x6b\xb7\x3b\x2d\xce\xfa\xb8\xc5\xc3\x17\x69\x8a\x6a\xe3\x1a\xdc\x34\x81\xc4\x24\xd2\x49\xae\xf9\xc6\x92\xa6\x36\x8e\x47\x04\xc4\x54\xe8\x41\x68\x1c\x78\xd7\x16\x09\xb7\x0f\x43\x20\x97\x12\x71\x88\x3f\xf9\x5c\x8f\x01\xad\x8a\x97\xb6\xbc\x35\xf0\xc0\xfe\x55\x9a\xad\x44\x1a\xfe\xfe\xe8\xb7\xfb\x5e\x10\xff\xa0\x5b\xd8\x91\xbd\x25\xe2\x40\x62\x0e\xb0\xcf\xdd\xb0\xcf\x20\xf8\x56\x83\x62\x25\xb4\x27\xe4\x77\xd9\x6d\x42\xae\xc1\x20\x78\x18\x70\x82\x80\xf1\xea\xe3\x99\x1e\x07\x65\x8d\x88\x20\xb8\x45\x93\x50\xa0\x2d\xa8\x8d\x6b\xed\xac\xab\xb1\xf6\x30\x7d\xab\xd5\x4d\xb6\x9a\x6c\x95\xc2\xe1\x59\x88\xb7\xc6\x1c\x88\x52\x51\xf6\x6c\x69\x12\x63\x28\x5e\xba\xb8\x79\x94\xc1\x35\x8d\xec\x38\x2b\x15\x52\x78\x6f\x61\xdf\xe6\x51\x05\xb4\xf6\xd7\x7f\x48\x0d\x64\xc7\xf4\xf5\x54\x28\x81\xcc\x8c\x1a\x40\x62\x09\x41\xaa\x4f\xac\x90\xd1\xfb\x11\xb2\x88\x2a\xa3\x51\x1f\x74\xb1\x59\x21\x87\xb7\x36\xee\x40\x94\x68\x16\x6b\xe3\x7e\xb3\xd1\x88\xea\xe2\x46\x9b\x5a\xcb\x6b\xeb\xe3\xbc\x27\x7d\x40\x4a\xb4\x69\xa7\xce\x54\x38\x05\x35\x6e\x43\x9e\xfa\x78\xbb\xd8\xc1\x44\xe5\xc0\xee\x6f\x1e\x2b\x48\xb4\x54\x40\x5e\xd8\x97\x59\x90\x1e\x22\x80\xf3\xc9\x91\x6a\xd8\xb7\xd8\x1e\x54\x94\x8a\x01\x1d\x16\xb9\xb5\x39\x81\x16\x2d\xca\x80\x97\x42\xad\x19\x8b\xa5\x43\xfb\xa2\x50\x7e\x7d\xa4\xa4\x3e\xc0\x06\x22\xf0\xa1\x32\x8c\x2d\x6b\xed\xa6\x76\xb5\x26\x9b\x50\x07\xba\x18\x5b\xd9\xf0\x51\xba\x1c\x60\x6f\x17\x15\xcb\x81\xfd\x54\xb1\x62\xd3\x5b\x5e\x92\x03\xd1\xe4\x8c\x94\x6c\xb4\x80\xb2\x3f\x6c\x7c\xb6\x25\x82\x84\x29\x4b\x65\xa0\x94\x56\xa0\xbf\xed\x78\xdf\x9d\x30\xf4\x6d\x3d\xf8\x4e\x9a\x2e\x78\x7c\xf8\xf6\x7d\xc7\x5e\x1c\xfe\x60\x98\x53\x33\xdf\xf3\xa8\x78\xfc\xca\xac\xdc\x4c\x73\x86\xb5\xef\x97\xd6\x92\x7e\x95\x83\x87\x8e\xe8\x3f\x64\xa4\x54\xb3\xe5\x01\x62\xc7\xb4\x9e\x31\x7e\x28\xf2\x50\x0d\x48\x40\x99\xa3\x07\x97\x4d\xd5\x4c\x5a\x97\xb8\x26\xbd\xf1\xc6\x26\xed\x1f\x04\xa6\xa4\xf7\xf0\xf0\xd5\xef\x99\x4f\xa7\x3f\x51\x7b\xe4\xa5\x97\x9f\x3f\x41\x74\xf3\x4b\x70\x96\x1b\x80\x66\x9d\x54\x5d\xac\x40\x2b\x08\x2a\xbb\xc1\xc0\xe9\x69\x51\xe4\x54\x8c\xcb\xad\x35\x70\xa0\x97\xd4\x40\xb1\x40\xb9\x56\x8f\xce\xa8\xa6\x54\x36\xd6\xd8\x48\xad\xd5\xd5\xb7\x19\x3f\x99\x94\xfd\x84\x50\x49\x49\x55\x40\xc4\xa3\x11\x53\xe7\xca\x38\x97\x56\x49\x9f\xcd\x25\xb3\x95\x97\xa1\x22\xe9\x5e\x94\x3b\x95\x1c\x28\x50\x21\xba\xd6\x57\x9a\xc0\xbd\x75\x73\x0f\x3a\x23\x0d\x92\xfc\xca\x69\x12\x9d\x39\x4f\x1a\xc0\xf4\x01\x58\x71\x3f\x0c\x97\x41\x60\x69\x35\xab\x16\xcd\x46\x4a\x07\xc0\xe9\x3c\x1c\xc5\x0a\xb5\x8d\x80\x35\xed\xa6\xa2\x00\x93\xce\x23\xe8\xea\xd2\xe7\x40\x73\x3e\xf9\x5c\x8c\xbc\x97\x7b\xeb\xd7\xdf\xa4\x6f\x94\x97\x21\xaa\x93\x34\x81\xbd\x0c\xb6\x6c\x19\x35\x34\x56\x6a\x04\xd5\xac\xb6\x97\x95\x51\x05\x99\x79\x7e\x7f\x66\x98\x52\x73\xe5\x15\x91\x9c\x50\x4e\x7d\x3c\x54\x50\x00\xf6\x7a\x81\xcd\x54\xc2\x5a\xc0\x4a\x77\x5b\x4c\x3a\x23\xa5\xb6\xc9\x11\x7c\x45\x35\x92\x5a\xee\x5b\xba\xb0\xa5\x5a\x16\xcb\xbc\x2a\xdf\x74\x37\x8b\x1a\xd9\x94\x11\xa8\x29\x5e\x50\x9e\x45\x3f\xe0\x68\xd0\x97\xcd\x63\x45\x3d\x56\x6f\x25\x5c\x51\x83\x7f\x4b\xaf\xdf\x30\xfb\xc4\x96\xc4\x31\xa6\x4f\x7a\x7c\x28\x71\xf5\x5f\xaf\x3c\x83\xd9\xa3\x3d\xfe\xfd\xb6\x6d\x89\x9d\xb2\x8d\x76\x1f\xa6\x03\xb0\x0d\xb2\xb0\xef\xe9\xa1\xe9\x8c\x20\x6b\xd5\xe9\x4c\x7a\x3d\x9b\xc1\x44\xc2\x21\xd0\x4b\xf5\x71\xbf\xc7\xaa\x72\xaa\xea\xe3\x4e\x93\xde\x53\x1f\x37\x19\x59\xbd\x5c\xc0\xd7\x44\x6a\xfd\x0e\x19\x24\x21\x87\xed\xa6\x42\x3f\x7e\x57\x13\x92\x18\xd1\x6b\xe8\x5d\x0b\xa5\xaf\x94\x68\xcf\x8b\x73\x50\xed\x1d\x49\xa2\xa0\x27\xae\xbd\x77\xdf\x7d\xb8\x54\x96\x84\x78\x16\x4c\x95\x86\x4b\x5c\x23\x69\x24\x75\x0c\x81\xbf\x94\x1a\x1c\x2b\x09\xfb\xcc\x8c\xdf\x9f\x15\xd0\x3b\x0a\x34\x1a\x47\x80\x89\x96\x65\x19\x03\x1e\xb7\x3d\x33\xd7\x99\x5b\x1b\x77\xda\x2d\x36\x13\x28\x7b\x93\x87\x29\x16\x8a\x6f\xb5\x6a\x14\xe9\x5b\x7d\x1b\x2d\x93\x16\xd0\x69\xaa\x62\xf8\x94\x65\xf3\xfb\x81\x9c\xa4\x9a\xf1\x66\x28\xa6\xcd\xef\xc5\x6e\x6e\x6c\xfc\x22\xa9\x69\x88\x79\xc3\xfe\xd4\x3c\x66\xf3\x2c\xec\xb7\x8a\xf8\x5a\x75\xb1\x5c\x95\xd9\x6c\xa5\x9c\x7a\xbd\xd5\xc3\xf3\x56\x6b\x30\x44\x79\x68\x1f\x5d\x1f\xf7\x99\x9c\x46\x2b\x0f\xde\xa4\xcd\x60\xd2\x9a\xea\xe3\xda\x26\xf2\x97\xfc\x67\x72\x28\x72\x32\x84\x25\xdf\x3d\xcb\x47\xd5\x4c\x0c\x37\x8f\xd8\x3c\x71\x64\xb6\xb2\x9d\x8d\xcd\x22\x34\xdf\x9c\x95\xa4\x94\x14\xa6\x4f\xa6\x05\x67\x10\x35\x17\xe0\xae\x85\x73\x2a\xa5\xfa\xc6\xf2\xb8\xfc\x7c\x93\x23\x33\x4b\x03\x8a\x31\x5a\xe6\xc8\x0f\x88\x61\x31\xac\x0f\x04\xc0\x16\x08\x98\xf4\x56\x1c\x7a\xc3\xa3\x79\xeb\xd3\x46\xf3\x36\x2d\xf0\xad\xaa\x4a\x4f\x5d\x6e\x3a\xa2\x57\x39\x91\xb4\x88\x07\x7d\x4b\x9c\x83\x85\xc3\x64\x6b\x89\x04\x28\x5e\x3a\xf1\x81\xb4\x40\xc7\xbf\x76\x0c\x48\x0b\x70\xf4\x1c\x8c\x98\x9d\xf1\x5e\xf2\x8e\x46\x85\x1a\x23\x1c\xc5\x75\x4b\x87\xa6\x42\x1b\xc5\x95\xe6\x8a\x3e\x2b\x46\xc9\xfc\xd4\x05\xf6\x69\xe7\x3e\x00\x0f\xae\x6f\xac\x20\xc3\x1e\x89\x30\x6a\x53\x28\xe4\x54\x3b\x73\xf3\x3c\x99\xe0\xe4\x87\xfb\xc4\x3d\x76\x8f\x9d\xd2\x9b\xcc\x7a\x73\x7d\x5c\x4f\xb1\x3c\xc5\xd7\xc7\x29\x4f\xd3\xe6\x77\x72\xb5\x75\x7e\xd3\x1c\x2a\x9c\xda\xd3\x38\x39\xac\x51\x35\x36\x6a\x16\x65\xcc\x2a\xd0\xe7\xdf\xf2\x87\x58\x2b\xbb\x76\x68\x7b\xe2\xd5\x81\x77\xe4\xf5\xea\xd2\x01\x1d\x5d\xb9\xbe\x4b\x7e\xa0\x2c\xaf\xf0\xcf\xc7\xa4\x01\x06\xe1\x43\x5b\xed\x2c\x76\xec\x85\x43\x96\x8f\x6c\x03\x27\xde\xfc\xa3\xf4\xd4\x8e\xcd\x9a\xb3\xea\x36\x2d\x1f\x9f\x7e\xfe\x30\xde\x87\x0f\xf6\xb1\x8b\xcc\xdf\x6b\x1f\xf3\x0b\x94\xc5\x62\xd4\xd1\xb4\xc3\xe8\x70\xba\x2c\x06\xbb\xd1\x68\xa0\xea\xe2\x06\x9b\x4a\xc3\x69\xc0\x74\x6e\xaa\xde\xcd\x55\x69\xcd\x38\x09\xd0\xe1\x26\x14\x15\x40\x01\x0b\x6e\x9b\x66\x09\x30\x3d\x9e\x51\xce\x40\x3a\x02\xae\x52\xee\x7b\xc6\x96\x7c\xdb\xbf\xa2\xc8\xc1\x14\x11\xb1\xad\x12\xeb\x4b\x2f\x38\xdf\xa1\x97\x26\xe7\x24\x3f\x09\x30\x39\xa9\x5e\xb1\x3c\xb5\xa0\xe5\xec\x06\x9a\xd6\x63\x95\x25\xb0\x2e\x77\x52\x59\x69\x55\x9c\x81\x65\x75\x6a\xa3\xd0\x54\x63\x61\xbf\xb1\x99\xa4\x4a\x17\x54\xa9\xa1\xc9\xe9\xfa\xaa\x70\x69\x47\x65\x7e\x6f\xda\xc4\x64\x64\x5f\x91\x54\x1e\xcd\xe6\x25\x2f\x4b\x8a\x26\x44\x3d\x00\xb0\x96\x13\x1f\xa4\x73\x2c\x6c\xe0\x34\x1a\x33\xa5\x33\x5a\x28\xd6\x6e\x33\x13\x5b\xde\x64\xd4\x5b\x74\x96\x3e\x71\x9d\xed\x16\x52\xbf\x8d\x48\x6d\x46\xe1\x81\x72\xe2\xc9\xa3\x00\x18\x77\x32\x02\x13\x1d\xe9\x56\x38\x72\x93\xb8\x48\xdf\xa5\xd0\x6b\xdf\xf3\xf4\xf3\x97\x2e\x26\xe4\xbc\x5e\x6a\x82\x34\x80\xbb\x97\xc4\x7a\x2b\xf0\x24\xef\x2c\x9f\xdb\x9a\xc3\x57\xb4\x30\x30\x4c\x45\x8e\x9b\x6d\x59\x19\x76\xd4\xc6\xc3\xf6\x4c\x6f\xc0\x5b\x1f\x0f\x78\xb8\xc2\xba\x38\xa7\xe7\xf4\x94\xc9\xa4\xa9\x8b\x9b\x4c\x54\xb4\x59\xcb\x29\x42\x9e\x4d\xda\x5c\xa5\x07\x1e\x49\x5b\x80\x72\x53\xb8\x52\xc9\x5a\x0d\x93\x59\xac\x4a\x91\x84\x9c\x39\x45\x5c\x28\xec\x8d\x18\x90\x45\x30\xd0\x24\x35\xb4\x1c\x1d\x79\x72\x2f\xda\xf6\x59\xe7\x9a\x6e\x9d\x54\xd2\xc7\x95\xe8\xa1\x37\x3f\xca\x2d\xf1\x67\x2e\x2d\x6e\x35\xa0\xc7\x8e\x27\x3a\x77\x52\xf1\xd5\xdb\x5e\x5b\x39\xa8\x2e\xef\x9e\x11\xcb\xac\x2f\x3c\x8e\xea\xd4\x6c\xe5\xb8\x09\xdd\x6a\x0d\xa8\xfd\xb9\x33\xd2\x3d\x83\x3b\xf1\xbf\x2e\xd4\xfd\x41\x7c\x71\x6f\x57\xd3\xa8\x3e\xd3\x46\xd3\x6a\x9a\x0e\x74\xab\xde\xbc\x65\x96\x8c\x83\x0a\xc0\xc1\xc3\x80\x83\x10\x55\x04\xdc\x59\x18\xcc\x70\xda\xec\xf6\x2c\x13\x93\xa7\x56\x33\x4e\xa6\xa4\xd8\xeb\xf6\xb9\x41\x7a\x7a\xcc\x46\x5d\x76\x6d\x5c\x67\xe2\x0b\xc8\x70\x3f\x7b\x5d\x63\x53\x34\xca\xd9\xc4\xca\x70\x54\x35\x06\x1e\x92\x37\x82\x7c\xba\xe1\x57\x19\x90\x05\x6a\xe3\x9e\x95\x41\xc1\x24\x6f\xbc\x08\xcc\xf3\xc1\x0d\x27\xdf\xfe\xd3\xf9\x19\x3b\x0b\x59\x13\xd2\xf2\xd3\x94\xbd\xae\x99\x35\x7d\xda\xe4\xbf\x4c\x99\x07\xb6\xf9\xeb\x28\x1b\x0c\x73\x3d\x0a\x0f\x1f\x36\xb0\xcf\xb8\xdd\x89\xd5\xd2\xcf\xf2\x26\x7b\xd1\xa1\x97\x4f\x1e\x39\x21\x3d\xf4\x9a\xb2\x37\x3f\xf7\x21\x78\x91\xa5\x54\xbf\x58\x81\x2b\x1c\xf6\xe7\xe0\x6b\x4f\x7f\x91\xc6\xaf\x29\x8b\xba\xbc\x76\x2f\x48\x1f\x4a\x9f\x8f\x2f\x3c\x85\x12\x7c\xdd\x99\x15\xa4\x82\x4d\x24\xcf\xed\x27\x2d\x36\xe6\xbf\x61\xa7\x97\x6f\x72\xdd\x29\xcb\x20\x59\xae\xca\x9b\x34\x20\xd4\xb8\x41\x76\xf8\x8e\xc7\x1b\x37\x48\xd3\x2f\x3f\x36\xa2\x9f\xb9\x87\xad\x6d\x25\xec\xd2\x33\x55\x4a\x6e\x52\x1a\xf0\xd2\xcb\x89\xb4\x6d\xee\x9f\xfe\xc0\x66\xf1\x22\x27\x74\xee\xf2\x5b\x29\x6c\x95\xd3\x31\x6f\x25\x37\x4a\xce\x71\x34\xec\xd5\x03\xe7\x98\x49\x85\x41\xe7\x17\x99\xbd\x5e\x46\x13\xc4\xc9\xf3\x6a\xac\x89\x35\x76\xab\xcb\x5a\x1f\x77\x79\x82\x5a\x20\xdd\xa0\x29\x48\xf1\xbc\xaf\x2e\xce\x9b\x28\xc3\x7f\x21\x62\x50\x88\x69\xf9\x16\xb2\x3e\xe4\x82\xb8\xa9\x16\x56\xf9\xf2\xb5\x7d\x25\x97\x7e\x90\xa9\x1c\xfb\xa1\x37\xa4\x5f\x91\xe6\xc6\xd7\x3f\x26\xba\xcf\x9a\xf4\x08\xec\x02\x9f\x61\x6c\xc7\x13\x63\x17\x8d\x9a\xc8\xa0\x67\x55\x93\xad\x20\xf3\x6c\x48\x87\xfc\xd2\x25\xe9\x8a\x6a\xeb\xb6\xa5\x0e\xe9\x31\xf9\x08\x47\xe4\x30\xfb\x1e\x58\x40\x5a\x48\x80\xcc\x18\x06\xfb\xca\x87\x7d\x45\xa9\x39\xb1\xf6\x9e\x16\x2d\x0a\x4c\x11\x87\x46\xe0\xf9\xcc\x4c\x86\xd1\x44\x98\xf2\x32\xc1\xe3\xce\xcf\x2d\xca\xad\x8f\x17\x79\xdc\x1e\xf0\xaf\x80\x5e\x69\x13\x53\x9a\xe5\x16\x45\x77\x56\x29\x4b\x81\x25\x50\x07\xc7\x4b\x05\x6e\xd7\x45\x8f\xb4\xd1\x6b\x6c\xe7\xd1\xac\x3b\x96\xe2\x62\x06\xb3\xfe\x87\x0c\x79\x85\x91\x15\x34\xd0\xf1\xef\xa5\x1f\xb7\x2c\x99\xbf\xf0\xfa\xbb\xef\xdf\x74\x7f\xab\x5a\x30\x76\xe8\x84\x27\xf7\x1e\xdf\x3a\x6b\xec\xf0\x95\xe2\x77\xed\xee\x90\x91\x31\xc1\xfa\xc2\x96\xf1\xeb\x0c\xb4\x7b\xd9\xc8\xc5\x8f\x6d\xd9\x68\xef\xdc\xfd\x8e\x36\xbd\xba\xec\xeb\xd9\x37\xd6\x7b\x70\xb7\x02\x69\x4d\xbb\x6a\x05\x21\x80\x87\x25\x20\x3b\x47\x03\x1e\x4a\x31\x1e\x9c\x0c\x13\xd2\xe7\xaa\xbc\x05\x85\x85\x36\x5b\x49\x89\x57\x0f\x36\x5d\x81\xd3\xe5\x72\xc2\xfe\x5d\x3e\x17\xec\x9f\x36\xba\x82\x41\x97\x91\x66\xa9\x48\x04\x0e\x3a\x62\x12\x38\x0d\x57\x1f\xd7\x78\x28\x73\xf3\x74\x8d\x66\xd8\xb8\xa5\xa9\x60\xd2\x97\xe3\x82\xd9\x8d\x72\xaa\x5c\xfc\x1f\xba\x0c\xb2\xf4\x84\xf5\xe3\x95\x83\xff\xb7\xb8\x72\xf8\xd8\x59\x4f\x9c\xdc\xff\xf8\x84\xa1\xe3\xe6\xa9\xbf\x75\x27\xde\x7b\xe7\x06\xee\x35\x28\xfd\x68\xcd\x1d\x2f\x9f\x3c\xba\x3b\xbd\xe9\x60\xf7\xce\xf6\x8d\x5b\x1e\x5b\xac\x34\x1d\xdc\xf2\x82\x4c\xe7\x6d\x80\x1e\x54\xc4\xd6\xcb\xa6\x86\xc5\x4a\x9d\x59\x59\x26\x87\x96\xe1\xec\x5c\x4e\x6e\x38\xd3\x6e\xcf\x71\x84\xeb\xe2\x8c\x23\x23\xc3\xc1\xe0\x0e\x4b\xc1\xba\xb8\xc5\xae\x51\xe9\x41\x99\xe8\x3d\x94\xa7\x36\x19\x62\xbf\x65\xeb\xf9\xa9\x82\x8d\x94\x0f\x4b\x02\xed\x96\x68\xda\xc1\x96\x8b\x74\x00\xb7\x30\x95\x4b\x38\xc2\xed\x68\x0b\x89\xd8\xa1\x6f\xdf\xbe\x66\x38\x9e\x55\xee\xcc\xad\x6c\xb9\x79\xd9\x6c\xe9\xaf\x57\x3e\xa2\xeb\x07\x0c\x1c\x95\x2d\xfd\x94\x37\xe9\xf1\xa9\x9b\x05\xe9\x8c\xaa\x07\x5b\xf3\x5b\x03\x95\x88\x77\xa9\x80\x9d\x3e\x71\x06\x75\x90\x7e\x42\xf9\xa8\x4c\xb5\xe7\xe1\xa5\x8e\x49\xb3\x3a\xdd\xec\x8d\x78\x4c\xf1\x34\xfa\x33\x99\x03\x8b\xfd\x3a\xdc\xa3\x29\x68\xa5\x28\xd1\xa0\x13\x68\xd0\x06\x76\xb3\xd8\x67\xb0\x99\x4a\xda\x19\x3c\xab\x66\xeb\xe3\xea\xe6\x66\x6c\xfa\x5d\x81\x6c\x65\x34\x92\x25\xb8\x7c\x61\x5c\x1b\x79\x7d\xa2\x72\x28\x8f\xe0\x3e\x8b\xc8\x75\x30\x25\x3d\xd9\x56\xa4\xdd\x22\xd0\xdb\x3d\x00\xc7\x30\xa2\x17\xba\xc5\xc2\x4e\x6d\x30\x83\xe3\xcc\x41\x73\x56\x38\xa9\x0f\x70\xe7\x01\x9b\xd1\xc6\xd4\xc6\x6d\x76\x23\xf8\x9a\x46\x53\x33\x21\x72\x8b\xc8\x24\xfe\x82\x9c\xef\xcd\x63\xe4\x45\x4b\xb1\x24\x09\x35\xa5\x2a\xf4\x78\x5a\xff\xbb\xa5\xef\x2f\x97\x1b\xe3\x2d\x4e\x02\x8c\x46\xf5\x19\x85\x26\xa2\xd9\x72\xdf\x3c\xe9\x63\x30\x44\x6e\x48\x1f\x56\xcd\x55\xe8\x67\xbb\x2c\x33\xbe\x06\xd8\x29\xb0\x37\xfd\x54\xc7\x58\x88\x31\x78\x0c\x01\xab\x9a\xa2\x82\x01\x4f\x86\x33\xa3\x3e\x2e\x32\x7d\xe2\x46\x51\xd4\x3a\x29\x15\xa7\xe5\xd2\x3d\x01\x12\x5f\x4e\x0b\x30\x8b\x0a\x19\x00\x3d\xa7\x42\xe4\x80\xc6\x5b\x4c\x4d\x86\xda\xf4\xa4\x66\xb2\xb9\xb7\x69\x40\x74\xc7\x13\x4d\x0c\x4c\xcd\xe1\x03\xa6\x91\x2a\x16\x03\xf7\x3a\x18\x97\x4c\x89\x62\x5c\xca\x70\xf6\x03\x38\xaf\x83\x3d\x94\x45\xf5\x88\x65\xa3\x90\x46\xf0\x3a\xcc\x3a\x9d\x37\xc4\x84\x23\xaa\x2c\xa3\x97\xf5\xc3\x01\xfb\xed\x2e\xb0\x36\x5c\x36\xd1\x68\x35\x62\x4b\xae\xf9\x58\x5d\x67\x75\x53\xdb\x8d\xa4\x09\xcb\x10\x12\xff\x3e\x4d\x2a\x85\x64\xd3\x42\xc6\xf3\xe4\x9e\x3d\x7b\x4d\x46\xae\xc5\x49\xb2\xdd\xc8\x0a\x88\xab\x5a\x36\xe6\xd9\x17\xc1\xbe\xdc\xf6\xf8\xb2\x23\x4b\xe9\x8e\x37\xe7\x4b\x3f\x29\x04\xdb\xcb\xf5\x50\xd1\xe2\x49\xef\xbd\x4d\xbf\x0c\x70\x83\xae\x61\x87\x02\xdc\x11\xd0\xaa\xc5\x5a\xb7\xdb\x10\x36\xeb\x79\x5e\xb4\x5a\xfd\x61\x26\x3b\xc7\x97\x11\xcc\xc0\x3c\xd8\x27\xae\x35\xc3\x9f\x94\x56\x4b\x31\x8c\x31\xe8\x31\x1a\xfa\xe0\xd6\x76\x72\x7b\x4c\x72\x41\x97\x9f\x7f\x8b\xe9\x29\x53\xad\x22\x5a\xc8\x50\x01\xd9\xaa\x63\x45\x7c\x69\x9b\x6d\x4b\x67\x46\x34\x57\x33\x77\xd8\xcc\x69\xd5\x4b\xb7\x8c\x45\xd5\x89\x4f\x98\x95\xd2\x23\x68\xa7\xf4\xdb\xf7\xcf\x2f\xeb\xd5\x55\x26\x97\xef\xfa\x8f\x1f\x3c\xb6\x5b\x7d\xf8\x24\x42\x97\x5e\x93\xbe\xcd\x93\xce\xbf\xfe\x69\x6d\x61\xdb\x98\x6e\x17\xa6\x96\xe2\xf4\xda\x4a\x07\x48\x94\xaa\x98\x31\xc3\xec\x04\x27\x5a\xcd\xb3\x66\x78\x9d\xc7\x76\x1a\x1e\xf2\x51\x46\xd4\x82\x52\xa3\x12\xb9\xd2\x25\x3d\x29\xbd\x11\xe7\x56\x9e\x54\xe9\x35\xe6\xe7\xcb\xee\x30\x83\xe1\x25\x14\x8f\x2e\x0a\x1c\x2e\xad\xd4\x34\x56\x56\xca\x05\x71\xf4\x48\xb1\xde\xd6\x66\x26\x7a\xd6\xfb\x40\x69\x77\xb9\xb0\x12\xa1\xf9\x2b\x11\x8f\x98\x07\x7e\xaf\xbe\xc2\xa2\xb1\x68\x74\x3c\xae\xaf\x30\xfd\x97\xfa\x8a\xa4\xba\xc2\x55\x46\x26\x25\xc1\x8e\x9e\xba\xe3\xc8\x2b\x3b\x57\xec\xb2\x9e\x15\x67\x6e\xdc\x54\xd1\x5d\x75\xc6\x74\x00\x7d\x7c\xf9\xf8\xe9\xf7\x1e\x98\xa5\x59\xd2\x20\xfd\xdc\xa5\x8b\x66\xee\x06\x92\xdb\x7b\x8a\xf9\x03\xfb\x1f\xca\x0b\xd4\xd9\x3d\x96\x19\xf0\x22\x33\x93\xa1\x75\x38\x18\x0e\xb1\xe1\x88\x37\x10\x70\xfb\x74\x56\x33\x7c\x54\x21\xca\x7d\x1c\x60\x30\x52\x2a\x52\x75\x81\x7b\x4d\x12\x58\xaa\x9a\x24\x46\x25\x45\x40\x76\xb3\x3b\x76\xd1\xd1\x88\xad\x30\xee\x40\x05\x08\x43\x77\xcf\xc8\xaa\xc8\x3d\xba\x6b\xc5\x2e\xcb\x19\x55\x87\x36\x1b\xd0\xec\xc9\xf3\x96\xec\x5a\xbf\x64\x24\x9a\x35\xb9\x6b\xbf\xc2\x61\x8b\xd1\xa9\x09\x55\xb1\xbe\x93\x4f\xbe\xbf\x7a\x86\xa6\x55\xe7\x06\xaa\x45\xdd\xe8\xa1\x93\x17\xf7\x5c\xd3\xb9\xcf\x1d\xa9\xfa\x17\x5e\x47\xb9\x01\xf6\xfe\xb1\x2c\x03\x05\x26\xbb\x45\xb4\xb1\x8c\x5f\xad\xa6\xc3\x1e\x86\x89\x84\x29\xe0\x28\x8b\xc5\x96\x69\xd0\x39\x75\x4e\xde\x64\xc3\x49\xca\x21\x52\xf2\x98\xea\x3b\x22\xc3\x6f\x4a\xce\xd4\x12\xd3\x8a\xd1\x60\x1f\x76\xd1\xd6\x58\x33\xe3\x88\x64\x0b\xe5\x95\x11\x38\x7c\x47\xa5\x4d\x29\xeb\xc2\x89\x9b\xcc\x95\xd7\xf7\xbe\xf8\xc6\x6b\xfb\xba\x46\x0a\x5a\x9d\x9b\xd6\x69\xe2\xf9\x0e\xf9\x47\x3a\xca\xa5\x34\xdc\x98\x2f\xa4\x2f\xe8\x57\xde\x39\xf1\xcc\xf6\x63\x8e\x11\x9d\xfa\x2f\x6b\xd1\xb2\x63\x20\x50\xbb\x22\xb1\x6f\xda\x98\x2b\x77\x4d\x21\x77\x56\x4a\xcd\x9c\x99\xe7\x26\x92\x98\xdf\xfd\xe8\x1a\xd3\x91\xd4\x6e\xb6\x89\x99\xf4\x36\x1b\xd8\x19\xb4\x05\x21\xd6\x61\x37\xea\x35\x47\x51\xe9\x41\x8a\x65\x2d\xdc\x31\xa0\x54\xfa\x77\x2a\x09\xa2\xc9\x1a\x79\x72\xe3\x94\x16\x47\x8e\xda\xe8\x03\xa7\x26\x4d\x9a\x38\xb1\xac\x93\xd7\x5b\x9e\xf5\x30\x3b\x34\xb1\x86\x9e\xb9\xb2\x76\xfc\x28\xed\x12\xa1\xa8\xb0\xed\x4a\xf2\x7e\xea\x6d\xa6\x23\xa9\xdb\xa8\x8c\x39\xac\x3a\x46\x10\x28\xb3\x99\xd3\x71\x76\x07\x63\xb3\xf1\x56\x2b\x40\x81\x8e\xe2\xf4\xf2\xd7\x4b\xc9\x84\x6c\xb1\x49\xf1\x46\x6a\xd2\x3c\xae\x14\x49\x79\xe6\xf8\xb6\x91\x76\xa7\xbf\x9a\xa9\x45\x1b\xa5\x49\x2b\xa5\x77\x95\x77\xa3\x8c\x95\x80\x0b\xa5\x2e\x0f\x70\x31\x89\xe0\xc2\x05\xb8\x38\x08\xb8\xb0\xe2\x5e\x38\x56\x83\xd9\x2c\xaa\x79\x91\xb7\xdb\x18\xad\x56\x30\x1f\x87\xed\x1b\x29\x01\xce\x14\xe7\x66\xdd\x9a\x76\xdb\xa4\x66\x02\xff\x19\x12\x2b\xe9\x9f\xb3\x67\xd5\xcd\x99\x7f\xea\xde\xce\x7d\x4f\x9f\xe6\x98\xad\x03\x7b\x6f\x5a\x87\x70\x25\xc9\xc2\x61\x68\xf3\x6f\xd7\x50\xc6\x26\x92\xbf\x7c\x10\xde\xeb\xe2\x70\x6f\x39\x23\x15\x8b\x99\x8c\x82\x56\x4b\xeb\x58\x10\x19\xb4\xda\x24\xea\xf4\x70\x0a\x87\x35\x34\x2d\x30\x0c\x39\x07\xb9\x7e\x56\xc6\x45\xf5\xe5\xa6\xd8\x90\x4f\xa2\x3c\xaa\xa0\x84\xc1\x93\xee\xf8\xfa\xfa\xd3\x7d\xe1\xfd\xe8\x1a\xea\xb6\x12\xb7\x79\x5f\x29\x1d\x61\x96\xaf\x5f\x4f\xf4\x05\x2d\xa0\x6b\x4a\x7d\x9f\x32\xdf\x85\x39\x86\x8a\xe4\x84\xfe\xc6\xfe\x31\xb0\x19\x5a\x38\x7d\x9a\xfd\x22\xc1\xff\xff\xfc\x8e\xbc\x47\xf8\x8e\x96\x2a\x8b\x59\xf0\x06\xe5\xfd\xe9\xf4\xbf\xb3\xb3\x5b\x2e\xf6\x1b\x77\xa5\xec\x28\x7d\x3f\xa4\xff\x2b\x30\xda\x29\x66\x2b\xe0\x11\xdb\x39\x99\x60\x63\xd8\xbc\xa2\xe0\x74\x32\x3a\x2b\xbe\x87\x65\x74\x3e\xbf\x86\xe7\xf5\x6e\xd2\xbb\x04\x4f\x15\x29\x05\xe9\x52\x02\x84\x47\x91\x5a\xba\xea\xea\xcb\xd5\xcd\xc8\x2b\x59\xac\x13\x26\x2c\xd9\x5a\x21\x34\x7c\x9d\x00\x78\x95\xef\x16\x30\x53\xd2\xa1\xa9\xf7\x2e\x5b\xd4\xf9\xf4\x84\x09\x6b\x4b\x4f\x4b\x5f\x96\x67\xf7\x1a\x99\x7b\x6a\xde\xf8\xb1\x33\xe8\x09\x89\x47\x1f\xd6\xad\x5d\xcf\xbe\xbc\x7e\xfd\x6f\x9f\xb4\x69\x9d\x5b\x1f\xc0\x3d\xdb\xd0\x11\x80\xd3\x0e\x70\xea\x29\xff\x61\x2d\xc3\xf3\x06\x23\x0b\x67\xbc\x5f\xa3\x4a\x95\xf5\x29\xc6\x82\xfc\xea\xa4\x5f\x0b\x92\x76\xc3\xc4\x69\xa7\x07\x46\x82\xb6\x3e\xa7\xa6\x2f\x67\x7b\xfe\xf6\xf2\x40\xd5\x46\xdc\x58\x08\xd6\x3c\x07\x6b\x0a\x64\xef\x05\x31\xad\x41\x60\x59\xd1\x4c\xab\x8d\x94\xee\x24\xac\x88\x6b\x2a\x85\x54\x4d\x65\x34\x9a\xba\x57\xc1\xe6\x28\x36\xe1\xa2\x8d\x61\x70\x5a\x3f\x70\xea\xe9\x3e\xd3\x26\x84\xdb\xfb\x51\xff\x81\xad\x59\xfb\xcd\xf1\x87\x96\x4f\xd7\x6d\x54\xc1\x3b\x66\xc0\x19\x0e\x82\x33\xc4\xbd\x75\x58\x84\x28\x5e\x20\xc5\x3c\x6c\xb2\x98\x47\x4c\x9b\x3b\x15\x15\x03\xcc\x20\xc9\x75\x1a\xe5\xe0\x22\x9e\xc4\xa3\xd8\x36\xe9\x4b\x9d\x62\xe7\xb2\x37\xa8\x42\x90\xfe\xa4\x16\x33\x80\x27\x00\xaa\x22\x1e\x95\xa7\xa8\x38\x2b\x98\x09\xbb\x3f\x98\xcb\x30\x0e\xf1\xa4\x5c\x94\x09\x1b\x53\xa5\x80\x4e\x17\x3b\x4a\x85\xc7\x6d\xeb\x32\x2b\xd2\xca\x32\xe5\x54\x78\x2c\x13\x92\xd5\x90\x8d\x05\x9a\x1d\x36\xe2\xfa\xcc\x09\x7d\xee\x9e\x3a\x6d\x82\x63\x80\xd5\x9f\x3d\x70\x6a\xcb\xee\xcd\xaa\x34\x77\xee\xec\x57\xbf\x79\x5d\xe2\xef\xcb\x67\x08\xdc\x23\xaa\x81\xe8\xab\x8b\x33\x86\xcb\xb5\x9a\xd4\x00\xea\x24\x3b\x1b\x70\x41\x2a\x41\xdc\xc8\xe7\x73\xa8\x79\x8d\x46\xed\x50\x07\x82\x7e\xc1\x09\x12\x2b\xa6\x66\xb4\x22\xe3\xf5\x1a\x34\x56\x52\x09\x82\x6b\xdd\x1c\x69\x7b\x10\x6f\x53\x83\x15\x12\x6f\x53\x7f\x05\x1e\xc2\x1b\xb8\xfe\xea\x58\x78\x62\xb7\x5d\x21\x36\x3c\xbe\x7e\xd2\xd4\x53\x53\x5a\x75\x4b\xd5\x5e\xfd\xf6\x27\x74\xac\x7f\x97\x1d\x03\x6b\xb6\xac\x41\x5f\xc2\xcf\x66\x0e\x23\x46\x2b\xa2\x2e\x02\xbe\x59\xc0\xb7\x1f\x57\x1d\x73\x36\x9b\x87\xf6\x1b\xf4\x7e\x7d\x20\x98\xe9\x75\xe2\x12\x10\x03\x2a\x3a\xc0\x89\xa2\x1a\xd7\xad\xd0\x84\x7b\xa3\xa2\x8c\xeb\xf4\x36\x0f\xb8\x8e\x26\xbd\x82\x34\xa4\xa0\x32\x0d\xb9\x68\x7c\xaa\x92\xf4\xf4\xf2\x8e\xfd\xa7\x4f\x70\x0c\xb4\x06\x23\x03\xd9\x56\xc9\x3a\x52\x52\xe7\x3a\x77\x94\xd4\x62\xf9\x0c\x15\x0b\x98\x94\x6d\xd5\xf3\x00\x1f\x4f\xe0\xab\x8e\x89\x7e\x1b\xd8\x7b\x1a\x95\x20\xd8\xdc\x4c\x30\xe0\x72\x64\x00\x35\x1c\xd0\xd3\xb4\x88\x2b\x5f\x35\x00\x9d\xa0\x58\x4a\x49\x42\x70\x54\xa5\xc5\x4c\x92\x34\x50\x8c\xd2\x6b\x5d\x93\xe9\x66\x91\x72\x7a\xd7\xf2\x2e\x7d\x4f\xd3\xcc\x61\x35\x4d\x44\xf2\xc0\x6c\xbf\xad\x8f\x7b\xe2\x54\xe6\x51\x90\xc5\xf8\xb8\xc7\x74\xc6\x90\x6e\x7a\x30\xf1\xf9\x40\xd5\x23\xac\x6a\xc6\x72\x45\x1f\x1c\x80\x33\xd6\xe1\xfe\x47\xb8\x57\xba\x46\xad\xa6\x78\x4a\x6f\xc0\x3d\x97\x40\x21\x02\x48\x25\xa4\x53\x8e\x3a\xc9\x01\xb7\xf6\x3f\x42\xa1\x64\xd3\xa5\x6c\x31\xca\x1c\xd8\x27\x1d\xe7\x77\xbf\x86\xa2\xfc\x6e\x60\x0b\x47\xf7\xae\xd2\x7c\x60\x8e\xff\x6c\x41\xb3\x70\xfe\x48\x63\x8d\xad\x09\xc4\xd2\x1d\xb1\x4c\xa3\xc5\x42\x19\xac\x56\x9e\xe2\x1d\x76\xeb\x14\xc3\x62\xc3\x83\x06\xc6\x80\xcb\xf1\xc1\x6a\xd3\x91\xca\x5b\x31\x55\x79\x8b\x13\xbc\xee\xbc\x45\x6c\xa6\xd5\xe0\x86\x83\x42\x20\xc2\x94\x56\x06\xec\x8d\x35\xb8\xd2\xc3\x8f\xd9\xd0\x00\xcb\xd6\xcd\x0e\xe9\x25\x4f\xaa\x12\xb7\xfd\x6b\xaf\x25\x7e\x79\xe5\x15\x92\xd3\xb2\x1e\xce\xa8\x35\xc8\x15\x91\x72\x82\xd5\xda\x33\x26\xba\xec\x1a\x51\xf4\x0a\x78\xdc\x81\x9e\xd5\xfb\x03\x2a\x6c\x24\xd8\x32\x32\x34\xc2\x51\xd4\xe2\xa0\xdd\xeb\x35\xa1\x63\xa4\xcb\x43\x79\x9a\xb5\x90\x56\xca\xae\x58\xb8\x58\xac\x2a\xc5\x4f\x00\x2a\x29\xce\x12\x44\x4b\x59\x24\x5b\x6c\x87\xc2\xb8\x14\x0a\xa4\x9d\x66\xef\x85\xd7\x0e\xbd\x72\xe8\xb5\x0b\x7b\x0f\xc4\x07\x0d\x18\x92\xf8\x7c\xc8\x80\x41\xf1\x53\x28\x83\xff\x60\xff\xc1\xf7\x78\xa4\x97\xae\xf3\xef\x1d\xdc\xf7\x21\x2f\x5d\xa5\x77\x2d\x5e\xc4\x27\x7e\x16\x56\xcc\xbd\x67\xa5\x40\xab\xf8\x45\x44\x26\x3a\xa9\x93\xcc\x21\xc0\x67\x0b\xc0\xa5\x33\x92\xef\x72\xe9\x74\x25\x66\xde\x5f\xe2\x2f\x8d\xf2\x2e\x63\x5e\x4e\x61\x98\x62\x42\xb8\xd1\x82\xdd\x62\x94\xcb\x7b\x31\xb0\xa5\x60\x69\x98\xab\xaa\x6e\xad\x26\x4b\xcb\xed\xbc\x35\xa3\x93\x56\x06\xc8\xa7\xb9\xc6\xe8\x8c\xa1\x6b\xff\xbe\x9d\x62\x1d\x2e\xac\x78\x6a\xf3\x8a\xad\xd6\xdd\xea\x58\xc7\x8e\x1d\xa3\xd5\x2f\xcd\x6c\xbb\x7f\xd3\xe8\x8e\x03\x43\x59\xed\x8b\x27\x4e\xa5\xcf\x56\x14\x16\xe4\x47\x0a\xf4\x91\x29\x23\xef\x9e\x3f\x71\x94\xa5\xa4\x30\x2b\x2f\x90\xad\x8f\xb4\x19\xdc\x65\xda\x02\x7f\x5d\x5c\xfd\xb0\x6e\xc6\xf2\x1b\x78\x3f\x83\xc0\x5e\x99\x01\x67\x81\x7b\xc6\x1b\x68\xb5\xda\x64\xb7\xbb\x5d\x1c\x43\x99\x4d\xd8\x46\xc0\xe0\x03\xe8\x69\x95\xf8\x61\xd9\x1e\x6a\x87\x9a\x5e\x62\x58\x79\xf4\x5a\x2c\x37\xaf\xc0\x1f\x16\x97\xdc\x1b\xcb\xf5\x96\x95\x14\x2d\x3d\x6a\x7c\xd4\xe8\x29\x6d\xc7\xb8\xd7\x2d\xd2\x6f\x36\xc6\xba\xdd\xfc\x62\x9d\x8c\xc3\x07\x41\xaf\xe0\x9a\xde\x0c\xaa\x4b\xcc\x62\xa4\xed\x7a\x51\xf4\x80\x1a\x55\xd9\xed\x2a\x5f\xa6\x97\x72\x01\x97\x1e\x32\xa9\x54\x7a\xad\x1a\xab\x02\x4b\x92\x1c\xcf\x35\x11\xd8\xc9\x36\x8f\x29\x95\x03\x18\x6c\x5e\xe3\x9b\xd4\x3f\x9d\x6a\xeb\x06\xa6\x6a\x7d\xc7\x4d\xac\x6a\x59\x8c\x7a\x8f\xca\xa7\x87\x0d\x6d\xac\xf9\xfd\x64\xcc\x54\xc3\x3a\xad\x1c\xbb\xb9\x84\x3e\x61\x11\xf0\xa8\x0b\x7c\xad\x91\xb1\x1c\x1f\xf2\xfb\x9d\x56\x3a\xc3\x9a\x61\x17\x38\xb5\x5a\xab\x35\x18\x04\xbb\x10\x0c\xf9\x00\x60\x0e\x39\x62\xc0\x3b\x0e\x87\x8e\x71\xe1\xa2\x60\x77\xd3\xa2\x60\xcc\x40\xe9\x1d\x1f\x1b\xef\xec\xd2\xab\x2e\x89\x07\x4c\xac\x00\x47\xa8\x98\x84\x69\x95\x14\x25\x62\x0f\x04\x6c\x56\xf4\x07\x94\x71\xba\xbe\x9e\x3f\x42\xf3\x4c\xd7\xe7\x66\x2f\xe8\xd6\x0d\x75\xb8\x63\x80\x74\x15\xc4\xf5\x5f\x91\x5f\xfa\xeb\xc2\x03\x33\x2b\x3c\x0b\x9e\x7b\xe4\xc1\x2e\x0b\x91\x3f\xb1\x66\x72\x3f\xab\xe1\x22\xa9\x93\xfd\x84\xd4\xc9\x02\x30\x31\xa7\x9b\xc9\xcb\xa3\x7c\x06\x55\x38\x6c\x36\x30\x36\x90\x05\xc5\x25\xc8\x66\x2b\xb4\x63\x14\x07\x53\x9d\x0c\x53\xc6\x8a\xb9\x31\xb0\x86\xe9\x14\x1b\x25\x0a\x3d\x02\xeb\x57\x02\xc9\x92\x19\x4e\xb8\xbb\x2d\x9d\x6c\x3b\x46\x2e\xeb\x5a\x23\xe6\x6a\xfb\x42\x5f\xc4\xf7\xf6\xce\x17\xce\xf5\x33\x15\x76\xb8\x3f\xd6\xcb\x99\xe1\x1c\x5d\x57\x3b\xca\xe9\x75\xf6\x6e\xb7\x8a\xed\x17\x30\x56\x74\x1b\xd8\xe2\x91\x17\x5f\x7c\x64\xdc\x0a\x97\x39\xf0\x60\xcf\x58\xe0\x8e\xee\x75\xc5\x83\xee\x9e\x38\xa4\xb0\xae\x47\xc7\x40\xfb\x1e\x78\x0e\x2f\xc8\xad\x5d\x00\xfb\x2d\x3d\xb0\x4a\xfe\xe7\x1e\x58\x63\x9e\xdd\x7a\xba\x55\xf7\xee\xad\x4e\x3f\x8d\x3e\x7e\x74\x2b\xfa\x50\x6a\x77\x27\xfc\x0f\xbd\x2a\xe5\x6f\x7d\x94\xd0\xa1\x17\xde\xb1\x8f\xd4\x5e\x16\xc7\xb4\x76\x9d\x4e\x2d\x32\x6a\xc6\xed\xd1\x9c\xc2\x3d\x11\x88\x93\x65\x85\xc7\x5a\x90\x57\x55\x37\x6d\x59\x96\xec\x93\x92\x7c\x67\xb2\xd5\x12\xa2\xdf\x9d\x36\xf5\xe0\xee\x67\x36\xc2\x9b\xb7\x14\x17\x15\x06\x6d\x71\xf6\xfa\x23\xdb\xbe\xfe\xe5\x89\x67\xd1\x45\xa9\xfb\xf0\x11\xa8\xfd\x88\x5e\xaa\x0d\x9c\x40\x35\xab\x63\x56\xd3\x1a\x2d\xa3\xc6\x0e\x01\x9f\x2c\x7d\x4d\xd5\x31\x47\x51\x88\x01\xcf\x8d\x09\xa1\x9f\xbf\x40\xc2\xc5\xa5\x39\xaa\xe8\xca\xf3\xd8\x08\x46\xbb\xd7\x64\xed\x91\x70\x0f\x32\x54\x0d\x6b\xad\x25\x6b\xe5\xc6\x74\x02\x03\x76\x30\x48\x78\x58\x92\x60\x4c\x48\xb5\xc3\x14\x9b\x8c\xc0\x48\x5e\x45\xd9\xe0\xeb\x83\xa4\x57\x69\x51\x7a\x1e\xcd\x45\xd7\xd6\xa0\xcf\x1e\x5c\x2b\x85\x1e\xc2\x30\x7e\x09\xf2\xee\x1f\xb0\xae\x15\x4f\x9d\xd5\x70\x66\x83\x81\xb2\x18\x75\x94\xce\x6e\x33\x9a\x70\x51\x38\x4b\x0b\x16\x5d\x5a\x7f\x11\xb1\x79\xeb\xe6\x34\xe1\x95\xba\xfa\x62\xba\x0d\x08\x46\xee\x28\x9a\x38\x45\xea\x8a\xa6\x48\x2f\xd1\x11\x69\x03\x7a\x10\xed\x1a\x48\xc4\x52\x25\x7e\xfd\x3a\x29\x4b\xe6\xc5\x3d\x68\x30\x9b\x09\xef\xb7\x83\xf5\xdd\x29\xe6\x50\x73\x5e\xa4\x62\x59\x44\x31\xb4\xc3\x44\x9b\x7c\x7e\x97\x1e\xb4\x28\x0f\x90\x1c\xf2\xaa\xd5\x76\x2b\x2d\x83\x72\x8e\x48\x8a\x34\x8f\x4a\x21\x67\x02\x51\x65\x12\x8e\x68\x32\x0c\x9c\x8f\x78\x81\xa8\x7b\x01\x9c\xfa\x3d\x59\xd2\x27\x49\xa8\x76\xd4\x3f\xd8\x6f\xe0\xb8\x45\x33\x5e\x71\x17\xa0\xa1\x15\x81\xd6\xd9\x53\xba\xa3\x1d\x1d\x15\xfc\xac\x98\x35\x7a\xe0\x98\xf1\xc5\xc3\xd1\xa0\xd2\x8a\x4a\x7c\x06\x3a\xc0\xd5\x19\x80\x15\xf7\x54\x73\x3b\x0c\x1a\x41\xaf\x66\xc0\x14\x12\x18\x8f\xd7\x20\x38\xe1\x43\x59\xf5\x1a\x8d\x96\xb8\x9e\x00\xcc\xeb\xa5\x4a\x29\x4a\x7a\x1a\x2c\xe9\x1c\x9a\xd6\x8e\x9b\x49\xd6\x18\xe3\x5b\x71\x7a\x48\xbc\xdb\xe4\x85\x9d\xfe\x2e\x2d\xa2\xc7\xfc\xb4\x6a\xf3\x2b\xbb\x1e\xdc\x2f\x9e\x50\xf7\x43\x9d\x46\x4c\x19\x33\x62\xc5\x0f\x0f\x3e\x20\x35\x18\x77\x2e\x7f\xf6\xf4\xba\xc5\xea\x2e\x5d\x64\xff\x25\x1f\x68\x7c\x3b\x27\x51\x1a\xd0\xff\x76\x80\xcb\x61\xd5\xeb\x29\x8b\xc1\x00\xd4\xe1\x74\x18\x8a\x2d\xd5\x16\xda\x62\x61\x44\x15\x0e\x2c\x68\xd3\x15\xff\xad\x7a\x1f\x67\x6f\xd3\xa2\x29\x50\x6a\x4e\x66\x80\x32\xb8\x08\x72\xfb\xb3\x8f\x6f\x78\x0e\xb5\x7d\xf6\x51\xe9\xd5\x05\x42\x03\x45\xb7\xaf\x5e\xc2\x80\xb3\xdf\x86\xf9\x97\x74\x5d\xfa\x15\xb1\xc8\x48\x9b\xa4\x5f\x12\xa3\x51\xdf\x67\xf6\x31\x41\xe9\xe8\x73\xcf\x00\x5c\xd2\x7a\x76\x07\x9a\xcc\xf7\x03\xbb\x1f\x4f\xe6\x31\x1d\x12\x78\x46\xab\xc1\x39\xd8\xa5\x97\xf1\x21\x61\x37\xd3\x62\xab\x04\x9f\x88\x83\x7f\x0f\x7d\xdb\x3a\x7a\x21\x91\x75\x01\xbe\xf3\x40\x58\x9a\x1e\x78\xef\xd3\x4f\xe1\x1f\xea\x7f\x58\x87\x29\xb7\x44\x6d\x4c\x58\x59\x67\x46\xeb\x6f\x0f\x49\xeb\x2f\xa0\x9e\xb0\x52\x00\xad\x0b\x4b\xb3\x95\x95\x50\xc3\x5c\xa9\x86\x1a\xd8\xb0\x93\xca\xa7\x0c\x07\xed\x56\x2b\x96\x09\x6f\x45\x4d\xe7\xc8\xad\x7d\x79\x59\x3b\x5a\x16\x6f\xf8\x4f\x52\xad\x2c\xd7\xf0\x92\x6c\x6c\x59\x04\x3a\x06\x0e\x1b\xe1\x0f\xfb\xe1\x9f\x70\x7e\xb8\xa0\xa8\x54\x15\xed\x1c\x8d\xd6\x18\x0d\x3d\x40\x14\xde\x25\xd5\xf8\x3c\x46\xbb\x09\x1b\xa3\x06\x8b\xa8\xb7\x99\x4d\x2a\xb3\xad\xc4\x1b\x76\xe1\x3c\x71\x96\x75\x05\x8c\xc0\x53\x2a\x33\x38\x3d\xd2\x53\xec\x87\x68\x05\x8f\xdb\x3d\x58\x8f\x20\x51\xd4\xe9\x34\x4b\x78\xaa\xd8\xfd\x56\x54\x24\x43\xf1\xf1\x14\x56\x9c\x44\x5f\x1e\x05\xbe\x6a\x47\xb7\x46\x68\x45\x45\xbb\x09\x77\x4d\xaa\xbe\x67\xe1\xa1\xc9\xb9\x83\x46\xcf\xb8\x23\xc2\x55\xfa\xb2\x7c\x4f\x6d\x58\x12\xcc\x09\xc2\x7a\xe7\xd8\x17\x50\x2b\xee\x0a\xe0\x47\x77\x80\x5e\x02\x7f\x14\x47\xdd\x6f\x61\x6f\xaa\xd2\xc1\x05\xa4\x73\xa8\xf5\xf7\xdd\xa4\x7f\x4a\xdb\xb8\x3e\xcb\x37\x6c\xa6\x9a\x3d\xcf\x32\x4b\x10\xbc\xfb\x32\xf1\xbe\xc2\x95\x8e\x00\x6a\x25\x6d\x93\xfe\xd9\xed\x7b\xd4\x9a\x7d\x61\xf3\x86\xe5\xcd\x9f\xe7\xd0\x12\x06\x3f\x4f\x7a\xff\x73\x42\x36\x5e\x7f\x18\xb2\x75\xfb\x5e\x7a\x83\xbb\x72\x9b\xe7\x11\xb7\x84\xc6\x7b\x23\xcf\x0b\xd9\x61\xbc\xfe\x1b\xdf\x77\x43\x36\x34\x8c\x2b\x52\xe0\x19\xc8\x9e\x46\xcf\x73\xdf\x81\x08\xf3\xc4\xb4\x3c\xe2\x68\x04\x1f\x6a\x09\x8b\xbf\x97\xac\xe4\x82\xaf\x3b\x2a\xe1\x7d\x42\x58\xda\xfe\xf9\x77\xa8\xa2\xfb\x37\x5f\x48\x6f\x72\xdf\xcd\x9f\xb3\x65\xc3\xd2\x45\x8f\x11\xbf\xa0\xe9\x3a\x88\x07\x99\x01\x1f\x81\xc0\x9b\xbe\x0e\x97\x0d\x70\x38\x2a\xd1\xf3\xd2\x9b\x5f\x7c\xd3\x1d\x55\x7c\xf7\x39\x37\xe4\xb1\x45\x4b\x37\x6c\x99\x33\x9f\xac\xd3\xb0\x56\x1a\x40\xcd\x6c\x78\x13\xf4\x92\x0e\x3c\x09\x4a\x05\x64\xf2\x3a\x7c\x91\x11\xb3\xa3\x4a\x9e\x8d\x12\xa9\x9a\xca\x0c\xe5\x90\xa1\x30\xcf\xaa\x71\x89\x59\x65\xd2\x00\xe4\xe8\x57\x93\x53\xc8\x8d\xe1\xaa\xaa\x9e\x80\x75\xa6\xb0\x13\xa9\x87\xe0\x9c\x79\x4a\xb5\x0f\xc1\xa9\xbc\x0d\x6b\x84\x6d\x82\xc3\x16\x7e\x18\x05\xb6\x6e\x95\x3e\xe3\xfa\xef\x5b\xdc\xbb\xf7\xe2\x7d\x14\x2d\x7d\x06\xdf\x7e\xbc\xe1\x3a\x76\x13\x28\x57\x4c\xa3\x11\xb4\x2a\x01\x3e\xe4\x6b\x18\x76\xd3\xeb\x78\x02\x26\x50\x78\x65\x76\x39\xe7\x60\xa2\x8e\xca\x28\x23\x7d\xb6\x75\x2b\x0a\xec\xdd\xb7\xa4\xa6\x76\xd1\xbe\x9f\xe5\xa5\x5e\x90\x57\x26\x75\xd5\x94\x34\x80\xbd\xcc\x75\x32\x47\x28\x10\xb4\xa2\x40\xff\x9d\x1e\x0b\xfb\xd3\x1f\x61\x68\xca\x66\xe4\xa8\x30\xca\x2f\x2f\xc7\xcf\x4d\x80\xe7\x1e\x63\x6b\xe0\xb9\x8e\xca\x73\x78\x66\x85\x69\x1f\x43\x1f\x6d\xb8\x7e\xb0\x65\x29\xe3\x91\x1f\xc5\xcf\xde\x0f\x06\xfc\x76\x7e\x23\x3c\x1b\x26\xcf\x62\xd4\xbf\x4f\xd9\x5f\xa1\x98\x86\xf7\x62\x6a\x5f\x00\x96\x65\x02\x5c\x84\xca\x2f\x87\xaf\xe0\xde\xf0\x72\xdd\x33\x3c\xdf\x09\x4f\x66\x84\xe7\x37\x53\x1a\xbc\x0e\x70\xf5\x76\x02\x1b\x59\x47\xf5\x6f\xa6\x0a\x56\x32\xe0\x75\xde\x3d\x48\x96\x51\xbe\x0f\xcf\xa5\xbe\x4f\x9e\x6b\x25\x3f\x47\x37\x5c\x3b\x18\xc9\xa1\xf4\xca\x73\xf7\x4b\xc7\xd2\xd7\xa3\xff\x43\x4f\x4b\xae\xf7\xde\xc1\x80\x3f\x6d\xbd\x63\xe9\xeb\xc1\x73\xe3\xe0\x39\xed\x61\x5a\x9d\x93\x2d\x2f\x26\xd7\xd7\xd7\x4a\x77\xb0\x1b\xf9\x1d\xf0\x5c\x04\xe0\xce\xa6\xe6\xa1\x91\xf8\x79\x6a\x36\x75\x2f\x75\x83\xf2\xc6\xcc\x28\x9f\x8b\x20\x8b\xc7\xae\xe5\xc3\x68\x49\x7e\x31\xfe\x23\xbf\x1c\xbe\x9d\x2f\xe3\x69\x32\x7c\xbf\x1f\xb7\x1f\xbe\xdf\x59\xf9\x7e\x1d\x7c\x9f\xa7\x66\xc3\x11\x58\x80\x3a\x8b\xc4\x08\x9a\x5e\x54\xca\xd8\xc8\x2b\xf3\xc9\x39\xdc\x87\xe7\xbf\x13\xdc\x66\x37\xc5\x2d\xdd\xf0\x45\x4c\x6d\xb6\xc2\x26\x68\x6b\x1a\x6e\x47\x00\x6e\xdb\x93\xbd\x80\x22\x30\xf1\xf4\x63\xab\x79\xf2\xee\xfb\x00\x67\x0b\x09\x2e\xb2\x9b\xe2\x96\x6e\xb8\x7a\x90\x2c\xa3\x7c\x1f\x9e\x4b\x7d\x9f\x3c\xd7\x5a\xc6\x85\x3d\x92\xa3\x71\x34\xe2\xe2\x3e\xc0\x59\xda\x7a\x80\xb3\x49\xc9\xf5\xbe\x38\x68\xb5\xa4\xad\x77\x2c\x7d\x3d\x78\x6e\xa0\xbc\x9e\x2e\x27\xbb\xe9\x7a\x55\x4d\xd6\xfb\x8a\xd0\xa5\x02\x9f\xcb\x9d\xb6\x5e\x55\x93\xf5\xbe\xa2\xa7\xca\xeb\x65\x16\x16\x35\x5d\x4f\xd5\x64\xbd\x7f\x91\xf7\x2a\xf0\x39\xcd\x69\xeb\xa9\x9a\xac\xf7\x2f\xba\x46\x5e\xcf\x56\x10\x49\x5f\x0f\xd3\xf8\x3c\x21\x1f\x9e\xcb\x21\x78\xb9\x49\xe0\x73\xef\xa3\xd1\xd1\x86\x2f\x63\x1a\xab\x0d\x69\xc3\x34\xb2\x90\x93\xc0\x47\x81\xd7\x1e\x0d\x67\x31\x9e\xc7\x6b\x77\xc5\xe7\x4d\x9f\x65\x3a\x34\xac\x13\x05\x75\x77\x64\x6d\xf8\x81\x72\xc4\xf4\x0c\x1d\x11\x23\x0c\x8d\x42\x59\x8c\x56\x66\x27\xc2\x52\xb7\x7b\x5f\xa2\xe9\xfb\xc0\x37\xc0\xef\xb3\xfd\xd7\xf7\xbd\xca\xac\x52\xde\x97\xf9\x7f\xbf\x0f\xf0\x30\x8f\xe0\x2b\x47\xc1\xc3\x12\x19\x5f\xa8\xe1\x97\x83\x16\x3d\xd2\x2a\xf8\x1a\x0d\xcf\x8d\x27\x72\xa1\xab\xf2\xdc\x24\x19\x5f\x54\x56\xa6\xbc\x68\x72\xbd\x95\x4d\xd6\xfb\x37\xda\x40\x9e\x43\x94\x2d\x80\xd2\x9e\x1b\x0d\xcf\xa5\xaf\xf7\x6f\x34\x47\x59\x2f\x52\xda\x74\xbd\x3b\xd8\x79\xfc\x2e\x79\x3d\xc2\x3b\xbb\xc9\xf3\x5b\xe0\xd7\x37\x28\xdb\x41\x1a\x04\x0c\x46\xcd\xc1\xac\x7c\x4a\x93\xc6\x3f\xa3\xe1\x7b\xe3\xb9\x43\x49\x9c\xc0\xf7\xe6\x61\x9e\x23\xdf\x03\x9e\xa3\x4b\xc5\x08\xcd\x94\xb7\x61\xd2\xbf\xb3\x13\x70\x5f\x4f\x78\x2e\x57\xe1\xb9\x4c\xe0\x39\xcc\xa1\x2a\xad\x5e\x50\x87\x91\x3e\xc9\x70\xb2\xad\x4a\xea\xf5\xf9\xf9\xe0\x5b\xb9\xa8\x1e\xb1\x1c\x0b\xc2\x17\x1f\xac\xdd\xe5\xb2\xe9\x59\x3d\xf8\x15\xc6\xda\x38\xc5\x72\x6c\xed\xff\xc7\xdb\x7b\xc0\x47\x55\x65\x01\xe3\xf7\xbe\x3a\x6f\x7a\x9f\xc9\x4c\x92\xc9\x64\xd2\x3b\x19\x92\x10\x5a\x46\x01\x41\x44\x41\x8a\x30\xd2\x41\x01\xb1\x50\x44\x40\x2c\x20\xa0\x58\xd1\x00\x16\x54\x14\x5c\x15\x50\x01\x97\x2e\x16\x5c\xc5\x0a\xd8\x57\x45\xb1\xac\x65\x75\x6d\xb0\xae\x95\x30\x2f\xff\x73\xef\x2b\xf3\x66\x92\xe8\xee\xff\xfb\x7e\x1f\x30\x61\x72\xdf\x79\xe7\x9e\x7b\xfa\xb9\xf7\xbd\x7b\x93\x1e\x9e\x67\xcc\xdc\xe2\xc0\xb6\x00\x13\x20\xc7\x29\xd5\x8e\xd7\xdf\x19\xaa\xcc\x5c\x05\x89\xeb\x27\x6c\x74\x78\xa0\x9e\x6c\x52\xc0\xdc\x22\x7f\x9d\xf9\x34\xbd\x6c\xc6\x39\xcc\xb7\x29\x1f\xf3\xad\xe1\x41\x7a\xe6\x6f\xaf\xbf\x4e\xfc\x16\xe8\xc5\x0c\xe1\x62\x18\x4f\x05\x19\x0f\xe8\x43\x14\x8b\x74\x3c\xe6\xfc\x3c\x3e\x54\x8c\xf3\x0d\xe3\x01\xf8\x2b\xe5\xb3\xb8\x73\xf9\xb1\x00\x3f\x58\x85\x6f\x04\xfd\x21\xdc\x72\xd6\x77\x73\xe7\x15\x13\xa6\x19\xe1\xc9\xb9\x35\xfd\x84\x1b\x01\xbe\x52\xf7\x51\x2f\x53\xfc\xc8\xe6\xe0\x41\x88\x8e\x4c\x7e\xdd\x0a\xf0\xc3\x84\x8b\x21\x2f\x0d\x91\x67\x08\xfc\x5e\xa7\xd3\x15\x0a\x98\x44\x31\xe0\x82\x94\x39\x10\x1c\x91\x0c\x24\xdc\xac\xc9\xe5\x43\x56\xd6\x3a\x5c\x39\xba\x4b\x59\x4a\x6e\x09\xbd\x56\x99\xf9\xf0\x47\xfa\x85\xb1\x68\xfa\xb1\xe5\xa8\xcb\x2b\x7a\x48\xa6\xff\x60\xf3\x63\x0b\x36\x6d\x92\xbf\x3e\x7b\xdc\xb4\xab\xc8\x93\x04\xa6\x9e\x38\x87\x9d\x72\xe5\xec\xc3\x6f\xa7\x86\x33\x17\xdf\xb9\x60\xdb\x0d\xa9\xa7\xf9\x01\xf2\x8f\x17\xcf\x60\x7a\xbf\xfe\x3a\x1d\x0b\xf8\xbf\x7e\x54\x6f\x2b\x0d\x7e\x92\xe8\xad\x32\x14\x6d\xcc\xb7\x02\xdc\x30\xea\x37\xce\x50\xe1\xfa\xab\x70\xc1\x90\x5b\x2c\xce\xe2\xcd\x6c\x0d\x9f\x74\x1a\x26\xe7\xa6\x83\x2d\x32\x18\xb9\x08\xc6\x0c\xa7\x41\x73\xf7\x0c\xfe\x90\xb5\x87\x12\x03\x87\xc2\x2e\x2e\x52\x10\xcc\x0d\xe7\x0e\x4f\x06\xc2\x5d\x73\xa9\xbe\xe3\x1b\x45\x5d\x72\x0a\x0a\x7a\x5f\x94\xac\x42\x74\xe0\x16\x2e\xff\x3c\x75\xd9\xa7\x5d\x30\xac\x8e\x1c\xd6\xa4\x8c\x11\x6c\x4c\xe7\x99\x53\x40\x8b\x46\x6a\x3c\xea\x97\xe6\x11\x69\x1f\xa2\xf2\x44\x76\x19\x79\xcc\x1c\xa3\xb9\x05\xe1\x9d\xc3\x9f\xc9\x63\x97\x91\xc7\x00\xb7\x44\x85\x0b\x45\x8d\x3c\x5e\x07\x3e\xa4\x1b\xc5\x57\xa5\xfa\x90\xb9\xba\xaf\x51\x62\xb0\x02\x37\x1f\xe0\xae\xa0\xf8\x86\xa8\x70\xd7\x69\x31\xe1\x87\x9d\x81\x18\xc7\xa8\x3e\x6e\x1d\xf0\xbf\x1b\xf5\xbd\x14\x9f\xe9\x67\x66\x32\xc0\x85\x13\x0e\x70\x9d\x28\x68\x03\x94\xf0\x25\xa0\x48\x8d\x8a\x4d\xc3\x0f\xf7\x5d\x21\x7c\x06\xf7\xfd\x07\xc6\x5b\x82\x66\xbe\x4a\x24\xde\x0f\x8f\x42\xbd\x50\x75\x22\x9f\x0d\x24\x9c\xce\x41\x81\x84\xc3\x01\x3f\xac\xd6\x41\x01\x06\x9b\xc1\xfb\xe0\x80\xdd\xca\x62\xdd\x1d\xbb\x2a\x2b\x35\x7a\xaf\x07\x7c\x87\x85\x8d\x80\xaf\x06\x29\x98\x6e\x53\xbc\x16\xee\x6d\x73\x12\x46\xb9\x32\xed\x8a\x9e\x09\x2a\x6c\x86\x7a\xce\x85\x06\x26\x8a\xb1\xd9\xcc\x9a\x24\x49\x79\xfd\x95\xb3\x58\x9d\x9c\xc7\xad\x1c\x96\xc0\xdb\x97\x58\x79\xd6\xe4\x40\x9c\xf2\xf2\xc3\xc7\xa1\xc3\x86\xb7\x42\x54\xff\xa3\x3c\x4f\x17\x4d\xbf\x13\xc2\x40\x65\xea\xe3\xd9\x49\x99\x6f\x83\xac\x3d\xf9\xf5\x49\xcc\xc8\x8f\x29\xef\x82\x0c\x48\x35\x90\x77\x41\x52\x17\xf1\x77\x46\xfe\x53\xf9\x95\x3a\x0e\xb0\x15\x25\xe7\xac\xc9\xcc\x3d\x70\xfb\x93\x3b\x35\xb3\x22\x67\x9a\x02\xdc\x6a\x2a\x9f\xb3\x54\xb8\x41\x1a\xdc\x3b\x46\xb8\xeb\x21\xa7\x30\xe0\x83\x9c\xe2\x3e\x0d\xee\xa9\x9d\x0e\xbb\x01\xdf\x3e\x23\x3e\x23\xdc\x8b\x46\xb8\xb7\xa1\xdf\x29\x14\x5f\xad\xda\xef\x45\xaa\xfe\x88\x12\xe6\x8d\xfa\xb3\x4a\xd5\x9f\xa1\x2a\xdc\x24\x05\xce\x6b\xb1\x29\xca\xa3\xc0\x51\x7c\xd4\xdf\xd6\x92\x98\x03\xfe\x73\x24\x70\x91\xc0\x5f\xa8\xca\x0f\x49\x26\xcc\x15\x63\xc9\x28\x3f\x56\xc1\x0f\x76\x4f\x2a\x5a\x17\x1a\x9a\x28\xb7\x22\x97\x8b\xb7\x8b\x76\x6c\x63\x31\xeb\x71\x9b\xc4\x61\x49\x13\x6b\x33\x9f\x9d\xb4\x21\xbb\x63\x44\xd2\xce\x22\x8e\x85\xb0\xc2\x6a\x2f\x96\x3b\x5f\x4c\x3f\x0f\x9a\x79\x34\x1b\x99\x22\x8f\xfa\xa2\xca\x11\x28\xe4\xa0\x1e\xe2\x1e\xd9\x10\x9e\xdc\xd6\x86\x6f\x92\x3f\x66\x7a\xc9\x21\xe6\xbc\xd4\xbd\x87\x71\xce\x33\xcf\x3c\xc3\xbe\xf2\x0c\x2e\xdb\xf4\xdb\x61\xfa\xa8\x15\x1d\xcf\x3e\x23\x7f\x80\x8f\x9b\x34\x3e\xfe\xbc\x13\x46\xc2\xab\x7c\x9c\x0f\x70\x06\xfe\x00\xdc\x5f\x34\xdf\x69\xcd\xe4\x8f\x29\x03\xdf\x0f\x69\xb9\xfc\xb4\xd3\x26\x1a\xf0\x99\x32\xf0\xfd\xc0\xac\x51\xf0\x99\x5c\x16\x23\xbe\xa9\xa0\xf7\x33\xa9\x9d\xd4\xa9\x76\x32\x53\xe5\xf3\xb9\xe1\x7c\x67\x4e\x31\x8e\x64\xc6\x37\xc8\xf2\xb9\xa5\x34\x0f\x1f\xa6\xe6\xef\x2b\x55\xf8\xb5\xe5\x55\xd6\xfc\x62\x5c\x9d\x19\xdf\x14\xfc\x6b\x34\xfc\x6a\x0e\x4e\xe5\x18\xce\x23\xf8\xf3\x3a\xc3\xff\x9c\x82\x9f\xe4\xe0\x48\xc5\x03\xf2\x9d\x49\xc7\x5d\x47\xea\x1e\xc5\x0e\x08\x3c\xb4\x2f\xa5\x39\xd0\xb0\x8c\x76\x92\xfb\x9f\x46\xfb\xed\xa6\xf6\xeb\x55\xfb\xf5\x3a\x5c\x82\x2d\xd3\xfe\x55\xf8\x61\xb4\x5f\x5a\x57\xd0\x7e\xfd\x84\xab\x6d\x09\x29\x94\x6b\x0b\x16\xe3\xdc\xf4\xc0\xd4\x9a\xe0\x34\x4a\x4f\xb7\xcc\x7e\x49\x6c\xe3\x86\x2a\x78\x68\x7b\x3f\x3d\xe7\x37\xc0\x83\x7c\xe7\xeb\xed\x06\x78\x68\xbf\x51\xcf\xc1\x8d\xf0\x34\x57\x54\xdb\x8d\xf0\x5a\xfb\x20\xc8\x53\xae\x15\x8e\xbb\xc9\x1e\xed\xc4\xbe\x64\x66\x5a\xfb\x0b\xc8\xbc\x93\x65\x94\x04\xa5\x41\x3b\x87\x57\xb4\x01\xcc\x70\x6a\x5b\xfd\xf0\x3c\x34\x0d\x78\x73\x80\xdb\x28\x5f\x81\x4c\x3b\xd8\x7c\x3a\xc4\x4e\xf1\xb5\x53\x7c\xd6\x5d\x9c\x8e\x50\x81\xa3\x38\x85\x57\x75\x9c\x24\x46\x9f\xab\xe3\x8c\x27\xc0\xdd\x87\x89\xeb\x0e\x13\xd7\x1d\x4e\xd8\x6c\x83\xc2\x4b\xc0\x7f\x87\x13\x66\x0b\xfc\x90\xa4\x41\x61\x2e\x42\x7b\x75\xd1\xfd\x1c\xf4\x9c\x3a\xbb\xff\x93\xfa\x78\xf2\x32\xc7\x23\x1c\xd0\xfb\x3e\x15\xdd\x86\xf2\x95\x1c\x0d\x72\xae\xbc\x84\x9b\x51\x62\x05\x0b\x3d\xb0\xb8\x20\x22\x20\x35\x51\x75\x29\xb9\x6a\x76\x1f\x29\xda\x07\xcd\xf5\x51\x24\x1f\xa0\x59\x26\x92\x91\x5f\xe8\x7d\xbe\x60\xe0\xe1\x7c\xb5\xcf\xfa\xff\xaa\x4f\x12\x97\xe6\x53\x7b\x8b\xab\xf6\x36\x51\xcd\xa6\x1b\xfd\x39\x26\x28\x48\x43\x99\x7a\xa9\xbc\x53\x4c\xec\x6d\x84\x52\xef\x5e\xac\x40\x4f\x2c\xad\x08\x98\x8b\x99\x4a\x5d\x29\x75\xdc\x6b\x34\xdc\xc6\x7a\xf7\xab\x84\xe4\x0f\x12\xf4\x41\xe3\x5c\x02\xc5\xfd\x9c\x86\x9b\xb9\xbb\x5e\xc1\x9d\x5b\x5a\x4e\x70\x97\x1b\x71\x93\x9a\xea\x20\xc5\xdd\x90\x8d\xfb\xa9\x84\x14\xc8\xe1\x6d\xc5\x4c\x8e\x01\xf7\x8b\x64\xaf\x1d\x8a\x7b\x94\x82\xbb\xbb\xe2\x25\xc2\xfe\xa0\xc5\x5b\x8c\x83\x19\xb8\xc1\x66\x0e\x52\x5d\x6f\x50\x63\xc3\x68\x2d\xb7\x38\xb2\x93\xa2\x56\x71\x02\x5c\x33\xb5\xf5\x51\x0a\x1c\x33\x56\xf3\x7d\xa6\x9d\x0a\x5e\x75\xee\x02\xf0\xd1\x7a\xa7\x41\x8d\x21\x2d\xb8\x9f\x8e\xd7\xb4\x43\x65\x02\xe5\x2f\xc5\x49\xf3\xf5\x51\x2a\xec\x84\xf6\x9f\x29\xee\xf1\x14\x56\xa5\x54\xad\xa3\xf6\x19\xe9\x04\x5b\x5d\x9b\xce\x81\x72\x82\x06\x3a\xf7\x19\xe9\x54\xeb\x7b\xf0\xbd\x7c\x30\xa0\x10\xa9\xc8\x96\xbc\xb7\x7f\x8b\x70\x1f\xc0\x35\xea\x3c\x3d\x4a\xb9\x64\xab\xa8\x22\x8a\x53\x95\xa9\x0b\x97\x03\xbc\xe2\xa3\xce\xd1\x7d\x14\xf5\xa4\x2a\xb4\x91\xa7\x25\x30\xae\x5b\xf8\x73\x35\xdc\xe9\x5c\xdc\xaa\x00\xeb\x38\x75\x7f\x75\x4e\x56\xce\x9e\x09\xa7\xd0\x7a\x5c\xc3\x27\x21\x66\xb9\x62\x2b\x0c\x1e\x51\x59\x03\x90\x0c\xae\xcb\xb6\x15\x85\xde\x0f\x34\xdc\x70\xcf\x4a\x79\x9b\x72\xcf\x70\xed\x1e\x57\xd6\x3d\xd9\xfd\x60\xcd\x26\x19\x6c\x8b\xd7\xd2\x7b\xba\x75\xda\x8f\xf0\x96\xd2\x0f\xd4\xee\xc0\x17\xec\x04\xfe\x80\x3d\xa0\xda\x44\x14\x57\x25\xdc\xee\x41\x55\x09\x8b\x05\x7e\x98\xcd\xf0\x03\xdc\x4e\x15\x03\x81\x8a\x11\x6b\x1b\x0c\x06\x4a\xb3\x47\x8d\x77\x9a\x5c\x14\x7c\xe8\xa8\xce\x1b\xd0\x89\xaa\xb4\xfe\x50\xfe\x69\x32\x71\x96\x10\xd8\x0c\x48\x3a\x3e\x80\xeb\x03\xf6\x70\x1b\xb5\x9f\xa6\xec\x38\x28\x59\x78\x48\xc8\x2d\x99\xb2\xde\x40\xf6\x0b\xa2\x75\xe1\x68\x15\xde\xac\xd6\x85\xa1\x50\x2e\xe3\x82\x70\x94\x09\xdf\x07\xe8\xb8\x8d\xea\x66\x53\x96\x1c\x15\xf4\x3a\x5e\x80\xb3\xf0\x23\x35\xbc\xaa\x4d\x00\x5c\xb5\x82\x36\x8d\x6f\x9f\x11\x9f\x3e\xf7\x84\x91\xc5\x9c\x89\x6f\x9f\x11\x1f\xc0\xa9\x79\x46\x4d\x6e\x38\x13\x9f\x29\x03\xdf\x0f\xcc\x14\xad\x6e\x91\x32\xf1\x99\x32\xf0\xe9\x70\xa1\x82\x90\x11\xdf\x35\xf2\x5c\x6e\x08\xc5\xd7\x83\xc2\x7d\xa9\xce\xc5\x42\x95\x11\xf0\x71\x0e\x7d\x2e\x76\x05\xc0\xf5\xe6\x7a\x02\xdc\x18\x15\x6e\xba\x0a\xc7\xe7\x86\xfc\x56\x1d\xee\x1a\xa8\x6f\x8c\xf8\xb4\xb9\x14\x48\x53\x4a\x15\x74\xda\xdc\xd8\x75\x19\xf8\xfe\x8d\x67\xab\xb6\x5d\x50\xa5\xa0\xd3\xe8\x33\x65\xe0\x4b\x8f\x37\xc7\x93\x89\xcf\x94\x81\xef\x07\xdd\x57\xe4\x07\x33\xf0\x81\x8e\x0f\xa1\x76\xd1\xc3\x10\xdf\x95\x5a\x38\x54\x02\x18\x19\x1c\xca\xb6\x8b\x15\x70\x4f\x6f\x11\x2b\xb8\xd5\x78\xaf\xc4\xe6\x6d\x10\x9b\x21\x56\x61\xb5\x96\x2a\x06\x53\xe0\x4b\xe2\x3e\x6b\x66\xac\xca\xea\x53\x62\x68\x9f\x4a\x2d\x07\x51\x98\x54\x74\x79\xb9\x9c\xbd\x58\x29\xe3\xd2\xb5\x1c\xed\x97\xe6\x04\xb4\x5f\x04\x19\x25\x18\x02\x8d\xcb\xd4\x2a\xd8\xc2\xb4\x4f\x65\x69\x5c\x21\xbe\xba\x99\x8e\x1f\xea\x47\x74\x4c\xb1\x0b\x6f\x01\x63\x2e\xc6\xde\x4c\x3d\xa7\xe7\x00\xf3\xfb\x00\x3e\x49\x7d\xe0\x3a\xcd\x07\xaa\xd0\x46\x1f\xc8\xea\x71\xa5\x39\xcb\x26\xac\x76\xc6\x9c\xe6\x6d\x04\xe0\x36\x53\x19\x24\xff\x10\x0e\xfe\x70\x87\x68\xec\xee\x49\x73\xdf\x7e\xed\x7f\x45\x3f\x23\xdf\x4e\x1c\xa6\xf3\x67\x0f\xed\xcc\x8d\x48\x21\xc3\x5c\x18\x3d\xa3\x98\xc6\xee\x73\x69\xec\xee\x07\x0e\x09\xa0\x21\xa2\x00\xf4\x95\x3b\x73\x72\xa5\x80\x06\x6d\xc0\xbf\x59\xc7\x3f\x1f\x4d\x47\xbf\x2a\x51\x13\x3a\x98\x15\xce\x4f\x63\x47\x9d\xe1\x9f\x3f\x41\xe1\x05\xe9\xe0\xfc\x60\x38\x8d\x5d\xc7\x7d\x8d\x8e\x7b\x26\xc2\xe8\x73\x45\x7f\x00\x39\x83\x71\x24\x4f\xc1\x6e\x98\xd7\x54\xf0\xdf\xa7\xe3\x9f\x89\xd5\xd9\x97\x20\x29\xbd\x71\x6e\x48\xe9\x41\xb9\x43\xef\x63\x8d\xd6\x87\xd1\xc7\xe5\x52\xda\xb3\xe6\xca\x14\xfc\xcf\x69\xf8\xd3\xf1\x2c\x87\xd2\x1e\x36\xca\x12\x81\x8c\x0e\x51\x59\xf6\xcc\x92\x51\xae\xc6\x16\x05\x27\xc0\x3d\x47\x65\x79\x6e\x16\x5c\x8e\xc6\x10\x9d\xd7\x87\x29\xad\xbd\xb2\x69\xb5\x39\xd8\xac\x79\x37\x80\x87\x2c\x9c\xbb\x87\xd2\x3a\x36\x93\x56\x15\x3a\x83\x56\x8a\x7b\xb6\x86\x3b\x6b\xde\x8a\xed\x38\x6f\xa5\xe3\xbf\x4f\xc3\x4f\x6c\x26\xeb\x0e\x43\xa4\x54\xed\xe6\x15\x4a\x7f\xef\x6c\xfa\xcd\x56\xce\x54\x8c\xad\x99\xf4\x97\x40\xae\xf7\x30\xa5\x7f\x5c\x26\xfd\x81\x1c\xb3\xbb\x18\xe7\x18\xe9\x07\xcf\xcb\xcd\x15\x1e\x05\xd8\x3e\x94\xfe\xfe\xb8\x42\x85\x0e\xbb\x2c\x8c\x54\x8c\x9d\x7c\x87\x39\xcc\x06\x3a\x4f\x3c\x9e\xe2\x5e\xa1\x42\x8b\x2e\x0b\x26\xd0\x19\xb8\x41\x3e\x73\xa9\x1c\xfb\x64\xce\xfd\x59\x2d\x36\x82\x5a\xc7\x09\x70\x0d\x54\x8e\xe3\x33\xe5\x28\x58\x6c\xd8\x00\x37\x1a\xe2\x8f\x01\x1f\xc4\x9f\x25\x7a\xdd\x9c\x89\x6f\x9f\x11\x9f\x52\x7f\x11\x38\xd1\x66\x35\xe2\xbb\x95\xd4\x63\x86\x79\x33\x5a\x8f\x29\xf3\x66\x39\xc6\x79\x33\x25\x3e\xaf\xd4\xe2\x14\x95\xd7\x71\x45\x62\xce\x7c\x12\x49\x19\x5c\x90\x2d\x63\xaa\xef\x82\x4f\xd7\xf7\x7b\x20\xa6\x2b\x32\xce\x0f\x82\x6e\x32\xaa\xc6\xeb\x32\xa6\x32\x13\x2c\xba\xcc\xee\x31\xab\x3a\x61\xce\xf5\x83\xd0\x18\x55\x6a\x3a\xfc\x4c\xf0\xbb\x77\x0b\xe5\x6e\x65\xdd\x51\x60\x16\x1f\x2f\x53\x32\xf4\x77\x12\x52\xdf\x5e\x6c\xb8\x98\xe9\x6b\x28\xce\x19\xac\xcc\xbd\xcf\xa1\x33\x26\xd5\x09\xbf\xd5\xe6\xb2\xf3\x76\x1b\xeb\xf6\xd8\x7c\x0e\x3b\x9b\x60\x4d\xc3\x92\x2c\x47\x5e\xea\x09\x05\x9d\x1f\x1f\x4e\xef\x12\x41\xcf\x1b\x33\xbc\x8c\x4f\xa7\x8b\x2f\xd3\xe6\xd3\xe5\xaf\x1f\xc2\x39\xec\x8f\xea\x44\xfa\xc9\x32\xfe\x01\x3a\x17\x02\xfe\x86\xac\xaf\xed\xe0\xcf\x45\x31\x34\x30\x11\x0b\x38\xa3\x51\xde\x6e\x0f\x16\x98\x51\x10\x15\x15\x47\xf3\xe0\x7b\x5e\x9e\x7b\x62\x32\x8f\x0b\xba\x59\xd3\xe4\x24\xeb\xd1\x77\x38\xa1\x5b\xbd\xb9\x3b\xec\xf3\xa6\x6d\xbe\x4f\x0e\x0f\x50\x1e\xff\xf0\xd0\x8d\x28\xe8\x2c\xad\xb2\xbd\x08\xce\xc7\xdc\x8e\xff\x7c\x9a\xbc\xaa\xba\x65\xd8\x1b\x0b\x6e\x38\xe5\xcd\x21\xd3\x46\x4f\xab\x95\x8f\x5c\xf2\xd5\x9e\xfb\x8e\x5d\x23\xcb\x1b\xd6\xe2\x0d\x6f\x7f\x96\xf3\x61\xe0\xad\xc9\xe7\x6e\xc7\xc1\xe1\x03\x6f\x69\x3d\xf9\x1f\x36\xf7\xb5\x1f\xaf\xbe\x7a\xbd\x7c\x38\xb2\x0d\x69\xbe\x47\x5f\xf7\x35\xd4\xfa\x33\xa1\x5d\x5f\xe7\x35\xb4\x2b\xf6\xff\xbb\x5b\x5b\x27\x7e\x95\x5d\xa1\xd4\x1d\xf9\xe9\xbc\x91\xca\x8a\x6f\x53\x65\x25\x9a\x7e\x64\x2f\x50\x60\x12\xe9\xd8\x48\xf1\x88\x26\x0d\x8f\x54\x4f\x73\x1c\x52\x03\x87\xf5\x1a\x98\xe0\xb9\x5f\x28\xd1\xf0\x48\x3d\x75\x18\x45\xd6\x0d\x9d\xe0\x89\xeb\x30\xe9\x5a\x3a\x4e\x75\x27\x8d\xa7\x97\x0e\x93\xc8\xc2\x23\xea\x78\xba\xeb\x30\x25\x19\xf4\xdc\x2d\x5c\xa6\xe3\xe9\xad\xc3\xf4\xe8\x92\x9e\x06\x1d\xa6\x36\x0b\x8f\xce\x1f\xa9\x8f\x0e\x33\x3c\x8d\x87\xc8\x85\xfa\x29\x22\x97\x52\x85\xff\xd4\x5f\xb9\x94\x3c\xc3\x67\xe0\x37\x91\x15\xf5\x51\xfd\x69\x9e\xbe\x22\x2d\x31\x03\xaf\xcd\x3a\x4d\x8d\x7a\x7f\xbe\x2c\x9a\x4e\xe8\x34\xf5\x65\xce\x57\x61\xea\xb3\xc6\x96\xc6\xd3\xf4\x5f\xe0\x69\xf9\x2f\xf0\xf4\xd0\xf1\x38\x32\xf1\x88\x8c\x8e\x27\xa1\xc3\xf4\xef\x12\x4f\x73\x57\x78\xa8\xbe\x2a\x78\x4e\x61\xa6\xaa\x30\x43\xfe\x94\xd7\xa7\x63\x49\xe1\xb5\xa7\x6b\x5e\xaf\xcd\xe2\x35\xa9\xcf\xf5\xf5\x4d\x83\xdd\x9c\x07\xed\xfa\x7a\x26\x6d\x3f\x33\xbd\x9e\x4b\xe9\x2b\xcb\xb0\x27\x1c\x4e\xf7\x49\xd7\x6f\xa9\x3d\x0d\x52\xed\xe9\x2a\xc5\x9e\x2a\x0d\xf5\x3b\xc5\xb3\x59\xc7\xb3\x0e\x79\x21\xd7\x04\x3c\xbe\x6c\x3c\xfb\x54\x3c\x90\x5f\x7a\x29\x96\x12\xad\x8e\x23\x38\x6e\xa2\xba\x5b\xa6\xda\xe4\x22\xca\x2b\x48\x8a\x74\x7e\x12\x1c\x3b\xa8\x2d\x0d\x52\x6d\x72\x91\xca\xcf\x72\x9d\x9f\xd3\xe9\x1a\x75\x1a\x4f\x9c\xb9\x5c\xc5\x13\xd2\xf1\xb4\xd0\x35\xe9\x34\x9e\x5e\xcc\x5c\x15\x4f\xa5\x8e\x47\x59\xeb\x16\x75\x3c\xdd\x75\x7a\x62\x19\xf4\xcc\xa6\x36\x39\x48\xb5\x49\x0d\x4f\x2c\x0b\x4f\x9a\x9e\x06\x9d\x9e\xaa\x0c\x3c\x17\x08\x3a\x8f\xc1\x26\xcf\x55\xf1\xf4\x49\xe3\x21\xb2\xa5\x7a\x42\xd7\x9a\xc1\x16\x13\x6a\xfc\xbe\x4c\x91\x99\xdd\xc0\x6b\x22\x6f\x7d\x7d\x19\x6c\xd2\xab\x48\xbd\xaf\xaa\x27\x74\x2d\x89\xca\xbd\x4a\x95\xfb\xa5\x1d\xe4\x4e\xd7\x8d\xa8\xdc\xff\x93\xe1\x47\x8d\xf3\x36\xeb\xa0\x1f\x7d\x8d\xcb\xa0\x6f\xe9\x35\x89\x21\x6a\xfb\x68\x65\xee\x11\xda\xaf\xa5\x73\x27\xf5\x19\xf0\xe3\xa0\x7d\x0e\xd5\xcf\xe1\x19\xed\xca\x3c\xe2\xef\xda\x3c\x62\xda\xdf\x17\xa7\xe9\xa4\xf3\x86\x94\xce\xe1\x99\xfe\xbe\x38\x6b\xce\x95\xca\xa0\x3e\xcb\xdf\x17\x66\xcc\x79\x2a\xfe\x7e\x78\x96\xbf\x4f\xcb\x32\x1b\x4f\xda\xdf\x17\x65\xf8\xfb\x39\x06\x3c\x69\x7f\x5f\x9c\x85\x47\xd4\xf1\xa4\xfd\x7d\x75\xd6\x1c\xec\x65\x3a\x9e\xb4\xbf\xcf\xeb\x92\x9e\xb4\xbf\x6f\xcc\xc2\xa3\xf3\xc7\xe0\xef\x9b\xd2\x78\x88\x5c\xa8\x6e\xd5\x77\xee\xef\x73\x0d\xfc\x26\xb2\xa2\xba\x35\xbc\x53\x7f\x0f\x34\xf1\x98\xd4\x72\xca\x73\x48\x50\x1b\x5f\xad\xc8\xa3\x24\x53\x66\xbf\x92\xfa\x0a\x4f\x55\xea\xab\x99\x06\x89\xe9\x38\x1e\xd6\x71\x9c\x4a\x9e\x7e\xf8\x13\x1c\xfd\x1e\xed\x0c\xc7\xef\x1a\x0e\xd0\x9d\x35\x0a\x8e\xba\x6c\x1c\xed\x2a\x0e\xa2\x3b\x33\x11\x47\x60\x6a\x32\x74\x07\xf0\x6c\xd6\xf1\xac\x6b\xff\x9a\xfa\x36\xa6\x22\x1b\xcf\x3e\x8d\x16\x66\xdd\xa7\xb4\xa7\x72\x9d\x16\x79\x15\x8f\xf9\x6b\x14\x1c\x94\x5b\x65\x3a\x2f\x7f\x25\x7a\x4f\xee\xa3\xed\xb9\xea\x1c\xc7\xaa\xf4\x1c\x47\xd6\x1a\x88\x3e\xa7\x41\xdb\x6b\x0d\x73\x18\xbf\xeb\x73\x22\xba\x3d\x47\xd3\x34\xd2\xb9\x03\x6a\x27\x63\x32\xed\xd9\x60\x27\x80\x87\x2f\xa6\xb2\x9b\xa3\xca\x6e\xa5\x02\x53\x98\x81\x87\xcf\xa5\x7c\x9f\xab\xc8\x6e\x06\x85\xa8\xd0\xc6\xaa\xe0\x78\x58\xc5\x21\x48\xa7\x5e\x6e\xc0\xd0\xe1\x7e\x52\xeb\xab\xfe\xab\x22\x9b\x8e\xdf\x35\x3a\x60\x3c\xd3\x51\xf6\xfc\xa0\x82\xa7\x4d\xc3\x03\xe3\x39\x5d\x81\x89\x67\xe3\xd9\xac\xe3\x59\xd7\xfe\x95\x12\x97\x4a\xb2\xf1\xec\xd3\xc6\xc3\xac\xfb\x9c\x62\xa9\xd1\xc7\x03\xb2\x2b\xa6\xb2\x9b\xa3\xf2\x3c\xa4\xc9\x82\xcf\x25\xb2\x20\xf7\xd1\x76\x27\x4a\xd7\x8f\x9b\xb5\xfa\x11\xc6\xf7\x38\xfa\x95\xcc\x4e\x48\x74\x2e\xe3\xc1\x9d\x66\x1b\xa9\x22\xf5\xf9\x03\xa5\x7e\xdc\xae\xd5\x22\xa8\xdf\x0b\x74\x2e\xc3\x4f\xe7\x32\x9e\xd8\x19\x08\x91\x2a\xd2\x30\x37\x41\xe6\x5e\x5e\xa1\xba\xd1\x3b\x43\x37\x28\x1e\xaa\x1b\xe3\x94\x76\x6e\xa5\x81\x9e\xdf\xf5\x7a\xf6\x55\x76\x9e\xea\xc7\xd3\x3c\x50\x68\x68\x53\x69\x20\xbc\x9c\xa6\xc0\x14\x65\xce\x27\x19\xc6\xa5\xce\x27\x01\x8c\x3b\x1b\xcf\x3e\xbd\xae\x5a\xa7\x60\x89\x68\xbc\x3c\x0d\x74\xf0\x90\x50\xe7\x2e\x61\xa9\x2d\x89\xad\xd8\x8e\xce\xa3\xb6\x94\xee\x27\x1b\xe6\x20\xfa\x4e\x81\xa9\xec\x1a\x66\x3d\xc5\x43\x7c\x5a\x85\xee\xd3\xb2\x61\xb6\xe8\x30\x95\x5d\xc2\x6c\xc0\x83\xff\x14\xcf\x56\x1d\x26\x0b\x8f\xb8\x48\x87\x79\x00\x9d\xe8\x1c\x8f\x01\x66\x9b\x0e\x53\x99\x99\x53\xd2\xb8\x49\xeb\x21\xb1\xb5\x7d\x74\x3a\x87\x36\xb4\x1f\x54\xda\xe5\xbf\x64\xb5\xaf\x27\x2d\x9d\xb4\x6f\x51\xdb\xf7\x64\xb5\x6f\x20\x2d\x9d\xb4\x6f\x55\xdb\xff\x4d\x73\x5c\xbf\xde\xfe\x80\x9c\xea\xb4\x7d\x9b\xd2\x8e\x96\xc1\x18\x2f\xa6\xbc\x9a\xa6\xca\x57\xa2\xb2\xc3\x06\xd9\x65\xc3\x1c\xc4\x01\x05\xa6\xaa\x6b\x98\xf5\xb8\x88\xf2\x8a\xc1\x69\x5e\x65\xc3\x6c\xd1\x61\xaa\xba\x84\xd9\x80\x4f\xfd\x53\x3c\x5b\x71\x8f\x6c\x3c\xed\xb5\x24\x87\xa3\xfc\x29\x53\xe4\x22\x0f\x20\x74\x76\x68\x3f\x28\x8f\x20\xed\xa9\xcd\x59\xed\xeb\x49\x4b\x27\xed\x5b\xba\x68\xdf\xd0\x45\xfb\x56\xa5\x1d\xcd\x92\xc7\x70\x23\x29\xcd\x33\x54\x3e\x27\x14\x1e\x1a\xd6\x99\xb3\x61\x0e\xe2\x2a\x05\x26\xd2\x35\x8c\x66\x47\x8c\x8a\xa8\xa1\x13\x98\x2d\x3a\x4c\xa4\x4b\x98\x0d\x78\xc2\x9f\xe2\xd9\xaa\xc3\x64\xe1\x11\x27\xeb\x30\x0f\x00\xcd\x67\x74\x86\xc7\x00\xb3\x4d\x87\x89\x64\xc8\xab\x1f\xe5\x5b\x65\x07\x79\x19\xdb\x8d\xf2\x32\xb6\x1b\xe5\x65\x6c\xdf\xd2\x45\xfb\x86\x2e\xda\x55\x79\xc9\x85\xa4\x9d\xda\x4b\xa5\x6a\x47\x35\x9d\xb6\x6f\x53\xda\xd1\x02\xd0\xc9\x65\x94\x57\x33\x15\xf9\xa2\xe7\x15\xd9\x79\xd3\xb2\xcb\x86\x39\x88\xde\x54\x60\x7c\x5d\xc3\xac\x47\xc7\x55\x9e\x7b\x75\x7e\x66\xc3\x6c\x41\x1f\xab\x30\xbe\x2e\x61\x36\xe8\x30\x5d\xe3\xd9\xda\x15\x1e\x2a\xbb\x99\xaa\x9f\x3c\xa4\xca\xce\xdb\x25\xcc\x36\x1d\x46\xc7\xd3\x4e\xd6\xfc\xba\x51\x3e\x57\xa9\xf2\x1d\xa1\xcb\xd7\xd8\x6e\x94\xaf\xb1\xdd\x28\x5f\x63\xfb\x96\x2e\xda\x37\x74\xd1\x6e\x94\x6f\x37\x2a\xc7\xaa\x0e\xf2\x35\xb6\x6b\xf2\x55\x72\xf2\x3a\x2d\x27\x07\xfb\xcd\x53\x62\x5c\xae\x2b\xb3\xae\x31\xc0\x1c\xc4\x51\x05\x26\xaf\x6b\x98\xf5\xd8\xad\xc6\x94\x5c\x57\x66\xfe\x9f\x86\xd9\xa2\xc3\xe4\x75\x09\xb3\x01\xd7\xff\x29\x9e\xad\xb8\x5b\x36\x9e\xf6\x1b\x48\x3d\x42\xf9\x53\xaf\xca\xe5\x7e\x2a\x97\xc5\x59\xed\x07\x95\x78\x94\xfa\x32\xab\x7d\x7d\xea\xcb\x4e\xdb\xb7\x28\xed\xf2\x9c\xac\xf6\x0d\xf2\x9c\x4e\xdb\xb7\x2a\xed\x68\x25\xb4\x4f\xa5\x3a\x39\x5f\xb5\xa3\x94\x62\x23\xe1\x34\x0f\xb3\x61\x0e\x42\xb6\x46\x61\x72\xbb\x86\x59\x8f\xbe\x52\x75\x3b\xac\xf3\x27\x1b\x66\x8b\x0e\x93\xdb\x25\x8c\x96\x6f\xfc\x11\x9e\xad\x3a\x4c\x16\x1e\x6a\x23\xf3\x55\x3b\xfa\x5e\xb5\x91\x70\x97\x30\xdb\x74\x18\x1d\x8f\xfc\x77\x92\xd3\x51\xbe\xf5\x56\xe4\x92\xfa\x9d\xf2\xbf\x34\xab\x7d\x0b\x69\x81\xf6\x5e\x59\xed\x5b\x49\x0b\xb4\x93\xf9\x84\x57\xa8\x9e\x2b\xed\xdb\xd4\x38\x55\x0b\x34\xac\xa7\x63\x59\x94\x99\x0f\x54\xa7\x79\x9b\x0d\xa3\xe7\x03\x35\x5d\xc3\xa4\xf3\x81\x6a\x7d\xbc\xd9\x30\xe9\x7c\xa0\xa6\x4b\x98\x0d\xff\x05\x9e\xad\x5d\xe1\xa1\xbc\x5d\xa4\xc6\x29\xb7\xca\xdb\xea\x2e\x61\xb6\xe9\x30\x3a\x9e\xf6\xc5\xc0\xb7\xbb\x09\x3f\xd9\x73\x55\x7b\xb9\x5d\xb1\x97\xac\x76\xdd\x5e\xb2\xda\x75\x7b\xc9\x6a\xd7\xed\x25\xab\x5d\xb7\x97\xac\x76\xd5\x5e\xe4\xf3\x49\x3b\x91\xa3\xda\xfe\x40\x17\xed\xdb\x54\xfb\x52\x72\x63\xaf\x9e\xd3\xee\x47\xad\x4a\x8d\xdd\x21\x9f\xd7\x60\x04\xb6\xc7\xbf\x0d\x10\x7a\xfe\xe5\xd5\xf3\xaf\xfd\xe8\x13\xa5\x6a\xe8\x90\x33\x6a\x30\x80\xa3\xca\x00\xa1\xe7\x16\x5e\x3d\x27\xd8\x0f\xb9\x35\xea\x34\x1f\xd2\x60\x00\xc7\x48\x03\x84\x1e\xbf\xbc\x7a\xdc\xd9\x8f\xf6\x2a\x38\x3a\xc4\x5c\x0d\x06\x70\xfc\x64\x80\xd0\x7d\xa4\x57\xf7\x91\x1a\x1d\x1d\xfd\xba\x06\x03\x38\x0a\x0d\x10\xba\xfd\x7b\x75\xbb\xdd\x8f\xde\x52\xe7\xe6\xb2\xfd\x91\x06\x03\x38\x4e\x1a\x20\x74\x1d\xf6\xea\xba\xb7\x1f\xfd\x53\xc1\xd1\xc1\xee\x34\x18\xc0\xd1\x68\x80\x20\x72\x83\x5a\x4e\xaf\x7b\x9c\xa5\xe0\x3b\x21\x77\x70\x89\xac\xc0\xe4\x76\x94\x71\x16\xec\x41\xf4\xda\x7f\x0d\xbb\x1e\x68\x4b\xc3\x66\xd5\x4c\x59\xb0\x5b\xfe\x07\xd8\x0d\x24\xdf\xfd\x2f\x61\xb7\xfe\x19\xac\xb8\x58\x87\x7d\x00\xf8\x70\xc1\x7f\x09\xbb\xed\x0f\x60\x95\x77\x1e\x0f\x39\x4b\xe1\xea\x7c\xfa\x64\x7e\x56\xcd\xd7\xc5\x75\xbd\xf6\x53\xae\x6b\xeb\x06\x4a\xed\xe7\x24\x7d\x2d\xe9\xf4\xfa\x96\xac\xeb\x7b\xb2\xae\xd3\x5a\x90\x5e\x9f\xdf\xe9\xf5\xad\x59\xd7\xff\x4d\xae\xeb\x35\x60\xa9\x52\x1b\xfe\xc1\xf5\x6d\x99\xd7\xc1\x1e\x47\x83\x3d\x9e\xa5\xd8\x23\xd1\x2f\x90\xc1\x52\xc2\x2b\x1c\x54\x74\x35\xcf\x68\xbb\x99\xb0\x07\xb3\x61\xf3\xb3\x61\xeb\x74\x58\x5a\xd3\xe8\xb0\xc4\xff\xe6\x19\x6a\x89\x4c\xd8\x2d\x1d\x60\xf3\xbb\x84\xa5\x35\xce\x7f\x89\x77\x6b\x07\xd8\x2c\xbc\x54\x67\x14\x58\x52\xf3\x5c\xf0\x47\x78\x0d\xb0\xdb\x3a\xc0\xe6\xa7\x6b\x20\x80\x4d\xd7\x22\xa5\x4a\x0d\x94\xe6\x7f\x87\xeb\x34\x57\x4e\x5f\x4f\x6d\xce\xba\x4e\x73\xe6\x3f\xb8\xbe\xe5\x4f\xae\x6f\xf8\x93\xeb\x5b\xf5\xeb\x17\x2b\xb9\x33\xb9\xae\xd7\x46\xa5\x4a\x4e\x6d\xd0\xaf\xec\xeb\xdb\x32\xaf\x23\x32\x3e\x88\xe3\x69\xfb\xc9\xca\x41\x98\x5e\x06\x5f\xd8\x05\xac\x96\x8b\x74\x02\xab\xf8\x4d\xaa\x5f\x45\xaa\xef\x98\xaf\xad\xeb\xa4\x73\x80\x2c\xd8\x2d\x1d\x60\xab\xbb\x84\xdd\xf0\x3f\xe0\xdd\xfa\x67\x78\xb5\x3c\x84\xea\x17\xe4\x21\x7f\x84\xd7\x00\xbb\xad\x03\x6c\x75\x3a\x77\x21\xef\x62\xeb\x39\x44\xa9\x92\xbb\x18\xf4\x2b\xfb\xfa\x41\xdd\xff\x28\xf2\xff\x32\xeb\x3a\xcd\x65\xfe\xe0\xfa\x96\xcc\xeb\xf2\x9c\xac\xeb\x34\xb7\xf9\x83\xeb\x5b\xb3\xae\x9f\x4f\xae\xeb\x39\x4d\xa9\x92\xeb\xfc\xc1\xf5\x6d\x99\xd7\x95\xbc\x86\xac\x83\x28\x79\x0d\xb3\xf6\xd5\xcc\xf5\x07\xe5\xfa\x58\x2d\x37\x92\x06\xa3\x63\xed\x3f\x13\x88\xb2\xec\x58\xe8\xd5\xe3\xc5\x7e\xb4\x8d\xc0\x42\x1f\x53\x3a\x8f\x9b\x64\xad\x80\xc2\x12\x98\xba\xce\x70\x28\xed\x24\x9e\xf7\xa6\x2b\x37\xf1\x4c\x7a\xf6\xe9\xf4\x2a\x73\xb3\x4c\x4d\x46\xbc\xd7\xae\x3b\x4b\xc8\x75\x97\xda\x0b\x81\xd3\xf3\x02\xe5\x19\x8c\x47\xf5\x75\xef\xd3\xd5\x35\x22\x75\xd9\x3b\x3d\x5f\x29\x4c\xd3\x60\x98\x1b\x11\x83\x2d\x04\x26\x3d\x57\xdc\x7e\x84\xc2\x78\xf5\x39\xc4\xfd\xed\x3d\x0d\xf7\xea\xed\x6c\x0f\xf9\x32\x43\x3c\xd4\x9f\x15\x51\x75\x12\xa3\x6f\xb8\x2a\xfc\x06\x7f\x08\x99\x51\x5e\xc2\x6a\xc2\xbc\x84\x25\xab\x45\xe2\xe1\x5a\xcb\xa1\x8c\x3d\x79\xc8\x06\x5c\xb1\xbe\xb8\x21\xd6\x80\xdf\x28\x6c\xbc\xa9\xb6\xc7\x4c\xfe\xd0\xcd\x67\x2c\x1a\xda\x3c\xa3\xe5\x59\xc0\xf3\x8b\x3c\x1a\xff\xd4\x7e\x0d\xb2\xa1\xf2\x84\x0d\x59\x2c\x64\xd7\x42\xab\xd5\x64\x37\xb1\xf4\x24\x4d\x13\xdd\x44\x98\x3e\x2f\xa3\x6e\x6d\x4a\x8f\x52\x30\xec\x14\x1c\xc7\x77\xf9\x82\xf6\x68\x55\xc3\xa0\x51\x0f\x7c\x1d\x0d\x08\xcb\x2d\x67\x0f\x54\xf6\xa0\xcc\xa4\x91\x97\x4c\x58\xc2\x16\xeb\xff\x4e\x63\xfb\x4f\xdc\x63\xcc\x2e\x7e\x27\xca\x41\xb9\x09\x8b\x3f\x2c\x85\x7c\xbc\x6d\x89\x5b\x42\xa8\xf6\x40\x3c\xf4\x51\xfd\x01\x7a\x62\x27\xd9\x7e\xa8\x86\xd1\xcf\xea\x24\xe7\xe4\xd3\x53\x3a\xf1\xb7\x65\xc3\x86\xf4\x0f\x6b\x27\x74\x96\x0f\x3f\xa3\x5f\x48\x3d\x9b\x93\x7b\x2c\x56\x1e\xa3\xc7\x72\x16\x56\x14\xaa\xa7\xc9\x22\xc4\x42\x7f\x9f\x31\xbb\x44\x37\xf4\x97\x87\xa2\xa8\x47\x22\x27\x5f\x0a\xf9\xf3\xf2\x62\x51\xa9\x10\x3a\x75\xbb\x6d\xe1\x48\x84\xd0\x90\x1f\x42\xb5\xf1\xa3\xd0\x3f\x7d\x43\xaf\x36\xee\x24\x94\xd4\xab\x27\x5b\x75\x45\x0f\xab\xbd\xe1\xd9\x35\x5d\x63\x5f\x48\x5d\xf6\x9c\x60\xce\x26\x4e\x7e\x9f\xbc\xe5\xa9\xc7\x59\xaf\x16\x0f\x95\x38\x68\xcc\xbb\xab\xb2\xf2\x02\x4e\xcb\x21\xd4\x98\xd9\x25\x0e\xad\x3e\x60\xaa\x32\x6a\x0c\x6a\x1f\x33\x14\xfb\x31\x2b\xeb\x5a\xe9\xeb\xa3\xd3\xd7\xd3\x78\x54\x38\xa6\x56\x85\x93\x5f\xa6\xcf\x4a\x78\xf5\x39\xdd\xfd\x72\x39\xb5\x87\xa6\xcc\x76\xb6\x07\x39\x70\x43\x85\xef\x47\xdb\x2b\x3b\xc0\x1b\xda\x35\x78\x7a\x5e\x48\xfa\xbd\x57\xcd\x4e\x18\x80\xae\x62\x96\x53\x1d\x74\xa2\xb2\x84\x97\xc7\x92\xc3\x6a\x92\x38\x97\xbb\xce\x82\x2d\xfc\x12\x1b\x79\xda\xa4\xa5\xfe\x40\xe8\xe8\x81\xf1\xda\xde\x83\xdd\xea\x3c\x06\x85\x64\x1b\xa2\x1e\xdf\x3f\x15\xad\x64\xc2\x1f\x61\x3c\x20\xad\x9b\xf2\x93\xb8\xa0\x58\x3e\x1a\xcd\xea\xa7\x92\xf4\x63\xb2\x48\x76\xc9\xde\x45\x3f\x74\xef\xb4\x66\xb2\x39\x8e\xb1\xab\x06\x4f\xd4\xc7\xaa\x5d\xe1\xbe\x03\x30\xfe\xc8\xd8\x55\x14\x17\x15\xcb\x9f\x92\xf3\xb8\x7f\x82\xbe\x76\x89\x7e\xe8\xab\x08\x35\x25\x72\xc0\xf6\x4d\x92\xc9\x1b\x8d\x96\x78\x8b\xbd\x16\x4b\x5e\x1e\x5f\xe0\x0c\xf2\x12\x08\xa0\x25\x7e\x14\xd4\x53\x57\x4d\x77\xb3\xb6\xe9\x59\x86\xcd\x15\x77\x6e\x37\x6f\xaa\x84\xa0\x2e\xf5\x34\x4d\xdd\xa9\x1d\x0d\x49\xab\x1b\x69\xac\x98\xa9\xc4\x8a\xd7\xa9\xee\x38\x32\x6a\x4f\x1a\x2b\x66\xaa\xb1\xe2\x4b\x1a\x2b\xb0\x3b\xab\xf6\x14\xfb\x29\x30\xe4\x3d\xde\xc3\x8a\xa6\xaf\xc7\xb5\x34\x32\x2b\xc8\xfe\x00\x96\xed\x81\xdc\x5d\xc1\x52\xbd\x55\x68\x5b\xf7\xa8\xe1\x29\x0f\x1d\x97\x5b\xaf\x8b\x6f\x47\xef\x83\x04\xad\xbb\x58\xfd\x1d\x13\xf5\x59\x10\xfa\x4c\xc9\x66\xfd\x99\x12\x65\x0f\x04\xc0\x64\x4d\xc7\x05\x05\x66\x9a\x0e\xa3\xc5\x05\x9c\x8e\x1d\x54\xdf\xbb\x51\xbd\xae\xea\xa0\xef\x86\x76\x45\xdf\x3b\xe8\x9b\xc7\x2a\x39\x78\x86\x01\xe5\x96\xdc\x2e\x8b\x85\xb1\x09\x8a\x93\x8d\x37\xd7\x1a\xf6\x32\x20\x4e\xc9\xe3\x8b\x79\xfd\x81\x58\x0d\xee\x83\x55\xd5\x9e\xd9\xa3\xf6\xa6\x6e\xa5\x9a\x6a\x3f\xdb\x32\xa3\x79\xc0\xd5\x67\xdf\xac\xab\x76\x56\x5f\xe5\x09\x37\xe9\x48\x55\xee\xce\xba\xd2\x8e\x94\x32\xf6\xa4\x68\xb6\xd2\x93\xa6\xd9\xe9\x9e\x34\xcd\xce\xd6\xed\x86\x44\x90\x91\x24\x1e\xe3\xb4\x6a\x0b\xa0\xda\x02\x43\x55\xfb\xa3\x2c\xd5\xd6\x77\x6a\x48\xf7\xdb\x95\x66\xab\x84\xfc\x91\x66\x6b\xd4\x75\xd0\x6c\x6d\x1e\x82\xea\xf5\x7c\x45\xaf\x8f\x50\xdd\xf1\x67\xcc\x65\x50\xbd\x9e\xaf\xe8\x35\x46\x8a\x5e\xe7\x64\xcd\x65\x50\x5d\x9d\xaf\xe6\x40\x0f\xe1\x5a\xf2\x9c\xf6\xeb\xc8\x38\x5b\xd9\x09\x6c\x09\x81\xa1\x7a\x6d\x57\xf5\xda\x6f\x80\x25\x67\x7f\x5c\x40\x6b\xc6\xb9\x6a\xde\x5f\x89\x96\x12\x4f\x1c\x4d\xf7\x9d\x0d\x73\x10\xf0\x50\x98\xc2\x2c\xfa\xa8\x7d\x28\x63\x5c\xf7\x7d\xe6\x9a\xb6\x42\x93\x5b\x9f\xaf\xb9\x1d\x7d\xa7\xd9\x47\x93\xd1\x3e\x94\xf5\xf3\x47\xb5\xf5\x73\x3d\x6f\x52\xdf\xb7\x36\xc0\x3c\xa2\xc3\x90\x3d\x31\xfa\x67\xda\x90\x7c\x07\x85\xf1\xea\x73\xad\xfb\x53\xbf\x52\xfb\xe0\x33\xdb\xc1\x3e\x2a\xf4\x35\x91\xf9\xb4\xce\x8a\xa7\xd7\x44\xa0\x27\x0b\x77\x3f\xbb\x85\xff\x42\xdd\xab\xac\x2c\xe1\xb2\x61\xb3\x00\xce\x52\xb2\x93\xed\xb9\xcd\x02\xd0\x52\x7b\x38\x6e\xd8\x30\x5a\xdd\xae\x81\xda\x4a\x93\x16\xbb\x4f\x10\x63\x99\x73\xe4\xe4\x84\x77\xb9\xfb\x15\x3b\x71\xd2\x1d\x18\x3a\xc3\x8f\xcc\x02\xf7\xe7\xf8\xa9\x85\x14\x6b\xf8\x87\x11\x13\xc1\x61\xa5\x03\xc5\x3c\x94\x0e\x68\x5e\x75\x3f\xf7\x57\xfc\xae\xe0\x85\x3e\x42\xbb\x30\x27\x88\x3c\xf3\x24\x76\xa0\xb1\x88\xc7\x74\xdf\x09\x75\xc7\x42\x4a\x31\xbe\xf8\x35\x8c\x1b\x01\xbe\x6f\xb1\xfc\x4c\x54\xaf\xa1\xbc\x7a\xad\xb3\x1f\x1d\x55\x33\xde\xf9\x1d\xe7\xca\x08\x2c\x79\x97\x8f\xc2\x66\xd7\x98\x3a\x0e\xa5\x9d\xe4\x0e\x4d\x28\x5d\x35\x6a\x73\x6d\x54\x87\x16\x19\x9f\x8b\xe8\xa6\x5f\x27\x78\xb4\xeb\x86\xdc\x5b\xa5\xa4\x4e\x85\x6b\x3f\x93\x3e\x0f\xe7\xd5\xd7\x39\xf6\xcb\x5b\xa9\x8c\x77\x66\xb6\x83\xec\x8f\xd0\xf6\x33\xc9\xbc\x2d\xa5\xef\xdc\x4c\xf8\xcc\x76\x0d\x1e\xd5\xd3\x9a\xe9\x5c\xbd\x5d\xcb\xb1\xdf\xe3\xee\x67\xf2\xa8\x2c\x5d\xbb\x58\x24\x2a\xb2\x53\xd9\xeb\xa1\x02\x7b\x8f\xc8\x49\x93\x10\xbd\xe7\x28\xe4\xbc\xcf\x69\x39\xaf\xe2\xbd\x2c\x56\x46\x48\xe7\xbc\x1d\xbd\x14\x7e\x4e\xf1\x47\x69\xa7\x03\x39\xef\xbb\xf2\x31\x54\xc1\x8b\xa0\x51\xae\x5d\x98\x61\x38\xf0\xc2\xb5\xb5\xf4\xe0\x19\xe8\xdb\x15\x73\x55\x8c\xe4\xc5\xdf\xbf\x16\x82\x64\x3f\xb4\x02\x80\xfd\x94\xbf\x0e\xd9\xd1\x69\x89\x42\x0b\x32\x5b\xad\x16\x24\x70\x88\xe7\x58\xec\xb0\xb1\x16\xde\xce\x30\x26\x96\x37\x99\x78\x96\xc5\x92\x88\x01\x51\x5c\x39\x54\x43\xdf\x0b\x15\xc7\x03\xf5\x86\xad\xf7\x3d\x31\x97\x58\xda\x54\xda\x14\x68\x0a\x88\x01\xb1\xb4\x62\xe4\xe2\xa6\xcd\x9b\xd5\x7f\x8b\xe5\x63\x7c\x72\x49\xd3\xa6\x8d\x3d\x1e\x79\xa4\xc7\xc6\x4d\x4d\x4b\xa8\x4e\xb6\xbf\x27\x1f\xc3\x3b\x80\x06\x33\xaa\x4b\xf8\x24\x86\x47\x26\x16\xd8\xc5\x0b\x16\x4e\xc4\xf0\x57\x30\x0b\x88\x1c\xff\xaa\xec\xf2\x86\xe9\x1e\xdf\xca\x1e\xac\xc0\x0a\xe8\x2b\x06\x43\x8a\x96\x36\xe1\x1d\x9f\x34\x2d\xff\x6d\x38\x1e\xbc\xbc\x89\xdb\xfc\x61\xd3\x55\x27\x2e\xe6\x3f\xbb\xaa\x07\xd9\x3b\x6e\x08\x8c\xb1\x8c\xe2\xaf\x4a\x78\x4c\x9c\x20\xb1\xac\x20\x20\x48\xad\x58\x89\x95\x30\x1d\x14\xc5\x6e\x40\x4e\xc5\x04\x88\x61\x04\x30\x8e\x68\xd9\xf0\xdf\x96\x37\x7d\x02\xf8\xf1\x60\x18\xc2\xea\xab\x9a\x3e\xfc\xa8\xc7\x55\x54\x66\xd5\xf8\x59\x6e\x3d\x73\x13\xf0\xda\x97\x90\x18\xe0\x1b\x46\x4f\x24\x01\x63\xa5\x2e\xeb\xa8\xaf\x9a\xbb\x14\x3f\x7b\xf0\x20\x85\x7f\x00\x3f\xc0\x55\x30\x17\x03\xbc\x3f\x61\x46\x2c\xc7\x53\xf8\xa7\xd3\xb6\x47\x6e\x78\x80\xbd\x1e\x3f\x40\x6e\xc0\xed\xbf\x00\xfc\xbb\x1a\x3c\xcb\x23\x2e\x0d\xaf\x08\x14\x4c\xd5\x67\xe6\x3e\xfd\xff\x07\xcf\xb4\xb7\x81\xfe\xbe\xd9\xbe\x1c\xe0\x45\xd4\x98\xb0\x89\x2c\x2b\x71\x60\x41\x1c\xff\x64\x92\xdb\xdb\xfe\x6c\xc2\x2e\x39\x07\x01\x8e\x27\x93\x98\xec\x93\x4b\x06\x56\x89\x82\xe4\x74\x44\xac\x6f\x2c\x29\x92\x83\xed\xc9\x87\x7b\xb7\xad\x82\x7b\xf7\xe8\xa4\x49\x87\x27\x4d\x22\xfb\x69\xce\x62\x27\xb0\xe3\x41\x9f\x59\x14\x4c\x58\x10\x28\x22\xcf\xe2\x75\x63\x41\xb4\xca\x60\xa9\x2a\xb3\x51\xcc\x8e\xdf\x0c\x19\x43\x13\x7f\x28\xb5\x8a\xb9\x84\xdc\x37\x07\xee\x9b\xa8\xdd\x47\x52\x08\x1e\xb3\xeb\xc6\xe2\x8c\xfb\x3c\x51\x80\xdb\x8c\x07\xc8\xaf\xb0\x13\x98\x4b\x52\xab\xe8\x1e\xaa\xf2\xed\x6c\x35\x66\xe1\xbe\x50\xc2\x9c\xbe\x6f\x2f\x2e\xcd\xbe\xb3\x85\xde\x29\xdf\xae\xdc\x49\xee\x9d\x0d\x7d\x4e\xd0\xfa\x24\xfb\x5f\xf2\x0c\x5a\x37\x96\x31\xf6\x29\xe1\xa8\x87\xd9\x28\xbf\x82\x07\x6c\xd6\xfa\x64\xd0\x0d\xec\x04\xee\x54\x7a\x9f\x88\x8a\x13\x2e\x0e\x14\x0b\x2c\x46\x12\x30\x19\xaa\x48\xc6\x6a\x3c\x4a\x5e\x1b\x72\x14\x3e\xcc\x02\x3a\x6c\x66\xa9\x61\xf4\x0a\x07\x08\xde\x1b\x01\x6f\xbf\x34\x5e\x20\x44\xe0\x38\x93\x24\xb2\x64\x48\x3c\xee\x0c\xaf\x87\x9c\xee\x08\x78\x47\xd1\xc1\xa5\xae\x36\x70\x47\x1b\x27\xe0\x95\xd7\x70\xfd\x30\x43\xf1\x96\x26\x9c\x0a\x5e\xc9\xa4\xe1\xa5\xbc\xfa\xef\x30\xcb\x6b\x74\xcc\xe0\x07\x17\x01\xbd\xbd\xc9\xdc\xbb\xf8\x7e\xbb\x99\x7a\xce\xf7\x11\xd9\xe1\x93\xe8\xfc\x63\xed\x95\x5c\x01\x8c\xc5\x02\x1a\x16\x32\x23\xe2\x4f\x58\x51\xb4\xda\x2c\x1c\xcf\xed\x4f\x9a\x79\x91\x7f\x6e\xac\x88\x98\xbd\xb8\x10\x29\xa7\xfb\xe9\xfd\x07\xb4\x08\x1a\x63\xf9\x06\x9e\x8d\xb2\xc5\x3e\xe6\x15\xff\x3d\x7e\xf9\x11\x7c\x4e\x2e\x6a\xcf\xc5\xa3\xd9\x67\xdb\x2e\xe4\x6e\x0f\x1f\xca\xc3\x0b\xe5\xeb\xf3\x0e\xa9\xfd\x55\x73\x51\xe8\xcf\x87\x26\x27\xf2\xac\xa2\xe4\x10\x59\x9e\xe7\x3c\x0c\x72\x32\x2c\xc7\xf9\x03\x56\x8f\xdb\xb3\x3f\x69\x73\x3b\xdd\x4f\xe2\x28\xc4\x3e\x27\x2e\x4c\x98\x4d\x98\xc1\xfb\x93\x22\x78\xcb\xbd\x38\xba\x7d\x2c\x87\x90\x4e\x4a\xb0\x23\x51\xae\x38\xfd\x8f\xec\x38\x09\x74\xc5\x81\xae\x62\xd6\x03\x3f\x3c\x31\x0f\x34\x78\x18\x2c\x3f\x86\x47\x3a\xdf\x73\xe2\x0b\xe4\x3b\x43\x21\x3c\x43\xbe\x0b\x7e\x91\x1f\xc5\xa3\x42\xec\x3b\x84\xd8\xf3\xe4\x7b\xf3\x0e\x85\xe5\x8d\xf2\x23\xf0\x9b\x7c\x2f\x3e\x0f\x7e\xc3\xe7\x80\x1e\x9e\x82\x97\xb2\x37\xb1\xaf\x01\xaf\x8a\x77\x21\x41\xb0\xda\x58\x62\x85\x16\xb0\x3d\x76\x98\x84\x1d\x12\x96\x50\xed\xf8\xf1\x87\xd3\xea\x6c\xd8\xcd\x9d\xbd\x69\xeb\xe5\x0b\x1e\x7b\x74\xe1\xa2\x2d\xcc\xe6\xcb\xb7\x6e\x59\xb4\xe8\xd1\x47\x69\xde\x42\xd6\xa0\xef\xc1\xdd\xa8\xcc\x2d\xa8\x5b\x22\x20\x72\x1c\x6b\x31\x21\xd6\xc4\x5a\x6d\x10\x65\x10\xbe\x67\xac\x89\x43\x6e\x72\xcc\x84\xf1\xf4\x7d\x7d\xef\x20\x57\xfa\x2f\xbb\x16\x33\xa9\x61\x18\xc1\x87\xc1\xdd\xe4\xd7\xb5\x8f\xee\xc7\xb9\x37\x21\xe6\xf9\xf6\x70\x10\x78\x04\xc4\x32\x48\x71\xab\x4a\x69\x4c\x1c\xb5\xaf\x62\x04\x3e\xca\x2d\x25\xde\x79\x28\xf8\xe6\x33\xc1\x37\x97\xab\xf7\x60\x90\x0e\xc4\x1e\x70\x32\xf1\x5a\xed\x1e\xdc\x10\x85\xbb\xe4\x33\xf1\xd1\x11\xdc\xd2\xa1\x27\xf2\xf9\xd5\x4a\xcc\x70\xc3\x7d\x3f\xf0\xcb\x60\x44\xf9\x09\x2b\x98\x1c\xcf\x9a\x30\xcf\xb3\x60\x71\xc4\x99\xeb\xae\x5c\xf1\xe2\xa4\xdf\x1f\x0e\x8c\x3c\x80\x8f\xb2\x6f\xb6\xe5\x73\x9f\xe1\xed\x19\x38\x2c\x24\x2e\x98\x79\x13\xd8\x07\xcf\xb0\x56\xc0\x63\x36\xb3\x92\xc0\xd2\x60\x47\x70\x19\x02\x83\x01\xa3\x2f\xaa\x61\x95\x2f\xc3\x37\x69\x98\x87\xca\xdf\x66\xe2\xae\x49\x78\xb1\x20\x98\x58\x8b\xc5\x24\x49\x56\x48\xe4\x40\x1a\x12\xcb\x91\x41\xea\xc8\x0d\xa7\xe6\xb0\x74\x6b\x1f\xda\x43\xec\x07\x7c\x13\xa0\x3e\x0a\x7d\x70\x11\xec\x1b\x2a\x9f\x45\xba\x20\xe3\x17\xe9\x9c\xdf\x21\xc0\xcf\x22\x07\x0a\xa3\x52\xc8\x54\x5b\xd0\x19\xe8\xde\xc4\x04\x86\x05\x2d\x62\x9b\x6a\x8a\x8b\xcb\x22\x11\xdb\x69\x7d\x12\x7d\x9a\x9a\xce\x04\x73\xf4\xdb\x6c\x43\xba\xf7\xdb\x9d\xec\xd9\x7d\xef\xd8\x9e\xa7\xc3\xff\x39\x4b\x18\xec\x64\x0a\x18\x06\xc4\xe0\x40\x8b\x11\x63\x05\x69\x31\x50\x31\x16\x76\xdb\x9d\xcc\xad\xdc\x9d\x2c\xcc\xdd\x3b\xb6\x30\xc7\x9c\xb3\x3b\xc9\x99\xf7\x8e\xe5\x3c\xf0\xff\x51\x30\x8a\x4a\xba\x2f\x51\xa5\x7e\x00\xdb\xc4\x09\xe3\xe7\x8c\x9f\x43\x5b\x0c\x03\x89\xeb\xc7\x6d\xbb\xb4\x69\x03\x4f\x0c\xc7\xd3\x1b\x6f\x77\x6f\x34\x1c\x98\xdf\xe8\xe9\xa2\xbd\x2b\xf8\x07\xd7\x33\xc9\x07\x52\xdf\x5f\x36\x6b\xc1\x9c\x79\xf3\xe6\xbe\x5c\x58\x5d\x53\x5a\x5a\x5d\x56\xb6\x2b\xbb\x01\x3f\xda\xa1\x65\x0b\x33\x1a\x2f\xbe\x7d\xf5\xed\x77\xdd\xbd\x7a\xcd\x1a\xf9\xfd\x89\xa7\x8f\x1a\x71\xf6\xe8\x31\xf2\xe0\x0e\x4d\x78\x61\x87\x26\x25\x56\x7c\xcc\x0e\x61\x8e\xf1\x87\xd5\x58\x41\x0e\xbb\x61\xf0\xfa\x64\x46\xac\xc0\x31\x36\xca\xbc\xfa\x52\x31\x76\x01\xec\x35\xe4\x9c\x2b\x76\x08\xfb\x77\x7a\x8f\x88\x8a\xc0\xef\xb2\xac\x28\x08\x92\x89\xc7\xe4\x56\x01\xcc\xc4\xe0\x74\x75\x0c\xe4\xc3\x6e\x05\x2c\x1e\xd9\xa5\xe1\x4a\x2d\x66\xae\x01\x7f\x7b\x3e\x3b\x84\x9b\xc9\x1f\x06\x7f\xfb\x95\x4c\xde\x27\x28\x11\xbf\xa2\x5e\xf7\x2b\x7c\x05\xa5\xf1\x3c\x74\x0b\x3b\x92\x7d\x0c\x99\xc0\xde\x83\xc8\x64\x22\xa6\x85\xb1\x04\x45\xc4\xf7\x63\x19\xd0\x47\xf4\xfd\x58\xe1\x18\xea\x43\x3d\x5b\xbc\x52\x77\xf6\xca\x19\x01\xb8\x01\xc7\x7d\x2c\xf6\x31\xd3\x64\x19\x33\xdf\xc9\x18\xdd\x82\x2f\x18\x88\x67\x15\xcb\xab\xe4\x3b\x63\x14\xff\x42\xc0\x3f\x83\xe2\x8f\x27\x72\x18\xc0\xc7\x73\xe4\xd4\x19\xc9\xcc\x98\xbe\x1f\x2b\x0a\xc0\x14\xe8\xa7\x93\x0e\x14\x55\x28\x26\x73\x63\x71\xec\x03\x3c\x18\xc9\xdf\x61\x46\x96\x6f\x89\xe1\x0b\xf0\x25\xc5\x72\xeb\x40\xf9\x4e\xc4\xa1\xdd\xa0\xdf\x7e\x7e\x80\xea\xb3\x1c\xa8\x5f\xa2\xc0\xe2\x70\x40\x7a\xca\x41\xe8\x60\x38\xce\xe5\x94\x30\x66\x38\x1b\xcf\xf1\xf7\x8d\xb5\x72\x6e\x33\xe8\x3d\xd9\xf9\x5a\x3d\x61\x33\x58\x9b\x0e\x60\x2e\x3d\x8e\x11\x96\x92\x3d\xd0\xb4\xff\x9f\xfa\x67\x01\x2e\x91\x3f\xc0\x05\x4c\x81\xf6\x0d\x3f\xc2\xde\x73\xe2\x49\x6c\x97\x7f\x4c\x7f\x23\xf9\x7f\x1b\xff\x18\xf7\xa6\x60\x75\x8b\xe8\x54\x08\x99\xd7\xd3\x38\x43\xf6\x97\xac\xa0\x34\xe6\x82\x0f\xc2\x0c\xc4\x50\x48\x1b\x04\x14\x54\xcf\x3c\x52\xf5\x3e\x4a\xf4\xfe\xf4\x07\x98\xcf\x36\x00\x2c\xdc\x82\xdf\x03\x47\xf3\xab\x1a\xdb\xc9\xd8\x4e\x4f\x94\x58\x4d\x88\xe3\x1c\x16\x18\x9b\xcb\x69\xb3\xde\x37\xd6\x66\xe3\x24\xc9\x74\xdf\x58\xc9\x41\xc6\xc7\xb9\x31\xba\x4f\x49\x80\x90\xe1\x3c\xee\x60\xad\xc6\xd7\xb8\xb6\xf7\x38\x19\x95\xf1\xf3\x1e\x39\x5e\x20\xfd\xe1\xb6\xe3\x90\xfc\xcf\xb6\xb3\xc8\x79\x8c\xc0\x03\xf8\x2e\xcf\x26\xdf\x33\x7d\xaa\x03\xf5\x4f\x14\x08\x66\xb3\xc9\xca\x3a\xb0\xc3\xca\xda\xa0\x0e\xe5\x59\x64\x73\x82\x04\x40\xc6\x1c\xc9\x12\x89\xff\x72\x29\x1e\x4c\x73\x61\xc4\x59\xaa\xc1\x51\xf1\x64\x71\x57\x0c\xd2\xc2\x18\x3d\xa0\x89\x78\xb3\x03\xe0\x2a\x0f\x1c\xd0\xbc\x19\x38\x4a\xdd\x9f\x31\x7a\xdf\xac\xea\x31\x45\x51\x02\x8e\x48\x66\xb3\xd5\xc4\x41\x2c\xe6\x49\x2e\xfb\x07\x1e\x93\x75\x29\x2e\x73\x1d\xee\x29\xbf\x78\x36\x71\x99\xa4\x0f\x79\x1d\xde\xae\x3b\x4d\xdc\xee\x84\x3e\x8e\x43\x1f\x34\x3e\x11\x37\x29\x70\x58\xab\x8c\xc8\x1b\xbc\xe0\xd8\xc1\xde\x2a\x46\xbe\x88\x3f\x7d\x11\xd2\xfc\x12\x7c\x89\xbc\x2a\x7d\xdf\x8d\x48\x20\xb1\x46\xc0\x10\xda\x44\xa0\x0d\x62\x45\x87\x58\x43\x68\x08\x63\xc0\x70\xfc\xb8\x1a\x0f\x9e\x90\x07\xd2\xf1\xb9\x00\xc7\x31\xa8\x41\x04\xa8\x42\x2a\x12\x6e\xce\x64\x36\x63\x91\xe7\xa1\x14\x01\x3a\x2c\x26\x4a\x88\x3e\xae\x7a\x55\x69\x29\x49\xa4\x00\x69\x2a\x15\x03\x15\x23\x5f\x38\x76\xec\x85\x91\x57\x5f\x7d\x35\xd0\xc6\xef\xfa\xe8\xa3\x5d\xbb\xe6\xcc\x99\x6d\x94\x9b\x0d\xea\x27\xbf\x49\x30\xb3\x36\x6c\x86\xda\xcd\x62\x97\x6c\x64\x86\x8d\xb3\xa4\xa3\x8d\xca\xbc\x80\xb6\x95\xa4\x22\x23\xa3\x84\x82\xba\x80\xe4\x7b\x75\xf9\x60\x3c\x90\x11\xd9\x0d\xdc\x3a\xd0\xed\x5e\x89\x7c\x14\x74\x9a\x4c\x52\x50\x0a\xe5\x40\x34\x73\x7a\xbd\xdc\x17\xc9\x89\x5e\xec\x25\x15\x02\x39\x01\xb3\xb6\xbe\xb6\x72\x3c\x31\x44\xb7\xba\xf4\x93\x3e\x77\x41\xdb\xb1\x12\x86\x15\xcf\x67\xf4\x43\x99\x98\x1f\x6a\x7a\xf7\x3d\x7d\x3b\xf7\x30\x18\x11\xc3\xc6\xa6\x0e\xbe\xe4\x42\x46\xc4\x4b\x46\xf7\x9b\x34\x56\xde\x80\xdb\x6f\x62\xc3\x85\xb5\xa7\xf4\xbc\xe8\x72\x79\x28\xd8\x22\x16\xdb\x2f\x60\xbf\x67\xae\x71\x8a\xfc\x14\x84\x52\xf4\x9d\x0d\xec\x87\xb6\x3d\xb4\x6d\x86\xd6\x86\x7e\x6a\x9f\xc1\x1e\x61\x96\x40\xdb\x1c\x68\xbb\x85\xb6\x7d\xdf\xbe\x80\xfd\x84\x99\x03\x95\x7a\x1d\x33\x4d\x69\x83\x7b\x67\xc0\xbd\x04\xee\x02\x05\x8e\x9c\x77\x4e\xf6\x60\xe4\xd7\xa2\x08\x9a\x90\xa8\x77\xe5\x98\xf3\xf2\xbc\x28\x10\x86\x82\x2d\x9f\xcb\x2f\x88\xfa\x82\x53\x92\xb9\xd8\x8b\xa7\x24\x73\xbc\x16\x9f\xd7\xeb\x03\xcb\x45\xa2\x7d\x4a\x12\x02\x73\xde\x94\x24\x49\xa5\xc0\x4a\x9d\x07\xd2\x07\xbf\xba\x8c\xbb\xc3\xba\xb5\x83\x28\xeb\x49\x72\x55\xc8\x34\x74\xa7\x87\x3a\xf3\xfa\x81\xbf\x24\xb9\x50\xff\x32\xec\xfb\x27\x7e\xfd\xc7\xb6\x7f\x86\x64\xd9\x72\xce\xd9\xd3\x2f\x9d\x76\x29\x73\x99\x7c\x09\xc9\x2b\xf1\x16\xbc\x08\xc7\x7e\xfd\x15\xdb\xb7\xdf\x69\x3b\x63\xec\x23\x1b\x9e\x78\x1c\x5f\xb0\xef\xf1\x7d\xcf\xee\x03\x2b\x1a\xd6\xde\xca\xad\x01\x1f\x93\x8b\x0a\x21\x3b\xb8\x23\xd1\xc3\x2a\x49\x96\x82\x40\x89\x2f\x28\x3a\x9d\x85\x79\x82\xc0\x45\xb8\xc2\x60\x20\x84\x72\x4d\x0c\x68\x8a\x27\xc6\x78\x98\xf2\x32\xc9\x6a\x77\xb8\x8b\x51\xc8\x14\xe4\x82\x85\x13\x93\x4e\x80\xd8\x8b\x2d\x09\x77\x32\xe8\x09\xe4\x26\x7c\x1e\xb1\x64\x52\x52\x8c\x4c\x4c\x8a\x3c\x34\xef\x4e\x8a\x1c\x6f\x06\xeb\x6c\x39\x50\xaf\xa6\x05\xa1\x43\xf5\x6a\xae\x4c\xc6\x6d\x3c\x36\x2d\xe3\xbc\x63\x3d\x0c\x94\xb8\x9c\xc5\x4d\x71\xd1\x1f\xa0\x3f\x44\xb6\xb1\x89\x67\x78\x31\xd6\x54\x52\x2a\xc6\x70\x49\x29\xeb\x0f\xb0\xde\x80\x47\xc0\x3d\xbf\x61\x72\xc3\xd7\xe6\xb5\xd4\x14\x5f\xdb\x38\xa7\xe9\xd7\x87\x2e\x69\xc6\xae\x6b\xe4\x5b\x7d\xd7\x06\x7a\xc5\xf3\xaf\x65\x9c\x95\x3d\x0f\x56\xf7\xfa\x20\xb8\x6e\xd7\x90\xcd\x78\x27\xb3\xde\x79\xe9\x15\x16\xef\xdd\x9f\x4f\xd9\xde\x3b\x75\x7a\xcd\xde\xee\xf2\x79\x96\x71\x53\x25\xf7\xd5\xdc\xda\xb8\xe3\xe4\xa6\x2a\x1b\x7e\x6d\xd9\x24\xe6\xde\xd3\xa8\x9c\xc9\x9e\xba\x6b\xf8\x73\x51\x19\x1a\x9f\xa8\xf3\xf3\x50\xbb\xe5\x4b\x4e\x67\x2c\x07\xe5\xe7\xe4\x57\x94\xdb\xdc\x13\x93\x45\xa6\x20\x6b\x2b\x20\x27\xb2\x87\x0b\x0a\x4a\x27\x26\x0b\x38\xc6\x1f\xf6\x4f\x4a\x86\xa1\xa0\xa8\x35\x1c\xf0\x4b\x93\x21\x32\xd0\x4a\xe3\xf9\x7b\xca\xc6\x8d\xe4\xf4\x85\x80\x7a\x18\x19\x99\x4f\xd6\x76\x01\x26\xe3\x8d\x16\x20\x72\x28\x83\x22\xfe\x02\x7c\xe5\xd5\xe2\xbf\x2d\x5c\x71\xe3\xc0\x78\x3c\xdc\xbb\x6e\xd8\xd4\x73\xeb\xb1\xeb\x5a\xf9\x1a\xf9\x2b\xf9\x08\xd3\xe3\xc9\xb6\x9e\xf2\xf1\xbc\x79\x67\xc8\xc7\x99\xcd\xf2\xa1\x8b\x70\xf1\x5f\xc6\x2e\x9f\x3a\x77\x5c\x8d\xe3\x5b\xc7\xee\x7b\x7c\x8d\x0f\x74\x97\xc7\xe0\xf3\xf1\x18\xe6\xaf\x2f\x3d\x73\xea\xcc\xcb\xc8\xf8\x8a\x41\x8f\x2f\x82\xb8\xe3\x42\xc9\x84\x8b\xc7\x92\xc4\x8a\x4e\xbb\xd9\x69\x76\x7b\x4c\x56\x9b\x95\x08\x37\x94\xe4\x6d\x98\x9b\x92\x74\xd8\x30\xb8\x7a\x6c\xc3\x92\xc3\x81\xe0\x57\x56\x72\xa3\x96\x16\x63\x9a\x67\xac\x82\x94\x3d\x29\xe3\xda\x01\x38\x8a\xb2\x12\x27\xdc\x40\x94\x17\xbf\xc6\x5c\x95\x5a\x46\x7c\xb1\xfc\xf9\xcd\x37\xb3\x4f\x72\x97\xc9\x8f\xbf\xf1\xcc\xed\x24\x9b\xb8\x9d\xdd\xfa\x06\xd0\x35\x16\xe8\x7a\x10\xf8\x5e\x87\xee\x4f\x84\x73\x82\x85\x25\xa5\x05\x45\x45\x64\x6f\x50\x8b\x0b\xbc\x56\x49\x90\x05\xd3\x40\xa8\xbe\x8e\x54\x3f\xcd\xe0\x57\xea\xea\xb8\x52\x8b\xd5\xb2\x20\x59\x64\x8d\x39\x9c\x8e\x05\xc9\x02\x67\x8b\x15\x23\x2b\xb6\x3a\x9c\xd8\xc1\x5a\x9d\x39\x39\x4e\x2b\x5b\xe5\xf3\xe5\xce\x4f\xfa\x44\xbe\x8a\xab\xba\x34\xc9\x05\x51\x87\x03\x98\x61\x18\x13\xc6\x8f\x57\xac\x51\xf9\xe9\xa6\x71\x94\x4e\x67\xb8\x03\xe9\xc3\x56\xd3\x67\x49\xda\x71\x2c\xda\xd0\x97\xa1\x47\xfa\x34\x68\x07\x5a\x6a\x07\x3d\x91\x9d\x9c\x95\xbf\x5e\x3b\x16\xa3\xf5\x8d\x4d\xdc\x83\x91\xb7\xee\x4c\x0d\x4e\x36\x47\x9e\xda\xbe\x7d\xfb\xbb\xef\x6c\x7e\xae\xea\x5f\xbe\xe1\xa7\x8e\x1d\x86\xf3\xe5\xcf\xc8\x27\xda\x6f\x38\xbe\x72\xc6\x85\x2e\x7c\xe1\x63\xfb\x0f\xd7\x9f\x32\xee\x34\xe1\xf6\xd9\xb7\x27\x5e\x79\xfd\xc6\xb5\xb5\x67\x9e\x76\xe9\x55\xe5\xf0\x1b\x77\xea\xc4\x01\xd5\x53\x27\x00\x9f\x06\xb4\xf7\xe6\x96\xf2\xe5\xa8\x1c\x0d\x4b\x54\x38\x91\x24\xd9\xcc\x25\xb8\x34\xa7\xa0\x20\x12\x29\x0a\x94\x9a\xf9\x8a\xca\x22\xde\xcb\x4f\x49\x86\x9c\x5e\xd0\x30\x36\x68\x73\x94\x16\x20\xb3\x9b\x9e\x2d\xd7\xf2\x22\x3d\x12\x28\x6b\x0b\xe1\xb8\x36\x6f\x1c\xc0\x0d\xba\x37\x06\xd5\x0c\xa8\x67\xa4\x05\x3c\x71\x51\x3b\xd4\x0d\x4c\x10\x24\xca\x7e\x89\x9d\xc5\xf5\xf1\x5e\x5f\x0a\x6f\x0a\x4c\xe1\x05\x67\x8e\x18\xed\x7d\xf0\x2f\x63\x85\xf9\xd3\xbe\x28\x28\xbb\xea\x8b\x8b\x0f\x30\xab\x0e\xac\x9e\xff\xd4\xda\xd4\x3e\x76\xc4\xd3\x15\x8b\xeb\xa6\x8d\x1f\x3d\x16\xdf\xf2\xe1\x63\x6f\xa6\x6a\x99\x55\xd7\x2d\x32\xc9\x6f\xa6\x6e\xef\x27\xff\x4e\xe2\x08\xaf\xbe\x97\x35\x00\x6a\x96\x02\xd0\xcd\x32\x54\x89\xee\x49\x54\x84\xfc\xfe\xd2\x48\xae\xc7\x13\xf4\x7a\x4b\x8a\xf2\x0a\xb9\x68\x45\x34\xaf\x8c\x43\x0e\xd0\x84\x72\x8b\xe8\x40\x8e\xaa\xea\xf2\x4a\xb7\xdd\x1f\xf0\x13\x85\xb5\x25\x8b\x73\x2d\x81\xa2\x88\x39\x54\x12\x0e\x87\x48\x8b\x27\x59\x2a\xb2\xe1\x40\xb8\xac\x2c\x1c\x60\xb1\xd3\xeb\xe6\xb1\x92\x0d\x6a\x53\x95\x2a\x13\xd4\x3c\x89\xa6\xa4\xe9\xf3\x4a\xe3\x69\xd1\x2b\x07\x08\x52\x20\x35\xa0\x47\x3d\x71\x17\x8d\x8f\xf4\x54\xaa\x28\x1b\x53\x74\x9c\x2c\xb9\xc6\x4b\x63\x01\xbe\xb4\x21\x16\xc0\x81\x38\x2e\x8d\xad\xc0\x67\x6f\x79\x16\xe3\x15\xf0\x47\x7e\xf8\xde\x97\xe5\x76\xf8\x82\xaf\xbf\xbe\x69\x04\x83\x9f\x65\x97\x34\xc9\xb3\xad\x51\xfc\xb2\x25\xc4\x5e\x81\x5f\x95\x1b\xc9\x67\xd3\xaa\x4d\xf2\x74\xbc\x96\x7c\xc8\xd7\x17\x57\xf5\x1b\x7a\x5e\xcd\x2a\xfc\xd7\x05\xa9\xa7\xc9\x3e\xc5\x1c\xaa\x6e\xff\x85\xdb\x07\xbc\x92\x50\x35\x6a\x40\x83\xd1\x13\x89\xda\x58\x61\xa1\x19\xd5\xf4\x6a\x69\xe9\x71\x7a\x63\xe3\xe9\x7d\xfa\xf7\xcf\x75\x39\x9d\xe5\xb9\xb9\xa7\xd7\xb0\x82\xdf\x6f\x8e\x93\x03\xe9\x84\x21\x67\x94\xfb\x23\xb6\x53\x3c\x36\xcf\x5e\x1c\x48\x58\x92\xa7\xd9\x5c\x2e\x5b\x4e\xdf\xc1\x3d\x06\xc3\xef\xdb\x93\x91\x12\xd2\x1c\x4a\xc6\x62\x91\x48\xaf\xe6\x1e\x3d\xb8\x38\xb7\x20\x19\x8f\x8b\x82\x58\xbf\x20\x09\x55\x49\x10\xb5\xa4\xf3\x4b\xb0\x1e\xc8\x1a\x20\xb7\xab\xad\x54\x77\xa5\x56\x43\x99\x2b\x7d\x1e\x9a\x2b\xcd\xc0\x20\xcd\x0a\xc9\x47\x77\xf3\xb5\xca\x2c\x45\x25\x39\x0e\x36\x5e\x80\xd5\xc3\x70\xfc\x5d\x9f\x9b\xe6\xc7\x64\xff\x14\x10\x85\x27\xf3\x34\x30\xf5\x68\xf4\xd3\x1e\x69\x2d\xdf\xf5\x16\x24\x24\xf3\x66\x8c\x19\x32\xcd\x32\xdf\xd5\x23\x14\xac\xae\x1b\x9c\xb8\x60\x78\xbf\xc9\xa6\x05\x7c\xc4\xe3\x0b\x36\xc4\x17\x9f\x7c\x77\xe0\x68\x67\xf0\x8e\x9a\x61\xbd\xc6\x2e\x5b\xd6\xb3\x3a\x1c\xef\x3e\x72\x02\xfb\xeb\x43\x07\x52\x73\xf9\x01\x6d\xb3\x47\x5e\x38\xf1\x2c\xd7\x98\x52\x6f\x51\xdf\x68\x7c\x6a\xf3\xd9\x13\x26\x9e\x6e\x2d\xaa\x8c\x84\x8a\x9b\x63\xa3\x99\xb7\x26\x26\xe5\xcb\xe5\x13\x17\xae\x5c\x79\xa1\xbc\xe6\x2c\xf1\x42\xcb\xf0\xa1\xf8\x7a\x3a\x8f\x12\xa1\xcf\x03\x0d\x40\x76\xe4\x87\x2a\x60\x6e\xa2\xaf\x97\x65\xad\xd8\x2e\x49\x8e\x9e\x79\xd5\xd5\x0e\xc8\xfe\xe3\x45\x01\x2e\xd0\xaf\x7f\xf7\x9e\x45\xf9\x5c\xa8\x2e\x14\x05\xbb\xf4\x58\xbd\x5e\x66\x62\xb2\xae\x69\x4a\xb2\x8e\xa4\x4a\x3c\xef\x99\x98\x84\x6c\x9a\x73\x13\x0d\x55\xf9\xdc\x52\x69\xf4\x53\xfa\xde\x32\x81\x74\xcd\x44\xd5\x91\xa8\x1f\x28\xa0\x72\xf4\x7d\xdc\xc3\xaa\x7c\xc2\xfa\x01\x43\x0a\x53\x6b\x71\x9c\x9e\xe5\x65\x64\x6b\x3e\x8e\xe0\x7c\xd0\xc4\xf5\xf5\xaf\xe3\xe2\x7b\xef\x19\x37\xc8\xf2\xcc\x4f\xcd\x89\x01\x83\xe7\xb1\x05\x77\x5d\xb7\xec\xd6\xc0\x76\x6b\xbc\x47\xf7\xba\xea\xfe\x35\x78\xd4\xa8\xea\x5b\xae\x9d\x77\xb3\x73\x97\x54\x59\x5a\x5d\xe5\x8a\xd5\x97\x4e\x3c\xb7\x8e\x61\x53\x29\x7e\xc0\xe1\xe7\x5b\xf7\x96\xa6\x9e\x64\x37\x4f\x48\xca\xd7\xcb\x23\xef\xdd\x79\xdd\x5d\x75\xe7\xf4\xed\x79\x6a\x53\x4b\xd0\x5d\x78\xf6\xe5\xc9\x7b\x1f\xbb\xe3\xa6\xc2\x33\x7b\xc5\x7b\x17\x55\xe5\x7b\x9d\x25\xa3\x16\x13\x73\x17\x74\x9b\x27\x67\xe9\x57\x83\xc7\x6f\x40\x3d\xd0\xae\x44\x1f\x9e\x29\xa8\xa9\xb2\x98\xe2\x21\xbb\xcf\xe7\xef\x51\x19\x41\x98\xe7\x9a\xfc\x56\x6b\x51\x61\x7d\x43\x69\xa8\xb6\x2e\x6c\x2a\xab\x6a\xb2\x73\x6e\x57\x81\xab\xb9\x67\xb9\xc8\x71\xcd\x0d\x8d\x3d\x9a\xe2\xf5\x61\x7f\x41\xb4\x80\x98\xbd\x35\x59\x53\x59\xea\x89\x96\x17\xbb\x21\x6b\x24\x0d\xde\xa4\xc3\x22\x41\x16\x51\x97\x1f\x85\x44\x9e\x0f\xe6\xbb\x6d\x3c\x9b\x3e\x69\xd9\xa5\x9a\xbb\x62\xff\x86\xaf\xf1\x78\xba\xa8\x70\xab\xc7\x4d\xb9\x9b\x33\x93\x16\x25\x1d\x2f\x05\xdb\x67\xc1\x27\x34\xc5\x03\x71\x4f\x94\x05\xdd\x14\xe1\xc3\xc6\xd8\xd2\x98\x08\x3f\x21\x97\x6e\x6c\x8a\x45\x70\x71\xcc\x1f\x88\x37\x05\xe2\xa5\x01\xfa\x5b\x53\x6c\x51\xe1\x98\x3e\x7d\x30\x5b\x7f\x88\x7f\x9e\x3b\x54\x87\xd9\xbe\x2d\xc9\xc2\x2b\x6e\xef\xfb\x5b\x22\x36\x2b\x76\xea\x6f\x2d\x6b\xd8\x8b\x05\xf7\x8a\x1a\xa7\xbc\xe6\x5a\xb7\x58\xeb\xdc\x15\x71\xb4\x61\x8e\xc1\xb2\xc4\x30\x4c\xcf\x0f\x36\xe1\x1b\xe4\x05\x0e\x07\xf9\xb9\xe9\x83\x4d\x90\xfc\x59\xc0\xc5\xfc\x8c\x57\x6d\x1a\xb8\xfa\xde\xbe\x1f\xdc\x36\xb8\x6f\xdf\x53\xfe\x63\x36\x73\xd8\x86\x18\xe0\x31\xe2\x1e\xe3\x8e\x40\x0d\x97\x0f\x19\x4d\x80\x17\x3c\x4e\xc1\x19\xb6\xd9\x83\xe1\xb0\xbd\x20\xe2\x72\x39\x04\xc1\xe9\xc8\x39\xc5\x81\xcf\x44\x76\x7c\x16\x80\x59\xf1\x39\x28\x89\xc8\xef\x4e\xe4\xa1\xdf\x9d\xd0\xae\x17\x9a\x50\xc8\x36\x03\xe3\x6a\x0d\x53\x82\xda\x53\x20\xf5\xf9\x18\x82\x84\x72\x7c\x3a\xa8\x25\x3d\x0a\x97\x1e\x2c\x18\x77\x39\x85\x18\xde\xfa\xd8\xfe\x31\x6f\xd7\x5e\xb8\xe0\x9e\x37\x71\xf3\xdb\x0f\xce\xbf\xa0\xf2\xcd\xc3\xbf\x70\x47\x2e\xf8\xfa\x90\xfc\xcf\xdf\x56\xdf\x99\x68\x3b\xc9\x1d\x69\x2b\x65\xa3\xa9\x9d\x2d\x6b\x6e\x67\xee\x4d\x0d\x97\xdf\x4a\x91\x67\xfd\xe5\x3b\xb9\x27\xe8\xda\xeb\xdb\x74\x6d\xf8\x4d\x84\x4e\xfe\x8c\xc4\xed\x4c\x75\x00\xb5\x34\x28\xf3\xc9\x03\xe9\x7e\x45\xe7\x42\xec\xd8\x95\x98\x06\x09\x4e\x99\x29\x2f\x57\xcc\x35\xc5\x70\x99\x3d\x50\xc6\x7a\x4c\x9e\xea\x2a\x4c\x73\x84\x0a\x67\x89\xcf\xef\x5b\x90\x8c\xf9\x23\xce\x6d\xce\xfd\x4e\xb6\xc5\x39\x8b\x7e\x79\xdd\xc9\x6f\xf3\x63\x87\x7f\x9b\x7f\xbf\xff\x75\xff\x31\x3f\x6f\x65\x9d\x7e\xa7\xdf\x12\x0a\x15\x5c\x96\x74\xe4\x45\xf2\x6a\xf3\x58\x33\x9b\x97\x17\x12\x2d\xdc\x65\x49\x93\x45\x84\x34\x64\x37\x64\x21\xa2\x68\xc9\x01\x7d\x02\xbf\x18\x27\xcc\x89\x2b\x59\x51\xc6\x44\x98\x31\xb5\x50\x98\x16\xd0\x83\xae\xcb\xad\x1e\x85\x4b\x2d\x95\x9c\x93\x1e\x2b\x2c\x22\x2a\x55\xd2\xd0\x04\x3f\x1b\x8b\x20\x33\x54\x0c\x56\x84\x8c\x82\x9c\x4e\x15\x65\xaf\x92\x6f\x0a\x5f\x3d\x69\xe8\xb2\xfe\xcb\xc6\xbc\xb1\xe2\x3d\xf9\xbb\xe2\x35\xcb\x58\x76\xd9\xea\x22\xec\xfa\xf8\xe7\x8d\xcb\xfa\x2c\x3f\x73\xfc\xc2\x20\x9e\x2b\x2f\x64\x39\xbc\x02\xbf\x7e\xf9\xb2\x3e\x8d\x7b\xcf\x3e\xfb\xf7\xaf\x6e\x3b\x8d\x1f\xba\xf2\x1f\x3f\xaf\x7c\xb5\x5b\xe2\xca\xcb\x6e\xf1\x35\x57\x14\x28\xbc\xcb\x51\x6d\xd1\x83\x06\x25\x62\x9c\xd3\x69\xb2\x40\x89\xed\xc1\x2e\x97\x57\xb4\x5a\x7d\x76\x8b\x07\x81\x7b\x22\x33\x39\x8c\xcd\xe5\x16\x18\xcd\x7a\x6a\x55\x53\xa1\x46\xa2\x3e\xa5\xa6\xe4\x7f\x60\x14\x34\x42\x62\xba\x1d\x39\x56\xf6\x99\x8f\xe5\xcc\xc2\xa5\xb5\xf8\x5a\x3c\x1a\x12\xd2\x75\xf2\x2e\x28\x57\x1e\x94\x9f\x5e\x2c\x1f\x99\xc5\xd6\x32\xfe\xd4\x37\xe4\xf3\x6d\xea\x29\xa6\x7a\xa5\x3c\x99\xe9\x4f\xe8\xa2\x7b\x92\x02\x5d\x01\x34\x3d\xd1\xe8\xb4\x92\x4c\xd5\x6d\x37\xb3\xa2\x5f\x34\x5b\xbd\x7c\x30\x07\x79\x7d\xde\x89\x49\x9b\xcb\x29\x0a\x2c\x63\xb1\xf2\x90\xf5\x09\x8c\xd5\x29\x30\x8c\xe0\xb4\x72\x66\x1f\x4b\x72\x1e\xf5\xbc\xff\x5a\xc2\xe7\xe6\x66\xb7\x6a\xbd\x99\x67\x28\xa4\xcf\xd2\xf7\x15\xfb\x78\xf2\x71\x45\x1b\xf8\x86\x62\xf2\x21\x33\xaf\x3e\xe6\x04\x1e\x26\x3f\x4e\x3e\xf2\x11\xf9\x28\x2e\xa2\x9f\x99\xdc\x08\x6e\xf2\xeb\xcb\xbe\x5d\xf6\x10\x7c\xe4\x7f\x3d\x38\xf7\xdb\xb9\x0f\xc1\x07\x9f\xfa\xc5\x17\x6a\x5e\x23\x5f\xcd\xbd\xcc\x7f\x04\x79\x76\x23\x3a\x05\x0d\x85\xfc\xf6\xb6\x44\xfe\xa8\xe2\x82\x53\x2b\x86\x0d\xae\xf1\x0d\x6c\x91\xf8\x9e\x00\x36\xb0\xa6\xb6\x6c\x58\x81\x69\xdc\xf8\xa6\x31\x79\x63\xc0\x63\xed\x4c\x0e\x2e\xab\x29\xa3\x5f\xdc\x35\x8e\xde\xf0\x65\x7b\x32\x36\x9c\xb8\x32\x7f\xb2\xa6\xc2\x11\x2b\xe6\xf9\xe2\x98\xa3\xa2\x46\xc8\x8b\x4b\x6c\x9e\x3b\xa7\x3f\x85\xc8\x51\xca\xcb\x96\xf8\x8b\xb5\xea\x80\x6b\x95\xe8\x6c\x48\xd0\x03\xcd\xae\x8c\xc9\x58\x6d\xa9\xa0\x94\x15\xc4\x58\x63\x93\x87\xa6\x7a\xd8\xef\xf6\x79\x19\xd2\x9a\x3e\x62\x3e\x84\x9b\x04\x72\x10\x62\x53\xac\x2f\xd3\x14\x17\x44\x7a\x9c\x9d\x12\x99\x8b\x21\x68\xbb\x5d\xdd\x99\x52\x3b\x66\x19\xb1\x34\x3d\x1b\xdb\xc4\xbd\x3c\x6a\x72\x63\xac\xc0\xeb\xd8\xea\xf7\xb4\x78\x2f\x98\x32\xf2\xfc\xd4\x45\xcb\xd7\x9c\xf7\xe0\x94\x8b\xa6\x9c\x3a\xae\x31\x91\x88\xc7\x0a\x07\x0e\xae\xbb\x7e\x5a\xd5\xfd\xa3\xc4\x3e\x25\xb5\x05\xa7\x15\xf5\xc6\x4f\x45\x8a\xab\x0b\xca\x73\x53\xc3\x86\xf4\x99\x7a\x55\xbf\xc6\xfc\x9e\xd5\x0d\x0d\x4b\x0b\x8a\xbc\x41\x9f\x3d\x54\xc9\xe3\xea\xd5\x77\x57\xca\xbf\x5d\x56\xd7\xfb\x46\xfc\xce\xea\xbb\xd7\xb0\x57\xd8\xe5\xa3\xdf\xbd\x2c\xaf\x7c\x67\xd6\xac\x11\x67\x9d\x36\xd9\xc3\x44\xf0\xa9\xa3\xc3\xfd\x7b\x46\x9b\xcd\xa3\xca\x62\xae\x5e\xf3\xdb\x72\xee\x9e\xb3\x61\xee\x92\x51\xe7\x5f\x92\xc4\xab\x71\xc9\xf3\xd8\x6c\xef\xff\x93\xfc\xa5\xfc\xe8\xea\xea\xc2\xa6\xf2\xba\xf2\x21\x67\x90\xf5\xaf\x6a\x79\x34\x37\x15\xea\xe2\x18\xaa\x45\xe3\x12\xc1\x22\xb6\x22\x10\x88\x3a\xf2\xc4\x7c\xb3\xd7\x9b\x9f\xc7\x86\x59\x36\xdc\xad\x2e\x2f\x87\x88\xc0\x97\xcc\x0b\x27\x50\x29\x94\xf3\xb9\x89\xb0\x3b\xe8\xb1\xb9\xa7\x24\x6d\x61\x75\x23\xb8\xd0\xe1\x5a\xba\x17\xdd\xe1\xca\xac\xf3\x36\xf5\xb2\x81\x1e\xae\x89\x59\x8f\xdf\xa7\x9f\x42\x4f\x12\x1e\xb6\x54\x8c\xe2\x40\x13\x63\x9c\xd1\x8e\xe0\xa6\x46\x36\xf4\xf0\x5f\xc2\x4d\x8f\xcc\xad\x7a\xf0\x9e\xe5\xe3\x46\x9f\x71\xa9\xbd\xe7\xdd\x77\xf4\x97\x7f\xc0\xdc\xc6\x25\xc9\xee\xdb\xda\xe2\x65\x15\xd5\xe5\x79\x55\x09\xfe\xd0\xe6\x3b\x2a\xa7\x2d\x97\xef\x93\xcf\x5f\x7b\xc1\xaa\xdb\xdc\x1f\x95\xcc\x0f\x8e\xfa\x51\x3e\xfe\xb7\x87\xf1\xb7\x4f\x1f\xc1\x4d\x1f\x4d\xba\x7f\xbb\x7c\xa0\x47\xcf\x96\xee\xd7\xde\x77\xf1\x45\x77\xd3\x3c\xd2\xad\xda\x7c\x08\x45\x50\x11\x54\x12\xb7\x25\xce\x84\x8c\xbb\xb8\x28\x1f\x32\x6e\x5c\x52\x58\x98\x1b\x89\x84\xbd\x36\xc1\xe4\x35\x55\x54\xda\x63\x7e\xbf\x25\x3f\x10\x4a\x48\x79\xa1\x90\x00\xce\x15\xe7\xb0\x08\x79\x99\x22\xa8\x84\x51\x91\xb3\xa8\xa0\x68\x52\xd1\xec\x22\xde\xc6\x16\x15\x31\x5e\x37\x53\x3e\x31\x49\x7c\x04\x61\x09\x38\x09\xcd\x1b\x06\xc9\x37\xc5\xd2\x42\xce\xd7\xea\x95\x9c\x5a\xdf\x30\x4f\x4b\xb4\xeb\xd3\x69\x36\x78\x90\x7a\x2e\x00\x91\x34\x40\xc2\xa9\x9d\x04\x14\x35\xcd\xe6\x4b\xc1\xab\x88\xf5\x4d\x51\x9f\x2b\x0a\xd9\x8e\x7b\x3e\xfe\xf4\x15\x8c\xab\x66\x8d\xc1\x4c\x72\x5e\xfd\x6f\x4f\xbe\x20\x1f\x99\x3f\x7f\x3e\xdb\x8b\x95\xcf\xc7\xf7\xb4\x5d\xd5\x22\x3f\x88\x47\x26\xae\xbc\x8b\x6b\xc2\xf6\x1b\xae\xbd\x3c\x56\x77\xf9\x75\xb7\xc9\x45\xcc\x8f\x97\x8f\x28\x2b\x1b\xf1\x58\x3c\x8e\x17\x96\xd3\xe7\x74\xa1\xee\xaf\xe7\x66\x80\x1e\xf8\x51\x2e\xc4\xcc\xd9\x89\xb2\x02\x57\xbe\xcf\xce\xb2\x39\x16\x8e\x43\x01\x13\x32\xc5\x0a\x7d\x79\x93\x93\x3e\xb7\xcf\x0d\x35\x69\x68\x52\xd2\x02\xee\xc7\x6e\xb1\xd0\x92\xd9\x95\xb4\x70\x39\xf9\x7c\x3e\x24\x72\x1e\x06\x4a\x67\x46\xdd\x1e\xd0\xb0\x58\xa8\x47\x85\xca\xec\x53\x8e\xe9\x21\x96\xc5\x82\xe8\x8b\x35\x94\x30\x2e\xa7\x9b\x3c\x18\x94\x4f\x8e\x21\x29\x75\x45\x79\x27\x39\xe4\x18\xbb\x1a\x9b\x1a\xb8\x19\x6f\x1d\xdd\x78\xe4\x9b\xcf\xfe\xb1\x71\xcd\xcb\x8d\xf2\x0f\x15\xe7\xe0\xad\x29\xcf\x5d\x23\x06\xe0\x96\x91\x43\x9e\xd8\xe1\x7f\xe6\xb9\x22\x3c\x13\x97\xe2\x9e\xf8\xec\xc8\xe5\x97\xd9\xb7\xef\x6c\xbc\xa3\x48\x5e\xd2\x57\xde\x78\x2e\x7b\x7e\xf9\x07\xf2\x2e\xf9\x35\x6b\xaf\x6f\xc9\xd3\x51\xaa\xec\x03\xb4\xe2\xba\x22\x11\xf5\x33\x5e\xaf\x2f\xcc\x49\xa2\xe8\xca\x09\xe5\x71\x18\x99\x6c\x6e\x9f\x2f\xea\xb0\xd8\x6c\x85\x7a\x89\x25\x25\x83\x96\x40\xd8\xac\xa6\x55\xee\x64\xae\xc8\x06\x20\x1c\xc2\x0f\x1e\xaa\xab\x08\x9f\x55\x5d\x29\xa1\xc1\x18\x22\xa8\x11\xb8\x33\x4e\xad\xf1\x40\x88\x8b\x7a\xe0\x2f\x48\x19\x84\xec\x21\x29\x5a\xd4\x13\x6b\x28\x87\xda\xa9\x29\x5e\x52\x2a\x3c\xd2\xff\x07\x5c\x7c\x07\x1e\x73\x3b\x2e\xfe\xa1\xdf\xa3\xf3\xe6\xc9\x1f\x4c\x95\x4f\x9b\x2a\x1f\xb9\xf4\x52\xfc\x04\x1e\xd7\xf3\xeb\xda\x1b\x7a\x49\x2e\xc6\xf4\xda\x26\xfc\x92\xdc\xbc\xe9\xb5\x4d\xf2\x7a\x3c\x89\x7c\xe0\xeb\x67\xb5\xe3\x21\x86\x20\xc8\x0b\x0e\x43\x5e\x50\x8b\x56\x24\xf2\xf3\x73\x72\x02\x79\x66\x73\xa0\x2c\x58\xcb\x17\x16\xd6\x60\x18\x6f\x4d\x4d\x30\xc0\xd6\x75\x33\xe5\x84\x72\xe8\xf4\x15\x1f\x62\xf2\x23\xf9\x64\x84\xe1\x64\x6d\xc4\xe9\x0d\x95\x46\x2a\x43\x91\x50\xc4\x5b\x59\x59\x3c\x25\x59\xc9\x79\x6d\x93\x93\x5e\x5d\xb4\xfa\x0c\x8f\x72\x76\x71\x46\x94\x0f\x64\x9c\xf8\x64\x38\x73\x93\x28\xb3\x1a\xcb\xa9\xa3\xe4\x05\x2e\x56\x50\xa4\x44\x7b\x72\x3e\x68\x23\x2d\xc1\xc5\x62\xe2\x8e\x39\x9f\xc8\x1d\xde\x14\x5f\x73\x16\x7e\xfa\xe4\xa3\x9e\xc5\xcb\x17\xaf\x0a\xe0\xbc\x0a\xf9\xfd\x6f\xe5\x36\xf9\x43\xf6\xf4\xdb\x46\xbd\x2a\x9f\xcd\xf6\xb5\xcf\xba\xf0\xe9\x2a\xf9\xb3\xe2\x93\x9f\xfe\x13\x4c\x93\xdd\xbe\x29\x31\x24\x67\x53\x41\x69\x72\xe4\xc5\x13\x8a\x9f\x7e\xf1\xc3\x67\x1b\x37\x9d\x9f\xd8\x14\x2a\x1a\x3c\x74\x4f\xde\xbe\xbf\x1e\xda\x56\x0d\x3e\x8f\xe8\xfa\x1a\xba\x1e\x1e\x02\x4d\xaf\xf0\xdb\x4d\x5e\x6f\x90\xf7\xf9\xcc\xac\x8b\x75\x85\x73\x05\xde\x87\x12\x1e\xdf\x94\xa4\xc7\x63\xcb\xe1\x73\x26\x25\x9d\x16\xa7\x05\x99\x78\x72\x2c\x2b\xa9\xb6\x79\x0e\x05\x27\x25\x91\x1d\x3e\x84\x19\x9a\xa2\xbb\x55\xf5\xa6\x2a\x4f\x5d\xa1\xf3\xb0\xfe\x78\x72\xfa\x44\x6f\x9e\x28\x39\x79\x38\x8d\xf3\x10\x15\xa7\x33\x7c\x90\x31\x83\xa2\x0b\x4c\xdd\xbf\x7e\xc5\x9f\x6e\xc4\xdd\x2f\x96\x8f\x57\x9d\x3f\xbb\x37\x76\x5d\x21\x3f\xb3\x71\xe7\xce\x9d\xf6\x5c\x3c\x11\xf7\x66\x2e\x8f\x2f\x58\x50\x26\x6f\x3a\x75\x7d\xed\xc9\xab\x2b\x9e\xe9\x2e\x2f\x2d\x79\x86\x5d\x20\xdf\x32\x94\x5d\x34\x90\x3e\x93\x35\x8e\x73\x33\x73\x44\xab\x53\x44\x36\x79\x09\x3e\x85\xfa\x3a\xd4\xfe\x13\xe8\xc0\x30\x64\x46\x5e\x54\x83\xea\xd1\xa6\xc4\x79\xe5\x65\x65\xe1\xdc\x5c\x5f\x6d\x5d\xb7\xfa\xba\xfa\x42\x04\x19\xb0\x05\x15\xa2\x78\xf7\x6e\x42\x6d\x30\x11\xc6\x28\xec\x0c\x17\x84\x27\x85\xdf\x08\xf3\x16\x36\x1c\x8e\x44\x82\xbb\x93\x8e\x48\x24\xd2\x12\x61\x2d\x6c\xa4\xb8\xb8\x1a\x7e\x2d\x8f\x94\xd7\x96\xc3\xaf\xe5\xe5\xc5\xa2\x64\xdb\x9d\x44\x92\x53\xaa\x93\xa0\x41\x62\x59\xf7\xee\x24\x9b\xa3\xce\xf7\x12\x07\xa8\xe7\x85\x5a\x03\xad\xa1\x49\x72\xa8\xaf\x0a\x29\xa9\xa0\x7a\xa2\xad\x96\x8e\xe8\x0b\xf9\x05\xac\x33\x56\xa8\x9c\x84\x8c\x15\xad\x09\x28\x07\xd6\x6b\x15\x1d\x13\x2b\x24\x6b\xa9\xdc\xe1\x95\x4b\x96\xdc\x70\xed\xf5\xd8\xbc\x69\xca\xb4\x86\xda\xda\x86\x93\xd7\x34\x77\x2b\x29\x32\x6f\xb0\x2f\x9d\xbc\xe2\x96\x9b\x57\x4c\x5c\xe4\xfd\x8b\xc5\x9d\xeb\xbb\xe0\xe1\x1b\x99\xfd\x2b\xf0\x9a\x57\xde\x7b\xef\x95\xb7\xdf\x92\xc7\xe2\x42\xf9\xe3\x9b\x57\xdd\xc9\x3c\x78\xeb\xaa\x11\xe7\x48\xcb\xfe\xf2\xc9\x0b\xaf\xbe\xbf\xea\x5a\xcb\xb0\xee\x39\x6d\x0d\xe0\x29\x18\x74\x2f\xd8\x91\x87\xbf\x1d\x72\xc5\x42\x74\x5e\xa2\x9e\xe5\x38\x6f\x48\x2a\x08\x06\x6d\x16\xc9\x2b\x15\xc5\x6c\xd6\x02\x8b\x75\x58\xd2\x1c\xb0\x58\x02\x05\x81\x61\x49\xb6\x80\x2d\x10\x5c\xae\xbc\xb3\x93\x2e\x51\x40\xc3\x93\x82\x3f\xcb\x64\x14\x0e\xb8\x9b\x69\x83\x3e\xeb\xa2\xac\x71\x04\xc9\xf4\x40\x31\x79\xb8\x96\x89\x92\x57\x42\xc4\x86\x26\x7a\x30\x39\x44\x4d\x46\xf4\x79\x69\x84\xf4\xb9\xfa\x62\xe6\x89\x61\xa3\x02\xab\x46\xca\xbb\x36\xdf\xbf\x7c\xf9\x5b\xfb\x37\x3e\xf9\xfb\x67\xdf\x35\x36\x5f\x36\x73\xd1\xf3\x33\x2f\x94\x47\x6e\xfc\xcb\xc3\x75\xcf\xd7\xe1\xeb\x76\x3e\x75\xcf\xca\x67\xe5\x2f\xce\x7a\x65\x37\x7b\xdb\x80\x91\x6b\xe4\xc7\x2b\x77\x80\x4e\xf8\x41\x31\x9e\xa0\x75\x7b\x10\xe2\x5f\x19\x9a\x9a\x88\x97\x44\xbc\x5e\x5b\x8e\x0d\x59\xad\x42\x05\xd1\xf4\x9c\x52\x87\xe0\x28\xaf\xf0\xe7\xee\x4e\xba\x0b\x77\x27\xfd\x6e\xbf\xbb\x44\xc2\x82\x55\x64\x8b\x4b\x76\x27\x8b\x8b\x91\x40\xca\x75\x48\xfc\x89\x74\xdd\x24\xb7\x6c\xa6\x39\x97\xf1\xb0\x37\x65\xbd\xdb\xad\xcc\xf7\x46\xd9\x80\x7a\xc6\x3f\x3d\x63\x9a\x4a\xd7\xe5\x84\x71\x89\xc6\xd5\x6d\xb2\x59\xed\x23\x27\x58\x76\xfd\xb3\x98\x31\x6d\x60\x06\x2d\x5c\xf6\xf3\xef\x4b\x16\x6c\x2e\x2e\x29\x2f\x8d\x15\x57\x97\xc8\xef\xe3\x1d\xec\xf2\x31\xcd\x17\xa7\x16\xf1\x03\x4e\xce\x5b\x3f\x97\x59\x74\xe2\x49\x66\xfb\x1b\x7b\x20\xd5\xbf\xee\xc9\x83\x37\x5c\xbe\xe0\xa6\x15\x57\x5e\x99\xfa\xfb\xbd\xf7\x52\xdd\x8f\xa0\x12\x6e\x0b\xd8\xb9\x03\xec\xbc\x10\xb4\x7f\x7c\xa2\x3e\x06\x25\x9f\x3b\x10\x76\x87\x51\x39\xc4\xb4\xba\x5a\x67\xe4\xe5\x64\xbe\xe7\x65\x52\xe4\x49\xac\xdb\x99\x9f\xef\x74\xb3\x9c\x95\xab\x7a\x39\xc9\x59\xad\x25\x2f\x27\xad\xa8\xc3\xca\x05\x51\xe1\x8c\x63\x88\xa8\xda\x12\x85\x65\x38\x28\x5f\xc8\xe2\x05\xd4\x2d\x9c\x1b\xeb\x53\x13\x31\x4f\x77\x3a\x2f\xd1\xc8\xab\x47\x0e\xbb\x21\x6f\xe4\xb6\xac\x94\x7f\xdf\xfe\xb8\xfc\xfb\x6d\x2b\xb1\xf4\xf8\xe3\x58\x5a\x99\x1a\x7c\x27\x8e\xaf\xbc\xf3\x2f\x4b\x57\x3e\xbe\xe8\xba\x61\x23\xb1\xfd\xd8\x07\xef\x1d\x3b\xfe\xee\x91\xe3\xcc\xef\x5f\xc8\xfb\x36\x3f\x82\xfb\x7f\xf9\x19\x3e\xed\xd1\x47\xe4\x27\xe5\xe7\xe5\x3d\x6c\xcb\xd5\xb3\x66\xaf\xc5\xe2\x62\xf9\xeb\xb3\xa6\xe2\x02\xdc\x22\xff\x4d\xfe\x54\xfe\x48\x7e\x1e\xf7\xa1\xcf\x99\xb3\x83\xb9\xdd\xfc\x41\x24\x42\x3c\x9f\x92\x68\xf0\xb8\x4d\xa6\xa0\x2d\x14\x08\x04\x83\x8c\xcd\x62\xb7\xdb\x44\xb2\x6c\x67\x63\xf2\xf3\xc8\x09\x7e\xaf\x24\x4d\x76\x4f\x90\x2b\x60\x12\xcc\x30\x88\x71\x4e\x9f\x25\xc7\xc7\x42\x0e\xdf\x42\x4a\xb5\x03\xe3\x03\xf5\x86\x59\x6e\xcd\x9b\xab\xd5\x84\x2a\x5e\x32\x58\xb2\xb8\x89\xfb\x62\x48\x5e\x62\xae\x26\x52\xfd\x97\x06\x88\xc0\x3d\x7e\xdc\x6b\xdd\x7d\xf8\x23\xbc\x8c\x09\x5e\xbb\x67\x05\x1b\xba\x7e\xf2\xf5\x21\x76\xc5\x9e\x95\x76\x7e\xa0\xcc\xe2\xd4\xf2\xe5\xf2\x61\xe7\x59\x38\x99\x5a\x8c\x27\x8f\x19\x23\xdf\x8f\x27\x8f\x1e\x2d\xdf\xcf\x5c\x23\xdf\x5c\x04\x31\xac\x9e\xee\x33\x40\xf6\x25\x3e\x3b\x51\x29\x5a\x83\x79\x9c\x5f\x62\xed\xd1\xb0\xdf\xee\x2f\x2a\xce\x47\x02\x54\x3c\x4e\x56\x10\x24\xb7\x1b\x4d\x4c\xba\xb9\xb0\x64\x92\x26\x26\xf3\x4c\x6e\xf5\xa9\x2d\x7d\x65\x98\x24\x60\x86\xa7\x84\x21\x14\x93\x97\x8a\xe8\xfc\x1a\x54\x39\x90\xe7\x17\xb9\xba\xbb\x89\x9d\xb9\x7d\x4e\xbe\xb1\x17\xf6\x45\xc1\xc8\x20\x18\x31\xd3\x16\xae\x1c\x3d\x53\x76\xcd\x4b\x5c\x22\x1f\x5f\xd9\xb6\xf6\xae\x93\x2b\xe5\xe3\x73\x13\xb3\x65\xd7\xcc\xd1\x2b\xb9\x05\xaf\xed\xb9\xee\xb5\x4b\xe4\x37\xbe\xb0\x1c\xc1\x17\x6d\xc6\xfc\xca\x95\xf2\x89\x4d\xf2\x9a\x23\x96\x2f\x70\xdd\x25\x87\xae\xdf\xf3\x1a\x7d\xc6\x6c\x42\xfb\x27\xdc\x32\x6e\x10\x58\x5b\x04\x9d\x9b\x08\xe6\xf9\xac\xb9\x76\x3b\x68\x59\xb4\x00\x79\x9d\x5e\x46\x62\xc1\xf6\x5c\xb9\xb6\xbd\x18\x3c\x69\x6e\xae\xcb\x64\x82\x70\x6c\xdb\x99\x34\x39\x91\x8b\xbe\x38\x86\x8c\x0e\x84\x2e\x72\xab\x23\x32\xcc\x37\x92\x57\xc9\x0a\x4b\xc8\x91\xce\x98\x0e\x22\xea\xd2\x6a\x6a\x86\x2d\x24\x25\x68\x09\x33\xf7\xbe\x1f\x97\x2f\xff\xfd\xce\xbb\x7e\x5c\x91\xc2\x55\x57\x0d\x58\xb4\xed\xcc\xe9\x83\x96\x6f\xbc\xe8\x86\xa9\xf8\xa3\x19\xd1\xd5\x98\xbd\xef\x21\x79\xd5\x2a\xf9\xe7\x47\xe5\xcd\x85\xb5\x17\x5d\xd9\x67\xce\x65\x7d\xd9\xe3\x43\xe4\x5f\xb0\xe9\x2c\xb0\x25\x2b\xf8\xc0\xbf\x81\xcf\x28\x43\x55\xa8\x3b\x6a\x42\x0b\x13\x2d\xe5\x61\x1b\x6a\x04\x37\x5b\x59\xd9\xd4\xbd\x06\x58\x59\xe3\xeb\x86\x50\xb7\xe6\x1e\xb6\x42\x36\x58\xdd\x2d\x37\x12\x8c\xec\x4e\x36\xd6\xee\x4e\x76\x0b\x36\x36\x06\xbb\xb1\x95\x0d\xf5\x6c\x15\x5b\xe9\x16\xcd\xac\x79\xb7\xb2\x83\x34\x15\x50\x8b\x96\x38\x55\x2a\x29\x44\x7a\x22\x55\x4b\x8d\xb5\x25\x60\xba\xa4\x5f\x9c\x39\xb9\x57\x83\x4b\x3b\x99\xdb\x0b\xe4\x63\x16\xc7\x24\xc8\xa4\xc4\x98\x27\xee\xc1\x6c\x9c\xfb\xdb\xcd\x4b\x16\x2f\xf5\xae\x35\x37\xf4\xe9\x15\x2f\x1c\x68\x59\x38\xa2\x7a\xe9\x55\x17\x2d\x75\xdd\x23\x36\x94\xd5\x75\x73\xe5\x4f\xba\x72\xf2\xce\xd4\xad\x63\x98\xd9\xb2\x54\xf7\x64\xdd\x1d\x6f\x6c\x7c\x4d\xfe\xb8\xff\x0d\x6f\xce\xbc\x62\xca\xd4\xdc\xc6\xaa\x8a\x8a\x82\x72\x1f\x1b\xed\x31\xaa\xd7\x05\xf3\xa7\x4d\xf2\x34\x16\x15\x56\x04\x72\xbd\xb9\xd1\x59\x5c\xf8\xc4\x93\xfc\x80\x94\x7f\xff\x7e\xe6\x9b\x94\x9f\x19\x28\x7f\x0f\x3a\xbb\x15\x74\x36\x8f\xeb\x89\x24\x54\x9f\xc8\x11\x59\x96\x3c\x9e\x88\x2d\x66\x81\x1f\x91\x14\x04\x6c\x72\x60\x66\x44\x12\xfb\xf4\x2a\x41\xab\x98\x94\xd9\x83\x72\x70\x82\x0d\xf4\x40\x33\x2e\xef\x64\x2b\x33\x2a\xf5\x36\x53\x8d\x43\x07\x3f\x39\x88\x5f\x20\xeb\xb5\xdd\xda\xbf\xe7\x21\x2a\x39\x4b\x4d\xdf\xc8\xdf\xd1\xe7\x5c\x7e\x38\x4e\xf6\xdb\xfb\x0e\x3f\x96\xda\x49\xe6\x85\xdc\x39\xca\xbc\x10\xc0\xf6\xa5\xb0\x67\x03\xec\xb7\x9d\xc3\x16\xa5\x61\x71\xfb\xaf\xdc\xf3\xfc\x00\x37\xc1\xfb\x94\x02\xbb\x87\xc0\x1e\xc7\x3d\x53\x7b\x50\x5d\x22\x97\x63\x99\xf2\x20\xfc\x70\x94\xe3\x72\x7c\xbf\x05\xdf\x6a\xc1\x16\x34\x09\xe1\x61\x30\x60\xd7\xf8\xf1\x0d\xca\x87\xbc\xaa\xd0\xa2\xbe\xaf\xd0\xfe\x3e\xe0\xfc\x96\x3f\x1b\x70\x7e\x27\xaf\x56\x70\x9e\x54\x70\x4e\x01\x9c\xc1\x84\x0d\xd0\x0d\x0c\xa2\x59\xe4\x79\x2b\x05\x49\xfa\xde\xef\xe9\xbd\x84\x9e\x1f\xe4\x75\x5d\xdc\xdb\xab\xf3\x7b\x91\xa8\x8f\xe5\x98\xfc\x92\x72\xef\x7d\xe9\xb1\xf4\x4e\x14\xc3\xbd\x95\x74\x2c\x95\x50\x59\xdd\x6f\xc3\xb7\xda\xf0\x44\x1b\x1e\x6a\xc3\x2d\x36\x5c\x6b\xc3\x36\x34\x9b\xe2\x24\x63\x22\x7f\xb2\xc6\x85\x16\x82\x2d\x4c\xe4\xce\x72\x0b\x8c\x8f\xce\x21\x99\xd0\x79\xdc\x01\xa6\x3f\x7d\xde\x00\x32\x45\x5e\x62\x18\xde\xca\x3b\xec\x2c\x4a\x58\xd0\x5e\xcc\x6c\x4f\x9a\x2c\xa8\xf6\xb0\x92\x14\x1a\x27\x0e\xa1\x08\xf0\x07\x62\x25\xa5\x0d\x8d\x64\x66\x21\xea\xfb\xaa\xb9\xef\xa0\xc5\xb7\xde\xba\x78\x50\xdf\x66\xf6\x23\x5c\xde\x6f\xe9\xed\xa7\x17\x9d\x7e\xfb\xd2\x7e\xe7\x28\xcf\x1c\xcc\x6f\x7f\x9e\x3d\x87\x5b\x0c\xfd\x94\x24\x5c\x92\xd5\xca\xd8\x6c\x0e\xbb\x15\x59\xa4\x59\x0c\x66\x78\x54\x7b\x60\x3c\x39\x81\xdf\xf8\xa0\xaa\x20\x12\xd4\xfe\x80\x0f\x32\xcd\x18\xd3\x2b\x8d\x90\x5d\x9f\xee\xea\x64\xac\xe3\x18\x04\x46\x92\x04\xc1\xea\xb0\x4b\xd6\x04\x59\x16\x85\x31\x30\x36\x54\xfb\x1a\x1d\xc3\x6b\x99\x63\xc0\x25\xa5\xa4\x0b\x3a\x8f\x12\x6d\x60\xbf\x34\x62\xc6\x8b\x33\x06\x91\x35\x06\x08\x53\x92\xc5\x42\xc7\xc0\x4c\x92\xb0\x24\x74\x32\x86\xe2\xc6\x26\x82\x1a\x98\x04\x9e\x3a\xce\xb4\xa6\xf1\x3d\x60\xe4\x96\x51\x0e\x01\x74\x6a\x22\xa4\xc9\xc1\x6d\xf7\x41\xc9\xea\x0e\xe6\xd8\x4d\x16\x1f\xa3\x4a\xe4\xaf\x49\x10\x88\x22\x8f\x7a\xf8\x97\xf1\x7c\x67\x67\x92\x31\x8c\xd0\x20\x23\x46\x4e\x7f\x37\x48\x4b\xff\x62\x1c\x6f\x00\xf4\x2e\xcf\x61\x32\x59\xad\x01\x2f\xc3\x04\x02\x39\x41\x6b\xc0\x3e\xc9\x87\x7d\x6e\x0b\xd2\xe4\x77\x88\x8e\x9d\xfe\xd4\x5e\x10\xd6\x0b\x27\xa3\x24\x0d\x1c\x31\xc8\x54\xff\x62\x94\x6d\x8a\x49\x7f\x27\xb1\x08\xe8\x19\x44\xe9\x61\xa1\xfe\x1d\x9d\xc8\x15\x50\x4e\x4e\xd8\x86\xdd\x6e\xa7\x33\x1c\xce\xcb\x75\x86\xdd\x28\x07\x3b\xd8\x1c\x7f\x02\xb1\xc0\xa7\x84\x35\x89\x90\xdf\xc1\xd9\x66\x09\x58\x90\x34\x0a\xe3\x0a\xeb\x0e\x41\x04\xca\x20\x55\x0f\x44\xe4\x1c\xc6\x2e\x08\xc6\xf3\xf1\xa7\x72\xc1\x0b\x1d\xa9\x9e\x31\x8c\x1b\xd3\x35\xdd\xe8\xcc\xf6\x2f\xb9\x39\xfc\x0b\x10\x41\xab\xd0\x59\x89\xd2\x10\x92\x0a\xbc\xa5\x92\x97\xac\x05\xd6\x14\xc4\xec\x31\x48\xb6\xed\x76\x21\x2f\x14\xca\xcb\x83\x14\x3c\x0f\x09\x15\xc3\x0c\x89\x37\xc9\xb7\x5d\xda\x91\xc4\x19\xab\x74\x44\x7f\xbd\x66\xac\x16\x14\xe4\x59\x04\x7f\x20\xae\x54\xa1\x82\xd8\x04\x61\xc5\x8d\x49\x54\xb1\x63\x9a\xa1\xba\xb9\x39\x3d\x2f\x5d\xff\xda\x95\xcf\xbc\x7e\xf6\x4d\xfb\xe6\x4e\x5f\x5f\x2c\x88\xb7\xaf\xe9\x77\x47\xf7\xea\x39\xf7\xfd\xf3\x57\xf9\x1b\xcf\xc2\xb3\x92\xab\xc7\x4d\x3c\xe7\x9a\x57\xd8\xcd\x4b\xe4\x97\x65\x79\xeb\xb8\x83\x4f\xcc\xff\x75\xe7\xe4\xb1\x83\xcf\x0c\x3d\xfc\xd7\xfa\x92\x37\x4e\x97\xbf\x49\x7d\x3d\x78\xf2\xe5\x5f\xcf\x1b\x77\x01\x84\x00\x86\xce\x45\x3d\x05\x71\x95\xa7\x6f\x9c\xd8\x19\x72\xb8\xa9\x1d\x09\x2c\x62\x1d\x4e\xf3\xde\xf6\x37\x12\x1e\xc9\x31\xc8\xcc\x61\x70\x26\x02\x27\x4c\x4a\x42\x89\xa7\xac\xe5\xaa\x8b\x36\x6e\xc3\xe3\x15\x6a\x2e\xd6\x84\xa3\x90\xbe\x14\xb3\x25\xb5\x30\x2c\x91\x75\xe3\xc7\x70\x12\x3f\xd4\x76\x0e\xbb\xfc\x93\xaa\x90\x84\x9b\x02\x47\x3f\xe3\xa6\xb6\xad\xfb\xec\x27\x66\xe6\x8d\x0b\x4b\xcd\xef\x9f\x9e\xba\x4b\x99\x0b\x9f\x21\x37\x73\x53\x81\x16\x11\x15\x26\x9c\x2c\x87\x44\x4e\x34\x49\x3c\x33\x29\xc9\xc3\x2f\xa8\xb6\xbe\xa5\xd2\xf8\xa2\xb9\xf6\x00\xf4\xe9\xf2\x69\xf2\x11\xb6\x4d\x6e\x16\x82\xbf\x7f\x2d\x5a\x7f\xfb\x89\xe2\xf2\x03\xae\x67\x01\x97\x05\xf2\xb6\x52\x13\xc3\x98\x31\x79\x95\x02\x0b\x66\x6c\xb6\xda\x58\x96\x03\xdc\x13\x93\xd0\x2e\x71\x2c\xc6\x20\x45\xc8\xda\x10\xd2\x52\x9b\x16\x65\x42\x41\x7f\x55\x5e\x9f\xbb\x55\xd6\x0b\x3c\x0d\x12\xa9\x14\xa2\x12\x8e\xfa\xfc\xcc\x84\xd4\x6e\x6e\x3c\xc4\x5e\x67\xea\x28\xdb\x24\x37\xaf\x67\xbe\x61\xbe\xb9\xeb\xf3\xd4\xf9\xa9\x73\xbe\x00\x3a\xce\x67\x9a\xb9\x19\x50\x8f\x1a\xde\x2f\xd9\x92\xc4\x3b\x32\xdf\x2f\x39\x1f\x62\x41\xf3\xa7\x9f\x12\xdf\xae\x3e\xc3\xe8\x14\xc4\x1f\xa8\xbf\x7a\x17\x6f\x60\x7e\x61\xde\x82\xfb\xcb\x13\x21\xfa\x0e\x05\x79\x3a\xbc\x16\xb5\x40\xe8\x59\x8c\x6e\x05\xb9\x25\x3c\x81\x41\x84\xf4\xf1\xe9\x87\x5d\xc9\x93\x86\xef\x42\x4e\xbe\x41\x79\x12\x9c\xf0\xa3\x77\xfb\x57\xdc\x83\xc2\x48\xf0\x51\xb5\x09\x3f\x46\x82\x60\xe2\x19\xd1\xc4\x98\x24\x33\xcf\x6c\x49\xf2\x3c\x54\x8a\xe4\x39\x31\x3d\x1b\x48\x8b\x93\x8f\x61\x32\x51\x84\xe3\xcc\x23\x9b\xe4\x1f\xf7\xe2\xa6\x0f\xf1\xbd\xfb\x72\x98\x1f\x1f\x4e\x5d\x0b\x75\x3d\x99\xbb\xf3\xa0\x03\xdc\x3e\xf6\x7d\xa8\x4f\x8b\x50\x1d\x9a\x9c\x68\xae\xb4\x79\x84\x42\x84\x04\x1b\xdb\xad\x3e\x54\xe6\x2c\xdb\x92\xcc\x2d\x16\x8a\x3d\xac\x39\xd0\xe2\xc4\x0e\xe7\x2c\xe7\xad\x4e\xa8\xd4\x9d\x91\x1a\x73\xcd\x96\x24\xdb\x62\x1e\x6a\x66\xcc\x09\x29\x38\xc8\x0c\xc3\x98\x13\x4f\x17\xe8\xca\x8c\x55\xd6\xf3\x12\x5a\x69\x5e\x6a\x67\xd2\x45\x38\x35\x9c\xe2\x42\x51\x5b\x72\x4d\x3f\xba\x55\xdf\xc8\xed\x5b\xbf\x74\xf2\x8d\x03\x7b\x8c\x3a\xbf\xcf\xb5\xf7\xdf\x7f\xed\xb8\x9b\x06\xf5\x1c\x31\xb1\xe7\x6d\xf7\xc9\x2f\x4e\x9b\x56\x3b\xa1\x6f\xcf\x7e\xfd\xe4\x09\x3d\x47\xd5\xf7\x3e\x7d\x50\xdf\xf8\x58\x66\xe0\xa6\x0f\x67\xdf\x30\x65\x5c\xb7\x37\x77\x3f\xfa\xfe\x65\x2b\x2f\x98\x58\xff\x76\xc9\x91\xf3\x2f\x5d\x38\x69\xda\xa5\xaf\x2f\x39\xf7\xaa\xf1\x53\xe7\x5d\x44\xf9\xd9\x1d\x44\x71\x17\xf7\x12\xf0\x3f\x6f\x0f\xc3\xf3\x2c\x79\x73\x6f\x2f\xe6\xb6\x27\x79\xf2\x72\x97\xc6\x44\x65\x2a\xd5\x17\xed\x3e\x81\x13\xda\xee\xe5\x5e\x6a\xbb\x93\x3c\x43\x72\x6f\xbb\xcc\xd5\x71\x26\xe0\x5b\x61\x42\xf2\x90\xa9\x11\x8b\x8f\x77\xc0\xdd\x3b\x92\xbc\x45\x79\x5c\x8f\xbe\x06\x4b\x11\x04\x94\xe3\x4a\xe8\xda\x9e\xf6\xb4\xde\xbd\xf3\xde\x5c\xba\xec\xed\x05\xd3\x0f\xac\x7f\xe0\x59\x86\x41\x77\x1c\xbb\x76\xf9\x8f\x6b\x64\xc4\x30\xcf\x7c\xf1\xd9\x73\x32\xa5\xef\x25\xd0\x7f\x81\xff\x1c\xfc\x7e\x49\xc2\xed\xf0\xf9\x38\xa8\xbf\x72\xac\xae\xe1\x50\x51\x0a\xc3\xa9\xaa\xa3\xf4\xe3\xaa\x94\xa9\x85\x25\xca\x9c\xb8\xcb\x78\x7e\x8b\x57\xc0\x53\x2a\xc7\x79\x4f\x6d\xb8\xe7\x9d\x67\xc6\xf4\xab\x1f\x70\xe6\xb0\xb7\xe5\x66\xbb\x78\x24\xe7\x05\x6e\xf5\xce\x57\x3c\x1f\xe6\x9c\x3f\xa1\xed\xc2\xdd\x2f\x29\xef\xb2\x4c\xc4\x6e\xee\x62\xae\x09\xf9\xc0\x47\xee\x4b\xe4\x45\xa4\x0a\x8f\xe4\xa9\xae\xf1\x97\x3e\x9e\xcc\x47\x7e\x3c\xdb\xbf\xc4\x7f\x9b\x1f\x0c\x01\x4a\x5d\x3f\x7d\x8e\xc8\x99\x3b\xc8\xef\x2f\x8f\x46\xc3\x8f\x27\x87\x46\xb1\x23\x5a\x1b\x6d\x89\x4e\x8c\xde\x1a\xbd\x3f\xba\x2d\xfa\x49\xb4\x3d\x2a\x39\xd8\x28\x72\x3e\x9e\x34\xc1\x88\x66\xa3\x25\xe8\x36\x32\x81\x0a\x77\x23\x72\x77\x21\xdc\x8d\x90\xdb\x62\xe1\x1f\x4f\x3a\x2c\xf8\x98\x05\xbf\x61\xc1\x0e\x4b\xc4\xd2\x62\x59\x6c\xb9\xd5\x72\xbf\x45\xb0\x90\x57\x33\xc6\xcf\xa1\x9e\x0a\x06\x4b\x34\x6a\x2e\x59\x27\xa4\xba\x95\xd5\x6a\xf4\x2c\xc0\x09\xea\x7e\x1b\xa8\x6a\xd1\xfd\x31\xec\x98\xcd\x6c\x25\x8a\x46\x9b\xa7\x9c\xd1\x7a\xc6\xf2\x64\xbf\xf9\xa7\x5d\xb2\xa1\xe1\xca\x95\x97\x0f\xbd\x6e\x6e\xcb\xc2\x91\xd0\x76\xcd\xb8\x81\x0b\x4e\x99\x73\xdf\x88\xf5\x43\xa6\x9d\x96\x7b\xdd\xdc\xc4\x65\xcc\x4f\xe5\xa1\xda\xd2\x6e\x7f\x1f\x99\x53\x57\x39\xee\xc3\xea\x98\x9c\x5f\x15\xaa\xae\xac\xfe\xfb\xc8\x9a\x50\x81\x6d\xdc\x87\x55\x45\x54\x6e\x63\x51\x31\x37\x97\xaf\x04\xdd\xb8\x38\x31\x90\x33\x79\x1c\x26\x87\xd7\xe7\x34\x49\xa6\x2d\x49\x1b\xe4\x2a\x48\x1a\x26\xcd\x06\x06\x48\x05\x52\x9d\xb4\x44\x5a\x2f\x3d\x2e\x1d\x97\x44\x0b\x2b\xb9\x78\x8e\x07\xc7\x82\xd1\x44\x6e\x16\xf7\x09\xc7\x3a\xb8\x08\xd7\x02\x5f\x6f\x85\xf2\x1a\xd8\x30\x87\xcc\x95\xa4\xed\xaa\xd6\x95\x19\x89\xc8\x8b\x7b\x31\x65\x3e\x18\x3e\x71\x36\xee\x8b\xb2\x51\x1f\x83\xaf\xf9\xfb\x35\x6f\xe2\x3e\x0f\xcb\x79\xcc\xb0\x6b\xdf\x5e\xf6\xa3\xbc\xe1\x61\x86\xc7\x31\x59\xfe\x08\x0f\xfe\x84\x3c\x24\xfe\x89\xbc\xfb\x23\x65\xfe\x7e\x1e\xfa\x89\x1b\xcd\x0d\x53\x9f\xa1\x4e\x26\xac\x26\x0e\x59\x44\x06\x31\x56\x9b\x64\xda\x8b\xd1\xee\x24\x79\x7f\x92\xe3\xe1\xeb\x8e\x24\x87\x21\x09\x42\x09\x5f\x72\x16\xbe\x1f\x6f\xc3\xaf\xe3\x63\x98\x1f\x86\xb1\x03\x47\x30\x83\xa9\xd0\x54\xed\xd4\x9f\xa9\xd6\x5f\xae\xa5\xe7\x09\xa9\x9f\x79\xec\xe7\x27\xf3\x94\x0f\xfb\xd4\x9a\x35\xa9\x1e\x6b\xd6\xe0\xf3\xd6\xac\xa1\xba\x48\x9e\x67\x1b\xcf\xbb\xe9\xf3\xbd\x67\x25\x6a\x80\x1a\x89\x11\x90\x60\xb1\x8a\xc0\x49\x31\x88\xe9\x03\xc3\x0e\x21\x22\x2c\x16\x6e\x85\xc0\xc6\xd6\x31\x09\x66\x12\xc3\x3a\x98\x08\x03\x16\x05\x24\xc4\x6b\xc7\x83\x09\xf6\xa9\x8d\xc7\xd3\xa7\x3e\xab\x24\xb8\xb0\x4f\xc2\x94\x82\xb1\x1c\x73\xf2\x59\x36\xd1\x26\x73\x88\x59\x80\x4f\xc1\xe7\x7e\x2e\x7f\x2d\xff\xeb\x73\xf9\xf3\x4f\x3e\x01\x1a\x66\x01\x0d\x73\x54\x1a\x86\x24\xaa\xb3\x69\x10\x78\x86\x61\xeb\xb8\x04\x37\x49\x11\x17\xc3\x41\x2d\x11\xa1\x5e\x9d\x84\xbb\xf1\xf5\x84\x8a\xce\x29\x20\x01\x08\xbb\x08\x05\xb3\xd8\xc4\xc9\x67\x81\x0a\xb8\x05\xe7\x7d\x8e\x03\x38\xf8\xb9\xfc\xb0\xbc\x3f\x75\xc3\x27\x9f\x28\xef\x97\x01\x0d\xa7\x72\xbd\xe0\xb2\x84\x9a\x12\x2e\x9e\xbc\x4c\xca\x99\x2d\x0e\x53\xc4\xc4\xd8\x78\xc6\x44\xbd\x0e\x83\x78\x9a\x94\x6a\x6e\x01\x19\x6b\xfb\x6e\x75\x71\x97\x84\x5d\xc5\x51\xf8\x79\x23\x3e\x8a\x8f\x9e\xbc\x87\x75\xcb\x0b\xe4\x05\xcc\x15\xf8\x59\x39\x91\xba\x76\x14\x83\xf0\x5c\x79\xa5\x12\x67\x2e\x45\x3b\xb9\xd1\xcc\x8f\xe0\x17\x2b\xf6\x60\x86\x63\xc8\x9b\xb6\x44\xd6\xb6\xa4\x83\x6d\x61\x8f\xb1\x2c\xdb\x82\x31\x91\x71\xed\xf8\xb4\x93\xc4\xae\x98\x07\x44\x2a\xac\xc6\xec\xe7\xcc\x24\x79\x24\xd3\x97\x3c\xe7\xcd\xe4\xa7\xd6\x72\x8c\xb0\x19\x6c\x21\x37\x61\x21\x3e\x00\x92\x20\xa7\x85\x3a\xd8\xc3\x87\xd3\x5b\xd8\x60\xf0\x8b\xee\xb8\xfa\x62\x0a\xdd\x24\xc0\xc7\x6c\x6b\x7d\xf0\xf6\xd3\xce\xaf\x8f\x95\x56\xe6\x85\xfd\xf1\xca\xd4\x5a\x31\xff\x5f\x58\x3a\xbd\x47\x69\xb7\xa2\xca\xa2\x3b\x37\x2a\xb4\x1e\x4c\xad\x65\xb6\x51\xfc\xa1\x84\xd9\xc4\x78\x3c\x1d\xd0\x13\xec\x71\x97\x57\x0f\x34\x74\xdf\x81\x06\x26\xbf\xf5\xe1\xd5\x06\xec\xc2\xe6\xdf\x3e\xfb\x5e\x6e\x33\x60\xc7\xed\xbf\x30\x95\xdc\x7b\xcc\x53\xe4\x9d\x94\x5d\x60\x33\x8a\xc6\x6f\x4f\xe2\x93\xd9\x6f\x7e\xfe\x83\xa9\x6c\x6d\xa5\xf4\x90\xf1\x52\x7a\x48\xae\x20\x31\x2c\x79\x79\x41\x46\x27\xd4\x97\x17\x5c\x0a\x2d\x31\xe8\xbc\x55\xd8\xfc\xcb\x71\x95\x3f\xa4\x0f\x1e\xe2\x88\x99\xe3\x79\x01\x8b\x9c\x4c\xf2\x66\xe8\x08\x9d\x54\x72\x4f\x75\x3f\x05\xf2\x90\x83\x2f\x4a\xee\x66\x9e\x48\xbd\xdf\xca\x3c\xd5\xda\x76\x09\x7d\x06\xff\x17\xd2\xa7\x86\x83\xe5\x38\x11\x72\x3f\xd9\x48\xac\x11\x07\x4b\x5f\x84\x32\x33\x4f\xb4\x02\xd1\x27\x3e\xe2\x56\xa9\x74\x93\xb1\x02\xdd\x3c\x8a\x90\x58\x28\xb0\x22\x43\xec\x7c\x67\x12\xd4\xf2\x04\x7d\x78\x4d\x27\x82\x46\x43\x18\x02\x53\x96\x1a\x28\x6c\x3e\xe9\x69\x55\x79\x45\xc7\x4d\x69\x00\xa3\x20\x34\x9c\xa0\x28\xb6\x13\x14\x1d\x69\x88\x03\x0d\x65\x84\x06\xf6\xfb\xb6\xa5\x3a\xef\x28\x0d\x22\xe4\x49\x56\x46\x10\x44\xd1\xc4\x4a\x82\x9c\x45\x48\x1a\x51\x9a\x1a\xca\x52\xa0\xe7\xfd\x56\x4a\x90\x91\x2f\x14\x5f\x69\x02\xec\x44\x80\xea\xc3\xc4\xcb\xec\x89\x2c\xd6\x68\xe8\x74\xc2\x62\x94\x34\x85\xb6\x5f\x8e\x73\xab\x54\x5c\x54\x4e\x22\xaa\x48\xd8\x79\x48\xbd\x18\x09\x03\x32\xf2\x66\x9d\x41\x29\xc8\x5c\x94\xfe\x38\x87\xa2\x1d\x94\xdb\xdc\x3f\x88\xc0\x40\x49\xda\x2e\xa1\x0c\x57\x75\x8b\xd2\x46\xf0\x31\x8c\x49\x00\x7c\xec\x09\x1e\xff\x09\x3e\x17\x19\x2f\xe5\x5c\x19\xa5\x8f\xb2\x5f\xa3\x0f\xf0\x59\x50\x43\xc2\xc3\x4b\x12\x63\x36\x5b\x05\x1b\xb6\x4a\x30\x5e\x93\x42\x24\x64\x26\x04\xab\x3a\xa7\x99\xc6\x1b\x37\xa2\x8e\xaa\xa3\xa7\xcc\xd4\x7a\xa0\x54\x33\xed\xbf\xe0\x05\xdc\x7b\xec\x6c\x1a\x1f\x6a\x12\x66\x91\x64\xde\x18\xb8\xc0\x51\xf9\xf0\x29\x8d\xf4\x36\xad\x64\x4a\xbf\xcf\xcc\xaa\xee\x1e\x38\xd1\x16\x01\x7b\xf9\xa4\xb5\x55\xbe\x4b\xb1\x19\x06\xcf\x4c\xad\x65\xa7\x52\x9b\x11\x51\x01\xd4\x2f\x2c\x38\x1c\xc1\x24\x89\x0c\xb0\x17\x44\x5e\xdf\x92\x11\xe4\x40\x3e\xf4\x33\xb3\xb5\x15\xcf\x50\xec\x48\x72\xa6\x6d\x09\xe8\x93\x50\x73\xc2\x01\xc9\x92\x24\x99\x2d\x02\x79\x13\x44\xe6\x44\x4a\x22\x97\xd2\x2c\xab\x2d\xfd\x34\x96\xfa\x98\xb2\x86\x5e\x7b\xec\x5a\x35\x33\xca\x07\x76\x76\xeb\x7b\xad\x27\x0b\x89\xf7\x9a\xa9\xea\x01\xd4\x8c\x09\x9b\x68\xe2\x58\x13\x6b\x46\x16\x46\x90\x04\x40\xbc\x2b\x29\x9d\x34\xb1\xb2\x56\x5a\x69\x09\xa0\xb2\x6a\xa9\xbe\x7f\xe8\xe2\xde\x93\x6f\x06\x74\xd4\x7c\xb9\x55\x6d\x97\xf0\x31\x95\x07\x94\x76\x1e\x24\xd8\x2b\x61\xe7\x78\x8b\x99\x87\x2a\xc7\x84\xb1\x4d\x90\x00\xf5\x9e\xa4\x90\xb2\xa4\x3d\x83\x4a\x7f\x5c\x63\x72\xba\x1f\x4a\xbb\xfa\x73\x26\x7b\x71\xaa\x08\xb8\xc4\xf0\xd0\x25\x0c\xe2\xc4\x3e\x6e\x96\x32\x0e\xc5\x36\x28\xaf\x9a\x12\x76\x91\x31\x99\xcc\x16\x08\x58\x66\x51\xd6\xa4\xd9\xa6\x49\x33\xd5\x19\xab\x14\x91\x36\x44\x55\x67\x02\x4c\x02\x87\x82\x17\xc0\xb8\x4e\x94\xb3\x1f\x2b\xf8\xd9\xa9\x94\x4f\x35\x09\xa7\xc2\x27\x0b\x32\x03\x73\x84\x8e\x16\x93\xc1\x28\x56\x7b\x51\xd3\x65\x66\x2f\x26\x7c\x52\xbc\x94\x62\x38\x8c\x82\x37\xcd\x27\x41\x64\xb0\x88\x21\x3f\xe1\x38\xab\x59\xa2\x94\x9b\x53\x74\x08\xbb\x60\x08\x22\x56\x64\x91\x56\xc6\x34\x9f\xc8\xca\x4a\x03\x26\x3f\xa2\xec\xd4\xd6\x54\x11\xc3\xb7\xca\x37\x33\x3c\x3b\xfb\x44\x39\x7f\x1a\x1d\x45\x2b\xf5\x49\x44\xe7\x41\x37\x09\x9f\x6c\xc4\x85\x80\x4e\x99\x58\xd6\x22\x28\x9d\x09\x29\xcd\x3b\xb5\xe9\xde\xa9\x32\x4b\xa3\xf4\x37\x4f\x54\x1f\xa5\xfa\xcd\x97\x60\x70\xca\x9c\xdc\x4c\xd5\x17\x48\xe0\x0b\x2c\x26\x5e\x62\x78\xc6\xcc\xc2\x17\x9a\x72\x31\xa6\x93\x82\x6a\x05\x95\x19\x0a\xa5\x58\x2b\x7c\x67\xde\x6a\xc5\xf3\x4e\xae\x6e\x7d\x8f\xfa\x3e\xee\xea\x93\x1e\xa2\x4f\x2a\xdd\x2a\x9f\x18\x1e\xf0\x99\xac\x36\x33\xcb\xda\x4c\x16\x4a\xb1\xa9\x8d\x92\xbe\x2b\xc9\xa4\xd4\x0e\x3a\xe5\x13\xed\x46\xfd\x39\xb3\x95\x39\x7a\x72\x35\x58\x1d\x9e\x97\x6a\x13\x36\xb7\x4d\x6c\xe5\xeb\x61\x1c\xca\x1e\x09\x0b\xa8\xaf\xa5\xfa\x24\x09\x0c\x63\x31\x53\x7d\x3a\xf1\x3f\xeb\x53\x5c\xd5\xa7\x32\x45\x9f\xd8\xe6\x13\xaf\x29\xfe\x92\xfa\x08\xaa\x4f\x10\x9d\xc8\x4b\x6d\xd8\x6c\xe2\x4e\x40\x57\x38\x1d\x65\x3a\xea\x13\x56\x70\xc2\x5f\x76\x2a\xd0\x3e\x4f\x51\x29\xe2\xd6\xd8\xef\x15\x9f\x46\xf1\xaa\x7c\x32\x59\xc8\xcb\x72\xa0\x4f\x18\x2b\xfa\xb4\x27\x69\x6e\x13\xb8\x13\x5a\x1f\xa9\xae\xed\x8e\x74\x13\x8d\x2b\xfa\x74\x72\x35\x73\xb4\x55\x16\x5b\x53\x6d\x78\x1e\x8c\x82\xdb\x70\xb2\xb1\x35\x33\xc6\x59\x50\x5f\x18\x07\x78\x69\x8b\x05\xac\x1c\xa4\x62\x96\xff\x48\xa5\xb2\xfc\x54\x86\x5a\xe9\xc1\x4f\x0b\x80\x2f\xa9\xde\x4a\xf7\x2b\x34\xce\x90\xb7\xd4\x1d\x66\xc8\xe7\x05\x8b\x60\x65\x6d\x16\x35\xb0\x82\xfc\x4f\x9a\xd2\xf2\xd7\x79\x97\x11\x5d\x69\xd2\x42\xd4\x0c\xfc\x08\xf1\xdb\x6a\x94\xa5\x7e\x97\xd5\xfb\x80\x92\x06\x39\xd0\xc0\x84\xcb\xce\xf3\x2e\x84\x1d\x92\x64\x35\x61\x93\xd3\x65\x75\xd0\xf1\x58\xdb\xa8\x1b\x4e\x48\xe0\x87\xcd\xcc\x09\x09\xc9\x54\xab\xb5\x65\xa9\x8c\x95\x41\x25\x25\x8c\x7b\x94\x80\xa4\x68\x5f\x5b\x6b\xeb\x7b\xd4\x93\x51\xf5\x4b\xad\x95\x9c\xa0\x80\x27\x0b\x25\x27\x55\x41\x43\xbc\xb7\xa0\xde\x09\x97\x44\x98\x6b\xb5\x81\x12\x42\x0c\xfc\x63\x35\x34\xea\x61\x86\x22\xc6\x74\x55\xd4\x74\xf1\x97\xe3\xec\xc7\x48\xf7\x43\x3a\x5f\xdd\x90\x5d\x58\xcc\x82\xd9\x86\xac\x16\x5e\x36\x75\x48\x31\xe2\x46\x9d\x34\xe4\x19\x84\xaf\x66\xd0\x49\x1a\xc9\xf4\x7c\x83\xbb\x1a\xd8\x8a\x58\xbd\x0f\x9d\xaf\x82\xd9\x2c\x59\x58\xc6\xc2\x38\x5d\x36\x51\x74\xda\x6d\x74\x4c\xf6\x94\x49\xe5\xab\xa9\xcd\x92\x8e\x99\x9d\x98\xb3\x31\x80\x92\x22\x91\x7a\x3f\x90\x2b\x91\x29\x51\xd5\x56\xea\x02\x95\x88\x0a\x1a\xab\x38\x41\x46\xc9\x2d\xc0\xe7\x92\xb1\x26\x12\x0e\xc8\x7e\x6c\x56\xd6\x62\xb1\x99\x08\x6f\x4d\x4a\xd7\x52\x9b\x31\x19\x4a\xe9\x0b\x73\xe9\x24\xc0\x95\x99\x13\xa9\xd9\x00\x68\x6c\xea\x7d\xee\x1f\xc0\x5e\x10\x25\xfb\x31\xe1\x03\x32\xe6\x5b\x16\xd4\x3d\xe1\x91\xcc\x02\x6f\xe6\x41\x69\x91\xd5\x0c\xec\xed\x90\x74\xa9\x36\xef\xca\x88\x22\x7a\xc0\x85\x5e\x94\x88\xab\xe6\x5f\x6a\x0e\xc6\xea\xe3\xe2\xd5\x37\x86\xdd\x64\x85\x0d\x9b\x5d\x4e\x9b\xc9\xe4\xb2\xb3\xac\xd3\x61\xa7\x2e\xd8\xd1\x26\xb1\x1c\x4b\xbf\x0a\x5c\xca\xa2\xea\xad\xb6\x34\x6c\x18\x5f\xba\x98\x01\xbe\xc6\x15\xcb\xf1\x41\x94\x69\xa3\x7c\x55\x94\x97\xe1\xdb\x22\x20\xd7\x8f\xc9\x78\xf9\xf7\x5a\x5b\xb5\xbc\x4a\xd5\x25\xc2\x5f\x86\xb1\x59\x2d\xa2\x98\xc9\xdf\x94\x31\x39\x6c\xfb\x43\xfe\x52\x7b\xa1\xfc\xa5\x89\x9c\x9a\x70\xb1\xcd\x60\x27\x6a\xd2\x95\xce\x3f\x29\x7f\x41\x7b\x25\x46\xb2\x5a\x80\xbf\x22\x7b\x42\xea\x90\x84\x76\xca\x5f\xb5\x57\xe8\x85\x3a\x55\x3c\x4f\x77\xab\x4a\x4e\xca\xea\xe3\xd2\xf9\x6b\xb2\xf0\xa0\xbc\x2e\xa7\x83\xe3\x5c\x56\x49\x72\x92\x55\x21\x60\xaa\x2d\x45\x36\xfc\x52\xa2\x1d\x78\x5b\x3d\xda\x75\xc9\x5f\x3d\x26\x35\x44\xc9\x30\xa9\x67\x4a\xb5\xa9\x4a\x2c\xdf\xcc\xfd\x83\x3a\x41\xf6\x55\xd0\x61\x70\xc2\xad\xc6\xfc\xd8\x83\xce\x49\x84\x6c\x92\xcb\x25\x30\x6e\xb7\xcf\xeb\x30\x9b\x7d\x88\xe7\xbd\x2e\x70\x11\x56\x8e\x3a\x89\x3d\x49\x89\x6f\x73\x6a\x29\xb3\x8d\xe8\xb2\x4a\x4b\x46\xe6\x9c\x7e\x72\x21\x9e\x15\xbe\x74\xb7\xac\x7b\x0f\xdd\x39\xab\x5e\x44\xf5\xd0\xd4\x95\x64\xd0\x76\x7a\xc2\xef\x36\x9b\x1d\x16\x8f\x48\xdd\xb4\x97\xf3\xd9\xbc\x12\x6f\xa3\x86\x9e\xb0\x24\xdd\x8c\xfd\x24\xf8\x6d\xa7\x66\xe1\x99\x0f\x90\x37\xa7\xdf\xb1\x4b\x7b\x6e\x65\x5b\x8d\x86\x74\xa2\x40\x4d\x41\xbe\x99\xc8\x4c\xf5\xe2\x8a\x45\x50\xd9\xd1\x47\x1b\x75\x7a\x88\xdc\x5c\x28\x80\xa6\x24\x42\x5e\x41\x08\x88\xbc\xcb\xc5\x38\x45\x67\x4e\x90\xb5\xdb\x73\x7c\x92\x14\xe4\x7d\x7e\x1f\xe5\x18\xe3\x6f\x73\x28\x22\x4c\x98\x93\x56\x73\xca\x25\xc8\x6e\x9d\x48\x03\xf3\xb2\x84\x99\x4d\x2e\x6b\x34\x9c\xb8\xea\x9c\x88\x68\xdf\x33\x18\x90\x2a\x66\x2a\xe2\x13\xfb\x14\x43\xa2\xee\x8a\xce\x07\x20\xe6\x52\xee\x30\xf5\x99\xee\xdd\x08\x6a\x76\xe6\x04\x42\xb5\x2d\x6a\xb5\x8e\xc9\x8a\xf8\xe1\xb6\x38\x77\x18\xa0\x1a\x15\x78\x18\x2b\xfc\x96\x86\x27\xd6\x5d\xdb\x01\x1e\xa0\x3e\x48\xc3\x53\xfc\x9e\x3d\x2a\x7e\x19\xb5\x74\xec\x80\x84\x27\x15\x9e\x99\xae\xc1\xe3\xce\xe0\x99\xe9\x04\x44\x85\x67\xa6\xe9\xf8\x5d\xbb\x31\xe2\xd3\xe0\xf5\x1a\xf6\x34\x34\x22\x7b\x10\xa7\xda\xb8\xe9\x6a\xed\x44\xac\xcc\x43\x9f\x4a\x8d\xa0\x18\x2a\x45\x95\xa8\x16\xc5\x51\x13\xea\x85\x5a\x50\x3f\x34\x10\x9d\x81\x86\xa2\x11\x68\x34\x1a\x8b\x26\xa2\xa9\x68\x3a\xba\x10\xcd\x42\x97\xa2\x05\xe8\x0a\xb4\x18\x2d\x43\x2b\xd0\x4d\xe8\x56\xfc\x6a\x62\xa6\xbd\xe4\xb4\x73\x16\xf1\x97\x5c\xe2\x28\x1d\x38\xfa\x0a\x7e\x96\x90\xdf\x78\xd6\x8d\xfc\xb4\x69\x62\xa4\x69\xe8\x4d\xfc\x74\x77\x45\xdf\x73\xaf\xe6\xe7\xce\xf5\x54\xb6\x8c\x5d\xcc\x5f\x6a\x2e\xec\x39\x78\x25\x3f\x65\x8a\x25\xd6\xeb\x8c\x5b\xf9\xa9\x53\x2f\x9d\x3e\x8b\xbb\x70\x01\x13\xaa\x1f\x7e\x1d\x3f\x73\x26\x1b\x8e\x8f\x58\xc1\x5f\x78\xe1\x6d\x81\xda\x7e\x13\x97\xf1\x0b\xfc\x35\xa7\x4e\x58\xca\x2f\x98\x3f\xbf\x75\xfa\xd4\x0b\x67\x5c\xb8\x17\x73\xe0\xda\xce\x9b\x34\x63\xe2\xd8\xd1\x23\x47\x2b\xbf\x8d\x1b\x33\x72\xe8\x19\x23\x86\x8d\x50\x7e\x1b\x32\x68\x58\xbf\x96\x81\xfd\x07\x2a\xbf\x25\x7a\xf7\xef\xd5\x14\xaf\x8b\x2b\xbf\xf5\xe8\x5e\x57\x5b\x59\x5a\x54\xaa\xfc\x56\x55\x56\x14\x8b\x84\x83\x61\xe5\xb7\x82\xdc\x60\xc0\xe3\x20\x89\x07\xf9\xcd\xeb\x04\x7f\xca\x92\xda\x89\xfc\x06\xf1\x63\xd9\xe2\x2b\x16\x5e\x41\x7e\x8b\x24\x97\x5c\xb9\x70\xc6\xc8\x61\xfd\xeb\x8a\x82\x56\xb4\x70\x21\xb2\x06\x8b\xea\xfa\x0f\x1b\x39\xc3\xbc\x7c\xde\xec\x8b\x66\x5d\xa4\xdc\xb1\xe0\xd2\x59\xb7\xde\xb4\x62\xf9\x0a\xf8\x6d\x67\xf2\xe6\xeb\x97\x9f\x40\x9a\xe9\x05\xb5\x97\x38\xdc\xca\x83\x5d\xea\x9f\x0e\xcf\xef\xfe\x9f\xfe\x4f\xd4\x25\xa0\xee\x31\x10\x88\xd3\x2f\x64\x5d\x45\xfd\xda\xd9\x7f\xdd\xea\xc8\x1b\x96\xc5\xea\x87\xff\x1f\xbf\x8b\x5d\xb4\x07\xba\x80\x31\xb6\xe3\x2e\xbe\x4f\x9f\x8e\xef\x56\x3e\xa9\xb5\xd3\xa6\xe1\xbb\x95\x4f\x5b\xfb\x9f\xb7\x1f\x56\x9a\x4e\x1e\x9a\x36\x8d\x99\x3e\x7d\xba\x3c\x4d\xf9\x1c\x4e\x43\x1f\xee\xb4\x95\xdc\xd0\x19\x3e\xbe\x6c\x0a\xf9\x33\x79\x52\xfa\xcf\xd4\x8e\xdf\x27\x93\x3f\x53\x26\x90\x3f\x53\xe8\x77\xa5\x59\xfc\x9e\xde\x8c\x63\xf4\x37\x44\xce\x36\x06\x1b\x7c\xed\xff\x9e\x0d\xa2\xd5\xe8\x4e\x74\x0f\xba\x1f\xfd\x05\x6d\x44\x8f\xa2\x6d\x68\x07\xda\x83\x9e\x44\xfb\xd1\xf3\xe8\x25\x74\x10\xbd\x8e\xde\x46\xef\xa1\x0f\xd1\x27\xe8\x73\xf4\x15\xfa\x16\x1d\x43\xff\x41\xbf\xa2\x36\xd4\x8e\x59\x28\x85\x2d\xd8\x81\x3d\x38\x80\xc3\x38\xc2\x5a\x76\x30\xf5\x53\x1e\xde\x8b\xcd\xbb\xf9\x77\xdf\x65\xe3\x53\x37\xd2\x37\x30\xf8\xf7\xf2\xcf\x5a\xb9\xf5\x17\xfe\xe3\x8f\x23\x43\x6f\xdd\xf6\x2b\xff\x89\xd0\x38\xed\x81\xbd\xd8\xbe\x9b\x7f\xeb\x2d\xb1\x69\xfa\x5f\xf6\x62\x07\x00\xbd\x5d\x38\xfc\xea\xed\x27\xf8\xcf\x3e\x8b\x8d\x58\xbc\xa3\x8d\xff\xdc\xdc\x73\xe6\x7d\x7b\xb1\x7b\x37\xff\xda\x6b\x96\x5e\x17\xde\xbf\x17\x7b\x00\xe8\xf5\x92\x73\x96\xee\x96\xf9\x7f\xfe\xb3\x74\xf4\xb2\x3d\xed\xfc\x57\xf6\xbe\x97\xdc\xbd\x17\xfb\x77\xf3\xaf\xbe\xea\x68\x99\x75\xcf\x5e\x1c\xd8\xc5\x1f\xac\x38\xf7\xba\x7d\x7b\x31\xb3\x9b\xff\xe6\x9b\xca\xb1\x2b\x9e\xdc\x8b\xd9\x5d\xfc\xb7\xee\x53\xe7\xde\xb1\x17\x87\x76\xf3\x2f\xbe\xe8\xe9\x77\xe9\x9d\x7b\x71\x78\x17\xff\x52\xcd\x84\x1b\x9f\xd9\x8b\x85\xdd\xfc\x0f\x3f\xd4\x4e\xbc\x69\xff\x5e\x2c\x26\x22\xfc\xb1\x63\x2f\x7d\x7b\xf0\xab\xd7\x3f\x7f\xfb\x93\xf7\xcc\x1f\x3e\x1f\x1a\xbc\xe8\x91\x1f\xf9\x0f\x3e\x08\x9f\x71\xc5\xa3\xff\xe1\x3f\xfc\x70\x2f\x2e\xd8\x11\x18\xb8\x60\xf5\x5e\x1c\xd9\xc5\x3f\xef\x3f\x6d\xfe\xaa\xbd\x38\x7f\x07\xff\xfc\x73\xcf\xed\xc5\xd1\x84\xf4\xfc\x4b\x07\x5f\x7f\x9b\x7f\xef\x9d\xf7\x88\x1d\xbb\x92\xcf\x1e\x78\xf9\xd0\x1b\xfc\x3b\xdb\x76\xec\x79\x72\x3f\xff\xe8\xa6\x47\x95\xd6\xc7\x1e\xdf\xb9\xf7\x29\x7e\xd3\xea\x3b\xef\xb9\xff\x2f\xfc\xc6\x07\x37\x2a\xad\xb7\xad\xb9\xeb\xde\xf5\xfc\x83\x8b\x97\xad\xb8\xe9\x56\x5e\xf5\x16\xae\xe4\x95\x4b\x96\x5f\x7f\x33\xbf\x70\xfa\x85\xb3\x2e\x5d\xc0\x4f\x9d\x34\x55\x69\x3d\x6f\xc6\x45\xb3\xe7\xf1\x93\x86\x8e\x18\x3d\x76\x22\x7f\xc6\xa0\x33\x94\xd6\x21\xc3\x46\x8e\x19\xc7\x0f\x6a\xea\xd5\xd2\x6f\x20\xaf\x7a\x2d\x57\xb2\x7b\x8f\xde\x89\xfe\x7c\x5d\x24\x56\x5a\x59\xcb\xab\xfe\xca\x95\xcc\x2d\x28\x2a\xab\xe2\x83\xa2\xc5\xe1\x09\xf0\xaa\xa7\xb2\x24\x39\x93\xd5\xe9\xe5\xd1\xaf\x6d\xed\x4f\x10\xe1\xee\xe0\xff\x73\xfc\x3f\x74\xb2\xff\xa7\xdf\x4e\x3e\x81\x11\xc0\x04\xf8\xe3\xef\x6c\x7a\x70\xe1\xa4\x41\x75\x41\x74\xfc\x38\x0a\xd6\x0d\x9a\xb4\xf0\xc1\x4d\xef\x98\xf7\x62\x53\x42\x3a\xfa\xe9\x17\x5f\x7f\xc7\xbf\xff\xe1\xfb\x70\xcf\x9e\xe4\x27\x9f\x7f\xf5\xed\x31\xfe\xc3\x53\x3c\x69\x0d\x81\x00\x66\xc1\x26\xf8\x70\x28\x89\xad\xd8\x89\xbd\x38\x88\x73\xa1\x95\x16\x84\x01\xe2\x7b\x02\xe0\xe2\xd4\x2f\x59\x2e\x4e\x6d\xfd\xbf\xf6\xff\xff\xee\xe2\xfe\xfb\xff\xc8\x1a\xae\x2f\xd6\xd4\xc9\x87\xff\x7f\xd0\x5e\x9c\xd5\xa6\x39\xd5\xd2\x4e\x3e\x62\x17\x78\x02\xff\x23\x3c\xfe\x1f\xdb\x89\xe3\xcc\xfc\xd7\x06\xce\xf8\x70\xe6\xbf\x93\xe7\xff\x1f\x40\x51\x37\xad\xc3\x80\x67\x66\xef\xee\x00\x37\xad\x03\xb2\x8e\x74\x75\x84\x69\x6b\xff\x6f\x68\x50\x9d\xfe\x94\x0e\xae\x7f\x52\x17\x61\xa0\xcb\xf6\xc9\xe9\x3f\x4a\x78\x98\x60\x08\x12\x93\x0d\xa1\x22\x23\x60\x4c\x31\x86\x0d\xe5\x0f\x39\x27\x1b\xf2\x3d\x12\x3b\x06\xa0\xd3\xd1\x99\xe8\x6c\x34\x0a\x25\xd1\x78\x34\x19\x9d\x8f\x2e\x40\x17\xa3\x39\xe8\x32\x74\x39\xba\x0a\x5d\x83\xae\x45\x37\xa0\x5b\x50\x2b\xba\x1d\xad\x45\xeb\xd0\x06\xf4\x10\xda\x8c\xb6\xa0\xbf\xa2\x5d\xe8\x09\xf4\x34\xfa\x1b\x7a\x01\xbd\x82\x0e\xa3\x37\xd1\xdf\xd1\x11\xf4\x11\xfa\x07\xfa\x12\xfd\x0b\x7d\x8f\xfe\x8d\x7e\x46\xbf\xa3\x14\xc6\x98\xc7\x12\xb6\x61\x17\xf6\xe1\x1c\x9c\x87\xa3\xac\x2b\x71\x61\xe8\xbc\x85\x0f\x7d\xc1\xbf\xf0\x82\xea\x74\xce\xb8\xb0\xf5\xd1\xe3\xfc\xc1\x83\x83\x66\x5c\xbf\xe9\x67\xfe\xe5\xfc\x49\x57\x6c\xf8\x94\xff\xdb\xdf\xc2\xe7\x5f\xfe\xc0\x97\xfc\x73\x43\x67\xdd\xb4\xed\x3b\xfe\xf5\xd7\x87\x5c\xb4\xf2\xb1\x7f\xf3\x87\x0a\xc7\x2d\x5e\x77\x94\x7f\xfa\xe9\xc8\xe4\x2b\xef\xfb\x07\xff\xcc\x88\x4b\x57\xef\xf8\x9a\x7f\xfb\xed\x61\xb3\x6f\x7e\xfc\x7b\xfe\x8d\x92\x31\xcb\xd6\xbe\xcf\x3f\xf1\x44\x6c\xfc\x92\xbb\x3f\xe2\xf7\xfd\xda\xfe\x34\x44\x26\x07\x2e\x00\xcf\x12\xc0\x81\x84\x34\x72\xde\x9a\x9d\xff\xe2\xdf\xa9\x38\xf9\x34\xb8\x35\x1b\xf5\x38\x3e\xec\x4b\x38\x4b\x93\xcb\xef\x38\xc2\xef\xae\x23\x3e\x92\xef\xdf\xff\xb7\x67\xc0\xc7\x99\xc0\x2d\x45\x01\x20\x88\x83\x09\xcb\xee\x77\xf6\xbd\xf1\xcc\xa1\xe7\x5e\x66\xcd\x18\x82\x51\xc2\x39\x70\xfa\x8a\x8d\x3f\xf1\x2f\xbd\xc4\x4b\x36\x97\x0f\xca\xd6\xbd\xb8\x30\x61\xa9\xa9\x6f\xec\xd9\xf7\x54\x01\xa1\xca\xd4\x33\x98\xc3\x66\x9c\x07\xb7\xbb\xe1\x6f\x2c\x61\x55\xfd\xac\xbf\xdf\xab\xaf\xbd\x05\x91\x6a\x07\xff\x22\xf3\x22\xcd\xea\x9e\x78\xfa\x6f\x2f\xec\xc5\xbe\x5d\x3c\xb3\xf7\xa9\x67\x0f\xec\xc5\xde\x1d\x3c\xbf\x91\xa7\x97\x12\x8f\x6e\xdb\x01\x41\x71\x17\xbf\xb1\xe5\x91\xad\xdb\x21\x52\xee\xe0\x1f\x16\x1e\xa6\x97\xd6\xae\xdb\xf0\xd0\x5e\x6c\xdb\xc5\x0b\x10\x2c\x1e\xdc\x8b\xad\x3b\x78\x69\x85\x44\x2f\xf5\xbe\xa9\x15\xa2\x92\xb8\x8b\x5f\xd1\xeb\xc6\xdb\x20\x2a\x09\x3b\xf8\xeb\xcc\xd7\xd1\x4b\x0b\xaf\x58\xbc\x8c\x86\x41\xf3\x82\x45\x57\x2f\x85\xd8\xb8\x83\xb7\x4d\xb7\x29\x81\xa0\x07\x44\x96\x76\x7e\x7a\xd3\xcc\x4b\xe6\xca\xfc\x34\xfb\xb4\xff\x8f\xb7\xf7\x00\x8c\xaa\xd8\x1a\xc7\xe7\xcc\xcc\xbd\x5b\xb3\xbd\x64\x93\xdd\xcd\x26\x9b\x42\x48\x48\xc2\x2e\x21\x84\x96\xa5\x85\x2e\xbd\x2c\x3d\x95\x04\x42\x12\x92\x90\x48\x93\xde\x2c\x20\x20\x8a\x0d\x51\x51\x6c\x88\x05\x04\xf5\x89\x3e\x0b\xea\x13\xec\x5d\x11\x54\x14\x7b\x2f\x4f\x21\x37\xff\x99\xbb\x77\x93\x4d\xc4\xf7\x7d\xff\xdf\xf7\xfd\x7e\xd9\xec\xee\xdc\xbd\x33\xe7\x9c\x39\x73\xe6\x4c\xb9\x67\xce\x89\xfc\x3a\x7d\xd6\xbc\xf2\x0b\x82\x81\x0d\x2f\x65\xe7\x05\xf3\x70\xb3\x32\x94\x8c\x1e\x37\xe9\x77\x61\x78\x70\xd4\x25\x13\x7f\x13\x8a\x2d\xc5\x32\xf0\x77\x99\xd6\x3f\x0a\xee\xc3\x82\xe5\x9d\x0f\x4e\x7f\xca\x06\xd6\x87\x05\xfb\x2f\x76\xf9\x56\xde\x17\xdf\xfc\xc0\x06\xcc\x90\x5b\xf8\x05\xef\x17\x37\x69\xe7\x1b\x86\x5b\x7e\xf9\xc5\x32\xdc\x30\x5f\xbb\x49\xdc\x8f\xb5\x8e\xa1\x6c\xb4\x64\x83\xf6\xc3\xc2\xf3\xf0\x3c\x2b\xf1\x48\x18\xa4\x5c\x36\x68\xb0\xc1\x95\x0d\x3d\x8e\x9f\xe5\x61\x24\xc1\x9b\x92\xde\x5d\x70\xa0\xe8\xa8\x20\x9b\xc6\xfd\xdf\x1e\x1c\xe2\x4d\xc7\x9d\x81\x88\x93\xad\xff\x6b\x23\x04\x5b\x5d\x05\xf3\xfd\x17\x79\x07\xed\x17\x7b\xfb\xed\x41\xf3\x45\xde\xd0\x25\xa3\x93\xfd\x96\x11\xf3\x56\x75\xb9\x2f\xb0\xdf\x0a\x62\xaf\xd9\x3b\x99\xbd\x55\xf9\x7e\x7b\x1a\xfb\xb6\xb2\x6f\x7f\xcc\xbb\x6b\xf9\xff\xf2\x7e\x17\xfc\xd0\xf5\x5a\xa1\x91\x97\xf3\x00\xc3\xab\xc0\xec\xf4\xcd\xee\x13\xf6\xa6\x2f\x9f\x0f\x54\x76\xfc\xcd\xef\x78\xc5\xfe\x9d\xdf\x1d\xfd\x39\x56\x25\x2b\xbf\xb5\xb6\x45\xcb\x5d\x38\x31\x1f\x82\x4c\x2f\xb3\xf9\x78\x3b\xa8\xf6\x82\x5d\xaf\x3b\x00\x61\x88\x51\xe9\xf8\xa4\x7c\x6f\x3e\xff\xe7\xb9\xe5\x37\xff\x6c\xbd\x1e\x52\x4a\xf8\xbf\x7f\x1e\x24\x97\xca\xff\x31\x6a\xf7\x9f\xa5\xd2\xe9\x79\xd2\xa9\xc8\xff\x1c\xf6\x29\x2e\x88\xde\x7a\xaa\xeb\xf8\xf0\x54\x34\xf1\x4c\x47\x79\xe9\xf4\x5f\xd4\x7f\xc7\x4f\xed\xb9\xc4\x93\x51\x95\x9f\xa2\x24\x18\x56\x86\xa0\x44\x06\xfa\x4c\x04\x4c\x69\xa4\x68\x24\x3b\xcb\x28\xef\x31\xb4\xa0\x25\x74\x2a\x9d\x1c\xf1\x35\x2e\xa0\xce\xbe\xc6\x93\xcd\xc9\x2d\xe4\xf4\x85\x64\x3a\xf9\x02\x8f\x73\xc2\xcd\x09\x5f\xa2\x2f\xca\x6b\x8f\xec\x90\x56\x20\x22\xc6\x44\xa3\x26\xdc\x18\xe4\xe1\x30\x41\xb4\x93\x51\x48\xcc\x73\x54\x0e\xc8\x6a\x4e\x36\x63\xfa\xe2\xf9\x82\x31\xb4\x27\xff\xa2\x2b\xcf\xbf\x42\x7b\xca\xcf\xa4\xaa\x60\x15\x29\x27\xcb\xf9\xbe\xc5\x23\x7c\xdf\x42\x60\x98\x72\x4f\xb6\x1b\x31\x70\xf7\x80\xe5\x12\x85\x0b\xb0\x0a\x2e\xf0\xe7\x0c\x1d\xf9\x55\x28\x2f\xa4\x55\x01\xdf\xa4\x55\x6b\x90\x8a\xe1\x3f\x1c\x46\x38\x84\x45\x99\x12\xac\xd8\x4c\x9f\xe8\x64\xad\xa5\x78\x1b\x8c\x80\x1c\x23\xdd\xc4\xa1\x4a\xe3\xa1\x54\xda\x13\xb1\xc9\x2e\xa6\xcf\xe1\x94\xbf\xe5\x87\x9a\x3e\x71\x7e\x08\x4e\x91\xf8\x59\x1f\x23\x0a\xd0\x27\xe8\xfd\x8c\x5a\xfb\x11\xee\xa7\x1d\x11\x68\xcf\x6d\x2e\xec\x99\x57\xa0\x01\x23\x9e\x8e\xa7\x06\xe8\x8a\xf3\xeb\xb9\x0d\x60\xdb\x67\x8c\x7f\xf7\xb1\xfc\x0c\x36\xe5\xce\x75\x63\x60\x6b\xa0\x17\xbd\xee\x7c\x35\xbd\xaf\x75\x4f\xeb\x8d\x11\x7b\x13\x23\xcb\xff\x04\x2d\x51\xe0\x33\x5a\xba\xc0\xd7\x60\xfa\x44\xeb\x3d\xad\x77\xd1\x92\xf3\xeb\xe9\x8a\x48\x19\xcc\xca\x5c\xaf\xe0\xe8\x5c\x82\x3f\x87\x04\x7a\x3d\x47\x71\xbe\x10\x57\xb0\x1c\xb5\xac\x3d\xe7\x0a\x77\xca\xf1\x0a\x86\x86\x12\x29\x11\x59\xfd\xd5\xa2\xa0\xc2\x1a\x01\x0b\x5a\x1d\xfb\x14\x89\x5a\xa5\x02\xb6\x44\xc8\x7c\x10\x64\x07\x0d\x85\x03\x72\x0b\x2d\x85\xc1\x4e\x3e\x86\xdb\xed\x8c\x92\xfd\x1a\x08\x6a\x28\xbe\xbe\x4a\x1a\x00\xcf\x54\xc1\x71\x49\x25\x9d\xe6\x8e\x25\xf0\x6b\xf8\xad\xd6\x1e\xf0\xb1\x94\x24\x59\xe0\x3b\x6e\x67\x74\x3b\xba\x8d\x76\xa7\x99\x88\x5b\x30\xb1\x36\x8c\x57\xab\x4d\x08\xf9\x92\xf5\x36\xb9\x0d\xf5\x7a\x4a\xdd\x72\x1b\x52\xa4\xd8\xa1\xc5\xda\x1e\x5a\xa3\x26\x8e\x36\x6e\x07\x9d\x03\x05\x36\x6e\x5e\xc7\xcf\x3f\x45\x6c\x9f\x6f\xbf\xf4\xb5\xa5\xcb\x5e\x5f\xba\xf4\xb5\xe5\xcb\x5e\xbd\x74\x6a\xe9\xfe\xb2\xd2\xbb\xcb\x4b\xef\x2d\x2d\xb9\xbb\x14\x97\xf3\xdf\xdf\x60\xb7\x2e\xbd\xf4\xd5\x65\xa5\x77\x97\xcc\xbb\xa7\x94\xdd\x29\xe5\x81\xf8\x50\x15\x9a\x4a\x2b\xe8\x44\x26\x55\x46\xb6\xaa\x4e\x62\x2b\xea\x5c\xb6\x9a\x2e\x62\x2b\xe9\x71\x6c\x15\x3d\x97\xad\xa0\xeb\x58\x7f\x59\xc5\x66\x15\x7d\xc6\x57\x55\x4d\xae\xe9\x73\xe9\xa5\xfd\x57\x74\xab\xaf\xcf\x6e\xf2\xcd\x9b\x97\x5a\xae\x1e\x31\x42\x3f\x06\x85\x42\x74\xa8\x29\x2f\xcf\xd6\xab\xd7\xd0\x31\xe5\x4d\x2b\x6a\x54\xf1\xd3\x67\xb9\xe3\x67\xc5\xaf\x5e\x73\x49\x73\x43\xf3\x51\x70\x3d\x12\x1e\xd5\x50\x7c\xd9\xb2\xcb\xe4\xe4\xe0\x65\xbd\x6b\x17\xd4\xca\xc9\xc0\x02\xef\x9c\x19\x73\xe4\x64\xc2\x0c\xc7\xd4\x89\x53\xe5\xa4\x65\xa2\x38\xb0\xef\x40\x39\x89\xfb\x1a\x72\xba\xe7\xb0\x64\xc8\x11\xd6\x76\x6f\x58\xb6\x60\xc6\xc4\xbe\xdd\xbb\xf7\x9d\x38\x63\xc1\xb2\x06\x55\x69\x7a\x29\x1b\xbf\x5d\x87\xc2\xa5\xe9\xe9\x29\x2c\xf1\x50\x38\xdd\xf4\x97\xa3\x80\xb9\xed\x8e\x0c\xff\x5b\x9f\xed\x2d\xec\x2c\x8c\x75\xa9\xf6\x37\x1f\xdc\xce\xd6\x9f\x92\xdf\x2b\x18\xc8\x50\xbe\xad\xca\xb7\x53\xf9\x8e\xde\x57\x75\xb9\xee\xfa\xdd\xf5\x7e\xd7\xeb\xb4\x2e\xf0\xa3\xf8\xc8\x47\xbd\xfa\xf4\xe9\x75\x0d\xff\xf8\xbd\x20\xbf\x20\x3f\x95\xa7\xa4\x82\xde\xec\xef\x40\x41\x7e\x7e\x01\x9e\xc8\x3f\x5b\x13\xf8\x0f\x78\x5d\x7b\xde\xd6\xfb\x7b\xf5\xe9\xdd\x5b\xce\x0c\x2f\xf0\x7b\xd2\x2c\xfe\xf9\x3b\xcf\x7c\x0d\x4f\x91\x6b\xd9\x47\x36\xbb\x92\xde\x28\x28\xc8\xff\x94\x5d\xc0\x4e\x96\x98\xc1\x81\xb5\xb0\x0f\x78\xb4\x77\xb0\xb0\x75\x28\x4b\x5d\xdf\xab\x57\x1f\xec\x56\x32\x49\x84\x25\xce\xf2\x62\x6f\xf5\xe9\xd5\xa7\x3b\x4b\xc8\x67\xad\xb6\xd0\x24\xf2\x27\x8a\x63\xfd\x53\x4b\x0d\x46\x55\x4c\x5c\x09\xd9\x23\x8f\x0d\xf9\x53\x10\x3f\x16\x87\x2b\x6b\xdf\x6b\x90\xa4\x23\x8f\x48\x52\xdd\x3b\xe4\xcf\xa6\xf7\x17\x1c\x91\x24\x20\x8f\xd4\xbc\xd5\xc2\xfa\x0f\xf7\x0b\x78\x17\x5d\x27\x5b\x53\x7b\x43\x7a\xaa\x67\x0a\xc8\x0e\x36\x13\x5b\x4e\x33\x80\x0c\x64\xf4\x59\x1c\x37\xc7\x4b\x36\x43\x97\x1e\x92\x46\xd7\x5d\xa0\xcd\x2f\xb5\x34\x9f\x6c\x6e\x3e\xc1\x3e\x97\xd0\x75\xe7\x57\xe2\x41\xcd\x27\x9a\x59\x9a\xfd\xd8\xc2\xbd\xdb\xc6\xe2\xf0\xcb\x5e\x4f\x6d\x7a\xb7\xcd\xcd\x30\xa5\x41\xaa\xda\x07\xa6\x78\x86\xeb\xd4\xcb\xec\xbf\xcb\x03\x6a\x19\x63\x97\x3e\x9a\x71\x11\x0a\x26\x94\xde\x53\x52\xc2\x3a\xa0\xfc\x39\xf6\xaf\xe4\xb4\xdf\x63\x9f\xb1\xa4\xb1\x31\xa0\x16\x36\x90\x39\x64\x09\xe3\xa3\x8b\xeb\x0f\x9b\xca\xc0\xba\x6d\x42\x22\x71\xca\xfa\x83\x68\x43\x5a\xb3\xac\x3f\xb4\x17\x1d\x03\x64\xcb\xbf\x88\xe7\x32\x67\xa7\x13\xbd\x64\xce\x75\x25\x43\xeb\x87\xee\xac\x98\x3f\x7c\xd4\x98\xca\xe2\xe2\xca\xd2\x51\x63\xe7\xe2\x95\x0b\xaf\x1a\xd4\x30\x6c\xfe\xf6\x51\xc3\xe7\x17\x57\x56\x16\x0f\xaf\xa8\x96\x7d\xc6\x24\x22\x4c\x1f\xa4\xbb\x65\x1d\x96\xc5\x34\xc5\x30\xb4\x22\x64\x4b\xf7\x65\x07\x8a\x02\xbe\x61\x14\x31\x9d\x36\x9c\x29\xb5\xe2\x81\x7d\x8e\xb6\x9d\x39\xa2\x89\x1b\xd1\xa7\x4f\xbf\x7e\x83\xe4\xd9\x71\x7e\xa6\x3f\x93\x3f\xc0\x30\x85\x73\xfd\xfd\x42\x7a\xd3\x88\x7e\xfe\x7e\x7e\xd6\x88\x36\xf9\xe4\x92\xac\xfa\xd8\x97\x1e\xe5\x9e\x88\x75\x44\xd1\xee\x1f\x86\x69\xc3\x8e\xc7\x1b\x8a\x97\x06\xae\x15\x23\x07\x79\xed\xca\xc1\xde\xae\x5a\xb1\x40\x39\x97\xcd\x8d\xe1\xd3\x62\xd2\xa0\x9c\xbc\x94\x79\x92\x91\x78\x33\x98\xf6\xec\x01\xe3\x9e\x9b\xa5\x1f\xf6\xec\x91\x7e\xb8\xb9\xe8\xca\x9f\xaf\xba\xf2\xe7\x2b\xaf\xfc\x89\x7d\x5e\xf5\x4d\xa6\xc7\xd3\xbd\xbb\xc7\x93\x09\x0f\x47\x53\x52\x55\xdf\x95\x97\x8c\x5f\x51\xd8\xb7\xfe\x95\xe1\x8d\xd3\x72\xf0\xd8\x3d\x60\xba\x39\x5a\x98\x03\x63\xc5\xae\xfa\xe5\x0a\x5e\xfe\x97\xb8\x48\x91\x68\xd1\x4c\xe9\xa7\x4b\xfa\xf6\x1b\xdb\xf3\xc1\x6e\x43\x87\x21\x1a\xc3\x4f\xee\x11\x3d\x1f\x95\x86\xac\xee\x14\x87\xa9\x9b\x29\x25\x87\xaa\x91\xba\x00\xf5\x4e\xb2\xba\xac\x91\x67\x94\x69\xae\xdc\xfc\xfc\x40\x20\x9b\xaf\x4e\xec\x61\xa3\x0b\x8c\x8c\xeb\xe3\x02\x75\x81\x55\x01\xc1\x15\x70\x05\x38\xf3\x9e\xe5\x87\xbc\x67\x2b\x07\xf8\xa3\x4a\xad\xc3\x51\xe4\xc5\x78\x16\x39\xb0\x1f\x39\x4e\x23\xc4\xa4\x81\x5b\x72\x16\x64\xc8\xc7\x6e\xfe\xca\x22\xc8\xba\x08\x5b\x72\x7a\x4c\x6b\x18\xf9\x4a\x7d\x5f\xc6\x9d\x71\x2b\x0b\xff\xc2\x16\xe8\x1d\xc3\x07\xfe\x2d\x6d\x1a\x3a\x34\xf3\xc1\x9e\x9c\x21\xac\x7f\x27\xb4\x6d\xa4\x0f\x51\xaf\xec\x19\x7e\x6e\xc8\xda\x2d\x35\x39\x99\xe4\xc4\x99\x4c\x4e\x51\x4c\x20\xa4\x57\xbe\x33\x8b\xc9\x08\x5b\x21\x39\x9d\xa6\xe4\xd4\x64\x59\x5e\xc4\x9e\x91\x13\x50\xa4\x5e\x04\x51\x8c\x4b\x4a\x85\x54\x94\x3b\x3b\xc8\x0d\x93\xb3\xa2\x0f\x10\x3a\x79\x0a\x0f\x2a\x16\x02\x56\x67\x6f\xee\xc4\xc4\xc1\x43\xbe\x38\xf8\xe6\x8f\xc8\x23\xbf\x44\x3c\x9c\x64\xa8\x32\x0a\xd2\x33\x64\x77\x17\x19\xd6\x18\x86\x9c\xd9\x37\x6d\xfe\x88\xca\x69\x77\x04\xef\x28\xd6\x7c\xf9\xa5\x76\x18\x4b\x4c\xab\x1c\x31\x7f\xda\xbe\xe0\xbe\x61\xda\x2f\xbe\xd0\x14\xef\xbb\xe9\x8e\x4b\x2f\xbd\x63\x7f\x73\xf3\x7e\x72\xc5\x1d\xc3\xb4\x5f\x7e\xa9\x29\x8e\xc9\x53\xac\xf9\xe2\x0b\xed\x30\x96\x88\x40\x91\x96\x35\xef\xe7\x59\xf7\xcb\x76\x24\xfd\x51\x31\xb9\x9a\x5e\x83\x1c\x28\x85\xc9\x80\xc3\xe9\x10\x8c\x56\x2b\xd8\x3c\x66\x9d\x4e\xb0\x11\x7f\xaa\xcd\xe2\x40\x0e\xbe\xcd\x1b\x36\xb2\xec\x38\x81\x57\x5b\x17\x36\xb0\x92\x7a\x82\xd5\x6a\x9f\xdc\xf1\xd5\xf2\x34\x54\xf6\xe0\x10\x50\x24\x20\x1a\x1b\xc1\x59\xd8\xa9\xfa\x6c\x25\x12\xf5\x62\xc8\xfd\xf2\x71\x87\x85\x7c\x79\x13\x5b\x5b\x98\xfe\x55\xc3\x35\x07\x97\x2f\x3f\x78\x4d\xc3\x57\x5f\x8d\xf8\x2a\x7b\xfd\x9c\xb9\xeb\xd6\xcf\x99\xb9\x09\x2e\xfd\x97\xe1\x9e\xfa\xe5\x07\x0f\x2e\xaf\xbb\xc7\xf8\xaf\x11\x5f\x7d\x85\xfb\xce\x59\xbf\x71\xd6\xec\x0d\x6b\xf9\x1c\x67\x1f\x6a\xa0\x94\xbc\x8e\xec\x28\x19\xd5\x84\xe2\x1d\x28\x4e\x54\xab\xf5\x3a\x9d\x41\x40\x6e\x13\x32\xa5\xf8\x05\x03\xb1\x5a\x5d\x9c\x7c\x57\x38\xcf\x0a\x56\x22\xc6\xe9\x54\x21\x6e\x6b\x9d\xab\x26\x1a\xa2\x56\x13\x92\x24\x57\x86\xa0\x0e\x6b\xfc\x84\x93\x27\x0a\x0b\x4d\xcf\x2a\x7e\xcb\x3a\xfb\x72\x55\xce\x80\x58\x65\xc5\x06\xb9\x90\xec\x34\xe7\x02\x28\xfd\xbc\x20\xa6\x42\xfb\x0e\x2e\xaf\x9c\x00\xf0\x09\x86\xd1\xce\x02\x9b\xd4\x16\xe2\x95\x1b\xd1\x5e\xad\x9b\x96\x1f\x0c\x01\xd8\x0a\x9c\xd2\x61\xfc\x89\xd4\x36\xa1\x92\x57\xb1\xbd\x66\x7c\x9e\x59\xc9\xc6\x86\x4a\x7a\x2f\xab\x59\x5e\x28\x41\x6f\x17\x4d\x76\x73\xa2\x90\xe2\xd7\xc4\xeb\xed\xf6\xa4\xf8\xdc\xf8\xa2\x78\x12\x1f\x6f\xe2\x93\xcf\xc2\xdc\xd9\xca\xd1\x7b\x99\xf1\x5c\xfb\xf2\xe3\x10\x11\x9a\x32\x18\x4d\xf6\xe4\x7c\x46\x56\xd4\x45\x46\x01\x53\x58\x78\xf5\xd6\x45\x6b\xab\x37\x97\xf5\x5f\x9f\x76\x70\x7b\xab\x6f\xfb\xc1\xf4\xf5\xfd\xca\x37\x95\x6d\x5e\xb4\x95\xde\x3b\xf5\xad\xa9\x95\xd7\x8d\xab\x59\x5b\x98\xb5\xe1\xba\x3e\x7d\xae\xdb\x90\x55\xb8\xb6\x66\xec\x8e\x45\x53\xde\x99\x22\xd3\x55\xc2\xe8\x5a\xc8\xe8\xea\xce\xe9\x32\x27\xe8\xec\x09\x0e\x9f\x90\x95\x6d\xf0\x98\x13\x12\xb8\x5b\xb8\x22\x0f\xf1\x78\xec\x17\xa7\x4b\x1e\xad\x44\x55\x41\x54\x31\xfe\x95\xb8\xa0\x93\x4b\x0a\x1f\x9b\xa7\xac\x18\x3a\x24\x58\xb0\xe9\xae\xcd\x65\x03\x36\x2b\x44\xa6\x6e\x2a\x2a\xdf\x74\xd7\xa6\x82\xe0\x90\xa1\x2b\xe8\xbd\x03\x16\x85\x86\x6c\x48\x25\x5b\x16\xd7\xac\xed\x97\x19\x21\x35\xb3\xdf\xda\x9a\x86\xcd\x24\x75\xc3\x90\xd0\xa2\x01\x9c\x87\x6d\x6d\x8c\x87\x55\x28\x81\xc7\x1e\xb2\xc5\xe9\x05\x9a\xe8\xd6\xc8\xf3\x75\x4e\x52\xcf\x3c\xa1\x57\x7a\x46\xf4\x84\x7c\xc4\xd5\x36\x27\x90\x18\xb0\x1d\x8f\x69\x59\xff\xf5\x90\x86\x50\x78\xbb\x57\xf4\xee\x98\x1e\x6a\x18\xf2\x75\x4d\xb8\x37\x0c\x7d\x6d\x0f\x78\x6e\x2d\x6e\x08\xad\x2b\x2b\x5f\x1b\x6a\x1c\x76\xab\xf4\xe9\x86\x8d\x2d\x3d\x39\x5f\xd6\x33\x5c\x23\xd8\x5a\x45\xc7\xd7\x05\xa2\x3e\x4e\x4b\x23\x78\x22\x47\xca\x2c\xd6\xa0\xc5\x6a\xc7\xc4\x8f\xd7\xff\xf1\xa9\xfe\xd3\x3f\xf8\x07\x9e\x42\xc0\x2d\xbb\x00\x3e\x4b\xa4\xb3\xd2\x71\xe8\xcb\xd7\x6a\x09\x28\x9e\xdc\x4d\x2b\x91\x1b\xa5\x86\x8c\x16\x95\x2a\x8e\xb8\xe2\x5c\x1e\xaf\x68\xe5\x01\x02\x73\x83\x27\x73\x83\x9d\x1d\x86\xcb\x4e\x09\x32\xcc\x1d\x51\x4e\x9c\xe6\xa0\xd2\xfc\x2a\x62\xf3\x67\xd6\xce\xd8\x3c\x75\xd8\xcc\x2d\x93\xfa\x76\x4f\xd7\x2f\x9d\x36\xb6\x20\x0f\x4c\xe9\x8d\x83\xaa\xee\xf0\xb6\xde\x33\xb4\x6c\x68\x9f\x41\xe5\x4e\x32\xb4\x69\x79\xf8\x8e\xca\x11\x9b\x83\xbc\x4f\xd5\xb7\xbd\x4e\xfb\xb3\x39\x09\x7f\xe6\x75\x59\x68\xb4\xdb\xa1\xd3\x99\x3d\x6a\xb5\xcb\xec\xf2\x25\x6f\xd1\x82\xd6\xbd\xd9\x0d\xf3\xdd\x30\xd9\x0d\xee\x2d\x1a\xd0\x78\x32\x3c\x60\xf7\x00\xf5\x80\x27\x7e\x69\xd2\x96\x24\x9c\xe4\x6c\x71\x6e\x72\xe2\xa9\x4e\x70\xc6\x23\x51\xb4\x6d\xf1\x82\x37\xde\x50\x64\x03\x1b\xd3\x95\x8c\xfa\xd9\x96\x42\x36\x79\x0a\x72\x17\xc3\xfc\x5f\xfe\x56\xbe\x62\xcf\x61\xca\x27\xfb\xdb\x6b\x24\x74\xaa\x5f\x1a\x3f\x05\x95\x96\x2f\x90\x39\x91\x8a\xb5\xfe\x10\xad\x22\xbe\x72\xb3\xd4\x17\x9b\x5a\x7f\xc8\x96\x6b\x06\x0f\x4f\x68\xfd\x38\x5a\xcb\x21\xe5\x17\xc6\x0f\x2d\xc3\xff\x9e\x70\xe9\x04\x5e\xcf\x5d\x6d\x09\xb4\x40\x38\x21\xd7\x73\x43\xa8\x38\x1e\x25\x38\x30\x76\x5b\x49\x92\x45\x14\x8d\x3a\x55\x9c\x46\xa3\x62\x0b\xee\x64\x9f\xd3\x69\x75\xb8\x3c\x46\x8b\x57\xef\x4e\x00\xaa\x4b\x12\xd4\x7a\x8b\xc7\x41\x4d\x71\xea\x24\x9a\x40\x13\x35\xa6\xb8\x44\x8d\x26\x31\xce\x44\x6d\x2a\xc2\x16\x70\xcf\x1e\x8f\x7a\xd8\x73\xfe\xc5\x3f\x26\x7f\x05\x72\xbb\x3a\xda\xeb\xf0\xb7\xa7\x32\xfb\x59\x4d\xfd\x66\xee\xe2\x85\xbf\x83\xac\xa6\x41\x73\x81\x5d\x65\x2e\x10\xd8\x0d\x5a\xf0\xfa\x3c\xe9\xe9\x79\xaf\xb3\xbf\x79\x30\x90\x7f\x4b\x2f\x4b\x4f\xc3\xde\x52\xf6\xe1\xbc\x4e\xba\x01\x8a\xc2\x0f\x85\xe1\x8b\xd9\x0f\xcd\x86\x42\xe9\xbb\x9d\xb0\x48\x7a\xac\xf4\xa1\x52\xc9\x5d\xba\x05\xce\xee\x94\xe2\x99\x8c\x8e\x62\x7d\xb7\x54\x18\xc6\xf4\x65\x59\x28\x60\x37\x9b\x8d\x6a\xaa\xd7\x1b\x45\xad\x36\xce\x0a\xc6\x38\xa3\xd3\xa1\x33\x5b\xcc\xa5\x61\xb5\x45\x65\x47\xf6\xd2\x30\x77\x8c\x66\x41\x46\x6c\xd4\xcf\x0d\x1b\x2d\xdc\x8d\x59\x8c\x97\xa7\xbf\xae\x63\x82\x96\xd8\x63\xbf\x8a\xdb\xc3\x0e\x3f\xed\x8a\xbf\xb2\x51\x5b\x20\x03\x16\x4a\xbb\xf8\x1b\x57\x5d\x58\xbc\x65\xcb\x16\xf2\x27\x8c\x96\x0e\xff\xf3\xf1\x7f\xbe\x77\x16\x9e\xf8\xe7\xe3\x11\x3b\xda\x39\x08\x91\x3a\xd6\x3e\x56\x34\x39\xd4\xdd\x6a\x34\x9a\x21\x2e\x4e\xcf\x63\x2e\x30\x92\x6d\x76\x9d\xd1\x64\x1c\x1f\x56\x9b\x54\x56\x64\x1d\xcf\x08\x65\xda\x1e\xe1\x38\x3b\x0f\x31\x52\xa4\x04\x42\xeb\x4c\x5f\xd4\xef\x5c\xe4\x3b\x62\xa3\xd2\xe1\xb5\x38\x42\x1a\xcc\x59\x0e\xae\x95\xec\x4f\x3a\xb7\x7c\xf9\x72\x46\xd5\xeb\x52\x0e\xa3\x4a\x1a\x12\xa1\x0a\xda\xbe\x51\xf8\x97\x80\x46\x87\xe2\xac\x86\xf8\x78\x9d\x88\x90\x2b\xd1\xed\x34\xca\x6e\x07\x75\x38\xe2\x6b\x59\xd4\x59\x9c\x4e\x8b\x4e\xa4\x48\x4f\x50\xfc\xdc\xa8\xb7\xfb\xa8\xf3\xc5\x0e\xaf\x38\x11\x31\x0f\x9a\x95\x30\x9a\xfd\xf8\x39\xd1\x48\x1c\x4d\xd9\xc1\x9b\xfd\x0d\x75\xf7\x0c\x61\x8b\x3a\x7b\xda\x28\x0b\x64\xa8\xbb\xe5\xc4\x6d\x52\x2d\x9e\x6f\xc5\x55\xf8\xad\xc0\xc8\xcb\xaa\x8a\xe0\x78\xeb\x93\x81\x91\x37\x6f\x96\x2e\x3f\x1b\x39\xef\x87\xe4\xb8\x8c\xdc\x8f\x4f\x22\x1a\x1f\xca\x8c\xb7\x09\x82\x56\x2d\x3a\x8c\x46\x24\x22\xb7\x27\x9e\xce\x0d\x3b\xd5\x1a\x75\x69\xd8\xa6\x89\x67\x2f\x51\xa7\xb3\xce\x0d\xeb\x88\x68\xf9\x6b\xc3\x66\xc5\x7a\x12\x51\x46\x71\x1b\x8d\x7a\x9d\x33\x27\xfb\xa8\xc0\x7d\xeb\xca\x43\x39\x3f\xd1\xd9\x2c\x7d\xff\xe3\x73\xd2\x7b\x9b\x37\xc3\x19\x00\x88\x93\xde\x59\xb7\x6e\xf7\xdb\x6f\xef\x5d\xbf\x8c\xdc\xf8\xf2\x8f\x52\x2a\xc9\x7d\x09\x46\xbf\xf7\xf6\xa2\xd9\x95\x2f\xd5\x2f\x8a\xd0\xba\x45\x9a\x46\x5f\x62\xb4\xc6\x23\x1f\x9a\x12\xca\x72\xba\x5c\x36\xaf\x86\x10\xa3\x31\x39\x3e\xde\x66\x4b\x71\x62\xaf\x17\xcf\x0d\x7b\xbd\xc8\x64\xf2\xcc\x0d\x9b\x88\x5a\xd4\x8b\xf3\xc2\xfa\x44\x64\x51\x62\x60\x75\x76\x7f\xd2\xc9\xa0\x36\x22\x7f\xc9\xe0\x37\xdb\x94\xc3\x82\xb2\x67\x64\x46\x35\xd7\x8a\x9a\xa8\xfb\x64\xb2\x4a\xfa\xe8\x40\xfe\x00\xef\xd0\xd4\x65\xfe\xbb\xb7\xc3\x77\xa0\x06\xf1\x9a\x75\x30\x5b\xda\xbe\x62\xf3\x5d\x0f\x5c\xc0\xa4\xf5\xd4\xb8\xb1\x71\x9f\xab\xf5\x0f\x3c\x27\x2c\x7d\xe5\x9f\x5b\x9e\x6a\x77\xed\xcb\xe6\xd2\x0b\x22\xb1\xe0\x65\x8f\xbd\x01\xb6\x36\xd9\x19\x9a\x90\x81\xba\xe7\x65\xf6\xec\x2d\x18\x4d\xa6\xb8\x82\x1e\x3d\xf2\xe3\x44\xa1\x67\x1e\x52\x5b\x73\xb4\xc4\x45\xfa\x24\x5b\xad\x85\x7d\x32\x12\x7b\x0b\x42\xcf\x09\x61\x21\x93\xbd\x35\x82\xc6\xab\xf7\x3a\x26\x84\xbd\x0e\x53\xfe\xc4\xb0\xc9\x68\x40\x7a\x71\x42\x58\x6f\xea\x9e\x87\xf2\x26\x46\xbc\xbc\x28\xde\xc3\xe2\x8b\xba\x78\x8c\x52\x8e\x93\x44\xce\x5c\x75\x38\x43\x8e\x7d\xb1\xf1\x8d\x0d\xa6\xa6\x34\xab\x01\x54\x69\x96\x64\xa7\x35\x48\x1c\x2e\x50\x38\x42\xf8\xf0\xcb\x7d\xaf\x11\x3f\x7b\xb3\x41\x44\x90\xe3\x08\xf4\xca\x50\x15\x40\xd3\x65\x57\xc2\xad\xfd\x07\x0f\x54\x49\x1f\x14\xc0\xd5\x86\x69\xb7\xcf\xfa\x35\x33\xcf\xe7\x75\x75\xeb\xd6\xc3\xbb\xa0\x42\x2b\x66\x2f\x9e\x30\xe7\x76\x78\x7d\xce\xf0\xd1\x33\xa4\x3b\x12\xfa\x4d\x81\x99\xd6\x6e\xfd\x8c\xe6\x7d\x57\xc2\x04\x0d\xe8\x84\xd1\x23\x0c\x30\x08\x60\x95\xb4\x60\x8c\xf4\x91\x74\xe9\xcc\x61\xe2\x6e\x51\x2b\xd2\xaa\x8a\x71\x55\x56\x69\x1e\xd9\x83\xa5\xe3\xce\xed\xb3\x9b\x87\xa7\x83\x98\x0c\xaa\x51\x3d\x1f\xe6\x86\x5e\xa8\x9a\xf1\x73\x25\xe3\xa7\x97\xcd\x78\x66\x85\x72\xb4\x3e\x9f\x4d\xa3\x77\xb9\xdd\x5e\x7d\x92\x68\x30\x24\x02\xe3\x94\x3f\x25\x31\xd1\x69\x1e\x1f\x76\x3a\x28\xc5\x6a\x94\x1c\x07\x18\xc6\x87\xb5\x22\x36\x76\x98\xf0\x70\xff\x29\x11\x0b\xeb\x98\x3e\x16\x95\x8b\x48\xcf\x67\x02\xcc\x54\x53\x50\x3e\x55\xe9\x87\xe8\xb9\x51\xee\xf9\xd3\x0f\xe9\xf9\x50\xe0\x87\x11\xfb\x0f\x4f\x7f\xe0\xe9\xc7\x6e\x7f\xcc\xdd\x24\xfd\x22\x4c\x9e\xbc\x62\xdd\xd6\xe6\xd0\xb6\x19\xaf\xdf\x0e\x34\x03\xe2\x17\x2e\x24\x2b\x8e\xf1\xd0\x30\xb0\x43\xaa\x3d\xd6\xfa\xd8\xe8\xc2\xc4\xc7\x9c\x9a\x2c\xa9\x10\x07\x47\xae\x84\xa1\x5f\x44\xe6\x6f\x97\x4b\x55\xf4\x2e\x26\xdf\x46\x54\x1d\xea\x15\xa7\xd7\xaa\x8c\x46\xa2\xe7\xfb\xb9\x7a\x62\x36\x89\x30\x2f\xfc\x0f\x11\xee\x15\xe1\x52\x11\xfa\x8b\x40\x72\x45\x88\x13\x41\x47\xd9\xd8\x43\x8d\xda\x79\x4c\xdd\xc6\x1d\x85\xde\x87\xd4\x94\xf0\x41\xa5\x28\x58\x14\xe3\xb6\x68\xf6\x5c\xee\x83\x24\xa6\x87\xb6\x9f\xfb\x81\x8e\x30\x64\xdc\x20\xd9\x4f\xdc\xd2\x2e\xe9\x3d\xae\x6f\x21\xa3\xe2\xcf\x1d\x78\x60\xeb\xd3\xc2\xb0\xd6\x6f\xb1\xf5\xfc\xc1\xd6\x26\xd8\x2d\xd3\xb9\x8d\xd1\xf9\x0c\xe3\x7b\x02\x2a\x0e\xf9\xb5\x9a\x04\xd6\xf9\xb8\xa3\x5b\x8d\xc6\xee\x4e\x74\x20\xbb\x1d\x99\xb4\x7a\xbd\x6a\x7c\x58\x6f\x27\xa6\x89\x61\x62\x6a\xb7\xb4\x36\x1d\x37\x07\xa3\x0e\xdb\x38\x05\xed\x7e\xda\x94\x90\x25\x32\x05\xd1\x03\xd2\x9c\x24\x9b\x0a\xf6\x15\xde\xd7\x72\xd7\x5d\x8d\x3f\xde\x30\x61\x56\x25\xd3\xb2\xe0\x52\x93\xd2\x15\xf5\x27\xdf\x90\x4c\xad\xf7\xc0\x6e\xbc\xe8\xba\x96\x83\x5b\x5a\x9f\x10\x4e\x48\x0b\x17\x55\x31\xda\x36\x33\xda\x4e\xca\x3c\x1c\x1c\x4a\xd4\xc4\xc5\xa9\x3b\x18\xa8\x41\x40\x49\x2c\xab\x54\x9d\x59\xe5\x8c\xf5\xbd\x1e\x1d\x5e\x39\x15\x90\xac\x01\x99\x34\x9c\xb3\x4a\xe6\xcd\x21\x98\x26\xf5\x82\xe1\xbb\xff\x2c\x93\xbd\xed\x32\x06\xdd\x8d\xa7\xb5\x3e\xd1\xfa\x93\xc2\x22\x46\xc7\x01\x46\xc7\x95\xb2\xdf\xb0\xe2\x50\xaa\x51\x6b\x50\x53\xaa\xc3\x58\x30\x18\x04\xb3\x49\xa7\xc6\x84\x0a\xa2\xc6\x28\x22\xc1\x6e\x04\xd0\x8f\x8f\xba\xf2\x31\x1d\x2f\xe2\xfc\x71\x16\x76\xe2\x91\xb2\x8f\xdb\x99\x1a\x72\x63\x3f\xe9\xf4\x52\xce\x10\x58\x0b\x39\xd2\x7a\xf0\xd7\xfd\x08\x5f\x4d\x96\x16\x08\x27\x2e\xdc\x0f\x4f\x49\x33\xa4\xee\xad\xf7\x44\x68\x99\xc6\x68\x69\x90\xfd\x28\xf4\x0b\x79\x04\x00\x0d\x22\xa2\x16\xd1\x38\xbd\x46\x54\x89\x73\xc3\x2a\x42\xb5\x44\x3b\x37\x4c\x2c\xc0\xb8\x12\xa3\x2a\x63\xdd\x30\x2a\x56\xcd\xfc\x98\x83\x1d\x92\x69\xc3\x9f\x17\x4e\xe3\x5b\x5a\x0f\x90\x3b\x5b\x4b\xf0\x0b\x52\x15\xec\x7e\x8d\x5c\x75\xee\xe4\x85\xba\xa8\x1c\xe7\xd3\xbe\x0c\x5f\x9f\x90\x87\xe8\x74\x2a\x3e\x04\x03\xd5\xc7\xa9\xa8\x40\x27\x85\x05\x23\x56\x83\x7a\x52\x58\xc7\x2b\x7d\xfc\xe2\xc8\x32\x21\x8a\x8a\xd5\x74\x68\x6b\x31\xee\xdb\xfa\x3d\x99\xd0\xfa\x22\xae\xfa\xf1\x79\x7c\xd7\x4b\x2f\xb6\xce\x92\x37\xe4\x31\x1a\xd1\xf6\x0d\x1d\x22\xcc\x60\xe3\x57\x02\xf7\x94\x84\x2c\x86\x78\xd1\x20\xba\x13\xf5\x44\x63\x9f\x1b\xd6\x50\x62\x2c\xe1\x7e\xa2\x2c\xb1\x07\x29\xa2\xcb\x33\x1e\x29\x26\x9f\x4d\x12\x91\xd9\x84\x92\x03\xce\x02\x36\x79\x62\x23\xa9\x59\xd9\x79\x22\x8b\x2e\xbb\xf5\x57\xe9\x7b\x48\x02\xe1\xee\xcb\x56\xf5\x94\x74\x45\x0b\xfd\x83\x9b\x97\xac\x6c\x9e\x50\x01\x35\x30\x1c\x2e\x81\x45\x65\x97\xfc\xf9\xf8\x0b\x81\x3c\xfc\x7d\xf8\xfb\xb3\xa7\xff\x2d\xf3\x3a\x09\x21\x61\x0e\xbd\x84\xcd\x97\x72\x42\x4e\xad\x46\xe3\xb0\x3b\xe3\xd4\x1a\x2b\x99\x18\xb6\x9a\x34\x46\x75\xdc\xa4\xb0\x5a\xf1\xda\x54\x14\x1d\x84\x94\x63\x95\x11\x1f\xd5\x7c\x67\xde\xea\x70\x16\x81\xec\x4d\xd8\x49\xff\x74\x65\x7a\xba\xf5\xb4\x49\xef\x4a\x0f\x48\xd5\x90\xf9\x9a\xb1\x4f\x4a\xb7\xcd\xdd\xb7\x2f\x5e\xb6\x91\xf4\xb3\x98\x33\xfb\xb4\x12\xda\xb7\x75\x7b\xe0\x85\xe6\x35\xb0\x65\xcd\x8a\xc9\x11\x1b\x55\x46\xc3\x14\xc6\x93\x34\x14\x0c\x25\x24\x65\x68\xd4\xea\x74\x5f\x8a\x3b\x65\x6e\xd8\x4d\x69\x9c\x83\x98\xcd\x2a\x35\x01\x95\xec\x2b\x9f\xa9\x3e\x67\x61\x51\x8c\x69\x2e\x17\x34\x92\x41\xb8\xeb\xb5\xa0\x95\x2d\x09\x0a\x7a\x17\x58\x83\x8c\xa0\x82\xa8\x7f\x63\xa7\x4a\x3e\x41\x4f\x5e\x3f\x1b\x32\x8d\xb2\x5e\x7e\xf6\x8d\x3f\xc2\xa2\x56\xf0\xd8\xcb\x0e\x96\x65\x98\xb0\xa8\x0d\x58\x16\x2f\x2e\x2c\xeb\x5f\x92\x15\x9f\x90\xa8\x03\xdd\x00\x08\x8e\x6b\x7d\x93\xf5\x90\x91\xb9\xf7\xe6\xc6\x5f\x39\x0e\x26\x49\x07\xae\x99\x97\x78\xeb\x25\x70\xff\xee\x8d\xdd\x32\x1e\x4a\x0a\x0e\x96\x69\xd6\x31\x9a\xa7\x32\xbe\xf9\x51\x41\xc8\xed\x4e\x63\x9c\x4b\xa5\x71\x56\xa2\x36\x79\x7c\x2e\xdf\xc4\xb0\xcb\x64\x32\xa9\x35\x46\xe0\xcc\x0b\x46\x14\xb6\x2c\x31\xce\xc2\x58\xba\xd3\x33\x8c\x20\x13\xee\xb0\xf7\xea\xcd\xc8\x76\xf6\x6a\x27\x3a\xc2\x5d\xf2\xe1\x99\x6d\x36\x95\xe8\xbc\xe6\xf4\x91\xf7\x27\x59\x93\x76\x1c\xb8\xd2\x63\x2f\x70\x94\xce\x29\xae\x0e\x96\xdb\xdc\xe6\x64\xbf\x0e\xde\x09\xa5\x25\x8c\x93\x7a\x30\xae\xde\xba\x7b\xa4\x58\x03\xcf\x49\x85\x8b\x47\x5e\x0f\x75\xdb\x1b\x33\xb3\xee\x35\x5b\x0a\x06\x46\xe6\x22\x43\xd9\xbc\xe9\x6e\x46\xaf\x8b\x51\x3c\x31\x94\xeb\x50\xa9\x92\xe2\xac\x09\x09\x29\x5a\xa2\x61\x4c\xd6\x90\xd4\x34\x93\x7b\x42\xd8\x64\xd2\xaa\xc7\x87\x53\xd8\x78\x9d\xa2\x65\x9d\x8e\x88\x68\x52\x58\xb4\x13\x23\x8a\x6a\x9c\xac\xe8\xe1\x97\x8e\xa9\xbf\xec\xbd\x37\x6d\xa0\x1c\x20\x94\xf0\xb0\xbf\xe9\x1d\xfb\x20\x4e\x87\x93\xf4\x52\xdc\x1b\xf7\xc6\xf3\x8c\x83\xde\x80\x74\x69\xb6\xf4\xc0\x3f\x96\x0e\xb8\x4c\x9b\xb4\x73\xcd\x82\x35\x93\x4b\x7a\x27\x78\xa7\x07\xdc\x89\x06\xd3\xe8\x57\xfa\xbd\x89\x67\x9d\x3f\x0e\x3f\xf4\xd8\xd3\xdd\x3b\x75\x7c\xf3\x96\x65\x95\xb3\x57\x17\x6c\x1f\xd7\x88\x67\x8f\x48\xf3\x78\xbb\xe7\xf6\x54\xc6\x1d\x56\x17\xa7\xec\xb3\xa5\x28\x94\xc6\xd5\x25\x22\x1a\x35\x1f\x6f\x3e\x14\xe1\x25\x11\x76\x8b\x30\x4b\x84\xd1\x22\x74\xe7\x7b\x58\x44\x51\x9a\xac\x0d\x22\x9e\xad\xba\x3e\xc8\xe3\x2f\xea\x6c\xbd\x81\x6b\x4a\x5c\x19\x1d\x40\xf8\xfc\x5c\xc5\xf0\xa8\x99\x5e\x50\xa1\x1e\xa1\x78\x10\x04\x11\x8b\x1a\x35\xd0\xf1\xe1\x55\xb0\x8d\x8d\xcb\x20\xaa\x8c\xa2\x5d\x01\xdd\xc5\x4d\x8c\x1c\x07\x07\x27\xc3\x39\xc9\x25\x7d\x4e\xfb\x4a\x93\x9f\x94\x7a\x32\x48\x18\x65\xb2\xfe\x7f\x3b\x9d\xc8\x26\x3e\x3e\x2e\x39\x71\x5e\xad\xc9\x24\x3a\xd9\xe4\x35\x39\xc5\x96\x30\x21\x6c\x33\x69\x4c\x5e\x13\x31\x8d\x0f\x13\x47\xcc\x99\x89\x18\xf7\xc1\xdc\xae\x9a\x75\x7f\x1f\x32\xf7\xb2\x70\xa7\xa0\xb2\x37\x3f\xce\x70\x8b\xb2\x07\x6d\x1e\x08\xf4\x76\x36\x2b\x39\x2b\x9d\x92\xce\x1d\x7f\xc3\x3e\xbb\xb2\xbe\xf6\xde\x7d\x7b\x9f\xfe\x3a\xd4\xaf\xb0\xcf\xd2\x46\x9c\x2f\x7d\x28\x7d\x00\x09\x90\xf0\x05\x38\x7a\x3d\x1c\xff\xe2\x9e\xc7\x8e\xa8\xb1\xf3\xf8\x09\xe9\xd4\x6f\x07\x8e\xd5\x2c\x6f\xfd\x5a\x7c\x01\x61\x28\x45\x63\xc9\x02\xf2\xa1\x12\xab\xd0\x48\x11\xf7\xab\xa0\xd6\x88\x8c\x52\x1e\x4c\x3a\x1a\x8b\x39\xa6\xd2\xf9\x69\x76\xf9\x5d\x8a\xd5\xad\xff\xc6\x6a\x9c\xfd\xcb\x3f\x7e\x69\xad\x60\x1f\xf2\xf9\xa3\x22\xf2\x38\x7a\x46\x89\x77\xe7\x0b\xc5\x51\x41\x50\xb3\x8e\xaf\x11\x58\x03\x01\xca\x3d\x59\x98\x1b\x8c\x39\x7d\x6b\xf5\x9b\x83\x84\xcd\x61\x9e\xb9\xfc\xf2\x53\xfb\xf7\x93\xc7\xb1\x59\xba\xfb\x26\x59\x8e\xdb\x0e\x90\xdf\xe0\x4e\x25\x86\x62\x4a\xc8\x20\xc8\x41\xe2\x80\x4d\x6b\x31\x66\x8b\x91\x4e\x80\x2c\x72\xfc\xe6\xfc\x20\xc9\x00\xe7\xe4\xfd\xfb\xd3\x4b\xe0\xd2\x12\x21\xef\x26\xa9\x7b\x29\x2c\x29\x63\xb0\xa4\x7f\xd3\x99\xa0\xe9\xa0\x49\x0e\x06\x27\xaa\xa9\x06\x88\x4a\x44\xb9\xc1\x13\x81\x8e\x19\x77\x04\x92\xd3\x9e\x9c\xcf\x20\x1d\x6e\xfd\x9e\xc1\xf9\x76\xfd\x7a\x04\x0a\x8c\xc7\x90\xc0\xfd\x05\x70\x99\x20\x08\xa9\x04\xee\x51\x22\x78\x22\xa6\x46\x7c\x70\xc8\x0f\x82\xa6\xf5\x7b\xb8\x62\x23\x9d\xb9\xfe\x03\x2e\xc7\x6d\xa4\x95\x9c\x54\x0d\x45\x1a\xce\x61\x4c\x88\xc0\xa0\x68\x75\x3c\x84\xa9\xba\x3d\x84\x69\xfb\xb8\x2a\x0b\xab\x3c\xa4\x05\x81\x9c\x94\xbe\xba\x55\xfa\x12\x26\xa6\xc2\x74\xe1\x94\xe4\x83\x33\x6e\xb6\xbc\x3c\xf4\x17\x98\x6a\x81\xdb\x66\x32\x98\x6c\x34\xc7\x2a\x7c\x11\x98\x1a\xf0\x43\xe4\x10\x08\x83\x79\x57\xaa\x74\x3f\x38\x6f\x05\x87\x30\x52\x3a\x04\xa3\xdd\xdc\x6b\x15\xdf\x4b\x7d\x83\xdc\x89\xff\x50\x45\xf8\x94\x19\xb2\x60\xca\xe3\x2f\xaa\x35\xc0\xa7\x27\x3c\x32\x21\x89\x78\x9f\x89\x7a\x2e\x6a\x1f\x7f\x23\x11\x16\xf1\x7b\xd1\xb8\x8a\xc2\x78\xbc\xe2\xfc\xfb\x72\x34\x45\x74\x11\xb8\x22\x80\xc0\x44\x42\x8d\x31\x50\x2a\x32\xb8\x70\x71\xb8\xc9\x4c\x53\x72\xb8\x7f\x48\xef\xfb\x3e\x4f\x90\xce\x30\x28\x2b\xe0\x1e\xe9\x27\xe0\xbb\xb7\x6f\x00\x83\xa9\xb4\x69\x76\x14\xa6\x5a\xc3\x60\xaa\x54\x0c\x26\xa8\x8e\x42\x36\x2a\xfa\xef\x80\x85\x0e\xb0\xac\x9d\xf7\xb1\x76\xee\xc5\xda\x59\x83\xd2\x43\x26\x2e\xbd\x1a\x8d\x16\x78\xac\x46\x41\xe0\xe1\x78\x4f\x14\xe6\xf2\x89\x4f\xa4\xc1\xa3\xbe\x0f\x14\x2b\x17\x69\x1f\xbe\xfa\xd3\x8d\xb7\x6e\x14\x1e\x5b\xff\xfc\xf3\x1f\x70\x58\x0c\x60\x2f\x98\xcb\x60\x75\x0b\x99\x45\x42\x54\x98\x01\x53\xe9\x58\xa5\x19\x99\x1a\x1e\xdf\x9f\xc1\x50\x1e\xd1\xb7\x3b\x31\x88\xd8\xc7\xd8\x93\xa5\x7d\x0c\xd4\xa7\xad\xf5\x30\xf7\x83\xe7\x9f\x5f\x2f\x9f\xc7\xf9\xb7\x54\x83\x1f\x6c\xdb\xc9\xba\x66\x7c\x48\x83\xd4\x54\x45\x61\x35\xe6\x12\x9c\x70\x32\x20\x8f\xd7\xbc\x31\x32\xb8\x57\x48\xfc\xe0\x27\x97\x35\x7f\xda\xfa\xb4\x54\xb3\x6b\x17\x64\xf0\x36\x78\x07\x0c\xf8\x77\xa6\x99\x38\xbf\x92\x58\x1f\x90\xdb\x56\xa3\x16\xb8\xa7\x40\x36\x74\x3d\x1b\x88\x65\x51\x97\x88\x92\xc4\xc7\x97\x08\xad\xdf\x45\xa2\x47\x62\x3e\x23\x20\x7b\x69\xa6\x0c\x8b\x3f\x4f\x54\x74\x06\xc2\xdc\x1d\x0c\xef\x4e\xb1\xda\x42\x71\xa9\x92\x83\x1b\x5a\xb7\xe2\x06\x32\xea\xf4\xe9\xd6\xf7\x4e\x9d\x92\xf7\x45\xde\x80\xd7\x59\x1b\xae\x91\x6d\x39\x78\xb7\xa0\x40\x62\x6d\x39\x78\x58\x55\x59\xa6\xe0\x75\x72\x90\xe7\x7f\x93\x14\x29\x6d\x6e\x3b\x12\xc9\xcf\x37\x49\x3a\x17\x78\xe7\x8c\x1f\xd2\x58\xbe\xab\x64\x2f\x70\x88\x0e\x12\xbe\x62\x73\x1e\x17\xf2\xa0\x71\xa1\x4c\xbd\xd3\xca\x7a\x2e\x4e\x70\x3a\x3d\x0e\xec\xf0\x26\x25\x26\x4c\x9a\x99\x88\xb4\x46\xb6\xf2\x02\xee\x2b\x76\x7c\x38\xde\x2a\x18\x9d\x20\x0f\xe6\xc1\x60\xc7\x8a\xb5\xd3\x31\x50\xb9\xb1\x22\x5c\x8a\x46\x08\x8b\xc6\x78\x0b\xf2\x89\x61\x72\x1a\xaf\xf0\x73\xd2\x17\x3b\x76\xdc\xb3\x7b\x7e\xd5\xa4\x81\x05\x3d\x4f\xc3\xcd\x7c\x46\xcc\xdf\x64\xc5\x85\xf5\x6c\xd1\xb5\xf8\xa6\xdb\xdd\x47\xad\xc3\x26\x4d\x3b\x76\x61\x3d\xed\xfb\xcc\x2b\xaf\xb0\x31\x23\x96\xde\xc1\xa1\x64\xbd\x43\xa6\xd6\xe1\xc2\xae\x84\x44\x67\x27\x32\x19\x95\x0e\x85\xca\x0e\x22\x3b\x87\xa2\xfb\x3b\x02\xb9\xec\x77\x21\x6e\xfd\x45\xa9\x12\x4e\xfc\xd9\x4b\xf6\x9f\x09\xa7\x21\x1d\x7f\x47\xdf\xb3\xa4\xf3\xb0\xc9\x66\x15\xfd\x19\x21\xe9\x30\x1b\x2b\x8d\x30\x5c\x05\x53\x54\xc0\x56\x43\x3e\x55\xbd\x0a\x1f\x6d\x6b\x0b\xe9\x55\x2a\x4c\xd2\x40\x35\x5e\x35\x8f\x49\xc5\x6c\x73\x3e\x64\xc9\x6e\x26\x79\xfb\x19\x84\x3b\xc9\x31\xf1\x53\x14\xc7\xda\x5b\xe4\xae\x2d\xb5\xe4\x28\x4c\x62\xb5\x38\x39\x3b\xd0\xee\x14\x3b\x18\x79\xf2\x40\x8e\x3d\x72\xdb\x6d\x8f\x9c\x1c\x35\x68\xc0\x38\xf1\xd3\x1b\x6e\xdf\x7f\xed\x90\xe9\x53\x87\xb5\xb5\xa1\x7b\xd1\xb5\xd4\x4f\xdf\x33\x65\x08\x6a\xe9\x04\x42\xfc\x1b\xf2\x65\xaa\xbe\x63\x28\x56\x72\xd9\xc6\x2a\x35\x2c\x51\x83\x59\x0d\x3e\x35\x30\x9a\x0e\xa9\x35\x44\x4c\x8b\xd2\xc1\x60\xe4\xb7\xbd\x46\x77\xb3\xfa\x88\x82\x59\xf6\x79\xc9\xe3\xa4\x1c\xe5\xd7\xb4\x4d\xbe\x66\x33\x3f\x7a\x39\xc3\x21\x0a\x38\x91\x5f\x8f\x67\xd7\x2b\xe5\xfc\x44\xbe\xbf\x8d\x5d\xf7\x93\xaf\xb5\xf2\xf5\xe2\xb6\xe7\xe8\x2c\x71\x0d\xbb\xd6\xc9\xd7\x8b\xe4\xe7\x1d\xfc\xbe\x5e\xbe\xbe\x84\x5d\x27\xc9\xd7\x4e\xf9\xba\x80\xfb\xee\x91\xaf\x5d\xf2\x3c\x67\x32\xbc\x48\x5b\x68\x0b\xeb\x4d\xdd\x42\x7a\x36\x4e\x46\xe6\x39\x18\xf0\x51\x98\xf2\x50\x18\xe8\x51\x18\x8d\x8a\x9e\x8d\x59\x8a\xc4\x4c\x68\x5a\xce\x9f\x82\x4d\x60\x86\x2b\xe0\x45\x36\x55\xb9\x4f\x9a\xcc\xe0\x3b\xdb\x7e\xa3\x47\x85\x8f\x59\x7b\xc5\xcb\x9c\xf9\x37\xf0\x35\x40\xf7\x50\x12\x78\xa6\x7b\x36\x7b\x70\xba\x07\x9a\x3d\x30\xcc\x73\xd8\x83\x6d\x9e\x67\x3d\xbf\x78\x48\xb2\xc7\x6f\xb5\x45\x58\xb4\x98\xb5\xd9\xc5\x60\x48\xdc\x1f\x68\x46\xc8\x06\x9e\x2d\x9e\x47\x3d\x58\xe5\x69\xf1\x60\xbb\x67\x8a\x07\xa7\x78\x18\x93\xbf\x38\xe4\xf1\x27\xba\x15\x26\x9b\x15\xbf\xab\x9d\x60\x98\x32\x22\x74\xc8\xf2\x53\xd9\xa6\x42\xd7\x86\x06\xfe\x17\xf4\x60\x7d\x36\x3c\x9a\x0d\x19\xd9\xd3\xb2\xdf\xc9\x26\xbd\xb3\x8b\xb3\xb1\x3d\x1b\xd6\x67\xc3\xd3\xd9\xf0\x71\x36\xc3\xfa\x69\xa8\x47\x76\xb6\x60\x4d\xc3\xd9\x73\xb3\x61\x51\x36\xcc\xca\x86\x97\xb2\xa1\x47\x36\xbc\x93\x0d\x77\x66\xc3\xb5\xd9\x77\x66\xe3\xc3\xd9\x40\xb2\xa1\x30\x1b\x8c\xd9\x80\x78\xf5\xf8\xff\xec\xc5\x8b\xdb\x45\x53\x16\x8b\x68\xcd\x7b\xe6\x5d\x8c\x6e\x5e\xf7\x18\xba\x1d\x9d\x79\x30\x8c\x71\x81\x44\xb8\x10\x4a\x95\xd9\xf0\xff\x98\xf0\x28\xdd\xae\x36\x97\x2c\xc7\xe9\x5c\x8e\xcd\x22\xfd\xee\x2b\x84\x8c\x0f\x42\xc2\xd1\xb6\xf0\xa1\x84\x04\x83\x35\x2d\xcb\x2c\xcb\xbf\x8b\x8d\x72\xb1\xf9\xbe\x67\xf9\x52\x43\x26\x60\xd5\x81\x62\xcf\x46\x0f\x16\x3c\x30\x99\xd7\x27\x7c\xc8\xe3\xe1\xc5\x62\x71\x28\x7d\x25\x52\x96\xf1\xa4\xed\x46\x09\xd0\x68\x36\x6f\xbe\xd2\x0f\xe5\x7e\x98\xe1\x07\xa7\xbf\x9b\x1f\xb7\xf8\xa1\xd8\x0f\x82\x9f\x41\x39\x10\x4a\xf4\xfb\x19\x18\xf0\x9b\xfc\xab\xfd\x57\xfb\xf7\xfb\x5f\xf5\x0b\x21\xff\x78\xff\x3c\x7f\xbd\x9f\xa2\xd9\xb1\x15\xca\xe7\x91\x20\x39\x8d\x63\x18\x9e\x55\xb2\xce\x41\x0a\x9e\x81\x6d\x07\xb9\x17\x16\x98\x6e\x85\xe1\xd6\x23\x56\x6c\xb7\x6e\xb0\x32\x95\xf3\xc3\x21\xab\x15\xe9\x65\x1a\xe5\xc2\xac\x2c\x8f\x27\xed\x94\xcb\x82\x52\xd6\xcc\xe0\x2d\x0d\x4d\x87\x23\x5e\x10\xbd\xf0\xb6\x17\x86\x79\x37\x78\xef\xf0\x7e\xe6\xa5\x36\x2f\x4c\xf4\x02\xf2\xfa\xbc\x79\xde\x79\x5e\xda\xe2\x05\xd2\xe4\x05\xec\xf6\x7a\xe3\x5d\x69\xe0\xad\x62\xd7\x0b\xd9\x75\x8e\x17\x4e\x78\x41\xe5\x85\x8d\x5e\xd8\xe5\x85\x7d\xde\x37\xbd\x78\x22\x2b\x80\x8d\xde\x22\x2f\xd3\x73\xb3\x65\xf9\x99\x3d\x77\xf1\xdc\xc5\xbc\x36\x73\x23\x1b\x5b\xfc\x37\x4e\x54\x8c\x4e\x49\xe7\x3a\x45\xa6\x69\x5c\xdb\x7c\xe4\x09\xd9\x61\xba\x0e\x8e\xe8\xa0\x58\x07\x76\xdd\x06\x1d\xf6\xeb\x74\x4c\x7f\x76\xe8\xaa\xa8\xee\x49\xe7\xba\x47\x2e\xd7\xc6\xca\x25\x84\x34\xf8\x88\x15\x8a\xad\x1b\x39\x0b\x7e\x61\x2c\x20\x02\x2f\x24\xb7\x11\x77\x92\x4e\x06\xca\xb8\xe8\xf8\x48\x99\x74\xc6\xbb\x81\xa1\x74\xae\xaf\x1f\x91\xf5\xf5\x7a\x15\xf8\x55\x3b\x55\x3f\xab\xc8\x04\x15\x20\xa6\xab\xcf\xa8\x88\x53\x05\xc4\xaa\x62\x5a\xa7\x6d\xf6\x21\x15\x5b\x13\xa5\xb5\x57\x83\xd5\x8c\xeb\x04\x36\xf8\x93\x73\xf4\x4f\x06\x57\x08\xca\x70\xa5\x57\x19\x2d\xf9\x21\x1f\xdc\x69\x03\xb0\x4d\xb7\x81\x68\x2b\xb6\x35\xdb\x88\xdd\xb6\xc1\x76\x87\xed\xb0\x8d\xfa\x6c\x79\xb6\x79\x36\x72\xb4\xed\xba\x43\x36\x9b\x5a\x1d\x95\x24\x14\xa9\x5b\x29\x5b\x23\xad\xa2\xdf\xb1\xba\xa9\x64\x39\xfc\xf9\x8f\x83\x4c\x0e\xcd\xb0\xd9\x07\x2d\xbe\xfd\x3e\x5c\xec\x7b\xc4\x87\xa7\xfa\x98\x08\xfd\x74\xc8\xe7\x13\xe2\x14\xb6\x44\xea\x88\x8b\x95\x3a\xaa\xa3\x75\x44\xf7\xa1\x21\x87\xe0\x17\x2d\x68\x8f\xb6\x9d\x79\xd8\x91\x30\x82\x7f\x87\xf4\x06\xeb\x08\x9f\x16\x4c\x6c\xe8\xd4\xca\xc2\x68\xd4\x32\xad\xcd\x46\xa8\x24\x15\xac\x52\x6d\xe3\x83\xd4\x62\x45\x00\xb3\xb2\x3a\xe4\x6f\xa5\xb4\x8a\x5e\x22\xc3\xd7\xe4\x46\xe0\x6f\x66\x75\x4d\x66\x72\x9e\x60\xbc\xdc\x88\x1f\x35\xc2\x74\x23\x0c\x31\x82\xcf\x08\x26\xa3\x11\x8b\x11\xda\x22\xf5\x8a\x8e\x0f\xe9\x7c\x7c\xe0\xf5\xba\xf7\x20\x1a\x14\xca\x81\xe9\x0e\x68\x71\x40\xa5\x03\x86\x39\xc0\xe2\x80\x7f\x3a\x00\x39\x7c\x8e\x3c\xc7\xd5\x0e\xda\xcb\xe1\xd0\x1a\xd2\xc0\xb1\xca\xb1\xcd\xf1\x8a\x83\xcc\x73\xc0\xdf\xf4\x8b\xe8\x58\x93\xce\xc7\x1a\x0e\xfb\x66\x13\xf2\x87\x12\x60\x28\xef\x12\x79\x56\xb0\x59\xc1\x6f\x05\x64\x9d\x67\xc5\xa9\x4c\x2a\x62\xe9\x6a\x93\x18\x5d\x55\xf4\x34\x2b\x1b\x17\x29\x3b\xf8\x20\x2a\x64\x65\x6f\x4f\x7d\x24\x15\xaf\x4f\x85\xb2\x54\x18\x92\xba\x33\x15\xf7\x4c\x05\x7f\x2a\x58\x52\x19\xbb\x7e\x0b\x69\x53\x53\x55\xea\x34\x48\x65\x97\xa8\x13\x45\x11\x7a\x98\x46\x27\xf7\xc8\x75\x35\x2a\xf2\x59\xc6\x64\xad\x3b\xd3\x91\xc3\xad\xe0\xb0\x3e\x62\xc5\x53\x78\x3f\xbd\xdd\xfa\xa9\x15\xfb\xac\x0c\xe2\x27\x4c\x58\xa9\x26\x4a\x96\xac\x53\x4c\x4c\x0e\x36\xc9\xbc\x36\x45\xe8\x32\x1c\x64\x6b\xe6\x6e\x78\x73\x2a\xa8\x52\x87\xa7\xe2\x47\x52\xa1\x3c\xf5\x50\x2a\x6e\x4a\x05\x6b\x2a\x7c\x9a\x0a\xab\x53\xc1\x97\xfa\x54\x2a\x46\xa9\xa9\x76\x37\x03\xb5\x58\x7e\xcd\x8e\xf6\xb5\xc5\xac\xed\x66\xc9\xf0\x2c\x11\x78\x97\x6d\x64\x1a\x2a\x11\x5a\xac\x70\xa7\xf5\x6d\xeb\xe7\x56\xe2\xb4\x1e\xb6\xe2\x5f\xac\x30\xcd\xba\xce\x8a\x0b\x38\x59\x1f\x84\x12\xac\x56\x51\x97\x06\xd6\x3a\xeb\x2d\x56\xfc\xb8\xf5\x25\x2b\x36\x5a\x73\xad\x45\xd6\x57\xad\x5c\x47\x2d\xee\xa8\xba\xdc\xc6\xdc\xa6\x61\x89\x5c\x6f\xab\x32\x36\xac\x61\xf5\x9e\xc9\xea\xfd\xa7\x0b\x2a\x5d\xcd\xae\xb7\x5d\x44\x70\xc1\x30\x17\x4c\x72\xad\x73\xb1\x3e\xf5\x74\x28\xdd\xe5\x42\x42\x1a\xb8\xc6\xb9\xea\x5c\xf8\x32\x17\xcc\x76\xc1\x95\x2e\xd8\xe8\x82\xdb\x5d\xf0\xaa\x0b\x5a\x5c\x4c\xf5\xb8\xd8\x94\x96\x2b\x11\xae\xe7\x17\x47\x91\x2e\x8e\x69\x7f\xca\xf0\xb6\xc8\x78\x95\x31\xa9\xad\x9b\xf4\x3b\x9b\xdb\x26\xc3\xa3\x89\xb0\x24\xf1\x8e\x44\x6c\x4b\x04\x5b\xe2\xd0\x44\x9c\x92\x08\x25\x3c\xe2\x09\xfb\xcf\x4b\x1c\x9f\xc8\x3a\xe1\x57\x21\x47\x62\x22\x9f\x9d\x25\x8e\x4b\x9c\x9b\x88\xef\x48\x84\xa2\xc4\x50\xe2\xd5\x89\x04\xcd\x56\x84\x6d\xb1\xd2\xd9\x23\xb8\x96\x33\x3e\x2e\x95\x71\x39\x22\x7c\x14\xdf\x45\x23\x43\x36\x3c\xda\x09\x5b\x9c\x30\xdd\x09\xf1\xce\x02\x27\x6e\x76\x1e\x77\xb2\xfa\xbd\x1f\xf2\x38\x9d\xc8\x98\x86\x9d\x45\x4e\xc8\x75\xc2\x72\xe7\x15\x4e\x7c\xad\x13\xee\x70\x1e\x76\xe2\x37\x9d\x10\xd1\x91\x1d\x12\xa4\xe0\x88\xce\x8d\xd2\xf9\xdc\x48\xae\xcf\x14\xa5\x9f\x5d\x6e\x04\x17\xef\x65\x47\x8d\x78\xa8\xdc\xcf\xf4\x5d\xfb\x99\x3c\x4e\xcb\x65\xe3\x63\xc6\xe7\x45\x6c\x9e\xa3\xf7\xc1\xa3\x3e\xc8\xf0\x4d\xf3\xbd\xe3\x23\xbd\x7d\xc5\x3e\x6c\xf7\xc1\x7a\x1f\x3c\xed\x83\x8f\x7d\x91\xf1\x97\x29\x14\x36\x24\xf9\xe6\xfa\x60\x91\x0f\x66\xf9\xe0\x25\x1f\xf4\xf0\xc1\x3b\x4c\x97\xf9\xe0\x5a\xdf\x9d\x3e\x7c\xd8\x07\x6c\xe1\x53\xe8\x03\xa3\xef\x3f\x8c\xbf\xb1\xf3\xb9\x74\x3e\x9f\x93\xe9\x28\x60\x75\x18\x1b\xca\x84\xe9\x6e\xf8\xdd\x0d\xa2\x1b\xee\x74\x1f\x77\x63\x8b\x7b\x89\x7b\x83\x9b\x0c\x71\x43\xa1\x1b\xd2\xdc\x40\xde\x76\x43\xb9\xfb\x90\x1b\x33\xf6\xfd\x11\xd2\xba\xdd\xea\xb8\x34\x70\xcf\x77\x2b\x1d\x6d\xee\xec\x18\xf5\x2b\xcf\xc3\xd9\xe2\xeb\x3b\xb1\x98\xe1\x61\x52\x60\x12\xe9\x8f\x28\x66\xac\x14\x1e\x54\xc6\x4a\x91\xfe\xf6\xac\x3c\xee\x5b\xe5\xc1\xd1\x02\x42\x74\xdc\x97\xf5\x92\x9c\x2f\xa2\x97\x7e\x7b\x42\xce\xe7\x38\xda\x76\xec\x90\xc3\x6e\xb4\x44\xf3\xc9\xb2\x2d\xe7\xb3\x46\xf2\x3d\x2d\xe7\x73\x1d\x6d\x7b\xfc\x90\x2b\x5e\x13\x27\xe7\x63\xf3\x56\xb6\xb0\xa4\x0f\x88\xdb\x90\x19\x8d\x08\x25\x22\x41\x10\x8d\x04\xcc\x26\xad\x8e\x02\xe8\x4c\xc4\x6a\xc1\xd4\x28\x8a\x66\xaa\x7d\x02\xc6\x22\x33\x5c\xc2\x4a\x50\x96\x2a\x92\x1f\xb5\xb0\x59\xac\xec\x2f\x3e\xfa\xa4\xcf\xe2\x54\x76\x5f\xe4\xf8\x82\x03\xa1\x08\x92\x55\x06\x50\x41\xf2\x3f\x76\x81\x61\x14\x94\xe7\x66\x33\x8d\x69\x77\x99\x16\xaf\x83\x89\xd2\x33\x34\x19\xd7\x4a\xa3\x5a\xdf\xca\x5c\x79\xcf\x07\x3f\xdc\xf6\x7e\xa3\x24\x32\x7a\x2e\x7c\x49\x9f\x44\x54\x0c\xb0\xf5\xb6\xf9\xb0\xc0\x68\xd0\x70\xbf\xe3\x51\x9b\x79\x7f\x0a\x55\xf9\x7b\xa7\x26\x07\x29\xfd\x5a\x3a\x32\x67\xc3\xa5\x70\x19\xc4\xc5\x0b\x47\x9a\xd7\x1e\x3b\xcc\xd6\xd6\xad\xf4\x49\x12\xaf\x94\x65\xdc\xd5\x41\x4c\x59\x12\xf4\x51\xa7\x3f\x3d\x35\x0b\x48\x3c\xe8\x61\xd5\xa5\x1b\xe6\x48\x47\xbe\x66\x98\x0e\x1f\x5b\xdb\xcc\xf0\x5e\xa0\x8c\xe1\xc2\xab\x6c\x5d\xc3\xd6\xe5\x6c\x89\x64\x60\x3a\x51\xa7\x66\x4b\xd9\x40\x61\xd4\x9c\xde\x1c\x31\xab\x54\xf9\xe5\xdd\xf3\x79\x0f\x14\xcf\x5c\x3c\xd0\xb2\xc3\xf7\xe1\x63\x2d\xef\xd0\xf3\xce\x4c\x67\x4e\x60\xdb\x4a\x99\xa7\x88\x3e\x4b\x04\x06\xcb\xc0\xfd\x46\xb2\x61\x91\x69\x55\xa2\x22\x3a\x6e\x2e\x63\xee\x80\x16\xb1\xc2\x0c\xca\x5e\x8a\x33\x4a\x1e\x1c\xb6\x7e\xad\xed\x1a\xd7\xa2\x87\x96\x5d\x72\x60\xba\x70\x63\x7c\xf7\x5e\x43\x2a\x17\xe7\xa7\xd8\xf9\x9a\xeb\x61\xa9\x1f\x89\x6b\xdb\xc3\x7d\x09\x1f\x66\xeb\x75\x91\xfb\x56\x32\x3e\x32\x13\x61\x53\xc4\x17\x69\xd4\x55\x34\xe4\x5b\x93\xed\x04\x1e\x0e\x03\x1c\x96\xfa\x25\xc3\xe0\x34\xe9\x69\x4e\xcf\x2b\x74\x2f\x69\x15\x9e\x61\x6d\x9c\x15\xd2\xc7\x19\x04\x6a\xa0\x56\x4b\x9c\xc0\x9d\x7a\x5a\x18\x18\xcd\xd6\x30\xba\x06\x45\x42\xda\x76\x72\x73\x9b\x03\x3c\xe8\x3f\x37\x29\xe5\x64\xe2\xf9\x5b\x1f\x9c\x2c\x9c\x21\xfe\xa1\x97\x8c\x1d\x9a\x42\xce\x08\x93\xee\xa7\x7b\x07\x34\xd7\x17\x0e\x72\xbb\x07\xf7\xa9\x6b\x19\x20\xef\x07\x3c\x4c\xab\x49\x1c\x5b\xdf\x0b\x28\xfe\x30\x22\xa2\xec\xe9\xd1\xf8\xd0\x4c\xbe\xc8\xbf\x18\x99\xb4\x3a\x4a\x26\x2b\xfb\x04\x7d\x9c\x38\x45\xaf\x5c\x96\xa0\x88\xc7\x64\x56\x56\x88\x2d\x6b\x27\xc9\xf9\x4c\xf7\x87\xa5\xb6\xc3\xa2\x37\x59\x3a\x96\x06\x03\xe5\xf5\xd7\xc3\xd2\x34\xb2\x87\xf6\x65\x75\xec\x1e\xb2\x9b\x54\xd6\x38\xb6\x12\xb3\x58\xb9\x55\x86\xc9\x48\xb5\x13\xc3\x34\x11\x75\xda\x05\x90\x77\x1c\x05\x5b\xc4\xc0\x33\x5f\x5e\xae\xca\xee\xb5\xf6\x2c\x7e\x6d\xcb\xb8\x7d\x3d\x36\xaf\xaa\x9d\x25\xed\xc1\x2b\xe2\xd6\x3c\x5a\x9a\x60\x7e\x3d\x65\xe1\x22\xd2\x70\x8c\xd3\x38\x0c\x8f\xc5\xfc\x19\xa0\x16\xe5\x86\x9c\x1a\x15\xd1\x6a\x75\x7a\xcd\x47\x48\x45\x28\x39\x17\x66\x7d\x83\x52\xd5\x87\x3c\xe2\xa8\x12\x58\xaf\x28\x6a\xec\x11\x89\x4b\x9e\xcf\x5b\xdc\xec\xc7\x06\xeb\xca\xc2\xbe\xab\x5d\x87\x9f\xa4\x9b\xd2\xf3\xef\x18\x1c\x68\x95\xbd\x97\x4e\xc4\x63\xc9\x52\x61\x02\x72\xb3\xbe\x98\x9a\x00\x89\x56\x95\xd5\x1b\x67\x00\x83\xc7\x6b\x8c\x83\x0c\x12\x17\x67\x4a\x30\x69\xce\x86\x4d\xa7\x20\x01\x25\x7c\x1e\x46\x1f\xa1\xa2\xae\x31\x64\x3a\xc7\xfd\xe1\xbc\x66\x8d\xc7\x6d\xb2\x64\xc9\xcd\x88\xec\xf5\x1b\xa8\x2a\xd9\x0e\x13\x93\xea\x27\x8c\x2b\x1a\xe7\xcb\x70\xa8\x0e\xf9\xfe\x5c\xb7\x2e\x67\xf8\x94\xf1\xa1\x38\x98\x83\xc7\x6e\x1b\xd1\xd4\x33\x6f\x4c\xee\x4c\x26\x84\xda\xef\x1a\x2a\x06\xcc\x18\xd6\xbb\x67\x20\xe9\x7a\x14\xa9\x7f\x21\xd9\xc2\x68\xec\x86\x56\x85\x46\x24\xba\xdd\x62\x5a\x8a\x39\xc5\x6e\xb6\x77\x57\x89\x7a\x24\xa2\xcc\xee\x89\x89\xe6\xf8\xa4\xf8\xb3\xe1\x34\x93\x39\x24\xef\x20\x9c\x51\x51\xa4\x32\xa9\x7c\xaa\xa7\x54\xaf\xaa\x04\x0d\x51\xa9\xb4\x26\xb3\xe9\x6c\xd8\x6c\xd6\x26\x9d\x22\xda\xb3\x61\x72\x3a\x36\xd4\x88\x52\x91\xc5\x66\x25\xfe\x54\x7c\xd7\x50\xb6\x96\x58\xa3\x6e\x25\xd0\x4a\x3e\x37\xa1\xc8\x6f\xb7\x76\x54\x65\x44\x1e\xfa\x72\xeb\x4e\x36\xf9\xdf\xb2\x7b\xe3\xaa\x6d\xf1\x27\xd5\xdd\xb3\x26\x0e\x1a\x91\x99\x36\xb4\xb7\xd7\x9f\x9d\x22\x3c\x6d\xda\xbc\x76\xc5\xc6\x21\xc3\x26\x8e\x26\xae\xea\x96\x85\x2b\x13\xfa\x16\x55\x05\xf3\xd6\xe5\xf5\xe9\xd1\xbd\x4f\x6f\x7d\x43\xc3\xa2\x39\x83\x27\x26\x88\x96\xb2\xc8\xfe\x67\x26\x1e\x43\xb6\xc9\xed\x6e\x46\x43\x42\x3e\xa3\xbc\xfd\xa7\x51\xf3\x0d\x11\xc1\x6a\x41\xac\x4b\x7d\x1e\x56\x0b\x3a\xd1\x60\x00\xf1\x43\xf8\x28\xf2\xa4\x81\x1f\x9c\xe9\xb0\xf8\xe1\x72\xc0\x6a\xa3\x98\xaf\xd8\xfd\xf9\x7c\x7f\xd8\x1c\xb4\x73\x2f\xf8\xc1\xfc\x5e\x64\xc0\x93\xd2\xbd\x30\xe8\x8d\x89\xd2\xaf\x99\x3d\x67\x3f\x88\xbf\xd9\xbb\x77\x17\x3c\x2b\x0d\xbc\x0e\xfe\x31\x7a\xf2\xc6\xe3\xbd\x22\x76\x48\xe3\x71\x88\x5c\xc6\xe8\x70\xb3\x79\x4a\x0f\xa6\xac\x9c\x16\x8b\x8d\x4d\x7a\x1c\x2a\xa6\x17\x90\xe8\xf5\x30\xee\x5a\xad\x4c\x4e\xce\x86\x13\x12\xb4\x36\x9b\xf3\xf3\xb0\xed\xc3\x58\x26\x77\x0a\x14\x6e\xe9\x88\x13\xdc\x6e\xaa\xf2\x17\xde\x2a\x21\xef\xb8\x07\xde\x64\x15\x17\x20\x72\xd9\xf6\x75\x4b\xb7\x5a\x9f\x57\xa7\x25\x67\xa6\xa5\xe5\xf6\x4e\x38\xda\x03\x5e\x96\xde\x34\x65\xcf\x99\xdf\x42\x86\x2c\xdb\x52\x33\xdf\x98\x9f\x59\x14\x1a\x50\xd0\x0d\x1e\xb9\xfe\xb6\x9c\xcb\x64\xba\x43\x4c\xb6\xaf\x62\x74\xeb\x51\x4e\xc8\x41\x05\x41\xab\xd1\xc6\x69\x98\x9a\x8d\x43\x5a\x9d\xf6\xf3\xb0\xee\x43\xfa\x91\xf2\x74\x38\x6a\x44\x12\xdd\x49\x37\x60\xbb\xbf\x17\x93\x62\xde\x3b\xaf\x5a\x3b\xa3\xdb\x4b\x39\xe5\xcd\xd2\x32\x3c\x96\x1e\xbd\xe7\xce\xbb\x1b\x16\x3d\x78\x70\xc7\xf5\x88\xc0\x10\xc6\x17\x2e\x97\x5a\xe4\x40\xb9\x9c\x37\xbe\xec\x4c\xc1\xef\xf7\x64\xb2\x71\x40\xe7\x74\xf6\x34\x7b\x3c\x79\x3d\xb3\x7d\x3e\xb5\x41\x6d\x38\x1b\x56\xab\x6d\xe9\xe9\xe4\x6c\x38\xfd\x54\x82\x8d\x71\xaa\x2b\x6f\xf8\xb3\x53\x85\x8e\x08\x5f\x64\x73\xf2\x68\x38\x11\x39\xc4\x99\xbc\xc3\x65\x8d\x39\x49\x50\xa0\x98\x04\x16\x74\x36\x2e\x66\xeb\xce\xbb\x12\xbb\x0d\x4e\x4d\x4a\xf1\xd9\xb3\xb3\xbb\x67\x75\xcf\xe9\xd1\xed\xc4\x35\x5b\xb7\xed\xda\x56\xd4\x7f\xdb\x65\x6b\xb7\xf6\x1b\x34\x7e\x10\x6d\xec\xd6\x6b\x56\x76\x6e\x96\xf4\x7b\x61\xcf\x9e\xfd\x86\x06\x72\x0a\x1b\x9b\x5b\x16\x5f\xed\x27\x49\x93\xfb\xcf\x58\x50\x3d\xab\xff\x64\x0f\xb1\x44\x62\xac\x48\x7b\xa5\x1d\x6d\x8f\xb6\x95\xc8\x3e\x7c\xf8\x89\xb2\xab\x66\xf2\x53\x6f\x20\x87\x65\xe3\x9b\xb4\xd2\x5e\x70\x49\x3b\x5e\x79\x85\xe7\xf5\xd3\xbb\xda\xde\x16\xce\x33\x89\xf5\x72\xbd\x6f\x10\x90\x56\xc0\xaa\xd5\x7a\x03\xdf\x6e\x3e\x11\x80\xdc\xdc\xa8\xef\x57\xa6\x1e\xa2\xca\x81\x5b\x81\x07\x7a\xbf\xb6\x65\x48\xbe\xae\x7f\xe8\x86\x9b\x1f\x59\xd1\x7f\x9c\x30\xa5\x8f\xb6\x46\x3f\x61\x74\xbd\x3d\x50\xcb\xcf\xc1\x35\xb3\x11\x6e\xb9\x1c\x3f\x28\x2f\x14\x8f\x04\x95\x40\x00\x88\x4e\xab\x56\x8d\x0f\xab\x8d\x88\x12\x3a\x3e\x4c\xec\x31\xba\xa9\x3d\x56\x52\xcf\xbc\x34\x26\x44\x3c\x76\x10\x6b\xcb\x04\x28\x39\x7f\x1e\xae\x90\x3e\xc2\xfd\x8e\x1d\x3b\x86\x8f\x1d\xe3\x7e\xbd\xa4\x97\x85\xc7\x20\xa0\xca\x52\xfc\x9d\x58\x1e\xd1\x69\xb0\x28\x0a\xfc\x11\x0d\xe3\xff\x89\x40\xc4\x5e\x46\x60\x6f\x1e\x67\x14\x54\x7b\x19\x3f\xf6\xee\x7d\x09\x97\xb7\xde\x24\x3c\xb6\x7b\xf7\xee\xf7\x2e\x67\x30\xfe\x60\x30\xcc\x0c\x06\x3f\xe7\x16\xc7\xe4\xcd\x06\x84\x88\x3a\x9d\x56\x64\x9d\x43\x6b\x50\xeb\xf5\x04\xe9\x54\xf2\x2e\x77\xd0\x1c\xec\xea\xe3\x0c\xec\x2a\x7f\x7e\x81\x55\xc1\x02\xe6\x73\xd7\x6e\xfa\x26\x82\x45\x95\x65\xba\xde\x70\xa3\xb4\x8d\xa1\x41\x7f\xa1\xd5\xc4\xf1\xb0\xf5\x29\x32\x30\xe1\xb6\x98\x4c\xa2\x41\xdf\x99\xf2\x40\x74\xe8\x8f\xda\xaf\x29\x18\x0a\x82\x0c\x61\x46\x7e\xd0\x19\xad\x8c\x74\xe3\xab\xcf\xbc\x76\xe3\x75\x91\xea\x68\xb7\x5d\xa5\x1f\xc2\x71\x7d\xcb\x70\x09\xed\x75\x4a\x0f\x99\xe2\xb0\x5e\xaf\x16\x34\x1a\xa3\x56\x14\x09\x62\x7d\x29\xb6\x3e\x51\xbf\x61\x4e\x3b\x03\x1d\xf5\x9f\xe3\xd9\x74\xed\x39\xed\xde\xbd\x50\xcb\xab\x72\xa3\xe1\x7a\xd3\x7b\x72\x4d\x70\xa7\x7a\xb8\x43\x3a\xf9\x48\x26\x55\x47\x9f\x8c\xf1\xc7\x12\x72\xe8\xbf\xc8\x73\x35\xde\x82\xe3\x18\x95\xab\x14\x9e\x33\x8e\x73\x18\x4f\x0b\x87\xa1\x48\x86\x91\xc8\x46\x60\x1b\x8e\x27\xfa\x78\xb5\x29\xa4\x31\x8c\x30\x99\x6c\x36\x02\x4f\xe9\x69\x44\xea\x18\xa8\xdc\xac\x60\x10\x72\x83\xb9\x8a\x4b\x59\x21\x25\xe2\x38\xdf\xcf\x83\x34\x38\x1d\xca\xac\x48\x7a\x99\x23\x80\x07\x83\x93\xa7\xa4\xf6\xe8\xa1\x9e\xa9\xcb\x1a\x53\x54\x30\x69\x52\x4a\x5e\x96\x38\x4b\xdf\x7d\xb4\x2a\xeb\xf2\x6f\xd2\xd3\xfc\xdd\x26\x8e\xe8\x96\x96\x9e\x9e\x36\x61\x54\x46\xa4\x7f\x14\xd0\xcd\xf0\xa2\x30\x97\xc9\x0e\x93\x79\xd6\xf5\xf5\x54\xad\x46\xac\xe9\x31\x6f\x87\xe0\xc9\xe8\x83\x1f\xd9\xa1\x3d\x8f\xbe\x25\xbf\xe1\xc5\x19\x19\xb9\x6f\xe7\x76\x63\xef\x8c\x19\xc2\xdc\x77\xea\xd8\xdf\x3b\x91\xe7\xd7\x91\xb9\xd3\x2f\x91\x79\x21\xd5\x1a\x8c\x1a\x61\x35\x3f\xc3\x15\x48\x50\x9e\x91\x44\x27\x4a\xdc\x8e\x8d\xcf\x92\x2a\x37\x1f\x9c\x21\x9e\xd1\x1e\x38\xa0\x3d\x23\x86\x1f\xa4\x7b\xc7\x5c\xb5\xfc\xf9\xe7\x97\x6d\x1d\x23\xf3\xf9\x45\x99\xcf\x82\xec\x45\x58\x23\x30\x71\x64\x22\xa2\x23\x3c\x5a\x81\x55\x6f\x19\x41\x48\x11\x1a\x87\xe6\xa2\x83\xe8\x49\x96\x87\x3b\x5e\x1c\x8e\x8a\x4e\x9e\x98\x5d\x98\xdb\xc9\xdd\xb1\xdc\xa8\xfc\x21\x65\x22\x6b\x50\x3c\xa4\xf5\x26\x5c\x1e\x69\x4f\x69\x4f\xa4\x2d\x62\xf1\xe4\x1d\x02\x15\x15\xff\x06\x85\x4a\x1d\x83\x22\xda\x22\xb2\xfc\xf3\x10\x39\xb2\xec\x4b\x0f\xf3\x66\x88\x88\xfe\xbb\x97\xa3\x4e\x6d\xed\x44\x1e\xd4\x2f\xe4\x75\xd9\x6c\x49\x6e\xb5\xda\x4b\xad\x7a\xbd\x29\x21\x81\x9f\x05\x18\x17\x7f\x4b\xfc\xc1\x78\x21\xde\xa4\x46\x47\xa1\x18\x15\x05\x64\x14\x66\x1e\x96\x3c\xf6\xd1\xf1\x45\x1b\xde\x2a\x13\xb0\xea\x6f\xda\x7d\x12\xa3\x49\x38\xdc\xb9\xe5\xa1\x99\x53\x17\xe9\x93\x1d\xb4\x71\x4b\xea\x82\x90\xd3\xad\xf6\x78\x7c\xf1\x2e\x46\x64\xb2\xcb\xe3\xb1\x51\xbd\xde\x9b\xa8\x36\x29\x64\x05\x4e\x04\x38\x4d\x81\x58\x35\x10\xfc\x5b\xca\x0a\x94\x2e\xfb\x77\xb4\x8d\x8c\x74\xe0\xae\xe4\x7d\x14\x51\x18\x98\xe9\xa5\x3f\x61\x9a\xdc\x47\x34\xfc\x79\xb8\x1a\x04\x4a\x79\x6f\xd3\xf2\xa7\xd8\x28\xf7\xc3\xc0\xb3\x1d\x87\xbc\x98\x5c\xf1\xa7\xea\x6c\x9e\xe6\xcf\xb7\xce\x67\xbd\xf6\x98\x74\xe0\xda\x9f\xc5\x9d\xbb\x4d\xd2\x69\x36\x91\x44\x9d\xfb\xad\x1e\xf5\x0f\xf9\x18\x24\x36\xac\x6a\xe2\x44\x41\x30\x50\x6d\x48\x67\x1d\xa1\xd5\xea\xf5\x90\x4b\x8a\xc8\x38\x42\x88\x5a\x0e\x8f\x14\xe9\x7e\x31\x78\xda\x9f\x97\x47\xf5\xd0\x84\xbd\x7b\x8b\x23\x2a\x88\x61\x7b\x37\xa2\x80\xba\xea\xe5\x82\x50\x82\xa0\xa5\xac\x77\x71\xea\xb5\x71\xdc\xde\xa2\x1d\x8d\x4e\x66\x2d\x6b\xf0\x40\x67\xb6\x46\x1e\x6d\x46\x38\xa8\xea\xaa\xbc\x19\xaa\xdd\xbb\xcf\x5d\x1e\xe9\x73\xd1\xf1\xc5\x8c\xc2\xa1\x3c\xc4\x4d\x5e\xb0\x46\x67\xa4\x2a\x41\x50\x59\x2d\x44\xa7\xd7\x4d\x0a\x23\xa3\x3e\x49\x8f\x4d\x44\xaf\x57\x99\x94\x49\xbe\x5a\xa5\x1e\x1f\x56\xd9\xff\x3a\x27\x8e\x31\x0a\xb7\x74\x58\x9c\xc9\x86\xd6\xf2\x60\xc4\x9f\xaf\xc9\x03\xd2\xe9\xd3\x91\x21\xe9\xd4\x29\x3e\x28\xe1\x1d\x2f\x49\xbf\x1f\x3b\x06\x9a\x97\xbe\x3a\x16\x59\xa3\x17\xb7\x7d\x43\x4f\xa8\x06\x58\xd2\x49\x29\x7f\xa6\xa0\xda\x8b\x7e\x80\xc5\x66\x95\x66\x14\xa0\xb6\x5f\x51\xea\x11\x82\x73\x43\x16\xcb\x88\x5c\xde\xd9\xe2\x4c\xa6\x11\xb9\x21\xad\x7e\x44\x2e\x2d\x34\xa7\xa3\xac\x7c\x73\x56\x56\x96\x12\x9f\xad\x2b\x9c\x5b\x61\xd4\xff\x0a\x9c\x03\xe8\xf3\xff\x15\x38\xf7\x43\xe8\x7f\x00\xe7\x36\x05\x4e\x3a\xbe\xfe\x95\xdf\xcd\x2a\xd5\x5e\xa0\xf0\x36\x4a\x0c\x99\x29\xe9\xc7\xc1\xf4\x0b\x69\xb4\x23\xfa\xe1\xb4\x68\xe9\xfc\xfc\xbf\x2f\x7b\x2b\xa4\xfc\x1f\x97\x3d\x80\x3e\xfc\x3f\x2e\x7b\x3f\xfa\xe3\xbf\x51\xb6\x85\x95\x5d\xa7\x1a\xc8\xca\x2e\x50\xe4\xa1\x15\x1a\x38\xdf\xd8\xcd\xdf\x18\xdf\x30\xb8\x78\x61\x57\x94\x6f\x2e\xce\x37\x17\xf1\x77\xe5\x5b\x57\x38\xb7\x42\xea\xff\x0a\x9c\x03\xe8\xcb\xff\x15\x38\xf7\x43\xda\xff\x00\xce\x6d\x0a\x9c\x76\x79\x40\x7f\x46\x78\x4b\xb0\x8f\x83\xf1\x71\xde\xfa\xc0\x78\x31\xde\xde\xd6\xc1\x13\x5e\xca\x2c\x72\x18\xbc\x2c\x06\x1b\x2f\x6b\xe3\x65\x6d\xc4\xf7\x9f\xcb\x1e\xf8\x1f\x94\xbd\xff\xff\x47\xd9\xad\xac\x6c\x99\xdc\x8f\x9a\x15\x79\xf8\x35\xd2\x8f\xd0\x8f\x0a\xdf\x22\x15\x8e\xf2\xcd\xc7\xf9\xe6\x23\xdd\xbb\xf2\xad\x2b\x1c\xde\x0b\xfe\x37\xe0\xb4\xeb\x87\xff\x21\x9c\xfb\xff\x47\xf4\xdc\xa6\xc0\x61\xf2\xf0\x6d\x44\x3f\xa4\x46\xe5\x21\x9b\x83\xc9\xe6\xbc\xcd\x06\xc7\xc5\x78\x7b\x5b\x0c\x4f\x06\x47\xda\xe5\x5b\xa5\x5d\x12\x78\xd9\x04\x5e\x36\x81\x64\xfc\xe7\xb2\x07\x40\xec\x5c\xd6\xcd\xcb\xba\x79\x59\xf7\x7f\x55\x96\xd7\xfd\xbf\x5b\x56\x1e\xc7\x38\xdf\xf8\xee\x2e\xe3\xd7\x10\xd8\x84\xae\x45\xea\x87\xb1\x15\xf3\x7c\x8a\x5d\xfe\x34\xd9\xc6\xd8\x8d\x8a\x42\x3e\xb6\x78\xa5\x16\x8b\x15\x59\xbd\x1e\x87\xc1\xe5\x32\xcc\x0d\xbb\xa8\x8d\x58\x2d\x82\x0a\xab\x4a\xc2\x38\xb1\x23\x24\x6d\x6c\x68\x6e\x65\x44\x13\x4c\xc9\x29\xd1\x9d\xac\x0e\x33\x77\x3b\xdf\x09\xb1\xd8\xe9\x10\x69\xe1\xf4\x9a\x71\x79\xe5\xe3\x26\x94\x4c\xae\x90\xde\x03\x5b\xde\x0d\x15\x07\x5e\xb4\x48\xd5\xd6\xd7\x75\xf5\xab\x48\xf2\x6d\xdb\x6e\x58\x7f\xe1\x3e\x61\xd8\x9d\x33\xe7\x49\xdf\x9d\x8b\x8c\xc3\x9b\x18\x6d\xc5\xf2\x99\x98\x81\xa1\x24\xab\x43\xd0\x6a\xd9\xb0\x6b\x42\xa6\x04\x97\x4e\x6f\xe5\x11\xe1\x89\xc9\x22\xaa\x88\xaa\x34\x4c\x3a\x48\x0b\xb6\x5b\x98\x07\xdb\x8d\x20\x05\xbe\x36\x66\x0b\x91\x40\xef\x01\xfc\x74\x2a\xa7\x0b\xd8\x2a\xd9\x9c\x4c\x8b\xd7\x6c\x2c\x2f\x0e\x8e\xc8\x97\x32\xdc\x52\x1b\x4c\x80\x75\x2a\x23\xc0\xea\xdd\xdb\x35\xc7\x69\x51\xd9\x40\xf2\xc3\x85\xca\xd6\x7a\x61\xd8\x85\x27\x07\x9c\x19\x00\xe7\x38\x4d\x23\xda\x7e\xa6\x1b\x19\xbf\x3c\x8c\x5f\x49\x16\x83\xc7\x63\x14\xe3\x8d\xf1\xde\x24\x64\x44\xc6\x44\x53\x22\x99\x1b\x4e\xb4\xda\xb5\x73\xc3\x76\x6a\x22\xa8\xcb\x29\x95\x18\xd3\x4c\xbe\x90\x94\x37\x37\x06\xc8\xcb\x79\xd1\xc3\x3d\x34\x71\x5e\xf9\xcc\x76\x6e\xb1\x49\xa0\xc4\xb7\xbc\xae\x79\xe9\xc2\xb5\x0d\x9b\xa4\x37\x7f\xec\xf7\xcc\x4a\x78\x5d\xfa\x55\xfa\x51\x1a\xb7\x00\x5e\x58\x5d\xfb\xd9\xd9\xe9\xaf\xdc\xb5\x67\xf5\x23\x78\x3f\xe3\x57\xeb\x8d\x13\xa5\x3b\xa4\x7b\x61\x2f\x9f\x93\x9d\x46\xf3\x21\x99\xd4\xca\xfb\x10\xfe\x90\xc6\x2c\x08\x4e\x1d\x8a\x37\xa8\x1f\x87\x7e\xc8\x86\x08\x0c\x40\x8a\xc3\xf6\x40\xc7\x2e\x96\x2f\x12\x41\xbd\x53\xa4\xf1\xe4\xab\x77\x48\x67\xae\xb8\x7e\xe7\x15\x87\x7b\x0c\x28\xca\xcd\x1d\x30\x20\x17\xbe\x7e\xe2\x79\x58\xff\xc2\xe3\x4f\x3e\xbb\xad\xb6\x66\xfb\xf6\x85\xf5\xb2\x3d\xd9\x30\xb4\x18\x3d\x4e\xca\x90\xc8\x63\xe3\x20\x51\xc4\x58\xc5\x6d\xf2\x1e\x93\x4f\x6f\xf6\xe7\x07\x10\xda\xad\xd3\x7a\xe6\xc9\xe7\xf8\x82\x66\xf1\x9f\xaf\xdd\xb1\x18\xcf\x58\x74\xf9\xf2\x56\xd9\x5e\xee\x43\xd4\x00\x69\x8c\xe6\x44\x1e\x1b\x27\x51\x65\xb1\x78\x5c\x7a\xe4\xd6\x69\x8c\x9c\x68\x57\x04\x4e\xa0\x48\x9e\xba\x07\xa2\x47\x06\xd2\x3a\x36\x16\xdb\x77\xdb\x0c\xc0\xb7\xfb\x93\xed\xd2\x87\x9e\x05\x0b\x4a\x82\xf3\x66\x98\x1e\x31\xef\x58\xb1\xf9\xea\xee\x63\xe6\x66\x8f\xb7\x41\x43\xc3\xe2\x7e\x8d\xe3\x47\x15\x27\x4d\xad\x50\x37\x34\x2e\x9e\xdf\x73\xf2\xb8\x61\xbe\x90\xef\x0a\x79\xdd\xf6\x06\xaa\x84\x1e\x8c\x86\x14\xd6\xae\x8e\x24\x8b\x05\x25\xbb\x44\x83\x5f\x87\x50\x6a\xb2\xc1\x60\x34\x92\x78\xbb\xfb\x28\xf4\x7b\x48\xa3\x22\x47\x65\x1e\x72\xdb\x2e\x6e\x20\x69\x89\x1a\x69\x07\xf8\x0a\x3b\x76\xef\x8a\xc7\xaa\xeb\x25\xef\x0a\x76\xd9\x14\x54\x39\xa0\xc7\x35\x3b\x37\xee\x8d\x3b\x62\xac\xa9\xbf\x7a\x70\xd1\x9a\x60\xcf\x1e\x85\xf4\xb0\xf1\xfa\x65\xeb\x76\x6d\xbc\x1e\x86\x57\x2d\x5d\xba\xc8\xb8\x60\xee\xcc\x2b\xc2\x99\x39\x81\xdc\xb8\xaa\xa6\xda\xb9\xab\x7a\x24\xb3\xb6\xfd\x07\xe3\xd3\x50\xc6\x6b\x7e\xf4\xb5\x7f\xc8\xa9\x06\x30\xc5\xe9\xb0\x56\x6b\xe1\x3e\xc7\xd9\x3c\x55\x6d\x34\xe2\x38\x91\xb3\x1e\x47\x58\x6f\x91\x17\x3c\x1d\x93\xe0\x00\x27\x92\xcf\xb7\x63\x36\xff\xf2\x0b\x44\x55\xf0\xdd\x03\xd2\x76\x98\xf1\x74\x8d\x74\x0e\xe2\x8f\xbe\x02\xaa\x5d\xbb\x96\xc3\xc7\x52\xda\x1a\x98\xef\x73\xfb\xdb\x38\x7f\x5e\x67\x72\x95\xcb\x70\x27\xa2\x60\xc8\xe4\x14\x2d\x16\xb7\x5d\x8f\x90\xc7\xe8\x72\x11\x87\xf5\x28\xf4\xed\xc4\x19\x4b\xd4\xb2\x36\xba\x9e\x89\xe1\xc9\x5f\xb6\xf3\x20\x77\xff\x55\x2b\xaf\xb7\x1e\xb2\x95\xf5\x19\x3c\xb0\x70\x40\x8f\x7b\xbd\xf0\xbb\x74\x7f\x5c\xdf\xb1\x4b\xb7\x42\xfd\xf2\xad\x35\xd5\x86\x19\xa1\x01\xbd\x8b\x72\xe1\x81\x35\x37\xa6\x5d\xce\x65\xfc\x03\x46\x4b\x3a\x6b\x2b\x7e\xce\xbd\x20\x64\x75\x9b\x45\x31\x25\x4e\xaf\x77\x20\xe4\x77\x59\xad\xc4\x18\xa7\xe1\x82\x93\xd4\x2e\xed\x5d\xe8\x89\xa1\x28\x1a\x18\x9b\x53\xf4\x97\x2e\x90\xbe\x6b\xc3\x35\x37\xef\xbd\xb6\x7c\x8d\xe7\x80\x7d\x68\xb3\xb6\x7f\x75\xfd\xfa\xc3\x05\x05\x3d\xfb\x0e\x60\x2b\x6d\x58\xb8\xf4\x8a\xc7\x8e\xbe\xf4\xaf\x29\x95\xf6\x91\xcf\x0f\x5c\xd7\x54\x10\xea\x93\xdb\xef\x92\x50\x64\x0f\xe0\x53\xd6\x4e\x1e\xc6\x2b\x3d\x4a\x0d\xe9\xf8\x5e\xa3\x56\xaf\x41\x71\x5a\x1d\x6f\x19\x21\xd2\x32\x4a\x07\xfc\xcb\x0e\x23\x78\x5a\xe6\x05\x9e\x08\x96\xad\x94\x96\xe2\xbe\xf8\x93\xbb\x8f\x3e\x38\xa7\xe4\xc0\x83\xfb\xaf\x90\xd7\x96\x6f\xb2\x7a\x67\xb1\x7a\x3b\x91\x0f\x65\xa2\xb1\x21\xaf\x26\x2d\xcd\xad\xd7\x8b\x48\xec\x6e\x4f\x4e\x46\xf1\x4c\x6a\x51\x96\x5d\xa3\xf1\xfb\xbd\x5e\x92\x20\xf7\x9e\x8c\x76\x26\x28\xc2\x1a\xbb\x22\x52\xf6\x9c\x02\xe6\x58\x7e\x14\xc4\x6e\x1f\x7a\x81\x6f\xcd\xd9\x6d\xf2\x5e\xa3\x92\x80\xac\x9b\xb6\x6d\xdd\x33\xa6\x7f\x61\xff\xab\x2e\xdf\xb4\x63\x40\xc1\xc0\x51\x27\xe7\xcd\x9d\x97\x97\x6b\x6d\xaa\x6b\x1c\x94\x0b\xa3\x17\xb5\x34\xd7\x0c\x2e\xb1\xda\xa7\x17\xcc\xaa\x5b\x50\x96\x1f\xb6\x9b\xc3\x20\xce\x98\x31\xaf\x87\xf4\x43\xf5\xc2\xc6\x10\x6b\xbf\xf7\x95\xf6\xb3\xb1\x7a\xe4\x87\xcc\x76\x94\x28\x9a\x4c\xc9\xac\xaf\xa5\xc4\x31\xc2\xe3\xad\x5d\x3b\x9a\x25\xd6\xe2\x3b\xb2\x8e\xeb\x90\xa7\x82\x68\x3b\xfa\x48\xa7\xc6\xbb\xed\xda\x45\xab\xdd\xf7\xc5\x0f\x6f\xd1\xf7\xa9\xaf\x5b\xbb\xfb\x4a\xe8\x76\xac\x28\xaf\x67\x41\x7e\x30\xaf\x08\x7e\xff\xd7\xf1\x19\x15\x8e\x4b\x9e\x1a\xb8\x65\xc9\xb2\x8d\xd2\xf7\x83\x46\x0d\x2e\xcc\x1f\xde\x4f\x5e\xd3\x1e\x11\x76\x62\xb3\x4a\x8d\x04\xa6\xd0\x7b\x87\xdc\x82\x4a\x0f\x7a\x13\x06\x30\x6b\x8d\x86\x24\x03\xe6\x67\x9d\x20\xa4\x89\x1b\x01\x7a\xb6\x9e\x0d\x3e\x9b\x55\x98\x6b\x3a\x39\x3b\xd0\x61\x46\x5e\x28\x2f\xed\x54\xfe\x7c\xbe\x4b\xe2\x67\xdf\xd6\x20\xf4\x79\xef\x93\x79\x4d\xd5\x1f\xe0\x8f\xaa\xce\x9c\x50\xa9\xf5\x0f\x68\x0f\xda\xee\xbe\xdb\xc6\x6d\x85\x71\xeb\x77\xc2\x4e\x18\xa1\xe0\xeb\x15\x4a\x34\x00\x51\xab\xd9\xac\x9f\x98\x30\xa6\x1c\x0f\xd5\xf1\x20\x80\x58\x94\x37\xd8\x18\x26\x8e\xb1\x13\x36\x62\x97\x57\xcd\x41\xab\x82\xef\xd5\x79\x9f\xbc\xf7\xd6\x89\x33\x55\x1f\xe1\x0f\xaa\xc5\xa9\xda\x07\xf4\x93\xa4\x9f\x38\x3a\xb9\x6e\x3b\xe0\x49\x15\xdf\x2b\x4c\x60\xfa\xc3\x1b\x67\xb0\x18\x04\xe2\xd4\x38\x13\x91\x46\xe3\xb6\xbb\xac\xab\x8d\x06\x03\x56\x71\xac\x2a\x87\x55\xae\x1d\xdf\x9d\x48\x30\x9d\xec\xa8\x9f\x62\x39\x18\xdd\xaf\xe5\x7e\x0b\xf8\x7e\xad\xaa\xa3\xb2\x93\xfb\x05\xbb\xd9\xfa\x0e\xd9\x3d\xa4\xf7\x80\xd1\x66\xa5\xd2\xe2\x5e\xbf\x29\x64\x9b\x97\xdd\xc7\x79\xc9\x9b\xd1\xaa\xcb\xfb\x38\x3b\xa1\x88\xd5\x9d\xcb\x73\x9f\x50\x62\x92\xcd\xe6\x4b\x54\xab\x7d\xf1\x6e\x93\x9a\xcd\x47\xdc\xc8\x46\xf5\x9c\x18\x7d\x82\x8f\xef\x03\x66\x05\x02\x91\x93\xcc\xb1\x1a\xed\xef\xb6\x4a\x8c\x6c\xa5\x5f\x10\x64\x6d\xf0\x77\x7b\x25\x4f\x5c\x77\xe3\x6b\xcf\xbc\x7a\xa3\x58\xdc\x79\xaf\xa4\x7e\x88\xfe\xaa\x6d\x5a\x46\xdb\xf3\xc2\x2e\x28\x54\x69\x59\xbb\x58\xb9\x27\x22\x6c\x36\xdb\x05\x8d\xc6\x46\xb8\xcf\xb2\x38\x93\x76\xb5\x88\x72\x13\x3e\x0c\x04\x8f\xf3\xa8\xc9\xb1\xd4\x44\xda\x9e\xc9\x66\x30\xfa\x7c\x15\xfc\x9f\x9c\x5a\x1b\x5e\x73\x87\x65\xa1\x79\xc1\xe4\xc9\x55\xe6\x85\x8e\xdb\x55\x5a\xfd\x0e\xed\xc7\x1b\x9a\x86\x16\xf4\x19\x72\xe9\x1a\x99\x17\xb1\xf8\xba\x85\xcc\xc0\xf0\x51\x86\x0f\x63\x51\x88\x41\xf7\xac\xb9\x33\x36\xb9\xed\xad\x9d\xb0\xcd\x5a\x7b\xea\x13\x5f\x27\x6c\x62\xb3\x76\x87\x5e\xba\x22\x06\x5d\x0c\xbe\x38\x36\x93\x09\x84\x1c\x89\x3a\x27\xb1\x5a\xbd\x06\x9d\x2e\xc9\xe4\x4e\x4c\x44\x76\xa2\x53\xb6\x19\x4f\x05\x38\xd2\x60\xa0\x73\x07\x24\x9d\x70\x92\x18\x79\x60\x23\x5e\x00\x3a\xe1\x2f\x53\x24\x62\xd4\x48\xff\x68\x61\x57\x94\x0c\x30\xc8\x32\x91\xd7\xab\x40\x91\x85\x5d\x4c\x16\xb4\x48\x87\x52\xf9\x4e\xb6\x26\x39\x39\x9d\xd8\x6c\x69\x36\x8f\x5e\xef\x33\xc7\x53\xf5\x6a\x39\xfe\x2f\xe3\xc1\xb3\x81\xc0\x5f\xb6\xf1\xd2\xa3\xdb\x9f\x50\x20\x07\x58\x8c\x08\x83\x1c\x0c\x91\x0b\x03\x54\x6e\x30\x4c\xf1\x6c\xd9\xe4\x99\x62\x5f\xe3\xf2\x0f\x1d\x34\x20\x71\x82\x79\x26\x93\x81\x50\x6a\x71\xa8\x5f\x02\x17\x08\x5d\xf7\x31\xc2\xae\x05\xb3\x27\x4d\x2a\x2f\xfb\xc0\xea\xb0\xf6\x1f\x54\xe8\x63\x5f\x49\x9e\x50\xbf\x24\x46\xdb\xd5\xf4\x16\x5c\x28\xa6\xcb\x7d\x94\xd1\xd6\xa1\x13\xf8\xa6\x56\x48\x6b\x58\xcd\x1f\xd4\x07\x13\x4e\x15\x26\xbc\x6c\xee\xd2\x3b\x3b\xeb\x02\x08\xc2\xbc\xf7\x5e\x6e\x5a\x76\xcb\x4b\xf4\x8d\xbd\x80\x3f\x13\xd3\x99\x32\x78\xd4\xfd\xd4\x53\x6e\x18\xc8\x74\xc1\x49\x7a\x0b\x34\x77\xe0\x89\xd5\x05\x5a\x21\xa4\x17\x57\x1b\xb4\x7f\x87\x27\xaa\x05\x40\xc1\xf4\x63\xd3\xcb\xef\x7d\xf9\x19\xe0\xbd\x6f\xd0\x97\x6e\x11\x9a\x98\x1a\xe8\x21\x3d\xcd\x11\xa1\x48\x7d\x40\x12\x97\x20\x0d\x1b\xcd\x73\x42\x76\x67\x3c\xc4\x1b\x89\xa8\xb5\x5a\x3d\xa2\xdb\x1c\x2f\x33\x1b\xa3\xdc\x67\x13\xb8\xed\x41\xf4\x60\x4a\xb4\xe7\x2b\xf0\xd3\x82\x69\x31\x6d\xce\x9f\xd9\x0c\x04\x58\x1c\xad\x17\xa0\x31\x03\xf2\x13\x8a\xc3\x4f\x0d\x1e\x39\xb3\x7b\x3e\x7d\xdc\xbd\x71\xa3\xfb\xcf\xa2\x6c\xeb\xf8\xf8\xfa\xbc\x61\x9a\xf4\x39\xd8\x82\xa2\x74\x2c\x16\xcf\xcb\xe7\xcc\xb2\x43\x56\x8d\xcf\x97\xea\x48\x48\x48\x13\xec\x71\x16\x0d\xf2\xa6\xac\xf6\xb9\x23\xd5\x7d\x3b\x10\x38\x19\x08\x74\x6a\x71\x39\x8c\x66\x97\x66\xb6\xb6\xd3\x76\x5d\xb7\xf1\x63\x86\x26\xa6\x65\x6a\x57\xa8\xb3\x26\x0f\xcd\x9c\x38\x7a\x48\x42\x76\xaa\x66\x99\x90\x3d\x79\x57\x94\x44\xe1\x67\x7f\xa6\x3f\x37\x54\x39\xbf\x5f\x4a\xf7\x94\xbe\xbd\x4a\xab\x07\x48\x2f\xc8\x64\x32\xba\xf6\x30\xba\x56\x8a\x7f\xca\x11\x42\x52\x43\x46\xbd\x96\x18\x8d\x56\x62\x31\xe8\x35\x44\x11\xc3\x53\x81\xb7\x63\x3d\x9e\x11\x45\x02\x19\x19\x98\x4d\xa8\x92\xed\x02\xbe\xf5\x90\xee\x76\xe3\x03\xd3\xa7\x1b\xf6\xa5\x48\x45\x17\x00\x4b\xf7\xd1\x5b\xb6\x6f\x58\xda\xb7\x48\xfa\x0a\x46\x26\xfd\x9c\x75\x8e\xe1\x59\xcd\xf0\xcc\xed\xc0\x83\xcd\x71\x1a\x56\x73\xab\x51\xaf\xc6\x7f\x83\xc7\x47\xe4\x4e\x27\xf7\xb9\xb4\xfc\x64\xa7\x1d\xa4\x63\x29\xfb\x0c\xd3\xa7\x3f\x60\xbc\x5d\x77\xe8\x84\x74\x1f\xe0\x0b\x0c\xa8\xa3\xa8\xef\xd2\x0d\xdb\x61\xe4\xb9\xac\x9f\x93\x94\xfa\x94\xaa\x30\xc3\x22\xf7\x75\xa3\xe0\xd6\x22\xe4\x76\x27\xd9\x0d\x82\xe0\x55\x19\x13\xe3\x13\xed\xab\x2d\x4c\xc1\x9c\x0c\x04\x4d\x6f\x9f\x88\x9d\x28\x45\xce\x45\xc5\x3c\x9d\x93\x9b\x3a\x10\x5b\xdf\xe1\x3b\x7b\xf5\xd1\x15\xd4\x5f\x75\xcd\xf4\x39\xd7\x6e\x1d\x19\x53\x6d\x71\xe6\x40\x75\xa5\x6e\xdc\xc8\xfc\x11\x2a\xef\x0c\x69\xa5\x52\x79\xa4\xd0\x33\x5f\xfc\x83\xb5\x7b\x9a\xdc\xd7\x3d\x0e\x4f\x7a\xaa\xc3\x91\x61\x17\xe2\x34\x16\xe4\xf7\x79\x56\x27\x30\x6a\x4e\x05\x03\x9d\x1b\x5e\xa6\xe5\xa2\x2d\x1f\x4b\xcf\xcd\x7f\xdb\xf6\x67\x63\x88\x13\x7e\xfc\x4b\xf3\xdf\xdf\x4e\x21\x5f\xe7\x4d\x11\xae\xc1\x93\x44\xee\xab\xd2\x7e\x84\x02\xa8\x44\xb2\x1a\x71\x16\xb5\x1f\x14\x89\xb0\xff\x6e\x99\xe5\xc2\x35\x32\xa7\xe5\xf3\xc8\xc2\x2e\x3c\x45\xdc\x2f\x97\xe3\xc7\xbb\xba\x96\xb3\xca\xe2\x31\x4d\x96\x08\x61\x97\x2c\x08\xf2\x3a\xea\x33\x56\xee\xb8\x78\x2f\xeb\x93\xfc\x5c\x8e\x28\x6a\xa9\x46\xee\x85\xca\xb9\x9c\xce\x7d\x0f\x1f\x6f\x17\xe3\x07\x23\x42\xab\xc0\xd8\xc9\x60\xdc\x1d\x81\xc1\x63\xca\xab\xe8\x6a\x11\x3a\xc3\xf0\xa7\x71\x35\x51\xc0\x26\xfe\x27\x3e\x93\xa4\x88\x7a\xd8\xf9\x87\x67\xe3\x46\x4f\xe4\xec\xa7\x91\xd1\x71\x83\x18\x89\x83\x99\x1e\x32\xab\xd8\xaa\x02\x11\xa2\x51\x0b\x80\xe0\xaa\x99\x72\x98\xfb\x98\x87\xe4\x8a\x8d\x07\xf7\x5a\xc4\x20\x1e\xf9\xb4\x75\xc9\x19\x61\xd7\x07\xec\x4f\xa6\xe7\xa4\x30\x1f\xbf\x27\xae\x65\xeb\xf7\xf4\x90\xc9\x66\xb7\x27\xb8\xd4\x1a\x8d\xcb\x26\xe8\x57\x9b\xb9\xdb\xa1\x67\x83\xf2\xe0\x12\x73\x6e\x0e\xda\x5b\x17\x62\xd5\xf7\x9f\xd9\xe1\xc9\xa3\xbd\x3d\xb2\x35\x5b\xf4\x75\x95\x3d\x66\x4c\x1e\xe9\xe9\xd9\x5d\xbd\x49\x9d\x3f\x4f\x98\xef\xcf\xf2\xe7\x0c\xb9\x69\x15\xfb\xea\x53\x58\xd7\x58\x18\x39\xf7\xb7\x4f\xd8\x45\x44\xb9\xed\x74\xfc\xac\x9e\x4a\x90\x9f\x11\xe8\x35\x74\xb5\x0a\x62\x4e\x3a\x45\xfa\x94\x95\x4f\x14\xec\x4e\xf9\x33\xb0\xf5\xe3\xaf\xa7\xb3\xb7\xb0\x2b\xe5\xfb\xac\xcf\xd9\x3b\xc2\xd7\x9f\x19\x4f\x8e\xb0\xb6\xd1\xf1\xa7\x26\x1a\x06\x4b\xcf\x94\x32\x07\x27\x46\x1f\xc4\x75\xaa\x43\x8c\x2e\x98\x14\x2b\x72\xbb\x3a\x04\x0c\x90\x95\x1e\xc3\x2d\x42\x25\xe3\xb3\xf1\x10\x20\xca\xbe\xe5\x39\x6e\x80\x7b\x7d\xb5\x27\x5b\xe5\x87\x9b\x95\x77\x29\xf6\x9a\x6d\xcf\xd1\x17\xc5\x35\xa6\x74\x41\xb7\x88\x9f\x25\xf8\x81\x1f\x39\x95\x6d\x29\x6d\xa8\x26\x34\x18\x6f\x4e\x82\xe1\x49\x47\x92\x70\x5e\x12\xd8\x92\xc0\x9f\x04\x28\x69\x5e\x12\xf6\x25\x25\xf1\x23\x2b\xe7\xb8\x09\x2d\x14\x73\x2b\xda\x34\x2b\x08\xd6\x0d\xd6\x5f\xad\x6c\xa8\xdf\x69\x7d\xc6\x4a\x26\x5a\xc1\xc7\xad\x7c\x8f\xb6\x2d\x09\xe9\xad\x56\x95\x2a\x0d\xac\xe3\xf9\x0f\x1d\x56\xba\xdc\x84\x34\x3f\x6a\xb4\xda\x95\x16\x26\x1e\x32\x2d\x68\x78\xe8\x7f\x07\xd1\xc5\xed\xa6\xbf\x6f\x6b\x20\x5a\x54\x18\xb2\x43\x86\xf1\x1d\x23\x76\x18\x7b\x1b\x37\x1a\x89\x60\x84\xa1\xc6\xc9\x46\x06\x73\x5a\xc8\x2c\x9b\x75\x02\xbb\x7b\xce\xc8\x64\x38\xcf\x88\x63\x4c\x9f\xf3\x2f\x06\xf3\x5c\xdb\x66\x06\x33\x23\xe4\xc4\x1d\xe6\xd7\x18\xc6\x1b\x21\xcf\x08\xc8\x08\x46\x64\xe6\x25\x39\x84\xfc\x76\xbb\xd9\x0c\x06\xe3\x01\x71\x9b\x25\x5d\x7d\x46\xe6\xff\x17\xbf\x22\xe4\x0a\x19\xf9\xf9\x37\xe8\x1f\xdf\x1f\x5e\xef\xdf\x1f\x99\xd2\xb2\x18\x62\xfe\xd7\xa9\x8c\x29\x5a\xe6\xdb\x4f\xd8\x1a\x2d\xe4\x65\x25\x52\xc3\xa9\x5f\xa6\xe2\xf8\xd4\x17\x52\xf1\xf0\xd4\x96\x54\x9c\x9e\xba\x31\x15\x4f\x49\x4d\x95\x41\xc8\x56\xae\xf9\x8a\x2d\x72\x86\xb4\xaf\x13\x8c\x6f\xbe\x40\x28\x2d\x94\x28\x83\x80\x6e\xa9\x50\xc0\x8a\xbf\x93\x4a\x86\xa5\x3e\x97\x8a\x67\x76\x02\x80\x2e\x7a\xb6\xe8\xff\xc9\xf9\x0b\x24\xa2\x67\x59\xdd\x55\x6d\xdf\xb1\x7e\xe3\x64\x23\x7c\xae\x1c\x27\x26\x2d\x64\xed\x5f\x98\x88\x92\x21\x94\xbc\x37\x19\x27\xb3\xd5\xea\x80\x0c\x23\x91\x1f\x8e\x73\x33\x85\xd9\x8b\x03\x01\xd6\x07\x9c\x31\xee\x22\x63\xdd\x48\xaa\xfe\xc6\xa5\xa4\x3d\x36\x0f\xeb\x8a\xcf\xe6\xa4\xa4\xe4\xe4\xf9\x7c\x79\xe7\x72\x7c\x72\x22\xa7\x29\x97\x5d\xe5\x26\xfb\x72\x71\x5e\x4e\x8a\x2f\x2f\x8f\xfd\x9c\xe3\x4b\xce\x65\xe9\x9c\xe7\xeb\x4a\x23\x99\x73\x93\xd9\x8f\xbc\xe0\x41\x1f\xbb\xe9\xcb\xcb\xf9\x29\xa5\x47\x0f\x96\x21\xe7\xa0\x72\x2f\x07\x6a\x25\x39\xa6\x34\x45\x9f\x4a\xab\xc9\x17\xac\x6e\x44\xf6\x1e\x99\x84\x12\x43\x06\x80\x24\xe4\x82\x90\x6b\xaf\x0b\xbb\xbc\xb2\x7d\x07\xab\x4d\x61\x2e\xab\x0d\xeb\xd1\xff\x89\xda\x4f\x61\xb8\xf4\x28\xae\xf8\x2b\x5d\xf9\x0b\x06\x5e\x9c\x82\x0e\xfc\x2a\xb6\x5e\xe0\xd1\x78\x64\xfc\x3e\xe4\x81\x90\x67\xaf\x07\x7b\x92\x75\x31\xf8\x21\xdf\x9f\xcf\x4f\x98\xfe\x27\x1a\x60\x42\x2d\x0c\x5f\x00\x9b\xff\x4a\x84\xf4\xcd\x92\x05\x0b\x96\x3c\x7c\x51\x42\x30\x1a\xd9\xf6\x0d\x6d\x11\x13\x18\x15\x39\xfc\xa4\x6a\x0e\xce\x30\x10\xbb\x4d\xb6\xda\xc4\x80\x9c\x5e\x6c\xb7\x71\x0b\xd3\x1c\xee\x57\x0e\x17\x80\x45\xb0\xa7\x92\x29\xbe\x82\x11\xdd\x86\x2c\x1c\x93\xe9\xee\x1b\x1e\x50\x5c\xd2\x3f\x51\xfa\x01\xae\x70\xe5\x14\x25\x0f\xbf\xfc\xc5\x35\xab\x8e\x6f\x1a\x3e\x72\xd5\xdd\xf3\xa4\x17\xde\xc5\x2b\xa5\x77\xe1\xdc\xb0\x25\x95\xd3\xbb\xc5\x8f\xa9\xde\x38\x69\x70\xfd\x84\x9c\xdc\x89\x8d\xa4\x56\xda\xea\x2d\x5c\xbd\x63\x72\xcd\xa3\x1b\xc7\x0c\x5b\xf3\xd8\x92\xda\xfb\xd6\xcf\x4d\x86\xbe\x30\xa1\xfe\xd8\x68\xde\x3a\x5e\xa8\x8d\x78\x8a\x60\x7f\x53\xd1\xfd\x4a\x9a\x77\xeb\x34\x25\x8d\x11\x85\x22\x25\x4d\x50\x02\x2c\x53\xd2\x14\xd9\xe0\x49\x25\x2d\x20\x03\xfc\xa4\xa4\x45\x64\xc5\x99\x4a\x5a\x85\x96\x91\xa0\x92\x56\x23\x1b\x79\x57\x49\x6b\x90\x81\x3f\x4d\x97\xd3\x5a\x68\x64\xf3\xad\x48\x5a\x87\xdc\xea\x07\x94\xb4\x1e\xe5\x68\xb2\x94\x74\x1c\xca\xd7\x1c\x57\xd2\x06\x94\xa0\x0d\x30\x4a\x80\xb2\x81\x11\xdd\x27\x53\xc5\xd3\xc0\xea\x22\x28\x69\x8c\xf8\x29\xc5\x48\x9a\xa0\x5e\x30\x54\x49\x53\xd4\x0d\x76\x29\x69\x01\xb9\xe1\x4d\x25\x2d\xa2\x74\xd6\x02\x91\xb4\x0a\xfd\x82\x07\x28\x69\x35\xea\x46\xee\x57\xd2\x1a\xe4\x26\xdf\x2a\x69\x2d\xfe\x9c\x26\x28\x69\x1d\xea\xa3\x6e\x56\xd2\x7a\x34\x4b\x7d\x52\x49\xc7\xa1\x05\x9a\x19\x4a\xda\x80\x7a\x69\x2e\xa0\xa1\xa8\x1a\xcd\x67\xef\x26\xf6\x5e\x86\x2a\x50\x39\x5b\xcb\x97\xa3\x12\x76\x5d\xc2\x52\x65\xa8\x0e\xd5\xa3\xa5\xa8\x41\xce\x55\xc5\x7e\xf5\xa1\x6e\xec\xd7\x4c\xf6\x1d\x40\x79\xa8\x27\x7b\xfb\xd0\x70\x96\xab\x8e\xdd\xaf\x61\xe5\x7d\x68\x08\x4b\x37\xb0\x52\xfc\xb3\x44\x86\x5b\x87\x6a\x99\x74\x69\xe5\x3b\xff\x19\x5a\x80\xa5\x26\x2a\x54\x8c\x90\x4b\x67\xb3\xd4\x48\x56\xbe\x8c\xcb\xe7\xd0\xea\xf9\xd5\x4d\xd5\xcb\x2a\xca\x7d\xe5\x25\x4d\x25\xbe\xb2\xba\xfa\xa5\x0d\xd5\xf3\xab\x9a\x7c\xdd\xca\x32\x7d\x81\xbc\x9e\x79\xbe\xe1\x75\x75\xf3\x6b\x2a\x7c\x43\xea\x1a\xea\xeb\x1a\x4a\x9a\xaa\xeb\x6a\x73\xb4\x43\xba\x66\x0b\xf8\x26\x32\x10\x23\x4a\x9a\xb2\x7d\x23\x6b\xcb\x18\xdc\x31\x8c\xa0\x52\x86\x36\x96\x60\x1f\x1a\x2b\x7f\xd7\xb1\xdb\xd5\xa5\x15\x11\x60\xbe\xb1\x75\xb5\xec\x87\xc1\xec\xd7\x1a\x46\x24\x1a\x5c\x57\xc3\x3e\x07\xa1\x46\x46\x5f\x05\xcb\x5c\x2e\x03\xf1\xa1\x1e\xec\xfd\x5f\x00\x1d\xd4\x58\x56\x51\x5b\x5e\xd1\xe0\xeb\xe1\xfb\x0b\xfc\xff\x5c\xd4\xd7\x81\xbf\x4b\x49\x5f\x84\x9e\xa9\x72\xd1\xc6\xf6\x82\x01\xc6\xbb\x3c\xf6\xca\x61\x1c\x46\x53\x2b\x1a\x1a\x79\xfe\x40\x4e\x5e\x5e\x4e\xcf\x8b\xe3\x8a\x62\xea\x71\x31\x4c\x1c\x51\x8f\x08\xa2\x8b\xd3\x59\xcd\x50\xfb\x64\xf1\x69\x92\xef\x70\xa6\x2c\x62\xdf\x0d\x68\x21\xfb\xad\x0e\x55\xfe\xc7\x46\xf6\xb1\x7c\x15\xb2\x48\x36\xb2\x3b\x15\xf2\x55\xb9\x0c\x95\xc3\x9e\xc2\x72\x4c\x92\x73\x8d\x97\x4b\x72\xa6\x37\xc9\xd8\x6a\xe5\x5c\x93\x2f\x82\x71\x1c\xc3\x58\xc9\xca\x97\xc9\xe2\x19\xcd\x59\x26\xc3\xe6\x62\x1e\x81\x5c\xc7\xd2\x55\x4a\xf3\x2d\x40\x4b\x64\x21\x6d\x64\x39\x79\xb9\x68\xdd\x1a\xb9\x10\xc6\xf0\xbc\xba\xd1\x57\xe2\x6b\x6a\x28\x29\xaf\x58\x54\xd2\xb0\xd0\x57\x57\xd9\x59\xb0\x7c\x0d\x15\xf3\xab\x1b\x9b\x2a\x1a\xd8\x8f\xd5\xb5\xbe\x29\x39\x93\x72\x7c\xe3\x4b\x9a\x2a\x6a\x9b\x7c\x25\xb5\xe5\xbe\xc9\xed\x05\xc7\x55\x56\x56\x97\x55\xc8\x3f\x96\x55\x34\x34\x95\xb0\xcc\x75\x4d\x55\x4c\x36\x16\x2c\x69\xa8\x6e\x2c\xaf\x2e\xe3\xd8\x1a\x73\x2e\x26\x69\x17\xef\x6d\x1d\xd2\x15\xd3\x13\x10\xe3\x1c\xe7\x58\xb3\xcc\x87\xb1\x72\x76\x7e\xdd\x18\x29\x32\xa9\xa9\xa2\xb9\xc2\x37\xb6\xa4\xa9\xa9\xa2\x91\x67\x1e\xcc\x32\x34\x2a\xcc\x8f\x34\x2c\xc7\xb5\x44\x96\xab\x5a\xf6\x3b\x6f\xb4\x16\xc6\x32\xce\xa0\x2a\x39\x5d\x22\x37\x7c\xb9\x0c\x92\xf7\xf0\x5a\xa5\x74\x29\xeb\xf3\xbe\xff\x88\xdc\xa7\x94\x2d\x51\x04\xa8\x56\x16\xbf\x66\xa5\x46\xcd\x0a\x36\x2e\x0a\x95\xf2\x67\xa3\x8c\xb7\x96\xe1\xf0\xb1\x74\x89\xdc\x34\x3e\x99\x5a\xde\x6c\x95\x5d\xa8\xf0\xc9\x4d\x5b\x22\x0b\x4a\x44\x38\x17\xb1\xbb\x4d\x72\xde\x32\xf6\x7b\x0d\x7b\x2d\x55\xb4\xdd\x22\xc6\xcb\x08\xd6\x52\x45\x9f\xb5\xc8\xda\xb1\xaa\xbd\xfe\xbc\x54\x84\xf7\x97\xb0\xef\x96\xe4\x14\x59\x1c\x3b\xf3\x26\x22\xe6\x95\x4a\x3f\xf4\xc9\xf1\x92\xea\x59\xba\x4e\xae\x4b\x94\xa3\x3d\xe4\xd6\xe4\xf5\xa9\x90\xa9\xe4\xa9\x12\x59\xfb\x96\xb2\x12\x35\x32\xde\x08\x5d\x55\xb2\x30\x97\xc8\xa2\x58\xa1\x88\x66\x93\x4c\x7d\x63\x8c\x48\x47\x04\xd8\x27\xd7\x80\x43\x1f\x26\x53\xcb\x75\x6e\x85\xc2\xd9\x69\x4c\x57\x8f\xb9\x28\xc4\x08\xf7\x62\xbb\x52\xa3\xdc\xf5\x9b\x65\x3e\x76\xc0\xae\x95\xa9\x2d\x97\x7f\xab\x6b\xe7\x34\xcf\x55\xa3\x60\x8a\xd4\xb8\x46\x1e\x13\x16\xb6\xb7\x52\xa5\x2c\xa1\x11\x6e\x96\xcb\xd0\x7a\xfc\x0d\xbf\x2b\x65\xde\x34\x29\x58\xeb\x64\x8a\xca\xd9\x2b\xd2\xee\x11\x09\xab\x63\x65\x97\xc8\xad\x18\xe9\xfe\x11\xf9\x6f\xfa\x0b\xe7\x4a\x64\xfe\xd6\x29\xe5\xea\xd9\x1d\x8e\x2b\x42\xcb\xa2\x48\x77\x1e\x5c\xd2\xc8\xba\x27\xeb\xcc\x43\xea\x96\x34\x56\xd7\x56\x64\xfb\x5a\xaa\xaa\xcb\xaa\x7c\x2d\x25\x8d\xbe\xf2\x8a\xc6\xea\xf9\xb5\xec\x76\xe9\x52\x5f\xe7\xee\xe1\x63\x77\x4b\x98\x02\xa8\xad\xad\x6b\x66\x9d\xab\x99\x15\x6b\xa8\xa8\x6c\xa8\x68\xac\xaa\xae\x9d\xef\x6b\x2c\xa9\x6d\xf4\x35\x56\x34\x54\x57\x2a\x20\x7c\x4d\x55\x25\x4d\x5c\x5d\x2c\xaa\x68\x6a\xa8\x2e\x2b\xa9\xa9\x59\xca\x46\xaf\x45\xf5\xac\x68\x29\x1b\xae\x5a\xaa\x9b\xaa\x38\xfe\x86\x6a\xd6\x63\x2f\xa9\x68\xb9\x27\x27\x4a\x0d\xd3\x29\x95\x4c\x61\xfb\xaa\x17\xd5\x37\xd4\x35\xcb\x84\xf6\x68\x2c\x6b\xa8\xa8\xa8\x65\xf8\x4a\xca\x4b\x4a\xab\x6b\xaa\x9b\x18\xac\xaa\x92\x86\x92\x32\xa6\x69\x98\xba\xa9\x2e\x6b\x94\x35\x09\x53\x20\xbe\xfa\x92\xda\x1e\xc3\x96\x34\xd4\xd5\x57\x30\x62\xa7\x0d\x1f\xd3\x91\x91\x91\x17\xd1\x42\x8d\x75\x35\xcd\x15\x8d\x72\xee\xda\x8a\x8a\xf2\x46\xae\xc5\xca\x59\x55\x6b\x58\x21\x86\xb8\xa6\xae\x6e\x21\xaf\x52\x65\x5d\x03\x23\xb3\xbc\xa9\xaa\x47\x0c\xdd\x95\x75\xb5\x4d\xac\x68\x9d\xaf\xa4\xbc\x9c\xd5\x9d\x31\xac\xae\x6c\xc9\x22\xae\xdf\x98\xce\x69\x8a\x12\x57\x52\xd6\x50\xc7\xee\xd5\xd7\x94\x34\x31\x28\x8b\xb8\x1e\xab\x92\x7b\x7f\x3d\xea\xcb\x56\x15\xb9\x4c\x26\xf8\x2b\x47\xd6\x01\xb1\xda\xad\x4c\xd1\x6d\x39\x8a\xa4\xe4\xb2\x82\x4d\x4d\xf5\x7d\x73\x73\x5b\x5a\x5a\x72\x4a\x14\x15\x57\xc6\x34\x5c\x0e\x23\x2a\xf7\xff\x1c\x2c\x17\x96\x7a\x59\xac\x63\x55\x57\x83\x2c\x20\x1c\xe6\x22\x26\x38\xff\x11\x75\xd3\xd2\xfa\x0a\x45\x58\x1a\x1a\x73\xaa\x9a\x16\xd5\x44\x06\xc7\x08\xda\xa8\x16\x5d\x12\xa3\xb7\xa3\xfd\x69\x12\x1b\xf8\xc6\xc8\x83\x54\xbd\xa2\x05\x8a\x15\xf9\xf7\x75\x81\xc0\x35\x60\xd7\x91\xbd\x67\x64\x4c\x1f\xc3\x46\x8f\x5a\x2e\xc6\x4b\x64\x9d\xcf\xdb\x72\xd2\xc8\x31\xbe\x71\xf5\x4c\x4c\x8a\x59\x1b\xf9\x94\x0c\xd9\xbe\xe8\xe8\xdf\x93\x0f\xfd\x9d\xd9\x15\xd1\x45\xd5\xec\xba\x49\xae\x78\xa3\xdc\x93\x72\x64\x66\xcd\x67\xf7\xc7\x31\xca\xc6\xb4\xb3\x81\x09\x61\x75\x7d\x53\x63\x4e\x63\x75\x4d\x4e\x5d\xc3\xfc\xdc\x71\xc5\x63\x90\xe2\xb3\x15\x21\xc9\x8f\x4e\x22\xd4\x3e\x87\x6f\xff\xd3\x4c\x97\x7f\xc5\x6c\x06\x4a\xd9\x5c\x57\x64\xf3\x5a\x35\x9b\xc3\xf2\xa7\x06\x7a\x36\x37\x35\xb0\xb5\x98\x09\x99\x91\x85\xad\x46\x6c\xc8\x8e\x1c\x6c\xdd\x19\xcf\x56\xbb\x09\x6c\x85\xe6\x46\x1e\xe4\x65\x2b\x25\x1f\x4a\x46\x29\x6c\xbd\x94\x8a\xd2\x50\x3a\xca\x60\xf3\xc7\x4c\xd4\x1d\x65\x31\xee\xf4\x60\xb4\xe6\x2a\xb3\xc8\x20\xea\x85\xf2\x51\x6f\x54\x80\xfa\xa0\x42\x56\xbf\x7e\xa8\x3f\x1a\x80\x06\xb2\xf5\x6b\x88\x8d\xa1\x83\x99\xb6\x1e\xca\xb4\x63\x31\xd3\x86\x23\x18\xff\x47\xa1\xd1\xac\x66\x63\x99\x3e\x1f\xc7\xa6\x15\x13\xd8\xe4\x64\x12\x9b\x48\x4c\x61\xdc\x9e\x86\xa6\xa3\x30\x9a\x81\x66\xa2\x59\x68\x36\x9a\x83\xe6\xa2\x79\xa8\x04\x78\x34\x9a\xf5\x68\x03\x7a\x02\x5d\x8b\xbe\x40\x1b\xd1\x56\x74\x05\xba\x19\xdd\x8d\xf6\x01\x41\x97\x03\x45\xeb\xd0\x4e\xf4\x13\xfa\x19\x5d\xc5\xe6\xfe\x9b\x41\x44\x1f\xa1\x1f\xd1\x1e\x74\x0f\xfa\x15\xfd\x82\x7e\x43\xb7\xa1\x03\xe8\x45\xf4\x3c\x5b\xd7\x94\x32\x8e\x5f\xcd\x24\xe2\x25\xd6\xaa\x2f\xa0\x7f\xa1\x57\xd0\x09\xc6\xb7\x97\xd1\x97\x4c\x43\xbd\x81\x5e\x45\xaf\xa1\x83\x8c\xf3\x3f\xa0\xed\xe8\x6d\xf4\x26\x7a\x8b\xb5\xd7\xd7\xe8\x5b\xb4\x85\x4d\x4f\xaa\x99\x66\xe5\x42\x59\x8b\xf6\xb2\xf6\x59\x2c\x8f\x2d\x8d\x4c\xbe\x9a\x98\x26\x6e\x41\x5f\xa1\x4b\xd9\x5c\x7e\x29\x5a\x8e\x56\xa2\x15\xe8\x28\xba\x15\xad\x42\x97\xa1\xd5\x68\x0d\xfa\x06\x7d\x87\x1e\x03\x15\xa8\x41\x03\x5a\xd0\x81\x1e\xb5\x22\x09\xe2\xc0\x00\x46\x30\xa1\x36\x40\x60\x06\x0b\x58\x01\xc0\x06\x76\x70\x80\x13\xe2\xc1\x05\x09\x90\x08\x6e\xf0\x80\x97\x2d\x90\xff\x8d\xfe\x00\x1f\x24\x43\x0a\xf8\x21\x15\xd2\x20\x1d\x32\xa0\x1b\x64\x42\x77\xc8\x82\x6c\xe8\x01\x39\x90\x8b\xfe\x44\xef\x40\x1e\xf4\x84\x00\x04\xa1\x17\xe4\x43\x6f\x28\x80\x3e\x50\xc8\x56\x78\xfd\xa0\x3f\x0c\x80\x81\xe8\x13\xf4\x29\x14\x41\x08\x06\xc1\x60\x18\x02\x43\x61\x18\x14\xc3\x70\x18\x01\x23\x61\x14\x8c\x86\x31\x30\x16\x3d\x80\x1e\x84\x4b\x60\x1c\x8c\x87\x09\x30\x11\x26\xc1\x64\x98\x02\x53\x61\x1a\x3a\x8f\x2e\xa0\xb3\xe8\x33\x98\x0e\x61\x98\x01\x33\x61\x16\xcc\x86\x39\x30\x17\xe6\x41\x09\x94\x42\x19\x94\x43\x05\x54\xc2\x7c\xa8\x82\x6a\x58\x00\x0b\xa1\x06\x16\xa1\xc7\xa1\x16\xea\xa0\x1e\x16\xa3\xcf\xd1\x39\x68\x80\x46\x68\x82\x25\xd0\x0c\x2d\x70\x29\x2c\x85\x65\xb0\x1c\x56\xc0\x4a\xb8\x0c\x56\xc1\x6a\x58\x03\x6b\x61\x1d\xac\x47\x77\xc2\x06\xd8\x08\x9b\x60\x33\x6c\x81\xcb\xe1\x0a\xb8\x12\xae\x82\xad\xb0\x0d\xae\x86\xed\xb0\x03\x76\xc2\x35\xb0\x0b\xae\x85\xeb\x60\x37\x5c\x0f\x37\xc0\x8d\x70\x13\xdc\x0c\x7b\xe0\x16\xd8\x0b\xb7\xc2\x6d\x70\x3b\xec\x83\x3b\xe0\x4e\xd8\x0f\x77\xc1\xdd\x70\x0f\xdc\x0b\xf7\xc1\x01\xb8\x1f\x0e\xc2\x03\xf0\x20\x3c\x04\x0f\xc3\x21\x38\x0c\x8f\xc0\x11\x38\x0a\x8f\xc2\x63\xf0\x38\xfc\x03\x9e\x80\x63\xf0\x24\x3c\x05\xff\x84\xa7\xe1\x19\x78\x16\x9e\x83\xe3\xf0\x3c\xbc\x00\x2f\xc2\xbf\xe0\x25\x38\x01\x27\xe1\x65\x78\x05\x5e\x85\xd7\xe0\x75\x78\x03\xde\x84\xb7\xe0\x6d\x78\x07\xde\x85\xf7\xe0\x7d\xf8\x00\x3e\x84\x53\xf0\x11\x9c\x86\x33\xf0\x31\x7c\x02\x9f\xc2\x59\xf8\x0c\x3e\x87\x73\xf0\x05\x7c\x09\x5f\xc1\xd7\xf0\x0d\x7c\x0b\xdf\xc1\xf7\xf0\x03\xfc\x08\x3f\xc1\xcf\xf0\x0b\xfc\x0a\xbf\xc1\xef\xf0\x6f\xf8\x03\xfe\x84\xf3\x70\x01\x5a\x41\x82\x36\x8c\x30\x60\x8c\x09\xa6\x58\xc0\x22\x56\x61\x35\xd6\x60\x2d\xd6\x61\x3d\x8e\xc3\x06\x6c\xc4\x26\x6c\xc6\x16\x6c\xc5\x36\x6c\xc7\x0e\xec\xc4\xf1\xd8\x85\x13\x70\x22\x76\x63\x0f\xf6\xe2\x24\xec\xc3\xc9\x38\x05\xfb\x71\x2a\x4e\xc3\xe9\x38\x03\x77\xc3\x99\xb8\x3b\xce\xc2\xd9\xb8\x07\xce\xc1\xb9\x38\x0f\xf7\xc4\x01\x1c\xc4\xbd\x70\x3e\xee\x8d\x0b\x70\x1f\x5c\x88\xfb\xe2\x7e\xb8\x3f\x1e\x80\x07\xe2\x22\x1c\xc2\x83\xf0\x60\x3c\x04\x0f\xc5\xc3\x70\x31\x1e\x8e\x47\xe0\x91\x78\x14\x1e\x8d\xc7\xe0\xb1\xf8\x12\x3c\x0e\x8f\xc7\x13\xf0\x44\x3c\x09\x4f\xc6\x53\xf0\x54\x3c\x0d\x4f\xc7\x61\x3c\x03\xcf\xc4\xb3\xf0\x6c\x3c\x07\xcf\xc5\xf3\x70\x09\x2e\xc5\x65\xb8\x1c\x57\xe0\x4a\x3c\x1f\x57\xe1\x6a\xbc\x00\x2f\xc4\x35\x78\x11\xae\xc5\x75\xb8\x1e\x2f\xc6\x0d\xb8\x11\x37\xe1\x25\xb8\x19\xb7\xe0\x4b\xf1\x52\xbc\x0c\x2f\xc7\x2b\xf0\x4a\x7c\x19\x5e\x85\x57\xe3\x35\x78\x2d\x5e\x87\xd7\xe3\x0d\x78\x23\xde\x84\x37\xe3\x2d\xf8\x72\x7c\x05\xbe\x12\x5f\x85\xb7\xe2\x6d\xf8\x6a\xbc\x1d\xef\xc0\x3b\xf1\x35\x78\x17\xbe\x16\x5f\x87\x77\xe3\xeb\xf1\x0d\xf8\x46\x7c\x13\xbe\x19\xef\xc1\xb7\xe0\xbd\xf8\x56\x7c\x1b\xbe\x1d\xef\xc3\x77\xe0\x3b\xf1\x7e\x7c\x17\xbe\x1b\xdf\x83\xef\xc5\xf7\xe1\x03\xf8\x7e\x7c\x10\x3f\x80\x1f\xc4\x0f\xe1\x87\xf1\x21\x7c\x18\x3f\x82\xde\x45\x1f\xe3\x23\xe8\x7d\x7c\x14\x3f\x8a\x1f\xc3\x8f\xe3\x7f\xe0\x27\xf0\x31\xfc\x24\x7e\x0a\xff\x13\x3f\x8d\x9f\xc1\xcf\xe2\xe7\xd0\x07\xe8\x43\x74\x0a\x9d\x41\xef\xa1\xd3\xf8\x38\x7e\x1e\xbf\x80\x5f\xc4\xff\xc2\x2f\xe1\x13\xf8\x24\x7e\x19\xbf\x82\x5f\xc5\xaf\xe1\xd7\xf1\x1b\xf8\x4d\xfc\x16\x7e\x1b\xbf\x83\xdf\xc5\xef\xe1\xf7\xf1\x07\xf8\x43\x7c\x0a\x7f\x84\x4f\xe3\x33\xf8\x63\xfc\x09\xfe\x14\x9f\xc5\x9f\xe1\xcf\xf1\x39\xfc\x05\xfe\x12\x7f\x85\xbf\xc6\xdf\xe0\x6f\xf1\x77\xf8\x7b\xfc\x03\xfe\x11\xff\x84\x7f\xc6\xbf\xe0\x5f\xf1\x6f\xf8\x77\xfc\x6f\xfc\x07\xfe\x13\x9f\xc7\x17\x70\x2b\x96\x70\x1b\x41\x04\x08\x26\x84\x50\x22\x10\x91\xa8\x08\x8f\x34\xa1\x25\x3a\xa2\x27\x71\xc4\x40\x8c\xc4\x44\xcc\xc4\x42\xac\xc4\x46\xec\xc4\x41\x9c\x24\x9e\xb8\x48\x02\x49\x24\x6e\xe2\x21\x5e\x92\x44\x7c\x24\x99\xa4\x10\x3f\x49\x25\x69\x24\x9d\x64\x90\x6e\x24\x93\x74\x27\x59\x24\x9b\xf4\x20\x39\x24\x97\xe4\x91\x9e\x24\x40\x82\xa4\x17\xc9\x27\xbd\x49\x01\xe9\x43\x0a\x49\x5f\xd2\x8f\xf4\x27\x03\xc8\x40\x52\x44\x42\x64\x10\x19\x4c\x86\x90\xa1\x64\x18\x29\x26\xc3\xc9\x08\x32\x92\x8c\x22\xa3\xc9\x18\x32\x96\x5c\x42\xc6\x91\xf1\x64\x02\x99\x48\x26\x91\xc9\x64\x0a\x99\x4a\xa6\x91\xe9\x24\x4c\x66\x90\x99\x64\x16\x99\x4d\xe6\x90\xb9\x64\x1e\x29\x21\xa5\xa4\x8c\x94\x93\x0a\x52\x49\xe6\x93\x2a\x52\x4d\x16\x90\x85\xa4\x06\xdd\x45\x16\x91\x5a\x52\x47\xea\xc9\x62\xd2\x40\x1a\x49\x13\x59\x42\x9a\x49\x0b\xb9\x94\x2c\x25\xcb\xc8\x72\xb2\x82\xac\x24\x97\x91\x55\xe8\x16\xb2\x9a\xac\x21\x6b\xc9\x3a\xb2\x9e\x6c\x20\x1b\xc9\x26\xb2\x99\x6c\x21\x97\x93\x2b\xc8\x95\xe4\x2a\xb2\x95\x6c\x23\x57\x93\xed\xe8\x3a\xb2\x83\xec\x24\xd7\xa0\x1b\xc9\x2e\x72\x2d\xb9\x8e\xec\x26\xd7\x93\x1b\xc8\x8d\xe4\x26\x72\x33\xd9\x43\x6e\x21\x7b\xc9\xad\xe4\x36\x72\x3b\xd9\x47\xee\x20\x77\x92\xfd\xe4\x2e\x72\x37\xb9\x87\xdc\x4b\xee\x23\x07\xc8\xfd\xe4\x20\x79\x80\x3c\x48\x1e\x22\x0f\x93\x43\xe4\x30\x79\x84\x1c\x21\x47\xc9\xa3\xe4\x31\xf2\x38\xf9\x07\x79\x82\x1c\x23\x4f\x92\xa7\xc8\x3f\xc9\xd3\xe4\x19\xf2\x2c\x79\x8e\x1c\x27\xcf\x93\x17\xc8\x8b\xe4\x5f\xe4\x25\x72\x82\x9c\x24\x2f\x93\x57\xc8\xab\xe4\x35\xf2\x3a\x79\x83\xbc\x49\xde\x22\x6f\x93\x77\xc8\xbb\xe4\x3d\xf2\x3e\xf9\x80\x7c\x48\x4e\x91\x8f\xc8\x69\x72\x86\x7c\x4c\x3e\x21\x9f\x92\xb3\xe4\x33\xf2\x39\x39\x47\xbe\x20\x5f\x92\xaf\xc8\xd7\xe4\x1b\xf2\x2d\xf9\x8e\x7c\x4f\x7e\x20\x3f\x92\x9f\xc8\xcf\xe4\x17\xf2\x2b\xf9\x8d\xfc\x4e\xfe\x4d\xfe\x20\x7f\x92\xf3\xe4\x02\x69\x25\x12\x69\xa3\xfc\x70\x32\xa6\x84\x52\x2a\x50\x91\xaa\xa8\x9a\x6a\xa8\x96\xea\xa8\x9e\xc6\x51\x03\x35\x52\x13\x35\x53\x0b\xb5\x52\x1b\xb5\x53\x07\x75\xd2\x78\xea\xe2\x11\x05\xa8\x9b\x7a\xa8\x97\x26\x51\x1f\x4d\xa6\x29\xd4\x4f\x53\x69\x1a\x4d\xa7\x19\xb4\x1b\xcd\xa4\xdd\x69\x16\xcd\xa6\x3d\x68\x0e\xcd\xa5\x79\xb4\x27\x0d\xd0\x20\xed\x45\xf3\x69\x6f\x5a\x40\xfb\xd0\x42\xda\x97\xf6\xa3\xfd\xe9\x00\x3a\x90\x16\xd1\x10\x1d\x44\x07\xd3\x21\x74\x28\x1d\x46\x8b\xe9\x70\x3a\x82\x8e\xa4\xa3\xe8\x68\x3a\x86\x8e\xa5\x97\xd0\x71\x74\x3c\x9d\x40\x27\xd2\x49\x74\x32\x9d\x42\xa7\xd2\x69\x74\x3a\x0d\xd3\x19\x74\x26\x9d\x45\x67\xd3\x39\x74\x2e\x9d\x47\x4b\x68\x29\x2d\xa3\xe5\xb4\x82\x56\xd2\xf9\xb4\x8a\x56\xd3\x05\x74\x21\xad\xa1\x8b\x68\x2d\xad\xa3\xf5\x74\x31\x6d\xa0\x8d\xb4\x89\x2e\xa1\xcd\xb4\x85\x5e\x4a\x97\xd2\x65\x74\x39\x5d\x41\x57\xd2\xcb\xe8\x2a\xba\x9a\xae\xa1\x6b\xe9\x3a\xba\x9e\x6e\xa0\x1b\xe9\x26\xba\x99\x6e\xa1\x97\xd3\x2b\xe8\x95\xf4\x2a\xba\x95\x6e\xa3\x57\xd3\xed\x74\x07\xdd\x49\xaf\xa1\xbb\xe8\xb5\xf4\x3a\xba\x9b\x5e\x4f\x6f\xa0\x37\xd2\x9b\xe8\xcd\x74\x0f\xbd\x85\xee\xa5\xb7\xd2\xdb\xe8\xed\x74\x1f\xbd\x83\xde\x49\xf7\xd3\xbb\xe8\xdd\xf4\x1e\x7a\x2f\xbd\x8f\x1e\xa0\xf7\xd3\x83\xf4\x01\xfa\x20\x7d\x88\x3e\x4c\x0f\xd1\xc3\xf4\x11\x7a\x84\x1e\xa5\x8f\xd2\xc7\xe8\xe3\xf4\x1f\xf4\x09\x7a\x8c\x3e\x49\x9f\xa2\xff\xa4\x4f\xd3\x67\xe8\xb3\xf4\x39\x7a\x9c\x3e\x4f\x5f\xa0\x2f\xd2\x7f\xd1\x97\xe8\x09\x7a\x92\xbe\x4c\x5f\xa1\xaf\xd2\xd7\xe8\xeb\xf4\x0d\xfa\x26\x7d\x8b\xbe\x4d\xdf\xa1\xef\xd2\xf7\xe8\xfb\xf4\x03\xfa\x21\x3d\x45\x3f\xa2\xa7\xe9\x19\xfa\x31\xfd\x84\x7e\x4a\xcf\xd2\xcf\xe8\xe7\xf4\x1c\xfd\x82\x7e\x49\xbf\xa2\x5f\xd3\x6f\xe8\xb7\xf4\x3b\xfa\x3d\xfd\x81\xfe\x48\x7f\xa2\x3f\xd3\x5f\xe8\xaf\xf4\x37\xfa\x3b\xfd\x37\xfd\x83\xfe\x49\xcf\xd3\x0b\xb4\x95\x4a\xb4\x4d\x40\x02\x08\x58\x20\x02\x15\x04\x41\x14\x54\x82\x5a\xd0\x08\x5a\x41\x27\xe8\x85\x38\xc1\x20\x18\x05\x93\x60\x16\x2c\x82\x55\xb0\x09\x76\xc1\x21\x38\x85\x78\xc1\x25\x24\x08\x89\x82\x5b\xf0\x08\x5e\x21\x49\xf0\x09\xc9\x42\x8a\xe0\x17\x52\x85\x34\x21\x5d\xc8\x10\xba\x09\x99\x42\x77\x21\x4b\xc8\x16\x7a\x08\x39\x42\xae\x90\x27\xf4\x14\x02\x42\x50\xe8\x25\xe4\x0b\xbd\x85\x02\xa1\x8f\x50\x28\xf4\x15\xfa\x09\xfd\x85\x01\xc2\x40\xa1\x48\x08\x09\x83\x84\xc1\xc2\x10\x61\xa8\x30\x4c\x28\x16\x86\x0b\x23\x84\x91\xc2\x28\x61\xb4\x30\x46\x18\x2b\x5c\x22\x8c\x13\xc6\x0b\x13\x84\x89\xc2\x24\x61\xb2\x30\x45\x98\x2a\x4c\x13\xa6\x0b\x61\x61\x86\x30\x53\x98\x25\xcc\x16\xe6\x08\x73\x85\x79\x42\x89\x50\x2a\x94\x09\xe5\x42\x85\x50\x29\xcc\x17\xaa\x84\x6a\x61\x81\xb0\x50\xa8\x11\x16\x09\xb5\x42\x9d\x50\x2f\x2c\x16\x1a\x84\x46\xa1\x49\x58\x22\x34\x0b\x2d\xc2\xa5\xc2\x52\x61\x99\xb0\x5c\x58\x21\xac\x14\x2e\x13\x56\x09\xab\x85\x35\xc2\x5a\x61\x9d\xb0\x5e\xd8\x20\x6c\x14\x36\x09\x9b\x85\x2d\xc2\xe5\xc2\x15\xc2\x95\xc2\x55\xc2\x56\x61\x9b\x70\xb5\xb0\x5d\xd8\x21\xec\x14\xae\x11\x76\x09\xd7\x0a\xd7\x09\xbb\x85\xeb\x85\x1b\x84\x1b\x85\xff\x8f\xbd\x6f\x01\x93\xa3\x28\xd7\xee\xee\x99\xae\xaa\xde\x6c\xee\x21\x02\x46\x08\x01\x11\x11\x63\xa6\xbb\x7a\x66\x07\x31\x32\x97\x2a\x48\x08\x49\x0c\x09\xb7\xc3\x11\x66\x77\x67\x77\x07\x76\x77\x36\xbb\x33\x49\xc8\xf1\x70\x38\x1e\x0e\x72\x38\x1c\x45\x0e\x72\x90\x83\x88\x88\x88\x8a\x88\x5c\x22\x62\xc4\x10\x6e\x11\x03\x72\x13\x11\x91\x9b\x08\x11\x14\x10\x62\xb8\x08\xc9\x5f\x5d\xfd\xee\x4c\xef\xec\x6c\xd8\x28\xf8\xeb\xff\xfc\xcf\x3e\x5d\xdf\xd7\x35\xd5\xf5\x7e\x55\xdd\x53\xef\xfb\x75\xcf\xcc\x5e\x6c\x7f\xc9\xbe\xc4\xfe\xb2\x7d\xa9\xfd\x15\xfb\x32\xfb\xab\xf6\xe5\xf6\xd7\xec\x2b\xec\xaf\xdb\x57\xda\xdf\xb0\xbf\x69\x7f\xcb\xbe\xca\xfe\xb6\x7d\xb5\xfd\x1d\xfb\x1a\xfb\xbb\xf6\xb5\xf6\x75\xf6\xf5\xf6\x0d\xf6\x3a\xfb\x7b\xf6\x8d\xf6\xf7\xed\x9b\xec\x1f\xd8\xeb\xed\x1f\xda\x37\xdb\x3f\xb2\x37\xd8\xb7\xd8\x1b\xed\x5b\xed\xdb\xec\xdb\xed\x3b\xec\x3b\xed\x4d\xf6\x8f\xed\xbb\xec\x9f\xd8\x9b\xed\xbb\xed\x7b\xec\x9f\xda\xf7\xda\xf7\xd9\xf7\xdb\x0f\xd8\x0f\xda\x3f\xb3\x1f\xb2\x7f\x6e\x3f\x6c\xff\xc2\x7e\xc4\xfe\xa5\xfd\xa8\xfd\x2b\xfb\x31\xfb\x71\xfb\x09\xfb\x49\xfb\x29\xfb\xd7\xf6\xd3\xf6\x6f\xec\x67\xec\x67\xed\x2d\xf6\x6f\xed\xe7\xec\xe7\xed\xdf\xd9\xbf\xb7\x5f\xb0\x5f\xb4\x5f\xb2\xff\x60\xbf\x6c\xbf\x62\x6f\xb5\xff\x68\x6f\xb3\x5f\xb5\x5f\xb3\x5f\xb7\xdf\xb0\xff\x64\xbf\x69\xbf\x65\x6f\xb7\x77\x10\x83\x98\xc4\x22\x31\x12\x27\x36\x21\x84\x12\x46\x1c\xd2\x42\x26\x90\x56\x32\x91\x4c\x22\x93\xc9\x14\x32\x95\x4c\x23\xd3\xc9\x0c\xb2\x1b\x99\x49\xde\x43\x76\x27\x7b\x90\x3d\xc9\x7b\xc9\x2c\xf2\x3e\xb2\x17\xd9\x9b\xcc\x26\xfb\x90\x39\x64\x5f\xb2\x1f\x79\x3f\xd9\x9f\x7c\x80\x1c\x40\x3e\x48\x0e\x24\x1f\x22\x07\x91\x0f\x93\xb9\xe4\x23\x64\x1e\x49\x10\x97\x78\x84\x13\x9f\x24\x49\x8a\xb4\x91\x34\x39\x98\x7c\x94\x1c\x42\x3e\x46\xe6\x93\x8f\x93\x43\x49\x86\x64\x49\x8e\xe4\x89\x20\x92\x1c\x46\x0e\x27\x0b\xc8\x42\x72\x04\x59\x44\x8e\x24\x8b\xc9\x12\xb2\x94\x7c\x82\x2c\x23\x47\x91\xe5\x64\x05\x39\x9a\x1c\x43\x8e\x25\xc7\x91\xe3\xc9\x3f\x90\x13\xc8\x3f\x92\x4f\x92\x13\xc9\x49\xa4\x40\xda\x49\x07\xe9\x24\x45\xd2\x45\xba\x49\x0f\x29\x91\x93\xc9\x29\xa4\x97\xf4\x91\x7e\x52\x26\x03\x64\x25\x19\x24\x43\xa4\x42\xaa\x64\x15\x59\x4d\xd6\x90\x53\xc9\x5a\xf2\x4f\xe4\x53\xe4\x9f\xc9\x69\xe4\x5f\xc8\xe9\xe4\x5f\xc9\xa7\xc9\xbf\x91\x33\xc8\xbf\x93\x33\xc9\x67\xc8\x59\xe4\x3f\xc8\xd9\xe4\x3f\xc9\x39\xe4\xbf\xc8\x67\xc9\xe7\xc8\xb9\xe4\xf3\xe4\x3c\xf2\xdf\xe4\x7c\xf2\x05\x72\x01\xf9\x1f\x72\x21\xf9\x22\xb9\x88\xfc\x2f\xb9\x98\x7c\x89\x5c\x42\xbe\x4c\x2e\x25\x5f\x21\x97\x91\xaf\x92\xcb\xc9\xd7\xc8\x15\xe4\xeb\xe4\x4a\xf2\x0d\xf2\x4d\xf2\x2d\x72\x15\xf9\x36\xb9\x9a\x7c\x87\x5c\x43\xbe\x4b\xae\x25\xd7\x91\xeb\xc9\x0d\x64\x1d\xf9\x1e\xb9\x91\x7c\x9f\xdc\x44\x7e\x40\xd6\x93\x1f\x92\x9b\xc9\x8f\xc8\x06\x72\x0b\xd9\x48\x6e\x25\xb7\x91\xdb\xc9\x1d\xe4\x4e\xb2\x89\xfc\x98\xdc\x45\x7e\x42\x36\x93\xbb\xc9\x3d\xe4\xa7\xe4\x5e\x72\x1f\xb9\x9f\x3c\x40\x1e\x24\x3f\x23\x0f\x91\x9f\x93\x87\xc9\x2f\xc8\x23\xe4\x97\xe4\x51\xf2\x2b\xf2\x18\x79\x9c\x3c\x41\x9e\x24\x4f\x91\x5f\x93\xa7\xc9\x6f\xc8\x33\xe4\x59\xb2\x85\xfc\x96\x3c\x47\x9e\x27\xbf\x23\xbf\x27\x2f\x90\x17\xc9\x4b\xe4\x0f\xe4\x65\xf2\x0a\xd9\x4a\xfe\x48\xb6\x91\x57\xc9\x6b\xe4\x75\xf2\x06\xf9\x13\x79\x93\xbc\x45\xb6\x93\x1d\xd4\xa0\x26\xb5\x68\x8c\xc6\xa9\x4d\x09\xa5\x94\x51\x87\xb6\xd0\x09\xb4\x95\x4e\xa4\x93\xe8\x64\x3a\x85\x4e\xa5\xd3\xe8\x74\x3a\x83\xee\x46\x67\xd2\xf7\xd0\xdd\xe9\x1e\x74\x4f\xfa\x5e\x3a\x8b\xbe\x8f\xee\x45\xf7\xa6\xb3\xe9\x3e\x74\x0e\xdd\x97\xee\x47\xdf\x4f\xf7\xa7\x1f\xa0\x07\xd0\x0f\xd2\x03\xe9\x87\xe8\x41\xf4\xc3\x74\x2e\xfd\x08\x9d\x47\x13\xd4\xa5\x1e\xe5\xd4\xa7\x49\x9a\xa2\x6d\x34\x4d\x0f\xa6\x1f\xa5\x87\xd0\x8f\xd1\xf9\xf4\xe3\xf4\x50\x9a\xa1\x59\x9a\xa3\x79\x2a\xa8\xa4\x87\xd1\xc3\xe9\x02\xba\x90\x1e\x41\x17\xd1\x23\xe9\x62\xba\x84\x2e\xa5\x9f\xa0\xcb\xe8\x51\x74\x39\x5d\x41\x8f\xa6\xc7\xd0\x63\xe9\x71\xf4\x78\xfa\x0f\xf4\x04\xfa\x8f\xf4\x93\xf4\x44\x7a\x12\x2d\xd0\x76\xda\x41\x3b\x69\x91\x76\xd1\x6e\xda\x43\x4b\xf4\x64\x7a\x0a\xed\xa5\x7d\xb4\x9f\x96\xe9\x00\x5d\x49\x07\xe9\x10\xad\xd0\x2a\x5d\x45\x57\xd3\x35\xf4\x54\xba\x96\xfe\x13\xfd\x14\xfd\x67\x7a\x1a\xfd\x17\x7a\x3a\xfd\x57\xfa\x69\xfa\x6f\xf4\x0c\xfa\xef\xf4\x4c\xfa\x19\x7a\x16\xfd\x0f\x7a\x36\xfd\x4f\x7a\x0e\xfd\x2f\xfa\x59\xfa\x39\x7a\x2e\xfd\x3c\x3d\x8f\xfe\x37\x3d\x9f\x7e\x81\x5e\x40\xff\x87\x5e\x48\xbf\x48\x2f\xa2\xff\x4b\x2f\xa6\x5f\xa2\x97\xd0\x2f\xd3\x4b\xe9\x57\xe8\x65\xf4\xab\xf4\x72\xfa\x35\x7a\x05\xfd\x3a\xbd\x92\x7e\x83\x7e\x93\x7e\x8b\x5e\x45\xbf\x4d\xaf\xa6\xdf\xa1\xd7\xd0\xef\xd2\x6b\xe9\x75\xf4\x7a\x7a\x03\x5d\x47\xbf\x47\x6f\xa4\xdf\xa7\x37\xd1\x1f\xd0\xf5\xf4\x87\xf4\x66\xfa\x23\xba\x81\xde\x42\x37\xd2\x5b\xe9\x6d\xf4\x76\x7a\x07\xbd\x93\x6e\xa2\x3f\xa6\x77\xd1\x9f\xd0\xcd\xf4\x6e\x7a\x0f\xfd\x29\xbd\x97\xde\x47\xef\xa7\x0f\xd0\x07\xe9\xcf\xe8\x43\xf4\xe7\xf4\x61\xfa\x0b\xfa\x08\xfd\x25\x7d\x94\xfe\x8a\x3e\x46\x1f\xa7\x4f\xd0\x27\xe9\x53\xf4\xd7\xf4\x69\xfa\x1b\xfa\x0c\x7d\x96\x6e\xa1\xbf\xa5\xcf\xd1\xe7\xe9\xef\xe8\xef\xe9\x0b\xf4\x45\xfa\x12\xfd\x03\x7d\x99\xbe\x62\x5c\x6b\x5c\x47\xb7\xd2\x3f\x1a\xeb\x8c\xef\x19\xb7\xd1\x6d\xc6\xf5\xc6\x0d\xc6\xed\xf4\x55\xe3\xd3\xc6\x46\xe3\x33\xc6\xb7\xe8\x6b\xf4\x75\xfa\x06\xfd\x13\x7d\xd3\xb8\x83\xbe\x45\xb7\xd3\x1d\xc6\xcd\xc6\x8f\x98\xc1\x4c\x63\x3d\xb3\x58\x8c\xc5\x99\xcd\x08\xa3\x8c\x31\x87\xb5\xb0\x09\xac\x95\x4d\x64\x93\xd8\x64\x36\x85\x4d\x35\x5e\x65\xd3\xd8\x74\x36\x83\xed\xc6\x66\xb2\xf7\xb0\xdd\xd9\x1e\x6c\x4f\xf6\x5e\x36\x8b\xbd\x8f\xed\xc5\xf6\x66\xb3\xd9\x3e\x6c\x0e\xdb\x97\xed\xc7\xde\xcf\xf6\x67\x1f\x60\x07\x18\xe7\xb0\x0f\xb2\x03\xd9\x87\xd8\x41\xec\xc3\x6c\x2e\xfb\x08\x9b\xc7\x12\xcc\x65\x1e\xe3\xcc\x67\x49\x96\x62\x6d\x2c\xcd\x0e\x36\x2e\x64\x1f\x35\x2e\x32\xbe\x68\xbc\xc8\x0e\x31\x6e\x35\xbe\x66\x9c\xc7\x3e\xc6\xe6\x1b\x17\x1b\x5f\x37\x3e\xc7\x3e\x6e\x9c\x6f\x7c\x81\x1d\xca\x32\x2c\xcb\x72\x2c\xcf\x04\x93\xec\x30\x76\x38\x5b\xc0\x16\xb2\x23\xd8\x22\x76\x24\x5b\xcc\x96\xb0\xa5\xec\x13\x6c\x19\x3b\x8a\x2d\x67\x2b\xd8\xd1\xec\x18\x76\x2c\x3b\x8e\x1d\xcf\xfe\x81\x9d\xc0\xfe\x91\x7d\x92\x9d\xc8\x4e\x62\x05\xd6\xce\x3a\x58\x27\x2b\xb2\x2e\xd6\xcd\x7a\x58\x89\x9d\xcc\x4e\x61\xbd\xac\x8f\xf5\xb3\x32\x1b\x60\x2b\xd9\x20\x1b\x62\x15\x56\x65\xab\xd8\x6a\xb6\x86\x9d\xca\xd6\xb2\x7f\x62\x9f\x32\xbe\xcf\xfe\x99\x9d\xc6\xfe\x85\x9d\xce\xfe\x95\x7d\x9a\xfd\x1b\x3b\x83\xfd\x3b\x3b\x93\x7d\x86\x9d\xc5\xfe\x83\x9d\xcd\xfe\x93\x9d\xc3\xfe\x8b\x7d\x96\x7d\x8e\x9d\xcb\x3e\xcf\xce\x63\xff\xcd\xce\x67\x5f\x60\x17\xb0\xff\x61\x17\xb2\x2f\xb2\x8b\xd8\xff\xb2\x8b\xd9\x97\xd8\x25\xec\xcb\xec\x52\xf6\x15\x76\x19\xfb\x2a\xbb\x9c\x7d\x8d\x5d\xc1\xbe\xce\xae\x64\xdf\x60\xdf\x64\xdf\x62\x57\xb1\x6f\xb3\xab\xd9\x77\xd8\x35\xec\xbb\xec\x5a\x76\x1d\xbb\xde\xd8\x60\xdc\xc2\x6e\x60\xeb\xd8\xf7\xd8\x8d\xec\xfb\xec\x26\xf6\x03\xb6\x9e\xfd\x90\xdd\xcc\x7e\xc4\x36\xb0\x5b\xd8\x46\x76\x2b\xbb\x8d\xdd\xce\xee\x60\x77\xb2\x4d\xec\xc7\xec\x2e\xf6\x13\xb6\x99\xdd\xcd\xee\x61\x3f\x65\xf7\xb2\xfb\xd8\xfd\xec\x01\xf6\x20\xfb\x19\x7b\x88\xfd\x9c\x3d\xcc\x7e\xc1\x1e\x61\xbf\x64\x8f\xb2\x5f\xb1\xc7\xd8\xe3\xec\x09\xf6\x24\x7b\x8a\xfd\x9a\x3d\xcd\x7e\xc3\x9e\x61\xcf\xb2\x2d\xec\xb7\xec\x39\xf6\x3c\xfb\x1d\xfb\x3d\x7b\x81\xbd\xc8\x5e\x62\x7f\x60\x2f\xb3\x57\xd8\x56\xf6\x47\xb6\x8d\xbd\xca\x5e\x63\xaf\xb3\x37\xd8\x9f\xd8\x9b\xec\x2d\xb6\x9d\xed\x70\x0c\xc7\x74\x2c\x27\xe6\xc4\x1d\xdb\x21\x0e\x75\x98\xe3\x38\x2d\xce\x04\xa7\xd5\x99\xe8\x4c\x72\x26\x3b\x53\x9c\xa9\xce\x34\x67\xba\x33\xc3\xd9\xcd\x99\xe9\xbc\xc7\xd9\xdd\xd9\xc3\xd9\xd3\x79\xaf\x33\xcb\x79\x9f\xb3\x97\xb3\xb7\x33\xdb\xd9\xc7\x99\xe3\xec\xeb\xec\xe7\xbc\xdf\xd9\xdf\xf9\x80\x73\x80\xf3\x41\xe7\x40\xe7\x43\xce\x41\xce\x87\x9d\xb9\xce\x47\x9c\x79\x4e\xc2\x71\x1d\xcf\xe1\x8e\xef\x24\x9d\x94\xd3\xe6\xa4\x9d\x83\x9d\x8f\x3a\x87\x38\x1f\x73\xe6\x3b\x1f\x77\x0e\x75\x32\x4e\xd6\xc9\x39\x79\x47\x38\xd2\x39\xcc\x39\xdc\x59\xe0\x2c\x74\x8e\x70\x16\x39\x47\x3a\x8b\x9d\x25\xce\x52\xe7\x13\xce\x32\xe7\x28\x67\xb9\xb3\xc2\x39\xda\x39\xc6\x39\xd6\x39\x8e\x56\xfb\x4b\xf3\xe6\x65\xe6\xc1\xe6\x9d\xf2\xaa\xe2\xe0\x50\x47\x79\xb0\x18\xeb\xab\x26\x5a\xfa\x4a\x9d\x9d\xe5\xca\xdc\x79\xf3\x12\x34\xd3\x17\xdc\xe7\xec\xa7\x85\xd0\x92\x4c\xfb\x60\x71\x55\x91\x14\xb4\xa1\x99\x72\x77\xb9\xbf\x78\x0a\x2d\x84\x76\x42\xae\xa3\x34\xd8\x51\xed\xeb\xea\x2d\xae\x99\xd0\x51\xf7\x5b\x72\xaa\xbb\x42\x47\x47\xb1\xbf\xd2\xd2\x51\x73\x49\xbe\xa3\x10\x74\xd9\x19\x9a\xbc\xea\xbf\x50\xa1\x02\x80\x45\x00\x8a\x10\xb0\xa8\x4d\x8b\xa8\x77\x54\xac\xb9\x54\x20\x8c\x62\x68\x89\x08\x7b\x2c\x6a\x33\xe1\xb0\x48\x50\xdd\x91\xa0\x0e\xab\xf7\xd5\x5d\x73\x5b\x0f\xeb\x28\xf7\xf5\x15\xb0\xd3\x1d\xd9\x99\x70\x78\xa4\x9f\x9e\xba\x1f\x3f\xbc\xbd\x30\x18\xef\x51\x05\x59\x50\x29\xf5\x76\x16\x49\x49\x1b\xba\x00\x23\x29\x61\x24\x0b\xc2\x91\x94\xc2\xa9\x5b\x80\x98\x4b\xa1\xb5\x16\x2c\xb4\x4a\x27\x4f\x58\x18\xc1\x38\xb9\xee\xb7\x1e\x11\x8d\xea\x94\x11\x3b\xdd\xc1\x6d\xf3\xde\x42\x7f\x67\xa9\x83\x2c\x2a\x74\x54\x2b\x45\xd2\xab\x4d\xeb\xa2\x68\xbb\xde\xc8\x0e\x59\x14\x4e\x50\xaf\x36\xf1\x45\x6a\xf4\xf1\x5e\x55\x90\xc5\xe1\xf1\xfd\xe1\xf1\x8b\xa3\xc7\xf7\x47\x8f\x5f\x1c\x1e\xdf\x1f\x4e\x70\x7f\x61\xa0\x3c\x54\x19\x2c\x0f\xf4\x14\x63\xa2\xbf\x3b\x56\xec\xef\xa6\x4b\x30\xf8\x32\x06\xbf\x24\x1c\x7c\x59\x9b\x89\x4b\x7a\xaa\xfd\xdd\x85\xc1\x6a\x5f\x6f\xa1\x5a\x99\x58\x8e\xee\x91\x65\x61\x0c\x83\x61\x0c\xcb\xa2\x31\x0c\x46\x63\x58\x16\xc6\x30\x18\x9a\xa3\xc2\xa3\x86\xb4\x99\x70\x54\x64\x1a\x87\x22\xd3\xb8\x3c\xda\x5b\x25\xda\xdb\xf2\xb0\x9b\x4a\x38\x23\xcb\x83\x53\x5a\x09\x4e\xe9\x8a\xf0\x94\x56\xc3\x53\xba\x02\xa3\xaa\x62\x54\x2b\xc2\x51\x55\xb5\xb1\x57\x0c\x96\xfa\xbb\xed\x6a\x50\x4e\x5c\x31\x62\x84\xd5\xe8\x1e\x5d\x81\x53\x5f\xc5\xbb\xe6\x98\x48\xb4\xab\x23\xfe\x71\x11\xff\xd4\xba\x4f\x8e\x0f\xc7\xba\x56\x9b\x96\xe3\xeb\x97\xf1\xda\x9a\x6b\xf7\x96\xfb\xbb\x87\xf4\xdb\x3b\xd1\x36\x0f\x36\x01\xeb\xc2\x7a\xb0\x1c\xd6\x87\x4d\xc2\xa6\x60\xdb\x60\xd3\xb0\x19\xd8\x2c\x6c\x0e\x36\x0f\x2b\x60\x65\x68\xd3\xc0\x4f\x03\x3f\x0d\xdc\x34\x70\xd3\xc0\x4d\x03\x37\x0d\xdc\x34\x70\xd3\xc0\x4d\x03\x37\x0d\xdc\x34\x70\xd3\xc0\x4d\x03\x37\x2d\xed\x25\x3d\xe5\x41\x95\xfc\x04\x65\x58\x97\xc1\x98\x33\xc0\xce\x00\x3b\x03\xec\x0c\xb0\x33\xc0\xce\x00\x3b\x03\xec\x0c\xb0\x33\xc0\xce\x00\x3b\x03\xec\x8c\xb0\x57\x68\xcc\x6a\x1d\x33\x8b\xf1\x66\x81\x9d\x05\x76\x16\xd8\x59\x60\x67\x81\x9d\x05\x76\x16\xd8\x59\x60\x67\x81\x9d\x05\x76\x16\xd8\x59\x60\x67\x31\xee\x2c\xe6\x3b\x87\xf9\xce\x01\x3f\x07\xfc\x1c\xf0\x73\xc0\xcf\x01\x3f\x07\xfc\x1c\xf0\x73\xc0\xcf\x01\x3f\x07\xfc\x1c\xf0\x73\xc0\xcf\x01\x3f\x07\xfc\x1c\xf0\xf3\xc0\xcf\x03\x3f\x0f\xfc\x3c\xf0\xf3\xc0\xcf\x03\x3f\x0f\xfc\x3c\xf0\xf3\xc0\xcf\x03\x3f\x0f\xfc\x3c\xf0\xf3\xc0\xcf\x03\x3f\x0f\xfc\x3c\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x25\xf0\x25\xf0\x25\xf0\x25\xf0\x25\xf0\x25\xf0\x25\xf0\x25\xf0\x25\xf0\x65\xba\x25\x13\xac\x25\xe1\xdb\xbc\x50\x73\x69\x46\x84\xb6\x50\x0c\x57\xbb\x25\x43\xbd\x85\xa1\x9e\xd0\x2f\xd7\x7d\xdd\x8b\x3b\x6f\x1e\x6c\x02\xd6\x85\xf5\x60\x39\xac\x0f\x9b\x84\x4d\xc1\xb6\xc1\xa6\x61\x33\xb0\x59\xd8\x1c\x6c\x1e\x56\xc0\x86\xb3\xe1\x26\x80\x9f\x00\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x89\x54\xeb\x51\xd1\xd5\x7a\x28\xb2\x83\x16\x88\x24\x81\x48\x12\x88\x24\x81\x48\x12\x88\x24\x81\x48\x5c\x44\xe2\x22\x12\x17\x91\xb8\x88\xc4\x45\x24\x2e\x22\x71\x11\x89\x8b\x99\x70\x31\x13\x2e\x66\xc2\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\xf7\x80\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf5\x80\xeb\x01\xd7\x03\xae\x07\x5c\x0f\xb8\x1e\x70\x3d\xe0\x72\xe0\x72\xe0\x72\xe0\x72\xe0\x72\xe0\x72\xe0\x72\xe0\x72\x8c\x9b\x03\x9f\x03\x9f\x03\x9f\x03\x9f\x03\x9f\x03\x9f\x03\x9f\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\x03\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x1f\xfc\xef\x82\xff\x5d\xf0\xbf\x0b\xfe\x77\xc1\xff\x2e\xf8\xdf\x05\xff\xbb\xe0\x7f\x17\xfc\xef\x82\xff\x5d\xf0\xbf\x0b\xfe\x77\xc1\xff\x2e\xf8\xdf\x05\xff\xbb\xe0\x7f\x17\xfc\xef\x82\xff\xdd\x34\xf0\xa1\x03\x5c\xe8\x00\x17\x3a\xc0\x85\x0e\x70\xa1\x03\x5c\xe8\x00\x17\x3a\xc0\x85\x0e\x70\xa1\x03\x5c\xe8\x00\x17\x3a\xc0\x85\x0e\x70\xd3\xc0\x47\x9a\xe3\x66\x80\x0f\x2d\xe0\x42\x0b\xb8\xd0\x02\x2e\xb4\x80\x0b\x2d\xe0\x42\x0b\xb8\xd0\x02\x2e\xb4\x80\x0b\x2d\xe0\x42\x0b\xb8\xd0\x02\x2e\xb4\x80\x9b\x01\x7e\x06\xf8\x59\xe0\x43\x0f\xb8\xd0\x03\x2e\xf4\x80\x0b\x3d\xe0\x42\x0f\xb8\xd0\x03\x2e\xf4\x80\x0b\x3d\xe0\x42\x0f\xb8\xd0\x03\x2e\xf4\x80\x0b\x3d\xe0\x42\x0f\xb8\xd0\x03\x2e\xf4\x80\x0b\x3d\xe0\x42\x0f\xb8\xd0\x03\x2e\xf4\x80\x0b\x3d\xe0\x42\x0f\xb8\xe0\x7f\x17\xbc\xef\x82\xf7\x5d\xf0\xbe\x0b\xde\x77\xc1\xfb\x2e\x78\xdf\x05\xef\xbb\xe0\x7d\x17\xbc\xef\x82\xf7\x5d\xf0\xbe\x0b\xde\x77\xc1\xfb\x2e\x78\xdf\x05\x8f\xbb\xe0\x71\x17\x3c\xee\x82\xc7\x5d\xf0\xb8\x0b\x1e\x77\xc1\xe3\x2e\x78\xdc\x05\x8f\xbb\xe0\x71\x17\x3c\xee\x82\xc7\x5d\xf0\xb8\x0b\x1e\x77\xc1\xe3\x2e\x78\xdc\x05\x8f\xbb\xe0\x71\x17\x3c\xee\x82\xc7\x5d\xf0\xb8\x0b\x1e\x77\xc1\xe3\x2e\x78\xdc\x05\x8f\xbb\xe0\x71\x17\x3c\xee\x4a\xe0\x4b\xe0\x4b\xe0\x4b\xe0\x4b\xe0\x4b\xe0\x4b\xe9\x74\x0f\x16\x56\x15\x15\xe1\xb5\x3b\x9a\xc9\x03\x4f\xbf\xe6\xcd\x73\x1d\x9d\x89\x44\x6a\x38\xac\x0f\x9b\x84\x4d\xc1\xb6\x4d\xec\x29\x97\x4f\x29\xb4\x97\x57\x45\x8f\xca\xc0\x66\x61\x73\xb0\x79\x58\x01\x1b\xce\x85\x07\x16\xf7\xc0\xe2\x1e\x58\xdc\x03\x8b\x7b\x60\x71\x0f\x2c\xee\x81\xc5\xbd\x04\xa2\x48\xb4\xc1\xa6\x61\x81\x0f\xee\xf6\xc0\xdd\x1e\xb8\xdb\x03\x77\x7b\xe0\x6e\x0f\xdc\xed\x81\xbb\x3d\xd7\x6d\x55\xb9\x4e\x7b\xb1\xb7\xbc\xba\x3e\x28\x10\xb8\x07\x02\xf7\x40\xe0\x1e\x08\xdc\x03\x81\x7b\x20\x70\x0f\x04\xee\x81\xc0\x3d\x10\xb8\x07\x02\xf7\x40\xe0\x1e\x08\xdc\x03\x81\x7b\x20\x70\x0f\x04\xee\x81\xc0\x3d\x10\xb8\x07\x02\xf7\x40\xe0\x9e\x07\x7c\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb5\x07\xa2\xf6\x40\xc4\x1e\x88\xd8\x03\x11\x7b\x20\x62\x2f\x25\xec\x4a\xb9\xbf\x3c\x34\xb1\xb3\x54\x1c\x2c\x0e\x95\x86\xf4\x5e\x4b\xa6\x77\xa0\xa7\xa0\x5d\xa7\xd0\x5f\xae\x14\x7b\x8b\xa5\x42\xab\x18\x18\x2a\xa9\x9c\x5d\x57\x33\x51\xc1\xeb\x0b\xca\xf0\x5a\x97\xf4\x95\x82\x3b\x0e\xe1\xce\x8a\x48\xe3\x96\x25\x7d\xc5\xee\xb0\xd1\xd4\x92\x6a\x3e\x02\xcb\xd6\x58\xf1\x6c\xb1\x52\xb0\x0f\x2b\x28\xfd\x4c\x81\x13\x3f\x5e\x55\xc5\x14\x8e\xbd\xbc\x47\x79\xf1\x00\xc8\x3e\xa2\x30\x30\x50\x20\x8b\x0a\x7d\xed\x9d\x05\xeb\xc8\xaa\xb5\xb8\x6a\x1d\x5b\xa2\x40\xb6\x96\x96\x62\xcb\x7a\xca\xf6\x51\xa5\xee\xbe\x42\x6c\x79\xa1\x4a\x11\x45\x6c\x69\x4f\x29\x96\x53\xdb\xd2\xa1\x52\xeb\x82\x48\x04\x93\xd1\x60\x78\xbf\xa5\x50\x1b\x78\x6b\x31\x3a\xdc\xe2\xf0\x70\x4b\xc3\xc3\x9d\x51\x1d\x79\x68\x38\x18\x7d\x7c\xbc\x3d\x18\x4c\x77\x30\x18\xbb\xb3\xd8\x5b\x29\x50\xf4\x15\x5f\x1b\x0c\x29\x78\xb1\xa2\x87\x14\x74\x66\x9f\xa2\x87\xd4\x1b\x0e\xa9\xbf\x6a\xad\x29\xd1\x72\x38\x9e\xd8\x60\x4f\x99\x0c\x05\x83\x49\xd8\xda\xc4\x2a\x6a\x4c\xc0\x8d\x0d\xa8\xf1\x74\xa8\x4d\xed\xda\xe5\x60\x82\x5b\xa3\x73\x3b\xb9\x21\xbc\xd6\x72\xf4\xec\x54\xa3\x67\xa7\x5c\x3b\x3b\xe1\x35\x01\x92\xf4\x40\x92\x1e\x48\xd2\x03\x49\x7a\x20\x49\x0f\x24\xe9\x81\x24\x3d\x90\xa4\x87\xe4\xd8\x43\x72\xec\x21\x39\xf6\x90\x1c\x7b\x48\x8e\x3d\x24\xc7\x1e\x48\xd5\x03\xa9\x7a\x20\x55\x0f\xa4\xea\x81\x54\x3d\x90\xaa\x07\x52\xf5\x40\xaa\x1e\x48\xd5\x03\xa9\x7a\x20\x55\x0f\xa4\xea\x81\x54\x3d\x90\xaa\x07\x52\xf5\x40\xaa\x1e\x48\xd5\x03\xa9\x7a\x20\x55\x0f\xa4\xea\x81\x54\x3d\x90\xaa\x07\x52\xf5\x40\xaa\x1e\x48\xd5\x03\xa9\x7a\x20\x55\x0f\xa4\xea\x81\x54\x3d\x90\xaa\x07\x52\xf5\x40\xaa\x1e\x48\xd5\x93\x21\x3e\x47\x3a\xcc\x91\x0e\x73\xa4\xc3\x1c\xe9\x30\x07\x9d\x72\xd0\x29\x07\x9d\x72\xd0\x29\x47\x3a\xcc\x91\x0e\x73\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x10\x29\x07\x91\x72\x24\xc1\x1c\x49\x30\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x07\xc7\x72\x70\x2c\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x07\x07\x73\x70\x30\x07\x07\x73\x70\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\x47\x32\xcc\x91\x0c\x73\x24\xc3\x1c\xc9\x30\xc7\xcd\x71\x8e\x9b\xe3\x1c\xc9\x31\xc7\xcd\x71\x8e\x24\x99\x23\x49\xe6\x48\x92\x39\x92\x64\x8e\x24\x99\x23\x49\xe6\xe0\x7f\x0e\xfe\xe7\xe0\x7f\x0e\xfe\xe7\xe0\x7f\x0e\xfe\xe7\xe0\x7f\x0e\xfe\xe7\xf9\x36\xa7\xd0\x55\x2a\x25\xe6\xb5\x0d\xaf\x4c\x50\x00\x1c\x0a\x80\x43\x01\x70\x28\x00\x0e\x05\xc0\xa1\x00\x38\x14\x00\x87\x02\xe0\x50\x00\x1c\x0a\x80\x43\x01\x70\x28\x00\x0e\x05\xc0\xa1\x00\x38\x14\x00\x87\x02\xe0\x50\x00\x1c\x0a\x80\x43\x01\x70\x28\x00\x0e\x05\xc0\xa1\x00\x38\x14\x00\x87\x02\xe0\x50\x00\x1c\x0a\x80\x43\x01\x70\x28\x00\x0e\x05\xc0\xa1\x00\x38\x14\x00\x87\x02\xe0\x50\x00\x1c\x0a\x80\x43\x01\x70\x28\x00\x0e\x05\xc0\xa1\x00\x7c\x28\x00\x1f\x0a\xc0\x87\x02\xf0\xa1\x00\x7c\x28\x00\x1f\x0a\xc0\x87\x02\xf0\xa1\x00\x7c\x28\x00\x1f\x0a\xc0\x87\x02\xf0\xa1\x00\x7c\x28\x00\x1f\x0a\xc0\x87\x02\xf0\xa1\x00\x7c\x28\x00\x1f\x0a\xc0\x87\x02\xf0\xa1\x00\x7c\x30\xba\x0f\x46\xf7\xc1\xe8\x3e\x18\xdd\xc7\xca\xe1\x63\xe5\xf0\xb1\x72\xf8\x58\x39\x7c\xac\x1c\x3e\x56\x0e\x1f\x2b\x87\x8f\x95\xc3\xc7\xca\xe1\x63\xe5\xf0\xb1\x72\xf8\x58\x39\xfc\xf4\x30\x0e\xe2\xc6\xca\xe1\x63\xe5\xf0\xb1\x72\xf8\x58\x39\x7c\xac\x1c\x3e\x56\x0e\x1f\x2b\x87\x8f\x95\xc3\xc7\xca\xe1\x63\xe5\xf0\xb1\x72\xf8\x58\x39\x7c\xac\x1c\x3e\x56\x0e\x1f\x2b\x87\x8f\x95\xc3\xcf\x48\x7b\xa8\xa7\xb8\xaa\xd0\xa2\x72\x87\x42\xd7\x50\xb1\xbb\xdc\x1b\xba\x03\xaa\xe8\x99\xa0\xdd\x95\x85\xbe\x42\x65\xc8\xee\x29\x0d\x96\x56\xda\x95\x21\xa5\xca\x6d\xdd\xd0\xd6\x6d\xc8\xf0\xcb\x65\x95\x08\x84\x9d\x66\x33\x64\x65\xb5\xbd\x5a\x19\x22\x9d\x85\xee\xe2\x50\x8f\xdd\x57\xac\x14\xbb\xed\xbe\xc2\xca\x42\x57\x7c\xb0\xd0\x55\x54\x47\x0e\x15\x57\xd2\xe0\x8b\x6f\xc1\x83\xf1\x21\x6d\xd8\x50\x59\xa1\x0e\x55\x57\x3a\xd5\x81\x81\xe2\xe0\x89\x41\x55\x6f\x79\x75\x71\x50\x39\x61\xbf\xb9\xe4\x84\x10\x6c\xa5\x02\xee\x8f\x17\x7a\x8b\x5d\x31\x95\xb0\xd8\xdd\xa5\xbe\x62\xaf\xdd\xa9\xf6\x2b\x56\x4f\x31\xb6\xaa\xb0\xca\x5e\x5b\x38\xb5\xd4\x1f\x53\xa9\x4a\xac\xa2\xb6\x53\xcb\x9d\xac\xab\xd4\x5f\xe8\x3d\xa5\xd0\x15\x53\x9b\xad\x42\x2d\xa2\xaa\xaf\xd8\x17\x53\x5b\xb8\xd3\x5f\xed\x8f\xa9\x8d\x0c\xa9\xd7\x4f\xe9\x89\x07\x9d\x50\xfd\xc2\x40\xd1\x1a\x28\xb6\x68\xb7\x32\xa4\x52\x15\x5b\x97\xb1\x95\x65\x35\x20\x35\xc2\x78\x30\x14\x95\xe3\xac\x22\x0a\x7c\x55\x68\x14\x28\x51\x5b\x60\xba\x83\x4c\xa6\xc7\x51\x66\xa8\x47\xf5\xa9\xa7\x29\x91\x0f\xdf\x2b\xca\x26\x60\x5d\x58\x0f\x96\xc3\xfa\xb0\x49\xd8\x14\x6c\x1b\x6c\x1a\x36\x03\x9b\x85\xcd\xc1\xe6\x61\x05\xac\x0c\x6d\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\xef\x01\xdf\x03\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\x3e\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x1b\xf0\xdb\x80\xdf\x06\xfc\x36\xe0\xb7\x01\xbf\x0d\xf8\x6d\xc0\x6f\x03\x7e\x1b\xf0\xdb\x80\xdf\x06\xfc\x36\xe0\xb7\x01\xbf\x0d\xf8\x6d\xc0\x6f\x03\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x0e\xf8\x39\xe0\xe7\x80\x9f\x03\x7e\x0e\xf8\x39\xe0\xe7\x80\x9f\x03\x7e\x0e\xf8\x39\xe0\xe7\x80\x2f\x81\x13\x6a\xb2\x84\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x08\xf0\x8c\x00\xcf\x88\x94\x24\xc7\xe8\x67\x9d\x64\x75\x68\x8e\x09\x3f\xda\xb8\x5a\x1b\xe7\x98\xe1\x1b\xec\xce\xea\x61\x2f\x3c\x0e\x3c\x23\xc0\x33\x02\x3c\x23\xc0\x33\x02\x3c\x23\xc0\x33\x02\x3c\x23\xc0\x33\x02\x3c\x23\xc0\x33\x02\x3c\x23\xc0\x33\x02\x3c\x23\xc0\x33\x02\x3c\x23\xc0\x33\x02\x3c\x23\xc0\x33\x02\x3c\x23\xc0\x33\x02\x3c\x23\xc0\x33\x22\x2d\x9c\xcc\xf0\xf3\x4a\xa7\x30\xec\xb5\x64\x6a\x4f\x66\x5b\x0a\x35\x77\x4a\xa6\xfe\x51\x4f\x3d\x0d\x53\x0a\x8d\x15\x91\x16\x7a\xda\xa2\x2d\x74\xc5\x8c\x48\x8b\x5a\xc7\x33\x0a\x4d\x2a\xa3\x7d\xe9\x27\xcb\xd1\xbe\x74\xc5\xf4\x48\x8b\xe1\xc8\xa7\x17\x46\xd7\x4d\x08\x3f\x1a\x1e\x7e\x0c\xad\x10\xf1\xc3\x7a\x1d\x17\xea\xb5\x3f\x39\xac\xaf\x45\x32\xb9\x30\x72\x1f\xc7\xe9\x18\x70\x9c\xf6\x27\x85\xf5\xc3\xb0\x93\x0a\x23\x76\x1d\x51\xf3\x6a\x75\x2d\xa2\x3e\xcf\xf5\xfe\x89\x08\x3f\xda\x1b\xf6\x3a\x45\x34\x4e\x72\xb1\xb1\x42\x34\xce\x7a\xb1\x71\xd6\x45\xb3\x59\x2f\x36\x9b\x75\xd1\x38\xeb\xc5\xc6\x59\x17\x4d\x66\xbd\x38\xba\xae\x65\x41\x7d\x6c\xa5\x9a\xeb\x2c\xa8\xcd\x42\xa9\xe6\x2d\xa9\x79\xe5\xda\xd1\x4b\xea\x47\x97\xeb\xd1\x2d\x69\x1c\x7a\xb9\xb1\x62\x49\xe3\x5c\x94\x1b\xe7\x62\x49\xb3\xb9\x28\x37\x9b\x8b\x25\x8d\x73\x51\x6e\x9c\x8b\x25\x4d\xe6\xa2\xdc\x64\x2e\xf4\xc7\x7e\xc3\x8f\x4b\x96\xeb\xae\xae\xd5\x41\x85\xb5\xda\x9d\xa4\x6b\x6b\x41\x4c\x2a\x8f\xd8\x0d\x8f\xd1\xe0\xe1\x31\xda\x9d\xa8\x6b\x87\xd1\x26\x96\xa3\x7b\xce\x8a\x9a\x57\xad\xc5\xb3\xa2\xde\x61\xb5\xee\xae\xa8\x87\x56\xad\xbb\x2b\xea\x51\x56\xeb\x51\xae\x18\x19\x65\x75\x64\x94\x2b\xea\x51\x56\xeb\x51\xae\x18\x11\x65\x35\xba\x47\x8e\x0b\x97\xd9\x53\xb5\x71\x8e\xab\xc5\x7c\x6a\x2d\xe6\xe3\xea\xdd\x9f\x5a\x7f\xaf\x1c\x17\xbe\x57\x4e\x0d\x3f\x06\x1f\xac\x69\x12\x9a\x4d\x42\xb3\x49\x68\x36\x09\xcd\x26\xa1\xd9\x24\x34\x9b\x84\x66\x93\xd0\x6c\x12\x9a\x4d\x42\xb3\x49\x68\x36\x09\xcd\x26\xa1\xd9\x24\x34\x9b\x84\x66\x93\xd0\x6c\x12\x9a\x4d\x42\xb3\x49\x68\x36\x09\xcd\x26\xa1\xd9\x24\x34\x9b\x84\x46\x93\xd0\x68\x12\x1a\x4d\x42\xa3\x49\x68\x34\x09\x8d\x26\xa1\xc9\x24\x34\x99\x84\x26\x93\xd0\x64\x12\x9a\x4c\x42\x93\x49\x68\x32\x09\x4d\x26\xa1\xc9\x24\x34\x99\x84\x26\x93\xd0\x64\x12\x9a\x4c\xba\xc3\x78\x18\x1f\x34\x99\x84\x26\x93\xd0\x64\x12\x9a\x4c\x42\x93\x49\x68\x32\x09\x4d\x26\xa1\xc9\x24\x34\x99\x84\x26\x93\xd0\x64\x12\x9a\x4c\x42\x93\x49\x68\x32\x09\x4d\x26\xa1\xc9\x24\x34\x99\x84\x26\x93\xd0\x64\x12\x9a\x4c\x42\x93\x49\x68\x32\x09\x4d\x26\xa1\xc1\x24\x34\x98\x84\x06\x93\xd0\x60\x12\x1a\x4c\x42\x83\x49\x68\x2e\x09\xcd\x25\xa1\xb9\x24\x34\x97\x84\xe6\x92\xd0\x5c\x12\x9a\x4b\x42\x73\x49\x68\x2d\x09\x8d\x25\xfd\xe1\x7e\x11\x3f\x34\x95\x84\xa6\x92\xd0\x54\x12\x9a\x4a\x42\x53\x49\x68\x2a\x09\x4d\x25\xa1\xa9\x24\x34\x95\x84\xa6\x92\xd0\x54\x12\x9a\x4a\x42\x53\x49\x68\x2a\x09\x4d\x25\xa1\xa9\x24\x34\x95\x84\xa6\x92\xd0\x54\x12\x9a\x4a\x42\x53\x49\x68\x2a\x09\x4d\x25\xa1\xa9\x24\x34\x95\x84\xa6\x92\xd0\x54\x12\x9a\x4a\x42\x53\x49\x68\x2a\x89\x5c\x5d\x22\x57\x97\xc8\xd5\x25\x72\x75\x89\x5c\x5d\x22\x57\x97\xd0\x50\x12\x1a\x4a\x42\x43\x49\x68\x28\x09\x0d\x25\xa1\xa1\x24\x34\x94\x6c\x1b\xc6\xc3\x78\xa1\xa1\x24\x34\x94\x84\x86\x92\xd0\x50\x12\x1a\x4a\x42\x43\x49\x68\x28\x09\x0d\x25\xa1\xa1\x24\x34\x94\x84\x86\x92\xd0\x50\x12\x1a\x4a\x22\x57\x97\xc8\xd5\x25\x72\x75\x89\x5c\x5d\x22\x57\x97\xc8\xd5\x25\x72\x75\x89\x5c\x5d\x22\x57\x97\xc8\xd5\x25\x72\x75\x89\x5c\x5d\x22\x57\x97\xc8\xd5\x25\x72\x75\x89\x5c\x5d\x22\x57\x97\xc8\xd5\x25\x72\x75\x89\x5c\x5d\x22\x57\x97\xc8\xd5\x25\x72\x75\x89\x5c\x5d\x22\x57\x97\xc8\xd1\x25\x72\x74\x89\x1c\x5d\x22\x47\x97\xc8\xd1\x25\x72\x74\x89\x1c\x5d\x22\x47\x97\xc8\xd1\x25\x72\x74\x89\x1c\x5d\x22\x47\x97\xc8\xd1\x25\x72\x74\x89\x1c\x5d\x22\x37\x97\xc8\xcd\x25\x72\x73\x89\xdc\x5c\x22\x37\x97\x39\xe0\xe6\x80\x9b\x03\x6e\x0e\xb8\x39\xe0\xe6\x81\x9b\x07\x6e\x1e\xb8\x79\xe0\xe6\x81\x97\x07\x5e\x1e\x78\x79\xe0\xe5\x81\x97\x07\x5e\x1e\x38\x79\xe0\xe4\x81\x23\x80\x23\x80\x23\x80\x23\x80\x23\x30\x3e\x81\xf3\x2a\x80\x2b\x80\x2b\x80\x2b\x80\x2b\x80\x2b\x80\x2b\x30\x4e\x01\x7c\x01\x7c\x01\x7c\x09\x3c\x09\x3c\x09\x3c\x09\x1c\x09\x1c\x09\x1c\x09\x1c\x09\x1c\x09\x1c\x09\x1c\x09\x9c\xf0\x1e\x88\x3b\x2f\xe4\x39\x65\xf3\xb0\xc3\xf5\x32\xb4\x21\xaf\x29\xeb\x4f\xd4\xbf\x83\xa6\xbf\xa6\xd9\xd9\xde\x3b\x71\x65\xb5\x1c\xfc\x08\x67\xf0\xcd\xcd\x62\x27\xda\xe0\x98\x90\x6b\x94\xcd\xc2\x02\xc3\x05\x86\x2b\x48\x5f\xa9\x5f\x7f\x61\xae\xd8\x51\xee\xc7\xd1\x1e\x77\x8a\x6b\x3a\x7a\x0b\x7d\xaa\x77\x67\xb0\xd0\x19\xfc\xa2\x5f\x71\x4d\xf8\x9a\x8f\xa8\x92\xe8\x39\x89\x9e\x93\xe8\x39\x89\x9e\x93\xc3\xed\xa4\xd3\x3f\x54\x1d\x28\x0e\x96\xca\x83\x61\x4d\xb8\x3e\x28\x9b\x80\xc5\xb8\xc2\xf5\x41\x59\x1e\xda\x0c\xda\x65\xd0\x2e\xe3\xc6\x7b\x4b\x83\x05\xec\xf8\xb0\x49\x32\x50\x1c\x2a\x56\x86\xab\xdb\x60\xd3\x64\xa8\xa7\xb8\xb2\xd8\x1b\xef\x2c\xf7\x77\xc7\x83\xdf\x08\xc4\x0b\x08\x2f\x83\xf0\x32\x98\xa8\x2c\xc0\xb2\x00\xcb\x22\xa8\x2c\x82\xca\x22\xa8\x2c\x70\xc3\x87\x97\x6e\x22\x14\x35\x6e\x22\x14\x1b\xca\x26\x61\x53\xb1\x25\x3d\x7d\x4e\x71\xa8\x52\xea\x2b\x54\x70\x5a\x12\x21\xe5\x29\x2b\x58\xb9\xbf\x58\xe9\x29\x0d\x76\x3a\x95\xd5\x65\xed\x0c\x39\xaa\xaa\x18\xfc\x8e\x6f\x4f\x6b\xa5\x67\xb0\x08\x7f\x68\x42\x57\x69\xd5\xb0\xdf\x3a\xa4\xce\x72\x3f\x76\xc2\xae\xda\xb8\x53\x18\x1c\x2c\xaf\xee\x2d\x76\x55\xa8\xf6\xaa\x03\x2d\xda\xea\xdf\x04\x0e\x5f\xec\x2c\xaf\xee\x0f\xbd\x76\x05\xe6\xa0\x59\x67\x7f\x6b\xcd\x6b\x1f\xd2\x6a\xce\xc5\xd7\x7e\x5c\x37\xe1\xb7\x94\x07\x2b\x3d\xc1\x37\x13\x0b\xbd\xad\xa5\xfe\x4a\x70\x75\xe9\x1f\x6a\x9d\x50\x5c\x59\x2d\xad\x52\x57\x44\x7f\x47\xd1\xee\x29\x57\x87\x8a\x13\xd5\xc5\xd7\x5b\xee\x0e\x2e\x93\xfe\x72\xa5\x25\x68\xac\x74\x65\x6f\x65\xa0\xe6\xb6\xeb\xc7\x62\x2e\x9e\xb9\xba\x78\xd6\xea\xe2\x19\xa9\x8b\x67\xa1\xca\x72\xd8\x36\x58\xbc\xee\xa2\x1e\xd7\xaf\xef\x61\xdf\xc3\xbe\x8f\xe3\x43\x0d\xa1\x2c\xfa\x0f\x35\x84\xb2\x68\x1f\x6a\x08\x65\x93\xb0\x29\x58\xe0\x85\x5a\x42\xd9\x0c\x6c\x16\x76\x18\x27\x0f\x2b\x60\xc3\xcb\xc7\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\x7c\xbc\xbb\x7c\xbc\xbb\xfc\xe0\xdd\x35\xd0\xde\x5b\xee\x38\x85\xaa\x73\x15\x58\x3b\xdc\xeb\xed\x0a\xed\x60\x05\xfb\x95\xa1\x9e\x42\x67\xd1\xd6\x25\xed\x3c\x45\x5b\xa7\xab\xd4\xdb\xab\x96\x8a\x72\xf8\x1e\xc6\x93\x5b\x17\x4f\x5e\x95\xcd\xb6\x84\x2d\x06\xd5\x19\xa6\x95\xc1\x52\xa1\xbb\x3a\x10\xda\x41\xec\x77\xf6\x87\xb6\xb7\x8b\x04\xf9\x56\x6f\x78\xb5\xf8\x39\xcc\x4b\x4e\x3a\xa5\xfe\x55\xed\x55\xd5\x49\x25\xf0\xc2\x36\x2d\xe5\x81\x62\x3f\x2a\x87\xfa\x4a\xea\x12\x2d\x74\x14\xd5\xb5\xb4\xaa\xb6\x13\x1b\xaa\xf6\x93\xae\x62\x9f\xba\x9a\xe2\x41\x61\x0f\x0d\xa8\x78\xe3\x1d\xbd\xd5\x76\xbb\xa7\x58\x50\xe8\x9d\xa5\x42\x9f\x5a\x98\x26\xf4\x55\x87\x70\x7d\x15\x27\x45\x7c\xb5\x42\xe9\x08\x92\xa1\xda\x72\x73\x38\x13\x39\x9c\x89\x1c\xce\x44\x0e\x67\x22\x87\x33\x91\xc3\x99\xc8\xe1\x4c\xe4\x70\x26\x72\x38\x13\x39\x9c\x89\x1c\xce\x44\x0e\x67\x22\x87\x75\x2e\x87\x75\x2e\x97\x02\x4e\x0a\x38\x29\xe0\xa4\x80\x93\x02\x4e\x0a\x38\xa1\xaa\x73\x71\xc7\x38\x93\xaa\xd9\x36\xd8\x34\x6c\x06\x36\x0b\x9b\x83\xcd\xc3\x0a\x58\x19\xda\x30\x4b\x51\x36\x11\xda\x36\xf4\xd7\x86\xfe\xda\xd0\x5f\x1b\xfa\x0b\x55\x9c\x12\x29\x79\x58\xd1\x1a\x3e\x01\x3e\x51\x3f\x2a\x9f\xac\xde\xbe\x45\x95\x92\x06\xbf\xfd\x1a\x3c\x5a\x66\xc1\x13\xec\xd5\x25\x75\x2d\xe9\x67\xd7\x81\x47\x7a\x8a\x81\xa1\xa7\x14\xc2\x17\xf4\x83\xea\xc0\x6b\x1d\x7e\x58\x1d\xec\xb0\xe0\x71\xb2\x6e\x57\x29\xac\xd2\xaf\xaa\x9e\x4f\x1c\xe8\xad\x0e\x05\x3f\x27\x3a\x21\x78\x18\x8d\x67\xeb\x2d\xda\xd7\xee\x54\x5d\xa5\x1f\xc8\xe3\xc5\x29\x91\x1a\x5d\xe1\x04\x01\xe9\x50\x5b\x02\x2f\x7c\xd8\xae\x2b\xfb\x0a\x03\xa5\x95\x4e\x7b\xb1\x12\x36\x9f\xa0\x1f\xb9\xc3\xd7\xc1\x87\x3e\xeb\x29\x86\x8e\xb3\xaa\xb0\x0a\x2f\xeb\x47\xf1\xa8\xad\x0c\x37\x74\xd4\xa4\x84\xde\xa4\xe1\x07\xf3\x78\xa1\xe6\x4d\xd0\x63\x47\xad\x1a\x38\xbc\xfe\x2a\x3a\x6b\x0d\x1f\xd2\x87\x3b\x13\xf1\x94\x1e\x61\x0c\x3b\x13\xf4\x63\x7a\x1c\xb9\xb2\x8c\x9e\x5b\x82\xe9\x83\x5b\x9f\x02\xa7\x32\x1c\x32\x53\xc1\x87\x1f\x67\x50\x03\x0e\x3e\xaf\x10\x9c\x8e\xc0\x2a\x5a\x0c\x8c\x9e\x11\x1d\x9d\x3e\xcd\x78\xc0\x20\xf1\x80\x41\xe2\x01\x83\xb2\xde\x94\x6a\xf8\x93\xaf\xb5\x2f\x57\x4e\xec\x38\x75\x50\xad\x0a\xa5\x0e\x7d\x5f\x6d\x8a\xfe\x42\x7c\xe4\xe5\xa9\x11\x7f\x30\xf8\xbc\x76\x91\xa9\xd3\xd2\x5b\x1c\x1a\x3a\x79\x82\x62\xb2\xae\xe0\x77\x78\x03\xb6\x50\xfc\x36\xec\x4f\xd4\xbc\x36\xbc\xd7\xda\x55\xae\x0e\xd6\x77\xd4\x85\x56\x6b\xa7\x69\xae\xb6\xa7\xf9\xae\xb6\x37\x7c\x83\x62\xae\xba\x8e\x12\x93\x6a\x77\x26\x82\x5d\x3e\x11\x11\x94\xf4\x8b\x93\xd5\xc8\x82\xef\xbd\x04\xdf\x8d\x99\xdb\x51\x18\x88\xec\x27\x1a\xf6\x73\x0d\xfb\xf3\x22\xfb\xa9\x86\xe3\xbd\xda\xfe\xf0\x04\x9d\x58\xae\x04\xbf\x73\xee\xe8\x89\x9a\xab\x6a\xd1\x92\x37\xf4\xc4\x1b\x90\xbd\x26\xfb\x6d\x91\xfd\x44\x80\x1e\xd9\xcf\x35\xec\xf3\xe1\xf6\xad\xed\x85\xc1\xd2\x5c\x0c\x7e\xba\x7e\x31\x9b\x08\x1b\x24\x82\x4e\xe7\x35\xa9\x4b\x34\xd4\xf1\x26\xed\x78\x43\xbb\x64\x93\xfe\x92\x4d\xfa\x4b\x36\xe9\x2f\xd9\xd0\x5f\xba\x49\x7c\xe9\x26\xf1\xa5\x9b\xc4\x97\x6e\x12\x5f\xba\x49\x7c\xe9\x26\xf1\xa5\x9b\xc4\x97\x1e\x1d\x5f\xce\x1f\x1d\xdf\x88\xba\xc6\x76\xbc\x49\xbb\xc6\xfe\x92\x4d\xfa\x4b\x36\xe9\x2f\xd9\xa4\xbf\x66\xf3\xd7\x36\x7c\x91\x35\xa9\x6b\x6c\x97\x6c\xd2\x2e\xd9\x80\xdb\xd0\xdf\x88\xba\xc6\x76\xc9\x26\xed\x74\x7f\xc1\x17\xb2\x14\x31\x97\xf4\xed\x4c\x26\xfa\xbb\xf5\x9b\x71\xd8\x71\x87\x1d\x8f\xad\x2d\x0e\x96\x03\x8f\xaa\xe5\x42\x5b\xb5\x54\x04\xd6\xd1\xcb\x44\xe0\xb1\x60\x89\x08\x9d\x52\xf8\x16\xa7\x43\xa5\x35\xba\x8d\x5e\x22\xb4\xa7\x97\x07\xdd\xa8\xbf\x14\x76\x34\xb9\xe1\x2e\xf5\xe4\x86\x7b\xd2\x93\x46\xde\x7d\x9e\xdc\x70\x9b\xb9\xa5\xfe\xcc\xa2\xa5\xfe\x98\xc2\xa9\x3d\x95\x68\xa9\x3f\x83\x98\xd6\x80\x34\xb7\xb7\x63\x5a\x03\x98\xaa\x9a\x3a\x12\x6f\x64\x23\xdd\x8f\xaa\x9a\x58\x47\xad\xed\x0d\x77\xd0\x5a\xc3\xae\xbd\x34\x7c\x18\x0b\xdb\x54\x3b\x58\x78\x68\xb5\x63\x62\xbd\xef\xa0\x5a\xaf\xdb\xca\x99\x30\xfc\xe4\x2c\xa8\x0c\x8f\xae\x76\x4c\x8e\xfe\x1e\x49\xf0\x42\xb8\x84\xa9\x17\xc2\x1f\x36\x39\x71\xb0\xd8\x55\x1c\x54\x69\xe6\x14\xcd\x21\x9a\x69\xc0\x46\xf5\x8a\x1a\x2d\x86\x24\x3c\x71\x78\x57\x7f\x5a\x6f\x7a\x8d\x80\xea\x1f\xdb\x9b\x54\xab\x6b\xd8\xd5\x9f\xd8\x9b\x12\x91\x1e\xba\x56\x13\x3c\x48\xb2\xaa\x3f\xb4\xa7\xd2\xae\x6c\x1e\xbe\x1b\xf1\xbd\xc0\x8f\x1f\x75\x62\x56\x84\xff\x39\x87\x05\xff\x31\xce\x30\x77\xec\x50\x3e\x7e\xaf\x7b\xf3\xc7\x2e\xfb\x69\x60\x37\x2d\xfd\xd1\x27\xf5\xfe\xe7\x77\xdc\xa6\x5f\x09\xfe\xe7\xeb\x1a\xe3\x74\xfd\x2b\xdf\x53\x0d\x23\x7e\xa7\x61\xc6\x37\xc5\xb7\x1a\xb1\xf8\x1f\xe3\x7f\x54\xfe\xb6\xf8\x36\xe5\xbf\x1a\x7f\x55\xf9\xaf\xc5\xdf\x54\xfe\x5b\xf1\xb7\x94\xbf\x3d\xbe\x5d\xf9\x3b\xd8\x75\x86\xc9\xae\x67\xd7\x1b\x31\x76\x03\x7b\x5c\xf9\x4f\xb0\x27\x0c\x8b\x3d\xe9\x2c\x36\x4c\x67\x89\xf3\x09\xc3\x0a\x7e\x7b\x49\xf9\xcb\x9d\xa3\x8d\x98\x73\x8c\x73\x8c\x11\xfc\x5f\xb5\xf0\x37\xc5\xcd\xc8\xd6\x62\xcc\x35\x8e\x35\x2c\xc5\x22\xbd\xc6\xa4\x9e\x62\xfb\xa0\xb1\xbb\x6e\x17\xfc\x67\x2c\xa3\xe6\xe9\xd6\x01\xe9\xa8\x31\x1a\x6a\x8c\x3b\xff\xdd\xf1\x99\xaa\xcf\xa4\x31\xdf\x90\xc6\x62\xe3\x68\xfd\xbf\x06\x4e\x37\x3e\x6b\x5c\x60\x5c\x62\x5c\x61\xac\x37\x1e\x35\x9e\x31\x5e\x30\xb6\x19\xdb\x4d\x62\x4e\x32\x67\xaa\x3e\x4c\xf5\xf7\x92\xb2\xd4\x30\x63\xe7\x86\xfb\xb1\x75\xa1\x8d\x9f\x19\xda\x16\xa9\x30\xd4\x08\xa6\x0c\x4e\xb9\x6d\xea\xcc\xa9\x3d\xe1\xde\xd4\xab\xa6\xed\x37\xed\x8a\xe9\x07\x84\x7b\xd3\xcf\x9b\xfe\xf4\x8c\xe4\x8c\xb3\xc2\xbd\x19\x9b\x77\x5b\xbc\xdb\x1d\x33\x0f\x0f\x8f\x9f\x79\x6d\x68\xf7\x38\x39\xb4\xb3\x66\xea\x56\x6c\xaf\x8d\x7b\xcf\xdb\xfb\xec\xbd\x9f\x9e\x3d\x7f\xf6\x85\xb3\x5f\xde\x67\x91\xae\x9d\xb8\xcf\x59\xfb\xdc\xb8\xcf\x96\x39\xbb\xcf\x39\x7c\xce\x9a\x39\x57\xce\x79\x78\x5f\xb6\x6f\xdb\xbe\x3d\xfb\x5e\xb8\xef\x26\xfd\xba\xb5\xef\xc3\xfb\x91\xb0\x9f\xfd\x0e\x0c\xed\xfe\x0f\x85\xf6\xc0\x0b\x42\xfb\xe1\xfb\xf5\xa8\xcc\xc4\x79\xb0\x17\x19\x96\xb6\xeb\x0c\xd3\xba\xc0\xea\x57\xe5\xc5\x6a\xb6\x16\x19\x17\x19\x97\xaa\x59\xb9\xca\xb8\xd6\xb8\xd1\xb8\xd9\xb8\xcd\xb8\xcb\xb8\xd7\x78\x48\xcd\xd1\x53\xc6\x16\x35\x4b\x5b\x8d\x37\xd4\x41\xc4\x6c\x35\xa7\x99\xbb\x9b\x7b\x99\xfb\x99\x07\x9a\xf3\xcc\xa4\x79\x88\x99\x35\x0f\x37\x17\x9b\xcb\xcd\xe3\xcd\x93\xcc\x2e\xb3\xd7\x1c\x34\xd7\x98\xa7\x99\x67\x98\x67\x9b\xe7\x9a\x17\x98\x17\x9b\x97\x99\x57\x9a\x57\x9b\xd7\x9b\x37\x99\x1b\xcc\x3b\xcc\xcd\xe6\xfd\xe6\xc3\xe6\x63\xe6\xd3\xe6\x73\xe6\x4b\xe6\x36\xf3\x4d\xcb\xb2\x98\x35\xc9\x9a\x61\xed\x69\xcd\xb6\xf6\xb7\x0e\xb2\x5c\xab\xcd\x9a\x6f\xe5\xad\x85\xd6\x52\xeb\x68\xeb\x84\xe0\x8c\xdb\x17\xa8\x72\x86\x2e\x37\xe9\xd2\xa8\x97\x56\xb7\xf6\x1f\x6d\xac\x37\xcf\x6d\xac\xd9\xf1\x54\xa3\x1f\xb6\x31\xe3\x91\x96\x7b\x35\x1e\x35\x56\xb9\xe3\xb6\x48\xcd\x9a\x51\x65\xa7\xfd\x95\x9a\x3f\x56\x0f\x4f\xed\xac\xe7\x1d\x27\x35\xfa\x4d\xfa\x19\x63\x4e\xcc\xcd\x8d\x73\x82\x9a\x51\xe8\x98\x87\xf8\x9f\x33\xea\xd1\x7d\xa2\xcd\x49\x4d\x63\xb6\x0c\x12\xdf\x61\xcf\x32\x0c\xb6\x96\xad\x35\xf6\x52\xab\xc5\x0d\xc6\xde\xec\x7b\xec\x66\x63\x36\xdb\xa0\x56\x8e\x03\x9c\x23\xd4\x9a\x71\xb8\x7e\xaf\xbd\xa4\xdf\xe7\x44\x9d\xdd\x2e\xfb\x64\xe5\xcf\x52\xef\x64\xd3\x98\xa3\xae\xd3\x60\xed\x30\x63\x5b\x74\xaf\x26\x5b\xab\x5b\xbf\x16\x69\x1d\xd4\xdf\xa1\xde\xdf\xa6\xb1\x59\xb5\x9e\x66\xec\x6f\x1c\x64\xb8\x46\x9b\x5a\x03\xf2\xc6\x42\x63\xa9\x5a\x05\x4e\x30\xda\x8d\x1e\xfd\x9f\x18\xd6\xaa\xd5\xe0\x4c\xe3\x9c\xe0\x38\xeb\xd8\xe1\xd2\x3c\xd4\x5a\xaf\xfc\xeb\x62\x19\xd5\xc7\x2d\xd6\x2c\x55\xba\x41\x8d\xe1\xc6\xd6\x0e\x97\x68\xbf\xbf\x71\x88\x6a\xbf\x31\x72\xec\x8d\xd6\xe9\xaa\xbc\xda\xba\x57\x95\xdb\x75\xfd\x65\xd6\xf9\xaa\xbc\xda\xbc\x73\xb8\x34\xa6\xd9\xc4\x6e\xb5\x27\xd9\x53\xed\x19\xe1\xef\xe8\xaa\xf9\xa8\xff\xa6\x5f\xf0\x8b\x7e\x1b\xd8\x2d\x7a\x5c\xaf\xd4\xc7\x15\x44\xa0\x56\xe2\x7b\x0c\x4b\xcd\xa0\x7a\xb7\x9a\xae\xd9\x66\xce\x37\xf3\xe6\x42\x73\xa9\x79\xb4\x79\x82\xd9\x6e\xf6\x98\xfd\x66\xc5\x5c\x6b\x9e\x6e\x9e\x69\x9e\x63\x9e\x67\x5e\x68\x5e\x62\x5e\x6e\x7e\xd3\xbc\xc6\x5c\x67\xae\x37\x37\x9a\x9b\xcc\x7b\xcc\x07\xcd\x47\xcc\x27\xcc\x67\xcc\xdf\x99\x2f\x9b\xaf\xa9\x08\xe3\x56\x8b\x35\xc5\x9a\x69\xcd\xb2\xe6\x58\x07\x58\x73\x2d\x6e\x1d\x6c\x1d\x6a\x49\x6b\x91\xb5\xcc\x3a\xd6\xfa\xa4\xd5\x69\x9d\x6c\x0d\x58\xab\xac\x4f\x59\x9f\xb6\xce\xb2\x3e\x6b\x9d\x6f\x5d\x64\x5d\x6a\x5d\x61\x5d\x65\x5d\x6b\xdd\x68\xdd\x6c\xdd\x66\xdd\x65\xdd\x6b\x3d\x64\x3d\x6a\x3d\x65\x6d\xb1\x5e\xb0\xb6\x5a\x6f\xc4\x8c\x18\x89\xb5\xc6\xa6\xc5\x76\x8f\xed\x15\xdb\x2f\x76\x60\x6c\x5e\x2c\x19\x3b\x24\x96\x8d\x1d\x1e\x5b\x1c\x5b\x1e\x3b\x3e\x76\x52\xac\x2b\xd6\x1b\x1b\x8c\xad\x89\x9d\x16\x3b\x23\x76\x76\xec\xdc\xd8\x05\xb1\x8b\x63\x97\xc5\xae\x8c\x5d\x1d\xbb\x3e\x76\x53\x6c\x43\xec\x8e\xd8\xe6\xd8\xfd\xb1\x87\x63\x8f\xc5\x9e\x8e\x3d\x17\x7b\x29\xb6\x2d\xf6\x66\xdc\x8a\xb3\xf8\xa4\xf8\x8c\xf8\x9e\xf1\xd9\xf1\xfd\xe3\x07\xc5\xdd\x78\x5b\x7c\x7e\x3c\x1f\x5f\x18\x5f\x1a\x3f\x3a\x7e\x42\xbc\x3d\xde\x13\xef\x8f\x57\xe2\x6b\xe3\xa7\xc7\xcf\x8c\x9f\x13\x3f\x2f\x7e\x61\xfc\x92\xf8\xe5\xf1\x6f\xc6\xaf\x89\xaf\x8b\xaf\xd7\xd7\x86\x0c\x4a\x72\xb9\x3a\x37\x5b\x03\xdf\xdc\xaa\xfd\xcd\xda\xdf\x1c\xf8\xd6\x2c\xdd\x66\x96\xf6\x17\x6b\x7f\xb1\xf6\x23\xc7\x8e\xf0\xa3\x6d\xc6\x68\x6f\x3e\xa1\xfb\x7f\xa2\x11\xd7\x5a\xaf\xdb\x1c\x3b\xea\xd8\xb0\x7e\xfd\x28\xac\xfd\xb5\xbf\xff\xa8\xf6\x03\xda\x1f\xd0\x7e\x5e\xfb\xf9\x51\xfe\xb1\x11\xac\x68\xfd\x3c\xed\xcf\xd3\xb1\x6d\xd4\xb1\x6d\xdc\xe9\x18\xc7\x9a\x87\x5d\xf5\xc7\x98\xe7\xf1\xcc\xcf\x88\x38\xa3\xb1\x9d\x1d\xe9\x7f\x3c\xfe\x38\xe2\x1c\x71\x9d\x84\xfe\xe5\xa3\xe2\x8f\xce\x6d\x18\xf3\x95\x3b\xc5\xba\xb7\xde\x66\x44\xff\x0f\x8d\x31\xf6\xb3\x23\xd7\x03\x8b\xb4\x89\xf6\x99\x8f\x5c\x1b\x63\xf9\xd1\x73\xfd\x44\x64\x2c\x67\x8f\xba\xc6\x10\x73\xa4\x0c\x7b\x98\x56\xf7\xcd\xed\x61\x9f\x75\x3f\xb6\x4c\x1f\x7b\x76\xa3\x1f\x3d\x5f\x11\x7f\xfc\x6c\x30\xb5\xf6\x7b\xe8\xc1\xaf\xa1\x3f\xa0\x7f\x05\xfd\xe1\xf8\xe3\xfa\x37\xcf\x9f\x51\x6b\xe2\x9f\x94\xf6\x54\xba\x55\x69\xbc\xe0\x7f\xf3\x18\xc6\x32\xb5\x05\xff\x8f\x26\x50\xb9\x9d\x6a\x3b\x59\x6d\x03\x6a\x5b\xa5\xb6\x4f\xa9\xed\xd3\x6a\x3b\x4b\x6d\x9f\x55\xdb\xf9\x6a\xbb\x48\x61\x5c\xaa\xec\x15\xf5\x39\x7d\xc7\xca\xfe\xc8\x79\x9a\xa4\xfd\x8b\x6a\xeb\xf8\xdc\xff\xbf\x8e\xff\x59\xeb\xf8\xe2\x40\xf3\xa3\x9c\x17\x29\xbb\xea\x65\xec\xc8\x7a\x19\xad\x1f\x51\x9e\xb0\xd3\x57\x47\x95\xe6\xe5\x91\x72\x6b\xa4\x8c\xd4\x8f\x75\xac\x52\x20\xf5\x9a\x7c\xa4\x3c\x36\x52\x9e\x5f\x2f\xcd\x1b\xeb\xa5\x75\x70\xbd\x8c\x6d\xd0\xf5\xdb\x1b\xfb\x89\x85\x63\xe9\xd5\xfe\x19\xba\xcd\xc6\x51\xfd\x8f\x7b\xa4\x28\x47\x1f\xc5\x22\x33\xbf\x78\x67\xf3\x3c\x9e\xf9\x09\x23\x44\x9c\xa3\x71\xef\x1d\xaf\xaf\xdf\xbb\x98\xb7\xa8\x8f\x38\xcf\x1f\x75\x9d\x1c\x5b\xc7\x8d\xcd\x8f\xd4\x47\xe6\x5f\xa9\xad\xa0\xcd\x24\xed\x9f\xad\xfd\x83\x22\x11\x5e\x59\x47\x37\x77\x8f\x8c\x71\xb9\x2e\x37\x47\xca\xd1\x63\xbf\x32\x12\x43\x4f\xa4\xe6\xca\xc6\x79\x1b\x71\xee\x22\x65\xf4\x5c\x47\x67\x7b\xc4\xfc\x44\xc7\xd2\x15\x19\x4b\x64\x1e\xa2\x71\x46\xfb\x1f\x71\x9d\x8f\x2e\x97\x37\xf8\xe3\x5f\xc7\xf7\x8c\x6f\x8a\xdf\x1d\xbf\x7f\xc4\x7f\xaf\x78\xb2\xc9\xff\xab\x78\x39\xbe\x35\xfe\x66\x7c\x7b\xf8\x6b\xcd\xc6\x9e\xc6\x78\x56\x70\x03\x2b\x78\xf8\x3f\x7a\xaf\x55\x5b\xf0\xde\xb9\x59\x6d\xb7\xa9\xed\x2e\xb5\x05\xf3\xf2\x90\xda\x1e\x55\xdb\x53\x2a\x9a\x2d\xca\xbe\xa0\xb6\x60\xee\xde\x08\x2e\x9d\x51\xef\x81\x19\x63\x94\x63\xb5\x19\xeb\xa8\xd1\xed\xc7\xaa\x71\xc7\xec\x27\xa6\x73\x20\x33\xd8\x0f\x5a\x19\xc1\x9d\x0f\x95\xfd\xc7\xb7\x29\xee\xb3\x82\xbb\x30\x91\x33\x10\xcc\xfd\xde\xea\xd5\x49\x3b\xe3\x4d\xd5\xa3\xa5\x7a\x3c\x44\xf7\x69\x34\xf4\xf8\x76\xc7\x36\x47\x7c\x9b\x18\xf5\x95\x61\xe8\x6b\xc2\xd4\xd7\xc4\x3e\xef\x76\x8c\x4d\x10\x83\x18\x17\x22\xc6\x93\x74\x8f\x53\x54\xb9\xc7\x2e\x5c\x99\xc3\xd7\xe5\x58\xb3\xde\xd2\xac\xaf\xbf\x02\xee\xe4\xb7\x39\xee\x1d\x8d\xa0\xe9\xb9\xfc\xbf\x1f\xc1\x58\x73\x6f\x19\x7c\xc4\x55\x34\xf5\x6d\xaf\x9e\x9d\xbf\xb7\x82\x91\x70\x8c\x64\xe1\x38\x7b\x1c\xeb\xbc\x85\x38\x7f\x61\x8c\x63\x5c\xe9\x7f\x46\x8c\x4d\xe7\xb5\x1e\xe3\x42\xa3\x37\x12\xe3\xb4\x3f\xf3\xfc\xbd\xfd\xb5\x32\xd6\xbc\x07\x11\xb4\xbf\x23\x11\x34\xbf\x56\x76\x86\xfb\x57\x1b\x79\xd3\xb3\xf9\x57\x18\x79\xb3\x73\x8f\x3b\xc4\x97\xfe\x8d\xdf\x21\x7e\x29\xc8\xb1\xc6\x2a\xad\x55\x61\xd6\xd9\xbc\x7e\x44\x7b\x23\xe2\x9f\x33\xea\xd8\x4d\x91\x72\xa7\x88\xa3\x4b\xf3\x93\x8d\x65\xb4\x7e\xcc\x63\x8d\x71\xbf\xba\xf3\x96\xa3\xe7\x24\xbc\x0b\xc1\x1a\x6b\x9a\xf4\x7f\xce\xa8\x19\x18\xff\xa8\xb7\x8e\xf1\xea\x9a\x20\x1b\x46\x59\xaf\x1f\xbf\x96\x8c\xc5\xef\x8d\x3f\x11\xff\x8d\x7e\xba\x15\x28\xdb\xe0\x5d\xb1\xa7\xd2\xc6\xad\x41\x5f\xe1\xdd\x87\xd8\x97\xf4\xa8\xc2\xeb\xf7\x92\xbf\xed\xeb\x37\xbe\xa7\x8e\xf8\x8c\xf0\xae\x49\xdd\x8f\x6d\x89\xdc\x4d\x78\xa4\x5e\x13\xad\x8f\xcd\x8e\x94\x03\xcd\xdb\x58\x2f\x34\xd6\x8f\x28\xd7\x35\x22\xc6\x4e\x08\x4a\x44\x15\xbe\xca\x47\x95\x5b\xea\x73\x1d\x8d\x1f\xf5\xd1\xa8\x22\x7d\x86\xbd\xd9\x33\xea\x47\x45\xfd\xd1\xe5\x98\x73\x72\x76\xa4\x3e\xac\xb9\x64\x14\x6e\xb4\xfd\x58\x33\xb0\xd3\x51\xe3\xa8\x33\x22\xe5\xba\x51\x65\x1d\x71\xfc\xd7\xaf\x15\x7f\x30\xfe\x73\xfd\x04\xb4\x25\xd4\x41\xa6\xbe\xe3\x67\x7e\xea\xef\xe7\x9a\x8d\x6d\xd1\xd9\xe8\xe1\xba\x9c\xad\xb3\x96\xd7\xb4\x7f\x99\xf6\xa7\xe9\x0c\x71\x7b\xbd\x26\x5a\x1f\x3f\xcd\xa8\x65\xdf\xe1\xb1\xd1\x36\xb1\x65\xba\xe5\x23\x8d\xf5\xf1\x6b\xb4\xaf\xef\x6f\x58\x2f\x68\x7f\x6d\x24\x2f\x8e\xf6\x73\xa1\x2e\x5b\x47\x95\x5b\x22\xb8\x5b\x1a\x63\x46\x0f\xd1\x7e\xba\xea\x88\x23\x22\x8c\x96\x5b\x46\x95\x63\xcd\xc9\xaa\xfa\x0c\x44\x6b\x30\xae\x51\xb3\x11\x9d\x81\xe8\xd8\x31\x03\xa3\x47\x1d\xe9\x13\x31\xcc\x8f\xb4\x5f\x5f\x2f\xc3\xde\x74\xb9\x2b\xd7\xec\x7d\xf1\xa7\x47\x5c\xb3\xb7\x1b\x07\xa8\xf2\x56\xb5\x1f\x66\x6a\xf3\x23\xfa\x64\x7a\xed\x88\xb7\xd7\x3c\xa6\x31\x53\xff\x0f\xca\xe0\x3f\x50\x32\x7b\x82\x3d\xd9\x7e\x0f\xbb\x51\x3f\x0b\x0b\xfe\x93\x55\xf0\x7f\xac\xee\x61\xf7\xb1\x07\xd8\x2f\xd8\xa3\xc1\x7f\x75\x52\x68\x31\x63\x2f\x63\x3f\xe3\xc0\xe0\xc8\x26\x78\x66\xfc\x79\x5d\x3e\xfb\x2e\xf4\xbc\xf5\x5d\xee\xf9\xf9\x77\xad\xe7\xdf\xbd\x6b\x3d\xbf\xf0\xae\xf5\xfc\xe2\x9f\xd1\x73\x70\x25\xce\x19\xe3\x4a\x0c\xfb\xdd\xf5\x1e\xc3\x48\x87\x7b\x0c\x72\x2a\xa2\x55\x74\xa8\xa0\xb7\x8e\x38\x7f\xe3\x6d\xff\x08\xce\xca\xae\xf5\x3f\xfe\xf6\x61\xff\xbf\x1f\x77\xfb\xfb\x76\xb1\xfd\xdd\x38\xf7\xe3\x6d\xff\x2c\xce\xe8\x78\xdb\x3f\xbf\x8b\xed\xef\xde\xc5\xf6\xf7\xed\x62\xfb\x47\x76\xb1\xfd\x2f\x77\xb1\xfd\xd6\x48\xfb\x39\x6a\x65\xb5\xd4\x3b\x63\x16\x8e\xd8\x2d\xd2\xe3\xa3\xc6\xf0\x27\x24\x4c\x7b\xea\x38\x5b\xbf\x82\xd6\x7f\x2f\xda\xe2\xcd\xe0\x73\x1c\xe1\xa7\x3c\x94\xb2\x0a\xca\x0b\x23\x35\x67\x44\x4a\x5d\x13\x6f\x6b\xac\x19\x5d\x2a\x5d\xd7\xfc\x58\x32\xaa\xfd\x83\x91\x32\x82\x18\x5f\x14\xa9\x19\x18\x55\x6e\x89\xc4\xf9\xe6\xdb\xc7\x13\x2d\xed\x47\xeb\xfd\x47\x7d\xf4\x13\x2d\xc7\x9a\x93\x75\xf5\x1a\x8c\x74\xdd\x38\xe6\x61\x74\x3c\x2f\x47\xda\x6c\xa9\x47\x12\xad\x19\xd1\x4f\xe8\x9f\x56\x2f\x23\x6d\x76\x45\x5b\x84\x77\xb2\x6a\xda\x22\xfc\x24\x0f\xca\xf0\x9a\xdd\xfc\xb7\x7d\xcd\x86\x6a\x6d\x97\x9f\xb2\x85\xcf\x07\x37\xd5\xfd\x26\x4f\x12\xef\x6d\x7e\xd4\x88\x67\x52\x7f\x79\x39\x46\xfc\x3b\x7f\xb2\x39\xba\x8c\xaa\xe8\x5d\x9e\x93\xf5\x8d\xe3\x1a\x0b\xfd\x2f\x1f\xfb\x88\xa7\x5a\x07\xd5\xca\xf1\x5f\xb3\x7f\xce\xdd\xb7\x3d\x14\x42\x80\x1e\x3c\xbd\x1b\x34\x82\xcf\xdd\x1a\x46\x90\x0b\x05\x0a\x3d\x78\xce\x78\xae\xda\x2e\x50\xdb\xc5\x6a\x0b\xd4\x7c\xf0\x54\xf0\x6a\xb5\x5d\xaf\xb6\x9b\xd4\xb6\x41\x6d\x77\xa8\x2d\x78\x6a\x77\xbf\xda\x1e\x56\xdb\x63\x6a\x7b\x5a\x6d\xcf\xa9\xed\x25\xb5\x6d\x53\x23\x39\x38\xe0\x98\x71\x95\xbb\x8f\xbb\xe5\x2e\x96\xea\x3d\x19\x94\x6f\xd4\x4b\xbc\x8f\xd7\xfd\x8d\xbf\x8f\xc3\x3b\x26\xf9\x51\xe5\x78\x3e\xf1\x11\x69\x19\xde\x25\x79\x07\x3e\x45\x32\x7e\xf4\x9d\x96\x6f\x13\xcf\xfa\x31\xfc\xbf\xa0\x34\xcf\x7d\xe7\x67\x23\xec\x73\xf8\x73\x44\xba\xe7\x07\xeb\x65\xa4\xe5\xf8\xdf\xc7\x3b\x7f\x26\x12\xdc\x5d\x0c\x3e\x7b\x71\xa8\xb1\xab\x9f\x30\x1a\xbe\x1b\x37\x56\x79\x55\xc4\xbf\x2b\x72\x3f\x69\xec\xa3\xfa\x8d\xbf\x17\x2e\x7c\xa7\x38\x69\xf4\xaa\xbd\x75\x1c\x6d\xce\x35\x9a\x32\xeb\x5f\xbf\x1c\xf3\x33\x2e\xef\x72\xf9\x0e\x8d\xfa\xff\x09\x2e\x8c\x0d\x04\xdc\x13\x0b\xde\x9f\x75\x7f\x74\x19\xbc\xba\x6e\x8c\x36\x5b\x74\x79\x57\xa4\x1c\xbb\x9f\xc6\x3e\xc7\xc0\x0d\xbe\xbd\x61\x1e\x6a\xd4\xef\xaa\xe9\x9c\xf0\xad\xa7\x87\xff\xb6\x0f\x34\xc9\x11\x83\x36\xc1\x5f\xab\xce\xeb\x36\xed\x68\x43\x9e\x67\x18\xe1\xf7\x67\xe6\xab\xf9\x8c\x7e\x7f\x66\xff\xe0\x1c\x1e\x79\x44\x7e\xb6\x31\xe5\xa8\x65\x59\x55\xe2\x1b\x34\x56\xed\xdb\x34\xe1\x77\x70\x62\x1d\x1d\x7d\x2a\xaa\xce\xde\x52\xb7\x31\xab\xb7\xdc\xd1\xab\x32\xca\xe0\xec\x5b\xf8\xf6\xd0\xf0\x37\x74\x6c\x85\x3c\x43\x65\x99\xfb\x19\x07\xa1\xee\x00\x7c\x67\xe6\x20\xd8\x43\x82\x4f\xab\xeb\xfb\xbe\x7a\xdf\x0a\x22\x24\xf6\xaa\xc0\x8f\x3d\xa9\xca\x69\xe1\xc8\x8d\x78\xf0\x1d\x21\x7b\x82\x8e\x5f\x45\x64\x5e\xac\xae\x86\x36\x23\xab\xd6\xb4\xa3\x8d\x93\xd4\x7a\x5a\x51\x57\xc2\x59\x6a\x7d\xbb\x5c\x9d\xf1\x0d\xc6\x23\xc6\xd3\xc1\x17\x6f\xcc\x19\x6a\x15\x3b\xc0\x74\xd5\x0a\x26\xcd\xa5\x66\xf0\x7d\x96\xb8\xb3\x5c\xcd\xe0\x56\xed\xad\xa8\x79\x47\xd7\xbc\xa3\x94\xf7\x8a\xc6\xbb\xb3\xe6\x6d\xaa\x79\x3f\xae\x79\x77\x69\x4f\x5d\xef\x46\x2b\x7b\x54\xf9\x2f\xb1\x9f\xd4\x5e\xdb\x5c\xf3\xee\x8e\xb4\xba\x27\xf0\xd9\x75\xaa\x7c\x5e\x7f\xdf\x6a\x92\x31\x43\xbd\x17\xac\xf8\xb3\xce\x91\xaa\x7c\x91\xfd\xb4\x76\xd4\xbd\xda\x0b\xda\x4c\x31\x66\x3a\x47\x18\xb1\xf8\x2b\xf1\x97\x9c\x45\x1a\xe5\xbe\x5a\xab\xfb\x6b\xde\x03\x35\xef\xc1\x9a\xf7\xb3\x9a\xf7\x50\xcd\xfb\x79\xcd\x7b\xb8\xe6\xfd\x42\x7b\x54\x21\xed\x6e\xcc\x56\x67\x67\x9e\x91\x34\x0e\x61\xb7\x2a\xcc\xd7\x55\xb4\xb7\x6a\xec\xd7\xd9\x46\x65\x5f\x53\xfb\x1b\xf5\xfe\x6b\xec\x11\x3d\x96\x5b\x54\xf9\x3a\xdb\xa0\xca\xd7\x74\x5f\xbf\xc4\x68\xa9\x7a\x17\xab\xf7\x93\x5a\x09\x6c\x23\x66\x53\x75\xd6\x5a\xec\x89\xf6\x44\x63\xb2\x3d\xd9\x9e\x62\x4c\xb1\xa7\xd9\xd3\x8d\x69\xf6\x6e\xf6\x1e\xfa\x73\x4a\x86\xbe\x96\xe7\xe8\x6b\x22\xb8\x46\x82\xeb\xc0\x56\xc7\x1a\x76\x8b\x3d\xdd\x0e\x3e\x1f\x14\xd3\x2b\xc1\xb6\x31\x3f\x11\xb1\x50\x5d\x67\x53\x54\x0f\x07\xa9\xd8\x0f\xc5\x6c\xdf\xae\xe7\xf4\x36\x55\xbe\xa0\x63\xfb\x55\x90\x31\x6a\xef\xb1\x9a\xf7\x78\xcd\xbb\x01\xed\xa2\xb8\xc6\xff\x09\x00\x00\xff\xff\x5e\x38\x55\xf3\x74\x9a\x04\x00") + +func liberationmonoBoldTtfBytes() ([]byte, error) { + return bindataRead( + _liberationmonoBoldTtf, + "LiberationMono-Bold.ttf", + ) +} + +func liberationmonoBoldTtf() (*asset, error) { + bytes, err := liberationmonoBoldTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationMono-Bold.ttf", size: 301684, mode: os.FileMode(420), modTime: time.Unix(1459927769, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationmonoBolditalicTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xbd\x77\x7c\x54\xd5\x16\xf7\xbd\xf7\x39\x33\x99\xf4\x5e\x80\x40\x66\x92\x90\x04\x48\x20\x40\x02\x01\x04\x32\x94\x84\x0e\x09\x10\xc8\x50\x13\x08\x45\x3a\x26\x34\xa5\x4a\x11\x11\x14\xa4\x2a\x48\x51\x54\xec\x41\x51\x8a\xa8\xd8\x2b\xf6\x8a\xa8\x48\x8b\x05\x7b\x17\x32\xf3\x7e\xf7\x39\x67\x20\x72\xf5\x7a\x9f\xcf\xf3\xfc\xf7\xe6\xde\x35\xfb\x9c\x7d\xf6\x5e\xeb\xb7\x7e\x6b\xed\x76\x26\x44\x21\x85\x10\xd1\x7c\xd8\x84\xab\xb0\x70\x70\xbf\x72\xd7\xf2\x3d\xc2\x16\xb0\x98\xda\x86\x3d\xba\x17\x14\xce\xfb\x64\xc6\x5b\xdc\x6f\xe3\x7e\x65\x8f\xa2\x01\x83\xde\xfe\xe5\x75\xa7\xb0\x39\x1a\x0b\x91\xd3\xb9\xc7\xa0\x92\xae\x53\x1b\xf4\x7f\x5e\xd8\x3a\x54\x08\xa1\xe7\x0e\x18\x94\xdd\x5a\x3e\xf7\xc4\xc3\x42\xc8\x3d\xb4\x2f\x1b\x3b\xb5\x7c\x46\xb7\x86\x0d\xdf\x13\x22\x63\x8a\x10\x01\x2d\xc6\xce\xae\x72\x4d\x0e\xba\x7a\x86\x10\xed\xdf\x15\x42\x7b\x66\xfc\x8c\x09\x53\x17\x96\x3f\x16\x25\x44\x73\xf4\x3b\xf6\x4d\x28\xaf\x9c\x21\xe2\x45\x10\xf6\x68\x23\x22\x27\x4c\x99\x37\xfe\xd8\xaa\xb3\x8d\x84\x18\x63\x13\x7a\xc7\x03\x13\xc7\x95\x57\x5c\x78\x77\xd9\x4c\xf4\x67\xf1\xbc\xed\x44\x2a\x82\x3a\xd8\x5f\xe7\x1e\xfb\xa2\xf1\xc4\xa9\x55\x73\x8f\x67\xfc\xf2\x1b\xba\x03\x85\x48\xab\x98\x32\x7d\x6c\x79\xc4\xbe\x0d\xb4\xed\xb8\x85\xfb\x29\x53\xcb\xe7\xce\x08\x6b\x6b\x7b\x85\xf6\x2b\x69\xef\x9a\x56\x3e\x75\x9c\x6d\xc7\xcd\x2f\x09\x7d\xfb\x61\x21\x42\x7e\x9b\x31\xbd\xb2\xea\xe4\x6b\x03\x1b\x09\xfd\xde\x7d\x42\x0c\x3f\x38\xe3\xaa\x71\x33\xee\x6a\xf0\x12\x4d\xdb\x14\x41\xd0\xb5\x06\x57\x9a\x10\x2b\xf2\x3f\x9b\x32\x3a\xa2\xe3\x2f\x9a\x13\x33\xfc\xbc\xb6\xbe\x51\x0f\x7f\x79\x21\xed\x42\x6d\xc0\x60\xc7\x17\x42\x17\xea\xa1\x34\x1a\xf0\x19\x70\x4f\xed\x2d\xe8\x38\x7a\x21\xed\x8f\xfb\x03\x06\x8b\x0a\x11\x27\xea\xfc\x04\x95\xaa\x36\x41\xc3\x64\x8a\xe8\x29\xc6\x89\x00\xac\x44\x8a\x6c\x31\x02\x56\x93\xf4\x28\x74\x49\xa1\xdb\x8e\x6a\x87\x85\x5d\x08\xfb\xad\xf6\x1c\x91\x24\x1b\x19\x65\x91\x5e\x2e\xc6\x6b\xd1\x81\x76\xcd\xe1\x08\xd2\x34\x7b\x90\xcd\x76\x42\x04\xfb\xdc\x62\xae\xcf\x6f\xbd\x55\x97\x41\xdd\x44\xb2\x70\x79\x53\xed\x51\xde\xc1\x0a\x89\x36\xa1\x4c\xc8\xa7\x3e\x83\x27\x5b\x07\x7b\x81\x62\x42\x84\xdb\x8e\x8a\xf5\xaa\x35\xa5\x25\x72\x32\x32\x8c\xeb\x7a\x48\x13\xdb\x51\xdf\xbb\xc8\x37\xa0\xe8\x4c\x7d\x2b\xea\xe6\x50\xf6\xa5\x1c\x87\x0c\xe4\x3a\x13\x99\x4a\x9b\x73\xdc\x5f\x85\x64\x21\xd1\xc8\x15\x48\x3c\xd2\x0d\x59\x84\xd4\x20\x05\xc8\x28\xb3\xbd\xd8\x64\xe9\xf0\xcb\x16\x24\x04\x3d\x9b\x29\x5d\xc8\x20\x24\xc9\xba\xc6\xb6\x18\x8c\x24\x23\xb9\x48\x6f\xc4\x89\x4c\xa2\xfd\x9f\x56\x3b\x7f\x5d\x6f\xab\x8f\x0d\x79\x10\xb9\x12\xd9\x69\xb5\xdd\x6c\x5e\xfb\xbe\xa5\x3c\x08\x0e\x85\xb3\xab\xe5\xe7\x04\x7c\xb4\x73\x9d\x83\xa4\x22\x23\x91\x7e\x96\x5d\xda\x8a\xc6\x48\x3a\x12\x46\xdb\x67\x28\xbb\x5b\xd7\x27\xad\x7a\x38\xf1\x7d\x68\x96\x62\x9d\xf5\xfc\x0c\x32\x02\x59\x89\x78\x78\xfe\x12\xf2\xbe\xe5\xc7\x03\xd8\x3f\xc5\xfd\x05\xae\xcb\x2c\xee\xf3\x28\xe1\xdf\xf7\x35\x65\x27\x8b\x5f\xda\x88\xfa\x94\x77\x9a\xfe\x49\x85\x71\x81\x89\x4b\x71\x6f\xf8\x7c\x3f\xd7\xe9\x26\x8f\x52\xb5\x6d\x8f\x10\x0f\xdf\x8b\xd4\x3d\xcd\xf5\x93\x5c\x6f\xa5\x4c\x40\x3a\x50\xd7\x16\xc9\xb0\x62\xdc\xd9\xe4\x4f\x71\xf3\x4f\x62\xc4\xc2\x75\x99\xe4\x5e\x26\x31\x75\xe2\x70\xb9\x8c\x47\xcf\xab\x56\x2c\xea\xca\x4e\x4b\x57\x82\xc5\xfb\xdf\x88\xef\xb8\x15\x8b\xc1\x97\x49\xd8\x65\x72\xc5\xa5\x38\xfc\x87\xa8\xfc\x72\x58\xb1\xa8\x23\x2a\x16\xbe\x77\xac\x72\xb3\x65\xef\xb2\xd2\xf0\x7d\xe4\x7f\x29\x93\x2c\xdd\xca\xff\x02\xcb\x9f\xc1\xff\x43\x39\xd8\xca\xa9\x7f\x2a\x93\x2d\x7f\xfc\x65\xae\xe5\xe7\xbf\x94\xbe\x13\x94\x5d\x4c\xde\x8d\x3c\x75\x5a\xb9\xa8\x64\x92\xd5\xb6\x4e\x69\xf0\xeb\xbf\x97\x56\x99\x64\xd9\xbc\xbc\x2c\x45\x42\xad\xeb\xde\x16\xb7\x97\x97\x89\x88\x66\xf9\xb9\xce\x2c\x8d\x31\xe2\xbf\xb7\x59\x58\xfe\xa9\x54\x63\xf6\x8c\x55\xce\x45\x1e\x42\xee\xb2\x99\xf9\x32\xe2\xff\xa0\x54\x3e\x31\xe6\x8c\xf1\xfe\xbe\xed\xd2\xb8\x4f\xfe\xcf\x52\x2a\x9f\x52\xad\x7e\x2e\xeb\xda\x5f\xf6\xaf\x13\xeb\x18\xab\x8d\x1a\x3b\xfd\x2c\xae\x55\x5d\x0f\x33\x66\xbe\x9e\xc8\x2f\x56\x0c\x77\x5a\x7e\xfb\xc7\x87\x3f\x0e\x61\x16\xe7\x11\x94\xf5\xea\x70\xe9\xe7\xaf\xb5\xcd\x1c\x97\x23\xac\xf9\xc4\x65\x71\xda\x87\xfb\xf3\x60\x2d\xb4\x5d\x9a\x57\xfc\x3c\x31\x77\x89\xa1\x48\x3b\x13\x97\x61\x7b\x6f\x1d\x3f\xef\x41\x3e\x32\x39\xf6\xd5\xda\xcc\xf9\xb9\xab\xe5\x17\x98\x7c\x2f\x98\xf3\x85\x9a\x1f\x58\x74\x8d\x35\xc0\x57\x6c\x09\x31\xf3\xd5\x58\x72\x9b\x59\x2a\x7c\x75\xc7\xcc\xc5\x1c\xf4\xfb\xf0\xbf\xc6\x68\xe8\xdf\x8f\x3b\x83\x1f\x38\xf4\xdd\x6b\xbb\x34\x1e\xfc\xfc\x5d\x96\x6f\x3e\x72\xdd\xf7\xa3\x99\xeb\xbe\x83\x96\xfc\x71\xa9\x9f\xef\x7b\xcb\x77\x2b\x87\x2f\xb7\x63\xcc\x4b\x8e\xbf\x19\xf7\x97\x8f\xd7\xcb\xc7\xdb\xe5\x79\x5f\x27\xdf\x8d\xf2\x72\x5f\x2f\xcb\x6f\x83\xbf\x1f\x6c\x7f\x1d\xe7\x2a\x0f\x1b\xda\x8c\x75\xf3\x62\xec\x2e\xc7\xf3\x4f\xe3\xce\x5f\x5a\xf9\xee\x7b\xde\xe2\xa1\xd8\x8c\xb9\xcf\x6b\xf9\xcc\x5a\xee\x23\xbe\x6a\x1d\xf6\x5d\x4f\xd9\xde\xb2\xcd\xba\x2e\x9e\xb1\xc6\x0a\x79\xef\xbb\xcf\xb4\xe9\xeb\x67\xbb\x34\x97\xf4\xb2\x38\x27\x0f\x45\x05\x32\xcc\x6a\xbf\xc0\xcc\x4f\x63\xbc\x58\x6b\xa7\xef\x75\x2b\x17\x95\xb8\xad\xfc\x64\x6d\x32\xc6\x53\xa2\x89\x47\x5d\xfb\x1e\xb1\xe2\xdb\xd8\xd2\xa1\xf6\x05\xa3\x4d\xdc\x06\x2f\xd6\x9a\x2b\x1e\xaf\xc3\x3d\x22\xaf\xb2\xf4\x45\x9b\xa2\xc6\x9a\xf7\x1b\xab\xbd\xd3\xe2\xa2\xa1\x85\x47\x5d\x37\xab\x23\x6a\xcd\x9b\x8d\xdc\x84\xbc\x61\xf9\x3f\x00\x1d\xbf\x5e\xc2\x22\x15\x07\x6a\x7d\x3a\x6c\xf2\x62\x8c\x73\xb5\x76\x32\x3e\x7c\x8f\x21\xb7\x23\xac\xab\x62\xbb\x15\xa7\x8f\xad\x3c\x54\xe3\x1f\xee\xc5\x0e\xa4\x8d\xd5\xaf\xc2\xc2\x55\x64\xf9\xd8\x88\x76\xa7\xac\x18\x4f\xb7\xf0\x35\x45\x86\x20\xb1\x66\x3f\x9f\xcf\x8a\xf7\x2d\x36\x73\x5d\xe9\x68\xc6\xce\xc8\xe3\xd9\x56\x2e\xa9\xb9\x62\x38\xf2\xa7\x29\x92\x6b\x79\x2b\x02\xd7\x92\x39\x4a\xc6\x51\xcf\xd8\x16\x8c\x01\x6d\x3f\xf7\x6f\x53\x86\x5b\xc2\x3c\xa2\x91\x9b\xda\x0d\xd4\xcf\x44\xd4\x1c\x72\xa7\x15\xd3\x5a\xd3\x07\x59\x89\xdc\x41\x9b\x1b\x29\x1f\xa5\x8c\x44\xf2\xb9\x56\xfb\x15\xd5\x4f\xad\x7b\x1f\x50\xc2\x89\x46\x6c\x24\x5c\xc8\x23\x08\x7a\xe5\x06\x44\xe5\xc5\x39\xab\xaf\xda\x5f\xa9\xb8\xb1\xc7\x93\x23\xcd\x9c\x91\x70\x21\x47\x5b\xb8\x7f\x42\x5a\x50\xff\xbe\x89\x45\x56\xfd\x8d\x54\x5a\xc2\x3e\x49\x92\x37\x32\x85\xf6\x51\xd6\xf8\x56\xfb\xce\x20\x2b\x37\x9b\x9b\xf9\xeb\x9b\x8f\xa8\xfd\xa7\x6a\x4b\x2e\xcb\xde\xe6\x98\x33\x64\x8c\x25\x8f\x0a\xe1\x65\xf7\xe5\x6b\xc6\x36\x78\x99\x10\xb5\xe9\x5c\x73\xae\xf0\xce\xa6\x2c\x35\xf7\xe9\xbe\x9e\xdc\xff\x4a\xf9\x21\xe5\x3d\x54\x9c\x46\x9a\x70\x7f\x2f\xf7\x1f\x53\x8e\x36\xfb\xfb\xee\xb6\xe4\x33\x9e\xf7\xe3\xd9\x2e\x84\x73\x8b\x77\x27\xb2\x9b\xfa\x42\xea\x13\xb8\xfe\x01\x59\x83\x1c\x44\x6e\xc7\x66\x35\xe5\x28\x9e\xcf\xa7\x7c\x16\xb1\x21\x77\x21\x6f\x23\xdd\x90\x87\x90\x3f\x69\xf7\x2a\x25\x76\xbd\xef\x9b\xf8\xbc\x9f\x52\xf7\x3d\xfd\x06\x70\x7d\x48\x88\x0b\xf4\xa9\x7d\x81\xfb\xa7\xb9\x57\xbe\x2c\x42\x38\x27\x79\x37\x22\x6f\x58\xfd\x39\x03\x79\xc3\x68\xb3\x1f\x2c\x11\x5c\x63\xd3\xc7\xe9\x46\x2c\xa1\x74\x22\x8f\x9a\xf6\x7c\x9c\x22\x7c\x01\xf4\x29\xe6\x9e\x67\xde\xc7\xb8\x57\xdc\x6c\x40\x38\x9b\x79\x27\x22\x4f\xf0\x3c\x9e\xfb\x93\xea\x1c\x46\x39\xc7\xb4\x6b\xe0\x7b\x04\x49\xa5\x5e\xe7\x40\xb2\x82\xeb\xfb\x91\x68\xda\xc0\xb5\xf7\x73\xea\x93\xb9\xe6\x3c\xe8\xbd\x8f\xf2\x03\x53\xbc\x9c\x21\xbd\xbf\x70\x9d\x82\xdc\x61\x71\x8e\x5e\xaf\x7a\x9e\x48\xf9\x38\xa2\x78\xce\x46\x3e\x42\x14\xb6\xd5\xe8\x1f\xc6\x35\x3c\xfa\x56\x9a\x73\xcf\xc5\xfd\x22\x73\x89\xa6\x72\x6b\x91\x39\xf7\xa9\x7d\xb0\x31\xd6\x95\xa4\xd4\xb9\x4e\x36\xe7\x97\x8b\x67\x8f\x9e\xe6\x9a\x69\xcc\x7f\xd6\x3c\x6c\xec\xa9\xac\x75\xdc\xc8\x2d\xff\xb9\x23\xd8\x9c\x1f\x8d\x36\x4e\x2b\xff\xd4\x1c\xbf\xd3\x1a\xe7\x9b\xcd\xf1\xef\x7b\xd9\xea\xaf\xea\xb3\xad\x79\xb0\x99\x35\xaf\x4d\x32\xeb\x7c\x8c\x4f\xb1\xc6\x66\xce\xf7\xea\xf9\x22\xab\xcd\x4a\xab\x9d\x5a\xab\x8f\x21\xaf\xd8\xcc\x35\x66\xa6\x35\x77\xb0\x6e\xfb\x9e\xa3\x5c\x68\x33\xcf\x0d\x4f\x58\x3a\xd5\x3a\x3d\xcd\x66\x9c\x6f\x8c\x79\xc5\x6f\xab\xaf\x55\xc6\x5a\x3a\xd4\x39\x90\x33\x84\x2f\xc8\x2c\x8d\x39\x3b\xda\x5a\x87\xfd\xeb\xca\x6c\x73\xac\xa9\xb9\xd3\xf7\xa6\xcd\x9c\x5b\xd5\x1c\x74\x35\xf2\x30\x75\xcc\x07\xbe\xe5\x16\x2e\xd6\x6d\xdf\x7b\x08\x73\x8e\xb1\x77\x69\x6f\x62\x34\xe6\x62\xb8\x35\xd6\x11\x35\x3f\xe8\x96\x8d\x44\x33\x66\xc6\x1a\xe3\xb7\x17\x6e\xf1\xcf\xfe\x5c\xed\x53\x14\xdf\xbe\xc5\xc8\x30\xdb\xa5\x3d\x59\x7f\xdb\xa5\xf3\xc8\x4c\x4b\xb7\xaa\xb7\xd9\x2e\xed\xbb\xd4\x98\xdf\x86\x9c\xb6\xda\xf8\xe3\xf4\x89\xed\xd2\xfa\x9a\x5c\x27\xee\xa5\x96\x5d\xd5\xe7\x67\xb3\xad\x21\xaa\xed\x9d\x56\xdc\x93\xff\x1a\x73\xc3\xe6\x83\x96\xce\x46\x75\x74\x56\x59\xfb\x0f\x44\x30\x6f\xf9\xce\x5a\x76\x9c\xd6\x3a\xbc\xc5\x8a\xf5\x68\xab\xfd\x2a\xea\x86\x98\xb9\xeb\x53\xf3\x7e\xab\xbf\xe6\xa8\x6f\x4f\x1d\xfb\x7d\xad\xba\x0f\x4d\xee\x8c\x18\xa8\xb5\x98\xbc\x56\xe7\x4c\x23\xbf\xaf\x36\x6d\x1a\x76\xfb\x5a\x7d\x95\xfd\xae\x26\x56\x23\x3e\xfe\xb3\x48\xba\x69\xdf\x58\x8f\xac\x7d\xaa\xff\xac\xeb\x63\x4d\xf1\xfd\x64\xbb\xb4\x4f\x49\xb6\x5d\x3a\xc7\x2a\x8e\xd5\x7e\xc2\x63\xbb\x78\x1e\x57\x6b\xb1\xb1\xd7\x78\xcd\xca\x83\x8f\x2d\x1e\x14\x96\xb7\x2c\xdb\xaf\x5a\xf9\xc7\x9e\xd2\x58\x57\xeb\xec\x5f\x8c\x38\xf9\x4b\x69\xe5\xaf\xff\xb9\xb2\xd7\xd2\xea\xa3\xec\x5e\x8b\x90\x17\xa2\x1e\xe3\x3f\x0d\x61\x7e\x14\x8d\xcc\x37\x36\xde\x69\xcc\x89\xd4\x5d\x98\x7c\x29\x86\x86\xff\xd6\x1e\xc1\xe0\x6e\x84\x95\xdb\xd9\x16\x8f\xaa\x4d\x92\x15\xff\x5b\xac\x1c\xb8\x2c\x0e\x17\xf5\x4c\xb1\x30\xf6\xab\x53\xaf\x78\x0b\xa4\xdf\x67\xa6\xa8\x7d\x85\x3a\xff\x1a\x6b\xff\x48\x33\x4f\x54\xac\xa4\xc2\xa3\xf6\x0e\x13\x2c\x9e\x37\x9b\xdc\x88\x19\x96\xaf\xe4\x8e\xda\xa3\x19\xe5\x5c\x4b\xb7\xda\x4b\x34\xb5\xf0\xfb\xcb\xdc\x3a\x58\xd5\x5c\x95\x66\xe5\xa9\x9a\xa3\xbe\xb3\xd6\x72\xff\x7c\x57\x65\xe6\x9a\x11\xa3\x3f\x2f\xd9\xfd\xdb\xfd\xb7\x7f\xbf\xa9\xce\x36\x43\x2f\x95\xff\xc1\x4b\x98\xb9\xef\xb9\xc8\xaf\xbf\xfc\xa7\xfd\xa9\xb3\x4e\xfe\xbd\xff\x9f\xa5\x81\x51\xcd\x29\x3d\xcd\x7c\x34\x72\x46\xe1\x5d\x63\xce\xa1\x06\xbe\x97\x2e\x95\xc6\xfe\x4f\x9d\xc5\xbe\x44\x7e\xb7\x70\xaa\xf7\x1b\x63\x91\x3d\xe6\x18\x33\xda\x7e\x66\xe6\xa5\xe1\x93\xda\x83\xa9\xb9\x52\x8d\x35\xb5\xdf\xeb\x6f\x71\xb6\xa7\x0e\x4e\xe3\xfc\x48\x1e\xb1\x06\x69\xf3\x90\x4a\xe4\x45\x64\x20\xeb\x4d\x77\xca\x75\x94\xbf\x53\x5e\x4f\xd9\x06\x61\xad\xd3\xc6\x98\x22\x9f\x44\x5a\x71\xcd\x7a\xaa\x95\x71\x4d\x0e\xca\x04\xab\x5d\x24\x3a\xa7\x52\xe6\x98\x7d\xb5\x42\xf3\xb9\x76\x9d\xd5\xb7\xbb\xa5\x57\xf5\x9b\x45\x5b\x74\x89\x37\x4c\x91\xd7\x20\x81\x48\x53\x24\xdb\x14\xed\x03\x53\xc4\x8f\x94\x79\xd4\x2d\x55\xeb\x9c\xc2\xac\xf6\x69\xfe\xe7\xea\x9d\x1b\xe5\x39\x9e\xab\xf1\x7d\x98\xf6\x8a\x2f\x35\x67\x9c\xb1\x72\x73\x89\xcd\xd8\x93\x4b\xd5\x4f\xf1\x12\x60\xc6\x40\x7e\x69\xf2\x68\xe4\xdb\x3c\xb3\x5e\x9d\xcb\x24\x7b\x2c\x63\xae\xa7\xad\xaf\xda\x66\xbe\xc3\x52\x6b\xa1\x5a\x47\xd8\x8f\x19\xef\xb5\x54\xbf\xa9\x56\x5e\xab\x75\xe8\x53\x53\xe4\xef\xe6\x7b\x2a\xdf\x1d\x56\x6c\xd4\x9a\xd9\xc8\x1a\x1f\x6a\x5c\x67\x58\x63\x6b\x22\x72\xc8\x66\xee\x9f\xd5\x9c\xb4\xdc\x5a\x0f\xd2\xac\x18\x8d\xb4\xda\xaa\x71\xa0\xe6\x08\xdd\x8a\x7f\x81\x95\x03\x6a\x0f\xbf\xcf\x66\xbe\x83\xfc\xd6\x8c\xa9\xef\x2b\x9b\xb1\xb6\x18\xe7\x0e\xeb\xbd\x9c\x91\xaf\x2a\xc7\x6f\x35\x7d\x53\x6b\x93\xda\x9f\x1b\x73\xa9\x5a\x33\xd9\x5b\xfa\x76\x99\x98\x8c\x52\x61\x52\x7b\x65\x35\x7f\x32\xbf\x09\x35\x8f\xc0\xb1\xe0\x5c\x20\x39\x73\x49\xb5\x66\x7f\x61\xbd\x57\x50\xf3\x83\x7a\x87\xa1\xf4\x1c\xb4\x70\xa8\x3c\x64\xfe\x93\x0a\x97\xda\xd3\xaf\xe0\x5a\x33\xdf\xcd\xa9\x35\xd1\x38\x33\xaa\x58\x30\xde\x25\x7e\x48\xf5\xee\x95\x35\x46\x76\x31\xdb\xcb\x27\xac\xbd\xb2\xca\xe3\x0b\xd6\x3b\xbf\x2b\xcc\x33\x8b\x4c\x33\xf1\x48\xec\x48\x70\xcb\x24\x13\x83\x2c\xa7\x54\x67\xb2\x97\xcd\xfd\xb7\xac\x67\x61\xe6\x9c\x22\x19\x6f\x52\x71\xc0\x3e\x5d\xd4\x5a\x9c\xa8\xf9\x5e\xed\x45\x4a\x6c\xe6\x7e\xda\x67\xf2\x69\xcc\x75\x57\x59\xf3\x0b\x7d\x7d\xea\x9d\xed\x6f\xd6\x1a\x57\xdf\x8a\x93\x5a\x1f\x0e\x99\x7b\x7d\xe3\xbd\x01\x6d\xe5\x00\x53\x8c\x39\xb7\x9e\xd9\xe7\xa2\xbe\x11\xd6\x7a\xa0\xfa\x3e\x63\xbb\xf8\x4e\x55\xb5\x35\xde\x2b\xab\x7d\xcf\x4d\x66\xbc\x8c\x31\xef\x5f\x77\xfc\x73\xae\x5a\x7f\x33\xad\x9c\xcb\x30\xcf\x33\xc6\xb5\x7a\xef\x47\x2c\xd4\x7b\x1a\xa9\xde\xaf\xaa\x39\x5e\x9d\x2f\xa4\x75\x86\xf8\xc4\x3c\x2b\x09\xf5\x9c\x31\x20\xd5\xbb\xd2\x6f\x2c\xee\x9e\xa5\x9e\x79\x50\xb2\xdf\x92\xcc\xc9\x72\x8e\x39\x1e\x0c\x6e\x14\x66\x35\x6e\x14\x36\x75\xc6\xde\x8b\xfc\x68\xc6\x4e\xae\xe5\x9a\x7c\x97\x01\x56\x3c\x55\x9c\xd4\xfb\x15\xf6\x56\x32\xca\xe2\x58\xe5\x06\x67\x0c\x1f\x73\x81\xaf\x3d\xeb\xd4\x19\xca\xa1\x48\x01\x32\xd6\x3a\x4f\x8c\x31\xf7\xfc\x5e\xe6\x02\xef\xbb\xea\x15\xbd\xda\x4f\xdb\xfe\xfa\x3e\x20\xf5\x6f\xca\xba\xef\x25\xfb\xfd\x0f\xe5\x7f\x7b\x4f\xd9\xb5\xce\xbd\x3a\x33\xdf\x66\xfb\xe7\xf7\x93\x56\x69\xac\x39\x35\xb6\x7f\x7e\x6f\xe9\x7f\x8f\x73\x79\xf9\x37\xef\x26\xeb\x96\x17\xf7\x15\x97\x95\xff\xf8\xae\xd2\x5f\xfe\xdb\xfb\x12\xff\x3e\xc0\x5f\xd6\x7d\x8f\xd3\xc7\x2a\xfd\x3c\x29\x9d\xff\xf6\xfe\xf2\xef\xde\x63\xaa\xf2\x3e\xab\x54\x73\xd3\xcd\xb6\x4b\xef\x85\xd4\x3c\xe5\xb6\xfd\xf3\x3b\x32\xb5\x0f\x5a\x59\xa7\xf4\xbf\xd7\xfc\x97\xf2\x3f\xd6\x49\xff\x7b\xa1\x7f\x78\x07\x6a\x70\x75\xc6\xea\xab\xd6\xe1\x1c\x73\xfe\x52\x6b\xea\x3f\xbd\x1b\xff\x7f\x55\xfe\xcf\xef\xcc\xff\xa9\xfc\xb7\x77\x73\xff\xaf\xcb\xcb\x63\xe4\x7f\xff\xfa\x6f\x65\xdd\x77\xd1\x7f\x57\x66\xff\x77\xb9\xf8\x9d\x8c\x1a\x0f\xea\x1d\x91\x8a\x5f\xaf\x4b\xf5\xc6\x79\xe8\x6f\xc4\xd8\xaf\x31\xb7\x79\x59\x4f\xbc\x57\x5c\x2a\xff\xf2\x4e\xec\x6f\xe4\x9f\xfa\x79\xcf\x9a\x62\xac\x69\xff\x45\x7c\x77\xff\x4b\xff\xbf\xfb\xae\x46\x9d\x53\xd4\xda\xc3\x5c\xe9\x65\xbd\xf0\x32\xef\x7a\xd5\xf9\x41\xb7\x72\xfb\xbf\x88\xfa\x0e\xaf\x96\x35\xb6\xf6\x28\x7d\xd4\x7a\x17\xfb\xdf\xc5\xd8\x4f\xbe\xfc\x9f\x76\x7c\x4d\x4d\xb9\xc8\xbd\x9f\x4b\x3f\x37\x7e\x1f\xfd\x98\xfd\x18\xfc\xba\xff\x6f\xe3\x58\xff\xbf\xcb\xbf\xc6\xe5\xff\x95\xdf\xff\x0d\x7b\x1d\x91\xd6\x19\xd2\x28\x39\xe7\x1a\xef\x2c\xeb\x62\x6e\x66\xe1\x66\x9f\xa3\xce\x9c\xfe\xd2\x98\x77\xfc\xdc\x1d\xf8\x2f\xb9\x64\x9d\xe5\x2f\xf6\xbb\xd9\x92\x03\x7f\x93\x03\xcf\x99\x72\xb1\x6e\xa7\x29\x3e\x75\xa6\x5e\x6e\xf2\xa6\xde\x5d\x1a\xef\x2f\x47\xfe\x03\x47\x21\x96\xbd\x97\x2f\x89\xf2\x4d\x72\x9e\xf4\xbd\x8f\xb8\xac\xf7\x55\xfe\xef\xbb\xd4\x39\xe5\x53\x4b\xd4\xfb\x51\xe6\x7c\xa9\xf6\xc4\xec\x59\x34\xb5\x3f\x55\xf3\xaf\xd2\x73\xcc\xdc\xe7\x09\x75\x4e\x19\x66\xee\x3d\x7c\x6f\x5b\xba\xfa\x51\x46\xfb\xc5\x9c\x97\x8d\xef\xdc\xd5\xfb\x8e\x83\xd6\x9e\x4d\xf1\xa8\xd6\x22\xf5\x8e\xa6\xb3\x85\xc7\xdf\x27\xd2\x92\x28\xb3\xbf\xec\x61\xf6\x33\xf8\x53\x58\xd4\x19\xf8\xa8\x55\x0e\x32\x45\xd9\x30\xbe\x1b\x38\x69\xed\xd3\x14\x77\xea\xdd\xf6\x19\x73\xff\x66\x9c\x19\xd5\x77\xd2\x6a\x8d\x56\x67\x04\x61\x71\xeb\x34\xe3\xed\xff\x3e\x41\x0c\xc2\x26\x67\x7d\xe3\xdd\x93\x8a\xd1\x03\x56\x1b\xf5\x3b\x05\xea\x1d\xb5\x3a\xc7\xaa\x75\x51\xad\x7d\xf5\x4c\x31\xde\x93\x2b\x9e\xd5\xfb\x12\xff\x77\xbc\x9c\x9b\xe5\xec\xff\x2c\x8d\x6b\xeb\x9d\x94\x71\x26\x50\xbf\x57\x30\xce\xe2\x40\xbd\xd3\xeb\x68\x33\xcf\xc6\x2a\x4f\x38\x9f\x0a\xf5\xbd\xb7\x7a\xa7\xa2\xde\x8d\x57\x59\xe5\x74\x33\x4e\x2a\x3f\x35\xb5\x8e\xb3\xdf\x54\xef\xfb\xd5\xb5\x12\xff\x75\xdd\xf2\x72\x91\x93\xcc\x67\xaa\x54\x52\xf7\xd9\xff\x69\xfd\xff\x22\x75\x7f\x2f\x43\x89\x36\xfe\xb2\x3a\xb5\x27\x55\xe7\x86\x89\xa6\x28\xbe\xd4\xf7\x8a\x06\x0f\x11\xe6\x33\xe3\xdc\x75\x87\xc5\x9b\xda\x8b\xa4\x99\x22\xa7\x59\xb9\xab\xa4\x01\xf7\x8a\xc3\xdd\x36\xf3\x5d\x45\xb9\x55\x2e\xa3\x9e\x67\xc6\x3b\x89\x8d\x66\x2e\xa8\x77\xf6\xc6\x39\x5b\xc5\x37\xc0\x1a\x27\x0f\xd8\x2e\xed\x21\xac\xfd\xdc\xc5\x7d\x85\x7a\xd7\x57\x77\xdf\x52\x6c\xd5\x6f\x37\xf3\x40\x9d\x67\x7d\xfb\xd8\xdf\x76\xa4\x9c\xa8\x84\x3a\x75\x76\x60\xaf\xa9\xb9\x4c\x91\x9c\x57\x7d\xb1\x8c\x11\xe6\x38\x1f\x7b\x25\x79\xbb\xcd\x3c\x1f\x91\xa7\x5a\x4b\xdb\xc5\xef\xb7\xe5\x97\x9c\x6f\x15\x6f\x6a\x1c\x92\xf3\xea\x7c\xeb\x3f\xd7\xd6\x3d\xbf\x1a\xef\x05\xd4\x99\x54\x7d\x97\x3a\xf5\xaf\x62\x9c\x89\xfd\x72\xf9\xd9\xd8\x6e\xe5\x56\x4f\xeb\x3c\x55\xe7\x5c\x6c\x9c\x1b\xad\xf3\xb0\xff\x2c\xfc\x77\xe7\x60\x75\xbe\x36\xf4\x36\x35\xdb\x08\xce\x01\xb5\x53\xf0\xbf\x9a\x52\xfd\xfe\x95\x3a\xe7\xfc\x68\xbe\xb3\xd6\xd2\xcc\xef\x5b\xd4\x3b\x38\x79\xbf\xf5\x3d\xc9\x5c\x04\x0e\xe5\x62\xe4\x29\xe4\x2a\xf3\x3b\x00\xaf\x3a\xcb\xa9\xf7\xfa\x0f\xd4\x11\xf5\x6e\x5d\xbd\xcb\x9f\xc5\x73\xb0\xa8\xdf\x7f\xf2\x2d\xb7\x64\x96\x25\xea\xdd\xfa\x6d\x88\x7a\x8f\xa6\xf6\x4e\xff\xb2\x76\xfd\xdb\x9a\xff\xdf\xd7\x68\xf1\x2f\x3f\x16\x06\xeb\x1d\x9c\x68\x0b\x6e\xf5\x7d\xc6\x40\xca\xeb\x11\xf5\x7d\xcb\x0a\xeb\xbb\x91\xa7\xa9\xf7\x7f\x4f\xf2\xa8\x79\x6e\x52\xdf\x2b\x18\xe7\xa7\x6b\x90\xdd\x75\xe4\x16\x04\x6e\xbc\x1b\xcc\xd2\x90\x01\x48\x3f\xab\x1c\x60\x9e\xd3\xa4\x9a\xa3\xd4\xba\xa2\xde\x43\xab\xef\xfd\x66\x5a\xf9\xfa\xae\xcd\xfc\x5e\xd2\xbf\xfe\xef\xb1\x44\xe5\x5d\x85\x25\x2a\xae\x0f\xe3\x42\x2f\x64\x80\x12\xea\x52\x7d\x67\xd5\x6f\x73\xa9\xef\x40\x0c\x69\x68\xfe\x6e\x96\xad\xb1\xf1\xbb\x5d\xea\xde\x66\x53\xbf\x2f\xe6\x15\x8b\x45\x80\x58\x28\x16\x6a\x6d\xf5\xe9\xfa\x2c\x7d\xa1\xbe\x4a\x5f\xad\xef\xd2\x5f\xb7\xc7\xd8\x1b\xd9\x5f\xb4\x7f\x65\xff\xb9\xd1\x2b\x49\x5b\x93\xb6\x27\xfd\xe1\x8c\x73\x36\x72\x16\x38\xfb\x39\x87\x3a\x3d\xce\xe1\xce\x91\xce\x05\xce\x7d\xce\xe7\x9c\xef\x38\x3f\x76\x7e\xe7\xfc\xd9\xe9\x75\x45\xb8\xe2\x5c\x29\xae\x74\x57\x0b\x57\x4b\x57\xae\xab\x83\xab\xa3\xab\xb3\xab\xbb\x6b\x94\x6b\xba\x6b\x91\x6b\x83\xeb\x51\xd7\xf7\xc9\xf6\xe4\x98\xe4\x84\xe4\x94\xe4\xf4\xe4\x16\xc9\xfd\x93\x07\x27\x8f\x4a\x5e\x96\xbc\x31\x79\x4f\x8a\x96\x12\x90\x12\x91\x12\x9d\x12\x97\xd2\x20\xc5\x99\xd2\x34\x25\x33\xa5\x67\x4a\x79\xca\xb8\x54\x2d\x35\x32\x35\x39\x4d\xa4\x69\x69\xa1\x69\x91\x69\xb1\x69\xf5\xd2\x1a\xa6\x35\x4e\xcb\x4a\xcb\x4d\xeb\x98\x36\x25\x6d\x71\xda\xb2\xb4\x95\x69\xab\xd3\xd6\xa7\xed\x4a\xbb\x3f\xed\xe1\xb4\x43\x69\x87\xd3\x9e\x4b\x7b\x2d\xed\x8d\xb4\x8f\xd2\xce\xa6\x77\x4c\x77\xa7\x77\x4d\x2f\x4b\x1f\x9b\x3e\x3e\x7d\x72\xfa\xf4\xac\xa9\x59\x73\x5a\x24\xdc\x9d\x7c\xf7\xea\xf3\xda\xf9\xb6\xe7\x3b\x9e\xef\x7c\xbe\xcb\xf9\xee\xe7\x07\x78\x53\x7d\x3e\xe3\x37\xd2\x76\x6a\xed\xf4\x2a\xfd\x6a\x7d\x19\xfe\xdf\xa8\xdf\xa1\xbf\x69\x6f\x60\x5f\x67\x7f\xd3\xfe\x7d\x23\xd1\xc8\x8b\xff\x3b\x9d\xc2\x59\xcf\xe9\x72\xf6\x74\x16\x59\xfe\x8f\x76\x2e\x76\x3e\xe6\x7c\xc1\xf9\xbe\xf3\x13\xe7\x8f\xce\x5f\x5d\xa1\xae\x68\x57\x02\xfe\x37\xc3\xff\xd6\xae\xf6\x17\xfd\x9f\x84\xff\x6b\x5d\x3b\x2d\xff\xe3\x2d\xff\xfb\x25\x0f\x4a\x1e\x8e\xff\x6b\x2f\xfa\x1f\x85\xff\xf5\x53\x92\x2c\xff\xcb\x52\x2a\x0c\xff\x5d\xff\xe0\x7f\xd1\x45\xff\xd7\xa6\xed\x4c\xbb\xf7\xa2\xff\xaf\xe0\xff\x87\xf8\xdf\xe1\xa2\xff\xe3\xd2\x27\xe1\x7f\x59\xd6\x4c\xfc\x4f\xb8\x7b\xe5\x79\x79\xbe\xd1\xf9\x76\xf8\xef\x3e\xdf\xed\x7c\xa1\xd7\xe5\xf3\xf9\x4e\xf9\x9e\xf1\x3d\xed\x7b\xc2\x77\xd0\xb7\xcf\xf7\x88\xef\x61\xdf\x5e\x5f\xb5\xef\x5e\x5f\x9e\x2f\xdb\xd7\xec\x0b\x67\xcd\xb9\x9a\xaf\x6a\xbe\xac\x39\x55\xf3\x79\xcd\x67\x35\x9f\xd4\x7c\x5c\x73\xac\xe6\xa3\x9a\x0f\x6b\x3e\xa8\x79\xaf\xe6\xdd\x9a\x77\x6a\xde\xaa\x79\xb3\xe6\xf5\x9a\xa3\x35\x47\x6a\x9e\xac\x79\xa2\xe6\x50\xcd\xfe\x9a\xc7\x6a\x1e\xad\xd9\x5b\x53\x5d\xf3\x50\xcd\xbd\x35\xeb\x6a\x56\xd4\xcc\xa9\x99\x50\x33\xa2\x26\xa5\x26\xbc\x46\x9e\xf5\x9d\xfd\xe5\xec\x8f\x67\xbf\x3e\x7b\xf4\xec\xcb\x67\x9f\x3d\xbb\xfd\xec\xfa\xb3\x4b\xce\x36\x39\x9b\x76\xb6\xd1\xd9\x86\x67\x1b\x9c\x4d\x38\x1b\x7b\x36\xe4\x6c\xf0\x99\x6f\xcf\x7c\x70\xe6\xbd\x33\xed\xcf\x64\x9d\x69\x74\x2a\xff\x54\xe7\x53\x6d\x4e\xb5\x3e\x95\x7d\x2a\xeb\x54\xd3\x53\x29\xa7\x12\x4f\xc5\x9e\x0a\x3b\xf9\xe7\xc9\x9a\x93\xa7\x4f\x7e\x7e\xf2\xd3\x93\x1f\x9f\x7c\xe3\xe4\x8b\x27\x9f\x39\xf9\xf8\xc9\x43\x27\x1f\x39\xf9\xe0\xc9\xfb\x4f\xee\x3e\xb9\xe5\x64\xc1\xc9\xae\x27\xbb\x9c\x6c\x7c\x32\xe5\x64\xf2\xc9\xa4\x93\x89\xc7\x33\x8f\x37\x39\x76\x7d\xf9\xaa\xf2\xc6\x61\xd5\x61\x9b\xc2\x36\x86\x6d\x08\x5b\x1f\x76\x73\xd8\xba\xe0\xa7\xad\xdf\x98\xfc\xff\xef\x4f\x80\x16\xac\x0a\x29\xfe\x83\x09\xa9\xbe\xc9\x30\x7e\xb4\x7f\xd1\x61\xf6\xd4\x85\x4d\xd8\x99\x4d\x1c\x22\x50\x04\x89\x60\x11\x22\x42\x59\x17\xc2\x45\x84\x88\x14\x51\x22\x5a\xc4\x88\x58\x11\x27\xe2\x45\x82\xa8\x27\xea\x8b\x06\x22\x91\x59\xa8\x91\x48\x12\x4e\x46\x5f\xb2\x48\x11\xa9\xa2\xb1\x48\x13\xe9\x22\x43\x34\x11\x4d\x45\x33\x91\x29\xb2\x44\x73\xd1\x42\x64\x8b\x96\xa2\x95\x68\x2d\x72\x44\xae\x68\xc3\xcc\x9c\x27\xda\x89\xf6\xa2\x83\xb8\x82\x95\xbb\x93\xe8\x2c\xf2\x85\x5b\x74\x11\x5d\x45\x37\xd1\x5d\x14\x88\x42\xd1\x43\xf4\x64\x2e\xec\x2d\xfa\x88\xbe\xa2\x9f\xe8\xcf\x9c\x58\x24\x8a\xc5\x40\xf6\x8a\x83\x45\x89\x18\x22\x86\x8a\x52\xe1\x11\xc3\xc4\x70\x66\xc8\x91\x62\x94\x18\x2d\xca\x44\x39\xf8\x57\x88\xeb\xc4\xf5\xe2\x06\xb1\x5e\x6c\x11\xdb\xc5\x1d\xe2\x76\xb1\x5b\xdc\x25\xee\x14\x77\x8b\x7b\xc4\x7d\xe2\x5e\x71\xbf\x78\x40\x3c\x24\x1e\x64\xbd\xdc\x2b\x1e\x11\x8f\x8a\x7d\xe2\x31\x71\x40\xec\x17\x87\xc5\xe3\xe2\x09\xf1\xa4\xe3\x13\x71\x15\x6b\xea\x38\x71\xa5\xe3\x33\x31\x57\xec\x12\x33\xc4\xe4\xc0\x04\x31\x5b\x4c\x0a\xcc\x13\x2b\xc5\xad\x81\xad\x45\x65\x60\xfb\xc0\x0e\x62\x82\x98\x13\xd8\x2c\xb0\x79\x60\x96\x3e\x33\xb0\x8d\x98\x22\xe6\xeb\xc3\xc4\x1e\x71\x48\x2c\x11\x63\xc5\xb4\xc0\x56\x72\x70\x60\xdb\xc0\x4c\x31\x55\x2c\x70\x9c\x10\x63\xc4\xb5\x62\xb9\xd8\x2c\x63\x65\x9c\xe3\x2d\xc7\xdb\x8e\x8f\x1c\xc7\x1c\xef\x39\xde\x17\x07\x03\xe7\x8a\xa7\x65\x07\xc7\xb7\x81\x81\x8e\xaf\x1c\x5f\x07\xee\x0d\x7c\xd8\xf1\xa9\x98\xe7\xf8\xc0\xf1\xb1\xe3\xac\x58\x26\x56\x8b\xa5\x62\x8d\x58\x25\x6e\x12\x6b\xc5\x3a\x71\xa3\xd8\x28\x36\xe1\xe1\x06\xb1\x4d\xdc\x26\xb6\x8a\x9f\xb4\xeb\xb4\xdb\xc4\x4c\xed\x16\xed\x56\x6d\xab\xb8\x5a\xdb\xae\x6d\xd3\x58\xa1\xdd\x3d\x86\x0f\xf3\x94\x96\x0c\x1e\x34\xb0\xb8\x68\x40\xff\x7e\x7d\xfb\xf4\xee\xd5\xb3\x47\x61\x41\xf7\x6e\x5d\xbb\xb8\xf3\x3b\x77\xea\x78\x45\x87\xf6\xed\xf2\xda\xb6\x69\xd5\x32\xbb\x45\xf3\xac\x26\x19\xe9\x69\x8d\x53\x53\x92\x9d\xf5\x62\xa3\x22\x23\xc2\xc3\x42\x82\x83\x02\x1d\x01\x76\x9b\xae\x49\x91\xe5\xaa\x96\x65\x05\xd5\x7a\x9a\x2b\xaa\xb0\x3c\xb5\x20\xb5\xbc\x67\xf3\x2c\x57\x41\xbd\x89\xdd\x9b\x67\x15\xa4\x16\x96\x55\xbb\xca\x5d\xd5\x14\xb6\xf4\xd4\x9e\x3d\x8d\xaa\xd4\xf2\x6a\x57\x99\xab\x3a\x9d\xa2\xbc\x4e\x75\x59\xb5\x9b\x96\xe3\x2f\x6b\xe9\x36\x5b\xba\x2f\xb6\x94\x91\xae\x8e\xa2\xa3\x32\x91\xea\xaa\x3e\xda\x3d\xd5\x75\x40\x0e\x2b\x2e\xe5\x7a\x4d\xf7\x54\x8f\xab\xfa\x1b\xe3\xba\x9f\x71\x6d\x4b\x37\x6e\xc2\xb8\x49\x4e\xa6\x87\x81\x4a\xa1\x75\x15\x54\x17\xce\x9e\xb8\xaa\xa0\x0c\x8c\x72\x6f\x48\x70\xb7\xd4\x6e\xe3\x82\x9b\x67\x89\xbd\xc1\x21\x5c\x86\x70\x55\xdd\x24\x75\xc6\x5e\xd9\xa4\xb3\x34\x2e\xb4\x26\x05\x1d\xf6\x6a\x22\x30\x4c\x99\xc5\xd3\x82\xf2\x8a\xea\xa2\xe2\xd2\x82\xee\x89\xc9\xc9\x9e\xe6\x59\xbd\xaa\xc3\x53\xbb\x1b\x8f\x44\x37\x43\x65\x75\x40\xb7\x6a\x87\xa1\xd2\x75\xa5\x82\x2e\x6e\x70\xed\xcd\x3a\xb2\x6a\xf5\x81\x48\x31\xa6\x2c\x33\xb4\x22\xb5\xa2\x7c\x44\x69\xb5\x5e\x4e\xdf\x55\x7a\xc1\xaa\x55\xd7\x55\x47\x65\x56\x37\x4d\xed\x5e\xdd\xf4\xea\xd3\xf5\xf0\x7c\x5c\x75\x56\x6a\xf7\x82\xea\x4c\xa5\xb5\xcf\xc0\x8b\x76\xfa\x5c\x32\x29\xab\xed\x69\x2c\x17\xab\x7e\x11\xb8\x93\xfa\xcd\xb9\xbf\xd6\x94\x5b\x35\x01\x69\x91\xbf\x08\x75\x59\xad\x75\xab\x96\x03\x4b\x93\xd5\x4f\x62\x21\x5c\xaf\x5a\x55\x98\xea\x2a\x5c\x55\xb6\xaa\xfc\x80\x6f\xf1\x98\x54\x57\x64\xea\xaa\xbd\xa1\xa1\xab\x66\x14\x40\xb7\x28\x2a\x45\xc5\x01\xdf\xa1\x1b\x12\xab\x0b\x57\x7b\xaa\x23\xcb\x26\xca\x0e\x1e\xcb\xf5\xc2\x81\x7d\xaa\x63\x8a\x87\x97\x56\x6b\x69\x85\xae\x89\xe5\xd4\xf0\xff\xfc\xd4\xe4\x76\x89\xc9\x51\x17\xdb\x14\xfd\xd3\x63\x01\x2d\x90\x03\xc3\xc9\xc9\x8a\x86\x1b\x0e\xb8\xc5\x18\x6e\xaa\x17\x17\x97\x9a\xf7\x2e\x31\x26\xf1\x61\xe1\xce\xce\xf4\x54\x6b\x65\xea\xc9\x11\xff\x93\xb8\x12\xf5\x64\xb1\xff\xc9\xc5\xee\x65\xa9\xc4\xb6\xcf\xa0\xd2\x55\xd5\xb6\xb4\x5e\x15\xa9\x05\x30\x7e\x43\x79\xf5\xe2\x31\x64\xd7\x24\x15\x98\xd4\xc8\xea\xf0\x5f\x13\x93\x53\x57\x45\x47\xb9\xda\x67\x7b\x8c\xb6\x2e\x50\xf5\xaa\xb8\xd2\x55\x6d\x4f\x87\x24\x7a\xd5\xed\x40\xde\xa8\x2e\xab\x22\x8d\x9b\xf0\x5f\xcd\xe2\x9b\x44\x0c\xa4\x47\x45\xbb\xda\xa7\xa2\x46\xe9\x29\x48\x2d\x28\xb3\xfe\x3f\x7b\x62\x3d\x14\xb8\x20\xba\x67\xa6\x99\x08\x83\x4b\xab\xdd\xdd\xb9\x70\x97\x5b\x11\x2b\xd8\xdb\x32\x9b\x1e\xe5\x65\x04\xec\xca\xee\x46\x30\xab\xb3\x53\x67\x54\xc7\xa6\x76\xbd\x18\x5d\x05\xab\xe0\xca\x41\xa5\x46\x17\xab\x5b\x75\x6c\xb7\x6a\x51\x36\xd6\xea\x55\x9d\x5d\x60\x8c\x2b\x57\xc1\xaa\xb2\xee\x26\x04\xa5\x2b\xb5\xb8\xf4\xa0\xc8\xf1\x9d\xd8\x9b\xeb\x4a\x7c\x44\x4d\x9d\x9e\xee\xaa\x71\x7c\x37\xb2\x2c\xbd\x60\x55\x69\xc5\xf8\x6a\x67\x59\x62\x05\xe3\x6e\xbc\xab\x34\x31\xb9\xda\xed\x21\xc2\x9e\xd4\xd2\x71\x1e\x95\x76\x30\xd4\xf4\x44\xa2\x91\x1c\x1e\x23\x57\x06\x97\xf6\x19\x94\xda\xa7\x78\x58\x69\x3b\x0b\x88\xf9\x40\xa9\xb3\xa5\x15\x5c\xa6\x26\xb5\x34\xd1\x54\x43\x02\x56\x07\xa6\x05\xba\x4a\xb5\x44\xdd\x43\xc3\x48\x2a\x5c\x85\x5c\xa4\x76\xed\xc8\x67\xb5\x23\x2d\x10\x89\x84\x70\xa3\x56\x25\x6e\xd7\x8e\xae\x52\x99\x28\xfc\xad\x81\x51\xdd\xd4\x55\x30\xae\xbb\xd5\x4e\xdd\xff\x45\xa9\x5d\xa5\x53\xb7\x9e\x7e\x6d\x01\xea\x16\x3d\xdd\x7a\x26\x26\x7b\x92\xcd\x9f\xe6\x59\x1a\x8f\x5d\x96\x61\x7a\x04\x2a\x52\x7b\xfa\x1f\x31\x4d\xf1\x20\x90\xfc\xec\xd6\xd3\xa8\x52\x5c\xd6\x53\x49\xef\x2a\x4d\x1d\x97\xea\x49\x9d\xe8\xaa\x76\x17\x95\x2a\xdf\x14\x3d\x06\xcb\x16\x19\x06\xe7\x56\xac\x06\xff\xe5\xae\x0e\x59\xd0\x24\x92\x79\xec\xbf\x51\x64\x56\x17\x66\x26\xd6\x25\xb7\xba\x87\x71\x7f\xf1\xb6\xe7\x65\x8f\x7b\xf9\x1f\xbb\x56\x05\xa6\xf6\x19\xb4\x4a\x29\x4f\xb5\x14\x0a\x90\xf7\xaa\x16\x2a\x85\xdd\xed\xa2\x12\x8d\xb9\x40\x0d\xe8\x54\xe6\x5e\x57\x24\x43\xda\x18\xd0\xab\xf6\xba\xdd\x6a\x30\x4f\xec\xa0\x94\xa4\xf6\xaa\x58\x95\x3a\xa8\xb4\xa3\xd1\x9a\xf9\x64\x41\xe2\xd5\xca\x56\xb4\xe8\x23\xfb\x0c\xee\xda\x3c\x8b\xa9\xad\xeb\xde\x54\xb9\xb2\x78\xaf\x5b\xae\x1c\x34\xac\xf4\x60\x24\x7b\xe4\x95\x83\x4b\x1f\xd6\xa4\xd6\xad\xac\xab\x67\x6f\x63\x9e\x95\x1e\x74\xb1\x68\x18\xb5\x9a\xaa\x55\x95\xea\xc6\xa5\x6e\x94\xa6\x81\xdc\x04\x1a\xed\x13\x0f\xba\x85\x58\x6c\x3c\xb5\x19\x15\xc6\xfd\xd8\x03\x52\x18\x75\x81\xfe\x3a\x29\xc6\x1e\xd0\xcc\xba\x48\xd3\x50\xba\x61\xc8\xcd\x1e\x64\xec\x01\x9b\xf9\xc4\xed\x6f\x6d\xa3\x2e\xd0\xac\x5b\x6c\xd4\x19\x3f\x7b\x85\xa2\xcc\x1d\x6c\x77\x07\xba\x83\xdc\xa1\x5a\x98\x96\xb8\x57\xaa\xaa\x87\xa9\x39\xa4\xfe\xdd\x8b\x14\x8f\x84\xca\x30\x99\xb8\x97\x5e\x03\x8d\xea\x03\x72\xf1\xde\x20\x77\xa2\xd9\x62\x31\x2d\xdc\x26\xc2\x95\x25\x97\x4c\x97\x0c\x2b\x7d\x84\x1d\x8d\x4c\x34\x3e\x31\xd4\x55\xfd\x90\x2e\xf5\x26\x12\x6c\x96\x95\x02\x57\x85\x4a\x94\xf9\x9e\x89\xab\xca\x3c\x6a\xb0\x89\x78\x42\xc3\xff\x65\xb5\x4c\xed\x4c\x98\x52\x3b\x03\x24\x20\xb4\x3a\x38\x75\x5c\xd7\xea\x90\xd4\xae\xaa\x3e\x5f\xd5\xe7\x9b\xf5\x01\xaa\xde\x41\x8a\xca\x78\x49\xf7\xc5\xc4\xbe\xa8\x5a\xaa\x0c\x18\x5e\x9a\xcc\x90\x74\x35\x78\x39\x71\x55\xe4\x37\x2a\x52\x1e\x26\x95\x55\x91\x67\x9a\x77\x19\x28\x47\x0a\x29\x87\x8a\x12\x39\xc2\x2a\xcb\xe4\x28\x76\x5a\x4e\x39\x9a\x92\x43\x8b\xf4\x88\x1c\x59\x4a\xfd\x10\x4a\x9e\x8b\xdd\x7c\xfe\x8c\xb0\xab\x93\xbd\xc5\x5a\x44\x13\xa3\xf9\x7c\xca\xb8\xf2\xf1\x29\x45\x19\x9f\x33\xac\xa7\xba\xd1\x2e\x12\x69\xa9\xee\x64\x27\xd1\x49\x76\x44\x5f\x47\xec\x75\xa0\xbc\x82\x7b\x55\xb6\xa7\x6c\x47\xd9\x8e\xfa\xb6\x94\x79\xdc\xab\xb2\x8d\xcc\x7d\x78\xb1\x53\x74\x09\x96\xb9\x68\xc9\x15\x9a\x21\x2d\x78\x92\x23\x5b\xf3\x64\x71\x17\x97\x6c\x4d\x9f\xd6\x56\x6d\x2b\xfa\xb5\x04\x67\x04\x9f\x12\x31\x6b\xb3\xa9\xa5\x14\x2e\x3e\xcb\x10\x85\xbe\x85\x71\xc7\xf3\x87\xa5\x28\x39\x20\x9b\x3f\xdc\x49\x15\x59\x2c\x09\xce\x27\x64\x37\xd9\x55\xf8\x70\xbf\x8b\x74\xbb\xdb\xfb\x9c\x91\xb5\xf2\x87\xc2\x86\xce\xef\x91\x37\xbe\x91\xf9\x5f\xcb\x2f\xce\x34\x76\xd6\x9c\x69\xe2\x3c\x4b\xb9\xf3\x8c\x3c\x72\xe6\xcd\x33\xda\xa9\x93\x29\xce\xa2\x93\x65\x27\x4f\x9c\xd4\x3f\x3f\x91\xe1\xfc\xec\x84\x3c\x2c\x63\x45\x67\x19\x0d\x80\x18\x77\x48\x27\xbd\xe4\xb3\x4e\x9f\x94\x7c\xda\xe9\x78\x49\x97\x06\x32\x1e\x74\x71\x20\x12\x7c\x4a\xf1\x90\xf1\xe9\xe2\xb3\x08\x29\x43\x74\x3c\x88\x33\x36\xd6\xd1\x30\x17\x0d\xce\xe8\x87\xa5\x0e\xc0\x28\x77\x23\xdd\xe7\xfc\x44\x1e\x2f\x71\x1d\x2f\x3a\xbe\xf8\x78\xf5\x71\x5b\xc4\x71\x19\xf1\xaa\xf3\x55\xed\xf1\x43\xf5\x9d\x2d\x0f\xc8\x04\x77\x0b\x59\xb4\x7f\xf1\x7e\xed\xcd\x47\x64\xc4\x23\xb2\xe8\x81\xb2\x07\x4e\x3c\xf0\xfd\x03\xb6\xfb\xef\x8d\x74\x16\xdd\x5b\x76\xef\x89\x7b\xbf\xbf\xd7\xb6\xb3\xf5\x8e\x12\xb1\x23\x72\x87\x6b\x87\xbe\xf3\x71\x39\x48\x48\xdf\x11\x39\xc8\x1d\x13\x12\x5e\x98\xbd\x5d\x16\x6d\x93\x8b\xb6\xca\xc5\x5b\xd6\x6e\xd9\xb9\x45\x3f\xe0\x3b\xe2\x7e\x76\x4b\x70\x78\x61\xc4\x66\x99\xbd\x59\x2e\xda\x24\xc5\xa6\xc8\x4d\x65\x9b\xf4\xd1\xeb\xe5\xda\x9b\xe5\x9a\xd5\xa1\xce\x88\xd5\xce\xd5\xd9\xab\x75\xf7\x75\x52\xac\x88\x5c\x51\xb4\x42\xcf\x5e\x9e\xbf\x5c\x5b\xb6\x34\xc6\xd9\x72\xa9\x5c\x32\xd5\xe7\x5c\x0c\xe4\x59\x95\x2e\x67\x55\x65\x7d\x67\x65\x51\xb4\xf3\xaa\x69\x39\xce\x99\xd3\x7c\xce\xe9\x85\xad\x9d\xd3\x90\x06\xb2\x5e\x49\xfd\x9c\x7a\x25\x8e\x1c\xbd\x24\x80\xb6\x4d\xa7\xca\x29\x14\x63\x46\x37\x76\x96\x23\x65\xc8\xe8\xa2\xfa\xce\x51\x85\x0d\x9c\x8b\xbe\x94\xdf\x7f\x29\x87\x7c\x35\xfe\x2b\x2d\xf0\x2b\xf9\x55\x61\xbc\x73\xc0\x48\x39\x82\xc0\x0c\x47\xcf\xb0\x42\x97\x33\x56\x46\x97\xc4\xb4\x8e\x2e\xb1\x43\x97\xad\xb5\x5e\x12\xa1\xcb\x4d\x9e\xbb\x3c\xda\x41\xd9\x43\x16\x3e\xdc\xc0\x69\x3b\x20\x0b\xdd\xd7\xca\x41\xc0\x18\x88\x14\x17\x25\x39\xdd\x03\x5c\xa9\x85\xae\x01\xf5\x93\x0a\xbf\xef\x2f\x6f\xea\x27\x7d\xfd\x64\x9f\xc2\xa6\xce\x88\xde\xb2\x57\x61\x9a\xb3\x67\x61\xaa\xb3\x47\x61\x8c\x33\xa2\x70\x51\xe1\x77\x85\xbe\x42\x5b\xc3\x8a\xc4\x92\x04\x19\x57\x12\xdf\x3a\xae\x24\x4a\x46\x94\x44\xb6\x8e\x28\x61\xe3\x5a\x42\x12\x96\x38\x23\xf2\x23\x46\x47\x2c\x8a\xb0\x45\x44\x64\x47\x0c\x88\x98\x1e\x71\x53\xc4\x67\x11\xbe\x08\x47\x3e\x75\xdf\x45\xe8\xd3\x85\x1c\x20\xe4\xe2\x78\x69\x97\x07\xe4\xda\xbd\x83\x07\x65\x66\xf6\x39\xe0\xf0\xb1\x09\x0a\x2a\x1a\x5e\x2d\x57\x56\xa7\x0d\x52\x9f\xee\xe2\x61\xd5\x01\x2b\xab\x45\xc9\xb0\xe1\xa5\x7b\xa5\xbc\xd1\xb3\x7c\xcd\x1a\xd1\xb5\x51\x9f\xea\xd6\x83\x4a\xab\xcb\x1a\x79\xfa\x54\x57\x70\xe1\x56\x17\x8b\xb9\x88\x6c\xb4\x37\x5e\x74\xf5\x54\x56\x55\x56\xcd\xca\x34\x7f\x64\x15\x1f\x55\x22\xb3\x6a\x56\xa5\x71\x5f\x95\x29\x2b\x85\x71\x29\x91\xca\xcc\x2a\xda\x0a\xb3\xa9\xbf\x56\xf8\xbb\x56\x66\x56\x56\xaa\xc6\x95\x95\x52\xa9\xcc\xe4\xba\x52\xdd\xa9\x27\xea\x92\xab\xaa\x4a\xd5\x4b\x5d\x56\xf9\xcd\xa9\x67\x55\x46\x77\x51\xa9\xb4\x99\x76\x55\x55\xa5\xff\xff\x66\x0d\x7d\x2c\x50\x99\xf5\x84\xb0\xbf\xc6\x29\x6e\x81\xbd\x80\xd3\xdd\x3c\xe3\xf3\x2f\x3f\xb6\x0e\xcc\x46\x73\x84\xf0\x9d\x53\xbf\x59\xe0\xff\x14\xc2\x3b\xd4\xf7\xdb\xff\xcd\xc1\xf5\xf2\x1f\xf3\xdf\x46\xca\xfa\x32\x5d\x86\x0b\xaf\x78\x89\x81\x7b\x4e\x7c\x2e\xde\x17\xaf\x89\xa7\x39\xb1\xbd\x63\xfc\x2e\x93\xf1\x63\x7f\x4d\xba\x64\x96\xac\x27\x6d\xe2\xac\x4c\x11\xa7\xc5\xcf\xe2\xb8\x78\xc9\xfc\xf7\x88\x75\x7f\xec\x05\x32\x80\x93\x57\x8a\x98\xcc\x67\xa0\x78\x4b\x7c\x2a\x6a\xc4\x0b\xff\x69\x59\xb5\x13\x37\xc9\x50\xd9\x55\xee\x90\xf3\xc5\x4f\xfe\x7a\x19\xcd\x1c\x31\x4b\x2c\xe6\x0c\x76\x1b\xe7\xc7\x37\xc4\x71\x39\x56\x8e\xd0\xc6\xc9\x4e\xf2\x4a\xf5\x7b\x5a\xda\x26\x6d\x9a\x0c\xf7\xfe\xe8\xfb\xf6\x32\x85\x99\xda\x12\xf1\xb9\x4c\x44\xeb\xe7\xe2\x4b\xb1\x41\xae\x55\x95\x7a\x7d\xbc\xd8\x22\x56\x69\x77\x72\x26\x2c\x13\xaf\x82\x5a\x70\x3e\x55\xa7\x3a\x21\x2b\xe4\x5c\xb1\x88\xa7\xe6\xcf\x74\xb1\x80\x33\x60\xd5\x5f\x74\x5e\x2f\x6e\xe1\x73\xc1\x5f\x70\x5f\x7b\x61\xaf\x08\xf1\xfd\xcc\xf9\xf5\x55\x58\x78\x87\x53\xea\x46\x4e\xbd\xcb\x69\x79\x4c\xfc\xac\x75\xc7\xa6\xd3\xf0\xc3\xa6\x7e\x87\xcc\xf8\x79\xca\xdf\x37\xe0\x1e\x7d\x86\x76\x58\x0b\xac\xbd\x85\xf3\xe5\x3a\xce\xd9\xfd\x38\xfb\x56\x78\xa7\x7b\x87\xfe\x5d\x6c\xec\x05\xb5\x81\x22\xd4\xf7\xad\x7d\xd7\x85\x93\x5a\xc9\xdf\xb5\xf8\xdb\x5e\xaf\x8a\xf0\x0b\x49\xbe\x1f\xb4\xf3\x22\xc2\x16\x6f\x8b\xf7\xbe\x23\x9e\x22\xbf\x42\x6b\x03\x7d\xe7\xf4\xb1\x22\xa4\x36\xc2\xf7\x8b\x6a\xe7\x9d\xea\x9d\xaa\x5d\xa3\x5d\xe3\x9d\x28\xf6\xc8\x0c\x59\x5f\xdc\x62\x7b\x4b\x7f\xcb\xbe\xc2\xfb\x1d\x27\xf2\xfb\x44\x7f\x3c\x08\xb7\x2f\x95\xf5\x03\x96\xd8\xe6\x88\x38\xdb\x47\x46\x16\x3e\xef\x5d\x44\x6c\x8e\x8a\x1f\xa5\x26\xde\xbb\x68\xb2\xdd\x65\xb2\x18\x39\x42\xff\xd5\x42\x68\xb0\xab\xcf\x20\x9f\xe7\x23\xbb\x11\x72\xd8\x4e\x1b\xfb\x32\xe4\x25\x84\x78\x04\x34\x44\xe0\x4d\xfd\x7b\x62\xf5\x6f\x96\x1d\x44\x2e\x90\xba\xc0\x13\xec\x3a\x46\x08\x11\x4c\x92\x06\xbf\x26\x44\x08\x75\x21\x5f\x08\x11\xba\x07\x41\x4f\x58\x2e\x32\x17\xa1\x5d\x78\x13\xe4\x4d\x21\x22\xe9\x1f\x89\xfd\xa8\x8e\xc8\x61\x21\xa2\xb9\x8f\xa6\x7d\xf4\x05\x21\x62\x88\x79\x2c\xba\x62\x2b\x10\xda\xc6\x65\x21\x5c\xc7\xa1\x2b\xbe\x08\x01\x4f\x02\xfd\x12\x8e\x0b\x51\x6f\xa2\x10\xf5\xb1\x57\xbf\x0c\x79\x57\x88\x06\x5c\x37\xd8\x29\x44\x22\x5b\xba\x44\xea\x12\xf7\x21\xbf\x0b\xd1\x10\xfd\x0d\x69\xdb\x10\x1b\x0d\xdf\x34\x7f\x95\xb5\x11\x18\x93\xf0\xc1\x49\x1f\x27\x3a\x5d\xf8\xe5\x3a\x2d\x44\x72\xb5\x10\x29\x60\x4e\x81\x93\x54\x66\x80\x54\x72\x2d\x15\x9e\x1a\xc3\x45\x63\xf0\xa5\x71\x9f\x1e\x8b\x80\x3b\x03\x6c\x19\xe8\x69\x32\x05\xa1\x6c\xda\x12\xa1\x7f\x33\xec\x37\xc3\x56\x33\x6c\x67\x72\x9f\xf9\xa1\x10\x59\x2b\x85\x68\x8e\xbe\xe6\x70\xd0\x1c\x5b\x2d\xe8\xdb\x02\x9f\xb2\xc1\xd0\x92\xeb\x96\xe8\x68\x45\x2c\x5a\x81\xa5\x35\x92\x83\xfd\x1c\xec\xe5\x82\x25\x17\xde\xdb\xf4\x44\xe0\xb9\x0d\xcf\xda\x72\xdf\x16\x3f\xf2\xf0\x35\x8f\xb2\x5d\x29\xf2\x1c\x02\x07\xed\x69\xdf\x9e\xfa\x0e\xd8\xea\x40\x3c\x3b\x50\xdf\x01\x1c\x57\xc0\xdd\x15\x94\x1d\xb1\xdf\x91\xf6\x1d\xb1\xd5\x11\xbf\x3a\x52\xd7\x09\xfb\x9d\xf0\xbd\x33\xb8\x3b\xbb\x11\xf0\x75\x46\x47\x67\xf4\xe5\xdb\x10\x74\xe6\x83\x2f\x1f\x9f\xdc\x60\x70\xd3\xd7\x8d\xff\x6e\xf0\x77\x81\xbf\x2e\x7d\x11\xe2\xd9\x95\xb8\x75\xc5\xdf\xae\xc4\xba\x1b\xba\xba\xa1\xab\x1b\x7c\x75\x23\xa7\xba\xbb\x10\x6c\x14\xc0\x5d\x01\xf8\x0b\xa8\x2f\xa0\xbe\x00\x6e\x0a\x43\x85\xe8\x81\x8d\x1e\xc4\xac\x07\x7c\xf4\x00\x57\x8f\xef\x85\xe8\x49\xdc\x7a\x0e\x46\xe0\xbe\x27\xb1\xec\x89\xbd\x5e\xf8\xdf\x0b\xcc\xbd\xf1\xa3\x37\x7e\xf4\x86\xd7\xde\x07\x10\x9e\xf5\x41\x6f\x1f\x6c\xf4\xc5\x46\x5f\x6c\xf7\xc5\x8f\xbe\xd8\xe8\x0b\x47\xfd\xb0\xd7\x0f\xfc\xfd\xc8\xd1\x7e\xe8\xee\x4f\x9b\xfe\xe4\x78\x7f\x78\xe9\x4f\x6e\xf4\x87\xef\xfe\xe8\xee\x8f\x9e\x01\x60\x1f\x00\x9e\x01\xe8\x1f\x80\xfe\x01\xe8\x1f\x40\xbe\x15\xc1\x49\x11\xfe\x15\x53\x57\x7c\x3f\x82\xde\x62\xc6\xc6\x40\xb8\x1e\x48\x4e\x0e\x04\xff\x40\x72\x7d\x20\x3e\x0c\x04\xef\x40\x7c\x1b\x48\x0c\x07\xe1\xfb\x20\xec\x0c\x82\xa3\x41\xe0\x19\x84\x9d\x41\x70\x34\x18\x6e\x07\xe3\xc7\x60\xda\x95\x80\x75\x08\xed\x86\xe0\xc3\x10\xf0\x0c\x81\xe3\x21\xd8\x1a\x42\x0c\x86\xe0\xef\x50\x30\x0d\xa5\xed\x50\xf8\x1f\x8a\x1f\xa5\xc4\xac\x94\xd8\x96\x92\x77\x1e\xf8\xf3\xc0\x95\x07\x0c\x1e\x6c\x7b\xb0\x3d\x8c\xb6\xc3\xe0\x60\x18\x3e\x0c\x23\x0f\x86\x81\x7d\x18\x7e\x0c\x03\xf3\x70\xfc\x1e\xae\xfe\x5d\x3e\x76\x87\x83\x6f\x04\x5c\x8c\x40\xdf\x08\x30\x8e\x80\xa7\x91\xe8\x1b\x49\x7c\x47\xe1\xcf\x28\xb8\x1f\x85\xbd\x51\xf0\x36\x0a\xde\x46\xe3\xeb\x68\xf4\x96\x81\xa7\x1c\xfc\xe5\xd8\x29\x27\xfe\xe5\x8c\xd1\x72\xec\x94\x63\xa7\x1c\x5c\xe5\xe0\x1a\x83\x9e\x31\x8c\x89\x31\xc4\x70\x0c\xbe\x8f\xc1\x9f\x31\xc4\x67\x2c\xf6\xc6\x62\x6f\x2c\xbe\x8e\xc5\xd7\xb1\xf8\x3a\x16\x1e\x2b\xe8\x5b\x41\xdf\x0a\xfa\x8e\xa3\xef\x38\xfa\x8e\xa3\xef\x38\x38\x1d\x07\x6f\xe3\xe0\x6d\x1c\x18\xc6\x83\x61\x3c\xcf\xc6\x33\x26\xc6\x93\x97\xe3\xf1\x79\x3c\xfe\x8c\xc7\x9f\x09\xf4\x9b\xc0\xb3\x09\xf4\x9b\x40\xbf\x09\xdb\x10\xb0\x4f\xc0\xcf\x89\xe0\xbc\x12\xdb\x57\xa2\x7f\x12\x78\x27\xe3\xc3\x64\xfc\x9b\x82\x0f\x53\x68\x37\x95\xe7\x53\x69\x37\x0d\x1d\xd3\xc8\x87\xe9\x3c\x9f\x0e\x67\x33\xa8\x9f\x01\xae\x99\xf0\x71\x15\x6d\xaf\x02\x67\x25\x7c\x57\x12\xc3\x2a\xf0\xcf\x62\x0c\xcc\xc2\x9f\x59\xf8\x37\x9b\xe7\xb3\xc1\x3a\x87\xba\x39\xf8\x35\x17\x8c\x73\xe9\x3b\x0f\x5f\xe7\x81\x69\x1e\x7e\x5e\x0d\xde\x6b\x68\x7f\x0d\xf5\xf3\xe1\x7c\x01\xf6\x16\xd0\x76\x21\x71\x59\x88\xce\x85\xf8\xb8\x88\x36\x8b\x89\xe7\x62\x70\x2c\x81\xef\x25\xe4\xdb\xb5\xdc\x5f\x0b\x7f\x4b\xc1\xbc\x8c\xb1\xb6\x8c\x58\x2d\xa7\x5c\x4e\x3e\xae\x00\xeb\x0a\xec\x5e\x47\x9b\xeb\xd0\xbb\x92\x58\x5c\x4f\x3e\x5d\x4f\xbf\x55\xe4\xf2\x2a\xf2\xf7\x06\xf0\xdf\x40\xdf\x1b\xf0\x69\x35\x1c\xad\x46\xef\x6a\x78\x58\x4d\xff\xd5\xb4\x5b\x03\x37\x6b\x28\x6f\x24\x67\x6e\x24\x4f\x6e\x22\x66\x6b\xc1\xbf\x16\x8e\xd7\x82\x67\x2d\x1c\xaf\x85\xe3\xb5\x70\xb4\x0e\xdd\xeb\xf0\x69\x1d\xfe\xaf\xe3\xd9\x3a\x70\xdf\x0c\x96\x9b\xc9\xcf\x9b\xd1\x77\x33\x1c\xaf\x07\xd3\x7a\xfa\xae\x07\xcb\x7a\xb0\xad\x27\x8f\x37\xd0\x6f\x03\x7d\x36\xe0\xef\x06\xf8\xda\xc8\xf5\x26\xf4\x6c\x52\x25\x75\x9b\xa8\xdb\x0c\xb6\xcd\xd8\xdd\x0c\xde\xcd\xd4\x6d\xc6\xee\x66\xec\x6e\xc6\xee\x16\xfa\x6f\x21\x0f\x6e\x41\xef\xad\xe0\xbf\x15\xfc\xb7\x62\x6f\x2b\xd8\xb7\x12\x97\xad\xf8\xbe\x15\xdb\xdb\x88\xf9\x6d\xc4\xe0\x36\xda\xdc\x46\x9b\xdb\x68\x73\x1b\xbe\xdd\xc6\x78\xba\x0d\x3d\xdb\xd1\xb3\x1d\xbb\xdb\xd1\xb3\x9d\x35\x67\x3b\x9c\x6c\x87\xa3\x1d\xe4\xf4\x0e\x62\xb3\x83\xb8\xec\x80\xdf\x1d\xe4\xc5\x0e\x74\xee\x40\xe7\x4e\xe2\xb4\x13\x2e\x77\xe2\xe3\x4e\xb8\xd9\x89\x4f\x3b\xb1\xb3\x93\x98\xee\x22\x27\x77\xc1\xfd\x2e\x62\xbc\x0b\x9d\xbb\xe0\x79\x17\x7d\x6f\x27\x77\x6e\xc7\xde\x1d\xd8\xbb\x03\xdc\xbb\x89\xf1\x9d\x60\xba\x0b\x5d\x77\xa1\xf3\x6e\xb8\xbe\x1b\xfd\x77\x73\xbd\x87\xba\x3d\xe4\xd5\x1e\xf4\xec\x01\xf3\x1e\xfc\xde\x03\xa6\x7b\xd0\x79\x0f\xb9\x7c\x0f\xfa\xee\xa1\xed\xbd\xb4\xbb\x17\x8e\xee\xa5\xfe\x5e\x72\xe5\x3e\xda\xdc\x8f\xef\x0f\xe0\xe3\x83\x60\x7e\x88\xe7\x0f\x61\xab\x1a\xee\xaa\x99\xcf\xf6\xc2\xed\xc3\xd8\x7c\x18\xac\x8f\x60\xef\x11\x74\xec\xa3\xfd\xa3\xf8\xff\x28\x3a\x1e\x45\xc7\x63\xe4\xd5\x7e\xe6\xa0\x03\xc4\xec\x00\xcf\x0f\xd2\xf7\x10\x9c\x1e\xc2\xc7\xc7\xc1\xfe\x38\x7d\x0f\xc3\xdf\x13\x45\xe6\xaf\xcf\x3f\x49\x9b\xa7\xe8\x7f\x84\x98\x1f\xe1\xfa\x69\xf8\x78\x86\x76\xcf\x30\x6f\x3c\x4b\xce\x3e\x47\xfc\x9e\xc3\xef\xe7\xd1\xfb\x02\xf9\xf1\x22\xbc\xbe\xc8\xf5\x8b\x70\xf5\x12\x6d\x5f\xe6\xfe\x65\x30\xbe\x42\xbb\x57\xa8\x7f\x15\x3b\xaf\xe1\xd3\x6b\xf4\x7d\x0d\x3c\x47\xf1\xf5\x75\xb8\x7b\x9d\x7c\x78\x83\xf2\x4d\xda\xbf\xc9\xf5\x5b\xe0\x7a\x9b\xf8\xbc\x4d\x3e\xbc\xc3\x58\x7b\x07\x1d\xef\xc2\xf5\x7b\xc4\xe5\x3d\xea\xde\xc7\xcf\xf7\x99\xaf\x3e\xe0\xfe\x03\x7c\xfc\x10\x2e\x3f\xa4\xcf\x87\xd8\xf8\x08\xdf\x3f\xc2\x8f\x63\xd8\xf8\x18\x8e\x3e\xe6\xf9\x71\x30\x1f\x87\xfb\x4f\xe0\xe8\x13\xca\x4f\xc9\x85\xcf\xe8\xf3\x19\x7a\x4f\xd0\xe6\x04\xb9\x7b\x02\x3c\x9f\x83\xed\x73\x72\xe4\x24\xb1\x3f\x89\x0f\xa7\xf0\xf3\x34\x36\x4e\x13\xa3\x33\x94\x67\x58\xb3\xce\xc0\xf5\x59\xfa\xd7\x80\xa1\x86\x5c\xff\x02\x6e\xbf\xa0\xed\x97\xe0\xff\x12\x9f\xbf\xa2\xdd\x57\xe4\xdf\xd7\xe8\x3c\x47\x9b\x6f\xe0\xf2\x5b\x72\xfc\x3b\xae\xbf\x27\x7f\x7e\x80\xfb\x1f\x68\xff\x23\x5c\xfc\x84\xbf\x3f\xe1\xcf\xcf\xf0\xf3\x33\xb8\x7e\x81\xfb\x5f\xc1\xfa\x2b\xe5\x6f\xe0\xfa\x0d\xbc\xbf\xc1\xfb\xef\xc4\xe0\x77\x70\xfd\x01\x27\x7f\xe0\xd7\x1f\xf8\xfe\x87\xba\x47\xcf\x9f\xd4\xfd\x49\xbb\x3f\xd1\xf7\x27\xe3\xf3\x3c\x6d\xcf\xd3\xff\x3c\xd8\xcf\xc3\x03\xe1\x11\x17\xc0\x74\x81\x9c\xb9\x80\x1f\x17\xb0\x57\x4b\x5d\x2d\xbe\xd6\x8e\x30\x7f\x77\xa2\x96\xbe\xb5\x6f\xaa\xaf\xd3\x11\x78\xf1\x56\x58\xff\xf6\xf2\xb8\xf5\xbb\x51\xe8\xf4\xc1\xaf\x8f\xd8\xf8\x2e\x08\x29\x1a\x23\x5b\x90\x73\x42\xca\x0a\xe4\x7e\x84\x7a\xad\x23\xb2\x0f\x39\x21\xa4\x3e\x11\x99\x8f\xac\x46\x0e\x23\xbf\xb3\x11\xcf\x45\x66\x20\xbb\x91\x0f\x85\xb4\xc7\x22\x4d\x10\x74\xd8\x9f\x43\x68\x13\x90\x85\x8c\x40\xe8\x17\xf0\x85\x90\x0e\xda\x38\x4a\x91\x9d\x42\x06\xda\x10\x37\x32\x05\xc1\x7e\x20\x7d\x02\xbf\x17\x32\x08\x1d\xea\x6f\xc2\x04\x51\x17\x44\x5d\xd0\xcf\x42\xb2\x57\x95\xc1\xb4\x0b\x5e\x8b\x80\x29\x18\xdd\x21\x2e\x04\xdd\x21\xd5\x42\x86\x86\x22\x45\x08\xb6\x43\x57\x22\x47\x84\x0c\x43\x7f\x18\xcf\xc3\xc0\xc7\x5e\x56\x86\xd7\x43\x06\x23\x60\x09\x3f\x80\x80\x27\xa2\x21\x42\xbf\x88\xc5\x08\x7e\x45\xa0\x37\x12\xcc\x91\x65\x08\xfd\x22\x5f\x12\x32\x0a\xdd\x51\xe0\x89\xc2\x7e\xd4\x1e\xf5\x02\x05\x01\x77\xf4\x06\x04\xbd\x31\xd8\x89\x69\x87\xe0\x53\x0c\xd8\x62\xe8\x13\x73\x5c\xc8\x58\xf0\xc5\xc2\x51\x6c\x4f\x04\x1c\xb1\xb4\x8f\xa5\x7f\xec\x6b\x08\x7e\xc6\x81\x27\x0e\x3d\x71\xf0\x1a\x87\x0f\x71\xe0\x89\x07\x5f\x3c\x3e\xc6\xf3\x3c\x01\x1e\x12\xb8\x4f\x58\x86\xf0\xac\x1e\xfa\xea\xcd\x45\xf0\xad\x1e\x38\xeb\xb7\x44\x88\x4b\x7d\xf4\x36\x00\x43\x03\xfc\x4a\x44\x5f\x22\xbe\x24\x12\xc3\xa4\x2a\x04\x1f\x92\xc0\xe8\x24\x96\x4e\xec\x38\xa9\x77\x82\xcd\x05\x2e\xf6\xcf\xd2\x05\x1e\x17\x71\x4f\xa6\x6f\x32\x5c\xa7\xe0\x6b\x0a\x36\x53\xb0\x93\xb2\x0d\x21\x0f\x52\xc1\x9f\x4a\xdf\x54\x70\xa5\xa2\x2f\x15\x2c\xa9\xd4\x37\x8e\x44\xc8\x9d\xc6\xf8\xde\xb8\x2f\x02\x67\x8d\xb1\xd9\x18\xfe\x1b\xd3\xb7\x31\x3e\xa4\x81\x39\x8d\x67\x69\x3c\x4b\xc3\x5e\x3a\xf7\xe9\x6f\x22\x60\xca\xa0\x7f\x06\xf8\x33\xb0\x9d\x41\x3c\x9a\x60\xb7\x09\x7d\x9a\xe2\x4f\x33\x62\xd0\x0c\x3e\x33\xe1\x2d\x13\xff\x33\xa9\xcb\xc4\x36\xfb\x72\x99\x85\xbd\x2c\x30\x65\x11\x93\x2c\xfa\x37\x47\x67\x73\xb8\x68\x8e\xef\xcd\xb1\xdd\x9c\xbc\x69\x8e\x5f\xec\xd7\x65\x0b\xfc\x6e\x41\x5d\x0b\xea\x5a\x80\x39\x1b\xff\xb2\x89\x79\x36\x1c\x64\xe3\x77\x4b\xfc\x6a\x85\x0f\xad\xc0\xd8\x0a\xec\xad\x68\xd7\x8a\x3c\x68\x05\xbe\xd6\x70\xda\x1a\x1d\xad\xb1\x99\x03\x6f\xb9\xe4\x6e\x2e\xf1\x6d\x03\x9e\xb6\xf0\xa3\xfe\x99\x51\x1e\x98\xda\xd1\xae\x1d\xcf\xda\x81\xb1\x3d\x31\x6d\x4f\x0e\x76\x20\xa7\x3a\xe0\x73\x07\x6c\x5e\x81\x7f\x1d\xa9\xef\x48\xdb\x4e\xc4\xb4\x13\xed\x3a\x83\xbf\x33\x7a\xf3\xf1\xcf\xcd\x33\x37\x38\xdd\xb4\x77\xa3\xdb\x0d\x76\x37\x39\xd2\x85\xb2\x2b\x7d\xbb\x12\xeb\x6e\x60\xee\xd6\x1d\x81\xa3\xee\xf0\xc6\xbe\x5c\x16\x90\x8f\x05\x8c\x8d\x42\xca\x1e\xe8\xe8\x01\xfe\x1e\x70\xdb\x13\x9f\x7a\xd2\xbf\x17\x79\xd0\x8b\xe7\xec\xb5\x65\x1f\xea\xfa\x82\xb3\x2f\xfe\xf5\xa3\xad\x3a\x86\xf6\x27\xe7\xd8\x2f\xcb\x22\x38\x29\xc2\xaf\x62\x38\x28\x46\xef\x40\xf4\x0d\x44\x0f\x7b\x5f\x39\x98\xba\xc1\x60\x1c\x4c\xdd\x60\x74\x0c\xc6\x9f\x12\xca\x12\x70\x95\x10\xe3\x12\x78\x29\x81\xaf\x21\xf0\x34\x04\x4e\x87\xc0\xe9\x50\xf4\x0f\x05\xeb\x50\x62\x33\x94\x9c\x29\xe5\xba\x94\x6b\xf6\xbb\xd2\x43\xde\x79\xb8\xf7\xa0\xcf\x83\x1e\xf6\xbc\x92\x3d\xae\x1c\x8e\xff\xc3\xf1\x7f\x38\xfe\x0f\xc7\xef\x11\x60\x65\x8f\x2b\x47\xd0\x7f\x04\x79\x30\x02\xac\x23\xb1\x31\x92\x76\xa3\x78\x36\x0a\x9c\xa3\xd1\x33\x1a\xbd\xa3\x89\x55\x19\x38\xcb\xc0\x59\x86\xde\x32\xf4\x96\x31\x46\xca\xf0\xa1\x4c\x3d\x23\xa7\xca\x89\x57\x39\x79\x50\x8e\xff\xe5\xdc\x8f\xc1\x16\x7b\x5b\x39\x16\x2e\xc7\x52\x57\x01\xe6\x0a\x6c\x8d\x23\x6e\xe3\xb1\x3b\x1e\xdf\xc6\xe3\xdb\x04\x62\x39\x91\x67\xec\x43\xe5\x44\x74\x4e\x44\xe7\x95\xf0\x32\x89\xf8\x4d\x02\xd7\x24\xc6\xcc\x64\x72\x6f\x32\x3a\xa6\xd0\x6f\x0a\x31\x98\x82\x0f\x53\xe0\x7f\x0a\x7c\x4c\x81\x8f\xa9\x3c\x9f\x4a\x6e\x4e\x25\x16\xd3\xc0\x3e\x0d\x9c\xd3\x78\x3e\x1d\xbd\xd3\xc1\x3a\x03\xfe\x67\x90\x1b\x33\xe1\x67\x26\xd8\xae\x22\x3f\x2a\xd1\x55\x49\x9e\x57\xd2\xb6\x0a\xbf\xab\xc0\xc5\x9e\x55\xb2\x67\x95\xb3\xe0\x60\x16\xf8\x67\x31\x9e\x66\xc3\xe7\x6c\xb8\x98\x8d\xee\x39\xe8\x9b\xc3\xb3\x39\x3c\x9b\x03\xa7\x73\xc1\x34\x0f\x3d\xf3\xd0\x7d\x35\xed\xae\x7e\x57\xc8\x6b\xc0\x7e\x0d\x36\xe6\xa3\x77\x3e\xfd\x16\xc0\xd7\x42\x38\x58\x48\x9b\x45\xf4\x5b\x4c\xfb\x25\xe4\xc4\xb5\xc4\x60\x29\xb8\x97\xc2\xd1\x32\xfa\x2c\xa7\xfd\x72\x30\xaf\xa0\x6e\x05\xcf\x57\x50\x77\x1d\x1c\xac\x64\x5e\x5e\xc9\x7c\x77\x3d\x7e\xac\x22\x87\x6e\x80\x8f\x1b\x98\x1f\x56\xe3\xd3\x6a\xda\xac\x26\x77\xd7\xd0\x7e\x0d\x7a\x6e\xc4\xf7\x1b\xe1\xe1\x46\x62\x71\x23\x58\xd8\xa7\xca\x75\xd8\xb9\x99\xe7\xeb\xb1\xcb\x7e\x53\x6e\x40\xff\x06\xf4\x6c\xc4\xb7\x8d\xf4\xd9\x08\xd6\x4d\xe4\xfc\x26\xea\x36\xc3\xc1\x66\x74\x6f\xa1\xfe\x16\x9e\xdf\x4a\xfd\x56\xf8\xd8\x4a\xfe\x6d\x23\x17\xb6\xc1\xf7\x6d\xd4\x6f\x07\xd3\x76\x62\xb3\x83\x79\x61\x07\x25\xfb\x3f\xb9\x93\x58\xee\xa2\xdc\x85\x8d\xdb\x69\x7b\x3b\x6d\xef\x00\xc3\x6e\xea\xef\xc4\xb7\xbb\xe0\xe0\x2e\x72\xe9\x2e\x62\x7c\x17\x31\xbe\x9b\x58\xdc\x4d\xbe\xdc\x0d\xaf\x7b\xa8\xdf\xc3\x58\xbd\x87\x7e\xf7\x60\xfb\x5e\xe2\x72\x2f\xed\xee\xc3\xfe\x7d\xe0\xb9\x1f\xfc\xf7\xd3\xe6\x01\xb0\x3c\xc0\xfd\x83\x3c\x7b\x88\xf1\xf1\x10\x39\xf4\x90\xba\x86\xe7\x6a\x74\xed\x45\xe7\x5e\xfc\x7d\x98\x76\x0f\xa3\xef\x11\xec\x3e\x82\x7f\xfb\xe8\xbb\x0f\x3b\x8f\xc2\xe1\x63\x60\x7e\x8c\x36\x8f\x11\xbf\xc7\xc0\xb8\x9f\x71\xba\x9f\x31\xb2\x9f\xfc\xdb\x4f\xfb\xfd\xc4\x6b\x3f\x79\xba\x1f\x3e\xf6\xc3\xf5\x7e\x7c\xd8\xcf\x98\x3c\x40\xbf\x03\xf0\x79\x80\xe7\x07\xc8\x9f\x03\xf4\x3f\xc8\xfd\x41\xb0\x1d\x44\xef\x41\x78\x38\x48\x9c\x0e\x92\x8f\xec\x11\xe5\x21\x7c\x38\xc4\xf5\xe3\xe4\xea\xe3\x70\xf0\x38\x3e\x3f\x4e\xac\x0e\x93\x63\x87\x89\xd1\x61\xf2\xfe\x30\x3e\x1c\xc6\xdf\xc3\x60\x7d\x02\x1c\x4f\x80\xe3\x09\x70\x3c\x41\x5e\x3d\x81\x4f\x4f\x12\xe3\x27\x89\xd7\x93\xe8\x7d\x0a\x6c\x4f\xe1\xfb\x11\xf8\x3f\x42\xf9\x34\xb9\xf4\x34\xf5\x4f\xd3\xf7\x19\x7c\x7f\x16\x2c\xcf\x82\xf3\x39\x6c\x3d\x0f\xa6\x17\xd0\xf7\x02\xd7\x2f\xa2\xef\x45\xec\xbe\x04\x8e\x97\xc0\xfd\x12\xf1\x79\x19\x0c\x2f\x63\xe3\x65\x78\x78\x19\x3f\xd8\x6f\xca\x57\xe0\xe2\x15\xf0\xbe\x82\x8e\x57\xb1\xfb\x2a\x6d\x5e\x45\xef\x6b\x94\xaf\x61\xfb\x35\x72\xf3\x28\xf9\x71\x14\xcc\x47\xe1\xe6\x75\xc6\xc1\xeb\xf8\xfd\x3a\xfa\x5e\x47\xff\x1b\xe0\x7c\x03\x9e\xdf\x20\x57\xde\x24\x2f\xdf\x84\xf7\xb7\xb0\xfd\x16\xfa\xdf\x02\xef\xdb\xc4\xff\x6d\xe2\xfb\x36\x31\x7b\x1b\x4e\xdf\x81\xa3\x77\xc0\xf4\x0e\xed\xde\xc5\xc6\xbb\xe8\x7e\x17\xdd\xef\x51\xff\x1e\x3e\xbe\x47\x9b\xf7\xd1\xfd\x01\xcf\x3e\x50\x25\xf8\x3e\x84\xd3\x0f\x89\xf7\x87\xe8\xfb\x08\xae\x3e\x82\x83\x8f\xf0\xe3\x18\x6d\x8e\x91\x2b\xc7\xc8\xfb\x63\xe8\x3f\x06\x2f\xc7\xd0\xfb\x31\x79\xf0\x31\x3c\xb3\xa7\x95\x1f\xc3\xd3\x71\x30\x1c\x47\xf7\x71\x78\xf9\x04\xbc\x9f\xd0\xf6\x53\xc6\xf4\xa7\xf8\xf7\x29\x7d\x3e\x25\x47\x3e\x43\xcf\x67\xf8\x77\x02\x4e\x4e\x30\xd7\x9c\xa0\xfe\x73\xf2\xfa\x73\x30\x9c\x84\x97\x93\x70\x76\x12\x6c\xa7\xa8\x3b\x05\x27\xec\x77\xe5\x69\x9e\xb1\xdf\x95\x67\xe8\x77\x96\x3c\x39\x8b\xbd\xb3\xe8\xaa\x81\x87\x2f\x18\x2b\x5f\x90\x97\x5f\x10\xf3\x2f\xb0\xf3\x05\x3e\x7f\x81\x0f\x5f\xe2\xe7\x97\xe8\xfa\x8a\xeb\xaf\xc1\xfd\x35\x5c\x7f\xcd\x5c\x7a\x0e\x7c\xe7\xd0\xff\x0d\x5c\x7c\x83\x0f\xdf\xc2\xe1\xb7\xf4\xfb\x96\x76\xdf\x81\xf9\x3b\xda\x7d\x87\xcf\xdf\xd1\xf7\x7b\x74\x7c\xcf\xf5\x0f\xd8\xfe\x11\x3b\x3f\xd2\xe6\x27\xec\xff\x84\x8d\x9f\x88\xe5\xcf\xf8\xfe\x33\x7e\xff\x82\x8f\xbf\xc0\xd7\x2f\xe0\xfa\x15\xbf\x7e\xa3\xdf\x6f\x60\xfa\x8d\x7e\xbf\x11\x93\xdf\xb0\xf7\x3b\x18\xfe\x80\xc7\x3f\x88\xc3\x1f\xf0\xfa\x07\x6d\xff\x20\x37\xff\x24\xce\x7f\x62\xeb\x3c\xfa\xcf\x93\x3f\x17\xe8\x77\x01\xbf\x6b\x29\xd9\x0b\xcb\x5a\xe2\xe2\x25\xdf\xbc\xc4\xd9\x4b\xce\xfa\x68\xef\xa3\x9d\xef\x25\xa1\x89\xee\xc8\x4e\xe4\x77\xa1\xc9\x89\x42\xd3\xea\x21\x73\x91\x73\x42\xd3\xb3\x90\xb5\xc8\x05\xa1\xd9\x0e\x08\xcd\x4e\x7d\x40\xac\xd0\x1c\x36\x84\x3e\x81\xed\x90\xe7\x84\x16\xd4\x13\x39\x21\xb4\xe0\x19\x42\x0b\xa1\x4f\x88\x2a\xd1\x1d\x5a\x25\xb4\xb0\x40\x64\x0a\xf2\xa1\xd0\xc2\x9b\x20\xe8\x88\x40\x47\xc4\x32\x04\x9b\x91\xb4\x8d\x6a\x88\x94\x21\xdf\x0b\x2d\x7a\x0b\x82\xed\x18\xda\xc5\xd2\x2e\x96\xfb\xd8\xfb\x91\x23\xc8\xbb\xc8\x17\x08\x78\xe2\x22\x91\xdd\x08\xb8\xe2\x5e\x13\x5a\xfc\x36\xa1\x25\x70\x5f\xaf\x5a\x68\xf5\xe9\xd3\xe0\xb8\xd0\x12\x69\xdf\x10\x5c\x8d\x68\x93\x34\x5f\x68\xce\x11\x42\x73\xf5\x15\x5a\x32\xf6\x92\xa9\x4f\x01\x6b\x0a\x65\xea\x69\xa1\xb1\x7f\xd3\x1a\xe3\x07\x7b\x35\x2d\x0d\x1d\xe9\xe0\xca\xe8\x28\xb4\x26\xe0\x6f\xc2\x7d\xd3\xc3\x42\x6b\x46\xdf\x66\x60\xc9\xc4\x77\xf6\x5d\x5a\x73\xfa\x37\xc7\x76\x0b\xee\xb3\xd1\x9d\x8d\x8f\x2d\xe1\xb0\x25\x18\x5b\xe1\x4b\x6b\x38\x60\xcf\xa4\xe5\xe2\x6b\x1b\xf4\xb5\xa5\x4f\x1e\x7d\xf2\xf6\x08\xad\xdd\x60\xe4\x67\xa1\xb5\xe7\x79\x07\x9e\x5f\x81\xdd\x2b\xe0\xba\x23\x38\x3a\x82\xa9\x23\xfd\x3b\xa1\xb3\x13\xfa\x3b\xaf\x44\xe0\x8a\x7d\x92\x96\xcf\x75\xfe\x3e\xa1\xb9\x89\x81\x7b\x03\x42\xdb\x2e\xe0\xec\x82\xfe\xae\x94\x5d\xb9\xef\x86\xaf\xdd\xd1\xd7\x1d\xde\xd9\x23\x69\x05\x70\x59\x88\xde\x42\xf8\xe9\xd1\x12\x81\x97\x9e\xb4\xef\xf9\xa6\xd0\x7a\xe1\x73\xaf\xd5\x08\x7c\xf5\x06\x53\x6f\xb8\xef\x43\xbf\x3e\xf8\xd0\x97\x67\x7d\xc1\xda\x8f\xbe\xfd\xb0\xd5\x0f\x7f\xfa\x81\xa3\x3f\x71\xec\x0f\x96\xfe\xf8\xdd\x1f\xfd\x03\xb0\x3b\x80\x3e\x03\x88\xd1\x00\x38\x18\x00\xf6\x22\x62\x57\x44\xbf\xa2\x22\x04\x4e\x8a\xb0\x51\x04\x8f\x45\xd8\x29\x86\xd3\x62\x78\x60\xaf\xa5\x15\x57\x20\xe0\x2d\x46\x57\x31\xb9\x54\xac\x9e\xc3\xcb\x40\xf2\x70\x20\x7a\x07\xf2\x7c\x20\xb6\x07\xc2\xff\x40\xb0\x0d\x22\xee\x83\x72\x11\xb8\x1c\x44\xbf\x41\xe0\x1b\x84\x3f\x83\xc0\x35\x18\x1b\x83\xb1\x31\x98\xfb\xc1\xdc\x97\xc0\x67\x09\xcf\x4b\xc0\x55\x82\x3f\x43\xb8\x1f\xc2\xfd\x10\xee\x87\x80\x7b\x28\x38\x86\x82\x63\x28\x18\x87\xc2\xd1\x50\xf8\x18\x8a\x6d\xf6\x69\x5a\xe9\x62\x84\x3c\x2a\xc5\x6e\x29\x9c\x96\xa2\xcf\x83\x6d\x0f\x98\x3c\xf4\xf7\xd0\x7f\x18\xfd\x87\xd1\x7f\x18\xfd\x87\x91\xeb\xc3\x68\x3f\x8c\xf6\xc3\x68\x3f\x8c\xf6\xc3\x69\x3f\x1c\xac\xc3\xc1\x3a\x1c\xbe\x87\x13\xbb\xe1\xc4\x7b\x38\x76\x86\x63\x67\x04\x3e\x8e\x60\xfc\x8d\xa0\xcf\x08\x7c\x1b\x89\x8e\x91\xe4\xf1\x48\x62\x3e\x92\xe7\xa3\x1a\x23\xc4\x60\x14\xdc\x8e\x02\xfb\x28\xe2\x3e\x0a\x7e\x47\x91\xff\xa3\xe1\x77\x34\xb6\x47\xa3\x7b\x34\xf9\x33\x1a\xbf\x46\xd3\x6f\x34\xdc\x97\xf1\xac\x8c\x67\x65\xe8\x66\x2f\xa8\x95\xc1\x5f\x19\x36\xca\xe0\xa0\x9c\x67\xe5\x6e\x04\x5e\xd9\x07\x6a\xe5\xf0\x55\x4e\x5c\xcb\xb1\x3f\x06\xbc\x63\xc0\x3b\x06\x9d\x63\xc0\x3b\x06\xbc\x63\xc0\x3b\x06\xbc\x63\xc0\x33\x16\xbc\x63\xe9\x3b\x16\x5d\x63\xf1\xbf\x82\xf8\x56\x90\x07\x15\x70\x55\x81\xae\x0a\x74\x55\xc0\x7d\x05\xbe\x8f\x63\x8c\x8d\xa3\xed\x38\xb8\x1c\x47\x5c\xc6\xf1\x6c\x1c\xcf\xc6\x61\x67\x3c\xb9\x3b\x9e\x1c\x1a\x4f\xfc\xc7\xe3\xf3\x78\xfa\x8e\x47\xe7\x78\x78\x9b\xc0\xb3\x09\x3c\x9b\x40\xdf\x09\xe0\x98\x40\x8c\x27\x90\x1b\x13\xc8\x8d\x09\x60\x60\x1f\xaa\x4d\x24\x06\x13\x99\x2f\x26\x82\xfb\x4a\xfa\x5f\x89\xfe\x2b\xc9\xed\x2b\xd5\x3d\xfa\x27\xe1\xe3\x24\xda\x4c\xc2\xc7\x49\x3c\x9b\x04\x6f\x93\xc8\xab\xc9\xe8\x9e\x0c\x2f\x93\xd1\x3b\x19\xce\x26\xe3\xdb\x64\x30\x4d\x86\xcf\x29\x70\x3d\x05\x3c\xec\x5d\xb5\x29\xc4\x80\xbd\xab\x36\x05\x3f\xa6\x52\x3f\x15\x5d\x53\x19\x1b\x53\xc9\x91\xa9\x3c\x9b\x4a\xfc\xa7\xe2\xff\xb4\x50\x04\xbe\xd8\xcb\x6a\xd3\xd0\x37\x0d\x7d\xd3\xd0\x37\x0d\x7d\xd3\xe9\x37\x9d\xbc\x60\x6f\xab\x4d\x07\xff\x74\xf0\x4f\x07\xc3\x74\x7c\x60\xaf\xab\xcd\xe0\xf9\x0c\x62\x3b\x83\xf8\xcc\x20\x3e\x33\xf0\x7f\x06\x3a\x67\xf2\x6c\x26\x3a\x67\xa2\x73\x26\x3a\x67\xa2\x73\x26\x31\xbf\x0a\xec\x57\xc1\xcb\x55\x60\xbc\x8a\xd8\xb0\x3f\xd6\xae\x62\x5e\xbb\xea\xb8\xf9\xe7\x28\x2a\xd1\x57\x09\xce\x4a\x70\x56\xa2\xb3\x92\xbe\x95\xe4\x44\x25\x7e\x54\x92\x13\x55\x70\x52\x45\xbc\xaa\xd0\x5b\x45\xbc\xaa\xe0\xab\x0a\xbe\xaa\xe0\x6b\x16\xba\xd9\x57\x6b\xb3\xe0\x7c\x16\x9c\xcd\x02\xf3\x2c\xf4\xcf\x42\xff\x2c\xf4\xcf\x46\xff\x6c\xf4\xcf\x06\xef\x6c\x74\xcf\xe6\xd9\x6c\xf0\xb2\xe7\xd6\xe6\x80\x77\x0e\x78\xe7\xa0\x77\x0e\xdc\xcd\x81\xef\x39\xe8\x9e\xc3\xf3\x39\x70\x31\x07\xfd\x73\xd1\x3f\x17\xfd\x73\xd1\x3f\x17\xfd\x73\x69\x33\x97\x98\xcc\x3d\xae\xfe\x34\x05\xc2\xb3\x79\xe8\x98\x87\x6f\xf3\x78\x3e\x0f\xfb\xf3\xb0\x31\x0f\xfb\xf3\x68\x73\x35\x6d\xae\x26\x6e\x57\xe3\xdb\xd5\x3c\xbb\x1a\xfd\x57\xe3\xd7\xd5\xd8\xbf\x1a\xae\xaf\xc1\xb7\x6b\x78\x7e\x0d\xf9\x7e\x0d\x38\xae\x01\xc7\x35\xd8\xb8\x86\x9c\xbb\x06\x0c\xd7\xd0\x66\x3e\xf8\xe7\xa3\x7f\x3e\xcf\xe6\x13\xc3\xf9\xc4\x63\x3e\xba\xe7\x13\x8f\x05\xf8\xb0\x80\xe7\x0b\xe0\x6f\x01\x36\x38\x0f\x68\x0b\xe0\x6f\x01\xfc\x2d\xc0\xce\x02\xda\x2c\x04\xe3\x42\xf4\x2f\xe4\xd9\x42\x9e\x2d\x44\xc7\x42\x7c\x58\xc8\xf3\x85\xe0\x58\x88\x8d\x45\xcc\xb9\x8b\x68\xb3\x88\x36\x8b\xc0\xbf\x08\x0e\x16\xf1\x6c\x31\xfa\x17\xe3\xdf\x62\xec\x2f\xc6\xbf\xc5\xf8\xb0\x98\xe7\x8b\xf1\x6f\x31\x18\x96\xe0\xdf\x12\xf0\x2f\xc1\xf6\x12\x9e\x2d\xc1\xbf\x25\xe8\x5d\x42\xdf\x25\xe8\xbd\x16\xff\xae\xe5\xf9\xb5\xe8\xbe\x16\xff\xae\xc5\x87\x6b\xf1\xef\x5a\xfc\xbb\x16\xff\xae\x25\x4f\x97\x82\x6f\x29\xfc\x2e\x45\xff\x52\xc6\xed\x52\xf2\x66\x29\xe3\x76\x29\xd8\x97\x31\x66\x96\xe1\xdb\x32\xc6\xcc\x32\xb0\x2f\xa3\xdf\x32\xec\x2e\x07\xd7\x72\xea\x97\x83\x77\x39\xfe\x70\xb6\xd1\x96\x63\x6f\x05\xba\x56\x50\xbf\x02\x5b\x2b\xc0\xb3\x82\x67\x2b\xf0\x65\x05\x7d\x56\xf0\xfc\x3a\xf2\xf0\x3a\xb0\x5e\x87\xae\xeb\xe0\xe0\x3a\x70\xae\x04\xe3\x4a\xf0\xad\x04\xdb\x4a\x7c\x5b\x49\xfd\x4a\xb0\xad\xc4\xfe\xf5\x3c\xbb\x1e\xff\xaf\xa7\xcf\xf5\x3c\xbf\x9e\xf1\x70\x3d\xb6\xae\x47\xd7\x2a\xfc\x5a\x85\x9d\x55\xf8\xb3\x0a\x1b\xab\xc8\x97\x1b\xc0\x75\x03\xf5\x37\xc0\xd7\x0d\x60\xbb\x81\x67\x37\xe0\xcf\x0d\xf4\xb9\x81\xe7\xab\x99\xa7\x56\xa3\x6f\x35\xfe\xac\x66\x4c\xae\x86\xaf\xd5\xe4\xf2\x6a\x6c\xad\xc1\xd7\x35\x60\x5f\x83\xad\x35\xf4\x5d\x03\xc6\x35\x8c\xd7\x1b\x99\xab\x6f\x04\xdf\x8d\xc4\xf4\x26\xfa\xde\x44\xdf\x9b\xe8\x7b\x13\x7d\x6f\xa2\xef\x4d\xf4\x5d\x8b\xdd\xb5\xe4\xc1\x5a\xfa\xaf\xa5\xff\x5a\xfa\xaf\xe5\xd9\x3a\xea\xd6\x11\xab\x75\xf8\x7f\x33\x63\xe1\x66\xc6\xc1\xcd\x60\xba\x19\x1e\x6f\x66\x6c\xde\x8c\x1f\xeb\x89\xfd\x7a\xc6\xd7\x7a\xc6\xfc\x7a\xea\x37\x80\x71\x03\x7e\x6e\x20\xcf\x36\x30\xef\x6e\x44\xc7\x46\x6c\x6e\x04\xcf\x46\x30\x6c\xc4\x97\x8d\xd8\xdc\x04\xde\x4d\xd8\xe3\x7c\xa7\x6d\xc2\xde\x26\x9e\x6f\x62\x1e\xdc\x4c\xdd\x66\xee\x37\x33\x37\x6e\x46\xdf\xe6\xe3\xc6\xd7\xdd\xda\x16\x78\xd9\x82\x1f\x5b\xe0\x6c\x0b\x5c\x6e\x01\xc7\x16\x7c\xd8\x02\xd7\xb7\xa0\xeb\x16\x9e\xdd\x02\xe6\x5b\x89\xd1\xad\xe8\xba\x15\xde\x6e\xe5\xd9\xad\x60\xdc\x0a\x86\xad\xcc\xc7\x5b\x89\xcf\x56\x38\xd9\x0a\x97\xdb\xe8\xb3\x0d\x5c\xdb\xc0\xb4\x8d\xfb\xdb\xe0\xe9\x36\xee\x6f\x03\xdb\x76\xf6\x0a\xdb\xd1\xb1\x1d\xdf\xb7\x33\x87\xec\x80\xb7\x1d\xac\x43\x3b\xb8\xde\x05\x07\xbb\x98\x47\x77\xa1\x6f\x17\xf9\xb6\x0b\x3f\x6f\x07\xdf\xed\x60\xba\x9d\xfb\xdb\xc1\x7c\x07\xf9\x78\x07\x31\xdd\x0d\x37\xbb\x69\xbb\x9b\x3c\xda\x4d\xae\x72\xd6\xd4\xee\xc4\xc7\x3b\xb1\x71\x17\xf6\xee\x22\xdf\xee\xc2\xd6\x5d\x60\xbf\x9b\xeb\xbb\xc1\xba\x07\x7e\xee\x41\xf7\xbd\x60\xb9\x0f\x5f\xee\x27\x87\x1e\xe0\xfe\x41\xe6\xbe\x87\xa8\xab\x86\xdf\x6a\xf0\xec\xa5\x7e\x2f\x98\x1e\x86\xbf\x47\xb0\xb9\x8f\x98\x3e\x4a\x9b\xc7\xd0\xf7\x18\xbc\x1f\xc0\x3f\xce\x81\xda\x01\xf4\x1d\xe2\xfa\x10\x5c\x3c\x0e\x8e\xc3\x70\xcb\x59\x4e\x7b\x02\x1e\x9e\x04\xdb\x53\xc4\xed\x29\xea\x9f\x82\xbb\xa7\xc0\x75\x04\xff\x8e\xc0\xd3\x11\x70\x3e\x4d\x5c\x9f\xe6\xfe\x69\x62\xf1\x34\xb9\xfe\x0c\x76\x9f\x61\x0e\x7d\x06\x1e\x9e\x65\xbc\x71\xa6\xd3\x9e\xc3\xf6\xf3\x60\x7a\x9e\x76\xcf\xc3\xe5\xf3\x8c\xbd\xe7\xe9\xfb\x02\x39\xf5\x02\x78\x5f\xc4\x2f\xce\x79\xda\x8b\xe4\xc4\x4b\xf8\xfc\x12\x3c\x70\xbe\xd3\x5e\xa1\xcf\x2b\xf0\xf1\x0a\x71\x7a\x95\xfa\x57\xe9\xff\x2a\xf5\xaf\x82\x9d\x73\x9d\xf6\x1a\x7d\x5e\xc3\xbf\xd7\xc0\x7d\x14\x5f\x8f\x82\xf5\x28\xfa\x8f\x82\xf1\x75\xf8\x7a\x1d\x8c\x9c\xed\xb4\x37\xc0\xff\x06\xfd\xde\x00\xcb\x9b\x70\xf1\x26\xf1\x78\x8b\x78\xbf\xc5\xf8\x7d\x8b\xb8\xbe\xcd\xf3\xb7\xc9\x13\xce\x74\xda\x3b\xc4\xe8\x1d\xf8\x78\x97\x1c\x7b\x17\xbb\xef\x81\xe1\x3d\xfa\xbe\xcf\x3c\xf4\x3e\x1c\xbf\x8f\x5f\x1f\xe0\xd7\x07\x70\xf1\x21\xfd\x3e\x44\x17\x67\x39\xed\x23\xc6\xf4\x31\xee\x8f\xe1\xd7\xc7\x70\xf5\x31\x3a\x3e\xc6\xde\x71\x72\xf2\x38\x3e\x1c\x27\x17\x4f\xa0\xeb\x2c\x98\xcf\xe1\xf3\x39\xee\xcf\xc1\xc3\x39\xb0\x7e\x43\x2e\x7c\x03\xe7\xdf\xd0\xef\x1b\xfa\x7d\x4b\xae\x7c\x4b\xbf\x6f\xc1\xff\x1d\xba\x7f\x00\xeb\x0f\xd8\xfc\x01\x9b\x3f\x52\xfe\x88\xbf\x3f\x53\xf7\x0b\x71\xfc\x95\x76\xbf\xa2\xe3\x37\x74\xfd\x0e\xbe\x3f\xf0\xe1\x0f\xf8\xff\x83\xb6\x7f\xc2\xd7\x79\xda\x9c\x87\xff\x0b\xc4\xe5\x02\xdc\xd4\xe2\x57\x2d\x6d\xbd\xe4\x82\x6f\xb7\xd0\xc5\x08\xe4\x7b\xa1\xcb\x95\xc8\xef\x42\xd7\x26\x22\x2f\x09\x5d\x6f\x82\xdc\x2f\x74\x5b\x3d\xe4\xb0\xd0\xed\xa5\x08\xcf\x03\x68\x1f\x40\x3f\x47\x3b\x64\x1b\xf2\xae\xd0\x03\x43\x91\xee\x48\x15\xb2\x0f\xf9\x59\xe8\x41\x6e\x64\x2d\x72\x42\xe8\xc1\x2e\x84\x7e\xc1\xdc\x07\xbf\x29\xf4\x90\x40\x24\x0b\x19\x8c\x5c\x10\x7a\x28\xf5\xa1\xaf\x09\x3d\xac\x21\x82\x9d\x30\x30\x84\xcd\x45\xc0\x14\xb6\x05\xd9\x83\x1c\x40\xc0\xc5\x59\x49\x0f\xfb\x42\xe8\xe1\xf4\x0f\xa7\x7f\xf8\x7c\x04\xfc\x11\x5c\x47\x70\x1d\x01\xb6\x08\x30\x45\x62\x23\x12\x4c\x9c\xa1\xf4\x48\x74\x44\xa2\x3f\x4a\x20\xb9\x48\x05\x82\xcd\xa8\xe7\x84\x1e\x6d\x43\xfa\x22\x8b\x11\xfc\x8c\x06\x7b\x0c\xba\x63\xca\x90\x0d\xc8\x11\xa1\xc7\xa2\x27\x96\xf6\xb1\xe0\x88\x05\x7f\x2c\x6d\xe2\xc0\x1a\x07\xbe\x38\x9e\xc7\xc1\x4b\x3c\x7c\xc4\x63\x3f\x1e\xff\x13\x62\x11\xfa\x24\xc0\x47\x02\x78\xeb\xb5\x44\xe8\x57\x9f\xfe\x0d\xe0\xa2\xc1\x39\xa1\x27\xd2\xbe\x21\xdc\x36\x84\xa7\x86\xe8\x6e\x78\x5c\xe8\x8d\xe0\xbc\x11\x3a\x1a\x71\x9d\x04\x86\x24\x70\x26\xd1\xdf\x89\x2d\x27\xd7\x4e\x7c\x73\x9e\x16\xba\x8b\x6b\x17\x3e\x27\xa3\x37\x19\x9e\x92\xf1\x23\xa5\x23\x42\xdf\x14\x7c\x48\x81\xd3\x54\xee\x53\xb1\x9f\x4a\x0c\x39\xc3\xe9\x8d\xd1\xd1\x98\x18\x34\x26\x66\x8d\xd1\x9f\xc6\x7d\x1a\x9c\xa5\xad\x46\xe8\x9f\x46\x9f\x74\xfa\xa4\xa3\x23\x1d\x1d\xe9\xdc\x67\xc0\x55\xc6\x14\x04\xbb\x19\xc7\xff\x5d\x9a\xc0\x6f\x13\xb8\x6e\x8a\xee\xa6\xf0\xd0\x8c\xb2\x19\x36\x9b\x11\x8f\x4c\x62\x9a\x49\xfc\xb2\x7a\x22\x70\xd1\x1c\xdf\x9b\x13\xd3\x16\xf8\xdf\x02\x9e\x5b\x80\x91\x73\xa2\x9e\x4d\xd9\x12\xee\x5a\x62\xb3\x15\xfd\x5b\x81\xbf\x35\x7a\x5b\x17\x21\xc4\x3d\x07\xbc\x39\xf0\x9f\x4b\xdb\x5c\x38\x68\x83\xbd\x36\xe8\x6d\x43\x0c\xda\xc2\x69\x5b\x7c\x6e\x5b\x2d\xf4\xbc\x48\x84\x5c\xca\xdb\x89\xe0\x5f\x3b\x72\xb4\x1d\xfe\xb5\xc3\x9f\x76\xd4\xb5\x03\x43\x3b\x7c\x6c\x0f\xe7\xed\xe9\xd7\x1e\x1e\x3b\xa0\xb3\x03\xf9\x7a\x05\x39\xd3\x91\xfc\xe9\xd8\x57\xfd\x77\x15\x38\xff\xaf\xb7\xfe\x5b\x00\xba\x70\x88\xb0\x7d\x76\xa9\x07\x08\x91\x7d\x34\xff\x68\xab\x96\x39\x51\xc9\x51\x7a\x72\x54\xf2\x7a\xfd\xee\x39\xb5\x3d\xb4\x83\xf6\x82\x3f\x1f\xb7\xbd\x7e\x5e\xfd\xf1\x53\xa1\xc9\xc9\x00\xdf\x6c\xf5\xab\xef\x0e\x91\x76\xb7\xcd\xbe\x7d\xb8\x4d\xd7\x74\x91\x9f\x93\x9d\x29\x1a\xd4\x8b\x7c\xbd\x55\x4b\x99\x1a\x93\x2c\x63\x92\x75\xed\xb9\xb3\xeb\x65\x7a\xed\xbb\xb9\xd2\x95\x2b\xef\xd5\xb7\xfe\xf9\xb8\xfa\x75\x3b\xa5\x67\x98\xde\xd7\xb6\xc6\x7e\xd4\xd0\x13\xeb\x0e\xb2\x03\xe9\x9e\xe1\x01\x9a\x40\x4b\x66\x94\xc8\xb1\x54\x20\xfa\x97\x2f\x96\xca\x98\xda\x0d\x7c\x46\xe9\x7d\xb5\x25\xb5\x8b\xb4\x25\x34\xae\x07\xfe\xb3\xe0\x48\x14\x4e\x31\xd8\xdd\x2c\x24\xd0\x61\x0b\x0d\x0b\x7d\xc8\x93\xd4\x28\x5c\x86\x39\x1b\x46\x88\xc8\xa8\xc8\x87\x3c\xf5\xe3\xe3\xa2\xa3\xc2\xf8\x9f\xbd\x5e\x42\x6c\x8c\x1e\x1c\x14\x60\x17\xd9\x39\x39\x39\xf9\x48\x74\xfb\xf6\xd9\xd9\x51\x5c\x18\x06\xf9\xa9\x7b\x8d\x7d\x3d\xc7\x91\xac\x2b\x00\xa9\x31\xa9\x79\x39\x48\x72\x4c\x8e\xae\x44\xd5\x27\xc7\xe8\xdf\x2f\xfb\xa6\x91\xf7\xc7\x0d\x5b\x37\x7a\x5f\xdd\x70\xcb\x86\x07\x1b\xbd\xbe\xfc\x54\x23\xa9\x6f\xba\x65\xa3\xcc\xe5\xe3\x60\xa3\xda\xd2\xe5\xb2\xcd\x72\xbd\x9b\xf7\xf0\x46\xef\x26\x39\x49\xc9\x46\xd9\x7d\x83\x9c\xe6\xbd\x59\xc9\x06\xef\x61\xf5\x07\xdf\xd4\xbf\xda\x6b\xe2\x2b\xb1\x3d\x65\xff\x44\x64\x8a\x1c\xd1\x49\xf4\x72\x37\x75\x65\xc5\x67\x55\x7a\xea\x25\xb8\x5b\xe4\x24\x87\xb4\xcf\x0d\xd0\x62\x1b\x49\xad\x91\x0c\xb3\x35\xaa\x1f\xef\xe8\x10\xac\x05\x57\x7a\xa4\xc8\x0c\xd0\x1a\xc0\x56\xce\xd1\xd6\x0a\x73\x3d\xae\x46\x8f\x1a\x39\x32\x3a\xa1\x7d\x03\xb3\xa6\x55\x4b\x7b\x6a\x5e\x0b\xd9\x26\x2d\x2e\x36\x3e\x21\xa6\x85\x4c\xe5\x3a\xb7\xb3\x96\x2f\x73\x1c\x49\x32\xc1\xde\x26\x37\x43\x4f\x48\xd2\xe2\x62\xc3\x35\x47\x4c\x40\x84\x8c\xa5\x32\x26\xb7\x85\x96\xa1\x77\xd6\xb4\xb8\xa9\xc9\xef\xbd\x26\x83\x46\x8e\xed\xab\x25\xd8\x9e\xba\xb5\xcb\x8a\x17\x16\x35\x98\xda\xe0\x99\x7d\x41\xde\xef\x37\x16\xc4\xdd\xb9\xb6\x7f\xef\x1b\xdf\x5e\x3d\xfb\x60\x23\x5b\x83\xe6\x83\x7e\x4d\xca\xed\x9e\xd1\x73\xc8\xec\xf6\xf7\xdd\x1f\xf8\xf8\xd3\xd9\x21\x53\xc7\x04\xcb\xeb\x34\x7b\x8b\x2d\x55\x43\xf6\x5c\xdd\xd5\xbe\x62\x85\x63\xd7\x63\x19\x8e\x3b\xe3\xbc\x3b\x6d\x4d\x07\xce\x1d\x3a\x6a\xff\xa2\x1e\x01\xb6\xf5\xe1\x37\xa7\xbb\x9a\x25\x25\x79\xcb\x1b\xb7\x70\xc5\x85\x7a\xd7\x05\xb4\x1b\xa7\x7e\xe1\xd0\xf7\xae\xef\x67\x7b\x4b\x7b\x31\xac\x44\x89\x24\x18\x69\x27\x72\xdd\xc9\xce\xec\xc7\x3c\x69\xce\xfd\xc3\xd3\xda\x50\xc6\x84\x24\x3e\xe6\xb1\x85\xec\x1f\x6e\x8b\xa3\x54\x99\x27\x49\xdd\xd6\xf9\x39\xf9\x99\x99\x99\xa2\x9e\xfa\x24\x89\x53\x65\x4e\x5a\x6b\xe5\x5c\x6a\x8a\xf2\x3a\x21\x37\x3d\x35\x25\x5c\xc6\xc5\xe6\xb4\xee\x2c\xa5\x7a\x20\xff\xe6\xc1\xd2\x87\x6c\xf7\xed\xbd\xb0\xfe\x4c\x76\xd9\x72\xcf\x97\xad\x46\x2f\x5f\xdb\x2c\xa3\x75\x41\x56\x49\xf3\x1e\x99\xf2\xdd\xb3\x43\xee\xa8\xfa\xb2\xd5\xc8\xe5\x37\x5f\xac\xb3\xf7\x0a\x3c\x3e\xe0\x91\x65\xdd\x4e\xf7\x3d\xb8\xb8\xe3\xb7\xed\x5b\xf4\xdc\x7d\xc5\xe4\x3e\x3b\xbd\xb3\x3f\xb9\xea\xc4\xec\xd3\x7d\xf7\x2f\xee\x7c\xb1\x4e\xe8\xbe\x6f\x7c\xdf\xd8\x96\xd9\xfb\x89\xc6\xa2\x85\x68\x2f\x46\xb8\xdb\xdb\x22\x62\x23\xb4\x30\x3d\x22\x43\x46\x84\x49\x91\x27\x23\xec\x79\x61\x19\x11\xb1\x69\x8d\x1c\xce\x00\x67\xf3\x62\x8f\x33\x5e\x44\x45\x46\x69\x41\x7a\x54\x54\x40\x62\x62\x7c\x91\x27\x31\x3e\xa0\x75\xb1\x27\x80\x71\x66\x78\x19\x15\x2d\xda\xd7\xcb\x26\xe4\xc6\x65\x42\x7b\x15\xfc\x91\x7c\x90\xb9\xe9\x38\x26\x73\x5a\xc7\x2b\x2f\x1d\xf1\x09\x6d\xf3\x12\x02\x1c\xf1\x39\xad\xf3\x1c\x01\xa9\x29\x19\x08\xcf\xa3\x65\x7a\x86\xf2\x9a\x6a\xa9\x18\x08\x88\x8b\x4d\x80\x98\xaa\xc4\xb1\x2f\x2c\x5f\xbe\x75\xe8\x63\x0f\xb9\x47\x4c\x76\xbf\xe0\xd9\x54\x30\xa4\x5d\x93\xf4\x66\xed\xef\xa8\x3c\xf0\xe2\xc1\x23\x6f\xc8\x3d\x8b\xba\x94\x8e\x1f\x3e\x68\x82\x1c\x98\xd3\xa6\xa4\x22\xee\xb6\xe9\x7a\xc8\xd0\x11\x33\x0f\x55\xcc\xbd\x72\xc8\x8d\x8b\x7b\xdf\xbb\xec\x96\xfb\x12\xbf\x7d\xbe\x57\xd4\x73\x71\x95\xd7\x6c\xbe\x69\x87\x0c\xf4\xb6\x79\xec\xe1\xe6\xeb\x87\xf6\x2d\xd6\xef\x6b\x96\x33\xb3\xac\x6b\xa7\xae\x53\x85\xd4\x3a\xeb\x7d\xf5\xbb\x8d\xb1\x1f\xfa\xa8\x1a\xf6\x6a\xd4\x67\x9a\x23\x5e\xb7\xfb\xc7\xb9\x90\xb2\x95\x77\xa8\xad\xd8\xfe\x9a\x08\x13\xc1\x8f\x30\x3d\x25\x8a\xfc\x7c\x5a\x69\x51\xb9\x0d\x64\x5e\x72\x40\xb0\x8c\x8b\x8c\x91\xcf\x6f\x98\xf5\xe9\x3e\x59\xff\xe0\xa7\x57\x6d\xf2\x0e\x95\x4d\x64\xdb\xd7\x65\x8d\xdc\xf2\xca\x3b\xde\x2b\xbd\x59\x47\xbd\xaf\x78\x5f\x13\x52\xcc\xf1\x0e\xd5\xb7\xa0\x27\x1c\x3d\x0e\xbf\x9e\x98\xb6\x0d\x18\x0f\x5a\x46\x72\x74\x54\x6c\xb0\x74\xcc\x79\xe2\xf8\xcc\xde\xfd\x64\xfd\x8d\x33\x3f\x39\xe4\x1d\xfa\xbe\xdc\x24\xdf\x7d\xf5\x76\x99\xb5\xcd\xfb\xbe\xf7\xf5\x97\xbc\x0d\xbd\x63\xdf\x54\x63\x55\xca\xbe\xda\x5b\xb6\x72\xf5\x7b\xb1\x22\xec\x51\x61\x97\xf6\x30\xb0\x1f\x55\xa4\xa7\x25\xd8\x13\x1c\x19\x8e\x8c\xbc\x8c\xbc\x04\x26\x89\xee\xc2\x97\xe4\xfd\x73\xdd\x9b\xe5\x2f\xdc\x5e\xf3\xed\xa4\x8f\x53\x3f\xb0\x1d\x9c\xf8\x7c\xa7\xf7\xe6\x5d\xb8\x70\xcd\x3b\x9d\x9e\x9f\x28\xa3\xc1\x35\x4e\xec\xb2\x4d\xb4\xed\x15\x21\x6a\x06\x14\x36\xbb\xed\x01\x4f\x90\xfd\x91\x4b\x33\x60\x54\x6a\x54\x72\x9b\xe4\x28\x26\xe4\x38\xed\xfd\x93\xde\x99\xf2\xa6\x93\xf2\x66\xad\xbd\x77\xa2\xdc\x72\x42\x6e\xf1\x4e\x3c\x81\x8e\x81\xde\x8d\xda\x7e\x99\x09\x97\x21\xfb\xa4\xd8\x36\x5c\x8a\x6c\xa8\x8c\x91\xc9\x72\xa0\x6c\x26\xaf\xf0\xf6\xe4\xf9\xa6\xda\x49\x06\xf6\x4c\x79\x8b\xbe\x5d\x5b\x63\xb5\x7d\xdc\x63\xb6\x85\x4b\x87\xcc\xcc\xd6\xba\x67\xcb\x5b\x7e\xfe\x59\xb5\x53\x7f\x2f\xf2\x65\xd9\xca\x68\x27\xe4\xd6\xe1\xc2\x68\x97\x4c\x74\xe4\xd4\x2b\x64\xf2\x15\x04\x46\xfd\x49\x4a\xdf\x39\xdf\x39\x7b\x53\x78\xd5\x45\xf8\xa3\x9a\xa4\x88\x11\xf9\x8c\xc3\x56\x2d\x1d\x32\x47\xc6\xda\x3c\xa7\xcf\xdf\x17\x6b\x3f\xf1\xa7\x4b\xcd\x71\x57\xf9\xce\xd9\xd6\xda\x87\xc1\x5b\x43\xe1\x12\xf9\xee\x8c\x88\x46\xce\x46\x5a\x58\x23\x77\x44\x92\x33\x29\x3f\x69\x40\xd2\x4d\x49\x4f\x25\x05\xc4\xe9\x49\x49\x81\x22\x30\xba\xca\x13\xc8\xf2\x52\xe5\x11\xf5\x2f\xcf\xf6\x06\x47\x55\x8a\xdb\x55\x0e\x37\x90\x6d\x73\x5c\x2a\x78\x01\x31\x46\x0a\x6b\x46\x3a\xb7\x8d\x96\x79\x39\x0e\xf9\xeb\x53\xcf\x97\xef\x39\x77\xa7\x5c\x36\xaa\xfa\xe7\x6f\xfa\x14\x55\x2e\xab\x18\xd8\x77\xc6\xf5\xa3\xbd\xcb\x5a\x7e\xd0\x32\xf6\xa3\x77\xb6\xca\x9b\x65\xd4\x32\xef\xa8\x5b\xbc\x55\xde\x33\xab\xf5\x0f\xca\x86\x3f\xea\x2d\x58\x7e\xe5\xd0\x17\xe4\x7e\xef\x99\x3f\xfe\x30\x62\x2d\xb2\x58\x63\xda\xb2\xc6\x84\x8b\xd6\xee\xc4\x08\xdd\xa9\x6b\xe1\xba\x1e\x1c\xe0\x08\xa8\xf4\x38\x1c\x21\xc1\x01\xa1\x9a\xd0\x2a\x3d\x2c\x45\xf9\xfe\x19\x38\xdb\x00\x6a\x8c\xc2\x1c\xd6\x0b\x26\x99\xbc\xd6\x6d\xf3\x58\x2e\x1c\x59\x4d\xe5\xf2\x07\xda\xf9\x16\x35\x5b\xfd\x53\x5f\x19\xfc\x89\xec\xd6\xf4\x2d\xfd\x9a\x41\xd3\xdf\xbf\x66\xd2\xf9\xd5\x6f\x61\x2b\x1a\x5b\x3b\xe1\x27\x51\xb4\x70\xd7\x8b\x88\x91\xe1\xb6\x98\x00\x11\x1a\x19\x19\x54\xe5\x89\x74\xc8\xfa\xa2\xfe\xac\x3a\x86\xd4\x27\xcb\x97\x65\xa7\x6d\x5a\x67\x32\x59\x31\xe0\x48\x6b\xdb\xd8\x18\xf7\x01\x0e\x46\x7e\xb2\x23\x3a\x7d\xab\x1c\x79\x78\xdd\x80\x01\xc3\xae\x4a\xf6\x7e\xd1\x49\x26\xbd\xf3\xd4\x47\x87\xf6\x9e\xda\xde\x54\xbb\xb1\xf9\xb3\x5f\x7f\xbf\x64\x53\xff\x76\xf9\xe5\xe5\x91\xcf\xbe\xb1\x7d\xd5\x8a\x6f\xe7\xdd\xba\xa4\x5b\x8d\xe1\xf7\x15\xbe\x2f\x6d\x77\x80\xa5\x85\xe8\xe4\x4e\x49\x8f\x8e\x8a\x8e\x9a\xe5\x89\x88\x76\x46\xef\x88\xd6\x23\xf5\xe8\x68\x91\xe8\x74\x12\x1b\xa7\x43\x00\x2e\x40\x85\xa8\xb5\x19\x23\x05\xca\x08\x92\xc1\x82\x15\xa5\xbc\x34\x73\x6e\x05\x61\x26\x91\x69\xdd\xd6\x80\x7a\x11\x69\xb8\x8c\x90\x49\x52\x4d\xd4\xf2\xcf\x0f\x6b\xa4\x4c\x79\xb1\xdf\xdc\xae\x8b\xe7\x8d\xc9\x1a\xb1\x72\x6b\xe9\xc0\x27\x5a\x7b\xbf\x6e\x27\x9b\xbd\xfd\xfc\xf1\x92\x3d\x55\xf2\xfa\x75\x43\x6e\x3d\x96\xf0\xf0\x83\x8d\x82\xeb\x47\xdd\xd7\x61\x4a\xfb\x82\x3e\xa7\xaa\x46\x75\xee\x73\x4f\xec\xbe\xa7\xb7\xde\x30\xf4\x8e\xa9\xf1\xb6\xa8\xe5\x93\x8a\xf7\x2f\x28\x60\x7f\x10\x0f\x9f\xd7\x11\xbb\x60\x98\x6d\xea\x8e\xd5\x85\x2d\xc2\x56\xe9\x89\x0c\xb4\x47\x44\xc8\x10\x47\x40\x80\x26\x61\x53\xed\x03\xa2\xdb\x67\xfb\x97\x7d\xb5\xe8\x93\xe5\x79\x32\x99\x35\x5e\x82\x28\x39\xa6\xad\x7e\x47\x3b\xef\xcf\xed\x6a\x17\x35\xd5\x7e\x97\x1d\xee\x3a\xdc\xc4\x7b\x22\xb0\x5b\x96\x77\x8c\xdc\x38\x2c\x49\x3a\xbd\x9f\x4b\xe7\x3b\xfa\xa0\x0b\xf7\xbd\xa5\xb7\x0e\x1b\x9a\xe7\xed\x20\x5f\x52\xff\xcd\xa8\x6e\xe4\xfa\x83\xd8\x4e\x12\x3d\xdc\x4d\x22\xa3\x22\xa2\x9c\x51\x5a\x88\x3d\x2a\xbc\x5e\xf8\x2c\x4f\x7c\x44\x3d\x67\x3d\x2d\x52\xaf\x57\x2f\x5a\x44\xc7\x55\x7a\xa2\x03\x84\xa3\xca\x63\xaf\xc3\xa2\x3f\xd3\x0d\x4c\x94\x51\x39\x06\x93\x9d\x64\x5a\xbc\xc5\x23\xf4\x01\x93\x5d\x48\x5b\x83\x42\xcd\x26\xcf\x1d\x3d\x2e\x93\xec\xfb\x06\x2f\xee\x39\x7a\xd8\xec\xe1\xde\x6f\x9f\xd7\x07\x34\xa9\xad\x1e\x7a\xf5\xe6\x07\x8e\xec\xf2\x9e\x8a\xdd\xff\x40\x64\xc2\xfd\x03\x36\xf6\x19\x30\x62\xb8\x76\xfe\x2d\xef\xa1\x61\xfb\x77\x6c\xf3\x9e\xdb\xa4\xfe\xae\xc0\x22\xb0\x6e\x26\xd6\x0d\x45\x33\xe1\x76\xa7\xc5\xb9\x80\x24\x44\x5c\x64\x9c\x2b\x4e\x0f\xd2\xe3\xe2\x18\x8d\x11\x8c\xc3\x50\x19\x11\x10\xca\x98\xcc\xb8\x34\x26\x73\xfc\x81\x36\xd0\x46\xb7\xcf\xac\x33\x2c\x5b\xc7\x27\xd8\xd9\x71\x90\x91\xfe\x85\x48\x8b\xf1\x2f\xb4\x86\x17\x5a\xec\xb3\x6f\x8f\xdb\xfb\xeb\xf6\x7d\x0f\x85\x78\xbf\xb7\x0f\xb8\xe2\xaa\x7b\x9b\x76\x7c\x68\xdc\xf6\x47\x4a\x36\xbf\xb3\x63\xf0\x90\xc2\x59\x6e\x4f\xff\x9e\x95\xdd\x62\xbf\xfb\xec\x36\x79\xb5\x74\x5c\xbb\xfd\xae\xb4\xde\x5d\x3e\x7a\xab\x4f\xd1\xfd\x9b\x27\x7f\x76\xdb\x50\x2d\xa4\xef\xf0\xc2\x39\x83\x3c\xd3\x8a\x6e\x56\xf9\x4a\xd6\xda\x3e\x37\x62\x1d\xe7\x0e\x0e\xb4\x07\xd8\x67\x79\x02\x02\xd4\x68\xc9\x37\x27\xd2\xa6\x6a\xb6\x4d\x66\x9a\x0b\x94\x5a\xa8\xf7\xe3\x1c\x39\x44\xe6\xd7\x76\x6f\xae\x3f\x9d\xe9\x7d\xda\xfb\x92\xb4\x6b\x49\xf2\x8a\x9a\xcf\xbc\xf7\xd4\xfe\x6c\xee\xc7\x0a\xe0\x64\xa7\xc1\x49\x13\x91\x2b\xb2\xdd\xf5\xe2\x1c\x69\x99\x69\x99\xb3\x3d\x69\x69\x22\x22\xc2\x39\xdb\x13\xe1\x10\xad\x66\x5f\x3e\x39\x19\x85\x3f\xeb\x3b\xcb\x7c\x69\xec\xb7\x4c\xf7\x03\xcc\x24\x0f\xb0\xc5\xe4\x5e\xda\x6d\xe8\x75\xae\xe5\x9f\x6f\x9f\x1a\x7e\xf7\x38\x39\x66\xc2\xca\xdf\x76\xbd\xf0\xfe\xc1\x95\x72\xda\xfc\xb5\xde\x9f\x8f\x6e\xed\x51\x91\x73\x4b\xdf\x2b\x33\x8b\x0e\x15\xcf\xea\xb4\x7f\xc8\xac\x2b\x62\x77\x6f\x19\xff\xd0\xec\x48\x5b\xc2\xb2\xa1\xd3\x5e\x9c\xb2\xfe\xfa\xeb\xdf\x6e\x60\x8b\xba\x6e\xc2\xfc\xd3\x57\xdb\x32\x17\x76\x98\xd6\xf9\xba\xae\xf3\x6b\xcf\x6e\xee\x71\x5d\xcf\xad\xbd\xd6\xa9\xf8\x8e\xc2\x97\x1b\xf0\xa5\x81\xc8\x20\xbe\xe9\xa1\x69\x95\x9e\xa0\xd8\x88\x50\x67\x68\x76\x28\xf1\x0d\x0d\x15\xb1\xb1\x49\x55\x9e\x58\x87\x08\xa8\xf2\x5c\x69\x93\x43\x6c\xd2\x66\xe4\xe2\xc8\x91\x7f\xcd\x46\x7f\x7c\x33\x54\x16\xb6\xcd\x53\xdb\x27\xe5\xa6\x66\xcd\xc0\xb2\x4e\x74\xdb\xca\x0f\x0e\x3d\x1a\x2c\x23\x83\xd7\xcc\x7c\xa0\x59\x9b\xc7\xc7\x6f\xd9\x3b\x68\xfb\x27\x4b\xe5\xea\xf1\x8f\x5d\x90\xa2\xb4\x5f\x61\x55\xf7\xa1\xbd\xa7\x6c\x8a\xdd\x79\x5f\xda\xfa\xb7\xdf\xec\x3d\x64\xef\xf6\xab\x3e\xde\x39\xc8\x3b\x74\x87\x77\x9e\xf7\x9b\xd5\xfa\x1b\xc3\x27\x16\xdd\x3c\x60\xd0\xa8\xed\xe6\x79\x83\xb5\x48\x2f\xb7\x75\x32\xce\x09\xf1\xee\x10\xbb\x6d\xeb\x70\x7b\x84\x7f\x51\x52\x08\x8d\x85\x29\x44\x5e\x5c\x9c\xae\xf7\xaf\x50\x7a\xa8\xb9\x4e\x69\x62\x93\x77\xa3\x3e\xa9\xae\x8e\x6d\xc3\xed\x52\x6c\x1d\x2e\x23\x8c\x00\x1a\x8b\x20\xfd\x83\x58\x34\xb5\x70\xd5\xbd\x76\x82\xb9\x76\x9a\x2a\xce\x5f\x6f\xac\xa0\x6a\xbd\x5e\x60\x53\x7f\x4b\x2b\x40\x34\x74\x47\xe6\x07\xc8\x80\x96\x9a\xd4\x22\x6c\xf9\xb6\xe9\x36\x1d\xd6\xb2\x47\x1e\x1d\xa9\xb6\x02\x31\x51\x32\x2e\x48\xc6\x8d\xb3\xe9\x17\x9e\xd2\xbb\x30\x3a\xbb\xca\xeb\x4e\x7b\x1f\xf7\x1e\x3e\x05\x96\x71\x32\x15\x1d\x4d\x0d\x2c\x5d\xdc\x2d\x6d\xf6\x07\x3c\xa3\xe9\xff\x99\x4d\x8f\xb0\x39\xb9\xb8\xc9\x66\x0b\xd2\x6d\x52\x3c\xe0\x89\x94\x2e\x39\x43\xae\x95\x36\x97\x74\xcb\x9d\xf2\x88\x7c\x53\x82\x3a\x7b\xe4\x4c\x05\x99\x88\xcc\x54\xeb\x7c\x9b\xe4\x38\x89\x60\xeb\x7c\xad\x4d\xd7\x7b\x7f\xf6\x59\xed\x47\x9f\x7c\xf2\x17\xac\x2e\x77\x74\x80\xbd\x25\x71\xcd\xa7\x3a\x42\xcb\xd7\xa6\x6b\xba\xe6\x47\xab\x26\xbd\xbc\x36\x41\xb2\x8d\x8c\x1a\xa7\xbb\x2f\x1c\xb1\xe9\x0b\x4e\xc9\xee\xb2\xe0\x34\xc1\x50\x7f\x4a\x5a\xfd\x8b\x26\xdb\x7e\x63\x5d\x72\x8a\x0e\x6e\x67\x50\x7c\x84\x74\x4a\x2d\x44\x97\x32\xa6\x61\xc3\x46\xdb\x87\x37\x64\x3e\x0d\xb5\x45\xc4\xc4\x84\x8e\xf6\xc4\xd8\xcc\x05\x0a\x70\xd6\x70\x30\x80\xaa\x41\x21\x93\x3b\xeb\x79\x7f\xbb\x4c\x19\xc7\xc4\xad\xde\x5f\x22\x72\x7a\x94\x2e\x1d\xdc\xaf\x7c\xd4\xb8\x1d\x4e\xef\x99\xae\xb2\xfb\x89\xa3\xe7\x6e\x5c\xb1\x78\xae\xf7\xc6\x5c\x99\x9c\x2b\x37\x5d\x31\xaa\xb8\x5b\x49\x9b\xf1\x1d\x3a\x0e\x98\x35\x26\xf4\xd5\x93\x77\xae\x9f\xff\x44\x71\xbf\xab\xbc\x19\xc6\x81\x52\x13\x21\xde\x33\xb6\x1a\xf6\x22\x5d\xc5\x00\x31\xc5\xed\x16\x49\xef\x79\x84\x08\x0a\xea\xf3\x9e\x27\x20\x28\xb2\xe0\x3d\x4f\x7c\x7c\x6c\x64\x44\x90\x33\x68\x74\xd0\xf4\xa0\x45\x41\xf6\x10\x11\x29\x19\x00\x91\x41\x91\xb9\x1d\x3b\xa6\xbd\xa7\xfe\x49\x42\xcb\xc8\x96\x5a\x90\xbd\x65\x6e\x6e\xf3\xf7\x3c\x8c\x7a\xbf\x23\xe6\x18\xc0\x13\xe5\x8a\x9a\x8d\x73\x8c\x47\xc6\x42\xac\x32\x27\x8d\x63\x44\xbe\x4c\xb5\x06\x44\xb4\x9a\xfb\x1a\xc9\x9c\xbc\x1c\xdd\x3f\x1a\xa2\x4d\xa7\x83\xad\xdb\xbc\x04\xd5\x54\x53\xf3\x24\x24\x44\x33\x7d\x07\xa8\x89\x40\xed\x5e\xd4\x44\x10\xad\x3b\x67\xd9\x43\x02\x72\x36\xf6\x29\x2e\xb9\xe5\xec\x9c\xfc\x6e\xf6\xfc\xeb\x5e\xe8\xd4\x38\x3e\xaa\xcb\x92\xb2\x2d\x37\xac\xf8\xe1\x70\xd5\x5d\xb7\x8c\x38\x3c\x37\x77\x75\x4d\xd5\xab\xc7\x6f\xf8\x42\x66\xdf\x7b\xe4\xcd\x15\x6f\x8c\x2f\xee\xb9\x65\x42\xe7\x96\xe5\xa3\xa7\x4e\x9c\xd2\x20\xa1\xe5\xb0\xca\x39\x33\xef\x96\xf3\x3e\x29\xea\x13\xbd\xd9\x6b\xdf\x31\xaf\x61\xfd\xb0\x63\x72\xee\xaa\xc3\xef\x56\x7b\x9f\xf3\x7a\xf6\xbc\x7a\xaa\xb0\xb4\x7c\xfc\x50\xd9\xf0\xf7\x67\xe5\x59\x39\xe1\x59\xef\x1f\x5f\x1d\xf4\x76\x39\xaf\xcb\x49\x2f\x7a\x8f\xcc\x9b\x5a\xb2\x47\x76\x54\x63\xcf\xb7\x99\xd8\x57\x30\xaf\x3a\xd8\x01\xd5\x73\x87\x86\xe8\xe5\x9e\x90\x90\xc0\x00\x72\x3d\xda\xd8\xe8\xb5\x57\xfe\x37\x65\xcd\xd4\x93\x65\x32\xa1\xe4\x22\xc3\x56\xe1\x3d\xd6\xd0\xdb\x6e\x9b\xf7\x23\xed\x69\x59\xfa\x46\x64\xa7\xb7\x64\xdf\x94\x10\xd9\xdb\xfb\x98\xbd\xe0\xb1\xa6\x2b\xbd\xbd\xe5\xfc\x97\xd4\x1c\xcb\xa6\xd0\xb6\x0f\xdd\x91\xcc\x36\xa9\xac\x93\x4d\x83\xe2\x92\xe2\x92\xca\x3d\xf7\xc5\x3d\x1e\xa7\x75\x8e\x93\xb6\x66\x71\x52\x8f\x88\x93\x21\x01\x71\x71\x52\xd3\x62\xcb\x3d\x9c\xf3\x9c\xe5\x1e\xa6\xf2\xcb\x76\x84\xa3\xf9\x9f\x7f\xc7\xd1\x54\xca\x64\x33\xb1\xcc\x3d\x45\x4c\x6e\x26\xe7\xf8\xd6\x79\x6d\x75\xb5\xfb\xd0\x93\xd5\xca\x33\xbe\xf6\x90\x0c\xd0\xc2\x1e\x7f\xe1\xfe\x3b\xd6\x6d\xec\xb9\xfe\xf5\x1d\x6b\xde\xea\xfc\xce\x6e\x97\xbd\xe1\xb0\xa1\x7f\xf6\x94\xb2\xff\xe4\xf6\xf6\x82\xa5\xd7\xde\xf4\x6a\x72\xe4\xd2\xa9\x45\x0f\x2c\xeb\xae\xff\x31\xd3\xfb\xf4\x8e\x86\xb5\xa7\xba\x16\x7a\x57\x75\xac\x62\x10\x0d\x62\x4e\x7d\x9d\x31\x91\xc0\xce\x22\x21\x3c\x76\xb4\x27\x32\x4a\x46\x85\xdb\x84\x4d\x32\xb7\x38\x1c\xda\x68\x8f\x23\xe6\xd2\x48\xc8\xcf\x19\xa9\x26\x98\x48\x60\xd8\xb5\x64\x63\x4b\x14\x9d\xec\x8a\x31\xd7\x47\x4d\x5e\xfb\xd6\xee\xf9\xd2\x71\xcc\xbb\xf4\xec\x57\xf5\x56\x6a\x6d\xe5\x9c\x16\xde\x53\x41\x23\xfa\xce\xba\x7b\x8c\x3c\xeb\xfd\xf6\xe7\x5c\x6f\xe9\x37\x5f\x4c\x99\xaf\xed\xf5\x5e\xd3\x75\x72\xd5\x7d\xde\x07\xc9\xf5\x24\xb8\x7b\x08\xee\x82\xd8\x70\x27\xb8\x43\xb5\xf0\xd1\x8a\x9c\x88\xd1\x97\xc8\x31\x99\x60\x6a\xd6\x02\x6c\xd2\x70\x3d\xc7\x15\xd3\x56\x3e\xeb\x1d\xce\x54\x7d\xa5\x96\x32\xe5\x59\xef\x39\x19\xbf\x7e\x7d\xa7\x07\xc7\xcb\xfc\x61\xd1\xf6\x02\x6f\xee\x56\xef\xd6\x3f\x16\xeb\xc5\x6b\x17\x5f\x58\x2a\x5f\x1e\x69\xec\x03\x55\x8c\xbe\xc5\x4e\x88\xe8\xb7\xcf\x1e\x38\xda\x63\x3f\xe0\x3b\xe1\x6e\x1a\xae\xf5\xfb\xce\x2e\x8f\xdb\xe5\x15\x76\xd9\xcc\x7e\xaf\xfd\x90\x5d\xd7\x23\xec\x04\xca\xce\xf4\x24\x6d\xa0\xd0\x45\xd0\x68\x8f\xf8\x9b\x40\xf1\x63\x1c\xce\xa5\xda\xbc\x98\xe2\x92\x01\xfa\x4b\x59\xb5\xa3\xf3\xb5\x8a\xac\xda\x6d\xdd\xb4\x57\xb2\xec\x4c\x3e\x87\x4f\x7b\xef\x3b\x6d\x60\xe8\x0c\x86\xef\x0c\x5f\x93\xdd\x51\x86\x76\x69\x77\x38\x04\x14\xeb\x01\xf6\x68\xb5\x85\xf3\x2f\xbf\xc6\xee\xcd\x61\xe6\xa2\x96\xdf\x47\x9b\x9a\x55\xbb\x7e\xac\xf7\x23\xf4\xdf\x97\x65\x2b\xf7\x2e\x3e\xed\xd5\x51\xad\x74\x0e\x26\x7e\xbb\x89\x5f\x23\xf6\xf5\x0d\x1b\xd4\x2f\xf7\x34\x68\x20\x02\x03\x61\x91\x0d\x77\xa8\x16\x6a\x0f\x0d\xb4\x09\xa2\xaa\x8e\x33\x97\x6d\x74\xfc\x7b\x9c\x68\x63\x02\x4b\xb0\x9b\xc7\x0e\x42\xdb\x36\x5f\x6d\x30\x74\x9b\x16\xfe\xe1\xc9\xa9\xfb\xa4\xb6\xe7\x91\x23\xd1\xde\xd3\x91\x4b\x67\xdd\x36\xe6\x95\xbc\x85\x4d\x5b\x78\xbf\x6d\xa6\xb9\xa6\x78\xcf\xc6\x9e\x3f\xb3\x4b\x2e\xf8\xe5\x9a\x03\x4f\xb5\x7d\x7e\x97\x77\xfb\x6a\xef\x2f\x99\xce\xaf\x8f\xd5\xbe\x7d\x54\xe1\x4a\xc6\xd7\x13\x06\xdf\x79\xee\x54\x87\x56\xe6\x39\xee\x90\xfa\xeb\x0e\x69\xdb\xe2\x90\x23\x1c\xd2\x91\x14\xd6\xab\xbe\xa3\xa9\x43\xfd\x97\x3f\xe1\xfc\xe2\x20\x1c\x99\x39\xd2\x18\x04\xd6\x19\x0d\xff\xd5\x2e\x56\x6a\x8f\xcc\xf0\x6e\x9c\xa1\x08\x90\x19\x13\xe4\xe4\x09\x32\xc3\xfb\xa7\xd6\xb9\xf6\x19\x7b\x41\xed\x37\x5a\xcc\x9f\x8f\x9b\x67\x9c\x5c\x6c\xbe\x6e\xd8\x6c\xec\x8e\x0e\xb2\x05\x3a\x88\xb3\x23\x3a\x58\x0f\x11\x21\x30\xa0\x9b\x69\x6c\x1d\x39\xd4\x06\xd9\x8a\x5c\x9e\xb2\xd0\x41\xdf\x90\xe5\x7d\xee\x41\xd9\x31\xeb\xc2\x94\x2c\xd9\xf1\x41\xef\x73\x10\x7c\x61\xe9\xe9\xd3\xfa\x02\x43\x77\x6f\x78\xde\x82\xee\x18\x91\xe2\x8e\x8a\x0a\x8d\x14\x91\x61\x8c\x15\x23\x3b\xec\xc6\x59\xf1\x62\x7e\x58\xdb\x26\x75\x56\x30\xe6\xc8\x18\x45\x26\xa9\xfb\xe2\x93\x4f\x71\x6c\xed\x92\xdf\x6b\x6a\xdc\x32\xef\x3b\xcd\xb5\x41\x0f\x65\x7a\x3f\x89\x7d\xf5\x71\x57\x66\xcc\xc4\xe9\xb3\xa7\x69\x77\xd7\x5c\x98\x77\xec\x77\x65\xcb\x29\x84\x7d\xa8\xe1\x47\x92\x3b\x42\x93\x8e\x60\x5b\x50\x60\x80\x5d\x0f\xb1\x99\x3c\xb5\x6e\xad\x5e\xf9\x25\x60\x27\x59\x77\x18\x14\xc9\xe4\x20\xa9\x07\x7e\x70\x6b\xb1\xc9\x50\x95\xd6\x44\x0e\xad\x7d\x4e\xf6\xd2\x9a\xdf\xe8\x2d\x87\xa3\x7b\xb4\xa1\xb5\x4f\x5c\xf0\x2a\xdd\x9c\x9e\x6d\x69\xe8\xb6\xab\x73\xba\x46\x7a\xeb\x97\xd2\x3b\xc7\x48\x67\x28\x99\xa4\xb4\x1c\xd3\x26\x92\xbf\xe7\x77\x18\xb9\xeb\xfb\x13\x4c\x0e\xfa\x35\x10\x4e\x77\x78\x5c\xa0\x2d\x24\x24\x32\x30\xb0\x5e\xa4\x1e\x7e\x31\x74\xd1\xed\x39\xdd\xe7\xa8\xb8\x75\x96\x79\x9a\x43\x4f\xd5\xd3\x33\x02\x28\x38\x79\x24\xc4\x3a\x14\x0f\x52\x4f\xbd\x27\xb8\x75\xf8\x94\xe4\x0f\x8e\xa5\x3a\xf4\x86\x91\xf7\x1c\xc7\xce\xf0\x74\x2d\x28\x27\xe5\x4b\x39\xc0\xfb\xa7\x5e\x91\xf3\x72\x2b\xef\xf7\x05\xde\x2c\xf9\x6e\xc5\x0f\xc7\x8b\x2f\x6c\x63\x30\x87\x65\x67\xae\xd9\x58\x2c\x7f\x36\x82\x2c\x8d\xf9\xe2\x94\x71\x8e\x05\x47\x88\x2d\x2c\x34\x50\x3a\xf4\x70\xf5\x2e\xd4\xa4\xc6\xe0\x26\xa7\xbd\x49\x4e\x80\x41\x4f\x8c\x61\x5b\x5b\x7a\x38\x34\x3a\x78\xb1\xd7\x87\xcd\xe2\x23\xd1\xf5\xaf\x95\x12\x8b\x3f\xae\xda\x9d\x5b\x3b\x03\x37\x7f\xfa\x6e\xa1\xb6\xd3\xb0\xa1\x19\xb1\x3e\xc8\x98\x8a\x60\xa7\xc0\x9c\x14\x18\x3d\xda\xc3\x28\xaa\x77\x69\x14\x5d\x3a\x1e\x98\x6b\x7f\xb0\x34\x36\xc3\xe6\xba\xc7\xa1\xfd\xcf\xf7\x3e\x9e\xb0\x4f\xca\xdb\xdf\xfd\x64\xe2\x7e\x9f\xf8\xe9\xe1\xc9\x5b\x47\xef\x9d\xb4\xad\x2c\xb6\xe6\xcc\x6e\x79\x8d\xf0\x2d\x3b\x79\x6a\xb7\x77\xa9\xb7\x76\xb9\xbe\xf6\xd7\x87\xbd\xdb\x56\x79\xf7\xcb\x71\xca\x2e\x71\xb7\xbd\xaa\xfe\x4d\x32\x27\x3e\x35\x43\x44\xab\x19\x42\xb3\xd9\xa2\x46\x7b\xd8\x0f\x69\x97\xcf\x10\xa9\xca\xb9\x8b\x07\x12\x6b\x71\xd0\x26\x3e\x3f\xd2\xc8\x82\x13\x9f\xd5\x78\x6e\xfb\x7c\x4f\xe5\xcc\x2d\xc5\x3b\xbd\x4d\x03\xe4\x71\x6f\x63\x7b\xc1\xee\x1d\x93\xde\xdb\x38\x50\xfe\x30\xa0\xbb\x77\xf4\x07\x49\x86\xaf\xde\xa9\x86\xaf\xf5\x44\x63\x91\xee\x8e\x8d\x4e\x1c\xed\x89\xb6\x85\x24\x97\x7b\x44\x48\x4c\x40\x60\x20\xcb\x64\xa0\xb9\x7f\x20\x3d\xfc\x7b\xd4\x24\x69\xbd\x80\x4b\xcf\x68\x1c\x55\x87\x84\xba\x1c\x68\xb7\x47\x4c\x9e\x92\x55\x9c\xb1\xfc\xaa\x3b\xf6\xd5\xf3\xbe\x3d\xe1\x11\x29\x76\xbf\xfb\xc9\xd2\x6f\xba\xfb\xc9\x18\x35\x22\xec\x95\x86\x07\xde\x75\xcb\x85\x77\xca\xab\x85\x6f\xf9\xc9\x53\x4f\x7a\x3d\xde\x0b\x7a\x51\x1d\x4a\xc0\xa7\xe6\xed\x4f\xe1\x24\x02\x84\xb9\xee\xc4\x70\xa9\xc5\xb1\x26\x89\x38\x19\xc1\x81\x4e\xd8\xed\xcc\x6d\x76\xb6\x9b\x17\x47\xc6\xa5\x29\xda\x1a\xe5\xc9\x7a\x1d\x9e\x1c\x31\xba\x9f\x29\x3d\xfe\xc9\x07\x2a\x0c\xa6\xbe\x3d\x7b\xba\xf9\xa8\xd5\xc5\xe7\xf6\xcd\x99\xb6\xa7\x57\xf5\x85\x34\x4d\xaf\xad\xb5\x17\xdc\xb6\xb1\x70\xf3\xc2\x91\xf1\xb5\x8f\xeb\x1f\xf4\xed\xe4\x5d\xa9\xfe\xb6\x9f\x8d\xbc\x78\x16\xae\x32\x45\x96\x3b\xc1\x15\x12\x2f\xe2\x1b\xc2\x53\x03\x19\x66\x6f\x10\x6f\x13\x8e\x72\x8f\xed\xe2\x4c\x70\x71\x9e\x35\x66\x83\xc6\x19\x69\x8a\x33\xb5\x67\xcc\x68\xa1\x19\x47\x0d\x6b\xc6\x55\x1b\xab\x24\x69\xbc\xbb\x66\x8a\xf8\xf5\x6b\xaf\x2f\x40\xa6\xd9\xe7\x2f\x1a\xbb\xa4\xfb\x33\x9f\xed\x2c\xed\xbb\xf3\xf3\xa5\x27\x8e\x49\xef\xf1\xc0\x27\x8a\x67\x74\xc8\x2e\x5e\x74\xcf\x1d\xfd\xb7\x31\x6b\xbc\xf0\x44\xda\xa8\xa9\xd9\xe5\x1d\x26\xe5\xb4\x1f\x3a\x7f\x88\xe7\xee\x6b\x0b\xf7\x1e\x6a\xb4\xbf\x79\x69\xab\x26\x6d\x33\x52\x9a\x8f\x58\x34\x60\xd9\x17\x0b\xcc\x39\xf1\x41\xc6\x6d\x73\x63\xdf\x53\xdf\x1d\xaa\xab\x17\x73\x8a\x30\x4d\x5a\xc9\x54\xe7\x4d\x41\xb2\x43\x9f\x7c\xcc\xfb\xd1\x31\xef\xa4\x2c\xdb\x20\x56\x99\xf3\x3b\x6c\xe5\xa7\x8d\x35\xe6\x4a\xfc\xfe\xd2\xf8\x5b\x0c\x64\xa5\x3d\x30\x92\xbd\x71\x74\x94\x23\x40\x17\x61\x75\x16\x96\x9c\x9c\xe8\x84\x8b\xef\x49\x98\xba\x03\x2e\x4e\x7f\xec\xd0\xe5\x57\x2f\x1e\x8a\xdf\x21\x33\x76\xc4\x74\xef\x39\x61\x7e\xea\x6d\x32\x63\x5b\x7b\xef\x7b\xb1\xf7\x3d\x52\x3a\x4d\x6f\x73\xe1\xf5\xd1\x05\x25\x3d\x36\x3f\xa2\x37\xb9\x70\xcc\x7b\xd2\xfb\xb5\x81\x7b\x27\xb8\x27\x5a\xe7\xe0\xa0\xe0\x20\x5d\xd3\x03\xa4\x19\xe3\x7c\xe3\x2b\x0d\xb5\x55\x8b\x51\xef\x83\x65\xb2\xb6\xd1\xfb\xde\x2b\x32\x77\x50\x64\x40\xaf\x1c\xb9\x50\xb6\xb2\x17\x5c\xf8\x63\xfd\x9c\x3b\xc7\xe9\x0e\x73\xbe\xb3\x5f\x89\x1e\x76\x66\xee\xc8\x48\x5b\x44\x44\xfd\x7a\x41\x81\x7a\x6c\xa8\xc3\xaf\xce\x9a\x32\xd4\x9b\x13\x92\x85\x49\x0b\x43\xea\xe5\x6d\x80\x9a\xb2\x72\x92\xa4\x23\x2e\xcf\x70\x62\xdd\xef\x11\xf6\x60\xdd\xfb\xd5\xef\x39\x52\x6f\x61\x73\xb9\x7a\xdc\xf9\x6c\x6c\x82\x1e\x98\x91\xf0\xb1\xd4\x65\xbb\x2b\x64\x50\x40\xed\x2a\xa6\xda\x5e\x83\x1f\x2b\xdd\x26\x07\x1d\x3d\x3b\xbe\x45\xe2\x9d\xbd\x35\xf5\xfb\xdf\x6a\xef\x69\xef\x62\xcc\xe7\x2d\xdc\x0d\xc3\x64\x23\xa9\xb5\xb5\x49\xcd\x11\xcd\xea\x17\xcc\x59\xc6\x9c\xdc\x61\xa9\xee\xe4\xce\xf6\x42\xe5\xae\x9a\xd9\x93\x63\x8c\xf9\xbd\xc5\x1b\xde\x19\xde\x97\xb4\x12\xef\x31\xd9\x6e\x9f\xf4\xc8\xb6\xb5\x1f\xca\x3e\xf2\x1b\x6f\x8c\xf6\xa2\xb6\xd0\x3b\x50\x3e\x58\x7b\x6d\x6d\xfb\x8b\xdc\x8d\xc7\x5e\xa0\x68\xe4\x8e\x88\xb5\x4b\xbb\x16\xc8\x5c\xc8\x14\x22\xad\xc9\xda\x30\xa0\x38\x8c\x31\x94\x4b\x6d\xad\xf7\xd8\x14\xef\x2b\xb2\xcd\x93\x72\xbb\x6c\x53\xbb\x49\xcb\xd2\xeb\xd7\xbe\xa2\xb5\xbd\x60\xbc\x43\x53\x7f\x51\xc2\xf8\x7e\x2a\x48\xad\x7d\x0e\xdd\x9f\x43\x81\x32\xd0\xda\xa6\x5d\x7c\x91\x67\x04\x26\xcf\x78\x3f\x21\x93\x6d\x41\xe7\xcf\x34\xd5\x07\xd4\x3e\xd0\x5c\xbf\xab\xc9\x85\x6a\xed\xa5\xb7\xf4\x35\x35\x47\x2f\x4c\x37\x30\x1e\xf4\x0e\xb5\xad\xe0\x8c\xe3\x50\x33\xac\xb4\xfd\xe2\x91\x80\xfe\xc5\xa3\x5e\x68\x5b\xd3\x4c\x8c\x5a\x9f\x91\x83\xb2\x52\x1b\xd6\xd8\x5b\xed\xfd\x40\x16\xa5\x7b\x87\x3a\x66\x3d\xf9\x67\xe0\x53\xc6\x3b\xe0\x68\xf2\xd2\xf1\x77\xef\x6c\xed\x92\x20\x39\x6b\x7f\x3a\xad\x45\x99\x2f\x6d\xa5\xe8\x8a\xbd\x08\xbf\x3d\x87\xf6\x8b\xc7\x91\x18\xa0\xff\xe2\x09\x10\x97\xec\xe5\x25\x2b\xe0\xb2\x6b\xba\x2c\x92\x4d\xbd\xd5\x8d\xb5\x61\xde\x35\xde\xa1\x4f\xd9\x7f\x7f\xf2\xf7\x1b\x0c\xcc\x4d\x34\xcd\x76\xb5\x7d\x09\xe7\xd0\x78\x77\x50\x00\x01\x13\x76\x69\x3b\xae\xbe\xb7\xca\xc9\x26\x70\x6a\x20\x49\xb5\xdc\xe9\x1b\xf7\x79\x9b\x9d\xd2\xda\xc8\xae\x1f\x6b\x9a\xf6\x7d\x6d\xa4\xbe\xe8\xc2\x12\x78\x9c\xe0\x6b\x6c\x2b\xf2\x2d\xb3\xde\x59\x1f\xb4\xde\x59\x3b\x20\xeb\x96\x18\xdb\xfb\x31\xc7\xcb\xca\x8c\x31\xab\xd9\x6d\x3b\xf5\xe3\xf6\x87\x59\xa3\x43\xf6\x09\x6d\xb5\xf5\xce\x5a\xa6\xe5\x25\x27\x38\xf4\x2c\xef\x47\x81\x52\x3b\x1a\x60\xdb\x59\x93\xf9\x93\xd3\x98\x23\x73\xe0\xa1\xd8\xd6\x5f\x34\x17\xed\x44\x67\x77\x4a\x7a\x52\xb1\x27\x3d\x3e\xb0\x45\xb1\xa7\x99\x08\x94\x21\x7a\x60\x64\x60\xa4\x88\x89\x09\x2b\xf6\xc4\x44\x8a\x36\x45\x1e\x56\x97\x4b\xbb\x59\xeb\x30\xd8\xbe\xee\xb2\x96\x17\x9d\x96\x2f\xdb\xb6\xc9\x35\x8e\xb7\xd1\xc6\xd4\xe9\xb0\xc6\x73\x9e\x23\x5c\x57\x87\xc3\x3c\x0e\x89\xd2\x11\x6e\x4e\xf6\x79\xb2\xf7\x8a\x75\x41\xdd\xe5\xae\x13\xc1\xc1\xb3\x7a\x0c\xae\xef\xfd\x74\xa6\xdc\xf0\xc0\x23\x21\x7d\x43\x9c\xe9\x2e\x67\xa3\x06\xcd\x9a\xb6\x48\x1a\x3d\x58\x0b\x18\xf2\x98\x6c\xb6\xe2\xca\x8a\xec\xb2\x31\x3b\xe3\x63\xe7\xcf\xce\x68\x2e\x4b\xec\xb6\xbc\x96\x8d\x17\xf4\x2c\x0e\x97\x5d\xd6\xad\x69\xd1\xc1\x3b\x37\x2f\x29\x2d\x3d\x60\x4b\x40\x70\x80\x6d\x50\x71\xd3\x99\x15\x5a\x90\xa6\xe5\xce\xec\x30\xe6\xb6\x99\xf8\x99\x8a\x9f\xd7\x12\xc3\xfa\xea\xaf\x7a\xba\xe3\x02\xe2\x82\xa3\xa3\x1b\x15\x79\xa2\xe3\x83\x53\x8b\x3c\xc1\x91\x2c\x02\x4c\x51\xf9\x6a\x5e\xab\xb3\x17\xcb\xc9\x57\xa7\x72\x47\x8e\xf5\xf6\x4a\x33\x0e\xb7\x19\xc0\x77\xc4\xf8\x8f\xb4\xca\xcf\x80\xd4\x04\xe7\x8f\xb2\x7e\xdf\x34\xad\xc3\x81\x19\xeb\xb7\x0c\x58\x7b\x64\xfa\x95\xab\xea\xdb\x82\x92\x1d\x13\x06\xf5\x2a\xb9\xb6\xef\xc6\xb1\x1b\x53\x22\xcb\x56\xdb\x4e\x78\x67\x3f\x3c\xbc\xe2\xd0\x03\xcb\xbd\xc7\x8e\xcf\x1a\x37\xba\xe5\xcc\x08\x79\xd3\xa4\x79\x37\xc9\xe8\x59\xaf\x3f\x7d\xff\x20\x73\xce\x1d\x09\xce\x2a\xe2\x91\xa4\xce\x54\x81\x51\x45\x9e\x88\x30\x19\x46\x0c\x1a\xc8\x70\x7b\x03\x21\x12\xac\x10\xfc\xe5\x4c\x65\x6e\xc5\x0d\x90\x8d\xa4\x3d\xcf\xff\x25\x80\x62\xd7\x1e\xae\x69\xfa\x6b\xc7\x46\xdc\xf7\xff\x51\xf6\x1e\x70\x51\x1d\xdb\xe3\xf8\x9d\x5b\xb6\xf7\x0a\xbb\x0b\xec\x02\xcb\x82\xf4\x2e\xa2\xb2\x16\x14\x45\x11\xb0\x5e\x11\x11\x54\x2c\xd8\x5b\x12\xbb\x31\xf6\x88\x3d\xd6\xd8\x4d\x2c\xb1\xc6\x9e\x84\x18\x35\x89\x89\x2d\xa6\xf7\x98\xa8\x31\xc5\xc4\x24\xa6\xaa\x3b\xfc\x67\xe6\xde\x2d\xa0\xef\xfb\xf9\xfd\xe5\xc1\x23\xcb\xdc\x99\x73\xcf\x9c\x39\x6d\x4e\xf9\x75\x59\xc3\x47\xf0\x3b\xd0\xa5\xdf\xa0\xa7\x4b\x5f\x28\x9d\xe3\x04\xd6\x98\xed\xb7\x4c\x57\xce\xcc\x03\xf6\x8b\x23\x1a\x5e\xe0\x34\xc6\x4e\x95\x0b\xe0\xaf\x13\x3f\x1a\x3a\x44\x3d\xfa\x40\x35\xa1\x8d\xee\x08\x96\xdf\x10\xce\x6c\x54\x02\xe5\xf1\x9a\x6c\x66\xab\x85\xd2\x45\x96\xf2\xac\x51\xa6\xd3\xc9\x62\x4b\x79\x99\x48\x0d\x86\x3c\x42\x03\x99\x05\x88\xed\x64\x67\xe5\xe4\x06\xbc\x00\x04\x26\x6b\x26\xe1\xe9\x52\x26\x08\x18\xd2\xf2\x72\xe8\x0b\x1a\x8e\xed\xb8\x7f\xfc\xb2\xf5\xe5\x4b\x5e\x9b\x38\xea\x59\x0b\xed\xec\x0e\xc2\xff\x50\xd9\x76\xf4\x2a\xea\xf7\x74\xf1\xaa\xb6\x13\xfb\x58\x75\x32\xcb\x14\xc7\x90\x41\x6f\x1c\x7a\x1a\x24\xbd\x3f\x76\x48\xc5\x11\xb0\xf4\x81\x33\xff\x30\x7d\x6c\xe4\x98\x15\xf0\x87\x91\x57\xf8\x17\x9e\x20\x78\xa3\x89\x2d\x83\xf1\x66\xa3\xa2\xa9\x1c\x6f\x54\xa4\xb6\x8c\xc7\x37\x2a\xb4\x8e\x89\x8c\x44\x46\x8d\xbd\x8c\x47\x48\x34\x95\xf2\x16\x2b\xb0\x62\x0c\x66\x34\xf3\xeb\x35\x45\xa3\xd9\xa4\x05\x2e\xbf\x14\xe2\x24\xac\x11\xed\xb2\x0b\x21\x96\xe6\xae\x7e\xd7\xfb\xd0\xbf\x2b\xdf\xbc\x64\x02\xbe\x68\x45\x6d\x45\xf7\x19\x51\x80\xed\x09\x6f\x4a\x87\xad\x71\x80\x4b\x6c\xad\xe9\xda\xf9\x99\xc0\xf8\xfe\xc8\x4f\xdf\xe9\x57\x2b\xcb\x48\xaf\x1b\xdf\xce\x6b\x5d\xba\x9e\x39\xbc\x64\x5a\x5e\xed\x30\xc2\xbb\xd0\xc1\xb7\x71\x3f\x21\x62\x8b\xf6\x1a\x14\xda\x52\x5e\xa5\x00\x58\xb2\x96\xf2\x46\x0e\x57\xe9\x2a\x10\x6e\xbd\xb0\xc6\x14\x10\xae\xb9\x18\x26\xab\x14\x63\x4f\x8b\x8d\xba\x6b\xfb\xe1\x0f\xfb\x1b\x29\x37\xa0\x74\xd1\x0f\x2f\x6d\xdd\x1e\xbb\x6a\xd6\xe0\xd1\x46\x25\x78\xc5\xcd\x4c\x7f\xf8\x0c\x33\xbd\xa1\xe7\xfe\x43\x8e\x93\xc6\x9e\x83\xf3\x1a\x08\x6e\x62\x61\x09\x7b\x8e\x2d\x46\x98\x49\xa5\xb2\xbd\xf6\x08\xad\xc2\xa6\xb1\x58\xe2\x10\x32\x74\x2c\xab\xa1\x34\x49\xa5\xbc\x86\x92\x96\xf1\x94\x43\xf4\x03\x0a\x58\xf1\x1f\x72\x7c\xd9\x88\x1d\x9e\x58\x0d\x31\x3e\xb2\xb7\x39\xb9\x2e\x2d\x60\xb0\x47\x37\x64\x77\xc1\xbe\xd3\x17\x69\xe0\xa4\x7b\xb4\xbb\x94\x17\x4b\x17\xbe\x5e\xb7\x74\x6d\x8f\x25\xaf\x4f\xaa\x5b\x62\xe5\xd0\x68\x85\x35\x6a\x53\x32\xfc\xf0\x54\x79\xd7\xbe\x4f\x77\x59\xd7\x77\x41\x11\x2c\x59\xbf\xd8\xd5\xae\x1b\x70\x1e\x18\x31\xf0\xc8\x9e\x39\x20\xee\xda\xa8\x21\x15\x4b\x62\x86\xae\x79\xf8\xed\xad\x5f\xd9\xda\xc1\x13\x9f\x85\xbe\x21\x17\x96\xfc\x85\xf0\x17\x87\xeb\xde\x10\x9a\x74\x79\x75\x16\x33\x45\x31\x26\xa3\x5c\x66\x66\xb4\xe5\x3c\xa3\x0b\xaa\x13\x79\x98\x95\x03\x04\x22\xb2\xfd\x91\x22\x6f\xcc\x11\x3d\x6e\xc4\xe4\x41\x58\x04\x37\xca\xce\x3e\x01\xb4\xba\x79\xf0\x87\xa7\xb4\xad\xbb\xd5\x6e\x8a\x18\x0f\x6f\x03\x27\x08\x2f\x51\x3b\xe4\x4c\xcd\xf4\x71\xf0\xaf\xc2\x52\x5f\x39\x3d\xba\x7b\x66\x61\x97\xfd\x4b\x7c\xaf\x71\x97\x60\x5d\xe7\x91\xb1\x04\x9f\x6a\x04\x43\x2e\x82\x41\x8e\x7e\x73\x7b\x4d\x4a\x45\xcf\x0a\x25\x25\x97\x94\xf2\x72\x2d\xc5\x31\x5c\x29\xcf\x98\x03\x82\x4d\x60\x8d\x6e\xd1\x54\xcc\x75\x79\x10\xc7\xa6\x3f\x06\xd5\xee\x07\x0f\xdc\x60\xc9\x42\xf8\xb5\x9b\xce\xbf\x17\x0f\xc2\xe3\x1b\x1a\x1a\xe8\x86\x86\x73\x57\x49\x71\x28\xba\xf1\x2c\x92\x39\x56\xb4\x86\x1e\x51\x4a\x0b\xaf\x45\xae\xb1\x1a\x0d\x3d\x2b\x8c\x94\x5a\x51\xca\xab\xb5\x94\x04\xbd\x2e\x96\x77\x82\xe9\x48\x05\x24\xa8\x11\x6d\x54\x6e\xd0\x74\xd4\xd0\xf8\x56\xf3\xb3\x1e\xcf\x27\x26\x3c\x3d\x73\xec\x38\xf3\x3e\xb8\xd9\x4d\x4f\xff\x28\x7c\xed\x4d\x30\x05\x2f\x0a\xfb\xda\xf4\xef\x47\x8f\x1a\xc5\x4c\x68\x78\x70\x6a\xce\xe9\x6a\xc9\x0b\xc2\xfa\x80\xea\x88\xde\xf1\x1b\xb4\xbe\x12\xd9\x4a\x3a\xb9\x4c\xab\x90\x22\x6b\x02\x59\x4a\xd8\x90\x34\x8b\xba\x86\x95\x60\x39\xd4\x90\xa4\xff\x39\xbb\xa8\x87\x80\xc8\x5d\xe0\x33\x90\x02\x33\x40\x38\xf8\xa9\x17\x1c\xc9\x5d\x7a\x78\x00\x9c\x81\xfd\x7d\xa3\xd0\xdc\x41\xfc\xd9\xbd\x1a\x82\x37\xea\x11\xbc\x85\xe2\x2c\x88\xaf\x4f\xe0\xd7\xb1\x74\x3e\x42\x15\x5b\xda\x40\xe0\xc4\x7d\x77\xd9\x57\xd0\xb9\x4f\xa7\xd2\xbd\x36\x67\x72\x19\xef\xd4\x39\x4c\x54\x58\x98\xa4\x8c\x0f\xd3\x19\xf4\xda\x74\x4f\x9c\x52\x21\x42\x9c\x91\xe1\x37\x82\xf2\x44\x87\x79\x80\x2c\x62\x8c\x6d\x99\xec\x4c\x2d\xc8\x14\xb9\xa8\x9f\xe5\xe3\xbf\x04\x06\x81\x67\x67\x5b\x23\x22\x33\x06\x45\x8e\xbf\xb5\x4b\xaa\x56\xca\xae\x19\xe5\x74\xde\xd4\xe2\x7e\x1d\xe9\x36\x73\x7a\xf5\x2b\xb5\x3c\x7b\x13\xff\x3d\xb3\x7f\xd4\x64\x7a\xe5\x8c\xac\xb4\xf8\x57\x36\xf8\x4e\x33\x3d\xa3\x8b\x3b\xa4\x49\x67\xa5\xd5\xf5\xab\xaa\x92\x8c\xec\x3f\x60\x48\xf1\x04\x5f\xaa\xf0\xf7\x6d\xdb\x7c\x2f\x52\x7e\x9a\x66\x7b\x20\x9a\x76\x78\x35\x06\xca\x6c\x46\xbb\x6b\xd6\x69\xb4\x02\xdc\x05\x05\xa2\x53\x2f\x94\x8a\x91\x5d\xea\x32\x49\xa4\x99\x39\x02\x81\xd3\x57\x9f\xd4\x7a\x0b\x87\x6e\xc1\x54\xbc\xc3\x25\x01\xc8\x5a\x65\xd7\xff\x06\xb4\xda\xf9\x74\x5d\xd7\xec\xe2\xce\xfb\x96\xfa\x5e\x65\x8a\x5e\xe8\xa6\x5b\x91\x73\x07\xde\x6d\x57\x82\x5b\x1a\xd3\x54\x37\xc4\x33\x9f\x41\xb8\x53\xa3\x95\xb1\x66\x83\xa4\x8d\x54\x17\x10\x31\x21\x42\xdd\x10\x4b\x96\xa1\xa9\x90\x43\x8e\x4c\xd5\xbf\xde\xfb\x6c\x0b\x88\xbe\x00\x0e\x1a\xb3\xe0\xf1\x51\xe5\x7c\xdd\xc2\xd2\x17\x46\x2f\x2e\x33\xbd\x77\xee\x24\x18\x74\x02\xce\xe9\x36\x14\xde\x83\x5f\xd0\xdf\x0c\xad\x9c\x0b\xbf\x9b\x70\x65\x3e\xf0\x08\xb4\xfd\x29\xa2\xed\xd9\xe8\x7d\xc3\x28\x37\x96\x2b\x61\x5a\x93\x5d\xcf\x68\xa4\x1a\x07\xe2\x43\x16\x69\x34\x81\x22\x54\xcb\x20\xe1\x0e\x68\x2f\x02\x72\x98\x98\x8f\x31\x02\x1a\x42\x25\x31\x4d\x73\x46\xd6\x7b\x7c\x54\xfd\x86\x45\xbf\xac\x1d\xb9\x24\x9c\x76\x96\xc3\xdb\xff\x20\x89\x52\xde\xb5\xdf\x9c\x6e\xab\xca\xea\x7b\xb0\xad\x64\xed\x6b\x07\x0e\x3b\x7b\xe4\x18\x7c\xf6\xad\xea\x81\x47\xe0\x40\xf6\x9f\xfc\xc3\xbe\x6e\x23\x26\x2c\x07\xfa\x89\xef\xad\x82\xf7\x31\x5e\x10\x7c\x7b\x11\x7c\x58\x57\x40\xe7\x1b\xeb\x09\x66\x89\xc2\xa0\x23\xaa\x82\x85\x65\xec\xc8\xa2\xf4\xab\x0a\x58\xf4\x21\xe8\xb4\x98\x55\x3f\xc2\x1b\x91\x98\x63\x42\xa5\x71\x0e\xbb\xd7\x1a\xf5\x0f\xbc\x5d\x1e\x8b\x35\x85\xd5\xcf\x75\x5b\x7e\x76\xec\x88\xf9\x11\x2c\xe7\x96\x0e\xeb\x55\xd4\x7b\x6e\xf1\x9a\x9a\x35\x31\x3a\xb6\x55\xd5\xd2\x07\x72\xb0\x1d\xeb\x0a\x2f\x3d\x0d\xdc\xdf\x3c\x31\x74\x90\x7d\xa1\x1a\x4e\xa8\x7b\x12\x09\xbd\x31\x97\x1b\x0e\x8a\xba\xc2\x0a\x44\x37\x3b\xd0\xfe\x59\xa8\x48\x64\x9f\x48\x2c\x55\xf4\x58\xa4\x33\x9a\x74\x4a\xad\x54\x62\xc6\x36\x5a\xc1\xe5\x4a\xc4\x0a\x71\x24\x8c\x9f\x6a\xb2\x3d\x2e\x8b\x1f\x93\x56\x76\x72\xdd\xd0\x8d\xdf\xc7\xf5\x86\x3f\x2c\x0c\x67\x80\x56\xc2\xb2\xdd\xce\xce\x1f\x59\xcd\x94\x1a\x7f\x3a\x07\xbb\xd2\xaf\x2d\x5c\x3f\xa0\x24\x3d\x37\x65\xe1\x38\xbd\xc8\x13\x10\xbd\x8c\x42\x78\x49\x42\xd6\x74\xa4\xc2\x49\x59\x2c\x08\x33\x5a\x5b\x94\x8d\x56\xb0\x36\x8b\x8e\x92\x96\xf2\x26\x36\x96\xa5\xd9\xa0\x80\x6d\x6a\xcb\x8a\x42\x24\xa7\x00\x64\xc5\x09\xc6\x2c\xc1\x93\x34\x4b\x10\x6d\x26\x4b\x14\x20\x91\x58\x00\x34\x5e\x7f\x5f\x4e\x35\x72\x15\xb3\x9f\x78\x42\x45\x97\xf0\x6f\x3f\x57\x3a\xfb\xd7\xed\x67\x2f\xd3\xb0\xe7\x90\x21\x63\x54\x74\xe7\x6e\x75\xcf\x3e\xd3\x69\xa1\xcf\x54\xbf\xda\xdd\xdd\xdb\xda\x6b\x8d\xcf\x32\x26\xb4\xaf\x2d\x1e\x7f\xaa\xfa\xb9\x7a\x5b\x61\xdb\xcc\xd6\xe6\xd8\x34\xad\x2d\xb2\xe3\xd0\xae\x4f\xbc\x32\x04\xc3\x7e\xab\xf1\x1e\x5b\xc4\xf5\x42\x22\x2e\xd6\x6b\x30\x58\xad\x48\xf2\x5a\x2d\x88\x61\x81\x52\x5e\xc2\xd2\x68\x3f\xaf\x64\x06\x4d\x11\xec\x20\xc9\xcd\xc4\x61\x6e\x52\x57\x33\xe5\x35\x2b\x07\x3c\xfb\xa2\xfb\xd8\xb2\x43\xb9\x60\x8e\x1b\xce\x1a\xa6\x2c\x2a\x99\xb6\x28\xd6\x53\xdc\xa3\x6f\xe6\xf6\xdd\x0a\x24\x7b\x81\x0d\x7e\xdf\xe0\xfb\xb5\xb5\x35\x27\xd5\x7e\x5a\xa2\x92\x73\x13\xa6\x45\x74\x14\xf0\x37\x00\xe1\xef\x79\xb6\x15\xa2\x2b\xa7\x57\xa7\xa7\x4c\x26\xae\x9c\x37\x59\x34\xe6\x70\x85\x1c\x53\x14\xe6\x4f\xfe\xb3\x0e\xf0\xb2\xa2\x09\x8c\x43\x18\x90\x4e\x25\x89\x71\xea\x91\x75\x4c\xcb\xa7\xa8\xe6\x54\xac\x0b\x1f\x07\xc2\x77\x68\x2c\x0c\xfc\x53\x66\xe1\xd6\x7f\x05\xff\xd0\xce\x63\x5b\xf9\xb6\x15\x64\xed\x7d\x79\x1e\xdd\xf1\xe1\xc9\xf6\xeb\xad\x03\xa6\xfd\x0c\xf4\x1d\x8a\xe9\x83\x78\xed\x85\x88\xc5\x1a\xd0\xda\x01\x9b\x58\x2b\xc1\xe5\x42\x0b\x84\x18\xc0\xa6\x36\xf1\xf3\xf0\xd0\x9b\x20\xa1\x9f\x4c\x9b\x5f\x00\xca\x41\x1c\x9a\x77\x65\xcb\xb3\x4f\x4f\xa6\xc7\xa3\x79\x78\x34\x4f\x22\x9a\xc7\x82\xf4\x53\xb3\x96\x65\x4c\xc8\xba\xd6\x68\x2c\x66\x24\x22\x0c\xc4\x30\x36\x37\x35\x8c\x2b\x05\xcb\xd8\x83\xf6\x34\x06\x21\x54\x22\x45\x86\xb1\xd1\x62\xc6\xf6\x31\xb3\xf1\xcf\x4c\x19\x67\x85\x0f\xef\xd9\x6f\xc6\xc8\x75\x31\xbe\x37\x32\xa5\xba\xf4\x6b\xdf\x81\x4f\x6a\xb5\x99\x90\xc3\xaf\xb3\xa6\x7b\x57\xf0\x2b\xcc\xeb\x94\x58\xb2\x9a\xae\x22\xfc\xfe\x02\xf6\xc5\xa3\xf5\x89\x7f\x13\xb0\x0a\x29\x31\x81\xb5\xd8\x04\x36\x37\xf3\x6f\x86\xd8\xbf\xe0\x34\x7c\x09\x7e\x44\x33\x48\x03\x4e\xdd\x0f\xb2\x40\x3a\x0c\x03\x49\x60\x21\x7c\x92\x4e\xa5\x95\x70\x33\xa8\xf1\xfd\x8b\xbb\xc4\xa3\xf9\x3f\x86\x7d\x39\x2d\x9a\x3f\x8c\x6a\xed\x8d\x69\xd4\x83\x71\xfa\xd9\x7a\x7a\xa8\x1e\xd8\xf4\x00\xe8\x81\x82\xd1\xcb\x2d\xe1\x66\x24\xf2\x91\xa4\xef\xc9\xd3\x01\x11\x2c\x86\x4d\x92\xe0\x33\x6c\x7d\x1b\xa3\x3d\xb9\x51\x00\x53\x3a\x42\x6b\x24\x63\xce\xc5\xa6\xb2\x06\x2c\xaa\x2b\xf2\x64\x64\xf4\x9e\xd2\xd2\xfe\x1b\x42\x30\xcd\xb2\x36\xfd\x22\x60\x07\x71\xbe\xc1\x53\xbf\x80\x7d\xd5\x17\x38\xa6\x4f\x75\x1a\x9b\xea\xfb\x5d\x1e\xe3\xf2\xb1\x6e\xe0\xa6\x8d\x0f\x96\x5e\xdd\x26\xfa\xc4\x47\x23\xb8\xe4\x98\x76\x24\x34\x4b\x23\x35\x5c\x0b\xa4\xf8\xcc\x51\xe6\x50\x33\x1a\x47\xc2\x88\x46\xb4\xd4\xe5\xa1\x1b\x7c\x77\x3d\x4c\x99\xc7\xd7\x89\x1e\x1e\xff\x36\xbd\xfb\xe2\x3b\xbe\x01\xc4\xc7\xbe\x1f\xf1\xb8\x4b\x48\x06\x27\x52\xc9\x5e\x6b\x84\x4a\xa9\x52\xfe\xc5\xab\x54\x46\xca\x68\xf9\x8b\x37\x52\x54\x42\x88\x39\x1d\x72\xad\x4f\x34\x41\xec\xa3\xc1\x92\xc8\x83\xf4\xd2\x5c\x23\x3a\xc2\x2e\x29\x61\x2f\x88\x4e\xcd\xf8\xba\x49\xb0\xf7\xf2\x81\x94\x36\x4c\x99\x29\x2b\x90\xf2\xb5\x71\x4f\xcc\xb3\x14\x44\x9c\x5a\x02\x3a\xc7\xbe\x5a\x51\x6b\xca\x37\xd6\x57\x95\xf4\xe6\xf2\x65\x1d\xba\xbc\x8a\xac\xf2\xc9\x23\xa2\x13\x41\x51\x4c\x4c\xb7\x52\xe6\x1c\x37\x6e\x02\x28\x5a\xb5\xae\x61\xf8\x08\xf8\x41\xf5\x42\x23\x6b\x1a\x51\x1c\x61\x85\x1f\xb4\x88\xee\xd0\x5e\xb0\xdb\x6f\xc0\x3c\xfa\x47\x62\xb7\xcb\x8f\xe0\x6e\x0f\xa9\x58\x36\xe8\x5d\x7a\x70\x03\x48\x60\x9e\x74\xd5\xbf\xa3\x05\xbd\xe0\x21\x7a\x3f\x07\x1a\x17\x8f\xdf\x4f\xee\x74\x39\x5d\x7f\xf1\x4e\x27\x92\xad\xa6\xbf\x78\xa4\x35\x82\xff\xf5\x7e\x4c\x2e\x39\x75\xe8\xcd\xb2\x53\x40\x36\x79\xd1\x44\xa4\x43\x05\xec\x58\x2b\x8e\x28\x42\xaf\x1a\xc3\xc6\xbd\x5a\x31\xd4\x94\x6f\x58\x32\xb8\x7b\x1f\xf4\x2a\x4b\x5e\x8d\x05\x9d\xa7\xcc\x96\x17\xc8\xce\xc4\x3d\xf5\x8c\xb9\xc0\xd6\xb0\x18\xd9\xff\xc3\x46\x82\xe4\x81\x0b\x2d\xac\x61\x54\xd7\x2c\x90\x1c\x9d\xf8\x4c\xc3\x98\xba\xb8\x24\x78\x32\x3e\x6a\x13\x7b\x8e\x9e\x34\x16\x9e\x5c\xb4\x5d\xe0\x0d\x83\x10\x31\x6c\x67\x8a\xd0\x5e\x76\xf0\xa6\x52\xba\xfd\xbc\x8c\xa2\xbc\x54\x29\x35\x88\x7a\x8f\xe2\xe4\xc8\x3a\x35\x28\x95\xdc\x7e\x5e\xab\xac\x52\x1e\x54\x32\x51\xca\xb1\xca\x65\xca\x2d\xca\xd7\x95\x77\x95\x12\x25\xb9\x0c\x27\xd7\x13\x42\xbc\x8c\xa0\xaf\x13\x9e\x9f\x9b\x83\xf8\xbc\xe0\x73\xd5\x00\xa6\xb2\x78\x61\xa7\x59\xbd\x3b\xcf\x2c\x4e\x98\xbd\x65\xc4\x9c\x39\x95\x09\xf3\xe7\xb6\x28\x9a\x41\xb3\x2d\x6c\xa9\x2d\x52\x3e\xea\x95\x9a\x66\x19\xf0\x45\x12\xd2\x71\x49\x27\x1a\xf2\x4f\x27\x21\x5d\x7b\x90\x1a\x09\xff\x60\x06\xb3\xb9\xe4\xbe\xde\xe6\x55\x51\x12\x2f\x2b\xd9\x5c\xc1\x6a\x69\x66\x0b\xf1\x06\xfa\x03\x9e\x11\xcf\xc4\x24\x4f\x2b\xbe\x5f\x05\x3f\xa7\x93\xb2\xe1\xf5\x6c\x7a\xe9\xc3\xa1\x5c\x21\xfc\x03\x68\xd0\x7b\xd6\x35\x9e\x67\x77\x72\x43\xa8\x58\xaa\xd0\xeb\x36\x1a\x4c\x5e\x53\x44\x19\xcf\x87\x03\x65\x38\x08\xd7\x9b\xe4\x32\x85\x57\xda\x87\x01\x34\x03\xe4\x0c\xa3\x50\x50\x65\xbc\x22\x70\x05\x5d\x99\x89\xd6\xb8\x9c\x91\x9a\x99\x89\x83\x32\xc8\xef\x68\x41\xc1\x40\xd3\x02\x12\xe3\x8b\x34\x15\x21\xae\x17\xd9\xc1\x44\x57\xc2\x5e\x06\x0b\x5d\xd2\x6f\xa9\x0b\x84\xe7\xc0\xfb\xc7\xdd\xdb\xdd\x87\x1a\xea\x01\x38\x10\xbb\x3d\x76\xd7\x31\x78\x63\x40\x9f\xae\x4f\xf5\xcb\x18\x0a\x72\x47\x0f\x51\x6d\x7c\xc7\xfc\xfa\x6b\xfa\xb7\xf6\xef\x02\x79\x27\x0c\x27\x4f\x1a\x4f\xaf\x94\x68\x64\xfd\x06\x76\x9c\x7f\xa6\x6c\xfc\x24\x4c\x53\x3f\xa3\x33\xb8\x8b\xeb\x8f\xf4\xb5\x76\xde\x98\x48\xb9\x4a\x5e\xc6\xdb\x71\x44\x10\xa3\x52\xb1\x3a\x9d\x75\x0a\x6f\xd2\x49\xb9\x68\x36\x7a\x22\xdf\x29\x0e\xb1\x4d\x1c\x58\x55\xe9\x37\xe6\x9a\x86\x33\x21\xb8\x11\x09\x61\xc3\xae\x00\x4b\x9a\x5c\xe1\x1a\x4d\x4a\xae\x42\xb1\x89\xe7\x22\x71\x6b\xe8\xd5\xd8\xa9\x05\xff\xae\xf3\x79\xe3\xc7\x8c\x34\x6b\x5f\x8d\x3e\x12\x17\x4f\x35\xbe\xbf\x6b\x8f\xfe\x0f\x69\xc7\xf6\x15\xb5\x61\xd1\x20\x32\x1a\x7e\xa7\xb5\x8c\x1d\x05\xe6\x0f\x9f\x19\x03\xea\xf6\x9d\xb9\x9c\xbb\xa2\xae\x7c\xef\x5b\xef\x5e\x99\xb7\x39\xb5\x7b\xa7\x89\x33\x0e\xee\x2d\x1d\x5d\x9f\x33\x78\x20\xd6\xf7\xda\x50\x7b\xd9\xb7\xd9\x97\xa8\x08\xaa\x05\xf1\xee\xb9\x10\x3d\x99\x80\x8a\x31\x71\x9e\xfd\x3c\x47\xe2\x48\x44\x53\x18\x78\x72\xad\x98\x72\x72\xad\x52\x72\x8b\x6c\x95\xe2\x78\x59\x1c\xd5\x89\x25\xa0\x95\xa8\x5c\x02\x7e\x01\xc8\xa9\x7b\x65\xc4\x84\x29\x53\x7b\x6f\x9b\xbd\xdd\xd6\x32\x7b\xd4\x6b\x75\xe3\x9e\x9c\xde\x7b\xfb\xcc\x6d\x61\x79\x07\x6a\x8a\x6b\x36\xd4\x74\x69\x3b\xa9\x1b\xb3\x68\xde\xa6\x79\xf9\xf9\x0b\x36\x2f\x68\xd3\xb5\xeb\xe6\xc2\x79\x5b\x17\xe4\xe7\x2d\xda\xbc\xa8\x5d\xc7\xee\xdb\x5e\xeb\x3a\x68\x7d\x75\xd7\x81\x1d\x9e\x10\xce\x41\x39\x92\x2f\x45\x5c\x21\x92\x2f\xed\xbc\xd1\x1a\x46\xab\xd3\x0e\xe6\x15\x52\xc4\x9e\x06\xf3\x6a\x16\x21\x5b\x65\xd2\x53\x3a\x9d\xcc\x62\x36\x1a\x18\xb9\xcc\x20\xc4\xae\x89\xc1\x6b\x57\x2a\x33\x48\xc4\x77\x66\xc8\x25\x9d\xf0\x95\x2b\x7e\x11\x79\xc0\x14\x01\x93\x03\x1e\x70\x82\x72\xf4\x33\x05\xfe\x96\x02\x0f\x39\x40\xa9\x13\xff\x34\x35\x52\xc0\x75\x1a\xd4\x23\x21\xf8\xf2\xca\xed\xab\xee\xdc\x59\xb5\x7d\x25\xbd\xd2\xf7\x03\x1d\x86\xcf\x80\xc0\x7b\x0e\x90\x33\x60\x38\xce\x51\x1c\x2e\x48\x4b\xa5\xa6\x92\x08\x7a\x91\x0d\xf9\x59\xd1\x7d\x20\xa1\x77\x32\x8a\x87\x7f\x3f\x58\xc3\x28\x1f\xfe\x45\xec\xc6\x70\x12\xdf\x7e\x99\xca\x45\xd6\x55\x2f\x6f\x16\xeb\x01\x39\xed\x81\xbb\x3d\xa0\xdb\x03\x75\x3e\xe8\xa8\x00\x8c\x56\x01\x94\x9c\x22\xbf\xbd\x87\x8d\xa0\x22\x62\x91\x45\xee\x02\x4a\xd6\x15\x81\x8d\xf3\x04\x1c\x91\x44\x89\x7a\x55\xaa\x5f\xaf\x22\xf1\xce\xe4\x42\x19\x4b\x1d\x10\x42\x44\x81\xab\x01\x21\x04\x80\x78\xae\x72\x89\xf6\x95\x9d\x95\x02\x3c\xf8\xb0\xe4\xe4\x0a\xa1\x59\x48\xab\xf7\x88\x97\x09\x6d\x01\x93\xfc\xc6\x55\xfa\x1e\x3d\xa4\xff\xb8\xc9\x2a\x26\xa9\xff\x13\xeb\xe7\x77\x5a\x36\xae\xa0\x78\xee\xfd\x43\xdf\x7c\xac\xf8\x93\x1d\x35\x7d\xe5\xbc\xa4\x8a\x17\x0e\x2d\x7f\x76\x76\xa7\x2e\x4f\xff\xfc\xd7\x90\xad\xe3\xc6\x27\xf1\x33\xc7\x4c\xe2\x2e\x3f\x3b\x3f\xbc\xa0\x7d\x7e\x3b\x6b\x54\xba\xc7\xe1\xee\x54\xd5\x71\xd4\xd1\xe8\xa8\xca\x2e\xa3\xde\xa8\x5d\xb2\xc6\x5d\x5a\xcc\xf7\x89\x4b\xf7\x24\x24\xcf\xa9\x18\xb5\xcd\xe3\xaa\xeb\x50\x7b\xa0\xdf\xc3\x1b\x99\xed\x5d\xea\x81\xed\xd1\xf8\x48\xae\x02\xe1\x77\x17\x7b\x8e\xad\xe0\x36\x0b\xf8\x3d\x01\x38\x96\x5b\x5d\x41\xb1\x54\xaa\xff\xc8\xe4\x66\xa2\x9d\xcc\x94\x32\xdd\x13\x6f\x24\xfa\x26\x27\x5e\x4f\x64\xcf\x7d\x81\xfe\x91\x58\xb5\x28\x2a\x8e\xdd\x8f\xf8\xbd\x05\x9d\xce\x0c\x8a\xf7\xb6\x42\x42\x4c\xff\x0e\x2f\x51\xbe\xc3\xcb\x25\x5a\xf4\xe7\xbb\x54\x23\x9a\xcb\xab\xd6\x17\x51\x12\x9d\x64\x9c\x64\xb6\xe4\xba\xe4\x37\x89\x04\xb1\x56\x09\x25\xb1\xc7\xc4\xb4\xb8\xc8\xc7\x50\xf6\xb4\x8b\xe8\x48\xa7\x36\xf7\x70\x26\x56\xea\x33\x13\x45\x20\x88\x0e\xe8\x77\xc7\x08\xaa\xa1\x15\x9d\x02\x13\xcd\xc6\x44\xc7\xd2\xc4\x56\xca\x60\x0d\x52\x1d\x1d\x13\x4d\xeb\x75\x86\xcc\x0c\x03\x3d\x69\xf7\xa9\x23\xbb\x3f\xeb\xb3\x38\x7d\x42\xd5\x90\xba\xca\xf1\xad\xe6\xb8\x37\x82\xcb\xf5\xf0\xdf\xc3\x87\xe1\x7f\xcb\xea\x81\xfc\xd0\x21\x20\xaf\x9f\x79\xf7\xf3\x4f\xee\xfe\xf6\xf1\x67\xbf\x81\xee\x37\x2e\xbe\xfb\xf5\xb5\xc4\x59\xeb\x57\xd6\xef\xdc\xd0\x62\xfc\x34\xf0\xd2\x0d\x78\x6a\xcf\x3e\xd0\xe9\xbb\xef\x40\xa7\x7d\x7b\xe1\x2b\x37\x91\x7d\x5d\x00\xdf\x80\xd7\xe1\x57\xf0\x1c\x68\x43\xf8\x33\x47\xcf\x65\x53\xb8\x6d\xe8\xed\xd3\xa9\x56\x5e\x6b\xac\xc3\x43\x79\x6e\xf1\xb2\xc4\x9b\xbc\xc6\xab\xd2\x15\xc9\x34\x32\x8d\xc1\x49\x9d\x04\x96\xa3\x06\xd5\x4d\xde\x70\x12\xeb\x7e\x44\x71\x21\xc4\x9b\x98\xe8\x3f\x32\x44\xbc\xe7\xb8\x73\x89\x0b\x57\xea\x09\x98\xc1\x58\x1d\x15\xee\xed\xb2\x91\x2a\xea\xc1\x9a\x0d\x71\xe1\x82\x6b\xd5\x75\x92\x34\x50\xb8\x57\x53\x3d\xd9\xf5\x59\xfc\x95\x15\x4b\x56\x48\xb2\x65\xc9\x79\x61\x5d\x3a\x94\x75\x06\xcc\xc4\x36\x45\x4f\x6a\x24\x23\x7b\x76\x8f\xa3\xe7\xf6\xef\x6d\x8f\xfc\x95\xa3\x8b\x4d\xfd\x47\x29\x47\x4f\x1f\x35\x24\xc2\x05\xef\xc6\x85\xa5\x73\x33\xcc\xdd\x73\xac\xcf\xaf\x1d\xdb\x35\x8a\xa1\xa3\x3b\xc6\x75\x26\x67\x65\x06\xb5\x94\x5d\xc3\xbc\x44\xc9\x70\xc7\xa6\x13\x72\xb4\xc3\xbf\x54\xa8\x98\x00\x2d\xb8\x99\x5c\xc4\xe7\x81\x11\xe9\xe7\xe2\x2f\x8c\xf2\x94\x1a\x14\xfd\x2a\x85\xa7\x4f\x4b\x7d\x6d\x5e\x51\x83\xae\x77\xc8\xef\x4b\xc1\x88\xce\x60\xac\x1b\xae\x84\x6b\x63\x42\x7e\x25\xf1\x0f\x68\x8d\xbe\x4c\x38\x3a\xc7\x56\xaf\x86\xa1\xf7\xf3\xa9\x54\x01\x35\x16\x2d\xc5\xbc\x4c\x15\x5c\xc2\x7c\xd0\x4d\x02\xcf\x99\x27\x1e\x7e\xc5\x32\x4b\xc1\x4b\xd7\x7d\x93\x90\x6c\xf4\xc7\x8f\x23\xd9\xa8\xa3\x70\x57\x72\x3f\xed\x69\x11\x67\x75\x23\xfc\x57\x78\xf3\x22\x74\x26\x87\xde\x10\x6d\xb8\xc0\x9b\x5d\x17\x10\x97\x8d\x32\xf5\x30\x55\x99\xc6\x9a\xb8\x1e\xd1\x55\xd1\x34\x8e\x2b\xa5\xe5\x8c\x29\xda\x6c\x8e\x36\x31\xac\x4a\x95\x70\x91\x57\x51\x6c\xea\x45\x9e\x0d\x12\x9f\x15\x13\x5f\x2a\xd1\x28\x85\xdd\xd1\x93\x0d\x6a\x46\x68\x80\x89\xc1\xe1\xf1\x42\xb0\x8f\x91\x41\xca\x8a\x1e\x1d\x71\x2e\x84\xfc\xd8\xfd\xcd\x49\x0d\x0e\x6f\x98\xb4\x16\x64\xd6\xaf\x1d\xda\xfb\xf3\x13\x87\xa6\xce\x2f\xed\x05\xa2\xfd\xd4\x47\xff\xd7\x8c\xd8\x7c\x53\x41\x17\x78\x82\x29\x98\x39\xb6\xf6\x69\x23\xdc\x43\x97\xce\x82\x3f\x94\x0c\x6e\x4a\x81\x48\x5f\x78\x89\x7b\x89\x5b\x23\x51\x19\xa4\x54\x7b\x50\x28\x59\x48\x68\x32\x8e\xb1\x33\x2f\x72\x2b\x28\x15\xd2\xa6\x6d\x5e\x35\x63\x39\xc8\x33\x0a\xaf\x42\x77\x10\x09\x75\x4a\x50\x19\x2e\x61\x61\x63\x12\x72\x31\x08\xad\x49\xb3\x02\xe7\x2a\x87\x79\xf1\x95\xf9\xcf\xbc\xda\x7b\x55\xbf\x05\xa7\x37\x57\x76\xea\x5c\x55\xd3\xb1\xc3\x20\xb6\xcf\xd3\xa7\x8e\xcf\xeb\xb3\xb2\xe7\xa9\xa7\x3b\x0d\xaa\x2e\x2c\x1c\x5c\x23\xf8\x7f\x87\xa2\x8d\x18\xce\xfe\x8d\xec\x02\x2d\x95\xef\x75\xab\xd4\xfb\x11\x46\x69\x1d\xed\xa4\x19\x35\x4b\x8b\x49\x05\xc5\xd2\x0a\x69\x9d\x94\x91\x49\x81\x74\x10\x07\x90\xc4\xab\x44\xaa\x84\x20\x2d\x84\x58\xbd\xa6\xc9\x06\x38\xa2\x90\xfe\xf8\x3a\x1c\x0b\x56\x5c\x07\x2b\x71\x60\x21\x7d\x0e\xee\x03\xbd\xbf\x01\xbd\xe0\x4b\xdf\xf8\xda\x7c\xf3\x8d\x90\x0b\x11\x4e\x67\xb2\x2d\xb9\x7a\xf4\x96\x39\xde\x48\xbd\x84\xb2\x2b\x12\x15\xb4\xc8\xcb\x35\x1a\xd9\x2d\x5e\xf3\x35\xb0\x50\x96\xef\x79\xea\xab\x50\x4d\x9d\x70\x6e\x03\x89\x0a\xcc\xcd\x21\x41\x81\xa1\x27\x8e\x04\xae\x83\x70\x47\xe5\xf5\xc9\xb5\x3d\x06\x47\xdf\x88\x7f\x6f\xe9\xc2\x35\x77\xea\x07\x87\x83\x3d\x4e\x3a\xb3\x7e\xc9\x8c\xf6\x83\xbd\xc5\x13\x25\x4f\x2c\x19\x5a\x75\x74\x5e\x69\xa7\x38\x41\x8f\x04\x79\xb4\x87\x4d\xe3\x96\x22\x09\xdf\xdb\x9b\x15\xa3\x43\xf2\xf3\x16\xff\xae\xee\x73\x1d\xad\xd5\x45\xe9\x10\xcd\xe9\x74\x94\x36\x3c\x2a\x9c\x36\xb3\xe1\x4e\x95\xb6\x28\x3c\x22\xc2\x72\x8b\x8f\xf8\x9a\x92\xdf\xe2\x3b\x4a\x80\x84\xfa\x26\xe8\x1a\xa7\x32\x13\x49\xc0\x2b\x51\x0a\x2a\x43\xf5\x7f\x74\xf6\x4d\x44\x90\x08\x91\xec\xb9\xe4\x16\xc4\x0f\xb9\x44\xb0\x02\x34\x80\x9e\xb0\x6e\x1b\xb8\x0e\x26\x14\x76\x5b\xd1\x3e\xa2\x75\xaf\xbe\x80\x4f\xef\xac\xfd\x24\xf6\xf2\xf2\x67\x56\x8f\x1b\xc3\x77\xaf\xda\x4f\x7b\x46\x8d\x33\x48\xb4\x9a\x41\x3d\xf2\x7b\xae\xee\x9c\xdf\x25\x3b\x4b\x33\x7e\x56\x4d\xef\x9e\xf3\x2c\xb4\xb2\x4f\xeb\x92\xc5\x5d\xd1\xfb\xdc\x61\xb7\xb2\x51\x8f\xde\x67\xe5\xba\x5d\x52\x0e\xdc\x91\xa0\xb3\x48\xcb\xe0\x2c\x76\x6b\xd4\xbd\xc4\xdb\x58\x47\x7b\x1b\x0e\x62\x0f\x22\x3b\xc9\x4e\xb9\xbd\x06\xbb\x59\x46\x73\x61\x56\x8d\x5a\xab\x52\x72\xc6\x72\x9e\x13\xfc\x5a\xa9\xfe\xbc\x37\x7c\x5f\x41\x2c\x6b\xd1\x9d\x04\x5c\x21\x66\xb7\x44\x4a\x7f\x26\xd7\x30\x93\xf7\x64\x75\xd7\xb2\xc6\x22\x78\x1b\xc4\x80\xf0\xc9\xea\xfa\xc1\x1b\x6c\xd8\xf6\x8e\x65\xc6\x15\x5d\x4a\x6b\x31\x11\x2e\xe5\x3e\xf7\xed\xe8\x9c\xb6\x6b\xdf\xb3\x74\xfb\x87\x27\xaf\xc6\x08\x7a\xcc\x1b\xf0\x55\xf6\x5f\x12\xd7\x17\xef\x95\x4b\xb1\xf2\x4d\xb1\x1a\xf6\x24\xa0\x8e\xf3\x1a\x46\xc2\xd1\x40\xc8\xbf\x13\x0e\x36\xc6\x71\x7a\x9a\x1c\x2d\x80\xbe\x8c\xe2\x59\x70\x49\x59\x1e\x7e\xb2\x09\x24\x9c\x83\x9f\x6c\x3c\xbd\x7c\xcb\x84\x4b\xcf\xd0\x93\x1d\xec\xf1\xfb\x12\xee\xfe\x7d\x09\xd3\xb0\x68\xe6\xd4\x4f\x27\x2c\xc3\xfc\xa8\x01\x6c\x63\xc2\xe9\xf7\x0d\x12\x59\x1a\xb1\x7d\x36\xc2\x0e\xa0\x0f\xfa\xcd\x84\x4e\x9d\x52\xeb\x45\x6a\xb4\x9a\xe2\xea\x79\x21\x52\x18\x69\x2b\xa9\xb6\xcb\xc8\xd0\x89\x26\x8e\x62\x21\x8c\x1e\x49\x55\x92\x83\x00\x52\x72\xac\xce\x8c\xf5\xc9\xed\xe3\x34\x23\x97\xb5\xde\xd2\x75\x33\xec\x20\x99\x22\xed\x19\x1e\x49\x9f\xa9\x55\x8c\x6e\x5d\x47\xee\x88\x81\x95\xce\x64\xae\x71\x4f\x0b\xf9\x20\x24\x11\xe4\x16\xaf\x95\x46\x49\x11\x79\x49\x95\x8a\x2f\x55\xe8\xe5\xc0\xcd\x00\xb1\x63\xf5\xf7\xad\x60\x32\x04\xa2\x18\x7f\x3e\x08\x4e\x21\x04\x56\xc7\x9d\x61\xce\xe7\xbd\x91\x5d\xd7\xc7\x5f\x5a\xf4\xa5\x03\x91\x36\x6d\x48\xed\xb8\xa1\xa4\x95\xaf\xa0\x1e\xf1\x90\x56\x48\xae\xf5\x43\x72\x4d\x4b\x39\x70\x81\xf8\x70\x74\x88\xb0\x10\x93\x19\xbf\xe7\x65\x01\x21\x96\x28\xd2\x25\x89\x8d\x68\x12\x64\x4f\x62\xec\xa7\xac\xdd\x55\x38\xe3\x60\xdd\xc6\x17\x3b\xcd\x7a\x79\x95\x37\xbf\x6b\x65\xe6\x94\x6e\x55\x59\xf4\xdc\x4d\xcf\x56\x9e\x7b\xb6\xeb\xaa\xfa\xc1\x6f\x2e\x2e\x06\xff\x74\xcd\xeb\x7d\xa8\xcb\x92\x7e\xc7\x04\x7e\x92\x83\x64\x43\x8f\x10\xf9\xc3\x22\xf9\xa3\x0e\xea\x22\x05\x00\x20\x4b\xd1\x28\x05\xc8\xd8\x16\x7e\xc9\x91\x82\x4e\xc7\xa5\xbf\x9e\x54\xc3\x53\xb7\xc8\xaf\x77\x4e\xab\xe1\x89\xa5\x48\xe6\x80\x31\x6e\xb8\xa2\x33\x11\x3f\xfe\x5f\x29\x62\x63\x79\x10\xcf\x3a\xc4\x15\x1a\x3c\xb2\x9f\xe0\xab\xc8\xd6\x8a\x93\xfe\xfa\x23\xa5\x97\xca\x7e\xa1\x76\xfa\x8e\x53\xb1\x5e\x0b\x43\x1b\xc2\x18\x5a\x57\xa5\x03\x51\xba\x59\xba\x65\x3a\x06\xa8\x07\xa9\xc1\x78\x7d\x76\x25\xfa\xce\xa6\x0a\xd0\x37\x9e\x07\xe7\x80\x9e\x15\xe7\x79\x4d\x98\xe7\x73\x3c\xcf\xcf\xd4\x15\xdf\x51\x4a\x7b\x82\xd6\x85\xd1\xe8\xf4\x83\x4a\x3d\x7e\x46\x58\x1b\xc7\x13\x3e\xe4\xca\xd0\x33\x77\x70\x7f\x59\xfc\x4c\xb6\xb0\xf6\x45\xb4\x76\x96\x37\x9a\xa1\xd3\xd1\xda\xe9\xda\xf4\xaa\x74\x3a\x2a\x1d\x80\xa4\xf3\x49\x1f\x26\xd1\x87\x92\xae\x27\xfd\x96\xc4\x50\xf1\x51\xf1\x78\xba\xca\xca\x26\xb0\xe0\x98\x4c\x78\x9d\x6d\x83\xce\x9f\x8d\x8a\xa4\xf2\xbc\x91\x52\x13\x22\x18\x25\x32\x21\xf5\x91\x91\x11\x9b\x2b\x22\xb5\x94\x1a\xa8\x58\xb5\x5e\xaf\xa8\xe2\xf5\x5b\x43\x2e\x32\x9b\x87\x49\x23\xf6\xe7\x0f\x1c\xc6\xf6\x9d\x18\x65\x9f\x9b\x43\x8c\xcb\x56\xc8\x5c\x5c\x34\x76\x51\x5d\xf5\xc0\x21\xdb\xa2\x80\xcd\x0b\x5f\xf9\xf6\xca\xcf\x51\xed\x87\xed\x5c\x07\xa6\x66\xc1\x6f\xb2\xe8\x9d\xb5\x3b\x3a\xf6\x1c\x5b\xd4\xba\xc7\xa4\xc1\xaa\x0b\xb7\x76\xad\xc8\x18\x3d\xa4\xa2\xb6\x8a\x06\xc4\x08\xc5\xef\x2f\xc4\xf4\x4a\x76\x19\xe2\x90\x25\x8a\xde\x9b\xea\xd0\xf8\x3e\x75\x8f\xb2\x78\xd5\xb4\x56\xcb\xc5\xd1\xba\x37\x75\x46\x8e\x72\x27\x22\x8c\xa1\x6f\x71\xfc\x3e\xc9\x0b\x81\xf1\x53\xa8\x67\xa9\x3f\x29\xcb\x31\x1a\x8f\xd6\x9e\x04\xab\x8f\x6a\x0d\xfe\x07\xfc\xe3\x17\x4a\xf6\xf8\xc7\xd3\x0b\xa8\x54\x34\x3e\xec\x38\xad\xd3\xa1\x07\xcc\x27\x81\xf5\xa8\x59\x1b\x5c\x21\x00\xd3\x95\x90\x67\x9e\xa7\x52\x90\xda\x8a\x9e\x21\x20\x85\x9d\x04\xa9\x47\xc3\x62\x1f\xf3\xcc\x02\xc9\xec\x00\x5c\x23\xa9\x24\xea\x3b\x2a\xd2\x6b\x60\xc8\x53\x0c\x6d\x2c\x30\x82\x78\xa3\x5e\x22\x75\x23\x2d\x36\x9b\x3c\x98\x1d\x78\xff\xfa\xc0\x5a\x1b\xd1\xf9\x9a\x4b\x85\x1f\x67\xe8\x38\x1c\x2e\x76\xb2\xf1\xd6\x51\x43\x38\x7e\x28\xb0\xb9\x24\x0e\x9a\xcb\x26\xf1\x54\x26\x6a\x90\x37\x8f\x02\x46\x50\xc3\x9b\x8c\x46\x56\xab\x55\xd5\xf0\x32\x65\x0d\x7f\x49\x06\x4e\xc9\xc0\x3a\x19\x28\x90\xf5\x90\x21\x11\x28\x8b\x92\xd1\x6a\x4e\x26\x43\x92\x53\x6b\xd0\xeb\x58\x56\x5a\xc3\xb3\xc1\x60\x4a\x62\xb8\x05\x23\x62\x05\x12\x08\xe4\x3d\x93\x08\x56\x7f\x7c\xac\xcb\x88\x18\x74\x26\xdd\xd5\x77\x18\x3e\xa0\xa7\x32\xb1\x1e\x78\xb1\x10\x24\x78\xe0\x27\xdd\xc0\x00\x8f\x6f\xcf\xf5\x56\xbd\xf7\xbc\x0b\xe6\xc2\x19\x5c\xe1\xbb\xf0\xf9\x0b\x70\xea\xbb\xec\xec\x0b\x70\xa5\x40\xeb\x3d\x61\x07\x1c\xa7\x8c\xde\x35\x8e\xe0\x68\x2a\xc0\x4a\x83\xf6\x30\xb0\x9d\x6c\xec\x7a\xd4\x96\xa0\xd0\x11\x94\x92\xb1\x24\xd6\x97\xec\x73\xbc\x48\x17\x3f\xe0\x7d\xf6\x22\xb2\x55\x71\x71\x40\x5d\xa6\xd6\x51\x74\x90\x2e\x1e\x19\x3f\x85\x5a\x4c\xe8\x02\xe0\xd1\xaa\x93\x40\x76\x54\xa5\xf5\x3f\x10\x1c\xbf\xc7\x3f\x5e\xa4\x0b\x3c\xbf\x5a\x8d\x9e\x30\xd4\x1b\x54\x8f\x99\x7f\x76\x60\xfe\x91\x94\x17\xed\xaf\x0d\xc7\x76\x62\x80\x68\xa0\x3b\xa5\xd3\x08\x4f\xf8\xf7\x56\x88\x65\x25\x30\x25\x89\xef\xf0\x75\x93\x77\xe8\xae\xd6\x49\x41\xc8\x1a\xcd\xc7\x4f\xa1\x9e\x6b\xf2\x0e\x36\xf4\x0e\xfe\x07\x82\xe3\xf7\xf8\xc7\x8b\xef\x10\xe9\x35\x89\xef\x90\x6a\x28\x30\xf4\x30\x30\xab\x0d\x2a\xfc\x54\x65\xb3\x75\x66\x07\xd6\x11\x68\xd5\xe9\x35\x05\xde\x25\x55\x57\xa0\xa3\xf7\xe9\x34\xe2\x73\xc2\x1b\x11\xbe\x82\xcc\x39\xf6\x55\x44\x7b\x6a\x24\xd9\x7b\x78\x33\x2d\x34\xc3\x32\xd5\xf8\xce\x9c\x2d\x40\xf2\xfe\x75\xf6\x1b\xf6\x2e\x2b\xc1\xa9\x23\x5b\xd0\x7f\x5c\x65\x39\x1d\xc3\xb2\x40\x22\x31\x54\xf1\x12\x06\x58\xab\x1e\x13\x2f\x3f\x3e\xe0\x27\x48\x00\x24\xb3\xbd\x69\x9c\xb8\x34\x46\x88\x15\x7f\x0f\x56\x8c\x99\xdf\x62\xfe\x98\x26\xe1\xe2\xed\xaf\xb6\xb8\xda\x9e\x84\x8c\xd3\x59\x5f\xd0\x39\x21\x51\xe3\xf0\xc0\x17\xf0\x10\x0e\x1c\x47\xef\x4b\xe2\x4d\x09\x9e\xd2\x43\xce\x33\xde\x07\x7c\x34\x41\xd8\x4b\x61\xb1\x12\x75\xc8\x3e\x90\xd8\x51\xb2\x0f\x19\xe2\xbe\x7d\x26\xec\x1b\xed\x70\x20\xf4\x44\x14\x45\x38\x19\xe5\xff\x31\x7e\x0a\xb5\x42\xe0\x49\x78\xb4\x03\x49\xc7\xa3\x8e\x28\xff\x03\xc1\xf1\x7b\xfc\xe3\x83\xb4\x47\x47\x44\xa0\x27\xa2\x57\x45\x3b\x1e\x99\xff\x4a\xc8\xf8\x00\xfc\x02\x3c\xee\x7d\xee\xf4\xc7\xc0\x33\x3b\x00\xcf\x48\x34\x3f\xa1\x55\x86\x3c\xc0\xd0\xce\xfd\xce\x48\xe1\x09\x71\x67\x01\x55\x4b\xed\x66\x6b\xd9\xbd\x48\x6f\xef\xe8\x35\x77\x57\x56\x2a\x47\x2b\x19\x65\x9a\x39\xac\x48\xd9\x9e\x29\x67\x6a\x18\x86\x39\xd9\xf8\x9e\x37\x0c\x7d\xc0\xfc\x09\xc0\xcf\x00\xac\x06\x3b\xc1\x79\xc0\x2c\x01\x60\x12\x00\x00\xe7\xef\xe0\x7f\x99\x89\xf8\x7f\xe9\x69\x46\x39\xc8\x95\x03\xab\x1c\x48\xe5\xa0\x16\x0c\x81\x5b\x37\x83\x41\x60\xd0\x66\xb8\x95\xfc\x80\x9b\x40\x27\xf4\xf1\xa0\x4d\x70\x3b\xfe\xef\xcd\x70\xfb\x56\x50\x03\x37\x50\x14\xd3\x78\xb1\xf1\x23\x2e\x8b\x9b\x4c\x59\xd1\xae\xb9\xb1\x77\x4c\x15\x5d\xc5\x47\x85\x51\x2a\x96\xb2\x07\x23\x15\x85\xdb\x3e\xce\xef\x09\x23\xe1\xab\xa2\x93\x0c\xc7\xf1\x02\x72\x15\xc9\x91\xeb\x36\x1a\xdc\xff\x64\xec\xbc\x21\xbb\x3c\xb5\xc7\x00\xbd\xfd\xa3\x31\xf3\x07\xef\x4c\x18\x7e\xbc\x91\xfa\xdd\x07\x13\x26\x0d\x5f\x5f\xed\xfb\x85\x06\x9e\xc9\x23\xd6\x0f\x32\x3d\x51\x5f\x7c\x68\xd0\x82\x2d\x60\x26\x00\xf3\x26\xd6\x17\xef\x1f\x32\x7f\x3b\x9c\x0b\xe1\x7c\x66\xba\xef\xeb\x09\x07\x41\xdf\x3f\x69\x57\xdd\x3e\xb8\x47\xe0\x4f\x24\x9e\x92\xec\x79\x4b\x91\x46\xae\x88\x67\xdb\x62\x41\x34\x65\x35\x5b\x6d\x8c\x21\x64\x4f\x9a\x8f\x9f\x42\xcd\x43\xe3\x4d\x5e\x15\xc0\xc3\x2d\xdf\x5a\xc2\xfd\xc3\xb3\x43\xe6\xdf\xe3\x1f\x1f\xc2\x9f\xac\x56\xf4\x80\x63\x94\xc3\xf2\x98\xf9\x67\x07\xe6\x17\xce\x34\xe1\x4f\x18\x20\x1a\xd8\xe6\xda\xc2\x84\x27\x02\xfc\x89\xc4\x18\x12\x98\x5a\x8b\x30\xad\x16\x61\x92\xa3\x25\xe4\xcf\xc9\x55\x8c\x34\x00\x93\x18\xc7\x7b\x88\x9c\x7d\x2b\x15\xe3\x35\x02\x63\x0d\x2f\x31\xd4\xf0\x00\xd9\x2b\x34\x17\x88\x6e\xf6\x7b\x32\x02\xa2\x43\xb0\x46\x58\x7f\x7c\x33\x52\x04\x4b\x3f\xc9\x10\xa2\xdc\x93\x2f\x7e\xf1\xd3\x06\xf8\xc3\x33\x63\x27\xec\xed\x73\x84\x7f\xb6\x2b\xa0\x1a\x29\xae\xf0\xe7\x97\x36\x2f\xb9\xbf\x04\x7c\xd3\x6d\x20\x2c\xea\x32\x57\xd0\xe3\xad\xe8\xfd\x76\x23\xdb\x3e\x13\xdf\x54\x9b\xe5\x4e\xca\x19\x56\xca\x3b\x29\x87\xdd\x4c\x49\x4a\x79\x9a\xdc\x74\x0a\xb1\x4f\xc1\x6b\x4e\xd1\xcf\x56\x00\xb2\x44\x37\x9b\x98\xf0\xa5\xc4\xf1\xe4\x62\xba\x2f\x2d\xa8\x37\x56\xa2\x76\xd3\x7b\x57\xd5\x25\x24\xcd\xcc\x28\xeb\xa7\x64\x26\x77\xec\x5c\xd2\xbd\xa4\x73\x49\xc9\x87\x99\x6f\xc2\xdb\xe7\x93\x40\xca\xef\xc7\x2f\x59\x32\xda\xf7\x4f\x74\x25\x75\x9b\x37\xe6\x8a\x29\xf1\x8a\xc5\x5d\x98\xe7\x28\xee\x93\x3e\xba\xa0\x74\x42\xab\xfc\xaa\x96\x59\x6d\xe0\x9f\x0f\x95\xcc\xdd\xdb\x7f\x2f\x9b\x1d\x57\x51\x56\xd8\xd1\xd5\xc2\x6c\xc9\x6a\x3b\xb6\x7e\xf8\xf9\xa1\x78\x4f\x49\x8c\x1f\x77\x04\xe1\xbb\x23\xc2\xb7\x84\xea\x50\x4f\x91\x53\x9c\x97\xa7\x8f\xa3\x5b\xb5\x6e\xd5\x86\x71\x86\xea\x14\x64\xfc\xa8\x90\xf1\x53\xba\x53\x98\xab\xe0\xd1\x79\x27\x81\xee\x68\x5e\x6b\xff\x03\xc1\xf1\x65\xdc\x31\xff\x78\x7a\xc1\xaf\xc2\xfc\xad\x5a\xa1\x27\x0a\x56\x16\xe4\x3d\x66\xfe\x75\xdc\xe9\xc0\xf8\xe7\xff\x0d\x81\xa7\xfd\xd1\xf6\x25\x8f\x19\x5f\xc6\x6d\x0e\xc0\x33\xf2\x37\x4a\xe0\x2a\xf8\x01\x86\x6e\x73\xa0\x4d\xbe\xf0\x84\x5f\x5e\xf8\x9f\x91\x28\x03\x6b\x6c\xfc\xb7\xc9\x33\xad\x4f\xb5\xee\xd0\xf4\x19\xc4\x03\xbe\x44\xcf\xbc\x2f\xc6\x42\xb6\xa7\xaa\xbc\xb9\x59\x54\x1b\xaa\x8c\xb7\x55\xb5\x19\xdb\x86\xd6\x3a\x91\x1e\xdb\xc6\xd9\xc6\x19\xa7\x8d\x57\xc5\xe7\x95\xf1\xf1\xba\xd8\xc8\x32\x3e\x56\x67\x48\x2b\xe3\x0d\x16\x95\xa4\x8c\x67\xe5\x26\x39\x2d\x57\x59\x88\xdf\xdf\x1f\x97\x13\x70\x25\xfa\x9d\x89\x81\x1b\x00\xb3\x3f\xc0\xcc\x4a\x63\x03\x54\x8c\x1d\xc8\x35\x34\x71\xbe\x61\x37\xbc\x1e\xd9\xd4\x9c\x29\x53\xf4\xb9\x81\x68\x72\x21\x8c\x28\x8a\x3e\xa4\xcd\x6f\xd5\xba\x47\xc4\x9e\x39\x77\x27\x8c\x55\x75\x3e\x31\x78\xe8\x70\x45\x21\xe8\xba\xda\xd4\xa7\x32\xe9\x52\x7a\xc3\xc2\x23\x2d\xc6\x6e\x7f\xa8\xb4\x3d\x64\x5a\x95\x2c\xb3\x2a\x87\xf5\xe8\x95\x4a\xff\x1d\xdf\xab\xa3\x01\x24\xcb\x92\xc1\x4d\xba\x8b\xb7\x6f\x4d\xb7\x76\xc9\xf0\xce\xe8\x69\x93\x26\x4d\x1a\x99\x92\x03\xaa\x39\x76\x48\xcc\x53\xab\xf4\x9b\x36\x2d\x59\x02\x5f\x4f\x1f\xbd\xe4\xb7\xf2\xbd\xe3\x73\x18\xda\x3b\x97\x1e\xdf\x6e\x72\x79\xdb\xd4\xe2\x52\x8c\xdb\x4a\xa4\x4f\x4d\x62\x4b\x10\x6e\x3b\x89\xfa\x54\x99\xa0\x4f\xb9\x4e\x36\x56\x1f\x75\xa5\x89\x42\x81\xec\x03\x89\xcb\x23\xb4\x54\x24\xd0\xde\x61\x61\xaf\x63\x62\xd0\x5e\xc7\xb6\x89\xf5\x04\x25\x48\x60\x7c\x7d\xc8\xf8\x29\x63\x09\xed\xe1\xd1\x31\x98\xf6\x62\xe2\x02\x12\x2d\x64\xfe\x63\xfe\xf1\xf4\x02\xa9\x30\x7f\x6c\x2c\x7a\x22\x61\x51\x42\xcc\x63\xe6\x9f\x44\x68\x49\x98\x7f\xa4\x4c\xa4\x0b\x0c\x10\x43\x7b\x76\x7a\xdc\x4d\x24\x14\x7e\x46\x88\x57\xc2\x30\xdd\x13\xde\xe1\x35\xb2\x06\x50\x28\xf4\x71\x40\xb9\x44\xa9\x61\x40\x93\x35\xd4\x24\xe7\x3e\x38\x7e\xca\x70\xfc\x0e\x00\x8f\x56\x9c\x04\xc5\x47\x15\x6a\xff\x03\xc1\xf1\x83\xc9\x3b\xdc\x13\xde\x41\x21\xcc\xaf\x54\xa2\x27\x74\x57\x74\x8a\xc7\xcc\xff\x0c\x79\x07\x61\xfe\x91\x09\x14\x92\x58\x72\x9a\x00\x44\x03\xcd\x49\x20\x3d\xaa\x51\x09\x0f\x05\xc8\x1b\xf1\xd1\x7c\xf4\xee\x8b\xb8\x2f\xa8\x08\x2a\x91\x2a\xf1\x26\xc9\x2d\xc0\x48\x59\xec\xac\x43\x6b\x02\x26\x93\x56\xe5\x00\x0a\xc6\xe1\x08\xd3\xba\x4a\x79\x3d\xa5\x05\x72\x46\xab\x95\x86\x51\xd2\xf8\x52\x5e\x1a\x88\xf3\x0c\xdc\x60\x89\xc9\xd0\xa9\xb8\xd0\x0e\xbe\x79\xb0\xe8\xc5\xf0\x58\xc1\x0a\xb7\xc6\x11\x11\xe9\x71\x59\xac\x6e\xab\x50\x59\x45\x2a\x11\xd3\xbd\xdf\x78\xa3\x72\xcf\xef\xeb\xdf\xbf\x35\x60\xc7\x8f\x6b\x4a\xb2\xa2\xbd\x8d\xa9\xef\x74\x7d\x0e\xb8\xfb\xb4\x04\x9a\x6c\x78\xb6\xcf\xc0\x19\x4b\x23\xd5\x87\x46\xcd\x2b\x62\xff\xf8\x03\x7e\xba\x1a\x7e\xfa\xf6\x88\xb3\x47\x9f\xf8\x67\x77\x85\x69\xca\xe0\xda\x8d\x3d\x3a\x8f\x48\x4b\x19\xbd\xc1\x67\x1f\xd8\x6f\xed\xe6\x76\xd9\xaf\x8d\xbc\x25\xd0\x19\x8e\xa1\xda\x4b\x78\x4a\x99\xc0\x53\x44\x1c\xda\xed\x08\x87\xb1\x27\x62\xd3\x94\xd6\x26\x38\x24\xb1\x4f\x64\x8f\xca\x85\x3d\x3d\x2d\xd0\x0d\x1e\x4f\x3b\xda\x23\xc5\x49\xfe\x7f\x8e\x9f\x32\x94\xd0\x25\x1e\x6d\x3f\x09\xe8\xa3\xf6\x48\xff\x03\xa1\xe3\x8f\xf9\xc7\x23\x39\x4a\x89\x9a\x13\x7a\xc2\x35\xd3\x65\x7f\xcc\xfc\x5b\x09\xfc\xc2\xf8\xe7\xa9\x10\x78\x62\x9f\x8b\x4d\x7b\x2c\x3c\x9b\x03\xf0\xe0\xca\x26\x84\x8e\xf1\x03\x0c\x1d\xb5\x2e\x2a\x42\x78\x22\xc8\xdf\xa8\xa1\xd4\x5e\x76\x38\xd2\xb5\xf0\xfd\x8a\x92\x72\x79\x2d\x32\xf9\x01\x9e\x95\x1d\xe2\xb1\x73\x14\x50\x07\x78\x0e\xa0\xdf\x5f\xa6\x0a\x48\x3f\x4d\xb4\xa9\xd9\x99\xc4\x07\x4a\xfe\xff\xee\x5d\xdf\x02\x96\xf1\x2d\xb8\xcb\xbc\xf1\xe3\x8f\xf0\xc9\xeb\xd7\xe1\xf8\x1f\x7f\x14\xea\x04\x48\x11\x2c\x67\xd8\x52\x24\x0b\x23\x90\x35\x89\x74\x27\x25\x22\xa1\x48\x2b\xa5\xd4\x51\xb6\x60\x30\x59\x33\xdd\xc9\x10\x54\x9d\x10\xe1\x34\x53\x9d\xfe\xba\x30\x7a\x78\xd9\xa4\xd4\x2d\x20\xf6\xad\x2b\x23\xab\xcb\x47\xa6\x0c\xd8\xf3\xdb\x7b\xd0\x1d\x37\x7a\xf8\xfc\x32\x68\x07\x9f\xc6\x8d\x1d\x31\xbf\xd4\x54\x5d\x5d\x52\xd7\x7f\xd6\x29\x50\x7d\xbc\x2f\x5f\x52\xd3\x6b\xe6\x62\xf8\xe5\x3b\x75\xf4\x15\xd8\xa5\xef\x53\x80\xdb\x0a\x8e\x77\x9f\x01\x7f\xc7\xb8\x22\x71\x37\x64\xef\xfa\x09\x7b\xbd\x5d\xa0\x0d\x9b\x0d\xd1\x86\xdd\x62\x8f\xb4\x28\x9a\xe0\xb6\xf9\xf8\x29\xfd\x29\xa2\x9d\xe0\xe1\xb6\x1b\xb6\x08\xff\xf0\xec\xc0\xd8\x63\xfe\xb1\xfe\x7d\x16\xe8\xce\x39\xc2\x69\x7b\xec\xdc\x9b\x03\x73\x8b\xfb\x46\x13\x60\x68\x10\x39\x37\xd2\x21\x3c\x11\xe4\x3f\x42\x4c\x0a\x81\x67\x80\x00\x4f\x9d\x00\x4f\x38\x5a\x22\x1c\x86\x3b\x68\xb3\x9f\xf2\xe8\xc6\x0f\x60\x5f\x76\x06\xd2\x57\xac\x48\x8b\x4d\xf0\x9a\xad\x16\xbb\x26\xba\x94\x67\xf4\x12\x8d\x45\x82\x36\x43\xa2\x03\xe4\x12\xb1\x49\xd8\x36\xf6\xb7\x30\x38\x96\x30\x34\xc8\xdd\x44\x82\x65\xb3\xc4\x83\x2b\x14\x94\xe9\x04\xc2\x4b\x63\xd9\x35\xef\x2f\x5f\x5b\xba\xf4\x8d\xc9\x35\x4b\x22\x24\x46\x45\x19\xbc\xcd\x3c\xbb\x69\xe8\xda\x58\x6d\xaf\xae\x03\xe7\x94\x70\x97\xe0\x90\xdd\x6f\x37\xec\x9f\x0d\x3f\xfa\x6c\xd2\x90\x01\xba\xb1\xb9\xb0\x9a\xad\x7b\xf7\xcc\xcb\x3d\xda\x8d\x1e\xb7\x14\x38\x82\xef\xb3\x39\xf0\x3e\x23\x39\x11\x07\xe1\xe1\x18\x07\x11\x2b\x23\xec\xc2\x2b\x85\xe0\x00\xfb\x2b\xc6\x4a\x6a\x03\xfe\x8a\xc5\x54\x0e\x50\x52\x8a\xa3\xb4\x5e\xcf\xc5\x89\xba\xa8\xa0\x27\x54\x04\x64\xfe\xe2\xff\x28\x3c\x22\x3f\x5f\x1f\xd7\xc4\x5f\xb2\x37\xc4\xc7\xb2\x9e\xe8\xb7\x68\x14\x36\xc9\x42\xe6\x19\x1e\xa2\xcf\xac\xff\x85\xcc\x83\x35\x87\xe0\x3c\xb0\x06\xe7\x84\x0b\xf3\xe8\xa4\xf4\x26\xf0\x02\xa5\xc4\xcf\xe2\x5a\x4d\x44\x36\x76\x14\x3f\xaf\x13\x7c\x10\x58\xb7\x20\x3a\x6f\x9c\xa8\xf3\xbe\x2c\xd8\xd8\x61\xd8\x12\x3c\x09\xe2\x8f\x86\xd9\x45\x3f\x04\xa1\x2b\x9c\x07\x30\x8f\xec\x79\x27\x61\xcf\x6b\x89\x0c\x89\x42\x5b\x1e\x75\x12\x30\x47\xa3\xa2\x9b\xca\xc1\x9e\x01\x5b\x2d\x4e\xd4\xdb\x3b\x90\xf7\x42\x38\x0d\xbc\x57\x65\x40\x56\x76\x0a\xd0\x2a\x1a\xe1\x74\x06\xdf\x4b\x9c\x67\x40\x60\x9e\x0d\x48\x47\xdf\x80\x47\x85\x85\x35\x9b\xe7\x6c\x60\x9e\x0d\x26\x32\x4f\x54\xd4\x23\xf3\x04\xe1\x59\x48\x79\x45\x3b\x02\x4f\x04\x6c\x6f\xd9\x9c\xfe\xd7\x0d\xcc\x39\x3f\x04\xb6\x85\x0f\x85\x73\x84\x27\x05\xae\xbd\xae\xe6\x7a\x02\xc9\xfd\x26\xf3\x7b\xc4\xf9\xf5\xc2\x3e\x9a\x4c\x02\x9c\x02\x5f\xe2\x70\x9e\x50\x18\x15\x8f\x2c\xd7\x44\xaf\x25\xcc\x9c\x98\x60\xa2\x58\xbd\x4c\xab\x75\x94\xf2\x5a\x9d\x2c\x26\x98\xc3\xe0\x8f\x35\x3d\xff\x68\x16\x03\xbe\xee\x6d\x9e\xc3\x60\x11\x92\x18\x40\xae\x31\x53\xca\xd0\x56\x0d\xc7\x76\x58\x31\x60\xfc\xcc\x39\x1f\xcc\xde\x9f\x8a\x13\x19\xb4\x7f\xa8\x6c\xcf\xb5\xca\x6c\x37\xbe\x63\x76\x6a\xf2\x80\x6e\x56\x23\x38\x2e\xad\xb8\x2d\x3d\x81\x13\x1a\x6a\x6a\x4e\xed\x39\x0a\xa6\x5f\x79\xdd\x9f\xce\x70\xb1\xff\xf0\x9d\xf0\xeb\xc1\x03\x06\xf0\x2f\x3c\x51\x03\x6e\xb9\x40\x7b\x37\x3c\x2b\xc8\x35\xd1\xef\x61\x90\x50\x2b\x89\x0c\x2f\x44\xef\xd4\x07\xbd\x93\x0b\xd1\x6d\x7b\x6f\x4c\x64\x14\x65\x03\x76\x87\xbd\x8c\x77\x46\x38\x18\xb3\xbb\x94\x0f\x93\xab\x29\x33\x52\x55\xcd\xea\xc4\x52\x5e\x6d\x61\x71\x4a\x81\x18\xd8\xe1\x3f\xef\x99\x7e\xf7\x1b\x31\x95\x24\xd2\xc7\xe6\x6c\x90\xc4\x03\x64\x44\x81\x26\x01\xac\x5c\xf6\xbc\x13\x2a\x1b\xfc\x4d\x48\xdd\x58\xbe\xb1\x74\xd1\xab\x93\x47\x2d\xb1\xd0\x79\xf0\x7b\x17\x62\x61\x20\xdc\x36\xcf\xf7\x49\x79\x49\xc5\xf4\x2e\x6b\x6a\xd7\x38\x75\xec\xa6\x87\xa5\xf9\x87\x85\x24\x8e\xd3\x2f\x4d\x07\x9e\x4b\x75\x83\x07\x80\xd4\x3d\x0b\x16\xf8\x2a\x86\x8c\x58\x00\xef\x8d\x38\xff\xfa\x8b\xa5\x41\xbf\x5b\x6d\xc0\x2f\xb6\x98\xea\x44\xce\x37\xd0\x68\x02\x74\x27\xe8\x6e\x15\x01\x5d\x6f\x31\x4d\xce\xa5\xdb\x1d\x42\x77\xcd\xfd\x6b\xfe\xf3\x4d\x3c\x4c\x21\xf3\xcc\x0a\xd1\x19\xd7\xb3\x64\x1e\xac\x01\x36\x9b\x67\x40\x60\x9e\x0d\x88\xe2\x36\x3c\x66\x9e\x49\xdc\x85\xc0\x3c\x1b\x18\xc9\xa3\xf3\x20\x7e\xf0\x2b\xe1\x13\xf1\x22\x3f\x28\x16\xf4\x50\xf4\xb9\xa0\x43\x17\xe1\x28\x2b\x7a\x53\x5b\xea\xb1\xf0\x2f\xa4\x5a\x3d\x16\xfe\xb9\x21\xf0\x2f\xfc\xef\x51\xf8\x49\x6e\x3f\x99\xa7\x45\x88\x1d\x4f\x4e\x69\x60\x1e\x92\x17\x42\xe6\xe9\x2a\xf0\x83\x7f\xc8\x3c\xe9\xe9\xcd\xe6\xd9\x1f\x32\xcf\x7a\x2a\x43\x3c\xc7\x91\x91\xe8\x1c\xbb\xae\xb8\x12\x9b\xf8\x80\x9a\xcf\xb9\xfe\x1f\x41\x8f\x49\x4b\x43\xac\x3d\x73\x63\x66\x1b\x26\xe2\x11\x7d\x7c\x27\xc1\x73\x0b\x11\xcf\xf1\x02\x9e\xf1\xf4\x4d\xe6\x3c\x1b\x98\x73\x83\x00\x27\x9e\x32\x38\x0f\xcc\xc7\xb5\x0c\x84\x79\x74\x12\x19\x56\x0b\x29\xff\xb3\x92\x48\xff\xb3\xb2\x1f\x1a\xc9\xb3\x19\x19\x21\xcf\x92\x7a\x03\xe4\x1d\x13\x45\x5c\xa5\x08\xb8\xc2\xee\x4c\x32\x8a\x26\xfa\xe5\x22\xc9\x1e\xca\x86\x2b\x17\x7a\x6d\x31\x91\xcb\x79\x57\xcc\xd2\x8a\x08\x17\x67\x66\x6c\xff\x2b\x07\xa5\x20\x93\xa8\x51\xff\x47\x1a\x8a\x34\xc6\x13\x23\x8d\xc9\x75\x67\x3e\x3e\x21\x45\x02\xc2\xb3\xd4\x0e\x39\xbd\x57\xb2\xe5\x30\xfb\xcb\x56\x09\xc8\xb8\xf5\xd8\xe4\x94\x42\xf8\x47\xe7\x91\xb1\x74\x77\xc7\xfc\xf9\x8e\xfb\x84\x4f\xb8\x70\xaf\x6b\x52\x73\xc0\x4a\xb5\xf5\x3a\x2d\x06\x24\xc6\xcb\x78\xad\x92\x92\x02\x2d\x23\xb5\x7a\x01\x6d\xa5\x07\xf1\x26\xab\x55\x2d\x0f\xa9\x63\x42\x38\x03\x8e\xac\x43\xdc\x42\x8c\xa5\x12\x8b\x29\x60\x0f\x69\x2e\x89\xa4\x92\x66\x4a\x63\x94\x38\xad\xc4\x5f\x58\xe1\xdc\x42\xd7\xc2\x68\xe0\x89\x06\x75\xf8\xe7\x02\xd7\x82\x73\x0b\x63\xe1\x9a\x58\x5c\x63\x81\xb9\xb3\xfb\x30\xfa\xb7\xfb\xa1\x89\xc9\x38\x7d\xda\x9f\xeb\x30\x19\xf1\x2f\x27\xe5\xf5\xc6\x84\x51\x11\x66\x8b\x19\x59\xd8\x5a\x0b\xe2\x58\x16\xc6\x49\x1b\xa4\x66\x5a\x53\xce\xa7\xd1\x60\x36\x0d\x68\x5a\x1a\x86\xb9\xb2\x50\xeb\x07\x3b\x78\x0a\x02\xe6\x07\x0e\xfb\xcc\x79\x14\xad\x7e\x30\xa5\xf8\x02\x09\x7c\xb9\xfe\x37\xa0\xd3\xcd\x84\x3f\x8c\x17\x50\x3a\x02\xde\xbe\x35\xdf\x35\x1f\xb3\x29\x90\xe4\x82\x1f\x6a\x1c\xd1\x4c\xab\x3b\xf0\xcf\x4e\x25\xbe\xa9\x74\x61\x51\xcb\x8e\x5d\x11\x36\x6f\xb1\x9b\x10\x7f\xda\x53\xb4\x66\x1e\xf5\x18\x5f\xb7\xe0\x03\x6d\x7a\x1e\xb1\x3d\xb6\x8d\xe8\xee\x82\xfd\xf6\x3c\x20\xf2\x10\x5b\x63\x01\x1a\x13\xe6\xa9\x0d\xcc\xe3\xd7\x5f\x42\xf9\x1b\x9e\xa7\x1d\xe1\x6f\xc2\x3c\x8b\x65\x94\xb0\xd2\x23\xf3\x04\xe1\x79\x1c\x7f\xc3\xf3\x2c\x0b\xb1\x27\xd7\x9b\x1e\x03\x0f\xe2\x3f\x57\x08\x5f\x4a\x12\xf8\x8f\x5a\x38\x2f\x6a\xf4\x79\x2e\x77\x09\x7d\xde\x4d\xf8\xbc\x25\x15\xb2\xee\x80\xc0\xba\x02\x3f\x0c\xf3\x6a\x85\x4b\x82\x54\x15\xd8\xa5\xd2\x04\xdc\xfd\xd9\xc4\x77\x46\xec\x66\x12\xb3\xec\xcf\xf3\x79\x34\x3f\xea\xf1\x79\x3e\x42\x5e\x94\x90\x12\x25\xe4\x8c\x5c\x47\x72\x2f\x96\xd4\xdb\xb5\xe2\xfc\x4d\x8b\x9e\x35\x9b\x0d\x55\xbc\x99\x61\x35\x55\xbc\x82\x35\xd2\x06\x5c\xa4\xa3\x40\x2c\x34\x20\xba\xe2\x8c\xe8\x98\x89\xc5\xf7\xa4\x62\x46\x79\x4c\xae\x8b\xa1\xbf\x07\x0e\x78\x1f\xde\xa4\xcf\x6d\x5c\x2e\x01\x5a\x36\x3a\x29\x25\xc7\xbc\x08\x26\xd3\x8e\x83\x15\xb8\xca\xaf\x69\xc9\x9a\xc4\xf4\xb8\xc2\xd6\xad\x06\x8e\xa6\xcf\xdc\x7e\xf8\x14\x4c\xa1\x48\x9c\x4f\x3b\x84\x9b\x0f\x49\xec\xb1\x14\x41\x41\x2a\x14\x9a\xf4\x11\x32\x44\xaf\x4a\x99\x3d\x8c\xe5\xd8\x9e\xbc\x8d\xa3\x0c\xb4\x98\xc7\x17\xcc\xe4\x0b\x5c\x33\x90\xf4\x2f\x26\x24\x47\x4b\xcc\xd0\x02\xfd\xe1\xed\xf7\x41\x38\x49\x04\x7b\x35\x90\xad\xf5\x1e\xb0\x05\x53\xb5\xd8\x56\xe7\xae\x5e\xfd\xaf\xbf\x90\xaf\xc5\xa6\x05\xd2\xb5\x04\xbf\x3b\x47\x11\x9a\x48\x16\xf9\xd7\x8b\x02\x4d\x98\xcd\x7e\x9a\x20\xf9\x64\x44\x66\xc8\x7e\x14\x78\x7d\x0b\x42\x13\x46\x63\x08\x4d\x44\xc1\x7c\x5c\x3b\x04\xcd\x93\xd2\x84\x87\x76\x44\xbc\xf5\x1b\x42\x13\x25\xc1\xcf\xfd\x39\x62\x24\x16\xdf\xec\x55\xd0\x40\xca\xc8\x38\x2d\x2b\xe4\x2c\x05\x4b\x8c\x18\xfd\x99\x61\x6f\x2d\x2a\x26\x2f\x59\x01\xbe\x02\x29\x30\x05\x44\x80\x8f\x7b\xc1\x99\x6c\x2b\x5c\xb1\x03\x76\xc2\xcd\x4b\xf1\x5a\xa4\xc6\x88\xe4\x45\xb4\x56\xaa\xa0\x27\x37\x5e\xa1\xfe\xc2\x90\x4a\x24\x01\x5e\x8c\xe9\xea\x3d\xc4\x8b\x71\xd6\x44\xb2\xd7\xaa\xd6\xca\xbd\x98\xba\x28\x39\x90\x33\x72\xa6\x39\x89\xe1\xd0\x03\x1c\x6a\xf4\xf5\xe5\x50\x5a\x73\x93\x08\x92\x20\xc5\xbd\x4a\x28\x0e\x7e\xef\x8f\x28\x41\xb4\xc7\xbc\xd3\x50\x2e\x84\x95\x60\xb8\x10\x0e\xdc\x04\x37\xa9\x02\x0e\x14\xfe\xf3\x92\x2f\x9e\x97\x1e\x4d\x70\x86\xdf\xe3\x27\xff\x78\xbd\x54\x76\x8b\xe6\xb9\x17\x29\xe9\x11\x20\x63\xfc\x77\xf0\x8d\x5f\x92\x3a\x05\xe4\xd9\xab\x78\xcc\x6d\xb0\x13\xfd\x01\x8d\x51\x51\x81\x7b\x7a\xb1\xe6\x8a\xb8\x2e\x3e\x77\xd9\xbe\x5e\xe2\x19\x3f\x1f\x58\x17\x7d\x0e\xec\xbe\x5e\x68\x4f\x10\xeb\x61\x53\x89\xaf\xdc\xe3\x35\x29\x38\x35\xcd\x2a\xbd\x0c\x43\xc9\xe5\x92\x2a\x5e\x6e\xc0\x89\xee\x05\x81\x42\x17\xb6\xcb\x56\x72\xd7\xce\xb8\xad\x1c\xb9\x62\x45\x96\x39\x98\x0a\x3c\x23\x80\x36\x0f\x3e\x5b\x48\x0f\x4f\x7a\x38\xbe\xe7\xa2\x36\xf7\xb8\x42\xdf\xad\xd9\xc7\x0e\xc3\xad\x37\xc1\x5e\xef\xb1\x09\x81\xb3\xbd\x88\xe4\x27\xa6\x79\xc3\x15\x8c\x9a\x42\xeb\x00\xa0\x97\xea\x35\xd8\x7b\xc4\xca\xa5\xf2\x52\x5e\x1a\x92\x98\x10\xba\x60\xae\xb0\x5c\x2e\x5e\xd0\x4d\xf2\x14\x47\xfe\x94\x0d\x4f\x8d\xf2\xef\x45\xf7\xcf\x73\x41\xcb\xc1\x24\xd5\x8f\x39\xfe\xd4\xc6\xdd\xbe\xf7\x1b\x1a\xc0\xd2\x71\x1b\xb6\x82\xff\x1a\x82\xf7\x6a\x2f\xfa\xef\xd5\x90\x2d\xb5\x57\xa0\x91\x10\x1b\x0e\xcb\x99\xdd\xc4\x7e\x2a\x13\xc7\x2c\x12\xac\x1d\x6c\x98\x8b\x63\x22\xd1\xde\xdd\x20\xb8\x4d\x17\xf6\xee\x5b\xd1\x97\x84\x3e\x9f\xce\xf6\x10\x9e\xc5\x9f\x8b\x3e\xa6\xe6\xf7\x79\x0b\x91\xae\xf1\xe7\x63\xd6\x5d\x4c\x78\xaf\xe0\x87\x5a\xd8\x74\x55\x22\x9b\x91\xe5\xcf\x5e\xe6\x3a\x51\xe1\x54\x14\xe2\x65\xa6\x28\xaf\x83\xd1\x9b\x28\x92\x0d\xa4\xd3\x68\x71\x36\x90\x39\x34\x1b\x28\xac\x00\xc7\xeb\x10\x29\xd7\x3c\xf9\x2f\x03\xcb\x3f\x64\x83\x20\xa6\xc2\x38\x9f\xd4\x8e\xef\xbf\xd6\x11\x92\x01\xb8\xe1\x8b\x07\xda\xf9\x0f\x9d\xd2\xb5\x48\xcf\xb8\x47\xd7\x75\xcf\xa9\x3f\xbc\x20\x24\x0f\xf0\xf7\x76\xa5\xbe\x32\xe6\x86\xdf\xda\x00\x94\x0a\xe9\x62\x6f\x72\x3c\xd2\xc0\x10\x87\x75\x38\xcd\x4e\x5d\x15\xef\x64\xc3\xc3\x18\xb3\xa1\x69\x85\x12\xff\x6d\x87\x90\xd3\x25\xdc\x76\xe4\x1a\xfd\x11\xe1\x08\x42\x3b\x09\xe0\x08\x26\x51\x2a\x00\xbd\x7e\xda\x1c\xd5\x37\x5c\x64\x74\x5a\x9b\xc8\x2e\xa6\xb6\x05\x05\x9b\x26\x9a\x17\xc3\xcf\xde\xc9\x03\x4e\xce\xac\x62\xbb\xff\x38\x76\xd1\x12\x4b\xe7\xac\x1b\xa6\x27\xe7\x77\x6c\xd5\x62\xea\x5a\x30\x79\x48\xeb\x6e\x2d\x67\xbc\x39\xda\x97\xcf\xca\x40\x9b\xac\x05\xde\x69\xab\xeb\x37\xf1\xe3\xe1\x0a\xf8\x0f\x6c\x14\xf8\x4f\x1c\xe2\x69\x38\x6f\x32\x06\x73\x62\x97\xd5\x6d\x8b\xec\xc9\x3b\x6c\x76\xad\xd4\x60\x60\xca\x79\x83\x4e\xa9\x95\x49\x85\x3c\x38\x11\x8f\x81\xc0\xf0\xff\x91\x46\x89\x4d\x20\x4f\xae\x95\xbc\x0c\xd3\xe7\xb1\x09\x95\x5b\x6c\x07\x97\x0f\xe9\xe8\xc9\xe8\xd2\xce\xf8\x8c\x96\xfe\xe9\xd1\xd4\xca\x87\xd7\x96\x6c\x96\xbf\xc5\x7a\x6b\xe8\x17\xbb\x06\xee\x44\x6b\x03\x77\xa8\x01\xbf\x45\x88\x7e\x2b\xf8\xf2\x2a\x02\xbe\x3f\xd1\xae\x89\x88\x08\xe1\xcd\xcd\xef\x6e\x03\x7e\x0b\x7c\xb3\xda\x64\x9e\xa0\xcf\x71\x3d\xa1\x3d\x3a\x48\x7b\xa2\xac\x18\x1f\x32\xcf\x66\x30\x00\xcd\xa3\x3a\xc6\x04\x26\x0a\xf8\x17\xb9\xde\x81\xb9\xf0\x38\x2f\x9a\x0d\x8f\xf3\x4f\x27\xd0\xb2\xbd\xf1\x01\x97\xca\x15\x23\x8a\x75\x52\x83\xbc\xf9\x66\x63\x0d\xaf\x35\xd4\xf0\x97\xb4\xe0\x94\x16\xac\xd3\x82\x02\x6d\x0f\x2d\xcd\x68\xb5\x51\x5a\x5a\xcd\x69\xb5\x2a\xb3\x41\xa5\xa9\xe1\x55\x4c\x78\xb8\x5d\x6e\xaf\xe1\xe5\x6c\x58\x98\x05\x58\x6a\x78\x20\x56\x8a\x23\x69\xe7\xc2\xff\x05\x1c\xce\x81\x82\x69\x2e\x69\xa0\xb0\xaa\x35\x18\x1a\xe2\xce\xc8\x35\x8a\x36\x2a\xf8\xb5\xc7\xdb\xaf\x55\x6f\xfb\x69\xbb\x27\x9d\x4e\xf1\xc0\xb7\x0b\x41\x94\x07\x7e\xdb\x0d\xd4\x78\x7c\x93\x72\x23\x4f\xc7\xa6\x8c\x5b\x31\x88\x7b\xf7\xda\x66\xf0\x1c\xa0\x67\x49\xc4\x48\x91\x06\x09\xf3\x9a\xe4\x55\x38\x66\xf1\xef\x88\x3b\xd2\xd8\x6f\xc1\x96\xa0\x93\x89\xab\xd0\xf7\xf2\xa6\xa7\x50\x48\x6d\x4e\x89\x4a\xa1\x75\x4c\x4a\x8a\xc2\x66\x4b\x2a\xe5\x6d\xba\x30\x95\x45\x63\x89\xc6\x09\xf4\x9a\x78\x9c\xb4\xaa\x60\x4b\x79\x56\x6a\xc2\x45\x59\x9a\xde\xfe\xf8\x93\x8d\x43\xeb\x0c\x00\x31\xc6\x10\x5f\xfb\xf8\xcb\x90\x07\xaf\x7a\x90\x51\x10\x5a\x0e\x2a\x5a\xbc\xea\xb9\xa6\x1b\x96\xd9\xce\xbe\x67\xda\xf5\xe3\xc9\x53\x4e\x4e\x9c\xd5\x6d\xea\xae\xe1\xaf\x24\x3f\x71\xe0\x4e\x84\xcc\x37\xad\xb6\x70\x50\xe7\xde\x25\x75\x1d\xc1\xf2\x85\xb9\x40\xa6\x8c\x07\x37\xcb\x0b\xf6\xb4\xc7\x37\x3b\x27\x4e\x6c\x7b\x61\x16\x28\xfe\x7a\xe2\xe1\xc3\xf0\xcd\x89\x2b\x12\x81\x72\xc7\x76\x78\xa8\xe6\xb9\x7d\xa0\x00\x50\xb0\x4f\x62\x61\x4b\xbf\xcd\xf9\x35\xe1\xa7\xd9\x22\xaf\x7c\x92\xf0\x53\x3a\xc4\x77\x44\x72\x4d\x09\x3f\xed\x2d\xf8\xa3\x78\xc2\xd7\xac\xd6\x26\xb6\x6e\x3e\xae\xb7\x24\xcc\x83\xf9\xa6\x4f\x90\x73\xdf\xa1\xcf\x77\x10\x5b\xb7\x37\x96\x55\xb2\x5b\xf0\x37\x2a\xb8\xee\x1e\xff\xba\x88\x57\xda\x05\x9a\x7e\x64\xdd\x63\xfe\x75\x71\xc3\xa5\x47\xd6\xc5\xb5\x95\xde\x26\xf0\xe7\x88\xf0\xef\x16\xe4\x41\x52\x52\x60\x1e\x9c\xbb\x3a\x99\xc0\xdf\x47\x80\xbf\x0f\x99\x27\x39\xb9\xd9\x3c\xe7\x08\x3c\x39\xa2\x1e\x95\x29\xf0\xf7\xe4\xe4\x26\xf3\x8c\x22\xf0\xf4\x11\xf4\x28\x2d\x99\x27\x25\x25\x74\x1e\xd8\x01\xd7\x7a\x0a\xc0\x33\x15\x74\x13\xee\xc7\x52\xf0\xfd\x58\x4a\x1b\x26\x3c\x78\x3f\xd6\x11\x8d\x1d\x45\x64\x4d\x1f\x71\x2c\x8e\xdc\x34\x1f\x07\xa9\x54\xaa\x33\x95\x3e\xd9\xf8\xc4\xd1\xd4\xb6\xf8\x01\xac\x57\x3f\x06\xc6\x85\x84\x0f\xd8\xbc\x3a\xf2\xb2\x20\xa5\x20\x05\x7c\x97\x92\xe5\x7f\x20\x08\xf3\xb2\x10\x98\x17\x72\x82\x6f\x0d\xbf\x3c\x48\x3d\x97\x9a\x2d\x02\xe4\x87\xff\x00\xd2\x03\x93\xc9\x3e\xe6\x0a\xfb\xf8\xa9\x00\xeb\x2d\xb4\x8f\x45\x5c\x2f\xf4\x79\x5f\xe1\x73\x4e\xf8\x9c\xd4\x89\x22\x30\xe5\x86\xc0\x84\xb0\x22\x93\x05\xf0\xf6\x64\xe3\x3d\xec\x8b\xc3\xcf\xae\x12\x74\x9d\xb3\x82\x64\x0c\x70\x39\x40\x1d\x14\xeb\x4d\x69\xb1\xee\x42\xa9\xd4\xaa\x2a\x9e\x95\xc9\x65\xa5\x3c\x90\xcb\x39\x35\x83\xcb\x1c\x62\x8e\x90\xe9\xaf\x3b\x2a\x34\xa7\x88\x11\xac\x3e\xb1\x0a\x55\x87\x9b\xee\x9b\x13\xe0\x67\x13\x6e\xb8\x6f\x74\x80\x75\x49\x6c\x39\xae\x79\xf8\x62\x83\xef\x38\xdd\xb5\x01\xf0\x42\x4d\xaa\x17\x1a\xef\xb1\x7d\xb8\x5e\xc8\x92\x6f\xe9\x8d\x30\xc4\x4a\x6c\x51\x51\xd6\x52\x3e\xca\xa2\xe6\x24\x48\x73\xd4\x93\xa4\x60\x0d\xad\x90\x49\x48\x5a\xf0\xa5\x8c\x40\x9d\x53\x7f\xc1\x71\x21\x3f\x38\x37\x90\x23\x4c\xbe\x9a\xe5\x09\xe7\x82\xe2\x5d\xee\x5d\xf1\xbb\x82\xb9\xc2\xf1\xe4\xa7\xad\x49\xc6\xb0\x1a\xdc\x69\x78\x5f\xc8\x19\x7e\xbf\xe1\xe9\xd0\xa4\x61\x4f\x97\xc7\xc6\x63\x04\xec\x4f\x1c\x5d\x21\xe2\x16\xdf\x29\x08\xf6\x67\xbf\x50\xfb\x13\xdf\x28\x04\xf6\x54\x98\xa7\x36\x30\x4f\xc0\xfe\x0c\xf1\xeb\x0a\x77\x13\x15\x81\x79\x04\x39\x04\xf0\x95\x55\xb3\x79\x82\xf0\x04\xec\xcf\x66\xf0\x84\xde\x89\x08\x72\xe8\x71\xf0\x04\xe7\xd9\x88\x38\xee\x66\x4a\x8f\xed\x08\x4b\x0f\xcb\x58\xcb\x2c\x0b\x43\x91\x08\x30\xff\x7c\xe4\x2e\x5f\x98\x6f\x23\x91\x44\x74\x60\x42\x31\x0e\x85\xeb\x16\x32\xdf\x66\x90\x4b\xe4\x1a\x1d\x00\x2c\x70\xff\xc2\xd9\x02\xb0\xe1\x71\x5c\xf3\xd9\x04\xf8\x90\x6e\xf1\x23\x39\x03\x2d\x05\x3b\x38\x5f\xa0\xf5\x01\xe8\xf3\xe7\xd9\x56\xc2\xf3\xc4\x9f\xe7\xf2\xeb\xe9\xdc\x08\xb2\x7e\xab\xa6\xfe\x36\xbb\x3d\x80\x17\x92\x3b\x4d\xd6\xee\x1f\xea\x7f\x0f\x0b\x0b\xc1\x8b\x10\x1b\xb3\xc7\x1f\x1b\x13\x9c\x47\xa1\x08\xd8\x72\xc2\xfd\xc9\x31\xff\xfd\x89\x7f\x9e\x26\xf8\x15\xe6\x99\x1d\x88\xb1\x09\x89\xcb\x41\x87\x29\x8e\x06\xea\x04\xb5\x92\x91\x86\xc6\xe5\x08\xb5\xba\x08\x1f\x6d\x13\x88\x03\xfc\xab\xe9\xda\xc4\x57\x26\xdc\xe7\x57\x0a\x7c\xb4\xf7\x23\xbe\x05\x71\x9e\x01\xfe\x79\x90\xcd\x92\x28\xf8\xf4\x9a\xcd\x33\x9a\xf8\xf4\x2a\x05\x9f\x9e\xef\x7f\xcd\xb3\x27\x30\xcf\x42\x2a\x4f\xf4\x3d\xe2\x89\x80\xea\x96\xca\x00\x24\x21\xbe\x47\x3c\xe7\x12\x82\x17\x61\xce\x85\x20\xe4\x9e\x5e\xf5\x9e\xca\x40\x71\x41\x3e\x47\x01\x6c\x66\x91\x5a\x3c\x6a\x34\x4a\xa1\x90\x9b\x29\x0e\x47\xf4\x00\x7f\x44\x0f\xce\xa7\x13\xd2\xbc\xb0\xa6\xd8\x16\x30\x9f\xfa\x4b\xed\x7c\x05\x7f\xf8\x2e\xfa\x21\xf7\x13\x29\xb2\xf3\x60\x29\xbb\x74\xff\x21\x4a\xac\x31\x35\x13\xd9\x44\x58\x77\x68\xe3\x75\x59\xe5\x26\xb5\x3a\xa6\x94\x57\xab\x69\xbb\xd9\x94\x50\xca\x9b\x2c\x34\x25\x8d\xa2\xa2\xca\x78\x36\x95\x22\xa6\x58\xa5\xd8\xb3\xc6\xaf\xec\x04\x1c\x17\xa2\x13\x4b\xd2\xa4\xe6\x05\xa9\x3c\xe5\xc2\x4e\x0c\x10\x92\x25\xb3\x6f\x9e\x1d\x84\xdb\x41\xba\x0b\x5e\x4d\x08\x67\x3b\x1f\x1f\xb7\x6c\xdd\xec\x3b\x9b\x3f\xcb\xe0\x64\x2e\x29\xbc\x6b\x8b\x3c\x3a\x8f\xbe\xd4\xbd\x64\xe5\x73\xdd\xcb\x96\xaf\xe1\xda\x2d\x59\xb2\xf7\xe3\xba\x71\x83\x1a\x4e\x5d\x81\xa7\x0e\x9c\x4d\x7a\x42\xd9\xff\x79\x66\xab\xef\x9f\x71\x43\xff\xb9\x31\x76\xcc\x3f\xc2\x7d\xee\x00\x62\x3b\xe1\x7a\x9d\x31\xe8\x4d\xba\x79\x93\x24\x1e\xbd\xa7\x9a\x0f\x8b\x8f\x8a\x8f\xaa\xe6\xf7\xc5\xbf\x12\x4f\xb7\x8d\x07\x6c\x8b\x78\xc0\x68\xe3\x81\x52\x12\xaf\x8e\x57\x73\x7a\x86\x73\x56\xf3\x9c\x21\x70\xd9\x9b\xda\xb4\x28\xb1\xc8\xb0\x71\x26\x22\xe2\xd7\xa4\xd1\x8a\xd4\x93\x95\x93\x19\xa8\x53\xcc\x89\x71\x5a\x39\x62\xb1\xe2\x1c\x76\xe6\x92\xff\xb6\xc1\x31\x5f\x39\x5a\xa4\x2a\x3e\x67\xce\x1c\x01\xfc\xab\x6f\xee\xdf\xb1\x72\x35\xfc\xbc\x7f\x9f\x4e\x5d\xba\x4f\x9e\xe1\x58\x1a\xd1\x36\x6a\x70\x2d\x38\xb5\xf0\xed\x91\xec\xd8\x5e\xed\x92\x33\xf4\x55\xa7\xcf\x2e\x5d\x50\xff\x9a\x4b\xf7\xec\xf0\xce\x5d\xe0\xe2\x29\xf4\xd6\xa7\xe0\x1b\xc3\xc5\x18\xb2\x57\x49\xed\x4f\x2b\xae\x55\xc9\x1a\x91\x3d\xc3\xaa\x29\xb5\xa9\x9a\x57\x1b\x48\x21\xd3\xa6\x0d\x65\x12\xc5\x1a\xaf\x62\x10\x59\x8c\x2b\x17\xf8\xe1\x03\x1e\x66\x4d\x92\x6f\x65\xee\xaf\x17\xbe\x5c\x07\x7f\x38\x01\x15\x34\x93\xf0\xe4\xd4\x75\x25\x9b\x37\x6d\xc6\x35\x7b\x7f\xd8\xbb\x6d\xc5\x4f\x73\x19\x70\xa1\x7b\x5f\x38\x6a\x86\x9f\x2e\x96\x23\xba\xb0\x53\x1e\x2a\xd9\x1b\x16\x86\xe8\xc2\x14\x85\xc9\x41\x1d\x8b\xa8\x43\xc7\x4a\xcb\x91\x6d\x45\x89\x17\x35\x4d\x0b\x90\xb5\x25\xc6\x9d\x4b\x0b\x9a\xd5\x3e\xf1\x97\x20\x23\x75\x4f\x10\x4a\x65\x51\xda\x7b\x4c\xc7\x04\xdf\x87\x31\xa4\x08\xd9\xf2\x8d\x0b\xff\x58\x4d\x6a\x90\xc5\x70\xc3\x7a\x76\x99\xbb\x75\x4d\xef\xfa\xce\xd1\xd3\x7a\xb0\xd7\x3f\x3a\x76\xa4\x62\xc8\x95\xd7\xde\x86\x07\xcf\x0c\xad\x4a\x9f\x22\x07\x7b\xa7\x2c\x04\xf6\xaf\xee\xcc\xfa\x94\x0a\xc4\xda\xcd\x10\xf1\x84\x6f\xf2\x8d\xb8\xd6\x35\x27\x67\x38\x53\xe8\xe6\xa6\x0a\x69\x5b\x08\x2d\x46\x4f\xae\x3b\x13\x63\x29\xb0\x7d\xec\x0c\x01\x2b\x27\x46\x4b\xc1\x8a\xe2\xc1\x77\x2f\x7c\x09\xaf\x3c\x39\x75\x7d\xc9\x96\x4d\x9b\x01\xc4\x98\x39\xb8\x2c\xf6\x06\x64\xf7\x7e\xd8\x04\x3f\x4f\x8b\xf8\x41\x7b\x43\xf0\x13\x19\xc4\x8f\x44\xc0\xcd\x23\x95\xd9\xc8\xca\xcd\x8b\xc2\x10\xc4\x10\xbc\x10\x5b\x34\xc6\x1a\xf5\xe2\x44\x29\x98\xd7\xad\x3b\xc1\xcb\xca\xf5\x8b\x7f\x5f\xe5\xc7\xcb\xa6\x39\xdb\x8b\xba\xf7\x58\x54\x3e\xe8\x59\xa6\x72\x59\xec\x7b\xa4\x38\x5b\xc3\xa9\x77\xe0\xce\xb7\x05\xcc\x3c\xf7\x13\x48\xfc\x76\xfc\xb0\xe9\xb7\xb0\xce\x50\x82\x60\x7c\x87\xd4\xba\x46\x58\xc1\xb5\xae\xf5\x1a\xa3\x58\xe3\x9a\x0d\xf4\x3d\x21\xf5\xad\x71\x53\x0f\xb1\xf0\x1d\xed\x72\x32\x42\xc5\x13\x03\xb3\xe1\xda\xce\xe9\xf0\xbf\xcf\xc1\x0c\x5c\xdf\xda\xf7\x2e\x5c\x94\x02\x22\x84\xfa\xd6\xcc\x20\x60\xf8\x33\x0b\xec\xc6\xf5\xad\x7d\x3d\xc0\x3c\x5c\xdf\x1a\x94\x0b\xf5\xb5\xb9\x6d\x92\x31\x54\x1c\x95\xe6\xb5\x99\xc2\x6b\x78\x8b\x49\xe3\xd5\xc4\x54\xf1\xba\x08\x27\xa3\x61\x9b\x96\xd8\x0e\x2b\xb0\x66\x0a\x29\x75\x19\x8f\x96\xd9\xce\xb0\x92\xa0\x1c\xb1\x84\x98\xbf\x29\x45\xd3\xa2\xdb\x8b\xe8\xec\xc1\xdd\x6c\x25\xd3\x06\x54\xa4\xc6\xdb\xe2\xe2\xe2\x0d\x6e\xa3\xf4\xd1\x12\xdc\x75\x33\xe8\xc3\x8e\xe9\x4f\xe5\xeb\x2f\xa9\x32\x2a\xce\xe4\x7b\xc5\x62\xdc\x94\x58\xbb\x8e\x7b\x89\x4b\xa3\x12\xb0\x3d\xae\x31\xf6\xe4\x75\x1a\x99\x57\xe6\x28\xe5\xc3\x14\x32\x9d\x9b\xa2\xa2\x83\xc5\xeb\xc8\x2d\x64\x00\xda\x60\xe5\x35\x6b\x76\x68\xad\xb3\xff\x59\xcb\x6e\x6a\x1f\xe7\xc9\xfa\xe2\xae\x9e\xdc\xa8\xac\x22\x5d\xea\xff\xac\x6b\xe7\x01\x73\xe7\xe9\xdf\x51\xb5\x2e\xfb\x2d\xb4\xbc\xdd\x98\x03\x83\x1e\x7f\xb7\x3a\x40\xac\x0f\x6c\xa4\x22\x70\xb5\x4a\x49\x98\x3e\xac\x0a\x71\x6f\xcc\xda\xc2\xab\x9a\x50\xbf\xc0\xcb\x74\x34\xdb\x8c\x97\x39\x03\x4c\xc2\xc0\xde\xd8\x09\x2f\x5f\x80\x73\x83\xec\xab\x1d\xf8\x10\x7e\x54\x37\xce\xbc\xbf\xed\xc8\x8d\xfd\x99\x5a\x08\xe1\xc4\x4f\x82\x6c\x0b\xca\x97\xcf\x7d\x38\x77\x39\x88\x15\xce\xa1\x47\xac\x81\xad\x46\xb4\x8f\xce\x84\x14\x9d\x43\xa9\x14\x28\x95\x8a\x2a\x5e\xc9\x00\xdd\x23\x05\xe0\x49\xa9\x73\x8c\x46\xca\x45\x54\x61\x39\x30\xe5\x03\x0c\x1b\xf3\x05\x54\xbc\xf7\x2b\x48\x03\x86\x5f\x73\x7c\x7f\x27\x31\xe9\xf0\x81\x6f\xea\xcf\x9b\x4b\xd6\x3d\xbf\xbd\x61\xf7\x37\x80\x05\x61\x37\xef\x37\x80\x19\xbb\xc0\xea\x39\xfe\x9a\x7f\xbf\x93\xfa\x6a\x71\x54\x92\x37\xcc\x62\x2e\xe7\x2d\x14\xab\x97\x6a\x34\x11\x48\x29\xd6\x49\x63\x48\x34\x58\x80\x57\x85\x14\xd3\x42\x84\xd6\xa4\xfa\x3f\xb9\x32\xcf\x15\x2e\xcd\x63\xa2\xfd\x57\xe6\xf4\x05\x23\xdb\xf5\xc0\xc8\xe5\xeb\x16\xfe\xbc\x01\x57\x68\x52\xe7\xc2\xcc\x04\xfa\xf6\x3d\xad\x75\xc7\xa6\x67\xb6\x15\x17\x75\x7f\xb6\xb7\xac\x7d\x6d\x1d\xff\xd6\xe9\x77\x41\xff\x57\xab\x07\x76\x05\xce\x8f\x1e\x38\xbb\x6f\xa1\x0f\x7c\x03\xaf\xff\x38\x69\xc8\xcc\xdb\xe2\x7d\x00\xec\xc7\x6e\x44\x76\xba\x91\x8a\x44\xd6\x82\x59\x6f\x41\x8a\xbb\x8e\x93\x49\x65\x3d\x79\xa9\x9d\x75\x94\xf1\x0a\x7c\xf3\x9d\xe9\xcf\x64\x14\x72\xc4\x10\x93\x90\x72\xd8\xf1\x08\x84\x5a\x11\x84\x6d\x05\x04\x29\xbb\x71\xde\xc3\x17\x40\x8b\x98\x87\x43\x3d\xb4\x0d\x6e\x2c\x28\xdc\x05\xd2\x2f\x7c\xf1\x13\xfc\xec\xcc\xf6\x23\x43\xfb\xee\x7a\x99\x7e\xe1\x00\xfc\xee\x84\xcd\x77\xf4\x22\x48\xcc\x3a\x3a\xf9\x1c\xc8\xde\xf7\xc5\x27\xbf\xff\xf3\xe5\xac\x69\xff\x0a\xf4\x6f\x14\xfb\xaf\x28\x29\xaf\xb7\x85\x54\x52\xc5\x17\x48\xc7\x4a\x0f\x4a\x5f\x97\xb2\x38\x3b\x6e\x0b\xfa\xe5\xaa\x94\xd3\x31\xe8\xd8\x8a\xfb\x48\x23\xb9\x43\x3f\x9a\x98\x90\x88\x73\x01\x45\x3f\x35\xfa\x66\xbf\x85\xf7\x1f\xb6\x4c\xa2\xb7\x15\xf8\x36\x25\xd3\x43\xda\xfb\x72\x92\xf0\x2d\xc5\x4d\xd0\xf1\x26\xe8\x7d\x13\xed\x59\x67\xb4\x67\xc7\x10\x6f\x92\x22\x0d\xa8\x85\xd7\xe2\x40\xb3\x3a\x94\x0e\xa5\x45\x6b\xa1\xaa\x78\x8b\x51\x2b\xab\xe2\xb5\x6c\xb3\xba\x9d\xf8\xe2\x25\xc3\x48\x6a\x1c\x02\x9c\xbc\x99\x43\x9a\x30\x60\x8a\xc6\x3d\x19\x0a\x80\xe0\x75\x88\x7f\xaf\x1a\x46\x73\x25\x40\x51\xfe\x54\xcb\xfb\xb5\x00\xbc\xfe\xe9\xf7\x7b\xe0\xd9\x8f\xaf\x5d\x6f\xa1\x61\x64\x92\xbe\x1f\x82\xbe\x69\x2d\x46\xac\x66\x36\xd7\x0c\xeb\xf2\xc6\x8b\xf0\xf7\x07\xb0\x11\x4e\xfe\x14\xd0\xbf\x9e\xe9\x13\x9b\x96\x30\x62\x03\xc2\x49\x2c\x82\xed\x12\xf1\x29\x16\x23\x3d\x22\xdc\x11\xee\x40\x68\x09\x07\x05\xe1\x3d\xc2\x5f\x0f\xbf\x1a\xce\x32\xda\x70\xa0\x66\xc3\xc3\x29\x95\x0a\x49\x18\x9d\x8a\xc5\x7c\x42\x0c\xb8\x6f\x5e\x3a\xa3\x0a\x97\x39\x09\x76\x54\x12\xca\x17\xc4\xba\x48\x93\x1d\x3a\x26\x5a\x28\x3a\xe3\xcf\xfb\xc3\xdd\xde\x58\xf0\xfd\xa7\x3f\x9d\x6b\x98\x32\x16\xe4\x53\x8d\x1f\x5d\x8f\x80\x3f\x28\x33\xfa\x17\xdd\x9f\xf4\x74\x7e\x52\xfe\xe2\x15\xde\x0f\xc6\xbd\xd8\xed\xef\x3a\xf8\x96\xe9\xe0\xb6\x2d\x67\xed\x91\x53\x2b\xcf\xdc\x39\x72\xb9\xcd\x00\x3e\xe5\xb3\xe2\x36\x37\xe2\x7a\xf3\xeb\x46\xcf\xaf\x7c\xfb\x65\xb2\xb7\x8d\x45\x48\xef\xc7\xf5\xf7\x4d\xd8\x37\x2a\xd4\xdf\x97\x19\x0c\x08\xbf\x06\x06\x57\xcc\x57\xc8\xec\x54\xc8\xdd\x53\x48\x19\x7e\xc1\xa7\x28\xb8\x48\x43\x2a\xf2\x8f\xf0\xbc\xf6\x42\x5e\xaf\xc4\x30\x9b\x25\x27\x4b\x0f\x34\xfe\xda\xfc\xbe\x1b\x17\xde\x30\x7d\xc9\xc9\xda\xf7\xe7\xc6\x62\x5b\xb5\xf1\x2f\xb4\xee\x3d\x22\x77\x52\xbc\x56\xb5\x42\xa3\xd5\x94\xf2\x3a\xa9\x56\xab\xb4\x9a\x4c\x0c\xae\xb7\xa5\x52\xda\xfd\xe5\x98\x71\x1a\x69\xb0\xf8\x45\xb0\x98\x08\x70\x11\x73\x55\x08\xec\x60\xb7\x47\x54\xd9\x4b\xcb\xec\x09\x20\xa5\x0b\xbc\x06\x33\xe0\x6d\x70\xe5\xbd\xae\xef\x65\xb7\xfc\xea\x70\xd1\x22\x1b\x3b\x5f\xa1\xca\xe9\x52\xd7\xf0\x60\x30\xfb\x7c\xc3\x82\xe7\x96\x84\x29\x85\x3e\x01\xdc\xf3\x92\x81\x68\x0f\xf3\xbc\x91\xee\xd8\x6a\xdc\xff\x47\xa6\x36\xd4\xf0\x5a\x35\xe2\xef\x88\x35\x5a\x15\x32\x96\x8a\x0a\x2d\xe8\xec\xe7\xed\x8f\x69\x17\x60\x0d\x72\x78\x29\xf3\x7f\x74\x0e\x18\x5b\x12\xbd\x72\x41\xdf\x54\x4f\x84\x2b\xce\x6d\xc8\xc5\x4d\x04\xa6\x6c\x7a\x7c\x13\x81\x98\x9d\x73\x91\x38\x4a\x1f\x00\x6f\xe4\xbc\xb9\x1d\x6e\x09\x69\x26\x40\x53\x5b\x91\xad\x84\x6b\x41\x1b\x10\x9f\x88\xf4\xea\x68\x8b\x81\x63\x95\x94\xd2\x81\xd4\x1a\x3b\x13\xbc\x0d\xb1\x92\xdb\x42\x5c\xa4\x89\xf4\x27\x12\xf3\xd1\x73\x49\x65\x0c\x41\xfc\x6c\x05\xc9\xcf\x81\xcb\xa0\xa5\x6f\x70\x4e\xec\x85\xfd\x33\x97\x76\x5d\x14\xff\xbc\x43\xd5\xda\x1d\xde\x36\x21\x9f\x2b\x7c\xf8\x1e\x93\xf6\xe0\x9d\x75\xbb\xf2\x9e\xdb\x37\xb9\xae\xfd\x0b\x27\x5a\xc2\xcd\xe9\x55\x31\x3d\xda\x7a\xa3\x0b\xdb\x10\xfa\xf9\x0e\x9d\x83\x3b\xa4\xde\x12\xa2\x1f\x8f\xd6\x4c\x85\x87\x2b\xcb\xf9\x70\x9d\x9e\xd2\x99\xa9\x98\xf2\x40\x94\x64\xc0\x57\x2d\xf8\xd6\x11\x91\x07\x6b\x14\x02\x5c\x3f\x8b\xe8\x3b\x58\xb7\x90\xf8\xaf\x34\x71\x8b\x15\xfa\xea\x8c\xd9\x20\x3e\x5a\x6b\x8d\x2d\xa8\xb4\x8f\xbf\x05\x9c\xdf\xf7\x90\xc7\x31\x45\xa3\x3b\xed\xb4\xb6\x54\x00\x97\x3b\xab\xa3\x63\xda\xad\xa9\xc9\x9f\x99\x56\xaf\x2a\xb9\xb2\xc3\x1b\xe7\xf0\xec\x5a\x25\x14\xb5\xcc\xd8\xb1\xb4\xea\xe3\xb2\xa7\xe0\x97\xc5\x91\x19\x69\xa3\x57\xd3\x53\x7d\xf5\xb7\xff\x0a\xb9\xf3\x25\xf2\x31\x89\x0a\xed\x91\x60\xc4\x55\x44\xa5\x5a\x9d\xb6\x8a\x67\x75\x3a\x25\x25\x53\x29\x55\x88\x9d\x19\x68\x23\x65\x0c\x36\x4b\x10\x18\x2f\xc9\x6d\xf6\x7b\x6b\x88\x42\x8d\x1d\x36\xe4\xf2\x87\x38\x6d\xc4\xe6\x09\x05\x7f\x24\xfd\xd1\xc1\xdf\x40\xa1\xc3\xbd\xa4\x7b\x05\xa4\x89\x82\xd0\x00\x03\xb3\x39\x20\xd6\x50\x13\xfa\x1b\xf4\x47\xe7\xd0\xe5\xd5\xeb\x00\xcd\xb0\x7a\x46\x8a\x56\x97\x23\x35\x8c\x15\xf2\x40\x88\x90\x0e\xde\x3f\x62\xed\x47\xa4\xb6\x90\x5e\x07\x0d\xdd\x40\xb7\x2e\xbd\x5a\xb4\x73\x64\xb6\xd5\x64\x35\xe9\x79\xc0\x7c\x08\xe6\x9b\xbe\x54\x67\x15\xc1\x7b\xfe\xd6\x07\x81\x7a\x98\x1f\x09\xd5\xf5\x0d\x78\x5d\xc4\x57\x35\x3d\xd1\xc1\x47\x7f\x30\x3f\x6e\x5d\x81\xcc\x85\xee\x5f\xa1\xc5\x31\x7f\xb2\x5f\xda\x30\xb0\xb7\xc7\xd8\x5d\x97\x55\xac\x1b\x0c\x3e\x0d\xa9\x92\xc9\xbe\xbc\x78\x9d\xfe\x1d\x4e\xda\xba\x0c\x52\x62\xb5\x4c\x2a\xa4\x5e\xa6\x9e\x4a\xf7\x86\x33\x4a\x95\x12\xe9\x51\x2a\x95\x54\xa7\xd3\x22\x5e\x40\x61\xa1\xf7\x98\xbb\x36\x3f\xce\x9b\xe1\x1b\x1d\xb1\xf2\x6f\xdd\xdf\xf6\xf5\xdf\xb5\xf5\xfd\xc6\xfd\x4d\x85\x70\xd5\xd6\xea\x15\x58\xd0\xd0\x00\xde\x78\x05\x7c\xd8\x40\x68\xf6\x4b\xb4\x6e\x16\xa9\x6b\x91\xe0\x35\x2a\xd4\xb4\x5c\x65\xd6\x48\xb5\x12\x5c\x87\x46\x2b\xe1\x70\xb7\xca\x0f\x33\x2e\x67\x20\x53\x4f\x8f\x73\xe9\x05\xc7\x98\xd1\xed\x71\xe1\xb0\x5e\x72\xed\x0b\x3c\xdc\x0d\x80\xac\xb9\x16\xc6\xf3\xf1\xef\xfe\x08\x3f\x1f\x03\x87\xc2\x4f\xe8\xe1\x32\xf8\x1e\xbb\xe0\xa9\x4b\x83\x4a\xf6\x97\x3e\xe8\xc0\x44\x3c\xbc\xc1\xa6\xc6\x3c\x89\x9b\x32\x21\x3e\xe3\x40\xf4\x95\x86\x23\x57\x4d\x0e\x43\x9a\xc2\xcd\x44\x25\x95\xf1\x51\x46\xab\xa4\x8c\xb7\x1a\x0d\x86\x10\x13\x29\x53\x74\xc4\x05\x8b\xc5\xa3\x73\xc0\x98\x63\x0a\x00\xc9\xe7\x6f\x13\x68\x45\x84\xff\x10\x18\xc3\x4c\x3e\x1a\xe6\x88\x48\xef\x1f\xb9\xeb\xce\x67\xa4\x84\xa7\x52\x4f\x0f\xd9\xd0\xaf\x33\xdd\x76\x66\xcf\xbe\x65\x96\x33\x3f\x1f\xb5\xd9\x22\x32\xfb\x46\xed\x41\x47\x7a\xf0\x53\x6d\x92\xe3\x4e\x3e\xcf\x94\x3d\xd8\x4e\x6a\x78\x76\xa9\x3d\x57\x35\x88\x1b\xd5\xaf\xa2\xb6\xdb\x38\xe6\xcb\x87\x83\xe7\xb6\x6c\x11\xbb\x6d\x1b\x33\x84\xe0\x2a\x0c\xf1\x69\xac\x3b\x86\x21\xfb\x40\x63\x01\x7a\x46\xa6\x1e\x84\xa5\x82\x51\x8c\xad\x11\x40\xf6\x77\x96\x10\x84\x82\x45\x90\x09\x81\x1e\x13\x6a\x83\x62\x49\xc2\xfa\x75\xc5\x7d\x92\xdb\x46\xe6\xa6\xe9\x80\x0a\x94\xbd\x6e\x08\x9f\x2b\x36\x9b\xd8\x93\xea\xcb\xf9\x60\x93\xe9\x7b\x75\x61\x5f\x6e\xe8\x83\x7b\x3f\x3f\x2d\xf6\x9c\xc0\xf7\x60\xfd\xc8\x3d\x98\x03\xdb\x26\x06\xa5\xc5\x22\x29\xc7\x37\x13\x5a\xa5\x99\xf4\xf8\x0c\x16\x15\x7c\x4c\x01\xd1\xc0\x15\x1d\x3d\xfd\xa2\xc6\xdb\xb1\x76\x9b\x2d\xe4\xc6\xab\xf4\xec\x13\xf3\x17\x69\x3f\x45\xd3\x1b\xbb\x64\x95\x76\x3c\xb4\x30\x70\xd5\x35\x6d\xfc\xc2\x05\xed\x7b\xe0\x66\xc8\xfe\xbb\x29\xae\xbf\x41\xc2\xae\xa3\xc4\x1e\x18\xdc\x1e\x6e\x0e\x3a\x2b\xd1\x48\x37\x33\xaa\x34\x32\xa3\x82\x92\x61\x41\xd1\x54\x4c\x88\xca\x88\xee\xad\x8c\xd0\x4e\x96\x08\xb2\x18\x63\x26\xae\x7f\xd1\xbc\x35\xc6\x4f\x97\x3f\xa8\x3e\xf8\xcf\xf3\x60\xb1\x85\xb7\x0c\xc8\xf8\x38\x21\x6c\x66\x95\xed\x30\xbc\x79\xfe\x85\xc1\xcb\xf9\x5d\x35\x2b\xfa\x9b\x6e\xdf\xda\x01\xa6\x00\x76\x1e\x1c\xd5\x79\x1c\x60\xdf\x9f\x7e\xae\x15\xbc\x0f\x67\x9d\x63\x96\xff\x7d\x18\x6e\xa9\x87\xc7\xc1\x60\x4a\xac\x7b\xca\x55\x93\xba\x99\x31\x94\x1b\x51\x36\xad\x36\x9b\x6d\xa5\xbc\x59\xa7\x76\x92\x90\x49\xec\xf7\x6d\x5a\x08\x1c\xe0\x26\x24\x18\x2a\x5a\x2a\xe6\xa2\x63\x6b\xc5\x19\x1a\x1b\x69\x60\xbb\xc8\xaa\x22\x87\x64\x7c\x94\xd0\xe6\xc3\x36\xf0\xc3\xeb\xe7\xaf\xf0\x5b\xbe\x59\x06\xd6\xc2\x2f\xbb\x94\x0c\x7a\xb2\x70\x55\xcd\x93\x9d\xe9\xab\xd9\xad\xbc\xcf\x21\xc0\xe0\x5b\xfc\x1d\xdf\xd5\xf3\x8b\x81\xfd\xdc\x30\x38\x63\x68\xe5\x7c\xf8\xc3\xe4\x2b\xf3\x41\x32\x82\x2d\x03\x8e\xe4\x22\x39\x9e\xc8\xab\xb4\x53\x94\x1a\x74\xf4\x9a\x15\x88\xd7\x98\xa5\xe6\x1a\xcc\xe4\x22\x1d\x94\xa3\x06\x9d\x7a\x72\x15\x1b\x12\x5e\x42\x8a\xa4\x62\x24\xea\x48\x60\xbd\x3b\x13\x97\x92\x40\xb4\x66\x0c\xc6\xab\xe6\x82\xe7\x0f\x9f\xde\x01\x6c\x47\x66\x0c\x02\xbd\xba\xc1\xdd\xdf\x03\x4f\xed\x9b\xea\x8d\x4b\x1d\x69\x15\xeb\xfb\x95\x77\x8d\x73\x1a\xef\xdd\x01\x52\xb0\xed\x56\xfb\xd6\xff\x59\xb9\xbb\x0f\xe5\xc6\x1a\xf6\x99\xf0\x57\xe0\xd9\x1d\x2b\xb6\xeb\x30\xde\xc2\xe0\x68\xf6\x1f\xb6\x3b\xe2\x43\x0e\x2a\xd5\x6b\xd1\xea\x0c\xb4\x49\x65\x2a\xe3\x35\x2a\x9d\xc3\x26\xb1\x95\xf1\x8c\xc4\x42\x9d\x44\x9c\xba\xa0\x69\xe8\x0b\x09\xd6\x32\xc6\x30\xc2\x81\xd4\x51\x2e\x0c\x9f\x9c\x84\xfa\xeb\x09\x60\xf4\xdf\xff\x8c\xdb\xd8\x79\x6f\xd9\xab\x97\x80\x17\xc4\xaf\x19\x03\x5a\x74\x85\x5f\xc3\xf7\xc3\xd2\x0e\xee\xe9\x5f\x9d\xee\x41\xcb\xfe\xfb\xf0\x66\x62\xfa\xe5\xab\xa0\x27\x18\xdf\xb1\xf5\xfd\x78\x2e\x4a\xfe\x1f\x6c\x9c\x3a\x5d\x19\xb0\xdb\xee\x92\x9a\x61\x51\x54\xac\xd7\x28\xb7\x1b\xed\x48\x03\xe6\xd0\xb7\xd6\xa1\x95\x1a\x19\xa9\x70\x71\x40\xb2\x03\x45\x2f\x94\x84\xc5\x6d\xb0\x9a\xf9\xa1\x82\x2e\x8c\xbb\x2b\xe1\xdd\x13\xc5\x95\xf0\xc6\x57\x6e\x62\xbd\xbd\x75\x1c\x54\x7c\xf1\x2d\xbc\x56\x37\x2e\xb2\x2c\x6e\xe5\x4a\xe6\x8f\x8d\x7f\x2e\x80\xb1\x7e\xe3\xed\xd8\xdb\x2f\x7d\x50\x5e\x04\xab\xe6\xf8\x6b\xdb\x22\x39\x11\x49\xb5\xc0\x15\x89\xed\x48\xb3\x45\x62\x9e\x32\xdb\x0d\xb8\xc2\xad\x8b\x54\xb8\xf5\x3c\xa6\xc2\xad\xbf\xba\xd4\x23\x9e\x1e\x1c\x2b\xe8\x17\x25\x20\xc4\xb3\x41\x37\x3c\x63\x4b\xe5\xbc\xc7\x47\xad\x58\xbb\xe8\x97\xb5\xb8\x7c\xba\x7a\x28\xd2\xe5\x5a\xdb\xdf\x5b\x5f\xcb\x27\x18\xbb\xc3\x77\x37\xcd\xd9\x59\x5c\x54\xba\xaa\x98\xf5\xcd\xfd\x6d\xe0\xb0\x0b\xa7\x2e\xc1\x5d\xaf\x0c\xa9\xe8\xea\xfb\x5b\x32\x00\x89\x99\x0f\x38\xe9\xc3\x65\xdf\x02\xd7\xcf\x13\x87\x2e\xbf\x21\xfa\x7e\xe0\xbb\x6c\x03\xb9\x7f\x21\x3e\x32\x0d\x69\x97\x22\x35\x55\xf1\x88\xf8\xa4\x2c\xc7\x10\x01\xfb\x56\x53\x4c\x32\xa1\xb9\x96\x81\x16\x29\x4e\xfa\xd3\x57\x56\x76\x14\x72\x2d\x9d\x6f\x7f\x7f\xf3\xea\x2b\x37\x16\x8d\x9a\xba\xbb\xcb\x21\xe0\x81\xef\xd2\xab\xe0\x0e\xae\xf0\x85\xdd\x9b\xf6\xde\x4d\xf2\x65\xb1\x55\x5d\x8a\xe0\x42\xc2\xc7\xec\x88\x8f\x9c\x27\x3d\x52\xe2\xbc\xc6\x28\x85\xd1\x9d\x90\x10\x5d\x8d\xde\x45\x6b\x34\xaa\x6b\x02\x5d\xf5\x42\x6e\x61\x8c\xb8\x24\x44\x5b\xa6\x59\x27\x55\x5a\x0b\x9a\x95\x8e\xb0\x17\x4c\x7c\xf3\xed\xb6\x4f\x54\xe6\x0d\xed\xff\x5a\x29\xfc\xa1\x0b\x88\xbc\x7e\xe9\xf7\xfc\xd1\xaf\xbc\x34\x67\xe6\xb4\x71\x93\x67\xbd\xd8\x02\x98\x7b\xc0\x23\x3f\xdf\x68\x04\x85\x95\x2b\xc7\xf4\x4f\xd3\x46\xa5\x15\xb5\xf4\x16\x9c\x88\x38\x7d\x78\xdf\x9a\x7e\x8b\x47\xf2\x89\xce\xc8\xe1\x25\x45\x85\xa3\x07\xba\x5f\x7b\xeb\x38\x81\xb5\x18\xc1\x5a\x89\x78\x6e\x02\x86\x35\x46\x16\x61\xf0\x78\x10\xf3\xf0\x58\x34\x06\x03\x12\xcf\x06\x5d\x13\x69\x9c\x97\x29\xc0\x1a\x6c\x50\xeb\x69\x96\x07\x2a\xda\x2b\x08\xd6\xe2\x9c\xba\xa3\x40\x32\xac\xb4\xa2\xff\xd0\xba\xf0\x3f\x5b\x02\xc9\xb9\xb7\xdf\xed\xf2\xdc\x1f\x63\xc6\xd5\x54\x8e\x9d\x35\x39\xf6\x6e\x7b\xf8\xef\xb7\x6f\x7f\x07\xe4\xe5\x33\x07\x14\x66\x9b\xda\xb4\xcc\x68\xe1\xed\x60\x5b\xba\x76\xe5\xec\xca\x25\x95\x05\x46\x73\xa7\xb6\x99\x59\x05\x25\xee\xd5\xf5\x6b\x84\xbb\xd7\x07\xe8\x6c\xdc\xc2\x3a\x1c\xd3\x0b\xef\x31\xe8\x04\xfb\x32\xa3\xb8\xf7\x45\x5f\x9b\x52\x67\x30\xa8\xca\x79\x83\x3d\xca\x1a\x7e\xb2\xf1\xcc\x71\xb9\xaa\x28\xdc\xcd\xe0\x56\xce\x1f\x26\x66\x5c\xf6\x13\x65\x96\x18\x1e\x21\xde\x5b\x4b\x25\x31\x4e\x2c\x56\x31\x7d\xe6\x06\x4b\x01\x4a\x40\xa7\x8d\xd3\x80\x4e\x7d\x53\x52\x6d\x28\x33\x24\x74\x9e\x08\xef\x28\x7f\x4c\xc9\xee\xd2\x67\x5a\xbc\x33\xb1\xad\xc7\x99\xd4\x96\xfd\x72\xcc\x42\xf8\x20\xa7\xf0\xc1\xc8\x08\x73\x85\x8c\xfd\x40\x7f\x2b\x39\x97\x3d\x6c\xe9\x35\xcc\xe9\x69\x95\xec\xf4\xb4\x26\x75\x7a\x61\x2d\xa9\xd3\x1b\x4b\x65\x79\x35\x91\x51\x51\x5a\x7c\x31\x67\xb6\xf5\xe4\xad\x66\xc4\x59\xbc\x8a\xd0\x92\xbd\x6f\x65\x86\x36\x17\xfa\x1f\x75\x7b\x43\x64\x6d\x01\x90\x0a\x37\x73\x4d\x2a\xf8\xaa\x8a\x4a\xa6\x2f\x6a\xe3\x38\xb1\xa9\x47\x2f\x4f\x61\x5c\x56\x77\x9d\xa2\xfb\xae\x5d\xea\x60\x25\xdf\xb6\x61\x99\xa9\x76\x78\x61\xd9\x56\xd3\x3b\xda\xd6\x65\x59\xf4\xc4\xa9\xa9\xed\x04\x5d\x14\xf1\x1d\x2e\x85\xd4\xf8\x71\x78\xd5\x12\x89\x42\x6b\x50\x51\x0a\x64\x12\x2a\x02\x1a\xb0\x21\x0f\xd7\x05\x0c\x61\x32\xa4\x65\x3e\xb8\x58\xde\x15\x31\x95\x4b\x87\x99\xde\xc9\x70\x24\xee\x9b\xc3\x56\x77\xe8\x88\x39\xc9\x91\x77\x6f\xe2\xd6\x39\x62\xbd\xe2\xd7\x10\x1f\xf1\x60\x5f\x5a\x54\x74\xb4\xa3\x94\x8f\xb6\xc8\x90\xf1\xa7\x94\x51\x16\x82\x03\x23\x46\xc1\xe3\x31\x90\x2b\x34\x09\x92\x12\x46\x41\x4c\xc0\x60\x15\x63\x51\x29\xc2\x38\xd8\xa9\x09\xaf\x3b\xb1\xb0\x60\xec\x72\xf7\x8c\xe9\xed\xca\x52\x94\xea\x00\x42\xa6\x2d\x8a\x5d\x39\xb5\xad\x80\x86\xce\x33\x96\x74\x93\x85\x9d\xb6\x3b\xdb\xb6\xf5\xfa\xd1\x71\xda\x2a\x27\x68\x00\xd4\x01\x64\x5f\x25\x93\xfe\x3e\x4e\xaf\xce\x6c\x30\x1a\xaa\x78\x23\x23\x57\x2a\x25\xc8\x20\xb0\x37\xad\x4b\x0b\x02\x40\x48\x44\xc5\x4c\xb8\xb2\xfd\x4e\x9a\x92\x1e\xd1\x31\x71\x60\xf1\xde\xf1\x9a\x1b\x81\x0e\x42\x93\x63\x6d\xe9\xc9\xea\x2f\x4d\x6b\x6b\xf3\x3a\xb1\xf5\x37\x6f\xa2\xb5\x86\x21\xb9\x7d\x05\xe9\x15\x4e\x2a\xca\xab\xb5\x86\x45\x18\x29\x3d\xd3\xb4\x93\x10\xe6\x4d\x01\x6d\xa2\x59\x27\x21\x64\xce\x09\x7a\x85\x16\xd0\x14\xb8\xf4\xda\xee\xb0\xad\x20\x6e\x8b\x25\x27\x9f\x1f\x1d\xfd\x3c\xf0\xf4\xed\x3d\xda\x58\x9b\xf9\x71\x42\xec\xc1\xe7\x12\x5b\xc2\x3b\xa6\xcd\xfb\x2a\x67\xe2\xfe\x42\x93\xda\x77\xf5\x6e\x3a\xc0\xc4\xc3\x02\xe3\xdc\xc1\x48\x76\x9f\xf8\x2a\xea\x2b\x24\x9c\xee\x22\x78\xfa\x22\x78\xe6\xb1\xad\xa8\x38\xcc\x03\x90\x99\xea\xc2\x7a\x97\xca\xa6\xd3\x2b\xe2\xb4\x2e\x8b\x8d\x38\xad\xcf\x9f\xc7\x0a\x72\x68\x55\xe7\x47\xe0\xc1\xa6\x9c\x0b\xff\x97\xd0\x8b\x9f\x94\x78\x36\xe6\x64\xf5\x9a\x1e\x31\x1e\x84\x0f\xed\x37\xd5\x32\x34\xe3\xc3\x04\xf7\x89\xe7\x73\x74\x12\xf8\x27\xa3\x57\x70\x25\xdb\x46\xfc\x65\x9a\x8f\xeb\x23\x0f\xce\x2d\x6c\xbb\x7b\x39\xdd\xd1\xf7\xaf\x6e\x51\x1d\x02\xee\xd5\xaf\x22\xe0\x4f\xe3\x13\xdd\x4f\xb6\x7a\x72\xe2\x2f\xdd\x6a\x71\xe9\x67\x04\x67\xcb\xc6\x9f\xb9\x5c\xb4\x47\x6e\x0c\xa7\xd3\xa6\x52\x48\x22\x22\x23\x10\x67\x8f\x64\x8c\x88\x5a\x8d\x7e\xa3\x9d\xc8\x6a\x52\x0c\xda\x2d\xb4\x9b\x32\xe2\xc2\xbe\x1e\x6c\x10\x63\xb7\x10\x71\x99\xe5\x4a\x70\x35\x5c\xa1\xa7\x27\xed\xae\xde\x3e\xe0\x89\x7c\x70\x37\x69\x5c\xdb\x09\xbd\xfb\xef\x85\x6f\x9c\x7c\xfa\xd2\xc4\x8b\xe7\x27\xb4\x9d\x94\x04\xee\xe6\x6f\x5d\x30\xf2\xca\xf4\xef\x56\x36\xac\x07\x69\x37\x95\xa5\xb7\x97\xbc\x05\xdf\x6c\x18\xf7\xc1\xe2\x77\xc1\xa0\xc5\xca\x9b\xf0\xbd\x45\xbe\x97\xe6\xae\x14\xce\x11\xf6\x39\xfe\xc3\xf5\xa3\x22\x30\x0d\x59\x19\x3d\x02\x4a\x6f\x54\x20\x0b\xa7\x8a\x57\xb1\xa1\x9d\x14\x30\x64\x39\x06\xbd\x50\xb2\x0a\x33\x25\xa4\x4b\x84\xee\x34\x6d\x7e\xf1\x44\xef\xbc\x76\x49\x9d\x12\x07\xd6\x03\x16\xce\x81\xc3\xae\x9c\x37\xe1\x5d\xd6\x15\x7f\xb0\x13\xf4\x06\xf2\x5e\xdd\x10\x45\xc1\x57\x7d\x37\x7d\x7f\x1e\x3d\x56\x3e\x02\xef\x6f\xaf\xd6\xfd\xfb\x88\x7d\x8f\xca\x90\xec\x31\x22\x1d\x5a\x27\xd7\x0e\xe2\xd5\x72\x96\x33\xd2\x0c\x60\x18\x40\xd4\x07\xdc\xec\x80\x38\x59\x8d\x38\xbc\x4d\x2c\x5c\x4e\x78\x39\xa0\x73\xe0\xe7\x35\xef\x83\xec\x21\x1f\x74\x9d\x3f\xa4\xf7\xdc\xbc\x15\x79\xf9\x2d\x3a\x38\x91\xf4\xbb\xcf\x14\xfb\xde\x05\xe3\x67\xf7\x6f\x5f\x70\xaa\x6d\x56\x2e\x94\x0a\xbe\xa4\xc3\xb0\xaf\xa4\x2d\x3a\xdb\x11\x38\xfa\x2f\xcc\x24\x8b\x34\x6b\x95\xba\x9e\xbc\x1a\x1d\x18\x0e\xf7\x75\xa0\xfc\x37\x90\xf8\x87\x9e\xec\x88\x78\x13\x29\x05\xa1\xdc\x0c\xb1\x12\x6b\x01\x40\xb0\x70\x7d\x66\x0f\x9f\x97\x9e\xd3\xad\xa5\x6f\x46\xdd\xed\x0d\xb5\x45\x9e\xec\x16\xfc\xf8\x3c\xfb\x97\xc0\x39\x42\x35\x24\x09\x94\x77\x3e\xc4\x7d\xd4\xf5\x7c\xec\xc8\x07\x45\x6f\xef\x53\x5f\x90\xf5\x1c\x82\x6b\x4c\x87\x55\xff\x50\x43\xaf\x58\x34\x5b\x80\xc9\xdf\xa7\x49\x4f\x65\x78\x6d\x4a\x99\x9c\xf8\x0c\x39\xb6\x86\x57\x71\x1c\x90\x33\xb4\x0e\xe8\x42\x1b\x36\x35\x0d\xc3\x10\xfb\x36\x05\xca\x4e\x8b\xfd\x9b\xc0\x44\x78\x2d\x0e\xbc\x01\x62\x85\x36\x4e\xf0\x4d\xaa\x31\x0e\x8e\x83\xdb\xe9\x0b\xd7\xc0\xb2\x37\x41\xde\xed\xcb\x70\xff\x9b\x70\x01\x45\x85\xd4\xb7\xd6\xe3\xee\xdb\x0a\xa9\x4c\xda\x93\xd7\x30\x2c\x53\xc6\x2b\x85\xa2\x2e\x07\x59\xd6\xc4\xb0\x2c\x25\xd3\x02\x2d\xa5\xed\x19\x52\xf4\x3a\x24\x29\x39\x50\xff\x3a\x46\x28\xf7\x2a\xe5\x32\xa5\x2e\x0e\xd7\xc1\x06\xf2\x2f\xa2\xc1\x38\x28\x14\xc3\x6e\xa4\xbe\x8e\x86\x4b\xa1\x0f\x97\xc4\x06\xe0\xf0\xdf\x17\xdf\xf9\xf7\xf0\x83\xcb\x02\x1e\xf6\xc0\x1a\x4e\x4d\xee\x3e\xd3\xbc\x56\x93\xde\xa0\x47\xda\x8f\x56\xab\x41\xd8\xd0\x52\x06\x86\x42\x24\xc9\x0a\x2a\x6e\x46\xc8\x5d\x80\x5f\x79\x13\x7a\xb5\x39\xf5\x59\x29\x20\xd1\xdf\xca\x0a\x1d\x1f\x1d\x05\x0e\x7f\x0d\xef\xc7\x02\x8b\x63\x6a\x2d\x98\xd1\x6d\xd9\xbc\xd9\xc9\xe0\x9e\xaf\x24\x99\xb5\xc5\xfb\x2e\x5e\xba\x09\x9f\x83\x35\x0d\xa7\x86\x3e\x33\x0e\xac\xed\x3d\x22\xfd\x36\x78\x11\x21\x26\x59\xfe\xcd\x1b\xf0\x1c\xdc\x81\x61\xfa\x0c\xc1\x64\x42\x30\xd9\xd1\xde\x84\xa9\x10\x2c\x12\x95\x8a\x92\x49\x95\x32\x25\xb2\xa8\x98\x30\x8a\x32\x57\xf1\x02\x50\x8f\xf8\x5d\x08\x54\x48\xe5\x76\xe3\x28\x73\x97\xdf\x3b\xea\x57\x37\xc0\x77\x7f\xc0\x1f\x41\x7b\x90\x03\xe7\xc4\xb3\xb6\x64\x5f\x09\xe8\x91\x3c\xfb\xe5\xf3\x43\xa7\xcf\x19\xbc\xb3\xf7\xaf\x53\xe1\x0d\x58\xf3\xe7\xfb\xc0\x03\x8a\x34\xe0\x83\xcb\xb7\x21\x7f\xbb\xe7\x91\xfa\x69\x4f\xd6\x2d\x1a\xfa\x1e\xe9\x5b\xc1\xc2\x12\x76\x03\xa9\x67\x9f\xec\x0d\xd3\x18\xb4\x06\x44\xc3\xe6\x32\xde\xa8\x56\x4b\xb4\x5a\x5a\x22\xa1\x90\xa0\x76\x34\xa1\x18\x01\x51\x5c\x86\xa0\x97\xc5\x12\x1f\x5b\x00\x32\x74\x82\xc1\xed\x37\xf2\x81\xa1\x35\xfc\xe5\xe2\xc7\xb0\x71\xde\x2f\x1b\xe1\x57\x71\xcc\x7c\x84\x23\xa0\x74\xd7\xbe\xfb\xc1\xef\xef\xa8\x5f\x7d\xe3\x93\x97\xb7\xfc\xf6\xac\x06\x4c\x39\x77\x11\x6e\x7a\xed\x8d\x63\xef\x20\xfc\xf8\x10\x1c\x73\x10\x1c\x09\x98\x76\xc3\xcc\x16\x73\x4f\xde\x68\xf0\x3a\xd4\x31\x4c\x78\x38\x63\xd1\x26\x30\x4c\x5c\x29\xcf\x84\x42\x62\xcd\xb3\x5d\x16\x77\x2d\x50\x5c\x0c\x90\x32\x1d\x4d\x77\xce\x14\x5a\x86\x8c\xf9\xba\x1d\x3c\xf7\xc5\xe1\x4f\x86\xbe\xf5\xfd\xac\xc9\xe9\xc3\xd6\xd6\x3a\xc0\x10\xdf\xf7\xf1\xcc\x7c\x27\x1c\x7d\x7c\xeb\xc8\xb7\xef\xcc\x7d\xa2\xba\xa2\x66\xa9\x7d\xf0\xa6\x97\x57\xcc\x1c\xb2\x7c\x40\x9a\xad\x53\x76\xac\x47\xbf\x1c\xe8\x2f\xee\x80\x9f\x71\x75\x63\x6a\x96\x0f\xcc\x8e\xe8\x94\x9e\xd6\x6a\x40\x3f\x42\xf3\x06\x44\xf3\xb8\xbf\x7a\x34\x95\xe9\xb5\x39\xc8\x69\x0b\xe7\x38\x0a\x37\x91\xae\x46\xea\x2e\x70\x52\x4e\xb1\xc1\x66\x88\xda\x1b\xf0\xec\x64\xe6\xe6\x60\x1a\x7f\x4c\x33\x69\x44\xf4\x48\xaf\x74\x49\x0d\x71\x13\x3f\x87\x7f\xbb\xc1\xcf\xcf\xd6\xf6\xe8\xd1\x7f\x82\x0b\xfe\xd0\x06\x44\x7e\x70\xe6\xd3\xd2\x8a\xe1\x6e\xf8\xe6\xb6\xa1\xe5\x36\xba\x3e\xf9\xdc\xc1\xfd\xaf\x0f\x99\xd1\xb6\x55\x87\xea\x6a\xdd\xb9\xab\x2f\xd4\xf7\xda\xdc\xe7\xf5\xd1\xa5\x65\x2d\x6e\x0b\xbc\xb9\x3d\xe2\xcd\xdf\x72\x9d\x10\xed\x25\x79\xad\x6c\x38\xbe\x35\x57\x52\x4a\x43\x35\xaf\x53\x1a\x19\x3b\x65\xaf\x0e\xf1\xf7\x65\x36\xbd\x3b\x27\x46\x81\xc0\xa1\x73\xdd\x7e\x35\x11\xd9\x5c\x40\xc5\x7c\x94\xec\xfb\x25\x29\xf6\xab\x1b\xf0\x34\xfc\xe0\xad\xaf\x01\x70\x48\x8f\xae\x58\x38\x72\x12\xbc\xd1\xf7\x00\xd7\xe9\xd6\x77\x07\xf7\xc0\xdf\xe0\x47\x27\xf7\x46\xaa\x0f\xac\x5d\x5f\xd1\x9b\x84\x8a\x89\xfd\x86\xe7\x91\xda\x8e\x04\x96\x32\x04\x8b\x8a\x52\x19\x4a\x79\x9d\xca\x82\x61\x41\x5c\x41\xfb\x18\x58\x8c\x7e\x58\x4c\x64\xab\x3d\xa1\xb0\xfc\xc5\x2c\xf7\x40\x2e\xb6\xf4\xea\x57\x0b\x1a\xa9\x43\x6f\xdf\xe2\x80\x81\xbd\x38\x65\xd6\xc8\xa9\xf0\x7a\xd1\x16\xb6\xd5\xc5\x93\x6b\x56\x4c\x7f\x7d\xe4\xd1\x0d\x86\xad\xb5\x55\x1d\xbb\x80\xf1\x94\xbf\x0f\x46\x22\xd7\x12\xd1\x1b\xa2\x7b\x85\xc7\xe8\x64\x2d\x34\x6e\x85\x61\xb3\x58\x1e\xaf\x9e\xfa\x1d\xcc\x58\x35\xcb\xc4\xf9\x53\x92\x40\xe7\x46\x36\xb4\x2e\xb3\xd0\x14\x23\xf7\xf6\x22\xf7\xda\x45\x87\xd2\x2f\xbb\x2f\xeb\x1d\x5d\x9e\x59\x3a\xb7\x13\xbc\xe6\xfb\xe6\x03\x39\xe4\x06\xce\x9c\x3f\xa5\x6c\xe0\xf1\xed\x5d\x64\x48\x2f\x83\xb0\xa1\xbf\xd2\x1e\x1f\x1d\xe5\xea\x3c\xa2\xfb\xf1\x0f\x9e\x7d\xce\x5d\x52\xd0\xa9\x28\x29\xc7\x14\x5b\x3c\xbe\xc4\x9d\x88\x6c\xd1\xb7\x90\x2d\xba\x83\x2d\x23\xbd\xa5\x23\xbd\x3a\x85\x95\x65\x24\x1a\x8d\x91\xdc\xe3\x69\x25\xc4\x35\xe4\x07\x0d\x98\x68\x8a\xc3\x8c\xdb\xef\x12\xe2\x84\x58\xf3\x58\x8a\xdd\x71\x06\x8e\x81\xc7\xe3\x91\x6d\xe9\x06\x72\x4e\xcb\x76\x7c\x65\xc2\x96\x83\xf0\x8b\x43\x63\x37\x3b\x26\x81\x54\x10\x49\xff\xfb\x23\xdc\x0b\x7f\x98\x7e\x85\xbb\x51\x5e\x5e\x31\xe8\xe4\xe5\xb3\x07\x96\xfa\xf6\xd7\x03\xd2\xaf\x01\xdc\x41\x46\xc7\xb7\x24\x67\x46\xf1\x32\xa0\x30\x31\xe3\xf4\x5a\x7d\xa6\x1e\xdc\xf9\x8b\xbb\x74\x3f\x0b\xdb\x24\x56\x8a\x62\x8e\x8b\x79\x35\x9a\x63\x1c\x62\x2c\xa2\xd3\x4c\x18\x89\xbf\x80\xf5\xb7\xd7\x7f\xc3\xe3\x85\x67\x00\x55\x83\xce\x4e\x1d\x7a\xc6\x88\x7d\xa2\x52\x23\x65\xac\x41\x8c\x59\xa9\xd5\x69\x6b\x70\xa3\x2f\xf4\x45\xab\x0d\xd8\x43\x29\x58\xab\x7a\xb2\x15\x7a\xf1\xe4\x18\x85\xf2\xae\x2e\xf2\x2d\x94\x7b\x75\xd5\x80\xc5\x7f\x81\xc5\x70\x0a\xfe\xfe\x4b\xf8\x3f\x36\x1f\xac\x80\x63\xaf\xc1\xbf\xaf\xc1\xf1\x60\xd9\x35\xa0\xc0\xb5\x36\xeb\x10\xac\x6b\x89\x4f\x9c\x25\xf6\x55\x19\xd2\x1b\xe6\x49\xf6\xe8\xe2\xc0\xcb\xeb\x28\xbd\x54\x5e\x08\xbe\x24\xd1\x58\x4c\x30\xbe\x9b\x8c\xe9\xcd\x1d\x43\x63\x8e\xae\x13\xe2\x98\x2e\xfa\xc7\xf8\x73\x11\x1a\x57\x20\x5d\x72\x0e\x77\x09\x8d\x39\x26\x8e\xf9\x47\x18\x83\x78\xa6\x98\xf7\xd2\x78\xbb\xf1\x37\xce\x4e\xfa\xef\x1a\x91\xc5\xa1\xd5\xcb\xb0\x9e\xa4\x6a\xd6\x87\x17\x5f\x74\xe2\x9b\x02\x97\x34\x37\x78\x3d\x80\x74\x86\x70\x20\xf9\xe5\x73\x90\x9d\x34\x29\x3a\xb9\xd7\x40\xf3\xe1\x4f\x0e\xa5\x5e\x7d\xb9\x67\x18\x69\xd2\x7b\x53\xff\x54\x1d\x53\xff\xf0\xa9\xdf\xbf\xc2\x15\xc6\x99\xc6\xdb\x48\xa7\xb7\x13\xbf\xaf\x11\x51\x4e\x86\xd7\x6e\x66\x4c\xd6\x2a\xde\x64\xd0\xeb\x6a\x2a\xf4\x94\x52\x51\x83\xa4\x32\xc5\x55\x87\xf4\xbf\x08\xfd\xc6\x32\xc7\x9f\xe0\x14\x43\x94\x45\x5c\xb9\x5b\x4e\x60\xa2\xab\xc6\xb4\x6d\x51\xd8\x2b\xbf\x97\x71\xdf\x87\x6e\x70\xea\x23\xcf\x35\xa0\x8d\xbf\x19\x7f\xff\x4f\x11\x3a\xd8\xd7\xf9\x79\xd4\xa4\x21\xa4\x1f\xd5\x3b\x1f\xe0\xfc\xa6\x07\x8c\xd8\x48\x98\x69\x7c\x1e\xc1\x95\x28\xf6\xdd\x8a\xc0\xdd\x0a\xc3\xc3\x4a\xf9\x70\xad\xc6\x58\xce\xeb\x34\x76\xa5\xba\x67\x85\x52\x29\x93\x49\x4b\x71\xef\x04\x96\x61\x9b\xe4\x99\x09\x6d\xea\xa9\x60\x27\x5a\x37\x29\x26\x8e\x01\xe4\x10\x74\x8f\x40\xbc\xfa\x43\xb7\xaf\xbf\xfb\x97\x4f\x0e\xc4\x82\x55\x60\x59\xfc\xad\x78\x5f\x5d\x73\xc8\x85\x36\x54\x57\x71\x56\x56\x28\xd0\xc2\xfd\xb4\x7f\xaf\xe4\xb8\xa2\x18\xb2\x8c\x54\x48\x8f\x30\x4a\x80\x4e\xca\x32\x8c\x81\x1c\x83\x02\xdc\x6a\x58\x68\x43\x45\xae\x76\x8c\x99\xa0\xe9\x8e\x81\x16\xba\x65\xe7\x11\x5e\xf4\x6b\xce\xc1\xfb\x35\x4d\xb6\x8d\xfe\xce\x17\xc9\x15\xfa\xd0\x89\xb9\xff\x4a\xe8\xee\x31\x54\x18\xc2\x91\x4c\xec\x1b\x16\x45\x65\x7b\x1d\x0e\x6b\x78\x84\x8d\xb1\x84\x23\xd3\xac\x06\xf7\x0f\x53\xd5\xe0\xfe\x61\xd2\xea\xe6\xfd\xc3\x08\xed\x88\x3e\xf5\x90\xa4\x8e\xe0\x06\x82\x00\x98\x74\xf7\xfc\x89\xd1\x2d\xd2\xc7\x3a\x73\x3b\x58\xf6\x3d\xed\x06\x93\x3f\x72\x7f\x05\x14\xf1\xf7\xe2\x1f\x4e\x0b\x81\x18\xf6\x8d\xb0\x7c\x66\x76\x8c\x1c\x43\xf0\x72\xe6\x4b\x61\x33\x43\x21\xc7\x7b\xfa\xb1\x48\x6b\xb8\x6e\x7b\x0b\x2a\xcf\xeb\x8c\xf7\xf4\xac\x88\xa7\xa2\x9d\xc8\xde\xd5\x5a\x1d\xe5\x7c\xb8\xd5\xae\x47\x5a\xb1\x5e\xa7\x55\x20\xb8\x15\xe4\xaa\xc5\x90\x57\x10\xdc\x4a\x2a\xd8\xcb\x4b\x6c\xe5\x95\x83\xa0\xcd\xc9\xcc\x30\x4b\xa4\xca\xc7\x51\x22\x58\xfe\xa4\x35\x33\x67\x48\xf8\xf8\x3f\x76\xc4\x72\x3f\x2b\x2b\xe6\xbe\x0a\x8c\xf3\x63\x02\xbb\x5b\xef\x06\x13\xfd\x74\x49\xd7\x3d\xd1\x8e\x7f\x79\x1e\x76\x7b\x1f\x6f\x5d\x31\xee\xf7\xee\x35\xbe\xb2\x47\x49\xd4\x5f\x57\xe2\x74\xb0\xae\x04\xe2\x03\x7a\x21\xfb\x02\xd7\xfb\x0c\xa9\x2b\xb1\x38\xa4\xae\x84\x90\x1b\x44\xca\x64\xfd\xaf\xfc\xce\xc0\x3c\x81\x5c\x64\x31\xf7\x6b\x2b\xf7\x72\x20\xbf\x73\xa1\x05\xe2\x11\xb8\x5c\x50\x93\x7c\x91\xd3\xc1\x3c\x8f\x20\x3c\xb8\xd4\x5f\x48\xbe\xc8\xe2\x90\x7c\x11\x11\x9e\xff\x2b\xde\x37\x08\x0f\x2e\x07\xf7\x3f\xe2\x7d\x17\xfe\xd3\x2c\xe7\xc9\x3f\x8f\x34\xd1\x3f\x8f\xec\x4f\xba\x16\xcd\xa3\x39\xce\xd0\x81\x08\xd9\xec\xc0\x5c\x92\x0d\x62\x7c\x6d\x1c\x35\xf2\x1f\xbc\x6a\x57\xd0\x13\x64\x51\xa9\x5e\x27\x13\x3b\x2b\x16\xd0\x05\xb1\x55\xb1\x63\x63\xd1\xa3\x36\xa7\x0d\xe8\xd0\x0f\xaf\x8d\x39\x63\x03\x24\xfe\xb5\x72\xfc\x04\x34\x55\x65\x95\x18\x2f\xdf\x7c\xdd\xbf\xe8\x6a\xff\xba\x2e\x57\xb3\x75\xaf\x4a\x6e\x04\xd7\x25\x6f\xdb\x01\xac\xa3\x5a\x23\xed\xcc\xc5\x44\xcf\x8a\x06\xb4\x36\x1a\x14\x44\x8f\x8d\xa6\xcf\xa0\xdf\x81\xed\x91\x85\xf1\xba\x95\xe3\xf1\xca\xe9\x69\x8f\x5b\xfb\x6f\xf2\xce\xba\xa6\xef\x8c\x86\xfa\x63\x9c\x8f\x4b\xbe\x68\xb6\x7e\x21\x50\xa3\xfd\x6b\xe3\x4d\xf4\xaf\xff\x4d\x34\x8d\x21\x58\x16\xbd\x25\xfa\x60\xf4\xeb\xd1\x92\xff\x17\x48\x1e\x8b\xff\x7f\xe8\xd1\x7e\x3c\xc4\xc4\x3c\x82\xff\x4f\x9b\xc1\xd1\x9e\x5a\x84\xe0\xc8\xf7\x26\x34\xc1\xc3\xff\x2f\x28\xd0\xdc\x7d\xd1\xdc\x4f\xb0\x25\x06\x09\x6d\x0b\xd4\x62\x59\x4d\x60\x8a\x6d\x42\x13\x2c\x13\xa8\xe2\x91\xed\x3f\x37\x83\x24\x1b\x74\x42\x4d\x95\x38\x5c\xff\x8d\xd0\x44\x21\xa2\x89\x74\xaf\x93\xed\x30\xab\x03\xa2\x89\x0e\x55\x1d\xc6\x76\x60\x18\x3a\xcf\x99\x07\x74\xe8\x87\x37\x8f\x39\x93\x07\xf2\x9a\xd1\x84\x88\x8f\x47\xd6\xfe\x97\xac\x8d\xf3\x9b\xfc\x07\x36\x58\x47\x6e\x08\xa1\x47\xb2\x36\xbd\xe1\xf7\x77\xc8\xda\x5d\xd0\xda\x1e\x6f\x38\x53\x30\xab\x00\xad\x5d\x50\x55\x30\xb6\x00\x2d\x2d\xae\x4b\x16\xc5\x65\x9a\x03\xef\x2e\xd4\xce\x95\x8c\x46\xf3\x2c\xa4\x04\xe8\x7f\x02\x52\x7c\xda\x82\xf1\xf7\x42\xfd\x39\x0e\xc7\xe8\xef\x16\xc7\xa4\x09\x3a\x40\xa7\x4e\x81\x1c\x09\x5c\x2f\xe1\x30\xb2\x19\xdc\x54\x6b\x6f\x14\x13\xe5\x8c\x1a\xcc\x53\xce\x58\x6f\x6c\x4c\x35\x1f\x1b\x8b\xb4\x3b\x53\x15\x6f\xd0\xb0\x12\x1b\x32\x12\x83\x7e\x1d\x41\x13\x26\x2d\x7a\x32\x82\xd7\xc2\x52\xf1\x26\x4b\x68\x3e\xd3\x3c\x12\x03\x7f\xb1\x7d\x2a\x22\x2a\x2c\xf0\xfb\x07\x62\x48\xc6\xcb\x67\x0c\x21\x71\x18\x34\xbc\x13\x01\x4c\x5a\x12\x8d\x01\xde\x58\x3d\xe9\xb2\x18\x8e\x71\xf2\xf5\x60\x18\x86\x72\x75\xb7\xcf\x89\x3c\xdc\x2b\xf6\x20\xc5\xb9\x93\x5e\xaf\xcb\xe9\x8c\xa0\x22\x62\xca\xf8\x08\x07\xa3\x93\x98\xb4\xea\x04\x1c\xe8\x69\x8b\xa3\xbc\x92\x14\xa4\x3e\x5b\x49\x02\xe4\x15\xb1\xc9\x8f\x3f\xa0\xd8\x7f\xb3\x8d\xf4\x1b\x57\xf3\x50\xb3\xb6\xd8\x8a\xc4\xb1\x05\x48\xc5\x17\x63\x2e\x73\x49\xf5\x22\xb1\x21\x69\x47\xc6\x9a\x44\xb7\x6b\x18\xbe\x6c\xfd\xa2\x9f\xd7\x8c\x58\x62\xe3\x64\x11\x0a\xa0\xc8\xd9\xd1\xdb\x30\xa8\x3d\xfc\xf9\x22\x9c\xcc\x00\x27\x5d\xd4\x63\x4d\xd1\xc3\x7f\x98\x17\x37\xcd\xd8\xb6\xa9\x78\x5e\xc9\x07\xdd\xcb\x5f\xde\xfb\x16\x28\x7a\xa9\xa6\x32\xb1\x2e\xec\xfe\xc3\x33\x95\xbb\xf7\x53\x8d\xae\x9c\xcc\xcd\x8c\xea\x0b\xf8\xdf\xbb\x67\x47\x9f\xa7\x02\x35\x2c\x4e\x07\x6b\x64\x04\x79\xe4\xff\x51\x6b\x63\xe1\x63\x6a\x6d\x90\xd8\x06\xc9\x6e\x21\xff\x5a\x98\x07\x7d\xda\xb4\x0e\x05\x89\x43\x90\xec\xc1\x39\xd7\x54\x8c\xd7\x20\xc5\x91\x08\x32\xad\x51\x3b\x5b\xaf\xe6\xf0\x0d\x8d\x90\xef\x98\x69\x43\x68\x0b\xc6\x22\x88\xdd\x39\x99\x18\x4f\x6e\xa6\x15\x9b\x20\xfe\x3e\x9d\x12\x10\xbe\xc4\xdf\xa7\x73\xe9\xad\x6b\xdc\xd6\x53\xec\xad\x2d\x9c\xd0\xb1\xb3\xd0\x97\x2d\xc4\x20\x70\xab\xfe\x8b\x98\x3f\x3f\x42\x78\xd7\xae\xc8\xa6\x38\x45\x72\x9b\x32\x84\xbc\x88\x21\xc2\xe7\xb8\x67\xe2\x33\x24\xc7\xab\xbc\xc9\xe7\x64\xbc\xa4\x56\x27\x8c\x8f\xc3\x9f\x93\xec\x93\x68\x92\x7d\xc2\xa4\xa5\x71\xc1\xf7\x27\x73\x70\x15\x3a\x61\x0e\x61\xac\x3f\x0b\x85\x41\x4a\xbc\xff\x9c\xb4\x83\x35\xec\x2e\xa2\x73\x3f\x25\xe8\xdc\xd4\x21\x7f\x96\x6d\xe0\x2c\xfd\x81\xe6\x5a\x81\xf1\x4d\xf7\x14\xf0\x2d\x7d\xa4\x46\x11\xc9\x89\xff\x23\x24\x27\x7e\xe1\xf0\x66\x39\xf1\x48\x3f\xc1\xfd\x7a\x4b\x49\x3f\x74\x1c\x15\x9a\xe5\x75\xd8\xad\xe1\x48\x17\x0e\x67\x2c\x0e\xb3\x03\xe9\x74\x06\x89\x1a\x97\x18\xe6\x34\xc1\x00\xd1\x90\x98\x43\x7f\x9c\xa8\x24\x11\x80\x4c\x27\x13\xa8\x44\x6a\x40\x27\x4c\xf4\x96\xd1\x87\x16\xdd\xac\x7f\x08\x24\x5f\x02\xf3\x57\xc9\x69\xe0\x40\x98\xab\x77\x71\x26\xbd\xd4\xb7\x29\x1e\x40\xf8\x45\x32\x1d\x17\x07\x29\x30\x98\xd9\x09\xff\x83\xdd\x7e\xe4\x0a\x61\xef\xda\xea\x87\x73\xdb\x6d\x01\x2a\x5f\xda\x25\x66\xe5\xed\xb7\x1f\x8e\xf0\xc3\xc9\xde\x0f\x85\xd3\x66\x0d\xb3\xd6\xf0\x61\x5a\xb3\xdd\x64\xaf\x41\xba\xfb\xff\x1b\x9c\x31\xae\x50\x38\x69\x63\xa0\x95\x1c\x7d\x64\xee\xb7\xcb\x70\x57\xa3\xdb\x40\x75\x3d\x09\xc1\x69\x4d\x1b\xd8\x3e\xb6\x53\x1c\xd8\x0c\xa1\x07\xfc\x17\x07\x6b\x41\x5a\x3c\x73\x00\x3e\x84\x1d\x7e\x41\x50\xf6\x19\x8a\xa0\xac\x3d\x02\x7d\x92\xb3\xf4\xfe\x8b\xe7\x7d\x7d\x2f\x23\x18\xff\x43\x36\x0e\x8d\x74\x3d\x03\xe5\x44\x27\xa5\xbd\x37\xd6\x13\xeb\x8e\x2d\xe5\xdd\xda\xe8\x78\x57\x7c\x29\xef\x32\x6b\x28\xa0\x62\x14\x0a\x0b\xee\xc8\xcd\x20\x83\x9a\x79\x34\xd2\xb4\x09\xc4\xae\x5c\x49\xb0\x42\x13\x89\xf3\x68\x52\xa0\x29\xc7\x10\x84\x1f\x78\xa4\xed\x2a\xba\x77\x1b\x7e\x70\x54\x59\xa4\xac\xfb\xa5\x7b\x0e\x75\x27\xad\x2d\xa5\x3c\xcf\x64\x4c\xea\xd9\x7a\x2a\xb2\xde\xe0\xed\x78\xf0\x77\x1c\x2c\x01\x9d\xe3\x73\xba\x2e\xdb\xf2\x03\x98\x79\xa9\x7d\x36\xae\xcf\xb4\x8a\x67\x54\x9d\xf2\x77\xc2\xb7\x16\x15\x65\x1c\x01\x9d\x7c\x03\xde\xa0\x0f\x5c\x3c\xeb\xeb\x7d\x39\xa4\x7e\xcd\x0b\xfe\xb3\x4f\x4d\xa1\x9e\x11\xf2\x75\xfc\x52\x35\x70\xf6\x8f\xf8\xcf\x3e\x35\x65\x32\x39\xfb\xd9\xd9\x01\x3a\x03\x8d\xbf\x35\xfe\xc2\xde\x41\xfb\x17\x41\x22\xe0\x8d\x83\xf8\x30\x49\x98\xc4\x6c\xb3\x30\x66\x83\x8a\xae\xe6\x55\xfe\x0b\x0e\xb1\xca\x2d\xb6\xd8\xfd\xb6\x02\x2d\xf4\xa5\xcc\x8d\x21\xfa\x39\xbe\xfe\x92\xd0\xef\xe4\xa6\xe4\x3b\x26\xff\x31\x29\x76\xf8\xe6\x99\xf3\x26\x6a\xe2\x5e\x19\xf7\x3b\x90\xfc\x3e\xec\x95\x61\x3f\x1f\x34\x03\x7b\xc5\x98\x95\xf4\x00\xdf\x4b\x27\xde\xa9\x18\x3d\x23\x79\xda\xeb\xbe\xb3\xe8\xb0\xff\x42\x1b\x1f\x4e\x1b\x43\x78\xf5\x67\x70\x35\xfb\x26\x92\x31\x3a\x04\x0d\xe2\x31\x58\xa6\x68\xd8\x30\xc9\x20\x5e\x29\x0f\x0b\x93\xc9\x19\x19\x95\x8a\x9d\x68\x06\x7f\xe3\x77\x60\xa2\x35\x34\xf1\x1e\x48\x45\xdf\x81\x10\x64\xd2\x96\x65\xdf\x2c\x9a\xdb\x70\x1f\xde\x4e\x86\x5f\x81\xee\x40\xe7\x2c\xdf\x3b\xe1\xb9\x7d\xf0\xc3\xa2\x1e\xc3\xd6\xdb\xea\x4f\x6e\x9e\xd8\x3d\x81\x79\x7d\x27\xf4\x5d\x7b\x69\xe3\xbc\xdb\x92\xc3\x2f\x0c\xee\x77\xe3\xc3\x61\xc3\x37\x3d\xed\x8b\x1d\x36\x69\xd6\xba\xd7\x42\x72\xfd\x75\x62\xce\x3d\xd2\x44\x8e\x22\x29\xf8\x68\xce\xfd\xf4\x40\xae\xbf\x84\xea\xb0\xb7\x59\x5d\x33\x8a\x25\xf2\xfe\x5d\xc4\x37\xf5\x54\x18\x9a\x13\x67\xb5\xb4\x60\x58\x33\x5b\xcd\x5b\xcc\x66\x20\xb5\x7b\xe5\xaa\x22\xbb\x3d\x3c\x3c\x3a\x7a\x9c\xfa\x3d\x35\x8d\x9b\xae\x4b\xe3\xe3\x0d\x94\x14\xb7\xea\x30\x08\x6d\xfa\xf1\xb7\xee\x52\x65\x65\x46\x6a\x46\x6a\x26\x4e\xd5\xc9\xfb\xff\x38\xfb\x0e\xb8\xa6\xae\xf6\xff\x7b\xee\x48\x20\x64\x4f\x92\xb0\x02\x84\xb0\x64\x05\x88\x20\x42\x14\x70\xa0\x20\xc3\x41\x54\x44\x70\x21\x88\x0a\x6e\xc5\xbd\xb7\x75\x5b\x77\xb1\xb5\xad\xd5\xba\x57\xad\x5a\x6b\xed\x70\x56\x5b\x3b\xb5\xbe\xad\xdd\x7b\xbc\x6f\x5b\x35\x87\xff\x39\xe7\xde\x84\x80\xf6\x7d\xff\x9f\x5f\xfb\x31\x48\xbc\xe7\x9e\xe7\xac\x67\x9d\xe7\xf9\x3e\xde\x20\x2b\x8c\x90\x83\xd8\xac\xa7\x88\x8d\x4e\xcb\xc9\x01\xfa\x26\x8a\x21\x28\x13\x86\xd6\x6c\x9d\x6c\xc0\xac\x7b\x17\x7e\x6c\x85\x09\x4b\xe1\x47\xf4\xb4\xa0\xfc\x05\x65\x55\xe3\xe0\x67\xda\xdc\xfd\xa0\x4b\xac\x46\x2e\x02\x2a\x8c\x3e\xb1\x30\x20\x25\x3a\xb3\x73\x52\x9c\xb5\xa3\x91\xcd\x7d\xf8\x2a\x10\xc3\xbf\xd9\xae\x51\xa9\x99\x8d\x5d\x06\xf4\x1a\xbc\xaf\xc3\x12\x78\x1a\xd8\xd7\xd1\x7e\xa1\x1f\xc4\x5d\xfe\x3a\x24\x34\x3d\xd8\x1c\x16\x68\x13\x74\x15\x3e\x37\x14\xeb\x2a\x36\x7a\x6b\xcb\xc7\x2d\xf5\x64\x4f\xee\xa1\xfe\xa4\xe2\x9d\x41\x6c\x19\x43\x17\x2b\xd9\xb2\x17\xca\xca\xb2\xb2\xac\x0c\x9d\x15\x96\x95\x94\x45\x6f\xe5\xa1\x70\x71\xb6\x5d\x1c\xa9\x10\x91\xd6\x8a\x95\xc7\xe5\x91\x7c\xb0\x25\xfc\xde\x06\x56\x3e\x2f\xd8\x07\x57\x84\xd7\x59\x0e\x0b\x3a\x0b\xda\xdb\x63\x09\xb7\xce\xcd\xf5\xe1\xb3\x04\x5b\x9b\xbc\xe7\x69\xca\x83\xf7\x8c\xdf\xc3\x44\x45\x79\xd7\x90\x60\x48\x92\xf7\x9c\xe6\xdf\x33\x9c\xbc\xc7\x17\xdb\x4b\xa8\x59\xf0\xaa\x47\x67\xa3\x6f\xd0\x46\xea\x57\xa2\xb3\x99\x4c\xed\x75\xb6\x12\x92\x6b\x9a\x27\x3c\x27\x16\x74\xbb\xbc\x3c\x9f\x1c\x3f\xe1\x7d\xad\x58\x80\x37\xe9\xf9\xd4\x6d\x3e\x63\xbe\x1d\xa6\xe0\x2d\xef\xbb\x6e\xd2\xa5\xbc\x95\x94\x9f\xef\xc5\x91\x08\x23\x98\x5d\xaf\x7a\x31\xbb\x6e\xd0\xb9\x84\x2e\xda\x6b\x24\xf9\x62\xcf\x5e\x11\x70\xbb\xf0\x73\x56\x81\x2e\x4f\xfa\xf0\x93\x31\xcc\x6e\xd2\xd3\x09\x5d\xbe\xb9\x9a\xfc\xbb\xae\x7b\xdf\x75\x93\xae\x6d\x79\x84\xe9\x6a\x95\x93\x82\x2d\xf9\xaa\x17\xb3\xe7\x06\xd2\xbb\x79\xba\xda\xea\xb8\x42\x7c\xa1\x60\x4f\xf2\xcf\xf1\x39\x91\x72\xb9\x2f\x5d\xed\xb1\x87\x6e\xd2\x8b\x1f\xa3\x0b\xbf\xab\x90\xd0\xf5\xbb\x87\x76\x42\x17\xd0\xeb\xbd\x74\xf1\x58\x06\xaf\x7a\x31\x08\x6e\xd0\x16\x61\x1d\x6d\xb6\x76\x18\x04\x48\x1f\xb8\xe2\xc5\x20\x68\x5d\xc7\xa8\x28\x5f\xba\x04\x6c\x04\xa5\xe7\x7d\x37\xe9\x45\xfc\x3a\xfa\xe8\x5f\xfc\xbb\x6e\x79\xdf\x75\x93\xe8\xfb\xe8\x19\x9b\xad\xcd\x3a\xde\x25\x74\xa5\xb5\xa3\x2b\x32\xd2\x97\x2e\x3e\x27\xfd\x8a\x90\x93\xde\x4a\x17\x0d\xc2\xc3\xdb\xaf\xa3\x6f\x7e\x3b\xee\xf3\x36\x8f\x58\xd7\x2e\xbf\xfd\xba\xf7\x5d\x37\xe9\x25\xfc\x7c\x79\xd0\xdc\xbc\x36\xf8\xab\x4a\x4f\x6e\xeb\x0d\xda\x2e\xac\x63\xdb\x7d\xcf\xdb\xe1\x57\xbc\xb9\xad\x37\x68\x95\x40\x97\xe7\x18\xb5\xb1\xe9\xbd\xef\xf3\xae\xa3\x4f\xde\x3d\xff\xae\x5b\x4a\xcf\xbb\x6e\xd2\xae\xb6\xf9\xda\x24\xcf\x3d\xa3\x35\xcf\x5d\x29\xa6\xbf\xc6\x73\x4a\x72\xda\x33\x5a\x73\xda\x7d\xbe\x3f\x00\x33\x7c\xf2\xca\x5b\xbf\xff\x12\x3d\xdf\x9a\x57\x8e\xbf\x27\x31\x36\x2d\xb7\xe1\x24\xf6\x1d\x52\x6f\x33\xc1\x69\xb0\xca\x14\x4a\x45\x95\x0b\xed\x5c\x53\x70\x70\x60\xa5\x2b\x98\xe5\x90\x44\xe2\x3c\xf5\xd2\xf8\xab\x11\x4f\xec\xbb\x56\x0e\x58\xce\x11\x0f\xc8\x35\xb6\x88\x73\xa4\x47\x0a\xd7\x24\x62\x5b\xba\x45\x88\xbb\xd1\xb3\x7d\x96\xfc\x05\x47\xc1\x5d\x09\x40\x07\x74\xcd\x03\xcd\xfb\xdc\x7f\xc6\x9f\x03\xa9\xef\xf4\x19\x5b\xff\xca\xd6\x97\x7e\x07\x7d\x3e\xf9\x4f\x48\x7a\x41\x5c\x11\x78\x7a\xd3\x2f\x67\xb6\x75\xfb\x31\xab\x76\xea\xd3\x43\xab\x62\x07\x2c\xbe\x97\x3a\x62\x70\xdd\xb0\xc2\xc1\x3b\x57\xff\x79\x72\x7b\xaf\x9a\x3e\x5d\x22\xaa\x09\xbd\xbf\xc2\x12\xb6\x91\x2d\xc2\x36\x8e\xd3\x18\xa2\x0c\xb3\x84\x95\xba\x2c\x16\x83\xc4\x10\x58\xea\x32\x04\x89\x24\x12\xa6\x04\x29\x36\xed\xe2\x74\xdb\x42\x92\xd8\xbc\x97\x38\xf8\x43\x0a\xf0\x20\xf0\xbd\x00\x1a\x43\x36\xcb\x54\x0e\x29\xee\xb7\x20\xf2\x93\x34\x60\x38\x73\xf6\x56\xe9\xf8\xb2\x59\xd0\x0d\x57\xc2\xcf\x63\x41\x0d\x18\x26\x0f\x38\x06\x4b\x63\xb7\x5d\xfd\xac\x3c\x8e\x61\xbb\xf5\x76\x95\xa6\xaf\xda\xb9\x7d\xf5\xf8\x6d\x7d\xf2\xb6\xac\xfc\xd7\xb3\x23\xc3\x3e\x0a\xf9\xe8\x78\x64\x57\x45\x5e\x8f\xdb\xc6\xd8\x82\xec\x81\x4f\xc0\xbd\x43\xf6\x06\xd3\xd6\xd7\x24\xe0\xde\xbd\x87\xe4\xa6\x99\x8f\x1e\x88\x08\x9d\x63\x09\xe6\xf4\x8c\x99\x91\xe8\x74\x8c\xd2\x07\xf0\x8e\xc0\xdd\x99\x48\x49\x56\x6f\x4c\xe9\x13\x00\xef\xbc\x26\x08\x01\xbc\x5b\xb8\x8c\x00\xde\x29\xf3\xf3\x6a\x76\x06\xfa\x00\xde\x81\x37\xbc\xc6\x08\xc6\xbb\x5b\x30\xa7\x67\x19\xc6\xbb\x2b\x4d\xe9\xd1\xf5\xe8\x82\x56\xbc\xbb\x64\x8f\x61\x02\x28\x0b\xd2\xe5\xb7\xa0\xbd\xa2\xc3\x35\xf4\x35\x66\x19\x53\xe9\x92\xb1\x12\xb1\x9f\x27\xf8\xcf\xe3\x99\x26\x9b\x80\x11\x54\x15\x0f\x7c\x1c\x53\xe5\xec\x5c\x5f\xfb\x06\x1f\xaf\xa6\x2d\xd9\x99\x03\x92\xd4\x2d\xf0\xc3\x6f\x8c\xcc\x3b\xae\xe2\xa6\x47\xfe\x5c\x7e\x4d\x37\x07\xbc\xd4\x7b\xf0\x83\xcf\xd8\xe7\x67\x91\x1c\x59\x29\xea\xcf\x89\x74\xd9\x48\xa4\x97\x74\xa6\x8a\x9c\xb1\x11\x14\x9d\x56\xe6\x0a\x50\x52\x1d\x59\xda\x5f\x6b\x31\x84\xd0\xb4\x7f\x44\x08\x52\x6b\x43\x94\x86\x04\x52\x6c\xbc\x53\xb1\x4b\x21\x97\xfb\xe3\x74\x0d\x95\xbd\x4d\xa6\x67\x60\xa2\x8a\x44\x51\x1b\x32\x84\x28\x07\x1e\x8a\x97\x78\x81\xe5\x40\x6c\x73\x44\xa4\xa5\x3a\xda\x18\xbc\x48\xf1\xf3\x09\x3e\xcd\x06\xc2\xf6\x21\x5a\x2f\xfd\x5a\xd1\xa0\xe1\x8d\x83\x76\x57\xad\xaf\xb2\x38\xe4\x0b\x5e\x03\x41\x71\x4b\x8b\x46\x8e\x99\xf2\x66\x53\xaf\xbe\x52\xc5\x90\x6f\xe0\x8c\xc4\xf8\xbc\x51\x59\xfd\xb3\xc6\x75\x01\x49\x61\xa6\xb0\xb2\xd0\xce\x71\x71\x19\x2b\xed\xb3\xc6\x35\xec\x1f\x32\x3f\xb6\x93\x76\xd2\x57\x12\xe7\x0b\x83\x6a\xce\xbc\x74\x13\x8c\x3e\x37\xa8\x76\x08\xf8\xf2\xd1\x83\xaa\x9a\xf5\xf0\xde\x98\xd7\x97\xfd\xee\x9e\x65\x8b\xb2\xc7\xdb\xbb\x17\xf1\x31\x83\x41\x88\x4f\x7c\xc8\x6d\x40\xbb\x23\x09\x67\x87\xf8\x89\xab\x5d\x7e\x11\x41\xf2\x18\x86\x89\xa9\x76\x31\x8c\x3e\x22\x22\xb2\xda\x15\xc1\xe8\x13\xaa\x5d\x7a\xcd\xe3\x05\x97\x71\xf4\x2f\xd1\x20\xf5\xf8\xda\x3c\xc2\xe1\x53\x40\x4e\xb8\x97\x4d\xcf\x21\xc9\x5a\x91\x76\x71\xb8\x27\xeb\x19\xe7\xe0\x7e\x38\xb2\x1a\x68\x96\xdb\xce\x5e\xde\xfc\xf4\xb0\xc6\xcd\xf0\xee\xa5\xcf\xdd\xc7\x77\x81\x4a\x17\x30\xfd\x64\xbb\x08\xe6\x4d\x6c\x5c\xbb\xeb\xf3\xcd\x3b\x98\x5b\xf9\x3d\x00\xbb\xf0\xd2\xf6\x75\x4b\x2e\x25\xb1\xfa\x05\x8d\x1b\xef\x4e\x39\xbc\xf7\x99\x8f\x2c\x6c\xc8\xec\x92\x03\x57\xde\x74\x17\xf5\x2b\x5f\xbb\xe4\xd8\x53\xfc\x58\xf4\x68\x2c\x9f\x72\x0b\x29\x1b\x65\xa7\x72\x9c\x11\x46\x93\x49\x1a\x26\xd6\x26\x68\xd1\xf2\x69\xb5\x94\x2c\x4c\x5a\x2c\x9d\x23\x65\x14\x52\xe0\xcf\x48\xa9\x68\x2f\xb2\x35\x0f\xea\xef\xcd\xde\xc6\xf7\x55\x38\x02\x29\xd2\x43\xbb\xd2\x6a\x90\x0b\x06\x09\xe2\x46\x0e\x32\x36\x05\x9f\x67\xc2\xda\x3c\xc1\x73\x38\x0f\xeb\xe1\x97\x2d\xd4\x2b\x3b\x40\xd9\x30\x30\xb5\xa8\xb0\x73\x48\x5d\xd5\x82\x8d\xa5\x8b\xc6\x36\xed\x5a\x03\x86\x37\x6e\x87\x77\x76\x6f\xde\x3b\x79\xec\xa6\xe7\x26\x68\x8f\x37\xef\xf8\x28\x98\x0d\x9f\x5f\x09\xb4\x6b\xd6\xa4\x75\x2f\xcf\xe9\xdf\xef\xa9\x05\x43\x7b\xae\x49\xda\x35\x72\xf6\x79\x3b\xab\x5d\x36\x7e\xc5\xa7\x53\xce\x6c\x5c\x51\x3e\x70\xd5\xd2\x21\x95\x42\x7c\x07\xfc\x9e\xc4\x77\x68\x71\xfd\x7b\x11\x83\x78\x89\x8b\x65\x70\xfd\x70\xa4\xdb\x07\x90\xeb\xb6\x8b\xbe\x96\x55\x84\xc7\x70\xe2\x17\xc4\x46\xaa\x13\xaa\x63\x98\x3e\x7c\x28\xc7\xa3\x83\x60\xef\xa2\xcd\x89\x09\x9f\xea\xa3\x26\xbc\xcb\xac\xfc\xfa\xea\xa3\x71\x53\xea\x52\xd6\xf7\xb5\xd8\x4a\xad\xfd\x85\xf3\xf8\x3d\x89\xe7\x50\x7b\xfa\x2b\x13\xea\x95\x97\xb9\xa4\x12\xe2\xde\xb9\xf8\xc4\x9a\xe5\x61\x88\x6f\xf0\xbd\xf9\x16\x2f\x07\xd5\x20\xa2\xff\x6d\xd4\x99\x50\xc2\xfc\x9d\x41\xaf\x7a\xba\xf2\xea\x71\xf5\x5e\x3d\xee\x69\x64\xb7\xec\xc3\x72\x56\xad\x6e\xa7\xc7\x5d\xf0\xfa\xde\x9f\xe6\x31\x9d\xb3\xb2\xda\xe0\xd7\xe4\xfa\x62\xb5\x52\xd3\xc1\x51\x01\x5b\x34\xd7\x07\xab\x15\x7f\xdf\xd8\xaa\x77\x10\x1f\x62\x4a\x7b\xff\x65\x1b\xdf\x32\xd1\x3d\x88\x0f\xb1\xd4\xc7\xa7\x5a\x00\xca\x79\x9f\x36\x6b\x9d\x6d\x05\x74\x8e\xb5\xd2\x3a\xce\xca\x30\xb4\x39\xcc\x0c\x94\xe8\xc3\x69\x66\xce\x9b\x81\xf9\x09\x3e\xed\xf6\xfd\xfe\xed\xf5\x5d\x46\x47\x3f\xa6\x3f\x79\xfb\xb5\xd1\x17\xd9\xd1\x70\x32\xe9\x79\x28\xea\xb9\x9f\xb3\x0b\xe3\x98\xed\x40\x3d\x3b\x2a\x1d\xe3\x1c\xa8\x63\x9d\xd9\x6a\xa6\x53\xcd\x79\xe6\xa3\xe6\x8b\xe6\xf7\xcc\xf7\xcd\xa2\x24\x73\xb1\x79\xbc\x99\xc1\xe4\x24\x99\x87\x9a\x0f\x9a\xb9\xee\x66\xc0\xe4\x9a\x01\xa2\x91\x26\xa4\x55\x36\x36\x54\x36\x34\x34\x92\x42\x70\x6d\xe8\x13\xad\xf7\xea\x77\x48\xeb\xa7\x6e\x3e\x51\x1f\xbb\xe0\xbd\x7b\x78\x9a\xd7\xc6\x3c\x37\xa2\x4f\x9c\xdf\x56\x1f\xad\xe7\x12\xe3\x49\xe3\x8c\x42\xef\x7a\xdb\x3b\xbf\x56\xa7\x91\xb1\xcc\xb6\xa0\x51\x5a\x2a\x2d\xe3\x2c\x68\x94\xc2\xdc\x9a\x7d\x7d\xb4\x94\x0f\x66\x46\xbd\x07\x33\x03\xbd\xc1\x42\x7c\xb4\x3e\xd8\x9a\x02\xf6\xc6\x48\x01\x7b\x03\x3f\x13\x47\xb5\x45\x49\xa1\x5b\xde\x80\x03\x98\x07\x04\x83\x1d\xe7\x17\x68\x19\x73\x99\x0b\xa8\x65\x0c\xc3\x48\x0c\x94\x04\x87\x80\x4b\x3c\xc9\x82\x24\x14\x85\xa4\x7b\xb6\x72\x7c\x5c\x39\x21\x1b\x60\x88\x7c\x87\xbf\xc0\xd6\xc9\x5d\x1c\x7d\x11\xfe\x7b\xde\x9a\xd5\xbb\x26\x5c\x6b\x1a\xb9\xaf\x74\xd9\x72\xd5\xb2\x0c\x4e\x09\xc4\x60\x48\x5e\x4a\xc6\xbc\x04\x6e\x7c\xcf\x9e\xe5\xdc\x95\x07\xcd\x25\x8b\xa6\xd4\x3f\x3b\xd0\xd9\x7b\xd1\x26\xed\xfc\xe4\xe0\x90\xdc\x5e\x5c\xf7\xbf\xaf\x27\xc4\xa5\x74\xb0\x77\xef\x86\x68\xfb\x1b\xf6\x65\x7b\xb3\x7d\x48\x8d\x93\x6c\x67\x78\x60\x74\x64\x0a\x6b\x31\x59\xd2\x8b\x5d\x56\x8b\xd9\x94\x54\xe6\x52\xa8\x4d\x26\x09\x3a\x38\x18\x40\x4d\xa6\x90\xe8\x28\x6f\x4a\x9a\x60\xf0\x7b\xc3\x19\x40\xbb\x2b\x37\x3e\x26\x0e\xfd\xda\x76\x2c\x39\x48\xe6\xa7\xe6\x10\x54\x2b\xb1\x9d\x1f\x89\xae\x93\xba\x77\xf6\x18\x63\xc3\xb7\xcd\x3a\xdd\x67\x21\x51\x1b\x7b\x57\x8f\x02\x40\x55\x9b\xd7\x6f\x78\xe3\xe0\x9d\x55\xbd\x46\xc5\x55\xac\x9b\x54\x40\x03\xad\x05\x8c\xce\xe8\xdc\x03\xd0\xc9\xd6\xd8\x4e\x20\x09\x24\x0e\xcd\x9a\x7b\x78\x11\xbe\x8c\x1b\xb5\xfc\xf5\x81\xb3\x66\xcf\xec\x5d\xee\xfe\x22\x61\xd6\xb8\xf1\x07\x86\xa4\xe5\x4c\x99\xbe\x7e\x60\x70\x9f\x8a\x7d\x70\x4a\x61\xa5\x23\xb7\x37\xe6\xe7\x25\x14\xc7\x4e\xe0\xfa\x22\x3d\x27\x9e\x4a\x75\x06\x5b\x8c\x26\x63\xb1\x8b\xb1\x96\xb9\x28\x8d\xdc\xc6\xa2\xe5\x08\x09\x32\x29\x24\xb1\x48\x2c\x4b\x3c\xb9\xc2\x97\xec\xfc\x92\x08\x76\xbd\xa0\xc9\xe0\xa1\x24\x00\xef\xba\xa4\x6b\xbc\x51\xc6\xa4\xd0\xa4\xb0\x3e\x79\x3d\x66\x17\x2f\x5c\xd7\xf8\x5a\x63\xf1\x94\x8a\x3c\xb2\x3e\xac\x5f\xcf\xa5\xd6\x4d\x38\xd2\x78\x83\x15\xd6\xfd\xdd\x29\x76\x61\x95\x78\x78\x51\x4e\x19\x1d\x9c\x10\xb1\x78\xd2\x98\xe7\x06\x05\xa5\x64\x0b\xeb\x14\xd6\x15\x4c\x12\x22\x8e\xaf\xc6\x26\x56\x66\x74\xe9\x41\xb0\x38\x5a\xdc\x68\x6f\xbf\x8b\xf6\x52\x38\x95\x40\x65\x52\x1d\x9d\x61\x61\xc9\xc5\xae\x30\xa5\x89\x0a\x0c\x96\x8a\x59\xb9\x0e\x43\x7e\xeb\x94\x8e\x38\x79\x5c\xb1\x8b\x95\xeb\xc9\x7a\xd9\x5b\x15\x4c\x03\x71\x99\xf1\xa9\xcf\x7c\x3a\x41\x04\x5f\xef\xd4\xeb\x39\xd7\xd8\x69\x1e\xfa\x9f\x4b\x6d\x55\x27\xac\xa9\xde\x34\x5a\x35\xfb\xee\xf8\x57\x26\x16\x55\x4b\x41\xf8\xcb\x11\xf4\x88\x03\xe5\x15\x0d\xa7\x26\x14\x56\x04\x80\x71\xa7\x6b\xa4\x74\xed\xde\x81\x95\xee\xc2\xca\xdc\xd1\x39\x03\xb3\xc7\xe5\x82\x3b\x15\x5d\x1b\x72\xaa\xbb\xd6\xe4\xd2\x7f\xbe\x03\x97\xbe\x33\x7c\xc8\x81\x83\x17\x8f\x34\x5f\x07\xd3\x2e\x56\x57\xd0\x9d\xdd\x5f\xa7\xdd\x38\x76\xfb\xca\x32\xf8\xc3\x9c\x37\x16\xfe\xe7\x99\x0b\x8b\x7e\xde\x7a\x7d\x21\x50\x93\x71\x42\x38\x96\xbd\x8e\x74\x67\x0b\x19\x67\x27\x67\xa0\xd9\x20\x96\xb2\x72\xa3\x22\xd9\x8a\x87\x18\xaa\x53\xe2\x11\xa2\x01\x9e\x04\x79\xc7\xd8\x8e\x68\xb0\x9e\x84\x49\x6f\xec\xaa\x90\x7d\x07\x04\xac\x14\x11\xda\x96\x3e\x43\x25\x4a\xa7\xdd\xc7\x3f\xd5\x6e\xa8\x18\x4c\x83\xbd\x3e\xee\xe8\xd8\xe7\x03\x69\xd9\xb0\x33\x0d\x60\xd8\xf6\xc1\x23\xc7\x1f\x1e\xf3\xb2\x81\x8e\x78\x39\x1c\xa4\x2c\x29\x1c\x32\xc2\x5d\x98\x9c\xd0\x65\x54\x97\xc1\x5d\xea\xb3\xc1\x67\x43\xba\x8e\x75\xda\x13\xeb\xa7\xd3\x3f\xbc\x05\x97\xbf\x7e\xa3\xb7\x1b\xd2\x9d\xcf\x1d\xda\xf7\x06\x68\x7a\xe3\xe2\xc1\x03\x95\xc3\x4e\x7d\x3a\x62\xfc\x0a\xf8\xe3\x9c\x8b\x0b\x7e\x7e\xe1\xcd\x79\x3f\xec\x1a\x31\x06\x84\xf0\x6b\xba\xa9\xe5\x29\x2e\x12\xad\x29\xce\xed\x0f\xc4\xf1\xdd\x38\xb5\x4d\x8c\x23\xa9\xb4\x7a\x56\xaa\x56\x07\xc8\x81\x94\xf1\xe7\x02\xb0\xdf\xe9\x1a\xbf\x25\xb1\x6a\x28\x18\x0a\x48\xf3\xc3\xee\x26\x80\x16\x12\x58\x70\xaa\x03\x63\x07\x51\x1a\xb1\x9d\x79\xed\x7c\x33\x3c\xbe\x0c\x7e\x1c\x04\x0f\xc3\x33\xcd\xa5\xcf\xd3\xaf\x81\xf2\xeb\x0a\x79\xd2\xbb\x2a\x10\x18\x10\xb2\x64\x33\x7b\x09\x88\x60\xf6\xc3\xff\x80\x02\xd8\x7d\x1c\x97\x7f\x3c\x22\xa2\x0e\x16\x80\x99\x0b\xe0\x89\x93\x7c\xcc\xc2\x8f\x02\x5d\x41\x48\x9b\x4b\x73\x86\x98\xa8\x30\x36\x94\x53\x2b\xfc\x64\x81\x81\xe1\x95\x2e\x33\x13\xc8\xaa\x64\x4e\x7f\x99\x0c\xe9\x0c\x32\x21\x3f\x1b\x67\xf9\xe6\xd8\x2f\x79\x59\x82\xde\xc0\xd9\x70\x29\x0f\x3e\xc0\xcf\x86\x76\x1b\x56\x80\x70\xc6\x8f\xc3\x0e\x74\x06\xbe\xbc\x07\x3b\xb6\x48\x05\xbf\x10\x43\x49\x5a\x5d\x73\x13\x10\x8f\x81\xef\xbe\x72\x70\xec\xa4\xe6\x93\x31\xb1\x60\x06\x18\x3c\x77\xc8\xb4\xe6\x47\x43\x00\xf8\x22\xa6\xf3\xc4\xfd\x15\xec\x7b\x55\x3b\xba\xa6\xb9\xfb\x17\xfc\x91\x7a\xfb\x66\xfe\xae\x07\x1d\x4f\x8d\x05\xcd\xe0\x6a\xca\x9e\x47\x39\x71\x51\xf4\xda\xa8\x2d\xf0\x2b\x42\x7b\x1d\xe2\xcb\x91\xe4\x9c\xe0\x28\xc0\x20\x05\x25\x57\x05\x46\x70\xb4\x88\x92\x4a\xa3\xd0\x09\x91\x2a\x59\x33\x9a\x7d\xb3\x2f\x02\x85\x87\x93\xf1\xb9\xb6\x36\x10\xe1\x45\x05\x30\x00\x3b\xd0\x07\x03\x0e\xa9\x6b\x40\x2f\x40\x4f\x90\x7c\x25\x5a\x47\x33\x13\x06\xc0\xf7\x9b\xc1\xe0\xf4\xb4\x1d\xc0\x7a\xa1\x4f\x17\xa0\x6c\x86\xef\x2c\x82\x9f\x8b\xe0\x58\x5b\x7e\xf1\x9c\x30\x10\x18\xf1\xcc\x97\xf0\x11\x18\x67\x8e\x58\xb3\x5b\x6b\x41\x33\x0c\x53\x5f\x1c\x76\x1d\x64\xef\x53\x81\xd5\x30\xa3\xea\x34\x27\x97\xe9\x23\xdd\x87\x23\x79\x24\x0a\x30\x9b\x36\xfa\xc3\x3f\x08\x2e\xd9\x10\x1e\xeb\x15\xed\x0b\xa4\x33\xf9\xd3\x0c\x5d\xed\x12\x33\x18\xcf\x96\x0a\x68\x0d\xf0\x69\xf5\x3a\xda\xf9\x8c\x4e\x01\x05\xb1\x76\xc2\x6c\xdb\xec\x31\xc0\x36\x06\x8c\xb5\xc1\xb5\xdd\xe9\x9a\x78\xba\xe4\x32\x1d\xe3\xfe\xe0\x32\x5c\x77\x9f\x5f\xdf\xa5\x68\x7d\x31\x3e\x11\xce\x1e\x8b\x72\x6a\x35\x94\xbf\xc4\xbf\xd2\xa5\x02\x62\x96\x65\xe4\x52\x09\x23\x62\x50\x1f\x57\xf0\x86\xf3\xee\x36\x7f\x1c\x64\x8c\x66\x86\x54\x03\xc0\xa1\x6b\x9c\x23\x82\xed\x0e\x3f\xdf\x0c\x3f\xea\x02\xe7\x36\xd3\xa5\x35\xb0\xb6\x03\xb3\x6a\x42\xf3\x84\xf0\x0e\xd0\xd5\x2b\x93\xad\x82\x07\x1f\xfd\x0c\x4a\x61\x0e\x7d\x92\x0e\xbc\xbf\x78\xf1\x7d\x97\x8b\xe8\x83\x19\xc8\x5e\xaa\x47\x72\x27\x03\xc7\x68\x26\x26\x27\xc7\x95\xb9\x92\xcd\x62\x73\x94\x2a\x8a\x2d\x71\x81\x28\xbd\x2a\x10\xad\x92\x4a\x29\xb0\x61\x7b\x2b\x70\x22\x5f\x6d\xb7\x4d\x80\x1c\xb9\xaf\xf4\x16\x0a\xe7\xc3\xe8\xe2\x80\xcd\xc0\x87\xac\xe0\xec\x82\x04\xda\x16\x65\x8b\xca\x38\x1f\xbb\xa9\x76\xc9\xa4\xb2\x8a\x63\xdb\xcb\x80\xf1\xcf\x0b\x57\x69\x58\x3a\xa2\x71\x6c\x7e\xbf\xf7\x36\xf7\x81\x37\x5b\x34\x9a\xb8\x94\xde\x19\xea\x12\xb5\xcd\xd5\xb5\xa8\x71\x60\xef\x98\x8e\x65\xaa\x17\x37\x75\xeb\xd7\xbd\x3b\x0e\xa2\xcb\x1b\x57\x7c\xf8\xca\xc6\x55\xa6\x5c\x67\x56\x9e\x2d\x59\x9d\xd0\x63\x6c\xc9\xd1\xf7\x41\x97\xde\x9d\xfc\xd8\xb7\x55\xe9\x43\x66\x17\x8c\xa8\xd1\x0a\x76\x67\x3d\xa9\x77\x8b\xce\xb1\x52\xad\x96\xe1\x6c\x1a\x8f\xbe\x2b\x06\x14\x28\xf6\x09\x55\x7e\x92\xc6\x8b\xe3\x00\x81\x90\x14\x81\x64\x4c\x02\xdd\x46\xf1\xcd\x19\x93\x93\x55\x9d\x11\x9d\x15\xeb\xea\xda\x79\x68\x71\x76\x7e\x6e\x61\xb2\xa0\x02\xcb\x47\xd5\x0c\xef\x27\xfd\x44\x15\xd7\x7b\xc8\xe8\xdc\x68\x32\xc7\x53\x28\x8c\x7d\xbc\x91\x32\x22\x5a\x82\x28\x1d\x62\x28\x94\xdc\xa0\x96\xc8\xe5\xe8\xc0\x86\xc9\x8b\xe5\x73\xe4\x6b\xe4\xac\x42\x0e\xe4\x54\x22\x06\x65\x12\x62\x61\xb1\x74\x48\x69\x9b\x98\xc4\xe2\x88\x7f\x6c\x19\xeb\xe9\xe4\x05\x67\x46\xce\x99\x3f\xeb\x60\xc6\x7f\x2a\x41\xe1\xdd\x3f\x80\x7c\x1d\x7c\xf0\x7c\x17\xf8\x51\xbd\x83\x0e\x1f\x75\x76\xfa\xf8\x99\xf5\xd3\xbb\x9f\xb9\xf2\xdd\xf5\x8d\xf0\xeb\xd7\x2c\xf0\x28\x9d\x28\xe3\x63\x35\x2f\xa0\xbd\x9c\x8e\xf8\xb9\x8e\x0a\x71\xca\x19\x91\x88\xc3\x51\xad\xc5\x2e\x8d\x92\x23\x37\x3a\x9e\x50\x56\x92\x8b\x47\xb2\xa5\x69\x5e\x97\xe0\xa3\x58\xd9\xf4\x37\x4e\x66\xc0\xaf\xcb\x96\x2d\xc9\x9b\xda\xb5\xc6\x04\x7f\xb2\x02\xf9\xb9\x63\x57\x69\xf7\xe1\x5f\xd2\xe0\xc7\xe0\x25\x2e\x6f\xd5\xa4\x0d\xc3\xca\xe4\xcf\xbc\x79\x04\xc7\x10\xa1\xbe\x8e\x92\xbc\xf4\x30\xa4\xb9\x0f\x72\xa6\x06\x69\x34\x46\xca\xdf\x1a\x68\x0d\xac\x72\xfd\x42\x01\x66\x9f\xf5\x15\x2b\x9d\x6d\x05\x6c\xac\x15\x30\x0a\x2b\x08\x10\x21\x0e\x67\x55\xd1\xaa\xe0\x2a\x97\x4a\x4d\x47\x56\xb9\x68\xa6\x1d\x3e\x86\x07\xbb\xaa\x92\x47\xaf\x52\xd9\x89\x55\xc7\xa0\xf3\xe6\xc1\xab\xd2\x09\x50\x56\x56\x7c\x5b\x86\x83\x3a\xc5\x16\x1f\xec\xaa\xa5\xbb\x69\xd9\x99\x37\xf6\x3f\xf3\xd4\x86\xe5\x7f\xef\x76\x9f\xce\x59\xca\xac\x1e\x38\xe0\x81\x7c\x7f\xd4\x7e\x2d\x00\x18\xba\xea\xdd\xec\x5b\xc3\x46\xd2\x7e\x4c\xe7\x95\x8b\x57\x9d\x0d\x53\xae\x18\xbf\xe4\xcd\x5a\x90\x37\xb3\x7b\xcf\x9e\x17\x47\x7b\x60\xab\x04\x6c\x24\x3e\xb7\x11\x69\x31\x4e\x7d\x50\x80\x9e\xd2\x57\xe3\x3c\x5a\x4a\x41\x2b\x0c\x95\x2e\x85\x46\x8c\x69\xb7\x7b\xd3\xbe\x3d\xf8\x0f\x1a\xc2\x1a\x34\x24\xe1\x5e\x4c\xf3\x79\x12\x48\x15\x03\xe4\x7a\x9f\x08\xbc\x82\xfa\x1a\x60\xab\x01\x33\xf1\x67\xbd\xad\x5e\xee\x80\xef\xb7\x50\x6f\x9d\xd2\xa9\xea\xc1\xa3\xda\x99\x61\x72\x38\xdf\x28\xe9\xc2\xa4\xd0\x1a\x7c\x37\xe4\xfe\xf1\x72\x0f\x78\x1f\x7e\x7b\xe0\x50\xff\x71\x03\xe0\x98\x1d\x2f\x15\x2c\x2c\x8e\xec\xdb\x9d\xd8\x5f\xfb\xd0\xfc\x17\x93\x1c\xb3\x42\xe2\x1b\x09\x6b\x59\xcb\x25\x90\xd8\x4c\x03\x3a\x17\x19\xce\x10\xa9\x81\x43\xa4\x2a\x4d\x5a\x13\x92\x1c\x81\xc8\x96\xf6\x17\x73\x0c\xab\xa6\x54\x95\x2e\x1a\xf3\xb5\xab\x44\x90\x13\x41\x97\xe1\x13\xc8\x6f\x11\x13\x19\xc7\x87\xcc\xa2\x71\x60\x36\x07\xf0\xb0\xd0\xb7\x19\x05\xcd\x05\x93\x81\x88\xf1\x1f\xdc\x3c\x38\x28\x7e\xc5\x9d\x1f\xe3\xe1\x9e\x6f\x11\xd3\x73\xbf\xfb\xde\x1d\xb8\x6a\xfd\xaa\x11\x63\xc7\x72\xf9\x88\xfd\xf0\x08\x02\x4c\x30\xc8\x73\xfb\xdd\xa0\xd8\x96\x42\x24\x27\x44\xa4\xfe\x00\xf6\x7a\x25\x51\x85\xce\x58\x05\x65\x48\x88\x4c\x28\x71\xc5\x46\xc6\x07\x72\x34\x4b\x25\xc8\x55\x31\x8c\x34\x32\x12\x89\x0e\x4b\x89\x0b\x4b\x8e\x60\xca\x5b\xc8\x4a\x80\x6b\x13\x14\x62\x03\x71\xda\xa8\xbc\x25\x09\x78\x31\xe2\x05\x33\xc2\x62\x44\xa7\x55\x00\x0b\xe3\x49\x46\xd4\xa0\x2d\x6e\xd7\x18\x52\x6d\x62\x3b\x40\x8a\x98\x8e\xe6\x16\x56\xc2\xeb\xcd\x60\xd4\xd0\x7e\x07\xff\x5a\x9b\x9d\x06\x64\xcd\xf0\xdd\xed\x5a\xe0\x6e\x39\x9a\x32\xb8\x70\x66\x28\x60\x8b\x91\x68\x19\xb5\x21\x68\xd5\xc1\xb5\x61\xb3\xb7\x42\x51\x5e\xa6\x44\x1b\x07\x9d\xb4\xbc\xe6\xe8\x2c\xa0\xb9\x59\x2b\x05\xcb\x60\x6e\xcd\x83\xf2\x91\x7e\xf0\xef\x8e\x5d\x9c\x86\xe5\x5b\x99\x43\xcb\x67\x00\xe6\x9d\xde\x69\xa7\xe1\x0f\xc3\x53\x92\xd1\x59\xc4\x76\xd4\x16\x92\x3f\x90\xe8\x0c\x0c\x94\x2b\xe4\xd5\x38\xa7\x81\xd2\xf0\xc9\x5a\x14\x92\x01\x9c\x17\xda\xb9\x2d\x7a\x00\x47\x62\xb7\x79\xdf\x45\x0e\xc9\x2c\xc3\x00\x02\x78\x47\x89\x58\xf0\xe6\xa5\x13\x00\xc4\x3b\x73\x7a\x8e\xd5\x25\xfc\x6a\xfb\x35\x11\xde\xea\x40\x97\x0d\x1e\x68\x1b\xd8\x21\x0e\xde\xd1\xde\x3c\x16\x1a\x17\x38\x7c\xec\xe4\xb1\x3f\x5c\xfe\xe5\x6b\x18\x73\xf9\xcb\x8f\xff\xc2\x32\x08\xdf\xb9\x07\xa2\xf9\x37\x22\x1b\xbd\xa3\x33\xc4\x6c\x2a\x1b\x64\xa6\x18\x8d\x56\x83\xb4\x72\xad\xd6\x2f\x30\xd0\x50\xec\x0a\x54\x08\x98\xfa\x6d\x21\x55\xec\xad\x40\x3e\x78\x3f\x90\x7b\xcf\xd6\xe8\x3e\x42\x1a\x81\xd7\x9f\x32\xcd\x36\x6d\x90\x71\xd3\xfd\xc5\x45\x3b\x05\x20\xfd\xfe\xd3\x6c\xd3\x13\xe0\x0e\x2b\xdd\xf4\x47\x0c\x30\xc6\xd0\x6b\x2f\xc3\xf8\xb9\xa7\xab\x8c\x6a\x8c\xa5\x0f\x5e\xbd\xfc\xdd\xd9\xd7\xaf\x5f\xe7\x7d\x40\x3d\x11\x7d\x9f\x71\x03\x91\x0e\x64\xc3\x92\x4a\xc5\x70\x4a\xb1\x5c\x1e\x8e\x6f\x40\xc5\x88\x5b\x88\x35\x26\x8a\x32\x0c\x75\x51\x66\xdf\xbc\x24\x8f\xb4\xc2\xa1\x93\xf8\x94\x09\x5a\x27\xa9\x70\x66\xe7\xe1\x7e\x71\xe6\x1d\xf0\x02\x15\x2b\x99\xdd\x0f\x14\xaa\xda\xa6\xcb\x57\x4f\x01\xe7\xe5\x17\xea\x56\x25\xc1\x3f\xc4\x83\x42\xba\xc5\x5b\x1b\x61\xee\xfc\x8a\xb5\xc9\x93\xaa\x76\x0d\x83\x03\x7e\xcd\x2c\x18\xe0\x70\x7f\xfd\x27\xd8\xfb\xc3\xb0\xa2\x07\x5b\xad\xa6\x0a\xd9\x57\x7e\x52\xba\xa1\x9a\xfe\xd9\x75\x08\x9e\xde\x05\x7f\xe4\xf3\xd9\x11\xcd\xfb\x90\x6c\x8d\x44\xfb\x19\xd1\x1c\xa9\xd0\x86\x19\x42\x42\x6c\xc4\xf5\xd8\x01\xbb\x1e\x03\x64\x32\xbf\x52\x97\xec\x9f\x68\xc6\x90\xdd\x02\x91\xc4\x48\x48\x45\xf3\xd9\xa6\xf6\x11\x32\x7b\x7c\x31\x9c\xd8\x7d\x7e\xa1\x8a\x7d\x98\xde\x0e\x83\xab\x66\x2c\x02\xa2\x6c\x8c\xad\xb6\x61\xc3\xb2\x5f\xd7\xbd\x9b\xc9\x8a\x23\xc5\x35\xdb\xe6\x3e\xd3\xbd\xa8\xcf\xf2\x62\x36\x33\x7c\x46\x9f\x47\x4f\x59\x4d\x83\x65\x5f\x69\x87\x57\x98\x42\xc1\xc0\x41\xc3\xcf\x9f\x78\x1b\x0c\x7e\xf3\x8d\xc8\x59\x72\x58\xf7\x1d\x7c\xff\x5f\x63\x6b\x67\xdd\x27\xfa\x09\xce\x55\xbd\x4b\x72\x90\x8c\x38\x33\x4a\xe6\xaf\xc2\x1c\xc2\x80\xfe\x29\x40\xa1\xa6\xf5\x95\x5e\x2e\x6d\xf7\x28\x41\x02\x9f\x13\x92\x8f\x2d\x0c\xc1\x82\x15\x30\xb8\xc2\xa2\x97\x4e\x02\x3f\x7d\x75\xff\xcc\x4b\x3f\xc0\xa3\x67\xf7\x0f\x87\x1f\x0d\x5f\xca\x1c\x99\x5a\x8f\xb3\x90\xa3\xe8\x6f\xe8\x8a\xe7\xb7\xed\xfe\x36\xc5\xfd\x0a\xcd\xb8\xdd\x34\x03\xae\x14\x77\x21\x69\xc8\xe8\xbc\x0c\xc7\x77\x32\x48\x76\xe1\x2c\xf7\xc0\x20\x93\x89\x2e\x75\x99\x94\x7e\x52\x99\xb4\xcc\xc5\xe9\xd5\x32\x99\x44\xcd\xdb\xc5\xe4\x0e\xdc\xde\x26\x84\x82\xc8\x50\x2f\x26\xad\x23\x3d\xcd\x66\x31\x68\x79\xb3\xc3\xc0\x4e\xaa\x1b\x31\xf3\x72\xe6\x6a\xdb\xd6\xee\xf0\x9b\xee\x13\x6d\x13\x4d\x81\x34\x50\x88\x58\xb6\xf7\x85\x45\xb5\x55\x4c\xb1\x66\xdb\x6a\xa4\xab\x81\xfa\xcb\x0b\x9b\x76\x0c\xab\xeb\x91\xbc\x64\xbc\x8a\xdf\x93\x03\xb1\x5f\x82\xcc\x8b\x96\x20\x63\x30\x48\x6f\xab\x76\xc9\x29\xb5\x98\x65\x24\x12\x91\x52\xca\x88\xb0\x93\x9b\x37\x5d\x5b\x01\x80\x10\x19\x58\x7b\x63\x10\x21\x88\x0a\x9c\x9f\x85\x74\xb7\x3f\x07\xd8\xae\xc1\xe6\x31\xf0\xe3\x31\x07\xaf\xd8\xfa\xa5\x83\x84\x04\x70\xa9\x06\x64\xb9\xa3\x9e\xf9\x91\x3d\x79\x19\xe6\xb8\xdf\xa3\xe3\xc1\x6b\x97\x57\xae\x5c\xe9\x7e\xe7\x2e\x5a\x13\xe2\xef\x20\xfa\x4d\x18\xb2\xa1\x4d\x66\x25\x1b\x1e\xc2\xa8\x35\xea\x32\xb4\x2e\x1a\x8d\xd8\xa8\x53\x88\xd1\xb4\xf8\x8b\x3d\x67\x95\x2c\x0d\x4f\x82\x90\xb9\x86\xc9\xe0\xb3\xd6\x42\xb1\x9e\xe1\xc0\xf4\x60\xc1\xa4\xb1\x80\x74\x47\x44\x08\x60\x07\x8f\xb7\x9d\x87\x2b\xa7\x7f\xb2\xbe\xae\x87\x2d\x25\xa5\x73\x79\x51\xa7\x59\x97\x6d\x93\xf3\x40\x4c\x0a\xa8\x78\x06\x44\xb9\xad\x63\x3b\x5e\x13\x2b\x19\xc9\x65\xf7\x92\xeb\xbb\x65\x6f\x71\x4c\x74\xff\xd1\x74\xea\x65\x90\x04\x6f\x80\xa4\x47\xcd\xbf\x8d\x8f\x5c\xc0\xcf\xd3\x4c\xc4\xe7\x9e\x46\xeb\x16\x47\xa5\x53\x99\xce\x50\x71\x7c\x89\x2b\x5a\x1c\x29\x17\xcb\xc5\xaa\xc8\xc8\x20\x5c\xab\x55\x15\x50\xe2\x52\xe9\x29\x3b\x62\xe6\x4a\xaa\x1d\xda\x22\x12\xfa\x2a\x75\x06\xd1\x86\xf4\xc4\x43\x2b\xa4\x3b\x7b\x50\xf4\x84\xbb\x0c\xb1\x23\x9b\x80\x42\xe2\x45\x05\x0e\x8f\xda\xc2\x2c\x58\xb4\xe6\xc1\xef\x9f\xe9\x26\x75\xef\x6b\x04\xe1\x93\x61\xc3\xdb\x9b\x03\x0a\x25\xe1\xe1\x96\x90\x60\x53\x6c\x4c\x42\x48\x6d\x4f\x5a\x54\x7c\x12\x7e\xb4\xb8\xae\x2a\x69\x68\xf5\x2e\x3d\x5b\xb4\xb0\xe9\xd2\x7b\x1c\x3b\x3a\x7c\x66\x8f\x12\x39\x3c\xf7\xc2\x84\xe4\x0c\xb0\xa4\x63\x48\x74\xb8\x68\xb3\x48\x22\x62\x87\xf4\x8c\x1a\x33\xda\xfd\x27\x4d\xc7\x0e\xee\x33\x66\x7b\x03\x3f\x3e\x9c\x73\xfe\x3c\x1a\x9f\x89\xc7\x49\x94\x9b\x94\x06\x43\x08\x3a\xdf\x4a\x65\x64\xb1\x4b\x89\x6c\x7f\x46\xd1\x1e\x27\x11\xe0\xc0\x38\x44\x1e\x29\xf2\xd5\xd6\xf2\x27\x0a\xb4\xe7\x48\x33\xf5\xa2\x70\x7f\x20\xd1\x85\x4f\x94\x98\xe1\x2f\x5a\x76\xe6\xaf\xcb\x36\x2c\xf9\x61\xcb\xd8\xe5\x81\xf6\x9e\x7d\x97\x6e\x2f\xe8\x55\xb2\xa2\x84\x59\x1d\x3a\x53\x51\xfc\xa2\xfb\xa5\xf4\xe3\x7e\x9d\xeb\x2e\x9e\x39\xf5\x3e\xa8\x3c\x55\x5d\xf1\x71\xdd\x38\xf8\xf9\x6f\x0d\xd5\xb3\x7f\xf0\xe8\x2b\x73\xc9\xd9\x89\xc5\x28\xce\x06\x85\x4a\x27\xa3\x24\x8c\x24\xac\xd8\x25\xd1\x33\x88\x27\x31\xed\x91\x0f\x5a\xdd\x2c\xad\x18\xa7\x8e\x74\x87\x09\x11\x6e\xc0\xba\x21\x4f\xa0\x80\x7a\x00\xfe\xc8\x3c\x3c\x6e\xc3\xf6\xf9\x5f\xac\xfd\x35\x99\xc5\x00\xa7\xbf\x04\x2a\x14\xdd\xfa\x20\xd2\x81\x54\x34\xa0\x57\x49\xf9\xfc\x82\x6e\xc5\xfd\x96\x14\x31\xab\x2b\xaa\xcf\xbd\x72\x19\xee\x7a\xf5\x62\xcc\x74\xd9\xd0\xce\x7d\xc0\x28\xb0\xb1\x44\x62\xaa\x0b\x82\x54\x43\xe3\xdc\xbf\x37\x8d\x19\x39\xe3\x9b\x56\xec\xc9\xf7\xa9\x08\x2a\x11\x57\xb2\x08\xd6\x19\x25\x3a\xb9\x0e\x9b\x8c\x7a\x79\x3c\xce\x94\xa1\xc4\xbe\x29\x99\xed\x38\x27\x9e\x46\x8c\xf0\xf3\x24\x7c\x4e\x3c\x08\x8c\x1a\xeb\x8b\xd9\xb0\x25\x68\xae\x25\x46\x5d\xa8\x9e\x67\x48\x6e\x0f\x47\x49\x46\x72\xc6\x7c\x63\xa4\x07\x96\x92\x7b\x5f\x22\xbe\xc5\x89\x67\xfe\xd2\x06\x95\x12\x0d\x85\x79\x73\xd9\xe6\x87\xaf\x79\xc1\x29\x01\x5f\x8f\x0f\xcd\x79\x30\xc6\x7f\xf1\x53\x16\xbb\xa4\x7e\x7a\x23\x45\xe9\x85\x5d\xde\x8a\x4d\xd9\x5a\xdf\x31\x4d\x28\x88\xa3\x16\xb4\xee\x6c\x9a\xbe\xc6\x43\x2b\x9e\xbf\x85\x4c\x12\x2f\x9c\x22\xfc\x16\x59\xb3\x6c\xd1\xb5\xf3\x0b\xe1\x97\x97\x47\x9f\x7f\x81\xe0\x28\x02\x35\xc1\x51\xac\x3f\x50\xc5\xdb\x95\xd7\x5a\x2e\x90\xfe\x2d\x68\xcd\x9d\xce\xb0\xd0\x28\x4b\x24\xad\x43\xba\x9f\x25\xd8\x10\x89\xf8\x84\x21\xd8\x2f\x38\xba\xd8\x15\xac\xf7\x53\x15\xbb\x64\x7e\xca\x76\x40\x69\x14\x06\x80\x51\x09\x28\x42\xc9\x49\xb6\x74\x4f\x75\x50\xde\x02\xe7\x91\x20\x79\x97\x22\x76\x29\x88\xc4\xc4\x93\x88\x89\x4f\x19\xdc\x53\xbb\x13\x44\xbd\x7a\xf6\x7d\xf8\x79\xcf\xf2\x86\xe5\x11\xd2\xf3\xcf\x6d\xdd\x03\xef\xfc\x76\x7e\x6a\xd8\x68\xfa\xf6\x53\x75\x6b\x93\x96\x8f\xae\x75\xd5\xe4\x39\x47\xbc\x09\xd2\xf7\x9e\x7d\x56\x24\x57\xf4\x1c\x72\xfa\x50\xb7\x09\x93\xea\xf7\xbf\x57\x17\x36\x09\xd4\xf5\x9d\x5c\x99\x47\xce\x16\xd2\x0b\x09\xee\xa1\x85\xea\x80\x71\x3b\x4c\x41\x41\x86\x52\x57\x90\x59\x45\x01\x39\x1b\x10\x80\xce\x57\x80\x92\x8d\x6d\xf5\x3a\xb5\xc3\xed\xb0\x3e\x8e\x7c\x08\x7c\x24\x2a\xe6\x1e\xbe\x18\x88\x9f\xb4\x81\x40\x0c\x2b\x04\x26\x78\x9d\xab\x4f\xc8\x8e\x71\xd5\x2d\x99\x2b\x5d\xee\x01\x42\x3c\xd8\x0a\x83\x78\x18\xac\xfc\xfb\x9e\x5e\xd5\x5f\x7a\x4b\xd5\x38\x39\xd5\x49\x3f\x6c\x45\x43\x24\x98\x8d\xdc\x5e\xb4\x87\xb1\x8f\x30\xc1\x69\xe4\xb3\x26\x78\xd0\x46\x2b\x49\xf6\x8a\x7b\x22\x68\xa3\xfd\x1f\x50\x1b\xd5\xbe\x00\x6d\xff\x03\xbd\x31\x6e\xe0\xd6\xf1\x85\x65\x31\x8e\xa0\x74\x87\xec\xc8\x3f\x63\x38\x2a\x76\x94\xa8\x6e\x49\xd3\xf2\x1e\xd5\xb4\x45\x72\xa4\x29\x27\xda\xbb\xd3\x79\x3b\x11\xfb\x6d\x8c\x88\x41\x2b\x8c\xa1\x46\x5a\xc9\x18\x8d\x94\x42\xa1\x47\xbf\xa2\x23\x88\x26\xde\x5b\x69\xbd\x4d\x2d\x05\x8c\x91\xc6\x23\xac\x22\xf5\x4f\x4d\xf1\x47\x90\x65\x10\xe5\x04\xc0\x10\xfc\x74\xe8\x73\x33\x90\x89\x47\x16\x34\x3c\x17\xe4\x0e\xa7\x73\x41\xce\xd7\xef\x7e\xb9\x1b\xde\xf6\x1f\xb6\x25\x04\x5c\x11\x55\x69\x9f\x5e\x61\xe8\x9a\xb3\x7f\xad\x1f\x88\x01\xe9\xf7\xae\xde\x84\x6f\x3c\xcf\x1c\x5a\x35\xd5\x1a\x3a\x78\x24\xcf\x73\x85\x98\x75\xc4\x73\xc3\x31\xb6\xa2\x3c\xb4\xc4\x25\x37\xc8\x0d\x7e\x94\x9f\xb9\x04\xd7\x8e\xd4\xfa\x88\x12\x1f\x6c\x45\xdf\xa3\xe6\x41\x53\x14\xcc\x5b\x06\xd3\x8a\x4e\x1f\x7d\xe9\xfa\xe7\x58\xe9\x7f\xe3\x8a\x16\xd0\x77\x25\x23\x07\x21\x75\x1f\x3e\x2a\x03\x41\x62\xa4\xee\xc3\x54\x76\x24\x5b\xf4\xee\xc5\x59\xf0\xc7\x9b\xb5\x1f\xbe\x8d\xd4\xfb\x94\xe4\xba\x06\xa4\xdf\xaf\xdc\xf2\xa8\xcf\xf2\x19\x19\x23\x47\x21\xda\x8c\x88\xb6\x83\x88\xb6\x70\x24\xf1\xb0\x1d\x13\x06\x94\x9c\x4d\x19\x65\x42\xdc\x0b\x6b\x7c\xe8\xb0\x39\x19\xd6\xc8\x98\x4c\x5a\x4a\x1b\x81\xf1\x74\xc3\x28\x2a\xa4\xc4\x87\x29\x08\x53\x69\xb0\x9b\xae\x78\xac\x2e\x3b\x9a\x57\x9e\xb1\x39\x08\x87\x70\x18\x08\x43\x13\x4b\x04\xdc\x08\xab\x83\x0f\xa3\x50\x6b\x88\x41\x83\x93\xee\xa5\xc8\xe6\x38\xce\x85\x85\xa5\xe6\xab\x46\x0f\xab\xaa\x60\xb9\x8e\x2d\x27\x16\xad\x09\x07\x90\x49\x4c\x2c\xe9\xf4\xf9\xba\xb2\x6e\xc3\x2c\xf0\x6b\x89\x85\x2d\xda\x77\x20\xaa\x39\x2b\x39\xee\x68\xc7\xba\x19\x81\xf0\x37\xf8\xf9\x91\xe7\xe7\x2f\x1d\x51\x92\x5f\xb4\xdc\x00\xa2\x1e\xb9\x9e\xd9\xd7\x25\xdf\x9e\x3e\x84\xd7\xc1\x30\xde\xee\xb3\x68\x6c\x56\x8c\xa4\x2d\x0d\x0d\x0b\x0d\x43\x3b\x21\x34\x34\x14\x6d\x8c\xd0\x50\x91\x41\xa3\x31\x95\xb8\x34\x4a\x21\xc9\x58\xdf\x3e\x45\x16\x6f\x0e\x1e\x72\xc1\x9a\x22\xe0\xaa\xf8\xdc\x24\x7b\xb8\x36\xa2\xde\x22\x26\x3e\x24\x3a\xe1\x95\x13\x4b\x66\xc1\xdf\xd6\xde\xfc\xee\xd3\x3d\x60\xdc\x72\x10\xf1\xdb\xb6\x6f\xd3\xaf\x85\x2d\xeb\x3f\x71\x3e\x98\x19\xf1\xc9\x77\x55\xcf\x6f\x5f\x51\x57\xbd\x76\x66\xd3\x3e\x29\x2d\x99\xd9\x6f\xf5\x91\xea\x41\x33\xb2\x7a\xf6\xce\x59\x70\x68\x88\xab\x53\x17\x01\xbb\xa6\x9a\xc4\x7e\xe4\x38\xc3\x23\x2d\x46\x31\x5f\x6f\x4f\x1c\x2a\xa6\x31\xe2\xa7\xc6\x62\x41\x84\x5a\xf4\x4a\x8d\x46\x86\x09\x6f\xb7\x02\x1e\x7a\x55\x04\x7c\x81\x6c\x16\x87\xe7\x66\xd8\x13\xb2\x22\x5c\x8b\xa3\x3d\x15\x86\x2f\x91\x69\xc5\x98\x05\x97\x5f\x89\xb8\xf3\xf1\xa8\xea\x01\xcf\x3a\x76\xbc\x0a\xec\xd7\xbe\x7f\x67\xed\x9c\x2d\x4b\xdc\x7b\xe1\xe5\xe6\xb3\x59\x3b\x9f\x2f\x2f\xe8\xd6\xeb\x50\x49\x59\x52\xa7\x9e\x59\x33\x5e\x5d\x39\xa1\x7e\x8f\x8c\x0e\x98\x35\x68\xd4\xce\xf2\xab\x2b\x8a\xfa\xe0\x3b\x61\x88\xef\x16\x10\xcd\xc9\x54\x3f\x67\x42\xac\x54\x26\x93\x96\xb8\xc2\xad\xa1\x88\x67\x44\xcb\x14\xb2\x50\x19\xa2\xdc\x1c\x14\x1a\x88\xfe\x16\x4a\x69\x03\x03\xd5\x25\xae\x40\x25\x25\x6a\x7b\x16\x09\x12\x0f\xaf\x3a\x65\xa0\x51\xa8\x32\xf8\x8d\xd4\x5a\x1c\xc8\x93\x6c\x4b\xc6\xe3\xa9\x6a\x4f\x76\x17\xde\x5c\xfc\x25\x91\x77\x68\xa0\xd3\x96\x1d\xa2\x1f\xe8\xc6\x82\xb2\xc1\x8d\xe1\x4f\x8d\x77\xcd\x8c\xf9\x38\xe9\xf3\x9d\x8d\x6b\x03\xb7\x72\xae\xcc\x5e\xc6\xf8\x15\x9d\xcb\x47\x06\xe4\xad\x18\x58\x3b\xfe\xba\x76\xd7\xfa\xf8\x3d\x15\xe5\x5d\x32\x0e\xf5\x1f\xee\x5a\xa3\x5f\xbd\xa3\x5f\xcf\x90\xa5\x0b\xe3\x8e\xea\x23\x86\x96\x0f\xb1\xd0\x01\x13\x5d\xa3\x5f\x1c\xc2\x9f\x61\xbc\x97\x86\xa1\x71\xaa\xd1\x6e\x72\x38\x43\x02\x65\x52\x3c\x52\x61\x84\x32\x59\xa8\x26\x54\x84\x51\x66\x34\x94\xb0\x32\xd4\x63\xeb\x82\x0d\x3b\xef\x15\xbe\x67\x6d\x6c\x24\xd0\x53\x58\x13\xde\xe0\xa3\xaf\x36\x9f\x1d\x35\x74\xc8\xf8\xfe\x8d\x91\x4b\xc6\xe4\x87\x3d\xf7\x2e\xfc\x7a\x54\xe3\x82\x7f\xef\x78\xff\xdb\x66\x90\xcc\x6c\x85\x7f\xdc\x99\xbd\x7c\x44\x71\x4e\xfa\xf1\x92\x81\xc9\x8e\x23\x4b\xc7\x7e\xd9\x39\xa0\xce\x55\xbb\x7f\xd8\xf7\xd7\x2f\x82\xf4\x03\x78\x4d\x8e\xc0\x62\x56\x83\xf4\x6d\x12\xdd\xcf\xe8\xb4\x3a\xb4\xbd\xb5\x3a\x89\x02\x09\x75\x49\x10\x50\x50\x39\x5e\x07\x29\x91\x3b\xbc\xfb\x57\xec\x8b\x0a\x61\x71\x80\x87\x07\x40\xe0\x01\x40\x45\xc2\x16\x65\xb8\xfb\x9d\x67\x76\x11\xd4\x7a\x75\x00\xec\x16\x79\x96\x69\x7a\xb4\xe0\x6c\xd9\x81\x97\x09\x74\x7d\xc6\x59\x32\x3f\x91\xb0\x88\xbb\x40\xb0\x66\xec\x54\x96\x33\x2c\xc8\x52\xea\x0a\x09\xa2\x02\x02\xe5\x3a\x5d\x2c\xbe\x5d\x62\x59\x39\x25\x4f\x42\x92\x84\x12\x23\xee\x11\xc4\x07\x3d\x08\x33\xd4\x46\x9a\x00\x0f\x37\xd6\xb4\x17\x2a\xbe\x28\x8c\x22\xd6\x57\x18\x82\x17\x4f\x5e\xa1\x41\x28\xd3\xa7\xcb\x95\x8c\x48\xba\xeb\x99\x86\x8d\xab\x16\xfc\xb8\x75\xf4\x72\x93\x28\x23\x03\x44\x11\xd9\xe2\x70\xc8\x3e\x8e\x87\xb7\x4e\x6e\x9d\xdd\x5c\x50\x54\xb4\xb8\x18\x16\x6d\x5a\x61\xe9\xd2\x1b\x84\x1d\x18\x36\xfc\xec\x4b\x57\x40\xe9\x89\xea\x0a\x60\x03\xe1\x48\xc4\xa4\xe7\x3e\xdc\xfe\xc5\x2f\x6c\xd5\x27\xf0\xe7\x4f\x6b\x87\x4f\xb8\xdd\x5a\x03\x94\xed\xa5\x16\xe1\xf8\x6b\x01\xbb\x69\x0c\xd1\x97\xa2\x9d\x3a\x1a\x94\xba\x68\xda\x4f\x2e\xd7\x95\xba\xd4\x72\xa5\x9f\xa9\xd4\x5b\x12\xd8\x37\x9f\x9d\xa4\x0f\xd2\x11\x61\x2a\x5e\x35\xe1\x11\xb4\x05\x60\x6a\xc6\x74\x3c\x06\xbc\x5e\x3e\x76\xc9\xe6\x41\x30\xeb\x59\x10\x77\xf6\xf4\xb5\x00\xf8\x83\x7f\xef\x3e\xeb\xf7\x5d\xeb\xd8\x23\x1b\x8c\x78\x17\x66\x66\x26\x9a\xc1\x9a\xeb\xa0\xf7\x89\xbd\x2f\x44\x0d\xe8\x0d\x1f\xdc\xff\x48\x11\x8c\xe7\x7e\x23\x2c\xe6\x28\x12\x27\x41\xd0\xfb\x94\x94\x4c\xc7\x8a\x55\x72\x85\xd8\x84\x64\x76\x90\xc7\xdc\x25\x77\x2b\x3e\x3b\x8d\x60\x7f\x00\x0b\x48\xb5\x09\xb7\x74\xf4\xe7\x19\xe1\x83\x0f\xce\x5e\xb4\x71\xe5\x80\x4f\x41\xe4\x4a\xb0\x08\xc4\xb9\xbb\xc4\x16\x77\xca\x4b\xcb\x02\x8a\xdd\xeb\x93\xab\xb7\x0d\x9a\x37\xa9\xe9\xe2\x54\xa6\x93\x7b\x0b\x3d\xea\xe1\xd8\xc1\xd3\xc6\xcf\x89\x2b\x2d\xe5\xcf\x47\x25\xd2\x1f\xac\x68\x3e\x24\x88\x13\x24\x3a\x8d\x56\x83\xc1\x14\xad\x33\xa1\xf9\x08\x89\xc7\x68\xa9\x16\x93\x32\x00\x31\xaf\x00\x7d\x2b\x35\x7c\x36\xb5\x97\x5b\x11\x2a\xf4\x62\x01\x46\xc1\xc6\xc7\xd9\xa1\x59\x0a\x05\x8e\xf4\x56\x6e\x2b\xc4\xbc\xd0\x11\x71\x59\x09\x3d\x53\x23\x45\xf3\x96\xc5\xf4\x6e\xb0\x9b\xfb\x97\x54\x5b\x9e\x5a\x37\x70\x4c\x70\x62\xd5\x84\x0b\xdd\xe7\x25\xd7\x07\x97\xc4\x45\x77\x8f\x9c\x9e\x16\x7e\xea\xa5\xec\xf4\x2e\xe3\xcb\x87\x21\x86\x77\x7e\x78\xb5\xa3\x6e\xea\xda\x7d\xe5\xdd\x2f\x8d\xed\xdd\x77\xc9\x92\x5d\x19\x69\x97\x82\x63\x6d\xc9\xcf\xac\x5a\x65\xdf\xb0\x09\xad\x69\x09\x1c\xcb\xee\x25\x76\x6a\xc8\x29\x4a\x0f\xf2\x9c\x01\x14\xa3\xf1\x53\x90\x9a\xac\xfa\xd6\x10\x35\x44\x30\x66\xa0\xaa\x76\xe0\x40\x18\x84\x31\x07\xd0\xdf\x95\x5c\x98\x02\x7f\x55\x2e\x04\x81\x38\x24\x0d\xd7\x60\x05\x46\x78\x0f\x7e\xd5\x47\x16\xe4\xff\x61\xd3\x78\xc0\xf6\x2c\xa3\x0f\xb8\xd7\xe1\x30\xb4\xfd\xcb\xe9\xdc\x07\xa9\x60\x43\xf7\xda\x48\xca\x53\xd7\xb4\x09\x9d\x21\x2b\x15\xee\x54\x9b\xd0\x09\x0a\x36\xa1\x6f\x02\xf4\x3a\x56\x55\xea\x62\x7d\x82\xe4\xc8\x39\xb1\x3f\x31\x44\x4e\x23\xa0\xca\xe0\xd9\xc2\xee\xa2\xcf\xd8\x27\x84\xc8\x7d\x67\xbe\xfe\xb4\xd7\x8a\xe0\xb4\x4f\x0a\x8f\x63\x8f\x2e\xdd\xcc\xdb\x0e\xa6\x5a\x6f\x9d\x34\x44\x5b\x22\x46\xf4\x8e\x8c\x2b\x75\xd9\x10\xcd\x6c\x98\x4e\x86\x13\xa7\x65\x66\xd6\xec\x43\x21\x7f\xc5\xd4\x9e\x4a\x9e\x4d\x63\x06\xe3\xf8\xff\xa0\x77\x7d\xf8\xab\xcf\x25\x4f\xd6\xc5\x38\x12\xe7\x1a\x96\xfd\x4f\xc2\x99\xfd\xfb\xa5\xdc\x2d\x69\x13\x7d\xe1\xc9\xf4\xd3\x3e\xf8\xa7\x3a\x6c\xd7\x63\xe7\x83\x86\xc2\x38\xa8\x65\x3e\x38\xa8\x8a\xff\x86\x83\xda\xea\x35\xf4\x42\xa1\x7a\xdd\x85\xc9\x77\xa3\xef\xda\x3d\x70\xa8\x76\xf4\x4b\x07\x52\x0a\x92\xd4\xe2\xc4\x9e\xc2\x3f\xcf\x9e\x05\xfe\x82\x8b\x10\x50\xaf\xb4\xfc\xc0\xec\x40\xfb\x4c\x8b\x6b\x9a\x92\x5c\x73\x85\x9a\xa2\x14\xa5\x3e\xde\x61\x41\x2d\x4d\x15\xe0\xcf\xbd\xc0\x5b\xf4\xa6\xad\x4f\x03\xe5\x48\x78\xdf\x4a\xa7\x2e\x09\x48\x4c\x2d\x1b\x15\x5b\x50\xa1\x9d\x32\x2b\xb7\x90\x0e\x38\xeb\xce\xcf\x0c\xe9\x10\x65\xf8\xd0\x24\xdc\x9f\xe0\x58\xeb\xa7\x49\x6d\xcd\x30\xa7\x92\x45\x43\x2b\x45\x43\xa3\x03\xa8\x80\x52\x1f\x90\x0b\x1f\x58\x5d\xa1\xb0\x25\x10\x11\x38\xdd\xe9\x1e\x28\xdd\xe9\xf0\x22\x9b\x79\xdf\xbd\xea\xfe\x7d\xba\xb5\x6e\xa3\x83\xe0\xbb\xf7\x74\xda\x34\x7e\x7e\x48\xe6\x51\x7e\x4a\x3f\xda\x9f\xf1\xd3\x3b\xf5\x8a\x12\x74\x5a\xf4\x52\x23\x49\xac\xa7\xfc\x91\xa0\x44\x72\xa7\xfd\x8c\x5e\xe4\xf3\xf2\x48\x5d\xcd\x40\xe5\x45\xde\xc9\x60\x97\xd3\x62\x81\x08\x64\xfb\x46\x90\xba\x15\x68\xf4\x3d\xa2\x63\x03\x66\x6b\x3b\x0f\xeb\x59\xe2\x99\xe1\xd1\xd1\xd1\x92\xb9\xe6\xe9\xa3\x0a\x79\xd0\xd9\x00\x90\xd0\xb1\xae\x36\x83\x81\x15\x67\xcf\xd2\xc1\x74\x7c\xc7\x95\x4d\x62\xb0\x94\x97\x4b\x1e\x5a\xf5\x88\x53\x17\x38\xe3\x18\x09\x65\x90\x18\x4a\x5c\xea\x40\x24\xbc\xd5\x95\xea\x71\xea\xd5\x6a\x36\x80\x91\xa8\x25\x6a\xb1\x4e\x87\x14\x71\x1d\xc5\x3e\x69\x0f\x08\xd7\x39\x71\x3c\xd3\x6a\xbb\x0f\x88\x5e\xd8\x89\x5c\x6f\x02\x07\x86\x10\xb7\x33\x29\x53\xc2\xa7\x64\x7a\xa8\xcd\x54\x8f\x98\x71\x6a\xb1\xa1\x23\x21\x16\xf6\x08\x53\x37\x96\xd2\x9b\x0f\xc1\x0f\xd0\x9e\x88\x9d\x34\x74\xee\x41\x10\x76\xf6\xd1\x95\x3d\xd5\x5d\x09\xd6\x45\x23\x1c\xc0\xdc\x24\xf7\x1e\x68\x6f\x78\xc0\x79\xfd\x68\x24\x50\xcc\xbe\x7b\x43\xdb\x06\x87\x0d\xf7\x2c\xa2\xb7\x8d\x4d\xcc\x8a\x09\x9e\xd6\x61\xe9\x7c\x29\x90\xc0\xcf\x70\x29\xd2\xeb\xdc\x0c\x64\xee\x89\x02\x26\x4d\xb2\xe7\x70\x83\xce\x22\xf3\x0f\xaf\x9f\x11\xf6\x67\xaf\x92\x1a\x33\x09\x4e\x93\x0c\x0d\x5a\x25\x33\x73\x21\x0c\xae\x7c\x68\xc6\x70\x3b\x41\x8c\x02\x08\xf5\x32\x3c\x80\x3b\xbc\x6c\xb6\x03\x72\x7d\xe2\x41\xf3\xf2\x98\x4d\x69\xd8\x59\x8a\xa8\x60\x8c\x48\x9c\x18\x8b\xe8\xb7\xa2\xe0\x9a\x05\x1b\xb7\xc0\x2f\x4f\xbd\xf2\xa7\x11\xc8\x02\x6b\x0b\xb6\xed\x5c\xf9\x94\xd1\x0a\x06\xc2\x9a\x7d\xdc\x15\x38\xf6\x75\xb8\x56\x7f\x7a\xf5\xcb\xf0\xe7\xf5\x4f\x4d\xcd\xca\xef\x76\xe4\x6c\xc3\xf0\x57\xc1\xe0\x47\x4f\x61\x3c\x1b\x24\x57\xbf\x47\x7b\x36\x89\xb2\x3a\xd5\xda\xa0\xd0\x24\x89\x55\x21\x8a\xc7\x08\xbe\x86\x50\xbd\xda\x27\x32\xe5\xff\x88\xdd\xdb\x65\x8e\x21\x38\x24\x65\x68\x48\xc3\x97\xcf\xfa\x60\xf7\xe6\xd1\x9d\xe7\xf6\x1d\x50\xa2\x5f\x71\x1f\xff\xb3\x7d\x60\xe8\x24\x36\xd3\x3d\x76\x42\x76\x52\xf4\x2b\x4f\xd3\xdd\x1e\xed\xf7\x62\xf7\x56\x8a\x6a\x07\x62\xec\x5e\xfa\x5d\xfe\x9f\x77\xef\xa6\xf9\xbb\x69\x35\xe2\x8f\x98\xee\x58\x4c\xb7\x5c\x6f\x8c\x95\x84\x2a\x44\x51\xc6\xa8\x12\x97\xca\xa8\xc7\x5e\xf3\xff\x42\x37\x10\x82\x4c\xfe\x37\xcd\xf0\x93\x77\x27\xfd\x6f\x7a\x1f\x04\xd3\xe5\xff\x48\x2a\xc6\x11\x47\xb4\xbe\x82\x64\x75\x27\x2c\xa9\x63\x12\x8b\x5d\xf1\x31\x66\xb3\x36\x30\xc0\x21\x0a\x44\xf6\x46\x58\xa0\x52\xa5\xa0\x02\x84\x24\x50\x01\x07\xca\x63\xea\xb7\x72\xee\x08\x4d\x36\x93\x66\xf7\x38\xad\x82\xff\x17\xa3\x07\x2b\xe6\x18\x82\x42\x7d\x26\x5e\xe3\x4f\x67\x4c\xeb\xed\x1d\xc9\xce\xb0\x67\x97\x22\x7e\x6f\x75\x24\xce\x31\xad\x47\x4f\xe2\x31\xd1\x6b\xf9\x11\xb9\x4f\x33\x65\x64\x05\x66\x27\xd5\xba\xf8\x71\x0d\xeb\x3d\xe1\xd1\xf5\xbd\xcf\x48\xb9\x73\xd2\x99\xf4\x03\x7e\x78\xee\xbd\x14\x80\x3f\x0a\xf5\x3c\xa3\x90\xee\xab\x31\x63\x2d\xd4\x6c\x66\xfd\xe4\x3a\x3f\x6d\x29\x06\x75\x51\x50\x9e\x3a\x49\x64\x3c\x1a\x0f\x7e\x71\xfb\x22\xe0\xbe\x63\xc8\x06\xbf\x02\xa9\x46\x82\x05\x13\x90\x2b\x16\xc1\x6f\xa7\x2a\x9c\xf9\xa3\x77\x19\xe7\x86\x9f\xdb\x93\xd8\x10\x1c\x93\xe4\x98\x6d\x3a\xaa\xd0\xb2\x99\xba\x25\x99\x4d\xe3\xe1\xaf\x5d\xfb\xb8\x4b\xe8\xba\x9e\x69\x45\xf9\x48\x10\x8d\xda\xbf\x37\x40\x74\x4b\x3a\x93\xd9\x56\xb0\xd4\x23\x47\xf7\x11\xcc\x4f\xa4\x37\x86\x85\x87\x07\x97\xba\xc2\xcd\x0a\x8d\x9f\x86\x29\x45\x86\x43\x80\xc2\xcf\x27\x58\xce\x8b\x9d\xf9\x4f\x78\xcb\xed\xdc\x43\xa4\xde\xe8\x93\xd0\x97\x37\x7a\x1c\x43\xf3\xa4\x8b\x15\xf4\xb7\x45\xf9\x8f\xa1\x30\x3f\x72\xf3\x8e\xa1\x09\x93\x52\x9d\xf4\xc9\x9e\xbc\xfc\x08\x45\xbc\xf3\x65\xb4\xa7\x65\x94\xfa\x84\x94\x16\x2b\xfc\x81\x08\xef\x0a\x7b\x0e\x5f\x89\x1a\x90\x5d\x80\x3d\xf0\x68\xb7\xde\x41\xb6\xf8\x7b\x0a\x65\xdd\x83\x9b\x20\x1a\xe8\x74\x01\xa3\x1e\xd0\x7f\xce\xef\xe5\xfe\x00\xed\x4b\xdd\xb3\xa9\xb4\x1a\xdf\xe9\x92\x18\x4b\xb4\xef\x64\x88\x1b\x63\x4f\x4d\xb0\x0a\xb1\x1b\x85\x2a\x54\xd5\x47\xc5\x28\x19\x95\x8a\x0d\x08\x90\x13\x27\x99\xa1\x9d\x93\xcc\x5b\xf5\x92\x67\x3b\x82\x6b\xcf\xea\xf5\xd0\x08\xde\x10\x76\xc1\x56\xf8\xd1\xd5\xcb\x77\x77\x81\xf0\x37\x6f\xde\x81\x49\xf5\x4b\x6c\xe0\x02\xd7\x15\x3e\xac\x5d\x1c\x03\xbb\x32\x05\xf4\xcb\xb7\xe0\xb9\x97\x3f\xbb\x71\x0d\xe4\x3c\x77\x43\xb1\x70\x4d\xbc\xb5\xef\x78\x77\xe8\xcc\xa5\x9d\x07\x8d\xf5\xc4\xa1\x73\x0a\x44\x9f\x81\x0a\xa7\x7a\x3b\xe3\x94\x9a\x32\x97\x42\x19\xaa\x44\x06\x9e\x52\x69\x90\x1a\xb4\x18\x40\x54\xaa\x28\x73\x49\xd1\xf1\xa0\xfd\xfd\x91\x76\xed\xaf\xa4\xc3\x8a\x5d\x74\x3b\x87\xde\x63\x74\x5b\x7d\x53\x4c\x3d\xb5\xfe\x48\xe4\x9f\x27\x44\x4e\x4d\xfb\x0d\x6f\x5c\xb4\x66\xd6\xbf\x36\x8e\xcf\x97\xd0\x39\xd1\xf0\x85\x38\x90\x18\x0d\xdf\x4d\x02\x03\xa2\xdd\xaf\xcd\x99\xd8\x6b\x7c\xc7\xc1\x53\xd7\xa5\xf5\x7c\xfb\x95\xeb\xc0\x75\x3c\x37\xf1\xf2\x67\x97\xff\xba\x4a\x9f\xb8\xbd\xf0\xb7\x17\xcf\x83\x28\xc1\x07\xfd\x34\xa1\x3d\x8e\x8a\x71\x6a\x23\x24\x92\xa8\x40\x95\x28\x0a\x1b\xa5\x51\xfa\x40\xa4\x7a\x07\x2a\x7d\x20\x1a\x09\xb2\x1b\xb1\x48\x05\xe4\xe9\x1c\x24\xd0\x3c\xd9\x85\x1e\xb3\xd4\xeb\x86\xe6\x11\x97\xe9\x03\x63\x8e\x8d\x8a\x8d\xea\x17\x14\x7a\x3f\x54\x13\x64\x0a\xeb\xe9\x98\x92\xf7\xf1\x8f\x93\xae\x4c\xa9\xee\x0f\x98\x0e\x0b\x87\x8d\x9d\x03\xea\x99\x65\xeb\xe1\x9f\x2f\x6c\xde\xb1\x62\xfb\xf6\xea\xbc\xcc\x82\x65\x77\x4a\x57\x6c\xb9\xf8\xfd\x9d\x53\xf0\xca\xfe\xa6\xc6\x09\x33\xde\xd8\x0f\xaa\xc0\x6a\x72\xbf\xcf\xe7\x69\xe3\x3c\x5e\x92\x4b\xe9\xd4\xcb\x29\x5d\x90\x2c\x08\xc9\x3b\x99\x52\x6f\x16\xa1\x8d\xc1\x88\xf4\x9c\xb9\x1d\x0c\x34\x71\x98\x2b\x29\xbc\xef\x48\x9c\x15\xd9\x7a\xb8\xec\x97\x8d\x49\x57\x73\x5a\x83\x46\x44\xb3\x0b\xe0\xbd\x96\xe2\xf7\x8b\x9f\x7e\x71\xd6\xef\x2f\xf6\x7e\xbf\x77\xf3\xb3\xf0\xcf\x61\xab\x1b\xe7\xb8\x3f\xae\x5c\xd5\x38\x83\x3e\x80\x74\xf1\xe5\x56\x38\x0c\x6c\xd3\xdf\x39\x7a\x02\x84\x9f\x36\x82\x45\x70\x86\xfe\xfa\x6b\xe7\x3b\xb8\xc3\x92\x80\x7f\xf7\x73\x76\xfa\xd3\x64\xf8\x08\xef\xff\x58\x34\xa7\x59\xc4\x8e\x0e\x42\x56\x95\x48\x57\x4c\x0f\xa5\x69\x5a\xa3\x97\xea\x44\xe4\x92\xe4\x2a\x8e\xd8\x4f\x4e\xf2\xd6\x61\x17\xe9\x0c\x16\x9b\xe0\x0b\xb5\x95\xd7\x8d\xd8\xfa\x55\x54\x3f\x10\xb8\x24\x90\x86\xbf\x72\x0c\x7f\x43\xf7\x9d\xe6\xbb\xd7\xc1\x71\x77\xee\xcc\x73\x5d\xc6\x74\xe7\x6f\xe7\xf8\x7e\x96\xa1\xb9\x78\x42\x3f\xd4\xff\x67\x3f\xcd\x20\xf0\x76\xfb\x7e\x98\x1e\x0f\x0f\xb5\xed\x07\xcd\x39\x1e\x4f\x30\xa9\x20\x26\x0a\xa6\x68\x25\x4d\xcb\x19\xda\x69\xd6\xcb\x55\x2a\xa4\x15\xaa\xcc\x64\x60\xfc\x4c\x9b\xb0\x76\xd6\xb6\x63\x71\x1b\xb5\x43\xd3\x6e\xa0\x5f\xb0\xf5\xbc\x02\x32\x7f\xba\x2c\xcb\x77\xb8\x0f\xc7\x45\x12\x2d\x64\xcc\x84\xf4\x7c\x60\xc7\xc4\x00\x2a\x9b\xe0\x8a\x61\xfc\x74\x3c\x66\xb1\xbe\x92\x1e\x87\xc6\xac\x45\x1c\x50\x6c\xf6\x19\x33\xf0\xb2\xbe\x34\x9b\x05\xf3\x3c\xe1\x1a\x74\x62\xdd\x88\x6d\xf7\xa3\x9e\x87\xdf\x7c\x82\xef\x3f\xd1\xa8\xbb\x5f\x58\x3e\x6a\x38\x53\xac\xf9\xfe\xc2\xa3\xdd\xec\xc8\xa6\x1d\xc3\x1c\xa9\x7d\x62\xe7\x4f\x22\xe3\x9e\x2c\xf4\x15\x81\xc7\x1d\xa1\xa0\x43\xf9\x51\x5b\x94\xc1\x4a\xa3\x42\xa6\x54\x4a\x90\x09\x63\x6e\x45\xf6\x13\x46\xee\xed\xdc\x7b\xf7\xee\x61\xb3\xed\x2f\x64\xd1\xf0\x47\x70\x82\xf2\xb5\x64\xbe\x74\x53\xbb\x2b\xd9\xef\x5e\x77\xff\x87\x70\x57\x51\x00\x66\xaf\x8c\xa4\xf5\x6a\x16\x50\xe8\x34\xb0\xcf\x20\xda\xa4\x94\xce\x19\x20\xe5\x67\x41\xa2\xc4\x7c\x16\x4f\x01\xa1\x21\x2c\x00\x99\x96\x6a\x1c\xff\xc8\x4e\x2c\x5e\x09\x4f\x65\x8d\x81\x5f\x8f\x49\x03\x25\xa0\xc3\x56\x17\x53\x68\x80\x6f\xba\xdf\xa7\x63\x81\x1a\xa8\x8d\xe8\x7d\xd7\x91\xfe\xf8\x0d\x7a\x9f\x0a\xbf\x4f\x6c\x56\x56\xca\xc6\xc9\x68\x19\x76\xd7\xa2\xd7\xe1\xd3\x13\xd6\xc6\x64\x14\x3b\xd2\xc1\xdf\xa0\xc3\x05\xd5\x59\xf8\xcd\x59\xc9\xa4\x9d\x2b\x06\xc6\x0f\x67\x8b\xbe\xde\xd1\xb3\xff\xa3\x0e\xcc\x7b\xf6\xd8\x8a\xd9\x86\x6f\x8c\x98\x37\xe2\x3c\xaf\x59\x68\xef\x48\x91\xd5\x12\xe5\xd4\x60\xf8\xac\x12\x5c\x95\x90\x61\xb4\x48\xdf\x57\x04\xd0\x3a\x9f\x00\x22\x0f\x56\x2f\x32\x26\x90\x60\x25\xb7\xea\x36\xa2\x27\xc6\x01\xb0\xa6\x1f\xfc\xea\x26\xf8\x1a\xec\xd9\xb2\xf2\x2b\xf8\xce\x2b\x3b\x6e\x4c\xa8\x3b\x7a\x1e\x1c\x81\x85\x6c\x26\x84\xcb\x4e\x84\xc1\x18\x70\xe4\xa5\xa1\x65\xd3\x50\x9f\x7d\x50\x9f\x2f\x09\x7d\xe2\x68\x46\xa9\x5c\x5a\xe2\x92\xcb\x59\x20\x51\xb0\x9a\x12\x17\xc6\xa9\xf0\x5c\x17\xfb\xe4\x50\x23\xc3\x3c\xdd\x81\x61\x4d\x89\x73\xb6\x13\x60\xb2\xfb\x02\xd3\x4d\x68\x84\x83\xb7\x2f\xfb\x1a\xa4\x9f\xd9\x7e\xa3\xb1\xee\xc8\x79\x7a\x31\x38\xf2\xf0\x12\xa0\x57\x1c\x0f\x05\x1f\xc0\xc2\x97\xaa\x4a\xa7\x11\xdd\xe8\x3f\x42\x8c\x61\x1a\x8e\x82\xe8\x90\x98\x18\x5b\xea\x4a\x34\x8b\x4c\x91\xca\x48\xa6\xd8\x45\x45\xea\x95\x48\x36\x69\x95\xff\x10\x63\xf8\xbf\x43\x0c\xf1\xe5\x53\x5b\xa1\x0d\xf2\xb8\x41\x73\x96\x4c\x2a\x19\x72\x62\x7b\x29\x30\xfe\xf5\xfa\x65\x12\x60\x58\x9f\xdb\x9f\x0f\x30\x5c\x5f\x1e\x84\x64\x77\xb4\xab\x18\xc9\xee\x5c\x60\x2f\x74\xf2\x91\x85\xf9\xe3\xfa\x1c\xba\xba\x79\x05\x1f\x59\x98\xa4\xe1\x23\x0b\x13\x96\x2b\xfb\x4b\xaf\x12\x19\x0e\x06\xe1\xba\x49\x68\x2c\xcf\x73\xef\x51\x46\x6c\x4b\xf0\x08\x67\x14\x25\x2a\xf5\x41\xed\x22\x3a\x90\xa0\xe8\x60\x73\xcb\xf7\xd6\x46\x0e\x5e\x89\x1d\xa8\x89\x49\xeb\x96\x98\x1d\xad\xfa\xd8\x76\xef\x82\x2b\x3b\x36\xb2\x4f\x8f\x7e\xea\x4f\x6c\x77\xe1\x00\xb9\xf8\x7d\x5d\x54\x41\x3f\x76\xe4\x9b\xc7\x35\x1f\xe8\x2a\x46\x3e\xdc\xfc\xf6\x51\xca\xa7\xcf\x30\x8c\xaf\x28\x47\x3f\x90\x75\x11\xa6\xd3\x99\x4b\x5d\x81\x3a\x33\x87\x4e\x9a\x98\xa3\xbc\x93\xd7\xea\x84\x74\xd8\xdb\xf4\x8d\xa3\x83\x5a\x55\x30\x8c\x6b\x7c\xe1\xd6\x11\x1f\x12\x0e\x6c\x8d\xdc\xea\x1f\x7b\xf7\xac\x97\x40\xed\xad\xb3\xcc\x16\x81\x94\x47\xf3\xce\xc6\x5f\x39\xc4\x13\x38\x1c\xdb\x54\x11\xe8\x4c\x54\xb3\x85\x48\xce\x20\x3b\x58\xa6\x50\x20\x2a\x14\x4a\x1c\x8f\x55\xea\x1b\x83\x23\xe0\xaf\x7a\xae\xe9\x79\x78\x60\xaf\x9e\xc5\x63\x4e\xd3\x3b\x77\xed\x94\xad\x96\xd4\xf7\x48\x88\xcd\xef\xbb\x7b\x97\x6c\x95\x2c\xc5\xde\x35\x2b\x26\x0f\x0e\x68\x5a\x90\x99\x4b\xff\xab\xa3\xa5\x56\xf7\x81\x06\xff\xdd\x6d\xc9\xb5\xd8\x13\x74\xef\xeb\x28\xba\x05\xd7\x0f\x1a\x84\xe6\x04\xdf\xad\xd9\x9d\x66\xa5\x3e\x38\x1e\x89\x65\xa9\x86\x09\x0e\xd6\x53\xfa\xa8\x62\x97\x9e\x80\xf6\xd2\xad\x37\xc4\xc2\x9d\x8a\xa7\xe0\xa5\xcf\x9a\x88\x43\x00\x76\x96\xd8\x04\x6e\x44\x26\x0d\x4d\x1d\xe0\x6d\x05\xe2\x23\x63\x2f\x92\x69\xea\x59\xa6\x3e\xa5\x0e\xd6\xc6\x95\xfa\x5f\xd2\x26\x68\x1b\x5e\x1f\xb9\xe1\xe5\x51\xe7\xe6\xac\x19\x7e\xc1\xf6\xd9\xa3\x95\x5d\xd2\x0b\x96\x9a\x82\xeb\x33\x7b\x0e\xe0\xde\xe3\x27\xad\x67\x59\x89\x35\xa3\x49\xb3\x29\xc2\x19\x51\x98\xb3\x74\xda\xf0\x67\x87\x94\x30\xdf\xbc\x7d\xf4\xef\xdd\xb1\x49\xdd\xed\x1d\x52\xba\xa3\xb5\x3d\x83\xce\x63\x28\x57\xc5\x47\xd6\x30\x62\xec\xb9\xa0\xfc\xfc\x38\x95\x56\x2b\xc7\x55\xa4\xda\x46\x65\xfa\x94\x8e\x89\x20\x45\xc8\x84\x39\x15\x94\x57\x11\x33\x95\x07\x50\x87\xb3\xad\x60\xee\x28\xe9\xc6\xa6\xa5\x56\x0c\x17\xde\xec\x07\x3e\x3c\x0b\xbf\x02\xa6\xb3\xb4\x3a\x3b\xb0\x9a\xa0\x84\x4f\x33\xe4\xf1\xf1\xa0\xb0\x9c\xed\xc9\xf5\xa5\x4c\x98\x1b\xa8\x75\x3a\x64\x1d\xeb\xcc\x4f\x42\xcb\xfc\x27\x1c\xf7\x56\x8b\x79\xa5\x0f\x7a\xfb\x89\x76\x60\xe5\x24\x83\xe2\x51\x59\x1b\x90\x72\xa2\x1f\x6a\x90\x9c\x7e\x83\x60\x87\x46\xe2\xa8\x9e\x30\xbf\x40\x63\x60\x89\x8b\x03\x0a\xa3\x51\xc5\x98\x15\xaa\x20\x24\x41\xf5\x52\xcf\x15\x29\x1f\x89\xe8\x8d\xa4\xf1\xc4\x51\x62\xa0\xee\x74\x4f\x14\x05\x89\x87\xd3\x10\xfd\x95\x5c\x21\xf9\x17\x83\x19\xc5\xc0\x58\x3c\x35\x7c\x6a\x8e\x81\x86\x7f\xf8\x6b\xb9\x2d\x9f\x2e\x58\xae\xd0\xd6\x85\xd7\x15\x83\xc0\x01\x9b\x82\xe0\x42\x65\x57\xc4\x29\x47\x81\x2d\x70\xd4\x21\x78\x62\x79\xd0\xc8\x86\xef\x97\x2d\xcc\x2d\x1c\x71\x08\x6c\x79\xb4\xe0\xc5\x25\x7d\x53\xfb\xf6\xc7\x73\x95\x89\x68\xfd\x11\xd1\x9a\x4c\x85\x38\x15\x94\xd1\x64\x2c\x73\x25\x99\x14\x38\x8e\x5d\xaa\xf7\x51\x04\xf1\x2c\x85\xeb\xb4\x98\x37\x79\x30\x6c\x59\xcc\xa6\x1d\x42\x06\xb1\xc8\x9b\x73\xc8\x3b\x39\xd8\x4b\x55\xbd\x03\x43\x02\xb7\xc1\xbb\x87\x6f\xfc\x18\x91\x96\x9d\x16\x91\x59\x6d\x7b\xa7\xb8\x22\x21\xa3\x66\xd4\x90\x45\x2f\x69\xb5\xab\xc6\xbc\xcd\x8c\x4b\xd7\x76\xed\x3f\xca\xb1\xf1\xeb\x45\x97\xf6\xe7\x4f\x18\x5a\x94\x93\xa2\x89\xba\x5c\xde\x33\xa1\xc6\xb5\x6b\xee\x88\xa9\x97\xb6\x74\x1e\x37\x3a\x7e\xd4\x62\xde\xc6\xa8\x46\x74\xce\x44\xf2\x2a\x8c\x3f\x9b\x62\xa4\x73\x8b\xf5\x21\xfc\xd9\x54\xb6\xc5\xed\xe6\xef\x43\xd9\x08\x1f\xb4\x6e\x3e\xfa\x80\x9c\x0d\xb4\xb1\x98\x89\xb3\x97\xed\x83\xb7\xdf\x78\xe3\x8c\x72\x16\x30\x4e\x93\x6d\xa9\x78\x6a\xa0\x23\x49\x53\xa4\x8b\xb1\xcd\x66\x8b\xb6\x3e\xf5\x1d\x6c\x7a\x6b\xd3\xd6\xae\x25\xf4\x52\xf7\xda\x3c\xfb\xd3\xcb\x80\x76\x45\xcf\x5e\x62\xee\x86\x58\xc2\xdb\xc5\xc7\xd1\xfe\x76\xa2\x39\x93\x50\xf2\x63\xac\xbf\x02\xf8\xf1\x35\x99\xb0\xad\xc3\x44\xd9\x14\x00\x60\x50\x6a\x27\xfc\xb8\x52\x26\x37\x55\xc0\xe3\xf0\x03\x7a\x34\x28\xa6\x1b\x0a\x5f\xec\x78\xc1\xbd\x16\xb5\xc3\xef\x78\x46\xc0\xa0\xc6\xba\x9c\x4c\xab\x50\x8b\xc5\x72\x09\xab\x50\x00\x39\xff\x2e\x12\xda\x84\xd1\x4b\x71\xba\x93\x1c\x57\xbe\xb0\xf1\x55\xb9\x34\x38\x1d\x97\x75\x7d\x6e\xf6\x97\x89\x2c\x3f\xbf\x96\x21\x09\x48\x7d\xfb\x3e\x58\xfa\x7b\xa6\x5f\xe2\xf7\xbf\xd3\x95\x5b\xba\xab\x7a\xc0\x08\x70\xa9\x31\xeb\x39\xf7\x6e\xb4\xfe\x1d\x6a\x47\x82\x0f\x70\x7f\x67\x51\x7f\x7f\x72\x5f\x10\x3d\x4a\x26\xf7\xa7\x02\x34\x3a\x8a\x2b\xf3\x2d\x41\xcc\xbb\x1b\x52\x04\x24\x7f\x2c\x8b\xa3\x18\x05\x0d\x70\x45\x10\x36\xaf\xae\x47\x54\x5a\x52\xa7\xfe\x05\xb9\xbf\xc0\x0f\xca\x03\x8c\xca\x41\x89\xf0\x4b\xf8\x31\xbd\xa3\xe9\x63\xee\x0b\xd9\x5b\x7e\xd6\xe2\xc6\x87\xef\xd2\x8a\x6c\xa0\x8c\xbc\x58\xed\xfe\x91\x9d\x70\x73\x07\x7a\xf1\x0e\x8a\x22\xf7\x0d\x7e\x78\x9e\x38\x74\xf0\x88\x5b\x06\x03\x45\x69\x00\xb9\x52\x60\x40\x63\x3f\xf8\x01\x88\x39\x0e\x2a\x40\x94\xfb\x5e\x3f\x70\x92\x9e\x07\xfb\x82\x97\xdc\xb3\x60\x0f\x21\xde\x7d\x35\x6a\x4f\xf2\x56\x30\x3e\x76\x99\x4b\xad\x50\xe8\xe4\xba\x32\x97\x5c\xc7\x89\xc5\x34\x92\x12\xe6\x27\xc5\xbb\x73\x3e\x92\x33\xa7\x15\xfe\x88\x11\x31\xc7\x89\x90\x2c\x59\x32\x57\xaa\x70\x97\xfa\xc4\xbe\xd3\x35\x19\xdc\x5c\x2c\x14\x71\xc4\x43\xa1\x10\xf6\x0e\x3f\xd2\x93\x98\x93\x4f\x5a\xd2\xd8\x75\x88\x0e\x03\xd2\x6e\x90\xb4\x97\x23\xa3\x43\x2e\x67\xc4\xfe\x68\xdb\xa3\x5d\xa8\x08\x91\x30\x12\x6c\xf2\x61\x04\x50\x9c\x9e\xd2\x06\x16\x1b\x09\x4e\x43\x2b\x09\x1e\x93\x5c\x14\x07\x70\x6c\x09\x1f\xc1\x97\x92\x7e\x27\x55\x0b\x8f\xdb\xe8\xb1\x30\xc7\x46\x7f\x64\x73\x6f\x7c\x79\xcf\xfb\xe3\xeb\xc7\xdf\xb9\x74\xa7\x67\x37\xda\x1e\x62\x30\x76\x1a\x35\x3e\xb3\xdb\xd0\xee\x46\x81\xae\x4b\xdb\xc6\x57\xed\x3d\x51\x3d\x1a\x3c\x34\x07\xc7\x8d\xb7\x93\xfd\x84\x31\xa8\x56\x10\x9d\x3d\xd9\x69\xf4\x93\xcb\xc5\x58\x03\x0a\x30\xe9\x74\x14\x66\x7e\x32\x49\x00\x22\x31\x40\xd1\xfe\xee\xda\x83\x91\xed\x75\xcd\x39\x7c\xdd\x76\x69\x0e\x1c\xb9\x03\x5e\x7d\x66\xe5\x53\x4f\x8f\xb4\x82\x8d\xee\xb7\xa2\x99\x45\x51\xb0\x68\xcf\x89\x6d\xf0\x5f\xa7\xdf\xba\x07\x80\x01\x54\x7f\xf3\xe2\x99\xb1\x75\xaf\x82\x41\x97\x5f\x87\xeb\x54\xaf\x6e\x79\x11\xfe\xbe\xe1\xd4\xde\x60\x99\xa6\x6f\x35\x99\xbb\x7f\x0b\x74\x59\x48\x9d\xea\x70\x1e\x31\x5b\x12\x53\xe6\xd2\x18\x8d\xea\x12\x97\x34\x94\x66\x24\x46\x89\x91\xd5\x2b\x58\x2b\x12\x13\x6c\x6b\xb6\x62\x46\xa2\x20\xd8\x3c\x09\x72\x51\x36\x7e\x45\xb1\x75\xfc\x18\xc1\x22\xb1\xde\x60\x25\xcc\x1b\x4f\x2a\xa3\x56\x19\x0f\x5c\x38\x7a\xfd\xe7\xdb\xcf\x6d\x16\x6f\xd8\x39\xbe\x0d\xf1\x9d\x92\x83\x93\x1e\xfd\x55\x59\xb8\xb1\x62\xfc\xc2\x12\x17\x1c\x96\x92\x3e\x71\xfd\xac\x9d\xc7\xe6\xd8\x2c\x35\xb5\xad\x03\x19\xb8\x3c\x37\xa1\x7a\x43\x52\xa7\xbe\x0b\x33\x31\xff\x79\x03\x9d\x9f\x53\xdc\x40\xb4\x17\x2d\x4e\x15\x6b\x28\x75\xb1\x2c\x25\x55\x2a\xfd\x91\xb2\xc4\x52\xbe\x02\x8d\x78\xbf\x04\xfd\xce\x17\x2a\x9b\xc6\xce\xad\xe1\xf5\xb1\xd9\x61\x4f\xbd\xfc\x76\xff\x8d\xc1\x10\x76\x02\x19\x6f\xbc\xfb\xdd\xbc\xef\x57\x74\xa1\xed\x52\xd1\xed\x63\x97\xc6\xf5\xcb\xdd\xfd\xd6\x47\x6f\x6d\x81\x7f\x1c\xd4\xc3\xc3\x3c\xdf\xdb\x89\xfa\xbd\x45\x62\x84\x51\xbf\x81\x00\xa9\x47\x81\x7e\x94\x9f\xba\xd4\x25\xf7\xe3\xfb\xf5\xb9\x38\xb4\x68\x3c\x49\x45\x21\xc0\x1b\xcf\xe4\x01\x14\x07\x6b\xba\xac\x7c\x76\x37\x88\x3e\x3b\xef\xf5\x1a\x78\x7f\x74\xdf\xcd\xdb\xeb\x06\x5a\x9c\x09\x63\x41\x51\xe0\xbd\xdd\x27\x41\xe8\xb6\x81\x7b\x46\x72\xb9\x01\x7d\x6a\x8f\x1d\x99\xd2\x28\x92\xba\x79\x8c\x7a\x2a\x0d\xf1\xdd\xd1\x5c\x3e\xea\x3f\xd4\xa9\x04\x81\xa5\xb8\x16\x65\x10\xc3\x13\xa0\x6f\xcd\x2c\x25\x25\x28\x5b\xab\x37\x74\x06\x56\x9d\x4f\xb5\x16\xb1\x86\x99\xe2\x44\xbd\xc3\x0f\x71\xef\x20\xc8\xdb\x7b\x3d\x97\x0f\x8f\xe0\xfe\xe1\xbf\xda\xf5\x4f\xa7\xf0\xfd\x6b\xd0\xfe\xe1\xe3\xbd\x90\x7c\xd2\x22\x01\x5a\xec\x32\x9a\x29\xff\x62\x17\x87\xd9\x7e\x8a\x4f\x2d\x12\x9f\x18\x2e\x6f\xf9\x18\x4e\x00\xac\x72\x20\xbb\x88\xfe\xd7\xd9\xf7\xe1\x17\x3d\xcb\x27\xac\x0a\x1f\xa8\x3c\xe2\xc9\x9e\x5a\x78\xf9\x03\x65\x51\x2a\xe8\xc6\x16\x9d\xd9\x4b\x42\xb6\x76\xbf\x04\x13\x4b\xb3\xde\xe1\x33\xa6\x2e\xbf\x56\xd0\x0f\x6c\x00\x32\x10\x8b\xef\x76\x87\xa3\xb9\x40\x6b\x81\xb1\x5f\x4c\x18\x5b\x48\x45\x2d\xa0\x4d\x94\xf2\x04\xdd\x27\x08\x28\x82\x40\x10\xa5\xaa\xa8\xe0\x41\x1f\x19\x72\x47\xf7\x14\xda\xf7\x0a\x52\xd9\xdc\xe1\x0c\x11\x2b\x23\x94\x11\x25\xad\x8e\x22\x05\xa5\x30\xa3\x5f\x75\x24\xda\x5f\xf1\x0f\x91\x00\xed\x33\x40\x00\xef\x77\xc1\xc0\xf1\x8c\xc7\xa1\xfe\x17\x9d\xf5\xc2\xd1\xa6\xb1\x03\xfa\x4f\xbe\x3a\xc7\xbd\x01\xac\xb9\x59\xdd\xdf\x1e\xdd\xa3\xd7\xcd\x65\x77\x16\x4e\xee\x37\xfe\x0e\x9b\xd9\x38\xa1\x76\x53\xb8\x61\x5c\x9f\xba\xed\xfd\xe8\xb9\x21\xce\xcc\xa8\x38\xb5\xbb\x63\xff\x7e\x1d\xd3\xb0\xae\x52\x8c\xeb\xc8\x93\xda\xb6\x51\x98\x4a\x0b\xe2\x69\x88\x75\x28\x44\xa1\x22\x44\xa5\x48\x64\xd6\x9a\x65\xc5\x2e\xb3\x5e\x8b\xac\x38\xed\x3f\xc7\x2b\x90\x5d\x26\x0e\x7f\xcc\x33\x24\x04\xc3\x38\x88\x06\x4a\xaf\xeb\x5f\xd5\x77\x74\xe4\xa6\xba\xa2\xee\xd5\x3b\xcb\x6b\x3b\x7f\xf4\xfd\x73\xf0\xc6\x85\x73\x1f\xbc\xb4\xe6\xd4\xec\x2f\x98\xad\x03\x0a\xb2\xd2\x8f\x17\x57\xa7\x77\x9d\x76\x77\xed\x82\x45\x47\xbe\xbe\x71\x11\x5e\xda\xbf\x75\xfe\xec\x9d\xb2\xb8\xe6\x21\x9b\xfb\xf1\x77\xe9\xdc\x0e\x2e\x89\xb2\xe1\x3c\x0f\xb5\xa1\xcc\xa5\x55\xcb\x9d\x34\x28\xe3\xef\xd4\x43\x4b\x5d\x41\x4a\xb9\xd2\x2f\xb2\xac\xf5\x52\xbd\x0d\x1e\x25\x5f\xac\xba\xed\xe5\xba\xc1\x1b\x2b\xa0\x00\xff\xf5\x9a\x7d\x6a\xdf\x42\x10\xd8\xbb\x87\xcd\x11\x92\xda\x43\x19\xfb\x8f\x37\xee\x11\x80\x23\x45\xa0\x3f\x68\xbd\x78\x07\x88\x27\x53\xec\x41\xe1\x7e\x4d\x0d\xfc\x8a\x5d\xb3\xc1\x6a\xa4\x8d\x02\x09\x1b\xa0\x10\xf1\x28\xc3\x58\xde\x57\xc4\x79\xd4\x3f\xfe\x0f\xed\x5f\x06\x56\x97\x81\xc0\x9b\xf0\x9b\x81\xb0\x61\x20\x32\x87\x91\x40\x47\xd2\x11\x99\xa3\xd7\x61\x32\xd1\x23\x98\x96\x2f\x84\x1c\x07\x7c\x5f\x19\x86\xf1\xb3\x81\xd4\x2c\x2d\x73\x31\x66\x9d\x46\x5d\x36\x48\x43\xf1\xf7\x95\x22\x3d\x52\x7d\xcd\x54\x1b\xe8\x6c\x4f\x58\x07\xd2\x35\x05\x75\x57\xb8\x9c\xc2\x37\x95\x24\x75\x87\xe7\x1e\x4c\xe8\xb6\xe8\x6d\x11\x0f\x2f\xad\xd8\xf3\xdd\xcd\x91\x8b\x48\x66\x03\xb9\xaf\x74\x67\x16\xf5\x52\x06\x34\x96\x0c\x48\xb9\x7a\xf5\xd6\xed\x15\xd3\x0f\x9d\xa3\x5f\xc6\x17\x97\x0f\xc2\xfa\xf5\xcd\xec\x96\x6b\xb3\x0b\x58\x10\x63\xd9\xa5\x64\xec\x81\x4e\x7f\x31\xf0\x67\x02\x14\xfe\x3a\x11\x5f\xb8\xcd\xa3\x73\x68\xf8\x5b\x71\x0c\x1b\x09\x6e\x5f\x58\xda\x87\x5c\x84\x7f\xfd\x2c\xb4\xc1\x9b\xe0\x1a\xfc\x1a\x8d\x5a\xdf\x17\x6c\x7c\x90\xca\x94\x42\x27\x78\x8e\x5e\x8f\xf9\xc2\x38\x34\xf8\xb7\xd0\x7b\x39\x4a\x75\x82\x56\x00\xb6\xcc\x05\x04\x33\x9f\xd4\x4d\xc1\x18\x69\xbb\x1e\x5d\xbf\x09\x8c\x2f\xd2\x81\x6c\xe6\xa3\x75\x42\xee\x02\x77\x82\xd4\x42\xc1\x55\xc3\x8d\x7c\xa5\x27\x8a\xc5\x49\x17\x61\x24\x76\x31\x0a\xc7\x2e\x02\xf3\x13\x62\x17\x81\x45\xed\x68\x9b\xa7\xe0\x6b\x87\x02\x9f\x18\x13\x66\x26\xfc\x26\x3f\xc9\x37\x49\xa1\x93\xf9\x9d\x2d\xa4\x7e\xb8\xbd\x87\x02\xce\xf7\xa4\x2b\xc0\x01\xa0\xfa\x37\x6f\x82\x02\xe8\xb0\x74\x03\xda\x38\x99\x45\x30\xca\x27\x4d\x01\x8d\x33\x46\x90\x3b\x61\xd8\x22\xe4\x10\xff\x0d\x42\x1a\x30\xbe\x30\xe5\xf0\xd0\x43\x74\x32\x95\x0a\x99\xa9\x2a\xb6\xd5\x2d\xe5\x85\xa0\x27\xf7\x16\x4f\x16\x45\xa4\x4e\x13\xbe\x95\x2c\x04\x7d\xd2\x9e\x24\x92\xfc\x41\x51\x24\x3c\xac\x85\x5f\x6a\xe1\x21\x10\x0e\x54\x8f\xc9\xa7\xf8\xd3\x35\x35\x98\x3e\x64\x44\xb0\x37\x11\x7d\x91\x98\xbe\x50\x3f\x24\x1f\x38\x11\x57\xec\x8a\x40\x0c\x24\x54\xa4\x60\x14\xc6\x52\x97\x4e\xc1\x32\xad\x92\x8a\x04\x70\x79\xe8\xb3\x12\x22\xd0\xff\xff\x45\x70\x59\x58\x39\x3c\x44\x28\x39\x1c\x09\x8a\xfc\x57\xec\xf5\x11\x62\x5b\xb6\xd6\x0e\x0a\x77\xc6\xa7\x81\x3e\x35\x35\x35\xa7\xe3\x0d\xff\x6a\x23\xc9\x4e\x1c\x9a\xda\x20\x92\xc2\x9f\x31\x3f\xd6\x22\x3e\xf7\x13\x3a\x27\x5a\x24\x49\x22\xa9\x2e\xce\x88\x08\x05\xa5\x0a\x57\x84\x97\xb9\x14\x0a\x19\x0f\x05\x19\x48\xa0\x20\x43\x08\x14\xa4\x5a\xa8\xfa\xd2\x2e\x0c\xdb\xa3\xd7\xb5\x83\x83\x24\xd6\x23\x06\x7e\xf4\xad\xd1\xa8\x61\x00\x18\x23\x29\x9a\xd4\xbb\xac\xfe\x40\xed\x88\xe8\x8a\x8b\x7d\x30\xe6\x63\x3c\xa8\x8b\x76\x1f\x8d\x32\x39\x86\x38\xb2\x52\xaa\xb3\xbe\x9a\x04\xb6\xf6\xad\xd9\xb7\xf3\x22\x58\x74\xad\x02\x7c\x02\xc7\xbe\xe1\x2e\xbf\xca\x88\xf3\x73\x37\xc0\x9f\x5e\x5e\xf9\x0c\xd0\x02\x99\x7b\x2f\x7f\x1f\x47\x53\x69\xb0\x3f\xfb\x09\x1a\x43\x02\x95\x45\x95\x39\x3b\xc4\x68\x34\xd1\x25\x2e\x8d\x46\x69\x32\x59\x8a\x5d\x21\x26\xb3\x3a\x4e\x19\x57\x86\x4e\xbb\x00\x6d\x99\x42\xc6\x93\xf1\xdf\xa0\x2d\xed\x6d\x1c\x71\x8f\x41\x5c\x7a\x94\x41\x51\x9b\xc2\x11\x71\x80\x58\x55\xed\xe0\x2f\xc1\xb0\x36\xa0\x97\x7d\xc0\xe7\x56\xf8\x9f\x82\x01\xe3\xde\x99\x3b\x63\xa3\xe8\x6a\x40\x82\xb5\xaa\xae\x7b\xb7\xc8\xc8\x87\xf0\xd7\x99\x6d\xf0\x30\x7d\x01\x30\xe1\xd8\x73\x70\x95\xfe\xd9\x39\x87\xe0\x9d\x3d\x6b\xa6\x74\xeb\x93\xf7\xc9\xc9\x21\xfd\x4e\x81\xa1\xee\x99\xed\x80\x31\x29\x82\xb3\xd8\xd2\x12\xc3\x7e\x44\xf2\xeb\x3a\x60\x44\x20\xaa\xdc\x99\xac\x4e\x50\x26\xa0\x53\x6d\x2f\x76\x25\x52\x06\xa0\x64\x0c\xe8\x03\xcd\x07\x2d\x6b\x1b\x58\x9d\xae\x01\xc8\x80\x0c\x0d\xc1\x3c\xc3\x7e\xe5\xf1\x44\x25\xa1\xd0\x8f\x07\x9b\x21\x06\x3c\xbe\xda\x3e\xaa\xbc\xd8\xc6\xb4\x5b\x78\x52\x4a\x14\x6b\xf6\xf4\x9b\x70\xcd\xe3\x7b\xa0\xd7\x80\xad\xdd\xd2\x33\xb6\x6c\xce\x19\xba\x72\x47\x9b\xad\x50\x11\xa0\xb1\xc7\xa8\x53\xd2\xdb\x6f\x89\x03\x47\xab\xfb\x1e\xb9\xf4\x41\x2c\x73\xb4\xfd\xce\x70\x7f\x10\x5e\x52\x90\xc6\xef\x8f\xbe\x68\x52\x5e\xe3\x3a\x22\x49\x9e\x41\xa5\x3b\x83\x52\xc3\x23\xc2\x8b\x5d\x51\x4e\x2a\x42\x11\xab\x30\x33\xe6\x8c\x32\x97\x59\xc7\x48\x8b\x5d\x7e\x4c\x9b\xb8\x78\xcc\xe2\xf8\xa0\x5c\xcc\xe7\xd2\xc9\x2d\xad\xd8\xd1\xea\x8f\x64\x70\x91\x6a\x21\x2f\x85\x54\x15\x01\x64\x1b\x24\x92\x08\x57\x47\x04\xd1\xb5\xc0\x47\x20\xab\x5b\xaf\x65\x4f\x5d\x05\x69\xd9\xa5\x85\xce\xd4\x75\x45\x49\xba\x1b\xd7\xa0\x72\x48\xe7\x80\x69\xc3\xac\xf5\x0d\x6b\x01\x5d\xd6\xad\x53\x9f\xf4\x59\x95\x89\xf3\x6b\xfd\xb2\xd8\x4c\xdd\xd2\x85\xba\x20\xbd\xc3\xd1\x25\x3f\x29\x5d\xd9\x21\xa9\x6b\x41\xf2\xc9\x4b\x63\x9c\xf1\x1d\xe9\x31\x67\xe1\xc3\x0d\xd9\x99\x31\x59\x46\x95\x6d\xca\xe0\xde\xd5\xee\x7b\xb1\xc1\x3d\xf8\xf1\x6d\x41\xfc\x7b\x3e\xf7\x1e\x15\x4d\xf0\xc1\xc3\x82\x23\x4a\x5d\x61\xc1\x66\x95\xbe\xd4\xa5\x51\x51\x1d\x88\x9f\x49\x2a\x71\xfa\x29\xa8\x98\x52\x97\xcd\x1b\x37\x6a\xba\xe6\x5b\xb8\xce\x1e\xe7\xad\xd8\x26\x54\x48\xc1\xf5\xeb\x5a\xfd\x66\x3e\xbe\x44\x91\x23\x05\x3d\x44\x7c\x42\x60\x62\xd3\x40\xbf\xa6\xa5\xd6\x4d\xcb\x0e\xa6\xbc\x16\x3e\xfe\xc4\x42\x57\x76\x4c\x54\x61\x8f\x7e\xea\x4f\x6d\x77\x5f\x8b\x1d\xa8\x89\x4d\xeb\x96\xe4\xb4\xa9\x87\xe7\x46\x46\x2e\x7c\x6d\xb4\x28\x52\xdd\x50\x68\xed\x40\xcf\x3a\x0b\xe1\xde\x5d\x65\x5e\xbf\x27\x76\x35\xda\x7a\x8f\x36\xdd\xf6\xa3\x0f\xba\x3f\x0f\x33\x5a\xb3\xf8\x71\xe5\x13\x2c\xa8\x8e\x78\x54\x54\x81\x33\x26\x3a\xad\xcc\x15\x65\x48\x66\xa2\xa3\x13\x82\x13\xd0\xf1\x4d\xd0\x07\x47\x14\xa3\x91\x2a\x15\xc2\x10\xd1\x08\xb5\xad\x55\xbc\xdb\x55\x26\xf4\x78\x04\x91\xdd\xd9\x66\x98\xe2\x08\x8f\x52\xcc\xef\xe3\x30\x15\xef\x72\x16\xf3\xce\x4b\x72\xc4\x45\xde\x74\x87\xbf\xfb\x55\xfa\x35\x35\x58\x67\x8c\xdd\x9d\xb2\xd2\xba\xb2\x4e\x62\x36\xf7\x0a\x11\x37\x7d\xb9\x09\xa8\x7e\xb2\x46\x77\x9b\xac\x9e\x31\xaa\x7e\xe2\xe7\x27\x72\x27\xc7\x35\xd2\x9a\x82\x8e\xa3\x4d\x85\xce\x3c\x6d\xed\xc0\xc8\x58\x32\xe6\xb3\xee\x0f\x13\x43\xd2\x13\xe3\xc3\x12\x6e\x80\xc2\x13\x70\xb3\xb2\xbe\xe0\xc7\x17\x5d\x63\x47\x1e\xfc\x2c\x33\x7d\x3c\xe8\x55\x30\xb9\x92\x8f\x8d\xcc\x42\xba\xcb\x41\x74\x7e\xd3\x30\x3a\x4c\x7c\x32\x1a\x69\x3c\x85\xa8\x40\x52\x38\xcd\xa6\xa0\xb9\xb0\x48\x9d\x1c\x8d\x53\x25\x37\x73\xe6\x52\x17\xe7\x1b\x35\xc6\x07\xb7\xb5\x26\x9b\x88\xc4\xff\x14\x55\x20\xc4\x20\x60\xe7\xa2\xa7\x2e\xbd\x47\xdf\x63\x74\xac\x34\x6d\x62\xfe\xe0\x2a\xf5\x86\x88\xb5\x13\x83\x07\xea\x62\x33\x4d\xd9\xa6\x45\x9a\xfc\xcc\xd1\xc6\x86\xcf\xf6\x97\xef\xbf\xbb\x7f\x94\x75\x94\x3e\x78\x69\x63\xe7\x1e\xd6\x44\xbd\x2d\x4a\xa6\x62\x33\x93\x0b\x7a\xe7\x35\x4d\xed\x53\xe1\x66\x8f\xbc\x20\x17\x7f\xa8\x9b\x49\x1f\xa9\x76\xce\x38\xb4\xd8\x7d\x06\x47\xbb\x32\x4d\x67\x1b\xd6\xad\xd2\x9e\x56\x3b\xbb\xf4\xe3\x7d\x45\x3f\x12\xac\xd1\x2b\x54\x2c\xce\xf8\xf1\x0f\xb6\x69\x18\x91\x4d\x54\xec\x8a\xb1\xe9\x71\x5c\x39\x4e\x52\xf7\x84\xd0\xf8\x5c\x5f\xf2\xd9\x29\x18\x61\xb7\xcd\x45\x41\xba\x6f\x34\x79\xeb\x45\x81\x58\x03\xc2\xfe\xfe\xba\xd3\xdb\xf5\x93\x27\xe7\x8e\x19\x3d\x2a\xeb\xb7\xcb\x9b\x9f\x63\xef\xb3\x69\x3d\x8b\x4a\x73\x6b\xa7\x0f\x75\xc0\xbf\xfe\xf3\xd3\x26\x05\x77\xe5\xe1\xa0\x4e\xdd\x72\x8b\x92\xb3\x23\x2c\xdd\x86\xe5\xef\xbb\xb2\x61\xb5\xa9\x7b\x56\xb7\x9c\xb8\x4e\xd6\xb8\xee\x23\xba\x1f\xbf\x38\xac\x0f\xde\x8b\x18\x03\xf7\x18\xa2\xd7\x0f\x69\x6c\x11\x4e\x35\xe7\xcf\xf8\x23\x6d\x52\x01\x28\x91\x84\x92\xf8\xe2\x0b\x78\xa0\x05\x80\x47\xf6\x31\x48\x56\x84\x7d\x59\x44\xdf\xb3\xb9\x37\xd0\xca\x68\x77\xf3\x42\xba\x06\x07\xf1\xbc\xed\x1e\x7c\x95\x19\xe7\xee\x4f\xbf\x88\xdf\x3f\x99\xa2\xb8\x78\x12\x67\x15\x4f\x65\x3a\x83\x62\x23\x22\xc2\x82\xa2\xa2\xe2\x2c\x5a\xa9\x14\xf8\x5b\xd0\xff\x8a\xc0\x30\x1d\xa7\xa0\xf4\x12\x8a\xe8\xc5\x02\x08\x31\xc9\x89\x17\x3e\x48\x5c\x55\x04\x13\x95\xe6\x50\x60\xc7\x98\x5d\x93\x03\x34\x76\x0d\x62\x5a\x38\x42\x86\x89\xea\x0c\x84\xaf\xf1\xa5\xaf\xc6\xa0\x43\xec\xfa\xd7\x37\xa3\x19\x10\xab\x3f\xf7\x66\xec\xa1\x80\x48\xe5\xa9\xb7\xa3\x98\x5b\x07\x60\xdc\x9b\x36\x46\xf8\xce\x2a\x3f\xfd\x4e\x14\x7d\xeb\x00\xa3\x07\xf3\x43\x9c\xe9\xa3\x12\xe1\x6c\xfa\x38\xf4\x1f\x14\x09\xa6\xc2\x25\x46\x47\x22\xf8\xf3\x41\x6a\x9b\x7f\x19\x69\xc4\xff\x12\xe5\x02\x7f\x52\x02\x4e\xfa\x6d\x34\x26\x31\xb2\xe3\x6c\x4e\xad\x1c\xc7\xcd\x71\x72\xf4\xbf\xc8\x5f\xa6\x13\x31\xa5\x2e\x7c\x3d\xeb\xf1\xb1\x11\xed\x07\x0f\x00\xa7\x90\x22\xbd\x57\xf8\xc9\x4e\xfd\xc9\x0e\x6b\xed\x3f\x0d\x61\x1a\xe1\xbd\x9f\x52\x61\x6d\xea\x4f\x95\x4c\x23\xf3\x25\xf0\x87\x7f\x82\xaf\x51\xf7\xe4\x27\xaf\x13\xa6\xa0\x73\xf3\x0e\x8b\x6b\x2c\xa2\xde\x22\xcd\x14\x63\x51\xa8\x34\x1a\x19\x0e\x0c\x61\x82\x5b\x63\x50\xbd\xf7\x94\x7c\x20\xaa\xcf\x8d\x85\x02\x78\xae\x2c\x84\x90\x5e\x5e\x01\x67\x34\x9d\xd6\xd5\x4d\x99\xa1\xcc\xe1\x26\xa4\xe4\x86\xc7\x4c\x2d\x5f\xb6\x4c\x19\xe7\x5f\x57\x32\x2b\xa4\x01\x88\xe0\x27\xf0\x41\x9f\x2d\xae\xb2\xb9\x33\x7a\x97\x83\xfc\x20\xdd\x68\xa5\xdf\x7b\xc1\x6b\x96\x76\xe9\x7b\xaf\x57\xf0\xea\xbd\x4f\xd1\x5d\x1f\x04\x83\x0d\x3c\x7d\x83\x10\x7d\x23\xd9\x7c\x3e\x43\x58\xe4\x1f\xa5\x30\x18\x8d\x9a\x52\x97\x51\xe9\x1f\x5e\xea\xf2\xd7\x27\x52\x54\x7c\xe9\x63\x59\xcd\x3c\xad\xc2\xcd\x4a\x0e\x68\x4b\xb0\x88\xdc\xb1\xa8\x7c\xe8\xb5\x7b\x83\x5a\x98\x55\xd3\x9b\x94\xba\x8e\xb3\x8a\x6a\xea\x55\x39\xe2\x32\x79\x4a\x61\x6c\x43\xc1\x0f\xea\x78\x49\xa9\x73\x7c\x70\xc3\x6f\xd7\x64\x03\x92\xcb\x62\xab\xe0\x80\xd5\x8b\xbb\xf4\x1d\x53\xe0\xe0\xe9\x8f\x30\x0e\xf1\xd7\x7e\x10\x0a\xff\xe8\x36\xf8\xcb\xd2\xa0\x05\x2f\xae\xa2\xbb\x3e\xbc\xe7\x8c\x9b\x1d\xfa\x51\x28\x3f\x86\x07\xe0\x3b\xe6\x01\x5a\xb7\x40\x2a\xf8\x14\x15\x08\x52\x8e\xd0\x22\x83\xec\x15\x90\x40\xa9\x29\x11\x48\x16\x4c\x36\xec\x6c\xa6\xbd\x71\x36\x18\x04\xa8\x95\xe3\xd0\x33\x72\xe5\x74\xfa\x8c\xc2\x51\xa3\xfd\x06\x9f\x2d\x56\xd7\xe4\x4f\x54\x14\x9f\xbf\x20\xa2\xe0\xae\xec\xc2\xdc\x51\x55\xea\xae\x50\x0b\x9a\x8b\x6c\x83\x26\xf6\x85\xfd\x58\x7d\x9b\x3e\xc3\x28\xcb\xe1\x10\xb3\xf1\x24\xb0\x1f\xa1\xd8\x00\x1d\xee\x55\x49\xb1\xad\xbd\xf2\xa9\xae\x4f\xec\xd5\xcb\xdf\xc4\x74\xec\x63\xbd\x3f\xa7\x5e\x36\xb1\x63\x07\x53\xa4\xbe\x4a\xc3\x56\x3f\x46\x04\x53\x5e\x51\x25\x5d\xe5\x3f\x9c\xc8\x24\x30\x88\x3a\xc7\x2c\x17\x61\xcd\x59\x49\x99\x4f\x51\x52\x90\x74\xd8\x4f\xc4\xbe\x02\x08\x82\x38\xb0\xf3\x4e\x6a\x3c\x7e\xa1\xa0\x91\xc1\x53\x4c\x88\x3e\x64\x3e\x67\x86\x83\xbb\xc5\x05\x46\x27\xc6\x06\x6c\x3e\xb7\x4b\x37\x85\x1b\xbb\x76\xed\xc3\x12\xd9\x42\x26\xad\x33\x63\x7d\xb4\x6f\x54\x2d\x7a\xc3\xd3\x68\xac\x9f\xb1\xbf\x21\xbb\xd5\x7c\x34\x40\xa4\xa2\x15\x67\xd0\xf8\xfc\x41\x12\x9a\xdd\x04\xbe\x60\x91\xe7\x5a\xdf\x03\xf9\xc5\xdf\xa3\x33\xe7\x53\x82\x9e\x4d\xcc\x3f\x57\x2f\x32\x1c\xd7\xd2\xc9\x95\x5d\xac\x16\x36\x57\xf2\x37\xdc\x48\xf7\x0c\xda\xb0\x75\x50\x91\x3f\x7a\xf7\x00\x70\x87\xd9\xc6\x7e\x49\xde\x2d\xe5\xc8\xbb\x13\x29\x09\x7a\x2f\x87\xde\xdf\xfa\x6e\x22\x22\x30\x8e\x7b\x84\x10\x22\x01\x26\xfb\xbe\x3b\xa1\x1a\xbd\x9b\x5e\x21\xf9\x1b\xd4\xba\x4f\xa0\x77\x97\x97\xe0\x77\xdb\xa8\xb3\xcc\x18\xf4\xee\x20\xb4\x46\x3a\xb5\xe1\x24\x48\x3d\x0c\x58\xe9\x49\x34\x3d\xfe\x22\xf6\x24\xea\x07\x4f\x8b\x67\x8d\x22\xbc\xb9\x12\xb8\x23\xb1\x6f\x41\xda\x74\xba\x07\x93\x38\x22\x2f\xce\x1c\x9a\x12\xb4\x27\x29\xff\xdc\x16\xc6\x12\x1d\x1d\x1e\xd4\xcd\x51\x3e\x90\xa3\x17\x95\x97\x4a\x9e\x45\x1d\xd7\x3d\x7a\x27\x34\x28\xd8\x6f\x83\xb4\x77\xb9\x36\x81\x5f\x17\x1d\xf8\x9e\x6d\x40\xfd\xe3\xd8\xa8\xd0\x13\x8c\x4c\xa6\xd7\x4b\x40\xc0\x2b\x68\x60\x72\x32\x44\xc1\x97\xc0\x33\x49\xc4\x10\x89\x6f\x34\xc2\xa2\xb1\x07\x78\xb5\x77\x7a\xdf\xef\xb7\xe0\x57\x1d\x73\x5f\x78\x05\xee\x5d\x73\x2e\xc3\x39\xaf\x5f\x61\x7a\xc6\x4a\xe6\x08\x48\x81\x47\xd5\x55\xd9\x33\xe7\xd0\x0f\xe0\x35\x78\xa4\x73\x16\x31\xe1\xd1\xbe\xbc\x04\xbe\xe7\xfc\x51\x9f\xa8\xc7\x43\x9c\x12\xf7\xa5\x43\x7d\x25\x1d\xd1\xc8\x80\xff\x49\xd2\xa7\xdd\xce\x5f\x80\xb4\xe1\xbf\xba\x6c\xcc\x97\x89\x21\x71\xf2\x9d\x60\x56\x1f\x7b\xed\x9d\xc4\x83\xfe\xfe\x9d\x4e\x5f\x0d\x62\x53\x8f\x1f\x03\xdf\x83\x77\x53\x4a\x43\xb2\x6a\x60\x32\xea\xd0\xb9\x38\x68\x0d\xd8\x8a\x7e\x2c\x06\xe7\x71\x9f\xbf\x50\x67\xd9\x3a\xd2\xa7\xf1\x88\xbf\x42\x25\xc1\x33\xcc\xd1\x14\x9a\x6f\xa4\xd6\xa5\xe4\xd8\xb1\x80\xb4\x86\x7b\x54\x35\xd4\x1b\x1a\x28\x0e\x91\x94\xd3\x60\x64\x76\x47\x93\x4d\x1b\xd9\xb1\x63\xc2\x53\x97\x92\x45\xaa\xda\x43\x57\x60\x6e\x2f\xd7\xb0\xb3\xb2\x65\x22\x73\x76\x19\xfd\x1d\xdc\x6d\x7d\xd5\xff\x5b\x50\xf5\xe8\xce\xd4\x21\x09\x54\x4b\x0b\x7d\x82\xe9\xcd\x86\x71\x57\x95\x22\x4a\x32\x0d\xd7\x5d\xbb\xc9\xf4\xe6\x38\xf2\x3b\x37\x15\xd1\x42\xcb\x99\x1c\x66\x37\x37\x97\x42\x12\xf0\xb0\x1f\x47\x51\x89\x57\xf0\x50\x1d\x24\x12\x19\x88\xed\x0c\x2d\x8f\x0a\x74\xe5\x9f\x28\x1a\x29\x9d\x6d\x67\x72\x5e\x6f\x3a\xd1\xbb\xe8\xc5\x7c\xf8\x90\xf2\x6d\xeb\x8f\xdb\x22\x93\x3d\xf1\x0a\x46\xad\xc5\x95\x78\x23\x70\x95\x7f\x66\x37\x69\xda\x1c\x32\x3b\x85\x9b\x8b\x5b\x3e\xbf\x01\x70\xb8\x5d\x37\xd4\x6e\x3b\x6a\x27\x45\xed\x68\x24\x59\xf8\x76\x0c\xae\xe6\x67\x88\xe0\xb3\x32\xb6\xdb\x67\x8b\x7a\x9d\xb0\xab\xa3\xb8\xb9\xf0\x61\x98\x65\xd6\xac\x61\x93\x0b\x06\xbf\x8e\xda\x8e\x66\xa7\x30\xd3\x44\x00\xb5\x95\x1e\xa1\x19\x89\x3f\x95\x68\xbf\x86\x5b\x7b\x30\x4f\x71\x4e\x11\xfd\x67\xb9\x61\x50\xcd\x86\x19\x86\xce\x99\x5c\x2f\xe7\xe4\x7e\xbd\x6b\x67\x4f\x74\xa0\xb6\xcb\x51\xdb\xad\x42\x5b\xb1\x48\x8a\x06\x9b\x42\x7a\xe6\x1d\xef\xc4\xc5\x67\x67\x8a\x06\xd5\x6c\x9c\x6e\xc8\xce\x28\x67\xa7\x94\x15\xd6\xcd\x9e\x9c\x1a\xdb\x15\x73\x85\x06\xf0\x1d\x2b\xe6\xf6\xa2\x35\x0b\x3c\xa6\x63\x98\x00\x7f\xc5\x69\x64\x60\x51\xe4\x40\xdb\xed\x19\x04\x81\x47\xe3\xf5\x0a\x0b\xd9\x59\x24\xfd\x1d\x5c\xee\x13\x63\x77\x4d\xca\xcd\x9e\x90\x78\x30\xf6\xd0\x92\x0d\x3b\x4e\xae\x4b\x02\xdf\x81\x2d\xb2\xcd\x33\xb2\xf2\x17\x25\x34\xce\xdf\xb2\xb6\xf9\x53\xbd\x1b\xf5\x31\x0a\xf5\x11\x8d\xfa\x30\xa0\x3e\x80\x16\xc9\x5a\xf1\xe3\x7d\x10\x6f\x42\x5b\x65\x09\x17\xe7\x06\x7f\xd9\xcb\xc7\x7c\x76\x76\xde\xa6\x80\xd7\xb8\xce\x69\x15\xc3\x3b\x67\xa5\x24\x95\x82\xef\xdc\x8a\xf5\xb5\xaf\xff\xd2\x34\x2d\xa1\x7b\xce\x92\x69\xf9\x45\x32\x38\x0a\xfb\x7a\x9f\xa5\x66\xb2\xcf\xb3\x78\x0f\x84\x3a\xf1\xef\x03\xd1\xef\x15\xe4\x77\xcb\xbf\xb1\x5e\xe7\xa6\xae\xb1\x85\xec\xbb\x94\x08\xcf\xb1\x88\x01\x68\x8e\x31\x1e\xb1\x35\x82\x01\x11\xc0\xc2\x16\x7e\xf1\x0c\x34\xde\xa7\xfb\x80\xae\xd7\x18\xe7\xa3\xf3\x2c\xc3\xdf\x21\x5c\xe3\x74\x42\x1b\x11\xc3\x7a\xdb\x58\xd0\xf6\x05\x76\xfa\x12\x3c\x7b\xee\x7e\x33\xf8\xea\x8b\x6b\x2c\xf3\xe8\x3c\xe3\x24\x9c\x76\x02\xbb\x93\x75\x71\xc7\xd0\xfe\xd1\x38\x25\x7e\xec\x1a\x97\xc8\x6f\xe5\x20\x5a\x44\xe1\x78\x6b\xbc\x91\x22\x08\xcc\x9e\xd5\x8e\x1e\xda\x79\x88\xfd\x71\x17\x07\xec\x5f\xb2\xaf\x04\x2d\x5a\x14\xf4\x80\xb4\x6f\x46\xed\x97\x91\xf6\x7a\x67\x80\x98\x01\xcc\xca\x41\x80\x5b\xe3\x42\x7d\x7b\xae\x55\xbc\x28\xc9\xcc\xc0\x2f\x6f\x8a\x08\x10\xb2\x88\xdd\xc9\xa3\x1d\x03\x7a\x15\x3b\x82\xa9\x21\xf5\x12\xfd\x0e\xd1\xa8\xd5\x55\xa2\xba\xd8\x99\xf0\xf5\xdd\xd6\xb3\x23\xc0\x28\xdc\xc7\x31\xf6\x08\x9b\xc1\x0d\x42\xcf\x04\x1c\x65\xa8\xb5\x2e\x86\xf2\x94\xe5\x04\xef\xd3\xc3\xc3\xdc\xdb\xb8\x41\xcf\xe3\x3d\xad\x64\x0f\x33\xff\x46\xef\xe2\xd0\x9e\x66\xe6\xa0\xad\x65\xc2\x6f\x43\xba\x87\x98\xa3\x95\xdc\x5d\x5c\x8d\xe0\x24\x7b\xd8\x4c\xb5\x44\xfd\x41\xce\x4e\x0e\x7a\xfe\xf5\xc7\x9e\xb7\x39\x2c\x06\x31\x13\xf3\x9d\x18\xd0\x33\x38\xf6\xf0\x1f\x51\x2d\x66\x44\xc3\x50\x38\x80\xce\x6c\x39\x4b\xe8\x44\x1f\x1e\x3a\xc1\x1f\x88\x4e\x38\x80\xd0\x49\x2d\x87\xa7\x18\x65\x4b\x15\x79\x86\xac\x18\xb2\x91\x10\x91\x2f\xd1\xc3\x2d\xee\x6d\x3b\x9f\x27\xf3\x25\x86\x63\xe8\xe5\x2d\x8b\x48\x9f\xd4\x1c\xc6\xb7\x4f\xf0\x2b\xdf\x27\x1c\xc3\xf7\x49\x7d\x80\x9e\x3d\xd3\xfe\x59\x0d\x19\xcf\x07\xc2\x70\xe0\x18\xcf\x70\x10\xef\xae\x46\xe2\xb4\x96\xcd\x24\xb5\x27\x65\x47\x45\x88\x9d\x29\x10\x33\x23\x5b\x16\x31\x4c\x0d\x62\xd2\x4c\xed\xd3\x93\xa3\x86\xc3\x77\x9e\x9e\xcc\x66\xc2\xf7\x40\xfc\xc3\x4b\x20\x9e\xf0\x60\x3a\x95\x91\x0b\x6d\xfd\x0f\xf3\xed\xf8\x56\xa4\x05\xff\x30\xa1\x7f\x07\x35\x8c\x3e\x00\x7e\xfc\xef\x67\x3f\xde\x7b\xf6\x81\xa3\xf5\xec\x23\xc6\x3b\x8c\xbe\x21\xb4\xf5\x39\xfb\x56\xdf\xb3\x4f\xcf\xf7\x9c\xfd\x61\xad\x47\x1f\xb5\x1d\x4d\x1d\xa0\x7f\xa2\x25\xb8\xaa\xe6\x51\x31\x4d\x73\x00\x73\x49\x92\xb4\x65\xe1\xed\x4f\xfa\x36\x5c\x17\x38\x2d\xbe\x29\x7e\xea\x81\xa6\x7b\xf7\x48\x9b\xf5\xd4\x01\xc6\x28\xb4\xa1\x38\x4e\xcc\x60\x2e\xc7\x6b\xf7\x58\x26\x3b\x2c\x0c\x98\x8a\x1a\x4c\x0b\x04\xf5\x60\xd5\xbd\x7b\x4d\xb8\xcd\x4c\xd4\x86\x46\x6d\x02\x28\x83\xd3\x1f\x70\x9c\x44\x24\xf2\x3f\x4f\xa6\x1e\x63\x81\xf8\x34\xe6\x3b\xfd\x6e\xaa\xb6\x49\x3b\x2d\x70\x9a\xa1\xc9\x30\x15\xe8\x6b\x6a\x9a\xa6\x4e\xe5\x65\xda\x0f\xd4\x03\x66\x1b\xf8\x98\xdf\xd7\x78\xa4\x18\xf9\xcd\x22\xfe\x21\x9e\x5e\x10\xff\x40\xa0\xef\x18\x3a\x3b\x33\xd0\xd9\x91\xe3\xb3\x23\xe5\x28\x6e\xe5\x20\xca\xff\x29\x17\xd5\x7a\x76\x88\x8a\x6a\xe7\x55\x52\x3b\x4d\xff\x6b\xfd\x66\xba\x79\x6f\xf9\x70\xd3\x9e\x72\x76\xe7\x8c\xc6\x90\x00\xc9\xb8\xcc\x1c\xf8\x1d\x5e\xbf\x51\xec\xef\xcc\x0b\xdc\x05\x72\x46\x28\x7a\xdd\x20\x8a\x3f\x23\x0e\x8b\x98\x1e\x85\x71\x82\xd8\xdf\x31\x2a\x10\x4d\xcb\xd8\x26\xe6\x6f\x51\x00\x92\xef\x46\xc4\x79\x54\x62\xd5\x6a\x97\x18\x17\x0c\x11\x53\x4e\xca\xb0\x9a\xf4\x4d\xee\x32\xe2\xe2\x84\xee\xbd\xb0\xa1\x0e\x1f\xaf\x29\xfd\xe9\xd0\x71\xdd\x16\x96\x56\x8e\x2f\x98\x97\xcd\x97\xf7\x48\xeb\xc2\x36\x0d\xe8\xd5\xa9\xd1\xd9\xb7\x30\xa7\x21\xfb\x26\x5f\xc9\x23\x89\xcc\x05\x08\x40\x67\x67\x25\x92\xe9\x2a\x4a\x73\x42\xa4\xa4\x28\xd9\x1a\xd2\x0f\x29\x63\xe9\x61\xfd\x58\xd4\x79\xa2\x9b\xc0\xfb\x83\xc6\x4d\xaa\xd8\xd2\xa7\xc2\xd2\xc1\x91\x6d\xca\x87\x03\xfa\x14\xf5\xdd\xd5\x21\x61\x71\xaa\x29\xde\xbc\xd4\xc2\xbf\xb3\x02\xcd\xdd\x2e\xee\x34\xe2\xd3\xb1\x4e\x3d\x32\xee\xb8\xb5\x2e\x85\x34\x54\x4a\x63\x38\x6b\x27\xa5\x5a\xeb\xf2\xc7\x93\xde\x9a\xdd\x23\xcc\x67\x02\x8d\x15\xd9\x08\x3c\xa8\x10\x9a\xcc\xaa\x1c\x30\xcb\xe2\x4b\x7b\xe7\x85\x24\xa5\x69\x96\x46\x2f\x1d\xd5\xa1\x6f\xaf\xae\xc1\x29\x76\xed\x62\xeb\x0a\x76\x67\x44\x5c\x44\x6a\xe7\x2d\xf3\xd0\x8f\x8e\x19\x1b\x17\x12\x5c\x16\x76\x07\xab\x43\x6b\xc6\xa1\x1d\xa2\x3e\xe1\xcf\x50\x88\xe1\x89\x49\x57\x9e\x58\x1f\xab\x5d\x6c\x20\x9f\x20\x60\x95\x08\xa8\xbe\xf7\x8b\xe5\x7f\xb0\x3b\xc2\xff\x1d\xf7\x03\xfa\x43\xe8\xef\x05\x6a\x98\x4d\x4c\x06\xae\xee\x7a\x4c\x41\x01\x7f\x2e\x00\x9d\x24\xfb\x95\x14\x7c\x96\xac\x06\x4f\x55\x6b\xa4\xca\x25\x02\x31\x7a\x38\x1c\x74\xc8\x89\xed\x1e\x1b\xbe\x64\xee\xf4\x06\x8e\x2e\x62\x68\xc7\xd2\xde\x9d\x0c\xda\xa3\x1d\xab\xab\x22\x94\xf8\x7d\x95\x8c\x9d\xad\xe2\x7e\x44\x54\x89\x0f\x8a\x29\x23\x9e\x57\x2b\xd2\x9a\xad\x06\xce\x20\xb6\x71\xa0\x12\x98\x4e\xcf\x3c\x0d\x0c\x7d\xe1\x37\xaf\xcc\x3a\x0d\xbf\x62\x76\xfe\xfe\x73\xdd\x4f\x3f\x8f\xf9\xe5\xa7\xfa\x5f\xff\xe0\xf5\xf1\xb3\xec\x60\xa4\x0f\x29\x29\x13\x65\x3c\xaa\x97\x73\x0a\x29\x56\xc4\x54\x48\xa7\x4d\xa5\x5a\xab\x69\x0a\x9e\x1c\xbc\x60\x44\xa8\x10\x57\x9d\x8d\xc4\x0c\x7d\x9f\xb3\x62\xe2\xb0\x31\xdd\xfa\x6f\x7c\xa7\x12\x48\xde\x72\x7f\x14\x1b\x12\x32\x34\x94\x7e\xe1\xd5\xa2\x11\x33\x86\xf6\xcd\x5a\x3a\x8a\xee\x0e\x8b\xc0\xe1\x47\x15\x99\xc9\xce\x01\x4d\x3d\x83\xc3\xf8\x75\xfc\x1d\xe9\xe9\x93\x89\x1d\x20\x7f\x85\x28\xfe\xbc\xa8\x25\xca\x25\x03\x7e\xbf\x78\xee\x0d\x24\x90\xf5\x0f\xf1\x1e\x07\x09\xe0\x53\xe6\x3f\xec\xaf\x54\x38\x15\x7c\x4c\x1a\xcc\x98\x8d\xba\x93\x20\xf9\xb0\x44\xcc\x78\xf4\x62\x4f\x4e\x8b\xb6\xd5\xa1\x4c\x7c\x1b\x5e\x71\x1d\x85\x83\x8c\xf4\x86\x10\xc0\xbc\x79\xa4\x79\xe9\x8e\xa0\x7d\xf2\x82\xc2\x4d\xf6\x11\x73\x27\x3d\xbf\x7b\xe9\x4a\xe5\x3e\x43\xc3\xf2\xac\x86\xe9\x35\xf4\xed\x59\x4d\xc3\x47\x9b\xec\xc9\x43\x23\xa2\x02\x83\xc7\x0d\x1e\x3f\xad\xaa\x56\x57\xd1\xcf\x12\x63\x0a\xae\xc5\xb2\xfa\x36\x22\xa9\x07\x7b\x5f\x29\x66\x92\x68\xec\x69\xc2\x3a\x9d\xa0\x37\xa8\x45\xf4\x3c\x32\xae\x89\x68\x48\xe5\x44\xb6\xa8\x0e\xb1\x88\xc0\xa2\x23\x2e\x16\xb1\x85\x44\x52\xdf\x93\xd4\xe9\x65\xca\x8f\xc0\xeb\xe0\x3e\x67\xd9\xe7\xfb\xbc\x98\x32\xf0\xcf\x1f\x77\xb1\x2c\x10\x93\x26\xfc\xfd\x37\xdf\x4a\x65\xe7\xdb\x25\x1f\x61\x6e\xec\x03\x25\xd4\xff\xad\x2d\xbd\x68\x1f\xbd\xf5\xff\xd8\x16\x74\xd9\xc7\xdc\x6b\x37\x46\xcd\x11\x0e\xf1\x20\xd4\xfa\x10\x91\xfc\xc2\x2d\x19\xdf\x0a\x06\xa1\x46\xfb\x38\xe1\xdc\x4e\x40\x6d\x06\x32\xe3\x51\x1b\xf5\x61\x06\x20\x8b\xa6\xd0\xd3\x24\x11\x37\xc1\xc5\x8c\x99\x81\xd0\x38\x09\x34\x32\xe3\xdd\x74\xdb\x36\x62\x4a\x7f\x48\x04\x50\x93\x63\x2e\x91\x88\xe1\x10\x57\x4e\x14\x42\x03\x70\xe9\x63\xbe\xe5\xaa\x49\xa8\x29\x98\x0d\xe7\x32\xe3\xe1\x5c\xb4\x2e\x0e\xf7\xaf\x6c\x48\x8b\x58\x89\x2b\xab\x4d\xfa\x6b\x08\x91\x93\x47\xd8\x17\xd9\x4a\x51\x10\x5f\xa3\x19\x69\x14\x73\x44\x48\x6f\xb6\x9b\x88\x1e\x8a\x13\xfd\x70\xb5\xc0\x3c\xf7\x36\x33\x3d\xbc\x07\xf9\xe4\xd6\x2e\x83\xab\x96\xf1\x32\x36\x9c\xc9\x61\x57\x10\x7d\x5b\x43\xa9\x8f\xcb\x59\x56\x21\x0a\xc0\xa2\x1e\x9d\x5c\x5e\x38\x60\xad\x1b\x27\xb1\x73\xde\xbf\x31\x2f\x9f\x7c\x16\xe9\xdf\x20\xd4\xaa\x2f\x73\x7f\x7c\x7c\x4f\x30\xf9\xbb\xa1\x2f\x93\xf3\xe2\x7a\xc0\x9e\x6f\x3c\xe1\x3a\xb0\x06\xfd\x9c\x76\x0c\xcb\x0d\x15\xdc\x0a\xf6\xb7\x9c\x41\x3a\x1c\xa1\x8c\xa5\x31\x65\x58\x8b\xd3\x30\x76\x83\xc3\xce\x2c\x9b\x36\x3b\x69\xec\xec\x6f\xd1\x53\x96\x1d\x3b\xe0\x67\x14\x5f\x53\x7f\x2b\x98\x24\xb4\xe1\x68\xa4\x28\x20\x76\x44\xda\x18\x34\x11\x36\x71\x84\xe6\x11\xdf\x26\x0f\x7e\xb6\x63\x07\xe0\xd7\x81\x8a\x47\x4a\xcb\x8c\x96\xdf\x51\x1b\xc9\x61\xf6\x3c\xd6\x7d\xae\x25\x27\x71\x0a\x80\xb8\x85\x03\xcc\x30\xee\x5f\x15\xd8\x12\x20\x9b\xdd\xa7\xcf\xec\x43\x24\x9e\x8c\xf2\x47\xcf\x97\x0b\xcf\x53\xe7\x59\xf4\xfc\x15\x44\x53\x0e\xd2\x5c\x38\xb1\xbf\x71\xff\x6a\x23\xd5\x22\x85\x03\x3c\x0d\xe8\x96\x87\xe8\xf9\x79\x2d\xb7\xb1\x1c\x45\x54\xe9\x98\xf3\x0a\x7f\xcf\x1c\x73\x5a\x6f\x9c\x8d\x5e\xec\x23\x54\xc0\xbc\x15\x83\xbb\x97\xaf\xa8\xe8\x56\x3e\x3c\x26\x32\x39\x3b\x2a\x32\x31\xf7\xed\x8a\xf9\x03\xf3\x07\x2d\x1c\x58\x16\x1e\xdb\x25\x39\x3c\xae\x0b\x4f\x7b\x07\xea\x75\x70\x08\xdc\x69\xab\xb7\x59\x79\x1d\xca\xc0\xeb\x50\xaf\x13\x15\x0a\xd1\xb1\x8f\x7a\x9d\xde\x4d\x9e\x0d\x40\x74\xf8\x31\x73\x44\xde\xd9\x71\x90\x16\x76\xf2\xb9\x81\x6f\x76\xc7\xa7\x35\xff\x06\xfc\x8e\x26\xf4\x8e\x5b\x4f\x7e\x47\x0e\xc0\xda\x98\x85\xe8\x64\x3f\x09\x3a\x99\xfb\x6f\xe1\x2f\xaf\x13\xdd\xcc\xab\x6f\xb6\xe4\xc2\x95\xb4\xa3\x65\x03\x92\xbc\xea\xe3\x6a\x7f\x6a\x8e\x8e\x93\xa1\x39\xb9\x68\xba\x73\xb1\x8d\x6c\xa2\x5b\x65\x13\x0d\x32\xa3\x7b\xe6\x75\x36\x47\xa6\x04\x36\x85\x64\x0f\xc9\x8b\xe9\x95\x97\x65\x8a\x4f\xd4\x4c\x37\xe6\x54\xc2\x95\x11\x31\x11\x1d\xba\x8e\xa9\xce\x0c\x8f\x0d\xcf\x4c\x1d\x5e\x93\x85\xe5\xd3\x11\x70\x81\xde\x26\xd4\x1f\x97\x1e\xa1\x68\x8e\x25\x9b\x93\x8f\x49\x27\x7f\xf2\x1d\x20\xcc\x01\x8b\xf0\x27\x7b\x18\xc7\x98\xba\x95\xc0\x08\xbf\x46\xe7\x2c\x8c\x9d\x43\x9f\x25\xe7\x59\x7a\x84\x01\x73\x38\xbc\xc8\xe4\x4c\x88\x91\xca\x03\xaa\x40\x85\xfe\xdb\xb8\x89\xdc\x95\x86\x4f\xd0\xb3\x05\xe8\xd9\x57\x3d\xcf\x72\x73\x00\x5e\x84\x14\x22\xff\x90\x5e\x45\x37\x4d\x8c\xfb\x56\x8f\x64\xf4\x9c\x4f\x1a\x48\x2d\x99\xd1\x60\x78\xcb\x31\xf2\x2c\xdd\xfa\xac\x01\xdf\x1a\x58\x52\xf0\xa3\xb0\xb9\xd7\x27\xa4\x1e\x3d\x79\x76\xb5\xe7\x59\x5f\x1a\xc8\xc5\x50\x11\x6c\xc6\x34\xc0\xd1\x98\x86\x96\x6a\xa4\x57\xec\x68\x79\x8f\x9c\x62\x16\xcc\x11\x31\x9e\xb3\x02\x90\xaa\x8b\x2b\x62\xd3\x7d\xdd\xf2\x82\x67\xe2\xc0\xfe\xb8\x66\xb4\x1d\x67\xde\xbd\xcb\xfb\xcc\x71\xbb\x09\xa8\x1d\xee\x03\xb5\x63\x3c\xb4\x93\x56\x42\x1b\xba\x98\xb4\x20\xcf\x1f\x43\x7f\xfd\x93\xda\x8a\xce\xbc\xf2\x18\xf0\xf3\x63\xce\x8b\x31\x55\xc4\x16\xe4\x2c\x86\x08\xc6\x81\xdb\x81\x2f\x60\xc5\xd4\x49\xab\x98\x47\x93\xde\x07\xcd\xa7\x7f\x06\x66\x39\x30\xff\x4c\xfa\x83\x57\x45\x91\x54\x89\x38\xbb\xed\x7e\x65\xc8\xbe\xeb\xc9\x6f\x38\x51\x24\xbf\xdb\x40\x4b\xac\x28\x12\x28\x1e\x7b\x96\xec\xaf\xdb\xc2\xb6\x12\x45\x7a\xb6\x14\x92\x45\x0b\xd8\x9d\x4c\x2d\x77\x4c\x29\xa6\x17\xb7\x10\x88\x3d\x0a\xb8\xa3\x44\x11\x94\x49\x1c\x47\xf6\x19\xda\x63\x73\xd4\x58\x17\xba\x68\x37\xdd\x49\xb9\x88\xde\xf5\xc4\x7d\xf6\xc5\x3f\x6e\x33\x51\xc4\xe3\xdb\x0c\xd1\x39\x9c\x8b\x04\xdf\x0a\x76\x1b\x60\x88\xad\x83\x23\x9c\x67\x10\x5b\x87\xbb\x82\xed\x31\x38\x59\xe4\x64\x42\x44\xab\x7c\x75\x60\xac\x90\xc2\xc9\x0a\x76\x8b\x42\xe4\x2c\x2a\x42\xef\x29\x67\x5f\xa0\x43\xb9\x1f\x90\x0e\x2c\x3f\x1a\xc0\xcd\xf1\x23\x27\x0b\xaf\xb8\x06\xc7\x07\xda\x79\x45\x08\x29\x69\x4d\x4b\xb6\x31\xcd\xae\x6e\x3d\xa6\x07\xed\x49\xfa\x84\x7d\x61\xf3\xcc\x84\x42\x57\x79\xd1\xc6\xfd\x98\x1f\x50\xec\xef\xa0\x8b\x47\xf7\x05\x65\x82\xee\xab\x42\x5d\xe1\x38\x12\x5e\xf3\xc5\xe7\xb8\x07\xfb\x2b\x80\xc2\xd9\x50\x9f\x00\x1c\xcb\xad\x1f\x44\xe1\xf3\xc1\xeb\x6e\x1a\x07\xd9\x34\xe2\x07\x71\x1f\xc5\xb9\x27\xc5\xdd\x8e\x63\x7f\xfd\x04\xfd\xc7\xaf\xe1\x7f\xb8\xdd\xd4\x01\xd1\xdf\x94\x1a\x73\x7d\x95\x8a\xa3\xfd\x94\xd8\x9a\x48\x21\xbb\x80\x69\x13\x51\xae\x40\x87\x20\x45\xb7\x38\x25\xcb\x5f\x57\x13\x3f\x7b\x71\x4d\xad\x74\xa3\xe1\x69\x91\xcb\xe1\x37\x92\x15\xe7\xe7\x64\xf5\xf5\xcb\x9a\xca\xd3\xf3\x21\x3b\x1b\x54\x72\x50\xe0\x91\x0a\xff\xf3\x3a\xc6\x2b\x87\xfe\x89\x47\x56\x7a\x79\x64\xb4\x95\xe7\x91\x5c\xe5\xe3\x4c\x92\x86\x2f\xb0\xbb\xe8\x7c\x72\x3e\x31\xcf\xf2\x67\xe7\x88\x81\xe7\x74\x30\x11\x0e\x60\x17\x6b\xc8\xe7\xdb\xab\xc4\x40\xfb\xbd\x5f\x14\xff\x83\xdd\x15\x0e\x24\x71\xb0\x05\x7f\xa2\xbd\x75\x1f\xed\xad\xcb\x64\x6f\x2d\x69\xe9\xc2\xef\x2d\x2a\x1a\x19\xe5\x34\x99\x43\xbc\x3f\x81\x60\x93\x22\x4b\xf8\x8c\xc7\x60\xa7\x5b\x5e\x44\x3f\xe7\x08\xf3\x2c\x3f\x2a\x62\xe6\x70\xde\xbe\xf1\x93\xf8\x4f\xe6\x9a\x6e\x6b\x4e\xa3\x3f\xb8\x05\xdc\x82\xcd\x67\x44\xf3\x27\x88\x66\xb5\x97\x66\x31\x3d\x27\x80\xf3\xb6\x73\xd8\x35\x88\x07\x91\xcf\x06\xbf\xef\x0f\x88\x57\xb9\x87\x90\x1f\xdc\xee\x38\xf8\x9f\x70\x00\xf0\x27\x9e\xd3\x4a\x76\x1b\xad\x16\xbd\x8c\xfa\xc6\x2b\x85\x2c\x59\xbf\x39\x52\xbc\xc4\x68\xf3\x5f\x22\xef\xb1\x88\x19\xb2\xb3\x78\xa0\x2d\xb4\xb3\x52\xa3\x81\x36\xfa\xf2\xe2\x4d\x4c\x33\x28\xc9\xef\x51\x1f\xbc\x27\xf9\x06\x77\xef\xfa\x75\x78\xe6\xa9\x19\x49\x45\xe8\xbf\x2d\xcd\xe4\x5c\xb2\x7b\xc0\x2d\xee\x16\xb2\x8c\x91\x2d\x29\x9e\xc3\x4a\x3d\x2b\xa5\xf1\xd8\x13\x7a\x9d\x38\x02\x69\x9b\xdb\xf2\x26\x05\x6d\xef\x70\x73\xcd\xa2\xf5\x60\x7b\x5f\xce\x59\xd2\x6b\xf5\xae\x15\x8b\x82\x99\x9e\xc5\x3c\xef\xd9\xcb\xe4\x80\x4c\xc1\xd7\xe7\xef\xf1\xf5\x31\xad\xbe\x3e\xd7\x3f\xb9\xfa\x7c\xda\xfe\x83\xaf\x0f\x64\x3e\xd9\xd7\xd7\xf2\x19\x6a\x97\xfe\x5f\x7d\x7d\x20\xfd\x1f\x7c\x7d\x54\x21\x6a\x7b\xef\xbf\xf4\x79\xef\xc9\x7d\xc2\xdd\x70\x0c\x65\x6d\xef\xbb\xe0\x79\xde\xa4\x36\x6e\x0e\xf4\x6c\x03\x7a\xb6\xff\x63\x3e\x11\xc2\xf3\x60\xc3\x63\x8e\x0e\x00\x77\xc1\x01\x54\x5c\xcb\x45\x34\x12\xe5\x31\x96\xe3\x68\xa2\xbe\x5c\x25\x27\xd1\xc0\xf0\xb6\x79\x5c\xf7\xa6\xc0\x7b\x81\xf7\x0c\x59\x70\xdd\xb4\xa6\xa9\xa8\xcd\x1e\xd4\x26\xc9\xd3\x86\xa6\x45\x3e\x6d\x14\xa4\x80\x74\x84\x66\x8b\x01\xb5\x08\x6c\xea\x9e\x35\xb5\x69\x1a\xa8\x47\xf3\xd6\x8d\x3d\x4d\x0f\x10\xad\x7d\x5c\xc6\x11\x88\x85\x87\xcd\x9d\xdd\x87\x42\xe9\xdf\xd8\xd3\x20\x63\x27\x39\x1b\x06\xfa\x6f\xe0\x16\xd6\x16\x30\x9e\x79\xe6\x95\x40\xcc\x1e\x80\x73\xa6\x1d\x88\x63\xac\x1f\xbc\x66\xaa\x5f\xc9\xce\x04\xec\xcd\x33\x77\x83\x96\xc8\xe7\xe1\x31\xfd\x0a\x31\x37\xfc\x90\xf8\x46\xa4\x94\x58\x24\x48\x6d\xc6\xd7\x37\xd2\xdb\xe3\x1a\x81\x45\xbe\xbe\x11\xb8\x12\x8d\x4d\xdd\x72\x84\x8c\x4d\x44\x7b\xa5\x26\x01\xf9\x16\xbc\x23\x22\xb8\x2e\x70\x7a\x7c\x53\xfc\x14\x38\x00\x7b\x47\x00\x3c\x85\xda\x64\x0b\x6d\x00\xc7\x31\x73\x88\x4c\x23\x0e\x0e\x83\xe0\x1d\x89\x9a\x82\x1a\x4c\x0f\x04\xf5\x6f\xf3\xbe\x11\xf8\x0c\x6a\x13\x83\xda\xf8\xf8\x46\x98\xf3\xfe\xbe\xbe\x11\x8d\x8f\x6f\x44\x33\x43\x4f\xfe\x37\xa0\xff\xe1\xdb\x8d\x8d\x0d\xd3\xa6\x21\xd9\x74\x10\xde\x06\x09\x2d\xab\x79\x3f\x1a\x4d\xf1\xfe\x54\x8b\xd8\x7d\x30\x92\x19\x18\x09\x6f\x9f\x3a\x85\xfa\x19\x82\xfa\xb9\x40\x0d\xa7\x64\xe8\xac\x49\xc4\x2c\x2f\x05\xb1\x65\xec\xf0\x49\xc6\xca\x01\x17\xc2\xc3\xcf\x3e\xeb\x49\x7c\x8f\x1c\x7e\xe8\xf0\x8b\x24\xc3\xfd\x24\x39\x2b\x4d\x48\x66\x4f\x40\xef\x50\x61\x8d\x8d\x0b\x20\xef\xb8\xc2\xbf\xa3\x6d\x1e\x65\x0e\x78\x3d\xd2\x27\x69\x32\x7c\xf8\x49\x9f\x1c\xc9\x43\x58\xc6\xc2\xd7\xe1\x5a\x8a\x6d\xa9\x52\x8a\xfd\x7e\xa5\x6e\x11\x3e\x48\x43\x16\x36\x52\xa7\x5b\x0a\x05\x59\xc2\xb0\x34\xbb\x7e\x10\x47\x7b\x65\x09\x23\xc8\x92\x02\x8f\x2c\x81\x8d\x1e\x59\x42\xc3\xe7\xd0\xf8\x3a\x3c\x59\x37\x36\xfc\x03\xdf\xef\xf0\x18\xdb\x7f\x4c\x35\x06\xf0\x26\xcc\x40\x1c\xf0\x30\xb6\x4d\x90\x6d\x25\x3a\xd9\x72\xfe\x88\xbf\xb4\x07\xda\x4a\x71\x84\xc9\xe0\x03\x8b\x48\x92\x83\x67\x97\x8e\x57\x8c\x89\xfe\x77\xa0\x3c\x1b\x66\x0c\xef\x76\x7d\x56\xb7\x46\x5e\xc6\xe5\xc2\x0a\x6a\x61\xcb\x6f\x94\x16\x71\x4e\x3f\x8e\x39\xaf\x94\xa9\xb1\x53\x82\x9f\x37\x42\x99\x07\x02\xcd\x93\x94\xb6\xf0\xee\xe9\xc1\x45\x81\x3d\x8a\xab\x46\xd7\x67\xf7\x48\xa9\xe8\x51\x3b\xfd\xe5\xf1\x0b\x64\x33\x02\x1c\xf6\x5c\x6d\x9d\xb6\x1f\x7a\xe7\xcb\x68\xac\x38\xd4\x1a\xaf\x83\x52\x46\xf1\xdb\x2c\xc5\xbb\xb3\x7d\xdd\x3e\x8b\x2a\xc7\xb8\xfa\xee\xe8\x5a\x10\x1d\x95\xee\x34\xe7\xc3\x01\xe5\xbd\xbb\x2f\x4b\x4d\x1a\x9f\x18\x1e\x43\xbc\x3e\x00\x3e\x80\x03\x5a\xde\x23\x3e\x58\x74\xbe\xbc\x3c\x05\x49\x93\x46\x8f\x13\x16\xb8\x2f\xa3\x9f\x62\x41\x27\xe4\xd0\x43\xe2\x56\xc9\x83\xb6\x19\x3a\x8b\xaf\x36\xc7\xc1\xb2\xb8\x67\x0a\xe8\xdf\xe0\x80\xbb\x77\xc1\x4c\xf4\xde\x68\xb8\x93\xba\xda\x32\x9b\x32\xe1\x7d\x1d\xa8\x52\x89\x99\x39\x1a\xe2\x9d\xc4\x3a\x3e\x39\x46\x04\xdb\x4d\x48\x0f\x70\xd8\xf9\x0d\x24\xfc\xb8\xaa\x9f\x51\x3e\x30\x2e\x77\x50\xcf\x62\x71\x0d\xd7\xcb\x65\x18\x86\x3f\xe6\xd6\x4c\xed\xdc\xb9\x6f\xef\x50\x8b\x5e\xdd\xb3\x01\xff\x21\xfb\xe8\x36\x14\x81\x57\x5b\x82\xb0\x2d\x0a\xb5\x7f\x4d\x20\xdf\x4d\x86\x7e\x60\x70\x4b\x08\xfa\x2e\xcf\x7d\x5f\xf8\xee\x2e\x54\x81\x3d\x2d\x36\xf4\x5d\x4f\x28\xf9\xab\x89\xe8\x74\xbf\xc0\xd1\xd4\xee\x96\xa5\x44\x4f\x92\xfa\xea\x49\x62\xec\xd7\x88\x20\xf7\x10\x58\x0e\xcd\x5b\xba\x05\x80\x3d\xa0\xa4\x47\x7e\x7d\x70\x73\xe4\xa7\x53\x56\xcc\xd1\x3a\x7b\xf4\x70\xce\xd9\xd5\xd2\xd2\xd2\x07\x2e\xa2\xd7\xb6\xec\x46\xf2\x7c\xbb\xfb\xb7\xbf\xbf\x26\x7d\x9d\x86\xa7\x41\x4e\x4b\x35\xea\xab\x00\x46\xfe\xfd\x08\x7f\xf7\xe8\xb9\x96\x48\xa4\x83\x2f\x50\x8a\xa9\xae\xee\x1c\x7e\xbf\xbb\x2f\x3d\x72\x53\x2f\xb4\x74\x16\xec\x0a\x96\x23\x67\xf7\x8a\xa0\xd1\x11\xad\x4e\x61\xa3\x27\xd8\xdc\x79\xf8\x13\x36\x5e\xbe\x0c\x97\xbf\xfd\x36\xea\xf3\x35\xea\x2a\xc3\x82\x6f\x70\x9f\x70\xf8\xa3\x04\xb2\xcf\x16\x50\xc8\x2e\x07\x37\x7d\xfd\xe4\x04\x3a\x46\xee\x9e\x1c\x43\x2f\xa3\x5a\x6e\xa1\xf1\xce\xa6\x5a\xe8\x27\x3c\x43\xcb\x1f\x36\xc4\xb0\xab\xf9\x67\xae\xb5\x7c\x47\xeb\x98\x97\xbc\x3a\x28\xb6\x02\x81\x01\x7d\xcf\xdc\x9a\xf8\x28\x61\x1e\x13\xbb\xe1\xd1\x2d\xdc\xdf\x86\x96\x0f\xc0\x21\x8f\xae\x4a\x91\xe7\x38\x60\x47\xdf\xd3\xbd\xde\x75\x9f\x8e\xe1\xfe\xfd\x20\x80\xd0\x75\x1d\x16\xb5\x7c\x46\x78\x30\xe2\x3b\xfe\x73\x68\xa2\x8d\x61\xef\xb6\xd8\xd7\xbb\xdd\xec\x75\x6e\xdf\x6d\xf5\x6d\xb7\xd9\x77\x6d\x6c\x11\x8d\x60\x8b\xbc\xda\xde\x14\xa1\xe1\x12\x74\x36\x7a\xb6\x5c\x17\xf4\x24\x31\x38\x2f\xf2\xea\x7f\x2a\x0b\x29\x0d\x20\x86\x4b\x7a\x82\xa9\x9b\x23\x8e\x46\xa0\x46\x53\xe1\x77\x47\x71\x6e\x2b\x94\xc1\x67\xa8\xfd\x2d\xf3\x70\xec\x80\x53\xca\xf8\xfb\x53\x6a\xa5\x4c\x26\x9a\xa3\x55\x92\xd6\x04\xc8\x9b\xec\x5a\x0d\x01\xb3\x8a\x70\xa4\x7a\x7d\x9e\x06\x3e\xfa\x2e\x9b\x8e\xb4\x54\xe8\x86\xb1\x3d\xc2\x13\x95\xff\x8f\xb1\xef\x80\x8b\xea\xd8\x1e\xbe\x73\xcb\x2e\xcb\xf6\xc6\x02\x4b\x5b\x60\x59\x3a\xc8\x52\x04\x14\xd6\x02\x22\x28\x55\xd1\x2b\x22\x25\x76\xec\x8a\xbd\x60\xef\x35\x1a\x8d\x1a\x7b\x6c\xd1\x58\xa2\xd1\xc4\x58\x92\x18\x63\x62\x89\x31\x96\x68\x8c\x1a\x6b\x9e\x89\xb1\x44\x93\xf7\x94\x1d\xbe\x99\xb9\x77\x17\xd4\xbc\xf7\xfd\xf5\x07\xec\xdd\x9d\xbd\xf7\xcc\x99\x33\xa7\xcc\x69\x43\x7c\x47\x16\x96\x45\xb5\x29\xcd\x2b\x85\x97\x83\x7d\x87\xda\x72\x7d\x83\xf3\x2a\x5b\xb6\x2c\xcd\x97\x12\x3e\x7a\x80\x1d\x0b\x66\x4a\x02\xc8\xb9\xa2\x5c\x38\x57\x94\xda\xa4\x36\x64\x3b\x9b\x52\x90\xb9\xdd\x6d\x70\x8f\xb9\x79\x0b\xab\x87\x74\x9f\x9f\x3b\x8f\xbd\x5c\x3e\x66\x4c\x79\x6d\x6d\xf9\xa8\x51\xe5\xb5\x58\x1e\xaa\xd9\x41\xa0\x85\x64\x28\xe1\x72\x80\x3a\xa6\x74\xeb\x4c\x80\xc4\x59\x98\xc8\xb1\x32\x16\x8c\x42\x5a\x1f\x12\x90\x2d\x74\x31\xc9\xde\xde\x89\x5d\xbb\xeb\x62\x12\x7d\xf5\x09\x15\x92\xa1\xbc\x87\xbf\x55\xef\x70\x58\x9b\xb7\x0d\xf5\x28\x93\xfa\xd9\x8c\xed\xed\x41\x71\x05\x91\x84\x8f\x8e\x97\x84\x32\xd9\xd2\x00\x91\x26\x39\x16\xaf\x6d\xc2\x59\x91\x26\xad\x98\x26\xc7\x63\x4b\xe3\xe5\x2c\x0d\xfb\xae\x46\x12\x9a\x9f\xbf\x03\x99\x1c\x68\x4e\x34\xbb\x97\x9a\xf1\xba\xdf\x47\xd0\x4d\x0c\xaf\xb8\x7d\xd0\x1c\x26\xb3\x7b\xe9\xde\xaf\x8f\x15\x7c\x30\x93\xdf\x70\x29\xa1\x7b\x07\xb2\x3b\x68\x3d\xb7\xef\x9f\x6d\xaf\xff\x62\xe3\x7b\xfd\x57\xe3\x8b\xdd\xf1\xa6\xf1\x85\xec\x51\x66\x0e\xc8\x41\x30\x61\x9d\x8c\x95\x00\x41\xcf\xd0\xbb\xcf\x9b\x6a\xc4\x23\xa6\x30\xef\xce\xcc\x1c\x7c\xb4\xf4\xe5\x78\x9c\xec\xc3\xc0\x5d\xec\x5a\x7a\x3c\x77\x07\xcd\x05\xa7\xcd\xfb\x38\x3c\xe5\x9e\x9e\x48\xd5\x90\x88\xf3\xb2\x63\xaf\x3e\x31\x67\xf0\xf4\x80\x55\x14\x61\x6a\xc9\x44\xec\xb6\xfa\x0d\x04\x20\x59\x56\xdf\x03\xdb\x45\x6b\x2d\x20\xd4\x0a\x6f\x6a\x88\x48\x03\x0d\x00\xd1\x31\x68\x98\x4c\x74\x63\x8e\x96\xd6\xa9\x5c\xf2\x9a\x79\x25\x4f\xce\x2e\xed\x64\x55\x84\xfa\x46\xa7\x64\xb6\x65\xfd\x36\x18\x60\x43\xa0\x64\x9a\xbc\x45\x92\xce\xb8\xa4\x9f\x80\x3b\x09\xbb\x9d\x6e\x2d\xb1\x09\xa7\x72\xd2\x26\x56\x03\x10\x79\x37\xf8\xb7\x9b\x79\xb3\xdb\x09\xf3\x26\xbc\xa9\x08\x6d\x8e\x81\x0d\x13\xdf\xe4\x4d\x1c\xfa\x1a\xfe\x71\x8e\x34\x30\xb7\x0d\x2f\xff\x6d\x64\x6e\x1b\x7f\xef\xdf\xff\x70\xff\xfe\x84\x7e\x26\x23\xb8\x3b\x12\x79\x22\x4a\x8b\xc6\x5d\xcb\x88\x76\xca\xf3\x39\xd9\x73\x3e\x46\x3f\x58\xba\x88\x76\x0a\x80\x1f\x23\x5e\x1c\x21\x9e\x51\x88\xe7\x24\x67\x88\x80\xc5\x5a\x93\xb7\x70\xf4\x01\xfb\xe1\x03\x0d\xd0\x10\xc6\x8e\xa4\x7d\x25\x32\xca\x1f\xd1\x83\x81\xf6\xac\xd3\x4a\x7c\x1a\xe9\x81\x74\x50\x10\xa8\x01\xef\x26\xd1\xd6\xa5\x71\xcc\x9d\x2d\x3b\xc8\xcb\x45\x11\xc9\x1d\x0a\x3a\xe7\x07\x78\x8b\x34\x91\x6d\xcf\x2f\xef\xc4\x85\x68\x08\x59\x44\xf5\x4d\xea\xad\x21\x84\x11\x3d\x36\x19\xe7\x6b\x2c\x65\x7f\x03\x4f\x90\xed\xcf\xa0\x27\x5a\x30\x7f\x08\x08\x62\x69\xca\x57\xa6\xad\xf3\x52\xb2\xae\x27\x9f\x48\xd0\x08\xc6\x90\x5d\x6a\xfa\x47\x92\xe4\xd0\x27\xef\x06\xcc\x09\x60\x83\xd2\x93\x9b\x79\x05\xd8\x74\x3d\x7d\x12\x72\x53\x2c\x2d\x92\xe3\x8d\x21\x56\x4d\x95\x31\xa1\x03\xfc\x17\xfa\x58\xb2\x78\xe5\xca\xc7\x7e\x16\xbf\xd0\xa4\xae\x1d\xe3\xfc\x2c\xe6\xd8\xc8\x4e\x85\xf1\x1f\xaf\x5c\x89\xb4\x10\x7f\x44\x6b\x1d\x25\xd7\xd0\x3e\xb0\x53\x81\x0e\x25\xda\x0a\x68\x27\xc4\x05\xda\xea\xa2\x43\x7c\x5d\x60\x5c\x3a\x6e\xff\x1f\xdb\xe2\x9f\x0f\x2a\x40\xe1\x7f\xdd\x2c\x53\xfe\xeb\x27\xdc\x85\xd7\xb7\x11\x3c\xf5\xc6\xc6\x02\xb0\x2f\xac\xa6\x06\x34\xe0\x7d\x65\x38\xc0\x48\xa5\x2c\x38\x26\x93\x08\x2c\x4b\xb0\x2d\xa4\x88\x21\xdb\x52\xa4\xf6\x94\x01\x7b\xbc\x7f\xf5\xae\xc1\xbf\x1e\xec\x1b\x3f\x7e\xdf\xc7\xe3\x89\x8c\x86\x87\x11\x3d\xd9\xd0\xf7\x85\x33\x52\x97\x7e\x82\x88\x02\x69\xd4\xcf\x62\xc6\x9f\x5b\x39\x3e\x06\x76\xb9\xbf\x60\xc1\x7d\xca\xdb\xe9\x85\x08\xf0\x01\xe1\x2b\x32\xd2\x3b\xcd\x9f\xb2\x52\x31\x54\x12\xd5\x92\xca\xa2\xf2\xa8\x22\x8a\xa7\xaa\xa8\x7e\xd4\x50\x6a\x0c\x35\x99\x9a\x4d\x2d\xa6\xde\xa5\xde\xa3\xd6\x53\x5b\xa8\x7f\xef\x5b\x97\xbf\x79\xe3\xe6\x83\x80\xdd\xcb\xd7\x8d\x47\x7f\x3e\xe6\x0b\x37\xf5\x9c\xb7\x68\x1e\x79\xd9\x77\x51\xf7\xa5\x2b\x96\xa2\x97\x0e\x19\x5f\xb9\xc2\x73\x95\x63\xda\xac\x69\xe4\x83\xb6\xb3\xc2\x47\x8c\x1e\x21\x7c\x10\x3d\x5a\xb1\x3a\x68\xc0\x90\x01\xe4\x83\xd0\x21\x9a\x4e\x5d\x3b\x09\x1f\x18\xba\x82\xf6\xde\xcd\x5b\x34\x47\x57\xfb\x78\xbf\x16\x89\xf1\xf8\x6d\x2b\x5f\xb7\x69\xd1\x8a\x55\xb3\x46\xaf\x1e\xd2\xb5\x7d\x8b\xc4\xc4\x16\xed\xbb\x0e\x59\x3d\x7a\xd6\xaa\x15\x8b\x36\xd5\x29\x73\xd7\x76\xdc\x28\x65\xda\xe5\xb6\x23\x5f\xf1\x60\x73\x71\x50\xa5\x90\x6a\x8e\xdb\xf7\xe8\x4c\xa9\x71\x4d\xff\xb9\x0a\x33\xe3\x18\x4b\xe1\xef\xff\xff\x2a\xca\x95\xb8\x1e\x92\x14\x92\x64\xe1\x2c\x49\x16\x10\xa2\xb5\x5b\x0d\x21\xc1\x49\x89\xf6\x04\x9b\xf8\x57\x2f\xfe\x35\x89\x7f\x81\xf8\x57\xfa\xda\x35\x08\x31\x86\x68\x2d\xc0\x92\x64\x4f\xb2\x83\xff\xcf\xd8\xd7\xaf\xad\xaf\x3d\xcb\xf5\x6c\x2b\x82\x07\xdd\x11\xc1\xa6\xb5\x1b\xed\xf4\x83\x81\x37\x41\x47\xe7\x61\xb8\x17\xe4\xd3\x6d\x06\x0e\x84\x8b\x13\x9b\x37\x4f\x5c\x96\x98\x9a\x9a\xf8\x9f\x94\xe4\xe6\x49\xa1\xf8\x12\x22\xcd\x37\x25\xf9\xc3\xe6\x49\x49\xcd\xe9\xd2\x94\xe4\xe4\x94\xfa\x69\x37\x07\x82\x8e\xec\x4c\xf8\xd1\xcd\x81\xf5\xb2\x64\xf4\x8f\x9e\x83\x7f\xbf\x93\xd4\xbc\x79\x92\x73\x5b\x52\x73\xc4\xdc\xf1\x35\xf8\x16\x7f\x11\xf2\xf8\x3b\xff\xc1\x5f\x7f\x07\xbf\x0b\x17\x0d\x1c\xc8\x84\xe2\x27\x3a\x3f\x83\x1f\x0d\xbc\xc9\x4e\xbd\x36\x70\xe0\xc0\xfa\xe1\x20\xff\x6d\x34\x2e\x1a\xfd\xc0\xef\xd1\x7d\xee\xa2\x17\xe0\x1d\xf4\xa2\x1b\x7a\xe1\x1c\x86\x1f\xfe\xf2\x1a\x68\xff\x22\x71\xe0\x35\xfa\x72\xb2\x3d\xcd\x99\x91\x94\x94\xb2\x32\x31\x31\x95\x0e\x12\x47\x3b\x1b\x52\x52\x92\xee\xa1\x81\xf0\x7c\xf3\xc4\xd4\x48\xf4\x31\xba\x67\xfd\xf0\x81\x03\x41\xfb\x6b\x02\xcf\xbe\xc5\xd6\x80\x66\x12\x69\x13\x3f\xc2\x69\x44\xf3\x82\x5f\x20\x40\xf4\x0b\xb0\x35\x2e\xbf\x00\xa0\x42\xd9\x51\x20\xf1\xcd\xf8\x1f\x7d\x53\x3b\xf7\xfe\x3f\x85\xff\x20\x9e\x32\x8a\xbd\x08\xfe\x83\x78\x0a\x43\x7c\x2f\x4a\xb6\x4e\xa6\x25\x22\xff\x92\x70\x16\xcf\xe0\xb3\x1d\x72\x0c\x23\xb8\xaa\xb1\xca\x43\xe3\x13\xc0\xc8\xba\x79\xec\x52\xa6\xa0\x75\xde\x30\xc5\xdb\xbe\xa7\xd8\x8b\xdf\x7d\x47\x4b\x27\x0d\x49\x0c\x4a\xc9\x2c\x69\x33\xf1\x7d\xc1\xf6\x99\x06\x8b\xa9\x4e\x0d\x7f\x21\x3d\x47\x8e\x0c\x5c\x80\x55\x9d\x72\x04\x56\x13\x5d\xc7\xd6\x44\xd5\x81\xbb\x5e\x51\x75\xd0\xf7\x2f\xa1\xbd\x6f\x7d\xdd\x9f\x62\x12\xfc\x29\xd6\xd7\xdd\x29\x68\xfc\x47\x68\x3c\xfd\xba\x3f\x05\x08\x78\x83\x1f\xbd\xee\x50\xa1\x21\x52\x00\xa9\xdf\xc8\x78\x25\xb6\x52\xe4\xb2\x3a\x4f\xa5\x52\xfc\x62\xaa\x4b\x4c\x0a\x5f\xb7\x0a\x5e\x1f\x18\x22\xde\x05\x28\x47\x4f\x6c\x36\xb0\xee\x81\xeb\x6e\xbb\x9b\xfa\x81\x18\xb4\x1e\xfa\x37\x63\xb9\xf4\x4d\x35\xde\xc5\xff\x14\xca\x45\x01\x30\x83\x5d\x41\x67\x70\x1d\x10\xce\x3c\xf6\xc8\x84\x33\xe0\xa6\xe7\x96\x74\x86\x23\xc6\x12\x99\x19\x17\x1c\xce\x81\xc8\xcc\xe8\xa0\x88\xcc\x28\x61\xee\x3b\x08\x9f\xfc\x0a\x47\x14\xee\xe5\x8e\x29\x05\x3e\x29\x45\x28\x36\xb9\xd1\x6d\xaf\x1e\xab\x9e\x98\xdd\x33\xb6\xb2\xe3\xa0\x61\xf6\x7e\xda\x3e\x47\x13\x2a\xfc\x7b\xa7\x8d\x19\x93\xde\xcb\xbf\x22\x61\x1a\xd2\x65\x74\xe8\x1e\x47\x91\x0d\xad\xa7\x02\xa9\x28\xca\xe2\x50\x99\x42\x42\x94\xfe\x11\x11\x6a\x4e\xca\x1c\xd3\x2a\x05\x39\x9e\x9a\x9a\xe0\x0a\xe8\x16\xcc\xd7\x26\x09\xde\xaf\x19\xd8\xd6\x26\xaf\x8f\xce\xeb\x5e\x16\xd5\x96\x18\xdc\xe5\x11\xad\x7b\x34\x31\xba\xe1\xd5\x26\x9e\xa9\xd6\xad\xb1\x01\x8e\x7e\xbb\x4c\xf0\x04\xf7\x01\x2c\x68\x38\xc3\xd6\x21\x7d\xa2\xb7\x70\xde\x24\x95\x4a\x8e\xd1\x6e\x9f\x01\x40\x8a\x02\x36\x0a\x40\xdd\xbb\x43\xab\xe0\x5f\xe8\x17\xb7\x0d\x5e\x3e\x0c\x22\x0e\x23\xdc\xfc\x02\xbb\x70\x06\x64\x47\x90\xb3\x8f\xa6\x9e\x26\x4e\xc2\x5a\x82\x42\x6d\xe4\xdc\x32\x34\x85\x33\xcc\x80\xed\xe0\x35\xf4\x7f\x71\xcb\x03\x79\xff\x79\xf2\x07\x70\x54\x47\x1f\x3d\x72\xe4\xe8\xc4\x01\x23\x47\xe0\x75\xb5\xb0\xc7\x25\x9d\x24\xad\xc8\x7d\x24\x54\x9d\x67\xa3\x6f\xe4\x95\xfb\x48\x3a\xbd\x79\x1f\x49\x2b\xf7\x8d\x40\xc3\x05\xf6\x63\xf6\x10\xd7\xf5\xf5\x73\x7e\x25\x7b\x32\xf0\x65\x73\xae\xeb\x06\xbc\x9e\x1f\xc0\xcf\x98\x25\x0d\x3d\x9a\xda\x6a\x1c\x1a\x03\xbf\x25\x83\x36\xe0\x31\x0d\x97\x11\x3c\xed\x24\x1c\x92\x74\xba\x8f\xf5\xac\xbc\x4e\x8d\x83\x26\x4e\xb8\xf5\x62\x6b\xa8\xdb\x46\xe1\x58\xf1\x60\x96\x5d\x35\x1a\xde\x86\xb7\x46\xf3\xfd\x82\x0e\xc4\x3e\x5c\x3c\x1a\x04\x00\xff\xd1\xdd\xfa\x05\xa2\x0b\xf6\x6c\xdb\xb6\xd9\x1d\xe6\xec\x14\x7e\xbb\xee\xef\x29\xce\x97\xf1\xac\x93\xba\xed\x63\x10\x86\x6e\xcd\x4a\x43\x92\x43\x2d\x41\xac\x89\x2b\x49\x83\x8f\x7e\x7b\x06\x6f\x4d\x38\x30\x03\x7c\x0a\x42\xd1\xff\x41\x2d\xd9\xe3\xa3\x87\x0d\x98\x78\xe4\xe8\xd1\x23\x02\x7d\xee\x85\xd5\x4c\x3a\x91\xe3\x9a\xfd\x68\x01\xd8\x26\x6b\xc7\x59\x10\x99\xa6\x58\xe0\x49\xe6\x31\x56\x00\xea\x35\xbb\xc7\x7f\xbc\x6f\x3c\xb2\xa3\x9f\x83\xab\xe0\x34\xfb\x54\x23\xe5\xaa\x9d\x7f\x0a\x31\x01\x0d\xc1\xe0\x1a\xb8\xcc\x3e\x43\xef\xf5\x75\xfe\x2e\xd8\xd1\x0d\x1b\xc1\x03\x10\x46\xe2\x1d\xa4\x94\xd7\x11\x12\x31\xcc\x82\x58\x74\x29\x06\x3d\x67\x0a\x6a\x19\x8e\x7e\xc8\xf3\x3b\xea\x07\xdf\x5d\x78\x74\x11\x8e\x6f\xae\x1f\x4f\xbf\x74\x72\xe4\xbe\xf0\x2f\xf0\x13\x78\x4c\x9e\x35\xd4\xf9\xb3\xf8\xac\x50\x70\x8d\x0e\x65\xef\xa2\xf7\x46\x39\xff\x2d\xbc\x07\x2f\xa3\x71\x6b\xd9\x3f\xd1\x7b\x87\x9c\x5b\xc5\x71\x66\xf0\x13\x5d\x81\x26\x26\xe5\xfa\x40\x0f\x71\xdc\x21\x04\xd3\x21\xfc\x1e\x3d\xd4\xf9\xb9\xf8\x5e\x24\x78\x40\xef\x22\xdf\x1d\xec\xbc\x21\x7e\x37\x0e\x8d\x1b\x81\x9f\x4b\x8f\x70\x2e\x13\xdf\xbb\x02\xae\x83\xf7\xb8\x15\x68\xdc\x48\xe7\x6f\xe2\x7b\x45\xe0\x37\x3a\x8f\xc0\x32\xd6\xf9\x58\xf0\x1b\xc0\x79\xe8\xbb\x90\xbd\x83\x78\x85\xcf\x3e\x20\x65\x3c\x38\x1c\x5d\x82\xd0\xe0\x0e\x29\xc6\xd9\xe8\x72\x10\x02\x88\x9b\x1b\xe8\xf7\x4f\xbc\x71\x1a\xf0\x47\xbe\x1e\xf9\xcd\xf7\xf0\xe0\x49\xf4\x65\x15\x7c\x0a\xe6\x81\x41\xcf\x9e\xc1\x05\x50\x88\xb1\x02\xdd\xd8\xbd\x8c\xe7\x3f\xc7\xfb\x81\x6e\xdc\x36\x6c\x9c\x3d\x6c\x12\xef\xd7\xb0\x01\x0e\x00\xc5\xe2\x39\xb3\x7b\x3c\xa7\x06\x96\x14\x2b\x28\x46\x7b\x10\x4a\x81\x61\xac\x19\x8d\x46\x73\xc0\xb6\xf9\xac\x86\xc9\x1a\x29\x23\xa1\x66\x0a\xf3\x72\xf5\xa6\xd1\x49\x68\x23\x5e\x4b\x77\xaf\x1a\x06\x69\xda\xad\x1c\x61\x93\xd0\xb6\x73\xa8\x01\x50\x83\x40\x10\x87\xac\x22\x56\xc1\x00\xc0\xca\xe5\x86\x42\x5e\x23\xd7\xf8\xb3\xac\xaf\x58\x4e\xf2\x95\xd4\xc8\x8a\x1e\xe5\x43\x7d\xcf\x94\x13\x07\xad\x1c\x04\xbf\xde\x2f\xc6\x95\x90\xc0\x21\xd5\xf7\x41\x12\xa0\x93\xfe\x75\xfa\xea\x1a\x10\xfa\x85\x50\x6b\xa0\xfb\xec\x0e\x9b\x71\xa5\x01\x53\xc8\x86\xbb\x60\x0d\xd0\xc0\xc7\x30\xff\xc6\xe9\xb3\x20\xe3\x03\xb1\xda\xc0\xd0\xfb\xcb\x9f\x0a\xa5\x06\x70\xfe\x1e\x82\x77\x30\x81\x37\x90\xca\x74\x58\xff\x19\x5e\xa3\x8f\x8f\xae\x90\xf7\xd1\xb0\xca\x42\x5e\xc6\x7a\xb9\x13\xf9\xdc\xcd\x28\x5e\x85\x36\x45\x68\xbe\xa3\x7b\x2d\x03\x98\x05\x9f\x62\x60\x4f\x1f\xb9\x0e\x80\x1f\x28\x29\x5c\xb8\x6d\x53\xd7\xe1\xfe\xf0\xd7\x96\xc0\xf2\xf9\xe9\x9f\x57\xc1\x1b\x2e\x68\x8f\xae\xf7\x53\x9a\x4a\x2a\x80\xfa\xd7\x07\x6f\x95\xa8\x36\x7f\x79\xf3\xfb\x53\xf0\xc4\x0e\x01\xdf\xef\xc0\x65\x4c\x7f\xb6\xa5\x46\x82\xb3\x86\x28\x40\x97\xb1\x7b\x98\xcb\x12\x03\xf6\x0f\xed\xa3\xe8\x65\xee\x18\x37\x6c\xad\xd2\x65\xd2\x11\xd8\x4c\x7d\xc6\xee\xb1\x80\xd6\x56\xf8\x05\x22\xad\x49\xec\x1e\x76\x86\xa4\xd2\x6d\xef\xca\xe5\x52\x89\x74\x69\x99\xa7\x44\x82\xbd\x91\x67\xdc\xcd\x67\x01\x76\xe0\xba\xed\x5d\x7a\x9a\x74\xd6\x43\x29\x84\x70\x56\xd4\xc9\x28\xd0\x01\xfd\xc2\xb7\x5c\x60\x85\x23\x03\xae\xa3\x7f\xae\x1e\xfd\x5c\xb6\xab\x47\x3f\xd3\x1c\x52\x0d\x09\x94\x74\x2f\xad\x65\xa8\xcc\x24\x81\x36\x8f\x80\xf5\x8c\x0f\x7d\x9e\xf8\x24\x01\xb5\xaa\x0c\x08\xb0\x62\x07\xfc\x91\x74\x10\x94\x0e\xd6\x83\x66\x50\xec\xd3\x87\x44\x31\xa7\xe0\xb2\xd0\xde\xd0\x52\xf9\x8e\x78\x95\x76\x59\x99\x8a\xe1\x3c\x2a\xf8\x47\x1c\xb8\xc6\x81\x74\x24\x3e\xb9\xed\xdc\xa7\x1c\xc3\xa8\x39\x20\x97\x70\x1c\xba\x3f\x5b\xc1\x03\xd2\xee\xd0\xd5\x4b\xb7\x91\x9c\x2a\xca\xd1\x3f\xf2\x16\xa9\x94\x2c\x75\x75\xd5\x15\x10\x75\x1d\x48\x98\xf0\x18\x67\x43\x26\x38\x1e\x0d\x5b\xb4\xa6\x23\xa3\x5f\x3e\x15\x51\xc7\x65\xb9\x5a\x4c\xde\x12\x71\x28\xc0\x16\x27\xc2\xd6\xce\x11\x2d\xc0\x06\x68\x29\x5d\xc9\x7b\x5c\x93\x02\xe6\xac\x14\xb0\x2b\xa4\xa0\xbb\x14\x48\x03\x94\xed\x7d\xa4\x11\x52\x5a\x2a\x95\x71\x0c\x8b\xe1\xc2\x71\xf4\x71\xe5\x51\xe5\xa4\xfd\x68\x63\xf1\x72\x52\x7e\x00\x90\x32\x04\x32\x01\x28\x46\x3b\x18\xde\x1d\x0c\x7f\x05\x12\xe0\xdd\x07\x98\xfb\x00\x6f\xf8\xe2\xe5\xbf\x45\xb0\xe8\x0c\xe7\x17\x5c\x16\x6e\xdc\xf9\xe2\x90\x1b\x32\x4c\x1f\xc1\x08\xb6\x3c\x2e\x5b\x13\x46\x45\x4f\x20\xeb\xe0\xfc\x1a\xad\xc3\x2c\xc7\x20\x80\x40\xd4\xca\xe4\xfd\xe4\xb4\x8c\xd5\x82\x54\x56\x6b\xd0\x86\x6a\x13\xb5\x6d\xb5\x9d\xb4\x3d\xb5\x23\xb4\xd3\xb4\x4b\xb5\x9b\xb4\xfb\xb4\xc7\xb5\x17\xb4\x77\xb4\xcf\xb4\x1a\x61\xc0\x7f\xfb\x58\x2d\x7c\xdc\x93\x7c\xd0\xf8\xb6\x3c\x5e\x3b\x44\xbb\x4e\xcb\xd0\x07\x1b\xee\xef\xd3\x6a\x3d\x3d\xad\x51\x08\xf3\x43\x87\xf5\x28\xef\x81\xbb\xf0\x13\x42\x40\x9c\x01\xed\xb9\x7b\x5c\x37\x4a\x4d\x99\x11\x2e\x2d\x0e\x5d\x80\x65\x59\x59\x00\xe3\xa1\xab\xc0\x8d\x4f\xbd\xd1\xfa\xe9\x9b\xa4\x81\x8b\xb9\xa3\xbe\x62\x8f\x28\x4f\x20\xd1\x27\x36\x26\xfe\x5a\x05\x4a\xcf\x3f\x76\xea\xad\x9d\x4f\x97\x1f\x3d\x55\xbd\xeb\xe9\x8f\xf3\xf8\x79\x65\xf8\xa7\xbe\xb7\x88\x2d\xc3\xad\x9b\xef\x81\x89\x40\x36\xeb\xda\xcf\xef\xc1\xc9\xf0\xf1\x6c\xe6\xfd\x5f\x3e\x83\x8b\x67\x3f\xf8\x02\xd4\x5e\x76\x21\x4f\x58\xd7\xfe\x68\x5d\x3d\x90\x16\x16\xe1\xf0\x96\xab\x96\x95\xc9\x99\xcd\x1c\xd8\xc7\x21\xb6\xc9\x31\x52\x09\xcb\x20\x51\x2e\xac\xa1\xdd\x6e\x4a\x2d\x2f\xc7\xd0\x45\x00\x3d\x23\x14\x52\x10\x96\xcd\x04\x6f\x95\xbe\x07\x02\xb3\x41\x22\x08\x84\x4c\xfd\x3e\x11\x06\x70\x84\x99\xe9\xdc\x4c\x77\xab\x1f\x43\x87\xba\x1e\x29\xd6\x6e\x3c\x89\x70\xc1\x21\x8d\x2d\xca\x61\xf2\x95\x54\xf0\xbe\xac\x2d\x54\xa9\x51\x69\x2a\xf8\x30\x95\x8e\xe6\x96\x95\xb9\xdb\x22\x12\xb3\x4f\xa0\x17\xbd\x70\x1e\x25\xb4\x36\x37\x61\x97\x56\x82\xc9\x95\xd0\x8f\x99\x8d\x34\x25\x39\x1d\x48\x2d\x7a\xb4\xc6\x61\x16\x17\xd1\x4c\xed\x34\xbd\x93\x7f\x40\x3a\xec\x18\x5d\x1a\xf5\x56\x9b\xf8\x8d\x20\x78\xfb\xc1\xcb\x9f\x7d\x90\x9c\x65\xed\x1e\x0d\x53\xd3\xa9\x86\x22\x17\x2d\x2d\x9b\x02\x67\xd7\xce\x6b\x09\xcf\xdd\x91\x17\x5e\xac\x3b\x0d\x8a\x8e\xde\x3f\x73\x11\xce\x99\xc2\x49\xee\x80\xf8\xa7\xa0\xeb\xd8\xa9\x88\xd6\x0e\xa1\x75\x1c\x23\xa9\xd4\x85\x31\xfd\xd1\x9e\x97\x30\xa9\x48\xc8\xab\x3e\x66\x68\xa0\xd3\x69\xc3\xa8\x28\x6d\x52\x52\x12\x91\x7d\x02\x6f\xc8\xd2\x49\x30\x6f\x40\xdf\x0b\x12\xfa\xf9\xea\x70\x97\x5e\xac\x97\xe5\x50\x80\x33\x22\xbc\x73\x94\xfa\x00\x47\x57\xf0\x68\x53\xe3\x7e\x87\x24\xd6\x1e\xef\x0a\xce\x18\xed\xac\xbc\x0a\xaf\x00\x09\xda\x8d\x2f\xd7\x71\x6d\x91\xce\xb0\x0d\xdd\x63\x12\xf9\x8e\x92\xf2\x77\xa8\x94\x34\x27\x61\x24\x95\x3c\xa3\xf3\x44\xfa\x3b\x49\x57\x11\x90\x45\x42\x58\x10\x0f\xb3\x32\x08\x3b\x12\xcc\x13\x01\x7f\x2a\xfa\x65\x69\x34\x33\xb3\xb7\x4c\x59\x92\x0c\x77\x70\x59\x2f\xdf\xbb\x75\x4b\x47\xf7\x6f\xf9\xbd\xf9\xf3\xfe\xce\x15\x94\x1b\xc6\x3f\x08\x8c\xe1\x64\x0e\x7f\xa0\xeb\x7b\xe4\xba\x25\xf9\x1c\xaf\xdb\x4d\x72\x1d\x45\x68\xba\x15\xc2\xc5\x17\x68\x1d\xb1\x1d\x66\xa1\x1c\x8e\x48\x86\xae\xe2\xd5\x4c\x26\xb3\x8b\x39\xca\xb0\x6a\x26\x90\x59\x8b\x5e\x7c\xc7\x70\x1a\x86\x61\x58\x85\xc2\x54\xc1\x2b\x58\x36\xa0\x82\x67\xf5\xaf\xf3\xaa\xa1\xc2\xc4\x53\xf4\x02\xd9\x87\x8a\x64\xcf\x82\x57\x72\xff\x99\x9c\x48\xf8\x5e\xa4\xf1\xf2\xad\x5e\x07\x81\x64\xd3\xa5\x3b\xbd\x3f\x83\x2f\x01\xd3\xbb\xbc\x66\x6b\x75\xcf\xf2\xfe\x1f\x54\x33\xfa\x4b\x97\xea\xaf\xfc\xf6\xeb\x06\x30\x04\x30\x33\xee\xdd\xdb\x08\x17\xc2\xbf\xa7\x33\x63\x67\x4d\xdb\x0d\x3f\x5d\x3a\x7b\xee\x01\x50\x80\xe7\x81\xfb\x10\x9c\x25\xf3\x88\x26\xf3\x0a\x44\x7b\xa0\x0b\xb9\x26\x7e\x09\x57\xef\x5f\xac\x43\xee\x97\x01\x37\x0b\xc3\x99\xb2\x98\x65\x61\xdf\x0f\x92\xc2\x9d\xe9\xcf\x41\xfc\x3e\x78\xae\x50\x02\x54\xe1\x06\x58\xc6\x65\x21\xb6\x54\xd5\xa9\x95\xc5\x23\xb2\x3c\xae\x7e\x39\xc2\xdf\x0b\x74\x5f\x29\xb9\x6f\x3c\x79\x0e\xce\x79\xbd\x4d\xae\x9b\x11\xfc\x79\x0a\xd7\x44\x07\x94\x53\xed\x1d\xd1\x72\xcf\x0a\xfe\x33\x39\x60\x3e\x94\x03\x76\xb4\x1c\xb4\x40\x2f\xe5\x88\x9b\xaa\x91\x1d\xca\xc9\xe5\x2c\x60\xb9\x4a\x9e\xd5\x01\xaa\x12\xf3\xfc\xd7\x6b\xe4\x54\x08\xec\x35\x4a\x08\x6e\xc0\x47\xdf\x98\x06\x9e\xc7\x31\x47\xe3\x5e\x96\xc6\x31\xf7\xe3\x14\xd1\xce\xf4\x68\xb6\xe8\xd9\xb3\x97\xbb\x9e\x3d\x63\xc2\xef\xdc\xc1\x30\xe1\x3e\xba\x9f\x70\xdd\x10\x4c\x09\x84\x2e\xc5\x35\x46\x10\x21\x0a\x03\x34\x87\xf8\xbb\x04\xb1\x01\x96\x21\x48\xc0\x19\x51\x62\x0d\x07\x81\x77\x03\xfa\xa3\xcb\x70\xd9\x65\x4c\xa7\xcc\x27\xf0\x05\x5b\xf4\x72\x17\xc6\x03\xe5\xc2\x2b\x7b\x8a\xcc\x57\xa8\xd1\x82\x7b\xa1\xde\x45\xf7\x56\xe0\x5a\xe3\xe8\x9e\x52\x24\x3b\x68\x64\x30\xb2\x0c\xf0\xa4\x3c\x2b\x05\x11\x26\x24\x68\xba\x4a\x4d\x86\xa4\xc8\xf0\x4c\x2c\x00\xa7\xfe\x72\x31\xb4\x0d\xbe\x13\xc3\xfc\x10\xe7\x9c\x08\x22\x7c\x61\x38\x7d\x33\xee\x01\xf8\x19\x2c\xfb\xd7\x33\xf8\xc9\x0c\x38\x04\xe9\x6b\xd4\x87\x08\xe7\x31\xe4\x99\x29\x04\x86\x75\x42\x9f\x51\x74\xdd\x82\xe0\xdc\xbf\xe1\x39\xfb\x94\x2b\x40\x9a\x40\x08\x3e\x67\x73\x98\xb9\x70\x79\x78\x35\x1f\x2c\x67\x23\x8c\x11\xd5\xbc\xb7\x51\x8e\xfe\x7b\x9a\xbc\xd8\x10\x4f\x3d\xd5\x24\x2d\xb8\xf1\x28\x8a\x14\x40\x27\x75\x91\x70\xb3\x4c\xa1\x46\x21\x9d\x8e\xf3\x13\x85\x00\x79\x3a\x0a\x01\x6b\xf0\x4a\x07\x7a\xac\xb5\x31\x0f\xbb\x74\xd4\x8f\xf0\x6d\x3f\x31\xd7\xb9\x22\xdc\x7b\xc7\xe9\xe2\xd5\x57\x26\x29\x82\xfe\x08\x52\x7c\xfa\x5d\xc9\xba\x0b\xa3\xbd\xc3\xe1\x8e\xd2\x2c\xdf\x11\xfa\x82\xba\x76\x8c\xb9\xac\xbf\x73\xe7\x90\xcf\x9d\x29\xdf\x9f\xdb\x3d\xec\xd7\x1d\x65\x5b\xb7\x7e\xb6\x63\xc4\xfd\x83\xbd\xbf\xa7\x7b\xbf\x55\x43\x97\x0c\xf8\x54\xe0\x2b\x5c\x2b\x32\x9f\x74\xb2\x5e\x3d\xd1\x75\x0b\x84\xd3\x00\x2a\xc4\xa1\xa5\x18\x2d\x53\xc5\x1b\xb4\x5a\xe0\xa3\x93\x61\x9e\xd4\x58\xe3\xcf\x55\x02\x37\x44\x2f\x74\x8a\x11\xea\xf9\xa7\x63\xfb\xc2\x95\xe7\x4a\x85\xd0\x5f\x74\x7c\xd4\xd1\x13\xae\xd2\x77\x7a\xd4\x59\x5d\x94\x2f\x5b\xf0\x68\x81\x6c\xd0\x28\xff\xce\x8f\x3a\x35\x83\x4f\x7f\x06\xf3\xe1\x70\x30\x1f\x74\xcb\xe9\x05\xf6\xc0\xbc\x0e\x29\x65\x39\xf4\x4f\x4e\xeb\xbc\x95\x60\x3f\x2c\x70\xc2\xbf\x84\x73\xa0\x6f\x44\xde\x1e\x4e\x59\x1d\x7a\x03\x55\xc1\x1b\xd8\xe0\x00\x3f\xa5\xd4\x53\x86\x68\xdb\x22\xc3\x10\x09\x4c\x4a\xe4\xe9\x42\xc5\x6f\x17\x37\x0f\xd3\x26\xea\x92\x49\x79\x16\x52\xc8\x4c\x60\xe7\xb8\x1f\x69\x18\xfd\xd3\x5b\xeb\xcb\x5a\xa4\xa7\x43\x6d\xf4\x88\x8c\x41\xbb\xba\x1d\x05\xf4\x8c\x29\x67\x87\x76\xdf\x37\xa9\x36\x73\x48\x34\xd4\xa6\x0f\x1a\x9b\xd9\x9f\x1d\xb5\x10\x36\x8c\x29\x5b\xde\x01\xf3\xf0\xf7\x01\x35\x17\x48\x2f\x0f\xef\x7f\x62\xda\x18\xf8\xfb\xaf\x5d\xe5\x88\x8b\x57\xec\xb9\xd4\x73\xec\x54\x37\x0f\x90\xd4\x21\xdd\x2d\x1a\xeb\x6e\x54\x7f\xf4\xf7\x16\xa5\xd8\x4f\x03\x85\x82\x13\x18\x79\x23\xfd\x90\x71\x2d\x5e\x1b\x27\x93\x35\x1d\x17\xd7\xf0\x3b\x97\x24\x31\x20\xb9\x50\x4d\xe4\x42\x73\x34\xdc\x73\x1f\x1d\x11\x21\x48\x05\x32\x86\xf4\x7f\x23\x63\x7a\x0b\x63\x0a\xf1\x18\x60\xb3\x35\x19\x13\x09\xbb\x22\x5d\x15\x8f\xe9\xdb\x74\x4c\x50\x50\x93\x31\x58\x06\xa5\x93\x31\x82\x0c\x6a\x1e\x40\xc6\xb8\x24\x10\x19\xd3\x1f\xd7\xb1\x24\x72\x6a\xa4\x20\xa7\x9e\x88\x72\xca\xd7\xb7\x51\x4e\x61\x07\x09\x86\x9b\xf4\x02\x0c\x27\xbd\x4d\x8d\x1a\xb5\x82\x92\x31\x32\x2b\x2e\x26\x2f\x16\xa9\x79\xbd\xb7\xa9\xab\xdd\x90\xce\x82\xdb\x60\xe1\x5a\xa1\x34\x0e\xa6\x30\x59\xc2\x92\xac\x62\x5b\x6d\x81\x6d\x33\xa6\x6e\x5f\x8e\x87\x7b\xbc\x86\x80\xc3\x53\x36\xf9\x30\xf6\x2c\x20\x6b\xb7\xd1\x2a\xb3\xc2\xa7\x3e\x30\xbd\x55\xdb\xae\x5b\xec\x4c\x51\x7e\xb7\x11\x1d\x1f\xce\x1a\x03\x2a\xca\x86\xd1\xc9\x53\xc7\x4f\x1a\x50\x01\x4f\xd4\x56\xf5\xf8\x72\xfb\xb0\x71\x83\xca\x4a\xbe\xd9\x5a\x34\x6f\xf1\x3c\xf8\x25\xb1\x99\xcf\xc3\x2e\xec\x0e\x64\xe7\x79\xa3\x9d\xdb\xda\x11\xaa\xf3\xf7\xf3\xf7\x2b\xe4\x29\xff\x21\xfe\xb4\x9a\xf1\xf7\xa7\xe4\xf2\x90\x42\x5e\x4e\x49\x25\x66\x5b\x24\x15\x59\xc8\xd3\x42\x6d\x0e\xc1\xcc\x7a\xb3\x9c\x18\x17\x6c\x0b\xc1\xb5\xbc\x81\x68\xac\x90\x62\xb6\xf8\x8f\x1e\xb7\x43\x73\x77\xc1\x0d\x20\xc5\xd0\xe8\x9a\x1d\x43\x65\x72\x43\x1a\xbc\x07\xcc\xb1\x20\xe4\xef\x23\x9f\xb4\x9e\xd4\x63\xc4\xe4\x29\x8f\x7a\x2c\x9a\x6e\xab\x18\x97\x39\x7f\xd8\x44\xff\x85\x11\xe3\x5b\x97\x8e\xcf\x32\xf4\xa8\xa9\x80\x97\xb9\x1d\x0f\xaf\xcd\xaf\x2b\xd9\x51\x67\xf5\x5d\x3d\xa2\x0e\xce\x04\x4f\xab\x7b\x9e\xd0\xe6\x4d\x6c\x35\x7e\xee\x72\x67\x50\x68\x5c\xc1\xbb\x64\xff\xce\x87\x5d\x39\x15\x9b\x86\x24\xa8\xd1\x21\x53\x79\xd0\x06\xb9\x59\x8d\x8b\x9e\xdb\x33\xc5\x56\xc3\x06\x69\x06\xae\x3f\x88\x1b\x5a\x5b\x48\x1d\xe9\x00\x40\x87\x31\xca\x4c\x2b\x28\x01\x36\xe7\x9a\x82\x8a\x08\x78\x3d\x67\xe8\x0d\x10\xd9\x07\xb1\x1d\x69\xa2\x29\x7c\x59\x36\x3d\xee\x65\xfd\xac\x4b\x75\x17\xaf\xb3\x71\xce\x3a\xc9\x2c\xb2\xce\x76\x44\x0f\xb8\x17\xa8\x02\xf1\x3d\xab\xc3\x10\x14\x62\x41\xb8\x0a\xa4\x0d\x66\xd6\xdb\x42\x79\xcb\x0a\x79\x6f\x71\x9d\xdd\xac\x17\x37\xe2\x72\x15\x9b\xd2\xdb\x48\x82\xaf\x54\x05\xc4\x72\xa7\x3a\x2b\x39\x65\xed\x32\x69\xcc\xce\x6e\x55\xdd\x7a\x2e\xc9\xd7\x2c\x01\x9e\x79\x25\x2a\xff\x0f\xe1\xd3\x4d\x3f\xde\x57\x76\x00\x8f\x5e\xfa\x31\x9d\x43\xe9\x76\x9b\x56\x87\xaf\xfe\x71\x40\xaf\xfe\x7d\x4f\x31\x51\x52\xf8\x53\xc9\xa7\xb5\xb9\xad\x96\xde\x9d\xf8\xd5\xbe\xa4\x76\x60\xe2\x3a\x90\xf6\xf6\x11\x82\x07\x57\x6f\xc4\x30\xaa\xb3\x23\x41\x19\x64\x09\xb2\x14\xf1\xea\xa0\xc0\x20\x5a\xc3\x04\x05\x19\x25\x46\x73\x11\x6f\xf3\x06\x46\x6f\xc0\xa8\xbd\x81\x27\xe7\x6d\xd4\xe0\x2e\x89\x06\x06\xc9\x1d\xc0\xe0\x66\x89\x76\xc1\xd6\xb1\x0b\x86\xcf\x1b\x8b\x6d\x25\x79\x34\x16\x21\x93\x49\x68\x9a\x88\x96\x3d\xe8\x95\xa6\x89\xb8\x81\x65\x6c\xf7\x63\xa5\xb3\x9e\xc0\x6f\xce\xdc\xed\xb3\xb7\x0f\xa8\x59\x38\x97\x6a\x58\x0b\x92\x86\x9d\x09\x9d\xdd\x69\xf8\x34\x30\x21\xe4\xc7\xdf\x41\xd7\xad\x45\x1d\xe6\x9d\x99\x35\xa1\xdb\x8c\xce\x1e\xb4\xe7\xc8\xce\xdd\xde\x2d\x3d\x3c\x2e\xa3\x5d\x61\x66\xdd\x9e\x8a\x1e\xcd\xb2\x84\xf3\xd4\x49\x70\x30\xdb\x80\xf0\x1d\x4c\x8d\x75\x94\x52\x81\x40\xc1\x05\x12\x6a\xbd\x4c\xdd\xa7\xfe\xa6\x98\x13\x14\xd8\x4f\x81\xcd\x14\x98\x49\x2d\xa7\xe8\x64\xaa\x37\x45\xb7\x37\xf2\x46\x3a\xca\x08\x7a\x4a\x41\xb6\xb4\x54\x4a\x27\x48\xc1\x8f\xca\x5f\x95\xff\x56\x32\xdf\x28\xc1\xa7\x4a\xb0\x4d\x09\x66\x29\x57\x28\x69\xa5\xd4\x48\xb1\x9e\xfe\x94\xe7\x41\xc0\xe1\x86\xdd\x58\x27\x7f\xf5\x1f\x5e\x3f\xa1\xe5\xa5\x21\x00\x98\x84\xaa\x95\x36\xb2\x29\x49\x79\x0f\x1d\x65\x4d\xc1\xe5\xb0\xa4\x2c\xce\x81\xb0\x75\x99\xbf\x75\x41\x55\xcb\x6d\xb9\x0a\xba\xf7\x86\x15\xef\x76\xfc\x08\x0c\x05\x51\xe0\x2a\xdc\x12\xca\x64\x86\x22\xeb\x77\xc9\x41\x30\x3c\x22\x29\xdc\x12\x56\xdb\x3d\xff\x4c\x5e\x6e\x79\x86\x21\x2a\x31\x2c\xb4\x70\x68\xd1\x34\x90\x0c\x7a\xfc\x20\x95\x1e\x39\x72\x08\xbe\x0f\x6f\x91\x7a\xfe\x88\x77\xa1\x35\x0c\xc4\x35\x24\x8d\x9e\x3e\x3e\x12\x5c\x8c\x41\xa3\x96\x7b\x1a\x03\x49\x89\x6f\x7c\xae\xe5\xaa\xe5\xd7\xb4\xe7\x16\xce\x1d\x6a\xac\xa6\x4f\xca\xab\xd0\x53\x4e\xab\x1d\xad\x07\xac\x0e\x18\x0a\xef\xbd\xaf\xe2\x80\xd2\xd3\x83\x29\x3d\x34\x76\xee\x0c\xf5\x75\xf4\x14\xff\x7c\x7b\x6e\x8b\x8d\x4b\x9d\x87\x98\x92\xb6\x05\x91\x91\xd1\x49\xf1\xe1\x43\xca\x47\xd4\xb5\xe8\xf8\x72\x26\x92\xf1\xb3\x10\x2d\x2d\xe2\x4e\x21\x8b\xc6\x44\x6a\xd5\xf9\x9b\xf5\x85\xbc\xda\xbc\xd6\xbc\xcb\xcc\xe8\x18\xb3\x99\xf2\xf0\xf0\x2e\xe2\x3d\x28\x4a\x5d\xe4\xae\x6e\xf3\x7a\x07\x56\x4c\xe3\x14\x6e\xc3\x82\x6c\x2f\x9b\xab\x1e\x32\x70\x77\xf8\x78\xb6\xfb\xb3\xc0\xf6\x20\xfb\x57\x30\xac\xd7\x9e\xc7\xc3\x7a\xae\x8d\x87\x15\xa6\x2c\x60\xad\x5e\x95\x00\x36\x98\xb2\x0d\xbf\xdf\x9a\xb2\x1e\x8c\x04\xa3\x61\xce\x07\xb0\x00\x7e\xb7\xf2\xe3\xfa\x7b\xd3\xaa\xc6\x4c\x63\x87\x3d\xbc\x3b\xa5\xa2\x76\xbc\xd0\x73\x8b\x4d\x47\xfb\x5e\x4b\x7a\x6e\x71\xb8\xe7\x96\x9a\xa2\x94\xaf\xf7\xdc\x12\xba\xba\xa5\x88\xc5\x85\x11\x05\xd3\xfb\xe1\x6e\x65\x2f\xd2\x6f\x6b\x9e\xb4\xef\xa0\xf2\x99\x1b\x0c\x40\x93\xd0\x06\x77\xdb\x8a\x0e\x0a\x1c\x30\x60\xd2\x67\x82\xee\x85\x6b\x85\xdc\x60\xd3\x90\x9e\x40\xf2\x73\x1b\xae\xa2\x6b\x2b\xe9\x91\x65\x71\x68\x14\x12\xca\xe0\xe5\xa5\x2d\xe1\xbd\x28\x39\xb2\x1d\x8c\x82\x66\x27\x36\xbe\x14\xca\x0b\x63\x1d\x17\x2b\x5d\xc0\x86\xbd\xaf\xa4\xf5\x1d\xa2\x25\xd6\x0a\xaf\x26\x68\x81\xef\xa8\x20\xf8\x37\xbc\x4c\xaf\xf1\xf0\x09\x8e\xb3\x26\xc4\x79\x76\xe9\xd7\x7b\x4c\x8e\x17\x38\xb3\xb6\xc6\x47\x9a\xf6\xb3\x1d\x96\x30\x7f\x98\x26\xf0\xa1\xfa\x2f\x02\xb2\x57\x2e\x25\xcf\xff\x16\xf1\xee\x7d\x42\xad\x6a\x87\x8e\x56\x9a\x8d\x26\xa5\x5a\x21\x37\x73\xfa\x62\xde\x53\xc6\x79\x11\x77\x21\xde\xbe\x99\x76\x52\x9d\xc3\x55\x92\xda\x16\x22\x25\x47\x04\x12\x57\xf9\x10\x46\x22\xa5\xaf\xcb\x54\x4c\xed\xb6\xc4\x8e\x6a\x56\x9f\x0b\xef\x03\x2b\xf0\xa9\x55\x2e\x78\x6b\xa5\xef\x10\xe0\xb3\x31\x94\x19\x92\x73\x3a\x3e\x72\x38\x9c\xc6\xdd\x76\x6e\x6c\x17\xff\xfe\x07\xf3\xe8\xd6\xf5\x07\xbf\x0b\x41\x38\x5f\x8c\x70\xb0\x8c\xd4\xca\x54\xed\x97\xd3\x6a\x16\x34\xa9\xa7\x2c\xa8\x19\x84\x0a\x29\xba\x1c\x3e\xff\x1c\x44\x0c\x1a\xb5\x28\x4f\x0d\xbc\x75\xf0\x14\x9b\x56\xbf\x7f\xfa\x23\x67\x55\xab\xe6\xcd\xd3\x4e\x38\x49\x2f\x8e\xa1\x68\x7f\xe3\xfa\x35\xcd\xa8\x02\x87\xce\x27\x3a\x26\x3a\xa6\x90\x8f\x8e\x0e\x91\x59\x49\x31\x2c\xea\x60\xc3\x63\x87\x8f\xc9\x37\x27\x91\x02\x52\x09\xb8\x27\xf9\x4b\x42\x2b\x24\x06\xca\x2f\x5c\x22\x0b\xa1\x64\x8d\x3b\x77\xa8\xd8\xc2\x4b\x28\x92\x2b\xec\x0c\x92\x98\xe6\xde\xb3\xb1\x40\xc8\x5b\x0b\x15\x99\x56\x26\xe0\x70\x14\x84\x0a\xa8\xf1\x40\xa9\x8a\x01\x9b\x07\x2c\xd9\xb3\x56\xd8\xc1\x51\x15\xeb\x4e\xaf\x59\x00\x74\xfb\xe9\xe5\x87\x4f\x7e\x44\xc3\xdb\x95\xa1\x8c\x7f\xc8\x5f\x4f\x75\xcc\x87\x97\xad\xc7\xbf\x9b\x92\x06\xc6\x66\xe5\x79\xfb\x8f\xef\x29\x6c\x65\x7d\x60\x54\x70\x70\xc4\xac\x21\x13\x6e\x2c\xf5\x91\xca\x46\xf0\x15\x8b\x2d\x1e\xd2\x23\x9f\x68\x7b\x97\x9b\xb3\x72\x14\x47\xcd\x69\xa5\x35\x98\x96\xc4\x3e\x39\x88\x96\x8a\x85\xf8\x56\xa4\x33\x28\x11\x1e\x83\xb1\xc6\xa0\xa1\x7c\x83\x7c\x0b\xf9\x80\x20\xb5\xd1\x28\x93\xcb\x25\x62\x53\x45\xa1\x76\x4f\x63\xb5\x71\x77\xc9\x7a\xec\x2b\x4d\xd1\x87\xa0\x6d\x85\xb6\x92\x2e\x13\x08\x35\x57\x10\x33\x4a\x1f\xe6\x11\x14\x12\x14\xc6\xf6\xe9\x7f\x51\x3e\xe6\xcf\xe6\xad\x73\x53\xe0\x2f\xfc\xb0\x50\x9f\xd4\x81\x16\x5b\x76\x2d\xf3\x83\x95\x19\xef\xfc\x28\xdc\x3b\xc4\x4f\xfe\xa1\xe5\x90\x2d\x9d\x1e\x0e\x7f\x86\xf0\xea\x84\xaf\xc1\x88\xc3\xd3\x0c\xda\x13\xfe\xa4\xbf\x5a\xc3\x71\x44\x67\xb5\x6c\x01\xda\x57\xfe\x58\x03\x35\x21\xc3\xc2\x80\xeb\xd3\x49\x38\x33\xae\x80\xca\xb8\xcb\x75\xd9\x33\x9b\xa8\x01\x84\x09\x89\x9d\x96\x55\xa4\xaa\x9a\x5c\xe8\x9d\xa0\xa3\x4b\xb6\x96\xca\x4d\x39\xf0\xca\xf1\x38\x90\xf5\xeb\xa7\x97\x0b\xde\x3d\xb5\xe4\xed\x0b\x8e\xa4\xb0\x81\x2d\xb2\x27\xb6\x37\xcc\xde\x0d\x97\x30\x7f\x3c\x03\x5e\x37\x4f\x4e\x80\x0d\xa7\x87\xd2\x17\x4f\xc3\x5d\xf0\x71\x7a\x9b\x77\x80\x84\xe0\x6a\x22\xa2\x93\x45\xa4\xae\x2c\x8e\xd1\xd2\x6a\x83\x7d\x90\x4e\xe5\xe7\xa3\x11\xb9\xb7\xdd\xdd\xc0\x4d\x2c\xb4\x84\x57\x3d\xc9\xb5\xe8\x4d\xba\x56\xd3\x60\x71\xdf\x79\x6b\x27\x64\xf6\xec\xb8\xa9\x7b\x6c\x8f\x35\x3b\x97\xf4\x3a\xfc\x72\xe1\x6f\xe3\x76\xf7\x9e\x52\xbe\xa9\x37\xd8\x98\xdb\x3d\xd4\x96\xc1\xb7\xed\xfc\x59\x97\xdc\xfe\xd9\xfe\xb1\xa1\x41\x21\x1b\x26\x0f\x01\x01\xf5\x33\x3e\x58\x3d\x65\x15\x6c\x10\xce\x17\x5b\xa2\x75\x8b\x25\x7d\x39\x2d\x94\x9f\x43\xe5\xe9\xe5\xe1\x85\xf9\x0e\x85\x20\xa2\x9a\xd4\xf2\x11\xf9\x1f\x56\xc4\x2d\xd2\x10\x9b\x94\x9c\xe3\xea\x13\x6d\xc8\x9c\x71\x37\x38\xfd\xf3\x87\xdb\xd5\x5f\x00\xaf\x9d\xb4\xa7\x75\xe6\x58\xd0\x63\x15\xbc\xb9\x3e\x22\xb9\xf8\x9d\x01\x76\xbe\xa4\xc7\xc2\x8e\x86\x6f\x8f\xce\x04\xc6\x13\x6f\x1d\x91\xb0\x6b\x36\xad\x87\xff\x5a\x41\x6f\x98\x5a\x53\xb0\xf4\x48\xd7\x01\x35\x63\x6f\x09\xf2\xf1\x70\xc3\x6f\xec\x72\x04\x8b\x1f\x15\xec\xd0\xea\xbd\xbc\x34\x85\xbc\x97\x17\x4e\xd1\x2e\xe4\x59\xa9\x9a\xca\x7c\xb5\x72\xbe\x50\x4f\xdd\xfe\x4f\xa5\xf3\xf5\xe0\x58\xd1\x3b\x7e\x36\xff\x7e\xc9\xf4\xdf\x56\xb8\x65\x88\x24\xc9\x1e\xe1\x08\x0d\xaa\x8b\x98\x33\x49\x36\x9e\x19\x6f\x52\x9d\x50\x68\x8f\x38\x3f\x0b\xf0\x6a\x16\xec\x71\x40\xa6\x2a\xaf\x0e\x8d\xa1\x27\x0b\x30\x10\x1d\x19\xc1\xe0\x43\x19\x1c\x32\x03\xd2\xba\x94\x8d\xd5\xce\xec\xee\xf2\x6d\xee\x9e\x9a\x3a\x91\x3f\xd0\x2c\x78\xf6\xcd\xe7\x6a\x5c\xd2\x5d\xd1\xb1\x73\xaf\x89\x9d\x63\x41\x40\x38\xc2\x80\x61\xc5\x7a\x47\x07\x5c\xcb\xbd\x45\x6c\x49\xa7\xb9\x20\x6d\xf2\xbe\xe9\x53\xb6\x5f\x86\x63\x8e\x63\xdc\x7b\x93\x1e\x67\xc5\x88\x2a\x6d\xb8\x63\xa5\x31\xa8\x88\x37\x6a\x3c\xe5\x45\x88\x34\x43\xb5\xb4\xb6\x90\xf7\xa7\xbd\x80\x28\x24\x9b\x94\x2b\x22\x71\xe3\x22\x29\xa0\x39\x23\xfc\x9b\xf4\xae\xae\xfc\x98\x3f\x0b\x2a\x6a\x06\xd0\xd1\x9a\xab\x05\x7b\x0f\x65\x4f\xfb\x72\xae\xaa\x64\x52\x87\xf7\xfb\xda\x7e\xd8\x34\x69\x7e\xd1\xba\x5f\x66\x83\xda\x0e\xa9\x1d\xbd\xfb\x0e\x58\xd2\x09\x76\x01\xcb\x3c\x4e\xee\xaf\x05\x92\x13\x93\x2c\x1f\x19\x56\xd4\x8f\x38\xa7\xa0\x4d\x27\x4e\x1f\xda\x3a\x15\xde\xb8\x36\xca\x83\xf1\x59\x35\x70\xac\xf3\x37\x6e\x2d\x10\x7c\xd3\x0d\x83\x90\xa4\x7d\xcc\x16\x12\x9e\xad\xe7\xf4\x32\x15\x2b\xd5\x7a\x9a\xa5\x6a\x5f\x8a\x32\x95\x34\x29\x87\xef\x6a\xe6\x8a\x24\x84\xce\x94\x82\x0f\x73\x2d\x0c\x6e\x80\x4c\xa4\x07\x20\xd2\x03\x0c\xcf\x2e\x4a\x6f\x27\x6f\xfb\x3b\x88\x80\x0c\xd5\x00\x2f\x0c\xf6\xf5\xf4\x2e\x85\x17\xe1\x05\xba\x57\x4e\x42\x7a\x42\x44\x14\xd3\x85\x2d\x8c\xae\x81\x2f\x73\x07\x83\x2a\x67\x7e\xfd\x39\xb0\xbb\xb2\x47\xe2\x74\x98\xc7\xb4\xfc\x73\x53\x17\xcd\xd1\x00\x9c\x73\x82\x70\xf8\x90\x6b\x81\xe0\x09\x72\x68\x7c\x19\x56\xa7\xa6\x7c\x14\x3e\xc8\x50\x51\x78\x79\x36\xed\xcc\x84\x4d\x14\xdc\x3d\x04\x97\x09\x72\xb5\x66\x72\x59\xbc\x26\xbd\x9d\x5e\x38\xb8\xc6\x7f\xe4\x93\x31\x09\xf5\x3f\x15\xdc\x2c\xd8\xb7\x4b\x3b\xe6\xc9\x48\x75\x56\xfe\xad\xeb\xbb\xe9\xf9\xab\xe8\x4a\xe7\xa2\xfa\x9b\x34\xac\x01\xcb\xe8\x95\x1b\x1c\x95\xf4\x10\xe7\xfa\x82\xe6\x45\x05\x0c\x3b\x97\xd0\x0c\xae\xef\xf9\x21\xe2\x2f\x31\x54\x9c\xc3\xc4\xf8\xfa\x4a\xd5\x61\x1a\xb5\x06\x29\xa7\x6a\x4d\x90\x97\x14\xed\x27\x4a\xea\x45\xbd\xd2\x23\xca\xd5\xdb\x8a\x6b\x6c\x5e\x25\xae\x26\x78\xa5\xd7\x95\x48\x61\x29\x82\xed\x4b\x3b\x7b\xf5\xa1\xb9\xf8\xf7\x7a\xd5\x8c\xc9\x99\xb6\xbf\x86\xce\xae\xc9\x6b\x97\xd0\xdd\x1c\x75\x23\xca\xab\xa5\x9d\x6f\xd5\xdd\x31\x71\xe6\xa8\xe3\x86\x59\x63\xc6\xcc\xda\xbe\x7e\x12\x30\xff\x3c\xdf\xf0\xa1\xe1\x03\x78\xbc\xdf\xa2\xcf\x17\x5e\xbf\x3e\xa0\xcb\xfc\x55\xc0\x56\xf3\x81\xdf\x87\xbe\xdf\x6d\xd9\x08\xdf\xfd\x86\x72\xdb\x8d\x99\xdc\x1a\x97\xdd\x48\xf5\xbf\x43\x11\x4b\xd6\x7d\x74\xe9\xb2\x1b\xc9\x98\x91\xaf\x8c\x71\x9b\x8d\x2e\x79\x80\xed\x4f\x2c\x0f\x1a\x6d\x5d\xb3\xf9\x0d\xfb\xd3\xe0\xb6\x3f\x45\x1b\xd5\x75\x1b\x32\x86\xe0\x92\x8c\x19\x2b\x8c\x49\x21\x63\x62\x63\x5d\x63\x90\x2e\x37\x14\x8d\xc1\xb5\x74\xfd\x48\x27\xe7\x34\x47\xa0\x6f\x54\x31\x6f\xd0\x5a\xb5\xb8\xad\xb7\xc9\xd7\xea\x6b\x65\xe4\xf2\xc0\x22\x64\xf6\x31\xcd\x4a\x5e\x37\x56\xe3\xe2\x52\xdd\x25\x60\x81\x81\xb2\x04\xd3\x02\x5b\x73\x17\x22\x44\xf4\x41\x76\x13\x43\xf6\x11\xe1\xf8\x4c\x93\x00\x00\x76\x08\x3c\x07\xff\xba\xf0\x64\xd8\x45\x90\xb4\x6d\xf6\x8a\x9f\x0f\x15\x2e\x8b\x4a\x6e\x2d\x69\x7d\xa4\xdb\x27\xa7\xe7\x0c\x6b\x35\x36\x4c\xd7\x23\xa7\x6d\x97\x99\x3d\xcb\x6a\xdf\xeb\xd5\x65\xda\x62\x70\xff\x21\x7c\x0a\x82\x5e\x5c\x07\x3d\x5f\x2e\xe9\xdd\x6d\xfa\xba\xb0\x80\x82\xcf\xab\x52\x73\x3e\xa5\xab\x93\x62\x43\x75\xbe\xe1\xf5\xff\xee\xd4\x6d\xc9\x88\xe2\xca\x85\x02\x3f\x56\xa1\xb9\x3d\x25\x3d\x6c\x53\xa9\x96\x8e\x20\xbd\xd1\xa8\x2e\xe1\x41\x48\x7c\x48\x31\x1f\x1b\x6f\x44\xff\xb9\xc8\xc8\xc4\x62\x3e\x92\xe2\x02\x4b\x78\xee\xf5\xa9\x89\x33\x13\xcb\x0d\x48\xc4\x1a\xd8\x2e\xb3\x55\x2c\xbc\xa6\x12\x5d\x06\xa4\x54\x8d\xd8\x57\xd0\x6e\x11\xea\x78\xa1\x39\xb2\xdf\x0c\x4f\xfe\x1e\xbe\x58\xb5\x69\x93\x4f\xa0\x4f\x33\xaf\x76\xe6\xb0\x9e\xfd\x4a\x7b\x9a\x83\xcc\xc3\x0a\x96\x4e\x0a\xfc\x15\x8e\xfb\xa9\x0e\xe4\x9b\x86\xc3\xb7\x4d\xa3\x8a\x2a\xe7\xd3\x5f\xff\x02\x3f\x78\xbf\xb6\x7f\x78\x71\x5e\x2b\x93\xcd\xa4\x39\x91\x50\x98\x17\x9e\xdf\x31\x2f\xb4\x7c\x12\xa0\x17\x31\x07\x36\x8d\x3f\x31\x08\xae\xaa\x1c\x35\x2a\x77\x5b\xb7\xce\x5d\x7a\x92\xfd\xb2\x83\xa2\xb8\x32\x8e\x17\x7a\xcb\xca\x34\x95\xbc\x52\xc6\x1a\x38\xc0\x30\xf8\x70\x0a\x57\x11\x26\x85\x15\x89\x3f\xc1\x0c\x9a\xf4\xde\xc5\xc7\xd6\x3d\xe0\xd5\x01\xff\x06\x7e\x4b\x7f\x2f\x5c\xc1\xe7\x96\x47\xbd\x63\xb2\x18\x7c\x13\x23\xe1\x37\x74\x2c\x63\x72\x7e\x0b\x7a\x8f\xeb\x97\x56\xb0\x26\x50\x17\xd7\x12\x92\xb3\xbe\x06\x19\x79\xd6\x69\x44\x4f\x53\x88\x3f\xae\x99\x73\x17\x82\x41\xba\x17\x98\x28\xc1\x0d\x83\x68\x8e\xc0\x23\x79\xdb\x35\x86\xea\x4f\x39\xa8\xe7\x84\xc2\xfd\xfc\x9a\x9e\xe7\x74\x44\xbc\x66\x3a\x77\x5a\x23\xa1\x53\x01\x5e\x2b\x1d\x92\x9d\x0c\xe9\xcd\x10\x4b\xc5\x3a\x4c\x56\xb3\xc6\x5c\xc8\x2b\x35\x81\x81\x94\x4c\xe3\x15\xcd\x98\x08\x47\x14\xfb\x1e\xd8\x85\x66\x2b\x3a\xd1\x90\xd6\x23\x29\xfa\x7a\xfb\xba\x44\x5d\x4a\x88\x5e\x3c\x2b\xb1\x8b\x2d\xf7\x70\x89\x02\x8b\x84\x5e\xc9\xf6\xb3\x55\x45\x0f\x3d\x31\xc2\xc5\x00\xc6\x96\xf5\xef\xb9\xc0\x16\x14\x5b\x16\xe4\x7b\x23\xdc\xa3\x65\x7e\xad\xbf\x0f\xcc\xe9\x31\x90\x4d\x3b\xd5\x67\xf9\x2e\x78\x69\x07\x66\x02\x87\x76\xbe\x03\xd8\xc9\xce\x27\x65\x5d\x77\xaf\x9b\x76\xa6\x6b\xd0\x42\x10\xb4\xa7\xa0\x2e\xb8\x04\xde\x41\x7c\xfc\x1a\x9a\xcb\xbf\xd9\x56\x68\xff\xd8\x1d\x7e\x31\x7e\xc5\x7c\x8c\x31\x24\xa2\x98\x0f\x0b\x31\x1b\x29\xda\x4b\xed\xa9\x54\x4a\x8b\x79\xa5\x9a\x36\xba\x7b\xad\x09\xeb\x22\x08\x20\xc4\xcd\x93\x75\xaf\xf4\xca\x41\xbb\xc6\x04\x2c\x82\x37\x2a\x13\x34\xa9\x84\x99\x2c\xea\xa8\x29\x4c\xad\x73\x21\xfc\xf1\xed\x3d\xc5\xe1\x91\x2a\x9f\x7e\xc1\x3d\x07\x85\x3a\xf2\x58\xba\x3f\x48\x5d\x71\xa0\x73\x4c\xbc\xae\x65\xe8\xd6\xf7\x84\x66\xca\xed\xba\xca\x55\xad\xda\xe5\xf6\xa4\x8f\x3a\x5b\x7d\x08\xe6\xae\x9f\xa8\xfa\xc5\x43\x35\x69\x7c\xce\x9c\x39\x63\x69\xfa\xf4\x3e\x38\x68\xfd\x44\xbd\x04\x7e\xf5\xc9\x46\xdc\x4e\xb9\x55\x8b\x5c\xdd\xc4\xaa\xea\x0b\xeb\xd0\x7a\xe4\xa2\x39\xe1\x7a\xd5\x58\xcf\xf3\x73\xa8\x65\x86\x0a\x5e\xc6\xd2\xbe\x55\xbc\x96\xd6\x01\xb3\xab\xa5\x3c\xa9\x09\x80\xfd\x41\x2e\x97\x02\x16\x9a\x4d\x5d\x69\xb4\x03\x5e\x29\x82\x37\xfb\xec\x03\x60\xc3\x85\x9f\x4b\x16\x7c\x33\xb1\x7e\x6f\xcd\xaa\x8a\x3d\xfd\x57\x57\x22\x71\xb9\x39\x1b\xd4\x6e\x02\xe3\xa8\x86\x69\xb7\x6f\x2d\x84\xdb\xff\xb3\xc6\x8f\x99\xf4\xd7\x5e\xb8\x7a\x0e\x3c\x00\x7a\x09\x7b\x98\xf4\x0d\x24\xfd\xcd\x02\x30\x1c\x72\x23\x29\xfe\x6b\x46\x86\x25\x6b\x64\x9a\xc2\xc1\xd9\x19\x77\xdf\x04\xb4\x0b\x69\xe1\x98\xa9\x11\x90\xd9\xa0\x08\xde\x2f\x5a\xbe\x60\x2d\x08\x3e\x09\x76\xe5\x4e\xf9\xa4\xb2\x98\xaf\x99\x55\xb8\x79\xf0\xec\x42\x09\x2c\x07\x1b\x02\xcf\xac\x3c\x08\x2a\x0f\xc0\xc9\xa3\xe1\xdf\x9f\x8f\xa3\x3f\xe9\x55\x3e\x15\xde\x1a\x76\x76\x26\x08\x27\xfb\x0c\x71\x59\xf6\x96\xab\x6f\x84\x11\x54\xf1\x46\x23\x32\x73\xd5\x15\xbc\xc2\x83\xf8\x2f\xfe\xb9\x7f\x83\xd8\xf3\xdd\x5d\xb9\x6a\x5d\xc2\xa6\x83\xdb\x40\xd2\x97\x17\x7f\x31\xc2\x47\xf2\x61\xd5\x0b\x8e\x4e\x9b\x90\xd1\xb6\x8a\x6a\xf0\xbd\x7b\xe0\x28\x48\xd9\x75\xf8\x54\xbb\xd1\x83\x7f\xdf\x39\x7a\x8a\x01\x8a\x3d\x9d\xb5\x62\xdf\x84\x28\x64\x0b\x18\xa9\x40\xa9\x89\x95\x87\x60\xe2\xb2\x86\x98\xe5\x7a\x12\xf0\xd0\xb4\x35\x19\x56\x13\x38\xd7\x31\x84\x18\xde\x80\x01\xc0\x3b\x00\x1f\x55\xd0\x42\x37\x78\xb1\x06\x34\x7d\xc0\x91\x77\x7e\x63\xe9\x1a\x60\x3d\x8c\xc3\x1c\xa4\xf9\x1d\xba\x4d\xcb\x8a\xe9\x3e\xfc\xdd\x41\x2d\x17\x3a\x77\x1e\x39\x15\xd3\xe6\xfb\xee\x33\xa6\x76\x0a\x8d\xd6\x27\xf6\x7a\x6f\xe8\x17\x20\x6e\x0b\x8e\x76\xa8\xea\x3c\xe0\xc0\xb0\x36\x7c\x4b\x6b\xb3\xac\x8a\xec\xe1\x9f\x96\xc5\xff\xea\x67\xcd\x22\xb0\x66\x20\x1c\x3d\x22\x3e\xec\x10\x87\x4e\x46\x57\xf0\x94\x43\x26\x63\x39\xec\x61\x47\x7b\x9b\xb8\xdf\x04\x1c\xf9\x9e\x16\x6a\xe6\x60\xd3\x13\x7b\xe3\x18\xfa\x41\x28\xfc\xf4\x2d\xe2\xe5\xf8\x20\xda\x39\x3e\x8f\x1e\x58\x08\x5a\x1f\x82\x0c\xf6\x94\xd7\xc1\x2a\xb4\xc7\xce\x21\x3c\x6c\x21\xf5\xe7\xc9\xbd\x0b\xdd\xf7\x46\x9c\x5b\xcd\x9a\x5f\xbb\xb7\xb5\xe9\xbd\x91\xda\x5a\x30\x1b\xfe\x01\xac\xcc\xde\x70\x67\x65\x47\xba\xb6\x43\xd7\xa3\x4e\x07\x77\xfb\x14\x1c\x0c\xc7\x62\xb8\xfd\x90\x9c\x78\x89\xd6\xd6\x46\x45\x38\xbc\x6c\xfa\x30\x03\xab\x08\xb0\x58\xcc\x55\xbc\x85\x95\x29\x14\x92\x2a\x5e\xa1\x7f\xa5\xe1\x0a\x51\xc6\x18\x29\xfd\x4a\x7e\x5b\xb2\x3e\x05\xd8\x92\xf5\xaf\xee\x64\x06\xb0\x2f\x07\x67\x8f\xca\x0a\xcc\x8c\xb0\x0c\xb5\xf5\x19\xd1\xbc\x4a\x5f\x7f\xcd\x12\x3d\xb1\xb7\xf8\x4e\xaf\x91\x53\x19\x6f\xf6\x0a\x3c\xf2\x25\xdc\xdf\xaf\xbb\xee\xa2\x4c\xd1\xaf\x4b\xcc\x69\xa0\x4d\x76\x7e\xa3\x9e\x05\xba\x03\xef\xde\xe4\xcd\xde\x5d\xcb\xe0\x0a\x1a\xd7\x9f\x21\xe7\x0e\x17\x48\x4e\x42\x20\xda\x95\xac\x94\x91\x32\xc5\xbc\x54\x8a\x8c\x1d\x6c\x6d\x93\x52\x22\x44\x80\xe1\x7a\x22\xb8\x5d\x0d\x0e\x4c\x60\x64\x0f\x40\xd7\xfa\x33\x9e\xe0\xeb\x07\x70\x15\x93\xe6\x49\xf7\x6f\x86\x78\xf7\xd4\x66\xf8\x7e\x63\x21\xcf\xce\x41\x73\x0f\xa4\x5a\x39\x82\xfd\x03\x02\x03\x8a\x78\x93\x8f\xaf\x4f\x11\x6f\xf6\x75\x50\x81\x81\x3a\x4f\x9d\xbe\x8a\xd7\x99\x39\x4f\x4f\xa6\x92\xf7\x64\x5f\x6f\x94\xee\x7b\x36\xa1\x89\x94\x14\x94\x51\x1c\x47\xee\xa5\x33\x6a\x68\xca\x92\x92\x41\x23\x7b\xda\x66\x0d\xb3\x71\x36\x86\xf2\xe9\x91\x37\xf7\xf0\xf8\x59\xef\x6f\xee\xba\xec\xda\x88\x5b\xb0\x0b\xbc\x15\xb7\xf3\xc2\xfc\x58\x00\xa7\xa6\x81\xd3\xb4\x19\x7a\xb7\x66\x4e\xe6\x65\xbd\xff\x51\x9f\xb2\x84\x0f\xe1\xe1\x1f\xe0\x1e\x68\x80\xf0\x07\xed\xf8\xc7\xdf\xb2\xa7\x3f\x7e\x34\xa8\xcb\x7f\xc4\x5e\x2a\x7b\x61\x29\x3b\x88\xfb\x81\x32\x52\x5e\x0e\x85\x07\xc7\x48\x28\x20\x91\xeb\xcd\x72\x4a\x30\xfa\x11\x20\xe2\x23\xad\x61\xd6\x14\x96\xd2\x62\x86\xca\x25\xeb\x98\x22\x58\xd9\x1c\x9c\xd4\x84\xc3\xd4\x54\xf0\xce\x5a\xb8\xf7\x0c\x98\x0b\x7a\x46\xb6\x2b\x86\xdf\xd6\x0c\x06\x8b\x0e\x9d\x3c\xdb\xbd\xfc\xf4\xd1\x4f\xbe\x1c\xf7\xd5\x56\xe8\x05\xdf\x9e\xf0\xf4\xf7\xe3\x15\xd7\xc0\x56\x41\x57\x9f\x0b\xbb\x70\x7e\x88\xb6\xe3\x70\xfd\x5f\x89\x5c\x15\x11\xa0\x67\x54\xbe\x45\xbc\x4a\x2f\xb3\x16\xf1\x32\x3d\x05\x2a\x84\x52\xa8\x4d\x3b\x33\x08\xc7\x3d\x4c\x8a\x05\x73\x6e\xb2\xf1\xf0\xaf\xd7\xda\x3d\x37\x7d\x09\x54\x74\x48\x6d\x0c\xa3\x6f\x93\xe1\x63\x4a\xaa\x2d\x5e\xe4\xd5\x6a\x6a\xf1\x6e\xc3\x67\xbf\xef\xf5\x0a\xf0\x8d\xed\x62\xda\xf5\x60\xaf\x29\xc0\x8c\x5f\xfc\x0e\x5f\x06\x16\x0f\xe8\x06\xbb\xdc\xef\x5c\x37\xa2\x30\x6f\x43\x61\xf1\xcd\xdc\xde\xcc\x37\xf5\x83\x86\xb4\x69\x1e\xb1\x61\x12\x33\xbd\x7e\xd0\x70\x47\x72\x14\x7e\xf5\xe2\xd8\x9a\x43\x9d\xc9\x1c\xa6\x8b\x3d\xab\x9b\x21\x0b\xc9\xcb\x43\xad\x8b\x0e\xf6\x56\x87\x07\xe8\x02\x8a\x79\xb9\xce\x0b\xd0\x48\x37\x32\x37\x09\x0a\x68\x6c\x5d\x6d\x11\x26\x20\x88\xd6\x96\xe0\xd5\x9e\xd5\x4d\xab\xb8\x0a\xa5\x43\x69\xfa\xf3\xfa\xe3\xe1\x8c\x47\x6e\xbe\x6f\x10\x93\x30\xa9\x5b\x69\x5e\x8b\x29\x65\x85\x9d\x0d\x33\xee\x8e\x34\xa6\xc6\x96\xfb\x0c\xbf\x83\xfe\xc6\x75\xf3\x1f\x7a\xe7\x5c\x50\xd7\x71\xb0\xcb\x99\x9a\xe9\x1b\xfa\xf4\xec\xdd\x47\x53\xdb\xb7\x76\x78\x51\x1f\x7a\x97\x73\xfd\x20\xc7\xe0\x2d\xd3\xe8\x22\xf2\x62\xdb\x42\xba\xed\xcb\x73\xeb\x0f\x93\x39\x90\x33\xa6\x9b\x5c\x29\x42\x75\xb8\xc3\x68\xf0\xa9\xe2\xbd\x0c\xac\x5c\xc9\x28\xab\x78\x09\xc3\x48\x3d\x75\x52\x46\xd8\x05\x4d\xab\x4a\x8b\xd8\xc5\xa5\x71\x25\x8d\x5d\xf4\x88\xd9\x0f\x8e\xe6\x97\x26\x8e\x6d\x36\x0a\xd8\xe0\x0b\x78\xa5\xf7\x86\x69\x1f\xee\x9b\xf9\xfb\xa2\xac\xdc\x3c\x6b\x50\x8f\x91\x4c\x76\x41\xc7\x00\x6f\xba\xd7\x8b\x43\xb4\xda\xb1\x7f\xc7\xfa\xfa\xd9\xda\xf3\xd2\x2d\x02\x0d\x6e\x47\x70\xfc\xc6\x5d\x40\x52\x29\xd2\x61\x04\xac\x37\x8b\x3b\xfa\x50\x7e\x72\x6d\x31\xaf\x92\xcb\xfd\x84\x5a\xd0\xf6\xb8\xd7\x0a\xf3\xeb\x45\xcf\x8e\x9e\xb8\x76\x30\x04\x6a\xe0\x3e\x7a\x03\xf4\xde\x91\xfc\x9e\x2a\xf8\x50\x9d\xd9\x0e\xb4\xf6\x1d\x13\x11\x99\x12\x37\xc9\x2f\x4a\x37\xb9\xfc\xed\xc0\x81\xb8\x97\x06\x5d\x3d\xb6\x3f\x50\x64\x15\x80\x6c\x30\x44\xe6\x71\x59\xb1\xf8\x6a\x79\xcb\x8d\x1f\xad\xa4\xe3\x5e\x24\x92\xf5\xbd\x88\xd6\x77\x10\xa2\x51\x1f\x64\xf3\xeb\x0c\xc6\x6a\xde\x60\x56\xd0\x55\x3c\xe6\x61\x52\x46\x22\xe8\x83\x71\xa9\x2e\xb9\x8d\xf9\x14\x39\xfb\x13\x78\x95\x06\x29\xb8\x64\xa1\x75\x4c\xab\x1d\xbd\x7a\x4e\xc0\xcc\x18\xd8\x2a\x4b\x66\x75\xdc\xb0\x6b\x07\x5c\xff\x02\x0e\x08\x07\xc5\x1f\x5f\xec\x03\x8e\x3f\xb7\x3b\xc7\x72\x59\x50\x67\xf1\xbb\x73\x0a\xde\x85\x35\xd7\xcf\x2c\x00\x61\xf8\x6c\xe8\x00\x39\xb7\x1a\x45\x45\x50\x89\x54\xae\xc3\x16\x67\x8b\x89\x30\xd3\xfe\x14\x15\x11\x8a\x8b\x1a\xc7\xf8\x97\xf0\xfa\x18\x7d\x8c\x26\x34\x34\xa1\x90\x0f\xd5\x68\x8c\x1e\xa6\x62\x77\x8b\x97\x46\xbd\x3b\x0a\x5d\x22\xd5\x17\xd7\xce\x16\xea\x67\x03\x89\x54\xec\x41\x23\x58\xbb\x42\x86\x9d\xd0\xa0\xa6\x71\x3d\xbd\x4c\xc9\x29\x64\xa5\x85\xa6\x88\x9c\x32\xb5\x9f\x71\x0e\x74\xee\x1e\xd7\x25\x31\xc1\x54\xa4\xbb\xea\x7b\x78\x70\x97\xb2\x6e\xed\x0a\x47\xb4\x3a\xb6\x79\xc5\x96\x69\xcf\x57\x97\x6f\x48\x8d\xa8\x74\x46\xb6\x6a\x3d\xb7\xce\xd4\xa7\x6d\xcf\xbe\xcc\x95\x36\xd5\x2d\xfb\x9e\x80\xa7\xb6\xa6\x06\x9b\x7a\xcc\xdd\x93\xde\x62\xc8\xa1\x41\xc3\x47\x0f\x1c\xbc\xab\x32\x3d\x3e\xa2\x06\x2e\xb3\xc5\x8f\x8d\x49\x68\x8d\xd6\xde\x8c\xe4\xc5\x71\xc4\x33\x63\x70\x67\xd4\x30\x99\xbf\x2e\x2a\x2a\xa8\x8a\x8f\xd2\xab\x74\x3a\x45\x35\xaf\x7b\x95\x49\xa6\x62\x0d\x15\x99\x0d\xc4\xe1\x85\xcb\x65\xba\x62\xf7\x54\xb4\x54\xcc\xc9\xc5\xc7\xf3\x56\xf4\x0e\x6b\x09\x0e\x33\x67\x0e\xff\xea\xeb\x77\x6b\x5b\xf6\xea\x76\xb8\x10\xfe\xda\x1e\x04\xdc\x3c\xfd\x24\x7d\xe0\xa1\x1d\x3f\xbf\x37\xa4\x76\xe3\x46\x1f\xa0\x0d\x85\xdb\xe1\xf7\xb7\x1b\x40\x56\xf9\x92\x41\xdd\xe2\x6d\xcd\x73\x93\x1c\x99\x07\xfc\x3f\xdd\xf3\xc1\xb2\xae\x73\xfa\xf3\x51\x29\x35\xc5\x39\x59\x7d\x87\x24\xa4\xe7\xf1\x5d\xce\x3e\xfa\x98\xd0\x6a\x2a\x82\x17\xeb\x2e\x91\x18\x5e\x85\x85\xd2\x12\x43\xc8\xc8\x22\xcd\x26\xf4\x95\x03\x71\xd7\x01\x35\x17\x1c\x9a\xf4\xdf\x40\x16\x63\x45\x88\x79\xdd\xe6\x25\x7c\x92\x31\xec\xeb\xaf\x37\xd4\x26\xbe\x0e\xef\x07\xf3\xda\xcc\x9c\x31\xe8\xc4\xc2\xd8\x99\xfb\x0c\xfb\xdf\x2f\x5f\x3c\xb0\x2c\x3e\x3c\x25\x27\xe5\x15\x58\xa3\x1c\x45\xcd\xf3\x33\xc3\x53\x7e\x8b\xb7\x10\x5d\x0f\x99\x11\x5c\x11\x91\x45\xc1\xb8\x87\x11\xa5\xd4\x59\x58\x8d\xb7\xd9\xec\x55\xc5\x9b\x59\xad\x2a\x58\x13\x5c\xc5\x6b\x74\xac\xac\x8a\x97\xb2\x6c\x93\x80\xc9\x57\xe4\xf2\x2b\xa5\xe1\x71\x84\x86\xfb\x8c\x84\x9c\xb0\xeb\x19\x40\xff\x60\xed\xb6\x74\xd4\x92\xea\x01\xf9\x6d\x92\xb3\x22\xa7\xfd\x62\xab\x4f\xb0\x81\x7b\x69\xba\xf4\x94\xd6\x35\xc1\xf3\x16\x75\x2a\x6f\xed\x97\x3d\x1b\x5e\x64\x73\x92\xea\xca\x7b\x7f\x91\x17\xd9\xf2\xb0\x73\xe8\xb7\xdf\xd2\x0b\x0f\xa7\xc5\xe4\x7d\xd1\x3b\xbc\x3b\x5f\x5f\x0a\xd6\xc3\x0a\x41\x3f\x0d\x41\x30\x47\x20\xfd\x2c\x80\xb2\x50\xcd\x1c\xbe\x32\x2f\xb3\x17\x42\xa9\x4e\x19\x88\x20\x97\xb2\x66\x8d\x56\x15\xa4\x09\x42\x7a\x9a\xb1\xd1\x74\x21\xf9\x3a\xae\x88\xc8\xff\x01\xad\x97\x49\x0e\x2c\xf4\xa6\x8a\xfc\x05\x05\x2b\xde\x1a\xdc\x2e\xb7\x79\xe7\xa8\x3e\x2f\xac\xf5\x6d\xad\x60\x67\x9a\xa9\x4d\xf3\xf6\x3d\x03\x67\xaf\x2c\x1a\x14\xab\x7f\x02\xc6\x32\x39\xbd\x3b\x75\xe8\x77\xaa\x5d\x62\xfc\x30\x68\x3f\x72\x04\x9c\x19\x16\x9b\xdc\xee\x54\xbf\x0e\x9d\xa0\x2f\x09\x1c\xa0\xa9\x1c\x44\x03\xa7\x90\xde\x80\x7b\xdf\x21\xce\xe9\xe1\x8b\x74\x32\x0f\x0f\x2f\xb5\x17\xa8\xe4\xbd\x28\x75\x60\x05\xaf\x7e\x35\x68\x48\x28\x6e\x1e\xec\xb2\xe0\x85\x0d\x48\x27\x69\x74\xa1\x16\x3b\xe2\x1d\x48\xc5\x26\x16\xfc\x7b\x8b\x8f\x3f\x98\x15\xd1\x6a\x6b\x8f\xaf\x2e\x2f\x87\xbf\x7c\x7d\xe9\xf9\xcf\xe0\x7b\x30\xb2\x02\x1e\xbc\x0d\x37\x0d\x1f\xb8\xe5\x20\xfb\xb3\x7d\xe8\xf0\x28\xfb\xe5\x2f\x4f\xc3\xef\xd6\x03\xf6\x26\x18\x08\x3e\xbd\x58\xbf\xf2\x1a\x1c\x5d\x3b\xea\x12\xa2\xcd\xf6\x08\xae\x33\x6c\x09\x5a\xf1\x28\x87\x57\x40\x50\x10\xb2\xfa\x82\x82\x18\x99\x4c\x51\x82\xfd\xe3\xc6\xd7\xfc\xe3\xee\x56\xc3\x64\xaf\x24\x69\x28\x8b\x5d\x8a\x60\x64\x9a\x34\x29\x13\x2c\x73\xb6\x3d\xbc\x08\x1f\x7e\xf7\x27\x78\x08\x4e\x7e\x17\x7e\xf4\xc0\xc7\x73\x2b\x93\xde\xea\x55\xb7\xb8\x73\x61\xab\x5c\x5b\x9f\xaa\x2d\x7b\xc0\xe7\x37\x9f\xdf\xfe\x12\x94\x83\x9e\xdf\xf9\xb7\x1a\xba\x6d\xfc\xa0\xd1\xc3\x6b\x5a\x65\x19\x4f\x1a\x17\x0a\xfc\x7d\x29\xe2\xef\xef\x70\x93\x11\x2d\x06\x39\xd4\x9e\x2a\x6f\x55\x05\xef\xa7\xa7\xbd\xbd\x15\xbe\x0a\xc4\x48\x71\x3d\x34\xbb\xdd\xa5\xf6\x18\x70\x09\x5c\x52\x92\x19\x99\x20\x58\xdb\x37\x49\x6d\x62\x17\x26\x06\xc3\xf2\x8e\xe3\x7d\x8d\xce\x91\x6a\xdd\x0a\x7f\xd9\x1a\xd6\xa3\x3d\xbd\x9f\xfe\xea\x0b\xf4\x8d\xc0\x8c\xb0\x69\x73\x19\xbe\xf7\x8c\x88\x90\x44\xff\xa4\x90\xfa\x35\x4c\x75\x7e\x61\x6c\x44\x40\xd0\x37\xdf\x81\x0c\xf8\xc5\x28\x12\xdf\xca\x20\x38\x06\xa0\x75\x93\x23\xfd\x5f\xcf\x49\xe4\x2c\xc5\xe0\x4a\xf4\x9e\x32\x89\x84\x96\x52\xb4\xa8\xf3\x89\xb9\x60\xc2\x49\x37\x13\xa2\xe7\x52\x38\xf4\x6c\xab\x94\x89\xf8\xec\x97\x45\xf0\x7e\x33\x60\x4a\x03\xcd\xfa\x82\x80\x66\x4c\x97\xfa\x6d\x4c\x17\x2f\xa8\x07\xeb\x60\xa5\x1e\x0a\xba\xcd\x35\xb4\x06\xd8\x7e\x0d\xc7\x3d\x7c\x03\x83\x83\x91\x05\x1b\xec\xf5\xbf\x4c\x57\x61\xde\xff\xdb\x70\x6d\x54\x8c\xff\x97\xb5\x5a\x6c\x8b\x56\xfb\xbc\x65\xeb\x39\xe8\x7f\x9a\xa8\xc2\x3b\xd8\x30\x25\xb4\x6c\x26\xfd\x24\xf3\x11\xcd\xc4\x20\xad\x55\x2f\x65\x83\x82\xac\x88\x6c\x34\xde\x0a\xb4\xf5\xbc\x81\x86\xf1\x3e\xd8\x70\x0c\x69\xc7\x8a\x1c\x6f\x87\xc1\xac\x37\xb3\x51\x85\xee\xe6\xd1\x99\xbe\x67\xa3\xb0\x13\xd2\x45\x51\x78\xf9\xc8\xd1\x8e\x4d\x6a\xc0\x46\x11\x71\xc3\x87\xa4\x24\xe2\x5d\x88\xac\x28\x44\x61\x09\x5e\x5c\x62\xe3\x89\xd5\xc2\x35\xf0\xce\x47\xfd\x57\x06\xd1\x1d\x37\x6c\xa9\xa9\xcb\x60\x9f\x81\x98\xee\x39\x93\x76\x0e\x69\x01\x06\x83\xdc\x1f\x6f\xc3\x1b\x9f\xad\xdf\x59\xdd\x79\xd3\x2e\xfa\x83\x63\xf0\xe4\x87\x79\x19\x31\xbd\x2b\xc3\x63\xca\x8a\x82\x42\xe4\x5e\x3a\x0f\x7b\xcf\x4b\xef\x80\xe3\xe0\xf9\x8f\x97\x1e\x3e\xfd\x65\xe2\xa8\xbf\x9a\xc6\xba\x53\xd9\xe4\x8c\xe5\x0b\x34\x37\x13\x77\x1a\x5d\x77\xa4\x5e\x89\x1f\x63\x57\x10\xba\xec\x80\xe8\xe1\x28\xe9\x37\x1a\xef\x30\x33\x92\x12\x1e\x87\x01\xd2\x38\x00\x50\xa9\xd7\x53\x48\xc2\xaa\x95\x9e\x25\xbc\xd2\xf8\x0f\x5e\x57\xe2\x5d\x45\xff\xd1\x44\xd0\x1f\xb2\x7d\x22\x80\x94\xbe\x32\xf3\x5d\x2b\x6d\xb1\x39\xd1\xd6\x1c\x0f\x8e\x86\xc3\x88\x9b\x0f\x90\xe5\xe1\x00\x97\x6d\xcc\xe0\x51\x63\x4e\x59\x7a\xbd\x75\xea\xfc\x69\xd0\x12\x54\x9c\xc2\xcf\x57\xa1\xe7\x4f\x76\x3d\x5f\x83\xc4\x88\xbb\x11\x9e\x0c\xc8\xd0\x93\x65\x46\x80\xa0\x00\x6f\x36\xc2\x23\x61\x73\x58\xcf\x40\x0f\xc5\x6a\x06\x69\x17\x85\x36\xec\x27\x36\x70\xf9\xe6\x03\xb8\x09\x1e\x83\x11\x36\x70\x74\xda\xf2\x70\xe7\x4d\x1b\x6d\xa1\x07\x4c\x60\x06\xa3\x07\xc3\x2f\xe1\xfa\x53\x43\xc6\x9c\xb2\xf5\xea\xe9\x8e\xa1\xdc\x4d\xe2\xb3\xd6\x11\x7c\xfd\x80\xf0\x35\x81\xe0\xeb\x18\xf9\xbc\x04\xe1\xeb\x2c\x89\xb7\x0b\x23\x9f\xbf\x12\x23\x88\x68\xbd\x0e\x8d\x7f\x81\xe0\xf7\xa2\x7c\x1c\x0a\xbd\xd1\x4b\x43\x4b\xd5\x12\xb3\x52\x70\x55\x92\x02\xe8\xd8\x72\x62\x48\x93\x56\x8b\x1e\xbb\xca\x89\x57\x14\x97\xae\xa7\x07\x5d\xcc\xd0\xe8\xce\xfc\x0e\xac\xa0\x7f\xa8\x44\x56\xd4\xfc\x67\xd0\xf3\xfc\xef\x63\xb5\x76\xa6\x76\x45\xbf\x97\xb7\xb9\xdb\x30\x30\xba\xf3\xcc\xde\x4f\xc7\x83\x5f\x5e\x9e\xa0\x47\x94\x6f\xc6\x3a\x51\x37\x1c\x53\xc3\x16\x50\xde\x48\x52\x24\x3a\xcc\x52\xd6\xcb\xcb\xaf\x90\xf7\xd2\x28\x34\x5a\x4d\x21\x2f\xd3\x6a\x59\x95\x99\xb5\x88\x09\x0b\x42\x0f\x46\x7b\x13\xed\xc1\x45\x9e\xb6\x10\xa1\x7a\x8e\x05\x97\x16\x21\xae\x34\x1d\x87\xb9\x9d\x1c\x57\xbf\xd7\xb1\x3b\x96\xc3\xe7\xeb\x8e\xf6\x60\x65\x96\x8f\xc2\x3e\x32\xc2\x2b\xc6\xd1\x61\xa3\x67\xc5\x81\xdc\x3f\x4e\xbd\x80\x3f\xf5\x29\xff\xd9\x91\x54\xb6\x78\xda\x66\x7a\xf4\x3e\x78\x7e\xfb\xec\xd4\x7d\xc7\x07\x0e\x3c\x4e\x1f\xfe\x13\x98\x60\xc3\xa5\xba\x65\xd8\xa1\x36\x91\xb8\xd3\xc4\x18\xaa\x6f\x30\xfe\x40\xce\x2b\xf8\x0c\xc3\xf8\x24\xbd\x12\x57\x90\x5e\x89\xa0\xc0\x07\xa8\x7d\x80\x8f\xbb\x57\x62\x93\xef\x86\xe1\xef\x92\xb1\x3c\xed\xf7\x5f\xc6\x92\x58\x58\xc9\x66\x74\xdf\x70\x32\xb6\x4d\xc3\x27\xd4\x33\x7c\x3a\xad\xd5\x0a\xc7\x84\xee\x31\x75\xee\x31\xff\x18\x43\x86\x7d\xc5\xe8\xb9\x3b\x90\xde\x1b\x42\xb5\x70\xf8\xf8\xa9\xaa\x78\x1f\x9d\x9f\x9f\x51\xe7\x6d\x30\x1a\x2a\x78\x23\xa3\xd3\x51\xd2\x2a\x9e\x45\x3c\x61\xbf\x5c\x9d\xc3\xe2\x40\xf0\x84\x28\x51\xe7\x14\xdd\x07\xba\x54\x21\x2a\x41\x3c\x18\x11\x7a\x0c\x63\xa7\x25\x0e\xe3\x70\x69\xc8\x06\x35\xa0\x19\xd5\xb8\xc9\x8a\x1b\x9c\x7f\x60\x50\x74\x62\x7c\xf3\x21\x6b\x26\xc0\xbf\xaf\xc2\x87\xd1\x4c\x7e\x34\x3c\x9b\x56\x72\x2c\x7f\xc2\x38\xbd\xaa\x8b\x61\xf4\x8c\xb6\x69\x91\x65\x80\x4e\x48\x8d\x73\x38\x27\xb1\x55\x77\xee\xc0\x1f\xa3\xd2\x46\x4e\xef\x58\x9d\x0b\x5b\x0b\x78\x26\xf1\xc9\x92\x2d\xba\x30\x26\x8b\xcc\x6d\x24\xf5\x19\xf5\x1c\xcf\x5f\x22\x11\xa6\x86\xe6\x25\xe2\x9e\xf2\xa5\xba\x39\x52\xbd\x29\x24\xa2\xbd\x41\x85\x77\x83\x37\x5d\xe1\x3d\xd8\xfb\x91\x37\x13\xe9\x9d\xe6\x4d\xe3\x78\x1d\x39\xe7\xed\x2d\xd3\x68\xbc\x2a\xf8\x40\x3d\xd0\x6b\x58\x4a\x82\xde\x92\xc8\x64\x6c\x05\xb6\x4c\x33\xc5\x78\x15\xa4\x7a\x94\xbf\x92\xbd\x30\x74\x18\x89\x0a\x26\x4a\x33\x47\x0b\x9d\xa1\x74\x96\x20\x3d\x39\x32\xc2\x89\x0c\x93\xd9\x9a\x9a\x4d\xe3\x81\xf4\x2a\x9c\x7a\xef\x81\xf7\x2c\x3a\x19\x8c\x8a\x85\xb7\x65\xdd\x3b\x3c\xec\x05\x66\xc7\xd0\xcd\x3b\xce\x5a\xf8\x2c\x11\x76\x7d\xf8\xeb\x80\xf1\xf4\x1e\x38\xae\x75\xcd\x08\xb8\xfd\x8e\x30\x3f\x16\xc1\xfe\x25\xd9\x87\xc9\xd4\x3f\xc5\x04\xff\x5f\xe3\x03\x31\xff\x5b\x41\xbe\x17\x43\xfc\xcf\xab\x1b\x1e\xe3\xfd\x8f\x6c\x9c\x10\x2a\xd9\xe1\xaf\x0b\x40\x0a\xb7\x0e\x68\x68\x46\xc3\x54\xf1\x5a\x0d\x23\x55\x54\xf2\x52\x3d\x08\xac\xe6\x81\x8e\x7a\xb5\x47\xa2\xab\x8f\xaf\x05\xb7\x11\x72\x77\x74\x20\xdb\x5b\x94\x5e\x7a\x77\xe0\x29\xbd\xfd\xea\xcf\xb3\xf6\xa4\x7f\x3a\x3f\xcd\x2f\x5a\x15\x66\xcf\xb7\x5e\xa3\x93\xfb\x28\xd7\x1e\x98\xf5\xc7\x92\xa2\xd6\xda\x4e\xa6\x36\x7d\x93\xd9\xc1\xce\x16\x0f\xcf\x6a\x6f\x4b\x6b\xe7\x30\xfd\x9c\x0f\xb7\x2c\x9c\xf6\xe7\x74\x70\xb5\x43\x07\x58\xd4\x61\xae\x90\x83\x86\x50\xc1\x6e\x43\xb0\x1a\x28\x7f\x6c\x71\xfb\xd0\x8c\x07\x53\xcd\x2b\x64\x1e\x1e\xc0\x53\xc2\x00\xdf\x6a\x9e\x25\x21\xa4\xae\xee\xe1\xee\xe6\xe1\x04\x42\xdc\x36\xc8\x4e\xc2\x47\x89\xe6\xed\x82\x2d\x99\x9e\x7c\x61\xcc\xed\x31\xf7\x80\xe4\x5e\x9f\xdb\x7d\xee\xf5\x51\x7d\x78\x28\xff\xed\x53\x5f\x97\x76\x56\x16\xea\x47\x4f\xa0\x07\x38\x97\x0a\x39\x1c\xce\x87\xeb\x16\x57\x7f\xb5\x30\x0f\x9c\x6b\x57\x0a\x7b\x91\x5e\x8b\x43\x11\x3c\x3b\x11\x3c\xb8\x9f\xba\x9e\x32\x79\x9b\x2a\x78\x56\x5b\xc5\x03\x96\xf5\xf4\x66\x0c\x9e\x24\x9a\x95\x58\x88\xae\x60\x56\x77\xb4\x50\x88\x18\x4d\xe4\xda\x12\xf4\xfc\xd4\xd2\x23\x1d\x26\x8c\x37\x54\xc1\x32\x6d\x7c\xf3\xf1\x4b\xc7\xb9\xf7\x01\x5b\x05\xaf\xc6\x34\xaf\x9d\x91\xd7\x1b\x2a\xc0\x25\x3e\x3a\x35\x2e\xd7\x39\x13\x6f\x01\xca\x15\xe3\xce\xb5\x21\x74\xff\xad\x48\xf7\xbb\x04\xba\xd7\xeb\xdd\xfb\x1e\xc7\x35\xdf\xc1\xbc\x81\x39\xf9\x2a\x6f\x68\x1c\xd3\xf0\x33\xb2\x35\x2b\x24\xdb\xd0\x98\x1f\xf0\x18\x8f\x7b\x54\x0a\x75\x4f\x88\xd2\x74\xef\x1f\xdc\x77\xfa\x26\x39\x8f\xf4\x77\xa8\xe4\x66\x29\xc3\x48\x38\x9a\xab\xe4\x3d\x69\x1d\xd5\xd4\x99\x09\xf4\x62\x96\x0c\xfa\x0d\x62\x4b\xe0\x3a\x6c\xf9\x5e\x06\x35\x97\xc9\xa9\xc0\xfa\x12\xd8\x05\xa0\x65\x7c\xb9\x8b\x2d\x7a\x71\x08\x76\xa1\xde\xcc\x3f\x10\x73\x2e\xae\x90\x98\x76\x2f\x64\x65\x19\x24\xda\x0a\x5e\x22\x01\x34\xcd\x55\xf0\x34\x03\x74\x15\x8d\xe4\xe8\x3e\x26\x8e\x00\xc2\x09\x25\xf1\x96\xb1\xfa\x44\x17\xe9\x45\x38\xff\x0d\x24\xcc\xde\x68\x67\x6d\x3a\x00\x17\xcf\x2d\x87\x0f\xc6\xff\xf5\x41\xf6\x9e\x9a\x59\x6d\xb8\xac\xdb\xf0\xdc\x86\xc5\xf3\xfe\xac\x03\x5f\xce\x83\xcb\x13\x06\x50\x6f\xe6\x3e\xb8\x78\x0b\xbe\xc6\xbc\x05\xd1\x61\x57\xd8\x97\x5d\x83\x60\x53\x21\xa9\x6d\x71\x68\x95\x68\xcd\x95\x8c\x91\xf2\xe0\x3c\xaa\x78\x4e\x27\xc1\x55\x3c\xdc\x76\x14\x6e\x24\xca\x08\xbd\x8c\xec\xc9\x3a\x7c\x2a\x81\x5b\xa7\xd1\x52\xe6\xf8\xae\x71\x8f\x0b\x9c\x8e\x82\xc7\xe3\x26\x55\x2d\x68\xb1\x86\x9e\x0a\x9b\xed\x3a\x5a\xd9\x6c\x4c\xe9\x4d\xe7\x2c\xb0\x02\xf6\xa5\x47\x0f\x06\x96\x93\xb4\xf2\xe5\x2a\x66\x3a\xdc\xbb\x03\xde\x1f\xf6\x66\xce\x03\x92\xbf\xab\xd1\xfa\x97\x13\x5e\xdd\xc6\x11\x19\x1c\xe8\x27\x65\x81\x06\x54\xf3\xfa\x0a\xcd\x24\xcd\x42\x0d\xa3\xd6\xc4\x69\x32\xd1\x4b\x16\x5f\xd1\x1a\x8d\x49\x2b\x67\x02\x24\x42\x6c\x3c\xe9\x0b\x81\x98\x96\x3b\xc0\x19\x1f\xa8\x20\x9e\x0d\x2c\x20\x16\xd8\x48\xeb\x10\xdc\xd3\xcf\xed\x99\x46\x93\x40\xbb\x9c\x01\x0b\x86\x70\x71\x12\xf8\x63\x03\x05\x66\x05\xc6\x78\x84\x3d\x36\x2b\x9a\xd9\x07\xdf\x18\x9c\x51\x99\xbc\xec\xf1\x41\xdb\x5b\xb1\xc3\x1a\xa8\x0c\x69\xb2\x74\x08\xdd\x5a\x27\x71\x6e\xa6\xbf\x8d\x98\x5d\x08\xc6\xc0\x13\x53\x07\x6a\xe9\x74\xe7\x57\xba\xb1\xb5\x20\x0d\xce\x2c\x9a\x15\xe1\x4c\xa6\xbb\xb1\x06\x27\x89\xa7\x6c\x78\x86\xf8\xd2\xc7\x1c\x4f\x45\x50\x55\x8e\x8c\x10\x8d\x5a\xa3\xae\xe0\xcf\x68\x80\x59\x13\xa5\x59\xa5\xf9\x40\xc3\x16\x68\x40\x81\xa6\x42\x73\x03\x69\x66\x1a\x0d\x65\x20\x02\x50\xc1\xf9\xf8\xfb\x9b\xaa\x78\x7f\x96\x92\x56\xf0\x39\x2c\x48\x63\x81\x20\x8e\xc4\x3c\x32\x81\x4f\x97\x93\x04\xc0\xf2\xa1\xe5\x8d\x81\xb4\x61\x36\x6b\x80\xd8\x33\x38\x8c\x34\xeb\x4f\x7e\xd5\x30\x17\x3a\x0b\x4b\x58\xf0\xe4\x46\x43\x20\xf0\xd5\x4f\x1f\x55\x3a\x25\x77\xf1\x8a\xac\xe8\xac\x2d\x9b\x7b\xf1\xa7\x46\x36\x50\x55\x20\xf3\xdc\xf1\xa7\x1f\x6f\x9e\x30\x7b\x03\xfc\xc5\xf0\xe9\x8e\xf2\xe1\x03\x52\x6a\x5a\xe4\x64\xdf\x1e\xf1\x96\x23\xf7\x7a\xcb\x83\x5f\x6c\x9c\x51\x77\x2e\xdc\x30\xad\x7a\xf4\x75\x5c\x83\x4e\xd8\x83\x84\x9e\xcd\x0e\x85\x42\x2a\xa1\x01\xa3\x94\x79\x70\x62\x96\x02\x49\x56\x22\x5d\xc3\x70\xc0\x18\xee\x93\xaf\x4f\x46\x4c\x17\xed\x1b\x30\xc5\x9c\x43\x17\x83\x22\xb4\x71\x1a\xea\x34\x85\xce\xcf\x10\x37\xaa\x9c\x75\x97\x55\xbe\x38\x44\x2f\x2a\x00\xfa\x7a\x55\x63\xee\xc2\x1d\xb2\x7f\x4f\x8a\xfb\x37\x46\xd8\xbf\x2a\x55\xe3\xfe\xc5\xbc\x02\xc1\xa0\xc3\x11\xb5\x4a\x4f\x44\x0f\x48\x04\xd2\x93\x68\xf4\x4f\x2b\xd7\x71\x24\x27\x07\x67\xbe\x0d\x75\x45\x41\x59\x98\x04\xb3\x10\xca\x0b\x84\xb5\xb7\x00\x1b\x08\xeb\x3f\xf1\xe4\xbf\x40\x33\x78\xba\xf9\xc2\x00\x90\x04\xf7\xdf\x32\xe5\x9a\x07\xc3\xab\x08\xae\x9f\xa8\x06\x10\x06\x67\xb7\x9d\xad\x77\xea\xe8\x32\xa5\xc1\x79\x42\xb0\x87\xde\x47\x32\xe6\x2e\xe1\xdb\x7e\x0e\x95\x41\xa7\x45\x26\xb2\x96\x91\xc8\x2b\x79\x49\x93\x1c\x32\xd2\x24\xc7\x13\xb8\x8a\xb5\x65\xd0\xe4\x80\x91\x59\xf9\xfd\xb8\xde\xeb\x0e\xcc\xca\xf1\x8b\x57\x05\xc5\xb4\xc9\x29\x4b\x7b\x9f\x7e\x8c\x70\x71\x87\x2d\x82\x33\xe0\x49\x78\x7e\xb2\xf6\x6f\x69\x8b\xe9\xbf\xee\x03\x7f\xbf\x38\xf4\x86\x7e\xfa\x7a\x0e\xd0\xff\xcc\x1f\x31\x39\xe4\x42\xfe\x88\x3b\x09\xf0\xff\x94\x39\xf2\x7a\xde\xc8\x9b\x3a\xf3\xab\x39\x1e\x08\x1f\x84\xd7\xa2\x67\x6a\xa9\x0c\x87\xed\xa9\x02\x30\x17\x14\x77\x14\xf4\x36\x05\x98\xa6\x58\xaa\xa0\x29\x85\x46\x41\xcb\x58\x64\x6e\x31\x94\xd2\x93\xa1\x70\xc6\x94\xa0\x63\x11\xb1\x66\x4a\xc5\x24\x8d\x73\x67\x48\x27\x43\x51\xe6\x92\x36\xc1\x68\xa1\xce\xe6\xcc\x0c\x9e\x52\x90\x93\x33\xb8\x23\xdc\x06\xec\x3f\x81\xa9\x20\xca\xd9\x7d\xd2\x8f\x86\x50\xef\xbf\x22\x2b\x46\x32\xe3\x9d\x63\xe8\x99\x2f\xff\xf3\xc5\x22\x02\x97\x98\x5b\x82\xf8\x5a\x17\x17\x0f\x7e\x25\x57\x03\xf3\xfb\x8f\x5c\xfc\x1e\x71\x7b\x19\xe1\xf6\x00\x71\xfb\xa6\xd1\x2b\x4d\xf8\x3d\x63\x67\x18\x53\x49\xfd\x01\x81\xdf\x67\x20\x7e\x7f\xf9\xc0\x94\x46\x6e\xff\x72\x97\xf3\x2d\x7c\xdf\x11\x22\xce\x8d\x24\x67\x87\xd5\xb0\x55\xbc\x4e\xa3\xd1\xcb\x18\xc1\xf1\xe7\xce\xfe\x68\x3c\xde\x75\x87\x51\xe1\x53\xdd\x8f\x2a\x72\x4e\x94\xc3\x33\xfa\x2e\xc0\xaf\x44\xd9\xbe\x70\x55\xdf\xa9\x58\xae\x80\xfb\xe6\x50\x10\xd7\xb1\x02\x7c\x01\x4b\x5a\x25\x15\x77\xb4\xd0\xeb\x49\x5e\x0f\xc2\xf7\x63\x34\x2f\x2d\x99\x87\xaf\x43\x21\xe3\x00\x23\x65\x28\xa4\xdd\x34\xa6\xef\xd8\xed\x42\x57\x41\xa2\x1e\xe8\xed\x88\x83\x4a\x9e\x5c\xdd\x72\xf5\x37\xf4\xf3\x04\xbe\x40\xc0\xaf\x62\x7b\xe1\x1f\x72\x43\x74\x3f\xd8\x85\xdc\x4f\x8d\x63\x53\x55\x66\x7c\x47\xb9\x70\x4b\x35\x21\x1c\xf7\xc1\x54\xe6\x2b\xb7\x65\xb0\x20\x68\x7a\xeb\xeb\x5d\xc7\x5d\x2f\x69\xbc\xfb\xcb\x99\xce\xb9\x60\x1b\x92\x7d\xc3\xc9\x59\x09\xe6\x15\x26\x6c\x15\x2a\x75\x08\x56\xa5\x46\x49\x2b\x19\xa5\xd2\x43\x2e\x97\x55\xf0\x72\xc6\x43\x5f\xc5\x7b\xbc\x91\x42\x8b\xf5\x4f\x41\xfc\x85\x10\xc5\x82\x69\x4c\xfd\xa1\x3f\xbd\xf3\xef\x8d\xf0\xf2\x31\xb8\xf0\x6a\x03\x15\x4d\xdb\xde\x02\xdc\xc0\x61\x85\xf9\x05\x95\x33\x72\x98\xec\x5d\xab\x67\x3d\x9e\x8a\x94\x0a\x08\xe0\xfc\x9c\x62\x38\x38\xa3\x16\xd7\x64\xba\x87\xf0\x66\x26\xf9\x4f\x46\xac\x1f\x3a\x74\xb4\xa6\x9a\xa7\x69\xca\xa4\x50\x68\x91\xde\xa5\xf3\x16\x38\x46\x93\x0e\xff\x8d\xea\x55\x88\x05\xb8\x04\x30\x40\x38\xf8\xfd\x45\x9f\x64\xa2\x58\x8d\x87\x8f\xe9\x56\xef\x26\x15\xa6\x77\x7c\xcb\x0e\xfe\x78\x01\x24\x2f\xb0\x7a\x25\xaa\x56\x3f\x2f\x82\xbd\x5a\xcf\x82\x48\x0f\x20\x3a\x00\x96\x75\xf3\xc9\xba\xe9\xa9\x18\x87\x1f\x8b\x44\x02\x85\xa8\xa5\x8e\x5d\xc4\xee\x66\x39\x25\xc3\xb2\xc8\x80\x00\x9a\x46\x5d\x40\xe8\x4e\x2b\xaa\x02\x02\x24\x6e\x45\x20\x99\x96\x43\x23\x26\xcc\x5e\x57\xaf\x3f\x7c\x0f\x5e\x59\xfa\x7c\x47\xce\xde\xd5\xab\xd0\xd3\xff\xde\xbc\x72\xf6\x93\x29\xe0\xe4\x62\x38\x7f\x22\xa1\xfb\x40\xb4\x7f\xf7\x12\x3b\xa1\xbb\x23\x0d\x60\x3b\x01\x80\x0a\xd0\x00\xe8\x0a\x30\x18\x3c\x02\x4c\x24\x48\x43\x0f\x46\x6f\xca\x39\x00\x74\x72\x1d\xd2\xfb\x28\x23\x90\x1b\x75\x7a\xb5\x07\x12\x4a\x68\x89\x90\x96\x22\x67\x9b\x1a\x0a\x3d\xfe\xc9\x52\x40\x06\xbb\x86\x64\x9f\x23\x23\x01\x07\x6e\xb3\x21\x41\x8c\x55\xd8\xce\x67\x62\xc0\x6c\xe6\xfb\x0e\x33\x92\xa0\xf3\x2b\x30\x12\x9c\xee\x7f\x04\x3e\xdd\x01\xa7\xd8\x81\xd9\x6f\xd3\x98\x3d\x09\x74\xf3\x3b\xed\x80\x7a\xe8\xa0\xd6\x60\x3a\x4c\xdf\x00\x27\xc3\x86\x99\x60\x6b\xe2\xb3\x03\x3b\x89\x7e\x82\x7b\x6b\x7e\x87\xe0\x47\xda\x09\x55\xe8\x48\x35\xa2\x55\x53\x1b\x33\x8d\x83\x8d\x6b\x8d\x8f\x8c\x9c\xda\x18\x88\x2e\x0a\x8c\x0b\xd1\xe5\x51\xe3\x77\xe8\xad\x06\xa3\xa7\x86\x31\x1a\xb5\x7a\x46\xab\xf3\x44\x06\x80\xa7\x9e\xf1\xae\xe6\x19\xb6\x91\x39\x8b\x98\x25\x59\x8f\xbe\x40\x0c\x33\x17\xbc\x56\x82\x62\x6d\x6d\x12\xa3\x00\xce\xe4\x38\xb7\x00\xaf\x6e\x4b\xbe\xac\x9d\x33\x47\xf7\xd6\xb0\xfb\x40\x72\x7f\x08\x3d\xa9\x34\xbb\x7f\xaf\xe2\xac\x61\xd5\x8c\x04\x44\x81\x08\x38\xf1\x1d\xf8\x16\xbc\xbe\xfc\xec\x91\xca\x5a\x27\x62\x32\xce\xcf\x1f\x6e\x3c\x03\x03\x16\x6c\xbf\x0b\xee\xe2\x39\xac\x10\x79\x04\x8e\x89\x8f\x75\x78\x03\xa5\x4e\x89\x73\xc6\x81\x1a\x9b\x9f\x32\x99\x1e\x59\x62\x8c\xdc\xc5\xa6\x1b\x73\x27\x48\x0e\x9e\x2b\x5b\x02\x8b\xd1\x10\xa0\x37\x88\xa9\x6d\x7d\xc1\xd9\xbe\x43\x16\x01\xe5\xd7\xe0\x0f\xec\x9c\xea\xb9\x13\x8e\xbd\x70\x6d\x77\xfb\xad\xfd\xa7\xb4\xa2\xb3\x82\x17\xf7\x9b\x75\xbf\x16\x09\x55\xc6\xe9\x64\xc6\x2e\x01\xa3\x13\x07\x12\x1e\x89\xf3\x50\x8a\xc8\x79\x52\x5b\x42\x93\x15\x88\x77\xd3\xdc\x75\xb4\x27\x42\xa9\x54\x87\x25\x44\x69\x50\x32\x85\xfc\x3a\x25\x88\x57\x3a\xd0\x0e\x55\x1a\xfc\xd5\x7e\x99\x7e\xb4\x9c\xf1\x33\xc8\x0a\x79\x83\x70\x0a\x81\x61\x23\x9d\xec\x87\xba\x0e\x21\x1a\x4b\x24\x64\x00\x46\x08\xaf\xc0\x9c\xce\x17\x44\x83\x14\xa9\x84\x55\xd1\x52\x1d\x53\x5d\xdc\xb5\xcf\xbc\x8e\x1f\xd6\xcc\x6a\x5f\x0a\x26\x75\xd9\xf2\x64\x15\xec\x51\xb3\x17\x78\x82\x39\x4f\x63\xff\x82\x1f\xaf\xee\xdd\x2e\x60\x2d\x3d\xb9\xaa\x72\xf4\x83\x9a\x6f\xc6\xfc\x07\xdc\x85\xeb\x67\xc2\xdf\x8f\x54\x80\xf5\x2b\xc1\x7a\xa0\x59\x9f\x6b\xfe\xcd\xbb\x55\x76\xdf\x75\x53\x71\x74\x24\x43\xe4\xdc\x1c\x12\x4b\x8e\x2d\xbd\x96\x8e\x10\xce\xec\x63\xf6\x29\xe2\x2b\xcd\x43\xcc\xb4\xda\x1c\x68\xa6\x35\x8c\xd9\xac\x52\xab\x7d\x8b\x78\xb5\x5a\xa5\x29\xe2\x55\x6f\x9c\x79\xb9\xa1\x0f\x22\xd5\xc2\xb1\x25\x83\x19\x8d\xb9\x51\x93\xd2\x33\xe2\xcb\x10\xfa\x36\xd8\xf2\xee\x02\x70\x4f\x12\x08\xff\xfc\xc9\x79\xef\x7c\xff\x43\xfd\x87\x27\xd6\x8c\xda\xdd\x29\x61\x6b\xd5\xc0\x98\xae\x3d\xd9\xb4\x6b\x03\x56\xfb\x48\xfd\x3e\xf0\x09\x78\x6f\x15\x9b\x56\x5f\x1b\x51\x96\x92\x61\x07\xbb\x61\x7d\x68\x51\x8c\x3d\x8e\xec\xc3\x39\x62\xfc\xbb\x90\x73\x5c\xc8\x73\x6a\xd2\x2f\xdd\x95\x73\xac\x67\x97\x59\x9d\xbf\xec\x24\xfd\xff\x8f\xd4\x4f\x63\x49\xff\x86\x52\xa4\x9b\xd7\xa2\x97\x58\x84\x5b\x0f\x28\x40\x21\xaf\x50\x6b\x70\x5f\x7d\x87\x4c\xc5\x20\x0d\x1d\xdd\xa5\x89\xeb\x40\x08\x58\xa5\xa5\x16\x4e\xd0\xcf\x89\x08\x0b\xd1\x33\x19\x3b\xd6\x2d\x02\x9d\x9c\x77\x0a\x9e\x8f\x98\x50\x71\x6c\x20\xbd\x61\xe7\x92\x11\xcf\x0b\x98\xf1\x50\xf6\xf5\x11\xa4\x9a\x97\x0e\x07\x07\x41\x51\xfd\x34\xe7\x76\xb0\x02\xd1\x48\x27\xf7\x99\x63\x0e\x91\x0f\xef\x22\xbe\x19\x85\x60\xb0\x50\x29\x0e\x24\xb9\x7c\xfc\x02\x39\x44\xc7\x45\xbc\x76\x92\x6a\xa1\x8a\x3e\xa4\x3a\xa5\xa2\x55\x2a\xd6\xa8\xf6\x54\x5b\xcc\xf8\x1c\x55\xec\x00\x13\x57\x4e\x6a\x0d\x98\x48\x00\x71\x1c\x66\x9b\x44\x0d\x37\xe1\x18\x50\x06\xc7\x5d\x11\x25\x9c\x98\xda\x68\xcf\x3d\xf6\xf1\x51\xc2\x1b\x7f\x83\xe1\xa6\x18\x79\xce\xb3\xf0\xe0\xf2\xd2\x0b\xa5\x3d\x86\x4e\x7b\x76\x32\xa8\x93\xff\xe2\xbf\xab\xd4\x01\xbe\xdd\x2f\x80\xab\x6a\x09\xd4\xd2\x59\xa6\xea\x66\x20\xef\xe1\x29\x16\x7c\x06\xdb\xb2\xa7\x1e\xc2\xfd\x89\x55\x46\xe7\x21\xf0\x88\xd3\xc0\x30\x84\xe7\x66\x08\xfe\x4a\x36\x1f\x59\x14\x79\x8e\x68\x8b\x4a\xa9\x52\x16\xf1\x04\x54\x95\x8a\x8a\x33\x01\xb3\x09\x30\x6a\xd3\x60\x13\x2d\xe3\x4c\x66\xb3\xb1\x88\x37\x6b\x28\x69\x21\xcf\xba\x43\xd3\x45\x36\x57\x21\x68\xda\x4d\xb5\x6c\x77\x6f\xf4\x90\x14\x91\x2e\xb0\x2b\xc6\xa5\x63\x1b\x45\x25\xfb\xc6\xb9\xf3\x8a\x17\x6c\x6d\x8f\x41\x73\x17\x7c\x18\x3c\x6d\x55\xc7\x4e\x3d\x2e\xc5\xff\x9a\x04\x7c\x7f\x38\x74\x69\xe5\xd2\x81\x13\xe7\x42\xa7\x61\xfd\xdb\xd1\x1d\xba\x96\x17\xb5\xc9\xd8\x13\x96\x9f\x1c\xdd\x72\x91\xd7\xdb\x2b\x27\x0e\xee\xb7\x31\x80\x96\x8f\x28\xed\xb9\xb7\x07\xe5\xd6\xe5\x76\x20\xbc\xab\x28\xdd\x01\x05\x2b\x35\xca\x39\xd2\x10\x2c\x41\x68\x3a\xc9\x08\x6a\x2c\xd2\xac\x89\xb6\xf4\x9f\xee\x92\x14\x35\x9d\x01\xfc\xcf\xc3\xfa\x7e\xa6\x70\xe7\x77\xf0\x02\xa2\x23\x18\x6a\x3d\x1b\x4d\xbf\x7c\x79\x82\xf6\x1b\x30\xdc\xc9\xa1\x9b\x89\x3a\xe4\x47\xdc\x97\x48\xb7\xfe\x15\xc7\x7d\x22\xdd\x9a\xc4\x7d\xaa\xd5\xee\xb8\x4f\x51\x8f\x24\xf9\x31\x81\x0e\xb5\xd2\x53\x4d\xab\x0b\x91\xa8\xd4\xc8\x8d\x12\x02\x03\xd6\x6a\x44\xad\x1a\xd1\x98\xe0\x9e\xc6\x8a\x3e\x23\x41\x4a\xf5\x9f\xc0\xb7\xb4\xf7\xf8\x2e\xe7\x41\x00\xfc\x36\x27\x1f\x28\xe1\xf9\x93\x45\xed\x4b\xe1\x3d\x04\x4e\xdb\xdc\x81\x80\x83\x53\xbb\xc6\x3b\x4f\x81\x4b\x3e\xb0\x0d\xa1\xaf\xad\xf8\x7c\x8e\xe4\xe0\xf9\x39\xd4\x5a\xb4\x31\xb4\x6a\xa9\xb2\x90\xf7\x94\x0a\xfd\xec\x5d\x11\x5c\x16\x9c\xb5\xd0\x24\xd8\x0d\x53\x37\x7d\x6c\xe7\x5f\xd3\x46\xf7\x19\x5b\x66\xad\xd0\x5b\x7d\x22\xd2\x0a\x47\xad\xa7\x5f\x9e\x47\x84\x3d\x14\x5e\x5e\xde\xca\x83\x3b\x2a\x1b\x04\x92\xc1\xfd\x97\x27\xf0\x73\x90\x2e\xcd\xfe\x80\x9e\x83\x63\xb4\xd4\xde\x3a\xad\x8c\xf6\x50\x1b\xf4\x4a\x09\xa0\xa4\x84\x6a\xed\xa4\xbf\xa5\x68\x39\x22\xba\xa4\xb1\xa1\xab\x37\x19\xa4\x29\xe2\x19\x2f\x32\x1d\xe9\x9e\x9f\xa7\xd2\x4a\xc5\xcc\xb3\xe7\x41\xbb\x50\xda\xd3\x27\xd1\xfa\x04\xb4\x3a\x7f\xb6\x8e\x8b\xd6\x33\x6f\x07\xf7\x2f\x74\xb6\x67\xd3\x9c\xb7\xb3\x26\x8d\xce\x5d\x57\x4c\xfb\x23\xbc\x2f\xf1\xdd\xe6\x68\xb2\x96\x72\x6c\xab\x30\xac\x8c\x45\xf3\x9b\x24\x5b\x28\xa3\x65\x48\xdd\x32\x7a\xb8\x91\x5a\xee\xce\x14\x26\x7a\x3a\xf9\x61\x77\x9c\x87\xf7\xba\xc1\x71\xdd\x10\x6b\x00\xbe\x25\x60\x7a\x09\x9b\xf6\xf2\x04\xf8\x0e\x36\x43\x18\xed\x04\x76\xfc\x53\x8e\x88\xeb\x79\x52\x7c\x8e\xcd\xb0\x52\x16\x47\x46\xab\x39\x31\xe5\xe6\xd5\x67\x90\xfb\xef\x84\xe3\x04\xd6\xf3\xf2\x04\xee\x70\x8d\xb9\x0f\xd6\xa1\x7f\x44\x3a\x73\x1d\x8b\x74\x6a\xaa\xe4\xd5\xda\x3b\xd8\x1f\x81\x63\x6d\xd0\x73\xbe\x26\xcf\x41\xba\x28\xc7\x1a\x25\x8c\x14\x6f\xa6\xa6\xa1\x98\x24\x02\x93\xcc\xe5\x32\xf3\xd8\x0a\x97\xed\xc4\x0f\x5b\x46\x78\x1c\x33\x1e\x3f\xe3\x12\xd2\x3f\xd5\x24\x57\xaa\x3b\x89\x39\x0e\x46\xcf\xfc\x80\xc3\x75\x9f\xfc\x90\x54\x8a\x73\xa0\xa5\xa2\x02\x19\x0d\x53\xc4\xeb\x35\x9a\x20\xda\x83\x46\x5b\xd6\xc3\xcb\x4f\x6a\x76\xcf\xc5\xbb\xa9\xf6\x6e\x30\xe9\x55\xb4\x19\xb8\xa2\xf6\xf5\xb8\xbb\x36\xf1\x4d\x23\xed\xd1\xc6\x64\x30\x40\xb7\xf1\xed\xbe\x33\xdb\x35\x2b\xdc\xfd\x79\xd1\xca\xab\xd3\xf2\xbe\xcb\xdb\x73\x2c\x7f\xed\xd5\x29\x85\x60\xfb\xfb\x6f\xe7\x0e\x2f\x8a\x04\xab\xd1\x9e\xf9\xd3\x77\xf1\xbf\xea\x4b\xc1\xbb\xda\x4b\x7b\xc6\x02\x70\xbc\x56\x05\xa6\xc0\x89\xfa\xef\xf7\x8e\x69\x38\x3d\x42\x01\xfb\xb0\x1d\x4e\x46\x3a\x95\xba\xee\x4b\x3e\x17\xf0\x74\x12\x9f\x63\x90\x39\x94\x11\xbc\x04\x23\xbe\x3d\x9f\xac\x77\xf0\x1e\x99\x27\xe6\xd7\x0a\x0e\xa8\xb1\x56\x8d\x53\x64\x8d\x4d\xf2\x62\xb1\x99\xac\x77\x99\x1b\x21\xfa\x60\xb4\xc4\x3b\x41\xaf\x9d\xe8\x37\xe6\xd1\x48\x94\x4c\xc3\xeb\x81\x59\x33\x89\xc7\x12\xd7\x95\xd8\x1a\x0a\x35\xab\x2e\xc6\xce\x6e\x4f\x17\x05\x35\xc9\x34\x97\xba\x32\xb6\x2c\x7a\xb1\xf4\x6b\x8a\x1e\x3c\xce\xe3\xa6\xa7\x0d\xe8\x5b\x09\x7c\xce\xc3\xfb\x45\x65\x1b\x57\x4f\xac\x93\x75\x46\x54\x34\x31\x66\xb0\xc6\x1f\x3c\x41\x54\xb5\x36\xa0\xf9\x98\x81\xe1\x31\xe0\x63\xc1\xd6\x40\xbc\x81\xbd\x4f\xe6\x21\xd8\x1a\x64\x0a\x45\x4d\xfa\x83\x13\x5b\x43\xdf\x68\x14\xf8\x9e\xbf\xb6\xeb\xcc\xae\x6b\xbb\xce\xee\xba\x86\x88\xa9\x7e\x1c\x33\x1d\xff\xa0\x0d\x88\xee\x85\x70\x72\x9f\xc8\xec\xd0\x4f\x28\x15\x42\x89\x0a\xdf\x50\x2e\xdc\x51\xed\x46\x8a\xdb\xd4\xd0\xbf\x6a\x6a\x34\xb9\xf3\xae\xac\x61\x17\x0b\x1a\xef\x5e\x3f\xce\xf9\x11\x46\x0f\x8e\x07\x45\xf0\x8e\x41\xcf\xc0\xb6\x46\x9a\x23\x58\x69\x42\x77\x56\x06\x2a\x69\x0d\xb1\x38\xc2\xb0\xc5\xa1\x40\x26\x07\x5a\x04\xb5\x87\xaa\x88\xf7\x30\x36\xe6\xdd\x88\x75\x95\x1a\xad\x0e\xc4\x6b\x88\xd5\x21\x6f\x54\x08\xe8\x6b\xe7\xce\x4c\xf8\x73\x3b\x2c\xda\x09\x1f\x59\xe9\xa8\x4e\xdd\xbb\x56\x8d\x4b\xe9\x39\x82\xa7\x67\x0c\x9b\x38\xe2\x48\x4f\x66\xfc\x11\xd8\x01\xda\x62\x2b\x13\x9b\xe3\x12\x13\xc8\xe6\x70\xf1\x1c\x05\x92\x2e\xbe\x54\x92\x23\x50\xe1\x55\x24\x74\xc8\xd3\x10\xc3\x38\x8c\x51\x28\x64\xde\x9e\x6a\x93\x4c\x86\xa4\x94\xac\x11\xad\x82\x86\xda\x04\x18\xda\xd5\xdd\x57\x04\x85\xd4\x30\x5a\xb3\x77\xb7\x63\xe4\xae\xb1\xf0\xca\xf9\xa7\x9d\xba\x07\x75\xea\x1e\xde\xbe\x93\x05\xec\x3b\x0f\xb8\xf3\xf4\xcc\x21\x63\x4a\x36\x0d\x4c\x43\x8b\xdb\x11\x86\xc5\x0e\x6e\x66\x8f\x82\x36\xbc\xbb\x29\xb7\x2d\x52\x4a\xd6\xd5\x48\x35\x73\xf8\xcb\x91\x18\x54\xcb\x03\xe5\x08\x2a\xb9\x46\x8e\xa0\x92\xcb\x3d\x3c\x65\x6a\x0f\x45\x23\x8a\xde\x84\x88\xa0\xa7\x29\x72\x76\x7d\x7f\x69\xca\x7f\xb6\x39\xff\x40\x24\xdc\xa9\xfb\xa1\xea\x89\x2d\x6a\x46\x7e\x46\xcf\x18\x31\x69\xf8\x67\x48\x3f\x22\x88\x29\x4f\x4e\x23\x7e\x36\xaa\x35\xe2\x23\xe5\x48\x46\x87\x50\xdd\x1c\x69\x32\xa4\xc6\xa8\x65\x81\x32\x7a\xb0\x6c\x92\x8c\xc6\xaf\x6e\xc8\x1e\xc9\x58\x0d\x23\x93\x05\x78\x05\x20\xd6\x55\x82\xbe\x11\xe0\xe5\xa7\x43\x82\x5b\x57\xa1\xa3\x55\xac\xce\xcb\x4b\x8d\xdd\x64\x54\xa3\xb0\x7e\xd5\x7d\xd1\xc4\x77\x41\x5c\x89\xae\x6c\x57\x77\x65\x2c\x57\x94\x1a\xa8\x04\xc5\x85\xfd\xa6\x86\xc2\x53\x56\x90\x24\xed\xd0\x9d\x94\xc7\x6a\x05\x82\x8e\x9c\xbb\xd2\x7d\xeb\x6f\x8b\x8e\x5d\x03\xa0\xd6\x5c\xd8\x63\xf2\x8a\x23\xe1\x71\x9d\x2a\xde\x2a\x51\x7d\x70\xe4\xdc\xf1\x99\xf0\xde\x57\x7d\x3f\x5f\xaf\x97\x12\xfb\xe4\x67\x34\x97\x4f\xd1\x5c\xbc\x10\xb7\x8a\x75\xf8\x50\x3a\xc4\xff\x28\x83\x97\x51\xad\x37\x18\x15\xbe\x48\x63\xf3\x22\x1e\x3c\x4d\x13\x7f\x03\xc1\x26\x86\xd0\xde\x98\x4d\xe4\xb6\x3f\xf4\x76\xbd\x2b\xe1\x49\x48\x3d\xeb\x30\xbd\xd5\x1f\x6b\x67\xbd\xdd\x71\xe6\xfe\x81\xf3\x56\x78\x4e\xed\xf6\xf8\xfc\xe3\x5f\xa3\x92\x72\x2b\xb2\x23\xe3\x73\xab\xdb\xd3\x0b\xae\xdc\x3f\xbc\x63\x12\x3c\xf7\xd3\xe0\xbd\x3b\x32\xb3\xb1\x54\x70\x4a\x72\xf2\x36\x81\x2e\x65\xed\xda\xac\x83\xfb\x09\x8c\x07\x44\xbe\xa1\x46\xfb\x22\x1c\x49\x20\x4a\x6d\x52\x17\xf1\x26\x13\x50\x28\x90\x6e\xac\x50\x8b\x1e\xce\x26\x51\x14\x82\x07\x9f\xb0\xd1\x0c\xda\x6e\xc1\xf9\x01\x38\x1c\x0d\x59\x1f\x74\x01\x5c\x05\xcf\x80\x35\x7c\x8f\xac\x39\xdf\x4d\x05\x0f\x91\xf4\xe8\x5c\x7e\xe2\x8c\x3f\xbb\xe9\x12\xf8\x08\x76\x04\x97\xbd\x46\x74\xed\xb4\xb4\xb7\x1d\x71\x93\x8f\xc0\x8f\xcb\xad\x43\x5c\x3a\x25\xb7\x57\x17\x86\x75\x4a\xad\x84\x6a\xb3\x87\xe4\xac\x84\x87\x37\xc9\x47\x11\xc6\xac\x71\x8f\xc1\xd5\xa1\x15\xfb\x19\x3a\x24\x44\xcc\x7d\x41\x54\x10\x86\xf3\x0b\x91\x6c\x88\xa0\xda\x39\x6c\x81\xc1\xda\x60\x65\x31\xaf\x09\x46\xfc\x16\xc8\x99\x60\x13\xe5\x67\x30\x1a\x8a\x78\x1f\x23\x63\xd3\x49\xb5\x46\x8a\x2d\xe1\x69\x92\xd4\x25\x84\x5b\xba\xa5\xc5\x2b\xda\xbf\xab\xab\x79\x93\x84\x68\xdc\x3a\x03\xbb\xc2\x2d\xb8\x17\x4c\x32\xc9\xda\xc0\x2d\xcf\x6b\x7b\xb6\xb5\x25\xb4\x6f\xa5\x1f\xab\x49\xcf\xeb\xbd\xda\xbf\x1f\xbc\x7f\x77\xba\x65\xba\x2f\xf0\x41\x76\x8e\x05\x5e\x50\xf9\x5b\xd8\x77\x1f\x03\x8d\x66\xb9\xef\x2e\xd8\x45\x76\x82\x75\x54\xd3\xc3\x3a\xa4\x67\x17\xee\x9c\xeb\xbc\xcb\xae\xda\x3e\x73\xe6\xf6\x9c\xe5\x53\x7e\x87\xcf\xb2\xf3\xeb\x5f\xcc\x5d\x43\xe6\x8c\x6d\x82\xbd\x18\x2f\xcc\x6d\xd1\xdf\xf1\xb6\xa0\x8d\x49\x24\x5a\xd7\x39\xe7\x60\x84\x97\x19\xe2\x5e\x49\xf5\x0b\x44\x7b\xc5\x2f\xd0\x8f\x1e\xec\x37\xc9\x8f\xc6\xaf\x6e\xf8\x3d\xf2\x43\x7b\xc5\xcf\xcf\x43\xa3\xf1\x41\x1f\x22\xd3\x9d\x91\x1b\x81\x51\xa3\xa1\x18\xa0\x62\x19\x0f\x0f\xaa\x50\x88\xa3\x6b\xf4\xf3\x55\xf4\x78\x7d\xaf\x58\x85\xe2\x76\xae\xf4\x28\x21\x36\x5c\x2c\xe0\x8a\x10\x41\x5a\x4b\xb6\x28\x9c\x2c\xd4\xb8\x9b\x7e\xfa\x6a\xf7\x0f\xfe\x58\x78\xe8\x47\x78\x0b\xb4\xef\xda\x6b\x4a\x30\x48\xb2\xc2\x53\xb2\x82\x1d\xbd\x7a\x2a\x07\x7e\x58\x75\xf6\xd8\x74\x60\x3e\xd5\xef\xd0\x56\x89\x4a\x9f\x5d\x3e\x61\xfe\x91\x94\x98\xae\xe5\x62\x5e\x34\x9a\xcb\x00\xa2\x4f\x94\x92\x6b\x25\x9a\x7f\x0a\xf1\xcf\x77\x70\x5f\x4f\x23\x34\xf0\xa7\x40\x03\x11\x42\xfe\x93\xa7\xa7\x3b\xff\xe9\xd5\x18\x08\x44\xdb\x2b\x45\xfd\xd1\x8f\x0a\xa3\xb2\x1d\x91\x66\x7f\x64\x9a\x84\x21\x7e\xa6\x0d\xd4\x22\x7e\xa6\xd5\x68\x11\x3f\xd3\x6a\xd5\x66\xa3\x1f\x22\xff\x42\x5e\xa3\x56\x73\x9e\x45\xbc\x94\xf3\x6a\x0c\x8d\x17\x22\x57\x44\xfe\x16\x45\xb4\x6b\x3a\xc4\xdd\x76\xdc\xed\x01\xa4\x5f\xb1\x0e\xc1\xc3\x49\xa9\x15\xe3\x47\x87\x58\x2d\x3a\xff\xa8\xc4\x84\xa8\xad\xb4\x5f\xa7\x44\xc4\x90\x47\xed\x1e\x0d\xaf\xec\xec\x13\xd4\xa9\x2c\x3c\xbb\xd4\x82\x94\xd1\x8c\x6f\x0f\x76\x90\x6f\xf7\x48\x9b\xbc\x1c\x6d\x9d\x0e\x88\x2f\xbf\x5f\x93\xc6\x8c\x77\x36\x8b\x19\x64\x6f\x16\x2d\xf8\x02\xff\x14\xf7\xa7\x81\x0a\x40\x94\x1d\x61\x08\x28\xe2\x0d\x06\x8d\x27\x62\xc6\x68\x32\x42\x0c\x05\xa5\xd1\x68\xd0\x4c\x34\x1a\x99\x4e\xa5\x56\x1a\x65\x46\x51\x5e\x50\x24\x03\x50\x04\x5e\x4c\x68\x25\xa7\x57\x8d\x72\x83\x30\x15\x2c\x48\x9b\x70\x6b\x26\xd7\x05\x6a\xf7\xcf\xbb\x3f\x45\xf2\xe3\xf3\x4e\x44\x86\x10\xa0\xe9\x19\x02\x94\xe0\x2a\xc4\x5d\x87\x3b\xe0\x7d\x0d\x6d\x2e\x78\xd1\x3a\x85\x21\x78\x6b\xc9\x1a\xfc\xab\xc9\xb9\x34\xa6\xe3\x07\x64\xdd\x46\xf6\x7c\xb3\x26\x0a\xd1\x49\xc9\x98\x5f\x05\x1e\xb0\x86\x8c\x31\x18\x1a\xc7\x08\xba\x20\xb6\x4d\xb0\x2e\x88\x6d\x13\x05\x19\xe3\xe3\xd3\xd4\x36\x41\x7a\x84\xa0\x4b\x07\x7d\x42\x79\x62\xd5\x4a\x42\xab\x39\x16\x20\x41\x21\x23\x6c\xac\xd1\x75\x17\x01\x5c\x5a\x34\x32\x31\xa7\xc2\x35\x44\xb9\x9a\x8e\x94\xab\xf3\x70\x4d\xc1\x73\xa4\x41\x4c\x67\xc6\xbd\x3c\x01\xfb\x92\xfb\x26\x22\x3a\xfa\x91\xe3\xa9\x44\x2a\xd3\x61\x51\xa9\xa2\x12\x12\x98\x0a\x9e\x4a\x60\x23\xa2\xa2\x3c\x2b\xf8\x28\xbd\x4d\x57\xc1\xdb\xf4\x7e\x41\x41\x3e\x15\x7c\x50\x63\x14\xa7\xa8\x3e\x34\x96\x92\x14\x23\xdd\x5d\x65\xb3\xb0\x06\xda\x84\x9d\xbb\xfa\xa1\x6b\x68\x77\x25\x5c\x8d\x0e\x97\xc2\xa5\x63\x8c\xde\xaa\xe8\x92\x56\x5e\x06\xdf\x74\x9f\xd4\xfb\xa9\x9a\xf8\xe6\xc3\xdb\x78\x7b\xa9\x02\x83\xfa\x35\x9f\x9b\xd3\x7b\xc0\x9c\x5b\x8b\x26\xe7\x8c\x9e\x32\x78\xe4\xc8\xcb\xb3\xa6\xb4\x61\x33\xcd\xde\x5f\xc3\x71\x4b\xbb\xf5\x6a\x93\x08\x42\xe0\xcf\xa3\x5e\x80\x9e\x3b\x5b\x17\x7b\x9b\xdf\xce\x68\x7f\xec\x20\xfc\x0b\x6a\x5e\x4e\x98\x70\xf1\x2c\x08\x03\x07\x7f\x9f\x29\xd8\x93\x35\x08\xff\xc7\x11\xde\x7c\xb1\xcf\xc6\x43\x23\xf7\xd5\x2a\xd4\x7a\x95\x54\x6e\x14\x3b\xfb\x8b\xe1\xdc\x26\x5c\xf9\x4b\x8a\x63\x5c\x70\x77\xff\x64\x3d\xfa\x95\xc1\xb4\x04\x36\xf6\x73\xa6\xd3\xd6\xed\x17\xd5\xbd\xab\x2f\xd8\x7f\xe3\x26\x14\xaa\xff\xc5\x46\x16\xb7\x8a\x00\x6c\x5a\xb1\xcf\x72\xf8\x33\x3c\x73\x0b\xb4\x3d\x33\x0a\xe1\xf4\xfc\x97\x54\x03\x18\x50\xff\x7d\xe6\xf4\xad\x97\x17\xc6\x13\xbf\x3c\x85\x24\x22\xbb\x94\xcb\x42\x36\x9e\x19\xc7\x41\x7a\x98\x2a\x78\xa9\x9e\xd2\x57\xf3\x1c\xe5\x81\xfe\x6b\x69\xad\x77\x05\xaf\xd5\xe1\xb2\x73\x6f\xa4\xd8\xe1\x73\x58\xc4\x8e\x71\x7c\x8b\xdd\x7d\x1a\x1c\x22\x9e\xc7\x26\x4f\xbc\xe2\x0f\x6c\xfe\xbf\x58\x7f\xb1\x1e\x3a\x7b\x79\x19\x7c\xf0\x09\xcc\x38\x7e\x85\xf1\xfc\xab\x57\x76\xcd\xa6\x25\xec\xce\x15\x2b\x8e\x1c\xde\xba\x7a\xf1\xad\x71\xcc\x23\xe7\x99\xb7\xe1\xf2\x1a\x41\xff\x41\xb2\x85\x7d\x0b\xc9\x11\x2d\xc2\x46\x9c\xc3\xc7\xc3\x17\x29\x3a\x1e\x6a\x4a\xad\x43\x7c\xc3\x48\x53\x52\x2d\xa5\x2d\xe4\x05\x7b\x5b\x4c\xb2\x6d\x74\xcc\xea\x09\x41\x21\xae\x88\x05\x03\x8b\x49\x4c\x3c\x15\x88\x02\x0b\x01\x9d\x0f\x7c\xf3\x41\x9a\x15\x9e\x88\xef\x0d\xb6\xc0\x1b\x10\xc2\x49\x3b\x21\x04\x8b\x23\x17\xcd\xed\x3f\x32\x8a\x4d\x03\x4b\xe0\xa0\x23\xcf\xe1\xcb\x83\xdf\x22\x16\x60\x2f\xad\x68\x99\x46\x6c\xd3\x86\x07\xec\x0b\xae\x2b\x15\x4c\xc5\x3b\x7c\xbd\x03\x2b\x78\x3f\x6f\xd6\xa0\xae\x44\x4c\x40\xab\x63\xb4\x3a\x4e\x26\x63\x1a\x83\x35\x84\x03\x4c\x81\x75\x89\xf1\xeb\x29\xa6\x26\x0a\x04\x3e\xa3\xf7\x15\x72\xf9\x04\x0d\x82\x7e\xc7\xd1\xbc\x77\xaf\x2f\xdb\xdf\x9a\xf7\xf6\x06\xf5\xc8\x21\x37\x80\xe4\x46\x9f\xe1\x79\xcf\x3f\x9b\x3e\x97\xf9\xc9\x1e\x9f\x3f\xb5\x33\xd8\xdc\x7b\xd0\xdf\xa9\xe7\x2e\xfd\xf8\x6d\x51\x95\x50\xe5\x11\x78\x03\xd5\xf1\xa3\x39\xfd\xc6\x7e\x06\x57\xe0\xfa\xe2\xa2\x8e\x63\x43\x3a\xac\x9f\xbf\xc5\x82\xd4\x1a\x8b\x97\x14\xe9\x60\x0a\xa9\xc6\x18\xc6\x84\x15\xf2\x3a\x86\x01\x44\x89\xcf\x6c\x12\x5d\xef\x4e\x69\x27\xfc\x47\xd0\xbd\xd4\x40\xe8\x84\x82\xd6\xd3\x95\xd9\x20\x02\x8f\x60\x0f\x38\x7f\xb7\x73\x55\x2b\x40\x6d\x59\xb0\x16\x3c\xa2\xfb\x66\xf7\xf5\x7f\x60\x7d\xe0\x19\x96\x9d\x5a\xe5\xff\x6b\xc2\xdf\xab\xdf\xde\xc0\x56\x76\x45\x0c\xa9\xfd\x95\xa7\x3b\x57\x07\x6a\x6c\x8b\xe6\xd4\x1d\x71\x24\xa4\x0e\xea\xd5\x4b\xbd\xfd\xfb\xb3\x87\x0a\x61\x3a\xe2\xa5\xa2\xef\x1d\x77\x86\xc6\x1e\x0d\xc0\x29\xb8\x2a\x5e\x81\x00\xf5\x60\xe4\x8c\x54\x27\x1c\x50\xe9\x52\x5d\xb1\xa2\x98\x39\x62\x57\x20\x76\xf0\xdb\x6d\x61\x49\x52\x09\x63\x68\x5b\x7e\xbf\xbc\xdd\x1d\x78\x85\xfe\x1c\x74\xdd\x07\xaf\xc2\xb3\xcf\x0d\x0a\x75\x28\xf8\x05\x06\xe2\x1f\xec\x28\xa3\x8f\xde\x5d\x54\x16\xd2\x15\xf3\xee\xd3\xe8\x79\xb1\x84\x1f\x69\xf1\xf3\x64\x80\x1c\xd3\x29\x18\x0d\x8b\x8d\x1b\xe3\x9b\xcf\x23\xcf\x62\x08\x53\x8e\x05\x36\x09\xb8\x9a\xb3\x0b\xfe\x8b\xae\x02\x85\x7b\xe0\xbf\xc2\x73\xda\x9c\xa9\xfe\x09\xd1\x95\x1a\x94\xc1\xf7\x89\xa1\x8f\xfe\xd2\x5e\x23\xa6\x95\x87\xa0\x67\x5d\x14\xe7\xa6\xa7\x7c\xb0\x1e\xa7\xf2\xd4\x31\xba\x2a\xde\xc0\x30\xde\x1c\x03\x18\x8d\xc2\xc3\x55\x27\xce\xed\x77\x72\xf9\x82\x80\x1d\x8b\x01\x32\x57\xfc\x83\xa6\x9a\x94\x22\x8d\x02\x92\x0b\x13\x7e\x07\x5e\x7f\xa7\x5e\x60\xe3\xcb\xb7\x96\xdb\x8f\xfe\x70\xf6\x40\x39\x1d\xbf\x07\x30\x5d\x10\x15\x8c\xa5\x67\xbc\x38\xe4\x9a\x35\xfe\x41\xb3\xce\x5d\xff\x1b\x82\xe3\x27\x04\x87\x83\x9c\xd9\x34\xc2\x51\x28\xc0\xa1\x06\x6a\x0c\x87\xf1\x1f\xe0\xc0\x44\x00\x2c\xaf\xc1\x11\xd6\x12\x48\xac\xe7\x2f\xf6\xff\x1e\x30\x80\xea\xf4\x83\x3a\xa5\xcd\xea\x36\xc9\xef\x5c\x78\xff\xbd\x36\xa0\x7e\xb3\x5a\x83\xb4\xd9\x6b\x74\xa8\x80\x06\xd7\x0f\xed\xf5\x3c\x23\x38\x0a\xe3\x1e\xfb\xc2\x00\xc2\x87\x3f\xb2\x68\xa2\x1d\x5e\x14\xab\x64\xab\xf8\x00\x8d\x52\x29\x53\xa9\x82\xaa\x78\x15\x63\xa2\x65\xc2\x8a\xbb\xe2\x96\x9b\x96\x62\xc3\xda\x1e\x39\xd6\x41\x4b\x42\x22\x3b\x5d\x91\x2c\x8c\xde\x42\x5f\xaf\xf9\xad\x46\x9e\x57\xe3\x95\xfe\xa4\x45\xe4\x95\x75\x27\x99\x17\xb0\x74\xc2\x14\x75\x8b\x27\xe9\x9e\x19\xa9\x05\x77\xe1\x1e\xda\xe6\xbc\x42\xdb\xa6\x8e\x80\xe7\x80\xfd\xfc\x23\x19\x9d\xe3\x3c\x28\x5d\xb3\xbc\x4d\x1e\x52\x8d\xe3\x93\xc2\xdb\x17\x01\x09\x48\x25\xb2\x1d\xdb\xd0\x1f\x10\xbe\x4b\xe2\x7c\x7c\x69\x39\x5d\xc8\x9b\x55\x72\xb9\x44\xa1\xf0\x2f\x41\xca\xb7\x11\x48\x8c\xff\x04\xa3\x25\x44\x1f\x8c\xbb\x58\x66\xd0\x2e\x00\xf1\x15\xce\x1e\xb6\x21\xf8\x6a\xae\x15\x9c\x89\x09\xbe\x16\xa9\x1d\xba\x7d\xc0\x5e\x66\x3f\x5c\x38\x69\xbe\x34\xf2\x5a\xb0\xc7\xb6\x8e\x77\xe1\x07\x60\xc5\xbf\x76\x5d\xe9\xb1\xb5\x9f\x27\xf8\x15\x7a\x2b\xde\x9d\x12\x65\xbb\xb2\x2b\x22\x78\xcd\x1e\x9c\x89\x81\x61\xfa\x1e\xe1\x2d\x1b\xe1\xcd\x42\xce\xfd\x03\xbc\xf4\x52\x7d\x15\x1f\x2c\xa5\x11\xe7\x91\xd2\x52\x9a\x35\x1b\x95\x16\x1d\x1b\x5a\xc5\xb3\x0c\x45\x78\xb2\xa0\x40\x93\x6a\x7c\x8d\x19\x5d\x68\x3d\xb1\x33\x39\xc4\x4b\xdb\x04\x75\x21\x7a\x01\xad\xc9\x84\x15\xe9\x43\x2e\x9f\xad\x01\x55\xe3\x98\x30\xb8\xc6\xe3\x98\xae\xc5\xd9\x74\xa5\x2d\xb4\xe6\xdb\x9a\xc4\x4e\xc6\xf4\xb3\x2d\xfc\x32\x96\x0d\x3e\xcb\x8c\xfb\xe8\x09\x22\xb6\xab\x74\x98\xf3\xa0\x0a\xfe\x51\x50\x86\x31\xd8\x36\xb6\x55\x5b\x8c\xdf\x19\x43\x31\x7e\xdf\x19\xe6\xfc\x8a\x69\x03\x42\x04\x7b\x0b\xe7\xd6\x20\x7c\x06\x21\x8d\x18\xc1\x1e\x44\xab\x11\x3e\x2d\x06\xb5\xda\xb3\x84\x57\xab\x15\x5a\x6d\x48\x09\xd2\x99\x94\x6a\x5f\x09\x50\x88\xb2\xed\x15\xc3\xc6\x8d\x5c\xd2\x22\x34\x59\x30\xb9\x84\x89\x08\x85\x5f\x08\x8e\xe3\x10\xe8\x34\x3c\x5c\xb0\x20\x32\xf8\x48\xa4\x21\x7a\x5c\x87\x23\xe7\x8f\x54\x80\xea\x5a\xfa\x31\x3c\xe3\x51\x5d\x23\x89\x3d\x12\xec\xd9\x3f\x75\xcf\x73\xb0\xc2\xf3\xc6\xae\x2b\x15\x05\x70\x0c\xe2\x4b\xde\x04\xdd\xf3\xc6\xfa\xb4\xf8\x6d\x57\x92\x6d\xba\xc7\x09\xa0\x15\xce\x51\x4e\xc1\x2a\xf6\x4f\xc9\x47\x54\x11\x55\xe5\x68\x96\xef\x57\xcd\xe7\xeb\x5a\xa4\xa6\xd8\x1d\x59\xd6\x50\x2b\xc2\xb2\xd5\x6a\xcc\x6c\x66\x77\xc4\xc7\x20\xe8\xaa\x78\x3b\xab\xd4\x38\xa4\x9a\x2a\x5e\x6a\x74\x18\xe9\x0a\xde\x78\x10\xb4\xc5\x8a\x1e\x6e\xa2\x4f\x7e\x9f\x15\x0e\xd7\xf0\xb5\xdd\x95\xd2\x87\x2f\x70\x15\x21\x5c\x63\x1f\xc7\x1b\x08\xa1\x59\x16\xcc\x6b\x45\xb5\x1e\xd1\x39\xc9\xd8\xc0\x11\x22\x41\xe2\xe1\xb5\xce\x8a\xc4\x7b\x63\x96\x81\x1a\x08\x18\x20\x27\x66\x8c\x54\x45\x9f\xed\x19\x3f\x60\xc4\xe8\xf4\xe1\x63\xa5\xf0\x31\x9b\x1e\x5c\x5d\x3b\xa5\xd5\xf8\xc5\x6f\x7d\x71\x7b\xcb\xdc\xbc\xb9\x4b\x52\xa3\x52\x41\x76\xaf\xb2\x33\xa3\xff\xde\x04\x6c\x83\x8e\x75\x5c\x14\x59\x9e\x51\x19\xdd\x43\xe9\x6d\x09\xaa\x9b\xb2\x70\xff\xda\x11\x33\x9b\x57\x4e\x7b\x7f\xd7\x8a\x9e\x31\x23\xb3\x02\xc3\x02\x6b\x87\xd8\x22\x2c\x2d\x42\x22\x43\x66\x8c\x98\xb4\xb2\xd0\xa0\x8c\x2d\xce\x2a\xc8\xf9\xe9\x7a\xbb\x8e\x8f\xd2\x41\x4a\x26\xe8\x02\x0f\x5f\xce\x4c\xcd\x2b\xf5\x89\xf9\xd0\xef\x9d\x81\x8b\xbf\xb4\x6a\x67\x0c\xa8\x9a\x53\xde\x3c\x48\xa9\x30\xc7\x91\xda\x0f\x48\xef\x3f\xc0\xcd\x47\x38\x1c\xe8\x48\x6f\x97\xeb\x68\x9d\x5b\xc2\x0f\x6e\x0d\xa8\xd6\x9a\xd6\xb4\x9c\x69\x5d\xe0\x88\x55\x2a\x94\x8a\x22\x5e\xa9\xf4\x2b\x28\x68\x59\xc2\x17\x98\x53\xd8\x22\x3e\xc5\x68\x0d\x0e\x0a\xf7\xf5\x73\xf8\x78\xf9\xf9\xe9\x8b\x78\x3f\xf1\xd0\x40\xc0\x1e\x41\x59\xd3\xf4\x01\x11\x93\x38\x28\x41\x40\x35\xc2\xa7\x0b\x73\xb1\xb8\xa3\xac\xcb\x4c\xb4\x91\xd6\xfb\x6f\xa2\xce\x28\x9e\x36\x8a\xc9\x3b\x78\x21\x84\x90\x71\x71\x1d\x0c\x5d\x56\xee\x18\xd7\x27\xc9\xde\xa7\x36\x64\xdb\x92\xd6\x99\xf9\xc3\x0c\xbf\x16\xfe\x3d\xec\x44\xe7\x45\x89\x5d\x5a\xf4\x89\xab\x52\xfa\x06\x86\x8e\xe9\xda\x63\xf9\xf2\xe1\xe3\x92\xde\xda\xbe\x79\x6d\x75\xa2\xbd\x19\xdf\xb5\x7b\xf2\x11\xc9\x03\x90\x61\x6b\x9b\x5f\xdd\x66\xd8\xac\x23\x43\x17\x16\xfb\x19\x22\xda\x24\x46\x27\x18\xf7\x74\xea\xda\x2c\xb9\x63\x1b\xaf\x6b\x19\x20\x1b\x9e\xf9\x32\x3b\x39\x9f\xf7\x8d\x5d\x65\x1e\xde\x71\xf0\x3b\x41\xb4\x62\x50\xa7\xfc\xe1\x25\x2d\x7d\xbc\x1d\xcd\x03\x23\xfc\x82\xfd\xbe\xb5\x46\x68\x53\xd1\xdf\x49\x44\x1f\x7c\x4f\xac\x5d\xe9\x27\xd4\xae\xc4\x11\x92\x06\x3d\xb2\x31\x7c\xb4\x32\x86\x26\xa1\x0b\x8d\x51\x87\x2e\x86\x29\x44\x52\x19\x02\x40\xd3\xd2\x95\xb4\x45\xa8\x5c\x39\xa8\x2e\x8d\xa6\x1f\x01\x5d\x54\x14\x29\x5d\x39\xa0\xd6\xd2\xf9\x51\xa7\xde\x30\x57\xa8\x5c\x59\x71\xf2\x26\x2e\x5c\x39\xbf\x26\x16\xd7\xad\x9c\xbe\x9e\xd4\xad\xfc\x0f\x82\x23\x0d\xad\xeb\x53\xc2\x1f\x03\x1d\x6a\x1f\x4e\xa7\xa6\xbc\x15\xde\xa4\xac\x88\xbc\x69\x60\x86\xfd\xf5\xb2\x22\x74\x12\xbe\x90\x0a\x45\x45\x96\xd6\x0c\x08\x72\x17\x15\x19\xfe\x76\x21\x1b\xff\x24\x86\x71\xb4\xdb\x7d\x7d\x37\x3d\x7d\x63\x93\xaa\x22\xa0\xe3\x7b\xcb\x7a\xe0\xaa\x22\x25\x43\x7a\xd1\xcc\x6c\x7c\xde\x2c\xc6\xd0\x20\x65\x2f\x80\x8a\xc1\x95\x20\xfc\xcd\x11\xe6\x0a\xde\x12\xe8\x85\xb8\xa1\xc1\xcb\x61\x8b\x88\xa0\x3c\x3c\xac\xa4\x52\xb4\xae\x49\xa5\x68\x57\x8e\xeb\x99\x26\x39\xae\xdc\xeb\x05\x74\xd1\x5e\xc4\x59\x85\xa4\x8a\x97\xc4\x9a\x40\xb8\x77\x30\x83\x93\x8d\x68\xf0\xe2\xe2\x4f\x62\xe6\x7b\xdf\x03\x0d\x14\xbc\xb6\xe7\x54\x55\x42\x54\x44\xdb\x8c\xb4\x80\xf8\x2c\x0f\xb0\x2b\x36\xc1\x63\xef\xb7\x55\x19\xf6\xa8\xb4\xa4\x16\x86\xfb\x77\x5d\x99\xf0\x9b\xe0\x54\xe8\x9c\x0e\xee\x41\x90\xe3\x13\x60\x0d\x08\xb0\xff\x6c\xce\xb0\xff\x05\x8f\x05\xa2\x0b\x72\x7e\x2e\xfa\x02\x70\x95\x62\x34\x9f\x0e\x8e\x48\x8d\x2a\x42\x55\xc8\xdb\xa8\x08\x4d\x44\x50\x04\x5a\xe7\x08\x5f\x47\x50\x80\x6f\x40\x21\xef\xed\xeb\x4b\x49\xa5\xc6\x42\x5e\xaa\xa1\x42\x0b\x5f\x2f\xc6\x46\xa6\x24\x6e\x86\x84\xa6\x95\x89\x48\x06\xbd\x94\xa6\xf4\x64\x3a\x64\x37\x60\x03\xc6\x4b\x1a\x2c\x16\x52\x49\x21\x33\x06\xcf\xcf\x5d\x11\xd2\xe9\xf5\x89\xf0\x63\x95\x2d\x56\x56\xcc\xf7\x99\x16\xde\xcc\xe6\x68\xe5\xb8\x66\x4f\x94\x6c\xee\x33\xd3\x16\x1d\x12\xdf\x36\x25\xd1\xf0\xdd\x71\x21\xb9\xbe\x43\x2f\xf8\x27\xfc\x89\xae\x51\x26\x37\xeb\x55\x3e\xaa\x4e\x6d\xb3\x8d\xd0\xc4\x47\x9c\x1d\x35\x59\xe5\xed\xef\x8d\x69\x76\x1d\xa2\xd9\x9d\xc8\x46\xf3\xa6\x4c\x0e\x85\xca\x58\xc1\xeb\x54\x2c\xcd\x78\x08\xa5\x56\xc5\x5a\x16\xa4\x48\xa3\xc9\x88\x48\xf3\x95\x82\x16\x34\x0f\x2f\x2e\x00\xb1\x71\x2c\x4b\x67\xb5\x59\x9b\xbd\x77\x5a\xd1\xb8\x94\x9d\x06\xab\x9f\x5f\x33\x1b\x92\x3e\xe3\x12\xf6\x0e\x30\x7c\xbb\x12\xd4\xac\x5d\x98\x5d\xfc\x6e\x50\x64\x4a\x21\x25\xc6\xc4\x72\x93\x11\x2e\x0d\xf8\x79\x0a\x6d\x31\xaf\x56\x68\x68\xb5\xc4\x95\x0f\xe0\x7a\x9e\x97\x29\x13\xe8\x1b\x73\xb5\xa4\xf4\x50\xb8\x67\x0f\x08\x6d\xe7\xa1\xf6\xad\xdc\x52\xfa\xf1\xac\x81\x03\xde\x8b\x09\x8d\x69\x89\x6c\x69\xe7\xc6\xe6\x5f\xa4\x1c\x03\xad\xb7\xcc\xcd\xfa\xc1\x3f\xad\x8d\xab\xc6\xe9\x4e\xc9\x61\x5d\x18\x4b\xea\xd8\xd3\xe7\xe8\x40\xea\x09\x39\xf5\x08\x0d\x6d\x1a\xeb\x4c\x60\xc1\xf5\x35\x58\xab\x38\xce\x87\x12\x4e\x47\x5c\xe5\x49\x85\x9a\x2d\xe0\xff\x31\xf7\xdf\xf1\x51\x15\xdf\xff\x38\x7e\xe7\x96\xed\xbd\x66\xd3\x93\xcd\x66\x93\x90\x64\x93\x6c\x92\x4d\x42\xc9\x52\x02\x81\x10\x48\xa3\x6c\x20\x24\x41\x3a\x24\x80\x34\xa9\xa1\x48\x07\x01\x11\x45\x50\x04\x05\x44\x04\xa5\x77\x02\x28\x22\x4a\x53\x14\x11\x1b\x22\xcd\x82\x28\x11\x45\x81\x9d\xfc\x66\xe6\xde\xdd\x6c\x00\x7d\x7d\x1e\xbf\xf7\x3f\x5f\x79\xb8\xd9\x6c\xf6\xce\x9c\x39\x73\xe6\xcc\x39\x33\xe7\x3c\x0f\xf2\xa1\xed\x04\x9b\x21\x02\xcd\x3f\xf2\xb6\x54\x72\x89\xc3\x62\xaf\xf4\x58\xf4\xba\x48\xc4\x31\x56\x21\x55\x53\x5c\xff\xc0\xa3\x31\xbf\x17\x4b\xae\x16\xfd\x91\xcf\x4e\x86\xe4\x1c\x33\x3e\x77\x95\xb8\xaa\xe6\x26\x40\x68\x0c\x0c\xdb\x2b\x27\xdd\x9e\x6a\x0a\xcf\xca\x54\x7d\x98\xf5\xc3\x07\xb0\xb6\xa8\x5b\x9f\xb3\x4f\xd5\x4e\x39\x33\x6b\x40\xed\x94\xb3\x3d\x5a\xf5\x6f\x6b\x0b\xc6\x2f\xb0\x97\xee\xb4\xb6\xd7\x52\xd6\xe1\x55\xd1\x0d\x0f\x76\x7d\x39\x27\x5b\xcc\x5c\xa8\x87\xbf\x41\xdb\x6f\x5f\x1c\x06\x5a\xf0\xd5\xef\x3f\x1e\x82\x8b\xb7\xf5\xab\x3e\x04\xc6\xa0\x57\x3c\x8e\x38\x34\x0e\x19\x91\x63\x0b\xd5\x82\x4a\x73\x07\xc7\xd9\xa2\x93\x62\xad\xea\xe0\x88\x52\x4f\x68\x70\x88\x5c\x43\xb0\x1e\x4c\x4d\xc9\x11\xbc\x47\x84\x5f\x7c\xe0\x9d\x3c\xd1\xe9\x3a\xbe\xcc\x4c\x53\x4c\x87\xfe\xd1\x21\xd2\x73\x46\xef\xa9\xed\x5b\x33\x6a\xcf\x88\xaa\x11\xbb\x5a\x27\xf4\xc8\xc9\x49\xf0\x64\x0f\x79\x7c\x68\x74\xc3\x67\x70\xd9\xf1\xe3\x6f\x7e\x04\x86\x1d\x3f\xfc\xc2\xd2\x6d\xf0\xd7\x05\x2f\xec\x00\x61\x0f\xbe\x79\x74\x74\x18\x23\xa3\x71\x01\xd2\x2b\x87\x28\x33\xa2\x1e\xd9\x7d\xe1\xa1\xc1\x48\x1a\x3c\x88\xf9\x4c\x5c\x6c\x0c\x13\x53\xe5\x31\x52\x8c\xae\xa9\x50\x57\xae\x3f\xbe\x1b\x5f\x35\xc7\xe2\xe8\x09\x3e\x71\xca\x6c\xc2\xf1\x29\x68\x43\x01\xe9\xf8\xbc\xc0\x4e\x80\x8b\x70\xe5\x1c\x73\x1b\xa0\x03\x37\xda\xf6\x51\xdf\x99\xf4\xcd\xcb\x71\x93\x72\x73\xcb\xd5\xf7\x26\x7f\xbb\xda\x3a\x11\x3c\x95\xd1\xbe\x5b\x41\x4a\x9b\x7e\x39\xe9\x79\x5d\x0a\x52\x72\xfb\xb5\x1a\x9f\x9f\xdd\x07\x94\xec\x01\xab\x00\x9d\xda\xba\x43\xa7\xac\x1e\x70\xeb\x1e\x38\x00\x3e\x4c\xcf\xce\x67\x1a\x66\xb7\x4e\x4e\x49\x3d\x02\xaf\x56\xcf\x77\x27\xa5\xa4\xbe\x07\xc2\x05\x6c\x8d\xc6\x15\x48\x8f\xbc\x80\xe8\x8f\xc7\xf4\x87\x06\x87\xab\xc3\x4b\x3c\x46\x9d\x5a\x6d\xb7\x59\xa5\xd6\x12\x8f\x88\x91\x1a\x9f\x44\x3f\xd0\xd0\x42\x85\xe0\x64\x90\xa1\xa1\x84\x51\x84\x03\xce\x47\xbf\x9f\x7c\xf6\xd9\xfb\xd7\x22\x07\x65\x65\x17\xaa\xa6\x2d\x00\xcc\x0f\x91\x15\xce\xd4\xce\xba\xb9\x4b\xe1\xd7\x2d\x3a\xf6\x2c\x6b\xd1\xa7\x30\xb5\x5d\x61\xb7\x84\xea\x1e\xf4\x3b\xf0\x1e\x5c\x91\x93\xd2\xb2\x65\x4a\xd4\x85\xf5\x40\x0c\x86\x38\xe3\x52\x1c\xb1\x61\x67\x36\xcf\x71\xb4\xcb\xed\x78\x65\xed\x12\xa7\xcb\xe5\xfe\x15\xc9\x4c\x7a\xe3\x2d\x2e\x53\xfc\x23\xf2\x3e\x22\x90\x9d\xd0\xc1\x1d\x9d\xd0\xb9\x7d\xe7\x4a\x4f\x52\xc7\x8e\xc1\x21\xed\xc5\x2a\xb7\x11\x00\x79\xaa\xa9\x3d\x6b\x8d\xec\xde\xaa\x7b\xa5\x27\x27\xab\x95\x3e\x60\x04\x27\x9c\x5f\xa4\x69\xb1\x42\xd7\x9c\x48\x6b\x82\x9b\xe6\x07\xe2\x2f\x8c\x83\x81\xe2\xcc\x00\xed\x44\xb8\x8a\xaf\x00\x50\xfb\x3f\x0f\x77\xc4\xbe\x13\x21\xf4\x5d\xce\xa0\xeb\x34\x39\xaf\xd3\x98\xb6\x03\xc6\x1b\x76\x44\xdd\x59\xdd\x61\x5a\x49\x56\xcf\xfc\x5c\x6f\x65\x58\xa2\x64\x58\xd4\x8d\x10\x73\xce\xf9\xe4\xb2\x84\xff\x3a\xfc\x59\xc7\x9f\x14\x65\x25\x56\x8b\x86\xa4\x67\xb7\x4c\x1b\x33\xf8\xad\x8b\xc9\x99\xb1\x49\x26\x16\x0e\xb0\x56\xc4\x6f\x59\x34\xae\xec\xc1\x9f\x5d\x4a\xff\xeb\x48\x68\x39\x7f\x7c\x74\xa4\x33\xb9\xa7\xa2\x52\x10\xdf\x58\xd1\xcf\x14\xc6\x59\xee\x48\xe5\xba\x23\x92\x33\x5a\xc5\xc5\xa5\xb5\x6d\x27\x75\x87\xc9\xa4\xb2\x12\x4f\xc7\x70\xa9\xc6\xa4\xd7\xd0\x9a\x12\x8f\x8d\xa2\x4d\x81\xd3\x7e\x42\xd8\x27\x4e\xa7\xe1\xca\x95\xb8\xb8\x91\xcd\xbf\xec\xc4\xfe\xca\x29\xfe\x00\x65\xbe\xa2\x15\x66\xd0\xff\xe0\x2c\xcd\xf5\xaa\x7c\x76\xf5\xfc\xbf\x5f\x4e\xca\x9b\xd2\x69\x84\xbd\xb0\x75\x82\x3b\x2e\x67\x4c\x87\xf6\xed\x92\x56\xbe\x39\xe7\xe7\x79\x55\xf4\x9a\xff\xc5\xc7\x16\xb9\x97\xea\x4f\x83\xce\x7b\x6e\x4c\xfd\x66\xc9\x31\x5b\x6a\x4a\xec\xdc\xcb\x73\x06\xf7\xbc\xf1\xd5\xb1\x63\x70\xcf\x21\x6e\xda\xbf\xb0\x0e\xeb\xda\x1c\xc4\x0f\x95\x68\x82\x26\x96\xd5\x88\x70\xfc\xf1\x7d\xfa\x0d\x10\x84\x4f\x22\x33\x33\xfd\x79\x08\xe4\x3c\x8d\xab\x44\xfa\x58\x4b\xf1\xdf\x29\xe1\xcf\xee\x6d\x36\xff\xd9\xfd\x4c\x64\xdb\x78\x91\x2e\x36\xe3\xd8\x06\x61\xbf\x92\x30\x38\xd6\x51\x1c\xe2\x73\xab\xfc\x67\x38\x3c\x42\x0d\xc9\x29\xe4\x81\x61\x68\xb0\x7d\xc8\xb0\x4e\x6d\xa7\xc3\x4b\x25\x2f\xae\x01\x93\x41\xdf\xfd\x9f\x9b\xe1\x55\x69\x79\xe1\x8e\x33\xb4\x74\xf9\xeb\x66\xef\x08\xb0\x31\xe6\xe1\x19\xf0\x06\x38\x73\xfc\x58\xbb\x61\xe3\xe0\x16\xbc\x67\xe1\x1c\xb6\x97\x08\xa6\x34\xea\x53\xa2\x2d\xf2\x28\x25\x1a\x60\x2e\xf2\xa0\x4d\xab\x59\x9f\x4d\x30\x34\xbe\x2a\x37\xb4\x0f\x88\xa6\x77\xf1\xd2\x97\xd7\x00\xdb\x7b\x87\xbe\xc0\xe5\x6d\x96\xbd\x5a\xd5\xb3\xb0\xf5\x24\xd8\x0b\xac\x0d\xbd\xf8\xf6\x27\x4d\x65\x6d\xe0\x3f\x17\xa6\x4e\x35\x79\x17\xf0\xe7\x8b\x68\x83\x66\xff\xe2\x4e\x23\xfb\x48\xb6\x53\x4b\xe1\x68\x4e\x1c\x05\x2d\xb6\x89\x39\xb1\x0d\xd9\x6b\x36\x17\xe7\x42\xff\x23\x8d\xcb\xfe\xd5\x17\x3e\xd7\x1f\x8c\xae\x80\x4b\xd6\xfe\x73\x10\x2e\xee\x0b\xc6\xf6\xc7\xaf\x63\x0e\xdf\xff\x92\x99\x7f\xb1\xfa\x62\xf5\x97\xd5\xf0\x15\xb0\x0e\xfd\xc0\xbf\x80\x0d\x30\x1c\xfb\x50\x36\xb6\x9c\x06\xa8\x7d\x03\xa9\x3a\xc7\xea\x8e\x72\x62\xa1\xd2\xae\x50\xf1\x2c\xca\x97\x52\xea\x8c\x22\xfe\x0f\x0d\x7a\xb4\x81\x5b\x65\x45\x59\x09\x39\x65\x6e\x50\x2a\x89\xcb\x8d\x4e\xc8\xe1\x06\x67\xf7\x68\xd3\x36\x2d\x25\xb7\xc4\xe1\x0c\xc3\xf5\xd3\x1a\xe3\xd8\x93\xa0\x81\xbb\x4a\xda\x95\xca\x64\x8c\x66\x3a\x5f\xa5\x9c\x6f\x97\x37\xdc\x49\x54\xbd\x60\xcb\x83\x19\xa0\xd6\xde\xf3\xa9\xda\xdc\xca\x98\x41\x19\xd5\x7d\xfa\x38\x3e\x90\xb0\x27\xcd\x35\xf1\x69\xf1\xfb\x23\x62\x22\x0e\x25\x3a\x11\x2f\xc2\xd8\x52\x90\x46\xf0\x9e\x49\x6d\x52\xbe\xdc\x36\x76\x98\xc5\x56\xb1\xc1\x6c\x25\x90\x78\xad\xff\x8c\x1b\xc1\xb8\xe7\x47\x98\x24\xdc\xe9\x73\x96\x9c\x5e\x69\x5d\x52\xac\x89\xe8\x59\x5a\x78\x56\x8a\xab\xa8\x8a\x48\xbd\x7b\x7f\x65\x59\x52\x38\x7c\xa1\x50\x38\x5c\x5b\xc8\x96\xe2\xc2\xe1\xbd\xf8\xda\x77\xb5\x5c\x2d\xc3\x89\x6e\xa3\x71\x68\x76\x8b\x55\xd3\x0d\x72\x40\xca\x86\xf3\x95\x5b\x9b\x56\x1a\x39\x85\x43\xda\xd8\x4c\x5f\x35\x79\xd6\x55\xf5\x9f\xd7\x65\xea\x73\x86\x1d\xd1\x40\xbf\xbf\xeb\xaa\xe1\x43\x5f\xea\xcd\xd5\x3a\x73\x5a\xa5\x8e\x19\xbc\xf9\x8b\x24\x57\xa6\x93\xc5\x73\x2b\x79\x68\x83\x9b\x99\xaf\xb9\xbd\xb8\xa6\x39\xc1\x50\x4c\xa5\x5a\x52\x79\x54\x77\x6a\xa5\x5b\xd9\xaa\x6d\xfb\x8e\xd6\xf0\x82\x42\x77\x64\x7e\x61\x3e\x2e\x55\xa9\xf4\xd8\x0a\xd3\xd4\x32\x57\xb6\x5b\x91\x9e\x9d\xce\x7f\xa2\xcd\x8e\xe3\xa8\x24\x87\x9b\x4e\x70\x24\xe0\x4f\x54\x1e\xb1\xa3\x30\xdb\xe1\xc8\x2e\x64\xda\x87\xb4\x6f\x83\x3e\xda\xeb\x69\x6f\xb0\x84\xb8\x43\x4c\xe8\xfd\x76\x4f\x08\xe5\x20\xee\x17\xd2\x29\x3c\x70\x51\x90\xc3\x77\x1e\x4c\x3e\xc5\xf5\xc0\xff\xed\x17\x0d\xa9\x37\x86\xa6\xcd\x68\xd5\xa0\x09\xd3\xfb\xdf\x81\xff\x7c\xc7\x3c\xe1\x33\x9b\xff\x1d\xfd\xf0\xe9\xa7\x07\x5f\xba\xa4\x25\xaf\x0f\x17\x93\x1f\x74\x12\xf9\x71\x7f\x36\xf9\x71\x99\xff\x6c\x19\xf9\xe1\xb5\x90\x1f\xcc\xf1\x15\x2b\x70\x19\x2f\x11\xf9\x41\xdf\x26\x3f\xee\xdf\x20\x3f\xd8\xd8\xc0\xbf\x3d\xfc\x9e\xfc\xb8\x4b\x5e\x79\x9e\x0f\x87\x33\x98\xd7\xb8\x9b\x8f\xf1\xbc\xbf\x3b\x5d\x22\x75\xb7\x4f\x72\x38\xe2\x2c\xa1\xc6\x50\xab\xcd\x16\xde\xbd\xd0\x95\x93\x96\x23\xd3\x4a\xdb\xe7\xc5\x85\x84\x86\x67\x17\xe6\x74\xd1\x6a\xbb\xe4\x14\x66\x87\x87\x86\xc4\xe5\xb5\x97\x2a\x38\x35\x47\x39\x1c\x8f\x14\x02\xc5\x25\xf9\x34\x27\xc8\xeb\x59\xfe\x1d\xfe\x49\xca\xf4\x91\x63\x90\xcc\x0c\x6b\x86\x96\x54\x87\x17\x19\x9d\x46\x22\x43\x19\x26\x67\x86\xd3\x86\x05\xc8\x18\x6b\x35\x5a\x19\x2c\x47\xe2\x58\xbb\xd8\x8e\x81\x09\x90\x4d\x65\x76\x99\x19\x24\xa1\xd8\x3b\xb6\xbb\xb0\xfd\xe2\x32\x8b\xc4\x66\x71\x5e\x70\xe8\x80\x76\x05\xe4\xc5\x3b\x6c\x52\x87\x8a\xf8\xde\xc5\xab\xd9\x2d\xc2\x9b\xd6\x3d\x53\x1c\xb2\x4e\xea\xec\x8c\xda\x87\x79\xe8\xad\xb4\x23\x7a\x3b\x52\xd1\x33\xb5\x34\xb5\xd3\x88\x9c\x8c\x5a\xe6\xb3\x9e\x29\x65\xa9\x9d\x6a\xb3\x33\x6a\x5a\x92\x27\x8a\x5e\x61\xbf\x13\xde\x78\x43\x49\x9b\xe9\xe4\x15\xde\xeb\x85\xbe\xd8\xb1\x26\x0b\x3d\x23\x26\xcf\xd4\xe0\x36\xdb\xf0\xcd\xe3\x96\xe6\xf5\x4c\x4d\xc6\x3d\x65\xd6\x60\xfb\x26\x02\x0e\xc1\x39\x26\xc8\x4e\x8e\xa1\x5a\xec\x51\x48\x90\x6d\xa6\x93\xe3\x50\x1d\x75\xa4\xda\x1c\x61\xa6\xcd\x3a\x8d\x08\x30\x9c\xaf\xfa\xce\x77\x67\x2a\xd2\x72\x85\x62\x4e\x24\xab\x85\x71\x02\xe4\x12\xeb\x33\x5d\x52\x10\xe9\x00\xe9\x68\x69\xf2\xe8\xac\xb8\x3e\x2e\xce\x75\xa1\x67\x05\x77\xc6\xb9\x2e\x17\x27\xc2\x57\xee\xff\x92\x39\x3d\x2a\xd7\x7b\x08\xac\x84\x7b\x82\x58\xd1\xf7\x4c\xbb\xbe\x85\x5d\x92\x55\xdf\x5b\x86\x1f\xc0\x19\x30\xb3\x7e\x66\x95\x0f\xde\xf5\x8e\x05\x2b\xe9\xa5\xaf\x7e\xf0\x50\xc5\xcd\xd9\xea\x88\xb6\x25\xb6\x4a\x0e\x75\xe7\xd4\x3e\xd3\x9a\xb7\xc7\xf0\xbd\xd7\x4e\xee\x7d\x1c\x09\x4a\xa5\xbb\x83\xa3\xd4\x41\x11\x41\xb4\x94\x09\x0a\xd3\xbb\xd5\xac\x4e\xcd\x68\x8d\x04\xfe\xd7\x28\x25\xc7\x45\xbe\x40\x03\x67\xf0\x77\x69\xc4\x83\x23\x30\xc0\x4d\x64\x13\x58\x7b\xbd\xed\x31\xca\xc1\xfd\x0a\x9b\x1d\x07\x12\x6e\xad\x83\xbb\xee\x34\x54\x0c\x95\x25\xc8\x49\x34\x21\xb8\x03\x77\x9b\x19\xd1\xf7\x6c\xbb\x0a\x42\x7a\xf0\x88\x7a\x1c\x60\xb8\x79\x1c\xfd\x80\x8f\x4f\xa2\x43\x53\x97\x87\xe0\x20\xc3\x41\x5b\x93\xa3\x63\x93\xb3\x1d\x61\x6d\xb3\x46\x4e\x68\xed\x8f\x37\x59\x27\xdc\xff\x38\xdc\x16\x8d\xb9\xd2\xa3\x16\x4b\xc4\xc5\x78\x6f\x42\xff\x38\x19\xc3\x05\x55\x7a\x38\x7f\xe0\x7b\x76\xc0\xed\x0f\x10\x6e\x7c\x5c\xbe\x5b\x20\x92\x73\xcf\xdf\xfe\xb0\xeb\xf0\x95\x8f\xf7\x6a\xfd\x38\xeb\x38\x1b\xb0\xdb\xa6\x5a\xa7\x46\x00\xd3\xd9\x8b\xf0\xdc\x5f\x47\x3b\x9e\x58\xff\x3c\xb8\x8d\xaf\x7e\x3e\xdf\x76\xec\xd8\xb6\xd7\x37\x9d\x6d\xba\xff\xc1\xf7\x97\x63\x9b\xee\x7f\xb4\xc1\xc5\x1e\x8d\x44\x2a\x29\xf6\xa8\xa4\x5a\xf4\x4f\x24\xa7\x44\xba\x62\x8f\xc8\xf8\x44\x7a\x84\x6b\x1f\x3f\x41\x72\xff\xfd\x0f\x7d\x16\x6c\xc4\x77\x3e\xde\x0b\xd7\xa6\x46\x4d\x0d\x01\xc1\x21\x8b\xa2\x16\x0d\xea\xfb\xf9\xb2\x05\xc3\xc6\x5f\xa0\xe7\xe2\x5b\x1f\xf6\xa5\xcd\x0b\x17\x6e\xf6\xfe\x0e\xe3\x7a\x54\xe1\xbb\x1f\xda\x97\x6f\x43\xa9\xa8\x50\x2a\xc2\xad\x31\x48\x2a\x3d\x06\x83\x4c\x2e\xd7\xe3\xc4\x08\x59\x00\x2e\x1a\xe1\x05\xae\xce\x29\xc2\x50\x12\x80\xb0\x81\xcf\x87\x20\xc5\x3a\x33\xd9\x53\x2f\xf4\xd8\x37\x68\xdc\xb2\x0f\x2a\x08\x3a\xcf\xf7\xdf\xfc\x0c\x3f\x1d\x33\x7a\x65\xf1\xda\xcc\xe4\x91\xfb\x47\x88\x94\xcc\x6f\x1f\xbe\x32\xec\xa5\x69\x49\x30\x86\xcb\xdb\xfa\x45\x8f\xce\xb0\x52\xb6\xe0\xa5\xb9\xca\x10\x8a\xf6\xc5\xf9\x21\x3d\xe3\xc0\xa8\xd2\x61\xea\xe0\x10\x33\xab\x97\xe8\xa3\x8a\x3c\x7a\x93\x24\xb1\xc8\x23\xd1\x3c\x56\x87\x82\x1c\x77\xf9\x03\x58\x08\x5d\x3e\xc8\x70\xb4\x28\x48\x0c\x0b\xa6\x4b\x08\x94\xc5\xd5\x6c\x54\x1c\xeb\xde\x33\xe2\xb9\x55\x15\xbd\x47\xbd\xf1\x74\x59\xe5\x88\x45\x26\x5a\x39\x10\xde\xbc\xa7\x36\xbf\x51\xda\x39\x23\xb9\xf6\x8d\xc2\xd0\x98\x82\xfc\xee\x0b\xcb\xd8\x1c\x89\x69\x7c\x68\xbf\xc1\x5f\x1e\x5e\x04\xbf\x1f\xbd\x70\xc1\xa2\xb8\x01\x7d\xba\x78\xff\x62\xef\x15\xbe\xe6\x1d\x34\xbe\x2e\x74\xfe\x82\xea\xfc\x6d\x69\x63\x26\x3e\xf3\x2d\xda\x2f\xfb\x52\x80\xf3\xa0\x75\x2c\xa6\x74\x6e\xa9\x18\x57\x64\x13\x33\x58\x92\x72\xcf\x12\x2b\x87\x3f\xda\x65\x83\xf3\xee\x8f\xf6\x8e\x13\x4a\x3a\x81\x01\xde\x7d\xa4\xaa\x93\x0f\xbb\xef\x2c\x77\xde\xf7\x7c\x91\x87\x16\xab\x71\x54\x75\xee\xe9\xa6\xe7\xf5\xcc\xfc\xa2\x3f\xc7\x79\xaf\xf1\x31\x92\x60\xa5\x77\xb3\x10\x23\x89\x9e\x77\xa0\xfe\x4d\x24\xbf\x25\xd6\xad\x17\xc9\xe4\xb2\xfe\x1e\x56\x2e\x97\x28\x95\x74\xa5\x47\xc9\x48\x02\x26\xd0\xe7\x51\xf8\x6a\xc1\x61\x11\xd2\x73\xa6\x24\x6f\x55\x7b\xd0\xd2\x0e\x3f\x18\x09\x2f\x8d\x9c\x6f\x9f\x3f\x0a\xe3\xda\x6d\x38\xe9\x7d\x9f\x6e\x7d\x92\xce\x25\x7d\x54\x08\xb1\xe3\xfe\x3e\x8a\x7c\x7d\x20\xf3\x4e\x2d\x31\x3e\xb1\x0f\x24\x9a\x42\x1f\x24\xb4\x3c\xf3\xb0\xed\x70\x09\xbc\x51\x52\x67\xab\xeb\xc3\xe6\xd4\xc3\x9f\x8f\x40\x0f\x78\xf3\x08\xf8\x3c\x20\x37\x2a\x92\x4a\x72\x07\x49\x42\x2a\x3d\x6c\xa4\x44\x42\x45\xea\xd4\xc6\x6a\x8f\x5e\x1d\x42\xe1\x9b\x70\x7f\x49\x30\x3e\x35\x85\x24\xc5\x93\x14\x55\xe1\xb0\x99\xc7\xc9\xc0\x7e\xb5\x4e\xeb\x0b\xa5\x01\x76\x66\x51\xa2\x77\x75\xcb\x6e\x9d\x4b\x9d\x9b\xf6\x6f\x86\x67\x0f\x4f\x3f\xd2\xfa\x5c\xcb\x71\x9b\x8f\x16\xf7\x6c\xdd\xdf\x35\x16\x5e\x22\x49\xab\xf6\x20\xf5\x2f\xdf\x41\x38\xfe\xcb\xa2\xa7\xa6\x94\x81\x02\x60\x9d\x31\xd1\x16\xe5\xdd\xc2\xf3\x37\x1c\xd1\x96\x80\xc6\x1e\x81\x69\x0b\xd3\x96\x78\x42\xc2\xc2\x4c\x66\x73\x70\x89\xc7\xac\x36\x19\x59\x79\xa9\x47\x82\x11\xfe\x9c\x4d\x38\x51\x41\x0e\x4c\x9b\xcd\x47\x91\xcf\xf5\x10\xa2\x7b\x30\xc9\x04\x04\x26\x61\x25\xbc\x7e\xf0\xe5\x63\xae\x6f\x13\x2a\xda\x55\xcc\x2b\xd8\x92\x33\x2d\xa2\x23\x9a\x5f\xc6\x94\x04\xd9\xcc\x67\xea\x0e\x9f\xfb\xf2\x10\xfc\xea\xb5\xb2\x5e\x93\xd2\x62\xca\xeb\x67\x7c\x62\x51\xc3\x97\xd9\x9c\x9f\xe1\x2f\x71\xe7\xf8\x5c\x55\x38\x84\xe4\xaa\xda\xa9\x9c\xfd\x54\x2c\xda\x37\x42\x01\x2b\x53\x46\x73\x62\x93\xb8\xbf\xc7\x62\x32\x51\x61\x66\x2d\x23\x52\xe8\x28\x6b\x95\xbf\x3c\x60\x40\x3d\x20\xb3\x13\x67\x09\xf2\x89\x88\xd6\xff\x4c\x54\x25\x31\xfc\x95\x24\x09\xf5\xf2\x63\xc9\xaa\xce\xd4\x91\x97\x47\x66\x55\xb6\xe6\x93\x55\xbb\x0c\x9f\xf6\x71\x77\x3e\x0f\xf5\x91\x7c\xd5\x67\x47\xaa\x70\xbe\xaa\x6a\xcc\x74\x21\x5f\x15\x26\xe0\xfd\x06\xc7\xf7\xa3\x71\x24\x22\xfe\xda\xa8\x1c\xb7\x89\xb1\x44\x5a\x59\x3e\xbc\x5f\xa5\x8a\x90\x45\x04\x17\x79\x22\x8c\x61\x68\x47\xd9\x63\x50\xcb\xd4\x36\x8e\x0f\x20\x76\x36\x13\xb7\xff\x11\xe2\xef\x64\xac\x8f\x87\xf9\x1b\x1c\x8a\x4e\x7f\xf8\xc3\xfc\xff\xfc\x28\xb2\x2c\xac\x7a\xe0\xd8\x8f\xbb\xb7\x6e\x1e\xea\x6f\xa8\xca\x7c\x2c\xd4\x1f\x4e\xf2\xbe\x05\x56\x0a\xe1\xfe\x38\xd7\x96\xdc\x0b\x78\xa8\x4c\x8c\x51\x98\x1c\x12\x1c\x12\x5c\xe9\x09\x09\x51\xc4\xc4\xc5\x45\x57\x7b\xe2\xd8\x0c\x85\x02\x69\x52\x8d\x42\x4f\x4b\x9e\xf2\x70\x74\x48\xf3\xa8\x1f\x7f\xb6\x97\x10\xe5\xaf\x89\xf2\xc5\x97\xb7\xc6\x83\xb1\x85\xfb\x75\xfb\xbf\xa5\xd5\x62\x54\x1b\x7a\x20\x3c\x9c\xd8\x2f\x2c\x34\xb7\xb0\xc8\x73\xee\x56\x18\x08\xd6\xd7\x4d\x9b\xb1\xee\xf9\x95\x79\x49\x79\x6f\xbf\x3e\xb0\xdc\x97\x61\xfb\xe1\xef\x87\xd6\x4e\x99\x3f\xed\x97\x17\xe8\x6a\xb8\x4f\xa7\x7d\x2e\x6c\xf4\x98\x70\xc9\xbe\x0d\x15\xb5\xa3\xc7\x3d\x55\xd0\xf9\x6a\x6d\xff\xf6\xdd\x70\xae\xed\xdb\x73\xe7\xbe\x17\x6b\x58\x38\xa8\xf6\x48\x9d\xbe\x1d\xbf\x06\x52\xd1\x18\x71\x4e\x43\x1a\xe5\x76\x47\x27\xa4\x14\x7b\x92\x12\x42\x22\x7d\xd7\x1d\x94\x29\x38\x58\x5f\xec\x09\xd6\xd8\x29\x4a\x54\xec\x03\xd9\x7f\x7c\x78\xbc\xdf\xc7\xc5\x30\x81\x79\x0c\x4d\xf7\x19\xcd\xf3\x18\xc4\x66\x3f\x2b\x32\xc0\xfb\x70\xb6\xf9\x3e\x3d\xae\x6a\xf4\xfc\xe7\xdf\x8e\x3e\xb1\xb1\xa2\xc7\x90\xf9\x46\x92\xd2\xb0\xe7\xeb\x97\x57\x0c\x9f\xde\xf0\x29\x03\x0f\x25\x56\xe0\xf1\x6f\xd2\xcb\x40\x7c\x62\x97\xf2\x7e\x5d\x3a\xb9\xb7\x97\x94\xa5\x67\x17\xe4\x99\x96\xaf\x9a\x39\xa6\xe6\xc5\x08\x5a\x3e\xd1\xb3\xf4\x88\xa9\x27\x3c\x80\x87\xfe\x8b\x2f\x96\x87\xe4\xf0\x9a\xa9\x34\xb7\xc1\xac\xd3\xc9\x8d\x34\x72\x92\x69\x5a\x4b\x69\x15\xfd\x3d\x5a\x9d\x1a\x49\xde\x0e\x11\x9f\x98\xd7\xec\x12\x8f\x64\xd8\xfa\x52\x0f\x9a\x4b\x19\x9f\xd5\x9b\xfb\xda\x10\x5f\x5a\xef\x8d\x89\x63\xef\x77\xef\x19\x90\xd8\x3b\x75\xa6\x2f\xb1\xf7\x53\x2c\x4a\xfe\xe4\x5e\x3e\xb6\xe8\x7b\x12\x5f\x8d\xe8\x31\x1a\xb5\x32\x3d\xad\x27\x99\x0f\x94\x46\x8e\x61\xba\x54\x3c\x3d\xea\x27\xd2\x13\x90\x0a\x21\x90\xf3\x78\x3a\xc4\x8e\xb7\x91\x90\x2f\x79\x3c\x21\x02\x2e\x20\x42\xcd\x27\x45\x34\xe5\x36\x5b\xb0\x75\xa2\xd6\x19\x19\x64\x8e\x56\x7a\xc4\x2c\x6d\xa0\x39\x8e\x36\x30\x5a\x8b\x4e\x26\x24\x38\x13\x9b\x5e\xeb\xf4\x2f\x44\x44\x84\x8b\xa8\x0f\x7f\xaa\xb3\xd8\xaa\x17\xf9\xd8\x92\x9a\xd9\x6d\x68\xb6\xc9\x01\xb8\x80\x94\xe7\xb7\x53\x86\x16\x64\xa4\x08\xbc\xb1\x82\xa5\xf0\x6b\xb3\x0b\x74\x16\x32\x9f\xc1\x87\xf7\xc0\x74\x93\x90\xfb\xec\xcf\x0b\x09\xc2\x74\xa9\xb4\x06\xc6\x44\x9b\x8a\x30\x5d\x7a\x4c\x97\x9e\xd1\x04\x19\x65\x42\x32\xc3\x23\x74\xe9\x05\xba\xfc\xb9\x22\x72\xc0\x93\x85\xf9\x93\x14\xda\xaa\x34\xb3\x75\x79\x40\xca\xc8\xf1\xdc\xd2\x36\x56\xbb\xc0\x24\x0e\xa4\xc3\x5f\xac\xa3\xfc\xa9\x23\xa7\xe1\x21\xd0\x52\x44\xd2\x47\x10\x4d\xc8\xb6\xe4\x3a\x10\xdc\x0a\xa7\x3b\x58\xaf\x31\x49\x4c\xfd\x3d\xe2\x60\x0a\x99\x74\x2c\x09\x2e\xa2\x75\x41\x3a\x05\x8e\x2c\x6a\x5e\x4e\xce\x97\xbf\x22\x18\x71\x81\x59\x2c\x44\x8a\xf4\xd6\x19\xf3\x43\x81\x3d\x74\x59\xf4\xb2\x34\xe7\xcc\x05\x0f\x41\x22\xdc\xbf\x21\x15\xb4\x86\x47\x7e\x32\x95\x86\xd5\xc2\xaf\x4e\xce\x67\xf7\x2c\x59\xb2\x0d\x3e\xac\xd9\x08\x52\x60\xdd\xd1\x48\x6f\x28\xdd\x5b\x61\xf6\x9e\x62\xf9\xda\x13\x23\x10\xaf\x36\x91\x9a\x2f\x19\xc8\xad\xd5\x07\xc9\x82\x8a\x3d\x32\x99\xda\x18\x6c\x94\x02\x1a\x20\xeb\x92\xa6\x59\xb5\x9a\xa5\x9a\x23\x52\xea\xfc\x99\x35\xc0\x6f\x60\x32\x7c\xfa\xb8\x08\x63\x16\x90\x99\x2c\x9a\x82\xad\xcb\xa0\x90\xe7\xa2\x9e\x1b\x91\x96\x95\xef\xda\x06\x74\xf0\xc7\x36\x6d\xcf\xc1\x2b\x4b\xa3\xd2\x7b\xc1\x9b\x82\x91\xf9\x19\x1d\xdb\xab\x08\x00\x38\xab\x2c\xd9\xfb\x01\xf8\x58\x0e\xdb\xfa\xee\x34\x0a\x48\xfe\x7a\xbc\xdb\xa8\x56\xe8\x58\x1d\xda\xee\x59\x5a\x65\xd0\x89\x19\x1a\x60\x40\x8a\x80\xa8\xc2\x26\x5a\x9e\x90\x3d\x3f\xe2\x41\x22\xcd\x0e\x1b\x75\xe0\x4b\xd4\xfd\xb5\x9c\xba\x60\x20\x81\x5f\x1c\x35\xb6\x0f\x1a\x09\xef\xb1\xd5\xd7\x7c\x09\xf4\x05\xb3\x74\x01\x09\xf4\x00\x47\x6d\x72\x49\x24\xd6\x11\xf5\xaf\x51\xa2\xfe\x8b\x71\xff\x6a\x83\x51\xaa\xa6\x41\x89\x87\x56\x3f\xa1\x7f\x9c\xfd\xfb\x28\x17\x5e\x84\x7b\x93\xe8\xa7\xca\x79\x06\x68\xfd\x0c\x70\xf6\x82\x37\x98\xa2\x9f\x61\xca\x13\x46\xef\x5f\xe3\x24\xdf\xb9\xab\x3b\x49\x2e\xaa\xf2\x9c\x96\x03\xa6\x5e\x0e\xd8\x79\x72\xd0\xd5\x5f\xf3\x31\x42\x4e\xcb\x70\xd5\x47\x95\x14\x99\x70\xac\x1a\xd9\x74\x3a\xba\xc9\xb1\xf2\x45\x5c\x06\x94\x7d\xc4\x67\x5c\xd6\xa6\x92\xba\x0c\xfb\x0c\xd2\x3a\x1b\x47\xc1\x15\xa3\x78\xac\xcc\xc1\x60\xf8\x60\x60\xbf\x72\x84\x68\x1c\x7f\x2d\xdd\x07\x93\x9a\xc5\x34\xaa\xf1\x7d\x0d\x76\xe3\xf8\x68\x7c\x86\x10\x80\xec\x3b\x56\x8d\x31\xca\x9e\x44\x40\x40\xc7\xc2\xff\xec\xd8\xb1\x77\xba\xaf\x69\x96\x30\x04\x82\xb7\xd6\x63\x17\xad\x29\x69\xe8\xe1\xb3\xa4\x5f\x25\x9a\x8b\x9e\xc4\x76\xed\xec\x4e\xc2\xd5\x84\x4f\x8b\x11\x2f\xc4\x88\x17\x62\xd0\x15\xbd\xc5\xd5\x84\xd5\xe2\x08\x31\xe2\x85\x58\xcc\x4a\xa5\x0a\x9c\xa8\xca\x31\x4a\x96\xbf\x70\x7b\x62\xfd\xcb\x80\xba\xc2\x48\x74\xe9\x96\xa3\xe0\x3f\x7e\x16\x88\x07\xd3\xc6\xc4\xdb\x5f\x35\x8d\xff\xda\x83\xd7\x30\x1d\x12\x44\x87\x8d\xd8\xb7\xc9\x6e\x8b\x52\x0d\x90\x7d\x8b\xeb\x61\x23\x0e\x00\x44\x84\xc2\xc8\x88\x4a\x3c\x8c\xba\x59\x26\x82\x80\xb2\x20\x74\xc3\x0f\x1e\xdc\x2d\x05\x11\xa5\xb4\x2e\xe9\xef\x0d\x38\x65\xea\x4a\x39\x31\xd7\xf1\x78\x7f\x7e\xb8\x8d\x1f\x3c\x1f\x8f\x71\x19\xed\xa7\x2f\x93\xf8\x17\xec\xfd\x99\xfb\x7b\x8c\xda\x10\x9c\x2b\x2c\x96\xc9\x58\xa4\xc8\xfa\x7b\x38\x86\xe2\xc7\xe8\x37\x28\x85\x63\x53\x12\xbe\xd4\x0c\x16\xd5\x9f\x90\x26\x60\xe0\x80\xd9\x3f\x1c\xfc\xe1\x17\x20\xa2\x97\xf6\xb3\x95\xb9\x06\xd6\x2c\x6b\xa4\x5e\xee\xbf\x38\xe1\xe3\xc8\xae\xdd\x67\x17\xc6\x45\x66\xb4\x7e\x96\x5d\xfc\x60\x0c\x97\x07\x2d\xc1\xb1\xdf\xbd\x0f\xef\xc2\xe2\x5f\x8a\x9e\x1a\x52\x76\x06\x94\xed\x9b\x34\xd2\xe5\xed\xe5\xa3\x6f\x38\xb1\x79\x11\x7d\x61\x9a\x22\x6c\xf3\x06\x59\x2c\x48\xd7\x5a\xd4\x86\x20\x23\x8b\xf8\xd3\x64\xf4\x3a\x03\xad\x5e\xe1\xd2\x8b\x27\x49\xa0\x88\x0f\xb6\x12\xac\xde\xe1\x73\x7f\x5b\xd6\x77\x4a\x42\x7d\x74\xe7\x71\x93\x53\x1d\x2d\xdc\x85\xd7\xb6\x1e\xdc\x7a\xfd\x3c\xfd\x6c\xd5\x00\xf7\xb8\xa9\x00\x9c\x81\xa7\x36\xb5\xee\x3e\x2d\xff\xee\x0f\xe5\x95\xc1\xf0\x69\x3e\x1b\x0c\xaa\xc3\x0e\x63\x5f\xb5\x7b\xe3\x2d\xf6\x08\xf7\x22\x25\xa3\xd2\xa9\x5e\xee\x8c\x04\x0e\xf9\x05\x09\x9a\x84\xc8\x04\x46\xca\x24\x24\x98\xd5\xe6\xd0\x4a\x8f\x25\xd2\x5c\x64\x9e\x6e\x5e\x6a\x66\xd5\x66\x20\x65\xcc\x6a\x6b\x35\x46\x8f\x74\xc8\x1d\x95\x1e\xa7\x52\xee\xbf\x70\x09\xf2\xe5\x12\x57\x38\x9b\xa7\xfc\xf3\xb0\x81\x38\x38\x50\x4f\x2e\x51\xf0\xa1\x38\x3e\xa7\x16\x4a\xf1\xe0\x43\x6a\x7f\x94\xba\x51\xc3\x90\xba\x46\x4c\x72\xc1\x70\x57\x87\x2a\x53\xfd\xac\x5e\x4f\x2f\x9d\xf3\xc1\xe0\xad\x20\xfd\x93\xca\xae\x75\x8e\xd4\x41\x6f\x55\xce\x9a\x98\xd0\x7e\xd4\xea\xea\x11\xb5\x9f\x99\x9f\x2e\x4a\xee\x02\xb8\x3e\x20\x69\x4e\xdd\xdd\xd5\x9d\x5f\x84\x27\xd3\xd3\xe7\xdc\x7b\x1d\x04\x81\x37\x3e\x89\xbd\xa0\x59\x0f\x2f\xd4\x6f\xd8\x3e\x6d\xdb\x28\x40\xef\xac\xde\xfc\x0a\xfc\x14\x9e\x75\xdc\x8d\xc1\xe3\x1e\x44\xe2\xd6\x0b\xa9\x78\x2a\x03\x57\xc1\x08\x4f\x2c\xf6\x84\x87\x23\x0f\x4c\x53\xe2\x51\xca\x35\xac\x19\x69\x30\x93\xd3\x4a\x59\x8b\x3c\x76\xbe\xec\x61\x5a\x53\x74\x70\x00\xf4\x3b\x27\x5c\x0a\xa5\xf3\x97\x42\x42\xd6\xb4\xc9\x29\x94\x87\x20\x21\x3b\x3c\x78\x2a\x3e\x8d\xe4\x0b\x2d\xb7\x01\xcc\x98\xd2\xfc\x8a\x21\x67\x2f\x2f\x7b\xf8\x66\xcf\xae\xa3\x8c\x29\x79\xe3\x0b\x6b\x9e\xd2\x5b\xca\x57\x0f\x18\x3c\xe4\xf5\x16\xe3\xa3\x63\x5d\xbd\x5b\xa4\x5a\xd3\x23\x74\xca\x8c\x52\x83\xd5\x7a\xf9\xcc\x47\xa0\xdd\x66\xeb\xfb\xfa\x49\x37\x46\xcc\x58\x60\x5f\xda\x6a\xec\xd7\xb5\x0b\x26\x5f\xfa\x48\xaf\xa9\x37\xab\xe8\xbe\x03\xf2\x16\xb5\x6d\x35\xc2\x90\xf2\x0d\x5e\x77\x45\x48\xce\x4e\x91\x7a\xa1\x2d\xdc\xe6\x70\x5b\xa5\x27\x3a\x9c\x95\x70\x66\x33\xf2\xf7\xcc\x7a\x85\xee\x29\x8f\x5a\x11\xd2\x1c\x4a\xb5\xe9\xba\x82\xa3\x39\xb3\x31\xd0\x5e\xb6\xfb\x26\xca\x87\x6b\x4f\x83\xba\x21\xc3\xde\x98\x02\xc4\xef\xc1\x03\x34\xac\x17\x2c\xe4\x5e\xe0\xe8\x89\x83\x20\xef\x22\x7f\x99\xd1\xb7\xeb\xf0\xad\x83\xc0\x9f\xcb\x9f\xbb\x9b\x0e\x67\xc7\xb5\x48\x84\x87\xb1\x75\x58\x33\xc4\x62\xd6\xde\xbd\x82\xf6\xc9\x0d\xdf\x1e\x3f\xd6\x6e\xf8\xd8\x8d\xf0\x23\xe2\x07\x0b\x78\xf7\x09\x38\x8b\x3e\xce\x66\x43\x7e\x8a\x2d\x44\x61\x2c\xf2\x68\x15\x1a\x44\x3a\x46\xfe\xf7\xd5\xf6\x6f\x1e\x80\x0a\x78\x83\xfe\xb1\xe4\x06\xda\x57\xd7\x1f\xf8\x0d\x5e\xd0\xba\xa8\xf7\x91\x8f\x70\x82\x43\xfd\x05\x92\xe0\x50\x35\xb3\x68\x23\x49\x7d\x70\xfc\xf4\x2a\x36\x74\xf1\x30\xe0\x2f\xb5\xc3\xe3\x25\x67\xf7\x92\x4c\x87\xfa\x8d\x1c\xce\x74\x98\x0b\x6f\x8f\xb9\x30\x70\x80\xf2\xb9\x0f\xc2\x7b\xc0\xdd\x78\x18\x44\xc7\xbe\x83\x6c\xdc\x24\x12\x8f\x1a\xe5\x56\xcb\x25\x52\x09\xd6\xa1\x22\x50\xe5\x11\xe9\xd8\x26\x85\xee\x8b\xb2\x71\xf2\xda\x1c\x97\x77\x1c\xbe\x79\x4a\xdd\xfd\xee\x6f\x7d\x05\x87\x25\xb2\xa5\x89\x6c\xf5\xc3\xe5\xd8\x63\x13\xc0\xb2\x30\xce\xf9\x10\x92\x7b\x29\xa7\xac\xfb\x29\x39\xce\xa7\x13\x31\x2c\x83\xf6\x09\x35\x90\x90\xdb\x9e\x80\xd8\x74\x12\xef\xc6\xa3\xd5\xa1\x0e\x68\xfd\x1b\x5b\xe1\x0a\x1b\x49\xc7\x9c\x37\x69\xdc\x1d\x66\x4a\x7d\xbd\xb7\x9d\x77\x33\x89\xed\x07\xb8\x1e\xf3\x75\x2e\x4f\x23\xa2\x5a\xd5\xe1\x7e\xd6\xc0\x5e\x1c\x45\x72\xd8\x8c\x6e\x19\x10\xc9\x19\xa5\x94\x56\xf3\x98\x29\x5a\x62\x71\xea\x49\x04\x04\xce\x43\x06\x0c\x08\x2a\x3d\x03\xe2\xbb\x48\xd4\x2d\x73\x41\x16\x88\xf5\x3e\x4b\xe0\xb1\xd8\x1c\xef\xf6\xac\xf7\x66\x8e\xa3\x4b\x1e\x9c\x80\xbd\x50\x9b\x83\xf9\xba\xc0\xc8\xd1\x8c\x72\x6b\x18\xb1\x44\x5c\xe9\x51\x00\x89\x84\x53\xca\xf8\xa3\x9b\x66\x91\x47\x4e\x3e\x7d\xd4\xe5\x24\x45\xcf\x99\x8d\x77\x92\xe0\xd2\x61\xf0\xab\x61\x70\x79\xd2\xaf\x57\x40\x46\x3d\x58\x03\x32\x18\xd1\x75\xef\x65\x3a\xea\x3a\x9d\xeb\xfd\x98\xce\xe4\xf7\x36\x81\x6e\x1d\x8e\x2b\xd2\x84\x20\xa2\x55\x3a\x9c\x9c\x25\x17\xf1\xc1\xa9\x4d\x69\x02\x38\xbd\x89\xc4\x70\x00\x52\x15\x00\x57\x67\x74\x82\x2c\x3c\x0e\x4e\x1b\x5c\x85\xc6\x61\xf7\x3e\x0b\xb2\x62\xe1\xc9\x24\x78\x33\x09\x9e\xc4\xa3\xb1\x5d\x70\x1d\xc5\xa3\x39\xf6\xe3\x8f\x58\x5f\xbf\x84\xe6\xb8\x2d\xb1\x29\x6c\x6e\x9d\x5c\x25\xe1\x58\x56\x21\x65\xc4\xc8\x70\xa8\x7a\xcc\x70\xc0\x38\xc4\x36\x3e\xf8\x15\xd7\x6a\xc2\x48\x37\x7a\x76\xe5\xb4\xfb\xdd\x91\xf9\x32\x0a\x9e\xa4\x7b\xc0\xaf\x40\xd6\x2e\xe0\x01\x99\xde\x2f\x2f\xdd\xc5\x53\x0e\x7e\x85\x7a\xfa\x43\x7a\x1a\x2c\x01\xef\x78\x67\xc2\x24\x7e\x0f\xfb\x14\xcd\xff\x55\x62\x33\xc4\xee\xa7\xd4\x68\xfe\xb5\x12\x4e\x4e\xb3\x40\x2a\x52\xb3\x46\xa0\x68\x12\x01\xd2\x27\x0f\x5c\xd9\xd4\x23\x12\x03\x26\xb5\xe5\x36\xb8\x07\x5e\x00\xff\xc0\x5b\xc0\xf1\x06\x48\x40\x3e\x41\xf4\xd1\x99\x63\xef\x80\x79\xf0\x19\xda\x41\xcb\xe1\x1a\xd0\xdf\xfb\x37\x5c\x84\x25\x03\x50\xa3\x50\x7f\x9f\x70\x1d\x50\x7f\xf1\xb8\xb8\x82\x92\xad\xf2\x28\xf9\x03\x73\x29\xda\x9a\xd5\x95\x1e\xde\x4f\xf3\xc7\xcb\xfb\x8a\xaf\xf8\x73\x5b\xd1\xd6\xb9\x96\x3e\x90\x58\xbf\x19\x98\xbf\x00\x61\x5f\x2c\x43\x43\xf6\xaa\x2e\x5d\xe0\x3a\x5c\x7b\xf8\x02\x5b\xf4\x60\x1b\x91\xee\x2a\x32\x77\x5d\x50\x5f\x2b\xc9\xd8\x50\x5f\x12\xd4\x57\x91\x47\x69\x6c\xea\x0b\xb9\x1c\xcd\x63\xf3\x9f\xd4\xd7\x48\xfa\x59\xdb\xee\x79\xc0\x4d\x72\x69\xc7\xfd\x59\xf4\xf0\xb7\xad\xbb\xd9\x1c\x24\xe8\xbe\x84\x5a\x66\x0a\xe9\x6b\xac\x60\x0f\x5a\x90\x0e\x34\x70\x12\x83\x04\xa3\xc6\x1b\x58\xb3\x92\x61\x2d\x8f\xcc\x5e\x40\x2d\x67\xde\xea\x7a\x02\xa2\x0f\xc3\xce\xc1\xab\xb6\xb2\xc7\xd1\x1e\xf0\x34\x8f\xea\x93\x3a\x64\xf5\xd0\x99\xc0\xfe\x05\x3f\x99\x37\x23\x22\x41\x4a\x41\x15\x46\xf6\x69\xef\xcc\x1e\x14\x45\xaf\x7b\xf0\x2e\xa6\xa3\x1f\xa2\x63\x3a\x89\x83\x43\x74\x68\x0d\x9c\xa1\xc4\x23\xe1\x38\x8d\x34\x58\xdd\xe4\x7b\x3e\x4e\x07\x08\x28\xce\xc8\xeb\x8e\xa6\x74\xdf\xcf\x0b\xd8\x67\x53\x2b\x46\x55\x01\xcb\xd6\x49\xc8\x26\x7c\xbd\xb8\xef\x86\xf9\x93\x67\xf1\x19\xbf\x16\x53\x8d\x2a\x02\xdc\xe1\x39\x81\xd3\x7e\xc7\x8f\x8c\x4b\x06\x7b\x02\xf0\x8c\x42\xf0\x79\x1b\x6a\x9e\x11\xeb\xc5\xd5\x9e\x20\x93\x9e\xd3\x1b\x0c\x7a\x8e\xb1\x28\x04\x64\xa3\x47\x3c\xbc\x28\x3d\x8e\xfb\x75\x89\x03\x18\x62\xf6\x39\x7c\xf4\xce\xca\x6e\x15\x69\x43\x1d\xa5\x3e\x96\x24\x56\x56\x0f\xad\x1a\xd8\x7e\x26\x8f\x75\x14\xa6\x81\xde\xbb\x8c\x8f\x2b\x1d\xd2\x32\x07\xb2\xe0\x0e\xd4\x49\x4c\x3c\xea\x11\xa0\x9e\x41\x34\x6d\x26\x39\x5e\x49\x6e\xb3\x56\x8d\x98\x53\xea\x91\x49\x38\x3d\x27\x12\x71\x7a\x46\x25\x0f\x55\xab\x08\x56\x80\x2e\x80\x26\x7f\xe5\x43\x1f\x15\x48\x38\xd4\xb4\xd5\xe5\x67\xcf\xed\x02\x76\x46\xfb\x91\xed\xd2\x46\x0a\xf9\xd0\x45\x65\xf6\x91\xd6\xcc\x42\x1f\x87\xcc\x86\x5a\x06\x78\xe0\x3b\xe2\x08\x3e\x33\x3a\x34\xf8\xd4\x2e\xa9\xc0\x25\x9f\x2f\x8c\xf1\x7c\x4c\x54\xb0\x5b\x29\x20\x25\x1a\x4d\x8c\xdc\xd8\x84\x94\xd8\x0c\x25\x31\xaa\x09\x25\x11\xd0\xdd\xfa\x15\x9c\xf0\xbc\xfa\xa2\xbe\x17\xbc\x56\xaa\x4c\x1b\xbc\x7a\xc8\x2c\xfe\x64\x1a\x5a\x42\xad\x2f\xbf\x54\x50\x05\xdb\x80\xad\xed\xd3\x72\x06\x45\x79\x2b\x09\x7c\x50\x63\x23\xa5\x47\xfd\x0d\xc5\x35\x91\xa8\x82\x5f\xb1\x4d\x12\x8f\x6c\x92\x5f\xd1\xde\x1d\xc3\x57\x52\xd7\xa0\x4d\xbc\xd2\x13\x62\x72\xc7\xc5\xc9\xc3\xf1\x56\x1e\xce\x8a\x91\xfb\x50\xe9\x91\xeb\x1f\x29\xcb\x11\x7c\xda\x27\x3b\x22\xff\xee\xc7\xf3\x84\x2f\x1f\x64\xc6\x3c\xd3\x51\xc2\x71\x90\xbf\xea\x2a\x6d\xd2\x4d\xef\x32\x38\x0d\x80\xf2\x86\xdd\xef\xbf\xaf\xac\x1a\x68\x8d\xdc\xe3\x48\x2a\x00\xce\xd3\xfb\x3f\x8e\x35\xc2\x65\x45\x93\x5c\x60\xb6\xb2\x13\x9d\xd5\x3f\xbf\xbe\x78\x74\xd2\xc7\xef\x9e\xfa\xa2\xb4\x52\x3b\x63\x70\xab\x09\x05\x11\x7d\xdb\xb4\xd1\x01\x29\x88\xf9\xf9\xcb\x82\xef\x5c\x74\xce\xca\xfa\xa2\x56\x83\x9f\xc2\xf7\x30\x68\x0c\x2f\x13\xac\xe6\x16\x78\x0c\x16\x4e\xc3\x15\x7b\x62\xe5\x6e\x8d\x86\xd2\xeb\xad\x38\xe3\x1f\xed\x46\x61\x45\xcd\x50\xe8\x9b\x8f\x81\x7b\x94\x70\xfe\x7e\xdb\x40\x72\x16\xb1\x95\xa2\x02\x7a\xff\x08\x06\xef\x3c\x28\xab\x19\x15\x92\xf5\xb6\xab\x5d\x5b\xa0\x7f\xff\x8d\x77\x41\xb8\x77\x9b\x7a\xca\x28\x17\xe0\xca\xfe\x88\x29\x18\x11\x0c\x72\xc5\x0e\xc3\xb1\x03\x2d\xf3\xe8\x3e\x3d\xe2\xaa\xc6\xa6\x94\x65\xb5\x61\x3f\xbf\x7a\x74\x5f\xcd\xcc\xa2\xdc\x6d\x33\xcc\x2f\x2f\x66\xb6\x2f\x98\xe2\x4c\x70\x0f\xc5\xfc\x87\x77\x08\xff\x63\x29\x07\xd5\xda\x1d\xa1\x43\x46\x49\xa5\x27\x2c\xc8\x9d\x90\xa0\x8a\x8c\xb4\xe3\x1c\x31\xa5\xca\x2d\x17\xab\x54\x6c\xb5\x47\xa5\x0f\x88\x3a\xfe\xaf\x79\xc0\xc6\x7a\x8c\xf6\xff\x75\x26\x3a\xed\x9f\x9b\xf6\x79\x1a\xfc\xfc\x7f\x4e\xc6\x6b\xbb\x83\xd1\x3a\x43\x1a\xbe\xb6\xac\xfa\x3f\xa7\x04\xcf\x09\x1a\x17\x9e\x93\x18\x12\x0d\x1b\xc1\xcf\x49\x9c\x30\x27\x36\x3c\x27\x31\x94\x3b\x1a\xcf\x4b\xb1\x7f\x5e\x9e\x3c\x2e\x8e\xc4\x39\xfc\xc7\xdc\x10\x1c\x65\xff\xa8\xc4\xcf\x2e\xf8\xb7\xd9\x79\xf6\x27\xe7\x39\xd0\x55\x98\x20\x85\xf9\xe0\xba\x7f\x9b\xa1\x3b\x2d\xe0\x03\x76\x0b\x3f\x47\x8f\xe3\xca\xf2\xf8\x92\xa2\xdf\x74\xb1\xcc\x09\x12\xb3\xf3\x00\x2d\xad\x07\x38\x66\xc7\x17\x6a\x89\xbe\x43\xf0\x6e\xb8\xbb\xe8\x3b\x37\x48\x0e\xe2\x03\x3e\xaa\x27\x3a\xba\x29\x07\xb1\xf1\x36\xb2\x2d\xda\x13\xff\x31\xcd\x6d\x09\x0a\x32\x00\x43\x70\xb5\xc7\x10\xa2\x64\xa3\xd8\x28\x7c\x9a\x02\x24\x34\x5f\x62\xcd\x1f\x9f\xef\x97\x5c\x01\xce\xcb\x7f\x72\x49\x0a\x0e\x12\x2f\xd2\x66\xf2\x9d\x35\x83\x4e\xc8\x06\x10\x81\xd8\xe1\xee\x57\x87\x91\x53\xcc\x56\xaf\x27\x1d\x3a\xb3\x07\xee\xbc\xf4\xe2\xb5\xce\x54\x63\xd1\x0b\x27\xce\x6c\x5d\x51\x83\x8f\xeb\x26\x3f\x8b\x8f\x58\xf2\x97\x18\xcc\x5f\xed\xff\x0e\x6e\xdb\x85\x2f\x50\xee\xfe\xb8\xf0\x15\xa4\x9f\x6c\xc8\x56\xae\x26\xb8\x3d\xb1\x6e\x83\xc5\x80\x26\x0b\x39\x90\xe1\xf8\xce\x04\xc3\xab\xc8\xc5\xfe\x3b\x13\x7e\x37\x41\x62\xd8\x44\x8a\xcb\x4f\x0a\xd9\x51\x85\x93\x17\xfa\xd6\xde\x77\x5e\x85\x67\xde\x9b\xba\xa3\xf5\x99\x4e\xe3\x76\x6c\x9f\x31\xe7\xf5\x5e\xe4\x8c\xa1\x3c\x35\xbb\x4b\x3a\x39\x84\x4a\xa1\x7b\x06\x1d\x7b\xf3\x20\xfc\x61\x63\xbb\x92\x71\x9d\xae\x7c\x3a\x79\x22\x6c\x8b\x94\x69\x0a\x6d\xf7\x14\xe2\xb3\x98\x5c\x01\x43\x11\xed\x75\xd7\xc9\xb9\x6f\xfc\x1e\x93\xae\xca\x63\xd2\xe1\x24\x07\xb7\x52\x83\xcc\x62\x0d\x01\x53\x94\x60\x34\x45\xa7\x1f\xb1\xab\xc5\x23\x80\x8a\x04\x7c\x94\xbf\xca\x6e\x06\xaa\x98\x53\x31\xaa\xe3\x06\xfa\xf7\x8b\xb3\xe0\xea\xfb\xb7\xfa\x04\xc2\x2a\x4e\x00\x9a\x2f\xc0\x3d\xfe\x96\x9d\xd0\xf0\x36\xa2\x61\x33\x39\xcb\x6c\xb1\x9f\x0a\x42\xbd\xeb\xf5\xc8\x7a\xd6\xab\x25\x2a\xc4\x1d\x89\x09\x18\x9b\x2c\x28\x67\x13\xac\x23\x06\xdf\x6d\x8e\x43\x23\x10\xc2\x64\x4e\x7c\xe7\xf7\x59\xe3\x87\x4e\xec\x67\xaf\xd2\xd8\x2c\xf1\xae\xc2\x21\x79\x4f\xd3\x7f\xbe\x33\x1b\xee\x42\x06\x36\x1c\x07\xbf\x5c\xd5\x5e\xca\x1e\x91\x56\x03\xf6\x53\xd0\x03\xef\xbb\x88\x86\xdf\x04\x0c\x5a\x33\x55\xe0\x4e\xd2\x6a\x95\x8c\xd2\x50\xed\x51\x86\x60\xef\xe0\x1b\x11\x60\xce\x8a\x00\xbb\x52\x04\xfa\x8a\x80\x28\x5c\xd9\xd9\x22\x8a\x17\xd1\x22\x11\x23\x65\x19\xc6\x27\x5b\x15\x2d\x84\x73\x17\x2a\x40\xc0\x40\xd3\x29\x14\x4d\x45\xf9\xe0\x41\x33\x5d\x4c\x34\x5c\x31\x32\xf0\x34\xea\x52\x2e\xdc\x0e\xe1\xac\x0f\xdb\x00\x3a\xb8\x32\x7b\xc2\x2b\xf1\x01\x07\x53\x1b\xe0\x61\xb8\xad\xe8\xa9\x69\x71\xc9\x5f\x5f\x24\xfc\xf2\x22\x5a\xb7\x12\x6c\xf4\x04\x77\x90\x52\x8f\x7c\x2e\x4c\x68\x91\xa7\x4e\xb4\x84\x90\x25\x61\x79\x40\x2b\x9e\x2c\x5f\x94\x59\xd3\xb9\x94\x88\xf2\xfb\x8a\x2e\x26\x18\x4e\xf5\x1d\x4f\xcd\x2a\x05\x21\x47\x53\xe1\x6e\xf8\x37\x96\xab\xbc\x09\xcf\xad\x8b\x0e\x38\xa7\x8a\x85\xf0\x4f\x2c\x4a\xdb\xb6\x3e\x76\x76\xa7\x10\x57\x79\x4e\x2b\x00\x53\xaf\x00\xec\x3c\x05\xe8\x8a\xde\x2a\xf0\x79\x15\x86\xd7\x90\x71\x0a\x05\xa7\x96\x31\x52\x1d\x47\x55\x79\x38\x1d\xf3\xdf\x67\x77\x7c\x4c\x84\x9f\x6d\xac\xf4\x45\x1c\xb3\x31\xf1\xd1\xd3\x3b\x62\xc0\x35\xf1\x88\xf2\x63\xbd\xbc\x4d\x6c\xd5\x74\xde\x0e\xb7\x48\x90\x1c\xa9\x25\x11\x12\x5a\xc3\x20\x9f\x46\x26\x52\x73\x8f\xda\xe3\x01\x27\x58\x51\x81\x67\x77\x58\x8e\xb2\x26\x96\x37\x63\x4e\xf0\x56\x2c\x42\x81\x47\x77\xbc\x3d\xde\x64\xb7\x3a\xf6\x53\x66\xd4\xaf\x81\x62\xd4\x18\xe6\x5a\xad\x36\x4a\x8c\x41\x55\x1e\xa3\x4e\x27\x61\x02\xce\xb0\x9c\x3e\x5f\x10\x3c\x09\x88\x92\x4f\x83\xd2\x3d\x6e\xb6\xc2\xfb\x6f\x75\xbf\x5f\x37\xe5\x09\x76\xeb\xfd\x83\x70\x08\xbd\x08\xd3\x52\x89\x68\x99\x41\x6c\xd7\x44\xb7\x0a\xdb\xd0\x25\x1e\xb3\xc1\x40\x05\xa9\xd4\xd8\x7a\xde\x8d\x61\x6f\xa8\xc0\xd1\xfb\x92\xb0\x70\x9f\x2e\xbf\xc1\x1a\x58\x68\x9c\x51\x76\xbf\x33\x76\x52\xa2\x60\xb1\x82\x20\xbf\x29\x7b\x1e\x23\x96\x5d\xf1\xd9\xab\x7e\x43\x56\xc0\x78\x42\x7e\x98\x18\xf1\x24\x9a\x8a\xdf\x4f\x45\x63\x9f\xc8\x2c\x95\x82\x30\x25\xab\x67\x74\x3a\x10\x51\xe5\xc7\x56\xe4\xb3\xd9\x1c\x3c\x9e\xbf\x3e\xd3\x85\xd1\x9e\x98\xd8\xd6\x40\x2c\x40\xfb\x9b\xc5\x6d\x18\xdf\xc2\x2e\x4d\x79\xcb\x94\x26\x2b\xc9\x39\xfd\x95\x55\xc6\xe8\xcc\x6f\x7d\x83\x04\xa2\x4f\x2c\x10\x03\xbd\x25\x54\xfe\x13\xe8\x7e\x11\x0b\x0b\x33\x60\xf4\xde\xf0\x93\xb3\x61\x27\xf0\xf9\x80\x8b\x96\x88\x65\x53\x1e\xbe\x82\xac\x39\xa5\xfd\x88\x28\xb3\x53\x97\x20\x70\x17\x2b\x1e\x5e\xf7\x21\x1a\x09\x26\x4c\x30\x15\xb3\xc7\x8c\xfc\x51\xb3\x91\xe8\x3e\x59\x30\x29\x36\x60\x54\x04\x14\x1b\x20\xb8\x57\x7c\xb9\x81\x40\x28\x2a\x5f\xe0\x11\x46\xa3\x12\x87\x4c\x6f\x06\x46\x45\x84\xa5\x21\x69\xba\xd6\xc9\x2c\x1f\xb4\xda\x5b\x8b\xf1\xa8\xba\x94\xac\x25\x78\x54\x42\x9c\xce\xf3\x15\x1b\x9b\x63\x2f\x74\xf7\x63\x56\xbf\x2d\xda\xac\x8b\xa5\x48\x1e\x82\xb4\x33\xd0\xa2\x6f\xc9\x76\xd1\x6a\xb5\x3f\xe6\x15\xe3\x07\x0e\xe1\x76\xa3\xef\x74\xc0\x7b\x23\xfd\xf2\xaf\x04\xc7\x23\x3b\x3b\x20\x87\x9f\xe4\xdf\x12\xec\xf6\x18\x01\xbb\x9d\x22\xd8\xed\x0c\x6d\x32\x05\xe6\x33\x10\x2c\x42\x82\xf5\xd0\x81\xc7\x7a\xf8\x9d\xc7\xfb\x70\xbb\x9b\xb0\x1e\x30\x86\x6b\x06\xd9\xbf\xe7\x91\xb6\x71\x2d\x92\xf3\x04\x7f\x6a\x53\x40\x9d\x80\xb7\x7c\x35\x00\x68\xb4\x77\xf3\x58\xe0\x3e\x98\x78\x01\x57\xa4\x8e\xd0\x9c\xcf\xd3\xcc\x12\x9a\x7d\xb0\x22\xa4\x9d\x4e\xe8\x3b\xbb\xb9\x72\x8d\x08\x14\x93\xdf\x7b\xa1\xdf\x27\xb0\xdd\x34\x22\x3a\xb8\xe9\xef\xa2\x51\xba\x58\xfc\x77\xc4\x9b\x8e\x48\x8e\x78\x6a\xe3\xe3\x03\xc7\x44\x9e\xc3\x63\xc2\xcf\x05\x60\x98\x24\x24\x34\x8d\x89\xb7\x41\x46\xf9\x6c\x10\x7f\x5b\x34\x68\xd1\x22\xa0\x2d\xc1\x0e\x59\xe3\xb3\x43\x84\xb6\x68\x10\x1f\xdf\xd4\x16\xc1\x99\x26\x6d\x7d\x28\xb4\x25\x11\xbe\x95\x9a\x1a\x48\x17\xc1\xc4\x23\x6d\xdd\xe4\xdb\xfa\x99\xff\x56\x4a\x4a\x13\xb6\x8a\xb2\xf1\x16\x17\x47\xee\xd1\x92\xdd\x41\x41\xe6\x62\x0f\x13\x14\x24\xa3\x64\xda\x4a\x8f\x4a\xa6\x47\xe3\x09\x16\x62\x40\x9a\x81\x1d\xf0\x3a\x5e\x1c\x60\x3a\xf8\xae\xcc\xa3\xac\xf8\x40\x28\x8d\xf9\x2b\x16\x2e\x9e\xfc\xc2\x7a\xf8\xe5\xd1\x5b\x0f\xc2\x41\x70\xd0\xa2\x31\x8b\xb6\xc0\xeb\x2d\xa3\x41\x0f\x6f\x2d\x97\xf7\x01\x3c\xab\x5b\x3f\xf5\x8d\x46\x6a\xd1\xe1\x0f\x2b\x66\x4d\x5a\x39\xe1\xd8\x76\xa0\xe4\x31\xb5\x1a\xd0\x7e\xb3\x08\x63\x6a\xd1\xa5\x4f\xc2\x84\x96\x76\x41\xcd\xb7\x7f\xa4\x26\x04\x8f\x31\x31\x48\xc0\x98\xc0\xdf\x49\xa1\x9a\x21\x51\xf8\xdb\x19\xa5\xf1\xb5\xd3\xc4\x7f\x1f\xb8\x74\x20\x5e\xc5\x1a\x3f\x5e\x85\x8f\xff\x26\x53\x53\x2d\x66\x92\x3b\x86\xf9\x8f\xf1\x97\x9b\xc9\x85\xd5\x1a\xd8\x16\xc9\xc9\x22\xb2\x5e\xd2\x4c\x2e\x7c\x46\x65\x46\xb3\x3c\x34\x13\xf2\x73\x0b\xdc\xc9\x16\x7d\xa5\xe7\xb4\x05\xed\x6f\x16\xb4\xbf\x59\x40\x57\xf4\xd6\x82\xf7\x37\x4b\x84\x05\xed\x6f\x16\x0b\x25\xc1\x38\x0a\x12\x96\xd2\x3c\x96\x95\xd6\x7c\x7b\x7b\x34\x2b\xcd\x9e\xa6\xc7\x16\x38\x88\x66\xa2\x5c\xe9\x8f\xa4\xa1\x8d\xf9\xa2\x1a\x46\x88\xc1\xc0\x33\x55\xe0\x6b\xf6\xb1\xb4\xb3\x1f\xc1\xa8\xcc\x56\x90\x59\x03\x0f\x76\xff\xab\x79\xae\x99\x01\xd1\x9c\xe2\x0e\x09\x55\x09\xf8\x34\x18\x91\x86\x12\x8b\x2d\x24\xb9\x4c\xfb\x58\x72\x19\x7f\xd4\xdf\x3c\x9f\x0c\x10\xcc\xb2\x5c\x9a\x0f\x48\x68\x9e\x3e\x06\x67\xb2\x1b\x6b\xe6\xc7\xc5\xb2\x25\x9e\xe1\x73\xe2\x1e\x49\x18\x03\x17\x3a\x9d\x7d\x76\xd9\x7b\xf9\x03\x2b\xa6\x2f\xa0\x9a\x70\xb1\xf1\x1c\xe3\xba\x38\x01\xf3\xc2\x32\x61\x61\x4f\x9c\x17\xf6\xe5\x80\x79\x61\x99\x98\x98\xa6\x39\x26\xf8\xb9\x64\x8d\x7d\xfb\x88\xbc\x44\x47\x07\xb6\x45\x30\xad\x88\xbc\x78\xf9\xb6\x7e\xf3\xad\xea\xa6\xf5\xca\xd7\x25\x18\xe4\xab\x4b\x40\x2f\xa0\x68\x20\xc7\xf2\x69\x34\xfa\xfd\x0f\x1e\x03\x65\x90\x80\x81\x42\xe4\x9c\x97\xe1\xd0\x50\x6d\xf3\xfa\x06\xa3\x7c\xed\x04\xac\x7b\x8b\x25\x50\x87\xf0\x6d\xad\xf1\xe1\xa9\x50\xc3\xb8\x47\x32\xc6\xfc\x6d\x6d\xf4\xb7\x95\x0f\x6a\xfe\xa3\xad\xdd\x3e\xba\xe8\x35\xd4\x9f\x8f\xe7\x9f\x21\x3e\x90\xf3\x23\x42\xdb\x45\x9e\x36\xea\x17\xe1\x7b\xcd\x79\x3f\xc9\xbf\xbe\xee\x35\x5b\x5f\x61\x61\x4d\x3a\x29\x1f\xed\xe7\x46\xa4\x93\xa4\x54\xa8\x5b\x89\x6b\xc6\x4a\x19\x09\x83\x9c\x03\x9d\x28\xe0\xe4\x5c\x88\x76\xc3\x87\x5f\x80\x33\x26\x7a\xab\xde\x5e\x51\x77\xbf\xe8\x3d\x7c\x9c\x72\x8d\x9c\x99\xbf\xcc\x75\xc0\xf8\xab\x68\xdf\xc5\x31\x74\x52\x2a\x62\x3f\x25\xc5\xb8\x31\x34\x57\xe4\xa1\xd5\x40\x14\x70\x5a\xee\x37\xc9\xf8\x16\x41\xda\xa6\xf3\x4c\xb6\xcd\x7b\x65\x5e\xdd\xd8\x3b\xe4\xf0\x10\xd9\x5e\x88\x17\x04\x4b\x9a\x8c\xf1\xeb\x47\xe4\x2b\x2a\x2a\x90\x67\x04\xff\x8d\x8c\xf1\x41\x33\xf9\x6a\x5a\xf7\xa0\x71\x31\xe2\xab\x89\xe4\xe1\xa6\xbb\x43\xa4\xa1\x54\x68\x7f\x8f\x08\xf9\xe1\x32\x77\x30\x09\xbf\xd3\xa9\x43\xf8\x32\x11\x01\xae\x48\xf0\x99\x26\x1b\x4a\xef\xe4\xf1\x15\x49\xc0\x5f\xb3\x62\xd0\x88\x1f\x65\xf3\x9f\x66\x3e\x4c\xf2\x56\xe5\x91\xf8\xc2\xf2\xda\xe8\xe8\xfa\x0d\x8e\xd1\x61\x71\x29\xae\xbc\x32\x99\x76\x6e\xcd\x7c\xfa\x21\xdd\xf9\x1a\x5c\x7d\x12\xa6\x6c\xdf\xb1\x59\x2e\x3a\xab\x68\xd7\xb2\x9c\x76\x12\x3b\xe5\x23\xa4\x7f\x5f\x44\xfc\x0a\xa1\x32\xdd\xa1\xa2\x20\x4b\x50\x91\x87\x41\x1e\x64\x48\x08\x86\x2f\x50\x8b\xdd\x26\xa3\x02\x59\x2f\x4d\x17\x44\xc1\x67\xfe\x25\x06\x31\x90\x2c\x42\x15\x8e\x48\x7c\x51\x88\x48\xcc\x2d\x8b\x8e\xd9\xb0\x1a\xd1\x14\x93\xe2\xaa\x0b\x36\x3e\x53\x1a\x10\x9e\x78\x78\xfb\xa1\xb5\x72\xd1\x01\xc5\xd4\x1a\x21\x4e\xb1\xf1\x25\xc4\xab\xb6\xe4\x6c\x32\xda\xad\x33\x59\x34\x7a\x56\x67\x36\x20\xd3\x8e\x91\xe2\x0a\x9f\x01\x1e\x2d\x29\x75\x6c\x68\x76\x13\xea\x00\x4d\xa7\xdf\x26\xb6\xc7\x47\x6f\x67\x4e\x30\xc7\xbb\x1c\x25\x1d\x62\xcb\x86\x3e\x7a\xf0\x7e\x09\xb6\x2e\x5c\x53\x8f\xab\x5e\xe7\xb4\x8e\x1f\x77\xa8\xd9\xf9\xbb\xf7\x07\x92\x3f\xdd\x78\x12\xf1\xe7\x36\xb1\xe3\x22\xdd\x3a\x8d\xb1\xc4\xa3\xd3\x84\x88\xa4\x0c\xc5\xd2\x62\x96\x2f\x89\x46\xce\xdd\x9d\x7c\x11\x6f\x5f\xcf\x24\xb8\xca\xe7\xc4\x66\xa4\xdb\xe9\x7c\xf8\x36\xbc\x40\x33\xf0\x07\xe0\xd8\x0a\xd2\x91\xb3\x1f\xf4\x56\xfb\xc4\xb3\x5b\xaa\x8b\x11\x6d\x65\x2d\x53\x1e\x39\x8b\x7f\x7f\xca\xd2\x56\xaf\xee\xd7\x7e\xa6\x68\xd9\x21\xbb\x8a\xb7\x27\x05\x9c\x7b\x4a\x8b\xef\x1e\x94\x32\x2d\xa5\xed\xef\x11\x23\x1b\x87\x56\xa8\x75\x9c\x3f\xee\xa5\xa9\x7c\x0c\x7f\x53\x4e\x6e\x3a\x70\x45\x13\xf4\xf2\x36\x90\xde\x16\x46\x0e\xdb\x02\x5d\x1c\xfc\x0c\xd8\xe0\xc7\xfc\x6d\x84\x06\x7e\xc3\xb8\x69\x8e\x0c\xfd\xc1\x29\xef\x42\x72\x17\x31\x8e\x8c\x9f\xc7\xbc\x0c\xe8\xb7\xd4\xd7\xaf\x91\xc3\x41\x1c\xff\xde\xaf\x9e\xef\x77\x19\x60\x7f\xf4\x8d\xfa\x69\x20\xb3\xc3\x7f\xfe\x82\xe7\x0e\xc0\x2d\xf0\x02\xd8\x08\x1f\xd2\x2f\xa0\x57\x34\x6a\x58\x7e\x0a\xba\x30\x1b\xc0\x47\x24\x76\x1b\xad\x34\xf6\x8a\x80\xef\x12\xe1\xd6\xb0\x5a\x7c\xe0\x22\x15\x49\xd5\x48\x3b\xe8\x44\x4c\xb3\x78\x69\x7d\x7a\x66\x4c\x4b\x02\xe8\x1f\x1d\x6b\x23\xc8\xd9\x91\xba\xe5\xc0\x7c\xe4\xab\x81\xa4\x78\x8b\xf1\xea\x03\x90\xfc\xdb\x8e\xfc\x2d\xf0\x7d\x50\xbd\xe4\xcb\xb1\xb4\xf4\xfe\xc1\x43\xc7\x57\x81\x31\xa4\x06\x3d\xd2\xe7\xbf\x13\xfb\xb8\x13\xc1\x9d\xf8\xa9\xf1\x47\xf6\x2b\xa2\x8b\xec\xf8\x64\xdc\x1a\x52\xed\xb1\xea\xf5\xe2\xfe\x1e\x59\xb8\x3e\x5c\xaf\x34\x32\x4a\xba\xbf\x47\x19\x18\xc2\xee\x2b\xa6\xaa\x37\xf0\xeb\x31\x5a\x24\x54\xc7\xc5\x95\x09\x7d\x55\x71\x43\x48\x98\x24\x4e\x98\xbe\x54\xde\x61\x94\xc5\x5e\x31\x72\x26\x30\x14\x4d\x29\x1c\x3b\x01\x7d\x59\xd6\xb5\xfa\xe7\x77\x75\xad\x2b\x53\xbb\xdc\xea\x9c\x72\x66\x73\x59\x55\xaa\x0e\x74\x59\xb4\x64\xf2\xc9\x6d\xf0\xec\xa0\xfc\xd7\x96\x02\x35\xd0\x81\x3f\x1f\x4e\xae\xc8\x19\x06\x00\x98\x0a\x17\xde\xfb\x29\xa1\x75\x1e\x8f\xf1\xf1\x37\xa2\xff\x06\x77\x9a\x64\x01\xa7\xbb\x43\x43\x0d\x25\x9e\x50\x93\x0a\xcf\x8f\xd4\x6c\xa6\xa5\x52\x6b\x91\x47\xaa\xa1\x13\x90\x0a\x6c\xbe\x35\xeb\xb2\x75\xd9\xc4\xf3\xb0\x05\x64\xcf\x9a\xfd\xf4\xea\x5d\xfc\x7a\x4e\x6e\xaa\xa0\x4e\x92\x07\xe8\x88\x79\xdb\x46\xd5\x8d\x3c\x35\xab\xcf\x68\x35\x18\xf9\xcb\x49\x63\x56\x45\x6a\xf2\xb5\x24\xc7\xfb\xaf\xf7\x18\x9c\xed\x68\xd9\xc1\x3d\xae\x43\x5a\x62\xbb\xb9\xc5\xa7\x2e\xef\x5c\xf7\x1d\x18\x72\x62\x60\x39\x9d\xfb\xe0\x6e\xad\xab\x2f\x00\xbf\x5e\xbf\xf5\x7b\x8b\x62\xba\x62\xc0\x80\x17\x1a\xa9\xd5\x3d\x2a\x96\x34\x60\x9f\xb2\x13\xe2\xf7\xaf\x9c\x87\x4a\xc0\x71\x5d\x36\xad\x46\x8b\xcc\x1c\x2d\xa3\x65\x24\x21\x11\x11\x41\xd5\x9e\x08\x56\x42\x55\x7b\x24\xfa\x40\x04\x4f\x52\x20\x96\x8f\xe4\xb4\x35\x31\xf6\x91\xb2\x28\xfe\x2c\x4d\x1c\xc0\x89\xa8\x67\x62\x11\x7b\x7f\xc5\xec\x7d\xea\xa9\x84\xb6\x3d\x1d\x89\x51\x3d\x46\x65\x24\xe4\x0d\xca\x3c\xdf\xfd\xc6\xa6\x97\xd7\x2c\x9b\xd5\xc5\x1d\x76\xc4\xc7\xdd\xd2\x63\xc7\xda\xb7\xba\xba\xe0\xa9\x9c\x9c\xca\x71\x9d\x76\xee\x5c\x38\xfb\xf9\x53\xf1\x9a\x6e\xab\xe6\xcf\xe2\xcf\x02\x32\x1b\x7f\x41\xbe\x1d\xc6\x9e\xce\x70\x87\x68\x01\xfa\xa4\xd8\x03\x42\x41\x68\x94\x3c\x2a\xa8\xc4\x13\x65\x92\xc8\xe5\xa2\x62\x8f\x5c\xd3\xbc\x06\x6c\x13\xd5\x80\x04\x64\x12\x64\x0e\xbe\xf0\x0f\x0f\x2b\xc1\xeb\x73\x1f\xdf\x31\x12\x05\x30\x45\xbf\x30\xe2\xa9\xe9\x99\x3f\xd5\x80\x41\x2b\x37\xbf\xfc\x22\x98\x3a\xc4\x6c\x4f\x68\x13\x9c\x7c\x3d\x29\xe5\xbd\x57\x47\x4f\xcd\xb1\x57\x80\x8b\xdb\x4b\xaa\xab\x96\x9a\x40\xd2\xd4\xda\x31\xab\x22\x68\xe5\xc8\xe1\xa5\xad\x26\x2c\xf8\xf5\xfa\xdd\x9f\xb2\xa7\x4f\x29\xec\x12\x89\xa8\x7b\x0a\xed\x89\x2f\x70\x7d\x90\xa7\xe6\x72\xeb\xcc\x1c\xcb\xb1\x95\x1e\x8e\x8b\xd6\x46\x87\x55\x79\xa2\x75\x91\x68\x93\xdd\xab\xd4\x6a\xe5\xd5\x1e\xad\x1f\xf0\xac\x19\x56\x06\xc1\x7e\x0f\x04\x14\x69\x16\x1a\xab\x06\xfc\x8d\x54\x26\x63\x9e\xf6\x56\xcb\xc4\x96\xa0\x78\x50\xe5\xf9\x69\x7f\x96\x80\xcc\x5b\xa7\xef\x1c\xdc\x30\x65\x8e\x58\x33\x1a\xed\xd4\x2f\xb6\x63\xc1\xec\xbc\xee\x57\x6f\x74\xe9\x79\xaf\xdb\xfb\x47\xb6\x2e\x5f\x7e\x26\x56\x3f\x67\x50\x54\x6c\x1f\x72\x5f\xd6\xc7\xc4\xf3\x76\x13\xa2\x55\x4a\xce\xa5\x33\xf7\x53\x31\x68\xff\x0e\x0a\x46\xde\x3a\x62\xa7\x58\x0c\x34\x06\x83\xb2\xd8\x63\xd0\x80\xa8\xe6\x37\xdf\x01\xb1\xaf\x64\x5b\x77\x3d\x39\xe6\x55\x0d\xfc\xe4\xd2\x7f\xbc\xd6\x8a\xad\x5b\x1c\xfd\xf6\xd2\xb6\xb9\x85\x4f\x1b\x7f\x4a\x07\xa2\xbd\x6b\x8f\xbc\xf4\x12\x18\x3e\x91\x33\x4d\x18\x7b\x07\xb8\x62\xda\xb6\xdc\xde\xa3\x57\x6a\x66\x41\x9e\x69\xd9\x2b\xb3\x46\x12\xa0\x8d\x51\x3d\x2c\x21\x4f\x93\x0b\x74\xd0\xb8\x12\xc9\x6d\x23\xd2\x13\x36\x7c\x57\x25\x12\x05\x45\x47\xeb\x10\x33\x99\x20\xc4\xd2\xe0\x20\xbd\x9c\xae\xe6\x6f\x64\xfc\xc7\x8a\xfe\x53\x3b\x7f\x89\x6c\x5f\x05\x6d\x2b\x43\xfb\x71\x08\xf9\x73\x46\x11\xa3\xcc\x4c\x74\x07\x23\x6d\x90\xfa\xc1\x9b\x33\x9f\x09\x9e\x56\x39\xba\xaa\x4f\xc5\x84\xbe\xe4\xec\x33\xb3\x70\x50\xc7\xd5\xb4\xf6\x5d\x23\x08\xf2\x8c\x5b\x84\xe5\xf5\xc1\xf5\x89\x33\xfb\xce\xa7\xe7\xc3\x39\xf0\xc8\xaf\xd3\xb3\xb5\xf7\xc4\x43\x80\xfa\x06\xb8\xf7\x70\xf2\x48\x61\xef\x40\x3a\xe2\x5b\xa4\xc3\x63\x70\xfc\x47\x84\xb9\xc4\x13\x61\x0a\x0e\x16\x69\xb5\x00\xa3\x70\x8b\x14\x48\x43\x88\x4c\x54\x33\x3a\xf9\x93\xd8\xc0\x13\xd0\x36\xb4\xef\xe0\xc6\xa7\x1a\x30\xf1\xf4\xa2\x5e\x43\x27\x0d\x1c\x51\x15\x53\xa6\xb3\x59\xe2\x13\x5b\xb9\x7b\x2d\xa5\xc5\x93\x89\x52\xb8\x9e\xe4\x38\xfe\xfa\xb3\x13\xcd\xcc\x14\xb8\x09\xee\xdb\x94\x8f\x4f\x45\xb3\x66\x3f\x04\xe7\xbd\x73\xfc\xea\x60\xfa\x9c\x1e\x13\x70\x1c\x14\xe2\xe5\x3e\xb2\xdf\x23\x7f\xc8\xa4\xad\xf2\x9c\x36\x21\x7f\xc8\x84\xfc\x21\x13\xe8\x8a\xde\x9a\xb0\x3f\x64\x8a\x30\x21\x7f\xc8\x84\xfe\xe9\x2d\x06\x46\xaf\x93\x21\x16\xcb\xf4\x4d\xa7\x4d\x48\x13\x37\xf7\x87\x40\x80\xda\x45\xb4\xe6\x82\xa6\x72\x6a\x22\x7a\x57\x6b\x5e\x1d\x7c\xb2\x69\xee\xa4\x20\xf3\xc1\x51\xbf\x00\xd1\x2f\x83\x0f\x0e\x46\x6a\x18\xc4\x0b\x4a\xf6\xef\x1f\x67\xcc\x2d\x9f\x36\xde\x77\x0c\x88\xd4\x2f\x25\x60\xa4\xbd\x46\xec\x01\xe4\x07\xe1\x84\x5b\x5f\x04\x9b\x12\x28\x2d\x6c\xb0\xda\x62\xd4\x4a\x4b\x3c\x5a\xd3\x63\x84\x91\xb0\x0f\x7f\x91\x74\xbc\xce\x85\x6a\x7b\xf8\x48\x0e\xbc\x5c\xfa\x41\xe9\xb5\xc9\xba\xdc\xb4\xee\x66\xc4\xb9\x7e\xf0\xc8\xbc\x29\xe6\x0f\xca\xaf\x0b\x71\x6d\xde\x39\x7d\xb3\x47\xcc\x9b\xf8\xeb\x75\x18\x33\x77\x71\xe1\x4c\x12\xe1\x26\x9c\x79\xac\x27\x35\x7b\x12\x88\xad\x5d\x40\xe2\x97\xba\x21\x5f\xda\x4a\xd6\xd2\x34\xf4\xfb\x25\x72\x77\x19\xed\xd6\x9a\xf4\x06\xe4\x69\x4a\x24\x0a\x03\x43\xa0\xd2\xf4\xfe\xf2\x23\xcd\xae\x98\x43\x90\xb5\x20\x10\xc6\x57\x79\xfb\x7e\x96\x72\xf0\x73\xa9\x5d\x80\xa5\x73\x05\x2c\xdf\xfb\xae\x76\x06\xfc\x20\x91\x59\x93\xc8\x56\x7b\x2b\xf3\xd2\xe7\xf1\xac\x82\x31\xab\xd6\xe6\x97\xd3\x2f\x0b\x31\x2b\x3d\x51\xbf\xeb\x10\x89\x16\x62\x33\xa0\xcd\x52\x87\x58\xa2\x33\xd1\x16\xca\xd2\x84\x1a\x1e\xb0\x26\xc8\x9d\xbe\xc8\xa7\x00\xa3\x70\x81\x06\x61\x69\x4c\x66\x28\xdb\x1f\x3d\xb5\xb9\x6e\xcf\xd0\x90\x64\x10\x92\x94\x02\x1b\xaf\x9d\xd8\xab\xeb\xf1\x07\xb6\x1d\x3b\xf4\x4e\x6a\x97\xf3\xf4\x92\x5f\xaf\xff\x79\x73\xf9\xda\x82\x7e\x60\x17\xe6\x41\x0c\xea\xfb\x34\xe7\xd1\x89\x40\x89\xbf\x1e\xe5\x06\xc2\x93\x50\xe1\x4e\xa2\x17\xb9\x93\x08\xc7\x18\xed\xc6\x90\x2a\x4f\x90\x31\xe4\xdf\xee\x23\x9c\x4f\xbc\x8f\x08\xbc\x16\x70\x3d\xe9\x5a\x02\xfe\x16\xbb\x63\xa3\x6d\x78\x6c\x52\xdb\xf0\x96\x9d\xd4\x8f\xdf\x4e\xdc\x7f\xf6\x83\xad\x72\xe9\x0d\x65\xd7\x22\x8c\x8b\x2f\x9c\xb7\x47\xf0\xf4\x94\x10\x7a\x08\x80\x29\x27\x2f\xf2\x48\xfc\xf8\xa5\x7e\x7a\x1e\xbf\x96\x08\xa4\x47\x4f\x3f\xf3\xd8\xed\xc4\x83\x4b\x09\xfb\xd6\x22\x7a\xe2\x3a\x84\xb6\xea\xa8\xd9\xfb\xf8\x35\xc5\x83\x8d\x9f\xee\x93\x4b\xcf\x2b\x0b\x8a\x99\x6d\xc4\xaf\x86\x35\x42\xbd\xa9\x74\xde\x7f\x46\x34\x6e\x26\x78\xae\x65\xe4\x77\xe4\xdf\x70\x43\xc9\x79\x5d\x0e\xf9\xdd\xc3\xd7\x8e\x40\xbf\x97\x93\xf9\xff\x0b\xd6\xd1\x33\x1a\x4f\x91\x4a\x73\x7a\x91\x4e\xad\x96\x5f\x06\x68\x97\x74\x83\x22\x50\x05\x58\xa0\xa1\x1c\xa7\x2b\x2a\x70\xe6\x35\x89\x39\x16\xf4\x34\xc1\x40\x03\x78\x5d\xe0\x2c\xa3\xd1\x83\x95\x51\xb6\x34\xa7\x4c\x32\x40\xa6\x29\x2d\xd0\x0c\xd6\xd6\xc0\xba\xae\x8a\x88\xd0\xe4\x4c\x47\x6a\xcf\xbe\xf2\x7e\xfd\x74\x35\xd8\x5f\x66\xe8\x89\x5c\x37\xe6\xa1\xe8\x10\xb2\x13\xcd\x94\x95\x8a\x43\xfe\x8a\x54\xaa\x56\x33\xe0\x5d\xe6\x37\xa6\x91\x61\x18\xb7\x54\x99\xcf\x84\x44\xed\x03\x7d\x11\x23\x4f\xb7\xa8\x18\x8d\xf3\x88\xf1\x86\x96\xc9\x6f\x0a\x88\x75\xae\x80\xf7\xe2\x80\xf7\xf4\xc4\xe4\xc8\xe8\xe4\xe4\xe8\xc8\xe4\xeb\xbe\x37\x2f\x27\xa1\x37\x29\x91\x91\x49\xa2\x91\x91\x49\x49\xfc\x87\xfc\xcf\x77\xf1\x7b\xf4\x37\x34\x7e\x7a\x0c\xa2\xe9\xb6\xe8\x21\xa2\x49\xbe\x9d\x12\x91\xae\x4f\x63\x47\xc9\x8c\xfe\x59\x5d\x76\xf4\x8f\xb9\xbd\x65\xe1\x96\x85\xef\x8f\x7f\x67\xe1\x96\x45\x5b\x44\x0f\x7b\xfa\xff\xc3\x36\x1d\xfd\x21\x7a\x7e\xb1\x30\xa6\x68\xb7\x5e\xfa\xe8\x70\xd4\xc6\x80\xe1\x34\x1f\x4b\x33\xfa\x6f\x23\xca\x52\x1c\xd6\xc8\x24\x7b\x92\x35\x2a\xd9\x11\x69\x4d\x12\xd5\x44\x27\x25\xa1\x71\x24\xbf\x1b\x99\x92\x82\xc9\x26\x3c\x2c\x41\xfd\x35\x08\xfd\x85\x60\x1e\x5a\x98\xa0\xff\xee\xf4\xb8\xe6\xf8\xbf\xf7\x8b\xf3\x22\x98\x12\xc4\x19\xd2\x85\x3d\x39\x32\xca\x81\x79\x77\x29\xbf\xb6\x53\x60\xff\x8e\x28\xd4\x7f\x32\xa8\x85\xcf\xe3\x1a\xd7\x1d\x90\xcc\xd4\x34\xbe\x83\x68\x50\xed\xa1\x44\x1a\x11\x8d\xbc\x63\xc7\xf1\x0a\xe4\xdf\x11\xc5\x20\xe6\x71\xbc\x0f\xb0\xfd\x3c\xc6\x59\xcb\x24\x25\x9a\x88\x4e\xdd\x87\x8d\xab\x4d\x8c\xc4\xfc\x5e\xc6\xf5\x66\x8e\x89\x36\x51\x0c\xe2\x37\x03\x08\x99\x67\x30\xbf\x11\x9f\x8f\xed\x9f\xb0\x5f\x44\x6d\xda\xb4\x09\xf7\xf1\x37\x57\xc4\x96\x89\x66\x51\x51\xc8\x97\x53\x6a\x43\x29\x79\x28\xfa\xa7\x36\x03\xb3\x30\x47\x15\x7c\xde\x00\x91\x0f\x1c\x99\x6a\x16\x13\x9c\x01\x92\x48\xcf\xfb\x71\x2e\x61\x88\xf6\x64\x40\xaf\x8a\x4e\x6b\x61\x2f\x19\x5c\x98\xdc\x2e\x21\xcc\x11\x19\xe1\x6c\x11\x5f\x32\x24\x3f\xb5\x53\x5c\x54\x9c\x28\x3b\x3b\x29\x5e\x97\x1f\xde\xab\x5b\x6d\x6a\x37\x57\x6a\x5a\x4a\x82\x31\x3f\xb2\x57\xb7\x11\xe9\x05\x6d\x12\x30\xbd\xf3\x11\xbf\x77\x88\xea\x30\x96\xe4\x1e\xb5\x28\x02\x8f\x95\x10\x80\x87\x0b\x32\xfd\xe8\x19\x62\xa6\x25\x5b\xe1\x31\xce\x5e\x22\xe2\xba\x69\xa2\xf2\xba\xd5\x3c\x53\x63\xb3\xe3\x71\x64\x20\x5e\xad\x6a\xbc\x49\x71\x94\x64\x3b\x60\x10\x9b\xf0\x32\xb2\xa3\x6d\x99\x2e\x5b\xb2\xf4\xc2\xd2\x0b\xb0\x6e\xd7\xae\x5d\x14\x0d\xac\xe8\x7b\x1b\x1b\x1b\x48\x2d\x2a\xd5\x2e\xbd\x5e\x8d\xfc\x56\x87\xf3\x78\x36\x52\xb9\x5c\xc0\x7c\xd9\x54\x04\xf2\xcc\x05\x32\x7c\x53\x05\x46\x87\x9e\x7a\xc5\x30\x68\x81\xae\x9f\x6f\x9a\x16\xbf\x3e\x6c\x68\x5f\x4c\x7b\x7f\x44\xfb\x75\x44\xbb\x18\xd3\x8e\xcb\x4e\x33\x3c\xed\x67\x30\xed\xc8\xe2\x16\x63\x60\xa4\xfe\xe1\x1f\xaf\x36\x0c\x9e\xab\xe3\xba\x2d\x5b\x5b\x33\xe4\xff\xf0\x1c\x0d\xea\xb9\x6e\xec\x7c\xf2\x9c\x9a\x32\xe1\xb8\x30\x1c\x32\x2f\xa7\x24\xbc\x30\x9e\x21\x19\xcf\xc2\xe3\x51\xc2\x4f\x46\x24\x34\x03\x3b\x87\x9d\x5e\x6d\x1c\x38\xc7\x28\xb4\xb7\x74\x5d\xcd\x80\x2a\x8a\x05\xa9\x5c\x4b\xae\x83\x38\x9e\xc2\xf1\x8d\x2d\x28\x17\x8e\x4e\xb4\x30\x8c\xc3\x11\x0f\xe2\xf5\x19\x19\xd2\x22\x2b\xb0\x52\x8e\x0a\x5c\x49\xfd\x78\xc5\x63\xea\xc2\x8e\xc4\x2a\xd6\xd5\x54\x6b\x5e\xc4\x19\x7c\x59\xb1\xbc\xb0\xf0\x70\xac\xfc\x6e\xc6\xbc\x38\xcd\xd3\x6b\xfa\x34\x4f\x7e\xc6\xe4\x76\x13\x0c\xe3\xb3\xe2\xe3\xb2\x72\x62\xed\x39\xf0\x33\x5b\xab\xa7\x72\xad\xf1\x7d\xa6\x4c\xf3\x78\xa6\x4d\xc8\x89\x8d\xcd\xc9\x8a\x8b\xcb\x12\x95\x78\xa6\x4d\xf3\x94\x4f\xb5\x0f\x2e\x1b\xe8\x70\xc4\x65\xe1\xcf\xb2\xed\xed\xb2\xf3\xcb\xba\x2a\xf0\x17\xa7\x79\xf8\xcf\xb2\x90\x8e\x88\xe0\x5a\xb2\x0e\x61\x0c\x46\xb7\xcc\xe2\x60\x00\xa3\x2f\x92\x02\x29\xa6\xfc\x78\x45\xda\x7f\xd3\x4c\xcf\xc0\xed\x4d\xe9\x83\xe8\x6a\x3b\xc1\x38\x01\x37\x8a\x89\xe0\x09\xf0\x4c\xc3\x04\x24\xa6\xf9\x3a\xc3\x3a\x9d\xae\x22\x3a\x6d\x15\xa5\xa5\x82\x90\x3a\x60\x59\xad\x1a\xf5\x25\x11\xa6\x50\x40\xd1\x20\x66\xa1\x5d\x6c\xd5\x23\x1d\x4e\xb6\x72\xe6\xb6\x5c\x37\xb4\x77\xa4\xd9\x30\xb0\xdd\x80\x60\x51\x74\x4a\x92\x42\x26\x5a\x95\xd6\x7b\x90\x6c\x10\xe8\xba\x40\x91\xe4\x4a\x23\x6d\x03\x1b\x92\xd3\x6d\xbe\xfd\x42\x69\xa4\xe9\x66\xdb\x85\x56\x84\x84\x16\x6d\x18\xbe\xfd\xc2\x85\x35\x81\x53\x15\xe0\x30\x89\xc4\xe0\xfa\x20\xdd\x08\xcd\x40\x91\x38\x3a\x2e\x19\x6d\x1a\x83\x24\xe1\xcf\xc3\xba\xbe\x9a\x1a\x6d\x7f\x6b\xbc\x2a\x22\x2c\x25\x23\x35\xf5\xcd\x20\xd2\x97\x19\xae\xa7\x5f\x69\xfc\x16\xad\x1d\xd5\x6e\x06\xc9\x17\x4d\xe1\xdd\x08\xb1\x8b\x63\xa2\x5c\x4e\x17\xfd\x4a\x1b\xb8\xdf\xf4\xb5\xdd\x0a\x3f\x1c\x76\xce\xb7\xd6\x5e\xf1\xad\x35\x16\x7d\xd7\xbf\xd6\x7a\x2e\x79\xfe\xe2\xd2\x8b\xfc\x5a\x03\x40\x83\xbe\xb7\x1c\xe9\x2f\x31\xd6\x5f\x8c\x06\xcb\x37\xe5\xc0\xc2\xcd\x09\xab\x8b\x5e\x1e\xfa\xd1\x1a\xe3\xa0\xb9\xfa\x92\xe7\xd6\x91\xb5\x44\x53\x68\x4f\x63\x5c\xe4\x19\x35\xae\xe0\xa2\x60\x59\x39\xff\xa8\x1a\x3d\x9b\x76\x46\x90\x3d\x5f\x03\x51\xbe\x65\xfa\x3b\x59\x9c\xf3\x74\x60\x8f\xaf\x45\xb4\x3a\x87\x54\x08\xcd\x22\x5a\x9c\x88\x96\xba\xc6\xbf\x51\xbb\x8a\x5d\x6e\x64\xa1\x71\x78\x88\x88\x6e\x2e\x17\xd8\x6d\x6a\x40\x97\xc3\x4b\xda\x65\x75\x20\x5e\xf5\x22\xdc\xe1\x2c\x32\x7d\xef\xec\x6a\xa1\xfe\xef\x7a\x89\xa6\x3b\x22\x99\x94\x35\xc9\xa4\xde\x81\x6d\xe2\x22\x31\x10\x37\xc9\xe4\x7f\xad\x95\xbb\xb6\x96\xfd\xdd\xd1\x64\x51\xf4\x9a\x3e\x01\xaf\x13\xbc\x5e\x44\x25\xcd\x17\x40\xb6\xdd\x27\x93\xcd\xe5\x86\xd6\x70\xdc\x65\x16\x60\xc4\xda\x22\xb6\x8a\x65\x59\x83\x2c\x50\x6e\x38\x62\x60\x3c\x2a\x3a\xf4\xa6\xf0\xe7\xf5\xcd\x45\x67\xd0\x9b\x41\x7d\x9b\x49\x0e\x2f\xff\x73\x11\x6f\x7e\x17\xed\x41\x72\xe0\xdf\x63\xfc\x6a\x97\xd9\xb4\xe4\xf9\x4b\x4b\x2f\x71\xdd\xb0\x28\x08\xba\xee\xa6\x68\x2e\xfa\xae\x76\xb7\x1a\xd9\x43\x0c\xcd\x6b\x2b\xc2\x47\x22\x66\xcc\xcd\xd6\x70\x9f\xf1\xeb\x78\xd1\x5c\x9f\x9c\xfd\x1f\xf6\xbf\xff\x8f\xec\x6b\x34\xd2\x11\x93\x59\x15\x9a\x7f\x6c\x47\x68\xf6\x18\xb1\x4a\x52\x4b\xc9\x24\x3c\x62\xa5\x34\x53\x45\x55\xbc\x2a\xea\x33\x05\xa9\xa1\xf8\xac\x1c\x7b\x93\x1a\x0a\xd0\x77\x60\x1c\xe2\x4f\xcb\xc6\xdb\xa4\x6d\xb3\x5b\xa1\xa6\x8c\xc0\x6d\x5c\x6b\xa4\x8d\x64\x4f\x3b\x4d\x0c\x21\xee\x5f\x0c\x12\xf0\x8a\x23\x2a\xd2\xe1\x88\x8c\x4c\xb1\xa7\x44\x62\x43\x28\x3a\xb9\x3f\xbf\xd1\x61\xb3\xcd\x67\x07\x71\x54\x3d\x5a\x8f\x16\xa1\x0f\xb4\x03\x50\x2d\x29\xbb\xdb\xe8\x0c\x09\xc9\xa6\xa2\x80\x3b\x6a\x6d\x14\x1d\x95\x64\x94\xaa\xed\x52\x06\x75\x69\xc6\xf0\x73\xa7\x7d\xe6\xa4\xf9\xff\xc1\x9c\xb4\xfd\xcb\xe7\xf5\x3e\xe3\xf2\x86\xef\xcd\xaa\x64\xde\xca\x44\xfb\xb0\xef\xa3\x78\xf4\x2b\xd9\x8a\xab\x10\xd1\xc2\x67\xc9\x81\x76\xe7\x6f\xc2\x67\x64\x40\x91\x29\xc9\xf8\xde\xee\x1c\xe2\xd9\x7d\x34\x1e\x86\xac\xc8\x30\x37\x92\x45\xa0\xa7\x2c\xc0\x6d\x59\x6b\xa1\x2d\x4a\xb1\xc0\x38\xa2\xbc\xcd\xc8\xd7\xfb\x37\xca\xcf\x19\x40\xbe\xa1\x3d\xe9\x26\xd0\xa0\x7b\xbd\xa6\xc6\xcd\xd3\xe9\x37\xe7\x78\x9c\x31\x5f\xbf\x62\x64\x77\x44\xe0\x6a\xd3\x22\x9a\x66\x18\x33\x15\x06\xdc\x61\x6b\xc3\xe8\x30\xad\xbc\xa9\x67\x22\x94\x2e\x2b\xea\xdd\xfa\xaf\xfd\x03\xbb\xa9\x16\x93\x30\xdc\x74\xfc\x31\x22\xe0\xad\xa7\x6b\x6a\x9e\xde\xf1\x04\x3a\x00\x98\x8c\x74\x7d\x48\x63\x3b\x34\x9f\x92\xed\x44\x4c\x9a\x4b\x21\x98\x8c\xbf\x8b\xb9\x05\x1b\xa2\x1c\xe4\x79\x72\xa6\x0a\x24\xe8\xb9\xc5\x8d\x1d\x88\x1c\xa8\x76\x61\x87\x02\x3f\xec\xfc\x2f\xbf\x01\x48\x7c\x13\xf4\x63\x12\x4f\x59\x12\xbc\x2b\x4c\x45\x74\x13\x51\x0c\x88\x47\xbc\x79\xc7\x2f\x63\x68\x4e\x42\xfc\xc2\x15\xd0\xd1\xe3\xf2\xfc\xaf\xbc\x89\xe7\x59\x12\x99\x72\xd3\x27\x35\xab\xd1\x8b\x83\x08\x39\xff\x07\xd2\x39\xfe\xd2\xbb\xbc\xcc\x60\x1f\x05\x38\x1a\x2d\xf4\xc2\xc6\x59\x68\xb6\x14\xbb\x18\x31\x52\x52\x48\x47\xe3\x2e\xf1\x7d\x41\x07\xd0\xc9\x00\xf7\x4d\x1d\x46\xbe\x87\x78\x81\xbf\x27\xa6\xcc\xfb\x91\xb3\x77\x74\x2f\xf2\x05\x00\xc7\x51\x78\x2b\xc4\xe8\x79\x4d\xb3\x07\x66\x5b\x46\x1a\xd1\x93\xc3\x83\xe0\xfa\x71\xc3\x86\x8d\xe3\xf5\xe6\x45\x6e\x23\x33\x41\xd4\x91\xf8\x42\x8c\x74\x1f\xa8\xa0\x72\x1f\x61\x23\x7d\xd1\x47\x24\xf7\x17\x76\x19\xd0\xff\xff\x7f\x3f\xc7\x50\x0d\x88\xbf\x07\x1a\x7f\x17\xf8\x1b\xe2\x56\x1a\xd5\xea\x90\x10\x9e\xc1\x82\xaa\x48\xd3\xf1\x12\x1f\xd0\xd6\xbf\xbd\x6f\x48\x42\x4e\x53\x12\xf2\xa0\x96\xfb\xfa\x7a\x31\x09\x71\x12\xbd\x49\xaa\x12\x16\x5c\x67\xa1\xef\x7c\x9f\x47\x05\x68\x17\x3d\x9a\xbe\xc8\xa8\x88\xdc\x31\xd2\xc7\xe4\x8e\x76\x91\x07\xd0\xff\x74\x3d\xdf\x3a\x9f\xeb\x01\x66\x21\x5e\x47\x90\x39\x91\x6c\xc7\x90\x23\x64\x69\x38\xc5\x60\x56\xd2\xc8\x24\xb8\xfe\xf2\x65\xfc\x9d\x7a\x76\x22\x6b\xe5\xba\xf2\xdf\x11\x64\x1a\xcf\xd9\x4d\xba\x55\xbc\xf7\x38\xd7\xf5\x33\xd4\xff\x44\xae\x13\x73\x81\xc3\x7f\xd6\xec\xa5\x90\x16\x96\x30\xd8\x4b\xa8\xa8\x10\xbe\x4b\x2f\x46\x6b\x09\xee\xe3\xb6\x0f\x43\xed\x55\xc1\x2a\xe6\x53\xf1\x45\xbe\x3d\x9a\x72\x38\xf0\x3d\x96\x13\x7d\x0e\x2e\xae\x82\xf1\xb0\x4a\x3a\xe1\xaf\xf9\xfc\x3c\xb6\x65\x26\x70\x57\xd0\x98\x90\xbc\x38\x04\x3b\xf3\x5f\x27\x64\x99\x6f\x42\xfe\x0f\x32\x40\xe3\x1b\x6a\xa6\x8a\x6d\x8d\x68\x43\x16\xd2\x4e\x96\x03\xc8\x1c\xe9\x4d\xe5\xa6\x1d\x4f\x23\xf9\xa7\x72\x52\x1d\xab\xa6\x25\x88\x6a\x35\x1f\xbd\x64\x83\x54\x78\x8e\x51\xe0\x57\xd4\xe7\x2d\x91\x99\x59\x88\xf6\xeb\x7f\x9b\x83\x5b\x0e\x7e\x0e\x1c\xa2\x41\x11\xa9\x68\xe2\x7c\x73\x30\x12\x0e\xa3\x55\x8d\x92\x7f\xd5\x19\x23\x1d\xfc\x2a\x73\xc0\x7d\x82\xce\xe1\xcf\xad\x0f\x51\x14\x6b\x65\x2f\x21\x4d\x1b\x8d\x18\xdf\x56\x06\xfa\xe1\x63\x11\xd0\x0b\x37\x44\xde\xcb\x31\xe9\xbe\x9b\x6c\xa7\x18\x27\xfe\x89\xf1\x7d\xae\xbe\x0d\xcd\x94\x7f\xe4\x38\xdc\xb1\x28\x3d\xa4\x1c\xbc\x9e\xe4\xed\xfe\x7c\xcc\x84\x83\xec\xa5\x86\xd4\xd1\xf3\x61\x66\x03\xfd\xfb\xe1\x4f\xfb\xa0\xf6\x7f\x82\xfd\xe9\x4f\x1b\xd7\x50\x12\x4a\xb7\x17\xb9\x30\x2c\x10\x89\xb0\xfe\xd6\x12\xa3\x82\xb3\x62\xe3\x06\x2d\x43\x7a\xcf\x2e\x05\xbb\x20\x7d\x67\x08\x38\xf3\xd3\x5a\xe3\x6e\xbe\x26\x48\xe3\x0e\xb4\xb9\xc9\x10\x6d\x16\x2a\xda\x2d\x55\xd0\x6a\xa4\xfc\x0d\x22\xea\x20\x22\x4e\x45\x19\x30\x59\xce\xdc\x34\x6d\x76\x36\x6f\x21\xe8\xa3\x00\x3e\x86\x89\x12\xab\x68\x31\x1f\xbb\xcc\x60\x1a\x5d\x17\x41\x4b\x40\x65\x74\x4b\x6c\x0d\x14\x6d\x43\x4b\x26\x4c\xbb\x05\x3f\x84\xc7\xad\x99\x79\x53\xe0\x6f\xab\x72\xca\xfa\xf7\x60\x2f\x79\xcf\x25\xaf\x58\xfe\xf5\xaf\x03\x56\xcd\x1f\x0a\x59\x7a\x97\x71\xf8\xc7\xf0\x45\xb0\x66\xcd\xaa\xf2\x58\x44\xc3\x75\xc4\x9f\x8e\x88\x06\x3d\x65\xdb\x0e\x50\xdf\x98\x25\x00\xf4\xda\x29\x51\xc8\x15\x07\x03\x18\xc4\x9f\x0c\x22\x32\x5c\x51\xbc\xad\xe9\xc4\x89\x5a\x7c\x52\xc5\x05\x07\x28\xbb\xf7\x83\xae\xdf\xec\xa4\x07\xa7\x93\xe8\xb5\x3d\xd5\xa3\x67\x30\x37\x1b\xde\xde\xdd\xbd\x0f\xb4\x36\x34\x80\x03\xbd\x6d\x03\xca\x49\xbe\x23\x92\x9b\x6d\x64\xbc\xd6\xdd\x62\xbd\xde\x22\x52\xd6\xa3\xb6\x2d\x54\x10\xe9\xc7\x82\xc6\xdd\x94\x5f\x83\x93\x06\x31\x14\x4b\x14\xa3\x62\x50\x4f\x6d\xe8\x5c\x90\x8c\x81\x00\xe9\xae\x73\xeb\xb2\xa4\x61\xf0\xae\xaa\x63\xae\xab\x4f\x18\xbc\xdd\xb5\xc3\xe0\x39\xb5\x65\xa2\xa0\x8c\x0e\x73\x1d\xec\xa5\x0e\x7b\xaf\x79\x45\xa0\x5e\x93\xdc\xe7\x9b\xce\xbb\x36\xac\xae\x88\x0c\x7a\x77\x8a\xb3\x01\xf5\x3d\x03\x8d\xf3\x6f\xd4\xb7\x98\x0a\xdb\x8f\x06\xd8\x7b\xa7\x98\x61\x19\x7e\x80\x2c\xe9\x58\x88\xce\xc4\x15\x45\xb0\xda\x64\x46\xc2\x3b\xc7\xbc\x55\x0e\x36\xdf\xb1\x0a\x0d\xa6\x01\xdf\xe9\x41\xd4\xc6\x2e\xd4\x06\x2e\xa1\x1e\xb5\x8b\xa6\x95\x1c\xc0\x03\x50\x52\x0a\xd2\x8e\x32\x70\x00\x7c\x4b\x40\xe0\x50\x94\xc0\x35\xa0\x80\x0d\xcb\x80\x9a\x9e\x08\xef\x2c\x94\x4f\xac\x83\xac\x83\x56\xdc\xfb\x52\x47\x37\x78\x55\xf4\xa7\x39\x09\xfd\x8b\x1a\xde\xd8\x5d\x5c\x8d\xe5\x7d\x22\xe2\xd5\x04\xd2\x97\xea\x20\x91\x57\x06\x4f\x03\x8f\xbb\x11\x45\x0f\x01\xea\xdf\x61\x03\x7b\xe9\x01\x39\x77\xe8\x89\xe8\xb2\xb0\xf7\x11\x21\x11\x6e\x29\x2d\x57\xa0\x8f\xc4\x0a\xe5\x01\xf4\x90\x98\x3c\x44\x18\xca\xd7\x97\x61\xec\x82\xe0\x00\x97\x4d\xcf\x5a\xd2\x07\x94\xe4\x6b\xc6\xc0\x86\x31\x86\xd1\xc3\xe0\x91\x54\xd6\x02\x1f\x58\x63\x07\xf5\xf0\x6e\xa6\x7b\x8f\x58\x9e\x30\x06\xf0\x58\x0a\xe8\x95\x5d\x83\x68\xd1\x52\x21\xdb\xd5\x22\x3c\x64\x31\x62\x1a\x1e\xb2\xd8\x3f\x64\xe1\x2e\x0a\xc7\xd1\xfa\x13\x6e\x98\x59\xe3\xa7\x1c\x3a\x06\x1b\x7e\x07\xa7\xfe\xb9\xa6\x5f\x08\x1b\x66\x2b\x18\xdb\xf0\x5e\x0f\x2d\xec\xa5\xcd\x7b\x4a\x7b\x79\x53\xe9\x77\x08\xde\x46\x7e\xe3\x2d\x76\x1f\x7b\x1b\xd9\xc9\xf6\xed\x94\xb2\xad\x42\x58\xa3\x1e\x4a\x84\x9a\x0f\x46\x16\x25\xfe\x3d\x18\x0d\xd3\x1f\x8d\xce\x05\x84\xac\x92\xfb\x4f\x21\xfd\xdb\xc5\x6b\x04\x5a\xc4\x82\x9b\x5f\x7e\x68\x58\x0a\x54\x8b\xd5\x3d\x07\x0e\x9a\x51\x94\xdf\xb2\x4d\x59\x8d\x63\xf8\xac\x8d\x2f\x8d\x7e\x0b\x36\x1a\xd6\xed\xf0\x54\xd1\x57\xbc\xb6\x4e\x59\xbd\x3a\x77\x5c\x04\x0a\x7b\xf6\x28\xce\xfe\x33\xeb\x8d\xb7\xd7\xc2\x6e\xb7\xc7\x12\x7d\xf3\x13\xdd\x51\xe0\xbf\x7a\x97\x1a\xeb\xe9\x7d\x78\xa8\xe4\x54\x44\x98\x80\x3a\x78\x07\xad\xad\x1a\x72\x37\x56\xc7\xf6\x24\x3a\xc6\x72\x04\x3d\xda\x87\x92\x0a\xba\x45\xea\x63\x0f\x7e\xaa\xb9\x24\x30\x35\xf0\xce\x45\xd9\xb8\x99\xb0\xca\x01\xb6\xfd\x75\x49\x87\x9a\x28\xc9\x4a\xac\x2c\xe5\x05\x00\x50\xf1\x38\x8e\x93\xac\x4b\xa4\xb7\xf4\x01\x7a\x4b\x82\x5a\xc5\xef\x25\x81\x7a\x2b\x8a\xc4\x70\xc5\x03\xd4\x38\xa9\x32\x60\x8d\x02\x16\x50\x0e\xee\x84\x4e\xf0\xae\x87\xbb\x92\x40\xeb\x91\xaf\xd7\xe6\x2c\x7e\x01\xd6\xb3\x97\x60\x55\xc1\x2a\xef\x96\x86\x8e\xcb\x2e\x75\x9d\x3a\x85\xd7\x91\x13\x1b\x3f\x60\xd7\x8b\x66\xe0\x8a\x2d\xdb\xd5\xaa\xb6\x52\x50\x8e\xa6\xb7\x0c\x4d\x3b\x43\x7a\x12\xf9\x46\xc1\xcf\xb2\x95\x84\x4b\xe3\x3a\xd3\x14\x2b\xd6\x67\xc6\x64\x32\x73\x8f\x42\x76\x16\x30\x94\x01\x23\x98\xf1\x3c\xfc\x19\x3e\xfd\xa7\xeb\x6b\xd0\x65\x07\x53\x35\x97\x5e\x05\x7b\xc3\xcb\x8b\xe1\x07\xf0\xb7\x0b\x79\x20\xba\xfd\xe9\x3f\xb0\x7f\xed\x93\x27\x09\x92\xa8\xe8\xed\xb4\x54\x18\x1d\x0d\x70\x72\xaa\x4c\x50\x41\x4d\xa3\xc3\x0b\x89\x5f\x3d\xbe\x2c\x2e\x96\x7a\x28\xe2\x85\xca\xdb\x65\x39\xf8\xb6\xb7\x62\xd4\x4c\x2c\x52\xdd\xfa\x82\x20\xaf\x1c\xd4\xb7\x4f\x1f\xd8\x07\xeb\xd7\xcd\xa4\x9f\xcb\x54\x18\x95\xb1\xcb\x12\x1a\x2a\x0e\xae\x47\x3d\x50\x94\x5a\xe0\x65\xcf\x9d\x26\xb1\x58\x72\x50\x10\xe4\xde\x81\x35\xa5\x74\xd9\xc4\xa8\x14\x24\xd9\xa7\xe7\xa2\x71\x1d\x53\x0c\xaf\xc6\x44\x99\x33\x99\x7e\x6f\xbd\x64\x9d\xe8\x5d\x9f\x04\xba\x76\xb2\x65\x64\xb7\xec\x52\x30\x22\xf7\x22\xbc\x7c\xab\x7b\xfe\x26\xd0\x22\xfb\x79\xf6\xf2\x8a\x2d\x4f\xef\xf6\xce\x6f\x00\xa3\x4e\xe4\xe5\xbb\x92\x87\x5f\x5a\x0e\x2d\xb4\x68\xe7\x58\xb0\x66\xfd\x3e\x34\xbc\x24\xe4\xd3\x3c\xb2\xbe\xfb\x08\xeb\x1b\x10\xf1\x82\xc7\xf1\x02\xff\x67\x23\x62\xc9\x32\xa4\x0b\x6e\x91\xf5\x17\xbd\x5d\x2e\x13\xb8\x25\x27\xdc\xa2\x9f\xc0\x2d\x81\x5c\x72\xe9\x4e\x06\xd0\xc1\x5b\x98\x04\xd6\x97\x1b\xbb\x94\xbf\xee\xb8\x70\xfc\x65\x73\x03\xf8\x78\x68\x76\x41\x9b\x86\xe9\x2b\xcb\x27\xe0\xf9\xe8\x49\xea\x0b\x61\x59\xb3\x52\xf6\x9d\x06\x40\x83\x80\x19\x51\x50\x21\xe4\xbd\x02\xad\xc7\xc0\x5c\x69\x2b\x2f\xc8\xb4\xaf\xbe\x05\x6d\x23\xd0\xd8\x4d\xab\x11\xd8\x0f\xa7\xd0\x2d\xef\xff\x92\x53\xb9\xea\xf2\x2b\xd7\xce\xc7\x65\x77\x01\xda\xf8\x0e\x69\xfd\x87\x95\x3f\x5d\xd0\xa1\x6e\x01\x52\xaa\xef\x1c\xea\x06\x8f\xdd\x7b\xb3\xf7\x91\x93\x45\x3f\xae\x98\x11\x9b\x75\x1c\x3e\xc8\xaa\x19\xe0\x7e\x0e\xb4\xcd\x18\xd6\x17\xcd\xdf\xb6\xc6\x4f\x39\x05\xa2\x4b\x49\x45\xef\x66\x28\x80\x76\xa4\x7a\x50\x49\x86\x5e\x8e\x64\x08\x60\xb1\x14\xc2\xeb\xb3\x79\x2c\x0a\x5c\x96\x18\x49\x25\xa7\x8f\x01\x75\x1b\x81\x6d\xd6\xec\x2d\x1d\x80\xa9\x02\x1e\xf5\xfe\x01\xbb\x39\x01\x07\x54\xcc\xa9\x87\xef\xf4\x03\x4b\xc0\x40\x18\xe1\xbd\xf9\x40\x0f\x64\x1c\x96\xff\x2a\xb4\xf8\x5e\x24\xe3\xb7\x6f\x57\xeb\xf6\x81\x7e\xbb\x3c\x6a\xb5\x5e\x5c\x8f\x66\x44\x4f\xa9\xc8\xe8\xf5\xbe\x35\x20\x94\x8e\x8c\x0c\x48\x2a\xc4\x20\x80\xc8\x5e\xa0\xb7\x00\xf6\x86\xfe\x12\x6c\x38\xab\x1e\x37\x7b\x63\xcb\xa3\x0e\x98\xba\x8a\xbd\xf4\xc6\xee\xbc\xa7\x1e\x6c\x64\x6d\x05\x69\x43\x2b\xe0\xa9\x3b\x4c\x10\x16\x71\x24\x97\xeb\x51\x7f\x41\x54\xfa\x76\x4e\x82\xfa\xdb\xe3\xe1\x38\xbd\x54\xca\x0a\x6c\xc7\x6a\x43\x8f\x2c\x00\xbe\xe3\xde\xcd\xe2\x43\x5a\xf8\x14\x2d\xee\x92\x5f\x16\x34\x85\xe7\x3c\x12\xe9\xdb\x85\x93\x66\xd6\x3b\x51\xc7\x8e\xe7\xc1\xa7\x7f\xff\x62\x6d\x0d\x57\xc2\xb3\xb0\x2a\x09\xac\x02\xe5\x1d\x83\x19\x4d\xcd\x30\x78\x17\x19\x2e\xef\x1d\xeb\xb9\x05\x7e\x01\xbf\x68\x00\x03\x9e\x27\xeb\x7f\x0b\x1a\xff\x45\x42\x8f\x75\x27\xad\x56\x07\xed\x03\x55\xbb\x11\x07\x80\x5e\x82\xf7\x10\x40\x04\x33\xa0\x86\x12\x19\x75\x32\xe2\xb7\x39\x1c\x84\x01\x31\xb1\x4a\x48\x41\xec\x0f\xe1\x9d\xdd\x2a\x4b\xee\x04\x90\x91\xd5\x32\x83\xae\x1c\xd1\x02\x71\xbf\xa8\xfd\x1f\xbf\x20\x51\x5f\x53\x92\x94\x3e\x74\x1d\xd5\x38\x6e\xf2\xde\x81\x91\xd1\x91\x2f\xbd\xf6\x37\xbc\xfe\xf3\x8f\xbc\x8d\xd6\x78\x09\xf1\x03\xcb\xb7\x06\xd9\x05\x6a\x91\x08\xc8\xd8\xfa\x27\x09\xb7\x93\x5f\x95\x78\xb0\xc0\x6f\x0c\x01\xb1\x9e\x69\x78\x70\x13\x99\x1d\xde\xcf\x40\x7b\x60\xe9\x50\x6a\xef\x00\x8c\xed\x32\xd7\xbe\x71\xa5\x81\xb9\xe9\x85\xe1\x13\xe6\xdc\xfc\xa9\xfe\x50\x6b\x38\x8e\x8f\xcb\x79\x88\xc6\x5a\x4f\xd6\x9d\x91\xb2\xef\x55\x2a\x14\xc8\x03\x66\x69\x3c\xd5\xac\xb0\xd1\xb0\x01\x53\xad\xe5\x2d\x11\x5c\x7f\x93\x97\x76\x4a\xac\x17\xc4\x3b\x0a\xfc\x74\x19\x36\x5c\x8e\xa7\x2d\x17\x3f\x7e\x0f\x6e\xbc\xec\x9a\x78\x64\xd4\x80\x09\x50\x45\xdf\x7f\x30\x9b\x9d\x0c\x2e\xcf\x5f\xf9\x21\x1c\x06\x4f\x17\x81\x88\x94\x43\x40\x3a\xa6\xb3\x5b\x88\xa3\x20\xb5\x5f\xfd\x7b\x45\xef\x27\xed\x15\x48\xe1\x35\xdf\x2b\xf6\xc1\x86\x85\x01\x7b\x05\xfd\x69\xd3\x4e\x81\xdb\xac\x69\xfc\x8b\x6b\x87\xda\x0c\xa1\x62\xf7\x28\x28\xca\x12\x6c\x51\x1e\x14\x4c\xaa\xde\x3b\x74\x5c\x30\xd9\xba\x7c\x15\x8e\x88\x62\xc3\xe6\x94\x93\x51\xd1\x6a\x3a\x8d\x47\xba\xa3\x55\x80\x8d\xd2\x3b\x41\x9d\xbb\x83\x2b\x36\xeb\x8f\x72\x9b\x67\xf2\xf0\x32\xd9\x3b\x9f\xcf\xcd\x7a\xe5\xaf\x55\x05\x2f\x7f\x0b\xdf\x82\xdf\x3a\xef\xd3\x8b\x95\xee\xf9\x2f\x5d\x86\x9b\x9f\xdb\xd4\x2f\x48\xf7\x5d\xcf\x23\xef\xd1\x21\xde\x5b\xf0\x41\xe3\xa2\x5c\xf6\xaa\x90\x17\x8f\x71\x97\x10\x2d\xa1\x54\xc2\x4e\x99\xd9\x1c\xc4\x13\x62\x46\x06\x97\x16\xe9\x95\x83\x7e\xb5\x92\xdb\x04\x91\xd6\xa4\x4c\x02\x56\x94\x80\xfa\x9c\xe9\x02\xa9\x2b\x1c\xb4\xa1\xe1\xa2\x6e\x11\x6c\x98\xaf\x18\x39\xb3\x7a\x80\x6d\xe8\xfa\x15\xed\x93\x34\x85\x9e\x08\xa4\x43\x36\xee\x2a\xea\xef\x75\xd2\x1f\xb5\x76\xf4\xed\xe9\xbd\xbb\xff\xe3\xde\x0d\x23\x5f\xc5\x77\x9f\xb5\x88\x8e\x59\xec\x25\x9d\x9d\x63\xe1\x9f\x14\xa5\x11\x73\x2c\x50\x50\x7c\x7c\xf2\x77\xfe\xbf\x49\x1e\xff\x1b\xdd\xf1\x91\xbf\x49\xf8\xbf\xe1\xf3\x3c\x56\xc4\x6a\xd0\x3e\x89\xef\xb3\x00\xbd\x0f\x6d\x91\xe4\x3e\xcb\x8a\x14\xf6\x96\x5d\x40\x04\x74\xac\x88\x9e\x8c\x46\x67\x41\xdf\xfb\x9d\x7c\x0f\xfb\x47\x1c\x10\xf1\xdf\x75\xf2\x60\xd0\xb8\x06\x17\x92\xdf\x33\xe4\x89\x72\xfc\xaa\xc7\xcf\x79\x67\xe3\x67\x1b\xdf\x40\xb4\xf5\x26\x35\xbd\x65\x54\xb8\x5b\x2d\x63\x70\xaa\xb5\x4c\xc2\x49\x45\x6a\x20\xe0\xff\xf1\x75\xa0\xb0\x98\xd8\x49\x14\xa1\x9c\x66\x7b\xc3\xdf\x92\x60\xec\x3c\xf8\x0b\x3d\x11\xf4\x99\xd9\xed\x8f\x7b\xf7\xd8\x1c\xef\x73\x60\x07\xec\x46\xf1\x35\xd9\xb8\x10\x92\x23\xa5\xa7\xdc\x6e\x9b\x9e\x2e\xf1\x48\x15\xa5\x7c\xd5\x5f\x0d\xa3\x97\xea\xa5\x14\xa7\x95\x70\x92\x52\x0f\xa7\x66\x8d\x94\xb2\xb4\x29\x5d\x88\x54\xb4\xe4\x43\xbb\x2a\xf9\xea\x9c\x51\x7c\xbd\x36\xb1\xef\x1f\xc0\x50\x0a\x3f\xa4\x7f\xbc\x08\x5e\xa4\x2b\x18\xbb\x1d\x6e\x4a\x04\x2d\xe2\x20\xf2\x09\xc6\xc7\x79\xbf\xec\xa6\xbc\x00\xa4\x10\x51\x73\xfa\xea\xa9\x3f\xce\x80\x6f\xc1\x32\x88\x83\x5f\x98\xc6\x07\x68\xcf\xb9\xc3\x76\xa3\x12\x29\x17\xe5\xa6\x4a\xdd\x89\x96\xd6\x89\xad\x8b\x3d\xe9\xe9\xb1\x71\x6a\x45\x62\x62\x9c\x22\x2e\xab\xd8\x13\x67\x8a\x8c\x89\x09\x2f\xf6\xc4\x98\x74\x29\xc5\x1e\x9d\x46\xaa\x50\x88\x8a\x3d\x0a\xcd\xe3\xe5\x1f\x03\xa2\xe7\x9c\x3e\x3d\x95\x91\x29\x94\x50\xb5\xeb\xf0\x99\xaa\x2f\xec\x4c\x0d\x84\xb4\x2b\x52\xf8\x0e\x1f\x7a\x6b\xd3\x5d\x36\xe1\xae\xdb\xd5\x06\x00\xbc\x24\xa2\x44\x46\x13\x1d\xc6\x81\x0c\x57\xab\xee\x61\x6f\xcd\xb8\x3d\x66\x94\x2c\x6f\xef\xc0\x81\x43\xcf\x9e\x5e\x6e\x48\x8a\xef\x97\x70\x26\xf5\xe8\xdc\x6d\x89\x23\x5f\x7f\x10\xc3\x78\x83\x23\xbb\x2d\x31\xcb\x06\x8d\xae\xf6\xca\xed\x65\x1d\x74\xf0\x33\x31\xa0\x7b\xd2\xed\x5b\x0e\xa8\xea\xda\x36\x09\x18\x6a\x27\x8d\x9e\x30\x7d\xd4\x27\x57\x39\x76\x80\x2d\xa7\xf5\x72\xed\xab\xab\x17\x2e\x04\x6d\x6a\x8e\xdc\x88\xc9\xda\x3c\x3a\x93\xa1\x47\x7b\xaf\xe4\x8e\x2f\xcd\x4d\x5d\x49\xce\xe8\xc2\x84\x7a\x65\x06\xf4\x2e\x96\x6a\xe9\x8e\x8c\x06\x52\x99\xb4\xd4\x13\x6c\x50\xcb\x22\x64\x68\xba\x64\x32\xb1\x42\x61\x29\xf2\x28\xd4\x62\x6b\x91\x47\x6c\x7c\x34\xb0\xbf\x29\xfb\xde\x4a\x7c\x63\x1e\x83\x94\x8f\x67\x13\x3b\x6d\x78\x71\x89\xf1\xa9\xbe\x00\x5e\x9b\xc9\xce\x3c\xd4\xfb\x8b\x53\xde\xc3\xbd\xc6\xda\xc7\x96\xd1\xcc\x8e\x4d\x6d\x0b\xce\xc2\x97\x0a\xcb\x76\xa4\xec\x18\x55\xdd\xaa\xfb\x33\x1b\x9c\xeb\x97\x0f\x01\x47\xe3\x06\x3d\xbf\x16\x1c\x3d\x05\xde\xed\x3f\xa4\xe3\x88\xf4\x95\xe9\xb6\x3f\x3b\xc2\x95\x99\x49\xf0\x9f\xce\xd4\x13\x6a\xd3\xd3\x38\x02\x81\x1d\x47\xe2\xbd\xb5\xf8\x5c\x18\x68\x8a\x3c\x40\x4d\x52\x11\x8c\x7e\x53\x45\x20\x8b\x66\xf9\xa8\x30\x44\x4f\xce\x79\xb0\xf3\xf3\x1f\xd6\xc1\x2f\xde\x37\xbe\xb5\xe3\xe3\x97\x9f\x65\x73\x3e\x3d\xf5\x3e\x3c\xb3\xe9\xa3\x9b\x97\x7e\xc2\xd8\x4c\x34\x85\x1c\x1e\xb6\x8e\x60\x55\x59\x28\x97\x3b\x3c\x48\x89\xc5\xd5\xa8\xa6\x22\x28\xc4\x1b\x8a\x92\xd3\x72\x0b\x86\x61\xa6\x0d\x45\x7e\x28\xb3\x00\xde\x34\x05\x6d\x0b\x1d\x23\xee\x70\x7c\xdf\x04\xdc\xb8\xdb\xd8\x32\x1f\x01\xb0\xb4\xd7\x58\x70\x19\x53\x91\x74\xc0\x7e\x20\x85\x5e\x08\xde\xe5\x69\x01\x47\xef\x21\x6a\x6e\x9e\xba\x47\xf9\x70\xe6\x2a\x08\x0e\x4c\x8a\x3b\x04\x2f\x21\x35\x17\xc1\x21\x52\x38\x0e\x29\x0c\xb6\x14\x0f\x5a\xda\xb4\x9e\x9a\xe5\x5f\x90\xd0\x71\xe1\xdf\x88\xf3\x4c\x84\xdd\xfb\x7b\x22\xb8\x1a\x07\xc3\x1c\x74\x72\x9c\xb0\x62\x48\x1f\x43\x10\x6f\x9d\x24\xae\x31\xd7\x1d\x1d\xa5\x52\xaa\x94\xc5\x1e\xb5\x2a\x42\x85\xba\x51\xa9\x28\x73\x48\x88\xa1\xd8\x13\xa2\x61\x59\x8a\x54\xff\xf7\x25\xeb\x3b\x02\x0b\xab\xfb\x10\x36\x7d\x88\xac\xff\x8d\x3f\xa9\x02\xe0\xda\x8e\x7a\xc5\x7d\xa6\x22\xaf\x4f\xcd\xe4\xa5\xd1\xbe\x5a\x59\xe9\x80\xd9\x8f\xc3\xf1\x86\x4f\xaf\xfb\xdd\xb0\x6e\x79\x62\xb7\x9e\xd5\x5d\xf2\x72\x7d\x55\xb0\x96\xac\xe1\xe3\xf1\xe4\x13\x3d\xc3\x36\xf6\x45\x73\x75\x00\xd6\xb2\xd7\x88\x0c\x28\xa9\x18\xb7\x5e\xa1\x2c\xed\xa3\xe0\xd0\xe7\x78\x6a\xa4\xa2\x22\x7f\x05\x5d\x9e\xdc\x16\x3c\xd0\x1c\x1f\x4d\x6f\x46\x3e\x3f\x1d\x02\x5f\xb3\xb1\x9c\x0d\x8e\x9b\x07\xa2\x6d\xde\x0f\xfe\x88\x83\x37\xe3\x78\xb4\x9c\xfa\xf7\xcf\x9d\xe3\xf7\xd3\x01\x88\x37\x6d\x08\xce\x8c\xc5\x8d\x18\x53\xea\x51\x21\x86\xe3\xea\xa1\x26\xa1\xbc\x0e\xef\x2d\xb6\x06\x36\x21\xd7\x12\x63\xe9\xa1\xf1\x1d\xdc\xf5\x06\x08\x4e\x6b\x35\xd7\x36\xe0\x4f\x3b\xad\x79\xce\xea\x35\xbc\xf4\xa6\x34\x4a\x57\xd8\xf1\x20\xcd\x9e\xf6\x5a\xf7\x1c\xc4\xf5\x92\xd1\xdc\x5e\x26\xf1\x33\xf7\x49\x5f\xb3\xd1\x02\xdd\x45\x64\xcf\xea\xd6\xd1\x72\x4e\xc2\x32\x6e\xa9\x14\x20\xb5\x81\xb4\x29\xf0\xc3\x55\x3b\x82\xcf\xe0\x00\x78\xb4\x8b\x8b\x73\xf1\x51\x98\x4d\xcc\x31\x51\xcc\x22\x6f\x4e\xb7\x25\x89\x4b\x90\x40\xb8\x81\x2a\x11\xde\x69\x03\xf6\x82\x65\xdd\x7f\x28\x02\x27\xe0\x9e\x25\x37\x9e\x83\xef\xf1\xfb\xe7\x67\xa8\xcf\xfb\x24\xcf\x37\xc8\x2d\x37\xe1\xa4\x44\xbd\xc8\x28\x14\x08\xc7\xd8\xaf\xce\xc0\x9c\x44\x93\x51\x24\x26\x39\x89\x24\x1f\xb1\xf6\x42\x1b\x71\xc8\xa4\x5b\xe7\xc1\x30\x1b\x47\x8b\x8a\xb3\xbe\x05\x4f\x9d\xbf\x35\x49\xeb\x64\xc6\x0d\x5a\xed\x5d\xc4\xe6\xc0\x88\x94\x59\xb5\x85\x0d\x53\xc0\x95\x07\x27\xe8\xb1\x15\x1b\xc9\x98\x6c\xa8\xbf\x13\xa8\x3f\x15\xa5\xdb\x2b\x67\x55\x6a\x31\xa3\x14\x8a\x66\x3a\xfd\x98\xe5\x51\x02\x5e\x39\xf0\xf6\xb3\xd9\xe9\x9e\x20\xec\x3c\x7c\x38\x1c\x23\x93\xef\x85\x9f\xe3\x48\xb8\xe0\xcd\xe3\x18\x0e\xb5\x19\x9b\xba\x3c\xe4\xe1\x03\x3e\x06\x4e\xc8\x4d\x42\xbc\x2b\x69\xae\x1f\x68\x23\xd1\x0f\xf6\xc6\x07\xec\x06\xb6\x0d\xc6\x35\xa2\x42\xb7\x8b\xb5\xfb\x40\xc7\x5d\x58\x9b\x29\xd1\x9b\x1d\x7c\x30\x9a\xe0\xdb\xfa\xd1\x8d\x33\x34\x14\x46\xff\x8e\xc2\x52\x4b\x9f\xfb\xee\xef\x2d\xf0\xa3\x0f\xbf\xbd\x07\x86\x00\x31\xec\x03\xda\x9f\xfe\x86\x6d\x73\xf5\xdc\x71\xf8\xf9\xba\xab\x67\x40\x0e\xf0\xc0\xaf\xe0\x57\x9f\xbc\xb4\xf8\x3c\xae\x5b\x4e\xc5\xb3\xeb\x58\x0d\xd2\x18\x09\xdb\xe5\x8a\x7d\xa0\xd3\x6e\x8f\x5c\x6e\x36\x9b\xd0\xbb\x9d\x1e\x33\x8b\xfb\xde\xee\x61\x71\xd1\x03\x1e\x4f\x54\x08\x5e\xd7\xf1\x6b\x02\x9b\x98\x18\xc0\x18\xbb\xbc\x26\x33\x93\x0c\x62\xdf\x00\x8e\x8f\x7e\xfc\x7b\xdc\xc5\x39\xf1\x23\xc6\xc2\x83\xb0\x4f\x49\x59\x87\x39\xeb\xc1\xe6\x43\xc0\xb8\xe2\xd2\xf1\x95\x7f\xae\x31\x83\x10\xf5\x94\x8a\xdd\x8d\x54\xdb\x72\x39\xbc\xa1\x3d\x43\xea\x29\x35\xbe\xc3\x6e\x64\xe7\x22\xbd\x1e\x42\x45\x53\xb6\xdd\x41\x11\x94\x4c\x66\x24\xa3\x96\xa9\xa9\x50\x7e\xd4\x81\x5a\x22\xdb\x77\xca\x61\x77\x99\x85\x73\x4e\x72\x47\xcb\x44\x8b\xf1\x9d\x2f\x48\x73\xe1\x7d\x0c\xc0\xef\xfe\x7e\x73\x70\xcc\xf6\xcd\xbf\x7c\x7b\xaf\xb4\x7b\x65\xcc\xe6\x0d\xbd\xfb\x76\x01\xd3\x46\xc0\x3e\x95\x1d\xe1\xac\x5a\xf9\xd5\x73\x7f\x1f\x1d\xbd\xf7\x83\xf1\x57\xcf\x4c\xba\x56\x39\x70\xdf\xbe\xd1\x4c\xa8\x16\x0e\x2d\x9a\xf7\x09\x94\x69\xc0\x4b\xc5\xcf\x9e\xc7\xb4\x31\x68\x6e\xce\x22\xfd\x12\x4e\xc5\x53\xa9\x54\x6b\x77\x54\x54\x42\x70\x42\x91\x27\x3c\xa9\xd8\x13\x14\xac\x0c\x0f\x97\x9b\x82\x4d\x6a\x7b\x91\x47\xad\x91\xc8\xe5\x5c\x51\x60\x04\xb5\x70\xda\x85\xb6\xdd\x16\xc2\xae\xeb\x57\x29\x68\xd3\x35\xfb\x8e\x63\xfc\xfb\x2c\x67\xf0\xa1\x41\xd3\x68\x04\x7c\x65\x73\x4a\x9d\x91\xea\x6c\x1b\xf2\xd6\xe4\xcb\x7b\x93\xc6\xef\x1d\x53\x37\xfa\xf3\xe7\xf6\x27\x4f\x78\xf7\x97\x18\x7a\xce\xa0\xfc\xda\x8c\xb2\x31\x0b\xe0\xa8\xb9\x2e\xf8\xb7\x0c\xc9\x5e\x89\xbb\xb4\x47\x3b\xbc\xab\xee\xdd\xbb\x6f\x3f\xb2\x4a\x0f\x6f\xdf\x0e\xb2\x46\xbe\x7f\xed\xe3\xf9\xff\xbc\x7d\x18\x7e\x07\xb3\x60\x51\x5a\x7b\x5c\xff\x09\xe7\x8c\x6e\x26\x75\x2a\x93\x71\x8d\x54\x8b\x48\x17\xa7\x8b\x43\x36\x84\x8e\x32\x2a\xd4\x54\x54\x53\x4a\x9c\x1f\x23\xc2\xc7\xf0\xcc\x5c\x02\x55\xc6\x13\xe7\xe4\x2f\xf8\x85\xfa\x82\xac\x3d\xcd\x0f\xa8\x8e\xfe\x08\xfe\x39\x73\x7d\xd7\x22\xd0\xa9\x54\x0c\x24\x52\x4f\x8f\xea\x99\x61\x40\x62\x7a\x6d\x20\xe8\x3d\xe8\x05\x78\x67\x71\xc5\xcc\xbc\xa1\xfd\x2a\xa7\xb5\x1f\x68\x38\xb8\x76\xe5\x95\x70\x36\x62\x45\xb9\xcd\x96\x1a\xdf\xcd\x33\x79\xce\xd3\xc7\x6c\xac\x61\xc9\xf0\xb9\xdf\x4f\x3d\x58\x38\xb7\x67\xef\x8a\x82\xba\x1e\x15\x4f\xf1\xfa\x2c\x8f\x0e\x27\xf8\x1f\x1a\x2a\xcc\xad\x92\xa2\x4f\xa4\x68\x7e\x18\x55\x91\x87\xe1\x31\xe0\x35\xc7\xf9\x72\x02\x7a\x1d\xc5\x9b\xcc\x04\xbd\xc3\x1a\xc9\xe4\xa5\x83\x3e\x00\x7c\xf3\xa3\x16\x7e\xa5\xe9\xf4\x4c\x23\xd5\x89\x0e\x47\x2e\x59\xfc\xc7\x27\x0a\x7a\xf4\x6c\x5b\x3c\x17\x2e\xf3\xc5\xc8\xdf\x62\xe7\xd1\xa1\xb8\x3e\x99\x5b\x2d\x51\x6b\x51\xfb\x5a\x85\x5b\x81\x66\x55\x61\xf2\x95\xb9\x14\x0a\x16\xf8\xc7\x4f\x60\x0c\xf0\x35\xf7\x08\x6d\xd7\xa9\xcf\xac\x8d\x05\xb1\x99\x70\x3b\xfc\xfb\xab\x5f\xd4\x74\x68\x99\xbb\x64\xfe\x3b\xc7\xe0\xaf\xf0\xea\xc5\x93\x79\x5d\x89\x8f\x45\x59\x91\x4e\xd9\x8b\x78\x2f\xc3\xf7\x8c\x6e\x8d\x9c\x2a\x46\xeb\x0d\xf9\x59\xfa\x62\x0f\xc3\xe7\xe6\x04\x38\xb3\xbe\x13\x43\x36\xca\x1e\xe5\x03\xe0\x58\xd8\x0d\xde\x38\x4f\x47\x7c\x7c\x09\xfe\x00\xef\x5d\x07\x92\xc1\x93\x7a\x7b\xfe\xc6\xb5\x9b\xd9\x9c\xc5\x8b\x8e\x9e\x7b\x77\x68\x79\x6e\x3e\xb2\x6b\x77\xa1\x7e\xde\x20\xfa\xd8\x80\x91\xd9\xf1\xb1\x6c\xb1\x47\xaf\xa7\xa5\x52\x75\xb1\x47\xaa\x96\xd3\xc6\x80\xfc\x7b\x5e\x3c\xa5\x04\xe7\x3b\x23\x3d\x26\x9e\x38\x75\xd6\x68\xa3\xa1\x25\xa0\xbb\xc2\xd5\xf0\x0c\x58\x53\x3c\x08\x98\x80\x1c\xdc\x3c\x0f\x6f\xf4\xa8\x38\x7a\x7b\xfd\x27\xb8\xf2\x3a\xb8\x68\x18\x3f\x70\x4f\xfd\x83\x13\x60\x27\xf8\x72\x37\x39\x2f\x69\x4f\xfc\x77\xdc\xaf\x11\xed\x6b\x3a\x99\x52\x8d\x37\x64\x35\x0b\xe4\x6a\x16\x6d\xc5\xac\x31\x50\xb2\xc8\xa2\xc0\x27\x66\x44\xb6\x70\x99\x21\x33\x09\xad\x68\x09\x98\x8c\x1e\x20\xf8\x33\x68\x39\xf5\xcd\xda\x05\x37\x80\xf3\xe0\xba\x4f\xc6\x0c\xdf\x79\x94\x9e\x0b\x76\x3e\x38\x51\x37\x6b\xee\xc1\x08\x70\x11\x16\x6e\xa9\x2a\x9d\x88\xe7\xed\x36\xea\x73\x21\xf1\x0b\x4c\x6e\x19\x67\xa4\xc5\x64\xaf\x57\x37\x1d\x5c\x03\x1e\xd4\x3e\x0a\xe8\x99\x67\x6c\xf0\xd3\xad\xf0\xc6\x56\xf8\x29\x9b\x53\xff\xf0\x59\x66\x0a\x8e\x0d\x45\xf3\x3e\x15\xef\x65\xcc\x78\xb2\xcf\xfc\x4c\x25\xa2\xbd\x59\x8a\x7c\xfe\x98\xed\x41\x14\xd2\x84\x7b\x3c\x41\x5a\xad\x04\x87\x0e\x21\xa5\xa8\x54\xe2\xab\x19\x41\x19\xf2\x65\xb7\x79\x5b\x01\x4f\x16\x1a\x04\xb2\x9c\x71\x38\x28\xb2\x9f\x22\xe9\xca\xd7\x37\xbc\x30\xc5\x7b\xc8\xc5\xe4\xf7\x1a\x99\x94\xae\x7f\x3b\x04\x6c\x87\xf0\x96\xb7\x18\x74\x78\x7a\x64\xef\xe1\xc0\xc2\x31\xf0\x2e\x23\x63\xfb\x1c\xfa\xf8\x32\x3e\xed\x42\xfd\xfe\x42\xfa\x0d\x45\x6b\xd3\xe5\x96\x47\x86\x59\x42\xc3\x42\xc3\x82\xa4\x84\x8a\xbd\x9e\x20\xa5\x54\x20\x63\xbb\x07\x11\xe1\x2f\xa9\xef\xcb\xd5\xe0\xaf\x7b\xff\x8d\x1c\x9c\xf2\x86\xeb\xfc\x80\x32\xe0\x7c\x7d\xfd\x0b\x53\xe0\x8f\x2e\x3a\xb4\xf7\xc8\x44\x3f\x5d\x70\xea\xf5\xaf\x13\xbe\xae\x43\xff\x3f\x81\x3e\x50\x73\x89\x5e\xf8\x05\xe1\xcf\xce\x46\x33\x17\xca\x25\x23\x7b\xb3\x78\x67\x90\x9d\xb2\x23\x7a\xdc\x1a\x8f\x9a\xea\x4e\x55\x52\x8c\x0a\x59\x9a\xe1\xd2\xf0\x08\xfc\xa1\xda\x43\x85\x6b\xc2\x69\x05\x13\xfe\x64\xc2\x7d\xc6\x97\xf0\x8e\xc7\x4a\x7b\x94\x7a\x23\xef\x98\x08\x06\x3b\xff\x67\x7b\xd4\x40\xba\x72\xcd\xba\x15\xd3\xbd\x87\x32\x99\xfc\xde\x88\xb7\xda\x35\x2d\xf6\xbc\xba\x0c\xec\x6e\xfc\xc9\x5b\x9c\x49\x57\xbe\xb6\x6e\xf1\x14\xef\xbb\xf4\x5b\x95\x7d\x0b\xfa\xf9\x87\x51\xfa\xee\xc2\x83\x91\xa2\x1e\xef\x1c\x3e\x0d\xcc\x95\x7d\xbb\xf4\x61\xd1\xdc\xcf\x43\xfe\x9f\x8e\xd8\x31\x9e\xc7\xe3\x82\x85\x5c\xeb\x1a\xf2\x7b\x05\xd1\x11\x38\x8f\xbe\x82\x6d\x85\x76\x2a\xe7\x5e\x83\x56\xa7\x45\x06\xb6\x6a\x5f\xe3\x51\xb7\x56\xa3\xcf\x57\xb9\xd5\x6a\x4a\xa7\xc6\xd2\xc7\xfa\x6d\x2c\x62\xf3\xb4\x68\xc2\x84\x6a\xb2\x31\x91\x13\x6f\xc3\x46\x1d\x27\x98\x95\x9f\x09\x66\xe5\xb0\x67\xfa\x57\x54\x47\x00\x03\x34\xc6\x31\x19\x31\x70\xef\xec\xb1\x33\xff\xe0\x2d\xca\x11\x95\x05\xae\x57\xbf\x39\x7b\xe0\x0f\xc3\xb4\x21\x53\xde\x1b\x8e\xe9\x59\xd5\xf8\x2b\x9b\xce\x76\xa7\x62\x70\x5e\x8f\x34\x54\x16\x26\x0b\x2b\xf1\xc8\x64\x8c\xce\x64\x42\x6e\x85\x49\x13\xc3\x30\xd1\x48\x41\x9a\x02\x0f\x15\xfc\xb9\x27\xd9\x3c\xe2\x86\xa0\xd9\x85\xcd\xa7\x29\x09\x49\x4d\x22\x6f\x70\xdd\xad\xdf\xb3\xfe\xde\x79\x60\xff\xb6\x65\x86\xf1\xf3\x73\x97\xae\xc8\xbc\x9b\xf5\xcf\xce\x7d\x07\xb6\xae\xd0\xaf\x5f\x85\x7e\x03\xda\x45\x2b\xe7\x4c\x9c\xf9\xa6\x62\x60\x64\x87\x76\x43\x66\x05\x2f\x5a\x39\xf7\x99\x19\x6f\x2b\x06\x76\xf1\x0c\x99\x45\xe4\x65\x33\xe2\xd9\x00\xa4\xb7\xe3\xb1\x46\x08\x53\x52\x0c\x6b\xd0\x44\x49\x59\x69\x89\x27\xd6\x2a\x66\x49\xc9\x36\x01\x01\x84\x87\x20\xe4\x63\xf2\x84\x5c\x51\x7b\xac\x1f\x81\x54\x45\xab\x01\x09\xff\x71\x99\x49\xe0\x0f\x6d\xcb\xc8\x7d\xcb\xb3\x62\xd4\xb0\xae\x3d\x9d\xf9\x91\x79\x3d\xba\x4d\xfa\x6e\xde\xda\xa3\xf6\xec\x76\xc1\xf3\xed\x3a\x57\x9a\x67\xa0\x69\xc1\x4b\xe5\xb3\xa3\xcf\xb5\x2d\xec\xd1\xe9\x52\xa7\x64\x6b\xc1\xdc\x29\x35\xc3\xdf\x19\xb0\xb2\xae\xe5\x80\xd2\xf6\xc1\x73\x0b\xac\xc9\xe8\xe3\x1e\x85\x64\x5e\x5f\xe0\xe7\x99\xe2\x28\xf5\x5e\x8e\x2e\xe2\xbd\xfd\x5c\x5f\x0a\x6f\x94\x9e\xad\xb1\x41\x3d\x5f\x64\xa3\x9e\x54\xd8\x68\x6c\x6c\xbc\xca\x3f\xa3\x11\xd1\x85\x49\x04\x6f\x45\xf0\x4f\xfd\xf5\x3a\xc4\x6a\xbe\x80\x76\xae\x4f\x99\xe3\x86\xde\x3e\x8f\xd5\xcf\x54\xbe\xad\x07\x27\x78\x18\x5b\x92\x93\x7b\x10\x3d\xdf\x1d\xb7\xc7\xb9\x56\xe2\xf6\x12\x91\x2c\xe2\xfa\x07\x61\x38\xda\x53\xae\x0a\x41\x3b\x1d\x15\x12\xa2\x0c\x15\x19\xd4\x4a\xa3\xbf\x0c\xae\xa0\x46\x09\x12\x12\xc3\x9f\xc2\x93\x3d\xda\x8f\x74\x17\x45\x5f\x2b\xf3\x64\x85\xa6\x03\xbd\xcb\x36\xf3\xfb\x77\x72\xa1\x37\xf7\x93\x63\x7a\x17\xd0\x39\x0d\xf9\x7d\x6a\x00\xa0\xc5\x20\xb9\x76\x31\x90\xc2\x9b\x07\x3e\xe8\x07\xe0\x61\xd0\x9e\x5e\xf2\x5a\xd7\xfe\xc0\x02\xff\x7e\x2a\xa7\x6b\x2e\x4d\xa7\xa1\x39\x5c\x27\xd8\x0c\x06\x5c\xbb\x4d\x87\x18\xa4\x53\x63\xb0\x26\x99\xd8\x44\x4a\xeb\x3b\x05\x8b\x34\xea\x49\x18\x44\xf4\xe1\x77\xee\x3f\x16\xe1\xdf\xf8\xd9\x13\x82\xfa\x4f\x90\x3d\x72\x04\xf8\x99\xd5\x72\xa7\x70\x5c\x22\x15\xb2\x1b\xc8\xe5\xac\x84\x3b\x08\x10\x37\x28\x16\x24\xfb\xb3\x37\xd1\x98\xed\x51\x48\x9b\x39\xf5\xa8\x43\xe4\x44\xd8\x99\x82\x58\xb8\xfc\xd9\x93\xb4\xf9\xd6\xeb\xf0\x94\x32\x6e\x0d\x50\x26\x8b\xc1\xcf\x10\x32\x57\x1e\x46\x30\xf9\xd1\xbd\xe1\x69\x90\xdb\x12\x9f\xf9\xac\x03\x3f\x73\x13\x50\xfb\x6a\x34\x9a\x0c\xb7\x9e\xd6\x2b\xa4\xab\xa4\x9b\xa5\xf4\x10\x29\xc0\x07\x3e\x5a\x09\x77\x18\xf5\x86\xfb\x52\xa2\x69\x48\x26\x90\xfa\x4e\x27\x3e\x59\xaa\xa8\x10\x42\xd2\xf0\x35\xa8\xef\xa0\x07\xf9\x64\x48\xc7\x32\x4e\x3a\x34\x05\x9e\x5d\x7f\x81\x5e\xc6\xe4\x45\x40\xab\x03\xec\x0c\x83\x85\xa9\xe0\xef\x70\xef\x0f\x09\x7d\xf7\xde\xe2\x29\x59\x7b\xff\x15\xf8\xe7\x5a\x26\x7f\x39\xbc\xce\xc7\x1d\x1d\x40\x63\xed\x83\x68\x41\xbe\x2a\xd2\xf9\x71\x6e\xb5\x38\x32\x72\x95\x7a\xb3\x9a\x1e\xa2\x06\x6a\x75\x90\xea\x20\xea\xdf\x8c\xa8\x48\x24\xd0\xf5\xd9\x38\x22\x42\x97\x4d\x94\xbc\x3f\x99\x0d\xa9\x45\xbf\x46\x61\xfc\x40\x5d\x63\xc1\xe2\x1d\x9b\x9e\x19\x50\xfd\xd4\x85\x0b\x30\x0a\xb8\x4e\x8e\x1f\xd8\xbb\xf8\xf4\xf4\xcb\x8b\x47\xf6\x1d\xfa\x3d\x77\x6a\x62\xcd\xa0\x67\x8c\xda\xf1\xc5\x2f\xae\xa2\x8b\xdb\x76\x69\x93\xe4\x2d\xed\x54\xea\x6e\x8f\xe8\xd9\x80\xe8\x79\x1e\xd1\xa3\x47\x7b\x90\x0d\xf9\xed\xfa\x20\xb9\x5e\x1f\x26\x5d\x45\x6d\xa6\xe8\x21\x38\xe4\x86\xb6\x68\x31\x4d\x36\x8a\xc6\x34\xf1\x73\x81\x88\xc2\x11\x40\x01\xc7\x07\xf8\xc4\xc0\x77\xc4\xc2\x61\x75\x8e\x09\xf3\x53\x79\xbc\xaa\x00\x53\xd7\x61\x7a\x44\x55\x0b\x4c\x5e\x71\x35\xfd\x49\xf7\x02\x78\x37\x03\x91\x07\x27\xf0\xa4\xb2\x2d\xc1\xd2\x89\x35\x43\xda\xad\xc9\xee\xf2\xe2\x2a\xb0\xb3\xae\x4d\x5b\x78\xb3\x13\x18\x85\x89\xc5\x32\xb2\x17\xd1\x39\x00\xd1\x29\x45\xde\xad\x7e\xbb\x56\x8a\xe5\x43\x46\x49\x04\xf9\xf0\xb9\x46\xa8\xff\x90\xa6\x1a\x48\xcb\xbe\xff\x63\xb1\x77\x15\x9c\x70\x20\xf1\xd5\x4d\x1f\x3e\x37\xef\x19\xee\xd4\xa5\x73\x9b\xa1\x77\x11\x12\x90\xa3\x97\xf6\x3c\x4b\xf0\x82\x2e\xa0\x76\xa7\xa3\x76\xe5\x48\x57\x29\x25\xab\xb8\xcd\x1c\x3d\x84\x03\x1c\xc7\x00\xdc\x83\xd4\x27\x0f\xfc\x4c\xa4\xa6\x84\x04\x08\xc1\x85\x03\xf4\x9d\x70\xef\x45\x07\x4d\x85\x43\x2a\x95\xce\x0b\x07\x3f\x33\x57\xd6\xfd\xb3\x0e\x3e\x58\xc7\xdb\x97\x5f\xa2\xb6\x67\x91\xb6\x63\xdd\x2a\xd1\x2a\xf1\x66\x31\x3d\x44\x0c\xc4\x62\x5a\x2a\xc7\x8d\xe3\xd0\xde\xe4\x00\x96\xf2\x81\x97\xe4\x9f\x3e\xca\xc5\xce\x3a\xe0\x55\x87\xd3\xf1\x0e\x48\x85\xd3\x54\xaa\xf7\x60\x38\x77\xea\x61\x04\x6a\x1e\x70\xeb\x50\xdb\x17\xc1\xd7\xec\x1b\xdc\x97\x68\xd6\x42\x76\x9b\x83\x82\x94\x32\xd1\x41\x90\x84\x91\x19\x81\x83\xaf\x12\xc6\xaf\x18\x3e\xc5\xd7\x5f\x7b\x98\x58\xb1\xb9\x80\xf7\xfb\xe9\x05\x67\x6e\x20\xef\x90\x5e\xfd\x69\xcc\x51\xc3\xe8\x9e\x1b\x8e\xcd\x1c\xbf\x7a\x58\xe4\x4f\x21\x60\x5d\xa7\xfe\x9f\x81\xaf\xaf\x7c\x08\x94\x20\x7f\xd9\x4c\x57\xf7\xde\xb7\x8e\x4e\x5d\xd2\x61\xed\x72\x38\xb2\x63\x3b\x3c\xae\x3d\x68\x5c\xeb\x7d\xe3\xa2\x9b\xc6\xc5\xca\x1e\x5f\xb6\xfc\xb8\x88\x5b\x8e\x51\x73\x9d\x0c\x13\x57\x04\x7b\x15\x9f\x3c\xf0\x51\x17\xf0\x56\x97\xf7\x0e\x82\x9f\xc1\x66\xd8\x93\xb9\x02\xc7\x81\x85\x0f\x23\xf8\xb3\xe5\x7f\x10\x23\x27\xa3\xf6\xc9\x7d\x20\xc0\x2d\xe2\xf6\x72\xf9\x1a\x48\xe0\x9f\x03\x27\x0f\x60\x4e\xe3\x6f\x63\x20\xc1\xaf\x59\x17\xf7\x31\x5a\xdb\xc6\xed\x32\xf9\x3e\x90\xb8\x83\xc3\xf7\xd3\x98\x09\x69\x44\x2e\x22\x19\x21\xeb\x48\x18\x74\x25\x7c\x90\xb2\x3b\xb2\x26\x3d\x57\x5b\x7d\x24\x1c\xcc\x9d\x15\xf9\x06\xf8\x1a\x58\xe2\x5f\xeb\x54\x4e\x4b\xde\xf0\x76\xde\xf8\x3c\x3f\x77\x3f\x22\x9d\xa1\x25\x63\x0c\xdd\x2b\x13\x03\x9a\x7d\x5c\x27\x99\xc9\x4d\x9b\x98\x8c\x0c\x38\xa5\x80\x19\xdb\xb0\x24\xef\xc4\xfe\x8f\x7a\xd3\xec\x03\xc8\x82\xd6\x68\x68\xef\xf7\x82\x2f\xa0\xb1\xb5\x01\xef\xc1\x6e\xde\x4f\x31\xbd\x0a\x44\xfa\x9f\xa8\x5d\x8e\xd2\x1e\x22\x63\x63\x7d\x22\x26\x94\x78\x12\x03\xc5\x81\x93\xab\x69\x3a\x82\x8c\xf1\x28\x9e\xeb\xd1\x88\xdf\xff\x70\x38\x86\x38\x62\xa7\x5e\xca\xa8\xea\x09\x1d\x4a\xf4\x98\x96\x12\x0b\xd4\xf0\xc7\x21\x40\x9f\xe9\x52\x03\x60\x95\x63\x15\x49\x90\x9a\x5c\x20\x8a\x61\x16\x8f\xd3\x47\x38\xba\xc1\x1f\x97\xe4\x86\xca\xb4\x13\x76\x1c\x00\xca\x56\xda\x36\xa0\x05\x90\x23\x46\xd2\x23\x07\x4f\x19\xf6\x96\xf7\x18\xdd\x16\x68\x3d\x73\xbd\xcf\x31\x57\xbc\x17\xde\x5f\x40\x0f\x20\x93\x01\xa8\x77\x51\xdf\xaf\xa2\xbe\x15\x54\x44\x5b\x19\x25\x03\xb8\x2e\x24\x27\x68\x4b\x71\x93\xb6\xcc\xf5\xb3\x02\xb4\xc1\xc3\xa0\x7f\x87\xda\xba\x9d\x07\x6f\x03\x4a\xaa\x98\xba\x13\xcd\x32\x13\x36\xc6\x8b\xa6\xf9\xe1\x37\x6d\xbb\xd3\x2f\x08\x6d\xa3\x8f\x91\x0c\x63\x1e\xe3\xb6\xf1\x5a\x96\x91\xb6\x9b\xb1\x85\xb4\x8d\x73\x24\xc5\x24\x87\xd7\x05\x0e\xee\xdf\x31\x22\x9e\x4e\xbd\x72\x60\x47\xad\xdd\x7b\x1e\x73\xc9\x7b\xe4\x3d\x86\x79\x18\x41\x77\xd9\xe9\x65\xb0\xae\xd8\x8f\x64\x62\x15\x87\xef\x4a\x43\x90\xae\x30\x8a\x0f\x22\x71\x50\xa1\xf6\x92\xc8\xca\x68\x76\x8c\x92\xae\x8b\x31\x47\xfb\x2a\xe4\x63\x77\x96\xbe\xf5\xd1\xf5\xa5\x8d\xd4\xc6\x93\x57\x17\x53\x8d\x6b\x46\xbd\xd8\x7b\x52\xed\x88\x55\xbd\xa7\x72\x97\xbe\x3d\xb8\x15\x5e\x5e\xf9\xfd\x7b\x1b\x40\xd8\xaa\xf5\x83\x3f\x9f\x30\x6b\xe6\xe0\x73\x53\x66\xcd\xc4\xfd\xdd\x06\xdf\xb0\xd1\xdc\x1e\xe4\xeb\x25\xa3\x15\x21\x55\x06\x27\x24\x30\x8c\x24\xc6\x80\xc4\x70\x67\x54\xa4\x18\x99\xc1\x58\x73\x9e\x48\x0b\x0c\x3e\xc1\x1d\xe2\xa0\x66\xac\xd0\x85\x42\x37\x3e\xbb\x8c\x04\x3e\x8b\xa3\x45\x7a\xdf\x91\x24\x22\x36\xb4\x7b\xc7\x1d\x55\x41\xd3\xe7\x9e\x76\x17\x7f\x73\xec\xad\x9d\x13\x9e\x06\x53\xf6\x6e\x34\x77\x69\xd5\xb2\x7a\x58\xd7\xd2\xbe\xa3\xd9\x45\x69\x99\x6b\x06\x89\xe7\x72\xe3\x87\x6c\xcf\xa5\x35\x55\x65\xcf\xbf\x3b\x7b\x6a\xff\xb9\x41\x4c\xeb\xb1\x63\xa7\xcd\x6b\xe9\x5d\x57\x55\xda\xa9\x6d\xff\xee\x0b\x78\x9f\xf4\x07\xc4\xf7\x1a\xc4\x77\xec\x93\x06\xed\x16\xc9\xe5\x52\xbd\xec\x00\xd6\x76\x64\x99\xf9\x43\x8e\x78\x7d\xce\x58\x9b\x34\x2a\xa3\x78\xf3\xc0\xf9\x77\x1a\xa9\xf6\x27\x0f\xd4\x7e\x30\x74\x68\x8f\xd2\x1d\xdc\xa9\x57\x17\xad\x3d\x00\x5f\x47\x42\x1e\x56\x5c\xd1\xa9\x90\xb4\x7f\x0a\xb5\xff\x22\x6a\x5f\x89\x8c\xe2\x88\xbd\x0a\x9a\x36\x99\x58\xe3\x13\x76\x74\x2d\x5f\xcd\x1f\x0b\x2a\xbf\xbb\xe9\x81\xaf\x23\xa6\xfa\x95\x5b\x1d\xd1\x3a\x3f\xb8\x76\xcf\xca\x49\x07\xe1\xf1\xca\xa1\xbd\xba\xdd\x73\xa1\x15\xf5\x0c\x9c\xc7\x5c\x79\x69\xf6\x84\x75\x3a\x38\x90\x0e\x2e\xea\xde\xb6\x23\xfc\x0a\xaf\xab\xf6\xa8\xcf\x15\xc4\x86\x30\xec\x14\xb3\x2c\x87\xc7\x43\xf3\xe3\x11\xba\xe1\xa1\xcc\xdb\xbe\xf2\xd1\x2b\xf0\x54\x38\x93\x1e\xce\x25\x3c\x3c\xca\xb8\xd7\x09\xba\xfa\x57\x24\x33\x6f\x22\x3d\x62\x42\x12\xc3\x69\x78\x5a\xa5\x58\x8d\x08\xbb\x4b\x60\x3e\x34\x91\x70\x72\x5c\x33\x6a\xe4\xb8\xa0\xa7\x3f\x1a\x17\x7b\xe5\xc4\xee\xf7\xe5\xdc\xc0\x93\x43\x14\x03\xe8\x69\x43\xeb\xe8\x01\xde\x15\x27\x0f\x6d\x7a\x31\xac\x57\x04\x1d\xee\xfd\x20\x27\xb7\x73\x77\xdc\xc7\x1c\xa4\x53\x36\x20\x1a\x75\x54\xc4\x76\x46\x81\xfb\xc0\xeb\x37\x71\xa7\x5a\x06\x44\xfb\x08\x5f\x9c\x4e\xa1\x3f\x2b\x63\x47\xab\x89\x71\xe2\x05\x8c\x5f\x50\x87\x77\x6f\xeb\x99\xa2\x5b\x0d\xad\xea\x2d\x6c\x17\x40\x5f\x0c\xe2\xfa\x5c\x3d\x81\x96\x6f\xab\x8b\x17\xbc\xef\xa1\x35\xf0\xde\xdd\xc3\xf4\x38\x6f\xd7\x69\x77\xe9\x36\x38\x3e\x98\x06\x5f\x31\x97\xd8\x06\xe4\xb3\xa5\x51\xf6\xbd\xf1\x9c\x4a\x25\x31\xe9\x83\xf7\x81\xd4\xdd\xb1\x56\x8a\x72\x48\x88\x8a\x74\x3a\x1d\x58\x4b\x92\x53\x2b\x61\xb7\x70\x59\x9b\x1c\x84\x4c\xbe\x52\x99\xcf\x3f\x50\xd3\x06\xbe\xc2\x81\xd5\x97\x9d\xe0\x62\xca\xf3\x3a\xb3\x6c\xe6\xe8\x92\x8a\xb1\xef\x1e\x9b\xa9\xea\x99\x9b\xab\xd8\x19\xf4\xfa\x9c\xe7\x66\x6a\x52\x44\x99\x5a\x8b\x2c\xee\x64\x6d\x71\x9f\xff\x1f\x6d\xef\x01\x1f\x55\x95\x3d\x8e\xbf\xfb\xca\xf4\x64\xfa\x4c\xa6\xa4\x4c\xda\xa4\x92\x32\x49\x26\x05\x92\x01\x02\x84\x10\x48\x85\x30\x09\xa1\xd7\x50\x24\x54\x05\x84\x88\x08\x28\x08\x88\x58\x40\x11\x41\xc5\x82\xc0\x52\xa5\x28\x41\xc5\x0a\xe8\x5a\xd6\xde\x76\x5d\xc5\xd5\xb5\xad\xee\xda\xc8\x9b\xff\x2d\xef\xbd\x79\x33\x89\xee\x7e\x3f\xff\xcf\x6f\x5d\x51\xef\x3b\x73\xee\xb9\xe7\x9e\x7a\xef\x3d\xf7\x96\xe4\x96\x4e\x34\x81\xbf\x55\xe4\x0f\x08\xd6\x2c\x9d\xb8\x76\x3d\x43\x0f\xb7\xb5\x15\xf8\x6c\x33\x3b\x67\x76\x5a\xdb\x7e\xf1\x0d\xe0\xe6\xeb\xc1\x1c\xba\x6a\xa0\xaf\xa4\x6d\x14\xa2\xbd\x1c\xbc\xc7\x1a\x21\xed\x19\x94\x8f\xf2\x9e\xcc\x82\xb4\x43\xd2\x91\x12\xe7\x43\x23\x51\x70\xd4\x9b\x0a\x0d\x7c\x3e\x31\xf0\xd8\xd1\x95\x09\xe2\x2a\xbd\x01\x48\xf6\xb5\x10\x81\x76\xb1\xb2\x9a\x16\xce\x44\x99\x7d\xc2\xaa\x95\x42\x09\x4e\x23\xe2\xcb\x17\xd6\xf7\x43\xbc\xdb\x29\x52\x3f\xd0\x0b\xa9\x67\xbf\x84\xd4\x77\x54\xf7\x47\xbd\xd5\x01\xc9\xe7\xef\x82\xe4\xfb\x0b\x11\xf9\x90\x7e\x06\xda\x03\x2b\xfb\x03\x8c\xe3\x52\x29\xef\x71\x4a\xc7\x68\xac\x83\x91\x6e\xe9\x21\xd5\x89\xd0\x86\x16\xc0\x8c\x9f\x11\x64\xab\xaa\xca\x68\x92\xe7\x65\xf8\x3d\x06\x5f\x09\xaa\xd8\x50\x28\x53\x8a\xfc\x11\xab\x6c\xf4\xbb\xc5\x0b\x1a\x3a\xaf\x1b\xbf\x7b\xc1\xc1\x0c\x56\x6b\x3f\x9e\x5c\xaf\x53\xf5\x68\xf7\x8d\x9a\x58\x1c\x08\x0c\x0d\xe6\xd1\xed\xc3\xca\x6f\x5b\xbe\x11\xd0\x37\x6d\x2a\x1c\x75\x80\x6f\x1e\x3a\xb9\xb4\x4c\x3d\xe1\xe4\xd8\xb1\x75\x1d\x4f\x35\xdd\x4b\xe2\xcf\x39\x90\xb6\x1f\xd9\x1f\xa9\x2c\xaa\x98\x1a\x44\x95\x07\x74\xb6\x92\x92\xec\x94\xb4\x98\xac\x2c\x6d\x79\xda\x39\x48\x14\x4c\x3e\xe0\x9f\x85\x94\x01\x72\x5a\xc9\x41\x8f\x5a\x40\x96\xc0\x05\xa5\x45\x9b\x8a\x44\xa3\x84\x3b\xa4\xb1\x74\x08\x1b\x8a\x06\x4f\x8a\x9c\xef\x42\x11\x8d\x9f\x0b\x5f\x78\xc1\x29\x89\xe0\xd0\xe3\xb8\x40\xe5\xf4\x9c\x87\x0b\xee\x58\xfd\xf2\x90\xfc\x4d\x8b\x3a\x96\xf0\xdb\xd0\x14\x04\xb4\xc7\xe2\x1e\xbc\xe9\x96\x21\x93\x37\x6e\xdd\x65\xa4\x77\xcf\x1f\xdd\x5a\xe4\x2d\x9d\x60\xee\xfd\x91\x1e\xea\x1f\xd2\x66\x64\xee\x4c\x77\xd4\x36\x2c\x2f\x9a\xdf\x7e\x4f\x7d\xdd\xd2\x89\xfc\x0f\xe5\xc9\x6d\x45\xf9\xb6\x59\x73\x1a\x1a\x76\x6d\x1c\xd1\x68\x1c\x5c\x5e\x5a\x10\xac\x3b\xea\xad\x1b\x36\x75\x1c\xb1\x75\x3c\x1c\xaf\x51\x41\x41\xbd\x4e\x45\x37\x31\x1a\x81\xef\x84\x46\xab\xb5\xaa\xa0\x13\x1d\x40\x25\x40\x79\xca\xc3\xe1\x76\x01\x76\x0d\x55\xf8\x84\x69\x15\x96\xa6\x78\xf2\x7e\x89\x37\x05\xbf\x09\x6e\xf6\xd1\x29\xbe\x92\x48\x57\xc1\xe4\x5c\xb3\x6c\xdc\xdd\xcb\x1e\xca\x07\x46\xc3\x29\xd6\x70\xa2\xa7\x8e\x61\x5a\xea\xea\xa6\x14\xd6\x0d\x1a\x36\xc6\x57\xc0\xfe\xb0\x61\xb1\x66\x23\xff\xef\xee\x4d\x63\xf2\x62\x46\x33\x4f\xf2\x0b\x6e\xba\x65\xca\x99\x91\xf5\x4d\xe3\xff\x3c\x62\x14\x96\x73\x33\xb4\x39\xad\x98\xb6\x14\x41\x4e\x2c\x82\x9c\xf8\x20\x69\x48\x4e\xec\xff\x45\x4e\x90\x5d\xe8\x47\x4c\xfe\xe1\x5f\x30\x7a\xee\x75\xe3\x76\x2f\x3c\x94\xc1\x98\xca\x9e\xda\x67\x60\x7b\x34\xfb\x6a\x27\x23\x29\x69\x83\x52\x52\x53\xba\x7d\xd9\x5a\xa0\xd8\xb8\x79\x11\xf0\x5e\xbd\x75\xdc\x68\x5f\xa5\x6a\xc2\x53\x63\xc6\xd6\x4d\xec\xa9\xbf\x17\xd1\x55\x02\x3e\x60\xbe\x82\x32\x82\x32\x94\xd4\x80\x96\x4a\x0a\xa8\x75\x35\x49\x49\xda\x78\xd3\x29\x51\x28\xf2\x88\x50\xa0\x55\x3d\x9f\xb4\x3c\x2a\x69\x9b\x78\xd3\xb8\xd7\x2f\xaa\x5a\x88\xab\xaa\x9c\x91\xb3\xbf\xf0\xce\x55\xdb\xf7\x4d\x3b\xbe\x74\xf3\x6e\xc3\x5e\x38\xa3\x43\x83\x46\xa6\xdc\x91\x8e\x66\x74\xe1\xf8\x87\xb6\x6d\xff\x70\xc9\x9d\x9b\x07\xb7\xae\xb3\x9a\xea\x86\x4d\x1b\x4b\xea\x1c\x2a\x21\x2d\x3f\x08\xb4\xc4\x9f\x88\xb3\xdb\x31\x15\x79\x11\xa2\x29\x38\x2c\xb9\x40\xe2\xbd\x0a\x22\x7d\x76\xa5\x68\xac\xb2\xfa\x25\x02\x8b\x55\x98\x88\xdb\x3f\x5c\x8c\x89\xb0\x98\x05\x21\x02\xa0\x19\xd2\xf0\x05\xd4\xe7\x74\xc8\x0d\xb5\x2e\x29\x29\x31\x51\xe1\xb0\x9b\x11\x2f\x68\x54\x3a\x2d\xf0\x42\x70\xee\x48\x78\x24\x46\x08\xeb\xe7\xb8\x8e\x49\x29\x96\x91\x91\xa7\xe8\x6d\xf4\xca\x19\xf3\x5a\x47\xde\x3d\xed\xda\x1d\x8b\x67\x83\x8a\xe1\xf7\xdc\x36\xf1\xa6\xec\xb5\xb9\x13\xfd\x43\x66\x4f\x33\x2e\x98\x5c\x5c\x4c\x4f\x9d\xd6\x39\xbc\x6c\xc5\xd4\xe0\x2c\x2d\x30\x8c\xf7\x4f\xb9\x66\x58\x53\x45\xcb\x80\xdc\xfc\xa2\x95\xf6\xa2\xbc\xac\x62\x48\xd7\x60\x48\xd7\xa7\x90\x37\xa9\x94\xe7\x89\x04\xad\x56\xa7\xb3\x98\xec\x88\x2a\x05\x1b\x8e\x80\x7d\x22\x51\xe1\xfb\xa7\xa4\xbd\x4e\xa5\xb7\xc4\x23\xec\xea\x90\x08\x84\xee\x5c\x73\xa7\xe5\x40\xdc\xc2\x8a\x21\x47\xcd\x4b\xa6\x97\xe7\xcf\x75\xed\xf6\x03\xb0\xf2\xf6\xd2\x89\xfe\x31\x0d\x87\xc0\x07\x5d\x73\x12\x17\xfb\x8b\xe7\xac\x2a\x2d\xcb\xcc\x98\x11\xfb\xd6\xcc\xc6\xd2\xf1\xc5\x1c\x13\x1b\x1c\x32\x6f\x0d\xd2\xb5\xaf\xa9\x73\x6c\x0e\xb4\xdb\xc9\x54\x1e\xd2\xb5\x78\x90\x7f\x5c\x1b\x17\x9b\x6e\x3d\x0b\x27\x2a\x87\x8a\x05\x03\x08\x65\x45\xa2\xe9\x86\x02\x0d\x75\x2d\x4d\x76\x4f\x98\x4c\xb8\x6d\x76\x5f\x25\x8d\xcc\x60\x2c\xb9\xde\x87\x3c\xdf\x5f\x09\x68\xfb\x86\xdb\x4c\xe7\x8d\xd7\xd4\x35\xd9\xad\xc0\xbf\xa8\xa6\xf3\xfa\x71\x3b\x17\x37\x2c\x35\x02\x46\x13\xa3\x3c\x6e\x5b\x99\x74\xfa\x9a\xd1\xe5\x35\xf5\xb9\x4b\x07\x4d\x2b\x39\x37\x79\xb6\xb5\x6d\xec\xac\x15\x2d\x55\x5b\x17\x6d\x03\xcc\x8a\xfa\x6a\x53\x96\xcf\x3e\xb7\x77\xf9\x83\x5b\x19\x7d\xc3\x98\x49\x2f\x54\x6f\x9e\xb4\x97\xc8\xd9\x53\xd4\xab\x4c\x80\xfd\x0c\x9f\x53\xb1\x9d\x83\x6e\x39\x1f\xe7\x67\x45\x94\x82\x04\x11\xf8\x05\xf9\x14\x3f\x8a\x23\xe8\xbb\xdd\x3d\x6e\x30\x6b\x6b\xcf\x36\x30\x65\xfb\x76\x66\x5d\x2f\x47\xff\x86\xe5\x64\x00\x8c\x41\x90\x3e\x6b\xa9\x84\x13\x30\x65\x60\x58\xd5\x53\x10\x0d\x07\x7c\xe1\xb8\xa7\x2a\x2a\x6b\x00\x66\x86\x5b\x33\xb9\xac\xe7\x42\x4f\x17\x18\xf8\x3e\x7f\x0e\xe5\x43\x13\x8b\xf9\xb7\x59\x5b\xef\xa3\x60\x20\xff\x16\x9f\x07\xe3\x86\x51\x10\xef\x9f\xa1\xfc\x65\x52\x19\x47\xa8\x78\x38\xc3\xc7\x9d\x66\xbd\xc6\x7e\x06\xb2\xd5\x08\xf2\x8f\xa6\x72\x7a\x21\x7a\x20\x77\x79\x54\x91\x1a\x3a\xd4\x85\xe0\xc1\x51\xdc\xec\x13\xbc\xa3\x74\xf6\x03\x7d\x1e\x04\xd2\x99\x93\x95\xed\xc6\xc6\x73\x2d\xda\xb1\x55\x13\x8c\x0d\xe7\xbb\x5c\xa7\x2d\x4c\xf1\x8c\x61\x2d\x53\xd5\x15\x5d\xc3\x26\x4e\xd7\xb4\x9f\x6b\xd6\xd1\xec\xa4\xf9\x13\xf8\x16\x70\xbe\xca\x33\x76\x41\x07\x3f\x8e\x1e\xff\xc0\xda\xe6\x41\x2d\x0d\x13\x87\xcf\x9e\xe2\x1c\xc6\x27\x82\x33\x43\x92\xd8\xb1\x38\x8e\xba\x4a\x9d\x63\xae\x62\x19\x48\x39\x66\x33\xea\x9c\x4f\x42\x22\xcd\x90\x0b\x46\x38\xfb\x2c\x2d\xcd\x3e\xa6\x14\xcd\xbd\xd7\x6f\x47\xb1\x95\x9c\x50\x68\xfe\xa4\xa7\x0a\x60\xc2\xb6\xbb\xdc\xef\xf0\xe6\x65\xe9\x82\xa6\xd9\xc3\x96\xe8\x21\x85\xce\x93\xb4\x9e\x2e\x59\x39\x7a\xd6\x9c\xd8\x59\xa6\x15\xe7\x62\x6e\x62\x7c\x55\xe0\x95\x31\xde\xb6\x25\xcd\xfc\x58\x48\x9a\x79\xe1\xe8\xa1\xb3\xa6\x14\x57\xf5\xbe\x3b\x63\x1e\x9e\x5b\x07\xb4\xb3\x66\xf6\x5f\xb8\xde\xc6\x7c\x24\x56\x8d\xe4\xd1\x22\x59\x56\x14\x8c\x93\x73\x9b\x26\x5c\xed\x19\x16\x35\xd6\xfc\xef\xe7\xb6\x1f\xfa\xf6\xc2\xde\xfd\x2f\x6c\xa9\xef\x28\xd8\xd2\xd0\xe6\x63\x2e\x7e\xcc\x7f\xfb\xd0\x6d\xef\x02\xd5\x3d\xf7\x1c\x1a\x7f\xb0\xee\x64\xf0\x38\xc9\x59\x2b\x60\x1f\x0c\x9c\x23\x07\x65\x3f\x6a\x36\xc6\x20\x13\xc5\x20\xe3\x50\x10\xde\x40\xc6\x67\x0b\x3c\x92\x69\x12\x6e\xc3\x40\x1b\xb8\x4f\x97\xd5\xd8\x4f\x8d\x00\x96\x1d\x0f\x4c\x3b\xb1\x79\xed\x4e\xf5\xd3\xea\x39\x23\x9a\x93\x0d\x6c\x67\x6d\x4d\xca\xcf\xbb\xb7\xae\xfa\xe1\xfa\x9b\x97\x19\xd6\x4f\xdf\xd0\xe6\x7e\x08\xf5\x95\xc2\xcc\x66\x1d\xb0\x2f\x23\x65\x3c\x4e\xa9\xbb\x59\x1d\xe9\x86\x3c\xb0\x4f\x38\xa9\x07\x29\x12\x0f\x47\xaa\xb6\xb4\x4e\xb1\x2b\x5f\x8e\xfb\xf2\xe0\xde\xfd\x4a\x66\xf6\x00\xef\xa1\xf9\xf3\x33\x9f\x78\xf3\x9e\xcd\x03\x33\x48\x8d\x2a\x8c\xb7\x1c\xcc\x2c\x8c\xcf\xa8\xea\x8e\x61\x88\x4d\xc3\x8f\xfd\x8b\xfe\x06\x3d\xbd\x4e\x2e\x85\x61\x1d\xae\x2f\x0f\xed\x38\xc8\xbd\xac\xb8\x35\xd8\x61\x57\x31\xb3\x4e\xbc\xb3\x7f\x5b\x4a\x51\x4e\xca\x13\xf3\xe7\xe7\x60\x9f\xfb\x0e\xb4\x03\x6e\x48\x9f\x8e\x4a\xa3\x52\xcf\xc2\x78\x22\x9f\x4a\x00\x45\xc7\x9d\x31\x06\xa5\x1d\x85\x71\x14\x0a\x2e\xc4\xe3\x5b\x38\xaf\x97\xfb\xd5\x34\xf1\x21\x67\xec\x7d\x71\x1e\x0b\xc3\x21\x98\x1d\xd0\x9f\x8d\x9a\xe2\xab\x1b\x54\xd3\x90\xc3\xff\x90\xb7\xb0\xe9\x9a\x65\x2d\x3b\x97\x3d\x3c\x80\xa6\xd5\x83\xcf\x3d\x64\xd4\x9c\x55\x2b\xd9\x39\x93\xcf\xd4\xd6\x37\x4d\xbe\x30\xea\x4e\xae\x7a\xf0\x86\xc5\xdb\xf8\x1f\x6f\xd8\x64\x2b\x86\xd9\xc9\xf2\x79\xd5\x8a\xb1\x6e\x34\xd6\x6f\xc0\x47\xcc\x51\xee\x6e\x18\x81\xc5\x9f\xd0\x2b\x95\x3a\x0d\x8c\x84\xf3\x8f\xda\x2d\x92\xc5\x7c\x5e\x08\x6f\x84\xdb\x5d\xfc\x3e\xa4\x39\xe4\xee\x17\x1c\xfd\xd2\xc7\x1a\x27\x6b\x87\x4d\x77\x2c\xe8\xb8\xd6\x73\xb3\x7d\xf3\x70\x55\x85\x33\xdf\x56\x0c\x3e\xaa\x6f\x28\xf5\x83\xc5\xeb\x8f\x1d\x5b\xcf\xaf\x4f\xb7\x0f\xd1\xdc\x60\xc4\xbc\xcd\x81\xf1\x47\x0e\xb4\x2b\x0e\xca\x7d\xcc\x10\xab\x71\x20\x8b\xa0\x80\x1a\x91\x87\xec\x21\x36\x2c\xc4\x3c\x33\x44\xe8\x70\x9a\x01\xed\x4c\x8a\x74\xf5\x12\x3d\xa6\x41\xa1\x93\x24\xdf\x28\x08\xfe\x38\xf6\x33\x7e\x82\xa3\x5e\xd7\xbe\xa4\x19\x3c\xde\xfb\xc8\x03\x6b\xeb\xaa\x67\x4f\x29\xaa\x02\x97\x51\x9f\x09\xd0\x5e\x68\x39\x05\xe5\xa4\xdc\x01\x8d\x5e\xad\x8e\xd1\x50\x0c\xe3\xb4\x09\x46\xc2\xe8\xbb\x20\x5c\x18\xc0\xe1\x1c\x34\xdd\x9b\x56\x0c\xff\xcd\xea\x15\xb3\xd0\x01\x50\x20\x12\xc0\x1d\x4d\x09\xe3\x17\x34\xf3\xd3\xe9\xa1\x8b\xb2\x57\xd7\x0e\x9e\x36\xd1\x1a\x70\xf2\x43\x19\x7b\xb3\x79\x6e\xcd\x72\x63\xcb\xf3\x4b\xcd\x27\x69\xda\xbf\xba\xa9\x73\xbe\x9a\x6d\x27\x39\x54\x17\x1c\xeb\x7f\xe0\x58\xb3\xa8\xd4\x13\x56\x57\x42\x2c\x9b\x0a\x79\x7b\x4c\x43\xc5\x25\x9c\x81\xe3\x35\x91\xf1\xfa\x48\xc2\x51\x26\x25\x55\x0a\x69\xdc\xb8\x40\x88\xe8\x86\xe8\x3f\xd1\xf7\x78\x60\x03\x9b\x22\x8d\x94\x51\xd3\x9f\x95\xa2\x17\xce\x9f\x00\x1e\xe7\x03\xd8\x4a\x81\xc7\x7a\x1f\x99\x51\x29\x33\x53\xe0\xaf\xfc\x70\xc1\x4c\x41\x1e\x4d\x01\x5f\xb1\xed\x90\x56\x98\x03\x1f\xd1\xd0\x67\xf1\xac\x80\xf0\x6a\x22\x4a\xbd\xd0\x3b\x4c\x30\xee\x7b\xea\xb3\xe5\x17\xf2\x55\x4a\xaf\xed\xeb\xcb\xe0\x2b\xfa\x57\x7e\x9c\x7f\xc3\x84\x42\xf0\x1e\x1c\xef\x2b\xe0\x43\x56\xc1\xfe\x9b\xf2\x50\x19\x27\xe2\x74\x90\xc7\x28\x3e\x0a\xa8\x5d\x2a\x15\x13\xaf\x50\x24\x09\x6a\xe4\x33\xe2\xbf\x04\xcb\x2f\xdf\xea\x10\x43\x03\x7c\x9c\xc1\x26\x6c\x73\xd0\xcb\xca\xaf\x1d\x36\x7d\xf4\x88\x92\xb2\x94\x0c\x5b\x5e\x79\xf1\x83\x5b\xae\xdb\x34\x75\xa5\xd3\x3d\xb4\x62\x98\xbe\x63\xd6\xcd\xf4\xea\x86\x46\xdf\x4e\x9f\xc7\x51\xd4\xbc\xb2\x78\xd5\xf6\xa5\x93\x1b\xb7\xb5\x17\x95\xc3\x16\xa8\x77\x2f\x51\x4f\xb2\x71\x5c\x2f\xda\x01\xa6\x72\x50\xac\x5b\x14\xd0\x2a\x3c\x9e\xe4\x64\x5d\x9c\xcb\xa5\xd7\x21\xd5\xb3\xc2\xb1\xfb\xc8\x02\x21\x24\x0a\xc7\x06\x55\x62\xae\xaf\x14\x6f\x84\x4c\x81\x76\xd8\x09\xb8\x64\x25\x13\x3e\x1e\x85\xfe\x64\xc0\xf5\xbb\xe6\xb7\x35\xb5\x3f\xb9\x77\x65\x3b\xab\x29\xee\x59\x7d\x3d\xc8\xdd\x98\x32\x3d\x65\x7c\x5a\x70\xe6\xac\xa0\xeb\x82\x9f\xeb\x5d\x33\x73\xf6\x56\x93\x7d\x45\xd3\x3d\xa7\x86\xd4\xf0\xff\xa0\xf7\xd2\xf7\x6f\xed\xe9\xfd\xa7\x2b\x69\xce\xe4\xe1\x63\x37\xd9\x77\x16\x54\x22\xde\x77\x40\xfb\x30\x1e\xf2\x5e\x8f\x72\xed\x98\xb3\xd0\x25\xa8\x60\x33\xca\xe8\xaa\x10\x8b\xd0\xbb\xd3\x56\x24\x10\x00\x86\xb6\x25\x7e\xd0\x71\xa1\x98\x51\xc7\x15\x7e\xf8\x2a\x3f\x6f\x62\xf1\x73\x85\x75\x50\xf4\x3b\xad\x77\xf8\x47\x77\x82\xf3\xbd\xd9\xfb\x1f\xdf\xb5\x0b\xd9\xf8\x38\x38\x17\xc3\xa1\xef\xd5\xc1\xc8\x39\x39\xa0\x56\x38\x9d\x56\xb7\x2b\x26\xc6\x7d\x16\x7b\x5f\xab\x60\xeb\x8d\xe8\x00\x27\x29\x67\xc0\xdb\x8a\xb1\xe8\x94\x3e\xf0\xda\xa5\xf5\x17\x43\x9a\x17\x5d\x28\x35\xbf\x63\x41\x76\xe1\xcc\x49\x65\x8d\x40\x33\xfb\xf0\x88\xd2\xcf\x9e\xbc\xfd\x28\xb8\xf1\x11\x07\x5d\x6e\xa6\x67\x6d\x5f\x31\x7c\x51\x79\x46\xf3\xb5\xc1\xd6\x76\xc6\xac\x78\x7f\xca\x6d\x63\x4e\xbe\xfe\xe8\xcd\x60\xd0\xec\x0f\x16\xae\x27\x39\xc7\xdb\x70\x7c\xe3\xa0\x5c\xc4\xa1\x17\x2f\x8e\x18\xf4\xc8\x63\xc7\xdb\x6c\x0a\xf5\x53\x90\x0c\x15\x1c\xae\x43\xcc\x38\xf0\x34\x84\x97\xa4\x90\xff\x23\x8f\x94\x28\xc9\x93\x7b\x66\x93\x1d\x79\x45\x64\x16\x99\x99\xf3\x6f\xfc\xe6\x8d\x92\x7d\xc5\xd7\xdf\xf7\xe2\x19\xcd\xd8\x79\x81\x41\x23\x8a\xdf\xca\x28\x30\x0e\xbf\x76\x15\xfb\xe3\xed\x6b\x7e\xe4\xbf\xa7\xf9\xbf\x82\x78\xc5\xe3\x5b\x5f\xfa\x3e\x71\xb5\xf5\x99\x8d\xcd\x53\x38\x70\x1d\x70\xaf\xac\x0d\xf2\x1b\x75\xcf\x1c\xb9\x97\xe8\xe8\x1e\xaa\x87\xed\x80\x31\xa3\x93\x4a\x3e\xc9\x99\x62\x18\x95\xce\x78\x06\x14\x43\xaa\xf2\x8f\x3a\x6c\x14\x76\x24\xc8\x3d\x0b\xab\x9b\x85\x09\xb4\xbd\x8a\xf6\xa1\x73\xad\x7a\x68\x88\xd1\xc3\x7a\x38\x8b\x06\x5f\xa4\xfa\x73\xbd\x39\xba\x01\xdb\xfe\xcc\xef\x3f\x78\x6e\xa1\x23\xe7\xd2\xeb\xe0\xfe\x82\xf8\xec\xd4\x78\xb7\xca\xcf\xfe\x68\x2a\x9e\x76\x28\xae\xf9\x23\xde\xd9\x7b\x1e\x3c\x91\x37\x9a\x7f\x8e\x1e\x79\x60\x4e\x8d\x76\xa3\x19\xbf\xeb\xb6\x22\x74\x2d\xdd\xcb\x6c\x31\x28\x99\x74\xf0\x76\xef\x16\xdc\xe6\x09\x5d\xcb\xcc\xa4\xbb\x0d\x4a\x7a\x49\x68\x03\x69\xa3\x4e\x84\x3a\x99\x13\xf4\x62\x83\x92\x5b\x1e\xba\x59\x68\xeb\x85\x70\x3f\xd1\x8b\x60\xdb\x8a\xd0\xbd\xbd\xb7\x92\x3d\x5c\xbe\x8e\x79\x84\xb9\x15\xb6\xad\x0a\x6d\xeb\xdd\x86\xdb\x7e\x80\x6d\xdf\xe0\xdf\x5e\x1f\xba\x13\xfd\x16\xce\xcb\xad\xfc\x7c\x66\x1f\xbd\x92\x72\x53\x5e\xca\xfd\x84\x82\x61\xe2\xe3\xf5\xc9\xce\x33\x60\x28\xcc\xb8\x02\xe2\xca\x17\x96\x0e\x72\xd1\x80\x05\x89\x3f\x14\x8d\x94\x01\x74\x38\x2c\x05\xe4\x5e\x44\x14\xc9\x33\xfb\x3e\x3e\x36\x7a\x95\x7b\xc0\xc2\x95\xf5\x6d\x99\x87\x39\x57\x69\xd9\x91\xbb\x57\xbf\xb3\xe9\x8e\x3d\xfc\xa4\xe9\x4b\x6f\x9f\xbe\xb8\x01\xb4\xbd\x1c\x1a\x98\x1f\x6c\x4e\x49\x19\xd5\xec\x88\xe5\x4e\x7e\xb8\x1f\xb8\xb6\xec\xe2\x0b\xf6\x3e\x7c\xdf\x91\x7b\xea\x47\x21\x3a\xc7\xf2\xa3\x99\x37\xe9\x75\x90\xce\x35\xa1\xd5\xbd\x5b\x31\xed\xb9\xb0\xed\x2b\x7a\x2d\x6c\xeb\x0e\x6d\x21\xb4\x87\x42\xa1\x7f\xb2\xaf\xb1\x63\xa0\x66\x0f\xa0\x06\x07\x52\x32\xdd\x8d\x41\x9a\xb2\xda\x33\x33\x29\xbb\xdd\xdb\x10\xb4\x1b\xcc\x1a\x3d\x6b\x68\x0a\xb2\xb6\x54\x4a\x3a\xd2\x13\x3e\x97\x24\x3f\x14\x2c\x7f\xfe\xd1\x2f\xbb\xfc\x53\x09\x87\x67\x24\x4f\xe2\xe0\xc8\xc4\x4e\x33\xc9\xe4\x48\x0d\xa3\x3e\xe0\x9b\xf9\xdc\xea\x1b\x0d\xeb\x2f\x2f\x33\x37\xac\x2d\x59\x76\x56\x3f\xf5\x86\xaf\x52\xf9\x0c\x43\x71\xa1\x6f\xb0\xf3\xb1\x95\x05\x1b\xfd\x40\xa5\xcd\xb0\x3c\xf0\xc0\xba\x35\x23\x9b\xe9\xc3\xbd\x7b\x67\x54\x5c\x0f\xe2\xe9\x49\x75\x93\xf9\x17\xaf\x79\x76\x4c\x60\x6c\xeb\x90\xc1\xb9\xfc\x3f\x99\xfd\xfc\x18\xdf\xd0\x72\x74\x2e\x06\x8e\x67\x2d\x77\x09\x8e\xa6\x9c\x6a\x0b\xe8\xb2\xdd\xde\x24\x6f\x41\x43\xd0\x6b\x73\x18\x4f\x81\x9a\x80\x31\xa8\xa2\x1c\x06\x47\x92\x83\x51\x33\x8e\x80\x55\xa7\xe3\x50\xab\x3e\xa8\xd3\x25\xc5\x26\xf9\x1b\x82\x49\x86\x58\x0a\x6f\x44\x4a\x47\x5a\x28\x43\xdc\x05\xe7\x87\x93\x26\x76\x5c\x90\x1f\x1b\xf3\xa1\x23\xfd\xde\x64\x9c\xc3\xfb\xd0\xfd\x01\x28\xda\xf4\xa1\x03\xf5\x5e\x69\xb5\x88\x3c\x53\x9a\x82\xce\xb6\x41\x46\x98\x84\x34\x3a\x45\x95\xa8\x7f\x5e\x9d\x5a\x10\xb7\x2a\xf5\xfa\x0e\x53\x2c\x70\xa4\xe8\x52\xf3\x9d\x2b\x1c\x55\x93\x86\x6b\xb4\xf9\x74\xf9\xa9\x85\xdb\x77\xde\xf2\xfd\xed\x73\x6e\x71\xb0\xea\x14\x6e\xd6\xbd\x37\xec\xab\x19\x5d\x7f\x73\x53\xf2\xca\x7a\xe6\x37\x90\x33\x74\xeb\x75\xa0\xee\x14\xc8\x1e\x3a\x7d\xf6\x40\xf0\x65\xfb\xf4\x73\xa7\x5f\xe2\x1f\x7c\x61\xc6\xa4\x82\x65\x6a\x70\xe7\x97\x20\xfb\xaf\x5d\xb3\x56\x7d\x86\x64\x72\x74\xe8\x9f\xdc\x79\xc8\x87\x02\x6a\x10\x35\xee\x48\x6e\x0a\x19\xbc\x93\xca\x35\xe4\x26\xe5\xc2\xc1\xe7\x06\xbc\x09\x09\x76\xd4\x1a\x17\x4c\x48\x88\xf5\x50\xac\x51\x19\x1b\x5b\xd4\x10\x8c\x35\x28\xcb\x1b\x82\xc2\x76\x6c\x78\xc8\xa4\x2a\x47\xc6\x8c\x82\x7c\x0f\xba\xc0\x2f\x32\xb3\xaa\x02\x79\x40\x29\x72\xc5\x8a\xde\x76\x96\xd8\x82\xce\x53\xa2\x23\x69\xe2\x65\xaa\x2f\x9a\xd9\xda\x43\x9d\xdb\xee\xde\xf8\xd5\xae\xce\x4d\x0e\x3a\xc9\x03\x58\x4e\xe4\x8a\x1e\x38\x52\xb5\x29\x85\x02\x57\x34\x47\xf4\xf6\x07\xee\x5d\xb7\x77\x54\xcd\xe8\xcd\x63\x55\x43\x66\xce\x0d\x3e\x7f\xe6\x65\xd0\xf6\xe4\x94\x89\x47\x1f\x06\x34\xe1\x09\x18\x7d\x9a\xf0\xe4\xea\xa2\xd1\x7b\xe8\x43\x1f\xf3\x9f\xfc\x63\xc9\xf4\xd5\x57\x88\x6d\x5a\x44\x51\x9c\x93\xfb\x12\xca\xc4\xb8\x80\x31\x25\xa3\x21\x98\x96\x02\xa8\xf8\x84\xf8\x86\x20\x14\x00\x86\x08\x00\xa5\x33\xe8\x92\x74\x90\x31\x3a\x67\xc0\x69\x42\x6d\x9a\x20\x34\xf6\x86\x9c\x04\xbd\x41\x7c\xf3\xe5\x82\x74\x74\x0b\x33\x42\x7c\x27\x00\xdf\x6e\x18\x9e\x7f\xf4\x44\x1f\x91\x0c\xda\x67\x47\x8b\xc3\x7e\xbc\x92\xa5\x24\x87\xdf\xa1\x13\x78\xad\x0e\xe8\x72\xf2\xcc\xc2\x94\x83\xa1\xfc\x17\xe3\x55\xa9\x85\x71\xab\x12\x2a\x27\x56\x9b\xfc\x21\x2a\x0d\x50\x86\x64\xfe\xe5\xfb\xf7\xa5\xde\xbe\x66\xea\x02\xb3\x16\x9c\x4d\x63\x56\xf1\xd7\x82\xf2\x22\x34\x40\x7e\x3f\x78\x01\xe4\x0e\x99\x37\xb5\x1c\x00\xf7\xb9\xe6\xc3\x87\xdc\xa7\xcc\x4d\xd3\xcb\xce\x51\x4c\xe8\x00\x1c\xa7\x1d\xea\x72\x2e\xe5\xa7\x06\x53\xd7\x05\xaa\xdd\xc5\x8d\x41\xb7\x61\x40\x79\x5e\x69\xa9\x2e\x39\x2f\x3b\xaf\x31\x98\x03\x98\x0c\x35\x95\x6d\xc8\x5e\x98\xdd\x9d\xcd\xaa\x99\x6c\x5d\x40\xc1\xe8\x98\xc6\x60\x5a\x9c\xd1\xa2\xd7\x01\x27\x03\x55\xc2\x62\xa9\x42\x57\x8d\xc6\xea\xb3\x28\x8e\x1c\x54\x95\x1d\xaa\x86\x21\x16\x1e\x39\xe4\x04\x16\x04\x14\x73\x91\x73\x38\xb8\x86\x81\x6c\xde\xa7\x7b\xa1\xc7\xc1\x62\xe0\x37\xe1\xc4\xab\x04\x3f\x49\x2a\xad\xa3\x2a\x11\xb3\xf0\x53\x60\x5e\xc6\x6c\xf7\x8b\xb7\x49\xd9\xec\xc2\xbf\x81\xcd\xc1\xee\xaa\x49\x9f\xb5\x3b\x34\xd7\x58\xa7\x0c\xa9\x30\xbc\xa6\x31\xd1\xd3\x77\x8d\xaf\xa6\x07\xdd\xd0\xd2\xda\xa8\xcb\x72\x6a\x16\xc4\x4d\x1a\x3c\xfc\xef\x23\xcf\x35\x2c\xea\xb1\xd8\xdd\x89\x05\x63\xf9\xca\xe0\x4c\xa7\x2b\x31\xbb\x19\x5c\xb4\xab\x78\x1b\xf8\x8b\x3b\xbf\x73\xbb\x15\xe4\x2e\xae\x99\xf5\xec\xa4\x49\x8a\xce\xb6\xf6\x69\xde\xd9\x7f\xf1\xe4\xcf\xde\x61\xe5\x77\x80\x15\xe9\xfc\x64\xba\xc1\x3b\x67\x71\x65\x7e\xc6\x9d\x0b\x34\xa6\x1d\x45\x79\x99\x37\x23\x7b\xb8\x07\xf2\x70\x00\x5b\x0f\xed\x61\x01\xd5\x12\xc8\xf1\x66\xe9\x13\xd3\x12\x1b\x83\x1c\x50\xa5\xa5\xe8\x61\xe2\x01\xd4\x4c\x9a\x3e\xa0\x57\x35\x06\xad\x0e\xbd\x5e\xe9\x70\xe4\x35\x05\x1d\x06\xa3\x9e\x52\x5a\xe5\x0f\x46\x43\x6b\x48\x89\x1c\x32\x5c\x30\x62\x1e\x11\xcb\x81\x98\x03\xd9\xe3\x31\x27\x8b\xfc\xf1\xa0\xa2\x01\x71\x2d\x1c\xc0\x26\x1f\x74\xd8\xc0\x6e\xc3\x7c\x41\xb7\xc4\xbc\x3a\xa4\x7d\xc6\xaa\x81\x6d\xfc\x95\xa9\x49\x81\x98\x55\xce\x8d\xb3\x87\x70\x40\x67\xd6\xb0\x4d\xa7\x96\xdd\xbc\x55\x9f\x92\x38\x28\x66\x55\xe1\x9b\x83\x7b\xdf\x6e\x3f\x3d\xcd\x10\xbb\x25\xb8\x09\x8c\x8f\xcd\x2a\x34\xf2\xb9\xe0\xe7\xe2\xf2\xee\xdb\xd4\xa0\xb9\xda\xba\xb1\x7c\xd5\xc2\x8d\x1b\x87\x8e\x3e\x46\x17\x95\xf1\x57\x6d\xfc\x61\x7a\xb5\x7b\x88\xa9\xb1\xa6\x64\xcf\xcd\xa4\x66\x4b\xcb\xb7\xb2\xdd\x70\xdc\xf9\xd4\x40\x6a\xfc\x89\x7c\x7d\x7a\x42\x82\x55\xd0\x8c\x04\x43\x42\x52\x02\xd4\x8c\x84\xec\x40\x36\xb6\x23\xb6\x60\x5c\x76\xb6\xc7\x65\x62\x62\x95\xb1\x3e\x68\x31\x6c\xca\x32\xfc\x08\x42\x84\xb9\xe8\xa3\x2e\x28\x1e\x44\x1b\xfa\x91\xd6\x51\x0f\x64\x96\xd3\xe3\x0f\x2b\x0e\x32\xb0\x32\xb3\x49\x73\x66\x36\x70\x72\xde\x6d\x77\xdd\xfc\xf5\x5d\xf3\x36\xdb\xe8\xa4\x54\x99\x0e\x19\xf8\x2b\x69\x92\x0a\x99\x8f\x1b\x0c\xdc\x03\xf7\xde\xf0\xe0\xa8\x9a\xba\x2d\x2d\x6c\x39\xb4\x18\x13\x67\xbd\x78\xfa\x12\xff\xd0\xd9\xe9\xed\x47\x9f\x10\xd4\xa8\xf1\x9c\xa0\x44\xcc\xfd\xf5\x2b\x93\x7b\x9b\xfe\x0a\x3c\x5f\x2d\x9e\xb1\xf6\x0a\x3a\x67\xf4\x13\x3e\xf3\x88\xea\x66\x1a\x8e\xc5\xc5\xc6\x2a\x04\x3e\xc4\x1a\x62\x93\x62\x21\x1f\x62\xe3\x03\xf1\x98\x37\xe6\xa0\x3a\x3d\x2b\x3e\xde\x9c\x93\x95\x45\x37\x05\xb3\x0c\xc9\x7a\xb3\xe0\x3a\xc8\xd9\x28\x53\x59\x14\x0b\x20\x07\xf0\xb2\xa5\xaf\x7f\x63\x01\xe7\xdb\xeb\xb1\x0b\x2c\xb2\xb3\x4b\xe7\xce\xbc\xf5\xdd\x02\xcd\xef\x9a\x0a\x53\x1c\x0d\xf4\x0a\x96\x1d\xf1\xcc\xa6\xce\x29\x4c\x83\xf9\xb9\x03\x7d\x2c\x44\xc7\xaa\xfb\xa6\xcd\xad\x29\xb8\x71\xa9\x11\x8d\xeb\x3b\x61\x5c\xc9\xd4\x98\x13\x4e\x0e\xa6\x0c\x2e\xe2\x15\xd4\x14\x30\x80\x24\x00\x87\x06\x02\x09\xc2\x78\x63\x83\xb1\xb1\xac\xc9\x64\x6f\x0a\x5a\x4c\x06\x96\x1c\xcd\xe9\xeb\x11\xc5\xc3\x5f\x29\x5e\xf9\x38\xd0\xb1\x59\x64\xef\x92\x18\xd1\x2d\x82\xdf\x34\xda\x4a\xfe\x4a\x73\x98\xf8\x72\x50\x0f\xd2\x77\xb6\x0f\x68\xbc\x95\x3f\x3d\xd0\x20\xce\x25\x18\x04\xf8\x67\xc0\x01\xd1\xbe\xb1\x40\xe1\xf8\xc2\xce\xbf\xd0\x4c\x26\x0d\xd9\x72\x07\xf4\xef\x8f\x43\x39\x2d\xa6\xaa\x02\x49\x79\xf6\xa2\xa2\x02\xb3\x81\x8a\x61\x98\x9c\xcc\x04\x87\x83\x49\x48\x48\x6f\x08\x26\x27\x18\x18\x0d\x14\x48\x46\xbc\x3f\xd4\x27\x29\x65\x19\x0c\x3f\x7d\x3e\x9f\xe1\x02\x0e\xc6\xc8\x43\x70\x62\x2e\x02\x63\x50\x3c\x82\x12\x74\x53\x16\x7e\xc6\x4f\x29\x6e\x93\xa2\xcb\xa2\xec\x85\x7e\x9f\x42\x69\x63\xb3\xf9\xd7\xf9\x8f\xdf\x50\xf3\xdc\xc4\xd5\xeb\x97\x35\x4e\xec\xde\x57\xe8\x2b\xb3\xdc\x98\xbe\x85\x01\x71\xbf\x3c\x7d\x99\xe6\x5b\xa6\x2e\x5a\x50\xdb\x30\xef\x4c\xf1\x10\xd7\x8d\xc9\x33\x14\x60\xc9\x89\x37\x36\xdf\x99\x36\xa6\x6a\x78\x4d\x4e\xb1\xc5\x55\xe2\xc9\x1d\xf1\x52\x5e\x6c\xca\x9f\x5e\xbd\x73\x8b\x53\x51\x55\x39\xb0\xda\x5b\x68\xb4\x17\xa7\x2e\x38\x34\xc4\x89\x7d\x55\x75\xe8\x07\xb6\x86\x6b\xa1\x8a\xa8\x96\x23\x89\x76\x32\x3f\x2c\x95\x68\x48\x4c\x4a\x84\xf3\x93\x18\x70\xaa\xd5\x80\xe8\x20\xcc\xbf\xb3\xf2\xf2\x60\x8c\x96\x67\xb3\xe8\x62\x74\xe8\x3e\xe3\x18\x3d\x55\xf5\xbc\x2f\xea\x80\x5e\x84\xcf\x06\x61\x05\x43\x25\x4b\x3e\xfc\xaa\x82\x5d\x92\xc7\x3c\x71\xc5\x5d\x19\xcb\x90\x44\x19\x14\x2b\xa5\x39\x2b\x7d\x38\xed\xc4\xd6\x3f\xf9\xc1\x0d\x69\xfc\x9a\x3a\x95\x22\x2c\x98\xb4\x6a\xe4\xe8\x95\x37\xa7\x7a\x47\xd5\xb7\xfa\x1e\x7a\x48\x25\x77\x50\xc0\xc9\x7f\x7e\x8e\xbf\x8e\x26\xa2\x09\xf2\x9c\x05\x79\xae\x33\x0a\x9d\x9a\x5b\xbc\xc2\x5e\x2d\xbc\x31\x8a\xce\xcb\x25\x53\x93\x02\x3a\xb3\xc1\x68\x68\x0e\xc6\x5a\x74\xb6\x78\x1b\x51\x30\x3a\x91\x55\x52\xf1\x86\xf8\xa4\x78\x38\xfa\x78\x5d\x40\xc7\x12\x65\x74\xe8\x74\x94\x51\x0f\x92\xa8\x24\xa1\xf0\x87\x1c\xfb\x13\x8d\x0e\x1e\xae\x64\x74\xc9\xc9\x36\x9f\x9f\x28\x1f\x1a\x7d\xa1\x1d\x9d\x86\x51\x02\x1b\x19\x39\xbe\xba\x0f\x72\xc2\x0b\xaa\xb3\xec\x68\xb8\xf1\x55\x93\xaa\xab\x96\xfc\xd0\xfb\xad\x97\x69\xf4\xf2\x4f\x97\x7b\x50\x30\x02\x23\x93\xe1\xeb\xff\x4d\xcf\xce\x78\x01\x54\x68\x72\x87\xcc\x9e\x51\xe1\xf9\xea\xe2\x4b\xfc\x25\x43\x36\x8c\x40\x32\xbe\xb9\x8c\xed\xe8\x19\xbe\x91\x0d\x42\x1d\x4b\x82\xd6\xa3\x24\xe0\x72\x5b\xe2\x34\x96\x98\x98\xcc\x86\x60\x4c\x8c\x85\xb2\xa4\x34\x04\x2d\x6e\x4a\xd9\x08\xa7\xd4\x20\xd6\xce\xc8\x2e\x1b\x2f\x8b\xc3\x77\x8b\x8a\xcf\x8b\x33\x4a\x5f\x49\x54\x24\xe9\xf1\x9b\x4b\x52\x19\xb9\x5d\x7c\xe3\xd4\x25\x98\xa0\x31\xf5\x83\x2f\x95\xa5\xd2\x37\x7d\x79\xe7\xd6\xb5\xdf\xec\x9e\xbb\xd9\xce\x29\x92\x55\xfc\x7f\xfc\xf7\xe4\x80\xdc\x53\xf7\xdc\xb0\xb7\x7e\x64\xfd\x86\x7a\x76\xcc\x5d\x9b\x3d\x83\xeb\xf8\x4f\x0e\xbd\x70\xee\xf1\x97\xf9\x3f\x9d\x9d\xd1\x96\xb8\xca\xfc\x2b\x93\xf8\xe9\x77\xbf\xed\x79\x1f\x98\xdf\x5b\x38\x71\xe9\xbb\x30\x8f\xd6\x82\x77\x59\x3f\x7b\x06\xbd\x3f\x70\x92\x56\x2a\xd5\x0a\x16\xdd\xc9\x77\x49\xb8\xe9\x50\x76\xe6\x86\xfe\x76\x20\xff\xe6\xc0\x53\x5b\x4f\xf9\x41\x8e\xff\xf4\x56\xf0\x2e\xf0\xf1\x97\xe9\xbf\xf2\x9f\x01\x57\x6f\x22\xf1\x2b\x57\x84\x37\x36\xdc\x54\x26\x7a\x75\x89\x4a\x6a\x0c\xea\x61\x56\x6e\x53\xd9\xa0\xe4\xda\x5c\x1a\xa5\x4a\xd9\x1c\x54\x45\xdf\x8b\x8c\x93\x09\xbc\x8e\x51\x85\xeb\x95\xd0\x45\x70\x76\xe9\x05\x26\x74\xba\x02\x48\x15\x02\x70\x0a\x69\x9b\xc3\x36\xec\xc7\xde\x17\x33\x98\xf5\xe9\xfc\x5f\x72\xbc\x8b\x6e\x7e\x94\x7f\xe3\xec\x6b\xff\xda\x04\x00\x38\xdb\x35\x7f\xe1\x3d\x0d\x0b\xe7\xed\x3b\x4b\x8f\x50\xa5\x99\xf2\x33\xb7\x5d\x7c\xf6\xa4\x2b\x21\xc1\x54\xfc\xc9\xe6\x87\xf9\xcf\xf7\xbc\xfd\xd4\x4e\x2a\xf4\x28\xbf\x79\xf1\xf2\x85\x6f\xce\x99\xd7\xf5\x21\x7a\x37\x31\xf4\x32\xfb\x1e\xf7\x2b\xcc\x20\xc6\x04\x72\x4a\xca\x7c\xd6\x42\x5b\xaa\x47\x95\xe8\x2f\xa2\x0a\x32\xb3\xe0\x54\xe6\x04\xb2\xa0\xd7\x8d\x4f\x4c\x74\x34\x04\x13\x6d\x14\x63\xd6\x58\x19\x7d\x93\x58\x3d\x80\x42\x45\x32\x1a\xc3\x85\x2a\xe7\x2b\x64\x5c\xcf\x93\xbc\x57\x5a\x3b\x95\x2f\xa1\x33\x64\xa1\x4a\x89\x2f\xab\x4c\xf1\x47\x2e\x0f\xa2\x13\x2a\x66\x1f\x50\xd2\xa1\xc0\x86\x96\x8e\x69\xe6\x9b\x5e\x5a\x66\x98\x32\xb2\xcb\xd9\xf5\xe2\xb5\xbf\x0c\x31\xc7\x99\x3d\x2d\x63\x6b\x52\x2b\x96\xdc\xaa\x5d\x35\x25\x6d\xee\xc2\xeb\x0b\x36\xa5\x6d\xaa\xef\x5d\xf3\xa2\xff\xfb\xa5\xfc\x02\x17\x33\x75\x65\xd7\xaa\xa5\xf5\x93\x7b\x9b\xe8\x89\xad\x65\xb7\x1e\xba\xa5\xf7\x29\x7a\x26\x7f\x50\xdf\xa2\x52\x1c\x4a\xce\x6d\x7c\x5a\x9f\x57\x4c\xaf\x3e\xc7\xf3\xe7\xf8\x39\x60\x3c\xbd\x15\xce\xdb\xc8\xde\x0f\x97\xe2\x75\xac\x7a\x8a\x62\x6e\xc4\x35\x77\xf1\x81\x58\xa5\x96\xd2\x36\x07\x39\x38\x9f\x6a\x2b\xaa\xf8\xab\x92\x9d\x17\xf5\x99\xc9\x1b\x28\xa8\xe2\x76\xd9\x75\xcd\xc0\xd1\xbc\xd2\xbb\x72\x3c\x7f\x65\xfc\x75\xf4\x76\xf0\x08\x3f\xfe\x22\x5f\x06\x5e\xc0\xf5\x8b\x22\x4e\x93\x82\xdb\x85\xeb\x53\xdf\x81\xb2\xf1\x0a\xb4\xe5\x1e\x2a\x83\xca\xa3\x02\x01\x8f\x47\xef\x74\xa5\x19\xdc\xf1\xee\xe6\x60\x4e\x8c\xdd\xcc\xaa\xa0\x73\x55\x99\x93\x1b\x82\x66\x9b\x0a\xf2\x5d\x65\xe8\xf3\x8c\x83\x50\x89\x19\x57\x45\xa2\x8b\x70\x20\x85\x98\x47\x96\xfc\x52\xd0\x49\x56\xc8\x50\x54\x5f\x55\x68\xf6\x28\x2d\x36\xfc\x5c\xae\xbf\x88\xe6\x62\x39\x14\x53\xdc\x7a\x0f\xd7\x9c\xd1\x5c\xf5\xf3\xa3\x28\xae\x88\x99\xc1\x5f\x79\xa4\x3b\xa3\x7b\x80\xde\x00\xaa\x1e\x6b\xe0\xe7\xd1\x8d\x1f\x36\x6e\x4e\x07\xb7\x33\x30\x92\xb0\x2d\x73\x4f\x9c\x75\xfe\x78\xd6\x80\x8b\x1f\x7e\x3b\xbd\xbd\xb6\xf7\x3f\xcc\x94\x8b\xff\x6a\x5e\x74\xb5\x0b\xc4\x14\xce\x59\x44\xff\x7d\xfb\x8a\x41\xaf\xc2\xdc\x2b\x0e\xfa\xa8\x1e\xc8\x3b\x2b\xaa\xd0\x0e\x58\x1d\x40\xab\x83\xec\xb3\x18\x60\x68\x6d\x8e\xd5\x73\xb6\xa6\x20\x27\x2b\x8c\x91\x15\x93\x0a\xf7\x3c\xf8\x71\x35\xa9\xf0\x5c\x22\x79\xc9\x8a\xbd\xbb\xdd\x73\xcf\x37\x77\x3f\xfb\x67\xc3\x64\xef\xe4\x06\xe0\x68\x00\xb7\xa3\x3f\xdb\x7b\x67\xbf\x50\xc2\xcf\xd7\x80\xb7\x1e\xfa\xcb\xc2\x93\x8f\x54\x34\x5e\x04\x3b\xf9\x59\xe8\x6f\x3e\x13\xe8\x7c\xd9\x87\xb0\x0e\xfe\x04\xe9\xf9\x0a\xdb\xd8\x2c\xaa\x34\x10\x9f\xe8\x22\x76\xd6\x4b\xe8\xf2\xd8\x20\x5d\x6e\xa3\x9e\x83\xc6\xa9\x1f\xba\xf0\x1f\x84\x3a\xc0\x4a\xe4\x95\xe0\x8b\xcf\x90\x41\x42\x9e\x13\x9d\x62\x85\xd9\x1f\x5a\x78\x45\xfc\x65\x0f\x8c\x89\x7f\x9c\xe7\xef\xba\xfc\xbd\xa6\xc1\x7b\x4d\xdd\xce\x4f\x33\xc0\x2b\xde\xb1\x33\x12\xc0\xe7\xbe\xa1\x5e\xf0\x4a\xc6\xa7\x5d\x96\xf9\xbd\xa3\xa7\xed\x4c\xe5\x53\x99\x20\x38\xb4\xe5\xe5\xce\x53\x0f\x0f\x28\xbe\x78\xeb\xec\x4b\x2f\xf8\x17\x37\x68\xaa\x17\x97\xbd\x70\x69\xf6\xad\xbc\x6f\xfd\xaa\xfc\xd6\x95\x28\xa7\x87\x72\x82\x72\xfa\x34\x18\x93\x17\x05\xe2\x95\xc9\x46\x26\x41\x9b\x00\xf3\xb8\x04\x9b\xd5\xd9\x14\xb4\x5b\x5d\xda\x01\xa8\x62\x8a\x15\x53\x77\xf9\xcb\x03\x76\x31\x5b\xf7\x30\xe1\xd8\x53\x1f\x5e\x2f\xad\x82\x09\x6b\xff\x59\xfa\x0f\xc0\x31\x3a\x8d\x24\xe4\x53\x5b\x07\x24\x9f\x7f\x70\x54\x73\xa6\x3f\xef\x46\x7b\x4c\x59\x3f\xc9\x39\xfb\x09\xbf\xec\x28\xca\xc7\xf7\xf2\xef\x5c\xf3\xf5\x91\x03\xc6\x37\x74\xd7\x57\xb3\xd1\x89\x39\xcc\xcb\xe1\x58\xbe\x83\x63\xc1\x77\x2c\x06\x92\x3c\x89\x89\x54\x53\x30\xd1\x15\x47\xa9\xac\x5a\x93\x09\x46\x2f\x26\x83\x36\x07\x0e\xc6\xc6\x3a\xc3\x55\x2e\xf2\xb8\x5a\x28\xe7\xe7\xd0\x71\xcb\xbe\x09\x38\x79\x24\x5d\x18\x9c\x59\x9e\x6f\xef\xbe\xd1\x6e\x58\x13\x95\x73\x8f\x06\x8e\xde\xae\x42\x61\x64\x2f\x88\x29\xf6\x6b\xd7\xb7\x44\x66\xd9\xe0\xd6\x5f\xbf\xe0\x43\x78\x4c\xcc\x1a\x29\xb5\x06\xd4\x04\xbe\x15\xe7\xd5\xc9\x54\x71\x20\xde\xee\x6e\x08\x3a\xec\x80\x32\x9a\x8c\x0d\xc1\x24\x93\x5e\x0f\xa0\xa5\xb7\x2a\xb4\x4d\x41\x95\xc2\x15\x71\x91\xbb\x3c\x6d\x66\x64\xf3\x90\xd2\x5f\xb2\xfc\xfa\xa6\xb9\x85\xc9\xe7\x1e\xaa\x6b\xce\xcc\xf7\xaf\xb5\x1b\x6e\x3e\x24\xe5\xc7\x7b\xef\x4f\xbd\xed\x86\x69\xf3\x4d\x24\x3f\xee\x2d\xe5\x43\x47\x1f\x43\x5c\x6f\x61\x56\x09\x69\x71\xf3\x34\x98\x16\x43\xf9\xbf\xc8\x8f\x61\x77\xb3\xa3\x70\x6e\x53\x1f\xc8\x74\xe9\x13\x72\x9b\x82\xda\x58\xbb\x25\x21\x21\xd6\x62\x81\x19\x8c\xc5\x90\x91\xd2\x14\x64\x33\xd8\x8c\x58\x2a\x16\xe6\x32\xb1\xc8\x45\x43\xe5\xad\x22\xd5\x8a\xe2\x0b\x26\x91\xa6\x47\xb8\x73\x08\x32\x1f\x3f\x08\x68\xc6\x53\x91\x64\x94\x36\x99\xd1\xf5\x75\x8c\x27\x3c\x40\xd8\x90\xa2\x54\xb0\xf2\x49\x01\xa9\x0f\x9e\x00\x0c\x3d\xac\xe2\x09\xe8\xbb\x03\x87\x26\x87\xa8\xb5\xef\xdd\x32\x79\xa5\x85\x53\x27\x71\xdf\x95\xcc\x06\x79\x83\xd2\x37\xac\xcf\x4e\xca\x34\xb9\xad\x71\xe6\xf8\xb1\xca\x5c\xfe\xab\x9e\x8d\xcb\xef\x1e\x16\x18\xb9\xa6\x96\x1f\x73\xc7\x16\xe8\xcc\x41\xd2\xa1\x39\x13\x41\xc7\x5f\x40\xdb\xb1\xe9\xed\x79\x4b\xb4\xbf\xf6\x7e\xc9\x3f\x77\xe1\x6e\xf5\x9f\x39\x5b\xe9\x6d\x69\x57\xfe\xc9\xce\x79\x83\xbf\xf2\xc1\xbc\xb6\x6b\xdf\x23\x6b\x21\xd5\x50\xfe\x3e\x86\xf2\x17\x07\xbd\xb1\xd3\x66\xb1\x40\xe9\xb3\xb8\x62\xb5\x1c\xcc\x23\x74\x7a\x35\x94\x42\x56\x1f\x96\x3b\xbc\xad\x2c\x17\x38\x46\xc9\x08\x4f\x2a\x99\xa5\xa9\xa3\xd7\x43\xc9\x2a\x7b\xe6\xe6\x7a\xfe\x0a\x4c\x22\x1c\x0f\xc1\x28\x60\x00\x5f\x78\x69\xa1\x28\x57\x50\x9c\xc0\x97\x2d\x7c\x27\x77\xe9\xea\x21\x70\x9e\x6f\xe3\x93\x04\x59\xc2\xf4\x3c\xc3\xb7\x32\xdb\x20\x3d\x06\x54\xc5\x16\x0b\xa3\xba\xa6\xa0\xce\xc5\x51\x2c\xaa\x7d\x91\x5f\x90\x20\x10\x00\x64\xe2\x0d\x9a\xa0\x40\x3c\x04\x69\x71\xfc\xba\xb2\x04\xca\xc8\x60\x28\x23\xb0\x33\xee\xd2\xaf\xbf\xf1\xff\xc4\xb2\x80\xde\xac\xe0\x3b\xd9\xb3\x30\x1e\xab\xa4\x06\x05\x74\x45\xe9\x8d\xc1\x22\x6b\x76\x7e\x53\x30\x37\x1b\xbd\x48\x6a\xb2\xb8\xb4\x71\xe5\x8a\x38\x45\x63\x30\x29\x0e\x25\xf1\x5a\xe1\x65\x52\xe9\x4a\x06\x59\x41\x82\x78\xd4\x08\x7a\xec\x4a\xa6\x58\xda\x4d\x8e\x97\xed\x2a\xfb\x94\x11\xe2\x2c\xfd\x02\x6c\xee\xb6\xbb\x13\x0b\x27\x27\x74\x7d\xf6\x90\x32\x46\xab\x7a\xcd\xac\xa6\xcb\xae\xab\x13\xd7\x33\x6c\x73\x46\x0d\x48\x7d\x6c\x0f\x96\xf1\x35\xce\x98\x31\x08\xd8\xd7\x96\xb8\x94\xde\x8e\x96\x27\xce\xee\xea\x3d\xc3\x34\x27\x8f\x1a\x9a\xaf\x5c\x93\xdf\x19\x14\xd6\x32\xea\x16\xf7\x7e\xfa\xcd\xa9\x07\x91\xc0\x0f\x26\x70\x7b\xf7\xf6\x3e\x4c\xe6\x38\x1d\xce\xf1\x2a\xe8\x57\x33\xa9\xc2\x80\xcb\x9b\x96\x06\x79\x9a\xe6\xb2\xe9\x9d\x4e\x4d\x53\xd0\x69\x80\xaa\x69\x65\x93\xe4\x93\x2c\x3d\xdf\x2d\xb1\x39\x4c\x3a\xba\x8a\x49\xbe\x40\xa1\x64\x22\x27\x7e\xca\xb5\xfa\xc0\xb0\x99\x7b\x9d\x5d\xfc\x95\x07\x3c\x0a\xa0\x33\x69\xd8\x86\x67\x96\xaf\xbf\x59\x3f\x6d\xa8\x4c\x00\xe8\xb9\x23\x8b\xc7\x0c\xfb\xd3\xc6\xde\x27\x99\x9a\xfd\x75\x86\xdb\x4a\x56\x76\x6d\xdc\x30\xa4\x9e\xe7\xc2\xa2\x00\xf5\xf4\x1d\x61\x0d\x22\x9d\xf2\x21\x8b\x92\xae\x4f\x71\xb1\x30\xe3\x76\xab\xdc\x59\x0d\x41\xb7\x8d\x24\xa3\x2e\x55\x7e\x38\x12\x90\x59\xf9\xbe\x21\x40\xa4\x95\x57\x48\xb1\x40\x89\xdf\x8c\xd4\x2f\xbc\xb2\x40\xc2\x80\x2d\xbb\xa6\x8f\xcd\x81\x24\x0b\xa6\x26\xc6\x1d\x2f\xc6\x03\x3f\xe9\xed\x0f\x34\x8f\x44\xd6\xb1\x7e\x53\x8b\x18\x06\xbc\xf3\xd4\x1d\xfc\x07\x9d\x7f\x17\x2d\x3d\x0e\x07\xd8\x9f\x46\xef\xe9\x9d\xb9\x6c\x0d\x30\x5e\x59\x7c\xdd\xb5\x1f\xa2\x9c\xfb\x9f\x70\x4c\x24\xe7\xce\x0b\x38\xdc\x96\xe4\xa4\x24\xba\x29\x98\x64\x88\xd3\x5b\xa0\xd0\x59\xac\x5a\x43\x53\x30\x46\xeb\x8a\x78\x08\x1c\x27\x6e\xe2\x52\x41\xb4\x89\x8c\x5e\x22\x98\x71\xcf\xe7\xe9\x85\xcb\xe4\x26\xf2\xf6\x8d\x68\x5d\x80\x63\xd9\x51\x4f\xdf\x3c\x07\xad\x0b\x7c\xf9\x2c\xcf\x4b\xc6\x91\x7e\x6a\xd5\x83\x1d\x73\x6b\x0a\xd6\x2f\x32\x4a\xf6\x60\x2e\xe4\x79\x09\x92\x95\xcc\x02\x0b\xa3\x11\x73\x68\x0d\xb4\xe3\xb1\x1a\x1b\xc5\x35\x05\x69\xca\x25\x64\x2b\xe1\x7c\x1a\xc7\xb3\x11\xcc\x95\x65\xd2\x74\x3f\x19\x34\x63\x27\xe7\x2e\x9a\x06\x13\x42\xcd\x5d\xb7\x48\x79\x74\xfd\xe4\xcb\xb7\xd6\x01\xc7\xcf\xcf\x5e\x24\x09\xf4\x88\xe6\x4b\xd7\xd6\x7b\x81\xaa\x2e\xf9\x3c\xdf\x8a\xe8\x9e\x96\x22\x24\xd1\xd9\xc5\xd6\x9c\xea\xb9\xa3\x8f\x5c\xbe\x7b\xb3\x90\x3f\xe7\x9b\xf2\xf2\x02\xe3\x8a\x93\xd2\xf9\xe5\x47\x0e\xe0\x3a\xb1\xad\x70\x4c\x66\xee\x4d\x28\xff\x7e\xe8\x97\xd2\x9b\x83\x76\x3b\x15\x1b\x6b\x6e\x0a\x1a\x62\x29\xb7\x07\x86\x0d\x6e\x8a\x52\xc0\x78\x5d\x1c\x95\xe1\x42\xa1\x7c\x99\x00\x95\x62\x8a\x2f\xff\xc0\xb8\x21\xec\x90\x22\xcc\x39\x3a\x56\x04\xd5\x3d\x3d\xab\xcd\x9c\x59\x34\x22\xaf\x32\xc3\xf8\x9e\xf7\x93\x67\x82\x95\x59\xa9\xf5\x35\x63\x4d\xbb\xc1\xe9\x61\xc9\x0f\xdc\x56\x93\x91\x96\x50\x9c\x5d\xaa\x4d\x78\xcf\xe6\xfd\x88\x6f\x8d\x55\xfe\xc5\x9a\x5e\x3b\x96\x9d\xf9\xc2\x49\xf3\xdb\xd6\x8e\x99\x57\xdf\xe1\xf7\x3c\x7a\x87\xe6\x69\x75\x65\xc9\x3d\x8b\x5e\x42\xf7\x67\x53\x1b\xa1\x4f\x35\xc1\x58\xcd\x8e\x6a\xdc\x6c\x7a\xbd\x39\x36\x96\x6a\x0c\xc6\x5a\x39\xa8\xbb\x4a\x4e\x12\x14\xe2\x43\xd1\xbb\xde\x72\xf1\x40\x31\xa3\xcd\x5e\x82\xce\xe6\x73\x0f\x20\xf5\x13\x58\x6d\xe0\x4f\x3d\x07\x32\xc7\xab\xf4\x15\x55\xa0\x09\xa4\x1f\x17\xb4\xee\x7a\x28\xcc\xbd\xdb\x4b\x9f\x59\xbb\x94\xee\xa2\x64\xef\xfd\xc5\x51\xb9\x01\x87\xe8\x1b\xb4\xb1\x2a\x28\x4b\x3a\xb5\x5e\x19\xe9\x1a\x7c\xd1\xae\x21\xfc\x02\x60\xd8\x42\xdc\x03\x2d\x44\x35\x7e\xef\x2e\xe2\xfd\xbf\x4b\x37\x21\xe2\x02\x82\x73\x88\x7c\xff\x6f\xad\x68\x12\xd0\x5b\xe8\xad\x78\x6d\xc0\x42\xe5\x04\xec\x7a\x5d\x8c\xae\x39\x18\xa3\xd7\x18\xd4\x30\x76\x55\x5b\x23\xe5\x32\xe2\xa6\x23\x89\x1d\x7e\x9c\x3c\xe2\x9b\xb3\x68\x7f\x80\x44\x6f\x86\xde\x6a\x2f\x7d\x8e\x64\xf6\xbd\xc3\xe9\xd9\x7e\x51\xc4\x5a\x5e\xa0\x1f\xb9\xf8\x52\xef\x04\xfe\x73\x2c\x46\x30\x56\x2b\x82\xfd\xff\x1b\xea\x6e\x09\x35\x98\x1a\x1e\x48\x57\xfa\xa1\xf7\xc8\x53\xea\x95\x7a\xca\x94\x17\xdf\x18\xcc\xb3\x79\x33\x33\x53\x9b\x82\x99\x2e\x93\x0e\xdd\x9c\x43\x55\xca\x1e\x81\x8d\xbc\x35\x07\x85\x0f\xc2\x06\x99\x74\x04\x1a\x4b\x54\x9a\x49\xb8\x94\x49\x5c\x77\x11\x8f\x83\x08\xef\x36\xc1\x14\x18\xc5\x15\x40\x89\x76\x94\xf1\x55\x4d\xb5\xeb\xb7\xfd\xfc\xef\x8f\xad\xa5\x83\x46\xb4\x38\xf8\x8f\x16\x83\xed\x2f\xdd\xad\x1d\xad\x4d\x4e\x49\x4a\x2a\xe0\x16\xe4\x0d\xcc\x0c\xd6\x6d\xbc\x51\x17\x3b\x34\x9b\x56\x8c\x3b\x09\xb2\x37\xcc\x9d\x92\x3f\x79\xea\xfd\x36\xcb\x4d\xab\x9e\xfb\x0b\xc7\xce\x49\xae\xac\xaa\x69\x8c\x05\x83\x0f\x2c\xce\x2f\xe5\xaf\x2d\xf4\x64\xa5\x28\x7e\xb5\x19\xc7\xe9\xde\x30\x2e\x5e\x5a\x14\xa8\x31\x8c\x2b\xc9\xea\x9a\x4e\xab\x69\x3a\x6b\x42\xfd\xbc\xdd\x5d\x84\x0f\x70\x1e\x38\x40\xde\x7c\x43\x31\x6b\x52\x72\x72\x7c\x53\x30\xd9\x65\xd6\xb3\x06\x45\x4c\x0c\x8c\x56\x63\x0c\x8a\xc2\x86\xa0\xc2\x46\xd9\x1b\xc3\x17\x2c\xf4\x8d\x59\xf1\x86\x51\xc4\x93\x7b\xb8\xf0\x9f\xf1\x31\x51\xa3\x66\x10\x73\xa4\xc8\xf5\x39\x33\x7b\x43\xe8\xae\x7b\x6f\xfe\x79\x6f\xd7\x9d\x2e\xd6\x94\x08\xb4\xa6\x9c\xe5\x0b\x7d\xe2\x68\xd7\xea\xf4\xa6\xa6\x89\xb7\xef\x6f\x69\x1e\x7f\x7b\xab\xb6\x6a\xe6\x85\xa7\xcf\xbe\x0a\xda\x9f\x9c\x34\xb9\xbd\xa1\xe6\x2f\xbd\x77\xf1\x3f\x87\xc7\x37\x9a\x3e\xb4\xb0\x8b\xff\xc7\xf7\x4b\x66\xad\xba\x22\x8c\xeb\x35\xee\x2f\x54\x0e\x55\x46\x95\x05\x12\x1d\x89\xcd\x41\x97\x83\x52\x9a\xd5\x06\x03\xf4\x31\x06\x83\xba\xa4\x21\xa8\xb6\x65\x51\x94\xb7\x29\x88\x24\x4d\x7e\x21\x12\x19\x18\x8e\x62\x85\x17\xb6\x14\x91\x1b\x61\xc4\x6c\xe0\xea\x28\xa5\x38\xbe\xd8\xc8\x91\x31\x0f\x6e\xbc\x41\x57\x20\x1b\x1c\x1d\x93\xe9\x7a\x79\xf7\x94\x46\xaf\xa1\xc6\x5e\x54\x67\xf8\x16\x0f\x31\xfe\xba\x3d\xd2\xf0\xf8\xd6\x45\xcb\x8a\x02\xbd\xd2\x10\x6b\xdf\xdb\xb8\xcb\xf8\x12\xa7\x1c\xd8\xf8\x5b\x21\x1e\xa6\x42\xcb\xb6\x86\x87\x08\xc7\xd8\x8c\xdf\x98\x46\xfb\xbb\x79\xd4\xb0\x40\x7a\x7c\x62\xa2\x13\xe5\x1b\x59\xa8\x9a\x3e\x2b\x31\x8b\x36\x30\x59\x59\x94\x52\xe9\x6d\x0c\x2a\x0d\x69\x16\x8a\x32\x85\xb7\x78\x7d\x11\x77\xe9\x48\xb7\x12\x8a\x4f\x1a\x93\x9b\x11\x04\xb9\xe5\xa2\xa7\x50\x81\x93\x6c\x24\xe6\xe0\xfb\x8b\x6f\xdc\x03\x52\xce\x9d\x7e\xd9\xdd\x3b\x2a\xa6\x7d\xec\x9d\x55\x80\x1b\xce\xcd\x1f\x50\x99\x19\x1c\x02\x27\xcf\x7c\x4d\xc5\x94\x9b\x12\xc0\x83\x5c\x8d\xe5\x83\xcb\x1f\x82\xd2\x07\x5f\x3c\x7f\xcd\xc2\xaa\xd2\x29\xb3\x6e\xb0\xf3\xbb\xc2\x53\x37\x25\x83\x39\xb2\xbe\x3b\x3d\xa9\x61\x21\x89\x71\xb2\xe1\xb8\xee\x81\xe3\x2a\xa5\x46\x07\xb2\xf2\x0a\x0a\x72\x9a\x82\x05\x2e\x05\xaa\x72\x6f\x94\x3d\xcf\x1c\x13\x63\x83\x9a\x19\x63\xf0\xa7\x53\x54\x4a\xc4\xc8\x7c\xf2\x82\x71\x79\xf8\x23\x3b\x5e\x9b\x8a\xc3\xbb\xb0\x0f\x43\xc5\x33\xe2\x1e\x76\x9f\xf1\x82\x7f\xbe\xf5\xd5\xd3\xdb\xc0\xec\xe9\xc0\xf1\xf9\x9f\x3f\xfc\x7e\xee\xb4\x39\x2b\xb6\x3e\x98\xf2\xea\x81\xe9\x1d\x93\xef\x4a\xfa\xbc\x86\x48\xeb\x60\x34\xe0\x45\x96\xed\x37\x5e\xff\x58\x0c\x1d\x37\x7f\xcc\xf6\xa3\x77\x6c\xd1\xd8\x62\xaa\xaa\xc7\x0c\x1f\x5c\x79\x64\x5c\x47\x69\x75\x70\x54\x0e\xbf\x59\x3e\x6c\x68\x97\xaf\xc2\xb1\xae\xc6\x76\x68\x54\x20\x33\xcf\xed\x72\xbb\xe4\x63\x4c\xcb\xcc\x4c\x6e\x0c\x66\x1a\xd4\x5a\x2d\x74\x6a\x30\x96\xb0\xc2\x24\x92\xc6\x75\xe3\x51\xa6\x31\xfa\x9e\x22\x6f\xc4\x18\xfc\xe6\xff\xe1\xd6\x22\x05\x0b\x7a\xb7\x4f\x89\x9b\x4f\x06\x73\xa3\x6e\xc4\xaf\xf4\xd2\xc9\x5d\x37\x6f\x3f\x90\xfc\xfc\xfe\x09\x63\x67\xdf\x6c\xfd\x47\x31\x70\xbe\x71\xfa\x9d\x9d\x77\xcc\xed\xde\xc0\x5f\xb5\x64\x5e\x6f\x1c\x2f\x0c\x05\xcc\xcf\xa9\x6d\x9b\x58\x3b\x22\x70\xa4\xa9\xa5\xa8\x6c\xd4\x30\xdb\xed\xbb\x6e\x5c\x34\xff\xce\x44\x74\x97\xd1\xbc\x87\xda\xd1\x7d\x35\x70\x9c\xd7\xe2\xfa\xee\x02\x6a\x60\x20\x09\xdd\x8d\xc2\xd9\x13\x12\x1c\x94\x23\xab\x31\xe8\xb0\xe9\x8d\x46\x5d\x53\xd0\xe8\x4a\x23\x73\x69\x90\x97\xa2\x4b\xa2\x5a\xe6\x13\xef\xb3\x51\xfa\xc2\x46\x55\x3c\xf3\x46\xee\xd8\xf0\x90\x17\x28\xd3\x2a\x69\x86\xac\xae\xd8\xe8\xb6\x57\xf6\x68\xce\xae\x53\x25\x65\x3a\x33\x33\xcb\xca\xae\x9b\x6f\xa8\x3a\xc8\x7f\xfa\xf0\xa1\x24\xba\xd1\xbc\x6e\x7a\x15\x7f\x35\xb0\xf6\xb1\xda\x3b\x07\xf2\xe7\x95\x5e\x76\xcc\x3b\xf7\x0d\xaa\xe9\x0d\xa6\xc7\x25\xc7\xc3\x91\x4d\xee\xac\x6c\x01\x43\xf8\x9f\x4e\x1d\xbd\xbe\x7b\xea\xc0\xbd\x37\xd8\xe7\x2f\xad\xbe\x5a\x0f\x14\x25\x59\x95\xb3\xd1\xf9\xa1\x2e\x98\xdf\x9c\x86\xf9\x8d\x05\x7a\xd5\x8c\x80\xcd\x66\x6d\x6e\xb7\x51\x66\xbd\x09\x3a\x75\x93\x55\x9a\x32\x99\x69\xc1\xef\x92\xf6\xb1\x88\x30\x37\xc6\x07\x88\x0e\xce\xf5\x85\x55\x47\x7f\xc7\xeb\xc0\xf1\x43\x06\x70\x64\x1c\x8f\xb0\x72\x6c\x39\xba\xba\x89\xc8\x4d\x17\xb6\xdb\xf9\x01\x87\x68\xb5\x1d\x76\x3b\x0b\xb9\x67\xb7\xe9\xa0\x81\x43\x56\x4e\xf6\xe0\xbd\xcc\x87\x5a\x85\x10\x19\x3b\x29\x41\x06\xd0\xe2\x6b\xb4\xcc\x80\xe5\x23\xc7\x6f\xdb\xbb\xbf\xa1\x3b\x89\xff\x87\x1f\x14\x3c\x7f\xf9\xbd\x3d\xfc\x7b\xe7\x57\x4f\x8e\x5f\x20\x8a\x48\x23\x98\xa6\x1f\x39\x11\xe8\x3e\xfd\xd7\x8c\xe9\x31\x07\x5e\xfb\xe4\xe2\xab\xfc\x33\x8f\x95\x6d\x33\x88\xe4\x82\x7d\x48\x9f\x67\x40\x5a\x4f\xc0\x98\x2d\x15\xf9\xfa\x54\xe8\xe1\x53\x53\xe3\x54\x71\x90\x62\x67\x1c\xa5\x50\xa9\x60\xd0\xac\x72\x45\x3f\xcd\x8f\xfc\xa9\xb4\x74\x8a\xd9\xd4\x4f\xc8\x86\x2e\xcd\x1c\x3d\xd3\x3c\xc6\x94\x19\x2c\x82\xd4\xa4\x17\x0f\x47\xb1\xda\x7d\xde\x8f\x61\xac\x96\x99\x3e\x1a\xc6\x6a\x7b\x52\x9f\xd8\xb7\xa6\x49\xc5\x12\x72\x2e\xa0\x08\x8d\xc9\x7f\xe9\x38\x89\xd0\x5e\x39\x71\x0c\xed\x9d\x51\x59\x90\xbe\xe9\x30\x16\xc9\x46\xbc\x4c\x4e\x53\x67\xeb\xd3\x60\x00\x92\x66\x4b\xd0\x36\x06\x13\xac\x56\xbb\xdd\xd4\x14\xb4\x47\xfa\x08\xb2\x8e\x56\x20\xbe\x2e\x58\x42\xd6\x66\x22\x65\xb2\x0a\x9d\xa7\x95\x9d\xca\x04\x6f\x2f\x33\x74\x8d\xde\xea\xea\x02\x8e\xc3\xdd\x45\xaa\x84\x2c\x47\x76\x66\x59\x39\x94\x47\xfd\x0e\xc6\xa8\xe1\xea\xef\x9e\xb5\xee\x16\xfd\x7a\x18\xb6\xed\x1d\x57\xba\xf5\xd8\x4d\x74\xf5\xd5\x95\xfc\x4f\x32\x51\x1c\x9d\x76\x6d\xf9\xca\x85\x1b\x37\x0c\x1d\x4d\x1f\xc6\xb1\xf0\x27\x90\x6e\x74\xa7\x49\x0e\xb4\x93\xd9\x6e\xca\xc9\x3a\x9b\x83\xe6\x18\xb4\x5d\xa4\x67\x13\xd9\x3c\x96\x31\x32\x6c\x0c\x1b\x63\x48\x4d\x4f\xf7\x34\x06\xd3\x5d\x26\xbd\x41\xdf\x1c\x34\xe8\x23\xef\x79\x10\xef\x26\x84\xff\x21\x2c\x56\xa6\x29\x85\x77\x4c\x06\x80\x6c\x20\xc4\x59\xc4\x40\x10\x19\x89\xd0\x3b\x50\x05\x66\xb5\x6e\xed\xae\x58\x72\xcb\xcc\x34\xd0\xd5\xfb\x81\x97\x59\x9f\xc6\x4f\x7a\xe2\xd8\x6d\xfc\x0f\x7f\x7a\x64\x51\xcc\xb0\x8a\x01\x95\x1e\x2c\x2b\x15\xdf\x1a\x9b\x26\x2c\x5b\x52\x16\x48\x78\x0a\x80\x8b\xcf\xf2\x5f\x9b\xee\xbc\x7e\xcb\xfb\xcb\x1b\x02\xb1\x39\xf9\xba\x47\x89\xb8\xe4\xe1\xb3\xd7\x14\xf8\x80\x35\x89\xb5\x50\xa7\x29\x0b\xc8\x3f\x1e\x43\x69\x18\x03\x2a\xbf\x41\xb5\x50\x79\xb8\x16\x8a\x9c\x06\xc6\x25\x2e\x55\xe1\xe5\x77\xa9\xfe\xc6\x8f\x4f\x00\x2b\x23\xca\x6f\xe8\x81\xb8\x16\xaa\xf5\xbe\x05\x87\xd3\x65\xb5\x50\xb5\x13\x4b\x70\x2d\x14\xbb\x04\xd5\x42\x6d\xe0\xf9\xf5\xa8\x16\x0a\x1c\xc4\xb5\x50\xed\xa7\x5a\xc2\xb5\x50\x00\xe4\x81\xf7\x99\x9f\x20\x6d\x4e\xca\x7e\xd4\x62\x8a\x45\xa5\x13\x0c\xa5\x0c\x17\x74\x90\x23\xaa\x11\x45\x2d\x82\xb4\xa2\x92\xcc\x2e\x74\x68\xdb\xfb\xf8\xc6\x1d\x0f\x4c\x39\x79\x6b\xf8\xd0\x36\x3d\xbd\xb6\x26\x65\xcd\x75\xbb\xb7\x5e\xff\xfd\x6a\xd9\xa9\x6d\xe4\xe3\xdf\x02\xe7\x98\xdf\xd8\x7f\x51\x6e\xa8\xe9\x19\x01\x5d\x92\x91\x76\x31\x0e\xb3\x59\x95\xee\x76\xa0\xf3\xe2\xb1\x5a\x95\x78\x5e\xfc\x79\xb4\xb0\x8b\xf6\x40\x61\x8a\x83\xf7\x39\x61\xe7\x49\x62\x94\x22\x7b\x32\x8b\x5c\xd5\xa8\xc4\xfe\xe0\xad\x9c\xa1\x31\xd3\x9f\x58\x0a\x6c\xf1\x4f\xd3\x65\x03\xc7\xcc\x8e\xbd\x6e\xc3\xa4\xae\xe7\x77\xaf\x6f\x9e\x0c\xbe\xc9\x2d\xca\x9d\x9d\x68\xaa\xcd\x18\x3a\x86\xce\x28\x1d\x1c\x18\x7c\xe3\x5b\xcb\x79\xc3\xc0\xda\xfd\x3b\xda\x3a\x1a\x96\x6d\xae\x9b\xd3\xeb\x4c\x2f\x48\x4d\x4a\xcf\x23\xb5\x10\x00\x7c\xc0\xfc\xa4\xd0\x42\xbe\xc0\x68\x24\x60\x74\xd9\xcc\x1c\xa5\x8a\x63\x1d\x0a\xb3\xc3\xec\xa0\x3d\x31\xe8\x20\xa9\x02\xc2\xf9\xa8\xaa\xe7\x85\x2b\x38\x8d\x90\x58\x7c\x21\x00\x48\xf7\xfa\x6c\x76\x3f\xbe\xbf\x85\x96\xde\x50\xb2\xa7\x7b\x95\x7e\xb3\xe8\x95\x51\x99\xed\x3d\xc1\xca\x17\x0b\x73\x5f\xb2\x4d\x5d\xf9\xc5\xab\x3b\x0e\xbc\xff\x44\x76\x9b\xc3\x1a\x78\xd2\x36\x6d\xe2\xa2\xda\x40\xdb\xca\x1a\x6e\x6d\x30\xcd\xe5\x1d\xbd\x2a\xfd\xc1\xf7\x7e\xe2\xbf\x78\x60\xf3\x13\xef\x39\xcc\x93\xdb\xc6\xac\xe6\xcf\xee\x5a\x31\xa2\xf5\xf0\x8d\x03\xab\x43\x21\x28\xce\x1f\x30\xef\xb2\x3f\x1a\x14\xdc\xdc\xff\xa0\xf9\xfc\x10\x7c\xc9\x7c\xa3\x40\x8b\xcb\x49\x47\xf5\x3a\xcd\x29\xe0\x3b\x4e\xb1\x30\xc3\x3c\x03\xf2\xc5\x5a\x50\x7c\xdc\x52\xa8\x07\x45\x9b\x37\xf2\x55\x4c\x9f\x92\x31\x2e\x3b\xb7\x6c\xae\x63\xae\xde\xb2\x66\x79\xc5\x80\xb8\x2c\xfb\x80\x4c\xb5\x66\x9b\x83\x9d\xd4\xbb\x89\x5e\xba\xbe\x7e\xde\x64\xdd\x1a\xe5\x80\xdc\x81\xeb\xf1\x7d\xcb\xaf\x30\xdd\xec\xdf\xf1\xbb\x4e\x1a\x85\xc5\xc2\x58\xad\x00\xf6\x89\xce\x52\x02\x74\x94\x55\xa8\x07\x22\xc7\x09\x61\xa6\x85\xb6\x5e\xc2\x39\x29\xda\x39\xa2\xc7\xd5\x9c\xab\x99\x67\x9f\x57\x62\x5e\x35\xb7\x68\x88\xdd\xe9\x2e\xce\x51\x15\xde\x66\x67\x1a\xc0\x0e\x7e\xde\x7a\xfe\xcf\x73\xa6\x69\xbb\x61\x6f\x20\x7e\x3d\x92\x9d\x4f\xa8\x73\xd0\x0e\x48\xb5\x35\x09\x50\x8f\x34\xfd\xd4\xd6\x14\xff\xff\xab\xad\xd1\xfc\x3f\xa8\xad\x01\xa0\x01\x7c\xc9\x36\xc0\x79\x89\x43\xd5\xc6\x8c\xc9\x64\xd3\x9d\x41\xa7\x72\xc9\x8c\x08\xe5\x9b\xa6\x70\xe1\x69\xc4\x99\x70\xfa\xd5\xa1\xb1\xe4\xcc\xbb\x6a\xc2\xb9\x06\xa1\x04\xe4\x19\xf0\x25\x98\x5c\x59\x57\x3d\x6b\x8a\x69\x08\xf8\x27\xdf\xd1\xe2\x69\x5f\xd2\x02\x0e\xfc\xf6\x25\x91\xdf\xa7\xa1\x1c\x4c\xc4\x75\x38\x7a\x2a\xf5\x88\x3e\x06\x0a\xc2\x13\x4a\xad\x16\xbd\x08\xaf\x3e\x03\x7b\xa5\xf1\x04\x09\xd3\x53\x45\x36\xc7\xc8\x0c\xa1\x37\xa2\xd1\x6b\x26\xef\x06\x4b\x7b\xca\x66\x39\x66\x56\x9d\xab\x0a\x3e\xe3\xee\x71\x33\x67\x41\x16\xff\x56\x37\x7f\x18\x34\xd2\xbe\xed\xdb\xe1\x98\xbe\x86\x7d\x54\xe0\x7a\x21\x7c\x47\x41\x7e\xe4\x1d\x05\x5f\xa3\xe2\xa0\x2f\xe9\xdf\x7a\x39\x52\x73\xf0\x25\x33\xf0\x77\x61\xbf\x89\x80\x7d\x16\xc2\x06\x21\x2c\xba\x77\x00\xd2\xcc\xf5\x4b\x73\x24\xc5\xe0\x7d\x19\xb5\x32\x4a\x71\xbd\xe7\x07\x54\x0f\x73\x0a\xf2\xc2\x00\x23\x9b\x44\xca\x7b\x5c\xa3\x50\xc4\x38\x71\x95\xa1\x85\x32\xc1\x59\x50\x41\xbc\xe8\x50\x78\xb1\x50\x6b\x4f\xd0\xa7\xe1\x89\xa8\x10\x04\x37\x96\xc6\x4c\x11\x5e\x8e\x47\x27\xa6\x4f\x74\xac\xda\xbd\x6d\xf8\xd2\x9e\x25\x9d\xae\x4e\x47\xfd\x9a\xd7\x5c\x3d\x2e\x3e\xa1\xb8\x40\xa7\x1a\x33\xa8\x24\xa5\x67\x56\xf3\xea\x75\x74\x67\xef\x9d\xb7\xad\x5c\x5a\xc1\x1e\xde\xbe\xfd\xb7\x77\x02\x15\x99\xc5\x99\xae\x6c\x38\xbe\xf7\x20\x3d\x0b\x21\x3d\x7a\xca\x7c\x9a\x52\x00\x1f\xb4\x7a\x92\xd8\x0a\xfd\xa2\x69\x17\x8b\x2d\xb6\x05\x3b\xd4\xaf\xf4\xbc\x5e\x9b\x9e\xec\x1a\xd8\x33\xba\x35\x35\x97\xad\xfb\x6d\xaf\xae\x52\xb5\x03\x3d\xec\xb0\x10\xe2\x1a\x87\xc7\xe6\x3c\x1a\x4b\xe9\x9e\x82\x68\x50\xb1\x95\x52\x2a\xb6\x22\x26\x1c\x45\x65\xbe\xf0\x9a\x2f\x78\x7d\xbc\x41\xb7\xf8\x42\xcf\xc1\x49\x19\xd6\xc5\xab\xb2\x07\xbb\x93\x40\xeb\xf8\x0a\xd6\x76\x75\xce\xab\x5d\x9d\xba\x1d\x2a\x22\xb3\xcb\xe1\x3c\x20\xfd\xc6\xf7\x34\x20\xe6\x73\x62\x79\x00\xbe\xf5\xdb\xc7\x78\x98\x19\xbc\x69\x6b\xcf\x12\xe8\x45\xbe\xa4\x7f\xed\xbd\x13\xbd\xdd\x00\x75\xf4\x32\xd4\x51\x1f\x95\x77\x34\x27\x33\xfd\x14\x28\x3a\x4e\x69\x34\xf1\xa8\x26\xef\x98\xd3\xac\x37\x9e\xc5\x68\xf4\x04\x0d\x2e\xd4\x92\xcc\xd1\x7f\x2d\xd7\x52\xca\x9e\xd0\xf5\x93\xc2\xad\x63\x62\x4d\xc4\xc0\x0e\x73\xdf\xc2\xad\xd8\xa9\x71\xeb\xe6\xc5\x8d\x37\xb8\x53\x93\x5b\x0d\x93\xa4\x12\xae\x9e\x2a\xcf\xb8\xce\x29\xb8\x84\xeb\x46\x52\x1b\x31\x6b\x4a\x46\x5d\x6f\xef\x8d\x8b\x54\xec\x1d\xea\xf1\xe0\x3f\x55\x29\xcc\x38\x38\x96\x20\x1c\xcb\x47\x50\x0e\x33\xa8\xd4\x13\x66\x87\x3b\x96\x4d\x26\xb5\x1c\x36\x37\xaa\xe5\x30\xa2\x32\xae\x3f\xac\xe5\x80\x72\x19\x51\xc9\xe1\x17\x2b\x39\x16\x47\x54\x72\x3c\x73\xbe\x91\xf1\xcd\x18\x01\x89\x2e\xef\x1a\x0e\x89\x6e\xed\xa7\x8e\xe3\xb7\x77\xc1\xa1\x86\xaa\xe6\x86\x0e\x48\xaa\xb7\x0e\x5c\x16\xca\x38\x00\x35\x1a\xd2\xe8\xc1\x35\xee\x9e\xa3\xf1\x9c\x07\xd5\xc3\x39\x41\xfe\x51\x93\x1e\xda\x97\x22\xd1\xbe\x20\x31\x28\xc3\x37\x63\x08\xcc\x95\xf3\x51\xbe\x41\x80\x78\x4c\xf3\x0d\xa6\x59\xc3\x96\x18\xda\x1c\xeb\xe6\xda\xc6\xda\x20\xef\xc6\x1b\x56\xb0\x6a\x15\x77\x52\xa1\x21\x56\x48\x3f\x0e\xda\x9e\x07\x48\xb1\x59\xc2\x8d\x8b\x94\x1c\x64\x1a\xbd\x23\xae\x38\x2f\x99\xf3\xd7\xa1\xba\xb3\xfc\x6a\xbe\x08\xd2\xf6\x19\xa4\x4d\x09\x69\xcb\xa4\x52\x8e\x26\xba\x21\xf3\x8a\x8e\xe9\x95\xb4\x19\x95\xc3\x69\xa1\x18\xe0\x6b\x3b\xf0\x69\x55\x32\xff\xe2\xbc\xc3\xc8\xc6\x17\xb1\x8a\x2f\x2e\x48\x08\x4c\x2c\x61\xd2\x10\x7d\x70\xba\xd5\xc6\x93\x5a\x8e\xd0\xa4\x99\x3d\xd2\x93\xe9\xb6\x76\x58\xc6\x77\xa8\xdb\x8d\x2c\x2d\x14\xc2\x65\x2d\x52\x6a\xda\x13\x10\x4d\x49\x03\x7b\x5f\xd7\x55\xaa\xef\x60\x55\x48\x85\xc0\x7b\xb5\x24\x37\xff\x27\xb4\xcb\x39\x50\xc6\xd5\x94\xeb\x49\x6c\x08\x68\xa8\x3f\xf9\x47\x95\x80\x15\xeb\x09\xb1\xb4\xa7\x68\x91\x02\xa1\x03\x0e\xbb\x8f\xfc\x38\xf5\xb1\xad\xcf\xfe\x6d\xea\x63\x50\xe6\xf5\xbd\xdf\xd3\xbf\xf2\x00\x84\xb0\x9d\xf9\x05\xc6\x52\x3f\xe0\x1a\x3b\x13\xe5\xa0\x5c\x27\xf4\x71\x71\x8c\x15\x57\xda\xe9\xa4\x4a\x3b\xa1\x4e\x57\x56\x6d\x87\x77\xa2\xad\x16\x32\x7c\x0f\xf3\x83\x58\x6f\xc7\x4f\x68\x6e\x77\xf0\x07\xc0\xdc\x2d\x2d\x13\xe3\x40\xab\xac\xea\x8e\xd7\x4d\x9e\x16\x73\x12\x4c\x7d\x68\xda\x44\xdc\xef\x11\xaa\x87\x9d\x0f\x6d\x80\x11\x46\x98\x09\x54\xd6\x69\x38\x0e\xdf\x71\x7b\x5c\x9c\x46\x89\xaa\x2e\x4c\x09\x09\x06\x80\x04\x16\x1b\x38\x51\xdf\x70\x89\x77\x1a\xae\xb4\x30\x21\x3b\x8a\x0f\xac\xa4\x30\xf8\xbe\x0d\xaf\xb0\x0c\x0e\x8e\x96\xdc\xb9\xf7\xbb\xf7\x0b\xcf\x14\xde\x75\xff\x2f\x6f\x14\xd7\x5f\xb3\x7a\xf3\x99\x65\xcb\x6a\x86\xf6\x80\x78\xc5\x9e\x9b\xaf\x00\x1a\xc4\xf0\x3f\xa8\xee\xda\xf8\x05\xff\x33\xff\x29\x78\xf0\xdc\x43\xbb\xb4\xc7\x1e\x69\x6c\xc5\x6f\x28\xfc\x0b\xda\xa5\xef\xd9\xef\xa9\x22\x2a\xf3\x84\x3b\x8f\xc9\xcd\x4a\x47\xa1\xa5\x4e\x0d\x23\xcc\xe2\x63\x4e\x3b\x27\x16\x06\xf9\xc4\xba\xe1\x32\xa1\xe4\x20\x32\x69\x2b\x31\x17\xfb\x70\xaa\x8f\x82\x77\x6f\xb8\x8e\x78\x00\xbe\xaa\x11\x9d\x75\x63\x9e\x39\xf6\xc0\x9c\x1a\xe3\xc8\xd4\x74\xf7\xf0\xa2\xf1\x1d\x5c\x21\x78\x2c\xb6\x76\xf4\x5d\xb6\x82\xc6\x1b\x96\x3e\x7a\xff\xcd\xb7\x1a\x0e\xe8\x86\x96\x6d\x1a\xd8\xb5\x62\x36\xfd\xd6\xea\x55\xa9\x53\x35\x83\xd4\x77\xe8\xea\x5a\x2d\x79\x80\x01\x4e\x5f\xc1\xe4\xb8\x24\xbb\x29\xfe\x9a\x8e\x6b\xae\x9b\xd2\x69\x29\xc8\x1e\xeb\xc9\x74\xc6\xa3\xf7\xb6\x18\x28\xbb\x66\x2e\x84\x5e\x31\x3c\x6a\x8c\xd5\x9d\x02\x85\x47\xb9\x70\xe9\x26\xce\x2a\xa4\x38\x26\x32\x85\x03\x5d\xd5\x59\xee\x94\x82\x01\x45\x31\x77\xbb\x36\xdc\x5c\x9b\xea\x76\x16\x15\x94\xc5\xec\x74\xae\x3f\x17\x7b\x97\x7e\x60\x3d\x93\x71\xcb\x02\xdd\xdd\xfa\x40\xed\xd5\x37\x36\x2c\x20\x76\x76\x1b\xf5\x14\xb3\x99\xbb\x1b\xbd\x2d\x7e\x34\x91\x8e\x87\x9d\x9c\x30\x6b\xb5\x86\x58\x1d\x32\x96\x76\x28\x8f\x58\x74\x9e\x0f\x5b\x4a\xbc\x62\x1c\x55\x9b\xa7\x94\x94\xc4\x0b\x1e\xcb\x89\x6f\x30\xab\xd6\x6a\x87\xcd\x70\x0a\x25\x7a\x23\x94\x15\x89\xd9\x19\xe6\x55\x9d\x85\x83\x40\x50\x3b\x3d\xdf\xbe\xae\xa2\x48\xa8\xd4\xdb\x50\x39\x58\xfd\xe1\x8c\xae\x58\x12\x9f\xbf\x06\x73\x95\x31\xd0\xe6\xb9\x61\xae\x92\x1b\xd0\x79\x54\x0e\x07\x07\x0c\x4e\xa7\x99\x71\xa3\xb2\xbd\x78\x5c\xb6\xa7\x0b\x97\xed\xe5\x95\x89\xd7\x60\x01\x7c\xcc\x0a\x1f\x65\xb1\xa6\x14\x95\x84\x13\x45\x48\xa3\x0b\x0b\x39\xca\x18\x2a\x4b\x41\xa2\xff\xbc\x7f\x8e\x6d\x5e\x6e\xac\xa4\xbc\xd6\x49\x8e\x49\xfe\x67\xab\x97\x18\xf9\xbf\x1a\xd9\xcf\xf8\x8f\x40\x32\xff\xd1\x4d\xdf\x77\x28\xb4\xe3\x13\x51\x4d\x9f\x77\xd1\x4d\x20\xb9\xf7\xd6\x25\xe3\xeb\x93\xd1\x3b\x2e\x40\x01\x3e\xc4\x34\xe6\x51\x8e\xe3\xc0\x6e\xcf\x8b\x43\x7c\x4a\x85\x36\x85\xa8\x18\x09\x0e\x90\x7c\xd8\xc3\x25\xf0\xb8\xc8\x54\x7a\x03\x25\x96\x16\xa3\x70\x2f\x71\xf2\x6c\xe1\xe8\x01\x5a\xff\xfc\xa7\xbb\xf6\x9c\x28\x18\x91\x65\xb1\x8c\x74\x6f\xf5\x0d\xcd\x29\xce\x69\x1d\x33\x69\xbe\xd9\x32\xae\xee\x2e\x76\x5c\x7a\x6c\xdc\x9a\xfa\x19\xfb\xc6\xdf\xb6\x7a\xc8\xb5\xf5\x79\xa6\x18\xf3\xd6\x41\xc5\xb9\x4d\x63\x27\x94\x34\x8e\xdf\xd0\x95\xdd\x50\x9f\x58\x33\x1e\xd2\x56\x0e\xf9\xe7\x82\xb4\x59\xd0\x0d\x5d\x1c\x22\x4c\x27\xdd\x47\x85\x6e\x62\x92\x62\x3b\x9b\x4f\xbc\x4f\x85\x6e\xe3\x3f\x61\x5b\x7b\xea\x55\x85\x65\xb5\xb5\xc6\xfa\x9e\x66\xf7\x61\xf0\xc1\xc7\x96\x2c\x18\xd5\x55\x66\x79\xfc\xa5\x1d\x1d\xe0\x19\x3e\xfb\xbe\x3b\x85\xfa\xea\x0f\x18\x1e\xe6\x6b\x6e\x64\xaf\x74\x10\xbd\x09\xda\xd1\xbc\xa3\x4e\xbb\x54\xb7\xe4\xab\x0a\xdf\x04\x96\x24\x0f\x25\xf1\x42\x12\x8c\xf6\x99\x51\xad\x13\x16\xff\x79\x0d\xff\x2f\xae\xed\x7c\xb3\x7a\x7e\x70\xf3\x58\x57\xba\xcb\x1a\x64\x7f\xe8\x9a\xb9\x87\xff\xcf\x5d\x1f\x58\x0b\xc0\x15\xbe\x36\x2f\x79\xe1\x37\x7b\x27\xa9\x6e\xe7\x94\xd8\x4e\x3e\x0f\xbe\x62\xce\x0b\xb5\x82\xb4\x06\xdd\x86\xa6\x10\xeb\xd5\x48\x28\x96\xc2\xa4\x7b\x51\x7d\x14\x3d\x9d\xd4\x0a\x1a\x87\xbc\x7d\x99\xfd\xac\x57\x01\x1e\xf3\x6f\xc8\xda\xce\xb7\x40\xda\xd5\x30\x9e\x78\x97\xd8\xda\x63\x0a\x86\x61\x91\x37\x05\x4a\x25\x85\x2d\x6d\xa1\xd1\x27\x5c\x53\x23\xee\x84\x28\x81\xda\x01\x9e\xe4\xcf\xb8\xe8\x74\x27\x3f\x1c\xdc\xe0\x02\x5f\x6e\x06\x1f\x6f\xbd\x95\x4f\xd9\x46\xf4\xc6\x48\x9d\x63\x7e\x86\x34\xd9\xa8\xb4\x63\x36\x8e\xb3\x42\x3c\x47\x63\x34\x7a\xe4\x67\x58\x80\x1e\x64\x80\xe4\x11\x9d\x11\x30\x13\xbc\x7a\x20\x5f\x15\xf2\xf8\xe9\x2b\xfc\x69\x37\x9d\xee\x82\x7d\xac\xf5\x32\xb5\x29\xe9\xce\xe1\x03\xda\x82\x46\x7e\xa4\x93\x1d\xb7\x75\x0b\x9f\xf2\x67\x67\xa5\xfa\x36\x5d\x47\x73\xd2\x84\xcd\x44\x47\x4e\x80\x76\xb6\x1d\xe7\x3d\x89\x54\x4e\x40\xed\x8e\x89\xa1\x15\x2a\x8e\x53\xc0\x0e\x4f\x26\x32\x6a\x35\x64\x3d\x71\x1e\xcf\x23\xcd\x10\x2a\xee\xc8\x2b\x81\xe2\x36\x8f\x54\x5d\x90\x0d\x94\x40\x5a\xc0\x04\xc7\x0b\xf8\x3f\x3b\xe1\x98\x05\x7a\xf6\x77\xde\xd7\x52\x3b\xf1\xd6\xad\xa7\xa6\x82\x5a\x6f\xbe\xc3\xea\x19\x56\x00\xf6\x57\x0b\x4c\xb8\xa9\x6b\x52\xc3\xfc\xce\xad\x20\x31\x25\xd1\x62\x2f\xf1\xa3\xfb\xba\xb0\xbf\xfd\x0c\xaf\xde\x69\xec\x76\x4b\xac\x52\xa5\xd2\x52\x16\xc4\x8f\x18\x0d\xba\x18\x4c\xe4\x87\x10\x42\xe7\x89\x35\x80\xe2\xad\x9c\x64\x55\x24\x25\x09\x6d\x87\x95\x36\x4d\x9d\x7c\x5d\xa9\x13\x58\xf8\xd5\x2e\x7a\x86\x93\x7f\x77\xe1\xaa\xd7\x1e\xe6\xdf\xcf\x3d\x6d\x06\xc3\x97\x4d\x9b\x1e\xbc\xe9\xdf\x5b\x6f\xe1\x43\xe6\xbd\x6b\xf6\xbc\xfc\x4b\x3c\xaa\xcf\x62\xc0\x74\xf0\x37\x56\xa1\x50\x40\x89\xb7\x40\xf9\x74\x1c\x37\xc6\xc5\xc5\x28\x22\x2b\x2e\x85\x6b\x95\x8c\xe4\x98\x28\xca\xc4\x18\xc1\x32\x88\x6b\xf0\x4c\xec\xcf\x9d\xa7\x36\x2f\x5b\xbd\xe0\x09\x47\x75\xab\x1b\xf6\xf0\xb7\xa1\xe3\x5d\x00\x58\x15\x0a\xbe\x67\x0f\xbf\xb2\xe7\xc8\xfd\xfb\xc0\x8a\x27\xae\x76\x3c\xfc\xf8\xfc\xc0\x7e\xc6\xf3\xe0\x83\x53\xab\x1e\xa6\x98\x90\x81\xdd\x4f\x07\x14\x63\x61\x6c\x89\x6e\x97\x4f\x0a\xe8\x95\x0c\xa3\xd8\xd1\xce\x50\x01\x4a\xbb\xa3\x5d\x83\x0e\x85\x92\xf3\xed\xc2\x95\xab\x8c\xdf\xc7\x28\xd1\xa3\xd4\x1c\xb4\x9f\xab\x67\x2b\xbf\x36\x2b\x26\x64\xbf\x98\x7d\xf5\x37\xf8\x07\xbb\x1f\xdc\x92\xc6\x2f\xf2\xbc\xf6\xd1\x47\xf0\xff\xf8\xce\x98\x50\x19\xc4\x1f\xf7\x7f\xc0\x0f\x55\x5b\x09\xd2\xfc\x04\xbf\x56\xb9\xf1\x6b\x25\xcf\xf3\x67\x21\x72\x90\x92\xf3\x62\x0e\xbb\xdf\x03\xb6\xa4\xf1\xcb\xc4\x1e\x00\xff\x19\x3f\x26\xf4\x7a\xe8\x61\x98\xc7\x9a\x4e\x9a\xb2\xa8\xf3\x76\x8b\x03\x3d\x31\xea\xbc\x84\x1c\x23\x43\x5e\x54\x82\x3e\x90\x26\xff\x0c\x3f\x6d\x86\x2c\x99\x5d\xfc\xe7\xcc\xb6\xf6\xd4\x9c\x54\xb7\xc7\x9d\x59\x98\x99\x91\x5f\x04\x4a\x87\xe7\xe5\xa4\x64\xa6\xe8\x06\xa7\x66\xa5\x4e\xe7\xc7\xc4\x3b\x8c\x76\x63\x8c\x52\xa1\xd6\x99\xf5\xb1\x76\x8b\x51\x65\xb0\xe6\xbb\x93\xec\xf6\x04\x6b\xac\x82\x65\x6d\x89\x46\xab\x3e\x46\x6d\x64\xf1\x5a\x5c\x2b\xfb\x17\xba\x5a\xa1\x84\xba\x65\x79\x02\x58\xad\x06\x83\xae\x5b\x41\xe5\x39\x2f\xf9\x84\x27\x70\xd0\xe3\x57\xf2\xa2\xf8\x4a\xba\x02\xd0\x89\x25\x95\x0b\xaf\x59\x54\x35\x69\x86\xf6\x04\xd7\x96\x39\x79\xfe\x75\x43\xd3\x39\x7f\x62\x6a\xe2\xec\xe9\x79\x7e\xa7\xa5\x29\x39\x23\x19\xe3\x1e\xc6\x1e\x00\x6f\x73\x6f\xa1\xb7\xbd\x8f\x33\x74\x37\xfc\x67\x1e\x29\xb4\x67\x3c\x69\x76\xce\xb3\x0b\x54\x00\x75\x2e\x7f\x99\xdf\xcb\x35\xdf\x78\xfb\xdd\x58\xd7\x43\xd3\xe0\x6f\xde\x13\x7e\x43\xc3\xac\x04\x3d\xbb\x49\x8a\xfd\x3d\x5e\xbf\xdd\x03\x4e\xf3\x7b\x7f\x9a\xf9\x16\xa8\x60\x0f\xdc\x7d\xfb\x8d\x10\x7e\x12\x84\x7f\x4b\x80\xe7\x40\x37\xcd\x88\xf0\x8c\xc7\xae\xf4\x7a\xba\xc1\xa4\x9f\x66\xbc\xcd\x3f\xc7\xbd\x85\xc0\x21\xfc\x54\x08\xff\xa3\x00\x0f\xb8\x6e\x86\x16\x69\x02\x1e\xce\x9b\xe6\x01\x6f\xf0\xcf\xf1\xff\xc9\x01\x3e\x30\x89\x1b\x40\x88\x02\xfc\xaf\x6c\x0f\x5d\xc3\x7d\x0b\x93\x2d\x47\x40\xc3\xb0\x90\x5b\x1c\xdd\x0d\xd0\x33\xe8\xce\x0f\x0b\x9f\x2f\x34\x3c\x8f\xba\xb3\xa7\x71\x4a\xaf\x32\x6d\xcf\x4b\xd0\x6d\xc5\xcd\x7a\xbd\x97\xff\x82\xfb\x76\xe5\xf2\x9d\xb7\xdf\xb0\x7a\x17\xc2\xf1\x33\xc4\x51\x8b\x71\xd8\x03\x6a\x4a\x49\x73\xdd\x2c\xa3\x40\x83\x7b\xbe\x10\x23\x41\x25\xea\x5e\x48\x81\xdd\x4f\xd7\xf2\x8f\x5f\xe4\x7f\xcd\x05\x2d\xef\xfc\xc2\x4d\xd8\xb5\xfa\x86\xdb\x77\x2e\x5f\x89\xe9\x78\x93\x6f\x0d\x85\x42\x2f\xe3\x97\x35\xd4\x2c\xa5\x8a\xd1\xa8\x68\x5a\x85\x2e\x6c\x86\xe6\xc7\x70\x09\x47\xfe\x62\x32\x25\x2e\xf4\xf0\x6f\x96\xc4\x4e\xd4\x00\x5b\x71\x96\x4d\x69\x76\x18\x53\xab\xb4\x09\x7c\x2b\xb0\x8f\x1d\x93\x91\xcb\xcd\xe0\xca\xca\xee\x85\xf6\x84\x65\xe7\x82\x66\x38\x2a\x05\xa5\x39\x4a\x9d\x67\xe1\xf4\xbf\x02\x51\xe9\x01\x64\xa0\x1f\x34\x3b\x0e\x6e\x89\x0b\x69\x15\xca\x35\xf5\xf5\x6b\x8e\x94\x43\xbb\xc8\xa7\x40\x0c\xa9\xa1\x1f\x20\x7c\x0c\xa2\x44\xa3\xec\xd6\xaa\x54\xe4\x87\x97\xca\xc4\xe9\xaa\x02\x5e\x3f\xa7\xb4\x33\x3e\x3b\xd4\x40\x3e\xc5\x71\x70\xab\x83\x0a\xe9\x76\x5d\xdb\x9d\x77\xcd\xea\x2f\xf9\x56\x82\xad\x0b\x78\xee\xbb\x8f\xff\x18\x8e\xea\x2e\xb4\x96\xcd\x0d\x33\xa5\x43\x07\x4f\x19\x94\xf4\xe7\xf4\x6d\xb8\x3e\xd4\x07\xdb\x1b\xd9\x31\xb0\xbd\x5a\x68\x5f\x86\xdb\x93\xd0\x9b\x8c\x8a\x1d\xb0\x3d\x0d\x06\xc4\x4a\x1a\x9d\xde\x7d\x9d\xd2\x1c\x67\xbc\x5e\x2e\x9d\xca\x36\x16\x43\x18\xa1\xee\x12\xc2\x0c\x13\x60\xee\x86\x7e\x4d\x79\x94\xce\xa4\xa8\xaa\x62\x8a\xe0\xe1\xb7\xb3\xc7\x71\xbf\x69\x08\xbf\xea\x7b\xa6\x0c\xb7\xa7\xc0\x76\xe9\xb7\xb8\xbd\x5c\x80\x3f\x1d\x86\x37\x2a\xd5\xb5\x54\xf0\x97\xdf\x20\x4e\x26\xd5\x22\xe1\x4c\x81\x30\xb2\x7e\x21\x4c\x29\x86\xa1\x33\xec\x12\x4c\x33\x3f\x94\x7d\x45\xb1\x1f\xc2\xa4\x43\xfc\x5e\x6a\x19\xb5\x8e\xfa\xd1\xa8\xa4\x56\x80\xa9\x10\x40\x73\x1c\xc4\xc5\x49\xe3\xe8\x80\xb0\x37\x71\x47\x21\xec\x70\x08\x9b\x4e\x2d\x9b\x49\x61\xc8\x46\x02\x99\x98\x68\xc4\x90\x18\x6f\x02\xe4\xcb\x61\xcc\x17\x6f\x04\x5f\x68\xbb\x5d\xc2\x37\x1a\xf2\xe5\x3b\x4c\xdf\x08\x08\xa3\xa0\x77\x6d\x52\x20\xea\xb2\x31\x57\x10\x0e\x38\xf6\xc3\x78\x8c\xde\x08\x9e\x8c\x86\xed\xd2\xef\x70\x7b\x05\xe9\x13\x8e\x57\x82\xc7\xe3\x1d\x44\xc6\x6b\x09\xf3\x64\x34\x84\x09\xf7\x89\x60\x46\x10\x98\xac\x30\x4f\x12\xf8\x32\x79\xbf\xf4\x15\x7a\xa6\xf0\xdb\x32\x79\xbf\xb0\x7d\xa1\x00\x3f\x37\xa2\xdf\xea\xd0\xeb\x3f\xbf\x85\x70\xba\xed\xb2\x7e\xe7\x46\xf4\x5b\x1d\xfa\x91\xc0\x14\x86\x69\x43\xb2\xf4\x8d\x32\x1b\xc2\x64\x20\x18\xd5\x55\xd4\x2f\xa5\x3b\x41\x03\xb3\x99\x30\x8d\xf0\xb6\x05\xbd\x65\xa1\x40\xb8\x6a\xd0\x9c\xd1\x4f\x33\x43\x42\x5b\xd0\x58\x80\x25\xf4\x6f\x04\xcf\x64\x67\x1b\x65\xf0\xd1\x78\x7b\x25\xbc\x56\x6b\x34\xde\xbb\x64\x78\x9f\x61\x36\x0a\x78\x13\xfa\xc7\x0b\xc7\xf4\x0d\x1e\x77\x86\x30\xa6\xef\xf1\x98\x80\x8c\xdf\x2d\x10\x66\x09\xd6\x9b\x1a\x01\xe6\x5b\x32\xee\x6c\xbb\x4c\xf6\x67\x46\xe0\x19\x11\xfa\xf0\xe7\x10\xc2\x13\x17\xc6\x33\x04\xc2\xc8\xf1\x8c\x08\xbd\x86\x61\xe8\x3c\x39\x9e\xa1\xec\x37\x8a\x47\x09\x1e\x48\xff\x4e\xd8\x4c\x64\xf9\x31\x22\xa1\x3a\x9d\x24\x7b\x2d\x10\x76\x25\x77\x42\x18\x6b\x3a\x82\xc5\x90\x2b\x30\x24\x9d\x92\x22\x93\xe5\x4a\xc8\xbf\x6f\xb1\x2c\x67\x0a\xb2\x9c\x80\x65\x19\xc4\xc4\x10\x7c\x30\x46\xdb\x0d\x61\x7a\x15\x2b\x61\xe8\xe1\xa0\x8a\x02\x2e\x5b\x5c\x73\xd0\xa6\x09\x50\x2c\xc7\x36\x04\xcd\x1c\xa7\xa1\x35\xfa\x86\xa0\x4e\xc3\xd2\xf2\x72\x31\x9f\x50\x2c\xfa\x8a\x78\x77\x75\x9f\x33\xbe\xe8\x12\x64\xfa\xc4\x6d\xfc\x17\xb7\xc9\xce\xf6\xa6\xdc\xde\x2d\x9c\xed\xe5\x6f\x47\x3b\x9c\xf4\x57\xbd\x56\xfa\x2b\xd9\xc1\x5e\xfa\xe9\x57\x5f\x15\xe6\xf3\x41\xc5\x7c\x48\x77\x16\x91\x75\xe0\x01\x4a\x44\xb7\xc7\x23\xf1\x21\x95\x1f\xc3\x3e\xcb\xb5\x43\x98\x5a\x01\xa6\x04\xce\x35\xe4\x00\x0c\xd8\x44\x18\x54\x87\xf4\x89\xe2\x16\x08\x93\x2d\x8c\x3f\x9e\x7a\x11\xe1\xd1\xeb\xa5\xf1\x43\xeb\xc1\xae\x52\xcc\xa7\x5c\x30\x46\x4d\x0d\x98\xdd\x09\xcd\x41\x77\xc0\xce\xb8\x18\x8d\xd5\xca\x18\x22\x0b\x40\x9c\x78\xbc\xd2\x72\x8b\xec\xf8\x28\x3a\x40\x0b\xc7\x6d\x46\xb1\xe1\xa7\x8d\xcf\x2c\xbf\xe9\x16\xc3\x4d\xfc\x17\xd7\x19\x86\x55\xcf\xde\x13\xd7\xc5\x5f\x81\x3e\xcd\x51\x14\xe3\x56\x3f\x86\x86\xcd\x4c\x5d\xb5\x70\x5d\xf7\xc8\xe6\xde\x26\x7a\x7e\x53\x61\xcd\x90\xe3\xeb\x7a\x9f\xe2\x86\xf1\xff\x1a\xd1\x99\x4a\x0f\xc4\xef\xf3\x20\xda\xa1\xad\xf8\x04\xcb\x56\xb6\x60\x2b\x46\xe0\xf6\x74\xd8\xbe\x0a\xeb\xe3\x28\xa1\x7d\x9c\x74\x17\xfd\x27\x8a\x85\xe2\x58\xd5\xc3\x81\xa9\xaf\x0e\x52\x0c\x1e\xef\x8d\xc2\x78\x53\x28\x6f\xc0\x1c\xef\xf1\xb8\x93\x02\xb6\xdf\x1b\xb1\x70\xfd\xcb\x1f\x0c\x1a\x9d\x89\xf6\xa0\x35\xdf\x3f\x1a\x38\xb8\x33\xfb\xd3\xec\xde\xa5\xd9\x9f\x64\xff\xd1\xe8\xf3\xdf\x87\xff\xc3\xe3\x0f\x7d\x0b\xe5\x3c\x3c\x7e\x05\xb5\xa2\x85\xb4\x5f\x81\xed\xe1\xf1\xc3\xf6\x3a\x91\x5f\xb7\x87\xe1\xe1\xf8\x47\x86\x9e\xf8\x99\x47\xba\x68\x0c\xeb\x62\x3a\x84\x91\x7e\x8b\x61\x9e\x82\x30\xea\xa3\x20\x09\xe9\x62\x41\x3e\x82\x29\xe2\xd7\xb3\xaf\x60\x3c\x39\x58\x66\x76\xf3\x7f\xfd\xe5\x4a\x94\x4e\xc7\x40\x18\x3f\xc6\x53\x47\x60\x42\x00\xc3\xd0\xce\xb0\x4e\x17\x41\x3e\xbf\x82\x6d\x17\xc6\xa3\xfa\x37\x8d\xde\x1c\x8c\x3d\xc9\xd0\x40\xf4\x24\xc5\x48\x46\x63\x20\xdc\x66\xc5\xdf\x20\xdc\x0f\xd8\x37\x75\xbe\x8c\x28\x1b\x0a\xc6\x52\x15\x54\x71\x20\x85\xb1\xaf\xb1\x03\x5a\x6f\x07\x55\xf6\x6b\xec\x5b\xed\xcc\x79\xf8\x5f\x40\x63\xd0\x24\x69\x60\x24\x75\x5e\x03\x34\x48\xd8\x3b\xba\x20\xb2\x8e\x8e\xae\x49\x1d\x46\x34\x0a\xdc\x7f\x22\x45\x71\xad\x8a\x87\x4d\xe8\x0e\x08\x82\x71\x1b\xb1\x25\x46\xa3\x24\xfb\xf8\x9d\x26\xc5\xa3\x94\x16\xbf\x6a\x62\x20\xd7\x90\xe9\x63\xbb\x8d\x1c\xc7\x50\x2c\x39\x36\xed\xbc\x4c\x2e\xa3\xf1\x48\xc7\xc4\xd5\x34\x4c\x82\x94\x1c\xfd\x13\x39\x1e\x0e\x27\x78\x13\x39\x1e\x0e\x1c\xbd\xbc\x02\x64\x03\x5a\xc5\xaf\x21\xa7\xc3\x87\xf5\x16\xa3\xd3\xe1\xbd\xf3\xb8\xbb\x12\x7f\xc8\xbe\x82\xe9\xe2\xb7\x73\xad\x98\xbf\x03\x04\xf9\x9d\x85\xe9\xad\x86\x72\xfd\x31\xe6\xe9\x18\xa1\xfd\x1a\x32\x0e\xfe\x4c\x18\x1e\xfb\xbd\x21\xbf\x5c\x45\xf3\xa1\x0b\xcf\x47\x35\x7f\x26\xfc\x5b\x0c\x53\x23\xc0\x84\xe7\xa3\x13\xe2\x4f\xc3\x78\xf2\x04\xfc\xf3\x84\xb9\xdc\x2e\xcc\x65\xbd\xd0\x3e\x59\x82\xbf\x06\xdb\x20\x04\xef\x85\xf6\xa5\x05\x28\x8d\xe8\xfb\x5c\xc2\x47\x95\x4a\xe0\x23\x83\x71\x40\x58\x9c\xf1\x18\xe1\xac\xb9\x63\x34\xdb\x83\x31\xaa\x80\x4a\xd9\x10\x54\x31\x7a\x63\x73\x50\xcf\x40\x93\xca\x40\x93\xca\x08\x75\x8d\xd8\x78\xe2\x03\x05\x82\x19\x85\x2c\x25\x77\x79\xe3\x37\x02\x19\x64\x3e\xdf\x02\x53\xd2\x7e\xfb\x2d\x0d\x6c\x7a\x92\xff\x28\x8d\xae\xe0\x5b\xe8\xe9\x9e\xde\x7b\x77\x22\x13\x72\xee\xdc\x39\xe6\xa5\x73\x20\xe3\x91\x9f\x2f\x23\x83\x81\xe9\x3d\x1f\x1e\x1f\xe6\xc1\xf0\x5f\x69\xc4\x03\x85\x5d\x26\xb7\xa7\xc3\x63\xc5\x30\x79\x38\x86\x00\x1a\x39\x9f\xe6\x46\xe0\xa9\xa6\x18\xe2\x1b\x63\xe5\xf2\x3f\x37\x02\x4f\x75\xe8\x73\x02\x63\x92\xf0\x84\x7e\x85\xf2\xa7\xc4\xf2\x97\x2f\xc8\x5f\x27\xe1\x5b\x52\x92\x68\xc3\x43\x7f\x83\xf2\x77\x16\xc7\x65\x0d\xd8\x8b\x2d\xa3\xb6\x10\x18\xbf\x5f\xb4\xe1\x02\x9e\x1d\x22\x1e\x68\xc3\xd3\x88\x0f\x4b\x48\x88\xc2\xf3\x8c\x80\x47\x81\x63\x36\x08\x51\x5c\x1c\xf6\x85\xa1\x5f\xa1\xdc\x29\xf1\xb8\xf2\x85\x79\xae\xc1\xed\x7f\x83\x73\x77\x16\xfb\xe7\x06\xa1\x7d\x94\x14\x07\x7e\x8a\xfb\x2d\x10\xfa\xb5\x90\x7e\x4d\x26\xc9\x07\x61\xdf\x81\xfb\x6d\x94\xf7\x9b\x90\x20\x8f\x27\x21\xfe\x4f\x71\xbf\x05\x02\xfe\xb9\x61\x3b\xce\xd6\x93\xdf\xe2\xf6\xb1\x52\x2c\x28\xc1\xe3\x39\x8a\x25\x73\xa4\x97\xdb\xb1\xd3\xe1\xdf\x62\x98\x74\x02\xe3\x92\xc7\x82\x73\x23\xf0\x54\x87\xbe\x21\x73\x64\x97\xe3\x99\x1b\x81\xa7\x3a\xf4\x36\x81\x49\x09\xe3\xa9\x85\xbe\xf8\xb4\xe2\x3b\x08\x53\x88\xed\x18\x4f\xcf\x0c\x3d\x47\x19\x03\x6a\x86\x4e\x4d\x4a\x05\xa9\x88\x19\xc8\xfc\x88\x6f\x97\xbd\xaa\x8c\x81\xb0\x4d\x38\x8e\xb9\xc0\xce\xe1\x57\xe2\xb9\xbf\x9b\x9a\x49\x35\x07\xaa\x98\x72\x7d\x39\x58\x53\x0e\x0c\xe5\x80\x76\x59\x5d\x69\x2e\xba\xc8\x55\xed\x3a\xee\xba\xe0\x7a\xd3\xf5\x77\x97\x22\xdf\xd5\xe0\x5a\xe8\x62\x0c\xae\x24\x57\xbe\x6b\xb2\xeb\x4f\x2e\x6e\x84\x0b\x30\x43\x5d\x20\xc9\x05\xe1\x11\x53\x27\x2d\xea\x9a\xd4\xd5\xb5\xa8\x03\x1a\xba\x0e\x64\xf5\xfa\xa7\x31\x84\x69\x34\x07\x34\x6c\x14\x91\x02\x3c\x7e\x63\x4d\xf1\xb2\x8c\xce\xd1\x98\x4e\xe4\x33\xdb\xa8\x69\x81\x31\x2c\x53\xac\x2f\x06\x89\xc5\x79\xc5\xd7\x14\xaf\x29\x66\x07\x15\x8b\xe4\xe6\x47\x92\x1b\xc0\x04\xb3\x84\xe0\x06\x48\xf2\x42\x57\x37\x24\x5b\xf5\xdf\xc8\xfe\x1d\xba\xaf\x62\xba\x75\x27\x18\x18\xc6\xc9\xe3\x5b\x42\xef\x05\x91\x5e\xf5\x10\x6a\x1b\x95\x40\xe2\x22\x21\xbe\x15\xc3\xbe\xe2\x7e\xf1\xf6\x4a\x78\xd3\xd2\xa2\xf1\x1e\x54\x3c\x27\xe1\x1d\x0a\x96\x09\x78\x0b\xfb\xc5\x0b\x7d\x0a\x7b\x11\xeb\xb4\x4f\xd0\xe9\x49\x24\xea\x74\xbb\x25\x5d\x44\xf5\x1e\x9b\xb1\x4e\x37\x23\x9d\xa0\x96\xcd\xc7\x10\x62\x00\x2e\xc3\xb3\x43\xc4\x13\xce\xb1\x9c\xce\x08\x3c\xdd\x58\xb7\x9a\x89\x6e\x7d\x83\xf1\x64\x66\xca\xf0\xa0\xfc\xe0\x23\x8c\xa7\x38\x12\x4f\x98\x1e\xf4\x06\x38\xfb\x00\xc6\x33\x96\xe0\x29\xc2\x3a\xea\x74\xca\xf1\x40\x5d\xfc\x08\xeb\x4a\xb1\xa0\x8b\x24\x3f\x1a\x05\xdb\x1f\xc0\xb6\x61\x2c\x69\xa7\xdb\xc3\xf0\x38\x5e\x2f\x16\x7c\x43\x15\x18\x6a\x14\x7e\x87\xfa\x77\xb9\xc2\xb9\x22\xc2\x81\xe3\xd4\xb1\x02\xec\xc4\xd0\xbf\x11\x2c\xdd\x41\xac\x85\xc3\x21\xc5\xab\x28\x37\x96\xe8\xc0\x7a\x3d\x86\xe4\x78\x4e\x8b\x4c\xaf\x4f\x87\x69\x42\x30\xa1\x8d\x44\xf7\xed\x61\x9d\x65\xe1\xbc\x3e\xab\xb8\x0f\xc2\x94\x48\x7c\xf9\x00\xf5\x95\x97\x27\xd1\x55\x0d\x61\xe6\x61\xbe\x8c\x93\xdb\xae\xfc\x7c\x19\x5f\x58\x48\xfb\xb3\x5c\x1b\xc1\x23\xcb\x63\x91\xaf\x9e\x87\xed\xc6\xb8\x88\x76\xd4\xef\xdb\x58\xee\x70\xbf\x6a\x8a\x5e\x87\xe5\x8e\x06\x3e\x9f\x5c\xee\x50\xdf\x7f\xe5\xde\x13\xfa\x46\x70\x5b\xf8\xc3\x18\xae\xa8\x48\x2e\x6f\x64\x1c\x61\x7c\x40\x90\x63\x04\x17\x8d\xef\x16\xc5\xeb\x02\x3d\x5e\x38\x96\x6c\x60\x80\x63\xda\x88\x23\x60\x40\x17\x14\x08\x58\xc5\x31\x89\xbc\xc1\xb0\x90\x37\x46\x61\x0c\x88\x03\x39\x39\x61\x1e\xa1\x71\x8a\x3c\x82\xb9\xd6\x2e\xac\x4d\x12\x64\x6e\xae\x8c\x57\x87\xa0\x9f\xca\xc5\xb2\xe8\x8f\x90\x45\xa0\xd5\x4a\xf8\x3e\x43\xf7\x40\xe0\x7c\xa4\x55\x80\xd1\xc0\x7c\xc4\x11\x30\x82\x24\x7d\x12\xc8\x4b\xaa\x4a\xea\x49\xfa\x36\x89\xc5\x0e\x12\x5b\x37\x84\x17\xfa\xad\x5c\x2c\x13\xfe\x08\x5e\x7f\x06\x69\xab\xe1\x5a\x08\x2e\xdc\xde\x8a\xdb\x0f\xf0\xa7\xc3\xf0\x58\x86\xac\x44\x3e\x54\x61\x19\xfa\x0c\xca\x90\xf4\x5b\x0c\x33\x91\xc0\xc4\x87\x65\x68\x18\x3f\x37\x02\x4f\x75\xe8\x18\xf1\x0d\x86\x30\x9e\xed\xd0\x7f\xc8\xf1\xc0\x78\x92\xc0\xa4\x85\xf1\xcc\xe1\x17\xb1\xff\xc0\x78\x4a\xf1\xda\xc3\x67\xc2\x9a\xc4\x04\xd8\xbe\x9b\x2d\x87\xed\xe3\x85\x76\x12\x07\x96\xc0\x7c\x59\x82\xc7\xf9\xf2\x73\x24\xa7\x4e\x0e\xf7\x1b\x80\x30\xd2\x6f\x31\xcc\xab\x04\x26\x5d\xde\xef\xdc\x08\x3c\xd5\xa1\x77\x09\x6d\x09\x61\x3c\x13\x20\x8c\x1c\x4f\x75\xe8\x22\x81\x49\x96\xe1\x81\xb2\xf5\x0f\x2c\x83\xa5\x82\xff\x9b\x20\xc8\xa0\x18\x80\x90\xf9\x9f\x00\xe1\x0e\x28\x81\x30\x1e\xe4\x53\xea\x05\xdf\xb7\x04\xfa\x94\x60\x60\x38\x5d\xa6\x2f\x9b\x54\xb6\xa6\x6c\x6b\x19\xab\x2f\xcb\x83\xff\xc2\x00\xa7\xd5\x99\xe6\xa4\x8b\x9c\xd5\xce\xe3\xce\x0b\xce\x37\x9d\x7f\x77\x2a\xf2\x9d\x0d\xce\x85\x4e\xc6\xe0\x4c\x72\xe6\x3b\x27\x3b\xff\xe4\xe4\x46\x38\xa1\x2f\x71\x82\x24\x27\xa0\x9d\xd1\xbe\x44\x90\x91\x28\x1a\xd5\x34\xa6\x11\xe7\x1a\x62\xc6\x8c\x65\x1f\xd1\xb8\x1b\xfb\xbd\xf1\x82\x2d\xb2\xe3\xb8\xab\x93\xca\x04\x39\x54\x5e\x20\x89\xa1\x93\x13\x93\xab\x92\xb7\x26\x33\x54\xb2\x21\x99\xd6\x27\x7f\x97\x4c\x03\xb7\xc1\x9d\xe4\x0e\xb8\x19\xb7\x91\x78\xd1\x8e\x2e\xd8\xb5\x94\x67\xdc\x0f\xe5\x7e\x36\xb6\x85\x65\x24\x17\xa2\x32\xa8\x6f\x91\xdc\x5b\x2c\x92\xdc\xe3\x77\xd4\xb8\x33\x10\x26\x88\x6d\xcd\x6e\xa2\x3f\x16\x8b\x4c\x7f\xee\x87\x72\x3e\x1b\xcf\x57\x59\x84\x9c\x6f\x84\xed\x26\x3c\x47\xc1\x88\x76\x18\x4d\x72\x73\xb0\x2f\x2a\xc7\x63\x18\x1a\xfa\x2b\xf5\x6f\x62\xd9\xa5\x7e\xf1\x7b\x6d\xd8\x17\xb5\x61\x5f\x34\x74\x23\xee\xd7\x6e\x97\xf5\x4b\xf0\x3c\x2a\xe1\x59\x46\xdd\x45\xfd\xf4\x5f\xf0\x2c\x9b\xf8\x7b\x78\x6e\x90\xf0\x74\x52\xb9\xd4\xa7\x58\x4e\x44\x44\xc5\xe1\x37\xe4\xb8\xfb\x24\x5c\x9d\x80\x64\xe9\x22\xb2\x62\x09\xd7\x0e\x11\x57\xd8\x96\xc4\xc7\x47\xd1\xf4\x8c\x88\x47\xb4\xdf\x11\x7e\x0d\xe6\x30\xdc\x1c\xcc\xd3\xf2\x08\xde\x05\x61\x7b\x36\xe6\x69\x9b\xbc\x1d\xbf\x77\x3e\x18\xf7\x5b\x21\xf4\xab\x27\xfd\x8a\xeb\x25\x10\xe6\x45\xb4\x26\x87\xfb\x6d\x97\xf7\xab\xd7\xcb\x62\x6d\x82\x67\xa1\x88\xa7\xff\xb5\x08\x09\xd7\x7d\x22\x2e\x34\x6e\x01\x2a\xcc\x0b\x24\x5f\x33\x31\x4d\x03\xa5\x35\x9c\xd7\x23\xd7\xc4\x42\x6f\xf1\xad\x9c\x1e\xd3\x34\x81\xd0\xf4\x15\xa6\xc9\xed\x96\xd1\x84\xde\x81\xfc\x5c\x71\x00\xc2\x0c\x22\xba\x0e\xb2\x08\xe5\x06\x03\x27\x5f\x2f\x9a\x8f\xd7\xd6\x3a\x30\x9e\x0d\x22\x84\x1c\x0f\xb4\xbb\x9f\x63\x9e\x0e\x12\x78\x57\x2d\xad\xd7\xcc\xc7\x3c\xed\x88\xe0\xe9\x37\xd0\xd6\x4a\xf0\x72\x7b\xac\x09\xdb\x21\x0f\x84\x91\x7e\x1b\x01\x63\x8f\x8c\xf9\x65\x6b\x17\xb5\x54\x7c\x9f\x98\x1f\xf9\x97\x76\xc5\x16\xd1\x1e\x63\x7e\x7e\x07\xe3\x60\x2d\x0d\x52\xf3\x52\xab\x52\x69\x1c\x08\x77\x48\xf1\x27\x96\x21\x85\x55\x92\xa1\x7b\xa0\x3f\x8a\x92\x45\xc2\x5b\x85\x56\xe2\xed\x3d\x1a\x32\x47\x62\xd8\x82\xf8\xe6\x83\x76\xa5\x51\x91\x69\xc2\x7b\x0c\x10\x66\xcd\x77\x19\x28\x0a\x1a\x32\x44\xe4\x1b\x45\x03\x1d\xe4\xed\x55\x45\x17\xce\x90\xd1\xfb\xfc\xd6\x58\x7d\x73\x7b\x2c\x47\x71\x0d\x41\x9a\x62\xc5\x8a\x3f\x52\x7e\x1f\x2e\xcd\x34\x57\x02\x54\x22\xc1\x9c\xc1\x17\xe7\x4d\x9b\x6f\xee\xe1\xbf\xb8\x90\xcc\x7b\x33\x81\x23\x93\xab\xc7\xab\x86\x57\x33\x98\x7f\x1d\x3e\xd4\x2c\xbc\x6b\x1d\xfa\x19\xd2\xf2\x19\xd7\x46\xa5\x50\xbe\x80\xcb\x68\x8e\x37\x4f\x0a\x7a\x0c\x06\x7d\x63\xd0\x60\x88\x4b\x8a\x67\xe3\x4c\x8c\x6a\x4a\x90\x63\xcc\x42\xd1\xa5\xf4\xd8\xa8\x50\x22\x61\xa1\x3c\xc9\xe2\xdd\xf7\x68\xbb\x17\x84\x09\xc1\xc5\xaf\x20\x01\xb0\x0f\xf1\x7f\xe6\xf9\xf1\xd7\x8d\xaf\xa8\x5f\xb1\x6e\xf6\x75\x83\x53\x80\x72\xd0\x8c\x55\x5b\xd3\xef\xe6\xdf\xbd\x27\xe3\x5e\x2a\x74\xea\xde\xb7\x66\xf0\xcf\x5c\xbb\x1e\x7c\xf7\x3d\xff\xb5\xe3\x7d\xfb\xea\xeb\x6b\x6b\x8e\x82\xb8\xa6\x5d\x17\xaf\xfe\xc0\xb8\x5f\xfd\x6e\xcd\xaa\x7d\xfc\xe5\xb8\x9b\xf0\x9e\xcd\x76\xf9\x9e\x8d\xa4\x9f\x3e\xd8\x2e\xdb\xb3\x91\xeb\x27\x3b\x5d\xf1\x0b\x81\x87\xba\xf0\x32\x43\x24\x94\x4e\x4c\x94\x64\x18\xcf\x05\xf7\x9b\x30\x17\x4a\xd5\xbf\x98\x39\x04\x66\xc4\x08\x29\xa7\x46\xfa\x39\x4f\xa9\x12\xf1\xa8\x0b\x85\x75\x75\x46\x0a\x5c\x89\xfd\x80\xb8\xa0\x6d\x4f\x17\x71\xa9\xcb\x25\xb8\x61\xc3\x64\x71\x1a\xa1\x4b\x86\xcf\x27\xc1\x89\x06\x4b\xc2\xc7\x4e\x92\xe1\xab\x90\xe0\x44\xe2\xc2\xf6\x43\xad\x54\x4a\xf8\x8a\x24\xb8\xf4\xf4\x68\xfa\x32\x15\x4b\x25\x7c\x03\x25\xb8\xaa\xaa\x68\xfa\x76\xc9\xe8\x2b\x96\xe0\x0a\x0a\xa2\xe9\x3b\xad\x90\x78\xa7\x1e\x24\xc1\x05\x83\x11\xf8\xe0\xfc\xdc\x8c\x6d\x09\x9a\x37\x2f\x99\x1f\x6c\x53\x8c\x98\xd7\x8c\xcc\xf7\xa1\xb9\x0c\x62\x9b\x52\x8d\x63\xc8\x0d\x11\x31\x24\x5d\x5e\x1e\x69\x37\xd9\x55\x4a\x8d\x44\x67\x89\xd4\x7f\xe4\x7e\x07\xa2\xf3\x4d\xc5\xaf\x12\x9d\x95\xf4\x0c\x01\xae\xac\x2c\x7a\xdc\x72\x7c\xfe\x3f\xc0\xb7\x5c\x86\xaf\xea\x7f\xc4\x57\x2a\xe1\x13\x1d\x44\x18\xdf\x4a\x25\x2d\xe1\x0b\x48\x70\x75\x75\x7d\xe7\x25\x8c\xaf\xec\x0f\xf0\x3d\x89\xe5\x9e\xe0\x1b\x4c\xa3\x47\x9f\xa1\x5d\x63\xe8\xe6\x59\xcd\xcb\x9b\xe9\x66\xa3\xdc\xae\xe1\xf9\x79\xa0\x9f\xf9\x19\x09\xd4\x64\x7e\x44\x37\x24\xcc\xcf\x4a\xd9\xfc\xec\x8c\x9c\x1f\x91\x01\x52\xde\x27\xed\xf7\xc8\xf4\xb5\x05\xb6\x4b\x7b\x3c\xb8\x7d\x74\x78\xff\x0a\xd3\x9d\x11\xa1\xaf\x40\x96\x9f\xe2\x3d\x31\xac\xaf\x35\x82\xbe\x5e\x4f\x7a\x16\x93\x16\x09\xcf\xa3\x12\x9e\xdd\x94\x85\xc4\x58\xe2\x34\x0a\x78\x8e\xe3\x18\xab\x86\xc4\x58\x16\x8c\x25\x27\x27\x32\x5f\xe6\xba\xb1\x1e\x64\x08\x7a\xbf\x42\xf0\xb8\xe2\x66\xa9\xb4\x9f\xc6\xad\xc2\x7a\x5a\x23\xe8\xfd\x0a\x61\x5e\xf2\xf2\xfa\xee\xcf\x85\xf1\xf9\xe8\xeb\x04\x7c\x91\x31\x0f\xd9\xf7\x0b\xe3\xab\xa0\x17\x49\xfa\x17\x85\x8f\x8b\xc7\x7a\x9f\x21\xe8\xbd\x48\x5f\xe4\x7a\x08\xa2\xaf\x18\xeb\x7d\x8d\xa0\xf7\x22\x3e\x71\x79\xa0\x7f\xfa\x8a\x25\xfa\x06\x0c\x88\xa6\xef\xa0\x42\x9a\x03\xa8\xf7\x6d\x02\xbe\xa1\x43\x23\xf7\x0d\xe1\xfc\x63\xb9\xc2\xfb\x74\x50\xdf\x03\x82\xb4\x2c\x25\xf3\x2a\xee\xab\x89\x32\x21\xdb\xa7\xdb\x60\x21\x90\x95\x64\x76\x53\x53\x65\xf3\x82\xf7\x0a\xb0\x9c\xe4\x08\x72\xb2\xb8\x8f\x9c\xa0\x7d\x02\x3f\x96\x93\x1f\x22\xec\x3a\x9c\x3a\x49\x4e\x8a\x60\x9f\xd2\xde\x85\x4c\x3e\xc3\x6b\xdc\x75\x11\xb9\x62\x2d\x6c\x3f\x8d\xf3\xfb\xc2\x08\xf8\x3a\xd8\xbe\x0e\xcb\x73\x53\x44\x3b\x59\x57\xfa\x45\x5c\x57\x0a\xfb\x1f\x59\xce\x8c\xd7\xaa\x30\x9d\x4d\x91\xfe\x47\x9c\x1a\x82\x47\xf0\x3f\x85\x51\xfe\x27\x23\x23\x6a\x7d\x4a\xf0\x3f\x4d\x51\xfe\xc7\xeb\xed\xb3\xde\x25\xc3\x17\xf6\x3f\x59\x59\x7d\xd7\xd1\xc2\xf8\xc2\xfe\x27\x52\x6e\x10\x7d\xc4\xff\x14\x46\xf9\x9f\xc8\x75\x8c\x3a\xc9\xff\x34\x45\xf9\x1f\x8f\xe7\x8f\xe8\x0b\xfb\x9f\xca\xca\x68\xfa\x88\xff\x69\x8a\xf2\x3f\x15\x15\x11\xf8\xd0\xbc\x61\x39\x2c\xec\xdf\xff\xc8\xf6\x49\xf1\x5c\x62\x39\x6c\xea\xcf\xff\xc8\x63\x64\x3c\xee\x47\x51\x4e\x85\xce\x50\xe0\xdc\x75\x35\x81\x12\xa7\x45\x18\xf3\x14\x94\x0b\x81\x69\x24\x17\xea\xec\xbb\x2e\x47\xf0\xec\x97\xf0\x0c\xa1\x1e\xfe\xaf\x78\x86\x1e\xf8\x3d\x3c\xbf\x88\x78\xa0\xbc\xed\x20\x78\xc4\x69\x90\xf0\x84\x04\x3c\x48\xde\x3a\x61\x38\x09\x61\x0a\x0b\x23\xe4\xed\x51\x64\x3f\x05\x3c\xbb\x43\x5f\x60\xfb\x19\x25\xb7\x10\xcf\x19\x91\x1e\x7a\xf7\x27\xb8\xa7\x88\x35\x1e\xc8\x77\xee\x51\xee\x06\x82\x07\xeb\x45\x86\xa8\x2f\xdc\x14\xa4\x2f\xe8\xb7\xb8\xdd\x2d\xac\x41\x6c\x97\xaf\x7d\x48\x7a\x34\x01\xb6\xcb\xd6\x3e\x60\x7b\x9e\x6c\xad\xe1\x17\x31\x8f\x0f\xdb\x01\x31\xec\x11\x73\x78\xac\x5f\xe3\x23\xed\x40\x46\x86\x34\xde\x59\x70\x2c\xaf\xe0\x79\xec\x12\xe6\x71\x4b\x1f\x3c\xad\x10\x06\x9f\x89\x01\x8b\xc8\x3c\xce\x16\x56\xbf\x64\xe3\x25\x78\xf6\x0b\x78\x14\xea\x21\xd7\x45\x60\xc1\x30\x91\x78\x50\x1e\xbe\x94\x8a\xc0\x24\xe1\xf9\x45\xa4\x07\x8e\x6b\x16\x81\x11\xc3\x2f\x09\xcf\x6f\x22\x1e\x38\xae\x91\x91\xbb\x38\x12\x9e\x47\x25\x3c\xbb\x43\x57\x88\x1f\x14\xd5\x5c\xc2\x73\x46\x1c\x17\xbd\xfb\xd3\xbe\xeb\x9a\xb3\xe0\x7c\xbd\x82\xe7\xb1\x4b\xe0\xbf\x93\x8c\x05\xb6\xdf\x84\xe6\x05\xfd\x16\xb7\x1b\xa4\x35\x8e\x99\xd8\xff\x0e\x14\xc6\xf8\x09\x59\x23\x50\xab\xa3\x72\xd0\xa3\x62\x9e\x44\x0d\x7d\x2e\x62\x75\x57\x5a\xe3\x98\x89\xe5\x61\x60\x44\x5c\x8f\x7f\x8b\xe5\x61\x02\x69\x67\xb7\xc8\xfa\xfd\x45\xca\x7d\x5f\x66\x96\x88\x6b\xc6\x51\xfd\xfe\x26\xf4\x8b\xf8\x36\x93\xc0\x88\x26\xb2\x2f\xfd\x78\xfd\xe5\xdb\xc8\xbd\x2c\x01\xcf\x19\x29\xcf\x13\xd6\x68\x92\x93\x65\xf4\xe7\x61\xbf\x9b\x6f\x4a\x67\xb0\x1e\x29\x6f\x03\xb1\xd4\x74\xa4\x25\x03\x06\x48\x7d\x45\xc3\x5c\xa4\xfe\x49\x60\xc4\x19\xe8\x07\xe6\x7e\x8c\x07\xd9\x39\x11\x51\xff\xfd\x1d\x94\xe0\x44\x64\xfd\xc3\xed\x05\xb5\xff\x13\xbe\x43\x12\x5c\x3f\xf8\x94\x2b\x24\xb8\x7d\xd4\xaf\xbf\x8f\x4f\x06\x77\x58\x82\x8b\xc0\x47\xf2\x23\xec\x7f\x71\x9e\xa7\xbc\x2d\xd4\xda\x6f\xfb\x45\xa1\x3d\x26\xaa\xfd\x7e\xfe\x01\xdc\x5e\x1c\xd5\x7e\x50\x68\xf7\x44\xb5\xef\xe5\x9f\xc0\xed\x23\xa3\xda\x0f\x09\xed\x24\x5f\xb3\x49\xed\xfb\xf8\xde\x7e\xdb\x0f\x93\x76\x6a\x0c\xb4\x39\x0f\x61\xbe\xcd\x14\xe6\x5d\x8d\xe7\x54\xae\xe3\xd1\x30\x17\x81\x9d\xc0\xc8\x64\x23\x1a\xe6\x7e\x90\x8a\xf9\x45\x4b\x88\x8a\xfb\xed\xef\xa0\x04\x17\xc9\xff\x68\xb8\xbd\x60\xc8\xff\x84\xef\x10\x28\xed\x0f\x5f\x68\x27\x5e\x8f\xba\x24\xc6\xf7\xca\xdb\xf8\x61\xb8\xfd\xe9\xa8\xf6\x8b\x7c\x33\x6a\xe7\xcd\x51\xed\xf7\xf7\x3e\x8a\xdb\x2b\xa2\xda\x0f\x0a\xed\xd1\xf0\x7b\x7f\x07\xfe\x10\x69\xa7\xb2\xf8\xf1\xec\x7a\x4c\xf7\x6c\x81\xef\x01\xc2\xd3\xb4\x34\x89\xa7\xd1\x30\x17\x41\x0e\x81\x91\xe9\x7f\x34\x8c\xa8\x6f\xb4\x84\xa8\xb8\xdf\xfe\x0e\x4a\x70\x91\xf1\x16\x82\xdb\x25\x83\xdb\x0b\x26\xfe\x2e\x3e\x39\xdc\x21\x09\xae\x2f\xbe\x77\x94\x53\x24\xb8\x7d\x70\x0c\xa3\x7e\x07\x9f\x1c\xee\xb0\x04\x17\x81\x0f\xcf\xe3\x27\x98\x9f\xd9\x7d\xe6\x51\xde\x2e\x9f\x47\x79\xbb\x7c\x1e\xe5\xed\xf2\x79\x94\xb7\xef\xfd\x1d\x78\x61\x1e\xf9\xcf\x51\x3b\xd6\xab\x6c\x41\xdf\x06\xf4\xdb\x7e\x98\xb4\x53\x67\xa1\xbc\x56\x60\xbe\x75\x92\x79\xa7\x9e\x25\x73\x2a\x2e\xcc\xf5\x03\x73\x91\x7a\x8d\xc0\xc8\xf6\x13\xa3\x61\xee\xa7\xbe\x13\xf8\x2f\xad\xf0\xf5\xdb\xdf\x41\xea\x23\x01\x4e\x5a\xe5\xeb\x17\x6e\xaf\x04\xf7\xc7\xf8\x0e\xfd\x01\xbe\x6b\xf1\x7c\x76\x0a\x76\xf6\x92\x30\x9f\x7d\xf1\xc9\xe1\x0e\x4b\x70\x11\xf8\x42\x0f\xa3\x3c\x0a\xf3\x3f\x47\x98\xf7\x66\x69\xde\xe5\xed\xf2\x79\x97\xb7\xcb\xe7\x5d\xde\x2e\x9f\x77\x79\xfb\xde\xdf\x81\x97\xcf\xfb\x2b\x78\x7e\x73\xfa\xcc\xbb\xbc\x5d\x9c\x77\x92\x9f\xe4\x8b\xf1\x3f\xd4\xf7\x78\xe2\x3b\x93\x92\x8c\x11\xf9\x95\x0c\xe6\x22\xf0\x10\x18\xd1\x53\xf7\x03\x73\x3f\x30\x09\x7e\x49\x44\x54\xdc\x6f\x7f\x07\x25\x38\x11\x59\xff\x70\x7b\x41\xe1\xff\x84\xef\x10\x28\xe8\x0f\x5f\xe8\x07\x94\xe7\x60\x7e\x15\x0a\xf3\xb4\x07\xff\xde\x18\xd5\x7e\x91\xf8\x37\xbe\x3e\xaa\xfd\xfe\xde\xcf\x70\xfb\xf2\xa8\xf6\x83\x42\xfb\xfb\x51\xed\x7b\xf9\x2e\xdc\x2f\x13\xd5\x7e\x88\xb4\x53\x9d\xb0\xfd\x7a\x2c\xaf\xcb\x04\x7d\xeb\x25\xba\x24\x9e\x0c\xef\x07\xe6\x22\x8c\x00\xa7\x93\x33\xa9\xbf\x0b\x73\x3f\x75\x45\x90\x7b\x11\x51\x71\xbf\xfd\x1d\x94\xe0\x22\xf3\x46\x04\xb7\x5e\x06\x27\xc6\x35\xfd\xe1\x93\xc3\x1d\x92\xe0\xfa\xe2\xdb\x89\xf5\x68\x99\xa0\x6f\x5f\x0b\x7a\xd4\x17\x9f\x1c\xee\xb0\x04\x17\x81\x2f\x34\x0b\xc5\x95\x98\x9f\x03\xc9\x7c\xf5\xfe\x82\xda\x7b\x4f\x47\xb5\x1f\xec\xf5\xe2\xf6\xcb\x51\xed\x87\x7a\xf1\xf9\x77\x7e\x0a\x6a\xc7\xfa\x40\xda\x0f\x0b\xfe\xcf\x02\xe9\x38\x84\xc7\xb5\x22\x32\xee\x90\x9d\xf1\x8d\x86\x91\xe2\x0e\x59\xde\x10\x0d\x13\x8e\x3b\x44\x44\xc5\xfd\xf6\x17\x8e\x3b\x44\x64\xfd\xc3\xed\xfd\x1f\xf1\x1d\xfa\x03\x7c\xe7\x30\xbf\x57\x08\xfe\xcf\x24\xf0\xbb\x2f\x3e\x39\xdc\x61\x09\x2e\x02\x5f\xe8\x25\x68\x5f\x5e\x44\x7c\x66\xda\x04\xfd\xba\xa3\xdf\x76\x49\xbf\xa2\xda\x25\xfd\x8a\x6a\x97\xf4\x2b\xaa\x5d\xd2\xaf\xa8\x76\x41\xbf\x42\x99\xa8\x1d\xcd\xaf\xd0\xbe\xef\x77\xda\x0f\x0b\xfa\x48\xe2\x74\x8b\x14\x57\xf7\xa0\x53\x3c\xfd\xe6\x19\x22\x8c\x82\x29\xfd\x3e\x02\x42\x16\xf7\x59\xa4\xb8\xaf\x87\xfa\xb8\x4f\x6e\x1a\x09\x03\xf1\xe4\xf4\xcd\x83\x49\x5c\x64\x91\xe2\x8e\x1e\x18\xe7\x53\xfd\xc6\x61\x22\x0c\xc4\xd3\x12\x01\x21\xf3\x8b\x16\xc9\x8f\xf5\x50\xa7\x28\xaa\x5f\xbf\x2e\xc2\x40\x3c\x3f\xf6\xdd\x6b\x26\x76\xd6\x22\xd9\x59\x91\x9e\xbe\x7e\x42\x84\x81\x78\x92\x23\x20\x64\x76\xc8\x22\xe9\x79\x0f\xf5\x3a\x45\xf5\x6b\xf7\x44\x18\x88\xe7\x6a\xdf\x9a\x19\x22\xe7\x16\x49\x2e\x7b\xa8\xcf\x09\x9e\x3e\x7a\x2a\xc2\x40\x3c\x25\x11\x10\x64\xde\x61\x0e\x2a\xe5\x67\x06\x2f\xb4\xc3\x30\x5e\x31\x2a\x19\x05\xed\xee\x3b\xff\x51\xb0\x17\xa9\x57\x22\x61\xe5\xf9\x66\x14\xec\xfd\x90\xbe\x30\x6c\x3f\x79\x5d\x14\xfc\xc1\x3e\xf0\x51\xf9\x62\x14\xfc\x5e\x14\x83\xff\x1f\xf0\x1f\xea\x03\xdf\x0f\x7e\xe5\x1a\x09\x7e\x1f\xe4\xcb\x9c\xff\x86\x5f\x06\x7f\xb8\x0f\x7c\x54\x7e\x8a\x6b\xc7\xc4\x3c\xd1\x4b\xf2\x53\x03\x82\x5f\xd6\xef\xf7\x8b\x51\xdf\x63\xa2\xbe\xe3\x7c\x15\x7f\xef\x26\x79\x6b\xd4\xf7\x83\x51\xdf\x3d\x51\xdf\x71\xfe\x2a\xc3\x3f\x32\xea\xfb\xa1\xa8\xef\x98\x3e\x29\x6f\xf5\x92\x7c\xf6\x0f\xbe\x1f\x8e\xfc\x4e\x39\xe0\xf7\xf5\x8a\x31\x44\x77\xd1\xf8\xe1\x7c\xac\x45\xfc\x02\x71\x7d\xf4\x3c\x1a\xf6\x62\x34\xac\x2c\xef\x22\xb0\xf9\x12\x2c\xce\xbb\x24\xd8\xbe\xf9\x4d\x34\xfc\xc1\x3e\xf0\x91\x79\x13\x82\xdf\x25\x83\xc7\x79\xd8\x7f\xc1\x2f\x87\x3f\xd4\x07\xbe\x2f\xfe\x77\xb0\x1c\x11\x78\x94\x97\xcd\xf9\x2f\xf8\xe5\xf0\x87\xfb\xc0\x47\xe5\x69\x10\x3e\x9c\x2f\x79\x49\x9e\x26\x9b\xb7\xa7\xa3\xbe\xe3\xb8\x3d\xfc\x9d\x37\x47\x7d\xc7\xf1\xbb\xec\x7b\x45\xd4\xf7\x83\x51\xdf\xa3\x7f\xbf\xf7\xbf\xfc\xfe\x90\xf4\x7d\x3e\x89\xe3\xd1\x77\x29\x7f\xf3\x92\xf8\x5e\xf6\xfb\xe8\xef\x87\x23\xbf\x53\x16\xf8\x1d\xc6\x07\x06\x6c\x13\xb1\xdc\xa9\x05\x3b\xb0\xac\xaf\xfd\x8c\x82\xc5\x71\x8e\x1c\x56\x1e\xef\x10\x58\x93\x08\x8b\xe3\x1d\x09\xb6\x9f\xb8\x22\x0a\xfe\x60\x1f\xf8\xa8\x78\x25\x0a\x7e\xef\xff\x11\xff\xa1\xff\x01\xbf\x14\xe7\x60\xb9\x83\x71\xce\x7f\xc1\x2f\x87\x3f\xdc\x07\x3e\x2a\x3e\x82\xf0\xe1\x38\xc5\x4b\xe2\x23\x99\xdc\x45\x7f\xbf\x28\xd9\x2b\x32\xaf\xf5\x51\xdf\x71\xbc\x24\xfb\xbe\x3c\xea\xfb\xc1\xa8\xef\xef\x47\x7d\xc7\xf1\x93\xac\x7f\x26\xea\xfb\xa1\xa8\xef\x99\xe8\xbb\x14\x37\x79\x49\x3c\xf5\x07\xdf\x0f\x47\x7e\x27\xb1\x13\xda\x13\x22\xb1\x13\xbd\xf3\xe5\xbe\x7b\x2f\x04\xa6\x5d\x8c\xc1\xd4\xb5\xd4\xb7\xa4\xbe\x4e\x16\x3b\x11\x3f\x66\x91\xfc\x4c\x0f\x75\x18\xc1\xc2\x7e\xa6\xf6\xef\xaf\xd1\x1e\x09\x86\x45\x30\xf9\x32\x5f\x28\xe2\x48\x67\x4a\x07\x12\x0c\xf9\x54\xdf\x78\x8e\xd0\x74\x46\xa2\x9b\xac\x51\x4b\x3b\x3d\x61\x7c\x22\x8c\x21\x1d\xc1\xc8\xf1\xc9\x61\xf1\x7a\xe7\x01\xf1\x9c\x00\x3e\x1f\x40\xf6\xcf\x68\xd9\x79\x37\x72\xe6\x66\xa6\x08\x43\xdf\x42\x25\x03\x2d\x82\x91\xad\x9d\x13\x18\x8b\xb4\x6e\xda\x13\x2a\x0f\xaf\xa7\x86\xdb\x99\x52\x7e\xa9\xcc\x9f\x4a\xe7\x7e\x04\x39\x05\xa0\x85\xcd\xa1\x37\x72\x97\x28\x0d\x15\x73\x5c\xcd\x41\xdf\x48\x55\x39\x2f\xa1\x53\x49\xe8\x51\x1e\x7c\xa7\xa8\x9f\xde\xe8\x32\x54\x06\x36\x95\xd7\xc5\x74\xa6\x71\x97\x36\x37\xac\xaa\x29\x9b\x5d\x75\x9e\x02\x54\x0b\xdf\x0a\x5a\x42\x37\x50\x7a\x4a\x7f\x22\xa6\x9b\xa3\x95\xe8\x5a\x79\x9f\xf3\x32\x3a\xd3\x24\xbf\x9a\xd4\xa7\xa4\x42\x69\xba\x54\x67\x8e\xbf\xaa\x9a\x75\xef\xb3\xf0\xa1\x44\xc5\x3a\xed\xc0\x62\x93\x75\xfb\x9c\x48\x1a\x74\xc7\xd4\x54\x37\x87\x6a\xd2\x0b\xff\x17\x12\x20\x0d\x8b\xd9\xc7\x99\x59\xdc\x71\xca\x41\x99\x4e\x5a\xb9\x98\x6e\x93\x9a\xa2\xf2\x2e\xa0\x22\x7f\xf4\x02\x5a\x32\x7a\x19\x59\x78\xaa\x2d\x81\x16\x9e\xa7\xa3\x3b\x33\x46\x56\x0f\x72\x89\xcf\xd1\x65\x8e\xaa\x1e\xe8\x14\xde\xa0\x63\x1f\x4f\xc9\x4c\xc1\x6f\xce\x25\x67\x25\x0b\x6f\x05\x32\xd4\x4e\xf6\x6f\xcc\xe3\x4a\x13\x15\x47\xb9\xa9\x24\x2a\x31\x10\xe3\x4c\x48\x70\x58\x38\x5d\xb7\x51\x4d\xc5\xa3\xab\x20\x3e\x20\x1d\x1a\x85\x97\xf9\xc5\x4e\x81\xac\x53\x46\xa8\x58\xa4\x0f\x67\xd4\x0e\xad\x74\x09\x2f\xd4\x66\x8e\x1a\x3a\xd0\x29\x3c\x50\x7b\x67\xf6\x73\xa8\x5a\xf1\x99\x6c\x85\x06\x12\x81\x5e\xa3\x85\x34\xe0\xc7\x68\xf9\x77\xa4\x1a\x45\xc1\x5f\x5b\x24\x7f\x87\xe3\xf0\x3f\x8a\x1b\x58\x31\x6e\x10\x60\xfa\xe0\x48\x47\x79\x43\x7f\x18\xa4\x3c\xe4\x31\x2c\xdb\xb3\x89\xfc\x6b\x30\x4c\x84\xde\x22\x7c\x12\x0c\x92\x7f\x4d\x04\x3e\x39\x6c\x68\x3d\x3e\x57\x62\x91\xd6\x9d\x7b\xf8\x4c\xdc\xfe\x44\x64\x3b\x53\xda\x3b\x41\x82\xff\x04\xb7\x67\xf7\x81\x97\xb5\x8b\xf0\xf8\xae\x7f\x59\x0d\xab\x20\xe7\x34\xd5\xc9\xe6\x30\x0c\x96\x31\x03\x65\x7e\x42\x1b\x88\x09\x0b\xfb\x9b\x58\x62\xc3\xc2\x06\x18\xbf\xc7\xac\x04\xf7\x85\x45\x0e\x7c\xf0\x90\x12\x00\x9d\x22\x2c\x7a\xfc\x59\x90\x94\xc6\x7f\xe0\x91\x70\x0f\x94\x70\x1b\xfe\x10\xb7\xdf\xec\x81\xa8\x64\xb8\xa9\x90\x62\x35\x00\x4a\xfe\x2b\x39\x72\x0f\x48\x4d\xe3\x3f\x41\xb8\x4f\x41\xdc\x8f\x2b\x6d\x10\x77\x2a\x95\x10\x88\x49\x32\xc4\x75\xc7\x5b\xb4\x06\x35\xdb\xad\x21\x3d\x38\x3f\x92\xa4\x3d\xdc\x4d\x5a\xff\x82\x2f\x68\xd1\x68\x1d\x1c\x52\xcc\xef\x2a\x41\x98\x90\x21\x7d\xb5\x41\xcc\x29\x6b\xb1\x2d\xef\x24\xb6\xfc\x55\x8a\xec\xec\x45\xe7\x9d\xd8\x96\x77\x0a\xb6\xfc\x33\x6c\xcb\x81\xd5\x1a\x99\x77\x2a\x87\x12\x18\x54\x87\x7a\x99\x64\x72\xf7\x83\x3c\x2a\x2d\x60\x67\x9c\x79\xce\x49\xce\x35\x4e\x86\x06\x26\x83\x29\xc9\x44\x9f\x37\x01\xdc\x05\xa9\x3d\x0d\xd7\x9d\xf6\x8b\x87\x29\xa5\x4c\x10\x4f\x0a\xc4\x93\x98\x97\x38\x29\x71\x4d\xe2\xef\xe2\x11\x71\x8c\xc2\x32\x4c\xc6\xb4\x1b\x9f\x0d\x00\x2e\x57\xd4\x98\xd6\x29\x4d\x52\x2e\x7d\x07\xf5\x0e\x25\xd4\xd7\x8a\x36\x1e\x9f\x4d\x25\x67\x6b\x1e\x95\xce\xd6\xe0\xda\xfa\xc8\xf3\xc3\x02\xcc\x4c\x09\xe6\x16\x8a\xc6\x36\x5e\x7e\xee\x79\x3d\x86\xb1\x48\x6b\xb6\x72\xd9\x97\xb5\x13\xd9\x87\xb2\xb2\x5d\x90\xf1\x18\xca\x0c\xe5\x30\x36\x60\xa0\x95\x51\x72\x98\x82\xde\x3f\x4c\x21\x4f\xf8\x8b\x62\x9e\xd6\xc9\x05\x36\xb9\x4c\x6c\x72\x58\xca\xcf\x3b\xed\x75\xd3\x4a\x6a\x0a\xac\xd9\x47\xc2\x82\x4e\xf0\x0f\xfc\xdf\xf1\x0b\xa2\x2e\xe1\x97\x49\x7a\x44\x07\x82\xb0\x87\x65\x5d\x47\xa5\x53\xce\x80\x36\xd9\xe4\x4c\xb4\xc5\xc0\x3e\x74\xa8\x8f\xcb\xbe\xb7\x2e\xf8\x04\x39\x27\xdd\xe0\x9b\xc3\x7e\x4f\xd2\x71\xaf\xb9\x70\x50\x7f\x24\xe7\xe7\x1d\x71\x23\x66\xb7\x8d\xb3\x66\xff\xa9\xaf\xa4\x8b\xeb\x10\x58\xce\x97\x11\x39\x7f\xb7\x9f\xf3\xee\x18\xa6\x5d\x5c\xcf\x50\xd7\x02\x8a\xc8\x79\x7c\x7c\xe4\x7a\x06\x96\xcf\x65\x44\x3e\x5f\x25\x72\xfe\x10\x94\x4f\x57\x40\xcf\x24\xe7\x25\x4f\x4a\x5e\x93\xcc\xd0\x12\x6a\x41\xba\x7f\xef\xb7\x50\xb6\x63\xe1\x6f\x1d\xbf\xfb\x5b\x72\x26\xf1\x02\xb4\x85\x4b\x71\xde\xb8\x48\x58\xcb\xcc\xa6\xd6\x52\xb2\x1b\x1b\xfa\x81\xb9\x08\xf1\x62\x18\x99\x1f\x41\x34\xdc\x8a\x75\x83\xf0\x61\xf7\xd7\x98\x0f\x11\xf7\x3e\x20\x98\xbb\xb1\x6e\x2c\x13\x74\xe3\x9f\xa2\x6e\x88\xe7\x4d\x65\x67\xeb\x0f\x88\xe7\x02\xa4\xf8\x47\x76\xae\x41\x80\x99\x29\x9d\x1d\x10\xe3\x1f\xf9\xf9\xfb\x16\x0c\x63\x91\xd6\x6f\x7b\x7a\x7f\xc2\x63\xbe\x29\xb2\x1d\xea\x46\x96\xb4\x1f\x73\x11\xe7\x55\xbe\xf0\x7e\x0c\xf4\xed\x9b\xd8\x3d\xec\x78\xee\xef\xc2\xdd\x51\xae\x40\x8c\x52\xab\xd1\xee\x68\x57\x68\xf4\x0c\x60\x60\x28\x71\xb9\xe3\xf9\x42\xe1\x9c\x36\xd6\x17\x14\xcd\x60\x3f\xbe\x9c\x28\xcb\x92\xec\x77\xb3\xaf\x4e\xcc\x7e\x2b\x9b\xdd\x43\x14\xc5\x20\xf8\xea\xff\x1b\x6e\xac\x2b\x69\xe2\xad\x06\x97\x05\x45\x01\x09\x61\xec\x44\x4b\x04\xec\x00\x74\xb0\x47\xe8\x19\x0a\x0b\xc4\xad\x3d\x4e\xd1\x77\xb4\x43\x74\xd9\x84\x46\x46\x09\xbe\xde\x06\x69\x53\x29\xd9\x23\xa0\x32\x8d\x3f\xe7\x09\xe7\x43\x16\x29\x5f\xe9\xa1\x3e\x10\xa2\xd4\xdf\xc9\xfb\x50\xad\x1d\x86\x8d\xce\x1d\x45\x1c\x30\x6e\xf0\xf7\x8b\x21\xbc\x3e\x87\x65\x66\x85\xfc\x6c\x87\x58\x65\x1d\xc6\x27\xc2\xc8\xe2\xe6\x65\xfd\xc0\x6a\xf1\x39\x35\x8b\xb4\x8f\xd2\xc3\x1f\xc2\xed\x45\x91\xed\x70\xbe\xdf\x0d\xaf\x3b\x63\x5a\xdb\xe4\xf0\xd1\xed\x61\x78\x9c\xff\xb4\x49\xed\xe1\xf8\x78\x0f\xfd\x2e\x9e\x43\xcd\x51\x06\x5a\xbb\x3c\x6c\xe8\x88\x69\x6b\x11\xa6\x49\x9c\x1c\x04\xbf\x00\xc6\xb2\x2b\xb0\x8d\x8c\x39\x1e\x36\x8f\xd1\xb6\x91\x5e\x21\x59\xc5\x08\x63\x88\xe4\x06\x84\xde\xe2\xbf\xa5\xb2\x38\x25\x94\x20\xe3\x09\x40\xd3\x2c\x0d\xbb\xcd\x33\x02\x1c\x5d\x9a\x8d\x29\xc6\xac\x16\x4e\xf9\xcb\x17\x8a\x38\x04\x9b\x04\x61\x3f\xe1\xd6\x53\xb1\xd4\xf0\x40\x32\x54\x12\x9d\x4e\x4b\x29\x58\x8a\x63\x19\xa0\x8f\x61\xb4\x1c\xb4\x85\x2a\x86\x53\xa9\x38\x86\x01\x6a\x25\x80\x88\xd0\x83\x4b\x79\x10\x9f\x4f\xf8\x0b\xf8\xec\x85\xe8\x5f\x7c\x24\x7c\x35\xa7\x18\x95\x5e\xbf\xd7\x6f\xf7\xdb\x95\x76\xa5\x37\xab\x65\x8d\xff\xd1\x47\x85\xff\xaf\xe1\xbf\xe5\x82\xdd\xfe\x47\x1e\x2e\x7d\xec\xb1\xd2\x87\x1f\xf1\x77\x13\x7a\xdf\xe6\xbf\x05\xc7\x20\x0d\x1a\x2a\x3f\x60\x55\xd3\x1c\xa5\x62\xa0\x78\x73\x0a\x2d\xab\x04\xf0\x2f\x85\x46\x41\xa1\x67\x8b\xca\x70\xa7\x30\x28\xc6\xdd\x19\xc9\xb5\xa2\xb0\xaf\x14\x38\x24\x8f\xd7\x0f\x8e\x7d\xec\x5f\xf7\x73\x13\xa8\x5d\xe7\x67\x1f\x7d\xdf\x7f\xfd\xaf\xf3\xb9\xbf\x5d\x5f\x8a\xee\xd0\xaa\x83\x63\xcc\xc0\xf8\x73\x02\x66\x15\xab\x50\x33\x8c\x42\x41\x01\x2d\xc7\xa8\x19\x35\xc0\x83\xc2\xd8\x65\xc8\x11\x6e\x38\x92\x14\x74\x1d\x96\x5d\xe9\xc9\x68\xfa\x79\x9d\xff\x63\x88\x1f\xd4\xc2\x21\xdc\x7e\xbd\xff\xfd\x0f\x4b\xd1\x99\x67\x40\xb9\xc0\x79\xf6\x04\xbd\x09\xf2\x5a\x7b\x1c\x50\x67\x82\x00\xeb\x11\xba\x54\xc5\xe5\x65\x17\x7b\xc1\xf9\x8b\x17\x31\xdc\x2d\x60\x1f\x5b\x4e\xcf\xef\x07\xee\x96\x0c\x66\x63\x06\xd8\x47\xe0\x42\x1f\x41\xb8\xcf\xfb\xc0\xa1\xbb\x15\x92\x33\xd8\x4f\xfe\xaf\x70\x74\xa8\x0a\xca\x65\x43\x68\x1d\x84\x43\x37\x99\xe9\x38\xf6\x74\x90\x03\x01\x40\x9d\xc6\xbf\x40\x37\x39\x5c\x82\xbf\x53\xa2\xb7\x8d\xe1\xdf\x3b\xcd\xec\x5b\xe6\xdf\x68\xf4\xe7\x07\x93\x27\x5f\x9e\x3c\x19\xcb\xf0\x21\x66\x22\x6b\x81\x32\xc9\x50\xba\x13\x14\xd8\xdd\x8e\x84\x12\xfe\x48\x0d\x3c\x80\xb5\xf0\x1f\x43\x17\x7f\x98\xbb\xd4\xbb\x9d\x5e\x00\x61\xff\x04\x61\x6d\x02\x2c\xa0\x76\xb7\x83\x30\x2c\xf8\x13\xfc\x63\x18\xdf\xc8\x4c\xa4\x17\xf4\x6e\x87\x3c\xd9\xca\xdf\x41\xff\x07\x5a\x32\x32\x06\x04\x8b\x79\x02\xa1\xb6\x82\x64\x08\xd9\x00\xbf\x23\x48\x48\x03\xed\x65\x26\x32\xbb\xfb\xe2\x45\x37\xf9\xd0\x9f\xf7\x80\x61\x05\x02\x56\x14\x67\xbc\x08\x69\xf8\x05\xc3\x2a\x29\x4b\x40\xad\x00\x88\x68\x74\xd5\x65\x95\x60\x2e\x11\x35\xe8\x2f\x66\x00\xa1\x9e\x5e\x2b\x1f\x05\x1e\x09\xc2\xf3\x12\xc4\xf3\x6b\x18\x0f\x4b\xa1\x8e\x39\xd4\xb3\x2f\x12\x0f\xbd\x83\x8c\xac\x77\xb5\x7c\x84\x22\x3d\xa1\xf7\xf8\x1d\xac\x0e\xd0\x18\x8f\xe9\x09\x09\x4d\x5e\x14\x16\xf0\x10\x19\x35\xc4\x42\x46\xbf\x43\xc4\x12\x0a\x01\x1a\xd2\x52\xc7\x5d\x82\x96\xf7\x1d\xb4\x97\x05\x2d\xd2\x3b\x68\xe5\x02\xcb\xd6\xcf\xa1\x6c\x76\x07\xa4\x53\x8b\xaa\x94\x28\x46\xc1\xf4\x04\xd5\x0a\xa5\xe2\x19\x38\x66\xd8\x4b\x95\xac\x54\x88\x49\x31\x73\x7e\xce\xec\x61\xd2\x94\x8c\xeb\xd7\x7b\x5e\xe1\x1f\xcc\x00\x0d\xb9\x54\x68\x06\xe8\xc8\x60\xce\xff\x36\x97\xbd\xc3\x75\x29\x1e\x5c\xcb\x6f\x8c\xbf\x04\x7f\xda\x16\xca\x65\x77\x42\xbc\x56\x54\x97\xa4\xb5\x18\x2d\x3d\xc1\x58\xa3\xde\xf8\x74\xbb\x5e\x0d\xc7\xd2\x13\x54\x30\x2c\xf3\x74\x3b\x4b\x51\x52\x17\x71\xf2\xba\x24\xd4\x93\x0f\xf6\x94\xa6\x05\xf0\x0f\xa1\x6b\x7a\x1c\xff\x70\x06\x18\x53\xfc\xf6\x58\x70\x4d\x06\x7f\x6f\x47\x06\x98\xef\xe5\x77\xc3\xff\xe4\xf7\x7b\x41\xc3\x04\xe6\x4d\x44\xc0\x74\xfe\xde\xf8\x4b\x2e\xfe\x61\xfe\x31\xf8\x5f\xfc\xbd\x60\x3a\xfc\x2f\x30\x0e\xcb\x62\x2b\x58\xcb\x3c\xce\xbc\x02\xed\xa3\xea\x08\x64\x67\xde\x65\xe1\xe1\x2b\xe1\xb2\x9f\x58\x40\x0f\xef\xbc\x69\xf6\x03\xe3\x3a\x6f\x99\xf5\x28\x58\x7b\xcb\x8c\xf6\x07\x27\x6e\x98\x39\xfe\xa1\xa9\xe8\x9e\xc7\xd7\x51\xad\x1c\x28\xc0\xf3\xa0\xa5\xec\x01\x8d\x1a\xce\x02\xb8\xa7\x5d\x85\xdf\x15\x2f\x14\x5e\x14\xf1\x08\x4f\x1e\xa3\xbf\x99\xfc\x0a\x40\x57\xf4\x36\x54\x00\x0a\xff\x49\x57\x80\x02\xfe\x55\xf1\x6f\xc9\x76\xb1\xaf\x41\xfb\x6e\x7d\x82\x85\xc6\x56\x41\xa1\xeb\x05\xb1\x29\xc1\x37\xe7\x22\x7b\xeb\xb1\x66\x35\x83\x0f\xd8\xb5\xc8\x22\xd5\x43\x7b\x34\x1a\xda\xa3\x4c\xe1\x37\x80\x61\x59\x05\x12\x09\x74\xa3\x9f\xf0\x1b\x50\xec\x81\xbf\xe2\x47\x83\x0f\x9a\xd9\xb5\xf5\xbf\x26\x70\xb7\x13\x3b\x69\x82\xbf\xfb\x86\xbb\x11\x52\x9f\x10\xd0\x51\x34\xcd\x31\x2a\xc0\x71\x8c\x92\xc1\x06\x4c\x32\x5f\xc4\x72\xfd\x7f\xbc\xbd\x09\x7c\x14\xc5\xb6\x30\x5e\xd5\xd5\xcb\xec\xfb\x92\x4c\x96\xc9\x64\x92\x4c\x16\x48\x42\x26\xc9\xb0\xa7\x81\x10\x76\x08\x8b\xc0\x08\x21\x21\x61\x13\x64\xdf\x05\x04\xd9\x51\x41\x03\x28\xe8\x55\x44\x45\x40\x14\x91\x3d\x82\x72\x5d\x10\xbc\x42\xc0\xed\x5e\xc5\x0d\xae\xb8\xe2\xc6\xf5\x7a\x5d\x48\xa6\xf3\x3f\x55\x3d\x93\x04\xd0\xf7\xbe\xf7\xfb\xbe\xf7\x0f\xf4\x4c\x77\x4f\xd5\xa9\x53\xa7\xce\x56\xdd\x55\xe7\xd0\x76\x7f\x38\x39\xec\x24\xfe\x98\xbc\xdd\x90\xcc\x7f\x86\x0f\x5c\x07\x43\x4f\x75\xa1\x4e\xd0\x00\x7f\x0a\x1c\x31\x00\x1c\x9d\x8e\x68\x45\xc2\x14\x3c\x85\xd5\x4a\x19\xb6\x82\xe8\xf4\xc5\xa0\x2a\x73\xf1\x3d\x31\xc8\x83\x94\x6f\xaf\x87\x9d\x2b\x3b\xb0\x28\x6a\x88\x5e\xaf\xd1\x6a\x0d\x92\x5e\x0f\x94\xd7\x12\x9e\x76\xb2\x19\x78\xd4\x62\x50\xe8\x04\xa0\xb2\x3e\xc3\xbf\x1f\xf0\x3d\x00\xfa\x63\x68\x83\xf7\x62\xe7\x20\x65\x20\x6d\x82\xf6\x5f\x62\xfb\x21\xf7\x00\x7c\x02\xf3\xe4\x24\x94\x8d\x42\xa8\x14\x0d\x46\x53\x0f\xb7\xef\x5d\x17\x2e\x69\x5f\x87\xdd\xb2\x61\x54\xc9\x40\x38\x4f\xce\xad\x0b\xa7\x27\xd3\x1b\xbe\x51\x30\x1c\x18\x71\x16\x8e\x33\x02\xf7\xd8\xc0\x9d\xe4\x30\x9f\x9e\x5e\x08\x05\xf4\x9e\xba\x30\xaf\x87\x52\x47\x46\xf1\x0e\x38\xfd\x18\xf8\x38\xe7\xba\x4c\xbb\x95\x63\x2a\xc6\x54\x50\x14\xd5\xdb\x39\x54\x3b\xf9\x71\x10\x17\xd0\x98\x9c\xfe\x54\xca\x75\xee\xd6\xf9\x25\xec\x7f\xf6\x43\xfa\x9f\xfd\xb0\x61\x3b\x77\xee\x09\x25\x74\x34\x6b\xd0\xcc\xb2\x17\xca\x56\xac\x4b\x4e\xca\x2a\x4c\xed\x92\x1e\xf2\x95\xde\x7c\x0b\x7f\xf0\x07\xf7\xf6\x72\x23\xf0\xd2\x17\xbb\xed\x9c\xdf\xe9\xd5\xd1\xe7\x6e\x7b\x23\x3b\xb9\xc7\xba\xfc\x61\xfd\xee\x8f\x9c\xbe\xf9\xde\x7f\x6e\xbe\xc5\xfc\x7c\xae\x2b\xe9\x4f\x76\x09\xf5\x36\x11\x2c\x24\x5c\xe3\x5b\x49\x7f\xf0\xd7\xe9\xb5\xc0\x7c\xa4\x17\x48\x7f\xc1\x25\xd4\x5b\x02\x48\xa7\x2c\x62\xb3\x08\xdd\xcf\xa0\x81\x90\x0e\x4f\x67\x32\x59\x81\xd6\x93\xed\xe4\x59\xa4\x01\x3d\x4e\xd0\xf7\xa3\x08\xd3\xe3\xe9\x24\x04\xbe\x2e\xb6\x4b\x5c\xdc\x71\x23\xee\xfb\x9d\xa4\x1c\x3b\x26\xad\xc7\xb7\xf5\xc2\xd3\xd3\x95\x8d\xca\x16\x3f\xab\x9b\x0d\x75\xa7\x45\xeb\xf2\x50\x97\x57\xeb\xd2\xd9\x65\x10\x66\x97\x38\x5b\xc2\x65\x47\xa4\xef\x8e\x19\x95\xa3\xeb\xfd\xf8\x36\x3c\x2d\x5d\xa9\xed\xa5\x6c\x81\xba\x3c\x1a\x00\x1f\x07\x85\x9e\x51\x79\x36\x23\x9f\x6c\xd6\x62\x41\x36\x0a\xbc\xb0\x6d\x94\x81\xd7\x71\x04\x34\x75\x4b\xe0\x37\xfa\x48\xd0\x6f\xf7\x61\x90\xeb\xe6\xef\x9d\x5f\x6e\xc2\x19\x91\xf7\x0a\x71\x4a\x21\x37\xbb\xe5\x1c\xef\x21\x7f\xb9\x76\x1c\x9b\x94\x9f\x5a\xce\xd4\x67\x05\xcf\x0a\xcf\x0a\x0f\x88\x06\x9b\x84\xba\xe3\x9e\xe2\x5a\xa6\x7f\x69\xcc\xba\xd3\x0c\x0f\xe3\x21\xc2\x11\x4c\xb5\x09\x8d\x9c\x1c\x04\x5e\xb9\xf4\x04\xf9\xfa\x71\xf8\x0d\x8a\x60\xb0\x2a\xe4\xb9\xa8\x3d\xa1\xf8\x76\xda\x6f\x34\xd4\xe1\xa1\x07\x46\x69\x35\xf0\x25\x6b\x47\x19\xb5\x46\x2d\x8f\x79\x01\xae\x0e\x8d\xe2\x6d\x18\xb1\x5f\x99\xa9\x43\xad\x32\x38\x52\x3e\x64\xd8\xdb\x7d\xfa\xe8\x37\xe1\x46\x16\xe3\x94\xe2\xc8\x2f\x21\x9c\x12\x5a\x49\x3f\x94\x8d\xf4\x93\x3f\x80\x3d\xca\x97\x0d\x03\x71\xbc\xf2\x15\xf1\xd1\x73\x65\x06\x3d\xbf\x4e\x17\x98\x51\xa9\x9c\x22\xea\x74\x1a\x03\x31\x63\xb3\x81\x18\x8d\x48\x27\x40\x67\x2c\x7a\xb3\x19\x14\x04\x6f\x94\x08\x93\x5d\xab\x2a\xbd\x31\xf1\xa5\x8a\xc2\xea\x0e\x46\x7d\x3f\x90\xe2\xa0\xd5\x5f\xe4\x73\xfa\xad\x41\xa7\x2a\xc9\x27\x41\x4d\x9c\x3c\x19\x93\x64\x50\x12\xcd\xb2\xcc\x35\xb7\x4d\xa2\xda\x42\x92\xb4\x88\xe7\xb5\x3a\x9d\x41\xc3\x83\x3a\x16\x74\x44\xf8\xaf\xb4\x05\xb1\xaa\xea\xe2\x51\xdc\x51\x39\x35\x98\xaa\x0b\xda\x86\xf2\x28\x3e\xd0\xac\x30\x70\x93\x05\xda\xb8\x0a\x6d\x30\xdd\x4c\x68\x70\x71\x1a\x5a\x36\xaa\x66\x0b\x98\x52\x23\x3e\x92\x3d\xec\x14\xbe\x74\x0a\xdc\xba\x0c\x3c\x4d\xd9\xd8\x52\xef\x6e\x24\x52\x3d\x2b\x62\x50\xeb\x12\xe0\x06\x7a\xf2\x26\x3d\x4b\x71\x48\xc0\x00\xe1\xea\xd5\xa8\x2e\x7c\x41\xe9\xc5\xfa\x67\x05\x18\x3f\x82\xcf\x49\x65\x2a\x5b\xb6\xf1\x1a\x9d\x0e\x4b\x82\x00\xae\x27\xe0\xa1\xd7\x30\x44\x9a\xfb\x45\xd5\xac\x9a\x5e\x08\x50\xa2\x0e\x67\x28\x20\xb9\xb3\x87\xbd\xfe\xe3\x8f\xaf\x0f\xbb\xf3\xce\x3b\x01\x37\xe1\xf0\x27\x9f\x1c\x3e\x3c\x73\xe6\x8c\xd6\xe3\x66\x04\x7f\xd9\xa5\x11\x75\xc4\x88\x75\xe0\xab\xeb\x4d\x5a\xa3\x51\x84\xf1\xd2\xb7\x68\xda\x28\xf1\xa2\xa3\x14\x1b\xa3\xd6\x23\x14\xd7\x3c\x40\xca\x23\xcd\xe3\x83\x71\x2f\x4e\x22\xbf\xf3\x8f\x22\x0f\xca\x94\x1d\x16\x8f\x5e\x07\x1e\x90\xd1\xe8\x70\x88\x5f\x85\xc1\x15\x32\xf5\x76\x80\x9c\xaa\x16\xdf\x63\x39\x5b\x50\x50\x10\x4b\x41\x91\xd1\x9c\xe0\xc3\xd1\x2a\xcb\x03\x77\xa5\x9f\x26\xb3\x6d\xd7\xd1\xd6\xd2\x03\x35\xee\x9d\x46\x92\x35\x65\xd8\xa8\xb0\x66\x18\x27\xe1\x65\x6d\x92\xda\xa6\x55\x8d\x52\x1e\xc7\x4d\xf7\xf8\x06\xb6\xef\xd1\xa7\x3c\x35\x9b\x2e\xee\x61\x7a\xa7\x69\x32\xb9\x9f\x5b\x6e\x91\x84\xea\xa6\xa3\x91\xfb\xa3\xcf\xd0\x6e\x23\x33\xb8\xbb\xe0\xde\xa4\xa6\x55\x91\xf5\xec\xde\xf3\x50\x6e\x0f\xbb\x37\xb3\x69\x4b\xe4\x3e\x76\x6f\x4a\xd3\x02\xf2\x09\x37\x0b\x66\x62\xf9\xf8\x62\x44\xdd\x9b\x50\xdf\x34\x85\x2c\xe7\x56\x40\xb9\xdb\x9a\xee\xa3\xe5\x40\x76\xa7\x00\xbd\x5e\x13\x1e\x42\x3e\x74\x9b\xdc\xd3\xed\xa9\x0e\x27\x63\x17\xae\x0e\x27\xb8\xcc\x6e\xaf\x9b\x33\xbb\xbc\x2e\xce\x42\xdc\x2e\xb7\x4b\x83\x34\x96\xea\xb0\xde\x98\x60\xcc\x31\x2e\x32\xde\x63\x14\x8c\x29\x9a\x72\x4d\x95\x66\x99\xe6\x7e\x8d\x60\xd6\x60\x2d\xd1\x20\x6f\x75\x18\xd9\xd4\x6c\xed\x60\x3a\x2a\x82\x15\xad\x2d\x09\x18\x12\xe6\x1c\x51\x0f\xa3\x39\x75\x65\x12\x66\xe9\x0e\x58\xc8\x7a\x98\x13\xc6\xfe\xe1\x87\xfb\x1e\x3e\x79\x1f\xe6\x1f\x3f\x56\xdf\x20\x0d\x2c\x5b\xb9\xa7\x4f\x45\x19\x37\x37\x4d\x99\x96\x8a\x6f\x4b\x53\xb6\x64\xe0\xbd\x69\xf8\x8e\x93\x2f\xbd\x8c\x0b\xf7\xec\x79\x48\x34\x8e\x18\xa4\x7c\xf3\xd6\xd4\x2a\x7c\xdb\xb1\xe7\x8f\xbd\x7c\x8c\x3d\x3b\x18\xda\x54\x4b\xd7\x77\xd2\xbc\x03\xa8\x0d\xea\x22\xfb\xed\xfe\xcc\x94\x2c\x21\x35\x3d\x3e\xbd\x32\xec\x4d\x90\x13\x93\x69\x3a\x27\x51\x72\xc6\xdb\xa5\xd4\xca\xb0\x51\x63\x93\x78\xd0\x96\xf5\x6a\x06\x62\x98\xe2\x79\xe0\x34\x9a\x5e\xd9\x1d\xca\xb0\x16\x86\x6c\xf4\xf1\x82\xcb\xcd\x3e\x04\x5c\x1c\x12\x44\xde\x8c\xfd\xa1\x8c\x80\x84\x33\x02\xd8\xe5\x26\x4e\x37\x06\xf7\xeb\xfe\xf2\xf5\x71\xab\xb8\xa4\x82\x55\x45\x3d\xd2\x7a\xac\xaa\xae\x70\x2a\x11\xe5\xef\xb3\xab\xb0\x34\x55\xb9\x74\x34\xb0\x2a\xa7\x34\xa3\x98\x9b\x09\xea\x69\x7d\x5a\xfb\x07\x31\xf6\x8e\xb8\xb3\xdf\xf4\xe3\xf3\x50\xd3\x94\x25\xdc\x76\xcb\xec\x45\x26\xeb\xc3\x97\xab\x0e\x75\x8e\xf4\x69\xfb\x42\xe1\x3b\xe7\xc5\xd1\x35\x06\xd3\x12\xfe\xc1\x42\x4b\xe3\xee\x6c\x33\x36\x58\x2d\xdc\xa3\xde\x3a\xe5\x1f\x30\x6e\x43\x61\xde\x7e\x4e\xb8\x15\xe5\xa0\x6e\xb2\xdf\x6c\xf3\xda\xee\xb3\x11\x13\xb1\xc9\x66\xa3\xd6\x25\x8a\x09\x3e\x5f\x66\x65\x38\xdd\xc7\x13\x57\x82\xab\x2a\x1c\x97\x60\x47\x2d\x09\xff\x63\xa9\xf3\xdf\x2b\xf0\xd4\xc3\xb8\xd0\xb7\x4d\x34\x0d\x4d\x28\x28\xb6\x0a\xa3\x6c\xc2\x12\x74\x91\xf3\xd1\x44\xfa\x6c\x17\xbd\xc0\x92\x93\x71\x78\xb9\x2f\xd5\x5f\x60\xfa\x97\xc6\xc3\x0f\x98\xd9\xbb\x20\xbe\x6d\xc7\xbc\xc2\xea\x7e\x71\xd5\xc3\xb0\xf4\x0f\x65\xa9\x92\x7f\x02\x77\x3d\x7f\xe2\x23\xb7\x72\x59\x7b\xeb\x80\xa9\xfb\x6a\xf0\xb7\xb7\x4c\xf6\x1f\x89\xcc\xa8\xb8\x7b\xcb\x78\xf3\xb7\xe6\xf2\xbf\x2c\x2a\x7a\xb2\x50\x19\x89\x2f\x35\xe0\x03\xff\x7c\xf5\xb5\xee\x93\xe7\x3e\xad\x9c\xa3\x32\xfd\x03\xdd\x3f\x0e\x76\xc2\x8a\x86\xca\xed\xf4\x1a\x83\xd1\x50\x13\x36\x09\xf9\x46\xd9\xc8\x99\x8d\x38\xfa\xed\x35\x72\x46\x10\x76\x19\xf3\xd5\x61\x8c\xb5\x66\x33\xaa\x0e\x9b\x89\x4e\x6b\xa3\x61\x0f\x63\xc9\x08\xd9\x9c\x8e\xf2\xdb\xcc\x99\xcd\x3e\x2d\x4c\x93\x54\xce\x02\xaf\xd6\x1f\xa2\x9c\xc6\xf5\xe8\xce\x2d\xc9\x8c\xac\x48\xc7\x1d\x93\x94\x53\x05\xca\xe5\x82\x7b\x93\xee\x3d\x4a\x8e\x67\xf2\x73\x95\xe7\xdf\x3a\xf1\x80\xa2\x60\xee\x01\xf2\xdc\x5b\x14\xb7\x08\xc8\xc8\x51\xa0\x75\x1e\x1a\x2b\x77\x48\x35\x99\x4d\x35\xe1\x0c\x9d\x5e\x57\x13\xf6\x23\xbd\x45\x9f\xa2\x27\x5a\xbd\xec\xdd\x67\xfe\xd1\xcc\x21\xb0\x1f\xc4\x6c\xe6\x1d\x8e\x84\x79\xe1\x38\x87\x24\xe4\xf0\x39\xb3\xc3\x65\x79\x38\x8f\x8f\x03\x1c\x2b\xae\x1f\x02\x26\x23\x9e\x73\x63\x2a\x0a\x5a\xcd\x1a\x4c\xd8\xef\x0b\x75\xe5\x68\x66\x09\x76\x14\xa7\x35\x27\x05\x61\x51\x5a\xd5\x7f\x26\x4e\xf2\x15\x14\x87\xf8\xe5\x25\xbf\x6d\x8d\xf4\xcd\xac\xec\x5f\xa0\x7f\x31\xe9\x80\xeb\x40\xd2\x01\x43\x26\x6a\x7a\xe7\xa9\xa7\xad\x3f\x49\xa5\xdd\x47\x4d\x88\xd3\xe0\xe4\x24\xe5\x33\x17\xfb\xc4\xa6\x76\x43\x6e\xc5\x8b\x27\xdd\xe9\xc7\x53\x9e\x79\xb9\x3e\xbf\xe7\xb8\xee\x0f\xcc\x78\x40\x7e\xf3\xdc\xaa\x6d\x79\x03\xca\x66\x2f\xc9\x82\x2b\xbe\xc7\xe8\x5e\x6d\x59\xee\x15\xdc\xf4\x59\x53\x67\xfe\xb8\x40\xb3\x80\xb6\x91\xe3\xda\x48\xf1\xd2\xe0\x70\x3e\x6e\xeb\x4c\x14\x0c\xde\xa4\x78\x8b\xcd\x9c\x17\x40\x06\x20\xfd\x29\x9a\x83\xe7\x1c\x95\x19\xb5\x0b\x6e\x6c\x2b\x0e\xfd\x61\x8e\x7e\xb7\x3d\x28\x45\x35\x22\x4b\x86\x14\xd0\x83\x00\x91\xe1\xf8\xfe\x22\x09\xff\x41\x5e\xfe\xa1\x65\xe4\x5f\x4f\xae\x16\x47\x0c\x76\xdd\xfb\xf9\x32\x77\x9b\xba\x05\x9f\x1b\xb7\x9f\xe4\x36\x62\x5b\x1f\xcf\x4d\xe9\xf8\x47\x8c\xc2\xeb\x3f\x62\xe9\xf8\xf3\xb8\x8d\x8b\x42\x03\xb4\xca\xdb\x91\x07\x7a\x28\xbf\x03\x5b\x35\x7d\xc5\x62\xd9\xf4\x44\x09\x28\x05\xb4\x41\x26\xc8\xcc\x80\xc3\x69\x5e\x9d\x27\xc1\x53\x87\x7b\x1e\x09\xe7\xd8\x4c\xa0\xdf\xe0\x54\x76\x85\xd3\x13\x61\x62\x84\xdd\x01\x98\x1e\x26\xe0\x2c\x8b\xc3\x96\x21\x60\x82\x62\x79\x5c\xc0\x9e\x04\x4f\x56\x14\x44\xd9\x4a\x4d\xc1\x08\x1d\x4e\xa0\x09\xa3\x68\x52\x49\xc9\xcf\xd2\x95\xf8\x88\x5f\xe5\x33\xfa\xc2\x2a\x18\xf0\x8b\x42\x71\xc8\xef\xc6\x52\x10\x87\xfc\x67\xc3\x78\xf0\xb0\x97\x81\x7b\xc3\x6b\x7c\x6b\x12\xe1\x28\x57\x76\xf6\x7f\xa3\x5c\x69\x2a\x57\xaf\x71\xbf\xb5\x09\x43\x45\xfc\xac\xde\xb4\x2c\x41\x39\xa9\xf7\xe1\x11\x1a\x0f\x59\x84\xdf\x54\x8a\xe9\xb1\x7b\xe3\x6e\x65\x22\x7e\x88\x1e\xf4\xf4\xd4\xc6\x9c\x89\xfd\x7a\x6d\xc4\xfb\xe7\x47\x5e\xa2\xa1\x4a\x11\xdf\x74\xb2\xe9\x17\x7e\x27\xf4\x55\x87\x82\xa8\x0b\x1a\x86\xc2\x72\xdb\x01\x7d\x07\xd9\xb3\x9d\xc9\x36\x8b\xde\x3e\xac\xac\x6b\xd7\x92\xcc\xb4\xe4\xe4\x1e\xdd\x4a\x64\xb9\x04\x77\xa8\x09\x97\xe0\x12\x3a\x07\x6b\x5f\x13\xe6\x45\x8e\xc4\x35\x4b\x12\x73\xb4\xa2\x9e\x63\x30\xa8\x5a\xd2\x58\x3a\x1b\x35\x53\x8b\x9f\x80\x7f\x97\x42\xe7\x9c\x30\x03\xed\x82\x43\x0e\x96\x87\xae\xb0\x39\x93\x8d\xd3\x61\xc6\xcc\x20\x9a\xa9\x82\x61\x93\x53\x4c\x03\x74\x10\x96\x73\xf9\x86\xe4\x2e\xec\x5d\x77\xc8\x8e\x7d\x59\x4b\x0f\x63\xf1\x1d\x6c\x99\x70\x08\x47\x7a\x0d\x5b\xd8\xde\xe3\xe5\x49\x59\x97\xac\xa5\xd5\x25\x03\xf0\x42\xa7\x3d\xd3\xc2\xa5\xb5\xad\xe8\x32\x45\xf1\x77\x2d\xb5\xf4\x8f\xeb\x3a\xa2\x5d\xa1\xa3\x7c\xc4\xa8\xc4\x15\x8e\x15\xbd\x48\x6e\xdb\x44\x67\x51\x61\xef\x41\xfc\x00\x6e\x43\x64\x96\xd0\xf3\xbb\xd9\x9f\xde\x11\x99\x34\xbc\xaf\xd1\x3a\x32\xe0\x70\x17\xb6\x0f\x0e\xc8\x0a\x2f\x1e\xda\xc3\x28\x18\x74\x49\x99\x1d\x6c\x9e\x02\x7f\xaf\x91\xa1\x69\x25\x7c\xf7\xce\xed\x95\x85\xbd\xee\x55\x02\x53\x36\x6c\x98\xa2\x6c\x4e\x6a\x27\x4d\xd1\x77\xe9\x9c\x89\xd7\xb2\xe7\xd0\x4d\x47\x40\xd7\xfe\x02\x34\x35\x21\x37\xcc\xb8\xba\xc8\xbe\x82\x4e\xe5\xe1\x50\x81\x25\x21\xad\x3c\x9c\x92\x60\x37\x70\x0e\xae\x32\xec\x70\xf0\x82\x60\xaf\x0c\xd3\x30\xac\xd7\xe9\xa3\xa8\xc8\x23\x35\x4b\x35\xe5\x0d\x3f\x66\xc9\xc6\x39\x29\x68\x27\x51\x82\x14\xb3\xfc\x40\x19\x45\x25\x98\xe5\xf3\x04\xb2\xe5\xe1\x20\xcd\x88\xc0\x08\x69\xc6\xa1\x58\xee\x63\x2f\x4e\xc6\x78\x44\xe7\x82\x71\xe7\xb1\x88\xd3\x97\x2c\x5a\x37\x53\x3f\xa0\xa8\x5d\xdb\x9e\x7d\xfa\xf6\x1f\xce\x3d\xfd\xc6\x13\x4b\x67\xe3\xe3\x38\xa3\xe8\xae\x8c\x3e\x2e\xdc\xa3\x4b\xea\x89\x6d\x93\x67\x70\xc7\xb9\x14\xbf\x1c\x4c\x28\x4e\x1b\x37\x80\x23\x91\x88\xd0\xf3\x81\x75\x7b\x14\xa5\x38\x72\x9c\x5c\xe9\x56\xa4\xac\x5d\xaf\x78\xea\xbe\x5d\x74\x57\x6a\xbe\xaf\x4b\xf1\xb6\xcc\x76\x89\x5a\x6f\xd7\x70\xc9\xb1\x4f\xef\x9c\xd7\x36\x35\xbd\x28\x77\x40\x77\x5f\x56\x9c\x25\x7b\x09\xf0\xd6\x17\x34\xc6\x11\xd0\x21\x05\xd1\x37\x67\x79\x68\xf0\xa1\x04\x97\x37\xc5\x4b\x25\xc7\x1a\x6e\x9b\x9d\x61\x4f\x21\x79\x5a\x2d\xc9\x4c\xb3\x71\x84\xa3\x77\x8d\x61\xb3\x1e\x7c\x67\x21\x2e\xc9\x66\x14\x48\x73\x8e\xa8\x98\xe4\x50\x8e\xa2\x49\xff\x0b\x9a\xf5\xb4\x3d\xc4\xb4\x33\x01\xde\x70\xb7\x96\x28\x3f\x09\xb0\x54\x78\x21\x1f\x48\x92\x17\xa7\xfb\x41\xa3\x84\xdc\xc1\xc0\x32\xcd\x48\x5f\x17\x33\x26\x9e\xb3\x9a\xd7\xf0\xd9\xc5\x98\xdc\x5d\xe2\x0b\xf7\x5f\xe4\x7b\xe0\xde\xdf\x0c\xda\xe9\x07\x7f\x33\x6f\xf6\x91\xa9\x62\xe7\x35\x16\x5e\x39\xb1\x4a\xab\xc9\x4b\x7c\xda\x4b\xb8\x8e\x1f\xee\xc6\xeb\x94\xf9\x66\x33\xfd\xdc\xfd\xe1\x6e\x65\x1a\xd6\xaf\x81\x8f\x8d\xbb\x13\xfe\xfa\x48\xd7\x0f\x57\x0f\xeb\xda\xb5\x1b\xf3\x61\xc1\x93\x10\x8a\xf8\x0b\x60\x93\x7c\xa8\xcb\x51\xbb\xdd\x2a\x49\x36\x6b\x42\x37\x33\x1e\x81\x2c\x78\x24\xdc\x36\xe1\x2a\x14\x46\x56\xb8\xb6\x21\x27\x3b\xb7\xc1\xfd\xe6\xac\xb3\x34\xdf\x69\x9e\xb5\x43\x5e\x2c\x11\x32\xf1\x47\x13\xf5\x10\x7f\x02\x17\x24\x6a\x8e\xdc\x20\x81\x89\x31\x17\x7a\xe3\x99\xf8\xd0\xbb\xed\xdc\x55\x77\x3d\x72\xfa\xed\xab\x7d\xff\xf2\xee\xac\x27\xe7\xce\xed\x93\x74\xd7\xdb\xab\xb2\x56\xff\xfd\x69\xfe\xc2\xa6\xdd\x35\x4b\x95\x2f\x7f\x9b\x51\x36\x76\x68\x43\x23\x7f\xa1\x21\x40\x7c\x91\x43\x5d\x36\x6d\xe5\x1e\x89\x0c\x79\xeb\xbb\xe9\xaa\xbf\x98\xaa\x6c\x11\x86\xb3\x77\x34\xef\xb2\x77\x48\x6f\x37\x6d\x6d\xfc\x0f\x8d\x45\xd8\x2e\x1a\x6f\x08\xfc\x86\x50\xd3\x77\x82\x19\x6c\x59\x16\x1a\x25\x17\x66\x38\x5d\xce\x9a\x30\xb6\x58\x2d\x35\xe1\x4c\x64\xb5\x58\x39\x2d\xb1\xca\x7e\x97\x4b\xef\xf1\xa4\xcc\x0d\x9b\x93\xb0\x56\x48\xf2\x48\x7a\x7e\x6e\x78\x98\x84\x5d\x12\x96\xf4\xf1\xd4\x8c\xb1\x2c\xe4\xc1\xe6\x94\xdd\x34\x9b\x44\xe5\xf5\x56\xcc\xc7\x52\x96\xc6\x72\xab\xd2\x51\x2d\x01\x55\x1f\xa4\xc6\x2c\x96\xe6\x14\xcc\x18\xcd\x09\x36\x4d\xb9\x87\x1f\x57\x35\xe8\xbe\x81\x55\x93\x2e\xad\x79\xfb\x32\xde\x9c\xb8\x42\x8c\x5b\x91\xb8\x69\x28\x2e\xf9\xf8\xd7\xbb\x9f\x09\x2e\x18\x50\x79\x7f\x1b\x3c\x2b\x51\x59\x10\xc7\xe3\x35\xf8\xfc\x1d\xcb\xbb\x14\xd7\x0d\x1e\xfc\xed\x07\x49\xf7\x67\xce\xda\xf0\xc5\xbf\x36\xbc\xd9\x4e\xbe\x73\xf6\xfa\xa1\x3d\xd5\xfe\xb1\x18\xca\xc0\xa3\x76\x94\x25\x3b\xf4\x76\x04\x12\xa9\xe1\xcd\x26\x2b\x8c\xa7\xd1\x6a\x13\xb9\x66\x2e\x04\x35\x16\x8c\x62\xab\x2a\x6f\xcc\xa2\xf8\xda\x59\xd0\x64\xbb\x7f\xe0\xf4\x49\x38\x30\x29\x0f\x7f\x8f\x47\x44\xae\xe2\x47\xdb\x2a\x87\x7f\x53\x76\xbc\xff\xf0\x60\xe5\xc2\xcc\xe9\x24\x8f\x73\x45\xae\xd0\xe3\xdb\xc8\x8b\x5c\xdb\x0d\xca\x58\xae\x94\xb6\x5d\x0e\x6d\xe7\x42\xdb\x6e\x54\x25\x17\x20\x87\xd3\x51\x19\x36\xf3\x16\x62\xb5\x54\x86\x6d\xd8\xca\xc9\xe0\xd6\x48\x46\x43\x25\xf8\x35\x46\x51\x16\xa5\xca\xb0\xc8\xc9\x1c\xa9\x0c\x73\x9c\xce\x49\x74\x36\x35\xff\x63\xf4\x99\x34\xcb\xb7\xd2\xa1\x83\xaa\x8a\xe9\x9d\xd8\x79\x94\xc0\x52\xba\x24\xd0\x83\xf8\x42\x42\x28\x9d\x1e\x34\x0e\xb1\x44\xa6\x64\xe2\xdb\xda\x2a\x0f\xa6\xe0\xc9\xb9\xca\x96\x90\x72\x21\x45\x39\x95\x8b\x3b\xc2\x67\x5b\xdc\xa9\xab\x32\xb9\x2d\x3f\xb4\x2d\x3f\xf6\xfc\x8a\x6f\x57\x3c\x05\x87\xf2\xcd\x8e\x59\xdf\xce\x7a\x0a\x0e\xdc\xfd\xf3\xcf\x81\x7e\x02\x42\xca\x9d\xfc\x1b\xc2\x27\xc0\xdc\xc5\xa8\x1b\x1a\x84\x46\xa1\x9e\x72\x6a\xdf\xec\xcc\xdc\xce\x66\x73\x52\x30\xc7\x96\x4b\xca\x13\xe2\x87\xc8\xe9\xdd\x4b\xfd\xcb\x46\x6a\x93\x6c\xa5\xf1\xb6\x90\x40\xa8\xc2\xab\x2f\xa9\x2f\x39\x55\xef\xf9\xd8\x0a\xf8\xd6\x5b\x99\x91\xa8\x87\xfe\xd4\x5b\xea\x0b\x0a\x62\xf9\xcf\x88\x28\xf9\xa3\x49\xc5\x5c\xd8\x65\x8b\xa6\x00\x16\x63\x79\x64\xdd\x1e\x1c\x12\xa5\x22\xba\x04\x83\xe6\x2f\x15\xd5\xf4\x41\xaa\xe2\x4b\xa7\x79\xb0\xad\x85\x5c\xc0\x84\x09\x27\x05\x62\xa9\xe0\xa9\x13\xf4\xc6\x2d\x63\x8b\xfd\x29\x0e\xf3\x73\x2e\x7b\x89\xe3\xb6\xea\x61\xe3\x23\xb7\xaf\xdc\x3c\x6e\x47\xf5\xed\xd5\xdd\x47\x17\xcb\x72\xd0\x9f\xda\xab\x6f\xfe\xda\x09\x6d\x1e\xbb\x45\xea\x92\x91\x97\x52\x96\xd6\x19\xbf\xe8\x4d\x6f\x9b\x92\x95\x18\x29\xef\xdf\xa5\x66\x49\x8f\xe2\xe4\x8e\x6d\x8b\x8a\x96\xa7\xa4\x39\xe2\x9c\x26\x4f\x8e\x80\xdb\x6e\x7a\x38\x47\xf9\x6d\x6e\x7e\xe7\xbb\xf1\x7b\x9b\x1e\xde\x4c\x16\x99\x94\x8f\xbf\x7b\x43\xd9\xf0\xde\xf4\xe9\x43\x07\x96\x8d\xb5\x73\x5e\xdc\x7d\x44\x42\x69\x47\x5f\x07\xdd\x2d\x99\x7e\x6b\xa7\x79\x0d\xf1\x0f\xcf\x7c\x7c\xd6\xb2\x5b\xc6\x4f\x0b\xe3\x4d\x38\xe3\x35\xac\x33\x95\xfe\xac\x7c\xa1\x3c\xb3\xa9\x6d\x6a\x28\x2b\x3f\xab\x7f\x3f\xd0\x27\xf4\x5d\xf1\x97\x30\x27\x49\x03\x8f\xaa\xad\xec\xc9\xd5\x78\x93\x92\xe3\x3c\x12\x4a\xb4\xc5\xdb\x4d\xf6\xea\xb0\xc5\x94\x80\x32\x61\x0a\x15\x7d\xde\xa1\x06\xbb\x62\x91\xbc\xb1\xfa\x6c\xd7\x8c\x6d\xd1\xcc\xc0\xd1\x70\x57\x01\x12\x90\x7c\xd8\x1d\x62\x26\x97\xa5\x7a\x15\x93\xb0\xc3\x4d\x13\x61\xbd\xbd\x7e\x6d\x76\xef\xa5\xf7\x25\xeb\x5e\x7d\x75\xf9\xad\x39\x83\xfa\xf5\x2b\xd3\x9d\x9f\x39\x4e\xf9\x01\xd7\xac\xd8\xe3\x32\x5c\xf8\x3a\xd3\x27\xcb\xfa\x6e\xdd\x3b\x09\x67\x57\xcc\xe9\x38\xef\xae\x63\xef\x29\xf7\xdd\xd5\xe9\xf4\x19\xdb\x27\x19\x23\x26\xe7\x7d\xa1\x5c\x7d\x65\x27\xfe\xf6\xa5\x0b\x3f\x3f\x57\x7a\xb9\x51\xb9\x94\xdd\xa6\x76\x75\x72\xfb\x07\x6f\x9f\xba\x83\x3e\x77\xa2\x32\x56\x0c\x7c\x1e\x4f\xe3\xef\x83\x26\x99\x22\xf7\xb4\xa6\x55\x86\x2d\xd6\x14\x6b\xbe\x75\xbb\xf5\xaa\x55\x40\x56\xd9\x5a\x6e\x7d\xcb\x7a\xc9\x2a\x98\x13\xb4\xf1\xf1\xc8\x6f\x74\xea\x12\x9d\xc4\x85\xe4\x74\x98\xa1\x23\x0b\xd8\x90\xfb\x11\x9f\x42\xac\xc0\x68\x9c\xdd\xc6\x65\x81\x14\x10\xb5\xdb\xec\x55\x54\x25\x7d\xee\x18\x84\xa9\x35\x7d\xb7\xa6\xba\x1e\x63\x2a\x66\xe6\xa8\xb2\x4a\xf3\xdb\xaa\x86\x41\xe4\x73\x70\xcc\xd5\xca\xc2\x92\xaf\x2b\x16\x0a\x40\x0a\xec\x3e\x50\xb2\x8b\xe6\x15\xe2\x4b\x6f\x7e\x61\x9f\x1e\x37\xd2\x1a\x76\xcf\x19\xa0\x7c\x7f\xfc\xf5\x0a\xe5\xc2\xa6\x79\xee\x79\x96\x79\xa4\xbd\x32\xde\x82\xff\x22\xea\x94\xf7\x16\xf7\x55\x76\xe8\xfa\xe0\x61\x1d\x16\x6d\xe5\x43\xd8\xb4\x6e\xd5\xc2\xa1\x0b\x57\xdf\xaf\xa4\x71\x3f\x2d\x1c\x3a\xd4\xd4\xfe\xa7\x60\x10\x2f\xc8\x62\x73\xca\x61\x4d\x05\xfc\x0e\x18\x3f\x17\x4a\x46\x7e\x14\x92\x93\x3c\x29\xae\x14\x90\x6d\xef\xd8\xb0\xcd\xa6\xe7\xb0\xec\xb2\x27\x58\xf5\xd6\xaa\xb0\x59\xab\xd1\xb3\xd9\x64\x74\xce\xe5\xa9\x67\x21\xcb\x54\xd1\x15\xfc\xa1\x34\x3a\xa9\xa2\x6f\xc2\x93\xb1\x5b\xc8\x00\x5d\x0e\x72\x41\xc0\x47\xb2\xc3\xfc\x51\x20\xe0\x44\x71\x59\xbb\xd2\x95\xbd\x0f\x61\xeb\x61\xf7\x2e\xf7\xc6\xa7\xec\xca\xe7\xc6\x41\xfd\xf0\x73\xb7\xff\xf6\xc9\xb9\x36\xb9\xbb\x4b\x17\x94\xe1\x50\xe7\x41\x95\xb9\xe7\x5e\xed\x88\x77\x7d\x85\x37\x7e\x17\xbf\x70\xae\x69\xff\xe1\xe2\x07\xd3\x94\x65\x91\x77\x0e\xba\xf0\xaf\x55\xb3\x93\xc9\xf8\xe4\xa3\xca\x6f\x33\x95\x73\xfa\xce\xdf\xaa\x7e\xcc\x96\xa8\x1f\xec\x06\x4f\xd8\x87\xe4\x43\xcd\x7e\xaf\x36\x1c\xa7\x77\x27\xe8\x9a\xad\x76\xa2\xe4\x06\xab\x0d\xde\xaf\xb7\xc5\x6a\x9f\x8d\x5a\x6d\x6b\x30\xd8\xca\x58\x83\xbe\x84\xc9\x94\x9f\x8e\x07\x7d\x65\xc0\xc6\x22\x0b\x07\x60\x40\x32\x8a\x24\x71\xe7\xed\x3f\xf8\x70\xfa\x0f\x78\x64\x17\x9c\xee\xfb\x21\xe1\x19\xdf\x9c\x7c\xe5\x43\xaf\x52\xb6\x4b\xb9\x70\x74\xb6\x0f\xbf\x80\x47\xdb\xbe\x2e\x5f\x67\x36\xa7\x72\x9a\x73\xbb\xf1\x69\xa5\xc3\xee\x73\xbb\x95\xed\xb8\x8a\x1e\x70\x7a\x62\xa8\x7f\x18\x9d\x87\x7c\x0f\x36\x2b\x01\x6c\x56\x3b\xb4\x55\x6e\xbf\xda\x88\x05\xe3\x03\x46\xce\x61\x2c\x35\xee\x30\x92\x97\x8d\xf8\xa5\x00\x6e\x13\x38\x1b\xe0\x12\x02\xb8\x6f\xe0\xd6\xc0\x9e\x00\xd1\x06\x6e\x0b\x2c\x0c\x10\x1d\x31\x07\xbc\x01\xce\x26\x4a\x71\xf1\x71\xb4\x67\xb6\x30\x6f\x8e\xc7\x39\x24\xde\x2b\x07\x72\xda\x79\xb9\x64\x6f\xb2\xea\xbc\x78\xbd\xd6\x9c\x9c\xf4\xea\x70\x0e\x6f\xd5\x8f\x0d\x5b\xed\xad\x1e\x38\xaa\x1e\x9c\x15\x48\x40\x3d\xe1\x98\x99\x83\x6f\x3a\x7b\x8b\xfe\xa9\xaf\xa7\x99\x45\x63\x09\x1e\x05\x9a\x7d\x3d\x8d\x65\x95\x0f\xc1\xcc\x27\x04\x9a\x59\x7d\x34\xd4\x9c\xc2\x5f\x94\x84\x84\x94\xdd\xb7\x9d\xc5\x2f\xf9\x1a\x9f\x49\xff\xf2\xe7\x51\xd8\x35\x48\x39\xf0\xed\xe5\x26\x64\x15\xfa\xf8\xee\xef\xb6\x73\xa4\x32\x38\x85\x74\x4d\x1e\x3f\xea\xc4\x40\xe5\xab\x3e\xd8\x7b\xe9\xec\x55\xc9\x40\x0e\xec\xbe\xad\xf3\xee\xdc\x0e\xeb\xcf\xa4\xbf\x74\xea\xf0\x8e\xd2\x0c\xd3\xee\x92\xfe\x9e\xdd\x81\x76\x72\xc9\xd1\xa4\x63\xfb\x9f\x79\x20\xb9\x4d\x32\xe2\xd0\x50\xe0\x53\xfa\xec\xc3\x8d\x92\x50\xae\xec\xf6\x58\x9c\x96\xaa\xb0\x5b\x06\x1f\xc5\x6e\x4e\x10\x13\xaa\xc2\x46\xad\x24\x02\x7f\xd6\x07\x63\xcf\x04\x82\x9e\x68\x6e\x2f\xe1\x46\xd6\xa4\x0f\x01\x04\xf0\xc0\x1c\x6e\x3b\x4c\xfe\x5f\x57\x36\x3c\x8d\x13\x8e\x01\x53\x6e\xda\xe7\x50\x2e\x1b\x47\x3f\x37\xaf\x06\x4b\xaf\x29\x87\xd2\x77\x25\xcd\xda\xbb\xe2\x11\x53\x2e\x3e\xf2\x25\x7e\xe4\x1b\xc7\xfc\xf9\x8e\xbf\xee\xed\xfe\x78\x6e\xe3\x9d\x59\x7f\x2d\x54\x96\x67\x9c\xe0\x5e\xfb\x47\x7b\x72\x47\x81\xb2\xb9\xa9\xa9\xe9\x2c\x6f\xe3\xfe\x29\x19\x2c\x12\x32\x2a\xcb\x70\x37\xf6\x2c\xbb\x4b\xd3\xcf\xfc\x29\xa1\x1c\x19\x41\xab\x14\xa3\x8e\x68\x9b\x1c\xee\xd8\x81\xb4\x0f\x8d\xf3\xc2\xfc\xcb\x5b\xee\xe5\xf4\x82\xd7\xef\x4f\xac\x0b\xe7\xf9\x07\xf9\x39\xb3\xbf\xc4\x5f\xe9\x9f\xee\xbf\xe8\x17\xf4\xc4\x2f\xdb\x5d\xbd\xfd\xd9\x72\x76\xb0\x2e\x3c\x25\x0f\x13\x73\x5e\x65\x1e\x14\xcf\xcb\xe6\x25\x4b\x5d\x38\x45\x92\x25\x0e\x49\xf9\x52\xb9\x54\x25\xbd\x25\x41\x79\xa9\xae\xe9\x65\xd9\x00\x75\x24\x24\x23\x57\x5d\x18\xb1\xe1\x66\x56\xb7\x92\x2a\x99\xa8\x6f\x53\x59\xd1\xfa\x66\x74\xcc\x2b\xc0\xd9\xa1\x8f\xb6\x85\x58\xaa\x6d\xfa\x5e\xc3\x5e\xd8\xf2\x42\x03\x3b\x5a\xf9\x3d\x6a\x32\xee\x24\x2c\x85\xd4\x77\x1e\x56\x98\x30\x91\x61\x35\x13\x6f\x7d\x6c\xfe\xd9\xe2\x71\x6b\xee\xe8\xda\xae\x5f\x51\x49\xce\xa0\xe2\xc6\x93\xa5\x19\xc1\x84\xed\x39\x4f\x56\xdc\x36\xb9\x62\xe7\xac\x5b\x2b\x9e\x22\x8e\xe4\xfc\x7e\xa1\xbb\xc9\xeb\x6b\x0c\xcb\xef\x58\x8c\xf3\x1f\xfd\x7d\xd4\x77\xcf\x86\xb9\x7e\xf3\xef\xfa\x75\xc0\xa2\x95\xff\xc1\xe9\x2b\x87\x8c\xd0\xae\x7b\xf4\xee\x25\x4b\x71\xfa\x5f\x56\x2e\x71\xe9\x7b\x64\xe7\xcf\xfd\x77\xe3\xa3\x20\xdd\x1c\x5a\xcd\xd6\x1b\x3d\x00\x3a\x36\x0b\xb4\x54\x4a\x62\x86\xe4\x70\xf8\x07\x87\x53\x1c\xe5\x8e\x65\x8e\xfb\x1d\xbc\xd9\x81\xb5\xc4\x41\x88\x24\xa1\x21\x61\xc9\xa5\xbe\xbe\x8c\x3e\xa4\x53\x9d\x8c\x76\xf9\xe9\x6c\x21\x18\x66\x59\x16\xc1\x26\x97\x60\x7b\xec\x0d\x23\x67\xc6\xa2\x9a\xd2\x55\x22\x5d\x39\x6e\x5e\xf9\xe4\x9c\x8d\xb7\xfc\xba\x53\xf9\x5e\xcc\x28\xeb\x9d\xb1\xbe\x7f\xea\x2f\xaf\x6c\x7c\xb4\x7c\xeb\xc7\x77\x07\x24\xbc\x66\xc4\x9c\xe4\x6e\xb7\xac\x19\xf8\xda\xe4\x29\x17\xde\xfd\xd2\xd5\xee\x35\x8f\xeb\xb5\x7c\xbc\xfa\xc0\x89\xb9\x33\x06\x9f\xdc\xbd\xaa\xcd\xdf\xfc\xbe\x59\xe4\x54\xcd\x66\xe5\xf9\x94\x85\x8f\xb1\xf9\xeb\x5e\xf8\xb8\x02\xbd\x30\xb2\xec\xf4\xd9\x34\x33\x83\x23\xa9\x2e\xec\x30\xeb\xb1\x48\x4c\xfe\xba\xb0\x29\x53\x0e\x64\xd6\x84\x03\x01\xa3\x06\xb4\x19\x4b\xb3\x1a\xcc\x8b\xa6\x64\xa0\x23\x17\x2c\x61\xb3\x2c\x9a\xae\x11\x07\x01\x69\x7b\x50\x8b\x53\xa3\x23\x41\xfd\x8d\xeb\x06\x8b\xe6\x7e\xe9\xd6\xcf\x94\x74\xe7\x76\x2c\xbe\x3c\xc4\xe2\x5c\xf1\xb8\x72\x0d\xaf\x39\x3e\xe2\xc1\xc9\x13\x47\xde\xb2\x49\xce\xcd\xea\x52\xd0\x26\xa7\x53\xa1\xd2\x25\x19\x1f\x4c\x26\x2b\x47\xee\x8c\xdc\x21\xf4\x6c\x9c\x33\x69\x39\xf7\xc4\xb5\xe3\x38\xe7\xb3\x3b\x71\xf2\x7d\x33\x26\xcd\x55\xce\xde\xcb\xe5\x87\xe7\xff\x26\x0f\x9f\xf1\x6b\xe3\x95\x47\x1e\x61\x36\x32\x83\xdf\x0b\x32\x68\x86\x7e\xa4\xa2\x5c\x54\x20\x27\x7a\x2d\x6f\x84\xed\xc9\x6f\x80\xbd\xb0\xdb\xbd\x36\xc2\x1b\x0c\x19\x67\xc2\x06\xc4\xb7\x39\x13\xa6\x6f\x7d\xa2\x0a\xc7\x4d\x27\xde\xea\x2b\x0e\x07\x47\xd5\x08\xa7\x3e\x2a\xe5\xc1\x85\xf4\x5b\xd9\xc4\x51\xf4\xdb\x0b\x73\xb0\x15\x18\x4d\xb0\x70\xfe\x54\xce\x6a\xb1\x81\x6f\xc4\xef\xdd\xa0\xfc\x7e\xe0\x79\xe5\xf7\xfb\x37\x60\xed\xf3\xcf\x63\xed\x86\x48\xdf\x2d\x38\xb8\x61\xcb\x93\xcb\x37\x3c\x7f\xc7\xea\xf2\x61\xd8\xf4\xe3\x87\xef\xff\x78\xf5\x1f\x17\xae\x72\xbf\x7f\xae\x1c\x7b\x7a\x0f\x2e\xfd\xe2\x33\x5c\xf6\xcc\x1e\xe5\xb8\xf2\x9a\x72\x94\x94\xdc\x39\x7d\xc6\x43\x58\x5a\xaa\x7c\x3d\xb0\x06\xa7\xe0\x12\xe5\x15\xe5\x92\xf2\x89\xf2\x1a\xee\x02\x3c\x85\x48\x5f\xfe\x88\x70\x06\x81\xb7\x82\x86\xcb\x5e\x8b\xd3\xe8\x4c\x72\x72\x46\xe2\xcc\xb7\xb8\x7a\x3b\x05\x9a\x7c\xe8\xcd\x70\x9c\xd9\xee\xb5\x73\x76\x93\xa6\xae\xe9\x2d\xd9\x01\x3f\xf4\xd3\x8c\xd2\x70\x66\x8d\x57\xc3\x69\x38\x4f\x3c\xcd\x76\x4e\xc7\xeb\x6c\x01\xf0\x59\x41\x81\xaa\x49\xad\xc1\x1c\x66\xec\xa1\xbf\xf4\x91\x7c\x91\xcf\x89\xe9\xa0\xc1\x79\x48\xa2\xf3\x3e\x37\x9c\x05\xed\x2e\xdc\xe9\xd1\x6d\xf8\x13\xbc\x82\x8b\x5b\x75\x74\x0d\xf1\xac\x1d\xbb\xd6\x43\xd6\x1c\xdd\x60\x12\x7a\x29\x04\x47\x56\xae\x54\xea\x2d\x03\x71\x38\xb2\x14\x8f\x1d\x39\x52\x79\x0c\x8f\x1d\x31\x42\x79\x8c\xbb\x4b\xb9\x37\x0d\xfc\xf2\x02\x1a\xb3\x90\xc5\x17\x4d\x97\xed\x36\x04\x16\x9b\x4f\xf6\xc4\x19\x44\xad\x46\x5b\x19\x4e\xd2\xd8\xa2\xcf\x46\xe9\x5f\x1c\x5b\x54\xa1\xa6\x08\xb6\xfa\x8a\xc0\x25\xa5\x0a\x91\xf2\x8e\xcd\x69\x11\x8a\x3b\x61\xa7\xcf\xda\x95\x3e\xd5\xe0\x26\x2c\xd8\x30\x62\xb2\x62\x9d\x23\x4f\x53\xae\x6e\x68\x78\x68\x6b\xe3\x06\xe5\xea\x2c\x79\x86\x62\x9d\x3c\x62\x03\x3f\xff\xdc\xd1\xd5\xe7\xa6\x29\x6f\x7d\xae\xbf\x80\x6f\x7f\x1a\x0b\x1b\x36\x28\xd7\x76\x2b\x9b\x2f\xe8\x3f\xc7\xf9\xd3\xce\xae\x3d\x7a\x8e\xad\xaf\x18\xd3\x74\x91\x5f\xc1\xf7\x46\x71\xc0\x2d\x39\x72\xbc\xf1\x52\xe2\xd5\x44\x2e\x31\x11\xc5\x6b\x2c\xd6\x1a\x07\xb6\x39\x30\xef\xc0\x0e\x70\x37\x4a\x80\x60\x15\xe0\x5f\x83\x19\xae\xa8\x67\xca\x87\x8b\xbe\xf1\xb7\x01\x3e\xb1\xa9\x16\x47\x52\x25\xab\xcf\x9a\xc1\xcd\xda\xf6\xd3\xca\x95\xbf\x6f\xd9\xfa\xd3\x9a\x08\x6e\xb3\xa4\xe7\x1d\xfb\x06\x4c\xec\xbd\x72\xd7\xed\xeb\x6a\xf0\x27\x93\x7c\x9b\x30\xd9\xf6\x94\xb2\x71\xa3\xf2\x9f\x67\x94\xa7\x53\xf3\x6e\x5f\xdc\x65\xe6\xdc\xae\xe4\x6a\x7f\xe5\x17\xac\x19\xc8\x9e\x21\xb1\x18\xee\x2f\x83\x0c\x06\x50\x0e\x0a\xa2\x10\x2a\x93\x33\xda\xe4\x1b\x7d\xc4\xed\x4e\xae\x0b\x27\xb8\x8b\x73\xeb\xc2\xf9\xee\xe2\x62\x77\x3e\xc9\x2e\x6c\x47\x72\x48\xb6\x8d\xe8\xea\xc2\x52\x4b\x80\xd6\x92\xe8\x1a\x29\x75\x42\x48\x15\x0a\x4b\x3a\xcf\x1e\x71\x04\x58\xca\x63\x6a\x0e\x03\xcd\xcf\x37\xd4\x19\x21\xcb\x79\xcc\xd9\xb1\x5f\x0b\x0e\x84\x44\xa5\x17\xa4\x38\xc8\xdf\xbf\x7d\xf3\xb2\xf9\xdc\x63\x7c\x56\xe7\xee\x5d\xe5\x50\x5a\x4d\xd1\xf6\x55\x53\x16\x3c\xc6\x65\x66\x76\x6c\xdf\x6e\x40\xff\x1e\x19\x9e\xc6\x75\x23\xc9\xbc\xc8\x34\xfd\xf1\x5b\xb6\xe3\x29\xbb\x7a\x1d\x8f\xaf\x5a\xf7\xf3\xe2\x7b\xab\x6b\x12\x43\x39\xf9\x45\x81\x1c\x93\x26\x67\x50\x68\xd6\xfa\x89\x95\xf6\x82\xcc\x9c\xfc\xd4\xb4\x38\x57\x5e\x19\x9f\x72\xed\xb8\xd0\x33\xe2\xfa\xeb\x5f\xb9\x2b\x11\x17\xd7\xab\xf3\xfb\x74\xfe\x06\x53\x48\x7e\x35\xdf\x11\x69\x51\x92\x6c\x16\x85\xa1\x61\x51\xc4\x1a\x33\xe6\x86\x86\xb1\x33\xe6\x9b\xd2\xb7\xb3\x59\xcc\xa2\x53\xdf\x87\x1c\x6a\xac\x0d\x70\xb7\xb4\x89\xbc\x1b\xe0\xda\x8e\xc4\x9e\x33\x17\xcf\xe0\xd7\xd9\x5c\x3c\xae\xe9\x7b\xfe\x84\xd0\xd3\x12\xd0\x5c\x51\x5e\xa2\xef\x8c\xa5\x1f\x3e\xa4\xb1\x9e\xbe\x43\xe7\x22\x87\xe8\x9c\xdc\x12\xdf\x1c\x03\x58\x2d\x3b\x18\xca\x7e\xfb\xc7\x65\x53\x9b\xcb\x36\xfd\xa7\xe9\x57\xfe\x05\xa1\xa7\x8d\xc2\x7d\x51\x2d\x7b\x94\x96\xbd\x8a\xde\x88\x1c\x45\xf9\xb2\x97\x27\x5c\x66\x3c\xfd\xf0\x66\xe6\x65\x0e\xca\xbc\x98\xc9\x63\xe3\x74\xe3\x45\x23\x88\x30\x7a\x0b\x71\x15\x74\x79\x6b\x05\xcb\xab\x51\x52\x54\x14\x5b\x1b\xf8\x2b\xff\x4f\x61\x30\xc0\xfc\x4e\xd9\xa4\xc2\x6c\x54\x61\x5e\x05\x98\x99\x72\x1c\x80\xeb\x45\x61\xf6\xf2\xf6\xca\xeb\xc5\x95\xf7\xc2\x28\xd3\x0c\xf0\x39\x96\x1b\xe3\x7a\x58\x49\x0c\x16\xc5\xef\x07\xe5\xd1\x3f\x81\xd5\x95\xc2\xea\xe6\xed\x96\xd7\x8d\x2b\xef\x06\x53\x76\xb3\xd7\xeb\xfd\x03\x58\x4d\x1f\x37\xf7\xf5\x47\xe5\xb4\x0a\x6b\x5b\x4b\x5f\x8b\xe5\x34\x00\x93\x45\x61\x65\x79\xb3\xf2\xb2\x06\x65\x11\x6c\xca\x33\x95\x98\x06\x99\x2a\x4d\xd3\x4d\x4b\x4d\x22\xd2\x7a\xb5\x58\xed\x6e\x0b\x64\xc0\xb1\x82\xc6\xb6\xe4\x07\xda\x44\xce\xc9\x9e\x19\x68\xd0\x38\xfe\x24\x4c\xe1\x8d\x28\xee\x10\x41\xb2\x1e\xd5\x61\xee\x40\x58\xa3\x47\x79\xf5\xea\x3c\x1c\x7c\x5d\x97\xdb\x9f\x11\x28\x2a\xa6\x93\x52\x9f\xf3\xab\x0e\x5d\x61\x6a\x75\xdf\xd2\xde\x5d\x3b\x90\x4f\x70\x56\x8f\xe5\x0f\xf4\x49\xeb\xf3\xc0\xf2\x1e\xc3\xd5\x77\x87\xf3\x9a\x5e\x23\xc3\xf9\xa5\x00\xcf\x29\x6b\x0d\x7a\xa4\x9d\xce\x81\x5f\x8f\xf2\x4e\x56\x14\x74\x60\x4f\x83\x60\x8e\x0b\x90\x5c\x6e\x67\x46\xc0\xea\xe7\x3a\xb5\xd4\x27\xdb\x5b\x20\x37\xfa\x6f\xc4\x4d\x6b\x90\xe9\x0b\x73\xc0\x8d\x33\xa2\xbc\x73\xaa\xd1\x03\x70\x19\x01\x0a\x8b\x4d\xad\x7d\x45\xe4\x8b\xd6\x20\xf0\xd2\xeb\x90\xbb\x19\x37\xae\x4a\x8b\xb5\x62\x0b\x6e\xe9\xc5\x21\x0a\x09\xfa\x0a\x0a\x30\xc8\xd5\xb6\x54\x7f\xa2\x75\xa7\xaf\xa3\x9b\x1b\x79\x65\xad\x49\xa3\x77\x72\x51\xe2\xed\x0f\xeb\xa3\x8b\xeb\xea\x0b\x2c\x34\x33\xe6\x75\xe4\x6b\x85\x6e\x2b\x42\x72\x4a\xcb\x79\x2b\x92\x36\x9f\xb4\xc2\xdd\x8d\x7c\xb2\xc5\x6d\x30\x55\x39\xb1\xd3\x86\xf4\x31\xf2\x9e\x65\x5d\x60\x9f\x37\xd0\xb8\x55\x9f\x5a\x51\xbb\xf9\xa4\x35\xd5\x23\x5c\xcb\x39\x8d\x81\x3d\xaf\xa9\x37\x6b\x93\xc0\x9c\xa9\xbd\x6c\x4c\xb0\xd8\x50\x3c\x36\x93\x78\x97\x8c\x08\xf4\x54\x36\xc0\x74\xdd\xc5\x9b\x8d\xd3\x45\x2c\x6a\x63\x38\x04\x5b\xde\x42\x31\x64\x04\x9f\xd3\x67\xff\x13\x84\xf0\x3c\x7c\x49\x49\x79\xfd\x66\xac\x26\x95\xf3\x23\xff\x14\x2f\x34\xa0\xe9\x0b\x7e\xa6\xf0\x3a\xcd\xd2\x8c\xb2\x65\x97\x09\xfc\x3b\xab\xc9\x24\x26\x24\x25\xb9\xcb\xc3\x49\x48\xcc\x2e\x0f\x8b\xae\xd8\x34\x06\xc1\xec\x85\x66\x00\xa4\x3e\x85\x0e\x47\x7d\x53\xba\xe0\x1f\x26\xd2\xb1\x77\xd6\x34\xe7\xae\x0d\x53\x45\x4c\xbd\x23\xfa\xb0\x85\x9f\xd9\x71\xf6\xf6\x73\x8b\x4f\x9c\x1f\x7c\xcf\xb1\x59\x13\xb7\xa7\x8b\xd2\x03\x9b\x7b\x3c\x58\xd8\x76\xe6\xb6\x2f\x7f\x55\xae\xd8\x17\x0c\x0c\x6f\x1a\x5d\x39\xfc\xae\xbf\x91\xa7\x97\x29\x6f\x28\xca\x73\xa3\xcf\xbc\x30\xef\xd7\x43\x63\x47\xf5\x1d\xe0\xd9\xb9\xbf\x20\xe3\xad\x3e\xca\x95\xc8\xd7\x7d\xc7\x2e\xfc\x7a\xce\xe8\xdb\x40\x81\x72\xc8\x06\xfa\xf5\x45\xb0\x2b\x02\x32\x81\x86\x35\x99\x08\x12\x79\xb1\x2a\xcc\xdb\x74\x5c\xf4\x25\x4b\xec\x8d\x4a\x08\xfb\xc0\xd2\xa6\x93\x8c\x3c\xc0\x56\x22\x36\xfc\x2c\x0e\xe3\xa7\x1a\x86\x93\x95\x17\xdb\x78\xb4\x38\xe4\xfe\xf8\x33\xbe\xa6\xe1\xd1\xcf\x7e\xe6\x26\xdf\xbd\x20\xa0\xfb\xa0\x4f\x64\x2b\xf0\xe3\x24\xa5\x03\x5f\x03\xf0\x25\x64\x39\x2a\x70\x55\x61\x81\xb0\x85\x6d\xcc\xa4\x83\x61\xa4\xff\x48\x1f\xa5\x4c\xb9\x40\x1a\x94\x0e\x62\xdc\xef\x5f\x4b\x86\xdf\x7e\x86\x7a\x2e\xa8\x47\xed\x9d\x9e\xe6\xd6\x23\xbc\xc4\x4b\x95\x61\x4e\xc3\x13\x0c\x96\x00\x3c\x04\xba\x34\x9c\xcd\x04\x4b\xa2\xcf\xe0\x80\x9f\x8b\xb4\x18\x3c\x15\x9f\x16\xfb\x9c\x2e\x6e\x4c\xe4\x08\x5f\x01\x66\xc4\x12\xf9\x98\x84\x94\x0e\xdb\xb9\x2b\xdc\x95\xad\x97\x23\xe3\x23\xc3\x3f\x67\x72\x32\x9e\xeb\xc0\x4f\x22\xf1\xd1\xb5\x9b\x7b\xc3\xf8\x20\x5b\xbb\x69\x07\x08\xe3\x41\x7b\x75\xb8\x74\x49\xb5\x03\xd1\x75\x34\x16\x51\xfa\x81\xc9\xea\x09\xfc\x38\x89\xe7\xde\x89\xae\x0f\xfd\x4b\x74\x7d\x28\x5b\xf1\x72\xa2\x13\x4e\xe9\x84\x1f\x57\x57\xe1\xd1\x36\x3a\x37\x7d\xc5\xef\x10\x87\x81\x4c\x66\xc8\x4e\x6e\x0e\x59\x49\x36\x13\x98\xc3\xf3\xbc\x46\xd2\x01\x6b\x62\x3a\xc9\x01\x97\x2b\x8f\x66\xa9\xae\xaf\x28\xa0\x8f\x21\x30\x38\x5b\x76\x1c\xe4\xf6\xec\x56\x7e\xaa\xc3\xa1\x8f\xf0\x23\xc7\xe2\xb9\x9f\x76\x46\x56\xc1\x34\x8c\x3d\xef\xb0\xa3\x93\xfc\x31\xf2\x01\xcc\xc8\xd2\x50\x3e\x7d\x9e\x2a\xda\xdd\x3a\x1d\xc9\x35\x7b\xb1\x37\xd3\xe3\xb6\x58\xcc\x6e\xec\x46\x79\x15\xc1\x3c\x10\xf2\x8f\x2b\x0a\xea\x0b\xf2\xd8\xc2\x61\xf5\x5d\x46\x20\x9a\x44\x99\x5a\x78\x37\x63\xb6\xf4\x54\x29\x66\xfb\x85\x98\xc5\x87\x4b\xfe\xd8\xf6\xe5\x63\xef\xee\xd5\xfe\x96\xf1\x5d\x56\x3d\xf6\xd8\xaa\xd1\xf7\xf4\xee\x38\xb4\xb2\xe3\xfd\xdb\x94\x53\x13\x26\xe4\x8d\xe9\xda\xb1\x47\x0f\x65\x4c\xc7\x5b\x0a\x3a\xf7\xe9\xdd\x35\x38\x8a\xeb\xb5\xfb\xa3\x19\xeb\xaa\x47\xb7\x7b\xfb\xc8\x33\x1f\xcc\xdd\x70\x5b\x65\xc1\xbb\x19\x17\xc6\xcf\x5e\x50\x35\x61\xf6\xf9\x65\xb7\x2e\xa9\xa8\x99\x73\x3b\xa3\x07\xdd\x1f\xb4\x95\x3f\x0d\xbc\x66\xd9\x2f\x70\x75\x98\x3f\x10\x16\xe8\x32\x70\xf6\x08\x89\xae\xe3\x2b\x1c\xc3\x8b\x0d\x8f\xf0\xa7\x1b\xb6\x8c\xa1\xe5\x1f\x69\x52\xf8\x7c\x5e\x03\x7d\xb6\xed\x17\xcc\x50\xfe\x60\x58\xd0\x53\xee\xa1\x35\xdc\x56\xe6\x6d\x25\x63\x27\x38\xa3\xea\x9b\x18\xeb\x23\x73\xde\x5e\xbe\xe2\xdd\xf9\x13\x4f\x6e\x7f\xe2\x65\x8e\x43\x0f\xfe\xb8\x6a\xe5\x4f\x9b\x15\xc4\x71\x27\x3e\xff\xec\x55\x85\xe1\x70\x1a\xf8\x4a\x14\x2e\x83\xbe\xf2\x80\xe2\xb6\x0e\x09\x9b\x0c\x18\x89\x43\xc2\x44\xcd\xa8\xad\xbe\x10\xc2\xa9\x54\x0d\x04\x0b\x8a\xac\xec\x09\xa8\x53\x85\xee\x10\x71\x75\xce\x68\x47\xf7\xa2\xbf\xbc\x77\x62\x64\x8f\x82\x9e\x03\xca\xdf\x55\x3a\x98\xa4\x0b\xf1\xaf\xf3\x9b\x0e\xfd\xcd\xfe\x51\xfc\xf8\x31\x0d\x53\x8e\x9c\x66\x6b\x89\x50\x25\xb6\xf1\x53\xf9\x10\x72\x82\x2e\x98\x28\x77\x71\x05\xf6\x86\x93\x91\x0b\xf8\x1a\xa6\x79\x2e\x39\xcb\xe7\x4b\xd8\x1b\x46\x3e\x8b\x8f\xd3\x12\x9f\x5e\x46\x96\xbd\x61\x0d\x45\x0f\xc1\xcf\x48\xb6\xe9\xf5\xc2\xde\xf0\x76\x3d\x36\xeb\xbd\x7a\x0e\xf4\x36\x7b\xba\x6f\x39\xe9\xf9\x04\xb4\xd7\xac\x93\xcd\x8a\xec\xba\x9b\x2a\xda\x4c\x6f\x14\xb1\xf1\x85\x0e\x84\x9c\x26\x4c\xae\xbf\x4b\x47\x9b\xdd\xae\xee\x57\xdb\x6f\x65\xb8\xc7\xbc\xb2\x69\x8f\x17\x2d\xde\xb0\x70\xd0\xea\x59\x25\x0b\x86\xc1\xbd\xbb\x46\xf7\x9a\xdf\x6d\xe6\xb6\xa1\xdb\xfb\x4f\x28\x4b\x5c\x3d\x4b\x9e\xcb\xfd\x9c\xe5\xc9\x0b\xb4\xfb\xfb\xb0\xf8\xfc\x9c\xd1\x1f\xb5\xf5\x2b\xc9\x6d\x3c\x6d\x73\xda\xfe\x7d\x58\xae\x27\xc5\x38\xfa\xa3\x36\x69\x14\xf1\x51\x28\x9d\x9f\x25\xe4\xc0\x58\xdd\x22\xe7\x1b\x00\x6d\x8c\xf4\xd8\x20\xe8\xb5\x16\x49\xa3\xd5\x80\x7c\x71\x16\x0e\x9b\x39\xb8\xc5\x11\x3a\x31\xd9\x1b\xb6\x8a\x82\x51\x97\xa2\xad\xd2\x72\x5a\xca\xaf\xc1\x73\xb1\x57\xb8\x2d\xeb\x52\x60\x22\xa2\x5e\xb0\x87\x39\x21\x2a\x1b\x3e\x38\x82\x24\xe8\xf4\x11\x9f\x93\xc3\x77\xfd\xfd\xae\xb7\x71\x97\x9d\x4a\x12\x57\xbe\xea\xdd\x15\x3f\x29\x8f\xef\xe4\x04\xec\x57\x94\x4f\x70\xdf\x8b\x98\x53\x94\x8b\xca\x91\x4f\x54\xb9\x99\x83\x7e\xe6\x47\xf0\xe5\xd1\x75\x6e\x3d\xf6\xd3\xe5\x6d\xe8\x48\x58\xab\x15\xd8\xda\x36\x74\x30\xcc\xd3\xa5\x6d\x48\x76\x86\xa7\xe3\xc7\xf0\x3e\x7c\x1e\xff\x88\x85\x72\x8c\xcd\xd8\x8b\x39\x4c\x87\xa0\xa2\x79\x1d\x66\x5c\x5e\x54\x55\xe0\xe8\x31\x87\x5c\x6e\x4c\x52\x0f\xf2\xe2\xe6\xcd\x91\xf6\x9b\x37\xe3\x71\x9b\x37\x03\x1f\x8c\x02\x9e\xaf\x80\x39\x31\x5d\x73\x65\x3f\x2a\x01\x25\x24\x91\xe3\x51\x7c\x5e\x7d\xbd\x0a\xc5\x8a\x9d\x5a\xcc\x80\x8c\xe2\xb9\xc6\x97\x89\xdc\xa0\xf0\x88\x9b\x8f\xbb\xe1\x5b\x2f\x2b\x5f\x2b\xdf\x5c\x56\x2e\x5f\xbc\xa8\xf2\xd4\x74\x80\x35\x33\x0a\x2b\x4e\xd6\xa9\xc0\x04\x28\xcd\xc0\x05\x83\x51\xb4\x40\x0d\x62\x2b\x05\x38\x9d\xc8\x8d\x2f\x03\x50\x98\x3e\xe0\xa4\xcb\xd8\x8d\xe3\x2e\x2b\x3b\x95\xbf\x46\xd6\x31\x80\x1c\xba\x1b\xe0\x75\xe7\x3b\xc1\xcf\x5a\xd0\x50\x5a\x36\x27\x34\x0a\x9c\x86\x49\x1a\x87\x04\xe6\x35\x20\x36\x0d\x86\x83\x2d\x4b\x09\x5a\xb5\xd8\x9a\xee\x83\xcf\xbb\xf1\xc7\xf8\xe3\xc6\xbf\x10\x9b\x32\x5f\x99\xcf\x2d\xc2\x2f\x2b\x72\x64\xd5\x2d\x1c\xc2\xb3\x94\x0d\x74\x0f\x33\x3a\xc4\x8f\xe0\x7e\x02\x59\x4f\xda\x4f\x18\x61\x8d\x61\x33\x29\x21\x3f\x82\x06\x2c\xc1\x98\x12\x34\xaf\x82\x19\x01\xbf\x1d\x68\x28\xc2\x14\xe8\x32\x57\xa5\x0c\xe3\xba\xaa\x6b\xeb\x93\x23\x0f\xf1\x9c\xf8\x34\xf0\x93\xe1\xa0\x45\xcf\xd4\x44\x3d\x5d\x57\x0d\xb2\x6e\x53\x9f\xd6\xf9\xd5\x5d\x72\x4e\x6e\x5f\xed\x8e\x07\xca\xc6\x17\xf8\x03\x39\x49\x09\xae\x60\x4e\xe4\x21\x29\xf9\x1b\xac\xed\xd3\x3e\xd0\x2e\x2d\x27\x6d\xcb\x2e\x55\x17\x9f\x89\x3c\xc4\xed\xfb\x03\x78\x41\xab\xa3\x59\x25\xb2\xad\x76\x45\x5c\x72\xed\xce\x4d\xad\xe0\x89\x4f\xff\xf6\xd9\xf7\x4a\xc3\xf5\xf0\x9a\x7e\xe1\x72\xf8\xf7\xb9\x17\x81\x9f\xe2\x0e\x03\xcf\xa9\xcc\x73\x20\x8c\x1b\xe9\x93\x1b\x75\x5b\x0b\x81\x21\xd0\xf1\xff\xe4\x72\x6a\x6b\x51\xac\x4f\x0c\x07\x82\x5c\xb2\x96\x23\x84\x17\x38\x05\x5d\x43\xf4\x9d\x24\x66\xb3\x31\xa8\xe7\x87\xe6\x6b\xc5\xa7\x7f\xb9\x1a\xa5\x01\x6d\x43\x40\xa9\xb2\x8e\x17\x04\x11\x4b\xbc\x42\x5d\x1c\x68\x08\x35\xaa\x8e\x04\xb4\x65\x53\xeb\xd2\x75\xd0\x50\x9b\x7b\x21\xf2\x41\x2d\xf7\x62\x6d\xc3\x34\x15\x4f\xda\x66\x0c\x06\xe1\x79\x09\x89\x44\x69\x8d\x6c\x6b\x18\x84\x2d\x78\xd6\x71\x2f\xd4\x02\xd2\xd7\x3e\xe1\x37\x46\xf1\xa6\x7d\x05\xbc\x05\xe4\x3d\xca\x01\x1a\x44\xe2\xa8\xc8\x1c\x0a\x03\x6b\x51\xf4\x73\x5a\x90\x60\x6a\x1c\xba\xc0\x65\x46\x7a\x89\x4f\x37\xda\x6b\xa3\xb4\x62\xfd\x66\x38\x08\x1c\x47\x71\xb8\xc6\x40\x1c\xa0\x20\x6e\xc6\x21\x08\x38\x64\x52\x1c\xc8\xf7\x0d\xcb\x9b\x69\xc7\x70\x90\xc0\xe6\x19\x38\x51\x94\x24\x0d\xd1\x8a\xca\x0d\x88\xb4\x00\x6a\xc1\x86\x91\x14\xf0\xf9\xa0\x96\x21\xd4\x9a\x2e\x0c\x5e\x40\x06\x9e\x17\xc1\x51\xd4\x08\x0a\xb9\x76\x03\x69\x62\xe0\x9a\x11\xf3\x33\xd4\x54\xdc\x7e\xb9\xca\x6f\x8c\xc2\x62\xe3\x24\x81\xd7\x67\x12\x44\x51\xc3\x69\x31\x00\xa3\x2b\xe8\x5b\x31\x05\x7d\xa8\xcb\x38\xa3\xb9\x9f\x4e\x46\x6d\xfe\x9f\x74\xc0\x80\x49\x1a\xa6\x31\x82\x47\x79\x8b\xe1\x46\xe1\x71\x9c\x46\x04\x78\xe4\x9a\x80\xff\x1b\x78\x56\xda\x5f\x46\xb9\x4c\x86\x1f\x23\x7f\x0c\x3f\x96\x9f\xb6\x48\xb6\x0b\x5a\x2d\xa7\xd3\x19\x44\x23\x36\x68\xa1\xbf\x1a\x15\x49\xb0\xac\x14\x6a\xf4\xd9\x73\x0b\xdc\x60\x6b\xd0\xbe\x68\xef\x19\x31\x63\x2d\x30\xac\xb9\xa6\x5f\xf0\x7c\xfe\x7d\x32\x83\xe9\xd7\x5c\xd0\x4d\x1c\xa7\xe5\x31\x50\x81\x67\xe3\x23\x44\x62\xa8\x37\xc4\xfc\x5f\xdc\xb2\x76\x36\xaa\x44\x81\x12\x0d\x5e\x90\x97\x8b\xb5\xb5\xca\x56\x55\x66\x38\x3c\x39\xf2\x10\xa9\x61\x32\x23\xa1\x14\xd9\xc4\x11\x49\x24\xa2\x46\x2b\x71\x40\x5e\x18\xf2\x82\x92\x20\x15\x9e\x96\x01\xf7\xb3\x63\x72\x6d\x2d\x9e\xa4\xca\x91\xd6\xd2\x22\x4b\x80\x9f\x16\x75\x90\xcd\xbc\x46\xa3\xd5\xea\xf4\x22\x5d\xf5\xaa\xf0\x12\x43\x91\x8f\xc4\x24\xab\xa1\x65\xb5\x80\x8a\x65\x33\x3f\x01\x09\x9c\xad\xc4\x8c\xd1\x81\xcc\xa8\x7d\xbf\xb6\x31\x95\xfa\x86\x93\xa3\x7c\xa0\x45\x6d\x65\xa3\x04\xce\xaa\x86\xe8\x90\x9e\x13\xb5\x22\x00\x3e\x1c\xd6\x36\x6a\x88\xa2\xae\x42\x41\x41\xc6\x57\x31\xb8\xce\xe8\x3e\x03\x2b\xff\xbe\x72\x2f\x80\x63\xe2\xcb\x6f\x6c\x98\x26\xf8\xa3\x34\x60\xb8\x0b\x30\x82\x9d\x64\x13\x2f\xe8\x75\x82\xce\x60\xd4\x60\x6c\x14\xb5\x00\xfa\x68\x58\x8c\xe8\x5b\x34\x43\x14\xff\x60\x8c\xc8\x2d\xed\x30\xdc\xa3\x9f\x93\xc9\xd4\x48\x1a\x50\x89\x13\xa0\x49\xe8\xc4\xb5\x63\xfc\x74\xb5\x1f\xaa\x6c\x30\x5a\x85\x64\x93\xc4\x69\x34\x3a\x3d\x38\xed\x3a\x49\x89\x8d\x66\x43\x6c\x34\x23\x7f\x44\x2a\x75\x48\x8b\x7c\x51\x65\x02\x44\x02\x85\x82\xe7\x43\xbf\xae\x65\x91\x4f\x55\xf8\xa4\x86\xd1\x29\x57\xb6\xa8\x74\xd2\x23\x1d\x10\x47\xbc\x59\x62\xae\x23\x14\x89\x6d\xc8\xb0\xea\xc8\x54\x4a\x27\x55\x4b\xa9\x82\xc3\xa9\x70\x5b\xe8\x24\x4a\x1c\x96\xb0\xc1\xa8\xe5\x79\x83\x4e\xcb\x30\xd7\x45\x58\x17\x0e\x43\x17\x24\xac\x8e\x45\x0b\x33\xb6\xd0\x89\x3e\xd4\x2d\xc2\xf4\xc3\x47\x6a\x6a\x23\x69\x9c\x50\xab\xdc\xcb\x09\x64\xc6\xb5\x2c\xa1\x8c\xf5\xa2\x96\xe9\x24\xca\xf3\xc0\x9b\x94\x4e\x46\xaa\x42\x80\xa7\x34\x84\xe8\x45\xb5\x31\x31\x12\xd3\x4e\x0d\xcd\xda\x29\xe7\x06\x8e\x62\x62\xe5\x6c\xd6\x99\x1f\x44\xf5\xe6\x69\xe8\x9c\xfa\xdc\x62\x72\x54\x17\x68\x41\x17\xe8\x35\x82\x96\x13\x38\x1d\x81\x13\xe6\xbd\x70\x9a\x46\x31\x2a\x05\x39\xd7\x31\x94\x2a\xad\x70\xce\xbd\x53\x8b\xe7\x34\x6e\xaa\x7d\x9f\xe9\x3e\xfe\xce\x46\x3b\xe5\xa7\x28\xde\x51\x3a\x71\x02\xc0\xd3\x18\x8c\x3a\x42\x8c\x1a\x3d\xc3\x58\xd3\xc0\x50\x3f\x1c\xe6\x22\xd1\x06\xfe\x90\x4e\xac\x99\xe8\xe7\xe4\x5a\xee\xe3\xc6\x4d\x20\x75\x78\x4e\xa4\x41\x7c\xba\xa1\xb2\x56\x28\x80\x7e\x30\x7e\xc2\xf3\x99\xae\x65\xfc\xa4\x15\x39\x4e\xaf\x63\xfc\x74\xed\x7f\xcc\x4f\xc1\x28\x3f\x65\xaa\xfc\x44\x3a\x5c\x3b\xa7\xea\x4b\xa6\x23\x18\x3f\x81\x75\xa2\x93\x33\xac\xd3\xf0\xd7\xa0\x29\xdc\x62\x65\x6e\xe6\x27\xac\xc2\x84\x7f\xa4\x06\x70\x9f\xa3\xb2\x14\x55\x6b\xe4\x7b\x55\xa7\x31\xb8\x51\x3a\x69\xf4\x74\x63\x00\xf0\x13\xc6\x2a\x3f\x1d\x0d\xeb\x1a\x44\xfe\x5a\xac\x8d\xc8\x9f\xcb\x1d\x6d\xc6\x17\x54\xf9\xa9\x71\x13\xf7\x71\xad\x22\xd5\x46\x1a\xf0\x1c\xe8\x05\xff\x78\x63\x71\xed\xf5\x36\x4e\x8f\xba\x42\x3f\x40\x4b\xeb\xf5\x20\xe5\x30\x2a\x3a\xe5\xbf\x62\xa9\x1b\xf4\xd4\x75\x6c\xd5\x6c\xfc\x62\x06\xf0\x74\x54\x5b\x35\xeb\x15\x66\x67\xf4\xa8\x9d\x6c\xd6\xe9\x25\x4e\xd4\x8b\x06\x62\xd4\x47\x0d\x2b\x8c\x7f\xa3\xa6\x65\xfc\x9b\x69\x77\x9d\x75\x65\x4e\x0b\x65\x33\xd0\x23\x54\x6f\x47\xad\x2c\xd3\xbb\xa4\xb9\x0d\x02\xa3\x63\x46\xbd\x64\xab\x49\x10\xac\x08\x9b\xb5\x5a\x83\x06\x6b\x2c\x56\x83\x99\xf5\xc7\xd0\xc0\xd4\xb0\xac\x05\x3d\xac\xe3\xae\x69\x91\xc2\xb8\x3a\xf6\xca\x17\x47\x5b\x8d\x99\x0c\x4c\xdf\x3f\xa8\x06\x49\xe5\xbe\x86\xda\xda\xf7\x99\x26\x63\xec\x17\x79\x48\x6b\x01\x06\x6c\x4c\xd5\x5a\x18\x0b\xb6\xb2\xf7\x7a\xd4\x59\xb6\x6a\x29\x71\x0d\x46\x60\x42\xb0\x81\xff\x35\x1b\xb6\xe6\xc3\xeb\x18\xd1\xdf\xcc\x8a\x31\x5e\xfc\xe5\x2a\x68\xb7\x66\x3d\xd4\x4c\x57\x1b\x78\x17\x7a\x9d\xa8\x33\x22\x83\x5e\x50\x34\x37\xb9\x18\xc1\xd6\x3c\xd9\xca\xcf\xa0\x74\xd5\x01\x4f\x32\x4b\xd6\xec\x6f\xf0\x77\x02\x59\x11\x69\x6e\xa3\x99\xae\xa2\x4e\xa7\xd5\x13\x4e\xcf\x59\xac\x46\x49\xb2\x98\x8c\xac\x4f\xa6\x88\x26\x4a\x57\x4d\x83\xbe\xc5\x66\xfe\x81\x38\xb7\x36\xa0\x74\x92\xc5\xb4\x1f\x8c\x2b\x1d\x53\xca\xaa\xb5\x4c\x05\xaa\x16\x15\x38\x56\x55\x82\x9c\xea\x5b\x80\xce\xa5\x7d\x95\x65\x33\x78\x3f\x46\x03\xd1\xeb\x8d\x1a\x4a\x5b\x8d\xda\xb4\xb6\xa1\xb5\x33\x14\x89\x89\x62\x2b\x27\xc0\x7a\xbd\x4f\x14\xf5\x06\x80\x63\x23\x1f\xf0\xff\x04\xf2\xc2\x50\x92\x4f\x29\x1d\x50\x6b\x7f\x4b\x8f\x0a\x65\xbb\x56\x27\x0a\x3a\x01\x98\x16\x19\x74\x40\xde\x9b\x9c\xae\xa8\xcc\x5b\xaf\xb3\x22\xcd\x06\x17\x5a\x51\x2d\x6e\xd4\xff\x8a\xfa\x60\xa4\xb9\x5f\x02\xdb\x15\xd5\x47\xb6\x21\xac\xd7\x61\x9d\xd5\x62\xd4\x68\xac\x26\x42\x2c\x66\x13\x53\xc1\xe6\x06\x2d\xe1\x09\x3b\x15\xf9\x88\x3e\xca\xb7\x6a\x07\xaf\xeb\x5f\x87\x66\xce\x05\xba\x06\x55\xc9\x71\x82\x95\x69\x60\x74\x55\x99\x97\x13\x1a\xbc\x30\xae\x9f\xd2\xfe\x0a\xef\xd7\xd6\xc6\xfc\xaa\x28\x2f\x51\xfa\x72\x9c\xd1\xa0\x97\xa4\xeb\xe9\x1b\x69\xed\x1c\x36\xfc\x97\xf4\x65\xf2\xc2\xe8\xcb\x1c\xb9\xa8\xc3\x45\x3a\x80\x9c\x44\x9d\xae\x16\xff\x93\xd1\x17\xb8\x17\x66\xe8\x06\x3d\xd0\x57\x22\xd7\xb4\x37\x39\xa1\x7f\x48\xdf\x68\xab\xd0\x0a\x53\xaa\x78\x4e\xb3\x5a\x55\x7d\x52\xd2\xdc\xaf\x66\xfa\x6a\xf4\x02\x30\xaf\xd5\x62\xe6\x79\xab\x41\xab\xb5\xd0\xa7\xea\x40\x54\x63\x44\xd0\x32\x65\x0b\xd6\x0e\xb4\x6d\xb3\xb5\xfb\x53\xfa\x36\xdb\xa4\x22\x1f\xed\x26\xd3\x4c\x91\x86\x28\x13\x2b\xf7\xf2\xff\x64\x4a\x90\xbc\x09\x3c\x0c\x4a\xb8\xb6\xb5\x7f\x6c\x47\xc3\x65\x8f\x51\x6b\xb5\x8a\x9c\xcd\xe6\x74\x98\x75\x3a\x27\x12\x04\x87\x15\x54\x84\x81\x67\x4a\xe2\x68\x58\x2b\x34\x58\x62\x2e\xb3\x91\xf2\x72\xcb\x16\x8e\x16\xcf\xd9\xda\xa2\x32\x6e\x30\x5f\xcd\x6a\xb9\x59\x7b\x34\x2b\xe7\xa8\x16\x89\x6a\x68\xa6\x4a\xae\xc3\xad\x8f\xec\xb2\xe9\x74\x66\xbd\x5d\x62\x6a\xda\xc1\x3b\x8d\x0e\xad\x60\x64\x82\x2e\xeb\xc3\x36\xce\xd4\x08\x7a\xdb\x12\x93\xf0\xd8\xd2\xa0\xe6\xa1\x09\xb6\x96\xf2\x16\x09\x88\x9a\xc0\x98\x06\x7f\x1f\xd8\x91\x8e\x59\x54\x8b\xab\x12\xc1\xc6\x4e\x5d\xcb\x1e\xc3\x87\x8e\x9b\x15\xb9\x51\xb5\xec\x71\x88\xa2\x5b\x12\xac\x56\xce\x22\x59\xe2\xe3\x88\xc9\x14\xef\xd4\x6a\xe3\x04\xa7\xcb\xc9\x28\xc6\xb9\x1a\xcc\xea\x10\xca\xba\xb0\x41\x17\xb1\x8a\x8a\xad\x19\xc9\x56\xc4\xbb\x61\x30\x6f\x44\x97\xb4\x16\x9c\x60\x54\x39\xd1\xa1\x7d\xbf\x95\x00\x45\x87\x99\x0d\xf1\xb5\x63\xaa\x20\x31\x75\xc5\x9e\x01\x20\x6e\x36\x5f\xcf\x74\xa6\xed\x08\x82\x39\x3b\x77\x0d\xa1\xbc\x92\xe8\x6c\x1d\xfb\xac\x3e\xbe\xbe\x21\xc8\xd7\x43\xa9\x62\xb5\x3c\xf4\x15\xae\x5a\xca\x53\xe9\xce\xbb\xa9\x3c\x94\xfa\xb0\xa5\x3c\x83\x6f\x3f\x1a\x85\xaf\xa0\x92\x9b\x1b\xa0\xe6\x29\x5a\x9e\x9b\x18\x2b\x8f\xff\xa8\x3c\x37\x91\x16\x89\x96\xe7\x26\x34\xc3\xb7\x1e\xc1\x48\x68\x29\x5e\x10\x83\xde\x52\x1a\xd1\x98\x78\x91\x06\x7e\x62\x74\xee\x44\xa5\xcc\xce\x56\x99\x79\x91\x9f\xbd\x45\xce\x63\xef\x91\x3b\xa1\x12\xd4\x03\xf5\x42\xfd\xd0\x20\x34\x14\x8d\x40\xa3\x50\x25\xaa\x41\x13\xd1\x14\x34\x1d\xcd\x46\xf3\xd1\x22\xb4\x14\xad\x40\x6b\xd0\x3d\xe8\x3e\xfc\xa6\x3c\xd9\x94\x51\x36\xfc\x0e\x61\xda\x34\x73\xa0\xd7\x88\x45\xc2\x74\x31\xb9\x78\xe0\xdd\xc2\x84\x09\x92\x37\x34\xe8\x1e\x61\xa2\x2d\xbb\xeb\xad\x77\x0a\xb3\x66\xd9\x73\x4a\x46\x2d\x15\x66\xeb\x52\x3b\xf6\xdd\x20\x54\x57\xeb\xfd\x9d\xfa\xdd\x27\xd4\xd4\xcc\x9e\x38\x9d\x9f\x32\x9f\xf3\x14\x0c\x59\x2d\x4c\x9e\x4c\x12\x82\x43\xd7\x08\x53\xa6\xdc\xef\xce\xeb\x51\xb9\x42\x98\xef\xca\xed\x3e\x66\xb9\x30\x7f\xde\xbc\xda\x89\x35\x53\x26\x4d\xa9\xc3\x3c\xa8\xb6\x71\x55\x93\x2a\x47\x8d\x18\x36\x42\xbd\x1a\x3d\x72\xd8\xa0\x7e\x43\xcb\x87\xaa\x57\xfd\x7b\x97\xf7\x28\xe9\x55\xda\x4b\xbd\x92\x3b\x97\x76\x0a\x05\xf3\x83\xea\x55\xfb\xc2\xfc\xbc\x9c\x40\x5a\x40\xbd\x6a\x93\x99\xe6\xf7\x26\xc4\x25\xa8\x57\x29\x89\x71\x6e\xbb\x99\x3a\x1e\xf4\xca\x61\x01\x7d\x4a\xe8\xdc\x89\x5e\x81\xfd\x58\xb1\x74\xd1\x82\x45\xf4\xca\x1b\x5e\xb6\x78\xc1\xa4\x61\xe5\xa5\xf9\x69\x71\x06\xb4\x60\x01\x32\xc4\xa5\xe5\x97\x96\x0f\x9b\xa4\x5b\x39\x67\xc6\xed\xd3\x6f\x57\x6b\xcc\x9f\x3d\xfd\xbe\x7b\xd6\xac\x5c\x03\x57\x87\xc2\xf7\xae\x5d\x79\x0d\xc5\x44\x2f\x2e\x2f\x7a\x62\x53\xd7\x8f\x44\xff\xac\x37\x2c\xda\xfb\xbf\xfe\xa6\xec\xe2\x8e\xee\xa7\x74\x07\xd9\x09\xb4\x18\x3b\xfd\xa3\xaf\x76\xf9\x74\xb7\x65\x7a\xf4\x10\xfe\x87\xe7\xd2\x9f\xdc\x77\xff\x49\x99\xd6\xf7\xf1\x9f\x9c\x4f\x9c\x88\x1f\x56\x8f\xc8\x43\x13\x26\xe0\x87\xd5\xa3\xa1\xe9\xbf\xbf\x5f\xaf\xde\x6a\x3c\x3b\x61\x02\x37\x71\xe2\x44\x65\x82\x7a\xd4\xb7\x94\xae\xff\xc3\xbb\xb4\xc2\x1f\xc1\x13\x32\xab\xe9\xdf\xd8\xaa\x96\xbf\x9a\x9b\xcf\xc7\xd2\xbf\xea\x31\xf4\xaf\x9a\x9d\xab\xb7\xa5\xef\x59\x65\xec\x67\x57\x88\xe6\x2c\x04\x19\x3c\xf7\xff\x4e\x06\xd1\x26\xb4\x05\xfd\x05\x3d\x86\x9e\x44\xbb\xd0\x33\x68\x1f\x3a\x88\x8e\xa2\xe3\xe8\xaf\xe8\x35\x74\x1a\x9d\x41\xe7\xd1\xbb\xe8\x7d\xf4\x11\xba\x88\x2e\xa3\xaf\xd0\xb7\xe8\x47\xf4\x6f\xf4\x2b\x6a\x40\x4d\x98\xc0\x54\x58\x8f\xcd\xd8\x8e\xdd\x38\x01\x7b\x89\xfe\x20\x57\x50\xbd\xb3\x0e\xeb\x8e\x08\xff\xf8\x07\x09\xd6\xec\xaa\xc3\x7a\xd9\x29\xbc\x9f\x3c\x70\xc3\x73\xbf\x08\x9f\x7e\xea\x1d\x74\xdf\xbe\x5f\x85\x8b\x62\xf1\x84\x27\xea\xb0\xe9\x88\xf0\xce\x3b\x52\x68\xe2\x93\x75\xd8\x0c\x85\xde\x4d\x1d\x72\xe7\x81\x6b\xc2\x67\x9f\xf9\x87\x2e\x3d\xd8\x20\x5c\xd6\x75\x9c\xbc\xad\x0e\xdb\x8e\x08\xe7\xce\xe9\x3b\x4d\x79\xac\x0e\xdb\xa1\xd0\xf9\x8c\xe1\xcb\x8f\x28\xc2\x97\x5f\x06\x46\xac\x38\xda\x24\x7c\x65\xea\x3a\xed\xe1\x3a\xec\x3a\x22\xbc\xf9\xa6\xb9\x64\xfa\x5f\xea\xb0\xfb\xb0\x70\x26\xfb\xd6\xd5\xc7\xea\x30\x77\x44\xb8\x72\x25\x67\xd4\x9a\xe3\x75\x98\x1c\x16\xbe\xb5\x75\x9f\xf5\x60\x1d\xf6\x1c\x11\x4e\x9d\xb2\xf7\x98\xbd\xa5\x0e\x27\x1c\x16\x4e\xe7\x8e\xb9\xfb\x44\x1d\x16\x8f\x08\x3f\xfc\x90\x57\x79\xcf\x5f\xeb\xb0\x24\x7b\x85\x1f\x7f\x3c\xfd\xed\x99\xaf\xce\x5f\x7e\xf7\xe2\xfb\xba\x8f\x5e\xf3\xf4\xbd\x63\xcf\x4f\xc2\x87\x1f\x26\xf4\x5b\xf4\xcc\xbf\x85\x8f\x3e\xaa\xc3\x29\x07\xdd\xbd\xe6\x6f\xaa\xc3\xde\xc3\xc2\x6b\xae\xb2\x79\x1b\xeb\x70\xf2\x41\xe1\xb5\x57\x5f\xad\xc3\x3e\x59\xfb\xda\xe9\x33\xe7\xdf\x15\xde\x7f\xef\x7d\x2a\xc7\xd6\xf0\xcb\x27\xdf\x38\xfb\x96\xf0\xde\xbe\x83\x47\x8f\xff\x55\x78\x66\xf7\x33\xea\xdd\x67\x9f\x3f\x54\xf7\xa2\xb0\x7b\xd3\x96\xbf\x3c\xf6\xa4\xb0\x6b\xc7\x2e\xf5\xee\xfd\x9b\xb7\x3e\xb2\x5d\xd8\xb1\x74\xc5\x9a\x7b\xee\x13\xa2\xda\xc2\x1a\x5e\xbc\x6c\xe5\xda\x7b\x85\x05\x13\xa7\x4c\x9f\x3d\x5f\xa8\xa9\xaa\x51\xef\x8e\x9b\x74\xfb\x8c\x39\x42\xd5\xa0\xa1\x23\x46\x55\x0a\xfd\x7a\xf7\x53\xef\xf6\x2f\x1f\x36\x72\xb4\xd0\x3b\xd4\xa9\xa4\x47\x2f\x21\xaa\xb5\xac\xe1\xc2\xf6\x9d\xe5\x52\x21\xdf\xeb\x0f\xe4\xe4\x09\x51\x7d\x65\x0d\x27\xa6\xa4\x65\xb6\x11\xe2\x24\xbd\xd9\xee\x16\xa2\x9a\x4a\x1f\xe6\x35\x06\x8b\x43\x40\xbf\x36\x34\xbd\x40\x07\xf7\xa0\xf0\xef\xab\xff\x66\x0f\xee\x7f\xfe\xad\xf1\x05\x8c\xa0\x8c\x5b\xb8\xfa\xde\xee\x1d\x0b\xaa\x7a\xe7\xc7\xa1\xab\x57\x51\x5c\x7e\xef\xaa\x05\x3b\x76\xbf\xa7\xab\xc3\x1a\x59\xfb\xf1\xa5\xcf\xbf\xfe\x4e\xf8\xe0\xa3\x0f\xa0\xce\xd1\xf0\xc5\xcb\x5f\x7d\xfb\xa3\xf0\x51\x37\x7b\x0b\x87\x80\x01\xd3\x63\x0d\x1c\x3c\x0a\x63\x03\xb6\x60\x07\x8e\xc3\x89\x70\x97\x4d\x08\xdd\x54\xf7\xb8\x41\xc5\x45\x4f\x6e\x50\x71\xd1\xbb\xff\xcf\xbe\xff\xe7\x2a\xee\xff\xfc\x8b\xbe\x7c\x74\xfa\x43\x7f\x70\x08\xff\x3f\xdc\x4f\xbf\xe1\x5e\x4c\xa9\x06\xfe\xe0\x90\xfe\x04\x8e\xfb\x7f\x58\x1e\xff\x0f\xef\x53\xc5\x79\xfd\xff\x06\x50\xc6\xf5\xd7\xff\x6f\x1c\xff\x7f\x51\x8a\xa9\xe9\xe6\x32\xa0\x99\xc9\xc3\x37\x95\x9b\x70\x13\xb0\x9b\xf1\xba\xb9\x4c\x43\xd3\xff\x09\x0e\x51\xa5\x5f\x7d\x93\xea\xaf\xfa\x13\x33\xf0\xa7\xf7\xc7\xb6\xfc\xa9\xe6\x61\x4c\x2b\x23\x31\xb6\x95\xa9\xb8\xce\x60\x54\xb7\x36\x1b\xea\x1f\xcd\x5d\x09\xfe\x1e\xb5\x1d\x3d\x51\x1f\x34\x00\x0d\x46\xb7\xa0\x30\xaa\x40\x63\xd1\x78\x74\x1b\x9a\x8a\x66\xa2\xb9\x68\x21\x5a\x82\xee\x42\xab\xd0\x3a\xb4\x1e\xd5\xa2\x07\xd0\x43\xe8\x51\xf4\x38\x7a\x0a\x3d\x8d\xf6\xa2\xfd\xe8\x30\x7a\x01\xbd\x84\x5e\x41\xaf\xa3\xbf\xa1\x7a\xf4\x36\xfa\x3b\xba\x80\x3e\x41\xff\x44\x5f\xa0\x6f\xd0\xf7\xe8\x5f\xe8\x3f\xe8\x77\x14\xc1\x18\x0b\x58\x8b\x8d\xd8\x8a\x9d\x38\x1e\x27\x61\x1f\xb1\xca\x53\x3c\xe3\x16\x3c\xf5\xb9\xf0\xfa\xeb\x51\xa5\xd3\x6f\x4a\xed\x33\x57\x85\x33\x67\x7a\x4f\x5a\xbb\xfb\x3f\xc2\x1b\xc9\x55\x8b\x1e\xbf\x24\xbc\xf2\x4a\xc2\xf8\x85\x4f\x7c\x21\xbc\x3a\x68\xfa\x3d\xfb\xbe\x13\xce\x9f\xef\x7f\xfb\x86\x67\xff\x25\x9c\x4d\x1d\xbd\xf4\xd1\x8f\x85\x97\x5e\xf2\x8e\x5d\xbc\xed\x9f\xc2\x89\xa1\xb3\x37\x1d\xfc\x5a\x78\xf7\xdd\xf2\x19\xf7\x3e\xff\xbd\xf0\x56\xc6\xc8\x15\x0f\x7d\x20\xbc\xf0\x82\xbf\x62\xd9\xc3\x9f\x08\xc7\x7e\x6d\x7a\x09\x2c\x93\x19\xa7\x80\x66\x71\x63\xb7\xac\x1d\x36\x67\xf3\xa1\x6f\x84\xf7\xb2\x1b\x5f\x02\xb5\x66\x64\x1a\xc7\x89\x9d\xb2\x25\x10\x5e\xf9\xe0\x05\xe1\x48\x3e\xd5\x91\x42\x69\xe9\x6f\x27\x40\xc7\x69\x40\x2d\xf9\xa0\x40\x1c\x8e\x93\xf5\x47\xde\x3b\xf6\xd6\x89\xb3\xaf\xbe\x41\x74\x18\x8c\x91\x6c\xe9\x35\x71\xcd\xae\x9f\x85\xd3\xa7\x05\xad\xd1\xea\x84\x69\x6b\x1d\x4e\x95\xf5\xb9\x05\xc5\x1d\xbb\x76\x17\x11\xca\x89\x9c\xc0\x3c\xd6\xe1\x24\xa8\x6e\x83\x7f\x7e\xd9\x10\xd5\xb3\xae\x1e\x6f\x9e\x7b\x07\x2c\xd5\x41\xe1\x14\x77\x8a\x79\x75\x2f\xbc\xf4\xca\xeb\x75\xd8\x79\x58\xe0\xea\x5e\x7c\xf9\x64\x1d\x76\x1c\x14\x84\x5d\x02\xfb\x49\x7e\x66\xdf\x41\x30\x8a\x87\x85\x5d\x25\x7b\x9e\x3b\x00\x96\xf2\xa0\xb0\x53\xdc\xc9\x7e\x7a\xe8\xd1\xc7\x9f\xaa\xc3\xc6\xc3\x82\x08\xc6\x62\x47\x1d\x36\x1c\x14\xb4\x6b\xb4\xec\xa7\xce\xf7\xd4\x82\x55\x92\x0e\x0b\x6b\x3a\xdd\x7d\x3f\x58\x25\xf1\xa0\xb0\x5a\xb7\x9a\xfd\xb4\x60\xd1\xd2\x15\xcc\x0c\xea\xe6\xdf\x71\xe7\x72\xb0\x8d\x07\x05\xe3\x44\xa3\x6a\x08\xda\x83\x65\x69\x12\x26\x86\x26\x4f\x9b\xa5\x08\x13\x4c\x13\xd4\xbb\x23\x47\x57\x8d\x6b\x14\x4c\x60\x5e\x6a\x1a\x04\x6b\x2f\x6b\xd4\x94\xf4\x1b\x34\xf4\x57\xa1\x57\xb0\xef\xc0\x21\xbf\x08\x65\xb6\x32\x06\xfc\x03\xd0\xfa\x75\x38\xf1\xb0\x60\x7b\xff\xa3\x8b\x97\xc1\xb0\x1e\x14\x9c\x3f\x3b\xd9\x4f\xf9\x5f\x7f\x77\x15\x0c\xa6\x9c\x28\xfc\xcc\xed\x12\xd7\xe8\x26\x9a\x7a\xd9\x7e\xfe\xd9\xd6\xcb\x34\x51\xb7\x46\xdc\xc5\xe9\x5c\xa5\x60\x2d\xc1\x68\x1f\x14\x4e\xe3\xd3\x50\xe3\x48\x18\x2b\x79\x60\x34\xc0\xb8\x82\xe9\x71\xfd\x9b\x99\x11\x4f\x72\x6a\x46\xb6\xe0\x42\x31\xab\xc0\xd6\x39\xfd\x6f\x1b\x87\x38\xcb\x29\x77\x81\x1a\x50\xe4\x7f\xcd\x42\xc0\xec\x2a\x58\xe4\xff\x83\x23\xe8\xfc\xa3\xc3\xef\x0c\x5a\xff\xe0\xc0\x37\x14\x74\xc3\xbd\x40\xab\x43\xba\xe1\x77\x01\xee\x85\x5a\x5f\xc3\xe1\x83\x43\x2a\xf2\x3b\xd3\xe1\xdb\x0e\xdf\xfe\x56\xc7\x8d\xf5\xff\xdb\xdf\x6f\x68\x1f\xdf\x78\x1d\xc5\x91\xd6\x4b\xc2\xd0\x6e\x14\xe6\x75\xdf\xf0\x3b\x81\x83\x3f\xd7\x50\x30\xa1\xe5\x6f\x62\xcb\xbf\xd6\x7f\x0d\x5b\x63\xb7\x5b\xab\xe4\xe8\xbd\x48\x53\xac\x5e\xe3\xd9\x89\x38\x08\x7a\x19\xfc\xf1\x66\x50\xcd\x15\x6f\xbc\x6e\x01\xc4\xe1\x56\x2a\x9d\xab\x67\xbf\x4d\xa4\xff\x69\x69\x76\xd0\xcf\xc8\x43\x38\x75\x2c\xfd\xef\xaf\xc2\xbe\x6a\xf6\xbf\x95\xda\x7d\xa5\x5a\xb9\x58\xa5\x7c\xa2\xfe\x1f\x03\x9f\xe2\xe4\xd8\x4f\x2f\xdf\x68\x1f\x5e\x8e\x9d\xbc\xd6\x52\x5f\xb9\x78\x93\xfa\x6f\xb9\xd5\x5c\x4a\xac\x8f\xa9\xfc\xd4\xe8\x09\xb4\x0a\x0d\x8c\x65\x40\x5f\x53\xc1\x54\xab\x55\xd5\xe2\x50\x90\x3d\x63\x98\x8f\xe6\xf2\xc3\xf9\x61\x6a\x1c\x4d\x01\x5d\x1f\x47\xd3\x67\xf5\xcd\x27\x17\x1b\x7d\xfc\xb0\x46\x1f\xe2\xe8\x0e\x01\xfe\x0c\xff\x37\x36\xf7\xf0\xec\x27\x74\x3d\xc7\xc1\x30\x41\xfc\x75\xeb\x3a\xd4\x6a\x76\xab\xcf\xca\xf1\x7f\x6b\x08\xf5\xe7\xdb\xd1\x2f\x7e\x49\xc3\x79\xbe\x1d\xc2\x78\x12\x5e\x4a\xc6\x91\x45\x00\x43\xb3\x1f\x00\xb2\xd8\x76\x34\xd6\xd1\x38\x85\xc7\x8d\x78\x29\x6e\x44\x5c\xab\x32\x12\x4a\xde\x8f\x24\x80\x7f\x38\x8c\x38\x99\x13\x59\x4b\x5c\xab\xa0\x8e\x38\x1a\x27\x49\xad\xdf\x5f\x79\x84\x82\x50\xca\x71\xb5\xb2\x0d\x45\xd7\xaf\x96\xf1\xaf\x73\xa9\x7f\xda\x3f\x0d\xff\x52\x43\x0f\x2e\x55\xa1\x7b\x08\xcc\xa8\x80\x7f\x89\x7f\x0e\xd0\x72\x1e\xa5\x31\x45\x11\x0b\x73\xa5\x96\xb6\x76\x68\x97\x1f\xd2\x62\x33\x37\x92\x1b\x5e\xc0\x2f\x6e\x58\x49\xd7\x9f\x35\x7d\x01\xf4\x78\x16\xca\x03\x6c\x9e\x06\xc5\x6b\x05\x5b\x8b\x0b\xf9\x2d\x0d\xb7\xf1\xcf\x46\xb6\x45\xfe\xa2\xe2\x62\x86\xf2\x2f\xf1\x63\xa3\xf0\x01\x97\x1b\xe0\x6b\x39\xfe\xa5\xc8\x9e\xc8\x6e\x7e\x6c\xc3\x4a\x7e\xb1\x5a\x87\x83\x3a\x0f\x45\xdb\xb8\xbe\x06\x7d\xaf\x88\xf9\x87\x68\x13\x0d\x1d\xb8\xf1\x50\x62\x1a\x8c\x4f\xa5\xb0\x93\xc5\xd2\xcd\x97\xcd\x5a\x81\x93\x24\xdc\x4f\x1c\x25\x4e\x11\x89\x08\x6e\xbe\x53\xd6\x95\x6a\x86\x69\xc6\x69\x88\x06\xd3\x0d\x11\x15\xf0\xdf\xd6\xa1\x4b\x1e\x7b\x13\xe1\xf3\x6b\x71\x50\xcb\x73\x0f\x4d\x52\xba\xe0\xd7\x26\xe1\x53\x8a\xa4\x5c\xa4\xfb\xa5\xb9\xb7\xb9\xbf\x47\xda\xe2\x7f\x2a\x5e\xc5\x86\x7f\xa0\xeb\x7c\x9e\x44\x4f\xf0\xd9\x7c\x16\xd0\xcb\x0b\xed\xe8\xe2\x34\x1a\x0b\x42\x29\x3e\x83\x83\x0d\x94\xc1\xc0\xf3\x89\x6c\xa0\xe8\x8e\x97\x68\xc0\x44\xb6\x20\x45\x25\x4c\x6c\x99\x9d\x83\xae\x51\xcd\xc5\x21\x07\x5d\x41\x46\xf7\x5b\xa8\xeb\x52\x9f\x5c\xf0\xf6\xc2\x3b\xde\x59\xb8\xf0\xed\x45\x77\xbc\xb5\x60\x78\xf5\xae\x9a\xea\xa7\xc7\x55\x3f\x53\x3d\xf6\xe9\x6a\x6e\x1c\xbd\xff\x2e\xfc\xb4\x60\xc1\x5b\x77\x54\x3f\x3d\xb6\x6a\x4f\x35\xfc\x52\x4d\x93\xbf\xa0\x49\x68\x38\x3f\x9e\x1f\x02\x1c\x63\xa6\x6b\x95\x61\x36\x9c\x07\x33\xe1\x12\x98\x05\x0f\x82\x19\x70\x25\xcc\x7e\xa7\x03\xaf\x2f\x45\x7b\xf7\x4f\xa8\x66\x06\xaa\xef\xac\x79\xb3\x98\xdd\x19\x38\xaf\xfb\x1d\x77\xde\xc1\x4e\xcb\xee\x2c\x98\x3c\x6d\x32\x3b\x2d\x9e\xe6\xb9\x75\xcc\xad\xec\x34\x79\x8c\x6d\xc8\xf0\x21\xec\xd4\x35\x9c\xeb\xd8\xb5\x23\x3b\x15\xbb\xea\xb2\x73\xb3\xa9\x71\x74\x85\x4d\xb9\xf3\xee\x9c\x36\x66\x78\xd7\xdc\xdc\xae\xc3\xc7\x4c\xbb\x73\x9e\x94\x31\x21\x23\x95\xad\x47\xcc\xb0\xa8\xa1\x92\xd4\xbd\x12\xea\xe3\x9a\xe8\x8e\x98\xff\xf6\x93\x2d\xe5\xa5\xf1\xf4\x82\x05\x81\xe8\xb7\x3d\xfa\xed\x8e\x7e\xc7\x7e\x97\x6e\xb8\xbe\xf1\xfb\xc6\xdf\x6f\xbc\x4e\xbf\x01\x7e\xac\x3d\xf2\x69\x61\xfb\xf6\x85\x9b\xe9\xc7\xaf\xa1\xa2\x50\x51\x1a\x3d\x53\x42\xc5\xf0\xb7\x37\x54\x54\x14\xe2\x86\xd0\xcf\x88\x87\xde\xe0\x56\x34\x97\x8d\x3c\x57\xd8\xbe\xb8\x98\x15\xc6\x6f\xd0\xdf\x94\xd1\xf4\xf3\x57\x5a\x78\x33\x3d\x23\x0f\xc2\x47\x1b\xb8\x52\xde\x0d\x85\x8a\x2e\xc3\x05\xde\x04\x27\xb7\x52\x60\xf3\xe1\x03\xbf\x50\x1c\xec\x10\x29\x85\xb3\x87\x0a\x0b\xdb\x73\x89\xd1\x42\x0a\x81\x93\xcf\x69\xb5\xbf\xb7\x2f\x6c\x9f\x0d\x27\x4c\x46\x9e\x43\xeb\x78\x2f\xb9\xc6\xe2\x65\x4a\x48\xd5\x29\x8c\xc3\x90\x3f\x15\xd1\x4d\x34\xdc\x84\x69\x17\x66\x29\xca\xd1\x23\x8a\x32\xfd\x7d\x72\x6d\xce\x87\x93\x8f\x2a\x0a\x26\x47\x6e\xff\xfb\x7c\xca\xcf\xe9\x20\x37\xbb\xf9\x15\x6c\x35\x6c\xb2\x6c\xa0\x71\x4c\x39\x27\x76\x58\x60\x6a\x0a\xc0\xf2\xea\x9b\xdf\x6b\xd1\xf5\x6a\x3e\x2b\xbe\x81\x63\xd3\xf9\x15\x8d\xfc\xbc\x33\xf3\xe7\xd5\xcf\x9b\x77\x16\x3e\xe7\xf2\x2b\x1a\x96\x70\xdd\xe6\x9d\x9d\x07\xe7\x70\x73\x3e\x8d\x86\xd7\xba\x0d\x3f\x8b\x96\xe6\x30\x24\x3a\x12\xa1\xa5\x74\x9c\xa6\x49\xc1\x96\x38\x68\xeb\x93\x73\xf0\xff\x86\x97\xbd\xac\xc5\x1b\x64\x26\xf0\x07\x18\x0c\xae\xde\x33\x76\x2c\x08\x04\xfb\x1c\x70\x33\x3a\xcd\xbf\xc1\x67\x6b\xd4\x40\xdf\x4e\xc3\xab\xc8\x18\x32\x97\xed\xcb\x4c\xde\x4f\xdc\x4c\x8c\x89\x4e\xd6\x59\x99\x18\xeb\x5a\xeb\x5b\xb6\x4e\x4e\x0d\xfe\xe2\x76\x49\x85\x2d\x5b\xf4\xc9\x98\x2d\x63\x4b\x67\x94\x6e\x1a\x3f\xb1\x57\xdf\xfe\x13\xca\xca\x26\x54\xf7\x1d\x50\xc9\x2d\x99\xb2\xbe\xdb\xac\x9e\x13\x6b\xfb\xf6\x9a\x58\x36\x61\x42\x59\xaf\xf1\xb7\x81\x76\x4a\x40\x1c\xbf\x9f\xdf\xca\xf4\x47\x0e\x48\x69\x4f\xb4\x58\x76\x64\xa4\xb4\x29\x28\x29\x48\xe9\xc9\x23\xd0\x27\xbd\x40\xa1\x94\x75\x6d\x5f\xd7\x74\xe9\xa8\xd6\xd8\xbb\x7d\xfb\x4e\x9d\xba\x31\xa1\x2d\xca\xf2\x67\xd1\x07\xff\x96\x70\x9e\xbf\x93\x6c\xb0\xf4\xee\xe4\xef\xe4\x87\x01\x73\xb0\x1d\x13\x4c\xed\xc0\x97\x01\xe5\x9d\xcd\x69\x15\xe0\x26\xd8\x2a\x74\x6b\xcb\x6b\x01\xea\xce\x45\x35\x92\xba\xf7\xce\x19\xdd\x8b\x77\xa3\x46\x0a\x45\x23\xdd\xd0\x05\xcf\xe9\xad\xce\x71\x74\x53\x16\xa3\x48\x20\xe1\x51\x6c\xd9\xb6\x0d\x9b\xb7\x3d\xaa\x5c\xdd\xb6\x4d\xb9\xfa\x68\xc9\xbd\xff\x5e\x7f\xef\xbf\xef\xbd\xf7\x27\xf8\x5c\xff\x5d\x56\x52\x52\x76\x76\x52\x52\x16\x3e\x18\x3b\x53\x26\x75\x5c\x32\xb0\x7c\x71\x87\x8e\x33\xce\xf7\x9a\x3d\x22\x97\x1b\xb0\x0d\x5b\x1e\x8d\x55\xa6\xc0\xa0\xda\xfa\x9f\xef\xa1\xf5\x7f\x36\xaa\x55\x62\x55\xb3\x94\x9f\x06\x76\xec\x34\xa0\xdd\xfe\xcc\xd2\x9e\x88\x6f\x45\xcf\x04\xd0\x7b\x45\xa8\x5a\xb6\x27\xa6\xba\x2c\x99\x96\xd4\x5c\x5e\x83\x34\x21\x54\xec\xb5\xc7\xdb\xd5\x77\x7b\xe9\xf1\x79\x45\x45\x05\x05\x6d\xa8\xe2\x72\x86\xcd\xf1\xd8\x0c\x54\x1f\x54\x30\xbd\x60\x69\x81\x10\x5f\x10\x5f\x40\x89\x77\x92\xee\xce\xaf\x50\x03\x59\xe5\xc5\x54\x92\xca\x95\x7f\x46\x33\xec\x50\x83\x15\x50\x7e\x10\x5a\x9d\x63\xba\x06\x32\x14\x60\xdb\x11\x6e\x26\x11\xce\xf9\x03\xb2\xe4\xb6\x1d\x31\xab\xcf\xf9\x19\x1d\x81\x3a\x83\x96\x74\xb8\x89\x2c\xb8\xb8\x15\x1d\xe8\xb7\xb2\xa6\xb4\x34\x6b\x7f\x3b\x4a\x10\x90\x65\x4f\xd3\x6a\xfe\x00\x9f\x0c\x74\x08\xa2\x4a\xd9\x9e\x99\xe6\xf3\x91\x5c\xa3\xc5\xe2\x16\x45\x0f\x21\x85\x45\xee\x1c\xe0\x11\x98\x59\xb8\xdd\x16\x5f\x9a\x8f\xf1\x8b\xd8\x4e\xdd\xe4\x41\x66\x88\x58\x14\x8d\xde\x34\x9c\xc6\x16\x10\xc3\x91\x13\x7b\xf0\xde\x62\xc1\x82\xb1\x57\x49\x40\x04\x77\x71\x08\x1c\x5f\x17\x0d\x03\xee\xa2\x0f\x4d\x44\x1a\x0d\x5c\x94\xc0\x39\xce\x08\x48\x81\x50\x46\xc0\x5f\x14\x2c\x0e\x05\xec\xad\x08\x72\x69\xc7\x88\x89\xbd\x27\x8c\x78\x2a\xf8\x54\x99\xf6\x9b\x6f\x74\x3d\xe1\x64\xc4\x84\xde\x13\x47\xec\x08\xee\xe8\xa9\xfb\xfa\x6b\x6d\xd9\x8e\x47\x9e\x5a\xb0\xe0\xa9\x5d\xf3\xe6\xed\x22\xf7\x3c\xd5\x53\xf7\xcd\x37\xda\xb2\x56\x65\xca\xb4\x5f\x7f\xad\xeb\x09\x27\x2a\x14\xe5\x8e\x79\xbb\x68\xd1\x5d\x6c\xfd\x45\x67\x54\x46\xee\xe7\x37\x23\x17\x4a\x05\x1e\x70\xb9\x5d\x82\xd9\x6e\xc7\x8e\x24\xab\x5e\x2f\x38\x88\x3f\xcd\x61\x73\x21\x17\x7d\x3c\x1a\x36\x43\x71\xce\x43\xbb\xad\x0f\x9b\xa0\xa6\x81\x70\x1a\x4d\x0a\x93\x76\x0d\xf3\xe3\x2c\x27\x63\xbb\xe0\xe3\xf2\xa2\xaf\x05\x6c\xd8\xdd\xe1\xba\xee\x83\x07\xdf\x12\x06\x0a\x7a\x4d\xe7\x29\x30\x2d\x68\xdd\x5b\x3c\xf2\xca\xac\xcd\xfb\x16\x2d\xda\xb7\x79\xd6\x95\x2b\xbd\xaf\xb4\x59\x39\xa6\x72\xc5\xca\x31\xa3\xd6\xe0\x05\x6f\x9a\xf6\xcc\x58\xb4\x6f\xdf\xa2\xe9\x7b\xcc\x6f\xf6\xbe\x72\x85\xeb\x38\x66\xe5\xea\xd1\x15\xab\x96\x53\x7d\xbc\x03\xcd\xe2\x79\xf2\x0e\x72\x22\x1f\xba\x5d\x8e\x73\x21\xa3\xa8\xd1\x18\xf4\x7a\x93\x80\x12\x2d\xc8\x92\xea\x17\x4c\xc4\x6e\x8f\xa7\xe8\xc7\x87\xf3\xed\xd8\x4e\x44\xa3\x5e\x92\xe9\x7a\xe3\x3c\x0d\xd1\x12\x8d\x86\x10\x2f\xeb\x0c\x89\x79\x20\xd0\x1b\x4f\xfd\xd9\x0e\x1d\x2c\x27\xa3\xbb\x9f\xa3\x6b\x40\x68\x84\x18\x6b\x50\x7d\xa1\x49\xb9\x9a\xaa\x35\x9c\x87\x7d\x6e\x6b\x1e\xc6\x51\x39\x0f\xb5\xea\xd0\x8e\x7d\x8b\x26\x0c\xc6\xf8\x33\x0e\xf7\x73\x87\x1c\x4a\x93\x4c\x3b\xd7\xbb\xb9\x5b\x8f\x2c\xda\x27\x63\xec\x08\xb9\x95\xc3\xdc\x67\x4a\xd3\xe0\x09\xb4\x8b\xcd\x3d\xa3\xb6\x6a\x02\xd8\x81\x09\xfc\x33\xd0\xb3\x7c\xd9\x63\x70\x8a\x16\xa7\x35\x41\x48\xf5\x6b\xe3\x0c\x4e\xa7\x37\x2e\x2f\xae\x24\x8e\xc4\xc5\x59\xa8\x93\xd7\x21\xaf\xa2\x83\xfa\xfa\x92\x11\x5e\x0d\xe1\x47\x6d\x00\xdb\x78\x01\x38\x39\x7d\x45\x80\x56\x74\xa7\x4f\x71\x08\x14\x16\xb7\x6c\xc3\xd4\xe5\xb7\xad\xad\xe9\xbc\x32\x7d\x5f\x6d\x24\xa5\x76\x5f\xc6\xca\x4e\xe3\xd6\xd4\xac\x9d\xba\x81\x7f\x66\xf8\xdf\x87\x4f\xd8\x32\xe8\xf6\xe5\x1d\x72\x56\x6d\x69\xdf\x7e\xcb\xaa\x9c\x0e\xcb\x6f\x1f\xb0\x71\xea\x2d\xef\xdf\xc2\xf0\x1a\x0b\x78\x4d\x01\xbc\xb2\x29\x5e\x56\x8f\xde\xe9\x71\xa5\x08\x39\x6d\x4c\x49\x56\x8f\xc7\x9b\x94\x97\x54\x92\x44\x92\x92\x9c\x7f\x8c\x17\xb3\x4c\xa2\x14\x8a\x29\xc6\x9b\x91\x0b\xba\x29\xa7\x50\x43\x7c\xcb\xe2\xd2\x1e\xc1\xd0\x9a\xdd\x6b\x6b\xba\xac\x8d\x22\x99\xb6\xa6\x64\xdc\x9a\xdd\x6b\x42\xc1\x1e\xa5\x8b\xf9\x67\xba\x4c\x95\x7b\xac\x4a\x23\xeb\x66\xde\xbe\xbc\x53\x96\x8a\x6a\x56\xa7\xe5\xb7\xcf\x5a\x4b\xd2\x56\xf5\x90\xa7\x76\xa1\x34\x6c\x6a\x02\x1a\x4e\x42\x1e\xba\xbf\xcd\x61\x34\x08\x7c\x42\xa2\x96\xf9\xc5\x14\xa5\x76\xf9\x42\x61\x46\x20\xb6\x79\xd6\x1d\x8c\x99\x4e\x62\xe2\x9c\x5c\xff\xf9\x2b\xbf\xed\x31\x4b\x0e\xd7\x26\x8b\xc9\x1b\x47\xca\xb3\x7a\x7c\x7b\x7b\xb8\x18\x97\xbe\xbd\x0d\x27\x3d\x5e\x36\x4b\x5e\x51\x33\x6e\xb9\x3c\xbb\xe7\xe3\xca\xe5\x55\xab\xe7\xb7\xa3\x74\x59\x09\x6d\xf5\x86\x39\x81\x9e\xfa\xdf\xa2\xc1\xa8\xe3\xd5\x76\x58\xf0\xfc\x22\x9b\x3d\x68\xb3\x3b\x39\xe2\xe7\x56\xfe\x7e\xd9\x70\xf9\x77\xfa\xc1\xdd\x42\x70\x22\x0d\xd9\xaa\x7c\x4e\x94\xcf\x95\x53\xb8\x23\x5d\x77\xe7\x41\x71\xe4\x69\x7e\x02\x4a\x44\x69\xb2\xd9\x26\x49\x46\x12\x6f\x8c\x4f\x4a\x16\xed\x34\x21\x52\x5e\xb0\x3e\xaf\x65\xdd\x29\xa3\x29\xdb\x80\x1c\xb0\x3a\x5a\xe2\xe6\x58\x83\xd1\xe1\x97\x88\xc3\x9f\x35\xed\xd6\xb5\xc3\x7b\x8e\x5a\x37\xb4\x63\x76\x86\x61\xe1\x88\x01\xa1\x7c\x6c\xc9\x98\xdd\x6d\xd2\x53\xc9\x91\x3d\xa5\x35\xa5\xed\xbb\x8d\x73\x93\xd2\x39\x8b\xc2\x4f\x4d\xe8\xbd\x36\x48\x65\x6a\x46\xd3\x3b\x7c\x67\xf0\x3f\xe8\xbb\xa2\x3b\xe5\x7e\x89\x2e\xbd\xde\x9a\xa4\xd1\xc4\x5b\xe3\x53\x7c\xeb\x74\x58\x97\xb8\x36\x11\x4f\x4c\xc4\xc3\x12\x71\xe2\x3a\x2d\xd6\x26\x05\x92\xb0\x33\x09\xf3\x49\x38\x29\x6e\xa1\x77\x9d\x97\xf3\xba\xe7\xbb\xd7\xb8\xb9\xe1\x6e\xec\x8e\x43\xa2\xe8\x58\x97\x8c\x93\xe3\x4c\x25\x74\xef\x72\x5e\x05\x60\x5f\x41\xc3\x00\x59\x83\x74\x73\x05\xfd\xcf\xbe\xa3\x5f\xad\x3a\xc6\xf4\x46\x7a\x73\x8f\x84\xeb\xfa\x97\x4e\x77\xc4\xa4\x17\x09\x64\x8c\xda\xb1\xc8\xd5\x58\x17\xb9\x7b\xd7\x2a\x1d\x39\x4b\xe4\x6a\x1b\xd6\x33\x7c\x70\x70\xe4\x9f\xb1\x5e\xf6\x18\xd7\x58\x5e\x5a\xc3\xfd\x36\x78\xc1\x60\xda\xcf\x07\x9a\x3c\x7c\x48\x38\xcb\xfa\x69\x3e\xec\x4d\x12\x9d\x48\x44\x79\x25\xd1\x44\x0a\x56\x3f\xb4\xe9\xb7\x4a\x45\x21\x76\x04\xa1\xcd\xa0\x35\xe4\x94\xac\x21\x01\x7e\xe0\x43\xef\x54\x29\xaf\x56\xbd\x03\x7f\x55\xb8\x2b\xfd\x56\xce\x29\xaf\xe2\xed\xd5\xf0\xe1\xde\xa2\x3c\x8c\x4b\xc2\x07\xc2\xf8\xeb\x8a\x03\x15\xb8\x83\xf2\xc3\x26\x3c\x55\x39\x56\x7d\xa0\x5a\x49\xac\x5e\x87\x3f\xdf\xa4\xc4\xa9\xb1\xb7\x40\x8e\xd2\x85\x9e\xa0\xbb\x0a\xe5\x04\xc9\x89\x9c\xd5\x61\xbd\xd5\x66\xad\x0e\x6b\x6c\x02\x42\x66\xce\x6c\xa8\x0c\x9b\x6d\x34\x0e\x4e\x2c\xf4\x48\xf0\x54\xab\xa0\x5a\x2c\x4c\x55\x4b\x8c\xd4\x68\xd8\x9b\x9d\xeb\xba\xe1\x40\x37\x3c\x25\x5d\x79\x20\x0d\x4f\xc9\x50\x1e\xc8\xe6\x26\xb5\x69\x9c\x39\x7c\x5d\xc6\xba\xb4\x75\xe4\x1a\xee\xa7\x1c\x7e\xe5\xf8\x2b\x17\x3e\xc7\x2f\xbd\x72\x1c\x78\xad\x1f\x42\xe4\x0c\xd0\xc0\x8e\x72\x64\x97\x64\x47\xf6\xf2\xb0\xde\x6c\x31\x97\x87\x35\x16\x9e\xc6\xc8\x72\xc2\x44\x95\xc5\xa1\x0a\x9e\x6b\x1d\xcf\xeb\xba\xf0\x86\x6a\xc3\xf8\xd8\xa2\x51\x38\x7e\xd4\x92\xf4\x25\x69\x4b\x32\x96\x0c\x57\xbe\x1a\xbe\x28\x63\x51\xda\x22\x68\xf2\x1d\x25\x17\x9a\x54\x7a\xb0\x26\x11\x6e\xfa\x2d\xda\x6f\x0f\xea\x28\xfb\xdc\xa6\xc1\x61\x01\xb9\x2d\xee\x14\x37\xa8\x63\x37\xdd\x7f\xc4\x0d\x0e\xeb\xf5\xc8\x40\x50\x5c\x65\x2c\x7e\xac\x1a\x09\xcb\x12\xa7\xee\x38\xa2\x1b\x8e\x82\xf6\x68\x9a\xa2\x4e\x74\x03\x9c\x9a\xa7\x08\xd3\xe8\x3f\xd2\xe4\xf5\x9a\xac\x7c\xe7\xba\xd4\x92\xea\x7e\xb6\x91\x38\x30\x43\xd3\xae\xc8\xb9\x26\x70\xcf\x04\x7b\x1f\xa0\x04\xf7\xf7\xbc\xfe\x4b\x27\x96\xe0\x53\x91\xbf\x76\xef\xb0\x6d\x8d\x72\xf7\xe7\xea\xfe\x16\x2f\xcb\x67\xd3\x13\xfc\xa2\x44\xd4\x4e\xf6\xc4\x0b\x95\xe1\x38\xad\x4e\x5b\x1d\x76\xe9\xe2\xe1\x9f\x64\x30\x38\x2a\xc3\x06\x22\xd9\x62\x83\x41\xdd\xc5\x56\x73\xaf\x96\xc8\x43\x34\x1e\x91\x40\xa3\xba\x49\x8c\x40\x05\xc5\xfc\x99\x2d\xca\xf7\x2f\xd0\x58\x43\xdb\xd6\x66\xae\x95\xf1\xa5\x8f\xaf\x28\x6f\xcf\x9e\xb9\xd5\xf1\x8f\xcc\x7f\x38\xb7\x6f\x79\x90\xfc\xb8\xf5\xe7\x35\x4a\x1a\xc9\x3b\x83\xfb\xed\xfd\xc7\x2d\x7d\x26\x9c\x99\xb1\x8a\xe1\x24\x2a\x23\xf8\x4f\x01\x27\xd0\x03\xa8\x40\xf6\x24\x70\xa9\x5c\x65\x38\x35\x15\x39\x1c\xbe\xca\xb0\x83\xe8\x4d\x26\x4d\x55\xd8\x94\x80\x54\x9c\xd4\x55\x49\xcd\x11\x6a\xd4\xd0\x82\xaa\xc3\x1d\x92\xa2\xca\x35\xa4\x46\x1a\x14\xa5\x58\xa0\xc1\x14\xe2\x3a\xb1\x77\xb2\x94\x93\xe7\x2d\x6b\x9b\xbe\x20\x73\xed\x42\x0b\x78\x4d\x3f\x7c\xf9\xf9\x8b\xcf\x7e\x77\x68\xea\x82\xdd\x7d\x9e\xc7\x19\x1c\x89\x7c\x92\xee\xc9\xcb\x35\x7e\xa9\x31\x4c\x5d\xd0\x75\x88\xb0\x70\xf7\x23\x8f\x7f\x53\x10\x39\x4e\xce\xf7\xe9\xad\xac\x05\x9f\xb2\x10\xf0\x1c\x02\x3c\x94\x8b\x0a\x51\x07\x98\x47\x8f\x94\x73\x73\x13\xda\xe7\x77\xc9\x1f\x1c\x16\xdb\x64\xa5\x75\xb1\xea\xba\xc0\x3f\x93\x37\x2d\x2d\x71\x70\x38\xcd\x65\x46\x9d\x25\x93\x34\x38\x6c\xb2\x84\xda\xa1\x76\xe5\x61\x14\x8b\x38\xd2\xb2\x76\x8c\x6e\x50\x65\x04\xee\x40\x27\x37\xd1\x95\x3a\xa0\xac\xd5\x6c\x2f\x76\x13\x96\xd2\x6d\x3e\xb7\x3d\x48\xa8\x92\x93\x5a\x7a\x49\xd4\xe8\x72\x74\x8f\xa8\x1f\x8e\xae\x38\x24\xd0\x40\x35\xb8\x30\x20\x85\x8a\xb1\x66\xe2\xd4\xdf\x7f\x9e\xd1\xbd\x5f\x9c\xf2\xe9\x6c\xbc\xc9\xf8\xc4\x93\xcf\xcc\xe8\xa3\x1f\xa0\x4f\xf5\xa7\xa4\x24\x7b\xb2\xb3\x72\x93\x27\xf7\xe1\xc4\xce\x2b\x6f\xd9\xf7\x24\xb7\xba\x72\xe5\x80\xf9\x0e\x65\xad\x7e\xda\x42\x7c\x58\xe8\xdb\xc9\x6e\x36\x2d\x9f\x72\xea\xef\x02\xd6\x0b\x65\x03\x4c\xb8\x1b\xc6\x4b\x95\xc9\xe9\x9b\xfb\xb7\x6b\xaf\x2c\x28\xf0\x65\xfb\xc5\xad\xa2\x4e\xe4\xc7\xf4\xc9\x18\x34\xc9\xae\x54\x91\x6d\x9c\x72\xca\x75\x5f\xd5\x13\x59\x71\x58\xcc\xc6\xc3\x93\xdd\x07\x71\xa5\x1a\xe7\x7b\xaf\x32\x42\x28\x04\x5a\xf9\x60\x4c\xdb\xcb\xc9\x89\x09\xa9\xa6\x24\x0f\xcf\x39\xe3\xe2\x6c\xe5\xe1\x38\x97\x06\xa5\x19\x31\x87\xcb\xc3\x00\x8d\x33\xa3\x92\x73\xb1\xf5\x1c\x51\xaa\xb8\x3b\x50\x3a\xd0\x30\x42\x74\x27\x1a\x86\x7f\x92\x5f\x0d\x11\xa9\x8e\x71\x00\xfb\x31\x1b\x67\x90\xc7\x7b\x77\xa5\x1f\xbe\xef\xf9\xd0\xab\x58\xf3\xa4\xf2\x5b\x62\xfa\x1c\x65\x05\xd7\x7b\xc0\xa2\x75\x69\x1b\xef\xe8\x7a\xdf\x10\xe5\x1f\x4f\xe2\x99\x46\x23\x1e\xb1\x75\x0a\x59\x7c\x82\x06\x42\xc7\x1b\x95\x69\x27\x22\xc7\x7c\x45\xb9\x09\xc7\xdc\xda\x1c\xa5\x03\x17\x0c\xe4\x14\x74\xc7\xa5\x5f\x53\x5d\xe5\x53\x26\xd1\x3c\x80\x20\x1f\x83\xe4\x2c\x11\x57\x85\xcf\x8a\x98\x9c\x10\x31\xbf\x56\xc4\xfd\xe1\x54\x4c\x36\xf6\x31\x8b\x5e\x91\xd3\x09\xa2\x68\xe6\xcd\xba\x2a\x50\x5d\xc6\x3a\x5c\x7a\x48\xcb\x13\x1a\x0f\xae\x24\xd8\xac\xc5\xe8\xee\xc1\xca\x8a\x8a\x4a\x1a\x52\x87\x3e\x96\x23\x3e\xac\xa6\x97\x08\xd2\x98\x8e\xc4\xaf\x3c\x30\x43\xb9\x80\x45\x1c\x98\x88\xa7\x4c\xc4\x81\xf7\xc7\xdf\x79\x6d\xd0\x46\xae\x6b\xe4\x55\xa1\x67\xe4\x7b\xce\xde\xb0\x2f\x32\x07\xd3\xfd\xbd\x19\x80\xd3\x52\x16\xd3\x39\x47\x36\x79\x50\xbc\xd3\x6b\x22\x26\x6d\x79\xd8\xe4\x34\x40\xc3\x87\x89\x63\x48\x98\x58\xa2\x7b\x69\xa2\x3b\x76\x4b\x98\xb9\x8c\xc6\x9c\x65\xcd\xb5\x04\xe9\xa6\x58\x88\x66\x8c\x2f\x0f\x7e\x75\xfe\xaa\xbb\x2d\x55\xb3\xe7\xfc\x6b\xd0\xc3\x0b\x2d\x3d\x4b\x27\x3d\x16\x37\x53\xf9\x0a\xa7\x60\xcf\x20\x63\xa2\x96\x54\x2f\x9e\xb1\x72\x59\x9f\xa1\x8a\x25\xb2\x07\x6f\xe5\xa6\x0e\x29\xe8\xdd\xfd\xd0\xca\xc8\x4b\xc2\x59\x65\x4a\xaf\xc9\xf4\xd9\xa0\x57\x99\xc4\x62\x0e\x9a\x51\x80\xae\x39\x47\x98\xbf\x8e\x20\xd2\xf5\x04\x61\xf1\xdc\xd4\xd6\xb1\x0f\xdb\x19\x52\x5c\x3b\x1a\x59\x90\x92\x60\x0e\x97\x89\x47\x44\x4e\x5e\xda\x0a\x34\xa8\x61\xb1\x05\x81\x08\x4f\x73\x23\x22\x2f\x45\x7e\x62\x64\x80\xf6\x4a\x81\x0e\x17\x59\x6c\x99\xc0\x0b\xc8\x8c\x4b\x41\x87\x6a\x38\xc2\x63\xad\x59\x44\x82\x13\x1b\xca\x9b\xe3\x55\xb0\xf0\x71\x25\xf4\x01\x1e\xb9\xae\x45\x52\xd0\xe9\xd5\x75\x83\x58\x1f\xe3\x9f\xc2\x17\x70\xae\x52\xf0\xc6\xf4\x39\xff\xc2\x57\x86\x29\x93\x85\xb3\x8d\xcf\xe1\x97\x95\x5b\x95\xec\xc8\x1e\x75\x5d\xe0\x0f\xd0\xde\x97\x6c\x7f\x74\x3a\x5d\xcf\x2c\x89\x95\x61\x89\xf0\x3a\xa2\xab\x0c\x13\x1b\x86\x2e\xb6\xd2\x47\xcc\x5a\xf8\xed\x3e\xd0\x3c\x34\xb8\x8e\x8f\x1c\xbb\x36\xa8\xf1\x62\x16\x19\x14\xd9\xdb\x96\xec\xcc\x6c\x7c\x9e\x7b\x43\x99\x84\xb7\xbe\x4d\xd6\x7f\x55\xdf\x38\x5d\xf5\x7b\x29\xaf\x4d\xe5\x3b\xd2\xfd\xd7\x2f\x20\x3d\xf4\xc7\x22\xf1\x02\x3f\x34\x2c\x98\x39\x0d\xd6\x44\xa3\x6f\xb4\x52\x18\x2c\x02\x47\x0c\xbe\x9f\xfb\x28\x52\x16\xe0\x4e\x44\x7e\x0c\x90\xc1\x81\x48\x19\x37\x69\xfe\xbf\x4e\x73\xbb\xcf\xfc\x2d\x32\x5a\x7d\xb6\xca\xa1\x3e\x4d\xdf\x01\x2f\xdf\xca\x62\xf1\x04\x64\x87\x91\xc0\x9c\x46\xa7\x73\x56\x86\x75\x3c\xb1\x8c\x0d\x13\xbb\xaa\x51\x5b\x52\x0c\x50\x8a\x85\x54\xef\x83\x4e\x65\xdd\xa1\x20\x4e\x2f\x08\xd9\x29\xdb\x70\x4e\x0b\xe1\xcd\xb5\x8f\x9f\xa9\x3f\x84\xbb\x9f\x7b\x7a\xca\x86\x76\xca\x35\xa5\xdd\x8a\x8a\x8d\xed\xe6\xd6\x6c\x1f\x3b\x78\x7c\xe4\xab\x5f\xf0\x53\x3f\xd6\x0c\xbc\x76\xfc\x8d\x6a\xee\xc7\xf0\x01\xe5\xd8\x63\xca\xf7\xd0\xc7\xb5\x08\x09\xc7\xf9\x81\x60\xfb\xdd\xb2\xc1\x4e\x86\x84\x91\xdd\xa2\x35\x1b\x35\x4e\xba\x31\x44\xdd\x08\xac\x86\xc5\x64\xa2\xe1\x72\x47\x03\x2e\xb9\x85\x76\xce\x8c\xa4\xf4\x50\x9a\x52\xaa\x3c\xff\x3a\x4e\x1b\xa1\x31\x7b\xaa\xde\xed\xf9\xdc\xcc\x05\x0b\x48\x27\x9b\x35\xa3\x53\x84\xf0\x1d\x23\xb5\xed\x5f\x0d\xbd\x8c\xd7\x2d\x5b\x32\x8c\xd1\x73\x32\xb4\xf5\x15\xf4\x37\x03\xf9\x65\x5b\x92\xbf\x32\xec\x4b\xe2\x05\xab\x55\xa3\x25\x2e\x23\xd6\xa8\x31\x93\x98\x89\x57\x23\xd2\xfa\x49\x06\x57\x44\x23\x32\x07\x89\x28\xb1\x90\xa4\x76\x57\x12\x0e\xc5\xe2\x34\xb2\x70\xe0\x20\x2e\xb7\x7d\x6e\xe0\xcd\xdd\xde\xff\x3c\xf8\x7b\xae\xce\xa3\x6f\x97\xf3\xd4\x3e\x9f\x64\x48\x4a\x5a\x9d\x7f\xcf\x8c\x0e\x23\xdb\xaf\x4c\x8f\x4b\xc8\x70\x62\xbd\x17\xb7\x49\xdf\xaa\x24\x01\xd3\xf6\x59\xbc\xde\xb3\x2c\x8c\x87\x2a\x7b\xe7\x85\xd3\x0b\xee\x18\x83\x9f\x7b\x68\x55\x46\xd6\x01\x6f\xa8\x2b\xc5\x31\x0c\x38\x1e\x04\x7a\xf8\xc1\xe7\xb5\xc7\xa7\x0c\x09\x27\xc5\x5b\x78\xb3\x19\x6b\xcc\x92\xd3\x6e\xa0\x23\x4e\xa3\x4a\x5f\x87\x64\x33\x8e\x40\x1b\x40\xd1\xd9\x82\xa0\x4a\x39\x32\xfb\x52\xa1\xd4\xee\xc7\x8b\x09\x1f\xa5\x81\x24\xe4\x5d\x79\xb6\x50\xb2\xb4\x5b\x5a\x30\xaf\xaa\x6c\x6c\xce\x2a\x6b\xbc\x35\xa5\x4d\x3c\x7e\xbf\x24\xe3\x36\xa5\x2d\x90\xec\xf1\x4d\x03\x4c\xd5\xf8\x94\xd2\xa1\x2c\x67\xe0\x66\x3c\xfd\xfe\x39\x59\x39\xcf\x58\x6d\xc1\xee\x94\x5f\x06\xd3\x38\x79\x80\x5b\x1c\x68\xed\xdc\x83\x92\x33\xc5\x59\x87\x7b\xcb\xd6\xb0\x2e\x25\x45\x34\x9b\x13\x06\x87\xcd\x16\x24\x3a\x89\x99\xc9\x74\xcc\x53\x53\x59\x3f\xbd\x98\x86\x2e\xf0\x11\x3a\xc3\x6f\x99\xfe\xba\x5d\x6e\xbb\x1a\xc6\xd2\x5d\xcc\x79\x3b\x95\xe0\x21\x38\x10\xb9\x47\x79\x7e\xf4\xf2\xe4\xd5\xfa\x23\x5b\x6f\x9d\x3c\x75\x79\xbc\x5e\x93\x12\x48\x4d\xd3\xd5\x9c\x5f\x3e\x97\x9b\xd3\x70\x0a\x5f\x6d\xbb\x2d\x7b\x68\x9b\x8d\x07\xaa\x46\x4c\xd9\x50\x5a\x5b\xb2\x82\x9b\x15\x2c\xcc\x8a\xef\xd1\x89\xca\x0b\xf8\x2e\x03\x58\x9c\x83\x22\x39\x95\xea\xe6\x8f\x41\x21\x9f\x03\xdd\xbc\x55\xc4\xa3\x45\x4c\x55\x73\xbc\x98\x25\x72\x22\x4d\x50\x44\xa2\x71\x45\x2b\x72\x6e\xd2\xc0\x7c\x72\xe4\xe1\x98\xe6\xe5\x26\xc4\x14\xae\x2a\x93\xdb\xa0\x8d\x64\x90\x49\x09\x25\xca\x16\xcc\x97\x87\x97\xe2\xfb\xc0\x50\x61\x51\x32\x83\xdb\x1c\x85\x18\x0d\xac\x4e\x73\x50\xdd\x3d\x14\x7f\x95\xae\xc4\xdf\xaa\x7c\xf9\x0e\xdf\x51\x19\xf6\x57\xa5\x1d\x54\x06\x5a\xc6\x81\xec\x1d\xe7\x87\x80\xbf\x99\x04\xda\xc3\x61\x75\x0f\x0e\x5b\x2d\x92\x66\x70\x58\xb2\x24\x18\x89\xb1\x3c\x4c\x5a\xbc\x01\xa4\x46\x5f\xb2\x20\x5f\x8a\xd5\x92\x2e\x81\xac\x81\x31\x67\x43\x2c\x45\x55\x76\xb1\x8d\x3f\xae\x3c\xa0\xec\x56\x52\xb8\x38\xe3\xb2\xc7\x76\x4e\xca\x78\x77\xc7\xd2\xf5\x5f\x64\xfb\x3b\x0c\x88\x9b\xf4\xc4\x7e\xee\xac\xf2\x88\xb2\x12\xef\xe6\xba\x2d\x39\x98\xac\x5c\x7c\xe5\x3b\x03\xe7\x3e\x75\xf6\x9d\x47\x6b\xc6\x4c\xbd\x23\xf2\xad\x84\x73\xd5\xbd\x28\x1a\x34\x80\xbc\x42\x3e\x66\xef\x90\x82\xb2\x47\xe0\x8f\x87\x05\x1a\x90\xf5\x38\x0d\xc8\x8a\xd1\xf1\x30\xa6\x71\x59\x8f\x37\xbf\x4c\xaa\x6f\x1d\x93\x95\x62\x18\x4a\x97\xd8\x31\x3e\x9f\x6b\x93\x17\x99\x97\xc7\xb5\xcd\xe3\xda\xfc\xfc\xe2\xcf\x91\xf1\xf0\xa1\xda\xfd\x43\xe4\x38\x5e\x14\xcd\x75\x62\x3a\xc4\xc3\x50\x60\x94\x57\x0f\xec\xcc\xd4\x63\x90\x5a\x74\xec\xb8\x7b\xe2\xdd\xca\xa5\x5d\xc9\xbb\xc8\x71\xce\xaa\x3c\xfd\x08\xa5\x57\x67\xf2\x0b\xd7\x57\xa8\x8f\xd6\x43\x1c\x27\xf2\xb1\x7a\xd4\xd9\x24\x01\xec\xfe\x1e\x6a\xdc\x35\x10\xbf\x32\x40\xc8\x7f\x44\xc9\xae\xc6\x73\x6b\xa0\xbd\x49\xfc\x28\xbc\xa9\xb9\x3d\x0e\x2d\x93\x60\x6a\x13\x64\x79\xa0\x69\x3d\xb7\xe4\x0b\x7d\xbf\xcb\xbb\x6b\x8d\x27\xf2\xa3\x07\xea\x7d\xbf\x72\xa5\xaa\xdb\x69\xbd\x97\x84\x63\x48\x40\x86\x83\xc2\x32\xba\xf9\x1c\x2a\x51\x16\x09\xf9\x00\xc3\x85\x50\x1a\xdf\x93\xbd\x9a\x1f\xb5\xf2\x23\x75\x8f\xd8\x31\x12\xe1\xd7\x4b\xa5\x48\x0b\xad\xd0\xe4\x4b\x9a\xe6\x5e\x81\x2a\xa6\x6a\x3f\x08\x2e\x82\x72\xa5\xe2\xf1\x0a\xe5\x1b\x01\x6f\x4a\xc3\x6e\xe1\x13\x25\x05\x5f\x4a\x84\x89\xc8\x21\xa8\xff\x28\xd4\x9f\x11\xad\x2f\x11\x82\xc5\x16\xaa\xe0\x10\xdd\x6e\xef\x93\xb8\x77\xd3\x94\x1f\x04\xec\x1e\xf3\xf8\x18\xec\x12\x48\x04\xf7\x4b\xa4\x21\x52\x12\x28\x5d\xb9\x14\xb2\x93\x77\x48\x6a\x3f\x93\x0f\x63\xcc\x13\xba\xa5\x7e\xf0\xe1\x51\xf9\x3c\x9c\xd3\x00\x2c\x51\x81\x6c\x49\x76\x43\x16\x7e\x39\x0a\x67\x28\x06\x9a\xd8\x46\x28\xe7\x16\x37\x7c\xc8\xd2\xd9\xa8\xb0\x4c\x51\x58\x7e\xd9\xc0\x71\x80\x9f\x81\x60\x5e\xe6\x45\x00\xb9\x9f\xe5\xe2\x89\x85\x3f\x60\x71\x7b\x68\x98\x77\x60\x76\x52\xa6\x7c\xf8\xc8\x97\xb7\x17\x2a\x97\x0a\xc9\x4e\x6e\x31\xde\xa3\xfc\x84\xe9\x93\xb2\x17\xf1\x4e\xb2\x27\x3a\x06\xa9\xb2\x3e\x06\x4f\x92\x28\xb8\x03\x34\x03\x1b\xe5\x71\xcb\xa9\x1b\xc0\x71\x9f\x35\x83\xc3\x2d\xe0\x60\x6c\x1c\x30\x36\x5f\xc3\xd8\x68\x91\xe3\x28\x91\x24\x41\xc0\xcb\xb4\x34\xb7\x77\x87\xbc\x02\x35\x0f\x0c\xcc\x37\xfc\x21\x38\x76\x73\xf7\xc7\x5f\x0e\xac\x0e\x3c\x9e\xb3\x5a\x38\xb6\xf2\xf4\x69\x75\xac\x94\x4e\xf0\xf9\x05\x38\xa2\x5a\x64\x3b\xc2\xf3\x12\xc7\x61\xa8\x5e\x0f\x13\x6d\xd6\x7a\x50\x52\x23\xb0\xfb\x94\xa5\xab\xb3\x1f\xcf\x58\x9d\x71\xd9\x13\x99\x81\x2b\x3f\x3a\x7d\x7a\x25\xb4\x2d\x2b\xb7\xe3\xdf\x9b\x36\xc1\x04\x19\xb8\x17\x2f\xe3\x18\x37\xd5\xb3\x14\x42\x01\x1a\x9b\x0b\xff\xfe\xd9\xd8\x4d\x97\x71\xf1\xab\xca\xed\x0f\x3c\x80\x03\x4c\xae\x9e\xc0\x26\x52\x05\x62\x4f\xfb\x4f\x33\x01\x99\x05\x9a\x87\x85\x86\x4b\x6c\xce\xd2\xa3\x65\xa9\x79\x16\xd2\x4f\x92\x42\xbd\xd0\xc8\x0f\xd1\x74\x3c\xc0\xfb\x0a\xf6\xf3\x22\x9f\xc5\xea\x1b\x0e\x22\xc6\xfa\x41\x96\xc9\x9c\x9a\x7a\x7a\xdc\x96\xc3\xcd\xca\x89\xf8\xe9\x27\xe9\x7b\xf1\x62\xe4\xc2\x27\x9f\x00\x8d\xbf\xc0\xef\x90\x27\x84\xbb\xd8\x7b\x63\x4c\xd4\x77\x3c\x30\xf6\xdc\x99\x2f\xb7\xe0\x0c\xf8\x6d\x1f\xc2\x5c\x3e\x29\x21\xfb\xd9\xd8\xe8\x0f\x42\x77\x58\x46\x5c\xb5\x18\xb1\x5c\x1a\x8d\xd3\x49\x09\xb7\x9e\xc6\x6e\x28\x05\xbd\xf7\x9b\x70\x05\xec\x74\x3c\x68\xac\x8e\xb2\x37\xc1\x33\x74\x54\x02\xd2\xc1\x0c\xd9\xa0\xc3\x2c\x9c\x44\x79\x38\x3e\xce\x2e\x0a\x66\xb7\x8b\x53\xed\x54\x90\x05\x21\x8c\x6d\x50\x89\xa9\xb1\xe8\x3c\xb9\x39\xa3\x06\xb8\x9a\x41\x89\x86\x4b\x0d\x40\x4f\x38\xed\x5e\xe5\xeb\xbd\x1b\xd3\x37\xba\x92\xdf\xdc\x3a\xa9\x3a\x6d\x60\x49\xa8\xab\xd5\x7a\x31\xfd\xaa\xf2\xd5\x3b\x38\xfe\xdf\x99\x38\x3e\x93\x2c\x6e\x5c\x09\xae\xfa\xcc\x47\x9e\x4c\xac\xb3\xf7\x1c\x3a\xe2\x44\xe3\x4a\xbe\xe3\x6b\xe7\xcf\xab\xb4\x6a\x8d\x27\xe8\x30\x77\xdc\x0d\x28\x52\x04\xe3\x5b\x23\xd8\x1a\xbd\xe0\x9f\xa1\x47\xfd\xc3\x3f\x43\x2d\x8b\x3a\x8b\xca\xa5\x3f\x40\x4b\x38\x7b\xad\x90\xe6\xcd\xfa\x06\x67\x90\xf9\xfc\x05\x5b\x06\x4d\xab\x66\x95\xf8\x7f\x37\xbd\xa1\x1c\x46\x29\xfb\x31\x5f\xd7\xf4\x98\x6c\xe1\x01\xb9\x74\x2c\xc5\x62\x71\xf2\xa8\xc2\x5a\x84\x59\x7e\x52\x18\xc3\x5f\x84\x9d\xfc\x73\xe2\x65\x9a\x01\xfc\x88\xc5\x0c\x6e\x9f\x91\xd4\xe1\x0a\x1a\x43\x97\x06\xab\x89\xc5\x2c\x02\x86\x8d\xc6\x7c\x7e\x2e\xf9\xdd\x1d\xeb\x1f\xd4\xd4\xf3\x45\x9d\xba\x56\x19\xc4\xcb\x5b\x9f\x5a\x32\x37\x27\x25\xd0\xae\xc7\xc8\x1e\x2c\x96\xce\xa7\xb8\x33\xbf\x02\x70\x09\x08\x1a\xe5\x3f\x34\x63\xab\xa0\xc1\x06\x86\xd5\x0f\x68\x3a\xe7\xa7\x5e\x18\x57\xad\xd7\x12\x29\x9d\xd3\x94\x6b\xb0\x8a\x8b\x9a\x33\xb8\xe9\xf9\xa6\xb7\x05\x03\xd4\x15\x05\x2b\x8b\x43\x76\x80\xe6\x63\xa2\xd7\x7c\x13\x83\x7d\x17\xa5\x3d\xfb\x9d\x63\xbf\x2b\x70\x7d\x88\x5d\x13\xf6\x7b\x16\x5c\x8f\x63\xd7\x2c\x9f\x18\x5a\xd8\xf4\x3a\xbf\x43\xbc\x0b\xae\xf5\xec\x9a\xe6\x28\xda\xc6\x7e\x37\xb0\xeb\xdd\x70\x3d\x9c\x5d\xbb\x19\xbc\xb7\xd9\xfb\x40\x7a\x1d\xcf\x6c\x71\x19\xfe\x1b\xff\x30\x3f\x1f\xa4\x22\xee\xa0\xc8\x61\xae\x0e\x57\x1e\x08\x03\x51\xf1\x2d\xa8\xe4\x64\x2c\xe0\xba\x9d\xe5\xec\xe3\x27\x35\x7c\xda\x0e\xaf\x19\x86\x2d\xc3\xf0\xbd\xf8\x6f\x60\xb1\x9f\x55\x86\xd1\x36\xa6\x36\xfd\x22\x94\x0a\xff\x84\xb1\x89\x63\x54\xf8\x0d\xd7\x03\x6c\xc3\x51\x9c\xd8\x36\x31\xd5\x66\x4f\x8f\xe5\x89\xa5\xe5\xba\xb7\x2e\x47\xf3\x02\xb3\x72\x38\x31\xd5\x93\x70\x5d\xb9\x66\x78\x96\x80\x0a\x8f\x8e\x39\x0a\x36\x61\x54\x0e\xd4\xcd\x34\x67\xe2\x94\x4c\x39\xf3\xe5\x4c\x52\xd7\x74\x5a\xce\xc9\xcc\xb5\x25\xa4\xe3\x44\x4b\x22\x56\x5b\xe4\x72\x06\xe5\x54\xe6\x4c\xcf\x21\xf4\x6b\x69\xce\x7d\x39\xe7\x73\x7e\xcc\x69\xca\x91\xb6\xe7\x60\x34\x93\xa6\x16\xc7\x39\x30\x28\x39\x15\xd1\x44\xe5\x37\xe2\x06\x6d\xb2\xb6\x9a\x71\x2c\xd9\x8f\x13\x69\x43\x99\x00\x3d\x21\x1d\xa6\x51\x99\xb9\x80\x2f\xf6\x0e\xf2\x56\x7a\xa7\x7b\xc9\x20\x96\xc3\xfc\x3e\xef\x79\xef\x8f\xde\x26\xaf\xb4\xdd\xdb\xdc\x0a\x34\xd2\x9c\x0b\xbd\xe9\x40\x53\x3c\x1b\xeb\x0c\x3a\xd6\x56\x91\xff\xe1\x0a\x42\xe6\xfd\x38\xa9\xae\xe9\xf5\x43\x49\x09\x46\x07\x23\x00\x2d\xa7\xec\xb8\xae\xdc\x8f\x6a\xb9\x44\x5a\x2e\x31\xb9\x55\xb9\x28\xef\xa8\xe5\xa8\x4c\x54\x28\x18\xd9\x0f\x61\x0f\xf2\xe0\xba\xa6\x5f\x0e\x79\x52\x4c\x40\xfd\xe6\x9c\xd3\x5f\xc0\xd8\x97\x31\x19\x42\xd1\xf2\x7d\x9a\xf6\x21\xcf\x7e\xec\xa8\x6b\xfa\x50\xd6\x39\x3c\xc8\x92\x8e\x93\x50\x12\x8e\x49\x0f\xd0\xa5\x1c\x14\xd7\xf3\xac\x0e\x8e\xd6\x71\xa2\x21\x28\x75\x3f\xf6\xd4\x35\x3d\x22\x5b\x3d\x29\x82\x11\xea\xe4\x25\x61\x39\xa9\x3c\xa9\x2a\x89\xa0\x8a\x96\xba\x31\x5e\xce\xa0\xbc\xcc\xea\xe2\xa6\x89\xc8\xba\x1f\x6b\xea\x9a\x8e\x1e\xd2\x98\x38\x92\x9e\x13\xcd\xa5\xdd\xcc\xe7\x19\x94\xcf\x59\xd9\xef\xa1\xac\xe1\x28\xe7\xf0\x39\x3c\x44\x88\xf1\x06\x06\xd4\x41\x8f\x53\xd9\xe3\xd1\x7d\x6a\x49\xe5\x1c\xf4\xc2\x7d\x04\xeb\x2c\xba\x14\x1d\x57\xd7\xf4\xe8\x21\x9d\x8e\x10\xd6\x6f\x35\x4f\xf7\x69\xa8\xd3\x9f\xbf\x06\xb0\x85\xa0\x5a\xe3\x7e\x80\xed\x91\xb5\xd8\x91\xe2\xc8\x77\xc8\x0e\x60\xa2\x4f\x0f\x39\x1c\x92\x14\xad\x04\x75\x7a\x83\x6f\x59\xc7\xff\x00\x75\x24\x36\x06\xff\xfe\x75\x1f\x8a\x97\x8d\x38\x95\xa4\x66\xea\x6c\xe9\x38\x07\xe5\x34\x93\x29\x3a\xbe\x78\x2c\x57\x46\x3e\x51\x75\xd4\x04\xb5\x0f\xd9\xe8\x39\xe4\xdc\x8f\x75\x75\x4d\x07\x8e\x30\xa4\x40\x45\x45\x15\x13\x95\x4d\x65\x29\x93\xcd\x0c\x41\x1b\xed\x73\x21\xe0\x05\x23\x6d\x01\x5e\x3b\x64\x71\xf1\x1a\xb5\xdb\xad\xe5\x3e\x83\xca\x3d\x2b\x3b\xab\x49\xc5\xc8\x91\xe9\xf0\x68\xcd\xe9\xd8\x8d\xdc\xad\x31\x6a\xa5\x1b\x32\xa8\x6e\x60\x75\xe8\xe2\x9e\x74\xe8\xb7\x1d\x66\x88\xf6\x14\x3b\x61\xe3\x6e\x8f\x47\x80\x58\x22\x4a\x8c\x56\x8f\xd1\xad\x69\x0f\xd3\x25\x17\xa1\xbe\x51\xa5\x81\x7f\x1f\xca\x93\x7d\x38\x39\x3f\x19\xcf\x48\x5e\x96\x7c\x7f\xf2\xf3\xc9\x2f\x27\x5f\x4d\x16\x07\x26\xa7\x19\xe2\xd3\xb1\x8f\x06\x82\xca\xf7\x91\x28\x98\x99\x31\x3c\x6a\x81\x87\xbe\x63\xb8\x9b\x5b\xf1\x5d\xbc\x6c\xc6\x36\x8d\x2d\x8e\x13\xd3\x71\x02\x4a\xa8\x4c\xe0\x9a\x95\x36\xd4\x19\x0e\xf4\x3f\xc6\xea\x58\x9a\xe9\x9f\xba\x9f\x4b\xab\x6b\xfa\x55\xb6\xa6\x65\xc7\xa5\xa4\x73\x6d\x2b\xdb\x2e\x6d\xcb\xa1\xb6\xf9\xf0\x51\xd1\xac\xef\xa1\x6e\x15\xd0\xf5\x41\x56\xd7\xa6\xd6\xed\xbd\x1a\x25\xc1\x4c\xc3\xd1\xc3\xe1\xd1\x45\x29\xf5\x16\x25\xd6\xcc\xeb\xc6\x8f\x66\x68\xe4\x77\xb0\x7a\x76\xb5\xde\xe8\x7d\x50\xcf\x8e\xe3\xf3\xe3\xe5\xf8\xf2\xf8\xaa\x78\x7e\x60\xbc\x17\x09\x94\x56\xb4\xe2\xcc\x98\x5c\x5d\x80\x7a\x6a\xff\x9c\x51\x8e\x3c\xab\x7c\x80\x3c\x2f\xd0\xf4\x4e\xb2\xc1\xea\x06\x3e\xc7\x8e\x41\x8e\x4a\x47\xb4\x87\x34\x47\x7a\x23\xe0\x78\x82\xd5\x71\xa9\x6d\xb9\x3f\xa0\xa3\xc9\xb9\x2a\x5d\x89\xc4\x9a\xce\xc5\xa3\xf8\x1b\xf9\xab\x59\x97\x67\x50\x5d\xfe\xdf\xf0\x0b\xd3\x67\xac\x6c\x5c\x2b\xdd\xf9\xff\x91\xf6\x1f\xf0\x71\x13\xf9\xfb\x38\xae\x69\x92\xd6\xbd\xa4\xd9\x71\x9c\x4d\x71\x0a\x4e\x1c\x5b\xd2\xee\xda\x21\xc5\x4d\x4a\x21\x21\x21\x95\x10\x20\x6c\xec\xb5\xbd\x89\xed\x75\xec\x75\x42\x12\x4a\xe8\xbd\xf7\xa3\x85\x5e\x13\x3a\xa1\x06\x0e\x38\x0e\xee\x28\x77\x1c\x47\x39\x3a\x77\x94\x3b\xe0\xa8\x47\x8f\xf3\x1f\x49\x8f\xed\x8d\xf1\xf1\xb9\xff\xf7\x97\xbc\xd6\x33\xd2\xce\xcc\xf3\x9e\xf7\x8c\xe6\x79\xde\x92\x56\x6a\xae\x96\xc6\xa7\x17\x8d\x2c\x2a\x2d\x62\x8d\x45\x27\x16\x5d\x58\xc4\x86\x14\x8d\x2f\xaa\x2f\x5a\x56\x94\xf4\x36\x5f\x2e\xd2\x1f\x2f\x92\x2c\xb0\xf7\xd9\xea\xc9\x45\x63\xf3\x0b\xe5\x1a\x97\x18\x7d\xf5\x68\xea\x3e\x46\x73\x1a\x96\xbb\x63\xb1\xce\xa5\xb9\x7f\xe8\xb9\x72\xb1\x3b\xec\xb0\x0d\x9d\xae\xa9\x6b\xdc\x17\x63\xf5\xaf\x77\xbd\x5c\x33\xc1\xe5\x1a\xcf\x86\xd1\xd2\xde\xf2\xea\x42\x77\x91\x09\x8e\xa2\x1d\xa3\xb6\x8d\x3a\x77\xd4\xf6\x51\x77\x8e\x7a\x7c\xd4\x9f\x46\xbd\x3b\xea\x8b\x51\x81\x07\xf6\x7e\x71\xff\xa8\x71\x99\xf2\x00\x0b\x2a\xbd\x93\xc8\x3b\xb6\x36\xcb\x39\xb4\x49\x75\x64\x5b\x5c\xae\xcf\x2a\xff\x52\x49\x59\xd3\xc4\x5d\x7d\x6b\xda\xb7\x7b\x3b\x7d\x4e\x91\x71\xf1\x50\xa5\x6f\xdd\xf0\x8f\x1f\xaf\x5c\x9a\xe7\xef\x6f\xb7\xf9\xa5\x94\xe1\x43\x99\xc7\x50\xbd\xe3\xef\x95\xc9\x47\x5b\x5b\xc0\x4f\xc1\xa2\x42\x3d\x13\xce\x25\x4a\xa3\x2c\xf7\x86\x7a\x8e\x92\xab\x8c\xdf\x45\x79\xb6\xaa\xe6\xf2\xb4\x47\xc9\x4a\x25\x97\x1c\x2c\xbf\xe5\x32\xe7\x9e\x77\xf1\x7e\x38\xeb\x3d\xdf\xd3\x15\x82\xee\xe3\xa2\x67\x93\x31\x5a\x16\x91\x3a\xed\xc7\x8b\x37\x93\xec\x15\xf3\x7e\xac\x3a\xb0\xa4\x96\x0c\xb1\xcb\x2e\xd9\xfe\x45\xcf\x13\x7c\x0c\x6d\xef\x99\xbf\xe7\xaf\xd6\x95\xc7\xbe\xf1\xc5\xe5\x7f\xdb\xd2\x23\xa9\x9c\xec\x69\xe5\x8f\x29\x2f\xaa\x86\xd4\xd9\x52\xb5\x06\xb6\x09\x57\xa3\x7b\x71\xd7\x58\xae\x8d\x0b\x8f\x1f\x63\xee\xe2\x9f\xf4\x5c\xbd\xf1\xa4\x2b\xc9\x35\x24\x73\x84\xd8\xb5\xf1\xf8\xdd\xf7\xb9\x36\xde\xc9\x1f\x63\x97\xa3\x9e\x4e\xfa\xeb\x99\x41\x3e\x7c\xdc\x84\xf1\xa5\xe4\x99\x11\x24\x83\x1c\xba\xf4\x24\xbb\xe7\x85\x4f\xb8\x6a\xdc\xb7\xfb\xf8\x8d\x2e\xde\x36\xfe\x94\xb2\x53\xfc\x49\xc9\x90\xda\x3c\x83\xa5\x6d\xd3\xdc\xb7\xaa\xbb\x2f\xd9\xc8\xf7\x4f\x84\x8c\xf3\x44\xdd\x39\xab\x6f\x71\x8e\x3f\xb3\xe4\xfc\x99\x5f\x3f\x74\xe4\x73\xfc\xa7\xe1\x93\x2b\x9c\x73\x8f\x0a\xb9\xb8\xe7\xf0\xa7\xd8\xa3\xb2\x7e\x96\xac\x9f\xa5\x6d\x63\xe9\x9e\xb6\x77\x23\x4c\xff\xae\x15\xd3\x7b\x72\xdf\xc4\x9d\x87\xdd\x6c\x9f\x72\xc6\xe8\x0b\x4b\x37\x3f\x72\xf2\x81\x37\x2e\x13\x97\x8f\xd8\x2f\x54\xdb\xb8\x7e\xe6\xd8\xa1\xb2\x8d\xaf\x7a\xf6\xa7\xe7\xed\xbd\x4a\xc6\x8d\x79\xd5\x69\x54\xb9\x68\xb5\xf7\x8e\x59\x19\x31\x1f\xe6\xbd\xd6\x3b\x7f\x8c\xc6\xbe\x52\x2f\x25\x44\xfb\xba\x67\xff\x31\xa4\xb6\xa4\xe7\x09\x3f\x7e\x3c\x96\x6f\xe7\xf7\x88\x27\x95\x3c\x25\x58\x9d\x93\x95\x2d\x46\x0b\x1a\x60\x42\xa9\x56\xd2\xce\xf5\x6f\x13\x75\x63\x6c\xf7\xfe\x02\xbc\xd7\x18\x8a\xcf\x7d\x3d\x5d\x16\xa5\xff\x78\x60\x87\xfa\x2e\xaf\x39\x7c\xe1\xfc\xb2\xac\x77\x0b\xd7\xef\xe6\xdb\x9b\x92\xe3\x4b\xa6\x56\x95\x8f\xaa\xa9\x4c\x6c\x9a\x29\x75\x7e\x09\x8f\xb3\xa7\xa4\xce\x1f\xf0\x5e\x7f\xcf\x20\x5a\xa2\x5d\xe2\x5a\xc4\xe3\xbd\x16\x11\x3a\x9b\x3f\xcc\xde\x56\x8b\xbd\xf2\x6e\x37\xa8\x5f\x5e\x63\x63\x22\xf9\xf2\x8b\x4b\x7b\xf6\xea\x5f\xa9\xc5\x63\x7a\x76\x97\x10\xf7\xbc\xd5\xde\x27\x7a\x56\xb2\x67\x65\x8c\x93\xeb\xda\x1f\xc8\xca\xcf\x4c\x5b\xbc\x2a\x33\xdb\x7f\xaa\xdf\x48\xf7\x05\xdb\x78\xe0\xa6\xeb\x4d\xf7\x61\xc7\x9e\x5a\x75\x5f\xcd\xc2\xb2\xe8\xeb\x8b\xae\x2c\x9d\x7c\xfc\x31\x89\x8e\xa1\xb7\xf5\x5c\x55\x42\x8f\xfa\x6b\xc1\x25\xff\xe8\x59\x59\x98\xfb\xd2\xd8\xd6\x56\xd6\xb9\xfb\xa7\x07\x8f\x7b\x28\xea\xfa\xe8\x76\xba\x90\xad\xf3\xce\xb7\x4e\xba\x2b\x3d\xcd\xfb\x81\x81\xa2\x73\xf7\x29\xf7\x5c\x54\x07\x32\xe6\x0a\xf7\xc7\xf8\xb9\x72\x02\xbf\x52\xfa\x7c\x69\x6e\x95\x27\xe7\xe5\x90\x45\xdc\xa1\x63\xe3\xe8\xc9\xf9\xf3\xd7\x14\x07\xa7\x9f\x39\xee\xbe\x0b\x1f\xe3\xa7\x14\x4d\x1c\x71\x43\xad\xb1\x47\x97\xed\xae\x96\xed\x7e\x23\x0e\x92\x71\xcd\xfe\xd5\x43\x87\x68\x4a\x69\x26\x61\xfe\x4b\xf5\x44\x66\x6e\x6e\xda\x47\xab\x72\x1f\x20\xf9\xf7\xbb\x0b\xfd\xc7\xab\x94\x07\xdc\xdb\x40\xfb\xcf\xba\x7a\x0f\xbf\xf7\xaf\x94\xca\x98\x21\xe2\x1e\x28\xde\x29\x99\x89\xfe\xd9\x75\xf7\x85\x74\xee\x0b\x10\xc8\xea\xa2\x69\xc7\xad\x59\xb5\x30\xc0\xe8\xec\xa9\xfb\xe7\xdf\x3d\xf9\x86\xad\x9d\x09\x91\x51\x77\xd8\x71\x6d\x45\xe4\xf0\x62\xba\xf0\x9c\xb9\x1d\xa1\x8a\x03\xa6\x8d\x8f\x84\x6a\xd2\xb6\x76\xad\x3c\xd0\x98\x75\xd8\x7c\x7b\x46\xd9\x65\x6e\xbf\x8f\xa4\x55\xec\x0b\x69\xdf\x7e\xca\xa1\xd5\xe5\x25\xb9\x39\xb9\x39\x1f\xad\xca\xce\x7d\x31\xf7\x9d\xdc\xcf\x73\x79\x76\xee\xe8\xdc\x69\x32\xb3\x37\x57\x04\x58\x6e\xae\x92\x39\x72\xd4\xc8\xa9\x23\x59\x26\x1f\x39\x7a\xf4\x88\x8f\x56\x8d\x96\xa6\xdf\xa7\x04\x3e\x5a\x25\xa4\xe5\x43\x52\x06\x42\x1a\x9e\xe7\x5f\x83\xd8\x80\x87\x77\xfa\x6f\x2b\xf3\xde\xd4\xe0\xbf\x8e\x29\xe2\xdf\xd1\x95\xd2\x9d\x21\xd9\xc4\xed\x13\xa1\x1b\x8e\xd9\xfa\x12\x71\xe4\x34\xac\x99\x5c\x50\x62\xcd\x0a\x5a\x53\xa6\x66\x3f\x3e\xe1\xea\xe3\x5b\x3b\x77\x92\x63\x44\xfe\x0e\x5a\xb5\x6e\x2b\x2b\xcc\x13\x6b\x97\x94\x4f\x18\x77\xc2\xa8\x39\x13\xad\xca\x70\x46\x67\xe7\xf2\x05\x57\xcc\x50\x47\x6d\x28\x6d\xda\xe2\xc6\xc5\x07\xd1\x05\xec\x6f\xde\x3b\xd9\xf2\xdc\xa7\xc6\xc8\x08\x2d\x9b\x7f\xb0\x2a\x47\x17\xd9\xd9\x24\x5d\x53\x1f\x96\x63\xe9\x9e\x2a\xf0\xde\x1a\x66\xa6\xbe\x21\xcb\x7f\x14\xa1\x7b\x52\x85\xc9\xd8\x4c\xba\xd8\x8c\x84\x59\x6c\xf4\x63\xa3\x7b\x6e\x1b\x45\x2e\xfb\xcb\xca\x25\xc5\xf7\xe6\xce\x0e\xad\xbf\x6b\x42\x3a\xfd\x74\xfb\xf6\x8b\xc8\x53\x3d\xb3\x2e\x21\x8f\x8c\x58\x52\xbf\xe9\xe9\xb0\x6c\x70\x1b\xad\x66\x9f\x4b\xdc\x31\x4a\x43\xf5\xd4\x2b\xf3\x77\xe4\x3f\x9a\xcf\xce\xc9\x27\xf9\x23\xb2\x87\xce\xcd\xce\x27\x59\x3c\x3f\xa7\x50\xba\x78\x44\x76\xe1\xe8\xc2\x69\x85\x6c\x2c\x2b\x2c\x54\x86\x0c\x19\xfe\xf1\xaa\x21\x72\x7a\x55\x67\xb8\xde\xfc\x50\x90\x65\x82\xf4\xfa\xd4\x7f\xf1\x53\xff\x55\x1d\x13\x0e\x2e\xf5\x5e\x81\xe1\xb9\x75\xa8\x7f\xb4\xfa\x6f\xbb\x18\xe7\xbd\xd2\xd3\x3f\x0b\xea\x79\xf3\xc8\xcd\x7f\x18\x35\xba\x64\xda\x88\x92\xe2\xc8\x98\x07\x8e\x27\x2f\x14\xf7\xbc\x3c\x2d\x74\xf8\xca\xc3\xb5\x11\xb7\xd1\xea\x78\xa3\x9a\x9d\x3d\x75\xac\x19\x2d\x9e\x54\x30\x89\xdc\x7f\xd9\xb5\x65\xab\x96\x4f\x18\xb3\xd5\x7b\xc7\x30\x79\x8c\x2e\xe4\xfb\xc9\xbe\x64\x28\x23\xee\x77\x2f\x41\x7c\xbc\x4a\x7b\x48\xfa\x4d\x21\xbd\x17\x43\xdd\x60\x7e\x16\x75\x1f\xcb\x2d\xe7\x22\x3d\xff\x8f\x43\x97\x9c\x72\x6e\xcf\x16\x39\xe3\x46\x5e\xb9\x6d\x2e\x5d\xd8\x76\xf7\x9d\xe7\x5e\x76\xd6\x75\xb7\xde\xac\x30\xd2\x29\xfd\xf2\xa5\x9c\x67\x69\xca\x70\xc5\x50\x0e\xb8\xbb\xb4\x38\xd3\x7d\x25\x44\xf1\xf0\xc2\xb9\x99\xd5\xd9\x1a\xc9\xd6\x46\x6b\xd3\xb4\xcf\xb5\xbd\x9a\x9c\x6a\x9a\x36\xa2\xa4\x84\x7e\xb4\xaa\x44\x4e\xb0\x7b\x47\x0c\x91\xee\xf2\x7c\xb1\xaf\x23\x36\x14\x3e\x5f\xea\x1d\x1b\xfe\x59\x5e\xef\x05\x77\x56\xdf\x93\x74\x67\xb9\xcf\xc5\x74\x2f\x64\x86\xfa\x5f\xd4\x9e\x4d\xbc\x5b\x36\x29\x0b\x86\xf6\x9b\x1a\x2a\x9e\x98\x37\x71\xee\x04\xa3\xa0\x78\xbf\x49\xe5\x05\x67\x6c\x39\x7e\xf5\xa1\x87\x2d\x3c\xe7\xd0\x8d\x9b\xae\x21\xb3\xc2\x53\x97\x1f\xc3\x2f\x8d\x2c\x28\x9b\x39\x76\x4e\xcf\xbb\x75\x93\x56\x8d\x29\x1e\x5b\x72\x78\xcf\x4f\xab\x56\xad\xde\x3c\x94\x19\x2b\xaa\x3b\xf6\x5f\x3a\xff\xfc\x3a\x96\x35\xcb\x0c\x75\x2e\xd8\xcf\xe5\x87\x2f\x7a\xce\xdf\x5b\xb1\x37\xaa\x30\x25\xed\x6e\xb6\x8d\xba\xec\xe0\x9f\x43\xd9\xf3\x85\x7b\x62\xa1\xe7\x7c\xef\x24\x02\xe9\x79\x95\xdf\xac\x6c\x15\x3f\xc9\xb5\x6c\xc8\xae\x8c\xec\x6c\x41\xb5\x6d\x59\x1e\x07\x19\xde\x19\x39\xb7\x07\xde\x63\x81\x3d\x73\xdd\xe5\xa5\xfc\xd8\x9a\xaa\xb4\x59\x35\x67\x9e\xf3\x97\xc0\x51\x43\x67\xaf\x12\x87\x56\xa4\xb5\x66\x38\x35\xc7\x15\x18\xed\x13\x24\x27\x48\x05\xca\x23\xde\xf3\xd3\x47\xba\xd7\xc1\x16\xaf\x0a\x64\x2b\x82\x89\xc5\xab\x58\xff\x05\x9c\x8a\xf2\x12\x39\x27\xdc\x67\xa7\x47\xc6\xd0\x57\x48\xb4\xe4\xa7\x9f\x4a\xc8\x19\xa7\xf6\xbc\x5d\x42\xf7\xdf\xbd\x7b\x37\xdd\xbd\xdb\x7b\x86\xe6\xde\x1d\xe2\x21\x5a\xa6\x95\xe2\xb7\xcc\x43\x76\xe9\xe9\xdb\xa8\xaa\x0a\xf7\xfc\xa4\x99\xeb\x9f\xd7\x74\xcf\xa1\x0a\xf9\x99\x28\x1b\x24\x0f\x6f\x2f\xde\xde\x93\x94\x7f\xae\xa1\x8d\x23\xf7\x5c\x21\x1e\xba\xf4\xd2\x4b\x5f\x3f\xbd\xbf\xad\x4c\xd9\x96\x7b\xef\x7b\xa6\x8c\xfc\x03\x7a\x46\x86\x26\x24\xef\x49\xe2\x34\xdf\x2e\x7c\x1e\xb7\xd5\x68\x62\xdc\x6c\x92\x8f\x46\x69\x26\xeb\xf9\xe9\x62\x76\xc3\xf5\xbd\xed\x6a\xa5\x39\x97\x65\x5d\xde\x73\x8e\x6c\x77\xa0\x7d\x39\x52\x81\x66\x66\x05\xb6\xe5\xac\xcd\x20\x19\x29\x56\xbe\x7d\x98\x81\x53\x66\x7e\x9b\x25\xa6\x74\xe3\xc4\x88\x39\xbc\xdf\x5a\x32\xe9\x72\xfa\xe9\x93\xf7\xb3\xcb\x4f\xf7\x2d\x4e\x3b\xe7\xac\x8c\x3a\xb7\xfd\xdb\xc4\x43\xe4\xd5\x54\x9b\xd3\xdc\xc7\x06\x6e\x63\x99\x01\xd9\xf6\x9b\xbd\x36\xe7\x0f\xd7\x64\x83\xee\x8d\x07\x25\xf2\xf3\x4e\x9c\x5d\xfc\x2c\x0b\xba\xcd\x9e\xe9\x59\x7c\x79\xd6\x65\x39\xaf\xbb\x06\xd3\xbd\x77\xa4\xd8\x9b\x75\xaf\x50\x7b\x4f\xf5\xc2\x3c\x77\x50\x08\x73\xad\xba\xa5\xd7\x7f\xae\xf7\xe8\xde\x6e\x71\x1f\xea\x15\xb9\x56\x10\x3a\x42\xcf\xd9\x36\x34\x9d\x2b\xd3\x9e\x32\x0b\xdf\x32\x9e\x7a\xda\xf0\x4e\x44\x8e\x11\x63\xfd\x07\xbf\x8e\x73\x9f\xf4\xeb\x3d\xdc\xd2\x25\xec\xb0\xd7\x18\x39\xc1\x5a\xb0\x70\xfc\x54\x2b\x67\xf5\xc8\xca\xe5\xb3\xc7\xd7\xec\x1f\x2e\x2c\x37\xb2\x0e\x1d\x55\xb9\x44\x2b\x3d\xfd\xd3\x09\x25\xe3\x26\x2d\x9e\x37\x79\xf8\xa8\xe1\x13\x4a\x96\xcd\x99\x28\xe7\xe5\xeb\xfc\x54\xba\x5e\xac\xf1\xc6\x9d\xeb\xba\xb2\x2d\x4d\xa5\xae\x47\xa5\x33\xf1\x78\x56\xf7\xfd\x00\xde\x87\xae\x3f\x71\x62\xc1\x2b\xf6\x24\xf9\x99\x58\x2e\xd6\xbc\x9a\x90\xff\xdc\x67\xf9\x93\x53\xa5\xce\x78\x44\x7c\xa3\x64\xbb\x1a\x49\xdb\x96\xe6\x3e\x72\xd7\xef\xad\x77\x8b\xb2\x2b\x2b\x4c\xc3\xbd\x85\x84\xfe\xfd\xd8\x8b\x1d\x29\x2a\x2e\xda\x51\xfe\xee\xe4\xcf\xf8\xf6\xd9\xed\x2b\x27\x4e\xb6\x2e\xf8\xfd\xdd\xd7\x7a\xe7\xf1\x4f\x12\xcf\x52\x8e\x71\xc8\xba\x57\x61\x47\xe8\xee\xa4\x29\x7c\xf3\xf9\x5e\xe7\xbb\x67\xca\xdf\xf3\x1c\x4f\x7a\xf6\x5c\x31\x92\x36\xfa\x6e\xef\xb9\xea\xf4\xbe\xfa\x99\xfd\xf5\xe9\x11\xee\x53\xc2\xfd\xfa\xfe\x84\x13\xd2\x79\xbd\x93\xad\xe7\x34\xcf\x5f\xfe\x54\x7b\xad\xcf\xff\x23\x64\xfd\x11\x4a\xb1\x8c\x3d\xd2\x0a\x46\x56\x0f\xe1\x19\xdb\x72\xdd\x5b\xd9\xfd\x01\x28\x7c\xdb\x6d\x6a\x50\xef\xe7\x7b\x00\xc4\xf8\x6f\xde\xbf\xc2\x47\x15\xf7\x0d\x18\x02\xb2\xd1\xc5\xf7\x8f\x9d\x7e\xfc\x22\x25\xa8\x8c\xa9\xce\x1a\x5d\x54\x54\x58\x58\xfc\x0b\x2b\x5e\x30\x70\x14\x0d\x6a\x49\x04\x47\xc0\x7f\xb7\x25\xd9\x7b\x44\xfc\xc2\x9a\xb7\xbd\x23\xce\xf5\xc5\xab\xe2\x47\xba\xd4\x9b\x8b\xae\x2f\x03\x84\x79\xca\xf7\x4d\xe3\x29\xff\x1a\x87\x54\x1f\xe3\x22\x64\x93\x3b\xfd\x77\xf3\x9e\xee\x8b\x19\x99\xa2\x5e\x70\x69\x4e\xcf\x3b\x59\x64\x9c\x57\xff\x4a\x79\x0c\x30\xaf\x7e\x86\x92\x77\x3f\x23\x3c\x6d\x5b\x86\xee\x8e\xc6\x5b\xc6\xd3\x38\x0e\x86\xf7\x1d\xa2\xd3\xb6\x8f\xda\x5e\x74\x39\xfd\xe4\xc9\xfb\xe9\xe5\xa7\xcb\x76\x5e\xc3\xa1\x29\x7d\x72\x7c\x5f\x3b\xfe\xda\xe4\x5e\x16\x13\xdb\xf4\x74\xff\x80\xf2\xe7\x28\x3a\xec\xde\xa7\x45\x3e\xe8\xed\xdb\xf7\xde\xf0\xca\xc6\x2e\xbd\xf4\xa3\xd3\xfd\xeb\x6c\xbd\x6b\x66\xae\x52\x51\x5d\xc0\xd2\x33\xd2\x97\xae\x22\x72\x75\xca\x71\x6f\xc9\xca\xc9\xe6\xba\xa6\x2f\x5e\xa5\xa5\x5c\xff\x4e\xbd\xd8\x48\xbc\xbb\xb1\xbc\xd5\xd4\x3d\x95\xeb\x8a\xcc\x8a\x77\x26\xbd\x63\xf6\xae\xaa\xe6\x5b\x93\xde\x9a\xea\xad\xac\x92\x0f\x7b\xbe\xdb\xbd\x9b\x04\xfe\xf8\xaf\xdd\x7e\xec\x39\x6d\xef\xa7\x22\xa4\xcd\xcc\x9b\xc0\xd6\xba\xe7\xd2\x02\xf3\x89\xb2\xf7\x3f\xb9\x9a\xb6\x9d\x4c\x24\x1b\xe4\x7a\x96\xc7\x59\xa4\x3a\x2f\x6f\x6e\xa4\x3a\x2d\x63\x6e\x84\x96\x96\xe6\x4e\x50\x64\x6c\x95\x5b\x5a\x1a\x0a\xfd\x5a\xfd\x6b\xc8\xfc\xff\x4f\xf5\x77\x90\xfd\x7a\xeb\x4f\x77\xeb\x4f\x77\xeb\x4f\xff\xdf\xeb\xef\x24\xd5\xff\x7f\xd4\xbf\x16\xf5\x27\xd0\xcb\x5e\xfc\xce\xeb\xfd\x14\xf2\x8a\x5c\xe7\x32\x39\xab\x95\x4b\xee\xdc\x5a\x3a\x79\x72\x6f\xc5\x5f\xab\x77\x0d\xd9\xff\xff\xa9\xde\x0e\x32\xb6\xb7\x9e\xed\xd6\xb3\xff\xc7\x7a\x3b\xc9\xb0\xff\xa3\xde\xc3\x7b\x3f\xe5\xfb\x6b\xb3\x64\xbd\x75\xbe\x7f\xe4\xce\x6f\xbd\x1e\x5a\xa4\xd3\xf5\x0f\xa3\x41\xd7\x3f\x41\xd7\x3f\x41\x32\x64\xc8\x00\xff\xb8\xf5\x4f\x1c\xa4\xfe\x35\x64\xee\xff\x5c\x7f\x30\xfc\x1d\xfd\xf8\xe3\xdc\xfa\xe3\xdc\xfa\xe3\x06\xaf\x7f\xf4\x20\xf5\x77\x92\x9a\xff\x19\x7f\xbe\xe7\xb7\x75\xfb\x8c\x2f\xc6\x89\xd1\x52\xd7\x6f\xa5\x24\x2f\xef\x97\x7e\xeb\xf8\x45\xbd\x6b\xa4\xd5\xff\x77\xbd\x5f\xe2\xed\x90\x2a\x0f\xf5\xca\xdc\x7a\x65\x83\xd6\x5b\xa1\xdd\x38\xa0\xde\x4e\x52\x48\xfe\xf6\xab\xf5\xd6\x79\xfe\x71\xe7\xff\x46\xf8\xe7\x4b\x8c\xef\x34\x7f\xfe\x33\x3a\xc9\xf5\xcf\x24\xd7\x3f\x93\x48\x51\xd1\x00\xff\xb8\xf5\x4f\x1e\xa4\x7e\xdf\xf1\xfb\x3f\xd4\x1f\x0c\x7f\x07\x99\xd4\x5b\xbf\xd4\xad\x5f\xea\xd6\x2f\xfd\x6f\xf5\x0f\xf8\x45\xfd\x9d\x72\x84\x8e\xfd\x9f\xeb\xdf\x80\xfa\xd2\x6f\x9f\xf9\xe3\xbb\x80\xbc\xee\xfb\xcd\x74\xfd\x66\x92\xc2\xc2\x5f\xfa\xed\x2c\x6d\xc7\x80\x7a\xd7\x90\x83\xc8\x7b\xff\x67\xbd\xa3\xbd\xf1\x4d\xad\xb7\x83\x54\xf4\x8e\x6f\xd8\xad\x17\xfe\x1f\xeb\xed\x94\xe1\xf3\xaf\xd7\x73\x79\x61\xb7\xeb\x5f\x65\x81\x7b\x9e\x2b\x50\x47\x4e\x51\x2e\x56\xd2\xee\xa5\xf9\xf9\xd4\x2b\xe8\xdd\x37\xb5\x92\x9f\x2f\x0e\x91\xbc\xbc\x5f\xf5\xb0\x61\xf9\x05\x05\x59\x6b\x56\x15\xf0\x21\x6c\xb4\x9e\x9f\xa7\x88\xe8\x2a\xda\x77\x46\xc2\xec\xbd\x19\xcf\x23\x68\x9c\x94\x48\xbd\x11\x4e\xeb\xbb\x49\x8e\x92\xaf\x56\x35\x4f\x5e\x58\xde\x10\x2b\xb8\x22\xb7\x66\xce\xf2\xe3\x0b\x6e\xf4\x6e\x11\x19\x12\xac\xd9\x11\x3b\xfd\x37\x39\xb7\x2f\xee\x59\x99\xff\x52\x7a\xdb\xf1\x6c\xcc\x21\x33\x96\xcc\xbb\xe2\xf8\x9f\x6f\x17\xf6\x8d\xab\x8f\xb8\xef\x86\x03\x96\xfd\x7c\x56\x4f\x5c\xda\x55\x2c\xed\xfa\xbb\xf7\x9e\xc9\x31\xd5\x39\xf9\x81\x2c\x36\x34\x47\xcf\xcc\x53\xf8\xda\x7d\x2c\x32\xfd\xb7\x88\x4b\x73\x86\xbb\xa7\x77\x08\xf5\x0c\xc9\x77\xcf\x96\x10\x29\xcb\x4e\x88\xd5\x4d\x34\x42\x55\x63\x47\xf4\x7c\x52\x9c\xb6\xad\x67\xaf\x34\xe1\xa0\xf7\x86\x8d\x58\x43\x94\x9e\xf7\x8a\xae\xec\x59\x19\x78\x9a\x17\xd7\x1f\xcb\x3e\xef\x79\xb1\x62\x4f\x87\xb0\x7f\x7e\xec\xdd\x2d\xe4\xa3\x1f\xf7\xbf\xf8\x02\x9f\x57\xc3\x7b\xbf\xe6\xcf\x48\xdf\x8c\x56\xa6\x54\x0f\xcb\x1b\x2a\x75\x60\xf6\xa8\x9c\x51\x6c\xcd\xaa\x51\xf9\x43\xd3\xd6\xac\x1a\xca\x73\xd8\xbe\xf7\x7c\xb9\x37\x9f\x4a\x73\xbc\x33\x60\x79\xbe\x67\xb2\xdd\x2b\xf4\xbd\x9e\x49\x23\x7c\x5c\x90\x91\xc5\x5a\x53\x62\xc3\xf5\x87\xac\x8a\x76\xdd\x38\x62\x5c\xcf\xcb\x27\x7e\x19\x5c\xf0\xca\xd1\x9f\x9e\x12\xbd\xab\xe7\xc7\x3b\x7b\x16\x17\x92\x67\x8e\x6b\x7b\x95\xdc\xb2\xaa\x71\xf5\x35\x47\xdf\x4f\x6f\x92\x7e\xf9\xe1\x9c\xa3\x7b\xe6\xf7\xbc\x7f\x36\xd9\xee\x6a\x90\x9e\xa7\x95\x66\x32\x89\xb5\x4b\xdd\x50\xa0\xe4\xdf\x95\x9d\xf6\x30\xd9\x5f\x19\xa6\x70\x32\xd3\x0b\xfe\xdd\x3b\x8b\x7b\x5f\x1d\x68\x1a\xcc\x7f\x6b\x20\x62\x48\x32\x29\xba\xa3\x29\xb9\xe5\x0f\xb7\x7d\x76\xf7\x84\x09\x65\xcb\x2a\x26\x4e\x9a\xba\xb4\x9c\x36\x5d\xf0\xcf\x13\x4e\x3b\xe9\x9f\x24\xa7\x67\xcf\x9c\xf0\x9a\x9d\x6d\x73\x2a\x1b\x6e\x73\xcf\x53\x2d\x51\x36\x28\x3f\xb1\x06\x45\x55\x0a\xef\x27\x94\xbb\x4f\x80\x7f\xc8\xfb\xb5\xc1\x0c\xf7\xae\x25\xf7\x17\x05\xb2\xb7\x13\xf3\xb5\xd9\xc4\x64\x0b\xbb\x5f\x19\xf9\xcf\x1b\x2e\xd8\x40\x0f\x69\x3b\x7d\xeb\x9e\x2c\x2f\x36\x3c\x4d\xe9\x24\x96\xb4\x73\xa4\x32\xea\x5e\x2d\x2f\x3d\x90\xfd\x00\xd9\xff\x1e\x52\x50\xa0\x3c\xe0\xb6\x60\xb8\x67\x9d\x4c\xef\x3d\x81\xde\xa9\x20\xef\x2d\xbd\x7d\x27\x4f\xb2\x88\x7b\x0a\x75\x8c\xd6\x73\xda\xb0\xd2\x4d\xdb\xe6\x74\x2e\x39\x64\xfc\xbd\x13\x6f\xdb\xb2\x69\x6b\x78\xf5\xb1\xc6\x61\x85\xa4\x73\x64\xe7\x86\x19\x6d\xcb\xcb\x17\xda\x75\x31\xbd\xab\xf3\xb0\xe5\x55\xd1\x65\x07\x05\xab\x83\x67\x48\xdc\x5b\x95\x26\x52\x29\x71\x27\x28\xe3\xab\x03\x25\xb9\xb9\x79\x79\xac\xa8\x20\x28\xc1\xef\x4e\xd7\xd9\x03\x9e\x9b\x7a\x4f\x92\xe4\xf5\xbd\x6a\x24\x34\x9b\xe0\x6c\x8e\x77\x32\xa7\x77\x62\xf7\xda\xa3\x0d\x23\xfa\xae\xed\x47\x9f\x4e\x1e\x6a\x9a\xed\x1c\x57\x3b\x72\xf6\x01\xf3\x4b\xf7\x9b\x5a\x97\x79\xcf\xf8\x3b\x37\x27\xb7\xdd\xb6\x95\xb4\x6c\x3a\x63\x7d\x4b\x7e\x76\xfa\x9a\xaa\xd0\x82\x33\xaa\x2a\x82\x13\x8c\x69\x99\xf1\xae\xd5\x4b\x2e\x0e\x17\xb9\x63\x76\xb2\xf4\xc5\x44\xe9\xcb\x34\x25\x4b\xce\xe8\x34\x85\x73\x5d\x64\x66\xd2\x74\xd5\xf5\x28\xf5\x3d\xea\x9f\xb5\xf1\x62\xb2\x94\x53\x36\xd9\xc4\xbc\x76\xd4\x8e\x51\x3d\xe7\x8d\x20\xbb\x9e\x38\xb4\xb5\xe0\xf7\x93\xdf\x79\x91\x68\x17\x5d\xb4\x95\xbc\xd7\x53\x72\x1c\xb9\x6e\xda\xd7\xae\xaf\x6f\x94\x73\x62\xb6\x6c\xdf\xfd\xfd\x47\x20\x2f\x27\x67\x44\x61\x21\x1b\x3e\xe4\x01\x32\xfd\xee\xb4\x94\x3e\x7b\x08\xfe\x6f\x7d\xdc\x3e\xcf\x24\x91\xbe\x9f\x1e\xa5\x9c\x68\x21\xf9\xcf\x5e\xbf\xf5\xa4\x5d\x22\x5a\xbb\xd4\x2c\x9f\x15\xbe\xad\x93\x7c\x57\xd0\xb3\xb3\xb4\x66\x61\x4b\x92\x6c\x3f\xfd\x8e\x75\x31\x35\xeb\x90\xc5\x76\xa9\x31\x8d\xdc\x79\xdc\xe5\x25\x09\x6f\x4e\xfe\x56\xe2\x97\x4b\x9f\x0f\x53\xc6\x28\xa3\x77\x15\xe4\x0d\x19\xc2\xb2\x33\x03\xee\xcc\x1c\xad\x30\xcc\x4c\x17\xbe\xaa\x0f\xdc\x9b\x9e\xbd\x77\x06\x86\xbd\x1b\xb4\xfa\x7e\xec\x49\xd2\x76\x5d\xb1\xf9\xe8\x57\x1f\x6e\xec\x08\xdc\xa5\xd5\x57\xad\x18\xee\xac\x5f\xd3\xfa\xe0\x21\xd3\xe7\x4d\x9d\x32\x63\x2e\xb9\xe2\xd4\x1d\xde\x74\x5d\xde\x34\x74\x5e\x43\xe3\xac\xe6\xe4\xea\xb9\x33\xcb\x66\x2e\xf5\xee\x45\xe2\xd2\xcf\x87\x4a\x3f\x64\x28\x43\xee\x09\xa8\xaa\xe6\xba\x97\xf8\xee\x75\xfb\x3d\xb1\xff\xfc\xce\xec\x47\xf3\x97\x1c\x7d\x73\xcf\xe6\x91\x74\x7a\xc1\x15\xc7\x2d\xed\x5c\x73\xeb\x2d\xf7\x9e\x71\xdc\xce\xfb\xee\x70\xf5\xb9\xe7\xcf\x90\xec\xcf\x70\xef\x0d\x98\x63\xab\x03\x81\xa1\xe3\xc6\x15\x17\xb3\xc2\x6c\xb7\x4f\x93\xfa\xfa\xe4\x4f\xa2\xfe\x59\x64\x85\x23\xa9\x3f\x5a\x2b\xf6\xce\xe1\x78\x13\x8b\xf5\x9e\xd7\x21\xda\x83\xd7\x1d\x7d\xea\xe1\x4b\xa6\x4c\xd9\x79\xc1\xb1\x9b\x96\xda\x15\x55\x67\x1f\x94\x3c\x68\x56\x78\xca\xda\xea\xb9\xd1\xd3\x48\x62\xf3\x39\x0d\xab\x0e\x4c\x16\xe6\xce\x9f\xba\xee\xe8\xc3\x17\xd4\xad\x2b\xc8\x9a\x4b\xf4\xfa\xce\xb9\xf5\x3d\x5f\x1e\xe4\xd4\x2d\xf7\xe2\x98\x9e\xfb\xa4\x7d\x53\xa5\x7d\x43\xdc\x88\x6a\x57\x71\x7a\x7e\x66\x26\x1b\x91\xef\xce\xf1\x80\xb6\xcf\x78\xe7\xf9\x1e\xf7\xce\xc6\xbb\xa3\x1d\xe9\xfb\x45\x4c\xea\xaf\x6b\xc9\xd4\xd7\x1e\x69\x4b\xe8\x77\x06\xe6\x1c\x59\x5e\xdf\x71\x78\xcb\xee\xab\x3f\xbb\xaf\x74\xea\xf4\x79\x93\xf7\x9b\xb1\x80\xc6\xbe\xe8\xf9\xea\x90\xd8\xb0\x03\x1f\x9f\xb5\xfe\xf0\xf3\xae\xff\x72\xea\xac\x15\x35\xfb\x85\x17\xf9\xf1\x54\x83\xb8\x80\xa9\x9a\x2e\x63\xd3\x6c\x19\xc5\x10\xc6\x02\xd9\x08\x88\x9e\x37\xaa\xbc\xbb\x68\x4c\x19\x41\x46\x86\xfb\xb1\xb6\x9c\xd2\x74\xea\xeb\xac\xe7\xe7\x23\xe8\x12\x1e\x7f\xc8\xbd\xe5\x8c\x0c\x79\x4e\xd3\x33\xee\x4c\xbb\x63\xc8\x2d\xb7\x0c\x71\xef\x59\xa2\x3d\xef\x89\x0b\xc8\x0f\x7d\x6d\x0a\x4a\x33\xd4\x6d\x59\x69\x29\x6d\xe6\x6b\x5e\x7c\x65\xe6\xa3\x55\x46\x8f\x78\x9c\xbe\xfe\xbb\xe7\x6e\xe7\x2d\x8f\xd2\x9f\xe3\x5c\x5d\x91\x76\x67\xc6\xd2\x9e\xaf\xdc\x26\x3d\x1b\xcf\xa7\xd7\x69\xee\x39\x96\x42\x65\x74\x75\xa6\x7f\x9a\x2a\x2b\x6b\x68\xc1\xb6\xe1\xf9\xbd\xad\xf6\x9e\xb0\xf2\xde\x49\x3a\xd1\x7b\x29\xab\xea\x36\x6d\xb8\xb1\x1c\x2c\x0f\x85\x8c\x29\xda\xac\xba\x53\x96\xed\xcf\x67\x66\x2f\xad\xed\xef\x80\x7a\x43\x71\x4e\xf5\x90\xc5\x46\xed\xf0\x03\x5f\xee\xed\x86\xc4\xdd\x2a\x2e\xa0\x96\xec\x47\x81\x32\x56\xaa\x91\x8c\xa1\x22\xb3\x3a\x2f\xa0\x14\x16\x6f\x2b\x1a\xeb\x47\x8c\xaf\xf8\x81\xaf\x77\x42\x81\xfe\x32\xe2\x95\xd0\x72\x69\x95\xae\x23\x07\x8e\xab\x9e\x51\x39\x72\xaa\x39\x20\xe6\x1d\x59\xb5\xe4\xe5\xeb\x2f\xa7\x9f\x3d\x79\x2f\xbd\x5c\x75\x64\xb0\xdb\x1f\xf4\x2e\x9e\x3f\xa9\xa3\x2e\xe3\xac\x73\xd2\xa4\x1d\xd7\x8b\x8b\xe8\x30\x2d\x4d\xfa\x33\xdf\x8d\xff\x95\x6a\xc6\xd4\x9c\xb4\x6d\x59\xde\xfd\x58\x6f\x3d\x25\x27\x89\x77\x72\xcf\x0d\x5b\x23\xc3\xdd\x55\xc1\xf4\x5e\xba\x63\x66\x11\x32\xe2\x7d\xfa\xc3\xf1\x74\xea\xd1\x67\xac\xe7\x6b\x96\xdd\x19\x5a\x5f\xfe\x90\x96\x96\x71\x7e\xda\x7b\x47\x27\x32\xeb\x23\x5b\x8f\x3a\xda\xeb\xe7\x80\xf6\x45\x35\xa5\x83\xb5\xef\x0d\x1a\xdb\xb7\xfd\x10\x3d\xfe\xb7\xf4\xfd\x49\x29\xed\xab\x1b\xd3\xce\xcf\xe8\x39\xa3\x1f\xa0\xbf\xfd\x4c\x65\x94\xeb\xc7\xfc\x9c\xa1\x45\x23\x47\x2a\x69\x7c\x9b\xee\x9d\x91\xf1\x10\xcc\xe7\xbc\x8b\x57\xfb\xb4\xce\x52\xc6\x52\x2e\xea\xc6\xed\x29\x30\x53\xe5\x58\xea\xb3\x6b\x4f\x5d\xb1\x74\x5c\xfa\x52\x71\x51\x2f\x1c\xc9\xf7\x46\x32\x32\x33\x22\x71\x2f\x93\xb8\x96\x87\x5b\xe2\xe2\x8e\xc9\x2f\xa8\x2e\x1e\x96\x95\x82\xdb\x37\x7e\xfb\xe2\x46\xbc\xd1\xf4\x2f\xa1\xf5\x0d\xe6\xce\xc6\xc4\x72\x75\x61\xdd\xa9\x53\x96\x4f\xb8\xb0\x66\x5c\xcd\x8c\xaa\x91\x8b\x8b\x57\x8f\x8e\xaf\x1c\x5f\x3b\x33\x52\x58\x5e\x91\x7e\xe8\xc8\xd0\x41\xe2\xa2\xc6\x95\x19\x93\x4a\x97\xae\x8d\xbd\x91\x3f\x2c\x7f\xc6\xca\x3a\xf9\x77\xf4\x28\x3b\x52\xec\x1f\x6b\x99\xfc\x6a\x46\xd5\x09\x38\x2e\x14\x79\xac\x65\x0d\x3c\xd6\xbc\x21\xec\x3f\xd6\x26\xbf\x4e\xbf\x4c\xd2\x15\xe2\xea\x1b\xf9\xf7\xdb\x05\xa9\xfe\x40\x9d\x20\x0f\xb5\x07\x8b\x1e\x7f\xbc\xc8\xbd\x14\x25\x8f\xb5\x0b\xf9\xd5\xe4\x87\xbe\x36\x07\x39\xd6\xd8\x80\x63\x6d\x3e\x4d\xde\x4e\x5f\x7f\xef\x83\xa7\xd4\xed\x3b\xf8\x97\x57\xab\x22\x29\x8f\xb5\xa9\x3d\x4f\xb8\x6d\xfa\x36\xd2\x27\xd5\x6e\xf7\xfc\xad\x32\xbd\x3a\x38\xac\xa0\x20\x3b\xc3\xbf\xec\xc2\x02\xb9\xd9\x23\x46\x8f\xa0\x39\x6c\xc4\x08\xca\x75\xaa\x9f\xb5\xda\x3b\x25\xd7\xfb\x6a\x39\xf7\x37\x5a\x87\x1f\xd6\x7b\x18\x02\xad\xc4\x2c\x49\x19\x44\xb7\x77\x52\xc4\x7c\x2d\xae\xbe\x8b\x7f\x26\xfb\x63\x7e\x40\x32\xeb\x67\x47\xd2\xe6\xaf\xda\xb1\x68\xa5\xb6\x3a\x6f\x76\x29\x7f\xb8\xe8\xe4\x93\x8b\x7e\x74\x4a\xf2\x17\x8f\x58\x63\x1e\x94\x3e\xe1\x70\x56\xd4\xeb\x3b\xba\x54\xfd\x49\x1e\x8b\xe3\x14\xab\xba\x68\xa8\x70\x2f\x5a\x4d\xcb\x64\x01\xe6\x1d\x94\x63\x8b\xc7\x16\x8d\x3d\x6b\x75\xf0\xc8\x22\x52\xe4\xfe\x38\xdb\x3b\x55\x92\xe3\x8d\xaf\x7b\x21\xf1\xbf\x1e\xa2\xf9\x7d\x76\x92\x15\x93\xe6\xd5\xcf\x1c\x39\xde\x18\x71\x54\xf1\xac\xc3\xeb\x27\x1f\x50\x3f\xa3\x70\xca\xb4\xfc\x2d\x05\xb3\xd7\xac\xec\xb7\x57\x7c\x3d\x6e\xf2\xb8\xa9\xb5\xad\x6b\xa7\x8f\xdd\x6f\xec\x74\xab\xb1\x65\x46\xcf\x33\x9e\xc5\xae\x8d\x8b\xa4\x8d\x09\xd5\x7d\xce\x44\xbe\xfb\x6e\xbb\xfc\xdc\x33\x57\xe7\xf3\x74\xae\xf0\xb3\x56\x7b\x33\xce\x37\xea\xe9\x52\x6f\xbe\x85\x22\xa6\x47\x2b\x11\x93\x92\x48\xc9\x18\x4d\x6c\xbd\xe6\x0c\x7a\xdd\xcd\x07\x37\x14\x5e\x7f\x70\xcf\xb1\x2a\x29\x25\x54\xef\x39\x96\x5f\x7d\x52\xf3\x7e\x69\x89\xe9\xb3\x7b\xfe\x45\xe6\x8d\xfe\xba\xf4\x23\x17\x67\xa1\xc4\xc9\xeb\xc7\xc9\x92\x38\x59\x3c\xed\xbf\xe3\xf4\x1d\x4f\x25\x91\x31\xc3\xb5\xa3\x6e\x3a\x95\x5c\x4f\x17\x1e\x7c\xe7\x84\xeb\xc6\xff\xf9\xcc\x9e\xd7\x75\x42\x9f\x57\xf9\xd5\xa7\x27\x46\xcd\x9e\xbe\xf9\xa4\xf3\xc8\xbc\x8f\x4a\xbf\x1e\xad\xf4\xf6\x67\xa8\xe6\xbe\xb3\x2f\x28\x15\xf4\xd0\xac\xdc\x5c\x41\xb3\x75\x12\x60\x7a\xce\xf0\xe2\xe1\xf9\xc3\xcf\x5a\x3d\x32\x1f\x13\xc0\xf5\xf5\x9a\xfe\xd1\xf7\xae\x1a\x40\x79\x79\xa3\x6e\xb0\x7d\x7b\x3c\xf2\x14\x63\x46\x60\x68\xcb\x94\x63\x4f\x69\x59\xa7\x5e\x9c\xfb\x9b\xed\xfd\x9d\x57\xd7\x46\xf4\x26\xae\xd9\xb3\x67\x2c\xd3\x8b\x0f\xe9\x39\xba\xcf\x01\x7d\x36\xad\x52\x7f\x90\xf3\x60\xa2\x52\x5e\x5d\x30\x70\x1e\x14\x97\x14\x17\x16\x9f\xb5\x7a\x6c\x61\x8a\x5d\xff\xd7\x1c\x20\xfb\x9a\x76\xe8\xa4\xf9\x75\xb3\x46\x8e\xaf\xf8\xe5\x3c\xe8\x79\xbd\xdf\x4a\xf1\xa5\x9c\x08\x53\xea\x52\x27\xc2\xce\x7e\x4b\x09\x29\x13\x17\x32\xa1\xde\xe8\x5f\x83\x66\x67\xf6\x5e\x83\xf6\x46\x80\x2e\x87\xd7\xc5\x85\xf0\x35\x21\x5c\x5c\xc4\x22\xea\x4d\x03\xcb\x7b\x33\x83\xf0\xde\xe9\x20\x2e\xf2\xe7\x00\x51\xce\x97\xe5\x8f\x54\x6f\x73\xef\xeb\xdd\xc5\x03\x34\x90\x72\x30\xa6\x1e\x7d\xec\xc8\x94\xb9\x7b\x17\x66\xaa\x5b\xff\x09\xc9\xfb\xb7\x78\xef\xb0\xc8\xdb\xa5\x71\x22\xa7\x8e\x4a\xfa\xeb\xfb\x4b\x46\xc4\xd4\xe8\xe6\x0f\x5e\x52\xb7\x3f\xc8\x3f\x90\x0b\xc5\x05\x3f\x8c\x3a\xf9\xe4\x51\x0a\x55\x1e\x91\xd8\x9d\xaa\xff\xee\x9d\xbc\x5d\x54\x28\xe2\xc2\xd5\xbc\x77\xe2\xb9\x46\x9b\xda\x18\xb7\x6e\x63\xe9\xdf\x4b\xf7\x74\x97\xbe\x5b\x2a\x2e\x7a\x43\xfe\xf3\x70\x37\x88\x66\x76\xaf\x7a\xbc\xd4\x65\x79\xf7\x0f\x11\x19\xdb\x72\x03\x7d\xe7\x8f\x53\xc7\x27\x65\xe5\x25\xf4\xaa\x29\x4b\x16\xd4\x17\x4f\x0b\x0d\x39\x6d\xd2\x69\xcd\x53\x97\x1e\x50\x37\xca\x30\x87\x9c\x52\x72\xa6\x68\x1e\x57\x3a\xce\x98\x7d\xd9\xf1\x32\xa9\xac\xba\xf8\x24\xef\x77\x1b\xd2\xb6\x8f\x7d\xbf\x4b\xdb\x02\xb2\x67\x67\xae\xd6\xfa\x7b\x96\xef\x3a\x45\x1b\xee\xfd\x7d\xe7\x6c\x8d\x64\x7f\xa2\x97\xfa\x89\xb8\x68\xec\xe7\xa5\x1f\xca\x8f\xef\x9f\x97\x65\x3b\xbf\x91\xfe\xcd\x94\xad\xa4\xcb\x1e\xa6\x1c\x5a\xfe\x5d\x09\xfd\x33\x86\x2a\x29\xd3\xe2\xa2\xd4\xe9\x2a\xdb\xb9\x98\xef\x66\x23\x45\x93\xff\x3c\x2b\xa6\x78\xf7\xf0\x4b\x9d\xbe\x8b\x36\x8e\xd9\x73\x85\x68\xba\xd9\x8d\xf3\xf7\xdb\xfb\x3b\xfe\x80\x7a\x5c\xce\x44\xfe\xc5\x9e\xa5\x7b\x3b\x73\x26\x88\xf4\x21\xde\xbd\x46\xe7\x2a\xca\xa4\xea\x02\x92\x3d\x34\x3b\x5b\x55\x4b\xe8\x68\x65\x74\x70\xf4\xe3\xa3\x19\x1b\x5d\x92\x51\x58\x42\x98\xd2\x7b\x7f\x24\xee\x85\x1b\xd0\x4e\xae\xea\xb6\xa3\xe4\x57\xa7\xf5\xb6\x80\x2a\xbd\xf7\x1e\x0d\xbc\xaf\xed\xf3\xbd\xaf\xb1\x34\xf7\x3e\xb8\xbc\x07\xf6\xfe\xf6\xfe\xbc\x21\x5c\x2f\x21\xf9\xbf\x72\x1f\xdc\x47\x5e\xf9\x82\xbb\xa9\x7b\xcb\xe3\x23\xbb\x8a\xdc\x1b\x9b\xa8\x57\xc3\xab\xe2\xd5\xa9\x97\x75\xde\x50\xcf\xc9\x9b\xa0\xbf\xeb\xdd\xcf\xf3\xf1\xc9\x8a\x32\xfc\x3e\xc1\x19\x75\x51\x5e\xb8\x37\x6f\x06\xc9\x75\x6f\xd8\x71\xff\xb9\xe5\x1b\x07\x94\xff\xec\x06\xd9\x83\x7b\xfc\xd2\x9f\xdd\x9b\x37\xbe\xb7\xb4\x5f\xf6\xfa\x7d\xca\x7e\xfa\xa0\x4c\xee\xf6\x8a\xbe\xdb\x5f\x54\x19\xec\xfe\xdb\xff\x72\x4f\xe6\xb8\xea\x80\x7b\x53\xe6\xe3\x85\x7f\x2a\x64\x0f\xec\xfd\xb6\x3a\xcd\xbb\x33\x33\xe5\x5e\x4b\xff\x1e\x4d\x19\x51\xcf\xeb\x39\x96\x9d\xb1\xf7\xdf\x72\x96\x0d\x97\x8c\x34\xcd\x7b\xa6\x72\x69\xf5\xf0\x19\xe6\xc8\x91\x55\xca\x18\x52\x3d\x66\xfb\x18\x3a\x66\xe8\xd4\x40\x20\x7b\xe2\x4c\xc6\xdc\x27\x14\xba\x3f\x6e\x7f\xf9\xb0\x0d\xee\xb5\x01\x39\xd5\x87\xa7\x3c\x28\x26\xf5\x01\x32\xda\x7f\x79\x98\x4c\xea\x7e\x2d\xdf\x64\xf3\xca\xc6\x8e\x2d\x2b\x0f\x06\xcb\x3f\x2a\x0b\x7a\x99\xb2\xcb\xe5\x9f\x69\xd3\xe4\x06\x5d\x51\x36\x36\x58\x5e\x2e\x73\x13\xcb\x82\x63\xa6\xc9\x8d\xb2\xd7\xe7\xb6\xcf\x59\xeb\x97\x9f\x36\x66\x6c\x99\x57\xf7\x8e\x60\x99\x57\xf5\x8b\xb1\x53\xa7\xca\x22\x65\x77\xe0\xbb\x32\xd2\xde\xe3\xbe\x93\x82\x2b\x8b\x7a\xb6\xb1\x8d\xb2\x8f\xcc\x7b\x72\xcc\x68\xf7\x8a\x2e\x21\xa3\x95\x02\x52\x5d\xb0\xbd\x80\x16\x17\x68\xee\x91\x2b\x7b\xe4\xfe\x94\x60\xb8\x9c\xd4\xbf\x66\x6f\x23\x99\x33\xa4\xe7\x01\x7a\xca\xa0\xa6\x85\xd6\xcd\x1a\xdc\x88\x7e\x1b\x34\xc9\x75\xee\x53\xac\x3d\x1b\x82\x8a\x7b\x1f\xeb\xf6\x51\x74\xd4\x18\xf7\x82\xcb\x73\xb0\x21\x3f\x22\xa3\x6e\x6d\x9c\xf6\x6b\x76\xdc\x50\x90\x18\x2a\x4d\x59\x3f\x82\x3c\x31\xa8\x29\x3d\x9f\x76\xaf\x5b\xd7\x7d\xcf\x7f\xf1\x09\x55\xc6\xed\xfd\x94\xbf\xae\x16\x4a\x6b\xca\xe4\xe1\x1d\x2e\xa3\x13\xb3\x98\xa6\xba\x6b\xd5\x2c\xca\x94\xe1\xc5\xd4\xfb\x41\x72\x19\x8d\xcc\x62\x11\xa6\x08\x6d\x02\x9b\x9e\xa5\x8d\x09\x05\xe7\x6e\x6d\xb0\xf3\xb2\xc4\xa4\xc5\x33\x9d\xf5\x0b\xcd\xe5\x64\x66\xde\xd8\xf1\x34\x6f\x78\xfb\x4d\xaf\x1f\x77\xec\xae\xd6\x60\xc1\x88\xb6\xcb\x77\x37\x7f\x4b\x0a\x69\xdd\xa4\x3d\xe4\x23\xbb\xbb\xe9\xe0\x49\x23\x16\xc4\x4f\x5e\x5a\xdb\x71\x50\xd9\xb4\x25\x5d\xac\xbd\xe7\xec\xe2\xaa\x6d\xe7\x2f\x6b\x7d\xf0\xe4\x05\xf6\x71\x0f\x75\xb7\xdf\x7e\xe2\x9a\x31\x64\x3a\x39\xa8\x63\xf7\x01\x2e\x2f\x7e\x28\x9d\xf5\x91\x58\xed\x8d\x95\xe2\xae\x30\xcc\xfd\xb1\x30\x3e\x3f\xb0\x7f\x07\x7f\xce\xfb\xfa\xa5\x37\xef\x78\xfe\x8e\x37\xef\x78\xe1\x8e\x37\x5f\x12\xab\x6f\xfe\x69\x21\x9f\xfe\xf3\x56\x76\x92\xfb\xf9\xe9\x69\xb7\x6f\x87\xca\xbe\xdd\xe7\xb5\x31\x4a\xf6\x4d\xb6\x31\x9c\xf9\x77\xc8\x44\xf2\xc7\x30\xf7\x6c\x4e\x38\x32\x4e\x1d\x17\xcc\xb5\x22\xf9\xa4\x94\x9d\x1e\xfc\x79\x63\xcf\xc6\x8c\xe3\x56\x5f\x5a\xd0\x41\x0a\xae\xcb\x1a\xc6\x7a\xbe\xd1\x87\x89\xcb\xde\xea\xf9\x2a\xfb\x24\xd9\xfe\xe6\x3d\xd7\xcc\xb6\x6e\xbd\xe7\x24\x5a\xff\xf3\x03\xb5\x97\x0d\x3f\x74\xeb\x27\x24\xb7\xee\x00\xea\x86\xe7\xf2\x5f\x31\x69\x77\xdf\x48\xe0\xfd\x5b\xa1\xec\x44\x9e\x28\xd9\xa4\x04\x79\xaa\xa4\x93\x85\xc8\x33\xa5\x90\x9c\x83\x3c\x57\x46\x92\xf7\x91\x17\x4a\x16\x2d\x42\x5e\x55\x0a\xe8\x1a\xe4\x35\x65\x0b\x4b\x20\xaf\x2b\x43\xf8\x10\xe4\x03\x4a\x16\x9f\x83\x7c\x1a\xe9\xd2\x66\x21\x9f\xae\x14\xe9\x9f\x22\x9f\xa1\x94\x05\x9a\x91\xcf\x54\x42\x69\x14\xf9\x2c\xa5\x30\xad\x5d\x5a\x42\xb8\x5c\xfd\x94\xdb\x3d\xab\xdc\x3c\x91\x7d\x11\xc8\x53\x65\x18\x09\x21\xcf\x14\x8b\xac\x42\x9e\x2b\x61\x72\x2b\xf2\x42\x29\x22\x3d\xc8\xab\x8a\x41\x4b\x91\xd7\x94\x6f\xe8\x66\xe4\x75\x65\x12\xfb\x17\xf2\x01\xa5\xc8\xfb\x3d\x8c\x9b\x4f\xa3\x1f\xf2\x15\xc8\xa7\x2b\x95\xfa\xdd\xc8\x67\x28\x87\x06\x02\xc8\x67\x2a\xeb\x02\x17\x23\x9f\xa5\x58\x69\x95\x4a\xbd\x12\x57\x9a\xe5\x27\x29\x3f\x5b\x94\x98\xd2\x28\xf5\x5c\xa3\x12\x95\xdb\x51\x99\x6b\x50\x12\x4a\x87\xb2\x59\xe9\xf4\x4a\xb5\xc8\xbd\x41\x65\x92\xdc\x3b\x59\xa6\x86\x52\xae\x54\xc8\x4f\x50\x99\x23\x4b\x25\xe4\xf7\xad\xb2\x7e\x50\xa9\x93\xf9\x4e\x59\xcb\xfd\x1b\xf5\xda\x4d\x28\xed\xf2\x88\x48\xf3\xbe\xf9\xf5\xd6\x0c\x99\x5b\x02\x2b\xe6\x7a\xb5\xa7\xc8\xdc\x3c\x59\xbf\xc1\x3d\xa6\xea\xe3\xcd\xf1\x64\x7c\x4b\xac\x31\xd8\x18\x4d\x46\x83\x0d\x89\x8e\xcd\x9d\xf1\xe6\x96\x64\x70\x52\xc3\xe4\xa0\x51\x5e\x51\x1e\x9c\x93\x48\x34\xb7\xc6\x82\x75\x89\xce\x8e\x44\x67\x34\x19\x4f\xb4\x97\xa5\xd5\x0d\x2c\x66\x04\x97\xc8\x26\xe6\x46\x93\x53\x82\xf3\xda\x1b\x64\xbb\x0b\xa4\x41\x6b\x25\x6c\xaa\xc1\x41\x65\xa1\x97\x26\xe4\xd7\xf1\xb5\x31\xbf\xb1\xe0\xc2\x44\xbb\xdc\x51\x2b\xf7\xb6\x7a\x46\xce\xf3\x1c\xd5\x2a\xeb\x34\xc8\xdd\x89\xd6\xc6\xe0\xbc\x64\xb4\x35\x2e\x37\x6a\x94\x2e\xb9\x2f\x26\x5b\x68\xf4\x5a\x0e\x2a\x53\xe5\xe7\xff\x40\xaa\xe9\x6a\x88\xb5\x37\xc6\x3a\x83\x53\x83\xbf\x00\xfd\xf5\xaa\xc1\xff\x66\xd4\x80\x76\x82\xfb\x18\xb9\xc2\x6b\xaf\xab\xaf\x35\x43\x7a\xb9\x5c\xfe\x2f\x93\x63\xa1\xac\x88\x75\x76\xb9\xd5\x8c\xb2\xf2\xf2\xb2\x8a\xc1\x0d\xe8\x85\x9f\xda\x07\xff\x5f\xc0\x5d\xec\xa9\x2e\x76\x2f\xf4\xe0\xdd\x89\x4b\x63\x82\xde\xd4\x4b\x7a\xdf\xb8\xbe\x6b\x93\x69\xa7\xb2\x5e\xee\x4b\x28\x4d\xbf\x3a\x41\x82\xb2\x5c\xcc\x9b\xce\x5d\xf2\x9b\x98\xb7\xd5\xe8\xb5\xea\xb6\xbd\x5c\x96\x58\xea\x95\x5a\xec\xd5\x74\xc7\x26\xe9\xa1\xb5\x7b\xa5\x96\x0d\x82\xb8\x48\x22\x36\x79\x7d\x89\xa5\x94\x6c\xf0\xda\x76\xfb\xe9\xb7\x9c\x90\xf9\x16\x8c\xf2\x3a\xa5\xdb\x9b\xe0\x5d\xb2\xa4\x5b\xaf\xb7\x6f\x5d\xee\x04\x4e\x19\x8c\x78\x57\x30\x1a\x4c\x76\x46\x1b\x63\x6d\xd1\xce\xf5\xc1\x44\xd3\xbe\x93\x32\xd8\x19\x6b\x8e\x77\x25\x63\x9d\x72\x67\xbc\x3d\xb8\xbc\x6c\x69\x59\x70\x71\x34\x19\x6b\x4f\x06\xa3\xed\x8d\xc1\x65\x7d\x15\x17\x35\x35\xc5\x1b\x62\xde\xce\x86\x58\x67\x32\x2a\x0b\x27\x92\x2d\x72\x0a\xad\xeb\xee\x8c\x77\x35\xc6\x1b\x5c\xb4\xae\xb2\xc1\x26\xe4\xe0\x47\x6a\xff\x24\x4c\x39\x8a\x14\xe9\x39\xd7\x63\x1b\x3d\x3f\x2c\xf4\x8a\xbb\xdb\x5d\x7e\x95\xa5\xc9\xd8\xc6\x58\x70\x61\x34\x99\x8c\x75\xb9\x85\x6b\x65\x81\x2e\x38\xdf\x1f\x58\x17\xab\xdb\x9b\x69\xed\x72\xbf\x3b\x68\x9b\xa4\xcb\x5c\x07\xb5\x78\xf9\xa8\x37\xf0\x8d\x5e\x93\xee\xea\xd0\x8e\xda\x6b\xe5\x7a\x11\xfc\x55\xf0\x20\xea\x46\x31\x81\xda\xbd\x09\xb9\x11\x3d\xda\x08\x34\x77\x2a\x34\x79\x7f\xbb\x3c\xdc\x76\x89\x11\x94\xf9\xa8\x37\x34\x41\xcf\x5a\x77\xd8\x9a\x06\x58\x11\xf4\x86\x36\xea\x4d\x14\x7f\x72\xb6\xc9\x6f\x93\x5e\xd9\x06\x6f\xa2\xb7\x7a\x16\xba\x2b\x65\x9b\xf4\xa5\x8f\xba\x16\x6b\xe1\x26\x6f\x65\x6d\xe9\xeb\xbf\x5b\xcb\xf7\xfd\x81\x32\xdd\x34\x66\xac\x37\x1d\xf7\xf5\x8d\x3f\xcd\x9b\x70\x64\x06\xbd\xe7\xab\x77\xc8\x7c\xc2\xeb\x4b\xaf\x47\xa7\x7a\xa3\xe9\xf6\x27\xe6\x59\xe9\xe6\xa2\xde\xca\xbd\x56\xd6\x68\xf5\x70\x7d\xbb\x5a\xbc\xc9\x1c\xf5\xa6\x62\x0c\x53\x33\xe9\x59\xdf\x95\x32\xa5\xfd\x09\x1c\xf4\x7a\xe0\xb6\x6e\x7b\xd6\xba\xeb\x75\x0c\x9e\x5d\x29\xd7\xf9\x05\x83\xb6\xe8\x7b\x2f\xf5\x50\xea\xf2\x16\x83\x8d\x9e\x1f\xfb\xdb\x6e\xf7\xac\x6d\xf4\xf6\x25\xfa\x3c\xed\x96\x6a\x05\x92\xdf\xe3\x56\x8f\x4f\xd6\xf7\x8d\x52\x93\x37\x43\x7d\x6f\x36\x7a\xad\x4d\xfd\x2f\xfe\x6e\xf2\x7c\x93\x04\x6a\xc2\xb3\xa8\x51\xfe\xf7\xc7\xdd\x9f\x61\x09\x59\xb7\xdb\x1b\x45\xff\xf0\xf7\xe7\x7f\xf2\x17\x9e\x8b\x7a\xfe\x4d\xa0\x5e\x87\xfc\xc6\xc5\xf2\x6d\x69\xf3\x0f\xe7\xda\x68\x97\x3c\x3c\xe5\xc1\x5c\x97\xe8\xee\x8a\xb7\xc7\xa6\x04\x37\xb5\xc4\x1b\x5a\x82\x9b\xa2\x5d\xc1\xc6\x58\x57\xbc\xb9\x5d\x7e\xbd\x76\x73\x70\xdf\xc3\x23\x28\xbf\x8d\xca\x05\xa0\xbd\x3d\xb1\x51\x1e\x5c\x1b\x65\xb5\xce\x58\x53\x67\xac\xab\x25\xde\xde\x1c\xec\x8a\xb6\x77\x05\xbb\x62\x9d\xf1\x26\x34\x11\x4c\xb6\x44\x93\xee\x72\xd1\x16\x4b\x76\xc6\x1b\xa2\xad\xad\x9b\x25\xf3\xb5\x75\xc8\xaa\x6b\x25\xd5\x6d\x8a\x27\x5b\x5c\xfc\xce\xb8\x3c\x62\x0f\x8c\x6d\xba\xb5\xac\xd7\x1a\xb9\xa6\x34\xc9\x25\x3c\x18\x6f\xeb\xe8\x4c\x6c\xf4\x0c\x9d\xda\xd5\xd0\x19\x8b\xb5\x4b\xbc\x68\x63\x74\x6d\xbc\x35\x9e\x94\x6d\xb5\x44\x3b\xa3\x0d\x72\xa5\x91\xcb\x4d\xbc\xa1\xcb\x5b\x49\xe4\x02\x12\xec\x88\xb6\x4f\xb5\xbb\x3b\x13\x1d\x31\x69\xec\xca\x39\x0b\xfa\x0b\x4a\xf3\xfc\x55\xa8\x2b\xd1\xba\x31\xd6\xe5\x95\x6e\x8f\xc5\x1a\xbb\xdc\x55\xac\x51\x76\xb5\x55\x56\x92\xc0\xad\x89\xc4\x7a\xb7\x4b\x4d\x89\x4e\x69\x66\x63\xb2\x65\x6a\x8a\xdd\x4d\x89\xf6\xa4\xac\x9a\x08\x46\x1b\x1b\x65\xdf\xa5\xc3\x12\x0d\xdd\x6d\xee\xfa\x26\xd7\x9c\x64\xaf\x71\xd1\x86\xce\x84\xfc\xae\xa3\x35\x9a\x94\xad\xb4\xb9\xeb\x58\x8b\x77\xf4\x77\x28\xd3\x65\x64\x35\x4d\xce\x09\xf7\x7f\x99\xb7\x06\xa4\xae\x6e\x0d\x58\xdb\xca\x30\x53\xa6\xc9\x8a\xc9\x64\xc7\xf4\x69\xd3\x36\x6d\xda\x54\x16\xc5\x12\xd7\x20\x57\xb8\x32\x69\xd4\xb4\xff\xf7\x66\xdd\xc9\xd2\xe1\x4d\xeb\xd4\xa5\xab\xd3\x9b\x20\x6e\x9b\x6d\x72\xe2\xfc\x2a\x74\x72\x73\x47\x0c\x93\xa5\xb3\xab\xac\x25\xd9\xd6\xea\x93\xa3\x0f\xdb\xbb\x8a\x76\xa7\xac\xdb\xbd\xc7\xd3\x52\x49\x7c\x0b\x3c\x92\xea\xc0\x2a\xe0\x60\xfe\x07\x07\xb4\xe0\xae\x80\x03\xb9\xbe\xc2\x67\xf9\x05\x92\x3d\xda\xdd\x69\xdc\xed\xad\xf9\xee\x58\x2e\x9d\xb7\x20\xb8\xa8\x43\x4e\x13\x47\x8e\x51\x10\x05\xa6\x04\x7b\xf5\x40\x85\x2b\x06\xf6\x75\x97\xbf\x16\xc5\xe5\x76\xd2\xeb\x78\x97\x77\x24\x95\x79\xce\x6a\x96\xdf\x2f\x92\x96\x2d\xe8\x73\x83\x9c\x84\xf1\x8e\x64\x57\x59\x57\xbc\xb5\x2c\xd1\xd9\x3c\x6d\x91\xb3\xc0\xd3\xf4\xca\xde\x6f\x14\xa5\x67\x9c\xf2\xbc\xa7\xf6\x07\xfc\x0b\x1c\xe2\xed\xa5\x52\xbd\x72\xa9\x93\x55\xa9\x89\x75\xa9\x7f\xd3\xdc\xd7\xa0\x4a\x5d\x9b\x25\x63\x9b\x1c\x25\x57\xc9\x93\xd1\xd7\x10\x65\xa8\x32\x4c\xc6\xde\x23\x94\x02\xa5\x50\x46\xa7\x45\x32\x66\x29\x96\x11\x62\x50\x19\xa3\x8c\x75\x9f\x28\xa2\x94\x28\x13\x94\x89\x52\x7b\x4e\x56\xf6\x53\x4a\xa5\x77\xa6\x4a\x5b\xa7\x41\x81\x9a\x8a\xa5\x84\x94\xb0\x12\x51\x2a\x95\x2a\xd9\xbf\xfd\x95\x19\xca\x4c\x65\x96\x8c\xe1\xab\x25\x87\xd6\xca\xd5\xba\x5e\xae\x8e\x8e\x5c\x0d\xe7\x4a\xff\xcf\x57\x0e\x90\x3d\x5b\x28\xd7\xf3\x45\x52\x56\x1c\x24\xc5\xc9\x52\x29\x24\x96\x4b\x6f\xaf\x54\x0e\x56\x56\x29\x87\x28\xab\x95\x43\x95\xc3\x94\xc3\x95\x35\xca\x11\x4a\x94\xb8\x4f\xc0\x3e\x51\x39\x49\x79\x54\xb9\x58\xf9\x58\x39\x59\x39\x5b\x39\x43\xb9\x52\xb9\x45\xb9\x9e\x30\xe5\x74\xc2\x95\x13\x94\x0b\x94\xaf\x94\xaf\x95\xb3\x64\xdc\x70\x2a\x51\x95\xb7\x95\x2f\x95\xab\x94\x5b\x95\xff\x28\xdf\x28\xdf\x2a\xd7\x2a\x3b\x94\x67\x95\xdf\xcb\x98\x68\xad\xf4\xf8\xb9\x72\x46\xfc\x51\x8e\xea\x33\xca\x1f\x94\x17\x95\xe7\xa4\xdf\x5e\x50\xfe\x29\x57\xa8\xbf\x28\x7f\x52\xfe\xac\xdc\x21\x3d\xff\x85\x72\x9e\xf2\x8a\xf2\xb2\xf2\x57\x39\x5e\x9f\x28\x9f\x29\xa7\x49\x79\x12\x97\x2b\xab\x3b\x29\xdb\x95\xed\x72\x7c\x36\x78\xdc\xd2\x25\xe7\x57\x52\xae\xc4\x9b\x94\x7f\x29\x47\xca\x38\x60\xb3\xb2\x55\x39\x5a\x39\x4a\x79\x40\xb9\x46\x39\x56\x39\x46\xd9\xa6\x1c\xa7\x7c\xaa\xfc\x5b\x79\x88\x68\x44\x27\x01\x92\x46\xd2\x49\x86\xb2\x47\xe9\x21\x99\x24\x8b\x64\x93\x1c\x65\x2f\x51\x48\x2e\xc9\x23\xf9\x84\x90\x21\x64\x28\x19\xe6\xbe\xe2\x9f\x14\x90\x42\x32\x92\x14\x91\x51\xa4\x98\x8c\x56\xbe\x57\x7e\x20\x41\x32\x86\x8c\x25\xe3\xc8\x78\x52\x42\x26\x90\x89\x64\x12\x99\x4c\xf6\x23\xa5\x64\x0a\x99\x4a\xca\xc8\x34\xe5\x47\xe5\x55\x52\x4e\x2a\x88\x41\x4c\x62\x91\x10\x09\x93\x08\xa9\x24\x55\x32\x9a\xdd\x9f\xcc\x20\x33\xc9\x2c\xe5\x7d\xe5\xef\x64\x36\xa9\x26\x35\xa4\x96\xd4\x91\x7a\x62\x13\x87\xcc\x21\x73\xc9\x3c\x32\x9f\x1c\x40\x16\xc8\xb8\xf0\x4e\xe5\x2e\x72\x20\x59\x44\x16\x93\x83\xc8\x12\xb2\x94\x2c\x23\xcb\xc9\x0a\xb2\x52\xf9\x49\xf9\x59\xf9\x87\xf2\x01\x39\x98\xac\x22\x87\x90\xd5\xe4\x50\x72\x18\x39\x9c\xac\x21\x47\x90\x28\x59\x4b\x1a\x48\x23\x89\x91\x26\xd2\x4c\x5a\x48\x9c\xac\x23\xeb\x49\x2b\x69\x53\x1e\x26\xed\x24\x41\x3a\xc8\x06\xe5\x43\xe5\x23\xd2\x49\xba\x48\x92\x74\x93\x8d\x64\x13\x39\x92\x6c\x26\x5b\xc8\x56\x72\x14\x39\x9a\x1c\x43\x8e\x25\xdb\xc8\x71\xe4\x78\x72\x02\x39\x51\xb9\x91\x9c\x44\x4e\x26\xa7\x90\x53\xc9\x69\xe4\x74\x72\x06\x39\x93\x9c\x45\xce\x26\xe7\x90\x73\xc9\x79\xe4\x7c\x72\x01\xb9\x90\x5c\x44\x2e\x26\x97\x90\x4b\xc9\x65\xe4\x37\xe4\x72\x72\x05\xb9\x92\x5c\x45\xae\x26\xdb\xc9\x35\xe4\x5a\x72\x1d\xb9\x9e\xdc\x40\x6e\x24\x37\x91\x9b\xc9\x2d\xe4\x56\x72\x1b\xb9\x9d\xec\x20\x3b\xc9\x1d\xe4\x4e\x72\x17\xb9\x9b\xdc\x43\xee\x25\xf7\x91\xfb\xc9\x2e\xf2\x00\x79\x90\x3c\x44\x1e\x26\x8f\x90\x47\xc9\x6e\xf2\x18\x79\x9c\xfc\x96\x3c\x41\x9e\x24\x4f\x91\xdf\x91\xa7\xc9\xef\xc9\x33\xe4\x59\xf2\x07\xf2\x47\xf2\x1c\x79\x9e\xbc\x40\x5e\x24\x7f\x22\x7f\x26\x2f\x91\xbf\x90\x97\xc9\x5f\xc9\x2b\xe4\x55\xf2\x1a\x79\x9d\xfc\x8d\xbc\x41\xde\x24\x6f\x91\xb7\xc9\x3b\xe4\x5d\xf2\x1e\x79\x9f\xfc\x9d\xfc\x83\x7c\x40\x3e\x24\x1f\x91\x8f\xc9\x3f\xc9\xbf\xc8\x27\xe4\x53\xf2\x19\xf9\x37\xf9\x9c\x7c\x41\xbe\x24\x5f\x91\xaf\xc9\x37\xe4\x3f\xe4\x5b\xf2\x1d\xf9\x9e\xfc\x40\x7e\x24\x3f\x91\x9f\xc9\x1e\xd2\x43\xf6\x52\x85\x12\x4a\x29\xa3\x9c\x0a\xaa\x52\x8d\xea\x34\x40\xd3\x68\x3a\xcd\xa0\x99\x34\x8b\x66\xd3\x1c\x9a\x4b\xf3\x68\x3e\x1d\x42\x87\xd2\x61\x74\x38\x1d\x41\x0b\x68\x21\x1d\x49\x8b\xe8\x28\x5a\x4c\x47\xd3\x20\x1d\x43\xc7\xd2\x71\x74\x3c\x2d\xa1\x13\xe8\x44\x3a\x89\x4e\xa6\xfb\xd1\x52\x3a\x85\x4e\xa5\x65\x74\x1a\x2d\xa7\x15\xd4\xa0\x26\xb5\x68\x88\x86\x69\x84\x56\xd2\x2a\x3a\x9d\xee\x4f\x67\xd0\x99\x74\x16\x9d\x4d\xab\x69\x0d\xad\xa5\x75\xb4\x9e\xda\xd4\xa1\x73\xe8\x5c\x3a\x8f\xce\xa7\x07\xd0\x05\x74\x21\x3d\x90\x2e\xa2\x8b\xe9\x41\x74\x09\x5d\x4a\x97\xd1\xe5\x74\x05\x5d\x49\x0f\xa6\xab\xe8\x21\x74\x35\x3d\x94\x1e\x46\x0f\xa7\x6b\xe8\x11\x34\x4a\xd7\xd2\x06\xda\x48\x63\xb4\x89\x36\xd3\x16\x1a\xa7\xeb\xe8\x7a\xda\x4a\xdb\x68\x3b\x4d\xd0\x0e\xba\x81\x76\xd2\x2e\x9a\xa4\xdd\x74\x23\xdd\x44\x8f\xa4\x9b\xe9\x16\xba\x95\x1e\x45\x8f\xa6\xc7\xd0\x63\xe9\x36\x7a\x1c\x3d\x9e\x9e\x40\x4f\xa4\x27\xd1\x93\xe9\x29\xf4\x54\x7a\x1a\x3d\x9d\x9e\x41\xcf\xa4\x67\xd1\xb3\xe9\x39\xf4\x5c\x7a\x1e\x3d\x9f\x5e\x40\x2f\xa4\x17\xd1\x8b\xe9\x25\xf4\x52\x7a\x19\xfd\x0d\xbd\x9c\x5e\x41\xaf\xa4\x57\xd1\xab\xe9\x76\x7a\x0d\xbd\x96\x5e\x47\xaf\xa7\x37\xd0\x1b\xe9\x4d\xf4\x66\x7a\x0b\xbd\x95\xde\x46\x6f\xa7\x3b\xe8\x4e\x7a\x07\xbd\x93\xde\x45\xef\xa6\xf7\xd0\x7b\xe9\x7d\xf4\x7e\xe5\x35\xe5\x3d\xba\x4b\xf9\x1b\x7d\x80\x3e\x48\x1f\xa2\x0f\xd3\x47\xe8\xa3\x74\x37\x7d\x8c\x3e\x4e\x7f\x4b\x9f\xa0\x4f\xd2\xa7\xe8\xef\x94\x37\x94\x37\x95\xb7\x94\x77\x95\xd7\x95\x77\xe8\xd3\xf4\xf7\xf4\x19\xfa\x2c\xfd\x03\xfd\x23\x7d\x8e\x3e\x4f\x5f\xa0\x2f\xd2\x3f\xd1\x3f\xd3\x97\xe8\x5f\xe8\xcb\xf4\xaf\xf4\x15\xfa\x2a\x7d\x8d\xbe\x4e\xff\x46\xdf\xa0\x6f\xd2\xb7\xe8\xdb\xf4\x1d\xfa\x2e\x7d\x8f\xbe\x4f\xff\x4e\xff\x41\x3f\xa0\x1f\xd2\x8f\xe8\xc7\xf4\x9f\xf4\x5f\xf4\x13\xfa\x29\xfd\x8c\xfe\x9b\x7e\x4e\xbf\xa0\x5f\xd2\xaf\xe8\xd7\xf4\x1b\xfa\x1f\xfa\x2d\xfd\x8e\x7e\x4f\x7f\xa0\x3f\xd2\x9f\xe8\xcf\x74\x0f\xed\xa1\x7b\x99\xc2\x08\xa3\x8c\x31\xce\x04\x53\x99\xc6\xdc\x27\xec\xa6\xb1\x74\x96\xc1\x32\x59\x16\xcb\x66\x39\x2c\x97\xe5\xb1\x7c\x36\x84\x0d\x65\xc3\xd8\x70\x36\x82\x15\xb0\x42\x36\x92\x15\xb1\x51\xac\x98\x8d\x66\x41\x36\x86\x8d\x65\xe3\xd8\x78\x56\xc2\x26\xb0\x89\x6c\x12\x9b\xcc\xf6\x63\xa5\x6c\x0a\x9b\xca\xca\xd8\x34\x56\xce\x2a\x98\xc1\x4c\x66\xb1\x10\x0b\xb3\x08\xab\x64\x55\x6c\x3a\xdb\x9f\xcd\x60\x33\xd9\x2c\x36\x9b\x55\xb3\x1a\x56\xcb\xea\x58\x3d\xb3\x99\xc3\xe6\xb0\xb9\x6c\x1e\x9b\xcf\x0e\x60\x0b\xd8\x42\x76\x20\x5b\xc4\x16\xb3\x83\xd8\x12\xb6\x94\x2d\x63\xcb\xd9\x0a\xb6\x92\x1d\xcc\x56\xb1\x43\xd8\x6a\x76\x28\x3b\x8c\x1d\xce\xd6\xb0\x23\x58\x94\xad\x65\x0d\xac\x91\xc5\x58\x13\x6b\x66\x2d\x2c\xce\xd6\xb1\xf5\xac\x55\xb9\x99\xb5\xb1\x76\x96\x60\x1d\x6c\x03\xeb\x64\x5d\x2c\xc9\xba\xd9\x46\xb6\x89\x1d\xc9\x36\xb3\x2d\x6c\x2b\x3b\x8a\x1d\xcd\x8e\x61\xc7\x2a\x57\xb3\x6d\xec\x38\x76\x3c\x3b\x81\x9d\xc8\x4e\x62\x27\xb3\x53\xd8\xa9\xec\x34\x76\x3a\x3b\x83\x9d\xc9\xce\x62\x67\xb3\x73\xd8\xb9\xec\x3c\xe5\x12\x76\x3e\xbb\x80\x5d\xa8\x5c\xce\x2e\x62\x17\xb3\x4b\xd8\xa5\xec\x32\xf6\x1b\x76\x39\xbb\x82\x5d\xc9\xae\x62\x57\xb3\xed\xec\x1a\x76\x2d\xbb\x8e\x5d\xcf\x6e\x60\x37\xb2\x9b\xd8\xcd\xec\x16\x76\x2b\xbb\x8d\xdd\xce\x76\xb0\x9d\xec\x0e\x76\x27\xbb\x8b\xdd\xcd\xee\x61\xf7\xb2\xfb\xd8\xfd\x6c\x17\x7b\x80\x3d\xc8\x1e\x62\x0f\xb3\x47\xd8\xa3\x6c\x37\x7b\x8c\x3d\xce\x7e\xcb\x9e\x60\x4f\xb2\xa7\xd8\xef\xd8\xd3\xec\xf7\xec\x19\xf6\x2c\xfb\x03\xfb\x23\x7b\x8e\x3d\xcf\x5e\x60\x2f\xb2\x3f\xb1\x3f\xb3\x97\xd8\x5f\xd8\xcb\xec\xaf\xec\x15\xf6\x2a\x7b\x8d\xbd\xce\xfe\xc6\xde\x60\x6f\xb2\xb7\xd8\xdb\xec\x1d\xf6\x2e\x7b\x8f\xbd\xcf\xfe\xce\xfe\xc1\x3e\x60\x1f\xb2\x8f\xd8\xc7\xec\x9f\xec\x5f\xec\x13\xf6\x29\xfb\x8c\xfd\x9b\x7d\xce\xbe\x60\x5f\xb2\xaf\xd8\xd7\xec\x1b\xf6\x1f\xf6\x2d\xfb\x8e\x7d\xcf\x7e\x60\x3f\xb2\x9f\xd8\xcf\x6c\x0f\xeb\x61\x7b\xb9\xc2\x09\xa7\x9c\x71\xce\x05\x57\xb9\xc6\x75\x1e\xe0\x69\x3c\x9d\x67\xf0\x4c\x9e\xc5\xb3\x79\x0e\xcf\xe5\x79\x3c\x9f\x0f\xe1\x43\xf9\x30\x3e\x9c\x8f\xe0\x05\xbc\x90\x8f\xe4\x45\x7c\x14\x2f\xe6\xa3\x79\x90\x8f\xe1\x63\xf9\x38\x3e\x9e\x97\xf0\x09\x7c\x22\x9f\xc4\x27\xf3\xfd\x78\x29\x9f\xc2\xa7\xf2\x32\x3e\x8d\x97\xf3\x0a\x6e\x70\x93\x5b\x3c\xc4\xc3\x3c\xc2\x2b\x79\x15\x9f\xce\xf7\xe7\x33\xf8\x4c\x3e\x8b\xcf\xe6\xd5\xbc\x86\xd7\xf2\x3a\x5e\xcf\x6d\xee\xf0\x39\x7c\x2e\x9f\xc7\xe7\xf3\x03\xf8\x02\xbe\x90\x1f\xc8\x17\xf1\xc5\xfc\x20\xbe\x84\x2f\xe5\xcb\xf8\x72\xbe\x82\xaf\xe4\x07\xf3\x55\xfc\x10\xbe\x9a\x1f\xca\x0f\xe3\x87\xf3\x35\xfc\x08\x1e\xe5\x6b\x79\x03\x6f\xe4\x31\xde\xc4\x9b\x79\x0b\x8f\xf3\x75\x7c\x3d\x6f\xe5\x6d\xbc\x9d\x27\x78\x07\xdf\xc0\x3b\x79\x17\x4f\xf2\x6e\xbe\x91\x6f\xe2\x47\xf2\xcd\x7c\x0b\xdf\xca\x8f\xe2\x47\xf3\x63\xf8\xb1\x7c\x1b\x3f\x8e\x1f\xcf\x4f\xe0\x27\xf2\x93\xf8\xc9\xfc\x14\x7e\x2a\x3f\x8d\x9f\xce\xcf\xe0\x67\xf2\xb3\xf8\xd9\xfc\x1c\x7e\x2e\x3f\x8f\x9f\xcf\x2f\xe0\x17\xf2\x8b\xf8\xc5\xfc\x12\x7e\x29\xbf\x8c\xff\x86\x5f\xce\xaf\xe0\x57\xf2\xab\xf8\xd5\x7c\x3b\xbf\x86\x5f\xcb\xaf\xe3\xd7\xf3\x1b\xf8\x8d\xfc\x26\x7e\x33\xbf\x85\xdf\xca\x6f\xe3\xb7\xf3\x1d\x7c\x27\xbf\x83\xdf\xc9\xef\xe2\x77\xf3\x7b\xf8\xbd\xfc\x3e\x7e\x3f\xdf\xc5\x1f\xe0\x0f\xf2\x87\xf8\xc3\xfc\x11\xfe\x28\xdf\xcd\x1f\xe3\x8f\xf3\xdf\xf2\x27\xf8\x93\xfc\x29\xfe\x3b\xfe\x34\xff\x3d\x7f\x86\x3f\xcb\xff\xc0\xff\xc8\x9f\xe3\xcf\xf3\x17\xf8\x8b\xfc\x4f\xfc\xcf\xfc\x25\xfe\x17\xfe\x32\xff\x2b\x7f\x85\xbf\xca\x5f\xe3\xaf\xf3\xbf\xf1\x37\xf8\x9b\xfc\x2d\xfe\x36\x7f\x87\xbf\xcb\xdf\xe3\xef\xf3\xbf\xf3\x7f\xf0\x0f\xf8\x87\xfc\x23\xfe\x31\xff\x27\xff\x17\xff\x84\x7f\xca\x3f\xe3\xff\xe6\x9f\xf3\x2f\xf8\x97\xfc\x2b\xfe\x35\xff\x86\xff\x87\x7f\xcb\xbf\xe3\xdf\xf3\x1f\xf8\x8f\xfc\x27\xfe\x33\xdf\xc3\x7b\xf8\x5e\xa1\x08\x22\xa8\x60\x82\x0b\x21\x54\xa1\x09\x5d\x04\x44\x9a\x48\x17\x19\x22\x53\x64\x89\x6c\x91\x23\x72\x45\x9e\xc8\x17\x43\xc4\x50\x31\x4c\x0c\x17\x23\x44\x81\x28\x14\x23\x45\x91\x18\x25\x8a\xc5\x68\x11\x14\x63\xc4\x58\x31\x4e\x8c\x17\x25\x62\x82\x98\x28\x26\x89\xc9\x62\x3f\x51\x2a\xa6\x88\xa9\xa2\x4c\x4c\x13\xe5\xa2\x42\x18\xc2\x14\x96\x08\x89\xb0\x88\x88\x4a\x51\x25\xa6\x8b\xfd\xc5\x0c\x31\x53\xcc\x12\xb3\x45\xb5\xa8\x11\xb5\xa2\x4e\xd4\x0b\x5b\x38\x62\x8e\x98\x2b\xe6\x89\xf9\xe2\x00\xb1\x40\x2c\x14\x07\x8a\x45\x62\xb1\x38\x48\x2c\x11\x4b\xc5\x32\xb1\x5c\xac\x10\x2b\xc5\xc1\x62\x95\x38\x44\xac\x16\x87\x8a\xc3\xc4\xe1\x62\x8d\x38\x42\x44\xc5\x5a\xd1\x20\x1a\x45\x4c\x34\x89\x66\xd1\x22\xe2\x62\x9d\x58\x2f\x5a\x45\x9b\x68\x17\x09\xd1\x21\x36\x88\x4e\xd1\x25\x92\xa2\x5b\x6c\x14\x9b\xc4\x91\x62\xb3\xd8\x22\xb6\x8a\xa3\xc4\xd1\xe2\x18\x71\xac\xd8\x26\x8e\x13\xc7\x8b\x13\xc4\x89\xe2\x24\x71\xb2\x38\x45\x9c\x2a\x4e\x13\xa7\x8b\x33\xc4\x99\xe2\x2c\x71\xb6\x38\x47\x9c\x2b\xce\x13\xe7\x8b\x0b\xc4\x85\xe2\x22\x71\xb1\xb8\x44\x5c\x2a\x2e\x13\xbf\x11\x97\x8b\x2b\xc4\x95\xe2\x2a\x71\xb5\xd8\x2e\xae\x11\xd7\x8a\xeb\xc4\xf5\xe2\x06\x71\xa3\xb8\x49\xdc\x2c\x6e\x11\xb7\x8a\xdb\xc4\xed\x62\x87\xd8\x29\xee\x10\x77\x8a\xbb\xc4\xdd\xe2\x1e\x71\xaf\xb8\x4f\xdc\x2f\x76\x89\x07\xc4\x83\xe2\x21\xf1\xb0\x78\x44\x3c\x2a\x76\x8b\xc7\xc4\xe3\xe2\xb7\xe2\x09\xf1\xa4\x78\x4a\xfc\x4e\x3c\x2d\x7e\x2f\x9e\x11\xcf\x8a\x3f\x88\x3f\x8a\xe7\xc4\xf3\xe2\x05\xf1\xa2\xf8\x93\xf8\xb3\x78\x49\xfc\x45\xbc\x2c\xfe\x2a\x5e\x11\xaf\x8a\xd7\xc4\xeb\xe2\x6f\xe2\x0d\xf1\xa6\x78\x4b\xbc\x2d\xde\x11\xef\x8a\xf7\xc4\xfb\xe2\xef\xe2\x1f\xe2\x03\xf1\xa1\xf8\x48\x7c\x2c\xfe\x29\xfe\x25\x3e\x11\x9f\x8a\xcf\xc4\xbf\xc5\xe7\xe2\x0b\xf1\xa5\xf8\x4a\x7c\x2d\xbe\x11\xff\x11\xdf\x8a\xef\xc4\xf7\xe2\x07\xf1\xa3\xf8\x49\xfc\x2c\xf6\x88\x1e\xb1\x57\x55\x54\xa2\x52\x95\xa9\x5c\x15\xaa\xaa\x6a\xaa\xae\x06\xd4\x34\xf7\xfd\xfe\x6a\xa6\x9a\xa5\x66\xab\x39\x6a\xae\x9a\xa7\xe6\xab\x43\xd4\xa1\xea\x30\x75\xb8\x3a\x42\x2d\x50\x0b\xd5\x91\x6a\x91\x3a\x4a\x2d\x56\x47\xab\x41\x75\x8c\x3a\x56\x1d\xa7\x8e\x57\x4b\xd4\x09\xea\x44\x75\x92\x3a\x59\xdd\x4f\x2d\x55\xa7\xa8\x53\xd5\x32\x75\x9a\x5a\xae\x56\xa8\x86\x6a\xaa\x96\x1a\x52\xc3\x6a\x44\xad\x54\xab\xd4\xe9\xea\xfe\xea\x0c\x75\xa6\x3a\x4b\x9d\xad\x56\xab\x35\x6a\xad\x5a\xa7\xd6\xab\xb6\xea\xa8\x73\xd4\xb9\xea\x3c\x75\xbe\x7a\x80\xba\x40\x5d\xa8\x1e\xa8\x2e\x52\x17\xab\x07\xa9\x4b\xd4\xa5\xea\x32\x75\xb9\xba\x42\x5d\xa9\x1e\xac\xae\x52\x0f\x51\x57\xab\x87\xaa\x87\xa9\x87\xab\x6b\xd4\x23\xd4\xa8\xba\x56\x6d\x50\x1b\xd5\x98\xda\xa4\x36\xab\x2d\x6a\x5c\x5d\xa7\xae\x57\x5b\xd5\x36\xb5\x5d\x4d\xa8\x1d\xea\x06\xb5\x53\xed\x52\x93\x6a\xb7\xba\x51\xdd\xa4\x1e\xa9\x6e\x56\xb7\xa8\x5b\xd5\xa3\xd4\xa3\xd5\x63\xd4\x63\xd5\x6d\xea\x71\xea\xf1\xea\x09\xea\x89\xea\x49\xea\xc9\xea\x29\xea\xa9\xea\x69\xea\xe9\xea\x19\xea\x99\xea\x59\xea\xd9\xea\x39\xea\xb9\xea\x79\xea\xf9\xea\x05\xea\x85\xea\x45\xea\xc5\xea\x25\xea\xa5\xea\x65\xea\x6f\xd4\xcb\xd5\x2b\xd4\x2b\xd5\xab\xd4\xab\xd5\xed\xea\x35\xea\xb5\xea\x75\xea\xf5\xea\x0d\xea\x8d\xea\x4d\xea\xcd\xea\x2d\xea\xad\xea\x6d\xea\xed\xea\x0e\x75\xa7\x7a\x87\x7a\xa7\x7a\x97\x7a\xb7\x7a\x8f\x7a\xaf\x7a\x9f\x7a\xbf\xba\x4b\x7d\x40\x7d\x50\x7d\x48\x7d\x58\x7d\x44\x7d\x54\xdd\xad\x3e\xa6\x3e\xae\xfe\x56\x7d\x42\x7d\x52\x7d\x4a\xfd\x9d\xfa\xb4\xfa\x7b\xf5\x19\xf5\x59\xf5\x0f\xea\x1f\xd5\xe7\xd4\xe7\xd5\x17\xd4\x17\xd5\x3f\xa9\x7f\x56\x5f\x52\xff\xa2\xbe\xac\xfe\x55\x7d\x45\x7d\x55\x7d\x4d\x7d\x5d\xfd\x9b\xfa\x86\xfa\xa6\xfa\x96\xfa\xb6\xfa\x8e\xfa\xae\xfa\x9e\xfa\xbe\xfa\x77\xf5\x1f\xea\x07\xea\x87\xea\x47\xea\xc7\xea\x3f\xd5\x7f\xa9\x9f\xa8\x9f\xaa\x9f\xa9\xff\x56\x3f\x57\xbf\x50\xbf\x54\xbf\x52\xbf\x56\xbf\x51\xff\xa3\x7e\xab\x7e\xa7\x7e\xaf\xfe\xa0\xfe\xa8\xfe\xa4\xfe\xac\xee\x51\x7b\xd4\xbd\x9a\xa2\x11\x8d\x6a\x4c\xe3\x9a\xd0\x54\x4d\xd3\x74\x2d\xa0\xa5\x69\xe9\x5a\x86\x96\xa9\x65\x69\xd9\x5a\x8e\x96\xab\xe5\x69\xf9\xda\x10\x6d\xa8\x36\x4c\x1b\xae\x8d\xd0\x0a\xb4\x42\x6d\xa4\x56\xa4\x8d\xd2\x8a\xb5\xd1\x5a\x50\x1b\xa3\x8d\xd5\xc6\x69\xe3\xb5\x12\x6d\x82\x36\x51\x9b\xa4\x4d\xd6\xf6\xd3\x4a\xb5\x29\xda\x54\xad\x4c\x9b\xa6\x95\x6b\x15\x9a\xa1\x99\x9a\xa5\x85\xb4\xb0\x16\xd1\x2a\xb5\x2a\x6d\xba\xb6\xbf\x36\x43\x9b\xa9\xcd\xd2\x66\x6b\xd5\x5a\x8d\x56\xab\xd5\x69\xf5\x9a\xad\x39\xda\x1c\x6d\xae\x36\x4f\x9b\xaf\x1d\xa0\x2d\xd0\x16\x6a\x07\x6a\x8b\xb4\xc5\xda\x41\xda\x12\x6d\xa9\xb6\x4c\x5b\xae\xad\xd0\x56\x6a\x07\x6b\xab\xb4\x43\xb4\xd5\xda\xa1\xda\x61\xda\xe1\xda\x1a\xed\x08\x2d\xaa\xad\xd5\x1a\xb4\x46\x2d\xa6\x35\x69\xcd\x5a\x8b\x16\xd7\xd6\x69\xeb\xb5\x56\xad\x4d\x6b\xd7\x12\x5a\x87\xb6\x41\xeb\xd4\xba\xb4\xa4\xd6\xad\x6d\xd4\x36\x69\x47\x6a\x9b\xb5\x2d\xda\x56\xed\x28\xed\x68\xed\x18\xed\x58\x6d\x9b\x76\x9c\x76\xbc\x76\x82\x76\xa2\x76\x92\x76\xb2\x76\x8a\x76\xaa\x76\x9a\x76\xba\x76\x86\x76\xa6\x76\x96\x76\xb6\x76\x8e\x76\xae\x76\x9e\x76\xbe\x76\x81\x76\xa1\x76\x91\x76\xb1\x76\x89\x76\xa9\x76\x99\xf6\x1b\xed\x72\xed\x0a\xed\x4a\xed\x2a\xed\x6a\x6d\xbb\x76\x8d\x76\xad\x76\x9d\x76\xbd\x76\x83\x76\xa3\x76\x93\x76\xb3\x76\x8b\x76\xab\x76\x9b\x76\xbb\xb6\x43\xdb\xa9\xdd\xa1\xdd\xa9\xdd\xa5\xdd\xad\xdd\xa3\xdd\xab\xdd\xa7\xdd\xaf\xed\xd2\x1e\xd0\x1e\xd4\x1e\xd2\x1e\xd6\x1e\xd1\x1e\xd5\x76\x6b\x8f\x69\x8f\x6b\xbf\xd5\x9e\xd0\x9e\xd4\x9e\xd2\x7e\xa7\x3d\xad\xfd\x5e\x7b\x46\x7b\x56\xfb\x83\xf6\x47\xed\x39\xed\x79\xed\x05\xed\x45\xed\x4f\xda\x9f\xb5\x97\xb4\xbf\x68\x2f\x6b\x7f\xd5\x5e\xd1\x5e\xd5\x5e\xd3\x5e\xd7\xfe\xa6\xbd\xa1\xbd\xa9\xbd\xa5\xbd\xad\xbd\xa3\xbd\xab\xbd\xa7\xbd\xaf\xfd\x5d\xfb\x87\xf6\x81\xf6\xa1\xf6\x91\xf6\xb1\xf6\x4f\xed\x5f\xda\x27\xda\xa7\xda\x67\xda\xbf\xb5\xcf\xb5\x2f\xb4\x2f\xb5\xaf\xb4\xaf\x95\xbb\x95\x7b\xb4\x6f\xb4\xff\x28\xf7\x2b\xbb\x94\xa7\xb4\x6f\x95\x7b\x95\xfb\x94\xdf\x69\xdf\x29\xc7\x2b\x4f\x28\xa7\x28\xb7\x69\xdf\x6b\x3f\x68\x3f\x6a\x3f\x69\x3f\x2b\x4f\x6b\x7b\xb4\x1e\x6d\xaf\xb2\x5b\x79\x4c\x57\x74\xa2\x3c\xa2\x53\x9d\xe9\x5c\x17\xba\xaa\x6b\xba\xae\x07\xf4\x34\x3d\x5d\xcf\xd0\x33\xf5\x2c\x3d\x5b\xcf\xd1\x73\x95\xef\xf4\x3c\x3d\x5f\x1f\xa2\x0f\xd5\x87\xe9\xc3\xf5\x11\x7a\x81\x5e\xa8\x8f\xd4\x8b\xf4\x51\x7a\xb1\x3e\x5a\x0f\xea\x63\xf4\xb1\xfa\x38\x7d\xbc\x5e\xa2\x4f\xd0\x27\xea\x93\x94\x33\xf5\xc9\xfa\x7e\x7a\xa9\x3e\x45\x9f\xaa\x97\xe9\xd3\xf4\x72\xbd\x42\x37\x74\x53\xb7\xf4\x90\x1e\xd6\x23\x7a\xa5\x5e\xa5\x4f\x57\x2e\xd5\xf7\x57\x7e\xa3\x5c\xa6\x7c\xae\xcf\x50\x9e\x54\x6e\x50\xce\xd7\x67\xea\xb3\x94\x2b\x94\x9b\x94\x73\xf4\xd9\xca\x85\xca\x45\x7a\xb5\x5e\xa3\xd7\xea\x75\x7a\xbd\x6e\xeb\x8e\x3e\x47\x9f\xab\xcf\xd3\xe7\xeb\x07\xe8\x0b\xf4\x85\xfa\x81\xfa\x22\x7d\xb1\x7e\x90\xbe\x44\x5f\xaa\x2f\xd3\x97\xeb\x2b\xf4\x95\xfa\xc1\xfa\x2a\xfd\x10\x7d\xb5\x7e\xa8\x7e\x98\x7e\xb8\xbe\x46\x3f\x42\x8f\xea\x6b\xf5\x06\xbd\x51\x8f\xe9\x4d\x7a\xb3\xde\xa2\xc7\xf5\x75\xfa\x7a\xbd\x55\x6f\xd3\xdb\xf5\x84\xde\xa1\x6f\xd0\x3b\xf5\x2e\x3d\xa9\x77\xeb\x1b\xf5\x4d\xfa\x91\xfa\x66\x7d\x8b\xbe\x55\x3f\x4a\x79\x50\x3f\x5a\x3f\x46\x3f\x56\xdf\xa6\x1f\xa7\x1f\xaf\x9f\xa0\x9f\xa8\x9f\xa4\x9f\xac\x9f\xa2\x9f\xaa\x9f\xa6\x9f\xae\x9f\xa1\x9f\xa9\x9f\xa5\x9f\xad\x9f\xa3\x9f\xab\x9f\xa7\x9f\xaf\x5f\xa0\x5f\xa8\x5f\xa4\x5f\xac\x5f\xa2\x5f\xaa\x5f\xa6\xff\x46\xbf\x5c\xbf\x42\xbf\x52\xbf\x4a\xbf\x5a\xdf\xae\x5f\xa3\x5f\xab\x5f\xa7\x5f\xaf\xdf\xa0\xdf\xa8\xdf\xa4\xdf\xac\xdf\xa2\xdf\xaa\xdf\xa6\xdf\xae\xef\xd0\x77\xea\x77\xe8\x77\xea\x77\xe9\x77\xeb\xf7\xe8\xf7\x2a\x8f\x2b\xbf\xd5\xef\xd3\xef\xd7\x77\xe9\x0f\xe8\x0f\xea\x0f\xe9\x0f\xeb\x8f\xe8\x8f\xea\xbb\xf5\xc7\xf4\xc7\xf5\xdf\xea\x4f\xe8\x4f\xea\x4f\xe9\xbf\xd3\x9f\xd6\x7f\xaf\x3f\xa3\x3f\xab\xff\x41\xff\xa3\xfe\x9c\xfe\xbc\xfe\x82\xfe\xa2\xfe\x27\xfd\xcf\xfa\x4b\xfa\x5f\xf4\x97\xf5\xbf\xea\xaf\xe8\xaf\xea\xaf\xe9\xaf\xeb\x7f\xd3\xdf\xd0\xdf\xd4\xdf\xd2\xdf\xd6\xdf\xd1\xdf\xd5\xdf\xd3\xdf\xd7\xff\xae\xff\x43\xff\x40\xff\x50\xff\x48\xff\x58\xff\xa7\xfe\x2f\xfd\x13\xfd\x53\xfd\x33\xfd\xdf\xfa\xe7\xfa\x17\xfa\x97\xfa\x57\xfa\xd7\xfa\x37\xfa\x7f\xf4\x6f\xf5\xef\xf4\xef\xf5\x1f\xf4\x1f\xf5\x9f\xf4\x9f\xf5\x3d\x7a\x8f\xbe\x37\xa0\x04\x48\x80\x06\x58\x80\x07\x44\x40\x0d\x68\x01\x3d\x10\x08\xa4\x05\xd2\x03\x19\x81\xcc\x40\x56\x20\x3b\x90\x13\xc8\x0d\xe4\x05\xf2\x03\x43\x02\x43\x03\xc3\x02\xc3\x03\x23\x02\x05\x81\xc2\xc0\xc8\x40\x51\x60\x54\xa0\x38\x30\x3a\x10\x0c\x8c\x09\x8c\x0d\x8c\x0b\x8c\x0f\x94\x04\x26\x04\x26\x06\x26\x05\x26\x07\xf6\x0b\x94\x06\xa6\x04\xa6\x06\xca\x02\xd3\x02\xe5\x81\x8a\x80\x11\x30\x03\x56\x20\x14\x08\x07\x22\x81\xca\x40\x55\x60\x7a\x60\xff\xc0\x8c\xc0\xcc\xc0\xac\xc0\xec\x40\x75\xa0\x26\x50\x1b\xa8\x0b\xd4\x07\xec\x80\x13\x98\x13\x98\x1b\x98\x17\x98\x1f\x38\x20\xb0\x20\xb0\x30\x70\x60\x60\x51\x60\x71\xe0\xa0\xc0\x92\xc0\xd2\xc0\xb2\xc0\xf2\xc0\x8a\xc0\xca\xc0\xc1\x81\x55\x81\x43\x02\xab\xb5\xee\xf6\x78\x79\x79\x4d\x39\xd2\xfa\x40\x62\x63\xac\xb3\xab\x21\xd1\x19\x63\x6d\xdd\x15\x69\x6d\xf1\xc6\xc6\x44\xb2\xac\xbc\xbc\x42\xab\x69\x73\xcf\x75\xb6\x6b\x51\x3f\x55\x6b\xd6\x76\xc6\x36\xc6\xd4\xa8\x97\x68\x35\x89\xe6\x44\x7b\x6c\xbd\x16\xf5\xd3\xf4\xba\x86\x78\x67\x43\x77\x5b\x53\x6b\xec\xc8\xf4\x86\xfe\x7c\x5a\x9d\x6c\x2e\xda\xd0\x10\x6b\x4f\xa6\x35\xf4\x65\xd5\xfa\x86\xa8\xdb\x64\xa3\x9f\xd4\xcb\xf6\xa3\x49\xcd\x06\x60\x0c\x80\xb6\x0f\x18\xf3\x92\x34\xbb\xbf\xa1\x58\x5f\x56\xb3\x61\x46\xcc\x4f\x55\xdb\x6f\x31\xe6\x25\xe9\x73\x52\x8c\x6a\x4e\x31\x6a\x4e\x7f\x5b\xcd\x7d\xd9\x8c\x39\x0d\x89\xb6\xb6\x28\x36\x9a\x53\x36\xd2\xe7\xa6\xb4\xd3\xd2\x9f\xe7\x73\xd7\x46\x3b\x79\x8b\xfc\xa3\xce\x4b\xc6\x5b\x1b\x63\x6a\xdc\x4b\xb4\x79\xe8\x49\x1c\x3d\x99\xe7\xf7\x24\xee\xbb\x6e\x1e\x6c\x8e\xfb\x29\x9d\x37\x9f\xc6\xd7\xa5\xcf\x4f\xc1\x58\xd7\x9f\xcf\x38\x20\xd5\xaa\xf5\xfb\x6c\x34\xbb\xa7\xce\x5b\xa3\xed\x8d\xf1\x06\x75\x41\xb4\xa1\x3b\x19\x53\x5b\xbd\x24\x63\x41\x6a\xb9\xd6\x94\x0d\x75\x81\xef\xa0\x56\x2f\xe1\x0b\x64\xef\x79\xab\xfc\xa3\x1e\xe8\xd7\x6f\xf7\xeb\x1f\x98\x5a\xbf\x3d\xb5\xfe\x81\x7e\xfd\x76\xdf\xc1\xed\xd1\x8e\x44\x57\xb2\x33\xd1\xd1\x12\x63\x76\x7b\x33\x8b\xb5\x37\x6b\x8b\xd0\xf9\x04\x3a\xbf\xc8\xef\x7c\xc2\x4b\x32\x17\xb5\x74\xb7\x37\x47\x3b\xbb\xdb\x5a\xa3\xdd\xc9\xcc\x44\xea\x96\xba\xc4\xb7\xa1\xd3\xb7\x61\x49\xaa\x0d\x9d\xa9\x36\x2c\xf1\x6d\xe8\xf4\x93\xa5\x7e\xad\x2e\x2f\x49\x5f\x9a\xe2\xc6\xae\x14\x37\x2e\x4b\x6d\x2d\x99\xda\xda\x32\xbf\x99\xa4\xef\x91\x65\xee\x90\x26\xdd\x21\x5d\xee\x0f\x69\xb7\x3f\xa4\xcb\xd1\xab\x6e\xf4\x6a\xb9\xdf\xab\x6e\x2f\x11\xcb\x3b\xe3\xed\xcd\xa2\xdb\xfd\x9b\xb9\x7c\x9f\x1e\x76\xa7\x6e\x69\xcb\x31\xf4\xdd\x38\x6a\x56\xa6\x58\xbb\x29\x25\xbf\x2a\x25\xbf\xb9\x3f\xaf\x1e\xe2\xf7\x75\x8b\x97\xa4\x1d\xd2\x3f\x8d\xb7\xf4\x65\x45\x6b\xa2\xbd\xb9\xcb\x3b\xbc\x2b\x2a\xcb\x91\x56\x20\x35\x90\x9a\x48\x2d\xa4\x21\xa4\x61\xa4\x11\xa4\x95\x48\xab\x90\xd6\x20\xad\x45\x5a\x87\xb4\x1e\xa9\x8d\xd4\xf1\xd3\x2a\xe0\x57\x01\xbf\x0a\xb8\x55\xc0\xad\x02\x6e\x15\x70\xab\x80\x5b\x05\xdc\x2a\xe0\x56\x01\xb7\x0a\xb8\x55\xc0\xad\x02\x6e\x15\x70\xab\x1c\xb1\xa8\x25\xd1\x29\x03\x20\xf7\xaf\xbf\xaf\x06\x7d\xae\x01\x76\x0d\xb0\x6b\x80\x5d\x03\xec\x1a\x60\xd7\x00\xbb\x06\xd8\x35\xc0\xae\x01\x76\x0d\xb0\x6b\x80\x5d\x63\x8b\xe5\x1e\x66\x77\x3f\x66\x2d\xfa\x5b\x0b\xec\x5a\x60\xd7\x02\xbb\x16\xd8\xb5\xc0\xae\x05\x76\x2d\xb0\x6b\x81\x5d\x0b\xec\x5a\x60\xd7\x02\xbb\x16\xd8\xb5\xe8\x77\x2d\xfc\x5d\x07\x7f\xd7\x01\xbf\x0e\xf8\x75\xc0\xaf\x03\x7e\x1d\xf0\xeb\x80\x5f\x07\xfc\x3a\xe0\xd7\x01\xbf\x0e\xf8\x75\xc0\xaf\x03\x7e\x1d\xf0\xeb\x80\x5f\x07\xfc\x7a\xe0\xd7\x03\xbf\x1e\xf8\xf5\xc0\xaf\x07\x7e\x3d\xf0\xeb\x81\x5f\x0f\xfc\x7a\xe0\xd7\x03\xbf\x1e\xf8\xf5\xc0\xaf\x07\x7e\x3d\xf0\xeb\x81\x5f\x0f\x7c\x1b\xf8\x36\xf0\x6d\xe0\xdb\xc0\xb7\x81\x6f\x03\xdf\x06\xbe\x0d\x7c\x1b\xf8\x36\xf0\x6d\xe0\xdb\xc0\xb7\x81\x6f\x03\xdf\x06\xbe\x0d\x7c\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x4e\x55\x5a\x8d\xbb\x96\xf8\x87\x79\xb4\x2f\xab\xd5\xd8\x7e\x1a\x8d\xf9\xab\xdd\xa2\xae\xd6\x68\x57\x8b\x9f\x4f\xf4\xe7\xbd\x56\x8c\xf2\x72\xa4\x15\x48\x0d\xa4\x26\x52\x0b\x69\x08\x69\x18\x69\x04\x69\x25\xd2\x2a\xa4\x35\x48\x6b\x91\xd6\x21\xad\x47\x6a\x23\xf5\xbd\x61\x54\x00\xbf\x02\xf8\x15\xc0\xaf\x00\x7e\x05\xf0\x2b\x80\x5f\x01\xfc\x8a\x48\xc6\xd2\xd4\xd5\xba\x2b\x65\x03\x25\x60\x49\x05\x2c\xa9\x80\x25\x15\xb0\xa4\x02\x96\x54\xc0\x12\x03\x96\x18\xb0\xc4\x80\x25\x06\x2c\x31\x60\x89\x01\x4b\x0c\x58\x62\xc0\x13\x06\x3c\x61\xc0\x13\x06\xf0\x0d\xe0\x1b\xc0\x37\x80\x6f\x00\xdf\x00\xbe\x09\x7c\x13\xf8\x26\xf0\x4d\xe0\x9b\xc0\x37\x81\x6f\x02\xdf\x04\xae\x09\x5c\x13\xb8\x26\x70\x4d\xe0\x9a\xc0\x35\x81\x6b\x02\xd7\x02\xae\x05\x5c\x0b\xb8\x16\x70\x2d\xe0\x5a\xc0\xb5\x80\x6b\xa1\xdf\x16\xf0\x2d\xe0\x5b\xc0\xb7\x80\x6f\x01\xdf\x02\xbe\x05\x7c\x0b\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x61\xe0\x87\x81\x1f\x06\x7e\x18\xf8\x61\xe0\x87\x81\x1f\x06\x7e\x18\xf8\x61\xe0\x87\x81\x1f\x06\x7e\x18\xf8\x61\xe0\x87\x81\x1f\x06\x7e\x18\xf8\x11\xe0\x47\x80\x1f\x01\x7e\x04\xf8\x11\xe0\x47\x80\x1f\x01\x7e\x04\xf8\x11\xe0\x47\x80\x1f\x01\x7e\x04\xf8\x11\xe0\x47\x80\x1f\x01\x7e\x04\xf8\xe0\x7f\x03\xfc\x6f\x80\xff\x0d\xf0\xbf\x01\xfe\x37\xc0\xff\x06\xf8\xdf\x00\xff\x1b\xe0\x7f\x03\xfc\x6f\x80\xff\x0d\xf0\xbf\x01\xfe\x37\xc0\xff\x06\xf8\xdf\x00\xff\x1b\xe0\x7f\x03\xfc\x6f\x54\x01\x1f\x3a\xc0\x80\x0e\x30\xa0\x03\x0c\xe8\x00\x03\x3a\xc0\x80\x0e\x30\xa0\x03\x0c\xe8\x00\x03\x3a\xc0\x80\x0e\x30\xa0\x03\x0c\xe8\x00\xa3\x0a\xf8\x08\x73\x8c\x1a\xe0\x43\x0b\x18\xd0\x02\x06\xb4\x80\x01\x2d\x60\x40\x0b\x18\xd0\x02\x06\xb4\x80\x01\x2d\x60\x40\x0b\x18\xd0\x02\x06\xb4\x80\x01\x2d\x60\xd4\x00\xbf\x06\xf8\xb5\xc0\x87\x1e\x30\xa0\x07\x0c\xe8\x01\x03\x7a\xc0\x80\x1e\x30\xa0\x07\x0c\xe8\x01\x03\x7a\xc0\x80\x1e\x30\xa0\x07\x0c\xe8\x01\x03\x7a\xc0\x80\x1e\x30\xa0\x07\x0c\xe8\x01\x03\x7a\xc0\x80\x1e\x30\xa0\x07\x0c\xe8\x01\x03\x7a\xc0\x80\x1e\x30\xc0\xff\x06\x78\xdf\x00\xef\x1b\xe0\x7d\x03\xbc\x6f\x80\xf7\x0d\xf0\xbe\x01\xde\x37\xc0\xfb\x06\x78\xdf\x00\xef\x1b\xe0\x7d\x03\xbc\x6f\x80\xf7\x0d\xf0\xbe\x01\x1e\x37\xc0\xe3\x06\x78\xdc\x00\x8f\x1b\xe0\x71\x03\x3c\x6e\x80\xc7\x0d\xf0\xb8\x01\x1e\x37\xc0\xe3\x06\x78\xdc\x00\x8f\x1b\xe0\x71\x03\x3c\x6e\x80\xc7\x0d\xf0\xb8\x01\x1e\x37\xc0\xe3\x06\x78\xdc\x00\x8f\x1b\xe0\x71\x03\x3c\x6e\x80\xc7\x0d\xf0\xb8\x01\x1e\x37\xc0\xe3\x06\x78\xdc\x70\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x0e\xf0\x1d\x27\xd0\xdc\x19\xdd\x18\x93\x84\xb7\x36\xe0\x31\xb9\x9b\xf3\xbe\x33\xcb\x8d\x80\x17\x89\xa4\xec\xb1\x90\x86\x90\x86\x91\x46\x90\x56\x66\xb6\x24\x12\xeb\xa3\x6b\x13\x1b\x53\x6b\xd5\x20\xad\x45\x5a\x87\xb4\x1e\xa9\x8d\xd4\xf7\x85\x09\x16\x37\xc1\xe2\x26\x58\xdc\x04\x8b\x9b\x60\x71\x13\x2c\x6e\x82\xc5\xcd\x0a\x58\x51\x51\x89\xb4\x0a\x29\xf0\xc1\xdd\x26\xb8\xdb\x04\x77\x9b\xe0\x6e\x13\xdc\x6d\x82\xbb\x4d\x70\xb7\x69\x18\x19\x32\xd6\x59\x1b\x6b\x4d\x6c\xea\xef\x14\x08\xdc\x04\x81\x9b\x20\x70\x13\x04\x6e\x82\xc0\x4d\x10\xb8\x09\x02\x37\x41\xe0\x26\x08\xdc\x04\x81\x9b\x20\x70\x13\x04\x6e\x82\xc0\x4d\x10\xb8\x09\x02\x37\x41\xe0\x26\x08\xdc\x04\x81\x9b\x20\x70\xd3\x04\x3e\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xda\x04\x51\x9b\x20\x62\x13\x44\x6c\x82\x88\x4d\x10\xb1\x19\xb1\x45\x32\xd1\x9e\xe8\xca\x6c\x8c\xc7\x3a\x63\x5d\xf1\x2e\x6f\x2b\xad\xa6\xb5\xa3\x25\xea\x65\x03\xd1\xf6\x44\x32\xd6\x1a\x8b\x47\x33\xec\x8e\xae\xb8\x8c\xd9\xbd\xdd\xba\x9d\xc4\xf7\xf3\x12\xc8\x65\x2c\x6a\x8b\xbb\x67\x1c\xfc\x8d\xe5\x29\x85\xd3\x16\xb5\xc5\x9a\xfd\x42\xb9\x71\x59\x7c\x1f\x2c\xe1\x61\xf1\xda\x58\x32\x2a\xe6\x44\xa5\x7e\xd6\x80\xc3\x0f\x91\xbb\x98\xc4\x11\xcb\x5a\x64\x8e\xbb\x40\xe2\x80\x68\x47\x47\x54\x5d\x10\x6d\x5b\xdb\x18\xa5\x0b\xbb\xe9\x81\xdd\xf4\xe0\xb8\x06\x64\xba\x38\xce\x96\xb4\x24\xc4\xd2\x78\x73\x5b\x94\x2d\x8b\x76\x6b\xb0\x82\x2d\x6e\x89\xb3\x3a\xf9\x59\xdc\x15\xcf\x98\x97\x62\x41\x36\x0a\xf4\x6e\xa7\x45\xfb\x3a\x9e\x11\x4b\xed\x6e\xac\xb7\xbb\xf1\xde\xee\x0e\xe9\xde\xb7\xaa\xdf\x19\xaf\x3e\x5f\xeb\x76\xa6\xd9\xed\x8c\x68\x8c\xb5\x26\xa3\x1a\xda\xe2\x5b\xdc\x2e\xb9\x5f\x26\xbd\x2e\xb9\x8d\x89\xf5\x5e\x97\x5a\xfd\x2e\xb5\x77\xd3\x23\xe3\x5a\xc2\xef\x0f\xeb\x6c\x49\xa8\x5d\x6e\x67\x2a\x84\x97\xb0\xa4\xec\x13\x70\x59\x87\xec\x4f\x83\xfc\xc8\x4d\x91\x70\x1d\x9c\x91\xea\xdb\xec\x01\xe6\x65\x24\x52\x47\xa7\x3b\x75\x74\x12\x7d\xa3\xe3\xcf\x09\x90\xa4\x09\x92\x34\x41\x92\x26\x48\xd2\x04\x49\x9a\x20\x49\x13\x24\x69\x82\x24\x4d\x04\xc7\x26\x82\x63\x13\xc1\xb1\x89\xe0\xd8\x44\x70\x6c\x22\x38\x36\x41\xaa\x26\x48\xd5\x04\xa9\x9a\x20\x55\x13\xa4\x6a\x82\x54\x4d\x90\xaa\x09\x52\x35\x41\xaa\x26\x48\xd5\x04\xa9\x9a\x20\x55\x13\xa4\x6a\x82\x54\x4d\x90\xaa\x09\x52\x35\x41\xaa\x26\x48\xd5\x04\xa9\x9a\x20\x55\x13\xa4\x6a\x82\x54\x4d\x90\xaa\x09\x52\x35\x41\xaa\x26\x48\xd5\x04\xa9\x9a\x20\x55\x13\xa4\x6a\x82\x54\x4d\x90\xaa\x09\x52\x35\x41\xaa\xa6\xe3\xe3\x5b\x08\x87\x2d\x84\xc3\x16\xc2\x61\x0b\xe1\xb0\x05\x3a\xb5\x40\xa7\x16\xe8\xd4\x02\x9d\x5a\x08\x87\x2d\x84\xc3\x16\x88\xd4\x02\x91\x5a\x20\x52\x0b\x44\x6a\x81\x48\x2d\x10\xa9\x05\x22\xb5\x40\xa4\x16\x88\xd4\x02\x91\x5a\x20\x52\x0b\x44\x6a\x81\x48\x2d\x10\xa9\x05\x22\xb5\x40\xa4\x16\x88\xd4\x02\x91\x5a\x20\x52\x0b\x44\x6a\x81\x48\x2d\x10\xa9\x05\x22\xb5\x40\xa4\x16\x82\x60\x0b\x41\xb0\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\x08\x86\x2d\x04\xc3\x16\x82\x61\x0b\xc1\xb0\x05\x8e\xb5\xc0\xb1\x16\x82\x61\x0b\xc1\xb0\x85\x60\xd8\x42\x30\x6c\x81\x83\x2d\x70\xb0\x05\x0e\xb6\xc0\xc1\x16\x82\x61\x0b\xc1\xb0\x85\x60\xd8\x42\x30\x6c\x21\x18\xb6\x10\x0c\x5b\x08\x86\x2d\x04\xc3\x16\x82\x61\x0b\xc1\xb0\x85\x60\xd8\x42\x30\x6c\x21\x18\xb6\x10\x0c\x5b\x08\x86\x2d\x04\xc3\x16\x82\x61\x0b\xc1\xb0\x85\x60\xd8\x42\x30\x6c\x21\x18\xb6\x10\x0c\x5b\x08\x86\x2d\x04\xc3\x16\x82\x61\x0b\xc1\xb0\x85\x60\xd8\x42\x30\x6c\x21\x18\xb6\x10\x0c\x5b\x08\x86\x2d\x04\xc3\x16\x82\x61\x0b\xc1\xb0\x85\x60\xd8\x42\x30\x6c\x21\x18\xb6\x10\x0c\x5b\x08\x86\x2d\x04\xc3\x16\x82\x61\x0b\xc1\xb0\x85\x60\xd8\x42\x30\x6c\x21\x18\xb6\x10\x0c\x5b\x08\x86\x2d\x04\xc3\x16\x82\x61\x0b\xc1\xb0\x85\x60\xd8\x42\x30\x6c\x21\x18\xb6\x10\x0c\x5b\x08\x86\x2d\x04\xc3\x16\x82\x61\x0b\xc1\xb0\x85\x60\xd8\x42\x30\x6c\x21\x18\xb6\x10\x0c\x5b\x08\x86\x2d\x04\xc3\x16\x82\x61\x0b\xc1\xb0\x85\x60\xd8\x42\x30\x6c\x21\x18\xb6\x10\x0c\x5b\x08\x86\x2d\x04\xc3\x16\x4e\x8e\x5b\x38\x39\x6e\x21\x38\xb6\x70\x72\xdc\x42\x90\x6c\x21\x48\xb6\x10\x24\x5b\x08\x92\x2d\x04\xc9\x16\x82\x64\x0b\xfc\x6f\x81\xff\x2d\xf0\xbf\x05\xfe\xb7\xc0\xff\x16\xf8\xdf\x02\xff\x5b\xe0\x7f\xab\xbe\x32\x10\x6d\x8a\xc7\x2b\xca\x2b\x7b\x57\x26\x28\x00\x0b\x0a\xc0\x82\x02\xb0\xa0\x00\x2c\x28\x00\x0b\x0a\xc0\x82\x02\xb0\xa0\x00\x2c\x28\x00\x0b\x0a\xc0\x82\x02\xb0\xa0\x00\x2c\x28\x00\x0b\x0a\xc0\x82\x02\xb0\xa0\x00\x2c\x28\x00\x0b\x0a\xc0\x82\x02\xb0\xa0\x00\x2c\x28\x00\x0b\x0a\xc0\x82\x02\xb0\xa0\x00\x2c\x28\x00\x0b\x0a\xc0\x82\x02\xb0\xa0\x00\x2c\x28\x00\x0b\x0a\xc0\x82\x02\xb0\xa0\x00\x2c\x28\x00\x0b\x0a\xc0\x82\x02\xb0\xa0\x00\x2c\x28\x00\x0b\x0a\x20\x04\x05\x10\x82\x02\x08\x41\x01\x84\xa0\x00\x42\x50\x00\x21\x28\x80\x10\x14\x40\x08\x0a\x20\x04\x05\x10\x82\x02\x08\x41\x01\x84\xa0\x00\x42\x50\x00\x21\x28\x80\x10\x14\x40\x08\x0a\x20\x04\x05\x10\x82\x02\x08\x41\x01\x84\xa0\x00\x42\x60\xf4\x10\x18\x3d\x04\x46\x0f\x81\xd1\x43\x58\x39\x42\x58\x39\x42\x58\x39\x42\x58\x39\x42\x58\x39\x42\x58\x39\x42\x58\x39\x42\x58\x39\x42\x58\x39\x42\x58\x39\x42\x58\x39\x42\x58\x39\x42\x55\xbd\x38\xb0\x1b\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\x08\x2b\x47\xa8\xc6\x11\x5d\x2d\xb1\x8d\xd1\x34\x19\x3b\x44\x9b\xba\x62\xcd\x89\x56\x3f\xdb\x21\xff\xb4\xa4\x7b\xd9\x0d\xd1\xb6\x68\xb2\x4b\xb4\xc4\x3b\xe3\x1b\x44\xb2\x4b\xaa\x72\xe1\x15\x14\x5e\x19\xb5\xf7\xeb\x84\x0c\x04\xfc\x46\x6b\x6b\xd4\x0d\xdd\x6b\xbb\x93\x5d\x6a\x63\xb4\x39\xd6\xd5\x22\xda\x62\xc9\x58\xb3\x68\x8b\x6e\x88\x36\xf1\xce\x68\x53\x4c\xd6\xec\x8a\x6d\xd0\xdc\x1f\xbf\xb9\x17\xc6\xbb\xbc\x44\xef\x4a\x48\xd4\xae\xee\x0d\x81\xee\x8e\x8e\x58\xe7\x1a\x77\x57\x6b\x62\x53\xac\x53\x66\xfc\x76\xeb\xc2\xe9\x3e\xd8\x06\x09\xdc\xce\xa3\xad\xb1\x26\x26\x03\x16\xd1\x1c\x6f\x8b\xb5\x8a\x46\xb9\x9d\xa4\x2d\x31\xb6\x31\xba\x51\x6c\x89\x6e\x8e\xb7\x33\x19\xaa\xb0\xa4\xfc\x6c\x4e\x34\xea\x4d\xf1\xf6\x68\xeb\xfa\x68\x13\x93\x1f\x21\x4d\x8d\x61\x57\x5b\xac\x8d\xc9\x8f\xbf\xd1\xde\xdd\xce\xe4\x47\xed\x92\xdf\xaf\x6f\xe1\x6e\x23\x9a\xf7\x45\x47\x8c\x76\xc4\xd2\xbc\x6c\xb2\x4b\x86\x2a\xc2\xfb\xcb\x36\x24\x64\x87\x64\x0f\xb9\xdb\x15\x19\xe3\x6c\x54\x25\xf8\x46\x3f\x91\xa0\xaa\xfc\xb8\x49\xb3\x1b\xc9\xb4\x04\x64\xd2\xd5\x22\xdb\xf4\xdc\x54\x51\xef\x1f\x2b\x32\xad\x40\x6a\x20\x35\x91\x5a\x48\x43\x48\xc3\x48\x23\x48\x2b\x91\x56\x21\xad\x41\x5a\x8b\xb4\x0e\x69\x3d\x52\x1b\xa9\xe3\xa7\x15\xc0\xaf\x00\x7e\x05\xf0\x2b\x80\x5f\x01\xfc\x0a\xe0\x57\x00\xbf\x02\xf8\x15\xc0\xaf\x00\x7e\x05\xf0\x2b\x80\x5f\x01\xfc\x0a\xe0\x57\x00\xbf\x02\xf8\x06\xf0\x0d\xe0\x1b\xc0\x37\x80\x6f\x00\xdf\x00\xbe\x01\x7c\x03\xf8\x06\xf0\x0d\xe0\x1b\xc0\x37\x80\x6f\x00\xdf\x00\xbe\x01\x7c\x03\xf8\x26\xf0\x4d\xe0\x9b\xc0\x37\x81\x6f\x02\xdf\x04\xbe\x09\x7c\x13\xf8\x26\xf0\x4d\xe0\x9b\xc0\x37\x81\x6f\x02\xdf\x04\xbe\x09\x7c\x13\xf8\x16\xf0\x2d\xe0\x5b\xc0\xb7\x80\x6f\x01\xdf\x02\xbe\x05\x7c\x0b\xf8\x16\xf0\x2d\xe0\x5b\xc0\xb7\x80\x6f\x01\xdf\x02\xbe\x05\x7c\x0b\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x61\xe0\x87\x81\x1f\x06\x7e\x18\xf8\x61\xe0\x87\x81\x1f\x06\x7e\x18\xf8\x61\xe0\x87\x81\x1f\x06\x7e\x18\xf8\x61\xe0\x87\x81\x1f\x06\x7e\x18\xf8\x11\xe0\x47\x80\x1f\x01\x7e\x04\xf8\x11\xe0\x47\x80\x1f\x01\x7e\x04\xf8\x11\xe0\x47\x80\x1f\x01\x7e\x04\xf8\x11\xe0\x47\x80\x1f\x01\x7e\x04\xf8\x95\xc0\xaf\x04\x7e\x25\xf0\x2b\x81\x5f\x09\xfc\x4a\xe0\x57\x02\xbf\x12\xf8\x95\xc0\xaf\x04\x7e\x25\xf0\x2b\x81\x5f\x09\xfc\x4a\xe0\x57\x02\xbf\x12\xf8\x55\xc0\xaf\x02\x7e\x15\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\x7e\x15\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x35\xc0\xaf\x01\x7e\x0d\xf0\x6b\x80\x5f\x03\xfc\x1a\xe0\xd7\x00\xbf\x06\xf8\x35\xc0\xaf\x01\x7e\x0d\xf0\x6b\x80\x5f\x03\xfc\x1a\xe0\xd7\x00\xbf\x06\xf8\xb5\xc0\xaf\x05\x7e\x2d\xf0\x6b\x81\x5f\x0b\xfc\x5a\xe0\xd7\x02\xbf\x16\xf8\xb5\xc0\xaf\x05\x7e\x2d\xf0\x6b\x81\x5f\x0b\xfc\x5a\xe0\xd7\x02\xbf\x16\xf8\x75\xc0\xaf\x03\x7e\x1d\xf0\xeb\x80\x5f\x07\xfc\x3a\xe0\xd7\x01\xbf\x0e\xf8\x75\xc0\xaf\x03\x7e\x1d\xf0\x1d\xe0\xf8\x9a\xac\xc2\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x76\xc4\x51\x57\x7a\xd7\x3a\xd5\x4d\x7e\xb2\xd2\xbf\xb5\x71\x93\x97\x04\x56\xf6\x9e\x60\x0f\x6c\xea\xcd\xf9\xf5\xc0\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\xec\x2a\x3b\x50\xd3\x7b\xbd\x32\x10\xed\xcd\xa5\xd5\xf4\x5d\x99\x4d\x8b\xf6\x65\x73\x6a\xfa\x6f\xf5\xf4\xdc\x90\x13\x1d\xb8\x23\xa5\x84\xe7\xb6\xd4\x12\xde\x8e\x21\x29\x25\xfa\x1a\x1e\x12\x1d\x64\x67\x6a\x5b\xde\x95\xe5\xd4\xb6\xbc\x1d\xf9\x29\x25\x7a\x2d\xcf\x8f\xfe\x72\x5f\xba\x7f\x6b\xb8\x7f\x1b\x5a\x34\x25\xef\xef\xf7\xec\xc2\x7e\x2f\x9f\xed\xef\xef\xb3\x24\x3b\xba\xef\x36\xea\x79\x36\xa0\x9e\x97\xcf\xf2\xf7\xf7\xc2\x66\x45\xf7\xd9\x0c\xd8\x7d\xb9\xbe\x7d\x69\x76\xbf\x9f\xfb\xdb\x57\x6d\xff\xd6\x5e\xbf\xd5\x1c\x7b\xa0\x93\x63\x03\x77\xd8\x03\xbd\x1e\x1b\xe8\x75\x7b\x30\xaf\xc7\x06\xf3\xba\x3d\xd0\xeb\xb1\x81\x5e\xb7\x07\xf1\x7a\xec\x97\xfb\xd2\xe6\xf5\xf7\x2d\xde\x97\x0d\xcc\xeb\xf3\x42\xbc\x2f\xb7\xa8\x2f\x97\xe8\xab\xbd\xa8\xbf\x76\xa2\xdf\xba\x45\x03\xbb\x9e\x18\xb8\x63\xd1\x40\x5f\x24\x06\xfa\x62\xd1\x60\xbe\x48\x0c\xe6\x8b\x45\x03\x7d\x91\x18\xe8\x8b\x45\x83\xf8\x22\x31\x88\x2f\xbc\xdb\x7e\xfd\xdb\x25\x13\xfd\x59\x6f\xaf\x67\x94\xbf\xd7\xcb\x66\x79\x7b\xfb\x8c\xc8\x4a\xec\xb3\xe9\xd7\xf1\xc0\xfd\x3a\x5e\x36\xd3\xdb\xdb\x8b\x96\x99\x48\xdd\x0a\x2c\xef\xcb\x75\xf7\xd9\xb3\xbc\xbf\xc1\xee\xfe\xec\xf2\x7e\xd3\xba\xfb\xb3\xcb\xfb\xad\xec\xee\xb7\x72\xf9\xbe\x56\x76\xef\x6b\xe5\xf2\x7e\x2b\xbb\xfb\xad\x5c\xbe\x8f\x95\xdd\xa9\x5b\xea\x2a\x7f\x99\xdd\xec\x25\x81\x55\x7d\x36\x6f\xee\xb3\x79\x55\x7f\xf3\x9b\xfb\x8f\x95\x55\xfe\xb1\xb2\xd9\xbf\x0d\xde\x5d\xd3\x1c\x68\x36\x07\x9a\xcd\x81\x66\x73\xa0\xd9\x1c\x68\x36\x07\x9a\xcd\x81\x66\x73\xa0\xd9\x1c\x68\x36\x07\x9a\xcd\x81\x66\x73\xa0\xd9\x1c\x68\x36\x07\x9a\xcd\x81\x66\x73\xa0\xd9\x1c\x68\x36\x07\x9a\xcd\x81\x66\x73\xa0\xd9\x1c\x68\x36\x07\x9a\xcd\x81\x46\x73\xa0\xd1\x1c\x68\x34\x07\x1a\xcd\x81\x46\x73\xa0\xd1\x1c\x68\x32\x07\x9a\xcc\x81\x26\x73\xa0\xc9\x1c\x68\x32\x07\x9a\xcc\x81\x26\x73\xa0\xc9\x1c\x68\x32\x07\x9a\xcc\x81\x26\x73\xa0\xc9\x1c\x68\x32\xc7\xe8\xc5\x43\xff\xa0\xc9\x1c\x68\x32\x07\x9a\xcc\x81\x26\x73\xa0\xc9\x1c\x68\x32\x07\x9a\xcc\x81\x26\x73\xa0\xc9\x1c\x68\x32\x07\x9a\xcc\x81\x26\x73\xa0\xc9\x1c\x68\x32\x07\x9a\xcc\x81\x26\x73\xa0\xc9\x1c\x68\x32\x07\x9a\xcc\x81\x26\x73\xa0\xc9\x1c\x68\x32\x07\x9a\xcc\x81\x06\x73\xa0\xc1\x1c\x68\x30\x07\x1a\xcc\x81\x06\x73\xa0\xc1\x1c\x68\x2e\x07\x9a\xcb\x81\xe6\x72\xa0\xb9\x1c\x68\x2e\x07\x9a\xcb\x81\xe6\x72\xa0\xb9\x1c\x68\x2d\x07\x1a\xcb\x09\xf5\xb6\x0b\xfb\xa1\xa9\x1c\x68\x2a\x07\x9a\xca\x81\xa6\x72\xa0\xa9\x1c\x68\x2a\x07\x9a\xca\x81\xa6\x72\xa0\xa9\x1c\x68\x2a\x07\x9a\xca\x81\xa6\x72\xa0\xa9\x1c\x68\x2a\x07\x9a\xca\x81\xa6\x72\xa0\xa9\x1c\x68\x2a\x07\x9a\xca\x81\xa6\x72\xa0\xa9\x1c\x68\x2a\x07\x9a\xca\x81\xa6\x72\xa0\xa9\x1c\x68\x2a\x07\x9a\xca\x81\xa6\x72\xa0\xa9\x1c\x68\x2a\x07\xb1\xba\x83\x58\xdd\x41\xac\xee\x20\x56\x77\x10\xab\x3b\x88\xd5\x1d\x68\x28\x07\x1a\xca\x81\x86\x72\xa0\xa1\x1c\x68\x28\x07\x1a\xca\x81\x86\x72\x2a\x7b\xf1\xd0\x5f\x68\x28\x07\x1a\xca\x81\x86\x72\xa0\xa1\x1c\x68\x28\x07\x1a\xca\x81\x86\x72\xa0\xa1\x1c\x68\x28\x07\x1a\xca\x81\x86\x72\xa0\xa1\x1c\x68\x28\x07\xb1\xba\x83\x58\xdd\x41\xac\xee\x20\x56\x77\x10\xab\x3b\x88\xd5\x1d\xc4\xea\x0e\x62\x75\x07\xb1\xba\x83\x58\xdd\x41\xac\xee\x20\x56\x77\x10\xab\x3b\x88\xd5\x1d\xc4\xea\x0e\x62\x75\x07\xb1\xba\x83\x58\xdd\x41\xac\xee\x20\x56\x77\x10\xab\x3b\x88\xd5\x1d\xc4\xea\x0e\x62\x75\x07\xb1\xba\x83\x18\xdd\x41\x8c\xee\x20\x46\x77\x10\xa3\x3b\x88\xd1\x1d\xc4\xe8\x0e\x62\x74\x07\x31\xba\x83\x18\xdd\x41\x8c\xee\x20\x46\x77\x10\xa3\x3b\x88\xd1\x1d\xc4\xe8\x0e\x62\x74\x07\xb1\xb9\x83\xd8\xdc\x41\x6c\xee\x20\x36\x77\x10\x9b\x3b\x75\xc0\xad\x03\x6e\x1d\x70\xeb\x80\x5b\x07\xdc\x7a\xe0\xd6\x03\xb7\x1e\xb8\xf5\xc0\xad\x07\x5e\x3d\xf0\xea\x81\x57\x0f\xbc\x7a\xe0\xd5\x03\xaf\x1e\x38\xf5\xc0\xa9\x07\x8e\x0d\x1c\x1b\x38\x36\x70\x6c\xe0\xd8\xe8\x9f\x8d\x71\xb5\x81\x6b\x03\xd7\x06\xae\x0d\x5c\x1b\xb8\x36\x70\x6d\xf4\xd3\x06\xbe\x0d\x7c\x1b\xf8\x0e\xf0\x1c\xe0\x39\xc0\x73\x80\xe3\x00\xc7\x01\x8e\x03\x1c\x07\x38\x0e\x70\x1c\xe0\x38\xc0\xf1\xcf\x81\x18\xe5\x3e\xcf\xc9\xb4\x1e\x69\xef\x7e\xc7\x4f\x7d\x5e\x93\x69\x28\xd3\x7b\x16\x9a\xf7\x33\xcd\xc6\xb5\xad\x99\x1b\xba\x13\xee\x83\x38\xdd\x5f\x6e\xc6\x1a\x51\x06\x75\x7c\xae\x91\x69\x2d\x52\x60\x18\xc0\x30\x6c\xb5\x2d\xde\xee\xfd\x60\x2e\xd6\x90\x68\x47\x6d\xd3\x0a\xc4\x8e\x6c\x68\x8d\xb6\xc9\xd6\x03\x9d\xd1\x46\xf7\xa9\x7e\xb1\x23\xfd\xef\x42\xb0\x2a\x8c\x96\xc3\x68\x39\x8c\x96\xc3\x68\x39\xdc\x5b\xce\x09\xb4\x77\x75\x77\xc4\x3a\xe3\x89\x4e\x7f\x8f\xbf\x3e\xc8\xb4\x02\x29\xfa\xe5\xaf\x0f\x32\xb5\xfc\xb4\x06\xe5\x6a\x50\xae\xc6\xe0\xad\xf1\xce\x28\x36\x42\x48\xc3\x6a\x47\xac\x2b\x96\xec\xdd\x5d\x89\xb4\x4a\xed\x6a\x89\x6d\x88\xb5\xf2\xc6\x44\x7b\x33\x77\x9f\x13\x88\x2f\x60\x5e\x0d\xcc\xab\x81\xa3\x6a\x01\x56\x0b\xb0\x5a\x18\x55\x0b\xa3\x6a\x61\x54\x2d\x70\xfd\x8b\x97\x46\x85\x2f\x6a\x8c\x0a\x5f\x6c\xc8\x34\x8c\x34\xc2\x16\xb5\xb4\x05\x62\x5d\xc9\x78\x5b\x34\x89\x61\xa9\xf0\x29\x4f\xa6\xb6\x9e\x68\x8f\x25\x5b\xe2\x9d\x8d\x81\xe4\xa6\x84\x97\xe9\x0a\xc8\x5d\x31\xf7\x39\xc0\x2d\x19\xc9\x96\xce\x18\xf2\x5d\xe9\x4d\xf1\x8d\xbd\xf9\x8c\x2e\x39\xca\xed\xd8\xf0\x9b\xaa\xb4\x02\xd1\xce\xce\xc4\xa6\xd6\x58\x53\x52\xf3\x72\xdd\x1d\x69\x5e\xea\x3d\x53\xd8\xff\xb2\x31\xb1\xa9\xdd\xcf\xad\x95\x60\x01\x14\x6b\x6c\xcf\xe8\xcb\xad\xed\xf2\xd4\x9c\x81\x9f\xfd\x18\x46\x45\x28\x2d\xd1\x99\x6c\x71\x7f\x99\x18\x6d\xcd\x88\xb7\x27\xdd\xd9\xe5\x3d\xac\x35\x3d\xb6\xa1\x3b\xbe\x51\xce\x88\xf6\x86\x98\x68\x49\x74\x77\xc5\x32\xe5\xe4\x6b\x4d\x34\xbb\xd3\xa4\x3d\x91\x4c\x73\x0b\x4b\x5d\xd9\x9a\xec\xe8\xcb\xae\xf5\x2e\x8b\x19\xb8\xe6\x6a\xe0\x5a\xab\x81\x6b\xa4\x06\xae\x85\xca\xd4\x42\x5a\x89\x14\xdf\x1b\xd8\x8f\xf9\x1b\x32\xb1\x6d\x62\x3b\x84\xfa\xbe\x86\x90\x29\xda\xf7\x35\x84\x4c\x51\xde\xd7\x10\x32\x0d\x23\x8d\x20\x05\x9e\xaf\x25\x64\x5a\x83\xb4\x16\x69\x2f\x4e\x3d\x52\x1b\xa9\x3f\x7d\x42\x61\xe0\x87\x81\x1f\x06\x7e\x18\xf8\x61\xe0\x87\x81\x1f\x06\x7e\x18\xf8\x61\xe0\x87\x81\x8f\xa3\x2b\x84\xa3\x2b\xe4\x1e\x5d\x1d\x6b\x5b\x13\x0d\xeb\x35\x39\x56\x6e\x2a\xfc\xad\xd6\x26\x3f\xed\x4c\x62\x3b\xd9\xd5\x12\x6d\x8c\x09\xef\xaf\xd6\xb8\xde\x4b\x03\x4d\xf1\xd6\x56\xb9\x54\x24\xfc\x63\x18\x57\x6e\x0d\x5c\x79\x95\x69\x6d\x9a\x5f\xa2\x53\x8e\xb0\x96\xec\x8c\x47\x9b\xbb\x3b\xfc\xb4\x13\xdb\x8d\xed\x7e\xda\xda\xa4\xba\xf1\x56\xab\x3f\x5b\x42\x75\xf0\x4b\x9d\x13\x88\xb7\x6f\x5c\xdb\x2d\x1b\x49\xba\x39\xbf\x4c\x5a\xa2\x23\xd6\x8e\x9d\x5d\x6d\x71\x39\x45\xa3\x0d\x31\x39\x97\x36\xf6\x6d\xb0\xae\xee\x76\xb5\x29\xd6\x26\x67\x13\x77\xff\x88\xae\x0e\x69\x2f\x6f\x68\xed\x5e\x2b\x5a\x62\x51\x89\xde\x18\x8f\xb6\xc9\x85\x29\xbd\xad\xbb\x0b\xf3\x2b\x96\x95\x92\x97\x2b\x94\x67\x41\xd8\x57\x5b\x46\x1d\x46\xa2\x0e\x23\x51\x87\x91\xa8\xc3\x48\xd4\x61\x24\xea\x30\x12\x75\x18\x89\x3a\x8c\x44\x1d\x46\xa2\x0e\x23\x51\x87\x91\xa8\xc3\x48\xd4\x61\x9d\xab\xc3\x3a\x57\x17\x01\x4e\x04\x38\x11\xe0\x44\x80\x13\x01\x4e\x04\x38\xbe\xaa\x33\x70\xc6\xb8\x26\xd2\x97\x56\x22\xad\x42\x5a\x83\xb4\x16\x69\x1d\xd2\x7a\xa4\x36\x52\xc7\x4f\xfd\x28\x45\xa6\x15\x7e\x5a\x89\xf6\x2a\xd1\x5e\x25\xda\xab\x44\x7b\xbe\x8a\x93\x22\xa5\x1e\xa9\x9d\xe1\x5f\x01\x5e\xe3\x5d\x2a\xcf\x96\x87\x6f\x4c\x86\xa4\xee\xf3\x5f\xdd\x4b\xcb\xba\x7b\x05\x7b\x53\x5c\xce\x25\xef\xda\xb5\x9b\x53\x5b\x62\x6e\xa2\xad\x8f\xfa\x5f\x78\x17\xaa\xdd\x5c\x46\xef\xc5\x6a\x77\x43\x77\x2f\x27\x7b\xe5\x92\xd1\x8d\xde\xb7\xb2\xe5\x35\x1d\xad\xdd\x5d\xee\x23\x45\xd3\xdd\x8b\xd1\xb8\xb6\x9e\xe6\xe5\xbd\x6c\xae\xb7\xcb\xbb\x20\x8f\x2f\x73\x52\xf6\x78\x3b\x02\xae\x41\x9e\xa9\x69\x6e\xce\xbf\xd8\xee\xed\x6c\x8b\x76\xc4\x37\x04\xd6\xc6\x92\x7e\xf1\x74\xef\x92\x3b\xf2\x9e\xf1\x7e\x5e\x6f\x89\xf9\x99\xc0\xc6\xe8\x46\x7c\xed\x5d\x8a\xc7\xde\x64\x6f\xc1\x80\x74\x8a\x9f\xcb\xea\xbd\x30\x8f\x2f\xfa\x72\xe9\x5e\xdf\xb1\x57\x76\x1c\xb9\xf6\x6e\x34\x96\xe1\x5f\xa4\xf7\x37\x32\x71\x95\x1e\x66\xf4\x66\xd2\xbd\xcb\xf4\xa8\xb9\x21\x81\x96\xd3\x5c\xf7\x21\xdb\xef\x82\x40\xb2\xd7\x64\x5d\x1a\xef\xdf\xce\x20\x3b\xec\xde\xaf\xe0\x0e\x87\x9b\x4a\x5a\x74\x13\xcf\x23\x9e\x75\xde\x30\xe3\x02\x83\x83\x0b\x0c\x0e\x2e\x30\xc8\xd4\xcc\xe9\xf6\x1f\xfb\xda\xf7\xe3\xca\xcc\x86\xcd\x9d\x72\x55\x88\x37\x78\xe7\xd5\x72\xbc\x1f\xc4\xa7\x7c\x9d\x9b\x92\xef\x74\xef\xd7\x8e\xe9\x72\x58\x5a\x63\x5d\x5d\xeb\xd2\x25\x93\x35\xb9\xcf\xe2\x75\xd9\x42\xf2\x5b\x6f\x3e\xd3\xe3\xb5\xde\xad\x8c\xa6\x44\x77\x67\xff\x86\x9c\x68\x7d\xe5\x3c\x9a\xeb\xdb\xf2\xf8\xae\x6f\xab\xf7\x04\x45\x99\x9c\x47\x15\x59\x7d\x67\x26\xdc\x4d\x2b\x13\x16\xc4\xbd\x2f\xb3\x65\xcf\xdc\xdf\xbd\xb8\xbf\x8d\x29\x6b\x88\x76\xa4\x6c\x57\x0c\xd8\xae\x1b\xb0\x5d\x9e\xb2\x1d\x19\x50\xdf\xec\xdb\xee\x75\xd0\x9a\x44\xd2\x7d\xd6\x79\xc0\x73\x54\x99\xdc\x8b\x92\xd6\x80\x96\xac\x01\xc8\xe6\x20\xdb\x95\x29\xdb\x15\x2e\x7a\xca\x76\xdd\x80\x6d\xab\xb7\x7c\xc6\xda\x68\x67\xbc\x0c\x9d\xcf\xf7\xbe\xac\xad\xf0\x0b\x54\xb8\x8d\x96\x0f\xb2\xaf\x62\xc0\x3e\x6b\x90\x72\xd6\x80\x72\xe1\x41\xda\x0b\x0f\xd2\x5e\x78\x90\xf6\xc2\x03\xda\xab\x1a\xc4\xbe\xaa\x41\xec\xab\x1a\xc4\xbe\xaa\x41\xec\xab\x1a\xc4\xbe\xaa\x41\xec\xab\x1a\xc4\xbe\xaa\x5f\xda\x57\x17\xfa\xa5\x7d\xfb\xec\x1b\x58\xce\x1a\xa4\xdc\xc0\xf6\xc2\x83\xb4\x17\x1e\xa4\xbd\xf0\x20\xed\x0d\xe6\xbf\xca\xde\x49\x36\xc8\xbe\x81\xe5\xc2\x83\x94\x0b\x0f\xc0\x1d\xd0\xde\x3e\xfb\x06\x96\x0b\x0f\x52\xce\x6b\xcf\xfd\x41\x96\x24\xe6\xb8\x77\x3a\x53\xb7\xdb\x9b\xbd\x83\xb1\x37\x63\xf4\x66\x4c\x7d\x4b\xac\x33\xe1\xe6\x34\xb9\x5c\x78\xa9\x5c\x2a\xdc\x34\xe0\x2d\x13\x6e\x4e\x77\x97\x08\x3f\x13\xf7\x0f\x71\xad\x2b\x7e\xa4\x57\xc6\x5b\x22\xbc\x9c\xb7\x3c\x78\x85\xda\xe3\x7e\x43\xd9\x03\xce\x52\x67\x0f\x38\x27\x9d\xb5\xef\xd9\xe7\xec\x01\xa7\x99\xd3\xfa\xaf\x59\xa4\xf5\x5f\xa6\x08\xf4\x5d\x95\x48\xeb\xbf\x06\x91\x37\x00\xa9\xac\xb5\x21\x6f\x00\x98\xdc\x95\xbb\x2f\xde\xbe\x85\xbc\x76\xe4\xae\xcc\x7e\xd4\xbe\xad\xde\x06\x32\xfa\xb0\xfb\xbe\xea\xad\xa6\xfb\x65\xba\x1b\x74\xbf\x6a\x77\x43\x66\x7f\xdb\xee\x6e\x6f\xdd\x96\x99\xf4\xde\x2b\x67\xee\x4e\xbf\x76\x77\x43\x76\xea\xf3\x48\xdc\x2f\xfc\x25\x4c\x7e\xe1\x3f\xd8\x64\x4d\x67\xac\x29\xd6\x29\xc3\xcc\x1c\x8f\x43\x3c\xa6\x01\x1b\xf5\xef\xe8\xa3\x45\x9f\x84\x33\x7b\x37\xbd\xbb\xf5\xf2\xfb\x08\xa8\xff\xb6\xbd\xac\xbe\x7d\x03\x36\xbd\x3b\xf6\x72\x52\xa4\x87\xb7\xd7\x23\x78\x90\x64\xb7\x77\xd3\x9e\x0c\xbb\x6a\xeb\x91\x37\x52\xf2\xa6\x9b\xe7\x4b\xd7\xd4\xda\xf2\xcf\x32\xf7\xcf\x62\x5b\xc1\x5b\x78\x74\x85\x2a\xd9\x0a\xd9\xbb\x57\xe6\xf1\xfc\xee\xe7\x66\x5e\xfb\xa2\x9b\x3e\xb3\xf8\xfd\xdd\xde\xf6\xf9\x4a\xa1\xf7\x8d\xfb\x0e\xd5\x23\x95\x6d\xde\x53\xbf\x73\x15\x85\xff\x5e\x21\xfc\x19\xfe\x8d\xc2\xf8\x7f\xf8\x7f\x64\xfe\x5b\xfe\xad\xcc\x7f\xc7\xbf\x93\xf9\xef\xf9\xcf\x32\xbf\x87\xef\x91\xf9\x1e\xde\x23\xf3\x7b\xf5\x7b\x14\xa2\xdf\xab\xdf\xab\x30\xfd\x3e\xfd\x1d\x99\x7f\x57\x7f\x57\xa1\xfa\x7b\x81\x03\x15\x12\x58\x14\x38\x48\xa1\xee\xb3\x98\x64\x7e\x59\x60\x85\xc2\x02\x2b\x03\xab\x24\x2a\xf7\x9f\x31\xee\xe1\xf7\x7e\xd2\x94\x32\xe5\x60\x85\x4a\x46\x69\x55\xb2\x5a\x62\x6b\x3b\x95\x11\x5e\x39\xf7\xad\x60\x4a\x5f\xce\x2b\xed\x12\x90\xec\xa3\xe2\xbe\x43\xe9\x57\x9f\x43\x3e\x4c\xb6\x19\x56\x66\x29\x8e\x72\xa0\xb2\xc2\x7b\xf7\xc0\x36\xe5\x6c\xe5\x62\xe5\x2a\xe5\x46\xe5\x11\xe5\x4d\xe5\x43\xe5\xdf\xca\xb7\xca\xff\x8f\xbd\xeb\x01\xad\xea\x3a\xe3\xe7\x3b\xe7\xdc\x78\x63\xd3\x98\x3c\x9f\x99\x4a\xd0\x18\x43\x10\xc9\x4a\x16\x44\x42\x91\xe0\x24\x88\x4b\x6d\x10\xeb\x5c\x56\xa4\x88\x95\x34\x93\xcc\x05\x29\x22\xa1\x88\x14\x11\x09\x52\x82\x04\x11\x71\xe2\x44\x8a\x14\x91\x62\xdb\x4c\x4a\x28\x69\x6a\x6d\x96\x45\x17\x53\x97\xa6\x69\x66\xad\xcb\xda\x47\x6d\x6d\xd0\x87\xa4\xae\x4b\xf6\x9d\xef\xdc\xdc\x7b\xde\xbb\xef\xbe\xdc\x17\x8d\xb3\xdb\x78\x9c\xdf\xfd\xee\xf7\xbe\xf3\x7d\xdf\xf9\xce\x77\xce\xbb\xe7\xfe\x79\x77\x1c\xb2\x20\x17\x0a\x50\x07\xe0\x67\x14\xb7\xb3\x18\x88\x56\xbd\x2f\xda\xf5\x56\x1e\xd0\xdb\xd9\x6b\xd1\x06\xb6\x20\x6f\x57\xde\xc5\xfc\x82\xfc\x06\xbd\x97\x7f\x36\x52\x12\x79\x7d\xee\x32\xbd\x37\xf7\xf0\xdc\x91\xe8\xca\xe8\x41\xbd\x17\xed\x9d\x57\x3b\xef\x52\xc1\x3a\x5d\xbf\xe0\xbc\xde\x2e\xd8\xa1\xb7\x85\x05\x24\x65\x2f\xea\x5a\x5c\xbe\xb8\x65\xf1\x48\x51\x55\xd1\xd1\xa2\x3b\x4b\xd6\x13\xf7\xc9\x25\x07\x97\x5c\x58\x12\x2b\x9e\x5f\xbc\xae\x78\x4f\xf1\x99\xe2\xc1\xa5\xf6\xd2\xca\xa5\x0d\x4b\x8f\x2e\xed\xa6\xef\xf9\xd2\xc1\x92\x2c\xad\xa7\x64\xb9\xde\x96\x0e\xe8\xed\xf2\x23\x7a\xfb\xd3\x7e\x6a\x15\xfc\xec\xb0\xb3\x3d\xc6\x38\x6d\xdb\x19\xf0\x23\x7c\x27\xe2\x71\x8c\xd6\x7a\x76\x8c\x9d\xc4\xa8\x9c\x65\xe7\xd9\x05\xf6\x1e\xbb\xc8\x7a\x58\x1f\x1b\xc0\x18\xdd\x64\x31\x8c\x52\x9c\xdd\xc7\x4a\x59\x90\x03\x11\x98\x0f\x8b\xa0\x04\x96\x43\x39\xac\x84\x55\xb0\x06\xd6\x41\x2d\x6c\x82\xe7\x61\x2b\xd4\x43\x23\xec\x82\x3d\xb0\x17\xf6\x43\x0b\xb4\xc2\x11\x38\x0e\xa7\xe0\x0c\x9c\x83\xb7\xe1\x5d\xe8\x84\x4b\xd0\x0b\xfd\x30\x08\xd7\x61\x04\xbe\x86\x51\xb8\x07\x3f\x70\xce\x6d\x9e\xcb\xa3\x7c\x21\x2f\xe2\xa5\xbc\x8c\x57\xf0\x4a\x5e\xc5\xab\x79\x0d\xdf\xc0\x37\xf3\x2d\xaa\xc7\xad\x23\x88\x51\xc2\x6e\x42\xe6\x21\x7f\x89\xe8\xe1\x64\x3e\xb4\x26\x73\x26\x6e\x26\xd3\x5a\x06\xa4\x21\xb9\x28\xb9\x56\x10\x4e\x5c\x34\x38\x7b\x7c\xb8\xdd\xfa\x83\x4b\x07\x69\xb8\x99\x4e\xf3\xc4\xd6\x64\x3a\x85\x9e\x80\x98\x40\x6f\x72\x4c\x1c\x8e\xcf\xba\x13\x07\x39\x9d\x56\xfb\x75\x3a\x32\x5b\x53\xfa\xcc\x59\x96\x9c\xb0\x0a\x19\xb3\x9b\xed\x66\xb6\x08\x67\x8b\x77\xd8\x62\xfb\x8f\xf6\x7b\xac\xc8\xee\xc4\x99\x63\x59\xf6\x33\x38\x67\xac\xa3\xb1\x36\x4a\xe3\x3c\x0b\x7b\xb7\xde\xda\x81\x74\x21\x8e\x64\x60\xc5\x98\xa7\x6a\xee\x00\x11\x23\xad\x80\x7a\x94\xf4\x98\x21\xad\xf8\x97\x70\x7c\x03\xeb\x45\xe9\x08\x2b\x65\x65\xac\x82\x55\xe2\x1c\x50\xcd\x6a\xd8\x06\x9c\x05\xb6\xb0\x6d\xac\x81\xde\xcc\xd0\x8c\xb3\xc1\x01\x76\x48\xd5\xe3\x75\x93\x08\xab\x79\x07\xd2\x6f\x89\x9f\xa3\x8e\xf7\xe9\xad\x65\x15\x8a\xc3\x2a\x44\xf3\x24\xf2\x5f\x90\x64\x17\x5b\xa5\x72\xc8\xa8\x7b\x81\xef\x43\x3c\xc7\xfb\xd4\xb7\xc4\x3f\xc5\xdb\x10\xcf\xc1\x47\x93\xc8\x22\x56\x96\x95\x63\xe5\x5a\xf9\x56\x54\xff\xaf\x2e\xc6\xc3\xfb\x8f\x3f\xf5\x0f\x7f\x9d\xf6\xfb\xd4\xae\xbb\x5e\xbb\x94\x07\x38\x13\x5f\x61\x1c\x23\x88\xa3\x15\x2a\xa0\x12\xaa\xa0\x1a\x6a\x60\x03\x6c\x86\x2d\xb0\x0d\x1a\x60\x27\xbc\x0c\xcd\xb0\x0f\x0e\xc0\x21\x38\x0c\x47\xe1\x04\x9c\x86\x37\xe0\x4d\x68\x87\x0e\xe8\x82\x6e\xb8\x02\xd7\x60\x08\x6e\xc0\x97\xf0\x0d\xdc\x81\x31\x18\xe7\x92\xcf\xe6\x79\xbc\x80\x17\xf2\x62\xbe\x8c\x3f\xc5\x57\xf0\xa7\xf9\x6a\xbe\x96\xaf\xe7\x1b\x79\x1d\x7f\x81\x6f\xe7\x3b\x78\x13\xdf\xcd\x5f\xe1\xaf\xf2\x83\xfc\x35\xde\xc6\x8f\xf1\x93\xfc\x75\x7e\x96\x9f\xe7\x17\xf8\x7b\xfc\x22\xef\xe1\x7d\x7c\x80\x0f\xf3\x9b\x3c\xc6\x6f\xf3\x38\xbf\x2f\x98\xc8\x12\x39\x22\x22\xe6\x8b\x45\xa2\x44\x2c\x17\xe5\x62\xa5\x58\x25\xd6\x88\x75\xa2\x56\x6c\x12\xcf\x8b\xad\xa2\x5e\x34\x8a\x5d\x62\x8f\xd8\x2b\xf6\x8b\x16\xd1\x2a\x8e\x88\xe3\xe2\x94\x38\x23\xce\x89\xb7\xc5\xbb\xa2\x53\x5c\x12\xbd\xa2\x5f\x0c\x8a\xeb\x62\x44\x7c\x2d\x46\xc5\x3d\xf1\x83\xe4\xd2\x96\xb9\x32\x2a\x17\xca\x22\x59\x2a\xcb\x64\x85\xac\x94\x55\xb2\x5a\xd6\xc8\x0d\x72\xb3\xdc\x22\xb7\xc9\x06\xb9\x53\xbe\x2c\x9b\xe5\x3e\x79\x40\x1e\x92\x87\xe5\x51\x79\x42\x9e\x96\x6f\xc8\x37\x65\xbb\x54\x3d\x5a\x67\xad\x55\x91\xcc\x3a\x8d\x7d\x13\x57\x34\xc4\x89\xee\x25\xba\x57\xd1\xbc\x90\x64\x0a\x89\xae\x25\xba\x96\xe8\x7a\xaf\x6e\x02\x6d\xca\x04\xc8\xc3\x0d\xd2\x7f\x23\xd9\xae\xe3\x4f\x9d\xaf\x6e\x07\xd1\x1d\x3e\x5b\xa5\x44\x97\xfa\xe4\x9b\x88\x6e\x22\xba\x9a\xe8\x6a\x1f\x6d\xda\x32\xf9\xe5\x44\x97\x93\x6f\x5d\xe4\x5b\x57\xda\x36\x06\xc5\x21\x3d\x6d\x1b\x3e\xd4\xa7\x8b\x73\x98\xf8\x24\xf8\xe9\xf7\x6d\x2c\x34\xad\xf5\xb7\xa5\xa3\x13\xf2\x44\xd3\x0d\x3e\xff\x4d\x3f\x47\x48\x26\x97\xe8\x16\xa2\x4f\x1b\x76\xdb\xbc\xfe\xd5\x32\x8e\xce\x56\xa2\x07\x3c\x3a\x41\x27\xe9\x11\x39\x44\xdb\x24\xb3\xda\xd0\xb9\xcf\xe8\xd3\xba\x00\xda\xf6\xf5\xf5\x0d\x9f\x6f\x63\x46\x8e\xe9\xdc\xd3\x11\xd0\x6d\x89\x68\x6f\xb5\x8c\x1e\x35\x1e\xad\x75\xf2\xdb\x86\x5d\x83\x76\xfa\xab\x35\x89\x0e\xff\x6b\x90\xef\xfe\x3f\xba\xfa\x77\xf4\x8f\xe9\x5f\xd1\x07\xe5\xe7\xf4\x1f\xe8\x5f\xe2\x9c\xf8\x4f\x3c\xf6\xc4\xe3\x56\x3c\xc6\x53\xef\xea\x61\x6c\x23\x96\x3a\x2c\x2f\x60\xd9\x8e\x65\x07\x96\x26\x2c\xbb\xb1\xbc\x82\xe5\x55\x2c\x07\xb1\xbc\x86\xa5\x0d\xcb\x31\xb4\x71\x12\xb7\xaf\x7b\xb9\xfb\xd0\x70\xa7\x31\x1e\x72\x89\x3e\xe6\xce\xe3\x4f\xfd\x7f\x1e\x9f\xd6\x3c\x5e\xab\x8e\xf9\x1d\x2c\x37\xb0\xde\x43\xf1\xac\x87\x26\x3f\x01\xb7\xa4\xfd\xd6\x87\x70\xda\xc0\xb8\x81\x06\x3f\xa8\x2e\x1e\x81\x78\x9c\x6a\x03\xeb\x0c\x6c\xf3\x10\x2e\x78\xc8\x9f\xf6\x50\x74\x12\x7f\x3c\x59\x8f\xd0\x6d\x69\x24\x7a\x3f\xc9\x74\xf9\xf4\x87\x6e\xa9\x83\xfe\x5a\xb6\x11\xf9\xda\x74\x71\x0e\x13\x1f\xed\xa1\xe3\xa7\x69\xa5\x2f\x33\xc4\xd5\x9c\x1b\x37\x93\x76\xfc\x6c\x4b\x9d\x27\xda\xae\xa8\x32\xf8\x46\xfc\xf9\x08\xc9\xe4\x7a\x51\x85\x32\xc3\xc3\x33\x9e\x75\x98\x6f\xb4\x71\x13\x61\xaf\x81\x66\xdb\xcf\x18\xa8\x7d\x68\x48\xe6\x9b\x71\x4b\xe8\x3b\x03\xcd\xbe\x36\xa3\x9d\x10\x19\xb3\x2d\xf5\x46\x5b\xcc\x38\x94\x7a\x7e\x9a\xfa\x13\xf2\xdc\x8f\x9b\x92\xe8\xf0\xf3\xf8\x42\xd9\x2d\x2f\xcb\xfe\x84\xb7\x59\x7c\x91\xe2\xfd\x15\x77\x64\x5c\xfe\x20\xc7\xf5\xbf\x37\xb3\x85\x2c\xcc\x0c\xce\x9c\x19\x5c\xbf\xef\xf7\x3c\x16\x35\x76\xd4\x79\x8e\x8b\x58\x7a\xb0\xa8\xb8\x0c\x60\x19\xc6\xa2\xde\x4a\x1c\xc3\xed\x6d\x2c\x2a\x76\xf7\x55\xea\xf8\xc6\x40\x34\x00\x83\x64\x82\x6a\xf9\xe5\x83\x38\x15\x81\x7a\x04\xad\x81\x40\xed\x2b\x29\xa6\xce\x7c\xe0\xea\x5f\xde\xc3\xdf\x3e\xae\xce\xc2\x18\x3d\xa0\x62\xbf\x18\xbf\xcd\x4d\xf7\xbb\x89\x1a\x39\x6a\x5c\x45\x3a\x59\x92\xc6\xa9\xea\xa6\xb6\x38\x85\x8f\x94\x19\x8c\x72\x02\x28\x27\x96\xcc\xb4\x8f\x29\x2c\x2a\x1f\x6b\x1c\x1f\xb7\x92\xc6\x3c\xc4\x05\x19\x64\xe6\x64\x5e\x06\x45\x7d\x76\x2a\x5d\x8f\xc0\xee\x9c\x29\xea\x3d\x54\x0f\x52\xf6\xe5\x7f\xde\x83\xa0\xd8\x73\xb6\x22\x21\x8b\xf2\xa7\xcc\x9e\xf4\x63\x4b\xb5\x64\x85\xd3\x92\x9a\x90\x1a\x83\xfa\x4d\xdb\x79\x40\x1f\x03\x32\x7d\x1a\x3e\xa6\x8c\xab\xe7\x63\x0d\x6b\x34\x7c\x8c\x4c\xb3\xff\xa6\xce\x95\xa0\xb8\x2b\x0f\xb6\x3d\x14\x0f\x52\xe7\x4a\x3a\xbb\x8f\xac\xe5\x29\x7b\xf3\x11\xb4\x3c\x55\xdf\x3b\x67\x88\x4f\x3e\xe6\x67\x88\x47\xd5\x1a\x2b\x08\xf9\x6e\x7d\xc6\x20\x35\x3f\x41\x9e\x19\xf4\x21\x5f\xdd\x6e\x03\xd3\x5a\xf4\x23\xbc\x90\x8c\x26\x3f\xb0\x2e\x4b\xf7\xed\xc4\xcd\xd4\x74\x18\xe4\x7d\xfa\xcc\x40\x32\x27\x85\xf5\x43\xbe\x08\x84\x6f\xb5\x2f\xe6\x0e\x46\xd5\x6a\xd8\x41\x8f\x1f\xfe\x58\x52\xc8\x3e\x79\x43\xfe\x83\xae\x6e\xa9\x23\x5b\x35\x2a\x16\xaa\xb3\x24\x74\xae\x64\x23\xe1\xef\xa9\x55\x3a\x7f\x4f\x3c\xde\xf9\x2b\x17\x92\xc7\xfb\xc9\xe3\x16\x8f\x16\x31\xe3\x6c\xc2\x90\xc7\x31\xf9\xa2\xc8\xc0\xa6\xd4\x32\xfa\x7c\x8c\xc9\x4f\xc0\xf6\x64\x8b\x62\x8b\x42\xc7\x2b\xfd\xed\x0a\x1f\xc6\xbc\x58\x9b\xfe\x3b\x7c\xd3\x2b\x43\xa7\xd6\x66\xed\xf1\x6a\x99\xb4\x1f\x03\x63\xd2\x62\xf0\x35\xe7\x84\xcf\xae\x29\x1f\x14\x81\xf4\xad\x6e\x32\x64\xf6\x1b\x7c\x13\x3d\x8b\xe1\xf3\x97\xcb\x6b\xf2\x13\xba\x02\x3a\x5b\x1f\x07\x71\x8a\x23\x8f\xfc\x78\x72\x56\xc4\x68\x35\xba\x8e\xb0\x88\x56\x2d\x63\x44\x9f\x22\x3a\x42\x2b\xc4\x71\x8f\xe3\xf0\x69\x7d\x23\xd7\x33\x77\xf5\xad\xeb\x9a\x32\x8e\xb6\xa1\x64\xbe\x7c\x93\x68\x3a\xbf\xa1\x57\xe8\xa2\xd9\x58\x17\x9b\x7a\x8e\x12\xe6\xf8\x30\x66\xd8\x8d\x25\xfb\xec\x68\x30\xf5\xd4\x7b\x16\x13\x3c\x34\x31\xe6\xc3\xa0\x98\xec\xf6\x22\x63\x72\x82\xa2\x61\x46\xc0\x6c\xbb\x13\x01\x7f\xab\x0d\x9d\x8e\x0f\x55\x86\x7c\x87\x87\xda\xa2\xd4\x6f\xfa\x0e\x9f\xb3\x57\xe5\x88\x99\xb3\xf0\x21\x5b\x86\xf8\x01\xee\xeb\x95\x5a\x95\x71\x7c\x32\xd7\xad\x31\xf5\x31\x0f\xb0\x02\x7a\x27\xa5\x7a\x23\xa5\x6d\x3d\x61\xcd\xb1\x7e\x62\x5f\xa0\x6b\x61\xea\xcd\x56\xea\xbd\x56\x57\xec\xab\xf6\xc7\xf6\xa7\xf6\xb0\x7a\xcb\x13\x5a\x13\x6c\x11\x2b\x61\xcb\x55\xcd\x14\xf6\x40\xde\x22\xfc\x6a\x06\x34\xc7\x67\x58\xf3\xad\x19\xd3\xfc\xcd\x8c\x69\xbe\x3d\x63\x9a\xbf\x9b\x86\x66\x95\x89\xc5\x01\x99\xa8\xf5\x66\xae\x51\x7b\x3a\xa9\x51\xad\xa9\xb2\xe8\x28\x5a\x1f\x41\xc7\x13\xfa\x2f\xac\xfc\x90\xd3\x2b\x99\xe9\x0f\x2f\xaf\xf5\x7f\x1b\x5a\xfe\x6a\x86\xf2\x97\x9d\xbe\x0f\x2b\xff\x95\xd3\xa3\x61\xe5\x6f\x65\x28\x7f\x39\x43\xf9\xab\x19\xca\x0f\x65\x28\xff\x59\x86\xf2\x71\x43\xbe\x18\x67\x56\x8e\x23\xa3\xd0\xa9\x31\xcf\xd0\x38\xcc\x26\xef\x90\x00\x2b\x3f\xa4\xf4\x5d\x47\xfa\x47\x73\x6c\xa1\xee\xe3\xc0\xa3\xaf\x23\x74\x64\xa5\xf0\x28\xa1\xe6\xef\x37\x90\x38\xb2\xd2\xe0\xb4\x1b\x92\x06\xe2\x71\x5d\xca\xba\x29\xf0\x9a\x81\x86\x45\xb9\xde\xe0\x34\xf9\x30\xe6\xa3\xd3\x5b\x31\xfc\xb4\x86\x3d\xfd\x26\x9d\xa2\x56\x50\x4c\xda\x3d\x8e\xd3\xd2\x30\x71\x08\x68\xbb\x23\x13\xf3\x3c\x31\x39\x09\x7a\x34\xbd\xd7\xd7\xf6\x58\x46\x77\xfc\x4c\x9e\xc9\xf2\x8e\x87\xe9\x4e\x1e\x07\x75\xce\xf6\x3e\xde\x39\x9b\xf1\xf5\x35\xf3\x5a\x98\x71\x75\x29\xfd\x95\xc4\xa0\x5a\x33\x87\xe1\xfd\x71\xae\xbd\x6e\xf4\x30\x63\x8b\x1d\x61\xa3\xf1\xe0\x6d\x4f\xb8\xaa\x55\xe6\x62\xf8\x9c\x9d\xce\xd9\xb7\x05\x68\x41\x59\x57\x57\xef\x76\x31\x75\xdf\x2d\x63\x7b\xb1\xa8\x23\xf4\x16\x2c\xad\x58\xd4\x35\xcc\xe3\x58\xd4\xd1\xbc\xba\x2a\x78\x0e\xcb\xdb\x58\xde\xc5\xd2\x89\xe5\x12\x16\x75\xd5\xae\x1f\xcb\x20\x96\xeb\x58\xd4\x6a\xe8\x6b\x2c\xa3\x58\xee\x61\x4b\x9e\x56\xbf\x31\xa1\x70\x7e\x68\xc9\x0c\x11\xc7\xa4\xc2\xfb\x1e\x3a\xe3\xb8\xfd\x71\x1f\xc7\xb4\x06\xaf\xf6\x61\x98\x3b\x3e\x0c\x49\x9c\x8b\xc3\xd6\x0a\xad\xf3\x41\x70\x0a\x7f\x3a\x02\xe8\x07\x40\x68\x35\xac\xb7\x3f\xb0\xb6\xb8\xa7\x73\xf2\x3e\x22\xd2\xdc\xe9\xa1\x21\x1f\x7e\x1c\xa7\xbf\x26\xa2\xce\x2e\xaa\x7b\x2f\x56\xb3\x4c\xef\x30\x9a\x3c\x7b\x14\x84\x67\x0d\xba\xc7\x77\xce\x29\x15\xee\x64\xff\x03\xbf\x85\x53\xcc\xda\xf1\x10\x32\xad\x1e\xcd\xba\x1f\xc5\x6f\x64\xa0\x27\x41\xf7\xb8\xcc\x30\x3e\xa4\x56\xff\x57\xfc\x16\x8a\x26\xf5\xdb\x23\xd4\xf8\xf4\x68\x3f\xaa\x6f\xdb\x03\x64\x62\x84\x3d\x06\x06\xeb\x49\xd6\x19\x60\x57\x3d\xbd\x01\xab\x99\x77\x56\x8d\xd6\x84\xff\x1a\x99\xfc\x8c\x37\xa5\x58\x23\x2a\x19\xf5\xc9\xa1\x75\x5d\xf7\x44\xa5\xb3\xce\x63\x4c\x3f\x3f\x53\x85\xf1\x34\x9f\x9f\x29\x55\x7d\xf8\xec\x33\xd5\x45\x2c\xef\xb9\x8d\x6b\x10\x9d\x27\x68\xb8\xfb\x34\x8d\x7e\x06\x47\xbc\xf8\xe2\x6f\xd1\xab\xed\x8d\xbf\x79\x89\x15\x36\xfe\xee\xc5\x46\x5c\x51\xaa\xde\xe7\xce\xd3\x43\x93\x4f\xe8\x58\x68\x39\x8a\xab\xcc\x12\x56\xe6\xf0\x96\x39\xcf\xcc\x54\x39\xdb\x5a\x75\xb7\x3a\x66\x4f\x9e\xde\xe7\x35\xa8\x23\x8f\x59\xd9\xbf\x62\xdf\xb2\x9a\xec\x5f\x67\xd7\x21\xd7\x12\x5f\x88\xbf\x8b\x11\xf1\x9d\xb8\x83\x7b\x11\x1d\x0b\x26\xd5\x53\x43\xd6\x13\xd4\x22\xf4\x11\x8e\x63\x7e\x54\xb2\x35\x38\xcb\x6d\x66\x5b\x71\x86\x7d\x19\x73\xe3\x20\xce\x78\xa7\x31\x07\x3a\xd9\x10\x1b\x51\x8f\xe2\x40\x14\xe7\xb5\x65\x50\x81\x73\xda\x5a\xd8\x00\xea\x09\x17\x99\xbd\x09\x63\x1a\x27\xea\x97\x2e\xb5\xd9\xa5\x9e\x43\xea\x2e\xd9\xfb\xc8\xa5\xba\x5d\xea\x4f\x2e\xd5\x43\x14\x8e\x00\x96\x63\x0f\x23\x3d\x6a\xff\xd9\xfd\xae\xd7\xa5\x2e\x1b\x52\x57\x14\x6d\xbf\x85\x78\x8b\x9e\xc0\xca\x65\x51\x1c\x1d\x5c\x7e\x95\xfd\x2c\xe2\x77\xf6\x5f\xdc\x5a\x7d\x44\x29\x99\x3c\x56\x90\xfd\x0c\x13\xf2\xae\x1c\xcd\x5e\x4f\x56\xae\xba\x52\xfd\x2e\xf5\xb1\x4b\x5d\x73\xa9\xbf\xba\xd4\x80\x4b\x7d\xe2\x52\x83\x2e\xf5\x29\x51\xb3\xd0\xd2\x7c\x56\x84\xfd\x55\xce\x56\xb2\x55\xf6\x07\x68\xf3\x7b\xf4\xf6\x03\xb2\xfd\xbd\xdd\x85\xdb\x31\xdc\xef\xa2\xfd\x31\x7b\x88\xda\xf2\x3e\xe2\xf7\x76\x27\xe2\x18\xe9\xfa\xcc\x69\xed\x2c\x1c\xd7\x38\xc2\x70\x6e\xb0\x98\xb0\x66\x61\xaf\xcd\xb6\x9e\xb4\x9e\x64\x73\xac\x39\x56\x1e\xcb\xb3\x22\xd6\x5c\x16\xb1\xe6\x59\x0b\xe8\xce\x25\x46\xd9\xad\xce\xc8\xe9\xac\x51\x99\x61\x61\x5d\x66\xcd\xb6\xe6\x5a\xea\x8e\x21\x41\x73\xc3\xbd\xc0\x7b\x24\x6a\x30\xf3\xf2\x50\x43\x19\xfa\xbe\xda\x89\xf6\x87\x14\xd3\x8b\x88\xb7\xc9\xb7\xbf\xa9\x35\x24\x51\xd7\x5d\xea\x73\x97\x7a\xc7\x91\x33\xec\xfe\x3b\x00\x00\xff\xff\x34\x4f\x4d\x41\x98\x3d\x04\x00") + +func liberationmonoBolditalicTtfBytes() ([]byte, error) { + return bindataRead( + _liberationmonoBolditalicTtf, + "LiberationMono-BoldItalic.ttf", + ) +} + +func liberationmonoBolditalicTtf() (*asset, error) { + bytes, err := liberationmonoBolditalicTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationMono-BoldItalic.ttf", size: 277912, mode: os.FileMode(420), modTime: time.Unix(1459927769, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationmonoItalicTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xbd\x77\x7c\x54\xd5\xd6\xff\xbf\xf7\x39\x33\x99\x84\x84\xf4\x06\x01\x66\x92\x90\x50\x02\x04\x08\x10\x40\x20\x43\x49\xe8\x10\x08\x25\x43\x28\x09\x1d\xa4\x04\x02\x52\x14\x09\x0a\x88\xf4\xa6\x88\x20\x82\x62\x43\x94\xa1\x49\x40\x9a\x8a\x5d\x04\xaf\xd8\xae\x0d\x41\x88\x57\xb1\x83\x0d\x32\xf3\x7b\xef\x73\x4e\x20\x72\xf5\xde\xe7\x79\xfd\x9e\xff\xbe\x5c\x57\xf6\x39\xbb\xac\xf5\x59\x9f\xb5\x76\x3b\x41\xaf\x90\x42\x88\x48\x7e\xd8\x84\x2b\x27\x67\x40\xef\x22\xd7\xc0\xa6\x42\xbf\x1a\x4e\x6d\xad\xae\x5d\xb2\x73\xe6\x7c\x5a\xfc\x0e\xef\x8d\x78\x5f\xd2\x35\xb7\x6f\xde\x3b\x47\xdf\x7a\x8f\xf7\x7d\x42\x64\x74\xe8\x9a\x37\xb0\xd3\xe4\x9a\x7d\x5e\x16\xb6\x26\x97\x85\xd0\x5b\xf4\xcd\x4b\x6f\x2e\xa6\x1c\x3a\x2c\x84\x7c\x92\xfe\x85\xa3\x26\x17\x15\x77\xae\x55\xeb\x3d\x21\xea\x4d\x12\x22\xa0\xc9\xa8\xdb\x66\xb8\x26\xf7\x9b\xd1\x41\x88\x5b\xb6\x0a\xa1\x79\xc7\x16\x8f\x9b\x7c\x67\xd1\x73\x11\x42\x34\xde\x2c\x84\x63\xdf\xb8\xa2\x92\x62\x11\x2f\x82\xd0\xcf\x70\x11\x3e\x6e\xd2\x9c\xb1\xa7\x5c\xd7\x9e\x15\x62\xd4\x61\xa1\xa7\x97\x8d\x1f\x53\x34\xba\x22\x76\xa1\x0f\xfd\x0a\x4f\xab\xf1\x54\x04\xcd\xb3\xbf\xc3\xfb\x68\xde\xeb\x8e\x9f\x3c\x63\xf6\xc7\x97\x5e\x6a\x89\xee\x40\x21\x52\x46\x4f\x9a\x3a\xaa\x28\xec\x9e\xa6\x4b\x84\xe8\x90\xcb\xfb\xa4\xc9\x45\xb3\x8b\x43\xc7\xd8\x5e\xa3\x3f\x75\xc2\x35\xa5\x68\xf2\x98\x6f\x7f\x78\xb1\x95\xd0\xd7\xcd\x10\x22\xf8\x64\xf1\xd4\x92\x19\xe7\xde\xea\xb7\x5d\xe8\x0f\x77\x11\xa2\xe0\x60\xf1\xf4\x31\xc5\x07\x27\x45\x2c\x16\xa2\x25\xe3\x03\xfa\x18\x5c\x69\x42\x6c\x3b\x5a\x76\x79\x44\x58\xbb\x2b\x9a\x33\x50\xe1\x14\x6f\xad\xab\xdd\xb5\xb2\xbc\x96\x52\xb1\x31\x60\x83\xe3\x23\xfa\xa9\x46\x69\x74\xe0\x67\xc0\x53\x15\x1b\x21\xf9\xe4\xb5\x94\xdf\x77\x05\x6c\x10\xa3\x45\x8c\xa8\xf2\x27\x28\x5f\xf5\x09\x1a\x22\x93\x44\x37\x31\x4a\x04\x30\x3a\x5c\xa4\x8b\xa1\x8c\xe8\xad\x47\x08\x9d\x56\xdd\x76\x52\xae\x16\x76\x21\xec\x0f\xda\x33\x44\x1d\x59\xdb\x28\x73\xf5\x22\x31\x56\x8b\x0c\xb4\x6b\x0e\x5b\x90\xa6\xd9\x83\x6c\xb6\xb3\xa2\x9a\xdf\x2d\x66\xfb\x2b\xad\x37\xeb\x98\xd7\x99\x27\x97\x2f\xd9\x56\xee\xbb\x53\x21\xd1\xc6\x15\x0a\x79\xec\xf3\x5f\xd1\xde\xd6\x9e\xad\x98\x10\xa1\xb6\x93\x62\x9d\xea\x4d\x69\x89\x7c\x10\x99\xc3\x73\x2d\x24\xd9\x76\xd2\x7f\x1e\xf1\xdb\x4e\x6a\x43\xa8\x6f\x49\xdd\x7a\xca\x62\xca\x19\x48\x1e\xcf\x59\xc8\x3d\x3c\xdb\x11\x35\xae\x05\x52\x0f\x19\x8a\xb4\x43\x06\x28\x1b\xf4\x71\x5a\x75\xb7\x59\xfd\xbd\x96\x8e\x4a\x51\xef\xc1\xd8\xda\x40\xd9\xc6\xaa\x6b\x63\x89\xa7\xca\x7b\x11\xb2\xcc\x7a\x5e\x88\xc4\x5b\xcf\x63\x6f\x2a\xeb\x23\x6f\x22\x53\x90\x27\x90\x89\xe8\x7e\x9e\xf2\x05\xca\xb3\x94\x9f\x81\xa3\x21\x65\x7f\x64\x3a\x75\xe3\xf0\x11\x5f\x44\x77\xa4\x07\x52\x6c\x89\xb2\xfb\x21\xd2\x17\xc9\x45\x52\xe9\xfb\x22\xe5\xdd\x48\x6d\x8b\xb7\x5c\xb3\xaf\xbf\xc2\x1a\x73\xc4\xb4\x2b\x43\x28\x95\xaf\xcf\x22\xa3\x68\xbf\x82\x7c\xcf\xb3\xb2\x7b\x06\x7b\x51\xbc\x7f\x63\xd9\x50\xdc\x2b\xec\x2b\xa8\x3b\x45\x39\x13\xc9\x37\xfb\x28\x4c\xf2\x5d\x4a\x38\x94\x41\x94\xb3\xcd\x31\x8a\x7b\x55\x27\x0e\xf1\xdc\xd5\xaa\xeb\x80\x14\x32\x2e\x12\x3d\x1f\x53\x77\x92\xf7\x8f\x78\x2e\xa3\x24\x2e\xb2\xad\x85\xbb\x1b\x42\x5f\xa1\xde\x33\x4d\xde\xff\x52\x1e\xb8\x29\x16\x6d\xaa\xc4\xa1\xaa\xa4\x56\xe1\xff\x66\x79\x08\x3d\x67\xac\x58\x54\x95\x17\xac\x31\x29\x16\xef\x7f\x21\xfe\x7f\x56\x89\x43\x55\x49\xbd\x49\x46\xde\x88\xc3\xbf\x89\xea\x9f\x68\xc5\xa2\x8a\xa8\x58\xa8\x98\x19\xe5\x06\xcb\xde\x4d\xa5\x31\xb6\xf8\x3f\x94\x0a\x7f\x80\x85\x61\x8a\xed\xcf\xb9\xfb\x9f\xca\x19\x56\x4e\xfd\x5d\xd9\xc6\xf2\xa7\xb2\xac\xe4\xf8\xbf\x94\xfe\xdf\x6d\x66\x6e\x2e\xb3\xf2\xb4\x8d\xf5\xae\x64\xa1\x15\xfb\x2a\xa5\xff\x52\x95\xf7\xe6\x56\x79\xb3\xed\xca\x72\x94\x55\xe6\x5a\x71\x2d\xfe\x8b\x32\x02\xd1\xac\x31\x47\xac\x32\xbc\xca\x7b\x7d\x8b\xa7\xbf\x2b\xdf\xb4\xe6\x8d\x9a\xbb\x7b\xad\xf2\x25\xab\xed\x9e\xff\x45\x39\xd1\xc2\xfb\x82\x35\xe7\x2a\xe7\x7d\xc3\x7f\x2f\xd5\xbc\x30\xe6\xfc\x2d\x36\x63\x4d\x33\x9e\xdb\x58\x65\xf3\x2a\xb1\x4e\xb5\xfa\x44\x5b\xef\x8d\x2d\x5f\xc7\xd8\x8c\x75\xcf\xaf\x7c\xc8\xb4\xfa\x3f\x62\x33\xd7\x86\xda\x56\x6c\x2a\xe3\xa0\xde\x83\x4c\x7f\xfd\x91\x55\xb8\xac\xe4\xaf\x29\x12\x65\xda\x31\xd6\x93\xca\xf9\x36\x0d\x51\xbb\xc1\x54\x8b\x9f\xe9\x55\x78\x9a\x8c\x94\xda\xcc\x7c\x55\x3a\x1e\x32\xf3\xe0\xba\x9f\x5b\x90\x72\x0b\xb7\x8a\x8f\xf2\x57\xad\x7b\x25\xa6\x8f\xca\x8e\x86\x2e\x89\x4e\x71\x97\xb9\x07\xf8\x7f\x30\x45\x54\xbf\xf1\x6c\xac\x07\x3f\xfc\xf9\xdd\xb0\x59\x99\x83\x95\x3e\xa8\x18\x2c\xff\x1f\x94\x33\xfe\x62\xde\x3d\x60\xcd\xf9\x19\x55\xd6\xc6\xbe\x55\xf8\xbb\x29\xdf\x8c\x35\x3d\xde\xcc\xf5\xaa\x98\x2b\xc7\xf9\x2f\x23\x17\xad\xf1\xa3\xfe\xdd\x8e\xb1\x2e\x25\xfe\xc5\xbc\xbf\x79\xbe\xde\x3c\xdf\x6e\xce\xfb\xaa\xf9\x7e\xe4\x2f\x7c\xbd\x39\xbf\x6d\x48\x82\xed\xcf\x73\xcc\x81\x64\x20\xc3\xab\xc4\xee\x66\x3c\x7f\x37\xef\x2a\xcb\xca\x7c\x6f\x66\x33\xd7\xd5\x34\xc4\x85\xd4\xa1\x7e\x3e\xf2\x18\x72\x90\xf7\xa9\xe6\xb3\x98\x80\x74\x34\x73\x46\xfc\x42\xdd\x6f\x94\xb1\x94\xdb\x4c\x9b\xfe\xa3\xb6\x1b\x6b\x49\xe5\x3c\x50\x38\x1f\x46\x0a\x2c\x5b\x77\x5b\xf5\x3d\x2c\x19\x8d\xd4\xb0\xdd\x58\x7f\xc7\x59\x63\x6b\xda\xcc\xbd\xab\x0f\x12\x68\xe6\x9f\xff\x65\x2b\xbe\x6a\x2f\x52\x79\x4c\xee\x89\xde\x66\x1e\x5e\x5f\x6b\xe0\x5b\x76\xb1\xf4\xd6\x36\x45\x72\x8e\x10\x6e\x24\xdd\x12\xe6\x9a\xbf\x4b\x95\x31\xc5\xa6\xcf\x46\xbe\x4f\xb5\x6c\x56\xca\x44\xcb\x0e\xeb\x8b\x94\x96\xfd\xbe\x56\x3c\xba\x9a\x22\x7b\xa2\xef\x9c\xcd\xdc\xbb\x3f\xb4\xf0\xb1\x1f\x8b\x45\xd4\x7f\x82\xec\xb4\xf6\xd7\xed\x66\x9c\x0c\x71\x98\xdc\x89\x6b\xc8\x31\xab\x7f\x07\x2b\x36\x0a\x53\x17\xcb\xc7\x5e\x56\xde\xaa\xbe\x5b\x2d\xac\x6a\x1f\xde\x81\x84\x98\x62\xc4\x41\xad\x35\xf3\x6c\xe6\x7c\x0d\xa3\xee\x53\x4b\xcf\x2e\x4b\xd7\x18\x53\x24\x71\x90\xf8\x2a\xc9\x2f\x8d\x73\x9b\x2c\xb1\xa4\x09\xed\x5f\x20\xdf\x51\xcf\xf9\x41\xfe\x44\x59\x64\xc9\x4a\x64\x13\x42\xec\xe4\xfd\xea\x94\x49\xbf\x5b\x6d\xe6\x3a\x72\x9b\x29\x92\x76\xf9\x06\x7d\xc8\x13\x09\x07\xda\x2d\xe6\xb9\xc2\xe0\x7e\x3f\x25\x6b\x9d\x64\xef\x93\x6b\xa9\x27\x36\x92\x73\x8b\x3c\x80\x4c\x42\x98\x5f\x52\xc5\xf0\x0f\x4a\x72\x59\xbb\x0f\x61\x5e\x4a\x85\x6f\xbe\x95\x6f\xd5\x78\x1e\x62\xae\x37\x1a\xf9\x22\x3b\x23\xb1\x26\x16\x39\xe3\x2f\xc4\xf2\x4b\x28\x3c\xcf\x21\x73\x4d\x1d\x7e\x75\x36\x6a\x6c\xf1\xf6\x33\xe5\x2a\xca\xaf\x10\xe2\xeb\x67\x1e\xc8\xaf\xd1\x1f\x61\xe2\x17\x9f\x5b\xd2\xcc\xca\x9b\x57\x85\xf0\xfd\x20\x84\xdf\x83\x70\x87\xb8\x96\x41\xc9\xbd\xc0\x57\x42\xb9\x8a\xa3\x71\x63\xca\xc9\xbc\x7f\x4c\xf9\x25\x25\x27\x6c\xff\x44\xea\xdd\x94\xa7\x91\x86\xc8\x4a\x64\x18\x72\xc5\x14\x91\x88\x14\xd0\xf7\x5d\x64\x03\xb2\x09\xd9\x4e\x5b\x37\xea\x1f\xa2\x0c\xe6\x7d\x35\x72\x14\xe1\xce\xe4\x4b\x45\xf2\x4d\xbb\xd7\x7a\xf3\x8c\x4d\xdf\x16\xe4\x43\x64\x19\xe2\xa5\x8d\x53\x7d\xc5\x9b\x3c\x47\x22\xdc\x83\x2a\x7e\xa7\x1c\x6c\x8e\xad\xf8\x8c\x92\x13\xfd\xb5\x9f\x29\xab\x23\x85\x08\x98\x2b\x6e\x47\xb0\xeb\xbb\x0d\xb9\x68\x8d\xe7\x0e\xc4\x55\x4a\xf8\x9f\xe6\x47\x35\x9e\x8b\x79\x1e\xcb\xf3\x1a\xca\xba\x08\x97\x30\x7f\x33\x24\x0e\x09\x65\x4c\x3f\x0b\xc3\xa3\xbc\xd7\x44\x9a\x23\xc9\xbc\x0f\x42\x5e\xa4\x3d\x96\xf7\xaf\x19\xdf\x9a\x72\x11\x75\xb3\x90\x8f\x90\x32\x13\xa7\xa8\xc1\x85\x64\x21\xcf\x3b\x91\x24\xfa\x30\x53\x7d\x67\xa9\xaf\xc3\xf3\x57\x96\x6f\x1f\x98\xa2\x9e\x0d\x9f\xcf\xf1\xbe\x9b\xf2\x11\xe4\x13\x04\xc0\xbe\xfd\xc8\x05\x04\x6e\xfd\xdd\x11\xee\x34\xbe\x4f\x11\x38\x93\xb3\x79\x3f\xa8\xe2\x43\x3c\x0b\xad\xf9\x34\xc2\x66\xdc\x29\x34\x35\x37\x9e\x37\xd7\x51\x75\x0e\x36\xf2\x64\xb8\xd5\x5e\xf9\xac\xe6\xe1\xf9\x2a\x77\x8f\x59\x3c\x3f\x6a\xad\x7f\x67\x6d\x37\xce\xb5\xd6\x3e\x6e\xac\x8d\x95\xf7\x8e\x3a\x56\x5b\x5b\xeb\x9d\x3d\xda\xd8\x93\x5f\x30\xd7\x29\x63\x9e\xab\xbb\xc7\x3f\xac\xf1\xaa\x7e\xbc\xb5\x0e\xe6\x9a\x76\x8d\x39\x3e\xde\xda\xbb\xd8\xab\xc5\x60\xab\x7d\xa5\xd5\xe7\x41\xab\x9f\x5a\x67\x83\x2c\x4c\x6a\xdd\x5c\x6f\xf9\x9a\x4d\xdd\x17\xd6\xbb\x3a\xd7\x7f\x62\xe9\x54\xfb\xda\x1a\x9b\x79\x86\xa9\x59\xc5\x56\xb1\x55\xaa\xba\x05\x48\x8e\x39\x1f\x7d\xea\xec\xd8\xd2\x6a\x8f\x61\xec\x49\xdb\x8d\x7d\x45\x71\xa3\xf6\x09\x75\x17\x53\x6b\xa8\x3a\x3f\xa8\x35\x83\x79\x2d\x0e\xd3\xf7\x3d\xe4\x75\x9e\x9f\x42\x76\x9a\xe7\x0d\xff\x7e\x6b\x8e\x55\xde\xe1\x8a\xac\x35\x71\x9a\xb5\xee\x95\x59\x36\xd4\x5c\x54\xfb\xfd\x09\x0b\xcf\x14\x2b\x36\x6d\xac\x33\xd0\x0c\x93\x67\x3f\xeb\xa3\xff\x19\xdb\x8d\x33\x59\x73\xdb\x8d\xf3\xd1\x7c\x33\x6e\x46\x7d\x7d\xdb\x8d\x7b\x89\xda\xbb\x58\xdf\xfc\x9f\x59\x7d\xb2\x6c\x37\xf6\xb5\x8c\x2a\x31\xaf\x8c\x7b\x6f\xab\x7d\x83\xc5\x4f\x65\x1b\xe3\xfc\xeb\x6d\xff\x7e\xdf\xac\xdc\x97\xdf\xb4\x74\x56\xc6\x3c\xce\x66\xee\x15\xea\x4c\xf2\xad\x65\x5b\x58\xfd\x9b\x9b\x75\x7e\x95\x27\x6a\x6f\xaf\xdc\xeb\xe0\xc4\x3f\xdc\xe2\xe2\x01\x8b\xe7\xca\xfd\x0c\xce\xfc\x9b\x2d\x3e\x7a\x59\x31\xe9\x55\xe5\xce\x79\xda\xda\x8b\x5b\x9a\xf7\x4c\x63\x1f\x7b\xda\xba\xdf\xa8\x35\x51\xf9\xa5\xf6\x3a\x75\x26\xee\x67\xee\x25\x6a\x1f\xbb\x7e\x17\xb1\xec\x1b\x38\x15\xff\xd6\xbd\xca\x38\x57\x3d\x6b\xe9\xb0\x70\xa8\xd2\xb0\xa5\x70\xa8\xbc\x1f\x68\xbb\x71\xbe\x7a\x1f\xf9\xc3\x9c\x23\xc6\x3e\x59\xf9\x4e\xdc\xfc\x87\xac\xf7\x97\xad\x58\xab\x33\x00\x3e\x19\xb9\x5e\x99\x67\x4f\x98\xf9\x74\xbd\x74\x58\xb8\x55\x7b\x03\x8b\xc3\x90\x2a\x76\x15\xf6\x75\xc8\x74\xe6\x3f\xeb\x8d\xbf\x13\x6b\x4b\x13\x84\x75\xc9\x37\x85\x35\x31\x05\xb9\xd5\xf6\xe7\x73\x56\x51\x95\xdc\x9a\x63\xe6\x88\xe8\x84\x2c\xb5\x5d\x9f\xc7\xd7\xef\xbe\x35\xad\x38\x64\x59\xbe\xdf\x5c\xce\xb7\xc6\xb5\xb1\xf8\x50\x67\x88\x14\xf3\xec\x6a\x9c\x5f\xf3\x2c\xbf\x4a\xac\xf2\x4d\x33\x56\xc6\x3a\xf0\xac\x95\xb3\x39\x66\xce\x18\x71\x53\xfa\x06\xd9\xcc\x3b\xd9\xd3\x55\xca\x4a\xfc\x6a\xbd\x49\xac\x52\x16\x55\xc1\xda\xce\xc4\xaa\xf2\xd4\x58\xa3\x14\xbf\x5d\xac\xb1\x55\x75\xc6\x5b\xbe\x07\xfd\x87\xf3\x77\x65\x5e\x8f\xb1\xdd\x38\x77\xce\xf8\x0b\x5e\xea\x5a\x31\xba\xf9\xae\xf8\x77\xe7\xd3\xe6\x56\xfe\x1d\x35\x73\xe8\xe6\x52\xcd\x19\x03\xe3\x2c\x2b\x1f\x85\x19\x7f\xff\x23\x56\x2e\xaa\xb9\x15\x7d\xa3\xac\xfc\x56\x63\xac\x7f\x6a\x7f\xbf\xcd\xf2\x59\x9d\xf9\x1e\xb1\xe6\xfe\x76\x53\x8f\x31\x0f\x95\x2f\xea\x0c\xa6\xd6\x2d\x95\x17\xad\x91\xdb\xab\x70\x56\x89\xd3\xb8\x3f\x92\x47\xbf\x08\xa1\xfd\x86\x70\x1e\xd0\x5e\x46\xfa\xb3\xdf\x74\xa1\x64\xbf\x94\xaa\xfe\x5e\x4a\xce\x0d\x92\x3d\x51\x1b\x69\x8a\x64\x5f\x97\xe9\x3c\x3b\x11\xf6\x62\x59\x0f\x89\xb3\xfa\xa9\x6f\xac\xec\xcd\x32\xc3\x1c\xab\x75\x32\xdb\xb5\x7b\xac\xb1\x5d\x2c\xbd\xea\x79\x26\x7d\xd1\x25\x4e\x99\x22\xd9\xcf\x65\x20\xd2\xc0\xd4\x6f\xd8\x60\xdf\xd4\xd8\x6f\xc5\x65\xca\x4c\xea\xd4\x79\x8e\x31\xda\x1c\xf5\x1d\xc8\x6a\xff\x40\x7d\x73\xa3\xe4\x9c\xa3\xee\x8f\xa2\x9c\xfe\x3e\x6b\x3d\x55\xf7\xc2\x7b\x6d\xe6\xbe\xc3\xfc\x92\xab\xcc\xf3\xa0\x71\xce\x66\x4f\xd2\x14\xc7\xaf\x9a\x39\x6a\xcc\xd5\xda\xe6\x3c\x96\x6a\x1d\x57\xeb\x9d\xba\xab\xa8\xfb\xb9\xfa\x5e\xa5\xce\xfc\xdc\xb7\x8c\xb5\x5b\x58\xe3\xd4\x5d\x52\xe5\xba\xfa\x0e\x15\x63\x8a\x16\x4a\xa9\xf6\x05\x75\xcf\xe0\xec\x68\x7c\xb3\xe8\x66\xc5\x46\xe5\xb0\xba\xff\x8e\xb6\x72\x80\x73\x9e\xb8\xc3\x66\xee\x7d\x9b\xad\x5c\xeb\x6b\xc5\x48\xf5\x51\xeb\x54\x3d\xdb\x8d\xb5\x61\xa7\xd5\x57\xf9\x39\x12\xdd\xa7\xcd\x52\xaa\xfb\xd6\x3c\x6b\x5f\x62\x2f\xf0\x3f\x67\xbb\xfe\x5d\xce\x38\xbb\xab\x73\x2f\xfb\x95\x9f\xf3\xae\xf8\xc9\x5a\x1b\x8b\xcc\xb1\xc6\x3a\xa8\x72\x43\xe5\xc8\x9d\x94\x3f\x22\x17\x90\xb7\x91\xb3\x16\x0f\x6a\x1f\x7b\x0d\x3b\x9c\xfd\x65\x23\x9e\x2f\x99\xe7\x59\x63\x9f\x55\xe7\xd3\x0f\xac\xf6\x66\xd6\x18\xc6\x4a\x75\x2f\xe2\xce\xa5\xbe\xf9\x19\xe7\xde\x14\xeb\xfb\x9e\xfa\x86\x97\x84\x24\x5a\x67\x62\xb8\x91\x3d\xac\xb3\xb2\x3a\x33\x7f\x66\xbe\x1b\xdf\x18\x55\xcc\x9a\x22\xcc\x45\xd9\xd8\xe4\x55\x6a\x08\x73\x58\x76\xb4\x6c\x83\x41\xaa\xf8\x28\x9f\xbe\xb5\xbe\x21\x28\x1c\xbf\x9a\x75\x92\xd8\xcb\x81\x26\x66\xa1\xd6\x85\x35\x16\x5f\xea\x8c\xb1\xcd\x76\xe3\x3e\xda\xd6\x8a\x13\xf1\xf0\x3f\x65\xae\xe1\xfe\x04\x2b\x26\xea\x7e\x38\xc8\x8a\x89\xfa\x76\x01\x87\xb2\x95\xcd\x3c\x93\xbf\x64\xde\x11\x94\x18\xeb\x8e\xda\xf3\x9c\xd6\xdc\x55\x6b\xe8\x0e\xeb\xbe\xa3\xf6\xc1\xaf\xad\x38\xf6\xb6\xfa\x4e\xb0\xe6\x37\xdc\x89\xf7\x4d\x7d\xc6\x3c\x57\x77\xda\x6c\x6b\xae\xab\xbc\xd9\x64\x3d\x2b\xbe\xd4\x3e\x9d\x68\xe5\x0d\xeb\xaf\x1f\x3f\x25\xeb\x94\x1c\x64\xdd\x57\xe8\x27\xd5\x7d\x45\xc5\x48\xc5\xd3\x6f\xf2\x23\x59\x7f\x34\x69\x8a\x7a\x56\xdf\x4a\x35\xdd\x9a\x13\xf7\x5a\xeb\x86\x3a\x9f\xa8\xfb\x47\xaa\xf5\x3d\xb5\x8d\xc5\xb9\xca\x6d\xd6\x12\x79\x1c\xa9\x6d\xc5\x82\x75\x4e\x7a\x2c\x9b\x19\x56\xbd\xca\x6d\x75\x27\x2a\x62\xaf\x6a\x81\x30\x9f\x7d\x57\xac\xfb\x03\x67\x7f\xff\x6c\xf3\x3c\xee\x57\xe7\xf2\x00\xeb\xec\xfb\x1c\xf3\x55\xdd\x19\x1a\xd9\xfe\xfc\x3d\xa0\xc7\x5f\x94\x55\xbf\x4b\xfe\xb7\xb2\x72\xdf\xbe\xf9\xfb\xe4\xe4\x9b\xf4\xaa\x7a\x75\x7e\x3b\x62\xfb\xfb\xef\x93\x56\xa9\xe6\x8f\xda\xe3\xaf\xd7\x77\xb1\xfd\xf9\xbb\x49\xe5\x77\x9c\x9b\xcb\xbf\xf8\x36\xf9\xa7\x32\xde\xca\x8b\x9b\x4b\xeb\xdc\xf1\xb7\xe5\x7f\xfb\x5e\x52\x79\x0e\xa8\x52\x5e\xff\x8e\x73\xfb\x9f\x4b\xff\x5b\xb6\xff\xfe\xfd\xf2\x2f\xbe\x63\x1a\xa5\xda\xd3\x38\x23\x1b\xf3\xa3\xea\x37\xb2\x2e\x96\x8c\xb6\xe4\xe6\xef\x46\xea\x1c\xf4\x6c\x95\xb2\xf2\xbb\xe6\x7f\x29\x2b\xcf\x13\xd7\xcf\x15\xd6\x77\xa1\xbf\xfb\x06\xaa\x62\x65\xe0\x1c\x65\xed\xc3\xdd\xcd\xfc\x56\x6b\xf9\xdf\x7d\x1b\xff\xbf\x2a\xff\xc7\xdf\xcc\xff\xae\xfc\x6f\xdf\xe6\xfe\xaf\xcb\x9b\x63\xa4\xe6\xcb\xa2\xff\x41\x59\xf5\x5b\xf4\x5f\x95\xe3\xff\xb3\x5c\xff\x9d\xcc\xac\x9b\x4a\x4b\x8c\x73\xf4\x5f\x88\x5f\x7d\x8b\xe2\x3e\xeb\x63\x7d\xf2\x15\xdc\x28\xaf\xdf\x2d\xfe\x46\xd4\x38\xf5\x8d\xcb\xe8\x3f\xa5\xca\xf8\xe1\xa6\x18\xf7\xc9\xff\x20\x7f\x1a\x5f\xf0\x17\xe3\x8b\xff\x46\x92\x6d\xc6\xf9\xda\xc7\x7e\xef\x53\x3a\xd4\xd9\x4d\xd5\xcd\xfb\xcf\xa2\xf8\x50\xfa\x2b\x58\xef\x7d\xea\xdc\x5d\xf3\x3f\x8b\xba\x93\x2b\x31\xec\x1c\xb9\x61\xc7\x1f\x6d\xca\x75\xee\x2b\xb9\xac\xe4\xa6\xd2\xc7\x4a\xbc\x95\x18\x2a\x75\xff\xff\x8d\x63\xfa\x7f\x96\xbf\xe5\xd5\x6d\xca\xff\xca\xef\x63\xff\xc1\xef\xff\x84\xbd\x8a\x48\x75\x8e\x9e\x66\x95\x6a\xbf\x7e\xfd\x26\xcc\xb9\x16\xee\x3d\x7f\x16\x63\xfe\x3e\x62\xc9\x8e\xff\x90\x4b\xd6\x5d\xde\xef\x35\xf7\x72\xe3\x5c\xf2\xb2\x35\xe6\xe6\x1c\xf8\xc2\xba\x0b\x54\xd6\xbd\x60\x8a\xc1\xf1\x14\x93\xb7\xca\xb8\x19\xbf\x87\xfe\x2b\x7e\x2e\x99\x76\x2a\x79\x52\xa2\x7e\x37\xa2\xce\xd0\xfe\xf7\x11\x97\xf5\xbd\x4a\xdd\xf7\xd4\x59\x79\x23\x7d\x2e\x58\xa2\x7e\x1f\xce\x3e\x21\xd5\xd9\x90\x3b\xaf\xa6\xce\x28\xea\xbb\x8e\x3a\x33\xaa\x73\x59\x57\xf3\x0c\xa7\xbe\x89\x1b\xe7\xbf\x10\x4b\x97\xda\xfb\x23\x2b\xc5\x66\xfc\xce\xc2\xf8\x9d\xfb\x1c\x73\xbc\x54\xbf\x6b\x57\x67\x1e\xb5\x1f\xaa\x33\x2e\xeb\xb4\xdc\x5c\x65\x4c\xb8\x25\x11\xe6\x78\x39\xc6\x8a\x83\x3a\xff\xaa\xb3\xe9\x2e\xeb\x59\x7d\x33\x55\xdf\xc4\xad\xdf\xaf\xa8\x73\x5a\xe5\xef\xfe\x8d\xf3\xdc\x2e\xeb\x8c\xac\xee\xa9\x6a\x2d\xed\x59\xa5\xbf\xfa\xae\xf3\xae\xed\xfa\xba\x6b\xdc\xf1\xff\x50\xcf\xea\x9b\x26\x65\x7b\xec\xda\x6d\xe6\x37\x1a\xb5\xae\xab\x33\xa4\x3a\xab\xa9\x6f\x6d\xea\x77\x5d\xea\xdb\x5c\x07\x6b\xad\x53\xdf\xa6\xd5\xdd\x4b\x7d\x47\x52\x7b\xb9\xfa\xbb\x01\x81\xd6\xb7\xe5\x9b\x4a\xe3\x59\xe5\x55\x88\x55\xaa\x33\xe7\x4c\x8b\x03\xf5\x4d\x4f\xdd\x43\xd5\x19\x41\xfd\xdd\x03\x75\x47\x50\xf7\xee\x49\xb6\x1b\xdf\x36\x4a\xac\x72\xa9\xf9\xac\xa9\xbb\xb3\xfa\x5e\xf3\x8b\xf9\xac\xa4\xf2\xb9\x6a\x79\xb3\xc8\x89\x66\x9b\x2a\x95\x54\x6d\xfb\xdf\xd6\xff\x4f\xa4\xea\xdf\xcb\x50\xa2\x8d\xbd\xa9\x6e\x96\x95\x53\xe3\x4d\x31\xee\xfb\x61\x16\x0f\x61\x66\x9b\xe1\xfb\xa3\xd6\xfc\x55\xe7\x87\x14\x53\xd4\xef\x0a\x0c\x1e\x13\xcc\x9c\x97\xea\xde\xa5\xee\xc9\x95\xdf\x39\xc7\x9a\xb9\x26\x6b\x5a\xf3\x45\x7d\x17\x1c\x60\x33\x7e\x27\x60\xdc\xcf\x54\x0e\xa8\xfb\xdb\x5e\x73\x7e\x5c\x3f\xef\x29\xfd\x77\x5b\xe7\x8a\x5b\x2c\xde\x55\x1e\x56\x9e\x4f\xd6\x5b\xfa\xbd\xa6\x1e\x69\x23\x77\xd4\x1d\xb7\x29\xe5\x08\x25\xd4\xa9\xfb\xc2\x36\x73\xee\x68\x6a\xbe\x9c\x37\x73\xdc\xa7\xfe\x9e\x42\xa1\xd9\xae\x72\x59\x23\xc7\xd4\x3d\xb7\xf2\xf7\xdb\xf2\x2a\x77\xdc\x00\xf3\x2c\xae\xee\x1c\xea\x7e\x5b\x79\xaf\xad\x7a\x7f\x55\xf7\x52\xe3\x4e\xaa\xce\x75\x0f\xfe\x59\x8c\x3b\x71\xa5\xdc\x74\x37\x16\x57\x91\x8b\x26\x97\xc6\x5a\x57\xe5\x5e\xac\xee\xc4\x95\xf7\xe1\xeb\x77\xe1\xbf\xb8\x07\xab\xbb\x84\xa1\x37\xc7\xea\x93\x2f\x44\xc5\x24\xfc\xf7\x52\x96\x52\xae\x32\xe7\xb9\xdc\x87\x6f\xcc\x79\x6d\x98\xcd\xf8\xee\x21\x99\x27\x52\xdd\x45\xd4\x98\x6f\xcd\xfb\x9b\x71\xd7\xef\x00\x2f\xc3\xd5\x9a\xa4\xe6\x2b\xe5\x12\x64\x71\x15\x79\xc7\xbc\x53\xf8\x54\x3c\xb6\xf0\xfc\xa4\x25\xb3\x4d\x11\xea\x9b\xfc\x3a\x64\xab\x35\xdf\xff\xcb\xde\xf5\xdf\xf6\xfc\xff\xbc\x47\x8b\xff\xf2\xc7\x76\xe3\x8e\x60\xdc\x43\xc0\xbd\x0f\x6c\x63\x28\x97\x9b\xbf\x83\x30\x7e\x6f\xa2\x7e\x2f\x70\xc4\xba\x1f\xa9\xdf\x9f\xec\xe6\x59\x47\x7a\x5a\xdf\x00\xe7\x23\x4f\x54\x91\xcd\xe6\xef\x62\xd4\xef\x2f\x7c\x97\x28\xdb\x23\x53\x90\xa9\x56\x39\xc5\xbc\x13\x8a\xdf\xac\xbc\x54\xdf\x8a\xd5\xfd\xfe\x01\x33\xcf\xd4\xbd\x5d\xfd\x1d\x1b\xe3\x77\x79\x1d\xac\x78\x2a\xc9\xaf\x22\x2a\x07\x76\xe0\x42\x77\xa4\xaf\x12\xea\x7a\xf9\x2b\x04\x7b\x86\xd0\x2d\xa9\x65\xfe\xdd\x2c\x5b\x5d\xe3\xef\x76\xa9\x77\x9b\x4d\xfd\x7d\x31\x9f\x28\x15\x01\xe2\x4e\x71\xa7\xd6\x4a\x9f\xaa\xcf\xd4\xef\xd4\x97\xea\xcb\xf5\x6d\xfa\xdb\xf6\x28\x7b\x6d\xfb\xab\xf6\xaf\xed\x97\x6b\xbf\x51\x67\x53\x9d\x2d\x75\x7e\x77\xc6\x38\x6b\x3b\xb3\x9d\xbd\x9d\x83\x9d\x1e\x67\x81\x73\x98\x73\x9e\x73\x9f\xf3\x84\xf3\x5d\xe7\xc7\xce\xef\x9d\x97\x9d\x3e\x57\x98\x2b\xc6\x95\xe4\x4a\x75\x35\x71\x35\x75\xb5\x70\xb5\x75\xb5\x73\x75\x70\x75\x71\x0d\x77\x4d\x75\xcd\x77\xad\x77\xed\x77\xfd\x90\x68\x4f\x8c\x4a\x8c\x4b\x4c\x4a\x4c\x4d\x6c\x92\xd8\x27\x71\x40\xe2\xf0\xc4\x85\x89\xf7\x25\x3e\x99\xa4\x25\x05\x24\x85\x25\x45\x26\xc5\x24\xd5\x4c\x72\x26\x35\x48\x4a\x4b\xea\x96\x54\x94\x34\x26\x59\x4b\x0e\x4f\x4e\x4c\x11\x29\x5a\x4a\x48\x4a\x78\x4a\x74\x4a\x7c\x4a\xad\x94\xba\x29\x8d\x52\x5a\xa4\xb4\x4b\x99\x94\x52\x9a\xb2\x30\x65\x49\xca\xf2\x94\x75\x29\xdb\x52\x76\xa6\xec\x49\x39\x94\x72\x38\xe5\x44\xca\x5b\x29\xa7\x52\x3e\x4a\xb9\x98\xda\x2e\xd5\x9d\xda\x29\xb5\x30\x75\x54\xea\xd8\xd4\x5b\x53\xa7\x36\x9a\xdc\x68\x56\x93\xb8\x27\x12\x9f\x58\x7e\x55\xbb\xda\xea\x6a\xbb\xab\x1d\xae\x76\xbc\xda\xe5\x6a\x5f\x5f\xb2\xdf\x6f\xfc\x8d\xb4\xad\x5a\x6b\x7d\x86\x3e\x57\x5f\x88\xff\x2b\xf5\x47\xf5\xd3\xf6\x9a\xf6\x35\xf6\xd3\xf6\x1f\x6a\x8b\xda\x3e\xfc\xdf\xea\x14\xce\x78\xa7\xcb\xd9\xcd\x99\x6b\xf9\x3f\xc2\x59\xea\x7c\xce\xf9\x8a\xf3\x7d\xe7\xa7\xce\x9f\x9c\xbf\xb8\x42\x5c\x91\xae\x38\xfc\x6f\x88\xff\xcd\x5d\x6d\xae\xfb\x3f\x11\xff\x57\xbb\xb6\x5a\xfe\xc7\x5a\xfe\xf7\x4e\xcc\x4b\x2c\xc0\xff\xd5\xd7\xfd\x8f\xc0\xff\x1a\x49\x75\x2c\xff\x0b\x93\x46\x1b\xfe\xbb\xfe\xc6\xff\xdc\xeb\xfe\xaf\x4e\xd9\x9a\xb2\xe3\xba\xff\x6f\xe0\xff\x87\xf8\xdf\xf6\xba\xff\x63\x52\x27\xe2\x7f\x61\xa3\x69\xf8\x1f\xf7\xc4\x92\xab\xf2\x6a\xed\xab\xad\xf1\xdf\x7d\xb5\xf3\xd5\x1c\x9f\xcb\xef\xf7\x9f\xf7\xbf\xe8\x7f\xc1\x7f\xc4\x7f\xd0\xbf\xcf\xbf\xd7\xbf\xc7\xbf\xdb\xef\xf5\xef\xf0\x67\xfa\xd3\xfd\x0d\xbf\x72\x96\x5f\x2a\xff\xba\xfc\x5f\xe5\xe7\xcb\xbf\x28\xff\xbc\xfc\xd3\xf2\x8f\xcb\xff\x59\xfe\x51\xf9\x87\xe5\x1f\x94\xbf\x57\x7e\xa6\xfc\xdd\xf2\x77\xca\x4f\x97\xbf\x5d\x7e\xb2\xfc\x78\xf9\xd1\xf2\x23\xe5\x87\xca\x0f\x94\x3f\x57\xbe\xbf\x7c\x77\xb9\xb7\x7c\x57\xf9\x8e\xf2\x35\xe5\x8b\xcb\x67\x95\x8f\x2b\x1f\x5a\x9e\x54\x1e\x5a\x2e\x2f\xfa\x2f\x5e\xb9\xf8\xd3\xc5\x6f\x2e\x9e\xbc\xf8\xfa\xc5\x97\x2e\x6e\xb9\xb8\xee\xe2\x82\x8b\xf5\x2f\xa6\x5c\xac\x7d\xb1\xd6\xc5\x9a\x17\xe3\x2e\x46\x5f\x0c\xbe\x58\xed\xc2\x77\x17\x3e\xb8\xf0\xde\x85\x36\x17\x1a\x5d\xa8\x7d\x3e\xeb\x7c\x87\xf3\x2d\xcf\x37\x3f\x9f\x7e\xbe\xd1\xf9\x06\xe7\x93\xce\x27\x9c\x8f\x3e\x5f\xfd\xdc\x1f\xe7\xca\xcf\x7d\x79\xee\x8b\x73\x9f\x9d\xfb\xf8\xdc\xa9\x73\xaf\x9e\x7b\xf1\xdc\xf3\xe7\x0e\x9d\xdb\x7b\xee\xd9\x73\x3b\xcf\x6d\x3f\xf7\xc0\xb9\xec\x73\x9d\xce\x75\x3c\x57\xf7\x5c\xd2\xb9\xc4\x73\x75\xce\x25\x7c\x92\xf6\x49\xfd\x7f\xde\x5b\xb4\xb4\xa8\x6e\x75\x6f\xf5\xfb\xab\xdf\x57\x7d\x7d\xf5\x75\xd5\xd7\x56\x5f\x53\xed\x05\xeb\x6f\x4c\xfe\xbf\xfb\x27\x40\xab\xa6\x0a\x29\xfe\x8d\x09\xa9\xfe\xee\xa9\xf1\x47\xfb\x2f\x3a\xcc\x91\xba\xb0\x09\x3b\xab\x89\x43\x04\x8a\x20\x51\x4d\x04\x73\xc2\xac\x2e\x42\x45\x98\x08\x17\x11\x22\x52\x44\x89\x68\x11\x23\x62\x45\x9c\x88\x17\x35\x44\x4d\x91\xc0\x2a\x54\x5b\xd4\x11\x4e\x66\x5f\x22\xbb\x41\xb2\xa8\x2b\x52\xd8\x49\xea\x89\xfa\xa2\x81\x68\x28\xd2\x44\x23\xd1\x58\x34\x11\xe9\xec\xd0\xcd\x44\x73\x91\x21\x5a\x88\x96\xa2\x95\xc8\x14\xad\x45\x1b\xd1\x56\xdc\x22\xda\x89\xf6\xa2\x83\xc8\x12\x6e\xd1\x51\x74\x12\x9d\x45\x17\x91\x2d\x72\x44\x57\xd1\x8d\xb5\xb0\x87\xe8\x29\x7a\x89\xde\xa2\x0f\x6b\x62\xae\xe8\x27\xfa\x8b\x3c\x31\x40\x0c\x14\x83\xc4\x60\x76\x3e\x8f\x18\x22\x0a\xc4\x50\x31\x4c\x0c\x17\x23\x44\xa1\x28\x02\xff\x62\x56\xcc\x7b\xc5\x32\xb1\x4e\x3c\xc0\x7e\xf5\xa8\x78\x44\x6c\x17\x8f\x8b\xc7\xc4\x13\xe2\x29\xf1\xb4\xd8\x21\x76\x8a\x67\xc4\x2e\xf1\x2c\xfb\xe5\x6e\xb1\x57\xec\x17\xfb\xc4\x73\xa2\x4c\x1c\x10\x87\xc5\xf3\xe2\x88\x38\xea\xf8\x54\x4c\x17\xa3\xc5\x18\x31\xc1\xf1\xb9\x98\x2d\xb6\x89\x62\x71\x6b\x60\x9c\xb8\x4d\x4c\x0c\xcc\x14\x4b\xc4\x83\x81\xcd\x45\x49\x60\x9b\xc0\xb6\x62\x9c\x98\x15\xd8\x30\xb0\x71\x60\x23\x7d\x5a\x60\x4b\x31\x49\xdc\xa1\x0f\x11\x4f\x8a\x43\x62\x81\x18\x25\xa6\x04\x36\x93\x03\x02\x5b\x05\xa6\xb1\x03\xcd\x73\x9c\x15\x23\xc5\x5d\x62\x91\xd8\x20\xa3\x65\x8c\xe3\x1d\xc7\x3f\x1c\x1f\x39\xfe\xe9\x78\xcf\xf1\xbe\x38\x18\x38\x5b\xbc\x20\xdb\x3a\xbe\x0b\x0c\x74\x7c\xed\xf8\x26\x70\x77\xe0\x1e\xc7\x67\x62\x8e\xe3\x03\xc7\xc7\x8e\x8b\x62\xa1\x58\x2e\xee\x16\x2b\xc4\x52\xb1\x4a\xac\x16\x6b\xc4\x4a\x71\x9f\xb8\x1f\x0f\xd7\x8b\xcd\xe2\x21\xb1\x49\xfc\xac\xdd\xa3\x3d\x24\xa6\x69\x1b\xb5\x07\xb5\x4d\x62\xae\xb6\x45\xdb\xac\xb1\x7b\xbb\xbb\x16\x0c\xf1\xe4\x0f\x1c\x90\xd7\xbf\x5f\x6e\xdf\x3e\xbd\x7b\xf5\xec\xd1\xbd\x5b\xd7\x9c\xec\x2e\x9d\x3b\x75\x74\x67\x75\x68\xdf\xee\x96\xb6\x6d\x5a\x67\xb6\x6a\xd9\xac\x69\x7a\x93\xc6\x8d\xea\xd7\x4b\x4d\xa9\x9b\x9c\x94\xe8\x8c\x8f\x8e\x08\x0f\x0b\xad\x1e\x5c\x2d\x28\xd0\x11\x60\xb7\xe9\x9a\x14\x8d\x5c\x5e\x59\x98\xed\xd5\x53\x5c\x11\x39\x45\xc9\xd9\xc9\x45\xdd\x1a\x37\x72\x65\xc7\x8f\xef\xd2\xb8\x51\x76\x72\x4e\xa1\xd7\x55\xe4\xf2\x52\xd8\x52\x93\xbb\x75\x33\xaa\x92\x8b\xbc\xae\x42\x97\x37\x95\xa2\xa8\x4a\x75\xa1\xd7\x4d\xcf\xb1\x37\xf5\x74\x9b\x3d\xdd\xd7\x7b\xca\x70\x57\x3b\xd1\x4e\x99\x48\x76\x79\x4f\x76\x49\x76\x95\xc9\x21\xfd\xf2\x79\x5e\xd1\x25\xd9\xe3\xf2\x7e\x6b\x3c\xf7\x36\x9e\x6d\xa9\xc6\x4b\x75\x5e\x12\x13\x19\x61\xa0\x52\x68\x5d\xd9\xde\x9c\xdb\xc6\x2f\xcd\x2e\x04\xa3\xdc\x1d\x5c\xad\x73\x72\xe7\x31\xd5\x1a\x37\x12\xbb\xab\x05\xf3\x18\xcc\x93\xb7\x7e\x72\xf1\x6e\x59\xbf\x83\x34\x1e\xb4\xfa\xd9\x6d\x77\x6b\x22\xb0\xba\x32\x8b\xa7\xd9\x45\xa3\xbd\xb9\xfd\xf2\xb3\xbb\x24\x24\x26\x7a\x1a\x37\xea\xee\x0d\x4d\xee\x62\x34\x89\xce\x86\x4a\x6f\x40\x67\xaf\xc3\x50\xe9\x9a\xa0\xa0\x8b\x65\xae\xdd\x8d\x8e\x2f\x5d\x5e\x16\x2e\x46\x16\xa6\x85\x8c\x4e\x1e\x5d\x34\x34\xdf\xab\x17\x31\x76\xa9\x9e\xbd\x74\xe9\x3d\xde\x88\x34\x6f\x83\xe4\x2e\xde\x06\x73\xbf\x8c\xc7\xf3\x31\xde\x46\xc9\x5d\xb2\xbd\x69\x4a\x6b\xcf\xfe\xd7\xed\xf4\xbc\x61\x52\x7a\xed\x29\x6c\x17\x4b\xaf\x08\xdc\x49\xfe\xf6\xd2\x9f\x6b\x8a\xac\x9a\x80\x94\xf0\x2b\x42\x3d\x7a\xb5\xce\x5e\xd9\x3f\x3f\x51\xfd\x49\xc8\x81\xeb\xa5\x4b\x73\x92\x5d\x39\x4b\x0b\x97\x16\x95\xf9\x4b\x47\x26\xbb\xc2\x93\x97\xee\x0e\x09\x59\x5a\x9c\x0d\xdd\x22\x37\x1f\x15\x65\xfe\x43\xcb\x12\xbc\x39\xcb\x3d\xde\xf0\xc2\xf1\xb2\xad\xc7\x72\x3d\xa7\x7f\x4f\x6f\x54\xbf\x82\x7c\xaf\x96\x92\xe3\x1a\x5f\x44\x0d\xff\x64\x25\x27\xb6\x4e\x48\x8c\xb8\xde\x27\xf7\xef\x9a\x05\xb4\x40\x0e\x0c\x27\x26\x2a\x1a\x96\x95\xb9\xc5\x48\x5e\xbc\xa5\xfd\xf2\xcd\x77\x97\x18\x99\xb0\x47\xb8\xd3\xd3\x3c\x5e\xad\x50\xb5\x1c\xaf\x6c\x89\x19\xa8\x5a\x4a\x2b\x5b\xae\x0f\x2f\x4c\x26\xb6\x3d\xf3\xf2\x97\x7a\x6d\x29\xdd\x47\x27\x67\xc3\xf8\xb2\x22\x6f\xe9\x48\xb2\x6b\xa2\x0a\x4c\x72\xb8\x37\xf4\x97\x84\xc4\xe4\xa5\x91\x11\xae\x36\xe9\x1e\xa3\xaf\x0b\x54\xdd\x47\x4f\x70\x79\xed\xa9\x90\xc4\xa8\xaa\x03\xc8\x1b\x35\x64\x69\xb8\xf1\x12\xfa\x8b\x59\x7c\x9b\x80\x81\xd4\x88\x48\x57\x9b\x64\xd4\x28\x3d\xd9\xc9\xd9\x85\xd6\x3f\xb7\x8d\x8f\x47\x81\x0b\xa2\xbb\xa5\x99\x89\x30\x20\xdf\xeb\xee\xc2\x83\xbb\xc8\x8a\x58\xf6\xee\xa6\xe9\x8c\x28\x2a\x24\x60\x13\xba\x18\xc1\xf4\xa6\x27\x17\x7b\xa3\x93\x3b\x5d\x8f\xae\x82\x95\x3d\x21\x2f\xdf\x18\x62\x0d\xf3\x46\x77\xf6\x8a\xc2\x51\xd6\x28\x6f\x7a\xb6\x31\xaf\x5c\xd9\x4b\x0b\xbb\x98\x10\x94\xae\xe4\x7e\xf9\x07\x45\x86\xff\xec\xee\x16\xae\x84\xbd\x6a\xe9\xf4\x74\x51\x9d\x63\x3b\x93\x65\xa9\xd9\x4b\xf3\x47\x8f\xf5\x3a\x0b\x13\x46\x33\xef\xc6\xba\xf2\x13\x12\xbd\x6e\x0f\x11\xf6\x24\xe7\x8f\xf1\xa8\xb4\x83\xa1\x06\x67\x13\x8c\xe4\xf0\x18\xb9\x32\x20\xbf\x67\x5e\x72\xcf\x7e\x43\xf2\x5b\x5b\x40\xcc\x06\xa5\xce\x96\x92\x7d\x93\x9a\xe4\xfc\x04\x53\x0d\x09\xe8\x0d\x4c\x09\x74\xe5\x6b\x09\xba\x87\x8e\xe1\x54\xb8\x72\x78\x48\xee\xd4\x8e\x9f\x5e\x47\x4a\x20\x12\x0e\xe1\x46\xad\x4a\xdc\x4e\xed\x5c\xf9\x32\x41\x54\xf6\x06\x86\xb7\x81\x2b\x7b\x4c\x17\xab\x9f\x7a\xff\x93\x52\xbb\x4a\xa7\xce\xdd\x2a\xb5\x05\xa8\x57\xf4\x74\xee\x96\x90\xe8\x49\x34\xff\x34\x6e\xa4\xd1\xec\xb2\x0c\x33\x22\x50\x91\xda\xad\xb2\x89\x65\x8a\x86\x40\xf2\xb3\x73\x37\xa3\x4a\x71\x19\xaf\x92\xde\x95\x9f\x3c\x26\xd9\x93\x3c\xde\xe5\x75\xe7\xe6\x2b\xdf\x14\x3d\x06\xcb\x16\x19\x06\xe7\x56\xac\x06\xfc\xe9\xad\x0a\x59\xd0\x24\x12\x69\xae\x7c\x51\x64\x7a\x73\xd2\x12\xaa\x92\xeb\xed\x6a\xbc\x5f\x7f\xed\x76\x53\x73\xf7\xca\x66\xd7\xd2\xc0\xe4\x9e\x79\x4b\x95\xf2\x64\x4b\xa1\x00\x79\x77\xaf\x50\x29\xec\x6e\x1d\x91\x60\xac\x05\x6a\x42\x27\xb3\xf6\xba\xc2\x99\xd2\xc6\x84\x5e\xba\xdb\xed\x56\x93\x79\x7c\x5b\xa5\x24\xb9\xfb\xe8\xa5\xc9\x79\xf9\xed\x8c\xde\xac\x27\xf3\x12\xe6\x2a\x5b\x91\xa2\xa7\xec\x39\xa0\x53\xe3\x46\x2c\x6d\x9d\x76\x27\xcb\x25\xfd\x76\xbb\xe5\x92\xbc\x21\xf9\x07\xc3\x39\x23\x2f\x19\x90\xbf\x47\x93\x5a\xe7\xc2\x4e\x9e\xdd\x75\x69\xcb\x3f\xe8\x62\xd3\x30\x6a\x35\x55\xab\x2a\xd5\x8b\x4b\xbd\x28\x4d\xfd\x79\x09\x34\xfa\x27\x1c\x74\x0b\x51\x6a\xb4\xda\x8c\x0a\xe3\x7d\x54\x99\x14\x46\x5d\x60\x65\x9d\x14\xa3\xca\x34\xb3\x2e\xdc\x34\x94\x6a\x18\x72\x73\x06\x19\x55\x66\x33\x5b\xdc\x95\xbd\x6d\xd4\x05\x9a\x75\xa5\x46\x9d\xf1\x67\xb7\x50\x94\xb9\xab\xd9\xdd\x81\xee\x20\x77\x88\x56\x5d\x4b\xd8\x2d\x55\xd5\x1e\x6a\x0e\xa9\x7f\xef\x45\x8a\xbd\x21\xb2\xba\x4c\xd8\xcd\xa8\xfe\x46\x75\x99\x2c\xdd\x1d\xe4\x4e\x30\x7b\x94\xd2\xc3\x6d\x22\x5c\x32\xf0\x86\xe9\x81\x43\xf2\xf7\x72\xa2\x91\x09\xc6\x4f\x0c\x75\x52\x7f\x48\x97\xf8\xf1\x04\x9b\x6d\x25\xdb\x35\x5a\x25\xca\x1d\x9e\xf1\x4b\x0b\x3d\x6a\xb2\x89\x58\x42\xc3\x3f\xd2\x2b\x93\x3b\x10\xa6\xe4\x0e\x00\x09\x08\xf1\x56\x4b\x1e\xd3\xc9\x1b\x9c\xdc\x49\xd5\x67\xa9\xfa\x2c\xb3\x3e\x40\xd5\x3b\x48\x51\x19\x2b\x19\x5e\x4a\xec\x73\xbd\x52\x65\x40\x41\x7e\x22\x53\xd2\x55\xf3\xf5\x84\xa5\xe1\xdf\xaa\x48\x79\x58\x54\x96\x86\x5f\x68\xdc\x31\x55\xe6\x09\x29\x7b\x8b\x81\xb2\xbf\x55\x0e\x92\x03\x38\x69\x39\xe5\x40\x4a\x2e\x2d\xb2\xaf\xc8\x90\x7d\xa8\xef\x45\xa9\xda\xdb\x8b\xf6\xb2\x1d\x65\x3b\xfa\xb7\xa5\xbc\x85\x77\x55\xb6\x94\x2d\xf6\x94\x3a\x45\xc7\xc6\xb2\x85\x08\x47\x34\x43\x9a\xd0\x92\x21\xba\xc9\xe6\x9c\x9d\x4a\xf9\x29\x11\xb3\xb6\x19\xe3\x9a\x52\x1b\xc6\x4f\x89\x98\xb5\xe9\xd4\x52\x0a\x17\x3f\x0b\x11\xce\x8e\xfc\x54\x6f\xb4\xef\x91\x62\x60\x99\x6c\xbc\xa7\xbd\x2a\x1a\xed\x15\x7e\x67\x69\xc7\x08\xd9\x85\xe1\x4a\x3a\x30\xbc\x33\xc3\x3b\x51\x76\xb2\xde\xb3\x78\xef\xe0\xee\x3a\x30\xbc\x42\x5e\xc9\xad\xef\xbc\x9c\xd3\xd0\xf9\x63\x4e\x7d\xe7\x0f\x39\x2d\x9d\x0f\x7f\xb7\xeb\xbb\x63\xdf\xe9\xf3\xbf\x7f\xf8\x7b\xed\xd4\xf7\xd2\xfb\xbd\x4c\xff\x7e\xea\xf7\xf3\xbf\xd7\xc5\xa5\xf0\x4b\x4d\x2f\xb9\x2f\xe5\x5e\x2a\xbe\x54\x7a\xc9\x11\x14\xfe\x8d\x14\xdf\x78\xbf\xd1\x22\xdc\x65\xb2\xbe\xbb\x75\x4c\x42\x8e\xfb\x5f\x91\x71\x39\xe5\x5f\xa6\x3a\x2f\x7e\xd9\xde\x79\xe1\xcb\x3a\xce\xb0\x2f\x65\xed\xf3\xe7\x72\x9c\x61\xe7\xa4\xfb\x5c\x4e\xac\xf3\x8b\xb3\x39\xce\x63\x67\x4f\x9d\xfd\xfc\xac\xee\x3e\x9b\xd1\x2a\xe7\x6c\x4e\xbc\xf3\xb0\x8c\x16\x1d\x64\x24\xa0\xa2\xdc\x21\xed\xf5\x81\x9f\xb7\xff\x74\xe0\x67\xed\x3f\x19\x28\x3a\xc6\xc9\x58\xe0\x2a\x89\xc1\xf3\x5d\xfc\x94\x78\x1c\x23\x72\x11\x0d\x7e\x62\x8c\xe3\x75\xa4\x68\x8a\x68\x32\x72\x8f\xd4\x71\x3f\xc2\x9d\xab\xfb\x9d\x9f\xca\x4f\x06\xba\x3e\xc9\xfd\xa4\xf4\x13\xef\x27\xb6\xb0\x4f\xe4\xe9\x98\x0c\xe7\xb1\x17\x65\xe1\xf1\xe2\xe3\xa5\xc7\xf5\xac\xe3\xd2\x75\x5c\x8a\xe3\xf2\x85\xdc\x54\x67\xf1\x51\xe9\x3a\xda\xf4\xe8\xf1\xa3\x7a\xf1\xd1\xd2\xa3\xda\x91\xc3\xed\x9c\x87\x9e\x89\x73\x1e\x7c\x26\xd5\x99\x5b\x56\x5c\x56\x5a\xa6\x97\xf9\x8f\xef\x2d\x8b\x6a\x90\x43\xe9\x0e\x2f\x0b\x0a\xc9\x09\x3f\x20\x5d\x07\x72\x0f\x94\x1e\xf0\x1e\xb0\x95\xc9\x64\x77\xb5\xfd\xcd\x9c\x61\x7b\xb3\xf6\x7e\xbf\x57\x3f\x28\x13\xa5\x73\x4f\x3b\x27\x9c\x38\xf7\xd4\x76\xe5\x94\xc9\xea\x6e\xe7\x8e\x6e\xce\xf4\x5d\x59\xbb\xb4\xad\xcf\x78\x9f\xd1\x8e\x3f\x73\xfa\x19\x2d\x7d\x67\xd6\x4e\xed\xe1\xa7\xe5\xf1\x1d\xa7\x77\x68\x07\xfd\x67\x65\x9d\xbd\xae\xe4\x9c\x9e\x1d\xeb\xcb\x3a\x38\x55\xd7\xf8\xb9\xdd\xf8\x79\xaf\xf1\xb3\xc0\xf8\xd9\xdd\xf8\xd9\x98\x9f\xed\x11\x4d\xc4\x18\xef\x01\xea\xa7\x0c\x13\xcd\x65\x28\x34\x09\x7e\x86\x23\x2e\xa4\x58\x86\xee\xb3\x3d\xb4\x39\xd2\xa9\x90\x47\x6f\x0e\x8d\xc8\x71\x6d\x6c\xba\x51\xdb\x78\x7f\xa4\xf3\x81\x9c\x54\x67\xf8\x06\xa9\x5c\xbb\x3f\xb6\x96\xe1\x5a\xc3\xfb\xe9\x70\x5f\x82\xdf\x19\xb6\x7e\xd7\xfa\x63\xeb\x75\xf7\xfa\xda\xcd\x72\xdc\xeb\x63\x89\xeb\xfa\x90\xb0\x9c\xb0\x75\xe9\xeb\xb2\xd6\xcd\x5f\xf7\xfd\x3a\x7b\xd8\x21\x19\x22\xa6\xca\x10\xb7\x4b\x5b\xbb\x22\xd5\xb9\x26\xcf\xef\xfc\x7c\xb5\x6c\xba\x5a\x3a\x57\xa7\xaf\xd6\xa6\xae\x9e\xbf\x5a\x13\xab\xc2\x57\xb9\x56\x29\xea\xdc\x49\xab\xe2\x6b\xe5\x84\xaf\x74\xad\x6c\xba\x52\xef\xbb\x62\xc4\x8a\xa9\x2b\xf4\xa6\xcb\x65\xd8\x72\xe7\xf2\xf4\xe5\xba\x7b\x79\x78\x54\x4e\xf8\x31\x19\x0c\xe0\x60\x22\x19\x2c\x74\xff\x71\x19\xbc\x27\xce\x95\x73\x50\x3d\xec\x0f\x8f\xce\x29\x5d\xa6\x70\xba\xeb\x2d\x03\xc5\xbd\x3d\xda\x39\x97\x2c\x6c\xe7\x2c\x5e\x5c\xba\x58\x7b\x78\xd1\xae\x45\xc7\x16\xe9\x4d\xef\x92\x0b\x26\x93\xf3\xc4\xbd\x84\x80\x96\xc9\x5a\x7b\x73\x22\x9c\xe1\x65\x32\xc1\xdd\x39\xae\x66\xce\xc7\xd3\xbf\x99\x7e\x75\xba\xee\x9a\x5e\x3b\x31\xe7\xc4\xf4\x33\xd3\xb5\x69\x53\xbb\x39\xa7\x92\xe9\x53\x90\x9a\x32\x7e\x60\x8d\x8c\xf8\x81\x8e\x0c\x7d\x60\x00\x0a\x1a\x4c\x96\x93\x28\x8a\x72\x6b\x39\x0b\xd1\x35\xc2\xd0\x57\x63\x6f\x4e\x23\xe7\xa9\xc3\x32\x5e\x7c\x8e\x68\x32\x7e\x4f\x4e\x2d\xaa\xe3\xdc\xc9\xb0\x38\x7c\x48\x37\xe7\xd0\x9c\x66\xce\x02\xca\x21\x94\xd1\x32\x72\x60\x54\xf3\xc8\x81\x76\xd2\xd1\xd6\x5c\xa5\x64\xa0\x3b\x34\xa1\x9d\x33\x4c\x97\xf7\x7b\x1e\xf7\x68\x53\xf3\x64\x99\xac\xe9\x6e\x83\xe6\xfe\xb9\x09\xce\xef\xfb\xf9\xfb\x69\xee\x7e\x2d\x5b\xe7\xb8\xfb\xa5\xd4\xcf\x39\x95\x2b\xfb\xf6\x6a\xe7\xec\x83\xa2\xde\x48\x6c\xaf\xd4\x5e\xad\x7a\xe9\x8e\x5e\xb2\xbc\xd7\xaf\xbd\xb4\x9e\x39\x2d\x48\x4a\x99\xe2\x1e\x29\x7b\x60\xba\x3b\x0e\x74\x43\xba\x22\xbb\x72\xe4\xe7\x39\xdf\xe7\x68\xa5\x39\xb2\x56\xb7\x84\x81\x71\x32\x66\x60\x6c\xf3\x98\x81\x11\x32\x6c\x60\x78\xf3\xb0\x81\x5c\x1f\x06\x4a\x21\x9d\xce\xb0\xac\xb0\x11\x61\xf3\xc3\x6c\x61\x61\xe9\x61\x7d\xc3\xa6\x86\xad\x0a\xfb\x3c\xcc\x1f\xe6\xc8\xa2\xee\xfb\x30\x7d\xaa\x60\x5d\x93\xab\x63\xa5\x1d\x90\xab\x77\x0f\xc8\x4b\x4b\xeb\x59\xe6\xf0\x73\x14\x0d\xca\x2d\xf0\xca\x25\xde\x94\x3c\xf5\xd3\xdd\x6f\x88\x37\x60\x89\x57\x0c\x1c\x52\x90\xbf\x5b\xca\x95\x9e\x45\x2b\x56\x88\x4e\xb5\x7b\x7a\x9b\xe7\xe5\x7b\x0b\x6b\x7b\x7a\x7a\x47\xf3\xe0\x56\x0f\xa5\x3c\x84\xd7\xde\x1d\x2b\x3a\x79\x4a\x66\x94\xcc\x98\x99\x66\xfe\x91\xd6\x63\x89\x48\x2b\x99\x31\x83\x07\xa4\x84\x7f\x64\x89\x28\x31\x3b\x20\xc2\xac\x4f\x33\x9a\x8c\x2a\x7a\x5b\x35\x72\x46\x49\x89\xd9\x60\xaa\x98\x91\x36\xd3\xf8\x99\x66\x55\x4b\xa3\x6d\x86\x30\x9e\x4b\xcc\x3f\x34\xf3\x43\x98\x06\x4b\x64\x1a\x4f\xa6\x6a\x85\x46\x98\xdd\x30\x6f\x6a\xe0\xcf\x75\xb3\x74\x1b\x5e\x92\x26\x86\x5b\xd0\x86\x97\xcc\x1c\x4e\x47\x74\x95\x18\x98\xcc\x7e\xc6\x28\xcb\x0d\xab\xca\xfc\x13\x2f\x84\xfd\x2d\xfb\x5b\x62\x9e\x3d\x9b\x9b\x7a\xa1\xf1\xf3\x4f\x7f\x6c\x6d\xd9\x59\x66\x09\xe1\xbf\xe4\xbf\xdd\xf8\xa9\xbe\x9b\x5f\x32\xff\x3e\xf8\xff\xe5\x1f\xf3\xdf\x73\xe5\x86\x7d\x84\x7b\xf7\x56\xf1\x1a\x77\xee\xa5\xdc\xc5\x37\x88\xb9\xdc\xa4\xef\xe4\x4e\x7e\xbc\xb2\xa7\xfd\x2d\xe9\x12\xc7\xc4\xeb\xdc\xd0\x97\x73\x13\xdf\xc4\xad\x77\xc1\x5f\x69\xb4\x67\xcb\x00\x71\x10\x8d\x77\x88\x3d\xdc\xef\xd7\x73\xeb\xff\xcb\x3f\x46\xbf\xa9\xf4\x5a\xc2\x9d\xf9\x75\x39\x1f\x7d\xcf\x8b\xe1\xf2\x88\xd4\x45\xa1\x98\x83\xee\x32\x6c\xe7\xda\x76\xdb\x5e\xf2\xf5\x12\xdf\x68\x19\xe2\x25\x19\x24\x6e\x97\x69\xda\xfd\xda\x14\x50\xfc\xf5\x9f\xb5\xdc\xef\x27\xf1\xf3\x80\x98\x64\x56\x68\x3f\x89\xb5\xda\x20\x31\x45\x7b\x4c\xcf\x16\xf7\xe2\x61\xa1\xd6\x4b\x2b\x16\x2f\x09\xa1\x97\xb2\x9c\x16\x88\xe1\xa2\x54\x4c\x00\x87\xe0\x69\xfc\x9f\x74\xa5\xea\x3d\xc4\x3d\x02\xf6\xc5\xcc\xaa\x2d\xf6\xbb\xae\xed\x16\xc1\xfe\xcb\xdc\xfb\x97\x8a\x75\x62\x23\xa3\xa7\x89\x02\xd1\x9f\xa6\x52\x91\x2b\xca\xb0\x26\xc4\x0a\xdd\x89\x37\xfb\x8d\x01\xbb\xc5\xb2\xca\xb1\x01\x4f\xe9\xc5\xda\x61\x2d\xb0\x62\xa3\x58\xc3\xff\x7a\xf3\xbf\xd1\x62\xb4\xd9\xe6\x1b\xef\x7b\x80\xa5\x3a\x5b\x66\x8b\xd5\xbe\x5f\x44\x9c\xd8\x6e\xcf\xae\x08\x14\x21\xfe\xef\xec\x0f\x5c\xfb\x19\xe4\x0b\xf1\xed\x7e\x51\x22\xe6\x39\xba\xc8\x89\xb0\x7a\xbf\x18\x27\x4a\xb4\x56\x2c\xf0\x5f\xb1\xf2\xbe\x67\xf8\x60\xc4\x49\x84\x5d\xab\xe3\xff\x49\xbb\x2a\x42\x6d\xb1\xa2\x9a\xef\x5d\xa2\x66\xfd\xd1\x0b\x44\x78\x45\x12\xd9\x34\xdb\xff\x83\xaf\xd0\x97\x67\xf5\xf9\xf8\x3a\xbe\x05\xb6\xf1\x22\xda\xf6\xa6\x91\x71\xef\xfa\xe6\xe3\xe3\xc7\xe4\xc5\x21\xac\x9f\xb2\xba\xb4\xb8\x49\xd4\xef\x17\xf6\x81\x7b\x3d\x5c\x3f\x89\x85\x85\xe4\x2e\x75\xb6\xad\x08\xf9\x6a\x6f\x8d\x94\xa1\x99\x8c\x0f\xe8\x82\xa8\x7f\x5f\x9c\xbe\x01\xc7\x85\x70\xc0\xaa\xe3\x2d\x72\xb0\x90\x93\x22\xba\x82\x18\x5f\xad\x97\x10\xc1\x24\x65\x70\xbe\x10\x21\x4d\x91\x2f\x85\xa8\x4e\x5b\xf5\x52\xe4\x43\x21\x42\xbb\x21\x9b\x85\x08\xa3\x2d\xbc\x18\x61\x7c\x04\x65\x24\x63\x22\x55\xf9\x89\x10\x51\x8d\x90\x13\x42\x44\x47\x23\xd8\x8b\x3e\x23\x44\x0c\x3a\x62\xb0\x17\x83\xbe\x58\x70\xc4\x62\x3f\x0e\x1d\x71\xe8\x8c\xc7\x56\x8d\x10\x04\xdb\x35\xbc\xc8\x0f\x42\xd4\x64\x5c\x4d\xfc\xaa\xc9\x73\x82\x1b\xc1\xaf\x84\x9d\x08\xef\xb5\xea\x23\xb9\x08\x98\x6a\xa3\xb3\x0e\x63\xeb\xd0\xd7\x39\x94\xa3\xbb\x0d\xb9\x43\x88\x44\x74\x25\x62\x23\xc9\x85\x10\xd7\xa4\xdf\x84\x48\xc6\x6e\x5d\xe8\xaa\xcb\xb8\x14\xca\x94\xed\x24\x19\xfe\xa4\x62\xb3\x1e\x1c\xd4\x03\x7b\x7d\xca\xfa\xd4\x37\xa8\x85\xe0\x4f\x83\x6b\x42\x34\x44\x97\x5a\x31\xd2\xc0\xd1\x08\x5b\x8d\xe0\xaf\x11\x7d\x1a\xc1\x6f\x63\xb8\x6d\x82\xbd\x74\xfa\xa7\x1f\x37\x7e\xc5\x26\x9a\xe1\x77\x33\xf0\x35\xc7\x4e\x06\x98\x32\xd0\xdb\x82\xf1\x2d\xc0\xdd\x12\x00\x2d\x89\x49\x4b\xb8\x6e\x05\x27\xad\x0e\x0b\x91\x89\x6f\x99\xe0\x6f\xdd\x0e\x41\x6f\x6b\x9e\xdb\x80\xbb\x0d\xf5\x6d\xc0\xdd\x76\x06\x42\xbf\xb6\xf8\x7e\x0b\x7d\x6e\x81\xb3\x5b\xc0\xd5\x8e\x3e\xed\xf0\xa9\x1d\x1c\xb4\x5b\x8e\xe0\x47\x7b\xb8\x6c\x0f\xee\xf6\x60\x6c\x0f\xb6\xf6\xd8\xee\x00\xa6\x0e\xd8\xed\x80\xaf\x1d\xe0\xb5\xc3\x6a\x21\xb2\x88\x51\x16\x18\xb3\xd0\x9d\x05\x3f\x59\xe8\xcf\x3a\xcb\x25\x07\xfe\xdc\x03\x84\xe8\x08\xde\x8e\xd8\xea\x08\x1f\x1d\xc1\xd1\x11\xbc\x1d\x89\x75\x27\xb8\xe8\x8c\xaf\x9d\x69\xeb\x8c\x6f\x9d\xf1\xbd\x33\xf9\xd0\x19\xdf\x3b\x13\xdb\x2e\xe0\xca\xc6\xff\x6c\x7c\xcb\x46\x4f\x36\xfa\xb3\xd1\x9f\x0d\x96\x6c\x70\x67\xe3\x4f\x0e\xe3\x73\xb0\xa5\xfe\xd5\xfe\xae\xf8\xd0\x15\x5e\xbb\x62\xa7\x2b\x7c\x75\xc5\xff\x6e\xb4\x77\x43\x57\x77\xb0\x74\x07\x77\x77\x7c\xec\x8e\x8f\xdd\x97\x08\xd1\x03\x0e\x7b\x80\xa1\x07\x3e\xf6\xc0\x8f\x1e\x70\xd5\x83\xfc\xea\x41\x2c\x7a\xd2\xbf\x27\xed\x3d\xf1\xb3\x27\x7e\xf6\x84\x93\x9e\x70\xd2\xf3\x34\x72\x59\x88\x5e\xe0\xea\x05\xf7\xbd\xc0\xd8\x9b\x38\xf6\x86\xcf\x3e\xd4\xf5\x01\x6b\x1f\x78\xeb\xc3\xbc\xe9\x83\x2f\x7d\xe0\xa2\x0f\x3a\xfb\xa0\xb3\x2f\xd7\xc1\xbe\x04\xb5\x2f\xbe\xf4\xc5\x97\xbe\xf8\xd2\x17\x5f\xfa\xc2\x6b\x5f\xf4\xe4\x32\x3e\x97\xf1\xb9\x8c\xef\x47\xdf\x7e\xd8\xeb\x8f\x2f\xfd\xe1\xac\x3f\xbe\xf4\x7f\x0d\xf9\x4a\x88\x3c\xec\xe5\xc1\x79\x1e\xbe\xe4\xc1\x5b\x1e\xbe\xe6\xc1\xe7\x00\x7c\x19\x00\x17\x03\xc1\x3e\x10\x5f\x07\xc2\xeb\x40\x6c\x0d\x84\xef\x81\xb4\x0f\x02\xef\x20\xe2\x34\x08\xff\x07\xe1\xcf\x20\x74\x0e\x02\xdf\x20\xf0\x0d\xa6\x6d\x30\x58\x06\x83\x05\xf3\x22\x9f\x98\xe5\x83\x35\x9f\xf1\xf9\x60\xcd\x07\xab\x07\x2e\x3c\xd8\x1f\x82\xfd\x21\xd8\x1f\x82\xae\x21\x70\x37\x84\xfc\x18\xc2\xd8\x02\x7c\x1e\x8a\xee\xa1\xe8\x1e\xca\xfc\x1a\xca\xbc\x1d\x8a\xbe\x61\xe8\x1b\x46\x6c\x86\x81\x77\x18\x2b\xe4\x30\xb8\x1f\x06\xa6\x61\xc4\x79\x18\x71\x1c\x86\xef\xc3\x89\xd3\x70\x7c\x1f\x8e\x0f\xc3\xd1\x39\x1c\x9d\xc3\xa9\x1f\xc1\xda\x33\x02\x3d\x23\x88\x61\x21\xeb\x42\x21\x31\x29\xa4\x4f\x21\x31\x29\x24\x5e\x85\x8c\x2f\xa4\x5f\x11\xfa\x8b\xf0\xa1\x08\x4c\x45\xe0\x2d\x62\x7c\x11\x98\x8a\x68\x2f\xa2\x7d\x24\xed\x23\xc9\x8d\x91\xd8\x1f\x09\x9f\x23\xb1\x3f\x12\x3e\x47\x51\x3f\x8a\xf6\xd1\xe8\x1a\x8d\x9d\x31\x70\x39\x86\xf8\x8e\x05\xff\x38\xfa\x8f\x87\xcb\xf1\xe0\x1c\x4f\xdc\x27\x40\xcc\x04\xca\x89\xe0\xbf\x15\x7e\x6f\xa5\xef\x24\x78\x9a\xc4\xb8\xc9\x60\x9f\xcc\x98\x29\x60\x9f\x82\xbe\xa9\x3c\x4f\x85\xdb\x62\x74\x14\xa3\x7b\x1a\xb8\xa7\xe1\xcb\x74\xfa\x4f\xa7\xbe\x04\x6e\x4b\x68\x2b\x01\x6f\x09\xfd\x67\x80\x67\x26\xf1\x9a\x49\x2c\x6e\x03\xe3\x2c\x70\xcd\x22\x3e\xb3\xe1\x7f\x36\xed\x73\xe0\x7c\x0e\x38\xe6\xe2\xf7\x5c\xec\xdd\x0e\xcf\xb7\xd3\xf7\x0e\xca\x79\xe8\x9c\x87\x8d\x3b\x19\x7f\x27\x7a\xe6\xc3\xcf\x7c\xda\x4a\xc9\x8d\x52\xe2\xb5\x80\x79\x75\x17\xdc\xdd\x85\xdd\xbb\xa9\xbb\x9b\x5c\x5d\x08\xf6\x45\x60\x5a\x04\xce\x45\xf8\xb4\x18\x3f\x17\xd3\x6f\x31\xb1\xbb\x07\x3f\x97\xe0\xdf\xbd\xf8\x74\x2f\xfa\x96\x82\x73\x29\xf9\xbb\x8c\x7c\x5e\x0e\xb6\x15\xe4\xc1\x0a\x70\xac\xa0\xef\x0a\x72\x74\x05\xe3\x57\xc0\xd9\x4a\xf2\x77\x25\x31\x58\xc9\xf8\x95\xe8\x5f\x89\xbd\x95\xc4\x6d\x15\xb9\xbc\x8a\xfa\x55\x8c\x5d\xc5\x98\x55\xc4\x65\x15\xdc\xaf\x02\xc7\x6a\xec\xac\x46\xdf\x6a\x62\xb2\x1a\x5b\xab\xc9\xd3\x35\xf0\xbb\x96\x5c\x5a\x8b\xbd\xb5\xe8\x58\x4b\x4e\xaf\x43\xe7\x3a\xb8\x5d\x47\xdb\x3a\x6c\xae\x23\xae\xeb\xe0\x65\x3d\x79\xb3\x1e\xbf\xd7\x93\x67\xf7\x61\xf3\x7e\xfc\xbb\x5f\x95\x70\xbd\x01\xfc\x1b\xb0\xb5\x81\xb6\x0d\xf4\x7d\x00\x7b\x0f\xa2\xf3\x41\x78\x7c\x10\x9d\x9b\xf0\x79\x13\xf6\x37\x61\x7f\x13\xfe\x6c\x62\x0d\xd8\x04\x8f\x9b\xd0\xbd\x89\xfe\x9b\x89\xc1\x66\x72\x76\x33\x1c\x6f\x06\xf7\x66\xec\x6e\x86\xd7\xcd\xac\x3b\x0f\x61\xf7\x21\x78\x79\x08\x9f\x1e\x02\xd3\x43\xf0\xf8\x10\x3c\x3c\x04\x0f\x5b\x88\xc7\x16\x30\x6d\x61\xee\x6e\xc1\xaf\x2d\xd8\xdc\x82\xde\x2d\xf8\xb6\x05\x3e\x1e\x06\xdf\x56\xc6\x6f\x65\xfc\x56\x70\x6c\x23\x5e\x8f\xd0\xf7\x51\xca\xed\xd4\x6f\xc7\xd6\x76\x6c\x3c\xc6\xf3\x63\xe8\x79\x8c\x1c\x78\x0c\x7c\x8f\x91\xd3\x8f\x61\xe3\x31\x6c\x3c\x4e\xfe\x3c\x4e\xfd\xe3\xe4\xfa\xe3\xcc\xcd\xc7\xc1\xf5\x38\x63\x9e\x60\xcc\x13\xd8\x7a\x12\xac\x4f\x81\x7b\x07\xe3\x9e\x06\xe3\xd3\xb4\xed\x84\xf3\x67\xe0\xf8\x59\xfc\x7e\x96\x58\xef\xa2\xcd\xcb\xb3\x17\x3c\x5e\x70\xec\x86\xb3\x3d\x60\xda\x43\x4e\xee\x35\x8f\x02\x62\x1f\x36\xf7\x13\xbb\xfd\xd8\x7c\x8e\xbc\x3b\x40\xdb\x01\x72\xaa\x0c\xdd\x07\x89\xf7\x41\xf4\x1e\x62\xdc\xf3\x70\x78\x18\xdb\x87\xc9\xd9\x23\xe8\x3d\x0a\xee\x63\xe4\xec\x31\xda\x8e\x33\xfe\x05\xec\xbc\x40\xff\x17\xe0\xfb\x45\xf8\x79\x11\x5d\x2f\x61\xeb\x04\x31\x3a\x01\xc7\x27\xf0\xeb\x65\x74\xbf\xc2\xba\xf2\x0a\x18\x5f\xa5\xed\x55\x62\xf0\x1a\x31\x79\x8d\xb8\xbd\x8e\xfe\x37\xd0\xf1\x06\x7e\xbd\x89\xde\x37\xe9\xf3\x16\x7e\x9d\xc4\xe6\xdb\xe0\x7c\x9b\xf7\x53\xf0\x71\x0a\xd0\xa7\xd0\x7d\x1a\x0e\xdf\x41\xc7\x3b\x60\xfd\x07\xb9\xf3\x0f\x7c\x7f\x97\xf2\x5d\xca\x33\xe0\x3b\x43\x5e\xbd\x07\x9e\xf7\xe8\xf7\x3e\xe3\xdf\xa7\xdf\x07\xe4\xce\x07\xf8\xf9\x21\xb9\xf7\x11\xfc\x7e\x84\xae\x7f\x82\xef\x9f\xf8\xf8\x31\xfa\x3f\x26\x97\x48\x25\xf1\x09\x7c\x7d\x42\xdd\xa7\xe8\xff\x14\x7d\x9f\xc1\xc5\x67\x60\xfd\x9c\xe7\xb3\xf8\x72\x96\xfc\xfa\x82\xb6\x2f\x18\x7f\x0e\x9f\xce\x11\xdb\xf3\x60\x3e\x8f\x8f\xe7\xe1\xf9\x4b\xf2\xe5\x4b\xca\x0b\xf0\x70\x81\x7c\xb8\xc8\x7b\x39\x7e\x97\x63\xfb\x5f\xe8\xff\x9a\xfa\xaf\xd1\xf7\x0d\x7d\x2e\x51\x7e\x4b\xf9\x1d\x3c\x7c\x07\x0f\xdf\x13\xeb\x1f\xd0\xf5\x03\x78\x7e\x64\x3e\xfc\x48\x7e\xfd\x44\xff\x9f\x88\xe7\x4f\xf4\xf9\x89\x3e\x3f\x53\xff\x33\x40\x2f\x93\x4f\x97\xc1\x70\x19\x3e\x2e\x93\x1f\x57\x18\x77\x05\x7c\x57\x18\x73\x05\x8c\x57\xd0\xfd\x0b\xd8\x7f\x21\xdf\x7f\xc1\xff\x5f\xf0\xe9\x57\x70\xfc\x0a\xde\x5f\xb1\xf3\x2b\x78\x7f\xa5\xee\x37\xe6\xc1\x6f\xf8\xf1\x1b\x36\x7e\x23\xbe\xbf\xe1\xe7\x6f\x60\xfd\x9d\x58\xfe\x0e\x67\xbf\xc3\xc7\xef\xf0\xf9\x3b\x7d\xff\x60\xfc\x1f\xc4\xe5\x0f\xf0\xfd\x41\xbe\x5f\x05\xdb\x55\xb8\x50\xff\x2d\xa2\x6b\xc4\xef\x1a\xdc\x5e\x03\x4f\x05\xdc\x57\x10\xaf\x8a\x33\xe6\xbf\xdf\xaa\xce\xcb\xc6\xbf\x73\x8a\x1e\x1f\x9c\xf8\x19\xe7\x07\xbf\xbf\xd4\xfa\xfb\x2f\x67\x84\x14\x21\x88\xfa\xda\x79\x07\xf2\xa1\x90\x92\x77\xc9\xbb\x9c\x84\x6c\x46\x2e\x0b\xa9\xd5\x45\x78\xd7\xf6\x09\xa9\x47\x23\xf9\xc8\x12\xa4\x0c\xf9\x4a\x48\x5b\x3c\x92\x8b\xa0\xc3\x46\x9d\xed\x4b\x21\xed\xe1\x48\x2f\xc4\x8b\x60\xc7\xfe\x9b\x90\x01\xe8\x0d\x18\x8f\x6c\x47\xd0\xeb\xa0\xdd\xf1\x00\x72\x1a\xe1\x3d\xb0\x11\x52\x8c\xf0\x1e\x84\xce\x20\x74\x06\x61\x27\xe8\x35\x21\xab\x71\x84\xae\x46\x7b\xb5\xa1\xc8\x6a\xe4\x04\xf2\x83\x90\xc1\xf5\x91\xd1\x08\x7a\x82\xdf\x12\x32\x04\xbb\x21\x2d\x10\xf4\x84\x80\x37\xe4\x13\x21\xab\xa3\xab\x3a\xef\xd5\x9f\x44\xc0\x11\x0a\x8e\x50\xc6\x84\x32\x26\x8c\xfe\x61\xdd\x90\x52\x04\x3b\xe1\xf8\x1f\x8e\xaf\xe1\xd8\x08\x67\x7c\xf8\x25\x21\x23\xc0\xc9\x19\x5a\x46\xac\x47\x0e\x23\xf8\x17\xe9\x42\x06\x20\xcb\x11\xb0\x47\x75\x41\xd0\x17\x85\xaf\x84\x41\x46\x37\x45\x78\x8f\xc6\x97\x18\xf8\x8b\xc1\x5e\x0c\x7c\xc6\xd0\x1e\x1b\x88\xb4\x46\xe0\x2a\x0e\xdb\xf1\x36\x04\x4c\xf1\xd8\x48\x80\x43\xce\xd1\x32\x01\x5e\x6b\xa1\xb3\x16\x38\x6a\x61\xb3\x16\xef\xb5\xe9\x53\x9b\xf6\xda\xe0\xaa\x8d\x1f\x75\xd0\x5f\x07\xfd\x4e\x7c\x70\xc2\x95\x73\x06\x42\x1d\x67\x6c\xe9\x42\x2f\xe7\x6c\xe9\x62\xbc\x0b\xbe\x5d\x8c\x77\x5d\x13\x32\x91\xbe\x89\xb3\x11\x70\x27\xd1\x2f\x09\x6e\x92\x78\x4f\x52\xef\x5b\x11\x7c\x49\x06\x6f\x32\xbe\x25\x13\xab\x64\xda\xea\xc2\x67\x5d\x78\xac\x0b\x17\x29\xf8\x9d\x02\x57\x9c\xcd\x65\x0a\x7c\xa7\x10\x83\x54\xfa\xa4\xe2\x5b\xea\x71\x21\xeb\x11\x8f\x7a\xf4\xab\x8f\x9d\xfa\xf4\xad\x0f\x0f\xf5\xf1\xbd\x3e\xb9\x55\x1f\x0c\xf5\xc1\xdd\x00\xff\x1b\xe0\x7b\x03\xf8\x6e\x40\x7d\x43\xfa\x35\xa4\x5f\x43\xfc\x6b\x88\xde\x86\xf8\xd7\x10\xac\x69\xc4\x22\x0d\x9f\xd2\x16\x22\x70\xdf\x88\xbc\x6b\x04\xa6\x46\xd8\x6c\x8c\x5f\x8d\xe9\xd7\x98\xf1\x8d\xd1\xd9\x04\x3f\x9a\xc0\x69\x13\xfa\x70\xde\x97\xe9\xf8\x90\x8e\xbd\xa6\xe8\x6c\x7a\x56\xc8\x66\xf8\xd6\x9c\xe7\xe6\x60\xcc\x20\xbe\x19\x60\xe7\xdc\x2f\x5b\x80\xad\x05\x3e\xb7\x6c\x27\x64\x2b\x70\xb4\x02\x47\x2b\xda\x32\x0b\x11\xea\x5b\x63\xbb\x35\x58\xda\xd0\xaf\x6d\x2d\x04\x1c\xb7\x60\x8b\x33\xbe\xe4\x8c\x2f\x39\xe3\xcb\x76\xe8\x6d\x47\xff\x76\xf0\xd2\x1e\xde\x3a\xf0\xde\x01\x6c\x59\xc4\x20\x0b\x5b\x59\xe0\x71\x53\xd7\x11\x7f\x3a\x12\x9f\x4e\xcc\xa1\x4e\xf0\xcd\x19\x5d\x72\x36\x37\xfe\x75\xb7\x2e\xcc\x93\x2e\xf8\x91\x8d\x5f\x39\xf4\xcb\x21\xae\x5d\xc1\xdc\x0d\xfd\xdd\xc8\x87\xee\xe0\xea\xc1\x38\xce\xd2\xb2\x27\x73\xa2\x17\x63\x7b\x81\xaf\x37\xcf\x7d\xe8\xd3\x87\xbe\x7d\xe1\xb5\x2f\x7d\x73\xc1\x92\x4b\x2e\xe5\x82\x27\x17\x7d\x9c\x7b\x65\x3f\xec\xf5\xc3\x56\x3f\xda\xfb\x91\x4f\xfd\xf1\xa1\x3f\x75\x79\xe0\xca\x23\x77\xf2\xf0\x33\x8f\x98\xe4\xc1\x09\x4b\x88\x1c\x40\x1f\xce\xbd\x72\x20\xfa\x07\x82\x99\xf3\xae\xe4\xbc\x2b\x07\xd2\x3e\x08\x5b\x83\xc1\xc3\xd9\x56\x72\xb6\x95\x6c\x01\x32\x1f\xbe\xf3\xd1\x91\x0f\x3f\x1e\x70\x7a\x78\xf7\x90\x37\x1e\x78\xf0\x30\x57\x87\x90\x23\x05\xe4\x73\x01\x18\x0a\x88\xc1\x50\xda\x86\xa2\x73\x28\x3a\x86\x92\x07\x43\xe1\x73\x18\x98\x86\x91\x3f\xc3\x88\xe3\x30\xb8\x1b\x06\x27\x9c\x67\xe5\x30\xb8\x18\x8e\xbe\xe1\xf8\x32\x1c\x4c\x23\xe0\x78\x04\x3c\x14\xb2\x16\x14\xd2\x56\x04\xc6\x91\x8c\x19\x49\xdf\x91\xbc\x8f\x82\xef\xd1\xe8\x19\x0d\x0f\xa3\xc9\x81\xd1\xf0\x3a\x06\x1c\x63\x89\xe1\x58\xb0\x8c\x65\xfe\x8e\x63\xec\x38\xec\x8e\xa7\xcf\x78\xea\xc6\xa3\x6f\x02\xf1\x9d\xc0\x1a\x33\x01\x6e\x27\xc0\xdd\x04\xec\x4d\x04\xf3\x44\xec\x4d\x64\xfc\xad\xf0\x7c\x2b\x7e\xdc\xca\xf8\x49\x8c\x9b\x44\x39\x19\xee\x26\x13\x87\x29\x70\x32\x95\xb1\x53\x59\x2b\xa6\xc2\x7d\x31\x78\x8a\xb1\x51\x8c\xed\x69\xc4\x65\x1a\xbe\x4d\x43\xef\x34\xda\xa7\x51\x37\x1d\xae\x4a\xc0\x58\x82\x9f\x25\xe4\x74\x09\x3e\x94\xc0\xe5\x0c\xe2\x33\x13\x5f\x67\xc2\xff\x6d\xf4\x9d\x45\x2e\xcc\x82\xf7\xd9\xc4\x69\x36\x6d\x73\x28\xe7\xe0\xe3\x5c\x6c\xdc\x8e\xde\xdb\xc1\x7e\x07\x98\xe6\xe1\xfb\x7c\x6c\xcc\x07\x47\x29\x38\x39\xa3\xca\x05\xf4\xbf\x8b\x58\xdc\x05\x1f\x77\xd3\x76\x37\x3a\x17\x62\x77\x11\x3e\x2d\x46\xef\x62\xc6\xde\x03\x96\x7b\xd1\x73\x2f\xd8\xef\xc5\x97\x7b\xd1\xbd\x14\x4c\x4b\x89\xcb\x32\xf2\x66\x19\xf9\xbb\x0c\x3d\xcb\xf0\x75\x39\x3e\xad\x40\xd7\x4a\x70\xae\x82\x9f\xd5\xd8\x59\x0d\x2f\x6b\xd0\xb7\x86\xf8\xad\xa5\xdf\x5a\xe6\xfe\x3a\xfc\xe2\x4c\x29\xd7\x81\x61\x3d\xe5\x7d\xf0\x7a\x1f\x71\xbb\x9f\xf6\x0d\x70\xfa\x00\xd8\x1f\xc0\xee\x46\x74\x3d\x08\xae\x07\xc9\x83\x4d\x70\xb3\x09\xdb\x9b\xc1\xb0\x19\x7f\x1f\xc2\x16\xe7\x3f\xb9\x05\x9c\x5b\xf0\xef\x61\x6c\x3d\x8c\x8f\x5b\x59\x1f\xb6\xe1\xc3\x23\xb4\x3f\x82\xad\x47\xb1\xfd\x28\x39\xf5\x28\x7d\xb7\xb3\x9e\x6d\x87\xcb\xed\x60\x79\x0c\x1f\x1e\xc3\xdf\xc7\xc1\xf2\x38\x39\xf9\x04\x3c\x3c\x41\xf9\x24\xdc\x3e\x09\xe6\xa7\xd0\xf7\x14\x39\xfc\x14\x38\x76\xe0\xeb\xd3\xe0\xda\x49\x4c\x77\x82\x6d\x27\xfd\x76\x52\xf7\x0c\x6b\xc9\x33\xb4\x73\xae\x93\xbb\xc8\xf1\x5d\xd8\xf5\xc2\x95\x97\x3e\x5e\xf8\xd8\x4d\x3e\xed\xa6\xdc\x03\xbe\xbd\xd8\xde\x8b\x8d\xbd\xe0\xda\xcb\xb8\xbd\x8c\xd9\x4b\x2c\xf6\x92\xc3\x7b\xc1\xbd\x97\x7e\xfb\xe8\xb3\x8f\x3e\xfb\xc0\xb0\x0f\x7c\xfb\xe0\x76\x1f\x76\xf7\x81\x67\x1f\x98\xf7\xb1\x9e\xec\xc7\xc6\x7e\xec\xef\xc7\xfe\x7e\x78\x7e\x0e\xbb\xcf\xd1\xff\x39\xfa\x3f\x47\xff\x03\xbc\x1f\x80\xaf\x03\x70\x74\x80\x75\xb0\x0c\x7d\x65\xd8\x2c\x23\xd7\xca\x88\x49\x19\xfc\x94\x91\xd7\x65\x70\x73\x90\xf8\x1d\x64\x9e\x1d\x04\xcf\x41\xea\x0f\xd2\xff\x10\xfd\x0f\xd1\xff\x10\x5c\x3f\x8f\xbe\xe7\xa9\x3b\xcc\x1a\x7b\x98\x92\x33\xa6\x3c\xc2\x3c\x38\x02\xd6\xa3\xac\x0d\xc7\xc8\xfb\xe3\xf8\x7b\x1c\xfc\x2f\xc0\xeb\x8b\xe8\x7b\x11\xac\x2f\x51\xff\x12\x7d\x4e\xe0\xe3\x09\xfa\x9d\x80\xff\x97\x89\xe3\xcb\xe0\x7e\x85\xfc\x7c\x85\x18\xbe\x42\xfb\xab\xf0\xf2\x2a\xf1\x7f\x95\xf5\xe3\x55\x30\xbf\x8a\x4f\xaf\xe1\xcb\x6b\xaa\x84\xd7\xd7\xd1\xf9\x3a\x39\xf2\x06\x31\x7a\x83\x31\x6f\x90\x23\x6f\xd2\xfe\x26\x79\xff\x26\x78\xdf\xe4\xfd\x2d\x72\xe7\x2d\xf4\x9c\x24\x3f\x4e\x52\xc7\xb9\x54\xbe\xcd\xb8\xb7\xd1\xf9\x36\x7e\xbe\x0d\x67\xa7\x18\x7b\x0a\x3b\xa7\xe0\xe4\x34\xfe\x9e\x86\xf7\xd3\xf8\xf1\x0e\xb9\xf3\x0e\xbc\xbd\x03\xb7\xff\xa0\xfe\x1f\x8c\x79\x97\xb1\xef\xa2\xf7\x0c\x31\x3c\x03\xa6\xf7\x88\x09\xe7\x55\xf9\x1e\x98\xde\x03\xf3\xfb\xcc\x83\xf7\x89\xeb\xfb\xe0\xfb\x80\x31\x1f\xc0\xdd\x07\xf8\xf9\x01\x7d\x3f\x80\xb3\x0f\xd1\xf9\x21\x39\xf7\x21\x71\xfb\x10\xfb\x1f\x81\xe7\x23\xf2\xe6\x23\xde\xff\x09\x3f\xff\xa4\xef\xc7\xd4\x7d\x4c\x9f\x8f\xc9\xc9\x8f\xb1\xfd\x09\x7c\x7f\x82\xed\x4f\xd1\xfd\x29\xfa\x3e\xa5\xfe\x33\xf8\xfa\x0c\xcc\x9f\xc1\xfb\xe7\xd8\xff\x1c\xfb\x67\xf1\xf5\x2c\xfc\x7e\x81\x8d\x2f\xd0\x73\x8e\xf2\x1c\xbe\x9f\x03\xd7\x79\x6c\x9c\xa7\xed\x4b\x78\xf8\x12\xbb\x5f\x52\x77\x01\x3b\x17\x18\x73\x01\x5b\x17\x88\xfd\x05\xf0\x5d\x24\x0f\xca\xc1\xff\x15\x71\xfe\x0a\x2e\xbf\x22\x9f\xfe\xc5\xf3\xbf\xd0\xf3\x35\x3c\x7f\x8d\xad\xaf\xe1\xfc\x6b\xfc\xfb\x06\x2c\xdf\xa0\xeb\x12\x3a\x2e\x81\xed\x12\xba\x2f\xc1\xdd\xb7\x70\xf2\x2d\x5c\x7f\x47\x5e\x7c\xcf\x3c\xf9\x5e\x95\xf4\xfb\x81\xf9\xf2\x03\xed\x3f\x82\xeb\x47\x62\xf4\x23\xb6\x7e\x64\x0d\xf9\x89\x7c\xf8\x89\x7c\xfb\x89\x58\xfc\x4c\xdb\xcf\xe8\xfb\x99\x7e\x9c\x95\xe5\x65\xd6\xc6\x2b\xd8\xbd\x02\x07\x57\xc0\x70\x05\x9f\x7f\xa1\xcf\x2f\x3c\x73\x46\x96\xbf\xa2\xe3\x57\x38\xf8\x0d\x5c\xbf\x51\xfe\x4e\xbc\x7e\x67\xec\x1f\x8c\xf9\x03\xec\x7f\x30\x7f\xae\xd2\xff\x2a\x3e\x5d\x85\xc3\x6b\xf8\x72\x8d\x3c\xbd\x06\x9e\x0a\xf0\x56\xa0\xc3\x47\xce\xf9\xe0\xcf\x87\x4f\x7e\x7c\xf2\xbf\x25\x34\xb1\x5e\x68\x6c\x4c\x9a\xbc\x24\x34\xed\x4b\xa1\xe9\xa5\x42\xe3\x9c\xaa\xd9\x1e\x10\x9a\xbd\x16\x72\x58\x68\x01\x03\x84\xe6\xa0\xce\x41\x3f\xc7\x3e\xa1\x05\x16\x22\xbf\x09\x2d\x88\x32\xe8\xb4\xd0\xaa\xd1\xaf\xda\x24\xa1\x05\x87\x23\x77\x20\x97\x85\x16\xd2\x4b\x68\xd5\x05\xd2\x05\x39\x2b\xb4\xd0\x25\xc8\x66\xa1\x85\xd5\x47\xb0\x1b\xde\x0d\x19\x8f\x50\x1f\xfe\x24\xf2\x9a\xd0\x38\x3b\x6a\x11\x94\x91\xe8\x8d\x04\x47\xe4\x56\xa1\x45\xcd\x16\x5a\xf4\x42\xa1\xc5\xd0\x2f\x76\xb4\xd0\xe2\x76\x0a\x2d\x7e\xbb\xd0\x6a\x80\xa3\xe6\x6a\xa1\x25\xa0\xbf\x16\x3a\x6b\x47\x23\x67\x84\x56\xc7\x2b\x34\xa7\x0d\x01\xb7\x8b\xbe\x89\x60\xe0\x2c\xa7\x25\x51\x26\x31\x2e\x19\x9c\x75\x19\x93\x52\x17\x01\x47\x2a\x58\xeb\x61\xab\x1e\xbe\xd7\xff\x44\x68\x0d\xf0\xbb\x21\x36\xd3\x18\x93\xf6\x95\xd0\x1a\x31\xa6\x31\xfa\x1b\x97\x09\x8d\x73\x93\x96\xee\x16\x5a\x53\xc6\x36\x0b\x44\xb0\xd7\x1c\x1c\x19\x70\xd8\x02\xbd\x2d\x7e\x10\x5a\x4b\xde\x5b\xc1\x53\x26\x78\x32\x69\x6f\x8d\x4f\xad\xf1\xbf\x0d\x7a\xdb\xc2\x63\x5b\x78\xbe\x85\xf6\x5b\xb0\x7d\x0b\xf6\xda\x51\xd7\x0e\xdd\xed\xb0\xdf\x1e\x9b\xed\xf1\xbd\x3d\x76\x3b\x60\xab\x03\xfe\x75\x38\x21\xb4\x2c\x78\x70\xe7\x22\x60\xed\x88\xad\x8e\xd8\xe9\x04\xcf\x9d\xc1\xd1\x19\x7d\x5d\x68\xeb\xf2\xa1\xd0\xb2\xe1\x29\x87\xba\x1c\xfc\xc9\x41\x5f\x57\x70\x77\xc5\x7e\x57\x9e\xbb\xe1\x53\xb7\x6b\x42\xeb\x0e\x8f\xdd\xd1\xdf\x83\xf8\xf4\x20\x76\x3d\xe9\xd3\x13\x3c\x9c\x95\xb4\x9e\xe0\xe8\x49\x5b\xaf\x46\x08\xfe\xf4\xc2\x36\x67\x27\xad\x37\xb1\xea\x0d\xae\xde\xe8\xe8\x4d\x0c\x7b\xe3\x63\x6f\xf0\xf7\x46\x6f\x6f\x74\xf6\xc1\xd7\x3e\xf0\xd2\x87\x31\x7d\xc0\xdc\x87\x78\xf6\x39\x8e\x80\xa9\x0f\x58\x39\x6f\x69\x7d\x5d\x08\x3e\xf5\x05\x6b\x5f\xe2\xde\x77\x39\x42\x7c\xfa\x82\xa1\x2f\x7d\x72\xe9\x93\x4b\x9f\x5c\xfa\xe4\xd2\x27\x17\xff\x72\xe1\x3e\x97\x7c\xe8\x87\xed\x7e\xf8\xd6\x0f\xbd\xfd\xb0\xdb\x1f\xbc\xfd\xf1\xab\x3f\x98\xfb\xa3\x23\x0f\x7c\x79\xf4\xc9\x03\x5f\x1e\xf6\xf3\xe8\x97\x87\xfd\x3c\xec\x73\x46\xd3\x06\xe0\xcf\x00\x74\x0e\xc0\x9f\x01\x70\x3e\x00\x9f\x06\x86\x20\x70\x35\xb0\x1d\x42\x0c\x06\xc2\xd9\x40\x7c\x19\x84\x2f\x83\xe8\x3f\x88\x1c\x19\x34\x14\xa1\x7e\x10\x38\x06\x81\x63\x10\xdc\x0c\x46\xdf\x60\xe6\xc2\x60\xc6\x0d\x66\xdc\x60\x7c\x1e\x0c\xb6\xc1\xf0\x32\x18\x5e\x06\x83\x6f\x30\xbc\xe4\xe3\x4f\x3e\x9c\xe4\xe3\x6b\x3e\xf5\xf9\x60\xf1\x90\x97\x1e\xf8\xf6\x30\xce\x03\x56\x0f\x39\xe1\x21\x4f\x3d\x60\x1a\x82\xde\x21\xf8\x3f\x04\xff\x87\x80\x75\x08\xfe\x0f\xc1\x8f\x21\xf8\x31\x84\xb1\x43\xc0\x56\xc0\x3c\x2b\x68\x81\x10\xbb\x02\xfc\x2f\x20\x17\x0a\x88\x59\x01\xe3\x87\x62\x6f\x68\x53\x04\xdd\x43\xd1\x3d\x14\x1e\x38\x37\x6a\x43\x19\xcf\x99\x51\x1b\x0a\xc7\xc3\xe8\x33\x0c\xdf\x86\xa1\x7f\x18\xb8\x86\xe1\xdb\x30\x30\x70\x7e\xd4\x86\x91\xab\xc3\xd1\x3d\x1c\x9f\x87\xa3\x77\x38\x7a\x87\x33\x6e\x38\xe3\x46\x30\x6e\x04\xe3\x46\x60\x77\x04\x76\x47\xa0\x7b\x04\x3e\x8d\xa0\x7d\x04\xb8\x0a\xc1\x55\xc8\xd8\x42\xda\x0b\x69\x2f\xa4\xbd\x90\xf6\x42\xda\x0b\x69\x2f\xa2\xbd\x08\x2e\x8a\x88\x51\x11\xd8\x8a\x68\x2f\x02\x5b\x11\xd8\x8a\xe8\x53\x44\x9f\x91\xf8\x3e\x12\xce\x47\x32\xc7\x47\xc2\xf5\x28\x78\x1d\x05\xaf\xa3\xe0\x75\x14\xfd\x46\xc1\xe9\x68\x70\x8c\x06\xc7\x68\xf0\x8f\x9e\x81\x80\x7d\x34\xfc\x8d\x66\x7e\x8d\x81\xdb\x31\xf8\x3f\x86\xdc\x18\x03\x77\x63\x98\x33\x63\x88\xf7\x18\x62\x36\x96\x58\x8f\xa5\x6d\x2c\xdc\x8c\xc5\xfe\x58\xe2\x39\x96\x38\x71\xbe\xd5\xc6\x62\x7b\x1c\xb6\xc7\x61\x7b\x1c\x9c\x8c\x23\xa7\xc6\x91\x53\xe3\xc8\xcb\x71\xe4\xc9\x78\x62\x3d\x9e\x58\x73\xfe\xd5\xc6\x83\x67\x3c\xb8\x39\x03\x6b\xe3\x19\x37\x81\x71\x13\x18\x37\x01\xce\x26\x80\x67\x02\x39\x3d\x01\xdd\x13\xc0\x3f\x81\x79\x39\x91\xf9\x3c\x11\x5e\x26\x82\x69\x22\x98\x26\x82\x69\x22\x98\x26\x82\xe9\x56\x30\xdd\x4a\xac\x6f\x45\xef\xad\xe8\xbd\x95\x71\xb7\x32\xee\x56\xda\x26\xd1\x36\x09\xbc\x93\xc0\x3b\x09\xbd\x93\xd0\x3b\x89\xf6\x49\xf8\x3a\x09\xdb\x93\x58\x7b\x27\xc3\xe9\x64\x38\x9d\xcc\xf8\xc9\x8c\x9f\x4c\xfb\x64\xc6\x4f\xc6\xee\x14\xec\x4e\x61\xfc\x14\xe6\xc5\x14\xda\xa7\xd0\x3e\x85\xf6\x29\x8c\x9f\xc2\xf8\x29\x8c\x9f\xca\xf8\xa9\x8c\x9f\x4a\xfb\x54\xda\xa7\xe2\xd7\x54\x38\x99\x4a\xbc\x8b\x99\x03\x9c\xcb\x35\xce\xe5\x5a\x31\x39\x52\x0c\xcf\xc5\xe4\x48\x31\xfa\x8b\xe1\x9a\xb3\xba\x36\x0d\x1b\xd3\xf0\x6d\x1a\xbe\x4d\xc3\xb7\x69\xf8\x36\x0d\xdf\xa6\x81\x7f\x3a\xf8\xa7\x63\x7f\x3a\xf8\xa7\xc3\xf7\x74\xda\xa6\xd3\x36\x9d\xb6\x12\xda\x4a\x68\x2b\xa1\xad\x84\xb6\x12\xe2\x5b\x42\x7c\x4b\x88\xc5\x0c\xe2\x3b\x83\xf8\xce\x80\xd3\x19\xd8\x9e\x81\xef\x33\xf0\x7d\x06\xd8\x67\x80\x7d\x06\xb6\x67\x12\xe7\x99\xcc\xa1\x99\xe4\xda\x4c\x72\x6d\x26\xb9\x3a\x93\x5c\x9d\xc9\x1c\xb8\x8d\x39\x74\x1b\x73\xfa\x36\xe2\x75\x1b\xfa\x6f\x23\x87\x6e\xc3\xb7\xdb\xb0\x71\x1b\xf9\x78\x1b\xfe\xdd\x86\x9d\x59\xd8\x99\x85\x9d\x59\xe4\xd1\x2c\x6c\xcc\xc2\xbf\x59\xe8\x9f\x05\x37\xb3\xe0\x6f\x36\x36\x66\xc3\xcf\x6c\xfc\x9b\x8d\x9d\xd9\xd8\x99\x8d\x9d\xd9\xd8\x99\x8d\x9d\x39\xea\x3f\x99\x82\x9d\x39\xf0\x3b\x07\x1b\x73\xb0\x31\x07\x1b\x73\xb0\x31\x07\x1b\x73\xe0\x70\x2e\x1c\xce\x85\xc3\xb9\xf8\x31\x17\x0e\xe7\xe2\xc3\x5c\xf8\x9b\x8b\xfe\xdb\xd1\x7f\x3b\xfa\x6f\x47\xff\xed\xe8\xbf\x9d\x9c\xbf\x1d\x0e\x6f\xc7\xc6\xed\xe4\xde\xed\xe4\xde\xed\xe8\xb8\x03\x1d\x77\xd0\xe7\x0e\x38\xe6\xee\xa2\xdd\x81\x8d\x3b\xc0\x79\x07\x3c\xcc\x03\xc3\x3c\x30\xcc\x83\xab\x79\xe4\xed\x3c\xf2\x76\x1e\xf6\xe7\xd1\x76\x27\x1c\xdf\x89\xed\x3b\xd1\x7b\x27\x73\xed\x4e\xc6\xdc\x09\xf7\xf3\xf1\x7b\x3e\xdc\xcd\x07\xf7\x7c\xc6\xcc\x67\xcc\x7c\xe2\x3e\x1f\x5c\xf3\x69\x2f\xc5\x5e\x29\x39\x51\x8a\x4f\xa5\x70\x52\x4a\xcc\x4a\xc1\xb1\x00\xac\x0b\x18\xb3\x80\x31\x0b\x18\xb3\x80\x31\x0b\x18\xb3\x80\x31\x77\xa1\xf3\x2e\x74\xde\x45\xfb\x5d\x70\x79\x17\xb1\xbe\x0b\x0e\xee\x22\x47\xee\x06\xdf\xdd\x70\x7c\x37\xbe\xdd\xcd\x98\xbb\x19\x73\x37\x63\x16\x32\x66\x21\x63\x16\x32\x66\x21\x3a\x17\xa2\x73\x21\xed\x0b\x69\x5f\x08\x3f\x8b\x98\x73\x8b\xc8\x91\x45\xf8\xbd\x08\xbf\x17\xa1\x73\x11\x58\x16\x31\x76\x31\x7e\x2f\xa6\x7d\x31\xed\x8b\xc1\xb9\x18\xdf\x16\x63\xeb\x1e\xfa\xde\x43\x6c\x97\x90\x97\x4b\xd0\xbd\x04\xbb\x4b\x88\xdb\x12\xfc\x58\x42\xee\x2e\x41\xf7\x12\xb8\x59\x42\xdf\x7b\xe9\x73\x2f\xdc\xdc\x4b\x3c\x97\xc2\xff\x52\xf4\x2c\x85\xa7\xa5\xd8\x58\x8a\x8e\x65\xc4\x67\x19\xf9\xb1\x0c\x1d\xcb\xf0\x69\x19\x39\xb8\x8c\xf8\x2d\x63\xec\x72\xfa\x2f\x47\xcf\x0a\x70\xac\xc0\xbf\x15\xd8\x5d\x01\xc6\x15\xc4\x66\x05\x79\xbc\x82\xb6\x95\xf8\xb7\x92\xf1\x2b\x19\xbf\x12\xff\x56\x12\xff\x95\xe0\x58\x89\x6f\xab\xe0\x77\x15\xb8\x56\xd1\x7f\x15\xf1\x5a\x45\x3e\xad\x62\x2d\x59\x8d\xae\xd5\xe4\xed\x6a\xf2\x76\x35\x78\x56\x93\x53\xab\xe9\xb3\x1a\x2e\xd7\xa0\x6f\x0d\x79\xb0\x06\xbc\x6b\xf1\x7d\x2d\x98\xd6\xd2\xce\x3d\x52\x5b\x4b\xce\xae\x65\xfc\x3a\xc6\xad\xc3\xce\x3a\xea\xd6\xb1\xa6\xae\xc7\x87\xf5\x60\x5d\x4f\x4e\xad\xc7\xc6\x7a\xb0\xdf\x47\x2e\xde\x4f\xfd\xfd\x60\xb8\x1f\x9f\xee\x07\xef\xfd\xd4\x6f\xc0\xee\x06\xf0\x6d\xe0\x79\x23\xcf\x1b\xe1\x66\x23\x9c\x6f\xa4\xfd\x41\x72\xe9\x41\x7c\x7c\x10\x3b\x0f\xc2\xff\x26\xb8\xdb\x44\xdf\xcd\xe4\xca\x66\xfc\xde\x0c\xb7\x9b\x59\x27\x1f\xc2\xd7\x87\xf0\x67\x0b\xeb\xc9\x16\xf0\x6d\x21\xa6\x5b\xc0\xbf\x85\xf6\x2d\xf0\xfa\x30\x7d\xb7\xe2\xd7\x36\xf2\x72\x1b\xba\x1e\x01\xe3\xa3\xc4\x7c\x3b\xf8\x1e\x87\xcb\x27\xb0\xf3\x24\x7e\x3e\x89\x8f\x4f\x82\xf7\x29\xe2\xba\x03\x9f\x77\x50\xee\xc4\xe6\x4e\x78\x7d\x06\xfe\x9e\xc5\xc6\x2e\xf4\x7b\xe1\x75\x37\x9c\xed\x46\xdf\x1e\x6c\xef\x25\xe6\x7b\xc1\xbf\x8f\xb1\xfb\xe1\xf7\x39\x74\x3d\x47\xdf\x03\xd8\x3f\x00\x3f\x65\xb4\x97\xc1\x51\x19\xbc\x95\x51\x5f\x46\x9c\x0f\xe2\xc3\x41\x30\x1e\xc4\xaf\x43\xd8\x3a\x04\x7f\x87\xe0\xfb\x79\x38\x78\x9e\x71\x87\x99\x5b\x47\xc0\x76\x04\x5b\x47\xe0\x43\xfd\xa7\x92\x8e\xa2\xe7\x28\x36\x8f\xe2\xe7\x51\xea\x8e\xe1\xd3\x31\xf8\x38\x86\x8e\xe3\xe4\xf3\x0b\x70\xf5\x22\xfd\x5e\x04\xc3\x8b\xd4\xbd\x04\xe7\x2f\x61\xef\x25\xe6\xd1\x09\x78\x3f\x41\x9e\x9d\x80\x8f\x13\x70\xf6\x32\x7a\x5e\x66\x6e\xbc\x8c\x8f\xaf\x30\x86\xfb\xa0\xf6\x0a\x78\x5e\xc1\xcf\x57\xc1\xf0\x2a\xfa\x5f\xc5\xa7\xd7\x18\xf7\x1a\xf9\xf7\x1a\x7e\xbc\x8e\xbd\xd7\xc1\xf8\x06\xbe\xbf\x01\x77\x6f\xd0\xce\x3d\x50\x7b\x13\x1d\xdc\x01\xb5\xb7\xe0\xe6\x2d\x7c\x3b\x89\xaf\x27\xe1\xf2\x6d\xc6\xbe\x4d\x4e\x9c\x82\xc3\x53\xe0\x3c\x0d\xcf\xa7\xc1\x76\x9a\x71\xef\xa0\xeb\x1d\xd6\x9a\x7f\x80\xf1\x1f\xbc\xbf\x4b\xcc\xce\xe0\xf3\x19\x74\x9c\xc1\xde\x19\xe2\xc4\xbd\x4f\x7b\x0f\x6e\x3e\x44\xd7\x67\x60\xbe\x00\xaf\x17\x78\xbf\x40\x3c\x2f\x80\xf5\x02\x7e\x5d\xc4\xee\x45\x30\x5c\xc4\x97\x8b\xf0\x76\x91\x18\x94\x63\xb7\x9c\xf1\xff\xc2\xf7\x7f\x31\xee\x6b\x78\xf9\x9a\xf2\x1b\x6c\x5f\x22\xaf\xbe\xc5\x87\xef\x98\x93\xdf\xc3\xc7\x0f\xe0\xf8\x11\x3b\x3f\x32\xf6\x27\x74\xfd\x44\xfe\xfd\x84\x0f\x3f\xd3\xe7\x32\x76\xae\x60\xf3\x0a\xf9\xfa\x0b\x73\xea\x17\xc6\xfe\x4a\xff\xdf\xc8\x9d\xdf\x89\xc1\xef\xf4\xf9\x83\xf2\x0f\xca\xab\xf0\x79\x15\x4e\xae\xc2\xdf\x35\xc6\x5d\x83\xff\x0a\x7c\xf2\x11\x33\x1f\xed\x7e\x7c\xf7\xc3\xb1\xff\x4b\xa1\x8b\xd6\x48\x31\xb2\x13\xe1\x5d\x86\x23\x03\x90\xf5\xc8\x87\x42\xd7\x6a\x21\x85\xc8\x66\xe4\x8c\xd0\xf5\x40\xa4\x1b\x52\x8a\x30\x46\xa7\x8f\x6d\xb6\xd0\xed\x36\xa4\x3e\xa2\x9e\xe9\x6b\xa7\x8d\x3b\x93\x6e\x7f\x0b\xf9\x04\xb9\x84\x5c\x13\x7a\x40\x08\x82\xce\x80\x46\x08\x76\x03\x96\x20\x5b\x91\xe3\xc8\x59\xe4\x37\xa1\x3b\xc0\xe0\x40\x97\xc3\x8d\xe4\x23\xf4\x73\xd0\xcf\x41\x3f\x47\x19\x72\x1a\xf9\x4a\x00\x05\x89\x47\x9a\x22\x60\xe2\x3e\xa6\x07\x62\x3f\x70\x35\xf2\x24\x82\xce\x40\xf0\x05\xfe\x20\xf4\x20\x70\x07\xb9\x10\xfc\x0d\xca\x45\xc6\x23\xf8\x10\x04\xae\x6a\xd4\x57\xc3\xe7\x6a\xf8\x5c\x8d\xfe\xc1\xd1\xc8\x68\xe4\x01\x04\xfc\x21\x60\x0d\xe1\xb9\x3a\x76\x42\xb1\x19\x7a\x87\xd0\xc3\xb0\x1b\x86\x8e\xf0\x16\x08\x18\xb9\xbb\xe9\xe1\x97\x85\x1e\xd1\x0b\xc1\xf7\x48\xda\x23\xc1\x12\xe9\x15\x7a\x14\xe3\xa3\xf0\x21\x6a\x1f\x82\x7f\xd1\xed\x10\xb8\x89\xa1\x6f\xcc\x72\x04\x7e\x62\xf1\x37\x16\x1d\xb1\xd8\x8f\x03\x6b\x1c\x38\xe3\xd0\x1f\x87\xcf\x71\xd4\xc5\xc3\x49\x3c\x3e\xc6\xa3\x33\x9e\x7e\xf1\xd4\xd5\xa0\x5f\x0d\x38\xaa\x41\x5d\x0d\xec\xd4\x80\x93\x9a\xd8\xad\x49\xbf\x9a\xd4\xd5\xa4\x5f\x4d\x38\x4d\xa0\x2e\x01\x9f\x13\x96\xfc\x0f\x04\xec\xb5\xe8\x5b\x0b\x8e\x6b\xa3\x83\xbb\xa4\x5e\x07\xdb\x75\x16\x0a\xdd\x89\x1f\x4e\x78\x70\xc1\x97\x8b\x38\xb8\x88\x67\x22\x3e\x25\xd1\x9f\x3b\xa5\x9e\xc4\x7b\xf2\x0c\xa1\xd7\x25\x17\xea\x12\x8b\xba\xf8\x98\x82\x1f\xdc\x2f\xf5\x54\xc6\xa4\xa2\x2f\x15\xff\xeb\xe1\x73\x3d\x78\xaf\x8f\xff\xf5\x5f\x13\x7a\x83\xa1\x08\xb6\x1b\xa0\xab\x01\xb1\x6a\x08\x17\x0d\xe1\xbf\x21\x6d\x69\xe4\x4b\x1a\xfa\xd3\xd0\x9b\x46\x7c\xd2\xc0\x97\x76\x02\x81\xb3\x34\xf8\x6e\x44\x7b\xa3\xba\x08\x71\x68\x84\xbe\xc6\xc4\x88\x3b\xaa\xde\x84\x98\x34\xc1\x16\xf7\x54\x3d\x9d\x39\xab\xfe\x3f\x1b\x8c\xff\x0f\x07\x5d\x38\x44\xc8\x5e\xbb\x0c\x10\x22\xfd\x64\xfa\xc9\x66\x4d\x33\x22\x12\x23\xf4\xc4\x88\xc4\x75\xfa\x13\xb3\x2a\xba\x6a\x07\xed\xd9\x7f\x3c\x6f\x7b\xfb\xea\x53\x42\x93\x0f\x12\xec\xb1\xf6\x2e\xc6\x98\x9a\xee\x10\x29\x6d\x9a\xcd\xbe\xa5\xc0\x16\xa9\xe9\x22\x2b\x2b\x2d\x22\x52\xb4\x89\x4f\x6f\xd6\x54\x26\x47\x65\xc8\xcc\x0c\x87\x76\xdf\xfa\x6d\x27\x7c\x2d\xea\xbd\x58\x4f\xae\xd0\x0f\xfc\x71\xf8\xf5\xd7\xd1\x31\x47\xef\x6d\x9b\xac\x66\x01\x3a\xc2\xf6\xdb\xd5\xbf\xb6\x28\x44\x56\x46\x46\x7a\x73\x6b\x20\xa2\xbf\xba\x72\xc0\xd9\x8a\x8d\x2b\xf2\xce\xea\xbd\xb5\xf9\x15\x0b\xb4\xf9\xea\x6f\x86\x69\xa2\x16\x98\x3f\x02\x73\x82\x70\x8a\xf1\xee\x2e\x36\x47\xa0\x1e\x1c\x1a\xbc\xcb\x23\x6b\xd7\x21\x11\x6b\x39\xf5\xb0\xc8\xb0\x5d\x9e\x98\xd8\x1a\x7a\x64\xdf\x48\xd9\x37\x72\x44\xe4\xc3\x91\xdf\x47\xda\xfa\x86\xca\xbe\xa1\x23\x42\x4f\x85\x7e\x1e\x6a\x0b\x8d\x0c\x8d\xb4\x47\xc7\xc5\xeb\x51\x7a\x40\x50\x35\xdd\x2e\xd2\xe3\x32\xb2\xe2\x32\x22\xdb\xb4\x49\x4f\x1f\x36\x6d\xd8\xb4\x88\xb8\x8c\xb4\x08\x11\x97\x51\x59\x02\x4a\x4f\x74\x24\xea\xc9\x51\x4a\x92\x33\x33\x90\x44\x10\x2a\xc9\xa0\x3e\x31\x4a\xff\x78\x81\xb4\xc5\xf8\x2e\x3c\x31\xe5\x31\xdf\x7d\x8f\x4e\x79\xf4\xf5\x98\x2f\x16\xfc\x18\x23\x1d\x4f\x4e\x79\x42\xde\xfa\xc4\x94\x27\xde\x8d\xa9\x70\xdf\x2d\x27\x2e\xd0\x3b\xfa\x5e\x9a\xe4\x1b\x2f\x1f\x50\x32\x49\xb6\x9f\x64\x3e\xf9\xc6\x4f\xf2\xbd\x24\xdb\xab\xbf\x3c\x27\x92\xfd\x25\xb6\x23\xf6\x13\x22\x45\x34\x12\x2d\xc4\x48\xf7\x2d\xb5\x1a\x46\x36\x2c\xf1\x34\x0b\x6c\x10\x58\xe2\xa9\xdd\xa0\x41\xa4\x16\x1d\xe5\x76\xd5\xeb\x16\xe5\x8e\x8c\xeb\x16\x55\x23\x2a\x06\x47\x03\x9a\x3b\x34\x47\x89\x47\xac\x96\x52\xba\xed\xb9\x76\xcd\x9e\x22\xed\xba\x16\x2f\xf0\x2a\x7d\x58\xfa\x30\xe5\x46\x46\xbc\x7a\x49\x4f\x4b\xcb\x88\x88\x6c\x93\x6e\xd4\x28\x69\xd6\xd4\x9e\x9c\x59\x57\xcf\x8c\xb6\x47\x35\xd1\x5b\xb6\xe8\xa0\x65\xc9\x0c\x47\x1d\x19\xe7\x68\x22\xeb\xe9\x75\xb4\x98\xe8\x50\xe9\xd0\xa3\x63\xe3\xa2\x6c\x0e\xd9\x42\xd5\x75\x90\x5a\xc3\x52\xa7\x6f\xa8\xb6\x5b\x86\x8f\x68\xba\x65\xe4\x2d\x59\x0b\x8f\x94\xd4\x28\xad\x71\xf0\xd9\xe0\x7d\xda\xb8\xa9\x79\x7b\x97\xf5\xba\xf3\xb7\xa7\x5e\x1a\xbc\x30\xd7\x2f\x52\xb5\xc6\xe9\xf9\xd3\x87\x3e\xbe\x6b\xc5\xb6\x50\xe9\x49\xb9\x1c\x2a\xff\x15\x9c\xd1\x79\x64\xb7\x7e\xeb\xa7\xb4\xd5\xef\xba\xcb\xb1\xf6\xc9\xc4\x09\x93\x02\x7d\x83\x9a\xf4\x9e\x3e\x70\xf6\x5b\xd3\x1d\xfa\xa1\x76\xbd\x93\xe5\x43\xc1\x87\x2a\x9e\x6b\xd6\xa5\x69\x1d\x5f\x83\x6a\xf7\xa9\xbf\x6c\xe8\x3f\xef\xbf\x6c\x4f\xb4\xf7\x83\x9d\x08\xa2\xde\x48\xb4\x15\xcd\xdc\x2e\x57\xd3\xe7\x3c\xa9\xae\x03\x05\xa9\x99\x94\x35\x82\x6b\x3d\xe7\xb1\x05\x1f\x28\xb0\xc5\x50\x3a\xb4\x00\x81\xf3\xa4\x63\x5a\x9a\x88\x57\x3f\x49\xe9\x64\x99\x91\xd2\x1c\x7f\xb4\xe4\x24\xe5\x67\x5c\x8b\xd4\xe4\xa4\x50\x19\x13\x1d\x9b\xd1\xbc\x83\x94\xaa\x45\xfe\x55\xcb\x8c\x35\xb6\xa7\xd7\x5d\x7b\xe4\x42\x7a\xe1\x22\xcf\xbf\x9a\x8d\x58\xb4\xab\x79\x66\x76\xff\x66\x6d\x5a\x76\xca\x6b\x22\xf7\x5f\x1c\xf4\xe8\x8c\x7f\x35\x1b\xb6\xc8\x9b\xd9\x3c\xbb\x1f\x95\x1d\x07\x34\xb6\x77\x0f\xfc\xa4\xef\xde\x85\x9d\xbf\xec\x75\xb0\xb4\xdd\xf9\xf6\x6d\xf3\x0e\x74\xcc\x6e\x3d\xdc\xeb\x9b\xf2\xe9\xf4\xb3\xb7\x7d\xd9\xeb\x40\x69\x87\x2f\xbb\xb4\x18\xb0\xbf\x53\x76\xeb\x61\xcf\x12\x6f\xbf\xdf\x7f\xc9\x36\xc0\xde\x9b\x78\x37\x17\xed\x45\x1b\xb7\x53\xcf\xa8\x53\xc3\x96\xd0\x32\x2e\xb8\x89\xcd\x9e\x90\x10\x6e\x0f\x6f\xd0\xcf\x13\x6e\x4b\xbc\xc5\x7e\x4b\x3f\x8f\xb0\xc7\x32\x4f\xcc\x68\x5a\x53\x2d\x22\xae\x4d\x64\x5c\x1b\xc2\x98\x94\x5a\x2f\x20\x39\x29\xb5\x65\x8b\xc8\x4c\x7e\xb4\xca\x68\x1e\x6b\x04\x2f\x36\xae\x55\x66\x5c\x00\x21\xcd\x68\x9e\xe9\x08\xd0\x95\x6f\x01\x31\xd1\x71\x1d\x74\x3d\xb5\x9e\xe5\x64\x2b\xfd\xe5\xae\xa5\xf5\xf7\xbf\xf0\xcc\xbe\x23\x2f\xd4\xbe\x70\xa4\x74\x9d\xe7\xf0\xe9\x21\xc5\x73\xfb\x2f\xc9\xdf\x9e\x38\xb8\x7e\x9b\x06\x35\x5b\xac\xe8\x9d\x3d\x71\x49\x8d\xa7\xc6\xb8\x6b\xff\xb2\xac\x60\xc6\xfc\x29\x13\x3b\x2d\x0f\xe9\xd2\xfe\xde\x0d\x4b\x1e\x92\x01\x05\x03\x47\x97\xbd\x3b\x7d\x64\xde\xb2\x39\xb9\x97\x36\xee\x3d\x9f\xf6\xcd\xf9\x56\x19\xe1\xf7\xc4\xda\x26\x64\xba\xef\xbe\xa3\x47\xcf\x4e\xad\xdb\x77\xba\xb6\xf5\x8d\xef\xdb\x1c\x9b\x34\x64\xcc\x2d\x6a\x0e\x4b\x6d\x88\xde\x5b\x5f\x61\xcc\xff\xe0\xbd\xc6\xbf\x8f\x9c\x95\x61\x2d\x19\x5a\xb9\x35\xe1\x55\x3f\xd9\xd2\x37\xd8\xd6\x5c\xfd\x5d\x53\x51\x6d\x6f\x30\xeb\x30\x21\x6d\xd6\x34\x25\x3a\x32\x2e\x39\x55\x6b\xd9\xa2\x26\xeb\x4b\x40\x35\x29\x7f\x2c\x9c\x72\x74\xc2\xa8\x59\xdf\x7f\x74\xf4\xdd\x9f\xee\xf8\xe1\x29\xdf\x89\x7d\x4f\xc8\x4e\x3b\x5e\x95\xc7\xe5\xdd\x1f\xbe\xe3\x9b\xef\x73\x2b\x5d\x62\xbd\x6f\xb0\xbe\xce\xd2\xc5\x26\x69\xea\x92\xc9\xad\x6a\xca\x96\x2d\xb4\x7a\x19\xb1\x91\x31\xd1\xe8\x1a\x70\xfc\xfd\xcb\x73\x27\x8c\x3f\x7e\x6b\xd1\x9c\xef\x7c\x83\xcf\xc8\xbb\xe5\xd1\x13\xcf\xca\x6e\x8f\xef\xf0\x9d\x78\xfc\x84\xaf\xa5\x6f\x9e\x81\xab\x58\xbb\x66\xeb\x65\x7f\x53\x84\x8a\x76\x6e\x97\x56\xad\x9a\x0c\xb6\x05\x06\xda\xf5\xa0\x10\x11\x12\xcc\xff\xec\xd5\x85\x23\xdc\xee\xb2\x97\xda\x57\xdb\x6d\xac\x2e\xc3\x32\xb2\x8c\xb5\x25\x22\x23\xfc\x64\xf3\x08\x26\x5f\x04\x4b\x9d\x5a\x55\x52\xe2\xec\x71\x8e\x60\x59\x2f\x33\x25\x33\x8e\xb5\xa4\xb6\xac\x15\xe5\xfb\xf0\xde\x45\xa3\xdf\x9e\xf0\xad\xef\x97\xae\xbf\x36\x5e\x62\xdb\x3e\x6e\x61\xf7\x3f\xba\x49\xcd\x2f\xba\xfd\xd6\x7d\xf1\xad\xea\xbf\xd8\x89\x2f\x33\xc4\x3e\xdb\x60\xdb\x16\x11\x2c\x9a\xb8\x6b\xda\xb4\x50\xfe\xf1\x38\xec\xa1\xc2\x21\x43\x74\x87\x5d\xd8\xec\xb6\x67\x3c\x41\xf6\xbd\x95\xa9\x12\xfe\xca\x88\xe1\xc3\x8c\x49\x20\x23\x92\x23\x12\x5b\x26\x46\xb0\xbe\xc7\x68\xbb\xd6\xf9\xf2\xe5\x93\xeb\xe4\x93\x5a\xa1\x6f\x80\xdc\xb9\x56\xee\xf4\x0d\x58\x6b\xe8\xcf\xf3\xdd\xa7\x2d\x96\x69\xc4\xa7\xfa\x7e\xa9\x6f\x2e\x90\x36\x11\xfe\x0a\xc3\xa3\x64\xa2\xcc\x93\x0d\x65\x90\xaf\x1b\x3d\xee\xaf\x98\x08\x17\x59\xf2\xb4\xbe\x52\x53\xa7\xa5\x90\xfd\x52\x1c\xf2\xc8\x23\x22\x4b\x59\xca\x4c\x74\xc8\x2c\xa7\xd6\xd4\x29\x4f\x6f\xdd\x4a\x3f\xf5\xdf\x0d\xdd\x69\xe8\x0c\xd9\x2f\xe4\xa6\x02\x11\x69\xf4\x53\x6b\xa8\xbc\xa7\xed\x37\x6d\x65\x9a\xef\x3d\x65\xdb\xee\xbf\x64\x0f\x37\x72\x23\x74\x3f\x5b\xbf\x26\x55\x76\x64\xc1\x56\x9c\xcc\x90\x76\x9b\x67\xcf\xd5\xa7\xa3\xed\x67\xff\x70\xa9\xb5\x72\x0e\x73\xe7\x1e\xfb\x10\x62\x5a\x47\x24\x89\x74\x77\x4d\x67\x88\xeb\x0e\xd7\x72\x97\x1e\xaa\xf6\xe3\xc0\xc0\xa8\x12\x4f\x20\xbb\x14\x2b\x63\x0d\x8c\x89\xeb\x73\x06\x3a\x32\x8c\x19\xa3\x92\xc8\x9c\x29\xd5\x64\x80\x34\xe6\x86\x66\xcd\xfb\x48\xb5\x7b\xc9\x5f\x8e\x1d\x2d\x7a\xa2\xfc\x91\x17\x0e\x0f\x7f\xf6\x5b\xd9\x65\xca\x6d\xf7\x1d\x9c\x3e\x7d\xe6\x84\x4d\x53\x7b\xf8\x5c\xcd\xbe\x69\x16\xfd\xf1\x99\x8d\x72\xad\x8c\xb8\xfb\x1f\xef\x3e\xe4\xbb\xcd\xf7\xaf\x65\xfa\xab\xab\x17\xbd\xe9\x73\x6f\x59\xbf\x7c\x7a\xb9\x1c\xe7\xbb\xf4\xfb\xef\x06\x9f\x2d\xd8\xb3\x6a\xb3\x67\x85\x8a\x54\x37\x7b\x4e\xb0\x23\xa0\xc4\xe3\x70\x04\x07\x84\x68\x42\x03\x1c\x4b\x95\x39\xa5\x33\xd2\x0d\x80\x2c\x56\xec\x2f\x01\xb6\xe4\xcc\xe6\x75\x33\xd9\x66\x1c\x2d\x6a\xc9\x03\xaf\xb6\xf4\xbd\xb7\xb8\xf6\xfd\xd2\x99\xf3\xf8\xd7\xb2\xa8\xd6\x1a\xbd\xa2\x6f\xc9\xfa\xbb\x46\x5d\xed\xb5\xc6\x98\x53\xa2\x1e\x36\x96\xc0\x85\x4b\xa4\xb9\x63\xc3\xc2\x64\xa8\x1e\x16\x16\x15\x15\x52\xe2\x89\x72\xc8\x3a\xa2\x4e\x55\x33\xc6\x4f\x45\x82\x32\xd4\x41\xd6\xcd\xec\xc0\x6c\x52\xbe\x3b\xea\xb5\xaa\x6b\xae\x1b\x9a\x83\xa5\x23\xd1\x51\x2f\xae\xed\x09\x29\xc2\x9e\xb8\xaf\xcb\x8c\xa9\x93\x9f\x4a\xd9\xd7\x4a\x46\xbf\x50\xf6\x56\xd3\x29\x3b\xdf\x5d\xf8\x68\x7d\xed\xdd\x5a\x33\x87\x3c\x5f\x16\x3c\x6b\xc5\x82\xec\xbc\xa1\xb3\x66\x45\xec\x7c\x79\xed\xf2\x6e\x4b\x56\xaf\x5b\x5d\xb0\x22\x6b\xad\xc2\x34\x94\xf8\x28\x4c\xe9\xa2\x9b\xbb\x7e\xbd\xc8\x08\x11\x10\x1e\xe0\x0a\x28\x0c\xb0\x85\xe8\x01\x01\x41\x11\x91\x11\x25\x9e\xc8\xda\x91\xb5\x45\x62\x22\x31\x4a\x74\x88\xa0\x9b\x22\x45\xa8\xd2\x6f\x84\x8c\x7d\xcb\x0a\x5a\x96\x74\x44\x27\x12\x23\x50\xa7\x11\x26\xf3\xa9\x2a\xfe\x80\x30\x59\x47\x2a\x37\x34\xf1\xf6\xfb\xf2\xa8\x94\xfa\xb8\x07\x07\x3d\xb6\x74\xac\x73\x64\xe1\x13\x23\xa7\x4e\x9f\xf5\x74\xd2\x9e\x56\xb2\xd6\x8b\x87\x5f\x79\x7d\xbb\x5c\xb0\xbe\xdf\xda\xb7\xa3\xbd\x4f\xd5\x0a\x8a\x88\xb9\xd0\x7d\x45\x0f\xcf\xb8\xcd\xd9\xf3\x86\xf6\x1b\x32\x77\x6a\xe8\xce\x97\xd6\x2e\x5a\xf7\xb1\xcb\x16\xb6\x6a\x42\xdf\x3d\xb7\x77\x32\xce\x1f\xed\xe0\x79\x10\xb1\xac\x26\xaa\xb3\x0b\xd5\xd2\x85\x2d\xc4\x56\xe2\xb1\x07\x56\xd7\xc3\x42\x9c\x21\xe9\x21\x7a\x48\x88\x24\xc0\x01\x9a\x8c\x37\x12\x97\x63\x45\xfa\x30\xe3\x20\x91\x61\x1c\x24\x38\x44\x64\x4a\x75\x6e\xd0\x65\xa2\x7e\x67\x87\x7d\x1d\x2a\xa6\x27\xe8\xf5\x5f\xdd\x79\xb8\xd6\xdb\x15\x8b\xe5\x65\x99\xe5\x7b\x41\x66\x2d\xd7\xe7\x5e\x5b\xb2\x52\xef\x5c\xd1\xd3\x88\xed\x00\x78\xbc\x1f\x9b\x75\x44\x07\x77\xa2\xcd\x16\x10\x1e\x11\x11\x1b\x1f\x5f\xbd\xc4\x13\xef\x8e\x8a\xed\x16\x1f\x2f\x22\x23\x63\xa0\x32\x40\x04\xfc\x5b\xaa\xa7\x19\x86\xe3\xd3\x15\x0c\x93\xbd\xcc\xd8\x2a\x84\x81\x86\x03\x8c\x39\x05\x34\x9b\xfc\xfa\x95\xd3\x87\xc2\xbf\x9d\xb8\x73\xe4\xbd\xb3\xbb\x2f\xea\xe9\x3d\xac\x27\xd6\xaa\x58\x54\xbc\xe4\x19\xef\xc9\x07\x7c\xdf\x46\x3f\xbb\x2d\xe6\x9d\x51\x07\x07\x8f\x9b\xd3\xb8\xb5\xf6\xe1\x1a\xdf\xe0\x21\xfb\x37\xae\xf0\xfd\xbc\xc6\x3c\x97\xad\x03\xe3\x32\x62\x9d\x20\x1a\x88\xb6\xee\x3a\xc1\xc1\x81\xd1\xd1\xce\x12\x4f\x44\x58\xb4\x0c\xd3\xa3\xa3\x99\x8d\xa1\xc6\x6c\x4c\xfd\xcb\xd9\x78\xfd\xdc\x78\x7d\x52\xba\xa2\x38\x82\x24\x27\x69\x8e\x0e\xd2\x4a\xc9\xa8\x3f\xed\xcb\x5a\xf4\x91\x13\x13\x76\xff\xbc\x5a\x76\xa8\xbd\xb7\xda\xad\xfd\x36\x7e\xd1\xb4\xf3\x89\x92\xc7\x0e\xf5\x5f\xff\xe6\x95\xb9\x53\xf3\x1f\x1d\x72\xc7\xb8\x91\x5b\x0a\xa2\x3f\x7b\x77\x8b\xbc\x4b\x86\xad\xf4\x7d\xe1\x2c\xe8\xe7\x2b\xff\xad\x60\xc4\xee\x8d\xe3\x3e\xd9\x9a\xaf\xd5\x9a\x38\x63\xc8\x86\x29\x73\x57\x8f\x3b\xcc\xda\xe4\x24\xa6\x6f\x18\x31\xad\xe1\x0e\xb1\x05\xda\x03\xec\x25\x9e\x80\x00\xa9\x66\x4c\xf3\x2c\x2b\x72\x89\xc9\x91\x42\x26\xb2\xaa\x05\x4a\xf9\xcd\xe1\x16\x72\x82\x6c\x51\xe1\xac\xa5\xaf\x4a\xf0\xbd\xec\xdb\x21\x1d\x5a\xa1\xec\xbd\x66\x99\x6f\x73\x05\x77\x0e\x23\xef\xd5\xba\x54\x5b\x34\x14\x99\x64\x49\x8d\x98\xc0\xc0\x7a\x4d\xea\x35\x29\xf1\xd4\xab\x27\xc2\xc2\x5c\x25\x9e\x30\x87\x68\xf1\xef\xb1\x52\x45\x44\xe5\xca\xd4\x81\xa5\xb5\x89\x54\xe5\x9f\x53\x5a\xb6\xa8\xc2\x82\x5e\xc9\x89\x71\x88\xf9\xfd\xc4\x47\xc3\xb7\x17\xca\x21\xe3\x16\x7f\xbb\xf6\xc0\xc9\x03\x8b\xe4\xc4\xb9\xb9\x6b\x4f\xc9\xde\x5f\x14\xae\xcc\x29\x9e\x3c\x69\x6d\xdb\x81\x0b\x6f\x9f\xb0\xad\xff\xd5\x99\x9b\xfb\x46\x6f\xbb\x7f\xc2\x9e\xdb\xc2\x6c\xb1\x8b\x46\x4c\x3e\x36\x79\xe3\xdd\x77\x7f\x58\xd3\x16\xb1\x64\xdc\xe0\x83\x77\xe7\xd8\xdc\x4f\x76\x5d\xd4\x63\xf0\xd0\x01\xeb\x2a\xde\x19\x31\x72\xd0\x46\xcf\xeb\xf9\x3b\xcd\x18\xdf\x86\x5f\x73\xf1\xab\xa6\xa8\x2f\x9a\xbb\x6b\xd8\x6c\x22\x24\x24\xa5\xc4\x13\x14\x12\x22\xa2\xa3\x59\x62\xa2\x1d\x7f\x91\x81\x7f\x8a\x6d\x3d\x95\x7d\x91\x99\xea\xa8\xa5\x5c\xd4\x32\x5c\x11\xd7\x97\xde\x1b\x87\xb1\x33\x8f\x3f\x5d\x7d\x4f\x54\xd9\x86\x0b\x19\x6d\xde\x9f\xb9\xe5\x40\xbf\x07\xce\xcc\x93\xb3\x46\x1d\xf8\x55\x16\xcc\x99\x38\xea\xe1\xa1\xb3\x27\x0c\xd9\x31\x34\x7a\xf9\x83\x09\x5e\x19\x79\xd5\x33\xa5\x6c\xdb\xa4\x8f\xb7\x0e\xf6\x15\x6d\xf5\xcd\xf3\x7d\xb9\x5a\x3f\x33\x77\xe5\xf8\x17\xc6\x4c\x9d\x3b\xe2\x41\x85\x59\xed\x3b\x7a\x17\x5b\x5b\xe3\xae\x51\xd7\x1d\xe9\x60\x73\xdc\x54\x10\x60\x0f\x63\x63\x61\x17\xd2\x45\x0c\x31\xb6\x56\x5f\xf3\x3c\xcc\x8e\x14\x2c\x2b\x77\xa5\x3c\x6b\x67\xd2\xc3\xcc\xfd\x49\x13\x5e\xdf\x7d\xd7\xf5\xc5\xbb\x43\xec\x8e\xcd\x05\xf6\x40\x29\x36\x15\xc8\x30\xc3\x6d\x63\xa3\x54\xe3\x83\xd8\x2c\x35\x27\xe3\x2b\x1e\x37\xb7\x4c\x53\xc7\xd5\xc5\xc6\xc6\x69\xed\xe3\x0f\xb2\x8f\xef\x10\x01\xec\xe3\xb5\xa4\xb0\xd9\x34\x7b\x56\xc0\xd4\x80\xf9\x01\x0f\x07\xec\x0a\x38\x15\x10\x10\xa0\x7b\x35\x09\x52\x8d\x33\xc4\x30\x4e\xf2\x4c\xe2\xf6\xe9\x2a\x19\xa3\x5a\xca\x98\x20\x19\x33\x43\x3f\x7f\xed\x71\x7d\x88\x76\xcb\x49\xf9\xc8\x83\xbe\xb5\xbe\x35\x1b\xcd\x38\xcd\x90\xf9\xb6\xc1\xfa\x25\x03\x63\x77\x77\x2b\x9b\xfd\x19\x4f\x5f\xdb\x54\xdb\x7c\xdb\x2a\x9b\x2d\xcc\xf6\xbd\x4d\x0b\xd1\x6d\xee\xc8\xd8\x6e\x36\x29\x9e\xf1\x34\x95\xb9\xb2\x50\x16\x4b\x5b\x2e\x3f\x4a\xa5\x57\x9e\x96\xf6\x30\x2e\x12\xca\xe6\x34\x1c\x4a\x4f\x63\x82\x4e\x53\xbb\x7f\xcb\xc4\x18\x89\x28\xab\xb5\xf5\xf3\x7a\xfe\xfa\xf5\x3e\xb1\x7e\xfd\x9f\xfc\x68\xe4\x4e\x08\xb0\x6b\x9a\xee\xb5\xc9\x30\x9b\xb4\xc9\x2c\x31\x55\xcc\x17\x0f\x8b\x5d\xe2\x94\x50\xb7\xcb\x61\xcd\x95\x27\x96\x17\x99\x2d\x83\x64\x4b\xe5\xc5\x10\xbc\x38\xff\xe0\x46\x39\x55\x4e\x79\xd0\x37\xfc\xa4\xe1\x83\x97\x39\xb9\xce\xc8\xb5\x3a\xa2\xa1\x1b\x40\x09\x11\x09\xb5\xb6\x14\x24\x44\x56\xaf\x1e\x11\x51\xad\x4c\xd6\xdc\xe3\x89\xb0\x59\x3b\x5a\x7a\xd5\x7b\x67\x07\x99\xf9\x6f\xfb\x01\x9b\x59\xa8\x34\xae\xa3\x79\xbb\xe2\x97\xdf\x71\xdf\xfc\x7b\xe6\x2c\x7e\xa5\xde\xfe\x0e\xb2\xf9\xbb\x2f\x7f\xdc\x6a\xe1\xe4\xa5\xf3\x7c\x3f\xd5\x7b\xa9\x9e\x1c\x33\xe1\xb1\x9e\x43\x1e\x18\x39\xb8\x60\xcd\xfc\x90\x17\x3f\xdc\xb8\xac\xeb\x86\x15\xee\xfe\x77\xf9\xba\xbf\xfe\xba\x81\x29\xd8\x77\xc1\x56\xce\xd9\x24\x4b\xf4\x16\x43\xdd\x2d\x13\xec\xdd\x83\xba\xbf\xef\x11\x41\x91\x9d\xc3\x3b\xbf\xef\x89\x8e\x0e\x6f\x1c\x16\xe4\x0c\x1a\x11\x34\x35\x68\x7e\x90\x3d\x58\x84\x73\x1c\x0b\x0a\x0f\x0a\x6f\xd6\xa6\x4d\xd2\x7b\x9e\x36\xa2\x59\xc3\xf7\x3c\xcd\x44\xfa\x9f\xb6\x37\xb8\x1d\x3e\x8c\x49\x9f\xae\x1c\x89\xa8\xdc\x26\x52\x92\xd4\x26\x97\x6c\x4d\x93\x48\xd6\xe7\xb8\x0c\x4e\x02\xe6\x44\x6f\x15\x69\x7a\x57\xcd\x3a\xbd\x67\xc6\xa9\x7e\xc6\x81\x18\x6f\x39\xc7\x6a\xd6\x31\x5f\x33\x97\x85\x48\xdd\x39\xd3\x1e\x14\xd0\x6c\x5d\xef\x7e\x03\x37\x5e\x9c\xb5\xc6\x6e\xef\x30\xe3\x95\xf6\x29\x75\xb3\xef\x1d\xf9\xd0\xca\x85\x3f\x9d\x98\xb3\xe3\xa1\x82\xb2\x79\xad\x96\x97\xcf\x78\xf3\x93\x65\x5f\xc9\xf4\x1d\xc7\x4f\x2f\x3e\x95\x97\xd1\xb8\xd7\x43\x33\x7b\xb7\x28\x1e\x37\x76\xfc\xa4\x9a\x71\xa9\x83\x27\xcd\x9a\xf6\x84\x9c\xf3\xe9\x33\x1b\x7c\xf6\x6d\x73\x93\x9b\x5e\x94\x77\xae\x3c\xfe\xe1\x93\xbe\x17\x7d\x7d\xbd\xa7\xca\x3b\x17\x0c\x1e\x3b\x58\xd6\xfa\xed\x25\x79\x51\x8e\x7b\xc9\xf7\xfb\xd7\x07\x7d\x1d\xaf\x6a\x15\x1d\x3b\x1e\xf3\xed\x5e\xbc\x60\xd4\x01\xe3\xdc\xaa\xf9\x37\x10\xd3\x51\xac\xb3\x0e\xf6\x4e\xe6\x4e\xb0\x36\xc2\xc3\x3e\x61\xd7\x6d\xea\x30\xd8\x3c\x2b\xa3\x4d\xba\x3a\x11\xea\xdc\xb2\x65\x46\x94\x0c\xe5\xd6\xad\xeb\xdb\xdc\x15\x27\xdf\x3d\xa1\xdb\x3e\xfa\xde\xb7\xb8\x49\xf7\xcb\xf2\x54\x2f\x79\xa7\xef\x2e\xe3\x83\xc4\xfe\x82\xe5\xbe\x6c\x79\x59\x18\xf7\xe6\x36\x46\xbe\x64\x8b\x70\x96\x9f\x24\xd1\xd8\x1d\x17\x14\x5b\x3b\xb6\xf6\x08\x4f\x6c\xac\xd4\xb4\x98\x11\x1e\x4d\x97\x75\x46\x78\x64\xe4\xbf\xaf\xb8\xcd\x9a\x36\x90\x32\x91\x85\x88\x2c\xa9\x5c\x62\x39\x57\xe8\x19\xae\x4c\xbd\x45\x62\xb2\x9e\x08\xc5\x5a\x84\xaf\x3e\xcb\xd4\x66\x59\xd6\x7f\xe3\x98\xb5\xeb\x7a\x6f\xfd\x52\xb6\xbc\x67\xf1\xe7\xb9\x5f\xc8\x86\x8d\x9c\xbe\x57\xaf\x0d\x93\xd5\x76\x1d\x8e\xb7\x67\xfb\x7c\x83\xb7\x4f\x8e\x8e\x58\x71\x6b\xff\x1d\x0b\x3a\xda\xa2\xfb\x75\xf5\x15\xfe\xb3\xe2\xc3\x83\xbe\xa4\x39\xb7\xab\x79\xc2\xfa\xf9\xbc\x91\xd3\x99\xee\xe4\xf0\xd8\x11\x1e\x67\x54\x7a\xd4\xd4\x28\x3d\x2a\x2a\xdc\x26\xec\xea\xca\x90\x6b\xe7\x6c\x64\xb7\x07\x06\x42\x4d\x60\x94\xb8\x71\x54\xe3\x6c\x38\x4c\x2d\x2c\xe1\x0a\x4d\x9c\x96\x68\xe4\x05\x5b\x83\xb5\x4d\x86\x4a\x4d\xb6\x93\xd5\xc6\xbd\x98\xbb\xf6\x73\xdf\xbe\x33\x9f\x8d\xdf\x7d\x6d\x9b\xec\xdb\x69\x5f\xe4\xc2\xd1\x93\x1e\x9d\xd9\x5b\x9e\xf0\xbd\xb4\x6a\x59\x47\xdf\xf2\x6f\x2f\x3e\x26\xef\xf8\xa3\xd4\xb7\xbb\xe3\xac\x79\x63\xdf\xf6\x1d\x34\xd7\x0b\xc5\xdd\x06\xb8\x0b\x12\xd1\x22\xce\x1d\xa2\x85\x1a\x74\x85\x55\xa1\xeb\x3a\x47\x5a\x80\xcd\x62\xc7\x38\x23\x3f\xed\x5b\x09\x2d\x99\x5a\xe2\xa4\x13\xbe\xef\x64\xe9\x91\x63\x73\xde\x78\xa4\xf4\xa5\xa5\xb9\x30\xd1\x72\x8b\x6f\xcb\xef\x0b\xf4\xa2\x67\x36\x5d\xfd\xb9\xe8\x84\xac\x8f\xff\xca\xce\xfb\xd8\x09\x16\x2d\xdc\xb5\xed\x81\x23\x3c\xb5\xec\x52\xaf\x6e\x97\x51\x36\xbb\x9d\x6d\xd8\x86\x41\x5d\x04\x8d\xf0\x88\xc8\x9b\x0f\x08\x23\x94\xf3\x19\x52\x1d\x56\x4c\x69\x23\x03\xf4\x0d\x75\x2a\xea\xf7\xd7\x36\xd7\xa9\x18\x3d\x84\xe0\xda\xb3\x37\xfb\x86\x3c\xe8\xcb\xd8\x6c\xae\xad\x1e\x6c\xfd\xd3\xf0\xc9\xe9\x0e\x37\x54\x4b\xbb\xc3\x21\x46\x78\x1c\xba\x3d\xf2\xc6\x97\xaa\xb4\xeb\x1f\x77\x50\xae\x89\x42\x6d\xbb\xb3\x62\xe8\x84\x63\x68\xbf\xbd\x8e\xed\x29\x5f\xe4\x96\x8a\xf3\x28\xb6\x62\xe7\x35\xf6\xf4\xe6\xee\x84\x84\xf8\x11\x9e\x84\x04\xce\x34\xd5\x47\x78\xc2\x82\x39\x6b\x93\xc6\x36\x11\x0d\xf2\x28\x13\x79\x86\x02\x7d\xc3\x84\xbd\x4a\xb8\x8c\x9d\x4e\x8b\x31\x02\xc9\x59\x30\x51\x0f\xd0\x22\x5f\xfd\x60\xe2\xb3\xbf\x6c\x93\xf9\x2d\x9f\xab\x7b\xea\xd6\x87\xa7\xf7\x95\xb6\x2e\x1b\x5b\x75\xf4\x7d\xec\x94\x9f\x4f\xf5\x47\xff\x78\x71\x9b\x5c\xf0\xdb\x3c\xdf\xfe\xd6\xe5\xa3\x5e\xf3\xed\x9d\xef\x3b\xde\xd0\x25\x73\xb7\x56\x9c\xd8\x68\x71\xfa\xaa\xc1\x29\x33\xca\x41\xda\x38\x1c\x41\x76\x5d\xff\xd3\x8c\x8a\x32\x66\x94\xfa\x5e\x25\x75\x6d\x4e\xc5\x2f\x73\xf0\xef\xd8\x14\xad\xda\x94\x63\xbe\x3f\xb4\xa9\x15\x6b\xec\xd9\x15\x6f\x68\xad\xfe\x78\x5e\xf1\x56\x84\xbe\x2d\x86\x3e\x97\x3b\xdc\x16\xe4\x20\x1c\x8e\x48\xbd\x9a\xa8\x86\x73\x7a\xd5\x1b\x04\xc4\x59\xe1\xe0\xb2\x92\x28\xc7\xe9\x99\x75\x7c\x27\xde\x90\xed\xea\x5c\x7b\xbd\x8e\x6c\xf7\x86\xef\x04\xbc\x5d\xfd\x79\xf3\x66\x5b\x75\x23\x1e\xcb\xe0\x6f\x16\x7a\x23\x45\xa2\x3b\x2a\x2c\x04\xde\x8c\x50\x9b\x9f\xab\xec\x8a\x37\xb6\x06\x2b\xd7\xa0\xab\xbd\xcc\x34\x56\xb7\x04\x75\xe6\x62\xe1\x93\x9f\x3e\xf5\xd4\x0b\x43\x07\xbc\x93\xb9\xc1\x87\xfa\x2b\xfb\xea\xf9\xa3\x9f\x7d\x3e\xc8\x19\x55\x5c\x22\x6b\xe8\x41\x9b\xaf\x8d\x38\xf9\x8d\x19\x77\xf8\xb0\x27\x18\xf8\xeb\xba\xe3\x32\x1d\x5d\x1d\x5a\x6b\xd9\x4d\x8e\xc7\x71\xe9\xa8\x66\xab\x42\x4d\x5c\x9b\x61\x5c\x80\x12\xa5\xc3\xe0\x46\x66\x04\x49\xfd\x2e\xdf\xc6\xd7\x0a\x14\x37\x77\x6b\xc7\xbe\xa8\xd8\x28\x9f\xd5\x16\xec\xf4\xa5\xc1\xce\x08\x6d\x5b\xc5\x89\x6b\xbf\x2a\xfd\xea\xdf\x3d\x95\xe8\xb7\x8b\x88\x03\x64\xab\x7e\x23\x5b\x55\x82\xaa\xdb\xda\x42\x14\x7c\xa5\x6d\x25\x21\xaf\x0e\xde\x6c\x60\x8a\x67\xcc\x57\x8c\x89\x13\xb5\xdd\xd5\xf5\x6a\xd5\x42\x23\x1d\x8e\x98\x50\x3d\xe4\x7a\x90\x58\xf9\x23\x8c\xa3\x47\xab\xcc\x30\xae\x08\x7a\x6a\xbd\x60\xa9\xd6\xc0\xd8\xb8\x2c\xc9\xb5\x57\x77\x3f\x55\xa3\x5e\x66\xe1\xef\xf7\xf6\x0b\xab\xd1\xea\xa9\xad\x32\xe0\xdb\x21\x21\xc1\x69\xdd\x64\xfc\x17\xbe\x3f\xf4\xd1\x77\xee\x9a\x74\xc0\xd7\x43\x3e\xd7\xfd\x9f\xbe\x77\xaf\x6d\x66\xe6\xc5\xb5\x79\x76\xc8\x72\xf9\xb5\x19\xcf\xca\xfc\xa8\xce\x3c\x88\x0c\xbe\x5d\x2e\x63\xa5\x08\xd0\x67\x04\x2e\x0c\xd4\x02\x85\x9a\x09\x19\x19\x2c\x2e\xea\x3e\x9c\x28\x03\x0c\x2e\x24\x79\x99\x21\xb5\x8f\x7d\x67\xc2\xa2\x76\xec\x90\x01\x9f\xc9\x8c\x90\xb8\x27\x77\xfa\xfe\xb0\x4d\xdc\x36\xec\xda\x7a\xdc\x5a\xb9\x69\x96\x5e\xa8\xd4\xb3\x76\x8c\x25\xae\x9b\x8d\x3b\x78\x2d\xb5\x76\x04\x46\xb2\x70\xd9\x44\xfc\x8d\xa9\x90\xf6\x17\x37\xed\x70\x63\x77\x0a\x37\xd7\x90\xdf\xde\x78\x6d\xd4\xae\xcb\x9b\x5f\x79\x7b\xe4\xbe\xdf\x64\x97\xaf\x96\x1c\x2b\x29\x1f\xfd\xc0\xcc\x1e\xd1\xff\xfa\x68\xab\xbc\x53\x06\x2d\xfa\xf4\xd3\x4d\xbe\xbb\x7c\xdf\x2f\xd5\x1f\x93\x8d\x5f\xf5\x4d\x7a\xcc\xf7\xfa\xf8\xb3\xb2\x67\xe5\xba\x75\xc0\x88\x75\xb4\x31\xcb\xc3\xd5\x2c\xd7\x38\xe3\x8c\xf0\xd8\x74\xed\xa6\x59\x6e\x4c\x71\xe3\x24\x6d\x8b\x52\xcb\xba\x71\x89\x98\xe9\x2b\x1f\x4d\xc0\xe5\x5b\xa7\x3f\xb9\xcf\xf7\xeb\x3f\x7d\xe7\x7f\x19\xe7\x9b\xbe\xab\x40\xd3\x2a\x7c\xf6\xec\x47\x37\x2c\xf9\x65\x99\xfc\xea\xc5\x8a\x6f\xf3\xb7\x9a\xbe\xfa\xe6\x19\xbe\xd6\xe4\xb6\x9d\xea\x8e\x89\x62\x7b\x89\xb2\x05\x27\xe3\x6b\x70\x54\xa0\x5e\xe8\x19\x11\x28\x03\x85\x99\xc5\x19\x95\xae\x5b\x1f\xde\xd8\xc8\xeb\xa9\xd3\x7c\x15\x16\xa2\xaa\xb2\xa0\x95\x46\x14\x8f\xc9\xec\x50\x73\xe4\x80\x0d\x8f\xc4\x3d\xbd\xc3\x24\xa4\xcf\xca\x57\x3e\xbc\xce\x87\xed\xce\xe9\xd5\x17\xc7\xee\x7c\x35\xe2\xe2\xab\x95\xbc\x2c\xf2\x3d\xe5\xfb\x6d\xbb\x3e\xe7\xaf\x78\x39\x66\x7c\x6f\x88\x53\x5f\x1c\xaa\x6b\x51\xac\x0b\x51\x51\xc2\x6e\x27\x3a\xd7\x67\xc0\xf5\x3d\xd0\x38\xf5\x92\x75\x16\x3f\x6c\x83\xdc\x2b\x1a\xb0\x2c\xaa\x0b\xc6\x00\xdf\x77\xc5\x8a\xa1\x73\xef\x9c\x1c\xf7\xca\x9d\xb2\x56\x2b\xdf\x2f\xbe\x1f\x0a\x64\xfc\xd4\xad\x7d\xb4\xac\x8a\x17\xec\xd9\x0f\xdc\x3b\xfe\x8d\x7b\xa3\x2b\x9e\xb6\x69\x3b\x7c\x0d\xfb\xaa\xff\x3b\x1b\x51\x9f\x9c\x78\xca\xb8\xf7\x73\xe2\xae\x96\x24\xe2\xe3\x9d\x85\x9e\x5a\xf1\x36\x11\x30\xc2\xa3\xab\xbc\x38\xa1\xd8\x39\x61\x1e\x82\xe0\xc8\xc5\xda\x01\x4d\xad\xb2\x8c\x4f\xcc\xe6\x77\x68\x58\x52\x1f\xa1\x93\x5d\x61\x32\xba\x8e\x16\x67\x7c\x8a\xd6\xe4\x15\x5f\xa6\xed\xb8\xf6\xc0\x7d\x0f\x1f\x89\xb5\xb7\x9f\xb4\x79\xcd\x94\xce\xc9\xdd\x56\xbd\x3d\xff\xfd\x17\x83\x5e\xd4\xe6\x96\xfa\xca\xd3\x6c\xe9\xb9\x13\x6f\xd9\x73\x6f\x9f\xfe\x9b\x3e\x8b\x96\x63\x53\xe6\xcf\xba\xbd\xa4\x71\xeb\x1e\x19\xf5\xeb\xb7\xea\x34\x20\x73\xd0\x53\x73\xdb\xdf\xff\x6c\xe2\xd4\xb1\xef\x35\x48\x6f\xd7\xa0\x76\x78\xd3\x5e\xd3\x06\x17\x1e\x98\x9f\xad\x30\xbf\xc9\xba\x51\xdb\x38\x9b\xc4\xb8\xab\x09\xdd\xae\x2b\xa6\xac\x1c\x12\xd7\x6f\xee\x89\x0e\xbd\xcb\x57\x47\xbf\xf2\x65\xd7\xb1\xb5\x60\x7f\xb8\x3a\xd8\xf6\xd4\x66\x73\x8e\x4f\xc1\xe7\x7f\x1a\xff\x8d\x85\x68\x77\x50\x44\x80\x2e\xaa\x57\xd9\x0d\xac\x29\xc0\xbc\xd2\x03\xac\x43\x1b\x8f\x5c\xb8\x7f\x78\xfd\x60\xd4\x8e\x63\x8f\x45\x8f\x99\xb5\x6d\x5b\xc3\x47\x8f\x3e\xd1\xc2\xf7\x5d\xf4\xa6\xc7\x7b\x0f\xd7\x27\x5f\x7b\x66\x6c\x97\xb1\x05\xdb\xcf\xe8\x39\xd7\x1e\xf3\xfd\x72\xd9\xb0\xf1\x04\x18\x47\x18\xf7\xd4\xd0\xfd\x41\x9a\x1e\xa0\xb6\x67\xe3\xdb\x98\x4a\x67\x6b\xb1\xd0\x0a\x5f\xf9\xf9\xf5\x35\xa1\xe1\x8d\x86\xcb\x6f\x5f\xb7\x67\x5f\x9b\xeb\x39\x3a\xec\x90\xbe\xd8\x18\xcf\xb5\xc3\x3e\xa1\x72\x1d\xb2\x85\x87\x57\x8f\x0d\xd2\xa3\xab\x57\x97\x81\xc6\x32\x10\x81\x2a\xf5\xab\x01\x43\x5d\x2a\x6b\xae\xae\x7e\x0d\x13\xc0\x05\x3c\x2a\xa3\xa6\x8c\x8b\x62\x71\x5b\x73\xda\x65\xaf\x96\x38\xea\xcc\xe9\x8c\x23\x2d\xab\xc7\xf4\x1f\xf3\xc8\xae\xd8\x38\xdb\x58\x59\xed\x88\xf4\xde\x22\x83\x72\x3f\xf7\xdd\x82\xc5\x23\x8f\xed\x7f\xe9\xac\xcc\xf7\x7d\xe3\xfb\xe0\x88\x1c\xa2\x77\x36\xd6\x65\xff\xf3\x16\xbf\xc1\xa2\xda\x5e\x5b\xa4\xd4\x8d\xef\xaf\x41\x6a\xd9\x4d\x36\xfe\xc9\xd0\xb6\x4a\xef\xc9\x8a\xd3\x32\xef\xa4\xef\x77\x5f\xad\x93\xda\x18\xdf\x1b\x27\xf5\x2e\x9a\xac\xb8\xa3\x22\x4b\x6b\x5f\xf1\x92\xf6\x82\xb6\x10\x1f\x5e\x50\xff\x55\x07\xf4\x04\xa2\xc7\xcc\xe4\x2c\x05\x38\x4a\x69\x62\xd5\x2a\x38\x3c\xdd\xe7\x3d\x29\xfc\xf2\x9b\x93\x15\x4b\xb4\x6e\x5a\x45\xc5\x43\xda\xa8\x0a\xdd\xc4\x70\x96\x79\xf1\xa3\x71\x26\x60\x6f\x73\xe8\x01\xc4\x38\x40\xd7\x98\xb4\xd6\x49\xa7\xca\xde\xd6\x40\x66\x1a\xb7\x7d\x99\x68\xab\x79\xf5\x95\x5a\xba\xaf\x22\xae\x8e\xfe\x62\xc2\x35\xa9\x17\xad\xb2\xd5\xdc\xbc\xec\xea\x39\xb0\x7c\xe6\x1b\x6c\x9b\xc1\x7d\xc0\xa1\x56\x3e\x69\xbb\xe2\x91\x80\xbb\xe2\x51\x1f\x97\xad\xe9\x1f\xa5\xf6\x48\xe4\x33\x59\xa2\x25\x27\xf8\xd6\xf8\x5e\x92\x53\x13\x7c\x83\x1d\x33\x97\xfd\xbe\x6d\x99\xf1\x2d\xb9\xa1\xff\x92\xfe\xad\xf1\xbd\xb3\xda\x5e\x4d\xfd\xdf\x8d\x29\x7f\xec\x6a\xd1\xcf\xac\xf8\x79\x8f\x16\x61\x7e\xec\x94\xa2\xbf\x6f\xb0\xfe\x55\xa5\x2d\x87\x76\xc5\xe3\x48\x08\xd0\xaf\x78\xb8\x54\x5d\xb7\x95\x99\xa8\x20\xcb\xfe\x09\x5c\xa4\xda\xfb\xd6\x24\x68\xc9\xbe\x15\xbe\xc1\xcb\x02\x46\x2c\xfb\xcd\xb0\x25\xa6\xcb\x43\xb6\x0c\xfc\x0f\x10\x61\xfb\xa1\x44\xda\x02\xae\xff\xd6\x4d\x37\xf6\x1b\x7d\xe3\x33\xbe\x3a\x0f\x68\x0d\xdf\x7c\x4b\x1e\xd2\x93\xaf\x7d\xaa\x2f\xbb\x36\x13\xde\xc6\xf9\xeb\xda\x72\xfd\x0b\xd5\xf7\xfa\x7d\x52\x3c\x8f\x9b\x6a\x45\x75\x40\xcf\xc6\x28\xdb\xfb\x51\x9f\x14\x16\x9a\xdf\xf5\xb3\x6c\xbb\xf5\xa3\xf6\x7d\xec\x8d\x21\xfb\x85\xbe\xbc\x40\xac\x33\xbf\x05\xd7\xcb\xcc\x88\x73\xe8\x1d\xfc\x01\x2f\xef\xb3\xd9\x76\x5f\xac\xfd\x7d\xb4\x79\xee\xec\xce\x9c\x69\x65\xeb\x23\xd2\x44\x6b\xd1\xd6\xed\xac\x53\x27\x29\x26\x29\x21\xd7\x13\xd3\xac\x9f\x27\x26\xc6\x9e\x14\x1e\xd4\xa8\x7a\xa3\x5c\x4f\xf5\x58\xbb\xe8\xe7\x51\xbf\xf9\x30\xcf\x84\x2a\x48\xe4\x69\xda\xf5\x3b\x5f\x8a\xb5\xc0\xb6\xcc\xac\xbc\x31\x65\x46\xa6\x54\xb9\x04\xaa\x73\x57\x44\xb4\xe3\xff\xa3\xec\x3b\xe0\xa2\x3a\xb6\xff\xef\xdc\xb2\xcb\xf6\xbe\x0b\xbb\xec\xc2\xd2\x11\x14\x71\x29\x82\x85\xb5\x80\x58\x43\xb1\x70\x45\x04\x3b\xf6\x82\xbd\x2b\x1a\x3b\x46\x63\x17\x8d\x1a\x0b\x1a\x5b\x14\x63\x89\x2d\x9a\x18\x35\x31\x46\x13\xd3\xcb\x7b\xe9\x3d\xbe\x24\x26\x2f\x91\x1d\xfe\x33\x73\xef\xde\x5d\xd0\xe4\xfd\xfe\xf1\xf3\x12\xdf\xee\xdd\x33\xe7\x9e\x99\x39\x6d\xce\xf9\x0e\xd9\x7a\xb1\x6d\x70\x5e\x45\xae\xc5\x69\x5e\xe6\x2f\x87\xdb\x9a\x97\x3f\xa0\x3b\x27\xe3\x5f\x5d\xb8\xb4\x5a\xd1\x15\xbc\xfa\x83\x81\x1b\x34\x68\xea\x8c\x88\xb3\x19\x3f\x5e\x00\x7d\x95\x03\x15\x31\xbe\xd7\xca\xf7\x4f\xd2\x1b\x2f\x2d\xdb\xd8\xbb\xfb\x44\xf9\x24\x7d\xaf\x5e\x9d\x66\x8f\x9e\x3b\x3e\xb1\x35\x28\xe3\xd8\xc2\xa4\xd0\x7e\xf9\x4f\x94\x19\x36\xae\x85\x0f\x5a\xa6\xc1\x56\x49\xee\x16\x49\xb2\xd2\x6d\xc5\x3c\x4b\x77\x59\xda\x1b\x83\x11\xe0\xf7\xec\x81\xde\xb3\x14\xcd\x9d\x8d\x8a\xa5\x62\xbd\x66\x03\x7a\x47\x5a\x4b\x19\xf4\x68\x2f\xc8\x2d\x54\x54\x01\x4f\x89\x2f\x97\x92\x83\x4f\x0a\x88\xc5\x8c\x47\xef\x22\xc7\xc1\x2c\xda\x83\x72\x4f\x06\x79\x03\x9a\x32\x05\xe5\xa8\x33\x8c\x74\xef\xdf\x32\xe8\x10\x17\x73\x94\x73\xea\x1e\xd4\x17\x45\xb1\x8b\x7f\x05\x6d\x42\x33\x21\xdc\x50\x3e\x74\x7e\x5d\xc5\xb8\x29\x33\xb7\x96\x98\xcf\x24\x4f\x96\xeb\x9e\xec\xc1\xfe\x08\xf9\x1d\xd7\xe1\xc1\xb2\xd9\xf0\x0b\xf8\x15\xfd\xdb\xcc\xf1\x3b\xe1\x8b\xd5\x73\xaa\x9e\x05\xbd\xc9\xda\x98\x84\x78\x1c\x8e\xe6\xc2\x45\xe5\x7a\x8d\x94\x51\x6f\xac\x30\x4e\x32\x2e\x34\x5e\x36\xbe\x69\x94\x2b\x18\x23\x46\x42\xb2\x39\x5c\xf9\x46\xa3\xcd\xa6\x2b\xe0\x6d\x56\x2a\xa4\x80\xff\x14\x85\xf8\x2c\x8a\xb8\x24\xd7\x8d\x44\x2b\x49\x24\xb3\x0c\x90\x29\x91\xa7\x07\xb3\x8b\xe2\x54\x3a\x5a\x74\x84\xe9\x2f\x4f\xdd\xbc\x32\x66\xfa\x93\x47\x87\xcc\x9c\x39\xee\xd9\xb8\xf3\x91\x1b\xef\xcd\x7e\xed\x76\xf1\xbe\x6f\xd9\x3e\x47\x36\x69\x65\xfd\x2b\xd7\xc0\x9b\x2b\xab\x67\x8f\x19\xaf\xae\xd8\xc1\x5f\xbb\xb4\x00\x44\xbc\x3d\x56\x90\xe5\xa4\xc6\xaf\xd8\x9b\x48\x96\xa1\xc8\x06\xc7\x7b\xcd\x66\x8b\x1e\xb9\x36\x4a\x46\x19\x5d\xc0\x2b\xf5\x4c\x78\x01\xcf\x58\x9b\x64\x90\xc9\x91\x91\xb4\x2c\x90\x81\x43\x91\x34\x51\x6b\xd1\xe8\xff\xc7\x0a\x72\x4c\x17\xd2\x4f\x34\x63\xcb\x3d\x35\x6b\xe7\xa6\xd0\x89\x60\xd9\xac\xa7\x91\xc5\x19\x50\xff\x20\x92\x3b\x1c\x0a\x0d\x65\xc3\x17\x1c\x18\x3a\x6e\xea\x80\xb9\x7c\x87\xa3\xa3\xcb\x0f\x1c\x1a\x32\x97\xce\xe8\x3f\x74\x26\xb8\xf2\xd0\x74\x32\x99\x4d\x5a\xf0\xec\xb4\xb1\x3b\x41\xcf\xf9\xb3\xa6\x16\x1e\x86\xdf\x89\x39\x18\x24\xcf\x12\x24\xcf\x30\x2a\x12\xaf\xed\x10\xe4\x6c\x39\x29\xb4\x98\x9d\x4e\x27\x6d\x66\x9d\x4e\xb5\xd9\x6c\x2f\xe0\xcd\x7a\x35\x57\xc0\xab\xad\xcd\xe3\x9d\x40\x3e\xc3\x6f\x2f\x6c\x32\x36\x5a\x8a\x22\x0c\x66\x1d\x00\x68\x69\xbb\x33\xf5\xa0\x9d\x66\xde\xe4\x91\x47\x5a\x6c\xcc\x85\xbe\xbd\x57\x5e\x2f\xd8\xf5\xd9\x53\x60\xb1\x85\x85\x0b\x96\x5e\x88\xa1\xf3\x59\xf0\x47\x6e\xda\xa2\x95\x25\x7d\x5a\xce\x5d\x72\xe3\xc2\x5c\xe0\x7e\x6b\x1c\x5c\x5a\x3a\x3a\x14\xdc\x3d\xba\x2d\x9f\xa0\x04\xbf\x87\x74\x22\x24\x6b\x33\xd2\x6b\x50\x1a\x90\x14\x51\x34\x2d\x63\xd0\x2e\x94\x61\xa8\xb3\x1c\xe9\xb8\x51\x32\x81\x99\x24\x23\x69\x13\xe3\x4e\x39\x0a\x9b\xd6\x9f\xae\x3f\x0d\xff\x72\x00\x19\x97\xf0\xef\xcf\xf2\xf6\x26\x85\x3b\xcf\x24\x8f\x9e\x92\x6b\x06\xdf\x3b\x98\xc3\x0d\x7d\x99\xc3\x35\x61\xaf\x1f\xd1\x84\xac\xe3\xd4\xad\x46\x8f\xac\x11\xe4\xf3\x04\x2c\x61\x97\xb1\x3d\x51\xac\xde\x06\x67\x48\xc3\x75\x96\xb8\x02\x3e\x54\xa9\xb1\xe8\x35\xad\x0a\x78\xb4\xac\x34\x16\x4a\x8e\x76\x86\x90\x2f\xc1\xfb\x9d\xfc\x27\x4b\xf0\xb4\x01\x4e\x25\x62\x9f\xc1\x94\x19\x2d\x93\xe4\x82\x27\x17\xed\x18\x0f\xf2\xa1\xb1\x93\x27\x46\x5a\x24\xa9\x48\x83\xc3\x07\x8f\xb3\x17\xe8\xa1\x83\xfe\x6a\x17\x47\xaf\xf9\xb5\x76\x5d\xc1\x92\x4b\x8b\x26\xaf\xb7\x33\xf2\x18\xee\x39\x93\x6b\x77\x72\x23\xf5\xd3\xe4\x51\x03\xe7\x97\xb4\x2b\x1b\x5b\xb0\xa6\x32\x03\x96\xac\x5c\x14\xd6\xb3\x10\xb4\xbb\x72\x67\xc7\x33\x73\xc1\x13\xb7\x47\x8f\x1e\x12\xbb\x4a\x51\x54\xd3\x70\xed\xf3\x2f\xd9\x21\xf3\x6b\xfa\xec\x87\x3f\x96\x4e\x18\xde\x7f\xf7\xfb\x64\xff\x14\x20\x39\x76\x47\x72\x0c\xa3\x1c\xc8\xb6\x86\x84\x6a\x2c\x21\xe6\x02\x3e\x04\x5f\xd3\x97\x23\x38\x01\xf8\xf8\x02\xe0\x95\xe7\xf1\x2b\xa4\x68\x53\x86\xa8\xa3\x90\xef\x35\xe9\x54\x4f\x55\x2c\xd3\xe5\xf4\x22\xe0\xd6\xac\x3e\xb5\x4c\x35\x60\xd0\xdc\x97\x22\x66\xd7\x73\xaf\xc3\xd9\x6d\xd7\x94\x4f\x80\xbe\xac\x4e\xbe\x14\xfa\x74\x76\x42\x49\xd1\xa9\xed\x3e\x5c\x63\x88\x71\xfa\xd9\x50\x34\xa6\x02\x6d\x01\xa4\x57\x54\xca\x62\x5e\x45\x29\x64\x05\xbc\x42\x47\x71\x0c\x5a\x58\x8c\x45\xb2\x6a\x82\x8d\x88\x15\xc3\xb5\x4c\x77\x3c\xce\x86\xd5\x82\xb9\xe1\x0d\x2d\xc2\xc1\xfe\xed\xf0\x25\x07\xf8\xf5\x99\xd8\xeb\xb1\x35\x35\x35\x8c\xab\xe6\xee\xe5\xcb\x14\xdd\x78\x05\xd9\x9c\x87\x88\xbe\x1e\xf9\xd7\xc8\xdf\x35\x1a\x8a\x79\x23\xa5\x51\xa2\x55\xac\xd3\x2a\xac\x14\x1a\xc8\x6f\xea\x3c\x92\x11\x12\x73\xbc\xfe\xd8\x96\xc5\x59\xb7\xf7\x9f\xd8\x91\xe4\x58\x3b\x67\xc1\xde\xd0\xf3\x70\xb4\x83\xee\xf9\x6e\x0c\xfc\x1d\x39\x67\xd7\x63\xe1\x00\xbb\x61\x75\x54\xf5\x4c\xe6\x95\x9a\x87\x87\xce\xbd\x25\x3b\x85\x86\x45\xb2\xac\x26\x7e\xfd\xeb\x24\x86\x33\x29\x91\x4b\x4f\xcb\xbd\xc6\xb0\x7c\xb9\x3c\x44\xc7\x51\x42\xca\x36\x27\x07\xad\x08\x24\x52\x12\x36\x05\xc7\x70\x89\xf0\xd7\xcd\x7d\xea\x41\x64\x7d\x3d\xdd\xe9\x2d\xdf\xcf\xa0\x3f\xf8\x75\x28\x9c\xc8\xbd\xde\x30\x84\xd6\xc0\x14\xdf\x66\x4c\xdf\x89\xe8\xeb\x88\xdc\x1c\x5e\x2d\x91\x17\xf5\x88\xbc\x82\x65\x45\x3f\xed\x97\xd3\xb7\xf0\x53\x07\xb8\x87\x64\xc4\x1e\xaf\x11\xe2\x4d\xf4\x0f\xbb\x03\xed\xf3\x54\x2a\xc1\x6b\x0e\x37\x9b\x43\xa9\x96\xb2\x50\x44\x32\x32\x54\x6f\xd0\xc5\x2b\x09\xb3\x6d\xc4\x5d\x64\x10\xf9\x0d\x9a\x76\x53\x47\x26\x1d\xad\x57\x0f\x59\xbd\x4e\xf1\xbf\x96\xa6\x6b\x03\x1c\x5a\x6a\x4d\x68\x91\x33\xd5\x3d\xfd\xe0\x3e\xb9\x46\x15\xb2\xd1\xa4\xa0\xb3\x66\xf7\x2c\xe9\x4a\x77\x58\xd4\xb7\xa4\xc0\xba\xba\x0e\x7f\xdf\x69\x62\xe4\x6c\xfa\xe8\x84\x0e\xed\x52\xce\xd7\xf9\x76\x33\xc5\x51\x3d\xbb\xb4\x96\x2f\x68\x3d\xb6\xa4\xbc\x5c\x36\x66\xe0\xa0\xe1\x3d\xa7\xa0\xe5\x43\xbe\x3f\x78\x00\x2f\x1f\x71\xcd\xf6\x20\x3a\x3f\xdc\xab\xb5\x50\x61\x61\x88\xef\x30\xc4\xb6\x52\x14\xb1\x98\x1e\x7b\x84\x5f\xb3\xb8\x86\x31\x9f\xf4\x43\x69\xa9\x12\xe6\x0e\x19\x54\x4c\xd7\x73\x4b\x80\x43\xbb\x3a\xb0\x58\x45\x6e\x64\x73\xda\xa2\x85\x9c\x95\xe7\x4b\xf1\xeb\xf2\x1f\xd8\x32\x34\xbe\x0e\xcd\x08\x8e\x1d\x4d\x64\xc3\x84\x05\xec\xa1\x3f\x76\xcc\x34\x52\xc2\x11\x95\x16\xf8\x4f\x69\xc5\xe0\xf1\xb7\xf3\xd7\x8d\x99\xc0\xf3\xcd\xab\x57\xfa\xee\xf9\x0a\x44\x8c\x9f\xbe\xe4\x48\xf9\xa7\x23\x6a\x46\x65\x9b\x5f\xb9\xf8\x44\x05\xb0\x81\xb0\x33\xe7\x96\xc1\x7b\x6f\x8f\xa1\xbf\x98\x37\x77\x1b\x7c\x63\x39\x6c\x28\x3e\x0a\xc8\xb4\xd1\x8d\x3e\xe4\xbf\x0d\x62\x0b\x70\x94\x84\xd6\xb7\x99\xd1\x52\x46\x23\xb2\xcd\x46\xbd\x52\x27\x73\x50\xd1\x01\x3e\x44\x51\x64\x09\x86\xd9\x2c\xc3\xb3\x93\x29\x89\x01\x5b\x66\x26\x58\xdb\x60\xcb\xfc\x47\x6b\x4e\x5f\x7e\xea\x2f\x87\xf2\x98\x51\xc6\xe6\x1d\x9b\x0b\xd2\xc2\x26\xa4\xf3\xa3\x87\x2c\x1b\xd6\x7e\x5c\xd5\xb4\xad\x83\xcc\x67\x94\x83\x60\x18\xc7\x2c\x2f\x31\x2f\x88\x18\x5d\x0e\x8f\x97\x2f\xf0\xdd\xa4\x1f\x8e\x9b\xd2\xef\x79\xf8\xe7\xc0\x59\x53\x6b\xc1\x60\x41\x46\x88\xc7\x25\x6c\x0f\x64\xef\xe2\xa8\x68\xaf\xc9\x88\xb8\xd2\x21\xb7\xd7\xaa\x76\xc8\x51\xc8\x8d\x58\xd4\xfb\x59\x14\x3c\x07\xe0\x57\x82\x48\x54\xd1\xc6\x20\x8f\x08\x34\x75\x1d\xe6\x2d\x5e\xe1\xa2\x35\xe1\xec\x31\x79\x24\x7c\x78\x6a\x9c\x96\xee\xf5\xfc\x6c\x64\xfa\x26\xd0\x0b\xc6\x4e\x9d\xb6\x8d\x2f\x1d\xb1\xe0\xc0\x10\xb6\xc7\xc0\xc1\x9d\x86\xca\xac\x4f\xff\xf5\x0a\x1d\x97\x35\x61\x68\xdd\x41\x6c\xf8\xe0\xaa\x39\xd3\x76\xc2\xa3\x0b\xaa\xa6\xec\x02\x42\x6d\xc5\x05\xb4\x8e\x16\xa0\x79\xb4\xe1\x59\xb4\xd0\x45\xbc\x45\xaf\x97\xa9\x74\x32\x6c\x3e\x8c\x59\xc4\x74\xf8\x97\x4f\x46\x7a\xbc\x07\xaf\x6f\x0f\x8e\xf0\x6c\xec\xe0\xb1\x23\x76\xfd\x1e\x33\xac\x7e\x79\x18\xf3\x9c\x4c\xc6\x75\xaf\xaa\x29\x1f\x33\x84\xd9\x64\xfa\xe5\x45\xc8\xd2\x17\x96\x6f\x1d\xd4\xa6\x4f\xe7\xb6\x93\x2b\xd3\x0d\x52\x8c\x95\x8b\x6c\x46\x4b\x2a\xd9\x6b\x43\x71\xa5\xcd\x16\x81\x55\x10\x30\x32\x0e\x9b\x1e\x5b\x0b\x16\x4f\x98\x10\x5c\xfa\x8d\xa8\x58\x1a\x23\x04\x98\x68\x19\xa7\x80\x56\xb4\x18\x5f\xfa\xfd\x13\x24\x12\xe4\xdc\xe3\xc0\x97\xa6\x6e\x5d\x94\xef\x63\x26\x6e\xdc\xb2\xad\xb8\x7c\xea\x92\xb1\xed\x3a\xcf\xab\x1f\x7f\xfc\xec\xfe\xca\x69\x2b\x57\x77\xeb\xff\xf1\xd4\x3c\xe7\xfc\x6f\xcc\x0b\xd6\x44\x94\xf4\x9e\x50\x9a\xda\xd9\x1e\x11\xd3\xae\x5f\x87\xfc\xa7\x46\xa6\x3f\x39\xdf\xcc\xe5\x75\xab\xe8\xd7\xaa\x9d\x35\x3b\xad\x4b\x5e\xf2\xa8\xb3\xf8\xda\x55\xa0\x6e\xbc\x8f\xfc\xed\xbe\x68\xee\xa2\xbd\x46\xa3\x06\xad\x2c\x6b\x48\x28\x1d\x5a\xc0\x73\x34\xcb\xd2\x3a\x5c\xf6\x62\x08\x32\xaf\x99\x1e\x5c\x54\x26\x77\x33\x72\x3c\x47\xa2\x4f\x8b\x82\x46\xa0\x76\x1c\x9a\x3c\x33\x13\x1c\x77\xc0\x82\x05\x5c\xaf\xc2\xa5\x87\xec\xc7\xeb\x56\xad\x0c\xa9\x46\x86\x15\xd8\xe1\x57\x35\xbe\xa9\xc9\x59\x19\x51\x2b\x5a\x0d\x1b\xd3\x32\x9a\x7e\x46\xd0\x4b\xcb\x90\xac\x16\xb3\xd9\x54\x04\xde\xdb\xd6\x30\x8a\xec\x6d\xab\xc1\xa2\x44\xbb\x2d\x68\x6f\x83\xe0\x80\x54\xcb\x58\xa2\xd3\x32\x02\x6b\xc6\x04\xde\x59\xaa\xed\x37\xac\xfa\x8c\x73\xf6\x29\x61\x73\x5b\xe4\x4c\xf1\xd9\xe9\xeb\x57\xea\x56\xb3\xd9\xbe\xa2\x7c\x4f\xdf\xbc\xfa\x5a\xba\xaa\xe1\x08\xd9\xde\xaa\xa5\x89\x93\xca\xa6\x2e\x68\xdf\x87\xbe\x23\xf0\x70\x14\xad\x8b\xfb\x88\x07\x35\x8a\x57\x55\xb4\x4e\x8e\xfd\x89\xa0\x78\x35\x02\x64\x66\xa0\xbd\x4b\x0f\xbd\xf7\xe9\xcd\x6a\x85\x92\xb5\xc7\xb5\x05\x3b\x6e\x20\xc2\xde\xae\x53\xd3\xd3\x0b\x46\xd2\x57\x30\x82\x30\x52\xcd\x6e\x44\x43\xc8\x9d\xe9\x74\x6a\xab\x5c\x67\x54\xab\x01\x5e\x5c\xcd\x62\xd6\x78\x39\x29\x1c\x44\x3e\x49\x0e\x0a\x59\x4d\x36\xc1\x79\x5e\xf7\xba\xc7\xd8\x19\xde\x7f\xcd\x71\x22\x8c\xb6\xc8\xe3\x3b\xbc\xff\x52\x8a\x96\xb3\x76\xfb\xf0\x38\x78\xf7\xe6\x2a\xdf\x77\x68\xb8\xdd\x59\xdf\x47\xf5\x5f\x08\xea\xe0\x80\x7b\xf6\x5e\xff\xa2\xcb\x49\xac\xf8\x00\xe7\x50\xd0\xb8\x2a\xca\xea\x55\xc9\x95\xc8\xd3\x0d\xe1\x74\xb4\xa0\x18\x3d\xb8\xe0\xca\xcd\x90\xb0\x95\x04\x9e\x4c\xbb\xef\xe1\xa8\x2b\xb4\x0a\xbe\xff\xea\x07\x60\xee\x0d\xa8\x01\x6d\xc1\x79\xd8\x95\x4e\xa6\xb5\xb0\x14\xec\xf3\xfd\xe6\xbb\x8b\x69\xfe\x8c\xf6\xf2\x2f\x88\xa6\x95\xca\xf4\x6a\x8c\x4a\x1d\xa5\xd3\xeb\x22\x75\x8c\x9d\xd5\x9d\x69\xfc\x97\xd7\xa8\x31\xe4\xeb\x22\x15\xea\x7c\x9d\x59\x61\xa1\xb8\x20\xe3\xea\x49\x4a\x22\x47\x00\xd8\xbc\x0a\xd6\x15\x47\xfa\x26\x17\xb0\x60\xf9\x01\x2d\xa8\xcc\x4f\xb5\xc7\xa4\x3c\xb1\xa7\xbb\x03\xfe\x75\x79\xb5\x2a\x56\x99\x0e\xde\xb8\xe8\x1b\xb9\xfa\xdf\x70\x80\x6a\x99\x6c\xfa\xa2\x54\x36\xc5\x37\x3f\xf5\x82\xde\x5a\xc2\x18\x1f\x5e\xfb\xe5\x34\x92\x6b\x0b\xf4\x7e\x93\x10\x2f\x24\x16\x96\xd1\x1c\x8d\x56\xa5\x0e\xc8\x15\x68\x17\x29\x2c\x4d\x63\x61\x8f\x3f\x14\x96\xb7\x70\x30\xb9\xbe\x05\x0e\xa6\x97\xbd\xe1\x2c\x7d\xdb\xb1\x82\x89\x5b\xb5\xa2\xe1\x83\x55\x78\xae\xdf\x46\xef\xf6\x11\xb2\xa9\x2d\x50\xfc\x10\x1d\x19\x9d\x10\x1a\x66\x09\x0f\x57\xc9\x19\x25\xa5\x52\x3e\xe0\x75\x5a\x95\x0a\x45\x15\x96\x07\xc8\x81\xa0\x12\x82\x42\x64\xc1\xcf\x45\x9a\x8b\xec\x55\x43\x16\x32\x91\x59\x46\xbc\x69\x81\xb0\x02\x33\xd3\xd0\xde\xc5\x13\x89\x14\xad\x5b\x4e\x94\x08\x9a\x5f\x0b\x3e\xa7\x11\x02\xba\x76\xf8\xec\x7d\xc2\x12\x79\x2e\x37\x67\x92\x7d\xc9\x41\x53\x6e\xf8\xe5\x25\x40\xe1\xb8\x57\x56\x61\xea\x6a\xaa\x1d\x5f\x34\x82\xeb\x1a\xd2\xb5\xfb\x3d\x14\x74\xcf\x19\x1f\xe7\x06\xe5\x6d\x8a\x07\x73\x2b\xb8\x39\xa3\x40\xc5\xaa\xbd\xab\x4a\x2b\xe1\xfe\x21\x9b\xd0\xba\x98\x56\x14\x61\x83\xfb\x5a\x44\x76\x6a\xbb\x0a\xc5\xb1\x26\x38\x80\x3e\x2b\xc6\xe4\x40\xaa\x15\x33\x78\x0c\xb4\x69\x3f\x0e\xde\x49\x38\x8d\xe6\xf3\x7b\xe4\x1f\xfd\x86\x9e\x4b\xa4\xba\x79\x63\x62\xe3\xa2\x28\x83\xc6\x22\xe3\x14\x40\xe1\x8e\x72\x47\x3d\xe0\xed\x2e\xb7\xdb\x4a\x59\xd1\x4b\x5b\xd1\xd3\x7f\xf7\xd2\xf8\x8d\x0d\x59\xe4\x3f\xa9\xad\x99\x4c\xb2\x15\xd1\x0b\xa7\xb7\x02\xe9\x99\xc4\xf0\x26\x81\x4c\xb7\xe0\x13\x20\xbd\x60\xc3\x85\x39\x48\x04\xd1\x16\xc7\xbd\xd2\x61\xe6\xae\xa6\x9d\x63\xfa\x0e\x45\xaf\x98\x87\x5e\x11\x28\x26\x2f\x46\x72\x98\x59\x65\xaf\xae\xb3\xe4\x86\xbd\xbc\x04\x05\xff\xfc\x18\x50\x3a\x72\xa3\x8d\xb6\xce\xec\x93\x06\x06\xb6\x88\xec\x9c\xb9\x6a\xf6\xb8\xb8\x68\xb8\x2b\xb5\xb0\x02\xc9\x61\xe6\x58\xb8\x7b\xe9\x21\x72\x16\x4d\x27\xb2\x6b\x99\x78\xb4\xc0\xdb\x79\x63\x29\xfd\x11\x1e\x99\x97\x08\x2a\x85\x62\x8c\x0c\xe5\xb5\x85\xe7\x53\x5e\xb4\x32\x29\x95\xd7\xa4\x52\x71\x47\xf8\x1c\x15\x50\xe1\x4c\x27\x5a\x1f\xf6\x50\xfd\x2d\xb2\x3e\xdb\x88\xd6\x87\xe8\x2e\xa2\x42\xe2\x89\xd6\xcf\xcc\x00\x07\x0a\xd7\x77\x9d\xd9\xa5\xba\xda\xd9\x63\x46\x71\xee\xf2\xae\x33\x4b\xba\xcc\xee\x15\x3e\x9f\x89\x6f\x65\x6f\x39\x68\x63\xcb\xe8\x64\x7b\xcb\x84\xd6\x6b\xfb\x52\x14\xb9\xbd\x87\xfc\xa3\x97\x91\x9b\x8e\x68\x30\x12\xfe\xce\xb4\x11\xcf\xdb\xc3\xbd\x2a\x8a\x92\xd3\x72\xd9\xce\x52\xb9\x8e\x3e\x03\xb4\x4d\x2a\x8e\x3d\xc8\x09\x94\x47\x67\xd2\x99\x1b\x76\xbf\x0c\x5e\x8f\xbf\x12\x4f\x1f\x69\xe8\xce\x75\x25\x67\xb7\x80\x5a\xd3\x78\x95\x5d\xc4\x0d\xa3\xa2\x29\xde\x9b\x69\x2e\x37\x4d\x34\xd1\x3a\xd3\x25\x13\xad\x67\x4c\x46\x6c\x46\xc3\x00\xa9\xa5\xd5\x19\x17\x18\x8f\x19\x6f\x1b\x59\x85\x31\x44\x41\x31\x40\xc7\x30\x8c\x02\xad\x62\x25\x85\x23\xa3\x14\x52\x0f\x4c\x22\xb4\x14\x4f\xca\xe0\x32\x5c\x5e\x8b\x8f\xc8\xf1\x09\x39\xce\x11\x0a\x87\xb1\x3a\x10\x9d\x89\x73\xbd\x46\x9c\x6a\x10\xaa\x69\x89\x77\x80\x6d\x2f\x9d\x37\xe9\x60\x5c\x7d\xeb\xbf\xf6\xc6\x2d\x8c\x3b\x78\xaa\xe0\xe9\x37\xe6\xc4\x2c\x8c\xd9\x7a\x84\x3e\x3f\x63\xd2\xe0\x0d\x63\xb3\xab\x81\x66\xfc\x38\xf5\x9a\xb3\xda\xab\x57\x35\x97\x9f\x9b\x0e\xa8\x8b\x13\x95\x67\xce\x68\xea\xd6\x68\x87\x0f\xeb\xbe\xfe\xad\x41\x4f\x2e\xc5\xeb\xee\x36\xf6\x39\xb9\x81\xc8\x23\x40\x7b\x2d\xc2\x6e\x0b\xd1\x44\xe9\x5d\x0a\xb5\xa2\x8a\x77\xa8\xd5\x8c\x5e\x6f\xab\xc2\x87\xd1\x72\x36\x8a\x89\xaa\xe2\xe3\x98\x50\xa9\x66\xd4\x93\x12\x28\xca\x20\xee\x28\x5e\x79\xc8\xd3\x95\x45\xa3\xa8\x8e\xce\x41\x7c\x7b\x32\xc9\x91\xb9\x10\xdd\xa1\x08\x10\x99\x23\x52\x0a\x86\xde\x8c\xe5\xcb\xcf\x35\xac\x75\x95\x0f\xc8\x36\x38\xce\x85\x9f\x6b\x11\x47\x35\xbe\xb1\xad\x5e\x73\x56\x39\xba\xcf\xec\x9a\xd0\x16\x60\x4b\x38\xac\x74\x38\x86\xf3\x74\x49\xbb\x2e\x96\xfb\xf7\xb7\xb5\xec\x3d\xb9\x68\x4d\xcd\x47\x57\x6f\xcc\x1e\x97\x95\xe3\xad\x9a\xf7\x5e\xcd\xaa\xa5\xab\x5b\xa4\xa7\x0b\xbe\xdf\x34\xea\xdf\xec\x1a\xb6\x0a\x79\x7e\x49\xc8\x6b\x50\x99\xdd\x47\x78\x33\xc7\x25\x1c\xe1\x39\x12\xf1\xe9\x5f\x16\x12\x47\x36\x7c\xf6\x9d\x69\x93\xe3\xbc\xbd\xdc\x26\xc7\x25\xae\xf1\xf2\x78\x52\xe1\x6a\x33\x07\x2a\x99\x90\xb3\x53\x58\x38\xb7\x60\x61\xcd\xca\x21\x53\xfb\x56\xc5\xe7\x77\x29\x9c\x53\xb8\x68\x45\x4d\xf9\xbc\xa2\xd9\xb1\xb9\x25\x4b\x86\x17\xed\x1c\x56\x3d\xac\x78\xfb\x28\xa6\x6e\xf8\xa8\x11\x45\x05\x43\x46\x57\xf4\x29\x1b\x70\x34\x7f\xf8\xe8\x11\x7d\x0a\x46\x8f\x1e\xd9\x7b\x60\xc9\xd1\x2f\x86\x2e\x2a\xad\xed\x3f\x6c\x11\xbf\x83\xac\x97\x12\x64\x77\xd2\xb9\x5c\xa4\xab\xbb\x7b\x5b\xc8\x95\x1a\x65\x05\xcf\x6a\x18\xad\x41\x5b\xc1\x9b\x29\x03\xa5\x01\xf7\x35\x60\x81\x66\xad\x86\xd6\x18\x34\x86\x10\x93\xc5\x8a\x36\x8a\x82\x24\x52\xa5\x52\xf2\xb2\xc9\x06\x8f\x27\x70\xae\x2f\x1c\x98\xc9\xc5\x4a\xf2\x4c\xf2\x87\xd8\x0f\xc6\x06\x3a\x85\xc3\x45\x76\xb0\x00\xfd\xbb\xcd\x89\x36\xb0\x3a\x1c\xcc\x43\x7f\x0d\x07\x5e\xf8\xf5\xab\xff\x01\x5f\xbe\x4a\x1f\xa8\x59\xf1\x54\x23\xe2\xea\xa9\x15\x35\xf4\x4e\xdf\x66\x7a\x34\x96\x21\xd2\x53\x59\x48\x4f\x1d\x25\x7b\xc3\xe2\x55\x70\x14\x47\x01\xd6\x81\x2b\x26\x85\x82\x53\x41\x69\x31\x82\xe2\xda\xbf\x9f\xde\xcb\x28\x1b\x7e\x7f\xb8\x91\x51\x35\x3c\x10\xf3\x6f\x7d\xd9\x6d\x48\x7f\x65\x52\x79\x54\x9e\x37\x36\xd9\xda\x25\x55\xdb\xae\x0b\xfa\xe3\xa2\x5c\xb1\x85\x3c\x15\xa5\x8f\xa2\x0d\x4c\x54\x94\x8b\x0a\x29\xe4\x23\x49\xb2\x87\xf2\x27\x7b\x52\x02\x47\x9c\xb8\x8e\xc1\x80\x6d\xb1\x47\x50\x00\xc1\x6e\x95\x50\x41\x2e\x1c\xab\x47\x07\xf9\x61\xad\x40\x7c\x0c\x9a\xc3\x4c\xa1\xc2\x09\xf9\xa6\xf1\x78\x7b\xa0\xad\xd2\x91\x66\x52\x8e\x9c\xa7\xf7\x4d\x19\xbb\x7c\xcb\x84\xed\xd5\x8b\xf2\xf3\x16\xf5\xe9\x5b\x9c\xb7\xf4\xfc\xb4\xdb\x57\x14\x07\x98\xf9\x2b\xd6\x1f\x69\x3b\x66\x39\xbc\xf9\xcc\xfc\x1e\x25\x53\xee\x00\xe3\xec\x6d\x05\x8b\xf2\x52\x87\x4d\xee\xbf\xa4\x27\xf7\x3a\xf6\xc3\x7a\x16\x8c\x2d\xcc\x28\x8c\x73\xe7\x55\x74\xce\x5d\x3d\xcc\x90\x30\xa2\x5b\xfe\x53\xa3\x32\xaa\xd7\x44\x54\x0c\x98\x31\xb8\x55\xe7\xd4\x98\x6e\x17\xc7\x9c\x8c\xb2\x8f\xcf\x2f\xdd\xd3\xbf\xe1\x9b\x0e\x03\x63\xd9\x8e\x63\xd2\xe3\x72\x52\x5d\x74\xc6\x08\xa4\x6f\xde\x62\xaf\xb2\x31\xdc\x1c\x22\x53\x33\x92\x29\xa0\xc0\x53\xa5\x2c\xb5\x41\x2c\x13\x22\x6e\x1a\x8a\x0b\x3d\x72\xa6\x2c\xe6\xd9\x18\xdf\x5b\x31\xfb\x62\xd8\xab\x67\xd0\x3f\xe8\x17\x11\x54\x1c\x7b\x84\xe4\xa6\x12\xa8\x74\x6a\x91\x77\x20\x2e\x78\x5c\x28\x7b\x4a\xb6\x4b\xc6\x51\xe4\x2f\x0c\xae\x7c\x54\x2a\x99\x1b\xbc\xde\x7a\x83\x37\x99\xf4\xe5\xca\x89\xca\x05\x4a\x46\xa7\x8c\x40\xff\x59\xab\xfc\x59\xd9\xa8\x94\x1d\xd7\x5f\xd6\xd3\x94\x5e\xaf\x9f\xa4\x5f\xa8\xff\x97\x9e\x53\x30\x4a\xbd\x52\xef\x8c\x8d\x4d\xbe\xce\xc7\x52\x4e\xcf\x75\xde\xf9\x66\xb3\x2a\x49\xac\x80\xf0\x72\x13\xea\xfd\x04\x85\x84\x58\x0d\xaa\x0f\x11\x6a\xc2\xc5\x7d\xcd\x99\x69\x36\x3a\x2a\x06\x39\xc2\x46\xb4\xdb\x59\xa3\x5c\x4f\x09\x41\x15\x0a\xb3\x28\x50\x33\x7d\x4c\xa7\x8a\xe8\xaa\xb4\xad\x63\xea\xce\x9e\xa8\x7b\xbf\xff\x14\xfb\x10\xef\xd8\x49\x4c\x44\x0d\xfc\xef\xf3\x28\x38\x59\x5b\x03\x14\xc7\x8f\x03\x45\xcd\x20\xd8\xf0\xf5\xe6\x0f\xa7\x53\x8d\xdf\x7e\x8b\x42\xf4\x87\x5b\x8f\xf4\x28\x8a\x9e\x3e\xf6\xf3\xd7\x6e\x7e\x72\xc7\xdd\x25\x6f\xf7\xae\xcf\xe1\xd9\x83\xcf\x81\xbc\xcf\x3e\x03\x79\xcf\x1d\x82\x2f\x7e\x01\x5a\x82\x6e\xeb\xe0\x97\xd7\xe1\x3d\xf8\x02\xc8\x47\xb2\x56\xd0\xab\xd8\x44\x6e\x0b\x15\x4f\x79\xa8\x0e\x5e\x0b\xc7\xc5\x29\xe2\x5a\x7f\xcd\xc7\xc5\x29\x5c\x0e\x53\x92\x2b\xe9\x0b\x3e\xd4\x75\x06\x58\xeb\x15\xf4\x57\xbc\xe2\x0c\xf6\x1e\x85\xa3\x35\x5c\x24\x83\x94\x57\x68\x4a\x40\xf9\xa7\xf9\x33\xbd\x82\xa5\x94\xe1\xd2\x17\xe2\x41\xa7\xfb\x13\x44\x99\x19\xb1\xc8\x12\x09\x3a\x03\x67\x80\x01\x33\x79\x53\xdf\x31\xf6\xa7\xe3\xae\xaf\x5f\xba\x46\xde\x56\x96\x15\xea\x30\xa5\xa5\x2d\x65\xd9\x79\xd7\xc6\x54\x71\xad\xc1\x88\xcb\x5a\x98\xda\xbe\x6b\xee\xc2\x12\xa5\x72\xfb\xd3\xd5\xec\xf9\x45\x5d\x7b\x2b\x2b\x67\x8f\x1c\x1e\xed\x82\x1f\x47\x84\xe6\x84\x0c\xd6\x4c\x6f\xb1\x9f\x2f\xb4\x84\xff\xc8\xb1\x3d\xe1\xa9\x96\x39\x5d\xc7\x67\x78\x58\xa6\xbf\xa0\xdf\x66\x52\x6b\xd8\xc3\xcc\x61\x2a\x04\x29\x8b\x44\xaf\x59\x45\x2b\x91\x5d\xa0\xd1\xec\x53\x6a\x86\x62\x7e\x2e\x55\x50\x3f\x89\x4b\x0a\x17\x75\xd9\xc4\x13\xe0\x58\x80\x1c\x3a\xb9\x02\x29\x5c\xff\x5f\x98\xc1\xf0\x81\x06\x6c\x3b\x21\x83\x23\x80\x46\xe6\x9b\x08\xff\xd0\x80\x2d\xcf\xcb\x60\x25\x50\xca\xd6\x80\xf1\x39\xa0\x2a\x02\xae\x86\xeb\x9c\x41\x7f\x0d\xd4\x88\xd3\xbf\x20\x95\xe0\xf0\x6a\x74\x14\x40\xa3\xd2\x0c\x7d\x84\x67\x4e\x8a\x65\x6a\x24\x4b\x1b\x4b\xca\xc1\x99\x6b\x0d\x47\x99\xcf\xeb\xc1\xe1\xf5\xbe\x2b\xc8\x06\xfb\x6b\xba\x91\x0d\xc6\xe9\x2b\x56\x5a\xd7\xf8\x8c\xb7\x05\x9a\xab\x5e\xde\x96\x4e\x77\x62\x44\xeb\x88\xeb\x7c\x54\xca\x75\x41\x4f\xe8\xdc\x11\x6e\x5a\xc1\xb8\x5b\x47\x45\x21\xd7\x98\x55\xab\x4d\xd7\x79\x35\xc5\xda\xaf\xf3\x6c\xd0\x62\xb5\xe1\xc5\x8a\x57\x67\x59\x92\xa0\x18\xf1\x22\xfd\x87\xb5\xc8\x31\xd1\xb8\x64\x9d\x1c\xdb\xca\x4d\x0c\x76\x86\x0c\x68\x49\xb3\x47\xfe\x71\x2d\xc2\x4f\x5e\xdd\xbd\x00\x78\x6a\x36\x57\xf6\xfb\xf8\x99\xf2\xc2\x43\x2f\x14\xf4\xa5\xff\xfc\xe7\xd5\x38\x0d\x14\xc0\xe3\x4c\xce\xfc\x89\x23\xe7\x98\xe0\x1e\xba\x20\x37\x1f\xbe\xd5\x0f\xfb\x23\xe7\xb8\x5f\xb8\x67\x65\x45\x46\x39\xd5\x19\x14\xcb\xde\x20\x3e\x49\x37\x26\x92\x59\x8a\xec\xaf\x0a\x45\x25\x51\x5e\x23\x63\x39\xc6\x23\x57\x41\x81\x5d\x05\x85\xee\x18\xaf\x60\x83\x0a\x77\xb0\x19\x33\xcb\xfc\xfb\xcf\x2a\xf7\xab\x46\xdc\x76\xb1\xf4\xe0\xf4\xe9\x07\x0f\xcc\x9c\x79\x60\xfc\xa8\x9e\x3d\x47\x8d\xee\xde\xa3\x92\xed\x30\x63\x7f\xdd\xb4\x69\x75\xfb\x67\xf4\xaa\x1c\xd3\xa3\xc7\x98\xd1\x42\x2e\x19\x4d\xc2\x00\xf6\x2a\x1a\x4f\x47\xf5\xf6\x26\xb1\xb4\x56\xad\x39\xc2\xab\xc5\xb2\x7f\x14\x57\xe9\xe4\x11\xf2\x72\xf9\x44\xf9\x31\xf9\x25\xb9\xcc\x10\xd4\x03\x80\x2f\x5a\x30\x59\xf3\xb1\x4d\x0d\xea\x05\x98\x9c\x44\xea\xfa\x9a\x35\x04\xe0\xda\xbe\x40\x53\x00\x2e\xf1\xa3\xeb\xe0\x34\xb0\x6a\x1d\x58\x09\xa7\xaf\xf3\x95\xac\xc3\x67\xbb\x00\x45\xce\x28\x12\x5a\x83\x7c\x59\x5c\x67\xae\x06\x1a\x46\xad\xd6\xeb\x15\x5f\xf0\xfa\x4f\x00\x8a\x32\xbf\xe0\xa9\x8f\x1f\x53\x67\x8e\x6b\xf2\xc8\x89\x4c\xf0\x36\x95\x09\x45\xe6\xa0\xa3\x31\x79\xeb\x9c\x79\x13\x67\x77\x1d\x65\xa9\x8e\xbe\x30\xaf\x6a\xd6\xbc\x79\xb5\x53\x22\xc1\x6b\x26\xda\x33\x2a\x77\x61\xcf\x5e\x0b\xf2\x47\x76\xef\x1a\x32\x61\x51\x45\x49\xc5\x33\xbd\x87\x96\xa4\x8e\xc5\x7c\x54\xd0\xf1\xac\x02\xf1\x91\x48\x15\x7a\x53\xa2\x74\x5a\x9d\xf6\x0b\x64\xa2\x5a\xb3\x28\xb2\xa6\xb4\xa1\xa1\xe1\xe5\xba\x89\x3a\x5a\xad\x0b\xd7\xa1\x45\xa9\x43\x0b\x37\xdc\xf2\x05\x1f\xfe\x09\x15\x82\x18\xfc\xb4\x79\xb6\xbd\x0c\x85\x90\xb8\x2b\xaa\xcc\x1f\x14\x47\xe2\xf2\x13\xb9\x99\x58\x2a\x52\x61\x9e\xd1\x9c\x73\x12\x81\x68\x01\x3d\x05\xfe\xb4\x0a\xd4\x96\x0d\xdb\xd7\xc1\x92\x55\x36\x7e\x4e\xd7\xa1\xa6\x25\x51\xf5\x0b\x26\x2f\xa8\x1a\xdd\xbf\x57\xdf\xed\x74\xfc\xdb\x3a\x0d\xa7\x98\x3d\xb2\xf7\x98\xf1\x83\x7b\x0c\xcd\xeb\xa4\x1e\x37\xab\xb4\xb8\x64\x85\x8d\x56\x94\x74\xe8\xb9\xb2\x27\x8a\x35\x8c\xec\xf3\xcc\x8f\xe2\x99\x19\x47\xaf\x2e\xe5\xc4\x33\xb3\xcc\x58\x8f\x9c\x43\xdf\x02\xe3\x2b\x32\x78\x80\x7d\xde\xfc\xb3\xf3\x2b\xec\xfb\x7d\x08\x67\xb0\xcf\x20\x7f\x38\x12\xc7\x6d\x61\x3a\x9d\xd6\xc1\x5a\xe4\x16\xe4\x9c\xca\xad\x54\x50\xba\x9e\x44\xd9\xc8\xb2\x0a\xda\x2f\x3e\x5a\xc8\x90\x12\xb5\xe8\x0f\xf5\x99\x24\xc6\xa0\x60\x37\x7e\x51\x54\x65\x61\xcd\xf9\x2f\x00\xd7\x0b\xf3\xd4\xef\x56\xbf\x13\x3e\xf3\xd4\x3e\x99\x56\x15\xc2\x9a\xe7\x7a\x3e\xf4\x66\xcf\x86\xab\xb8\xab\xbe\xb9\x79\xb1\x77\xaf\x6c\xa2\x47\x37\x1c\x8b\xea\xd5\x25\x55\x8e\xf4\xcb\x2d\x78\x9e\xbd\x47\xea\xed\x62\xbd\x46\xb9\x5c\x07\x58\x06\xad\xce\x42\x5e\xc7\xd0\x9c\x8c\x01\xa4\xa7\x2e\xa0\xa8\xf1\x51\x6f\x34\xfe\x63\x12\x4a\x9b\x51\x2c\xc7\x76\x80\x77\x97\x80\x56\xaf\xc0\xbb\x4b\xcf\xad\xaf\x9d\xf2\x7a\x35\xdd\xcd\xc6\xbe\xf6\xe7\x7f\x64\xba\x3f\xff\xc3\x5c\x5c\x35\x6f\xd6\xbb\x55\xb3\x91\x2e\x7a\x1f\xec\xa5\x21\x7d\xdb\x28\x0b\x69\x4d\x62\xae\x33\xb0\x2b\xe8\x85\xfe\x66\x41\x3b\xcf\xa4\x53\xae\xe7\x75\x5e\x8d\x3e\x5f\xa7\xe3\x34\x14\xb7\x86\xa7\x36\x92\xb9\x4d\x21\xe7\x83\x52\xb8\x9c\x83\xcd\x83\x3c\xd3\x23\xf8\x21\xc0\x98\xe5\x36\xb7\x8e\x59\x6f\xa4\x67\x24\x69\x87\x8f\xcd\x2e\x2c\xe8\xb2\x0a\x76\x65\x87\xca\xfa\x1b\xbd\xf4\x0b\xc3\x69\x6f\xdb\x76\xe3\x32\xc9\xd9\x6c\x3c\xed\x61\xea\xb9\xc5\x41\x7d\x1b\x5f\xe0\xbe\x8d\x8f\x70\xdf\x46\xf0\x42\x97\xfa\x36\x50\xa4\x66\x42\xc6\x36\x13\xc9\x18\x97\xf8\x83\x78\x0b\x50\xcc\x88\x3a\x34\xd0\x5a\xb1\x37\x65\xd6\x53\x3f\x58\x68\xcf\x58\x7a\x68\x6a\xe7\xf1\x79\x9d\x7d\xe1\xc2\x79\x16\xc8\x46\x36\x70\x00\xb2\x81\x5a\xb4\xa3\x1c\xf5\x72\x03\x1a\x01\x59\xba\x7a\xca\x86\x06\x40\xb6\x4f\xca\x83\x02\x51\x70\xfe\x5a\x78\xa9\xec\x9b\xa6\x67\x6d\xdb\x37\xed\xfd\xd5\x3b\xf7\x75\x9d\x7f\xf4\xc3\x8b\x43\x56\xe4\x9f\xed\x35\xbd\x47\x12\xbd\x6a\xdb\xca\x85\xdf\xcf\x7f\x6a\x55\xc5\xe5\x15\xdd\xc1\x8f\xa7\xcb\x2f\x97\x5f\x68\x5b\xb9\x87\xe8\x13\x27\xb2\x4d\x45\x01\xdb\x64\x08\xd1\xcb\xd5\xf2\x10\xa4\xbe\x28\x9d\x8c\x92\xfd\xad\x6d\x8a\xce\x54\xa0\xbd\x00\xe4\xc0\xff\x17\xfa\xf0\x09\x19\xd8\x0a\xff\x94\x1d\x07\x4a\x4d\xc3\xea\x7a\xe1\xff\x9c\x00\x72\xcd\x1a\x27\x98\x08\xa6\x46\xc0\x35\x39\xf0\x69\xe9\xaf\x24\xbe\xcb\x47\xba\x6c\x3b\x97\x6b\x8c\x0f\xf9\x0e\xfe\x8e\xe2\xbc\x38\xf9\x4f\x14\x65\x90\x87\xfc\x08\xe2\x7c\x2f\x50\x31\x5e\x0b\x43\x5b\x42\x19\xfa\xb8\x05\x4c\xb4\x80\x08\x0b\x32\xfa\xf8\xf4\xdb\x50\x96\x6e\x28\x2b\x2b\x43\xc1\x43\x0e\x0e\x20\x10\x9d\x8e\x88\xce\x31\x91\xce\x0f\x02\x9d\xfb\x98\xce\xf7\x20\xdb\x57\x4f\xe9\x4e\xd3\xa6\x50\xff\x2f\xd1\x6f\x28\xf2\x9b\x6c\xf4\x9b\x7a\xae\x10\xfd\xe6\x87\x46\xb7\xf0\x9b\xb0\xc0\xd8\x09\x5e\x34\x6e\x2a\x1e\x3b\x15\x4c\x4c\x05\x11\xa9\x20\x95\xf2\x26\x80\xc8\x04\x90\x80\xc6\x6e\x32\x3e\x92\x61\x26\xfc\x94\x75\xb0\x59\xa4\x3e\x39\xcd\x6b\xa6\x28\x97\xc1\xe5\xdc\x59\xea\xd2\xa1\xd0\xc0\xc0\x90\x22\xe5\x17\x81\x9d\xe2\x29\x03\x29\x0c\x97\xea\x38\x83\xe2\x55\x52\x95\xdc\xec\x78\x8f\xa8\x49\x12\xc6\xce\x90\x2a\x95\x5f\x49\x78\x21\x07\xbe\x7e\xe7\x95\x0f\x33\xaa\x27\xac\x9c\x07\xb4\xf1\x57\xe3\xe9\xb7\x49\xa5\xf2\x90\x92\xd2\xb5\x8b\xd4\x57\xdf\xdd\xba\xaa\xdb\xa6\xd5\x9d\x8b\x16\x83\xd3\x37\x6e\x34\x36\x0a\x75\xb6\xb2\x03\xc6\x38\x7c\x15\x80\x41\x4e\x75\x69\xbc\x4b\xfd\x4a\x85\x9c\xa4\x4d\x5c\x1c\x95\x44\xe4\x47\x9e\x99\x25\xab\x93\x9e\x99\x4e\xad\xa6\x7e\x7b\xcc\x33\xc3\x03\xcf\xd0\xcb\xa8\x14\xe1\x19\x73\xd3\x67\x0e\xcb\x76\x48\xcf\xec\xf0\x3f\x63\x6b\xfa\xcc\x30\x59\x99\x34\xd6\x18\x2a\x99\xfa\x8c\x52\xd6\xa3\xa9\x26\x0f\xa5\x4b\xcf\x54\x88\xcf\xc8\xe8\xed\xe6\x7e\x48\x23\x32\x74\x6b\x2d\x0a\xf3\x0d\x58\xf2\x74\xe3\x16\x14\x93\x45\x20\x9d\xa3\xa3\xcc\x48\xeb\x27\x53\xc0\x04\xca\x79\xb3\x29\x44\x55\xce\x87\x87\x00\x46\x13\x02\x4c\xac\x29\xc4\x14\xa2\x63\xe5\x06\xd6\x50\x81\x8b\xc0\x70\xc6\xb0\x9c\xd7\x89\xd5\x1d\xa2\x51\xc2\x81\xaf\xe0\x34\x97\x97\x05\x1a\x61\x85\x0a\x31\xa9\xc2\xd4\x6d\x42\x4a\xd3\x4d\x8f\x87\xcf\x7f\x52\x47\xff\x40\x6f\x77\xc2\x63\x7d\x41\x37\x27\x3c\x3b\x10\xcc\x76\xf9\x3e\xfc\xae\xfb\x8c\xf7\x41\x38\xa8\x85\xc3\xb9\xdc\x2d\xb0\x68\x13\x4c\xd9\xc2\x9e\xb8\x0f\x27\xe2\x75\x36\x15\xa9\x93\x17\xb9\x81\xe8\x5d\xe2\xd0\x2a\x93\x53\xb3\xc1\x50\xb2\xfe\x48\xfd\x2b\x91\x67\x82\x38\x2f\xdf\x10\x59\x01\x83\x24\xab\x47\x9e\x99\x4e\xad\xfc\x5f\xcf\x48\xf3\x02\x8c\xcd\x9f\x29\x93\xe8\x8c\xa1\xbc\x44\xe6\x34\x30\xf9\x65\x2e\xd4\x7a\x12\x3a\xc9\x22\x3f\x9f\x3c\x32\x56\xf3\x67\xa6\x53\x9b\xfe\xd7\x33\x8f\xe5\x47\x78\xa6\x4c\xa2\xe3\x5f\x03\x12\x3f\xe2\x79\xe6\x66\x52\xab\x18\x4e\xa5\x7b\x91\xe9\xe6\xe8\x72\xde\xa1\xe3\x00\xae\x89\x06\x32\x99\x1d\xd7\xeb\x90\x2a\xbf\x47\x0a\x84\x3d\xfe\xb2\x1d\xd2\x9f\x2d\x56\x2a\x9b\xdc\x42\x99\x32\x49\xa2\x31\x6e\x5c\xad\x3c\x75\x99\x73\xd9\x34\x7f\xc1\x72\x5b\xf8\x69\x7f\x52\xae\x7c\xe1\xd2\xac\x01\xc0\x4d\xf7\xdb\x48\x97\x8a\x75\xcb\x74\x3f\xd8\x0d\x57\x2d\xcf\x3c\xb2\x1d\x76\xf2\xcb\xf3\x55\xd9\x4e\xc4\x7f\xaa\xb8\xce\x5b\x53\x0f\xf0\x3b\x06\xd6\xb9\x50\x0b\x49\xe4\xd0\x46\x94\xe7\xfb\xc2\x5e\x88\xfa\xfb\x67\xa6\x53\xeb\xfe\xd7\x33\x81\x7d\x17\xdd\xf4\x19\x61\xdf\xb5\x69\xba\xef\xe2\x9a\xd3\x29\x93\xc6\x1a\x83\x9e\x11\xf6\x5d\x8c\x28\x73\x40\xed\xa0\xfe\xcd\xb6\x62\xab\x70\x5d\xd6\x09\x39\x38\x41\x85\x91\x34\x33\xd2\xef\x0a\x60\x43\xe1\x87\x02\xec\x00\x43\xe1\xae\x4a\x30\x18\x0c\x1e\x0d\xf7\x80\x8a\x91\xf0\x19\x58\x0b\x7a\x80\xa1\xa0\x62\x14\x7c\x06\x94\x8f\x86\x7b\xe1\xae\xd1\x60\x08\xdc\x41\xea\xf0\x1b\xdf\x6e\xfc\x80\x4b\xe2\x26\xe1\x7a\x02\xe4\x9b\xb5\xf6\x3a\xec\xd1\x61\x31\x6c\x5c\xb8\x3a\xae\x9c\xd7\x1a\x38\x9a\xa5\x74\x6a\x96\x0a\x17\x0b\x01\xaf\xe1\x59\xbc\x66\xb4\x65\x09\xc1\x01\x39\x5f\x13\xd2\x3b\xa4\x50\x52\xcc\xfc\xe0\x92\xd1\x78\x20\xb6\x65\x9a\x6d\xe4\x30\x89\x06\xff\xfd\x68\xd8\xd3\x45\x27\x22\x71\xa9\xe4\x07\x23\x9e\x2e\x3c\xee\x26\xf5\xa3\xb4\x6f\x4e\xda\x16\x5c\x2f\xe9\x2b\x07\xf4\xd2\xb4\xad\xcb\x2e\x55\x99\x57\xd6\x76\xba\x50\x3a\x7b\x37\xa9\x9a\x7c\xb2\xb6\xd3\x8b\x03\xe7\x6c\x83\xd5\xf0\xe7\x55\xcc\x2e\x8f\xaf\x68\x25\xae\x9a\x84\xcf\x46\xab\xe8\xc3\xd5\x2f\x0b\xfb\x97\xd4\xf2\x11\xf9\xb7\x15\xe7\xf1\x0d\x61\x3d\x3b\x02\xb2\x6d\xfe\xcc\x74\x6a\xe9\xff\x7a\x26\xb0\x2f\xc2\x9b\x3f\x53\x26\xd1\x09\xec\x0b\xa7\xb4\x4f\x49\xcd\x1b\xa1\xd3\x5e\x1c\x6b\x83\x40\x47\x2b\xd2\x11\x6b\x3e\x97\x91\xbd\x63\x43\x36\x3d\x14\x98\x2a\x78\x99\xb1\x82\x07\x5e\xbd\x39\x1f\x89\x4f\x46\xe3\xcb\x7c\x19\xa1\x60\x90\x24\x87\x48\x43\x70\xac\x5b\x8e\xfc\x42\xb9\x54\x17\xeb\xaf\xec\xa7\x3b\xc3\xaf\x53\x71\x25\x74\x4b\xa0\xb9\xf5\xd1\x06\xf8\xe0\xc3\x55\x6b\x7e\x9f\x04\xa7\x1e\xae\x80\x90\xcb\xfd\xbe\xae\x76\x75\xe3\x1a\xf0\xc7\xa8\x89\xbe\xcb\xa5\x47\x85\xb3\x9e\xd8\xc6\xcf\xd9\x6a\x14\x23\xa6\x53\xc9\xde\x50\xa7\x3d\x22\xda\x5e\xc0\x2b\x92\x23\xad\x2c\x15\x4d\xb9\x22\x2c\xa4\x58\xc0\xea\x2f\x16\x10\x27\x5c\x98\x6f\xe9\x68\x8e\x14\xc8\x66\x66\x64\xe2\xf8\x5c\x3a\x6f\x16\x3a\x78\xe4\x38\x56\xd0\xa1\xe8\xdd\x46\x0a\x54\xe9\x73\x07\x2b\x5d\x9e\x0d\x5d\x2b\xe7\xe6\xf4\xca\xcd\x93\x59\x17\xe5\x75\x51\x30\x55\x43\xd7\x1f\x8e\xbc\x56\x7f\x3d\x19\x84\x7e\x7d\xf0\x0a\xe7\x5c\xfc\x44\xb6\x9c\xce\xec\xb5\x69\xd4\x55\x67\xea\x5e\x77\xcc\x9c\x81\x69\x03\xd2\x5a\x8f\xc8\xb1\x87\x4f\x19\xe4\x29\x4a\x75\x76\xea\xf5\xcc\xb3\x0d\x0c\xcb\x7c\xf1\xe5\xe2\xaa\xb4\xd5\xc3\xda\xe5\x44\x9b\xdd\x5d\x33\xc7\x3f\x55\x7e\x69\x34\x9e\x17\x52\x9b\xc6\xd5\x23\x99\x77\xc5\xf6\x88\xea\x52\x43\xe1\xdd\xd5\xd1\x80\x25\x2e\x7e\x9f\x1d\xf4\xfd\xf4\xde\x8f\x7e\x1f\xf4\x7b\x7a\xd9\x4f\xe4\xfb\x9c\xe0\xef\xa7\x71\x07\xa5\xef\x77\xfc\x97\x7c\xdf\xb9\xe9\xef\xe7\x48\xf4\xc7\xdc\xa7\xc8\xce\xf5\x1a\x84\x9d\x2b\xf1\x28\x53\x49\x34\xb6\xff\x57\x78\x26\xcb\xff\x0c\xda\x8f\x1f\xa0\x67\xee\x92\x1a\xbb\x0c\x2a\x87\xea\xef\x6d\xe9\x72\x45\x65\x23\x7f\xbd\x0d\xf2\x86\x0a\x78\xab\x26\xdb\x99\x4d\x9b\xd9\xec\x6c\x5d\x54\xa6\x03\x17\xdf\xc5\xc5\x44\xe9\xd9\x56\xba\x56\x05\xbc\x46\xa9\xc3\x68\x03\xfe\xd4\xb1\x3f\x65\x1c\x50\xb7\xf8\xef\x06\xd2\x57\x0a\xc4\xc0\xc2\x46\x72\x7c\x38\xeb\x42\x4a\xf0\x32\x82\x2a\xf0\xda\xe0\x4c\x2e\xa9\x5b\x32\x93\xf3\x2b\xb9\x96\x26\x15\x4c\xf8\x19\x7a\x97\xb5\xba\xe7\x38\xd7\xa2\x19\x0f\x66\x55\xa9\x6a\x6e\xdc\x56\x77\x05\x3d\x0f\x38\xda\xa4\xf7\x28\x0e\xdb\x97\x72\x76\xf5\x89\x16\x13\xf7\x34\x38\xd9\x87\xef\xf4\x2f\xdb\xe1\x30\xce\x29\x1f\x93\xc5\xc4\x17\x2e\x70\x83\xd1\xaa\x4e\xe0\x8f\xb2\x21\xd7\x06\xe7\xb7\x6c\xa4\xc6\xcf\xf9\xe6\xae\xa7\x03\xae\xc9\x5b\xea\xe9\xd4\xb6\xb0\xd4\xb0\x71\xed\xaa\x55\xf0\xd2\xc4\xb5\xa1\xf0\xe7\xc9\x17\x57\x22\x5f\xa0\xc7\x26\x7a\xdb\xb1\xad\xfd\x53\x87\x97\x61\xd9\x4d\x42\x36\x7a\x38\xdb\x07\xc9\x2e\x4f\xb4\xd1\x85\x44\xa6\xa4\x6e\x8b\xcc\x5b\xbe\x30\xef\xcf\x93\x79\x89\xf3\xcf\x0b\xfe\x7e\x50\xd0\xf7\xd3\x27\x3e\xfa\x7d\xd0\xef\xe9\x65\x72\xf2\x7d\x7c\xd3\xef\xe7\x48\xbf\x1f\x13\x22\xcc\x59\x42\xd0\xbc\x0a\x75\x3d\x98\xc6\xaf\x02\x0f\x17\x30\x0d\xa0\xf3\xd3\xc0\xdf\xf7\x0b\xfa\x7e\x7a\xe5\xa3\xdf\xe7\x04\xbe\xa7\x97\x29\xc9\xf7\xfa\xe0\xef\x7b\x13\x1e\x84\xdf\x8f\x49\xa4\x88\xc6\x31\x48\xeb\x86\xa6\x86\x22\x3e\xe7\x70\xef\xa1\x58\x21\x99\xf2\x78\xc3\x29\x77\x01\x4f\x23\x41\x51\x28\x9c\x46\xb1\x2a\x67\xd5\x58\x13\xd0\xf2\xb1\x6a\x34\x4a\x02\xdf\xd0\x24\x15\xe9\x21\x27\x41\xb6\xb8\x78\x0e\xa9\xf2\x78\x8f\xd5\x16\x8b\xd4\xb8\x01\x57\x6f\xf8\x4b\xb5\x9a\x34\x7c\xd2\xf4\xd9\x15\xc5\xad\x27\xc2\xaf\xa2\x7e\x1c\x52\x75\xa7\x67\x2f\xe0\x8a\xfa\xf2\xb5\xbe\xb5\x5f\x6f\xbb\xf2\x7a\xff\xcd\xef\x81\x09\x55\x0b\x96\xec\x1b\x38\x75\xea\x88\x75\x43\x32\x98\xb7\xda\xbd\x3c\xab\x6a\xc2\xe0\xd2\x2e\xb1\x9d\xa6\x8c\x1b\xf4\x29\x3c\xbf\x13\xde\x7a\x75\xf4\xe9\xe3\x33\x01\xfd\x5c\x29\xdc\x5e\x35\x7e\x66\xe3\x9c\x59\x53\xba\xae\xfe\x18\xcb\xb1\x80\xe8\x44\xbc\xc7\x0a\x85\x3d\x26\xc8\x21\xc1\x2f\x07\x52\x7f\x42\xe4\x54\x24\xc8\xf9\x1c\x99\xab\xe8\xbf\xfb\x7e\xfa\x88\x7f\xfc\x1e\xe9\x77\xf2\x7d\x4c\xf0\xf7\xf3\xc8\xf8\xc2\xf7\x3b\xa8\xa6\x6b\x41\xf8\xfd\x1c\x89\x3e\x6e\x0b\xc5\x6b\x21\x36\xb0\x7f\xa9\xa9\xd4\xa7\xec\x00\x76\x1a\xc9\x47\xab\xa8\x2e\xde\x16\x21\x8a\xa3\x3c\x15\x02\x34\x4c\x08\xa0\x8e\xf2\x68\x3f\xe9\xc0\x13\xa0\x1c\x1c\x03\x3f\x83\x46\x20\xd3\x30\x20\x04\x70\x38\xf9\x83\xf1\x1f\xc4\xe6\x6f\x92\xf2\xa1\xa4\x74\x54\xba\x87\xe4\x7a\xf0\x7f\x69\x43\x9d\xef\x45\xe6\x73\xdf\xb9\x3a\xe6\xe2\xe9\xd3\x70\xcf\xfa\xf5\x70\xc1\xe9\xd3\x78\x5c\x37\xe2\xad\x8e\xd4\x74\xb8\xb1\xee\xf0\xba\x1c\x31\xf6\x58\x36\xde\xa9\x8e\x47\x0b\x81\x33\x68\x59\x35\x85\x5c\x6b\x3d\xe5\x2c\xe0\x51\xdc\x68\xc5\xc7\x02\x42\xe3\x93\xe1\x71\xd6\x9c\x54\xe7\x89\xd6\x9c\x14\xf1\x08\xe6\x9c\xe6\x04\x6b\x8e\x74\xc1\x6f\xaf\x8d\x1d\x9c\x33\x2a\x79\xc0\xbe\xaf\x37\xde\x1b\x55\xe2\x1d\xd2\xa2\xdf\x81\x1f\x40\x0b\xce\xf7\x74\xbb\xa7\xc6\x6e\x1a\xdb\xce\x37\x52\x46\x8f\xcf\xda\x34\x6a\xd3\xd8\xf6\xe6\xb1\x03\xba\x96\xf7\x9b\x53\x0d\xdc\xb7\x2b\x87\x17\x75\x1d\x58\x38\x73\x31\x7c\xf7\xed\x31\xf4\xc7\x11\x09\xbe\xcb\xe5\x85\x47\x1a\xee\x27\x44\xd3\x5e\xbe\xb0\xee\x77\xbc\x06\x48\x1d\x04\x99\xa3\x12\x61\x8e\xf7\x90\x35\x10\xeb\x9f\x83\xe6\xdf\x4f\x1f\xf8\x8f\xdf\x8b\x73\x0c\xe2\x9a\x7e\x3f\x47\xfa\xbd\x30\x87\x34\x88\x0f\xec\x67\xe1\xdc\x9f\xd0\x18\x24\x8c\x31\x96\xd0\x08\x27\x8f\xf8\xeb\x90\x90\xed\xd4\x22\x5b\x19\xef\x35\x47\x52\x2e\x87\x23\x3a\xd4\x18\xaa\x2a\xe0\x43\xad\x46\x06\x57\x24\x3d\x52\xd3\x0a\x9a\x16\x1c\x01\x7f\x21\x92\x5b\x2c\x50\x02\x1e\x46\xce\xec\x0a\x2a\x38\x82\x36\xb1\x0a\x09\xce\x14\x6a\x93\x40\x55\x7d\x51\x14\xfd\x75\x70\xc5\x11\x70\xfa\x2b\x91\x48\x75\x92\x7c\x1a\xe4\x77\x48\xfc\xcf\x91\xf8\x1f\xc3\x09\xef\xe8\x0a\x7a\x47\x21\x7e\x1b\x2c\xc5\x81\x2b\xa9\x0c\xa0\xc2\xab\x5d\x17\xf0\x75\x04\x9b\x56\x2c\xd9\xab\x95\x1f\x92\xfd\x90\x2d\xca\x92\xd0\x58\x2c\x3b\x28\xd1\xd8\x2a\xfa\xd8\xb4\xb6\x29\x8d\x9c\x20\xbb\xba\xf5\x47\x42\x23\x4b\xa2\x01\x2b\x70\x8f\xa9\x40\x43\x8f\x4b\x1c\x6f\x52\x2a\xfc\x3b\xd8\x0f\xd7\x9a\x0b\xbf\x23\x9f\x4f\x96\xf4\xfd\x8b\xc4\xb7\x8a\x13\x7d\xab\x93\x82\x6f\x15\x19\x18\x93\xd4\x46\x93\x31\xf3\x84\xf9\x1b\x49\xe6\x2f\x26\x58\xa7\xbf\x48\xf8\x8e\x13\xfd\xbc\xae\x42\x6c\xe0\xfe\x5b\x1a\xfe\x75\x14\xdb\x94\xc6\x48\x89\xc6\x36\xe4\xeb\x6d\xc3\x4f\xb8\x9a\xd3\x78\x5d\xa2\xb1\xcd\x4c\x68\x44\xfd\x1d\x1f\xcb\xa9\x4e\x02\x1f\xe1\x7f\xcf\xc7\xf2\x06\x42\x23\xd2\x4f\x83\xf4\x82\x12\x1a\xf1\x22\x0d\xa3\x30\x07\x56\xbf\xaf\xc9\x50\xb2\xc6\xaf\xb8\x27\x49\xad\x6b\x02\xd5\x8a\x4a\xf1\x86\x59\x2d\x49\x89\x0b\x0d\x54\x98\x49\xcb\xa8\x18\x55\x6c\x01\xaf\xd2\x33\xce\xa6\xa5\xd8\x36\xb4\x6c\xed\xaf\x7b\x82\xaa\xb1\xfd\x15\xbb\xcd\xca\xb1\xfd\x60\x24\x34\xae\xde\x91\x33\x74\x41\xee\x96\x21\xf3\x6b\x7a\x2d\x3e\x5e\x39\x74\x6a\x50\x4d\xf6\xd8\xdc\xfc\xae\x0b\x86\xb7\x1d\x32\x60\xd0\xa2\x01\xcc\x54\xf9\xb2\x57\xe4\x9f\x1f\x1d\x5d\x7e\xf8\xf0\x7c\x90\xf1\xd9\xf4\xe0\xda\xec\x55\x95\x15\xe5\x27\xbf\x19\x38\x63\xc5\x01\xb8\x85\xbe\xe3\x06\x31\xb1\xf0\x5f\xa2\x0d\x44\xb1\xa6\x51\x46\xad\x27\xf6\x6e\x02\x7a\xa7\x14\xf4\x4e\x91\xc8\x47\xef\xed\x75\x52\xa1\x8e\xd0\x42\xde\xa5\x73\x44\x38\x52\x1c\x8c\x8d\x71\x38\xc2\x29\x8b\xdc\xa8\x32\x26\xa3\xdd\x88\x8b\xe1\x35\x0a\x75\xbe\x51\xa7\x8a\x41\xef\x6a\x65\x2d\x62\x8d\x6f\x92\x7f\x83\x66\x05\xc5\xa4\x40\x7c\xbb\xe8\xe6\x55\xe8\xf8\x04\xd8\x23\xf7\xc8\xc5\x43\x29\xb1\xad\x9b\x66\xd7\x5f\xc0\x6f\xc8\xe1\x5a\xf4\x2d\xb6\x71\x60\x39\xae\x45\xe7\xd2\xe0\xdb\x76\x90\xec\xaa\x77\x55\xdb\x1b\xac\xe5\xc3\x07\xaf\x1c\x9a\x3d\x76\xfa\xb4\xcd\x03\xd9\xc3\x0d\x1e\xf2\x9e\xa3\xcb\xf7\xd6\xf5\x9f\x47\x27\xf5\x1f\x6a\x07\xf6\xea\x1d\x3b\xaa\x1b\xf6\x54\x8d\x29\xac\x03\x54\xff\x19\x53\xb7\xc2\xb3\x81\x9c\xc0\x60\x29\x6f\xb0\x92\xca\x23\x7b\x14\x68\x02\xeb\x43\xf0\x4f\x8a\x25\xff\x65\x25\x4d\xf6\x57\x54\xf0\xfa\x78\x87\xac\x8f\x84\x26\x7b\x14\xa8\x9b\xd3\x08\xf8\x40\x5b\x59\x42\xc3\xdd\x94\xc6\x48\x89\xc6\x36\xca\x25\xac\x75\x5d\x73\x1a\x77\x25\x1a\xdb\x18\x59\x13\xdb\x9a\x85\xf6\xf3\x3b\x64\x9f\x27\x88\xfb\xb9\xa7\xf0\x3b\xf4\x79\x09\xd9\xe7\xf9\xb8\x8a\x84\xae\xed\x48\x05\xe5\x43\x02\x7c\x2f\xf7\xf3\xdd\xec\xdd\xcb\x82\xf8\x5e\xfe\x67\xd3\x77\x27\x3d\xc0\x84\x46\x0b\x71\x9f\x8b\x34\x62\x02\x34\x48\x5d\x3b\xa1\xd1\x43\xd8\xe7\x7f\x34\xd1\x4f\x8f\xd0\xd8\x4a\x79\x04\x1a\xae\xbf\xa7\xb1\x55\xa0\xe1\x69\x4a\x63\xa4\x44\x63\x1b\x7a\xa7\x6d\xcd\xf4\x8d\x40\xe3\x75\x89\xc6\x36\x81\x46\x86\x44\x03\xf2\xb8\x9f\x59\xa0\xa1\x97\x85\x7c\x49\x51\x81\xdf\xc9\x28\xff\xef\x42\xbe\x69\x6c\xfa\x3b\x21\x0f\x82\xf9\x4f\x92\x62\xda\x07\xc1\xb9\x1e\xb4\x97\xb0\xdf\x35\x42\x76\x90\x0a\xa5\xa2\xa8\xce\xde\x44\xb7\xb3\x86\x8f\x70\xaf\x2e\x75\x44\x70\x56\xad\x8a\x65\xe5\x6a\xb9\xa9\x80\xbf\x24\x07\x72\xaf\x35\x22\x5f\x2e\xd7\xd8\x42\x19\xb5\x05\xe0\xf6\xe2\x36\x39\x36\xdc\xb3\x5c\xe6\xd7\x18\x1e\x72\x48\x85\x33\xa5\x62\x0b\x4c\xd3\x9a\x79\x79\x74\x7c\x34\x17\x9d\x19\xeb\x01\xfd\x4f\xc5\x26\x85\x33\x35\x3f\x82\x48\xcd\xc2\x53\x73\x54\xfd\x07\xcd\x7b\x29\x62\x42\x3d\x6b\x61\x47\x5f\xa6\xa1\xaf\x92\x05\xc9\x7b\xb9\xdc\x8b\x9f\x0c\xbf\x05\x1b\xdb\x75\xf2\x8d\xa5\xe7\xa4\xa7\x0c\x28\x7c\x61\x9b\xef\x06\x77\xd6\xbc\x6a\x95\xf9\xbe\x3f\x86\xe6\x3a\xa1\x18\xda\x84\xbc\x9e\x5c\x6f\xbc\x46\x6b\xd3\x96\xf3\x66\x9b\xd2\x62\x65\x0c\x94\xa1\x82\x67\x58\x39\x83\x8b\x5c\x29\xa0\xd6\xe9\x19\x95\x91\x9c\x74\x30\x18\x65\xcf\x5f\xf3\x21\x41\x07\x7a\x9a\x16\x0b\x78\xe4\xd1\x12\x7c\x20\x81\xc6\x0a\x8b\xbb\x14\x47\x2b\xd1\xbf\x76\x39\x77\x5d\xbd\x44\x7a\xb2\xaf\xee\x72\x32\xee\x24\xdf\xef\x49\xec\xa2\x97\xd1\x3f\x1b\x1a\x4c\xb8\x37\x9b\xf9\x71\x03\xac\xf9\xe4\x13\xa9\x5e\xbb\x0b\xd1\x51\xb9\x5e\x57\x88\xca\xa1\xb7\x70\xce\x48\x67\x21\x4f\xeb\x22\x23\x22\x53\x22\x91\x9a\x8a\x8c\x54\x51\x2a\x1b\xd2\x49\x48\x45\xbd\x80\x34\x94\x4a\x27\xf4\x1f\x34\x4b\x94\x49\xdd\x08\xb8\x1a\xe5\x6f\x84\x8b\x13\x69\x60\xd2\x29\x17\x48\xb2\xc3\x7b\x1a\x7d\x12\x53\xf3\x03\x70\x6b\x9e\x3c\xb5\x48\x28\xf7\x9e\x5a\xff\xcd\x12\xfb\x12\xee\xf5\x1d\xd5\x5d\xfa\x1f\xbf\x45\xba\x13\x7a\xd3\x5b\xc5\x82\xef\xe7\xd8\xc3\xd5\x62\xce\xef\x28\xc9\x99\x25\x8b\x39\xaa\x54\x61\xad\x58\x02\xeb\x14\xeb\x61\xc1\x47\xfe\x35\xc8\x47\x06\x26\xff\x7a\x13\xf2\x86\x83\x25\x1a\x7e\xbf\x22\x78\xdf\x62\x1a\x91\x44\x67\x09\x34\x56\x86\x10\x1a\xaa\xa6\x34\x02\xf9\xc9\xad\xfe\x3c\x8c\xba\x29\x8d\x91\x41\x31\xd3\x56\xc1\xb6\x2a\x25\x1a\x48\xaf\xec\x24\xfa\x26\x59\xd0\x2b\x1a\x61\xbf\xc4\xa1\xcf\x43\xc9\x3e\xeb\x25\x7c\xde\x96\x0a\xca\x77\x8e\x94\xc6\x7c\x44\xc7\xa1\xf9\x24\x71\x1e\xa9\xc1\xf4\xf7\x21\x3c\xda\xb7\xd1\xa4\x0f\xa1\x59\xbf\x86\xd0\xab\x21\xd4\xb2\xff\xd9\xf8\x03\x17\x45\xb0\x3c\x6d\x54\x0b\x6f\xa8\x8e\x2d\xe7\x29\xb3\xde\x4c\x6b\x18\xb3\x59\x67\x52\xe1\x16\x47\x15\x83\xf3\x3f\x42\x6b\xb2\xc7\x1f\x0c\x78\x40\x74\xac\xbf\x5b\x83\x18\x28\xa1\xf3\x9e\x6a\xbc\x04\xff\xba\x44\x9f\xa9\x9c\xe3\xd8\x0c\xff\xe3\x02\xb7\xea\x13\xfe\xb8\xb0\x6f\xeb\xe5\x9e\x18\x79\x63\xd9\xda\x95\xa4\xe7\xfe\xee\x57\x07\x2f\x29\x23\x6c\x13\x27\x51\x2c\x55\x2d\xd6\x7f\xe2\x38\xc5\x4a\xd9\x91\x57\xe0\xd0\xa0\x5d\xae\x71\xd8\x58\x8e\x2d\xe6\x43\x39\x8a\x56\x5a\x19\xc6\x02\x42\x14\xf8\xa0\x30\xc7\x86\xb7\x7a\x70\x73\x91\x07\x2d\x39\xb4\x53\x38\xe4\x0c\xb0\xd1\x81\x2e\x12\x8c\xc2\xd6\xff\xe4\xdd\xfa\xaf\x63\xaf\xc7\x82\xba\x7a\xdc\x3a\x72\x5b\x6a\x27\xf9\x01\x7d\xc8\x66\x3f\xbc\xc6\xa9\x2f\x5f\xbe\x8b\x3b\x48\x84\x76\x12\x2e\xf6\xf2\x65\x3c\x07\x18\x73\xe0\x63\xa2\xab\x5a\x8a\xba\xaa\x4e\x58\x7f\x61\x81\xb3\x89\x2b\x88\xef\x1d\x78\xde\x43\xbe\x15\xf4\xb5\x10\x4b\xdb\x02\x76\x86\xc7\x78\x02\x88\x46\xab\x26\x7a\xb2\x1a\xe9\xcf\xd3\x64\xde\xfb\x04\x3e\xf7\xf7\xae\x90\xba\x61\x9b\x57\xad\xd0\xd1\x40\xce\x70\x3a\xe4\x20\x60\x17\x21\xc7\x96\x95\x23\xb6\xab\x98\xa4\x76\x95\x5f\x36\xf7\xae\xbf\x5b\x5f\x49\x77\x11\xba\x55\x7e\x1a\x0a\xa7\xb2\xd9\xbe\xaf\x68\xbb\xd0\xad\x82\xc7\x22\x98\x03\xe4\x3d\x52\x04\x1f\xb5\xf1\x0d\xe1\x3d\x54\x01\x9d\x8b\x7b\x5a\x76\x20\x9d\xab\x40\xc2\x8d\xf7\x9a\xd4\x0b\x95\x0a\x2f\x59\x52\xcc\xa3\xad\x40\xf6\x50\xfd\x27\xf6\x5b\x4d\xbb\x81\xc8\x71\xb3\xd4\xe7\x72\x9b\xf4\xb9\x9c\x63\x81\xe1\x15\x0e\x1e\xc0\xfd\x2e\x89\x35\x15\xe6\xfb\xce\xaf\x05\x7e\xd0\xbb\x03\x22\x93\x14\xe1\xdd\x95\x02\x9f\x4e\xf4\xb9\x8e\xc8\xe4\x89\x26\xb2\xc2\xfc\x9f\xf1\x3f\x6f\x90\x87\x7c\x49\xe7\x72\x07\x28\xf9\x09\x10\xc2\xf8\xcf\xe6\xf0\xbd\xf3\x5c\x0f\xe1\xb7\xb7\x91\x3d\x0f\xf9\x1a\xec\x0d\xbc\xbb\x34\x16\xde\x47\x36\x5f\x5f\x3c\x16\xa9\x81\xf4\x8f\x85\x3e\x07\x0e\x5f\x5f\x24\xff\x36\x22\x3e\x83\x06\x47\x52\x72\x56\x09\x58\x3a\x04\xfd\xa1\x64\x1c\x43\xa9\x02\x60\x0d\x82\xba\x26\xc8\x99\x1e\x13\x8a\x51\xd1\x7c\xc4\xda\x38\x8c\xde\xc0\x2f\x6a\x71\x63\xed\xa5\x39\xa0\x53\x2c\x9c\xd3\x87\xde\xe5\x02\x37\x3b\xcc\xaa\xa0\x3f\xf5\x2d\xd9\x3c\xeb\x2c\x9c\x50\xeb\xef\x1f\xca\x45\x6b\xdd\x40\xb5\xf1\xda\x29\x46\xa9\x61\x55\x00\xfd\x31\xc8\x0d\xda\x02\xde\x40\x61\xd4\x8c\x02\x5e\x1e\x54\x45\x2d\xa6\x46\xc8\x70\x20\x93\x8c\x83\x05\x2f\x8f\x8f\x25\xfb\x2e\xfa\xaf\x04\xf8\x52\x95\x5f\xf6\xe5\xff\x49\x02\x59\xe3\xe1\x11\x07\x2d\x67\xa6\x2e\x9a\xbc\xd7\x77\xb4\xa6\x06\xfc\x38\x67\xd2\x33\x74\x4a\x4d\xc0\x97\x11\x6c\x70\xaa\x18\xb3\x1c\x12\xd6\x43\xe0\xec\x8e\xd8\x8a\xe9\x44\x9f\x15\x8a\xcf\xac\xa0\x82\xa2\x16\x81\x0e\x9a\xaf\x57\x89\x6c\x53\x85\xf9\xfa\xb7\x40\xbf\x00\x7d\xde\x83\xf8\x50\x85\xc2\xe7\x5f\x3e\x76\x5c\xe4\x43\x65\x08\xe3\xea\x9a\x8e\x3b\x5c\x1a\x17\xf9\x50\x54\xd3\xf8\x62\x18\xfa\xfe\x24\x97\x87\xbf\x1f\x4d\xd6\x42\x63\x17\xae\x0e\xaf\x05\xb7\xb8\x16\xb0\x9d\x43\xfb\xf6\x2c\x37\x10\x45\x20\xad\xbc\x0e\x67\x64\x24\x32\xbd\x91\x6c\x18\x63\x35\x52\x48\x8d\x75\xe5\xfa\x72\xc3\xd1\x92\x0e\xc6\x0c\xf1\x37\xe9\x73\x51\xad\x80\x98\x4f\xce\x0c\x36\x65\x39\x80\x34\xeb\x64\xb8\x89\x95\x53\x02\x7a\x63\x97\xb2\x4e\xae\x4d\x91\x1d\x5b\x3d\x31\xa9\x45\xa1\x72\x70\xe5\xaa\x0f\x22\x8e\xd6\x7f\x10\xa6\xc1\xdd\x4b\x4f\x03\x1b\x68\xa5\x19\x90\xfd\x8e\x39\xa2\x7d\x87\xe1\xed\xe3\x2f\x7d\x02\x76\xb7\x69\x31\x80\x3f\xb5\xbd\x61\x11\x5b\xbe\xb6\x44\x36\xa7\xed\x2d\xf8\xb0\xad\x17\x76\x82\x77\x61\x03\xe1\x17\xe9\x10\xdc\x47\x15\x8f\x3b\x74\x1c\x11\x05\xbc\xc3\xa1\x33\x71\x26\xaa\x80\x37\xe9\x55\x3a\x8e\x6c\x7d\xc1\x02\x0b\x27\xf9\x8f\x6d\xa4\xc2\xca\x37\x3e\xd3\xe6\xe7\x9c\xfe\xe0\x71\x3d\x55\xfb\x9d\x1b\x66\xf5\x4a\x75\x74\xc8\xcb\x35\xd7\xaa\x06\x30\x57\x1f\xd3\x5c\xd5\x70\x70\xcb\x2a\xc5\x2a\x59\xf7\x51\x4c\x14\xb6\xc6\x81\x73\xa0\xc1\xd2\x59\x91\x14\x9b\x37\x8b\x2d\xcb\x88\x0d\x2d\x0a\xf6\xfb\x23\xfc\xf3\x26\xd0\x38\x28\xd1\x90\x62\x73\x67\x73\x1a\x81\x7c\xd8\x56\x21\xdf\xe5\x0a\xa2\xc1\x45\x05\x9d\x6b\xed\x04\x83\x90\x1d\x26\xd9\x4f\xe9\xac\x03\xd1\xe0\x64\x12\x0d\xfc\x8c\x57\xcc\x8a\x25\x1a\xfc\xe7\x84\x86\xc6\x87\x5c\x16\xd7\x13\xd9\x99\x28\xaa\x87\x37\x51\x6f\x2a\xe7\x57\xeb\xc1\x6c\x3d\xd0\x61\xc8\x2d\xbd\x5e\x4d\x85\xdb\x75\x6a\x5d\x39\xaf\x54\xaa\x99\x30\x9b\x19\x23\xf3\xd0\x34\x41\xbd\x48\x11\x8f\x81\x05\xc0\x2d\x29\x9f\x5d\x86\x6d\xa1\x5b\x28\xd3\x12\x4e\x9e\x02\x07\xc1\xb1\x6d\x32\x4d\xfe\xd6\x29\xf0\xdf\xf6\xf1\xaf\x5e\x18\xb2\xfb\xbb\x3d\xed\x52\xe9\x56\x4e\x38\xa5\x3f\x98\xe8\x84\xeb\x4a\xc0\x69\x97\xaf\x7f\x37\xd7\x1b\x31\x1d\x9f\x7a\x71\xe2\x74\xee\xe6\x9d\x9d\x60\x13\xa0\x17\xc8\xb6\xc0\xfc\x4d\x30\x6b\xcb\x6a\x19\xeb\x96\xbd\x02\x87\xee\xde\x5e\x83\xe3\x67\x1a\xc9\xe9\x0d\xb4\x5e\x30\x96\x71\x3a\x7a\x83\x78\xb9\x9c\x4a\x6c\x8d\xbb\x83\x5b\x3b\x5b\xd3\x66\xb6\x75\x6b\xad\xb5\x65\xb4\x35\xba\x80\xb7\x87\x5a\xf5\x6c\xa2\x36\xb1\x80\x57\x2b\xb5\x7f\x9b\x8d\x6f\xd2\x2d\xec\xcf\xc3\xc7\x07\xf5\xc5\x4a\xb9\xf7\x00\x2e\x58\x86\x31\x90\x7e\x7f\xc9\x3a\xa5\x73\xb9\x73\xd1\x94\x2f\x5f\x68\x39\xfd\x4c\xd5\x82\x5e\xb3\xf7\x55\xbe\xd8\x72\xc6\xd1\x1f\x9c\xac\xef\xa9\xec\x76\x7d\x67\xf4\xad\xe2\x67\x14\x82\x45\xdd\xa7\xbb\x41\x57\x75\x26\xf8\x63\x42\xff\xcb\x24\xe7\x7e\xfa\xf4\xee\xfd\x0b\x40\xcf\x4f\xaa\x9e\x7f\x1e\xbe\x52\xb5\x2e\x14\xb8\x06\xf7\x7f\x1e\xae\x9d\x7e\xf9\x02\x98\x03\x22\x8f\x6c\xef\xdf\x61\xf0\x00\xbf\xde\xb8\x44\xd6\x4e\xba\xa8\x8b\x66\x3e\xb2\x76\x48\x0f\x19\x99\xf7\x7e\x42\x8e\x85\x27\x7a\xc3\x19\x64\x87\x31\xa6\x89\x40\x03\xeb\x24\x9f\xa0\x93\xf4\xe8\xf3\x05\x44\x57\xf5\xc3\x76\x20\xe4\x4b\x78\x9f\x7a\xcc\x98\x48\x0f\x85\x0b\x63\x86\xfd\xed\x98\xf4\x72\xc1\xe7\x0b\xf3\x8f\x49\x70\x4c\x08\x8d\x0c\x91\x6f\xd1\x7f\x48\x6f\x7a\x7e\x97\x4b\x68\xf4\x17\xf8\xee\x4f\x68\x78\xfe\x86\x06\xf2\x41\xd2\x04\x1a\x19\x7f\x4b\x83\x5e\xa6\x23\x34\xd2\x24\x1a\xb0\x2b\xc6\x53\x11\x68\x90\xb3\x8a\x5e\xc2\xef\xd0\xe7\xb9\x6c\x4f\xe1\x77\xe4\xf3\xfe\xe4\x73\x61\xcc\x3a\x69\xcc\xe5\x7e\x7f\x37\xb5\xe9\x98\xa3\x83\xc6\x5c\xce\x91\x31\x53\xfc\x63\xbe\x86\xfc\x1e\x27\x91\x77\xa6\x20\xef\xcf\x89\xbc\x81\x1a\xc9\xdb\xc3\xf5\x45\x9f\x0f\x10\x3e\xe7\x84\x79\x20\xf8\x29\xe4\x3d\x33\x9b\xc6\xd7\x8a\xc0\x98\x27\x1b\xef\x73\x73\x89\xcd\x1e\x70\x00\xeb\xfe\xaf\x01\xbe\xe2\x1a\xe9\xfe\x70\x4a\xd2\xfd\x7e\x1c\x16\x1d\x95\xe8\xb5\x50\x2a\x0d\xb2\xd9\xac\x5c\x29\x47\xee\xab\x52\xc9\x69\x18\x19\x81\x2c\xca\x69\x0a\x61\x0e\x18\x21\xbe\x22\x47\xff\x04\xa3\xa5\xf8\x7e\xf8\xfd\x59\x17\x67\xa1\x7f\x17\xfb\xb1\x5a\x60\xc9\x46\xdf\x06\x7a\xdc\x46\x50\x57\x8b\xf1\xbc\xae\x36\xde\x67\x3b\x70\x7d\x51\x2c\x95\xe9\x0d\xa7\x8d\x16\x63\x01\x1f\x69\xb1\xa8\x23\xac\x61\xd6\x02\x3e\x3c\xcc\xe1\x08\xd3\xa9\xe5\x81\xd6\x7c\x7f\xa7\x9e\xd1\xdf\x3c\x81\x46\x95\xbb\x75\x20\xb8\x53\x2f\x43\xc4\x86\xf7\xb7\xf1\x31\xdf\xda\x61\x41\x72\xa0\x61\x8f\x49\xaf\xb3\xd7\x65\xd5\x05\x9a\xf9\xb2\xe8\x65\x4b\x3e\xf7\xb7\xee\x19\xe2\x80\x6e\x09\x88\x15\x3a\xfa\xe0\x87\x81\xb3\xe1\x9d\xd2\xf9\xb1\x14\x3f\x45\x04\x64\x2a\xe4\x9f\x0f\x4a\xf9\xe9\x1d\x80\xcc\x63\xa2\x7f\x1e\x05\x1a\x83\x25\x1a\x52\xfc\x64\x6b\x4e\xa3\x58\xa2\x21\xe8\x7e\xe0\x6e\x4a\xe3\xa0\x44\x43\xca\xf9\x58\x9b\xd3\x08\xe4\xc9\xb7\x36\xb3\xfb\xcd\x69\x6c\x47\xda\x6f\x27\x95\x74\x82\x06\x56\x5c\xa4\x1a\x16\x96\x8f\xff\xeb\xd5\x5b\x6d\xf9\xc7\xad\xe0\x98\x15\xb4\xb6\x82\x48\x2b\xb0\x52\xb8\xee\xaa\x2c\x49\x38\x0e\xf1\x8f\x43\xce\x3c\x85\x71\xb6\x8b\xf9\xf6\xc8\xa0\xf3\x33\x34\x16\xd7\x2a\x68\xac\x9d\xa0\x12\xf1\x8b\x9f\x72\x4b\x76\x06\xd1\xe1\x58\x89\x5f\xfc\x4c\x47\x91\x52\x92\xc1\xff\xcc\x04\x14\xdb\x7d\x40\xf6\x40\x5b\x21\xb6\x6b\x27\xf2\x80\x3e\x5f\xcc\x66\x0b\xbf\x25\xb9\x27\x37\xf9\x9c\xe0\xeb\x90\x71\xb3\xc5\xbd\x9e\xf4\x48\x6e\x87\xf4\x33\x92\x71\x07\x0a\x7b\x5d\xc8\xbf\x4a\x36\x52\x38\xeb\x3f\xe8\x3f\xeb\x0f\xd0\x08\xf8\x58\xcd\xcf\x13\xfc\x34\x9c\x4d\x69\x94\x49\xf5\x02\x63\x50\xfc\x23\xd4\x14\xe8\xa5\x7a\xab\x7f\x61\x2c\x1c\x32\x4e\x07\xa9\xae\xa7\xb9\x2f\x47\x7a\x04\xc9\x38\x65\x82\x6e\xeb\xd7\xe4\x9c\x51\xa4\x31\xd2\x4f\x03\xf9\xe6\x49\x42\x8c\xab\x69\x4e\xe3\x75\x3f\x0d\x7a\x9b\x8f\xd0\xd0\x34\xa5\x51\x27\xd1\x58\x8e\x34\xf7\x6f\xc1\xb1\xcd\xa3\x7c\xd0\xcb\x41\x50\x7c\x8f\xeb\x34\x45\x0c\x0b\x1d\xe5\xac\xd7\xa9\x29\x4e\x7d\x06\xd8\x5f\xe0\x69\x0e\x6d\x73\xd2\xaf\xe9\x2f\x36\x70\x47\x9b\x82\xb0\x2b\x64\x72\xf0\x61\xfd\xbb\x01\xc4\x8a\x8d\x8b\x1d\x6c\xb1\x88\x53\x31\x6e\x59\x30\x6e\x4b\x24\x8a\xfd\xba\x7b\x13\x2c\x1a\xad\xa6\x90\x37\x6a\x71\x27\x9c\x56\x6b\xd7\xd3\x4c\xa8\x8d\xb1\x29\xec\xf6\x18\x64\xa8\xf5\x7a\x4a\x61\xa1\x92\x1e\xed\x19\xc7\xc5\x93\x42\xb3\x82\xff\xc2\x05\x8c\xed\xc2\xc8\xa3\x91\xa3\x87\xfb\xad\x48\x0e\x46\xf6\x8f\x10\x2f\x9c\x46\xad\x04\x47\x43\x12\x2f\x2d\xb0\xcf\x77\xd6\x3b\x41\x1b\x3b\xbc\xed\x74\x0b\x68\x2f\x6d\x61\xe3\x86\xf2\xa1\x0b\xea\xca\xc7\x4d\x99\xbe\x79\x90\xf9\x8c\x3d\xb3\x95\x9b\x0d\xbb\xc6\xbc\x5b\xfd\xf4\xd3\xd5\x9b\xb6\x5c\x87\x07\x07\xcf\xf2\x23\xbe\xec\x82\x17\x97\xcc\xa9\xda\x01\xfa\x20\x1f\xa4\x9d\x88\x97\x69\xa3\x5c\xc8\x6f\x4d\xf7\x3a\x2c\x31\x8e\x18\x47\x39\x1f\xa3\x8c\x51\xb2\xba\x68\x4e\xc7\x55\xf0\x3a\x86\x0d\x47\xea\xd7\x18\x40\xde\x11\x2b\xe7\xfc\xe5\xae\x66\x36\x11\x98\xa2\x64\x16\x9b\x3c\x1e\x97\xb7\x63\xf7\x1a\x5f\x35\x20\x27\xf8\x6a\x91\xfe\x72\x92\x0c\xb6\x12\x5e\x80\x3f\xc0\xd5\xdf\x0d\xec\x87\xf6\xd9\x4b\x75\xa0\x2d\x38\x5d\xbf\x7d\xc5\xf6\x4b\xf0\xda\x96\xb2\xfd\x60\x45\xf4\x93\x4f\xce\x29\x9c\xf7\xdc\x71\x70\xf2\xb5\x6f\xd8\xe7\x4b\x86\xb7\x35\x84\x85\xed\xbb\x02\x7f\x59\x79\x2d\x52\xb7\x7e\xf2\x15\x18\xc5\x54\xf5\xeb\x09\x2b\x16\xe3\xb5\x50\x8c\xf8\xfe\x99\xcb\xd5\xcb\x98\x97\xec\xc1\x73\x84\x31\x89\xd3\x91\x26\x67\x8c\x06\xc6\xa0\x30\x9b\x5d\x04\x5c\x45\x57\xc4\xab\xf1\xbc\xc4\x06\xcd\x4b\xe0\x20\x4d\xa8\x6b\x0d\x9a\x0f\xd2\x7c\xfd\x7f\x99\x89\x07\xf4\x27\x2e\xdf\x3d\x4f\xd4\x3f\xce\x01\xfb\xe3\x33\xf0\xbf\x3b\xfe\x66\x06\xfc\x35\x3b\x0b\x09\x4e\x9b\x95\x72\x7a\x75\x2a\x23\xc6\x43\xe5\x14\x0c\x87\x1c\x5a\x4e\x94\xba\x91\x40\x38\x02\xb3\x8c\x8d\x76\x9b\x70\x98\xce\xb8\x71\x17\x01\x81\x67\xcb\x60\x17\xae\x82\x0d\xcf\xf9\x7e\x3d\x3b\x5f\x06\x7a\xb5\x9d\x00\x3a\xdf\xfe\xf4\x65\xf8\x2f\x78\x6f\x10\xf0\xbc\x74\x12\xdc\x59\x79\x6f\x0a\x73\x7a\x9f\xfb\xba\xef\xe6\xde\x17\x2f\xc1\x84\x95\xc1\xf2\xc2\x38\xdd\x2d\xbd\x36\xa3\x49\x2e\x33\xc9\x14\x61\x16\x7d\x5c\x01\xaf\xb7\x2a\x50\xf0\xa2\xd0\x33\x7e\xcc\x12\x11\x73\x45\x90\x13\x20\xa3\x07\xc4\x13\x2d\xc9\xad\x29\xb4\x00\x88\x2e\x93\x83\x18\x4f\x51\x40\x38\x17\x82\x24\xc7\x44\x07\x24\xc5\x76\xac\x77\x9f\x15\x60\x89\x04\x11\xf9\x25\x47\x83\xa6\xa2\xc2\x71\x3d\xe2\x7b\x1d\x8a\x09\x43\x91\xbd\x8e\x8c\xe0\x52\x38\x1a\x83\x14\x45\x1a\x19\x35\xc3\x19\x39\xa3\x4e\x80\x4c\x65\x75\x96\x72\x5e\x67\x7a\xb4\x3b\xaa\x8c\x60\xa7\xe2\x5a\x14\x7c\xfa\x62\xd1\xd3\x6c\xb4\x1f\x75\xce\xc8\x5c\x87\x70\xe4\x99\x76\xdb\x5f\x02\x45\xef\xbc\x73\x1c\x5e\x7a\x0b\x9e\x2a\x38\x6c\x5f\x51\xb9\xe1\xde\x74\x66\x04\xe0\xab\x27\x77\x02\x4f\xfc\xf5\x13\xfc\x15\x96\xbf\x07\xa6\x76\x5a\x5d\xb3\x1f\x14\x0b\x3c\x4d\x45\x36\xe4\x57\x59\x14\x15\x4b\xf5\xf4\x26\xd9\xc2\xcc\x61\xe5\xbc\x59\x67\x70\xe9\x22\x5c\x29\x2e\x9a\x62\xf5\x6c\x24\x8b\xd8\x63\x5d\xac\x4b\xae\xd3\xb9\x11\x63\x2c\x01\xe8\x7c\x1c\x7b\x68\x63\xe9\x5f\x16\xfd\x0a\xbd\xbb\x8d\x29\x08\xe2\xb5\x8d\x8d\xfc\x0b\x03\x87\xca\x74\x74\x10\xda\xeb\xdd\x03\x22\xd8\xeb\x89\x86\x5d\xc7\x47\x39\x0f\xce\x48\xf7\x46\x24\x24\x77\xeb\xa3\x49\x38\x66\x5c\x32\x7c\xfc\xbe\xe9\xdd\x31\xee\x2b\xb0\x8b\xb8\xaf\x73\x1a\x16\x0c\x5e\xb1\x43\xb7\xc3\xd8\xad\xf7\x8f\x1d\x66\xcc\xab\xbc\x07\xcf\x0b\xb8\x4f\xdc\x6a\x8e\x41\xab\xa1\xa3\xd7\x44\xeb\x28\x97\xce\xa5\x8b\xa2\x70\x25\x50\x94\x35\x44\xc9\x61\xa4\x65\xaf\x82\x47\x4e\x9e\x49\xc2\x9a\x10\x18\x0d\x7a\x01\x82\xcc\x0f\x9a\xf2\x99\x2e\xb5\xbc\x36\x43\x2f\xa2\xbf\x3c\x32\x32\x62\xcf\x94\xd4\xd6\x4e\x77\x52\xe7\x5c\x5d\xe2\x95\x31\xd3\x47\xac\x1b\xd6\x5e\xc0\x81\x4a\x87\x9f\x9f\x10\x71\xa0\x0a\xe7\x2f\x57\x6f\xd2\x77\xeb\x7d\x57\xcb\x94\x8c\xee\xb3\xa3\x71\x18\x81\x83\xda\xfe\xa2\x1f\x0d\xea\x31\x67\x78\x58\xa7\x6d\x21\x18\xa3\x0e\xdc\x95\x80\xf6\x92\xde\x26\xd3\xcb\x2a\x78\x3d\xc3\x85\x06\xb6\x94\x14\x3a\x61\x59\xd3\x78\x5f\x49\x2a\xac\x1d\x88\x64\x44\xf0\x5f\x44\xea\x14\x7c\xee\x73\xf8\x8b\x5f\x6b\xbd\x45\xbb\xaf\x5e\xbc\x68\xb9\x81\x5e\x01\xd8\x99\xfe\xb0\x11\xce\xbd\x13\xd0\x56\x3e\xdf\xf9\xe7\x1e\xfe\x0a\x86\x63\x3e\x50\x18\xc1\x5e\x47\x7c\xa8\x09\x6e\x8e\x99\x41\xdb\x99\x61\x94\x72\xb9\x0c\xa3\xcf\x2a\xf5\x28\x2e\x6d\x06\x43\x9c\xda\xda\x94\x16\x83\x54\x29\xee\x08\x45\xf3\x9e\x89\x84\xe6\x36\xb9\x23\xcd\xc0\x03\x8c\xa0\x73\x81\x2f\xd1\xc5\x6c\x82\x7f\xf9\x7e\xbd\xf6\xe1\x4b\x2b\xd6\x02\xcf\x20\x78\x0f\x2e\x01\x5d\xdf\xfd\x0d\x6c\xab\xfd\xeb\xc5\x43\x07\x86\xf0\xe0\xbd\x60\x6c\x2c\x3b\x9a\xcd\x34\x6f\xb8\xcd\x5a\xc4\xdb\x28\x96\x33\xa1\xfd\x01\x74\x3a\xa4\x03\x75\xfa\x10\xa4\x17\x43\xac\x40\x3a\xb0\x94\xf4\x20\x49\x4d\xb8\xff\xee\x9c\x92\x91\x35\x87\xca\x3a\x2e\x9e\x50\x06\xd0\xb2\xda\xfa\xde\x8d\xa0\x3f\x7e\xe0\xf0\x55\x89\x70\x59\x25\xf3\x07\x66\x91\x83\xc9\x03\x87\x2a\xe6\x61\xc0\xac\x19\x20\xe6\x99\x87\xa6\xc5\xbf\xf9\xd1\xb2\xfa\x9e\xc4\xa5\xfb\x34\xd5\x12\xf9\x33\x18\x07\xc6\x88\x6c\x51\xa2\x57\xaf\x64\x0c\xc8\x07\x37\x08\x68\x5e\x16\x99\x9c\x80\x7d\xcb\xc2\x29\x49\x25\xf9\xf7\x09\xc5\x01\x9c\x47\xc3\x98\x91\x20\x5d\x4f\xb9\x23\x09\x0a\x0b\x6d\xc0\xac\x1a\xd9\x32\xf8\x09\xfc\x09\xc4\xd9\x1b\xfe\x1b\x4e\xcb\x8b\xce\x97\xb4\xf3\x82\xae\xc0\x0d\x56\x5c\x98\x30\xed\xa5\x37\xa6\x8d\x7b\xf5\x26\x7d\x16\xbe\x0c\x37\x1a\xe1\x87\x4b\xd6\xf1\xc7\x4a\xda\xd5\x4e\x02\xf9\x60\x06\x1c\xba\x76\x25\xfc\x1a\xde\xaf\xa9\x01\x0e\xbc\xc7\x69\x71\x2e\x55\x78\x26\x39\x16\xad\x22\x8e\x52\x28\x42\xca\x71\x62\x15\x3c\x02\x55\x9c\x24\xdc\xdd\x21\x66\x55\x01\xed\x62\xc0\x40\xdf\x70\x17\x5d\x5b\xe4\x4b\x70\x31\x9b\xe1\x5f\xb5\xe0\xd6\x36\xb0\xbf\x16\x83\xa7\xd2\xd4\x08\xa4\xd3\xb6\x13\x9d\x16\x49\xb5\xf0\x5a\xf5\xc8\xd8\x86\x32\x7a\xf4\xfe\x4a\xa4\x49\x94\x26\xc6\x8a\xd6\x0d\xdb\x84\xbe\x91\x40\xbc\x08\x6d\x20\x78\xe9\x0a\xb7\x61\xb8\x85\x54\x97\xdc\x14\x69\x72\xe3\xde\x32\xa0\x1d\x76\x7f\xfb\x9b\xb7\xf7\xc1\xd7\x6e\x5e\x7b\x3d\x5c\xcf\xa4\x6b\x86\x6c\xbd\x5e\xbd\x1c\xc4\x4c\xf0\xad\xd3\x0c\x62\x27\x4c\x9b\xf1\xfb\x4f\xf0\x3f\x70\xc4\xbf\x3e\xfb\x60\xf2\xea\x82\xfe\xb9\x33\x4e\x1f\x6a\xa8\x02\x6f\x97\xe4\x4f\xbb\x44\xf4\x5a\x1a\xe2\xeb\x06\xc7\xa3\xfd\x85\xfc\x02\x59\xa8\x23\xd4\x51\xc1\x47\x53\x7a\x75\x68\x28\xa5\x56\xa3\xc5\xac\x66\xa9\xc8\x20\x80\x57\x3f\x6b\xc6\x40\x51\x27\x8e\x86\x32\xfd\x0d\x2b\xa2\xbb\x65\x31\xbb\x51\x98\x16\x69\x90\x34\x02\xf8\xf5\xcd\x9f\xdf\x3f\xf1\xe5\x3a\xb8\xf3\xe5\xf7\x63\x4f\xd9\x37\xcf\xdb\x70\x16\xb4\xef\xe6\xec\x06\x3b\x6d\x5b\xba\xf8\x9d\x81\xab\xe7\xc0\x0f\xcd\x47\xb6\x6f\xfe\x34\xb4\xed\x8b\x53\xaf\x8e\xdf\x79\xbc\xd3\xa2\xaa\x75\x53\x4e\x6f\x80\x9f\x0f\x19\xbf\xb8\xa6\xf7\xf9\x5d\xa4\x1f\x28\x01\xad\x9d\x0f\xc8\x9e\x47\xf3\xa3\xd2\x60\x44\x66\x01\xed\x39\x04\x79\x64\xe5\x68\xe7\x8b\x2a\x2b\x4b\x68\x8d\xf5\xc3\x3d\x0b\xd9\x36\x1c\xbc\x05\x70\x9f\x4b\x17\x3b\x9f\xab\xce\xe9\xd5\xa9\x75\x4c\x65\x04\x70\x48\x00\xd0\x43\x9e\xda\x6c\xae\x35\xec\xe0\x4e\x90\xdc\x6f\x26\x1a\xef\x26\x92\x8d\x05\xf7\x04\xa9\x75\x46\x5d\x15\xaf\x30\x1a\x29\xad\xc6\x41\x71\x55\x3c\x25\x97\xd2\xcb\x52\x98\xe8\x57\x89\x04\x0a\x32\x9a\xf4\xd8\x77\x04\x6c\xab\xc2\x9e\x5d\xb2\x72\xfb\x97\xc4\x64\x80\x56\x1e\x78\x07\xba\xea\xc1\x67\x0d\xe9\x0f\xb3\x3b\xdd\xe2\x78\xdb\x72\x53\xa7\xd2\x15\xd5\x0f\xdb\xb0\x6f\x54\x6f\xd9\xba\x50\xb2\x35\xbf\xc8\xf0\xe9\xb5\xd7\xeb\xd6\xea\x55\x48\x8b\xa8\x64\x31\xd1\xc8\xe6\x59\x64\x31\x96\x18\x0b\x25\x93\xd9\xca\x79\x19\x4b\xb9\x9a\xcd\x8c\xa8\xa0\x25\xbd\x8d\xa7\x87\xc6\xbb\xa5\xa9\xbe\x0e\x06\xea\x13\x0f\x83\x68\xe3\xb5\xf7\xc0\x50\xd0\xfb\xdc\x10\xf7\xbe\x59\xc8\xb6\xa4\x45\x76\xeb\xa5\x6b\xf9\x42\xcc\xed\xb5\xb7\x26\x2e\xaa\xee\xb2\x35\xa3\xb3\x80\x50\xbd\xea\x17\x33\x50\xff\x06\x76\x81\x37\x46\x6c\x10\xec\xcb\xb7\x6d\xbf\xde\x0b\x2f\x7f\x7f\xec\x6c\xa2\x9b\x00\x55\x17\xe6\x13\xfd\xbc\x07\x0e\xe0\x86\xa3\xb9\x32\xa3\xf5\x6e\xf7\xaa\x6d\x4a\x2a\x84\xb0\xab\xc2\xe7\x00\x62\x13\x95\x1f\xfa\x43\x80\x38\x41\x0a\x50\x68\x21\x37\xa5\xc5\xfb\x8d\x09\x38\x3c\x74\x5c\x87\xf6\x95\xf0\xf3\x1b\x9f\xd0\x45\x37\x7c\xd1\xa9\x56\x4d\xf7\x27\x93\x13\x73\x93\x1c\x31\xee\xd4\x8e\x70\xc0\xb8\x32\xef\x8a\x27\xd6\xb2\xf3\x1b\x32\x99\x1b\x0f\xab\x57\x3c\xd1\x33\xba\xf7\xaa\x62\x90\xd0\x67\xd9\xb0\x5e\x3d\xdc\xb1\x09\x3d\x44\xdc\x2e\xb4\xc6\x6f\x11\xbc\x12\xb4\xf3\xac\x16\xe4\xff\xe8\x48\xbd\x95\xde\x40\xe9\x9b\x60\x32\xe6\x88\x5e\x90\x74\x31\x07\x9a\xbd\x78\xe9\x04\xda\x43\x13\xd7\xbd\x8d\x1f\x8e\xc4\xdf\x5e\x07\xe8\x8f\xaa\x26\x99\x92\x92\xe9\xd6\x6d\x72\x67\xb8\xe6\x1e\x04\x91\x07\xfb\x5b\xe5\xcc\x94\xa7\x5e\x30\xe6\x9a\x13\xe3\x3b\xf6\x74\x2d\xaf\x5b\x15\x7f\xc2\x3c\x7a\x6c\xb7\xa1\x1f\x7e\x99\xd4\xde\x73\x74\xb3\x6f\x31\xf7\x3a\xcc\x1d\x6c\x3e\x76\x3d\x77\x10\xdc\x3e\x2a\xa3\x7d\x9b\x69\x9b\xe8\x73\x3e\xcf\x2b\xe7\x29\xf1\xbc\x03\x9f\xad\xc8\xf0\x79\x47\x10\x4e\xb7\x09\xef\x51\xb9\x4e\xaf\xab\xe0\x59\xbd\x5e\x45\x31\x26\xca\x84\xa1\xba\x43\xd4\x2a\x35\x5a\x22\x4d\x60\x4d\x0d\xc1\xd9\x0b\xbc\x0b\x70\xda\x44\x38\x8a\x20\xa9\x13\x11\xc4\xbb\xe0\xb6\xe3\x76\xb9\x1f\xc8\xbb\x1c\xfd\x9f\x02\x02\xe6\x0d\x47\xae\x81\xf6\xda\x5a\xf0\xd5\x1a\x7c\x09\x60\x00\x6b\x7b\x20\x9a\x4f\x37\x46\x5f\x66\x0d\x8c\xb0\x01\x43\x58\x8a\x25\x69\x1a\x3f\x58\x67\x96\xff\xd4\x4b\x5a\x71\x72\x3f\xe2\xf6\xf6\x37\x06\x5c\xba\x13\x7e\x6a\x75\x97\x8e\x91\xad\xb2\xe6\x3b\x9f\xa0\xaf\xfe\xdb\xb7\x13\x1c\xa4\xab\x4e\xc0\x1c\xb6\x4d\xcd\x36\xdd\x3e\xe3\x06\x38\x8e\x3e\xe5\x3b\xe5\x93\x05\x63\xc3\x49\x63\xea\xf0\x98\x45\x7c\x08\xfa\xdc\xf2\x7f\x1a\x53\x40\x88\xfb\x1a\x8d\xd9\xd9\xeb\x6e\xd5\x79\xa1\x73\x66\x30\x52\x1c\xbb\x57\x18\xd3\xb7\xf9\x51\xbc\x38\x03\x46\x2a\x64\x54\x6a\xb4\x4e\x90\x22\x94\xeb\xf5\x3a\xe4\x33\x53\x6c\x88\x3c\xe4\x91\xe3\x9e\x80\x9c\x9b\xc9\x18\xed\x2c\xcb\x1d\xc7\x9d\x51\xfe\xd3\x9e\x51\x9f\x39\x3e\x1b\x45\x4e\xdb\x98\x96\x6b\x7c\x3f\xd5\xd4\xd0\xc6\x35\xb4\xa1\x86\xc8\x57\x41\x51\xcc\xb7\xe4\x5d\xe3\xbc\x46\x8d\x1e\x98\xf4\x26\xb3\x59\x6b\xa0\xe4\x2a\xad\x9e\x51\x59\x84\x44\x18\x8e\x10\x24\x17\x5d\x6e\x8a\x66\x90\x39\xc4\xd8\x5f\x00\x97\x5e\xc6\x7b\x6c\x99\xcc\x85\xc3\xef\x5d\x1c\xcc\x19\x68\x73\x67\x38\xe2\x45\x7a\xbe\xfb\x65\xdb\xcd\xa8\xe7\xed\x75\xec\xc3\xf6\x0f\x3b\xd1\x5d\x1c\x4f\x25\xc5\x4d\xf6\xcd\x67\x6e\x5e\xec\x3a\x3d\xf7\xd6\xd3\x59\x02\x7e\x33\xa7\x41\x6b\x2b\x1e\x7b\x51\x71\xb4\x2a\xd6\x18\x69\x55\x31\x4e\x23\x86\x8f\xa6\x38\x53\x00\x4e\xc4\x23\xc8\x19\x45\x50\x12\x64\x54\x13\x84\x63\x99\x88\xe1\x4e\x0a\xbc\x32\x65\xf4\x89\x65\x11\x29\x4f\xf6\x9e\x31\xd6\xfc\xc2\xb3\x27\x4d\x29\xd9\xdd\x07\xd9\xcf\xec\x39\x65\x4c\x4e\xdb\xd0\xf6\xd4\x9e\xf7\x6d\x9a\x95\xc6\x41\xe6\x03\xbd\x4a\xe7\x2e\xea\x59\xc9\x1c\x6c\x18\x35\xb4\x7d\xf7\x8e\x8b\x97\x31\xa7\x1a\x4a\x07\x66\xe7\x7a\x91\x46\x7e\xf6\xe1\x9e\xc9\xd3\x9f\xdc\x46\xf4\xbe\x11\xe9\xe1\xeb\x04\x9f\x23\xdc\xab\x31\x00\xca\xac\x63\xe4\x68\xc1\xcb\xb1\x41\x4e\xf1\x9f\xf0\x89\xa0\xe6\x41\xca\x3e\x18\xdd\xdc\xf8\xb2\x73\xef\xc2\x6e\xad\x23\x12\xb2\x27\x47\x02\xc7\xa7\xa0\x8d\x2a\xac\xee\x30\xfc\x93\x1d\x73\x60\x40\x83\xf1\xe9\x0d\xaa\x3d\x5a\xa4\xf4\x1f\xd6\xac\x5f\x48\xc0\xce\xc9\xb9\x18\x39\xe7\x31\xca\x98\xca\x40\x7f\x0d\x37\xd0\x28\x63\xb7\x50\x22\x16\x3a\xb7\x96\x5b\x84\x62\xea\x18\x8c\x50\xa6\x45\x5b\x41\x1b\x62\x54\x22\x35\x17\x62\x27\xbb\xa2\xb9\xd5\x34\x78\x84\xfb\x62\x82\x6e\x3d\xca\xc8\x44\xcb\x44\x2e\x93\xdb\x1e\x03\x94\xfe\xda\xab\x23\x8e\x3e\xd8\x06\x7a\x67\x0f\xb6\x96\x44\xbe\x6c\x69\xf1\x02\x2d\x42\xa6\x5f\x9e\xe2\x87\x4c\xdf\x0d\x16\x80\x90\x25\xf0\x76\xce\x94\x03\x63\xee\x4c\xca\x08\x46\x4e\x9f\x70\xc0\x8f\x10\x2e\x62\xef\x71\xe3\x09\x3e\x69\x3c\x46\x2e\xb4\xa8\xd5\x3a\x1d\xa5\xd7\x85\x38\x09\x06\x5f\x10\xf6\x9d\x18\x84\x06\xe9\x3f\x02\xc6\xe7\x04\x02\xa7\x5a\x80\x98\x0d\xc4\xca\x8f\xc0\xf2\x8d\x0b\x2d\x71\x5f\xb5\xd8\x16\x57\xb2\xca\x34\xf8\xc6\x85\xc7\x02\xf4\xc9\x73\x17\x1c\x18\x33\xf5\x78\x66\x72\x2a\xbc\x0f\x3f\x69\x8e\xd4\x47\x53\xad\x61\x09\x67\x40\x7a\xc6\x80\x76\x62\xa2\xd7\xa2\x51\x20\x65\xa7\xa0\x94\xac\xdc\x8c\x26\x9c\xa5\x1c\x41\x52\x25\xcc\xe2\x5a\x67\x81\x59\x3d\xc6\x14\xb0\xc5\x7a\xb0\xdd\x65\x64\xa6\x80\x91\xcb\x04\xeb\x8f\x9f\xd8\x01\xec\xc7\xe6\x0d\x07\x13\x93\xe0\xbe\x7a\x90\xb6\xff\xad\x2d\x67\x63\xf2\x46\x1f\xad\x1c\x32\xb0\x63\x4b\xf3\x9f\x5f\x20\x37\x7f\xdf\x77\xdd\xbc\x7f\x72\x32\xcf\xc3\xcb\xe5\xec\x81\xa4\x57\xe0\xbe\xf3\xcf\x9e\x89\x14\xe4\x67\x42\x6b\xe1\x37\xe2\xb3\x3a\x71\xc7\x8b\x8e\x2e\xe4\x75\x32\xbd\xde\x64\x51\x5b\x0a\x78\xb5\x5e\x86\x02\x28\x19\x5a\x9b\x92\x9f\x2d\x28\xa5\x24\xd2\x08\x2d\x14\x5a\x10\x1b\x6c\x45\xcc\x29\x80\xe4\xb5\x66\x32\x11\x80\x3b\xb9\xbf\xd3\xee\xc2\x17\x6f\x02\x2f\x88\x2d\x5a\xd3\x12\xe4\xb5\x80\xef\xc3\x86\xd6\x6d\x5f\xbd\x39\x61\x4a\xe7\x6c\x64\x42\x73\x1a\x0e\xc6\x27\xbf\x71\x1b\x29\xac\x89\x49\x11\x9d\xfe\x32\x72\x83\xcd\xf0\x7b\xf8\xfe\xda\x35\x56\x31\x06\x7a\x89\xe0\x90\x3b\xa9\x24\x24\x2b\x8d\xdc\x68\xe7\xca\x79\xbb\xdd\x28\x37\x86\x85\x18\x43\x2a\x78\xa3\x74\x8d\x03\xce\x2d\x48\x47\x47\x66\x19\x9b\x84\x11\x5e\x83\xd2\x39\x38\xd1\x40\x90\xf2\x33\xd8\x97\x9e\x86\x7f\xd6\x5d\x1a\x7e\x49\x4a\xe1\x4c\xb9\xfd\xd1\x55\xf8\x79\xed\xa8\xbd\x47\xdf\x60\x1e\xae\xf8\xee\x49\x1f\x0c\xc4\x42\x47\xce\xde\xf2\xfd\x58\x2f\xd4\xa5\xe0\xda\x66\x9c\x6f\x70\xa2\x75\x96\xe5\x75\xc9\xe4\x61\xa1\xf2\x50\x36\x3c\x3c\xb2\x80\x0f\x47\xd2\xd2\x59\x8a\x78\x1d\xa5\x0a\x67\x51\x74\xc2\x4a\x19\x9a\xa0\xf0\xd2\xe0\x07\x89\xc0\xc8\x3f\x42\x65\x33\x56\xe8\x11\x40\xd0\xe8\xe4\xf8\x94\xd1\x8b\x6e\xa5\x91\x2d\x5d\xf4\xfd\x9e\xff\xb6\xe6\x74\xe5\xa7\x40\xb6\xf3\x58\x4d\x46\x5c\x74\x64\xfb\xb4\x79\xce\x34\xa6\xc7\xe1\xb9\x20\xed\xfc\x15\x38\x7b\xfc\x94\xa3\x2f\xd2\xef\x7d\x03\xf7\x1f\x3a\xa3\x18\x00\x4d\xb2\xde\xeb\x36\x87\x84\xec\x37\x6f\x80\xbf\x8c\x19\x0c\xab\x00\xed\x3b\xbb\x7a\x11\x48\x13\xf2\x33\xf0\x25\x76\x37\xe9\x71\x0f\xc5\xde\xa5\x8e\xb6\xe0\xf0\x1d\x2d\x3a\x8b\xdc\x22\x67\x51\xd0\x8c\xad\xdc\xb5\x1c\xb1\x9d\xca\x0f\x13\xcf\x48\x1d\x55\x41\x48\xfa\x19\x4c\xf2\x4f\xbf\x15\xe1\x8e\x2a\x17\x88\xbe\x73\x6b\xcc\xcb\x8b\x80\xda\x8d\xa1\xf4\x07\x81\xd0\x7d\x67\xe1\x4b\xf4\x97\x70\x20\x97\xbb\x75\x4f\xcd\xd8\xcb\x8b\xcc\x3e\x8e\xdd\x59\x0f\x5b\x6c\x27\x36\x16\xe9\x98\x33\x68\xed\xb7\x40\xb6\x27\x34\x32\x21\x56\xa5\x33\xc5\xea\x62\x75\x09\xa6\x04\xe4\xfb\x25\x98\x4c\x9a\x0a\xde\xc4\x3e\xea\xee\x91\x90\xdc\x94\xd6\x91\xc9\xec\xc8\xa4\xa7\x45\x47\x36\xb9\xda\x8f\xc1\x5b\x20\x52\xb8\x46\x26\x2b\xa5\x78\xc6\xda\x7d\x4f\xac\x9f\xdc\xe5\x0f\xf8\x60\xc0\xf3\x7d\x80\xf2\xa3\x2b\x77\xb2\x2a\x9f\x3f\xd7\x67\xfb\xdc\xde\x9b\x56\x81\xf8\xa1\x47\x9e\x82\x59\x1f\x7d\x09\x12\x4b\xaa\x87\x75\x4f\x8f\x33\x46\x67\x95\xf6\x38\x7c\xcf\x7d\x68\xdb\xa6\xb5\xfc\xf2\xe1\x7d\x12\x0d\x71\x9d\x2a\x8b\x2b\x46\xfc\x1e\x0b\xb7\xed\x45\xfc\x4e\x46\xfc\x76\x67\x7b\xa2\xd9\x46\xfc\x3a\x62\xdd\x4a\xad\xd1\xad\x75\x6b\x63\x8d\xb1\x28\xf2\x8c\xb5\x1a\xd5\x8f\x54\xb3\x07\xf8\xcd\x4c\xeb\x48\x0b\xfc\x46\x09\xa8\xdd\xe4\xda\x33\x6d\x93\x7b\x8e\xe2\x26\xa7\x0d\xdd\x7b\xa0\xd7\xdc\x01\x29\x1f\x7e\xd4\x6e\x5b\xea\xcf\xc7\xc0\xc8\x6b\xf7\x37\x4d\x1f\x33\x7b\xfa\xd2\xda\xb8\x8d\x1d\x7e\x7a\xed\xfc\xb5\xaf\x7b\x4c\xe5\x7b\x25\x9a\x22\x5b\x76\xce\x98\xbd\xde\x3a\x6f\xe9\xcf\x2b\x4e\x64\xc7\x86\x97\xf4\xe8\xda\xa7\xb0\x6f\xd4\x8a\x85\xf3\x89\xee\x66\x90\xef\x82\xeb\x4a\x64\x4c\x5f\xd2\x87\x3f\x11\x0e\x60\xbc\xdc\x3d\xac\x61\xa8\xb4\xe7\x1d\xee\x33\x20\xc6\x6b\x40\xe1\x98\xc3\x61\x64\x74\x1a\x23\xf2\x30\x8c\xe1\x4c\x3c\xfa\xf4\x04\xcf\x50\xcd\xf2\x08\x42\x54\x26\xde\xb9\x2a\x07\x01\xf0\x19\x62\x11\x09\xd7\x99\xe4\x15\x84\x8a\x04\x30\x71\xd9\xc4\x27\xfb\x29\x20\xe4\x06\x67\x64\x46\xf4\xc8\x19\x3f\x49\xf9\x5f\x63\xe7\xd0\xee\x7d\x0b\x52\x5a\x64\xf7\x6c\x9d\x94\xde\x87\x7d\x30\x64\xc1\xfc\xde\x09\xad\xfe\x7a\xd3\x61\x29\xd7\xec\xd4\x8c\x1f\x9a\x90\xca\xfa\xd4\x86\xa2\x7e\xf1\xa9\xdd\xdb\xa2\xff\x11\xff\x0b\xa8\xd1\xde\xc2\xf8\x92\x31\x54\xfa\xc9\x70\x97\x4b\x8b\x73\x35\x16\xde\x65\xb5\x86\x9a\x42\x8b\x78\x53\x78\x08\xae\x4d\xe0\x39\x06\x77\xa0\x5f\xf3\x04\x81\x72\xe4\x48\xd5\x89\xe2\x51\x95\x60\xa8\x33\x19\x3a\x5a\x02\x18\x7c\x3c\xfa\x64\xfb\x21\x4b\x0f\xb5\x6f\xdb\xd0\xb9\x53\x44\x5a\x9b\x76\x5d\xb5\xa1\x83\x7b\xee\x99\xaa\x58\x1c\x00\xa2\x0c\x35\xb7\xea\x14\x05\x6f\xc2\xaf\x0c\xbb\x8c\x5d\xf2\xe6\xa9\xa7\x0d\x88\x4d\xa6\x9f\xc1\xd8\xf3\xd2\xb9\x1e\xb2\xd7\x0a\x85\x86\x36\x52\xac\x06\x05\x6a\x9a\x60\x6d\x24\x60\x4c\x47\x13\x15\x44\x34\x90\x70\xdd\xc2\xcd\x41\x45\xcc\x33\x17\x4f\x32\xd9\xe2\x95\x0b\xbd\x47\xb5\x35\xb4\x3c\x79\xb6\x36\x80\xb1\xf9\x01\x15\x4d\x79\x4e\xda\x43\x9d\xa1\x58\x06\x66\xde\x69\x55\xa8\x64\xaa\x22\x5e\x86\xf4\x33\x96\x81\x0e\x8b\xe0\xf1\x12\xc8\x0c\x8a\x82\x40\x90\x2c\x82\xe1\x37\x8f\x5b\x1c\x07\x57\x74\xf6\x44\x7a\x52\x72\xba\x69\x2d\x41\xa2\xb0\x1f\xaf\x13\xdf\x7f\xc2\x86\x9d\xda\x3a\x73\x7e\xaf\x31\x7e\x21\xac\x68\x25\xbd\xfb\x6b\x48\x69\x3b\x89\x4e\x76\x79\x75\x94\xd1\x84\xef\x48\x91\xa9\x64\xc8\x3d\x37\x31\xd8\x5b\x09\x3a\xc8\x6c\x36\x38\x10\x8e\x33\x7d\x21\x61\x69\xed\x33\x22\xba\xe7\x8c\x9d\x1c\x02\x18\xff\x89\xe6\x5f\xdf\x25\x38\x23\xb2\xf4\x3b\x0d\xa3\x86\xc5\x27\x71\x19\xb5\x24\x3e\x1d\x8f\xec\xfa\x2d\xe4\x83\x44\x62\xec\x64\x92\xaf\x50\x52\x94\x36\x82\x31\x33\x5a\x64\x27\xb5\xa2\x9d\x24\xf1\xcc\x35\x21\x97\xe0\x37\xe3\x8c\x98\x4f\x68\xea\xc3\xb1\x83\xf9\x99\x46\x6c\xc2\x23\xce\x6e\xe8\x97\x0e\x7d\x3f\x9e\x7b\xce\x7c\xe8\xd2\x3e\x2b\x3f\x6a\xdd\x86\xc4\x67\x2f\x32\x0f\xed\x95\x65\x07\xc6\x6c\xbd\x12\x01\x7b\xc3\x07\xbf\x6e\xd9\xd5\x67\x24\xbe\xbb\x62\x6a\x6e\x79\xf1\x9e\x77\x98\x3c\x21\x4e\x58\x88\x78\xe2\xd9\x6c\xa2\x13\xc2\xe2\x75\x6e\x59\x01\xef\xb6\x3a\x5d\x56\xb5\x4b\xad\xb4\x5b\x0c\xfa\x22\xde\x60\x50\x12\x38\xd4\xa0\x84\xb3\x78\xa7\x4e\x13\x80\xd2\x00\xb3\x28\xec\x6a\x06\x55\x7a\x67\xa9\xbe\xd7\xc0\x59\xcf\x45\xce\x3e\xd5\xbb\xa4\xd4\x88\xfd\x23\xe7\xee\xa7\xfa\xda\x68\x8c\x59\xda\xef\xe0\xa4\x95\x0b\x0d\x04\xb3\xb4\x5f\x7a\x8f\x4e\x47\xf7\xd0\x55\x70\x6a\x54\x65\xe9\x81\x31\x9b\xce\xa4\xc2\x3e\x6b\x8c\xaa\xa5\x89\x53\x4a\x27\xcf\xf4\xf6\xa5\xef\x20\x7e\xbb\x37\x7e\xcf\xb5\x46\xf3\x15\x8b\xd1\x7d\x22\x64\x4e\x46\xa1\x54\x20\x13\xaa\x64\x28\x63\xd0\xa5\x1e\xe2\xdd\xe0\xc2\xdd\x4e\x99\x32\x0c\xd3\x28\x97\x92\xe0\xb8\x9d\x35\x13\x03\x56\xc6\xe3\x9b\x85\x69\x16\xfc\xf9\xda\x97\x7f\x7c\x31\xab\xc5\xf5\x08\xf0\x79\xf2\x85\x97\x97\x2d\x5e\x71\x7d\x74\x69\xbf\x64\xf0\x79\xc4\xf5\x96\x53\xc6\xcd\x3e\x04\xdf\xb0\xfc\xf9\xfe\xe7\x60\xcd\x32\x55\xed\xbf\x66\xc3\x17\x3f\xde\xb9\x77\x1d\x90\x3d\xb7\xf0\xed\xfc\x7f\xd5\xaa\x0a\xe1\x83\x1d\xaf\xc1\xfa\xb3\x94\x1f\xa7\xff\x2a\xb2\x07\x11\xf8\xc6\x1b\xab\x39\x0c\x59\xa3\x30\xb6\xe9\x75\x23\x52\x31\x54\xd3\xc9\x14\x72\x77\xf2\xcc\x0c\x21\x79\x44\x81\x1f\x5e\x3e\x63\x3a\x78\x71\x9f\x61\x44\xd5\xea\xaf\x17\x77\xec\x9c\x9d\x16\x9a\xd7\xfb\xc9\x05\x67\xe1\x59\xf3\xfe\x03\x3d\xca\x99\x61\x0d\x47\x06\xe4\x8c\xaf\xfc\x16\xec\xfc\xb3\x6c\x80\x72\x87\x7a\xef\x7a\x78\x03\xaa\xe1\xaf\xc2\x9c\xee\x40\xfb\xf9\x7d\xc4\x07\xf2\x7f\xbc\x5a\xbd\x5a\xcb\xa8\x8d\xac\x0c\x5f\xf0\x42\xf9\xd1\x8f\xf0\x22\x13\x01\xe1\x48\xb4\x8c\xb7\x36\x4e\x68\x52\x1c\x9b\x33\x22\x75\x42\x87\x8e\x29\x1d\x9c\xb0\xd3\xe4\xf3\x93\xe1\xf3\xb7\xa8\x46\x1f\xa0\xb9\x81\x2d\x3d\xcb\x73\x5b\xc5\xf8\x3e\xf7\x9d\x11\xae\xee\x00\xed\x41\x7b\xe4\xeb\xff\x09\x07\xc8\x36\x23\x1f\x02\xdf\xf1\x1b\x16\xe6\xb0\x3a\x8a\x78\x2b\xa5\xd3\x6a\x15\x11\x0c\xa5\xd4\x31\x1c\x01\x4b\x0d\x97\xf4\x88\x2d\xcb\xe0\x11\x65\xd0\x04\x2f\x55\x00\x46\x06\x81\xfd\x2e\x07\x5a\x7a\x62\x6e\xaa\x3d\x26\xa9\xdf\xd6\x5e\xf6\x46\xea\xec\xaa\x24\x8e\x56\x8d\x72\x81\xba\xbc\x67\x27\x54\xf3\x63\xdb\xe6\x27\xf7\x6b\xe9\x1b\x3a\x74\xc3\x33\x04\x47\x75\xee\xa2\x64\xb6\x95\x6f\xfe\xbd\xe8\xd0\xab\xe9\x8c\x62\xfe\xb4\xb2\x85\x1d\xdb\xf5\x79\x38\xe8\xb9\xe7\x8a\x83\xee\x16\x31\x60\xb4\x7f\x9d\x4a\xab\x2a\xe7\x95\x06\xca\x30\x04\xe3\x68\x62\xf0\x2d\x8a\xd5\x22\x5b\xc3\x32\xf8\x6a\xa2\x20\x8d\xe7\xaf\xc8\x16\xd9\x75\xfb\x91\x56\xf1\xa5\x21\x6e\xb4\xfd\xf7\x81\xc3\xe0\xa0\x70\xf7\x08\xcc\x07\x65\x76\xd8\x1e\x66\x33\x43\x5c\x0f\xaf\x85\x83\xb7\xe0\x79\xfa\x01\xa8\xaf\x5d\x05\xdb\x2d\x85\xc9\xb5\x6b\xc1\xbf\xa9\x20\x5c\x57\x89\x8f\x02\xc2\x47\x01\xe1\x43\x45\xf8\xb0\x60\x3e\x90\xbb\xa5\xfb\xff\xe0\xa3\x1e\x54\x83\x62\x01\xfa\x15\x1e\x02\x2e\x3b\x9c\x02\xb7\xd2\xb7\x1d\x0d\xa3\x1c\xa0\x12\xfe\x48\x8f\x06\x79\xab\x56\xc0\x33\x4b\xe1\x81\x55\x2b\x40\x29\x8e\xcf\x76\xc2\xfe\xec\x2f\x48\x1e\x4e\x14\x5d\x98\x38\x43\x78\xb8\x9a\x56\x9b\x71\xea\x10\xb9\xd5\xf8\x7a\x39\x3f\x26\x8a\x1f\x0c\x95\xa4\x24\xf0\x98\x18\xa3\x07\x6b\x22\x7f\x25\x9f\xff\x9a\x5f\x06\x36\xfc\x19\xc1\x7c\x14\xe9\xab\xfb\xe8\xb3\x53\xf0\xc2\x4b\x2b\x2f\x4d\x8d\x79\x3e\x6a\xf7\xb2\xa5\x1f\xcf\xbb\xfe\x6e\x0f\x07\x7b\xb0\x76\x37\xb4\x69\xdf\xba\xfa\x0a\x3c\x7f\x26\xbf\x66\x49\xcf\x9a\xc5\x8b\xef\x6f\xdb\xba\x73\x0d\xe2\xe5\x6b\xc4\xcb\xcf\x88\x97\x70\x7c\xe2\x65\x73\x84\x22\x45\x18\x6e\xb5\x82\x0a\x5e\x65\xb5\xea\x42\x19\x5d\x48\x39\xf2\x41\xfd\xf7\x0c\x64\x05\xa9\xe3\xe8\x28\xf6\x91\xfb\x17\x62\x48\x01\xbf\x1b\x30\x5d\x7a\x9c\x82\x0f\xd6\xef\xdd\x5c\xfd\x4e\xe9\xd3\x33\xe0\xad\x57\x3f\xfe\xed\x10\x68\x73\x03\x56\x22\x26\x5d\x0d\x7f\x82\x0d\x74\xab\xd9\xdf\xed\xdf\xf4\xec\xa2\xb5\x3d\x5f\xd8\xfb\xf5\xad\x0b\x20\xe1\xa4\x05\xfc\xb8\xbb\x16\x1a\xc9\xfe\x31\x23\xdb\x3d\x03\xcd\x93\x9d\x6a\xe5\x0d\xb5\xb1\x05\x3c\xad\xb6\xd9\xf4\x61\xa1\x20\x0c\x14\xf0\x61\x3a\xbd\xb2\x80\xd7\x87\x37\xf3\x33\xb2\x48\x63\xad\x1b\xc8\x45\x08\xb1\xc8\x60\xd8\x18\xc4\x15\x5b\xea\xeb\x01\x3a\x86\x17\x9d\xff\x7e\x7e\x15\x30\xf4\x3b\x9a\x0d\x3f\x79\xff\xec\x9d\xe5\xbf\x6e\x80\x37\xa2\x98\xd1\xcc\x11\x38\xff\xa9\x1f\x5f\x5a\xb8\xa6\x41\x7d\xee\xd2\xeb\xc7\x76\xc2\x67\x4c\x60\xcc\x71\xcc\x8b\x01\xc9\xa7\x1a\xf1\x92\x84\xa3\x56\x9b\xd9\x62\x2e\xe0\x43\xb5\x49\xb1\x8c\xc1\xc0\x58\x98\x84\x02\x9e\x71\x58\x74\x01\xa8\x55\x5b\x96\xff\x20\x3b\x08\xb3\x86\x9c\xf7\x64\x06\x66\x50\xcb\xc8\xa5\xc3\x1f\xe6\x87\x6e\xf0\xee\xdd\x73\x1f\x0c\xbc\x70\x71\xf5\xac\x0e\x27\xcf\x3a\xc0\x4e\x5f\x4d\x38\x33\x3c\x14\x22\x9b\x15\xe3\x2d\x19\xb7\x7b\xeb\xa4\x0e\x8b\x66\xac\xbc\xd4\x66\x44\xed\xc1\xe5\x73\xfa\x2d\x19\xdc\xd2\xed\xe9\x92\x92\x93\xb9\x0a\xb4\x58\x3d\x03\x5e\xd4\x4c\x1d\xd6\xae\x34\xd7\x13\x1f\x1f\x93\x96\x9f\x99\x93\x57\x39\xc4\x7f\xdf\xf5\x0a\xa4\x7f\xdc\x54\x6b\x6f\x98\x33\x2c\x3c\xac\x82\xb7\xb8\x29\xf7\x10\xde\x18\x42\x51\xea\x70\xa3\x9a\xab\xc0\x79\x6a\x29\x7c\x6d\xb2\xba\xfd\x70\x5e\xfe\xeb\xa2\xe5\x1e\x11\xe6\x54\x8e\x6f\xb7\xc8\x74\xef\xa3\x47\x5f\xfa\xd2\x7f\xe1\xf5\xb9\xd7\xfa\xf5\xd9\x68\x87\x9f\x3d\xf3\xd2\xb1\x14\xfa\xbb\xf0\x86\xbe\xb6\xee\xdf\x7e\x01\x33\xe9\x07\x6b\x36\x1d\x25\xb7\x5e\x6f\xa9\x19\xba\x39\x6f\xe9\xf8\xea\x5d\x7d\xd6\x4f\x9b\xf3\xe5\x76\x41\x3f\x16\x21\x3d\x7d\x9a\xac\xff\x34\xaf\x5d\xa1\x60\xad\x76\x13\x8e\xc2\x58\x6b\x98\xc5\x6a\x29\xe7\xad\x0c\xab\xae\xe0\x59\x53\xb3\x19\x6e\x12\x8e\xe1\x3d\x90\x2e\xa1\x23\x24\x61\x68\x13\x92\xb4\x6b\x63\x65\x3b\x6e\x84\x3f\x9e\x58\x78\xb2\xfc\xb4\x62\xe1\xe4\x43\x77\xd7\xaf\xf9\x90\x7f\xc1\xc5\x4c\x76\xf9\x7c\xed\xba\x5e\x7f\x97\xb6\xed\x82\x6b\x4a\xf6\x4d\xb2\xcc\x9f\x76\xf7\xf0\xc4\x19\xe0\x66\x6d\x2d\xbc\x73\x0e\xf1\x54\x85\x6b\xbe\xd0\x3c\x3b\xb1\x1d\xb6\x99\xe4\x2a\xb4\xec\x54\x2a\x93\x5c\x29\x93\xcb\xb0\x82\x30\xa1\xa0\xd5\x64\x7d\x1c\x4b\xa4\xdf\xd4\xcf\x81\x5c\xbc\x53\x95\x54\xe9\x8b\x50\x76\x3d\xe7\x3d\xf5\x4a\xef\xb7\x1d\xcc\x20\x07\xb4\xb7\xe9\x71\xfe\xd5\xd9\x5f\xef\xb9\x72\x9d\x39\xbe\x70\xec\xb6\x67\x41\xf5\x13\x7d\xc1\xf2\xd5\xab\xe1\x9a\x15\x73\xaf\x4e\xdc\x73\x50\xcd\x95\x4e\x11\xf2\x5b\xf8\x2c\x5a\xc9\x7d\x4e\x25\xe0\x0c\x44\x2c\xa0\xdc\x51\xee\x42\x5e\x6f\x55\xc7\x45\xe9\xd4\xa6\xa0\xda\x2b\x8c\x6c\x4f\x14\x95\x78\x1f\x0a\x81\x15\x65\x9b\xc1\x89\x62\xf0\x08\x82\x60\x6b\xca\x64\x3c\x72\x3a\xdc\xd9\x73\xc8\x8e\xd9\xf9\xf0\xd7\xff\x7e\x78\x4f\xb5\x4f\xb5\xf1\xe9\xed\x5b\x12\x0b\xd7\x3f\x35\x59\x61\xdd\x6c\xdf\xd2\xe5\x6a\xf1\x03\x3b\x73\x7a\x43\x74\xeb\xac\xd0\xf8\x2e\xc3\x7b\xd5\xbf\x52\xbd\x36\x62\x40\x61\xc5\x84\xc4\xb6\x09\xf1\xb1\xd3\x2b\xe2\x53\xaa\xaa\x41\x69\x1f\x38\xa0\x5a\x8a\x61\x87\xb1\x05\xc8\x77\xb5\x53\x6e\xaf\x81\xf4\x35\xe8\x59\xab\x4a\x69\x45\x92\xd3\xe1\x93\xa9\x80\xd3\x22\x00\x1a\x72\x38\x08\x14\x32\xc3\x04\xf2\x2f\x52\x05\x3a\x32\xec\xb0\x93\x70\x05\x3c\x99\x7d\x0a\xc4\x1e\xd4\x2b\xd8\xea\xaf\x76\x1c\xb8\x30\x6a\x08\xfc\xd7\x13\x23\x6f\xfc\x67\x73\x2f\xfa\x3f\x57\xe1\x15\x38\x19\xbe\xc3\x7d\xbe\xb4\xd5\x8d\x53\x97\xab\x66\xc0\x41\xbe\x5f\xbb\x6d\x3e\xf8\x1a\x96\x15\xad\x46\x8c\x5c\x0e\x60\x52\x8b\xf7\x5e\x61\x68\x57\x75\x3d\xf7\xfa\x5f\x69\x38\x86\x41\x3e\x36\x33\x50\xec\xc1\xd0\x9e\xe2\x00\xe5\xbf\x58\x55\x78\x12\xff\x01\x53\xf6\xed\xdc\x87\x9f\x17\x7e\x03\xa8\xc5\xf8\x0e\x08\xf4\x1b\x13\x5e\x13\x72\x92\x3c\x66\x29\x95\x4e\xaf\x2b\xc7\x79\x20\xf4\x47\x43\x53\x1a\xa3\x1f\x51\xd6\xd0\x04\xcf\xd6\x24\x00\x07\xba\xc9\xff\x04\x20\x41\xf7\x62\xb0\xfa\x28\xa8\x81\x53\xf0\xff\x8e\xc2\xa9\x60\x35\x9c\xca\xca\xc0\x35\x98\xbd\x15\xbe\xbe\x15\x56\x80\x5d\x5b\x51\x70\xdd\xd8\x88\x53\xc8\xcc\x48\xae\xab\x51\x46\x61\x50\x59\xb6\xf1\x3e\xf2\x27\x4e\xca\xd6\x50\x0a\xc4\x09\xce\x15\xb4\xf7\x46\xc6\x46\x45\x85\xea\x43\xcb\x79\x86\x03\x5e\x85\x26\x1f\x28\xbc\xd1\x7a\x26\x32\x2e\x2e\x4c\x17\x56\xce\x47\x60\x4c\x27\x91\x1b\xb4\x44\xec\x9f\xdc\x4a\x6a\x93\x25\x61\x4a\x66\x7a\xf0\x85\xb9\x3a\x10\x8d\x0f\x78\x93\x00\x10\xa6\x41\xa8\x46\x31\x02\xb7\x1f\xd0\x9c\x39\xc9\x56\xce\xa7\x0f\x57\xb2\x6f\xef\x87\xb5\x35\x8d\xd4\xd1\x7d\x40\x36\xfb\x85\xe7\x0e\x17\xf5\x63\x6f\x86\x0e\xde\x3d\x98\x4e\xf7\xbd\x11\x4e\xe7\xc3\x5b\x2e\xf0\xad\xc3\x77\x02\x2c\x92\xcd\x32\xcf\x99\x63\x7e\x1b\xca\xe0\x97\x30\xff\x3d\x2e\xf7\xda\x83\xa7\xd6\x3e\xfc\xf5\x35\x50\xe9\x4b\xad\x61\x1d\xb5\x2b\x1f\xfe\xdb\xff\x2e\x43\xb8\xad\xd2\xbb\xb4\xf3\x46\x4a\xef\x10\xe5\x8d\x72\x57\xf0\x51\x3a\xfc\x62\x7a\x26\x96\xbc\x8b\x4b\x7a\x17\xf1\x7c\x93\x74\x68\xe0\x17\xfa\x5f\xaf\x62\x92\xa0\xd9\x99\x21\xe2\xab\xdc\xdb\x0f\x7f\x7e\xcc\xab\x30\x76\xe0\x83\xd7\x1d\xe0\xcb\x30\x9f\x0f\xac\x74\x70\x4b\x85\x17\xf9\xeb\xd1\x17\x59\xc2\x24\xad\x5a\xd2\x70\x8f\x60\x9c\xb3\x94\xa6\xf1\x2b\x6e\x2a\xb9\x2b\xc5\x4d\xb5\xa4\x32\xa9\x12\x6f\xaa\xcd\xaa\xb4\xba\xda\x48\x6f\xd4\xc6\xdb\x26\xb5\x80\x6f\xa3\x6b\x95\x5e\xc0\xb7\x72\xb9\xd0\x16\x76\x59\xc2\x28\x53\x0b\x5c\xfd\xae\x89\xc1\xf7\x77\x05\x72\x73\x44\xad\x34\x7d\x45\x82\x42\xdd\x74\xce\xb0\x6a\x31\x90\x6b\x8f\xc5\xf6\x60\xf4\x61\x7c\x5a\x66\xbc\x78\xf9\xb1\xd0\x1c\x2c\xbd\xf8\x54\x69\x0e\x7d\x2b\x53\x07\xe6\x3e\x3b\xfa\xd0\xb8\x5e\x39\x2a\x9a\x1d\xfa\xcc\x03\x37\xb7\x05\xe8\x6f\x3f\xd1\x75\x5a\x56\xaf\xfc\x69\x6d\xc1\x93\x61\x00\x12\x19\xd8\x7d\x10\x2c\xf4\xcb\xe0\xe1\x6b\x03\x72\x40\xe6\xbb\x60\xcd\x8d\x4e\x4f\xd8\xc0\xc3\x87\xa6\xcb\x11\xca\xf8\x9e\xa7\xaf\x3c\x0f\x5a\x5c\x7c\xf1\x10\xfc\x18\x86\x04\x24\x42\x37\xde\x47\xb1\x8c\x99\xdc\xff\x69\x41\x11\x96\xd9\x14\x82\x6f\x56\x24\x99\x5e\xa6\xe9\x75\xa0\x7e\xe0\x3e\x72\xf3\xaa\x5c\xec\x66\x8a\x16\xbb\xac\xe2\xf5\x40\xb6\xe7\x1b\xd0\xd6\xb5\x35\x3d\xaf\x74\x94\x73\xf3\x25\x17\x18\x72\x36\xf1\xe5\xfd\x93\xba\x93\x5b\x43\x8f\xc6\x57\x6f\xc2\x1d\x56\x79\x6f\xbf\x96\x40\x31\x8d\xf7\x51\xfc\x98\x42\xea\xdb\x2c\x54\x18\xd5\x06\x9f\xec\x17\x97\xda\x28\x03\x83\x5d\x5f\x34\xa2\x03\x57\xc0\xeb\x8d\x2a\x25\xf2\x68\x74\x4d\x8f\xc9\x31\x1f\xf8\x44\x2d\xf8\x52\x1e\x2d\x50\x10\x9e\xc8\x85\xd8\xe9\xc3\xfa\x87\x17\xf3\x53\xb7\xda\xce\xc3\xb7\x1c\xe0\xcd\xf7\x62\x7e\x6b\x80\x84\xb7\x5a\x17\x1d\x1f\x7b\x2a\x16\x0e\xb0\xae\x33\x4a\x37\xf4\x80\x83\x84\x3f\xdc\x6f\x85\xf8\xda\x8c\xf4\xe2\x7d\xc2\x17\x5e\xe7\x1d\xbd\x2e\x83\xbe\xb8\x34\x1c\x19\x91\x70\xca\x1c\x6a\x0b\x2d\xe0\x6d\x16\x03\xa5\x42\x9e\x8c\x8a\x38\xe9\xe4\x1c\x3f\xe0\xa7\x07\xa7\xfa\x1e\xc3\x23\xe6\x0e\x90\xee\x49\x2c\x35\xf0\x7b\x80\xcf\xaf\x1d\xe0\x3c\xe2\x13\x0c\x43\xec\x35\x94\xbd\x12\xee\xbb\x16\xfe\xd6\xb7\x88\xf9\x69\x4d\x79\xc5\xb7\x09\x3d\x5c\x2c\x5c\xd5\x13\x98\x37\x03\x5a\xc7\x99\x5e\xa7\xc5\x66\xb4\x95\xf3\x46\x93\x4a\x09\x68\x25\x4d\x39\x75\xba\x70\x7c\x25\x6d\x08\x23\x37\x12\xdd\x2a\x70\x66\x94\x6a\x23\x88\xbe\x8b\x65\xa2\x31\x6e\x30\xbe\x29\xcf\x93\x86\x36\x9f\x07\xd8\x24\xa6\x85\x99\x05\xf3\x8b\x64\x9c\xcd\x3d\x68\x07\x90\xed\xe8\x2f\xd3\xa7\x94\xee\x82\x7f\x9d\xcd\x68\x13\xd9\x22\xad\xb0\xdc\xb1\x79\xb3\x0b\x64\x9d\x4d\x3c\x0b\x98\x41\x31\x3b\xae\xc2\x04\xae\x6b\xc3\x3a\xd5\x14\xd0\x12\xbc\xf2\xd7\x79\x8b\x66\xb7\x69\xf5\x1a\x32\xe7\xb7\xdf\xa4\xc4\x39\x6f\x45\xee\x5e\x42\x91\x3c\x95\xe3\x8d\x8a\x72\x17\x97\x46\x51\x4a\x05\xa0\xc3\x1d\x15\xbc\x02\x05\xc0\xe1\x3a\xad\x9c\x31\x5b\x0d\xd6\x72\xde\xe0\xa0\x64\x41\x27\x6e\x9e\x1c\x83\x68\x33\xc5\xc2\x0e\xc4\xb9\x4c\xb8\x52\x56\x64\xdc\xd4\x9c\x71\x2c\x6d\xc4\xbc\xd6\x53\x12\xcc\xbb\x61\x68\x89\x13\x49\x7d\x9b\xed\xfc\xa7\x0e\xb0\xf0\xbd\x98\x07\x60\x04\x12\x3a\x7a\x81\xd9\x48\x6f\x64\x05\xbf\x00\xec\x8f\x64\xbf\x64\x06\x91\xfd\xf9\x3b\xc2\x4d\x4e\xc1\xef\x81\xd7\x48\x2a\xe5\xf5\x46\xe0\x35\x92\x6c\x2f\xe0\x93\xf5\xb1\xba\xc4\x84\x04\x95\x39\xe2\x7f\x2e\x12\x72\xcf\x53\x4e\xb3\x55\x12\xc4\xf7\xdf\xdc\xa7\x44\xae\x27\x4a\x13\xd6\x0d\x7a\x83\x9b\x0e\x30\x4e\x5a\x36\x7b\x96\x19\x12\x5a\xe6\xcd\x8f\x98\xbd\x5b\xba\x52\x29\xad\xba\xe4\x80\x79\x35\x59\x43\xe2\x7b\x08\x6b\xe8\xaf\xdf\xe8\xd3\x25\x59\x9d\xb2\x4f\xee\x90\x7a\x6d\x16\xb4\x2e\x1f\x7e\xab\xc7\x48\x72\x8f\x91\x88\x5b\xf1\x74\x00\x27\x51\x91\x8b\x4b\x47\x1e\x83\x7d\x51\x1a\x84\x5b\xb1\xfc\x8f\x26\xd8\x17\xcd\x7b\x54\x25\x1a\xcd\xfb\x5c\x47\x91\x5e\x45\xa1\x47\x75\x39\xd3\xb4\xcf\xb5\x19\x6e\x5c\x80\x8f\x47\x30\x24\x02\x3d\x3a\x42\x7f\x56\xa0\xcf\xa7\x19\x66\x59\x80\x8f\xa0\x7a\xf1\xd5\xe8\x99\x65\x5c\xbd\x3e\x8e\x2a\xe1\x82\x7a\xbc\x9a\xd6\x8b\xcb\x93\xfc\x34\x42\x7e\xa3\x47\xa2\x27\x30\x9a\xa3\x1f\xd4\x2c\x88\x8e\x6c\x8c\x40\x07\xfd\x7b\x0c\xc0\x23\xf6\x00\xc5\x20\x94\x72\x78\x0d\x4c\xa2\x57\xad\xce\x4f\xf4\x2a\x94\xf9\x89\xb4\xd8\xb7\x96\x6e\x48\x42\x4c\x3c\x66\x8c\x07\x81\x31\xa2\x1f\x1d\xe3\xf5\xa6\x63\x50\xd3\xa9\xc5\x68\x0c\x5c\x11\x1d\xd3\xb4\x6e\xbc\x09\xcd\xdf\xe9\x11\x7e\x9a\x71\xff\x93\x26\x92\x82\xeb\xff\x40\xf3\x8f\xff\x2f\x3e\xbb\x34\x6e\x78\x0c\x4d\xf1\x6e\x41\xa3\x8c\xb6\x4b\xeb\x6f\x2a\x19\x23\xa6\x89\xbc\x59\x09\x60\x33\x18\x2f\xac\x40\xc4\x40\x41\x63\xfc\xf4\x23\x91\x77\x16\x05\x29\x93\x57\xcd\x76\xf6\x9a\xc2\xf2\x3b\x7b\x15\xfa\xfc\xce\x94\x28\x67\x42\x7b\x5a\x10\xed\xff\x12\xda\xb8\x1f\xcb\x20\xd5\xd2\x63\xba\x9d\x02\x74\xe9\x6d\x94\x40\xb7\x3b\xa2\x6b\xf7\xea\x99\x8e\x5e\x93\x2b\xbf\x23\x2e\x9b\xee\x28\x02\x21\x08\xe4\x31\x7d\x82\xe9\x49\xfa\x13\x96\x8b\xfd\x09\x75\x42\x6f\x5a\xa0\xb7\x40\xc0\x30\xe3\x8a\xd0\x33\x75\x94\xb0\x42\xdc\x64\xc5\x31\x9d\x0c\x52\x2f\xf5\x54\xb1\x67\x30\x0e\xe9\x4a\x37\x13\xe9\x8e\x1c\xc2\x53\xee\xd8\x18\xa4\xe3\x63\x75\xee\x58\x77\xac\x5c\xa7\x33\x93\x0a\x4c\xc7\x63\x2a\x30\x71\x7d\x4c\x20\xea\xf7\xc8\xa3\xe5\x41\x18\x25\x4d\xef\x6c\xcf\x01\xe2\xd5\x0d\x6c\xd6\xc2\xb0\x85\x51\xab\x7e\x99\x18\x7c\x79\xfb\xb8\xdd\x55\x3d\xc9\xe5\xed\x26\xf8\x61\x18\x88\xb5\x90\x02\x19\xf0\xc2\xe2\x63\x85\xf9\x41\xb7\xb8\x8f\x7c\x03\x9e\x99\x83\x6f\x71\x1f\xb6\x78\xec\x2e\x64\x9b\xbe\x17\xef\x42\x8c\xa7\xd2\xa8\x27\xbc\xd1\x6e\x27\xe5\x8c\x2e\xe0\x9d\x0e\x0e\xf9\x55\x34\xa3\xd3\x32\x5a\x23\xc7\x51\x46\x9d\x2a\x09\x23\xab\xd8\xe3\x29\x7c\x0e\x71\x92\xb7\x91\xea\xf6\x80\x9e\x44\x61\xae\x68\xb0\xa4\x97\x43\xee\x87\xdb\x14\x2d\x8b\x8e\x94\xdc\x29\x7c\x35\x98\x1c\x69\x4a\xf4\x92\x62\x04\x47\xd4\xa9\x1b\x04\x4a\xe7\x3a\x02\x86\x6e\xf4\xd0\xd5\xbf\xc3\x5b\x0b\xbf\xdf\x35\xf9\x69\x3b\x8d\xef\x48\x94\xdb\x4c\x07\x3a\x1b\x7b\xb6\xff\xcf\x4b\x7b\x2e\xab\xcf\xd9\xce\x54\xae\x4c\xf6\xa9\x99\x9a\xe9\xc3\x9f\x7b\x61\xd4\xc8\x21\xcf\x0d\x05\xdc\xab\x60\xf8\x5d\x90\xbd\x83\xdc\x93\xe8\xe2\x47\x37\xec\x2f\xdb\xb7\x7f\xce\x64\xd7\xe2\xd2\x4a\x86\xad\xde\x0e\x7d\xf0\xcf\x25\x53\x67\x7f\x20\xe1\x57\xd4\xf9\xf1\x2b\x02\x3a\x26\xe2\xef\x31\x30\x96\x7f\x4e\xf4\x54\x5a\x10\x0e\x05\xe7\x20\x34\x5a\x89\x34\x42\x9b\xea\x4b\x8a\x26\xb5\x22\x67\x64\x75\x94\x0a\x09\x2a\xd2\xab\x33\x9a\x74\x0b\x35\x1c\x03\xe4\x6c\x88\x4e\x2c\x16\x41\xf2\xca\xf9\xc4\x7e\x4b\x2a\x16\xf1\xdf\x22\x18\x1d\x2f\x78\xa3\x72\xff\x7d\x82\xb2\xfa\x6d\x62\x95\xc8\x98\xbd\x6f\xb2\x95\xb7\xe8\xdf\x47\xb3\xc2\xcd\x82\xb9\x0d\xdf\x08\x95\x22\xdc\xbe\x9f\xcd\x2b\x57\x9a\xb1\x1e\x86\xfd\x48\x5d\x00\xd1\xc3\xb8\x6f\x24\x46\xe8\x1b\x99\x84\x3e\x2f\x23\xbd\x6a\x45\xc2\xe7\xf1\xc2\xe7\xe4\x79\x7f\x7f\x26\xda\x3f\xb5\x51\xc2\x4e\xa0\xc9\x4e\x60\x52\x38\x3f\x5e\x18\xfe\x3d\xd9\x07\x45\xc2\x73\x2d\x9b\xec\x86\xd6\xfe\x9e\x8a\x17\x61\x7f\x4e\x27\xab\xd3\xc7\x81\x59\x4e\x41\x36\xe9\x8f\xc8\x37\x14\xf9\x6e\x9b\xb1\x0e\xa7\x8b\x0d\x41\xbd\x6f\x7e\x1d\x4e\xfa\xe2\xaf\x04\xf5\xc5\x2f\x1f\x4c\xbe\x37\x0a\x3b\x8e\x21\x31\x4e\x05\xb9\x4b\xd9\x44\x4e\xc0\xad\x8e\xd0\x50\xad\x4c\x5b\xce\x87\xc9\x18\x6b\x78\xb8\x8e\x43\x01\xa4\x85\x6b\x12\xa3\x49\xd1\xd9\x3f\xc6\x64\xf4\x9d\xff\x4b\x20\xc6\x3c\xf7\x0f\x11\x18\x25\xf2\x27\x97\xf8\x4b\xf3\x86\xdb\x6d\xa1\xb6\x0a\x3e\x54\x87\x79\x94\x31\x16\x87\x19\x79\x51\x66\x0e\xb3\xc9\x89\x45\x52\x41\x01\x98\x58\x60\xfa\x4f\x01\xd7\x63\xf9\x6c\x16\x65\x3d\x8e\x4b\x29\x98\x60\x48\x6c\xe5\x20\x77\xaf\x46\xa3\xd8\xaa\xab\x37\xb6\x45\x7c\x42\x3c\x0a\x98\xd4\x94\xda\x9c\xa0\x8b\x4d\x8a\x41\xfb\x3d\xc6\x62\xb6\xe8\x28\x45\x24\xa9\xcb\xb7\x07\x61\x2a\x49\x6d\xcf\xe2\x89\x89\xe8\xa2\xfe\x7f\xc5\x4e\x60\xe1\xff\x57\xc0\x34\xf7\xff\x1a\x28\x49\x7b\x7c\xbb\xb4\xc7\xbb\x80\x17\x84\x35\x18\xfd\xb7\x7b\x9c\x9a\xde\x99\xec\xf1\xb6\x62\x5f\x4f\xe3\x6f\x88\xc6\x3b\x24\x6f\x8b\xd6\x97\x5c\x6e\x46\x4e\x7b\x39\x6f\xb3\x99\xc3\x2c\x8c\xd9\xa8\x62\x50\xb4\xe3\x3f\xf1\xf0\x04\x97\x32\xc4\x06\x6e\x58\x77\x0b\x67\x20\x6e\xb2\xb3\xdd\xf8\x2c\x84\x7e\xb6\x75\x9b\xbc\x01\xe1\xf3\xb7\x2d\xc9\x83\x1f\xaf\x1d\xac\x6d\x0b\x6f\xcf\x7e\x16\xc8\x9e\x9d\x00\x52\x27\xec\xbd\x68\xf8\xa1\x63\x56\x55\x0d\xbd\xdc\x57\x0a\x9f\x5e\x5d\x9a\xdd\x1d\xb8\x7c\xab\xb9\x5c\xdf\x4d\x3a\xa3\x21\x95\x27\xb9\xa0\xaf\xd0\xbe\x38\x87\xec\x8c\x16\x45\x62\x6e\xaf\x4e\x6d\xc0\x39\x6d\x85\x9c\xb5\x5a\x91\x52\x95\x9d\x01\x21\x94\x70\xb8\x26\xde\x7b\x68\xa6\x29\x92\x0b\x92\x77\x14\xd6\x11\xb9\x32\x97\xc9\xa0\x8c\xec\x39\x08\x53\xe1\x0f\x69\x97\x00\x7f\x26\xa2\xcf\xb5\x31\xc7\x4e\xbd\xfa\x0e\xff\xec\x24\xd3\xfe\x9b\x60\xc8\x9b\xcc\x77\x5f\xc3\x0c\xb8\x7a\x04\xfc\x43\xf6\xd3\xde\x92\x21\x67\xdf\x7d\x30\xf4\xd0\xd0\x86\xe7\x7b\x82\x8e\x60\x85\xd4\x87\x5f\xeb\xef\xc3\x57\x74\xa6\xae\x88\xa8\x29\x4d\xfa\xcc\x70\x2f\x36\xb2\xf2\x85\x26\x82\x7b\x77\x59\xd0\x00\x82\x6c\x59\x62\xd7\x37\xcb\x0e\xa2\x60\xc7\x8e\x22\x8c\x64\x6a\xa0\xd7\x11\xe9\x5c\x5d\x1a\xa9\x31\xb7\xa8\xe1\xe5\x94\x99\x61\x6d\x6c\x39\x1f\x6a\xa3\xcc\xc0\xc8\x98\x71\x6b\x9e\x05\xd9\x6f\xb3\xcd\x6c\xd3\xd0\x9a\x98\x1a\x5e\xf3\x11\xe0\x64\xe4\x82\x7c\x02\xf4\x2f\x1a\x52\x7c\x0f\x98\x3f\x47\xe4\x21\xd7\x8c\x88\x15\x2f\x78\x06\x02\x00\xf6\x32\x79\x34\x92\x96\x9b\x89\x63\x08\xee\x84\x2d\xf8\x52\x8c\xe1\x54\xe3\x95\x9e\xbe\x5b\xd7\x5f\xa6\x77\x74\xca\xaf\x2e\x1c\x3a\xbe\xe3\x5b\xc6\x2e\xc9\xb7\xc0\xd9\x3c\x79\x2b\x11\x8f\x22\xb1\x6d\x6a\x87\x27\xb2\x53\x3b\xf6\x62\x1d\x0f\xbf\x04\x5d\xe0\x05\xd6\x96\x5c\xdc\x61\x52\xce\x80\xee\xd9\x63\x7a\x2e\xe8\x0e\x9f\x07\x4f\x44\xd0\xa5\x18\xae\xe2\xa3\xc8\xd8\xcc\x44\x77\x5c\x5b\x21\x97\x81\xfd\x94\x27\xd1\x3b\x67\x50\x5d\xa8\xee\x54\x3f\xea\x88\x37\x47\x95\xe0\x48\x48\x4a\x60\x14\x09\x09\x11\x49\xd4\xf6\x58\x50\x1a\xfb\x30\x96\x8e\xf5\x9a\x8b\x63\x8a\xd3\x8a\x99\xe1\xc5\x53\x8b\xbf\x28\x66\x0a\x8a\x01\x4d\x15\x7b\x8b\x69\x25\x53\x9c\xda\xbb\x86\xa7\x52\x5b\xa7\x7a\x53\x19\x33\x93\x8a\xe5\x92\xaa\x35\xe4\xa7\x76\x8f\x68\x5f\xc8\xaf\x8d\x00\xfa\x88\xc8\x88\xd6\x11\xcc\xa7\xdd\x01\xd5\x5d\xdf\x3d\xb2\x3b\xa3\x61\xba\x47\x74\x8f\xc8\xcc\x53\xaa\x4d\x4c\xa6\x2d\xb3\x80\xd7\xd9\xac\x94\x78\x78\x88\x2b\x07\xb2\x84\xfe\x8f\xb2\x32\x41\x5a\xb8\x9b\x5b\x40\x6a\x2c\x2f\x2b\x9b\x6c\xbf\x55\x36\x19\xdf\xd1\x95\x42\xee\xd0\xb0\x06\x8a\x4c\xff\xf9\xc2\xf3\x8c\xd8\x20\x51\x83\xa0\x1b\xcf\xc1\xa3\xe2\x2e\xb8\x8e\x2f\x39\x4f\xfa\x87\x9b\xd0\x0b\x01\xc8\xcd\x5b\x5a\x54\x3e\xa9\x27\x0c\x09\x5c\x85\x0e\x86\xb3\x40\x8e\x26\xe3\xf9\x94\xec\xd6\x1d\x7b\xb7\xf5\xe4\xf4\x64\x3b\xb6\xb9\xe1\xbf\x03\xfd\xef\xee\x49\xff\x36\xa5\x65\x71\xbb\x29\xde\xbe\xbd\x3b\x4e\x69\xb0\x05\xdd\x93\xce\x0d\x33\x5f\x70\xd6\x7f\x16\x19\xdb\x36\xc1\x1d\x97\x1d\xf0\x0b\x0f\xfa\xfd\x42\x6a\x3a\x88\x15\xfa\xb7\xed\xcd\xfd\xc2\x7a\xd1\x2f\xf4\x63\x37\x32\xb9\x7e\x1b\x46\xb0\xa8\x09\x8d\x6d\x94\x1f\x37\xf9\x41\xc0\xa2\x92\x7d\x42\x70\x2e\x09\x8d\x73\x02\x8d\xe1\x84\x46\x6a\x30\x26\xe1\x30\xb2\xd7\x04\x4c\xc2\x37\xe9\x70\x11\xb3\x20\xac\x89\xff\x9b\xc1\xd5\x89\xb1\x1d\x7a\x06\xfc\x4b\xf4\x91\xbb\xfa\x7b\x49\x45\x3a\x47\x25\x3a\x77\xe9\x6a\x01\xaf\xdb\xde\x1c\x1f\xf1\x9c\x44\xe7\x2e\x5d\x28\x44\x67\xb9\x41\x98\x1d\x04\xc7\xac\x56\xc2\x31\x7b\x93\x8e\x21\xfc\xd0\x62\x80\x16\xc0\x98\xad\x13\x71\xcc\x30\x3f\xbf\x89\xfc\x24\x4b\xbd\xad\x02\x9d\xa3\x12\x9d\xbb\xf4\x6c\xa1\xef\x32\xb4\x39\x06\xdb\x39\x89\xce\x5d\xe2\xfb\x23\x7e\x5a\x06\xf8\x11\xe2\xd6\x5a\x09\xe7\xe8\x4d\xf0\xeb\x23\xfc\x08\x78\xb6\x75\x22\xb6\x12\xe6\x99\x16\x7b\x6d\x2d\x12\x3f\x02\x9d\xa3\x12\x9d\xbb\xf4\xca\x47\xf8\x11\xe8\x9c\x93\xe8\xdc\xa5\x27\x09\x7a\xcf\x1a\xe0\x47\x88\x81\x6b\x25\x8c\x89\x37\x69\xed\xe3\x30\x26\x90\x6e\xac\x93\x30\x26\x02\xf2\x49\x94\xf8\x11\xe8\x1c\x95\xe8\xdc\xa5\x37\x0a\xf3\x95\xd8\x1c\xef\xe2\x9c\x44\x47\x92\x4f\x8b\xa6\xf3\x75\x89\xf0\x93\x2e\xf2\xd3\x5a\xe4\x27\x5a\xe2\x47\xc0\x21\xa8\x13\x71\x08\x02\xfc\xa0\x10\xb1\xc9\x7c\x5d\x22\xfc\xa4\x8b\x63\x8d\x13\xf8\x89\x69\x8e\x67\x70\x4e\xa2\x73\x97\x5e\xf2\x08\xe6\x8b\x10\xdf\xd7\x4a\xbd\xd1\xfe\xf5\x1c\xdc\x1b\x2d\xc4\xf7\x75\x62\x7c\x8f\xf9\x81\x84\x1f\x20\xc2\x1c\x07\xf2\x04\x47\x25\x3a\xd2\x7c\x45\x35\xcf\x13\x9c\x93\xe8\xf8\xe5\x03\x92\x03\xfc\x24\xc0\xac\xff\x47\xd9\x77\xc0\x35\x79\xad\xff\xbf\xe7\x1d\x09\x09\xd9\x3b\x64\x40\x08\x61\xef\x00\x01\x07\x04\x41\x45\x51\x44\x50\x21\xe2\xde\x20\xee\x51\xdc\x88\xa3\x4e\x1c\x55\xeb\xac\xa3\xee\x5a\xf7\x6a\xb5\xb5\x55\x6b\x6b\xab\xb5\xb5\xf3\xda\xde\xdb\xde\xae\xdb\xdd\xfb\x6b\x7b\x3b\x94\x1c\xfe\xe7\x9c\xf7\x4d\x08\x68\xef\xef\xff\xab\x1f\x89\xa1\xef\x79\xcf\x73\xd6\xb3\xce\xf3\x7c\x9f\x50\x6c\x03\xfa\x5f\xf4\x64\x01\xdb\x20\x2f\x14\xdb\x20\xf8\xfb\x37\x60\x5e\x08\x2e\x41\xf0\xf7\x40\x86\x9e\x6f\xc3\x25\x10\x7e\x8f\xec\x42\x16\xe9\xcc\x4b\x91\xbc\x8e\xa6\x9c\x5e\x55\x94\x44\x62\x88\x08\x0f\x67\x22\xc8\x65\x1c\xcb\x50\x69\x6d\xd9\x2b\xbc\x13\x5a\x45\x71\x9e\x18\x2a\x3b\x2b\x4e\xc4\x79\x92\x41\x10\xc0\x3a\x78\x51\x68\x07\xac\x09\xca\xfd\x9f\x44\x81\x2d\x60\x57\xfc\x4d\x98\x14\x0d\xcc\xc0\xb7\x67\xca\xac\x59\xc7\xfb\xaf\x9c\x06\x54\x87\x8f\xdf\x1c\x34\x39\x21\x0d\x5c\x40\x8a\x5f\xe5\xf6\x83\x93\xc0\x80\xcf\xa6\xe7\x3e\xbe\xe1\xd9\xfe\x87\x2e\x3e\x56\x31\x6a\x50\x5d\xbf\xf5\x4b\x0e\xae\x19\x77\x78\x48\xea\x4a\x44\x9b\x05\x0e\x62\x8b\xd8\x32\x44\x5b\x8c\x57\xed\x90\x4a\x4d\x56\xb9\x9c\xb5\x5a\xf5\x38\x34\x92\xb5\xb4\xdd\xb8\x06\x88\xc3\x17\x4b\x02\x75\xac\x38\x94\xbc\x40\xdd\x33\x03\x73\xef\x3d\xd8\x0b\x6b\xc9\xb3\xc0\x8c\xae\x33\xe0\xd5\xdd\x36\x90\x04\xe2\x57\x4e\x1e\x35\x73\x93\xe7\xe9\xbe\xbf\xbc\x7c\xe2\xe2\xc5\x7e\xc0\xba\x07\xfe\xfb\x83\x82\x1d\x55\x20\xec\x50\xff\xc4\xac\x61\x96\x4d\xf9\xf3\x0f\x4c\x1c\xd8\x7f\x50\x8d\x63\xf5\xaa\xd5\x2b\x6e\xae\xaf\x6c\xc3\xfa\xc1\x7b\x32\xe9\xd1\xfe\x28\x01\xe7\x6f\x95\xe8\x32\xc1\xf9\x4b\xf2\xea\x39\x96\x15\xcb\x4d\xfa\xc8\x28\x6b\x63\x84\x97\x62\x30\xc8\x9f\x58\x08\xf5\x8b\x20\x46\x56\x81\x50\xb0\xfd\xaf\x01\xfd\x82\x76\x17\x18\x74\xce\xe6\x74\x30\xeb\xbf\xe3\xab\xe1\x4b\x2b\x46\x10\x38\x1c\x46\x17\xb4\xbe\xb8\xe2\xad\xa7\xe7\xdc\x86\xd0\x53\x8c\xcb\xe2\x7b\x12\x07\x0d\xc4\x60\x38\xdc\x73\xc4\x08\x13\xf2\x13\x90\xae\x86\xec\x30\xca\x40\x99\xbd\x72\x92\x07\xc8\x2a\xc2\x65\x0c\x15\x2e\x84\x6d\x16\x10\xe5\x24\xa4\x7b\xb7\x38\x10\xc3\x47\xdf\x06\x62\xf9\x90\xba\x01\xd7\x7b\xdf\x42\xc6\xdf\x69\xdb\xad\xbf\x6d\x59\xab\x85\x7f\xc2\x2a\xae\xb4\x5b\xe6\xf0\xc1\x63\xca\x1f\x7c\xc9\xf5\x78\xf2\x99\xa5\xab\x7b\x0f\xbf\x7f\x0e\x63\xba\x88\xd1\x5a\xf6\x44\xba\xbc\x93\x4a\xa7\xf2\x29\x44\x7d\xb4\x85\xb1\x74\xb9\x08\x22\x2e\xf8\x22\x2d\x56\x25\xa5\xcb\xc2\x91\x69\x11\x3e\x27\x25\x97\x69\x18\x4a\x26\xd1\xe9\x18\x89\x24\x95\xa8\xf5\x71\xed\xa1\x52\xf9\x15\xd7\x04\x2d\xf9\x82\x1b\x81\xcc\x18\x01\x3a\x55\xa5\x09\x6a\xf7\x02\xc1\xe4\x4e\x01\xef\xd3\x02\x10\x9a\xa8\x47\x0b\x38\xfa\x82\xb0\xa7\x8b\x0b\x9f\x1c\xbf\x64\xde\xaf\x5f\xd6\x4d\x37\xd1\xf2\xe1\xe7\xfe\x63\x2b\xca\x9f\x34\xb3\x7c\x57\xf5\xc5\xe4\xea\xda\xea\x1d\x0b\x13\xe1\x82\xee\xa5\x93\xb6\x95\x0e\xaa\xdc\xb2\x8f\xfe\x3c\x35\x33\xb6\xd8\xc9\x79\x90\x74\x3f\x5e\x57\x7d\xf2\x38\x98\x00\x76\x0e\x1e\xd5\x17\xfc\xf0\x40\xbb\xdb\x58\x3f\xbc\x66\x65\xff\x17\x7a\x3e\x36\xeb\xe8\xf0\x7b\xc7\x67\x4f\x69\x06\xf2\xab\x4b\xa7\xc1\xeb\x2d\xff\x88\xcd\xb6\xe9\xac\x96\x4e\x5d\x4b\xf0\x9c\xb8\xd1\xf9\x7f\x9e\xdb\x42\xaa\x21\xe6\x50\x85\xde\x68\x8b\x75\xa4\xcf\x62\xa1\x0c\x8e\x64\x47\xf2\x08\x9f\xd8\xe0\x70\x20\x3d\x3a\x7e\x24\xd2\xac\x73\x18\x85\x7b\x44\x30\x3c\x2d\x58\xa7\x14\xeb\x92\x7c\x9c\x3c\xc9\x82\xc6\x91\x05\x22\x25\xff\x11\x88\x3d\x28\xc0\x7a\x65\x8c\x47\xcc\xea\x83\xf5\x40\xe3\xb4\x21\xf0\xe2\x39\x80\x89\xbb\xf2\xee\xc5\x6d\xe0\xb1\xc6\x2d\xf0\x9b\x8b\x1f\x7d\x3f\xea\x58\x3d\xf8\x18\x48\x7f\x35\xc3\xb7\x36\x2c\x9e\xbc\xa7\x7a\xe1\xcc\xed\xdb\x37\x3c\x76\x6e\xf4\x8e\xf5\xd7\x6e\xf9\xeb\xb8\x2d\xdc\xfe\xd5\xab\xdf\xb5\xb1\xda\x4d\xd3\xd7\x7e\x34\xeb\xc4\xbe\xc9\xa7\xa7\xab\xd9\x82\x9d\xdb\x4f\x32\x4d\xe2\x17\xfa\xf6\x2f\x5a\x59\x35\x78\x02\xd3\x72\x66\xfc\xec\x81\xdb\x86\xd6\xcd\x78\x96\x15\xe2\xc1\x87\xa1\xb1\xee\xe2\xee\x52\x09\x68\xa4\xc8\x5a\x51\xd8\x6c\xc8\xee\x49\xec\x8f\x86\xa6\x8f\x09\x73\x52\xfa\x8c\x72\x9f\x3e\x70\x9f\x1d\xb4\x56\xc8\x61\x10\x68\xf6\x18\x1e\x35\x36\x7c\xab\x4d\x22\x5f\xf1\xb5\x77\x70\x48\x18\xb4\xe7\xd0\xb0\xe6\xca\x4e\x9e\xe1\x37\x0f\xad\x07\x63\x67\xad\x81\x7f\x9c\xbd\xfe\xde\xd0\x03\xf5\xa0\x7a\xf8\xd3\x27\xdd\xc3\xa6\x4f\xef\x37\xf9\x99\xa1\x4b\xe7\x9e\xbe\xbe\x92\xa9\xeb\xb5\x69\xa0\x77\x82\x6d\x5a\xfd\xf3\xab\x3e\x8c\x63\xcd\x7b\x67\x3c\xf9\x43\xd3\xc5\xa3\x0d\x2f\x35\x9a\xd9\x88\xb5\xa3\x9b\x5f\x2d\x9f\x96\xb8\x6d\xc2\xc8\x89\x4b\xc6\x9c\x98\xd8\xd0\x70\xf3\xf8\x8c\xa5\x24\xbf\xe2\xd3\x56\x40\xe2\x99\x70\x9d\x2d\xb5\x9e\xd3\x71\xc8\xce\xd1\x69\x3a\x44\xef\x14\x04\x52\x96\x79\x7b\x92\x67\x91\x71\xbc\x22\xea\xf0\x30\xf7\xf9\xc0\xa5\x16\x40\x57\x4e\x9f\x6f\x37\x6d\xd2\xea\xf3\x0b\x5b\xbe\xb1\xb2\x47\x76\xae\x7e\xf0\x59\xdd\xa8\x98\x59\x39\xd1\x31\x59\xd1\x59\x69\xeb\x70\xdc\x52\x6b\x38\x89\x5b\xd2\xe2\xfe\xb4\x9c\x86\x2b\xf7\x85\x6b\xf4\xb8\xbf\x72\x1f\xad\xfc\xeb\xfe\xc4\x71\xb8\xcc\x00\xee\x6d\x55\xa0\x32\x35\xb8\xb9\x60\x76\xee\x26\x95\xb9\xd1\xdf\x64\x61\x4e\xe0\x0a\xd5\x55\x83\x7b\xac\x8c\x36\xc7\x65\x0d\x5f\x19\x82\x55\x3d\x2e\xa8\x8b\x6d\xa7\xa4\x04\xb7\x82\x56\x77\xd4\xc5\x6e\x05\xfd\xf5\xdb\x79\xc9\xde\xa5\x0d\x8f\xa8\x38\x14\x7f\x96\x9a\x0b\x66\x0b\xf8\xb3\xc5\x21\xf8\xb3\x6d\x98\x3c\x44\x9f\x20\x7e\xd4\xcc\x8e\x3e\xda\x98\x50\x1f\x2d\xd1\x29\x44\x75\x01\x1f\x4f\xd0\x27\x5e\x0e\x4c\x88\x8b\xa9\xd9\x38\xec\xa3\x8d\xf3\xca\x54\xe8\x87\x44\x5a\x12\x87\x3d\xa9\x49\x02\x36\x4a\xc7\x3e\xfe\x0c\xfa\x6a\x13\xda\xe9\x3e\x0b\x89\xfc\xe7\x7d\x48\xbb\x84\xf7\x0f\x00\xbd\xf1\xfb\x99\x5c\xfc\xfe\x5c\xfc\xfe\x5c\xfc\xfe\xdc\x87\xde\x4f\xe6\x2d\xb3\xfd\xbc\x45\x75\xd4\x89\x6e\x05\xef\x17\x84\x79\x73\xb4\xbb\xa3\x08\xa1\xb1\xcd\x9f\x1c\xd5\x5e\x3f\x6b\x9b\x03\x7a\x7b\xc0\xeb\xcb\xcf\x01\xe3\xc4\x34\x3a\x31\x8d\x4e\x4c\xa3\x33\x94\x46\x1e\xfb\xa4\x2e\x80\x7d\x22\xb4\xc2\x48\x9e\x1d\xf1\x53\x2a\x04\xfc\x94\x36\x0f\x1a\x30\xa9\x83\xb2\x2d\x03\x0e\x62\x66\x90\x9c\xaf\x48\x2a\xe9\x14\xa3\xc7\xdc\x5b\xe6\x03\x2a\x19\xc3\x30\x52\x35\x25\xb5\xa1\x5f\x9c\xf1\xc9\xa5\x56\xa1\x88\x0d\x3a\xd2\x46\x3e\xbd\x23\x84\x23\x23\x86\xec\x01\xda\x76\x3c\x98\x71\xc2\xef\x4a\xba\x20\xae\xbb\x67\xd0\x85\xe4\xab\x55\xfb\xa7\x81\x84\xb1\x69\x19\xb1\xc5\x31\x98\xd3\x96\x71\xb7\xee\xcf\x30\xf1\xcc\xf5\xc5\x59\x67\x07\x72\x7f\xfc\xb9\x3b\xc0\x51\x7b\xf2\x7c\xc6\x85\xe4\x0c\xc6\x9a\x4b\xa1\x3a\x51\xa5\x17\x12\xe2\x5d\x71\xae\x30\x57\x2e\xa6\x2e\xdc\xe7\xb2\x1a\x98\x72\x9f\x41\x65\xcf\xc0\xdf\x15\x3e\xad\xc6\x1a\xa6\x51\xd8\xed\x61\x0a\x65\x98\x9e\xf8\x25\x48\x96\xae\xe0\x1f\x0e\x4a\x1b\xd5\x8d\x4c\x01\x4f\xbe\x23\x30\x1d\x92\x32\x48\x42\x77\x18\x90\x36\x87\x8c\x28\x28\x54\x5e\xce\xee\x3a\x68\x79\x54\x1b\x54\x1d\x5d\xbc\xbe\xa6\x76\x34\xd0\x36\x96\x74\xa9\x9b\x5e\xb6\xdb\x87\x87\xb9\x7d\x61\xb3\xf6\xdb\xb4\x8c\xdc\x41\x64\x94\x4c\x49\x51\xee\xf1\x7d\xa1\xc8\x75\x53\x86\x8d\xab\xeb\x35\xc6\x3f\xd9\x34\x61\x44\xcd\xaa\x4a\x34\xf6\x23\x23\xe8\x7b\xa3\x5a\x6a\x62\xb3\x33\x42\xc6\x9e\xd4\xfa\x1d\x9b\xc5\x0d\x20\x39\x4b\x9d\x2e\x98\xd5\x1a\x35\xe2\x0d\x78\x21\xbc\x4a\x5f\x38\x45\xd3\x12\x83\x4e\xa3\x94\xcb\x0c\x12\x17\xb9\x45\x94\x04\xeb\xcd\xdc\x70\x93\x24\xb9\x40\x8e\x46\xc7\x01\x05\x21\x9b\xda\x2f\x15\x2d\x2b\x29\x9a\x38\xbd\x7c\x77\xd5\x8b\x68\x04\x3b\x16\x4e\x3d\x6c\x3d\x3a\xb5\x21\x07\x9c\xb4\xc2\xf2\x49\x68\xc9\xbc\x31\x5c\x76\x6a\x7e\x19\x78\xd7\x54\x3b\x62\xc8\xca\x0a\x44\xf4\x33\xc3\xe8\x22\x21\x10\x7e\x00\x5e\x36\x47\x64\x4e\x6e\x4f\x24\x07\xa3\xd0\x7e\x3e\x81\xf6\x52\x38\x95\x46\x75\xa6\xfa\x7a\x9d\x51\x54\x9a\x4c\x1d\xe3\xb4\xdb\x6c\x4e\x35\xa3\x88\xc8\x0c\x8b\x08\x2b\xf7\xc5\x46\xa8\x72\x69\x2d\x5d\xee\x4b\xd1\x1a\x14\x2a\x32\x02\x45\x68\xc9\xdb\x80\x07\x95\xc4\xb7\xe2\x3f\x24\x20\x4a\x1b\xea\xd8\xc3\x60\x1c\x42\xb9\xdb\x10\x0f\x20\x1f\x86\xa4\xe7\x53\x68\x48\xa5\x5c\x01\x01\xee\xf6\xa0\x3e\xf3\x7a\xd7\x95\x4d\x2d\x00\x9b\x1d\x2b\xc4\x2a\xa6\xfa\xe9\x81\x43\xc7\x9c\x9f\xd3\xcb\xa7\xa6\xb9\x91\x7b\xfa\x38\x03\xbf\xd8\x1c\x0d\x76\x91\x47\xfb\x4e\x29\x04\x3d\xdf\xda\x07\xe2\x0f\x7f\x7a\x08\xbe\x02\x8f\xac\x2f\xea\xbb\xff\x85\xa3\xf7\xc0\xf0\xab\xdd\x2a\xec\xe0\x57\x38\x6f\x17\xfe\x0a\xf7\x5e\xdd\x4f\x8f\x7e\x6b\x1f\xfc\xf0\xf0\xa7\x7b\x41\x37\xe2\x8f\xa5\xec\xb0\x9a\x7d\x16\xed\x5b\x7e\x0e\xbc\xde\x68\x3a\x37\x25\xb7\xdc\xa7\x4d\x51\x85\x65\xc6\x66\x96\xfb\x6c\x76\x67\x8c\x5a\x96\x96\x16\x63\x67\xe4\x11\xb1\x06\x87\x45\x8e\x43\x0e\x91\xc6\x88\x47\x4b\x86\x1b\x32\x07\x42\xc1\xdf\x00\x90\x9d\x27\x10\x6a\xc5\x8f\x91\x2f\x77\xa9\x0d\x9d\x09\x23\x08\x99\x26\x96\x0a\x8c\x1b\x4e\x0c\x1d\x77\xd9\x00\x35\x2d\x1f\xb6\xa7\x7f\xc8\xb8\xe1\xe8\xc0\xb8\xe9\x5f\xf8\x01\x1d\x02\x9d\x41\x95\x30\x6e\x34\xd0\xee\xfd\x7a\xc2\x48\xb0\x63\x97\x30\x0d\xfb\xfd\xbb\xf8\xe9\xd9\x0b\x5f\xe4\xfd\xd0\x8b\x5a\xd7\x70\x4d\x68\xed\xe5\x94\x8e\x32\x52\xe9\x5e\x93\x41\xa1\xa0\x87\xfb\xf4\x12\xb1\x42\x21\x12\x8b\x35\x23\x7c\x52\x31\xc3\xf2\xb7\xf7\x37\x04\x4d\x8f\xe8\x7f\xfc\x38\x1d\x8c\x03\x38\x3d\x48\x33\x35\x02\x37\xc0\xe1\xd3\x69\x40\x01\x8c\x62\x07\xb3\xd7\x0b\x27\xc1\xca\x7d\x63\xfa\x30\xec\xdf\x12\x40\xd1\x3e\xe8\x39\xea\xb7\xa4\x82\x51\x72\x53\x6a\xaf\x73\x7f\xa3\x5a\xc1\x42\xa8\x98\xc9\x75\xff\x09\xcc\xf6\xff\xd0\xd2\x93\xd6\x82\x9d\xd5\xc7\x6b\xd6\x5c\x69\xc1\x3e\xcc\x03\xad\x8f\x71\xa3\x84\x9c\xac\x6e\xde\x68\x75\x58\x58\x94\x52\x66\xa3\x1d\x62\x96\xb3\xc8\x38\x19\xa7\xb4\x58\x9c\x38\xac\x84\xd5\x2a\x95\xd2\x20\x9e\x8a\xea\x7a\x40\x11\x25\x37\x66\xc6\xb6\xc8\x1d\x37\x83\x63\xbc\x49\x49\x0f\x02\x5c\x12\x27\x26\xce\x3e\x1e\xbc\x44\x28\xd8\xa5\x00\x34\xfb\xd2\xbe\x2f\x12\xb5\x67\x39\xa9\xbf\xa1\x70\x33\x0f\x5e\x72\xbd\xfe\xc4\x3e\xc0\x64\x61\x04\x93\x9d\xa3\xfd\x5a\x96\x9e\x51\x38\x16\x03\x97\x70\xb7\xe0\x97\xdd\x47\x16\x46\x47\xb6\xfc\x7d\x24\x01\x30\x19\xf3\x37\x50\x58\xbf\x83\x80\x98\xf4\x6a\x39\x93\x18\xc3\x48\x0a\x08\x80\x09\xf1\xc9\x3e\x87\xd4\x72\x05\xc1\x69\x4a\xa4\xca\xbc\xf1\x66\xab\x51\xa6\x97\x55\xf8\x22\x9c\xe1\x9c\x53\xaf\xe6\xc2\x68\x75\x98\x3a\x4c\x4f\xeb\x15\x58\x07\x63\xa8\x18\x9a\x8a\x0d\x80\x99\xa4\x92\x08\x99\xf6\x89\x48\x6d\x9b\x8d\x64\xef\x6b\xdd\xc0\xa0\x17\x67\xf3\x25\x4b\x84\x40\xe0\x38\x10\x18\x61\x60\x78\x34\xc3\x14\x16\xf8\x9b\xd1\xd9\xbf\x9a\x08\x23\xb3\x2a\x02\x68\x26\x53\x06\xc3\xaf\x9b\x81\x77\x62\xe5\x81\x6f\xe0\xc7\x06\xf0\x46\x74\x22\x46\x3b\x61\xcb\xe4\x60\x35\xec\x55\x75\x46\x21\xee\x9b\xee\x57\x5b\x08\xb2\x49\x14\x2c\x05\xbf\x8e\xba\x4e\xe0\x4d\xfc\xb1\xfd\x73\xe8\x5b\x61\x65\xbb\x70\xd5\xf7\x29\x41\x4c\xdb\x18\xaf\x46\x4a\x33\x38\x0b\x8d\xc1\xb8\xbe\xa1\x88\xb6\x6d\x88\x03\xa1\x18\x74\x0e\xf1\xd2\x59\xab\xec\xab\x66\x5c\x99\x01\x9e\xb0\xc3\x49\x55\xf4\x1e\x3b\x3d\x64\x27\xdd\xd7\x7f\x66\x27\xf4\xee\x0c\xd9\x0b\x2a\xa4\x79\x39\x91\xe6\x45\x91\x5c\x07\x16\xb1\x25\x99\x94\x11\x61\xc0\xe8\xeb\x84\x7d\x92\xfd\xe8\xc6\xf2\x0d\x87\xf1\x3b\x41\xb0\x7a\x01\xe7\x71\xb2\x0d\xb0\x6e\xf9\x8b\xbd\xe0\x88\x7d\xf4\xec\x89\xb0\xbb\x9d\xa9\x9b\xb4\x6f\x52\xbc\x1d\x1a\x5e\xde\xc8\x1e\x81\x12\x7f\x19\x98\xe7\x6f\x61\xe4\xb4\x6b\xe7\xe3\x8f\xef\xfc\xe9\x27\x62\x9b\xd5\x22\x39\x56\xcc\x96\x22\x29\xe6\xf5\xea\xec\x99\xa9\x66\xf4\x87\x49\x4c\x4c\x2f\xf7\x25\xaa\xb8\x70\x89\x52\xc2\x03\xcf\x28\x19\x82\x02\x62\x08\x05\x9e\x09\x29\x36\x44\x72\x7c\x01\x8e\x05\x8d\x33\xe2\x50\x50\x21\x47\x2c\x8e\xc4\x83\x92\xe8\xd0\xa8\xec\xac\x54\x3a\x2e\x95\xe6\xcb\x2f\xe3\xb8\xff\x28\xbd\xce\x4e\x1b\xed\x34\xf3\x1b\xfc\xf9\xc7\xe8\xa2\xed\x06\xaf\xc5\x5b\xd8\xbb\x68\x6a\x6e\x9f\xb9\x59\x39\x53\xdc\x9a\xf8\xf0\x2d\x71\x8f\x35\x80\xe4\x84\xde\xe3\xbb\xce\x9b\x5d\x78\xff\x8b\x33\xcf\x83\x83\xec\x27\xf0\x97\xb8\xee\xc3\x73\xd7\xce\x2a\x02\xc3\x8f\xbd\x2a\xbd\x6b\x33\x75\x9d\xd6\x39\xb1\xa4\xa2\x72\xff\x00\x7b\x81\xa5\xaa\x2a\xff\x5a\x7c\x76\xac\x4d\xed\x28\x1a\x56\xb4\xff\xb9\x85\xab\x75\x9b\x8f\xb9\xd2\x9d\x16\x65\x6c\xf1\x18\xde\x16\x2d\x44\xe3\x9d\x41\x62\x6f\xdd\x5e\x99\x2d\xc2\x12\x51\xee\xb3\x28\xa5\x61\x8a\x30\x5e\x74\x2b\x8c\x26\xc4\x1e\x70\xc4\x94\xa0\xea\xb6\x81\xec\x90\x6b\x9d\x4c\x3b\x88\x04\x6d\x23\x4c\x45\x7c\x20\x15\x99\xf6\xc2\x4d\x4e\x6c\xd7\xbe\x79\x39\x4d\xc6\xe4\xa8\xec\x12\x34\x90\xbc\xf4\x92\xbc\xb4\xb9\x36\x6f\xe9\x4e\x0b\x93\xe1\x7f\xc2\xc2\xe4\x46\xac\xd6\xa7\x54\xdc\x74\x5a\x8b\xa7\x75\x49\xb7\x65\x97\xbe\x9c\x12\xb9\x9a\x89\x59\xbd\x52\xc8\xe3\x60\xf7\x21\x1b\xcd\x88\xf1\x92\x19\xc3\x08\x1f\xc0\x25\x3c\x18\x25\xa5\x0c\x1b\xe1\x53\xf2\x81\xa6\x21\xd3\x8d\x41\x62\xb4\x38\xd3\x32\x9b\x47\x53\x12\x1c\x23\x34\x2b\x66\xc0\x80\xda\xf4\x3e\xef\x7f\x00\x3f\x5a\x7a\x25\xf3\x44\x31\x48\xb9\xfb\xc9\xe7\x9b\xe1\xcf\xcf\xf6\xa6\x4d\x0a\x40\x7d\x0b\xf4\x33\x1f\xb3\x1d\x3c\xf7\xf6\x2b\xe7\xe0\xc7\xfb\xc5\x70\x29\xee\xfb\x37\xd4\x77\x0a\x92\x09\x3a\xca\xe4\x0d\x97\x48\xe4\x94\x5e\x2e\xc6\xa1\xb5\xc1\x0d\x8d\x3b\x13\xb2\xe6\x42\x6a\x2f\x33\xe0\xd9\x01\x47\x6f\x0c\x1d\xff\x42\xf1\x79\xcf\x1f\xfb\x8f\x5d\x7c\xe7\x72\x57\x70\xf2\xf2\xce\xa1\x43\xae\x2b\x36\x1f\xdf\xbf\xf5\xd4\x9f\xa9\xf0\x06\xe1\xbd\x7f\x08\x18\x67\x6a\xca\x4a\xb9\x70\x5c\x80\x19\xc9\xf6\x91\x3e\x83\x58\x19\xad\x8f\xd6\xa3\x43\x14\x2d\x8e\x66\x25\x12\x07\x06\x73\x61\x23\x42\x91\xce\x02\xd7\x19\xbc\x91\x26\x88\x1c\x82\x76\x16\x28\x2f\x19\xc0\x39\xc3\x31\xe3\x62\xc7\x43\x58\x67\xf1\xde\xc5\x11\x8b\x8f\x81\x9d\xe0\xe2\x99\x5d\x1b\x9f\x78\x09\xbe\xda\xe2\x00\xa3\x22\xe0\x53\xd1\x40\x0a\x56\xc4\x3c\xbe\xec\x93\xfe\xff\xe4\xf1\xce\x40\xc9\x32\xa6\x01\xfe\xbc\xf2\xd5\x28\xf5\xe6\xfa\xab\x47\x97\x9d\x08\x60\x9d\x21\x7d\xc7\x80\xf4\x86\xef\x48\x8e\xbb\x83\x4a\xf4\xea\x19\xab\x42\xa9\xc0\x69\x3e\x4a\xa5\x58\xaf\x66\xc4\xc6\xb6\x48\x06\x82\x37\xe2\x16\x8e\x28\x09\x60\x20\xc9\x5c\x71\x42\x44\x34\xb9\xfb\x02\x24\x78\x81\x98\x90\xec\xb8\x65\xf6\x65\xfa\x6c\xf8\x63\xcb\xcd\x8b\x40\x6b\x5a\x62\x5f\x32\xf3\xca\x4c\x3a\x73\xe6\x8b\x7e\xf7\x9e\xbd\x49\x6a\xff\x9b\x36\xe9\x38\xfa\x87\x6d\x75\xf0\x3f\xbf\xec\x38\x58\x3a\x62\xfe\x36\xba\xda\x7f\x98\xae\x7e\xd0\x6d\xdf\xfb\x03\x9f\xf4\xd9\xc7\xf9\xf8\xb8\xa7\xbd\x68\x7e\x7d\x24\x87\xb2\x2f\x91\xf1\x79\xad\x51\x5c\x38\x89\x25\x36\x52\x16\x24\x59\x1c\x62\x8e\x66\x55\x16\x9d\x65\xb8\x4f\xae\xd3\xb1\x9c\xcc\xc8\x21\x9a\x25\x1c\xa3\x36\xb1\x26\x9c\x29\xd4\x16\xf6\xea\x6e\x8f\x4f\x81\x74\x52\xd5\x0d\xb4\xfa\x62\x2c\xfb\x84\x02\x0a\x38\x18\x10\xdf\x59\xa2\x1f\x0c\x4e\xe8\x9e\xb4\x76\xdd\xda\x03\x40\x44\x7f\x3b\xa0\x79\x40\xa4\x7d\x14\xfc\xe3\x63\x3b\xfc\x27\xfc\x94\xee\x6d\xf7\x6f\x06\x99\x20\x0c\x9a\x5e\x4f\x00\x51\x3f\x7d\xfa\x29\xd7\x1d\xb1\x1d\x38\x78\x3b\x74\xef\x64\x18\x70\xf0\xc1\x2f\xe0\x36\xb9\x0f\x6a\x7d\x11\x56\x73\x5a\x22\x37\xe2\x90\x3e\x9d\x49\xf5\xf3\x26\x98\xa9\xf4\x58\x87\xc1\x81\x0b\x2f\x51\xc9\x31\xc9\xe5\xbe\x8c\x18\x11\xfa\x23\xb5\x18\x54\x0a\x8b\x4c\x9a\x08\x18\x29\x52\xb1\x95\x52\xe1\x0e\xc7\x4d\x6e\xb6\x05\x34\xf1\xd0\xe0\x68\x5e\x78\x30\x8f\x92\x18\x58\x26\x62\x91\x82\xf1\x78\x31\x04\xaf\x36\x16\xc9\x10\xad\x53\x04\xb2\xe2\xc4\x6e\x7a\xf7\xf7\x19\xb9\xe3\x9e\x4d\xdc\xdc\x1d\xfa\xf7\x0f\x29\x81\x3f\xad\x03\x59\x0b\xcb\xf7\x7c\xb6\x7e\x78\x29\xe0\x9a\xe1\xfb\x53\xf4\x2c\x5c\xb4\xec\x4a\x34\x50\xbe\x92\x0a\xd3\xe3\x9f\x7b\x57\x4e\xcf\xb6\xaf\x3b\x02\x7e\x87\xeb\xb4\xd5\x65\x29\xf3\x97\x1a\xe0\x20\xf0\xd9\x98\x77\xe7\x03\xc7\x3b\xf5\x66\xf0\x24\x4c\x1b\xf1\x5a\x4d\xad\x09\xdc\x3d\xb9\x15\xb8\xf5\xfe\x73\xe3\x0b\x81\xa3\x3b\x30\x0e\xee\xf2\x0f\x74\xfe\x30\x3e\xfe\x0a\xb4\xbf\x2c\x54\x8e\xd7\x22\x93\x89\x23\x18\x92\x9b\x40\x19\x0c\xe2\x88\x08\xf3\x70\x5f\x04\x23\x56\x75\x88\x96\x11\xd6\x27\x00\x9f\x15\x0c\x95\xe9\x0a\x3c\x62\x1d\x9f\x69\x25\x80\x1f\xb1\xf4\x72\xdb\xe3\xd1\x89\x2d\x57\x9e\x39\xf4\x32\xf0\x55\x4f\x58\x1e\xe1\x84\x7f\xda\x80\xb8\x0a\xde\xb4\x83\xff\xd0\x3f\x6c\x3d\x75\xf7\xab\x93\xcf\x49\x22\xcd\xb5\x33\xd7\xad\x3a\xb7\x15\x5c\xde\x49\x64\x39\x8e\x3b\x18\x88\xd6\xc4\x84\xce\x6c\x9e\xd7\x1c\x61\xae\xac\x89\xa0\x18\x8d\x56\x83\x24\xb6\x56\x2b\x36\x1a\x0d\x88\x49\x2a\xc5\x72\xa2\x1f\x8b\xad\x0f\x93\xc6\x63\x6c\x93\x44\xce\xd0\x3a\x02\x41\xa0\x7b\xb7\x98\xa9\x04\x74\x04\x6c\x1d\x13\x03\x7f\x7b\xb3\x6c\x77\x92\x65\xdd\xfc\xc5\x4f\x1b\x46\xc3\xe5\x11\x60\x6e\x01\xac\xb5\xd2\xa5\x7b\x62\x5f\x8b\xa5\x6b\x97\x41\xea\xf2\xdb\x66\xcd\x9a\xe8\x65\xb3\x81\x7f\x19\x28\x6a\xbe\xcb\xc7\x34\xd2\xc8\xc6\xaf\x62\xbf\xe4\x06\x53\x76\x92\x95\x6d\x56\x44\xa8\x2c\x8c\x29\x76\xb8\xcf\xc4\x8a\x18\x09\x83\x76\xb8\x4a\x85\x78\x8a\x4a\xdb\x1e\x2d\x8d\x12\x50\x49\x38\xfe\x7a\x5a\x4c\xca\x24\x06\xf2\x6c\x85\x02\x69\x6e\x8c\xf9\xe0\xe0\x01\xa7\x31\xca\xd6\xcb\x0e\x8f\xae\x40\x13\x99\xdf\xf7\x6f\x52\xd7\xbc\x95\x3c\xd4\xdb\x29\xdf\xc6\x48\xf8\x99\xc8\x3f\x0f\x48\x77\x4c\xde\xeb\x39\x86\xf5\xa5\xe3\x31\xd9\x12\x6e\x9f\xe2\x5a\x42\xd6\x95\xde\x02\xd6\x5b\x4d\x9f\xfb\xdd\xa2\x69\x1f\xbc\x36\x9b\xe9\xbc\x3c\xa8\x2b\x51\x53\x11\xed\x4b\xd9\xde\x88\x1f\xba\xa9\x4c\xaf\x25\xca\x52\xe1\x8b\xb2\x52\x40\xa9\x00\x0a\x56\xa3\x0c\x4f\xc0\x11\x46\x6c\x7a\x5b\x32\x7e\xbb\x8c\x4c\x5c\x04\xbc\x3d\x3a\x58\x3e\x51\xbe\x43\x6f\x25\xf1\x98\xda\x23\x27\x32\x36\xba\xcf\xa9\xb9\x4f\x6d\x31\x4d\x06\x8f\x37\xad\xb4\xd3\x72\x2b\x7b\xc2\x10\x77\x06\x9d\xed\xf8\xf4\xc8\xec\xde\xb7\xa5\xd1\xb3\x26\xce\x9c\xb5\xdd\x57\x33\x76\xd1\xa1\x91\xe7\x27\x8f\x3a\x7c\x04\xc3\x85\x0d\x1e\x56\x38\x4a\x54\x7a\xa7\xa5\x3e\x3a\xc2\x99\x2d\xdb\x27\x7b\x35\x29\xe7\x34\xbd\x7f\xde\xac\xa7\xe0\xf1\x45\x33\xa6\xef\x21\xb0\xe0\x68\x3c\x62\x7c\x2f\x42\xf0\x9f\x22\xa8\x24\xaf\xd1\xa8\x1e\xe9\xa3\x45\x18\x69\xcd\x28\x16\x4b\x10\x87\x91\x18\x08\x54\x57\x7b\x54\x26\x2c\xc5\x98\x20\x62\xf0\x43\xa9\xfa\x03\xe0\x8f\x53\xaf\x4c\xdd\x67\xdb\x37\x07\x7c\xf6\xf6\xed\xda\xab\x8d\xc0\x9a\x1d\xcc\xd5\xa7\x0b\xfc\x2f\xd3\x05\x5b\xe8\xa9\x42\xae\xfe\x33\xcc\x1f\x81\x5c\xfd\xdd\x88\x96\x85\x48\x9e\xe1\x8a\xe0\x52\x2b\x5d\xe1\xb3\xaa\xc2\x64\x72\x19\x6f\x8c\x73\x72\x93\xd1\xa8\x91\xcb\xa5\x1a\xa5\x34\x68\x8c\xb7\xa9\x9a\x78\xd3\x12\xe3\x13\xef\x5c\x42\x58\x3e\xc8\x8e\x73\x63\x0f\x97\x3b\x9f\x46\x7b\x83\x1d\x36\x71\xec\xd2\x7b\xb9\x60\x9a\x15\x36\x0d\x3b\x3b\x6c\xbe\x75\x81\x49\x4e\x3f\xc3\x89\xb8\x5e\xb3\xd6\x0f\xa9\x1d\xc9\x6c\xd1\x1e\x5a\xb5\x11\x46\x80\xaf\x36\x2e\xd8\x53\x32\x34\xbe\x5f\xaf\x4e\xd3\x6b\xdd\x6a\x32\x47\x35\xd8\x27\x42\xe4\xa0\x0e\xfb\xe9\x59\xb1\x0e\x67\xb4\x8e\xf0\x29\x28\xb1\x46\x2a\x15\xa9\x64\x8c\x88\x14\x06\x21\x46\xb2\x3b\xc0\xd7\xf8\xfa\x30\x58\xdd\x63\x10\x07\x8e\x73\x1b\xd1\x4f\x9c\x64\x36\xeb\x79\x2b\xfc\x06\xbe\x35\xed\xf2\xb4\xbd\xf0\x7b\xeb\xc5\xc9\xaf\x4f\x00\x17\x5f\x7f\xcb\xdf\xfd\x18\x7c\xc0\xf6\xde\x08\xd7\xe3\xe4\x4d\x30\x75\xe3\x83\x07\x0f\xfc\xbb\xde\x27\x67\x1a\xfb\x5b\x7e\x21\xb9\x6e\x51\x94\xe7\x6c\x24\x3e\xcd\x7c\xaa\x3a\x12\x13\x2a\x96\x41\xc7\xda\xac\x57\x4a\x65\x62\x59\x39\x7f\xa2\x03\x15\x6a\x70\xaa\x59\xa8\x50\x03\x41\x20\x17\xc4\x66\x18\x27\xae\xb1\xaf\xc5\x82\x0d\x1f\x6f\x0d\xeb\x38\x6d\xfb\x09\x6e\x5e\xf2\xf5\x8a\x5e\x19\x11\x31\x69\xfd\xf6\xf6\xb6\xae\xff\xd9\x76\xba\xf2\x72\x6f\x70\xe1\xb5\xab\xfe\x0c\x79\xc6\x49\x78\xa5\x0f\xfd\xe5\x46\xff\xb3\x5f\x5d\x0b\x7f\x5c\x34\x7b\x71\x06\x5d\xb2\x11\x0c\x84\xcf\x80\x81\x2d\x8d\xb6\xfe\x20\x09\x1e\xc0\x31\x63\x88\x27\x4e\x23\xf5\x52\x3d\x38\x07\x25\x43\xdf\xdf\x17\x2e\xb5\x39\xa4\x5c\x46\x86\x83\x73\x44\xe0\xcc\x65\x05\x12\x0b\x0a\x15\x47\xf5\xf7\x71\xaa\xd0\x68\xfb\x20\x0c\x9a\x1a\x6f\x30\x6d\x20\xd5\x56\x27\xb8\x52\xf4\x48\x02\x8a\x45\xed\xb0\x0c\x70\x6c\x0a\x56\x6f\xb8\x68\x5c\xdd\x96\xbf\xc1\x7f\xc9\x8a\xaf\xe2\x2b\xfb\xb0\xf8\x2a\x7e\xf9\x12\xf8\x2b\xfc\xe3\x07\xbd\x6f\xf8\xac\x06\xeb\x73\x39\x3f\xbc\xf0\xda\x1a\xe9\x60\x49\x2c\x9d\x3b\xfc\xd0\x54\x95\xfa\xc5\x6b\x07\x4b\x98\x37\xc4\x53\x55\xbd\xfa\xdb\xa2\xe7\xd6\x2e\x9b\xf9\xf6\xfb\x2c\x3b\xc5\xd5\xbf\x0f\x29\x7f\xba\x7b\x62\x4a\x36\xb8\x9b\x14\x95\x16\x27\x1a\xb2\xad\xd2\xc7\x32\x2b\x97\x78\xcb\xa8\x00\x4e\xe0\x7c\xc4\x03\x8c\x54\x2c\xc9\x88\xa4\x14\x72\x4a\xae\xd4\xe9\x91\xb5\x17\x5d\xee\x93\xaa\x18\x4b\x87\x38\xa3\x20\x06\xa8\xab\x03\x36\x60\xbb\xca\x6d\x21\xe8\x80\xc6\x76\xd0\x80\xf6\xb3\x87\x2c\xd2\x63\x26\xa8\x0e\x01\x06\x3c\xde\x06\x0b\x78\xb8\xe5\x40\xd3\x50\x36\x69\xd1\xd3\x1d\x71\x01\x09\x56\x29\x5b\x8e\xe8\x74\xe1\xb3\xad\xb6\x60\x54\x40\x3e\x20\x52\x22\x53\x4a\xda\xc3\x74\x85\x30\xa9\x10\x44\x57\xf7\xff\x17\x9c\xeb\xa1\xb3\xb1\xff\x1d\x4d\xb7\xe6\xf4\x5f\xc2\xb8\x86\x60\xaa\x46\x53\xe9\x54\xae\xd7\x66\x30\x86\x4b\x8d\x52\xb9\x4d\xaf\x4b\x29\xf7\xe9\x0c\xf2\x58\xac\xd3\xe2\xd8\xf6\x0a\xac\x37\x15\x84\xe6\xf9\x84\xc2\xab\x06\x92\x92\x45\x8f\x82\x58\xd5\xe6\x83\xf6\x28\xab\xf4\x96\x6e\x7d\xa2\x72\xba\x17\x56\x28\x8c\x8e\x47\x02\xad\x5e\xb6\x9d\x06\x5b\xdb\xc6\xc2\xdd\x52\x1f\xd4\xf7\xed\xf9\xd8\x93\x0f\x81\xad\x32\xaf\x6c\x78\xd2\xaf\x6b\x3f\x28\x40\x8d\xe1\x63\x8c\x31\x3a\xb0\x57\xab\xd1\x18\x59\x96\x32\x1a\x95\x48\xf6\xaa\xa8\xb0\x10\x70\x20\xe1\x9a\x26\x4f\xc0\xdb\xf1\x84\xa6\x9a\xe3\xab\x00\x9a\x37\x0f\x14\x00\x7c\x7e\xee\xf5\xab\x75\xb3\x97\x1f\x1f\xc9\x23\x7d\x46\x6d\x7e\x6f\x2e\x41\xfa\xd4\x3d\xbb\x45\x21\x1a\x34\x61\x2d\xc8\x59\x45\x10\x3e\x47\xec\xf2\xdd\xb8\xb2\x08\xfe\xf3\xdd\x89\x64\x6e\xcd\xad\x87\xd8\xe9\x88\x0e\x27\x95\x86\x91\xda\xc5\x74\x8a\x2d\xb1\xdc\x97\x12\x61\x53\xdb\xd4\x94\x5c\xae\x27\xf6\x42\x0c\x92\x57\x98\xa4\x1b\xed\xb4\xf7\xa0\xcd\xca\xf1\x77\x63\xa4\x10\x29\x5f\x4e\x3a\x5b\x88\x76\x35\x0a\x27\x53\x01\xe2\xc8\x35\x0c\x26\xda\x0e\xe8\xc8\xb3\x53\x53\x7b\xd7\x55\xe5\xc4\x6f\x00\xd1\x57\x11\xdd\x33\x26\xdf\xba\xc9\xd6\xdd\x5f\xf4\x58\xe3\xec\x4f\x1f\x1f\xbf\xbe\xcf\xc2\xea\x37\xea\x8c\x53\x74\xfd\x32\x46\xfb\x26\x76\xae\xd8\xf2\x11\xc8\x3b\x76\xec\x49\x85\x68\xc8\x28\x24\x25\xfe\x9e\x6f\x1d\x5c\x57\x33\xa4\x76\xe7\xa0\xe5\xa9\x7d\xd3\xab\x86\x0d\x8b\x8c\x0b\xc8\x5d\x8c\xcd\xe9\x40\x7b\x24\xcf\x6b\xc7\x50\x15\x15\x3e\x9b\x15\x31\x68\x5e\xf6\x86\x87\x27\x13\xd1\x1b\x82\x83\x13\x0a\xce\x19\xb0\x03\x1f\x02\xe7\x74\x83\x76\xb2\x37\x07\x74\x38\x89\xd6\x0e\x28\x9d\x55\x67\xe1\xeb\xe2\x68\x5e\xf2\xbe\xaa\x82\xc5\x8f\x3e\x92\x8f\x81\x6b\x7f\xbe\xec\x34\x13\xc1\xfb\x4a\xdc\x48\xf0\x6c\xfb\xa3\xc9\xf3\x10\xee\x22\x77\x8f\xd4\x4b\x44\xe3\x51\x28\x6d\x56\xa5\x35\xdc\x6c\x4e\x2a\xf7\x99\x55\x1a\xb4\x20\x1a\x43\xb8\xbe\xe3\xa6\x7f\x08\x7b\x19\x04\x90\xd9\x1e\x59\x22\xb1\x00\x97\x7b\x6f\x37\x1c\x2e\xab\xa8\x30\x2a\xa7\xf3\x1c\xdb\x65\xcc\x50\x3a\x0c\xcd\xd1\xc9\xaf\x0d\x19\x0e\x77\x4f\x79\x58\xbf\xa9\xa5\x33\xe1\x2d\x21\x43\x3b\x02\xe2\x1f\x3c\xf6\xd0\x78\xc6\xa3\xfd\x3e\x18\xed\x33\x3d\xda\xf1\xf1\x5e\xbd\x19\x83\x86\x98\xcd\xe1\x6c\xb8\x86\x54\x78\x44\x5a\x27\xab\x6a\xb7\xe7\xb1\x29\xac\xe5\xb1\xb0\xf8\x84\xf5\x40\x36\xaa\x87\x09\x14\xd6\x58\xc8\xe5\x82\xcc\xef\x5f\xbc\xf6\x24\xfc\xd7\xa5\x83\x77\xb4\x87\xc2\x56\xd6\xad\x79\xcd\xf5\xca\xe3\xcf\x27\xd2\xbd\xc2\xe6\x80\xdf\x4d\xc0\x04\xe2\xde\x7d\xe5\x1e\xbc\x74\xf4\xf1\x39\x29\xbd\x87\xdc\xbe\x00\xee\x1e\xd9\x9d\x99\x30\x75\x81\xa0\x67\x0a\x67\xd0\xcc\xe3\x83\x9a\x31\x76\xab\xcc\x6c\xd6\xc9\x74\x11\x98\xb1\xc8\x38\x8c\x34\xf5\x08\x7c\xd0\x8e\x61\x0b\xb8\xf0\x72\x94\x1a\xe9\x65\x00\x47\x7a\x8b\x55\xcc\x06\xf9\x82\x69\xc4\xc8\x00\xcc\xfe\xab\xb7\xb0\x79\x01\x17\xea\x59\xb0\x78\xd9\x0b\x31\xfe\x8b\x2c\x5d\xd4\x3d\x6b\xf1\x2a\x62\x4d\xdc\x7c\x61\x3e\xfc\xe4\x9d\x7a\x30\x0f\xd9\x10\x30\xf5\xf8\xf6\x92\x56\x4c\x57\x04\xa2\xeb\x07\x12\xb7\x90\x84\xac\x3c\xa7\x4a\x5f\xe1\x4b\x30\x87\x9b\xfb\xfb\x28\x8d\x4a\xc6\x85\x4b\x54\xe1\xaa\x70\x9b\xc4\x86\xf8\x9e\xcd\x20\xa1\xf1\x15\xf7\xc3\xf1\xf6\x79\xea\xbc\x4c\x41\x15\x03\x59\x81\x20\x86\x28\x2d\x6f\x45\x20\x93\x89\x84\xb7\x89\x68\x01\x07\xc5\xc8\x4b\x4d\x4e\x44\xff\xf1\x5a\xcd\xfa\xf8\xcd\xdd\xff\xf5\x24\xa8\x91\x3d\xc6\x98\x63\x13\x8a\x2d\x23\x4b\x7b\xf4\x03\xda\xed\xdf\xef\x7a\xe6\xb4\x6d\xdb\xd0\xf1\x4b\xcf\x44\xfb\xbf\x0b\xa3\xdf\xf9\x75\x60\xff\x94\xa6\x85\x70\x7f\xc4\x46\x4f\x41\xfc\x9a\xce\xf3\x27\xc6\x5d\x83\xef\x6e\x3d\x77\x62\xc2\xea\xcf\xe6\xce\xfe\xfa\xdb\x29\x5e\x72\x5f\xd4\x80\xc6\x32\x85\x60\xba\x8d\x23\xdf\xcb\xd0\xf7\x1e\xe4\xfb\xbf\x08\x1f\x0c\x6b\xfd\x81\x0b\x47\x63\xf5\x50\x95\xde\xb4\x6c\x9d\x1e\x27\xc7\x27\xa5\x57\xf8\x62\xdd\x15\x48\xaf\xd4\x47\x26\xc5\x2a\xf5\x20\x9c\xd1\x27\xc5\xc6\x26\xe9\x19\xc6\xe9\xb4\x95\xfb\x9c\x2a\x46\xfe\x50\xf5\xd3\x34\x12\xe8\xc7\x7b\x18\x93\x92\x82\x08\xea\x22\x92\xe5\x5d\x00\xc4\x81\x8b\xdd\x24\xa4\x51\x67\x0a\xb1\x7c\x82\xd3\xc3\xe8\x11\x9c\x5b\xc4\xb9\x8d\x39\x14\x93\xd7\xfa\xc1\x63\x9b\xfb\x31\x67\xe9\x8a\x49\x0b\xd6\x0c\x1f\x37\xc2\x3a\xb8\xdb\xa4\xa2\xca\x41\xcf\xf6\x3c\x99\xf5\xed\xde\x95\x87\xd4\xcd\x0c\x88\xce\xcc\xae\xb2\x2f\xaf\x1a\x3a\x81\xee\xfc\xe2\x98\xf1\xa0\xf2\xe9\x6b\xdd\xe6\x8c\x77\x2b\x92\xfb\x8d\x99\x35\xb1\xb8\x6c\x6d\xda\xe0\xa2\xfc\x7e\xb7\x54\xdb\x0f\x8d\x1d\x62\x5a\x5c\x5c\x14\xff\x44\xd6\x82\xfa\x26\x8f\x7a\x3a\x5a\xdf\x19\xad\x3f\xb0\xb5\x68\xcc\x5a\x82\x00\x6b\xb5\x4b\xa4\x52\x09\x36\x7a\xd1\x38\xa5\xd2\x18\x53\x0c\xb2\x80\x63\x0c\x26\x0d\x46\xcb\x6c\xb7\xfb\x02\xa5\x68\xf0\xb8\xf8\xd1\x84\x0c\x26\x8a\x11\x98\xaf\x4e\x24\x0e\xa4\x8f\x83\xcc\x05\x4f\x2c\x3d\xf6\xda\x08\xcb\xe0\xc2\x29\xdd\x6a\xc7\xc0\xb2\x2b\x5b\x80\xed\xea\xf9\x37\x96\xac\xb9\xbd\xf4\xfb\x0d\x7f\xbb\x07\x9e\xdc\xbc\x61\xf9\xf8\x65\x6b\x53\xab\xbc\xdd\x2a\xfc\x2f\xdd\x05\xdd\x4e\xad\x9c\x3d\x61\x4d\xac\xf3\x48\xed\xa9\x51\x24\x2f\xba\xf5\x15\x38\x99\xf9\x1e\xe9\x96\xd8\x7f\x25\x67\x8c\x06\x23\xc6\x5d\xd3\x2b\xd4\x52\x35\xb9\xa0\x93\x62\xe0\x9f\xb4\x76\x57\x07\x2e\xde\x35\x2a\x16\xd2\x1f\x78\x8c\x09\x8f\xc3\x43\x67\x9e\x3f\x7b\x1e\x88\xac\xf0\x3e\x17\xff\xe9\xe7\xbd\x0e\xb9\xac\x51\xe7\x93\x6a\xa7\xf5\xd0\x41\xbd\xb5\x99\x39\xd6\x32\xa0\xd9\xfc\xfa\x09\x52\x1d\x20\xad\x6e\x4c\x33\x3e\x07\xfd\x60\x35\x77\x09\xf1\xc0\x78\x2a\x97\xea\xe1\x75\x45\xc7\xd8\x63\x2a\x7c\x76\x4a\x1a\x1e\x81\x4e\x83\xc2\x60\x48\xc6\x97\x71\x2c\xa5\x50\x64\x95\xe3\xab\x1c\x31\x92\x9b\x96\xd0\x09\x6b\x0f\xbf\xcc\x3b\x99\x02\x24\x69\x83\xcc\x30\x50\x27\x37\x50\xbb\x80\xf0\x4b\x5a\x1b\x5a\xff\x39\x9f\x06\xc7\x9e\x39\x49\xbf\x40\x8f\x1a\xf2\x7b\x7e\x2c\xdd\xed\x95\x39\x3b\x37\xf4\x5f\xf2\x62\xd3\xb4\xf5\x11\x6c\x67\xdb\xa9\xb5\x8e\x58\x77\x54\x6a\xa7\x46\xdb\x3f\xab\x23\xa6\x8d\xaf\x59\x50\xdd\x79\xe8\xc4\xf2\xb5\x13\x72\x60\xf5\xda\x85\xe6\xd2\xfe\xa0\xf3\xd5\x31\x93\x76\xed\x5e\x00\xfa\xbd\x59\x5b\x3b\x12\x64\x6c\xdc\xc2\x84\x1f\xd4\x6c\x7a\x30\x1f\xe6\xb2\x23\x17\x36\xf7\x3b\x00\x7f\xa8\x99\x3c\x66\xd0\xde\xbf\xe1\xf3\x91\x0f\xab\xd9\xd9\x6c\xa9\x4a\x44\xf5\xfe\x49\xc0\x1b\x22\x31\x4c\x76\xcc\xa1\x28\xc4\xa1\x54\x32\x64\x6d\xc8\x64\x3a\xcc\x9b\x38\xc4\xa7\xb8\x8e\x91\x2d\xc4\x3c\x67\x02\x83\x6b\x2f\x8f\xd1\x58\x0a\x80\x93\x9e\x0b\x4e\x54\x54\xff\xb8\xf0\xce\x07\xdb\x41\xfc\x89\xc3\x2f\x5c\x1e\x56\x7f\xe9\xde\x92\x85\x6b\x1f\x4b\xfa\x93\xb6\xc1\x61\x45\x7d\x6e\xbd\x76\x17\x14\x3d\xf7\xcc\x56\x85\x78\xe0\x04\x78\x07\xc2\x4d\x4b\x8b\x3e\x42\xeb\xb1\x1d\x56\x71\x2c\xda\x0b\x1a\xca\x4a\xd9\xce\xe9\x19\x19\x90\x45\xa0\x5d\x70\xce\x27\xb3\xb2\x04\x00\xaa\x20\x18\x48\xc3\x63\xcb\x06\xf6\x21\x8e\xb5\x30\x66\xc5\x61\xdf\x18\x0e\x18\x39\x0a\xff\x7d\xf3\x2d\x9a\xbe\xe3\x9f\xd7\xad\x78\xa1\xaf\x7a\x5c\x4c\xce\xe7\xae\x92\x8c\xce\x69\x59\x5b\x98\xfd\x7e\x11\x7d\xbf\x65\xe8\xe1\x05\xbd\x9a\xca\x47\x0f\x49\x1d\x35\x72\x7b\x59\xdd\xd8\xfa\x98\x92\x12\xbc\x1f\xfa\xb6\x7e\xcd\xc9\xd8\x42\x4a\x82\xf6\x43\x8a\x57\xa3\x89\x4f\x8b\xaf\xf0\x29\x92\x92\xb2\x68\xc6\x26\x4d\x53\xda\x78\x24\x6b\x5b\x10\xd6\xc0\xd8\x16\xb6\x9f\x15\x27\xe6\x6b\x37\x11\xbc\x9c\x54\x9a\xdc\xc5\x1a\xdb\xe8\xf3\x20\xb1\x82\x51\x94\x95\x80\x67\x09\x91\x74\x01\xc8\x07\xf4\xcc\xb8\xb8\x92\xdc\x94\x0c\x70\xa4\xcf\x82\xd8\x15\xf6\xe8\x84\x08\x67\xae\xe3\x45\x5b\x6a\xf1\xfc\xea\xa1\xa3\xe7\x46\x25\x96\xc8\x9c\xce\x82\xf2\xe4\x21\xbd\x9f\xee\x33\x66\xb4\x3a\x22\xcc\x39\xa0\xcb\xf2\x5f\x3c\x75\xd9\x23\xba\x15\x17\x33\x4b\x47\x0c\x99\xd2\x2d\xd5\x96\x9d\x0d\xdf\x1e\xb0\xb4\x7b\xd1\xdc\x92\x91\x03\x27\x6d\x8b\xef\x0a\xd2\xb3\xb3\x6b\x32\xa7\x0c\x19\x31\xa4\xf6\xc9\x1e\x3d\x9e\xac\xf7\xf1\xfe\xeb\x26\xa4\xbf\x2c\x20\x36\x5c\xa4\x57\x69\xb4\x46\x50\x14\xa3\x93\x28\x19\x55\x1b\x9f\xe3\xb3\x34\x43\x6c\x84\x76\x38\x52\xc0\xa9\x45\x43\x88\xaa\x7c\x6e\xf6\x13\x2b\x95\x6b\xce\x2e\x53\x54\x8e\x5d\xf4\x5c\xd4\xdc\x73\xf0\xa3\xb3\xe5\x1a\xdb\x73\x53\x87\xce\x5a\xd8\xa5\x8c\x7e\xdb\x5f\xd1\xdb\xdd\xbf\x27\x06\x68\xba\x6f\x03\xdb\xc6\x8c\xa5\x02\x75\x4f\x7b\x11\x5d\x23\xd1\xab\x0f\x97\x4a\xe5\x5a\xbb\x5e\x6e\xfe\x2b\xad\x3a\x10\x64\xc6\xab\x16\x4a\x20\x7a\x74\x79\x53\x0d\xbd\xae\xb8\x67\x54\x46\xb7\x85\x56\x6d\xb8\xeb\xa1\x40\xb3\x6f\x3b\x71\xf7\x54\x07\xb4\xcd\x63\x72\xd7\x3e\x14\x63\xc6\x9e\x06\xf1\x54\xa0\xee\x1b\xa6\x2b\x81\xca\xf1\x5a\x31\x5d\x71\x7a\x93\x59\x8f\x08\xd3\x5b\xe5\xd1\x7f\xa9\xf4\x0b\x29\x1b\x7f\x41\x63\x87\x32\x70\x7f\x4d\x6c\x68\x29\xb8\xbf\xa2\x3a\xa4\x16\x5c\x7b\xe2\x69\x21\x96\x16\xc7\x37\xe8\x91\x0c\x8f\xd1\x6a\x2a\x7d\x5a\x4a\xc0\xb6\x55\xca\x10\xa7\x0f\x02\xdc\x2a\xff\x02\xe0\xb6\xad\x98\x6c\xd2\xa3\x60\x6e\xb1\xa7\x8d\xfe\xe3\xfd\x88\xf7\xbb\x05\xa0\x6e\xbb\x7d\x13\xf1\x4d\x01\x29\x5c\xba\xdb\xf5\x9a\x0b\x3b\xd8\x8e\x36\x37\x83\x41\x01\xd7\x1a\x00\xc5\xad\x3f\x31\xf1\xe4\xfc\x5a\xbc\x0a\xa5\x02\x89\x1c\x25\xc7\x84\x31\x15\xbe\x30\x43\x68\x3d\xd4\x10\x75\x57\x00\xa7\xa7\x17\x39\x3d\xce\xe4\xc8\xac\x94\xcf\xa4\x8d\xf0\x57\x2b\xb8\xb2\x4d\xfc\x4d\x8c\x27\x7c\x8f\xf4\x66\x62\x36\xbd\xb9\xb9\xe5\xbb\x68\xde\xa6\x41\x63\xae\x25\xb5\x39\xa3\xbc\x2a\x26\x9c\x22\x63\x7d\x78\x74\x41\x78\x64\xa1\x3c\x26\xc8\x61\xdc\x16\xf8\xd2\x0e\xe0\xb5\xb6\xdc\xb6\x82\x82\x1d\xf0\x65\xb6\x53\x73\xcb\x67\xb8\xfa\x2a\x15\xc0\x07\x56\x13\x3f\x72\x1f\x6f\x42\xb8\x84\x46\xc2\x92\xa2\x35\x3a\xab\xae\xbf\xcf\x6a\x31\xd1\x16\x8e\xb3\xd0\x26\x56\x19\x19\x89\xd8\x63\x24\x25\x53\x29\xd1\xa9\x51\xb6\x9b\x4e\x5e\x3f\xe8\x00\xaf\xc1\xdf\x37\xba\xc9\x8e\x10\x68\x21\xfb\xc1\x89\x38\x80\x91\x0c\x5c\xa9\x8c\x8a\x74\x2a\x9b\x0c\x53\x47\xc4\x68\x46\x05\xa6\x79\x8a\x29\x22\xce\x25\x69\x32\x34\x0d\xcc\x19\xc1\x03\x0b\x2b\x44\x69\xe9\xd3\xa7\x73\x50\xd4\xdc\x4c\x77\x0d\x4b\x4f\x1b\xbf\x80\x03\xdf\xf1\x75\x63\x83\xd8\xc6\x88\x77\x53\xc5\x5e\xa7\xc9\xac\x41\x7a\x9c\x46\x23\xd6\x33\xc8\x86\x45\x1a\x9d\xd1\x28\x26\x3a\x8f\xfe\xbf\xe2\x1c\x0b\x48\x31\x1d\x01\x8f\x09\x90\x77\x67\xbe\xae\x81\x87\xe4\x1c\xb8\x19\xee\x88\xf9\x88\x2f\x40\xab\x8f\x1b\x58\xbf\x6f\xb6\xd8\x43\xe8\x84\xcf\x27\x8a\xbb\x94\x0e\xa5\xef\x2d\x86\xd9\x68\x63\xbc\x51\x5b\xfd\xd8\x26\x60\x6e\xf6\x2b\x3e\x2c\xed\xd2\x1f\x63\xfd\xcd\x86\x55\xcc\x24\x44\xab\x06\xd7\x56\x25\xfb\x83\x22\xbb\x23\xe0\x05\x16\x7c\xab\x81\xbd\x81\x3d\xd1\x40\x44\xa7\xc7\x78\x72\x33\xa2\x7a\xa6\x7e\x23\x05\x76\xbe\x9f\xd7\xc5\xc7\x63\xb2\x95\xfb\x94\xb7\x12\xdc\xdc\x95\xe6\x3f\x5f\x8e\x46\x6b\xe8\x15\xec\x33\x3b\xc6\x63\x52\xc9\x29\x39\x52\x6f\xe4\x56\xce\x86\xeb\xd8\x8b\x22\x22\x18\x25\xa0\xf8\x1a\xae\x79\x41\x37\x33\xaf\xea\xb8\x79\x2c\x05\x01\xb6\x2a\x8a\xf1\x18\xda\x30\xab\x90\x9c\x2b\x07\x51\x67\xcb\xe8\x5f\xa3\x61\xc9\xd6\x67\xf7\xc2\x7f\x1d\x85\x4d\xda\x73\xea\xaf\xa6\x5e\xac\xdd\xb9\xb4\xc2\x0a\x5e\xf7\xbf\x7e\x81\xbb\x05\x27\x9f\x86\x9b\xb4\x6f\xec\xdc\x0e\x7f\xdc\x0d\x52\xf5\xe7\x67\xdf\x98\xb8\xe0\x89\xf5\xa0\xa9\x45\xa8\x33\x92\x86\x64\xec\x2d\xb4\x6f\xd3\xb1\xf7\xce\xa2\xd7\x59\xad\x9a\x74\xa9\x4b\x29\x4a\x8e\x44\x1a\x86\x31\xd2\xa0\xd1\x93\xb2\xbe\x02\x26\x33\x66\x2d\x6e\x77\x07\xe4\x3c\x05\xa3\x77\x22\xc9\x2a\x22\xae\x7a\xe7\xa3\x38\x34\x13\xbd\x4c\x1f\x97\x58\x30\xd3\x31\xfb\x08\x9f\x12\x1f\xae\xa6\xc7\x6c\xaf\x2e\xa6\xbb\x2e\x1e\x50\xd5\xdf\xb0\xe6\x30\xfe\xdf\x85\x53\xa2\xe6\x62\x14\xbd\xa9\x9d\xba\xa4\x5d\x3e\x4c\x0f\x6f\x79\x96\x44\xf0\xf4\x1a\x77\x6d\xf8\x70\x51\xdd\xe0\x9a\x71\x7d\xa6\x62\x1e\x8e\xff\xf7\x91\x43\xf4\x0c\x4c\x3b\x9a\x57\x4c\x7b\x32\x92\x88\x06\x95\xda\x68\x52\x9b\x2c\xc9\x52\x87\x52\x14\x6f\x89\x2f\xf7\x69\x2d\x06\xb9\xb5\x3d\xf1\x01\xcb\xb0\x9d\xec\xd0\x08\x71\x2d\xff\x3b\xed\xf0\xa3\x43\xdd\x23\x35\xf4\xf0\xe6\xff\x85\x72\x24\x5e\x46\xad\xed\x7b\xe8\xd1\x64\x63\x7c\x78\x5c\x17\x18\xe9\x35\x9d\x30\x6f\x4f\x4e\x49\x48\x29\xf7\x25\x58\x73\x44\x26\x51\xb9\x2f\xca\xa4\xb2\x59\xf5\x3a\x5d\xb8\x5a\x49\x05\x50\xb8\xf1\x94\x87\x02\x4c\xe2\x9b\xcb\x47\xa3\x12\x18\x6c\x20\xe0\x0f\x7c\x34\xb7\x07\x47\x3b\x2c\x84\x56\x42\xe7\xcd\xe9\x13\x1c\x0f\x66\xfc\x05\x3c\xe3\xdf\x2e\x0c\x8c\x3e\xce\x0f\xcb\xbf\x37\x08\x50\x50\xe7\xe3\x87\x36\xba\xcf\x8c\x36\x29\x60\xc6\x8f\x1d\x3d\xe8\x5f\x4b\xf6\x55\x6b\x31\x96\x5f\x68\x8c\xf1\x54\x82\xd7\x10\x8d\x46\x16\xad\x8a\xb4\xdb\xa9\x08\xa5\x4a\x2d\x57\xe3\xed\x4f\x76\x7c\x9b\xc0\x22\x25\x42\xda\x08\x0d\x21\xbe\x5d\xcc\x18\xc1\x5d\x78\x20\x88\xd2\x4d\xb6\x4d\x0d\x82\x98\x7a\x3e\x50\xcb\xb4\xec\xca\xac\xe6\x35\xf2\x35\x41\x89\x2a\x0e\xd0\xf7\x62\x20\x1e\x6c\xe2\xa8\x05\x8b\xf3\x7a\x10\x7c\x05\x41\xce\x0e\x27\x3e\x59\x44\x67\x0c\xa2\x2c\x46\xe5\x88\x8a\x32\x58\x95\x06\x3d\x4b\x8b\xe9\x8a\x10\xaf\x71\x90\x4e\x4e\x17\x22\x24\x3a\xac\x44\x3b\x4a\x45\xcc\xa6\x61\x05\xa9\x51\xdd\xba\x7c\x23\xdd\x13\x90\xa3\x07\xda\x53\xba\x4f\x74\xac\x46\xb5\x5f\x81\xd8\x05\x93\x1b\x90\xa3\x6d\xb1\x6b\x3c\xad\x2d\x97\xa3\x82\xba\x0a\xd6\x93\x54\x94\xde\x2b\x61\xc2\x95\x9c\x4a\x19\xa6\x24\x9b\x84\x07\x24\x97\x00\x64\xce\xa1\xbd\xeb\x04\xb1\x71\x0a\x12\x4b\xf1\x16\x28\x91\x5a\x75\x8b\x8f\xde\x3d\x04\xaf\x98\x8d\x12\x75\xe3\x91\xbb\x68\xa3\x56\xea\x06\x2c\xa0\xb7\x3e\xb8\x41\x5f\xca\x29\x2d\x9c\xec\xc7\xa1\x03\x6d\xf1\x95\xd8\x3e\x65\xb7\x11\xfe\x6d\x47\xdf\xff\x83\xe6\xc6\x44\xb9\x70\x2d\x54\x13\xdd\xdf\x27\x16\x69\x75\x4a\x13\x12\xe1\x26\x93\x48\xa7\x43\x06\x91\x4e\xa9\xb2\x22\x41\xae\x92\x20\xa5\x44\x62\x10\x21\xf3\x4d\xa4\x0f\x71\x5c\xb7\x33\xe0\x48\x19\x0f\x52\xdc\x90\x30\xf1\xd0\x60\x32\x82\x3e\x16\xd7\x56\x42\x54\xa3\x66\xa7\x9b\xe1\xec\x9e\xe0\x35\xb3\x7f\x8f\x62\xc0\xe2\x99\x0b\xa7\xdf\x5d\x53\x52\x6e\x94\xd1\x7d\x2c\xb0\x4f\xfe\x3a\x4f\xfe\xa0\xc6\x5e\xd3\x9a\x37\xd3\xd3\x9a\xe0\x96\x65\xa5\xc3\x2f\x5e\xfc\x3b\xf0\x5d\x8e\x4f\x2a\x58\x09\x5f\x9a\x3b\xbd\x7e\x23\xbc\x77\xfe\x5b\x50\x00\xf8\x3b\x0a\x35\x8e\x9f\x46\xe3\x30\x92\x55\xd6\x45\x1b\x8d\x2e\x13\xa7\x75\x69\x91\xc4\x74\x19\x4c\xb2\x36\x5b\xb3\x4d\xde\x60\x3b\x53\x81\x0c\x67\xcc\x02\xb2\x48\x89\x11\xc1\x39\x5a\x00\xb4\x6d\xb1\x60\x41\x43\x83\x7e\xc9\x21\x03\xf5\xb3\x16\x82\x1e\xab\x6b\xb7\x7c\xb1\x34\x2f\xab\x6c\x6a\x9c\xfe\xf4\x87\x3f\x4f\xbc\xba\xa0\x66\x0a\x70\xef\xa8\x99\xba\xf0\x34\xe8\x46\xf7\x3d\x30\x36\xe9\xf0\xf7\x6f\x6d\x39\x38\x74\x07\xbc\x71\x69\xe2\xe0\x93\xd7\xea\x68\xd0\xf2\xe5\x15\xf8\xd1\xae\x85\x4b\x96\x2e\xd8\x73\xf4\x47\x50\xfb\x32\x1f\xd3\x36\x05\xef\x4b\xa2\x43\x99\x78\xfb\xc7\xaa\x97\xea\x91\x88\x94\xaa\xc2\x28\x83\x05\x58\xd0\x9c\x03\x1e\x03\x5c\xe0\x0c\xc1\xe8\x35\x2d\x29\x58\x83\xf7\x01\x92\x1b\x2a\x8a\x63\x40\x56\x6c\x1c\x93\xa3\xe1\x74\x46\xad\x88\x06\x15\xe5\x9b\x9f\x02\xaa\x07\x7d\xf6\x97\x1e\xd8\x01\xbf\x81\xb0\x1c\x1c\x2b\x2b\xdf\xbf\xff\x29\xff\xaa\x0d\xfb\xb6\xec\x82\x55\x60\xbb\xf6\xd6\x45\x64\xbf\x4c\x89\x04\x4b\xe0\x42\xd5\xab\x67\xe0\xcb\x70\xb5\x05\x8e\x63\x47\xcc\x5f\xac\x6c\x39\x17\x05\x12\xdc\x3f\xb9\x98\x62\x27\xfc\x84\xec\x49\xec\xd3\x50\x11\x1b\x19\xe9\x3d\x14\xad\x47\x27\x46\x8f\x78\xb1\x5a\x24\xd3\x8b\x94\x54\xe0\xcc\x10\xca\x3c\x6d\xd0\xfd\x46\x67\x2c\x71\xc9\x61\x4c\xe0\xc9\x93\xc6\xec\xf9\x2d\x66\xf4\xd9\x15\x26\xfa\x19\x91\x88\xeb\x35\xa3\x79\x78\xdd\xc8\xfd\xda\x9f\x2f\x81\x16\x7f\xd1\x82\x2b\x85\xe9\x25\x25\x9d\xa6\x4d\xc8\x56\x53\xc1\xfe\x86\x91\xbc\xe6\x87\xfb\xa3\xfe\x0f\xfd\x9d\x3a\xfb\x7e\xc7\xfe\x98\xe6\x07\xa7\x1e\xee\x0f\xad\x03\x1e\x9f\x9d\x4a\xf7\x22\x09\x63\xb2\x8a\x28\x9a\x5c\xbf\x19\x30\x72\x33\x32\xba\xce\xfa\x34\x56\x91\x92\x2a\x68\x5f\x0b\x43\xdd\xbe\xff\x76\x6a\x65\xfb\x61\x7f\x2b\x8e\xf6\x64\x65\x44\xe6\xf7\xb8\x13\xde\x53\x54\x3c\x63\x4d\x4d\x60\xf0\x0f\xca\xb0\x93\x54\xb1\x27\xfc\x95\x64\x0f\x98\x38\x7e\x6c\x26\xf6\xe7\x52\x75\x88\x9e\x45\x64\x2f\xb7\x8d\x5f\xa5\x56\xa9\xc4\xe1\x4a\xb1\xb5\xfd\xf8\x41\x80\x2f\xe5\x3c\x74\xd9\xb7\xf7\x77\xe7\xb9\xb3\x1f\x99\x82\x77\x7c\xe3\xc7\x30\x5b\xb4\xff\xb9\xd8\x52\xc3\x8e\x9b\xff\xd4\xe8\xb6\x0b\x3e\x80\xed\x5e\xd2\x5f\x1c\xd2\x0f\x0c\x14\xed\x42\xfd\xb9\x30\x87\xd4\x5a\x94\xf2\x70\x6d\x38\x86\x82\xa6\xda\xb1\xf1\xd0\xae\x03\x03\x57\x30\x01\x5e\xd9\x91\x10\x34\x05\x73\xd0\x04\xe4\xa4\x44\xe9\x6c\x66\x93\xf2\x4b\xe9\xde\xd0\x55\x41\x44\xfd\x7c\xc9\xbf\x01\xcf\x83\x7c\x3f\xc3\xd1\x00\xe9\xdc\x4c\x3e\xa2\x30\xbd\x67\xaf\x90\x35\x3a\x83\x73\xd3\x10\x8d\x72\xc4\x17\xa5\x62\x09\x2b\xa9\xc0\x0e\xd5\x80\x7c\xc1\x41\x6b\x1a\x5c\x92\x86\xbf\x02\x61\xce\x8c\xc9\x01\x83\x41\xf8\xb8\xf1\x8e\x91\xe3\x5f\xfe\x2a\x61\x34\xcd\x02\x0b\x48\xd3\x1e\xd2\xdf\xbd\x07\x19\xfc\x3e\x00\x90\x2e\x78\x05\xbd\x4f\x45\xde\xc7\x49\x91\x9d\x25\x55\xf1\x78\xfb\xc2\x11\xcb\xc1\x21\x4a\xfc\x1d\x1c\x8e\x62\xa6\xbb\x9f\x57\xc2\x57\xc7\xd7\x46\x4d\x1a\xff\xc9\xb7\x40\x7b\x01\xb5\x3f\xd8\xbf\x08\x98\xf4\x87\xb4\xef\xdf\x2c\x1b\xca\xeb\x5a\x34\xae\xae\xc2\xf6\x46\x7b\x49\xc6\x57\xf8\x09\x93\x29\x10\xef\x51\x28\x00\x4d\xcb\x71\x22\x82\x14\xe8\x83\x7e\x84\x80\xc6\xeb\x70\x92\x3b\x64\x15\x07\x9c\xe4\xb2\x94\x8f\x58\x02\xcc\xd9\xbb\xe0\x9d\xfd\xa7\xe1\x69\x20\xb9\xf7\xfb\xc7\xa3\x4b\x80\xa6\x71\xa9\x6f\x3c\xdb\x69\xc9\x3c\xf8\x6e\x5f\xd8\x15\x5c\x00\xf7\x61\xf3\xcc\xfa\xc2\xfe\xc1\x7e\x3f\x40\xfd\x8a\x09\xae\x98\x46\x16\x16\x86\xe4\x71\x58\x98\x56\xaa\x53\x6a\xc5\x48\x51\xd2\xb7\x5d\x61\x07\x42\xc2\x48\xde\x03\x83\xd4\x23\x37\x9f\x35\xe2\x74\x68\xdd\x74\xf2\xa2\x15\x97\xe0\x8f\x25\xa3\x3e\x06\x7b\xef\xc1\x92\x49\xe3\xfe\xf8\x10\xa6\xdc\x3d\xbb\x72\xfa\xe4\x8d\xb0\x19\xdc\x07\x17\x60\x57\xdb\x82\x51\xe7\x6e\xa0\x9e\x70\xfe\x59\x15\xce\xb1\xa3\xba\x50\x5d\xbc\x8e\xec\x48\x8e\x61\x12\x13\x33\x91\xed\x92\x0a\x34\x4c\x6a\xa2\x4a\x26\xd5\x48\x09\xec\x39\x12\x1e\x26\x6c\xe5\x5f\x6f\xb3\x5f\xaf\x0b\xbe\x3e\x63\x30\xfe\x4e\x2c\xc0\x9e\x07\xf6\x91\xc7\x4e\xf3\x0e\xcd\xb8\x54\x26\x3b\x2b\xc4\xcd\xc3\x23\x38\x32\x8c\x1f\x7e\xf3\xd5\x05\x5f\xa4\x68\x4c\xe7\xc4\x48\x9d\x3d\xc2\xac\xfc\x4a\xda\xeb\x00\x9d\x35\x7a\xf2\xb6\x6d\x03\x46\xbc\x39\xa5\xd0\x0e\xa8\x4f\x4e\x3d\x77\x70\xe2\x8c\x55\xab\x7b\x57\xde\x9b\x59\x62\x07\x63\x8e\xdd\xea\xbc\xdb\xa6\x1f\x2a\xdb\xc7\x20\x8e\xf9\x46\x42\x16\x98\x13\x99\xdf\x33\x6a\xec\xb0\xec\xe2\x08\x4f\x46\xd7\x9e\x69\x07\xae\x3d\xbe\x40\xc7\x95\x74\x1f\x3c\x30\xa3\x40\x9f\x97\xd3\x43\xa8\xf5\xd3\x13\x63\xad\x12\x1b\xc7\x89\xec\x06\xb5\x4c\x8d\xab\x42\x3e\x0a\x6c\xaa\x1d\x66\xb0\x47\x1b\x82\x14\xcc\xd0\x37\xcb\xb2\x22\xf3\x3c\x7d\x07\x46\x7c\xee\x78\x6e\x53\x7d\xbc\x23\xa9\x5b\x9f\xe1\x96\xcf\x90\x0a\xa5\xdd\x63\x1a\xb1\x92\x5d\xf7\xcc\x05\xcd\x21\xcb\xd8\xa5\x0f\x66\xc1\x5d\xa1\x7d\x46\x52\x59\x5e\xb9\x02\x7d\x94\xfb\xd4\x91\x7a\x53\x84\x3e\x82\x0f\xf8\xd3\x5b\x71\x75\xbd\x0a\x5c\x59\x2f\xa4\xf7\xa0\x93\xd2\xe3\x6e\xd7\x7b\x20\xce\x26\x8e\xb7\x2e\x3c\xce\x5f\xae\xbe\x14\xfd\xdc\xee\x9a\x14\x9e\x8c\xe7\x8e\x5a\x8e\x2a\x5c\x97\xb6\x12\x12\x3d\x3d\x52\xcc\x2f\xaf\x61\xfe\x71\xea\x14\x21\xa8\xa5\xe7\x9a\x1e\x17\x8e\x21\x22\x53\xab\x57\xa0\x73\x53\x8a\xf6\xbd\x83\xf8\xeb\xd0\x5c\xc8\xa4\x4a\x44\x02\xd2\x0e\x22\xa8\x88\x47\xce\x05\x76\x47\xf2\xfa\x93\xb3\xed\x3a\xbb\x8d\x57\xd2\x0d\xf3\x66\x03\xc5\x56\xf9\xec\x6e\x39\x51\xe9\x55\x8f\x2f\x94\x6d\xd7\xb8\xb3\x73\xbb\x45\x76\x86\x55\x93\x67\xe5\x96\x30\xf2\x6e\x49\xf3\x2d\x87\x34\x33\xa6\x67\x7a\x5b\xbe\x18\x1e\x95\x93\x65\xda\xa3\xa5\xe8\xd6\xcf\xe0\x20\x61\x6e\x12\xa8\xec\x0b\x3c\xa0\xb3\x2a\x8e\xcf\xb0\xd0\x50\x22\x46\xa5\x42\x06\x7f\x58\x34\x71\xe0\xb2\x61\xed\x33\x2c\x04\xe8\x59\x3b\x30\x8a\xd3\x00\xef\x3c\x27\xa9\xee\xc6\xb6\xf9\xc2\xb1\x1c\x44\x29\x20\x9a\x4a\xf7\xbc\xfe\xce\x65\xd9\xde\xd9\x57\xf2\x27\x74\xee\xbb\x71\xac\xb7\xe0\x8e\xe3\xd2\x13\x78\xfd\x8a\x3c\xbd\xd3\x75\xfe\xa1\x43\xbb\xd4\x68\xba\xe7\x75\x2d\xcd\xe8\xb2\xbc\xdb\xac\xea\xb1\x97\x33\x87\x76\x1b\xb4\xaa\x9f\x89\x4d\x7a\xf6\x1c\x9a\xbf\xcc\xaa\x11\xf7\xff\xac\xf2\x0d\xcc\xe8\x8b\xd6\xf4\x38\x12\xfa\xef\x73\x63\x28\x33\x95\x78\x46\xa5\xd0\x2a\xf8\xcc\x03\x9a\xa0\xa7\x9a\xc5\x62\x56\xab\x62\x85\xc8\x8e\xd0\xe2\xd4\xa4\x34\x35\x36\x87\x73\x42\x01\xb8\xd1\x34\x32\xef\x5b\x31\xb2\x3e\x2c\xb7\x82\x13\x02\x9c\xfc\xc5\x3d\xfb\x66\x84\x35\x81\xc3\xcd\xf0\x2b\x10\xd1\x4c\xaf\x09\x20\xc9\x57\xbb\x92\xfc\x23\xc9\x5e\xfe\x50\xc0\xfc\x37\x53\x71\x41\x1a\xe4\xff\x05\xeb\xff\x11\x28\xff\x6d\xc8\xf6\xe1\x56\x1e\xda\xdf\x0a\xcb\xdf\x64\x3b\x07\xf1\xec\xef\x06\xf0\xfc\x1f\x7c\x14\x02\x65\xcf\xe6\x62\x3e\x95\x8f\x64\xfb\x3a\xc4\x3d\xa2\x90\x9e\xd6\xd9\x1b\xa9\xd1\xc6\x86\xd9\xec\xc8\x46\xe6\x80\x56\x69\x47\x3a\xa7\xdd\xae\x64\xa2\x94\x38\x82\xce\x60\x50\x06\xca\x0c\xba\x79\x84\xe9\x76\xb1\x25\x04\x8e\x83\xec\x6b\x64\x9a\x86\x40\xb9\x93\x88\x45\x0b\x1f\xac\x48\xc2\x25\xc0\xdb\x83\xc1\xef\x83\xcf\x0d\xae\x8f\xa8\xcf\x20\x7a\xb9\x5e\xcc\xf0\x6e\x44\xd3\xc4\x88\x89\x83\xff\xb6\xe8\x42\xb4\x08\x4a\xd4\x8a\x4a\xb6\x13\x4c\x03\x6f\xc3\xb4\x65\x7e\xa2\x9a\x87\x2f\x4b\xe0\xbd\x8a\xf3\x96\x81\xb7\x5b\xba\x3e\xfb\xb4\xad\x1a\xfb\x16\xd1\x3c\x55\xa3\x31\xbc\x84\xc6\x90\x85\xf1\xf8\x13\xe4\x0a\xc4\xd9\x63\x15\x4a\xca\xd2\x76\xaf\x1d\x2c\xd5\x4b\xea\x7d\xd1\x81\x6b\x19\x72\x79\x21\x24\xe1\x61\x1b\x3f\x8e\xf7\x6f\xf0\x78\xcc\x18\x94\x56\xc4\x82\x3f\x5f\xfa\xe7\x92\xe8\x4e\x71\xce\xd8\x0a\xcb\xfc\x3e\x3e\x4f\x97\xbc\x4e\xcb\x67\x4d\x3e\x39\x2a\xca\xb1\xa2\x76\xbe\xa5\x22\x23\xdb\x1e\x63\xdf\x06\x7f\xd0\xdd\x3e\x75\x65\x6d\x4c\x7e\x27\x47\x44\xf4\xea\x8a\x12\xef\xac\x1e\xdd\x56\xf4\x6b\xdc\x50\xff\xfc\x84\xae\xa3\x46\x7a\x27\x2e\x5f\x9d\x15\x1b\xd5\xad\x6c\x64\xc1\x96\xdf\xd6\x22\x9d\x7f\x19\xa2\x17\x09\x0e\x95\x88\x99\x1d\x86\xed\xb6\x8f\x91\xac\xb0\x13\x19\xa5\x3a\x8f\xb6\x91\x4c\x4f\x61\xdd\xc6\xad\xc6\xbc\xd8\xad\x75\x32\xb1\x69\xb8\x28\x0f\x70\xd2\x75\xef\x7d\xf2\xca\x12\x89\x84\x8b\xc8\x73\xc1\xd1\x6f\xb2\x9d\x90\x39\xf1\x52\xf1\xac\xac\xac\x39\xf9\xfe\x7c\xf4\x9e\x63\xe8\x3d\x75\xc4\xa7\x6b\xf1\xca\xe4\x5a\x46\xab\x56\x4b\x22\x90\x8a\xa6\x24\xa0\xb1\x7c\x59\x29\xf2\x4a\x63\x3e\x00\x6e\x52\x4a\xcb\xa3\xc4\x15\x4e\xe2\x14\x0c\x4e\x97\xed\x72\x2b\x4b\xa3\xf2\x00\xe9\x1b\x96\xd3\x66\x5a\x2f\x8e\xeb\x72\xef\xe5\x34\x85\xc8\x6c\xb7\x85\x7d\x74\x12\x2d\x46\xc2\xeb\xae\x59\xb4\x18\xf5\x39\x3c\xef\xbb\xe8\x41\x8d\xb0\x1a\x1c\x79\xcf\x3e\x78\xf8\x20\xb3\x7f\x2f\x6f\x7f\x7e\x84\xfa\xff\x84\xfb\x1c\x6b\xcf\x5e\x85\x4a\x42\x85\xeb\xf4\x02\x98\x3b\x08\x89\x02\xca\x0b\xad\xa1\x87\x44\x6c\x2a\x9d\x4d\xea\x5b\xe5\xd3\xec\xd8\x5e\x19\x11\xb1\x29\xfd\xf6\xf5\xb2\x02\xd1\xa5\xd5\x22\x75\x04\xa3\x81\x61\xd7\xe8\x6d\x53\xd7\x6c\xe4\x3e\xe7\x63\x7c\x1e\xbc\x4d\x37\x59\x2b\x97\x4b\xc4\x8e\x96\xc3\x6c\xe9\x73\x3b\x8a\xd1\xbb\xf7\xa3\x7e\xef\xa3\x71\x87\x61\x1b\x4d\x0c\x00\xcb\xd1\x4a\xa2\x8a\xb8\xf9\x11\x3b\xb4\xfc\xf5\x00\x03\x76\x0d\x84\xa7\x5f\xff\x0d\xbc\xfc\x9e\xff\xd8\x40\x70\x91\x6e\x82\x0a\xf0\xb3\x7f\x1e\x2c\xe5\xe5\x4a\x22\x3a\x8b\x38\x67\xd1\x84\x7d\x46\x4a\xbd\x8e\x24\x24\x69\x94\x0a\x3d\xbe\xee\x11\x3c\x97\xd6\x8e\xbe\x5f\x52\x47\xa9\x5d\xb4\x5c\x10\xfa\x48\x2c\x62\x0e\xb8\xe2\xb3\xe2\x23\x7b\x74\xba\x2a\x33\xfb\x4d\x16\xa6\x7b\x20\xa7\x91\xbe\x93\x11\xf6\x7c\xa2\x33\x7c\xaf\xec\x4a\x6a\xe7\xc5\x2b\x99\x58\x9c\xd6\x08\x13\x79\x9d\x25\xb1\xb5\x8c\x1d\x82\xe8\xd0\xe1\xc8\xb3\x0b\x5a\xa4\x6a\x22\x55\x85\x64\xac\xa9\x7d\x48\x6f\x51\x2b\x4d\x0a\x9d\x5c\x57\xee\x93\x86\xc9\xb1\xf6\x72\x5d\x08\x50\xd5\x04\x6b\x22\xba\xc8\x2d\xb6\xca\xe1\x14\x89\xe3\x3c\x01\x72\x5c\x48\xf0\xf0\x12\x1c\x5c\x06\xe0\x6a\xed\x64\x78\xd8\x9f\x52\xb2\xa8\x0c\xde\x09\x86\x95\xb7\xdc\xa6\x2b\xd2\x1e\xab\x3a\x36\xa4\x4f\xca\x6a\x50\x32\x66\x00\xfc\xb2\x60\x46\xd7\x59\x02\x75\x17\x2a\xc6\x7a\x3a\x47\xb9\xd0\x3c\x89\xd1\x3c\x2d\x47\xf4\x45\x62\xcb\x8e\x51\x59\xad\x52\x4a\x8a\xc9\xb1\xd2\x91\x54\x24\xf6\xc1\x76\x70\x29\xf2\x60\xf0\xa1\x50\xf0\x81\x0b\xd2\x36\xc7\x1a\xb0\x31\xb5\xd1\xb0\xf3\xae\x73\x3b\xe1\x6f\x7b\x9a\xcf\x8f\x00\x67\x41\xd3\x92\xda\x13\xa3\x36\xad\xad\xb0\x82\x77\xfd\xa5\x6c\xa7\x93\x70\x8b\xee\xd5\xbd\x4f\xc1\x6f\xb7\x95\xad\x9b\xe3\x94\x99\x1a\xea\xa7\xbe\xd6\x30\x6f\xfd\x7a\xc0\xc7\x56\x23\x19\x84\x69\x72\x20\x3e\x56\xe0\x75\xc8\x63\x0c\xb1\xe5\x3e\xc6\x6e\x92\xc4\x30\x06\xbb\xc1\xae\xa4\x94\xd1\xfd\x7d\x32\xa5\x95\x76\x50\x8e\x50\x12\xdb\x52\x60\xda\x6e\x6f\x02\xb4\x8a\xc4\x06\xa3\x38\x4e\x24\x5c\x28\x21\x69\x94\x13\xa0\x56\x9b\xe9\x11\x34\x9f\x20\xdd\x45\x79\xf9\x89\xf3\x47\x1e\xbf\xf7\xf4\x15\xdf\xd1\x86\xcb\x17\xb3\x9f\x5c\x59\x49\x08\x9f\x73\x6e\xd6\xc6\x03\x95\x23\x26\x92\x01\x68\x5f\xdf\x3b\x66\x4f\xef\xe2\xae\x0b\x56\x3c\xbe\xa0\xbe\x7c\x51\xc9\xe6\x29\xc3\x16\x36\xa3\x11\x3c\x48\xae\x5d\x5b\xdc\x25\xc7\xcb\xef\xc3\x16\xb4\x9f\x37\x10\x7b\xcb\xe5\xd5\x32\x86\x72\x1f\x60\x64\x0c\x62\x0e\x2a\x09\xae\x4f\x27\x28\xd9\x02\xd5\xee\xb6\x08\xfe\xb6\x20\x81\x28\x35\x1f\xc1\xdf\xaf\x36\xb3\xf8\xd5\x4f\x67\x2c\xa8\xdf\x95\x78\x3e\x1f\x98\xce\x82\xd5\xeb\xe1\x83\xe3\xa5\xb4\x5d\x03\x12\xe0\xca\x25\xb5\xa3\x15\x5b\xcf\xc0\x69\xd7\xe1\x2b\x27\x65\x70\x21\xdf\xf7\x15\xd4\xf7\x61\xd2\x77\xbc\x57\x67\xd0\xe9\x40\xb9\x4f\x17\xae\x0b\xa7\xc4\x62\x05\xb2\x84\x3b\x74\x1e\xf0\x8c\xc5\xa8\xf9\x8b\x3f\xbe\x32\xa8\x50\x91\x8b\x01\xff\x2c\x85\x4f\x6c\x06\x31\xe7\x4f\xbd\x4a\x5f\xa2\x1f\x9b\xf8\xe2\x1b\x8b\x17\x17\x75\xaa\x03\x4d\x16\x30\xe7\x0e\xc8\x39\x75\x72\x87\x62\x54\x1d\xfc\xfe\x3f\xcd\x3b\x35\xfe\xcf\x28\x81\x8f\x17\x06\xfa\x36\x52\xe1\xe1\x62\x40\x7a\x35\x18\x74\x00\xed\x2f\xd0\x71\x5f\x91\x90\x6c\x56\x1d\x1a\xad\x21\x14\xc5\xd0\x32\xce\x7e\x60\xd2\x66\xf8\xd1\xd9\x53\xaf\xd1\x97\xe9\xd9\x13\x2f\xdd\x59\xdc\x54\x9c\x3b\x89\xbb\x05\xeb\x2c\xf0\xf1\x37\xe1\x6b\x27\x4f\x6d\x57\x8c\x99\x00\x34\xbf\xa3\xde\xe9\x4c\x7e\xec\xf9\x68\x0f\xd5\x13\xdf\x8b\xc3\xab\x36\xa0\x43\x17\xa6\x09\xd3\xb0\x06\x0b\x2b\x6d\x8b\x16\xe1\x8b\x43\x21\x85\x4e\x25\x5c\x75\x66\x05\xea\xa4\x09\xe0\xfd\xf9\xfb\x41\xde\xbd\x33\xd7\xaf\x7e\xb8\xf1\xad\xe9\x9f\x7f\x52\x7a\x39\x0b\x7e\x77\xe9\xea\xb5\x1e\xa0\x27\x78\xeb\x7f\x9e\xd9\xaa\xb8\xfe\x36\x9c\xe0\x87\x2b\xdf\x95\x6d\x7d\xf1\x57\xec\x73\x18\x27\xd4\x8c\x95\x23\xae\x6d\xa7\x92\xbd\x52\xab\xa5\xd2\x67\xb5\x86\xb3\xe1\x2a\x62\xe8\x86\xb3\xac\x91\xa8\x72\xac\xa1\x63\x65\x5a\x52\xec\x18\xd7\xfe\x24\x94\x88\x55\x21\xd1\x64\x9c\xc7\x2d\x66\x77\x1c\x80\x6f\xdc\x7c\xe5\xf6\x5e\x90\x79\xe7\xc6\xed\x9b\x5f\x2f\xbf\x31\x79\xe6\x8c\xc7\x5f\x99\x02\x0b\x92\xae\x25\x31\x33\xe0\x2f\x70\xec\x27\x54\xeb\xbf\x81\x06\x3c\xf9\xfe\xef\x2d\xa0\xea\x10\x3c\xfb\xf9\x33\xe7\x8f\x82\xea\xa4\x8f\x3e\xe2\x7d\x53\xd8\xf7\x55\xc1\x76\xd2\x88\x98\xcf\x08\x5f\x2a\x6e\xfd\x81\xd4\xf5\xd5\x05\xe2\x08\x64\x12\x64\x4c\x29\x25\x48\x4d\x90\x48\x4c\x31\x24\x8e\x40\x45\xe2\x08\x0c\x7f\x15\x47\x10\x30\x18\x3a\x07\x8b\x1e\x64\x6a\xb4\x2a\xca\xd1\xbe\xc2\x2c\xb3\x67\xf1\xba\x85\x5b\x1b\x6a\x3b\x5b\xbd\x7b\x77\xcd\x9d\xfb\xf1\xbb\x2f\xc0\x73\xf0\xd5\x6b\x77\xf7\x3c\x71\x66\xd1\xb7\x9b\x6e\xbc\x4f\x1f\xdd\xd0\x3c\x65\x70\x51\xdf\xb5\x93\xc7\xf7\xa8\x02\x36\x10\x0d\x0f\xc0\xad\xab\xe6\x2f\x3c\x60\xea\xb4\x7a\xd4\x1e\xdf\xbb\x42\xdd\x9c\x3a\x52\x07\xbb\xe8\x0c\xc6\xd4\xc5\xdc\xd3\xea\x53\xcb\xa8\x04\xc4\xcc\x2d\x32\xca\x42\x59\x38\x99\x2c\x92\xdc\x6a\xbb\x3a\xdc\x6a\x3f\x5c\x62\xb5\xfd\x05\xf7\xc3\x85\xb1\xff\xe2\xaa\x7b\xef\x40\xfb\xfe\x99\xe9\xa4\x32\x76\xb1\x32\xe1\x2f\xae\xbd\xfb\xcd\x5b\x29\x14\xc6\x0e\xbd\xfd\xc6\xf3\xdf\x07\xcd\xff\x62\x32\xff\x3f\x90\xfc\x97\x4b\x48\xd7\xff\x8c\xe4\x63\xd8\x10\x9f\xcb\xf1\xda\x22\xed\x95\x35\x91\x14\x67\x56\x99\x91\x80\x50\xa9\x02\x6c\x98\xd4\xf6\x56\xfe\x65\x28\x3d\x1f\x2d\x41\xb7\xdd\xe6\x30\x58\x39\x73\x46\x13\x40\x29\xb7\x18\x8c\x02\xff\x7e\x09\x94\x5b\xe0\x49\xb1\x76\xca\xc1\xb1\x6b\x76\x9e\x3d\xfd\xc2\x01\x78\x7d\xcc\xa0\x69\x7a\xee\xe2\xa1\x62\x5a\xea\x7a\xcd\xc5\x76\x6a\x89\x59\xed\x1a\xb5\xab\x7a\xc6\xf8\x4d\xdb\x98\xb2\x07\x79\xf5\x75\xa6\x95\x69\x39\xa2\x38\x7c\xef\x87\x78\xf1\x64\x62\x73\x87\x63\x9c\x0e\x1a\x88\xa5\x2c\xf6\x9c\x4a\xf4\x22\x4b\x20\x05\x14\xfb\x4d\xf9\x4b\x64\xe0\x94\x00\xb0\x1f\xc8\x9f\x2c\x3b\x0b\x3f\x3d\x7b\xd6\x7f\xe5\x1d\x5a\x0d\x8f\x22\x6d\x43\x3e\x0a\x6c\xb8\x9f\xc5\xec\xf6\xff\x02\xde\xa6\x6b\xc9\xf9\xdc\x83\x26\xe1\x26\x7a\x2f\x47\xe9\xce\xd0\x4a\xc0\x92\x73\x01\x04\x4b\x3a\x23\x3d\x01\x60\xbd\x98\x39\xd6\xf2\xeb\xdd\xb3\xe7\xe8\x6a\x44\x63\x4d\x30\x46\x9e\xbb\xcc\xdd\x43\xf2\x2a\x05\xc7\xb6\xe9\x0d\x2c\x63\x60\xcc\x94\x39\x11\xa9\xf9\x06\xad\x55\xae\x94\x28\x2b\x7c\x12\x8a\x54\x49\x54\x51\xed\xb0\xb6\xdb\xc5\xb6\x91\x10\xb6\x90\x6a\x75\xc0\xa9\x09\x09\x71\xeb\x10\xcf\xb9\x00\x87\xc6\x1b\x62\x2c\x27\xd7\x79\x48\xd1\xba\x79\x91\xf0\xc6\xb9\xf1\xda\x40\xe8\x3c\xbd\xa8\x2d\x46\x9e\xed\x3d\x78\xd8\x98\xcb\xeb\xb6\x91\xba\x75\x7f\x9e\xa1\x65\x95\x81\xa0\x79\xb8\xba\x7d\x80\x3c\xa0\x3a\xa1\x3d\xb1\x91\xdc\x4d\xe6\x7a\xed\xd6\x28\x2a\xaa\xbf\xcf\x4c\xb1\x26\xb4\xfe\x2c\xc5\xca\xe5\x2c\xc5\xa8\xed\x7a\x35\x62\x58\x6a\xa1\xaa\x19\x9a\xed\xe0\x4d\xa4\x60\x10\x3f\x24\x2f\xf8\x90\x37\x52\x2e\x4b\xec\xf4\x38\x2a\x80\x3b\x2b\xbd\xfb\xcd\x7f\xcc\x58\x30\xf9\xa9\xd8\x0b\x5d\x81\xe9\xfc\x8d\x57\x36\xc0\xfb\xcf\xea\xc1\x40\x13\x7c\xc6\x7e\xd6\x0e\x6f\x03\x1d\x90\xf2\x42\xa4\x7e\x84\x62\xcb\xb9\x37\xae\xbf\x02\xaf\x1f\x97\x4d\x9e\xb7\x6d\x1b\xa2\xf1\xa8\x20\x43\x22\x71\xcd\x1a\x3b\xcd\xd0\xfd\x7d\x16\x26\xc2\x64\x42\x9a\x20\x63\x52\x2a\x4d\x0c\x83\x78\x3b\x8e\xc3\x6b\x13\x27\xfc\x85\x69\xe8\x6d\x29\x0f\xcb\xfa\x68\xc9\x82\xe9\x04\xff\xb4\xc3\x67\x4c\x60\xa0\xfe\x11\x32\x26\x0b\xb8\x4d\xf0\xb6\x7d\xdb\xbc\xc9\x0f\x8b\x1a\xf8\xdb\xbc\x6d\x88\xef\xca\x10\x7f\xc0\x58\x8d\x66\xca\x45\x6a\x30\x47\x1b\xe2\x75\xf1\xf8\x76\x9c\x51\x52\x3a\xa5\x86\x92\x45\x05\x03\x5e\xf4\xb1\x46\xca\x88\xb6\x06\x95\xd6\x3e\xd4\x37\x14\xa7\xd1\xf1\xa8\x44\x6d\xa2\x03\xba\x84\x3c\x65\x5a\xad\xd7\xb9\x90\x9e\x73\x80\x24\x28\x0f\x1d\x58\x7f\x7e\x1a\x9f\x98\xbd\xbb\x8c\x56\xf1\x78\x8c\x2d\xcf\xe0\xe4\xe4\xb9\x4b\xc0\x56\x9a\x86\xbb\x8a\xfa\xee\xdf\xb8\xf3\x4b\xb0\xec\x75\x3e\x17\x7b\x32\x06\x62\x7c\x8c\x24\x23\xc3\xe7\xe0\x27\xd6\x37\x45\x4c\x26\xda\xdb\x32\xb4\xb7\x23\xd1\x38\x32\xa8\xae\xf8\xb6\x9a\x4a\x35\xa4\x22\x36\x9c\x6a\x75\x44\xe9\xd4\x51\xae\xf0\x70\xb5\xcb\x85\x44\xa8\x4b\xe9\xa4\x6c\xb9\xe5\x3e\x9b\xca\x90\x89\x2d\x39\x75\xb0\x60\x3c\x65\x2a\x68\x1f\xea\x1e\xb8\x07\xe5\x42\x8b\xf5\x20\xa6\xf1\xe8\x5c\x74\x34\x44\x83\x5a\xf0\xcc\x33\x21\x23\xa5\xf3\x45\xde\xa2\x1e\xf3\x7b\xf6\x2f\x4d\x55\x83\x4e\x70\xf7\x6e\xc5\x53\x8f\x18\xb7\xce\x0c\x5f\x3e\x3f\xeb\xee\xf2\xd5\x8d\x61\xcd\xfc\xd0\x97\x0e\x28\x69\xfa\x78\xc1\xd4\xa9\x33\xc1\x9e\x96\x37\x17\x74\x9c\x82\x45\x70\x68\x06\xfc\xf3\x22\x7c\x67\xff\xbc\x8d\x40\x1b\x32\x17\x7c\xfe\xd7\x1f\xad\x95\x9c\x18\xcd\x05\xc6\xa2\xc8\x46\xf3\xe1\xf3\x26\x5a\xb2\xcd\xd9\xe5\xbe\xa8\x9c\x72\x9f\x5e\x17\xe6\xe6\x74\xe6\xa8\x28\xce\xac\x34\x52\xea\x14\x1c\x7b\x2e\x8d\x43\xe7\x46\x6a\xc8\xb3\x8a\x39\x31\xf1\x4e\x50\x9c\x3e\x90\x08\x66\x12\xa2\x8f\xf9\x85\x26\x93\x83\x57\x5b\x58\x6e\xac\x58\xff\xd5\x84\x04\xee\xa2\x44\xce\xd0\xb5\x97\x20\xad\x91\x68\xe0\xd9\x59\xf4\x4b\x03\x34\x0d\xc5\x9b\x1f\xbd\x11\x06\x74\x9e\xbc\x6f\x58\xd9\xb0\xfd\x87\xfd\xa7\x84\xdd\x70\x0b\xdc\x84\xfb\xfe\x27\x65\x40\x4e\xe9\x9e\xd5\xd1\xb9\xb3\x1e\xb1\x2f\x76\xcf\xeb\x51\xb6\xa4\x39\x74\x73\x20\xdd\x20\xde\x3f\xb5\x57\xe9\x84\xe4\x60\x0d\xd1\x64\x0a\x63\x68\x64\x79\x2d\xf6\x44\x2d\xab\xc5\x3e\x40\xad\x2a\x27\x5c\x16\xde\xdf\xa7\x52\xc8\x54\x6c\x17\xa4\xe3\x08\xac\x34\xe0\x6f\xb8\x1e\xac\xe0\x8d\x9d\x91\xbc\x8f\x01\x97\x3b\x77\x8b\x1d\x39\xe4\xe2\x93\x77\x00\x22\x53\x19\x18\xed\x0c\x08\x14\x6e\xc1\xb9\xb9\x1e\x27\xef\x9d\x60\x1b\xe0\x3f\xa0\x6f\x66\x0f\xc9\xca\x05\xe6\xa5\xe5\x0d\x69\x60\x79\x8f\xa2\x27\x37\xef\x1d\x50\xfe\x7a\x64\x97\x89\x49\x35\xa5\x69\xb0\xd3\x8a\xe6\xa8\x6e\x83\x26\xd5\xe6\xa5\x47\x7f\xd5\x24\x8a\xcd\x03\xf3\x4e\xbe\x31\xc6\xeb\x4a\xa6\xaf\x2e\xf9\xf9\x67\xf5\xbc\x46\x85\x4e\xd4\xa3\xd7\xe9\x98\x74\xa7\x4b\x19\x95\x5d\x09\xdf\x1c\x3b\x22\x2e\xd3\x15\x11\xd5\x6d\x68\x61\xe1\xe8\x44\xff\x58\xbb\xc9\x95\x8d\x79\xfc\x02\x74\x0e\x4e\xa2\xb5\x8f\x47\x6b\xdf\xf3\x54\x74\x1a\x5a\xce\xf3\xbe\x68\x03\x76\x46\x61\xd1\x6f\xf2\x19\x10\x9f\x97\x22\x3e\x2f\xa5\x58\xce\xcb\x81\x04\xe2\x5f\x09\xa8\x94\x6a\x77\x84\x49\x75\xbb\x9d\xe3\x8e\x84\x03\x13\x4f\x8b\x27\xd4\x73\xd7\xe6\xb5\xa3\x3d\xa2\x0e\x37\xd7\x1e\xed\x02\xbe\xb6\xe2\x29\x89\xe3\xd2\xc6\xfa\xf8\xa8\x54\x2f\xf6\x29\x3a\x9f\xdf\x81\x1d\x79\xb9\x2e\x4f\xb2\xc3\xb6\x73\x35\x2e\x30\x78\x0e\xfb\x87\x6a\xb7\x6c\x15\x1c\x33\xe9\x27\xce\x08\xce\xc6\xb3\x27\xb4\x7b\x4c\xba\x94\xd2\x4d\xd1\x7c\xb5\x41\xbe\xf8\xa0\x99\x51\xe0\x31\xc6\x21\x5d\xf1\x2b\xb4\x8e\xb9\x54\x31\x35\xc8\x1b\xed\x40\xaa\x8c\x43\x45\x5b\x8a\xd2\x32\x0b\xca\x7d\x96\xb4\x4c\x57\xa6\x8b\x92\x69\xdb\x96\xd4\xcc\xe7\x5c\x23\xcd\x31\xaf\x7d\xfd\xdf\x1b\x81\x4b\xb7\xb6\xb0\x7a\xa1\xb0\x00\x0e\xad\x77\x86\xae\x34\x8e\xfe\x10\x46\xc7\x6f\xf4\x28\x75\x30\xbc\x4f\xdf\x2e\xde\x5e\xb8\x94\x55\x02\x03\xfd\xc3\x9e\xf2\xa5\xab\x87\xd6\x89\x57\xcd\x27\x8b\x7e\xd2\x7c\xaa\x51\x9c\x9e\xdb\xa5\xd4\xb2\xf8\xcf\x7d\xc0\x75\xa8\xbc\x7c\xef\x09\x6e\xf5\xf6\xde\x23\xa7\x8c\xba\x34\x7e\xc6\x9c\x94\xa4\xb4\x71\x45\x7d\xed\xba\x31\x63\xc6\x0c\x8e\x72\xd1\xaf\xa1\x75\x5f\xe2\x9f\xe8\x8a\xc8\x48\xca\xee\xb5\xec\x43\x50\xf0\x2c\xbc\xa3\x51\xe8\x6a\x06\xc2\xbf\xc3\x3f\x2d\x1e\xe3\x9c\xbe\xa3\x7d\xc3\xb6\x54\x2f\x1f\xd8\x37\x2e\x2d\xa7\x73\xa1\x50\x93\x50\x89\x6c\xd2\x1d\xdc\xeb\x54\x16\x55\xe8\x75\x66\x29\x53\xd3\x93\xd2\xcb\x7d\x49\x94\xc3\x15\xeb\xea\xef\x8b\x55\x45\x3a\xf5\x2a\x8d\x5c\x53\x81\x63\x40\x30\x4f\x6f\x27\xe6\xdd\xed\x16\x1e\xbb\xf8\x42\x2e\xbe\x1d\x42\xa9\xe9\xd0\x4b\x67\x21\xd5\xac\x5d\xa9\x49\xfa\x77\x23\xed\x99\x3f\xa0\xa6\x4a\x77\xa0\x13\x6c\xc9\xeb\x16\x95\x5c\x50\x6f\xdb\xa1\x4f\xce\xec\xfd\x58\xd4\xdc\x83\x17\x3f\x7c\xee\xe0\x73\x0d\xe6\x06\x93\x7d\xc3\xbc\xe2\x74\x4b\x92\xcd\xdb\x5b\xa5\x65\x3b\x6d\x1f\x56\x3e\x7a\x5c\xef\xba\x96\xe3\xf0\x43\xd5\x7e\xcd\x26\xc6\x31\xc5\x93\x9f\x41\xa0\x54\x2e\xb4\xf4\x62\x2e\x2c\x99\xbb\xa5\x51\xb6\x32\xac\x64\x30\xf1\x15\xb6\xfe\x1d\xad\xff\xc7\x68\x8f\xa7\x52\x71\x5e\x7d\xa2\xa8\xdc\x97\x68\x90\xd8\x28\xbd\xde\x82\xf4\x18\xbd\x2a\x10\xd0\x22\x9c\xda\x60\xb1\x92\x40\x49\xa5\x47\x67\xcd\x07\x0a\x3f\x89\x9d\x20\xea\xec\xd7\x9d\x7f\xdc\xf8\xf4\xe9\x8e\x89\xf2\x3f\xc7\x75\x1f\x81\x13\xe5\x57\xc1\x5d\xab\x7e\xea\x65\xe0\x6e\x3d\xa8\xe8\x37\x78\xfc\x90\xbf\xca\x8f\x2f\x99\x72\x78\x48\x8f\xae\x53\x04\x3c\xb9\x0f\x11\xbd\x61\x48\x13\x74\x7a\x35\x9c\x84\x41\x06\x2c\x8e\xbc\x11\x21\x4d\x15\xed\x48\x7d\x5b\x1e\x01\x7f\x67\x04\x04\x99\x09\x18\x40\xe2\x6c\x18\x3a\xc2\x1f\x49\xd7\x5a\xfc\xeb\x77\xd2\x1f\xe1\xb8\x9a\x95\x2d\xf7\x56\x33\x27\x5a\xfe\xc1\x44\xe3\xf3\x70\x82\x02\xec\x6f\xe8\xfd\x32\x24\xc5\xf3\xbd\x91\x46\x9d\x49\x03\x58\xa9\x58\xa7\x54\x6b\xc4\x34\xab\xd1\xb3\xac\x5e\xc3\x84\x29\xd4\x7a\x44\x00\xf6\xcb\xbb\x79\xe5\x13\xab\x43\x79\x02\xda\x05\xff\x07\x97\x86\x0b\x07\x4e\x06\x7b\x89\x2c\xc0\xdd\xee\x0b\x73\x78\x59\x4c\xeb\xb2\xec\xf9\x46\x10\x36\x2f\xf9\xd7\xb9\xd0\xba\xcc\x05\x97\xe5\xcc\x37\x01\xf1\xbc\x94\x5f\xe6\x32\x12\xda\xe9\xff\x3b\x7d\xcd\xff\x1a\x9d\x8b\xff\xde\xcf\x6e\xff\x9d\xb7\x9b\x30\x36\x27\xa2\x53\x8c\x94\xf2\x24\xaf\x1e\x70\x9c\x5c\xa4\x08\xaf\xf0\x29\x14\x22\x89\x5c\x2f\x62\x70\x5d\xd3\xd0\xeb\x20\x5e\x63\xc7\x44\x61\xa4\x63\xad\x23\xf0\xc9\x36\x1c\xcf\xf7\x7f\x97\x7f\x62\x18\x33\x1d\x7e\xca\xff\x73\x38\x33\x9d\xf9\x12\x14\xc0\x97\xc1\xbf\xee\x67\xf1\x9f\xfc\x79\x18\x8b\x6c\xd9\xf5\x6c\x1f\xca\x89\xef\x10\x9d\x16\x0a\x00\x26\x4a\xa9\x90\xa9\x65\x15\x48\xee\x85\x60\x30\x84\xde\x23\xe2\x7c\x14\x91\x33\x2a\x3b\x78\x43\x10\xd7\xfe\x86\x80\x8f\xdd\x61\x5c\x4c\xd3\xdb\xad\x94\x3a\xdb\x5c\x13\xef\xd6\xf6\xa8\x1d\x3f\x51\xeb\x51\xf7\xa9\x9c\x72\xc4\x3e\xff\x2c\xfc\xe8\xdc\xfa\x03\x9f\xf7\x18\x00\x54\xcb\xb3\x1a\x2c\x9b\x12\xe6\xcf\x2d\x1b\x05\xbf\xac\xcc\x2e\xed\x76\xfc\x49\x7a\xd1\x7d\x6b\x80\xb6\x2a\x42\x5b\x06\xb6\x22\x13\xe2\x92\xe3\x2a\x7c\xc9\xd6\xff\x2f\x0a\x03\x59\x33\xff\x1b\x95\x1d\x5d\xe3\xff\x8d\xe6\xf7\xe4\x9e\x82\xf4\x2e\xe2\x0a\xef\xda\x06\xcd\x7f\x21\xfe\xc1\xe9\xe2\xd4\xa2\x7c\xdd\x6e\xe3\xec\x79\x45\x83\x89\x7d\x0c\x6a\xc0\xb7\xac\x54\x44\xa9\xc4\x4c\x12\x3d\x9b\x22\x63\x03\x76\xf0\x2d\x73\x1b\xed\xef\x68\xca\x75\xda\x66\x31\x5d\x04\xee\x73\x54\x74\x34\x23\xd5\x5d\x02\xa9\x68\xf9\x19\x90\x21\xc4\x8e\xa0\xd1\x90\xa8\xae\x20\xa7\x71\x6a\x85\x32\x76\xc4\x31\xeb\x6e\x4b\x1f\xa3\xc3\x73\xa7\xf5\x1b\x3b\x56\x31\x68\xde\x40\xd9\x9c\xaa\x25\xba\xfe\x73\xf6\xaa\x27\x0c\xca\x88\xd1\xd9\x4d\x49\x19\x72\xa3\x8a\x1d\x55\xee\x1d\x3f\x32\xbe\x0f\xcc\x02\xaf\x16\xc6\xcf\x5e\x35\x0d\x0e\x64\x86\xd6\x4c\x50\xd6\x29\xba\xf5\x58\x90\x4b\xd1\x60\x32\xf5\x22\x33\x9c\xc3\x35\x92\xd5\x94\xe5\x32\x25\x07\xe9\x84\xd4\xcc\xd3\x62\x09\xb2\xa1\xb2\x29\x5c\xf8\x1f\xaf\x3e\xb1\xfe\x82\xb7\x65\x6e\x24\xeb\xe8\x37\x8d\x73\x0d\x70\x41\x74\x8e\x4a\x17\x93\x10\x2f\xdb\x35\x77\xaf\x6e\x28\xb7\x7c\xce\x9c\x07\xb9\x92\x11\x5c\xa7\x6e\x4c\x8f\x96\x43\x13\x47\xe1\xb9\xa0\xad\x68\x2e\x18\xf6\x67\x34\x17\x29\xf4\x3b\xc2\x5c\xcc\x00\x1f\x33\x83\xd9\x2f\x50\xaf\xf6\xd3\x34\xa5\xbc\x08\xd2\xce\xc8\x44\xe1\xd2\xe7\xd1\x4c\x88\x10\x0d\x24\x43\x95\x9f\x84\x40\x8f\x18\x1f\x80\x48\x58\xb0\x32\xc6\xdc\x73\xba\xa1\x74\xee\x64\xdb\x4c\x13\x93\x50\xd5\x35\xda\x4e\xf7\x93\x6c\x6b\x00\x6b\xfd\x17\x4e\xed\xa8\xaa\x90\x90\xf7\x53\x2f\x90\xf7\x5b\xa9\x98\xf3\x06\xa3\x51\x44\xe3\x5b\xaf\xb4\xd3\xf2\x70\xd5\xf3\x20\x2b\xd0\x85\x5b\x08\xa1\x0b\xed\x25\xa4\x9e\x73\x01\xe8\xd0\xe1\x1e\xa6\x30\x31\x52\x97\x91\x58\x38\x50\x94\x4a\x27\x0c\xec\x1a\x67\xa6\xcb\x70\xc7\xcd\x2d\xcf\x3a\x0b\x25\x53\x25\x65\xfd\xac\xce\xaf\x07\x95\x4b\xd1\xbc\xa6\xa2\x31\xe7\xa0\xfe\xe5\x88\x93\x59\xce\xe9\x28\x2a\x9c\x96\x5d\x42\xbd\xea\xa9\x70\x34\x44\x7e\x99\xc9\x39\x6e\x77\xa5\xab\xe5\x13\x29\x18\x00\x57\x82\x88\xcd\xf0\x9d\x3e\xe5\x47\x9e\x80\xaf\xac\x9b\xd7\xb9\x66\xd0\xf2\x33\xe9\xcc\x09\x90\x0d\xaf\xa8\x46\xf4\x6a\x58\x41\xdf\xf7\x8f\xab\xee\x3e\x01\x3e\xc0\x67\xe6\x9f\xa8\xaf\x77\x51\x5f\x5a\xca\x71\x4a\x23\xc6\xbd\x30\x78\x21\xcf\xaa\xa4\x52\x20\xba\x48\xba\xc3\xd9\x92\xee\x02\xc2\x37\x98\x38\xb4\x8b\x10\x07\x33\x16\x20\x9b\x58\x6b\xf4\x20\x36\x36\xbd\xd9\xc2\xa4\x7e\xd7\x9c\x3f\xc7\xc2\xe9\x9c\x5f\x2f\xb1\xb3\x7a\x20\x69\x00\xdf\xd2\xfa\x05\xb3\xfd\x5f\xa0\xae\xee\xaf\xce\x1c\x40\x87\xfb\xff\xb3\x3c\x93\x1e\x8e\xfa\xfb\x91\x7a\x81\xed\x8c\xfa\xd3\x51\xe6\x33\x62\x99\x32\xec\x22\x48\x3f\xcd\x32\xd4\x45\x34\xb1\x05\x99\xf8\x36\x01\x47\xdd\x0b\xe1\x62\x0c\xae\xc5\x8a\xaf\x14\x80\x82\x06\x25\x99\xf1\xfa\xac\x6e\xe3\xba\x3e\x31\xbf\xaf\x41\x24\x36\x83\xd8\xc7\xe1\xa0\xfe\xbe\x51\x2f\x48\x87\x8b\x46\x4c\xa3\x7f\x81\x83\x1b\x4b\xd5\x19\x74\x9a\x9f\x6b\xae\xcd\x46\xfb\xe6\x1d\xa6\x2f\x2b\xe2\x6e\xa9\x44\x94\x74\x0e\x3e\x53\x3f\xa3\xef\x5f\x91\xef\xdc\x1c\x5c\x27\x6f\x24\xcb\x30\x4b\x48\xbd\x32\xd9\x19\xb1\x18\x71\xf1\xb4\x5b\xa4\xae\xb4\x87\xcf\x54\x77\x8b\xe9\x91\x56\x4d\x51\xee\x9c\x39\x66\x5f\x2c\xcb\x6c\x1c\xb1\xb1\xfb\xe3\x8b\xae\x09\xed\x9a\x84\x76\x61\x61\x14\x17\x68\x87\xcb\x42\x62\xc5\xdd\xc3\x34\x59\xd5\xde\xce\xa4\x1d\x77\x6b\x63\xcd\x13\xbd\xf8\x76\xcd\xa8\xdd\x7c\x22\x53\x64\x67\x68\x9c\x8e\x1e\x68\xe7\x44\x2c\x85\x84\xb4\xa0\xf1\xce\x8f\xf5\x89\xdc\x73\x9c\xe2\x18\xee\xd6\xb5\x28\xc7\xc8\x31\xfd\x07\xdb\xbb\x5f\x22\x7b\x9e\xde\xc1\x36\x30\x0b\xb9\x5f\xd0\x9e\x08\x3b\xc5\x4a\x51\x6b\xde\xe9\xe5\xe1\x0d\x02\x4f\x66\x0e\x13\x93\xe2\x54\x77\xab\x5a\x3c\x4a\xed\xee\xce\x95\xc6\x25\x0f\xec\xd3\x7b\xcc\xe2\x81\xbd\x70\xdb\x25\xa8\xed\x38\xa1\x2d\x92\x08\x69\x6f\x92\x0b\x5b\x2c\xb3\xc5\xbc\xaf\x8c\xb1\x92\x86\x99\x3d\x92\x9d\x6c\x43\xdf\xde\xe3\x16\x0e\xec\x9e\x1b\x97\x42\xce\xda\x16\xc4\x77\xfe\x46\x7c\xa7\xd6\x0b\x06\x82\xf9\x22\x51\x3e\x0f\x92\xd1\xff\x4a\xe5\x2f\x42\xd2\xd2\xc8\x49\xd3\x0a\x5e\xf7\x10\x04\x16\x9c\xab\x0c\x5e\xef\x1e\x91\x34\x60\x72\xe1\xa6\x95\x19\x33\xa2\xb7\xcd\x6b\x5c\x5b\xb5\x67\x72\x3a\xf8\x16\x8c\x92\x0f\x7b\xa5\xe6\xc4\x2a\xfd\xe8\xe9\x6b\x17\x4d\xfe\x71\x21\xfb\x07\xee\x6b\x3d\xda\x8b\x2a\x62\x3b\x5b\x2f\x98\x80\x41\x6e\x90\x2b\x25\x8f\xea\xcb\x43\x2e\x73\xe9\x40\x96\x8b\x70\xd1\xe6\x61\x68\x77\xc6\xe8\x69\xee\xb1\xeb\xc6\x4d\x69\xa2\xe7\x4a\xe6\x0f\xa8\x2b\x2c\x2b\x49\x8a\xea\x01\xbe\xfd\x43\xdc\xbc\xa0\xf2\x85\xe5\xdd\xa6\xd5\x49\x97\xf9\x5e\xaf\xf4\x0d\x93\xc3\xa7\x5a\x5b\xa9\x89\xd4\x76\xb6\x8c\x3d\x8a\xf6\x44\xe4\xef\xd8\x2f\xd6\x88\xbe\x8f\x26\xdf\x1d\x32\x7c\x36\x66\x53\x3f\xb0\x55\xec\x45\x4a\x84\xd7\x4c\xc4\x02\x2a\xcd\x7d\x1b\x6f\x4f\xa7\x04\x97\xc8\x62\xab\x0e\xc1\x73\xf0\xe2\x21\xb0\xfd\xf0\x0f\x8c\xa2\xe5\x67\xe6\x8d\x8e\x6d\x58\x8e\x41\x6d\x6e\x67\x92\x36\xb8\x5e\x88\x9b\xbe\x78\x18\x8e\x3b\x04\x4a\x40\xe9\xa1\x1f\x98\x37\x50\x1b\x05\x1e\xf7\x0e\xf6\x14\x9b\xcd\x9d\xc5\x7b\xea\x1c\x1d\xb6\xa6\x86\x7e\x82\x22\x1e\x35\xb1\x33\xce\xc9\x39\x3d\x2e\x37\x9b\xcd\xd6\xbe\x44\x43\xff\x04\x16\xa4\xec\x67\x5f\xc1\xc8\xb5\x3f\xa1\x76\xaf\xa3\x76\x63\x84\x76\x80\x59\x53\x03\x84\x76\x6d\x55\x49\xba\xee\xbf\x23\xc0\xe0\xb2\xa7\x02\x80\xb7\x80\x3e\xc0\x36\x32\x55\x7c\x8d\xc8\xd3\x4c\x23\x22\x31\xe2\x36\x51\x0a\xdc\x8c\x61\x5a\xe1\x34\xb6\x11\xf4\xe1\xf9\xec\x87\x88\x33\x98\xb8\x4a\xec\xd5\x38\x47\x31\xeb\x7c\xd4\x26\xfe\xfd\x38\xa4\xbc\xd5\xff\x37\x33\x1d\xc7\xbe\xbb\x08\xbd\xaf\x33\x7b\x8e\xb9\x8a\xde\xc7\x91\xf7\x51\xc2\xfb\x70\x52\x35\x87\xfe\xdf\xd9\x3b\x1c\xfc\x98\x3d\xa7\x03\x8c\xed\x3e\xbf\x97\x35\xe8\xf9\x9c\x87\x9e\x47\x44\x6b\xc5\xf4\xbb\x57\x45\x77\xfa\xb1\xec\xb9\xfb\x36\xe8\xd7\x91\x58\xee\x3a\x3a\xbe\xf5\x3c\xa1\x15\x34\x32\x6d\xb4\x82\x7f\x21\x5a\x61\x9d\x40\x2b\x75\x0e\x7e\x4f\xff\xd2\x3a\x11\x3d\x17\x76\x0a\xa0\xc7\x04\xf4\x4f\xfa\x9e\xff\x23\x33\xed\x82\xdf\x23\x3a\x81\x07\xbd\xab\xa6\x75\x31\xe9\x97\x0a\xbe\x8b\xf4\x0b\xfe\x24\xfd\xc2\xba\x40\xbf\x22\xf4\xec\xda\x87\x9e\x25\x63\x02\x22\x7e\x4c\xb0\x2e\x38\x26\x1a\x6c\xa4\x28\xa6\x33\xdb\x89\xd4\xd4\x54\x9e\xc3\xe0\x71\x4a\x96\x4a\x2b\x50\x13\x33\x17\x2d\x24\x83\x96\x84\xe9\xdc\x2c\xef\x72\x77\x9d\x1c\x3d\xf7\xc1\x07\x0f\x6e\x7c\xf0\x01\x9a\x8b\x31\xcc\x68\xa1\x9d\x04\xcb\x32\xc4\x04\x85\xe7\x3b\x0b\xcf\x21\x5a\xee\x50\x43\xe8\xd3\xe0\x83\xbf\x3e\xfb\x74\x75\xdb\xd9\x07\x69\xa1\x67\x1f\x5c\x40\x6d\xb7\x0b\x6d\x85\xb3\xef\x6a\x77\xf6\xe9\xf2\xe0\xd9\x1f\x12\x7a\xf4\x51\xdb\x7a\xea\x59\xfa\x6b\x00\xd1\x88\x54\xe7\xb8\x46\x11\x4d\xe3\x13\x80\x4c\x5a\xd4\xbf\xcb\xc1\x5b\x71\xf4\x3b\x70\x9b\x7e\x5e\xca\xb4\x94\x79\xcf\xd6\x7f\xf9\x25\x6a\xb3\x95\x7a\x96\xd1\x09\x6d\x90\x42\x2a\x26\x53\x77\x2b\x93\xd7\x85\xb1\x18\x46\x6b\xd2\x4a\x1a\xe8\xc1\x78\xb0\xf1\xcb\x2f\xeb\xf9\xbe\x9a\xa8\xa7\x69\x48\x63\x8d\x5e\x77\x01\xb5\x93\x8a\x44\x12\xd4\xf2\x36\x86\x2b\x0a\x69\xcb\xf7\xf9\xcd\x3c\xd3\x34\xd3\x3c\x3d\xf9\x09\xa2\x16\x2c\xa8\x9f\x3f\x9f\xec\x81\xfb\x40\xcb\x2c\x03\x7b\xc8\x1e\x20\xb4\x0a\x7b\xb5\xce\xbf\xde\x42\x4f\x05\xda\xb5\xa8\x9f\x4f\xd1\x99\xa9\x40\x67\x46\x8e\x73\x03\xa4\x2c\x25\x46\xdb\x9a\x5d\x53\x43\xe1\xa3\x13\x8c\x65\xe9\x0a\xdc\x81\x9c\x0a\xfa\xcb\x86\xb5\x8b\xc2\x9e\x1c\x38\xda\xb6\x28\xe3\x25\xf6\xd4\xaa\x19\xa2\x65\x3d\x0a\xe6\xae\x24\xfb\x78\x33\x27\x23\xb2\x80\x9c\x0f\xb0\xa1\x26\x70\x3e\x70\x46\xcb\x66\xd7\x6b\x2e\x52\xfe\x90\xa2\x69\x39\x3b\x9f\xf9\x53\x14\x8e\xfa\x34\x53\x51\x5e\x8d\x58\xdd\xec\x13\xe3\x2a\x57\x62\x31\x45\x19\x9b\x7d\xa4\x6f\x02\x58\xc6\x57\xae\x6b\x2b\xca\xa0\x00\x9e\x90\x1a\x0c\xf4\xc7\x23\xa6\x90\x02\x0b\xbd\x9b\xca\x83\xc5\x14\xe6\x57\x95\x92\x42\x09\x05\xd3\xf2\xdf\x0f\x94\x45\xc0\xf3\x69\x85\x03\xe9\x59\xe8\x5f\x2a\x4a\x7b\x1a\xf1\xa2\x8b\x20\xf6\x74\x20\xab\x30\x2d\xc0\xfe\xf1\xf8\xf8\x60\x2c\x11\x78\xab\xc6\x37\x63\xc8\xb2\xca\xc9\x65\x9e\x42\x7d\x11\x1c\xd8\xb7\x5b\xf9\x8e\x8c\xa4\x27\xba\x14\x99\x26\x5a\xc8\xfb\x16\xa1\x79\x5b\xc0\x1d\xa1\x4c\xb8\x9a\xa5\x8c\x5b\xe7\xd3\xc9\xf0\x10\x64\x94\x97\x52\xaf\xf3\x85\xe1\x31\x64\x92\x62\x9d\xb7\x93\x32\xc9\x28\xf8\xdc\x34\x9c\x83\x92\x49\x22\xbc\x50\x67\x34\xd3\x94\xd8\xa7\xa4\xbb\xd3\x95\x6e\x9e\x92\x38\xaf\x2a\xb9\x6f\xcf\x22\x47\x7c\xa6\x6e\x6a\x64\xe1\x10\xf6\x94\x2b\xc5\x95\x56\xb2\x72\x0a\xfa\xf0\x78\x47\x8e\xcc\xc1\xf6\xcd\x2e\xf6\x14\x73\x03\xad\x15\x87\x77\x85\x57\x12\x46\x73\xf4\x9a\x9a\x70\xee\x09\x2a\x18\x1f\x5b\x00\xd0\x79\x74\x90\x9f\xb4\x84\x85\x97\x44\xf0\x10\xcc\xe1\x3f\xd9\x53\xba\x9f\x6c\x5f\xe1\xbf\x64\x6f\x48\xc1\x58\x1a\x30\x32\x74\xc2\x8c\x5e\x89\x88\x65\x25\x0a\xb9\x1c\x31\xce\x34\xbc\x35\x79\x53\x4d\x1b\x92\x3c\xdb\x15\x88\x3d\xf7\x69\x3a\xd6\x9d\x55\x15\xb9\x72\xc0\xc4\xa1\x15\x2c\x23\x5b\x51\xdc\x25\xfe\x89\xac\xc7\x27\x1b\xb5\xab\xd1\x7c\x0c\x66\x52\xd8\xe1\xdc\xdb\x88\x32\xf1\x49\x8e\x32\x13\x51\x1e\xc7\xc5\xb9\x90\xe6\xe2\x32\x72\x0c\xac\xbd\x09\xdf\xeb\x09\x92\xdf\xa8\x7d\x1d\x24\xf6\x84\xef\x31\xcb\xaa\x1f\x3c\xa8\xbe\x7f\x9f\xfc\xc4\xfc\x62\x3b\xd2\x83\xca\x89\x0e\x6b\x45\xd2\x8e\xa1\x44\x46\x16\x68\x90\x96\x97\x45\xb1\xe8\xed\xe9\xbc\x96\x47\xa2\xe6\x88\xc1\x28\xa8\x79\x7c\x92\x33\x56\xf4\x48\x12\xa2\x81\xce\xde\xb1\x70\x36\xc8\x5b\x09\xa7\x47\xc9\x6b\x2a\xbb\x95\xf7\x2d\xb5\x39\xcc\xb9\x16\x33\x5d\x4d\xaf\xf1\x7f\x4b\x1b\xfc\x53\xc6\x15\x47\x8e\x98\x54\x51\x34\x70\xec\xd7\xd9\x29\x9e\x1e\xe5\x5e\x93\x99\xe4\x22\xd1\x66\xf0\x1d\x53\x25\x02\x68\xef\x2a\x2e\x61\x9d\x5d\x10\xb2\x58\x92\xbb\x19\xda\x7c\x7d\xee\x75\xf0\x1d\x6b\x78\xf0\x2d\x5e\xfb\x22\xa4\x6f\x7f\xcc\xfe\x0f\xe5\x42\x6b\x2f\x95\x47\x46\x88\xd1\x1f\xc6\x6a\xbc\x84\x6c\x0e\x29\xb2\x3c\xd2\x02\x51\xeb\x41\x9c\x3d\xd1\x23\x6a\x2e\xe7\x04\x2c\x0f\xbe\x30\x33\x73\xe4\xf0\x9e\x85\xcb\x23\xc6\xe8\x6a\x06\x8d\x1c\x6b\xcb\x1b\xd1\x30\x66\xe7\x86\x9f\xa2\xa6\x58\xd7\x54\x0e\xf1\xce\xac\xa9\xcc\xa0\x5f\x9f\xb6\xa0\xba\x32\x3e\x2f\xbf\x87\xd7\x96\xec\x70\xc4\x8e\xef\x31\x6e\xca\x59\x75\x6d\xae\x3b\xd1\xe3\xb2\xe7\x95\x11\x3b\xc9\x80\xf4\x85\x54\xf6\x0b\x64\x1b\xa4\xd3\xfb\x28\xde\x76\x12\x74\x08\x8d\x88\x6e\x22\xfb\x76\x26\xe2\xcb\xd5\x82\xac\x01\x0c\x62\xc9\x6e\x8c\x16\x47\x8a\x10\x33\xd5\x5b\xe0\x69\xf0\x05\xd7\x63\x79\xc8\x73\x98\x6f\x31\x2c\x2b\x06\x48\x43\x4b\xe3\xd5\x6c\xfe\x69\xb5\x9b\x7f\xbe\x6c\x0b\xf3\xc5\x72\x30\x8a\xfa\xbf\xb5\xa1\x77\x2e\xa7\x8f\xfe\x1f\xdb\x80\xaa\xe5\xcc\x4f\x6d\x6d\xde\x20\x63\xa0\x01\x52\x39\xf1\xd3\x09\x80\x7f\x16\x5a\xd1\xa3\xcb\xb9\xee\xc4\x6e\xa1\x98\xc1\xcc\x54\xf2\x1c\x8b\x85\x20\xff\x1c\x2e\xbe\xcc\x0c\x86\xe6\xc9\x60\x0e\x33\xb5\xe5\x4f\xc1\x86\x12\x9e\x25\x7c\x5a\x24\xe2\x18\x2e\x48\x07\xc0\x45\x9a\xf9\x36\x8f\x4f\x46\x8d\x70\x6d\x66\x66\x2a\x9c\x4b\xce\xd1\x01\x58\xc5\xd8\x5b\xa7\x20\xfd\x46\x71\x96\xa3\x11\x77\xa7\xd2\x32\x23\x6e\x23\xa1\x85\xa3\x5a\xdd\x46\x0f\x63\x87\xdf\xbc\xb4\xef\x64\xdd\xa9\x0d\xf0\x6b\x60\x7a\xf1\x45\xbc\xd7\xcf\xb3\x1f\xb0\x63\x45\x56\xbe\xde\xf4\x59\xc0\x34\x8a\x50\x67\x48\x8c\x64\x0a\xfc\x19\xa3\x80\x95\xf9\xd7\x1b\xe9\xa9\x05\xe4\x27\x77\x70\x36\xbc\x34\x9b\x97\xab\x73\x91\xde\xfc\x16\xd1\xb7\xb5\x94\xe6\xbc\x26\x2c\x4c\x4b\x29\x71\xeb\x5b\x99\x3c\xad\x41\xbd\xdb\x11\xfc\x17\xbd\x23\xa8\x81\x83\xdf\x1f\x56\xc6\x83\x3a\x39\x25\x85\xbb\xc1\xf1\x56\xac\xab\x29\xcf\xb1\xa0\x91\x63\x8c\x68\x27\x93\xc1\x68\xc9\x58\xdc\x6f\x56\x4c\x9f\x5e\xb0\x78\x3a\x7a\xcc\x7c\xf4\x28\x1f\x8b\xf4\x0e\xfa\xf2\x58\x5b\x1b\x5a\x14\x6c\x83\xd4\x2e\x31\xd6\x4b\x1e\xc3\x4d\x3e\xad\x80\xbb\x8f\x1e\x05\x66\x32\x67\x29\x70\x10\x6a\x73\x1f\xb5\x41\xf2\x9b\x22\xf2\x9b\x53\x02\xa3\x38\xce\x03\x1e\x33\xbc\xf0\xa4\xe1\x0f\x95\x68\xfa\x88\x11\xd3\x8f\x54\xa0\x67\x65\xe8\xd9\x41\xc2\xb3\xb4\x88\x7f\x56\xcc\x15\x20\x2d\x05\x0c\x52\xc1\x1b\x86\x17\xb6\x1a\x4f\x54\x1c\xc1\x8f\x93\xf9\x69\xfd\x05\x56\x81\x55\xad\xef\x22\x3e\x64\x44\x1a\xa7\x9e\x51\x4a\xc8\xe4\xe0\xd8\x21\x9e\x5d\x04\x4a\x8b\x07\xa4\x08\x58\xb5\x69\x68\x8f\x11\x1b\x86\xf7\x18\x39\x32\x3d\x2e\xb7\x67\x7a\x7c\x56\xef\x37\xab\x96\x0e\xed\x31\x60\x79\x4d\x7f\x57\x4a\x8f\x74\x57\x5a\x77\x4c\xf3\x3a\xa4\xbc\xff\x9d\xee\xd6\x41\x47\x63\x88\xae\x34\xef\x7b\xd1\x9d\x39\x2c\x7a\xc0\x60\x83\xff\xd4\xf1\x74\x7c\x0d\x94\xf4\x06\xf2\x7c\x38\x5a\xe3\x30\xb4\xc6\xc1\x9d\xc1\xb7\x72\x90\x9f\x74\x1a\x69\x0b\x7b\xb6\x7b\x45\xf0\x45\x74\xeb\x19\xf4\x9e\xd7\x1f\xfd\x1e\x06\x6b\x5f\xc0\x4d\x7e\xf6\x65\xbf\xb9\x23\x82\x87\xfd\xfc\x07\x50\xea\x40\xa4\x0d\x7e\xcb\xff\x24\xeb\x94\x01\xeb\xe9\xcc\xd6\x06\x34\x2b\xba\x0b\x5a\x99\x44\x4d\x35\x72\x32\xbc\xe9\xfe\x9e\x79\x5d\x75\xfd\x11\xf2\x09\x8b\x27\x90\x95\xd8\xa7\x87\x37\xd2\xd3\x4d\x57\x93\xd0\x38\x28\xb9\x6f\xf7\x7c\xfb\xb8\xd8\x21\xd1\xdd\x6a\x60\x3d\x12\x4b\xf9\x79\x6b\x17\xa1\x8f\xc7\xea\xc6\x75\x41\xfb\xf2\x5b\xb0\x91\x59\x24\xd4\x50\x37\x7b\x65\x34\xb3\xa1\x86\x66\xbd\x2c\xb7\xa1\x06\xf1\x18\x22\x08\x6f\x09\xaa\x00\x51\x07\x36\xc5\x5f\x8b\x87\x4f\xa0\x1f\xac\xff\xce\x9d\x96\xcd\x77\xee\x60\x1e\xac\x46\x7a\xc1\xd7\x84\x37\xc9\xce\x00\x4e\xd0\x94\x48\x98\x10\x76\xcc\xbd\x05\xbf\x4f\x68\x2a\x04\x5b\xb8\xfe\xef\x81\x72\xc2\xb3\x3b\xa3\xe7\xbf\x11\x9e\xe7\x04\x65\x98\x3c\xcf\x60\xad\xaa\x12\x6c\x29\x6c\x4a\x80\xdf\x73\xb7\xe0\xc9\xf7\xc8\xbe\xfb\x04\x56\x21\x1d\xf6\x10\x79\x9e\x0d\x7d\x1e\xcd\xa0\x83\x9e\x05\xeb\xd0\xf3\x40\x87\x36\x50\x79\xdb\xf3\xe7\x85\xe7\xa9\x36\x7a\xb4\x48\xd7\x63\x1c\xbf\x03\x1d\x22\x07\xd6\xc1\xbb\xef\xc1\x93\xbc\xce\x9d\x81\x78\xc1\x18\xf4\x3c\x3e\xd5\xe8\xfd\x22\xac\x76\x87\xf4\x80\x5a\x39\xfd\x8a\xc2\x15\x71\xe0\x9f\x71\x2b\x71\x2f\x37\x6f\x0a\x79\x8a\xb0\x9a\x29\x14\xfa\xa1\x39\xde\x00\x41\xad\x8c\x6e\x0c\x6a\x36\x75\x5d\x1c\x5d\x1b\xe1\x0f\xf3\xbd\xf6\x38\x7e\xf6\x55\xf4\x6c\x18\xb5\x13\x9d\x7f\xc4\x39\xc2\xc2\x18\xde\x70\xc6\xb1\x71\x0e\xa3\x93\xf1\x60\xe8\x31\xfa\x37\x38\x68\xd5\xd4\xdd\x0c\x90\x4f\xfd\x06\x1c\x3d\xf7\x0b\xb0\x28\x80\xe5\x17\x0a\xc0\x7f\x8b\x64\x94\x4e\xec\x6c\xbf\x87\x19\xa2\xef\x97\x11\x75\x5f\x24\xe3\xd5\x7d\xb4\x5f\x7c\xe8\xd9\x4f\x1f\x7a\x96\xe8\xfb\x87\x78\x75\x5f\x24\xe3\xd5\x7d\xd0\x9a\xcd\x9e\x02\x77\xb8\x77\x08\x4d\xac\x04\x29\xc6\xc1\x71\x0b\x16\x1b\x92\xd7\x77\xd8\xda\xe7\x69\xf8\x3b\xb2\xd8\xec\xb7\x90\xc5\x76\xe4\x88\x0e\x60\x5b\xaf\xc5\xcd\xb5\xb4\x66\x88\x7e\x45\x7a\x94\xee\x82\x4e\x26\xe1\x64\x8d\x6a\x61\x83\x3f\x7a\x5f\x12\xbd\x09\xe6\x10\xbd\x29\x26\xcd\xd2\x51\x6f\xe2\x5a\xd0\x96\x4c\xe9\x1d\xaa\x37\x81\xd6\x99\xec\xbb\xe0\x34\xb1\xdb\xda\xe9\xc1\x60\x1b\xb1\x85\x88\xcd\x06\x67\x88\x9c\x4c\xb6\xe8\x00\x6f\x2f\x61\x0a\xf0\x66\x75\x88\xe1\x0c\x33\x7b\xc4\x2c\x72\x36\x35\xa1\xf7\xac\x63\xcf\x83\x0f\xb9\xe7\x29\x05\x1a\x67\x38\xd7\x18\x46\x08\x25\x3b\x02\x8b\x77\x37\x8f\x62\x83\x74\xc8\xa6\xe9\x8d\x00\xd4\xd2\x83\x7a\x97\x4e\x35\xd7\xc6\x9f\x67\xcf\x2f\x9a\xa6\xeb\xda\xb3\xa4\xcb\xdc\x55\xfc\x7a\xa7\xb0\xef\x01\x9a\x5b\x8c\xfa\x0a\x3f\x4b\x81\xf5\x35\xf8\xc6\x9b\xdc\x82\x89\x53\x1c\x67\x1d\xec\x7b\xc7\x8e\xf1\x3c\x64\x12\x7b\x0d\xbc\xc8\xcd\x23\x67\x4a\x73\x81\xa3\x29\x7a\x7d\x0d\xe6\x97\x99\x42\x7c\x81\x87\x6c\x2a\xf1\xef\x31\x4f\xc7\xf8\xdf\x89\x39\x10\xc3\x5e\xbb\x88\xfe\x23\x7d\xc0\x8f\xb8\x9b\x54\x83\x38\x89\xd2\x60\xb9\xc4\x30\x61\x4a\x5e\xb5\x43\x6b\xc8\x03\xa4\xe4\xe0\x3a\xcf\x22\x25\x70\x62\xf4\xb4\xe4\xd8\x92\xde\xb2\xe1\x13\xdf\xa9\x1d\x23\x9d\x6a\x2c\xcb\x16\xad\x8e\xb0\x99\x46\xdb\x17\x94\x8c\x08\xcf\x6c\x60\x9c\x84\x96\x2f\xd8\x2f\xc1\x3c\xd1\x28\x81\xaf\x2a\x25\x7a\x46\xe0\xab\xe0\xaf\xf8\xea\xbc\x87\xf8\x2a\xf7\x52\x47\xc6\x4a\xc3\x56\xf6\x14\x9d\xcf\x7d\xf1\x48\x3e\x89\x77\x33\xe2\x6f\xf8\x27\x7a\x0e\xa8\x11\x6b\x6b\xf4\x0b\x9f\x48\x9d\x6d\xcf\xe2\xd0\xfa\xd4\xa1\x77\xb1\xc2\x3e\x14\xb3\x8d\x22\x10\xd8\x87\x48\x7c\x09\x1e\x80\xef\x6f\x9d\x67\x27\xbc\x4a\xb7\x60\x07\x00\x50\xe0\x6d\x88\x73\x98\xd9\x46\xea\xe7\x8e\xf6\xbf\x16\xc9\xae\x53\x01\xf3\x9f\x6e\x7d\x0b\x7d\x0e\x17\xf8\x9b\xe2\xac\x88\x69\xe4\x42\xde\xae\x75\xe3\xbf\x85\xe8\xe9\x9d\x42\x0b\x78\x96\x18\xe2\x74\x6b\x22\xa2\x49\xcc\x1d\x7e\xe4\xf8\x5c\x88\x28\xb1\x83\xfc\x04\x07\xe0\xa7\xa2\x3b\xcf\x22\x41\xc0\x7f\xb2\xa7\xee\xd9\x3e\xd7\xe1\xbf\xe8\x1d\xcd\xec\x19\xf0\x81\x68\x0c\xda\x77\x1a\xc4\x5b\xa5\xe1\xac\x9a\x55\x87\x29\x5f\x12\xf6\x9f\x9a\xf8\x81\x1e\xda\x84\x5a\x64\x20\x2e\x6e\xbf\x11\x3d\x78\x77\x9d\x09\x6e\x46\x70\x8a\x6c\x34\xd0\x3a\x14\xed\xeb\x83\xc2\xbe\x0e\xa3\x1a\x65\x41\x6d\x44\x8b\x3d\x4a\x4e\x92\x22\x88\x4f\xe0\xd9\xe9\x8b\xc8\xeb\x7a\x15\xcd\xb6\xd6\xc6\x3f\xc7\x3d\x4f\x5e\x55\x58\x34\x67\x35\x3f\xff\xff\x61\xbe\x03\x96\x87\x7d\x88\x4c\xd0\x87\x18\xee\x50\x17\x74\x9a\x37\xc7\x58\x9d\xc4\x7c\x77\x78\xf0\x96\x5e\xab\xe6\x7f\x14\x68\x67\xfd\x6f\x3e\x44\x60\x75\x18\x0a\x72\xe6\x35\x98\xab\x13\xb9\x5b\x87\x27\xae\x2e\x5a\xb9\xe0\x23\xb4\x6e\x0e\xd4\x4e\xff\xbf\xf8\x10\x81\x3e\xa9\x5a\x94\x39\x2f\x3a\x2c\x81\xbb\xf5\x51\x94\x63\xf8\xb8\xbe\x55\xd1\x7d\xee\xf0\xe7\xb0\x86\xf9\x06\xcc\x47\xe7\x04\xf7\xcb\xb2\xa2\x00\xbd\xda\x38\xdc\xa7\x1b\xf5\x3e\xc7\x3e\xd5\x35\x2c\xe1\x65\x87\x6d\x0a\xf3\x4d\xcf\xc4\xa7\xde\x3e\xb0\x79\x09\x3e\x5b\xef\xc0\xda\xd6\xdf\x5b\x1b\xdb\xfb\x42\x78\x3e\x3a\x91\x77\x9b\xd4\x06\xf8\x28\x7c\x12\xd6\x51\xf6\x47\xfb\x4d\xe0\x93\x0f\xf9\x4d\x00\xdc\x01\x87\x53\x89\xad\xe7\xc8\x2e\x43\xfa\x30\x56\x87\x6f\x13\xfe\xce\x08\xf6\xbe\x69\x8a\xe1\x57\xf4\x67\x0a\x1c\x3e\x63\xda\x74\xbe\xcd\x7e\xd4\xc6\x2d\xb4\xe1\x68\x5a\x0c\x02\x6d\x38\x72\xaf\x2c\x76\xc2\xaf\x84\x46\xa5\xd3\xa7\xcd\xe0\xd7\xaa\x84\x7d\x85\x1e\x28\x5a\xc1\xf3\x77\x8e\xb8\xe5\xf8\x8b\x30\xc4\x17\xfd\xeb\xba\xfa\x77\x59\xe8\x9f\xd9\x57\x40\xde\x2a\x8c\x75\xcd\x32\x88\x0f\xfd\xb7\xf5\x79\xf1\x51\x3e\xde\xd6\x70\x58\xd5\xfa\x63\xeb\x5d\xe2\x6b\x41\x0a\x1c\xf6\xb5\x30\xed\x7c\x2d\x43\x82\xae\x16\x58\xd5\xde\xd7\x02\xd7\xc3\x2a\x4a\xd6\x7a\x98\xe8\xe3\xd8\xd3\xd2\xc8\x05\xfd\x26\x8c\xe0\x6b\x91\x04\x5c\x2d\xb0\x8a\xf8\x5a\xe0\x8b\xa8\x4d\x27\xa1\x0d\x3a\xc7\x1c\x27\x0e\xfa\x67\x8c\x82\xaf\xc5\x15\x70\xb5\x5c\x27\x9e\x16\x00\x0f\xa3\x36\x31\xad\x97\x43\xfc\x2c\x8c\x24\xc4\xcf\xa2\x0d\xf1\xb3\x28\x43\xdc\x2c\xf0\xdd\x80\x9b\x05\xbd\x23\x16\xbe\x4f\x9d\x6a\x1d\x1d\xea\x6b\xc3\xf3\xb8\x85\xb8\x59\xe0\xfb\x6b\xf1\x33\xd5\xa8\x9f\x71\xd4\x0e\xd4\x8f\xf4\x74\x18\xb6\x12\xf0\xf9\xf2\x84\x5c\x7b\x8f\xf3\x74\x82\x5f\x67\x97\x47\xa5\x76\x6f\xb0\x65\xed\x80\x5f\xf0\x37\xd5\x48\x48\x22\xf9\x85\x94\x85\x30\xd4\x56\x89\xda\x72\xd2\x60\x5b\x21\x71\x4c\xc8\xbc\x1c\x9f\x25\x1a\xd9\x23\x2b\x6a\x60\xce\x37\x52\xcf\x0e\xf8\x73\xa4\x69\xa8\x66\xbf\xea\x56\x82\x1b\xe0\xcb\x40\xd0\xd2\x17\x5e\xf1\x77\x6a\x5d\x44\x78\x1c\xd5\x48\x07\xf6\xa1\x5b\xdc\xd2\xd7\xf5\x9a\x0b\x5e\x11\x30\x7a\x61\x0a\xa2\x73\x61\xab\x52\x90\x39\x2c\x45\x53\xeb\x6b\x38\x2c\xd0\x79\x99\xc3\x08\x32\xa7\x57\x40\xe6\xc0\xaa\x80\xcc\xa1\xe1\x53\xa8\x6d\xf6\xa3\x74\x6f\xe3\x5f\xc8\x88\xec\xff\x0f\xd5\x1b\xcd\xdd\x87\x30\xaf\xf5\xab\xd6\xa7\xf8\x73\x0a\x44\xe1\x94\xea\x1f\xb7\xc8\x89\x08\x9c\xd3\x33\xb3\xa6\xab\xab\xa3\xae\xe9\xd4\x45\x30\x6f\xac\xef\x50\x5d\xd5\x2c\xd2\x6e\x35\x2c\xa6\xb0\x75\xaf\x41\x96\x92\x4c\xa5\x12\x8b\x69\x22\x05\x79\xab\xce\xa8\x13\xa6\x1e\x5f\x12\x89\xd1\x6b\xec\xc0\x0e\x6f\xe4\x45\x69\xd3\x5d\x07\x66\xdb\x6c\x63\x27\x76\xee\x5f\xfe\xc5\x87\xec\x28\xd1\xd8\x22\xfa\xfc\x18\xba\x18\xbd\xef\x24\x1c\x48\x21\xa6\x4b\xa9\xd1\x1c\xca\x09\xbb\xc9\x0c\xec\x68\xde\x75\xc4\x5f\x85\xee\xaa\xa9\x9e\x51\xb3\xac\x62\x4a\x42\x6c\x0e\xf1\x1d\x55\x74\xef\xf7\x64\x6a\xe2\x8a\x22\x47\x1c\x71\x1e\x81\x56\x80\xce\xc5\x1b\xe8\xbc\x06\xf6\x0b\xe6\x1e\x48\x7e\xcc\x59\x5e\xbc\x1c\xad\xf4\x30\x4c\xbb\xff\x0d\x34\x97\x90\xe8\x92\x58\xb7\xc5\x6a\x9e\x9b\x97\x35\x1e\xa2\x0d\xbf\xb0\x32\x0e\x46\xc6\xad\x28\xa4\x7f\x86\x55\x37\x6f\xf2\xfa\x30\xd4\xc0\xf5\xd4\x3f\x5b\x17\x50\x91\x58\x4a\x18\xe4\x72\x15\xc5\xd8\x1a\xcd\x12\x9e\x9b\xe7\xe5\xf1\x87\x87\x0f\x43\xc8\x42\x0c\x99\xe0\x26\x91\xcf\x36\xc0\x94\xd8\xa7\xa2\xaa\x8a\x7b\xf6\x05\x92\x91\xe2\x9e\x9e\x7e\x8a\x21\x5c\xa2\x27\xb5\x93\x6a\xa4\x7e\xd6\xb0\xbc\xde\xf0\xbb\xd8\xec\xfe\x7d\x5d\x89\x31\x96\xf2\xde\xdd\x4d\x7a\x57\xd7\xc2\xb2\xfa\xc5\x49\xa8\xdf\x64\x44\xeb\xe5\xd6\x1a\x22\x77\x45\xa0\x51\xcc\x06\x24\x63\x5b\x3d\xf0\x41\xb7\x4e\xb3\x13\xae\x61\xc7\x3b\xac\xfa\x49\xbf\x7a\xb5\x1e\x8f\xf1\x4f\xd4\x6e\x65\xa0\x1d\xdd\xc8\x4a\x82\x12\x15\xeb\x8d\x62\xec\xe9\x5f\x89\x1d\xfd\x7f\x22\xad\x51\x79\x0b\xd6\xe3\x76\x3f\xa1\xfe\xaa\xe0\x74\x6a\x4f\xeb\xec\x80\xbc\x0a\x0f\xca\x2b\xa6\xbd\x08\x3c\xdf\x5e\xfc\xc1\xe9\xed\xf5\x30\x74\x6e\xa7\x53\x53\x84\xf7\xc8\x42\xf5\x39\x71\x7b\xb9\xb7\xa4\xbd\xdc\x5b\xd5\x26\xf6\x80\xff\x1f\x68\x0c\x9f\xa0\xb3\xff\x17\x76\x15\xf3\x28\xbb\x2a\xf2\xaf\xcc\xaa\xaa\x0e\x66\x15\xa2\xb1\x3b\xbc\x4c\x2d\x69\xed\xdc\x91\xb7\xd4\xf1\x6e\xfc\xcb\x8b\xf0\xd9\xfe\x05\xd6\x82\x73\xf0\x3b\xf2\x0c\x45\xf3\xfa\x2d\xda\x26\x2d\xbf\x60\xdd\x15\xd6\x22\xdd\x95\x86\x72\xb2\x46\x3b\x03\xfa\x0b\xb2\x32\x98\xc0\xac\x19\x05\x9f\xc3\x81\x10\x97\xc3\x3d\xde\xe3\x00\xe0\x08\xea\x7f\xc0\x48\xe0\x0f\x8c\xaf\xa3\x7e\xee\x79\xd4\xf8\x46\xff\xc5\xf8\xfe\xa7\xe3\xf0\xd0\xfb\x27\x01\x0d\xe8\x09\xf6\x3e\xa4\x9b\x27\xf9\xbb\x59\xe9\x17\x81\x66\x1d\x9a\xe3\x79\xc0\x4a\x77\x01\xdb\x3a\x3e\x43\xc7\x3c\xa8\x32\xb1\x47\x80\x75\x01\x7a\x66\x7f\xeb\x17\x74\x77\xe6\x73\xf2\x0c\xbe\x65\x4a\xc3\xa1\xcf\x71\x80\xee\xfe\xe0\x44\x39\xdb\x9f\x69\x6a\x19\x35\x92\x79\x0a\xf5\x37\xbb\xf5\xef\xe0\x63\xee\x5f\x41\x3d\x9f\x3c\xe7\x04\xe0\x63\x7f\xd2\x06\xfa\x7d\xee\x5f\x7f\xfe\x26\x92\x62\xba\xbe\x82\x65\xad\x37\x5b\x6f\x12\xd9\x25\x65\x89\xdf\x41\xdc\xee\x8e\x61\x43\xdb\x15\xc3\x27\x21\x37\x0c\x1d\xcf\x2e\xe2\x57\x4c\xe0\xec\x0a\x56\xe0\x0b\x0f\x1b\x81\x34\x5c\x81\xda\xf4\x6a\xbd\x43\xd6\x07\x69\x4f\x7c\x2b\xbc\x3a\x6a\x07\xb2\x7d\x3d\x4e\x31\x5c\xd1\x0b\x34\x6c\x71\x3d\xef\x42\x8d\x1a\xe0\xbf\x9e\x7f\x9e\xdf\xc3\x14\xdc\x8c\xd6\xb5\x89\x32\xe3\x33\x4f\xc9\x35\xa2\x46\x5a\x2a\xd5\xab\x28\x22\xbf\x22\x3e\xce\xc4\x35\xaa\x04\xf8\x23\x3e\x8a\x83\xac\x94\x51\x40\x54\x19\x4c\x97\x7a\x7a\xcb\x87\x70\x43\x4b\xed\xa3\xac\xf5\x65\xd3\x62\x63\xab\x73\xcb\x4a\xe1\xbd\xde\xbd\xbb\x9b\xf5\x23\x7b\x97\x0d\xae\x49\x4f\xaa\x2e\x09\x43\x3c\xeb\x19\x76\x3a\x78\x42\xe4\x22\xb1\xe6\x52\x9a\x0b\x0f\xe3\xc2\x24\x62\x86\x5c\x01\x66\x06\x23\xb7\xc5\x71\xe2\x38\x4f\x9c\xc7\xe8\x41\x0a\xed\xf0\xf1\x75\xbb\x7a\xec\xaa\x1b\x5f\xf7\x54\x8f\xa7\xd8\x57\x07\x2e\x5f\x56\xb9\x6c\xd9\xc0\x65\x4b\x2b\x97\xf2\xba\x97\x94\xad\x07\xdd\x45\x2b\x29\x03\x9e\x5f\xde\x07\xa4\xc5\x15\xe9\x48\x6a\xa0\x87\x24\x0b\xf2\x41\x53\x52\xe5\x14\x8b\x65\x5a\x93\x32\x2f\x47\x6f\x90\x65\x8e\x62\xeb\xfb\x2a\x2a\x8d\xf9\xf9\x71\x7d\x86\xc8\xfb\x48\x92\xd2\x8c\x69\xee\x64\x55\x5a\x59\x06\x9e\xc3\xa9\x22\x19\x53\x21\x4e\x17\xf6\x38\x2b\x6a\x04\xc1\x13\x8d\xcf\x83\x0b\xdb\x73\x53\x75\xec\x11\xdd\x83\xf9\xf8\xa7\x48\x36\x6e\xdc\x8b\xe3\xc6\xf1\xfa\xd0\x38\xf6\x28\x35\x8d\xbb\xda\x5e\x4f\xb3\xe0\x24\x54\x8f\x75\x20\xd3\xb0\x9e\xe1\xae\xc2\x5f\x65\x40\xa2\x44\xb4\x6f\x60\x8f\xd2\x4c\xc7\x67\x81\x18\x69\x68\x5a\x9a\xa1\xff\x68\xa0\x5f\xe0\xae\x2a\xe1\xef\x32\x20\xe3\xdf\x1d\x83\x6c\x00\x35\xf7\x02\x1a\xab\xc5\x1b\xae\xa6\x10\x83\xc0\x95\xea\x1b\x25\x58\xa3\xe1\x0b\x20\x90\xd9\x7b\xc4\x51\x02\x40\x91\x58\xd8\xa9\xb3\x2b\xad\xab\x6e\x6c\xcc\xe2\xea\xe4\xa2\x2e\x5d\x62\x86\x38\xc7\x25\x2f\x62\x2f\x45\xba\x22\xb3\xf2\x16\x2e\x45\x1f\x93\x56\x35\xf0\xfd\x3c\x40\x7a\xda\xff\xa2\x47\x3f\x42\x4f\x63\x5a\x33\xd8\x3b\xe0\x3e\xf7\x39\x6a\x20\xc1\xf5\x96\x2e\x84\x8b\xc5\x54\xa3\x94\xec\x40\xc4\x8f\x05\xbf\x22\x1e\x1d\x10\xa4\x3f\x98\xc4\xfc\x7b\x16\x7d\x01\xce\x70\x6c\x71\x80\xf9\xe8\x07\xf7\xb9\x12\x3e\x90\x81\x30\xf8\xfd\xb1\x63\xd8\xa8\x00\xad\x46\x24\xe3\x7e\x43\x7a\xaf\x02\xeb\xe6\xe2\x46\xb9\xe0\x3b\x61\x74\x21\x09\x7c\x6e\xf1\x70\x97\xd2\x61\x48\x8e\x9f\xc5\x59\x97\x9a\xe0\x77\x91\xa2\xa9\xe1\xb5\xfa\x88\x8d\xe8\x3c\xb7\x2a\xd8\xbb\x74\xa1\x28\x9a\xd7\x83\xc5\x21\xd6\x16\x10\x24\x20\x4d\x05\x45\x20\x7b\x57\x10\x81\x14\xed\xef\x8f\x8e\xc7\xa4\xd6\x85\xc2\x1e\xe0\x90\x65\x47\x07\xf8\x1c\x87\x1a\xe2\xbf\xfe\xd9\x3a\xe6\x73\xdd\x83\x3f\xf4\xcc\xe7\xfa\xef\xeb\xea\x5e\xa8\xab\x43\x7b\x67\x35\x3a\x7f\x3d\x88\x4c\xe6\x25\x6e\xf0\xd4\x32\x82\x75\xf7\x13\x92\xce\xcf\x0a\x12\x1a\xee\x43\x52\x1a\xc0\xa7\x51\x9b\xfe\x82\xdf\x26\x68\x10\x62\x4f\x0c\xf6\x3f\xc1\x4b\x82\xff\xc9\xc7\xbb\x9f\xd0\x98\x22\xd8\x59\xb4\x85\xfb\x93\x8a\xa0\x12\xbc\x7a\xa5\x81\x96\xca\x29\x13\xcb\x85\x19\xb8\x30\xb5\x3a\x8c\x33\xb0\xe1\x66\xa4\x0b\x90\xb8\x39\x52\x27\x8a\x57\x40\x63\x83\x67\x16\x9d\x2a\x03\xcf\x60\x49\x01\xb6\xe2\x18\xdb\xe8\x24\xcc\x61\xf3\x7b\x54\x0c\xaa\x70\x45\x8c\x8b\xc3\x3c\xb6\xa0\x73\xcf\xca\x41\x9c\x49\x3b\x77\xed\xa2\xf4\xfa\x9c\x7a\xdd\x5c\xc4\x68\x33\x26\x79\x28\x9c\xd7\x92\xc9\x8e\xa2\x33\xc4\x34\xa9\x32\x12\x49\xc5\x7b\xb5\x88\xa1\x23\x6d\x86\x93\x99\xd5\x32\xab\x55\xa6\x36\xb3\x76\x13\xda\x33\x02\x05\xa8\x7b\xd5\x5f\xfb\x06\x71\xe6\x13\x56\x06\x41\x6e\x52\x69\x71\x41\xa4\xa7\x8b\x76\x42\xec\xc2\x41\xc9\x7d\x8a\xba\xda\x47\xc6\xd4\xd9\x0b\x6b\xe0\x36\x64\x6d\x56\xa2\xbf\x9c\x27\x2a\xce\x91\xed\x9e\x3f\xd5\x11\xe7\xa8\xad\x19\x92\xfd\xde\xb1\x63\xe0\x57\xb4\x49\xe8\x56\x27\xfb\x32\xb2\x41\xce\xe1\xfa\x5e\x54\x8a\x57\x97\x1c\x23\xa1\x1c\x26\x2d\x27\x33\x25\xc8\xd0\x1f\xb5\x2d\x86\x88\x1a\xa4\xf4\x07\x0e\xc9\x75\xd5\xf5\xff\x42\xd2\x43\xb2\x96\xf8\x8a\x40\xc2\x5f\x10\x28\x4b\x2a\x2d\x42\xbf\xef\xaa\x9d\x90\x34\x77\x20\xfa\x7d\xbe\x3d\xa7\xab\x1a\xff\x0f\xf6\xe5\xf6\x04\x83\x30\xf2\xbd\xa9\x0e\x7d\xf7\x64\xa2\x5f\x60\xbe\x3b\x08\xad\x7d\x43\xeb\x73\xe8\xc4\x68\xce\x33\x62\x31\x0b\x24\xa2\x36\x2f\xbc\x51\x8c\x18\x76\x9c\x47\xec\xf6\x34\x3c\x67\xfe\xcd\x3c\xe3\xa2\xf1\x37\xe3\x6f\x67\x1a\x1b\xcf\x9c\x98\x3d\x1b\xb5\xbd\x4a\x6c\x8e\x77\xc9\x9d\x01\x85\x0c\x36\x86\x98\x29\xc4\xbf\xe6\xf4\x20\x4b\xe5\xb7\xd4\xd9\xb7\x37\xcf\x4f\x85\x55\x3f\xae\x5b\xf7\x23\x65\xf2\x1b\xd0\xc6\xfe\x96\xf8\x39\x25\x24\x06\xca\x46\xb9\xa8\x14\x12\x79\xdf\x9d\x2a\xa5\xfa\x53\x3e\x6a\x24\x55\x4b\x4d\xa3\xe6\x50\x8b\xa9\x95\xd4\x06\x6a\x1b\xb5\x8b\xda\x4b\x1d\x02\x5d\xbc\x87\xb6\x97\x1c\x3c\xf8\xf4\xf4\xd9\x75\x4d\x4d\x93\x97\xf7\xd8\x57\xb1\x71\xe3\xa0\x2d\x39\xab\x56\x75\x6a\x16\xef\x4e\x9d\x3b\x37\x73\xa1\x61\xd4\xa8\x88\x71\xa2\xa7\x14\x83\x07\x6b\x86\xd9\xf3\xf3\xa3\xbb\xc5\x26\x32\x7d\xfb\x26\x76\x1b\xf6\xd4\xb8\x85\xbb\x9b\xb7\xec\x5b\x3e\x5b\xde\x67\x47\xaf\xa7\xc3\x41\x3f\x4a\xda\x8f\xe9\xf3\x74\x9f\xc3\xe1\x3b\x0e\xce\x6f\x2c\xdf\x3f\x66\xcd\x9a\x09\xeb\x87\x6c\xda\x34\x62\xab\x77\xe9\xd2\xe2\x15\xf1\x33\x67\x26\x37\x44\xd5\xd7\xc7\x4c\x55\x0d\x18\xa0\xab\x06\xbd\x4c\xb9\xb9\xd6\x2e\xe9\x59\x8d\xfb\xd7\x6f\x5d\xd1\x30\xb5\xba\x57\x97\xac\xac\x2e\xbd\xaa\xa7\x36\xac\xd8\xba\x7e\x7f\x63\x78\xef\x3d\x65\x07\x0f\xee\xee\xfb\xb4\x6c\xa7\x98\xe9\xd9\x33\x8c\xed\x8d\x39\x0d\xae\xcc\x77\x23\x53\xf8\x07\x1f\x3e\x1a\xf8\x8f\x54\xed\x13\x8a\xf7\xfd\xd7\x1f\x78\xcb\x66\xaa\x01\xfa\x62\xe4\x7f\xe5\x6e\xab\xfa\xf7\xc8\x97\x3c\xe2\xdf\xe4\x1f\x98\xcf\x64\x3b\xb3\x1d\x9c\x23\xdb\x01\x9c\x6a\xb7\x4b\x87\x59\x96\x3b\x33\x4e\xf8\xd4\x0a\x9f\x46\xe1\x13\x08\x9f\xe2\x0e\xdf\x81\xf3\xff\x11\xf6\x1d\x00\x51\x1d\xdb\xdf\x77\x6e\xd9\xde\x2b\xcb\xb2\xcb\x2e\x4b\x07\x69\x4b\x57\x61\x15\x41\xac\x2c\xa2\xe2\x8a\x0a\xf6\x8a\x62\xc3\x8a\xbd\x77\x13\xc5\xae\xd8\x63\x4b\x2c\x18\x5b\xa2\x89\x35\xb6\x14\x12\x93\x68\x4c\x4c\x7b\x31\x89\xa9\xff\x24\x2f\x51\xd9\xe1\x9b\x99\xbb\xbb\xa0\x49\xde\x17\x02\xb2\xdc\x32\x67\xce\xcc\x9c\x32\x73\xce\xef\xe8\x1d\x6a\x3b\x40\xd3\x27\xcd\x09\xfe\x3f\xf7\x3e\xff\x39\xe2\xb9\xb6\xfc\x6d\x47\x20\x7a\xd0\x1b\x11\x6d\x6a\xa7\xde\x49\x7f\x5f\xf9\x39\xe8\xe6\x7d\x1d\x1f\x91\xd1\x79\x95\x95\x70\x6d\x6a\x66\x66\xea\xfa\xd4\xac\xac\xd4\xc7\x19\xe9\x99\x69\xe1\xf8\x23\x44\x3a\x35\x23\xfd\xe5\xcc\xb4\xb4\x4c\xba\x77\x46\x7a\x7a\x46\xe3\x82\xcf\x2b\x41\x37\x76\x31\x3c\xf1\x79\x65\xa3\x38\x1d\xfd\x47\x2f\xc3\x3f\x6b\xd3\x32\x33\xd3\xbc\x07\xd2\x32\x91\xba\xc0\x9f\xc1\x0d\xfc\x20\xf4\xe0\x67\x1e\xe3\xc7\x6b\xf1\x5f\xe1\x9a\xca\x4a\x26\x1c\xb7\xe8\x7d\x0d\x9e\xa8\xfc\x9c\x9d\x7f\xbf\xb2\xb2\xb2\x71\x22\xe8\xfe\x22\xba\x2f\x1e\x7d\xc3\xf7\xd0\x7b\xfe\x83\x7e\x01\xb5\xe8\x97\xbe\xe8\x17\xef\x04\xdc\xf8\xd3\xfb\xa0\xd3\x93\xd4\xca\xfb\xf4\x47\xe9\xce\x6c\x6f\x4e\x5a\x5a\xc6\xe6\xd4\xd4\x2c\xda\xe6\xbb\xdb\xdb\x94\x91\x91\xf6\x0d\xba\x11\x36\x64\xa6\x66\xc5\xa2\xcb\xe8\x9d\x8d\x13\x2b\x2b\x41\xa7\xfb\xbc\x0c\xfd\x9e\xad\x01\xa9\x02\x3b\x39\x0f\xc2\x1b\xcd\x38\xf6\xc3\x77\x1e\x94\xea\x3b\x0f\xe2\xa6\x06\x0e\x84\x00\x95\xc9\x4e\x05\xe6\x67\x63\xbd\xb4\xcf\xec\x41\xbc\xf7\x2f\xa1\x5e\x48\x3e\x2d\x64\xef\x80\xb7\x05\x8b\xc8\xbe\x9b\xd1\x85\x6c\x5f\x15\xfa\x12\x51\xc4\x89\xe4\x45\xd2\xdf\xb6\xc8\xb0\x48\xbc\xff\xac\xbb\x90\x19\x56\x1f\x26\x58\x14\xf0\x19\x60\x11\x92\x7d\x00\x4e\x81\xed\xa9\xf2\xa6\x3f\x5a\xda\x53\x0c\x10\x0b\x9f\xb1\xa7\xb4\x2d\xec\xa9\xb8\x16\xe6\x14\xdc\xd0\xd2\x9c\x02\xf0\x2e\xec\x4d\x39\x9e\x3d\x4f\x33\xf2\xe7\x69\x8e\x67\x8f\xd3\xd0\xbd\xa7\xd1\xbd\xf4\xb3\xe7\x69\x46\x9e\x7f\xf4\x73\xc7\x69\x34\xf2\xeb\x7a\x53\x4d\xe4\x5e\x39\x65\x71\xc9\xc5\xac\x44\x26\x92\xc8\x64\x12\x11\x43\x9e\xe4\x23\xbc\x35\x38\xeb\x5c\x09\xf8\x21\xe0\x8f\xfc\x96\xf9\xde\x44\xcf\xe5\x8f\xfe\x7c\x6f\x84\x7b\xc9\x09\x20\xa0\x4c\xec\x54\xaa\xf1\xd9\xd8\x3d\xed\x33\xb6\xf5\xae\x7f\x09\xdd\xa3\x00\x58\xc0\xee\xa7\x0b\xb8\xa1\x88\x6f\xc8\xce\x17\x13\xdf\x19\xa4\xa6\xfb\xf2\x80\xc2\x22\xc1\x82\x8e\xf1\x8e\x78\xfc\xcd\xfe\x19\x97\x97\x68\x47\xdf\xbc\x9d\x7c\x18\xf5\x25\xa6\xe9\x12\x1a\x4b\xd1\x31\x4e\xc1\xdb\xf3\x88\xad\xc6\x00\x8b\x9d\x55\xab\x25\xeb\xf3\xbb\xa4\x0c\xcf\xae\x5e\x18\x3d\x43\x5b\x72\xc3\xd9\x25\x62\x7a\xcc\xec\x59\x31\xd3\x22\xba\xa6\x61\xd0\x4f\x06\x86\x21\xb9\x7d\xb4\xe9\x75\x4a\x8b\x6b\xdb\x52\x76\x97\xc2\xa1\xb4\x58\xe4\x5c\x4c\x8c\xd1\x28\x64\xd4\x72\x32\x76\x29\x2d\x44\x08\xd9\xf6\x88\x0a\x6c\x7d\x18\x31\x99\x9c\x1f\xaf\x1c\x4d\x18\xae\xc5\x56\xc8\xd1\x79\xfd\xfa\x44\xba\xfa\xb6\xef\x3d\xaf\x9f\x27\x22\xb7\x2c\xaf\x97\xf7\xcd\xe4\xc8\xe4\x6e\x89\x91\x69\x5d\xc0\xcf\xc9\x91\x29\x5d\x12\xd0\x6f\x1f\x95\xce\xe8\xd4\xa9\x47\xfb\xd2\x19\x85\x85\x3d\x26\xc7\xc6\x75\x4a\x8e\x70\x76\x50\xc7\xc6\x75\x4e\x42\xff\xa2\xb5\x71\x9b\x1d\x0e\xc6\x0b\x52\x79\xeb\x57\x28\x24\xcb\x83\xb7\xde\xb0\x41\x82\x8f\x09\xc7\xd7\x8e\x1f\xdc\x44\xa1\x1f\xdc\x5c\xf8\xcd\x09\x10\x7c\x82\xf0\xe6\x73\x58\xca\x69\x9b\x6e\x50\x12\x6c\x37\xd2\x2c\xaf\x74\x91\x1d\x43\xd9\x6d\x8c\xd3\xc0\x3a\x6d\x19\x9c\x16\xbe\xe3\x7d\xd7\xdb\xb0\x67\x61\x3e\x70\xfe\x00\xbe\xfc\x2a\x1d\xae\x04\x13\xe7\x55\xff\x45\xd6\x98\x95\xbd\x20\x28\x16\xa4\x90\xe7\x59\x4a\x44\xfb\x4f\x06\x9a\x9f\x17\x14\x3f\xf7\xbc\x20\x25\xf0\x02\xd0\xf4\x2d\x67\x61\xbb\x70\x5b\x9f\xf7\xef\xd8\x94\xa7\xaf\x9a\xd8\xce\x9c\x65\x36\xd9\x7b\xf9\x90\xd1\x36\xf5\xfa\x5b\x3c\xdb\x13\x72\x0f\xfc\x10\xdd\xd3\xf4\x11\x7b\x49\x50\xc0\x35\xf1\x76\xb6\x8e\x11\x29\x19\x9c\x65\x38\x47\xf6\x9c\x9d\x8d\xf7\x39\x22\x02\x2b\x16\x47\x4d\xb2\xc8\x80\x10\x14\x74\x7b\x67\xf1\x46\xf8\xd7\xca\x0b\x9d\xca\x17\x24\x2e\xec\xf8\xd5\x4c\xcf\xb5\x45\x54\xd3\xc1\x2d\x7d\xb9\xa6\xba\x0d\xbd\x5b\x45\x97\xf4\x5f\xbb\x2f\x26\xbe\x37\x7f\xd6\x47\xda\x92\x08\xd2\xd1\x3c\x44\xb6\x1f\x5a\xb7\x3e\x9e\x81\xc8\x70\x47\x18\x2b\x74\xa0\xae\x6b\xb9\x85\xf9\xf0\xd6\x0f\x3f\xc0\xed\xd5\x0b\x81\x93\x4e\xa4\x13\x77\xb1\x97\xe6\x55\x57\xcf\x03\x13\xe1\x4a\xc2\xf7\xa3\xb0\x94\x49\x47\x36\x84\xc0\xb7\xd7\x2b\x08\x9c\xe5\x09\x49\x52\x26\x93\x7e\xc6\xd4\x18\xac\x67\xbe\xc1\xc6\xc3\x18\x52\x27\x1b\x7e\x0c\x3e\x05\xbb\xd8\xdf\x55\x42\x6e\x90\xf7\x22\x1f\xe3\x01\xbf\x04\xf7\xc1\x46\xf6\x37\xf4\xb7\x11\xde\x1d\x14\x2f\xbb\x8e\x81\xef\xa8\x9f\x05\xa4\xc2\x3e\x65\x38\x4f\x71\x20\x89\x62\x41\x02\x59\x42\x29\x24\x43\x83\x3f\x3f\xc2\xd1\x2d\x03\x8c\xd3\x8d\xf0\xee\xea\xe9\xab\xb9\xc5\xd3\xa6\x35\x0e\xa2\x9f\x7a\x39\xfe\xbd\xbb\xd0\x7b\x07\xe2\x58\x73\x6e\xbc\x77\x82\xaf\xad\xfb\xa8\xfd\xed\xec\x7f\xd0\xdf\xa6\x78\xb7\x50\xfc\xda\x82\xe8\xbe\xe9\x2c\x3e\xc3\x33\xd5\xd3\x2a\x4e\x2b\xc3\x91\x30\x14\x6a\x33\xb1\x19\xbf\x51\xeb\x2f\x4e\x90\xea\x83\x63\xc7\x03\x80\xbd\x3c\xd5\xf2\xac\x51\x3d\x1e\xcc\x5f\xd1\x77\x6f\x4d\xd5\x62\xf1\x34\x2e\x2f\xaf\xf7\xc8\xd6\x74\xbb\x5d\x8e\xaf\xb7\x2e\x9d\xfb\x47\x4d\xf5\x68\x75\x6e\xd1\x80\x1b\xa3\x5f\x43\x6d\x9f\x04\x9f\x80\xab\x38\x0f\x80\x1b\xee\x5d\xe7\x6b\xfb\x3f\xe0\x7b\xb0\x0e\xf5\x33\x88\xb2\x9f\xa1\xf4\x20\xe5\x24\x15\x14\xf4\xcf\x59\x00\xc8\xbc\xfa\xc7\x1c\x00\x27\x23\x4c\x78\x3e\xf0\xff\xf2\x74\xa7\xed\x1f\xc2\xfd\x59\x03\xfc\x65\x15\xcf\x07\x3b\xf8\x9e\xf6\x10\xde\x8c\xf3\x9e\xe0\x69\x69\xea\x84\x68\x49\x62\xff\x0f\xd7\xbe\x3e\x2e\x93\x0a\x4f\x83\x84\xe3\x14\xad\xc4\xcc\x90\x52\x62\x5f\x0c\x93\x33\x57\xdd\x12\xbe\x0e\xef\x2b\xf3\xa5\xed\x82\xc3\x4d\x9d\x26\x69\x7c\x81\xf8\x09\x3d\x5b\x87\x59\xd9\xd9\xe2\xba\xf1\x70\x22\xdd\xe9\xd8\x96\x01\x5d\xc4\x4d\x4d\x4d\xb3\xc0\x7d\x24\x37\x57\xa3\x36\xab\xbd\x7b\x7c\xe3\xf1\x29\x6a\x93\x1f\x8f\xe9\xde\x11\x3e\x9e\x4c\x42\x7f\x5b\xc1\x7e\x8d\x75\x4b\x3d\x72\xdc\x44\xdc\x39\x92\x89\xc0\x04\x82\xe5\xf1\x78\x30\xc0\x01\x18\x92\x85\xa3\x5d\xbe\x0a\xc2\xc5\xa0\xfb\x89\x39\xf3\x7f\x5a\x01\x2f\x5e\x40\x4f\x67\xc1\x6b\x60\x09\x98\x80\x66\x5b\x34\x5c\x0d\xa7\xa0\x49\x33\x95\x3d\x44\xff\xf8\x8f\x31\xad\xf8\xda\xae\x77\x38\xf8\x13\x7b\x48\x07\xe4\x16\xd8\x48\x78\x71\x06\xf9\x49\x09\x4d\x53\x9f\xbd\x9f\xc3\x5e\x24\x00\x09\xe8\x7e\x01\x50\x2f\xd1\xc1\xdf\x2c\x80\x25\xfd\x68\xfa\x1a\xc9\xd6\x4b\x4d\x73\x55\x42\x46\x40\xdd\xe6\xfb\x46\x55\x34\xfd\xc0\xf6\x64\xbb\xab\x04\xb4\xbe\x91\xaf\x9d\xf2\x03\x3b\x84\xed\x4e\x10\x1c\x7a\xb8\xf4\x21\xe6\x1e\x65\x94\x4e\xa5\xab\xd0\x55\xe9\xe6\xe8\xde\xd0\xbd\xab\x13\x8a\x75\xa7\x9b\xde\x70\x59\xcc\xd6\x42\xa5\x08\x18\x18\x5d\x88\x48\x14\xa2\x63\x82\xd8\x20\x35\x06\x4b\x60\x65\xcf\x56\x23\x09\x54\x97\x88\x43\xff\x63\x1d\xf4\x2c\xaa\xbe\x2a\x50\x84\x30\x12\x3b\xbe\x55\xab\x81\xe3\xd2\x89\x5b\x17\x47\x55\x5f\x7b\xfb\x17\x7f\x99\xda\xb7\x1a\xc0\x6e\xe4\xe3\x80\x35\x77\xf9\x5a\x36\x4c\x9f\x91\xf0\x6b\xf8\x13\xfc\x9a\x54\xa6\xbd\x0b\x14\xbe\xb3\x5c\xa4\xeb\x7f\x60\x7b\x23\xda\xb1\xe7\xe5\x72\x45\x59\x42\x7a\x94\x29\x75\xa1\xba\x71\x3a\x24\xd0\x54\x22\x5a\xcc\x88\x2c\x3a\x9d\x45\xc4\xb0\x26\x93\x1a\x97\x82\x61\xa5\xcf\x16\xb4\x09\xd0\x8a\x29\x05\x3c\x14\x07\x2e\x1b\x84\xe1\x44\x5b\x16\x0d\xc2\x94\xb2\xbd\xd7\xc3\x8f\xdf\xa8\xbf\x7a\xe9\xde\xb5\x3b\x53\xa7\x23\x52\xcf\x85\x6e\xb9\x3f\xfd\xca\x4d\xef\x6a\x44\x2a\x7d\xee\x53\xf8\xe6\x89\x23\xb5\x0a\xe1\xeb\x20\x16\x48\x57\x2e\x41\x94\x0e\xd8\x56\x76\x0b\x16\x1f\x3e\x8c\x78\x7e\x14\xae\x67\x3a\x60\xcc\x24\x8a\x8f\x8b\x2b\x63\x8f\x31\xaf\x70\xff\x45\xe3\xa8\x3c\xc6\xd1\xa7\x81\xec\x78\x19\xe7\x0b\xab\xc6\x83\xcf\xd0\x65\xc2\x25\x57\x44\x5f\xb1\xc7\xec\x20\x3c\x02\x7e\x4e\xa6\xd9\x39\xf6\x18\x9b\x23\x68\xe7\xf3\x57\xc2\x5c\x52\xa1\x54\x22\x5d\xe3\x11\x48\xb8\x96\x6f\xc0\xa8\x0f\x29\x7e\xa8\x2d\xfc\x2a\xbc\x21\x80\x77\x17\xe8\xa5\xc2\x9a\x2b\xc2\xbb\x9b\xc2\x57\x87\x7b\x77\x86\xaf\x0d\xc7\xef\x1e\x17\x01\xd7\x6b\xc8\x49\x03\x9a\x2b\x1b\x28\x8a\x1d\xcc\x15\x68\x22\xa9\x70\x5c\x87\x9e\xc9\x84\x6c\x93\x9b\x12\x1e\xa7\x55\x0c\x95\x9b\x46\xd6\x00\xb8\x0b\xf6\xd0\x90\x7e\xc7\x77\xc6\xbe\xc5\x77\xc6\x8e\xc5\x1d\xb8\x9b\xfd\x28\x1b\xec\x01\x71\xf0\x0e\xea\x2f\x32\xf5\xb8\x0c\xf2\xae\xe8\x81\xe4\x5d\xde\x06\xf2\x2e\xa0\xf0\xbf\x8b\xa6\x06\xa0\x7b\x04\x5c\x3e\x5a\x4f\x6a\x2a\xd3\xa5\x00\xb4\x90\x2e\xf7\x88\x84\x48\xcd\x72\x9c\x0c\x75\xc8\x25\x2f\x13\x88\x25\x0c\xc7\x30\xac\x94\xc1\x95\x5f\x8d\x29\xb9\x46\x72\x60\x12\x28\xcc\x89\xd1\x5b\xec\x0c\x4e\x13\x44\x7a\x58\xcc\xf7\x97\x29\x98\x06\xfb\x4c\xbb\x00\x04\x17\xc6\x82\x97\xc6\x9e\x85\x4f\x1a\x07\x08\x96\x5c\x11\x7e\x45\x8f\xf3\xae\xe5\xf2\xbd\x37\xe8\xf4\x27\xe7\x58\xca\xcf\x57\x44\x6b\x39\xa2\xc3\x42\x68\x8d\x9f\xdd\xb2\xdf\x01\x5a\x71\x7f\xd0\x3c\xfb\x92\xeb\x8b\xee\x49\x29\x68\xd9\x1f\x3a\xf4\xd9\xfe\x74\x45\xfd\x11\x21\x6b\x28\xfc\x98\x54\x81\xbb\xa0\x2c\x93\x72\x22\x9a\x66\x05\x42\x29\xcb\x90\x4e\xa0\x2e\xe0\x53\x30\xcc\x36\xbb\x43\x4b\xa2\x2e\x7d\x84\xd3\x5f\xbf\x36\xe1\xed\xeb\xf3\xc1\xe8\xeb\x50\xe2\x15\xf1\x34\x17\xd2\x5e\xef\x7e\xda\xe3\x65\xc0\x69\x1f\xc5\x34\xd2\xc3\x38\x1f\xba\x2f\xa9\x12\x9a\x74\x2c\xb6\x15\x6e\x47\x5f\x16\xcb\x28\xcc\x66\xa9\xd5\x62\x2d\xf7\xc8\x2d\x1a\x0a\x17\xce\x64\x5b\xa0\x87\xf9\x33\x64\x01\x09\xf8\xa5\x85\x18\x27\x0c\xa7\x06\xfb\x70\x14\x68\xbd\xce\x88\x67\x49\x8a\x31\x52\x4d\xea\x48\xf3\xac\x4c\x78\xfd\xc3\xb6\xd5\x07\xc6\x0c\x8e\x7f\xcb\x0a\x93\xe3\xa7\xd7\x95\x4c\x9a\x32\xe3\xec\xe8\xba\x78\x98\x6c\x7d\x2b\xb1\xdf\x07\x65\x47\xbf\xf7\x2e\x20\x84\x72\x7d\xbf\xbb\x31\xea\x87\x0f\x0e\xbb\xa4\x5b\x3f\xef\xfe\x01\x70\x4c\x5b\xbc\x69\x1f\xbc\xb8\xee\xc1\xe2\xcf\xb7\x4a\x77\x83\xa8\xe5\xc0\xf2\x60\x2a\xdc\xe7\xeb\x02\xe2\xe7\x57\x88\x9f\xc9\x82\x76\x9a\x48\x66\x14\x9a\x6b\x02\x26\xeb\x37\x8a\x92\x9d\x64\x68\x60\x52\x47\x52\x71\x69\x69\x69\x81\xf9\x98\xaf\x11\xe0\xf9\x88\x9e\xc9\xe2\xeb\xe7\xa2\xcf\x11\xc4\x3e\x9a\x82\x3e\xff\x85\xf8\xcd\x51\x1a\x97\x98\xe6\xca\x3d\x34\x03\x30\x87\x53\x08\x30\xb4\x03\xc3\x41\x80\x74\x34\x0f\x98\x19\x56\x6f\x07\x2e\x7f\x2b\xd6\xdf\xbb\xd1\x33\x93\xc8\x33\x72\xca\x79\x8a\x16\x68\x04\x48\x46\x08\x4e\x37\xbd\xeb\xd2\xc8\xd5\x85\x02\x86\x66\x58\x89\x04\x88\x29\xb1\xaf\x92\xb5\x9f\x73\x4e\x67\x1c\x12\x12\xc9\x49\x38\xe8\x46\x2b\x04\x02\x21\xb0\x33\x91\x51\xfd\x43\xe8\x6b\xbf\x3f\xb1\xc0\x35\x1d\x8b\x61\x0a\x93\xba\xcb\xa8\x5a\xcb\xd6\x3f\xed\xfe\x22\x7b\x7e\xd5\xe2\xc6\xdf\x18\xf9\xc4\xf9\x7e\xba\x3f\x24\x74\x47\x13\x99\x8c\x66\x1d\xfb\x2b\xf9\xdc\x36\xd0\xaf\x6b\xe4\x73\x1c\xe5\xc7\xd4\xd9\x8a\xc6\x57\x49\x85\x50\x36\x2a\xc7\x15\x6d\x0b\x2d\xf7\x84\xda\x72\x6d\xb4\xd2\x16\x6a\xbb\x60\x7b\xc7\xf6\xb3\xad\xc9\x26\xd0\x32\x36\x5b\x90\x48\xa4\x41\x6b\x86\xa5\x70\xfd\x5a\xed\xf3\xa8\x35\xe3\xe3\x7c\x98\x71\xc1\x80\x37\xe5\x25\xb8\x9e\xa7\x1f\xf0\x07\x8d\xbd\x12\x83\x7d\xfd\x75\xe3\xad\xc1\xaf\xfc\xbe\xf5\xea\xdb\x83\xea\xff\x02\x1d\xbe\x5d\x72\x61\xe2\xc3\x21\x1b\x27\x77\xde\x6c\x85\xc7\xac\xba\xef\xee\xd6\x81\x59\x40\xbc\xf0\xd3\x4f\xb7\xc0\x79\xf0\xe7\x65\xcc\x5e\xd0\xea\x1a\x1c\xb3\x17\x5e\x1f\xf1\x39\xe8\x12\xb1\x79\x33\xa2\x7f\x20\xa2\x7f\x3b\xa1\x3f\xde\xdf\x1f\xce\x4c\x3e\x13\xc3\xc8\x5f\x97\x17\xd9\xb1\x7a\x97\x04\x83\xa9\x00\xa1\xc8\xbf\x9e\x9d\x24\x20\x95\xc1\x65\x84\x48\xb2\x8b\xe7\xfa\x6a\xa9\xc6\xd9\x07\xaa\xaf\xd3\x4d\x57\x99\x45\x9d\x6f\x8f\xdf\xd7\x38\x1d\x3d\x8b\xdf\x1b\x84\xde\xf3\x2d\x79\x6f\xd2\x73\x7c\x4b\x26\x7c\x43\x92\x95\x7d\x07\xdd\x8b\x6d\x33\x29\x15\xe9\xd2\x49\x25\xe5\x1e\xa9\x94\x05\x2c\x87\x8b\x29\x03\xaa\xdc\x03\x98\xbf\xa1\x10\x61\x6c\x31\xf4\xad\x45\xb3\x1f\x04\x5b\x99\x0d\xd6\xa7\x95\x56\xe6\x82\x95\xb3\x7a\x07\x5b\xd9\x03\x5b\xb7\x3e\x2d\xdd\xba\x95\x61\x36\x6f\xe6\xe5\x80\x6f\x6c\x50\x9b\x29\x94\x1f\xcf\x04\xd1\x80\x5a\xb4\xb8\x94\x9c\x00\x08\xd0\x2c\x04\x48\x60\x09\x03\x1d\xf4\xe7\x06\xf3\x69\xb0\xd9\x68\x3a\x2e\x86\x4f\x2e\x7c\xeb\xfd\x13\x75\x05\x09\xa2\x03\x4f\x4b\xfd\x7d\x39\x45\xfa\xe2\x24\xef\x65\xb0\x9d\x87\xde\x2b\x23\x95\x96\x85\xac\xb0\xdc\x23\x46\x72\x84\x62\x19\x20\xa1\x24\xcd\x93\x93\x4f\x2c\xf5\x37\x92\x21\xc6\x5d\xb1\x03\x9c\x84\xcc\x84\xd2\x0b\x61\xcf\x50\xe6\xa1\xb5\xf1\x17\x30\x2d\xc8\x7b\x92\xa9\xb4\xee\xa2\x23\xc0\xa7\x3b\xb7\xc2\x81\x33\xa1\x62\x2b\xe9\xcf\x4d\x22\xfb\x70\xbb\x19\xe4\xf3\x9b\x7c\x6d\x4e\xf4\xb9\x0d\xe1\xa9\xa5\xe9\x0f\x34\x57\x8b\x28\x23\x15\x86\x46\x37\xc3\x15\x02\xd8\x28\xb6\xc2\x13\x69\x89\x0a\x89\x96\x47\x57\x78\x54\xf2\x28\xf4\x45\x2b\x15\x0c\x43\x6b\x9b\x03\xb4\xfd\x95\x23\xfc\xf5\x64\xc8\x71\x3f\x8f\x3f\xd4\x1a\xab\x52\x1f\x64\x8b\xbf\x4c\x75\x0e\xcd\x61\x4c\x25\x2d\x29\x21\x74\x20\x26\xf6\x64\x6c\xcc\x89\x86\x8d\x40\x71\xc0\x6a\x3f\x69\xb7\xbc\xf9\xc1\x56\xf8\x7f\xdf\x2c\x9b\xc1\x2d\x96\xf5\x5e\x3d\x22\xb3\xf1\xf8\x9c\x99\xb2\xc5\xa2\xea\xe3\xe5\x6f\xdf\xbd\x7b\xe7\xd8\x46\x10\xb2\xe5\xf0\xe1\x4b\x07\x37\xc3\x7b\x2f\xd1\x25\xd3\xa7\x79\x0b\xf3\xe7\xbe\x32\x79\xca\x52\xfa\xf4\x84\x3b\xbc\x0d\x74\x2e\xd0\xc7\xd6\x84\xb7\x48\xe2\x70\x59\x88\xb7\xa1\xb8\x76\x8c\x15\xa8\x40\x85\x47\xab\x52\x05\xa9\xf9\x49\x89\xa6\x64\x56\xb3\x72\x79\x06\x22\xa1\x35\xd6\x73\xfe\x0c\x5d\x0a\xe7\x40\x1e\xed\x96\xbd\xef\x84\xaa\xe7\xce\x5e\x8a\xca\x31\xce\xed\x5b\xb6\x3b\x17\x9c\x0a\xeb\xb5\xb3\x67\x02\x7c\x78\x2b\xbb\x1b\x58\xf9\xda\xb1\xce\x6e\x70\x0c\x76\x29\x68\x33\x75\x2e\x93\xd4\xf8\xee\xf5\xe3\xe0\x24\x2c\xfa\x09\x3e\x84\x13\xd1\xba\x68\x40\x63\x7e\x1a\xad\xf3\x48\x82\xb0\x6b\x32\x89\x43\xcc\x21\x68\xc2\x9a\x35\x94\xf6\xef\xc2\xdb\x27\xb9\xa9\x7f\x17\xdc\x38\xfa\x1d\x49\x6e\x46\x74\xf3\x3f\x4d\xd4\x27\x93\x13\x90\xc8\xb6\xc4\xcf\x3e\xdc\x7b\xce\xd2\xc5\x97\xc7\x1d\x8d\x87\x16\xeb\x5b\xad\x26\x4c\x98\x34\xb0\xfe\x37\xae\xef\x37\xef\xfc\x0c\xcb\xe6\x20\x59\x5d\x7c\x0f\xa8\x67\x2f\xdd\xbc\x15\xbe\xbd\xfa\xfb\x0d\x48\x56\x97\xfe\xf7\x85\x05\xc0\xf2\xd1\x04\xca\xbf\xae\x05\x8b\xb0\x5e\xc4\xf6\x00\xe2\x5b\x3a\x90\x52\x92\x7a\x1a\x68\x39\x22\xa4\xfd\xf3\x85\xdc\xd3\xc6\x77\x4f\x81\xef\x1e\x55\xe0\x9e\x11\x68\xcd\x3c\xe6\xfe\x8b\x64\xfd\x20\x22\xeb\x33\xd1\xad\xa2\x13\x74\x2b\x22\xe9\xfd\x35\xcf\xc8\xf5\x61\xfc\x75\x37\xbe\x0e\x12\xfc\xd7\x31\xde\x7e\x67\x72\x7d\x44\xcb\xeb\xe1\xfe\xeb\x58\x97\x48\xc9\x75\x5e\x97\x64\x5a\xc9\x75\x93\xff\x7a\x0d\xba\x5e\x4e\x74\x4d\x35\xaf\x6b\x7e\xf5\xe9\x1a\xab\x4f\xd7\x20\x9d\x4a\x68\x24\x36\x70\x14\x3e\x45\x30\xea\x95\x4a\x71\x38\x2e\x33\x22\xa3\x68\xb1\x8a\xb6\xba\x3d\xb4\x81\x6a\xae\x90\x49\x60\x55\xd0\xbc\xa6\x5b\xd6\x07\xc4\x87\xfe\xb4\xd0\x17\x23\x15\xe1\x83\x7e\x27\xe2\x96\x69\xbd\xf7\xf7\x9d\x9b\x82\xaa\xc0\x4b\x33\xb6\x18\xe9\xe8\xee\xaf\xe5\xac\x71\x98\xcd\xa7\x34\xde\x87\x65\x03\xa7\xbe\x9f\x4b\xdf\x9f\x5e\xdb\xef\x47\xd8\xb4\xef\x50\xc5\x0c\x3a\x7d\x5e\xcd\xc8\x79\xfd\xe1\x07\xd5\xc7\x96\xaf\x1f\xd5\x73\xd3\xb0\x89\x23\xbf\xbd\x94\x07\x86\x6c\x87\x2f\x61\xfd\xf5\x0b\xae\x97\x4c\xea\x51\x27\x50\x29\xae\x60\x4d\x5c\x6c\x5c\xac\xdb\x13\x17\x27\xa5\xa4\x21\x18\x91\x48\x20\x34\x13\x1c\x28\x3f\x70\x68\x33\x34\x34\x8f\x8a\x13\x16\xe5\xc0\x0e\x12\xf0\xa1\x26\x29\x80\x10\x67\x7c\x28\x7c\x25\x92\x85\x4c\x00\x35\xc7\x91\x91\x43\xd3\xc9\xa7\x27\x09\xe4\xba\xec\x7a\x60\x4e\x00\x8a\x2f\x8f\xbc\x9c\x37\x7f\xf0\xb4\x79\x8b\x1e\x37\x0e\x1d\xf0\x62\x9d\x6d\x7b\xda\xd6\x92\x51\x75\x7d\x4f\x1e\x34\x4f\xd9\x57\xa2\x1b\x30\x72\x20\xfc\x88\x3b\xfc\xe3\xfd\xe5\x73\x4a\x8f\xd4\x44\x98\xb6\x4e\x5a\xd0\xb8\x88\x3d\xd1\xad\x64\xcb\xfe\xc6\x77\x63\x53\xca\x8e\xf4\x9d\x38\x6d\x95\xb8\xdf\x4e\xb4\xfe\xb6\xc3\x3e\x88\xd7\xd9\x48\xbf\x69\x4e\x89\x59\x85\x5e\x26\x24\x09\x69\x89\x7c\x2e\xb5\x16\x11\x44\x92\x71\x05\x38\x10\x05\x80\x11\x6b\x64\x16\x61\x31\x38\x77\xc5\x3b\x7f\x7c\xcf\x0b\xb9\x63\x21\x7a\xd4\x3b\x2e\xed\xac\x52\xb9\x92\xfe\xed\xe9\xd3\x9b\xf0\xa7\x2b\x3f\xb1\x89\xd8\xfe\x2a\x45\x63\x58\x8f\x78\x23\xa7\x1c\x68\x45\x69\x6d\x8e\x30\xc4\x09\x55\x28\xcb\x98\xc2\x28\x93\x04\x83\x65\x05\x20\xa5\x7c\xf6\x31\x4e\x1a\xf1\x41\x5e\xa1\x85\x13\x05\xc8\xd1\x28\x3f\xa6\x54\x04\x83\x44\x29\xb3\x2e\x3c\x35\xef\x1b\xef\xfc\xa9\x13\x8f\x0c\xae\xda\x44\x35\xf5\x2d\x8c\x2e\xdd\xfb\xf9\xdc\x2b\x9f\x80\x44\x10\xdd\x64\xa2\x7f\x30\xd3\xc9\x1d\x26\x0d\x2c\xed\x06\xef\x9d\x9d\xb6\x6c\xe2\x67\xcc\x0c\x11\xbc\x56\x39\x6b\x61\xd7\x89\x0f\x8f\xf4\xbf\x7c\xf4\x3f\xa0\x7f\x05\x28\x9c\xb7\x9a\x3f\x9b\xf5\xd5\xf6\x43\x56\x40\xbe\x2b\x56\x8f\x86\x4b\x1e\x46\x48\xac\x32\xcd\x31\xbd\x61\x7a\xd7\xc4\x9a\xf4\x2e\x06\x30\xca\x30\x20\x65\xc2\xc2\x04\x7a\xe4\x2c\xe0\xea\x71\xfe\x69\x47\x20\x6b\xc7\x6b\xb2\x78\x30\xba\x38\x02\xb9\x8d\xfc\x28\x3b\xef\xfc\x67\xa4\xf9\xa1\x87\x7d\x9b\x00\x64\x03\x4c\x48\xf6\x02\xe8\xe0\x31\xef\x14\xf5\x7e\x0b\x5e\x3c\x7b\xb1\x6c\x4b\x9f\xb2\xd1\xd3\xbe\x5c\xb5\xee\x52\xe2\x5a\xfb\x82\x91\x2b\x57\x9c\xfa\x30\xf8\x8d\x5b\xc3\x27\xf4\xea\x3a\xe4\xd2\xec\x69\x03\xd6\xf4\x15\xd1\x92\x31\xee\x7e\x75\xbd\x7b\x0f\xee\xd3\xb1\xc3\xc8\x9e\x9d\x0b\x17\x3b\xc7\xb8\xd7\x12\xfa\x57\xc1\xf5\x2c\xc6\x6f\x43\xdc\x3d\x65\x23\x28\xbb\x1a\x96\xe0\xd4\x68\x34\x52\x2b\x25\x3d\x8d\xcc\xa6\xdc\x16\x28\x9e\x40\x67\x08\x25\x1c\x25\xc5\x14\x09\xf2\x36\x8d\xf8\x0a\x32\x04\x0e\x0c\xe8\xc9\x52\x34\xe8\x39\x6c\x58\xe5\x8b\x63\xf3\xba\x67\x4e\x8c\x4c\x98\x51\xb7\x7d\x6d\x4f\x70\x00\x79\x18\x85\xbd\x61\x8a\x99\x09\x0b\x86\xaf\xc1\xe5\xe7\x40\xef\x9c\x62\xa3\x39\x32\xbd\x28\xbb\xcd\x96\x0e\x99\x31\xa5\x21\xad\xf2\xec\x61\x9d\xaa\x8a\x5f\x03\x10\x0c\x10\x08\x56\x2d\x7b\x0c\xd7\xc3\x8f\x08\x7d\x44\x4e\x10\x2c\x69\xa4\x8b\xf5\x26\xa9\x09\xe3\x20\xab\xd4\x4a\xa9\x9e\x22\xc8\x6d\x7e\x68\x28\xf0\x2f\x05\x38\x6c\x04\x30\xe5\xa5\x7b\xd2\xd2\x7e\xcf\x96\xdd\xe8\x70\x76\x01\x30\x2b\x1e\xa0\xd7\x57\x64\x47\xf7\xe9\xf1\x6c\xbd\x8d\xf2\xb1\x30\xab\xe0\xe9\x22\xa4\x2b\x37\xa3\xf1\x9d\xc3\xdd\x44\xd6\xbf\x01\xe9\x96\x2c\x97\x4d\xa3\x0d\xd6\x16\x7b\xcc\xca\xe0\xc4\xe0\xdc\x60\x46\xca\x04\x07\x53\x42\xa1\xb1\x18\xe3\x50\x2a\xff\x56\xb4\xd6\x5f\xbf\xca\x0f\xf3\xab\xb1\xfb\x2c\xb6\xa8\x14\x8d\xd6\x8e\x66\x03\x08\xa3\x19\x52\xc7\x13\xfc\xb1\xbf\x3e\xec\x05\xf0\xde\xab\x87\x86\xec\xfb\x71\xe6\xaa\xd3\xb9\xde\x4f\x43\xc0\xab\xab\x4e\xe6\xd0\x0e\x4b\x3f\xdd\xbd\x2f\x16\x1d\xa5\x7f\x7a\xaf\x61\x3f\xcc\x84\xef\x6d\x5f\x08\xe4\xc0\xb1\x6f\x34\xfc\x82\xbd\x0b\xff\x84\x5f\xed\x99\xb8\x92\xe4\x2b\xf1\x32\x13\xad\x41\x2d\x65\x3a\xa5\x56\xb8\x3d\x6a\xa5\x88\x21\x78\x74\x22\x43\xa0\x7a\x11\x68\x51\xfb\x32\x50\xda\xca\xd3\xbe\x7d\xe5\x8c\x82\x4d\xf5\xb5\x8b\x15\x13\x49\xf1\xac\xd5\x62\x20\xc9\xcf\x1d\x35\x75\xc5\xd4\x69\x19\x9d\xe8\xa2\x55\x5e\x5b\x2b\x24\x73\xe7\x63\x7b\x06\x63\xff\x51\x4f\x48\x7b\x62\x64\x4c\x7c\x47\xe4\x56\xa2\x4b\x5b\xa7\xc3\x99\x14\x0a\x46\x47\xa9\xa5\xea\x20\xa3\x4a\x2f\xe5\xa1\xcf\xa5\x7e\x18\x11\x27\x01\xf7\xc1\x5e\x39\x4e\x9c\xc5\xc7\x8f\x7c\xb6\xb7\x15\x18\x31\x9e\x70\x14\x06\xdc\xa5\x17\xa9\x83\xec\xce\x14\x9b\x53\x1c\x3c\xca\xde\xb5\x6f\x6b\xf3\xed\xf3\xe5\x3a\xc6\x32\x04\xae\x39\xc7\x5c\x19\xbc\xaa\x22\x52\xb6\x40\xa4\xca\x5e\xb4\xe1\xe9\x72\xba\xdd\x9a\x82\xcc\xdd\xde\xcb\xd8\x16\xfd\x1c\x0d\xe2\x20\xd4\xef\x30\x5c\x0b\x41\x2b\xb2\x8a\xdc\x1e\xbb\x39\xc8\x6a\x90\x01\x25\x99\x24\x78\x2b\xc9\x1f\x93\x07\x9c\xff\x02\xc9\x91\xc6\x03\x67\x45\x31\x36\x10\x71\x72\xa1\xb4\x4f\xf9\x9c\x93\xd6\xe9\xf5\xdb\xc5\x36\x73\xb0\xc5\x54\x90\xb8\x8d\x65\xd6\xbe\x91\x37\x34\x68\x00\x2c\xe5\xbe\xf2\xf6\x70\x45\x78\x4a\x5f\xd9\x49\x4f\x6c\x7c\xb7\x95\x25\xd6\x22\x9a\xab\x5b\x95\x7a\x31\x26\x12\x92\xf8\x41\xea\x0a\xa9\xd1\x9e\x8d\x63\xa5\x4e\x8a\x69\x25\xcb\xe3\xf9\xf3\x46\xb1\x53\x8b\xe1\xb7\x48\xf9\x03\x8a\xce\x38\xf8\xd6\xeb\x1b\x3e\x6b\x50\x1e\xd3\xc2\xb7\xd9\xec\xc6\x8a\xcf\xc0\xc6\x63\xed\x32\x33\x72\xaf\x41\x1c\x57\x43\xad\x83\x9b\x09\xae\x5e\x2a\xe5\x72\x89\x53\x75\x7a\x9d\xbe\xd8\x13\x67\xe1\x31\xcc\x11\xaf\x95\x8c\x2e\x4e\x17\x27\x0b\x47\x6b\xf4\x94\x82\x54\x55\x93\x51\xcd\x06\x64\x16\xbf\x5b\xe3\x5f\x1e\x48\x90\x20\xfb\x22\x17\x08\x39\x1c\x13\xc0\x92\x4c\x3a\xa1\x80\xfc\xfb\xfc\x82\x66\xd2\x52\xd3\xc3\x33\xe8\xdf\xb6\x1c\xe6\x74\x87\x77\x81\x10\xd8\x34\xc0\x4c\x7f\x16\x0c\xbf\xfa\xf3\xd8\x7d\xd3\x19\xf8\xc1\xc6\x8a\x41\xa3\x17\x57\x64\x76\x69\x3d\x31\x32\x71\xdc\xa2\xa5\x33\xbb\xc6\xac\x05\xda\xb3\x4c\xbc\x74\xc2\xe0\x84\x91\xf3\x4c\x22\x20\x5c\xb5\xc4\xbe\xb4\xca\xdd\x4f\x3d\xdf\x30\xe5\xf0\x80\xdc\x92\xa0\x10\x87\xb3\x73\x46\xee\xfa\xc2\xcc\x98\x3e\xa1\x89\x39\xe6\xd0\xf4\xbc\xd2\x8c\xaa\x87\x9b\x82\x5b\xd6\x9a\xa1\x7a\x10\xde\xe5\x37\xfd\xc0\xe1\x39\xec\xc0\x78\xa7\x1a\x2a\x98\x94\x43\x57\xea\xf5\x52\x01\xae\x91\x4b\xf9\xc1\xe1\xa8\x96\xd5\xa7\x9a\xd1\xc6\xed\x12\x1c\xbd\x11\x0c\x30\xaa\x19\x46\x42\x42\x3d\x0d\x9f\x2f\x8a\x0e\xb3\x46\x70\xee\xbc\x01\xbd\x24\xcb\xe1\x8a\x82\xea\xdc\xd7\x62\x3d\xdd\x32\xba\x2d\xb4\x58\x2c\x23\xd3\x99\x3b\x66\xe6\xb0\x77\x40\xb4\x39\xc1\x86\x46\xb1\xb0\x38\x3a\x9d\xbe\x0e\x37\xc2\xce\xab\xca\x81\x02\xb4\x02\x1a\xa3\xa2\x56\xa6\xe6\xeb\x98\x35\x7d\x41\x6a\x04\x15\x21\x83\x32\x94\xa0\xe0\x52\x52\xa9\x01\x17\x54\x16\x0a\xcc\x14\x92\xfc\x1c\x5e\xfc\x29\x2d\x34\x34\x59\xf5\x51\x0e\xb2\x85\x4a\xf9\xab\xe4\x62\xa5\x6c\x93\x02\x12\x78\xa7\xa1\x53\x2a\x5f\x4c\x61\x75\x25\xf5\x97\x13\x41\xd4\x87\xa7\x3e\xea\xb1\xf9\xf6\xe3\x59\x93\xe1\x5f\x5d\xdb\xc6\x6d\xe8\x33\x72\xf7\x00\x5d\x5e\xd7\x19\xb0\x94\xf9\xe9\x37\x60\x7c\x78\x75\x36\x84\x57\xc7\xd1\xf5\xab\xb6\xc2\x29\xf0\x52\x41\xb7\x75\x20\x88\xcc\x91\xad\xec\x08\x52\x27\x37\xf2\x98\x5e\xc4\x23\xb5\xdb\xf5\x7a\xab\xc2\x8a\xf4\x8c\x55\xa5\xe0\x05\x78\x8b\x7a\xc2\x20\x4c\x41\xf3\x69\x94\x48\x32\xb6\x90\xe1\x1a\x1f\xbe\x0b\x43\x97\xac\x9f\xdc\xb5\xe6\x95\x45\x43\x5b\x2f\x98\x18\x96\x32\x78\xcb\xce\x55\x1d\x07\xbe\xfa\x68\xf1\xc3\x21\x8b\x3d\xcc\x9b\x7d\x5f\xfe\x26\xbf\xf7\x98\x8c\x98\xcc\x6e\x99\x13\xeb\x32\x23\xca\xac\xd1\x39\xb1\xf1\xbd\x66\x78\x2a\x81\xfe\x8f\x39\x1b\x27\xd4\x90\x3d\x93\x42\x34\x86\xe9\x44\x0e\xd9\x31\xfa\xb9\x5c\x62\x10\x21\x3e\x89\x94\xb8\x74\x27\xd5\x02\x40\xa7\x59\x2c\x52\x31\x38\xfd\x45\xc8\x83\x31\x6b\x53\xa3\x1c\x98\x48\xbc\xa7\xa8\x01\x0f\x6e\xdd\x54\xa7\x82\x61\x40\x47\x27\x9a\xb7\xbc\x08\xac\x49\xb5\xf0\x87\x5f\xd2\x3c\xe3\xcf\xcd\x6b\xfb\xfd\x8c\x13\x03\x75\xd7\x5e\xcd\xab\x00\x52\xe0\x58\x25\x60\x5d\x1b\x07\xbe\x04\xaf\xbd\x44\x1f\x7c\x71\x7e\x8f\x5d\xf7\x46\xc2\xc6\xf9\x80\xc6\x73\xea\x3e\x9a\x63\x0b\x7d\x18\xe4\x0a\x9d\x02\xd7\x35\x96\x04\x0b\xd1\xc4\x12\x2a\x5b\xd4\xfc\x03\x81\x39\x63\xf7\xa1\xb1\x04\xca\x80\x81\x07\x25\xb5\xc1\x78\xb6\xd0\xef\x9a\xe1\xb2\x85\xdc\xf0\x2c\xb7\xc9\x34\x35\x75\xcc\x10\xf1\x72\xe6\x70\x90\x1c\xcf\x10\x6f\xcf\x56\x7d\x25\xf3\x05\x8a\x1e\xbd\x1c\xad\x68\x5f\xae\x12\xb1\x51\x09\x76\xb7\xce\x25\xd6\x08\x94\x94\xac\x85\x11\xe7\xef\x3b\x2f\x85\xf8\x02\xd4\x44\x2c\xd0\x2c\xf8\xbf\x53\xe7\x15\x73\x4f\xce\x13\x3f\x58\x70\x70\x60\xd8\x6b\xf6\xcd\xf0\x91\x6e\xcd\x8e\x82\xf6\xf4\x06\xef\xe0\xe4\x98\x5b\x3b\x81\xfb\xc4\xd1\x71\xd5\x7b\xbf\x82\xd3\x48\x3c\x1c\x65\x47\xf3\xf2\x04\xdb\x83\xb2\x20\x3b\x37\xd9\x65\x72\xa8\x25\x76\xbd\xbd\xd8\xa3\x51\x8b\xf5\xaa\x70\x35\xad\x2e\xf6\x58\x68\x03\xc0\xa2\x30\x25\x50\x05\x4d\x93\xc5\xef\xb9\x91\x40\x76\xe2\x65\xe0\x48\x32\x46\xaf\xe2\x8b\x1c\xf0\x73\x55\x48\xf0\x43\xa5\x20\x5c\x9b\x0e\x7e\xab\x73\x9f\xbf\xbc\xe8\xd7\x6d\x9c\x7b\x6e\x79\xfa\xaf\xe3\xa3\x6e\xbc\x38\x63\x49\xf1\xae\xef\xd6\x81\xeb\x59\x59\xb5\x19\x13\x40\x87\xde\x46\x58\x0a\x36\x88\xae\x9e\x3a\x02\xba\xde\x0a\x5e\xa2\x1e\xba\xeb\xbd\x81\xf0\xa9\x82\xee\x70\xed\xe3\xe3\xfb\xe6\xc3\x0f\x3e\x99\x2a\x62\x0c\x43\x2a\xe1\x03\xef\x19\x39\x78\x7d\x06\x92\xdb\x6b\x91\xcd\xf8\x1e\xeb\xa6\xf4\x48\x6e\xab\x29\x2d\xa3\x62\x81\x5a\x29\x13\x62\x90\x4b\x3d\x30\x93\x1a\x28\xbc\x65\x87\x8b\xa9\x3a\x00\x29\x4e\xca\x23\x2b\x19\xc9\x06\x9b\x83\xce\x84\xfa\xd7\xe8\xea\x19\x91\x9d\x53\x42\x6d\xa2\x76\x1d\x3c\xc3\x33\x46\x82\x55\xe7\xbc\x8f\x80\xf1\xfc\xcf\xde\x91\x4c\x16\x28\x1d\x5d\xa5\x9c\x6f\xaa\xdc\x06\xef\xd2\x66\x6f\xc7\x46\xde\xa6\x48\x41\xfc\xba\xc7\xb5\x41\x0c\x41\xfa\x22\x98\x61\x35\x4a\xca\x24\x33\xb9\x3d\x62\x99\x41\x62\x6e\x51\x29\x0e\x3b\x03\x39\x80\x47\x1d\xc2\x8b\x18\xb3\xc9\xaf\x35\x8c\x5a\x27\x3d\xb0\x6e\xb3\xa3\x66\x47\x4d\xd2\x93\x1f\x8a\xea\x8a\x2e\x9e\xd0\xd4\xec\xac\x51\x4c\x9c\xf2\x53\xdd\x04\x7a\xcd\x51\x7a\x91\x77\xe6\x1f\xef\xd3\x70\x34\x58\x4f\xaf\xd8\xd2\xb1\x2f\xbd\xc0\x3b\xbd\x5d\xce\xa8\x52\x9a\xbd\x41\x68\xc0\xf5\xad\xf7\x23\x59\x92\x48\x25\xb8\x8c\x4c\xb4\x29\x1a\xf9\x25\xa6\xf8\x78\xa9\xc6\x64\x08\x93\x48\x91\x61\x6b\x97\xaa\xa8\x16\xa3\x95\xa8\xc9\x0a\x58\x60\xbe\x6a\xe5\x38\x4b\xda\x5f\x81\xaa\x45\x21\xdf\x0c\x23\x29\xd9\x4b\x1c\x15\xa7\x50\x40\xd7\xb6\xc9\x68\x3b\xaa\x7b\x87\x76\x59\x93\xe6\x4e\x7e\x73\xf2\xc0\x91\x34\x9b\x5c\x37\x78\xd4\xa4\xc2\x79\x87\x87\x71\x7d\x97\xf5\xea\xdf\x75\x96\x25\x79\x47\xb2\x12\xa4\xf6\x1b\xbe\x13\x64\x4d\xaf\x5c\xa8\x59\x64\x6a\x78\x69\x1b\x5c\xff\xd6\xca\x59\xd3\xd7\xee\xdf\xbe\x18\xe8\x1f\xac\xd6\x2d\x32\x9e\x87\x47\xe7\x9c\x38\x5b\xdb\xd8\xd8\x9d\x0a\xf8\x67\x33\xfc\xfe\x19\x35\xea\x6b\x8a\x78\x88\x66\xde\xfd\x22\xfb\x0e\x64\xfe\x93\x7b\xaa\x9f\xb9\xc7\xd6\xe2\x1e\x22\xff\xb1\x9f\x87\xe5\x7f\xb3\x1f\xe9\x78\xc6\xcf\x23\x7e\x20\xef\xe7\x65\xea\x88\x1f\x68\xf5\x5f\x27\x7c\x24\xd7\xa7\xf3\xd7\x5b\x91\xeb\x69\xe4\x3a\xb2\xdf\xe6\xa2\xeb\x43\x91\x0e\x0d\x41\x16\x7a\x32\xb6\xdf\x04\x91\x6e\x4f\x70\x92\xdb\xc3\x50\x02\x64\x92\x0b\x82\x05\xc1\x32\xad\x36\xde\xed\xd1\x52\x32\x5b\xb1\x47\xf6\x3c\xe6\x32\xb6\xcf\x09\xb4\x02\x9a\x02\xbe\x85\x41\x61\x4e\xfb\xa0\xb6\x79\xa4\x3a\xa6\xc5\x41\x35\x59\x32\x38\xf8\x0c\x1c\x4f\xc8\x94\x76\xbc\x36\xf2\xec\x2d\xf8\x9e\xf7\xf2\xed\xbd\x20\xed\xb3\x95\x3b\x86\x1c\xad\x1c\xbc\xf6\xc8\x94\xaa\xba\xd7\xab\xab\x76\xbe\x4e\x4f\xeb\xd9\xf5\xd8\x84\x61\x5b\xdf\x64\x63\xcb\xde\x1e\x56\xdc\xf7\xd0\xde\x5f\xe0\x37\xbf\xfc\x02\x3a\x81\x77\xbe\x1d\x3f\xb4\xef\xbc\x8e\x49\xde\xa2\xb1\xd5\x57\x5f\xae\x9c\x70\x81\xfe\x34\xd1\xb9\xa6\x88\xdf\x93\x2e\x40\x7d\x7a\x1d\xf5\x29\x91\xca\xa6\x5c\x81\x0a\x1d\x66\x0f\x08\x4b\x0a\x73\x7b\x12\x92\xb4\xe8\x8b\x8b\x89\x49\x2b\xf6\xc4\x50\x9c\xf5\x9f\x80\xa4\x5b\xd6\x0e\x71\x08\x70\x4d\x49\x0c\x8a\xd3\xb2\x02\x8b\xc2\x0f\x1a\x9c\x11\x0f\x02\x98\x12\x42\xa7\x30\x3d\x50\x5f\x87\xdd\x35\x30\xee\x3a\xfc\x75\x13\x84\x61\xb1\x61\x49\xce\x11\xcc\x24\xb7\xbb\x97\x23\xd6\x91\xd7\x76\xf8\xeb\x9b\x1d\xf0\xbf\xf0\xc1\xa4\xb7\x67\x6e\xad\x33\x0c\x6c\xd2\x94\x79\x26\x2f\xf8\x80\x7e\xfc\x29\x5c\x7f\xe5\xbd\xd4\x81\x7d\xba\xda\xe2\x93\x57\xa6\xbb\x0b\x12\x3c\xa5\xbd\xe2\xd2\x5a\x6f\x07\xd9\xc7\xd8\xc3\xdb\x26\x1f\x2f\x3f\x7f\xa6\x7c\x02\xe8\xdf\x6b\xd1\xea\xc9\x53\x47\x55\xf1\x32\x74\x1b\x45\x71\x6f\x73\x7d\x29\x1d\xde\xd7\x91\x2a\x14\x6a\xb9\x92\x91\x6b\x28\x61\xf3\x66\x0a\xef\xbc\xf3\x58\xc8\xbc\x93\x24\x24\x35\xef\x90\x80\xc8\x01\x1c\x9d\xd3\x27\x7d\x92\x31\x21\x32\xae\xad\x05\xe6\x8c\x7f\x6d\x3c\x3c\x76\x9b\x6a\x02\x53\x5c\xcb\xb8\xbe\x91\x69\xf3\x8c\x8e\x78\x87\xf7\x73\xef\x69\xb2\x25\xbf\x0d\x34\xb8\x7b\xe3\xd8\xd8\xc7\xa4\xcd\x5b\xa8\xcd\x60\x5c\x9f\x29\xd0\xaa\x7e\x8e\x91\x6a\xd9\x72\xf0\xed\xff\x4f\xe3\xe4\xc8\xef\xdf\x49\x78\x52\xc4\x1f\x06\xfe\x0b\x29\xaf\x04\x8e\x08\xd1\x3c\x47\xab\x85\x1b\x26\x58\xa4\x8a\x64\xe6\x6d\xa4\xd4\x42\x71\x01\xf5\x12\xba\x20\x3e\x41\x03\x13\x47\xe5\xa2\xc5\x84\xd7\x12\x76\x66\x30\x4e\x15\x9d\x05\xf0\x3c\xd1\x37\x3d\xe2\x14\xa4\x26\x1b\xde\x57\x30\x05\x85\xab\xc2\x91\x6c\x95\xcb\x55\xd1\xd1\x94\x58\x65\x08\x65\x78\x0c\x61\x9f\x12\x0c\xc8\x19\x75\x00\x93\x59\xe8\xf0\x97\xb8\x4b\x0b\x08\x98\x0c\x07\xe0\xeb\x92\xd8\xf9\x0a\x7d\x01\x3b\x7a\x2d\x5b\x63\xae\x89\x1f\x7d\xb5\x66\xc8\x40\x36\x65\xcd\xe8\x89\xd5\x23\x26\xcf\xa4\x17\x76\x9a\xec\x72\x78\xcf\x0d\x19\x3b\xae\xb0\x2a\x34\x7f\x47\xbe\x3a\x95\xcd\x5e\x3e\xe5\xe5\xf3\xf0\xd6\x91\x05\x8b\xe7\x2c\x7f\x75\xef\x36\xd0\x6a\x47\xe3\xb5\xf9\x8f\x0f\x1f\x1e\xba\x18\xbe\xb1\xfd\x83\x23\xdb\xc0\x40\xb8\xa3\x4f\x5e\x8f\xfe\xfc\x39\xf1\x6d\xd4\xa7\x27\x6c\x0e\x95\x44\x25\x1d\x8b\x21\xb0\xa9\x06\x4f\x8c\xc1\x16\xd1\xc3\x63\x0b\xd1\x52\xb4\x0e\xe9\x8b\x1e\x1e\x99\x92\xf6\x83\x07\xa3\xf1\xf0\xbb\x3a\x62\x60\xa7\xd4\x2d\x32\x38\xd1\x0a\x36\x02\xbb\xc0\x0f\xd8\x4c\xfb\x40\x53\x91\x98\xe4\xbd\xec\x0c\x66\xa3\x37\x07\xfe\x09\xe6\x25\xc4\x58\xb2\xb9\x82\x2e\x57\x32\x86\x46\x73\xf4\x59\x20\x3f\xfa\x4e\x42\x4c\x6c\x6a\x7a\xf6\x2f\xb9\xed\x42\x63\x52\x33\xf2\x55\xda\xc2\xae\xe9\x83\x5b\x31\xa1\x8d\x5f\x80\x97\xc0\xa8\x0e\x9d\x15\x9b\xb4\xf7\x7b\x7e\xf4\x59\x26\xcd\x98\xcf\xc1\xe2\xd3\x79\x5d\xe4\xf0\x5b\xf8\xb1\x6c\xa7\xbc\x43\xf1\x10\xc9\x98\x8a\xde\x77\xbf\xcb\xc5\xe3\x31\x8c\xe0\x81\xf2\x67\x00\x68\x36\x53\xc0\xc5\x6f\xf4\x03\x53\x85\x07\xf8\x37\xfa\x09\x0e\x4a\xb2\xaf\x7c\x1f\x2f\x64\x48\xf1\xbe\x96\x50\xfa\xa0\xab\xbb\xb6\x8e\xc7\xd0\x87\xd7\xe1\x9f\x6e\x70\xad\x19\x49\xbf\x14\x6c\x35\xfd\xf9\x31\x8f\xa0\xff\x0b\x5c\x0b\x43\xe2\xe1\x60\x4e\xd5\x02\x4a\x9f\x97\x21\x78\xae\x0c\x20\xb5\xd2\x8c\xd8\x46\xa3\x42\x84\x6a\x64\x0f\xa9\x80\x01\xc9\x40\x60\xc0\x9a\xc7\x87\xcb\xea\x27\x85\xb2\xdb\xd4\x2a\x4a\xc8\x00\xff\x81\xaf\x0d\x74\x2b\x5a\xb9\x03\xe4\x01\x3b\x58\x06\x1f\x3d\x2e\x02\x3b\xc6\x4e\xbe\x7a\xe3\x01\x58\x87\x48\xd8\xa2\x7f\xe7\x34\xe8\x08\xa6\xc1\xd1\xf0\x1d\xb8\xcc\x06\x87\xb2\x9e\xd5\xcb\xe0\x27\xf0\x67\xf8\x19\x5a\xd3\xf8\x0c\xe8\x35\xc4\x07\x52\x4b\x42\x4b\x95\x7b\xf4\x12\x2d\xfa\x12\x1a\x35\x42\x79\xb9\x47\xc8\xb6\xa8\x6a\xc0\x17\x8a\x24\xf6\x49\xb8\xd3\xa6\x7d\x06\x71\xdb\x41\x33\x27\xce\x1c\x00\x09\xe7\x40\x71\xfb\x93\xca\x85\x23\xae\x7c\xb5\x7c\x69\x66\x4a\xe9\x05\x10\xa2\x7e\xf7\xe4\x65\x90\x79\x18\x1e\x6b\x57\x3d\x0b\xfe\xf6\xed\x9a\x05\x12\xd8\x0e\xb5\xdb\x0e\xf5\x19\x9f\x89\xc7\x22\x7f\x55\x4a\x19\x94\x91\xe8\x2b\x4c\x1a\x16\xc3\x43\xd2\x86\x85\x48\xb5\xd8\x9a\x7f\x4e\x56\x92\x08\x00\xce\x6f\x24\xb7\x3c\xf4\x0e\xa0\x95\xb2\x76\x1f\x64\x89\x8d\xbe\x57\x3a\xbf\x6e\x63\xaf\xb5\xc0\x7a\xb1\xfe\xd6\xa5\x91\x93\xdf\x7c\x37\xb9\x74\x6a\xe1\xf4\x51\xd9\xc8\x4f\xff\x63\xe8\xe1\x14\xfb\xf8\x0d\x1d\x41\xcc\xa0\xe4\xd6\xc6\x10\xcf\xe6\xa9\xef\x81\xc4\x7d\x87\x37\x28\x04\xbd\x47\xc0\xc7\x8f\xbb\x95\x65\x58\x95\xa6\xcc\xd2\x0e\xf5\xe7\x2d\xc6\x97\xe2\x2c\x88\x5e\x0f\xe2\xd3\x3d\x72\x96\x1a\xe5\xd2\xb2\xac\x48\x8c\x4f\x22\x00\x10\x8b\x34\x62\xc4\x34\x31\x13\xd8\x44\xf2\x99\xf7\xd8\x23\x22\xf1\xd4\x0c\x3e\x27\xa3\xa9\x0a\x7a\x4f\xe1\xc9\x68\xa8\x19\xc9\x9f\x97\xb1\x07\xa0\x06\xae\x7d\xcf\xfb\x15\x39\x36\x23\x35\x0d\xfb\xb0\x0b\x08\x26\x7e\xec\x49\x8e\x13\x4b\x68\x21\xef\x5b\xd2\xb4\x44\x6c\x96\x00\xb7\x47\xa2\xfc\x87\x26\xec\xcd\x6d\xb0\x23\xbc\xbb\x33\xe8\xb8\x76\xdb\xc3\xe1\xc4\x93\xf5\x20\x82\x51\x33\x87\xe1\x97\xf0\xf8\x99\xc6\x72\xee\x4b\x5e\x7e\xf7\x68\xfa\x91\xbd\xcc\xdd\x46\x96\x69\xa2\xcb\x18\x6c\xd7\x44\x1a\xa2\xd0\x97\x5d\x66\x0f\x29\xf7\xd8\x29\x19\x92\xa6\x32\xed\xdf\x39\x4e\xec\x52\x81\xc4\x97\x26\xe6\xdb\xad\xd0\x64\x60\xe4\xc9\x28\x1e\xbe\xda\xb7\xa6\x69\x21\x60\x2f\xc7\xcf\x28\x4d\x8a\x0b\xcd\x61\xf3\x7a\x0e\x1b\xd7\xab\xeb\xa1\x27\x4f\x0e\x99\xfb\xbc\xd2\xcd\xd6\x96\xcb\x2f\xb9\x3a\xd4\xc5\x14\xb0\xdd\x07\xc1\xe3\xf0\xed\xa2\xbc\x42\x65\x9d\x6e\xca\xe4\x5e\xa0\xf5\xe5\x51\x6b\xd6\x8e\x92\x5e\xa6\x33\x26\x55\xa3\x3f\xdd\x1f\x08\x17\xef\x04\xdf\x12\x7a\xd7\x20\x9e\x2f\xe6\xe6\x52\x62\xca\xe0\x92\x0a\x99\x1e\x1e\x21\x92\xe0\xc4\x83\x27\x5c\xe0\xcf\x20\x71\x92\x3e\x62\xf0\x9d\x8b\x60\xb8\xd7\x20\x01\xdb\x2e\xc2\x3d\xf4\xf7\x62\x7a\x45\x32\x7d\xd9\x7b\x38\x99\xbc\x67\x3d\xf4\xb0\x73\xd1\x1c\x0f\xc5\x7e\xac\x52\x25\x96\xb0\x4c\x50\x50\x08\x63\x0e\xd1\x97\x7b\x42\x02\x33\x3c\x91\x87\xe9\x41\x0b\x3c\x2a\x87\xc9\xe0\xa2\x40\x46\x6a\x14\x88\x02\xbc\x22\xe1\xb1\xf0\x34\xec\x5c\x38\x1c\x76\x34\x6d\xb8\xbb\xa7\xd2\x06\x13\x22\x68\x11\xad\xf2\x3e\x89\xa0\x85\x49\xcb\x46\x0d\x3a\x35\x6c\xc0\xec\xc7\xb5\x2f\x7c\x3c\x89\x3e\x06\x5d\xde\xaf\x66\x6c\x4c\x99\x76\xf4\xab\x13\x4d\x33\x81\x21\xb7\xa2\x1b\xfc\x01\xfd\x3b\x75\xf8\xb0\xea\xca\x55\x35\x07\xe0\x4d\x7e\x3c\x5e\x83\xbd\x99\x87\xdc\x07\xc8\x0d\x09\x71\x29\x64\x62\xb5\x42\xa1\x44\xb4\xe9\x38\xb3\x8e\x54\xcd\x34\xfa\xd3\x53\x08\x02\x1f\x62\x35\xc6\x25\x8a\xc4\x3f\xe8\x88\x0c\x96\x62\x1e\x3a\xda\x76\xbb\xd5\xaf\x1f\x0b\xa7\xc7\x82\x5d\x86\x64\x58\x11\x07\x5e\xdc\x0e\xaf\xbc\x8e\x5c\xe5\x76\xa0\x66\xd2\x87\x1f\xbd\x9b\xfe\x03\x18\xba\x66\xc1\x91\xd5\xe7\xa6\x56\x9d\x59\x73\x12\x88\x0e\xf5\xda\xe1\xe5\xf3\x6f\x9a\xee\xc0\x3e\x9c\x02\xcd\xe7\x44\x2a\xc9\x15\xd4\x2a\x21\x81\xe6\x6c\x06\x29\x13\x15\x5d\xe1\x89\x32\x5b\x34\x1c\x92\x85\x14\xa7\x0d\x18\xbd\xfc\xa6\x91\x4f\xbf\x72\x61\x51\xff\x58\xf2\xdf\xf7\x2b\xc6\xc4\x55\xd0\x78\x0b\x92\x94\x8d\x10\xd0\x27\x96\x5a\x92\x16\x76\x9b\x32\x5a\xf7\xea\xee\x13\xda\xc4\xec\x4e\x65\xc1\xa7\x77\x9d\x54\xc7\xa5\xad\xcb\x3c\xb9\xeb\xf7\xa8\x9a\x1b\x1b\xbd\x6f\x5a\xe8\xdc\x15\x5b\x22\x25\x4c\x99\x6e\x7f\xd7\xb2\x99\x73\xbb\x8c\x60\x0e\x34\x0e\x1f\xd4\xa6\x53\xce\x82\x85\xcc\xc9\xc6\xb2\x5e\xe9\xdd\xda\x01\x33\xb3\xfb\xa9\xe9\xf2\xbd\x11\x2f\x6e\x78\xc3\x49\x70\xbb\x9a\xae\xa3\x35\x73\x1b\xad\x99\x14\x2a\xd5\x15\x6c\x30\x5a\xac\x46\xab\x3d\x45\x12\xa5\x14\x24\xd8\x13\xdc\x1e\x93\xdd\xa0\x42\x72\x54\x65\x6e\x71\xce\xf3\xaf\x25\xa7\x19\x01\xdb\x4c\xf1\xff\x2e\x3c\x1d\xcd\xd7\x6a\x7e\x27\x0e\xfe\xf9\x1f\xef\xd7\x66\x3a\x74\xf3\xce\x50\x13\x68\x59\x80\x7a\x3f\xbe\x29\x50\x80\x3a\xab\x4d\x12\x2e\x40\xfd\xf4\xee\x97\x77\x97\xaf\xd8\x39\xff\xb9\x12\xd4\xe8\x2a\x5f\x82\x1a\xcd\x87\x03\xe4\xac\xb3\x2f\x3e\x95\x76\xa9\x4d\x74\xb9\xc7\xc4\x6a\x44\xe5\x1e\x8d\x46\xa6\xd4\xc8\x18\xdf\xac\xf7\x6d\x1d\x36\x47\x60\xf2\x75\x32\x5a\x02\xcd\xd3\x0f\x12\x3b\xcc\x58\x54\x39\xbc\xf4\xe5\xfc\xd9\x17\xe0\x93\x0b\x23\x4e\xef\x3b\x70\xb6\xfa\xce\xa2\x8e\x15\x91\xec\x8a\xd4\x9b\xc7\xc6\x4d\x4b\x8d\xa4\x57\x3f\x39\x47\x07\xf5\x3e\x77\x60\x3f\xa0\x97\x47\x45\x92\xf6\x0f\xfb\xda\xb7\xe2\xf3\xb2\x10\x06\x57\x8d\x60\x59\x4a\x2a\x55\xf5\xf0\x48\xd9\xe6\xca\x3e\x41\x89\xbc\x2e\xb2\x6b\x7d\x2c\x4a\xd7\xf8\x2a\x79\x3e\x03\x04\xcc\xc8\xc6\x74\xbe\xb4\x78\xdb\x16\x65\x35\x08\x2a\x6c\x63\x4b\x6f\x3b\xd9\xe2\x54\x0c\x1d\xbb\xf2\x56\xe8\xa0\x13\xf0\x09\x1d\x53\xe6\x9e\x32\x33\x61\x24\xdd\x43\xb5\x5f\xbf\x0e\x3e\xc9\x4f\x2d\xe9\x74\x64\x23\xf8\xf3\x09\x8f\x93\xd9\xf4\x10\x8d\x6d\x09\x9a\x9f\x16\x2a\xcc\xa5\xd1\x49\xca\x3d\x6a\x9d\x4e\xa1\x64\x2c\x48\xd8\x5a\xcc\x0a\x4d\xc0\xc2\x20\xfb\x28\x5a\x67\x4a\x0e\xc3\x57\xf6\x21\xb1\x2a\x7e\xaf\x19\x0f\x2a\xdb\x78\xfd\xf8\x92\xbe\x29\x13\x47\xad\xdd\xbd\xe8\x02\x10\x5e\x18\x3c\xb2\x36\xff\xe4\xf9\xc1\x67\xe0\x07\x8f\xe1\x1d\xf8\x63\x5c\xf9\x7e\x78\x76\xe3\xd6\xbe\x5e\x37\x97\x0f\x85\xce\x88\xfb\x0d\xbf\xc2\xbd\x0f\x26\x92\x3d\xa6\x93\xa4\xf6\x5d\x2d\x15\x47\x65\x50\x6d\x8f\x05\xa9\xb1\x44\xb6\x7a\x22\x9c\x6e\x0f\x2d\x0c\x63\x22\x82\xd0\x17\xa5\xd3\xcb\x42\xdc\xd8\x55\x41\x6e\x0b\x8b\xab\x83\x04\xaa\x02\xf0\xe7\xb4\x46\xde\x63\x49\x31\xe2\xa3\x04\x21\xb6\x1f\xec\x24\xdd\x43\xe8\x20\xf5\x56\xfd\x85\xe5\x7c\x9c\xcc\x01\xc6\x00\x0c\x66\x02\xa0\x37\x1e\xa8\x6a\x9d\x35\xaa\x34\xbd\x1d\x7c\x15\x7e\x57\x38\xa8\x20\xc3\x92\xa7\xd8\xa8\xe8\x50\xd5\xba\x57\xaf\x5e\xbd\x27\x1d\x1e\x60\x98\xf8\xa8\x72\xd2\xbc\x59\xf7\x26\x0e\x5e\xdc\x31\x37\xf3\xf8\x5b\x96\xa1\x6c\x91\x3b\xbf\x47\xbf\xd1\xad\x07\xed\x83\xe7\xe1\x2e\xab\xc3\xda\xa5\xc3\xa0\xac\x94\x94\x29\x3f\x6d\xe8\x95\x5a\x31\x64\x40\xdf\x41\xfb\x4a\x16\xc7\x77\x4b\x8e\x6b\x75\x36\x8c\x1f\x73\x5c\x6b\xfe\x65\x34\xe6\xc9\x54\xb2\x2b\xc8\x96\x18\x23\x55\x6a\x63\x94\x31\xca\x44\x6d\xa2\xa3\xdc\x93\xa8\xd5\xca\x2b\x3c\x5a\xf6\xef\xb5\x6f\xd4\x58\x2b\x68\x53\x91\xa0\xc4\x8c\x77\xd8\x02\x65\x42\x14\x34\xde\xb9\xf0\xf9\x60\xc8\xa6\xc3\x35\xf2\x50\xd7\x12\x13\x4b\xa6\xac\xde\x5b\xf4\xc2\xf8\x3c\xa4\x7c\x4b\x8f\x75\x07\x92\xfb\x17\xdf\xcb\x1a\x71\xec\x6c\xf7\x2d\x33\xbb\xd5\xae\xb8\x74\x43\x7a\x4a\xb3\x19\xfe\xe7\xd4\x27\x0f\x41\x4c\x9f\xf9\x83\x3b\xa5\x45\x6a\x1c\x59\x65\x9d\x0f\xdf\xb1\x1f\xdc\x5c\xbb\xda\xb3\x64\x48\xf7\x18\x75\x64\xbb\x11\x25\xe5\xc3\xf6\xec\x6a\x1b\x9f\xe9\xea\xba\xe2\xeb\x39\xbb\x31\xfd\x59\x88\xfe\x53\x88\xfe\x78\xa4\xd3\x24\x0a\x63\x38\xa5\xd5\x22\x4b\x5a\x4d\x6a\x23\x19\x59\x2a\x8a\x2f\x73\xf9\xec\x49\x80\x86\xe8\x34\xb2\xe5\xe3\xeb\x40\xe4\x3f\xf7\x00\x03\xea\x3d\xb9\xff\x9f\x00\xed\xb3\xa7\xc2\xdf\x4b\x8f\x62\xe2\x2f\xbd\x93\x31\xf2\xc4\x69\x42\xfc\xf2\x69\x5f\xcf\x52\xfe\xa9\xdb\xb3\xa9\x05\xdd\xbd\x4a\x31\xe1\x1b\x56\x79\x16\x0d\x75\x47\x13\xc2\x2b\x86\x46\x85\xad\xeb\xcc\xdb\x7b\xc8\x96\xe0\x3a\x71\xb5\x94\x9d\x0a\x47\xd2\x37\x58\xa6\x54\x84\x29\xc2\x90\xb1\xa5\x0b\xd6\x95\x7b\x18\x63\xb8\x54\x65\x35\x72\x54\x30\x9e\xe5\x97\x53\xfc\x65\xc7\x02\xb5\x16\xd0\x52\xe3\xf3\x85\x18\x12\x52\x41\x76\x62\x94\x80\x6c\xc5\x84\x62\xd8\x5b\x64\x14\xb0\x9e\x3a\x77\x4d\x88\x3d\x26\x38\x2a\xdb\xfa\xea\xe1\x90\xc6\xe3\x21\xe0\x4a\x7b\x69\x6c\x74\x6e\x97\xd8\xd2\x6d\x7b\x06\x0c\xd6\x86\x8d\xc9\x5e\xe6\xcd\x05\x1f\xce\xe4\x6a\xaf\x0e\x69\xdb\x2a\xd8\x91\x0c\x3f\xf4\x86\xae\x5d\x4b\x7f\x01\x62\x13\x23\x4a\x92\x06\x5f\xad\x18\xfb\xc6\x1b\x23\x86\x3d\x95\xd2\x85\x3c\xcd\xf8\xac\xfa\x2f\xb6\x1d\xfa\x2d\x9c\xca\x3c\x21\x31\x58\x48\xc5\x24\x8d\x47\x68\x32\xd9\x91\x0f\xc8\x31\x16\xa5\x5a\xa1\x02\x2a\x40\x18\xae\x22\xd0\xed\x3c\xcc\xbc\xb3\x45\xe1\x34\xc6\x49\x9c\xb3\x28\xb2\x52\x31\xf9\x5a\x3f\xf9\x64\xc9\x12\xfa\xe9\x6e\x3b\xee\x83\xd9\x5d\x6b\x22\x67\x19\x13\xdb\x74\xce\xaa\x2f\x33\x7b\x9f\x9a\xff\xc8\x91\x26\x3b\xda\x96\xc4\xf7\xe8\xbc\xbb\xeb\xa0\x81\x4a\x63\xdf\xec\xd5\xc8\xb8\xf5\x32\x47\x2b\xfa\x8d\x73\x0e\x1a\x00\xdf\x83\x95\xcb\x97\x83\x17\x80\x33\x2d\x72\x90\x73\x5c\xbf\x8a\xea\xca\x43\x87\xc6\x4e\x46\xd4\xe2\x9a\x61\x38\x1e\x49\x4f\x32\xc7\xf4\x5a\x64\xde\xab\xb5\x5a\x56\x22\x41\xd6\xad\x84\x61\xad\x03\x3d\xec\xb3\x61\x3d\x59\xfe\x38\x45\x64\x62\x23\x13\xd3\x2e\xb4\xe3\x02\xa3\xcd\x08\x00\xd8\xda\x66\x27\x6d\x85\x0f\xce\xc3\xf2\xcd\x20\x05\x82\xee\x16\x78\x75\xda\xb2\x91\x91\x2f\xde\xbc\x7c\xf3\x7a\xcd\x9c\x1b\x37\x1e\x83\x8d\xf4\xca\xb7\xe0\xed\x7d\xe0\x28\xc8\x07\xdb\xae\xad\xcf\x9e\x5d\xb9\xe4\xf2\xad\xa5\xb3\xfe\x6c\xa2\xe0\x17\x68\xce\x8e\x47\x34\xe1\xda\xc8\x0e\x2a\xd6\x25\xb1\x9b\xdd\x1e\xbb\x9d\x15\x8b\xe5\xbc\xe9\x2b\x56\xb1\x7a\xf7\x3f\x55\xf3\xe2\x17\x52\x9a\x2a\x22\xdd\x29\xe4\x9a\xd7\x58\x24\x66\x1f\xd9\x28\x60\x73\x96\x43\xef\xd1\x8b\xb7\xe9\x3f\xb6\xcc\xb2\xc0\xbb\x87\xce\x4f\xc8\xac\x99\xb3\xff\x7c\xd5\x92\xce\xad\x93\x82\xa7\x0e\x39\x77\x14\xbc\xbb\xe6\xfe\xd4\xbb\xef\xd0\x75\x7a\xae\x56\x28\x74\xd5\x5c\x5f\xbd\x72\xe3\xe1\x0d\x7d\x7a\x4b\x45\x8b\x8c\x2b\xf9\xfa\x49\xec\x4e\xc4\x2b\x33\xce\xb1\x63\xd4\x6a\xa9\x51\x2c\xd7\x23\x3e\x99\xf4\x7a\xa9\x91\x91\x6a\x5a\xd4\x3a\x25\x05\xd9\x89\x6d\x82\xa7\x1e\xc1\xab\x76\x68\x1d\x61\x7a\x34\xb6\xb8\x66\x14\x8e\x40\xb1\xb1\x3b\xc3\x34\x2b\xc3\x16\x8c\x38\x7b\xfe\xec\x88\x57\xc1\x26\xfa\xf5\xb3\x15\xad\xce\xb7\x1a\x04\x24\xcc\xa2\x41\xad\xc3\x42\x3b\x47\x0e\x6f\xcc\x63\x5e\x3f\x90\x10\xda\xf6\xa5\x97\x1f\x3d\x42\xed\x9f\x6e\xfa\x95\x7d\x85\xfb\x18\xa3\x90\xbb\xe4\x32\x0a\x08\x25\x42\xa4\xbf\x25\x4a\x1c\x19\xe0\xd7\xdf\xc4\xe8\x8d\xc8\x70\x6a\x49\x32\xa5\x96\x13\x3a\x18\x3b\xbb\x0e\xce\x38\xdb\x44\x09\x86\xee\x84\x1f\x0e\x0f\xca\x04\x2b\xdc\x80\xe2\x86\x66\x82\x85\xcc\xcb\x8d\x79\x43\x42\x98\xb6\xeb\x80\x0d\x6c\x1f\x62\x46\xcc\xe7\xfd\x58\xc4\x7f\xec\xc7\x46\x51\x0e\x97\xd6\x66\x46\xee\xab\xe1\x5f\xdd\xd7\xff\x9f\xeb\x1a\x08\x0e\xff\x9f\x1e\xab\xa5\x35\x5b\xd0\xa5\x62\x68\xda\xd0\xb8\xff\xe1\xa8\xa2\x3f\x8c\xab\x2c\xb9\xff\x5d\x5b\xbc\xde\x92\x91\x7f\x34\x9a\x9c\xb5\xc6\x52\x71\x2e\x63\x88\xa6\x87\x27\x24\x24\x28\x44\x26\x66\xc4\xd1\x6e\x8f\x58\xcf\x84\xb9\x3d\x4c\x4b\xff\x28\x28\x37\x8b\xaf\x3b\x47\x91\xe2\xd4\xb8\x64\x5a\x14\xae\x52\x4a\x4e\xf5\xf4\x42\x07\x96\x19\x91\xa0\xb9\x18\x99\x26\x19\x94\x82\x5e\x37\x2f\xc1\x37\xe1\x87\x55\xeb\x13\x45\xc5\x5b\xd7\xcd\x9d\xd5\x8e\xd9\x01\x6c\x5d\xd6\xde\xf9\x92\x99\x39\x7a\xe6\xed\x4b\x63\x27\x37\x5c\xec\x04\x9a\x68\xc1\xa5\x6b\xf0\x08\x5c\xdd\xad\x7b\x66\xc2\xb0\x09\xce\x20\x57\xa1\xd3\x60\x10\x7f\xca\xf4\x58\xba\x10\x3e\x82\xdf\xad\x58\x01\x74\x64\x5f\x64\x12\xe2\xeb\x08\x1c\xf7\x4c\x15\xb0\x38\x2e\xe8\x32\x2c\x65\xbc\x04\xab\xbb\x1b\x8d\xaf\xcf\xe5\x65\xb5\x4a\xc0\x6e\xc4\x78\x12\xd4\x58\x34\xdf\xea\xf8\x3d\x11\x97\x49\x81\x6c\x35\xa5\x02\x48\x19\x85\x02\x88\x44\x52\x7c\x46\x01\x70\x69\x43\xfd\xdf\x4a\xc5\x61\x2c\x44\x5f\xa9\x35\xbc\x3a\x05\x18\x6d\x8c\xd8\x1d\x76\xe6\x6d\x68\x39\x77\xb1\x16\x18\xea\x41\x83\x19\x46\x2e\x3b\x13\x4a\xcf\x0e\xf6\xce\x95\x95\xd6\x82\xbb\x37\x2e\x5c\x06\x6d\x8e\xad\x38\xb4\x7d\x41\x5b\x67\xaf\x35\x44\xf7\xb5\x42\xed\xe3\x33\x01\x03\x6e\x5f\xc0\xa1\xf6\xc9\x36\xa4\xc0\x20\x97\xcb\xdc\x1e\xb9\xd2\x40\xb9\x3d\x86\x7f\x6a\x1f\x1b\x8a\x38\xd3\x81\x54\xe4\xce\xb0\xf3\xb1\x56\x0e\x7b\x21\xb8\xbb\xf2\xb4\xcd\x3b\x37\x98\x9e\x2d\xfd\x11\x46\x9a\xc1\xfd\x0b\x57\xd6\xc3\x9f\x8e\xc3\xa8\x15\x2f\xef\x5f\x90\x9e\xf4\xd5\x8a\xab\x6f\x5e\x86\x17\x8f\xf9\xe3\xd1\x16\x93\x98\xa9\x3a\x12\x43\xe5\x45\xe3\xdd\x0f\xe3\x5d\x52\x6f\x04\x78\x79\x8e\xc4\xc1\xf1\x7a\x1a\xc7\xde\x7d\x49\xe2\xd5\x42\x5d\x0a\xc0\x8a\x59\x21\xc3\x08\x24\x42\x86\x12\x68\xfc\x48\xf2\x9a\x40\x35\x53\x5c\x9f\xc2\x57\xd2\x34\xe9\x2b\xf8\xf2\xa2\x35\x5f\x1d\x04\x82\xff\x2e\x04\x9d\x9e\xc0\x27\xec\x1a\xef\x7d\x3a\xfc\x69\x15\x97\xef\x7d\x48\x9b\x90\xb9\x05\x9a\x0e\xa2\xb6\xdf\x45\x7c\xd0\x53\x16\x97\x82\x11\xa8\x04\x9c\x56\xaa\x94\x84\x70\x7a\xbe\x60\x48\xae\x33\xf0\xe6\xf4\x0c\xe0\x60\x14\x00\x1b\x59\x5a\xe4\x7b\xa7\x63\xe0\x78\x66\xc8\x4a\x55\x04\x8c\xdd\x34\x96\x0d\x7b\xb0\x19\x44\xfc\xb7\xab\x8c\x4d\xed\x02\xf2\x7f\x6b\xa0\x3f\xe8\xb5\xa6\xb1\x23\x73\x2a\xf2\xd2\xd3\xa5\xdc\x57\xde\xd9\xfd\x96\x75\xdd\x5a\x4b\xcf\x7d\x7a\x15\xdb\x56\x47\xc8\x9e\x47\x11\x65\x42\xfd\x4b\x75\x99\x45\xac\xd1\x68\x71\x7b\x8c\x2a\x39\x29\xaa\x2a\xd1\x68\x58\x65\x08\x1b\xde\x2c\x08\xfd\x82\x27\x28\x10\x64\xe0\xdf\x6d\x27\xe3\xcf\xa3\xdd\xf0\x47\x7b\xc2\x16\xa1\x36\x1a\x76\xc0\xfc\x1f\x6b\x47\xaf\x77\xb2\x12\x3b\xc8\x09\x86\x6f\xda\xea\x6d\xd3\x83\xa7\x2f\x4d\x02\x41\xef\xbd\x72\xeb\xc2\x94\xd1\x35\x9b\x62\x72\xe2\x37\xf4\xd9\x74\x88\x5e\xfd\x3a\xbc\xfe\x4a\xfb\x6e\x45\x07\x16\xef\xdd\xbb\x98\xbe\xf8\x18\xa8\x7f\xb9\xb9\x61\xc7\xe9\xf7\xf0\xf9\x1e\x08\xc5\x63\x92\x82\xc6\x64\x2d\x1e\x13\x50\xf8\xcc\x18\x45\xe2\x31\x52\x0b\x91\xdc\x5a\x47\x6b\x29\x93\x4b\x0d\x42\x5c\x2a\x75\x61\x88\x4b\x2e\x47\x3f\xc4\xe2\xc2\x10\x4a\x1d\x17\x17\x97\xd6\xf2\x1d\x91\xf8\x1d\xe4\x99\x2e\xbe\x67\x82\xf1\x33\xc1\xf8\x99\x60\xfc\x4c\x70\xf3\x33\x24\xbe\x55\xf0\x12\x8e\xf5\x26\xcf\xe4\x35\x9d\xa1\x7e\xc7\x3b\xeb\x6a\x12\x02\x46\x35\xdf\xd3\x3f\x70\xcf\x28\xca\x45\x7d\xd9\x32\x96\x0c\xcd\xa1\xd9\xa4\x96\x64\x3e\xa2\xb6\x9d\x2b\x58\xa3\xb2\xaa\xca\x3d\x66\xab\x95\x32\x06\xeb\x8d\xc8\x13\x36\x32\x3a\xb2\x97\xcb\x9e\x6e\x7a\xe3\x55\x99\xb2\x10\x99\xfe\x5a\x1c\x35\x14\x17\x38\xe6\x55\xb7\x08\x0b\xe7\x02\xc8\xb0\xb9\x20\xdd\x6f\x7a\xe3\x10\x06\xa1\xdd\x6f\x7e\x2b\x81\x02\xd0\x7f\x75\x9f\xa4\x9d\xa1\x4b\x6f\x15\xef\xd6\x47\x49\xf3\xba\x4c\x78\x77\xe5\xf9\x6f\xe1\x3d\x2b\x93\x61\x85\x47\x72\x57\xac\x48\xdd\xb6\x4a\x16\x1f\x76\x5e\xe7\xce\x99\xe0\x74\x0e\x1b\x7b\x2d\xc7\x51\xe0\x4a\xf1\xc6\xe2\xb8\x50\x78\x3e\xc2\x30\x6b\x7a\x6a\xbb\xcf\x0f\xbf\x8e\xfa\x47\x62\x91\x05\x07\x34\x91\x4c\x3e\xe9\x5f\x35\xf5\x12\xf5\x07\xe6\x81\xd4\xc7\x03\xd4\x3f\xdf\x78\x20\x9f\xa1\xbd\x2b\xda\x4c\x55\x78\xcc\x66\x34\x91\x82\xca\x3d\x4a\x7d\x91\x9e\x46\x2a\x53\xaf\x61\x25\x6c\xb9\x27\x49\xe8\x12\xba\x85\x73\x84\xac\x50\x28\xc1\x3e\x6e\x62\x7f\xe2\x20\x06\xea\x50\xf2\xfa\x56\xa0\x57\xe1\x65\x6e\xa4\xed\xbe\xc3\x1c\xff\x9e\x17\x9e\x70\xa0\x50\x0e\xa4\xc3\x2f\xba\x5f\x78\x00\xeb\x3f\xf8\x6c\xc4\xb1\xc6\x9d\xa0\xa8\x7d\xbd\x66\xc1\x90\xbd\xb7\xd3\xc1\x21\x0b\x3d\xb0\xbf\x0b\x5e\x5a\xbd\xbc\x1d\x5c\xf1\xe3\x37\x7b\xc1\xcc\x27\x73\xe0\xb1\x76\x53\x6a\xbe\xff\x72\x2d\x1e\xab\x68\x44\xe7\x01\xb2\xb6\xd3\x29\xea\x1f\xe2\x7b\xf9\xb8\xc0\xfe\x2d\xe2\x02\x5b\x3d\x3b\x96\xe8\x9e\xe5\xe8\x1d\x53\xc8\x33\xad\x88\xaf\x52\xdb\xf4\x0b\x7e\x07\x39\x77\x6c\xef\x8a\xd1\x87\x55\xa0\x5e\x87\xea\x2f\xe8\xdf\xd1\xff\xac\x6f\xd2\x0b\xb4\xa8\xf7\x5a\xa0\x65\x90\x39\xcf\x88\xe4\x03\x3d\x22\x24\x25\x2a\x3c\x40\xd3\x5c\xf4\xe9\x19\x09\x67\xc7\x45\x8c\x24\xb8\xe0\xba\xaf\x98\x95\x46\x6b\x67\x7c\xe6\x71\x20\xa8\x14\xd0\x9f\x7c\xf1\xe8\x64\x55\xff\x9a\x65\x53\x9c\x21\x26\x6d\x68\xa6\x2b\xb7\x64\xd8\x38\xf0\xa8\x2a\xb6\x76\x77\x87\x99\xfb\xdf\xec\xd7\x25\xb9\x22\xab\x60\x72\x07\xf6\x0c\xec\x09\xb7\xc2\xcb\x35\x92\x05\xc2\xcc\x79\x10\x4c\x03\xdb\xbc\x6f\x6c\x59\x50\xfa\xea\x8a\x6e\xe0\x4a\xcf\x0a\xa8\xeb\xb9\x81\xf4\xe1\x33\x9e\x0f\xa4\xae\x71\xb8\x4b\x2b\x0d\xae\xf0\x98\xe4\x1a\x39\x26\x53\xa3\x94\x6a\xd4\x14\xe3\x2b\x54\xcd\x1b\xc4\xc4\x9e\xe4\x49\x72\x34\x67\x29\x80\x00\x75\xcc\xb4\xaa\x7e\x84\x90\x7e\xf0\xc7\x19\xf0\xd4\x8c\x9d\x40\xb0\xb3\x0a\x74\xaa\x02\xb1\xfd\xba\x0c\xae\x18\x8d\x08\x43\x32\xd0\x47\x07\x3d\xcd\xbb\x18\x7f\xa2\x5d\x8d\x73\x7c\x14\xa1\xf5\x82\xe8\xc1\xeb\x25\x98\x8a\x77\x19\x44\x02\x9d\x80\x78\xa1\x94\x5c\x25\x95\x4b\xcb\x3d\x72\x46\xec\x0b\x86\x7f\x6e\x69\x04\x2a\xbf\x3f\xbf\x20\x90\xc8\x1e\x3c\xea\x5f\x16\xc1\x58\xda\xfe\x0f\x73\xdf\x7b\x13\xcf\x87\x5c\xe4\x2f\xc8\xc9\xdc\xbf\xe1\x9b\xfb\x8b\xf9\xb9\x6f\x7c\x76\xfd\x5f\x13\x6c\x45\xf7\xbc\x85\xef\x11\xb7\x27\xd9\x48\xe8\x1e\x6d\xe0\x9e\xa6\xf3\x4d\x3f\x70\x25\xe4\x3d\xef\xe3\x7b\x44\xdf\x50\x49\xfc\x7b\x74\xcd\x6b\xc8\x89\xe4\xf2\x6d\xb2\xcf\x19\xe1\x52\xb3\x42\x11\x83\xd4\x0c\x87\x63\xff\x25\x62\x5a\x43\x9d\x06\x22\x12\xc0\xcb\x4b\x62\x23\x09\x27\xb4\xf3\xc9\x21\xc8\x2c\x03\xee\x12\xb8\x06\x08\x2e\x3c\xa4\x0d\x0f\x2f\xc0\x27\x70\x4d\x09\x2c\x05\x07\xb8\xfc\xa7\x65\xec\xde\x27\xe7\x60\x29\xf5\x7c\xce\x01\xb2\x73\x30\xdd\x77\x50\x7b\x78\xef\x3b\xd2\xa5\x13\xa8\xcb\x3d\x02\x01\xa0\x7d\xd9\x06\x9a\xf2\xe6\x29\x1a\x58\x99\x31\x00\x67\x1e\x30\x44\xed\x0a\x58\x6d\x6a\x0c\x60\xf0\x42\x4d\xa7\x0b\xbc\xbf\x01\x01\x53\x6b\xf5\xc6\xb8\x41\xfb\xf7\x3f\x59\x01\xbd\x37\xe1\xe7\xf0\x4e\x3f\xe0\xdc\x73\x3c\x48\xc0\xe5\x6f\x85\xc3\xb6\xbe\xb0\xe0\xeb\x69\xe0\xec\x49\x18\x5d\x35\xd3\xfa\xb7\x9c\x07\xbf\x9c\xc1\x9f\xb1\x9c\x41\x73\xb2\x1b\x1c\xc1\x6e\x43\xf4\x29\x90\x2e\x8c\x74\x69\xe4\x2a\x3c\xf0\x3a\x4a\xcc\x89\xcb\x3d\x1c\xba\x8b\x26\x2c\x71\x3a\xfd\xc7\x36\x38\x6c\x10\x97\x4e\xc7\x05\x99\x9c\xe9\x9a\x0c\x2d\x29\xc4\x4f\xa3\x1f\xf5\xaf\x8c\xa9\x2b\x6a\xac\x2d\xaa\x1b\x33\xa5\xea\x40\x8f\x7d\x74\xbf\x4b\xf0\xee\xf4\x6e\x9b\xcb\x69\x73\xad\xb7\x01\x6c\x84\x23\xe8\x84\x2a\x90\xdf\x08\x60\x2d\x5c\xf4\x3d\x3c\x3f\x91\xa2\xfe\x96\xdb\x80\x74\x35\xe2\x1f\x57\x41\x62\xab\xb3\x5c\x36\x93\x20\x84\x11\x30\x0a\x2b\x12\xb4\xc8\xad\x51\x28\x24\x4a\x95\xde\xc0\x89\x19\x96\x0b\x36\x87\x72\x81\x8c\x1e\xdf\x82\x09\x6c\x7c\xd9\xb5\x91\x51\xc8\x40\x88\x8c\x62\x9c\x5a\x1c\xf1\x85\x37\x4c\xf0\x8e\x8d\x40\x88\x16\xbd\x12\x30\xe0\x48\x75\x56\x34\x5c\x75\x06\x5c\x4d\x09\xaa\x3c\xd2\x49\xdb\x35\x6f\x72\xdd\xe4\xc2\x89\xad\x1f\x1c\x81\x9f\xa4\x96\xbc\x72\x66\xa6\xba\x6f\x35\x5d\x2e\x97\x7b\x17\xd3\xef\xb8\x06\x80\x8f\xe1\xac\xc1\xc3\x54\x74\x99\x77\xaf\x6a\xc8\x50\x30\x0f\x46\xf7\xee\xe8\x4d\xa2\xa7\x71\x7a\x5f\xdd\x77\x72\x2e\x7c\x80\xf3\x50\x71\x54\x27\x57\x6c\xb8\x4a\xa9\x52\x56\x78\x54\x2a\xca\xa2\x34\x85\x9a\x68\x39\x63\x32\x59\x2c\xc6\x72\x8f\x85\xc5\xda\xc7\xc5\xba\xd9\x39\x2c\xe3\x57\x3e\xfd\x03\x05\x9e\xb0\x60\x52\xfb\x37\xbf\x5b\xe8\x1f\x7f\x09\x4a\x9f\x33\xd4\xc2\x8f\xf7\x85\xde\xd2\x34\x75\xeb\xbb\xe4\xfa\x88\x5d\xf3\xaa\x5e\x1e\x78\xa4\xbe\xa3\xa5\xe3\xe5\xb7\x67\x4f\x84\xde\x95\xbb\x87\x83\x98\xb7\x5e\xfb\xb0\x78\xfb\x98\x9a\x55\x7d\xea\xee\xeb\x76\x9d\xed\xb6\x7a\x6e\xb7\xd5\xbd\x2b\x3c\xeb\xd6\x4f\x2b\x2e\xfb\xb3\xed\xe1\x03\xdb\xe6\xf7\xde\x5a\x19\xa4\x5b\x34\xb4\x57\xfd\x82\xce\xa4\x2f\xbe\x9c\x08\x5c\x03\xc0\xa5\xa0\x05\x42\x19\x0b\x18\x4e\x24\x96\xb3\x01\x6e\xf3\x75\xca\x04\x42\x5c\x27\x0c\x1b\x4c\x59\x40\x70\xf8\x25\x73\x3c\xfd\xe3\x67\xf0\xc9\xc1\x83\xc6\x38\x6f\x08\x97\xdf\x58\xb7\x62\x11\x3b\xe1\xc9\x39\x66\xcc\xb8\xd5\x4f\x6b\x9b\xd7\xef\x01\xff\xfa\x45\x6b\xd3\xc2\xaf\x4d\x45\xf3\xda\x24\x72\x00\xb5\xad\xa6\x62\x5c\x06\x89\x9c\x56\xd2\x4a\xb4\x4a\x68\x99\x4a\x8d\x9c\x33\xc0\x09\x18\x2c\x20\x7d\x23\x1e\xd8\x2e\x70\x32\x29\x78\x8b\x1c\x07\x90\x38\x90\x3c\x47\x52\x32\xff\xc2\x84\xd3\x27\x41\x87\x1b\x70\x61\x4a\x79\x6b\x30\xf6\x33\xf8\xfe\xf0\xee\xd5\x17\x90\xf4\x3b\xd1\x00\x66\xc0\x1e\x59\x7d\xa2\xbc\x76\x7a\x71\x24\x4e\xc9\x05\x4d\xeb\x90\x5e\x79\x42\x64\xb2\xcd\xa5\x42\x06\x02\x50\x03\x24\x05\x19\x01\x12\x80\x02\x6d\xcb\xfa\x5b\xc4\x31\x6b\xa1\x31\x00\x9e\xfb\xc0\xc1\xda\xe1\xa2\xca\x89\xbb\x4f\x2c\xcd\x0e\xb6\x68\xc3\xdb\xf6\xe9\x33\x2e\x7f\x33\xfd\x11\x7c\x72\x96\xdd\x0b\x5f\x86\x9b\xe0\xa6\xf5\x92\x8d\xc2\x4e\x5b\x80\xfd\x0e\xf8\x9c\xec\xfd\xfd\xcf\x3c\x94\xb8\x7f\xcc\x11\xc9\x0a\xe4\x88\x68\x5c\x62\x8e\x46\x0b\x93\xa1\x58\x62\x16\xc7\xf9\xf3\xd7\xec\x80\xa1\x1f\x7a\xff\xfb\x10\x9f\xbe\x2c\x41\x46\xf0\xde\xa7\x65\x38\x3b\xa4\x79\x8d\x05\x72\x43\x9e\xb7\xbd\x9f\xcf\xe1\x40\x3c\x21\x72\x14\xb5\xa7\xa5\xb0\x89\x27\x91\x50\x0a\x29\xb2\xc3\x9b\x13\x84\x7c\xf5\xa4\x8c\x78\x8a\x12\x56\x64\x90\xa2\x31\x40\x41\xef\xce\xa9\x89\xad\x74\x77\x4e\xed\xd2\x7b\x2e\xac\xfd\x08\x68\xc0\x0f\xb7\xbd\xe1\xa3\x17\x2c\xd3\x45\xd8\xd7\xb4\x8e\xf4\x1c\x67\x56\x7a\x2d\xf4\x57\x4f\x1f\x6f\x98\xd3\x1a\xb5\xeb\xcb\x0d\x41\x52\xa6\xf4\x1f\xf3\x2c\x8c\x48\x56\xef\x25\xb2\xda\xe2\x92\x89\x39\x46\x4a\xd2\x58\x58\x0d\x2f\x93\xfc\xc5\x0b\x91\x40\x22\x45\xe2\x88\x94\x66\xd8\xca\x09\xf5\x25\x8d\x35\x44\x4a\x4b\x1e\x5e\x78\x58\xe7\x3d\xe5\x17\xd1\x4f\xcb\xd0\x3b\x17\x22\x5e\xbc\x4d\xf6\x4b\x42\x5c\x4a\x46\x51\xee\xc9\x65\x00\xc3\x88\x74\x1a\x8d\x88\xc1\x1c\x45\x2b\xb0\x3f\x1f\x82\xe1\xb0\xa9\x5b\x44\x4c\xf1\xa5\xdf\x86\xef\xde\x9d\x0b\x77\x4b\x2a\xcf\x8f\x12\x5e\xc9\xda\xb8\x67\xe5\x79\xf8\xe4\x3c\xf8\xcc\x61\x04\x92\xc4\x54\x3a\xd5\xfb\xb9\xc3\xbe\x5b\x13\x4a\x7f\x48\x18\x0f\x9a\x7e\x41\xfd\x51\x11\xfa\x83\x31\xfd\x80\x41\xee\x0c\x32\x50\x9a\x53\x6f\x70\x54\x9a\x2f\xf7\x90\xa8\x18\x15\x10\xec\x7a\x04\x82\x1f\xf1\x3f\x20\x9a\x97\x4f\x3b\xb2\x67\xf0\x37\xf1\x63\x7e\x44\xfc\xf8\x04\xbd\x4f\x49\xb5\x72\x05\x21\xdd\x25\x95\x71\x48\x7b\x89\x25\x72\x05\x87\x54\x18\x32\x23\x68\x8d\x92\x57\x61\x7c\xec\x95\xf1\x79\x1d\x46\xbe\x91\x47\x33\xaf\xa4\x31\x88\x34\x05\x1e\xf9\x7e\xac\x1a\xeb\x53\x65\xbe\xf6\x9e\x76\xf4\xde\x24\xfa\x0b\xdb\x08\xe3\x88\x3c\x08\xc2\xfa\x8b\xc2\x07\x27\x94\x18\xcd\x0a\x62\x20\x68\xcb\x3d\xe2\xbf\xe9\x2f\x5f\xf5\x57\x16\x1b\x2d\x19\x76\xbf\xbd\x82\x15\x58\xdb\x05\x44\x6b\x1d\x82\xc7\xbe\x85\xc7\xac\xb4\x02\x80\xb5\x6b\x2a\xfb\x4d\xde\x73\x22\x48\xc0\x28\x89\xea\x42\xc6\x41\xe3\xd4\x7e\xbd\x61\xf4\xa4\x99\x16\x92\x3f\x84\xf3\xd5\x29\xe2\x17\x1a\x70\x6e\x85\x4b\xc7\xaa\x2a\x3c\x2c\x0b\x4c\x41\x0c\xd2\x9f\xea\x0a\x4f\xb0\x11\x6b\x50\xa7\xd3\x17\xf7\xcb\x1f\x9c\x39\x31\x57\x7d\xb6\x13\x48\xc5\xa1\xb0\xb8\x7d\xec\x30\xfe\xf1\x07\x10\x1c\xaa\xca\xf9\xe8\xae\x7b\x7d\x03\xd0\xc0\x2f\xf2\x2b\xba\xed\xad\x0f\x12\x5c\x41\x7f\xc5\xfc\xf6\xbe\xb1\x79\x65\xff\x53\xf3\x3b\x82\x0b\x67\xa1\xae\xa6\xc6\x0a\xf9\x65\xc4\xeb\xf1\x39\x64\x2c\xf5\xc8\x43\x55\xb1\x48\x32\x21\x2a\x30\x0d\xaa\x66\x1d\xee\x6b\x1d\x29\x70\xe7\xbf\xa9\xef\x0b\x63\xff\x51\x75\x7b\x6f\x3c\xab\xb9\xf9\xd8\x31\xde\x97\xa2\x42\x28\xb7\x2b\x99\x0e\x41\x16\x2f\x0d\x64\x0c\x4d\xeb\xe4\x3a\x13\x1a\x06\xa3\xca\x68\x33\xba\x8d\xac\xcc\x68\xd4\x69\x95\x92\x50\x49\xb9\x84\x91\x33\x12\x89\x5c\x8e\x56\x89\x9c\xa5\x9a\xf5\x0a\xb2\xfd\x03\xa6\x3f\x6f\xff\x02\xe2\xdc\xf3\xf9\xc9\x1a\xbb\x4d\xad\x93\x00\xd6\x61\x63\x32\x34\x98\x51\xe0\x77\x0b\x38\x28\x9f\xb9\x68\xe8\xab\x6d\xb7\xbe\x09\x7a\x80\xc3\xc3\xce\x40\xb8\x1b\x9e\x74\x1f\xce\x6a\x38\x78\x27\x9d\x1e\xb8\xd6\xdd\x75\xc3\xa6\x39\x93\xda\x81\x22\x98\xbf\x1f\x2e\x82\x8f\x97\x83\x49\xed\xe0\x37\xff\xfd\x9a\x8f\x5d\xfd\x11\xd1\xfd\x3e\xa2\x5b\x4f\x85\x51\xe9\x2e\xab\xd2\x84\x28\x67\xa5\x02\xf4\x53\x8a\xe8\x97\x4a\x45\x12\x31\x23\x14\x69\xa8\xd0\x8a\x66\x91\x42\x78\x87\x69\xa3\x7c\x75\x58\xf1\xd1\x94\x83\xd8\xbc\x4e\x0d\xe5\x24\x14\x0a\x02\x25\xc6\x49\x3c\xeb\x9e\xd5\x2b\xf5\x9b\xaa\xb1\xd5\x3b\x71\x53\x01\xa0\x8f\x83\xd0\xb2\x75\x6f\x01\x45\x61\x97\x21\xb5\xa3\x57\x0f\xd9\x34\x46\x77\xeb\x8d\x11\x73\xbd\x3b\x10\x73\x8f\x80\x54\x90\x0a\x67\x6e\x81\x43\xe0\xe7\x2f\x32\x3f\x4d\x9b\xfc\x05\x8c\xd9\xf2\xd7\x23\xf0\x21\x4f\x2f\x9a\xe9\xec\x5b\xc4\x06\x0a\x42\x96\xb0\x51\x0e\x64\x5a\x59\xb9\x47\xab\xa5\xc4\x62\x1d\x3e\xfb\x96\x48\x15\xfe\x6c\xbc\x40\x36\x0c\xc5\xaf\x5d\x5f\xce\x04\xce\xcd\x73\x00\x2d\xde\xa3\xd1\xda\x6d\x42\x41\x1a\xcd\xce\x7f\x61\xc1\x93\x97\xc1\x97\xf0\xc9\x85\xaa\x9f\x60\xd8\xfb\x73\x6b\x40\x50\x19\xfc\x05\xbe\x1b\x27\xa0\x7b\x19\x77\x4c\x9b\xf9\xe1\xb8\x27\xe7\xe8\x5c\xef\x9b\xcc\x0b\xfd\xcb\xc1\x87\x0f\xac\x48\x1e\x76\x42\x7c\x4b\x27\xf1\xc9\x1d\xc8\xda\x9b\x87\x3e\x7f\xc2\x7d\x86\xd6\x7b\x34\xde\xdb\x55\x31\x6e\x4f\xa4\x4a\x65\xb4\xdb\xc3\x7a\x78\xec\x94\x51\xea\xf6\x18\x0d\x7f\xdf\xdb\xc5\x3c\xf2\x45\x54\xe5\xd0\x0c\xb1\xcb\x79\x17\x2f\x18\xa0\x59\x98\x21\x94\x21\x3b\x08\x39\x0f\x3b\x47\x4f\x1a\xb2\x76\x70\x56\xd5\xe4\xe1\x2b\x07\xa6\xef\x38\x71\x48\x37\x1c\x9a\x2e\xbc\x3e\xe6\x00\x7c\x73\xdd\xaf\xa1\xd0\x0d\xff\x5c\x91\x90\xf7\x90\xde\x58\x3d\xbe\xcb\x86\x6f\xfa\x4c\xad\xee\xb4\xe5\x47\xf0\xe6\x4b\x07\xdc\xa3\xbc\xbf\x5f\xbc\xb5\x11\x9c\x06\xba\xba\x70\xb3\x7d\x67\xfa\xa0\x8f\x3e\x98\xb9\x12\xad\x53\x5c\xeb\xb4\x07\x9b\x4d\xea\xc4\x44\x22\xf9\x64\x14\x58\x43\xac\x21\xc5\x1e\xab\x55\xa3\x56\x5b\x70\x7e\x80\x4a\xe3\xe6\xf7\xcd\x5b\x08\x0b\xdf\x56\x07\x59\x2a\x4a\xc0\x9b\x33\x48\x6c\xa0\x05\x83\x23\xc4\x22\x7d\xbf\x92\x74\x22\xfa\x97\xa3\xc7\x57\x2f\x04\x23\xc7\xba\xe6\x9c\x18\x03\xcd\x0d\x2c\xd0\xb9\x47\x77\x70\x8c\x9d\x0e\xff\xea\x93\x0b\xa8\xe1\x53\x9c\x65\x23\xd9\xec\x31\xa3\xc6\xd6\x99\x84\xf2\x21\x25\x1d\x57\x8e\x48\x67\xb3\x1b\xbb\x98\xdb\x0c\x4c\xe8\xd8\x16\x5c\x84\x6f\x24\x0c\xc9\x6e\x93\x49\xd6\x15\xde\x07\x9e\x4f\xea\xe8\x13\x7d\xea\xf6\x70\x4a\x96\xd1\xfb\xf4\x29\x10\x62\xd3\x96\x9d\x6f\xf6\xee\x3e\x55\xdf\xc0\x66\xaf\x6a\xec\xc9\x66\xf3\xf3\x64\x00\xb2\x95\xbb\x91\xe7\xb4\x94\xd3\x65\xa6\x90\xbc\xc6\x55\xb4\x95\x2c\x27\xd7\x68\x39\x99\x58\x86\x37\x2e\x85\x12\x29\x23\x20\x42\xd8\x48\x8c\x66\x2c\x84\xfd\xc7\x03\x38\x64\xdc\xae\x0d\x18\xcf\xd8\xe5\x64\x56\xc2\xcb\xbd\xf7\xf7\x07\x4f\x6f\xed\x2e\x6a\xfc\xa6\x68\xf7\xe8\x29\x23\x2f\x8d\xa7\xab\x5e\x7d\x81\x39\x0c\xff\x82\x33\x5f\xf0\xde\x23\xa6\x73\xe4\x42\x70\x09\x0c\x69\xec\x19\xd0\xdf\x7d\xc8\x3c\x29\x24\x7a\x66\x23\x92\x91\x71\x88\x2e\x3b\xd5\xd6\xe5\x08\x16\x5a\x58\x21\xab\xb4\x01\x25\x22\x4e\x93\xa8\x04\x4a\xa5\x54\xa5\x36\x18\x39\x89\x92\x13\x98\x43\xec\x1c\xde\xf4\xf2\x19\x51\xfd\x9f\xb7\x9b\x13\x00\x36\x9c\x13\x90\xbc\x36\xfa\x0c\x67\xda\x6f\x37\xe3\xb0\x54\x70\xb4\xbf\x25\x43\x08\x77\x9c\x01\x57\x34\x99\x75\xc7\x87\x25\xe6\xc7\xf5\xd9\xdc\x27\xd2\xed\xf9\xe6\x38\xfc\xae\x2c\xf9\xde\x99\x4d\xb2\x76\x21\xfd\xc1\xe7\x6c\xb0\xd0\xfb\x94\xae\x08\x19\x09\x7a\xfd\x3c\xa6\x4c\x03\xde\x82\x99\xf2\x9c\x81\x20\x04\x9e\x1b\x15\xe7\xad\xa3\x39\xb1\x89\x81\x36\x5e\xc6\x75\x47\x7d\x29\x20\x39\x4d\x69\x2e\xb3\x5d\x21\x57\xc8\xdd\x1e\x43\x30\x4b\x29\x14\xc1\x54\xb0\xd6\xed\x09\x56\x51\xc2\xbf\xa5\xba\xe0\x03\xae\xe7\xec\x64\x5b\x2e\x5f\x6a\xcc\x87\x1f\xd2\x5c\xdb\x4f\xa8\xe7\x13\xd4\xc0\x8f\x57\x2f\xeb\x5f\x92\x2e\x9e\x0f\xc4\x0e\xe6\xc2\x01\xf3\xb5\x8f\x3e\x99\xb7\xca\xb4\x3d\xe5\xe7\x37\xeb\xaf\xf5\xd9\x50\x5a\xb9\xaa\xe6\x47\xdd\xb4\x85\xf1\xbd\x8a\xce\x58\xdc\x65\x4b\x47\x0d\x9a\x53\x58\xa8\x5b\x3a\x6d\xf6\xd8\xa2\x19\x3d\x24\xb4\x74\x7a\x9f\x01\x27\xca\x49\x8e\x90\x2f\xdf\x42\x8e\xb4\x80\x5a\x04\x64\x14\xcb\x49\x58\xb9\x92\xc1\xf9\xf9\x32\x3d\x19\x74\x23\x8f\xe4\x01\x88\x8d\xcc\x10\x1b\xd9\xa1\x05\xef\x4e\xe4\x5a\xd3\x5b\xaf\x34\x1c\x9e\x13\x12\xe4\xed\xf7\x06\x9a\x59\xde\xa3\xd6\x3f\x99\xa1\x4f\xaf\xd2\xeb\x16\xba\x1b\x37\xe0\x49\x86\x73\x15\xd1\xfb\x97\x72\xf5\xc8\x4e\xfe\x16\xc7\x98\x8a\xbe\xf9\x8d\x78\xb9\x0a\x3e\xc6\x14\x50\xe3\x71\x3c\x13\xba\x57\x83\xd6\x98\x09\xd9\xc8\x2a\x5a\xe5\xf6\x24\xd2\xc8\xa3\x94\xa9\x35\x8c\x54\x8f\x06\x8b\xc1\x51\x76\xfe\x11\x6e\x69\x27\xa7\xf3\x4e\x10\xd9\xe2\xc4\xa2\x35\xaf\xbe\xdf\xd8\xdd\xc3\xbe\xbd\x08\x1f\x0c\xec\x05\x14\xb7\xee\x85\x4f\x49\xee\x57\xcf\x66\xc3\x48\xcf\x24\x20\x87\xe7\xc6\xa6\x79\x5f\x06\x5e\xa5\x0e\x46\xa2\x39\xb6\x15\x8d\xd3\x5c\xd2\xae\xc3\xa5\x01\xa8\x59\x32\xf3\x85\x68\xca\x0b\x0d\x1a\x3c\xa5\x52\x9a\xa3\x10\x88\x51\x2a\x01\x81\x52\xe1\x64\xa6\xd3\x4f\x4e\xc1\xf9\xeb\xaa\x87\x4d\xed\x95\x1c\x6b\x32\xc5\xa4\x0f\xaa\x79\x85\xbe\xda\x80\x66\x79\x7b\x78\x6f\x63\x07\xf9\x5c\xf1\x02\x90\x45\xcb\x9e\x5e\x45\x6d\x79\x51\x1f\xdf\x25\xb1\xec\xd9\x2e\x89\x52\x8f\x54\x93\x5c\xc6\x0a\x85\x18\x42\x24\x48\xac\x2e\x54\x18\x8c\x42\xc4\x72\xad\x0b\xfd\x4e\x71\x02\xa9\x36\x48\xc0\x73\x3e\x8e\xa0\x3b\x38\xd5\x24\xd0\xc5\xae\xc5\x76\xa9\xc3\x17\x4e\x8d\xb7\x73\x75\xbe\xfd\xdc\xa1\x2b\x45\x76\x29\x8c\xdd\x54\xc9\x58\xb9\x95\x9b\x1b\x9e\x74\x95\xb1\x29\xdd\x41\x87\x9f\x1b\xe8\x0f\x62\xd7\xc4\xe1\x1d\x5d\xd3\x29\xad\x37\x1e\x0d\xd0\xec\x51\x43\xd3\x12\x6a\xb7\xf2\x7b\xba\x80\xea\x8a\xe8\x9a\x4b\x62\x98\xe2\x5c\x41\x42\x11\x10\x15\x7b\xe8\x44\x80\xfe\x23\x28\x13\x7a\x82\x32\xa1\x7c\x6e\x71\x91\x38\x29\xad\xdf\x63\x06\x0d\x1e\xf0\xd4\x53\xdf\x50\x5f\x01\xb9\x0a\x2c\x5d\x60\x3a\xb8\xf1\xf4\x2a\xf8\x11\x6a\x7d\xe3\xff\x7c\x8e\x8a\xbf\x4d\x92\x1f\xce\xa0\x95\x8d\x16\x83\x50\x49\x23\x67\x08\xf0\xb3\x2d\xd0\x0a\xdf\x02\x3b\xb7\xa1\xfe\x14\xe4\x88\xe8\x7a\x7a\x95\x39\x4c\xa4\x97\x7f\xff\x9d\x75\xa3\xf7\x96\x04\xda\x19\x42\xda\x29\x20\xed\xbc\x8b\xda\x39\x41\xda\x41\xb6\x2a\xc7\xea\x19\x01\x25\x70\x7b\x00\x49\xac\x0c\x18\xda\xc4\xd9\x47\xed\x3c\x62\xde\x32\xc3\xea\x53\xa8\xa1\x6a\x22\x20\x99\xc3\xc4\x7e\xff\x19\xb5\xf1\x7f\x24\x67\xab\x1f\xb1\xdd\xd2\xd0\xe7\x8d\x24\xb6\xd5\x8c\x2c\x81\x44\x57\x90\x4c\x4a\x59\x83\x24\x41\x6e\x8f\x5c\xa2\x0a\x35\xd2\x46\xb7\x47\xf7\xb7\x64\x81\x40\x63\xfe\x5c\x01\x3e\x2a\x9e\x55\xf3\x49\x02\x3a\xa3\x56\x01\xe8\x88\xd4\x28\xe4\xd3\x6b\xc0\xe3\x2d\xee\xfa\x2b\x3d\x36\x7f\xb2\xbc\xf3\x96\xce\xa0\xba\x68\xd3\xa7\xcb\xe0\xc1\x3b\x7b\x6a\x76\x7b\xe8\x6f\x1a\xf6\xcc\xdc\x5d\x8a\x8c\xda\x8d\x8a\x1b\xa7\xa6\x01\xf5\xb5\x2a\x19\x98\x0b\x67\x5b\x61\xdd\x0c\xf8\xe8\xd6\x64\x19\xd8\xfc\x87\x8d\xe9\xae\xd9\x02\x7f\x3a\xf5\x73\x70\xe3\x09\xcd\x0e\x60\x20\x7d\xf8\x03\xf1\xe1\x02\xe9\x43\x19\xe1\x4b\x47\x24\xf3\x67\x92\x31\x8f\x41\xfe\x30\x66\xbb\x04\x14\x7b\xc4\x12\xbd\x50\x84\x84\xfc\xc9\x16\x63\xee\xf4\xd9\xdc\xfe\x11\x27\x63\xae\x05\xb7\xcf\x80\xa7\x67\xea\xcf\xbc\x38\x02\xc9\xf7\x23\x68\x50\x70\x5d\xf3\xc6\x4e\xde\xff\x80\x8d\xe8\xad\x80\x3a\x84\xda\x1b\x86\x7e\xc3\xfe\xa7\x4e\xc1\xa1\xd1\x55\xa8\x14\x36\x45\x85\x82\x55\x28\x24\x7a\x11\xe1\x7f\xae\xcf\x27\x61\x84\x7c\x95\x7d\xfc\x66\x7f\x16\x12\x38\xd5\x9d\xf5\xf4\x98\x74\x73\x30\x9a\x54\x65\x8f\x77\xcd\x9c\x26\x72\xa3\x59\x35\x36\x32\x27\x27\x95\xa6\xd0\xcc\x6a\x28\x1b\x3f\xcc\x91\x00\xb6\x50\x2d\xd6\x95\x14\xd7\xc6\x43\x7d\x11\x4b\x38\xa0\x24\x7b\x60\x14\x53\xec\x91\x92\x55\xdc\xc2\x6d\x70\x68\x9b\x9d\x06\xa6\xa1\xee\x0c\x50\x9d\x41\x3f\xd4\x67\xea\x02\xbd\x60\x4e\x91\xf5\xfa\x1b\xe2\xd1\x06\x92\x8f\x9b\x70\x4c\x21\x47\x6c\x71\x19\x5a\xbc\x1d\x7b\x29\xf8\xfd\xca\x67\xdf\x9f\xeb\x6b\xc1\xe9\xff\x46\x9d\x92\xa3\x56\x1e\x9f\xe1\xbf\x57\x8f\x58\x5d\xd4\xdc\x0e\xcf\x31\x64\x13\x75\x43\x7d\x28\x23\xf2\xd7\x88\x6d\x22\xb9\xb1\xd8\x23\x97\x8b\x64\x52\xa9\xd8\xed\x91\x2a\x45\x8a\x62\x8f\x48\xdf\xec\xb6\x6b\x7c\x1e\x89\xcd\xbf\x89\x9a\x61\x97\x36\xef\xa9\xd0\x3f\x83\x31\xed\x67\x9e\x98\x08\x87\x9f\x82\xa7\xcd\xa0\xd1\x53\x71\x63\xd8\xec\xdc\x11\x13\x6f\xd2\x55\xdf\x75\xdb\x3c\x22\x93\x39\xbc\x0a\xa6\x43\x65\xe6\xa4\xbc\x7c\x17\x9e\xcf\x00\xb5\x7d\x93\xf0\x4f\x4f\x99\xb0\x2f\x22\xd5\x23\xb6\x49\x45\x41\x46\x89\x58\x29\x92\x15\x7b\x4c\x06\xdc\xf8\x73\xbe\x48\xa0\x71\x67\x8b\xa6\x09\xe0\xcd\x19\x5f\xf3\x6f\x34\xec\xf1\x54\x6c\x19\x38\x23\x67\x48\xe5\x56\xba\xa8\x61\x4f\x83\xaf\x7d\x2c\x1e\x7c\xcd\x43\x39\x5e\xce\xa8\xff\x83\x11\x0d\x02\x1f\x0d\xc8\x0f\xf1\x51\xe0\x6b\xdf\xdf\xf5\xff\xd5\x32\xbd\xd9\xd7\x6a\xbb\x86\x7a\x4f\xc5\x2f\xa4\xc3\xbf\xfe\xbd\x41\x3c\xf7\x8b\x91\x8c\xe8\x8e\x74\x73\x38\x95\xe2\x0a\xb1\x18\x90\xf9\xa6\xc4\xb9\xa7\x26\x8b\x52\x05\xa4\x0c\xde\xe1\x52\x51\xd2\x66\xe5\xcc\x1b\xf0\x44\x37\x13\x0b\x1e\xaf\xde\x5c\xe0\x8b\x34\xb1\xb7\x70\x38\x7c\x1b\x58\xd8\xff\xbb\x57\x7d\xa2\x02\xbc\x31\x7b\xcc\x0b\xaf\xb6\x82\xf3\x4c\x60\x96\x68\xca\xcc\xea\x1d\xf6\xf3\xad\x81\xfe\xd4\x8d\xf7\xca\x76\x7c\xad\x2b\x59\xdf\x4f\x22\x92\xc9\x06\x8f\x38\x7a\x6e\x7e\x76\x42\xcd\x94\x91\x65\x8a\xf5\x2f\x5f\x3f\xb7\x04\xde\xbd\x32\x0a\xdb\x64\x9f\x22\x1a\x0f\x23\x1a\x0d\x88\x4a\xe4\x6b\x18\xf4\x4a\xad\x4e\x2f\x0b\x46\x54\x69\xf0\x94\x43\x74\x22\x86\xc9\x0c\xac\xbd\x19\x62\xca\xe7\x68\xf8\xdc\x0e\x1c\x5d\xd5\x4c\x90\xc3\xef\x77\x20\x8d\x11\x48\x7e\xc1\x3e\xc7\x93\x03\x39\x80\xda\xbb\x7c\x4b\xb7\xe5\xe7\xc6\xae\xd9\xa9\xd8\x5f\xb1\xa7\x61\xcf\x9d\xa2\x2e\x65\xab\x7a\x15\xe5\x0d\x7c\xa1\x84\xae\xfa\xea\xe9\xa5\x57\x66\xc1\x8f\xee\x56\x9d\x3b\x92\xdf\x13\x8b\x73\xaf\x75\x7c\xf5\x11\x90\x3b\x63\x52\xcd\x09\x78\x8e\xd8\x8f\xf7\x11\x29\x43\xd0\xd8\x61\x5f\x36\xdd\x65\x91\x31\x68\x0c\x8b\x3d\x06\xa5\x1e\x28\x19\xbd\x1e\x88\xc5\x72\x24\x59\x94\x34\x32\x20\x7d\xb2\xfd\xb9\xcc\x5e\x27\x8f\x89\x4e\x50\x0b\x91\x1c\x36\xfb\x90\xda\x0c\xad\x01\xdd\x1a\x8e\xb9\x09\xea\xaf\x3c\xfd\x09\x1c\x45\xc3\x3a\xf0\xfb\xc1\x73\xda\x0d\x18\xe5\x05\x37\x90\x7e\xf9\x28\xfe\xec\xa9\xab\x48\x12\xdc\x00\xbf\xa6\x8f\xef\x98\x97\x47\x35\xdb\x90\xd8\xce\xc0\x36\xa4\x5a\x40\xe5\x1d\x23\xb9\x30\x91\xfe\x5c\x17\xfe\xfa\x8c\xc0\xf5\x51\x22\x9c\x4f\xc3\xd0\xd1\xfe\x7c\x1a\x5f\xbe\x74\x1e\x92\xef\x31\x54\x9e\x4b\xc5\x45\xc6\x44\x22\x7d\x18\x23\xb5\xb9\x3d\x22\x69\x84\x14\x6b\x6b\x8d\x58\x56\x18\x23\x8d\x91\x52\x11\x7a\x2d\x12\xf6\x5a\x5c\xa2\x33\xb7\x39\x78\x0c\x75\x2f\xab\x45\x72\x08\x29\xab\x85\x64\xbc\x33\x1d\xbb\x7b\x42\x86\xb7\x1f\x70\x81\xed\x96\xf9\xd6\x8e\x0c\x27\xa8\x3a\x69\x05\x71\xc1\xf0\x8e\x5c\x15\xc7\xac\xfa\x01\xd8\xe5\x75\x96\x75\x53\xbb\x26\x9b\xdb\x16\x74\xd0\xd5\xf2\xd9\xd7\x93\xea\xbf\x5d\x10\xbc\x80\xbb\xb5\x6d\x7e\x5e\xef\xa3\xb7\xa1\x37\xab\x5d\xe3\xb5\x8d\xcb\xc5\xcb\x05\x9d\x87\x31\xac\x2f\x09\xfb\x10\x7b\x98\xe0\xeb\x10\x7f\x80\xd8\x5c\x5f\xf9\xce\x1f\x5e\xe4\xcf\x16\xa4\xea\xc0\xde\x24\x3e\x5b\xac\x21\xb9\x8f\x49\x2e\xb3\x19\x07\x6f\x23\x51\x63\x30\xb3\xc8\xa5\x95\x22\x97\x96\x32\x1b\x28\x11\x9a\x74\xcf\x4c\x31\xdf\x4a\x00\x81\x30\xee\xe6\xa3\x7c\x7c\xf0\xe6\x03\x0a\x40\x0a\x8e\xfe\xfd\x54\xc3\xc5\x49\xd5\x6b\x4e\x26\x80\x59\x26\x38\x4f\x3c\x6e\xee\xf8\x03\x11\xaf\x85\x6e\xfe\x64\xfa\xcd\x77\x4a\xf6\x7e\xc7\x76\x7f\x65\x9d\x42\x50\x3a\x7c\xcf\xe9\xf9\x6d\x52\xa7\xce\x1f\x37\x42\x56\xbe\xad\xef\xd5\x0b\xb3\x41\xe8\x07\xa3\x31\xfd\x63\x11\x6d\xf9\x6c\x17\xa4\xb3\x7a\x93\xb1\x8d\x44\xfd\x09\x22\x67\xed\x5d\x03\x9f\xbb\x91\xb1\xfc\x8d\x1f\xcb\x18\x3e\x37\x4a\xdd\x9c\x1b\xd5\x74\x11\x96\x32\x4f\xc9\x33\xdd\xc8\x5c\x7d\x19\xbd\x73\x01\xc9\x63\x0c\xa3\x32\x5d\xa1\xc1\x61\x68\x35\x05\x03\x9c\x82\x2e\x0c\x0a\x12\x17\x7b\x82\x94\x0a\xc4\x04\x85\x41\x68\x46\x22\x41\xff\x2f\xa7\x6c\x44\x00\x81\x38\x80\xdd\x07\x3a\xb0\x71\x9a\xa1\x25\x42\x18\x19\xec\x71\x80\x89\x07\x7d\xc6\x35\xac\x7e\xe7\xdc\xde\x59\x6d\x47\x4f\x19\xd0\x2a\xc2\xa4\x8b\x48\x6c\x9f\x97\xb9\x1d\xbc\xe5\x19\xe4\xfc\x26\x8a\xbb\x92\x4a\x57\x7d\x3b\xea\xdc\x60\xe6\x4d\x98\xff\xc1\x37\x15\xd2\xb9\xc2\x0e\xfb\xdf\xa4\x2d\x48\x4e\x71\xd7\x53\x56\xf2\x7e\x19\xea\x15\xbb\x92\xe4\x80\x86\x20\x9d\x60\x50\xe8\x8a\x3d\x21\x2a\xa0\x2a\xf6\x70\xc4\x3a\x53\x2b\xf4\x0c\xaf\x47\x03\x56\x59\x5c\x40\x49\x13\x11\x89\x28\x24\xd6\x19\x21\x0a\x4b\xe7\x72\x0f\xe8\xe2\xd9\xec\x49\xe7\x45\xe5\x7b\x83\xe0\xc9\x41\x9b\x1b\xc0\xe5\xf4\x27\x51\xdc\xf0\x09\x19\xbc\xd9\x06\xd3\x89\xcc\x04\x7f\x42\x31\xd2\x53\xad\xaf\x27\x17\x14\xfa\xfc\x03\xbc\x26\x6c\x68\x85\x2b\xa5\x68\xd2\x73\x16\x9b\x05\xad\x0b\x9b\x48\x45\x96\x04\xf2\x12\x0b\xa5\x36\xa9\xcd\x8c\x5c\x61\xca\x5f\x2d\x3c\xce\x9f\x08\x13\xf7\x0f\xcb\xc0\xf1\xff\x9d\xfd\x8b\x4e\xce\xfd\xb7\x49\xef\xed\x46\x6f\x6a\x39\xdb\xc9\x7c\x20\x3e\x04\x99\xef\xdf\x93\xf9\x50\x3d\x8a\xcc\xf6\xa0\x00\x5e\x0a\xf6\x71\x9a\x7d\x10\x2a\xef\x10\x7f\xd2\xe6\xbb\xce\xdb\x79\x44\x76\xf4\xe3\x7d\x94\x5f\xc9\x75\xa3\xdf\x47\xe9\x8a\xae\xf3\x76\xb2\xe5\x0c\x25\x46\xe6\x00\xb6\x04\x90\xfc\x40\x46\x00\x86\x7b\x0b\x24\x3c\x3a\xfd\x06\x06\xea\x58\xd7\x86\x7a\x62\x28\x35\xc0\xba\x92\xdd\x25\xbc\xe2\x7f\x7a\x15\x6f\x4a\xf2\x7e\x62\x36\x9a\x8f\x97\xb8\xbe\x54\x0a\xe2\xab\x59\x1a\x1d\x16\x5d\xee\x91\x47\x9a\xcc\x91\x61\x14\x65\x56\x85\xb1\x6c\x92\x39\xa9\xdc\x63\x34\x6b\x9f\xcb\x63\x6c\xce\x30\x42\x96\x3f\x9a\x7d\xc1\x20\x2d\x10\xea\x64\xd0\xab\xe8\x66\x20\xd8\x60\xe0\xaf\xd3\x1e\xc8\x05\xa0\x33\x6a\xbb\x1b\x7b\x76\x5d\xd6\x37\x39\x36\x3e\xae\x4b\xff\x99\x83\x46\x2f\xf8\x64\xee\x8b\xe9\x93\x6b\x87\x8f\x9d\x77\x7f\x7e\x6e\xf7\x90\x91\xc6\x84\xf4\xa1\x1e\xa4\x6b\x7b\xba\xe9\x6d\x70\xec\x12\xaa\x09\x1c\x78\x61\xf6\x92\x94\xde\x13\x1e\x5c\x87\x4f\x61\xf6\xd3\x43\x87\xae\xdf\x7a\x02\xde\x06\xea\xf4\xd6\xa5\x29\xb3\xa1\x17\x9e\x1e\x53\xb3\x0a\xd7\x06\xa1\x7a\x21\x1e\x7f\x4f\x62\x52\x42\x5d\x0a\xb5\x48\x21\x95\xcb\x25\x7a\xa5\x54\x29\x94\xf0\x09\xfc\xbe\x80\x17\x4c\x38\x41\x71\x10\xe2\x98\x17\x8c\x0b\x89\x8c\x25\x4a\x9d\x1a\xc5\x7e\x2a\x1f\x7c\xfa\xe5\x3a\xc7\xfb\x07\x57\x9c\xf2\x7c\x13\x77\x2a\x01\xb4\x91\xb2\xd9\x99\xfd\x66\xc3\xef\xe0\xdb\x9f\x81\x25\x70\x2a\xe2\xe1\x58\xf0\x32\xf8\x9a\xfc\x2c\x19\xe0\xa4\x02\xe7\x91\x73\xc8\xde\xbe\x99\x72\xba\x82\xb5\x52\x99\xb4\xc2\xa3\x92\xc9\xc4\x0a\xca\x48\xb6\x76\x15\x8c\x38\xa8\x79\x57\xb7\x39\x1b\x23\xb0\x87\x11\xd8\xdc\xe5\xcb\x2f\x61\xb8\x28\xdf\x1e\x27\x58\x03\xda\xbf\xf3\x60\x39\x6c\x3c\xe4\xfd\xed\xe2\x4a\xcb\xca\xa8\x0b\x51\xe0\xa6\x05\xa6\xd1\xb4\x6f\xaf\xf3\xcd\x13\x8c\x72\xcf\xe6\x65\x77\x26\x30\xdf\xbc\x78\xeb\xd6\x8b\xde\x1b\x17\x60\xf4\x32\x9e\x2e\x6c\xd7\x2c\xe4\x6e\x22\xff\x32\x18\x79\x0a\x26\x51\x30\xb2\x66\x44\x2a\x74\x41\xa8\xa1\x34\x38\xf4\x58\xa9\xd2\x16\x07\xf6\x8f\x7c\x63\xac\xe6\xed\x1c\x2d\x99\x44\xfe\x23\x53\xb2\xef\xcc\x97\xf4\x8d\x03\xb3\x40\xab\xee\xf5\xdd\x41\xac\x19\x7e\x98\x01\xd4\x27\xea\xe1\x93\xcf\x61\xf6\x29\xf8\x3e\x68\xff\xe7\xea\x4d\x1f\xff\xc5\x66\x83\xb5\x70\xdc\x72\xf8\x9f\xa5\x73\xea\x3f\x62\x5e\x69\x7c\x77\xc6\xcc\x2d\x7c\x0c\xdd\x87\x4d\x3f\x70\x21\x04\x5b\xc9\xe5\xb2\x5b\xad\x06\xb1\x58\x6f\xa0\xb4\x41\xda\x72\x4f\x78\x50\x90\xde\xc0\xe8\x35\x66\x7b\xb9\xc7\xcc\xca\x39\x34\x11\xb5\xcd\xf2\xef\xd9\x08\x42\x35\xa9\xf3\x20\xf0\x01\xc4\xe0\x6c\x59\xc7\x33\x1b\x9b\xf6\x16\x21\x17\x74\x91\xbe\x5f\x7f\x67\x69\xcf\xc2\x55\xe3\x3f\x5d\xb4\xeb\x80\xfa\x60\xf5\x6e\x20\xd8\x3d\xe1\xe0\x4a\xb0\x1e\x84\x44\x1d\x51\xf5\x2c\x9a\xb1\x35\x0b\x14\x58\xe8\x81\x0b\xfa\xcd\x9d\x96\x32\x64\x46\xe6\xcd\x03\xef\xbf\x53\x5e\xe5\xdd\x8d\x8f\xb6\xe8\x41\xf0\xe5\x9c\xa5\xa3\xef\xfc\xb9\x96\xa7\xff\x09\x5a\x2f\x37\x91\xbe\x8a\xa2\x0a\x5d\x91\x0a\x05\x63\xb5\xd2\x8c\x91\xe2\x90\xbd\xa1\x53\x72\x48\x8e\x73\x1c\xcd\x28\x69\xbd\x58\xed\xf6\x88\x55\x61\x66\xb7\x27\xcc\xf0\x6c\x27\xfc\x46\x47\x73\x3f\xb4\x04\x94\xd5\xe9\x2b\x51\x22\xcc\x48\x6d\x56\x68\xbc\x3e\xf3\x75\xae\x71\x00\xb2\x8d\xca\x0e\xb6\x7e\x7a\x72\xe9\xc6\xa3\x60\xfd\xc8\x25\xf1\xa0\xbb\x09\x1e\x97\xef\xe8\x36\xdd\xfe\x52\xd2\x17\x2f\x6e\xdc\x21\x05\x5f\x42\x2b\x92\xa2\x71\x3f\x36\xee\x58\xa5\x54\x04\x1f\xdc\x7b\x7e\x7e\x8f\xbc\x7b\xc3\x2b\x65\x9b\x4f\xd6\x9f\xe8\xd0\x05\xc9\x74\x3f\xe6\x9b\x14\x79\x46\x0e\x97\x9a\x11\xaa\x70\xfa\x8e\x44\xa5\xc2\xae\x36\x10\x93\x2d\xff\xdc\x16\xa9\xca\x76\xc4\x52\x2c\x1f\x71\x60\x98\x12\x08\x94\xc0\x1e\x15\x19\xc5\x7a\xae\xf7\x9a\x37\xfc\x95\xe1\x35\xf0\x53\x0c\x07\x37\x5f\xd1\x3d\x61\x3a\xc8\x77\xc8\x45\xb4\xce\xfb\x03\xfe\xe6\xf2\x0f\x58\xf7\xf5\xf8\xf4\xd3\xde\x15\x7e\xfb\xcc\x4a\xe4\x96\x86\x6f\x53\x23\x74\x7b\x94\x12\x8d\x46\x2c\x41\x3c\x13\xeb\xff\xad\x4d\x32\x98\x09\x20\x4a\x49\xb3\xd6\xeb\x85\x33\x0a\xf7\x14\x4e\xfa\xe0\x06\x3d\xff\x4e\x7b\x53\xb0\x3a\xb3\xf5\x44\x50\x05\xd7\xe0\x6f\x64\x12\x9e\x9f\x33\xff\x78\xf5\x94\xb7\x50\x5b\x1f\x62\x5b\xd0\xb7\x0e\xe3\x5d\x06\x21\x23\x55\x49\xcb\x3d\x41\x3a\x8d\x4a\x25\xd7\x30\x68\x11\x72\x40\x4e\x3a\xe9\xcc\xe5\x9b\xf4\x5b\x80\x2d\x3a\xea\x9b\x45\x48\x63\x28\x68\xa1\x9d\x8e\x62\x87\xec\x4a\x29\x1f\xbe\x6b\x78\x59\x13\xb5\x0b\x88\xce\x0e\xc7\xf3\x67\xce\x77\xa0\x53\x5d\x15\xd3\xd9\x32\x03\x88\x42\x18\x7f\xbf\xf9\xbe\x7b\x47\xd1\xb5\x07\x24\x87\xda\x79\x41\xda\x00\x8a\xa0\x8f\x23\x9e\xa3\xfe\x63\x84\x48\xa7\xcb\x24\x13\xa9\xf4\x48\x89\xd2\x7a\x40\x69\x71\xa8\x9c\x86\xd1\x2a\x15\x12\x81\x46\xcf\x93\xe5\x03\x6a\xf3\x4b\x58\x2c\x1b\xa4\x00\xd7\xe4\xf0\x33\x85\x7c\x63\xe9\xbe\xb8\xd5\xd5\xbd\x4b\x36\x6e\x8f\xe9\x59\xb8\xa9\xb0\xf8\xd5\xdd\x57\xee\x15\xa2\x09\x32\x1e\x70\xe0\x2f\xf0\x02\x1c\x4b\xb7\x47\xc6\xa9\x8f\x45\x60\x3c\x5c\x8d\xd8\x74\x96\xd7\xeb\x47\x10\x3d\x8d\x24\xe6\xc7\x86\x51\xec\xe4\x2a\xb3\xaa\xc2\x63\xa5\xcc\xe6\x10\xa5\xd0\xa0\x09\xb1\x95\x7b\x42\x18\x2a\x90\xbb\x93\xe8\xc7\x5d\xe1\x6b\x90\x33\x0e\x0d\xd6\x9b\x51\x88\x06\x05\x4d\xea\x69\xd2\x19\x8c\x5d\x0c\xec\x4c\xff\xbd\xeb\xb4\xa9\xf5\x99\x8a\x19\xcb\xa6\x9f\x9f\x3e\x67\x43\x69\x64\x4c\x7d\x74\xdc\xd4\x2b\x1b\xaf\x31\x3f\x79\xb7\x03\x1d\x9c\xc0\x70\xea\xda\xda\xd4\xe5\xf0\x4f\x60\x1d\x67\x1d\xd1\x97\xf3\xae\xa2\x27\x70\x85\xeb\xcf\x37\xdc\xbe\x7f\x67\xaa\x92\x76\x79\xcf\x80\x43\x98\x3e\x44\x26\xfb\x3a\xe2\x97\x99\xb2\xe2\x31\x14\x88\xb5\xc8\x09\xb5\x1a\xb4\x5a\x85\x4e\x67\x71\xa3\x85\x26\x02\x0a\xbd\x2f\x78\x82\x97\xa1\xfe\xed\x31\x87\x9f\xb4\x30\x41\x80\x34\x42\xb6\x10\x29\x44\xb6\xdd\x41\xdb\xf4\x8d\x3d\x0f\xf4\x3c\x79\x24\x5a\x71\x50\x11\x3e\xf9\x8d\xda\x06\xe6\x63\x38\xe4\xe0\x66\xc3\x05\x58\xb4\x7c\x7b\x87\x51\x03\x38\x58\x0c\x5e\xd9\x76\xab\xa0\xe0\xd8\x95\x51\x0a\x5a\xe0\x7d\xa2\x5a\xb3\xaa\xa4\x92\x19\x09\x67\x51\xbe\xb9\xf5\x13\xe2\x9b\x03\x49\x2f\xa7\xcb\xac\x92\x9b\x6d\x66\x24\xb7\x28\x9b\xcd\x12\x66\x65\x84\x4a\x03\x63\xd1\x84\x45\x96\x7b\xc2\x7c\xdc\x43\x9e\x86\x3a\xc0\x3f\x9e\x81\xc6\x67\x19\xc8\x30\xb8\x1e\xa9\x4f\x6c\x21\x39\x8b\x2d\xba\x63\x93\x46\x02\x45\xc7\x7d\x2e\x55\x7b\xf7\xf4\x3d\xd3\x73\x4a\xda\xc4\x15\xec\x8b\x0e\x6d\x1b\xbd\x68\xea\x2e\x20\xd8\x55\x05\xa6\x0d\xa6\x6f\xc0\xc4\x6b\xbf\x31\x9c\xb2\x7a\x5a\xdc\x58\xf8\x02\x28\x1c\xe7\xe8\xda\x91\x70\x93\x8d\xe9\xb9\x04\x6e\xb8\xbd\xff\xf5\x6c\xef\x7a\x34\x0f\xdf\xa4\x73\xfd\x3c\xc5\x78\x36\xd7\x08\xbe\x4e\x04\xa6\xdd\x80\x0c\x33\xe4\xba\x45\x08\x19\x86\x42\x46\x84\x42\x8f\x46\x5c\xcf\x85\xe3\x2d\xfb\x7f\xa6\x9d\x9f\x71\x3c\x33\xf9\xda\x4a\x3c\x9f\xd1\x0a\xf1\x75\x01\x38\xb4\xad\x1b\xea\x87\x80\x05\x63\x11\x7d\x0d\x93\xc7\x6a\xad\x07\x13\x0b\x8a\x10\xbb\xb3\xba\xa6\x47\xc5\x1e\x54\x84\xf6\xc9\xfb\xa8\x27\xd3\xe9\xb7\x64\x34\x11\x9f\x60\xde\x2a\x46\x4f\x88\x5d\xbe\xee\x51\x9b\x2e\x59\x2c\x66\x7b\x68\xc1\x94\xf7\x0b\xb6\xec\x8d\x81\xc5\xcc\x2b\x98\xdf\x00\xc7\x01\xb3\xa7\x05\x8f\xa8\x9e\x54\x99\x2b\x25\xbb\x43\xb9\x27\x8a\x63\x39\xb6\xc2\x63\x57\xeb\xd0\x9a\x76\x52\xd9\x9c\x5a\xae\xcb\xe6\xe4\x3a\x9d\x9c\xcb\x66\xd3\x82\x3a\xa5\x95\x7b\x5c\x9d\x82\x2c\x03\x3d\x1a\x65\x10\x08\xa2\x12\xfb\x5f\x46\x5d\x49\xbc\xdc\x8c\x27\xec\x4b\x41\xc9\x0a\x24\x46\xf0\x07\x3b\x38\x0c\xc4\xa6\xe6\xa3\x40\x70\x44\xb6\x53\x9b\xe1\x43\x52\x71\x84\xf9\xce\x4f\x04\xbe\xa0\x10\xa1\x82\x1c\x93\x11\xec\x61\xa3\x0e\xf5\x9d\x3f\x16\xf2\x07\x73\xe7\x30\xcc\xa2\xc3\x27\x3a\x5a\x3a\x82\xda\x59\x13\x9a\xa8\x95\xfb\x7b\x7c\xb9\xb5\x7a\xeb\xe0\x85\x31\x3d\xd3\x8b\x6d\xdd\xa5\x21\x8a\x20\xed\xec\xb9\x2f\xbe\x7a\x60\xe6\xca\x8e\xf3\x3f\x7d\xff\x68\x55\xdb\x17\xb2\xab\x46\x0d\x6a\xd5\xb5\x14\x08\x36\xd2\xfa\x68\x4b\xbf\x89\xf3\xf3\x26\x2d\xe9\x73\xee\xcc\x1b\xfb\x07\x24\x83\x4b\xa3\x06\xae\x03\x21\x65\x03\xff\x6c\xbb\x74\x7f\x30\x28\x81\xe7\x3e\xce\xcb\xec\x96\x63\x55\x5a\xde\x0a\xda\x5a\xbd\xfe\x72\x94\x6e\x55\xd5\xf8\x7d\xe3\x0a\xf5\x3a\x47\x76\x42\x5f\xb3\x3d\xa4\x6f\xb1\xc5\x1a\xa4\xb3\x87\x84\x85\x4c\x1c\x56\xb1\xb0\xbb\x4a\x99\xd4\x75\x32\xb2\x89\x44\x88\x8f\xfd\xb9\x03\x54\x09\x35\xee\x58\x5e\x57\x9c\x2e\x10\xea\x49\x94\x11\xb4\xa1\xe8\xa0\x36\x9d\x44\x79\xb2\x20\xbd\xb9\x53\x9e\x4c\xaf\x97\xe5\x75\x62\x8b\xcd\xc5\x39\x7c\x8e\x76\x71\x48\x68\x78\xb1\x27\x54\x69\x02\x62\xc6\x64\x76\x99\x91\xbd\x60\x26\x8e\x58\x70\x90\xea\x53\xa4\xc7\x2e\x3f\x0b\xd6\xec\x63\xae\x9a\x08\x2e\x9e\xb7\x46\xc2\x13\x72\xe4\x94\x91\xd2\xbc\x4f\xf1\x8f\x1c\xc6\xc9\x8a\xff\xc6\x63\x1f\x8b\x45\xbd\x36\xed\xdc\x3a\xc5\xb5\x6e\x5d\xf0\xe9\x7d\x25\xc5\x7d\x67\x9b\xb6\x77\xfe\x74\xda\xd6\x21\x2d\xb9\x3b\xbf\x62\x44\xf1\x72\x37\x18\x36\x2b\x63\xc8\xa1\x63\x55\x83\x9d\x0b\xb2\x07\xf5\xed\xd9\xaa\x73\x09\xe2\x2f\x93\x63\xe9\x3c\x60\x42\x87\x51\x73\x6f\xf7\x9b\x52\x60\x30\x38\xfb\x14\xf6\xe8\xbd\x74\xe8\x90\x36\x1d\xbb\xe4\xeb\x6e\xc4\x03\x4f\x33\x7b\xdf\x35\x4e\xef\xd5\xb5\xa6\xbb\x88\x96\x4c\xeb\xd7\x63\x7a\xaf\xb6\xc1\xea\xf0\xec\xb8\x01\xa1\xe1\xa1\xbd\x7b\x58\x43\x4d\xa9\x16\x87\x65\x06\xb6\x35\xb7\xfa\xf0\x2a\x2d\x38\x13\x3c\xc4\x1f\x4c\x65\x50\x0a\xff\x01\xaf\x32\x2c\x81\x26\x61\x53\xfc\x9e\xdc\xb3\x50\x95\x0b\xc6\x66\x87\x0a\x54\x3b\x95\x9c\xc6\xd1\xce\xbd\x63\xcb\x0e\xe7\x82\x57\xc3\x09\x58\xe5\x7f\x6e\x60\xb0\xca\x98\x61\x57\x4e\x60\xb0\xca\xe5\xcb\x3b\x5a\x31\x58\xe5\xb5\x7a\x0c\x56\xf9\x2b\xfc\x1e\x4e\xf4\xe1\xd7\xa1\xf1\xc5\x6b\xdb\x84\xe9\x08\x62\xd5\x4a\x69\x08\x65\x94\x19\x09\x18\x4a\xc0\x6e\x27\x41\x11\x3e\x28\x14\x01\x4b\xa0\x50\xe8\x34\xf4\xbb\x8e\x1c\x48\xd1\x39\x75\x87\xc2\xa7\xd7\x4d\x4b\x86\xff\xf7\x43\xd1\x8e\xa2\xe1\xe3\x53\x05\xfb\x05\xc6\xb4\xd4\x73\x3b\xa6\xd0\x5b\xea\xe9\x09\xde\x35\x4f\xbe\xe4\x81\x50\x3a\xef\xbc\x4c\x6f\xf3\x66\x8c\x19\x1c\x0b\x98\x4b\x14\xf5\x2c\x2e\x6e\x28\x95\x88\xac\xcc\x60\x1b\x32\x79\x63\x43\xca\x3d\xb6\x58\x5b\x2c\x25\x12\x45\x12\x24\x5c\xcd\x73\x48\xb8\x78\xce\xc4\xfd\x23\x10\x2e\x66\x0f\x72\x1e\x48\xba\x9b\x20\x22\x25\x23\x3d\x4d\xe5\xb0\x31\x24\x45\xd1\x0a\xc0\x5f\x37\xaf\x0d\x7d\xf9\x8f\xcd\x04\x16\x17\xee\x7a\xb8\xea\xf5\xcc\x24\x47\x9b\xf2\x5e\xbd\x52\x3a\xb7\xd3\xd3\x59\x71\xd1\x86\x6f\xe1\x4f\x55\x79\xed\x92\x07\xa4\x67\x97\xe8\xbe\xbb\xbb\x13\xcc\x06\xa2\x05\x7e\x98\x5c\xd0\x00\xaf\xdf\xb9\x2d\x8f\x4b\x8b\x0b\x9a\xb2\x4d\x32\xb5\x2f\x68\x05\xc7\x18\xc3\xc2\x23\x6d\xb8\x1f\xbe\x33\x82\x16\xfd\x40\xf6\x5b\x9c\xca\xed\xb1\xc5\xd9\xe2\x50\x3f\xa2\xdc\x1e\x64\x3a\x1b\x9e\x3b\x36\x7b\xa6\x1f\x19\x9a\x00\x48\x14\x83\x88\xd7\x37\xf7\x85\xf4\x03\x8b\x18\xdc\x11\x2b\x0d\x7e\x7f\xed\x2d\x4d\x06\x70\x7e\x7b\xed\x62\xcf\x5d\xdf\x5c\xc8\xef\x20\x7b\xf0\xe2\xd1\x56\xdd\x33\x52\xdd\x05\x1d\x40\xbc\xab\xbd\xb8\xb2\x1a\x7a\xcb\x5d\xed\x52\x3a\x75\x28\xd4\x5d\x39\x5f\x54\x01\x8c\xc0\x74\xfa\xec\x62\x78\xe7\x83\x51\x74\x96\x23\xbf\x10\x36\xd6\x9f\xb4\xd9\x63\xec\xa1\xb6\x36\x49\x35\x33\xe1\x35\xab\x3d\xda\x8e\xe6\xc2\x7e\x34\x27\x5f\xe7\x8a\x90\x59\x61\x74\xc9\x64\x88\xe7\x32\x46\x00\x70\x44\x24\x49\xc2\xe1\x01\x98\xd1\x1c\x34\x18\x73\x01\xc8\x69\x76\xcd\x84\xf4\x90\x1b\xbf\x5d\x59\x2b\x35\xb4\x2a\x03\x45\x69\x4b\x3b\xb6\xe9\x17\x37\xc5\xde\xca\x92\x1e\xce\xe5\x37\x4e\xcf\xfb\x60\xd8\x55\xfa\x58\x65\xff\xb8\xb4\xf1\x09\x99\x05\xbe\x1c\x64\xd4\x4e\x34\xe2\x95\x0e\x57\xbf\x57\x49\x65\x18\xcc\x4f\xd0\x23\xb0\x51\x93\xab\xc9\xf2\x01\x6a\x90\xb7\x03\xbe\xcd\x0c\x6d\x0e\x60\x87\x06\xde\x0d\x87\x3d\x38\xf5\xda\x50\xa5\x6c\x54\x63\xda\x72\xb6\x3b\xff\xf6\xc6\xf7\x91\x7a\x70\x8d\x99\xfb\x88\x96\x54\x96\xa3\x31\x21\xfd\x11\x6c\x23\x38\x1e\x36\x9c\x43\x6f\xb4\xcc\xd1\x9b\xa5\x2e\xa9\xba\xdc\x23\x7d\xb6\x6b\x58\x2c\x7d\xc6\x97\x9a\x6e\xee\x63\x7a\x73\x17\x99\x16\xf5\xa7\x71\x77\xaf\xaf\x95\xa9\x13\xfb\x83\xa2\x41\x3b\x02\x14\xad\x7f\xb6\x2a\x35\xee\x7c\x97\x5b\xb8\xf3\x37\x78\xea\xc0\xd4\x40\x99\x6a\x44\x1b\xe1\x01\xf7\x12\x85\x61\x0c\xed\x98\x36\x35\xe1\x43\x90\x75\x8e\x21\x84\x72\x35\xb3\xc3\x4f\xd7\x3f\x73\x25\x14\x60\xb6\x44\xb5\x20\xee\x39\x16\xbd\x31\x54\x2c\x61\xc7\x36\xa6\x2d\x2e\x84\x5f\x70\x3c\x75\xe4\xdf\x67\x59\xd6\x61\x52\x1a\xe1\xd9\xe0\x66\x0a\x49\x35\x0c\x58\xca\xa5\x70\xa5\xb8\x46\x03\xd5\x8a\x44\x61\xc8\x0c\x12\xa5\xc5\x31\x10\xc7\x4d\x72\x15\x1e\xca\x6c\x88\x1d\xe8\x31\xb4\xf0\xb4\x78\xf7\x94\x14\xe8\xf3\x6f\x2c\x11\x30\x74\x24\xdf\xb4\x2a\x1e\x48\x44\xa5\x69\xce\x6b\xe3\xb3\x82\xd2\x35\x34\x9d\x1a\x1e\x1c\x62\x0f\xcb\xcd\xef\x96\x53\x67\x04\x91\x3b\x60\xdb\x11\x7b\x0a\xc7\xdc\x5f\x3f\x72\xc0\xe8\x8f\xd7\x0d\x1f\xb6\x31\x32\xb2\xcf\xca\x0e\x11\x8e\xb2\x55\x1d\x60\xa9\x74\xb1\x20\x76\x50\x2d\x9b\xd6\xf8\x13\xa3\x79\x7a\xf5\xf7\x93\xdc\x5e\x78\x1e\x26\x7a\x4f\x9d\x00\xed\xc0\xf5\x3f\xf7\x1d\x98\xd0\xff\x1b\x38\x14\x3e\x9a\x5c\xfe\x10\xec\xe4\xfb\x01\x70\x3f\xd0\x7c\x93\x52\x41\x54\x2c\x95\xe4\x32\x45\xb0\x91\x0e\x65\x88\xd5\x64\x75\x7b\x4c\x21\x12\x65\xb1\x47\xa2\x62\x0d\xc5\xcd\x09\x70\x81\x00\x43\x1e\x20\x8b\x64\x7d\xa8\x49\xa2\x33\xe3\x8f\x76\xc1\xd9\x4c\xda\xbf\x75\x92\x9e\x59\xf9\xe6\x9c\xdb\x95\xaf\xcf\x79\xaf\x36\x3a\xb6\x78\x52\x46\x54\xd4\xcc\x05\x21\xff\xd0\x37\x86\xfb\x1e\x2e\x3f\x0b\x4a\x1f\x82\xca\x53\xf0\xed\x41\x45\xfb\xe1\xcd\xdb\x43\x7b\x80\x41\x8d\x4b\x9e\xef\x1d\xc1\x0d\x69\xda\xc1\x6e\xe1\x76\x13\x1c\x17\x64\xd3\xda\x2c\xc1\xca\xe0\x72\x8f\x5e\xa3\x64\xe2\xa2\x23\x19\x24\x21\xc5\x02\x86\x8f\xb7\xf2\xc1\xb8\x04\x8c\x46\x15\xc5\x83\x98\x45\x11\x04\x8f\x0c\x7e\xd1\x5a\x81\xd0\x97\xfc\x1b\x45\x90\xa2\x48\xad\x1d\x63\x0e\xd0\xb0\x5b\xe0\xaf\x3f\x59\x07\xa6\xa5\x77\x51\x4c\x9a\x0b\x94\xbf\x84\x0e\x70\x3a\x3b\x29\x6b\x66\x5d\xf7\x84\x96\x25\x25\x17\xaa\x4b\x67\xb6\xf7\xe4\x0f\x4a\x2a\x50\x97\xcc\xee\xc4\x4c\x80\xc7\x61\x74\x61\xab\xcc\x8c\xf8\x88\x5f\x2e\x01\x0f\x78\xaf\x5d\x6c\x6a\x6a\x6c\xe4\x2f\x6f\xfd\x27\x3f\x2a\x31\x31\x2a\xed\x5d\xf8\x68\xf5\xb7\x5d\x7a\x24\x46\xa6\xdc\x04\xd1\xfc\x7e\x42\x4c\xd3\x6a\x76\x0f\x7b\x04\xcd\xf9\x18\xdc\x0f\xab\x39\x48\x1b\xe4\x46\x6a\x4f\x6b\x88\x08\x8b\x62\xb0\x84\xe4\x70\x7a\xd9\xdf\xfb\xa1\x55\x51\x11\x3e\x11\xae\xf7\x75\x09\xf5\x28\x43\xc7\x97\xe6\x34\x86\xab\xf9\xfe\x44\x09\xe8\x18\x60\xa6\x9a\x5c\x43\x9c\x6d\xa5\x7b\xb7\xc1\xaf\x61\x48\x89\xb3\xc2\xbc\x7d\xdf\x6b\x5b\x43\x7a\xa7\xa7\xe5\x48\x40\x7b\xf4\x4b\xda\x10\x53\xdd\x6e\xb0\x02\xc4\x83\x49\x96\x21\x19\xf1\x9a\x86\xa3\xf0\x5d\xb8\x3c\x34\x3e\xa3\x42\xf5\xfe\xab\x7f\xd8\x92\xda\x64\x27\xe4\x83\xc7\x3f\x85\x25\x64\x0f\x73\xc0\x07\x24\xde\xad\xe9\x07\xae\x40\x78\x97\x4a\xa5\x72\x91\x1d\xd4\xc6\x65\x29\x71\xb9\x3a\xe7\x76\xce\x2d\xe8\xd6\x5a\xef\x4a\x0e\xd1\x23\x6d\xc5\xe8\x63\xc3\x15\xe1\xe5\x1e\x89\x22\xb0\xdb\xc5\xeb\x6f\xb4\x7e\xdf\x4e\x24\x1b\x8a\x7c\xfe\x3f\x1f\x03\xa1\x92\x00\xff\x26\x97\x2a\xb8\x65\x8d\x17\x1f\xc2\x0b\x9f\xe5\xe2\x3b\xe7\x10\x22\x5b\x9f\xaf\x49\xc9\x91\x91\x6c\x51\x8c\x07\xdd\xc6\x2c\x8f\x2c\x4c\x1e\x37\x75\xd3\xd3\xda\xda\xbc\x31\xb5\x73\x97\xaf\x78\xb8\x2c\xb9\x6d\x70\x4f\x71\x92\x36\x75\x60\x8f\xec\xee\x1d\xb2\xa6\xb6\x52\xf7\xc9\x1e\x74\x7c\x74\x4c\x94\x36\x4b\x2f\x32\x2a\x34\xc1\xc9\xa3\x86\xa8\xba\x9b\xe9\xb8\xce\xf3\x3b\x17\x0d\xcf\xe8\x3f\x27\x7a\x6e\xc6\xbd\x45\x6d\x27\xf5\x28\x9a\xd6\x8e\x2b\xb5\x84\xfd\xd0\x00\x7f\x83\x61\xb0\xa9\xb2\xf2\xf1\x17\x00\x80\xdb\x80\x0e\xb3\xac\x33\xda\x56\xfe\x17\x9e\xe9\xb5\xbb\xbe\x67\xc7\x82\x5e\x7f\x82\x2d\x9f\x4d\x5b\x19\x1a\x44\xbb\xa6\x25\xc5\x44\xb7\xa9\xe8\xb4\x72\x4e\x6a\x56\xdb\xa4\xca\xaa\xba\x33\x49\xd9\x59\xc9\x98\x67\x32\xc4\x33\x81\x60\x1d\xf2\x18\x92\xa8\x0e\x78\xbf\xa6\x43\x72\x72\xeb\xf8\xd6\x49\x49\xad\xe3\x19\x03\x32\xeb\x42\xe5\x3d\x90\x75\xc8\x1a\x54\x61\x21\x4a\x0c\x72\xac\x34\xb4\xdc\x25\xe4\x0f\xcc\xf8\xa2\x59\x3c\xdf\xfc\x35\xaf\x5a\xec\x0e\x6a\xc2\x9d\x42\x9c\x58\xd8\xcc\x2f\xe6\x7f\x31\x8a\xa5\x86\x8c\xb7\x9c\x7a\x6d\xc2\x07\x4b\x57\xf6\xaa\x5e\x31\x7d\xde\x22\xa0\x3a\x6f\xb9\x78\x66\x56\xeb\xb9\xd1\xc6\xd1\xd9\x3d\xe7\x14\xbc\xc0\xf3\x66\xa8\x12\xf1\x26\xb6\x99\x37\x59\xf7\x16\x22\xde\x14\x4f\x71\xd1\xaf\xcd\xae\xa9\x7d\xff\xea\x5d\x78\xfe\xe5\x92\x92\x57\x8f\x3f\x02\x3d\xcf\xd5\xc2\xdb\xf0\x83\x07\xad\xe3\x5b\x65\x2f\x03\x2c\xf3\x2a\xe1\xc6\xe0\x02\x3f\x37\x76\x9d\x4a\xca\x6e\x9d\xc8\xef\xef\x66\x23\x7e\x58\x04\xdf\xa9\x22\x59\x15\x89\xb5\x7e\x42\x1f\x02\x23\xf0\x0e\x6d\x9b\xe6\x7c\x0a\xb2\xff\xc8\xcd\xd5\x44\xb2\x6a\xdf\x3d\x9d\xf8\x33\x0f\x5b\xf3\x99\xc7\x24\xd8\xcb\x87\x9d\x83\x74\x86\x52\xc9\xf1\x7a\x9a\x65\x39\x17\x47\x95\x7b\x38\xad\x4f\x67\xdc\xce\x0d\x00\xb6\x44\x60\xa8\x1c\x6d\x24\x4d\xd0\x84\xfc\x7b\x5b\xb4\x5e\x45\x77\x6c\x97\x34\xfe\x82\xfb\xf0\xe9\xbd\x20\xfb\x63\x50\x84\x21\x74\x86\xad\x79\xaf\x6a\xb1\xd2\x7b\x01\x6c\xd5\x03\xfa\x0b\xa0\x01\x2f\xdc\x86\xc7\xda\x8d\x9f\xbf\x13\x9e\xfe\x16\x6e\x26\xed\xbf\x88\xec\xc5\x52\xb6\x2b\x92\xa4\x18\xdf\x5c\x06\x44\x22\x15\xb6\x6c\x80\x9e\xa4\x4d\x86\xf8\x8e\x92\x9a\xd1\x62\xb4\x3e\xec\x1e\xff\x79\x8b\x4d\xcd\x83\xf7\x80\x25\xc5\x75\xfb\x96\x03\xeb\xeb\xfb\x4f\xbd\xd6\x77\x24\x9c\x3e\x75\x62\x9b\x14\x0c\x5e\xb4\x43\xfe\xe1\x99\x8f\x40\xfa\x91\x43\x1b\x15\x0a\xf7\x30\xef\xf7\x2f\x6c\xd0\x78\xaf\xa0\x76\x27\x34\x7d\xce\xbe\xc4\xdd\x43\x56\xa0\xc1\x25\x53\xaa\xe8\xff\xc7\xdc\x7f\xc7\x45\x75\x74\x7f\xe0\xf8\x9d\xb9\x77\x3b\x5b\xd8\x0a\x2c\x2c\x2c\x2b\x02\x4a\x5f\x60\x05\x14\x56\x05\xbb\x34\x1b\x6b\x01\x54\xc4\x8e\x0d\xc5\x86\x48\xec\xdd\xa8\xb1\xb7\xd8\x63\xd4\x58\x10\x41\xa3\x46\x63\x4c\x6c\x29\x9a\xc4\x44\x93\xc7\x34\x13\x93\x27\xc5\x94\x27\x4d\x77\xf8\xcd\xcc\xbd\xbb\x2c\x6a\x9e\xe7\xf3\xfa\x7d\xbf\x7f\x7c\x63\x84\x45\x76\xef\x9c\x73\xe6\xcc\x99\x33\x67\xce\x79\x1f\xa0\xf0\x13\x8b\xa4\x52\xad\x94\x89\x17\x40\x54\x24\x11\xac\x48\x42\xd2\x8e\x23\x1c\x22\xfa\xd7\xce\x72\x07\xba\xa2\x63\xf3\x41\x61\x57\x74\xe4\xe3\x17\x7f\x40\x0d\x5d\x41\xf7\x79\xe8\x44\x57\x90\xf7\xc1\x8e\x07\xec\xf3\x1b\x8b\xd1\xbf\x4b\x36\x96\xa2\x14\xf0\xeb\x90\x8d\xc5\xc0\x50\xbc\xa9\x04\xbc\x8e\x0c\x7c\xac\x2e\x86\x9b\x05\x65\xa2\xfb\xd8\x56\xa9\xea\x80\x42\xa1\x11\x79\xfb\x83\x59\x85\x13\x5b\xaa\xdd\x4a\x4f\x19\xf8\x7c\x07\x26\xa3\x7d\x8a\xc8\x34\x6b\x9b\xd4\xfe\x4e\x30\x48\x11\xd9\xce\x1a\x93\x32\x50\xc4\xa6\xa6\x84\xd8\x63\xda\xf5\x4c\x4d\x0d\x4e\x8a\xca\xe8\xcd\x3f\xb7\x13\x77\x0d\xdc\x11\x5d\xc0\x5e\xa0\xb6\x5e\xe1\xe7\xc7\x69\xe7\x32\xb4\xdd\x2b\xff\x6c\x21\x53\x8a\xdc\xcf\x38\x68\x7a\x2c\x29\xfe\x95\x80\xe9\xa2\xfe\xd6\xee\x6d\xf3\xc6\x26\x94\x07\x8f\x4e\x2e\x8e\x1b\x9b\xb3\x5b\xc6\x5d\x0b\x0e\xea\xdb\xda\xd4\x36\x64\x55\x98\x3e\x6e\x7f\xab\xb6\x64\x6e\xe2\xb8\xee\x20\x48\x74\x9d\x74\xcc\x3d\x01\x21\x6d\xba\xce\xf7\xb4\xb5\x09\xf8\xe5\xc9\xa9\x0e\x10\x14\xe1\xe2\xda\x56\x59\x44\x36\xd1\xf5\xd3\x46\x53\xef\xbc\xcc\x6e\xa6\xa4\x3a\xde\x2f\x33\xe2\xcf\x07\xfe\xd7\x9e\xb8\x81\xc1\xea\xc4\x84\xaa\xa1\x7a\x57\x2b\xd1\xf5\x35\x3d\xc7\xa5\x8f\x1a\x7a\x1a\xef\xae\x15\xa2\x0c\xf8\x25\x5e\xeb\x3a\xd2\x2d\x5b\x39\x97\x91\x7b\xfb\xcf\x36\x2f\x43\x7a\x9d\x4b\x96\x21\xbc\x3a\xf2\x44\xbf\x61\xf3\xba\x4e\xdd\x16\x57\xdb\x01\x70\x7b\x3b\x55\x4f\x18\xbe\xaf\x48\x94\x99\xea\xe0\x0d\x48\xdb\x2c\x6c\x40\xa4\x8f\x23\xd0\x41\xf6\xae\xe8\x14\xa6\x45\xc7\xe3\x5a\x32\x19\x4c\x0e\x93\xc7\x8c\x72\xa6\x74\xb1\x59\x7a\x66\x76\x0e\xeb\xd6\x2d\xa2\x77\x92\x5a\xee\xf0\x4b\x4e\xf6\x4f\x8b\x12\x31\xb1\xfa\x40\xd8\xa6\x8d\x24\xbe\x67\xe7\xde\x8e\xb4\xd8\xc0\xf8\xf8\xc0\xd8\x34\x47\xef\xce\x3d\xa5\xe6\x8e\xed\x8d\x66\x4c\x52\xbc\x6f\xa7\xcc\xe6\x3e\x96\xde\xbe\x96\x3e\xbd\x2d\xa9\xc5\xb1\x85\x1b\x6c\xd8\x07\x37\xe8\xbc\xaf\xc0\x7f\x7d\xc5\x3e\xe3\xdf\x22\xbc\xaf\xe0\xe3\xc9\x93\x47\x7e\xfc\xb1\x3f\xfd\xfa\x78\x05\xfd\x06\x63\xe9\xb7\xbf\x17\xd0\x6f\xf7\xf8\x7f\x7b\x9e\x7e\x73\x07\xd2\x6f\xec\xa5\x17\x5e\x20\xad\xab\xc4\xf4\x1b\xfc\x91\x7e\xfb\xfb\x6b\xfa\x8d\x6b\xed\xfb\xbb\xc7\x9f\xd1\x6f\xbf\xd1\xaf\x64\x3e\xa5\x8f\xc7\xa2\x5a\x76\x87\xe8\x9b\xa7\x64\x38\xcc\x99\x2c\x95\x39\x3b\xc7\xc6\xc7\x47\x05\xe2\xdd\xcb\x16\x11\x61\xc9\xeb\xed\x48\x4f\x4a\x97\xfb\xcb\x3a\xe7\x44\x99\x83\x2d\x69\xbd\xd3\x7b\xf8\xfb\xf7\x48\xef\x9d\x66\x09\x36\x47\xe5\x74\x96\xf9\x89\xd4\x22\x7e\xa5\xc5\x3f\xd1\x6b\x54\x73\xd9\xf3\xd5\xf3\x97\xd6\x21\x08\x91\x1e\x5b\x8a\x3f\xed\xf8\x2f\x36\xd8\x0d\xd4\xe3\x48\x31\xda\x53\xec\x11\x44\x17\x0c\xad\x6d\x06\x1b\x4b\x72\x1a\x25\xad\x23\x25\x91\x00\x6b\x0a\x76\xa7\x4c\x0e\x13\x4b\xf4\x0d\x1f\xf4\x23\x1d\x04\x9a\x81\x40\x98\x98\x24\x39\x41\xc1\x65\x9d\x7a\xd2\x2f\xee\x31\x33\xb3\x87\x44\x17\x15\x6c\xe1\x0e\x09\x2f\x3a\xf4\x4f\x88\x97\x77\x55\xa7\xa5\x54\x3c\xce\xc1\x2f\x65\x5d\xf0\xcb\x09\x7e\xfd\x13\xfb\x24\x76\x1d\x97\x9e\x52\xc1\xde\xea\x9f\xd0\x37\xb1\x6b\x45\x5a\xca\xf8\x0c\xfa\x89\xfc\xad\xdc\xbf\x84\x17\xee\x60\xfa\xcc\x64\xfa\x15\xfd\x31\x00\xbf\xb1\xcb\xf8\x76\xf8\x33\x12\xfa\x99\xf1\xe4\x99\x99\xfc\xe3\xc9\x93\x16\xf7\x4f\x8c\x23\x23\xa5\x8e\xa7\xf7\x36\xa8\x9c\xd4\xcf\x60\xff\xd8\x8a\xfd\x19\x43\xa8\x69\x6e\xb0\xd6\x29\xd2\x30\x62\xc0\x2a\x15\x78\x02\x84\x8e\x1e\x4c\x80\xe6\x32\x1f\x9a\x0d\x12\x8e\x18\x9e\x62\x1d\x96\x94\xeb\x90\x64\x44\x19\x20\x99\x19\x0e\xbb\x84\xdf\xfd\xed\xb0\xb9\x80\xe7\xab\x9d\xe8\xe6\xa1\x3b\xe3\x0e\x9a\x23\xdd\xc1\xe0\x97\xb1\xcb\x7a\x72\x7b\x60\xdf\xc1\xa3\xc7\xea\xf7\x64\x78\x6a\x7a\x1e\x8d\x72\x37\x82\xcd\xec\xb8\x79\xb3\x1e\xad\x17\xed\x8d\x75\xf5\x4e\x0c\x71\xb6\xeb\xd6\x1b\x3d\xc6\x34\xe6\xa3\x2b\xdc\x7a\xd1\x43\xde\x87\x77\x1a\x43\x4c\x73\xcd\x5a\x27\xab\x52\xe0\x93\xbe\xc6\x20\x53\x28\xf0\x41\x43\x61\x10\x88\xcc\xf2\x12\x49\xdb\xf3\xb5\x24\x11\x7f\x8b\xa0\xa7\x54\x3b\x05\xc7\xb5\x43\xf0\xee\x14\x7d\x0c\xdc\xfa\xc6\x89\x23\xe8\xcb\x43\x57\x66\x08\x29\x94\xe0\xcd\x0d\x3b\xc5\x7b\xd8\x03\xe7\x93\xf6\x74\x27\xe9\x94\xc5\xa7\xd8\x11\x8f\x47\xa2\x28\xe0\xf0\xa4\x54\x4e\x9b\x5e\xd3\x2a\x22\x6e\xd3\x9b\xe8\xb5\x67\xdc\x7d\xa9\x25\x52\x49\xa9\xcb\x4f\x2a\x15\xc9\x35\xa6\x12\x97\x46\x23\x92\xb3\xa2\x00\x52\xf6\xf6\x4f\x77\x5f\xbe\xf7\x5e\x76\x89\x4d\x62\x25\x87\x0b\xfe\xee\x8b\x9b\x2b\xdc\x7b\x6d\x0f\xde\x1e\x75\x3e\xea\xcd\xe0\x37\xdb\x90\xcb\xb0\x4b\xde\x9b\x2f\xf0\x1e\xb9\xf7\xba\xbf\xf6\xc6\x8d\xb5\x1f\xee\x39\x23\x5c\x7c\xf1\xb8\x23\x22\x6c\x07\xb5\x3c\x4d\x62\x7f\xad\x7f\x81\x8b\xd5\x6a\xd5\x80\xde\xac\x4b\xd4\x80\x51\xeb\x0a\x5c\x6a\xc3\x3f\xd1\xc4\x93\x22\x94\x1b\x50\xea\x74\x7c\xa9\x58\x5b\x00\x8a\x6d\x75\xb6\xaa\xa0\xaa\x31\xc0\xaf\xee\x54\xd3\x57\x28\xeb\xcb\x99\x41\x3d\x7e\xd9\xb0\x62\xd4\x94\x5f\x45\xba\xc6\xc6\x79\xee\xcf\xaa\x6a\x8e\xbf\xc5\xad\x9e\xf7\x68\x5c\xc5\xf4\xee\x39\xde\xfb\xc1\x53\x34\x17\x3e\x88\xc4\x5f\x75\x58\xb1\x44\x46\x18\xc8\xc9\x03\x02\x8d\xac\x42\xa7\x93\x2b\x14\x5a\x72\xa2\x95\x6b\x9b\xe1\x92\xf0\x4a\xd5\xd2\x14\x62\x0a\xe3\x41\x7a\x77\x62\x42\x48\x51\x12\x11\x0f\x2d\xbe\x20\x9d\x3c\x53\xb9\x53\x1b\x8a\xe7\x94\x2c\xdc\x87\xbe\x29\x3b\x0f\xc4\xe0\xfa\x3b\x9f\x5e\x42\x5f\xfe\x3e\x12\x55\xf5\xef\x5f\x93\xdb\x8e\x7d\xf4\xea\xa6\xb9\xa5\xcf\x75\x71\x23\x51\xce\xa1\xd3\x37\xdc\x3f\xc4\x4e\x1b\x3a\xae\x1f\xbd\x07\x10\x72\x17\xb1\x84\xe2\x98\x4c\x67\x38\x1b\x2d\x91\x32\x31\x7a\x9d\xae\x6d\x8c\x34\x5a\x24\x32\x99\x42\x49\x61\xbd\x5a\x0d\x45\x7e\xc1\xa2\xc8\x66\x08\x52\x7c\xd6\x16\xa2\x7e\x9e\xde\x9f\xd8\x41\xa1\xc4\x85\x47\xda\x48\x7c\x1b\x6b\x9a\x17\xba\xdf\x5f\x0f\xe9\x79\xcb\xe3\x16\x53\x8a\xb5\xec\xfa\xdc\xa9\x3d\x4b\xab\xfe\x48\x10\x69\x4a\x4e\xfe\x6d\x96\xbf\xa2\x15\x73\x5d\x5e\x99\x0d\x92\xc7\x16\xb8\x46\x0f\x5d\x34\xbc\xfd\xb8\x29\x03\xb2\x8a\xab\x7a\xc6\x75\xaa\x1d\x33\x70\x44\x6a\x83\x7c\x30\x0a\x14\xb1\x8b\x8b\xf4\x35\xa1\xa3\x4b\xd0\xd1\x4d\x68\x11\xf8\x6b\xdc\xe4\x7e\xc7\xd0\x5f\x03\x67\x54\xb6\xa9\x19\x34\xaa\x1f\xb0\xf2\xfb\xdf\x0c\x06\x88\x8a\xf0\x7a\xa6\x35\x5d\x12\xae\xc4\x05\x24\x2c\x51\xbc\xac\xcb\x42\x3b\x34\x22\x40\xae\x24\xa7\x6e\xb8\xbb\xed\x03\x2c\x2e\x51\x0e\x28\x43\xcc\xa3\x22\x51\x36\xff\xf9\x65\xe4\xee\x01\xeb\x8d\x84\xf4\x44\xe2\x18\x28\xc9\x77\x41\x35\xe3\x81\xf6\xa0\x05\xce\xf4\x56\x14\x64\xd5\xdd\x84\x13\x72\x77\x8f\x76\xef\xe2\xd2\xc1\x1a\xf7\x67\xf8\xb3\x9d\x84\xbe\x57\x4a\xe2\x57\xc9\x94\x8c\xb2\xd4\x25\xc6\x72\x56\x68\xf9\xaa\xd4\x96\x80\x04\x24\x3f\x8a\xe6\x7d\xf2\xb9\x9f\xb6\x92\x97\xa6\xd2\x7e\x58\x03\xc0\xc6\x10\x34\xaa\xf2\x7c\xe5\x4b\xf0\x5b\x38\x78\x2b\x72\xae\x75\x1f\x84\xfd\x29\x6d\x4b\x85\xfc\x7a\xfa\x7c\x31\x45\x18\x66\x15\x0a\xa5\xd4\xa0\x84\x04\x76\xe2\xc9\xe7\x93\x8c\x7b\xa2\xc2\x34\xbb\x81\xcf\xbc\x4f\xbb\x16\x74\xad\xac\xae\x6c\x66\xd0\xcc\xbe\x5c\xfa\x4a\x74\x67\xbe\x1b\x41\x38\x1f\x08\xbe\x43\x3a\xd6\x87\xcb\x98\xfe\x30\x72\xbe\x66\xc9\xb5\x35\xcb\x06\x87\x84\x84\x95\xb8\x42\x58\x95\x3c\x58\xee\x8f\xcf\x46\xc1\x04\x5c\x48\x00\x0e\xf1\xad\x8e\x10\xce\x44\xb4\x4f\x5f\xa4\xe7\xe8\xa3\xe1\xb3\x2b\x68\xc3\xaf\x57\xba\x6c\xed\xda\x70\x66\x17\xfa\xf0\x8d\x7d\xaf\x5a\xce\x04\x8c\x1a\x3e\xff\xb5\x89\x5f\x64\x2d\xea\xb3\xc2\xd3\x08\x8c\x9d\xdc\x3a\xea\xde\x1d\xf4\x3d\xea\xfd\xed\x82\x4d\x96\x92\x6e\x27\xc0\xb8\xfb\x20\x35\x3c\xd6\x1d\xed\xc1\x3a\x4c\x43\x03\xd8\xdf\x30\xff\x16\x72\x93\x1d\xec\x9f\xef\x0a\x0a\x0e\x36\x18\x8d\x81\xf9\x2e\xa3\x5a\xca\x19\x0c\xb4\x87\x60\xb0\x57\x49\x7d\xc8\x8b\xd0\xfb\x12\xd6\x5c\x65\x8d\x25\x44\xce\xa4\xec\x6f\xeb\xd1\x6f\x2f\x1e\x3b\xa9\x3d\xa9\x1e\x33\xe2\x95\xab\xeb\x6b\x2b\xc7\xe5\xe3\xe9\x1d\x6a\x46\x7d\x7a\xcf\xac\x3c\x7f\xef\x7c\x1d\xfa\x66\xcb\xf2\x55\xca\x01\xdd\x7e\xbc\x35\x6f\x53\x18\x1a\xce\xa5\x2f\x43\x95\xb6\xf7\x48\x5d\x2d\x1a\x45\xeb\x6a\x23\x98\x34\x67\xa8\x1a\x94\xba\xb4\xd6\xa1\x2e\x2e\x54\xad\x55\x6b\xe5\x96\x50\x67\xa8\xb9\xc4\x15\xaa\x35\x6a\xe4\x5e\xc0\x0d\xbb\xe0\xdc\x7b\xa0\x31\xdb\x36\xd7\x07\x3c\xab\xb0\xd6\x4e\xef\xfb\x68\x91\xc0\xe1\x69\xf2\x3e\x1c\x2d\xaf\x4d\x36\x54\x1c\xee\xae\xeb\xdd\x89\x94\xd7\x4e\xea\xc0\x97\xd7\x2e\xee\x5a\x51\x97\x27\x9e\x2d\xee\xa3\x9d\x06\x4b\x80\x91\x25\x45\xb6\x1d\x87\xf8\x16\xd9\x0e\x1b\x29\x14\xd9\xbe\xeb\x7e\x0b\x6c\x84\x33\x58\x3d\x4b\x2a\x6d\x41\xd3\x46\xcc\x43\x0c\x96\x6b\x04\xd3\x19\xeb\xbc\xc4\x8a\xad\x64\x2b\xa0\x26\x88\x4c\x4e\x83\x4b\x12\xa6\x56\xcb\x2d\x61\x61\xd8\x6a\x86\x19\x30\x23\x6a\x46\x6c\xf0\x32\x82\x37\x1c\xef\xbd\xad\xc7\x14\xf8\x72\xe3\xa9\x76\x00\x59\xe0\x49\x6e\x8e\x0e\x31\x65\xc8\x68\xc9\x43\x44\xcc\xa6\xe3\xe5\x71\x5d\x48\xc9\x43\xe2\xd8\x01\xaf\x1f\x47\x0f\x06\x25\x1e\xec\x39\x6a\x77\x5e\xc0\x26\xbf\x2e\xa6\x21\xe0\x33\x68\x96\x92\xb2\x07\x47\x31\xc8\xf9\x69\xdc\x60\x7f\x52\xf6\xe0\x3f\x64\xec\x4f\xa4\xea\x01\xd9\x48\xfe\x2a\x14\xc9\x82\x20\xa9\x7c\x00\x4c\x10\xd6\x61\x52\x33\x9c\xc2\xe4\x38\x5b\xd9\xf8\x9a\x61\x51\x74\x60\x88\x46\x13\x1d\x12\x2d\x2d\x75\x45\xeb\xf8\x9a\xe1\x44\x7b\x9c\x7d\xa8\x2b\x8e\x40\xb6\x5e\x6a\xc6\x2a\x7c\x46\x1d\x04\x75\x69\x3c\x6a\xf3\xac\x7a\x61\xfe\x66\x88\x93\x98\x68\x47\x66\x3e\x31\x1f\x3c\x80\xaf\xdf\x89\xaf\x8b\xd8\x5d\x7b\xe8\xfd\xc3\x75\x5d\x83\xbb\x9e\x7f\xbf\xa6\x92\x94\x0e\x0f\x03\xad\x6e\xbe\xfa\xe1\x89\x03\xb3\x56\xa3\x9f\x3e\x87\x9b\x56\x4e\xce\x0d\xea\xd3\xbf\xb0\xa0\x8f\x53\xb4\xab\xae\xf7\xaa\xda\x17\x17\x95\x95\xac\x5b\x52\xdd\xb7\xf4\x8f\x0e\x7b\x8e\xed\x59\xbc\xf0\x5c\xa4\x6e\xf9\xd8\xc3\xee\xe0\xce\x41\x9b\xf6\x86\x2f\xb2\x95\x0a\xb5\x1d\x98\xc7\x1c\x2e\x97\x49\x66\xba\x38\x23\xc2\x94\x7e\x04\x75\x86\x4b\x36\x04\x2a\x95\xc9\x81\xc9\xe2\x7c\x57\xb2\x31\x2e\xa1\x6d\x42\x81\xab\x6d\x70\xa0\x96\x74\x5a\x21\xe1\x6a\x9f\x80\xd8\x3f\x14\x7b\x18\xad\x3c\x67\xcf\xa8\xf5\xf0\x5c\x81\x99\x9a\x39\x4c\x89\x04\x3f\x5c\x7e\x43\x7f\xc0\x1f\x70\x9b\xd6\xbf\x76\x20\xe8\xcd\x8f\xee\xce\x79\x3e\x68\x7b\xd2\x8f\x17\x8f\x5e\x75\x6d\x2e\x04\xe3\x57\xbd\x71\x84\x5b\xf3\xfc\xc8\xdc\xa0\xfc\xdc\xc2\x9e\x90\x94\x80\xec\x99\x54\xda\x67\xc8\x92\x51\x25\x0b\xba\x76\xd7\x2f\x9e\xf9\xdc\x94\x5e\xb3\xf2\xa4\x50\x51\x33\x68\x41\x63\xc8\xc8\x2d\x3b\xad\xf3\xc3\x87\x4e\xe8\xcc\xd7\x2b\x63\x7d\x24\x18\x93\x46\x12\x61\x32\x6a\xa1\xbe\xc4\xe5\xaf\xc1\x87\x21\x95\x86\xdc\xe5\x6b\xb4\x22\x1e\xd0\xc1\x47\xfd\x78\x8c\x5b\x9f\x92\x65\xaa\x68\x80\x2f\xc7\xc8\x39\x3f\xf9\xcc\x71\x90\x7d\x0d\xcd\x27\x75\xcb\x96\x09\x78\x9d\xb4\x41\xb7\x2c\x93\x23\x9e\x28\x5e\xbe\x40\x97\xc5\x22\xbf\x20\xbe\xa9\x30\x60\x26\xa1\x51\xb4\x26\x84\xa7\xc3\x00\xf5\xf9\xcd\x74\x90\x9c\x19\x31\x9f\xfd\xf6\x2c\x3a\x52\x9f\x58\xbe\x2d\xcb\x42\xca\x0a\x6f\xe6\x62\xfd\x0e\xbf\x13\x3d\x35\xce\xb7\x32\x64\xa2\x1d\x25\x12\x7d\x06\x6e\x8d\x0e\xb5\xf6\xd6\x6e\x13\x59\x04\x92\x3a\x1e\xad\xda\x60\x82\x58\x7d\x39\xb5\x5e\x02\x45\x7a\x28\x12\x41\x3d\xeb\x1f\xa8\x95\x0b\x08\x17\x9e\x0e\xe5\xfe\x69\x49\xfc\x8a\x14\x84\x82\xc9\x48\x6d\x2e\xe6\xa6\x59\xee\xbc\x5c\x52\xdb\xf5\x9d\xd2\xa5\x7d\x27\x90\x73\x95\x17\x4e\xc5\xbf\xd0\x7f\xb2\xa6\x74\x6f\x9f\xc4\x8b\x46\x0b\x0e\xa3\x4d\x71\xbd\x9a\xab\xbb\x3b\xa0\xd3\x60\xa6\xc6\x2b\x1f\xa1\x66\x26\x80\x74\x2c\xd0\x1b\xa1\x11\xab\xa1\xbf\x04\x53\xa6\x23\x94\xe9\x58\x4d\x80\x41\x2e\x24\x08\x7a\x29\xb3\x27\x79\xd3\xc6\x04\xba\x84\xda\x19\x05\x10\xc8\xc2\x62\x4a\x8b\x70\x8e\x6e\xd7\xbd\x84\x17\x15\xa9\xa0\xc9\x1e\x9d\x15\x97\xc0\x4b\x4a\x0a\x7a\xa0\x2f\xdb\x8e\xe7\xc5\x45\x0a\x69\xd0\x6e\xd0\x49\x4a\x6a\x69\xbc\xb2\x0a\x22\x1d\xb8\xe4\x24\xdb\x0a\x40\x6c\x91\xc5\xd0\xa0\x0d\x92\x43\x39\xe4\xf4\x41\x5a\x25\xc7\x36\x77\xc3\xe3\x5b\x86\x09\xf9\x81\x5e\xf7\xd3\xb7\xf0\x9d\x9f\x39\xd1\x9e\xe0\x3d\xad\xce\xb7\x3a\x15\x7c\x2a\xc9\x47\x93\x48\x05\x3c\xd5\x22\xf6\xaf\xb5\x8d\x8d\x6b\x51\x93\x6f\x19\x3c\xaf\x45\x82\x8c\x44\xd7\x30\x4d\xc9\x4e\x33\x29\xd1\x20\xb4\xc8\x55\xfa\x20\x03\x21\xae\x00\x13\x07\x39\x95\x9a\x63\x7c\x30\xd2\x3c\x39\x76\x69\x4f\x50\xf5\x64\x99\xd1\xa0\x77\x83\xde\x0d\xae\x0b\xfe\x2c\xe8\xb3\x4a\xaf\x5e\x11\x61\xf1\x4a\x55\x3f\x6f\xcd\x9a\x79\xee\x83\x1e\xc5\x22\x92\xe2\x95\x8a\xe2\x93\x88\xda\xd3\xda\xfc\x28\xa7\x01\x12\x64\x0a\xb9\x16\xab\xb5\x9f\x56\x2b\x62\x19\x3d\xd9\xf6\x85\x4b\x9c\x66\x3a\x74\x56\x5f\x0d\xe2\x6b\x7f\x6c\xdb\xc0\x89\xc9\x07\xf7\x36\xcb\xe3\x7d\x74\x25\xa8\x2c\x70\xda\xf9\x07\xbf\x11\xe5\x51\xbf\xee\x23\x0e\x45\x20\x74\xef\xe0\x84\x9c\x43\xe2\xc7\xbc\x4e\x73\xf4\xc8\xf8\xd8\x2f\x57\x29\x74\x78\x7c\xa5\xce\x20\xc1\xae\x96\x80\x66\xfe\xd4\xf8\x49\xde\x5d\x44\x10\x80\xce\xba\x17\xdc\x1d\x1c\xd7\x79\x70\x9f\xd7\x5f\x45\xdf\x56\xc6\xfc\xf8\x56\xbd\x26\x27\x64\x70\xdd\x29\xf4\x31\x51\x94\x88\x92\x91\x78\x8b\x58\x18\xea\x3e\x0a\x7e\x16\xab\x90\x8d\x7d\x85\xf7\x21\x46\xd1\x9a\x7f\x35\x1e\x5b\xaf\x62\x48\x67\x5b\x89\x84\x91\x89\x58\x4e\xcb\x28\xbc\x87\x3d\x7e\x68\xba\xb0\x5b\x74\xb2\xa5\xd5\x14\x2c\x9c\xe1\xfe\x9d\xef\x63\x0b\xe5\x15\xe7\xbf\x59\x84\x0d\x4a\x73\x0f\xdb\x47\x83\x88\x19\xe1\x6b\x8c\xf0\x58\xb5\xb4\x7e\x03\xfb\x53\x52\x39\xf0\xc3\xe7\x0d\x00\x14\x2c\x00\x72\x56\xad\x56\x19\xe4\xa2\x02\x97\xdc\xe0\x33\x20\x5f\xa7\x4b\xc6\x6c\x2e\x75\x69\x51\xe0\xd4\x38\x03\x9b\x8d\xa5\xbe\x45\x4e\x7c\x01\x87\xa7\xd0\x89\xd4\xfc\x30\xa2\x31\x82\x0f\xaa\xe3\xb9\xe3\x64\x14\xd7\x40\xe6\xd7\x8c\x37\x6d\xf7\xa4\xf8\x35\xf3\x66\xc5\x2a\x06\x8f\xcf\x40\x51\x42\x87\xde\x8f\x2a\xc0\x71\xcb\xaf\x0f\x9a\x19\xdb\xfa\x68\x00\x7e\x7e\x04\x7e\x7e\x2a\xf5\x41\x63\x9c\x01\x40\xee\xe5\xc8\x8f\x55\xaa\xa5\x7e\x06\x16\x6f\x3f\xac\xda\x77\x10\x21\x63\x99\x8e\x60\xf5\x94\x6b\xbd\xec\x02\xc7\x5c\xe0\x8e\x19\xdd\x39\x55\x57\x8a\xf2\xbc\xdc\x2c\x7b\x5c\xe0\x61\x05\xfb\x25\xff\xc6\xfb\xdc\x0b\x98\x97\x70\xb2\x9e\x45\x81\x25\x2e\x56\x24\x62\x00\xb0\x92\x76\xa1\x6a\x86\x8f\x9a\x86\x52\x2c\x9d\x67\x78\xa4\xd8\xeb\x64\x9b\x93\x51\x59\x01\xf3\x83\xe2\x4e\xf3\xea\x6b\x65\x0d\x40\x0c\x87\x0f\x1a\x56\x3c\x76\xd2\xbc\x07\xdb\xbe\xd5\xef\x13\x27\x67\x64\xcf\x19\x10\x37\xd4\x62\x8f\x6d\xb7\x62\xcf\x03\x74\xff\x81\x28\x07\xc5\xe6\x5e\x68\x44\x1f\xa1\xd8\xdf\x80\xc5\x92\x3f\x60\xe6\xc7\x20\xe5\x8d\x1f\xd4\xc6\x36\xee\x68\xda\x21\xd4\x4b\x67\x31\x97\x81\xfd\xd2\xf4\x3a\x95\x82\x51\x50\xc0\x57\x95\x4b\x11\x2c\x32\xe5\x0b\x34\x93\x8e\x4f\x27\x5d\x40\x6d\x16\x4a\xfa\x3c\x74\x32\x5e\x5c\x32\x42\x90\x40\x6f\x33\xb9\x14\x25\x9b\xa7\xf5\x16\x1c\x3e\x7e\x40\xd9\xb4\x19\xbf\xdc\xe3\x29\xed\x33\xa3\xf3\x84\xfe\x83\x7b\xee\xa9\x43\xf7\xeb\xb8\x0c\xf7\x7b\xe9\x5b\x36\xa3\x63\xe8\x05\x9e\xca\x1f\x8f\x9c\xcd\x44\x35\xec\x8e\xc7\x43\xc9\xd9\xb3\x8f\x80\x6f\x15\x83\x4f\xa1\xf8\x2c\x2c\x32\x87\xc7\x96\xb8\x92\xc3\xc3\x25\x4a\xa5\x96\x54\xb4\xb7\x09\x94\x60\xe1\x42\x89\x0f\x6e\xb3\x97\xbe\x38\x72\xb8\xa3\x80\x69\x62\x01\xd9\x52\x48\xda\x80\x1e\xb4\x59\x01\x3d\x98\xe0\x78\xd3\xa8\x30\x5f\x3b\x61\xa2\x37\x1f\xdc\x8a\x81\x23\x3a\x0c\x68\x33\x6d\x17\x1a\xb4\x17\xb4\x3a\x3f\xb3\xc7\xe8\x84\xee\x53\x4e\x57\x2e\x7a\x21\xa2\x30\x31\x65\xd2\xd9\x29\xc3\x26\xec\x5a\x15\x9e\xd8\xb1\xc7\xb6\xd4\xd2\xac\xd0\xb0\x91\x53\x5b\x47\xb5\x0f\x0a\x71\x80\x1f\xb1\x95\xd9\xf9\x71\xea\xfc\xf0\x33\x68\x63\xc3\xd1\x3a\xff\x8c\x77\x2a\x0f\x81\xe4\xbd\xe7\xb6\x9e\x43\x0b\xa6\x69\x62\xd8\xa2\xda\xef\x66\x15\xed\x89\xaf\x02\x99\xdb\x07\x0d\xe7\xef\xa5\xc8\xdd\x7d\x3e\xd7\x8b\x69\xc3\x38\x98\xf4\x13\x5c\x8a\x35\x8e\x4c\x82\xc9\x95\x62\xb5\x8a\x95\x1a\xad\x12\x3b\x42\x4a\x4d\x54\xa0\x38\xb0\xc0\x05\xc5\x46\x1f\x46\x85\x4c\x4c\x21\xf5\x30\xc2\xe7\x6a\x22\xb5\x05\xab\x8e\xb8\xe6\x1e\x1a\x50\x62\xc2\x8c\xf2\xc7\x5a\x9e\x57\xae\x5d\xfe\xd8\x41\x3d\x8a\x66\x5f\xb8\xb5\xd2\xbd\xbb\x30\xc3\xd5\xba\x6d\xd1\xa6\x11\xcf\xcd\xe8\x62\x8d\x2c\xd9\x33\x6c\xc8\x98\x69\x93\xe2\x3b\xa5\x8f\x6c\x65\x69\xdb\x3d\x3e\xd0\x94\x3b\xd2\xe6\x88\x88\xf8\xe4\xad\x0b\xa0\x6b\x9d\xb9\x46\xbf\x06\xfd\xb0\x64\xdd\x16\x36\x71\xd7\x80\x45\xbf\xad\xda\xba\x64\x3d\xfa\x75\x04\x1b\x09\x3e\xeb\x92\x3f\xea\x74\xdf\x2e\x73\xc2\xbb\x92\x8e\xf1\x80\x99\x82\x75\x8c\xcc\x61\x04\xf1\x03\xb8\x50\x2e\x54\x12\x1c\x1c\x4e\x60\xc8\x55\x1a\x85\x66\xa8\x4b\x61\xc0\x8b\xbd\xd4\x25\x11\xee\x71\x2f\xf9\x4c\x23\xc9\x4f\x20\xd7\x88\xd6\x24\x9d\x09\x8a\x7c\x5c\xb8\x0e\x20\xf2\xc9\x1b\x05\x90\x01\x14\x37\xf7\xaf\x39\x8f\x7e\x84\x1b\x57\x4d\xe9\x15\xd4\xa7\x5f\x61\x01\x78\xfd\xea\x8b\xc0\x71\xaf\xf9\x76\x01\xaf\xd0\xcd\x20\xa8\x23\x3a\xdf\x76\xf0\xe6\xfd\xc4\x2b\x9d\x18\x6e\x51\x00\xf1\x77\xc0\x1f\x2c\xff\xc0\x73\xd7\x40\x68\x9e\x28\x60\xf5\x47\x33\xa9\xce\xe0\x48\x63\x58\x78\x48\x78\x81\x2b\x24\x58\x2f\xd5\x4b\x49\x8b\xfa\x82\x67\xb4\xa8\xa7\xd4\x7a\x91\x61\x9e\xdd\xa1\x1e\x2f\x5f\xa3\x8f\xaf\x9d\x92\x8c\x5d\xf4\xa7\x9a\xd5\xc7\xde\x5f\xcd\x3d\xbf\xa6\x3c\x37\x30\x3f\xaf\xb0\x07\xdb\x70\xf1\x99\x1d\xeb\xe7\x9f\x34\x58\x7a\xae\xdf\x8e\x5d\xcf\xd2\x71\x29\x5a\xc9\x6d\x4c\xf3\x35\xec\x7b\x86\xd0\xfc\x58\xab\x53\xc3\x89\x19\xa9\x4c\x4a\xcc\xa6\x18\x94\xb8\xc4\x5a\x1f\xdc\x1a\xde\x48\x0b\x06\x9a\x34\xa4\xcc\xbe\xb2\xbc\xe2\x58\xde\xa6\x07\x28\xc7\xc2\x25\x5b\xb0\x71\xf8\x83\xec\x03\x04\x94\x8b\xaf\x03\xc5\x7b\x41\x1d\xcd\x81\xc5\xcf\x95\xc8\x58\x05\xad\xf0\x52\xcb\xb8\x02\x97\xcc\xf0\xc4\x73\xa9\xa5\x14\x1e\xfd\x3d\xfb\x56\x30\x9a\xb6\xad\x72\xf4\xee\xbc\x05\x42\x59\xe8\x6d\x62\xf1\x49\x69\xe8\xd3\x7d\x81\x01\x73\x04\xcb\xfc\x21\xed\x5b\x67\x74\xca\xa5\xd0\x8f\x55\xab\xa0\x01\x04\xf3\x1d\xf4\x84\x56\x51\xfc\x29\x93\xc2\xcb\x00\xc8\xd4\xf5\xf9\xf9\xea\x02\x56\xa2\xd6\xe5\x1a\xc0\x96\x2b\xee\xe1\xa4\x36\x80\x4b\x77\xf7\xd2\x26\xee\x8c\x5e\xd7\x0a\xd6\xf3\x35\xba\x55\x78\x9c\x2e\x34\x7e\x85\xe9\x67\x25\x52\xd2\x42\x85\x84\xf8\x94\x72\x3e\xbc\xd2\x22\x51\x54\xb0\xf4\x0e\x2b\xc5\xaf\x61\x7b\x82\xf6\x16\x54\x36\xf9\xd5\xc9\xa8\xdc\x02\xd2\xd1\xaf\xa4\x75\xca\xbf\x6f\xc0\xcf\x36\x92\x4e\x29\x1b\xe1\x08\xf7\x36\x38\x9c\x8c\xd1\x45\xa0\x5d\x47\xc6\x50\x4b\xb5\x72\x35\x19\x08\x8b\x49\x6a\x10\x05\xfb\xf4\x74\x22\x6c\x44\x03\xcf\x18\x3c\x37\xc4\x3b\x81\x7d\x40\xa6\x19\x5d\x6c\x57\xd7\x0e\x5d\x34\x83\xcc\x9f\xaf\x11\xb6\x3a\xd9\x31\x57\x4b\xd1\xe7\x20\x74\xa9\xc0\xd5\xb2\xfe\xb0\x9e\xda\xed\x33\xc2\x5c\xab\x49\xed\x35\xc3\xca\x59\x19\x50\xb1\x7e\x5a\x89\x4c\xc6\x79\x33\xf5\xf9\x88\x2a\xb9\x9c\x92\xf1\xcc\xe0\x59\x91\x01\xfc\xbf\x1d\xee\x04\x47\x6f\xb8\xdf\x05\xe2\xc5\x78\xff\x4f\x41\x7f\xa1\xe0\x1b\x70\x04\xba\x7a\x83\xcd\x86\xc0\x3d\xdb\x7d\x8f\x9e\x26\x3a\xb8\x5f\x87\x17\xe0\x7c\x7e\x9f\xf8\x0f\xd6\x81\xf3\xd4\x1f\x88\x76\xea\x19\x56\x26\x66\xc5\x9c\x12\x9f\xae\x49\x18\x52\xc2\xf1\x00\xb2\xde\x53\xb5\x80\x1d\xc0\x8f\x45\x32\x13\xf8\xb3\x04\xcc\x47\x23\x2f\x42\x05\xfa\xf8\xcd\x3b\x60\xf6\x15\xa4\xfc\xb1\x0c\x7b\x04\x91\xe0\x55\x94\x0d\x63\xa0\x0a\x0d\x02\x7b\xdd\xbf\xa1\x7e\xb4\xa8\x93\xaf\xaf\x12\xb0\x7e\xa8\xbf\x03\x39\x25\x2b\x17\x4b\xc4\xd8\x2b\x60\xd5\x0a\x4e\x41\x40\x7f\xbc\xdd\xd3\xe8\x57\xa2\x7e\x14\xf6\x47\x40\xa0\x6b\x86\xfe\x69\x7a\x80\x90\x05\xbe\x6e\x41\xe8\x0a\x58\xec\x01\x00\xa2\x7d\xb8\xff\xa0\x10\x40\x78\xac\xfe\x98\xbf\xed\x94\x3f\x3c\x96\x42\x29\x56\xe3\x5d\x9a\xf4\xd3\x54\x4b\x39\x25\xd6\x73\xa5\xe1\xe9\xb1\x74\x9e\x41\xf8\xaa\x5e\xeb\x24\x58\x6f\x46\x4d\xdb\xc1\x25\x4f\x69\xef\x57\xa7\x50\x13\x97\xbe\xfc\xf1\x07\x9e\x5a\x55\xf6\x08\xe5\x6b\x3e\x1e\xeb\x6d\xea\xeb\xe3\xb9\xd3\xb0\x24\xcc\x2c\x0b\x08\x0a\x32\x94\xb8\x82\xb4\x3a\x19\xcb\x34\x0b\x32\x5e\x80\x1d\x6a\x09\xca\x1f\xe1\x71\xaf\xd8\x91\xbb\x0f\x64\xbc\xbd\x4a\x5e\x71\x6e\x8c\xb4\xff\x84\x29\x80\x5d\x71\xee\x9b\xe5\x13\x8e\xe5\x6f\x22\xf8\x43\x3b\xc6\xc5\xa6\x10\xfc\xa1\xc8\xb0\xec\xc1\x89\xf0\x43\x1f\xdf\xee\x65\x3c\xfe\x48\x5a\xc7\x45\xc7\xcf\x27\xc0\x64\x7a\x99\x3a\x90\x61\x8c\x05\x2e\xc6\x1b\x8d\xb7\x7b\xdc\x2c\xf1\xb3\x1a\x1f\x10\x02\xe0\x67\x83\xfe\xda\xb5\x66\xb8\x2c\xbf\x2e\x97\x1b\xd0\xa7\x5b\x43\x56\x59\x5d\xe3\x1a\xbc\xda\xc1\xcd\x41\x0b\x0a\x23\x62\xc0\x16\x54\x61\xd0\xb5\xcf\x0c\xd7\x42\x46\x28\xd6\xe5\xf9\x17\xf0\x96\x42\x98\xb6\xa4\x2a\x58\x2f\x2a\x71\x99\xf4\x06\x4e\x6f\x30\xe8\x39\xd6\x2f\x44\x1b\xe4\xc7\xc3\x2e\x79\x0e\x5e\xc2\xca\xa4\x69\xd1\x4f\xf7\xce\xf6\xc0\x30\x2d\x1b\x1f\x3f\x2b\xd6\xdf\x2b\x0d\x76\xe8\xac\x92\xf2\xd5\x02\x1a\x53\xa8\xe6\xb7\x6f\x7d\xe5\x01\x7e\x41\x46\xbf\x10\x1e\x94\x89\xaf\xb7\x26\xf2\x08\x26\x18\x25\x7a\x7f\xa3\x88\x74\x0b\x14\x89\x75\x22\xb1\x58\xa4\x63\x55\x8a\x60\xb5\x8a\xaa\x77\x0b\x82\x3c\xcd\x14\xec\x02\x09\xe4\x64\x4a\x08\xf4\x16\x61\x37\xe4\x72\x2f\x65\x4c\x4c\x9b\x32\xa8\xac\xee\x56\xdd\xa0\x31\xa3\xdb\x4c\x6c\x1d\x11\x4f\x84\x45\x6a\xb1\x0d\xba\x99\x20\x01\x7d\xa4\x0d\xe2\x0b\xb2\xa3\x02\xef\x5e\x16\xf1\x22\x13\xb0\xbd\xe6\x61\xf9\x98\x98\x20\xa7\x92\xd5\xd0\x58\xa6\xc1\xc8\xca\x0d\x5a\x01\x8d\xca\x27\x6a\xf9\x44\x31\x18\x5e\x6b\x3b\x77\xef\xea\xe8\x95\x42\xda\x96\x5d\x2b\xce\x01\xf1\x39\x76\xa4\xcd\xb4\x73\x7c\x4c\xb2\xfb\x3a\x0c\x23\x02\xd0\x86\xba\xdb\x88\x72\x84\xba\xae\xee\xb4\xc6\xaf\x27\xf5\x45\x2c\xd8\x17\xf9\x37\xde\xab\x5b\x31\xb1\x4c\x7b\xa7\xa5\x55\x2b\x83\x52\xc9\x1a\x82\xa5\xa4\x29\x43\x94\x56\xcb\x1a\x0c\x11\x25\x2e\x03\xc7\x62\x47\x96\x6d\x09\x22\xfe\x44\x65\x48\x04\x9f\xe1\x93\xec\xe0\x2f\x6d\xc8\x0d\xb0\x90\x5f\xa8\x06\xde\x7a\x47\x96\x54\x8b\x10\xea\x39\xe7\xa8\xcf\x57\xbf\xf5\x06\xd0\x94\x8d\x4c\xd8\x16\xdf\xab\x07\x48\xfd\xea\xdc\x05\x8b\xe6\xf1\x6f\xaa\xbc\x8d\xa5\xeb\x3a\x57\xae\xac\x4f\x87\x5d\x55\x3d\x3e\xaa\x9e\xf0\xee\x47\xfd\x47\x8e\x28\xcd\x1f\xd6\x2f\xa9\xa7\x0c\x24\x83\xb4\x0f\xdf\x9d\xb9\x29\xbf\xa4\xe7\xb8\x13\x7d\xfb\xb3\x2b\x3e\xfb\x6d\x68\xef\x31\xaf\xd2\x9e\x84\x98\x8f\xd3\x14\x6f\x3c\x86\xf0\x21\x95\x5a\x0c\x06\x85\x85\xf1\x37\xfb\xe7\xbb\x62\xcc\x66\x85\xc5\x12\x4d\xfa\x53\x2a\x44\xcd\x6d\x3d\x9f\xcd\x07\xf0\xd6\x66\xf2\x88\x39\x58\x03\x05\x7e\x32\x3c\x0d\xaf\x25\x91\x9e\x09\x00\x1f\xa8\xc7\x8d\x1c\xbd\x3a\xe2\x85\xe7\xd1\x99\xba\x53\xaa\xb0\x8f\x12\xf6\xc7\x8f\x12\x67\x02\xe3\x9b\x47\x1b\x42\x76\x8a\xfa\xcc\x98\x7a\xc8\x06\xfe\xe8\xd5\x71\x66\x75\x71\xb7\x58\xbc\x01\xd6\xe5\x14\x9e\xec\x32\xb6\x5f\xe2\x80\x4f\x1f\x36\x1c\x2d\x5f\xb2\x34\x21\x7a\xd4\xa2\x57\x36\xd1\x79\x40\xd7\xe8\x3c\x44\x32\x09\x4c\x27\xa7\x35\x32\x52\xac\xd1\x04\x88\xc4\xce\x50\x85\x01\x9b\xbe\xb6\x06\x83\x38\x20\x20\xaa\xc4\x15\xc0\x89\x5b\xe1\x99\x10\xeb\x3c\x1d\x93\x7c\x78\xe0\x23\xb5\xde\xd9\xf0\x76\x10\xfc\x3f\x4e\xc8\xe0\x57\x27\xa7\x2d\x4c\xfb\xb0\xf6\x7f\x4d\xc9\xf8\xf1\x4a\x74\x07\xd8\x34\xee\x4d\xff\x7b\x62\x48\xaf\xc8\xab\x74\x5e\x5a\x33\xf1\x84\x2f\xa9\x54\x15\x10\x60\x55\xaa\x9c\x8c\xde\xa2\xcf\x77\xc5\x5b\x2c\x2a\xab\x35\x26\xdf\x65\xd5\xa8\xf0\x01\x53\xa1\x32\xfe\x0f\xbe\x9a\x67\x47\x2c\xf2\xf0\xf7\x7f\x9a\xa0\x1a\xf4\x53\xda\x82\xb4\xba\x2a\xe5\x7f\x9f\xa3\x6f\x4c\xe8\x13\xd0\x5a\x7f\x7b\x7e\x97\x3e\xcf\x98\xa8\xa7\x71\x6c\x79\xac\x4a\xf1\x7d\x6d\x6b\xf6\x32\xcd\xa1\x79\x04\xb4\x3c\xa6\x61\x58\x33\x26\x29\xc5\xe6\x11\x3d\xc4\xef\xf9\xda\xfb\x1e\x9a\x67\x13\xde\x9c\x67\xd3\x1e\x0d\xa0\xf1\x20\x2b\xe9\x1c\x4f\xb6\x06\x26\x28\xc8\x14\x12\xc0\x2a\x24\x26\x89\x0a\xef\x81\x26\x9f\xbb\x0c\xbb\xc7\x24\xf0\xfd\x4b\xbd\x97\x05\xe4\x14\x63\xe5\xeb\x33\x84\xb0\x10\x3c\xfe\xde\x4f\x87\xd0\xb5\xfa\x57\xde\x0f\x6e\x34\xcd\x9e\x70\xf5\x97\x9f\x9b\x98\xdc\x69\xe4\xd0\xec\x09\x33\xda\x4b\xe0\x67\xea\x6f\x2f\xbc\x83\x1a\x1a\xd7\xae\xb6\x0c\xc9\x03\xd1\x8f\x5e\x3a\x40\x01\xb3\xf8\x60\x63\x7a\x61\x73\x1c\x37\x8a\xf6\xc9\x8d\x72\x1a\x02\x74\x05\x2e\x6b\x40\x80\x21\xe4\x99\x77\x19\x1e\xf2\x9e\xbc\xc8\x88\x03\x14\x41\xdf\xde\x1c\x1d\xb1\x00\x4e\xb6\x1e\xfd\xbe\x5b\xb8\xcd\x38\xfa\x96\x6b\xcf\xb8\xb9\x43\xea\x6e\xd6\x79\x23\x25\x63\xe3\xce\x7c\x78\xb6\x1e\x3d\xd8\x48\x6f\x34\x7e\x7a\xb7\x7c\x65\x6f\x14\xd6\x1c\x31\x99\x15\xa1\xbb\xcd\xfb\x2b\xeb\x50\x39\x77\x0e\xcb\x2f\x80\x89\x24\xf4\xe1\x95\xa2\xe5\x51\x1c\x15\x32\xb1\xac\xc4\x65\x24\x2b\xe6\xb2\x4f\xf0\xfc\x99\x50\x8e\xfc\xe5\x33\x7b\x1f\xbd\x3e\xbe\x6a\xff\xd1\x05\xe9\x41\x16\x9d\x4d\x80\x73\xdc\xf2\xd5\x4b\xe4\x5e\x7c\x01\x85\x74\x5c\x86\xb6\x2d\x6b\x86\x74\xe4\xaf\xc3\x31\x0d\x2f\xa2\x2b\xdc\x22\x8a\xf5\x8e\x69\xd0\x61\x2f\x42\xa7\xf6\x53\xc9\x54\xd8\xab\x90\x19\xa1\xa1\xd0\x05\x05\xe7\xf9\x72\x73\x0f\x58\xe2\x36\xb7\x40\xc9\xe1\xa9\x80\x75\x57\xe6\x34\xa2\x25\x6b\x67\x8d\x9e\xd5\x27\x3e\x26\x30\x30\xba\xdd\xa0\x71\x7d\xc6\xc2\xb7\x4f\x1c\x44\x5f\x60\x9f\xc6\xc1\x9e\x42\xd9\xe8\xe6\xd6\x1c\x65\xad\x6c\x32\xd0\x23\x90\x43\xae\xbc\xe9\x3c\x91\xfa\x89\x37\xe9\x5e\x12\xe9\xd4\xd3\x93\x80\x98\x95\x72\xac\xbf\x92\x55\xea\x09\x5c\xdf\x13\x6a\xc4\xcb\xc1\x13\x31\x82\x4c\xb3\x2e\xe9\xd8\x59\xbe\x91\xa3\xab\x5d\xd0\xc5\x9f\x85\xdb\xb0\x8d\x97\xd2\x7d\x62\x48\x0f\xd1\x46\xb4\x94\xde\x82\x01\x23\xc9\xbc\x04\x4c\x36\xa6\x61\x3a\x95\x43\xac\x33\x80\xd1\xcb\xf5\xd8\xe5\xd0\x07\x2b\xa5\x05\xae\x78\x25\x50\x2a\xe5\x6a\x85\x5a\x6e\x10\xfc\xf0\x21\x3e\x61\x05\x13\x55\x14\x07\x0f\x8d\x45\x09\x12\x53\x82\xfe\x82\xa5\xa3\xaa\xb7\x85\x17\xa2\xc0\x52\xbc\xb5\xba\xc0\x37\xae\xba\xcb\x31\xe8\x87\x4b\xc7\x4f\x88\xe7\x0e\xec\x72\xf4\x14\xd8\x47\xc2\x30\x34\xc2\x24\xfa\x1c\xfd\xb5\x60\x03\x8d\x9d\x95\x0b\xb1\x33\xec\xf3\x50\x1f\x59\x26\x56\x48\x58\xa8\x2c\x71\x41\x7a\xbd\x75\xd9\xee\x8b\x92\xc1\x87\xae\x3c\x81\x33\x00\x5f\xba\x53\xdb\x22\x70\x46\xb2\x22\x50\x39\xd8\xec\xc3\x37\x9e\x75\xea\x47\x5e\xe1\x6a\xfe\x6b\xdc\xac\xf0\x7f\xc4\xcd\x80\x37\x6e\xf6\x09\x65\xed\xc4\x19\x92\xdf\xb0\xb2\x94\x70\xeb\x09\x9c\xd1\x84\x06\x21\xda\xe4\xeb\x4f\x46\x38\x75\x5a\x11\xe9\x9e\xa4\x08\x0a\xc0\xa2\x26\x5a\x6f\x50\x08\x0e\xa5\x60\x36\x29\x58\xaf\xee\x59\x3e\x25\x89\x4b\xc2\x1d\x4b\x33\x9f\xf2\x29\xd1\xdf\xeb\xf2\xeb\x76\x82\xcc\xa7\x7c\xca\xbf\xf1\x29\xa4\x85\x3f\x69\x75\xfa\x8b\xb1\x19\x17\x8b\x95\xf2\x20\xb5\x52\x83\x79\x27\x8e\xf3\x0d\x5f\xc9\xfa\xfa\x90\x3c\xa6\x86\xaf\xc7\x24\x78\x91\xb7\xaa\xf3\x76\x8f\x1e\xd7\x91\x77\x2e\x79\x7f\x89\x77\x23\x1f\x5d\x46\xa3\xa0\x19\xe4\x09\xfe\x25\x6f\x8b\x02\xf0\xdc\x3e\xa0\xfc\x47\x39\x75\x9c\x5c\x27\x57\x4b\x24\x2a\xa3\x9a\x85\x01\x64\x72\x55\x2d\x26\xd7\xd3\x2f\x53\x67\x33\x93\xae\xcd\x6c\x3c\x20\xb7\xfe\x40\xc8\xb8\x17\xe6\xba\xf3\x4b\xce\x0d\x7f\x2d\x29\x08\x54\x47\x36\xec\x04\xe2\x1f\x06\xaa\x64\x6d\xbb\x81\x80\xcf\xbf\xaa\xe1\x27\x9d\x2d\x03\x31\xe8\x5f\xa8\x07\xa8\x7f\xb9\x0a\x7e\xfe\xb8\x8f\x28\x07\x99\xf2\x36\x0e\x5c\x0e\xbe\xa3\x4a\x40\xed\x8f\x1b\xeb\xc1\xbb\xb4\xae\xa5\xb5\x53\x47\x12\x05\x25\x06\xa5\xda\xcf\xc0\x48\x0c\xd0\xe4\xb3\xf2\x9b\x1b\x0d\x00\x21\xcb\x85\xb6\x1a\xd0\x35\xb7\x1a\xc0\x04\x9d\xbe\x62\x59\xa1\x0d\x27\xe8\x54\x22\x6b\x33\x38\x55\xce\x8f\x27\xca\xd1\x97\x64\xf5\xc3\xf7\x87\xcd\x23\x10\x55\x91\xaf\xbb\xed\x04\xa1\x6a\xf0\xd2\x5e\x04\xa0\x8a\xb7\x01\x78\x8f\x22\x7d\xf2\x1f\xd1\x9e\x14\x79\xdf\x7b\xf0\xa8\xd7\x8a\xb7\x6b\x5b\x13\x3c\x6a\x7f\x89\xac\x3b\x48\xa4\xfb\x0f\x54\x35\xe7\x82\x12\xdc\xc1\x2c\x5a\xcf\x9f\x4d\xea\xf9\xe1\xa6\x1f\xe8\x3b\xd2\x3c\xf5\xfe\x14\xd3\x9a\xe2\xb5\xb7\x12\xf0\xda\x19\x8a\xd7\xce\x42\x83\x17\xaf\x9d\x62\x17\x52\x8c\x89\x6c\x1e\x63\xe2\x21\x8f\x17\xe2\xf4\xc1\x98\x20\x7b\x61\x28\xdd\x3f\x17\xd3\x9f\xef\xe0\xcf\xdc\xa4\x18\x54\x07\x7c\x30\xfe\xb7\x7b\x30\xfe\x31\xad\x39\xfc\x5e\xe9\xd7\x4c\x2b\xc1\x25\x19\xdc\x8c\x5b\x02\x37\xc9\x29\xad\x56\x0f\x76\xc1\x08\xda\x03\x60\xa0\x46\x0c\x0a\x7c\xb1\xf2\x34\x62\x18\xd4\x8c\xad\x4b\x7a\x9b\x82\x02\x40\x7b\x9b\x02\x1b\xc3\x53\x1a\xe1\xe5\xc5\x8b\x7d\x42\x3e\x43\x78\x01\x4f\x60\x9f\x78\xf7\xfe\x85\x9e\xbd\xdf\xfb\x1c\x08\x22\x3d\xcf\x11\xf6\xfe\x59\xc2\xde\xef\x79\x0e\x04\xd1\x3e\x3d\x89\x29\x76\x34\x7d\xce\x9b\xc2\x73\xa2\x85\xe7\xd8\xbd\xf4\x50\x8c\x3c\xfa\x9c\x6f\xf8\xe7\xfc\xc9\xbf\x23\xc1\x07\x8b\xa5\x55\xd3\xf7\xa2\x78\x51\x2d\x63\x26\xb9\xba\x7a\x7f\xad\x3f\xf6\xdc\x55\x9c\x0a\x9f\x9b\x69\x17\x59\xde\x7d\xd7\x5c\xa2\xc9\xe1\x4f\x76\x38\xe0\x2f\x8c\x01\x39\x49\xf3\x17\xa8\x1c\x94\x53\x48\xe9\xdd\xb5\xaf\xdc\x79\xe9\x58\x56\x30\x14\x3f\xfe\xd0\xc2\x49\xc3\xdc\xdf\xd6\x5d\xdc\x81\xee\xf3\x48\xd2\x17\x37\x8e\x9f\xb1\x06\xac\xdc\xba\x17\x4d\x52\x9c\x5c\xb7\xea\xd7\x65\x94\x1f\x09\xb6\xff\x0b\x09\x7e\x16\xec\xe3\x83\xdb\x5e\xec\xc1\x7d\x86\x4b\x19\x08\x14\x64\x4e\xd5\xcd\x73\xca\xe3\x4d\x14\x0a\x78\x13\x12\x59\x0f\x9a\x24\x43\xde\xe3\xff\x04\xfe\xfb\x42\x2f\xfe\x7b\xb3\xbc\x9b\x75\x90\x7f\xce\x2c\x2f\x6e\x85\x47\xde\x06\x1f\x79\x0b\xf3\x8f\xf5\x27\x89\x69\x39\xff\xad\xbc\xcf\xe1\xfb\x44\xcf\xf2\xf4\x89\xf6\xce\x7f\x84\x57\xde\xbe\xb5\x64\x46\xc6\x42\x90\x71\x83\xb0\xdf\x11\x14\xc4\x48\xa5\x26\x5a\x45\xa6\x79\xa2\x8a\x8c\xe2\x50\x3d\x59\x42\x16\x19\xa6\xc3\xde\xb8\x06\xf0\x8e\xb8\xa6\x45\xc9\x58\x15\x08\xaf\x70\xaf\x57\x82\xd3\x6b\x2e\xb7\x83\x63\x95\x4f\x55\x88\x6d\x01\xef\x17\xf6\xc4\x86\xc7\xf1\xf9\x83\x21\x59\x20\xb6\x65\x5d\x58\x00\xf6\x25\xed\x4e\x73\x80\x26\x98\xd8\xe5\x60\xbc\x27\x05\x07\x63\xd2\x02\x69\x61\x98\xfe\x29\x3c\x45\xda\x18\x82\xb1\x3f\x5d\x1b\x06\x84\xca\x30\x2b\xf0\x9c\x15\x5a\xd6\x83\xa1\x93\xb2\x7b\x2f\xd4\xc5\xb8\xeb\xc1\xc2\x25\xc7\x12\x61\x57\xc9\xf8\xa7\x6a\xc0\xd8\xac\x0c\xf4\xf8\xdc\x79\x70\xf7\xc0\xd1\xb8\xc4\xea\xd9\x2d\xe6\x80\xdb\xd8\x62\x0e\x38\xb6\xf5\xd3\x73\xc0\x6d\xf2\x99\x03\x8e\xf5\x5d\x3b\x14\x1f\x97\xea\xc4\xa7\xc2\x73\x0c\x82\x4e\x34\xcf\x25\xc5\xb0\xa2\x3a\xe1\xe6\x9f\xf3\x37\xff\x8e\x18\x9f\xb5\xcc\xf7\x0d\x28\xf6\xf4\x0d\x68\xd6\x51\x43\xb3\x1f\xcf\x63\x9e\x14\x0a\x98\x27\x3e\x3a\x1a\xe0\xff\x44\xff\x81\x85\x9e\xe7\x60\x7a\xec\x02\x3d\x66\xaf\x4d\xe0\x9f\x33\xcb\x83\x9d\xe2\xd5\x51\xcb\x53\xf4\x6c\xf5\x3e\xa7\x1b\x70\x08\xcf\x09\x7d\xe2\x39\x1e\x0c\x16\x09\xdc\x0e\x22\x84\xf7\xf0\x07\x0b\xc2\x3b\xc5\xba\xa6\xf4\xdc\x16\xe8\x51\x0b\xef\x09\xf1\xca\x87\xe2\xcf\x51\xf9\xfc\xc1\xd3\xf3\x23\xff\x8e\x60\x1f\xdb\x52\x85\xf7\x7c\x92\x2f\x26\xa3\xfd\x73\x44\xc4\xa7\x16\xb3\xb4\x04\xa0\xb9\xbd\x06\x0d\xc8\xf1\xd9\x0c\x24\x8b\xaa\xdf\x32\x12\x64\x16\x32\xa6\x76\x92\x68\x14\x4d\x8e\x02\xcc\x4e\xfc\x2c\x92\x1b\x46\x9f\x25\x96\xca\x60\xbe\x4b\xa6\x96\xb2\x3e\xb0\x6d\x82\x83\xe4\x0d\x2d\xd3\x84\xb0\xed\x95\xa3\x76\xe7\x2d\xb8\xe9\x0d\x2b\x73\xe9\x7c\xe2\xb1\x88\xa1\xfc\xdd\x7d\x42\x8f\xc2\xbd\xfc\x51\xcc\x36\xca\xdf\xa3\x16\x7a\x64\x6d\xe6\xaf\x69\x17\x96\xe5\x9f\x34\x77\xa1\xbd\x33\x94\xd5\xe9\x75\xa5\x2e\x46\xaf\xf7\x37\x1a\x03\xf1\xe1\x81\x55\x28\xa5\xd8\x71\x94\xfa\xfb\x63\x47\xd2\x5f\x08\xb6\x5e\x6a\x71\xfd\xe4\x1b\x4e\xc6\x8e\xb4\x95\xf7\xe7\xb3\x00\x9f\xd0\x46\xc4\xf1\x16\xd8\x13\x8c\x06\x17\x15\x39\xd2\xd1\x83\xf6\x39\xa1\x71\x5d\x66\x86\x98\xc6\x4d\x7b\x29\xf8\xa5\x4a\x76\x56\xa8\x3b\x1b\xfe\xb6\x16\xa5\xa3\xaf\xd0\x47\x9a\x9d\xda\x75\x55\x70\xe8\x5a\x58\xb0\x15\xd3\x75\x11\xd3\x35\x8f\xfa\x15\x59\x4e\x9d\xd8\x68\x32\xe6\xbb\x58\x93\x49\x1f\x18\x88\x85\x16\xa8\xd6\xd3\x0e\xba\x0a\x97\xde\x40\xae\x56\x0a\x5d\x8a\x60\x6f\xd8\x92\x79\x8a\x34\x21\xc5\xee\x69\xea\xb8\x79\xc1\x7c\xba\x5d\x4e\x21\x21\x2e\x19\x13\x97\x59\x1d\x12\x50\x32\x7c\x66\xd0\xcc\x7e\x7c\xee\x1d\xda\x24\x90\xf6\xfc\x4c\x4f\x12\x1e\x89\x49\x0f\xa0\x31\xe9\x40\xe2\x63\xeb\x4d\xfe\x2a\x4e\x63\xd0\xb2\x62\x29\x2b\x2d\x71\xb1\x1a\xad\x37\x5b\x89\x8f\x49\x8b\x5a\x5c\x83\xb0\x9e\x58\xb1\x0c\x18\xb9\x1e\x97\x5e\x48\xef\x1a\x96\xda\xa1\x53\xbe\xe3\x17\x4f\x68\xfa\x5b\x3e\x62\xed\x68\x3d\x61\x61\x9d\x66\xa7\x21\x3f\x2b\xab\x02\xaa\xf9\x08\xb5\xbb\x89\x46\xad\xab\xf3\xf1\xcc\xea\xb1\x7c\x76\x51\xf9\xd8\x9c\x4a\x0f\x0d\x6a\x8d\x81\x95\xd2\x26\x7d\x6c\xb0\xd7\xf5\xfe\x2f\x34\x00\x9d\x91\xfd\xaa\x61\x05\xa1\xa1\x5d\x56\xef\x94\xe3\x68\xc1\x45\xec\x6c\xff\xf1\xe6\xab\xa0\xf8\x0a\x6a\xfb\x5d\xec\xb0\x65\xaf\x12\x12\x32\x73\xa6\x81\xda\x16\xc1\xeb\xc4\x22\x2a\x07\x1e\xb3\x9e\xf6\x2c\xd0\x8b\x95\x2a\xac\x2a\xac\x4c\xc1\x68\x54\x2a\x05\xd0\xb0\x52\x85\x4f\xf7\x2a\x01\xc3\x83\x46\xe8\xe9\x22\x21\x01\x7a\x40\x6f\x1f\x68\x8c\x1e\xf9\x83\x62\x0b\xda\x03\xe2\x6e\xf0\x41\xfa\x70\xb4\xcb\x02\x4a\xd0\x8f\x7c\xa4\xfe\xcd\x8d\xee\xe5\x34\x4c\x5f\xb9\x11\xa6\xf1\xbe\xb0\x1e\xeb\xf6\x2e\x8a\xb9\x1c\x73\x42\x23\x12\x8b\x88\x3e\xa8\x5d\x4a\xc0\xca\xa5\xf8\xe4\xa7\x90\xaa\x19\x1e\xd5\xf8\x89\xe1\xad\x2c\x3f\x2c\x5f\x48\x88\x09\xd1\xb1\x96\x1b\x84\xed\x23\xe8\x7a\x08\x48\xf8\x92\x67\xbd\x02\xa4\x86\xa0\xb7\x7e\x27\x11\x7b\xf0\xf5\x1a\x70\x91\x70\x8d\x32\xd7\xa0\x20\xfe\x1e\xb3\x87\x80\x99\xad\x20\xf9\xfe\x4e\x35\xe7\x4f\xf0\xd0\x65\x62\x56\xa6\x6a\x09\x1e\x44\x2e\xc7\x52\x5b\xd9\x69\x03\x95\xf0\xd6\x0e\xbd\xd5\xae\xb3\x85\x8b\x7b\xac\x05\xd2\xfd\x20\xb0\x8c\x74\x51\x49\x7e\xe7\xd3\x4b\x20\xe4\xf7\x91\xe8\xc8\xdb\xa0\xc7\xe2\x6f\x17\x43\xf8\xf7\x99\x43\xa7\x6f\x40\x5d\x1d\x8f\x53\xfa\x35\x77\x95\xc6\x2c\xbb\xd2\x5c\xe0\xcf\xb1\x3d\xff\x06\x8f\x1b\xcc\x44\x92\x68\x84\x38\x4c\x1f\x36\xd4\x65\x8e\x18\xea\xd2\xea\xcd\x72\xb3\x5c\xad\xd7\x91\xac\x10\x1e\x56\x8b\x64\x2d\x7a\x92\x78\xbc\x28\xfe\x2c\x1f\xab\xe4\x0f\x22\xa9\xad\x32\x00\x10\x8e\x28\x98\x2c\x56\xf9\xe2\x39\x75\xb1\xb3\x20\x68\xe0\xee\x81\xd1\x2f\x6f\x2a\x1a\xaf\x9f\xf4\xde\x92\x2d\xab\x81\xf2\xc4\x14\xf7\xe7\x79\x05\xb3\x36\x06\x64\xcc\x3a\xf9\xa1\x28\xe7\x71\x5c\xef\xa4\x59\x95\x0b\xc1\x7b\x28\xf1\xbd\x86\xce\xbd\x56\x6d\xd9\xb4\xf9\xe1\x3c\x24\x1e\x58\xbe\xb8\x06\xc4\x5e\xa5\xf2\xc9\xc0\x74\xee\x15\x5d\xc7\xfb\x70\x2c\x93\xee\x0c\x51\xe3\x17\x4a\x3f\x06\xfa\xc9\xf0\xea\x95\xd1\x16\x77\x1a\x43\x38\x0c\xcf\x77\x59\xa0\xf1\xc9\xeb\x6c\xad\x90\x4e\x9d\x25\x5c\x69\x7b\xfa\xde\xda\x5b\xb4\x23\x10\x18\x91\x24\xf1\x4d\xaa\xa1\xbf\x41\x0f\x1e\x14\xed\x1e\xd2\x6f\x5c\xfd\xa4\xee\x03\xfd\xa1\x68\xe8\x8b\x1f\x69\x06\x76\xc4\xcc\xec\x1a\xd8\xe6\xe5\x0d\xa3\x66\xe8\x0e\xe7\xce\xe9\x3a\x6e\xe6\xbc\xd5\x7b\xd6\x6c\xbd\x0f\x16\x5c\xed\x54\x68\x01\xbf\x3d\xda\xdf\x2f\xb1\x72\xf2\x62\xc2\xca\xfb\x27\xf3\xfb\x06\xee\x07\xad\xf6\x7c\x89\x1a\xd1\xbd\xe0\xb7\xa9\x8e\x4d\xa3\xf2\x76\x31\x6d\x98\x14\x67\xb0\x2c\x2c\x34\x2c\xb4\xd4\x15\xa6\x6d\xd3\x46\x1b\xc6\x9a\x58\x93\xaa\xd4\x65\xd2\xb1\x91\x58\xe7\x7d\x7a\xa8\xf2\x28\x0b\xc2\xb9\x5e\x27\x84\xae\xf9\xec\x43\x1f\xca\xe3\x5a\xf6\x35\xc1\xfe\xc5\xb4\xfe\xb7\x16\xac\xda\xb5\x65\x45\x79\xde\x10\x2f\xd5\xfd\x0a\x5a\xcd\x5f\xde\x3a\x24\x7d\xe3\x96\xbe\x45\xbd\x6b\xd3\xb9\x91\xd5\x53\x37\xcd\x5f\xfe\x66\xa4\xee\x8d\x7f\xad\xf5\x50\x5d\x78\xfe\x58\xf9\xe0\x75\xcf\xad\xeb\x55\xd4\x35\x9f\xd2\x9c\x8d\x69\xbe\x4f\x7b\xaf\x63\x9a\xf5\x80\xa0\xb2\xb9\x80\x3c\x2c\x4c\x0e\xd8\x08\x65\x44\x70\xbe\x2b\xc2\xa8\x94\x90\x7b\xf6\x7f\xa0\x19\xf8\x60\x40\x68\xad\x5e\x18\x69\xd8\x7c\x98\x15\x8e\xd4\xad\x01\x63\x3e\xb5\xbf\x2f\x45\x78\x28\x01\xbd\xd6\x1c\x2f\x58\x9e\xef\x1a\x14\x1b\x95\xd2\x3e\x4f\xa0\xbf\x7a\xf8\x1a\xf0\xab\x07\xbc\x01\xc0\xf9\x13\x7a\xcf\xe9\x2d\x85\x32\xe7\x9c\x91\xdd\x7a\xf0\x0a\xf4\xfe\xc9\x9d\xa7\x07\xf1\x58\xbf\x13\xf0\xde\x38\x01\xcb\x9a\x20\x9f\x04\x05\xf0\x18\x22\x22\x95\x48\xa5\xb5\xda\x6c\x96\x12\x97\x4d\xab\xf5\xc3\xe7\x7d\xce\x67\x9f\xf4\xc0\x28\x52\xaa\xff\x5b\xda\xa7\x9a\xbf\x11\xd4\xa5\xb2\x79\x67\x0f\x77\x0d\x79\x2a\xcf\xf3\xb9\x45\xd2\xe8\x4d\x15\x75\x79\x1b\x72\x44\x60\xcd\x98\xca\x96\xb9\x9d\xfa\x05\x63\x6c\x51\xef\x93\x4d\x1c\x0c\x0d\xc2\x74\xee\x42\xa3\xd8\x26\x2c\x5f\x7a\xc7\x1f\xca\x03\x74\xf8\xe9\xfd\xf4\xa2\x80\x00\xff\x7c\x57\x80\x86\xa4\x92\x14\xb8\x44\xde\xcb\xa5\x66\xf8\x01\x9e\x52\xde\x4f\x70\xfc\x53\x16\x27\x8f\xd8\x2d\x61\x6b\xa6\xe1\x3d\x7f\x5e\x82\xa8\xe1\x80\xf9\xca\x07\x9e\xac\xcd\x13\x6f\x15\x6d\xec\x3f\xa5\x52\x36\x8f\x78\x01\xbf\x9b\x03\x86\x8f\x5c\x32\xba\x98\xcf\xd4\x5c\x30\xb1\xe7\xcc\x7c\x19\x54\x56\x0e\x8b\x8c\xa3\x7b\xd4\x7a\x7a\xbf\x91\x83\x4f\xad\x6d\x9d\xd8\x33\xd4\x98\xcd\x8a\x52\x97\x99\xb5\xea\x74\x06\x8d\x61\xa8\x4b\xa4\xf1\x24\x92\xf8\xdb\x7d\xcb\x08\xf9\xe9\x25\x51\x8a\xa7\x5b\x84\x09\xab\x8f\xeb\xbe\x6b\x60\xf4\x2b\x9b\x7f\xd0\xec\xf6\xb4\x07\x0b\xd2\x59\x3c\xed\xc1\xce\xa9\x4a\x3a\xf5\x0b\x64\xb3\x89\x71\xf8\x4f\x56\x21\xdb\xf5\xa9\xee\x60\x8f\xe3\xba\x27\xd5\x54\xcd\x23\x34\xee\xc1\x34\x5e\xc5\x36\xbc\x15\xd9\x3f\x82\x82\xc4\x1a\x0d\x28\x70\x69\xd4\x0a\xa3\x4c\x2c\xcb\x77\x85\x7a\x53\x40\x5a\x50\xe8\x0b\xa7\x08\x9b\xa9\x6a\x56\x4c\x07\x3c\x78\x74\x4e\xfb\x8a\xea\x12\x0a\xa8\xd8\xaa\x5d\x4a\xd6\x69\xf0\xe5\x52\x8d\xcb\xbb\xae\xa6\x8c\xd3\x12\x44\xc5\x9b\x5f\x0f\x53\xd4\x4a\xa2\xcb\x5e\x83\xb3\xdd\x69\x3e\x86\x60\x52\x55\xf6\x40\x7e\x8f\x61\x30\x7d\xc7\xa9\xbd\x8d\x71\x1a\xb5\x5a\x96\x6b\x8e\x2b\xb2\x5a\x7e\xfd\xfb\x66\xa2\xf9\x74\xee\xf7\x44\xd4\x9e\x34\x58\x98\xb8\x1e\xe8\xe6\x0c\x02\x4e\x55\x01\xe2\x2a\x76\xf9\x5a\xdc\xca\x0a\xe0\xdf\x1c\x66\x6b\x61\x66\xa7\xcc\xe8\x3c\x80\xf4\x40\xc1\xf4\x1c\xa3\xf7\x77\xc9\x4e\xb3\x4e\x47\xe8\x29\xf0\xf4\xb5\xc4\x44\xa9\x59\x43\x80\x1a\xeb\xa0\xf1\x89\xa8\x9b\x2f\x5d\x3a\x2f\x5d\xbe\xcb\x99\x08\x2d\x1c\xdd\x2b\xad\xbb\x59\xe7\x02\x56\x57\xdd\x52\x4d\x7c\x8c\x97\xae\x87\x1a\x3e\x00\x47\x02\x72\xee\xb4\x02\x7b\x96\xc3\x43\xd6\x1f\x59\xf9\xde\x38\xc3\x51\xda\x53\xa7\x0d\xfd\x79\x3c\xfe\xb9\x33\x89\x6d\x40\x1b\x95\xe3\x0b\xf8\xe7\xcf\x69\x8c\x3a\xc2\xa9\x55\xa9\x74\x50\x04\x20\x20\xd5\x16\x3a\x79\x29\x69\x35\xe1\xcd\xac\xa0\xb7\x51\x84\x50\x7a\xaf\x2d\x36\x18\x9f\x9c\x59\x3d\xaa\xb5\xb0\xaf\x5a\x50\xed\x46\x25\xd8\x35\x76\x6e\x68\x9f\xba\xfe\x91\xbf\x9e\xdb\xb1\xdf\x8f\x5c\x72\x3f\xfe\x25\x27\x65\xcf\xe2\x4d\xe0\x20\xca\xb9\xf1\xfe\x86\x35\xed\x9c\x64\xec\xb1\x78\xec\x46\xea\x27\xe1\xb1\x95\x4a\x2d\xc3\x06\x32\x81\x05\x2e\x46\xad\xc5\x2a\xa6\x35\x3e\x35\x36\xdf\xd3\x8b\x17\x4f\x16\xb0\x4b\xf8\xc6\xbc\x78\x3d\x58\xe7\xb3\x51\x81\xe8\x72\x99\x32\x7b\xce\x9c\x0d\xa1\xad\x4f\xc6\xb6\x46\xdf\x9e\xdf\x73\x56\x31\x16\x5d\xe6\xd2\xe7\xb9\xdd\x9d\x93\xbb\x57\x6f\xdf\x71\xf9\xdb\xd7\xee\x1f\x59\x13\x9f\x0a\x49\xae\x6b\x3b\x3c\xf6\x75\x8a\xa3\x97\xea\x34\x6b\x34\x7e\x36\x1b\xe3\x17\x60\x2e\x75\x05\x04\x30\x7e\x7e\x3a\x52\x4e\xcc\x58\x9f\x3e\x2a\xf3\xdf\xe8\xad\x0f\x3d\x92\xa6\x3a\x5a\x0b\x49\x4d\x7c\xf1\x3a\x26\xce\x8a\xfd\x59\xbe\x45\x7c\x98\xce\x24\xe6\xc0\x9f\xef\xfc\x7c\xa3\xf1\xab\x95\xee\xad\x6f\xdd\x6b\x75\xce\xb4\x6a\xce\x96\x7a\x90\xd1\x35\xb8\xeb\xd7\xb7\x37\x2e\x05\xf0\xe5\xf5\x35\xe8\x53\xfd\xb9\x9d\x5b\x2e\x05\xa5\x9d\x9f\x76\x7e\xcc\xde\xc3\x1d\xe6\x56\x2e\x99\x7e\x76\xc5\xa2\x35\x23\x26\x01\x4d\xef\xb3\x3b\xc8\x9c\xcd\xc2\xb4\x4e\x26\xb1\x22\xb6\x9c\xe5\xef\x15\x06\xd0\xde\x50\x21\x4c\x1b\xa7\x91\xbf\x51\x08\x34\x1b\xcd\xe4\x46\x41\xa6\xf0\x76\x88\xa2\xd9\x30\x97\x9a\xc3\xfa\xcf\xe8\x12\xe5\x8d\xf1\x3b\x38\x2b\x5a\xf4\xd4\xfd\xc2\x6d\xf4\x79\x70\xdd\x9a\x8c\xcc\xd0\xe8\x4e\xb3\x43\x9e\x71\xc9\xf0\x77\xfa\xaa\x4d\xaa\x9d\x9a\x75\x0c\xbd\x67\xa0\xf1\x15\xba\x1e\xb5\x81\xf2\x02\x7c\x10\xd0\xea\xd5\xf8\x48\xaf\x36\xe2\x23\x99\x88\x6f\x07\x1e\xdc\x32\x81\xa1\xad\x17\x23\x83\x04\xd8\x9f\xba\x72\x80\xb0\x7b\x07\x3c\x76\xb6\xa3\x8b\xe6\xbd\xa7\xef\x1d\x6e\xfc\x3b\x1d\x0d\x50\x6d\xd5\x74\x2e\xe0\x92\x9e\xb8\x78\x78\x94\x83\x3e\xa2\xe7\x79\x54\x2d\xf4\xab\x4a\xe6\xb1\xe5\x31\x8d\xf3\xb9\x1e\xf8\x67\xbe\x5f\xc5\x18\xec\x23\x8f\xa6\x71\x3f\x1e\xe3\x7e\x38\xfe\xd9\x4a\x31\xd6\x07\xd2\xb5\xf1\x3b\xaa\x81\xb5\x4d\xd7\x18\x03\x63\x75\xea\xb4\x62\xb5\x5a\x71\x0f\xe0\x5d\xdb\x09\xf2\x41\x29\xe0\x80\x3f\x13\x7f\x7d\xc8\x10\x52\xb5\x4c\x51\xe1\x85\xad\x99\xe2\xa6\x91\xbb\x24\x92\x64\x05\x27\x8d\x54\x5a\x23\x92\xec\x72\x69\x99\x5c\xd3\xa7\xa7\x66\xa4\xff\x78\x54\xd3\xcb\x2f\x34\x38\x2e\x35\x3e\xb1\xff\x60\x45\x71\xb1\x76\x3c\x39\xaf\xb3\xf0\x4f\x51\x2e\x37\x4b\xfc\x2a\xf6\x5b\x4d\xf4\x3e\xcb\x68\x90\xc9\xd4\x6a\x16\xbc\xc2\xfe\xc4\x36\xb1\x2c\xeb\x94\x29\xbb\xb1\x66\x6b\x03\x28\xc4\x86\xf7\x52\xdb\x21\x93\x92\x92\x78\x4c\x00\x3e\x68\x43\xdc\x31\x87\xcf\x6b\x89\xcf\x6b\xf8\x67\x5c\x58\x78\x5c\x5c\x78\x58\xdc\x7d\xcf\x8b\x2d\xb1\xf8\x45\x42\x58\x58\xac\x78\x42\x58\x6c\x2c\xff\x8f\xfc\xf7\x57\xc8\x6b\xfc\x3b\xcc\x3f\x9c\x22\xca\x65\x7f\x14\x3f\xc6\x34\x29\x8e\x29\xc4\x74\xe8\x4b\xe4\xcc\x66\xc2\x7f\x6c\x8e\x48\xfc\x87\xfd\xf1\xd0\xb2\x43\xcb\x5e\x9f\x76\x64\xd9\xa1\xe5\x87\xc4\x8f\xfb\x7b\xff\x23\xbe\x26\x7c\x03\x7f\x7e\x95\xc0\x53\xb8\x53\x27\xf3\x65\x47\x8a\xd9\x51\x1b\x7c\xd8\x69\xc9\x4b\x0b\xfa\x1f\x62\xca\x12\xe2\x6d\x61\xb1\x6d\x63\xc3\xc3\x12\xe2\xad\xe1\xb1\xe2\xf1\xe1\xb1\xf8\x35\x26\x37\x2c\x01\xb3\x91\x10\x47\x65\x58\x88\xc7\xfb\x45\x18\xcf\x8c\x6d\x8a\x31\x90\x0d\x90\x3d\x29\x43\xb5\x81\x89\xb7\x5f\x27\x23\x5e\xd2\x5c\xfa\xe7\x41\x49\xe9\x01\x5b\x88\xc5\x82\x9f\x1f\x1e\x17\x1d\x17\x66\x8d\x27\x82\xbb\xdd\xad\xa2\xab\xef\xe0\x98\x98\xb8\xb8\x38\x50\x81\xd6\x30\x00\x64\x63\x7d\x19\xdf\x74\x04\x8f\xaf\x39\x25\x62\xc4\x1a\x31\x14\x33\x4c\xfc\xa5\x21\x98\x37\x11\xb5\x08\x12\x6a\xae\xc0\x69\xae\xd8\x65\x98\xf7\xbc\xb4\x50\x13\xda\x35\x6f\xcc\xd4\x8a\x98\x30\xba\xa7\xc1\xe7\x45\x45\xec\x05\xf1\x01\x7c\x50\x50\x1c\x63\x01\x95\xcd\x0d\x22\x6f\x2c\xe7\x0b\x8d\x55\x8d\x62\xe6\xc0\x81\x03\xf8\x7d\xe0\x4f\x51\x3e\xd7\x57\x3c\x8f\x09\x67\x5a\x39\xd5\xda\x10\x46\x11\x82\xff\x98\x08\x64\x9b\x88\x9f\x25\xfb\x75\xac\x96\x69\x5e\xdc\x08\x62\x8e\x4c\x12\x5a\xae\x9f\x64\x01\x26\x21\xb6\x8a\x57\x1a\xcf\x6a\x64\x1c\x80\x9b\xc3\x93\xda\x46\x16\x8e\xec\x6d\x4d\x88\xb2\x86\xc6\x86\x85\xda\xdb\x46\x17\x8e\xea\x96\xd8\x35\xca\x1a\x25\x4e\x4b\x8b\x8d\xd6\x76\xb3\x0c\xc8\xad\x30\xc6\x74\xc8\x88\x4d\x4a\x68\x63\xe8\x16\x36\x20\x77\x5c\x72\xcf\xcc\x36\x94\xee\x25\x58\xee\xc7\xc5\x35\xe4\xcc\x75\x4a\xa4\x16\x87\x12\xbe\x79\x6d\x21\xac\x03\xc1\x9f\xa2\x79\x22\x19\xdc\x10\x97\x61\xc1\x2a\xb1\x28\xd7\x68\xce\xc9\x1d\x3f\x7d\x7c\x44\x24\xe5\x1d\xa4\x60\xd9\x6d\x6e\xfa\x86\x11\x31\xd2\x63\x80\xc3\x2b\x8b\x2c\xa9\x48\x87\x5d\x02\xfb\xae\x5a\xfd\xc1\xea\x0f\x50\x4d\x5d\x5d\x1d\x03\x81\x0d\xbf\x6f\x5f\xd3\x2f\xf4\x7c\xa7\x39\xa9\xd3\x69\xd4\x32\x16\x4f\xe8\xa5\x24\x6a\x93\x7d\x26\x90\xe4\x7e\x38\x48\xd3\x28\x87\x67\xee\xc0\x84\xe0\x6b\x5b\xf5\xe5\x4b\xb5\xc5\x9e\x79\x5b\xb1\x6b\xcc\xe8\xc1\xbc\xec\x87\x61\x1e\xee\x63\x1e\x24\x98\x07\xbc\x5b\x87\xb2\x90\xe5\x79\xb8\x41\x79\xc0\x36\x5e\x42\x50\x9e\x86\x59\xae\x6e\xd1\x8f\x5c\xa4\x15\xe5\x3e\xbf\x73\xfc\xa8\xff\xc7\x9f\x85\xe0\x1c\x5e\xf7\x4b\xe8\x67\xd5\x4c\xb0\xd3\x8f\x63\xfd\x58\xb5\x22\x54\x01\x15\x8c\x94\x9f\x4a\xfc\x8c\x24\x0f\x6a\x0a\x79\x8c\x55\xf8\xce\x8a\x85\xc7\xa1\xee\x21\xd7\xb7\x18\x46\x2c\x34\x08\xcf\x5d\xfd\xe2\xf8\x32\x52\xe8\xc4\x81\x78\x51\x86\x28\x5b\x12\x4d\xf1\xb8\xda\x32\x0e\x12\xd9\x8a\x8e\xd7\x01\x9d\x2d\x24\x25\x9e\x05\x6c\xbc\x8c\x08\x6e\x48\x12\xfd\xd2\x62\x25\x44\x62\x95\x6b\x1d\x21\xfc\xcc\xd7\xcd\x92\x33\xb2\xb7\xf1\xbd\x58\xe4\xf3\x9a\x5d\x3f\xc7\x35\x60\xee\x1c\x57\xb7\x94\x59\x9d\xaa\xf4\xee\x4d\x73\x5c\xae\x39\xb6\xf6\xc3\x3b\x58\xe3\x07\xcd\xae\x6a\x17\x15\xd5\x2e\xbd\x75\xeb\x74\x58\xde\x2e\x9a\xbc\x8a\x4c\x17\x17\xba\xe6\xcc\x71\x0d\xac\x8e\x1c\xd9\x77\x44\x7c\x3c\x79\x9d\x93\xd4\xab\x6f\xae\x6a\x8e\x2b\xaa\x1d\x79\xb7\xe7\x2f\x8d\x25\x40\x18\x2a\xca\xe0\xe2\x29\x0f\x66\x46\x53\x1f\x48\xe8\xd6\x09\x74\x3f\x4d\xb2\x2f\x89\xb0\x96\x10\x32\x7b\x10\x26\xab\x63\x95\xc1\x4b\x08\x3f\xbc\x6b\x0e\x19\x3e\x26\x49\x18\x0e\xcf\x61\x29\xb5\x75\x9b\x19\x7f\x26\x00\x9b\x09\x8e\x93\xa9\xc9\xc5\x35\x9d\x82\xeb\x43\x04\x64\x0a\x1e\x74\x47\x82\x1d\x35\x09\xef\x82\xb0\x3f\x2a\xfc\xc7\x0e\x08\x33\xe9\x47\x74\x2a\x0b\x12\x87\x27\xc4\x29\xe4\xe2\xcd\x49\x45\xe5\xf2\x72\xd0\x6b\xa9\x5f\xac\x23\x89\xd7\xed\x48\xac\xb3\x47\xf1\x3e\x62\x64\xcc\x4e\x95\xca\x08\x21\x43\x77\x10\x16\x68\x25\xc4\x16\x0d\xf1\xec\x20\x34\x45\xda\x61\x57\x01\x1f\x17\x47\x02\xee\x97\x6b\xdb\xc7\xa9\x46\x88\x25\xe1\x51\x71\x78\x23\x29\x97\x5a\xd6\xa0\x9a\xc1\xb2\x8e\xf6\x90\xfe\xb6\x68\x55\x68\x48\x42\x4a\x62\xe2\xfe\x00\x32\x8e\x09\xed\x81\x5b\x9b\x3e\xc5\x6b\x48\x75\x92\xc5\xba\x05\xbd\xd6\x87\xb5\x3a\xec\x0e\xb8\x35\x13\x35\x1a\xef\x46\xda\xd0\x9b\x63\xde\xf1\xac\xb9\xad\x74\xcd\xa9\xea\xc9\xa6\x06\x01\x4b\x3e\xe0\x5d\x79\xfd\x57\xad\xb9\xbd\xfa\x36\xbf\xf2\xc8\xfb\x35\xf8\xfd\x6b\xb1\x7d\x93\x30\x7e\x27\x38\x96\x82\x76\x90\x4a\x7e\x91\xb0\xd2\xe0\xda\xe0\x2b\xdb\x0d\xe5\x8b\x74\x85\x2b\x5f\x14\xd6\x15\x64\xf0\x7e\xc7\x3a\xe8\x67\xd4\x8c\xfe\x94\x9f\x42\x81\x3f\xa8\xc6\x9f\x24\x20\x00\x54\xaf\x3d\x9f\xb6\x7a\xd6\xeb\x43\xba\x4a\x17\x6b\x41\xbd\xe7\x71\x78\x99\x8e\x1a\xe2\x7d\x26\x00\x76\x4c\x47\x4d\xd3\x9f\x84\x8e\x3a\x27\x00\x80\x80\x74\x10\xaa\x45\x59\x20\x32\x42\x0d\xe0\x40\xf4\xb1\xff\xf3\x35\x20\x5a\xb5\x1e\x1d\xb7\xe7\x1b\x3f\xb3\xf7\x0a\xfc\xff\xdf\x4e\x69\xac\x3e\x76\x0a\xc2\x4e\x58\x1f\xa5\x4f\xe8\xa3\xf2\x49\x7d\x7c\xd6\x92\x81\x9d\xc8\x32\xb1\x65\x0c\xcb\x0c\x4d\x18\x34\x7b\x5a\xcb\xe5\x90\x6d\xf7\x5d\x02\x69\x2d\x74\x26\xc4\xa9\xe1\x75\xc6\xe3\x77\xfc\xbf\xaa\x35\x44\x2e\x8b\xb0\x5c\x1e\x8a\xeb\xb1\x1e\xf8\xd7\xe7\xb1\x25\xa4\x79\xa0\x20\x16\x8f\x2a\xb0\x07\x56\xad\xf9\x78\xf5\xc7\xa2\x5c\x5e\x15\x04\x9b\xf7\x8d\x78\x11\xfe\x8c\xd1\x29\x57\x8b\x4a\x44\x13\x44\xac\x88\x74\xe5\xa5\x1b\xfa\x10\x9a\x49\x80\x75\x8e\xfd\xa6\x03\x6a\x30\xdc\x8d\x16\x2f\xa2\x4a\xe7\xbb\x47\xfa\x9d\x10\x89\xe7\xf2\xc0\x2f\xff\xb7\xfd\xf1\xff\x63\xfb\x1e\xc4\x32\x98\xc5\x69\xb0\x2e\x10\x7f\x43\x53\x6f\x20\xba\xa0\x96\xd1\xb9\x79\xc2\x9b\x69\xa1\x07\xc3\x78\xbb\x44\x8d\x63\x74\xbb\xf4\xc8\x66\x9b\xe4\x35\x81\x78\xed\x4e\xc5\x72\xca\x68\xfa\x91\x3e\xdb\xe4\xf4\x53\x33\x06\xe0\x34\xec\x34\x40\x03\xdd\xee\xae\x53\x87\x49\xf4\x0f\xbe\x0b\xd8\x1a\x6f\x0d\x8b\x8f\xc7\x7e\x51\x64\x42\x98\x35\x2e\x1e\x3b\x30\xc3\xf8\x2d\x90\xb8\x77\xc4\x9f\x89\xa3\x57\x14\xe7\xf0\xda\x0c\x14\xc6\xb0\x31\xf1\x4c\x06\xc9\xcf\xb1\x9b\xcd\x69\x8c\x15\x38\xad\x3b\xad\xd0\x1a\x8b\xbd\xd0\x48\x35\x19\x91\x22\xc3\x5c\xf7\xb8\x9d\xa6\xff\x83\xdb\x19\xf1\x0f\xff\x7e\xce\xe3\x84\x7e\xed\x79\xb1\x35\x8e\xf7\x46\xe3\xc0\x14\xcf\x3f\xb5\x25\x5e\x1d\xd9\xa4\x4b\x31\xd1\xc2\xbf\xc5\xf9\xfa\xa7\x3f\x09\xff\x46\x19\xa2\x0e\x20\xcb\xbc\x83\x65\xf6\xb7\xc0\x8f\x99\x44\x7f\xd5\x01\x81\x81\x2d\x05\x77\x69\xc8\x24\xbc\x6e\xfe\x8b\xec\x22\xf0\xf1\x16\x0e\xa4\x43\xf8\xfa\x7d\x68\xbb\x1e\x74\xd3\x0f\xe3\xc9\xf4\x3a\x7e\xc7\xc6\x8f\x7f\x72\xdc\x50\xd2\x23\xf8\xdd\x00\x60\x09\x0a\x0a\x98\x6b\x36\xab\x9f\x1a\x1e\xef\x25\x41\xd7\xb1\x30\x87\xfc\x37\x1a\x6c\x98\x0a\xdb\x33\xe9\xf8\xdd\x58\x41\x28\x19\x6b\x7c\x92\x96\xac\xc9\xe3\xc7\x4f\xe6\xd7\xc9\x2c\xbc\x0f\x98\x9b\x3a\x61\x7a\xa4\xc7\xe8\xb0\x2d\xb5\x11\xcc\x22\x1f\x20\x52\x43\xbf\x58\xe3\xe9\x43\x78\x5f\x44\x8a\x3f\xb7\xa2\x29\x9b\xf2\xa1\xaa\x23\x07\x10\x3a\xf3\xff\xed\x9c\x01\xa4\x9e\x89\x7a\x10\xcb\x93\x18\x8b\x7e\x13\xa6\x24\x5c\xa0\x8c\xf8\xe6\x20\x1a\xcb\xe8\x88\x57\xd7\xf0\xdc\x98\xbd\x4a\xe6\x33\xd0\xd3\x7a\xfd\x4f\xda\x05\xa2\x79\xd9\x84\x25\x7c\xe3\xd1\x9e\x6d\xf8\x4b\x3c\x55\x76\xfe\x17\x74\x70\xf2\xa6\x57\x78\xdd\x21\x67\x1a\x10\xdf\x14\x08\x97\x35\xcd\xc3\xb3\xa6\x39\xc5\x4a\x30\x31\x50\x8a\x6d\x50\x31\xdd\x25\xc9\xdd\x47\x36\xe8\xaa\x47\x0d\xd5\x63\xe8\x7b\xb1\x3c\xc8\x7b\x25\x8c\xf8\x28\x64\x48\xf0\x43\x98\x18\xb0\x20\x70\x82\x01\xbf\x71\x6c\x00\xda\x33\x75\xcc\x98\xa9\xd8\x1e\xde\x16\xed\x63\xab\xc4\x5d\x68\x4f\x5d\x15\x9b\x27\xab\x91\xed\x90\xbd\x23\xe3\x18\x19\x90\x35\x80\x3e\x4c\xd6\x90\x21\x4f\x48\x11\xde\xf6\xd0\x28\xfa\x9d\x3f\xc4\xd0\x33\xd7\xc7\xf8\x39\x33\xe8\x73\xf0\x19\x80\xff\xe8\x93\x1f\xfc\xf8\xe9\x0f\xb2\xcc\x6f\x58\xbe\x6f\x34\x3d\xf4\x9e\x1f\xd5\x06\xb5\xda\x6c\x26\x02\xfe\xcc\xfa\xd0\xca\x59\x1b\x9a\x5e\x3b\x69\xb6\x74\xb3\xf2\xe6\xa3\xed\x90\x24\x2d\xf5\x69\x7c\x17\xf2\x3f\xbd\xfe\x0d\x0b\x8f\x1e\x78\x36\x78\x06\xde\xec\x5d\x9d\xc2\x2a\xec\x2e\x10\xd2\xcd\xbb\x1a\x09\x2f\x0e\x38\x09\xde\x66\x55\x98\x26\x55\x3d\xcb\xc8\x12\x64\x10\x5b\xc7\xa7\xe4\xe0\xa0\x9f\xc4\x7f\xe1\x39\x5b\x6c\x2c\x3e\xe5\xc5\x12\xd9\xcf\xc3\xb2\x0f\xa5\xf3\x24\x3d\x86\x3d\xb1\x78\x01\x52\x06\xcc\x8b\x9d\x10\x8b\xf6\xdc\xbb\x47\xde\x73\x8e\x9b\xc1\xd9\x44\xbd\xe8\x7b\x80\xa0\xe7\x64\x0e\xbf\x81\xed\xa3\xdd\x97\x44\xbd\x6e\x61\x1a\x66\x88\xba\xb2\x1f\x88\x8e\xd1\xf9\x06\xd8\x42\x4b\x59\xf2\x4e\x7e\x36\xf0\x7b\xe1\x0a\xbc\x98\x50\x83\xe8\xd8\x18\xfc\xbc\x52\x54\xca\xbe\x27\xb9\xcd\x8f\x89\x27\x3c\x9e\xbf\x12\xc3\x9b\xee\xed\xcd\x28\x1a\x95\xca\xaa\x7e\x5f\xc2\xd0\xb9\xee\xc8\x56\x89\x3e\x27\x7b\x58\x1d\xf6\xa2\xc1\xb3\xb8\x6a\x9e\xdd\xe7\xbd\xb3\xcb\xb4\xd0\x13\x7e\x7e\x7b\x3c\x3d\xbf\xcf\x50\x0c\x08\x16\xe1\x45\x94\xcd\xa5\x11\x44\x52\x26\xf4\x98\x88\x6b\x00\x03\xea\x5c\x22\xfc\xc4\x33\x60\x00\xe3\xc2\xdf\x73\x85\xa8\x36\xad\x96\xb0\x2b\x68\x23\xaf\x45\xe9\xff\x4e\xeb\x9b\xf6\x7d\x3a\x68\x8b\x3e\x60\x55\xe4\x2b\xa5\xe1\xa1\xd8\x84\xcf\xe5\xf5\xd4\x3e\xb0\xb2\xa7\xec\x03\x7c\x18\xcf\xcf\x48\xbc\xb8\x3c\x34\x31\x81\x4c\x3e\x6f\x57\x26\xa0\x31\x50\xd5\x24\xfd\x47\xbb\x32\x21\x9e\x5f\x89\xf1\xa8\x41\x30\x4e\x7c\xac\xf6\x1b\x4c\xfb\xef\xdc\x35\xec\x33\x85\x1f\x03\xb0\xa3\x1c\xf4\xc5\x14\x03\xd0\x9b\x3c\x88\xbe\x56\x08\xd4\x67\xf1\x7d\x66\xf8\x0a\x53\x72\x01\x98\x09\xd9\x5e\x07\xad\x47\x7b\x0e\xcc\xb0\x94\x83\x17\xc3\xdc\x7b\xd7\xd8\xc6\xee\xe1\xae\x1d\xec\xb0\x6c\x9b\xfb\xc7\x83\xf0\x61\xfd\x75\xfc\x20\x06\x61\xdd\x7f\xbd\x69\x3b\x23\xc3\xeb\x54\x42\xd6\xa9\xc8\xa6\x06\xb6\x2c\xec\x1a\x59\xe1\x91\x3a\x3f\xd1\x38\x2e\xfe\xb8\x1e\x1c\xbb\xb1\x53\xaf\xdf\x39\x96\x01\x4d\x07\xc9\xe6\x87\xe9\x09\x64\x42\x4f\x29\xa0\x2a\x10\x06\x2a\xf5\x67\x30\x09\x44\x9c\xbd\xf9\x7e\x3c\x42\xf5\x90\xce\x0e\x52\x75\x0e\xda\xc7\x80\x94\x6d\x43\x92\xbf\x9e\x09\x1d\xb7\xbe\x04\x3d\xea\x7b\x74\x3a\xd7\x29\xac\xa4\x66\x3a\xf0\xfb\x0e\xcd\x8a\x77\x3a\x52\xb6\xbd\xbe\x33\xc7\x35\xbe\x80\xbb\xe6\x5e\xbb\x8a\x69\xba\x77\x77\xdc\x2b\xeb\xca\x90\x0d\xde\x30\x64\x0e\x5b\x80\xc6\x83\x55\x2f\x3d\x5f\x64\xa1\xf1\x7f\x2c\x0f\xce\x81\xc7\xd7\x31\x11\xc7\x00\x73\xc6\x23\x8e\x13\x52\x3f\x85\xdf\x19\x1f\x81\x78\x82\x64\x3a\x87\x95\xf7\x4a\xed\x12\xab\xc3\xca\x57\x5a\x7c\x69\x05\x33\xbe\x7c\x4f\x3f\x76\x41\xd8\xa3\x77\xad\xf0\x97\x31\xea\xda\x8d\x9c\xf5\xe0\xe6\xa3\x1d\x27\xb9\xef\x1e\x3c\x08\x23\x3b\x65\x4c\x28\x23\xb2\xc7\x0a\xcb\x56\x71\xa4\x7e\x3e\xfa\x98\x1e\x9f\x67\xfa\x9f\x74\xe9\xf5\x41\x12\xd5\x39\x3c\x42\x10\x13\x48\x47\x0b\x22\x5c\xfb\xe6\x47\x26\x59\xa0\x89\xf6\x46\xe2\x9b\x00\x64\x81\x38\xd8\x16\x38\x60\xc6\xd0\xe1\xed\xcc\x72\x73\xbd\x7f\x49\x51\x97\x36\x9d\xcf\x76\x71\x0e\x5b\x30\xb1\x8b\x34\x30\x31\x6d\x51\x18\x77\xcd\xd2\x63\xd1\x17\x6e\x31\xf8\x33\xa0\x63\x55\x65\x5d\xfd\xcb\xeb\x5c\xa1\xda\x77\x36\xa7\x1d\x24\x34\x6c\xc7\xfc\xde\xc0\x34\x48\x48\xdf\x1d\x00\x72\x4f\x48\x58\x8e\xe5\x19\xe5\xe8\xd0\x42\xb9\xa2\x95\x2f\x05\xb4\xb1\x5d\x1a\x6f\xb8\xb3\xc3\x38\xb5\x75\x33\xe6\xe9\x20\x3d\x47\x44\xe3\x67\x2c\xc3\xcf\x60\x49\x75\x5b\x1d\x84\x4a\x11\x20\x2c\x28\x19\x3f\xfa\x1c\xa5\x2f\x0b\xa4\xcf\x36\x49\x25\xe5\x25\x65\x15\xa4\xf7\x79\xc3\xe6\x06\x38\xa9\x71\x19\x96\x14\x8a\xb5\x82\x0f\xb0\xf4\xd8\x90\xc7\x5f\xc2\xf7\x88\xa8\xa8\xe4\x88\x8e\xaf\xc2\xf2\x4a\xa1\xe3\xa8\xce\x50\x75\x60\xc9\x54\xf0\xa8\x14\x36\x58\xdd\xf0\x43\x23\x77\xed\x51\x0a\xbf\x1e\xd6\x63\x9a\x20\xf7\x29\xa3\x62\x42\x9d\x32\x3f\xa0\x04\x0c\x23\x51\xaa\x4e\x83\x5e\x58\xad\x73\x3d\x35\x7d\xfe\xb4\x68\x50\x12\x29\x28\x0f\x70\x44\x38\x38\x18\x51\xee\x74\xb4\x52\xcc\x6b\xa8\xd5\x8f\x1b\x89\x5e\x8b\xe0\x02\xcf\x47\x84\xa6\xf4\x4a\x73\x0f\x84\xdb\xc7\xcc\x0f\x9b\x72\x8e\x5f\x37\x21\xa4\xf7\x0c\xa6\xc5\x9f\x31\x1f\x53\x8b\x09\xbb\x12\x2c\x30\xc2\xae\xc4\xcb\x2e\x0f\x0b\x4a\x4b\xf9\xbc\x95\x38\xec\x9b\x98\xc5\xdf\x6e\x34\xfc\x00\xde\xc4\x4c\x2e\x6f\x58\xa6\x66\x73\x27\x94\x3d\xba\xc7\x5d\xa3\xfa\x91\x88\x59\xa6\xcf\x1f\xd5\xf4\x3d\xb7\x96\xbb\x87\xfd\xe9\xc8\x63\x66\x43\x47\x5e\x92\x66\x4c\xbe\x18\x10\xa4\x46\x25\xfd\x99\x01\x79\xc2\x9d\x85\x17\xa3\xdb\x7b\x49\x41\xeb\xc1\xe9\x7d\xa4\x23\xd5\x9b\x9a\xf5\xf9\x9b\xc7\x4d\x2b\x1a\x97\x6b\xcb\xab\xa6\x6d\x18\x3e\x28\xbb\x7b\xe2\xc4\xa4\xf0\x21\x8b\x36\x2e\xac\xd8\xf5\x8b\x7e\xf3\xcb\xf9\x55\xf0\x96\xdb\x5e\xea\x1c\x33\xb8\xcf\x7e\x50\x3d\xae\xb4\xc8\x66\x39\xda\x61\xc3\xae\x3d\x28\xff\xe1\x34\x62\x9b\xf4\xb0\x0b\xdb\x83\xca\x5f\x5d\xa7\x26\xb6\xba\x81\xb0\x7a\x63\x88\x30\x01\xcf\x37\x56\xe3\x09\x70\xcf\xa2\xf4\xbf\x89\x6a\x38\x3d\xb5\x2b\x81\xe7\xf1\x74\x14\x60\x03\xc0\xdb\x13\x99\x47\x3c\xb4\x5c\xb3\x85\x16\xb0\xd1\x0d\xb7\x55\x58\x3c\x4b\xc3\xe8\xfa\xc1\x4f\x28\x2c\x6c\xdb\x3c\xff\xa4\xeb\x28\xd7\x85\xae\xcd\xf0\x63\x8c\x4e\xb0\x55\x44\x0f\xa4\xf8\xa9\xe4\xb5\xd4\xd7\x56\x91\x0e\xe5\x12\x18\x0d\x1c\x56\x8f\x2c\xac\x78\xc3\x70\x82\x5b\x81\x53\xdc\xd7\xd0\x85\x30\x90\x3d\xfd\xf0\xb4\x4e\xeb\xb6\xa1\x57\xb9\x6b\xa8\xbc\xdf\x62\xf7\xa1\x83\xf9\xfb\x01\x1c\xb1\x62\x39\xc5\xbf\x6f\xba\xc5\x4d\x11\xd7\x32\x5a\xc6\x7a\x4c\xad\xea\x28\x03\xf9\x78\x7a\x7b\x30\x62\xac\x73\x64\x24\xb1\x87\x0b\x7e\x96\x6d\x14\x37\x8b\x0e\xc8\x88\x1c\xa9\xad\xb4\xec\x91\x37\x90\xba\xaa\xa1\x3f\xe8\x05\xfa\x2b\xda\xb9\x7f\x41\x33\xa3\xef\x81\xfc\xd3\xec\x82\xad\xb0\x14\xf5\x40\x8f\xdb\x38\xd0\xa7\xc8\xbf\xf6\x9d\xbc\x5f\x40\x28\x5d\x43\x21\x14\xff\xea\x1a\x66\xc5\x1f\x73\x07\x65\x02\x77\x10\x8f\x03\x18\x8f\x55\x6e\xe6\x2e\x1a\x08\x3a\x45\x92\xc2\xa9\x10\xd9\xfb\x8f\xdb\x61\xa5\xba\x7f\x43\xeb\x4e\x3c\x04\x8b\xa8\xd1\xb9\xb6\xed\x70\xc1\x50\x50\xf8\x78\x09\x8c\xec\x99\x44\x6d\x0e\xed\x3f\x52\x8d\xf5\x2a\x98\x49\x39\x61\x0a\x92\x04\x74\x54\xe3\x11\xf4\xf8\xc9\x0c\xa3\x16\xe4\xd9\x0b\xab\xb2\x54\x50\xe5\xdc\x16\x0d\x7e\x3c\x7d\xb7\xf1\x06\xe0\xb1\x75\xe1\x62\x02\x6e\x42\xba\x1e\x98\x32\x01\x9b\xf1\xd2\xa6\xd0\x19\xee\x7d\x56\xb0\xb3\xaf\xa5\x77\xd1\xcc\x1b\xb3\x3f\x78\xf3\xeb\x6e\x3d\xb7\x5d\xcd\x2d\x3b\xc5\xdd\xdb\x77\xb4\x6a\x8b\x7b\xc9\x41\x50\xbf\xaf\xb4\xa2\xe4\x3f\xe8\xba\xfb\x77\x18\x78\x68\x01\xa8\xbd\x36\x73\x04\xbf\x66\x8b\xf0\x99\xa7\x47\xcb\xf5\x5d\x20\xac\x6f\x40\xd4\x0b\x5d\x6e\xe0\xae\xfd\x45\xe3\x1d\x0c\x5e\x86\xec\xeb\x1c\xe9\xfd\x14\x7e\x4c\x21\x17\xa4\xa5\xa0\xd2\x82\xcf\x90\x96\x40\x2e\xbd\xec\xe6\x6f\x8a\x03\xdd\x7b\xad\x60\x57\x79\x48\xc7\xdc\xa3\x61\x07\x67\x57\x67\x04\x1e\x84\xda\x55\xdd\x7a\x75\x3a\x98\x54\x51\xdc\x87\xc7\xd9\x2b\xc6\x6b\x70\x33\x5d\xe3\x56\x26\xf2\x84\x16\x3f\xda\x67\x7f\x94\x0b\x06\x5a\xee\x59\x83\x02\xf0\x99\xa0\xcb\x90\xb1\xf2\x49\x18\xe4\xf4\x0f\x7d\x57\x64\x8d\x15\x26\x7e\xff\xa9\xad\x13\xba\x88\xfe\xb8\x79\x2e\x73\x44\xd2\x9e\xc4\x9e\xa9\x95\x33\xa6\x6e\x29\xeb\xbe\x6a\x0d\xb6\xa9\xfb\x8e\x67\x37\xa0\x57\xd0\xe5\xc6\xd7\x67\x03\xf3\x8f\xc9\x59\x77\xd1\xa7\x3d\x16\x55\xf7\xab\x07\xc3\xb3\xab\x86\xd1\x3d\xea\xf5\xa6\x7b\xdc\x7b\x98\x2e\x25\x63\xa8\x67\xfd\x80\x9f\x42\x0c\xe8\x4a\xb4\x0b\x16\x2d\x82\xb5\xeb\x52\xb5\x3a\x3b\x64\x38\x91\x23\x0c\xec\x3b\x72\xed\xf9\x1d\xd7\x0a\x2f\x0c\x41\xef\x21\x3d\x1a\xd3\x1a\xe8\x3f\x60\x7f\x7f\x5c\x54\x06\x76\x81\x5d\xa8\xb5\xfb\xd1\x9f\x86\xd7\x79\x9b\x86\xcf\xb5\x58\x37\xc8\xfa\x8a\x3c\xa6\xd6\x36\x80\xbe\x75\x2e\xb5\x5a\x27\x39\x87\x67\x41\xc7\xa8\x28\xb7\x3a\x8f\xde\x7b\x76\x23\xdf\x0a\x43\x92\x2f\x66\xd5\xc1\x6b\xf7\x6f\xe8\x6e\x37\xdc\x26\xb6\xfc\xdf\x9d\x7f\xb3\xa2\xc2\x05\x44\x11\xfb\x0d\x79\x74\x94\x2b\x2c\x8a\x98\x50\x86\xf6\x1d\x84\x47\xc8\x78\x81\x82\x0d\x0d\x60\x92\x8f\x05\x40\x3c\x5e\xbd\x2b\x20\x40\xc9\xb2\x26\x41\xcc\x2c\x1e\x4c\x29\x0c\xac\xf4\x4e\xa7\x37\x33\x96\xf4\x45\xf7\x08\x9b\xcc\x70\x98\x87\x0a\xd8\x85\x0c\x0a\xde\xfb\xe2\x43\x6b\x26\x3a\x82\x1e\xa0\x21\x61\xe0\x00\x98\x59\x60\x5e\xfe\x3c\xfa\x3e\x1b\xbe\x89\x87\x6f\x3c\xdd\xf7\x28\xba\x85\x3e\x3e\x08\x0e\xac\xec\x5a\x33\x0b\xed\x23\xf4\x60\x3f\x9d\x3b\xc7\x91\xb8\x4e\xc0\x49\xa3\x52\x09\xfc\xa5\xa7\x89\x42\x51\x25\xb4\xf3\x3e\xb9\x60\xb2\xe2\x81\x1d\x6b\x91\x84\xde\x25\x11\xc8\x2f\x70\xb4\xa1\xce\x2f\xad\x4b\xce\xc7\x93\x52\xb8\x95\xcb\x12\xba\xbc\x56\xe0\x7c\xf8\x0d\xd6\xe6\x5d\xe9\xa9\x3d\xce\x6f\xd8\xfc\xf8\xe2\x80\xdc\xf0\xad\x87\xff\x44\xdf\xde\xbe\x13\xc3\xcb\x1a\xbb\x6d\xdc\x01\x3c\x96\x86\x89\xa8\x53\x8b\x81\x1c\x3b\x8d\xbd\x4f\x68\x20\x80\x67\x7c\xb4\xd7\x53\x12\x9e\xc6\xab\x30\x5e\x06\xfc\xed\x15\x1e\x51\xc7\x7e\xfa\x38\xdf\x0a\xaf\xb9\x1b\xee\x83\xc0\x7e\x25\x11\x1d\xcf\x3b\x53\xd7\xac\xf9\xfe\x20\x67\x75\xff\x1d\x3e\xef\xb9\x7b\x77\x5f\x3b\x9c\x82\xf2\xf9\x38\x1f\x83\xf9\x5a\x4f\xd7\x95\x81\x89\xac\x63\x59\x4e\xe9\x87\x0d\x5a\x1e\x5e\x28\x05\x0c\x87\x0f\xc1\xcd\x9b\xbd\xe7\xfa\x9b\x84\x88\x6c\x66\xbe\x6f\x1b\x64\x24\xc4\xa2\xf1\x06\x74\xfb\xd7\x0d\xf7\xad\x50\xfc\x5e\xe3\x3b\x68\xdd\x83\xe8\x03\x00\xae\x18\x55\xe5\xfe\x99\x0d\x79\x34\x8c\xdb\x0e\x8e\x54\x2f\x7b\x0d\xcd\x40\x97\x87\xdc\xea\xf2\x2d\x30\x2f\x29\xc8\x21\xfb\x00\xe6\x53\xdb\xbc\x0f\xe4\x3e\x6b\x1f\xb0\x3e\xb9\x0f\x4c\x6d\x5c\xee\xd9\x07\xb0\x3d\x83\xef\xd1\x5d\x80\xd8\x32\x5e\x76\x9b\x9b\x7e\x17\x25\x52\xbd\x69\x7b\x8c\x91\x63\xbf\xa9\x1e\x9b\x2d\xa3\x86\x33\x9d\xc3\xcf\x34\x62\x2b\xd0\x0f\x3f\xdf\xe8\x51\x18\x6f\x4f\x5d\xbe\x3f\x08\xde\xeb\xfd\x93\xf8\x97\x72\xc0\x59\xfd\xed\xa0\x70\x7a\x65\xab\xa2\xf3\xc5\x49\x13\xea\x2a\x1b\xbf\xd8\xd2\x79\xdf\x6b\x7b\x4a\x3e\x45\x9b\xd1\x2b\x0d\x70\x58\xe0\x73\x8b\x41\x17\xd4\x70\x6c\x5f\x5f\x1d\xfa\xa1\xf4\xee\x7b\x50\xe9\xfe\x1b\xaf\xa2\x4f\xab\xb9\x0f\xf0\x3a\xbc\x20\xd8\xec\x10\xa6\xcd\x09\xb9\xc9\x14\xc0\x4f\x9d\x09\x3b\x51\xfe\x00\x82\x33\x5e\x03\xee\x73\xb1\x4a\x83\x82\x56\xdf\x55\xd3\x16\xb0\xa4\x99\xa4\x83\xe2\xf4\x83\xfe\xe7\xc2\xa0\xe9\xcb\xf7\xb4\xc4\x31\x98\xb7\x71\xfb\x44\xdb\xb8\xbd\x3b\xe4\x61\xfe\x39\x45\x0e\x13\x36\x0d\xdb\x8f\xe4\x0d\x25\x2e\x42\xcf\x84\x89\x23\xdc\xa7\x4f\xde\x70\x1d\x4c\x1c\x45\xfa\xa4\x34\x35\x31\x37\x30\x2d\x93\xb9\x6b\xda\x48\x11\xd7\x94\xc9\x30\x1a\x89\x88\x03\x1d\x18\xfa\x3b\x92\xe1\x2c\xfc\x4e\xda\x04\x9e\xfc\x1d\xec\xc2\xf5\x68\xf1\x3b\x29\x60\x18\xfe\x3c\xa4\xe2\xc4\xec\x63\xbc\x07\x92\x3b\x2f\x00\xe9\x79\x88\xdc\x79\xd9\x80\x1d\x6e\x5c\x0a\xc4\x0f\x38\x31\x9c\x45\x62\x13\xf1\x9c\x98\xbb\x4b\xdf\x27\x61\xd4\x27\x44\x40\xcc\xbf\xd7\x4e\x21\x96\x49\xed\x0c\x29\x3b\x6e\x58\x82\x3f\x31\x10\x7f\xf9\x86\x7c\xcc\xbd\x80\x7c\x94\x76\x0d\x63\xd8\xaf\x68\x0f\x71\x39\x13\xec\x54\xc9\xd9\x7c\x97\x4c\x2c\x97\x8b\xc4\x6a\x20\x32\x08\xe5\xcc\xda\x34\xbe\xb5\x07\xcd\x0f\x51\x40\xf6\xab\x83\xe9\x68\xea\xd1\x57\x60\xf9\x81\xd4\x4e\x3f\x83\x14\x74\x8d\x4b\x77\xcf\x03\x37\x90\x9d\x81\x4d\x6b\xf0\xf9\x41\x43\xeb\xab\x74\xa4\x07\x29\xa9\x5e\x97\x2b\xf3\x5d\x3a\xb9\x58\x23\xd7\xc8\x81\x98\x64\xc8\x88\xd5\x22\x03\x50\x51\x40\x70\xc1\x7b\xf2\x24\x1b\xf9\xf3\xa0\x85\xd1\xb4\xb7\x27\xf0\x20\x58\x5a\x09\x0b\xdc\x00\x77\x63\x47\x74\xfb\xfd\x8b\xf0\x5d\x78\xc4\x8c\x16\x66\x82\x3e\x66\x74\xb8\x33\x58\xeb\xd6\x7c\x3b\x38\x00\xf4\x42\x75\x04\x38\xf1\xc2\x52\xb4\x17\xf4\x04\x1f\x93\xb8\x4a\xd3\x5f\x78\xff\xf8\x95\xcb\xa5\xf7\x3b\x4e\xa6\x8b\xb3\x75\x70\xbb\xc8\x76\x04\xc2\xae\xc0\xd5\xb6\x7d\xbe\x2b\x22\x34\x32\x59\xa2\x6c\x9b\x8c\xff\xc8\x6d\x91\xc6\x78\x4e\xce\x91\xd6\x71\x1a\x5f\xa0\x79\x12\x30\x4d\xe3\xdb\x3a\x79\xf2\x12\x3d\xb9\x4f\x5a\x92\xd9\x20\x9c\xf0\xd4\xb0\xb9\x43\xac\x80\xdc\xef\x9f\xec\x00\x3c\x8a\x8b\x9a\xc0\x14\x03\x12\xc6\x27\x6f\x82\xb1\x86\x79\x3d\xc7\x5a\x6a\xab\x7e\x9b\x35\x45\xb6\xf2\x4a\xf9\x98\x5b\x6f\x1d\x50\xa8\x93\x52\x7a\x14\x06\xee\x8d\x6f\x5c\x7e\x34\x66\xc2\x2e\xb7\x8d\x6b\xd3\x26\xc6\x39\xa5\xaf\xda\x7f\xd6\xd2\xe9\x8f\x3f\x2a\x98\x6b\x45\x1b\x14\x31\xb0\x73\x55\x97\x37\x8b\xbb\xc5\x02\x66\x52\xd5\x83\xca\xc9\x9f\xfc\x8b\xe3\x32\x7a\x25\x76\x6c\x57\x38\xd0\xff\x85\x55\xcb\x96\x81\xec\xf1\xfb\x80\x28\x2d\x7b\xd0\x96\x42\x17\xc7\xae\x76\xd7\x1f\xd9\x9c\x9b\xd1\x65\x06\xd6\x8a\x6e\x58\xff\xa6\xd0\x7e\xe5\xc1\x14\x4b\xd2\xa2\x30\xe8\x49\x45\x81\xd4\x22\x34\x5b\xd6\x42\x18\x42\xb0\x48\xb5\xc6\x7c\x97\xd6\xf0\x64\x99\x41\x73\x9b\x05\xbb\x60\xef\xf1\x31\x94\xd6\x9c\x10\xe8\x5a\xd2\xc1\x91\x88\x44\xe1\x41\xbf\x1c\x3e\x75\x30\x78\x65\x77\xc3\xe4\xfd\xe6\x65\xc6\xa0\xef\xbf\x40\x49\x83\xa7\x82\xe8\x8e\x40\x35\xbf\xe6\xe2\xf1\x8e\x3f\xcd\xab\x1d\x34\x0a\x0e\x03\x1f\x3d\x37\x7d\x61\xd1\xd2\x80\x9e\xd1\x3b\x0f\x81\x8f\xd0\xd1\x92\xd1\x8b\xc1\xc7\xe8\xd8\xb0\xd1\xce\x6c\x21\x2f\x67\x14\xc9\xe9\x60\xba\x70\x44\x47\xdb\x63\xfa\x73\xa9\x8e\x6a\x48\xbc\x57\xe4\x47\x5a\x89\x71\x58\xab\x38\x43\xb3\xbb\xa9\x61\x88\xd6\x84\xb1\x74\x45\xdb\x93\xb4\x5c\x2e\xda\x86\xce\xa3\x35\x37\x41\x05\xb8\x79\x7a\xcd\xee\x86\xad\x67\xbe\xf8\x1e\xbe\x84\xce\xa2\xcd\x5c\x3a\x1a\xb6\x62\xc1\xe3\x4f\x81\x82\xb7\xcf\x3a\xe1\xf9\xa4\xff\x07\xc9\x3e\xa4\xf8\x29\xfe\x82\x6c\x64\x10\x6a\x88\x6c\x64\x86\x7c\x1f\x34\x95\x16\x3d\x9e\x79\xc9\x84\xf9\x53\x12\x6c\x11\x3c\x05\x24\x73\x3b\x49\x1b\xb7\xc8\x45\xc6\xe7\x49\x29\x5e\xc4\xd6\xae\xdd\xd5\x90\xf9\xb3\xf9\xe7\xce\x67\xbe\xfa\x0e\x4e\x04\x57\xd1\x04\x42\x10\xf8\xba\x7e\xf9\x42\x74\x91\xe8\xae\x0a\xdb\x57\xec\x28\x72\x29\x94\x9e\x38\x67\x20\x59\x30\x42\xae\x14\x80\x50\x44\x48\x01\xf2\xe6\xb5\xd3\xa2\x77\x2f\x91\x80\x67\xcd\xb0\xb3\x1f\x3f\xb8\x09\x9b\xcc\xee\x93\x99\xb0\x95\xd9\xfd\x49\x67\x58\xe6\x59\x20\xb4\x3e\x00\xcb\x18\x73\xcd\x44\x11\x8e\xad\x2a\xa5\x8a\x88\x53\x65\x32\xa9\x38\x96\x09\x0a\xc2\xca\x11\xa4\x61\x24\x2d\x8b\x4e\x5a\xe4\x5b\xb6\xa8\x44\xb2\x3d\x23\xf9\xd2\xd3\x78\x0b\xdc\xdb\x7f\x58\x7f\x40\x56\x31\x72\xe2\x12\x9f\xde\x5a\x25\xa0\xd7\xda\xa3\xf9\x4b\x0b\x41\xf9\x9c\xca\xdb\xfa\xea\xda\x98\xdc\xfe\x95\x23\x9a\x5b\x66\xd1\xac\xcb\xd9\x79\xb4\x49\xd6\x98\xfd\x43\xf0\x1c\xd5\xa3\x0a\xbc\x5f\x93\x1a\x04\x25\xa9\xdc\x51\xfa\xf5\x19\xa4\x94\x91\x7c\x2c\x3a\x37\xe2\xfc\x27\x91\x6e\xda\x7a\xd3\xb1\xf0\x5f\x92\x92\x01\x93\xd0\xfc\x60\xf6\xc3\x60\x34\x70\x0b\xc8\x0a\x46\xca\x1d\x11\x6f\x45\xb0\x87\x56\xae\x7c\xfc\xc5\xca\x9b\xaf\xbd\x46\xf7\xb5\xd9\x4d\xdf\xb3\x6f\xe0\x31\xb4\x44\xcb\x88\x40\x54\x6a\xda\x20\xda\xe8\xd5\x32\x51\x98\x7f\x8a\xc3\x93\x83\x86\x37\x12\xec\x7b\x80\xd5\xe8\xfb\x3d\xdd\x3a\xe6\x4d\x36\x55\x3d\x34\x83\x5d\xeb\x42\x3f\xd5\x03\x83\x34\x52\xdb\x6f\xc0\xa8\xc9\x70\xf8\x32\xb7\x68\xe7\x09\xb2\x3f\xcc\x23\x18\xcd\x34\x7f\xe6\x6f\x46\xe8\xef\xc5\xce\xa4\x58\x67\xe1\x4e\x0d\x94\xca\x58\xfc\x87\x20\x68\xf8\x35\x4f\xad\x07\x46\x90\xce\xab\x24\x8b\x44\xad\x1c\x6a\x7c\xde\x60\x4b\xdc\x55\x05\xcb\x42\x97\x0d\xab\xeb\xfd\xb1\xe5\x4e\x4f\xf0\x01\xd8\x31\x62\xc7\x08\xf0\x18\x4d\xdc\xb1\x63\x07\x9a\xcb\xef\xd1\x12\x3c\xde\x65\x8a\x83\x17\xe4\x54\x1a\xa0\x1f\x2b\x56\xab\x25\x6a\x2d\x10\xf3\xcd\x0d\xb3\x68\x7a\xbd\x55\xa8\x66\xb4\x0a\xd5\x8c\x56\x8a\xaf\x0c\xfb\xbe\xd8\x87\x0b\x5f\x70\xe4\x26\x08\xb0\x2b\xb8\xd8\x7e\x00\x1f\xdf\x6f\x1e\x5e\xa0\x0d\x67\x57\x45\x5e\x74\x0f\xc4\xc6\xfe\xdd\x89\x73\x72\x17\xd6\xc3\x84\x47\x97\xe1\xa1\x61\xf3\xe8\x78\x79\xf4\x5c\x43\xf8\x31\x38\x65\xac\xdc\x8f\x53\xaa\x25\x7e\x9e\x4c\xf6\x34\x2f\x5a\xb8\x80\x14\x0e\xde\xe1\xb1\xc1\x6f\x1e\x12\x60\xc1\x3d\x50\xe0\xf8\x89\x02\x0c\xb8\xa7\x9e\x88\xd6\x1a\x16\xd2\x3d\xb6\x8c\xaf\x0b\xd4\x8a\xa1\x81\xae\xdb\xd6\x4c\x22\xb7\x8b\xfd\x13\xef\x5c\x01\x8c\xdf\x09\x9d\x58\x41\xee\x4e\xa9\x97\x48\xa0\xce\x18\xba\x22\x45\xe1\x2a\x21\x07\x18\x2b\x28\xbc\xf0\xeb\x8f\x68\x1f\x5e\x71\x24\x96\x9d\x34\xef\xd5\xa9\x8e\xd3\xe7\xff\xf3\xe7\xab\xec\x9f\x97\x1b\xd1\xb7\xe8\x1d\x30\x1b\xef\x96\x51\x67\xa3\x72\x6b\xc7\xcc\x9c\xbc\xff\xf4\xec\x89\x98\xaf\x48\x66\x2c\xb7\x83\xfd\x17\x1d\x81\xf1\xc3\xa4\x90\x3e\x01\x78\x04\xd2\xa7\x82\xe4\xb5\xa5\xe0\x71\x78\xd8\x2e\x07\x6d\xd6\x0f\xb7\xa3\xe0\xbe\x45\x09\xb3\xd6\x81\xc1\x20\xe3\xc1\x5f\x9f\x9f\x35\xce\xa8\x39\xcc\x86\xa3\x73\x3d\x47\x2a\xeb\xd5\x27\x96\x01\x31\x08\x7b\xad\xfe\x32\xfa\x39\xbc\x51\xb7\xb1\x6a\x62\x39\xb9\x23\x89\x6e\xfa\x90\xdb\xcb\x15\x53\x8c\x73\x1b\xa9\xcd\x30\x86\x9a\x2c\x5c\xb0\x3e\x58\x22\x15\xa9\xb5\x9c\x5c\xef\x4f\x18\x4b\x8a\x37\xa5\xd9\xf1\x01\x83\x4c\x1c\x8f\xb4\x4e\xe0\xae\x09\x0a\xb6\x98\xde\xa9\x46\x26\x39\x28\xda\x02\x08\x97\xd0\xeb\x5a\x28\xff\xed\x87\x43\xa5\x61\xc7\x37\xdf\x07\xf7\xf2\xfb\x0f\x08\x3b\xb0\xf6\xc6\x73\xa5\x28\x66\xc9\xab\x20\xe9\xb9\x81\xe0\xd6\x73\xa7\x93\x2e\x37\xfe\x7d\xa0\x6c\x7f\x43\x1f\x34\x7f\xca\x9d\xa2\x41\xfb\x0f\x17\x9c\x35\x81\x2f\x8b\x8f\xce\x9e\x08\x7b\x07\x20\x4b\xf1\xd1\x99\xf4\xce\x84\xf6\xb7\xe1\xde\xc6\xb6\xc2\xc2\x44\x33\x89\x8c\xc3\x19\x12\xde\x26\xb0\x4d\xbe\xcb\x12\x97\xef\x32\x05\x4a\xfc\x2c\x16\xb9\x21\xd0\x18\x49\xb7\x4f\x55\xcb\xed\x33\x3e\x2d\xad\x39\xa1\xdf\x67\xe3\x14\xf6\x4d\x9f\x66\x2d\x0e\x9a\x36\xa1\xf5\x27\x59\xf1\x9e\xbd\x12\x6a\x8c\x53\xd2\x87\x87\xd5\x4e\xfe\xea\x54\xec\xb4\x53\x53\x6a\x26\xbd\xbf\xb2\x31\xae\xea\x95\x29\xb3\x5a\xc1\x89\x8e\x0e\x8b\x36\x4e\x5e\xba\x01\xcd\xe9\x5e\x65\x45\xaf\x2a\x61\xe7\xca\xc2\x73\x7d\x0b\xf1\xde\x78\xea\x54\x43\xe3\xa7\xe8\xa5\xb3\xc7\x8e\x6d\xdd\x52\x79\xe8\x97\xc9\x15\xa0\x3f\x08\xf8\x0e\x1d\x75\xff\x79\x74\x63\xff\xac\x13\x44\x6f\x0e\x61\x7e\x7a\x60\x5d\xb5\x32\x31\xa4\xfa\x97\xd3\x59\x5a\x15\xba\x74\x16\x8b\xc2\x1a\xa0\x56\xb4\x29\xf0\x02\x8e\xf0\xc0\x08\x3c\xf1\xcd\x06\x4d\x68\xc7\x98\x05\xf8\xbb\x65\x2f\x32\x47\xb2\x90\xda\x98\x94\xca\xf5\x08\x3a\x56\x0d\xca\x67\x4e\xf9\x74\xc3\xee\x97\x87\xee\x1d\x0e\x4a\x47\x4b\x1b\x64\xb9\xdd\x8b\x67\x06\x17\x37\x3c\xb7\xa9\x74\xc0\xc2\xf5\x5c\xfa\xfc\x53\x01\x9c\x66\xd3\xd4\x65\x1f\x4e\xdf\xb5\xbe\xf2\xfc\x0c\x7f\x2e\x60\xf1\xf0\xc8\xb6\x49\xf1\xf9\xfd\xe7\x2c\x71\xaf\xbc\x50\xbf\x65\xd8\xc8\x7a\xac\x7f\xf3\xa0\x85\x2b\xc1\xb2\xd7\x90\x75\xc5\xc8\x14\x14\x10\x45\x23\x54\x34\x79\x6f\xe6\x49\x07\x0d\xad\xe0\xd6\xae\x30\x8c\x99\xb9\xfd\x64\xdb\xb3\xe3\xc0\xd7\x6f\xbe\x6e\x80\x96\x8a\x5e\xb3\xa7\xbe\xfd\x29\x4c\x38\xd6\x58\x54\xc1\xdb\x86\x09\x84\x7f\x68\xe1\x9f\x29\xd5\x28\x7c\x40\x56\xf8\x67\x7a\x78\xb2\x0b\x90\x2a\xc0\xa9\x1f\x5f\xf9\x62\x5d\xdb\xb3\x13\x50\xd0\xc5\x4b\x7a\x68\x19\xd9\x7d\x4e\xcd\x8d\xcf\xdc\x6f\x5f\x3c\x5d\x58\xc6\xef\xa1\xc3\x84\x3e\xb4\xa4\xf7\x6f\x88\x53\xad\xc4\x3b\xa8\x52\x09\xb1\x7b\xeb\x47\x41\xce\x7d\xce\xac\x56\x21\x1c\x87\x25\x69\xd5\xb1\x02\x30\x30\x30\xd6\xdd\x04\x6f\x6f\x3c\x3f\xe3\xe3\x85\xe8\xeb\x91\xbd\x80\x6a\xf6\xca\xd2\x62\x2e\x7d\xdd\x9c\xaa\x57\x4a\xa0\x0a\xcd\x9c\x53\xd1\xbd\x80\xd6\x92\xbc\x8b\xc7\x29\xc2\xe3\xf8\xe1\x71\x42\x9d\x1a\x1d\x53\xe0\xd2\xe9\xa4\x0a\x68\x90\xaa\x0a\x5c\x52\x75\x8b\x58\x2d\x29\xd5\xe1\x1b\xb1\x90\xc3\x94\x2d\x8c\x22\x12\xc1\x78\x34\xee\x1a\xa8\xbb\x8c\xbe\x07\x47\x6f\xd6\xb9\x86\x7e\x87\x3e\x29\x1e\xe3\x26\xad\xe1\xc1\xed\x36\x57\xea\x4f\x3f\xba\x0c\xae\x82\x9f\xbf\xea\xd6\xad\x99\xaf\x22\xde\xae\x91\xf1\x94\xea\x02\xcc\x17\x07\x14\x6a\x4e\x5f\xe0\xf5\x3f\xbc\xa8\x04\x76\xd6\xca\xa7\xbe\xb2\x76\x9d\x89\xea\x43\x06\x60\x7b\xba\xea\x6e\xa2\xfc\x53\x67\xf7\x6e\x78\x7c\xed\x8b\xaf\xdc\x8b\x97\xdc\xa5\x5b\xff\xa3\xcb\xb3\x67\xae\x39\x6b\x01\xb7\x51\x6a\xf5\x98\x69\xeb\xf0\xe1\x0c\x3b\x3b\x14\xd3\x53\x42\xf2\x06\x44\x06\x56\xc2\x48\x0a\x78\xc0\x52\x21\x08\xec\x01\x3f\x03\x21\x6c\x59\x20\x3a\xd0\x58\xd7\x88\xf0\x9e\x38\x8f\xf4\x5d\x27\xf6\xb1\x1a\xcf\x6b\x09\xd9\x63\xd8\x69\x42\x2c\xbd\x88\xbb\xca\x9e\xc3\xe7\x7c\x6d\x3d\x13\xa8\xf5\x97\x4a\xfd\x18\xd2\x66\x8a\x5a\x30\x9d\x20\x79\x72\xe8\x73\x48\x48\x38\x5b\x70\xe9\xe4\xf0\xc8\xc9\x35\x6b\x57\xb8\x57\xd8\xd8\x3e\xe7\xda\x58\x45\xb1\x69\x79\x20\x3b\xff\x5f\xdf\xbb\xe3\x81\xb2\x76\xf5\xe8\xea\x3a\xf1\x41\x00\x59\xc8\xb6\xa9\x1e\xf6\xc5\x65\xea\x67\xff\x0b\x8f\xf3\x0b\x1e\x27\x00\xfb\x97\x61\xd8\x7e\xa9\xc3\x42\x02\x83\x43\xf0\x1f\x19\x13\xa0\x94\x4a\x65\x74\xd0\x78\xc1\x9b\xe6\xef\x0e\x9e\x18\x5c\x62\xe0\x3b\x21\x10\xb7\x49\x87\xff\xfe\x0d\xbe\x26\x34\xa0\x7e\x36\xb8\x8c\xd2\x90\x9e\xb7\x0e\x53\xf0\xc7\xc7\x0d\x61\x0d\xe3\xf0\xdf\x96\x94\x0c\x3a\xf2\xc5\x65\x90\xb9\x1b\xc6\xee\xa5\xfa\xdd\x54\xdf\xe4\x12\x49\xb8\xdf\xb0\x6f\x13\xe2\xf4\x0b\x88\x8a\xc2\x4e\x5c\x58\xa8\xbf\x2f\x21\xf1\xff\x40\x05\x0f\x45\x2d\x10\xe3\xf0\xfc\xba\x10\x1e\x39\xb1\xf2\x85\xd5\xcd\x12\x49\xcf\xeb\x52\xb8\x64\xe1\xfa\x3b\xdf\xba\xe3\x6d\xf0\xc8\xf1\x95\x9b\x97\xb9\x57\xc0\xd9\x13\x6a\x4a\x27\x9d\x10\x48\x8a\xac\x1c\xbc\xf1\x58\x38\xdb\xe7\xc8\xf5\xba\xe3\x93\x6a\xca\xc6\xd2\xfd\xeb\x08\x9e\xdf\x87\xd4\x07\x70\x3d\x9d\x53\x8b\x7f\x6e\x83\x7f\x3f\x91\xfe\x3c\x84\xae\xd3\xb9\xa4\x0e\x96\xe2\x36\xb4\xe6\xeb\xc3\xf3\x5d\x06\x4e\xa5\x62\xb4\x6a\x5f\xd7\x8c\x18\xa9\xff\x59\x1e\xce\x81\x07\x82\x1b\x56\xb9\x6a\xc6\xe2\x04\x33\x98\xe8\xfe\xc6\x0c\xbf\x0d\x42\xa3\x97\x6d\x41\x6e\xde\x01\xab\x1d\xd5\x27\x6f\x09\x88\x5e\xb6\x08\x5d\x84\x0b\x66\x9f\xb8\x45\x69\x38\xd9\xf4\x6f\xce\xc4\xf5\xc2\xb2\x24\xb9\xfb\x20\x4a\x2f\x03\xfa\x90\x10\x3d\x90\x71\x4a\xab\xd5\x4c\x80\x80\x68\x59\xce\x53\x6e\xa2\x27\xcf\xc4\x63\x14\xbd\xad\xc6\x49\x12\x8e\x07\x26\xdf\xa7\x7e\x04\x1e\xcc\x58\x34\x33\xaf\xf7\x8e\x01\xfb\x32\xbe\xd9\xb0\x66\xdf\x6b\xeb\x02\x32\x16\xce\xce\xef\xb5\xab\xef\xbe\xb4\x6f\x36\xad\xd9\x57\xb4\xad\x14\x1c\x1a\x32\x28\xb5\xfb\xcb\xfa\x95\x6b\x67\x4d\x5c\xf2\x92\x64\xf6\xe0\xc1\xe4\xa7\xe5\x2f\x54\x57\x0c\x5c\x9e\x47\x70\x2c\x9b\xae\x62\x79\xf5\xe7\x7a\xe3\xf3\x1e\xf6\xa9\xa2\x02\x15\x0a\xc6\x5f\x13\x22\x21\xb2\x6a\x45\x84\x95\xc4\x2f\x23\x52\xa7\x45\x6e\x77\xbd\xb2\xca\x02\x91\x7c\x1e\x8c\xe0\xb7\x0a\xb0\x26\x3c\xc1\xf1\x24\xb3\xed\x54\xff\x31\xb1\x15\x41\xf9\xb1\xe1\xbd\xc3\xaa\x26\x14\x7c\xf7\xfe\xde\xdd\x31\xd9\xfd\xea\xb2\xb5\x1d\xc3\x63\x87\x47\x77\xea\x3c\xb7\xc8\x35\x2e\xb2\x75\xd7\x9e\x8b\xf5\x8e\xac\x29\x91\xc9\xe1\xb6\x79\xc7\xe7\x4e\xdd\x7b\x7e\xc1\x94\xac\xf1\xa5\xfd\x8e\xcf\xb3\x85\x27\x47\x4e\xc9\x6c\xd7\xa3\xa8\x5f\xbf\x81\xdd\x88\x4c\x7f\xc1\x8b\xe6\x3e\x9e\x57\x11\xe3\x7f\x8a\x33\x88\x60\x81\xb7\x33\x32\x5f\xf5\x69\xd3\xb1\xf7\x03\xd1\xda\x46\x02\x27\x82\x17\x37\xf1\x85\x3c\x7d\xce\xb1\xef\xd3\x9b\xce\x0b\xc1\x35\x1a\x47\x6d\x85\xde\x29\xc3\xa7\x4f\x09\x57\xe0\x92\xa8\x9b\x2f\x3e\x04\x34\x5c\x6e\xdc\x4d\x6c\x24\xe2\xe9\xa3\x1e\x5d\x26\x38\x77\x1c\x9f\xcf\x2d\xd8\x6b\xad\x58\xe4\xa0\xcf\x6b\x4d\x70\x0f\x68\x8e\x7a\xa8\x53\x6d\xc6\xdb\x1d\x69\xbc\xa7\x32\xa8\x25\x7c\x83\x8a\x96\xfd\x66\x49\x41\x88\xe7\xa2\x43\x27\x20\x92\x63\x4f\x92\xb3\xb1\x60\x4f\xfb\x2b\x0f\x81\x34\xe7\x70\x7b\xd9\xfa\x25\xb3\x8f\xcd\xde\x7b\x2b\xb4\xfd\xe1\x9c\x80\x9d\xa8\x69\x6b\x7b\x90\xda\xb8\x35\x22\x12\x0c\x47\xd7\x63\xa2\xa6\xd7\xc0\x1a\x77\xed\xe1\xed\x20\x19\x6d\x9b\x79\x76\x0c\xba\x4a\xf3\xe4\xf1\xfc\x2d\xa2\x18\x8d\x16\xa7\xc6\x1f\x8b\xc5\x5f\x2d\xf7\x93\xe0\x0d\x44\x62\xe4\xbb\x64\x78\x2e\xfd\xac\xcf\xca\x88\x6f\x7a\x16\x00\xcf\xad\xa7\x90\x77\x08\xe4\x24\xb6\xeb\xeb\xc0\x77\x5c\x1a\xed\xc5\xa1\x64\xcc\x27\xa1\x5c\xce\x49\x45\x67\x40\x0c\xcd\x0d\x8d\xf3\x14\x60\x52\x41\xd2\xa8\x87\x0e\x88\xf1\x8b\xd6\xec\xe1\x14\x54\xb4\xff\x05\xd8\x6d\xeb\x05\xf4\x89\xf5\x2b\xd0\xbf\x83\x12\x7c\x07\xac\xe8\x1e\xfb\xc5\x63\x0b\x3b\xa2\x23\x1a\x07\x3a\xd2\x9e\x2c\x4d\x73\xc0\x77\xa2\x3c\xfc\x7c\x12\x07\x89\x73\xca\xfc\x64\x32\x11\xd4\x6a\xc9\xdd\x74\xdc\x09\xa9\xbf\x3f\x1d\x4b\x89\x99\x8e\xa3\x77\xaa\xfe\xf6\x2c\x7f\x62\x94\xf8\x21\x5b\x06\x3f\xc8\xed\xaa\x15\xa0\x76\x68\xe3\xb9\x35\x70\x35\xdb\xd1\xe4\x76\xb7\x07\x77\x8c\xa8\x75\x27\x68\x31\x22\x30\x10\x5d\x06\xa9\x1e\x22\x2a\xd1\xd5\xc9\xe8\x48\x25\x3b\x15\x99\xb1\xdf\xf6\x33\xe6\xb1\x1d\xa6\x41\x45\x73\x6f\xa2\x9c\x6a\xec\xaa\xc5\x9b\xb2\x4c\x79\x26\xd6\x64\xe2\x8c\x94\x86\x50\x5f\x7e\x87\x08\xfd\x2c\xc9\xc1\xde\xea\x29\x44\x8b\x10\xac\x09\xab\x23\x2f\xf0\x77\xce\x78\xef\x02\x9a\x75\x01\x0c\x5a\xff\xc2\xa4\xd1\xc5\x03\xd1\xde\x89\xb3\x06\x16\x5d\x6b\xbf\xb1\x7a\xe1\xd5\xaf\xb3\xd9\xa8\x75\x07\xd9\x2f\x2a\xca\x87\xcf\x33\xeb\x26\x9c\x28\xee\x9b\x93\x81\xde\x46\xc9\xe3\x47\x2c\x47\xbb\xa8\x2f\x79\x1f\xd3\x54\x8b\x69\x22\xbe\x6e\x2b\x6c\xd7\x14\x8a\x20\xbc\x7f\x13\x8c\x12\x1b\x24\xf4\x98\x19\x7f\x1f\xf9\xd3\xcc\xaa\x96\x81\x07\x4f\xcb\x1c\x20\x50\x03\x3c\xe4\x3d\x2e\x2e\x20\x24\x95\xd7\x9b\xd6\xb6\x23\x04\xba\x8a\xc1\xa6\xea\x85\x17\x7e\xca\x06\x91\x53\xa6\x13\x02\xb9\x58\xb0\xa3\xa2\x7c\x7e\xd7\xe9\xed\xfa\xad\x3b\x08\xae\xa1\xfd\xe3\x47\x2c\x42\xfb\xc1\x7b\x03\xfb\x60\x22\x6f\x61\x9d\x78\x1b\xd3\x36\x95\xf6\x37\xd3\x33\xba\x63\x2a\x4a\x8f\x1a\xef\xcb\x3c\x3d\x64\xfb\xe5\xc9\x80\x1c\x10\xa2\x0c\x99\x10\x26\xa3\xcd\x17\x40\xfb\x77\xee\xae\x43\x7f\x00\xcd\xce\xf5\x87\x5e\xb8\x32\x64\xe7\xd4\xf6\xe0\x3b\xf6\x8b\x8b\x8d\xa7\xd0\xb7\x9b\x60\xe9\xfc\xe5\x6e\xd8\x73\xd5\xab\xbc\xef\xf5\x19\x1e\x63\x16\x1e\x43\x81\x6d\x94\x9f\x34\x5e\x94\x85\xb5\x84\x15\x89\x38\x40\x06\x93\x79\x15\x22\x8d\x66\x4d\x98\x7d\xb4\xe0\xb3\x0b\xf0\x8e\xc9\x7d\xa2\x3d\x8c\x30\xba\xef\x76\x82\xa3\x8d\x64\x08\x61\xbe\xc9\x7d\x8c\x40\x3b\x7d\x2e\xe7\x7d\xae\x54\x46\x9e\x0b\x9e\x78\xae\xce\x41\x31\x38\x29\xc2\xe9\x39\x23\x1c\xdd\xc9\x7d\xd7\x08\x23\xda\xbb\x4f\x98\xe0\x9d\x0b\xe0\xbb\x4a\x50\x38\x19\xa4\x56\x3e\xb6\xe0\x0f\xde\x00\x9f\x70\x0b\x45\x77\xb1\x9e\x84\x3b\x65\x1c\x17\xa0\xd3\xeb\x03\x24\xcc\x19\x10\x8b\xb5\x2a\x00\xc4\x13\xc9\x24\x09\xaa\x9b\xc8\xb7\x9f\xe5\x1b\x55\x7a\x12\x2e\xc9\x10\x62\xea\x14\x65\x42\x56\xbf\xe1\x58\x9b\xe7\x22\xa7\x0f\x9b\x7d\x6e\xf4\xaa\x25\x83\x76\x67\x86\xa3\x2f\x4c\x60\x67\xf6\xf9\x26\xe6\xf5\x4f\xfa\xae\xff\x50\x74\x77\xf2\xec\xb8\xd2\x6e\x35\x3f\x2e\x5d\xba\xc1\x61\x7f\xa5\x0a\x6d\xdd\xf1\x41\xe3\xe4\xbf\x0e\x0d\xc4\x74\xbc\x85\xf9\xdb\x4a\xf9\x6b\xe5\x54\xc2\x78\x49\x96\x24\x4f\xc2\x52\xfc\xf1\xa7\x56\xed\x10\xcf\x1a\x12\x8a\xc6\xd8\x5e\x2e\x24\x73\xad\xb8\xb0\xa2\x00\xfc\x51\xb0\x0a\xf3\x47\x9c\x3d\xf6\x0b\x54\x0c\x76\x61\x16\xf1\xfc\x3e\xc6\xa2\xec\x89\x9f\x4d\xef\xbd\x20\x91\x17\x79\x18\x7f\x41\x6a\x87\x4b\x57\x5e\x58\x49\x64\xcd\xdf\x91\xc5\x80\x4f\x58\x37\x7e\xaf\x86\x31\x9d\xe0\x38\x3f\x25\x19\x1d\x9f\xb5\x89\x24\xa8\x78\xf9\xa6\x76\x0e\x01\x19\x8b\x84\x08\x20\x6c\x33\xbd\x46\xb2\x00\x76\x4b\xed\x3c\x54\x37\xe9\x94\x09\x64\x2f\x6e\x0f\x3e\xa9\x59\xaa\x1b\xdc\x7b\x58\x29\xec\x5a\xe9\xee\x86\xde\xe2\x75\xe3\x7b\xcc\xe3\x8b\x94\xc7\xe0\x53\x72\x09\x80\xdc\xd3\x36\x89\x07\x8b\x95\x50\xde\x48\x2d\x3e\x3b\x11\xdd\x59\xdc\x1d\xf3\x56\x0c\x03\x0f\x21\x03\x28\xc5\xdc\x7d\x50\x86\x56\x61\xf6\x82\xc0\xd7\xa8\x93\xfb\x13\x4c\x73\x67\x4c\xfe\x5b\xf8\xb9\x78\xbf\x79\x95\xb0\x40\x8e\x74\xbc\x3e\x08\x3e\xab\x04\x74\xbe\xb0\xe2\x65\xf0\x05\xd5\xa9\xc7\x6b\x88\x3e\x55\x63\x5a\xbe\xc5\x9f\x31\x32\x61\x75\x5a\xb9\x92\xd5\x9f\xc6\x9f\x53\x81\x98\xe3\xd8\x60\x36\x50\x6a\xec\x59\x9e\xa3\x3d\x3e\xd3\xd3\xd6\x01\xad\x23\x25\x3c\x34\x92\x89\x00\x23\xb1\x07\x6a\x35\xb6\xb4\x70\xb4\xb0\x6c\xba\x54\x61\xae\xad\xb9\x70\x64\x86\x54\xdc\x09\x54\x9f\xc2\x33\x00\x37\xe4\x57\x3f\x97\xe9\x1e\x0c\xf7\xc4\x0f\xdb\xee\x1e\xcd\x7e\xe1\x2e\x8c\xeb\x57\x0b\x8f\xd2\xf9\x60\x6e\xe1\xb1\xf7\xd3\x3e\x85\x41\xc7\x81\x5c\x74\x16\x8f\x4c\x04\x20\xf1\x50\x8d\xe5\xec\x95\x02\xc8\x24\x1c\xb0\x5d\xd1\x3e\xf3\xdc\x9a\x0b\x1b\x41\x89\x52\x3e\xbf\x16\x8f\xc0\xa6\xee\x72\x8f\xc3\xcc\xbc\x31\x28\x03\xee\x7d\x4c\x73\x4b\x98\xdb\xf8\xb9\x2f\xe3\xe7\x62\x8b\xdf\xc8\xc8\x40\xdc\x71\x3f\x31\x5d\x76\xa2\xe6\xe5\x91\x45\x16\x9d\xdd\x27\x56\x71\xfb\xc2\xdc\x1a\x45\x28\xdc\xbc\xeb\xc2\xdc\xb9\x5a\x83\x7b\x3c\x91\x90\x7b\xaa\x63\x06\x9b\xf1\xd8\x02\xd7\x15\xf5\x7c\x7c\x85\x3f\x27\xbc\x85\xd7\xc9\x0e\xbc\x4e\xd4\x4c\x08\xb6\x1d\x3a\x29\x59\x21\x41\x5e\xbd\xa0\x5a\x41\x96\x00\xef\x64\x40\xe0\xc5\xf7\xa6\xed\x8d\x47\x5d\xb8\x57\xb8\xee\xe6\xfc\x73\x9f\xf6\x79\xe1\x6d\x10\xf1\xc2\x73\xd5\xa7\x47\xae\x99\x5f\xd3\x38\x12\x7c\xf2\xe1\xd9\x09\x7f\xbe\x3c\xf0\x66\xe3\x94\x3f\x5f\x19\x08\xc7\x2f\xda\x50\xfb\xd7\xcc\x65\x9b\xe6\x03\x96\xe6\x24\x26\x82\x8f\xb9\x4c\xd1\x51\x82\xd3\x4a\x6e\x22\x31\x93\x01\x11\xaa\x06\xba\x28\x2f\xf1\x99\x9c\xe4\x24\x6d\xc7\xde\x95\x70\x72\x0d\xf3\x27\x3d\xf3\x3d\xf0\x92\x46\x93\x87\x04\x3e\x72\x71\xa7\xcf\x4c\x63\xad\xff\x98\xa2\x9c\xcc\x92\x93\x0b\xd1\xa7\xed\xa7\xe5\x8d\x91\xcd\x91\xf5\x4a\xce\x9b\xdb\x75\x40\xbf\xa2\xaa\xce\x03\xb9\xd7\x6a\x26\x95\x6e\x89\x8d\x98\x98\x3f\xed\x9b\xf1\x40\x36\xf8\x74\xad\xb9\xe3\xc2\xa8\xd8\x98\xd6\xb9\xf9\xc3\xcb\x8f\x96\x0d\xca\x1b\x70\x3e\x6f\x90\x70\x1e\x24\x76\x6e\x30\xd5\x65\x3d\x13\x58\x07\x34\x1a\x92\xd5\x12\x87\xc5\xc3\x61\x81\xf3\xd7\x0a\x76\xa1\xb4\x53\x38\x0d\xea\x88\x35\xc7\x8e\x78\x2a\xbc\x86\x7e\xe8\xb9\xe2\x02\x58\xb3\x6c\x7b\xd9\xa9\x65\x8d\x8f\x7a\x02\xf0\xa1\x4d\xc4\x8e\x45\x35\xec\x17\x0b\xa7\x95\x1d\x70\x81\x21\x6b\x50\xed\xd9\x60\x3a\x0e\xb1\xd9\x23\xe8\x9c\x1a\x99\xd0\x53\x7e\x10\x1a\x8d\xd8\xa5\x7a\x7a\x27\xf7\xf7\xec\xe5\x9e\x8d\x4d\x07\x04\xef\x9e\x65\xc7\x1f\x43\x3f\xe5\xe3\x01\x5f\x5a\xfe\xe2\xfa\x15\x67\xd1\x67\x13\x17\x8e\x18\x84\x7e\xee\x82\x97\xd2\x66\x54\xce\x7e\x51\x5b\x39\x77\x5f\x08\xea\x0f\xe5\x13\x86\xf6\xec\x49\xdb\x9c\xe2\x45\x34\x12\x8f\xbb\x99\xef\xe5\xd5\x88\xa7\x22\xee\x04\xc3\x71\xa2\x06\xca\x1b\x05\x01\x00\xac\x80\xdd\x9d\x71\x70\xf9\x41\xd4\x60\x62\x83\x4d\xa2\xa2\xc7\x6b\xd8\x8a\xca\x4a\xaa\x8b\xbf\x63\x7d\xd9\x88\x3f\x6f\xc0\xda\xe2\x2f\xf6\x78\x03\x2d\xb4\xc5\xf1\x64\xc1\x2b\xec\x73\xe0\xa4\x5f\xd5\x8a\x19\xf2\x71\xe5\x73\xf7\x06\xe1\x17\xb6\x5f\xc1\x27\x1b\xd7\xd8\x32\xe1\x08\xf7\xda\xb8\xa8\x81\xa5\xcf\x2f\x86\x65\xee\x17\x1a\xaf\xe3\xe7\xaf\xc0\xfe\xc7\x7c\xba\xcf\x5a\x8f\x69\xe9\x26\xc0\x91\xe5\x5b\xe7\xaf\x50\x00\xa9\xb0\x80\x31\xa1\xfc\xbe\x66\x63\x23\x1d\x42\xcb\x70\x02\xb2\xa6\x33\x61\xed\x7f\x75\x4f\x1b\x11\x4c\x6e\x83\xbe\xdb\xd3\x65\x75\xeb\x38\x3b\xb0\x2c\x8a\x53\x80\xb1\x1b\xf0\xda\xed\x3d\x6b\xee\xea\xc1\xee\x3d\x78\x71\x1d\x9f\x38\x15\x8e\x76\x6f\xf8\x82\xa5\xd8\xb4\xc0\x08\x3e\x65\x3f\xa3\xe7\xae\x64\xa6\x8d\x53\xd6\x86\x63\x8c\x41\x4a\xa5\x2e\xa8\x01\x24\x9e\x6c\x95\x90\xc0\x32\x12\x7e\xe0\x24\x3a\xb2\x80\x6f\x41\x98\x4d\x71\xd8\x9a\x4f\x07\xde\x48\xb2\x17\x40\x97\x56\x23\x3b\x24\x62\xd2\xf8\x51\xd0\x57\x07\x5b\x3d\x9b\xe5\x32\x67\xf6\x2f\x9b\x7e\xf2\xed\x5d\xaa\x1e\x9d\x0a\x06\xe8\x66\x87\x6e\x7b\x6e\xda\x72\x65\xb2\xa4\x9d\xde\x28\x8f\xa9\x59\xb6\x7a\x6a\xc7\xb4\xce\xe3\x7a\xc8\xc1\x57\xe3\x62\x07\xe5\x54\x0d\x9a\xbb\x98\x85\xdd\xfd\xb3\x32\x33\x32\x0d\xa3\x86\x4c\x2c\x6d\xdd\x1d\xfd\x1e\x11\x98\x2c\xca\x53\x80\x5a\x96\x2d\x2a\x4c\xce\x6e\x57\x96\x4c\xf9\x88\xc0\x7c\xfc\x84\xf9\x88\x64\xec\x4c\x74\xbd\xd2\x10\x18\x15\xa5\x0d\xc4\xeb\xea\x54\xbc\xcd\xc6\xb1\xf8\x58\x8e\x19\xc2\x13\x95\xe4\x6f\x4f\xf2\x30\x42\x83\x8e\x06\xda\x96\x8e\xc4\x1e\xad\x92\x16\xf7\x41\x74\x32\x69\xf8\x4b\xe2\x48\xd5\xf1\x81\x42\x9a\xc8\x07\x16\x7b\xb8\x40\xd5\x1e\x2e\x2c\xdb\x9f\xc9\x05\xf7\x03\xcf\x05\xfa\x8f\x87\x89\x91\xc5\x84\x09\x20\xe7\x99\xc0\xab\xa3\x99\x09\x08\x64\xe0\x2e\xfb\x25\xf7\x0b\x5e\x7d\x56\xa6\x6d\xbd\x5c\xa6\x95\x29\xfc\xd5\x1d\xb1\xd1\x63\x14\x20\x01\x7b\xf9\x12\xcc\x82\xc1\xab\x71\x3e\x30\x77\xde\xf6\x04\x76\x87\x9d\x95\xd8\x92\xc9\xd4\x44\x26\x79\x49\x36\xe8\xc1\xcf\x13\xa7\xf7\xdf\x3a\xfd\xa5\x04\xd6\x54\x5d\x69\x9e\xae\xe6\x92\x26\xc5\x17\x4f\xcb\x1a\xd4\x6b\xc0\xf0\x0c\x70\x77\xd1\x94\x15\x40\x33\x77\xd9\x1c\xf7\xae\x6d\xe1\x79\x9d\x32\x87\x8d\x7b\xaf\x74\x70\xf1\xa8\xaf\x07\x1d\xc1\x9b\x4e\x26\xf8\x94\xfb\x37\x96\x2b\xe9\xa3\x90\xc5\xa4\x3b\xb5\xed\x83\x82\xac\x59\x58\xf3\xc5\xea\x10\x9b\xd5\x60\x50\x47\x58\xb1\x64\xeb\x58\xbb\x5d\xae\xe6\xcd\x18\x55\x14\x1e\x15\x10\xff\x6f\xb7\x0b\x6d\xc0\x80\x44\xdf\x2c\x5b\x0f\x2c\x48\x16\xf0\x45\x25\xe0\x23\x8c\x62\x49\x84\x44\xe5\xc9\xfe\x70\x44\x38\x78\xcd\x82\x77\xc4\x07\x3b\x94\x85\x0c\xb5\xbf\x50\x3e\x66\x7e\xc0\xdc\x77\x46\x54\x9d\xbe\xb5\x5f\xf9\x7c\xdf\x81\xc6\xd9\xe1\xbb\x16\x6e\xeb\x52\xb4\x69\xd1\x46\x56\xe9\x5e\xb0\x7a\xf4\xc8\xf6\x59\xed\xba\x4e\x2b\x50\x40\x13\x5b\xd4\x6d\x40\x65\x00\x9b\x9b\x7f\xb1\x53\xfb\x98\x92\xc2\x61\x83\xce\xf2\x0a\x95\x6d\xac\x4e\x73\x1a\x46\x0f\x9e\x30\xe1\xf9\x05\x03\xd2\x0c\x10\x46\x74\xeb\x90\xda\x29\xb3\xa2\xfd\x52\xfb\x90\x01\xd3\x27\x50\x7d\x0a\x27\x3e\x83\x98\xc1\x16\xca\xc6\xb4\x6d\x64\xd4\x20\xa9\x5e\x26\xd7\xeb\xe4\x3a\xe5\x39\x3c\x1f\x16\x3c\x17\xf1\xd8\x43\x67\xa8\x52\xe1\xb9\x48\xf3\x00\x89\x00\x6f\x8c\xd4\x26\x96\xd8\xa8\x39\x20\x1a\xd6\xc2\x6c\xb3\x86\x89\xd3\x07\x6c\x9e\x71\x20\x01\x9a\x24\x33\xc2\x0f\x55\xa7\xfb\xf9\xb1\x49\x93\xe3\x07\x4f\xcf\x1a\xd4\xbb\xff\xf0\x0c\xee\xd7\x45\x53\xd6\xa2\x3f\x6a\x97\x8d\xd6\x6f\x63\x67\xa0\x0f\xb3\x5a\xe1\x39\x19\xfb\xee\x30\x61\x4e\x20\x3e\x59\xdc\xe5\x92\x30\x6d\x06\x26\x9c\xea\x89\x4e\x26\xd1\x6a\xa8\x9e\xf8\x81\x24\xbc\xb3\x10\x3d\x31\xfe\x77\x3d\x49\xd5\x3d\x5b\x51\xa0\xcc\xa3\x28\xe2\xae\x73\x5e\xfe\x27\x4d\x89\x02\x93\x1e\x2f\x7a\x52\x57\x20\xf6\x59\x3e\x61\xff\xe2\x7e\xa5\x48\x6d\x21\xf5\x8c\xd8\x62\x91\x9b\xfd\xcf\x60\x62\x58\x46\xce\xbb\x9d\x34\x3a\xfb\xa4\x32\x78\xda\x68\x60\x2d\x10\x26\x1b\x5c\x96\x9c\xc9\x1a\xdf\x6a\x68\xea\x8e\xb1\xcb\xb7\x0e\xaf\x9b\xb4\x6a\x07\xab\x9a\xc0\x96\xe6\x96\xd4\x04\xb1\xbd\xf3\x2f\x66\x3a\xf1\x6c\x6e\x5d\xbd\xf2\xb3\xea\xe7\x17\x14\x66\x0e\x15\x26\x0d\x82\x6e\x78\x7c\x84\xc7\x27\x27\xa7\x90\xfa\x00\xb1\xc9\xa4\x08\xd6\x9e\xc1\x23\xb3\x78\x01\x25\xb6\x18\xdf\x21\x68\x9d\xb0\xb9\x53\x32\x30\x3d\x42\xaf\x56\x76\x96\xe4\x4c\xc7\x8a\xf0\xd2\xa8\x3e\x53\xf3\x97\x6f\x2d\xab\x9b\xe8\x4b\xc0\x73\xf9\x17\x3b\x76\x88\xc9\xc9\x8e\xda\xba\x7a\xc5\xe7\x98\x82\x81\xa9\x1e\x0a\xc8\x1e\xd3\x03\xd3\x70\x0a\xaf\xe1\x48\x6c\x4d\x55\x4a\xab\x35\x8c\x0d\x0b\x08\x08\xc3\x06\xc8\xac\x3f\x43\x21\x21\x25\x1e\x49\x08\x9d\xd0\xe9\xe9\xcd\x47\x16\xa9\x8e\x14\x12\xa4\x4e\xf5\xad\xc1\xb7\x4b\x78\xf5\x81\x3d\x7a\x4c\x4c\xcc\xcc\x5e\x55\x3c\x75\xde\xcc\xf2\xb4\x1e\x6b\x9f\x2b\x9a\x15\x55\x1c\xd2\x3b\x25\x27\xff\xbe\x6e\x6e\x45\x87\x1c\xd8\xbe\x5d\x42\x8f\xec\xf4\xc9\xa5\xfd\x2b\xe5\x50\xdd\x2f\x7d\xc4\xd8\xd4\x4e\xed\x63\x23\x9d\x8e\x49\xc3\x43\x3a\xa6\xd9\x3b\x62\xfa\x06\x62\xfa\x2e\x61\x19\xb5\xc2\x67\x4b\xa5\x45\xa1\xf0\x63\xfd\xf4\x7a\x3f\x96\xd5\x06\x10\xf2\x44\x5e\xad\xf1\xa5\xce\x8b\xe6\xd4\x7c\x69\xe8\xb5\xf4\x62\x21\x00\x07\x47\x3e\x88\x98\x1c\xbc\x38\xb7\xcf\xf8\x61\xba\x9a\xc9\x9d\xdb\x55\x5b\x26\x86\xac\x18\x3b\xfe\xb9\xa9\x03\x72\xfa\x6f\x07\x9f\x9c\x08\xad\xec\xd9\xb9\x6b\xfb\x92\x9c\xce\x89\x89\x23\x54\x65\x85\xe5\x05\x05\x63\xa5\xac\x74\x68\xce\xb8\x1a\xbe\x56\x43\xce\x9c\xe3\x0c\x58\x6e\x56\x26\x8e\xb1\x9f\x92\xc9\x03\x4c\x72\x93\xd2\x7c\x06\xdb\xbd\xb6\x8c\x1e\x24\x9e\x60\xd9\x56\x4a\xe2\x8c\x10\x0a\x53\x04\xbf\x9d\xba\x24\x42\x66\x73\x84\x40\x64\x16\xf0\x6c\x4b\x02\x96\x0f\xb6\x21\x76\xb1\x84\xdc\x99\xe9\xed\xcd\x9a\x0e\x83\x7f\x88\x98\x1c\xb8\x74\xc4\x58\x63\x00\x68\x3f\xb1\xe7\xf8\xb9\x03\xb6\x54\x15\x4c\xd3\x41\xd6\xcc\x56\x29\x4c\x13\xc3\x8f\xfc\xb1\xba\xd7\xec\x4e\x45\x79\xfd\xcb\xd2\xce\x1d\xb7\x4c\x18\x53\x39\x6b\x40\x87\xe7\x27\xcf\x07\xf2\xea\x9e\x39\xfa\x31\xa2\xb0\x39\xee\xc6\x43\xeb\xa1\xfd\x95\x89\xaf\x8d\x72\x0d\x2d\xff\x82\xe7\xe1\x5f\xcc\x3b\x6c\x38\x77\x9f\xe6\x74\xe8\x4f\x40\xbc\xf2\x4f\x63\xfa\xc5\xf4\x60\xa2\xf9\x90\x96\x3e\xdb\x1c\xc4\xc9\x80\x15\xa6\x19\x26\x10\xbb\x6e\xc6\x3a\xd0\x6d\xc6\x0c\x76\x9b\x5b\x04\x1f\x51\xdd\xf9\x8e\x4b\xc3\xeb\xda\x8f\x09\xad\x57\xd0\xb3\x84\xec\x2c\x7e\x80\x08\x24\x35\x3b\x46\xfc\x25\x20\x60\xf9\xe3\x04\x81\x78\xd6\xb1\xd1\x67\xa6\x26\x55\x5f\xa9\xae\x5e\xf5\x78\x0b\x5a\xf9\x1d\x76\x81\x86\x15\xa1\xdf\x39\xa3\x7b\xe6\xc2\xfb\xa8\x01\xf1\xb1\xa7\x0a\xfc\xec\x7d\x58\xbe\x51\x4c\x6c\x5d\x2b\xb1\x38\x40\x87\xad\x76\xbd\x41\xa1\xd4\xa8\xd5\xf8\x6c\x90\x70\xdc\xc2\x28\x3c\x47\x04\x62\xb0\x09\xc4\x34\x6f\xb6\x7d\x80\xf0\x49\xe6\x38\xdd\x2d\x4d\xe4\x8b\x81\x6f\xed\xea\xf9\x2d\x0c\xec\xaf\x8d\xc9\x28\x98\x66\x2c\xc4\x3b\x0c\x96\x64\x72\x79\xd7\x3d\xba\xf4\x29\x5d\x1a\xfd\x06\xcd\xf6\xfc\x06\x93\x76\xbe\x6f\x64\x72\xbb\x25\x53\xb0\x6b\x56\xb4\x7b\x5e\x41\xd6\xee\xc1\x5d\xdf\x32\xe7\xa2\x68\xe1\xdf\x27\xa1\xbe\x58\x0e\xd1\xcc\x39\xf6\xdf\x98\xd6\x70\x26\xf2\xb8\xc9\xa8\x25\x06\x57\xc9\x04\x51\xa3\xa6\xc7\xa4\xb2\x22\xbc\x99\x13\x1d\x20\xc6\xcd\x9e\xe5\x3b\xfb\xc2\x8e\xdd\x82\x58\xea\x8e\xe0\x19\x7f\x29\x36\x56\x63\x0e\x6d\x13\xa5\x1c\xa1\xac\x1e\xb0\xd0\xd4\x87\x27\xb3\xfd\xd4\xdc\x91\xa3\xd4\x63\xf5\xc3\xce\xc9\x4b\xc5\x19\x9d\xa0\xb6\x8b\x6d\xda\x82\x69\xa8\x1f\x21\xaf\x30\x73\xe4\x50\x5b\x81\xfb\xc3\xf1\x43\xf9\xf9\x4d\xc0\x6b\xe7\x27\x4c\x17\x26\x06\x7b\x80\x1a\x05\x59\x31\x26\x52\x97\xec\x89\x35\xe8\x7d\xed\x99\x24\xd9\xd6\x6c\xf4\xd9\x9f\x4a\x8e\x2f\x5c\xba\x7d\xe8\xf1\x39\x2f\x6c\x7a\xee\x70\xc9\xe4\xcc\xa2\x01\xc3\x2b\xda\xb3\xd7\x9f\x7b\x38\x67\xdf\xaa\x05\x0f\x2a\x37\x2f\xbf\x52\xf6\xe6\xa0\xf2\x09\x63\xdf\x26\x09\x5f\x78\x9c\x3b\x78\x8d\x06\x60\xef\x18\x42\x91\x46\xe3\xc7\x88\xc8\x58\x3a\x6c\xdf\xbd\x66\x94\x3f\xbc\xe3\x85\x98\xda\x6c\xc2\x22\xbd\x6d\xa2\xe0\xc5\x95\xed\xc7\xf7\xbd\xbf\x70\xf5\xa0\xfd\xf3\xa6\x2d\x91\xce\x16\xe5\xe4\x14\x8d\xeb\xc0\xad\xda\x15\xfe\xd5\x96\x25\xf3\x1f\xd6\x54\x8e\xd3\x66\xe5\x15\x5f\x1f\xfd\x2a\xb1\x59\xb1\xec\x28\xf6\x1b\xcc\x97\x3f\xa3\x3e\xa1\x91\x40\x39\x75\x95\xec\xf4\x56\x89\xef\x8e\x65\xf3\xc8\xd1\x96\xca\x8e\x38\x9c\x5f\xd6\xd9\x7f\x9e\xf9\xca\x81\x17\x36\x49\xe7\xc9\xd8\xeb\x57\x3a\x2d\x1c\x71\xee\xfa\xe6\xe5\x09\xc9\xc9\xa4\xc6\x08\xd3\xfe\xf5\xff\x8f\xb5\x37\x81\x8f\xaa\x48\x1e\xc7\xbb\xdf\x31\xf7\x64\xee\x99\x24\x93\x49\x32\x99\x24\x93\x8b\x24\x64\x92\x4c\x2e\xc8\x40\xb8\xcf\x24\x84\x84\x21\x07\xe1\xbe\x8f\x70\xdf\x47\x00\x91\x5b\x04\xbc\x38\x04\x4f\x40\x6e\x82\xa0\xa2\xd9\x55\x3c\xc1\x63\xdd\xd5\xaf\xab\xe8\xba\xab\xa2\x5f\x57\xd1\xf5\x5e\x25\x6f\xfe\xdd\xfd\x8e\x79\x33\x01\xfd\xfe\x3e\x9f\xbf\x59\x20\xdb\xaf\x5e\x75\x55\x75\x75\x75\x55\xbf\xae\x6a\x7a\x1a\x30\x23\x5c\x3a\x4a\x65\x14\x42\x1b\x82\x4b\xfc\xf0\x86\xa7\x24\xa1\x17\xe6\xb1\xeb\x95\x63\x1a\xaa\x5b\x11\x42\xd7\xab\x47\xb7\x1c\xa4\x4d\x3d\xd3\xb3\xf2\xa6\xcc\xed\x73\xc7\xd4\xce\xd7\x1f\x03\x24\xe7\xf7\x39\xc6\x42\x64\x91\x06\x72\xce\xc4\x99\x11\x6d\x17\x0c\x31\x31\x1a\x8a\xa6\x35\x78\x72\x28\x91\x26\x24\x8b\x56\xab\x52\xb8\x81\x98\x77\xc7\x85\xcb\x87\xd1\x1c\x11\x2e\x1f\xe6\x97\x66\x5a\xbe\x14\x53\x47\xd1\x52\xa7\x1a\xb0\xea\xa4\x49\xb5\x50\xc5\xa0\x55\x78\x14\x5a\xff\xf6\x39\x9b\x17\x07\xd0\x8a\x37\x01\xc5\xfc\x5b\x99\x72\xee\x1e\x7a\xeb\xc4\x52\x6d\x8d\xbd\x6f\x6f\xb4\xfe\x71\xdf\xb5\x53\xe7\x67\xbe\x39\xb1\x71\xdc\xd4\xeb\x4d\xe4\xee\x11\xf8\x3e\xe2\x79\x0c\xbb\x13\xd1\xe8\x3c\x6f\x50\x2a\x75\x1a\x15\xb6\x5b\x56\x91\xaa\x97\x84\x99\xc4\xbb\x94\xe1\x0b\xfc\x44\x17\x99\x0a\x96\xf7\xd3\x8c\x69\x30\x07\x07\xd7\xb9\xb7\x99\xb7\x35\xa8\x2b\x13\x33\xf4\x95\xf0\xda\xa0\xf2\xe4\x0a\xf8\x7a\xf3\xb1\x63\xcd\x5c\x59\x56\x5c\x6f\x4d\x8b\x09\xf5\xd5\x07\xf9\x63\x34\xb2\x31\xf1\x20\xe9\x9c\x49\xaf\x8e\x7f\x0e\x1b\x08\x34\x2d\xf2\x80\x11\xe8\x85\xd8\x49\xb8\xd8\x47\x56\x11\x08\x2d\xf5\xc5\x61\x7f\xdd\x42\x79\xc7\x08\x73\x60\x41\xc2\xe2\x18\x96\x2a\x5f\x34\x72\xea\x34\x76\x02\xf3\x19\x57\x3a\xd8\xbd\x68\xe3\x62\xf8\x44\xd7\x91\x87\x55\x2d\x09\xb5\xbd\xa6\x8e\x37\x67\x51\x0c\x8e\xef\x29\x07\xd3\x83\x99\x82\xb8\x32\x3f\x09\xac\x7a\x95\xca\xaa\x06\x79\x38\xef\x2f\xaf\x20\xe2\xa3\x8c\xdf\x00\x85\x4f\x31\xff\x86\xef\x2e\x98\x35\x77\x22\xd7\x1a\x4b\x0d\x3c\xe4\x58\x3b\xf1\xc0\x3e\xce\x4c\xdd\x5d\xdf\x3a\x64\xf4\x0a\x66\x21\x4b\x05\x56\xee\xde\x48\xf6\x2c\x3e\x62\x5e\x65\xae\x23\x2b\x9f\x79\xde\xe4\x30\x64\x6b\x92\x91\x35\xea\x50\x78\xbd\xd6\xf8\x67\x08\x53\x06\x81\x29\x32\xac\xd2\xb9\x84\x70\x88\x45\x2e\x30\xe1\xb5\x5f\xe2\x4f\x16\x83\xd1\xb6\x06\x53\x51\xc5\xc8\x25\xd8\x2c\x99\x34\x68\xc2\x17\x4d\xe9\x3f\x7a\xa2\xa6\x74\xde\xe0\x96\x29\xea\x71\x2b\xf1\xc3\x9a\xc5\xb6\x5a\xe6\x3a\xd7\x67\x64\x76\xb1\x7f\xcb\x7c\x78\xac\xeb\xc8\xa4\xca\xf5\xa3\x7a\xd5\x55\x37\x0e\x9e\x3a\x3e\xb6\x0c\xde\xe0\x1f\x6d\x9d\x0b\x8f\xf3\x6b\xfc\x22\x64\x4b\x8b\xd1\x18\xa8\x91\x15\x50\x51\x78\xac\x15\xf2\x1d\x47\x1c\x92\x91\xed\x14\x6a\xf3\xde\x35\xeb\x07\x68\x14\xa3\xa0\x6e\x33\x8a\xc1\x7e\xe3\x0c\x83\x5b\x1e\x83\xdf\x11\x7b\x7c\x0d\xc5\x2b\xdf\x22\xbd\x4e\x07\x69\x1d\x1e\x9c\x31\x88\x15\x3b\x56\xa1\x70\x32\x4c\x12\x20\x93\x46\x8c\x55\xf8\x4f\x1f\x64\x87\x8a\xd4\x93\x0c\x7f\xf8\x30\x40\x87\x5d\xfe\xd5\x23\x86\x82\xab\x7c\xc3\x52\x06\x67\x54\xf6\xe8\x51\x37\xbc\xe4\xd0\xf6\xb6\xd9\xed\xab\x52\xd2\x2b\x92\xfa\x39\x7b\x14\x8e\xf1\x95\x0f\x4c\x4e\x68\xf4\x97\xc3\x0f\x3d\x05\xb5\x7d\x72\x1b\x56\x34\x36\x2d\xda\xd0\x58\xd3\xde\xbe\xba\x57\xff\x54\x57\x6d\x81\x27\xbf\xa2\xa0\x35\xcb\x8a\xe2\xf3\xaf\xd1\x9c\x4b\x44\xeb\x90\x15\xd7\xfe\x7b\x0a\x98\x61\x51\x40\xad\x70\xbb\x0d\xba\x94\x14\xa7\x0e\x8f\x0a\x0e\x42\x0a\x84\x45\x18\xc5\x51\xe6\x52\xd1\xf1\xe5\x8b\xa0\x11\xef\x17\x8d\x4b\x3c\x64\x53\x94\x74\xf8\xc0\x11\x59\x7d\x69\xd7\xfc\x9d\x8b\x9a\x86\x4f\x7a\xe9\xe8\xba\x56\xc6\x91\xb9\xaa\x7d\x1d\x4c\x7e\xb2\xc7\x9c\x1e\x0b\x7b\xce\x6f\x9f\xd5\x64\x9d\x34\x67\x90\x02\xac\x9c\x3e\xe5\x6e\xb3\x65\x69\xc3\xfe\x0b\x7d\x77\xbc\x4d\x1d\xa6\x0e\x4f\xfc\xaa\xeb\x35\x57\xea\x8a\x79\xb5\x13\x27\xc5\x4c\x9e\x54\x31\x8c\x3f\x87\x39\x17\xbc\xc8\xb8\x98\x4f\x8d\x4a\xf6\x0e\x30\x93\x9a\x2f\xec\xaf\x5c\x63\x6c\x64\x0d\x4d\xc6\xbb\x9f\x8a\x84\x04\x7b\xa2\xde\x60\x48\x7c\x86\x2c\xa2\x76\xc1\x7e\x92\x15\x8e\x4c\x4a\x42\x9a\x97\xc4\x1b\x96\x14\xaf\x43\x20\x9f\xf8\x61\x5e\x9c\x3a\xdb\xd2\xd6\x5e\x92\xb1\x7c\xe5\xe0\x96\x9f\xfd\xf9\xc7\x07\x06\xde\x3e\xba\xe5\xc0\x0b\x57\x8e\x1b\xe1\x77\x66\xaa\xec\x91\xcd\x8d\xeb\x0b\xb3\x27\x6c\x9b\xd4\x34\x85\x9e\xae\xf8\xac\xe9\xd1\x86\xb3\x1f\x3d\x78\xc7\xe1\x7f\x96\x7d\x53\xd7\x8c\xf7\x39\x7e\x46\x72\xf4\x32\x3f\xa1\xc8\x2d\x1d\xa4\x3e\x07\x4c\xc8\xac\x6a\x90\xb9\x72\xe1\xb0\xa1\xc3\x1d\x17\xa7\xd2\x86\x23\xa6\x82\x4a\x51\x86\x7c\x62\x0d\xb9\x47\x0f\x8d\x2c\x26\xcc\x61\xc1\x01\x04\x5a\xd4\x7a\x53\x28\x78\x18\xd7\x38\xbb\x64\xc6\xe1\x59\xc5\x0b\x8a\xd7\xec\x7c\xfa\x11\x6b\xcd\xcc\xe2\xea\xea\x61\xae\x25\x13\xf2\x02\x96\x61\x13\x57\x06\x98\x1f\x36\xae\x9f\xf0\xd7\x1d\x83\x69\x7c\xc5\x95\xe2\xc8\xae\x67\x21\x1d\xdf\x62\x9d\x7a\xb2\x71\xfc\x3c\x16\xde\x7f\xff\x86\xe6\xfa\x69\xdc\x64\x6a\xce\xe7\x33\xef\xe5\xf5\x10\x74\x32\xc3\x50\x7c\x67\x07\xa9\x4f\x9a\x68\x2b\x60\x28\x33\x76\x07\xd4\x4a\xdd\x33\x64\xc1\xa5\xf0\x4a\x4b\x6e\x77\x16\xf6\x31\x3d\xd0\x8b\xbd\x52\xb2\xee\x24\xc2\x24\x68\x41\x1e\x88\x87\x7a\x98\xeb\xbc\x03\x1e\x1c\xe0\x4a\x75\xea\xed\xb1\x79\x3d\x33\x7a\x7a\x9c\xa5\xbf\x6d\xe0\x8e\x9e\x5e\x4e\xdd\xcd\xf5\xa0\x06\x7c\x37\xb9\x48\x3d\xc6\x9a\x10\x18\xf7\x16\x5c\xc9\x59\xbb\x5e\x22\xe3\x77\x30\xb4\x94\xba\x46\xef\x34\x29\xe9\x74\xf8\x75\xd7\x4e\xa0\x3d\x0b\x01\x73\x11\xf6\x06\x95\x45\x45\xf8\xf9\xe8\xd0\x52\xba\x82\x5a\x8b\x9e\xf7\xa0\x74\x5d\x3b\x80\xfa\x0c\xde\x8d\xc0\x8f\xf9\xf3\xbb\x5f\x85\x66\xd2\x27\xa9\x05\x26\x25\xbb\x24\xf4\x04\xff\x5c\x2f\x7f\xde\x85\xde\x7f\x8e\x3c\x5f\x1e\xba\x93\x7f\x0e\xa4\xe7\x68\x7c\x76\x71\x23\xe8\x13\xf4\xce\xb0\x9e\xf7\x89\xd0\xf3\x4a\xa2\xe7\xfd\xfe\x40\xcf\xd1\x60\xdd\x52\xcf\xa9\x73\x6d\x9b\xe7\x35\xd5\x36\xfe\xe9\xd1\x95\xad\x8c\xa6\x70\xf9\xea\x35\x30\xf6\x74\x8f\x99\x19\xf3\x7d\x73\x57\x4f\x6d\xb2\x4c\x98\x39\x90\xde\xb9\x7a\xea\x94\xbb\x2c\xf6\x15\xb5\xfb\x2e\xf6\x1d\xc4\xfd\x2f\x52\xf4\x43\x13\xff\xdd\xf5\xaa\x33\x7d\xc5\xbc\xea\xc9\x92\xa2\x43\xc8\x70\xa3\xe8\xb3\x48\xbf\x63\x80\xbd\x43\x4f\x6b\x15\x31\x4f\xc3\xbe\x28\xa2\xe9\x03\xc2\xbb\xb9\x76\x5b\x6f\x48\xae\xfb\xf0\xa0\xe8\x05\x6e\x18\x61\xd0\x64\xc2\xf8\x0d\xdc\xdc\x91\xfe\xf6\xcc\xe1\x5b\xa9\xf9\x5c\xea\x9a\x8c\xf8\x3a\xca\xd6\x95\xb5\xf3\xe9\xf6\x63\xd4\xf7\x84\xff\x17\xb9\x56\xfa\x21\x6a\x2d\x70\xe2\xaf\xee\x4f\xa1\xc9\x11\x38\xa7\x67\xd2\xb4\x98\xf3\x44\xe4\xd6\x54\x09\xae\x46\x25\x4e\xab\x35\x87\xdd\x0c\xaf\xc3\x9a\x48\x16\x53\x4f\x2e\x59\xc4\xe5\x7e\xce\x8b\xc3\x2f\x1f\xdc\x7b\x3f\xf6\x75\x06\x53\xb9\xe3\x66\xed\x18\xdd\x46\xe5\x2f\x39\xf0\x00\xd5\x28\xf9\x3c\x93\xce\xc1\xd5\xe7\x1e\xd8\x86\x1c\x9f\x85\xa5\xfd\x47\xa6\x96\xd7\x3a\xf4\xed\x54\x9d\xe4\xfd\xe0\x71\x3b\xcc\x0d\xa5\xff\x42\xad\x47\xe3\xb6\x26\x74\xac\x6b\x3b\xd1\x0b\x55\x58\x2f\x40\x0b\x37\x9c\x7e\x83\x6a\x47\xcf\xd7\x86\xda\xf9\x71\x45\x4a\xdb\x57\x1c\xd7\xd0\xc7\xa1\xaf\x98\xbf\x92\xba\x94\x3e\x7c\x72\x36\x36\x1b\x17\x4b\xcc\x4d\xac\x0e\x82\x34\xda\xae\xce\xcd\xa5\xad\x6a\x43\x8a\x91\x36\x56\x07\x33\x68\x7b\xc4\xd1\x27\xbc\xbb\x55\x2a\x9c\x1b\x4c\xeb\x76\x9f\x03\x5e\x6f\x94\x42\x45\x0c\xb7\xb0\xb8\x3a\x28\x2c\x02\xb1\x6a\x37\x05\x4a\x37\xcc\x69\x5f\x60\xdf\x76\x74\xa3\x35\x2f\xaf\x7a\x74\xca\xc6\xc3\xb1\x73\x1f\x5a\xd1\xee\xe9\xfa\xc6\xb6\x7e\xe8\xac\xc4\x75\x4b\x7e\x5c\xb0\x14\x3e\x54\xb3\x3a\x05\x4e\xd7\xe6\x1e\x9d\x37\xbc\x71\xc6\xa0\x79\xd4\x5f\xba\x6a\x27\x95\xf5\x29\x9e\x7d\x84\x3a\xb9\x64\xeb\xc1\x83\xf3\x8f\xf2\x67\x86\x43\xa0\x89\x5e\x77\x7c\xff\xf0\xb2\x81\xcb\x79\x7d\x2d\x43\x7c\x35\xb2\x57\x51\x84\x54\x01\x46\x07\xb2\x63\xe3\xe3\x3d\x6e\x93\x4e\xaf\xb7\xd9\xac\x2e\x13\xfa\xc9\xb0\x53\x74\x7a\x1a\x9d\xa6\xce\xc8\x28\x40\xbc\x19\xed\x40\x6d\x03\xa5\xe1\x53\x07\xe2\xa1\x6d\x13\x6f\xff\xf0\x37\x7f\xe3\xe5\x02\x7c\xfc\x0e\xfd\xc3\x17\x2f\x41\x0a\x1d\x43\x63\x25\xb2\x78\xf1\xf9\x24\xe4\x34\x39\xfc\x7c\x75\x18\xde\x65\xf3\x22\x4f\x8a\x9c\x5f\x53\x52\xc0\x52\x18\xbe\xf7\xb3\xd8\x4c\x0d\xff\xa1\x98\x62\xf5\x3a\x0d\x3c\xa9\xca\x7c\xa9\xa7\x37\x55\xdd\x6e\x6f\x1f\x5d\x68\xeb\x48\x49\xb4\x24\x79\x0c\xed\xf6\x79\xad\x0e\xb7\xc3\xcd\xb4\x7f\x0f\x0b\x62\x4b\xb8\xd0\x9e\x71\x13\xd6\x1c\x19\x37\x6b\xfe\xe2\x7b\x9b\xac\x17\xe3\xfd\xb9\x6e\x26\xee\x25\x9a\x53\xe4\xe7\x4d\x5d\xc5\x4e\x3f\xa1\xcc\xcb\x9f\x3f\x5f\xb9\xec\xfe\x57\xb8\xa3\x2d\xcb\xb8\x4f\xb9\xeb\xd4\x0f\x4b\x67\x1f\xe2\x9e\xdb\xb0\x62\xc1\x01\x38\x02\xc9\x62\x50\xe8\x3a\x8b\xbf\x49\xe6\x81\xde\x60\x70\x20\x2d\x0f\xc4\xe8\x81\x5e\x93\x63\x4b\x4c\x4e\xce\xf0\xda\xcd\x71\x1e\x3b\xfa\xd1\x24\x00\x4d\x59\x75\x50\x63\xa4\x7d\xd5\x41\xda\x1e\xce\xcb\x22\xc7\x5a\x10\xd3\x98\xef\x3c\x79\x14\x29\x8e\x39\x3e\x98\xe5\xf0\x55\x42\xfe\x98\x16\x89\x79\xe4\x72\xf0\xa2\xd8\xce\x83\xc0\xd2\x78\xde\xc5\xa0\x92\xfa\xa6\xff\xf9\x65\x07\xef\x89\x9d\x0b\x37\x2d\xdb\x9d\x48\xd9\x32\x1c\x2e\x41\x0e\x6e\x3b\x12\x84\xdd\x91\x94\x4a\x04\x51\xf4\x94\x53\x73\x3c\x96\x33\x35\x4f\x5a\xf3\xf8\x84\x59\x0b\xc7\xac\x1e\x5b\x7a\x72\xfa\xb8\xc7\x8f\xb5\xae\xa2\x8a\xeb\x27\x2c\xf9\x8b\x1a\x4b\x41\x31\xe3\xa4\x02\x4b\x81\xbd\x39\xb0\xbd\x99\xc9\x5e\xf3\xf0\xa2\x99\x07\xe1\xd0\xd5\xcb\x16\xd6\x9d\xe3\xbe\xe2\xcf\xbe\xa2\xa8\x90\x23\x32\xe8\x7f\x26\x25\x13\x57\x25\x4e\x0a\xa6\x00\x90\xe0\x4a\xa8\x0e\x42\x86\xd1\x69\xed\x46\xb3\x39\x3e\x4e\x69\x47\x3f\x86\x1e\x2e\x83\x41\xb8\x10\x86\xe7\x1d\x0d\x38\xff\x77\xb8\x78\x1d\xed\x0b\x73\x88\xef\x11\x91\xb8\x77\xe0\x7d\x71\xbf\xac\x30\x20\x0a\x0a\xd0\xe2\xb8\x6b\x18\x8c\xb7\x09\x83\x5b\x0c\xab\x3b\x9a\x63\xe3\x05\x7e\x8b\x2a\xb9\x5f\x13\xa0\x82\xcd\xf8\xf8\x93\xc1\x8f\xa7\x25\x24\x3f\x99\x3d\xbd\x6d\x80\x15\xfe\x3b\x81\x3e\xce\x2d\x25\x83\xab\xe0\x26\xc0\x8f\x55\x64\xb8\x61\xbf\x1d\x71\xaf\x9d\xd2\xab\x76\xb1\xba\xbc\x19\x93\x76\x90\xf3\x49\x47\x01\x60\x75\x68\x0e\xe7\x21\x5d\x1f\x04\x66\x04\xca\x4a\x7b\xd9\x7b\x55\x07\x5d\x76\x63\x76\x4e\x41\x4e\x4d\x30\x37\x1f\x56\x31\x74\x80\xae\x09\xc6\xc7\x59\x2d\x4a\x4d\xa0\xca\x93\xef\x63\x0b\xfa\x58\xd2\x8c\x9a\x82\x3e\x69\x69\x7d\x0a\x34\x8c\xc2\x68\xc8\x02\xc2\xe1\x59\x7e\xbb\x85\x5c\x39\x8e\x7e\x35\x61\xa7\x4a\x28\x49\x2a\x0a\x40\x3a\x2a\x91\x8e\x6d\xba\x85\x30\x5e\x09\x91\x34\x0c\xd0\x47\x26\xbd\x4f\xda\xf2\x28\x26\x5b\x0a\x1e\x8b\x32\xc5\x4b\x5b\xec\x3e\x71\x73\x18\xb5\xe1\xd4\x51\x1c\x1e\xe3\x9a\xb5\xc7\x1a\xdb\x87\x65\x4f\x3c\x5a\x9f\xa8\x6f\x4f\x99\x38\xb0\xa7\xd5\xb2\x57\x63\xa6\x26\x3d\x50\x3b\x98\xaa\x58\x5f\xd7\x50\xa3\x73\x1b\x54\x1b\x4a\xd7\x8f\x3e\x32\xac\xaa\x7a\x7a\xcd\xac\x85\x83\x7b\x67\x69\xbd\x59\x7d\xe7\xb8\xdf\xeb\xdd\x96\x5c\xdc\x3c\xcd\xa9\xcd\x80\x7f\xcd\xa4\x38\x05\xbc\x18\xeb\x1c\x35\xde\xd5\x35\xee\xce\x41\x53\x5f\x18\x33\x6b\x5a\x53\xe3\x44\xef\xd4\x23\x06\xeb\xae\x72\x6e\x24\xdc\x44\x25\x70\xe3\xa8\x9c\x74\xe6\x9d\x26\x57\x45\xde\x91\x23\xb0\xfa\xf4\x7d\x54\xd2\xe6\x9a\xa4\x8a\x7c\x62\x0b\x2f\x23\x1d\x09\x91\x3b\x57\xfd\x60\x68\x20\xd3\x55\x88\x64\x68\x4c\xc9\xcd\x85\xd5\x41\x85\xda\xa0\xae\x46\xe2\xcb\xca\x35\xc4\xa5\xda\x74\xb9\x86\xd4\x54\x43\xae\x8e\x51\xd9\x0c\x40\x65\x0b\x5f\x16\xc8\xcb\x4c\xbc\x18\x3d\x7c\x9c\x23\x97\xf6\x86\xc5\xd4\x9b\x2e\x12\xa3\xac\x64\xbc\x31\xc0\x7f\xc2\xa2\xa1\xdd\x81\x3c\xe1\x62\x71\x7e\xfc\xd6\xa7\x6c\xc5\xb2\xc5\x45\xe3\x3a\x5a\xc7\x98\xdb\x2d\x7b\x5a\xb3\x94\x7a\xad\xea\x98\x49\x4b\x8f\xe8\x5c\x04\x9d\x8a\x92\x31\x71\xed\xb1\xbb\x26\xf7\xe9\x7a\x7d\xd4\xe3\x8f\x94\xe7\x68\xc7\x34\x8e\xba\x67\x12\x1c\xae\xf1\xa2\xc8\x9d\x8b\x85\xff\x89\x1d\xd5\x72\x87\xe1\xfd\x94\xa1\x55\xf9\x4a\xc5\x8a\x92\x99\x13\xb8\x84\x72\xee\x5f\x69\x2b\x16\x3d\x18\xcb\x9d\xa1\x66\x5b\x7b\x55\xe8\x3f\x2d\xcb\x18\x53\xdb\xf0\x20\xe2\xdb\xc9\x35\x30\x4d\x4c\x35\xbe\x71\x0f\x04\x03\xc8\x21\xc1\x06\x91\xa2\xd3\x52\xe9\x54\x90\x6c\x30\xc6\x28\x63\x90\x00\x94\x16\x5b\x82\x0d\x09\x24\x21\x4e\x99\xa0\xd1\x24\x28\xe3\x18\x60\x4e\x90\x5b\x4c\x51\x02\x82\xaa\x88\x87\x91\xf8\xcd\xde\x6c\xde\x5e\xe2\xa3\xbc\x62\x44\xeb\x55\x7a\xfc\xb2\x49\x83\xa4\x20\x0a\x05\x5b\x4c\xe1\x86\xe0\xb0\xc5\xfc\x39\x9f\x35\xe6\xf6\x44\x1e\x07\x9e\x40\x36\x8f\xe3\xbc\xc7\x69\x15\x26\x90\xef\x92\x53\x73\xca\xac\x60\x06\x9c\x5a\x09\x0b\xe3\xe6\x14\x05\xa7\x8f\xdf\x34\xb1\x62\xd6\x82\x45\xf7\x23\x73\xa9\x69\xfc\x46\x01\x73\xd1\x24\x52\x2d\x3e\x4f\x6c\x05\x43\x5f\xbe\x73\x8c\x75\x4d\xd2\xf4\x71\xdc\xe9\x71\x6b\xba\x5e\xa3\x7e\x9b\x35\x7f\xf4\x19\xee\xbf\x63\x97\x2d\xdc\x0f\x5b\xc4\xb3\xe5\x6b\x90\x1e\xe4\x82\xea\x40\x36\xa0\x72\xa8\xda\x60\x8e\xd1\x64\x50\x19\x90\x18\x54\x56\xbb\xcb\x5e\x1d\x4c\x74\x65\x78\xbd\xda\x94\x78\x95\x4b\xab\x75\xa9\xe2\x19\x4b\x8a\xc1\x82\x2d\x86\x4c\x0d\x7c\x91\x92\x10\xce\xd9\xf2\x65\x22\x65\x8b\x44\x84\xe9\x40\xc3\xef\xf5\x91\x83\x20\x78\xb7\xd5\xc1\x8c\x9b\x3d\xe9\xd0\x2f\x29\x1a\x47\x92\x60\x38\x9c\x9e\xde\x1d\x43\xed\x36\x81\xef\x5c\x4f\x2c\xf5\x84\x42\xc1\x0e\x5e\xb0\x63\xdc\x8c\xf1\xf4\x3d\x96\xef\x9f\x2e\x52\x63\x7b\xa1\xe2\x3a\xe1\x7a\xb2\x3c\x30\xe7\x56\x1e\x9c\x98\x3f\x70\x70\x59\xdb\xb4\x22\x13\xe6\xed\x79\x92\xe3\x3c\x02\xa4\x82\xca\x40\x8a\xd5\xac\x35\x57\x07\xd5\x5a\x47\x5c\x72\x5c\x75\xd0\x9d\xec\xd2\x26\xc7\xc4\x24\x6b\x5d\x0c\xb0\xdb\x00\x5b\x1b\x04\xc6\xdb\x0e\x2d\x76\xee\xf8\x1b\x9e\x7f\x8f\x9b\x54\xfa\x8b\xd2\xb4\xe4\x94\x8a\x15\x9b\xdd\x29\x72\x26\x4e\xcb\x98\x48\xce\x80\x14\x33\x42\xf3\xa8\x66\xf3\xb1\x53\xd1\xd4\x3f\xf2\xda\xbb\xf8\x4e\x2b\xb4\x96\x2f\x67\x86\x22\x0f\x65\x50\x20\x33\xa7\xa0\x26\x88\xef\x7b\xd3\x29\xed\x69\xb1\x6e\xa5\x3d\x27\x2f\xd6\xed\x8e\xcd\xcb\xb1\x2b\x15\xb4\xcb\xe5\xc1\x53\x96\xd6\xc8\x56\xb0\xf0\x89\x3d\x71\x76\xe2\x0c\x2c\x68\x95\xae\x82\x4b\x26\xf9\x96\xc4\x4f\xf7\x90\x9a\xae\xfc\x76\x72\x3a\x3e\x4f\x8b\x9d\x76\x9e\x3b\x85\xd2\x4e\xdf\xe4\x7e\xf8\xe6\xd5\xe7\x15\x8f\x2a\xd7\xac\x85\x39\xc3\x1a\xe7\x56\xaf\xc9\x1e\x6a\x6d\xf7\xee\xd0\xff\xfa\xe9\xb9\x67\xe0\x63\xcc\x3f\xb8\xef\xb2\x6b\x37\x0d\x5a\x97\xe7\x74\x9a\xdb\xdd\xd3\x75\x70\xdc\xf1\x97\xd7\xef\x4c\x6a\xa8\x79\xbe\xa0\xca\x99\x12\x9f\x31\xfd\x6c\xa6\x3b\xef\xd1\xa7\x56\x6f\xb5\xee\x3d\x96\xea\xf3\xa6\xdb\x32\x9c\xc5\x8f\xe7\xa4\x90\xf5\x69\x52\xe8\x5b\xc6\xc7\xd6\x81\x9e\xa0\x2e\xe0\xb2\x5b\x74\x16\x34\x2e\x3a\x6f\x46\x5e\x46\x75\x30\x3f\x2f\x47\x97\x67\x30\xe4\xe9\x72\x18\x37\x74\x27\xe0\xb5\x4b\x1f\x74\xdb\x55\xa4\x86\x38\x4b\x43\x03\xb9\x5f\x4a\x2a\xd6\x2e\x9d\x4f\x8c\x18\x2c\xbf\x8f\x1c\x84\x70\xf3\xae\xb7\xb0\xa7\xe4\x15\x3e\xe3\xf9\x95\x7c\x1c\x87\x02\x66\x69\x3e\x42\x9d\xf3\x58\xdb\x52\x3f\x3c\xed\xe4\xaa\x07\x2a\x73\x58\x61\xf0\xd8\x62\x26\x91\xad\x18\xbf\xf1\x58\xfc\xe9\x23\x0f\x2d\x54\xe7\xa6\x09\xc3\x98\x59\x46\x1f\xdf\x01\xe3\xb9\xeb\x3b\xb8\xdd\x34\xbf\x68\xd1\xf7\xc7\x5a\x73\xfb\xa4\x6c\xce\x5d\xd4\x90\x96\x73\x83\xc5\x03\x4a\xc3\x2c\x44\x75\x39\xd2\xc1\xd9\xe4\x7c\xfa\xa0\x80\x97\x42\x2e\x75\x75\x30\xce\xa9\xd2\x98\xd0\xb0\x59\x4c\x31\x4e\x53\x62\xa2\xc9\x19\xc3\x28\xec\x76\x64\x6f\xec\x06\x05\x8d\xa6\x9d\xed\x16\xe7\x2f\x23\xf8\x4b\xf1\xe2\xb3\x44\x7e\xb9\x13\xc2\x9f\x0e\x15\x95\x93\x0e\x14\xee\xe7\x4e\x53\xcf\x38\x6f\xae\x70\xc2\x95\x25\xf1\x5e\x2f\xa2\xfb\x8e\xfa\xc2\x65\xb0\x4f\xd7\x6e\x27\x5d\x12\xcf\xed\x1c\x90\xc5\xfb\x1c\xf0\x94\x97\x3b\xbf\x75\x33\x5c\xa2\xc7\x34\x27\xc3\x5e\x5b\x37\x73\x7b\x2d\xf9\x88\x27\xde\x67\xfe\x8e\x1b\xc3\x64\x21\x7d\x4c\x01\x05\xa0\x57\x20\x39\x36\x4e\xab\xd1\xe7\x22\x1e\x34\x7a\x97\x9e\x61\xf4\x2e\xda\x06\x6c\xe9\xd5\x41\x9b\x93\x1c\x63\xed\x56\xd1\x1d\xbb\xcd\x84\x74\xd9\x81\x22\x5a\xe9\x93\xaa\x28\xe0\x81\xf1\xe0\x9d\xc4\x4a\x68\x41\x33\x48\x5e\x6c\x21\x86\xa2\x5e\x3f\x7a\x9a\x79\x96\x9a\xd0\xf4\x6b\x79\x3a\xb5\xfd\xfb\xfd\xbb\xaa\x37\x74\xae\x6b\xbb\x3b\x9e\x56\xa6\xb2\x4f\x58\x12\x0f\xe7\x40\x70\xa3\x6d\xea\xd8\xd5\x63\xca\x9b\x67\x56\x6f\x9f\x56\xcc\x0c\xdd\xb2\x2e\x6e\x68\x0d\xf7\xe2\xf3\x7f\x39\xf0\xe0\x4a\xee\xcc\x9b\xd3\xa7\x8f\x4f\xdb\xaa\xae\xdd\x41\x97\x7d\xf2\xd9\x6f\x0f\xae\xde\x31\xe2\x31\x68\x69\x9c\x33\xa9\xfe\xf0\xdf\x49\xfc\x54\x0c\x3f\x60\x54\xcc\x11\x5c\xcb\xe8\x8c\x92\xba\x08\x53\x2f\x04\x95\x4a\x05\x03\xd4\x24\x33\xa4\x40\x3c\x08\x2e\x3b\x7d\xc4\x56\x72\x47\x2a\x97\x6c\x5d\x52\x0a\xc7\x94\x2e\xdd\x0a\x3f\x80\x55\xdc\xb3\xd4\xeb\xdc\x7b\x30\xa3\xcb\xc7\xfb\xe2\x3a\xb4\xbe\x8c\x45\xe3\x9d\x84\x56\x98\x8c\x80\x8d\x49\x46\xc3\xca\x30\x2e\x9d\xcb\x8b\xd7\x13\x52\xa9\xdd\x10\x91\xed\x85\xf3\x31\x1d\xf8\xfe\x72\xfe\xbb\x27\x1e\x47\x16\x87\x4d\x89\x8c\x70\xbf\x24\x8c\x38\xd9\xa1\x3b\x08\x4d\xf7\x15\xf8\x46\x5e\xed\x7a\xc2\x49\xa7\xc5\x73\xaf\xc6\x27\xe7\xf6\xab\xe9\x97\x7b\x88\xfb\xfc\x91\x67\x3e\xa6\xca\x57\x5c\x18\x73\xc7\xea\xa5\x9d\x4d\x5b\x3c\x07\x21\x75\x4f\x79\x61\x76\xff\xc2\xcd\x5b\x37\x7d\x68\x76\xdb\x62\x0b\x2a\x86\x4e\x58\x5d\x73\x98\x0b\xed\x7e\x9b\x9a\x3c\xed\xcf\xeb\x56\x6d\x99\xf1\xa7\x75\x2b\xb7\x00\x21\x0f\xfe\x65\xf6\x15\xf6\xdf\xa0\x18\xdb\xca\x22\x98\x99\xe9\xed\x09\x72\x63\xd2\xbd\xe9\x35\xc1\x42\x6b\x5e\x22\x63\xc9\x06\x5e\x63\x82\xa3\x26\x98\x9c\x60\x57\x5a\x88\x1b\x70\x59\xc8\x08\x76\x94\x0a\x05\xd2\x91\xc0\x70\x20\xcc\xd7\x04\x10\x33\x72\x95\xc4\x23\x82\xe2\xcc\xc3\x2b\xa1\x37\x62\xbb\x13\x9f\xf9\x51\x42\x1f\xd3\xd8\xbf\x9f\x7d\xdb\x91\x8d\x36\x6f\x16\x7c\xc2\x66\x58\x7e\x64\x22\xf7\xb6\xa5\x5f\xea\x80\xb8\x96\xe6\xc1\xd9\xe5\x87\x1f\x84\x9a\x6d\xab\xe2\x36\x4c\x9a\x93\xf7\x46\xdc\x1b\x0b\xe1\xe8\xbb\x3a\x86\xda\xe0\x9f\x0f\x33\xc3\x94\xc1\xe6\x21\x0b\xbb\xf2\xa8\x93\xf3\xca\x2a\xf2\x2e\x97\xd7\x74\x6d\x87\x37\xb9\xa3\xe9\x31\x1b\x63\x9d\xfd\x9e\xb4\xa4\xe7\x51\x6f\xaf\xff\xee\xbb\xf5\x5d\x27\xe0\x7a\xea\x33\x6e\x75\x0b\x0c\xf1\x7b\x75\x77\x23\x67\xb2\x52\xb8\x67\xdd\xa4\x24\x59\x82\x4c\x1e\x3e\x5c\xa7\xc6\xe9\x81\x78\x75\xc3\x87\xcf\xc4\xeb\x2b\xf0\x5d\x81\x4a\x0f\xb9\x5d\xe7\xf8\xec\xb1\x1d\x63\xe7\xc7\xcf\x6f\xe9\x68\x99\x4d\x4d\x87\x7f\xe1\xf2\x36\x72\x09\xf0\x53\xbc\x2f\x21\xe0\x34\x2b\xd8\x07\x88\xaf\xda\x85\x74\x61\x1f\xf2\x35\x12\xc9\xcd\xb2\xb5\x81\xec\x84\x04\x47\xac\xc7\x92\x08\x50\xc8\x99\x6d\x04\x6a\x55\xac\x4d\xc5\x08\xa9\x89\x36\xc6\x96\x84\xa6\x91\x5d\x87\x8c\xa0\xce\x88\x5a\x2b\xa3\x52\x02\xc5\x4b\x29\xf8\x04\x4e\x13\x7f\xef\xbd\xcf\x1c\xe9\x4a\x20\x22\xf1\x05\x33\xfc\x06\xb7\x47\xca\x53\x95\xe2\xd0\xea\xa5\x95\x66\x5a\x72\x1f\xf4\xc3\xe2\x87\x2d\xe6\x76\x60\x6f\x63\xdc\xf9\x33\x4b\x29\xb0\x62\x7f\x6e\xd7\x17\xba\x59\xd0\xb9\xe9\x68\x2e\x65\xd3\x06\x11\x7f\xfd\x17\xc6\x0a\xfe\x43\xef\xe0\x46\x4e\x75\x51\xd3\xc4\xc5\xd1\xdb\xb9\xed\x27\x5f\x1c\x5e\xba\x6c\x21\x5d\x77\xe2\xd4\xf0\x9e\xb3\x78\x5b\x41\xee\xa0\xc3\x67\x7e\xed\xc8\xda\x15\x04\xe2\xb5\x09\x76\x80\x6f\x77\x16\x59\x34\x28\x28\x83\xc1\x81\x2b\x65\x87\x33\x2d\xa2\x52\x52\x85\x3b\x20\x95\x1e\xb1\xe6\x79\x25\xc4\x5c\xa0\x69\x41\xac\xf7\xc4\xa9\x63\xcf\x8f\x85\x37\xd0\x5f\x93\xe3\x27\xc7\xa6\x71\x3f\xbf\x76\xea\x19\x4d\xec\x54\x78\x65\xfd\xae\x78\x13\x67\x36\x69\x5a\xf9\x11\x21\xa3\xb2\xe2\xe9\x17\xee\xd9\x94\x53\xb8\x82\xdb\xbd\x6d\xf3\x98\x31\xc5\x59\x63\x1b\x31\x8d\x49\x88\xc6\x6b\xe4\x2e\xd5\x1c\xe0\x0f\x24\xc4\x65\x78\x00\x5a\x47\xed\x5a\x00\x5c\xf8\x12\x6a\xb6\x3a\x68\x54\x18\x5c\xa9\x38\xa2\x10\xa8\x94\x0a\xb3\xcb\x08\x45\x7e\x1d\x9e\xa8\x38\xda\xc9\x85\x78\x3f\xd0\x9d\x08\x1d\x88\x6c\x7c\x6e\x9a\xbf\xb8\x58\x92\x7d\x69\x73\xda\x8a\x65\xdc\x2f\x4e\xf8\x92\xb3\xfe\x1e\x1f\x35\x9c\xaa\x1f\xec\x84\x2f\x3b\xb9\x9f\xeb\xfa\xb0\xe3\xe2\x87\x19\x1e\xe5\xb8\x03\x2f\x7c\x64\x1e\x02\x7f\xdc\xf5\x56\x42\xd7\x6e\xcd\x7a\x6a\x7a\xed\xae\x89\x5b\xb7\x7a\x1f\x5b\xb6\xf0\x58\xc6\xd6\xad\x13\x77\xd5\x6e\xdc\x72\x63\xed\x0b\x8f\x15\x34\x73\xf7\xfe\xf9\x48\x45\xe6\xaa\x4d\xe4\xfe\x17\xa4\x5b\x38\xe6\xf7\xa0\x55\xb4\x2c\x90\xa4\xd3\xc7\xc7\xe9\xe3\x2c\x09\x09\xc8\xcc\x24\xa0\x00\x5f\x65\xb1\x69\x90\x99\xd6\xd8\x89\x6b\x93\x10\x8e\x70\x7d\xf2\x60\x5f\xfa\x86\x5b\x49\x2a\xa6\x8b\x21\xbe\x8f\x16\x82\x79\x4a\x49\x53\x51\xd1\xbc\xad\x6c\x60\x72\x6e\xff\x55\x2e\x47\xff\x01\xb2\xb8\xfe\xc7\x8e\xda\x14\x12\xc1\x4f\x1d\x53\x58\x36\x2f\x1c\xc1\x73\x0d\xe4\x46\x25\x29\x90\x67\xbe\xe6\x82\x07\x50\xec\xbe\x97\xdb\x3b\x8b\xfb\x8e\x7b\x8f\xd9\x2c\x8f\xde\x31\x5f\x6d\x88\xaf\x2b\x88\xaf\x14\xc4\x57\x55\x40\x93\x42\xe2\xf7\x24\x4d\x92\x19\xbb\x02\x8e\x60\x92\xcd\xee\xac\x0d\xda\x13\x8c\x40\xd3\x83\x04\xf0\xe9\x91\x01\x7c\x78\xd2\xdc\x3a\x72\xc7\xf7\x97\x47\x5c\xc2\xd4\x3d\x58\xa7\x63\x23\x83\xf5\x86\x0e\x8e\x6b\xf2\x97\x71\x9f\x8b\x9c\x07\x6f\x1f\xa1\xc3\x17\x7e\x7d\x53\xba\x47\xea\x96\xb1\xf9\x31\xc4\x5f\x16\xfb\x1a\x9a\x21\x65\x01\x0b\xae\x66\x8f\x94\x0f\x00\xa3\xc9\x58\x13\x4c\x32\x19\x62\x20\x66\x53\x1d\x8c\xb1\xb1\x9a\xda\x20\x2b\x1f\xb7\x08\xcf\xba\xfb\x45\x52\x24\x08\x17\x9d\x54\x9f\x92\xfa\x7e\x5f\x1d\xa6\xb9\x24\x90\x94\x53\x89\x68\x1e\xf7\xd4\x7d\x71\xf7\xc5\x26\xed\x5f\x3f\xa4\x20\xbe\x47\xca\xc0\x61\x06\xcb\x5f\xe3\xe8\x0b\x37\x3f\xc5\xc4\x1a\x0e\x99\xf6\x2c\xa1\x2f\xac\x5f\x7e\xef\x1a\xdd\x66\xd5\xd0\x86\xf1\xeb\xd1\xba\xff\x0b\x5a\xf7\xef\x23\x7e\x68\x15\x68\x0c\x38\x35\xda\x94\x9e\x38\x26\xd4\xc6\xc4\xb9\x52\x52\x62\x5c\x06\xbb\x1f\x11\x6e\xcc\xca\xf1\xe6\x60\x8a\xcd\x41\xc6\xeb\x8d\x01\x31\x95\xd5\x88\x74\xe2\x09\x38\xa3\x16\x39\xe9\x62\x2c\x61\x37\x2d\xec\xcc\x08\x5f\x27\x2d\xd2\x77\x28\x33\xbf\x9f\x40\xbe\xd0\xe3\xd5\xc3\x4d\x87\xd3\x03\x10\xb7\x4a\x5e\x25\xa5\x4a\x30\x14\x1c\xfd\xc4\x69\x0a\xbb\x09\x3f\xf7\x4e\xa7\xfa\xbe\xb8\x6c\xff\xae\x9a\xf5\xcf\xb5\x8b\x7e\x82\xd2\x61\x99\x0f\xb5\xc3\x0d\xf3\xfa\xf9\x12\x5d\x5a\x7b\x7c\x22\x9b\x33\xcb\x3a\x26\xbe\x6d\x6a\xe3\x2a\xd1\x6f\xe0\xc6\x6c\x5f\x8d\xfc\x06\x58\xfe\xfc\xa4\xd9\x07\x1e\x5c\x05\x47\xbe\xc1\x3b\x0e\x89\xc1\xe9\x5d\x4f\x71\x8b\x46\xb6\xa9\xee\x57\x64\xc5\x7e\x3c\x99\x2b\x61\xc6\xaf\xde\x31\xf2\x51\xee\x6b\xd1\x89\x80\xa0\x1d\x8d\xe7\x93\x48\x5f\x1d\x20\x27\x60\xb5\x80\xda\xa0\x25\x41\xc1\x6a\x63\x18\x46\x67\x50\xa3\x70\x99\x31\x90\x1b\x01\xc4\xe4\x32\x12\x34\x91\x2d\x15\x3c\x6e\x90\x5c\x22\x4f\xce\xfe\x8a\xe3\x49\x1d\x44\x83\xe5\xe5\xbe\xbb\x7f\x68\x07\x4c\xee\xe8\xa0\xfa\xfc\xb5\xeb\x1b\x08\xda\x44\xf5\xe3\x7e\xdc\xb3\x04\xde\x98\xcd\xad\x61\xaf\xde\x1c\x4f\xe9\xb9\x3c\xae\x40\x50\x37\x4c\xcb\x97\x5c\x03\xbd\x85\xe4\x29\xa4\x04\x74\x80\xd2\xa3\x58\x4e\x9f\xa0\x04\x0a\x35\xa1\x41\x11\xae\xd0\x40\xf2\x8b\x78\xdd\x81\xe2\x7c\x80\xea\x8c\xe2\xd5\x2e\xc7\x24\xe8\x46\xfa\x5e\x8f\xef\x22\xeb\xd1\x3b\xa4\xdb\xb3\x84\xbd\xca\xab\xb4\x96\x3f\xd7\x0c\x10\xbf\x07\x50\x4c\xd5\x0b\xf4\x0d\xa8\x5d\x09\x36\xab\x15\x4d\xb3\x74\x7e\x72\xfa\x6c\x59\x79\xb5\xc1\xac\x84\x52\x45\xac\xa2\x3a\x98\x1c\x8b\xe2\x48\xa0\x25\xae\x82\xa4\xbe\xa2\x4a\xe0\x6d\x16\xbc\x59\x20\x3b\x44\x80\xb7\x0a\x90\xea\x92\xc1\x77\xc1\xf0\x27\xfa\x48\x55\x97\x5e\x80\xc7\xb0\xab\x50\xb9\xd0\xbd\xf8\xe8\xa3\x78\xbb\x60\xaf\x45\x4d\x95\x2e\x1b\x36\xa6\x1f\xd5\x6b\x5d\x5d\x43\x8d\x7d\xce\x04\xf9\x9c\x1d\x8f\x81\xfb\xcc\x4d\x5e\xce\xfb\x09\x97\x8e\x74\x1d\xa6\x47\x91\x1d\x83\x35\xf9\x33\x82\xe3\xc6\x29\x66\x8c\x6d\x9c\x38\x6c\x41\xd7\x6b\xe1\x5b\xe0\x08\xe0\xb1\xc7\xba\xb6\x13\xbe\x87\x23\xbe\x07\x91\xfa\x13\x05\x01\xbb\x17\x8d\xb3\x37\xc1\xa5\xc1\x01\x58\x7c\x5c\x1c\x63\x33\x18\x6c\x8c\x27\x72\xa4\xb1\x8a\x4b\x05\x0d\x22\x49\xe7\x79\x95\x7d\x7c\x0e\x33\x49\x9d\x40\xc4\x4e\xd9\x18\x53\x33\xa5\xfd\x42\xf2\xf2\x8e\x47\xc5\x8d\x90\x51\x4f\x2d\xbe\x7b\x8b\x61\xce\x58\xb9\x22\x50\x27\x87\xf8\x6a\x06\x9e\x79\xb0\x6b\xbb\xc0\x8a\x62\x45\xc9\xbc\xe6\x85\xab\x7b\x8d\x90\xd8\xe0\x7d\xf8\x2e\x61\xcf\x23\x1d\x14\xe1\x3a\x1e\xae\x2c\x4c\xb7\x3e\x26\x3e\x2e\x26\x4e\x6d\x33\x98\x13\xb4\x05\x38\x67\x54\x6d\x93\xaf\x15\x52\x99\x2a\x71\x4b\x03\x4a\x33\x90\x2c\x15\xfc\x21\x0f\xb9\xf3\x41\x21\xc3\x13\x03\x61\xe4\x5e\x06\xfc\x95\x5c\xb7\xd7\x6b\x98\xd1\x5e\x52\xcc\x3b\x1a\xbf\xca\x36\x30\x7a\x8d\x1f\x9a\xe5\x7c\x1c\xc6\xc9\x76\x31\xc8\x92\x51\x55\x33\x4f\x4f\x5c\x0d\x96\x96\xf6\x2f\x66\x71\xd7\xdf\x1d\xf8\xd1\x5d\xf7\x31\x77\x45\xef\x61\x4c\x47\xfc\xd9\x48\x4e\x73\x5e\xc0\x1a\x8f\xc6\x26\x3e\x41\x6f\x46\xba\x6f\xd4\xa8\xd5\x8c\xd2\xc0\xd8\x23\x46\x46\x3e\x30\x16\x32\x30\xb8\x0c\x90\x2f\x6c\x3f\xc3\xa3\xf1\xc3\x4a\x97\xa3\xf9\x70\x9c\xf9\x98\x87\xe9\xbf\x71\x4a\x0a\x8e\xee\xe7\xee\x4f\xad\x1e\x25\xde\xd4\x87\x47\x81\xee\xbd\x65\xfe\x87\x5b\xa6\xa2\x98\xfe\xb9\x0b\xdc\x54\x99\xdc\x21\xb9\x87\x63\x28\xb2\xa1\x45\xa0\x34\xe0\x52\x69\x2c\x68\x81\x45\x3f\x9a\xa4\xa4\xb4\xea\x60\x92\x51\x63\xba\xd5\xfa\x2c\x95\x4f\x21\xc7\x24\x23\x17\x68\x29\x86\xcf\xa5\xbc\xb9\x54\x64\xf0\x4e\x39\x12\x69\xac\x48\x14\x55\x4d\x24\xbe\xd2\xe5\x5a\xf8\xf0\x6b\x7f\x52\xf2\x01\x7c\xe6\x90\x29\xbd\x56\x2c\xee\xf3\xeb\x27\x62\xec\xee\xed\xdf\x5a\xb2\x72\x56\x65\xa2\x72\x54\x19\xbf\x46\xdf\xe3\x23\xd1\xfb\x0b\x19\x45\xe9\x2e\x93\xbb\xaa\xa5\xea\x11\x12\xbb\x1f\x4f\xcb\xf7\x38\x0d\xee\xa2\x5e\xc3\xb2\x13\x53\xb8\x3a\xee\x3d\x1c\x2b\xbc\x82\xec\xcc\x3b\xc8\xce\xa4\x83\x8a\x33\x09\x0e\xfe\xd6\x3b\x0b\x0a\x74\x12\x2c\x09\x96\x54\x35\xa0\x52\x51\x2c\x15\xdf\x11\x4c\x4d\x50\xc7\x10\xc9\xab\x41\xc4\x15\x37\xe4\x26\x2a\x24\x7c\x9a\x3f\xf2\x61\x41\x2b\x33\x11\x3c\x29\x86\x29\x9b\xec\x6e\xbe\x0e\x7d\x5c\xbe\xa7\xb8\x5f\xb6\xe5\x93\x7e\xb0\x57\x43\x46\x52\x6e\xc0\x3f\x24\xdf\x7a\x08\x3e\x57\x5a\xc6\xdd\xc8\xc8\x4d\xca\xce\x58\x94\xe8\xe4\xfe\xe9\xf5\x3c\xf9\x40\x51\x7e\x08\xc4\xe4\xd4\x4f\x65\x76\xc2\x09\xe6\x87\x9d\x05\x0d\xad\x37\x5f\xe3\x3e\xe4\xde\x53\x1d\xd0\xdc\xbb\xf5\x4a\xc7\x29\x2d\x1e\x93\x77\xb9\x7a\xe6\x15\x72\x3f\x7a\x76\x40\x6d\xd1\xdb\x63\x0c\x4a\x35\xa3\xe6\x57\x5d\x46\xaf\x47\xe1\xb9\xde\x16\x71\xc7\x24\x39\x33\x91\x26\x37\x42\xf8\xe2\x3e\x7b\x12\xc4\x37\x46\x53\x67\xbe\x2e\x0c\xd3\xe1\xe0\x8e\x5e\xf8\xd3\x64\xb5\x86\x19\x91\x05\xd7\x74\x6e\xe5\xbe\xe7\xfb\x5e\xca\x94\x75\x05\xfa\x2d\x2c\x7a\x64\x20\xf5\x3c\xd1\x0b\x1d\xa2\xe1\x01\x42\x43\xfe\x39\x93\x25\xc6\xc2\xaf\xa0\x31\x0e\xa0\x70\x30\x0e\x64\x54\x1c\x36\x25\x63\xa0\xc8\xa6\xbc\xa8\x0f\x3c\x35\xe4\x3b\xab\x78\x6d\x62\x84\x5d\xa4\x06\x47\xde\x9b\xf8\xb7\x36\x44\xd7\xd7\xde\xdc\xc4\xec\x8c\xc5\x89\x8e\x32\x7c\x8b\xa0\xec\xea\xc4\x66\x89\x34\x42\x4f\x39\xa2\x67\x36\xc9\xd5\x2b\x38\x87\x2f\xcd\xc7\xf4\x58\x82\x6a\xb3\x85\x35\xb3\xb8\x88\x0c\x23\x94\xe6\x88\xb8\xd5\x46\xa4\x88\xdf\x79\x88\x18\x37\x3f\xbd\x89\xdf\x66\xb8\xf9\x3a\xf5\x8c\x9c\x8e\xae\x78\x27\x7d\x6a\xeb\xe6\x9b\xef\x4b\xfd\x6f\xc6\x3e\x5f\x32\xea\x7f\x1f\x9a\xbf\x3e\x10\x00\xc3\x03\xae\x1c\x67\x4d\x30\xc7\x96\xdf\x93\x2d\xab\x09\xf6\xc4\xf7\xaf\x01\x93\x09\x17\x71\x31\xa6\xa6\x78\x53\xf8\x91\xf2\x02\x50\x28\xed\xc6\x46\xdc\x06\x8a\x95\xab\x54\xda\x8d\xc6\x75\x1c\x8d\x69\xfe\xa8\x82\x26\xe1\x53\xe8\xc2\x3f\xf8\xf6\xa9\x4a\x48\xfc\x76\xfe\xdc\x6b\x25\xe4\x8f\x1a\xc3\x9e\x9b\xef\xa4\xdc\x3f\x58\x9b\x27\xad\x58\xed\xbc\x38\x09\x6e\xba\xba\x4b\xd3\xa8\x1a\xe0\x74\xe7\x2a\xc6\x65\xe4\x25\xe5\x67\x7c\xaa\x89\xdd\xc0\x2a\x9a\x5e\xeb\x3b\xf1\x89\xa5\x46\xd3\x4b\xf7\xee\x19\x39\xc2\xba\x69\x21\x3c\xac\x62\x66\xa7\x8e\x1a\x3e\xba\xc1\x04\x53\x0f\xcd\xca\x29\xe4\x72\x33\x93\x82\xca\x1b\xc9\xb1\xe3\x34\x07\x54\xaf\x66\x15\x2d\x53\xef\x48\xf4\x2c\x9f\xbe\x69\xec\x81\x51\x41\x86\x29\x5d\xd8\xd2\x7f\x28\x92\x43\x7f\x24\x87\x26\x66\x08\x48\x03\x85\x60\x50\x20\x3e\x8d\xf8\xbe\x29\x86\x14\x64\x28\x52\xd0\x12\xa3\xc9\xc7\x1e\x6f\x9c\x83\x9f\x72\xea\x60\x02\x4d\x67\x4a\xde\xaf\x24\x84\x70\x0d\xa6\x5b\x3b\xc0\x28\xbc\xa2\x23\xf9\xbe\xd5\x07\xab\xaf\x22\x7c\xe0\xc4\x8e\x0b\xfd\x0a\x30\xc7\x89\xf9\x99\x9f\x68\xe2\x86\xdd\xd6\x01\x3e\x72\xb3\x86\xeb\x92\xb8\x6c\xef\xe6\x01\x53\xa0\x1f\xd7\xc0\xee\x60\xdf\x27\xdf\x1d\x2a\xf0\x7e\x92\x37\x3d\x2e\x3d\xc1\xe3\x41\xde\xbc\xc7\x98\x80\x06\x35\xc1\x6e\xd6\xd7\x06\xcd\x09\xc4\x30\x02\x99\x61\x8c\x72\xec\x85\x2d\x59\x25\x2d\xdb\xd6\x43\xdc\x50\x9e\x48\x7e\x2d\x66\x3a\x22\x80\x61\x35\x55\x7d\x92\x8b\xcb\x97\x24\x85\x94\x1e\x7f\x46\x7e\x52\xd1\x90\xd7\x35\x29\x2e\x6a\xd8\x99\xe5\x88\xdd\x39\x70\x53\xfb\xe6\x44\xaa\xac\xec\xf1\x99\x0b\x17\x3d\x10\x6c\x9c\xbc\xe6\xf1\xf1\xec\xfb\x86\x23\xb6\x3d\xbf\xfe\x6f\x4a\xbc\xa7\x48\xf7\x90\xee\xe5\xec\xe2\xb3\x1b\xe7\x4c\x38\x72\x14\x33\x3c\xb6\x05\x26\xc3\x8c\x9b\xbf\xad\x58\x74\x90\x3b\xb9\x66\xc1\xfc\x43\x30\x80\xf5\x79\x21\xb2\xfb\xb3\x90\x3e\x7b\x41\x2e\xe8\x15\x70\x66\x27\xa0\x90\x3e\x35\x3b\x35\x3b\xc6\x6e\xcf\xc0\x5e\x73\x8c\x1b\xb9\xc9\x76\x86\xc2\x7b\x4e\xc8\x3c\x2a\xbb\x5f\x1c\xcb\x6b\x31\xbe\x33\x55\x36\x4e\x0a\xc9\x3b\x46\xab\xad\x01\xba\xa5\xb4\x04\x5a\x81\xbf\x2f\xb9\xfd\x46\x7a\xff\xc4\xbe\xd9\x89\x83\xfc\x9f\xab\x93\x16\xdd\xdf\xf9\x66\xf5\xa1\x7f\xdd\x05\xdb\x6d\xcc\xcd\x9b\xfa\x55\x6d\x53\x4e\x64\xed\x1d\xa6\xf8\x68\x63\x67\x0a\x35\x88\x39\xdb\x6c\x78\xc0\xf0\x7a\x86\xef\xe1\xe2\xcb\xcf\xaf\x84\xee\xbf\xce\xe2\x36\x36\x4e\x8f\xed\x5f\xb8\x6e\xcb\x98\x11\x3d\xb8\xfb\x93\x98\x89\xa7\xef\x1b\x84\x33\x0d\xc1\x3e\xc4\xcb\x40\xc4\x4b\x31\x18\x74\xae\x47\x76\x7e\x36\x56\xbd\xe4\x60\x7e\x82\x12\x17\x05\xa8\x0e\x16\xa5\x25\x98\xcd\x09\x69\x34\x88\x89\x41\xa1\x7e\x8c\x11\x07\xd3\xdd\xeb\x0c\x95\xf2\x61\x40\xa5\xec\x92\x6b\x64\xf8\x85\xf3\xcc\xc9\x2e\xa8\xe4\xe7\x27\x7f\x35\x82\x98\x63\x1e\xa5\xa5\x0a\xf8\xf3\xa3\x17\x1a\xf6\x8f\x6d\x9a\xff\xeb\xd3\x70\xc0\xa3\xe3\xc7\x4e\x59\xb9\xf9\x6e\xe7\x33\xcf\xb5\xd6\xbd\x56\x77\x4f\x7f\xc5\xa4\x40\x8f\xc4\xbe\xbd\xfe\x57\xe3\x9e\x6d\xdd\xbe\xaa\x7e\xfb\x18\x15\xa5\x9e\x3b\x6a\xdb\xa5\x9b\x0a\x2b\xdb\x77\xf0\x94\xfa\xc1\x03\x37\x2f\x9d\x3f\x78\xc4\x23\x39\xdc\x3e\x97\x7d\x3c\x62\xfe\x6a\xa6\xef\x68\x05\xbe\xab\x12\xf1\xe7\x22\xb6\x67\x50\xc0\xed\xb5\x59\x6d\xd6\xea\x60\x4f\xbd\x2d\x31\xd1\xa6\xa7\xf3\xdc\x79\x86\xea\x60\x9e\x9d\xcf\x8d\xff\x9d\xf1\x92\x73\xd9\x33\xdf\x11\x26\xdb\x6f\x11\x4e\x48\xbb\xbb\x55\x55\x52\x84\x6b\x90\x78\x95\x8a\xff\xf2\x03\xf7\x85\x66\xe0\xe3\xb6\x57\xdb\xb6\x72\xef\xc4\x5f\x0c\xdf\x6b\xb9\xe7\xd4\xb1\x76\x38\x6d\xc5\xc2\xff\xd9\xb6\xa9\x3e\x59\x71\x12\x93\x7f\x25\xb3\x10\xce\xcc\x79\x64\xe9\x84\xc7\xc3\x65\x96\x36\xcf\x6d\x3b\xa0\xa7\xb4\x2b\x9a\x66\x3c\xd6\x58\xf1\xb0\x8b\xdf\x93\xa9\x42\xfc\x9d\x24\xb5\xa1\x70\x3c\xed\x48\xce\xcc\x40\x36\xc3\x98\xa1\xca\x50\x79\xb4\x9e\x5c\x34\xe9\xec\xb1\x76\xa7\x9d\x37\x28\xce\x04\x59\x45\x92\xca\x28\xa3\xea\x93\x2a\xbf\x90\xc3\xe7\x92\x2d\x8d\xb4\x26\x7e\x8b\x78\x59\x9d\x43\x2a\xa6\x42\x1b\xe1\xc4\xe6\x86\xad\x59\x7b\x37\xc3\x82\x37\x77\xc4\x9c\xbe\x53\x18\xac\xaf\x34\x73\x2b\xb9\xef\x2f\x3d\x76\xc2\xf5\xa0\x62\xf0\xbc\xd9\x87\x53\xa8\xaa\xd1\x83\xda\x16\x93\xca\x2f\xd7\xee\x1e\xd4\xd0\xd5\x4f\x1a\x2a\xaa\xfc\x5f\x5f\x9d\x3b\x3a\x7b\xc7\x96\xe2\x1e\xe3\x37\x9c\xb9\x17\x50\x70\x0f\xf2\x41\xa6\x91\x9c\x28\x07\xc8\x0d\x68\x6c\xd6\xda\x46\x14\x78\x1a\x48\xac\xf3\x24\x8a\x75\x50\xe8\x61\x88\xbe\x8c\x4d\x28\xee\x0b\x79\xab\x67\x91\x5b\x42\x1a\xdf\x03\x73\xf1\x0b\x4d\xdc\xb8\xb7\x3b\x3a\x1a\x8b\x15\x64\x38\x9a\xdc\x1d\x6e\xae\x01\x89\x7a\x1d\x53\x76\x73\x3c\xf7\x25\x4f\x8e\xe2\xd5\xe3\xfc\x79\x3f\x80\x1e\x32\xa3\xc8\xb7\xb3\xd2\x80\x89\xb2\xa6\x58\x53\x80\xd7\x9b\x54\x1d\xf4\x1a\xd5\x4a\x9d\x92\x97\xa9\x2e\x01\xc4\xca\xa7\x44\xe4\x42\x45\xbe\x14\x2a\x23\x05\x98\x2e\x56\xa5\x32\x4b\xc9\x53\x94\x54\x74\xf8\xa3\x3b\x5a\x12\x15\xa2\xae\xf4\xd1\x3f\x3f\x63\xf1\x1d\x27\xc7\x2f\x5d\x3a\xeb\xe1\xf4\x4b\xc9\x7b\xdf\x59\x7e\xe5\xcd\x51\x8f\xfe\xaf\xb5\xe7\x7d\x3c\xa5\x58\x49\x86\xf7\x28\x8e\x51\xd4\x4f\xdb\x0e\x8b\xb7\xac\x5f\x3e\x63\xb6\xae\xf5\x40\xf0\xa5\xce\x35\xdc\x3f\xff\x36\x93\xe7\x61\x25\xe2\x01\xe7\x1a\xa7\x82\x9e\x01\x8d\xd3\x15\xeb\xaa\x0d\xc6\x02\x63\x2a\x91\x62\x8c\x91\xa5\x55\x34\x91\xa2\x4a\x94\x22\xd2\x03\xa9\x3e\x2b\x1b\xf9\x3d\x45\x70\xe7\xe4\x8e\x34\x4e\x8b\xea\xe9\xed\x49\xe8\x5d\x30\x43\xeb\x2e\xf5\xfb\x7a\x67\x98\x4f\xbb\x9f\xda\x33\x2b\x23\x39\x37\x30\x6c\x9c\xf3\x78\xca\x81\x75\xcf\x65\x79\x11\xb5\x4d\xe3\xb2\xfd\xc7\x62\x33\x6a\x27\xd0\x77\x3e\x71\xc1\xfc\xb8\x73\xf2\x86\x9b\x9b\x4f\x1c\xd5\x22\x1a\x47\x21\x1a\xdb\x91\x7f\x92\x05\xca\x02\x86\x64\xb7\xdb\xa5\xc9\x32\xa4\xa2\x08\x33\xd5\xee\xd2\x11\x42\x5d\x36\xab\xd9\x61\x26\x84\x3a\x22\x27\x27\xbf\xcd\xc8\x27\x0c\xca\x0e\x87\x76\x5b\x02\x65\xc7\x60\xfd\x16\xf8\xb0\x14\x80\x75\x04\x91\x2e\xf4\xca\x4e\xac\x2c\x47\xba\x31\xdc\xa6\xc4\x81\xd8\xee\xcd\x86\x6d\xc8\xa5\xab\xe5\xa3\x2f\x6a\x41\x58\x35\xb0\xaa\x68\x37\x66\xce\x6b\x5e\xb4\xba\x62\x04\xf5\x17\xec\x2b\xff\x8c\x68\xdf\x89\x68\xcf\x04\xbd\xcf\xb9\x93\x52\x93\xb0\x56\x38\x83\x4c\x1c\xf2\xab\xb4\xce\x54\x06\x68\xb5\x80\xa1\x0d\xa9\x09\xa6\x18\x43\x4c\x75\xd0\x20\xf9\x58\xfc\x67\x48\xb2\x4f\xc2\x0b\xdb\xaf\x14\x2b\x5f\x45\x14\x03\xc1\xd3\xcd\x1b\xa9\x40\x3f\xc0\x75\x1b\xee\x7f\x6d\xc7\xa1\xda\x58\xf8\x54\xd7\x68\x27\xbd\xc0\xc5\x55\x9e\x39\x7d\x17\x17\x3a\xf0\xc6\x04\xc3\x0c\x41\x77\x7a\x5f\x8d\x5d\x3c\xe3\xd4\x86\x59\x93\xd7\xc2\xd1\xdb\xef\xe1\x3a\x74\x0f\xed\x5c\xf5\xee\xaa\x59\xc3\x6c\x93\x05\xc5\xe9\xc3\x9f\x6d\x4f\x85\x1f\xd0\x9f\x93\xdc\x99\x54\x90\x71\x26\xd6\x84\xf3\xff\x28\x9a\xd6\xb3\x42\x0a\x42\x2e\x48\x92\x4e\x59\x93\x68\x51\x3c\x63\xad\x44\xe1\xe1\xef\x1f\xb1\xde\xf4\x48\x1e\x63\x59\xd6\x66\x50\x50\xf3\x55\x0c\xdd\x73\x6e\xcd\xec\x85\xa3\xee\x8b\x1f\xbb\xb0\x77\x70\xe8\xe8\xf1\x25\xf0\x83\x6d\xab\xa8\x71\x35\xc5\x56\x4d\xad\x0d\x1f\xb0\xbe\x9b\xfb\x71\x1d\xf5\xe4\xcc\x77\x5a\x1a\xc7\xcd\xfc\xb2\xee\x14\xde\xc3\xaf\x87\xd7\xe8\xb7\x99\x1f\xc8\x79\x78\xa3\x51\x47\x51\xac\x45\xc7\x27\xd3\xb0\xd1\xe7\xe1\xd1\x7a\xa2\x08\x1f\xc1\x0f\x27\xb6\x53\xd3\xb6\x96\xce\xa8\xfd\xc7\xfa\x6d\x63\x1f\x5d\x35\x6f\x93\x7a\x19\x5b\x55\x55\x3f\xbd\x9c\xea\xf3\x90\xe7\xd3\xfd\x9b\xd7\xfd\xb8\x6a\xf1\x4c\x53\xe5\xc8\x96\xd7\x66\x5e\xc2\xb2\x50\xc0\xa3\xf4\x4b\x48\x16\x29\xa0\x07\xc8\x09\xe8\xb3\x29\x65\x86\x32\x1e\x9f\xb0\x02\x56\x3d\x92\xcb\x59\x0f\xc3\x9f\xd0\x7d\xc9\x27\x9c\xa6\x29\x2d\xf5\x09\x87\x74\xbd\x68\x1a\x47\x5f\xa2\x89\xfb\x77\x88\x67\x47\xbc\xe2\x3d\xbc\x89\x90\x9a\xbb\xa8\xba\x9f\x69\x64\x51\x71\x7a\xe3\xe3\x2b\xe7\x6d\x66\x96\xb2\x03\x2b\xeb\xa7\x57\x28\x6a\xd6\x56\x56\x8f\xbd\x67\x4d\x4d\xcb\xb0\x8a\xb9\xc5\x96\xfe\xf0\x5a\xaf\xd1\xce\x3e\xfd\xca\x2b\xe7\xb4\x7d\xbb\x72\xc5\x64\x73\xd5\xd0\xa6\x37\xc7\xa4\x26\x0c\xee\x35\x72\xc0\xb4\x65\x2d\x7d\x8b\x7b\x0f\x2e\x8d\x25\x79\xb5\xb0\x1f\xfc\x07\xfd\x89\x02\xa0\xf8\x38\x07\xcd\x72\x7d\x52\x9c\xc1\xce\xba\xec\xe8\x87\x4a\x37\x3c\x8d\x08\x56\xc0\x82\xb3\x09\x00\x2d\x6e\x05\xe1\x54\x70\x5c\x2b\xd3\xc4\xe7\x42\xa6\x7b\x7d\x76\x87\x9f\x5f\xae\x28\xb9\x14\x73\xa1\x57\xe9\xb7\x44\x26\x1e\xff\xa9\x60\xd4\xd2\x1e\xbd\xce\xe9\x17\x0c\x1f\x10\x7c\x68\xc3\x1d\x0f\x34\x1c\x5e\xec\x6b\x75\xe9\xca\xb3\x9e\x8a\x99\x59\x3d\xdd\x5f\x3f\x32\x38\xb3\x68\x02\x7b\x77\x41\x45\x6c\xfe\xa0\x61\x79\xcd\x2f\x2e\xdd\x1d\x02\xcb\x0e\x6d\x6a\x7b\x61\x42\x7a\xea\xb0\xad\x3d\x47\xd6\x71\xff\x18\x76\x74\x44\xe3\xc4\xd6\xe7\x46\xf4\x6e\x40\x63\x3c\x09\x8d\xf1\x9b\x68\x8c\xff\x7f\xcf\x4b\x9a\xff\x65\xea\x82\x84\x3b\x87\xd5\xcd\x9a\x68\x59\xd7\xd6\xaf\x64\x65\x62\x5b\xc2\xc6\x85\x73\xda\x17\x8d\x21\x79\x49\x1d\x49\x0b\x07\xf7\x1f\x58\xd1\xd2\xbf\x1f\xce\x4b\x6a\x1a\x3b\xb5\xba\x66\x96\x8a\x56\x4e\x10\xf2\x92\x20\xfc\x0a\x7e\x49\x3f\x45\xce\x42\xbb\x49\xce\xf0\x59\x7d\x8c\x06\x09\xb0\x03\x30\x8c\x99\xbd\x88\xa6\x86\x78\x32\x5d\xc8\x1f\x0e\x6f\xd1\x7a\x85\x1d\xda\xcf\x56\xaf\x58\x3d\xd5\x34\xcd\x60\x9b\xd6\xe4\x4b\x31\xf7\x2e\xcc\x52\xeb\xee\x32\x33\x9b\xba\x26\x52\x07\x9a\x1b\x66\x8f\x51\x8d\x57\x94\xfb\x07\x36\xe3\xbe\x56\x83\xb7\xe8\x91\xcc\xa7\xb8\xe2\x70\x40\x6f\xd0\xd0\x36\x9b\xc2\xaa\xd7\x58\xad\x50\xf3\x34\x2c\x42\xcf\xf3\xf9\xcf\x55\xe4\xeb\x90\xe0\x1c\x0b\x1f\xac\x22\x36\x4e\xfd\xd4\xec\xfa\x15\xf5\x53\x8d\x53\xf3\xad\xd3\xc7\x96\x38\x4d\x6e\x4b\xcf\x9e\xda\x1e\x3b\x8d\x14\x07\xaf\x73\xf1\x4d\xdc\x77\x33\xc6\xa2\x4e\x0b\x7b\x77\x35\x85\x42\x20\x04\x9e\x63\x34\xcc\x77\x46\x05\x3b\xeb\x47\xf1\x6c\x7b\x2a\xe2\x37\x16\x9f\x9e\xa6\x0d\xb1\x00\x18\x0c\x6a\x3b\xce\xbc\xb2\x00\x35\x51\x1c\x52\xbc\x48\xe8\x3e\xf2\x88\xa4\x60\x74\x3d\x16\x3f\xed\x2f\x69\x1b\x39\x79\x72\x4c\xfd\x8a\xd1\xba\x65\xf5\xed\xf6\x9a\x65\x97\x97\xfb\x92\xe9\x3b\xab\x03\x53\xc7\x67\x0c\x83\x57\xb9\xd2\x3e\x19\x8b\x51\xfc\xf4\xc4\x6f\x5f\x42\xe3\x0e\xac\xbb\xdf\x20\x39\x57\xa1\x7e\xb5\x78\x57\xf3\x49\x0d\x45\x29\x69\x9a\xc5\xa6\x07\xa7\xf9\xeb\x80\x9e\xef\xba\xb2\x54\xbc\xbf\x07\x0b\x5a\x60\x1e\x67\xfa\x50\x6c\x59\xb5\xa9\xa6\x6a\x79\x55\xad\xb9\xb6\xcc\xe7\x58\xee\x80\x5f\xc2\x92\x66\x38\x99\xdb\xd7\xcc\xbd\x42\x1f\x58\xb6\x0c\xd7\xe6\x85\xa8\x0f\x0d\x92\xaf\x50\x2b\x3d\x1f\xd0\x62\xcd\x08\x5c\x8a\xff\xae\xe5\x3b\x97\x33\x9f\xe2\x9c\xcf\xff\x47\x58\x42\xbb\x0b\xc1\x6a\x41\xbc\x48\xf9\xd3\x02\xe5\xb7\xa6\x38\x82\x5a\x39\xa5\xa4\x76\x1f\x2c\x03\xcf\xd1\xbb\xd9\x10\x92\x04\xae\xce\x95\xf6\xa4\xde\x6a\xd5\x28\x14\x2a\x9c\xea\x11\x07\xe2\x91\x24\x8c\x52\x12\x9c\x84\x9e\x54\x17\x2c\x2e\x87\xe2\x67\x35\x64\x67\xfc\xc4\xd5\x26\xb7\xcc\x7c\x31\xa2\x75\xe3\x82\xbc\xf6\x15\x1b\x5a\x2c\xcd\x4c\xce\xe9\xf4\x5c\xb3\x2b\xd0\x1f\xd6\xdb\x57\x38\x9e\xab\x1f\xd1\x32\x93\x7a\xaa\x6b\xe0\x04\xc7\x0f\x93\xfa\x4d\x2c\xc9\xed\xc3\x4c\xc2\xd2\xc2\x32\xa0\x41\x27\xdd\x80\x78\x34\x00\x0b\xc9\x80\x3d\xab\xc0\x3b\x28\x45\x40\xd4\x76\xa5\x35\xec\x16\xf8\x2d\x74\xc3\xbb\x74\x9f\xac\x24\x6b\x86\xaf\xcf\x68\xc5\xdf\x14\xe0\xb7\xdd\x9e\xbe\xea\xb9\xea\x11\x23\x9d\x1e\x66\x0a\xe0\xef\xa2\xe8\xa4\xa7\x21\x7c\x46\xe0\xbc\x84\xf1\xa1\xc6\x18\x34\xa3\x54\x1a\x56\xc4\x4a\xf0\xfa\x94\x92\x3a\x13\xf7\x8d\xba\x58\x91\x6e\x9b\xd9\xda\x33\xd7\xe6\xc9\xaa\xb5\x1a\x2a\x2e\x2f\xa7\x1a\x5e\x99\x3d\xd1\x38\xdf\x38\xad\x86\xb1\x23\xbc\x9b\x91\xfc\x97\x22\xf9\x93\x5a\x19\x14\x92\x12\x23\xa6\x63\x90\xfa\x2f\x3e\xda\x4d\x4f\xe6\x52\x77\x2c\x5b\x01\x27\xc2\x2f\xa9\x5f\xbb\xe6\x22\x5f\x63\x36\xd2\xfb\x83\xcc\x77\x28\xde\x29\x3a\x9b\xe9\x45\x7e\x50\x51\x47\x81\x42\xe1\xb4\xe1\xb4\xb8\x58\xad\xde\x6c\x32\xe9\x71\x62\x07\x52\x48\x21\xb1\x23\x9c\x14\x57\xe9\xeb\x9e\x17\x27\x2d\x7f\x0e\x59\xca\x99\x47\x9e\x95\x26\x64\xc9\x39\xea\x4c\xbe\xf2\x11\x0b\xec\xd5\xcb\xdb\x9c\x0b\x62\x58\xaa\x78\x42\xd5\xa8\x56\x4d\xf1\xbc\x01\x4d\x13\x0d\x53\xac\xad\xd5\xd9\x3d\x8c\xb1\xc9\x99\x5e\xfd\x04\x04\x36\x72\xbe\xbd\x1a\xa7\xcc\x0d\xc9\xc7\x89\x29\x24\x65\x4e\x35\x2e\xa1\xae\xa2\xae\x7a\xec\x90\xa9\xe3\x93\x1a\xba\xde\x9b\xd3\x8a\xb3\xd6\xfa\x50\xda\x31\x29\x08\x64\x1e\x57\x47\x7c\xbd\x75\xe0\x59\xe6\x2c\x92\x47\x26\xce\x5c\xf6\xc2\xc2\x0b\x99\x68\xa5\x54\xa5\xc6\xc5\xe0\xd4\x9a\x64\x9b\x8d\x56\xc9\x32\xb5\xf9\xe4\xe0\x4a\x61\x32\xdf\x32\x87\x26\xe2\x57\x3c\xbb\x2f\x17\x4d\xea\x7b\xd4\x5a\x34\x6f\x60\xd3\x44\x66\xfc\xb2\x3a\x81\xd4\x65\x12\x6b\xaf\x2c\x2f\x49\xa4\x66\x8e\xaa\x78\x38\x88\xe8\x34\x79\x29\x15\xd7\xa7\x39\xb1\x08\x11\x08\x8f\x0b\xbf\xcd\x87\xc7\x7e\xfb\x3b\xcc\xe6\xeb\x90\x3e\x8a\xc6\x42\x45\x72\x13\xbd\x67\x93\x12\xc1\x73\x24\xcd\x33\x05\x99\xfd\x44\xa4\xed\xf9\x67\x0d\x26\x5d\x58\x3f\xf8\x7c\x3f\x28\xe5\xf9\xc9\xa5\xdc\x6d\xb7\x9d\xce\xa8\xd7\x2d\x1f\xdd\xee\x18\x6f\x6b\x1d\x29\x0a\x76\x0d\xa3\x56\xb1\x0b\x91\xe4\x4b\x17\x0c\x9b\x34\x25\xa6\x01\x09\xf8\xa5\x2a\xef\xe2\x3b\x17\x74\xfd\x34\xb7\x85\x97\xe6\x23\xb1\x45\x79\x29\x2c\x12\x35\x4e\x00\xcc\x1e\xcc\xe1\xbc\xb6\x74\x34\x27\x3f\x23\x79\xbd\xde\xb3\x89\x2e\x3b\xa6\xd1\x04\xdc\x88\x46\x17\x70\x22\x1a\x51\xd0\xd8\x8d\xc6\x88\xd9\x11\xce\x4b\xec\x4d\x15\xc9\x33\x13\xe9\xe6\xca\x74\x8f\xb5\x67\x16\x9a\x34\x53\x08\xb1\xd5\xcb\xe7\xd1\x4a\xd3\x42\x0b\x55\xda\x36\x62\xd2\x14\xc3\x14\x38\xb7\xaf\x66\x1e\x9a\x46\x2e\x37\xe5\x20\x84\xe2\xe4\x44\xa3\x67\x2e\x24\xf9\x89\xe9\x23\xba\xae\xe1\xb9\xe5\x45\x76\x1b\xa2\x31\x37\x80\xb8\x0e\x5a\x1b\xc3\x1a\xb0\xf6\xaa\xf0\xfc\x92\xd5\x73\xc5\x69\x49\x78\x08\x85\xaa\x2f\x54\xe6\xc7\x0e\x95\xa6\x69\xc1\xce\xa9\x9f\x26\xa8\x95\xe3\x17\xec\x64\x3e\xe5\x9c\xb9\xce\x01\xf0\x8b\x2e\x05\xfc\xa6\xd2\x59\xd2\xf5\x0d\xf5\x2b\xb2\x47\xa5\x38\xa7\x0f\xf9\x43\x7a\x92\xd9\x9d\x8a\xd6\xa6\xb9\x09\x6b\x12\x76\x26\xd0\x09\x09\x4c\x9c\x96\xcf\x4c\x64\xc2\x9e\x58\x73\xb7\x54\x48\xda\xad\x14\xf2\xfe\x88\x10\xdc\x7e\xfa\x7a\xf3\xc9\xf6\x8d\xfb\x9a\x4f\x2f\xdf\xb5\x77\x07\x37\x81\xae\xaf\x1b\xd2\xdc\xcf\x79\x64\xca\xc2\x04\x78\x00\xd2\x57\x57\xff\xb0\xfa\x91\xbb\xdb\xbf\x5c\xb4\x8f\xfb\xc6\x3f\x6d\x4e\xf9\xba\x77\x5f\x5b\xbe\xcc\xc2\xdb\xc6\x3c\x64\x43\xae\x21\x1b\x62\x01\xf1\xc0\x0d\xf2\xfa\x18\xc9\xaa\x84\xcd\x61\x22\x50\x91\x8c\x15\x5c\x2b\xc1\x45\x0c\x80\x03\x98\x05\xaa\xc8\x0f\xd2\xf1\x34\x92\x57\xc3\x57\xb2\xe7\xa3\x72\x25\x0d\x0b\xbd\x74\x6f\x8a\xb5\x3a\x2c\x31\x14\xbc\xe2\x9f\xd0\x56\xff\xd0\x1c\xdf\xdc\xc2\x99\x73\x46\x1d\x5a\x56\x0c\x3d\xb3\xe6\x0e\x69\x2a\xe2\xaa\xa7\xce\xad\x6a\x2e\xee\x84\xe9\xb6\x7d\xab\x56\x7c\xba\x4c\x09\x0d\xdc\xbf\xad\xbb\x97\x2e\xf9\xf7\x06\x15\xf7\x4f\x5a\x7f\x28\xa5\xeb\x84\x7a\xce\xcb\x33\x1e\x4b\xa3\x46\x6a\xa7\xe0\x4b\x81\x6c\x48\x5f\xfe\xc5\x7c\x0b\x0a\x41\x7e\x40\xcb\x3a\x73\x33\x6d\xe8\x87\xce\x4e\xc7\xfe\xa3\x56\x1d\xf3\x0c\x22\x38\x96\xb0\xc3\x27\xd7\xf8\xc4\xc2\xc1\x3e\xbe\x96\x97\xdc\xd7\x27\xd3\x51\x2c\x11\x88\x7c\x31\xe1\x93\x00\x1f\x7b\xe1\xf3\x7c\x8e\x44\x48\x9f\x7a\xe2\xc0\xca\x81\xf1\x03\x92\x53\x6d\xc9\x19\x23\xea\xa8\x82\x49\xd6\xc6\xfa\xf1\x93\x93\x7b\x8f\x19\x5b\x97\xbb\x7f\xd7\x37\xc9\x73\x13\xb6\x8d\x6a\x72\xf7\xae\x5b\x36\x95\x7a\x75\xfe\xca\x9e\xbb\x0d\x65\xaa\xf9\xaa\xe1\x83\x34\x36\x68\xf3\x96\xf4\x1e\x10\x48\xcc\xf1\xb8\x92\xfc\x43\x0b\xa6\xcc\xed\x30\x4d\x2f\xf1\x25\x65\xbb\x9d\x69\xf8\x0e\xb1\x12\xd0\xc9\x98\x48\xad\x01\xc7\xd9\x18\xa3\x16\xb9\x3e\x11\xf9\xb7\x11\xb9\xb7\x66\x9f\xb8\x57\x87\x22\xd8\x07\x8a\x7a\xd8\x72\x5c\x45\xbd\x8d\xf7\xe7\x5d\x2d\xce\xb5\x7b\x53\xa7\x24\x3f\x10\xb7\xa8\xd3\x30\xd7\x34\xbc\x81\xce\x83\xd0\xb8\xd0\xf6\xc8\xcd\xab\x1b\x16\xa3\x3e\xfe\x84\x64\x35\x9d\xdd\x89\x22\x8c\xb4\xf3\x0e\x83\xc1\x6a\x36\x62\xe5\x75\xa2\xf1\xcc\x3b\xcb\xd2\xb2\x64\xdf\x97\x7c\x11\xb9\xde\x7e\x5e\x34\xe1\x23\x46\xc2\x82\x44\xc5\x64\xa5\x5a\x13\x1d\xb9\x39\x31\xa5\x55\xaa\x31\xa3\xcd\xf5\x03\x6b\x93\xef\x34\xdf\x39\x5a\xd5\x2b\x21\x23\xd1\xf9\x9c\x61\x56\xcc\xa0\xe9\x03\x2b\x1c\xa5\xf0\xef\x4d\x4f\x3c\xd1\xc4\x95\x56\xf5\xd6\xbc\xf9\x2c\x5a\x38\x5c\xf0\x03\x46\x87\xe6\x10\xae\xb8\x9e\x1f\xd0\xa5\xa8\xe2\xe2\x58\x68\x8c\x8f\xd7\xd1\x09\xcf\x11\xa5\xb2\xa0\xf1\x32\x00\x9d\x2c\xcd\x32\xaf\x54\xac\x77\x06\xc5\x23\x2d\x06\x2a\x22\xca\x44\xd4\x39\x21\x56\x7d\x52\x1d\x37\xbf\x37\xac\xef\xbd\xa2\xf7\x60\xd3\x10\xb7\x49\x83\xed\x7f\x49\x5b\xf5\xa4\x29\xf6\xc1\xa6\xc1\xbd\x77\x97\x4d\xed\xa7\xe1\x8e\x59\xd0\x24\xbc\x08\x07\x71\x17\x5b\xce\x4e\xea\xad\x6e\x74\x55\x07\xa6\x8d\x4f\x5a\xd1\x02\x07\x75\x05\xab\x56\x54\x4d\xf3\x2c\xe6\x7d\x8e\x1e\xf0\x1a\xd3\x03\xd1\x8a\x5c\x82\x8e\x74\xad\xd6\xa3\xc3\x22\x8b\x95\xdc\x64\x59\xc6\x29\xf6\xd7\xc9\x5d\x09\xc4\x2b\x56\x48\x3e\xbc\x97\x77\x18\xf8\xdb\xfd\x13\x29\xec\x2b\x8f\xdb\xf1\xc8\xd8\xb2\xa4\x9e\x25\xe6\x11\x85\x55\xde\x8c\xea\xd6\xfa\x01\x0b\xfa\xda\xed\x4d\x43\x6b\xcd\x25\x9e\x14\x4b\xac\xe5\x2d\x78\xed\xee\x15\xab\x66\x0f\xe8\x61\xcd\x98\x50\x55\x98\x57\xdf\x73\xfc\xe4\x91\x13\x86\x6c\x1c\x9c\x39\x70\x90\xb7\x2e\x38\x21\xc3\x19\x9b\x57\x32\xa0\xc7\xd1\x57\xf0\xfd\x1f\xf0\x23\x06\x20\xfa\x2c\xc0\x72\xc6\xc0\x62\xe2\x74\xf2\x5a\x39\xc9\xf2\xbc\x1a\xa1\x52\x4e\x0d\xf2\x78\xea\x56\x35\xab\x07\xf7\x3b\x96\xde\xbc\xa2\xc9\xf5\x20\xfc\xe8\xcd\xb2\xa1\xf0\x2c\xe7\xe9\x91\xe1\x2b\x7f\x01\x7e\xc8\x79\x1f\xd8\x8d\x79\x0f\x22\x7b\xf4\x77\x84\xdb\x81\x70\x6b\x1c\xcf\x90\x0c\x58\x53\x38\x0b\x5b\x70\x45\x11\x87\x3e\xbb\x14\xc9\xf8\x2d\x54\x8f\x5a\xcd\xd6\x65\x1b\x1d\x6b\xed\x2d\xa7\x97\x2f\xdc\xa0\x1d\x81\x04\x3d\xb4\x20\xf3\x9e\x9f\x3f\x9b\x36\xa1\x75\xea\x13\xdc\x6f\xbb\xda\x57\x14\x17\xc1\x43\xbc\x7c\x15\xc8\xa7\x78\x19\xf5\x81\x73\x3c\x69\x35\xf6\x7f\x15\xc4\x0d\x14\xe8\xf7\x59\x88\x11\x85\x1e\xea\x9c\x90\xe3\xc9\xfd\xb0\x19\x7b\x84\xf0\xdb\xc1\x2d\x8f\x71\x06\x82\xc3\x87\x70\xfc\x53\xc4\xc1\x60\x3a\xa5\x72\x58\xe4\xf8\xaa\xf0\x49\x45\x09\x7d\x46\xf8\x0b\xb7\xd6\x44\xd9\x4c\x9c\x0a\x3e\x66\x82\x5f\xb6\x52\x25\x13\x5a\xbb\x5e\x99\xc0\xd3\xe2\x42\xf3\xe3\x67\xc2\xaf\xeb\x8c\xd1\xc4\xe7\x16\xeb\x91\xe3\x14\xb9\xe8\x44\xad\x38\x6e\x09\xbd\x82\x9e\x55\xe4\x4e\xb4\xf7\x4c\x2c\x1f\xe1\xe0\xac\x66\x2a\x91\x9b\x6a\xa1\xf2\xcd\x5d\x1f\xc3\x37\xdc\x0a\x38\xad\x44\xd5\xa6\x1e\x34\xd4\xb5\x12\xf7\x39\xbe\xeb\xd5\x73\x2e\x12\x4b\x5a\xe0\x6c\xfa\x6b\xd4\xa7\x1d\x24\x83\xb4\x0b\x3a\x83\x83\xa6\x0d\x66\x0b\x76\x20\xe2\xed\x76\x5c\xea\x25\x57\x56\xea\xc5\x47\x6e\x9e\x17\x23\xaf\x6c\x88\x2b\x79\x78\x84\xfe\xd3\x90\xc1\x17\x2a\x79\xa7\x4d\x5d\xdf\xa7\xff\xa8\xb6\x25\xc7\xf3\x93\xeb\x8b\xde\x92\x13\xb2\x25\x67\x74\x8f\x19\xc5\x03\x13\xa9\x61\x9b\xc6\x8f\xec\xd3\xd2\xd4\xaf\x34\xbb\x76\x3c\xe5\xc7\x32\x58\x37\xb8\x24\x2d\xcb\xe1\xc4\x7e\xc2\xaf\xe0\x59\xba\x0b\xd1\x14\x8f\x62\x44\x4d\x2c\x4d\x3b\xf4\xe8\xc7\x80\xc2\xb1\xc2\x73\x54\x7c\x3c\x20\xd1\x18\x5f\xdd\x27\x7c\x67\xae\xb0\x7d\x82\x0b\x69\x11\xa3\x41\xa2\x57\xb2\xb3\x02\xaf\x52\x3d\x1d\xdc\xdb\x93\x97\x8e\x3f\xb1\x90\xe3\x1c\x8b\x6c\x7b\x86\x2d\xea\x33\xbd\xd1\x6f\x81\xa5\x1c\x8a\xc2\x56\x23\x6d\xbc\x67\xde\x9c\xce\xa9\xef\x18\xd6\xd6\xee\x1d\x5c\x3f\x69\x32\x34\x22\x83\x3d\x1e\xcd\x3b\x9a\xe4\x97\x5a\x91\x41\x40\x6b\xa1\x69\x6e\xec\x9a\xd8\x9d\xb1\x74\x6c\xac\xc2\x06\x70\x96\xa9\x1e\xc5\xd9\x52\x8d\x3d\xb2\x16\x16\x98\x44\x2d\x34\x17\xd3\xc2\x79\x31\xe9\xa8\x1e\xad\xfd\x65\xc6\xc5\x6d\x8b\x57\xcf\xb9\x90\x33\x61\x6d\x16\xb7\xc1\x0c\x73\x27\xac\xce\x82\xab\x2c\x95\x0a\xc0\x75\x3e\xc8\xad\xe8\x3c\x73\xe8\x21\xb8\xfc\xc2\xcd\xb2\xe7\xae\xb6\x0d\x7d\x83\x9e\x79\xe9\x95\xb6\xe1\x93\xc7\xe3\x73\x87\x85\xcc\xf3\x54\xbc\x22\x13\x69\xbf\x9a\xd4\xa4\x37\xa9\xd4\x77\x35\xaa\x54\x54\x80\x65\x35\x1a\xed\x5d\x8d\x9a\x3d\xe2\x66\x5e\xfc\xeb\x05\xf8\x8c\xab\x85\x46\x21\x88\x12\x7f\x06\x67\x91\xc5\x3c\xbd\x47\xf5\x5c\x92\x62\x4c\xea\xc3\xa9\x5d\xbd\x53\x1f\x4d\x65\x9e\x87\x7d\xd3\xb8\xa7\xdd\xa7\x2e\x5e\x3c\x79\xf1\x22\xc6\xaf\x42\xf8\x07\xfe\xbf\xe0\xa7\x71\x82\x1c\x4c\xf3\xf3\xf8\x55\x8a\x07\x9f\x53\x71\xdf\xc2\x5e\xa8\x87\x9b\x9f\x91\x1e\xdc\x70\x40\x1a\xf7\x9c\xd8\x03\x1a\x53\xee\x47\x6e\x44\xe8\xc3\xd0\x31\x90\x83\xef\xa8\x8c\x25\xf7\xe4\xd3\x29\xb8\xea\x1a\xfe\xfa\xcd\xff\x4b\x2a\x30\xe1\x7a\x13\xf8\x53\x1d\x36\x54\x7c\x52\xec\xa4\xc7\xd3\x7b\xa4\x27\xa6\x26\x66\xe6\x67\xe6\x66\x16\xc1\xbe\x15\x63\x53\x73\x52\xe3\x13\xe3\xdd\x99\xee\xb4\x3c\x6e\x44\x99\x19\xa9\x86\x52\xa5\x52\x1b\x8c\xc6\x58\x8b\x49\x6d\xb0\xe6\xbb\x7b\xc5\x27\x9a\x75\x6a\x56\xa5\x35\x1b\xcc\x36\x9d\x46\xa5\x34\x50\x78\xef\xae\x99\xf9\x84\x72\xb0\xef\x20\x5d\x37\x9e\x87\x36\xdd\x5a\x23\x3e\x17\x1c\x7f\x8d\x14\x2d\xc0\xe7\x93\xf9\x09\xe5\xe3\x7d\x18\xaa\x1c\xc2\x50\x4a\xc9\xd4\x69\x73\x03\xcd\xb3\x15\x6b\xe8\x9c\xd2\xc2\x09\x53\xda\xaa\x3c\xec\xd8\xb4\x1e\x69\x93\x46\x3b\x13\x93\x53\x2b\x32\xf2\x33\x30\xde\xe1\xcc\xdf\xe0\x5b\xec\xdf\x90\xfc\x74\xe7\xd8\xb5\x34\x85\xb1\x22\xfe\x20\x8b\x26\x46\x1a\x7c\x8b\xfb\x1b\x77\x34\x0e\x96\x41\x96\x9d\xb6\x67\xed\x5a\x04\xbf\x14\xc1\xbf\x2f\xc0\xd3\x6b\x19\x7c\x4b\x68\x3c\xae\x1a\xe2\xf6\xfa\x1d\x6e\xf8\x67\xee\xe8\x77\xa3\xff\x0a\xcb\x98\xbf\xed\x99\xb5\x96\x9c\xe5\x9d\x82\xe0\x5f\x11\xe0\x29\x66\xad\x78\x7f\x39\xf4\x22\xfc\x0e\xb8\xe0\xaf\xdc\x4b\x71\xb0\xe1\x3b\xe6\x6f\x6b\xd7\xee\x21\xf0\xf3\x10\xfc\xf7\x02\x3c\x64\xd7\x52\xc2\x5d\xd5\xd0\xcd\x7a\xd3\xdc\xf0\x7d\xee\x25\xee\xb7\x6c\x98\x03\x1b\xd8\xba\xb5\xb3\xf6\x20\x78\x05\xf3\x37\xaa\x17\x92\x8b\x12\x38\x02\x6a\x14\x62\xd3\x0a\x05\xbb\x16\xe2\xb7\xc8\x94\xc7\xaf\x2a\xbd\x6c\x9a\xdf\x91\x46\xf5\xaa\x7d\x85\xfb\x8e\xfb\x4f\xed\x5f\x21\xc3\xf6\x99\xbd\x7c\xf9\x9e\xd9\x6b\x09\x8d\x1c\x87\x70\xf4\x27\x38\xac\x17\x14\x0c\x05\x99\xb5\xac\x70\x5b\xfa\x65\x6c\x34\x2c\x5e\xd4\xb7\xc3\xef\xe8\x7a\x9b\xfb\x2d\x03\x0e\xfe\xe8\x97\x0c\x4c\xee\xec\x3d\xcb\x97\xcf\xe6\xf5\xe3\x49\xae\x21\xf4\x4b\xe8\x35\xec\xd7\x06\x34\x1a\x15\xcb\x30\x14\x05\x74\x2a\x7c\xe9\x2b\xa9\x10\x67\xc4\x02\x12\x6b\x7d\x10\xef\xc3\x80\x5e\x2a\x8e\xa9\xd3\x52\x49\xbd\x0b\x52\xcd\xe6\x84\xf9\x71\x89\x5c\x03\x8c\xad\x1b\x92\x97\x42\x8f\x65\x56\xef\xe7\xf7\xc3\xb5\xcc\x2a\x38\x5a\xe1\x46\x56\x1d\xe9\x1d\x43\xf4\x0e\x97\x11\x46\x86\x0b\x8e\xb6\x3f\x7b\xaf\xfd\x17\xa3\xc2\x3d\xbf\xb5\x75\xfe\xd1\x5a\xb2\x3f\xca\xe5\x70\xf5\xb0\x38\xf4\x2b\x82\xd7\x63\x4a\x54\x5a\x9d\x5a\x8b\x7e\x28\xa4\x2a\x57\xc3\xe6\xc6\x40\xee\x6c\xf7\xe3\x12\x00\x0e\xbf\x6f\x8b\x91\x7b\xc9\xfe\xec\x7d\x0e\xf8\x5e\xed\xfc\xf9\x95\xeb\xe6\x9f\xaa\x3d\x8a\x51\x72\x8f\xc2\xb8\x63\xc7\x42\xa1\xd0\xbd\x5c\x03\x33\x91\xed\x6f\x4e\x07\xa9\xf8\x16\x21\xea\x3a\x35\x85\xe4\xbf\x0e\xe6\xf2\x99\x62\x66\x04\x6a\xef\x27\xb4\xf7\x0b\xfd\x1d\xb5\x97\x02\xc0\xec\x56\x4c\x41\xed\x69\x00\x98\x94\x14\x3e\x7d\xfc\x00\x50\x9d\xa3\xd3\xd9\x74\x90\x5d\x44\xde\x1d\xc2\xe7\x88\x22\x98\xfe\xe8\x5d\x05\xf5\x00\x9f\x2b\x0f\x4a\xb9\x4e\x66\x37\xe9\x2b\x0d\xe3\x54\xfd\x87\xb6\xf2\xf0\xa8\x3d\x0c\x8f\xda\xa9\xef\x04\xf8\x4b\x72\x78\xea\x3b\x6a\xad\x00\x7f\x49\x0e\x8f\xda\xfd\xa4\x7d\x21\xd7\x8f\x79\x46\xb1\x0f\xb5\xa7\xa3\x76\xaf\xba\x0a\x5e\xc1\x34\x82\xe5\x10\x2f\x62\xaa\x73\x30\x39\x4c\xe3\x3c\x04\xbb\x83\xed\x40\xb0\x03\x30\x2c\x58\x0c\x0e\x0b\xb0\x35\x3c\x6c\xaa\x49\x82\xc5\x3c\xdf\x4b\x78\xf6\xf2\x3c\x87\xde\x23\x3c\x53\xb1\x32\x7c\xa1\xeb\xcc\x6b\x84\xa6\x81\x3c\xcf\x97\xc2\x3c\xdf\x4b\x78\xf0\x0a\xbc\xfd\xaf\xd0\x7f\xa7\x0c\x1e\xb7\xdf\x90\x78\x96\xc1\x23\xde\xc6\x08\xf0\x97\xe4\xf0\xa8\xbd\x4e\x80\x2f\x8d\x80\xff\x9c\xaa\x17\xe0\x4b\x23\xe0\x3f\x17\xf0\x94\xa2\xf1\x96\xc3\xdf\xa0\x5a\x49\xfb\x68\xd4\x2e\x87\xbf\x41\x35\x49\xbc\xbf\xab\xcc\x46\xed\x19\x98\x77\xd5\x4d\x0a\x27\x02\x6b\x3a\xd0\xea\x4c\x98\x2f\x12\xee\xdd\x19\xa3\x78\x19\xc1\x0c\x22\xb2\xac\x0a\xbd\x00\x2d\x48\x06\x5b\x28\x70\x4b\x1c\x5d\xd4\x06\x01\x87\xed\xb6\x38\x16\x83\x5e\x91\x38\x10\x7d\xef\x12\xba\x33\x04\xfa\xee\x21\xed\xb3\x51\xfb\x18\xa2\xa7\x83\x84\xf6\x85\xb7\x84\xff\x0f\xb5\x47\xd0\x9d\x48\xf8\xff\x50\xb3\x04\xf8\x7e\xcc\xbb\x8a\xa3\x02\xbc\x17\xe9\xc1\x22\x32\xd6\xf7\xa3\xee\x7f\xc4\x63\x9d\x12\x1e\x6b\xac\x67\x63\xd8\x0e\x02\x85\xa5\x45\x70\x99\x14\xd4\xfd\x0c\xd6\x1c\xda\x4f\x34\x07\xc1\x05\x11\xdf\xef\x13\xbd\xc9\x14\xe6\x4a\x4f\xa2\x37\x50\x2f\xe0\x02\x14\x78\x16\xc1\x7c\xaa\x98\x42\x6e\x57\x2f\x08\x98\xe2\x62\x35\x01\xc0\xb0\x4c\x75\xd0\x86\x16\x38\x4a\x63\x22\xa7\x9b\x34\x34\xc5\xd7\xb1\x26\x07\x5c\xc9\xd7\xd1\xf8\x58\xe3\x47\xaf\x4b\xe5\x22\xbb\xa5\xc5\xe2\x1d\x37\x6a\xc9\xfe\x8e\xfd\x38\x05\x96\x65\x33\x3e\xfe\x74\xf0\xe3\x69\x2e\xd7\x45\x31\x05\x96\x7b\x1b\x5f\x63\x93\x76\xf3\x03\x3a\x2d\x22\xef\x95\x5a\x87\xef\xb4\x11\xc6\xe3\xb4\xa2\x05\xd1\x9e\x45\x68\xdf\x02\xd2\xa1\x16\xd3\x9e\x14\x96\xc3\x48\x6e\x0c\xb3\x89\xad\x45\x30\x43\x30\x8c\x7a\x08\x54\x92\xb9\x43\x15\x46\xce\x9d\x97\x89\x0c\xb2\x23\xec\x05\x34\x84\x65\x50\x8d\x60\x06\x23\x19\xe0\x9d\xc6\xf4\x80\x19\xd9\x57\xa5\x3e\xd6\x16\x1f\x17\x00\x4a\xa5\xa5\x3a\xa8\x14\xae\xad\xf8\x5b\xfc\x47\xaf\x4b\x5f\xd8\x70\x6a\xa7\x90\x05\x2e\xaf\x00\xe5\x21\x5b\x8d\xf5\xe7\x5d\x29\x29\xf4\x5d\xff\x86\x6e\xfd\xb6\xf3\x9b\x34\xb5\xad\x2b\xff\x9c\xb4\xbc\x83\x9a\x80\x78\x66\xfb\xdf\x77\x66\xc5\xeb\x1c\xe7\xef\xd7\x95\x47\x5d\xf0\x67\xd5\x8f\x3e\xbf\xaf\x6b\x3b\xfb\x18\xb9\xca\x47\x98\xaf\x2f\x13\xbd\xc9\x16\xe6\x65\x17\x69\xaf\x46\xed\x83\xc9\xfc\x18\x1a\xd1\xce\xf3\x77\x87\xc8\x9f\x7a\x00\xf4\x44\xce\x0f\x40\x13\xfe\x82\x8a\x3b\x84\x7b\x0e\xb2\x02\xb6\xf8\xc4\x40\x9c\x8b\x15\xf8\xc4\x2c\x02\x1a\x33\x19\xfe\x84\x58\xe9\xe3\x57\xd1\xdf\xe3\xd2\x7d\x7b\x4e\xe9\xbe\xd8\xa1\xfa\x2b\x72\x77\x6e\xc3\xee\x1b\x17\x2f\x62\xe7\x07\xd9\xff\xd7\x90\x2e\x87\xf9\x55\x80\xe5\x66\x22\x87\xd0\xbb\xa8\x3d\xcc\x2f\x6a\x4f\x14\xe5\x33\x5f\x2e\x1f\xea\x1b\x61\xbd\xa8\x46\xed\x32\xf9\x48\xed\xf8\xcc\xc3\x41\x02\x9f\x23\xcc\x37\xbe\x3d\x1d\xb5\xc7\x12\xf8\x61\x42\xfb\x72\xd2\x8e\xeb\xd3\x1f\x24\xb6\x22\x87\xd8\x8a\x1f\x31\x3c\xd0\x9d\xa7\x29\x18\xc7\x0b\x94\xd7\xab\x74\x7c\xdf\xb3\xe2\x22\x82\xfb\x9e\xcc\xc0\x19\xef\x63\xeb\xbd\x18\x0c\x81\x0c\x0f\x1d\x63\xe2\xa1\xf9\x31\x62\x9d\x64\x5d\xc8\x25\x63\x54\x45\xee\x79\x43\x3a\x68\x0a\xeb\x20\xb9\x67\x49\xf1\x02\xd0\x02\x13\x48\x0e\x98\x62\xd6\xea\x58\xa1\x94\xb2\x01\x85\xff\x8c\x4d\xac\x7b\x56\x89\xbd\x21\x77\xf8\x34\x35\xe5\x4f\x43\x9e\x26\x9d\xc9\x7d\x7f\xef\x88\x0e\xa8\xe8\x78\x80\x3f\x46\x5d\xcf\xbd\xcc\x40\xe6\x4d\x96\x3b\x04\xbf\x9f\xc0\xcd\x65\xfb\xdf\xfc\x02\x1f\xa1\xee\xba\x97\x7d\xdd\xfa\x2f\xd7\xdf\x25\x5d\x63\x9d\x44\x36\xb9\xc2\x7a\x98\x43\xda\xd7\x23\x5d\xbb\x40\x64\x33\x42\x68\x8f\x15\xd7\x06\x39\x3c\x5a\x03\xf6\x0a\xf0\x97\xe4\xf0\xa8\x7d\x15\x69\xdf\x80\xf0\x40\x02\x9f\x27\xe0\xc9\x24\xed\x2e\xd4\x6e\x20\xf0\x23\x85\x76\xa7\x04\xdf\x9b\xcc\x79\x0c\xef\xe5\xe1\x65\x73\x9f\xd2\x8a\xf2\xa2\x11\x8e\x57\x99\x3a\x45\x0b\xf1\xca\x4d\xa0\x47\x20\xd6\x60\xac\x09\x1a\x58\x95\xb2\x3a\xa8\xa2\x35\x5a\x1a\x59\x31\x1a\x59\x31\xda\xc6\xbb\xe7\xc4\x5c\x89\x27\x61\xd3\xdc\x4a\xa1\x8a\x38\x99\xad\xe8\x5f\x6a\x37\x5c\x99\x70\x33\x2b\x01\x3e\xf6\x26\xf7\x0f\x27\x7c\x87\x53\xb9\x3b\xdc\x14\xd5\xf5\xf7\x38\xca\xbb\x63\xc7\x0e\x26\x73\xc7\x7f\x37\x1c\x3f\xae\xb4\xaf\x11\xe8\xbc\x24\xe7\x0b\xf1\xbb\x4f\xe0\xeb\x92\x9c\x2f\xd4\x7e\x87\x00\xdf\x10\x01\x7f\x83\x7a\x44\x80\x6f\x88\x80\xbf\x41\x6d\x25\xed\x48\xda\xcc\x17\x44\x5f\xf2\x05\x7d\xb9\xca\xeb\x8b\x2b\x6c\xfb\xd0\x7f\xcc\x01\xe2\x3f\x54\x03\x5e\xf3\xee\xe3\x61\xfc\x61\xdb\xc7\xe3\x99\x22\xe2\x09\xdb\x3e\x67\x34\x9e\xab\x02\x1e\x05\x81\x41\x10\x45\xe2\x1a\x12\x8b\xc6\xe4\x0b\x42\x7b\x7e\x84\xdd\x41\x71\x19\x3e\x1b\xcf\xbf\xd7\xcd\x1e\xe1\x3e\x7b\x46\xf6\x69\x0a\xf7\x39\x11\xc1\x34\xb3\x57\xd1\xac\xa9\xb1\x10\x5f\xc5\x15\x6d\xfb\x7a\x46\xe0\x9c\x88\xda\x9b\x99\x11\x02\x3c\xd6\x17\x93\xe4\xab\xc8\xe0\x91\xbc\xa7\x08\xf0\x97\xe4\xf0\xa8\x7d\xb9\xb4\x26\xcb\xe1\x6f\x50\x33\x05\xf8\x86\x08\xf8\x1b\x14\x3f\xce\x53\xd0\x1a\xb4\x9f\xd8\x82\x02\x62\x0b\x38\x62\x0b\x34\x1d\x34\x95\x26\xf9\x0d\xf8\xae\xaf\x07\x15\x8f\x22\x98\x5a\x6c\x07\xa8\x03\x90\x1f\xb1\x37\x81\x06\xd8\x02\x3a\xba\x22\xa0\xb6\x0e\xaa\xa0\xa9\x74\xde\x1c\x98\xb2\x85\xba\x3c\x3c\xee\x51\x12\xee\x90\x60\x67\x18\x9a\xea\x21\xb7\x33\x18\xff\x6a\xc5\x5d\x51\xf8\xb1\x95\xd7\x80\xec\x80\x8b\xa1\xcb\x03\xfa\xb8\x41\xe5\x6b\x75\xba\x41\xe5\x01\x8d\x16\xfd\xa6\x56\x0f\x2a\x67\xa4\x0e\x51\x8f\xe8\x3f\xbe\x66\x4c\x34\x3f\x37\x25\x7e\x52\x23\xf8\x69\x56\xcc\x14\xfa\xf3\xa2\x35\xd5\x4d\x74\xb0\x2f\xf8\x34\xf4\x26\x81\x4d\x32\x89\xb0\xd1\xf8\xba\x24\x7c\xe9\x51\xf8\x66\x74\xc3\x57\x05\x97\x74\xc3\x57\x4a\x6c\x20\xd6\x7b\x9f\x00\x73\x27\xbf\x9e\xc7\x4b\xba\xc3\x9f\xef\x27\x7a\x3f\x0a\xeb\x2b\x58\x3c\x8e\x40\xe4\x88\xfa\xca\xe3\x98\x22\xe2\x90\xf4\x4f\xe6\x2b\x0b\x38\xae\x8a\x38\xa8\x07\x12\x08\x8e\x2c\x39\x8e\x4e\x82\xa3\x28\x12\x87\x6c\xde\x60\xbf\x69\x0d\xc1\x31\x9a\xc7\x91\x42\xe6\x8d\x53\xc2\x81\x74\xb6\x93\xe8\x5a\x51\x84\x2e\xaf\x40\xed\x6b\xc8\xbc\x19\x2d\xb4\xbb\x24\xdd\xef\x24\xb6\xaf\x88\xb7\x7d\x18\x5e\x66\xfb\x68\xd9\xdc\x27\x38\x88\xdf\x33\x5a\x80\x75\x09\xfe\x4f\x3f\x5e\x5e\x2e\x99\xff\x83\xe6\x82\x8c\x0e\x71\x8e\x84\xae\xa2\x76\x19\x1d\xd4\x77\x70\x13\x81\xcf\x40\xe3\x75\x94\xf0\x5e\x2c\xf0\x6e\xe2\xe7\xaf\x2f\xdc\xff\x1c\x04\xd3\x9f\xf0\x5e\xcf\xf3\x6e\x21\xbc\xf7\x14\x79\xcf\x40\xf4\x1d\x65\xc7\xf2\x38\x08\x8f\x1c\xff\x1e\x6a\xef\xcf\x0c\xe5\xdf\x23\xf3\x58\x2d\xeb\xf3\x69\xb1\x4f\x35\xa0\x1a\x05\x1f\xa6\x54\xd2\x23\xdc\xe7\x4e\xf6\x15\xa1\x4f\x0c\x53\x13\x8a\x21\x30\x7e\x49\x7f\x78\x3c\x3f\x49\x78\x20\xb5\x44\xc0\x53\x14\x81\x67\x8f\x82\x96\xf0\x40\x6a\x6a\x48\x4f\x60\x7c\x61\x3c\x98\x7e\x51\x06\x64\x1d\xa2\x22\xf5\xa0\x50\x26\x0b\xcc\x93\x28\x0b\x69\xdc\x44\x99\x50\x92\x1d\x45\x91\x20\xeb\x22\x38\xfd\x91\x76\x51\x2b\xe1\x82\x3a\x5c\x2b\x80\xc0\x34\x08\x30\xcd\x3c\x4c\x42\xb8\xbf\x2b\x68\xcd\x76\x91\xf1\xf4\xcb\xf5\x0a\xea\x10\x1d\x3e\xb6\x8e\x7f\x97\xb4\x9f\x26\xf0\x4f\xa0\x35\x5b\x06\x2f\xd9\xc8\x77\xd0\xf8\xcb\xe0\x51\xfb\x5d\xfc\x5d\x85\x5c\x43\x04\xbc\x68\x23\x71\x7e\x87\x1c\xfe\x06\x96\x2d\xe1\xff\x05\xe6\x7d\x02\x5f\x42\x68\xfe\x0c\xe1\x9f\x45\xe4\xe9\xb4\x8a\xf2\xdc\x86\x60\x36\x31\x65\xc8\xbe\x8e\x61\xc3\x30\xea\x73\x14\x4c\x77\x88\xf5\xac\xb0\x9f\x26\xe1\x91\xf9\x69\xb8\x5d\x7a\x57\xd6\x3e\x29\x0a\x5e\xa4\x73\x52\x14\xbc\xd8\x8e\xc7\xfd\x7d\x62\xab\x4a\x22\x6c\x39\x05\x13\x25\xdd\xd8\x86\x73\x7a\x15\xfb\x84\x77\xc3\xb6\xfc\x49\x04\xd9\x2b\x90\x4b\x95\xaf\x75\xb9\x90\x95\x8d\x77\xa2\xbf\x1c\x0e\xf4\x97\xd1\x88\xfe\xd2\xeb\xbb\x99\x5f\x98\x49\x86\x9d\x98\x5e\x62\x7e\xc1\xad\x68\x50\x53\x61\xdf\x32\x49\x6e\xf3\x79\x3a\xc6\x0b\x74\x48\x36\x13\xcc\x00\x2c\xb8\x4e\x56\x15\x2a\x33\x90\x94\x34\x28\x13\xba\x85\x7e\x78\x19\x3e\x8e\x74\x6c\x9c\xe2\x41\x84\xbf\x94\xe0\x1f\x08\x63\xf9\xd5\xdc\x1a\xd6\x1f\x72\x97\x17\x8b\xe3\xcc\x20\xd1\x53\xc4\x23\x86\xb0\x8b\x7a\xfa\x38\xd2\xaf\x71\x44\xae\xa5\x11\x76\xeb\x24\xd2\x2f\x7c\x07\x18\x79\x4f\xd6\x3e\x03\xf5\x39\x9d\xc4\xad\x65\x84\xc6\xaa\xd0\x8f\x24\x5e\x95\xfb\x2a\xe4\xbe\x30\x62\xb3\xc7\x12\x9b\x5d\x75\x27\xef\xcd\x88\x7d\x46\xe3\x58\x0c\xee\xfd\x43\x1c\x8b\x5b\x6e\x85\xa3\x45\xc2\x31\x03\xf4\x00\x9f\x90\xf1\x4d\x92\xc6\x97\xc7\xb1\x42\xc2\x31\x03\xf2\x1a\x20\xac\x40\x32\x7e\xa6\x88\x78\x6e\xe9\x33\xf1\x78\xae\x8a\x78\x44\x9f\x49\xb2\xfd\x33\x90\x0c\xa7\x13\x19\x96\x45\xfb\x31\xe4\xde\x34\xf2\x5e\xb8\x3d\xf4\x8c\x64\x1b\xca\x23\x6d\xae\x21\xbc\x66\xfd\x88\xd7\x24\xd2\x67\xa3\xbc\x4f\x83\xd0\xa7\x80\xe3\x0e\x11\x47\xf7\x38\x50\xc2\xb1\x42\xc4\x21\xf1\x6f\x91\xf1\xff\x67\x84\xa7\x3f\xa1\xa5\x22\x92\x16\x5d\x98\x96\x6f\xd0\x1c\xfb\x8e\xd0\xd2\x24\xa7\x25\x5e\xa4\xe5\x63\xd4\xcf\x7f\x14\x47\xd0\xf3\x5e\x84\x96\x7e\xe4\x80\x25\x82\x30\x86\x65\x48\xee\x8c\x23\xe3\xd9\x4c\x70\x6c\x12\x20\x24\x1c\x48\xdf\xfe\x43\x64\xd8\x4b\x58\x2b\x54\xfc\x7b\xa8\x7d\x1e\x91\x61\xb3\xd0\xae\x23\x34\x7d\x8c\xec\x99\x0c\x1e\xd9\xb3\xf9\x02\xfc\x25\x39\xbc\x64\xff\xaa\x51\xbb\x3c\x5e\xfc\x8e\x9a\x27\xb3\xc1\xad\xa2\x0d\x46\xfa\xa0\x03\x9f\x11\x29\x25\x9b\x22\xf4\x48\xa1\x95\xc6\x7f\x9f\x20\xe9\xd8\xb0\x1c\x79\x19\x11\x98\xa6\x08\x18\x87\x4c\xd6\xb8\x86\x40\x31\xfb\xbd\x99\xec\x71\x22\x98\x35\x6f\x93\x35\xa3\x8a\x5f\xbd\x29\xe8\x15\xf6\x66\xf0\x5d\x5c\x71\xe7\x4d\x46\x36\xc0\xea\xc8\xc1\x5f\x14\x11\xa2\x58\x46\xd8\x82\x71\x7b\x2c\xb2\xdd\x17\x85\x12\x6f\x04\xc3\x0f\x3a\x9e\x4d\xff\xe7\xa7\x42\xd9\xb1\xbd\xed\xce\x3d\x78\xbb\xe5\xea\x2b\x67\xc8\x46\xcb\xac\x4d\xf0\x7f\xc9\x7e\x03\x80\xa0\x07\xa2\xe1\x5e\xb6\x9e\xdc\x69\x65\x49\x31\x1a\x9d\x49\x49\xb6\x71\xc1\x24\xc6\x69\x66\xd4\xe3\x82\x8c\x45\x7e\xd3\x79\x6c\x9e\x74\xaa\x41\x3a\x75\x88\x3f\x23\x09\xbb\x3e\xb4\xc7\x62\x06\xbe\x64\x0b\x4c\x84\xcc\xac\x0d\xdf\xec\xba\x63\x61\xd9\xa8\x45\x7b\x1f\x59\x77\x47\x66\x12\x4c\x73\x2e\xed\xd7\xba\x79\xac\xfb\x9e\xce\x7b\x2a\xa1\xfe\x07\x98\xbc\x90\xfb\x73\xfb\xdd\xf0\x5f\x7b\x3f\x59\x9d\x7c\xd0\x7b\xe2\x81\xc9\x2d\xf7\xc3\x84\xa2\xaa\x96\x73\x8f\xdd\xec\xa2\x69\x18\x80\x16\x2e\xc4\xbd\xac\x3f\x42\x64\x79\x2f\x1a\x73\xd9\x1e\xb1\x34\x9f\x06\xa3\x76\xd9\x1e\x31\x6a\xff\x8a\x87\x47\x72\x9b\x48\xec\x6c\x2a\xd1\xe1\xd7\xe8\x75\x82\x5f\x14\xd6\x3f\x5e\xf6\x3f\x09\xb2\xc7\x30\xad\xdc\x15\x0c\x33\x48\xf2\x9d\x30\x1e\x76\x81\x32\x5e\xc4\xa3\x2e\xa0\x5e\x17\xfc\xdb\x78\xc9\xa6\x20\x3c\x6c\x91\x22\x5d\xc4\xa3\x2e\xa3\x3a\x05\x98\xfe\xa2\xbe\x08\xf4\x84\xf1\xf8\x60\xd7\xad\xf0\x30\xc5\x8a\x64\x09\x4f\x39\xfc\x3a\xf4\x2b\x81\x19\x28\xc7\xc3\xea\x65\x78\x0a\xa9\xc3\xdd\xe2\x11\x4c\x0f\x50\x4c\x93\xf0\x54\x50\x8f\x87\xbe\x27\x30\x35\x11\xf4\x1c\x94\xe1\x29\x92\xfc\xf6\xfc\x08\x7a\x16\x2a\x3e\x93\xf0\xf4\xa2\x46\x86\x7e\x22\x30\x7d\xc2\x78\xf0\xb8\x28\x8e\x88\x5e\x8f\x51\x94\x37\x9e\xcb\x3f\x60\x9f\x55\xb6\xee\x90\xb1\x22\xf3\xbd\x1f\x89\x63\x36\xfd\x80\x57\xe1\xff\x50\xff\xc3\x8f\x4c\xb9\x38\xef\x31\x6d\x6b\x64\xb4\x15\x4b\xb4\x59\x23\x68\x5b\xae\xf8\x56\xa2\xad\x37\x35\x42\x80\x29\x8d\xe0\x71\xbd\x0c\x8f\x9f\x9a\x71\x4b\x3c\xa3\x64\x78\x2a\xa9\x21\xb7\xc4\x23\xa7\xa7\x44\xa2\x27\x26\x02\xcf\x64\xa2\x6f\x3c\x9e\x00\xde\xbb\xbe\x05\x9e\x03\x32\x3c\xa5\xb7\xc1\xb3\x51\xf1\x8d\x84\xa7\x0f\x15\xec\x8e\x87\xc8\xfc\x68\x37\x99\x8b\xfb\xc4\xb4\x39\x52\xe6\x95\x78\x9f\x18\xc1\xfe\x93\xc0\xf2\x76\xe6\xfe\xaf\xc9\x3e\x71\x2f\x79\xac\x22\xdb\xab\x46\x36\x35\x5d\xd8\x67\xee\x94\xef\x55\xa3\x76\xf6\x56\xfb\xe9\x68\xee\xec\x16\x56\x40\xd9\x1e\x35\xde\x4f\x27\xf3\x6b\x90\x00\xb3\x8c\x9f\x5f\xf9\x91\x7b\xb3\xef\x2a\x0e\x4a\x78\x0e\x20\x7b\x44\xd6\x7d\x5b\x24\x9e\xd5\xc4\x5f\x19\x24\xf3\x57\x22\x62\x35\x76\x13\x91\x6b\x86\x30\x47\xff\x29\x5a\x63\xf9\xde\x3e\x3b\x82\xcc\xd1\x41\xc2\x1c\x7d\x4f\x90\x6b\x8f\x88\xd8\xf3\x5d\x19\x1e\x1f\xb9\xab\xbb\x1b\x1e\x66\x8c\x0c\x4f\x39\x45\x09\x78\xf2\xe4\x78\xd8\x24\x19\x9e\x42\xea\x9c\x80\xc7\x13\x41\x8f\x45\xb1\x48\xc2\x53\x41\x3d\x1d\x3d\xce\xdd\xe8\x29\xa2\x16\x0b\x78\x72\x23\xe8\xb9\x9b\xe8\xcb\x20\x61\x8e\xce\x16\xf0\x64\x86\xf1\xe0\xb1\xe5\xe7\x28\xde\x65\x33\x8a\xb2\x16\xe7\x28\x65\x96\x7f\x57\xe8\xe4\xbf\x2b\x20\x58\xa3\xec\xbb\xc2\x26\x25\xd1\x17\xaf\x28\xf3\xa8\x3d\x52\x34\xb6\x8b\xbb\x8d\x3f\xde\x1f\x8d\xc5\xeb\x9f\xea\x7b\x11\x86\xfb\x18\xc3\xc4\x85\xc7\x7f\x3c\xea\x4f\xb6\x37\x2b\xd9\xf5\x74\xd4\x2e\xdb\x9b\x45\xd4\xc4\xf1\x7b\x26\xa8\x7d\x3f\x89\x2b\x0b\x22\xe0\xe7\xf1\xfb\x43\xc2\x1e\x43\xb8\x3d\x6a\x7f\x42\xa2\x93\xca\x91\x7f\x37\xc3\xfb\x13\x5a\xfe\x5d\x19\x9d\x82\x6a\x88\x78\xd8\x29\x64\x2c\x0a\x04\x1d\xfb\x93\x28\x67\xf9\x3e\x07\x5b\x45\x74\xa3\x56\xd0\x31\x71\xad\xc8\x8a\xda\x2f\x09\xe3\xf1\xc1\x1f\x6e\x85\x07\xd1\x13\xc6\x53\x4e\xb1\x02\x4c\x8e\x1c\x0f\x1b\x2f\xc3\x53\x48\x9d\x14\x60\x0a\x23\xe8\x89\x21\x3a\x56\x2b\xe8\xd8\x79\x01\xa6\x38\x82\x9e\x83\x32\x3c\xe1\x75\xa0\x32\x82\x9e\x9d\x44\xc7\x6a\x05\x1d\x13\xed\x68\x7a\x18\x0f\x1e\x97\x88\x75\xa0\x20\x72\x1d\xf0\xc8\xbf\x7b\xa2\xb1\x12\x6c\x12\x0f\x5b\x2b\xf3\xff\xe8\x54\x51\xc7\x30\x8f\x3b\xb1\x0f\x89\xbf\x9d\x92\x98\x60\x02\xaf\xaf\x59\x11\x63\xc7\xce\xc6\x6b\x0a\x9c\xc8\xc7\x04\x93\x41\x78\xe4\x6e\x81\xa3\x2a\x74\xec\x0f\x71\x54\x3d\x4d\x70\x64\x44\xe0\xc0\x3a\xc4\xe3\x40\xfa\xb1\x41\xf8\xc6\x14\x85\x03\xeb\x10\xc1\x81\x61\x96\xf3\x3a\xe4\x8f\xd4\xa1\x9d\x8a\x03\x12\x9e\x03\x20\x8e\xa7\x25\x37\x9a\x96\xa3\x22\x2d\x08\x86\xf4\x24\xed\xab\x20\x39\xb3\x3b\xd9\x75\x3c\x0e\x32\x2f\x14\xa2\x4c\xd9\xd9\x58\xff\xf1\x7b\x32\xfd\xc7\x7b\x13\xb2\x18\x59\x6a\xdf\x86\xda\x65\x31\x72\x18\x3e\x32\x3e\x0d\xcf\xeb\xb4\x30\x8d\x7c\x6c\xaa\x95\x62\xf9\xd7\xe8\xb9\xfc\xbc\xce\x0b\xf3\x3a\x1b\xf1\xf1\x3a\x91\x7b\x9b\x30\x76\xf5\x84\x57\x28\xfb\x46\xbf\x11\xc1\xb4\x20\x3d\x48\x87\xf3\x59\x32\x76\xa3\x49\x4f\x92\xdc\xa3\x71\x54\x85\x1e\xfc\x43\x1c\x55\x07\x08\x8e\x1e\x11\x38\xc8\xd8\xb5\x09\xfc\x04\x79\x7e\xf2\xa3\x70\x60\x7e\x08\x0e\x0c\x33\x95\xe7\xc7\x1f\xcd\xcf\x41\x09\xcf\x81\xd0\xfb\xfc\x3a\x95\x15\x4d\xcb\x51\x91\x16\xea\x40\x17\xdf\x93\x44\x0b\x1a\xa3\xd7\xc9\xd8\xb5\x09\x63\xf1\x11\xff\x1e\x6a\x6f\xc1\x63\x81\xdf\x23\xed\x5f\xca\xe2\xb0\xa3\x62\x1c\x86\xf8\xff\x92\xef\x33\x26\x3a\x0e\xeb\x10\x63\x0c\x50\xf5\x22\xe9\x33\x41\xec\xf3\xcf\x08\x77\x7f\x32\xfe\x15\x82\xbe\xc0\xf0\x7b\x24\x26\x6a\xe2\xdb\x99\xcc\x70\x9f\x64\xfc\x2b\x04\x79\xb5\xf1\xf2\x8a\x8d\xea\x53\x8a\x6b\x30\xcc\x02\x5e\x5e\xe9\x61\x79\xf1\xb4\x1f\x94\xf0\x48\xeb\xba\x39\x9a\xf6\xa3\x52\x7c\x24\xec\x43\x24\x8b\xb4\x4f\x43\x7a\xf6\x5f\x45\xbe\x39\x9d\x26\xf3\x45\xb9\x0b\x74\x81\x49\x51\x76\x39\x1a\xe6\x0a\xf8\x9e\x87\xc9\xbd\x3d\xcc\x21\xf0\x5f\x04\x83\xed\x57\x78\xbf\x2f\x1a\xe6\x04\xf8\x4a\x80\x29\xbc\x2d\xcc\x61\xd8\xf3\x0f\xf1\x9c\x84\xe9\xb7\xc6\xa3\x1c\x22\xc1\x3c\x04\xa1\x00\x33\xe0\xb6\x30\xa7\xc0\x4f\x02\xcc\xc0\xc8\x98\x82\xac\x91\x38\x26\x52\x28\x77\x6d\x06\xe1\xd8\x47\xd6\x7e\x65\x37\xdf\xbe\x24\xa2\x1d\xc9\x81\x7b\xe7\x16\xf0\x88\x77\xa1\x3d\x1a\xfe\xf0\x6d\xe0\x4f\xca\xdb\x15\xd7\x45\xff\x56\xf9\x50\x28\x0d\x75\xac\x3e\x47\x53\x3d\x81\xb0\xc7\xd7\x0d\xe6\x54\x77\x18\xb0\x14\xf1\x3e\x97\xc8\x70\x0a\x3f\xee\x30\x83\x8c\x29\x94\x8d\x69\x34\xcc\x15\xa8\xe7\x61\xf2\x6e\x0f\x73\x48\x18\x0b\x0a\x86\xc7\x22\x1a\xe6\x04\x34\x09\x30\x45\x11\x30\x0b\x64\x30\x87\x61\xd5\x2d\xf1\xac\x93\xc1\x9c\x84\xb5\xd1\x78\x42\x9d\xd8\x9f\x23\x72\xcb\xe0\xf9\x22\x79\x2a\xca\xb3\xd0\x0e\xa4\xbb\x1a\x1e\x46\xf3\xe6\x20\x7b\xd5\xe8\x45\x30\xaf\xf0\x9c\x85\x12\xe4\x50\xa1\x10\x57\x12\x85\xe7\x50\xd7\x3d\x08\x42\xdb\x01\x29\x98\x40\x84\xc8\xe3\xe2\x1a\xa3\xe0\x4e\x10\x38\xbc\xe7\x9a\x20\xca\xba\x1b\xae\xc3\xb7\x80\x89\xc6\x73\xb2\x3b\x0c\xa8\x46\x73\x79\x08\xe1\x7f\x9a\x30\x66\x29\xfc\x78\xc8\xce\x30\x45\xc3\x5c\x81\x99\x3c\x4c\xda\xed\x61\x0e\xc1\x78\x41\x8e\x61\x1f\x2a\x1a\xe6\x84\x04\x93\x7d\x5b\x98\xc3\xd0\xf6\x87\x78\x4e\x4a\x30\x91\x78\x9e\x21\xf3\x70\x9a\x30\x57\x45\xfd\xe8\x15\x01\xf3\x17\x19\xcc\x29\xe8\x15\x60\x7a\x47\x8c\xfd\xcb\x44\x86\xe4\xcc\x02\x3f\xf6\xa8\xfd\x83\xa8\xf6\x2b\x7c\x3b\x19\x17\x79\x3b\x19\x63\xd4\x3e\x27\xaa\xfd\x44\xd7\xd1\x5b\xc2\x1f\x16\xe0\x1b\xa3\xda\x4f\x0a\xed\x2d\xe4\x1b\xed\x75\xbe\x1d\xf3\xd5\xd5\x21\x8c\x69\x9e\x34\xee\xd1\x30\xa7\xba\xc3\x80\x4f\x90\xde\x6b\x89\x0c\x67\x08\x36\xfa\x1a\x3f\xa6\x32\x1f\x3f\x1a\xe6\x0a\x78\x8f\x87\x89\xbf\x3d\xcc\x21\x70\x5d\x90\x61\xf8\xdb\x60\x34\xcc\x09\xf0\x2f\x01\x26\x39\x02\xc6\x22\x83\x39\x0c\x3e\xb9\x25\x9e\x18\x19\xcc\x49\xf0\x8f\x5b\xe2\x59\x4f\xc6\x94\x87\x79\x08\xfc\x5d\x80\x29\xb8\x2d\xcc\x29\x09\xc6\x17\x31\xee\x07\x89\xfc\x73\xba\x8d\xbb\xbc\x5d\x3e\xee\xf2\xf6\x43\xb2\x71\x94\xb7\x9f\x10\xda\xa3\xe1\x0f\xdf\x06\x5e\x3e\xee\x07\xc9\x98\xf2\xed\x64\xdc\x6f\xd1\x7e\x8a\x6f\x17\x62\x91\x7c\xd1\xf7\x47\xf3\x3a\x86\x5f\x5f\x3d\xa6\xa8\xf8\x29\x0c\x73\x85\xcc\x23\x04\x93\x7a\x7b\x18\x71\x5e\xcb\xe3\xd4\x68\x98\x13\x12\x4c\xd6\x6d\x61\xc4\x79\xfd\x7b\x78\x4e\x4a\x30\x61\x3c\x1e\x1c\x87\x11\xf9\x14\x08\xe3\x42\xce\x22\x81\xca\xa8\xf6\x2b\x7c\x3b\xb7\x3f\xaa\xfd\x50\xd7\xaf\xa4\xbd\x33\xaa\xfd\x04\xdf\x1e\x02\x51\xed\x87\xb1\x84\x51\x7b\x74\xbf\x27\xf9\x76\xb0\x0a\xb5\x8f\x23\x3a\xb9\x58\x98\x47\x1c\x3f\x47\x12\xc3\x32\x8c\x86\xb9\x02\x6e\xf0\x30\x49\xb7\x87\x39\x44\x7c\x26\xac\x93\xa9\x12\xef\xd1\x30\x27\x04\x7f\x88\x12\x0c\xf1\xad\x60\x0e\xc3\x9c\x3f\xc4\x73\x52\x82\x89\xc4\xc3\xdb\xcf\xc5\x51\xf6\xd3\x7f\x5b\x98\x53\x12\x4c\x89\x34\x8f\x96\x60\x7f\x92\xc8\xad\x82\x1f\x97\xae\x6f\x45\x3d\x8f\x68\x17\xe6\x45\xd7\xcf\x51\xed\x27\xbb\x0a\x08\xfc\x28\xe2\x97\x5e\x97\xda\x4f\xf1\xf6\x13\xc4\x23\x1a\x1e\x27\xbc\x2c\x8f\xd0\x73\x61\xf9\xbe\x25\x8c\xa8\xe7\xb0\xf8\xf6\x30\xe1\xf5\xab\x5c\xe2\x37\x1a\x26\xbc\x7e\x55\xdc\x16\xe6\x30\x59\x2b\x7f\x1f\xcf\x49\x09\x26\x12\x0f\x2f\xdb\xe5\x51\xf2\x1f\x71\x5b\x98\xb0\xfc\x47\x4a\xf2\x7f\x1b\xd9\x87\x8b\x58\x9e\xf4\x58\xf9\x7c\xe9\xd6\x2e\xcd\x97\xa8\x76\x71\xbe\xe0\x33\x13\x17\xf0\xb9\x1f\x7a\x6c\x88\x1f\xaf\x5f\xf8\xf9\x12\x05\x2f\xcd\x97\xa8\x76\x61\xbe\x84\xac\xb8\x1d\x8f\xa3\xd0\xfe\x10\x37\xe3\x96\xed\xa7\xf8\x76\xc1\x2f\x57\x4a\xfe\x74\x27\x38\x0e\xc0\xad\x62\x09\xbc\x5f\x49\x60\x14\x74\x89\x3b\x72\x2f\x81\xf7\x15\x95\x92\x8f\xd7\x09\xde\xe5\x63\xa3\x68\xbf\x94\xe0\x98\xc2\xe3\x98\x20\x83\x90\x7c\x0e\xa5\xe4\x2b\x74\x82\x0f\xbb\x9d\xf5\x26\x30\x04\xc7\x34\x1e\x47\x83\x0c\x42\x5a\x07\x95\xd2\xba\xd3\x09\x1e\xe4\x71\x44\xaf\xb9\x04\xc7\x0c\x1e\x47\xac\x0c\x42\xb2\x91\x4a\xc9\x46\x76\x82\xb7\x79\x79\x44\xdb\x75\xb2\x7f\x5b\x2b\x97\x87\x47\xc4\xc1\xcf\x7f\xa5\x34\x6f\x3b\xf1\x0d\x14\xb7\xb2\x59\x84\x8e\xc5\x3c\x8e\x78\x19\x84\xa4\xc3\x4a\x49\xf7\x3a\xc1\xd3\xf2\xd3\x67\xe1\x39\x45\x70\x2c\xe7\x71\x94\x47\x9e\x4f\x9b\x86\xe4\x25\xc5\x5c\x46\x2f\xb2\x9d\xbf\x82\x49\x26\x25\xad\xa0\xfa\x75\x1f\xe3\x28\xd8\x2b\xe0\x87\x3f\x80\xcd\x94\x60\x0f\xa1\xd8\xb2\x59\x82\x8d\x8a\xfb\xa2\xf0\x9e\x88\xc0\xfb\xfb\xb0\x87\xa1\xe5\xff\x0c\x7b\xf2\x8f\x60\xc5\x98\x11\xc1\x3e\x04\x7e\x8e\x82\xed\x7f\x5b\xd8\x53\xe0\xdb\x28\xd8\x01\xb2\xef\x0d\x0d\xb2\x78\x2f\x5d\xb9\xeb\x00\x9a\x59\x08\x72\x1a\x10\xe2\xcd\xa8\xe7\x57\xa2\x9e\x2f\x89\x78\xee\xe5\xe3\x4e\x11\xa2\xdb\xfb\x5e\x3e\xfe\x94\x3d\x8f\x7e\xff\xf0\x1f\xbc\x7f\xf2\x56\xcf\xc5\x98\x13\xcb\x25\x94\xf6\xbb\xcf\x4f\x45\x3e\x07\x79\xf2\x38\x01\xeb\x17\x8e\x35\xb1\xac\xc4\xb3\x15\xb2\xb9\x1b\x0d\x7b\x05\xdb\xd2\xff\x23\xec\x21\x48\xcb\x60\x35\x28\x9e\x0b\xfb\x34\xd1\xb0\x27\x40\x28\x0a\x36\x2b\x02\xb6\x5a\x06\x7b\x18\x26\xff\x2e\x5e\x39\xec\x49\xe8\xfe\x5d\xbc\xcf\x2b\xfb\x49\xb0\x0f\x21\x98\x96\x08\xd8\x8a\x08\xd8\x0b\x62\x4c\x84\x65\x1a\x21\x33\x0c\xdb\x2b\xec\x23\x93\x33\x99\x62\x8c\xe2\xe5\x7d\x64\x22\xff\xc9\xbc\xaf\x1c\xf5\xfc\x4a\xe4\x73\xae\x24\xea\x39\xf1\x99\x65\xcf\x1b\xa3\x9e\x9f\x88\x7a\x1e\xfd\xfe\xe1\x3f\x78\xff\x64\xd4\xf3\x00\x7e\x2e\xc6\x49\x58\x2e\x7f\xf0\xfc\x54\xe4\x73\x10\x8f\x9e\x4b\xeb\x38\xd1\xaf\x18\x61\x2e\xce\xe1\x75\x46\x96\xcb\x10\x0d\x4b\x7c\x10\x39\x6c\xd1\xed\x61\x89\x2f\x22\xc1\xe2\x31\x28\x0b\xfb\x00\x51\xb0\x27\xba\xc1\x96\xdf\x16\xf6\x30\xf4\xfd\x9f\xf1\x9e\xec\x06\x1b\x89\x57\xf2\x43\x88\x7e\x99\xa2\x60\x87\xdf\x16\xf6\x54\x37\xd8\x11\x61\xdf\x05\xc1\x86\x7d\x08\x2f\xef\xbb\x10\xf9\x2f\xe6\x7d\x98\xa8\xe7\x57\x22\x9f\x73\xfb\xa3\x9e\x13\x5f\x46\xf6\xbc\x33\xea\xf9\x89\xc8\xe7\x21\x10\xf5\x9c\xf8\x36\xb2\xe7\x9e\xa8\xe7\x27\xa3\x9e\x5b\xf1\x73\xc9\xa7\xf1\xf2\xbe\xce\xef\x3c\x3f\x15\xf9\x5c\xf0\x6b\x3a\x44\xbf\x86\x7c\x27\x96\x7f\xdf\xe0\x9f\xd7\x8a\xbe\x11\x7f\xd6\x0c\x43\x64\x46\xaf\x85\x4a\x69\xbd\xe8\x04\x0f\x61\xd8\xdb\xaf\x9b\xf8\x5b\x04\x81\x15\x60\xc4\x76\xd1\xbf\x42\x1e\x60\x49\xca\x2d\x30\x48\xf4\x1c\x95\xe8\x15\xbe\xf7\xf6\x8c\x58\xef\xc5\xe7\xe2\x19\xbd\x30\x9e\x0c\xf9\x39\x82\x76\xb2\x7f\x2e\x7e\x1f\xcf\xe7\xf3\xa8\x64\xfb\xe7\xfc\x7e\x64\x8b\x04\xb3\x05\x14\xf3\x79\x06\x86\x68\x18\xa5\xb4\xdf\xd9\x19\x9a\x2e\xdb\x07\xfd\x49\x6c\xa7\x4b\xb8\xc5\xb2\xf5\x48\x3a\xab\x22\xe8\x24\x84\x33\x99\x8d\xd4\x62\xf6\x2a\xd0\x00\xed\x39\x76\x2d\x6a\xaa\x24\x69\xb0\x4a\xfe\x66\x71\xbf\xc7\x4f\x2d\x36\x18\xfc\xfe\x35\xfe\x0a\x65\x83\x9b\xbd\x3a\xbc\x66\xbe\xdf\x37\xcc\xf3\x28\x39\xa3\xd3\xc6\x35\xc0\xea\xd0\x3a\x10\x03\xe2\x02\x7a\x5c\x9a\xb3\x26\x08\x94\x46\x25\xa5\xd4\x81\xbc\xd7\x9b\xf9\x92\x79\x16\x79\x89\x3f\x9f\xf2\xb7\x34\x83\xdb\x9e\x93\xb1\x88\x4d\xd8\x10\xcb\xfd\x3b\x49\x31\x4f\x3b\xdd\x16\x7f\xf7\x2a\x10\x45\x8b\xe6\xac\x1a\xb0\x20\x8f\x64\xc0\xfe\x1f\x48\xc1\xf5\xc7\x99\x33\xf4\x0c\xf6\x59\xe0\x00\xd6\x0b\x16\x9d\x9a\xd5\xad\x35\xc9\x73\x59\x61\x4a\x2e\x25\xdd\xd4\x94\x48\x21\x9a\x7c\x31\x14\x35\x2b\x6b\xd8\x80\x40\x92\xbf\xaf\xb5\x31\x73\x6d\x7d\xce\xf0\xfe\xbd\x13\xa7\xa4\x37\xa5\xf4\x6d\x64\xce\xa4\xf5\x48\xeb\x5d\xba\x7d\x0d\xfa\x67\xc9\x8c\x29\x15\x80\x06\xaf\x32\x2f\xd0\xed\x8a\x3f\xa1\xdf\x94\x20\x11\xa4\x05\x8c\x4e\xab\x49\x05\x59\x55\x1c\x8b\x7e\xf4\x56\x9c\xa6\xea\xbb\x5a\x20\x66\x9b\x1a\xf9\x4e\x85\x64\xeb\x5b\x75\x0e\xa9\x2a\x9c\x8b\x74\x3d\xf5\xd1\x54\x98\x9d\xde\xbf\xb2\x2c\xc1\x57\x6e\x1e\xe5\x5d\x38\x2c\xa3\x7f\x65\xa9\xb3\x31\x75\x94\xb7\x8d\xb9\x7c\xf1\x22\x44\xff\xd3\xa4\x64\xa4\x94\x14\xb6\xb7\xa1\x7f\x66\xad\x9f\x27\xad\xbb\x4a\x69\x1d\xeb\xc4\x27\x2c\x7f\x6f\x3d\x27\x7a\x3f\x8d\x1f\x77\x18\x1b\x6e\x17\xfd\x79\xac\xf7\x53\x6f\x81\x41\xf0\xfb\x37\x11\xbd\x9e\xc6\xeb\xbd\x26\xf2\x7b\x58\x9e\xfc\xb9\xd1\xcb\x63\x90\xe0\x28\x31\xc6\x08\x9d\x25\x67\x2a\x94\xe2\x59\x0e\x65\x27\x97\x4d\xf4\x92\xb4\x13\x7d\xcd\xe0\xf5\xb5\xab\x41\x6a\x7f\x99\xc0\x67\x77\x83\x7f\x99\xc0\x67\xcb\xe1\x65\x39\x14\xd9\x82\x7e\xcf\x05\x38\x7f\xe9\x21\xa4\x53\x37\x90\x4e\xb1\xc0\x08\x4c\x4f\x52\x94\x76\xad\x91\x45\x4a\x7e\x19\xe7\x49\x63\xe5\xf2\xd0\x7e\x9f\x5b\xa6\x62\x37\xe8\xf9\x1b\xe9\xeb\xdc\x5b\x61\x4d\x63\x8e\xeb\x60\x62\x4c\x58\xdb\x08\x4e\x3a\x5f\xc2\xc9\x30\x08\x27\x94\xe1\xf4\x29\x69\x8f\x9f\x96\xe1\x1c\x72\x9d\xfe\x71\x3e\x9d\x20\x57\xde\x18\xee\x5f\x3a\x98\x2c\x21\xa5\xc0\x31\x66\x05\x7d\x4c\x71\x1d\xc4\x02\x0f\xf0\x04\x8c\x29\x1e\x13\x9a\x01\x3a\x0f\xd0\xe9\x80\x87\xb6\x25\xa2\xb9\x20\x54\xd7\x33\x5e\x16\xea\x87\x44\xe9\x14\xbe\x74\x8c\xc2\xd5\xff\xc5\x5e\x4f\x67\x8d\x18\xd8\x37\xc9\x1f\xb0\x36\x7a\x57\x8d\xc9\xa9\x1e\xd4\x27\xb1\xb8\x97\xb9\x29\x29\x30\x76\x93\xc1\x58\x58\x42\x08\x49\x66\x6f\xb8\x52\x5d\x85\xa5\x77\x2c\x49\x4a\x4b\x2a\x2a\x19\xdf\xea\xcf\x19\x5e\x37\xbb\x94\x90\x24\xc5\x6b\x1d\x62\xbc\x46\xdd\xff\x14\x7f\x6a\x37\x22\xe6\x23\x36\x7a\x06\x6f\xa3\xc1\x17\xbc\xf6\xd8\xa2\xf7\x50\x7f\xe6\x61\x70\x3e\xda\xcb\x7c\x44\x75\x1f\xf2\xed\x2d\x01\x1d\xed\x0e\x58\xe2\x06\xb9\x03\x6a\xe3\x20\x37\x30\xe1\x13\xc9\xd2\x3b\xd7\xc3\xef\xbc\x46\x46\x1a\x58\xc1\xb7\x12\xce\xe1\x44\xe7\x78\xba\x0e\xbc\x15\x79\xe6\x16\x3f\x6f\x50\xfc\x49\x8a\x45\xf7\x82\x77\xc4\xf3\xcc\xfc\x59\x58\xe1\x9c\x23\x39\x2f\x42\xce\x83\xe6\x00\xf1\xac\xd2\x0f\x91\x67\x4a\x05\x98\x16\x09\x66\x0b\xa0\xf8\x7c\x4f\x7d\xd8\x16\x9f\x26\x30\x4a\x69\x9f\xb2\x93\x23\xdf\x2d\x43\x3f\x93\xfd\xce\x9f\xc4\x76\xa4\xab\xfb\x89\x4e\xbe\x88\x74\xf2\x6b\x41\x7f\x2c\x17\x28\xca\xa8\xd2\xe1\xcc\x7b\x64\x79\x7d\x3e\xb9\x56\x7a\x94\x56\x87\x07\x97\x37\xa0\xbe\xa6\xe6\x6f\xa4\xae\x73\x57\x93\x1b\xa8\xde\x6b\x32\x13\x78\x95\x7c\xd4\xde\xb3\xb1\xef\x80\xdc\x5d\x22\x4e\x3a\x4f\xc2\xc9\x30\x3a\xa3\x6e\x2d\x24\x38\x2f\x9b\xe5\x5a\x19\xc6\x39\xf8\x3a\xf5\xe3\x7c\x2a\x59\x40\x29\xaa\x64\x18\x69\xa4\x4e\xa6\x05\x4c\xce\x48\x9d\xfc\x53\x12\xae\x36\xf0\x7f\xd3\xca\x70\xaf\xb7\xd5\xca\xad\x22\x21\xdd\x54\x32\x4c\x92\x14\xbb\x77\x88\xb1\xbb\xe0\x37\x84\xf7\x10\xf8\xe7\xb5\x62\xfc\x2f\xf9\x0d\xf2\x7d\x7d\x7e\x8f\xe0\x67\x1e\x06\xeb\x17\xe4\x75\xf2\x7d\x41\x27\xd3\xb1\x4e\xa6\x63\x9d\x4c\x97\x74\x92\x7f\xe7\xba\xfc\x1d\xa2\x93\xfd\x79\x9d\x0c\xfd\x13\xd9\x1f\x7e\xdf\x71\xbe\xb0\x57\x67\xe1\xf7\x9b\xc3\xdf\x91\xba\xc1\x5c\x81\x3a\x1e\x26\x3d\x92\x36\x72\xae\x4c\xe0\x4f\xf8\xfe\x9c\x22\xe7\xef\x6e\xa2\xdb\xfc\xfe\xc6\x5e\x68\x14\x75\x3b\x59\xae\xdb\x51\xdf\xba\xd5\x83\x49\x4d\x56\x84\x49\x1d\xd6\x6d\x1e\xa6\x45\xfa\x1e\x2e\xe9\xb6\x26\xac\xdb\x64\x8f\x93\xe8\x36\xbf\x37\xd9\xc9\xef\x71\x86\xe6\x90\xbd\xcc\x9f\xc4\x76\xa4\xdb\x16\xe9\x1b\x02\x9f\x73\xe9\x0b\x7f\x43\x40\xab\xe6\x3c\xe6\x2d\x7a\x26\xfb\x09\xfa\x0d\x67\x46\x3a\x02\x1a\x4a\x07\x75\x77\x35\xaa\xb5\x0a\x5c\x4a\xc3\xf7\x86\x50\xd9\xda\xe3\xf7\xb1\x44\xfb\x91\xb2\xfa\xe8\x81\x27\x52\x4f\x70\x3f\xd2\x8b\xb6\x53\x67\xbf\x43\xbf\x32\x6f\x3d\x7d\x42\x0f\x95\x3a\xee\xeb\xa7\x7f\x0f\x27\xab\x55\x45\xe3\x4c\x23\xda\xaf\x94\x70\x3e\x76\x96\xfa\x7e\x11\x5d\xc9\xe3\x0c\xea\xb8\xff\xea\xf5\x4f\xf3\x3e\xc8\x26\xe6\x79\x6a\xba\x42\x89\xe6\x91\xe6\x2c\xbd\x96\x94\xed\xc0\xd9\xe4\xb8\x36\x0b\x15\xbb\x4b\xf9\xa6\x4e\xc1\x3c\x0f\x93\xd3\xb8\x6b\x6e\x20\x8b\x67\x94\x92\xcf\xdf\x09\x4e\x09\x3e\xe8\x6d\x62\x1f\x66\xa4\x00\x2b\xc0\x88\xed\xe2\x5e\x12\x5e\x8b\x07\x45\x60\x28\x8e\xd8\x97\x22\xba\xb1\x5c\xae\x1b\xa5\xd2\x73\x82\xe7\xa8\x88\x47\xf2\x41\x05\x3c\xe2\x99\x8f\xd0\x57\x78\xbf\x9f\x8c\x69\x81\x60\xaf\xf8\x98\xf6\x67\xf2\x1d\xe0\x27\xb1\x9d\xb7\x57\xe2\x7e\x2a\xe1\x71\x6c\x04\x3c\xbf\xcf\xfa\x93\xd8\x1e\x86\x27\xb1\xc3\x58\xa9\x9d\xf8\xfc\x48\xb6\xf3\x99\x27\xa8\xff\xb2\xcf\x47\xc9\x16\xd7\xa5\x61\xd1\xb3\x8e\x37\x59\xee\x1a\xf3\x84\x15\xd2\xae\x5f\xc5\xb1\xd8\x48\xcd\x20\xfe\xa0\xbe\x03\x97\x44\x41\xe6\xac\x20\xfe\x0d\x62\x1f\x25\x7b\x32\x43\xb2\x5f\x32\x73\x08\x60\xe8\x5d\xee\x1b\x90\xc5\x2a\x91\x6e\x98\xce\x43\x8a\x62\xd0\xdb\xc8\x4e\x41\x62\xa5\x2c\x26\x8f\x29\xab\x8e\x55\xfe\xf7\x0b\x05\xae\xca\x15\x4a\x46\xb0\x1f\xb3\x77\x20\x3f\x76\x40\x20\x45\x0b\x34\x3a\x9d\x16\x28\x18\xc0\x32\x34\x34\xe8\x69\x2d\x8b\x3c\x45\x15\xcd\xaa\x54\x2c\x4d\x43\xb5\x12\xe9\x56\x9e\xcf\x2c\xd8\x3d\xe1\x07\xfa\x1c\x05\xb2\xd2\xaf\x16\x8f\x49\xe9\xf5\x7b\xfd\x0e\xbf\x43\xe9\x50\x7a\xb3\xea\xd6\xf8\x8f\x1e\x15\xfe\xb7\x86\xfb\x86\x0d\xae\xf5\x1f\x79\xbc\xe4\xd8\xb1\x92\xc7\x8f\xf8\xd7\xf2\xf4\xfe\x0f\xf7\x0d\x3c\x87\x68\xd0\x80\xfc\x80\x4d\x4d\xb1\x40\x45\xd3\x68\x8a\x29\xb4\x8c\x12\xa2\x1f\x85\x46\x01\x48\x0d\x3a\xd2\x29\x32\xae\x05\xe2\x45\xf1\xa4\xd0\x8b\xdf\x83\x58\x72\x7b\xfd\xf0\xdc\x3f\xfc\x1b\x7e\xa9\x85\x43\x36\xf8\x99\xa3\x1f\xf8\x57\xfd\x3a\x9b\xfd\xd7\xaa\x12\x5c\xab\x65\x18\xe2\x31\x83\xe0\xcf\x09\x58\x54\x8c\x42\x4d\xd3\x0a\x05\x80\x5a\x96\x56\xd3\x6a\x48\x98\x22\xd8\x65\xc8\x31\x6e\xc4\x89\x07\x17\x5e\x71\x28\xdd\x19\xb5\xbf\x6c\xf0\xff\x03\xe1\x87\x43\x10\x0b\xbb\x57\xf9\x3f\xf8\xb0\x84\xcf\xa7\xbe\x07\xbe\xc0\x64\x50\xc3\x8c\x0a\xe5\x5f\xba\xb0\x2f\x7e\x3f\xfa\xff\xd9\xd4\x30\x24\x7b\xdd\x79\x08\x9e\x0a\xc2\x4b\x80\x5c\xf4\xe3\x77\x2b\xef\x8f\xa7\x97\xc6\xc3\x17\x36\x6f\xc6\x3c\x7f\x86\xe0\xfe\xd1\x1d\x8e\x46\x70\xce\x78\xe6\xe3\xff\x47\x38\x2a\x54\x89\xf7\x8d\x42\x1b\x88\x8f\xde\x23\xa0\x63\xd8\x67\x82\x80\x31\x32\x54\x1c\xcd\x5c\x0c\xfd\x29\xa0\xd3\x1b\x07\x31\x10\xa0\x46\x08\x11\xbf\xf3\xb3\x41\x6c\x5e\xf6\xb8\x96\x66\x84\x4a\x89\x6f\xfc\xc4\xe4\x59\x98\x77\x2d\xbf\x51\xf8\xef\x6b\xad\xad\xaf\xb7\xb6\x12\x3d\xbc\x4a\xb7\xd0\x3f\x21\x3d\xc4\xfd\xd3\xf0\x40\x23\x0d\x48\xff\x6a\xe8\x86\xf4\x4f\xdc\x3f\xb8\x9f\xe1\x29\xf6\x6a\xd7\xdd\x68\x9e\x41\xf8\x06\x82\xfd\x45\x80\x85\xf4\x81\x46\x18\x86\x85\x6f\xa0\xbf\xd4\x5c\x0d\xdd\x42\xcd\xe9\xba\x1b\xc9\xe9\x04\xb7\x97\x7a\x0f\xd2\x08\x56\xcf\xc3\x32\xc0\xf8\x12\x16\x14\x82\x3b\x01\x53\x10\x6c\x35\x82\x20\xb0\x54\x7f\x84\x77\x8d\x80\x97\x02\x07\x1a\x29\x1e\x2f\xae\x6c\x47\x33\x9d\x50\xdd\x53\xc0\x8a\xd7\xed\x6f\xe9\x16\xe6\x2f\x04\x56\x09\xac\x01\x35\x0b\x31\xd1\x4a\x4c\xb5\x4f\xbc\xc1\xc6\x4d\x7e\xe8\x78\x9e\x7a\xaa\x40\xce\x05\xe1\x04\xe3\xf9\x0f\xc2\xf3\x76\x18\x8f\x92\xc6\x44\xb2\xb0\x3b\x1e\xea\x08\xcf\x59\x57\x04\x87\x12\x3d\x14\xb7\x87\xfe\x14\x52\x04\x8f\x2d\x8c\x47\x05\x8c\x97\x0b\x22\x11\xc1\xa7\x78\xb6\x11\x22\x9e\xfd\x3d\x12\xa2\x50\x08\x0e\x44\xf4\xa4\xe2\x73\x28\xca\xf7\x42\x14\xb1\x44\xef\x01\x12\xfe\x21\xb9\x6b\x42\xd9\xcc\x16\xf6\x0a\xd0\x82\xac\x80\x03\xd0\x5a\x9a\x61\x99\x3f\x07\x15\x6a\x0d\xcd\x2a\xd9\xe7\x1b\x55\x4a\x24\x43\xb4\x28\x10\xca\x1d\xfc\x5f\x7c\x95\x10\xd6\xcf\x5a\x7c\x74\x9a\x92\x66\x7e\x5e\xf0\x01\xb7\x37\x19\x4e\xea\xf1\xc2\x78\x38\x3b\x99\xfe\xf0\xb7\x11\xcc\x59\xd3\x23\x16\x38\x87\xbb\xdb\xf2\x08\xd6\xeb\xa9\x42\x1f\x36\x30\x30\x90\xa9\x31\x5b\x68\xad\x4e\xfb\xe7\xa0\xde\x68\xa2\x75\x31\xba\xe7\x1b\x0d\x31\xc8\xcc\xda\x68\xa5\x42\xf9\xe7\x20\xc4\x15\x99\x18\xc5\xf3\x8d\x34\x0e\x0c\xc3\x7d\xc6\x46\x11\xa0\x4c\xe3\x49\x70\x42\x91\x8e\x34\x2d\xa4\x3f\x4f\xe6\xf6\x21\x2a\xb8\x3d\xc9\x70\xf2\x14\x8f\x8c\x28\xee\x81\xa9\x29\x30\xeb\x11\x0b\x77\x37\x9c\x63\x79\xc4\x04\x27\xc0\x09\x12\x85\x26\xee\x20\x77\x90\xc8\x62\x2a\xdc\x45\xef\xa7\x2f\xa1\x35\x51\x75\x06\x89\x3c\xef\x75\xa1\xdc\xa0\x50\x04\x0e\xc5\x9e\x03\x5b\xd7\x8e\xdb\x5f\x33\x65\xfd\xe4\x07\xe1\xae\x35\x13\x1b\xee\x1b\xbb\xa6\xb5\x7e\x5f\x23\x5e\x53\x75\xc8\xa6\xc7\x83\x0f\xc8\x58\x69\xf1\x9a\xca\x42\xb5\x4a\xbd\xaf\x91\x01\xb8\xae\x93\x78\xfb\xa6\x5b\xa8\xb3\x81\xff\xd0\x7d\xb2\x4f\x66\x77\x3d\x95\x7d\x3c\xbb\xeb\x62\xf6\xa9\xec\x0f\xc8\x7f\x61\x9b\xc6\xfc\x05\xd9\x7b\xdb\x05\x06\x19\x61\x05\xc0\x75\xb6\x88\x89\x21\x65\x19\xb1\x1d\x76\xdb\xb2\x46\xc1\x6b\x4c\x3b\xb6\x54\x23\x91\x9d\x1a\x8e\xec\x54\xa6\xf0\x0e\xa4\x19\x06\xd9\x61\xbc\x98\xe7\x89\xef\xc0\x22\x37\x7a\x8b\x1b\x0e\xaf\x8d\x62\xda\x47\xfe\x9a\xc8\xee\xe6\xed\xa7\x19\xbd\x77\x83\x5d\x8f\xa3\x73\x7c\xef\x1e\x12\x3f\x8a\xce\x59\x1a\x69\x3d\x36\x6c\x92\x59\xe3\x2d\x1a\xee\xf7\xc6\xe5\xba\xcb\xf0\x1a\xfd\x97\xdf\x12\x99\x7f\xc1\xb3\x11\x38\xb4\xd8\x46\x6a\x58\x15\xd2\x5d\x96\xa2\x75\x10\x97\x54\xa3\xd5\x0a\x9a\x18\x7e\x52\xd9\x2a\x6c\x24\x65\x18\x6d\x6e\x11\x2b\xb7\x08\x6e\x15\x31\x8f\xe4\xfe\x1d\x89\x3b\x37\x60\x85\x0a\x85\x8a\xd6\x6a\x55\x6a\xb5\x4e\xa9\xd5\x22\x89\xab\x89\x9a\xe4\x49\xc8\x85\x95\x04\x63\xa7\x11\x56\xc2\x33\xfa\xb9\x01\xb7\x22\xd4\xd7\x50\x1f\x4c\x12\xb4\x8d\xe4\x46\xe0\x2e\x30\xff\xca\xd0\x75\x84\xe5\x18\xc2\x4f\x23\xff\x3f\x11\xc5\xc0\xa5\x60\x00\xa8\x03\xd5\x81\xbc\x9a\xe2\xf4\xe2\x27\x83\x43\xf2\x92\xf2\x9e\x0c\x96\x25\xa5\x27\x5d\x68\x04\x94\x91\xa2\xf4\x34\x9e\x98\x4c\x9f\xf4\x38\xad\xf3\xc9\x20\xa3\xbd\xd0\xc8\x58\xd1\xbf\xd7\x90\x55\xc9\x16\xca\xad\xa0\xd5\x00\x5b\x47\x34\xe2\xe2\x1f\xcc\x2b\xf4\x41\x52\xee\x0d\xef\xe8\xf4\x86\x0e\xfe\xb2\x22\xa1\x70\xa5\xe5\xb6\x4f\x6e\xff\xce\x92\x5d\xd4\x0b\xbb\xb9\xe0\x85\xcc\x91\x6d\x03\x9e\x1a\xb0\x7e\xbf\xd7\x53\x58\x91\x91\x91\x9e\x17\x48\xeb\x79\x31\xb3\x66\x5e\xff\xa7\x07\xac\x3f\x90\xe1\x29\xea\x9d\x96\x91\x9e\x1f\x48\x83\x97\x45\x40\xb1\x31\xb7\x4f\x3a\xdc\x4a\xad\x81\xcb\x2e\xf5\x79\x6c\x49\xf9\xf3\x4d\x6f\x4c\x7f\xa5\xc8\x3b\xf0\x60\x61\x51\xd6\x88\xbd\x5d\x7f\x7d\x36\xf0\xe8\xb2\x32\xdc\xf8\x6a\x51\xc6\x90\x83\xf9\xc5\xa8\x11\x42\x09\x92\x34\xf6\x2c\xca\x1a\x86\xcf\x8e\x41\x6a\x2c\x3d\x9c\xde\x4e\xec\x9d\xf6\x1c\xb6\x5b\xc8\xce\xe1\xc8\x09\x97\xb9\xfe\x7c\xfb\xa8\x8f\xe9\xe1\xb8\xfe\x02\xf2\x91\x97\xd1\xc3\x99\xd9\x82\x5d\x34\x9c\x47\x91\x9b\x82\xc0\xfa\xf2\x0a\x78\x68\x72\xaf\xc9\xcb\x3b\xea\x3e\xee\xba\x5f\x78\xad\x6b\x1d\x79\x15\xad\x95\xdf\xa2\x77\x5f\x42\x36\xcc\xa3\xfc\x9c\xc3\x3b\xee\x29\xca\xcf\xbf\x00\x46\x5a\xf9\x39\x2c\x25\x73\x77\x14\xd8\x4e\x1f\xa5\x8f\xa3\xd9\xe6\x0c\xe8\x28\xa4\x28\xc8\x6c\xd3\xdf\x34\x82\x1b\x80\xcf\x75\xeb\x95\x47\xea\xba\x42\x3f\x0a\xe8\xd0\xba\x4d\x35\x71\x3f\xeb\xe1\x7d\x67\x14\xdc\x34\xa8\x51\x6c\x87\xb3\x2b\xe1\x82\x24\x6e\x1b\xb7\x0b\x57\xd9\x4d\x46\xb8\x96\x88\xb8\x54\x4a\x1a\x1f\xcb\x56\x74\xc7\xe5\xf1\xab\xa1\xdf\x87\x7c\x80\xb7\xcf\x2a\xe0\xfd\xdc\x7f\x15\xa7\xa1\x5a\xbf\xdd\x05\xe7\xc2\x85\x49\xdc\xf6\x4a\xac\x5f\x0c\xd8\x80\xfe\x5a\xc5\xf6\x13\xec\x82\x01\x14\x06\x5c\x40\xad\xa2\x21\x64\x28\x85\x3e\x86\x66\x19\xf6\x60\xa3\x52\x67\xa0\x19\x33\xae\x72\x42\xd1\xa0\xd2\xe1\xab\x14\xec\x1c\xb9\xb9\x97\x98\x3b\x2c\x1c\xbc\x21\x26\xfe\xbb\x66\xcf\xe1\xcb\x5c\xa1\xf7\x79\x2f\x35\x45\xfc\x0d\x6e\xa7\x2f\xfc\x7a\xe9\xd5\x57\xc5\x7f\x91\xcc\x8e\xb3\xc7\xd9\xbd\x0a\x9d\x59\x09\xfa\xc2\xfe\x8a\x3b\xc9\x7e\x1f\xae\xd5\xb1\x8f\xed\x8f\x6b\xc0\xa3\xd8\x07\x05\x11\xb1\x42\xe9\x4e\x1f\xd2\xd0\xbf\x2f\xa6\x5f\x5c\x80\x1e\x02\x06\x22\x8f\x54\x58\x37\x79\xba\x03\x67\xd4\xaa\x8b\xb0\xff\x93\x8d\x6a\x14\xcb\xea\x75\xe4\x57\xbd\x1e\xb0\x2c\x83\x7e\xed\x68\xc4\x97\x19\xa0\x5f\xce\x36\x02\x73\xc4\xe5\xa9\xe2\x3f\xbc\xe9\x23\xa9\x8c\xe2\x9f\xfd\xd9\x2f\x64\xfb\xb2\x5e\xc8\xe2\xfe\x8d\x7e\xe1\xfe\x8d\x7e\xfb\xe0\x03\xe6\x3f\x1f\x7c\xc0\x35\xa2\x3f\x41\x62\x0a\x65\xf3\xdf\x00\xfa\x05\x92\x15\x1a\x8d\x4a\x47\x1b\xa0\x41\x47\xa3\xbe\x35\x2c\x72\x00\x8c\x5a\x83\x01\x19\x1c\x46\x8f\x86\x09\xdb\x02\x13\x6f\x0d\x44\x73\x80\x0d\x8f\xc9\xe1\x13\x7c\x4c\x64\x15\x7c\x26\x4f\x91\xdb\xe6\x31\xf9\x6c\xbc\x65\xb8\x8c\xcc\xce\xe5\xcb\xa2\x65\x40\x46\x47\xb2\x0d\x94\xd4\x37\x2d\x58\x1f\xa5\x52\x0d\x18\x46\xad\xd1\xe8\x54\x0c\x83\x9c\x4c\xb4\x46\xfe\x9e\xf5\xa1\x4d\xbc\xf9\x39\x00\xcb\xb8\x97\x6a\xb0\xf9\xc1\x7d\x70\x07\xe0\x59\xc9\x00\xc1\x90\x11\xf5\xf1\x2d\xea\x83\xd8\x7a\x1a\x17\x69\xc5\x35\x12\x05\xb3\x5d\x40\x8c\x24\xed\xa6\xb3\xea\x5e\x82\x1f\xbf\x84\xdc\xc7\x74\xbc\x66\x85\xdf\xdb\x02\x14\xd8\x6e\x2b\x20\x5a\x26\x94\x88\x36\x64\x77\xbb\xd9\x6d\x4c\x83\x13\x22\x0c\xdf\x7e\x2b\xd8\xd6\xa7\xb8\x81\x84\x3f\x13\xc2\xf1\x0d\xf2\x6d\x15\xc8\xbb\xcd\x0a\x98\x19\x95\x46\x03\x95\x2c\x8b\x5c\x5c\x44\x87\x56\x45\x08\x91\xf8\xc2\x66\xbb\x94\x5f\x7e\x3c\x26\xec\xd8\xfa\xbd\x4a\x47\x56\xdd\x8b\xdf\x7c\xf3\x62\xdd\xea\xd5\xab\x11\x6d\xec\xf9\x0f\x3f\x3c\x7f\xbe\xad\x6d\x9e\x7c\xdc\xf4\xc8\x2f\xb7\xab\x14\x1a\x5a\x0f\x35\x28\x26\xd0\xc6\xa8\xf5\x7a\x34\x9d\x18\x6d\xd8\x72\x0b\xc2\x13\x46\x49\x1c\x23\xf9\x08\xc5\x4a\x03\xc4\xed\x97\xc6\x07\xc2\xc9\x94\x92\xbe\xc6\xe0\xcc\x8b\xba\x40\x89\x1a\xc6\xea\x0c\xac\x05\xc4\xe8\xf5\x16\x8b\xe2\xd3\xa0\xc1\x92\x64\xa1\xd4\xb4\x25\x80\xbc\x57\x60\xd9\x1f\xd4\x68\xe3\x68\x03\xa8\x04\x23\x01\xfd\x26\x08\x21\x5b\x0e\x92\x41\x35\x1a\x5a\x90\xd7\xdc\xdc\xe6\x28\xc8\x06\xd9\x82\xd1\x8e\x45\x3c\xa3\x30\xa5\x5b\x39\x7c\x59\x7d\x73\x8a\x1b\xae\xce\x2f\x1e\x34\xcd\x3c\x70\xed\x44\xc7\x12\x03\x95\x39\xb3\x2e\x58\xab\xae\xa3\x94\x70\x47\x8e\xab\x67\xfa\xa4\x16\x6e\x0f\x0c\x6d\x9d\x5b\x52\xd5\x7f\x78\x6a\x1e\x37\x12\xdb\xaf\x57\x43\x53\xe9\xdd\xd4\x6a\xa3\x92\x9d\x10\x3a\xd7\xb5\x85\xd8\xb4\xb7\x42\xd3\xe9\x3b\xa8\xb5\xa8\x6d\x5a\x68\x3b\xbe\xab\x15\xb5\xbd\x1e\x9a\x49\x6f\xa3\xd6\xa1\xb6\xb6\xd0\x81\xae\x9d\xa4\xed\x54\x68\x19\xfd\x32\xb5\x00\x45\x84\xf9\x54\xb9\xd0\xf6\x56\x68\x1a\x7a\x77\x0d\x82\x9b\x1e\xba\xb3\x6b\x1b\x99\xdb\x28\x7a\x65\xfe\x87\xfd\x1b\x5a\xc7\xfa\x07\x3c\x00\x58\x29\xb5\xae\x35\xa8\x56\x5b\x29\xa3\x4d\x65\x6b\x0d\xea\x55\x2a\x2b\x45\x39\x5b\x83\x14\x6d\x35\xb5\x06\xad\x91\x33\x35\x7c\x57\xb8\xd0\x80\x6f\x4f\xe1\x2f\x36\x73\x58\xdc\x4a\x37\x2d\xfc\xb1\xa4\x9a\xf0\x8d\xff\x05\x76\x07\xbd\xc4\x70\xf6\xc5\xa7\xe6\x2f\x1b\x4d\x8d\x73\x72\xa3\xcb\xe0\x06\x27\xb7\xb2\x12\x5e\x76\x76\xdd\x39\x96\x9b\x7f\x27\xb4\x3f\xb7\xaf\x43\xcb\x1c\xdf\xf7\xf5\x7f\x37\xac\x81\xf0\xfc\x56\xee\x9d\x2d\xdc\x53\x5b\xe1\x9b\x0c\x5c\xf1\x32\x4c\x3c\xbc\x6b\x3d\xd9\x8b\x30\x85\x76\x32\x1f\x22\x3b\x93\x0c\xf0\x0e\xf4\xa8\x40\x8e\xda\x6d\xb3\x78\x75\xee\x0c\x15\xa5\x53\xa1\xf8\x51\x47\x83\x74\x8b\xc5\x6c\x0c\x18\x35\xe3\x82\x46\x8b\xc3\x60\x01\x9e\x71\x41\x90\x34\x3e\x48\x23\xeb\x5a\xf9\x12\x59\x74\x2f\xf3\xd9\xd3\xaf\x23\xfd\x11\x02\x4c\x7c\x01\x40\xa9\x50\xda\xcd\xee\x40\x83\x67\x47\xd1\x18\x2c\xb6\x38\x28\x37\xbe\xc5\x3f\x1d\xfd\x65\xc1\xb5\x6b\x53\x2b\xa1\xcf\x92\xee\x45\x30\x34\xc4\xf7\x67\xcf\xab\xa9\x1c\xb9\x63\x49\xaf\xd8\x0e\x2d\x37\xf2\xcd\x47\xef\xfe\x07\xd7\xe1\xed\xb1\xa3\x74\x50\x59\xd3\x8e\x3d\x3d\xef\x46\x7a\x58\xb6\x83\xf1\xd7\x70\x45\xc9\x23\xb6\xc2\xea\x49\x9b\x9b\xd8\x7a\x75\xca\xe1\x9f\x6a\x97\xf5\x29\xbc\xb9\x99\x86\x8e\x3e\xdc\x36\xd8\xb2\xd0\xd1\xf3\x12\xcc\x9b\xf3\xec\x4d\xb8\xf6\x63\xd3\x62\xee\x82\x4f\x79\xb3\x76\x84\x07\x06\xa9\xb3\x9e\x4b\x1c\xbe\x77\x83\xe4\xf9\x5d\x62\xc7\x82\x2c\xd0\x3b\xe0\x56\xab\x74\xa6\x71\x41\x3a\x5e\xa5\x70\x28\x74\xa9\xa9\x3a\x85\x83\x89\x77\xbb\xbd\xe3\x82\x6e\x26\xde\x36\x2e\x18\x6f\x89\xbe\x90\x8e\x5c\x41\x2d\x6c\xd1\xe0\xb1\x89\xba\x01\xd6\xc0\x73\x99\x42\x15\x19\xd1\x30\x25\x5b\xf8\x2c\x72\x0a\x56\xfc\x7f\xbc\xbd\x09\x7c\x14\xc5\xf6\x28\x5c\x4b\xf7\xf4\xec\x6b\x26\x33\x99\x24\x33\x99\x4c\x16\x92\x00\x09\x99\x24\x43\xd8\x32\x2c\x09\x01\x04\x12\xf6\x66\x4b\x08\x48\xc2\xbe\x2f\xb2\x0b\x44\x40\x10\x0c\x01\x65\x51\x04\x05\x95\x7d\x87\xa0\x22\x28\x88\x0b\x20\xb8\x5d\xc4\x5d\xd1\xeb\x55\x51\x51\xb9\x78\x25\x99\xce\x57\x55\xdd\x93\x84\xc5\xff\x7b\xf7\xf7\xde\xf7\x26\xe9\x9e\xee\x9a\xea\xaa\x53\xa7\x4e\x9d\xa5\xba\xea\x9c\x76\x1d\xfa\xdc\x1d\x0d\x36\xe1\xb5\x4d\xd5\xa4\x89\x1f\x7e\xb9\x03\xb6\xf9\x18\xf6\xee\x74\xd4\x54\x39\xfa\xf1\xf7\x26\xc3\xeb\x33\xf6\xf8\xe0\x8e\xc6\xd8\xb0\x2f\x47\x40\x9e\xb6\x4d\xfd\x6f\x68\x85\x6b\x2f\x4a\x07\x3b\x4e\x59\xb2\x8d\xbe\x58\x85\xf5\x44\x49\xe3\x7e\x20\x22\xc3\x02\xfa\x04\xb3\xd5\x3a\xa3\x6e\x84\xc8\x1b\x21\x57\x22\x7a\x60\x3a\xcc\x83\x84\x59\x7b\x60\x6f\xb8\x10\x9e\x82\x97\xe0\xaf\xb0\x1e\xaa\x6d\xd8\x48\x30\xad\x31\x99\x40\x89\x68\xc2\x5a\x8d\x15\x34\x46\x0a\x65\x8a\xd3\x94\x46\xad\x09\x52\x82\xa3\x7f\x72\x10\x1a\x42\x86\xc8\x34\x00\x6d\xf7\x84\x86\x36\x83\xcb\xa2\xa4\x87\x32\x4f\x65\xee\x8f\xda\xff\x32\x9e\xeb\xe6\x76\x4a\x5d\xb6\x9c\x7f\x58\x0a\x41\xfc\x30\x7e\x4d\xf6\x87\x5a\xff\x3b\x81\x6d\x35\xc1\x73\x0b\x30\x25\x98\x9f\xa4\xd1\x6b\xa6\x89\x3e\x7d\xbc\xc1\x6c\x98\x26\x7a\xcc\x1e\x7d\x89\x7e\x92\x1e\xe7\x91\x13\xf2\x98\xa1\xc9\x7c\xca\xfc\xab\x19\xeb\xb1\xde\xac\x37\x73\x11\x11\xd1\xd3\x44\xa7\x33\x42\xe0\x53\xb8\x94\x69\xa2\xb9\x45\x5c\x0b\xd4\xa2\x05\xe7\xa4\x9a\xcd\x30\x25\xb6\x6a\xfa\x1d\x40\x0f\x9b\x22\x47\x05\x6f\x88\x0d\x6e\x84\x3e\xea\x46\x91\xc6\xae\xf1\x07\xc2\x11\x74\xc2\x9b\xfa\x4d\x50\x69\x18\x31\x7a\xbc\x99\x39\x01\x2e\xb7\xf9\xa5\xb5\xa1\x02\xf7\xe4\x11\x76\xfe\xa5\x98\x97\x62\xc9\x61\x4c\xba\x75\xa6\xfa\xa0\xe1\x84\xba\xa4\xdb\xd4\x65\x4e\x33\xdc\x10\x23\x55\xc4\xb2\x33\x4c\x7d\x09\x5e\xeb\xff\x90\x07\x06\xd6\x3d\xb7\x29\x7b\xde\xb8\xa8\xd5\x1b\x1e\x7b\xe0\xcc\xdb\x0f\x4d\xc8\xcd\x7b\x60\xda\xfc\x7e\x8f\x6d\x58\x2d\x5c\x19\x24\x0e\x94\xdf\xef\x81\xfa\xd6\xdc\xd3\x7c\x10\xf8\x81\x3f\x18\xe5\x89\x72\xb6\xd2\xc6\x68\x4b\xc5\xf8\x18\xe8\xb4\xc7\xd8\x63\x4c\x71\x38\x15\x03\x13\xed\x83\x73\x34\x08\x0e\x8b\xfb\x14\x6e\x08\xb3\x57\xb0\x0f\x32\xf7\xd2\xf7\x09\x74\x6d\xa7\x84\x27\x33\x44\xd9\x97\x60\x1a\xd4\x41\xb8\x2b\x95\x48\xb8\x6b\xb1\xba\xfb\xc4\xb7\x1e\x98\x0f\xb5\x1b\xd7\xf1\x03\x8b\x23\x57\xbd\x48\x63\x5a\xc3\xcb\x0f\x7d\x2c\x95\xe2\x88\xf5\x43\x62\xee\x0d\x6b\x5d\x06\x0f\xff\xce\xc2\x5a\xa7\xcb\xd1\xac\xa5\x9d\xa1\x75\x34\x66\x12\xe9\xd3\x7a\x42\x6f\xd1\xc0\x03\x7c\x20\x99\x8c\xa1\xfe\xc1\xe6\xc9\x2e\xa4\x12\x54\x25\x62\x5c\x8c\x43\xf0\x79\x22\xb5\x3a\xc2\x2b\x52\x6c\x26\x5d\x02\x27\x34\x4b\x35\x08\xba\xd4\x54\x1d\xb1\x53\x2d\x44\x77\xe7\xac\x72\x44\x87\x30\x97\xa0\xff\x7e\xc5\x3c\xf3\x37\x5e\x91\x96\x63\x85\xe8\x02\x2c\xc4\x8d\x4d\x71\x84\x4f\x5d\xf2\xeb\x20\x49\xe4\xfd\xc9\x3e\x98\x13\xf0\x41\xc1\x8f\x3e\x1d\x2f\x9d\x2d\xda\x55\xb4\xc2\xbd\xa2\x05\x39\x7a\x7d\x31\x0e\xe6\xf7\xda\xd3\xab\xd2\x5d\xd9\x82\x1c\x45\x97\xd7\xb6\x08\x49\x5b\x6e\xb6\x7f\x14\x7e\xa0\x31\x3c\x20\xad\xb3\xe7\x13\x65\xb1\x1c\x6e\xdc\xfc\xfd\x66\xb8\x46\x9a\x42\x0f\x72\x29\x95\xa3\xac\xef\xbf\xff\x3e\x54\x33\xe7\x01\xf4\xde\x11\xb9\x99\x67\xeb\x6f\x71\xcf\x92\xb6\x6a\x41\x26\x68\x07\xfa\x80\x59\xc1\x8e\xf9\x7d\xf2\xfa\x4c\x17\xed\xce\x96\xa9\x9c\x5b\xe7\x6e\x36\x5d\x4c\x48\x70\xbb\x3b\x99\x82\xd0\x88\x83\x79\xc1\xd6\x70\x9a\x08\x5a\x93\xeb\xbc\xd6\x79\xad\x75\x1c\x17\x98\x26\x72\xaa\x6e\x36\x9d\x6d\xba\xd8\x4b\x67\x36\xeb\x74\x98\x51\x30\xb1\x0a\xfd\x77\x45\xf3\xa3\xb2\x8f\xb1\x50\x72\xe1\xa7\x39\x64\x7e\x13\x9e\x09\xa6\xde\x09\xe3\xa8\x05\x4c\xec\xe1\xf6\x30\x40\x7d\xd1\xe7\x41\xe6\x6d\x5f\x91\x89\x26\x18\xc8\x62\x7e\x8a\x09\x47\xa2\xfe\xd2\x21\xa5\x06\x4c\xed\x14\x7c\x77\x24\x03\x62\xcc\x04\x6c\xd0\xdb\x7e\xe1\x36\xa8\x7a\x1f\x9a\x47\x1f\x81\xa1\x82\xe2\x49\xed\xda\x99\x50\xc1\x98\x9c\x92\x2e\x1d\xbb\x12\x05\xda\x69\xcf\x31\xa1\x84\x16\xa5\xf3\xa4\x88\xfc\x76\xad\x7b\x07\x3b\x0c\xf4\x77\xb3\x0d\x1e\xd8\x35\x66\xbd\x6d\x7d\x77\xdc\xba\x45\x8c\x2d\x3b\x6b\x35\xdf\x0b\xad\x0e\x4d\xe5\xf3\xaf\x4f\xfb\x62\x4e\xa8\xa2\x47\xa1\xd9\xa2\xe9\xdd\xd3\x1e\x08\xf4\x15\x03\xa5\xfe\x1e\x79\x26\x5e\x6f\x76\x7b\xbb\x59\x5d\x99\xbe\x6e\x43\x06\x2c\xe1\xba\xe4\x07\xa4\x07\x7b\x56\x4b\x2d\x47\xac\x5e\x3d\x42\x5a\xe4\xca\x12\x46\xe8\x66\x34\x87\x74\xaa\x05\xe0\xfa\xfd\x84\x27\xff\x41\x70\x4d\xe3\x81\xe4\x81\x9e\xc1\x66\x6d\x12\xdc\x59\xe4\x2f\xdd\x95\x1e\x18\x21\xa6\x9b\x5d\xde\x11\x84\x17\xeb\x91\x0d\x95\x88\x36\x1b\xc7\xf3\xd6\x12\xea\xb6\x83\x6b\x64\x5f\x54\x70\xde\x13\x08\x95\x4d\x34\x12\x4a\xa2\x08\x94\x83\x15\xd8\xb0\x82\x9a\x1c\x16\x13\x43\x8e\x8b\x7d\x67\x14\x8c\x48\xbb\x49\x8e\x2a\x42\x65\xaf\x1b\xc2\xf2\x91\xad\x27\xef\x25\xc8\x7a\x76\x4b\xf5\xfc\xe9\xf6\x41\xa3\x22\x87\xc4\x54\xae\x42\xab\xcf\xee\x7d\x78\x3e\xbf\x11\x75\xea\x30\x74\x68\x4c\x76\xaf\x82\x4e\x89\x47\xb6\x4f\x99\x06\x37\xc1\x91\x0f\xf4\x0f\xf6\x1c\x3f\x00\xe5\x85\x5e\xe3\xf3\x37\x2f\xdb\xfc\x63\x5a\xe8\x31\x4e\x5b\x5c\x2c\xa5\x6e\x0b\xfd\xba\xff\xfc\xbc\xc7\x3d\x83\x7a\x4e\x29\x49\xcc\x4d\x4b\x88\xeb\x30\xa0\xc3\xfe\x97\x67\x4f\x8e\x89\xb0\x2d\x1c\x23\x66\x75\x8e\x6b\xb9\x80\x58\x3a\xf5\xdf\x13\xdd\x76\x6c\xc3\x18\xa3\x1e\x5b\x5b\x80\x21\xc1\xf4\x84\xe4\x94\x24\x9d\x60\x32\x9b\x4a\xc4\xe6\x71\x31\x9c\xd9\xe7\xc1\xb6\x08\x5b\x89\xe8\x04\x11\xc9\x86\x16\x69\xe6\x88\x16\xe6\x88\x08\x73\x0b\x6c\x70\x45\x62\x8d\xe1\xbe\x03\xad\x71\x9c\x29\x97\xf2\xdb\x2f\x65\x60\x61\xf6\xd7\x38\xe8\x68\xf4\x09\x79\xac\x91\x71\x46\xbe\x02\x3e\x81\x0c\x37\xee\xf3\xa0\x7b\x50\xf1\x3c\xf7\xba\x35\x97\xdd\x3b\x4f\x5f\x36\x57\xbb\xe7\x68\x06\xb8\x3b\x98\x4f\xba\xd0\xf5\x45\x27\x43\xaf\x3e\xda\xfd\x9f\x92\x75\xf9\x84\x7f\x22\xbe\xa0\x28\xf4\x5e\x79\x4f\x0d\x5c\xd0\x77\x08\x3e\xc6\xc6\xd8\x5d\x23\xaf\xee\x57\x3a\xe4\x1e\xfb\xed\xb7\xdf\x86\xc2\x63\xa7\x98\x4e\x4c\xfd\x7a\x25\x72\xe7\x69\x20\x1c\xd0\xfe\xb8\xcd\x66\x11\x04\xab\x25\xba\xa3\x09\xf6\x04\x66\xd8\x8b\x24\x1b\x61\x3f\x20\x02\x0b\xb9\xb7\x02\x3b\xbb\xb6\x92\xf4\x86\x88\x8d\x79\x96\xc6\xb8\x7d\xb4\xbf\xb1\x2f\x20\xb3\x46\xec\x8b\x46\x7e\x2c\x87\x99\xf4\x63\x62\xd3\x23\xef\xdb\xfb\xcc\xed\x4e\x64\x44\x0c\x9f\xbf\xe7\x62\xcd\xcf\xbd\x1e\x3b\x31\xe1\xc0\xc4\x05\xc5\xb1\x4b\x6b\x2a\x9b\x2d\xfb\x70\x0f\x77\xfe\x89\x17\xb3\x17\x49\xef\xd6\x55\xf4\xab\x18\x52\xfb\x25\x77\xbe\x36\x1b\x5d\x0d\xbd\x57\xb0\x7d\x3d\x7a\x36\xd4\xe7\xfc\x8f\x15\xb2\x5d\x9c\x24\xfd\x83\x4f\x67\xef\x8d\x3e\x60\xef\xb5\xde\x23\x9a\xa4\x0d\x08\x87\x50\x2b\x87\xbc\x0f\x8d\xc8\x80\x1e\x84\xb6\xbf\x24\x72\x30\x85\xf4\x62\x36\x34\x59\x4d\xd3\xc4\x66\xd6\xa4\x08\x47\x04\x91\x87\x0e\x8f\x15\xe6\x59\x27\x59\x91\xc9\x71\xca\xf1\xab\x83\x08\x40\xab\xc3\xea\xd0\xbb\x5c\x71\xd3\x44\xb7\x4b\xd0\xf3\xd3\x44\xb5\x3e\x8a\xce\x5c\x02\x36\x07\xd7\xc8\x2f\xee\x91\x78\x72\x40\x9c\x9c\x80\x83\x06\x26\xb0\xd0\x2e\xcc\x61\xa7\x04\x25\xd4\x3b\x8d\x0e\x20\x78\x89\xe8\xc3\x83\xa5\x6c\x6e\xd1\xb2\xee\x8f\x4f\xce\x9c\xf4\xd6\x04\x69\x04\x5e\x12\x33\x4b\xe5\x9c\x15\xf3\x70\x0f\xd8\xec\xbb\x09\xbb\x7b\x4e\x98\xf5\xf8\x73\x07\xb3\xe1\xc5\x18\x29\xd1\xa2\x83\x9f\xc0\x4b\xf9\x95\x0b\x52\x3b\x2c\xeb\xd4\x06\x3e\xdd\xf9\xf1\xce\x03\x57\xff\x78\x3d\xa7\xc3\xaa\x51\x55\xbb\x1f\xeb\xd5\x9d\xb5\xcf\x42\xfd\xb1\x12\x7a\x8d\x00\x89\x41\xab\x0d\x09\x6a\x81\xa8\x8a\x7a\xb5\x9a\x37\x6a\x31\xe0\xad\xe1\x18\x3e\x8d\xb3\x70\xd0\x27\x28\x1a\x05\xe9\x11\xe8\xa7\xc2\x18\xe2\xc5\xd2\xd3\xae\x43\x43\x4e\x3d\xb4\xcd\xb3\x6d\xe2\xa9\x89\x43\x50\xef\xaf\x43\xcf\xa0\xf6\x1e\xa9\x15\x51\xdd\x26\x6d\x92\xd2\xd0\xa4\xad\x28\x27\xf4\x0e\x3d\xb6\x86\xaa\x98\x1e\x47\x7d\x34\x91\x7a\x1d\x20\x3e\x18\x01\x22\xec\x11\x25\x22\x82\x2a\x13\x6f\xd6\xe9\xd5\x5a\x3b\xd6\x5a\x01\x73\xf1\x1a\xd6\x65\x12\x05\x5e\x20\x07\x9b\xb8\x4c\x0c\x90\x83\x7a\x2c\x15\x70\x97\x36\x70\x8c\x47\xda\x10\x07\x2b\xc8\xb9\xf8\xd5\x0e\xd2\x06\x37\xac\x88\x93\x36\x92\x73\x4f\x29\xdf\xcd\x65\x51\xe5\xe6\xea\x9e\x67\x76\xed\x20\x87\x34\x0c\x06\x77\x6e\xda\xfd\x3c\x39\xe0\xca\xa7\x98\x9e\xc3\xd7\xef\x91\x5e\xe2\xaa\xf9\x14\x42\x90\x39\xa0\x23\x31\x70\x06\x81\xce\x41\x6f\xa7\x5c\x73\x1f\x77\x64\x5c\x62\x46\xb3\x38\x95\x3b\xa3\x99\xd9\xed\x36\x37\xcb\xe0\xa2\x5a\x74\xcb\x1b\x38\xd0\xa6\xc5\x51\xb2\xcc\xa7\x63\x31\x5d\x1e\xa4\x84\x6a\xe5\x51\x4a\xff\x32\x95\x90\x3d\x44\x51\x56\x09\xbe\x1c\x39\x32\x6a\x24\xe1\xfe\x2c\x98\x96\x1c\xab\x27\x90\x63\xcd\x09\x18\x21\x0d\x64\x40\x3a\x9d\x46\x7f\xa4\x91\x49\xa0\xc2\xb8\x28\x83\x53\x21\x01\x09\xe1\x70\xb0\x8a\x35\xe1\xcf\xe4\xaa\x1f\x9b\xe8\x4b\x8f\x7c\x20\x33\x76\x46\xeb\x66\x8f\xb7\x9a\xd2\x3b\xbf\x67\xdd\xef\xc1\xc1\x69\xbe\xe1\xfe\xd2\x7e\x1d\xb2\x52\x32\xdc\x73\xa7\xb6\x2d\xda\x9e\xa1\x7d\xf4\x8d\xde\x53\xa2\x83\x9d\x26\xcd\xdf\xf4\x03\x4a\xe9\xdc\xbe\xb7\xd7\xd7\xae\xb7\xd4\x23\x7b\x76\xff\x91\xad\x0a\xc4\x11\x2f\xcf\x1f\x10\x3a\x19\x9f\xe1\xcd\xcc\x2e\x84\xa9\x0f\xef\xf1\xb8\xdf\x5d\xda\xb2\x6c\x0c\x1c\x33\x6f\xec\x50\x69\x79\x9b\x76\x39\xc1\xb2\xae\x62\xfc\xaa\x12\xd8\xe7\xcb\xee\x7c\x6a\x4c\x56\x8f\x21\xfd\x22\x3b\x0c\xe1\x4e\xed\x7a\x59\x5a\xf2\x11\xf4\x8e\x5f\x30\x2a\x33\x6f\x39\x5e\xda\x5b\xaa\xff\x4e\xba\x59\x52\x7a\x05\x4e\xdc\xfa\xc8\xfa\xba\xb2\xf8\xb4\x8c\x5c\xca\x07\x3e\x90\xd7\x89\x12\xbb\xa4\x39\x68\x13\xf4\x58\x23\x9c\x38\x32\x15\x47\xe1\x04\x87\x23\x92\xc8\xdc\x52\x31\x01\x47\x5a\x75\x06\xb5\xa1\x54\x54\xdb\x88\x8e\xae\x84\x30\x0f\x8b\x02\x82\x52\xd9\x86\x8c\x80\x82\xcd\xc1\x82\x1f\x51\x0f\x4b\xed\x61\x32\x86\x58\xf0\xc1\x68\xa8\xb0\x7a\x21\x1c\x3d\xda\xd1\x01\x72\x6f\x4a\x5f\x17\xb4\xc5\xaf\xec\x28\x7c\xc0\xdd\xab\xcb\x26\xe8\x93\x2e\x4e\x3b\xf0\x22\x5c\x33\xe6\x7a\xab\xd3\x4f\x8d\x9d\xfb\x42\x20\xb1\x6b\x2f\xbd\xaa\x72\x30\xf7\xcb\x31\x69\xde\xf0\xd0\x13\xdd\xb6\xee\xb1\x6d\x8e\x3f\x10\x13\x03\x5f\x93\x86\x40\xdb\x6d\xe4\x96\xfe\x01\xbb\xc0\x09\x7b\xf7\x5e\x9c\x35\xbb\x55\xab\x55\x4b\x7a\xbf\xdc\xfc\xe3\xf3\xf2\x3c\x14\xf5\x63\x92\x4e\x68\xd5\x45\x78\x7a\x02\xe1\x04\x0b\x82\xda\xa8\x18\xc2\xcb\x47\x88\x91\x89\x66\xfa\x96\x27\xa8\xd1\x17\x9a\xcd\x1a\x2b\xf6\xe9\xf4\x44\x89\x07\xb1\x66\x7d\x9c\x3e\x43\x7f\x40\xcf\x99\xf4\x90\xa8\xc5\x7a\x8d\x35\x81\x8c\x2b\x90\x60\x4e\x88\x4b\xd8\x9a\x70\x20\xe1\x74\x82\xca\x80\x13\x12\xac\x1a\xab\x35\xa5\x44\xb4\x62\x99\x07\x92\x71\xc6\xec\x68\x86\x05\xca\x25\x94\x51\x27\x5b\x96\x0d\x43\x90\xb2\x7c\xaa\x21\x37\xb2\xfb\x00\x0b\x79\x2e\xf8\x54\xc9\x64\x34\xe6\xc0\x4c\x32\x34\x6c\x5e\xc2\x37\xb9\x2d\xa3\x5c\x8f\xf5\xaa\x7d\x5a\xfa\x7e\xd4\xa9\xb5\x2b\x5c\x2b\x6c\xe4\x68\x01\x2f\x9c\xb8\xec\x7a\xd8\x35\x42\x77\x3c\xf4\x86\x0d\xb5\xb6\x48\x8f\x3e\x3b\x5a\xd2\x59\x06\x41\xa9\xf3\xb1\x5b\x78\x5a\xe5\x94\xb9\x21\x09\xfd\x52\x59\x56\xf9\xd3\x82\x09\x95\xc1\x60\x59\xba\xf4\x67\xff\xfe\xf0\x35\x16\xf7\x00\x13\xfb\xab\x39\x77\x80\xf4\xad\x83\x46\xfe\x02\xed\x82\x5e\x57\x9c\x23\x8e\x34\xc1\x43\x0e\xc2\x1d\x75\x08\x06\x1d\x36\x4b\xb4\x3a\xba\x44\xd4\x69\x46\x88\x3a\x35\x47\xf9\x9f\xdc\xc1\xae\x8b\xf2\x0c\xaf\x12\xd9\x96\x27\xb6\x24\xb1\xb4\x00\x8d\x0f\xe2\x86\x84\xcb\x25\x13\xbd\x91\x46\x0e\x36\x3b\x6c\x46\xfa\x32\x83\xb2\x7b\xd4\x6a\x5e\xe2\xbe\x1a\xd2\x33\xe9\x8e\x79\x8e\x55\xcf\x47\x1f\xf3\x3c\x51\x06\x1f\x9d\x34\xe7\xf2\x70\xe9\x9f\x27\x2f\xcf\x3f\x50\x0a\x97\x17\xe5\xce\x49\xeb\xf4\xe1\x19\x0b\xd4\x7f\x05\x1f\x81\xef\x3a\x66\xcc\x34\x3e\xb3\xa9\xf5\x19\xb7\xa4\x09\x9d\xed\x5a\xa0\x41\x40\x3a\x97\xcc\xa5\x59\xf7\x49\x17\xb6\x4b\x15\xaa\x66\x2e\x58\x44\x74\x96\x6d\xa4\x4f\xcd\x8c\xff\x44\x13\x69\x95\x1f\x4c\x50\x73\x7a\x83\x9e\x08\x64\x68\x88\x06\x66\x8b\xb9\x44\x8c\xb1\x5b\xe2\x62\x6d\x06\x4b\x6c\x2c\x51\x7e\xb5\x36\xac\xd2\x32\x6e\xd8\x28\x95\xc3\xbd\xd3\xd8\x31\xb4\x0f\x6c\xbe\x06\xed\x97\x3a\x55\xa6\x86\x17\xef\x4d\xf6\x06\xfc\x49\xe9\x50\x85\x3f\x6c\x76\x3e\xb6\xba\xd3\xdb\x6d\x42\x9f\x9c\x7b\xfb\x62\x55\xec\xdb\x8b\xa4\x6b\xb1\xb0\x3f\x54\x9f\xeb\x0b\x07\xc6\xd6\xad\x81\x27\x13\xa4\x6b\x7d\x8e\x58\xd5\x1a\x0d\xfa\xea\xeb\xf5\xd2\x13\x70\x2c\x3d\xd6\x7f\xbd\x1e\x5e\x96\x32\xd6\x7f\xfd\xf5\xfa\xd1\x43\x07\xd3\xd8\x37\xf5\xb7\xeb\xaf\xf3\x26\x22\x97\x02\x54\xdf\x4a\xe1\x78\x62\x35\x26\xf1\x5e\xd6\x04\xb7\x21\x33\x9b\xb7\x1b\xa2\x78\x03\x6f\xc8\x8e\xca\xce\x28\x11\xb3\x6d\x51\xd6\x52\x31\x8a\x03\x77\x2a\x58\x61\xd5\xa2\xa9\x24\xb2\x65\x31\xab\xab\x03\xca\xa3\xbe\xa0\x95\x28\x75\xe1\x20\xaa\x02\xa3\x3c\x81\xc9\x22\x23\x8c\x25\x0a\xab\x3f\x2e\x40\x0d\xe6\xa4\x1c\x8b\xd0\x2f\x76\x75\xea\xb8\x85\xcf\xcd\x0c\x4d\x89\xc5\x0f\x3a\xff\x5c\xf0\x6c\xcb\x63\xbd\xeb\x3e\x3c\xfb\x51\xe4\xca\xd8\x73\xd9\x2f\xec\xdb\xd4\x0c\x7d\x17\x5b\x37\xc6\x68\x5c\xbb\x02\xb6\x28\x3b\xb4\x46\xca\xb9\xfa\x03\xcc\xe8\x99\x68\x5e\xdf\x22\x2f\x3d\x25\x76\x7d\xf3\xec\x3d\xa3\x27\x79\x0f\xac\x7b\x72\x4d\xab\x82\xf5\x39\x45\x29\x89\x86\xf5\xce\xb6\x66\x6d\xc9\x83\xb7\x12\xa5\x4d\x3b\xd9\x3b\xbd\xe9\xf5\x11\xdc\xcb\x84\xf6\xa2\x89\x66\x95\x1b\x8c\xb5\x7a\xd4\x84\xea\x22\x4d\x91\x26\xa8\x53\x68\xcd\xe6\x86\x6e\x62\xf7\x03\x48\xb8\xca\x45\x45\x4f\x6f\x14\xbc\x0a\xd9\x05\x68\xcc\xb7\x80\x35\x4c\x76\x44\x77\xa4\x94\x46\x24\xaf\x09\x32\xd2\x43\x08\xbe\x96\x7a\xfc\xb4\x73\x01\xfc\x85\xd0\xdc\x92\xed\x71\x47\x8c\xc3\x0a\xdf\x1d\xf4\x6c\xde\xda\x71\x37\x57\xa6\x4a\xf5\xef\x5e\x2e\x79\x7c\x5c\x97\xeb\x9f\x9a\x7e\xbc\x32\x7e\x01\x5a\xed\x9d\x3e\xcb\xbc\x75\x53\xc7\xe1\x0f\xd9\x6a\xaf\xda\xaa\x27\x76\xdc\x7f\xd0\xfc\x19\x3a\x20\x7d\x1f\xc7\x65\xe8\x27\x7e\x28\xbd\x2b\xef\xfd\xd0\x71\xd1\xf0\x7b\xd5\x8f\x66\x01\x18\x42\x9b\xa1\x87\xf1\x95\xf6\xf5\x37\xb9\x73\x7c\x11\x8d\x20\x02\xb2\x09\x97\x19\x17\xb4\xb7\x56\xe5\x38\x81\xbb\xd4\x3d\xd9\x8d\x81\xdb\xec\xbe\xe1\xc6\x3a\xec\xa6\x2c\x26\xc3\xe6\x28\x74\xbb\xe3\xe3\x63\x8e\x89\x29\xf1\x35\x43\x52\x32\x8f\x89\xa6\x96\xf5\x2d\x91\x1e\xb7\x0c\x92\x9f\x5a\xb6\x4c\x11\x04\xf3\x31\x11\x08\x35\x43\x40\x24\xf9\x8e\x6a\x78\xa9\x22\xbf\x6f\x96\x87\x20\xbb\x9e\x42\x23\xdf\xf1\x72\xf8\x21\x39\x8c\x8e\x8d\xf6\x32\x62\x51\xb2\xac\x2c\x68\x94\x43\x89\x56\x46\x33\x44\xc6\x42\x81\xd1\x81\x11\xd2\x37\x31\xb8\xdf\xc8\xf2\xc1\xcf\xcc\xba\x90\x33\x6a\xd9\xe3\x45\xed\x8b\x3a\x14\xb7\x19\xd0\xa6\xee\xa9\x3e\xfd\xb2\x56\x25\x6f\x29\x1b\x33\x76\xd8\xf3\x53\x07\x8f\xa8\x82\xf9\xad\xfb\xb7\x51\xd3\x19\x71\xfd\xe2\x39\xf3\x60\xc6\xd3\x7f\x0d\xb9\xbe\x47\x44\x83\x16\xcc\x95\xbe\xef\xb3\xf8\x51\xa8\x81\x89\x5b\x76\x6a\xe6\x3e\xf9\xe8\xfc\x85\x30\x71\xf3\xbc\x79\x3a\x5d\x8c\xfa\xa1\xb9\xd7\xeb\x96\x93\x11\x89\x20\x4f\x74\x2e\xc4\xaf\x27\xe3\xb2\x39\xe8\x16\x4c\xb4\x98\x52\x8c\xa6\x62\x51\x1f\x63\x34\xc6\xa4\xc4\x14\x8b\x29\x29\xf6\x66\x89\xc0\x9e\x58\x2c\x5a\x55\x76\x15\x28\x16\x31\x56\x45\x52\xdb\x8c\xbe\x5c\xb7\xca\xd1\xf8\xad\x61\x93\x22\x9c\xd0\x2a\x23\x91\x2e\x0c\x93\x63\xf7\xe4\x04\x54\x44\xf2\x2a\x82\x99\x0a\x5e\x13\xa4\x62\x04\x2a\xa6\x7a\x07\x84\xc6\xfb\x47\x26\xe5\x97\x5f\x1d\x3a\x86\x4f\xf6\x0f\x35\xf6\xec\x3c\x35\x7a\xdb\xbc\x01\x25\x33\xdf\x9e\x9b\xae\x09\xc0\x92\x56\xa9\xfe\x02\x67\x99\xb8\x71\x68\xaf\x8a\x09\xd2\xdb\x13\xc6\x39\x5a\xbd\x1d\xe5\xed\x16\xe3\x41\x3d\xd6\x6e\x9c\x54\x36\x43\xfa\xf9\xcb\xbc\x9b\x2d\x13\xbb\x76\xe2\xca\xf3\x7b\x57\xcc\x96\xf8\xac\x73\xbf\x51\x9b\x74\x2f\x39\xfd\xc8\xec\x24\x17\x68\x46\xda\x96\x1d\x8c\x31\x92\x56\x18\x8d\x11\x29\x11\xee\x62\x31\xc2\xa4\x23\x1c\x22\x25\x95\xf4\x70\x8a\x5a\xd6\xbd\xfc\xac\x51\x34\xa0\x57\x93\x97\x01\xd8\x04\xa9\x49\x44\xa0\xb7\xf9\x35\x34\xa8\x3d\xeb\x25\xda\x0c\x1b\x6b\x00\x52\xc2\xc8\x43\x1a\x6e\xab\x63\x27\x63\xec\xe6\x55\x50\x75\xba\x9b\xd9\xbe\xf5\x31\xe9\x36\x5c\xf6\xf2\xc0\x27\xc6\x96\x0f\xea\x5f\x3d\x20\x2e\x2e\xbb\x63\x5b\x8f\x3b\xd0\xa9\xad\x94\xec\x82\x87\x5d\x9c\x6b\xd0\xf3\x75\xdf\xf2\xf9\xb5\x5f\x54\x2c\xc6\xad\x6f\xbf\x0c\xd3\xbe\x59\x00\xdd\x6b\x26\x57\xcc\x90\x2e\xac\x42\x6d\x03\x69\x13\xa5\x5f\x7a\xe5\xa4\x8c\x87\x51\x75\x5f\x2d\x5f\x4e\xe8\xb7\x1b\x48\xe2\xae\x90\xf1\x68\x02\x31\x20\x19\x64\x80\xbc\x60\x42\x6c\x8b\xb7\xc4\xd8\xe6\xc1\xe6\x71\x6f\x89\xa0\xb9\xb9\x79\x5c\x73\x42\xbf\xcd\x4d\x7a\xdb\x5b\xa2\x1e\x7a\x3c\xa4\x8a\xb7\x44\x0e\x28\x3d\xc3\x98\x51\x83\xf1\x4c\x17\x16\x44\x20\xce\x17\x9f\x80\xb2\xd9\x24\x29\x67\x15\xcc\x80\x35\xc7\x0c\xfc\x99\x20\x91\xbe\xee\x64\x66\x81\xcf\x46\x6d\x02\xa2\x67\xe5\x70\x57\x56\x4b\x7f\x1d\x3a\x20\xfd\xf5\xf8\x6a\xa8\x39\x70\x00\x6a\x56\x0f\x95\xea\xbe\x7f\xf2\xd3\x99\xa0\xfe\x87\x1f\x20\x0a\x3d\xba\x10\xfa\x57\x3f\xf9\xf8\x82\x35\x25\xc5\xbb\x8e\x15\xf5\x43\x7f\x7d\x2b\xbd\xb4\x73\x17\xec\xf2\xdd\x37\xb0\x60\xf7\x2e\xe9\xe5\x6f\x61\x0b\xd8\xb5\x4a\xfa\xee\x2d\xe9\x23\xe9\x18\x2c\xfc\x54\x3a\x80\xf3\x16\x4c\x9a\xb9\x0a\x82\xfc\x42\xe9\x83\xfe\x94\xe7\x70\xb8\x3b\xf7\x16\x7f\x1e\x98\x81\x13\xe4\x04\xe3\xed\x36\xa3\xc5\x1e\x69\x7f\x4b\x84\x2a\x8d\x51\x85\x23\x81\x49\xef\xd1\x23\x13\xe7\xe1\x48\x56\xb5\x9e\xb3\xbd\x47\x5f\x42\x0d\x1b\x96\xe7\x50\x38\x2a\x6d\x96\x85\x68\xcc\x28\x99\xc0\xef\xb7\xd1\x78\x9b\x16\x48\xe7\xe6\xb3\xbd\x76\xae\x44\xf5\x96\xb8\x31\x7d\xcc\x53\x35\x86\xf6\x2b\x37\xd4\x0d\x98\xb4\x1b\xbe\x8d\xbb\x23\x60\x95\xac\x70\xe9\x3c\x09\xa0\x87\xa5\x74\xdf\x16\x38\x20\xb4\x10\x25\x86\x3e\x45\x89\x43\x87\xca\x36\x49\x5b\x1a\xf7\x87\xf0\x7e\xba\x42\xd2\xaa\x77\x3a\x35\xd1\x2e\x2a\x6e\x5d\x56\x40\x0c\x6b\xa0\x70\x79\x59\x28\xc9\x6e\x2a\x33\x81\x25\x02\x09\x39\x6d\xa1\xdd\x9b\xcd\xf4\x49\xa6\x36\x59\x1d\xe4\x96\xe8\xa2\x4c\x08\xa3\xf2\x7f\x43\xcf\xbe\xe7\x66\x34\x7f\x4b\x8a\x7d\x64\xf1\x9e\xed\x2f\xee\x5a\x52\x29\xc5\xbe\xd5\x7c\xc6\x73\xfb\xa0\x87\x1f\x2c\xbd\x22\xfd\x7c\x52\x3a\x3e\x5e\xf7\xd4\x57\x65\x50\xbd\xe7\xab\x7f\x5d\xff\x6c\xaf\xf4\x57\xd9\x57\x4f\xe9\x26\xc0\x6e\xaf\x10\x4d\xad\x33\xc1\x55\x49\xfd\x17\xdc\x12\xae\x90\xc8\x54\x0f\xe8\x70\x24\xc2\x60\xf1\x18\x6a\x60\x42\x50\x2f\x9a\x3c\x50\x87\x3d\x1e\xa0\x56\xc7\x90\x84\x23\xa2\xda\x0c\x2c\xe4\xe2\x90\x48\x27\x0c\x9a\xcc\xa3\x87\xb5\x1f\xc6\x9e\x90\x42\xd8\x56\xbb\xd7\xc2\xcc\x7c\xca\x95\x6c\x16\x3a\x07\x28\x58\xd0\xd4\x2d\x37\x2a\x1f\xf9\xf3\x89\x0d\x7f\x3c\x52\xf7\x46\xe6\x73\xfd\x97\x9e\xe8\x55\x58\xf6\xd9\x7a\xff\xb3\x03\x0f\xcf\x88\xaf\x82\xc2\xd3\xcf\x83\xfa\xc7\x57\x4b\xd2\x0e\xe9\xa9\x9c\x82\xf1\x0b\x52\x37\xcf\x41\x8f\x42\x7b\x76\xc7\x19\xd2\x8f\xb2\x4e\x67\xad\xaf\xe7\xfe\x62\xef\xf2\x74\xc0\x48\x74\xff\x07\x82\xcd\xad\x51\xc7\x44\xab\x95\x53\x27\xb5\x38\x26\x1a\x54\xc7\xc4\x98\x8c\xc8\x54\xbd\x41\x93\x67\x80\x91\xa9\xea\x24\x83\x21\x49\x9d\x1a\xc9\x23\x0d\xc6\x18\x51\xeb\x44\xd1\x04\xd2\xd3\x87\xc9\x72\x34\x57\xd1\x72\xd8\xca\x1b\x9f\x06\xd2\x50\xf8\x64\x94\xea\x88\x8d\xc4\xac\x81\xec\xa6\x93\x15\x90\x69\xb0\x84\xb3\x66\x37\xcc\x55\x20\xee\xaf\xda\x3f\x27\x70\xea\x50\x9e\xe5\x83\x8a\xf1\x70\x46\x69\xd1\xd3\xcb\xb7\xa2\xab\x5b\x2a\x2b\xc6\x8d\x46\x81\x82\x9e\xfd\x9d\x2d\x0a\x07\xf7\x58\xbb\xe8\xec\xe8\xc9\xf9\x0f\x74\x6d\xd7\xbb\xbd\x8f\xcf\xbf\xfd\x32\x9f\x1f\x8a\xbc\x7a\x15\xfd\x18\x8a\x44\xa2\xf4\x45\x68\xc2\xec\xe5\xc3\xca\x23\xdb\x06\xf3\x3b\xc5\x24\xc4\x38\xdc\x7d\xda\x4c\x5a\xb4\x4b\x67\xe4\x46\xe4\xe5\x34\x6f\x6e\x73\x35\x0f\x32\xfa\x29\x25\x08\x68\xc5\xb5\x01\x1a\x10\x1b\x34\xb1\x28\x11\x6a\x0c\x4c\x0d\x21\x22\x64\x4d\x34\x8d\x85\xb6\x56\x62\x43\xe0\xf9\x47\xde\x0f\xc1\x68\xd4\xa3\x43\xe8\xb3\x68\x94\xc0\xb5\xa9\x3d\xb7\x12\xe6\x3d\x4a\x6c\xe8\x0e\xf5\xbf\xf2\x80\xcf\x37\x27\xab\x7f\x94\xae\xb3\x5d\x8f\xbf\xdc\x20\xb6\xb4\xfa\x3a\xdc\x13\x3a\x42\x6d\x69\x5b\x54\xd8\xa7\x4b\xfd\xaf\x2c\x6f\x31\xc9\xfb\xd3\xfd\xf3\x7a\x1a\xf2\x82\x96\xf5\xff\xe6\x4e\xf0\xf9\x56\x5a\xee\x67\x72\xde\x9f\x68\xde\x1b\xb0\x47\xe8\x28\xd0\x1d\xe1\x30\x4a\x8b\x6a\xf4\xf1\x02\x5a\xb3\xfc\xc5\x24\xff\xf5\x7a\x8f\x9c\xbf\xee\xae\xfc\x5d\x9b\xe6\xef\xd3\x50\xfe\x2f\xf5\x5e\x39\xbf\xfa\xae\xfc\x6d\x9b\xe6\x77\x92\xfc\x1b\x59\xfe\x5f\xeb\xdb\xcb\xf9\x8f\xca\xf9\xd3\xc2\xf9\x9b\x35\xe4\x27\x38\x1e\x4a\x64\x58\x11\xd7\x8b\x68\xc9\xc9\x41\x9b\xd5\xea\xe0\x38\xe0\x70\x98\x8a\x44\x87\x19\xa8\x8b\xee\xa6\x7b\x36\xe7\x41\x25\x72\x40\x61\xdd\xca\xa4\x71\x72\x07\x24\x73\x76\x23\x84\x9f\x1e\x7d\xe7\xf5\xb1\x33\x1f\xd9\x37\x62\xf6\xec\xf1\xcf\x25\xbd\x12\xb7\xfe\xa3\x39\xe7\x2f\xf5\xdd\xf1\x43\xc4\xde\x27\x8c\xaa\x01\x15\x8f\xc1\x9c\x47\x97\xcc\x19\x3b\x41\x5f\xfa\xb4\x78\xee\xd4\x42\xe9\xeb\x0f\xc7\x31\x38\xd4\x60\x14\x77\x16\x75\xa1\x73\x73\x41\x0d\x06\x41\x1d\xd8\x2f\xaa\x75\x20\xfd\xa2\xcc\x75\x89\xc2\x17\xe9\xf0\x25\x25\x67\x13\xd9\x48\xd4\x3a\xfb\xf7\xb9\x1d\x0a\x17\xae\x59\xb3\xb0\xb0\x43\x2e\xfe\x1c\xa6\x74\x5e\xbc\xbe\x5b\x42\xb7\xf5\x8b\x3b\x0f\xa0\xef\x0c\x67\xd6\x9f\xc1\x03\xb8\x85\xa4\x2c\x3b\xb1\x78\x74\x40\x33\x09\x11\x35\x1d\xa4\x9f\x1d\x46\x37\xa1\x10\x7a\x51\x09\xb4\x9c\x48\x87\x3d\x89\x70\x3b\xd4\xb6\xf1\x69\xbc\xb5\xb1\xdc\x3a\xdf\x3d\x70\x69\xf4\x41\x83\x7e\xbf\x88\x0c\x20\xfd\x5d\x06\x17\x5d\x70\x99\x94\x4c\x4b\x62\x16\xb4\x37\x1b\x7f\xd7\xb4\x00\xb8\xb0\x09\x60\xf7\xc2\x85\x4a\x35\x50\xa3\x6a\x84\x2b\x31\x27\x40\xcb\x21\xad\x8c\x74\x58\xfc\xa8\xaa\xf1\xe1\x67\x9b\x36\xf7\x0e\x7c\x39\x40\x4c\x50\x6f\x54\xeb\xec\x48\xc6\x19\x41\x99\x8c\xb1\x4c\x33\x8d\x06\x74\x07\xd6\x9a\x40\xda\x04\x7f\x48\x6a\xbc\x6e\x82\xc9\x86\x0b\xf9\x3d\x6c\x18\x76\x07\xf0\x06\xcd\x0e\xbd\xb1\xd4\x0e\xed\x56\xa0\x0b\xa3\xf6\x02\x6b\x02\x3b\xdf\x85\xdf\x26\x6d\x6a\x82\xe9\x86\x8b\xa6\x18\x0f\xa1\xc6\x6b\xba\x96\x64\x66\x7d\x21\xab\x13\x13\x4d\x3a\x2b\xe8\x8a\x36\x5b\x41\x14\x34\xe1\xa8\xc8\x20\xc0\xfb\x45\x00\x22\x39\x93\x61\x92\x8a\x48\xb8\x70\xfd\x7e\xb9\xed\x17\x08\x7f\x66\x80\xf0\x5e\xbb\xd7\xf6\x37\xc0\xc0\x99\xf0\x2b\x29\xee\x8d\x7b\x21\xaa\x28\xe2\x06\xfd\x2d\x4c\x60\x4c\xfd\x77\xdc\x48\xfe\x0d\x32\x5e\x9a\x83\xf4\xa0\xd3\x63\x36\x1b\x0c\xf1\xc5\xa2\xc1\xc0\xc7\xc4\x44\x16\x89\x31\x80\x4f\x29\x12\xf9\xc8\xbb\x16\x48\x00\x79\x0e\x34\x42\x0b\xe5\x78\x9a\x6c\xbc\x38\xfc\xe1\x77\xcf\x34\x4c\xa4\x15\xcb\x2f\xf1\x94\x91\xc5\x8d\x1c\xba\xf3\xa7\xaa\xa3\x67\xfb\xad\x3a\x33\x63\xd4\xa6\x44\x8e\x5f\x5b\xd5\xee\xd1\xac\xe4\x79\x73\xde\xff\xf6\xaa\xfd\x91\xfe\x0f\x6e\x1f\x3b\x69\x54\xc9\x8e\x19\x78\xd7\x61\x69\xb1\xf4\xef\x15\x6f\x1f\x9b\x59\x7b\x78\xd4\xc8\x7e\x79\x39\x67\xdf\x4b\x4e\xa8\xee\x20\x5d\x0f\xfd\x29\x4e\xad\x94\xfe\x7a\x78\xda\x23\xeb\x59\x88\x2d\x02\x3b\x5d\xbf\x76\x9a\x7f\x98\xae\x31\x06\x19\x41\x57\xac\x0a\x9a\x54\xd0\xc0\xa9\x30\xe2\x34\x1c\x84\x9c\x06\xab\x81\x9a\x48\x66\x2b\x8b\xbf\xe3\xf0\xd3\x37\x91\x44\xa7\xa3\x16\x7e\xab\x0c\x7f\x36\x11\x10\x76\x88\xa1\x17\xea\xe1\xe7\x37\xe1\xb5\xd0\xf6\x32\xe9\x1d\x9c\x25\x9d\xab\xe2\x6e\xd4\x5a\xab\xb9\xdb\xd2\x4f\x75\xc7\x71\x37\xba\xdf\x4c\xca\xe5\xca\x88\xcc\x12\x80\xf9\x38\x8f\xe8\x1c\x3a\x47\xf7\x9b\xb1\x35\x99\x6c\xbd\x84\xd7\x82\x77\x85\x16\x9c\xc2\x7f\x49\xb9\xaa\xb1\x7f\x3d\x21\xe8\xff\x73\x93\xd2\x74\x34\x79\xee\x20\x79\x4e\x07\x9a\x05\x6d\x58\xe0\x84\x12\x51\x8d\x90\x86\xc3\x50\x03\x34\x04\x2e\x45\x21\x23\x5c\x3f\x2a\x3d\x6c\x06\x66\x6b\x20\xd1\x50\xbc\x1a\xe8\xb5\x47\xa3\xb9\xa1\xf5\x5c\xa7\xba\x43\xa8\x30\xf4\x22\x7e\x56\xca\x9d\x80\xe3\xb1\x6d\xec\x86\x50\x6c\x48\xd8\x40\xcb\x9f\x81\x4a\xb9\x41\xe8\x77\x65\xad\xec\x5e\x11\x1e\x96\xd7\xde\x92\x02\x66\xe0\x6b\xa8\x74\xed\x5a\x99\x87\x2a\xeb\x67\xcc\x2a\xe1\x17\x46\xfb\x57\xe1\x76\x24\xa1\x4b\x54\x06\x1f\x01\x90\xae\x05\x64\x52\xc7\xe6\xc7\xf0\x6a\x9b\x9f\xda\xc0\xed\x30\x4d\xfa\x88\x94\xdf\xab\xfe\x77\x6e\xbe\xaa\x1f\x19\x9b\xf6\xa0\x96\x47\xfb\x45\x9e\x17\xa2\x54\xac\xe9\x4c\x4e\xf1\x3e\x48\xd4\x29\x1b\xf4\xa3\x15\x63\xa5\xef\x8e\x41\xe3\xef\x70\xdf\xc3\x46\xec\x9c\x11\xea\xc5\x2f\xa3\xf1\x91\xc0\x79\x6e\x37\xbe\x02\x22\x40\x1c\x48\x03\x9d\x82\xcd\xec\x09\xc6\x84\xbd\xa2\xd3\xcb\x7b\xcd\x58\x6d\x35\x46\xa7\xaa\x53\xf7\x8a\x38\x4f\x5d\xa2\xae\x57\x63\x75\x30\xba\x79\xa1\x3a\x68\x8d\x2c\x54\x13\x78\xd2\x86\xf9\x95\x85\x0d\x44\xdc\x37\x4c\xd7\x52\x81\x8e\xc3\xa1\xf1\xfd\x99\x34\xd2\x75\x24\x0d\x6c\xab\x48\xf8\x24\x9e\xd1\x1c\x23\x39\x6e\xf7\xd6\x39\x27\x66\xb5\xde\xd2\x67\xc1\x96\x6d\x73\x8f\x4f\x5b\xbc\x6f\xe1\x46\xe9\xdd\xf6\xe5\x19\x2d\x46\x77\x2a\x1c\x3e\x5c\x2a\x6d\x5e\xde\xb9\xeb\xd0\xa1\xdd\x66\xa0\x5e\xcf\x7f\x0e\x5d\x0b\x9e\xf8\x70\xff\xee\x8f\xa5\xef\xa0\xfd\xa3\x3e\x0b\x16\x2f\x5a\xb4\x66\xda\xb8\xea\xdb\x8b\x16\xad\x9d\x3c\x6d\xa5\x2c\x57\xb2\x08\x0e\x37\x70\x6f\x12\x5a\x33\x1c\x65\xa8\xa0\x6b\xcc\x29\xb2\xfd\x74\x31\x60\xd6\x70\x4e\x55\xfb\x14\xf7\x66\xed\x93\xc3\x49\xde\xa7\xea\x25\x2e\x83\x53\x03\x1b\x30\x1d\xe3\x4d\x24\xaf\x8e\xe2\x8c\xe6\x76\x58\xd8\xcb\x27\x37\xb4\x13\xaa\x91\xd5\x41\xcb\x53\xd3\xdf\x5b\xbc\xe4\x83\x59\xe5\x67\xb7\x3e\x7b\x1a\x21\xf0\xc4\xaf\x95\x4b\x7f\x5f\x47\x94\x50\xf4\xea\xb7\xdf\xbc\x2e\xd1\xba\x7f\x92\x72\xf1\xd7\xfc\x35\x22\xbc\x48\x3f\x58\x49\x47\x5b\x05\xfd\x5e\x51\x00\xcc\xf0\xa2\x3d\x47\x8b\x61\xf3\x75\xd9\xa4\xe1\xd9\x16\x36\xd3\x69\x4f\xc2\x13\xfb\x8a\xfb\x9e\xeb\x1d\x68\x97\xbb\x6b\xdf\xf3\x03\x9b\xb7\xe2\x07\xcd\x9a\x5a\xdb\x62\xcf\x71\x5b\xb5\xf3\x07\xee\xbd\x3d\xc7\xac\xeb\xa2\xe5\x71\x34\x1e\x16\x71\xa5\xf8\x26\xe1\x85\x2d\xc0\x92\xe0\x80\x14\xdf\x5e\xd1\x65\x4a\xf1\xa4\xa4\xa7\x60\x2b\x4e\x09\x3a\x62\x0a\x53\xe8\x4c\x5b\x8a\x3b\x98\xe4\x76\x3b\xf7\x8a\x25\xc4\xda\x0f\x5a\xed\x85\xd4\x52\x46\x5a\xec\xd6\xf1\x7b\xa9\x11\xe5\xd1\xa5\xeb\xc8\x03\x3a\xfa\x80\x8e\x3e\xa0\x03\x41\x35\x00\xd6\xbd\x62\x1e\x7d\xa9\x2b\xbf\x84\x66\x26\x07\xb5\x86\x33\x29\xf0\x54\xf1\xbc\x3b\x99\x2d\x60\x4d\x66\x7c\x24\x9b\xea\xa1\x1e\x48\x7b\x37\x60\x37\x42\xcc\xce\xbe\xa6\xbf\xd2\x90\xeb\x43\xf3\xab\xba\x55\xf6\xcb\x9b\xda\x75\xea\xfa\x9e\xd5\x05\x26\xb1\x57\xec\xe2\xa9\xed\xa6\xe5\x93\xd3\x8c\xbe\xec\xa7\xce\xd3\x3b\x4e\xda\x30\xba\xb2\x7a\x20\xba\x95\xe6\x6a\x91\xe8\x7f\xbc\x5f\xf3\x28\xde\x6d\x1a\xbe\x3e\x35\x49\xba\x36\xb4\xba\x45\x62\x73\x57\x7a\x4a\xfa\x63\xfd\x5a\xfa\x23\x80\x3c\x47\x1e\xe0\x06\xf2\x66\xd2\x7f\x83\x83\x1d\xcc\x6a\x8d\x7a\xaf\x68\xd0\x65\x68\x8a\x34\xa5\x9a\xc9\x1a\xae\x88\x9c\x16\x69\x0e\x68\x2e\x6b\x78\x13\x91\x77\x58\x63\xe1\x39\x82\x00\x04\x3c\xdc\x42\xee\x19\x6e\x3f\x77\x8a\xe3\xf3\x38\xc8\x51\x4a\xa6\x36\xd7\xb0\x29\xfe\x73\x32\x29\xb3\x17\x10\xe7\x1a\xd6\x09\xf8\x6c\x74\xf4\x78\xb3\xe9\x6b\x5a\x42\x43\xe4\x80\x7f\x6c\xa8\x7a\xf2\x67\x18\x78\x55\xd2\xa1\xf6\x9b\xd6\x6c\x80\x76\xe9\xd9\x53\x28\x16\x0e\x92\xbe\x84\xde\x75\x70\xfc\x3a\x98\x20\x7d\xb6\x4e\x5a\xb7\x4e\x99\x13\x04\x37\xb9\x81\x5c\x91\xb2\xde\xad\x4d\x30\x91\x42\xaa\xd1\xf0\x90\xc2\xc3\x51\x8e\x30\x09\x3e\x03\xf7\xb3\x55\x0c\x7c\x11\x84\x74\x5d\x03\x82\x74\xf1\xd0\x30\x46\x39\x0d\xa6\x2d\xe5\x18\x50\x39\xa6\xe3\x6b\x75\xb1\xf2\x81\x5f\x59\xb7\x2e\xd4\x7a\xdd\x3a\x38\x8a\xd6\x88\xc0\x34\x32\x06\x06\x71\x97\xd8\xda\xab\x4e\xc1\x54\x81\xd4\x26\x40\xb6\x82\xeb\xb2\x0a\xa6\xab\xf2\x54\x97\x54\x58\x85\x0f\x20\x42\xc6\x6b\x10\x9c\x8c\xa0\x09\xf5\x46\x25\x88\x2e\x04\x26\x55\x0e\xf3\x93\xb3\xdf\xca\x56\x22\x2a\xb5\x42\xbb\x06\xda\x79\x99\x5d\xd5\x3d\x8f\x07\xd7\x45\x13\xb6\x35\xeb\x22\x5c\xb9\x49\x7a\x51\x7a\x71\xe3\xf5\x2a\x79\xbf\xdb\x74\x52\xef\x40\xa5\xde\x60\x30\x85\xd5\xab\xe2\x11\xc2\x07\xb8\xd3\x1c\x5a\xc3\xc1\xc9\x1c\x34\x71\xbd\xb9\x12\x0e\x73\xf0\x32\x8b\x6e\x0e\x2e\x29\xcb\xa4\x32\xe5\xaa\x1b\x6b\x0d\x50\x0e\x0b\x95\xa6\x0e\x26\xb5\xb2\xa6\x5e\xdf\x08\x07\xc1\x41\x9b\xa4\x19\x17\x43\x2b\x48\xad\x08\x3c\x4a\xea\xec\xc4\xb5\x25\x16\x8b\x86\xc6\xc2\x33\xa9\x3d\x6a\x64\xe0\x91\x9a\x68\x4b\x80\xdf\xcf\x78\x37\x45\x21\x20\x7d\x4a\x64\x89\x45\x03\x2d\x89\x5e\x72\x7e\x14\x7e\x06\x3f\xab\xdb\x8c\xad\xd2\x2c\x69\x16\x9a\x0b\x4f\x4b\xc1\x50\x65\x7f\x04\xe0\x54\x69\x35\xa3\xad\x69\xe0\x08\x37\x90\xf0\x6c\x1e\xb8\x82\x66\x4c\xba\xc8\x84\xf3\xf0\xaf\xc4\xb6\xc9\x63\x1b\x15\x86\xa5\x0f\x63\x52\xc5\x67\x23\xbd\xa1\xaa\x86\x94\x8d\x4b\xfd\x50\x07\xba\x7e\x0e\xb9\x43\x1b\x39\xa4\xda\x49\xe8\x52\x7f\xd8\xac\x63\x1c\xe8\x22\x5d\xef\x4d\x58\x89\x55\x7e\x53\xeb\x93\xf7\xe4\xd9\xd1\xfe\xaa\xed\xeb\x0b\x1e\xcc\xf4\x25\xa7\xc5\x46\x47\xfa\xd3\x42\x1b\x05\xf7\x0f\x50\xd3\xad\x75\x72\xab\x84\xb4\x84\x27\x5f\x90\x79\xda\xf9\xd0\x46\xb4\xff\x3e\xe5\xf9\x89\xd5\x1a\x66\xb1\x6c\x63\x5f\x36\x72\x57\x3d\x5f\xdd\xa4\x3c\xd5\xce\xff\x7c\xf3\xb3\x54\x7b\x67\x79\xf5\xb7\x50\x1a\x77\x05\xbd\x42\x30\xef\x3c\x8a\x08\x15\x42\x50\x03\xc1\x21\x11\xd6\x51\xf9\x2b\x6f\xc7\xc1\x04\xed\x5a\xee\x6b\x94\x56\x25\xef\xdd\xa1\x6d\x62\x30\x60\xaa\x8f\x22\x8c\x39\x1e\x49\xe0\x36\xa0\xef\x24\xa1\x12\xe5\x92\xa8\xb4\xee\xaa\x2a\xd5\xce\x5b\x37\x14\x1c\xd0\x3a\x78\x10\x1f\xd4\x72\x3c\xaf\x82\x02\x27\x01\xcc\x2a\x02\x75\xb2\x9a\x42\xea\x52\x96\x51\xd1\x75\xda\xe4\x69\x74\x22\xf4\x71\x15\x7a\xa5\xaa\x76\xa2\x0c\x27\xad\x33\x5c\x06\xe6\x38\x01\xa8\xb0\xd4\x14\xd8\xa6\x65\x60\xb6\x20\x5b\x8b\x4e\x54\x11\xa0\x6f\x7f\xce\xad\x55\xe0\xa6\x6d\x25\x70\xf3\xc0\x73\x1c\x11\x30\xb0\x80\x78\x52\xc0\x11\x11\xd5\x31\xf0\xd3\x1a\x81\x60\x12\x82\x34\x01\x35\x0b\x75\x55\xed\xac\xb3\x55\x29\xb8\x62\xed\x66\x30\x10\x5a\xa6\x30\xdc\x66\x45\x1c\xa2\x45\xdc\x0b\x83\x9f\xc0\xd0\x8c\xc2\x80\x7f\xae\x5d\xdc\x80\x3b\x06\x83\x00\x52\x82\x7a\xa4\x52\x09\x82\x1a\x6b\x54\xd2\x5d\x80\x34\x16\xd4\x08\x0d\x43\x29\x81\xe7\xe3\x2a\x06\x50\x53\xbc\xb0\xf2\x92\x83\x84\xd6\x55\x44\x11\x55\xf3\x12\xbe\x7d\x17\x6a\xc2\xc5\x35\x00\xe6\x63\xa0\xc9\xb0\xdd\xba\xc1\xad\x55\xca\x62\xfd\x24\x80\xd4\xa0\x91\x57\xa9\xd4\x48\x03\x49\x61\x74\x85\x7f\x13\xa2\xa0\xda\x0f\xa3\x8c\x86\x76\xda\x19\xb6\xb9\xaf\x69\x87\x11\x22\xa9\x9d\xc8\x10\xae\xd0\x16\x83\x8d\x96\x87\x90\x5a\x45\xca\xc3\xb7\x79\xf8\xbf\x28\xcf\x42\xdb\xcb\x30\xd7\x8c\xc1\xc7\xd0\x1f\x86\x8f\x94\xa7\x03\xd9\x41\x1b\xaf\xd1\x20\xad\x56\xaf\x32\x40\xbd\x86\xb4\x57\x2d\x03\x79\x58\xe4\x69\xa9\xca\x74\x76\x63\xb9\xfe\xa6\x45\x7b\x95\xd6\x33\x64\x86\x6b\x60\x50\xa3\xfa\x5b\x70\x16\x77\x05\x4f\x66\xfc\xb9\x65\x50\x2b\x50\xdd\x0f\x12\x2c\x70\xac\x7f\xf8\x50\x18\xf4\xda\xb0\x76\x0d\x1b\xd7\xe2\x2a\xdc\x98\x60\xa2\xd6\x43\xc6\xcb\x97\x55\x55\xd2\x06\x79\xcc\x20\x38\x36\xb4\x11\x8f\x64\x63\x46\x20\xbc\xc9\x88\xb0\x40\xf8\xae\x5a\x23\x20\x82\xde\xdb\x6c\x69\x34\x1d\x3c\x8d\x1d\xee\x63\xc7\xd8\xaa\x2a\x58\x21\x8f\x23\x8d\xb9\x71\x2c\x11\xf8\x34\x20\x37\x68\xe2\xd4\x6a\x8d\x46\xab\x53\xd1\x55\xb4\x12\x27\x30\x10\xb9\x50\x78\x64\xd5\x36\xae\x16\x90\xa1\x6c\xa0\x27\x82\x02\x7b\x93\x61\xc6\xf0\x80\x27\x57\x5d\xa9\xaa\x8b\xa7\xba\xe6\x58\x85\x0e\x34\xa0\x45\xd0\x20\xa8\x39\xac\xc6\x5a\xa0\x43\x2a\x8d\x8a\x14\x7c\x54\xd4\xd4\xa9\xb1\x24\x2f\x47\x01\x7e\x46\x57\xe1\x72\xed\xca\x3e\x08\x0b\x77\x45\x5a\x45\x8a\x63\xc3\x97\x5b\x5b\x3b\x91\xf7\x29\x38\x60\xb0\xf3\xa4\x07\xdb\x06\x8d\x1c\xaf\xd3\xf2\x5a\xbd\x41\x0d\xa1\x41\xa5\x21\x45\x1f\x17\x55\x21\x5d\x23\x67\x50\xe0\xf7\x87\x91\xdc\x58\x0f\x83\x5d\x39\x8f\xc5\x13\x42\x09\x04\x4b\x88\x27\x55\x92\x46\xdc\x7e\x89\x9b\x24\xb7\x43\x1e\x1b\x0c\x57\x81\xa0\x51\x40\x6a\xb5\x56\x47\x8c\x00\xad\x20\x85\x7b\xb3\x36\xdc\x9b\xa1\xfb\xa1\x4a\xee\xd2\x6c\xaf\xc2\x4c\x08\x92\x08\x43\x81\xb3\x48\xbb\x6e\xa7\xe0\x2f\xe4\xf2\xf1\x48\x86\xa7\x96\x41\xb3\x8c\x27\x1d\xd0\x12\xe4\xa8\xee\x1d\x31\x77\x20\x0a\x87\x37\x8c\x58\xb4\x78\x02\xc5\x93\xcc\xa5\xe4\x81\x83\xe4\x72\x1b\xf1\xa4\x12\x10\x14\xa0\xde\xa0\xe1\x38\xbd\x56\xc3\x20\xd7\x86\x58\x13\x8e\x92\x26\x08\x50\xee\x8b\x46\x62\x6c\xc4\x13\x35\x73\xb2\x21\x3d\x79\xf1\xc8\xaa\x50\x02\xe2\xab\xa4\x55\x88\xc7\x93\x6f\xa7\xf0\x05\xac\x15\x55\x8c\x27\x51\x9a\x27\xb4\x49\xf1\x64\xa0\x2c\x84\xd0\x94\x1a\x63\x9d\x4a\xae\x4c\x15\x0a\x73\xa7\xda\x06\xee\x94\x76\x17\x45\xb1\x61\x65\x6f\xe0\x99\x1f\x2b\x7c\xf3\x4d\xd2\x38\xd9\x76\x1f\xab\xf0\x02\x0d\xe1\x05\x3a\x35\xaf\x41\x3c\xd1\x42\xc9\x05\x29\xf8\x98\x88\xd4\x75\x2a\x65\x14\xa4\xdd\x41\x50\xf2\x68\x25\xd7\xe8\xfd\x2a\x38\xbd\xae\xba\xea\x0a\xe3\x7d\xdc\x82\x3a\x1b\xa5\x27\x05\x6e\x05\x4f\x88\x27\xe5\xa9\xf5\x06\x2d\xc6\x06\xb5\x8e\x41\xac\xae\x65\xa0\x1f\x15\x51\x48\xa9\xe0\xbe\x78\x62\xd5\x28\xe7\xb1\x55\xe8\xb3\xba\x6a\x32\xea\xe0\xf4\x50\xad\x6a\x67\x6d\x49\x15\x9f\x49\xda\xc1\xe8\x09\xce\x62\xbc\x96\xd1\x93\x46\x85\x90\x4e\xcb\xe8\xe9\xf6\x7f\x4d\x4f\x7e\x85\x9e\x9a\xc9\xf4\x84\x73\x6f\xbf\x2b\xf3\x4b\xc6\x23\x18\x3d\x11\xe9\x44\x8d\x3d\xa8\x55\x73\xb7\x49\x55\xb0\x51\xca\xdc\x4b\x4f\x50\x2e\x93\xfc\xe1\x91\x04\xf6\xe9\x32\x49\x51\xb6\x86\x7f\x96\x79\x1a\x2b\x57\xc1\x93\x5a\x47\x27\x72\x09\x3d\x41\x28\xd3\xd3\x71\x51\x5b\xab\xe2\x6e\x87\xeb\x08\xfd\xfd\xb8\xa3\xd5\x78\xfd\x32\x3d\xd5\x55\xa3\xcf\xaa\x24\xa1\x2a\x54\x0b\xa7\x93\x56\x70\xdb\xea\x72\xaa\xee\x94\x71\x3a\xd0\x81\xb4\x83\x70\x69\x9d\x8e\x8c\x72\xd2\x2b\x5a\xe9\x7f\x22\xa9\xbb\xf8\xd4\x1d\x64\xd5\x20\xfc\xc2\x02\xf0\x4d\x85\x5b\x35\xf0\x15\x26\x67\x74\xa0\x55\xd0\xa4\xd5\x09\x48\xa5\x53\xe9\xb1\x41\xa7\x08\x56\xd2\xff\x75\xea\xc6\xfe\x6f\xc0\xdd\x1d\xd2\x95\x29\x2d\x94\xcc\x08\x1f\xa1\x7c\x5b\x91\xb2\x8c\xef\xe2\x86\x3a\xe8\x5e\x76\x13\xe8\x1a\xb4\x18\x79\xde\x02\xa0\x49\xa3\xd1\xab\xa1\xda\x6c\xd1\x9b\x58\x7b\xf4\xb5\x8c\x0d\x07\x35\x84\x0f\x6b\xd1\x6d\x0d\x90\x18\x55\x87\x67\x62\xa0\x52\x6b\x58\x64\x40\xfa\x9e\x43\x16\x48\x32\xf5\xd5\x56\x55\x5d\x61\x9c\x8c\x91\x5f\x68\xa3\xc6\x4c\x08\xb0\x2e\x5e\x63\x66\x24\xd8\x44\xde\xeb\x40\xbb\xa0\x45\x43\x91\xab\x37\x10\x22\x24\x32\xf0\x7f\x26\xc3\xa6\x74\x78\x07\x21\xfa\x1a\x48\x31\x4c\x8b\xb7\x6e\x10\xee\xd6\xc0\x87\x1a\xf0\x6a\x25\xda\x85\x4e\xab\xd2\x1a\x80\x5e\xc7\x4b\xea\x7b\x54\x0c\x7f\x53\x9a\x6c\xa2\x67\x50\xbc\x6a\x09\x4d\x32\x49\xd6\xa0\x6f\x70\x0b\x08\x5a\x01\x6e\xa8\xa3\x01\xaf\x2a\xad\x56\xa3\xc3\x48\x87\xcc\x16\x83\x20\x98\x8d\x06\xd6\x26\x63\x48\xad\xe0\x55\x5d\xab\x6b\x94\x99\xf7\x19\xce\x4d\x05\x28\xb5\xd3\x18\xf7\x23\xfd\x4a\xfb\x94\x92\x6a\x15\x63\x81\xb2\x44\x25\x14\x2b\x33\x41\x24\xeb\x16\x84\xe7\xd2\xb6\x06\x83\x26\xa2\xfd\x18\xf4\x58\xa7\x33\xa8\x29\x6e\xd5\x72\xd5\x9a\xda\xa6\xca\x50\x28\x3c\x14\x9b\x28\x01\x96\x3b\x75\x22\x45\x1b\x20\x14\x1b\xfa\x98\xfb\x9a\xa0\x97\x74\x25\xfe\x82\xe2\x01\x34\xd5\xb7\x74\x20\x2b\x68\xd3\x68\x55\xbc\x96\x27\x44\x0b\xf4\x5a\x82\xde\x7b\x94\x2e\x65\xcc\x5b\xee\x90\x22\x0d\x02\x97\xd4\x22\x4b\x5c\x45\xff\x52\x74\x30\xdc\xd0\x2e\x9e\xed\xae\xea\x16\xb4\x02\xa8\xd3\x42\xad\xc5\x6c\x50\xab\x2d\x46\x8c\xcd\x26\x23\x63\xc1\xa6\x5a\x0d\xe6\x30\xbb\x54\x71\x21\x9d\x42\xb7\xe1\xd5\xbb\x4d\xda\x97\xdb\x40\xb9\x04\xaf\x7e\x79\xe4\xd8\x89\x94\xa9\x65\x78\x95\x89\x17\xf1\xb5\x1e\xd2\xaf\x5f\xd0\xf6\xf2\x57\xaa\xaa\xc2\x7a\x95\x42\x4b\x14\xbf\x08\x19\xf4\x3a\x41\xb8\x13\xbf\xa1\xa6\xca\x61\xed\xff\x88\x5f\x36\x5e\x18\x7e\x99\x22\xa7\x28\x5c\x38\x97\x8c\x13\x45\xe9\x6a\xd4\x3f\x19\x7e\x09\xf5\x6a\x90\x46\xaf\x23\xf8\x15\xf0\x6d\xcd\x3d\x4a\xe8\x7d\xf1\xab\xd4\x4a\x6a\x61\x4c\x15\x4e\x6f\x60\xab\xb2\x4e\x8a\x1b\xda\xd5\x80\x5f\xb5\x8e\x27\xc4\x6b\x31\x9b\x38\xce\xa2\xd7\x68\xcc\x74\x0f\x1b\x41\xaa\x21\xc4\x6b\x18\xb3\x25\xd2\x8e\x70\xdb\x06\x69\xf7\xb7\xf8\x6d\x90\x49\xd9\x5e\xda\x4c\xc6\x99\x42\xb5\x0a\x11\x4b\xab\xb8\xaf\x19\x13\xc4\xef\x10\x1a\x26\x4c\xb8\xaa\xa9\x7e\x6c\x03\x03\x82\x2e\x83\xc6\x62\x51\x21\xab\xd5\x1e\x61\xd2\x6a\xed\x80\xe7\x23\x2c\x84\x45\xe8\x39\xc6\x24\x8e\x8b\x1a\xbe\xd6\x1c\x56\x99\x0d\x94\x96\x1b\x57\x80\x34\x6a\xce\x96\x46\x96\x71\x97\xf8\x6a\x60\xcb\x0d\xdc\xa3\x81\x39\x2b\x5c\x44\xe1\xd0\x8c\x95\xdc\x01\x5b\xb7\x60\xa4\x55\xab\x35\xe9\x6c\x02\x63\xd3\x11\x9c\xdd\x10\xa1\xe1\x0d\x6c\xa0\x07\x75\xa2\x15\x19\xeb\x08\xdf\x36\x87\x47\x78\x78\xe5\x50\x43\xd7\xf8\x9b\x8e\xf2\xc6\x11\xa0\x88\xc0\x30\x07\xbf\x42\xc8\x91\xf6\x99\xc2\xc5\xe5\x11\xc1\xfa\x4e\x5e\xf3\x1e\x86\x87\x67\x91\xf3\x1d\xa0\x2c\xe8\x8a\x50\xa9\x1c\x02\x6f\xb1\x20\xb3\x60\x8e\x72\x62\xa3\x31\xca\xae\xd1\x38\x79\x7b\xa4\x9d\x61\x0c\x45\xd6\x9a\xe4\x2e\x0c\x6a\x45\xbd\x36\x64\x51\x49\xd6\x06\x20\x9b\x20\xef\xae\xce\xbc\x1b\x5c\xdc\x74\xe0\xf8\x15\xe6\x44\xbb\xf6\x4a\x93\x01\xa4\x74\x33\xeb\xe2\xdb\x2f\xc9\x03\x89\xb1\x2b\x79\xaf\x05\x9a\xc6\x5d\x64\x3c\xd3\x7a\x0c\x10\x9b\x1d\xdd\x06\x20\x3d\x4f\xb1\xd6\xa1\xd7\xe2\xe5\x2e\xd6\xfa\xb9\x8b\x24\x57\x8e\x9c\x9f\xb4\x95\xdc\x35\xe6\xa7\xa3\x3b\xfd\x9e\xfc\x24\xd7\x27\x8d\xf9\x59\xf9\xb6\xe3\x4a\xf9\x12\xc8\xbb\xb7\x02\x2a\x9e\x94\xfc\xa8\x3c\x9c\x1f\xde\x2f\x3f\x2a\xa7\x59\x94\xfc\x68\x74\x43\xf9\x96\x63\x10\xf0\x8d\xd9\x33\xc3\xa5\x37\xe6\x06\xd4\x1f\x5e\xa8\x96\x2b\x57\x6c\x27\x1d\x8b\x6a\xe9\x68\xd8\x97\x91\x06\xd2\x81\x1f\x04\x40\x5b\x90\x07\x3a\x83\xae\xa0\x07\xe8\x0d\xfa\x82\x81\x60\x08\x28\x01\x23\x41\x39\x18\x07\x26\x81\x69\x60\x16\x98\x0b\x16\x82\x25\x60\x19\x58\x09\xd6\xc0\x77\x82\x63\x8d\x49\x05\x03\xe6\xf0\x13\x27\x9a\x92\xbb\x0e\x9c\xcb\x4f\x52\xb9\x73\x7a\x3d\xca\x8f\x1e\x2d\x78\x02\xbd\x57\xf2\xe5\xd6\xd4\x0e\x83\x17\xf0\x53\xa7\xda\xd2\xf2\x86\x2c\xe4\xa7\x69\xe3\xdb\x74\x5f\xcd\x97\x95\xe9\x7c\x6d\x7b\xac\xe1\x47\x8e\x9c\x56\x3e\x89\x1b\x37\x0b\xb9\x32\xfb\x3c\xc2\x8f\x1d\x8b\xa3\xfd\x7d\x97\xf1\xe3\xc6\x3d\xee\x48\xef\x5c\xb2\x84\x9f\x15\xd9\xb2\xd3\xf0\xc5\xfc\xac\x99\x33\xab\xca\x47\x8e\xab\x18\x57\x03\x39\xc2\xda\x46\x95\x56\x94\x0c\x19\xd8\x6f\xa0\x7c\x37\x74\x50\xbf\xde\x3d\xfa\x16\xf5\x95\xef\x1e\x28\x2c\xea\x9c\xd7\xb5\x4b\x57\xf9\x2e\xd8\xae\x4b\xdb\x80\x3f\xc3\x2f\xdf\xb5\xce\xca\x48\x4f\x4b\x4e\x48\x96\xef\x9a\x37\x4b\xf0\x79\xa2\x9d\xd1\xf2\x5d\x5c\x8c\xd3\x61\x33\x51\xc5\x83\xde\x45\x98\x09\x3f\xc5\xd4\x76\xa2\x77\x44\x7e\x2c\x59\x38\x77\xf6\x5c\x7a\xe7\x11\x17\xcd\x9b\x5d\xd1\xaf\xa8\x4b\x46\x82\x53\x0f\x66\xcf\x06\x7a\x67\x42\x46\x97\xa2\x7e\x15\xda\xa5\xd3\x27\x8f\x9f\x34\x5e\x7e\x62\xd6\xb4\x49\x6b\x56\x2e\x5b\xba\x8c\xdc\x1d\x11\x57\x2d\x5f\x7a\x1b\x84\x87\x9e\x33\xbc\xa2\xd9\xaa\x6c\x0c\x93\x3f\x77\xaf\xe9\xfb\x3f\xfe\xa6\xe4\xe2\x50\xf6\x67\x3a\xfc\xec\x82\xbe\x47\x50\x2e\xef\xf7\xd5\x2a\x83\xee\xde\x4c\x54\x0e\xfe\xbf\xbc\x16\xfe\x26\xdd\xf1\x37\x79\x9a\xa6\xc3\xbf\xb9\x2e\x2f\x87\x9b\xe4\x23\xb4\x71\xf4\x68\xb8\x49\x3e\x6a\xeb\xff\xd7\xe9\x17\xe5\xa4\xba\x0b\xa3\x47\xa3\xf2\xf2\x72\x69\xb4\x7c\x5c\x6c\xcc\x7d\xf1\xbe\xa9\xf4\x81\xfb\x95\xc7\x37\x2b\xa3\x9f\x11\xa5\x8d\x9f\x91\xf7\x5e\x8f\xa0\x9f\xb2\xe1\xf4\x53\xc6\xae\xe5\x64\xe1\x67\xf6\x30\xf4\xb1\x3b\x40\xe3\xf9\x91\x31\xf8\xee\xff\xbd\x31\x08\xaa\xc1\x93\x60\x33\x78\x06\x3c\x07\x5e\x00\xbb\xc1\x7e\x70\x18\x1c\x07\x2f\x83\x53\xe0\x0c\x78\x13\x9c\x07\x97\xc0\x07\xe0\x0a\xf8\x14\x7c\x09\xae\x81\xef\xc1\x4f\xe0\x57\xf0\x07\xf8\x13\xd4\x82\x7a\x88\x89\x29\xac\x83\x26\x68\x83\x0e\x18\x0d\x3d\x58\x77\x18\x65\x96\x3d\x5f\x03\xb5\xc7\xf8\x7f\xfc\x03\xfb\x47\xbe\x50\x03\x75\x41\x3b\x7f\xc5\xdd\x6b\xf5\xbe\x5b\xfc\x17\x5f\x78\x7a\xaf\xd9\xff\x27\xff\xa5\x2a\x67\xf4\xb3\x35\xd0\x78\x8c\x7f\xff\x7d\x21\x50\xfe\x5c\x0d\x34\x91\x4c\x1f\xc4\xf7\x59\x70\xe8\x36\xff\xcd\x37\xbe\xbe\x0b\x0f\xd7\xf2\xd7\xb4\x6d\xc6\x6e\xa9\x81\xd6\x63\xfc\xbb\xef\xea\xda\x8e\x7b\xa6\x06\xda\x48\xa6\x4b\x49\x03\x16\x1f\x93\xf8\x7f\xfe\x33\x79\xe0\x92\xe3\xf5\xfc\xf7\xc6\x0e\x13\x37\xd5\xc0\xc8\x63\xfc\x3b\xef\x98\xf2\x26\x6d\xae\x81\x8e\xa3\xfc\xf9\xd4\xc1\x8f\xbc\x54\x03\xd1\x31\xfe\xc7\x1f\xd3\x86\x2c\x7b\xb9\x06\xe2\xa3\xfc\x4f\xd6\x4e\x53\x9f\xa8\x81\xae\x63\xfc\xb9\x73\xb6\xce\xd3\x9e\xac\x81\xd1\x47\xf9\x37\x5b\x0e\x7f\xf4\xd5\x1a\xa8\x3a\xc6\xff\xf2\x4b\x7a\xc9\xca\x53\x35\x50\x08\x7a\xf8\x5f\x7f\x7d\xf3\xa7\xf3\xdf\x5f\xba\xf6\xc1\x97\x57\xb4\x9f\x9e\x71\x75\x9f\xb3\xeb\x77\xfe\x93\x4f\xa2\x7b\xcc\xdd\xfd\x07\xff\xe9\xa7\x35\x30\xee\xb0\xa3\xeb\xac\xea\x1a\xe8\x39\xca\x9f\x89\x2c\x98\xb9\xb6\x06\xba\x0f\xf3\x67\x5e\x7f\xbd\x06\x7a\x83\x9a\x33\x6f\x9e\xbf\xf4\x01\x7f\xe5\xc3\x2b\x74\x1c\x5b\xc4\xd3\x67\xdf\xba\x70\x99\xff\x70\xff\xe1\xe3\x2f\x9f\xe2\x77\xbf\xb8\x5b\x4e\xdd\x73\xe0\x48\xcd\x2b\xfc\x8b\xd5\x4f\x6e\x7e\xe6\x39\xfe\x85\xed\x2f\xc8\xa9\x8f\xaf\xdb\xf0\xd4\x56\x7e\xfb\xc2\x25\xcb\x56\xae\xe1\x15\x6e\x61\x11\xe7\x2d\x5a\xba\x7c\x15\x3f\xbb\x7c\xdc\xa4\x69\xb3\xf8\x91\xa5\x23\xe5\xd4\x51\x15\xe3\x27\x4f\xe7\x4b\x7b\xf7\x1d\x38\xa4\x84\xef\x51\xd8\x43\x4e\x7d\xa0\xa8\xdf\xa0\xa1\x7c\x61\xa0\x6d\x5e\xe7\xae\xbc\xc2\xb5\x2c\x62\x56\xeb\x76\xc1\x2e\x7c\x86\xc7\x97\x9c\x96\xce\x2b\xfc\xca\x22\xc6\xc4\x25\x34\x6b\xce\x3b\x05\x9d\xc9\xe6\xe0\x15\x4e\xa5\x13\x39\xb5\xde\x1c\xc1\x83\x3f\x6b\xeb\x4f\xd0\xce\x3d\xcc\xff\x71\xe3\x0f\xf2\xcb\x61\xf1\xe6\x7f\xea\x4e\x40\x40\xf2\x38\xf8\x1b\x1f\xbe\xb8\x7d\x76\x69\x61\x86\x13\xdc\xb8\x01\x9c\x19\x85\xa5\xb3\xb7\xbf\xf8\xa1\xb6\x06\xaa\x83\x9a\xcf\xbe\xfa\xf6\x5f\xd7\xf9\x8f\x3f\xfd\x98\x3c\x73\x5c\xfc\xf2\xda\xf7\x3f\xfd\xca\x7f\xda\xd1\xd6\x48\x21\x44\x80\xe9\xa0\x9a\x1c\x1c\x10\xa1\x1e\x9a\x61\x04\x74\xc2\x18\x40\xdd\xdb\xdc\x06\x61\x0f\x08\xd4\xfd\x01\xbb\xb8\x8b\xc5\x85\x1d\x24\xfc\xdf\xfa\xfe\xef\x59\xdc\xff\xfe\x17\x7d\xaf\x69\xf7\x05\xee\x73\xf0\xff\x0f\xd2\x13\xef\x4a\x0b\x33\xd5\xe4\xfb\x1c\xc2\xdf\x94\xe3\xf8\x2f\xf3\xc3\xff\x32\x9d\x32\xce\x3b\xff\x6b\x09\x33\xbe\x78\xe7\x7f\xdd\x83\xff\x07\xb9\x18\x9b\x6e\xc8\x43\x38\x33\xde\x74\x4f\xbe\xd1\xf7\x14\x76\x2f\x5c\xf7\xe6\xa9\xad\xff\xdf\x81\x41\x61\xfa\x65\xf7\xb0\xfe\xd2\xbf\x11\x03\x7f\x9b\x3e\xa2\xf1\x23\x8b\x87\xe1\x4d\x84\xc4\x88\x26\xa2\xe2\x0e\x81\x51\xd6\x54\x6c\xc8\x1f\x1a\x13\x92\xe8\x7b\x54\x76\xe4\x83\x6e\xa0\x27\x28\x06\xfd\x81\x08\x86\x81\x11\xe0\x41\x30\x06\x4c\x00\x53\xc0\x0c\xf0\x10\x98\x0f\x1e\x06\x95\x60\x05\x78\x0c\x54\x81\xf5\x60\x23\x78\x1a\x6c\x03\x3b\xc0\x4e\xb0\x17\x1c\x04\x47\xc1\x09\x70\x12\xbc\x06\xde\x00\x6f\x83\x8b\xe0\x3d\xf0\x11\xb8\x0a\x3e\x07\x5f\x83\xef\xc0\x0f\xe0\x67\xf0\x1b\xf8\x37\xf8\x0b\x84\x20\x84\x3c\xd4\x40\x03\xb4\x40\x3b\x8c\x82\xb1\xd0\x8b\x2d\xc1\x71\xae\x51\xb3\x77\x7c\xcb\xbf\xf1\x86\xc2\x74\x7a\x8c\xab\xda\x7d\x83\x3f\x7f\xbe\xb0\x62\xf9\x8b\xff\xe6\xdf\x72\x97\xce\xdd\xf6\x15\xff\xda\x6b\xd1\x0f\x3e\xf4\xec\x77\xfc\xeb\xbd\x27\xad\xdc\x7f\x9d\xbf\x74\xe9\x81\xf1\xab\xf7\xfc\xc6\x5f\x88\x1f\xba\xf0\xe9\xcf\xf8\x93\x27\x3d\x23\xe6\x6d\xf9\x9a\x7f\xb5\xef\xb4\xea\xc3\xff\xe2\x3f\xf8\xa0\x68\xf2\xaa\x03\x3f\xf3\x97\x93\x06\x2d\xd9\xf8\x31\x7f\xe2\x84\x6f\xd8\xa2\x4d\x9f\xf3\x2f\xfd\x59\x7f\x92\x48\x26\x13\x8c\x23\x9c\xc5\x01\x1d\x41\x4d\xbf\xe9\xeb\x8e\xfc\xc0\x7f\x98\x5a\x77\x92\xb0\x35\x03\xe3\x38\x76\x68\x0f\x9a\x93\xc5\xa5\x4f\x5c\xe5\x8f\x65\x50\x1e\xc9\x77\xe9\xf2\x9f\x57\x09\x8f\x53\x13\xb6\xe4\x25\x19\x9c\xd0\x19\xd4\x1d\xfb\xf0\xa5\xcb\xaf\x5e\x78\xfd\x2d\xac\x85\x44\x18\x05\xcd\x5d\xcb\x97\xbd\x70\x93\x7f\xf3\x4d\x5e\x63\xb0\xd8\x89\xd9\x5a\x03\xe3\x83\xba\x96\x99\x39\x6d\x3a\x74\x52\x01\x90\x16\x7a\x15\x72\x50\x0b\x63\xc9\xe3\x56\xf2\xe7\x0b\xea\x15\x3e\x1b\xd9\xf9\x9d\x77\xdf\x27\x92\xea\x30\x7f\x0e\x9d\x63\x5a\xdd\x89\x93\xaf\xbd\x51\x03\xed\x47\x79\x54\xf3\xca\xe9\xb3\x35\x30\xe2\x30\xcf\xbf\xc0\xb3\x9f\x82\xbb\xf7\x1f\x26\x42\xf1\x28\xff\x42\xde\xae\x7d\x87\x88\xa4\x3c\xcc\x3f\xaf\x7a\x9e\xfd\xb4\xf1\xe9\x6d\x3b\x6a\xa0\xe1\x28\xaf\x22\xc2\x62\x7b\x0d\xd4\x1f\xe6\x35\xcb\x34\xec\xa7\x76\x2b\xab\x88\x54\x12\x8e\xf2\xcb\xda\x3e\xfa\x38\x91\x4a\xaa\xc3\xfc\x23\xda\x47\xd8\x4f\xb3\xe7\x2e\x5c\xc2\xc4\xa0\x76\xd6\x9c\x05\x8b\x89\x6c\x3c\xcc\x1b\xca\x0d\xb2\x20\x68\x4d\x24\x4b\x3d\x5f\x1e\x18\x3b\x71\xaa\xc4\x8f\x36\x8e\x96\x53\x07\x0d\x2d\x1d\x55\xc7\x1b\x89\x78\x19\x59\xcb\x5b\xba\x5a\x14\x51\xd2\xa3\x77\xdf\x3f\xf9\xae\xfe\xee\xbd\xfa\xdc\xe2\x0b\xac\x05\xac\xf0\x8f\x09\xd7\xaf\x81\x31\x47\x79\xeb\x95\x4f\xbf\xbc\x46\x04\xeb\x61\xde\x7e\xd3\xce\x7e\xca\xf8\xd7\xf5\x1b\x44\x60\x06\x63\xf8\x9b\xe8\x05\xd5\x32\x6d\xb9\xb1\xab\xf5\xe6\x4d\x6b\x57\x63\xb9\x76\x99\xea\x05\xa4\x8d\xec\x42\xa4\x25\x11\xda\x87\xf9\x37\xe1\x9b\xe4\x89\x63\x22\x94\xd2\x89\xd0\x20\xc2\x95\x88\x9e\xc8\x3f\x98\x18\x71\xb9\xe3\x93\x52\xf9\x48\x90\xde\xe0\x15\xec\xff\x81\x70\x70\x9a\xcf\x39\x32\x65\x07\x25\xff\xbf\x49\x08\x62\x5d\xf9\xb3\x7d\xf7\x39\xfc\xf6\xfb\x1d\x3e\xbb\xdf\x72\x9f\x03\xde\x95\xd1\x41\xd2\x92\x9b\x1c\xc2\x5d\xbf\xf3\x24\x2d\xd0\xf4\x9e\x1c\x5e\x72\x08\xd9\x3e\x7b\x22\xf9\xb6\x91\x6f\x5f\x93\xe3\xee\xe7\xff\x97\xbf\xdf\x55\x3f\xbc\xfb\x5e\x81\x91\x3e\x17\x0b\x49\xbd\x4a\x99\x77\x7c\x93\xdf\x31\x39\xb8\x77\x6b\x33\x47\x37\x7e\xca\x1b\xff\x9a\x7e\x6a\x37\x84\x93\x9b\xb2\x64\x25\x2d\x54\x1f\x7e\xae\xee\x42\x39\xf4\x13\xbe\x4c\xf4\xf1\x86\xa2\x1a\x1e\xbc\xfb\xbe\xb1\x20\x04\x9b\xb0\x74\x74\x91\xfd\x56\x4e\xff\x69\x6e\x76\xd0\x73\x68\x23\x8c\x1f\x41\xff\x7d\xa5\xd0\x5b\xc6\xfe\x9b\xb0\xdd\xd7\xca\xa4\x2f\x4b\xa5\xcf\xe5\xff\xe1\xe4\xac\x1a\x1b\xfe\xe9\xf4\xdd\xf2\xe1\x74\xf8\xe2\x4c\xe3\xf3\xd2\x97\xf7\xb0\xff\xc6\xa4\x86\x5c\xaa\x8b\x61\x96\x1f\xaf\x5c\x90\x5a\x49\x05\x23\x58\xa1\x67\xe4\x62\xca\xe4\x47\xe5\xec\x24\x23\x9b\x63\x98\x05\x66\x70\x03\xb8\x7e\xb2\xff\x4f\x1e\xdc\xe9\xff\xd3\x6b\xf1\xce\xc2\x5f\xd6\x79\xb9\x7e\x75\x5e\xea\x06\x0d\x00\xee\x3c\xf7\x36\xb3\x3d\x5c\x07\x31\x4f\xb9\x09\x75\xcb\x42\xbe\x0f\x36\xac\xea\x90\x1f\xb3\x59\xbc\x16\xc4\xbd\x5d\x1b\x78\x80\x6b\x45\xbf\xb8\xf9\xb5\x97\xb8\x56\x00\xc2\x0a\xb8\x10\x8f\xc2\x73\x49\x19\xea\x83\xa4\x40\xe6\x73\x8f\xfa\x4e\x1a\x25\x71\xb0\x0e\x2e\x84\x75\x00\x35\xc9\x23\x80\x94\x83\x40\x20\xe5\x07\x0d\xa4\x02\x33\x40\x1a\x0c\x50\x10\xa9\x58\x8d\x08\x34\x2e\xf1\x4c\x53\x8a\xa1\xcb\x09\x59\x51\x0f\x48\x4f\xd1\xd2\xa4\x22\x58\x26\x6d\x61\x6b\x64\x0b\xb8\x37\x50\xfc\xdf\xb6\x53\xcd\x9d\xac\xed\x8c\xe2\xa5\x04\x92\xd7\x04\x32\xb9\x93\xdc\x3e\x02\x9e\xfd\x38\xf5\x89\x0a\x68\xdc\x5d\x25\xb7\x25\xb7\x55\x46\x40\x03\x4d\x68\x10\x1a\x90\xc9\xcd\xab\x5d\x4a\xd7\xb7\xd5\x7f\x47\xf0\xb2\x87\xe4\x27\x65\x73\xd4\x79\x5f\x93\xb2\x35\x30\x8b\x7b\xb2\x76\x0c\xb7\x27\xb4\x25\xb4\x59\x5e\x3b\x62\x22\xf9\x4f\x72\x23\x94\xf2\x09\x2c\x77\x95\xaf\x41\xdc\xc9\xd0\xae\xd0\x8b\xdc\x88\xda\xa5\xdc\x3c\xf9\x19\x44\x9e\xd9\xa8\xd4\x71\xe7\x13\xf4\xfd\x22\xe4\x36\xd2\x2a\x6a\x73\xd1\x83\xca\x5a\x23\x91\xdf\x0a\x78\xf6\xe6\xd8\x81\x78\x0d\x16\x04\xac\xc6\xaa\x03\xa2\x09\x43\x0d\xc6\x50\x7d\x40\x84\x72\x7f\x85\xb7\x2f\xb4\x67\x8e\xc7\xbc\x3e\x0d\xf4\x6b\x38\xb4\xba\x8f\x14\x80\x6f\xf7\x81\xe7\x25\xa3\xb4\x05\x96\xc1\x52\x74\x09\xbd\x17\x6a\x85\xb2\x43\xe7\x43\xaf\xa3\x0e\xa4\x8e\xe7\xc0\xb3\x5c\x2a\x97\x42\x70\xe5\x01\x19\x41\xad\x53\xad\x36\x03\x10\xe7\xd5\x47\x90\xae\x39\x2a\xea\xf5\x1c\x17\xc3\x3a\xa9\x61\xe7\x4c\x9a\xbc\x28\x45\x46\x4a\x78\x25\x5f\x04\x5d\x92\xd6\x12\x06\x22\xe8\x32\x35\xea\x77\x84\xae\x41\x34\xc2\xe7\x66\xbf\xf7\xd0\x9c\xf7\x1f\x7a\xe8\xbd\xb9\x73\x2e\xcf\x1e\x50\xf6\xc2\xc8\xb2\x9d\xa3\xca\x76\x97\x8d\xd8\x59\x86\x46\xd1\xf4\x0f\xc8\x4f\xb3\x67\x5f\x9e\x53\xb6\x73\x44\xe9\xae\x32\xf2\x4b\xd9\x4e\x4a\x1d\x15\x60\x00\xf7\x20\xd7\x87\x7a\x9b\x63\xfb\x39\x92\x89\x3d\x1c\x20\xb6\x70\x57\x62\x07\x0f\x24\x36\x70\x39\xb1\x7f\x67\x11\xdb\x77\x6d\xb0\x6f\xd9\xe8\x62\xd1\xd8\x32\xb5\x65\xb1\xa8\x4d\x55\x75\x68\xd3\xa1\x58\x44\x6d\x22\x07\xf4\x19\x50\x2c\x5a\xfb\xb8\x87\x0f\x1e\x5e\x2c\xba\x06\xe7\x4c\x1c\x3b\xb1\x58\xcc\x1c\x5b\xb0\x60\xce\x82\x62\xb1\xd3\x9c\x5e\x33\xa7\xce\x2c\x16\xbb\x4f\x4d\x6d\xd3\x67\xf0\xd8\x39\x53\xa7\xce\x19\x3b\xb8\x4f\x9b\x54\xa1\x2c\x29\x29\xbe\x58\x4c\x32\xb3\xb7\x2f\xe6\xb3\xca\x06\x8b\xf4\xf4\xa6\x7b\x14\xff\xe7\x33\xdb\x46\x44\x77\x59\xfb\x33\x93\x95\x6f\x9b\xf2\xed\x50\xbe\xc3\xbf\x0b\x77\xdd\xdf\xfd\x7d\xf7\xef\x77\xdf\x27\xde\x55\x7e\xb8\x3e\xfc\x45\x56\xeb\xd6\x59\xeb\xe8\xe9\xcf\x40\x76\x20\x3b\x81\x5e\x49\x81\x1c\xf2\xd9\x1b\xc8\xce\x0e\xa0\x3e\xf4\x1c\x72\xd1\x04\xb4\xa4\x21\x6f\x68\x5f\x56\xeb\x9c\x1c\x96\x19\xbe\x45\x7f\x93\x86\xd2\xf3\x9f\x34\xf3\x3a\x7a\x85\x9f\x20\xa7\xe6\xe4\x4e\xfa\x20\x10\xc8\xbe\x46\x6e\x60\x35\xb9\x18\x4c\x0b\x9b\x45\x4e\xf0\x44\x8e\x3f\x37\xd4\x85\x5c\x6d\xcc\xca\x6a\x8d\x62\x94\x4c\x12\x26\x17\xdf\xd2\xc7\x3e\x6a\x9d\xd5\x3a\x95\x5c\xd0\x31\xb0\x0f\xac\xe0\x3c\xf8\x36\xf3\xd7\x29\x00\x99\x77\x30\x2a\x02\xbe\x78\x40\x5d\x93\xa0\xd1\x13\xaf\x4e\x95\xa4\xe3\xc7\x24\x69\xd2\x15\x7c\x7b\xfa\x27\x63\x8f\x4b\x12\xc4\xc7\xc6\x7f\x34\x8b\xae\x85\x4b\x24\xe3\xe2\x45\x8e\xfa\x77\xb3\x51\x2f\x6a\x9c\x9e\x0c\x6e\x3b\x8c\x30\x13\x13\x94\x14\x96\x7e\xb1\xe1\xfd\x15\x5d\x95\xe6\xb5\xc0\xbb\xa8\x32\x91\x5b\x52\xc7\xcd\x3c\x3f\x6b\xe6\xc5\x99\x33\x2f\x90\xf3\x0c\x6e\x49\xed\x7c\xd4\x71\xe6\x85\x99\xe4\x9a\x24\xce\xa2\xde\xf3\x9a\xd6\xe1\x63\x5e\xd6\x22\xf4\x31\x11\x31\xa4\xa6\x44\x98\xa0\x8e\x83\x66\x27\xa9\xeb\xf3\x77\xc9\xff\x5d\x2f\x75\x59\x8d\x77\x8d\x8b\xe4\xfb\x40\x50\x5c\xb6\x6b\xc4\x08\x42\xf4\xec\xdc\xf3\x5e\x70\x1a\x7e\x23\xe7\xa6\xa0\x11\xbe\x3a\x11\x56\xe2\xe1\x78\x06\xdb\xbb\x99\x72\x10\x3b\x14\xbe\x8a\xcd\x98\xee\x10\xd2\x06\xb5\x16\x36\x64\xb5\x77\xf1\x55\xb6\x34\x4e\xde\xfc\xe3\x68\xdc\xbf\xee\xcf\xcc\xc1\xc3\x9f\x1c\xd1\x65\x72\x97\xea\x07\xcb\xbb\x76\x7f\x60\x74\x41\xc1\xe8\xb2\xee\x3d\x4b\xd0\xfc\x71\x8f\x75\x9c\x9a\x5f\x5e\xd5\xbd\x6b\x79\xc1\xe8\xd1\x05\x5d\x1f\x1c\x03\x08\x27\x8a\x06\x88\x3b\xc8\x6d\x60\xfc\x22\x8d\x8c\xca\x7c\x30\x2f\x18\x91\x14\xd7\x3c\x33\x2f\x33\x2e\x9f\x03\x84\x7f\x74\x25\x0c\xa4\xa0\x43\xeb\x9a\xfa\xaf\x8e\x6b\x0c\x85\xad\x5b\xb7\x6d\xdb\x91\x69\x92\xd9\x29\xbe\x14\x3a\xd9\x6f\x16\xd3\x7d\x6d\x83\x7a\x73\x61\x5b\x5f\x5b\x1f\xe9\x3c\xca\x69\x0e\x89\x8c\xcd\x90\x2f\x3d\x48\xbf\x90\xd6\x64\xd7\x6c\x83\x2f\x4e\xba\x0b\xbd\xe1\x55\x00\x5b\x0f\x2d\x73\x20\x79\xbb\x9e\x5d\xd9\xbe\x77\x37\x07\x0a\xc8\x7e\x59\xd8\x26\xa8\xc4\x26\xd7\x50\xd9\xd5\xc5\x50\x92\x1c\xfd\x34\x34\x6f\xd9\x02\x4d\x5b\x9e\x96\x6e\x6c\xd9\x22\xdd\x78\x3a\x6f\xd5\x1f\x8f\xad\xfa\x63\xd5\xaa\xdf\xc9\xf9\xb1\xeb\x29\xb1\xb1\xa9\xa9\xb1\xb1\x29\xf0\x70\xf8\x4a\xaa\x68\x33\xbf\x57\xd1\xbc\xdc\x36\x93\x2f\x75\x9d\x36\xb0\x25\xea\xb9\x05\x9a\x9f\x0e\x3f\x4c\x0b\x23\x8f\x3d\x76\x73\x25\x7d\xfe\xa6\x41\x7e\x24\xfc\x68\x8a\xf4\x7b\xaf\x36\x6d\x7b\xb6\x3a\xd8\xac\x4b\x3e\xe0\x9a\xe0\x33\x9a\xf0\xb9\x6c\x50\x16\xb4\xc5\xc4\x47\x9a\x9b\x99\xe3\x5b\x72\x6a\xa0\x0e\x80\x1c\x8f\x2d\xca\x26\xbf\xcf\x4b\x8c\x4a\xcf\xce\xce\xcc\x6c\x4e\x35\x79\xbb\x68\x8a\x82\x26\x82\xf5\xde\x99\x93\x32\x17\x66\xf2\x51\x99\x51\x99\x14\x79\x67\xe9\x26\xf7\x61\x0d\x0e\xf1\x9a\xbc\x41\xf9\x5b\x9c\x41\x46\x04\xf2\xb6\x05\xbe\xc9\x35\x64\xa1\x5b\x92\xe5\xd5\xc6\xf7\xa0\x08\xa6\xdd\x07\x2d\x2d\x5b\x0c\x9c\xda\xed\xd2\xe4\x36\x04\x3b\xbd\xe7\xe7\xde\x83\x16\x98\xd3\x04\x0f\xf4\x5b\x5a\xd6\xa5\x4b\xca\xc1\x56\x14\x21\x64\x5c\xbb\xea\x1f\xe1\x0e\x71\x6e\x82\x07\x3f\x28\x09\xda\x9a\x25\x78\xbd\xb8\xa5\xc1\x6c\x76\xa8\x54\x2e\x8c\xb3\xb2\x1d\x69\x84\x46\x88\x35\xe1\x70\x98\xbd\x09\x5e\x46\x2f\xaa\x56\x94\xf8\xf5\x22\x9e\xac\x82\x2a\x95\xc1\x93\x00\x13\x40\x3a\xf5\x84\x34\x4c\xde\xf8\xef\x67\x0e\xf2\xc2\x12\xcb\x1f\x7e\x7d\x44\x90\xe0\xc8\x09\x10\x65\x37\x92\xba\x2c\x8f\xa4\x13\x25\x2a\xea\xb9\x5c\x25\x10\x85\x38\x29\x59\x48\x0e\x24\x25\xfb\xb2\xfd\x39\x81\x64\x5b\x13\x84\x7c\xb5\x7d\x60\x79\xe1\xe8\x81\x3b\xfc\x3b\x0a\x34\x3f\xfc\xa0\xcd\x27\x17\x03\x47\x17\x96\x0f\xdc\xee\xdf\x9e\xaf\xfd\xd7\xbf\x34\x05\xdb\x9f\xda\x31\x7b\xf6\x8e\x17\x66\xce\x7c\x01\xaf\xdc\x91\xaf\xfd\xe1\x07\x4d\x41\x93\x3c\x05\x9a\x7f\xfd\x4b\x9b\x4f\x2e\xe4\x52\xa4\x39\x33\x5f\xa0\x59\x5f\x60\x6b\x2e\xda\x81\x02\xfc\x38\xb7\x0e\x44\x82\x78\x42\x03\x91\x8e\x48\xde\x64\xb3\xc1\x88\x58\x8b\x4e\xc7\x47\x60\x5f\x42\x84\x35\x12\x44\xd2\x29\x51\xd1\x44\xb2\x23\x17\x6d\xb6\x4e\x34\x92\x27\xf5\x18\xa9\xd5\x71\x6c\xc4\xab\x99\x2e\x60\x3e\xcb\xd6\x90\xcb\x14\xa0\x38\x71\x80\x8e\xdc\x3b\x9a\x4f\xb4\x76\x85\x15\x30\xe7\x46\x76\x6a\x9b\x10\x53\xa0\x69\x6b\xe1\xa0\x1f\xa7\xae\xdb\x3f\x77\xee\xfe\x75\x53\x7f\xfc\xb1\xf0\xc7\xe6\x4b\x87\x97\x2c\x59\x3a\x7c\xc8\x32\x38\xfb\x1d\xe3\xae\xc9\x73\xf7\xef\x9f\x3b\x69\x97\xe9\x9d\xc2\x1f\x7f\x44\x6d\x86\x2f\x7d\x64\xe8\xb0\xca\xc5\x94\x37\x6f\x07\x53\x39\x0e\xbf\x0f\xec\xc0\x0b\xc6\x07\x9d\x91\xc0\xa0\x52\xab\xf5\x3a\x9d\x91\x07\x31\x66\x60\x8e\xf7\xf1\x46\x6c\xb3\x45\x51\xf0\xa3\xc4\x0c\x1b\xb4\x61\x95\x41\x27\x04\xe9\xda\xe2\x74\x35\xd6\x60\xb5\x1a\x63\x0f\x6b\x0c\x0e\x6b\x1c\xa4\x35\xae\x8b\x17\x72\x73\xcd\x67\x65\x15\x27\x57\x59\xf7\x41\x58\x2e\x6d\x0c\xe3\xbc\x94\xaa\x29\x5f\x83\xe9\xd0\xeb\xb0\xa4\x43\xa8\x8c\xf3\x40\x93\x06\x6d\xdf\x3f\x77\x74\x31\x84\xdf\x20\xd8\xc3\x11\x88\x90\xea\x83\xb4\x71\x85\x0d\xcd\x7a\x6a\xee\xfe\x20\x84\x11\x01\x87\x74\x14\x7d\x23\xd5\x17\x8f\xa6\x4d\x6c\x68\x19\x95\x5b\xa3\x89\x4c\x18\xcd\xed\x26\x2d\xcb\x08\xba\xf4\x76\x95\xd9\x6e\x89\xe6\xe3\x7d\x1a\xa7\xde\x6e\xf7\x38\xd3\x9d\x79\x4e\xec\x74\x9a\xa9\x42\x97\x9b\x3e\x4c\x76\xc8\x22\x23\x5e\xf6\xf8\x47\xe5\x01\x73\xcd\x42\x60\xb2\x7b\xb3\x09\x58\xe1\x5d\x1c\x01\xc2\xb0\xd0\xa2\xd5\x13\x16\x8f\x59\x3e\xb2\xdd\xd2\xc4\xfd\x55\xa1\xb8\xaa\xfd\x49\x4b\xdb\x8e\x5a\x36\x72\xf9\x84\xd5\xdc\xee\x01\x1f\x0d\x18\xfd\x64\xef\xf1\x8b\x73\xd3\x2a\x9f\x6c\xdd\xfa\xc9\xca\xb4\xdc\xc5\xe3\x7b\xae\x9d\xd0\xff\x4a\x7f\x06\x17\x8d\xd9\x32\x8e\xc0\x95\x4a\xe1\xb2\xb8\x74\x76\x57\x64\x1c\x9f\xd6\xdc\x18\x6b\x71\xb9\x3c\xb1\xe9\xb1\x79\xb1\x38\x36\xd6\x7e\x7f\xb8\x98\x94\x52\x09\x81\x30\x63\xbc\x17\x38\xbf\x83\x52\x0a\x15\xca\xfd\xe7\x75\xe9\xec\x0f\x2c\x7b\x71\xf9\xc8\xf6\xcb\x15\x20\x13\x96\xe5\x8d\x5a\xf6\xe2\xb2\x80\xbf\x73\x97\x79\xdc\xee\xf6\x13\x82\x9d\x2b\x13\xf0\x8a\x29\xe3\x17\xb7\x4d\x91\x41\x4d\x69\xbb\x78\xfc\xd4\xe5\x38\xa1\xb2\x73\x70\x42\x7b\x8a\xc3\xfa\x7a\x82\xc3\x0a\xe0\xa2\xfb\xe5\x22\x0c\x7a\x9e\x8b\x8e\xd1\x30\x1d\x98\x82\xd4\x2a\x83\xcf\x4a\x4a\x46\x8a\x7b\x32\x87\x3f\x2c\x46\xb1\x11\xd9\xd1\x03\xb3\x96\xfe\xd4\x79\x6a\x50\xac\x72\xab\xdc\x6b\x07\x05\xa7\x76\xfe\x69\xbc\x98\x03\xbb\xbc\xb7\x05\xc6\x6e\x2b\x98\x1a\x5c\x32\x72\xd4\xe2\xe0\xb4\xfc\x6d\xd2\xb5\xca\x47\x66\xb5\xa2\x78\x59\x4a\xea\x2a\x24\xfa\xbf\x8e\xea\xda\x2a\xbd\x41\xcb\xc9\xf5\x30\x47\xff\xd9\x56\x9b\xdf\x6a\xb3\x23\xec\x43\x4b\xff\xba\xa6\xbf\xf6\x17\x3d\xa1\xfe\x18\xc6\x50\xb7\xaf\xd2\xb7\x58\xfa\x56\x3a\x07\xdb\xd0\xb5\x76\x2e\xe0\xc4\x3b\xb9\xd1\x20\x06\x24\x04\x4d\x56\x41\x30\xe0\x28\x43\x54\xac\x5b\x65\xd3\x12\x65\x35\xdd\x7f\x31\xbd\x71\xad\x29\xc3\x29\x73\xbc\x97\x6c\x91\x77\xde\x32\xb2\xb4\xf8\x95\xee\x17\x70\x84\x2f\x65\xe2\xe0\xe5\x03\xf2\x87\xac\xe8\xdb\x26\x35\x49\xff\xd0\xc0\x9e\x81\x0c\x68\x4e\x9a\xd6\xb1\x62\x87\x3b\xb4\xab\xcb\xc8\x2e\xad\x3b\x8e\x72\xe0\x2e\xd3\xe7\x8a\x3b\x46\x17\x2e\xf7\xd3\x31\x35\xb9\xfe\x7d\xae\x1d\xd1\x45\xe8\xfb\xa1\x05\xc1\x1e\x31\x91\x3a\x9d\x25\x56\xad\x8e\xb2\x44\xc5\x79\x57\x68\xa1\x36\x66\x79\x0c\x2c\x8f\x81\xfd\x62\x60\xcc\x0a\x0d\xd4\xc4\x26\xc7\x42\x7b\x2c\xe4\x62\x61\xac\xf3\x21\xcf\x0a\x0f\xf2\x38\x66\x39\x96\x39\xd0\x00\x07\x74\x38\x81\x4a\x15\xb1\xc2\x0d\xdd\x4e\x63\x5e\x04\x8c\x20\xbc\x92\x40\x3f\xcc\x9a\x4b\x94\x26\xff\xb0\x61\xe4\xa0\x5f\xf4\xa4\x7c\x35\x69\x18\xe3\x1b\x89\x0d\x2d\xe2\xef\x68\x5f\x22\xb9\x83\x89\xd9\x3c\x1e\x2e\x37\x2c\x74\x23\xdc\x44\xb4\x6a\xb9\xd4\x06\x99\x43\x37\x9a\xb3\x96\xc1\xc3\xc5\xa1\xaf\xc3\xad\xec\x3c\xaa\xae\xa8\xcb\x48\xf4\x9f\xe2\xd9\xc5\xb4\x9d\xd9\xf5\xad\xb9\xd7\x98\x8f\x0d\x0f\x68\x15\x8c\x89\xb4\xeb\x75\xae\x28\xb5\x20\xa8\xdc\xc8\x19\xa5\xd3\x9a\x63\xec\x3a\xa3\x11\x5a\xe9\xcc\x1c\xc8\x3b\x4b\x37\x0a\x3b\x72\x1b\xd7\x7e\x79\x7d\x36\xea\xa3\x49\xc8\x83\xec\xf0\xe3\x44\x72\x04\x4c\x90\x1e\xe4\x97\x44\x8c\x4b\x3b\x48\xeb\x0b\x4a\x3b\x5c\xf5\x5c\x2d\xfb\xc4\x73\x35\x58\xda\x1a\x8e\xeb\x52\xda\x4e\xb9\x75\x4a\xeb\x47\xc0\x71\xb0\xfd\x56\x69\x33\xec\x20\x3e\x23\xc2\x7f\xd3\x53\x57\xe9\xab\xad\x70\xa8\x74\x9e\x5c\x4b\x3a\x72\x42\x13\xb6\x4a\xba\xad\x84\xb6\xfa\x51\x67\xcb\x7c\x3e\xe1\x73\x1d\x83\xf1\x46\x95\xa0\x1a\x21\xea\x4c\x02\x61\xc6\x82\x00\x34\x56\x84\xd1\x08\x62\xa3\x61\x40\xec\x5c\x9b\xb2\xfb\x4e\xde\xda\xdc\xe8\xae\x95\x7a\xec\x93\xb7\xc1\xf8\x9b\xba\x4e\x53\x1c\x67\x7a\x85\xa5\xc3\x57\xbb\x56\xc7\xae\x8e\x5a\x3d\xe8\xd4\x20\x58\x19\x25\xcd\x8b\x85\x4b\x5d\xd2\xdc\x20\xda\xea\x86\xdf\x56\xae\xab\x84\x67\xa4\xf6\xe4\x4b\xaa\x79\x8a\xd2\x28\x31\x49\xf1\x5c\x82\x3b\x1b\xf5\x8b\x43\xe1\x29\xa2\xf0\x78\x84\x74\x01\x6b\x1a\x60\x2a\xa2\x30\x91\xd1\x66\x07\x79\x79\xf7\x07\xc5\xdb\x04\x94\xb0\x77\x37\xf8\xdc\xe8\x89\xae\x89\xb1\x13\xa3\x26\x8e\x3b\x32\x8e\x9c\x63\xc9\xdd\x68\xa4\x27\x75\xa3\xf8\xd0\x17\xe4\x2b\x74\x53\xe6\x8f\x36\x82\x13\xc4\xfc\xcf\x75\x0c\xfa\x0c\xa6\x48\xd3\x08\xd1\x19\xa9\x82\x48\x43\x90\xa1\xd5\x58\xe9\x76\x28\x6b\x50\xa5\x02\x3a\x0c\xa2\xee\x40\x8a\xeb\xb3\x34\x39\x32\x82\xb3\x21\x42\x82\xdf\x96\xac\xc4\x55\x72\x10\x50\x22\xe5\xc8\x4a\x84\x23\x25\x53\xcc\x2c\xf7\x25\x27\x68\x16\x47\x2e\xee\x9f\x34\xea\xd4\xd4\xa8\x18\x8f\xcf\xb4\x38\x72\x72\xa9\xdb\x3d\x04\x6d\xf5\xa0\x13\x5c\x46\x7a\xf9\x7c\x8c\x54\xa1\x43\x7c\x7a\xc6\xd4\xa9\xbc\x94\xfa\x94\xbc\xc7\x2b\x97\xc5\xea\xc9\x67\xba\x96\x3f\xe8\x72\x68\xb4\x9a\x11\x62\x84\x56\x2b\xe8\x9d\x7c\x89\xe8\x74\xea\x05\xab\x9e\xf4\x96\xbe\xd1\x25\x52\x53\x1f\xbb\x4c\x83\xe6\x7c\x0d\x3e\x4d\xa9\x0f\x28\xaf\x8f\x75\x17\x75\x07\x71\xbc\x5a\xfa\xeb\x45\xea\xec\xe8\xc5\xc7\x5c\x8f\x75\x81\x17\x2e\x7d\x7e\x56\xba\x76\x2b\x09\x0e\x73\x49\xcf\x25\x4b\xfb\xde\xc5\xb5\x2b\x7e\x7c\x24\x24\xe1\xb2\x4a\x38\x7c\xcf\x4b\x17\xdf\xa8\x7c\xfb\x08\x85\x29\x52\x1a\xc8\xbd\x4a\x60\x22\xbc\x85\xd0\x7c\x54\xa4\xcb\xeb\x2a\x11\xbd\x5e\xa7\x91\x27\x86\x7e\x89\xa8\x76\x5a\x8d\x71\x25\xa2\x51\x01\xe9\x6c\x13\x67\xbf\x14\x22\x07\x15\x6f\xcc\x37\x23\x0d\x0e\x03\xbd\x72\xb8\x03\x81\x3a\x7e\xc4\x2a\x98\x95\x02\xb1\x37\x33\xe7\x53\x67\x56\xfb\x2c\x77\xb7\xbc\x71\x53\xd4\xd0\x0b\xbf\x79\xef\xc2\x98\xd3\x0f\xc3\x98\xcf\xa4\x5f\x2a\xd5\x38\x4e\xba\x25\xdd\x18\x0a\x9d\x3b\x4e\x1c\x76\xe7\x9a\xb7\x58\xca\x47\x26\xa7\xf1\xef\x3f\xbb\x7a\xec\x6b\x8b\xec\xa1\xdd\x28\x2f\xd4\xaf\x19\xf7\xd8\x11\x29\x75\x33\x5d\xe3\x73\x58\x1a\xc4\xab\x09\x8d\x65\x10\xbd\xbf\x3d\xe8\x0c\x86\x06\x5b\xb5\x69\xd5\xb2\x55\x91\x98\x9a\xd6\x36\x10\x0c\x14\x8b\x9a\xb4\x96\x41\x53\xd0\x14\x01\x5b\x46\x26\xc6\x15\x8b\x89\x76\x3b\x70\x44\x44\x58\xf3\xb4\x5a\xbd\x55\x5f\x24\x5a\xcd\x04\xf1\x79\xf2\x32\x77\xf6\xe7\x94\x57\xaa\xca\x9e\x99\xac\xb9\x77\x38\x03\xc2\x90\x89\x1d\x14\xb0\xc9\xdb\xd1\xad\x5e\x22\xdd\xfd\x90\xb9\x2d\x65\xee\xc8\x1a\x9a\xed\x33\xc2\x34\xa8\x81\xd4\x6d\x90\x00\x23\xa8\xff\x26\x98\x4c\x38\x40\x4e\x4f\x68\xe9\xd2\x29\x38\xf7\xfc\x73\x35\xcd\x7b\xce\x99\x1f\x73\x62\x14\x5c\x36\xb2\x27\xe4\x57\x4b\x1f\x16\x68\x87\x68\x7a\x47\x7b\xed\x05\xdd\xfa\xf4\xe4\x55\x43\xdf\xa9\xd4\x49\x21\x28\x96\xee\x9a\x61\xb2\xac\x93\xfa\x35\xbb\x51\x5d\x89\x26\xa2\x49\x43\x75\x5a\x69\x10\xdc\xe5\x9a\xd5\x77\xe4\xda\xb2\x0e\x76\xe8\x89\xec\x33\xd8\x02\x13\xa2\xe0\x93\x52\xf3\x2e\xd3\x9b\x67\x4a\x2d\x5b\x7a\xfa\x09\x93\xcd\x85\xbd\xdd\x09\x73\xc6\x48\xe3\x51\x34\x1c\xbe\xa9\x58\xc4\xd2\xaf\x3d\xe2\xe1\x2c\x4b\x25\xdc\x1b\xbb\x0f\xb5\xcd\x90\x7d\x92\xbf\x4f\x70\xe7\x21\xb8\x73\x13\xed\xa1\xcd\x71\x67\x74\xa4\x87\xb0\x5f\x53\x0d\x74\x05\x6d\x62\x44\x24\xc6\x50\x00\x5e\x3d\x19\x43\x45\xa2\x86\x87\xa6\xc6\xb5\x22\x94\x0a\xc3\x5e\x93\xf2\x58\x88\x45\xca\x24\x08\x22\xc8\xc8\x84\xe1\xce\x4f\x86\x3e\x48\x31\x11\x0d\xc9\x85\x3e\x66\xd7\x94\xd9\x01\x68\x80\x60\x75\x3d\xb0\xc7\xf4\x93\x9a\x45\xcd\x5b\x78\x30\xfa\xc0\x8b\xf3\xf2\xa5\x6f\xd7\xc0\xe1\x82\x66\xb1\x08\x53\xde\xc5\x7b\x56\x43\x97\xf4\x4f\xb8\x56\x9a\xb8\x3a\x14\x15\x8c\x5f\xd1\x32\x59\xea\x88\x92\xa2\xbd\x89\x2d\xd1\x33\x52\x0b\xf8\x81\x3c\xa6\x73\xa5\x0a\x1a\x67\x90\x8c\x99\x66\x41\x62\x2f\xe8\x54\x25\xa2\x4e\xc7\x19\x88\xa2\x66\xe5\x4c\x25\x22\xa7\x0c\x62\xe6\xa8\x8f\xea\x9e\xe7\x88\x8c\xa0\x23\xc4\xe6\xa5\x7e\x62\xa8\x27\x48\xcc\x8d\x9b\x78\xb0\xf7\xc6\x87\x42\xb7\x1e\x3a\x05\x55\xa7\x26\x22\xed\xc4\x53\xdf\x6f\x0d\xbd\x05\x37\xa0\x49\xa1\x2a\x3e\x9f\xba\xe6\xab\x1d\x42\xeb\x2a\x22\x75\xf5\x60\x38\x4a\x0b\x46\xba\x40\x94\x1d\xb8\xdd\x58\x6f\x34\x6a\x8a\x45\xa3\x1d\x47\x14\x89\xd8\xdc\xb0\x00\xd7\x7c\x8e\xae\xa3\xa3\xde\x84\x60\x83\x7b\x6f\x3f\xab\xb8\xd1\xf9\x37\xa9\x5f\x25\xc0\xbd\xbd\x8f\xcd\x5f\xf3\x98\x69\xda\x8c\x8a\xe7\x7a\x2f\xab\x34\x0d\x2a\x5d\xf8\x92\x7b\xde\x11\x18\x77\xa4\x87\x35\x16\x3f\x3c\x76\xe4\xf4\x59\x9d\x7b\x87\x0e\x85\xbe\x23\xf0\xec\x2b\xce\xec\x99\xbf\xff\x89\xd0\x62\xfe\x82\xb4\x60\xd4\x83\x14\xa6\x44\xa9\x82\x17\x58\xfb\x13\x82\x36\x40\x77\x6f\xa8\x8c\x3a\xac\xb5\x72\x2a\x15\x2c\x11\x55\x72\xf3\xcd\xe7\xf2\x98\xcb\x4c\xea\x7d\x83\x01\x01\xe5\xda\xa1\x1f\x6d\x85\xfd\x57\x92\xe6\x77\x92\xd6\x9f\x1d\x42\x9b\xbf\x04\x9d\xfa\x1a\x6b\x42\x4f\xb2\xf6\x2f\xd8\x29\xa5\x11\x04\x94\xa0\x6d\x0c\xd7\x4b\x48\xfb\x8f\x33\x9f\x36\xbe\xa0\x8d\x68\x2b\x3c\x87\x75\x26\x35\x10\xec\xd8\x58\x2c\x42\xea\x1f\xe3\x1c\xc3\x75\x9e\xec\xa2\xae\x69\x3d\xb4\xde\x3d\xcf\xf5\x4e\x97\xfe\x78\xb2\x17\x6d\xdb\x11\xd4\xf1\x83\xd0\xaf\xd0\x30\x42\xaa\x80\x1b\xe0\x1f\x65\xd2\x24\xfe\x42\xdd\x08\x64\x90\xd2\x25\x17\x5b\x3f\xf8\x15\xa9\xeb\x37\xb6\x2f\x3b\x9e\xae\x7b\xa6\x5e\x78\x05\xcc\x69\xb1\xb6\x84\xd4\x64\xa5\x35\x29\x4b\x29\x65\x47\xb2\x36\x6f\x80\xfa\xe4\x12\xa0\x17\x9f\x3f\xd8\xbb\x6e\x56\x0c\x96\x42\x0e\x37\x7e\x3d\xba\x0e\x62\x56\xc7\x1a\xce\xf5\xd4\xca\xda\x6f\x64\x1f\x31\xa4\xec\x09\x5c\x1b\xb9\x6c\x15\xe6\x70\x91\xc8\x99\x08\x81\x0b\x45\xa2\x16\xd8\xef\x2a\xdb\xdf\x50\xb0\xcf\xd6\x36\x1a\xb7\x0a\x55\x47\xe3\xd6\xae\xba\x8b\xe8\xe5\xb1\xcf\xf5\x5e\x81\x93\x56\xae\xa8\xfb\x24\xf4\x39\xdc\xc0\x7c\x70\x5d\xe7\xbe\xe3\x07\x13\xa5\x2b\x06\x24\x06\x6d\xd0\x00\x8c\x58\xe7\x24\x04\xc9\x61\xc2\xb6\xb1\x8d\x4a\x94\x86\x05\xda\xb2\x07\xd7\x80\xcc\x23\xac\xcc\xcf\x76\x80\xa0\xc9\xec\xcd\x64\x1c\x85\x3a\x0d\x8f\xd3\xce\x5d\xf1\xe1\x17\x15\x87\xea\xb6\x1e\x14\xd7\x7a\xa4\xbf\x42\xc3\xa1\x76\xf3\xc4\x6d\x81\x3d\x13\x76\xcc\xec\x96\xd3\xfd\xe7\x7f\xee\x80\x73\xeb\x16\x0e\x79\xe0\xf6\x51\x78\x56\x3a\x33\x13\xb7\x7d\xa4\xe2\x23\xe9\x15\x79\x5c\xbc\x0d\x00\x9f\xc9\xf5\x22\xcd\xf1\x1c\x06\xc8\x86\xe8\x48\xd6\x88\x36\x33\xa1\x10\x93\x40\xe5\xab\x35\x37\x8c\x3c\x46\x8d\x84\x25\xfb\x6d\x91\x1e\x48\x34\x13\x06\x0b\xf7\x9e\x33\x2e\x35\xcf\x27\x15\x7e\x74\xfc\xf4\x83\x1a\x2d\xe7\x1a\xfe\xaf\x82\xb5\xe5\xfd\xda\xe0\x67\xcd\xed\x3a\xd5\x5d\xe0\xda\x84\x82\x5d\xa6\x67\x67\x1f\x83\x97\x57\xcd\x49\x21\xf5\x8d\x25\xf5\xed\x23\xfd\x15\x4f\xc7\x61\xac\x27\xca\x53\x22\xda\xf4\x7a\x6c\x34\x0a\x51\x44\x50\x40\x81\xf9\x87\xa3\xcc\x22\xb7\x61\xa7\xb8\xd7\x87\x92\xa9\xbb\x26\x1b\x1d\x06\x01\xe8\x8f\xb4\x0a\xf6\x68\x28\xbb\x29\x90\xdd\x7a\xe2\x92\xcb\x11\x28\x57\xdc\xf9\xa1\xff\x64\xb6\x3e\x32\x07\x6a\xf7\xeb\x4d\x78\xf4\x1b\xb1\x0f\x94\xf6\x74\xb5\x33\x74\x75\x5a\xbc\x59\x4e\x34\xa2\x7a\xf5\x55\x69\x1a\x9f\x5f\x77\x72\xeb\x4b\x4b\xd0\xec\x9b\xd2\x15\xb1\x12\x0e\x46\xfd\x07\x56\xa4\xeb\x85\x35\xaa\x36\x5d\xc2\xf1\x29\xf8\xb1\x04\x1f\xf1\x20\xed\x30\x05\x8f\xe2\xc3\x24\x46\x99\x2d\x0c\x48\x95\x40\xbd\x5c\x31\x17\x76\x32\x84\x79\x61\x10\x71\xb2\xc0\x20\x14\x08\x88\x36\x3f\xb1\xca\x29\x82\xee\x00\xf1\x42\xbc\x76\xdc\xbb\xe7\xa3\x0f\x45\x71\x1a\x43\x8f\x8f\x5e\x73\x6b\x8d\x6d\xed\x8f\x79\x7b\x0e\xeb\x21\x83\xe8\xc9\x8c\x81\xfb\x7f\xbf\x25\xf5\x27\x28\xdb\x96\x77\xb4\xc3\x3e\xf8\x8a\xb4\xf0\x87\x2e\x7b\x3b\xc2\x4a\x05\xc2\xec\x6e\x84\x76\xd6\x11\x01\x76\x94\xcb\x07\x4e\x02\x61\xcb\xa0\xd9\x82\x31\xcf\x71\xaa\x68\x95\x1d\x23\xa7\x49\x47\xcc\x67\xd7\x11\x51\x67\x46\x76\x85\x82\xd8\x64\x49\xba\x3c\xcb\xad\x21\x7d\x47\x67\x04\x1a\xcd\x65\x07\xeb\x48\xc8\x47\x38\x14\x66\xc3\x1d\x0d\x6d\xfc\x68\xc8\x94\xa8\x19\x9a\xe7\x16\xf6\x1a\xfc\xf0\xa3\x29\x82\x9e\x73\x0d\x83\x8b\x42\x2f\xea\x1f\x89\x76\xa4\x65\x53\xa7\x35\xc8\x97\x30\x3f\xb9\x6d\x70\xde\xee\xe1\x45\xe3\xaa\xdb\x5d\x4b\xac\x26\xbd\x8b\x5e\xaf\xcb\xcc\xec\x3c\xc0\x15\xdf\x3e\x6c\xc7\xb5\x62\x3e\x16\x22\x83\x3a\x1e\x94\x88\x3c\x8f\x14\x87\x3f\x8a\x53\x1c\x99\xa7\x0a\x70\xa3\xc2\x4a\x1f\xf2\x84\x79\x28\xd5\x49\x0f\x10\x1d\xf0\x2c\x19\x77\x02\x70\x05\x8d\x90\x2b\x16\x89\x1d\x0c\x21\xc1\xbd\x4a\x26\x48\x79\x5f\x2d\x96\xfd\xb2\xa3\x1c\x11\x7e\x1f\x25\x45\x95\x1e\x79\x9f\x6b\x23\xe5\x2c\x91\x6c\xe4\x49\x04\x6c\x64\x8c\xbd\xce\xf5\x01\x91\x2c\xea\x6f\x44\x84\xab\x48\x8c\x30\x6b\xb4\x44\x2c\x99\x63\xcd\xd8\x4c\x78\x70\x64\x78\x1d\x39\x1b\x69\xa4\x40\x33\xf0\xc6\x59\xb2\xac\x39\x44\x14\x21\x16\x75\x80\x31\x64\x36\xc1\xa8\x83\x09\xdc\xeb\x52\x95\xb4\x4d\xf2\x3c\xf2\xd7\x76\x7e\xc7\xc9\x19\x33\x27\x27\x9e\xdd\xb2\x78\xcd\x4b\x81\xd6\x8f\x67\x4d\x81\xdb\xd1\x65\x69\x9d\xb4\x1c\xee\x3a\x04\x5b\x9c\x8d\x5a\x1e\x27\x5d\xfa\x7a\xf5\x0a\x01\x75\x7c\xed\xc3\xf3\x3b\x26\xcd\x93\xfe\x08\xbd\x62\x01\x08\x72\x60\x25\x7e\x1d\x2f\x63\xef\x91\x12\x83\x56\x08\x04\x15\x20\x7f\x88\xf0\x47\x13\xf2\x20\x44\xf7\x56\xb3\x88\x21\x4a\x34\x62\x2a\x26\x13\x05\x76\x74\x8f\x43\x83\xe2\x42\x65\x1e\x34\xc8\x03\xff\xfd\xec\x8d\x67\x43\xcf\x93\x13\x95\xc7\xaf\xe2\x63\x70\x9c\x12\x27\xc5\x78\x84\xc5\xef\x00\xe9\x17\x73\xa9\xcb\x2a\x1c\xf0\x0b\x54\xe9\xec\x14\xbb\x29\x36\xa3\x62\x6e\x05\x37\xad\xba\xfa\x24\x8a\x0c\xfd\x48\xf5\xb5\x0c\xfc\x27\x4a\x6d\x78\x0e\x63\x8e\xc6\x73\xbc\x90\x49\x5d\xbd\x68\x60\x32\xa4\xe1\x8f\x51\xaa\xf4\x40\x01\x3c\x22\x8d\x8d\xd9\x14\xc3\x8f\x92\xaa\x07\xc0\x09\x0f\x57\x57\x93\x3a\x4b\xb8\x12\xb8\x59\x79\x56\x7f\x98\x53\xd1\x7d\xe8\x7e\x16\xf3\x99\x70\x40\xea\x12\x10\x2e\x09\x7d\xe6\x44\x09\xd2\x61\x52\x33\x57\xf2\xd0\x88\xea\x6a\xc6\xab\xe9\x73\xef\xb0\x58\xa7\xda\x43\x98\xc6\x89\xf6\x5f\xa0\x91\x4a\x02\x84\x14\x56\xc0\x17\xd2\xe7\x77\x0d\x7d\xc6\x7d\x7c\x53\xaa\xa6\x76\xc0\x19\x4e\xe0\x9e\x10\x66\x02\x0d\x30\x1f\x85\x3c\xaf\xc6\x6a\x25\xb0\x08\xad\x05\x33\x3e\xee\x87\xdc\x5a\xe9\x9b\x51\xd5\xa3\xa4\x6f\x38\xb8\xc5\x02\xe3\x54\xda\x50\x08\x61\x07\xec\x2f\xed\x62\x7b\xcb\xb6\x91\x32\xa6\x2b\x65\xd0\x28\x3a\x50\xd5\x58\x86\x0f\x06\xd8\x5e\x7d\x01\x9d\xb7\x48\xdf\x73\xd0\xfd\x60\xf5\x83\xd0\xcd\x71\x02\xec\xef\x40\x38\x14\x8a\x04\x08\xe5\xe3\xe7\xf1\x0d\xe1\x22\x6b\xa7\x33\xa8\x85\x90\xc3\x34\x5c\x0e\x47\x03\x4a\x35\x06\xa9\x50\x62\xe2\xe0\xf8\x31\xc3\x3e\x91\xfa\xbb\xaf\xb8\xb9\xf7\x51\x6d\xed\xd5\x0d\x1b\xa8\xbe\x84\xba\x92\x32\x7e\x6a\x2c\x03\x21\x48\xec\xc0\x2d\x43\x58\xe0\xbe\x3b\xca\xb0\x09\xbe\x00\xf6\x7e\x72\x61\xcc\x24\x52\x04\x7e\x1e\xd5\xc2\xe6\xac\x08\x42\x37\xd7\xe0\x0e\xbc\x4c\xc1\x77\x54\x50\xd3\x50\x46\x0d\x6c\xae\xbc\xe4\xc9\x6d\x52\x08\x3a\xa9\x14\x02\x77\x34\x14\x02\xeb\xad\xdc\x18\xf8\x2b\x29\x43\xc1\xa7\x86\x06\xd8\x22\x7d\x26\x6f\xd9\x20\x4f\x91\xc3\xe6\x85\x57\x7e\x6d\x31\xbf\xc5\xfe\x16\xf3\xf3\xd1\x06\xbe\xf7\x3f\xff\xf9\x4f\x38\x92\xc6\x20\x0c\x90\x12\xbe\x27\x97\xf4\x59\x15\x56\x73\x34\x30\x0b\x21\x4f\xea\xc3\xc7\x4f\x90\x28\x30\x07\xeb\x97\x42\x15\xf9\xec\xd9\x16\xbf\xc2\x91\xe4\x51\x52\x67\xa9\x34\x10\x5e\xad\x9f\x4e\x68\x9c\x50\x26\xb7\x88\xc6\x86\xf1\xbb\xe8\x53\x44\xd0\xdb\x7c\xc9\xc2\x56\x18\xbf\x67\xf7\xae\xc9\xc7\x49\xb6\x58\xe9\xda\xab\xaf\xd2\xb6\x9e\x01\x6f\x63\xea\x57\x4b\x8e\x5d\xa7\xa3\xf8\x86\x80\x1c\x26\x42\xd6\x79\x69\x69\x72\x70\x6e\x7a\xa0\x82\x66\x67\x9a\x49\x2f\x91\x13\x1e\x77\xe9\x52\x68\xf8\xa5\x4b\xcc\x36\xba\x0c\x6e\x72\x08\x8f\x55\x68\x13\x90\xb1\x15\xa6\x4d\x2a\x9c\xe9\xd1\x32\x06\xd5\xc4\xd4\xfd\x18\x8b\x6a\x62\xd1\x3f\xd6\xad\x93\xdc\xeb\xd6\x01\x88\xba\x21\x91\xd9\x9d\x3c\xd0\x1c\x02\x1c\x00\x79\x6c\x33\x3e\x0d\xbb\x82\x36\x15\xf7\x6c\x7e\xa2\x39\x12\xd1\xda\xaf\xbf\x66\xfb\xd8\x1e\xc2\x45\x0d\x79\x21\xbe\x23\xef\x3b\xc5\xb1\x24\x2f\x2e\x82\x9b\x59\x5e\x0c\x96\x10\x5e\xf8\x19\xc9\x6b\x07\x51\x20\x96\x58\x6b\xb1\x8e\xc8\xbe\xa2\x03\x68\x4d\x54\x87\x00\x58\x85\x8b\x45\x5b\x74\x0c\x56\x99\x90\x2b\x16\x43\xba\xb2\x44\x5e\x7b\xd8\x84\x2f\x29\x9e\x50\x9b\x86\xd8\x50\x42\x18\x51\x2f\x2f\x37\x4e\x1c\x39\xb1\x21\x6a\x83\xd3\xf3\xd4\x92\x6e\x59\xd1\x2d\xbc\x9d\x7b\xda\x6c\x1f\x44\xc1\x2e\xde\x23\x5e\xa9\xe7\xfb\x47\xde\xc7\xc7\xeb\xba\xe1\xe3\x4b\xe6\x3c\xb9\x50\xbf\x42\xdd\x65\xf8\x88\x25\x70\xcc\x9e\x3d\xb7\xbf\xa2\x9c\x9c\xe2\xab\x29\x7c\x2d\x82\x4e\xe7\x5d\xa0\x11\xb8\x22\xa3\x30\xb4\xb3\xb0\x50\x4d\xe0\xf2\xff\x1d\x5c\x36\x32\x2c\xff\x06\xa6\x7c\xa2\xcf\x49\x5f\xdd\x03\x4f\x5d\x37\xfe\xc2\xed\x2c\x1a\x27\xb0\x16\xa6\xe2\xee\xdc\x79\x6b\x12\x0d\xe1\x66\x11\xb8\x3f\xea\xcf\x4a\x27\x80\xf6\x08\x2c\x35\x42\x23\xb0\x0c\xcb\x26\xb8\x57\xf1\xcf\x73\x5b\x55\xd7\x68\xb4\xe4\x63\x66\x93\x1a\xaa\x0d\xb8\x06\xf6\x25\x12\xf9\xe2\xb0\x4c\x39\xea\x05\xb3\xa5\xfc\x8a\x2f\x70\x6e\x6b\xcc\x87\x4f\x2e\xae\x52\x3d\xcb\x75\x2e\x7c\x60\x82\x59\x75\xed\xf1\xbd\x95\xd3\xbc\x09\x29\x81\xee\x43\x7b\x51\x7f\x3a\xd0\x0e\xdb\x71\xb4\xce\x64\x5e\x5d\x0f\x69\x24\x58\x5e\x4d\xbe\x80\x59\xe0\x7e\x01\xa3\x91\x8f\xf9\x5c\x3b\x53\xff\x25\xf7\x1e\xc9\xa3\xe2\x2d\xec\x7e\x17\x7d\x81\x44\xef\xb9\x7a\xe6\x93\x67\x0b\xc1\xe1\x45\xf6\x3b\x62\xf7\x29\xe4\x7e\x25\xbb\xc7\xec\xbe\x80\xdc\x17\xb0\x7b\x2d\xbb\x7f\xaa\xfe\x03\x6e\x9a\xea\x61\x72\xaf\x63\xf7\xb1\xe4\xf7\x25\xec\x77\x3d\xbb\x7f\x93\xdc\x5b\xd9\xbd\x83\xd5\xf7\x5a\xc3\xef\x51\x4c\x47\x99\x8b\x10\xd1\x4b\x2b\x28\x47\x39\x4c\x98\x2f\xd1\xd9\xfa\x1f\x12\x21\x57\x03\x7b\x28\x7e\xa0\x65\x4e\x4c\xd9\x1b\x57\x58\xe7\x4f\x84\xcb\xfa\xbd\xd4\x0f\xae\x42\xe8\x25\xb8\x87\x85\xf5\x25\x75\x6c\xaa\xbf\xc5\x77\xe1\xbf\x26\xb8\x76\xb2\xd6\xfe\x07\x5e\x6c\x48\x6f\xd5\x34\x3d\xf4\xee\x7d\xf2\x27\x73\x7f\x00\x7f\x3d\xfc\xdb\xe7\x9a\xfc\x2e\x3f\x5f\xbf\xab\x3e\x8a\xe1\x2c\x89\xe2\xcc\xac\xe2\x7e\xf9\x59\xf6\x67\xb7\x4b\xda\x7e\x47\xfa\xaf\xe1\x74\x05\xc7\x72\x3a\xa5\x85\x6e\x12\x24\xe9\xdf\x13\x5c\x04\x18\x8d\x00\x25\x7d\x6a\xfd\x7e\x52\xff\x0a\x42\xb1\xb3\x58\x3a\x54\xd2\xed\xa0\x4f\x93\xbe\x49\xe2\x51\x38\xbd\xbe\xbc\x49\x1f\x25\xd1\x3e\x62\xe9\x3f\xb3\xf4\x5a\x52\xce\x66\x96\xce\x8d\x66\xe9\xd2\x59\x56\x3e\x8d\xd3\xe7\xe5\x3e\x27\xe9\xbc\x47\x4e\xdf\xcf\xf2\x57\x10\x3d\xa3\x9a\xfb\x92\xa4\x0b\x0c\xfe\x3f\x7e\xdb\xcf\xe8\x6a\x1c\x2a\xc0\x6f\xc8\xb4\x3c\x57\x2e\x3f\x0b\xec\xa1\x7d\x2b\x2d\xe4\x22\x58\xba\x46\xa9\x37\x8b\x95\x13\xa6\x91\x24\x4a\x23\xb4\x9c\xcd\xfb\xef\xa0\x95\x24\x4a\x2b\x2c\xff\x3c\x86\x9f\x97\x68\x5c\x37\x56\xaf\x41\xce\x6f\x94\xf3\x13\x26\x8a\xcf\xb0\x72\x4c\x4a\xfe\xbe\x0c\xfe\xe1\x04\xce\x4d\x2c\xdd\x2c\xe7\xff\x59\xce\x3f\x83\xc0\x33\x9f\xa5\x5b\xe5\xf4\xa1\x72\x3a\xa1\x34\xae\x92\xa5\xdb\xe4\xf4\xd1\x72\x7a\x0b\xf6\x3e\x99\xa6\xdb\xe5\xf2\xa5\x3f\xa5\x8f\x49\x3a\x20\xe5\x3c\xc1\xd2\x23\xe5\xfc\x7f\x7e\x7c\x07\x2d\x27\x51\x5a\x6e\xd2\x5e\x46\x2f\x2c\x5d\xa6\x33\x46\x2f\x4d\x68\x3d\x89\xd2\x3a\x4b\x8f\xa0\xf9\xe1\x1a\xd2\xae\x87\x54\x05\xb4\x5f\x58\xf9\xbf\x01\x99\x4e\x18\x3d\xf0\x07\x1b\xe8\xe1\x56\xfd\xd4\xc6\x31\xc7\xd2\xb5\x4a\xfa\x9c\xc6\x76\xb1\x74\x5b\x63\x7e\x32\xa6\x06\x91\xf4\xf7\x54\x0f\x03\x0b\xf0\x1d\x31\xa9\x2c\x1c\x3a\x05\xbb\x03\x0d\xec\x09\x2c\xb0\x17\xf9\x99\x23\x57\xd4\x30\xc9\x93\x5f\xc7\xdb\x7c\xcc\x73\x7f\x0e\xe5\xf9\x46\x44\x8c\xa2\x5b\x5b\x66\xbc\x34\x60\x00\xec\x7e\xac\x7b\xc7\x53\x9d\xe2\x4a\x16\xce\x86\xfa\x1f\xb9\x74\xd4\x47\xea\x1e\xaa\x5e\x03\xea\xbf\xfc\x74\xfc\xfe\x75\xa3\x24\x1f\xb3\xb9\x42\xe3\xb9\x53\xe0\x92\x2a\x93\xc8\x53\xf5\x41\x0d\x75\x50\x47\x0b\x8c\xe7\x04\x5f\x4e\x82\xd7\x7f\x9c\xfb\x49\x7a\x66\x66\xe5\xd3\x70\x1b\x34\x38\xf9\xe3\x33\x17\xbf\x7a\x94\xc2\x77\x80\x3b\x85\x37\x2b\xcf\x40\xe5\x19\x7f\x1c\xe7\xf0\x25\x25\xa4\xc1\xb7\x9c\x50\x0f\x87\xf6\xad\xcc\x97\xde\xfd\x89\x53\x65\x1e\x7d\x75\xf1\x4c\x5a\xcf\x22\xee\x2c\xd8\xc7\x5f\x06\x7a\x22\x09\xb1\x76\x91\x40\x03\x37\x53\xbf\x7b\xcc\xb1\x96\x1c\xeb\xdd\xb1\x66\xc8\xce\x82\xc5\xab\x12\xd7\xb6\xff\xe3\xa5\xd9\x17\xb8\x5a\x47\x4a\xab\x82\xc7\xe7\x29\xfe\x17\xd7\x70\x67\xf1\x49\xf2\xbc\x91\x3c\x2f\x2c\xc2\x3a\x26\xbe\xc9\xf3\xf2\x3b\x67\x3f\x8d\x0b\x99\x94\xbc\x6f\xd8\x8b\xf9\xcb\x56\x7a\xd6\xa5\x3d\xf4\xca\x23\xbd\x9e\xef\xc7\x6f\x76\xa6\x66\x77\x1a\x35\xae\x7d\xbc\x9d\xe9\x60\x71\x92\x88\xa6\xd5\x6f\x21\x83\x39\xea\x18\x42\xaa\xc9\x3c\xe4\x6b\xea\x4f\x1f\xd6\xe8\x0b\x79\xea\x4f\x49\x8e\x71\x4f\x43\x49\x63\xa2\xbf\x2d\x7f\x43\xb8\x26\x89\x5e\x98\x90\x28\x7d\x45\x9e\x3d\xc2\x1d\xe0\x9e\xe0\x8f\xd0\xf5\x01\xc7\x75\x18\xe0\x55\x43\x80\xba\x06\x26\x1d\x12\x41\x35\xf5\xcc\x2c\x33\xba\xb8\xec\x06\x66\xef\x47\xe8\xa6\x74\x9a\xdb\x8e\x8a\x4a\x1f\x1c\xef\xd8\xde\x96\x3b\x70\x39\xcb\xd3\x3e\xb7\x4b\xb1\x54\xc7\xe4\x76\x5f\x6e\x19\x7e\x9e\xc9\x6d\xd3\x41\xba\xff\x5b\x7f\xa8\x21\x1c\x2f\x83\x00\xf5\x15\x96\x11\x08\xb8\x65\x0a\x04\xf4\x99\x61\xdc\xcb\xf8\xa0\x0a\xb0\x67\x78\xc4\x9e\xe1\x95\x67\x68\x68\x72\x1b\x3e\x28\x2c\x7f\x43\x7d\x4d\x05\xbc\xd2\x67\x89\x30\x8e\xe9\x5a\xaf\x4b\x03\xf1\x5e\xa2\xc3\x10\xfb\x3e\x68\x32\x10\x9b\xc3\x60\x32\x6a\x22\x81\xaa\x48\xa4\xf3\x86\xca\x1e\x7a\x82\x47\x1a\x7c\x85\x01\xce\xdc\x83\xaa\xb8\xab\xbd\x9f\x4e\x8b\x5e\x33\x77\xe1\x76\xe7\x2b\xd2\x98\x68\xd4\xe3\x4a\x82\x74\x4b\x1a\xe8\xb2\xac\x8a\x5f\x32\x1b\xbf\xb1\xba\x76\xd7\x4b\x1f\x30\x9c\xf6\x41\x3d\xd1\x0d\x62\x5f\x19\xe9\xae\x76\xac\xd2\x09\xaa\xef\x44\x21\xa8\x35\x16\x0a\x82\xae\x06\x5a\x8e\xe9\x11\x40\xdf\x8a\xa0\x06\x5a\x1b\xbc\x02\xa4\xa7\x29\x4e\x61\xe9\xc4\x1b\x11\x92\x01\x8a\x2e\x4c\x54\x88\x3e\xf6\x65\xa3\x62\xa6\x12\xb5\x63\x7a\xc2\x43\x0b\xa7\xdb\x51\xcf\x71\x08\x36\x0b\xcc\x0a\x66\x85\xa6\x8d\xa3\x75\x61\xd4\x13\xcf\xe0\x8b\x81\x0b\xb4\x0b\xda\x05\x60\x36\xe9\xa1\x11\xeb\x83\xce\x98\x42\xbd\xde\x6c\xd6\x7c\x2b\x9a\x6b\xa0\xed\x18\x74\x02\xe7\x9d\x35\x36\xba\xca\x26\x23\x86\x56\xdb\x81\xfe\x37\x71\x85\x4e\xed\x4f\x23\x14\x88\x42\x86\x6d\xc9\x0f\x57\x8c\x2e\x19\xda\xbe\x6b\xc4\xc3\xde\x6d\x93\x2f\x4e\x19\xbd\x60\x44\x14\x9c\x47\x60\x19\xd1\x61\x4a\x7e\xe7\x89\x5d\xfb\x76\x68\xcf\x97\x4f\xdb\x26\x3e\xd1\xa9\x4f\xcf\x66\xe3\x64\xbf\x11\x51\xa8\x2d\xee\x47\xe0\x4a\x05\x03\x82\x69\x3e\x93\xd9\x6c\xfa\x56\xe4\x81\xcb\xbd\xc6\x0c\x7b\x9b\x4b\xcc\xc8\x64\xf6\x98\xd3\xcd\x93\xcc\x0b\xcd\x6b\xcc\x2a\x0d\x36\x9b\x81\xdb\xed\xf8\x56\x74\x13\x68\x8f\x00\x0d\x83\x35\xe2\x6e\xbf\xb9\x53\xa6\xca\xa1\xcd\x64\x44\x29\x91\x86\xe4\xf7\xae\x69\x04\x6f\x99\x77\xc0\xcf\x82\x0e\xd1\xe9\x3a\x23\x84\xbf\x57\x4c\x59\x99\xdd\xa2\x4b\xd1\xc3\x29\xf6\xc4\xec\x82\x84\x5e\x2d\x7a\x59\x2a\x3d\x4f\x8f\x1d\x56\xbe\x0f\x2e\xe0\x6d\xcf\xa2\xb6\x63\x4b\xb5\x06\x5d\x4e\xeb\x81\xf9\xe2\x04\x5f\xaf\xe4\xee\x79\xb9\xfa\x11\x33\xfa\x77\xdb\xda\x1e\xc5\x4e\xb1\x45\x3d\x38\x87\xe8\x61\x3f\xa3\x1e\x78\x0a\x8b\xb5\x64\x02\x39\x41\x27\x07\xb0\x09\x93\x16\xa9\x8d\xd8\x64\xf2\x98\xd2\x4d\xe4\x0b\x92\x8e\x7e\x19\x12\x43\x92\x34\x5f\x0e\x2a\x42\x27\x2b\x87\x39\x1a\x5c\xe7\x13\x35\x9e\x9a\x45\xa4\x5b\x31\x01\xca\x8b\xae\x79\x16\x7a\xa4\x15\x11\xf0\x9d\xc7\x46\xcc\x89\x78\x4a\xdb\x5c\xfa\x16\x6a\xd0\xf5\x6d\xdb\x46\xc2\x5b\x92\xfe\x41\x78\x55\x9f\x29\xbd\x43\x71\xd9\x8a\xc8\xaa\xd9\xa4\x6e\x37\xc8\x0d\xda\x08\x2a\xed\x0e\x87\xfe\x5b\x91\x73\x38\x80\xc5\x12\xf1\x9d\x68\x21\x34\x75\x04\x08\xf7\xc1\x59\x6e\x13\xff\xc8\xf1\x04\x5b\x14\x59\x79\x2c\x00\x07\xb5\x26\x48\xdf\xca\x13\x0d\x04\x45\x48\x7b\x75\x79\xab\xcc\x19\x31\xfc\xf0\x66\xad\xa3\x1f\x9e\x09\x77\x45\x4a\xaf\xb7\xef\x58\x5c\x32\x52\x70\x3c\x8d\x0a\x5e\xc1\xa6\x9c\xf4\x75\x2d\x86\xb8\xdd\xf0\xd8\x94\x2b\x6d\x07\x0f\x88\xf7\xcd\x59\x22\xf7\xf3\x12\x42\x7f\x5b\xd9\xfc\x5e\xec\x71\x4e\xcd\xab\xf8\xef\x44\x86\x04\x22\xe5\x29\x12\x32\xf3\xc2\x8d\xf7\xe5\x58\x69\xb0\x00\x81\x06\x7d\xaf\xf4\xec\x3a\x29\xcd\x89\x44\x82\x6d\xed\x8a\x62\xd4\x73\x2b\xf4\x9e\x9b\xf2\xe0\x96\x53\x2f\x03\x0c\x3b\xa0\x20\x9e\x48\xe8\x46\x07\x1c\x20\x93\x60\xda\x9a\xe6\xf1\xa8\x8d\x6a\xe3\xb7\xa2\x5a\xed\x4c\x4c\x24\x38\x4f\xa4\x24\xe2\x8c\xf8\x56\x74\xde\xdd\x5c\xf6\xc5\x2c\xa6\xac\x70\x2c\x91\x0e\x10\x67\xc9\x41\x71\xe9\xb5\x20\x47\x6b\xce\x83\x4d\xe6\x58\xec\xf2\xf2\x29\xf4\xbd\xaf\x65\x30\xb7\x77\x6a\xc0\xd5\xb2\x2c\x23\xe8\x2d\x6b\x15\x8c\x7b\x7e\xf2\x83\x89\x3d\x32\x61\xe1\xc6\xd9\x43\x2b\xba\xe6\xb7\x6a\xde\x75\x19\xb7\x2b\xce\x27\x06\x7a\xa7\xf4\x97\xde\xea\x9f\x3a\xb8\xd9\xa0\xb4\x91\x7f\x0c\x79\xc0\x3f\x2e\xdf\x84\x93\x06\x4c\x7a\xb4\x77\x8f\x82\x59\xb1\xd8\xd4\x21\xf3\x81\x47\xf3\x29\x6e\xa4\xe1\xd2\xa9\xfa\x1e\xf5\x0b\xef\x58\xbb\x4a\x98\xa1\x34\x3c\xf1\xad\x44\xe9\xd4\xe9\xd3\x2c\x46\x3e\x5f\x08\x4e\xaa\x56\x01\x2b\xb1\xdd\x78\x8c\xd5\x8b\x4c\x44\x0a\xc8\x76\x1f\xf3\x74\x2e\x24\x33\xff\xf5\x44\x77\xf7\x91\xf1\x69\x6e\x9e\x54\xd8\x5d\x5f\x32\xee\x83\x31\xa3\xb8\xc9\x96\x5e\xd9\xfc\x75\x57\xac\x73\xa4\x7b\x7e\x61\xa9\x2e\x62\x30\xf6\x11\xac\x27\x11\x39\xe9\x64\x7e\x8f\xa3\x83\x46\xe6\xf7\xd8\x04\xb8\x06\xb7\xc7\x61\xe7\xcd\x89\xa4\xf3\x65\xaf\xc7\xe8\x29\x38\x2f\xa6\x2e\x35\x06\x3e\xbf\x59\x7a\x2d\x1a\xfe\xb1\x7a\xf5\x6a\xec\x5e\xcd\x7c\xde\xd5\x2f\xe7\x0f\x21\xa3\x90\xa6\xec\x1d\x74\x07\x0d\x3c\xd4\xe8\x40\x90\x08\x78\xf8\xf8\x10\xc5\xa3\x26\x5d\xf7\x25\x5b\xa9\x4a\xd8\xea\x44\x1a\x11\xa2\x4d\xc2\x73\x09\xa1\xdd\xe4\x04\xcf\x87\x3e\x75\xa2\x44\xfe\x50\x0d\xf9\xdc\x5e\x28\x97\xfb\x08\xff\x22\x8a\x26\xe5\xd2\xf5\xa6\x06\x10\x1f\x34\xe9\x04\x6a\xd8\xab\x16\x69\x55\x2a\xe1\xf1\x21\xaa\xc6\x92\x2d\xb9\xe9\x4a\x00\x28\xde\x17\x70\x28\x35\xc0\xdc\x6f\x90\xf4\xc9\x62\xf4\x46\xb8\x12\x21\x4d\xbf\x5b\xfb\x0f\x5a\x43\x63\xf9\x2d\x49\xf9\x6a\x22\x59\xcd\x20\x29\x68\x31\x6a\x89\x51\xac\x55\x41\xcd\x69\x83\x46\xa3\x7d\x7c\x88\xa6\x29\xec\x2c\x3a\x2b\xad\x83\xa0\x38\x39\xe0\x77\xd8\xc2\xd5\x54\x6f\x46\xbf\x9d\x39\x80\x36\x2f\xed\xdd\x58\x91\x76\xef\x6e\xfd\x08\xe9\x8b\x3b\xea\x82\xf5\x77\xb6\x05\x21\x81\xff\x1f\xda\x22\xd0\x5a\xc2\xd8\x82\x9d\xd0\xe2\x6f\xd1\x37\xd2\x5b\x14\x57\x26\x72\x52\x2d\xd0\xee\xd6\x4b\xf3\x95\x0a\x50\xfd\x7b\xfc\x2b\xc8\xa4\xf4\x81\xf1\x08\x84\x54\x8d\x55\xe6\x81\x28\xa0\x74\x48\x0d\x23\x8f\xdd\x0a\x7d\x1a\x45\xd0\xfc\x4a\x4d\xcd\x0d\x16\x4b\xb9\x7e\x36\x7f\x86\xe1\x18\x83\x18\x42\x09\x3a\x3b\xe7\x54\x9b\xcd\x10\x9f\xd6\x13\x7b\xfb\xac\x8b\x16\xe0\x3f\x6b\x51\x0c\x11\x1c\x2f\x3b\x79\xf4\xd1\x09\x51\xe6\x84\x8e\x2a\x0f\x50\x2e\xf3\x93\xac\x07\x7a\x26\xb4\xc8\x32\x0f\x89\x6e\xdd\x3f\x2f\xa1\x63\xdb\x1c\x57\x46\xa6\x71\x68\x6c\xeb\x3e\xaa\x3d\x0b\xa5\x0d\x49\x89\xbe\x66\x45\xdd\x52\x1c\xb1\x8e\xa4\xc4\x7e\x5d\x93\x19\x4f\x90\xbe\xe2\x5e\x45\x53\xf9\x87\x09\xcd\x44\x10\x9e\xa0\x06\x04\x17\x74\x6a\x81\xce\x2d\x84\x31\xe0\x53\x0e\x34\x75\x51\xb3\xe8\x8f\x3a\xb3\x23\x8b\x7f\xf8\xcc\x83\xe4\x73\x86\xea\x36\x5b\xb8\x03\x78\x31\x7f\x83\xc8\x50\xe3\x11\x9d\x6a\x11\x5d\xba\x91\xe9\x62\xf3\x04\x61\xfb\xd1\x9f\x49\xdf\xd4\xc2\x8f\x9e\xdc\xaa\xda\x8e\x5f\x38\x9d\xb9\x3d\xe5\x13\xee\xc0\xec\x85\x09\x89\x19\x4f\xbe\xb9\xf3\x49\x8a\x83\x17\xf9\x8f\xe1\x3f\x95\xbe\xb1\x12\xed\x46\xcd\x2f\x52\x0b\x54\x49\xba\x20\x07\xe0\x62\x3d\x41\x07\x01\x1c\x8c\x16\x5f\x43\xdf\xc8\x0d\x96\x7b\x60\xef\x42\xf9\x7d\x1a\x29\x03\x71\x0d\x65\x70\x9c\x0a\x2e\xa2\x3e\x83\x1b\xca\x60\x94\x49\x5f\xce\xc2\x78\x42\x95\x57\x17\xa3\x4d\x28\x31\x2a\xf4\x29\x23\xc9\x64\xa5\x8c\x70\x5f\x38\x09\x07\x27\x7d\xa1\x06\x11\x9c\x5e\x6f\x89\x75\x59\x68\xa3\x64\x0a\x3c\x6b\x3e\x4b\x9b\x76\xbf\x7e\xc0\xac\x0a\x22\xda\xfe\xa6\x1f\xfa\x90\x7a\xeb\x17\x23\xfe\xcc\x5d\x7d\x01\x2b\xf4\x4b\xb4\x8c\x46\x69\xfd\x2d\x85\xbe\xb2\x0f\x33\x90\x18\x34\x9b\xd5\x31\xfa\x08\xa4\x8a\x20\x7f\x51\x02\x88\x52\xcb\x53\x4d\xe1\x69\x4d\x19\x16\x2a\xac\xc8\x71\x7f\x98\x50\x4b\x42\x73\xd2\x6f\x94\x68\x87\xfe\x1d\x5c\x42\x5f\x4a\xc4\xd2\xe4\xbb\x49\x04\x81\x78\x7e\x07\xea\xa0\x7a\x89\xf9\x8e\x31\x1f\x85\x64\xbc\x2c\xe2\xa8\xee\xcb\x66\xfe\xe8\x9c\x05\xa6\x51\xb8\xf9\x9d\xcb\xa2\x97\x8d\xe2\xa0\xee\x92\x4a\x7a\x44\x95\xbc\x42\xfa\x77\x04\x84\xb1\xff\x21\xf8\xac\x26\xcf\xb7\x50\xdd\x22\xcf\x13\xcd\x33\xa8\xd5\x69\x04\x81\x87\x41\x7c\x9a\x68\xac\xae\xcf\x5c\x17\xe9\xd4\x3f\x93\x38\xa4\x20\x36\xa2\xe9\xfc\x17\x74\x91\xd2\x5c\x17\x5e\xe1\x2a\x2e\xa2\x5b\x63\x38\xd5\x84\x15\xd2\xfe\x5f\xed\x2b\x57\xda\x09\x7e\xb6\x12\x3e\x97\xd4\xc0\xe7\x22\x8e\x23\x95\x4a\x2b\x00\xad\x46\x41\x4b\xba\xbf\x09\x3a\x28\xcb\x4c\xf2\x3d\xe7\x93\x7e\x23\x27\x78\x93\x51\x8c\x90\xc6\x5a\xba\x6c\x61\x13\xfe\x6b\x21\xb2\xda\x8d\x75\x7a\x1d\x51\x2a\x89\x4e\xa6\xc3\x7a\xbd\x40\x94\xa0\x22\xd1\x6c\xe2\xd4\x82\xba\x48\x14\x1a\xf9\x71\x83\x82\x13\x7e\xff\x4f\x57\x43\xc8\x1c\xda\x27\x13\x28\xfa\xcf\x3f\x5c\xff\xe8\x14\xe6\xd4\x9d\x7e\x70\xfd\x90\xc7\xb8\x35\x1a\x53\x29\xed\x5a\xbd\x1a\x0e\xa8\x84\x9d\x57\x33\xfb\x89\xda\xbb\x7f\x09\x59\xd6\x24\x5c\x46\xed\x7c\x4d\x77\x68\x63\x71\xdf\xb6\x12\xa9\x57\x01\xf4\x47\x31\xe2\x9a\x59\x92\xfe\x3f\xf6\xde\x03\xbe\x6a\x23\x5d\x1b\x9f\xa6\x72\xdc\xb0\xc1\xf4\x66\x20\x10\x92\x80\xb1\x25\x1d\x17\x42\x73\x91\x02\x84\x16\x3a\xa4\xc0\xb1\x7d\x6c\x1f\xb0\x7d\x8c\xcf\x31\x2d\x8d\xf4\x84\x64\xd3\x36\xbd\x27\x9b\xbe\xe9\xbd\x90\x84\xf4\xb2\xa4\x67\xd3\x37\xbd\xb0\xe9\x85\x64\x53\x88\xf9\x8f\xa4\xc7\xb6\x5c\x20\x64\xff\x77\xef\x77\xef\xf7\xfb\xec\x9f\x66\x5e\x8d\x66\xe6\x79\xa7\x68\x9e\xf7\x95\x74\x24\xb2\x8f\xf7\x12\xf7\xae\xf9\xb5\xcb\xe9\x32\x5a\x9b\xa5\xf9\xe5\xfc\xfc\xc5\xbb\xca\x7f\x23\x2d\xfa\x43\xf9\x6f\xa2\x13\xfe\x48\x7e\xf6\x24\x2b\xdf\xf1\x86\xa7\xbf\x25\xf5\xef\x3d\x25\x4d\xf0\x09\x53\x52\xd2\xa6\x4e\x60\x7e\x33\xb2\x64\xc9\x5d\x95\xbb\x9c\x4e\x69\x2d\x57\xe8\x96\x2b\xdc\xcd\x72\x37\xd2\x3d\xff\x2d\xbc\x9b\xe8\xbe\xbb\xc4\xfb\x50\x96\x4b\xd5\xc6\xca\x72\x2b\xfc\xf1\x71\xaf\x5c\x78\xed\x1b\x40\x23\x5e\x7f\xd0\xec\x60\x7f\xb8\xf9\x0f\xf2\x70\x56\x60\x7c\xc6\xf8\xfd\xe7\x96\xf3\xf3\x8f\xec\x9c\x3f\x2d\x90\xff\x46\x3a\xf4\x77\xf3\x97\x05\xf2\xdf\x44\xb3\x7f\x37\x7f\xaa\xb6\x6f\x5b\xfe\xcb\x68\x5f\x1a\xcf\xd2\x64\xfb\x47\xed\x78\xc3\x6d\x37\x65\xfd\xdd\x76\xf7\xe7\x23\xbb\xb4\x7b\x7a\x87\x76\x0c\x70\x71\x82\xe5\xb2\xdd\x72\xd9\xdd\x94\x4b\xed\xd0\x1e\xa5\x73\xb9\x9d\xe2\x4d\xe9\xd0\xae\xac\xdd\xc2\x3b\x5c\x96\x5b\xe6\x95\x5b\x8d\xf3\x27\x84\xf1\x29\xc6\xf9\x43\xfb\x07\xfb\xc3\xcd\x7f\x52\x7b\x7e\xd9\xae\x25\x98\xdf\xa1\xd6\xfe\xdb\xbb\x73\xfe\x40\xfd\xb2\x3d\x63\x7f\x37\x7f\x6d\x20\xff\x4d\xae\x1e\x7f\xa0\xfe\xcb\xe8\x3e\x68\xb7\xd5\xda\xee\x21\x6e\xbb\x87\xf0\xbd\xbb\xb4\x3b\xda\xa1\x1d\xe1\xce\xe5\xd0\xcf\x5d\xcb\x75\x6c\xcf\xf0\xdd\xc6\x5b\xd6\xa1\x5d\x23\x77\x0b\xcf\x5d\x5f\xab\xb4\x21\x3d\x47\x91\x19\xee\xb8\x90\xd5\x64\x0d\x5d\x41\xf4\xdb\x59\x2f\xe6\x66\xc3\xb3\x24\x8b\xc4\x46\x65\x89\xcc\xbb\xc7\x94\x5e\x43\x7a\x2c\x5b\x32\x44\x0c\x1c\x30\xa0\x77\x5f\x4e\xd4\x65\x4b\x48\x6f\xf7\xa1\x3e\xff\xce\x7d\x96\xe7\xe7\xd3\x76\x3f\xbf\xc0\xfb\x4a\x6d\x86\x7b\xe9\x60\x20\x35\xd5\xe0\x27\xdd\x09\x7d\x72\xd9\x39\x63\xce\x29\x5f\x71\xe4\x59\xf9\x47\xf6\xa6\xb3\x97\xce\xba\x7a\x6d\xf6\x15\x0f\x3d\x5d\x7c\x4f\x76\x4f\x31\x7f\xcb\x51\xa7\x9f\xd8\xe7\xd8\x49\x2d\xdf\xb5\x2c\xda\x7f\x5a\xa2\xe1\xe5\xed\xec\xe4\xba\xa9\xd5\x4b\x57\xde\x5a\xb9\xfd\x61\xa1\xd3\x89\x67\xcd\x3b\xf2\xb0\xf3\xce\x5f\x98\xf8\xed\xa0\x96\x47\x5b\xde\x80\x8e\x4f\x7a\xdf\x66\x1b\x31\x25\x2b\x2b\x25\x23\xbb\x07\xe7\x0a\x51\xa4\x7e\x19\x3d\xdd\x6f\x5e\xb7\x7e\x30\xd0\xf4\xae\x67\x51\xff\xf3\x80\x05\x93\xdd\xdb\xac\xee\xcd\x59\x2a\x95\x35\x25\x73\xae\x99\x37\x71\x88\x31\xba\x74\x52\xef\x9e\x2d\xd7\xf5\x49\xbb\xfe\x7a\xaa\xbe\x43\x4b\xd3\xfa\x9e\x7f\x43\xcb\x7b\x45\x2d\x8b\x32\xce\x4b\x2d\xab\x3f\x44\xac\x78\xa2\x68\xfb\x59\x8a\xfd\xeb\x9b\x17\xae\xe1\xd9\xbf\x84\x5b\xfe\x21\xf1\xeb\x65\xff\xbb\x7d\x34\x92\xe4\x4e\xe9\x37\x58\xf6\xd1\x60\x31\xa0\x7f\xff\xde\x7d\x45\x6f\xd1\x9b\xa0\xa7\x7a\xb5\x3e\x9f\x56\x8c\x8f\xc1\xb9\xbd\xa5\xb4\xf6\xd6\x64\xda\xda\x5b\xd2\x70\xee\xd9\xcb\xec\xd8\x59\xdf\xde\xf3\x50\xfa\xbd\xe9\x6f\x1c\xfd\x70\x6e\x5e\x6b\x67\x0d\x7f\x68\x56\xf8\x9e\x51\x62\xfe\xb3\x47\xca\xbe\xb2\xf6\x6d\x79\x36\xfb\xd4\xb3\x87\xdc\xf0\xcd\xfb\x3f\xa1\xa7\x6e\xa4\x67\xd0\xe1\x9f\xfa\xfd\xd4\xf2\x7d\xcb\x2b\x2d\x4f\x10\xd6\x72\x07\x59\x41\x0b\xe5\x39\x9c\x42\xb2\x49\xaf\x5b\x33\x42\xf7\xd3\x7d\xa5\xaf\xc4\xe9\x44\xcf\xc1\xf6\xbe\xa7\xd4\xfa\x74\x28\x77\xb5\xc9\x72\x3f\xf0\x45\x0b\x5f\xda\xb4\xfe\xd0\x27\x9f\xfc\xe1\xcf\x93\xc7\x7f\xb4\xae\x7e\x0d\x3b\xf0\xcb\x96\xed\xa7\x1e\xf7\xed\xf6\x96\x8f\x97\xce\x68\x39\xfb\xaf\x8f\xf9\xef\xb6\x8a\x92\xc3\xc9\xa7\xbc\x92\xa8\xa4\xef\xed\xee\xcf\xf6\xee\xa7\x13\xbc\x4b\x89\xfb\xe2\x01\x82\xfc\xbc\x3d\xdd\x47\x3c\x4d\x9e\x9f\x7c\x67\xe0\xd6\x23\x4f\x3f\x9c\x2d\x59\x7b\xca\xba\xdf\x06\xb8\x36\xee\x29\xe4\x70\x6a\x48\xbd\x06\xca\xb2\x69\x69\xa1\x4c\x57\xaf\xfe\xf2\xc0\x04\xef\xc5\x52\xde\x17\x39\x0a\xbd\xe7\xad\x5b\xbf\x72\xe2\xf7\x0d\xbe\x2c\xd7\x72\x4a\xfa\xf2\x8f\x2b\x16\x8d\x2f\x18\x7f\x48\xcf\x0d\x83\x6f\x5d\x9b\x38\xac\xb8\xea\x8c\xe3\x72\xe9\xb9\xbd\x0f\x2f\xdb\x78\xc2\xf8\x43\xcc\x7d\x72\x0b\xc2\x83\x97\xc6\x0e\x99\x3b\xb9\x72\xfe\xbc\x19\xe3\xbd\x77\x06\xb7\xfc\x45\xf6\x85\x25\x31\x47\x13\x63\x4a\xef\x91\x59\x59\x3d\x87\xf6\x1c\xd7\x73\x72\x4f\xae\xf7\x1c\x38\xb0\xa7\xce\x79\xbf\xa1\xae\x16\xa9\x6d\xbd\xe3\x7f\xbc\xe7\x60\xf7\x09\xf6\xd6\xcf\x75\xe2\xe3\xcc\xad\x57\x4c\x3a\x7d\xfb\xce\xf3\x86\x69\xea\x03\x97\x1c\x79\xea\x79\x1b\xe7\x45\xae\x99\x3c\xc2\xac\x5a\x70\xe8\xe4\x85\x3d\x4e\x1a\x22\x75\xdc\xd0\x10\x5d\x3a\x87\xd6\x24\x36\xd6\x2e\x49\x19\xa0\xae\x98\x31\x65\xc9\xca\x7d\x0b\xe7\xe5\xe7\xf7\x38\xb8\xee\xa0\xb9\x73\xa3\x59\x4c\x9f\xe1\xd9\xbb\x2d\xa7\xcb\xbe\x19\x29\xfb\xd5\x7d\x6c\x79\xf4\x14\xe9\x7f\x0a\xdd\xbd\x44\x32\xd9\xbd\x48\xa2\x32\xb7\x97\x53\x89\xda\xd6\xcb\x07\xe3\x37\x7e\x81\xab\x23\x3d\xe4\x2c\x37\x2f\x19\x9a\x1c\xda\x52\x9d\x49\xbf\x3a\xea\xc0\x55\x7d\xce\xcb\x7d\xb7\xd7\x80\xed\x74\xd0\xa5\x97\xce\xa7\xdf\xb7\xec\xbd\x8a\xde\x1c\x7e\xb7\x4f\xb6\xec\x93\x2b\x64\x9f\x4c\xe1\x07\xba\x5f\x6a\x9c\x92\xd2\x7b\x40\x96\x3e\x60\xd0\x20\xd1\xbf\xcf\xfd\xd4\x7d\x2c\x48\xb4\x76\x84\xfb\x30\x88\xef\xe5\x65\xfb\x3f\x33\x69\xfd\x4e\xd1\xa8\x8e\xd7\x42\x68\xbf\xa5\xd7\xac\xd8\x70\x22\x3f\x2f\x54\x3e\x69\x51\xc3\xc4\xb2\xc9\x4b\x46\x35\xd7\xd1\xdf\xfa\xb4\x34\x59\x4b\x6b\x9b\x0e\xa3\xd7\x2d\x39\x6b\x6e\x4d\x45\xbf\x7d\xc3\xd5\x0b\xac\x29\xa3\x87\xd0\x73\x9b\x6f\x9d\x5c\xef\xb5\xf9\x01\x12\xa3\x79\x72\x6c\xfa\x7a\xbf\xe2\xca\x1c\xd8\x33\xb3\x77\x4e\xef\xbc\xde\xbc\x77\x7a\xef\x74\xde\x23\xc5\x1d\x98\x61\xed\x03\xe3\xfd\x78\xa6\xb8\xf5\x2b\x0b\xf8\x4c\x36\x9e\x44\x69\x7f\xaa\xa1\xf5\x33\xa9\xe9\x8f\x9c\x73\xc4\xfa\xaa\x7b\xd6\x3f\xd9\xe7\x94\xf4\x43\x66\x25\xfa\x0d\x5e\x31\x35\xd6\x7c\x56\xc9\xe4\x39\x07\xee\xbb\xef\x01\x55\xf4\xc2\xe3\x6e\x3c\xed\xc8\xb3\x3f\x5e\x77\x7e\xff\x19\x87\x1e\x3e\x3c\x3f\xb6\x72\xfc\xd8\x43\x0e\x08\x4f\xac\xf4\xe6\xb8\x4a\x0e\xa3\x15\xfc\x20\xf7\xd9\xf4\x4d\x84\xca\xae\x57\x64\xd7\x8f\x77\xb5\x90\xb3\xbb\xfd\x9a\xcc\xb4\xb3\x06\xdd\xfb\x74\x8b\xdd\x87\x39\xbd\x4e\x3a\xbb\xf2\xb0\xb3\xe9\x88\x7b\xe3\xcb\x0f\xdd\xf4\x8a\xeb\x3f\xb4\x5c\x2b\xfb\xb8\x58\xb6\x6d\x80\x5c\x2d\xc6\xb9\xad\x0b\xf5\xdd\x6b\xaf\xa1\x23\xc6\x8d\x98\x3c\x82\x8f\x18\xc1\x07\x67\xb9\xad\xcb\x0d\xb4\x6e\xdc\xc1\x58\xb6\x5a\x1f\xdd\x9e\xec\x3f\x64\x19\x98\x65\xbc\xfd\x33\xb0\xbc\xed\x6a\x0d\x0d\xdd\x7d\xc5\x11\x1b\x0f\x3f\x90\x4e\x9a\x74\xc0\x99\x07\x26\x8e\xa9\x5d\x52\x32\x67\xf9\xda\x19\xf3\x27\x17\xcd\x9e\x9b\xe7\x94\xce\x8d\x9c\x70\x07\xad\x48\x1c\x77\xc8\xc2\x45\xeb\xd3\x58\xfa\x6c\x6b\x42\xcd\xf8\x03\x67\xda\xf1\x4c\xa6\xcf\xa1\xd9\xf3\xa7\x4c\x1a\x93\x5b\xde\xf2\xf5\xb8\xfc\x59\xe5\xd5\xde\x98\xdc\x8a\x31\xe9\x27\xc7\x64\xcc\x94\xac\x41\xbd\xfa\x0c\xed\x33\xae\xcf\xe4\x3e\x3c\xbd\x4f\x7a\x1f\x9e\x29\xd7\x92\x89\xde\xa0\xec\x1b\x18\x94\x2c\x6f\x54\x70\x75\x88\xb5\x4f\x95\x42\x6f\xde\xb4\xfe\xcc\x43\xea\xdb\xf2\x9e\x3b\x2a\xaf\x3c\x52\xbd\x2e\xe5\x64\xdd\xd9\x67\x56\x53\xdb\xb0\x1c\x70\xe0\xda\x03\x2a\x59\x91\x3b\x2a\xdf\xef\x20\x0b\xf6\xef\xbf\xd7\x9e\x6b\xdd\x71\xa9\xdf\x37\xef\x90\xf9\xf1\x65\xbe\x4f\xc8\xa5\x0f\x73\xb5\x36\xc0\xbd\x6e\xed\xfa\x95\x19\x19\x74\x73\x9a\xee\xf9\x95\xbe\xbf\xe1\x5f\xf1\xf0\xbd\x64\xf7\x51\x8a\x67\xdf\xe0\x2d\xdb\x97\xb3\xb9\x22\x76\x1f\xdb\x51\x2b\x68\xf6\x16\x6d\x40\xda\x2d\x29\x37\x67\x5f\x77\x5d\x36\xcd\xf0\xeb\xdc\x5f\xd6\xb9\x1c\x75\x4a\xf2\x4c\xc9\x60\xf2\x5f\x69\xab\xd7\x73\xef\xbc\x13\xcd\xbd\x00\xd1\x56\x75\x3d\x5b\xbe\x99\xbd\xc1\xc6\xb7\xd7\xac\xd6\xa6\xdc\x92\xd6\x72\x29\xaa\x66\x3b\xc6\xc8\x7a\xeb\x64\xbd\x99\xee\xd7\x61\xa7\xa4\xf7\xc8\xe8\xdd\x3f\x43\xfe\x33\x6d\x73\xdf\x5e\x5e\xd5\x46\xe0\x89\x18\xab\xfd\x9a\x95\x5b\xbf\xe1\x5e\x55\x41\x1b\x5a\xc2\xc6\x18\x6d\x72\xe9\x09\xf3\xf7\x15\x13\x7b\xcc\x2b\x0d\x00\xde\x33\x24\x73\x4a\xf6\x1c\xa3\xb4\xef\xac\x57\xda\x1a\xc4\x76\x1c\x29\x71\x8b\x24\x6e\x7f\x32\xdc\xf5\x5a\x07\x0c\xe9\x19\x92\xe7\xf9\x10\x32\xbc\xb7\x92\xbe\x79\xd0\x70\x17\xfa\x6d\xe3\x31\x6f\xdc\x32\x1f\xf3\xd1\xfd\x77\xf2\x77\xf2\x56\xa5\x0a\x72\x15\x97\x9d\x49\xe7\x8e\x98\x32\xa1\x68\xe0\x58\xb3\x93\xb7\x3a\xb0\x78\xee\x2b\x57\x5e\xc8\xbe\x7c\xf4\x0e\x76\xa1\xba\x58\x7a\xaa\xed\x1e\xeb\x9c\xe9\xa3\x1b\xcb\xd2\xfe\x74\x5a\x8a\xd4\xe7\x1a\xa9\x4f\x7f\xaf\x7f\x7b\x49\x2f\x31\x53\xa4\xa4\xd0\xcd\x19\x2a\x06\xed\xb1\xd6\x6b\x48\x85\x7d\xdd\x65\xd6\xf4\x3e\xa4\xe1\x5e\xa0\x18\xf8\x01\xfb\xf9\x68\x36\xf6\xf0\x93\x57\x8a\x65\xf3\x6f\x09\xaf\xcc\xbb\x4f\x8e\xdc\x99\x29\xef\x1f\x1e\x4f\x2f\x2f\x3c\xf4\xb0\xc3\xfd\xb1\xeb\x54\x37\x4d\x49\x51\x3a\xd5\xed\x0d\x1b\xef\x58\x77\x11\x3b\xfa\x61\xf6\xc1\xe8\x40\xdd\xea\xf1\x29\x67\xa6\xb5\x9c\x1c\xa8\xbc\xbd\xee\x74\x32\x98\x0c\x9b\x92\x31\x70\xa0\xde\x33\x33\xb3\x37\xd9\x9c\xe2\x5e\x9c\x21\xe3\x8c\xcc\xc7\x8c\x01\xde\x55\x3c\xef\x92\x46\xaf\x0e\x10\x3c\x30\x9e\x92\x32\x8c\x9b\x03\x58\x63\xe5\x78\xea\x93\x4b\x4f\x5c\x38\x6f\x44\xea\x3c\xe5\xaa\x56\x4c\xda\xcb\x1b\xcd\xc2\x89\x85\x12\xfb\x22\x89\x5d\xe8\x61\x8f\x74\xb1\x87\xf4\xc9\xc8\x10\xc3\x7a\xf5\x97\xd8\x1b\x3c\xec\x01\xcf\x1a\xfe\x20\x7a\x8d\xec\x88\x5d\xe8\x8d\xa6\x7f\x23\xac\x6d\x30\x6f\xad\x8c\x2f\x50\x66\x96\x9d\x90\xbb\x60\xe4\x39\x25\x23\x4a\x26\x14\x0f\x9c\x33\xe4\xc0\xa1\xb1\x45\x7b\x94\x4e\x2c\x1c\x90\x97\x9f\x7a\xd0\xc0\xf0\x01\xca\x55\x15\x4b\xd2\x46\xef\x33\x6f\x79\xcd\x5b\xbd\xfa\xf4\x9a\xb0\xa8\x4c\x86\x43\x07\xdb\x85\x43\x7c\x7e\x7a\x59\xdc\xca\x56\xab\xa3\x76\xfb\xdc\xbb\xb8\xcb\xb9\xa7\x8e\xea\x7c\xee\x0d\x90\x75\x1a\xa8\xd3\x35\x5c\x55\x26\xff\xe5\x10\xa6\x74\x73\xee\xf5\x75\x9f\x03\xf2\x2a\x9f\xe0\x9d\x7b\x8f\x6f\xb9\x41\xd4\x3e\xc0\xb6\xc7\x84\x92\x94\x67\xde\xbc\x96\xef\xdc\x9a\x7d\x5d\xbf\x90\xf5\x2e\x51\x9b\x49\x96\xfb\x0d\xdf\x29\x19\x7d\x06\x64\xc8\xff\x6c\xc1\xe4\xc9\xd7\x2f\xdb\x3f\xf9\xdc\x71\x43\xfd\xc1\xb3\xcf\xbf\x62\xcc\xdb\x9b\xf1\x9c\x3d\xa9\x30\x75\xe6\xa2\x1b\x66\x2d\xd2\x0f\xec\x39\x69\x6c\xa0\x39\xca\xaf\x23\x7b\xcd\xe9\xb7\xcc\x3c\x20\x75\xd4\x21\x7c\x60\xcb\xd6\xc0\x39\x38\x51\xe2\x8f\x54\xbf\x26\x21\xef\x4b\x8c\x99\x2a\x19\xd4\x2b\x45\x12\x7b\x8a\x18\xda\xa3\xef\x66\x5d\x74\x73\x0e\xf6\x6a\x6b\x5d\xf7\x67\xe3\x82\xb6\xd6\xd2\x96\x9d\x9e\x8e\xca\xcb\x7e\x27\xd0\xda\xce\x67\xa3\xd4\xa9\x41\xea\x34\x46\xfd\x86\xa4\x49\x4b\x50\xf6\x75\x7a\xba\xc8\x9c\xa2\x85\xc4\x06\xe2\x5d\x3a\x6f\xbd\x34\xd7\xcb\xfd\xd6\x9c\x89\xcb\x84\xbc\x70\xa4\x1c\xd5\x23\x0f\x3f\x8b\x36\x6f\xba\x6f\x7c\x73\xfe\xcb\xb7\x0a\xaa\x3c\xaf\xb4\x5c\x2a\x6e\xbd\xe0\xa8\x01\xe7\x9f\x7f\xfa\x55\x74\x5a\xf6\x07\x83\xdf\xf0\xda\x1c\x97\xf5\x87\x64\xfd\xe9\xee\xdb\xf2\xa6\x84\x32\x32\xb2\x36\x6b\x29\x81\xea\xdb\xcf\x92\x6c\xfc\x5e\x84\x8f\x94\xa3\xaa\x1d\x75\xd4\x19\xcd\xf7\x45\xd6\x0c\x69\x1e\xf7\xda\xb4\x96\x1f\x94\xe7\x6f\x14\xe2\xd6\x8b\x36\xf6\x38\x7f\xc6\xcc\x53\xaf\xa1\xd3\xde\x18\xfc\x81\x3f\xa6\x9e\xfe\x21\x6d\x1f\xa9\xbf\x77\x3d\xb0\x47\x36\xd9\xac\x91\x81\x68\x80\xec\xcd\x2c\xd3\x3d\x1d\x3b\xb5\xa0\x57\x97\xa1\x0d\xb4\x26\x6d\xbe\x77\x5b\xe0\x95\xfa\x65\x7a\x63\xef\x99\x05\xed\x8d\xfa\x30\xb7\x5f\xe5\x90\xd5\xd3\x0e\x4a\x1d\xdd\xc0\x87\x93\xb6\xbe\xfb\x5a\x62\xfb\xe7\x63\x6f\xd9\x7b\xc3\xb2\xbc\xf3\x51\xc3\x35\xd6\x8e\xe7\x63\x40\x83\x6e\x2f\x05\x06\xb4\x28\xf1\x2e\x05\x9a\x59\x5d\x2e\x05\xb6\xeb\x73\x58\xd7\x0b\xc6\x94\x96\x2b\x57\xb3\x27\xd4\x8b\xfc\xe7\x0e\xbd\x4e\x70\xef\x94\x78\x5d\xca\xe6\xb4\x6c\x53\x65\x47\x2a\x57\x7b\xdd\x47\xc9\x4f\x72\x3d\x79\x41\xbd\xb0\x63\xde\x5e\xde\xe8\xfe\xe4\x0e\xa9\xda\x72\x99\x72\x95\x37\x92\x94\xdc\xa2\x5c\xc5\xa7\xab\xd7\xca\xb9\x9b\x71\x87\x08\x6d\x50\xdb\x9e\x6f\xf3\xc8\x4f\x9e\xe3\x23\x4d\x3e\x5d\xc4\x36\xb3\x96\xdf\xe4\x69\x30\xe6\x4a\xe5\xde\xec\x8d\x1b\xb3\xbf\xf6\x7c\xc8\x77\x64\xd9\xb5\x28\xab\x89\x0d\xee\xd3\x97\x28\xdb\x76\x49\x91\xcd\xbd\xf2\x05\x5c\x4e\x54\xae\xfa\xda\x2d\x4a\x18\xf9\x58\x79\x8e\x17\xa8\xc7\xe3\xf9\xb8\x90\x42\xdd\x7b\x25\x82\x9c\x25\xdd\x02\x5c\xdc\xc3\x95\x7f\x16\x77\xef\x2a\xbc\xbc\xc7\x55\x7b\x28\xcf\x79\x57\xfb\x29\x39\x4f\xb9\x86\x9f\xad\x5e\x2a\xed\x95\xec\xbb\xb3\xd3\x42\x4a\xda\x86\x2c\x2c\x91\xb8\x3c\xdc\x7a\x3a\x05\xd7\x43\x76\xe1\xde\x33\xa7\xda\x23\xf6\x18\x37\x20\x3e\xea\xd0\xa5\x63\x66\xee\x57\x36\x2c\x37\xb7\x67\xe3\xd0\x29\x4b\x95\x6b\x46\x8e\x1d\x39\x76\xfa\x31\xcd\x32\x9a\x5c\x14\x59\x5e\xe8\x3d\x7f\x27\xdb\xf5\xb5\xd7\xd7\xa9\xb2\x65\x3a\xdf\xa0\x02\x42\xf6\xe2\x64\x77\xe5\x33\xbd\xf0\x05\xf1\xad\xdb\x95\xbf\xf9\x91\xec\xd1\x0f\x07\xbf\xe9\x6e\x5e\xdf\x3c\x25\xeb\xa8\x50\x2f\xf1\xaf\xcd\x2b\x58\xc7\x71\x6d\x1e\xcb\xb7\x77\x56\xd0\x8f\x8e\xbe\xa0\x59\x8b\x1c\x78\xe0\xda\x01\xcd\x63\x9f\x51\xae\x3a\x76\x45\x6a\x78\xc2\x44\x2b\x71\xbc\xac\xe3\x3e\xf1\x32\xfb\x49\x99\xeb\xdd\x1b\xf3\x9e\x4f\xf5\x6f\x45\xb0\x77\xbd\x2b\xaa\xe2\xe5\x23\xbd\xef\x6e\xbe\x2c\x4e\xf0\x9f\xad\xc9\x76\x9f\x59\xfa\xe6\xb7\x9a\x1d\x4d\xde\xb3\x37\xfe\x33\x52\x1d\x8f\x6b\xfe\xf1\x6e\x9e\xe1\xf9\x7a\xc7\x07\x3c\xa5\x9b\xf4\x4f\x91\xbe\x58\xa6\xbf\xe8\xd6\xa3\xbf\xe7\x3d\xbb\xb2\xf5\x25\xbf\xfe\xce\xe9\x5f\x3e\xd4\x9a\x7e\x65\x87\xf4\x2f\x3e\x20\xdd\x3d\x37\xd6\xfd\x33\x52\xd2\xdb\x9c\xd6\x72\x24\x3f\x79\xc7\x57\xde\x3d\xce\x11\xd2\xa2\x76\xdf\xbf\xb9\xcf\x94\xbe\x13\xcc\x81\x03\x8b\xc9\x30\x3a\x65\xd8\x65\xc3\xd8\xb0\xde\x63\x43\xa1\x1e\x7b\x4e\xe4\xdc\x7d\xe6\xd0\xfd\x51\xe4\x63\x07\xaf\x32\xe4\x5a\x2f\xbb\xb9\x6f\xe0\x05\x03\xc1\x17\x0f\x68\x3b\x79\x09\x41\x30\x5d\xeb\x65\xf2\x69\xb9\xc3\x87\xe7\xe6\xe5\xe4\xe4\x7d\x9a\x9b\xe3\x09\xb9\x17\xcb\x60\xdc\x38\xb9\xc3\x16\xe7\x0e\xcf\xc9\xcb\x93\xd2\x5e\xb9\x39\xc3\xc6\xc9\x9d\xdc\xd7\xa6\x36\xec\x57\xe1\xe7\x1f\x37\x6c\x78\xae\x57\xf6\xe6\x9c\x5c\xaf\xe8\x37\xc3\xc7\x8e\x95\x59\x72\x6f\xc6\xb1\x5c\xda\xd0\xe2\xbe\xbf\x5c\x90\xd9\x2d\x1b\xf8\x6a\xd9\x46\xee\xfd\x0a\x6e\xa8\xb4\x1b\x33\x39\x19\x3c\xa8\x17\xe9\x4f\xa7\xf4\xbf\xac\x3f\xeb\x9f\xee\xde\x89\xf1\xda\x64\xba\x83\xdf\x57\xba\x60\xbb\xd2\xb9\x8a\xee\x97\xdd\x72\x0f\x3b\xa1\x5b\xf5\xc2\x2b\x26\x75\xaf\x48\xbb\x1e\x9a\x5c\xcb\xdd\xb7\x9e\x8e\x9d\xd2\xef\x05\x42\x55\xc6\xc8\x06\xce\x87\xe5\xf4\x25\x83\xe9\x94\xc1\x97\x0d\x66\x83\xb3\x52\xdb\xf4\x29\x96\xeb\xbc\xec\xf1\x83\xdd\x85\xc5\xbb\xec\xaf\xed\x4a\xb3\xab\xfa\xc7\x7b\x4b\xe5\x56\xf6\xa3\x8f\x74\xab\x5c\xcb\x17\xcd\x2b\x56\x34\xdf\xde\xad\x82\x8c\xcc\xd8\xf1\x85\xb8\x5b\x1d\x28\xb5\x73\x7f\x4a\x5c\x90\xcb\xf6\xcc\xe0\xee\x0f\x51\x4d\x63\x12\xe3\xbd\xdc\x4f\xe6\x6a\x19\xdc\xfd\xd4\x54\xe1\x24\x5e\xc8\x47\x15\xee\xa1\x68\xa3\x78\xa4\x67\xcf\xb1\xc5\xbd\x67\x9d\x7b\xc4\x41\xbd\x32\xb5\x70\xe5\xcc\x03\x0e\x5b\xb2\xef\xc3\x9f\x39\xa9\x7b\x1a\x99\xbd\xfb\xd6\x9c\xfb\x68\xa2\xe9\xea\x8a\x81\xfd\xfb\xc6\x2f\x7c\xb0\xe6\x2d\x7d\x18\x7d\x88\x0e\x1c\xf4\x2a\x7d\x6d\xc1\x19\x89\x85\x03\x07\x1c\xd0\x74\xe6\x81\x33\x8e\x59\x5e\x58\xb0\xec\x18\xfe\x44\xcb\x03\xcb\xb3\xc6\x1f\x7f\x69\xa4\xe1\xae\x63\xa6\x96\x1f\x79\x77\xa2\xf1\x96\x13\x22\xc3\xe8\xf8\x50\xc3\xa6\xf9\xc7\xce\xf3\xb8\xea\x37\xd9\x89\x2f\x28\xf3\xbc\x71\x24\xee\x19\xea\x3e\xd4\x3a\x0c\x9b\xb8\x7b\xfb\x94\xfe\x7c\xf3\xaf\x63\x5f\xba\xec\x5e\x9a\x79\xaf\x0c\xb2\xee\xbd\xec\x25\xf1\xca\x91\xbf\xdc\x28\xc6\xbb\x8f\x91\xba\x9b\xff\x1c\xeb\x09\xb2\x9d\xd7\x7a\xf5\x8c\x40\x3d\x1c\xee\x5f\xa1\xac\x28\x83\xf7\x1e\x61\x15\xb8\xbf\xb0\xf3\x1f\x0f\xed\x25\x4e\xdb\x7e\x4f\x7f\x3e\xf5\xb7\xdc\xe3\x32\x16\x54\x1e\x73\xcf\xe0\xf5\x77\x5e\xa5\xa5\xa7\xea\xd7\xf7\xd6\xf8\xbc\x7b\x57\x9f\xb9\xb1\xc7\x29\x12\xa5\xe5\xd3\xdf\xe6\x4e\x35\xe7\x3b\x77\x5c\xc4\x12\xdb\x6f\x1c\xbe\x7f\x59\x9e\x96\x7a\xdc\x5e\x8d\x07\x27\x8f\x9c\x30\x8b\xbd\x48\xbc\xbf\x21\xb4\xc1\x7d\x16\xc1\xfb\x5b\x48\x6e\x82\x4c\x49\x0f\x3a\x12\x32\x93\x0e\x71\x19\x64\x4e\x06\xd0\x0d\x90\x05\xe9\x43\x9f\x86\xac\x90\x0c\xda\x02\x59\x25\xbd\x59\x31\x64\x8d\xac\xe7\x36\x64\x9d\x64\xf3\xcf\x20\x4b\xd6\x10\x83\x21\xa7\xd0\x84\x96\x0d\x39\x95\x0c\xd2\x1f\x81\x9c\x46\x72\x43\x13\x21\xa7\x93\x70\xe8\x75\xc8\x19\x64\x40\x4a\xb9\xd4\x84\x0a\xf7\x0a\xef\x0d\x9e\x56\xae\x4c\x65\x5b\x14\xc8\x8c\xa4\xd1\x30\x64\x4e\x2c\x3a\x1d\xb2\x20\x63\xe8\x85\x90\x15\x32\x88\xbe\x07\x59\x25\x7b\xb3\x74\xc8\x1a\xd9\xc6\x66\x43\xd6\xc9\x68\xbe\x19\x72\x88\x0c\xe2\x3b\x20\xa7\xb0\x4f\xc4\x18\xc8\xa9\xa4\x48\x3f\x11\x72\x1a\x39\x48\x7f\x17\x72\x3a\x59\x11\xaa\x83\x9c\x41\xac\x94\x0c\x52\x4e\x62\xa4\x46\x6e\x49\xb9\xad\x27\x51\x52\x45\x72\xe4\x16\x91\xfb\x11\x29\x55\x92\x38\x69\x24\xeb\x48\x93\x97\xab\x56\xa6\xe6\x90\xd1\x32\x75\x2f\x19\x1b\x24\x4f\xce\xff\x3c\x29\xed\x27\x73\xc5\xe5\xf1\x3a\x59\x3e\x87\x94\x49\xb9\x49\x96\x72\xc3\x88\x57\x6f\x9c\x34\x90\x5c\x69\x80\x96\xfd\x6e\x6d\x86\x94\xe6\x42\x8b\xa9\x5e\xe9\x31\x52\x9a\x26\xcb\x57\xca\x1a\x48\x79\xac\x26\x96\x8c\xad\x8f\x56\xe5\x54\x45\x92\x91\x9c\xca\x78\xe3\xba\xa6\x58\x4d\x6d\x32\x67\x74\xe5\x5e\x39\x46\x5e\x7e\x5e\xce\x7e\xf1\x78\x4d\x5d\x34\xa7\x2c\xde\xd4\x18\x6f\x8a\x24\x63\xf1\x86\xdc\x94\xb2\xce\xd9\x8c\x9c\xb9\xb2\x8a\xa9\x91\xe4\x98\x9c\x69\x0d\x95\xb2\xde\x19\x52\xa1\x0a\x09\x1b\x54\x38\x87\xcc\xf4\xe2\xb8\x3c\x1c\xab\x88\xfa\x95\xe5\xcc\x8c\x37\xc8\x84\x69\x5e\xf7\xd4\xc9\x9c\x95\x72\x27\x19\xa9\x8b\xc9\xb8\x84\x24\xe4\x6e\x54\x16\xa9\xf2\xaa\xca\x21\x63\xe5\xf6\x3b\x55\x97\x24\x2a\xa3\x0d\x55\xd1\xa6\x9c\xb1\x39\x5d\x50\x76\x5d\x34\xa7\xa3\x16\x9d\x4a\xe7\xb4\x6a\xb5\xd0\xab\x20\xd1\x56\xdc\x90\xfd\x98\x27\xff\x73\xdd\xb5\x6b\x61\xb4\x29\xe1\x96\x30\x72\xf3\xf2\x72\xf3\xbb\x47\x6c\xc5\x1b\xbb\x33\x3c\x17\x6e\x6c\x2b\x5c\xf7\x3a\xc7\xa4\x02\x39\xde\x84\x4a\x7a\x47\xdc\x0e\xaa\x97\x71\x13\x59\x29\xd3\xe2\xa4\x7a\x97\xc3\x9e\x23\xf3\x45\xbd\x49\x9a\x90\x47\xa2\xde\x5e\x95\x57\xab\x5b\xf7\x02\x99\x63\x9e\x97\x6b\x8e\x57\xd2\x1d\x80\xa4\x87\xd6\xe0\xe5\x9a\xdf\x0d\xe2\x6c\x89\x58\xed\xb5\x23\x1a\xc8\x59\xe9\xd5\xed\xb6\xd1\xaf\x39\x2e\xe5\x5a\x0c\xe5\x0a\xd2\xec\x4d\xdb\x84\xcc\xe9\x96\x6b\x6d\x5b\xc2\x9d\x96\x81\xbe\x8f\x25\x72\x22\x39\xc9\xa6\x48\x55\xb4\x3e\xd2\xb4\x32\x27\x5e\xdd\x71\xaa\xe5\x34\x45\x6b\x62\x89\x64\xb4\x49\x26\xc6\x1a\x72\x16\xe4\xce\xcb\xcd\x99\x13\x49\x46\x1b\x92\x39\x91\x86\xaa\x9c\xf9\x6d\x05\x67\x57\x57\xc7\x2a\xa3\x5e\x62\x65\xb4\x29\x19\x91\x99\xe3\xc9\x5a\x39\x4f\x56\x34\x37\xc5\x12\x55\xb1\x4a\x17\x2d\x91\xdb\xdd\xac\xeb\xfe\xfc\x6b\x9f\x69\x81\x73\x83\xc8\x9e\x73\x7b\x6c\xb5\xd7\x0f\x33\xbd\xec\xee\x7e\xc2\x2f\x32\x2f\x19\x5d\x1d\xcd\x99\x19\x49\x26\xa3\x09\x37\x73\xa9\xcc\x90\x40\xe7\xfb\x03\xeb\x62\x35\x7b\xb3\xab\x41\xa6\xbb\x83\xb6\x46\x76\x99\xdb\x41\xb5\x9e\x1c\xf1\x06\xbe\xca\xab\xd2\x3d\xe7\x1b\x50\xba\x42\xae\x02\x39\xbb\x04\xcf\x41\xd9\x08\x26\x50\x83\x37\x09\x57\xa3\x45\xab\x81\xe6\x4e\x85\x6a\x2f\x4c\x78\xb8\x0d\x12\x23\x47\xca\x11\x6f\x68\x72\x3c\x6d\xdd\x61\xab\xee\xa4\x45\x8e\x37\xb4\x11\x6f\xa2\xf8\x93\xb3\x5e\x1e\x4d\x7a\x79\x2b\xbd\x49\x5e\xe7\x69\xe8\xae\x7f\xf5\xb2\x2f\x7d\xd4\x0a\xac\x70\x6b\xbc\xf5\xb2\xb6\xad\xfd\x6e\x29\xbf\xef\x67\xc9\x78\xcd\xb0\xe1\xde\x74\xec\xd8\x37\xfe\x34\xaf\xc6\xd9\x98\xe3\xbd\x8d\xb7\x51\xca\x71\xaf\x2d\xad\x3d\x3a\xd6\x1b\x4d\xb7\x3d\x51\x4f\x4b\x57\x8a\x78\xeb\x71\x85\x2c\x51\xe7\xe1\xfa\x7a\xd5\x7a\x93\x39\xe2\x4d\xc5\x28\xa6\x66\xd2\xd3\x3e\x11\x98\xd2\xfe\x04\xce\xf1\x5a\xe0\xd6\x6e\x7b\xda\xba\xab\x70\x14\x3d\xbb\x48\xae\xde\x33\xba\xad\xd1\xef\xbd\xe0\xa9\xe4\x8e\x4c\x9d\xa7\x6f\x22\x50\x77\x83\xa7\x6d\x95\x97\x16\x6f\xeb\x69\x37\x57\x1d\x90\xfc\x16\xd7\x79\x2c\xb1\xb2\x6d\x94\xaa\xbd\x19\xea\xf7\x66\x95\x57\xdb\xd8\x9d\xf4\x77\xb5\xd7\x37\x49\xa0\xc6\x3d\x8d\xaa\xe4\xbf\x3f\xee\xfe\x0c\x8b\xcb\xb2\xcd\xde\x28\xfa\xa7\xbf\x3f\xff\x93\x5d\x7a\x2e\xe2\xf5\x6f\x1c\xe5\x1a\xe5\x11\x17\xcb\xd7\xa5\xde\x3f\x9d\x4b\x23\x09\x79\x7a\xca\x93\xb9\x2c\xde\x9c\x88\x35\x44\xc7\xe4\xac\xa9\x8d\x55\xd6\xe6\xac\x89\x24\x72\xaa\xa2\x89\x58\x4d\x83\x3c\x5c\xb1\x2e\xa7\xe3\xe9\x91\x23\x8f\x46\xe4\x02\xd0\xd0\x10\x5f\x2d\x4f\xae\xd5\xb2\x58\x53\xb4\xba\x29\x9a\xa8\x8d\x35\xd4\xe4\x24\x22\x0d\x89\x9c\x44\xb4\x29\x56\x8d\x2a\x72\x92\xb5\x91\xa4\xbb\x5c\xd4\x47\x93\x4d\xb1\xca\x48\x5d\xdd\x3a\xc9\x67\xf5\x8d\xb2\x68\x85\x24\xb0\x35\xb1\x64\xad\x8b\xdf\x14\x93\x67\xec\xac\xe8\x9a\xeb\x73\x5b\xb5\x91\x6b\x4a\xb5\x5c\xb6\x73\x62\xf5\x8d\x4d\xf1\xd5\x9e\xa2\x63\x13\x95\x4d\xd1\x68\x83\xc4\x8b\x54\x45\x2a\x62\x75\xb1\xa4\xac\xab\x36\xd2\x14\xa9\x94\x2b\x8d\x5c\x6e\x62\x95\x09\x6f\x25\x91\x0b\x48\x4e\x63\xa4\x61\xac\xdd\xdc\x14\x6f\x8c\x4a\x65\x17\xed\x37\xa3\x3d\xa3\x54\xcf\x5f\x85\x12\xf1\xba\xd5\xd1\x84\x97\xbb\x21\x1a\xad\x4a\xb8\xab\x58\x95\x6c\x6a\x9d\x2c\x24\x81\xeb\xe2\xf1\x95\x6e\x93\xaa\xe3\x4d\x52\xcd\xaa\x64\xed\xd8\x80\xde\xd5\xf1\x86\xa4\x2c\x1a\xcf\x89\x54\x55\xc9\xb6\xcb\x0e\x8b\x57\x36\xd7\xbb\xeb\x9b\x5c\x73\x92\xad\xca\x45\x2a\x9b\xe2\xf2\x58\x63\x5d\x24\x29\x6b\xa9\x77\xd7\xb1\x5a\xef\xec\x6f\x24\xe3\xa5\x6f\x35\x4e\xce\x09\xf7\x3f\xd7\x5b\x03\x82\xab\x5b\x25\xd6\xb6\x5c\xcc\x94\x71\xb2\x60\x32\xd9\x38\x7e\xdc\xb8\x35\x6b\xd6\xe4\x46\xb0\xc4\x55\xca\x15\x2e\x57\x2a\x35\xee\xdf\xaf\xd6\x9d\x2c\x8d\xde\xb4\x0e\x2e\x5d\x4d\xde\x04\x71\xeb\xac\x97\x13\x67\x97\xd0\xc9\x75\x8d\x51\x4c\x96\xa6\x44\x6e\x6d\xb2\xbe\xce\x27\x47\x1f\xb6\x75\x15\x6d\x0e\xac\xdb\xad\xe7\xd3\x3c\x49\x7c\x33\x3c\x92\x6a\xc4\x2a\xe0\x60\xfe\xe7\x74\xaa\xc1\x5d\x01\x3b\xf3\x7b\xbe\xcf\xec\x33\x24\x7b\x34\xb8\xd3\xb8\xd9\x5b\xf3\xdd\xb1\x9c\x37\x6d\x46\xce\xec\x46\x39\x4d\x1c\x39\x46\x39\xc8\x30\x26\xa7\xd5\x06\xc8\x77\x0d\x80\x8e\xdd\xe5\xaf\x45\x31\xb9\x9f\xf4\x1a\x9e\xf0\xce\xa4\x5c\xaf\xb3\x6a\xe4\xf1\xd9\x52\xb3\x19\x6d\xdd\x20\x27\x61\xac\x31\x99\xc8\x4d\xc4\xea\x72\xe3\x4d\x35\xe3\x66\x3b\x33\x60\xab\x93\x1d\xdb\x08\x69\x19\xe1\xbe\x17\xa7\xcd\xae\x6f\xfb\x0b\x2d\xf5\x52\x99\xb4\x4a\x85\x7b\xa3\x4b\xda\xba\xba\xb4\x6b\x53\xdc\xcf\xe6\x49\x7b\x35\x43\xfa\x30\x99\x24\x8b\xf4\x74\xaf\xb1\x93\xde\xa4\x8f\xf4\xbf\xfb\x91\xfe\x64\x80\xf4\x50\x07\x91\xc1\x64\x88\xf4\x10\x73\xc8\x30\x32\x5c\xfa\x28\x7b\x90\x91\x64\x14\xd9\x53\xda\x94\x7b\x91\xbd\xc9\x3e\xb2\x7f\xc6\x4a\x6d\xc7\xc1\xb2\x34\x89\x45\xc2\xa4\x80\x14\x92\x22\x52\x2c\x5b\xb8\x2f\x99\x40\x26\x92\x49\xd2\x8f\x9f\x22\x59\xb4\x54\xae\xd7\xe5\x72\x7d\x74\xe4\x7a\x38\x55\x8e\xc0\x74\xb2\xbf\x6c\xdb\x4c\xb9\xa2\xcf\x96\x86\xc5\x01\xd2\x3c\x99\x27\xf5\x5f\x20\xfb\x7b\x11\x59\x4c\x96\x90\xa5\xe4\x40\x72\x10\x39\x98\x1c\x42\x96\x91\xe5\x24\x42\xdd\xb7\xa5\x1e\x4b\x8e\x23\x0f\x90\x73\xc8\x56\x72\x3c\x39\x95\x9c\x4c\x2e\x26\xd7\x91\x2b\x29\x27\x1b\xa9\x20\xc7\x90\x3f\x93\xef\xc8\xf7\xe4\x4f\xd2\x1f\x38\x91\xaa\xe4\x1d\xf2\x2d\xb9\x84\x5c\x4f\x7e\x20\xdb\xc8\x8f\xe4\x0a\x72\x23\x79\x9a\x3c\x29\x7d\x9d\x0a\xd9\xe7\xa7\xcb\x39\xf1\x37\x39\xae\x4f\x91\x67\xc8\xf3\x64\x0b\x79\x96\x3c\x47\xfe\x29\xd7\xa8\x97\xc9\x0b\xe4\x45\x72\xb3\xec\xfb\x6f\xc8\x19\xe4\x55\xf2\x0a\xf9\xbb\x1c\xb1\xcf\xc9\x97\xe4\x24\x69\xa0\xc4\xe4\xda\xea\x4e\xcb\x06\x72\x99\x1c\xa1\x55\x1e\xbb\x24\xe4\x0c\x4b\xba\xcf\x5b\x90\xcf\xc8\x5a\x69\xdf\xaf\x23\x87\x92\xc3\xc9\x61\xe4\x1e\x72\x39\x39\x92\x1c\x41\x36\x90\xa3\xc8\x17\xe4\x2b\x72\x1f\xd5\xa8\x4e\x43\x34\x85\xa6\xd2\x34\xf2\x1b\x69\xa1\xe9\xd4\x7d\x46\x20\x93\xec\xa0\x84\x66\xd1\x9e\xb4\x17\xa5\x34\x9b\xf6\xa6\x7d\x68\x5f\xda\x8f\xf6\xa7\x03\xe8\x40\x3a\x88\x0e\xa6\x43\xe8\x50\xf2\x13\xf9\x99\xe6\xd0\x61\x74\x38\x1d\x41\xf7\xa0\x23\xe9\x28\xba\x27\x1d\x4d\xf7\xa2\x7b\xd3\x7d\xe8\x18\x3a\x96\xe6\xd2\x71\xe4\x17\xf2\x1a\xcd\xa3\xf9\xd4\xa0\x26\xb5\x68\x98\x16\xd0\x42\x5a\x44\x8b\xe9\x78\xba\x2f\x9d\x40\x27\xd2\x49\xe4\x03\xf2\x21\x9d\x4c\xa7\xd0\x12\x5a\x4a\xcb\x68\x39\xb5\xa9\x43\xf7\xa3\x53\xe9\x34\x3a\x9d\xee\x4f\x67\xd0\x99\xe4\x16\x72\x2b\x9d\x45\x67\xd3\x39\xf4\x00\x3a\x97\xce\xa3\xf3\xe9\x02\xba\x90\x2e\x22\xbf\x92\xed\xe4\x23\xf2\x31\x5d\x4c\x97\xd0\xa5\xf4\x40\x7a\x10\x3d\x98\x1e\x42\x97\xd1\xe5\x34\x42\x2b\x68\x25\xad\xa2\x51\x5a\x4d\x6b\x68\x2d\x8d\xd1\x15\x74\x25\xad\xa3\xf5\xe4\x7e\xda\x40\xe3\xb4\x91\xae\x22\x9f\x90\x4f\x69\x13\x4d\xd0\x24\x6d\xa6\xab\xe9\x1a\xba\x96\xae\xa3\xeb\xe9\xa1\xf4\x30\x7a\x38\x3d\x82\x1e\x49\x37\xd0\xa3\xe8\xd1\xf4\x18\x7a\x2c\xb9\x9a\x1e\x47\x8f\xa7\x27\xd0\x13\xe9\x49\x74\x23\x3d\x99\x9e\x42\xff\x44\x4f\xa5\xa7\xd1\xd3\xe9\x19\xf4\x4c\xfa\x67\x7a\x16\x3d\x9b\x9e\x43\xcf\xa5\xe7\xd1\xf3\xe9\x05\xf4\x42\x7a\x11\xbd\x98\x5e\x42\x2f\xa5\x97\xd1\xcb\xe9\x15\xf4\x2f\xf4\x4a\x7a\x15\xbd\x9a\x5e\x43\xaf\xa5\xd7\xd1\xeb\xe9\x5f\xe9\x0d\xf4\x46\x7a\x13\xbd\x99\xde\x42\x6f\xa5\xb7\xd1\xdb\xe9\x1d\xf4\x4e\x7a\x17\xbd\x9b\xde\x43\xef\xa5\xf7\xd1\xfb\xe9\x26\xfa\x00\x7d\x90\x3e\x44\x37\xd3\x87\xe9\x23\xf4\x51\xfa\x18\x7d\x9c\x3e\x41\x9f\xa4\x4f\xd1\xa7\xe9\x33\xf4\x6f\x74\x0b\x7d\x96\x3e\x47\x9f\xa7\x2f\xd0\x17\xe9\x4b\xf4\x65\xfa\x0a\xfd\x3b\x7d\x95\xbe\x46\x5f\xa7\x6f\xd0\x37\xe9\x5b\xf4\x6d\xfa\x0f\xfa\x0e\x7d\x97\xbe\x47\xdf\xa7\x1f\xd0\x0f\xe9\x47\xf4\x63\xfa\x09\xfd\x94\x6e\xa5\xff\xa4\x9f\xd1\xcf\xe9\x17\xf4\x4b\xfa\x15\xfd\x9a\x7e\x43\xbf\xa5\xdf\xd1\xef\xe9\x36\xfa\x03\xfd\x91\xfe\x8b\xfe\x44\x7f\xa6\xbf\xd0\x5f\xe9\x76\xfa\x1b\x6d\xa1\x3b\x18\x61\x94\x31\xc6\x99\x60\x0a\x53\x99\xc6\x74\x16\x62\x29\x2c\x95\xa5\xb1\x74\x96\xc1\x7a\xb0\x4c\x96\xc5\x7a\xb2\x5e\x2c\x9b\xf5\x66\x7d\x58\x5f\xd6\x8f\xf5\x67\x03\xd8\x40\x36\x88\x0d\x66\x43\xd8\x50\x96\xc3\x86\xb1\xe1\x6c\x04\xdb\x83\x8d\x64\xa3\xd8\x9e\x6c\x34\xdb\x8b\xed\xcd\xf6\x61\x63\xd8\x58\x96\xcb\xc6\xb1\x3c\x96\xcf\x0c\x66\x32\x8b\x85\x59\x01\x2b\x64\x45\xac\x98\x8d\x67\xfb\xb2\x09\x6c\x22\x9b\xc4\x26\xb3\x29\xac\x84\x95\xb2\x32\x56\xce\x6c\xe6\xb0\xfd\xd8\x54\x36\x8d\x4d\x67\xfb\xb3\x19\x6c\x26\x9b\xc5\x66\xb3\x39\xec\x00\x36\x97\xcd\x63\xf3\xd9\x02\xb6\x90\x2d\x62\x8b\xd9\x12\xb6\x94\x1d\xc8\x0e\x62\x07\xb3\x43\xd8\x32\xb6\x9c\x45\x58\x05\xab\x64\x55\x2c\xca\xaa\x59\x0d\xab\x65\x31\xb6\x82\xad\x64\x75\xac\xde\x7d\x97\x0f\x6b\x64\xab\x58\x13\x4b\xb0\x24\x6b\x66\xab\xd9\x1a\xb6\x96\xad\x63\xeb\xd9\xa1\xec\x30\x76\x38\x3b\x82\x1d\xc9\x36\xb0\xa3\xd8\xd1\xec\x18\x76\x2c\x3b\x8e\x1d\xcf\x4e\x60\x27\xb2\x93\xd8\x46\x76\x32\x3b\x85\xfd\x89\x9d\xca\x4e\x63\xa7\xb3\x33\xd8\x99\xec\xcf\xec\x2c\x76\x36\x3b\x87\x9d\xcb\xce\x63\xe7\xb3\x0b\xd8\x85\xec\x22\x76\x31\xbb\x84\x5d\xca\x2e\x63\x97\xb3\x2b\xd8\x5f\xd8\x95\xec\x2a\x76\x35\xbb\x86\x5d\xcb\xae\x63\xd7\xb3\xbf\xb2\x1b\xd8\x8d\xec\x26\x76\x33\xbb\x85\xdd\xca\x6e\x63\xb7\xb3\x3b\xd8\x9d\xec\x2e\xf2\x3a\x79\x9f\xdd\x4d\xde\x64\xf7\xb0\x7b\xd9\x7d\xec\x7e\xb6\x89\x3d\xc0\x1e\x64\x0f\xb1\xcd\xec\x61\xf6\x08\x7b\x94\x3d\xc6\x1e\x27\x6f\x91\xb7\xc9\x3f\xc8\x7b\xe4\x0d\xf2\x2e\x7b\x82\x3d\xc9\x9e\x62\x4f\xb3\x67\xd8\xdf\xd8\x16\xf6\x2c\x7b\x8e\x3d\xcf\x5e\x60\x2f\xb2\x97\xd8\xcb\xec\x15\xf6\x77\xf6\x2a\x7b\x8d\xbd\xce\xde\x60\x6f\xb2\xb7\xd8\xdb\xec\x1f\xec\x1d\xf6\x2e\x7b\x8f\xbd\xcf\x3e\x60\x1f\xb2\x8f\xd8\xc7\xec\x13\xf6\x29\xdb\xca\xfe\xc9\x3e\x63\x9f\xb3\x2f\xd8\x97\xec\x2b\xf6\x35\xfb\x86\x7d\xcb\xbe\x63\xdf\xb3\x6d\xec\x07\xf6\x23\xfb\x17\xfb\x89\xfd\xcc\x7e\x61\xbf\xb2\xed\xec\x37\xd6\xc2\x76\x70\xc2\x29\x67\x9c\x73\xc1\x15\xae\x72\xf7\xbd\xd3\x21\x9e\xc2\x53\x79\x1a\x4f\xe7\x19\xbc\x07\xcf\xe4\x59\xbc\x27\xef\xc5\xb3\x79\x6f\xde\x87\xf7\xe5\xfd\x78\x7f\x3e\x80\x0f\xe4\x83\xf8\x60\x3e\x84\x0f\xe5\x39\x7c\x18\x1f\xce\x47\xf0\x3d\xf8\x48\x3e\x8a\xef\xc9\x47\xf3\xbd\xf8\xde\x7c\x1f\x3e\x86\x8f\xe5\xb9\x7c\x1c\xcf\xe3\xf9\xdc\xe0\x26\xb7\x78\x98\x17\xf0\x42\x5e\xc4\x8b\xf9\x78\xbe\x2f\x9f\xc0\x27\xf2\x49\x7c\x32\x9f\xc2\x4b\x78\x29\x2f\xe3\xe5\xdc\xe6\x0e\xdf\x8f\x4f\xe5\xd3\xf8\x74\xbe\x3f\x9f\xc1\x67\xf2\x59\x7c\x36\x9f\xc3\x0f\xe0\x73\xf9\x3c\x3e\x9f\x2f\xe0\x0b\xf9\x22\xbe\x98\x2f\xe1\x4b\xf9\x81\xfc\x20\x7e\x30\x3f\x84\x2f\xe3\xcb\x79\x84\x57\xf0\x4a\x5e\xc5\xa3\xbc\x9a\xd7\xf0\x5a\x1e\xe3\x2b\xf8\x4a\x5e\x47\xae\xe5\xf5\xbc\x81\xc7\x79\x23\x5f\xc5\x9b\x78\x82\x27\x79\x33\x5f\xcd\xd7\xf0\xb5\x7c\x1d\x5f\xcf\x0f\xe5\x87\xf1\xc3\xf9\x11\xfc\x48\x72\x29\xdf\xc0\x8f\xe2\x47\xf3\x63\xf8\xb1\xfc\x38\x7e\x3c\x3f\x81\x9f\xc8\x4f\xe2\x1b\xf9\xc9\xfc\x14\xfe\x27\x7e\x2a\x3f\x8d\x9f\xce\xcf\x20\xe7\xf2\x33\xf9\x9f\xf9\x59\xe4\x42\x7e\x36\x3f\x87\x9f\xcb\xcf\xe3\xe7\xf3\x0b\xf8\x85\xfc\x22\x7e\x31\xbf\x84\x5f\xca\x2f\xe3\x97\xf3\x2b\xf8\x5f\xf8\x95\xfc\x2a\x7e\x35\xbf\x86\x5f\xcb\xaf\xe3\xd7\xf3\xbf\xf2\x1b\xf8\x8d\xfc\x26\x7e\x33\xbf\x85\xdf\xca\x6f\xe3\xb7\xf3\x3b\xf8\x9d\xfc\x2e\x7e\x37\xbf\x87\xdf\xcb\xef\xe3\xf7\xf3\x4d\xfc\x01\xfe\x20\x7f\x88\x6f\xe6\x0f\xf3\x47\xf8\xa3\xfc\x31\xfe\x38\x7f\x82\x3f\xc9\x9f\xe2\x4f\xf3\x67\xf8\xdf\xf8\x16\xfe\x2c\x7f\x8e\x3f\xcf\x5f\xe0\x2f\xf2\x97\xf8\xcb\xfc\x15\xfe\x77\xfe\x2a\x7f\x8d\xbf\xce\xdf\xe0\x6f\xf2\xb7\xf8\xdb\xfc\x1f\xfc\x1d\xfe\x2e\x7f\x8f\xbf\xcf\x3f\xe0\x1f\xf2\x8f\xf8\xc7\xfc\x13\xfe\x29\xdf\xca\xff\xc9\x3f\xe3\x9f\xf3\x2f\xf8\x97\xfc\x2b\xfe\x35\xff\x86\x7f\xcb\xbf\xe3\xdf\xf3\x6d\xfc\x07\xfe\x23\xff\x17\xff\x89\xff\xcc\x7f\xe1\xbf\xf2\xed\xfc\x37\xde\xc2\x77\x08\x22\xa8\x60\x82\x0b\x21\x14\xa1\x0a\x4d\xe8\x22\x24\x52\x44\xaa\x48\x13\xe9\x22\x43\xf4\x10\x99\x22\x4b\xf4\x14\xbd\x44\xb6\xe8\x2d\xfa\x88\xbe\xa2\x9f\xe8\x2f\x06\x88\x81\x62\x90\x18\x2c\x86\x88\xa1\x22\x47\x0c\x13\xc3\xc5\x08\xb1\x87\x18\x29\x46\x89\x3d\xc5\x68\xb1\x97\xd8\x5b\xec\x23\xc6\x88\xb1\x22\x57\x8c\x13\x79\x22\x5f\x18\xc2\x14\x96\x08\x8b\x02\x51\x28\x8a\x44\xb1\x18\x2f\xf6\x15\x13\xc4\x44\x31\x49\x4c\x16\x53\x44\x89\x28\x15\x65\xa2\x5c\xd8\xc2\x11\xfb\x89\xa9\x62\x9a\x98\x2e\xf6\x17\x33\xc4\x4c\x31\x4b\xcc\x16\x73\xc4\x01\x62\xae\x98\x27\xe6\x8b\x05\x62\xa1\x58\x24\x16\x8b\x25\x62\xa9\x38\x50\x1c\x24\x0e\x16\x87\x88\x65\x62\xb9\x88\x88\x0a\x51\x29\xaa\x44\x54\x54\x8b\x1a\x51\x2b\x62\x62\x85\x58\x29\xea\x44\xbd\x68\x10\x71\xd1\x28\x56\x89\x26\x91\x10\x49\xd1\x2c\x56\x8b\x35\x62\xad\x58\x27\xd6\x8b\x43\xc5\x61\xe2\x70\x71\x84\x38\x52\x6c\x10\x47\x89\xa3\xc5\x31\xe2\x58\x71\x9c\x38\x5e\x9c\x20\x4e\x14\x27\x89\x8d\xe2\x64\x71\x8a\xf8\x93\x38\x55\x9c\x26\x4e\x17\x67\x88\x33\xc5\x9f\xc5\x59\xe2\x6c\x71\x8e\x38\x57\x9c\x27\xce\x17\x17\x88\x0b\xc5\x45\xe2\x62\x71\x89\xb8\x54\x5c\x26\x2e\x17\x57\x88\xbf\x88\x2b\xc5\x55\xe2\x6a\x71\x8d\xb8\x56\x5c\x27\xae\x17\x7f\x15\x37\x88\x1b\xc5\x4d\xe2\x66\x71\x8b\xb8\x55\xdc\x26\x6e\x17\x77\x88\x3b\xc5\x5d\xe2\x6e\x71\x8f\xb8\x57\xdc\x27\xee\x17\x9b\xc4\x03\xe2\x41\xf1\x90\xd8\x2c\x1e\x16\x8f\x88\x47\xc5\x63\xe2\x71\xf1\x84\x78\x52\x3c\x25\x9e\x16\xcf\x88\xbf\x89\x2d\xe2\x59\xf1\x9c\x78\x5e\xbc\x20\x5e\x14\x2f\x89\x97\xc5\x2b\xe2\xef\xe2\x55\xf1\x9a\x78\x5d\xbc\x21\xde\x14\x6f\x89\xb7\xc5\x3f\xc4\x3b\xe2\x5d\xf1\x9e\x78\x5f\x7c\x20\x3e\x14\x1f\x89\x8f\xc5\x27\xe2\x53\xb1\x55\xfc\x53\x7c\x26\x3e\x17\x5f\x88\x2f\xc5\x57\xe2\x6b\xf1\x8d\xf8\x56\x7c\x27\xbe\x17\xdb\xc4\x0f\xe2\x47\xf1\x2f\xf1\x93\xf8\x59\xfc\x22\x7e\x15\xdb\xc5\x6f\xa2\x45\xec\x50\x88\x42\x15\xa6\x70\x45\x28\x8a\xa2\x2a\x9a\xa2\x2b\x21\x25\x45\x49\x55\xd2\x94\x74\x25\x43\xe9\xa1\x64\x2a\x59\x4a\x4f\xa5\x97\x92\xad\xf4\x56\xfa\x28\x7d\x95\x7e\x4a\x7f\x65\x80\x32\x50\x19\xa4\x0c\x56\x86\x28\x43\x95\x1c\x65\x98\x32\x5c\x19\xa1\xec\xa1\x8c\x54\x46\x29\x7b\x2a\xa3\x95\xbd\x94\xbd\x95\x7d\x94\x31\xca\x58\x25\x57\x19\xa7\xe4\x29\xf9\x8a\xa1\x98\x8a\xa5\x84\x95\x02\xa5\x50\x29\x52\x8a\x95\xf1\xca\xbe\xca\x04\x65\xa2\x32\x49\x99\xac\x4c\x51\x4a\x94\x52\xa5\x4c\x29\x57\x6c\xc5\x51\xf6\x53\xa6\x2a\xd3\x94\xe9\xca\xfe\xca\x0c\x65\xa6\x32\x4b\x99\xad\xcc\x51\x0e\x50\xe6\x2a\xf3\x94\xf9\xca\x02\x65\xa1\xb2\x48\x59\xac\x2c\x51\x96\x2a\x07\x2a\x07\x29\x07\x2b\x87\x28\xcb\x94\xe5\x4a\x44\xa9\x50\x2a\x95\x2a\x25\xaa\x54\x2b\x35\x4a\xad\x12\x53\x56\x28\x2b\x95\x3a\xa5\x5e\x69\x50\xe2\x4a\xa3\xb2\x4a\x69\x52\x12\x4a\x52\x69\x56\x56\x2b\x6b\x94\xb5\xca\x3a\x65\xbd\x72\xa8\x72\x98\x72\xb8\x72\x84\x72\xa4\xb2\x41\x39\x4a\x39\x5a\x39\x46\x39\x56\x39\x4e\x39\x5e\x39\x41\x39\x51\x39\x49\xd9\xa8\x9c\xac\x9c\xa2\xfc\x49\x39\x55\x39\x4d\x39\x5d\x39\x43\x39\x53\xf9\xb3\x72\x96\x72\xb6\x72\x8e\x72\xae\x72\x9e\x72\xbe\x72\x81\x72\xa1\x72\x91\x72\xb1\x72\x89\x72\xa9\x72\x99\x72\xb9\x72\x85\xf2\x17\xe5\x4a\xe5\x2a\xe5\x6a\xe5\x1a\xe5\x5a\xe5\x3a\xe5\x7a\xe5\xaf\xca\x0d\xca\x8d\xca\x4d\xca\xcd\xca\x2d\xca\xad\xca\x6d\xca\xed\xca\x1d\xca\x9d\xca\x5d\xca\xdd\xca\x3d\xca\xbd\xca\x7d\xca\xfd\xca\x26\xe5\x01\xe5\x41\xe5\x21\x65\xb3\xf2\xb0\xf2\x88\xf2\xa8\xf2\x98\xf2\xb8\xf2\x84\xf2\xa4\xf2\x94\xf2\xb4\xf2\x8c\xf2\x37\x65\x8b\xf2\xac\xf2\x9c\xf2\xbc\xf2\x82\xf2\xa2\xf2\x92\xf2\xb2\xf2\x8a\xf2\x77\xe5\x55\xe5\x35\xe5\x75\xe5\x0d\xe5\x4d\xe5\x2d\xe5\x6d\xe5\x1f\xca\x3b\xca\xbb\xca\x7b\xca\xfb\xca\x07\xca\x87\xca\x47\xca\xc7\xca\x27\xca\xa7\xca\x56\xe5\x9f\xca\x67\xca\xe7\xca\x17\xca\x97\xca\x57\xca\xd7\xca\x37\xca\xb7\xca\x77\xca\xf7\xca\x36\xe5\x07\xe5\x47\xe5\x5f\xca\x4f\xca\xcf\xca\x2f\xca\xaf\xca\x76\xe5\x37\xa5\x45\xd9\xa1\x12\x95\xaa\x4c\xe5\xaa\x50\x15\x55\x55\x35\x55\x57\x43\x6a\x8a\xfb\x3d\x68\x35\x5d\xcd\x50\x7b\xa8\x99\x6a\x96\xda\x53\xed\xa5\x66\xab\xbd\xd5\x3e\x6a\x5f\xb5\x9f\xda\x5f\x1d\xa0\x0e\x54\x07\xa9\x83\xd5\x21\xea\x50\x35\x47\x1d\xa6\x0e\x57\x47\xa8\x7b\xa8\x23\xd5\x51\xea\x9e\xea\x68\x75\x2f\x75\x6f\x75\x1f\x75\x8c\x3a\x56\xcd\x55\xc7\xa9\x79\x6a\xbe\x6a\xa8\xa6\x6a\xa9\x61\xb5\x40\x2d\x54\x8b\xd4\x62\x75\xbc\xba\xaf\x3a\x41\x9d\xa8\x4e\x52\x27\xab\x53\xd4\x12\xb5\x54\x2d\x53\xcb\x55\x5b\x75\xd4\xfd\xd4\xa9\xea\x34\x75\xba\xba\xbf\x3a\x43\x9d\xa9\xce\x52\x67\xab\x73\xd4\x03\xd4\xb9\xea\x3c\x75\xbe\xba\x40\x5d\xa8\x2e\x52\x17\xab\x4b\xd4\xa5\xea\x81\xea\x41\xea\xc1\xea\x21\xea\x32\x75\xb9\x1a\x51\x2b\xd4\x4a\xb5\x4a\x8d\xaa\xd5\x6a\x8d\x5a\xab\xc6\xd4\x15\xea\x4a\xb5\x4e\xad\x57\x1b\xd4\xb8\xda\xa8\xae\x52\x9b\xd4\x84\x9a\x54\x9b\xd5\xd5\xea\x1a\x75\xad\xba\x4e\x5d\xaf\x1e\xaa\x1e\xa6\x1e\xae\x1e\xa1\x1e\xa9\x6e\x50\x8f\x52\x8f\x56\x8f\x51\x8f\x55\x8f\x53\x8f\x57\x4f\x50\x4f\x54\x4f\x52\x37\xaa\x27\xab\xa7\xa8\x7f\x52\x4f\x55\x4f\x53\x4f\x57\xcf\x50\xcf\x54\xff\xac\x9e\xa5\x9e\xad\x9e\xa3\x9e\xab\x9e\xa7\x9e\xaf\x5e\xa0\x5e\xa8\x5e\xa4\x5e\xac\x5e\xa2\x5e\xaa\x5e\xa6\x5e\xae\x5e\xa1\xfe\x45\xbd\x52\xbd\x4a\xbd\x5a\xbd\x46\xbd\x56\xbd\x4e\xbd\x5e\xfd\xab\x7a\x83\x7a\xa3\x7a\x93\x7a\xb3\x7a\x8b\x7a\xab\x7a\x9b\x7a\xbb\x7a\x87\x7a\xa7\x7a\x97\x7a\xb7\x7a\x8f\x7a\xaf\x7a\x9f\x7a\xbf\xba\x49\x7d\x40\x7d\x50\x7d\x48\xdd\xac\x3e\xac\x3e\xa2\x3e\xaa\x3e\xa6\x3e\xae\x3e\xa1\x3e\xa9\x3e\xa5\x3e\xad\x3e\xa3\xfe\x4d\xdd\xa2\x3e\xab\x3e\xa7\x3e\xaf\xbe\xa0\xbe\xa8\xbe\xa4\xbe\xac\xbe\xa2\xfe\x5d\x7d\x55\x7d\x4d\x7d\x5d\x7d\x43\x7d\x53\x7d\x4b\x7d\x5b\xfd\x87\xfa\x8e\xfa\xae\xfa\x9e\xfa\xbe\xfa\x81\xfa\xa1\xfa\x91\xfa\xb1\xfa\x89\xfa\xa9\xba\x55\xfd\xa7\xfa\x99\xfa\xb9\xfa\x85\xfa\xa5\xfa\x95\xfa\xb5\xfa\x8d\xfa\xad\xfa\x9d\xfa\xbd\xba\x4d\xfd\x41\xfd\x51\xfd\x97\xfa\x93\xfa\xb3\xfa\x8b\xfa\xab\xba\x5d\xfd\x4d\x6d\x51\x77\x68\x44\xa3\x1a\xd3\xb8\x26\x34\x45\x53\x35\x4d\xd3\xb5\x90\x96\xa2\xa5\x6a\x69\x5a\xba\x96\xa1\xf5\xd0\x32\xb5\x2c\xad\xa7\xd6\x4b\xcb\xd6\x7a\x6b\x7d\xb4\xbe\x5a\x3f\xad\xbf\x36\x40\x1b\xa8\x0d\xd2\x06\x6b\x43\xb4\xa1\x5a\x8e\x36\x4c\x1b\xae\x8d\xd0\xf6\xd0\x46\x6a\xa3\xb4\x3d\xb5\xd1\xda\x5e\xda\xde\xda\x3e\xda\x18\x6d\xac\x96\xab\x8d\xd3\xf2\xb4\x7c\xcd\xd0\x4c\xcd\xd2\xc2\x5a\x81\x56\xa8\x15\x69\xc5\xda\x78\x6d\x5f\x6d\x82\x36\x51\x9b\xa4\x4d\xd6\xa6\x68\x25\x5a\xa9\x56\xa6\x95\x6b\xb6\xe6\x68\xfb\x69\x53\xb5\x69\xda\x74\x6d\x7f\x6d\x86\x36\x53\x9b\xa5\xcd\xd6\xe6\x68\x07\x68\x73\xb5\x79\xda\x7c\x6d\x81\xb6\x50\x5b\xa4\x2d\xd6\x96\x68\x4b\xb5\x03\xb5\x83\xb4\x83\xb5\x43\xb4\x65\xda\x72\x2d\xa2\x55\x68\x95\x5a\x95\x16\xd5\xaa\xb5\x1a\xad\x56\x8b\x69\x2b\xb4\x95\x5a\x9d\x56\xaf\x35\x68\x71\xad\x51\x5b\xa5\x35\x69\x09\x2d\xa9\x35\x6b\xab\xb5\x35\xda\x5a\x6d\x9d\xb6\x5e\x3b\x54\x3b\x4c\x3b\x5c\x3b\x42\x3b\x52\xdb\xa0\x1d\xa5\x1d\xad\x1d\xa3\x1d\xab\x1d\xa7\x1d\xaf\x9d\xa0\x9d\xa8\x9d\xa4\x6d\xd4\x4e\xd6\x4e\xd1\xfe\xa4\x9d\xaa\x9d\xa6\x9d\xae\x9d\xa1\x9d\xa9\xfd\x59\x3b\x4b\x3b\x5b\x3b\x47\x3b\x57\x3b\x4f\x3b\x5f\xbb\x40\xbb\x50\xbb\x48\xbb\x58\xbb\x44\xbb\x54\xbb\x4c\xbb\x5c\xbb\x42\xfb\x8b\x76\xa5\x76\x95\x76\xb5\x76\x8d\x76\xad\x76\x9d\x76\xbd\xf6\x57\xed\x06\xed\x46\xed\x26\xed\x66\xed\x16\xed\x56\xed\x36\xed\x76\xed\x0e\xed\x4e\xed\x2e\xed\x6e\xed\x1e\xed\x5e\xed\x3e\xed\x7e\x6d\x93\xf6\x80\xf6\xa0\xf6\x90\xb6\x59\x7b\x58\x7b\x44\x7b\x54\x7b\x4c\x7b\x5c\x7b\x42\x7b\x52\x7b\x4a\x7b\x5a\x7b\x46\xfb\x9b\xb6\x45\x7b\x56\x7b\x4e\x7b\x5e\x7b\x41\x7b\x51\x7b\x49\x7b\x59\x7b\x45\xfb\xbb\xf6\xaa\xf6\x9a\xf6\xba\xf6\x86\xf6\xa6\xf6\x96\xf6\xb6\xf6\x0f\xed\x1d\xed\x5d\xed\x3d\xed\x7d\xed\x03\xed\x43\xed\x23\xed\x63\xed\x13\xed\x53\x6d\xab\xf6\x4f\xed\x33\xed\x73\xed\x0b\xed\x4b\xed\x2b\xed\x6b\xed\x1b\xed\x5b\xed\x3b\xed\x7b\x72\x1b\xb9\x5d\xdb\xa6\xfd\x40\xee\x22\x77\x93\xc7\xb4\x1f\xc9\x1d\xe4\x4e\xf2\xb8\xf6\x2f\x72\x34\x79\x84\x9c\x40\xfe\xaa\xfd\xa4\xfd\xac\xfd\xa2\xfd\xaa\x6d\x27\x4f\x68\xbf\x69\x2d\x9a\xfb\xce\x8c\x87\x74\xa2\x53\xb2\x49\x67\x3a\xd7\x85\xae\xe8\xaa\xae\xe9\xba\x1e\xd2\x53\xf4\x54\x3d\x4d\x4f\xd7\x33\xf4\x1e\x7a\xa6\x9e\x45\xfe\xa5\xf7\xd4\x7b\xe9\xd9\x7a\x6f\xbd\x8f\xde\x57\xef\xa7\xf7\xd7\x07\xe8\x03\xf5\x41\xfa\x60\x7d\x88\x3e\x54\xcf\xd1\x87\xe9\xc3\xf5\x11\xfa\x1e\xfa\x48\x7d\x94\xbe\xa7\x3e\x9a\x9c\xa2\xef\xa5\xef\xad\xef\xa3\x8f\xd1\xc7\xea\xb9\xfa\x38\x3d\x4f\xcf\xd7\x0d\xdd\xd4\x2d\x3d\xac\x17\xe8\x85\x7a\x91\x5e\xac\x8f\x27\xe7\xe9\xfb\x92\x0b\xc8\xf9\xe4\x6b\x7d\x02\x79\x94\x5c\x45\xce\xd4\x27\xea\x93\xc8\x45\xe4\x1a\x72\x9a\x3e\x99\x9c\x45\xce\xd6\xa7\xe8\x25\x7a\xa9\x5e\xa6\x97\xeb\xb6\xee\xe8\xfb\xe9\x53\xf5\x69\xfa\x74\x7d\x7f\x7d\x86\x3e\x53\x9f\xa5\xcf\xd6\xe7\xe8\x07\xe8\x73\xf5\x79\xfa\x7c\x7d\x81\xbe\x50\x5f\xa4\x2f\xd6\x97\xe8\x4b\xf5\x03\xf5\x83\xf4\x83\xf5\x43\xf4\x65\xfa\x72\x3d\xa2\x57\xe8\x95\x7a\x95\x1e\xd5\xab\xf5\x1a\xbd\x56\x8f\xe9\x2b\xf4\x95\x7a\x9d\x5e\xaf\x37\xe8\x71\xbd\x51\x5f\xa5\x37\xe9\x09\x3d\xa9\x37\xeb\xab\xf5\x35\xfa\x5a\x7d\x9d\xbe\x5e\x3f\x54\x3f\x8c\xdc\xab\x1f\xae\x1f\xa1\x1f\xa9\x6f\xd0\x8f\xd2\x8f\xd6\x8f\xd1\x8f\xd5\x8f\xd3\x8f\xd7\x4f\xd0\x4f\xd4\x4f\xd2\x37\xea\x27\xeb\xa7\xe8\x7f\xd2\x4f\xd5\x4f\xd3\x4f\xd7\xcf\xd0\xcf\xd4\xff\xac\x9f\xa5\x9f\xad\x9f\xa3\x9f\xab\x9f\xa7\x9f\xaf\x5f\xa0\x5f\xa8\x5f\xa4\x5f\xac\x5f\xa2\x5f\xaa\x5f\xa6\x5f\xae\x5f\xa1\xff\x45\xbf\x52\xbf\x4a\xbf\x5a\xbf\x46\xbf\x56\xbf\x4e\xbf\x5e\xff\xab\x7e\x83\x7e\xa3\x7e\x93\x7e\xb3\x7e\x8b\x7e\xab\x7e\x9b\x7e\xbb\x7e\x07\xd9\x4c\x1e\xd6\xef\xd4\xef\xd2\xef\xd6\xef\xd1\xef\xd5\xef\xd3\xef\xd7\x37\xe9\x0f\xe8\x0f\xea\x0f\xe9\x9b\xf5\x87\xf5\x47\xf4\x47\xf5\xc7\xf4\xc7\xf5\x27\xf4\x27\xf5\xa7\xf4\xa7\xf5\x67\xf4\xbf\xe9\x5b\xf4\x67\xf5\xe7\xf4\xe7\xf5\x17\xf4\x17\xf5\x97\xf4\x97\xf5\x57\xf4\xbf\xeb\xaf\xea\xaf\xe9\xaf\xeb\x6f\xe8\x6f\xea\x6f\xe9\x6f\xeb\xff\xd0\xdf\xd1\xdf\xd5\xdf\xd3\xdf\xd7\x3f\xd0\x3f\xd4\x3f\xd2\x3f\xd6\x3f\xd1\x3f\xd5\xb7\xea\xff\xd4\x3f\xd3\x3f\xd7\xbf\xd0\xbf\xd4\xbf\xd2\xbf\xd6\xbf\xd1\xbf\xd5\xbf\xd3\xbf\xd7\xb7\xe9\x3f\xe8\x3f\xea\xff\xd2\x7f\xd2\x7f\xd6\x7f\xd1\x7f\xd5\xb7\xeb\xbf\xe9\x2d\xfa\x8e\x10\x09\xd1\x10\x0b\xf1\x90\x08\x29\x21\x35\xa4\x85\xf4\x50\x28\x94\x12\x4a\x0d\xa5\x85\xd2\x43\x19\xa1\x1e\xa1\xcc\x50\x56\xa8\x67\xa8\x57\x28\x3b\xd4\x3b\xd4\x27\xd4\x37\xd4\x2f\xd4\x3f\x34\x20\x34\x30\x34\x28\x34\x38\x34\x24\x34\x34\x94\x13\x1a\x16\x1a\x1e\x1a\x11\xda\x23\x34\x32\x34\x2a\xb4\x67\x68\x74\x68\xaf\xd0\xde\xa1\x7d\x42\x63\x42\x63\x43\xb9\xa1\x71\xa1\xbc\x50\x7e\xc8\x08\x99\x21\x2b\x14\x0e\x15\x84\x0a\x43\x45\xa1\xe2\xd0\xf8\xd0\xbe\xa1\x09\xa1\x89\xa1\x49\xa1\xc9\xa1\x29\xa1\x92\x50\x69\xa8\x2c\x54\x1e\xb2\x43\x4e\x68\xbf\xd0\xd4\xd0\xb4\xd0\xf4\xd0\xfe\xa1\x19\xa1\x99\xa1\x59\xa1\xd9\xa1\x39\xa1\x03\x42\x73\x43\xf3\x42\xf3\x43\x0b\x42\x0b\x43\x8b\x42\x8b\x43\x4b\x42\x4b\x43\x07\x6a\xcd\x0d\xb1\xbc\xbc\x92\x3c\xc4\xe5\xa1\xf8\xea\x68\x53\xa2\x32\xde\x14\xe5\xf5\xcd\xf9\x29\xf5\xb1\xaa\xaa\x78\x32\x37\x2f\x2f\x5f\x2b\xa9\x77\xaf\x76\x36\x68\x11\x3f\x56\x4b\x2a\x9a\xa2\xab\xa3\x6a\xc4\x8b\xb4\x92\x78\x4d\xbc\x21\xba\x52\x8b\xf8\x71\x6a\x59\x65\xac\xa9\xb2\xb9\xbe\xba\x2e\xba\x36\xb5\xb2\x5d\x4e\x29\x93\xd5\x45\x2a\x2b\xa3\x0d\xc9\x94\xca\x36\x51\x2d\xaf\x8c\xb8\x55\x56\xf9\x51\xb9\xac\x3f\x92\xd4\x6c\x00\x46\x01\x68\xfb\x80\x51\x2f\x4a\xb1\xdb\x2b\x8a\xb6\x89\x9a\x0d\x35\xa2\x7e\xac\xda\x7e\x8d\x51\x2f\x4a\xdd\x2f\xa0\x54\x4d\x40\xa9\xfd\xda\xeb\xaa\x69\x13\xd3\xf6\xab\x8c\xd7\xd7\x47\xb0\x53\x13\xd8\x49\x9d\x1a\xa8\xa7\xb6\x5d\x16\x53\x2b\x22\x4d\xa2\x56\x06\xea\xb4\x64\xac\xae\x2a\xaa\xc6\xbc\x48\x9b\x86\x96\xc4\xd0\x92\x69\x7e\x4b\x62\x7e\xd7\x4d\x83\xce\x31\x3f\x66\xd3\xa6\xb3\xd8\x8a\xd4\xe9\x01\x8c\x15\xed\x72\xda\xfe\x41\xad\x56\x76\xd8\xa9\x71\x2f\x9e\xd7\x45\x1a\xaa\x62\x95\xea\x8c\x48\x65\x73\x32\xaa\xd6\x79\x51\xda\x8c\x60\xbe\xba\xc0\x8e\x3a\xc3\xef\xa0\x3a\x2f\x12\x33\x64\xeb\x45\x9d\x0c\xd4\x59\x7e\xf9\x06\xbf\xfc\xac\x60\xf9\x86\x60\xf9\x59\x7e\xf9\x06\xbf\x83\x1b\x22\x8d\xf1\x44\xb2\x29\xde\x58\x1b\xe5\x76\x43\x0d\x8f\x36\xd4\x68\xb3\xd1\xf8\x38\x1a\x3f\xdb\x6f\x7c\xdc\x8b\xd2\x67\xd7\x36\x37\xd4\x44\x9a\x9a\xeb\xeb\x22\xcd\xc9\xf4\x78\x70\x4f\x9d\xeb\xeb\xd0\xe4\xeb\x30\x37\xa8\x43\x53\x50\x87\xb9\xbe\x0e\x4d\x7e\x34\xcf\x2f\x95\xf0\xa2\xd4\x79\x81\x6e\x4c\x04\xba\x71\x7e\xb0\xb6\x64\xb0\xb6\xf9\x7e\x35\x49\xbf\x47\xe6\xbb\x43\x9a\x74\x87\x74\x81\x3f\xa4\xcd\xfe\x90\x2e\x40\xab\x9a\xd1\xaa\x05\x7e\xab\x9a\xbd\x48\x59\xd0\x14\x6b\xa8\x51\x9a\xdd\x30\x7d\x41\x87\x16\x36\x07\xf7\xb4\x05\x18\xfa\x66\x9c\x35\x8b\x02\xda\xae\x09\xc8\x4b\x02\xf2\xba\x76\x59\x5d\xea\xb7\x75\xbd\x17\xa5\x2c\x6d\x9f\xc6\xeb\xdb\x44\xa5\x2e\xde\x50\x93\xf0\x4e\xef\xfc\xa2\x3c\xc4\xf9\x88\x0d\xc4\x26\x62\x0b\x71\x18\x71\x01\xe2\x42\xc4\x45\x88\x8b\x11\x97\x20\x2e\x45\x5c\x86\xb8\x1c\xb1\x8d\xd8\xf1\xe3\x62\xe0\x17\x03\xbf\x18\xb8\xc5\xc0\x2d\x06\x6e\x31\x70\x8b\x81\x5b\x0c\xdc\x62\xe0\x16\x03\xb7\x18\xb8\xc5\xc0\x2d\x06\x6e\x31\x70\x8b\x1d\x65\x76\x6d\xbc\x49\x3a\x40\x6e\xe8\xa7\x95\xa0\xcd\x25\xc0\x2e\x01\x76\x09\xb0\x4b\x80\x5d\x02\xec\x12\x60\x97\x00\xbb\x04\xd8\x25\xc0\x2e\x01\x76\x09\xb0\x4b\x6c\x65\x81\x87\xd9\xdc\x8e\x59\x8a\xf6\x96\x02\xbb\x14\xd8\xa5\xc0\x2e\x05\x76\x29\xb0\x4b\x81\x5d\x0a\xec\x52\x60\x97\x02\xbb\x14\xd8\xa5\xc0\x2e\x05\x76\x29\xda\x5d\x8a\xfe\x2e\x43\x7f\x97\x01\xbf\x0c\xf8\x65\xc0\x2f\x03\x7e\x19\xf0\xcb\x80\x5f\x06\xfc\x32\xe0\x97\x01\xbf\x0c\xf8\x65\xc0\x2f\x03\x7e\x19\xf0\xcb\x80\x5f\x06\xfc\x72\xe0\x97\x03\xbf\x1c\xf8\xe5\xc0\x2f\x07\x7e\x39\xf0\xcb\x81\x5f\x0e\xfc\x72\xe0\x97\x03\xbf\x1c\xf8\xe5\xc0\x2f\x07\x7e\x39\xf0\xcb\x81\x5f\x0e\x7c\x1b\xf8\x36\xf0\x6d\xe0\xdb\xc0\xb7\x81\x6f\x03\xdf\x06\xbe\x0d\x7c\x1b\xf8\x36\xf0\x6d\xe0\xdb\xc0\xb7\x81\x6f\x03\xdf\x06\xbe\x0d\x7c\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x4e\x71\x4a\x89\xbb\x96\xf8\xa7\x79\xa4\x4d\xd4\x4a\x6c\x3f\x8e\x44\xfd\xd5\x6e\x76\xa2\x2e\x92\xa8\xf5\xe5\x78\xbb\xec\xd5\x62\xe4\xe5\x21\xce\x47\x6c\x20\x36\x11\x5b\x88\xc3\x88\x0b\x10\x17\x22\x2e\x42\x5c\x8c\xb8\x04\x71\x29\xe2\x32\xc4\xe5\x88\x6d\xc4\x7e\x6f\x18\xf9\xc0\xcf\x07\x7e\x3e\xf0\xf3\x81\x9f\x0f\xfc\x7c\xe0\xe7\x03\x3f\xbf\x30\x6d\x5e\x70\xb5\x4e\x04\x76\x90\x03\x9a\xe4\x43\x93\x7c\x68\x92\x0f\x4d\xf2\xa1\x49\x3e\x34\x31\xa0\x89\x01\x4d\x0c\x68\x62\x40\x13\x03\x9a\x18\xd0\xc4\x80\x26\x06\x7a\xc2\x40\x4f\x18\xe8\x09\x03\xf8\x06\xf0\x0d\xe0\x1b\xc0\x37\x80\x6f\x00\xdf\x04\xbe\x09\x7c\x13\xf8\x26\xf0\x4d\xe0\x9b\xc0\x37\x81\x6f\x02\xd7\x04\xae\x09\x5c\x13\xb8\x26\x70\x4d\xe0\x9a\xc0\x35\x81\x6b\x01\xd7\x02\xae\x05\x5c\x0b\xb8\x16\x70\x2d\xe0\x5a\xc0\xb5\xd0\x6e\x0b\xf8\x16\xf0\x2d\xe0\x5b\xc0\xb7\x80\x6f\x01\xdf\x02\xbe\x05\xfc\x30\xf0\xc3\xc0\x0f\x03\x3f\x0c\xfc\x30\xf0\xc3\xc0\x0f\x03\x3f\x0c\xfc\x30\xf0\xc3\xc0\x0f\x03\x3f\x0c\xfc\x30\xf0\xc3\xc0\x0f\x03\x3f\x0c\xfc\x02\xe0\x17\x00\xbf\x00\xf8\x05\xc0\x2f\x00\x7e\x01\xf0\x0b\x80\x5f\x00\xfc\x02\xe0\x17\x00\xbf\x00\xf8\x05\xc0\x2f\x00\x7e\x01\xf0\x0b\x80\x5f\x00\xfc\x42\xe0\x17\x02\xbf\x10\xf8\x85\xc0\x2f\x04\x7e\x21\xf0\x0b\x81\x5f\x08\xfc\x42\xe0\x17\x02\xbf\x10\xf8\x85\xc0\x2f\x04\x7e\x21\xf0\x0b\x81\x5f\x08\x7c\xf0\xbf\x01\xfe\x37\xc0\xff\x06\xf8\xdf\x00\xff\x1b\xe0\x7f\x03\xfc\x6f\x80\xff\x0d\xf0\xbf\x01\xfe\x37\xc0\xff\x06\xf8\xdf\x00\xff\x1b\xe0\x7f\x03\xfc\x6f\x80\xff\x0d\xf0\xbf\x01\xfe\x37\x8a\x81\x0f\x3b\xc0\x80\x1d\x60\xc0\x0e\x30\x60\x07\x18\xb0\x03\x0c\xd8\x01\x06\xec\x00\x03\x76\x80\x01\x3b\xc0\x80\x1d\x60\xc0\x0e\x30\x60\x07\x18\xc5\xc0\x87\x9b\x63\x94\x00\x1f\xb6\x80\x01\x5b\xc0\x80\x2d\x60\xc0\x16\x30\x60\x0b\x18\xb0\x05\x0c\xd8\x02\x06\x6c\x01\x03\xb6\x80\x01\x5b\xc0\x80\x2d\x60\xc0\x16\x30\x4a\x80\x5f\x02\xfc\x52\xe0\xc3\x1e\x30\x60\x0f\x18\xb0\x07\x0c\xd8\x03\x06\xec\x01\x03\xf6\x80\x01\x7b\xc0\x80\x3d\x60\xc0\x1e\x30\x60\x0f\x18\xb0\x07\x0c\xd8\x03\x06\xec\x01\x03\xf6\x80\x01\x7b\xc0\x80\x3d\x60\xc0\x1e\x30\x60\x0f\x18\xb0\x07\x0c\xd8\x03\x06\xec\x01\x03\xfc\x6f\x80\xf7\x0d\xf0\xbe\x01\xde\x37\xc0\xfb\x06\x78\xdf\x00\xef\x1b\xe0\x7d\x03\xbc\x6f\x80\xf7\x0d\xf0\xbe\x01\xde\x37\xc0\xfb\x06\x78\xdf\x00\xef\x1b\xe0\x71\x03\x3c\x6e\x80\xc7\x0d\xf0\xb8\x01\x1e\x37\xc0\xe3\x06\x78\xdc\x00\x8f\x1b\xe0\x71\x03\x3c\x6e\x80\xc7\x0d\xf0\xb8\x01\x1e\x37\xc0\xe3\x06\x78\xdc\x00\x8f\x1b\xe0\x71\x03\x3c\x6e\x80\xc7\x0d\xf0\xb8\x01\x1e\x37\xc0\xe3\x06\x78\xdc\x00\x8f\x1b\xe0\x71\x03\x3c\x6e\x80\xc7\x0d\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x00\xdf\x71\x42\x35\x4d\x91\xd5\x51\x49\x78\x15\x21\x8f\xc9\x5d\xc9\x3b\x66\xe6\x19\x21\xcf\x13\x09\xa4\x58\x88\xc3\x88\x0b\x10\x17\x22\x2e\x4a\xaf\x8d\xc7\x57\x46\x2a\xe2\xab\x83\xa5\x4a\x10\x97\x22\x2e\x43\x5c\x8e\xd8\x46\xec\xf7\x85\x09\x16\x37\xc1\xe2\x26\x58\xdc\x04\x8b\x9b\x60\x71\x13\x2c\x6e\x82\xc5\xcd\x7c\x68\x91\x5f\x84\xb8\x18\x31\xf0\xc1\xdd\x26\xb8\xdb\x04\x77\x9b\xe0\x6e\x13\xdc\x6d\x82\xbb\x4d\x70\xb7\x69\x18\x69\xd2\xd7\xa9\x88\xd6\xc5\xd7\xb4\x37\x0a\x04\x6e\x82\xc0\x4d\x10\xb8\x09\x02\x37\x41\xe0\x26\x08\xdc\x04\x81\x9b\x20\x70\x13\x04\x6e\x82\xc0\x4d\x10\xb8\x09\x02\x37\x41\xe0\x26\x08\xdc\x04\x81\x9b\x20\x70\x13\x04\x6e\x82\xc0\x4d\x10\xb8\x69\x02\x1f\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6e\x82\xc8\x4d\x10\xb9\x09\x22\x37\x41\xe4\x26\x88\xdc\x04\x91\x9b\x20\x72\x13\x44\x6d\x82\xa8\x4d\x10\xb1\x09\x22\x36\x41\xc4\x26\x88\xd8\x2c\xb4\x95\x64\xbc\x21\x9e\x48\xaf\x8a\x45\x9b\xa2\x89\x58\xc2\xdb\x4b\x29\xa9\x6b\xac\x8d\x78\x62\x28\xd2\x10\x4f\x46\xeb\xa2\xb1\x48\x9a\xdd\x98\x88\x49\x9f\xdd\x4b\xd6\xed\x24\x8e\x4f\x8b\x43\x4a\x9b\x5d\x1f\x73\xaf\x38\xf8\x3b\x0b\x02\x99\x53\x66\xd7\x47\x6b\xfc\x4c\x59\x31\x99\xbd\x03\x96\xe2\x61\x89\xd2\x68\x32\xa2\xec\x17\x91\xf6\xb3\x06\x1c\xb1\x54\x26\x71\x89\xa3\xcc\xaf\x95\x92\x70\x81\x94\xfd\x23\x8d\x8d\x11\x75\x46\xa4\xbe\xa2\x2a\xc2\x66\x36\xb3\x59\xcd\x6c\x71\x4c\x03\x32\x9b\x13\xe3\x73\x6b\xe3\xca\xbc\x58\x4d\x7d\x84\xcf\x8f\x34\x6b\xd0\x82\xcf\xa9\x8d\xf1\x32\xb9\xcd\x49\xc4\xd2\xa6\x05\x34\xe8\x81\x0c\xad\xfb\x29\x91\xb6\x86\xa7\x45\x83\xcd\x8d\xb6\x36\x37\xd6\xda\xdc\xec\xe6\x8e\x45\xfd\xc6\x78\xe5\x45\x85\xdb\x98\x1a\xb7\x31\x4a\x55\xb4\x2e\x19\xd1\x50\x97\x58\xef\x36\xc9\x3d\x98\xf4\x9a\xe4\x56\xa6\xac\xf4\x9a\x54\xe7\x37\xa9\xa1\x99\xad\x8d\x69\x71\xbf\x3d\xbc\xa9\x36\xae\x26\xdc\xc6\xe4\x2b\x5e\xc4\x93\xb2\x4d\xc0\xe5\x8d\xb2\x3d\x95\x72\x93\xbb\x4a\xdc\xed\xe0\xb4\x60\xdf\xf6\xe8\xa4\x5e\x5a\x3c\x38\x3a\xcd\xc1\xd1\x89\xb7\x8d\x8e\x3f\x27\x40\x92\x26\x48\xd2\x04\x49\x9a\x20\x49\x13\x24\x69\x82\x24\x4d\x90\xa4\x09\x92\x34\xe1\x1c\x9b\x70\x8e\x4d\x38\xc7\x26\x9c\x63\x13\xce\xb1\x09\xe7\xd8\x04\xa9\x9a\x20\x55\x13\xa4\x6a\x82\x54\x4d\x90\xaa\x09\x52\x35\x41\xaa\x26\x48\xd5\x04\xa9\x9a\x20\x55\x13\xa4\x6a\x82\x54\x4d\x90\xaa\x09\x52\x35\x41\xaa\x26\x48\xd5\x04\xa9\x9a\x20\x55\x13\xa4\x6a\x82\x54\x4d\x90\xaa\x09\x52\x35\x41\xaa\x26\x48\xd5\x04\xa9\x9a\x20\x55\x13\xa4\x6a\x82\x54\x4d\x90\xaa\x09\x52\x35\x41\xaa\x26\x48\xd5\x04\xa9\x9a\x8e\x8f\x6f\xc1\x1d\xb6\xe0\x0e\x5b\x70\x87\x2d\xb8\xc3\x16\xe8\xd4\x02\x9d\x5a\xa0\x53\x0b\x74\x6a\xc1\x1d\xb6\xe0\x0e\x5b\x20\x52\x0b\x44\x6a\x81\x48\x2d\x10\xa9\x05\x22\xb5\x40\xa4\x16\x88\xd4\x02\x91\x5a\x20\x52\x0b\x44\x6a\x81\x48\x2d\x10\xa9\x05\x22\xb5\x40\xa4\x16\x88\xd4\x02\x91\x5a\x20\x52\x0b\x44\x6a\x81\x48\x2d\x10\xa9\x05\x22\xb5\x40\xa4\x16\x88\xd4\x02\x91\x5a\x70\x82\x2d\x38\xc1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\x81\x43\x2d\x70\xa8\x05\x0e\xb5\xc0\xa1\x16\x38\xd4\x02\x87\x5a\xe0\x50\x0b\x1c\x6a\xc1\x19\xb6\xe0\x0c\x5b\x70\x86\x2d\x38\xc3\x16\x38\xd6\x02\xc7\x5a\x70\x86\x2d\x38\xc3\x16\x9c\x61\x0b\xce\xb0\x05\x0e\xb6\xc0\xc1\x16\x38\xd8\x02\x07\x5b\x70\x86\x2d\x38\xc3\x16\x9c\x61\x0b\xce\xb0\x05\x67\xd8\x82\x33\x6c\xc1\x19\xb6\xe0\x0c\x5b\x70\x86\x2d\x38\xc3\x16\x9c\x61\x0b\xce\xb0\x05\x67\xd8\x82\x33\x6c\xc1\x19\xb6\xe0\x0c\x5b\x70\x86\x2d\x38\xc3\x16\x9c\x61\x0b\xce\xb0\x05\x67\xd8\x82\x33\x6c\xc1\x19\xb6\xe0\x0c\x5b\x70\x86\x2d\x38\xc3\x16\x9c\x61\x0b\xce\xb0\x05\x67\xd8\x82\x33\x6c\xc1\x19\xb6\xe0\x0c\x5b\x70\x86\x2d\x38\xc3\x16\x9c\x61\x0b\xce\xb0\x05\x67\xd8\x82\x33\x6c\xc1\x19\xb6\xe0\x0c\x5b\x70\x86\x2d\x38\xc3\x16\x9c\x61\x0b\xce\xb0\x05\x67\xd8\x82\x33\x6c\xc1\x19\xb6\xe0\x0c\x5b\x70\x86\x2d\x38\xc3\x16\x9c\x61\x0b\xce\xb0\x05\x67\xd8\x82\x33\x6c\xc1\x19\xb6\xe0\x0c\x5b\x70\x86\x2d\x38\xc3\x16\x9c\x61\x0b\xce\xb0\x05\x67\xd8\x82\x33\x6c\xc1\x19\xb6\xe0\x0c\x5b\x70\x86\x2d\x38\xc3\x16\x9c\x61\x0b\xce\xb0\x05\x67\xd8\x82\x33\x6c\xc1\x19\xb6\xe0\x0c\x5b\xb8\x38\x6e\xe1\xe2\xb8\x05\xe7\xd8\xc2\xc5\x71\x0b\x4e\xb2\x05\x27\xd9\x82\x93\x6c\xc1\x49\xb6\xe0\x24\x5b\x70\x92\x2d\xf0\xbf\x05\xfe\xb7\xc0\xff\x16\xf8\xdf\x02\xff\x5b\xe0\x7f\x0b\xfc\x6f\x81\xff\xad\xf2\xa2\x50\xa4\x3a\x16\xcb\xcf\x2b\x6a\x5d\x99\x60\x01\x58\xb0\x00\x2c\x58\x00\x16\x2c\x00\x0b\x16\x80\x05\x0b\xc0\x82\x05\x60\xc1\x02\xb0\x60\x01\x58\xb0\x00\x2c\x58\x00\x16\x2c\x00\x0b\x16\x80\x05\x0b\xc0\x82\x05\x60\xc1\x02\xb0\x60\x01\x58\xb0\x00\x2c\x58\x00\x16\x2c\x00\x0b\x16\x80\x05\x0b\xc0\x82\x05\x60\xc1\x02\xb0\x60\x01\x58\xb0\x00\x2c\x58\x00\x16\x2c\x00\x0b\x16\x80\x05\x0b\xc0\x82\x05\x60\xc1\x02\xb0\x60\x01\x58\xb0\x00\x2c\x58\x00\x16\x2c\x00\x0b\x16\x80\x05\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x0b\x20\x0c\x46\x0f\x83\xd1\xc3\x60\xf4\x30\x18\x3d\x8c\x95\x23\x8c\x95\x23\x8c\x95\x23\x8c\x95\x23\x8c\x95\x23\x8c\x95\x23\x8c\x95\x23\x8c\x95\x23\x8c\x95\x23\x8c\x95\x23\x8c\x95\x23\x8c\x95\x23\x5c\xdc\x8a\x03\xbd\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\xb1\x72\x84\x4b\x1c\x25\x51\x1b\x5d\x1d\x49\x91\xbe\x43\xa4\x3a\x11\xad\x89\xd7\xf9\x62\xa3\x0c\x6a\x53\x3d\x71\x55\xa4\x3e\x92\x4c\x28\xb5\xb1\xa6\xd8\x2a\x25\x99\x90\x56\xb9\xe2\x65\x54\xbc\x3c\x6a\xeb\xe1\xb8\x74\x04\xfc\x4a\x4b\x4b\xd4\x55\xcd\x15\xcd\xc9\x84\x5a\x15\xa9\x89\x26\x6a\x95\xfa\x68\x32\x5a\xa3\xd4\x47\x56\x45\xaa\x45\x53\xa4\x3a\x2a\x4b\x26\xa2\xab\x34\xf7\xe7\x6f\xee\x8d\xf1\x84\x17\xe9\x89\xb8\x44\x4d\x34\xaf\x0a\x35\x37\x36\x46\x9b\x96\xb9\x49\x75\xf1\x35\xd1\x26\x29\xf8\xf5\x96\x15\xa4\xfa\x60\xab\x24\x70\x83\x88\xd4\x45\xab\xb9\x74\x58\x94\x9a\x58\x7d\xb4\x4e\xa9\x92\xfb\x49\x56\x1b\xe5\xab\x23\xab\x95\xf5\x91\x75\xb1\x06\x2e\x5d\x15\x9e\x94\xdb\xba\x78\x95\x5e\x1d\x6b\x88\xd4\xad\x8c\x54\x73\xb9\x29\x52\xd5\x28\x92\xea\xa3\xf5\x5c\x6e\xfe\x4e\x43\x73\x03\x97\x9b\x9a\x90\xc7\x57\xd6\x0a\xb7\x12\xcd\x3b\xd0\x18\x65\x8d\xd1\x14\x4f\x4c\x26\xa4\xab\xa2\x78\x21\x5f\x15\x97\x0d\x92\x2d\x14\x6e\x53\xa4\x8f\xb3\x5a\x95\xe0\xab\xfd\x48\x82\xaa\x72\x73\xa3\x1a\xd7\x93\xa9\x0d\xc9\x28\x51\x2b\xeb\xf4\xba\x29\xbf\xdc\x3f\x57\x64\x9c\x8f\xd8\x40\x6c\x22\xb6\x10\x87\x11\x17\x20\x2e\x44\x5c\x84\xb8\x18\x71\x09\xe2\x52\xc4\x65\x88\xcb\x11\xdb\x88\x1d\x3f\xce\x07\x7e\x3e\xf0\xf3\x81\x9f\x0f\xfc\x7c\xe0\xe7\x03\x3f\x1f\xf8\xf9\xc0\xcf\x07\x7e\x3e\xf0\xf3\x81\x9f\x0f\xfc\x7c\xe0\xe7\x03\x3f\x1f\xf8\xf9\xc0\x37\x80\x6f\x00\xdf\x00\xbe\x01\x7c\x03\xf8\x06\xf0\x0d\xe0\x1b\xc0\x37\x80\x6f\x00\xdf\x00\xbe\x01\x7c\x03\xf8\x06\xf0\x0d\xe0\x1b\xc0\x37\x81\x6f\x02\xdf\x04\xbe\x09\x7c\x13\xf8\x26\xf0\x4d\xe0\x9b\xc0\x37\x81\x6f\x02\xdf\x04\xbe\x09\x7c\x13\xf8\x26\xf0\x4d\xe0\x9b\xc0\xb7\x80\x6f\x01\xdf\x02\xbe\x05\x7c\x0b\xf8\x16\xf0\x2d\xe0\x5b\xc0\xb7\x80\x6f\x01\xdf\x02\xbe\x05\x7c\x0b\xf8\x16\xf0\x2d\xe0\x5b\xc0\x0f\x03\x3f\x0c\xfc\x30\xf0\xc3\xc0\x0f\x03\x3f\x0c\xfc\x30\xf0\xc3\xc0\x0f\x03\x3f\x0c\xfc\x30\xf0\xc3\xc0\x0f\x03\x3f\x0c\xfc\x30\xf0\xc3\xc0\x2f\x00\x7e\x01\xf0\x0b\x80\x5f\x00\xfc\x02\xe0\x17\x00\xbf\x00\xf8\x05\xc0\x2f\x00\x7e\x01\xf0\x0b\x80\x5f\x00\xfc\x02\xe0\x17\x00\xbf\x00\xf8\x05\xc0\x2f\x04\x7e\x21\xf0\x0b\x81\x5f\x08\xfc\x42\xe0\x17\x02\xbf\x10\xf8\x85\xc0\x2f\x04\x7e\x21\xf0\x0b\x81\x5f\x08\xfc\x42\xe0\x17\x02\xbf\x10\xf8\x85\xc0\x2f\x02\x7e\x11\xf0\x8b\x80\x5f\x04\xfc\x22\xe0\x17\x01\xbf\x08\xf8\x45\xc0\x2f\x02\x7e\x11\xf0\x8b\x80\x5f\x04\xfc\x22\xe0\x17\x01\xbf\x08\xf8\x45\xc0\x2f\x06\x7e\x31\xf0\x8b\x81\x5f\x0c\xfc\x62\xe0\x17\x03\xbf\x18\xf8\xc5\xc0\x2f\x06\x7e\x31\xf0\x8b\x81\x5f\x0c\xfc\x62\xe0\x17\x03\xbf\x18\xf8\xc5\xc0\x2f\x01\x7e\x09\xf0\x4b\x80\x5f\x02\xfc\x12\xe0\x97\x00\xbf\x04\xf8\x25\xc0\x2f\x01\x7e\x09\xf0\x4b\x80\x5f\x02\xfc\x12\xe0\x97\x00\xbf\x04\xf8\x25\xc0\x2f\x05\x7e\x29\xf0\x4b\x81\x5f\x0a\xfc\x52\xe0\x97\x02\xbf\x14\xf8\xa5\xc0\x2f\x05\x7e\x29\xf0\x4b\x81\x5f\x0a\xfc\x52\xe0\x97\x02\xbf\x14\xf8\xa5\xc0\x2f\x03\x7e\x19\xf0\xcb\x80\x5f\x06\xfc\x32\xe0\x97\x01\xbf\x0c\xf8\x65\xc0\x2f\x03\x7e\x19\xf0\xcb\x80\xef\x00\xc7\xb7\xc9\xf2\x6d\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x17\x3a\xea\x22\xef\x5e\xa7\xba\xc6\x8f\x16\xf9\x8f\x36\xae\xf1\xa2\xd0\xa2\xd6\x0b\xec\xa1\x35\xad\x92\x5f\x0e\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x06\xcf\xd8\xe0\x19\x1b\x3c\x63\x83\x67\x6c\xf0\x8c\x0d\x9e\xb1\xc1\x33\x36\x78\xc6\x2e\xb6\x43\x25\xad\xf7\x2b\x43\x91\x56\x29\xa5\xa4\xed\xce\x6c\x4a\xa4\x4d\xcc\x2c\x69\x7f\xd4\xd3\xeb\x86\xcc\x48\xe7\x84\x40\x0e\xaf\xdb\x82\x39\xbc\x84\xec\x40\x8e\xb6\x8a\xb3\x23\xdd\x24\x06\xeb\xf2\xee\x2c\x07\xeb\xf2\x12\x7a\x05\x72\xb4\x6a\xde\x2b\xd2\x35\x2d\xd5\x7f\x34\xdc\x7f\x0c\x2d\x12\x90\xfd\x74\x4f\x2f\xa4\x7b\x72\x0f\x3f\xbd\x4d\x93\x1e\x91\x8e\xfb\x28\xe7\xe9\x80\x72\x9e\x9c\xe1\xa7\xb7\xc2\x66\x44\x3a\xec\x86\xec\x36\xa9\x2d\x2d\xc5\x6e\xef\xe7\xf6\xfa\x55\xdb\x7f\xb4\xd7\xaf\x35\xd3\xee\xdc\xc9\xd1\xce\x09\x76\xe7\x5e\x8f\x76\xee\x75\xbb\xbb\x5e\x8f\x76\xd7\xeb\x76\xe7\x5e\x8f\x76\xee\x75\xbb\x9b\x5e\x8f\x76\x4d\x4b\x99\xd6\xde\xb6\x58\x9b\x18\x9a\xd6\xd6\x0b\xb1\x36\x69\x76\x9b\x14\x6f\x2b\x3d\xbb\xbd\x74\xbc\x5d\xbb\xd9\x9d\x9b\x1e\xef\x9c\x30\xbb\x73\x5f\xc4\x3b\xf7\xc5\xec\xee\xfa\x22\xde\x5d\x5f\xcc\xee\xdc\x17\xf1\xce\x7d\x31\xbb\x9b\xbe\x88\x77\xd3\x17\xde\x63\xbf\xfe\xe3\x92\xf1\x76\xd1\x4b\xf5\x94\xf2\x53\x3d\x31\xc3\x4b\x6d\x53\x22\x23\xde\x61\xd7\x2f\xe3\x81\xfb\x65\x3c\x31\xdd\x4b\x6d\x45\x4b\x8f\x07\xf7\x42\x0b\xda\xa4\xe6\x36\x7d\x16\xb4\x57\xd8\xdc\x2e\x2e\x68\x57\xad\xb9\x5d\x5c\xd0\xae\x65\x73\xbb\x96\x0b\x3a\x6a\xd9\xdc\x51\xcb\x05\xed\x5a\x36\xb7\x6b\xb9\xa0\x83\x96\xcd\xc1\x3d\x75\x89\xbf\xcc\xae\xf3\xa2\xd0\x92\x36\x9d\xd7\xb5\xe9\xbc\xa4\xbd\xfa\x75\xed\xe7\xca\x12\xff\x5c\x59\xe7\x3f\x06\xef\xae\x69\x0e\x6c\x36\x07\x36\x9b\x03\x9b\xcd\x81\xcd\xe6\xc0\x66\x73\x60\xb3\x39\xb0\xd9\x1c\xd8\x6c\x0e\x6c\x36\x07\x36\x9b\x03\x9b\xcd\x81\xcd\xe6\xc0\x66\x73\x60\xb3\x39\xb0\xd9\x1c\xd8\x6c\x0e\x6c\x36\x07\x36\x9b\x03\x9b\xcd\x81\xcd\xe6\xc0\x66\x73\x60\xb3\x39\xb0\xd1\x1c\xd8\x68\x0e\x6c\x34\x07\x36\x9a\x03\x1b\xcd\x81\x8d\xe6\xc0\x26\x73\x60\x93\x39\xb0\xc9\x1c\xd8\x64\x0e\x6c\x32\x07\x36\x99\x03\x9b\xcc\x81\x4d\xe6\xc0\x26\x73\x60\x93\x39\xb0\xc9\x1c\xd8\x64\x0e\x6c\x32\xc7\x68\xc5\x43\xfb\x60\x93\x39\xb0\xc9\x1c\xd8\x64\x0e\x6c\x32\x07\x36\x99\x03\x9b\xcc\x81\x4d\xe6\xc0\x26\x73\x60\x93\x39\xb0\xc9\x1c\xd8\x64\x0e\x6c\x32\x07\x36\x99\x03\x9b\xcc\x81\x4d\xe6\xc0\x26\x73\x60\x93\x39\xb0\xc9\x1c\xd8\x64\x0e\x6c\x32\x07\x36\x99\x03\x9b\xcc\x81\x4d\xe6\xc0\x06\x73\x60\x83\x39\xb0\xc1\x1c\xd8\x60\x0e\x6c\x30\x07\x36\x98\x03\x9b\xcb\x81\xcd\xe5\xc0\xe6\x72\x60\x73\x39\xb0\xb9\x1c\xd8\x5c\x0e\x6c\x2e\x07\x36\x97\x03\x5b\xcb\x81\x8d\xe5\x84\x5b\xeb\x85\xfe\xb0\xa9\x1c\xd8\x54\x0e\x6c\x2a\x07\x36\x95\x03\x9b\xca\x81\x4d\xe5\xc0\xa6\x72\x60\x53\x39\xb0\xa9\x1c\xd8\x54\x0e\x6c\x2a\x07\x36\x95\x03\x9b\xca\x81\x4d\xe5\xc0\xa6\x72\x60\x53\x39\xb0\xa9\x1c\xd8\x54\x0e\x6c\x2a\x07\x36\x95\x03\x9b\xca\x81\x4d\xe5\xc0\xa6\x72\x60\x53\x39\xb0\xa9\x1c\xd8\x54\x0e\x6c\x2a\x07\x36\x95\x03\x9b\xca\x81\x4d\xe5\xc0\x57\x77\xe0\xab\x3b\xf0\xd5\x1d\xf8\xea\x0e\x7c\x75\x07\xbe\xba\x03\x1b\xca\x81\x0d\xe5\xc0\x86\x72\x60\x43\x39\xb0\xa1\x1c\xd8\x50\x0e\x6c\x28\xa7\xa8\x15\x0f\xed\x85\x0d\xe5\xc0\x86\x72\x60\x43\x39\xb0\xa1\x1c\xd8\x50\x0e\x6c\x28\x07\x36\x94\x03\x1b\xca\x81\x0d\xe5\xc0\x86\x72\x60\x43\x39\xb0\xa1\x1c\xd8\x50\x0e\x7c\x75\x07\xbe\xba\x03\x5f\xdd\x81\xaf\xee\xc0\x57\x77\xe0\xab\x3b\xf0\xd5\x1d\xf8\xea\x0e\x7c\x75\x07\xbe\xba\x03\x5f\xdd\x81\xaf\xee\xc0\x57\x77\xe0\xab\x3b\xf0\xd5\x1d\xf8\xea\x0e\x7c\x75\x07\xbe\xba\x03\x5f\xdd\x81\xaf\xee\xc0\x57\x77\xe0\xab\x3b\xf0\xd5\x1d\xf8\xea\x0e\x7c\x75\x07\x3e\xba\x03\x1f\xdd\x81\x8f\xee\xc0\x47\x77\xe0\xa3\x3b\xf0\xd1\x1d\xf8\xe8\x0e\x7c\x74\x07\x3e\xba\x03\x1f\xdd\x81\x8f\xee\xc0\x47\x77\xe0\xa3\x3b\xf0\xd1\x1d\xf8\xe8\x0e\x7c\x73\x07\xbe\xb9\x03\xdf\xdc\x81\x6f\xee\xc0\x37\x77\xca\x80\x5b\x06\xdc\x32\xe0\x96\x01\xb7\x0c\xb8\xe5\xc0\x2d\x07\x6e\x39\x70\xcb\x81\x5b\x0e\xbc\x72\xe0\x95\x03\xaf\x1c\x78\xe5\xc0\x2b\x07\x5e\x39\x70\xca\x81\x53\x0e\x1c\x1b\x38\x36\x70\x6c\xe0\xd8\xc0\xb1\xd1\x3e\x1b\xe3\x6a\x03\xd7\x06\xae\x0d\x5c\x1b\xb8\x36\x70\x6d\xe0\xda\x68\xa7\x0d\x7c\x1b\xf8\x36\xf0\x1d\xe0\x39\xc0\x73\x80\xe7\x00\xc7\x01\x8e\x03\x1c\x07\x38\x0e\x70\x1c\xe0\x38\xc0\x71\x80\xe3\x5f\x03\x31\xf2\x7c\x9e\x93\x71\x39\xe2\xd6\x74\xc7\x8f\x7d\x5e\x93\x71\x38\xdd\x7b\x1b\x9a\xf7\x33\xcd\xaa\x8a\xba\xf4\x55\xcd\x71\xf7\x55\x9c\xee\x2f\x37\xa3\x55\xc8\x83\x32\x3e\xd7\xc8\xb8\x14\x31\x30\x0c\x60\x18\xb6\x5a\x1f\x6b\xf0\x7e\x30\x17\xad\x8c\x37\xa0\xb4\x69\x85\xa2\x6b\x2b\xeb\x22\xf5\xb2\xf6\x50\x53\xa4\xca\x7d\xaf\x5f\x74\xad\x7f\x2c\x0c\xad\x0a\x50\x73\x01\x6a\x2e\x40\xcd\x05\xa8\xb9\xa0\x35\x9f\x13\x6a\x48\x34\x37\x46\x9b\x62\xf1\x26\x3f\xc5\x5f\x1f\x64\x9c\x8f\x18\xed\xf2\xd7\x07\x19\x5b\x7e\x5c\x82\x7c\x25\xc8\x57\x62\x88\xba\x58\x53\x04\x3b\x61\xc4\x05\x6a\x63\x34\x11\x4d\xb6\x26\x17\x21\x2e\x56\x13\xb5\xd1\x55\xd1\x3a\x51\x15\x6f\xa8\x11\xee\x9b\x02\x71\x00\xea\x95\x40\xbd\x12\x74\x54\x29\xc0\x4a\x01\x56\x0a\xa5\x4a\xa1\x54\x29\x94\x2a\x05\xae\x7f\xf3\xd2\xc8\xf7\x8d\x1a\x23\xdf\x37\x36\x64\x5c\x80\xb8\x90\xcf\xae\xad\x0f\x45\x13\xc9\x58\x7d\x24\x89\x61\xc9\xf7\x29\x4f\xc6\xb6\x1e\x6f\x88\x26\x6b\x63\x4d\x55\xa1\xe4\x9a\xb8\x27\x24\x42\x32\x29\xea\xbe\xdf\xb7\x36\x2d\x59\xdb\x14\x85\x9c\x48\xad\x8e\xad\x6e\x95\xd3\x12\x72\x94\x1b\xb0\xe3\x57\x55\x64\x85\x22\x4d\x4d\xf1\x35\x75\xd1\xea\xa4\xe6\x49\xcd\x8d\x29\x5e\xec\xbd\x2b\xd8\x3f\x58\x15\x5f\xd3\xe0\x4b\x15\x12\x2c\x84\x6c\x55\x0d\x69\x6d\x52\x45\xc2\xb3\xe6\x0c\xfc\xec\xc7\x30\xf2\xc3\x29\xf1\xa6\x64\xad\xfb\xcb\xc4\x48\x5d\x5a\xac\x21\xe9\xce\x2e\xef\x75\xad\xa9\xd1\x55\xcd\xb1\xd5\x72\x46\x34\x54\x46\x95\xda\x78\x73\x22\x9a\x2e\x27\x5f\x5d\xbc\xc6\x9d\x26\x0d\xf1\x64\x8a\x9b\x59\xda\x95\x75\xc9\xc6\x36\xb1\xc2\xbb\x2d\x66\xe0\x9e\xab\x81\x7b\xad\x06\xee\x91\x1a\xb8\x17\x2a\x63\x0b\x71\x11\x62\x1c\x37\x90\x8e\xf9\x1b\x36\xb1\x6f\x62\x3f\x8c\xf2\xbe\x0d\x21\x63\xd4\xef\xdb\x10\x32\x46\x7e\xdf\x86\x90\x71\x01\xe2\x42\xc4\xc0\xf3\x6d\x09\x19\x97\x20\x2e\x45\xdc\x8a\x53\x8e\xd8\x46\xec\x4f\x9f\x70\x01\xf0\x0b\x80\x5f\x00\xfc\x02\xe0\x17\x00\xbf\x00\xf8\x05\xc0\x2f\x00\x7e\x01\xf0\x0b\x80\x8f\xb3\x2b\x8c\xb3\x2b\xec\x9e\x5d\x8d\x15\x75\xf1\xca\x95\x9a\x1c\x2b\x37\x56\xfc\xbd\xba\x6a\x3f\x6e\x4a\x62\x3f\x99\xa8\x8d\x54\x45\x15\x2f\xd4\xaa\x56\x7a\x71\xa8\x3a\x56\x57\x27\x97\x8a\xb8\x7f\x0e\xe3\xce\xad\x81\x3b\xaf\x32\x2e\x4d\xf1\x73\x34\xc9\x11\xd6\x92\x4d\xb1\x48\x4d\x73\xa3\x1f\x37\x61\xbf\xaa\xc1\x8f\xeb\xaa\x55\xd7\xdf\xaa\xf3\x67\x4b\xb8\x0c\xfd\x52\xe6\x84\x62\x0d\xab\x2b\x9a\x65\x25\x49\x57\xf2\xf3\xa4\xc4\x1b\xa3\x0d\x48\x4c\xd4\xc7\xe4\x14\x8d\x54\x46\xe5\x5c\x5a\xdd\xb6\xc3\x13\xcd\x0d\x6a\x75\xb4\x5e\xce\x26\xe1\x06\x4a\xa2\x51\xea\x2b\x2a\xeb\x9a\x2b\x94\xda\x68\x44\xa2\x57\xc5\x22\xf5\x72\x61\x4a\xad\x6f\x4e\x60\x7e\x45\x33\x02\xb2\x5c\xa1\x3c\x0d\x0a\x7c\x6b\xcb\x28\xc3\x48\x94\x61\x24\xca\x30\x12\x65\x18\x89\x32\x8c\x44\x19\x46\xa2\x0c\x23\x51\x86\x91\x28\xc3\x48\x94\x61\x24\xca\x30\x12\x65\x18\x89\x32\xac\x73\x65\x58\xe7\xca\x0a\x81\x53\x08\x9c\x42\xe0\x14\x02\xa7\x10\x38\x85\xc0\xf1\xad\x3a\x03\x57\x8c\x4b\x0a\xdb\xe2\x22\xc4\xc5\x88\x4b\x10\x97\x22\x2e\x43\x5c\x8e\xd8\x46\xec\xf8\xb1\xef\xa5\xc8\x38\xdf\x8f\x8b\x50\x5f\x11\xea\x2b\x42\x7d\x45\xa8\xcf\xb7\xe2\xa4\x91\x52\x8e\xd8\x4e\xf3\xef\x00\x2f\xf3\x6e\x95\xf7\x90\xa7\x6f\x54\xba\xa4\xee\x1b\x60\xdd\x5b\xcb\xba\x7b\x07\x7b\x4d\x4c\xce\x25\xef\xde\xb5\x2b\xa9\xb5\x51\x37\xd2\x56\x46\xfc\x03\xde\x8d\x6a\x57\x4a\x6b\xbd\x59\xed\xee\xe8\xee\xed\x64\x2f\x5f\x32\xb2\xda\x3b\x2a\x6b\x5e\xd6\x58\xd7\x9c\x70\x5f\x2a\x9a\xea\xde\x8c\xc6\xbd\xf5\x14\x4f\xf6\xc4\x2c\x2f\xc9\xbb\x21\x8f\x83\x99\x81\x14\x2f\x21\xe4\x2a\xe4\xa9\x9a\xe2\x4a\xfe\xcd\x76\x2f\xb1\x3e\xd2\x18\x5b\x15\xaa\x88\x26\xfd\xec\xa9\xde\x2d\x77\xc8\x9e\xf2\xbe\xac\xd7\x46\x7d\x21\xb4\x3a\xb2\x1a\x87\xbd\x5b\xf1\x48\x4d\xb6\x66\x0c\xc9\x4e\xf1\xa5\x8c\xd6\x1b\xf3\x38\xd0\x26\xa5\x7a\x6d\x47\xaa\x6c\x38\xa4\x86\x66\x54\x96\xe6\xdf\xa4\xf7\x77\xd2\x71\x97\x1e\x6a\xb4\x0a\xa9\xde\x6d\x7a\x94\x5c\x15\x47\xcd\x29\x6e\xf7\x41\x6c\xef\x82\x50\xb2\x55\x65\x5d\x2a\xef\x3f\xce\x20\x1b\xec\x3e\xaf\xe0\x0e\x87\x1b\x4b\x5a\x74\x23\xaf\x47\x3c\xed\xbc\x61\xc6\x0d\x06\x07\x37\x18\x1c\xdc\x60\x90\xb1\x99\xd9\xec\xbf\xf8\xb5\xed\xc7\x95\xe9\x95\xeb\x9a\xe4\xaa\x10\xab\xf4\xae\xab\x65\x7a\x3f\x88\x0f\x1c\xce\x0a\xc8\x4d\xee\xf3\xda\x51\x5d\x0e\x4b\x5d\x34\x91\x58\x91\x2a\x99\xac\xda\x7d\x1b\xaf\xcb\x16\x92\xdf\x5a\xe5\x74\x8f\xd7\x5a\xf7\xd2\xaa\xe3\xcd\x4d\xed\x3b\x72\xa2\xb5\xe5\xf3\x68\xae\x6d\xcf\xe3\xbb\xb6\xbd\xd6\x0b\x14\xb9\x72\x1e\xe5\x67\xb4\x5d\x99\x70\x77\xad\x74\x68\x10\xf3\x0e\xf6\x90\x2d\x73\x7f\xf7\xe2\xfe\x36\x26\xb7\x32\xd2\x18\xd8\xcf\xef\xb4\x5f\xd6\x69\x3f\x2f\xb0\x5f\xd8\xa9\xbc\xd9\xb6\xdf\xda\x41\xcb\xe2\x49\xf7\x6d\xe7\x21\xaf\xa3\x72\x65\x2a\x72\x5a\x9d\x6a\xb2\x3a\x21\x9b\xdd\xec\x17\x05\xf6\xf3\x5d\xf4\xc0\x7e\x59\xa7\x7d\xab\x35\x7f\x5a\x45\xa4\x29\x96\x8b\xc6\xf7\xf2\x0e\x96\xe6\xfb\x19\xf2\xdd\x4a\xf3\xba\x49\xcb\xef\x94\x66\x75\x93\xcf\xea\x94\xaf\xa0\x9b\xfa\x0a\xba\xa9\xaf\xa0\x9b\xfa\x0a\x3a\xd5\x57\xdc\x8d\x7e\xc5\xdd\xe8\x57\xdc\x8d\x7e\xc5\xdd\xe8\x57\xdc\x8d\x7e\xc5\xdd\xe8\x57\xdc\x8d\x7e\xc5\x5d\xf5\x2b\x0b\x77\xd5\xaf\x43\x5a\xe7\x7c\x56\x37\xf9\x3a\xd7\x57\xd0\x4d\x7d\x05\xdd\xd4\x57\xd0\x4d\x7d\xdd\xf5\x5f\x51\xeb\x24\xeb\x26\xad\x73\xbe\x82\x6e\xf2\x15\x74\xc2\xed\x54\x5f\x87\xb4\xce\xf9\x0a\xba\xc9\xe7\xd5\xe7\xfe\x20\x4b\x12\x73\xcc\xbb\x9c\xa9\xdb\x0d\x35\xde\xc9\xd8\x2a\x18\xad\x82\xa9\xaf\x8f\x36\xc5\x5d\x49\x93\xcb\x85\x17\xcb\xa5\xc2\x8d\x43\xde\x32\xe1\x4a\xba\xbb\x44\xf8\x42\xcc\x3f\xc5\xb5\x44\x6c\xad\x97\xc7\x5b\x22\x3c\xc9\x5b\x1e\xbc\x4c\x0d\x31\xbf\xa2\x1e\x9d\xae\x52\xf7\xe8\x74\x4d\x3a\xa3\xe3\xd5\xe7\x1e\x9d\x2e\x33\xa7\xb4\xdf\xb3\x48\x69\xbf\x4d\x11\x6a\xbb\x2b\x91\xd2\x7e\x0f\xa2\x67\x27\xa4\xdc\xba\xca\x9e\x9d\xc0\x64\x52\x56\x47\xbc\x8e\x99\xbc\x7a\x64\x52\x7a\x3b\x6a\xdb\x5e\x6b\x05\x69\x6d\xd8\x6d\x87\x5a\x8b\xe9\x7e\x9e\xe6\x4a\xdd\x2f\xda\x5c\x99\xde\x5e\xb7\x9b\xec\xad\xdb\x52\x48\x6d\xbd\x73\xe6\x26\xfa\xa5\x9b\x2b\x7b\x04\xdf\x47\xe2\x1e\xf0\x97\x30\x79\xc0\x7f\xb1\xc9\xb2\xa6\x68\x75\xb4\x49\xba\x99\x99\x1e\x87\x78\x4c\x03\x36\x6a\x4f\x68\xa3\x45\x9f\x84\xd3\x5b\x77\xbd\xa7\xf5\x7a\xb5\x11\x50\xfb\x63\x7b\x19\x6d\x69\x9d\x76\xbd\x27\xf6\x32\x03\xa6\x87\x97\xea\x11\x3c\x48\xb2\xd9\x7b\x68\x4f\xba\x5d\xa5\xe5\x90\x8d\x80\x6c\xba\xb2\x98\xb7\xac\xd4\x96\xc1\x7c\x37\x98\x63\x13\x7c\x5d\x47\x27\x8c\x64\x11\xba\xc3\xfd\xce\x0c\xde\xdf\xbd\x65\xe2\x15\xcf\xbb\xf1\x53\x73\x6e\x5b\xed\xed\x9f\xb1\xc3\xff\x8a\x8e\xfb\xfd\xc1\xb5\x64\x83\xf7\xd6\xef\x2c\x42\xc4\x93\x84\x8a\xa7\xc4\x36\xc2\xc5\x0f\xe2\x07\x29\xff\x28\x7e\x94\xf2\xbf\xc4\xbf\xa4\xfc\x93\xd8\x2e\xe5\xdf\xc4\x6f\x52\x6e\x11\x2d\x52\xde\xa1\xdf\x4e\xa8\x7e\x87\x7e\x07\xe1\xfa\x9d\xfa\xbb\x52\x7e\x4f\x7f\x8f\x30\xfd\xfd\xd0\x2c\x42\x43\xb3\x43\x07\x10\xe6\xbe\x8b\x49\xca\xf3\x43\x0b\x09\x0f\x2d\x0a\x2d\x71\xbf\xfd\xec\xbf\x63\xdc\xc3\x6f\xdd\x52\x48\x2e\x59\x4c\x98\x64\x94\x3a\x92\x51\x1b\xad\x68\x22\xfd\xbc\x7c\xee\x17\xbf\x48\x9b\xe4\xe5\x76\x09\x48\xb6\x91\xb8\xdf\x4a\xda\xe5\x7b\xc8\xfb\xc8\x3a\x0b\xc8\x24\xe2\x90\x59\x64\xa1\xf7\xf5\x81\x0d\xe4\x54\x72\x0e\xb9\x84\x5c\x4d\x36\x91\xb7\xc9\x27\xe4\x2b\xf2\x23\x69\xa1\x2a\xcd\xa0\x7d\x64\x1d\x54\xfe\x7f\x23\x63\x8d\x50\x7e\xba\xbf\xcf\xef\xf2\x63\x71\xbc\x1f\xa7\x38\x12\x43\xb6\x20\xb3\x29\xf3\xb1\xac\x3e\x59\xb5\xfe\x5e\xd6\x0d\x3d\xf7\xe8\x79\x75\xaf\xd1\xfe\x5e\xaf\x33\x7b\x7d\x94\x5d\x90\x7d\xa2\xbf\x97\xbd\xa5\xf7\xac\xde\x4f\xf4\x99\xea\x97\xef\x73\x9b\x1f\xf7\x5f\xe1\xc7\x83\xfa\x78\xb9\xf4\x21\x8f\x0c\xcd\x1b\xba\x71\xe8\x47\x39\x93\x72\xce\xcb\xf9\x6e\xd8\x0c\x2f\x35\x7d\xd8\x89\xc3\xee\x19\xb6\x75\x78\xbf\xe1\x53\x87\xaf\x1d\x7e\xed\xf0\xd7\x47\xe8\x23\x8a\x46\xd4\x8e\x38\x6f\xc4\x53\xde\x71\x36\xe2\xf5\x3d\x54\xbf\x9e\x3d\xf6\xf6\xe3\x51\xaf\xfa\xf1\xde\xe7\xf8\xf1\xd8\x97\xbc\x56\xd1\xfc\x33\x11\x5f\x20\xfb\xcb\x8d\xef\x22\x94\x9d\xc3\x1a\x64\x78\x91\xec\xad\x19\xe4\x02\x72\x99\xec\x95\x1b\xc8\x6d\xe4\x1e\xf2\x20\x79\x8c\x3c\x43\x5e\x20\xaf\xca\x3e\xfa\x80\x6c\x95\xbd\xb4\x8d\xfc\x22\x0b\xa9\x34\x8d\xf6\xa4\xfd\xe8\x10\xba\x07\xdd\x9b\xe6\xd1\x02\x3a\x81\x96\xd2\xa9\x74\x16\x9d\x4f\x97\xd2\xe5\xb4\x9a\xd6\xd1\x26\xba\x96\x1e\x41\x8f\xa5\x1b\xe9\xe9\xf4\x1c\x7a\x11\xbd\x82\x5e\x4b\x6f\xa2\x77\xd0\xfb\xe8\x66\xfa\x04\xdd\x42\x5f\xa2\xaf\xd3\x77\xe8\x47\xf4\x33\xfa\x0d\xfd\x91\x6e\x67\x8c\xe9\x2c\x83\x65\xb3\x01\x2c\x87\x8d\x62\x63\x98\xc1\x8a\xd8\x24\x56\xce\xa6\xb3\x39\x6c\x21\x3b\xc8\x1d\x71\xe5\x1c\x19\x66\x7b\xe1\x53\x5e\x48\xda\x43\x56\xe3\xc9\x6f\x77\x4e\xa7\xa7\x77\x4e\xd9\xf1\x41\x67\xd9\xcf\x43\x45\x20\xe7\x90\xce\xa5\x76\x16\xee\x78\x2c\x90\xb2\xb6\x4b\x58\xa5\x5c\xde\x26\xef\xac\x86\x0f\x76\x55\xf3\x8e\xe5\x9d\xe5\x6e\xea\xd9\x49\x9f\xd0\x2d\x9d\xfb\x04\x29\x5d\xd0\xd1\x0f\xe2\xdf\x69\x75\xd7\x3a\x91\x67\x79\xb7\x3a\x33\xa2\x8a\x1d\xca\x20\x42\xf4\xf5\xfa\x7a\x32\x44\xae\x16\x77\x92\xa1\xfa\xdd\xfa\x83\x24\x47\xdf\x2c\x57\x8e\xd1\xa1\xfd\xe5\x9a\x31\xd5\x3b\xd7\xbe\xf1\xce\x73\x55\x8e\x6e\xb5\xb2\x42\xca\x83\xe4\x99\x4c\xc9\x70\x39\x4f\xdd\xb5\x83\xf2\xad\x5e\xad\x54\xd6\xe3\xe6\xfe\x29\x90\xdb\x4d\x7f\x42\x9e\xdf\x94\x6c\xf1\xbe\x5b\x3a\x8a\x8c\x21\x06\x29\x92\x6b\x40\x39\x99\x4e\xe6\xc8\x55\xe0\x20\x52\x41\x6a\xbd\x6f\x33\xac\x97\xab\xc1\xf1\xe4\x14\xb7\x1c\x5b\xdc\x1a\xd2\x29\x6c\x93\x94\x6f\xe7\x25\xb2\x8e\x87\xd9\x20\x19\x1a\x6e\x0a\x31\xf8\xfa\xd6\x50\xce\x4e\x37\xe7\x23\x64\x82\x1b\x06\xca\xde\xc3\x36\xc8\xf0\x26\xf6\x42\x5b\xfa\x15\xec\x2c\x19\xde\x44\x9f\x6c\x0d\x49\x4f\x45\x55\xd2\x94\x0c\x25\x4b\xc9\xf6\xdf\xab\x2b\xfb\xa3\xfd\x1d\x7f\xee\x1b\xfe\x36\xeb\x0f\x7b\xed\xfa\xbe\xbd\x5d\xae\x06\x72\x25\x7e\x8e\x30\xd9\x83\xf2\x6c\xa5\x06\x2d\xa2\x93\x68\x39\x9d\x4e\xe7\xd0\x85\xf4\x20\x5a\x41\x6b\x69\x03\x4d\xd2\xf5\x74\x03\x3d\x9e\x9e\x42\xcf\xa4\xe7\xd1\x4b\xe8\x95\xf4\x7a\x7a\x0b\xbd\x8b\x6e\xa2\x8f\xd0\xa7\xe8\x73\xf4\x15\xfa\x26\x7d\x8f\x7e\x42\xbf\xa0\xdf\xd1\x9f\x68\x0b\x13\x2c\x85\x65\xb2\x3e\x6c\x10\x1b\xce\x46\xb3\x5c\x66\xb1\xf1\x6c\x0a\x73\xd8\x0c\x36\x97\x2d\x66\x87\xb0\x2a\xb6\x82\x35\xb2\xd5\xec\x30\x76\x34\x3b\x91\x9d\xca\xce\x62\x17\xb0\xcb\xd8\xd5\xec\x06\x76\x1b\xbb\x87\x3d\xc8\x1e\x63\xcf\xb0\x17\xd8\xab\xec\x6d\xf6\x01\xdb\xca\xbe\x62\xdb\xd8\x2f\x9c\x70\x95\xa7\xf1\x9e\xbc\x1f\x1f\xc2\xf7\xe0\x7b\xf3\x3c\x5e\xc0\x27\xf0\x52\x3e\x95\xcf\xe2\xf3\xf9\x52\xbe\x9c\x57\xf3\x3a\xde\xc4\xd7\xf2\x23\xf8\xb1\x7c\x23\x3f\x9d\x9f\xc3\x2f\xe2\x57\xf0\x6b\xf9\x4d\xfc\x0e\x7e\x1f\xdf\xcc\x9f\xe0\x5b\xf8\x4b\xfc\x75\xfe\x0e\xff\x88\x7f\xc6\xbf\xe1\x3f\xf2\xed\x82\x09\x5d\x64\x88\x6c\x31\x40\xe4\x88\x51\x62\x8c\x30\x44\x91\x98\x24\xca\xc5\x74\x31\x47\x2c\x14\x07\x89\x0a\x51\x2b\x1a\x44\x52\xac\x17\x1b\xc4\xf1\xe2\x14\x71\xa6\x38\x4f\x5c\x22\xae\x14\xd7\x8b\x5b\xc4\x5d\x62\x93\x37\x37\x1c\x37\x54\xaf\x94\x63\xb3\xcd\x95\xe9\x36\x4f\xde\xe2\xc9\x5b\x5c\x99\x0d\xf2\xf2\x0c\xf2\xe4\x59\x9e\x3c\xcb\x93\x03\x65\x3b\xc8\xc1\x3c\x3b\xc9\x4f\xdf\xf3\xea\x7f\xaf\x33\x2e\x5b\xec\xe5\x59\xdc\xa5\xec\x26\x4f\xde\xd4\x05\x6b\x94\x27\x8f\xea\x92\xbf\xd1\x93\x1b\x3d\xb9\xdc\x93\xcb\xbb\xc8\x41\xac\x60\x7a\x9e\x27\xe7\x79\xba\x3d\xe2\xe9\xf6\xc8\x2e\xdb\xb8\xb3\x7e\xd8\xb5\xac\x77\x49\xdf\x49\x3f\xef\x4e\xff\x74\xd0\x33\xa8\xdb\x46\x4f\xfe\x69\xb7\x65\x5f\x9f\xb3\x76\x25\x77\x98\x27\xbe\x5c\xdb\x45\xff\xa0\x9e\xde\xd8\xd1\x8c\x76\x2c\x7a\x65\x97\xfa\x5f\x68\xcf\x83\x3a\x4f\xf7\xe4\x57\xdb\xe5\x0e\x75\x7a\xf5\xf0\x34\x4f\xd6\xbd\x3c\x53\x02\x75\x6e\x08\x8c\xe9\xe2\x9d\xc8\x7a\x97\xb1\x7e\x2f\xa0\x5b\xb0\x4f\x46\x05\xe6\x9e\xdf\x03\x7e\x5b\x74\x5f\x5b\x3f\x8f\x7f\xd6\xf8\x75\x06\xc2\xaf\x02\xb8\x01\x19\xe3\x75\x7a\x27\x79\xf7\xd9\x20\xab\xed\xfd\xe8\xee\xdb\xd1\x5f\xf6\xde\x8a\xfe\xba\x78\xd7\x7b\x07\xfa\x27\x72\x4d\xfc\x55\xda\x9e\xd2\x6e\x95\x36\x9e\xfb\xb5\x1e\x42\xe6\xca\x6d\xb1\xdc\x0e\x91\x5b\x95\xdc\x56\xc8\xad\x51\x6e\xae\xd5\x7b\x98\xdc\x8e\x96\xdb\x89\x72\x3b\x55\x6e\x67\xc9\xed\x02\x89\x71\x99\x8c\xaf\x6e\xd3\xbb\xfa\xbf\x2c\x6c\x08\xcc\xfb\x0c\x4f\xbe\xa0\x6d\x1d\xcf\xfd\x7f\xeb\xf8\xbf\xb5\x8e\xcf\x72\x6d\x7e\x84\x79\x81\xb0\xba\x3d\xe4\x33\xdb\xc3\x60\x7a\x87\xf0\xa0\x5d\x1e\xed\x12\xd2\x2b\x03\xe1\xb6\x40\x18\x48\xdf\x59\x59\x69\x81\xb4\xa7\x94\x07\xc2\xc5\x81\xf0\xac\xf6\x90\xde\xd3\x1e\xb2\xf1\xed\x21\xdf\xec\xa5\xb7\x74\xae\x87\xfb\x6d\xa9\xf3\xe4\x63\xbd\x3c\x8f\x74\xa9\x7f\xb7\x5b\x8a\xb0\x6b\x29\x3d\xd0\xf3\xb3\x76\xd5\xcf\xbb\xd3\x3f\xbe\x86\xd0\x33\x88\xf2\xc2\x1f\x0b\x69\x6d\xa0\xdf\x6a\x3b\xf7\x24\xc2\xe0\x3c\x59\xdc\x8e\xcb\x27\x05\xd2\x83\xf9\x2f\xf1\xf2\x64\x78\xf2\x46\x4f\x1e\x13\xd0\xf0\x5a\x2f\xdc\xe4\xa5\xf7\x0b\xb4\xd1\xfb\x56\x16\xdd\x12\x08\x83\x6d\xbf\x36\x10\x56\x07\xb4\x0d\xd4\x19\xec\xb7\x0e\x63\x17\x08\xbb\x19\xeb\x6d\x5d\x7a\x26\xd8\x96\xea\x40\x5b\x82\xfd\x30\xaa\x5d\xcf\x60\xfd\x1d\xe6\x79\xd7\x70\x7e\x27\x79\xf7\xd7\xf1\x01\xe2\x29\xf1\xac\x78\xa9\xc3\xd7\x2c\xde\xef\xe6\xfb\x15\xdf\x89\x6d\x62\xbb\x68\xf1\xdf\xde\x4c\x06\x90\xdd\x59\xc1\x09\x56\x70\xff\x3b\xbe\xb7\xc9\xcd\x3d\x77\x1e\x94\xdb\x63\x72\x7b\x46\x6e\x6e\xbf\xbc\x2a\xb7\xb7\xe5\xf6\x81\xd4\x66\xab\x8c\xbf\x92\x9b\xdb\x77\xbf\xb8\xa7\x68\x97\x73\x20\x7b\x27\xe1\xce\xf2\xec\xac\x54\xd7\xfc\x3b\x4b\x31\x76\x5a\x0f\xf7\x7c\x20\xea\xee\xbb\xb9\x88\x7b\xe5\x43\x7a\xff\xe2\x47\xc9\x7d\xcc\xbd\x0a\x13\x18\x01\xb7\xef\x87\xca\xa3\x19\xbb\xe2\x4d\x59\x23\x93\x35\x4e\xf0\xea\x24\x9d\x6a\xfc\xbd\xb2\xdd\x23\xfe\x8e\x8e\xde\xcc\x20\xde\x9c\xa0\xde\x9c\x18\xf6\x9f\xd6\xb1\x1b\x44\x57\xc7\xe9\xd0\x71\xb9\x57\x63\xa6\x0c\xfb\xff\x81\x99\xd9\x3a\x2f\x77\xd6\xeb\x29\xdd\xd5\xf5\xdf\x80\xdb\xe3\x77\xca\xfd\x97\x6a\xd0\xed\x58\xfe\x9f\xd7\x60\x67\x7d\xcf\x88\xd5\x61\x16\x65\xfd\xee\xec\xd9\xf5\xb9\xe5\xb6\xc4\x42\x4b\xa6\xef\x66\x8d\x3b\x1b\x37\x1f\xe7\xff\xa7\x8e\x3b\x99\xe9\xff\x86\x8e\xdd\xf6\x6b\xbb\x8e\xd3\x49\x5d\x40\xc7\x9e\xff\xe6\xf8\xfd\xfe\x5c\xd9\x59\xbf\xbb\x1a\x54\xfc\x97\x68\xd0\xfd\x5c\xd9\x15\xee\x7f\x5b\xcb\xbb\x1d\xcd\xff\x86\x96\x77\x37\xf6\xb8\x42\x7c\xd9\xff\xf0\x2b\xc4\xdf\xb8\x3e\xd6\xce\x42\xb6\xda\xbf\x62\xd0\x7d\x7a\x87\xfc\x24\x20\x9f\xd2\xa5\xec\x53\x81\x70\x97\x88\x5d\x43\x7a\x48\xe7\x30\x98\xbe\xd3\xb2\x64\xb7\x8f\xee\x3a\x67\xd7\x3e\x79\xc1\xbf\x32\xd0\x39\xa5\x9b\xfa\x4f\xe9\xd2\x03\xbb\xdf\xea\x6d\x3b\x39\x3a\xc1\xf5\x86\x11\xb6\xa7\xef\xbe\x2d\xc9\xc5\x0b\xe2\x3d\xf1\xb1\x77\x77\xcb\xb5\x6c\xdd\xb3\x62\x80\x7b\x95\xc4\xbb\x56\x32\xd7\x0b\x2f\xf6\x5a\xe5\xcf\xdf\x4b\xfe\x67\xcf\x5f\x31\xc0\xd3\xf8\x58\x4f\xe3\x8d\xed\x32\xdf\x1a\xb8\x9a\xf0\x66\x7b\x4a\x30\x9d\xe7\x04\xc2\xc6\xee\xf3\xf8\xd7\x35\x82\xe9\x1d\xc2\xbb\x3a\x23\xf2\x83\xdc\x10\x5a\xf9\x47\xad\x2e\xe1\xd6\xf6\xbe\x0e\xea\x8f\xf4\xa0\x56\x81\x3a\xfd\xda\x94\xec\xf6\x52\x41\xb9\x6b\xb8\xd3\x3e\xd9\x18\x48\xf7\x53\x2e\xe9\x82\x1b\xcc\xbf\xb3\x1e\xd8\x75\xab\x83\xf5\x1c\x1b\x48\xbf\xab\x4b\x9e\x9c\x3f\x34\x7f\x99\x78\x45\xbc\xe6\xdd\x01\x4d\xf1\xed\x20\x5c\x09\x7c\xef\x7f\xcf\x9c\xe5\x5b\x3d\x0f\x74\xaa\x17\xe6\x78\x5e\xcb\x4f\x9e\x7c\x85\x27\xf7\xf4\x3c\xc4\x96\xf6\x94\x60\xba\x98\x41\xda\xbc\x6f\xbf\x6c\x30\x0f\x6a\x7b\xb3\x73\xba\xb8\xa5\xdd\xe7\x65\x1f\x79\xf2\xfa\x80\x5f\x1c\xac\xe7\x3c\x2f\x4c\xeb\x12\x6e\x0d\xe0\x6e\xed\xac\x33\x6a\x08\xd6\x53\xdd\x8e\xd8\x41\xc3\x60\xb8\xb5\x4b\xb8\xb3\x3e\x59\xdd\xde\x03\xc1\x94\x9d\xf5\x46\xb0\x07\x82\x6d\x47\x0f\x74\x6d\x75\xa0\x4e\xe8\x30\x29\x90\x7f\x53\x7b\xe8\x23\x7a\xe1\x1f\x99\xb3\x2f\x8a\x8f\x3a\xcc\xd9\xc7\xc9\x68\x19\x3e\x2a\xf7\x7d\x4f\x6d\x52\xc0\x3e\xe9\xd5\x56\xe2\xf7\x6d\x1e\x4a\xfa\x78\xdf\xa4\x74\xbf\x48\xa9\x2b\xa9\x4a\x0f\xa5\xaf\x7e\x8f\x77\x2f\xcc\xfd\xb2\x95\xfb\x5d\xab\xe7\xf4\x17\xf5\x97\xf5\x37\xf4\xb7\xdd\xaf\x3c\x49\x34\x4e\x86\x90\x3d\xc8\xde\x6e\xc9\x6e\xf0\xa8\xf8\xdc\x0b\x3f\xfd\x0f\xd4\xbc\xed\x3f\x5c\xf3\xe7\xff\xb1\x9a\xbf\xf8\x8f\xd5\xfc\xd5\x7f\xac\xe6\xaf\xff\x8d\x9a\xdd\x99\x38\x7c\x27\x33\xd1\xaf\xf7\x8f\xd7\xe8\x6b\xda\x5a\xa3\xeb\x53\xa9\x9e\x15\xed\x5b\xd0\xdb\x3a\x8c\xdf\xee\xe6\x7f\x13\xa3\xf2\xc7\xea\xdf\xfd\xfc\x7e\xfd\x5f\xee\x76\xfe\x17\xff\x60\xfe\x67\x31\xf6\xbb\x9b\xff\x53\x8c\xe8\xee\xe6\xff\xfc\x0f\xe6\x7f\xf6\x0f\xe6\x7f\xf1\x0f\xe6\x7f\xf3\x0f\xe6\x7f\xeb\x0f\xe6\xdf\x16\xc8\x3f\x5c\xae\xac\x4c\x9e\x19\x83\x50\xa2\x77\xa0\xc6\xb7\x49\xeb\x13\x12\x54\xc9\xda\xcd\xdc\xdf\x23\xf7\xff\x12\xdb\x42\xda\x60\xe7\x78\x16\xd7\x39\x9e\x65\xe5\x86\xe7\x79\xe1\xd6\x40\xfa\xb1\xed\x29\xa2\xa8\x73\x4a\xd7\xb0\x43\x9d\xbb\xcc\xc9\x5f\x09\x84\x01\x44\x31\x23\x90\xd2\xd8\x25\x0c\xa4\x77\xc0\xda\x19\x4a\x20\x54\xae\x6f\xaf\x3f\x28\xfb\xf5\x04\x43\x94\xea\xda\x27\x77\xb5\xa7\x20\xe7\x5d\xbb\xd1\x0f\x3b\x69\x7b\x30\x4f\x50\x93\x6e\xea\x09\xa2\xdf\xd5\xa9\x87\xff\x88\x6d\xe1\x5f\xc9\x6a\xb3\x2d\xfc\x27\x79\x10\xfa\x73\x76\xcb\xff\xec\x39\x0b\xfb\x2a\x78\x75\x7f\x54\xc0\xee\x0a\xa6\x77\x49\x09\xde\x5d\xc2\xdd\xa2\x4d\x3b\x29\xbb\x93\x52\xbf\x13\xee\xb2\x9e\x6e\xf2\x6c\xda\x89\x3e\xbb\x51\x5b\xd0\x8a\xde\x69\xce\x5d\xa6\xef\xb4\x37\xfe\x68\xdb\x77\xdd\x7b\xc1\xbb\x5a\x63\xda\xc2\xdd\x9f\xb3\xff\xce\xd5\xb7\xfe\x12\xc1\x45\x77\xef\xde\x35\x11\xf7\xb9\x5b\x42\x8e\x90\x9b\x6b\xa1\xbb\xf7\x19\x4f\x97\xdb\x39\x72\xbb\x48\x6e\xae\x35\xef\xde\x15\xbc\x49\x6e\x77\xc8\xed\x3e\xb9\x6d\x96\xdb\x13\x72\x73\xef\xda\xbd\x24\xb7\xd7\xe5\xf6\x8e\xdc\x5c\x6f\xe8\x33\xb9\x7d\x23\xb7\x1f\x65\x4b\xc6\xbb\x1c\xb3\x5b\x61\xbf\xdd\xce\xf9\x07\x43\x79\x4e\xba\xe1\x2f\xed\x21\xce\xe3\xbb\xfe\x67\x9f\xc7\xad\xcf\xfc\x78\x9e\x78\x79\x20\x1c\xd5\x7e\x1d\x01\x57\x55\x46\x75\x4e\x47\xa9\x51\x81\xeb\x0e\x5d\xf2\x74\xf3\x9c\xc8\xa8\xdf\x0f\xfd\xeb\x6f\xbb\x95\x73\x5b\xf7\xf9\x83\xfa\x04\x8f\x42\xfe\xaa\x8b\xbc\xad\xfb\xb0\x6b\x9f\xf8\xd7\x80\x82\x6d\xf1\x53\x82\xa5\x3a\xf4\xc6\xc6\x3f\xd8\x8a\x40\x5f\xd1\xd3\xdb\xd3\xfd\x30\x78\x35\x27\x80\xb8\xfb\xe7\xf1\xae\xef\x89\xb8\x57\x17\xdd\x67\x2f\xa6\x90\x3f\xfa\x84\x11\xe5\xdb\x3d\xcd\x1a\xbb\x0f\x45\x66\x20\xe5\x19\x2f\xe5\x88\x40\x8a\x7f\x6d\xe9\xbc\x80\xfc\x8a\xf7\x34\xd1\xff\x0e\x2e\xfc\xa3\xcf\x9a\xec\xfe\x53\x38\xdb\x76\x23\xcf\xe9\xed\x32\x79\xea\x3f\xa5\xc9\x6e\x69\x7b\x7c\x7b\xf8\xdf\x89\xfb\x5f\xd4\xea\xff\x2b\xb8\x90\x37\xba\xdc\xc3\xdd\xf3\xb3\x5d\xee\x1a\xba\x47\xef\xfa\x9d\x3c\x7f\x34\x24\x3b\xc7\x75\x7f\xbd\x41\xa7\x90\xf6\xab\x6a\x9e\x4f\xf8\xdb\x47\xad\xff\x2d\x8d\xdd\xf8\x88\x6e\x1e\xf7\x3f\xcd\xf3\xeb\x9e\xda\x51\x04\x3f\x8f\x10\xff\xf7\x33\x93\x64\x7f\x06\x7f\x3f\xe3\xda\x9f\x6c\xe6\xfe\xe5\x39\x24\x73\xde\xdc\x52\x19\xe2\x17\x34\xac\xed\xd7\x34\xfe\x6f\x70\x78\x65\x65\xbd\xd4\xaa\xaa\x2e\x56\x43\x06\xd5\xc5\x2b\xeb\xa4\x47\xe9\x8e\x3e\xc3\xaf\x87\x5a\x7f\xa1\xa3\x48\xe4\x6c\xe9\x65\xee\x41\xc6\x20\x6d\x34\x7e\x33\x33\x09\xf1\x2c\xf7\x69\x75\x39\x7b\x32\xfd\x7d\x36\x5d\xd6\x91\x49\x94\xd0\x22\xf2\x25\x99\x1e\x5a\x12\x5a\x2c\x53\x15\xfe\x3e\xff\x90\x7f\xc4\xbf\xe6\xdf\xc9\xbd\x9e\x7e\x5f\x10\xe1\xfe\x6a\x48\x49\xf5\x5a\x24\x75\xa4\x17\xc9\xf9\x51\x44\x4a\xe5\x2a\xb7\x90\x2c\x97\x2b\x6c\x52\xce\x8d\x13\xe5\x8a\x77\xa5\x9c\x03\x9b\xc9\x9b\xe4\x23\xf7\xa7\x38\x34\x5b\xae\x6b\xa3\xa9\x21\xd7\x34\x87\xce\xa1\xee\x2f\x5c\x44\x68\xbe\xec\xd3\x6d\x9e\xb4\xa0\x4d\x5a\xd8\x26\xcd\x93\xd2\xf7\x1e\xde\x93\x6d\xd2\x53\x6d\xd2\xd3\x6d\xd2\x33\x9e\x24\xcf\x00\x92\xa6\xbf\x2d\xe5\x6f\xf4\xbf\xb5\x1d\xdb\xd2\x26\x3d\x1b\xc8\xf5\x9c\x2b\xeb\xb7\xcb\xf0\x73\xef\x17\x58\x19\x24\x5b\x9e\x1d\x4c\x7c\x1a\x9a\x29\xc3\xaf\xf5\xe7\xdb\x4a\xbd\xe0\x49\x6e\x9e\x4c\xd2\x27\xb4\x3f\xe1\xe2\x7b\xf1\x4d\x68\x86\x87\xf2\x62\x5b\xae\x97\xda\xa4\x97\xdb\xa4\x57\xda\xa4\xbf\xb7\x49\xaf\xb6\x49\xaf\xb5\x49\xaf\xb7\x49\x6f\x78\x92\x26\x91\xfa\x91\x1c\x39\x5e\x79\xa4\x80\x4c\xd0\x1f\x95\x98\x3f\x4b\x6d\x1f\xf5\xb0\x7f\xd6\x1f\x91\xf1\x4f\x72\xff\x11\x6f\xff\x27\xfd\x4d\xaf\x2d\x0f\xcb\xf0\x67\x7d\xb3\x0c\x7f\xf2\xea\x7a\x0b\xad\xd5\xe4\x79\x2d\xcf\x30\xb9\x36\x28\x84\x2b\x9a\x1c\xb5\x14\x25\x5d\x49\x27\x3d\x94\x1e\x4a\x26\xc9\x54\x7a\x2a\xbd\x48\x4f\xa5\xb7\xd2\xdf\x7b\x72\x89\x78\xb3\xdb\xbd\x22\xe7\xcf\x1a\x77\x66\x28\xb2\x2c\x51\x52\x94\x5e\x8a\xfb\xc4\x10\xf7\xd6\x86\x1f\x77\xfa\x8c\xc4\x74\x39\xf3\x32\x65\x0d\x63\xa4\xee\x53\xd0\xdb\x8f\x7b\x7d\xfa\x98\x0c\xbf\xf2\x74\xfb\x87\xeb\x43\x7a\xd2\x3b\x6d\xd2\xbb\x6d\xd2\x9d\xc8\x17\xc0\xfd\xff\x02\x00\x00\xff\xff\x7c\x22\x13\xc6\x28\x32\x04\x00") + +func liberationmonoItalicTtfBytes() ([]byte, error) { + return bindataRead( + _liberationmonoItalicTtf, + "LiberationMono-Italic.ttf", + ) +} + +func liberationmonoItalicTtf() (*asset, error) { + bytes, err := liberationmonoItalicTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationMono-Italic.ttf", size: 274984, mode: os.FileMode(420), modTime: time.Unix(1459927769, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationmonoRegularTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xbd\x77\x60\x54\xd5\xf6\xc7\xbb\xf7\x39\x67\x4a\x7a\x2f\x10\x60\x26\x84\x84\x12\x20\x90\x50\x04\x81\x0c\x25\x21\x34\xe9\x9a\x80\x90\xd0\x11\x95\x16\x10\x45\xa5\x89\x8a\xf4\x26\xa8\x20\xa0\xa2\x02\x82\x0c\x45\x08\x88\x80\x80\x05\x05\xc5\x6b\x57\x54\x04\x25\x16\x04\x14\x3b\x64\xe6\x7d\xf6\x99\x33\x24\x72\xf5\xde\xfb\x7b\xef\xcf\xc7\x75\x65\x9f\xb3\xcb\x5a\xdf\xf5\x5d\x6b\xb7\x13\xf4\x0a\x29\x84\x88\xe5\x87\x21\xdc\xf9\xf9\xfd\x7a\x0c\x89\xab\x19\x26\x8c\x25\xd7\x51\x5b\xa3\x73\xa7\xbc\xfc\xbb\x3e\x1d\xff\x0e\xef\xfd\x78\x9f\xd3\xb9\x57\xcf\xbe\x6f\xdf\xf0\x76\x6f\xde\x4f\x0a\x91\xd3\xae\x73\xdf\xfe\x1d\xea\xed\xb8\xb5\x58\x18\xaf\xd4\x10\x42\xaf\xdd\xb3\x6f\x56\xb6\x18\xbb\xf7\x01\x21\xe4\x06\xfa\x97\x0c\xbb\x7d\xc8\xf8\x8e\x35\x6a\xbc\x2f\x44\xdd\xd1\x42\xd8\x1b\x0f\xbb\x63\x92\x7b\x94\xfd\xf6\x9b\x84\x68\xfd\xba\x10\xda\xf3\x23\xc7\x8f\xba\x7d\xda\x90\x5d\x31\x42\x34\x7a\x44\x08\xc7\xce\x51\x43\x4a\xc7\x8b\x64\x11\x82\xfe\x7a\x8c\x8f\x1e\x75\xdb\x5d\x23\xeb\xf7\x9a\xfc\x8b\x10\x43\x4f\x0a\xfd\xd5\xdf\x47\x8f\x18\x32\xfc\xca\xd8\xd9\x3e\xf4\x37\xa4\xbd\xc5\x68\x2a\x9c\x87\xec\xad\x78\x1f\xce\x7b\x9d\xd1\xb7\x4f\xba\xf3\x53\xe7\xfc\xb7\xd0\xed\x14\x22\xbd\xe4\xb6\x71\xc3\x86\xc4\xf6\x1e\xbc\x58\x88\xb6\x77\xf2\x3e\xfc\xf6\x21\x77\x8e\x8f\x78\xdb\x38\x48\xff\x39\xf4\x77\x8f\x1d\x72\xfb\x88\x71\x73\x5b\x4e\x11\x46\xfd\xf7\x84\x08\x7b\x66\xfc\xb8\xd2\x49\x6d\x5e\x5f\xbe\x4d\x18\xcd\xef\x11\x62\xe0\x73\xe3\x27\x8e\x18\xff\xfa\xa5\xf9\x8b\x84\x68\xde\x5d\x08\xdb\x54\x93\x2b\x4d\x88\x6d\x1b\x65\x4e\x71\x54\x9b\x5f\x34\x17\x66\xf8\x73\x6c\x59\xcd\xce\xc1\xf2\x4a\x7a\xc5\xa3\xb6\x1f\x1d\x1f\xf3\xaa\x1a\xa5\xd9\x81\x9f\xf6\x8d\x15\x8f\x42\xf2\xf1\x2b\xe9\x7f\x4e\xb5\xfd\x68\xd5\x5f\xfd\x13\x52\xa8\x6a\x42\x0a\x65\x6d\x51\x20\x06\x0a\x3b\x56\xa2\x45\x96\xb8\x19\x56\xf7\xe8\x31\x42\xa7\x55\x37\x8e\xcb\xc5\xc2\x06\x8e\xc7\x6c\x39\xa8\xac\x19\x28\xf5\x21\x62\xa4\x16\xeb\xb4\x69\x0e\x23\x44\xd3\x6c\x9a\x61\x9c\x12\xa1\x7e\x8f\xb8\xd3\x1f\xb4\xde\xb4\x7d\xdf\x8e\xc2\x23\xdc\xbe\x34\xa3\xdc\x37\x4d\x21\xd1\x46\x95\x08\x79\xe0\x8b\xdf\xc0\xd3\xda\x96\xa7\x98\x10\x91\xc6\x71\x31\x5d\xf5\xa6\xb4\x44\x53\x16\x13\x78\x6e\x81\x74\xb0\xea\x33\xa9\xfb\x15\xb9\x11\xe9\xc5\xfb\xef\xc8\x24\x9e\x55\xdf\x1b\x90\x8b\xbc\x4f\x44\xee\x41\x96\x23\x8b\x91\x19\xc8\x28\xab\x5c\x89\xac\x41\xee\x47\x16\x04\xfa\xcb\x92\x80\x8e\xab\x32\x18\x69\x68\xd9\x7b\x12\x99\x60\x95\x4a\x0e\x55\x79\x7f\x03\xf1\x5a\xcf\x3f\x20\x33\xad\xe7\x91\xd7\x94\x3d\x91\xee\xc8\x42\x24\xd4\xd2\x5b\xc7\x92\x2e\xd8\x7f\x8c\xb2\x94\x32\x32\x80\xcb\x7f\x99\xe7\xa5\x16\xde\x1d\xc8\x2c\x64\xae\x85\x59\x95\x8b\x90\x3d\x56\x39\x19\x39\x87\x3c\x80\x0c\xab\xd2\x7f\x87\xd5\xf7\x27\xe4\x59\x64\xbf\x35\x26\x0f\x49\xb0\x7c\x54\x9c\x2e\x43\xce\xc0\x75\x9c\xd5\xef\xb6\x4a\xee\x4d\x7b\xd7\x59\x7c\x35\xb3\xfa\xac\x05\x9b\xf2\xc7\x85\xbc\xa5\x62\x66\xf1\x7f\x43\xa0\xce\xc4\xde\xd9\xaa\x63\xac\xcc\xb6\x7c\x59\x1c\xe8\x6b\xc6\x67\x0a\x65\x4d\xca\xd3\xc8\xad\x48\x0a\x12\x83\x84\x21\x8f\x56\xc6\xff\xdf\x44\x5e\x13\x8b\x27\xab\xc4\xa1\xaa\xa4\x54\xe1\xff\x5a\x79\xdc\xf2\x69\xe1\x35\x52\xc7\x1a\xb3\xd0\xe2\xfd\xef\x24\xde\xe2\xf6\xfe\x6b\x64\xd1\x35\x72\x6f\x95\x38\x5c\x2b\x2a\xbf\xc6\x5a\xb1\xa8\x2a\x1d\xaa\x94\xc2\xb2\x77\x6d\x39\xc1\xd2\xf1\x4f\xe5\x93\x56\x5c\x52\xac\xd8\x3f\x69\xe1\xfb\x6f\xe5\x04\x0b\xf7\x3f\x95\x4f\x5a\xd8\x34\xa4\xb9\xc5\xf1\xa2\xff\xa1\x1c\x8a\x7c\x64\x04\xe6\xc8\x64\x4b\xcf\x39\x4b\xd4\x7c\x79\xe0\x9a\xb2\x7f\x95\xf7\x16\x56\xf9\xa4\xc5\xe5\xb5\xa5\xcd\x2a\x77\x58\x71\x9d\xf5\x37\xa5\x8a\x57\x0d\x6b\xcc\x4f\x56\xf9\x66\x95\x77\x95\xc7\xcf\xfe\x87\x52\xcd\xd9\xfd\x56\x39\xc2\x2a\x5f\x37\x02\x39\xb2\xe7\xff\x50\xaa\xf8\xa9\x39\x57\xc7\x8a\xaf\x35\xef\xcd\xb9\x77\x4d\x29\xd5\x3c\x69\xcd\x3c\xfa\xac\x8a\xaf\x06\xd2\x0a\xb9\xa9\x8a\x6f\x29\x56\x9f\x56\x56\xac\x55\x9d\x9a\x4b\x6a\x9d\x1b\x44\xdb\x29\xca\xef\xac\x18\x2a\xae\x6e\xb1\xf8\x7c\xa3\x4a\x1c\xd4\xfb\xc4\x00\xef\xfe\x37\xab\x70\x19\xb4\xc1\xdc\x15\x19\x96\x9d\x3d\xd6\xb8\xe1\xc8\x46\x23\xb0\x4e\x7c\x61\xf1\x13\x5f\x85\x27\xe5\xf3\xce\x80\x0f\xe6\xb3\xb0\xea\x83\x7e\x26\x21\xf9\x46\xe5\x5a\x7c\x37\x72\x27\xb2\xce\x08\xac\x9f\xd8\xd1\xc2\xe1\x61\x62\x00\x83\xb9\x0e\x15\x59\x92\x5d\xe5\x59\x54\x79\xee\x6b\x54\xce\x91\x60\xee\x05\x7d\xf8\x5f\x63\x74\xbf\xf1\xef\xf3\x4d\x5a\xbe\x4d\xb0\xf4\x55\x9d\x0f\xe7\x8c\x7f\xcf\x37\xd6\x48\x31\xcf\x08\xe4\x7a\x55\xcc\xc1\x71\x83\x8c\xca\x35\xeb\xd5\xbf\xb1\xa3\xd6\xa5\xb1\x56\x7d\x71\x95\x76\xd5\xbf\xd4\xa8\x9c\xaf\x13\x2d\xae\xaa\xfa\x5a\x5a\x05\x47\xd5\xfe\x3f\x59\x3e\xde\x5b\xc5\xd7\x6b\xf3\x5b\xf1\xbf\xde\xa8\x9c\xe7\xaa\xac\x63\xe1\x9f\x51\x25\x76\x55\xf1\xdc\xff\x37\xfe\x5f\x5b\x06\xf3\xfd\x03\x64\x8e\x85\x39\x3f\x20\x7e\x3f\x65\x7d\x8b\xab\x61\xd6\xf3\x56\x64\x13\x92\x63\x04\xe6\x59\xaa\x11\xd8\x13\x42\x2d\x9b\x77\x19\x95\x6b\x89\xe2\x74\xb6\x85\x69\x93\xd5\x2f\x1d\x69\x6a\x04\xe6\x43\x70\x6d\x98\x67\x54\xee\x9f\xc1\x3d\x54\x49\x96\x65\x4f\xd5\xa9\x35\xed\x01\x8b\x87\xe0\x1a\x3e\xcb\xd2\xe5\x30\x02\xf9\x1c\x5c\xa7\x55\x1b\xe7\x0f\x71\xdc\x1a\xa3\xe4\x4b\xab\x6d\xb4\x25\xf8\xe3\xf7\x59\xf6\xf7\x58\xba\x54\x6c\x9b\x59\xcf\x65\x55\xe4\xa7\x80\xc8\x1a\xd7\xd4\xab\xf8\xf8\x03\x22\x35\x2b\xe6\xdb\xac\x78\x75\xb1\x38\x78\xca\xa8\xdc\xcf\x3b\x21\xd7\x5b\x71\x52\x32\xb5\x4a\x9c\x82\x32\xd7\x8a\xcd\x1e\xab\x5d\x61\x79\xc1\xd2\x07\x6e\x19\x72\x0d\x47\xd9\x96\xd4\xb2\x78\x86\x33\xff\x39\xeb\x39\xdf\xa8\x9c\x3f\x5b\x8c\xab\x7b\xb4\xec\x88\x78\x10\x62\x22\x8f\x21\x4a\x2f\xb9\x2c\x95\xef\xb7\x53\x46\x58\xe7\x37\x30\x6b\x5a\x15\x61\x9d\x91\xe7\x91\x16\x01\x31\xd7\x32\x95\x6b\x77\x04\x44\xa6\x04\x44\x6b\x4c\xd9\x1b\xd9\x1b\x38\xb7\x99\xef\xfd\x90\xfd\x96\x5c\x0e\xc8\x55\x7d\x3b\xaa\x88\xea\xdb\xc8\x3a\x57\xaa\xf3\xc9\x1e\x8b\x63\xce\x22\xfe\xb3\xbc\x33\x07\xa5\x1b\x51\x7e\xb4\x44\xaa\x5b\x78\x26\xfd\x8d\x94\x5a\xd2\xc0\xd2\x9b\x62\xe5\xf7\x4c\x2b\x77\x95\x2c\x08\x88\xd2\xed\x2f\x47\xbe\xc5\x36\x6b\xb1\x5c\xf5\x57\x31\xf7\x3c\xd6\x6a\xd9\x4d\x88\x8a\x2b\x42\xf8\x1e\x46\x5e\x10\xe2\x4a\x47\xca\x1f\xa8\x7b\x8e\x92\xfb\x8e\xff\x19\xca\x6f\x91\x24\x9e\xb9\x1f\xf9\xa6\x07\xfa\xf9\x8f\x22\x45\xd6\xfb\x49\xab\xef\xaa\x2a\xf2\x33\x32\x10\xe9\x89\xe4\x22\x83\xe9\xf3\x20\x47\xed\x76\x01\x9d\x7e\xee\x16\xfe\x1e\x08\xf6\x7d\x4a\x57\x4c\xe0\x4e\x70\xe5\x97\x80\x3d\x65\xcb\xcf\xdd\xc1\xdf\xd5\xea\xfb\x52\x60\xbc\xef\x71\x64\x4f\x00\x43\xd0\xae\xef\xb1\x2a\x98\x8f\x5a\xef\x4f\xf0\xbe\x85\x12\x9d\xbe\xb3\x8c\x7f\x2a\x30\xde\xdf\x89\xf2\x49\xca\x74\x64\x25\x7d\x36\xf3\xbe\x43\xdd\x06\x29\xd7\x53\xb7\x9a\x12\x3d\xfe\xbd\x96\xbd\x08\x9e\xb9\xe7\xf8\x9b\x5b\x7a\xb9\xb3\xf9\xd6\x22\x17\x02\xbe\x55\x24\x52\x4e\xb2\xf4\x9f\xb4\xf4\x4e\x0a\x88\xef\x1b\x4a\x74\x0a\x7c\xf2\xb7\xe7\xfd\x80\xe5\x57\xdf\x7f\x16\x5f\x19\xb2\x8f\xe7\x23\x01\x5c\xbe\x8f\x10\xb2\xdc\xc7\xdd\xd1\xf7\x25\x92\x6c\x71\xca\x7d\xd2\xb7\x11\xd9\x85\xfe\x3f\x90\xc9\xc8\xc5\x2a\x6b\xcf\xbc\x40\xae\xca\x4f\x03\x79\x65\xce\x13\xda\xfd\x6f\x1b\x57\xcf\xb5\xc1\x67\xbf\x3a\x53\x3f\x6c\x54\xde\x3d\xd4\x3e\x1e\x6e\x3d\x77\x31\x2a\xcf\xb5\xc1\x7d\x3c\xd4\xa8\xbc\x77\x3c\x68\xb5\x3d\x65\xbd\xab\x3d\x5a\xad\xf1\x6a\x1d\x76\x5a\x65\x53\x6b\x9d\x78\xc3\x7a\x57\x63\xb7\x5a\x6b\xd5\xc3\xd6\x58\x55\xb7\xd9\x08\xac\x8b\xe3\xad\xf6\x32\xab\xcf\x4a\xab\xdf\x39\x6b\x4d\x5a\x8d\xdc\x8c\x1c\xb0\x7c\x4d\x34\x02\x67\x6c\xaf\x55\x1f\xd4\xa9\xd6\x11\x75\x26\x28\xb4\xf4\x06\xeb\x67\x59\x65\x73\xeb\xb9\x49\xc0\x77\xdf\xdd\x16\x07\xaa\xae\x9e\x11\x38\x0f\x06\xf7\x95\xe0\x79\xf7\x50\x60\xcd\xf2\xff\x6a\xad\x67\xaa\x9f\xda\x47\xfb\x07\xd6\x33\x73\x2f\x5d\x68\x71\xa1\xd6\xb0\x01\x46\xe0\xfc\xa2\x38\x4b\xa9\xa2\x6f\xac\xc5\x5d\x0b\xa3\xf2\x9c\x3e\xb9\x4a\xfb\x0a\xa3\x72\x6f\x9c\x50\x85\xe7\x6e\x46\xe0\x4c\x36\xc1\x2a\x83\x7b\xbb\xb0\xe2\xa6\xea\x7b\x1a\x95\xf7\x12\xaf\xd5\xd6\xd9\x2a\x37\x58\xfd\xe3\x2d\x1e\x45\x15\x1d\x6a\xbc\xad\x8a\xbe\x8e\x55\xda\x36\x58\xfb\xcb\xb5\xf7\xcd\xe0\x5d\xb5\xbb\xa5\x33\x18\x73\xb5\x8e\xaa\xf3\x84\xda\xcf\x6f\xb4\xf4\xdd\x62\xf5\xbf\xc9\xaa\x6b\x66\xf5\x9b\x1f\xf0\xd3\xdc\x0b\x54\x2c\xd5\x3e\xa0\xce\x27\x73\x8d\xca\x3d\xf0\x13\xc4\x6e\xd9\x7d\xc1\xa8\xdc\x47\xaa\xde\x79\xd4\xbe\xaf\xf6\x88\xc1\x96\xdf\x8f\x59\xfd\x6f\xb6\xf6\xfe\x31\x08\xfb\x83\x79\x4f\x57\xfd\xf2\x8c\xca\x7d\xa7\xb9\x65\x7f\x89\x11\xd8\x07\x83\x7b\xb2\x8a\x49\xb5\x80\x0e\x33\x5f\x3e\x31\x2a\xef\x4c\xca\x7e\x81\xb5\x3f\x25\x58\x92\x6b\x04\xce\x16\xa1\x96\xfe\xe0\xbb\xf2\x2b\xcd\x7a\x6f\x6c\xf1\xb5\xc2\xc2\x95\x60\xe1\x9c\x69\x8d\xeb\x5b\xa5\x74\x59\xa2\xda\xdb\x58\x3c\xd6\xad\x62\x57\x71\xaf\xce\x51\x63\x03\xeb\x9a\xb9\x76\xac\x0d\x48\xc5\xbb\xac\xa7\xac\x47\x57\x6e\x35\x2a\x73\x49\x9d\xeb\x7b\x59\xef\x6a\xbe\xa9\xfb\xf0\xcf\x48\x4b\xcb\xdf\xe7\x2d\x4e\x83\x77\xdf\x8e\x56\x1c\x36\x58\xbe\x07\x4b\xc3\xa8\xfc\xae\xd0\xc6\xd2\xa7\xf8\x50\xe7\x23\x95\xff\xfd\x2c\xe9\x6b\xfc\x75\xfe\x74\x37\x2a\xcf\x69\x79\xd7\x94\x83\x2d\x7d\x2a\x87\x8a\xad\xf8\x05\x4b\x0b\xbf\xda\xcf\xcc\xb5\xcb\x2a\xcd\x1c\x0f\x62\x55\xd8\x5e\xb7\xf2\x54\x9d\xcd\x54\x5e\x1d\xb0\xc6\x1e\xa8\xa2\x6b\xa6\xc5\xe7\x03\xc6\x3f\x9f\xbf\x83\xe7\x98\x51\x56\x39\xda\xa8\x3c\xaf\x57\xe5\xa5\x87\x51\x79\xee\xd9\x53\xa5\xfc\xa7\xf3\xa9\xca\xfd\x7b\x2c\x1b\x1d\xfe\xa6\x0c\x62\x3c\x65\xe5\xa3\x9a\x33\x63\xac\xf8\xdc\x6d\xf1\x74\x6f\x95\x72\xac\x85\x43\xf9\x3b\xc4\x8a\x8b\x1a\x17\x6d\x61\x57\x78\xa3\x2c\x3d\x37\x56\x89\x83\xca\x47\xb5\x1e\xa9\xbc\xde\x5a\x85\xb3\x91\x96\x3e\xf3\xfe\x18\xf8\xa6\x29\xd9\xc3\x24\xb9\xa4\xc5\x53\x6e\x47\x0e\x23\x6f\x23\xd7\x5b\xcf\xaf\x20\x5e\xeb\x59\x89\x8b\xbd\xe8\x66\xca\x09\xc8\xcb\x96\x8e\x60\x3f\xab\x5d\x1e\xb5\x9e\x27\x58\xed\xaf\x54\x19\xaf\xf4\x2e\xc2\x1e\x67\x0e\xa9\xbe\x73\xde\x18\x10\xf3\x7d\xbd\x25\x56\x5f\x55\x67\xd6\x4f\xb1\x9e\x39\x2f\xca\x02\xd5\xc6\xb9\xa7\x5a\xb0\x5d\xed\x7d\x55\x9e\x6f\xa0\x7d\x81\xc5\x91\xfa\x86\x74\xb1\x92\x5f\x8d\x9c\x96\x6a\xbf\xb8\x2f\x10\x6f\xf5\x2e\xd4\xb7\x3a\x35\x57\x96\x58\xf5\x91\x56\x3f\x75\xf6\x57\x6b\x83\x5a\x4b\xd4\xdd\x47\xad\x15\x9c\x37\x45\x57\x23\xf0\x8d\xaa\xc4\x6a\x67\xbe\xca\xb0\x2a\xa2\xe6\xd8\xdb\x81\x3e\xea\xdb\xd5\xd5\xfd\x43\xc5\xe5\x69\x23\xb0\x6f\xa8\xb3\xfe\x0e\x2b\xef\xb6\x1b\x81\xbd\x4f\x9d\xef\xd4\xde\x58\x66\x5c\xdd\xe3\xcd\x35\x49\x89\xc2\xa2\xce\xf3\x1f\x58\x18\x95\xa8\xfb\x75\x2b\x4b\xd4\x7d\x42\xed\x79\x6a\xfd\x49\xb6\xca\xe0\x39\x5e\x9d\xdd\xf7\x21\x3f\x22\xea\x2c\x3a\xd0\x6a\x7b\xc3\xd2\x11\x6a\xe5\x06\xfd\xfc\x7f\xd0\xae\x78\x53\x3e\x9c\x34\x02\x67\xd9\x0f\x8d\xc0\x5e\xc2\x9d\x5d\x63\xad\x92\xb1\x3c\x5f\x08\x9c\xcb\x4d\xce\x3e\xb3\x84\x3d\x4c\xc6\x05\xbe\x9b\x9a\xdf\x68\x3e\x0a\x8c\xf5\x7f\x1f\x38\x07\x2b\x1f\xd5\x59\x59\xed\xc7\xaa\x34\xc5\x65\x49\x1f\x4b\xd4\x59\xba\x41\xe0\x3b\x9f\x98\x46\x89\x1f\x12\xbe\x64\x6b\xab\xac\x65\x8d\xdb\x19\x68\x33\x79\x53\xfd\xa2\x02\x78\x65\xaa\x75\xc6\xae\x15\xc0\x24\x9d\x96\x3e\x75\x6f\xe8\x14\xe8\x27\x6b\x5b\x65\x7c\x65\x1f\x15\x47\xff\x21\x6b\x0e\x31\x3f\xfc\xdc\xa5\xfd\xdc\xc1\xfc\x47\x8c\xc0\x1e\xfe\xa3\x15\x2b\x35\xb7\xd7\x07\xc4\xf4\x5f\xe5\x84\xd2\xff\x78\x40\x44\x7b\x23\xb0\x2e\x36\x08\xcc\x3b\xb5\x5e\x4a\xb5\x26\xa8\x3d\x41\xf1\xa0\x62\xa4\xf6\x0b\x6f\x80\x63\x85\xc5\x5c\xd7\x66\x5a\xb9\x35\xd9\xd2\x1f\xdc\x43\x6f\xb4\x72\xed\x84\x25\xe4\xae\xac\x30\xcc\xfb\x91\xca\x35\x73\xcd\xba\xcf\xe2\xa4\xb5\xf5\x7d\xb4\xba\x75\x9f\x79\xde\x92\x46\xd6\xfd\xe9\xa3\x00\x17\x26\x1f\x3c\x4b\xd6\x6e\xa9\xd6\x21\xfc\x94\xd6\xb7\x54\x13\x87\x9a\x2f\x97\xa8\x6b\x5f\x85\x73\x75\x77\x01\x9b\x54\x7b\xc0\xef\xd6\xbd\xc6\x63\x89\xe2\x52\xed\xf5\xec\x33\xe6\x5d\x4c\xf5\xcf\x64\xaf\x62\xcd\xf0\xcd\x66\xaf\xba\xdf\x3a\xcb\xbe\x8a\xbc\x57\xa5\x1c\x1a\x10\xff\xb8\xe0\x79\xda\xf8\xeb\xf7\x80\xbf\xfb\x46\x57\xf5\xbb\xe4\xdc\xff\xb1\xfc\x5f\xbe\x57\x1e\xb2\xfa\x5f\xfb\x7d\xf2\xda\xf2\x21\x23\x70\xce\x0c\xbe\x5f\xfb\x7d\x32\xf8\x1d\xe7\xda\xf2\xef\xbe\x4d\x56\x2d\x67\x5a\x79\x71\x6d\x19\xfc\xae\xf3\x4f\xe5\x7f\xfb\x5e\xf2\x77\x3c\xfe\xf4\x0f\xa5\xfa\x8e\xfc\xdf\xbe\x5f\xfe\xdd\x77\xcc\xbf\x2b\xff\xd7\x6f\x64\xc1\x73\x54\xb0\x0c\x7e\xd7\xfc\x6f\x65\xf0\x3c\x51\xb5\x54\xfb\xeb\x3f\x7c\x03\x35\x6d\xed\xb7\xc6\xaa\x7e\x33\xac\x9c\x5f\x61\xfc\xf3\xb7\x71\x55\x7a\xfe\x4b\xfb\xff\x52\xfe\xb7\xdc\x53\xfb\x7f\xff\xff\xd0\x7e\x6d\x8e\xfd\x53\xac\x95\xaf\x85\xff\xa1\xfd\x7f\x2d\xff\xaf\xdf\xa2\x83\x65\xd5\x6f\xd1\x7f\x57\xce\xfc\x2f\x62\x7d\xef\xf1\xf9\xff\x2a\xfe\xf8\x80\x98\xeb\xe9\xdf\x88\x5f\xdd\x7d\x58\xc3\x2b\x0e\xfe\x55\xae\x7e\xaf\xfb\x07\x51\xe3\xfc\x1e\xab\xff\xbb\x55\xc6\x3e\x15\x10\x73\x9e\xff\x07\xf9\xcb\xf8\x83\x7f\x33\x7e\xd6\xdf\x8b\xff\x39\x84\x35\xde\x57\xc7\x92\x39\x01\x31\xf7\xef\xff\x20\xbe\x93\x96\x7e\xce\x74\x15\x8f\x18\x95\x67\x83\x7f\x90\xbf\xd8\xa9\x5d\x69\xc7\x57\x14\x90\xab\xbc\x07\xb9\x0c\x72\x13\xf4\x31\x88\x39\x88\x21\xa8\xfb\xff\x6b\x1c\xff\x2f\x71\xa9\x2a\xf7\x07\xe4\xff\xe4\x77\x9d\xff\xe0\xf7\x7f\xc0\xfe\x17\xb9\x64\x9d\x15\x2e\x59\xf7\x92\x98\xbf\xc7\xed\xfb\x95\xf6\xec\xca\xd2\x9c\xbf\x0d\x02\xe2\xbf\xf0\x1f\x72\xc9\xba\xcb\xfb\xd8\x3f\xfd\x53\xae\x19\x73\x6d\x1e\x3c\x6e\x49\xf0\xdd\xfa\x9d\xaf\xef\x45\xe4\x7c\x80\x37\xff\x77\x01\x31\xcf\x76\x7f\xc7\x4f\x93\x80\x9d\x60\x69\x7e\xbb\xc1\x37\x71\x8e\x7d\xf8\x03\xc4\x8d\x7c\xc8\x7e\xac\xd6\xf2\x4d\x01\x51\xdf\x43\x4c\x51\xdf\x42\xd5\xef\xb8\x59\x87\xe4\x20\x44\xcd\x7d\xf5\x0d\x79\xbb\x25\xea\xdc\xb8\x2b\x20\xe6\xef\xd2\x27\x5b\xba\xd4\xb7\xc0\xd8\xa0\x04\x78\x0d\x7e\xb3\x15\xcf\x50\x0e\x40\xd4\x5d\xe7\x07\xeb\xcc\x7c\x4c\x7d\xd7\xac\x32\x26\xda\x92\x98\xc0\x78\x39\x02\x91\xd6\xd9\xb1\x96\x75\xe6\x51\xf7\x68\x75\x56\x9b\x60\x89\x3a\x5b\x29\x0c\x6a\x1f\x55\xe7\x74\x75\xf6\x4c\xb6\x62\x1a\xfc\xa6\xaf\xce\xc2\xea\xbe\xd7\xdd\xa8\xbc\xeb\x56\xb3\xc6\x07\xef\x56\xdc\x61\x7c\xd6\xef\x2a\xcc\x73\xa5\xba\x5b\x29\x5b\x86\xc5\x9d\xba\xd3\xa9\x6f\x17\x47\x03\xb9\xa1\xbe\xcd\x9a\x3a\xd5\x3d\x4d\x9d\xdb\xd5\xf9\x5c\x7d\xcf\x66\x8d\x92\x77\xfc\x7b\x69\x3e\xab\xfb\x5b\xb8\x55\xaa\x7b\xdb\xe4\x00\x07\xe6\xef\xb6\xd5\x1d\x46\xfd\x6e\x5b\x9d\xb1\xd4\x39\x9c\x73\xa4\xf9\x1d\x2e\xf8\x77\x0b\x4a\xad\x72\x6e\xe0\x59\xab\x15\x88\xbd\x8a\x97\x7a\x56\x12\x7c\xae\x5a\x5e\x2b\x72\x4c\xa0\x4d\x95\x4a\xaa\xb6\xfd\x5f\xeb\xff\x17\xb9\x76\x9e\x69\x23\xaf\xa9\x53\xb9\xa9\x19\x81\xef\xfd\xa3\x03\x7c\x99\xf1\x68\x66\x95\x9a\xe5\xbb\x9a\x07\xa3\xad\xdc\x4b\x0f\x88\x99\x4b\x29\x96\xa8\xdc\x50\x71\x55\xe7\x6a\x65\x63\x88\x55\xce\x0e\xe4\x8d\x79\xe7\x7a\x24\x10\x47\xb9\xc6\x8a\xa5\xca\x4b\x35\x7f\x95\x9e\x05\x46\xe5\x79\x4f\xe5\xbb\x3a\xcf\x75\xb1\xf4\xa9\x3c\x29\x31\x2a\xcf\x25\xd6\xef\xd0\xa4\xca\xa1\x3a\xea\x4e\x63\x7d\xe3\x56\xdf\x7a\xcf\x2b\x31\x2a\x7f\x07\xf3\x7b\x50\xa8\x5f\xa7\xc4\x30\xef\x78\xe6\xf7\xfc\xd0\xc0\x1d\xd4\xbc\x9f\x5a\xdf\x5a\xb4\x50\xf5\x37\x64\xac\x73\xbf\xfa\xee\xa8\xee\x69\xc1\xef\x06\x55\xef\xaf\x0a\x8f\xfa\x86\x34\xdd\xca\x65\x67\x95\x32\xba\x8a\x5c\x73\x37\x96\xd3\xac\xbb\x1f\x6b\xac\x5c\x62\xfc\xf5\x5e\x1c\x59\xe5\x3e\x1c\xbc\x0b\xff\xcd\x3d\xd8\xc4\x7b\x83\x35\xce\xfc\xb6\x26\xc4\x15\xf5\xbd\xbf\x82\xf2\x4a\xe0\xef\xe2\x98\xdf\xac\x6d\x56\xf9\x69\xa0\x9f\xa9\xfb\x4f\x23\xf0\xfb\xe5\x57\x78\x57\x73\xeb\x0a\xa5\x9a\xef\xac\x03\x3e\x75\xd7\x5b\x44\xf9\x81\x25\x6f\x5b\xa5\xe2\xf4\x10\x82\x0f\xfe\xaf\x83\x1c\x5b\x75\x87\xac\xdf\x61\xa8\xdf\x25\xa8\x7b\xf3\x22\xe3\xbf\xef\x5d\xff\x65\xcf\xff\xcf\x7b\xb4\xf8\x2f\x7f\x2c\x0c\x6b\xac\x7c\x5a\x03\xae\x63\x60\x2c\xa4\xfc\x0c\x39\x61\xe1\x56\xbe\x7d\x68\xd5\x7d\x68\xfd\x8e\x40\xfd\xee\xa0\x3f\x72\x8f\xd5\xe7\xb5\x2a\x72\xc8\x6a\x57\x72\x9b\xf5\x3b\x86\x1d\x55\xc5\x08\x9c\x31\x0b\xaa\xcc\x2d\xd6\x42\xbf\xba\x6f\xb9\x03\xb9\xaa\x7e\xdf\x65\xfe\xfe\x32\xcb\x8a\x67\x30\xa6\x41\x51\x39\xc0\xfa\x2b\x8e\x20\x67\x94\xf0\xce\x9d\x4d\xe8\x96\xd4\x08\xfc\xbd\x2c\xa3\x8e\xf9\xf7\xba\xd4\xbb\x61\xa8\xbf\x2b\xe6\x13\x33\x84\x5d\x4c\x13\xd3\xb4\x16\xfa\x38\x7d\xb2\x3e\x4d\x9f\xab\xcf\xd7\x9f\xd0\xdf\xb2\xc5\xd9\x6a\xda\x5e\xb3\x7d\x67\xfb\xb9\xe6\x1b\xb5\x56\xd5\x5a\x53\xeb\x0f\x57\x82\xab\xa6\x2b\xcf\xd5\xc3\x75\x93\xab\xc8\x35\xd0\x35\xc8\x75\xaf\x6b\xa7\xeb\x88\xeb\x5d\xd7\xa7\xae\x0b\xae\x9f\x5d\x3e\x77\x94\x3b\xc1\x5d\xdb\x9d\xe1\x6e\xec\x6e\xe2\x6e\xe6\x6e\xed\x6e\xe3\x6e\xe7\xee\xe4\x1e\xec\x1e\xe7\x9e\xee\x5e\xee\x7e\xc1\x7d\x31\xd5\x96\x1a\x97\x9a\x94\x5a\x3b\x35\x23\xb5\x71\xea\x0d\xa9\xfd\x52\x07\xa7\xce\x4e\x7d\x38\x75\x43\x6d\xad\xb6\xbd\x76\x54\xed\xd8\xda\x09\xb5\xab\xd7\x76\xd5\xae\x5f\x3b\xb3\x76\x41\xed\x21\xb5\x47\xa4\x69\x69\xd1\x69\xa9\xe9\x22\x5d\x4b\x0f\x4f\x8f\x4e\x8f\x4f\x4f\x4e\xaf\x91\x5e\x27\xbd\x61\x7a\xb3\xf4\x36\xe9\xb7\xa5\xcf\x48\x9f\x9d\x3e\x27\x7d\x7e\xfa\xb2\xf4\x27\xd2\x37\xa7\x6f\x4f\xdf\x9b\xbe\x2f\xfd\x48\xfa\xb1\xf4\xb7\xd3\x3f\x4e\x3f\x9b\xd1\x26\xc3\x93\xd1\x21\xa3\x24\x63\x58\xc6\xc8\x8c\x5b\x33\xc6\x35\xbc\xbd\xe1\x94\xc6\x49\xcf\xa6\x3e\x3b\xff\xb2\x76\xb9\xc5\xe5\x36\x97\xdb\x5d\x6e\x7f\xb9\xd3\xe5\x9e\xbe\x34\xbf\xdf\xfc\xdb\x68\xeb\xb4\xeb\xf4\x49\xfa\x54\x7d\x36\xfe\x2f\xd4\x9f\xd2\x4f\xd8\xaa\xdb\x96\xd8\x4e\xd8\x2e\xd6\x14\x35\x7d\xf8\xbf\xce\x25\x5c\xc9\x2e\xb7\xab\xc0\xd5\xcb\xf2\xbf\xd8\x35\xc3\xb5\xcb\xf5\xaa\xeb\x03\xd7\x67\xae\x9f\x5c\xbf\xba\xc3\xdd\xb1\xee\x24\xfc\x6f\x80\xff\xd9\xee\x56\x57\xfd\x1f\x83\xff\x8b\xdd\xeb\x2c\xff\x13\x2d\xff\x7b\xa4\xf6\x4d\x1d\x88\xff\x8b\xaf\xfa\x1f\x83\xff\xd5\x6a\xd7\xb2\xfc\x2f\xa9\x3d\xdc\xf4\xdf\xfd\x0f\xfe\xf7\xba\xea\xff\xe2\xf4\x75\xe9\x9b\xae\xfa\xff\x06\xfe\x7f\x84\xff\xad\xaf\xfa\x3f\x22\x63\x0c\xfe\x97\x34\x9c\x80\xff\x49\xcf\xce\xb9\x2c\x2f\xd7\xbc\x7c\x1d\xfe\x7b\x2e\x77\xbc\x9c\xef\x73\xfb\xfd\xfe\x33\xfe\x43\xfe\x97\xfd\x2f\xf9\xf7\xf8\x77\xfa\x77\xf8\xb7\xfb\xb7\xf9\xbd\xfe\x4d\xfe\x96\xfe\x2c\x7f\x83\x6f\x5c\xe5\xe7\xca\xbf\x2b\xff\xb6\xfc\x4c\xf9\x97\xe5\x5f\x94\x7f\x56\xfe\x69\xf9\x27\xe5\x1f\x97\x7f\x54\xfe\x61\xf9\xfb\xe5\xef\x95\xbf\x5b\xfe\x4e\xf9\x89\xf2\xb7\xca\x8f\x97\x1f\x2c\xdf\x5f\xfe\x52\xf9\xde\xf2\xdd\xe5\xbb\xca\x5f\x28\xdf\x56\xee\x2d\xdf\x5a\xbe\xa9\x7c\x49\xf9\x03\xe5\x53\xca\x47\x95\xdf\x5c\x5e\xbb\x3c\xb2\x5c\x9e\xf5\x9f\xfd\xe5\xec\x4f\x67\xbf\x3f\x7b\xfc\xec\xd1\xb3\x87\xcf\xae\x39\xbb\xec\xec\xcc\xb3\xf5\xce\xa6\x9f\xad\x79\xb6\xc6\xd9\xea\x67\x93\xce\xc6\x9f\x0d\x3b\x1b\xfa\xf5\xf9\xaf\x3f\xfc\xfa\xfd\xaf\x5b\x7d\xdd\xf0\xeb\x9a\x67\x72\xcf\xb4\x3b\xd3\xfc\x4c\xf6\x99\xac\x33\x0d\xcf\xd4\x3f\x53\xfb\x4c\xca\x99\xf8\x33\x11\xa7\xff\x3c\x5d\x7e\xfa\xab\xd3\x5f\x9e\xfe\xfc\xf4\xa7\xa7\xdf\x3e\xfd\xda\xe9\x43\xa7\x5f\x3c\xbd\xf7\xf4\x8e\xd3\xcf\x9f\xde\x7c\x7a\xfd\xe9\x47\x4e\xe7\x9d\xee\x70\xba\xfd\xe9\x3a\xa7\x6b\x9f\x4e\x3d\x5d\xeb\x74\xca\xc9\xcc\x93\xf5\x3e\x79\x68\xc8\xdc\x21\x75\x22\xbc\x11\x2b\x22\x1e\x8e\x58\x1e\xb1\x2c\x62\x69\xc4\x92\xd0\x97\xaf\xfd\x5b\x91\xff\xbf\xfb\x63\x57\xfb\x96\xf9\xd7\x36\xaf\x65\x42\xaa\xbf\x77\x6a\xfe\xd1\xfe\x8b\x8e\xc0\x48\x5d\x18\xc2\xc6\x6a\xe2\x10\x4e\x11\x22\x42\x45\x98\x08\x17\x11\x22\x52\x44\xb1\x32\xc5\x88\x58\x11\x27\xe2\x45\x82\x48\x14\x49\x22\x99\x7d\xa7\xba\x48\x61\x15\xaa\x29\x6a\x09\x17\xb3\x2f\x55\xd4\x16\x69\xa2\x8e\x48\x17\x19\xa2\xae\xa8\x27\xea\x8b\x06\x22\x53\x34\x14\x8d\x44\x63\x91\x25\x9a\x88\xa6\x22\x5b\xe4\x88\x66\xa2\xb9\x68\x21\x5a\x8a\xeb\x44\x2b\xd1\x5a\x5c\x2f\xda\x88\xb6\xa2\x9d\xc8\x15\x1e\xd1\x5e\x74\x10\x1d\x45\x27\x91\x27\xf2\x45\x67\x51\x20\xba\x88\xae\xa2\x9b\xe8\x2e\x7a\x88\x1b\x44\x4f\xd1\x4b\xf4\x16\x7d\x44\x5f\xd1\x4f\xf4\x17\x37\x8a\x9b\x44\xa1\x28\x12\x03\xc4\x40\x71\xb3\x18\x24\x06\x8b\x62\x51\x22\x86\x80\xff\x01\xf1\xa0\x78\x48\xcc\x13\xcb\xc4\x23\xac\xfd\x4f\x89\x27\xc5\x7a\xf1\x8c\x78\x5a\x3c\x2b\x36\x8a\xe7\xc4\x26\xb1\x59\x6c\x11\x5b\xc5\xf3\xc2\x2b\xb6\x89\x1d\xe2\x05\xb1\x53\xec\x12\x65\x62\xb7\xd8\x27\x5e\x14\x2f\x89\xfd\x8e\xcf\xc4\x44\x31\x5c\x8c\x10\xb7\x38\xbe\x10\x77\x8a\x27\xc4\x78\x71\xab\x33\x49\xdc\x21\xc6\x38\x5b\x8a\x39\xe2\x31\x67\xb6\x28\x75\xb6\x72\xb6\x16\xa3\xc4\x14\x67\x03\x67\x23\x67\x43\x7d\x82\xb3\xb9\xb8\x4d\xdc\xa3\x0f\x10\x1b\xc4\x5e\x31\x53\x0c\x13\x63\x9d\x4d\x65\x3f\x67\x0b\x67\xa6\xb8\x5d\xdc\xeb\x38\x25\x86\x8a\x59\xe2\x7e\xb1\x52\xc6\xcb\x04\xc7\x3b\x8e\x7f\x39\x3e\x76\x7c\xe2\x78\xdf\xf1\x81\xd8\xe3\xbc\x53\xbc\x2c\x5b\x3b\xce\x3b\x9d\x8e\xef\x1c\xdf\x3b\xb7\x39\xb7\x3b\x3e\x17\x77\x39\x3e\x74\x7c\xea\x38\x2b\x66\x8b\xf9\xe2\x3e\xb1\x40\xcc\x65\x4f\x5e\x2c\x96\x88\x85\xe2\x61\xb1\x02\x0f\x97\x8b\xd5\xe2\x71\xb1\x4a\x5c\xd2\x1e\xd4\x1e\x17\x13\xb4\x47\xb5\xc7\xb4\x55\x62\xaa\xb6\x46\x5b\xad\xcd\x11\xc2\xd3\x79\xe0\x80\xa2\xc2\xfe\xfd\xfa\xf6\xe9\xdd\xab\xe7\x0d\x3d\xba\x77\xeb\xda\xa5\xa0\x73\x7e\x5e\xa7\x8e\x1d\xda\x7b\x72\xdb\xb5\x6d\x73\x7d\xeb\x56\xd7\xb5\x6c\xd1\xbc\x69\x93\xac\xc6\x8d\x1a\xd6\xab\x9b\x91\x5e\x27\xad\x76\xaa\x2b\x39\x3e\x26\x3a\x2a\x32\x22\x2c\x34\xc4\xe9\xb0\xdb\x0c\x5d\x93\xa2\xa1\xdb\x2b\x4b\xf2\xbc\x7a\xba\x3b\x26\x7f\x48\x5a\x5e\xda\x90\x82\x46\x0d\xdd\x79\xc9\xa3\x3b\x35\x6a\x98\x97\x96\x5f\xe2\x75\x0f\x71\x7b\x29\x8c\x8c\xb4\x82\x02\xb3\x2a\x6d\x88\xd7\x5d\xe2\xf6\x66\x50\x0c\xa9\x52\x5d\xe2\xf5\xd0\x73\xe4\x35\x3d\x3d\x81\x9e\x9e\xab\x3d\x65\xb4\xbb\x8d\x68\xa3\x4c\xa4\xb9\xbd\xc7\x3b\xa5\xb9\xcb\xe4\x80\xde\x85\x3c\x2f\xe8\x94\x56\xe4\xf6\xfe\x60\x3e\xf7\x30\x9f\x8d\x0c\xf3\x25\x82\x97\xd4\x54\x46\x98\xa8\x14\x5a\x77\x9e\x37\xff\x8e\xd1\x73\xf3\x4a\xc0\x28\xb7\x85\x85\x76\x4c\xeb\x38\x22\xb4\x51\x43\xb1\x2d\x34\x8c\xc7\x30\x9e\xbc\xf5\xd2\xc6\x6f\x93\xf5\xda\x49\xf3\x41\xab\x97\xd7\x7a\x9b\x26\x9c\x11\xca\x2c\x9e\xe6\x0d\x19\xee\xed\xd5\xbb\x30\xaf\x53\x4a\x6a\x6a\x51\xa3\x86\x5d\xbc\x91\x69\x9d\xcc\x26\xd1\xd1\x54\xe9\xb5\x77\xf4\x3a\x4c\x95\xee\x5b\x14\x74\x31\xcf\xbd\xad\xe1\xc1\xb9\xf3\xcb\xa2\xc5\xd0\x92\xcc\xf0\xe1\x69\xc3\x87\xdc\x5c\xe8\xd5\x87\x30\x76\xae\x9e\x37\x77\xee\x83\xde\x98\x4c\x6f\xfd\xb4\x4e\xde\xfa\x53\xbf\x4a\xc6\xf3\x11\xde\x86\x69\x9d\xf2\xbc\x99\x4a\x6b\xb7\x3e\x57\xed\x74\xab\x34\x29\xbd\xb6\x74\xb6\x8b\xb9\xbf\x08\xdc\x49\xfb\xe1\xdc\x5f\x6b\x86\x58\x35\xf6\xf4\xe8\x5f\x84\x7a\xf4\x6a\x1d\xbd\xb2\x4f\x61\xaa\xfa\x93\x92\x0f\xd7\x73\xe7\xe6\xa7\xb9\xf3\xe7\x96\xcc\x1d\x52\xe6\x9f\x31\x34\xcd\x1d\x9d\x36\x77\x5b\x78\xf8\xdc\xf1\x79\xd0\x2d\x7a\x15\xa2\xa2\xcc\xbf\x77\x5e\x8a\x37\x7f\x7e\x91\x37\xba\x64\xb4\x6c\x5d\x64\xb9\x9e\xdf\xa7\x9b\x37\xae\xf7\xc0\x42\xaf\x96\x9e\xef\x1e\x3d\x84\x1a\xfe\xc9\x4d\x4b\xbd\x2e\x25\x35\xe6\x6a\x9f\x5e\xff\xd4\x2c\xa0\x05\x72\x60\x38\x35\x55\xd1\x30\xaf\xcc\x23\x86\xf2\xe2\x9d\xd1\xbb\x30\xf0\xee\x16\x43\x53\xb6\x0b\x4f\x56\x66\x91\x57\x2b\x51\x2d\x07\x83\x2d\x09\xfd\x55\xcb\x8c\x60\xcb\xd5\xe1\x25\x69\xc4\xb6\x5b\xdf\xc2\xb9\x5e\x23\xbd\xcb\xf0\xb4\x3c\x18\x9f\x37\xc4\x3b\x63\x28\xd9\x35\x46\x05\x26\x2d\xda\x1b\xf9\x6b\x4a\x6a\xda\xdc\xd8\x18\x77\xab\xac\x22\xb3\xaf\x1b\x54\x5d\x86\xdf\xe2\xf6\xda\x32\x20\x89\x51\x55\x07\x90\x37\x6a\xc8\xdc\x68\xf3\x25\xf2\xd7\x40\xf1\x43\x0a\x06\x32\x62\x62\xdd\xad\xd2\x50\xa3\xf4\xe4\xa5\xe5\x95\x58\xff\xdc\x31\x3a\x19\x05\x6e\x88\x2e\xc8\x0c\x24\x42\xbf\x42\xaf\xa7\x13\x0f\x9e\x21\x56\xc4\xf2\xb6\x35\xc9\x62\xc4\x90\x12\x02\x76\x4b\x27\x33\x98\xde\xac\xb4\xf1\xde\xf8\xb4\x0e\x57\xa3\xab\x60\xe5\xdd\xd2\xb7\xd0\x1c\x62\x0d\xf3\xc6\x77\xf4\x8a\x92\x61\xd6\x28\x6f\x56\x9e\x39\xaf\xdc\x79\x73\x4b\x3a\x05\x20\x28\x5d\x69\xbd\x0b\xf7\x88\x1c\xff\xa9\x6d\xcd\xdc\x29\x3b\xd4\xd2\x59\xd4\x49\x75\x4e\xec\x48\x96\x65\xe4\xcd\x2d\x1c\x3e\xd2\xeb\x2a\x49\x19\xce\xbc\x1b\xe9\x2e\x4c\x49\xf5\x7a\x8a\x88\x70\x51\x5a\xe1\x88\x22\x95\x76\x30\x54\xff\x54\x8a\x99\x1c\x45\x66\xae\xf4\x2b\xec\xd6\x37\xad\x5b\xef\x01\x85\xd7\x59\x40\x02\x0d\x4a\x9d\x91\x9e\x77\x8d\x9a\xb4\xc2\x94\x80\x1a\x12\xd0\xeb\x4c\x77\xba\x0b\xb5\x14\xbd\x88\x8e\xd1\x54\xb8\xf3\x79\x48\xeb\xd0\x86\x9f\x5e\x47\xba\x13\x89\x86\x70\xb3\x56\x25\x6e\x87\x36\xee\x42\x99\x22\x82\xbd\x81\xe1\xad\xef\xce\x1b\xd1\xc9\xea\xa7\xde\xff\xa2\xd4\xa6\xd2\xa9\x63\x41\x50\x9b\x5d\xbd\xa2\xa7\x63\x41\x4a\x6a\x51\x6a\xe0\x4f\xa3\x86\x1a\xcd\x6e\xcb\x30\x23\x9c\x8a\xd4\x82\x60\x13\xcb\x14\x0d\x4e\xf2\xb3\x63\x81\x59\xa5\xb8\x4c\x56\x49\xef\x2e\x4c\x1b\x91\x56\x94\x36\xda\xed\xf5\xf4\x2a\x54\xbe\x29\x7a\x4c\x96\x2d\x32\x4c\xce\xad\x58\xf5\xfb\xcb\x5b\x15\xb2\xa0\x49\xa4\xd2\x1c\x7c\x51\x64\x7a\xf3\x33\x53\xaa\x92\xeb\xed\x6c\xbe\x5f\x7d\x2d\xb8\xa6\xb9\x4b\xb0\xd9\x3d\xd7\x99\xd6\xad\xef\x5c\xa5\x3c\xcd\x52\x28\x40\xde\xc5\x2b\x54\x0a\x7b\xae\x8b\x49\x31\xd7\x02\x35\xa1\xd3\x58\x7b\xdd\xd1\x4c\x69\x73\x42\xcf\xdd\xe6\xf1\xa8\xc9\x3c\xba\xb5\x52\x92\xd6\x65\xf8\xdc\xb4\xbe\x85\x6d\xcc\xde\xac\x27\xf7\xa6\x4c\x55\xb6\x62\x45\x37\xd9\xad\x5f\x87\x46\x0d\x59\xda\x3a\x6c\x4b\x93\x73\x7a\x6f\xf3\xc8\x39\x7d\x07\x14\xee\xe1\x72\xe1\x9e\xd3\xaf\x70\xbb\x26\xb5\x8e\x25\x1d\x8a\xb6\xd5\xa1\xad\x70\x8f\x9b\x4d\xc3\xac\xd5\x54\xad\xaa\x54\x2f\x6e\xf5\xa2\x34\xf5\xe1\xc5\x69\xf6\x4f\xd9\xe3\x11\x62\x86\xd9\x6a\x98\x15\xe6\xfb\xb0\x32\x29\xcc\x3a\x67\xb0\x4e\x8a\x61\x65\x5a\xa0\x2e\x3a\x60\x28\xc3\x34\xe4\xe1\x0c\x32\xac\xcc\x08\xb4\x78\x82\xbd\x0d\xea\x9c\x81\xba\x19\x66\x9d\xf9\x67\x9b\x50\x94\x79\x42\x6d\x1e\xa7\x27\xc4\x13\xae\x45\x68\x29\xdb\xa4\xaa\xda\x4e\xcd\x5e\xf5\xef\xbc\x48\xb1\x23\x5c\x46\xc8\x94\x6d\x8c\xea\x63\x56\x97\xc9\x19\xdb\x42\x3c\x29\x81\x1e\x33\xe8\xe1\x09\x20\x9c\xd3\xbf\xd2\x74\xff\x01\x85\x3b\x38\xd1\xc8\x14\xf3\x27\x86\x3a\xa8\x3f\xa4\x4b\xf2\x68\x82\xcd\xb6\x92\xe7\x1e\xae\x12\xe5\x9e\xa2\xd1\x73\x4b\x8a\xd4\x64\x13\x89\x84\x86\x7f\xa4\x57\xa6\xb5\x23\x4c\x69\xed\x00\x62\x0f\xf7\x86\xa6\x8d\xe8\xe0\x0d\x4b\xeb\xa0\xea\x73\x55\x7d\x6e\xa0\xde\xae\xea\x1d\xa4\xa8\x4c\x94\x0c\x9f\x41\xec\x7b\x79\xa5\xca\x80\x81\x85\xa9\x4c\x49\x77\xf5\xa3\x29\x73\xa3\x7f\x50\x91\x2a\x62\x51\x99\x1b\xfd\x75\xa3\xf6\x19\xb2\xaf\x90\xb2\x87\xe8\x2f\xfb\x58\xe5\x8d\xb2\x1f\x27\x2d\x97\xec\x4f\xc9\xa5\x45\xf6\x14\x39\xf2\x06\xea\xbb\x53\xaa\xf6\xb6\xa2\xad\x6c\x43\xd9\x86\xfe\xad\x29\xaf\xe7\x5d\x95\xcd\x65\xb3\xed\x33\x5c\xa2\x7d\x63\xd9\x4c\x44\x23\x9a\x29\x8d\x69\xc9\x11\x05\x32\x9b\xb3\xd3\x0c\x7e\x4a\x24\x50\xdb\x94\x71\x4d\xa8\x8d\xe2\xa7\x44\x02\xb5\x59\xd4\x52\x0a\x37\x3f\x4b\x10\xce\x8e\xfc\x74\x9b\x4f\x21\xb2\xf1\x76\x29\xfa\x97\xc9\x46\xdb\xdb\xaa\xa2\xe1\x0e\xe1\x77\x8d\x6f\x1f\x23\x3b\xa1\x40\x49\x3b\x14\x74\x44\x41\x07\xca\x0e\xd6\x7b\x2e\xef\xed\x3c\xa3\xfa\x8b\x0a\xf9\x4b\xaf\x7a\xae\x9f\xf2\xeb\xb9\x7e\xcc\x6f\xe0\xba\x98\xdf\xdc\xb5\xe8\xfc\xda\xf3\x5b\xcf\xeb\xe3\x2e\x2c\xba\xa0\x1d\xb8\x20\xd7\x5d\x90\xae\x0b\xc5\x17\xc6\x5d\xd0\xc5\x39\xcf\x39\x2d\xf4\xfb\x7c\xbf\xab\xfc\xab\x0c\xd7\xd9\xaf\xda\xba\xbe\xfe\xaa\x96\x2b\xea\x2b\x59\xf3\xcc\xe9\x7c\x57\xd4\x69\xe9\x39\x9d\x9f\xe8\xfa\xf2\x54\xbe\xeb\xc0\xa9\xb7\x4f\x7d\x71\x4a\xf7\x9c\xca\x69\x91\x7f\x2a\x3f\xd9\xb5\x4f\xc6\x8b\x76\x32\x16\xbb\x71\x9e\xf0\xb6\x7a\xff\x2f\xda\x7e\xd6\xff\xf3\xb6\x27\xfb\x8b\xf6\xb1\x32\x11\x44\x4a\x12\x70\x6f\x2b\x3f\x25\x6e\x25\x88\x5e\x88\x06\x09\xbc\xcb\x18\x4f\x5f\xdd\xef\xfa\x4c\x9e\xec\xef\x3e\xd9\xeb\xe4\x8c\x93\xde\x93\x46\xd4\x49\x79\x22\x21\xc7\x55\x7c\x78\xdc\xe1\xe9\x87\xf5\x03\x87\xe4\xcb\xbd\x32\x5c\xe3\xf7\x4b\xf7\xfe\x26\xfb\x0f\xee\xd7\xc7\xef\x9f\xb1\x5f\x8b\xda\xe7\xda\xa7\x65\xed\xcb\xdd\x37\x6e\xdf\xd6\x7d\x5f\xec\xb3\xed\xd9\x92\xe1\x72\x97\x35\x29\xeb\x55\x36\xbe\x6c\x46\x99\xad\xcc\x7f\xd0\x53\xa3\x2c\xae\x7e\x7e\xf4\x6e\xe9\xde\xdd\x6b\xf7\x8c\xdd\xde\xdd\xc6\x8c\x17\xbc\x2f\x68\x51\x3b\x72\x77\x5c\xd8\xa1\x97\xc9\x08\x4f\xe6\xa6\x02\xd7\x0c\xef\x62\xaf\xe6\xf5\x1e\xf4\x9e\xf0\xea\x59\x5b\x73\xb7\x6a\xeb\xb6\x78\xb7\x68\x07\xb7\x9c\xd8\xa2\x65\x6d\xce\xdd\xac\xad\x7d\x4e\x1e\xdc\x74\x62\x93\xd6\x3e\x42\x46\x89\x6c\x19\x89\x1f\x82\x9f\xd1\x88\x1b\xd1\xf1\x22\xda\x93\x20\x7b\xad\x2e\x59\x3d\x7e\xb5\xfe\xe8\x8a\x0c\xd7\x23\xf9\x19\xae\x26\x2b\x3d\x2b\x35\x30\xec\x58\x91\x58\x23\x5f\x61\x09\x59\x11\x19\x93\xff\xc4\xf2\x36\xae\x75\xed\x43\x64\x1e\xa7\x70\x97\xec\x6c\x95\xf9\x32\xcf\x53\x6f\xb8\xeb\xe1\x14\xbf\x2b\x6a\xf9\xd6\xe5\x07\x96\xeb\x9e\xe5\x35\x9b\xe6\x7b\x96\x27\xa6\xf0\x23\x3c\x2a\x3f\x6a\x59\xd6\xb2\xdc\x65\xd3\x97\x5d\x58\x66\x8b\xda\x2b\xc3\xc5\x38\x19\xee\x71\x6b\x4b\x17\x64\xb8\x96\xf4\xf5\xbb\xbe\x58\x2c\x9b\x2c\x96\xae\xc5\x59\x8b\xb5\x71\x8b\xa7\x2f\xd6\xc4\xa2\xe8\x45\xee\x45\xba\x32\xea\x5e\x94\x5c\x23\xdf\xbd\xb0\xc9\x42\xad\xe7\x82\xe2\x05\xe3\x16\xe8\x4d\xe6\xcb\xa8\xf9\xae\xf9\x59\xf3\x75\xcf\xfc\xe8\xb8\xfc\xe8\x03\x32\x0c\x2f\xc2\x44\x13\x44\xf7\x1f\x94\x61\xdb\x93\xdc\xf9\x7b\xd4\x83\xa7\x57\x74\x7c\xfe\xbc\x59\x19\xae\x87\xba\xb6\x71\xcd\x79\xb0\xad\xeb\xc1\xd9\x6d\x5c\x0f\x74\xf5\xbb\xd6\xde\x2f\xa3\x67\xbb\x67\x37\x99\xad\x37\xb9\x4f\x4e\x9f\x25\x3d\xb3\x42\xc2\xf3\x4b\x89\xcf\x38\x92\x6b\x2c\x52\x5d\x26\xf7\xaf\x96\x93\xdc\xdf\x91\xa3\xf7\xb7\x13\xd9\x12\xda\x8a\x91\x3d\xfe\x53\xd2\xb1\xdd\x95\x91\x6f\x3e\x78\x5c\x71\x35\xf2\x07\x0f\x28\x70\xdd\x9c\xdf\xd4\x35\x90\x72\x00\x65\x5c\x76\x6c\x7f\x9b\xd4\xfb\x1b\xd9\x3a\x99\xee\x7c\x21\xa5\x8d\x2b\x4a\x97\x7b\x64\x35\x99\xbc\xbd\xb9\xcb\x53\x46\x91\x54\x2f\xbf\x4c\x86\x7a\xd2\x51\xd8\xa7\x57\x8a\xeb\x42\x6f\x7f\x6f\xcd\xd3\xbb\xf9\x75\xf9\x9e\xde\xe9\xf5\xf2\xdf\xee\x25\xbf\xe8\x2e\xbb\xe7\xd7\x74\x75\xcb\x2f\x70\xf5\x2a\x93\x29\x9e\xa1\xb2\x2b\xf1\xe8\x02\xb0\x02\xa4\x33\xb2\x35\x5f\x7e\x91\x7f\x21\x5f\x9b\x91\x2f\x93\x64\x42\xff\xc4\xec\x84\xfe\x31\x32\xaa\x7f\x74\x76\x54\x7f\xce\xe1\xfd\x25\xf3\xab\x46\xca\x70\x97\x2b\x2a\x37\xaa\x38\x6a\x7a\x94\x11\x15\x95\x15\xd5\x33\x6a\x5c\xd4\xa2\xa8\x2f\xa2\xfc\x51\x8e\x5c\xea\x2e\x44\xe9\xe3\x04\x8b\x84\x5c\x97\x28\x6d\xb2\x4c\x2e\xde\xd6\xaf\x6f\x66\x66\xb7\x32\x87\x9f\x73\x5d\x48\xaf\x81\x5e\x39\xc7\x9b\xde\x57\xfd\xf4\xf4\x1e\xe0\xb5\xcf\xf1\x8a\xfe\x03\x06\x16\x6e\x93\x72\x61\xd1\xfd\x0b\x16\x88\x0e\x35\xbb\x79\xb3\xfb\x16\x7a\x4b\x6a\x16\x75\xf3\x0e\xe7\xc1\xa3\x1e\x66\xf0\x10\x5d\x73\x5b\xa2\xe8\x50\x54\x3a\xa9\x74\xd2\xe4\xcc\xc0\x1f\x69\x3d\x96\x8a\xcc\xcc\x49\x93\x28\xcd\x17\xb3\x05\x11\x99\xc1\x3f\x52\xbd\xc8\xcc\xd2\x49\x93\x4a\xad\x1a\x46\xf0\x36\x29\x73\xb2\xf9\x33\xb3\xb4\x34\x38\x50\xf5\xe5\x41\x60\x06\xf5\xa5\x93\x84\x1a\x34\x29\xb3\x54\x96\x0a\x55\x30\x4a\x19\x65\xb4\x9c\x24\xcc\x61\xa5\xfc\x08\x9a\x44\xd3\xe0\xd2\x4c\x31\xb8\xd4\x7c\x1d\xcc\x10\x34\x94\x06\xb0\x5c\xc5\x36\xb8\x34\x80\xb4\x34\x68\xd1\xfc\x93\x2c\x84\xed\x98\xed\x98\xb8\xd7\x96\xc7\xad\xb6\xc4\xfc\xf9\x97\x3f\x46\x6b\x56\xe1\x29\x42\xf8\xcf\xa9\x37\xff\x39\x7f\x71\xe0\xd9\x77\x93\xef\xa6\xff\xf7\xd7\xf5\x7f\xff\x13\xf8\xf7\x41\xb9\x8d\xbe\xc4\x1d\x75\x9d\x78\x9d\xa7\xfb\xad\xa6\x39\x62\x1a\xf7\xd7\x83\x7f\xe9\x7e\x40\x1c\xe5\x36\x3b\x9f\x5b\xeb\x2a\x6e\x88\xcd\xfe\x51\xed\x1e\xf4\xdc\x63\x3e\x2d\xe7\x86\xfc\x8f\x7f\xe4\x06\x31\x8e\xdb\xee\x7a\xec\xaa\x1b\xe7\x8b\x62\xb0\x9c\x2b\x75\x6e\xd4\x93\xb8\xcf\x96\x61\xbb\x97\xb1\xcd\x38\xec\xeb\x2e\xbe\x97\xdb\xc5\x61\x19\x22\xee\x96\x99\xda\x0a\x30\xac\x10\x9f\xda\x3e\x32\xde\xff\x37\x85\x4b\xb9\x0b\xdf\xca\xcf\xdd\xfc\x5c\xa5\x2a\xb4\x9f\xc4\x52\xad\x9d\x18\xab\x3d\xad\xe7\x71\x3f\x5f\x27\x4a\xb4\xee\x54\xab\xbf\x81\x76\x83\x58\x2f\x07\x72\x83\x9f\x21\x6e\x01\x85\xe0\x69\xf4\x5f\x74\x65\xe8\x5d\xb9\xd3\xdf\x2d\xd4\xdf\xcf\xae\xd2\x62\x9b\x75\x65\x9b\x08\xf3\xff\x0c\xe2\x87\xb8\x21\xaf\x60\xf4\x04\x31\x50\xf4\xb1\x9a\xb7\x6b\xea\x8b\xe9\x02\xdd\x85\x37\xcf\x73\xcf\x57\x7f\xe6\x05\xc7\xda\x37\xea\xe3\xb5\x7d\x9a\xb3\xe2\x51\xee\xd5\x4b\x44\x0f\xfe\x37\x5c\x0c\x97\x33\xc5\x5a\xb1\xc1\x37\xda\xb7\x5a\xac\x92\x79\xac\x85\x8b\x7d\xbf\xfa\xbf\x15\x53\x6d\x79\x5a\x0f\x11\xee\x3f\x6f\x7b\xe4\xca\x25\x31\x56\x74\xe7\x3e\x9f\x2f\xbe\xf9\x67\x36\x2d\x7c\xc7\x44\xd4\x95\x5a\xfe\x9f\xb4\xcb\x22\xd2\x48\x14\xa1\xbe\x77\x89\x9a\xf5\x47\x1f\x28\xa2\x2b\x6a\x93\x4d\x77\xfa\x2f\xfa\x4a\x7c\x7d\xe9\x13\x65\x24\xda\x9e\xb6\x6d\xb7\x1d\x16\x77\x89\x62\xfb\x4c\x63\xb4\x88\x37\xde\x34\x33\xee\x5d\xdf\x74\x7c\xfc\x94\xbc\xd8\x0b\x6f\xc1\x3f\x05\xd7\xc8\x6a\x04\x4c\x5a\x38\xda\x4b\xc8\xdb\x7e\x20\x98\x84\x6c\xc0\x5b\x92\xcb\x0e\x73\x0e\x8e\x7f\x0e\xea\x1d\xcb\x91\xd7\x91\xdf\xc9\x3b\x72\xc7\x79\x91\xd3\x14\x63\x42\x78\x0f\x25\xb7\xc3\xc6\x0b\x11\x5e\x0f\xe1\x3d\x82\xfe\x91\x48\x14\xef\x51\x77\x22\x1f\x09\x11\xdd\x06\xd9\x27\x44\x4c\x0d\xe4\x84\x10\x71\xbc\xc7\xbd\x27\x44\xfc\x62\x21\x12\x88\x6a\xc2\x41\x21\x12\xc1\x94\x48\x99\x74\x1b\xc2\x98\xe4\x4e\xc8\x4e\x21\xaa\x61\xaf\x1a\xfa\xab\xc7\x23\xf4\x4f\xa1\x4c\xa1\xac\x41\xff\x1a\xd8\xab\x09\xae\x5a\xd4\xd5\xc2\x56\xad\x93\x42\xb8\xc0\xea\xe6\xdd\x3d\x03\xf9\x4a\x88\x54\xc6\xa7\x32\x3e\x15\xdd\xb5\xb1\x5f\x1b\x7b\xb5\x67\x0b\x91\x46\xff\x3a\xbc\xd7\x39\x25\x44\xfa\x1c\x92\xe6\x3a\x04\x8c\x75\x61\xac\x1e\xe3\xeb\x51\x57\xdf\x40\xe8\x57\x1f\xcc\x0d\x78\xcf\xe4\x3d\x13\xbd\x0d\xf1\xad\xe1\x31\x21\x1a\x79\x84\x68\x0c\x57\x8d\x69\xcb\x82\xc7\x2c\xf8\x6b\xd2\x10\x81\xc3\xa6\xd8\x6d\x0a\x96\x6c\xb8\xc8\xa6\x3d\x07\xbb\x39\xe8\xc9\xc1\x5e\x33\xda\x9a\x63\xa3\xf9\xcf\x42\xb4\xa0\xae\x25\x3a\x5b\x52\xb6\x72\x23\xcc\xbe\xd6\xe8\xbe\xbe\x4c\x88\x36\x37\x23\xeb\x11\x78\x68\xcb\xb8\xb6\xf4\x6f\x87\x8d\x5c\x70\xe7\xe2\x8f\x67\x33\x82\x8f\xed\xa9\x6b\xaf\x4a\xda\x3b\x80\xb7\x03\xcf\x1d\x19\x0b\x85\xa2\x13\x76\x3b\x61\xbf\x13\x3a\xf3\xb0\xc3\x8d\x54\xe4\xa1\x2b\x9f\xd8\xe6\x83\x3f\x9f\xb1\xf9\xd8\xe8\x8c\xdd\xce\xaa\x24\x2e\x05\xf8\x59\x00\xc6\x02\x72\xa0\xe0\x11\x04\x8e\x0b\xe0\xba\x0b\xbe\x75\x21\x67\xba\xb2\x0a\x76\x85\xff\xae\xd8\xea\x8a\xaf\x5d\x89\x57\x37\xfc\xef\x86\xae\xee\xbd\x10\xec\x74\xc7\x4e\x77\xec\xf4\xc0\xcf\x1e\x00\xe9\x81\x8e\x1b\xa8\xbb\x81\xba\x9e\xf4\xed\x89\xed\x9e\xd8\xec\x89\x6f\x3d\xc1\xdb\x1b\x4e\x7b\x33\xb6\x37\x63\x7b\xe3\x57\x6f\x74\xf6\x81\xdb\x3e\xf4\xeb\x43\x4e\xf4\xc1\x4e\x1f\xf2\xae\x2f\xd2\x0f\xff\xfb\xe1\x57\x3f\xec\xf7\x03\x73\x3f\xb8\xe3\x4c\x23\xfa\xcf\x17\xe2\x46\xfa\xde\x48\x6e\xdf\x88\xbd\x1b\xc1\x7c\x13\x98\x6f\x2a\x14\x82\x7f\x44\x61\x13\x84\xbc\x2d\x24\x7f\x0a\xe1\xaf\x90\xdc\x2d\x02\x5f\x11\xf9\x58\xc4\xb8\x22\x7c\x2d\x62\x5c\x11\x3c\x0e\xa8\x83\x80\x67\x00\x78\x06\x80\x67\x00\xb9\x35\x90\xfc\x18\x08\x8f\x37\xe3\xc7\xcd\xf8\x31\x08\x3f\x06\x31\x76\x10\x3c\x0d\x62\xec\xa0\x23\x08\x3a\x07\xa3\x73\x30\x3e\x0f\x86\x8f\xc1\xe0\x1b\x0c\x3e\xb5\x98\x16\x83\xa5\x98\xb8\x14\x13\x8f\x62\x74\x16\xe3\x63\x09\x3e\x96\x80\x65\x08\x3a\x86\xe2\xd7\x50\xfc\x1a\x0a\x2f\x43\x37\x9b\xff\x2d\x02\x31\x0c\x1b\xc3\xc8\xcd\x61\xe0\x1e\xc6\xb8\x61\xe4\xc5\x70\x62\x37\x1c\x7b\x23\xb0\x3d\x02\xdc\x23\xc8\xe7\x11\xf4\x1f\x41\xec\x46\x12\x97\x91\xf0\x32\xf2\x8a\x10\xa3\xf0\x61\x14\xfa\x46\xf1\x3e\x0a\xfe\x46\x81\x63\x14\xf5\xa3\xd1\x7f\x0b\x3a\x6e\x81\xdb\x5b\x98\x1b\xb7\xa0\xeb\x16\x30\xdc\x02\xb7\x63\xc0\x30\x06\xbf\x6f\x25\x07\x6e\x05\xfb\xad\xe8\xc4\x84\xb8\x0d\xee\x6e\x03\xfb\x6d\x70\x77\x1b\x7e\xde\x8e\xbd\xb1\x4a\xc0\x38\x0e\x1f\xc6\xd1\x3e\x0e\x92\xc7\x81\x71\x1c\x18\xc7\x91\x27\xe3\xe1\x61\x3c\x3c\x8c\xc7\xc6\x78\x6c\x8c\xc7\xc6\x78\x6c\x4c\xc0\xc6\x04\xea\x27\xe0\xf3\x04\xea\x27\xa0\x6f\x22\xef\x13\x69\x2b\x65\x0e\x94\x62\xbf\x14\xde\x4b\xe1\xb9\x14\x9e\x27\x81\x75\x12\xba\x27\x11\xdf\x49\xe8\x98\x44\x7c\x26\x93\x83\x93\xc1\x3f\x19\xdd\x93\x99\xb3\x93\xf1\xed\x0e\x70\xde\x41\xde\xde\x31\x1c\x01\xe7\x1d\xf4\xbd\x83\x78\x4c\xc1\xde\x14\x78\x99\x42\xbf\x3b\xe1\xea\x2e\xda\xef\x22\x36\x53\x89\xc7\x54\xf2\xef\x6e\xb8\xbd\x1b\x9d\xf7\x10\xdf\x7b\xc1\x7f\x2f\x98\xa6\xc1\xed\x34\x62\x3d\x9d\xf7\x19\xf8\x36\x83\xb1\x33\xc1\x38\x8b\x78\xcc\x82\x97\xfb\xb0\x3d\x1b\xff\x66\x63\xe3\x7e\x08\xba\x1f\x4e\x1f\x00\xfb\x03\xf8\xfe\x20\x9c\x3f\x48\x6c\xe7\xc0\xfb\x43\xc4\xe0\x21\xb8\x7f\x88\xfa\x87\xc8\xad\xb9\xf8\x35\x0f\x7d\xf3\xc0\x3b\x9f\xf6\x05\x8c\x59\x80\x8f\x0b\xc1\xb5\x88\xb5\x62\x31\xef\x8b\x69\x5f\x0c\x17\x4b\xb0\xb9\x14\x1b\x4b\xc1\xb8\x8c\xfa\x65\xe8\x58\x8e\x9d\x87\xf1\xf1\x61\xb0\xae\xc0\xa7\x15\xc4\x73\x25\xfd\x1e\x01\xdb\x23\xf8\xf0\x28\xcf\x8f\x51\xbf\x0a\x9f\x57\xa1\x77\x35\xf6\x1e\xe7\xf9\x71\xe2\xb4\x06\x7b\x6b\xc0\xb2\x06\x4e\xd6\xf2\xbc\x16\xdf\xd6\x21\x4f\xd0\xe7\x49\x6c\x3c\x85\xde\xa7\xe8\xb7\x1e\xee\x9e\x46\xc7\x33\x70\xfc\x0c\x3a\x9f\xc5\x87\x67\xc1\xf6\x2c\x18\x9f\xa5\xdf\xb3\xcc\xd7\x0d\xc4\x64\x03\x1c\x6c\x80\xff\x0d\xe8\xdc\x80\x6f\x1b\xe1\x7f\x23\x38\x37\x12\xab\x8d\xe8\xdf\x48\xfc\x36\xe2\xe7\x46\x70\x6c\x42\xd7\x26\xb0\x6f\xa2\xee\x39\xc6\x3e\xc7\xd8\xe7\xe0\x6d\x33\xb8\xb7\xc0\xd7\x16\xda\xb6\x90\x4f\x5b\xb0\xff\x3c\x78\x9e\x27\x06\xcf\xd3\xf7\x79\x6c\x6d\x65\xec\x56\xe2\xb1\x95\xfc\xdb\x0a\x5e\x2f\x63\xbd\xf8\xbd\x0d\x3f\xb6\xe3\xdb\x76\xb0\x6e\x67\xdc\x0e\x6c\xee\x00\xcb\x0e\xb0\xa8\x0d\x7c\x17\x58\x77\x31\x7e\x37\xf6\x76\x33\x66\x37\xf6\x76\xc3\xcf\x6e\x72\x9a\xab\xbd\x28\xc3\xdf\x32\x72\xb0\x8c\xf5\xa2\x8c\x58\x97\xa1\x73\x0f\xdc\xef\x21\x3f\xf6\xb0\x76\xef\x21\x2f\xf7\xb0\x86\xec\x25\x4f\xf6\x62\x7b\x2f\xf9\xb7\x97\x78\xef\x85\x93\x17\xe1\xe4\x45\x38\x79\x11\x3c\x2f\x12\x8b\x17\xc1\xb2\x0f\x2c\xfb\xf0\x67\x1f\x76\xf6\x31\x7e\x1f\xf5\x2f\xd1\xbe\x1f\x7d\xfb\x79\x3f\x40\xdb\x01\x30\x1d\xc4\xfe\xcb\xf0\x72\x08\xff\x0e\x83\xe1\x30\x71\x3d\xcc\x7c\x39\x82\x9f\x47\xb0\x7f\x04\x7f\x8e\xc0\xc1\x11\x7c\x7a\x05\xec\xaf\x30\x1f\x5e\xe1\xfd\x15\xf8\x79\x05\x2e\x5f\x65\xcc\xab\xe8\x7c\x95\x38\xbd\xc6\xf3\xeb\x8c\x79\x1d\xec\x6f\xe0\xd3\x1b\x94\x6f\xa2\xfb\x18\xb6\x8f\xd3\xff\x2d\x74\xbe\x85\xcd\xb7\xf1\xe5\x04\xbe\x9e\x20\xaf\xde\x01\xdf\xbf\x18\xff\x2e\xb9\xfc\x2e\x98\xdf\xa3\x7c\x1f\x6c\xef\x63\xef\x03\xf0\x7e\xc8\xf3\x47\xcc\xe9\x8f\xc0\xf7\x31\x3e\x7e\x42\xfb\x27\x8c\xfb\x94\x9c\x3e\x49\x0e\x7c\xc6\x5a\xfd\x19\xfe\x7e\x4e\xcc\xbe\xa0\xfd\x14\x39\x7a\x8a\xb1\x5f\xd2\x76\x1a\xae\xce\xa0\xf3\x8c\x2a\x89\xd9\x57\xe8\xfa\x1a\x5c\x5f\xa3\xf7\x2c\x3e\x9c\x05\x73\x39\x98\xcb\xe9\xff\x0d\xfa\xbe\x65\xfc\xb7\xf8\xfe\x1d\x31\xf8\x9e\x75\xee\x7b\x78\xfa\x1e\xce\xcf\x61\xfb\x07\x72\xeb\x07\xe2\x72\x9e\xba\x0b\x70\x70\x11\x4c\x17\xf1\xff\x47\xec\xfe\x84\xcd\x9f\xd0\xf9\x13\x79\x72\x09\x7f\x7e\xc6\xde\xcf\x60\xfa\x85\x38\xfd\xc2\x98\x5f\xd1\xfb\x2b\x79\xf0\x1b\xef\xbf\xa1\xeb\x77\x30\xfc\x8e\x8d\x3f\xb0\xfd\x27\x7c\xfd\x09\x37\x97\xc9\xbb\xcb\xf4\xb9\x82\xfe\x0a\x78\xaa\x50\xff\x9e\x61\xa1\xf5\x77\xad\xe8\xe3\x9f\xcf\x65\x3f\x19\x79\x04\xb9\xc2\x45\x7f\x8e\x90\x5a\x27\xe4\x9c\x90\xfa\x09\x21\x8d\x9b\x91\x6f\x84\xb4\xdd\x29\x24\x67\x26\x69\xf7\x22\x07\x85\x74\x30\xce\x39\x1c\x99\x24\x64\x48\x13\x64\x03\xc2\x98\xd0\xcd\x42\x86\xdd\x26\x64\x78\x43\x21\x23\xa2\xb9\x83\xa3\x8b\x33\x92\x8c\xa6\x5f\x4c\x89\x90\xb1\x33\x84\x8c\x1b\x2f\x64\x7c\x77\x04\x3d\x09\xe8\x49\xa4\x5f\x22\xe3\x93\x68\x4f\xa2\x5f\x32\x78\x92\x17\x0b\x59\xcd\x40\x78\xaf\xce\x81\xb8\xfa\x7a\x21\x53\xd0\x95\x72\x04\x79\x0f\xf9\x4a\xc8\x1a\xf5\x10\x6c\xd5\x00\x53\x0d\xb0\xd7\x44\x67\xcd\x93\x42\xd6\xa2\xae\xd6\x3d\x08\xba\x39\x2f\x49\x17\x58\x5c\xe8\x71\x61\xcf\x75\x51\x48\x77\x1d\x04\xec\x6e\x74\xba\xd1\x95\x8a\x5f\xa9\xe8\x4e\x05\x5b\x2a\x3e\xd7\xc6\x6e\xed\x5e\xc8\x6a\xe4\x94\x90\x69\xf4\xe7\x2c\x25\xd3\xe8\x5f\x87\xb6\x3a\xfd\x10\xec\xa5\x83\x37\x1d\x1c\x19\x05\x08\x7d\x33\xa8\xe3\x6c\x25\xeb\xd1\xa7\xde\xeb\x42\xd6\x47\x67\x7d\xfa\xd6\x07\x07\xe7\x2b\xd9\x20\x1e\x29\x44\xf0\xad\x01\xed\x99\xf8\x9d\x89\x8e\x4c\x7c\x6f\x88\xcf\x0d\xc1\xd4\x10\x5f\x1a\xfe\x2c\x64\xa3\xeb\x10\xec\x35\xc2\x7e\x63\x0f\x82\xfe\x2c\x70\x66\x31\x3e\x8b\xf1\x59\x8c\x27\x7c\xb2\x09\xfd\x9a\xe0\x6b\x93\x9d\x42\x36\x45\x5f\x53\xb0\x34\xc5\x8f\xa6\xf8\x95\x8d\xfd\x6c\xb8\xce\x66\x6c\x0e\x63\x73\x9a\x21\xf0\x90\xf3\x91\x90\xcd\x68\x6b\x86\xfe\x66\xbf\x0b\xd9\x1c\xff\x9a\x8f\x46\xd0\xd9\x82\x3e\x2d\xc8\x81\x16\x3c\xb7\x0c\x47\xe0\xa1\xe5\x72\xe4\x98\x90\xa4\xae\xbc\xae\x0d\x82\xbd\xeb\xb0\x77\x1d\x63\x5b\xf1\xce\x79\x4e\xb6\xda\x27\x64\x6b\xfc\x6b\x0d\xd6\xd6\xb3\x11\xc6\xb7\x86\xfb\xeb\x6b\x20\xbc\x5f\xcf\x7b\x1b\x6c\x72\xd6\x93\x6d\xd0\xd5\x16\xac\x6d\xe1\xa5\x2d\x7d\xda\x11\x9f\x76\x60\x6e\x07\x47\xb9\x8c\xcf\x25\x7e\xb9\xe4\x63\x2e\xbe\x7b\x88\xa9\x07\xee\x3d\x8c\xf3\xe0\x53\x7b\xb8\x6d\x4f\x5d\x7b\xc6\xb6\xa7\x7f\x07\x9e\x3b\xc0\x59\x47\x72\xa1\x23\xbe\x76\x24\xff\x3a\x92\xaf\x9d\xe0\xa9\x13\x7e\xe7\xe1\x77\x1e\x7d\xf2\xe0\x2c\x8f\xf1\xf9\x60\xcc\xe7\xbd\x33\xbe\x74\x86\xf7\x02\xec\x16\xa0\xa7\x0b\x78\xba\x83\xb5\x3b\xf1\xe8\x4e\x7d\x0f\x37\x02\x6e\xce\x74\xf2\x06\x74\xdc\x00\x27\x37\xd0\xaf\x27\xe3\x7b\xa2\xab\x17\x3a\x7a\xc1\x4b\x2f\x6c\xf5\xc6\xaf\xde\xf0\xda\x1b\x8c\x7d\x88\x23\x67\x39\xd9\x07\x1c\x7d\xf1\xa1\x1f\xf1\xe8\x07\x8e\xfe\xd4\xf7\xe7\xfd\x46\x7c\xbd\x91\x9c\xb9\x09\xbe\x0b\xe1\xbd\x10\x1d\x45\xd8\x2e\x02\x7b\x11\xf3\x67\x00\x7e\x0c\x00\xc3\x00\xf4\x0d\xc0\xfe\x40\xf8\xbf\x99\xb1\x37\x53\x7f\x33\x7a\x6f\x66\xec\x20\x30\x0c\x22\xaf\x06\x31\x76\x30\xf1\xe2\x0c\x26\x39\x83\xc9\x62\xb8\x2b\x41\x7f\x09\xe3\x4b\xd0\x57\x82\x6f\x25\xc4\x65\x08\x18\x86\xc0\x07\xe7\x2f\x39\x04\x2e\x87\x92\x33\x43\xa9\x1b\x4a\xdd\x50\xda\x87\x12\x0f\xce\x61\x72\x18\xed\xc3\x68\x1f\xc6\x3c\x19\x86\xaf\xc3\x99\xfb\xc3\xb1\x39\x9c\xf8\x8e\x00\xc7\x08\xf4\x8e\x20\x37\x47\xe2\xdb\x48\x62\x33\x0a\x1c\xa3\xb0\x39\x8a\x3e\xa3\xf0\x6d\x14\x73\x73\x14\x39\x31\x9a\xb1\xb7\xe0\xf3\x18\xfc\x1b\x43\xae\xdd\x4a\xff\xdb\xc8\xed\xdb\xc0\x7e\x3b\x71\x1b\x0b\xf7\x63\xf1\x79\x2c\x71\x1b\x07\x77\xe3\x68\x1f\x8f\x2f\xe3\xf1\x61\x02\xf9\x34\x81\x38\x4d\xa4\x1f\xe7\x24\x59\xca\x7c\x9a\x44\x5c\x26\x51\x37\x99\xba\x3b\x78\xe6\xbc\x23\xa7\xd0\x36\x05\x0e\xa6\xe0\xe3\x14\xc6\x4f\xc1\xce\x9d\xf8\x71\x17\x18\xa6\x82\x75\x2a\xbe\x4c\x05\xc3\x54\xda\xee\x06\xff\x3d\xc8\xbd\xd8\xbc\x17\x7d\xd3\xe0\x72\x1a\x38\xa7\xd3\x67\x3a\x7e\xcf\x00\xc7\x4c\x62\x3c\x13\x9f\x66\x11\xe7\xfb\x18\x3f\x1b\xfd\xb3\xc9\xf1\xfb\x89\xf3\xfd\xe0\x7e\x00\xfd\x0f\xd2\x6f\x0e\x5c\x3f\x04\x77\x73\x89\xc9\x5c\x6c\xcd\x83\xe7\xf9\x8c\x9d\x4f\xac\x16\x50\xbf\x90\xfa\x85\xe8\x5f\x08\xc7\x0b\xd5\x3b\x3a\x17\x61\x7b\x11\xd8\x17\x81\x67\x11\x78\x16\xc3\xcb\x62\x74\x2d\x41\xd7\x12\xc6\x2d\x29\x43\xf0\x69\x29\xbe\x2d\xc5\xf6\x32\x70\x2e\x83\xd7\xe5\xac\xab\xcb\x55\x49\xdd\x72\xfa\x2d\x87\xa3\x87\xf1\x79\x05\xfc\xad\xe0\x79\x05\xf6\x57\x10\x8f\x95\xe8\x5b\x89\xfe\x95\xe8\x7f\x84\x7c\xe0\x9c\x24\x1f\xa1\xdf\x23\xac\x75\x8f\xd2\xf7\x51\x7c\x7d\x8c\xe7\x55\xc4\x69\x15\x7d\x56\x83\x6d\x35\x36\x57\x93\xdb\xab\xf1\x6b\x35\x39\xfc\x38\xb6\x1e\xc7\xd6\xe3\xd8\x7a\x9c\x38\x3f\xce\x98\x35\xf8\xb5\x06\x7f\xd6\x80\x7f\x0d\x7d\xd6\xc2\xc5\x5a\xc6\xac\x43\xf7\x3a\xde\x9f\x20\xa6\x4f\xd2\xf7\x29\xb8\x7a\x0a\xee\x39\x57\xc9\xf5\xf8\xf7\x34\xbc\x3e\xcd\x1c\x7a\x06\x1c\xcf\xd0\xf7\x59\xf4\x6e\x00\xe3\x06\x30\x6f\x20\xb7\x36\x62\x63\x23\x7a\x36\x31\x76\x93\x2a\xc1\xf0\x1c\xed\xcf\x81\xfd\x39\xc6\x3c\xc7\xfc\x7a\x8e\x38\x6d\xa6\x7d\x33\xfc\x6e\xa6\x7d\x0b\xf5\x5b\xd0\xf9\x3c\xb6\x38\x33\xc9\xad\x70\xbb\x95\xb1\x5e\xec\x6d\xa3\xcf\x76\xd6\xaa\xed\xe4\xce\x76\x7c\xdc\x81\x7f\x3b\xc0\xb0\x13\x3b\x3b\xd1\xb1\x93\xf6\x9d\xe8\xdb\xc9\xb8\x17\x78\xde\x85\x8e\x5d\xe0\xdd\x85\x8f\xbb\x89\xd5\x6e\x30\xee\x86\x8f\x32\xfa\xec\xc1\xce\x1e\x7c\xdb\x4b\x1e\xbc\x88\x0e\xce\x3a\x72\x1f\x7e\xbd\xc4\xb8\xfd\xe8\xdd\xcf\x1a\x7f\x00\xde\x0f\x12\x8f\x97\xa9\x3b\xc4\x1c\x3a\x8c\xae\x57\xe0\xef\x15\x72\xf4\x55\xec\xbf\xc6\x98\xd7\x99\x1b\xaf\xe3\xc7\x51\x62\x79\x94\xf7\xa3\xcc\xab\x37\xe0\xeb\x4d\x38\x3c\xc6\xfb\x71\xb0\xbe\x45\xbe\xbf\x4d\x7e\x9c\x80\xe7\x13\xe8\x3e\x81\x3f\xef\xa0\xef\x5f\xc4\xec\x5f\xd8\xfe\x17\x7a\xdf\x65\xfc\xbb\xe0\x7b\x17\x9b\xef\xc3\xe3\x07\xc4\xf1\x43\x9e\x3f\x42\xf7\xc7\xf0\xf5\x31\x36\x3f\x21\xf6\x9f\x82\xe7\x53\xe6\xdd\x49\x72\xe8\x24\xef\x27\xc1\xf9\x19\xf9\xfb\x39\x78\xbe\xa0\xed\x14\x75\x5f\xc2\xff\x69\x7c\x3c\x03\x2f\x5f\x61\xf3\x2b\xf4\x7c\xcd\xfc\x39\x8b\x9e\xb3\xf8\x5c\x8e\xcf\xdf\xc0\xc7\x37\x8c\xfb\x16\x7c\xdf\xc2\xd7\x77\xf8\xf5\x1d\x36\xbf\x87\xe7\x73\xc8\x0f\x60\x3e\x8f\x2f\x17\xf0\xfd\x02\x71\xb9\x08\xa6\x8b\xe8\xbb\x48\x5c\x7f\xc4\xaf\x1f\xc1\xf3\x13\x6d\x97\xd0\x7f\x09\xbb\x3f\xb3\x5e\xff\x8c\xde\x5f\xf0\xe3\x17\xe2\xf7\x2b\x71\xfb\x15\xfd\xbf\x62\xfb\x37\x72\xf1\x77\xfa\xfe\xc1\x3a\xf3\x27\x63\xff\xc4\xcf\x3f\x19\xf3\x27\xed\x97\xb1\x71\x85\xba\x2b\x70\x5f\x41\xfe\xf9\xc8\x43\x1f\x31\xf2\x83\xcb\xff\xba\xd0\x44\x2f\xe4\x23\xa1\xc9\x47\x84\xc6\x79\x45\xd3\xfa\x21\x33\x10\x2f\xf2\x95\xd0\xf4\x64\xa4\x1e\x72\x1d\x32\x1a\x59\x8e\xac\x47\x76\x22\xdf\x08\xcd\xa0\xdd\xe8\x8e\xdc\x83\x30\xc6\x38\x25\x34\xdb\x62\x64\x1d\x72\x02\xb9\x22\x34\x7b\x13\xa4\x04\x61\xac\xfd\x88\xd0\x1c\x77\x0a\xcd\x59\x07\x29\x44\xe6\x20\xfb\x90\x73\x42\x0b\xa9\x81\x14\x20\xe8\x0a\xd9\x8c\xa0\x2b\x34\x1e\xa1\x2e\x94\x31\xa1\xef\x09\x2d\x0c\x5d\x61\xc3\x11\x74\x85\x83\x37\xfc\xa2\xd0\x22\xb0\x15\x09\xee\xc8\xdf\x85\x16\x05\xb6\x68\x37\x42\xbf\x68\xf0\xc7\x80\x33\x76\xb6\xd0\xe2\x68\x8f\x8f\x46\x8e\x09\x2d\x01\xfd\x89\xd8\x4f\xc4\xff\x24\x74\x71\x56\xd2\x92\xe8\x93\xec\x44\xe6\x0b\xad\xda\xcd\xc8\x6d\x42\xab\xce\x3b\xe7\x25\xad\x3a\x3a\xaa\x83\xbb\x3a\xf6\xab\xa3\x33\x05\x3c\x29\x27\x85\x56\x03\xbc\x35\xe8\x5f\x33\x1c\x69\x83\xa0\xab\x26\x7e\xd4\xc2\x7e\x2d\xfa\xd4\x5a\x8d\xc0\x41\x2d\xfc\x70\x81\xc7\xf5\xb3\xd0\x38\x2f\x69\xee\x32\xa1\xa5\xc2\x1b\x67\x25\x2d\x15\x3b\xa9\xe0\x4f\xc5\x8f\xda\x60\xaa\xdd\x0c\xc1\x66\x6d\x6c\x72\x66\xd2\xd2\xc0\x9c\x86\xbe\x34\xc6\xa7\x61\x2b\x8d\x7e\x75\x0e\x0a\x2d\x9d\x7e\xe9\xf4\x49\xc7\x1e\xe7\x26\x2d\x03\x3b\x19\xf8\x5f\x97\xbe\x75\xb1\x51\x17\xdb\xf5\xd0\x57\x0f\xde\xeb\xe1\x5b\x3d\x62\x53\x0f\xcc\xf5\xc1\x5a\x9f\xfe\xf5\x89\x71\x7d\xfc\x6f\x20\x10\x62\xdb\x00\x9b\x0d\xf0\x2f\x93\xfa\x4c\x70\x36\x24\x86\x0d\xb1\xdf\x08\xde\x1a\x11\xa3\x46\xe8\x6e\x0c\x2f\x8d\x69\xcb\x6a\x88\xa0\x33\x8b\xba\x26\x70\xd7\x04\x4e\x9a\x62\xaf\x29\x18\xb2\xd1\x95\x4d\x5e\xe4\x10\xdb\x1c\xde\x9b\xe1\x5f\x33\x30\x37\x47\x6f\x0b\x6c\xb7\x00\x4f\x4b\x62\xda\x72\x03\x02\xa7\x2d\xb1\xd1\x92\x1c\xb9\x0e\x7f\xae\xc3\xbf\x56\x06\x02\xae\xeb\xc9\xb9\x36\xf4\x6f\x03\xc7\x6d\xb0\xdf\x16\xff\xdb\x92\x13\xed\xb0\xd7\x0e\xfd\xb9\xe0\xca\xc5\xcf\x5c\x6c\x78\xd0\xe9\x21\xae\x1e\xfc\xf3\xc0\x47\x7b\xea\xdb\x53\x76\x20\xaf\x3a\x52\xdf\x09\xac\x9d\x68\xcb\x03\x5b\x1e\x3c\x70\x6e\xd1\xf2\x79\xef\x8c\x8d\xce\xd4\x75\xa6\x5f\x01\x39\xd1\x85\x78\x74\x41\x6f\x17\xc6\x77\xc1\x4e\x57\x6c\x77\x03\x6b\x37\x6c\x74\x27\x0e\xdd\xe1\xb6\x3b\xfe\x74\xa7\x6f\x0f\xb0\x71\xae\xd1\x6e\xa0\xbc\x01\x3c\x3d\x89\x45\x2f\x70\xf6\x86\xcf\xde\xf8\xd1\x87\xb1\x7d\xb0\xdd\x17\x9d\x7d\xc9\xdd\xbe\xe0\xe9\xc7\xfc\xe9\x87\xfd\xfe\xd8\xe8\x4f\x0c\x6f\xc4\xa7\x1b\xc9\x85\x9b\xb0\x75\x13\xbc\x16\xc2\x61\x21\x5c\x15\xc1\xf3\x00\xf4\x0c\x80\x97\x81\x8c\xbb\x99\xd8\x0c\xa2\x7d\x30\xfe\x17\x83\xad\x84\xdc\x29\x01\xff\x10\xc6\x0e\x25\x4e\x9c\x35\xb4\x61\xd8\x1a\x4e\x5c\x47\x30\x6e\x04\xfd\x47\x12\xfb\x91\x60\x1a\x05\xee\x51\xe3\x85\x36\x1a\x5f\x47\xc3\xf9\x2d\xc4\xee\x16\xca\x31\x60\x19\x03\xff\xb7\xe2\xcb\x6d\xe0\xb9\x0d\x0e\x6e\xc7\xb7\xb1\xf4\x1b\x4b\xfd\x58\xd6\x84\xb1\xd8\x1e\x87\xbe\x71\x70\x30\x0e\x0e\xc6\xe3\xcb\x78\x30\x4d\x00\xc7\x04\xf0\x4f\x44\x7f\x29\xb1\x9a\x84\x4c\xa6\xee\x0e\x30\x4e\x01\xff\x5d\xcc\x9b\xbb\xe0\x84\x33\x83\x76\x37\xfe\xde\x43\x7e\xdf\x8b\x8f\xd3\x58\x6b\xa6\x31\x6e\x3a\x6b\xcd\x0c\xc6\xce\x04\xdb\x4c\x38\x9d\x45\xff\x59\xf4\xbd\x8f\xfa\xd9\xe0\xb9\x1f\xff\x1f\xa0\xed\x41\xe6\xd4\x83\x60\x98\x43\x2e\x3d\x84\xed\xb9\xf4\x9b\xcb\xfb\x3c\xe6\xfe\x7c\x38\x5e\x00\xee\x05\xbc\x2f\x44\xff\x22\x70\x2f\xf6\x08\x6d\x09\x7e\x2f\x05\xf3\x52\xf2\x6a\x19\xf9\xbc\x1c\x6c\x0f\xc3\xc7\x0a\xfc\x5e\x41\x5f\xf6\x77\xed\x11\xe2\xff\x28\xef\x8f\xd2\xe7\x31\xec\xad\x82\xbf\xd5\xd8\x7c\x1c\x7d\x8f\xe3\xf7\x1a\x9e\xd7\xc0\xc5\x1a\x7c\x59\x0b\x77\x6b\x19\xbf\x96\xfa\x75\xe4\xca\x3a\xfc\x7f\x82\x7e\x4f\xa0\xf7\x49\x30\x3e\x89\x9f\x4f\x61\x7f\x3d\xf8\xd6\xf3\xfc\x34\xf1\x79\x86\x9c\x78\x06\xdb\xcf\x12\x93\x0d\xd8\xda\xc0\x3c\xd9\x08\xbf\x9b\xc8\x8f\x4d\x60\x78\x8e\x7c\x7d\x8e\xf7\xcd\x60\xd8\x4c\x1f\xf6\x63\xed\x79\x6c\x6e\xe5\x7d\x2b\xb6\xbc\x70\xe2\x85\xef\x6d\xf8\xbf\x8d\xf8\x6e\x23\xd6\xdb\xf1\x6b\x3b\x58\xb6\x53\xbf\x03\x5f\x77\x30\x9f\x76\x10\xa7\x9d\xe8\xdf\x09\xb7\xec\xcb\xda\x4e\xda\x76\x82\xe1\x05\x70\xbd\x00\xd6\x17\xb0\xf3\x02\x36\x5f\x00\xeb\x2e\xb8\xdb\x45\xdd\x2e\xb8\xdc\xc5\xd8\x5d\xd8\xdc\x45\x7f\xf6\x6e\x6d\x37\xf6\x76\x93\x3b\xbb\xd1\xbf\x9b\x18\xec\x06\x53\x19\xf3\xb0\x8c\xfe\x65\xd4\x95\x51\x57\x46\xdc\xca\xd0\xbd\x07\xdd\x7b\xe8\xbb\x07\xde\xf6\x10\xb3\xbd\xe0\xde\x0b\xa7\x7b\xf1\x67\x2f\xbe\xbd\x88\xee\x17\xd1\xfd\x22\xba\xf7\xa1\x63\x1f\xcf\xfb\x18\xbb\x0f\xfe\x5e\x22\x2e\x2f\x81\xfd\x25\xf2\xe0\x25\x38\x7f\x89\xdc\xd8\x4f\x9f\xfd\xcc\xfd\xfd\xb4\x1f\xa0\xfd\x00\xed\x07\x68\x3f\x40\xfb\x01\x7c\x3a\x00\xf6\x03\xe4\xd5\x41\xfc\x38\x48\xff\x83\xf4\x7b\x99\x7e\x2f\xd3\xef\x65\x7c\x79\x99\xfa\x97\x99\x07\x2f\xb3\x06\x1d\x82\xf7\x43\xe8\x3a\x44\x0c\x0e\x81\xef\x10\x5c\x1e\x02\xd7\x21\xd5\x46\xdc\x0e\xc3\xe1\x61\x38\x3d\x8c\x4f\x87\x89\xfd\x11\xe6\xd1\x11\x9e\x8f\xd0\xef\x15\x74\xbe\xc2\xd8\x57\xe0\xfb\x15\xf0\xbe\x82\x2f\xaf\x32\x87\x5f\xc5\xd7\x57\xc1\xf2\x2a\x7d\x5e\x85\x97\x57\xc1\xf2\x1a\x7c\xbd\x46\xfd\x6b\x8c\x7d\x0d\x6e\x5e\x03\xe3\x6b\xd4\xbf\x4e\xff\xd7\xc9\x83\xd7\xe9\xff\x3a\xdc\xbc\x8e\x8d\xa3\xcc\x9d\xa3\xe4\xe5\x51\xe6\xdb\x51\xfa\x1e\xa5\xef\x51\xf2\xea\x0d\x6c\xbf\x41\xfd\x1b\xd4\xbf\x81\xcd\x37\xf0\xe1\x0d\xfa\xbf\x89\x0f\x6f\x82\xe3\x4d\x78\x7d\x93\xf5\xe5\x4d\xf4\xbc\x49\xfd\x31\x72\xee\x18\x3c\x1f\x23\xaf\x8e\xc3\xd9\x71\xd6\x8e\xe3\xf8\x7f\x1c\xbe\x8f\xc3\xcb\x71\xfa\xbc\x45\x6c\xde\xc2\xbf\xb7\xc0\xf5\x16\xdc\xbd\x45\x0c\xde\xc2\xef\xb7\xf1\xfb\x6d\xf2\xe4\x6d\x38\x79\x9b\x78\xbc\x4d\x3e\x9d\xc0\xce\x09\xfa\x9e\xc0\xfe\x09\x70\x9d\x20\x97\x4e\xe0\xf3\x3b\xe0\x7d\x87\xfa\x77\xe0\xf0\x1d\xec\xbd\x83\xcf\xef\xa0\xe3\x5f\xe4\xe6\xbf\xc0\xf4\x2f\xec\xbf\x4b\xff\x77\xe1\xe8\x5d\xf2\xe1\x3d\xfc\x78\x0f\x2e\xde\x43\xf7\x7b\xe0\x78\x0f\xae\xdf\xa7\xee\x7d\xec\xbd\x0f\xb6\xf7\x99\xe7\xef\xd3\xef\x03\x38\xfb\x00\x5b\x1f\xb0\xc6\x7d\x00\xae\x0f\xf1\xe1\x43\xf2\xeb\x43\xe6\xd9\x87\x60\xfd\x10\xbd\x1f\x91\xa3\x1f\xc1\xc9\x47\xf0\xf7\x11\x75\x1f\xc1\xd5\x47\xe4\xe7\xc7\xc4\xfa\x63\x7c\xfd\x18\x3e\x3e\x86\xa7\x8f\xc1\xf9\x09\xfa\x3e\x81\x93\x4f\x88\xff\x27\xc4\xf8\x13\x38\xfd\x14\x3f\x3f\x25\xe7\x3f\x05\xdf\xa7\x8c\xfd\x94\xb1\x27\xe9\x77\x12\x7c\x27\xe1\xe4\x24\xf5\x27\xa9\x3f\x49\xfd\x67\xf8\xf3\x19\x7d\x3f\x63\x2d\xf9\x8c\xba\xcf\xf0\xf1\x73\x38\xfd\x1c\xbf\x3f\xa7\xdf\xe7\x60\xfc\x02\x3c\x5f\x80\xf1\x0b\xea\xbe\xa0\xdf\x17\x70\xf4\x05\x71\x3e\x85\x9d\x53\xd8\x3e\x05\x9e\x53\xc4\xe7\x14\xd8\x4f\x31\xfe\x4b\xea\xbf\xa4\xfe\x4b\xea\xbf\xc4\xef\x2f\xa9\x3f\x8d\x9f\xa7\xa9\x3f\x4d\xfd\x69\xfc\x3a\x0d\xff\xa7\xb1\x77\x1a\xbc\x67\xd0\x7f\x06\xfd\x67\xe0\xe5\x0c\x39\x70\x86\xb6\x33\xe4\x37\x67\x4a\xed\x2b\xea\xbf\xc2\xee\x57\xd8\xe5\x7c\xa9\x7d\x05\xe6\xaf\xc1\xfc\x35\x98\xbf\xa6\xee\x6b\x74\x7c\x8d\xcd\xb3\xc4\xeb\x2c\xf5\x67\xc9\xbb\xb3\xc4\xe7\x2c\x6b\xc1\x59\xe2\x76\x96\x7c\x3d\x0b\x2f\x67\xe1\xaa\x9c\xbc\x2c\x67\x4e\x95\x83\xab\x1c\xfe\xca\xa9\xfb\x06\x5c\xdf\xc0\xcd\x37\xd8\xf9\x86\xb6\x6f\xc0\xf0\x0d\xf1\xfa\x86\x18\x7e\x43\x2e\x7d\x8b\xde\x6f\xe1\xed\x5b\xe2\xca\xf9\x55\xfb\x96\xb8\x7e\x47\x5c\x39\xc7\x6a\xdf\x51\xff\x1d\x38\xbe\xc3\x9f\xef\xc0\xfd\x1d\xb8\xbf\x23\x1f\xbe\x03\xfb\xf7\x60\xff\x1e\x9d\xdf\x13\xd7\xef\x89\xe1\xf7\x70\x70\x8e\xba\x73\xe4\xd4\x39\x62\x70\x8e\x78\x9d\xa3\xfe\x1c\x38\xce\xc1\xf1\x39\x72\xe3\x07\xe6\xde\x0f\xe8\xfe\x01\xdd\x3f\xa0\xf7\x07\x74\xfe\x80\xcf\x3f\xe0\xf3\x79\x7c\x3b\x4f\x1d\x67\x65\xed\x3c\xf5\xe7\xb1\x75\x1e\x5b\xe7\xb1\x75\x1e\x0e\x2f\xe0\xc3\x05\xf0\x5f\xc0\xb7\x0b\xe8\xbc\x80\x6f\x17\xa9\xbb\x08\xdf\x17\xb1\x75\x11\x5b\x17\xa9\xbf\x88\xad\x8b\xd8\xfa\x11\x3b\x3f\x82\xff\x47\xfc\xfa\x11\xbf\x7e\xc4\xaf\x9f\xa8\xfb\x89\x7c\xfd\x09\xff\x7f\x22\xf6\x3f\x51\xff\x13\xfc\xfe\x04\x0f\x3f\x81\xe1\x12\xf3\xea\x12\x39\x78\x89\xdc\xbc\x84\x0f\x97\xd0\x79\x09\x7d\x97\xe0\xff\x67\xf0\xfd\x4c\x6e\x72\x36\xd7\x7e\x26\xe6\x3f\xa3\x8f\x33\xba\xf6\x0b\x7d\x7f\x81\x83\x5f\xc8\xf7\x5f\xd0\xf5\x2b\x3e\xfe\x0a\x2f\xbf\x12\x9f\x5f\xd1\xff\x2b\x38\x7f\x43\xe7\x6f\xc4\xf8\x37\xf4\xfd\x86\x4f\xbf\x61\xef\x77\xfa\xfd\x0e\xfe\xdf\x19\xff\x3b\x7e\xff\x0e\xa6\xdf\x69\xff\x9d\x79\xf8\x3b\x58\xfe\x20\x97\xfe\xc0\xdf\x3f\xc0\xff\x07\x5c\xfc\x01\xbf\x7f\x32\xe6\x4f\xc6\xfc\xc9\x98\x3f\x19\xf3\x27\x63\xfe\x64\xcc\x9f\xe8\xfc\x13\x9d\x97\x69\xbf\x0c\xce\xcb\xe0\xbc\x0c\x4f\x97\xb1\x7f\x99\x35\xe0\x0a\x71\xb9\xc2\x5a\x73\x85\x31\x57\x18\x73\x85\x31\x57\x18\x73\x85\x31\x15\x8c\xa9\x40\x67\x05\x3a\x2b\x68\xaf\x80\xfb\x0a\xda\x2a\xc0\xed\x23\x37\x7c\xc4\xd3\x87\x7f\x3e\x72\xd1\x47\xac\x7c\xcc\x0b\x3f\x6b\x8a\x1f\x7c\x7e\xb8\xf4\x53\xef\x3f\x29\x74\xa1\xfe\x7d\xa2\xe5\x42\x97\x6d\x90\xd1\xc8\x0c\x64\x33\xf2\x91\xd0\x35\x81\x24\x23\x4d\x90\x02\xa4\x04\x99\x23\x74\x9d\x7a\xfd\x4e\xa1\x1b\x0d\x91\x9b\x91\xf9\x48\x19\xf2\x95\xd0\x6d\xf1\x48\x77\xe4\x1e\x04\x3d\xb6\x23\x08\x76\xec\xfd\x90\x63\x42\x77\xcc\x46\x76\x22\xf4\x75\x46\x23\xd8\x75\xde\x86\xac\x46\x68\x0f\x31\x10\xec\x85\x60\x2b\x04\x1b\x21\x8b\x91\x0d\x42\xe7\x9e\xa1\x87\x82\x2d\x14\x7d\xa1\x17\x85\x1e\x06\xae\x30\x0f\xc2\x58\xee\x1a\x7a\x18\xb6\xc2\x68\x0b\xc3\x56\xd8\xcf\x42\x0f\xaf\x81\x14\x22\xd4\x87\xe3\x4b\x04\x38\x23\xf6\x09\x3d\x92\x71\x91\xf5\x10\xda\x22\xf1\x25\x12\xdc\x51\xe8\x8e\x02\x5f\x14\x7a\xa2\xde\x13\x7a\x34\xef\xd1\xd8\x8e\x66\x5c\x0c\x36\x62\x18\x1b\x83\xee\xd8\xf1\x08\xd8\xe3\xc0\x1d\xd7\x09\xc1\xc7\xb8\x83\x42\x8f\xc7\x56\x3c\xcf\x09\xf4\x4f\x0c\x47\xd0\x9d\xc8\xf8\x44\xde\x93\xae\x43\xb0\x91\x84\x6f\xc9\xf8\x96\x8c\xcd\x6a\x94\xd5\xe0\xba\xda\x3a\x04\x1e\xaa\x63\x83\x7b\x8c\x9e\x02\xae\x14\xf8\x48\xe9\x85\x0c\x47\xd0\x91\x02\xb7\x35\xb0\x5f\x93\x71\xb5\xf0\xd5\x05\xf7\x6e\xb7\xd0\x53\xd5\x7f\x3a\x9d\xd8\xa5\x81\xb9\x0e\x98\x33\xc0\xc4\x1d\x43\xcf\xc0\xf7\xba\xbf\x0b\xbd\x1e\xf5\xf5\xc1\xd8\x00\x3e\x32\x5f\x17\x7a\x43\x38\x6b\x44\xbf\xc6\x60\x6a\x42\x7d\x53\xc6\x36\x05\x5b\x36\x58\x73\xd0\xdf\x8c\xf8\x36\x27\x6e\x2d\xd0\xd3\x02\xac\x2d\xb1\x7b\xdd\x37\x42\x6f\x45\x5d\x2b\xec\xb6\xe2\xbd\x15\xe3\x5b\xe3\x6b\x6b\xb0\xb7\x86\xcb\xeb\xf1\xf9\xfa\x53\x42\x6f\x03\xe6\x36\xc4\xaf\x0d\x76\xdb\x82\xb3\x1d\x1c\xb7\x43\x47\x2e\x7e\x7b\x68\xf3\x50\xd7\x1e\x5e\xda\xf3\xdc\x1e\x7d\xed\xd1\xd5\x1e\xdd\x1d\xe8\xd3\xd1\x89\xa0\xbf\x23\x38\x3b\xc1\x45\x1e\x63\xf2\xe9\x97\x0f\xaf\x9d\xc1\xd9\x19\x8e\x3a\xd3\xb7\x80\xe7\x02\x9e\x0b\xc0\xd0\x05\xfe\xba\x80\xb7\x0b\x7a\xba\xa0\xa3\x2b\x98\xbb\x92\x2f\x5d\x89\x75\xd7\x2b\x42\xef\x86\x8d\x6e\x5e\xa1\x77\x47\x77\x77\xb8\xec\x4e\xcc\xb8\x0f\xe8\x3d\xc0\xdb\x03\x3b\x37\x34\x43\xe0\xbb\x27\xed\x3d\xf1\xbd\x27\x3a\x7a\x91\xcb\xbd\xc8\xcd\x5e\xf0\xd7\x1b\xee\x7b\xc3\x59\x1f\xc6\xf6\xc1\xcf\xbe\xf0\xdd\x97\x1c\xec\x87\xef\xfd\xc8\xc1\xfe\x8c\xeb\x8f\xae\xfe\xf8\x7e\x23\xd8\x6f\xe2\xfd\xa6\x47\x84\x5e\x48\x0e\x15\xa2\xa3\x10\x7b\x85\xf8\x52\x44\x1e\x15\x81\xfb\x66\x74\x0d\x03\xf3\x2d\xf0\x72\x0b\xef\xb7\x80\xfb\x16\xf2\x69\x0c\xf1\x1e\xc3\x98\x31\x8c\x19\xc3\x98\x31\xf8\x79\x2b\x63\x6e\x85\xcb\xdb\x98\x03\x63\x89\xe1\x58\x6c\x8c\x63\xcc\x38\xca\xf1\xd8\x9a\x00\x9e\x89\xe8\x2b\x65\xfc\x24\xf4\x4c\x26\x16\x77\x90\x0b\x77\xe0\xfb\x14\xf4\x4f\x81\x87\x29\xf4\xbd\x93\x3e\x77\xc1\xc1\x54\xf4\x4f\x85\xb3\xbb\xc9\xa5\x7b\xf0\xe3\x1e\xfc\x9f\x86\xbe\xe9\x3c\x4f\x67\xcc\x0c\x78\x9c\x41\x4e\xcc\x44\xf7\x4c\xda\x66\xc1\xdd\x2c\xb0\xdf\x87\x9e\xd9\xe4\xc8\x6c\xf2\xe6\x7e\x62\xf1\x00\xba\x1f\xa0\xcf\x83\xe0\x7b\x10\x5d\x0f\x52\x37\x07\x4e\xe7\xc0\xd1\x1c\xe2\x3b\x87\xb1\x0f\x81\xf9\x21\xf8\x79\x88\x3c\x9c\xcb\xd8\xb9\xcc\x97\xb9\xe0\x9d\x47\xbf\x79\xf4\x9b\x07\x47\xf3\x68\x9b\x0f\x5f\xf3\xa9\x5f\x40\xdd\x82\x49\x08\xbe\x2f\x00\xc3\x02\xfc\x5f\x40\x0e\x2d\xa4\x7d\x21\xf6\x16\xc2\xcf\x42\x72\x74\x21\x18\x17\x92\xa7\x0b\xf1\x75\x21\xe3\x16\xd2\x6f\x11\xed\x8b\xc0\xb3\x08\x1c\x8b\x78\x5f\x0c\xae\xc5\x60\x5e\x4c\x8e\x2c\x81\xeb\x25\xf8\xb1\x04\xfe\x96\xa2\x6b\x29\xf1\x5c\x0a\x17\xcb\x98\x67\xcb\xc0\xba\x0c\x9f\x96\x13\xef\xe5\x3c\x2f\xe7\xf9\x61\xf2\xed\x61\x70\x3c\x4c\x9f\x15\x8c\x5d\x81\xbd\x15\x8c\x5d\x41\x5e\xac\xa4\xdf\x4a\xf8\x5a\x89\xad\x95\xd4\xad\xc4\xfe\x23\xbc\x3f\x02\xf7\x8f\xc0\xeb\xa3\xf8\xf9\x28\x7c\x3c\x0a\x8e\xc7\xc8\x8f\xc7\xc0\xf0\x18\xb9\xb5\x0a\xbb\xab\x88\xeb\x6a\xc6\x3f\x0e\x2f\x8f\x33\x6e\x0d\x7c\xac\xc1\xff\xb5\xf4\x5d\x0b\xe6\x75\x60\x5c\x47\xdf\x27\xe0\xe7\x09\xf2\xe9\x49\xe2\xf8\x24\x7d\x9e\x24\xb6\x4f\x81\xf9\x29\xf0\xac\x47\xcf\x7a\x74\xae\x87\xa3\xa7\xe9\xff\x34\xfc\x3c\x03\x17\xcf\xd0\xe7\x59\x74\x3f\x4b\x9f\x67\xcf\x09\x7d\x03\x5c\x6d\x60\xcc\x06\xfc\xdf\x80\xee\x8d\xd8\xdc\x08\xae\x8d\xd8\xda\xc8\x9c\xd8\x04\x8f\x9b\xf0\x71\x13\xfd\x37\xa1\xe3\x39\xb8\x78\x0e\xff\x9f\x03\xcf\x66\xec\x6f\xc6\xe7\xcd\xe0\xdd\x4c\xff\x2d\xd8\xdc\x42\x6c\xb6\x10\xaf\x2d\xa7\xfe\xbb\x3c\xcf\xfc\x7b\x9e\x79\xbb\x15\x1d\x5b\xd1\xed\x05\x87\x97\xf9\xb2\x8d\xdc\xdb\x8e\xdd\xed\x60\xdf\x01\x96\x9d\xe0\xdd\x09\x6f\x2f\x10\xc7\x5d\x3c\xef\x02\xcb\x6e\xe6\xe2\x6e\x62\x5f\xc6\x3a\xbf\x07\x1c\x7b\xc0\xb4\x17\x4e\xf7\x52\xf7\x22\x18\x5e\x24\x8f\xf7\xd1\xff\x25\xb8\x7d\x09\xfe\xf7\xd3\x67\x3f\xba\x0f\xc0\xc1\x01\xf0\x1d\xa0\xdf\x41\x74\x1d\x24\xef\x0e\x12\xaf\x97\xf1\xeb\x65\x38\x7d\x19\x9f\x0f\xc1\xc1\x21\xfa\x72\xb7\xd0\x0f\x83\xe3\x30\xfe\x1f\xc6\xbf\xc3\x60\x3c\x42\xfe\x1f\xa1\xfd\x08\xbc\xbf\x82\xae\x57\xd0\xf3\x6a\x89\xfa\xff\x8b\x10\x9a\xfa\xff\x34\xd0\x67\x6a\xe7\xd9\x19\x1d\xa2\x96\x27\xdc\x2e\x1c\x3a\xbb\x53\x88\x4d\xda\x85\xc8\x3a\x9e\x75\x3c\x26\x56\xb6\x6a\x15\x93\x13\x93\xd3\xb4\x49\x4e\x4c\x6a\x8c\x9e\x1a\x93\x3a\x5d\xd7\x66\xfa\x18\xaa\x9d\xaf\x88\xd5\x6e\x67\x07\x66\x7f\x56\x7f\x0b\x4d\x3b\x6a\xeb\x64\xea\x69\xe0\x89\xd3\x1d\x0e\xcd\x30\x9c\x21\x52\x52\xd8\x1e\x1f\x68\xd0\x21\x37\x2b\x33\x26\x56\xb4\x4a\xce\x52\x3a\x63\x72\x4c\x9d\x32\x4d\xcf\xd1\x9b\xe7\x24\x68\xdb\x96\x27\x1f\x79\xf5\x90\x5c\xa0\xef\xfe\x73\xdf\xd1\xa3\xea\x6f\x7e\x69\x32\x41\xef\xa1\xef\xb2\x1d\x33\x75\xa6\x7a\x22\x1d\x76\x4d\xb7\x2b\x6c\xea\xdf\x03\x14\x22\x37\x27\x27\x2b\xbb\x0a\x3c\xa5\xca\x54\x37\x7f\x61\xbd\x53\xbe\x84\x05\xf5\x4f\xe9\x3d\xb4\xe9\x15\x33\x35\x5c\xd4\x44\x0b\x21\x8c\x79\xb6\x3c\x91\x22\x5c\x62\x9b\x67\x8c\xb3\x66\x8d\x04\x23\x3e\x24\x26\x3c\x3c\x24\x36\x2a\x32\xcc\x08\x8d\x8b\x8b\x4f\x74\xd5\x72\x18\xf6\x24\x43\x8a\x6a\x46\xb2\xcd\x66\x8f\xb7\x87\xa6\xea\xd5\x93\xf4\xe4\xd0\x64\x77\xaa\xd3\x08\x8f\x08\xdf\x5a\x54\x53\x46\xd4\x10\xd1\x31\xd1\x5b\x8b\xaa\x25\xc4\x4c\x8f\x58\x14\xb1\x36\x42\xef\x19\x51\x1c\xa1\xf5\x8c\x91\x3d\x63\x8a\x63\x2e\xc4\xb0\x8d\xba\x6a\x17\x44\xc4\x44\xc4\xd8\x92\xe2\xf4\x50\x9b\xc8\xca\xc9\xcd\x89\x6d\xd5\x2a\x2b\x2b\x73\xd0\x84\x41\x13\xf0\x3b\x33\x46\x28\xe7\xad\xd2\x74\x20\x89\xd2\xf4\x23\x36\xa9\x95\x29\xe6\x53\x76\x76\xa0\xc4\x37\x3d\x35\x21\x55\x4f\x8b\x53\x92\xd6\x3c\x07\x49\x8d\xcb\xd1\x95\xe4\x50\x9f\x1a\xa7\x3f\xd9\x51\x1a\xbe\xaf\x0b\xc7\xde\xe8\x7b\xb8\xdf\xd8\x7e\x47\xbf\xec\xf8\xa3\x74\x14\x8d\x2d\x94\xb7\x16\x8e\x2d\x7c\xb7\xc2\x93\x27\xc7\x74\xd4\xdb\xfb\x0e\xdf\xe6\x1b\x2d\x1f\x51\x72\x9b\x6c\x7b\x5b\xe0\xc9\x37\xfa\x36\xdf\x61\xd9\x56\xfd\x1b\x91\x1d\xfc\xa5\xc6\x34\x4e\x31\x75\x44\x43\xd1\x4c\x6c\xf0\x8c\x4c\x76\x67\xeb\x46\x78\x42\x7d\x42\x68\x6b\x14\x1b\xe2\x74\xa6\xc7\xd6\x48\x69\x94\x22\x62\x45\xf3\x16\xae\x06\x09\x0d\x4a\x8b\x9a\x46\xd4\x8f\x28\x2d\x72\xd7\xaf\x9f\x60\xaf\x51\x23\x39\x21\xd1\xe3\xae\x5b\x90\xe8\x89\x4d\x2a\x48\x4c\x4c\xb0\x67\x87\xdb\xc3\x4b\x8b\x44\x48\x74\x88\x27\xa4\x57\x48\x49\x88\x4d\x15\xeb\x42\xbc\x21\x17\x43\x6c\x21\x21\xf6\xc5\x36\x69\xb3\xe9\xf6\x64\x33\x92\x83\x62\x90\x09\x8a\x92\xe4\xdc\x9c\xac\xcc\x4c\xf8\x21\x4f\x5a\x65\x99\x2c\x29\xb1\x22\x9d\xa3\x82\xad\x7e\xc4\x9a\xac\x25\xa9\xc0\xc7\xdb\x1d\x09\x69\xcd\xeb\xe8\x2d\x6b\xc9\xa4\x98\xba\x8d\xb5\xe6\xcd\x5a\xb4\x24\xa7\x78\x73\x34\x96\x75\x63\x6a\xe9\x32\x5e\xb5\x44\x4a\xd9\x4c\xbd\xb7\x93\xc6\xb4\x8b\xa7\x66\xf8\x06\xe4\x6f\xaa\xbe\x6e\x4e\xad\x0d\x8f\x77\xf9\xf4\x9d\x19\x7b\xdf\x68\xf4\x7c\xe2\x8c\xdb\x37\x3f\x76\x73\xe3\x2b\xde\xac\x01\x53\xa6\xcd\xd2\xd6\xb7\x1c\xfe\xd0\xe2\xe5\xf2\x9e\x27\x5f\x0a\x79\xe2\x89\x48\x59\x94\x3e\xed\x5e\x87\xfc\xd6\x59\x7f\xc8\x9c\xc1\x0f\x3f\xeb\x98\x35\xcb\xb1\x64\x63\xea\x98\xdb\x1c\xbe\x1b\x1b\x14\xdc\x7c\x97\xd6\xb8\x55\x8f\x1c\x97\x7c\xdc\x36\xa2\xa2\x41\x87\x1b\x5b\xa5\xf9\xea\x87\x4c\x16\xea\xff\x8d\xc4\xff\xb3\xf1\x96\xad\x37\xec\x46\x8a\xea\x22\x5d\x34\x15\x03\x3d\x2d\x84\x8c\xb2\x37\x4c\xd3\x74\x3d\xcd\x2e\x8d\xf0\x8c\x9a\x35\x13\xc2\xc3\x73\xb2\x53\xea\xef\x2a\x72\xa7\xec\x1e\xe8\xce\xa2\xac\x16\x92\xbc\xab\xc8\x08\xd9\x3d\xd0\x88\xa5\x74\x68\x76\x01\x4f\xb9\xb9\xea\x2f\xfb\x26\xab\x9f\x81\x39\x44\x82\x04\xb2\x25\xc7\x9a\xa2\x69\x32\x27\xdd\x1d\x13\x6f\x4f\xab\x9d\x01\x0b\xb2\x59\x46\x5a\x6d\x7b\x42\x7c\x62\x4e\x76\x0b\xdb\xdf\x57\x7f\xb6\x44\x5f\xbf\xec\xca\x3a\x99\xb2\x74\xc1\x82\xa5\xf3\xa5\x2b\xb7\x6b\x8f\x0e\x1d\xba\x77\xee\xa8\x39\xff\xad\xca\xd6\xc5\xe9\xf3\x3e\xfb\xfc\xe6\x8d\xcf\x6e\xf4\x79\xa7\xdc\x3e\x66\xea\xa4\xf1\xe3\x2e\xfd\x5b\x0d\x9e\x66\xfa\xcf\x19\x4f\xd8\x7a\x98\xde\x5e\x2f\xc6\x78\x3a\xb6\x70\x36\x8c\xc8\x88\xab\x93\x52\xa3\x46\x5c\x2d\xbd\x5a\x76\x52\xe3\x66\xa1\x11\xce\xf0\x36\x6d\xf3\xb2\x65\x48\xb6\x0c\x13\xd5\xa2\xab\xb9\xab\xe9\x51\x7a\xe3\xd0\xa4\x66\x29\xd5\x6a\x65\xeb\x21\xb6\xe8\xe8\xfa\xbd\x8b\xa2\xf5\xd4\x56\xb6\x56\xbd\x8b\x84\x2d\x91\x24\x09\x24\x87\x5a\x43\x92\x5a\x15\x0f\x1e\x34\x78\xd0\x20\x48\x48\x0a\xe6\x84\x72\xdf\x56\x3b\xa3\xae\xe9\x63\x74\x7a\x63\x89\xa3\x39\xd9\x89\x09\xf1\x91\xd2\x91\x98\xd4\xa2\x65\x92\xdd\x51\x4b\xe6\x64\xb7\x4c\xb0\x07\xdd\x4f\x6a\xa7\xe9\xf4\x0f\xf0\x60\x34\xe9\xb2\x20\xfb\xd1\x43\xaf\x7d\x2a\xeb\xb8\x33\xf7\x3c\xb3\x74\x6b\xcf\x87\x77\xcc\x5e\x52\x98\xbe\xa4\xe1\x1d\x99\x43\xea\xb5\x4e\x6f\xe2\x5b\x55\xd2\xbd\x68\x5c\xdb\x27\x86\x36\xeb\xba\x73\xce\x8e\xb9\x77\x7a\xee\x0d\xcf\xbf\xfe\xa1\xd7\xb7\xcb\xf0\x95\x6d\x1e\xcd\x9b\xf3\xe4\xe2\xbb\xbb\x4d\x1e\xd1\xad\x7c\xcd\xae\x53\x99\xe7\x4e\xb7\xc8\x89\x7e\x30\xd1\xe8\x92\xdf\x7b\x68\x9f\xb1\x13\x3b\xe5\x76\xbb\xf2\xe6\x9b\xe7\x87\xbc\x56\x3a\xa7\x25\xeb\x9a\x94\xbf\xb2\x30\x7d\x60\xae\x6b\x49\x9e\x10\x5d\xd3\x0c\x9b\x5a\xa1\xf0\xd0\x5a\x19\x03\x6b\x99\xb6\xd9\x5a\xc2\xcc\x31\x37\xfa\x6e\xd2\xef\x66\x4c\x84\xa8\xed\x89\x0a\x0d\x0b\x33\xb8\x9a\x38\x1c\x91\x51\xa1\xc2\x48\x21\x31\xae\x2e\xa9\x81\xa5\x30\x3a\x36\x29\x2d\x43\x8b\x89\x8e\x6d\x99\x63\xd7\xb4\x98\x4d\x07\xf7\x1f\x7c\x76\xfd\xe1\xfd\x07\x37\x69\xb1\xbe\x1f\x7c\x9d\xce\x9d\x93\x2f\xca\x44\x19\x23\x77\x5f\x3c\xe7\xeb\x68\xea\xef\x85\xfe\xc9\x41\xfd\x61\xa1\xa1\xba\x61\x38\x84\x50\xfa\xf5\xbf\xd3\xaf\x39\xd2\x5a\xc4\xc6\x44\x6b\x75\x73\x12\x63\xf5\xc9\x4f\x1f\x3c\x78\x64\xc3\x86\x23\x07\x0f\x3f\xa9\xc5\xfb\xbe\xf1\x75\x3e\xf7\xa3\x7c\x49\x46\xc8\x70\xf9\xd2\x8f\x17\x7d\xea\xef\x3f\x4b\xf1\xbb\x76\x45\x7f\xcf\xf6\x26\xb3\x60\x98\xa7\x49\x64\x44\x44\xa8\x16\xaa\x45\x45\x6b\xa1\xa1\x84\x3f\x9c\xab\x90\x73\x72\xf8\xfd\xe1\x9a\xd3\x1e\x12\x6e\x38\xa6\x87\x2d\x0a\xd3\xc2\xc2\x22\x6c\xe3\x1d\x33\x1c\x8b\x1d\xba\xa3\xcc\x7f\x70\x57\x48\x78\x81\xc3\x11\x61\xb2\x94\x39\x88\x05\x35\x6b\x10\x99\x3f\x28\x98\xfa\xe6\x8a\xa0\x16\x88\xd8\x00\x7f\xe9\x49\xb6\x24\x47\x98\xac\xdb\x32\xbd\xa5\x0d\x2a\xd7\x4a\x67\x23\xdf\xd9\x3d\x53\x56\xac\x9e\xf2\x92\xef\x9b\x46\x32\x2c\x7c\x8e\xb1\x7e\xd4\xec\x2e\x7f\x16\x48\xcd\x2f\x0a\x7e\xef\xf2\xc0\xad\xb2\xbe\x89\x73\x92\xd8\x69\xdc\x64\xac\x11\x61\x22\xde\x13\xa2\x85\x47\xd8\x8c\x2d\x45\xb6\x1d\x22\xd7\x9c\x70\x28\x8e\x49\x8b\x49\x6d\x9e\x8a\xb5\xd4\x04\x6d\xeb\x32\x5f\xa1\xdc\xb0\x4c\x6e\xd0\x4a\x7c\xfd\xe4\xe6\xa5\x72\xb3\xaf\xdf\x52\xb8\xd4\x7d\x0f\x6b\x2f\xc8\x4c\xe2\xeb\xf6\x44\xeb\x42\xb2\x55\x1a\x36\x29\x56\x0f\x34\xe4\xaa\x81\x22\x30\x77\x83\x9b\x56\x5c\x2a\xfd\x37\xca\x10\xdf\x51\x06\xad\xa8\x18\xa3\x62\x71\x83\x3c\xa1\x4f\xd3\x38\x1d\x89\x6a\x1e\xce\x00\x6a\xec\xde\xa2\x2c\x29\xa5\xc8\x1a\x14\x18\xcc\xc0\xe6\xa9\x09\xf2\x06\xad\x89\x3c\xb1\x6e\x9d\x1a\xa3\xfe\x9b\xa5\x9f\x9a\x36\x93\x3c\xa1\x6c\xc6\xe4\x94\x32\x26\xb2\x32\x83\x39\xa5\x40\xcb\x8b\xdf\xcb\x4c\xdf\xfb\xf8\x39\x91\x39\x5a\x64\xe6\x60\x0d\x4f\xb8\x64\x77\xd6\x18\xa2\x57\x93\xc2\x0a\xb6\x85\x2f\x49\xe6\xc8\x89\x7a\xf3\xed\x57\xde\x8e\xb7\x9d\xe2\x62\xaf\xfe\x52\xb7\xb8\x87\xb1\x3d\x6d\x03\xe0\x28\x89\xfd\xb4\x9f\xa7\x71\xf5\x6a\xe1\xb1\xb1\xf6\x70\x61\x17\x35\x6a\x46\x25\xcb\xa8\x64\x57\xb2\x16\x91\xec\x89\xaa\xe6\xaa\xa6\x25\xe8\xd5\xaa\xe9\x21\x21\x51\xa5\x45\x21\x0e\x3d\xa1\xb4\x48\xaf\x06\x99\x22\x30\x8f\x39\x0b\x30\x91\xab\x1f\x1f\xcc\xbe\x18\xb4\xa9\x36\x42\x33\xc3\xd2\x6a\xab\x04\x4e\xcd\x8e\xd5\x83\xcf\x39\xd9\xb1\xe9\xac\xeb\x46\xcf\x3f\x2e\x5d\xfa\xf9\xbc\xf0\xff\xf1\xc3\xee\x05\x4f\x3e\xb3\x64\xd9\xba\xb5\xcb\x7d\x85\xdf\x6b\x4f\xf9\x9e\xf7\xad\x92\xc3\x64\x3f\x39\x48\x0e\xf0\x3d\xe5\x7b\x46\xd6\x96\xba\x5f\xf8\x3e\xf5\x9d\xf1\xfd\x21\x23\xd7\xfc\xf1\x07\x7e\x2f\x87\x9a\x31\x9c\x03\x22\xc5\x75\x9e\x9a\x11\xe1\x76\x19\x2a\xc3\x99\x82\x51\xd1\x0e\x7b\x69\x91\xc3\xa1\x87\xda\xc3\xa5\x90\xec\x5a\xc9\x2a\xe6\xe6\x6e\x94\x63\x71\x98\x14\x5c\x64\x89\xbf\xdd\x48\x6b\x9e\x5d\xa7\xa5\x4a\x83\xc7\xe5\xee\x74\xdf\xf7\x0f\x2c\x97\x8e\x66\xcf\xc8\x21\x4b\xf4\x8a\x1b\x26\x2d\x9f\x35\xec\x72\xf7\x25\x66\x3e\x2d\xc6\x5e\x1b\xb8\xaa\x21\xda\x78\x6a\x56\x17\x22\x22\xb2\x86\x23\x3e\x32\xbe\x66\xad\x88\x88\x98\x98\xd0\xd2\xa2\x18\x87\xac\x2e\xaa\x57\xb5\x67\xfe\xcc\xaa\xdc\xee\x2c\x9b\xed\x64\xcb\x76\xac\x69\x6a\xe9\x72\xd4\x6d\x27\xcd\xa5\xcd\xee\x60\x71\x4b\x4d\x58\xdc\xf4\xed\xed\x6b\xe7\xcf\x9d\x31\x71\x41\x44\x59\xfc\xf9\x43\xef\x9f\x7f\x64\xe5\x5b\x6b\x53\xb5\x77\x27\xdf\xfe\xd9\xc2\xe9\xfb\x6e\x1a\x77\xe7\xbd\x13\x62\x36\xbd\x76\xd0\x5b\xfa\xf5\x9d\xeb\x57\x75\x59\x6a\xe2\x9a\x41\x0c\xbb\x81\xab\x81\xb8\xc3\xd3\xbe\x6e\x1d\xc2\xd7\xb0\x66\xad\x5a\x0e\x7b\x52\x9d\x3a\x2a\x8e\x99\x0d\xeb\xc6\xc6\xc4\xc6\x94\x16\x45\xb1\xc4\xea\xb1\xb1\x7a\x6a\xcd\x9a\xa9\xa9\xe0\x4c\x75\xe8\x21\xa5\x45\x1e\xa6\xa5\xa6\x7e\x5c\x64\x76\x3a\x54\x48\xcd\xdd\x5b\x54\xa2\x6f\xa5\x22\x6b\xc6\xf8\x6f\x36\xee\xd8\x56\xe6\xae\x9d\x56\xbb\x4e\xdd\x96\x89\xa9\xd9\x2d\x9a\xb3\x2f\x67\xca\xe6\x39\xd9\x7f\xe3\x21\xdb\xb8\xd1\xed\xca\xe9\x0f\xfc\x22\x69\x6f\x1d\x19\x35\x67\xd5\xc0\xd5\x43\x46\x0e\xbd\x71\x51\x9f\xfb\xef\x9b\xb2\x2c\xfc\x85\xf8\xdf\x0e\xbd\xf7\xfd\x9a\x87\x56\xee\x96\x13\xf7\x1e\x3b\xb4\x2f\xe6\xcf\x69\x77\x75\x1b\xd5\x72\x75\xab\xd1\x9d\xc7\x4c\x99\x3a\x2e\x72\xcb\xa1\x17\x9f\x9d\xe2\xad\x61\xc4\x6c\x27\xc1\x47\x11\x8b\x11\xc4\x3e\x94\x55\x2e\xdf\x53\x37\xdc\x16\x61\xd7\x9c\x21\x9a\x2e\x6d\x32\x32\x4a\x18\xe1\x46\x69\x91\xd3\x16\x15\xee\x0a\xcf\x0a\x1f\x17\x6e\x84\x87\xcb\x30\xbb\x5d\xaa\x6d\xd7\x5c\x6e\x72\xaa\x1c\x43\x92\xae\xae\x84\xe6\x7a\x20\x79\x4e\x08\x91\xa9\xfa\xc6\x9d\x15\x13\xb5\xbb\x5f\xdb\xe7\x5b\xec\x0b\x97\x3f\xcb\x5c\xdf\xcb\x32\x77\xbe\x3e\xf5\xca\x9c\x85\x7a\xc7\x8a\x6e\x95\xbc\xe7\x89\x9a\xa2\xd0\xd3\xa8\x5a\x72\x5c\x5c\x42\x7c\xbc\xd3\x11\x91\xa8\x8e\xdf\xae\xf8\x6a\xa5\x45\xf1\xf1\x29\x29\xd1\xa5\x45\x29\x29\x46\x42\x42\x72\x69\x51\x82\xdd\x20\x4b\x9c\x4e\xc3\xe4\xb8\xca\xc4\x09\x10\x9d\xf9\x97\x3c\x51\xff\x28\x66\x23\x25\x9b\x20\xd4\xe6\x28\x6a\x4d\x3e\x39\x3a\x72\x50\x54\x1b\xa2\xd1\xed\x8e\x33\xab\x5e\xf9\xc9\xbd\xab\xd5\xb9\x05\x1b\x9e\x99\xd7\x65\x5a\xae\x37\x4b\x4f\xad\xb8\xbf\xe6\xe4\xe7\x8f\x5d\x96\xfb\xe6\xfd\xab\x74\xf3\x53\x09\xef\x6c\x58\x72\xcf\x9a\xc6\x2d\xb5\x8f\x96\xf8\x6e\x1a\xf0\xbd\xda\x9d\x56\x82\xbb\x80\x7c\x49\x14\x69\x9c\x60\xb2\x63\x6a\xd5\xb2\x87\x87\x85\x25\x91\x2a\x75\xd2\xe3\xc9\x8b\xe2\x78\x29\xe2\xa3\xe3\xb5\x50\x3d\x3e\x9e\xe9\x1e\x49\xe6\x84\xcb\x18\x9d\xf3\xb5\x43\x4f\xad\x9c\xf5\x39\x57\xd3\xc2\x9c\xfa\x83\x32\xab\x66\x47\x4c\x8e\x95\x16\x4c\x76\x91\xe3\x8e\x73\x00\x5d\x4b\x30\x33\xc1\xa1\xdc\x88\x94\xd6\x5e\x5d\x70\xe9\xbd\x73\x3e\xe9\xbc\x28\x73\xfb\x6e\x6e\xbe\xe3\xd1\x4d\x4d\xb7\x97\x1e\xfc\x66\xf7\xa3\xf7\x75\x9d\xdd\xed\x89\x69\xd3\x57\xca\xfd\xef\xf9\x64\x91\x6c\x2b\x6f\x96\xf7\xf8\xbe\x74\x6d\xf6\x7d\x77\x79\x60\xf1\x0f\x6f\x2d\x5e\xd7\x71\x4a\xb7\x47\x8e\x6d\x30\xf3\x7f\x0d\xb9\xd0\x88\x38\x84\x88\x86\x9e\x04\x4e\x62\x8e\x30\xf5\xdf\x02\x09\x0d\x13\x0e\xa7\x03\xbe\xed\x9a\x8a\x7b\x95\x73\x67\x70\x63\x11\x31\x69\xd1\xb1\x71\x6c\x01\x46\x23\x5f\xdd\x7d\xbf\xfc\x54\xe1\xd2\x17\x19\x7b\x2b\x0a\x2b\xce\x4b\x87\x36\x44\x32\xeb\x75\x71\x3f\x5c\xe5\xc3\x55\x8a\xc8\x10\xd9\x9c\x7f\x5a\x25\x27\x34\x0a\xad\x1b\x51\x23\xa1\x76\x44\x44\x23\x7b\x42\x5d\x48\xcb\x69\x26\x62\xa2\x63\xb4\x28\xdd\xa5\x6b\xd1\xb6\xe4\xd0\xd0\xf4\x06\xe9\x1c\xa7\xd3\xd3\xf5\x98\x18\x97\x5a\x15\xf4\x26\xff\xb6\x54\x06\x66\x53\x4e\x71\xe0\xe0\x53\x19\xf5\x6b\xe6\x54\x86\x79\xfc\x55\xe7\x1f\xc5\x5c\x2d\x69\x4d\x22\xfd\xea\xa1\xcf\x1d\x57\xe5\xfc\x67\xe4\xff\x51\x7e\xda\xbf\xe6\xee\xf1\x73\xc6\xbd\x71\xdf\x43\xc7\x6e\x9b\x3b\x7e\xd6\xaa\xcf\x1f\x9c\x7e\xf7\x43\x73\xef\x91\x46\xda\xea\x05\x73\x56\xad\x5c\xba\x6c\xb1\x9c\x5a\xf6\xc1\xbf\xf6\xce\x7c\x21\xc1\x48\x79\x7e\xfc\xd0\x75\x85\x45\x6b\x46\x4c\x78\x3e\xd1\x48\xd8\x26\x7f\x19\x37\x61\xe2\xd8\x71\x53\x7d\x33\xee\x9c\x39\x6f\xe2\x83\x0b\xe6\xaa\x5c\x59\x80\xff\xb9\x56\xae\x14\x7b\xae\x73\xd8\xed\x35\x63\xc3\x93\x92\xb8\x36\xd4\x49\x8f\x72\x97\x16\x85\x47\x45\xb9\xa2\xd6\x46\x6d\x8d\xba\x10\xe5\x8f\xb2\x87\xea\x51\x51\x7a\x42\x02\x39\x94\x60\xae\x2d\x6a\xd3\xd7\xae\x2e\x2a\x7f\xdd\x2a\x72\x2a\xf7\xce\xab\x47\x11\x11\xcc\xf5\xd8\x96\x2a\xef\xd5\xe9\x3f\xc7\x5d\xe9\x2d\x6b\x8a\x91\xeb\xfb\xf5\xe7\xa7\x5f\xcb\xdc\xdc\xa2\xec\xb1\x2d\x5a\xbd\x43\x93\x5e\xfa\xfa\xf2\x27\xf2\xb3\x23\xeb\xa6\xcf\x5a\xb1\x62\x46\xf7\x07\x6f\xd0\x0e\xf8\x9e\xf1\x3d\x38\x6f\x55\x8a\x57\x26\xfd\x3a\xe0\x76\xe1\x3f\xfe\xde\x6f\x3e\xe3\x89\xa3\xcf\xcf\x5b\xb4\x35\xef\x6e\xf3\x2e\x6a\xee\xaf\x46\x6b\xf3\x2e\x5a\xd7\x13\x67\xd7\x6d\x6c\xb2\x21\x4e\x9b\xb1\x6a\xa0\x2d\x2a\xb8\xd5\x06\xb0\x5e\xbd\xdc\xaa\x1d\x57\x0f\xec\xba\xdf\x9b\xfb\xae\x1e\x65\xee\xbe\x4a\x5f\x89\xef\x61\x3d\xd6\xd2\xd7\xc4\x53\x5d\x93\xd2\xee\x30\x6c\x76\xc3\xce\xfd\xd6\x58\x3d\xd0\x69\x5b\x35\x50\x0a\x24\x4a\x04\x4f\xfb\xa6\xd7\x56\x16\x2a\xa5\xea\xe4\x70\xf1\x7b\xdf\xfd\xe6\xe1\x21\xa0\xf9\xf2\x03\x81\x23\x84\x79\x8e\x79\x8c\x73\xcc\x26\x52\xed\x7a\x8f\xdb\x10\xdc\x1f\xec\x0e\xa7\x14\x86\xa1\xd9\x72\xed\xe3\xec\xd3\xed\xba\xdd\x13\x9b\x50\x60\xd7\xa3\x34\xce\x27\xac\x6e\x81\x53\x55\xdb\xac\x9c\x9c\x2a\xdb\x7f\x5c\x73\xc9\xba\x96\x30\x49\x3f\x73\xe5\x19\x7d\x80\x76\xfd\x71\xf9\xe4\x63\xbe\xa5\xbe\x25\x8f\x2a\x1f\xc4\x24\x59\x68\xdc\xa4\x9f\x33\x7d\xb8\xd1\x73\xbd\xc1\x0c\x90\x2c\xa8\x86\x6d\x4b\x51\x94\x31\xce\x58\x64\xac\x35\xb6\x1a\xb6\xea\xba\xe1\x89\x4d\x2c\xe0\x5a\xbd\xa5\xa8\x89\xec\x25\x4b\xe4\x78\x69\xf4\xe2\xc7\x0c\xe9\x95\x27\xa4\x2d\x2a\x70\xb0\x31\xb7\x8f\xac\xcc\xc0\xf2\x50\x05\x00\xc7\x1c\x44\x21\xa8\xa9\x9f\xd1\x0b\x97\x2f\xf7\x89\xe5\xcb\xc5\x35\x3e\xb6\xf2\xb8\x82\x3e\xda\x6d\x9a\xa6\x47\x19\xd2\x90\xb9\x62\x9c\x98\x0e\x38\xe5\xa7\x8a\xce\xa0\x6c\xdc\xbc\xd6\xc3\x96\xcd\x43\x64\x73\xe5\xe1\x00\x3c\x3c\xf3\xd8\xa3\x72\x9c\x1c\xfb\x98\x6f\xf0\x71\xe5\xdf\x60\xd6\x88\xa6\xe4\x71\x4d\x91\x2a\xf2\x3c\xa9\xce\xd4\xd4\x90\x5a\xb5\x44\x52\x72\x0c\x9b\x75\xed\xb4\x90\x90\x94\x5a\xb5\x5c\x8f\x0f\xac\x95\x94\x94\x92\x12\x5f\x5c\x94\x62\x58\x3b\x78\x56\xd5\xef\x1c\x57\xa3\x66\xad\x6e\x6c\xd8\x91\x1c\x9e\xdb\x69\x2d\xdb\x69\xc1\xbd\xae\x45\x9d\x9c\x6c\x43\xaa\x93\x4d\xd3\x86\x7d\x6f\x1e\xdb\xb9\xbe\xdc\xaa\x35\xea\x59\x7c\x6b\xc7\x7a\x6b\xe7\x3c\xb8\x31\xb2\xac\xba\x0c\x7b\xfb\x0b\x29\x2a\x16\x1d\xd6\xbf\xeb\x32\x71\x48\x87\x5e\x5d\x6f\x6c\x99\x3f\x6e\x50\xe7\x1b\xba\xf6\x6f\x79\xfb\xe4\xa5\xd3\xc2\x5f\x79\xff\xe5\xcb\xa3\xd4\x57\x13\x4d\x34\xf4\x7d\x6d\x3c\xcd\xb9\xae\x8d\xe8\x22\x16\x79\xfa\x24\xa7\x24\xb5\x4d\xd1\x6d\x8d\x1a\x77\x8a\x8c\xb4\x35\xd6\x9b\xbb\x45\xdd\xe6\xa2\x79\xd7\x6e\x35\xf3\xc3\xf2\x3f\x28\x72\xe8\x61\xb1\x9e\x0f\x8a\x92\x92\x42\x12\x64\x68\x42\x6c\x54\x98\x2b\xac\x38\x6c\x5c\xd8\xf4\x30\x5b\x98\x88\xe5\x5c\xd4\x28\x2c\x36\x36\xac\x91\xde\xb4\x55\xab\xb4\xf7\x8b\x5a\x89\xa6\x0d\xde\x2f\x6a\x7a\x35\xcd\xb9\x85\xe1\x6a\x96\x79\x13\x8b\xc9\x19\xac\x32\x48\x7d\xd0\xa8\xba\x66\x5e\xbd\x9c\x26\x05\xaf\x0d\x69\xb5\xdb\xca\x96\x69\xe6\xfe\xd4\xbc\x59\xac\xda\x8f\x92\x72\x5a\xe6\xe8\xcc\x54\xe6\x6f\x73\xd5\x6e\xd7\x12\xd4\x49\x8f\x0b\x9b\xd9\x4b\x6b\x1e\x1d\x0b\x3d\x89\xb1\x36\x6b\x07\x88\xa6\x2d\xd6\x78\xfa\xe9\xf9\x8b\x34\x7b\xed\xbb\x6f\x18\x33\x65\xc8\xb3\xa3\x3a\x0f\x4c\xb4\xb9\x27\x0d\xab\xd7\xf4\x86\x61\x9f\xec\x5c\xfe\xd5\x3d\xdf\xbc\x31\xf8\xf9\x11\x9d\x4b\x3f\x9a\xf2\xf4\xe5\x07\x1e\x93\xb5\xf6\xad\xf9\x76\x9a\x6f\x68\xfe\xf5\xb9\x63\xda\x4f\xec\x7a\x47\x2b\xed\x92\xef\x03\xdf\xda\xc7\x9d\xb5\x0a\x6f\x7d\x7d\xcf\x13\xb2\xd6\xd3\x7d\x07\xac\xf4\xd9\xfe\xd5\xa9\x50\x36\xf8\x43\xc6\xca\xfe\x1f\xfa\xa6\xfe\xe1\x7b\xd3\xb7\x30\xbf\xf0\xa6\x61\x03\x0e\xc9\xdb\xcf\xcb\x5a\xf2\xc5\x1f\x5f\xf0\xbd\xb0\x6f\xcc\xed\xf7\x5f\x9a\xed\x2b\xdf\x2f\x5b\x9b\xf9\xcf\x1f\xe3\x18\x7b\x88\x83\xf3\x44\x5f\x4f\x83\x30\x4d\xe7\xec\x68\xb7\xb1\x59\x73\x35\xe3\x02\x15\x15\xe9\x90\x5a\x98\x56\x5c\xc4\x4e\x39\xc0\x29\xbb\x39\x25\xd9\xa9\x1b\xac\x83\xb9\xd9\x1c\x2b\x07\x0d\xb2\x3e\x6f\x04\xbf\x88\x65\x5b\x99\xc2\x09\xd8\x3c\x04\xa7\xea\xa9\x3a\x17\xfa\x10\x19\x25\x79\x32\x42\xe7\x56\x1c\x7f\xe8\x88\xf4\x7d\x2c\x7f\xa9\x58\x1d\x9e\xb7\x52\xbe\xbd\x45\x4e\xf3\xcd\xb2\xe5\xfd\xf9\xa2\xf1\x42\xdd\xf7\x7c\x45\xf2\xe7\xc0\xf9\xfc\x49\x70\xcd\x00\x57\x84\x48\x10\xb5\x44\x2f\x4f\xbd\xb0\x94\x48\x05\x2a\x8e\x43\x45\xa2\x30\x84\xcb\x1d\x16\x57\x3d\xae\x7a\x71\x51\x5c\x9c\x61\xb3\xc5\x16\x17\x01\x2a\xa5\xb8\xc8\x88\xfd\x9b\xed\xa6\x72\xb9\x35\x77\xc0\xc0\x2e\x63\xa4\xa5\xc6\xa4\xaa\xef\x09\x5c\xa9\xb9\x4d\x67\xb2\x1e\xa9\x4d\x85\x92\xc3\x9c\x31\xc3\x77\xfe\x67\x5f\x3d\xb9\x5a\x5e\x5c\x7c\xcf\xb3\xbb\x7d\xe7\x57\xae\xfc\xe2\x4b\xd9\xb0\xf7\x76\xef\x15\x19\xba\xf5\x69\x79\xcf\xce\xd7\x6d\x79\xbe\x3d\x53\xd7\x57\x8b\xdd\x2e\xcf\xdc\x3a\xd0\x57\xe2\x9b\x39\xf1\x4e\x5f\xed\xbb\xcc\x39\x3d\x81\xbd\xe3\x0e\x73\xef\x18\xe1\xc9\x8d\x89\x8e\xb6\x3b\x1c\xc9\x22\x3c\x3c\x29\x59\x44\x46\x47\x6a\x51\x21\xae\x10\x2d\xc2\x16\xc9\x74\x8b\x89\x89\x34\x84\xbd\x89\xdd\x63\xd7\x85\xbd\x97\x7d\x9d\xdd\x6b\x3f\x65\xbf\x68\xb7\x87\xeb\x76\x7b\x48\x88\x5e\x5c\x14\x12\x17\x9c\x8f\xa4\xe8\x04\xf3\xf0\x14\xdc\x3a\xab\xce\x48\x2b\xd9\xb4\x54\x37\x3b\x72\x2a\x87\x8e\xc6\x6a\x13\x91\xad\x9f\xf3\x8e\x58\xdf\x6a\xed\xc3\xbe\xed\xbe\x3f\x7c\x5f\x6b\xc9\xb2\xef\xf4\x0d\xe9\x8f\x8f\x7a\xee\x69\x6d\xa3\xef\x82\xef\xc2\x43\x4b\xda\xfb\xe6\xcb\x31\xb2\xaf\xb6\xcd\xb7\xad\xfd\x84\xfb\x7c\xea\x83\xe8\x93\xd6\xf9\xd2\x29\x62\x44\x3d\x4f\x7c\xa4\x11\x02\xd9\xb1\x71\xb6\x08\x93\xe1\xc8\xbf\x30\x5c\x79\x03\x8c\x16\xf5\xe1\xcd\x2d\xf4\x68\x93\xc8\xec\x58\x63\x84\xef\xb8\xef\xb4\x6f\xa1\x6c\x29\xbb\xc8\x8e\x07\x4f\x5e\xb8\xeb\xc9\xf7\xde\xd2\xbc\xbe\x17\x7c\xab\x20\x6e\xb7\x6f\xa7\x74\xfe\x78\xf9\x92\x0c\x35\xf9\x52\x36\x87\x62\x33\x4c\xdc\xe4\x69\x61\x0b\x09\x11\x7a\x68\xa8\x43\xe8\x5c\x5c\x9d\xc5\x45\x2e\x5b\x96\x4d\x8b\xe2\x47\xae\xad\xd8\x36\xdd\xb6\xd5\xf6\x85\xcd\xe1\xd2\x6d\x5c\x0d\xa5\x51\x5c\x24\x75\x11\x52\x5c\x24\x62\xaf\xbd\x8f\x4d\xc8\xb4\xbe\xab\x5c\xfd\xec\x9b\x90\x6a\xc9\x93\xfa\xca\x8a\x7a\xda\xea\x8a\xe1\x9c\x99\xf3\x56\xfb\x06\x3c\xe6\xcb\x59\x1d\x58\x8b\x0f\x81\xa3\xad\x79\x9e\xea\xee\xc9\x92\x36\x9b\xdd\xa9\xd9\xf5\xd0\x30\x65\x27\x4a\xf6\x94\xc5\x92\x1d\x2a\x97\xc5\x55\x0f\xd7\xa5\x27\xa1\x7e\x81\x94\x36\x87\x43\x14\xb3\x04\xd9\x62\xcd\x93\x56\x20\xe7\x30\x3f\xb1\xd2\xbc\xda\xe9\x94\x61\xce\xd8\x09\x72\xa6\xb6\xbe\xe2\xe6\x03\xfa\xdd\xc6\x46\x5f\xec\x9a\x8a\x33\xd8\x0f\xe6\x8b\xba\x8b\x56\x23\xcf\x23\x93\x52\xa2\x6d\x61\xa1\x09\xa1\xc2\x26\xaa\xa7\x38\xcb\xfc\x17\x3d\xd5\x22\x62\x0a\x92\x93\x8a\x8b\x92\x93\x35\xa7\x93\x38\x84\x85\x39\x0d\x8d\x8c\xd7\xe2\x82\xe7\xd1\xa0\x65\xf1\x97\xa3\xa8\xca\xf3\x74\x0e\x53\xe4\x84\x48\x0d\x9c\x44\xed\xa4\x07\x99\xa2\xae\xff\x46\x8f\xaf\xbf\xfd\xd3\x77\x4e\x3a\x65\x88\x1c\x50\xfa\x5c\xaf\x13\x1b\x9f\x90\xfd\x3b\x2d\x6d\xec\xfb\x54\x7e\x71\xff\xa3\xb2\x54\x76\x95\x03\xe5\x8d\xbe\x17\xae\x2b\xbf\xe2\x2b\xaf\xf8\xbc\x81\x5b\xf6\x5a\x67\xc5\xaa\x81\x19\x2b\xf6\x64\x87\xae\xab\xff\xa8\x65\x98\x11\x16\x1e\xe1\x60\x8d\xe8\xe5\x90\xeb\x1c\x5e\x75\xf2\x09\xa9\x5c\x23\x5a\x65\x05\xa2\xd1\xaa\xca\x37\x3e\xe2\x00\x21\xea\x63\x3c\xa7\x8b\x5b\x2b\x7e\x3d\x70\x40\x0b\x3d\xa0\x8d\xab\x58\x62\xcb\xab\x78\x43\x6b\xf1\xe7\x8b\x66\x3c\xde\xc0\x96\x34\x6d\xb5\xf2\xd4\xb0\x13\x6f\x07\xb9\x18\x12\x12\x1e\x61\x38\x1d\x64\x86\x23\x56\x0f\x13\x61\x44\x5f\xaf\x7a\xed\xbc\x7a\x76\xb1\x36\x5f\x2b\xf0\xdc\x77\x53\xdf\xd0\x5b\xfa\x8e\xc8\x36\x57\x8e\xca\x36\xbe\x23\x70\x7f\xf9\xd2\xea\xd5\x46\x44\x20\xf6\x5e\xff\x39\xfd\x13\x6c\x45\x73\x92\x49\x8e\x8c\x75\x98\x5f\x02\x62\x62\xa3\xc8\xf8\x28\x5d\x0f\x2d\x56\xf7\xea\xb8\x2a\xd7\x97\xab\xbb\x62\xf0\xc4\x5a\xb7\xa5\xfa\x34\x57\x4d\x62\x49\xff\xe4\x5f\xfb\x9f\x3b\x96\xf6\x62\xec\xe4\xa2\x77\x7c\x47\xe5\x2f\x72\xfd\x3b\xe5\xdb\x0f\xba\xee\x98\x21\xab\xe9\x21\x56\xae\x29\x1e\xdf\x34\x7d\x2b\xf0\x64\x38\x43\x42\x42\xc9\xe4\x30\xc5\x67\x98\x11\x1e\x21\xdd\x61\x31\x05\x9a\x23\x54\xde\xe1\x78\x00\x36\xa5\xb3\x0a\x9b\x81\xef\x45\x55\x09\x65\x9d\x0d\x90\x2a\x1d\x26\xa9\x6a\xb5\xd5\xbf\xf7\x55\x7b\x0a\x56\xdb\x7c\xe9\x73\x6a\x79\xda\xb4\x8d\xbe\x4c\xa8\x2d\xd6\x9e\xa8\x38\x72\xe5\x37\x65\xff\x07\xec\x77\xc7\xbe\x4d\xb8\x3c\x91\x1c\x03\x6d\x76\x07\x08\xf4\xca\xb9\x64\x19\x50\x73\x47\xcd\x9e\x1f\x0e\x68\xeb\x6c\x79\x97\x6f\x5a\xcd\xd8\x99\x8c\x55\xf7\xbf\x64\xb0\x27\x26\x0a\x91\xec\x74\xc4\x45\x47\x44\x44\x46\xc6\x25\xeb\xd5\xab\x19\x61\x61\x51\x71\xea\x3f\x20\x12\x1e\x19\x53\x10\xe7\x74\x26\x46\xe9\x91\x57\x53\x01\xe0\x81\xcf\x5c\x49\x95\x07\xe0\x40\x42\x34\xcb\xe5\xf4\xa8\xa7\xe9\x19\x75\xe3\x94\x17\x71\x89\x49\xb9\x32\x8e\xec\xd8\xa8\xeb\x1e\xd7\xfa\x87\x9e\x89\xbd\xc1\x58\xf7\xc3\x9e\x84\xac\xea\x0d\xf7\x7c\xa9\x0f\x7f\xb0\xc3\xf0\xb7\xfa\xfb\xba\xca\x5d\x8d\x7f\xf1\xbd\x7b\x65\x35\x6b\x4a\x52\xf3\xed\x03\xe6\xcb\xef\xcc\xd4\xa9\x92\xa7\x11\xa2\x93\x27\xc3\x61\x18\x36\x11\x16\x16\x6e\x0b\x8f\x8c\x0a\x9b\x2f\xe5\x54\x29\x6f\xe1\xc4\x66\xd7\xef\x73\xca\xc9\x4e\x39\x92\x4d\x4d\xa8\x29\xac\xf6\xb3\x41\xb9\xea\x47\xce\xb5\x09\x2b\x13\x13\x14\x2c\x99\xd1\x5c\xa5\x6c\xa7\x8a\xdf\xa3\x37\x7d\xae\x45\xc7\x6e\x36\xc6\x6c\xee\x73\x65\x39\xcc\x2c\x5c\x3c\x4b\x2f\x51\xd6\x35\x31\x92\xf9\x3c\xd2\xfc\xb6\x94\xa0\xd6\xd0\x68\x33\x97\x12\x93\x42\xc8\xa5\x10\x43\x8f\x2b\x2e\xd2\xe3\xfe\x76\x0d\x0d\x4c\xd5\x9c\x6c\x96\x51\x76\x26\xf3\x5b\x91\x31\xd2\xf7\xdb\xef\x7f\xf8\xfe\x94\x46\xc5\x6f\xd2\x79\xd4\xf7\x86\xef\xf5\x35\x8f\x3e\xb5\x9c\x05\x7c\xab\x6f\xb9\x1c\x29\x6f\x92\xbd\x39\x86\x3f\xed\xdb\xa4\x25\x54\x7c\xef\xfb\x89\xf9\x9c\x6c\xfe\xde\xc9\xf4\xbf\xd8\xcc\xaf\x38\xd1\xcc\x53\x3d\x5c\x44\xdb\xed\x0e\xe1\x48\x88\xb7\x45\xb3\x92\xb3\xb4\x39\xa3\x8a\x8b\x9c\xba\xbd\xea\xc2\x55\xc5\x67\xeb\x06\x6e\x2e\x5b\xd9\x86\xa3\x59\x2a\xbe\xb3\x2d\x16\x4f\xf9\x6c\x89\xaf\xfc\x80\x3c\x76\x5e\xea\x07\x7d\x65\xbf\xfa\x1e\x7e\x4e\xdf\x76\xef\x91\xb1\x15\x3e\x5b\xde\xfb\x87\x7c\x15\x3f\x2c\x35\xfd\xf7\xdd\x6b\x4c\x30\xf7\x3f\xb7\xe8\xe8\xa9\xa3\x47\x46\x8a\x94\x18\x67\x92\x10\x91\x31\x7a\x6a\xed\xf8\x6a\xc5\x45\xf1\x46\x64\x2d\x68\x88\x8c\x0b\xb3\x97\x14\x15\x87\xc9\x30\x11\xb8\x25\xe5\x04\x59\xb1\x3e\x89\x5b\x57\x85\x68\x2d\xf8\xdd\x5b\x4d\xb4\x0c\xed\xdf\x59\x7a\x65\x77\xfd\x07\x46\xb4\x6c\x33\xa8\xff\x8a\xc3\xb9\x9f\x9e\xfd\x77\xb6\x3e\xf7\x3d\xd1\x70\xda\xc4\x88\x07\x12\x37\xbe\x91\x28\x87\x49\xcf\xdf\xd0\x16\xe0\xec\x51\xeb\xcc\x51\xec\x69\x2e\x22\x22\x42\x64\x78\xb8\x1e\x19\x12\xcb\xbc\x0c\x31\x92\x12\xc3\xb5\x58\x56\xb9\x9e\xb1\x32\x2a\x36\x37\x76\x5c\xec\x81\xd8\x0b\xb1\xb6\x70\x3d\x36\x56\xd8\x6c\x31\xe6\xfe\x18\xc8\xf3\xbf\x6c\x43\x22\xe7\x2f\x53\xb5\x32\xa1\xd2\x4c\x6e\xcd\xef\x43\x5c\x6c\xeb\x9b\xe7\x0e\xfd\x25\xdf\xd2\xf3\x07\xe4\xe9\x6f\x7f\x7e\xf1\x71\xb9\xf8\x77\xdf\x09\xdf\x45\x99\xbc\xe8\x51\x2d\xb7\xe2\x65\x5b\xde\xcb\x3b\x1f\x3e\x56\xbd\xe2\x39\xfd\xf8\x17\xbe\x06\x33\x54\x8e\xf7\x24\xcf\x46\xc3\x73\x43\xd1\xd5\x53\xcf\x6e\xab\x9d\x58\xb3\x46\xb8\x10\x35\x12\x6d\x46\xa3\xc6\xb5\xc3\xab\xe9\xd5\xdc\x25\x45\x35\x6b\x56\x33\x74\xb6\x48\x0f\xe7\x0b\xcd\x6e\x0f\xac\x61\x83\xaa\x6c\x1b\xad\xaa\x4c\xc6\x40\xdc\x8d\x34\xb7\x6e\x2e\x66\xea\x9b\x96\x56\x97\x13\xb7\xf9\x5b\x08\xf5\x8b\xa8\x34\x77\x42\x7c\x2d\x2d\xa9\x96\x61\x8c\xf6\x5d\xfa\xc3\xd7\xb2\xeb\x9e\x1a\xde\x65\x6b\x9f\x6e\x3f\xe6\xfe\x4e\x4f\x3c\xd4\xa7\xc1\xa5\x33\xef\x9d\x6a\xb8\x2f\x79\xf1\xbd\xbe\xaf\x9b\x0f\xbc\x2b\x6f\xde\xd4\xe2\x4e\x75\xe5\xc4\xb2\xb7\xe4\xc8\xf4\x99\x93\xef\x99\x98\x5f\x78\x5d\x5a\x4c\x83\x0e\xfd\xc7\x76\xdd\xf2\xe2\x72\x6f\xea\xf8\x11\xef\xb7\xe9\xd6\xd4\x1d\x9b\x96\xd5\xa6\x8f\xfa\x77\xaf\x44\x77\xeb\xcc\xe7\x10\x19\x9e\x58\x07\xeb\xbd\xc6\x4d\x4c\x18\x36\x43\x71\x2b\x63\xab\x7c\xcc\xf8\xcb\x97\xab\xd4\x04\xed\x95\xfd\xbe\x3c\xa3\x99\xb1\xf1\xf2\x4d\xc6\xc6\xd5\xe6\x9e\xba\x10\x6e\xd4\x5e\x1e\x23\xd2\x3d\x31\x21\xf6\x28\x66\x60\x6c\x5c\x34\x0b\x6c\x78\xe5\xf4\xcb\xf9\xcb\xf4\x53\xb9\x55\x4d\xe6\xc4\x98\x9f\x14\x98\xe5\x46\xdb\xaf\xae\xfc\xfc\xe9\x81\xc9\x8f\x3d\x31\x6b\xbf\xfc\xce\xf7\xcb\xa5\xef\xa5\xd4\x6f\xbf\xb2\xe5\xd8\xda\xf5\xef\xe9\xf9\xca\x06\xa7\x17\xe3\x90\xf9\x2d\x2e\xdb\x53\x4d\xe7\xd8\x6c\xd7\x42\x42\xb5\xd0\xb0\xf0\x10\x4d\xef\x6f\x97\x9d\xec\xd2\x2e\xa4\xb5\xac\x5c\x35\x66\x9e\xda\xb2\x49\x00\x4e\xc5\x52\xfd\x52\x47\xe6\x68\x47\x5f\xf5\x39\x8e\x4a\x8f\xab\x79\xbd\x86\xb2\xdd\x51\x5b\xde\x95\xa9\x37\xbe\xfc\xf0\x2c\xfd\x01\xeb\xbf\x21\xad\xce\xe7\x49\x62\xa0\xa7\xa9\xd3\x11\x11\x13\xcd\x25\x34\x3e\xde\x88\x08\x31\x12\x93\x42\x43\x42\x92\x92\xab\x19\x59\xd1\x3d\xa3\x8b\xa3\xf5\xe8\xe8\x88\xc4\x10\x3d\x3e\xa2\x4e\x84\x8c\x70\x72\x3c\x72\x38\x4d\xdb\xca\x3f\xf6\x0c\xeb\x03\xe0\x55\x97\x93\x5a\x55\xf9\xdc\x96\x9a\x16\x2a\xeb\x46\x4a\x96\x5f\xb5\xf0\xb6\x63\xe1\x4d\x8c\x4d\x4a\x91\x39\xfa\x9f\x27\xba\xf6\xc8\xac\xd9\x74\xca\x89\x77\x5f\xba\x3d\x3a\xc6\x9d\x39\x75\x6b\x5e\xcf\xa6\x69\xa3\x5f\x92\xf1\xd2\x7d\xf0\xde\x37\x7c\x7d\x01\xfb\xd2\x7d\x1f\xce\xdd\x29\x5f\xaa\xf0\x7d\x7e\x52\x0e\xd0\x3b\x06\xd6\xdf\x3a\xe0\xde\x68\xae\x3f\x1e\x4f\xaa\x6e\x17\x21\x86\xc1\x3d\x02\x76\x9c\x36\xc3\xe1\x34\x9c\x11\xe1\x22\x44\xb7\x1b\xd2\x69\xc4\xaa\xad\x2f\x57\xe1\x4b\x6a\x55\x65\x5f\xb5\x2e\x5d\xec\xaf\x21\x6a\x43\x4b\x33\xff\xc9\xd1\x46\xca\x1e\xc7\x7d\x3d\xe4\xc9\xe3\xbe\xb9\xbe\x79\xc7\xe5\x49\x5f\x8f\xe3\x7a\x27\x4d\xfe\x3f\xa4\x7d\x07\x7c\x14\xc5\xfe\xf8\xcc\xce\xee\x5e\xdf\xdb\xbd\x7e\xb9\xcb\x5d\x2e\x97\x02\x04\x08\xe4\x48\x20\xb4\x1c\x48\x93\x1a\x3a\x4b\x4b\x40\x40\x82\x05\xa4\x49\x51\xe9\x1d\x82\xf4\x8e\x80\x28\xa0\x52\xe4\x45\xc0\x0a\x8a\x22\x28\x8a\xdd\xf7\xc4\x8e\xfa\xec\xfa\xec\x4a\x6e\xf3\x9f\x99\xdd\x6b\x49\x9e\xef\xff\xf9\xfc\xd4\xf8\xf2\x70\xf6\xbb\xdf\x9d\xf9\xce\xb7\x97\xd8\x5d\xb1\x32\xa6\x53\xec\x3c\xf3\x2c\xb3\x34\xf1\xfe\xc3\x54\x8f\xed\x1c\x0d\x91\x57\xea\x79\x6c\x4e\x33\x8c\xd1\xc0\xa3\x28\x28\x07\x95\x00\x95\xd1\x1e\xbc\x3a\x56\x25\x2d\xba\x3d\x63\x22\x71\xf2\xb2\x95\x16\x49\x09\x1a\x23\x08\x44\x98\xe7\x9f\x52\xfc\xaf\xc0\xd9\x70\xe6\x2b\x4c\xaf\xd8\x19\xa6\x17\x13\x8b\xed\x61\x6e\xc2\x40\x6e\xc4\xef\x5a\x42\xf5\xc6\xe2\x68\x06\xab\x67\x0c\x08\x0b\x6d\xa3\x49\xa7\x51\x2e\x83\xc5\x0b\xd6\x54\x6d\xf5\xb5\x94\xd2\xf8\xee\x37\xc5\xd6\x3b\x21\x63\x18\x62\x97\x5c\xbf\x80\x8a\x62\x6e\xf4\x5c\xed\xab\x68\xdc\x7a\x36\x63\xf7\x9a\xeb\x9f\xd2\xd8\xd6\x4e\x65\x38\x7a\x1a\xdb\xc4\x3a\x22\x51\xb0\x82\xc5\x01\xa0\x37\x40\xf6\x57\x19\x7f\x03\xf7\xab\x0c\x7c\x29\x12\x25\x71\x3b\x54\xdd\x07\xee\x64\xc2\xca\x06\x38\x55\x19\xae\x9b\xb5\xe6\xcf\xfd\x6b\xe8\xfe\xcc\xc0\xf7\x63\x64\x3c\x76\xc2\x40\x80\x20\x62\x39\x6c\x0e\x7a\xd3\x63\x27\x1c\x26\x52\x74\xb0\xf6\xca\x49\x54\x1c\x0f\x9e\x40\x28\x60\x5c\x5a\xc7\x71\x61\x31\xc7\xd7\xe9\x88\xc7\xe7\x57\x19\x23\x05\xff\x0b\x2e\x44\xff\xc2\x3f\x50\xc0\x78\x6c\xc0\xf8\x0c\x5f\xc3\x57\xac\xf9\x43\xc5\x65\x19\x7c\x82\xed\x81\xf7\x8f\x07\xad\xa3\x1e\x8e\xc5\x82\x99\xc1\xf6\x10\xe2\x75\x7a\x62\x9f\x42\x11\x32\x90\x25\x24\x32\x26\x35\x59\x82\xde\x23\x4c\x1c\x0c\xb9\x47\xe8\x11\x6c\x53\x3c\xb1\x1d\xce\x7b\x19\xde\x05\x9f\x40\xe1\xda\x0f\xd0\x9a\xda\x59\xf8\xd9\xba\xeb\x75\x39\xec\xeb\x75\x4b\xf1\x77\x3a\xa3\x06\xc4\x61\x85\x12\x3c\x89\xf7\x0c\xf3\x3e\x48\x11\xd3\xe1\x7d\xe7\xd8\x77\xde\xaf\xac\xa4\x74\x0b\x37\xb2\x8f\xa2\xf6\x5c\x0d\xd6\x8b\x3c\x51\x13\x41\x05\x1b\x22\x6b\x47\x81\x4d\xa0\x2c\x11\x84\x82\xb9\xc5\x11\xb7\x93\x79\x46\x79\xeb\x85\x6b\xec\xa3\x5f\x64\xfe\xe0\xc0\xb2\x83\xf8\xc4\x57\xb2\xfd\x41\x36\x28\x04\x13\xa2\xed\x5b\x58\xbd\x19\x36\x7d\x7e\x7e\x56\x56\x86\x15\xb5\x6a\x6d\x6b\x32\x50\xb6\xd9\xcc\x7e\xab\x77\xaa\xf7\x23\xef\x0f\xde\x3a\x2f\x67\x42\x5e\xaf\xdf\xef\x2a\x97\xfd\xa2\x39\x5c\x8e\xb7\x6e\x20\x16\xcb\x7a\xb3\x8b\x66\x12\x14\x24\xc3\x10\x58\x8a\x90\x48\x44\xd2\xa0\xd0\xf8\x74\x6e\x5c\x1c\x6a\x9e\x08\x31\xb7\x6d\xdc\x17\x63\x23\x62\x05\xf3\xb1\xdc\xa2\xce\xb0\x13\xf1\xd5\x38\x1d\x2e\xb6\x5f\x46\xa8\x5b\xcf\x09\xa3\x78\xbe\xcb\xa3\x8b\xf7\xee\x83\x17\xbe\x9d\x32\x73\xf6\x64\xe3\x53\x2d\xe1\xdc\x8b\x97\x9a\xc5\xde\xab\xdc\x3c\xe8\x99\xd9\x77\x75\x97\xa7\xea\xa6\x89\x55\xd3\xe6\x4e\x79\x64\x2b\x1c\xc3\xb1\x1d\x96\xcc\x18\x32\x42\x82\x39\x4f\x3e\xaa\xb4\x2c\x1f\xc8\x8f\xde\x39\x48\x66\x99\x56\x37\x0d\x1a\x34\x81\xc8\xf9\x7f\xe0\x6f\xee\x8a\xe9\xc0\x09\x42\x24\x12\xe5\xe7\x04\xc1\xe2\x22\xd1\xd7\xb0\xc3\x5b\x2e\x4b\x0e\xd1\x02\x8c\x4e\x14\xc4\x1f\x87\x68\xec\x1b\x7f\x53\x59\x59\xba\xfb\x53\x73\xa8\xe4\x87\xb1\x14\x0c\x13\xae\x2b\x39\x74\x91\x74\xdf\x67\x09\xdb\xf5\xe5\xa7\x7f\x19\xc9\xe8\x98\x63\x7c\x0d\xcb\x8e\xfa\x19\xae\x78\x62\xfe\x92\x2d\x2b\x97\x6e\x5b\x31\x97\xc9\x56\x3e\x53\xbe\x38\xd3\x6a\xb2\xb9\xe4\x08\xfb\x9d\x22\x77\x19\x7d\x31\x76\xf9\xe3\x4b\x57\x3f\x7c\xfd\xa5\xd7\x55\x3e\xb4\x18\xe3\xd8\x0e\x9f\x4b\x06\x98\x1c\x0d\x58\x80\x8e\xe7\xed\x0e\xe0\xf0\xf9\xa7\xd9\x21\xb0\x8b\xf6\x4a\xfb\x34\xfb\x42\xfb\x39\x3b\x6f\x40\x54\x67\xcd\xf2\x05\x7a\xd9\xed\x1e\x8f\x58\x2e\x7b\x5c\xc8\x58\x2e\x07\x75\x0b\x74\xeb\x75\x48\x17\xc5\xff\x01\x9b\x00\xa2\x1a\xbb\x4d\x1e\x0f\xb1\xf6\xee\x48\xb5\xba\xb0\xc9\x41\xb4\x13\x55\x5c\xc6\x3f\xa1\xad\x5b\xc0\x5f\x09\x16\x43\xe6\x97\x53\xdf\xfa\xcf\x89\x0b\x67\xef\xdd\xb4\x69\xcf\xad\xd5\xd2\x33\x96\x3b\x9f\x9f\xfb\x6b\x1d\x60\x02\xf8\x66\x64\x1f\xdf\x2c\x8c\xaa\x7a\xfe\xea\x87\xaf\x4c\xb9\xcd\x5c\xb9\x47\x86\x59\xaa\x2e\xb7\xba\xee\x0b\xd6\x8b\xf7\xd9\x85\xa9\xab\x7d\x34\xd3\xcd\x67\x02\x41\xb0\xf2\xd6\x70\x8e\xdd\x29\x00\x7d\x56\xb9\x6c\xd2\x8b\x28\xa3\x1c\x5b\x42\xf1\x7d\x56\x37\x3b\xb1\xd3\x2a\xc5\x50\xd7\x32\xb1\x00\x5d\xee\x48\x3e\xd9\x6a\x77\xb8\x25\x66\x3d\x8e\x64\x8c\x05\x8d\x6d\x7d\x60\xee\x4b\xcf\xc0\x95\x73\xef\x6f\xcd\x30\x35\xfc\x23\x2c\x1f\xfb\xe4\xce\xe5\x1b\xd7\xae\xd8\xb2\x62\xce\xb1\xaa\x0a\xe8\x82\x1e\xa6\x64\xd8\xf8\x6d\xf0\xfe\xeb\xf6\x23\x25\xd6\x99\x05\xf0\xd6\x0f\x5f\x7e\xf3\x8b\x77\x9f\x7f\x15\xe3\x49\x63\x06\x78\xaf\x1d\x78\xb7\x07\x44\x9b\x63\x4d\xd4\xc2\xeb\xbc\x76\xbb\xce\x82\x7c\x7e\x0f\xc0\x5b\xea\x31\x8a\xa2\xb3\x5c\x16\x45\x23\x2a\x97\x3f\xe2\x7f\xe0\x99\x85\x58\x48\xf2\x46\x17\xd5\x4a\xc6\xa4\x7b\x6e\xea\xa9\x25\xae\x84\x43\x4d\x8b\xa3\x4a\x4e\x88\xa9\x3d\xc4\xc0\xae\xfb\xd7\xde\xbc\x2b\x63\x6f\xf3\x6f\xee\xff\x56\xf9\xf3\x9b\x6f\x7e\x52\x72\x97\xef\xe6\x98\x5e\x7e\xf8\xfb\xa9\x57\xe5\x7e\x2d\xee\x5a\x0a\xf3\xa0\x0d\x9a\x60\x50\xf9\x54\xf9\xc8\x03\xdf\x38\xbe\x83\x8e\xcc\x04\xab\xa9\x1d\x73\x19\xdb\x31\x91\x68\x86\x8b\xb0\x1d\xc6\xe2\xcd\x30\x4a\xe5\x32\x91\xec\x1c\x5b\x2e\xbb\x38\xd2\x66\xb2\x2c\x25\x6f\x23\x7e\xd0\x09\xe5\x43\x53\x8e\x9c\xe4\xb4\x05\x98\x09\xb1\x36\xd2\xad\x06\x2b\xec\xfc\xb3\x9f\xf4\x3a\xd4\x2c\x70\xba\x70\xf2\x94\xd6\xf0\x1b\xf4\x48\xed\x10\xf4\x48\xb5\xf7\x95\x47\x2c\xfa\x0d\x9c\xb9\xe5\xe4\x31\xc6\x6a\x7a\xb6\xeb\x95\x11\x6c\x80\xed\x83\x6f\x50\x21\x18\x18\x2d\x60\x11\x6a\x22\x65\xbb\x0d\x86\xa0\x14\x6c\xd5\xda\x67\x75\xe4\x96\xcb\x6e\x87\x28\x34\xc7\x38\x09\x4e\xa0\x2b\x97\xb3\xd8\x56\x2c\xc3\xb2\x84\xc9\x16\xa5\x28\xcd\x91\x14\x9b\x2d\x25\xc9\x21\x6e\x97\x4a\xc5\xe1\xe4\xce\xe1\xe3\x6f\x53\xd2\x36\xc2\x63\x1e\xc1\xc7\xe3\x28\x64\x51\x67\xc8\xdc\x7c\xf8\xb2\xff\x8c\x74\xc7\xe8\x3f\x98\xd6\xc7\xe6\x5c\x38\xfd\xfc\xe5\x3b\x0e\xb5\x40\x7a\xf6\x61\xfe\xad\xd0\xd6\x25\xab\xe6\x45\x6e\x1d\x37\x74\x51\x0f\x65\xc4\xea\x45\xde\x3e\x03\x61\x87\xe7\x6e\x9e\x02\x11\xa6\x09\x1f\x34\x55\x8d\x0b\xac\x37\x97\x3c\x54\x7b\xe1\xda\xe7\xe8\xca\xb3\x1f\x9c\xfd\x68\xdb\xf1\xf2\x8a\xd3\xea\x1d\x7c\x1c\xef\x26\xa1\x5f\x07\xb6\xad\xdd\x2c\x63\xb7\x3b\x8c\x26\x87\xc9\xe9\x72\x18\x9d\x3a\x6b\xb9\xcc\x92\x66\x67\x74\x93\xd3\x74\x32\xca\x1d\xec\x71\x86\xe0\xc5\xfa\xb2\x8a\xaa\x14\x7e\xfc\x31\x03\xaa\xfa\x1a\x8e\x7d\xac\x6a\xc6\x5d\xf7\xd5\x70\x97\x95\x79\x1d\x56\xbf\xa2\x2c\x89\x15\x32\xa7\x57\x2e\x7d\x6c\x57\x6c\x1d\xd9\x57\xea\xc7\xba\x8c\x65\xb2\x05\x74\x8c\x06\x4d\x66\x33\x24\x67\xca\x61\x03\xd0\x38\x58\x36\x01\x3d\xde\x4a\xbd\x15\xb0\x08\x9f\x32\x72\x26\x44\x73\x9a\xd8\x52\x6f\x8d\xe6\x3c\x28\x0e\xe5\x93\x1c\xbf\xaf\xe0\x5d\xb5\xcd\xe0\x83\xca\xb3\xf0\xe7\x8b\x17\xab\xab\xab\x51\xa0\xfa\x8d\x73\xe7\xd4\x7b\x3a\x0b\xcb\xc5\x6e\xf8\x9d\x22\xfe\xd2\x92\xa8\x5f\x72\x38\x00\x30\xf3\x66\xa7\xcb\x26\x0d\x96\x6d\xc0\x2a\x94\xcb\x56\x2b\x32\xe0\x17\xc6\x25\x64\x9a\x0d\x48\xe5\xad\xea\x4b\x28\x56\x75\x50\xed\xa5\xa8\xdb\xc7\x57\x06\x1c\x6c\xb1\x75\xfe\xc2\xd5\x4a\x15\xd3\xe7\xe2\x45\xff\x93\x6f\x64\x48\x6b\xb3\x97\xde\x89\x5e\x50\xdf\x0e\xc9\xac\x2a\xfa\xbd\x26\xd0\x29\x9a\x09\x8d\x06\xea\x9a\x31\x18\x54\xdf\x0c\x71\x25\xe8\xa0\xde\x8a\xc5\x1f\x66\xd6\xd8\x42\x29\x8b\xe7\x29\xa4\x06\x2e\x55\x7f\x6d\xaa\x13\x61\xa3\xb2\x71\x69\x4d\x0d\xbc\xfa\xa6\x72\x23\x7c\x15\xfe\x3c\x5e\x99\xca\x5d\xae\x1d\xc7\x58\x94\xc2\xd8\x36\xfc\xce\xe5\xf8\x9d\xa3\xe9\x1e\x37\x8f\xba\xd4\xed\x35\x9a\xe8\xc6\x82\x06\x1b\x9b\xa2\x0b\x24\x77\x94\xf9\x58\xdb\xcd\x8f\xe0\xdb\x78\x2f\xd9\x13\xd5\x94\x5e\x6e\xc2\x8f\x4f\xc0\x7c\x24\x1f\x74\x8f\x66\xbb\xf2\xf3\x01\x30\x04\x83\x01\xab\x5e\x6f\x08\x18\x9a\x34\x0d\xb3\x76\x0c\x3a\xc3\x65\xb5\x8b\x66\x6b\xd0\x40\x3f\x08\x7f\x51\xa4\x9e\xdb\x3e\xc5\xd9\x1b\x4a\x50\x8e\xd4\x26\x1f\x8b\xee\x08\x0d\xc7\xba\xd5\xff\xa1\x7f\xaa\xfe\x67\xc6\xde\xba\x4b\x74\xc0\x11\x7e\x0b\xcf\x64\x4f\xee\x3f\x62\xb8\x9d\x69\x32\x75\xe8\xec\x49\x87\x5b\x77\xe9\xda\x8f\x39\xb6\x73\xfe\xb9\x83\xb1\xfd\x68\xf0\xd3\xcd\x16\xb4\x9a\x34\xa6\x72\xc2\x94\x91\x8f\xbc\x8e\x49\x0e\xff\xf9\xe1\xc3\x98\xe4\x30\xde\xff\x20\x74\x8e\xf1\xf6\x80\xc2\xa8\x5b\xc2\xe8\x02\x8f\xc1\xe3\xcd\xc0\x74\x80\x11\x76\x60\x6c\x0d\xda\xee\xd7\x43\xb4\x3e\x86\xd8\xc2\x8a\xd0\xbc\x2f\x09\x4d\xa0\x24\xce\x3f\x04\x19\xc4\xa0\xaa\xff\x1c\x7d\x28\x4e\xe2\x04\x0f\xae\x79\xe9\x80\x57\x9e\x7c\x2e\x56\x88\x69\x8f\xc8\xb9\x1b\xf1\xbb\x49\x3e\x0b\xd6\xca\xd4\x4c\x16\x8f\xd7\x80\xef\x97\x41\x44\x98\xe7\x12\xd1\xd0\xd0\xe7\x90\xcc\x4a\x49\x93\xb8\x37\x5e\xff\xee\xcb\xdf\x63\x5f\xfe\xf2\xfd\xd3\xab\x76\xec\xba\xf7\xde\x7b\xef\xab\x66\x02\xca\x0f\xf8\x98\x72\xb0\x98\x72\x43\xaf\xf2\xb5\xf2\xc5\xbb\x6f\xfd\xf3\xcd\x37\xae\xbe\x43\xf4\x00\x65\x38\xdb\x95\x2d\xc7\x6f\x0e\x13\x3d\x20\x40\x3e\xdd\x83\xa9\x22\x27\xd7\xe9\xc3\x7a\x80\x13\x7f\xb9\xde\xc7\x84\xf0\x4d\x67\xfe\x4e\x0f\x08\x61\x35\xc0\x95\xd8\x02\xf5\x94\xd2\xd1\xea\xaa\xcc\xf9\x6d\x28\xc7\x3e\xc6\x1f\x87\x98\x3d\x17\xed\xba\xfb\xc2\x73\x4f\xcc\x5b\xb2\x6d\xf9\xf2\x2d\xcb\xe6\x31\xd9\xb1\x97\xce\xe8\xf7\x2a\x58\xd9\x78\xa8\x84\x8d\xdc\xe4\xa9\xaa\xc0\x18\x5f\xfb\xf4\xd9\xab\x1f\xbe\x7d\xe1\x25\x55\x8e\x62\x3c\x33\xd8\xde\x54\x8e\x16\x47\x7d\x99\x4e\x37\x32\x9b\x4d\x4e\x53\x38\xc7\x86\x65\xa8\x60\x73\x99\x7c\x00\x4b\x51\x84\x2f\x70\x59\x11\xc5\x32\x05\x49\x75\xc3\x52\x78\x67\x58\x6a\x1b\xe7\xa9\xa9\xc9\x88\x8c\xb4\x68\x67\x6b\x46\xc7\x1d\xe7\x1f\x63\x99\xe2\xbd\x77\xbd\xf4\x0c\xf3\xf6\xca\xcd\xcb\xe7\xce\x5b\xb2\x69\x0d\xdb\x5b\xae\x08\x2c\x30\x97\x7c\x76\xbd\x04\x9e\x3e\x7c\xcb\x44\xe8\x85\x4e\xa6\x24\xf6\xf1\x5b\x2f\x5e\xfe\xe8\x83\xcb\xef\x11\x1a\xfa\x09\xd3\x90\x13\x9f\xa3\x13\x34\x8d\x3a\x04\x9e\xd7\xe9\x9c\x2e\xb7\x60\xb7\x33\x83\x64\xbb\x68\xb2\xf2\x4e\x9a\x41\x99\x4a\x3f\x18\xab\x04\xed\xe4\xe5\x47\x08\x5d\x33\x91\x22\x37\xeb\x9c\x36\x61\xff\x85\x1a\x9f\xf7\xe1\x26\x7a\xae\xa8\x72\x69\xc5\xe4\x49\x68\xab\xfd\xa7\x27\x15\x96\x79\xba\xef\xab\x37\xad\x9e\x36\xad\xaa\x58\x52\xf9\xf3\x21\x4c\x3b\x39\x58\x06\xe5\x81\xfe\xd1\x66\x3a\x3e\x68\xcf\xf0\x9a\xb1\x21\x60\xe7\xd9\xfc\x26\x41\xb3\x0b\xb9\x32\xb1\x6a\x91\x31\x2d\x83\x31\xa1\x8c\x0c\x97\x48\xd4\x22\xac\x0a\xb9\xe2\xde\xd0\x64\x3e\x44\x43\x5f\x42\xc2\x33\x9a\x85\x15\x8c\xfc\x9c\x78\x46\xa3\xaa\x1c\xe1\x0d\x0b\xc2\x00\xc3\xe6\x7c\xf5\xea\xab\xef\x86\xee\xb3\xdf\xbd\x0d\x0a\xe3\x27\x2a\x7f\x54\xf7\x7d\xeb\xd2\x89\x37\x32\x0e\x98\xe6\xdc\xf9\xeb\xe0\xd1\x77\xde\xbf\x7e\x10\x2c\xde\x79\x7c\xd1\x9a\xe0\xb0\x01\x0f\x47\x07\x78\xbb\xf4\x9e\x3a\x78\xd3\x83\xcb\x16\x38\x7a\xf5\xde\xd6\xb1\x97\x2b\xd8\xa4\xff\x2c\xf5\x3b\x9e\xa9\xfb\x11\xfd\xc9\x0d\xc1\x7b\x57\x12\xf5\x71\x06\x03\xe3\x70\x58\x5d\x6e\xc9\x8c\x69\xd0\x85\x0d\x62\xac\x80\x70\x10\x21\x12\x8e\x8e\x14\x4a\x8d\x89\x74\x7b\x71\xc4\xae\x86\x0a\xc8\x51\xaa\xfa\x75\xb1\xf4\xcc\x43\xed\xe7\xc0\x13\x4a\xf9\xd0\x71\xcb\xef\x3f\xf2\xe0\x81\x03\x58\x8e\xc3\x0c\xe5\x8b\xea\xd8\xcc\x01\x7d\xb3\x57\xb5\x5c\xb5\x99\xb9\x4f\x93\x73\x78\x1f\x83\x6c\x7b\xbc\x75\xda\xfd\x87\x1e\x8f\x21\xc3\x27\x39\x9d\xf8\xfe\x3b\x5d\x16\xa7\x1e\x58\x1b\xbf\xff\x30\xe1\x75\xa0\x4a\x19\x13\x57\xea\x25\x78\xdb\xf8\x7b\x16\x6d\x7d\x4c\x63\x00\x9d\xef\x9f\x7b\xf2\x01\xb6\x7d\x6c\xd0\xee\xb9\x27\xf6\x31\x33\x6a\x8f\xaa\x3c\x60\xda\x98\x47\x2f\x33\x9a\xbe\xdb\x1d\xd3\xcf\x0a\x8c\x83\x91\x78\xfd\x34\x97\x04\x62\x8c\x8c\xd9\x64\x60\xac\x09\xa7\x84\xb3\x9e\x53\x22\x61\x4e\x51\xaf\x44\x10\x96\x41\x6c\xef\xbe\xfc\xb6\x32\xe0\x25\x68\x96\xda\x84\xf3\xa1\xe3\x12\x7e\x6d\xb4\xf8\xcc\xac\xd9\xcc\x73\xf4\x3d\x4e\xfc\x9e\x33\xf4\x5b\x47\x46\x5b\x42\x60\xb3\x0a\x88\xe7\x4c\x36\x64\x42\x3a\x8f\x57\xaf\xf3\xea\x7c\x19\x48\x10\x4c\x3a\xaf\xd7\xa3\xd7\x59\x6d\xa6\x59\xa6\x65\x26\xc6\xc4\x61\x8c\xe8\xbb\x23\xaa\x4b\x22\x9e\x20\x9d\x1e\x6c\x4d\x71\x4b\xa0\x7c\x1d\x75\x4a\xd8\x9c\x25\x6d\xed\xc4\x37\xd1\xa6\x33\x83\x7f\x41\x7f\x5d\x5e\x5f\x9a\x7f\xf8\xe5\xd3\x27\xc7\x84\xf2\xed\x2b\x9e\x5d\x9c\xe5\xd6\x9b\xcd\x68\xe2\x09\xf8\xee\x4b\x6b\x62\x5f\x63\x5c\xf7\x2b\x7f\x74\xde\x57\x02\x0f\x2b\xc3\xab\x6e\x0d\x8c\xac\x18\xe6\x65\x2a\x28\xde\x24\x1e\x7e\x1b\xc6\xdb\x44\xb4\x02\xe2\x77\xd7\x41\x16\x1b\x97\x26\x9e\xe3\x18\x84\x48\x1c\xc3\xc8\x42\x56\xcf\x59\x91\xca\xab\x23\xee\xb4\xe4\x2f\x8c\x9f\xca\xb0\x55\x77\x04\xfd\x07\x1d\x54\xce\x2a\x4f\x3f\x07\xef\x53\x66\xbc\x08\x9b\xc3\x66\x97\x94\x19\xf0\x20\x7c\x4a\xe9\xc6\x34\x67\x04\x65\x14\x7c\x20\xf6\x4b\x8c\xf4\x4e\x01\x5d\x31\xff\x59\x45\xbb\x14\x97\x46\x7d\x36\x83\xc0\x08\x46\x51\x32\x19\x8d\x92\xd3\x25\x18\x0c\x9c\x68\xb4\x02\xae\x3c\x61\x3e\x47\xd2\x37\xa6\x54\x3d\x20\x98\xad\x2a\x07\xe4\x84\xa0\xcb\xdd\x16\xff\x5b\x80\x30\xa7\x77\x51\x5e\xcb\x01\x6b\x5a\xd9\x94\x66\xe7\xa0\x7e\x94\xae\x29\x2c\x79\x46\x69\x27\x9f\x55\x86\x9b\x56\xf0\xb3\x17\xb5\x66\x0b\x63\xf7\x7c\x1c\xb8\x1d\xd9\xae\x5f\xf8\xe6\x19\xba\x0f\x9b\xf0\x3e\x34\xc7\xb8\x50\x9f\x85\x0e\x41\x3d\x83\x09\xc3\x68\xe2\x11\x8b\x35\x73\xd6\x0a\x75\x44\xd7\x04\xce\xff\xea\xb3\x88\xc4\x5d\x16\xce\x4d\xcc\x91\xd8\x02\xd4\x37\x36\x8c\xb9\xb2\x0a\xe5\xad\x59\x55\xfb\xde\x1a\x0c\xff\x1a\xfe\xd6\x5c\xac\x1b\x84\xc1\xb0\x68\x91\x18\x76\x05\xf4\xa6\x40\xd8\xcb\x21\x94\x93\x8b\xc9\x43\xaf\xfb\x55\xb6\xea\x0b\xf5\xeb\xf5\x57\xf4\x3f\xe8\x39\x09\xe9\xf5\x62\x58\x94\x7e\x95\xb1\x26\x98\x9d\xe6\x41\xd0\x1c\xa9\x89\x40\x6e\x22\x83\x11\x92\xeb\x81\x79\x4a\x71\x67\x88\xff\xb7\x24\x12\x72\x52\x26\xa8\x26\x0a\x11\xeb\xb7\x03\x74\x22\xff\xe2\x83\x1b\x17\x2d\xde\x70\x60\x29\x34\xbc\x3d\xaa\x7c\xe1\xcd\x93\x16\x95\x8f\x7a\x5b\x19\x7e\x64\x39\xac\xb8\x65\x0e\xb7\x8a\x9b\x37\x19\x56\xae\x7a\x70\xcd\x88\x5b\x94\x07\xc7\x6f\xf1\x32\x9e\x4d\x37\x2b\x0f\x4c\x91\x31\xfe\x8c\x5d\x19\xce\x3c\x4e\xfd\x23\xae\xa8\x81\xe6\xa2\x62\x05\x27\x99\x45\xac\xe6\xaf\x30\xf6\x07\x89\x53\x85\xba\x31\x08\x1f\xc5\xfa\xdf\x57\xf4\x9b\x47\x46\x8b\x0d\x1e\x1f\xca\xb2\x63\xed\x33\x0b\x71\x5c\x4e\xae\xc1\xe7\xf7\xf9\xf1\x47\xfb\x0a\x7d\xeb\x7d\xc7\x7d\x57\x7c\x3f\xf8\x78\x09\xf9\x7c\x76\x60\xb7\xfd\x2a\xdb\xeb\x3b\x4e\x1a\xff\x6c\xb7\xca\xa3\x08\xa3\xd0\xf2\xa3\x24\x12\xb1\x2e\xd6\xec\x7d\xb7\x53\x20\x5f\xce\x87\x0f\xbd\x3d\x6a\xe0\xc2\x49\x93\x16\x96\x8f\x7e\x1b\x1a\x96\xed\x27\x5b\x70\x70\xb1\x32\x7c\x8d\x3c\x05\x8e\x9a\xb4\xd9\xc3\x78\xb7\x8e\x83\x23\xab\x46\xae\x79\x70\x95\xb2\xaf\x6a\x2e\xde\x87\xb9\x53\x94\xfd\x2b\x0e\x93\x6f\xb8\x95\x69\xca\x56\xa2\x7c\x7c\xf2\xed\xa2\x59\x76\x9d\xcb\x0d\xc4\xa3\xb2\x0e\x44\xdd\xfe\x5e\x20\x6a\x30\xf7\x02\xa6\xa8\xdd\x64\x22\xd9\x31\x9a\xd7\x1e\x13\x46\x86\x47\x7c\xa5\xa0\xa0\x28\x91\xd6\x5b\xe4\x56\xbd\xf5\x6a\x0a\x1f\xf5\x49\x14\x97\xc0\x19\x93\x96\x6d\x1a\x9e\xb3\x78\x7a\xc7\x19\x43\xbb\x6f\xb8\x71\xd1\x88\x1b\x66\x76\x99\x8a\xf2\x5b\x46\x1c\xa3\xb7\x34\xcb\x6b\x9e\xd1\xa2\x69\x21\x69\xc2\x09\xe8\x74\x38\xfa\x97\xc8\xd3\x49\x7a\x0c\x83\x94\xdf\x98\x4b\x5a\x9e\x51\x8b\xa8\x1d\x5b\x3f\x88\x78\x9c\x00\xc0\x76\x39\xbf\x67\x94\xce\x8a\xce\x40\x21\x19\xc7\x48\x75\x3b\x45\xec\x61\xbb\x33\x5c\xcc\xf8\x68\x69\x0e\x73\xb4\xf6\x46\xae\xdb\xa5\x4b\xc4\xe7\x54\x77\x9e\xed\xc1\xdd\x04\x82\x60\x5e\xb4\xa7\x1d\x93\x9f\xc1\x60\x61\xdd\x2e\x17\x62\x33\x2d\xac\x25\x2b\x24\x62\x45\x20\xe8\x5e\xe0\x5e\xef\x46\x6e\xb7\x5d\xd4\x19\xb3\x10\x04\x48\x44\x95\x68\x1a\x5a\x88\xce\x21\xde\x80\x10\x32\x1a\xb1\x4c\x11\x8d\xa2\x51\x6f\x95\xa0\xa4\x07\x85\x85\x63\xd4\x2a\x99\x44\xc8\x9e\x6a\x0e\x85\x63\xd2\xd4\x08\x29\x19\xb8\x57\x2d\x5a\x52\xf9\x91\xc7\x14\xb7\xb1\x25\x2b\x3e\x54\x75\x82\x99\x7f\xc7\x26\xe9\x94\xf3\x9d\xfd\x0b\x5f\xfb\xfc\xcb\x57\x16\xee\xb9\x9c\xf9\xb8\xb4\x64\xde\xee\xfd\x87\xa1\x65\x5a\x95\xb9\xfa\x8c\x70\xfe\xbc\x15\xda\xbf\xfc\x11\x7a\x6d\x67\xce\x58\x8e\xac\x15\x46\xdd\x7a\xe9\xe9\x0b\x97\xc8\x39\xb6\xc3\x24\xbb\x89\x1b\x89\x65\xfa\xed\xd1\x0e\x79\x00\x38\xec\xd9\xc8\x17\x34\x07\x11\xd2\xdb\xf5\xf9\x4d\x02\x46\x93\x71\x86\xec\xc3\x87\x68\x46\x26\x13\x12\x45\xf7\x0c\x99\xe6\x3e\x1a\x90\xc3\x21\xea\xd8\x6c\x94\x3d\x43\xce\xcb\x43\x1e\x2a\xe4\xb5\x8a\x96\xb4\xb4\xc7\x7a\x99\xa4\x49\x2f\x03\x1f\x0e\x15\x77\x66\x3a\xc1\x70\x71\x24\x55\xd8\xf3\xc4\x34\x0e\x91\x68\x07\x89\x40\xb3\x9b\x8a\xce\xd4\xae\x1f\xde\x33\xf7\x89\x27\xfe\xf5\xca\x8e\xcb\xd9\xc7\x5c\xb3\xfa\xcf\x9b\x43\x2a\x79\x7a\x0d\x66\x46\x74\x28\x35\xfd\xf8\xe3\xce\xe6\xfd\xef\x18\xb4\xae\xfa\xfd\xe7\x5e\x9a\x7b\x5b\x69\x59\x74\xc6\xdd\xff\xac\x5e\xb3\x70\x7d\xf3\xe2\x62\xaa\xcb\xed\x05\x9f\xb0\x85\xec\x0c\x7c\x65\xf2\xc1\xb8\x68\xc4\x0f\xb2\x05\x20\x34\x69\x6a\xf3\x78\x9c\x06\xce\xcc\x88\x19\x76\xb7\x3b\x83\xe1\x58\x9d\xd3\x19\x3c\x21\x8b\xce\x56\x4e\xc6\xea\xc4\x1f\xeb\x34\xb2\xac\x4e\x97\x7b\x02\xd3\xb4\x76\x4c\x91\x78\x12\x27\x48\xaa\x2e\x12\xf9\xf3\xd4\x14\xae\x36\x6d\xf3\xdb\xba\xf1\xc7\xb8\xdb\xba\x75\x2e\xa7\x43\xe7\xd6\x91\x22\x8d\x7c\x5d\x7e\xdb\xbc\xb6\x29\xfe\x93\x53\xfd\x27\x4c\xbe\x69\xfa\xda\x55\xd3\xc7\x4d\xae\x2c\x1f\x34\x61\xd2\xc4\xe9\xab\xd6\xdf\x56\x35\x69\x52\xff\x9d\x07\x67\x4d\x7f\xf0\x81\x19\xb3\x0e\x32\x8f\xac\x9e\x3e\xe1\xe6\x89\x83\xca\xc7\x55\x55\xce\x5a\x81\x7f\xaf\x9a\xd8\xbf\xbc\xaa\x6a\xd2\xf4\xb5\xd3\x1f\x3c\x30\x7b\xe6\x03\x87\xf0\xd9\xb5\xc1\x67\xb7\x9d\xeb\x8e\xf5\xd4\x91\xd1\x42\xbb\xcd\x86\x2d\x65\x03\x60\x5d\x48\x6f\x91\xf4\x88\xb8\xfc\x75\x26\xb3\xa9\x52\x66\xcd\xc8\x2a\x5a\x2b\x65\x07\x10\xcd\xf8\x6f\xbd\xd3\x86\xf4\x9a\x27\x1b\xd3\xa0\x56\x9c\x25\x25\xce\x49\x2d\x35\xb2\xa9\x39\x3a\x98\xf6\xc8\x69\x68\x89\x09\xc5\xa1\xb6\xf8\x47\xf5\x72\xd7\xc2\x2e\xca\x22\xb8\x40\x59\x74\x52\x59\x02\xef\x66\xf0\xef\x51\x65\xe2\x8b\xb0\x0a\xde\xf6\x22\x73\xa8\x7a\xd5\xbd\x75\x24\x21\x7c\x55\x35\xb3\x37\xb6\x8d\xa9\xa2\x76\x2f\xe6\x95\xa5\x98\x57\x1e\xa3\xf7\x33\x2f\x2a\xe1\xcb\x49\x86\x5d\x1a\x38\xc0\x01\xc8\xfa\x68\x3a\xbe\x8a\x52\xaa\x6f\x5a\x4d\x2b\xc4\x1c\xf4\xc1\x07\x99\x83\xc8\x58\xfb\xdb\xf5\x2d\xc8\x54\xfb\x2b\x39\xdb\xfb\xea\x86\xb0\xcd\x31\x1f\x6d\x03\xba\x80\xd5\xd1\x1b\xcb\x9c\x1d\x3c\x1d\x9a\x17\xb6\x2b\x36\x16\x15\x35\x0f\x06\x02\xcd\x8b\x6d\xb9\x1e\x8f\x8d\x45\xc8\xd6\xdc\xd6\xf5\x86\x76\x42\x61\x59\x53\xa7\xa3\x30\xa7\x90\xb1\x14\x42\x2b\x5b\xe8\x04\x3e\x5f\xf6\x40\x19\x04\x2b\x83\x58\x63\x0d\x06\x7d\x40\x37\x50\x66\x59\xe2\x63\x28\x22\x0a\x6b\x61\x8a\xc2\x4a\xb3\x69\x54\x85\x23\x35\xe0\x9b\xfc\x5b\x2b\x69\x53\xf9\x5a\xd2\xa9\x87\x6f\x29\x36\x51\x68\xf2\x90\x33\x25\xfc\x4f\xb3\xc0\xf3\xa9\x96\xdb\x96\xfe\x1b\x5b\x06\xf9\x24\xe5\x17\xaf\xef\x0c\x99\x39\x47\xdf\xf6\xed\x17\x16\xdd\x76\xf7\xa2\x8e\x53\x17\x6f\xda\x3d\xec\xce\x09\xd3\x26\xfe\xfb\x8d\xd7\xaf\x66\xef\x77\xac\x5f\xbd\x64\x6b\x74\xd6\x7d\xe7\x1f\x9a\x5f\x55\x39\xf5\x4d\xf8\xc9\x9a\x13\xb7\x2d\xea\x30\x75\xd1\x9d\x2b\xb8\xcb\x58\xd3\x1d\x30\x50\xee\xd9\xaa\x47\x9b\x60\x78\xf0\xec\x81\x37\x6d\xf5\xb4\x5a\x34\x6a\xf3\x91\x65\x6b\x82\x63\x46\x56\x0e\x6d\xd7\xbf\x5d\x7e\x8b\xdd\xd3\xe4\xcd\x81\xac\xe5\xc3\xd6\xec\xaa\x7d\xb9\xd7\xe4\xa6\xfc\x94\x21\xad\x6f\x2c\x09\x91\xee\x45\x24\x4f\x73\x00\x7b\x1e\xdd\xc5\xcd\xa7\xe7\x53\x12\xcd\xc2\x4c\x55\x47\xcf\x07\x02\x78\xef\x28\x16\xab\xa4\xa0\x02\x1c\x07\x67\xf1\x71\x45\x5d\x01\x2d\xcd\xb0\x7e\xa4\x0d\x73\xa6\x10\xf1\x7f\xfc\xeb\xfe\xd8\x9b\x0f\xb0\xe7\xcf\xe0\xbf\x68\x9e\x56\x10\xe4\xb1\x47\xa9\x0f\xad\x09\x28\x06\x7b\xa3\x13\x5b\x01\x0b\x6f\xb7\xeb\x6c\x16\x5b\xa8\xa9\x37\xe4\x2d\x69\x0b\x78\x91\x5f\xc8\xdf\xcb\xef\xe3\x39\x40\x7f\x41\x24\xbd\xc9\x68\x44\x97\x64\xd1\x75\x49\xb6\xdb\xc5\x0a\x23\xb4\x1a\x83\xc6\x05\xc6\xf5\xc6\x1f\x8c\x75\x46\xfe\x84\x78\x4e\x64\x80\x28\x8a\xd3\xc4\x85\x22\x6b\x40\x98\xc1\x8a\x99\xb9\xb9\xcd\x2f\xca\xb9\x20\x33\x72\x51\xce\x7c\x2d\x45\x4e\x92\x04\x3e\xc2\x69\x09\xaf\x25\x35\x77\x09\xce\x1b\x0f\xb7\xc5\x55\xb7\xa2\x74\x27\x62\x1e\x65\x4e\xda\x81\x72\x0e\x86\x0d\x67\xe7\x10\x1e\x4c\xf2\x18\x6d\x3a\x12\x8c\x27\x59\x7c\x24\xce\x0c\xab\x67\x4f\xe9\x52\x19\x9e\xd1\x66\xc7\x94\xc3\x8f\x9f\x3c\xfc\xaf\x61\xd3\x33\xc6\x45\x6f\x99\x86\x82\xd5\xca\x1f\x8f\x3e\xaa\xfc\xb9\xbe\x1a\x1a\x4e\x9c\x80\x86\xea\xd1\x4a\xed\xbf\xb7\x5d\x9d\x0d\xea\xbe\xfa\x0a\x32\xcc\xf5\x1d\x47\x7b\x0f\x0a\xcf\xbe\xe5\xda\xcb\x2f\x7d\xf8\x7a\xe8\x86\x1e\xfb\xf7\x5d\x53\x1e\x3f\xf2\x30\xec\xf1\xe9\xa7\xb0\xc7\xc3\x0f\x29\x4f\x7e\x06\x5b\xc0\x9e\x1b\x94\xcf\x2f\x2a\x6f\x2b\xa7\x88\x47\x92\xd0\xfe\xab\xcc\x1a\x14\xe3\xb6\x63\x0b\xb5\x25\x18\x1f\xc5\x6c\xda\x14\x06\x7e\xb6\x59\x33\x1b\xb0\x15\xb6\x72\xe6\x65\xe5\x7d\x26\xa3\x02\xfc\x83\x04\x7f\x46\xd6\x19\xe8\x8a\xda\xac\x46\xe8\x42\xc6\xa8\x20\xf5\x32\x1a\x05\x41\xf7\x99\x2c\x9c\x81\x71\xbd\x8d\xba\xa7\xcb\x48\x34\x4b\xdd\x9a\x06\x0e\x42\x7b\x1b\xac\x49\x16\xb7\x49\x29\x57\x48\x9a\x3e\x9a\x11\xd2\x56\x4d\x40\x26\x81\x04\xf8\x6a\xcd\xc9\xb3\x35\x43\x46\x9b\xb6\xd8\x4e\x6c\xdc\xf1\x60\xb0\xc0\xeb\x29\x6a\xb3\x93\x67\x0b\x36\x4e\x9a\xbb\x6a\xd3\xa0\x1e\xdd\x67\x74\xdd\xb9\x78\x36\x9a\x34\x6b\x3e\xc3\x16\x9c\xea\xd6\xcf\x38\x65\xce\xf2\x65\xca\x07\xed\x3b\xea\xc7\x5a\xf6\xf5\x93\xa7\xdf\x1d\xed\xdd\xed\xb6\x92\x08\x4b\x83\x84\xa4\x6e\x77\x1d\xd6\x35\x1e\xa1\xb9\x66\x43\xa2\x4d\x81\x5e\x8f\x58\x96\x87\x06\x49\x32\x5b\xac\x16\x88\xc5\xab\xcd\x6e\x62\x18\xde\x08\xa1\x95\xe7\x81\x19\x01\xf4\xc3\x28\x03\xf8\x9e\x58\xe7\xf8\x63\xb4\x4c\xdf\x48\xdc\x93\x15\xaf\x68\x48\xf1\xdd\xc1\x62\x48\x8a\x1a\x9c\xa1\xf8\x2f\xe8\x11\xe5\x18\x1c\x74\x12\xff\x6b\x48\x6c\xaa\x72\x02\x96\x3f\xaa\x3c\x0a\x07\xae\x83\xb7\x95\xc1\x19\x41\x65\xad\xb2\x21\x33\xe5\xd7\x44\x2d\x15\xf3\x13\xbe\x1b\x4d\xa2\x76\xc8\x22\x96\xd7\x59\x01\x96\x23\x00\xdb\x63\x47\x65\xf4\x0f\x4a\x89\xe2\x05\x1a\xa5\xd1\x12\x66\x72\x69\xa4\x0b\x5d\xa8\x3d\x86\xae\xd5\xc0\x47\x36\xc6\x9e\xab\xab\x8b\xd7\x43\x61\x9d\x86\x38\x3b\xd9\xc4\xbd\xb1\x02\x3f\x68\x06\x22\xe0\xee\x68\x77\xb7\xbe\x69\x20\x90\xd7\x2a\x2b\x2b\x94\xd9\xac\x59\x41\x5e\x28\x4f\x2f\xe2\xad\x69\x53\x9c\x19\x6a\x1a\x6c\x15\xbc\x28\x67\x17\x5e\x94\x41\xb6\x98\xcd\x58\x43\xc1\x10\x16\xd4\xa1\x56\xd9\xd9\xad\x42\x88\x35\x9b\xed\x17\x65\x33\x60\x33\x2e\xca\x6c\xca\xcd\x48\xa4\xb6\x8e\x51\x8f\x3e\xd2\xe0\x46\xc4\xf3\x11\xc8\xc5\xf8\x1b\xfa\xe7\x50\x4a\xaa\x82\x1d\xa9\xb9\x92\x45\x25\xec\xd1\xbf\xa5\x7f\xe5\xc3\x17\xf7\x2f\x80\x91\xea\x6d\x93\x87\x7e\x70\x5f\xc5\xc0\x87\x4e\x95\x0f\x61\xfe\xfc\xfb\x1b\x30\x0b\x96\x2b\x27\x50\xd9\x3d\x53\x27\xcd\xb7\x2b\x07\x98\xf2\xee\xbd\x94\x37\x87\xd6\xd5\xd5\x5d\xe7\x7e\x62\x5f\xe7\x07\xd9\x74\xa0\x2b\x00\xfc\xab\x94\xa7\xf5\x44\x59\x68\x99\x56\xbf\x15\x21\xf9\x2d\xc0\xc6\xf3\x1e\x2f\x72\x1e\x97\x01\x82\x44\x39\x33\x18\xac\xc7\x65\x03\x9b\x92\x40\x99\x16\x90\x8c\x97\x19\xc4\x0b\x33\x34\xf7\x0d\x5a\x76\x64\xf6\xec\x23\x87\xe6\xcc\x39\x74\xdb\xcd\x7d\xfa\xdc\x5c\x75\x63\xef\xc9\x6c\xa7\x3b\x1f\x3c\x3c\x6b\xd6\xe1\x07\xef\xec\x3b\x79\x4a\xef\xde\x53\xaa\x68\xde\x38\x3e\xc4\xe1\xec\x79\xfc\x7e\x2b\x98\x1c\x6d\x8b\x95\x51\x1e\x21\xd6\x6a\x32\xb3\x26\x56\xc4\xf4\x7b\x54\x36\xb3\x8c\x20\xeb\x38\xc1\xaa\x83\x56\x5d\x50\x57\xa1\x9b\xaa\x3b\xae\x3b\xab\xc3\x5a\xbf\x8e\x23\xd1\x85\xa3\xb2\x81\x0c\x9a\xfa\x87\xdd\xd5\x8b\xc3\x2c\x57\xf5\x47\x50\x4a\xba\xa3\x80\xa6\x91\x37\x92\x7a\x9d\x52\xb9\x47\x32\xca\x93\xd5\x7b\x24\xb1\x9c\x39\xac\xcc\x82\x6b\x36\xc0\xd5\xca\xec\x0d\xb1\x11\x1b\x68\xed\x16\x6c\xc7\x44\xd0\x66\x6e\x1d\xa6\xb2\x6e\xd1\x6c\x8b\x20\x64\x00\x9f\xce\x01\x1c\x99\x01\x7c\xc1\x2c\x88\x16\x70\x7d\x26\x4b\x1f\x92\x02\xae\xcf\x64\xf0\x41\x7a\x01\x57\x92\xaa\x13\x0e\xb0\xfc\xff\x5e\xc3\xe5\x86\xed\x99\xe0\xc2\x5b\xc7\x8d\xe8\xd9\xbb\xdb\x08\xfd\x32\xcb\xc1\x7b\x96\x6c\x18\x5b\xb9\x74\x82\x07\xbe\xcc\x30\x91\x9b\xbb\x2f\xec\xd3\x75\x7a\xc7\xce\x7d\x6e\xec\xa6\xbf\x75\xc9\x82\x69\x7d\x96\x77\x1b\x33\xba\xe8\x16\x82\x63\x11\x93\x8f\x76\x60\x1c\x73\xc1\x3d\xd1\x9e\xd9\x41\x41\xe0\x80\xc7\xeb\xe5\x39\x5b\x30\x48\xd2\x20\xf3\xf2\xb3\x05\x8b\x60\xf9\x4c\xae\x10\xa6\x0a\x8c\x59\xf0\x0b\x8c\x41\x10\x90\x9f\x94\xe8\x15\x7a\x90\x05\x79\x3c\x7e\xbf\xf3\x33\xd9\xff\x21\xd2\x7f\x26\x47\x49\x40\x09\x7d\x94\x52\x78\x91\x12\x45\xd5\x14\xbd\xbf\xab\xe7\xca\xa2\x75\x18\xc5\x6d\x68\x2d\x57\x49\x63\xa5\x5c\x68\xc7\xae\x6a\xe5\xd3\xac\x95\xb6\x83\xfb\x9e\xee\x54\x5a\x3e\xba\x77\xcf\x6e\x43\xf8\x15\x96\x3d\x0b\x16\x6f\x1e\x36\x72\xd4\x14\xe4\x9b\xb9\xf0\x9a\x65\xe5\xe6\x55\xb7\xf5\xea\xd2\xb1\x7b\x8f\x2e\xe6\xdb\xe6\xdc\x39\xbe\xcf\xed\x58\xb5\xae\xaa\x1f\x5f\xc6\x92\x98\xd7\x71\xcc\xda\x51\x5c\x5a\x7c\xb9\xb8\x6d\xc4\xc9\xc1\x8d\xd7\x5e\x50\xde\x62\x1f\x75\xfc\x90\xf9\x05\x51\xb9\x94\x3b\xd9\x8e\xd8\x06\xf2\x91\x5c\x48\xc9\x68\xb1\x08\xd8\x2e\xf1\x08\x1e\x7f\xa6\xdb\x6a\x15\x7c\xbc\xbd\x5c\x36\x20\xde\x05\x68\xb4\x4a\x75\xb1\xa6\xab\x34\xc4\x69\x81\x55\x92\xb0\x1a\x33\x56\xb3\xd9\x68\x36\xa8\xea\x74\x42\x9b\x19\x3d\x3b\xe5\xb3\x41\x0b\xb3\x58\xf6\xd4\x29\xa8\x5f\x72\xe2\x31\xde\x74\x20\xe3\x6a\xb4\x7d\xc1\x00\x65\x0d\x77\x3e\x76\x97\x72\xfe\x59\xac\xf1\xd5\x1e\x3f\xdb\x8c\xf0\xc5\x05\xca\x53\x6c\x3b\xac\xa3\x5a\xb1\x46\x61\xe5\x78\x9e\x31\x32\xd0\x08\x45\x89\xb5\x0a\xd6\x33\x50\x3c\x2d\xeb\x74\x50\x40\x3c\x24\xad\x03\x68\xf8\xba\x41\x15\x92\x14\xa6\x7f\xab\x97\x30\xe4\x44\xa7\x97\xbe\xb0\xec\xf0\x73\x2f\x1c\x65\x7a\xb2\x2f\xff\xf9\x1f\xde\xfa\xe7\x7f\xd0\x33\x8f\x3f\x74\xe4\xec\x3c\x62\x13\xc2\x1f\xe1\x41\xe6\x2a\x73\xc5\xc6\xeb\x5b\x51\x5b\xfb\x4e\xa5\x1b\x24\x73\xd7\xed\xa0\x2c\x1a\x12\x25\xc9\x2a\x08\xac\x01\xdf\x76\xe0\x70\x4a\xe6\x8d\xb2\x14\xb5\x88\xbd\x24\x49\x67\x65\x74\xeb\x64\x66\x0b\xe5\x8a\x85\xaa\x14\xd4\x78\x40\x4a\x3d\x43\x48\xf5\xa9\xd0\xb3\xd6\xb5\x8d\x90\x84\xf0\x6b\xca\xf7\xa5\xa1\xa2\x9c\x4d\x9d\x7a\x15\x08\x5d\x6e\xc9\x1f\x3b\x56\x51\x9e\x60\xc7\xf3\xc3\x9a\x34\x63\x4e\x4d\x40\x83\xd5\x5c\x81\x4c\x7c\xb7\x76\x71\x8b\x81\x00\x8a\xa3\x7e\x8b\x19\xf2\x46\x7c\xe7\x69\x19\xe6\x67\xb4\x0c\xf3\x7d\x52\x86\x99\x7a\xab\xd2\xca\x30\xd5\xa4\x08\x2c\x62\x8b\xb1\x4a\x82\xff\xbf\x13\x86\xa1\xc1\xbb\x77\xc4\x4d\x5b\x42\x73\xbf\x65\x22\xb7\x30\xe3\x8b\xba\xdc\x76\x63\x59\xcc\x7f\x0b\xe1\x37\x9f\x62\xbd\xe0\x6b\xac\x17\x98\xb0\x55\xd0\x22\x6a\x91\xa8\x7f\xdf\xed\x31\x58\x3f\x93\x0d\x58\xde\xd7\x20\x07\x56\x0a\xb0\x3e\xd0\x88\x93\xbf\x3e\xa7\x53\x7d\x8d\xe8\xeb\x57\x9e\x38\xf5\xf2\xab\xa7\x9f\xbe\xb0\x65\xce\xf4\xff\xcc\xbe\x63\xd6\x02\xd6\x76\xfa\xb5\x77\x1e\x3d\xf5\xda\xa5\xa7\xb7\x2d\x57\xae\xad\xdd\xb8\x8c\xbc\xf7\x16\x2c\xa3\xfb\x6a\x32\x7a\x58\xb4\x00\x1b\xdc\x58\xad\xd7\x21\x08\x8d\x66\xd1\x2a\x18\x04\x91\x4a\x69\x09\x8b\x6e\x51\xa7\x33\x23\x04\xac\x3c\xe0\xff\xa7\x94\x56\x73\x7b\xe2\x99\x0c\x61\x52\xbf\x12\x81\x78\x03\xb4\x5f\x98\xbf\x4e\xc2\x41\x0a\x96\x29\x83\x6a\xdf\xac\x21\xbf\x9d\x84\x03\xd6\x65\xc2\xa9\x70\x66\x50\x59\x57\xa6\x6c\x4a\xfc\xaa\xfa\x0b\x7c\x64\x82\x3f\xd7\x5d\xcc\xd7\x7f\xad\xfc\x06\x80\x98\xa7\xfb\x1e\x00\x49\xa7\xff\x0e\x6e\x8f\x9d\xc2\x72\xdb\x8d\x18\x87\x07\x31\xe5\x4e\x18\x75\xe2\xb7\x54\x8a\x50\x04\x59\x98\x86\xa4\x31\xc5\xf4\x9f\x31\xd8\xa6\x2c\x23\x76\x25\x86\x25\x61\x58\x27\x34\x58\xdf\xaa\xb0\x7e\x24\xb0\xbe\x81\x8f\xc4\x6a\xf0\x9d\xb5\x30\x76\x4f\x7d\x08\xf8\x61\xfa\xac\x89\xe2\x31\x10\x3f\xfb\x6d\x5d\x48\x7d\xd6\x9b\xc4\x23\x2b\x6a\x43\x4c\x33\x82\x47\x21\x8c\x16\xc2\x42\x10\x8d\x03\x48\xbc\x1f\xef\xf7\x0e\xe5\x23\xf6\x56\xb6\x94\xd6\xeb\xf4\x8a\x92\x62\x1d\x7d\x28\xe4\x91\xf0\x51\x03\x4f\x76\x58\xaf\x0f\xf9\x42\x59\x7b\x46\x85\xac\xf1\x82\x9d\x33\xb4\xba\x8a\xf2\xb8\xb2\xff\x5a\xb2\xd3\xb6\x0d\xe1\xda\x4c\xdb\x88\xc0\xa8\xd9\x20\x54\x0b\xe6\x89\xc8\x87\xce\x70\xf1\x8e\xc6\x2b\x76\x94\x5f\xaf\x7c\x54\x07\x98\x3b\xce\x0f\xb8\x71\xfa\xb8\x1b\x06\xa8\x05\x3b\x3d\x06\xa4\x14\xec\xb0\x3b\x2e\x5d\x52\xfd\x35\xec\x65\xfe\x90\x2d\x8f\x64\x5d\x49\x3a\x70\x43\xdd\xfd\xe0\x67\xe0\xac\x61\x04\x2e\x8f\x39\x53\x77\x7f\x8d\xd5\xc6\xea\x72\x61\x41\x31\xc0\xff\x24\xd6\x1f\x4e\xac\x9f\x0d\xc6\x80\x5f\x80\x3d\x6a\xa2\x0f\x8c\x11\xa4\xe4\x6a\xd0\xc8\x7a\x66\x05\xfe\x03\x75\xbd\x15\xaf\x07\x0e\xa1\xd1\xf5\x7b\x12\xeb\xf7\x24\xd6\x13\xf8\xc0\x93\xdb\xe8\xfa\x31\x09\x7c\x48\xf5\xd9\xa7\xc0\x1d\xb5\x20\xf2\x00\x62\x80\x4d\x54\x9f\x20\x8f\xa4\x3d\x53\xa9\x3d\xc3\x33\xbb\xd0\x50\xe0\x8a\x9a\x11\x13\x46\x88\x41\x71\x94\x92\xe7\x4a\xc2\xa3\x0f\x53\x7e\xe9\x04\x8b\xa3\x7d\x8d\x16\xab\x03\x4a\x0c\x66\x97\x88\x17\xf4\x66\xb3\xd3\x6a\xb5\x20\xcc\xd2\x5d\x0e\x58\x21\xeb\x4d\x15\x72\x50\x5f\xa8\x67\x88\x8b\xb4\x4c\x5f\xa1\x5f\xa0\x3f\xae\xff\x48\xaf\x0b\x22\x87\xde\xa1\xb7\xb2\x92\x8e\xd5\x55\xc8\x2c\xb2\x92\x5c\x46\xab\x0d\xc4\xd3\x66\x01\x35\x54\x35\x7b\x28\x5e\x70\x67\x2b\x4d\x16\x58\x96\x6a\x3f\xc4\xfa\x47\x61\x98\xac\x89\x08\x49\x61\x9e\x41\x21\x66\xb9\xf2\x68\xf5\x61\xf8\x05\xb3\x4b\x39\x0e\x7b\x2a\x8f\xc3\x79\xb1\xab\x37\xb2\xfd\x16\x43\x3f\xdc\xad\x4c\xe0\xba\x6f\x57\x06\x6d\x55\x0a\xb7\xb3\x27\x45\xa5\x56\xd9\x44\xf7\xe1\x0e\xa5\x1b\xa9\x75\xc1\xfb\x90\x47\xf7\x6e\x1e\x1c\x8f\xbf\xd7\x74\x0a\xfa\x7c\x6e\xb3\xba\xcd\x74\x1d\xad\xf1\xa0\x67\xd8\x44\xa3\x91\xc7\xf1\x99\x38\x6b\xa0\x99\xcb\x83\x67\xea\xf6\xd4\x58\x44\x60\x4c\xa1\x91\xfa\xeb\x67\x83\x51\xea\x19\xd2\x07\xca\xcc\xd6\xe4\xea\xc6\xe0\x6b\x34\x82\xe1\x5b\x28\xfc\xcf\x6a\x6c\xe6\x46\xe0\x8f\x49\xc0\x9f\x02\x1c\xf8\xcc\xbd\xa7\x18\x02\x9f\xc1\x4f\xfc\x51\x23\x0a\xea\x13\xea\xa9\xe3\x67\x68\x3d\x02\x7d\x47\x73\xed\x1b\x8e\xa7\x7e\xc3\x09\xf2\x0d\x30\xe5\x1d\xf5\xd7\xcf\x06\x37\xa7\x7c\xc3\xcd\xf8\x1b\x60\xda\x37\xd4\x5b\x9f\xa4\x73\xfa\x11\x00\x7f\x41\x63\xeb\xc7\x24\xe0\x27\xe8\x56\xfb\x08\x80\xbf\x00\xa6\xd2\x2d\xa6\x43\x9f\x56\xdf\x43\x02\x7c\xa3\xa3\x6d\xbc\x76\x8f\xd5\xaa\x67\xed\xd8\x22\xc9\xf0\x09\xbc\x8e\xaf\x90\x3d\x65\x44\x61\x25\x59\x4f\x67\x75\x3f\xe8\x38\x33\xd2\xe9\xb0\x64\x75\x57\x60\xfd\x82\xb5\x36\xa8\xb0\x22\xa4\x16\xa9\x6f\x5a\x52\x0a\xa3\x35\x41\xe1\xe2\x08\xa9\x0b\x82\x21\x52\x14\x24\xd1\xea\xa0\x50\xbc\x36\x68\xc5\x0a\xb5\x3a\x48\xc9\x54\x3e\x3a\xf0\xd6\xab\xef\xff\x30\x17\x86\xd4\x12\x21\x66\xe8\x16\x66\x94\x72\x5a\x91\x95\x9e\x58\xa9\x30\x42\xfd\x7f\x94\x2e\xda\x99\x35\xe3\xf7\xe2\xef\x6d\x9d\xb8\xd7\xbf\xd2\xfd\x11\xc8\xfe\x78\x72\x39\x73\xda\xfe\xd0\x3c\x7c\xba\x9f\x45\xda\x79\x3d\x44\xcf\x8b\x71\x51\xbe\xf4\x50\x8d\x3b\x83\x07\x29\xe7\x55\x7f\xfd\x6c\x30\x5e\xe3\x1b\xe4\x81\xf1\x2e\x6f\x72\x75\x63\xf0\x53\xf8\x92\x9b\xf0\x19\xbf\xab\xd1\xf5\x7b\x12\xeb\x93\x7c\x89\xc0\x07\x59\x2d\x1a\x5d\x3f\x26\x81\xcf\x14\x80\xe2\x7c\xc9\x45\xf8\x12\x93\xe1\x51\x9f\x48\x9c\x2f\x04\x7b\xc0\x27\x6c\x4b\x76\x06\x96\x45\x39\x51\x2b\x6b\x34\xea\x19\x32\x53\x50\x6f\xb6\xe8\xe0\x49\xe0\xad\x17\xf0\xc3\xf6\xbf\x01\xb6\x35\x40\xb7\x01\xea\x0c\x70\x0f\x1c\xaf\xec\x9b\x0c\xc7\xc2\xb1\x55\xca\x01\x58\x39\x49\xb9\x4f\xd9\x0d\x7b\xc3\xf1\xb0\xf2\x66\xe5\x3e\x58\x51\xa5\x1c\x54\xf6\x55\xc1\x71\xca\x1e\xe2\xf7\x69\x57\xf7\x1e\xbb\x91\x9b\x86\xf5\x2f\x1f\xc8\x06\x72\xb4\xc8\x15\x74\x07\x58\xbf\xc3\x66\xe5\xf4\x2c\xf0\xeb\x8c\x0e\x09\x18\x41\x38\xc7\x1d\x70\x05\xd9\x90\xd7\x12\xaa\x90\x39\xbd\xcd\xca\x22\xd1\xc2\x22\x6f\x85\xac\x66\xa2\xab\x71\x2e\x77\xa9\xe6\x7d\x4d\xda\x1a\x5a\x0f\x29\xad\x2c\x82\xfa\x59\x69\xd2\x3f\xf5\xbf\xa2\x36\xf9\x90\xd4\x4a\x43\x87\x1b\xe6\x85\xb3\x68\x8d\xc4\x7b\x0b\x67\x8d\x5d\x57\x01\xd9\xd8\xbf\x16\xce\x1c\xbb\xb6\xf2\x52\x40\x01\x03\xb6\xdf\xbf\x39\xb6\x31\xc0\x80\x7e\x3b\x94\x8b\x6a\xc5\xc4\xea\xdd\x5d\x9e\x3e\x86\xf5\xac\x81\xb0\x72\xf9\xee\x2e\x4f\x3e\xa4\x7c\x74\x70\x7a\x6c\xd0\x6a\xe8\x81\xc6\x07\x67\x32\x8f\x2c\x51\xf7\x9d\xe6\x8e\xd3\x73\x6d\xa7\xd1\xcd\x7d\xea\x3d\xb7\xd1\x7b\xbe\xaf\xc6\xee\x4a\xa3\x9b\xfa\xeb\x67\x83\x61\xda\xbd\x25\x0f\x0c\xb3\x39\xeb\x9d\x6b\xbd\xf5\x29\xf7\xdc\x4e\xe9\xd8\xd6\xe8\xfa\x31\x09\xf8\x29\xf7\xdc\x46\xef\xb9\xcb\x91\x4e\x07\xf8\x19\x9a\xff\x4c\xdf\xd1\x51\xc3\x69\xa2\xf6\x0e\x03\x7e\xc7\x44\x83\x99\xd5\x27\xdf\x91\x52\x2f\x62\xc1\xfa\x65\x49\xd4\x6f\x37\xf2\xd8\xa8\x03\x3a\xac\x77\x70\xf6\x4a\xd9\x68\xab\x94\x39\x23\x67\xe4\xb5\x8a\x11\x35\xca\x51\x3f\x83\x83\x56\x8c\x38\xb1\x5d\xe1\xa4\x35\x23\x71\x3f\x41\xc5\xcc\xab\x5b\x95\x7f\x9f\x3d\x0b\x2d\x3f\x40\xe6\xdc\xc1\x83\xbf\x29\x3b\x0e\x31\x35\x0b\x5f\x9c\xaa\x70\xdd\xbf\xf9\xf0\xf2\xf2\x2d\xb1\x73\xbb\x80\x9a\xb3\x7f\x8d\x5d\xcf\x5d\xc6\xb7\x7b\x58\xb4\x90\x0f\x9a\x9b\xdb\x3c\xf9\xb6\x7c\x10\xcc\x32\x63\x65\xab\x28\x62\x6e\xee\x41\x39\x28\xc7\x57\x2e\xe7\x80\x2c\x27\xc9\xa3\xaa\xe4\xa7\xf1\x0b\x79\x84\xed\x3d\x57\xc2\xde\x2b\x4b\xa3\xa5\x64\x26\x79\xa2\x52\xab\x10\x6a\x9e\xda\x3c\xcd\x51\x1b\x37\x67\x69\x06\x85\xda\x6f\x49\x47\xdb\x34\xb8\x03\x90\x5d\xff\xcc\xe1\x87\xa7\x31\xed\x77\x76\x1f\x3d\x7e\xd0\x84\xd1\xa3\x4a\x4b\xda\x17\x2f\xbf\x6d\xf3\x9a\x9a\x6f\xbe\x7c\xe6\x93\x3b\x7a\x36\xeb\x7a\xa7\x5c\x01\xf3\xb7\x3f\xd2\xfa\x60\x28\xa7\x62\xc0\x0d\x55\x9d\xda\xde\x33\xa8\xd3\x84\x16\xad\x86\x14\xf5\x1b\xb3\xef\x40\x2d\x62\xd1\xb5\x2f\xf6\xaf\x5c\x3d\xb1\xac\x63\x76\xb3\xee\xe5\x1d\xb7\xd2\xb3\xa1\xb9\xc2\x5c\x0d\x3e\x9b\x6e\x44\x77\x00\x37\x54\x03\xc2\x95\x5a\x49\x84\x2b\x4d\xab\x69\xdd\xc6\xca\xa4\x9d\x7f\xfd\xf5\xb3\xfb\x01\xca\x35\xc8\x03\x85\xad\x22\xc9\xd5\x0d\xd7\x32\x2b\xb0\x2a\xec\x3d\xcd\xb4\xc6\x4b\xb3\x4a\x30\xf1\xbe\x56\x53\xd2\x8a\x3e\x30\xa6\x3e\xfc\x23\x89\x67\xf6\xfc\x01\x40\x76\x54\xa0\xf0\x5b\xb5\x87\x59\xed\xa1\xd8\x1e\x3f\xfa\x5e\x4d\xfb\x9e\xea\xa3\x63\xb4\x87\x13\xcf\xce\x4f\xe0\x36\xe5\x47\x00\x02\x51\x23\x22\x0f\x23\x26\xab\x0d\x7e\xee\x8d\x9a\x36\x45\xda\x2b\x35\x02\x8d\x3f\xc7\x9b\x12\xef\xdc\x85\xdf\x49\x39\x5b\x84\x3c\x67\x2b\x69\x95\x11\x4c\xa1\x68\x04\x1c\x78\xfd\x19\xb6\x3f\xf5\x32\x77\x04\xab\xa2\xbd\xcd\xd9\xad\x4b\xf1\xb6\xb5\x6e\x6d\xcb\xf7\x67\x66\x36\xb5\xf1\x3a\x5d\x7b\x4c\x2d\x9d\x3a\x97\x78\xb3\xbc\xe5\x72\x29\x28\x97\x9d\xad\x07\xca\xa5\xce\x52\xa7\x35\x27\x3b\xcb\xea\x9f\xea\x67\x4c\xc8\xef\xcf\x12\x51\x73\x6b\xf3\x72\xd9\x6c\xb0\xd2\xdc\x53\xab\x4a\x3a\x5a\xb8\x44\x0b\x73\xa9\x05\xcc\x84\xc4\xff\x4b\xdb\xb6\x48\x3c\x5f\x0e\x3a\xb5\xda\x5b\x62\x56\x37\xc8\xc4\x26\x6e\x03\x12\x36\xb2\x49\x4e\x2e\xe9\x46\x65\x68\xde\x6a\x4b\xc8\x1c\xe2\x6a\xfa\xc8\xe2\xea\x6e\xbf\xcd\x5d\x95\xdd\x66\xcb\xb8\x45\x8b\x60\xef\x43\xd1\x5e\xbd\x6f\xd0\x1d\xb6\xef\x5a\x77\xa2\xe7\xd0\xfd\x0f\x1e\xa9\xe5\x4a\x4b\xa3\x95\x25\xf3\x06\x0c\x6c\xc9\xec\x1d\x34\x06\xc1\x2a\xc3\x08\xf8\xbb\xa4\xac\x1b\xdb\xab\x45\x1d\xb8\x7d\xde\xbc\xdb\x0f\xee\xa5\x99\xda\x2b\xa6\x0e\x1c\x25\x6d\x5b\xb7\x66\x8d\xf2\xb9\xf2\xbe\xe7\xf2\xa0\x09\xf2\xb6\x11\x24\x59\x7b\x02\xd3\xef\xd8\xce\x87\xf7\x90\x3d\x5f\x8c\x75\xb5\x76\x6c\x7f\xbc\xe7\x3d\x34\x5d\x6d\xa0\xaa\xab\x85\x82\x3e\xe0\x48\xea\x6a\x6a\xef\x0f\x42\x43\xbd\x54\xfa\x7c\x94\xd2\xa7\x8f\xd2\xe7\xc9\x1a\x7f\xd0\x62\x4f\xa3\xcf\xfa\xeb\x67\x4f\x55\xe9\x93\x3c\x30\xd5\x17\x48\xae\x6e\xb8\x96\x59\xa1\x53\xd7\xfa\xf1\x5a\x5d\xc8\xd7\xc8\xda\xf9\x09\xb8\x53\xf4\x1a\x8d\xf8\x08\x8d\xe8\x83\x99\xea\xea\x84\x7e\xa6\xe6\x7c\x12\xd8\x3f\xab\x78\x3f\x4d\x68\xd1\x04\x8d\x52\x1e\xac\x34\xc1\x72\x13\x26\xc6\x23\x35\x26\x01\x41\x4a\xc4\x09\x1a\xae\xff\xdc\xec\xc9\x14\x27\xfa\xdc\x10\xa3\x05\xa5\xea\x74\xf5\xd6\x32\x2b\x8c\xf4\xae\x40\x13\x79\x87\x08\xcb\x45\xd8\x4a\xc4\xaf\xf9\xad\x46\x34\x6a\xaf\xa9\xff\x9e\xf9\x89\xf7\x4c\x69\x0a\x40\x61\x34\xc8\x90\x17\x31\xf0\x5e\x01\x2e\x14\xe0\x34\x01\x56\x0a\xb0\x5c\x80\x18\x26\x10\xcc\xbc\x41\x85\x31\x66\x4c\xe2\xf2\x30\xe0\x6e\xbc\x2f\xfd\xb9\x7f\x82\x0c\xac\x73\x2f\x88\xf6\x66\x75\x66\x2b\x2b\xf0\x02\x2f\x79\x18\x9f\x4f\x0a\x79\x3c\x52\x7e\x13\x0b\x9b\xc9\xb6\x60\x11\x63\xb6\x99\xb3\xcd\xc8\xca\x9a\x75\x56\x96\xe5\x2c\x20\x50\x2e\x93\xa2\x0a\x11\x30\xa4\x1a\x82\x03\x06\xa7\x33\x87\x24\x27\x09\x16\x8b\x81\x36\x26\x8b\xa4\x85\x55\x68\xa5\xa9\xda\xab\x6e\x4c\x7a\x6a\x65\x5c\x3e\x17\xb9\xf3\xf2\x39\x2c\x9e\x49\xe6\x59\xae\x5b\x07\x24\x27\x4d\x2a\xac\xd7\xa2\x8f\x99\xb0\x6a\xec\xd0\x15\x4a\x6d\xdb\xf7\x6e\x5b\xf6\x7a\xf9\x48\xa8\x6f\xfb\x26\xec\x73\xfd\xb7\x2f\xff\xf8\x83\xf1\xaf\xdb\xbd\x67\xc3\xbd\x1b\xf6\x6f\x41\x6f\x76\x38\x3f\x6f\xc6\xed\x63\x87\xf7\xcc\xe9\x3a\xfd\xd6\xd1\xca\x9b\x4a\x88\x57\xae\x2b\x3f\x43\xe6\xe7\x5f\x14\x45\x38\x77\xf4\xd8\xd9\x67\x4e\x1e\xc7\xfb\x48\xf3\x2c\x29\xbf\x1a\xa8\xf2\x2b\xa3\x7a\x5e\x5e\x7c\x06\x86\x70\x2b\xb3\x3b\xe5\xbc\x68\x5e\x24\x3d\xaf\x41\x2a\x4d\x3c\x41\x69\xd9\x43\x69\xf9\xc9\x1a\xaf\xbf\x9e\xac\xad\xbf\x7e\xf6\x44\x95\x3e\xc9\x03\x13\x3d\xbe\x34\xb9\x5f\x6f\x2d\x95\xe3\x64\x2d\xc6\x83\x01\x01\x4f\x23\x6b\x8f\x24\xd6\xee\x01\x49\xb8\x20\xbb\xb0\x91\xb5\xf3\x13\x38\x10\x79\x4f\xe9\xde\x43\xe8\x1e\xf8\x33\xd2\xa4\x3d\x02\x33\xc1\x47\xec\x70\x76\x16\x8d\xef\x99\xc0\xd0\x68\xb1\x89\xd1\x93\x66\x2c\x1c\xcf\x59\xcc\x7a\xc3\x31\x99\xd5\x0b\xa3\x20\x87\x09\xea\x98\x6c\x85\x50\xad\x65\x3f\x0e\x7f\x80\x75\x90\xc7\xd4\xcd\x25\xfa\xc3\x81\x84\xff\xb9\x9e\xf5\xa8\x06\x00\x69\xbf\x36\x12\x04\x94\x0e\xc7\x9e\x44\xd7\x62\x4f\x1c\x46\xcf\x9c\x3e\xad\x1c\xd8\xb8\x51\x59\x70\x9a\xe6\x7a\x23\x70\x3b\xc6\x7d\x0c\xe6\xd3\x44\x2f\x24\x9d\x73\x8a\x1b\xd5\x0b\x73\x72\x83\xae\x80\x9b\xf5\x86\x2c\xa1\x72\x55\x2f\xb4\x90\xf2\x35\x11\x61\xce\x1d\x97\xe6\x6a\x6a\xa1\xf4\xff\xa9\x1d\x16\x27\xb4\x43\x9d\xaa\x1d\x96\xe4\x52\xed\x30\x9b\x67\xc7\x28\xb5\x7f\x5c\x5e\xd0\xaf\xef\x90\x9b\x20\xfc\xe3\xed\x79\xbd\xfa\x97\x8f\x7b\x3a\xa4\xa0\x7e\xf7\x1e\xde\x11\x5b\x93\x0d\x63\x7d\xb6\x1c\xdc\xc5\x04\x94\x1f\x95\x0f\x6f\x19\xde\xad\xa2\xfa\x3b\x28\xc2\xac\x09\x83\xba\x8d\x5c\xf5\xfb\xa6\x8a\xd8\xb9\x8a\xb7\xff\xb9\x71\x34\x13\x95\xdf\x55\xe9\x83\xe6\xf8\xd1\x33\x1f\xa1\xd2\xd3\x01\x42\x4f\x30\x43\x22\x9a\xe1\xee\x1a\x5f\xc0\x93\x6e\x83\xd4\x5f\x3f\x7b\xa4\x4a\xab\xe4\x81\x21\x19\x99\xc9\xd5\x0d\xd7\x52\x7a\xc2\xb0\x7d\x14\xf6\x5f\x35\x59\x19\x8d\xc2\x9e\x9f\x80\x4d\xe8\x84\x58\xb0\x19\x12\xb5\x60\xff\xaa\x09\xf8\xd5\x27\x52\xf4\x42\x9a\x83\x46\xdf\x31\x5a\xc5\xe7\x16\x15\x1f\x27\x7e\xc9\x2d\x4e\x8f\x51\x4a\xbc\x81\x01\x8f\x93\xbc\x5e\x9a\x53\x9e\x05\x3a\x47\x83\x99\x7c\x46\x86\x0f\xd8\x7c\xb6\x50\xb6\x1f\x5b\x8b\x2e\x87\x03\xab\x60\x0e\x97\xd9\x6a\x45\xe5\xb2\x55\x4c\x0b\x1d\xa4\xd4\x9e\xa8\xba\x61\x0a\x2f\x80\x34\xb1\x57\x4a\xe6\xfb\x92\x1c\x7f\xb4\x32\x9e\xc8\x1b\xfb\x92\x26\xf6\x6a\xa9\xbe\x35\x2c\x93\xad\xe5\xf0\x32\xfd\xd4\x94\x5e\x2d\xcf\x57\x37\x8b\xd4\xfb\x24\xbf\x69\x7e\xe2\x9b\xa6\x70\x40\xd5\x8e\x9d\x64\x23\x38\xaf\x5b\xfd\xaa\x84\x9c\x50\x7d\x37\x63\x13\xfe\xa1\xd5\x80\x81\xa6\xa4\x7f\xc8\x5a\xdf\x9f\xa4\xea\x38\x83\x13\xba\xca\xea\xab\x29\xfa\xda\x2f\x35\xad\x35\x5d\xa5\x9e\x3f\xe9\x48\x02\xfe\x8e\xb8\x9d\xaa\xc2\x97\xbc\x8d\xc2\x4f\xea\x6c\x3b\xbe\x4b\xea\x77\xba\x48\x87\x24\x74\x02\x5b\xa9\x64\x3f\xe2\xba\x27\x60\xef\x86\x17\xf1\xf9\x98\x4e\x31\x36\x52\x89\x9f\x94\xe1\x0b\x95\xa1\xa4\x1e\x4d\x83\x49\xd6\xdd\x81\xff\x83\xf0\x38\x60\xea\x9e\xab\x29\x2d\x65\xa8\xce\x48\xfc\x37\xa4\x57\x09\xb5\x13\xf2\x34\x3b\x61\xa9\x66\x27\x60\x1b\x16\xce\x76\x67\x98\x75\x0d\xf8\x63\x3b\x8a\x6b\x0f\x95\x7e\x26\xa9\xf4\x43\x88\x14\xcb\x7a\x4d\x8d\x50\x71\x55\x61\x1f\x89\xc3\xc6\xf4\xec\xd0\xec\x75\x0f\x86\xcd\x67\xba\xff\x1e\x76\x9c\x9f\x42\x3f\xe1\xeb\x21\x5f\x23\xb0\x27\x25\x60\xef\x04\x01\xb0\x33\x81\xb7\xe4\xf6\x36\x0a\xfb\x72\x02\xf6\x4e\x47\x12\xef\x80\x2f\xf3\x6f\xf1\x5e\x09\x24\x0d\x6f\x02\x1b\x79\x83\xff\x03\xef\x95\xb5\x49\xd8\x5c\x66\x38\x0d\x36\xed\xaf\x42\x61\xe7\xab\xb0\xeb\xae\x61\xd8\x98\x9a\x6c\xd4\x27\x71\xa1\xc6\x91\xc1\x26\x25\x12\x02\xc1\xba\x2f\xd8\x2b\xf8\x0e\x92\xdc\xfa\xa6\x60\x78\xd4\xd5\x34\x27\x27\x2f\x3f\xbf\xc0\xc3\x07\x80\xd5\x2a\xf2\x62\xb3\x02\x87\x33\xaf\xe9\x19\x68\x8e\xda\xe5\xbc\x3c\x2b\x30\x60\x8e\x6a\x31\x88\xc8\xd7\xa0\x1c\x4c\x65\xa9\x69\x99\x68\x91\x7a\xa5\x61\x6a\x71\x50\xe3\xb5\x61\xb0\xd8\x1e\x71\x22\x66\x5b\xeb\x65\xe3\x1e\x3a\xfd\xd4\x03\xe3\x97\xc6\x2b\xc4\x94\xce\x63\xaa\xa6\xae\x5a\x36\xfd\xe6\x4a\xe6\xd3\x01\x2f\x3c\x4c\xca\xc4\xc2\xd0\x04\x2d\xb0\x69\x7a\xa1\xd8\xbf\x5e\xfb\xf1\xd2\xd3\x1f\xbe\x06\x37\x86\x60\x4e\xae\xf2\x71\xd2\x77\x3f\x11\xd3\x33\x0f\x36\x82\x78\xad\xdb\x56\xfc\xbd\x01\xd0\x0c\x4c\x88\xe6\xeb\x5c\xb9\x28\x23\x03\xf8\x82\x82\xe0\x2b\x68\x8e\xad\x51\xf7\x40\x99\x06\xfe\x18\x3b\xf2\x78\xc4\x0c\x20\x36\x29\x97\xed\x22\x29\xdd\x13\x0c\xe6\x5e\xa2\xd5\x94\x5d\x2e\xeb\x4c\x2e\xd6\x19\x2f\x28\x2a\xa0\xff\x56\x7b\x39\xd6\x77\x54\xb9\xd5\xd4\x6b\xfa\xa9\xe1\xb4\xea\xb8\x62\x52\xd9\x15\x71\x62\x99\x97\xb2\x03\xac\x9d\x7c\x2e\x97\x5a\x22\xa7\xbc\x05\x9b\xd7\x2c\xa9\x3d\x36\x7b\xc5\xa6\x35\xcb\xb6\x2d\x9f\xcb\x3e\x52\x1b\xa1\x9f\x8b\x37\xc1\x0a\x45\xa6\x00\x6f\xc1\x9e\x25\x7b\xf6\x2c\x89\x55\xbc\x7b\xfe\xd5\xab\x57\x9e\x7b\x39\xe1\x7b\x1c\x9b\xf0\x55\xae\x06\x36\xcc\x7f\x12\x7e\xc4\x5f\x6b\x2c\xe9\xbe\x4a\x55\x0f\x1e\x9c\xd0\x99\x57\x33\x49\xfd\x1a\xfa\xd3\x75\x66\x15\xf6\x91\x04\x6c\x95\xf7\x24\x60\x7f\x56\x63\x75\x37\x02\x3b\xa9\x8f\xef\x60\x93\xb0\xd9\x40\x5e\x23\xb0\x27\x25\x60\xef\xc4\xb0\x77\x26\x61\x7f\x5e\x63\x16\x1a\x81\xfd\x46\x02\xf6\x4e\x86\x4f\xc0\x46\xbe\xcc\x74\xd8\x98\x5f\x8d\xa7\x7c\xad\x89\xc6\xaf\xfa\xa8\xfc\x0a\x62\x7e\xe5\x74\x1a\x8d\x1a\xbf\x5a\x86\xd7\xf5\xa0\x7c\x4d\x85\xb9\xbb\xb3\xca\xd5\x94\xef\x6b\x72\x72\x74\x9a\xc3\xb9\x91\x7d\x58\x59\x7f\x1f\x04\xc7\xdf\xee\xc3\xca\x3f\x53\x6c\x9e\xbf\x6a\x32\xc3\xf5\x6c\x1e\xda\xb3\x87\xc2\x6f\x96\xf0\xe1\xa8\x3c\xc2\x47\x78\x5b\x56\x06\x97\xee\x9f\xa6\x75\x7e\x14\x7e\x6f\x95\xb7\xfd\xae\xee\x33\x31\xcc\xf9\x92\x56\x92\xbf\x1e\xff\x49\x85\xbd\x03\xf3\x01\x15\x76\x06\x86\x6d\xc8\xcc\xfd\x1f\xb0\x77\xfc\x9e\x94\x1f\x7c\xa4\x43\x23\xb0\x27\x25\x60\xef\xc4\xda\xd8\xce\x04\x6c\x29\xc3\xdf\x28\xec\xcb\x09\xd8\x3b\x53\x60\xeb\x5a\x15\xa5\xc3\x56\x64\xd2\xc7\x48\x83\xcd\xeb\x3f\x57\xad\x4b\x2e\x23\x53\x03\x1a\x87\xc7\x83\x38\x3c\xfd\x97\x75\x2a\xbc\x22\x0c\xcf\x12\x49\xdf\x07\xd5\xdf\x4b\xf6\xa1\xa0\xde\x1e\x6b\xfe\x70\xd6\x98\xe6\xc3\xa2\x75\x86\xfc\x11\x2c\x65\x02\x98\x53\xb6\xa4\x95\x86\x81\x4c\x8f\xc7\xe7\x76\xb9\x32\x7c\x26\xa3\xd1\xe7\x40\xc1\x2c\xb5\xe4\x50\x07\x1c\x46\x67\xc0\x53\x2d\xbb\x03\x6b\xe5\x0c\x37\xe9\x21\xf4\x6a\x51\x41\x22\xef\x3e\xad\xdc\x3a\x11\x42\xf9\x6f\x05\x89\xd0\x19\xce\x0f\xeb\xc2\xc5\x6d\x23\xe9\xa5\x89\xcc\x1f\x55\x57\x99\x2f\x27\x2b\x07\xb9\xee\xca\x0b\x6a\x8d\xe2\x2d\xcc\x7c\x5a\xc0\x75\x89\x7b\xdc\xb1\x66\x8d\x83\xb4\x64\x24\x5d\xd8\xd8\x97\xb8\xee\x58\x67\xa6\x5d\x1e\x1c\xac\xd9\x8d\xac\x56\x20\x9a\x75\x26\xd1\xe4\xf1\xba\x85\x0a\xd9\x65\xb4\xd9\x6d\x95\xb2\x0e\xd9\xcb\xdd\x70\x9f\xfb\x84\x9b\x71\xdb\xdd\x76\x28\x9a\x6c\x5c\xbc\x7b\x02\xf1\x57\x24\x7b\xf3\x37\xd6\x54\xd5\xae\x25\xf1\x45\x9c\x34\xa1\x87\x84\xdf\x8b\x89\x4e\x7f\x80\x74\x5f\xda\xb7\xef\x6c\xec\xb7\xb3\xfb\x50\x55\xec\x37\x76\xd1\xf3\xf8\xaf\xcd\xb5\x76\xd2\x91\x09\x7d\xb7\x59\xa9\xfe\xf0\x43\xe2\x9f\x2b\xd6\xea\x38\xfd\x60\x74\xb4\xa9\x9e\x71\xbb\x3d\x56\x41\xc0\x3a\xa6\x27\x33\xe0\x11\x9c\x5c\x86\x2f\x63\xa0\x8c\x2d\x50\x60\x32\xd9\xb1\xf0\x31\xc1\x8f\x4d\x3f\x9a\x18\x93\xd6\xf8\xda\x64\x25\x09\x98\x65\x05\xb4\x19\x14\x89\x1c\xc4\xfd\x2d\xc9\x66\x66\x89\x2d\xa6\x99\xa9\x0d\xb7\x99\x44\x13\x1e\x7f\x8c\x34\x89\x4c\xdd\xe4\xa5\x4b\xb9\xcb\x7b\x96\x2c\x55\xb7\xb7\x1f\xb3\x83\x6e\xef\xc3\x2c\x71\xe6\x26\x62\x24\x7b\x13\x31\x95\x3d\xf8\x3b\x7e\x4d\xc4\x60\xa0\x2b\x5c\x2f\xa6\xa2\xda\xe8\x47\x12\xf6\xfd\x1e\x55\x07\x37\x52\x1d\xfc\xdb\x1a\x47\x08\x35\x16\x83\x19\x9b\x80\x9f\xd0\x25\x55\xf8\x96\xfa\x31\x1b\x15\xfe\xe0\x04\xfc\xd5\xfa\x14\xf8\x3f\xd7\x98\x8c\x8d\xc2\x4f\xc6\x84\x76\x24\x7c\xc5\x04\x3e\xc0\xdc\xbc\x31\xf8\x49\xff\xc4\x0e\x47\xd2\x97\x01\x2c\xce\x34\x5f\xc6\x4b\x98\x97\x42\xca\x73\x9b\xab\xbc\xd4\x82\x79\xe9\x69\x6c\x20\x4a\x71\xac\x35\xbf\x05\x5e\x37\x91\xf2\x80\xbe\xea\xba\x76\x64\x1d\xc3\xe4\xd9\x05\x94\xba\x4e\xc5\x75\x52\x02\x57\x55\x3e\x24\xf6\xc2\x2c\xa4\xe2\x8a\xcf\x81\xe2\x4a\x6b\x50\x12\xf5\xa3\x26\xe3\x7f\x29\xcc\x6d\xbc\x7e\x34\xa5\x1a\x57\xad\xc5\xa5\x7c\x60\x3c\xe6\x71\xcb\xf0\x7d\x22\x25\x3c\x1d\xa2\x01\x06\xd9\x6d\x3a\xb3\xd9\x86\x90\xcb\x6d\xb7\x5b\xad\xa4\x9d\x9b\xdd\x48\xda\xc6\x19\x11\xb2\x25\xf4\x84\x78\x13\xc3\x64\xd7\x38\x7c\xd7\xc3\xb9\x5a\x1d\xae\x94\xc8\xf2\x1d\x7f\xf6\x2c\xb3\x77\x72\x85\xf2\x1f\xf8\xca\x4b\x4f\x1d\x7e\x3c\xf7\x09\xc7\xcd\xa4\x7d\xe1\x8a\xf5\xab\x91\x61\x77\x6d\xc5\x9b\x9f\x1f\x7d\x21\xb8\x68\x16\xc9\xf1\xfb\xa7\x56\x03\x43\xec\x72\x17\xc8\x00\xbd\xa2\x4d\x30\xe3\x61\x18\xe4\xce\xc8\x70\x19\x45\xfc\x76\x9f\xdf\x82\xaf\x8a\xc5\xe7\xe1\xdc\xad\xd8\x4a\x96\x59\xc8\x42\x16\xc5\xcb\xc4\xf0\x6d\xd6\xdc\x31\xa9\x13\x02\xe2\x88\x91\x89\x23\x5c\x44\x4a\xad\x17\x26\x7f\xf4\xdd\x3f\x6a\x1c\x17\xe1\xeb\x35\x89\x8a\x61\xc7\x45\xb6\xfd\xf5\x0b\x9c\xf9\xdc\xb9\x37\xae\x3f\x14\xaf\x1b\xe6\x72\x69\xcd\x32\x3e\xb3\x13\x78\xaf\x9a\x52\x1e\xdb\x42\xe3\xb1\x73\xb4\xfb\x41\x62\x17\x3b\xdc\x52\x3d\xff\xc8\x2c\xfc\x4d\x1e\x42\x5f\xfa\xaf\x48\x85\x06\xb3\xe2\x66\x2d\xfe\x8a\x79\xff\xcb\x94\x96\x5a\x26\x78\x3f\x95\xde\xc7\x6b\xcc\x56\xd6\x94\x90\xcb\xdf\xe2\x75\x2a\x2d\xf5\x4f\x5f\xf7\x74\xca\xba\x78\x3d\xb3\x56\xa7\x95\xac\x67\xc6\xac\xc5\xc0\xa2\x44\x41\x33\x67\xd5\xea\x99\x23\x89\x7a\xe6\x64\x0e\xff\xff\x2a\x67\xfe\x7e\xbc\x32\x93\x6d\x1f\xfb\x82\xc9\xa0\xe5\xcc\x18\x37\xda\x13\x8d\xee\x45\xa1\x6a\x0b\xd5\xed\x55\x75\x06\x9e\xea\x0c\x93\x6b\x78\x03\x60\x53\xec\x63\x5a\xff\x8c\xe5\x8d\x01\x9f\x57\xcf\x68\x8e\xd9\x62\xb1\x1a\x8d\x9c\x4a\xc8\x92\x68\x35\xaf\x95\xad\xfa\x28\xa5\x67\xd4\xb0\xd0\x3c\xc3\x23\xbe\x5a\x90\xd6\xac\x2e\x52\xbf\xdc\x9c\xa4\x81\xa5\x96\x48\xbf\x42\x32\xc2\x48\x9d\x74\xd3\xea\x4a\xc7\x8f\x99\xff\xa6\x38\xe3\xfd\xec\x4b\xf7\xbd\x50\xdd\x4f\xa3\xb6\x9f\x6f\x26\xb1\x25\xeb\x96\xe3\x75\xa3\xe9\xbe\x0f\x48\xdf\xf7\x5f\x6a\x12\x1e\xce\xc4\x1e\x24\xe0\xe9\xf4\x9f\xc3\xe6\xdc\x21\x60\x8b\x1a\xa1\x1e\xc1\x5f\x12\x20\xcb\x88\x2e\x36\x94\xd6\x98\x5c\x16\x31\xcc\x2b\x64\xed\xbf\xe1\x41\x0c\xd5\xf1\x0f\x88\xd9\xc7\x19\x78\x29\x09\xb8\xac\x51\xd8\x98\x3f\xec\x8e\x0d\x21\x1a\xc2\x24\x5e\x1f\x47\x95\xe2\x8a\xd7\xdd\x92\xc0\x15\xaf\x83\xfb\xf0\x3a\xe9\x51\x88\xa1\x6e\xad\x31\x9a\x93\x4c\x07\xd2\x99\x38\x7d\x69\xdc\xaa\x17\xb6\x16\x4c\x26\x96\xb4\xa7\xb7\x1a\x10\x34\xb2\x3a\x96\xb1\xea\x49\x1e\x05\xb2\x22\x3d\xa3\x67\x00\x87\x68\xbb\x40\x2d\x80\x4d\x05\x26\x36\x0a\xc8\x90\x9a\x48\x6a\x15\x68\x44\xd2\xe5\xb7\xc5\x07\x92\xeb\xe6\x48\xe3\xbb\x59\x5d\x4f\x9f\x85\x39\x9d\x94\xfb\x98\x7d\xf0\xa5\x4e\x73\x2b\x99\x8f\x62\x4b\xb7\xcd\x7d\x5c\xb9\x9d\xf6\x99\x8a\xd7\xc0\x4b\x60\x40\xb4\x19\x07\x58\xbd\x85\x45\x06\x83\xcd\x6e\x44\x16\xc0\x9a\x68\x7d\x0d\xb6\x85\x4c\xa2\x4e\xc4\x6a\x87\x08\x48\xe7\x42\x6c\xa0\xa4\xf2\xb5\x84\xaf\x55\xeb\x7f\xa4\xa6\x31\x63\xc3\xa4\x2d\x7d\x3f\xa1\x06\x5d\x7e\xae\x5a\x2e\xff\x49\x67\xe5\x13\x95\x1e\xde\x8b\xc2\x0c\xe5\x28\xa3\x43\x33\x17\xdd\x71\x30\x76\xac\xba\x1a\x7e\x37\x7f\xda\x7d\x4c\x61\x75\x9a\xde\xd4\x5a\xb3\xe9\xe7\xa5\xc4\xc9\xe7\x09\x52\xbd\x38\xb9\xea\x4f\xad\xd1\xfc\xa9\x64\xfd\x2a\x90\xf4\xa8\xae\xf2\xfa\x93\x1e\xd5\xc4\x5d\x6f\x46\xcf\xb1\xb5\x4a\x4b\x9f\x68\xb4\xf4\x71\x4d\x02\x36\x85\x8b\xd7\x79\xa9\xae\x3e\x50\x5d\xf7\xb9\xb6\xee\xb3\x9a\x04\x4c\xd0\x10\x5f\xac\xab\xf3\x29\xf8\xf2\xa2\xeb\x6f\xf1\xe5\xa9\x6e\x1f\xc7\x16\xf8\x42\x69\xfe\x5f\x0e\xaf\x5d\xcc\xf5\xc0\x34\x3a\xb0\x8a\xd2\xb3\xd2\x8c\x3b\x0c\x3c\xa7\xa0\x0f\x41\xac\x5c\x9c\x89\x9d\x8b\xe3\xa2\xe5\x71\x91\x3a\x7e\xcc\x13\x87\x72\x23\xb1\xc5\x7d\x43\x34\x5b\xc7\xf3\x96\x80\xd3\x89\x45\xa3\xcb\x95\x93\x1b\x08\x85\xa4\x4a\x39\xc4\x7a\x91\xcb\x56\xbf\x2b\x64\xb2\xae\x57\x2b\xb2\x49\x74\xaf\x4b\xa9\x0f\x69\x58\xe8\x1f\xca\x92\xd8\xa1\x07\x1e\x1d\xbd\xa4\xf3\x92\x82\x1e\x2d\x07\xf4\x9e\x79\xd7\xba\x53\xf1\x8a\xff\x29\xd0\x03\x6f\x61\x02\xca\x9b\xca\xf5\x32\x79\x42\xc7\xfc\xa7\x3e\x81\xfb\x57\x2d\x39\xbd\xa3\x76\x11\x5b\xa1\xd5\xff\x2b\x4b\x54\x9c\x31\x5f\x26\xbd\x07\x48\x27\x9e\x40\xc0\x61\x21\xe3\x8e\x1c\x5e\x94\x1d\x76\xfb\xca\x65\xb7\xcf\x22\x8a\xa4\x54\x4d\xd4\x5b\xb9\x44\x05\x79\xb2\xd3\x5e\xbc\xa2\xb2\x61\x03\x02\x22\x5e\xf2\x8b\xdd\x2a\xe2\xcc\xca\xf4\x5e\x04\x73\xe6\xf6\x2b\xea\xdc\xbd\x5d\x15\x3a\x5f\xaf\x23\x41\xed\x91\x6d\x6b\x0d\x6b\xf8\x5e\x93\x51\xf6\xca\xa5\xa9\xb9\x0c\x63\x13\xb9\x0f\x49\x9f\x1b\xcd\x7d\x70\xd7\xcf\x95\x50\x7d\xe0\x83\x13\xfe\xf2\xb8\xcd\x4b\xfc\xe5\xd0\xeb\x69\x24\x6f\xe3\x48\x02\x76\xd2\xdf\x46\x61\x7b\x43\x7f\xef\xe3\xa7\xeb\x13\xbe\x78\x5f\xf8\xef\x72\x42\x98\xbd\xb0\x05\xd6\xbf\x92\x39\x18\x15\x7e\x6f\x83\xd8\x3b\x81\x3f\x38\x01\x9f\x3c\x13\x4d\xf3\xe0\x4f\x0f\xf8\xea\xe5\x6d\x30\xc0\x51\x77\x9d\x7d\x81\xeb\x83\x6d\x97\x20\x98\x1b\xed\x2d\x9a\xdd\x99\x9c\x60\xb3\xb9\xcd\x76\xbb\x9b\x43\x59\x21\x41\xc2\x5a\x8b\x30\x40\xa8\x10\x50\x99\x40\x12\xa1\xd7\x0b\xf7\x09\xc7\x85\x8f\x04\x9d\x55\x38\x2b\x30\x66\x52\x6c\xed\x70\xda\x1d\xf6\x0a\x99\x61\x1c\xb6\x0c\xb3\xc9\x5c\x21\xeb\xf5\x26\x94\x5a\xc0\xa7\xa5\x88\xa9\x59\x3b\xd3\xd3\x5b\xec\xd0\x00\x79\x88\x8f\x4f\x2c\x71\x27\x93\xc3\x72\x8b\xda\x4a\x79\xea\x9f\x33\xe3\x4a\x9b\xd6\x7d\xfb\x1d\x04\xed\x23\x4c\x4b\x65\x3a\xe9\xe5\x05\x4f\xc7\x3a\xf4\xf2\xe7\x75\xba\x7f\xcb\x4e\x0e\x0e\x82\xa3\xe1\x58\xd8\x8d\xdf\xae\xf4\xda\xaa\x94\x6e\x5f\xcb\xb3\x21\xbe\x0e\x28\x3f\x2a\xdf\x91\xc4\x4c\xe2\xcf\xf2\xe3\xbd\xa9\xa1\xfd\x98\x72\xb1\x96\x38\x35\xda\xc1\xe4\xf4\x35\x05\xc0\xe7\xf3\x86\x48\x9f\xe4\x66\x5e\xd1\xdb\xa2\x65\x53\x4c\xab\x4d\x9b\x5a\xec\x79\x01\x7b\x00\x53\xaf\xd3\x2e\xa2\xb0\x25\x5c\x2e\x9b\x0c\x96\x64\xd3\x20\x8b\xd6\x34\x28\x19\xb9\x8d\x24\xbe\xaf\x5e\x1f\xdc\x84\x3a\x10\x2f\x00\x22\x2d\xa7\xf8\xb8\xc7\xcb\x8d\xcd\x0c\xc9\x99\xab\x5e\x4c\xd2\x9a\x3b\x1e\x9e\xbd\x38\x7c\x60\x97\xfe\xc2\xea\xb2\x2f\x4e\x0d\x1c\x7c\x7a\xcf\xe1\x87\x0e\x3c\x39\x60\xe8\x31\x58\x16\xbb\x65\xc0\xa8\x51\x43\x1f\x1a\x3b\x08\xf6\xed\x35\x0c\xc1\x6e\xfa\x72\xf8\xfb\xd3\x2f\xd2\x78\xec\xe9\xd3\x30\x04\x25\xd2\x21\xe3\xd1\x47\x63\xcf\x7a\xf2\xaf\xbe\xf6\xda\x55\x65\xf0\xeb\xcc\x8a\xa3\xbb\x1e\xde\x93\xe0\x75\x3b\x28\xad\x16\x6b\xbc\xb6\x57\x0a\xad\x8a\x2e\x2f\x6b\x49\xa3\x55\xda\x0f\x82\xd2\xd2\x50\xd5\xdf\x2a\xab\xbc\xce\x85\x79\x5d\x07\x97\xd7\x04\xd2\x7c\x28\x32\xe9\x5f\xa9\xc1\xc6\xfc\x36\xa6\x79\x7c\x5f\xa8\x49\xc0\x25\xeb\x5e\xc6\xeb\x9c\x94\x2f\x0f\x55\x65\xbc\xf2\xa3\xa6\x0d\x28\x6f\xd4\xc4\x61\x36\xc4\x95\x59\x59\xf7\x9d\xea\xab\x54\xf3\xa7\x4e\xd5\x78\x02\x49\x6c\x1b\xe2\xca\xac\x74\x50\xdb\xc6\x45\x6d\x9b\xdf\xf1\x6a\x53\xfa\x3d\xa4\xfd\x2b\x29\xfc\x12\x6d\x2f\xe2\xba\x67\x0b\xcc\xf7\x17\xb7\x68\xc5\xa5\xaf\xa7\x7d\x2a\x28\xfc\x61\xea\x5e\x0c\x53\xf7\x22\x1f\xbf\x60\x58\x7e\xb3\xb4\x7b\x5b\x0f\x36\xd6\x6b\x59\x0d\x76\x4b\x0c\x5b\x88\xb4\xf8\x7b\xd8\xcc\x0a\xab\x0a\xbb\x09\x86\x6d\x6d\x91\x9f\x0e\x5b\xe9\x46\xfa\x6e\x26\xf0\x9e\x07\xfb\xaa\x9e\x8e\xcc\xd6\x71\xb0\x2a\x4c\xbc\x2e\x87\xed\xa3\xc1\x24\xeb\x86\x69\xeb\x0a\xe2\x00\x53\xf6\xe1\x70\x02\xd7\x95\x09\x1b\x8f\xec\x83\xb1\xb0\xf8\x7f\xe0\xba\x92\x4b\xee\x03\xd7\x34\x3d\x96\xd8\x17\x9f\xf5\x42\x4a\x13\x6d\x55\x9a\xb8\xa6\xc9\xe0\x4f\x6b\xf4\x26\x96\x4f\xd0\xc4\x33\x8a\x4c\x7a\x67\xe0\x75\xc3\xd5\x75\x1c\xc5\x54\x70\x79\x81\x10\xf7\xdd\xd0\xfe\x9c\x74\x4f\xdb\xa6\xf8\xd4\xc8\x9b\xf5\xc4\x16\x35\x8a\x1a\xbc\x38\x9e\x13\xeb\x7e\xc4\x3c\x8d\xe8\x87\xc3\x0f\xa9\xfa\xe1\x3b\xf8\x3f\x50\x3d\x8e\x69\x57\x93\x80\x5c\x9c\xda\xfb\xd3\x0a\x7a\x44\xc3\x06\x8b\x85\x67\x04\x01\x72\x9c\x91\xe7\x45\x09\x98\x2d\x98\x99\x61\xf5\x9f\xb4\x51\x34\x18\x38\x8b\xda\x6f\xbb\xfe\x64\x3d\x2d\x36\xa8\x35\xfd\x81\x92\xea\xe6\xa0\x19\x88\xb4\x47\xe8\x8f\x3f\x3e\xf3\xe3\x8f\x6a\x9f\x50\x65\xc4\x96\xd8\x66\xe6\xd6\x2d\xf0\xf0\x6e\xad\x1f\xf3\x45\x8c\x2b\xe2\x86\x80\x4c\x30\x28\xda\x3c\xd3\x8b\x6d\x45\x9b\xa0\xf7\x41\xc1\x21\xf2\x81\xa0\xdf\xe1\x74\x94\xcb\x8c\x28\x89\xe5\x72\xa6\x24\xf1\x5e\xa7\xdb\xed\xb4\x9a\x78\xcc\x91\x5c\xf1\x1e\xdc\x52\xa4\x1e\x3e\xd4\x66\xd3\x54\x39\xe2\xce\x48\x74\x14\xa1\xa5\xd1\x04\x2f\xad\xd7\x08\x7a\x2b\xd9\x5b\xe4\xf0\xe1\xc3\x5a\xb7\x11\x66\xc5\xd2\x6b\x5a\x7f\x91\xdf\x96\xc2\x5c\xb5\xe5\x88\x72\x35\x99\x0f\xb6\x37\x91\x3f\x96\xf4\x69\x10\x9b\x0d\xfa\x9b\xd6\x93\x77\x6a\x9c\xf0\x48\x22\xae\xb8\x07\xa6\xc4\x2c\xaf\xd7\xe4\xb4\xae\x17\x57\x54\xe1\x8f\x4d\xc0\x4f\xfa\x34\x28\x7c\x7b\xfd\xfc\x34\x15\xfe\xe0\x04\x7c\x22\xab\x53\xe0\xfb\xea\xc7\x2d\x55\xf8\x47\x12\xf0\x13\xf2\x9a\xc2\x07\xce\xcc\x46\xe1\x27\xe3\xa2\x3b\x40\x0a\xfc\xbf\x6a\x32\x73\xff\x07\x7c\x92\x5d\xb6\x17\xb4\x3c\xc9\x40\x27\x09\x14\x78\x1c\x9e\x5e\xf7\x3a\xe1\x34\x27\x14\x9d\xf8\x6d\xd0\xc9\x24\x73\xee\x8a\x81\x44\x72\x2d\xf0\x2f\xf1\xf7\xd2\x1c\x25\xf5\xbd\xbb\xb4\xf8\x6a\x66\x3c\xbe\x1a\x8f\xc8\xa6\xc8\x7e\xf2\xee\x3e\x29\xef\xde\x0b\xdb\xe1\x6f\x4b\xe6\xea\x4d\xf1\x38\x1b\xe8\x0b\xe4\x3d\x03\x13\xdf\x47\x9e\xe9\x0c\xb4\x08\x26\x0d\xe5\x4e\xc9\xca\x6c\xf8\x1e\x65\x28\xe9\x6f\xab\xbd\x87\x67\x76\x77\xa0\xf7\xb5\x93\x3b\x7e\x38\x04\x2e\x5e\xd3\x8e\x6d\x9f\x80\xbb\x1b\x86\x54\xfe\x03\xb2\xb3\x2d\x96\x24\xff\x49\xc6\x2b\xdb\xab\xbc\xb2\xae\x56\xb5\x7b\xbd\xd4\xee\xad\xad\x09\x78\x0c\xa9\x3a\x35\xed\xfd\x42\xf1\x1d\xa9\xf2\xca\xda\x94\x38\x75\x2d\xde\x15\x9d\x37\xed\x3c\xd4\x5c\xc4\x23\xf1\x5c\xc4\x24\x7c\xa3\x06\xdf\x6a\x48\x66\x23\x36\x8c\x51\xc7\xe1\xab\x72\x24\x56\xe3\x73\xa6\x44\xa9\x93\xf0\xc7\x24\x72\x1d\xa7\xe0\xfb\xa0\xe5\x47\x1a\x68\x7e\xa4\xc5\xa4\xc2\x4f\xd9\x3f\xda\xb3\x95\xe2\xd4\x49\x93\x3d\x93\x34\x1a\x24\x48\x4d\x32\x5a\x60\x3a\x0d\xd2\x7e\x29\x14\xa7\x31\xaa\xec\x19\x9a\xf4\xab\x8d\x32\x5a\x40\x2a\xfe\x2a\xec\x49\x71\xd8\xd8\xce\xb5\x68\x7e\x30\x02\x5b\x30\x9a\x1b\x85\x7d\x39\x0e\x9b\xd9\x19\x4b\xc2\x66\x8d\xe6\x46\x60\x1f\x4e\xc0\x5e\x09\x8c\x9a\xac\x20\xb0\x8d\x66\xdb\xdf\xe3\xcd\xac\x84\x49\xd8\x3a\xb3\x2d\x09\x1b\x40\x78\xaf\xd6\x0f\x51\x04\x99\x51\x01\xff\x7f\xbd\x64\xe3\xcc\xa4\x35\x29\xad\x2a\x2b\x48\x14\xb8\x86\xb4\x3c\xc9\x78\xd3\x43\xd2\xf1\x30\xa5\xdb\x21\x3b\x38\xd9\xe5\x90\xea\xb6\xed\xb5\x3e\xa1\x99\xa0\x29\x98\x14\x6d\x99\xe3\xd0\x21\xe4\x67\x02\x56\xc6\xda\xac\xc0\xeb\xb4\xe5\x97\xcb\x0e\x9b\x4b\x97\x09\x32\x07\xca\xac\x15\xeb\xbf\x8c\x1d\x61\x2b\x9e\x21\xb9\x21\x46\x8b\xe6\x3e\xb6\x88\x0c\x75\x1f\x47\xea\x75\xa0\x68\xac\xf3\x21\xf5\x90\x15\xa7\x7a\x91\xa5\xb4\x26\xa3\xe1\xd4\x6c\x84\xf6\x0b\x6a\x60\x6b\xe5\x8a\xda\x58\x34\xd1\x68\x74\x01\xea\x3f\x6f\xe9\x96\x95\xcb\xb6\xae\x98\xcb\x95\x6e\xda\xb4\x64\x03\xe9\x2c\xfa\x46\xb2\xd9\x28\x7a\x37\x36\xe9\xc3\x97\xdf\xff\xe0\x8d\x4b\xb4\xef\x12\xaa\xfb\x40\x93\x5f\x1e\x6c\x81\x35\x05\xa3\xa3\x2d\x5d\xf6\x80\x9d\x05\xf9\x01\xbd\xc5\x12\x60\xbd\x58\xfb\x68\x56\xe0\xca\xcf\xcc\xcf\xac\x90\xf3\x4d\xf9\x26\x56\xcc\xe3\x44\xae\x52\x16\x11\x1b\x48\xcd\xa9\x4f\x94\x70\xa4\x4f\x2e\x89\x6b\xe8\x52\x72\x76\x09\x9d\xfe\xa9\x53\x8b\xe7\xb4\x31\x26\x89\x94\x5b\xad\x46\x37\x4b\x1d\x63\xb2\xb6\x5f\x57\xdb\x2e\x69\x57\x35\x6c\x07\x7f\x5c\x7f\xf7\xa1\xd3\xcf\x9e\x3c\xb1\xfd\xc1\xe3\x0f\x0c\xdc\xb6\x6d\xfe\xdd\xb0\x39\x99\x65\xc2\x3e\xda\xad\x67\xeb\x76\x52\x97\x8e\xcb\xb6\x29\x8f\xcf\xbb\x3f\xc3\x76\x72\x36\x9d\x66\xc2\xbc\x45\x46\x9b\x24\xf4\xd6\xcd\x24\x4e\x8b\x9e\x05\xa9\xbd\x5f\x49\x5c\xba\x67\xd4\x25\x80\x00\x27\x8a\x16\x0f\xa6\xf4\x9c\x5c\x17\x36\x39\xed\x2e\xd1\x22\x9e\x81\xc6\xa8\x59\xb6\x40\xa3\x13\x85\xd2\xba\xc0\xaa\x31\xe9\xd4\x14\x11\x5b\x69\xfd\x56\xb0\xb4\x0d\xd7\xdf\x35\x83\x65\x3e\x8c\xbd\xa3\xf5\x83\x8d\x9f\x55\x7a\x3f\xd8\xfb\x94\x3f\x68\x43\xd8\xe4\x41\x31\xf8\x1c\xe8\x77\xd0\x3c\xe7\x36\xd1\x0c\xa3\xdd\xce\xb3\x02\xfe\x53\xb7\xc7\x68\xab\x90\x8d\x46\x56\x8f\x58\x7b\xf2\x44\xb4\xce\xbb\xa9\x2d\xe0\xb0\x49\x1c\x92\xf2\x8b\x73\x23\x6a\x67\xfc\x3c\x32\x47\x06\xe3\xb5\xb9\xee\x8b\xd8\xcf\x7b\x61\x6e\x3b\xd8\xf5\x27\x50\x77\xee\xe0\x41\xe5\x6d\x18\x39\xb8\x1b\xae\x3a\xfd\x06\x3a\xfd\x40\xe8\x62\xec\xa5\xcb\xe7\xe6\xce\x50\x9a\x4c\x53\xed\xbd\x52\x6d\xff\x3c\x98\x7b\xb5\x8f\x06\x82\x9c\x24\x09\x16\x2f\x46\x2b\x37\xcf\xed\xc7\x17\xc2\x2d\x8a\x64\xdb\xb2\xff\x6b\xf3\xdc\x48\x23\xdd\x73\x29\x56\x7f\xbb\x67\x0b\x21\x8c\xfc\xcd\x9e\xa1\x8a\x9a\xd0\xe3\x5a\x1b\xdd\xf8\xae\x41\x30\x1c\xe3\x3a\x9a\xf6\xf3\xef\x18\xcd\xc4\x46\x9a\x24\x02\x93\x68\x72\x7b\x24\x5e\xe2\x05\x03\x19\x64\x23\xd8\xe9\xb4\x1a\xb6\x5e\x5f\x86\x7a\x3b\x47\x47\x23\x91\xf6\xc4\x59\x74\x22\x89\xda\x64\xde\x86\x36\x1d\x7c\xe4\xe6\x3d\xb9\x87\x17\xc0\xc1\x8c\x47\xf9\x5c\xf9\x53\x39\xb9\xe5\xbe\x76\x0f\x4c\x3c\xf1\x30\x73\x04\xdb\x52\xec\x92\x3b\xba\xc0\x01\xb1\x01\xca\x51\x65\x2b\x9c\xd9\xe5\xde\xd5\x50\x22\xfa\x1a\xb6\xcb\xb9\x16\x7c\x36\xde\xbd\x81\xd1\xa6\xc0\x22\x05\x83\x81\x80\x9b\xd7\x59\x74\xb9\x79\xce\x8c\x0a\xd9\x69\x95\x82\x56\x3e\xc8\x07\x8d\x56\x6b\x36\xb6\x9c\x59\x23\xc6\xcf\x68\x6f\x80\x5f\xa9\xf8\x7c\xc2\x56\x8c\x24\x3d\x36\x89\xe1\x4d\x59\x64\xa0\x4e\x91\x5b\xed\x15\xe1\xcc\xa3\x6d\x6c\xb4\xe9\x3a\x85\xea\x74\x9d\xf2\x9f\xf6\xab\xd3\x75\x9e\x98\xb7\x6a\x5e\x49\xd7\x16\x05\x3d\x3b\xd7\x1b\xb2\xf3\xec\x3f\xd4\x21\x3b\x55\x86\xd5\x7b\xad\x7b\x6c\x3d\xfb\x7d\xa5\x0e\xdb\x01\xf1\xfe\xc4\x0a\x87\xb0\x35\x3c\x3c\x1a\xf4\x00\xce\x66\x93\xa4\x80\x31\x08\x82\x79\xf9\x9c\x0d\x05\x6c\x01\x5b\x18\x85\xf1\x7d\x0a\xbb\xf4\x16\x72\x9d\x0c\xb2\x1e\xd1\x76\x8e\xa2\x9a\xaf\xf7\x7c\xfd\x0f\x6a\xf0\x35\xb4\x1d\xb1\x9b\x66\x22\xa7\x7e\x40\xc3\xce\xc4\xc7\x66\xe9\x96\xcf\x28\x6c\x93\x53\xd0\xb5\xed\x7f\xed\x50\x3c\xf0\x9e\x95\xe6\xad\x62\xcf\x7e\x6f\x34\x68\x54\xdc\x30\x97\x83\xf2\xc4\x89\x34\xae\xe9\x07\x9d\xa2\x41\xcc\x09\xbd\xac\x03\xdf\xb5\xcc\x80\x09\x33\x40\xd1\x53\x21\x6b\x2c\xd0\x9b\xc2\x02\xeb\x17\x31\x46\x92\x03\x86\x92\x2c\xaf\x03\x6c\x38\x6b\xe8\x27\x8d\xcd\xbd\xa9\x4d\x1c\x72\x76\x8e\x4f\x1c\x4a\x65\x6f\x69\xa3\x87\xc8\x3d\xc4\x38\x16\xd0\x7a\x28\x2c\xe3\xa2\x59\x3a\xc9\x02\x58\x49\x32\x00\x83\xcb\x4d\x27\x75\x20\xa3\xce\x28\x62\xd2\xb1\x91\xd2\x28\x1d\xaa\x3f\x5d\x2a\x65\xb2\x03\x69\xa6\x91\x13\x51\xdb\x9c\x87\xb2\x73\x48\xdb\x0c\xf2\x0b\x5f\x0a\xea\x7e\x82\x5d\x63\x4d\xd1\xd6\xd8\xcf\x9f\xd7\x81\x73\xbb\x0f\xc2\x88\xf2\xf6\xc1\x83\x70\xd5\x13\x97\xe1\xce\xdd\x7f\x3d\xf9\xfa\xc9\xbb\xa6\xc1\x7f\xce\x00\x20\xb5\xd7\x33\xe1\x0b\x3d\xa3\xa2\x57\xe4\x83\x40\x10\xf0\x4d\xc3\x74\xed\x14\xad\x84\x04\x24\x59\x84\xfa\x6c\xb5\xe9\xb3\xbf\x41\x96\x4f\xba\x34\xb4\x95\x16\x35\x68\xfc\x4c\xa3\x59\xff\xa3\xf5\x73\xec\x1d\xe6\x43\xfe\x11\xa4\x53\xbb\x3f\x2f\xdf\x5a\xaf\xfb\x33\x7b\x1f\xc9\xea\xe1\xef\x69\x06\x6f\xfd\xf8\xd2\x9b\x5f\xbc\xf3\xc2\xab\x04\xf7\xc5\x58\x6f\x23\x3d\x48\x6d\x20\x00\x3a\x47\xb3\xbd\x16\xe2\x1c\x05\x88\xe1\x2d\x5c\x30\x4b\x74\x11\xff\x23\xe2\x39\x6c\x35\x71\x7e\x06\x23\xce\x38\x93\x52\xaf\x81\x2f\x52\xe4\x20\x71\x7d\xab\xdd\x74\x1a\x69\x50\xaa\xdc\x08\x2b\x6a\xff\x60\x74\x13\x3e\xac\xba\x6d\x98\xd6\xa9\x74\xc7\xc6\x8d\xd5\xbb\x36\x32\x01\x05\x04\x94\xab\x4b\x37\xc8\xc7\x47\x8c\x7a\xf3\x70\xb2\x5d\xe9\x1b\xff\xba\xf8\xc6\xcb\xe4\xce\xdd\xa2\x9d\xb9\x89\x9c\xb8\x9e\x05\x26\x9e\x61\x4c\xc0\x44\x06\x25\x93\xd9\x28\xc0\x40\x0c\x4d\x03\x02\xb0\xc1\x64\xa9\x94\x13\xa7\xfe\xa4\x88\xd6\xd6\x9e\xfc\xdc\x82\x60\x6c\x02\xb3\x3b\xd6\x04\x6d\xdb\x0d\x5f\xd9\x09\x1f\xdc\xad\xce\xa2\x61\xc0\xcd\xf8\x8e\x4f\xc4\xfc\x53\xc2\xd2\xb2\x7b\x34\x8c\xf9\x97\xd3\x64\x71\x38\x38\x13\xe7\xf1\x9a\x9d\x15\xb2\x59\x32\x4b\x7a\xa4\xc7\xf2\x47\x6f\x47\x56\x4c\x74\xf5\xf9\x68\x83\x89\x91\x76\x7c\x9d\x09\x13\x25\x13\x63\x8a\x43\x4c\x28\x5b\x07\xb3\xec\xa1\x00\xdc\xd5\xf7\x5f\xbb\x18\xa3\xf2\xfb\x1f\x7f\x28\xd7\x51\xb1\x43\x79\xf5\xc2\x04\x58\x0a\xc3\x8e\xd8\x06\xd3\x7d\xec\xed\xb3\xee\xc4\x6c\x94\xcc\x8d\x19\x0f\x87\x97\xc3\x4b\x0f\xd5\xce\x80\x6f\x7d\xf9\xad\xca\x87\xc6\x60\x1c\x17\x72\x32\xe6\x43\x43\xa2\x2d\x32\x91\x53\x6f\x15\x84\xec\x70\xd8\xcb\xeb\x11\x97\x97\xcf\xbb\x33\xdc\x19\x95\x72\xb6\xdb\x6a\x75\x67\x23\x60\x32\x61\x5c\x4d\x2c\xc8\xc2\x1b\x64\xaf\xdf\x71\x24\xae\xb9\xd4\x9b\x6a\x9e\x43\x4a\x6d\xf0\xbf\x72\x52\x7b\xa3\x87\x22\xce\xc4\x40\x4f\x37\xcf\x32\x95\xdf\x2b\xdf\x3c\xb6\x4e\xf9\x12\xf2\xff\x3a\xff\x47\xaf\xc3\xc5\xc7\xe6\x2f\xdd\x01\xc7\xf7\xec\xf9\xd2\xb9\x47\xb7\x43\xdd\x9d\xbb\x86\x2b\xbf\x3b\x5e\x3f\xb5\xec\x8c\xed\x86\x6b\xf7\xbf\xba\xfb\x64\x97\x25\x77\xcc\xbd\xf9\xbd\xcd\x73\xef\x9e\xb6\x0c\x8a\xfd\x9e\xda\x47\x42\x10\x98\x06\xc9\xdc\x0f\x1b\x18\x16\x8d\x30\x12\x71\x21\x58\xad\x92\xdd\xc1\x42\x22\x05\x06\xb0\x15\x2c\xb2\xb2\x65\xec\x54\x16\x99\x11\x4b\x86\x78\xb1\xac\x5e\x14\x01\x66\x45\x88\xcc\xd6\xd2\x83\xb4\xf9\xb4\xf1\x51\x5e\xa5\xa5\xc9\xba\x46\x55\x31\x21\x7e\x71\xda\x28\x22\x31\xd6\x6b\xfd\x92\x4e\x83\xc2\x91\x9c\xc9\xf1\xe9\x5e\xe3\xd6\x6f\x77\xec\x96\xf6\x70\x27\x69\x9c\xe8\x6b\x8c\x57\x0b\x8e\x74\x54\xec\x17\xcd\xb7\x59\xed\x82\xc1\xac\xd7\x5b\xec\x16\x41\x60\x5c\x6e\xb3\x28\x89\x03\x65\x03\x90\xa0\x88\x24\x09\x58\x7c\x80\x9b\x21\x03\x5d\x42\x05\xa9\x97\xba\xa6\x55\x35\x69\x4d\xa9\xdc\x74\xb0\x97\x15\x86\x74\x21\x14\xb6\x87\xdb\x46\xda\x76\x86\x68\xdd\x80\x81\x4d\x4a\xfa\x0e\xe9\xeb\xf0\xc1\x96\x5e\xe5\xf5\x9f\x6b\x7e\xae\xf5\x5d\xcf\xcc\xf9\x07\x27\xbb\x57\xda\x3b\x55\xac\x5a\x72\xbd\x88\x7d\x75\xc9\xf6\x9d\x0b\xb4\xf9\x63\x5c\x73\x9e\x64\x3b\x8e\x8c\x16\x66\x72\x46\x8f\xc7\xed\xce\x16\x01\xc8\xe5\x50\x7e\x13\x01\x73\x41\x41\x9f\x9b\x83\x79\xa0\x47\x9f\xeb\xc9\x25\x43\xc8\xb0\x80\xd5\xb3\x4c\x30\x39\x82\x2c\x55\x00\xa9\x52\x29\xc5\x01\xa2\x8a\xa1\xc4\x24\xb2\xfa\xd2\xf4\xbf\x8e\x25\x7b\x72\x26\x11\xa8\xed\xb2\x7a\x76\x7e\x78\xe0\x15\x32\x9d\xac\xeb\xda\x92\xf4\xe9\x64\x13\x13\x12\x55\x9b\x52\x96\x1f\x26\x53\xca\xc8\x9d\xe3\xf0\x7e\xbf\x48\xe7\xbf\x64\x82\xae\xd1\x10\x6f\x76\x22\x83\xcd\xea\x41\xc8\x6a\x40\x26\x3d\x99\xce\x61\x0a\x04\x9d\x06\x60\xc4\x3c\xdd\x87\xc9\x58\x3d\x77\x75\x5f\x1b\x0c\x7e\x54\xbb\x4d\xb6\x21\x3d\x37\x0d\x30\x02\xdd\xa4\x13\x48\xbe\xd6\xd9\x8b\x56\x37\x4c\x9e\xb9\xac\x5f\x0f\x05\x5d\x82\x3b\xe1\xd6\x4b\x0a\xea\x35\x60\x79\xa6\xaf\x43\x7b\x7f\xcb\x26\x4d\x5a\x2a\xc3\x57\x4e\x9f\x50\xbd\x94\xbd\xa7\xb6\x2d\xba\x74\x7d\xc9\x92\xf5\x13\xa7\xaf\xac\x6d\x5a\x31\x77\x6e\x45\xd3\xd6\xc5\x6d\xe8\xdd\xab\xc2\x77\x6f\x02\xed\x1b\x79\x43\x34\x6c\x13\xcd\x66\x2c\x27\x83\xd9\xd9\xac\x05\xe5\xe4\x66\x59\x6d\x4e\xa7\xbe\x5c\x76\x8a\x02\xb4\x38\x01\xe1\xf7\x9a\xcb\x29\x1e\xc4\x49\xf3\xe2\xd3\xab\xa6\xf6\x85\xd4\xc2\x4c\x9a\x42\x18\xef\xec\x44\xdb\x7d\x88\xe8\xc6\x09\xf3\x3b\x74\xec\xd1\x7d\xd8\x91\x23\x3a\xd4\x7f\xe3\xdc\x3b\xda\x74\xec\x5c\x7c\xc4\xd1\x6f\xd7\x16\x28\x6f\xb9\xf5\xd8\xb6\xd8\x62\xee\xb2\x72\xcf\xbc\xd6\xc7\x1f\x79\x5a\xd9\xb5\x7d\xc6\x9c\x4d\xcc\x13\xb1\x88\xb2\x40\x8b\xcd\x92\x38\x32\x4f\x62\xb3\x29\x33\xda\xec\xa0\x32\x1a\x01\x18\x75\x68\xc0\xc6\xbc\x5e\xb2\x58\x1c\x4e\x1d\x6d\x4f\xc7\x92\x4e\x5e\x27\x44\x64\x47\xa2\x68\x02\x7a\x1a\x98\x30\xd9\xb0\x64\xb0\x37\x1c\xdd\x56\xaf\xb5\x60\xca\x74\xe0\xf8\x28\x37\xe2\xd4\x53\x83\xa2\xd4\xb1\x47\x47\xba\x5d\xb9\xa2\x0e\x75\xbb\x72\x85\x8e\x75\x53\x26\xad\x53\x32\x76\xef\x86\x5f\xac\x83\x3b\x41\x72\xd6\xda\x48\xe0\x00\xbd\xa3\xb9\x76\x68\x84\x48\xb2\xd9\x00\x70\x88\x08\xb1\x0e\xd6\xe5\x84\x76\xbb\xc8\x20\x56\x52\x39\x00\x0b\x88\x2e\x12\x51\xef\x1e\xdd\xd9\xf4\xce\x70\x36\xcd\x08\xa6\x99\x05\x09\x4a\x76\xc6\xc7\xae\x85\x1e\x3e\xbb\x7d\x6d\xd7\xae\x45\xa5\xf7\x90\xe1\x6b\x22\xd3\x89\x99\x71\x52\x29\x63\x8b\xd6\xef\xb0\x3e\x60\xdb\xac\xdc\xca\x3c\x16\x7b\x2c\xc6\x83\xd4\x9e\xed\x0e\xd0\x2b\x9a\x43\xf0\xa2\x18\x11\xdc\x1c\xac\xc3\xe9\x8a\xa3\x65\xd5\x5b\x06\xc9\x64\xee\xad\xb3\x31\xb4\xfe\x7f\xb0\xa2\x89\x0f\x14\xab\xae\x0b\x53\xbb\xb9\xb3\x07\x55\xac\x62\xdb\x1a\xf4\x74\x97\x40\xdf\x68\x9e\xa8\x27\x5d\xfc\x58\xd6\x42\x22\xda\xc8\x64\x36\x61\xea\x33\x9b\x75\x22\x8d\x65\xc3\x46\x63\xd9\x5a\x5e\x57\xfa\xe9\x91\x46\x9c\xe9\xe7\x46\x82\xd9\xaf\xbf\xae\x86\xb2\x3f\xfd\x94\x24\x37\xa0\x16\xeb\x62\xdf\x57\x57\x33\xb6\x75\x8c\x54\xad\xca\xa4\xe9\x18\x97\x41\x18\x17\x3b\xe6\x99\xcd\x0c\x46\x1b\x69\x98\xc0\x9b\xcc\x56\x16\x6f\x13\xc3\x00\x51\x30\x72\x0e\xa7\xcd\x0a\xcd\xac\xdd\x6e\x11\x21\x6f\x32\x5a\x44\x64\xa4\xbb\x84\xb7\x83\x30\x4e\x77\xa2\x23\x35\x89\xf2\x4b\xda\x26\x41\x1d\x24\x73\xe6\x04\x08\xc3\x90\x14\x8f\xe4\x47\xdc\x6d\x51\xcb\x7d\xf0\xf9\x67\xae\x34\xf5\x58\x9b\x29\x9f\x3e\x09\x9f\xed\x7e\xba\xe5\x53\x37\x3e\x5a\xb2\x87\xbd\xde\xf1\x7a\x17\xe6\x86\x69\x93\x5a\x56\xc5\xee\x41\x2f\x3d\xd3\x6d\x76\xf7\x57\x36\x95\xaa\xf8\x0d\xc5\xf7\x76\x2e\xa6\xfd\x10\xe8\x16\x0d\x19\x0d\x8c\xdd\x6e\xb3\x19\xb2\x32\x32\x7c\x06\x5f\x76\x38\x68\xcb\xb0\x19\x90\x5b\xe0\x84\x0a\x39\x0b\xf3\x23\x3b\x88\xb7\xa8\x27\x91\xaa\xb2\xb4\x3a\x6c\x95\x43\x72\xd9\x5a\x01\xa1\x14\x49\x69\x07\xed\x22\x43\x05\x69\x3e\x76\x3e\x8f\x82\x2b\x3b\x67\xcd\xea\xb7\x7d\xf5\xfd\x65\xe5\x37\x76\x3d\xd0\xa9\xd7\x96\x03\x86\xd5\xfa\xce\x8e\x43\x7d\x47\xbd\x7d\x15\x1d\xa9\xbd\x79\xd7\xea\xc5\x2b\xd0\x63\xb5\xa3\x36\xae\x80\x3e\x74\xff\xf5\x03\x73\xa6\x2e\xdf\x49\x71\xad\x7b\x19\xf3\xc3\x66\xb4\xa7\x64\x71\xd4\x2b\xb2\xac\x41\x00\x0e\x87\x53\x70\xba\x3d\x0e\x68\x45\x3a\x7c\x27\x75\x12\x9d\x5e\x46\x0d\x8a\xb4\x76\x88\x91\xc4\x00\x3c\x35\x1a\x4c\xa5\x5e\xea\x24\xbc\x95\x0b\x7b\x16\x35\x6f\x37\x43\x9b\x87\x77\xa2\x7f\xad\x6d\xe3\x16\xd3\x01\x01\x8b\xbe\xe4\x54\x3c\x35\x1f\x80\xc6\xa8\x6d\x3c\x9a\x9c\x8c\x09\x73\x23\x6d\x3c\xbb\x1d\xc4\xe7\xe6\x7d\xc1\x2d\xa2\xf9\x9b\xbd\xa2\xb9\x5e\xde\x22\x49\x4e\xc0\x83\x60\x16\x1d\xc3\x68\x30\xd9\x2b\x65\x93\x09\xa9\xcd\x08\x58\xe4\x4f\x1b\xa4\xa7\x0e\xc0\xf4\x88\x17\x0a\xd2\xa7\xb1\x24\xe7\xea\x65\xd9\x4b\x8a\x31\xf1\x39\x1d\x3a\x97\xae\xe1\x80\x3d\xc3\x1f\xb0\xef\xec\x41\x23\xce\x1f\xc8\x6e\x6c\xca\x9e\x0c\x47\x28\x57\xca\xa6\x1f\x9a\xf2\xd6\xed\x0b\x8e\xd6\x9f\xb5\x87\x6d\x38\x0e\xd1\x9e\xed\x21\x22\x6b\xfc\x04\x6f\x17\xc6\x3b\x3b\x8c\xb1\xb5\x5a\x85\x41\xb2\xd5\x6a\xf0\xd2\x46\xfc\xc1\x94\x46\xfc\x49\xbc\xeb\x63\x1c\xef\xca\x9f\xc0\x98\xd7\xa5\x35\x29\x8b\xf7\xe7\x87\xeb\xba\x57\x8c\x38\x5f\x39\x96\xa5\xca\x6f\x23\x6d\xfa\x57\xdc\xb0\xe8\xd0\x94\xe9\xff\x68\xdb\xbc\x15\x51\x7f\x49\xb7\x7e\x82\x6f\x91\x32\x82\xce\xe7\x13\xb1\xc5\x76\x43\x34\xdb\xc5\x61\x5b\xc8\x27\x58\x2c\x3e\x0e\xf9\x33\x25\xd1\x68\x64\x4c\xac\xde\x4e\x65\x3c\xb6\xcc\x04\x22\xe4\x2f\xc4\x31\x56\x73\x61\xd3\xdb\xbc\xe7\x26\x43\xa9\xb9\x11\x12\x72\xc9\xa7\x43\xef\x1d\xf8\x0f\xda\x22\xf7\xb2\x4d\x9f\x7e\xf3\xd3\xeb\x77\xdf\x01\x6f\x2a\xa8\x79\xb0\xa6\xa0\xe7\xec\x15\xeb\xee\xe9\x9c\xd7\xa7\x82\xee\x6b\x37\x78\x5b\xcf\xe8\x9f\x1c\x1f\xd1\x17\x28\x5f\x5c\x8f\x29\x57\xb3\x30\x7e\x79\xb4\x4f\x76\x7f\xcc\x83\x48\xd7\xb2\xb0\xd3\x20\x20\x94\x01\x24\x29\xc3\x80\x32\x03\x3e\x46\x10\x6c\x56\xd1\x64\xc3\x06\x90\xc8\x7b\xca\x65\xde\x85\x97\x95\x95\xfd\x1d\x82\xa4\xd7\x54\x8a\x0d\x84\x91\x84\xda\x56\xb6\x45\x79\xe8\xea\x3f\x4a\x77\x0c\xfc\xee\x27\xf8\xf9\xa0\x2d\x11\xd8\xbe\x59\x6c\xd9\xde\x75\x6b\xb6\x44\xdb\xc1\x36\xca\x70\xae\xac\xf6\x48\x7e\x73\x12\xd3\x65\x5a\x15\x04\xbb\xfc\x65\xe3\xa6\x5f\x79\xff\x9d\x77\x5d\xa8\xa5\x43\xb3\x6f\xab\xe8\x9d\x0a\x90\xee\x6a\x26\x51\xd4\xf9\x78\x5e\xe7\xc6\x9a\x5b\x30\xcb\xc7\x55\xc8\x3e\xc1\x27\xe8\xec\x19\x7a\xbb\xbe\x52\xb6\x23\x5d\x72\x82\x5d\x03\xad\x3e\xde\xaa\x49\x80\x05\x04\xd9\x54\xe7\x5e\xca\xf8\xc5\xaa\x3b\x3f\xd8\x70\xf6\x6c\xdc\x9d\x37\x5d\x1d\xc2\xb8\xfb\x60\x62\x08\x63\x8a\xa1\x1b\x9f\xc6\x98\x5a\xc7\x45\xfc\xaf\x37\x10\xfb\x23\xc7\x6d\x30\x18\x03\xc0\x08\x9a\x15\xf8\x42\x24\x3d\x44\x14\x1c\x83\x64\x01\x1a\xfd\x4c\x3e\xb6\xce\x98\xff\xe9\xa7\x0b\x25\x7a\x88\x11\x51\x13\x84\xaa\xac\x69\x7c\x62\xc3\xfc\x23\xf9\x1c\xfb\xd8\xc6\xf5\x25\xf9\xb9\xed\x3a\xde\xcd\x16\xed\xba\xe7\xc2\x73\x4f\xcc\x59\x96\x9c\xda\x30\x76\x24\x29\xe7\xe2\xfb\x6d\xd8\xa6\xd7\x3f\xe8\xd8\xac\xfc\x74\xf3\x38\x52\xe6\xf5\xc1\x05\x75\x72\x03\x03\x0e\x28\xcf\xb2\x0f\xd0\xd8\xa0\x1b\xf4\x89\xe6\x61\xbe\x6d\x22\x2e\x64\x96\x14\xc0\x98\x58\x93\xc7\x2b\x30\x0e\x06\x33\x30\x4c\xb2\x0e\x9d\x43\xc7\x72\x88\x8a\xf0\x0b\x89\x36\x05\xa0\x9e\xb0\xd4\x18\xae\x81\xce\x60\x24\xdd\x0a\x68\x6b\x37\x03\x8c\x4f\x61\xbc\xa4\x2c\xfe\xfa\xec\x59\x18\xfe\xea\x97\xa7\xf6\xc1\x7d\x4a\xad\x3a\x87\x71\xe3\x56\xe5\x59\xe6\x73\x65\x24\xd7\x7d\xc7\xb3\x35\x9b\x5e\xcd\x88\x71\xec\x0c\x75\x14\x23\x96\x05\x13\x30\xef\x9a\x83\xef\x54\x13\x30\x28\xda\x4c\xb0\x5a\x41\x38\x27\x07\x8b\x22\x67\xd3\x66\x99\xc6\x3c\x1b\x08\x8b\x61\xc6\x82\xc2\xe1\xbc\x3c\x6c\x33\xe5\xd9\x31\x09\xdb\xcc\x95\xb2\x8d\x4d\xe9\xdd\x94\x6c\x53\x57\x9a\x8e\x2d\x71\x2c\x90\x59\xeb\xa8\xb8\x4d\x28\x2b\xd1\x8a\x4e\x80\x29\xad\x9c\xb0\x05\x98\x33\x21\x52\xb1\x7f\x7f\xf7\x05\x37\x75\x50\x3e\x57\x7e\x69\x71\xba\xf0\xbb\x7f\x7d\xf2\xc3\xd0\x53\xc7\x8f\x2e\xee\xfd\xf0\x7d\x9b\x1e\xf6\xd5\xf4\x56\x4a\x7f\x57\x7e\x81\xb7\x0d\x5c\x30\xb6\x77\x9e\x98\x55\xd4\xb7\xe3\xdb\x6f\x87\x1e\xd9\xfe\xe4\xd1\x71\xf7\x8e\xcf\xcb\xeb\x3c\xb6\xd7\x8c\xf9\x73\xee\xc9\x55\x76\x5e\xa0\xdf\x73\x04\x7f\x4f\x36\xdb\x07\xe4\x63\x7b\xb0\x00\x7f\x8f\x0f\x84\xb2\xb3\x8d\x0e\xe0\x68\xd2\xd4\x67\xcc\xb5\x85\x42\xb9\xb9\x81\x72\x39\xd7\x05\x84\x69\x02\x63\x42\xf4\x83\xca\x65\x9b\x98\xd2\x6e\x31\x91\x52\x5b\x5a\xbf\xdf\x5e\xca\x17\x85\xb3\xe9\x17\x65\x49\xf4\x83\xa0\x33\xb5\x43\xeb\x91\x82\xa1\xcb\x37\x76\xb9\xb5\x7f\xc1\xaf\x57\x83\x7b\x33\xde\x38\x01\x77\xc8\x07\xff\x98\x5c\x59\xbd\x70\xd9\x3a\xe7\xae\xd0\x9b\xaf\xbe\xf1\x39\xf4\x77\xbe\x69\x40\x34\x5f\xca\x6c\xda\xa1\xe5\xc6\x8d\xae\x7b\x96\x2a\x57\x87\xce\x1b\xda\x29\x63\x40\xd9\xc0\x91\x83\x06\x67\xaf\x5c\xb4\x9d\xc8\x99\x5b\xf1\x3d\xdd\x4f\x7d\xd7\x43\xe8\x7d\xf8\x48\x19\x8e\xb6\x70\x6f\x53\x1f\xcb\xe0\xa8\x60\xd1\xe9\x6c\x5e\x00\x82\x36\x5b\x6e\x9e\xcb\xff\x24\xe6\xea\x58\xc7\xae\x3b\x17\x35\x18\x2c\xbd\x5c\x2e\x64\x45\xd9\x67\xa0\xa7\x46\xc6\x9c\xdc\x78\x06\x1a\x4f\xca\x56\x7f\xdc\xf5\xa6\x49\x9d\xf4\x34\x4e\xda\x54\x35\xbd\x93\x2a\x16\x95\xc9\x56\xaa\x9a\xbf\xe5\xa3\xa9\x63\x97\x2f\xed\xd0\xbe\xa4\x4d\xf7\x2e\x0b\xd7\x59\x3b\xf9\x86\x4c\xee\xd7\xb1\x55\xeb\x8e\x1d\x8a\x5a\x75\xe4\x5c\x23\x27\x6e\x5f\xf5\xd7\x6b\xdd\xfa\x58\xf6\x5a\x76\xac\x67\x63\x26\xdb\xcd\x43\x5b\x77\xec\xd8\xba\x55\xc7\x8e\x74\xce\x05\xc6\x9f\xcc\xb9\xc8\xc2\x7a\x91\x48\xe6\x5c\x04\xed\x19\x19\xbc\x10\x14\x42\xd9\x7e\x33\x46\xb1\x46\xf6\xbb\x24\x17\x71\x15\x59\x64\xc9\xaf\x4d\xbe\xa0\x73\x2f\x2e\x44\xea\xcd\x39\x4a\x3f\x94\xf4\xf1\x17\x92\xa8\x49\xfb\x92\x4e\xb0\xe1\x24\x8c\xd8\x0d\xdd\xda\x15\x75\x2c\x19\xd5\xb7\xde\x40\x0c\x2c\x3c\xbf\x90\xf6\xd9\xba\xf6\xbc\xdb\xac\x4e\xc6\x80\x58\x9e\xab\xb1\x11\x89\xe8\x1e\x3a\xb3\x99\x11\x21\x64\x18\x9b\x1d\x0b\x1a\x2b\x60\x69\x3e\x36\x62\x52\x98\x63\xbc\x85\x7b\x2a\xfb\x0e\xa7\xb2\x44\x32\xf0\xf3\x25\x95\x0d\x6e\x43\xed\xd5\xb1\x9f\x1d\x09\xe7\xeb\xdd\x69\xf9\xda\xdd\x20\x39\x0b\xe4\x3d\x10\x04\x5d\xa2\x66\xab\xde\x6e\x67\x02\x01\x4f\x56\xc8\x47\xb7\xc5\x26\xfb\x5c\xbc\x69\x90\xcc\x43\x1b\xdd\x1c\x2b\x9d\x09\xa2\x36\xe0\x7c\xbe\xde\xde\xa8\xfb\x92\x66\xb2\x36\x18\x10\x72\x7c\xed\xf2\xae\x25\xed\x5a\x96\xb5\xab\x37\x26\xe4\xf6\xed\x3b\x85\xc3\x8e\x1b\xfb\x4c\x69\x38\x2b\xa4\x2f\xe6\xc9\xea\x9e\x34\x8f\xba\x44\x1d\x84\x56\xb3\xd9\x66\x07\x82\x95\x0e\x09\xc6\x3f\x56\x6c\x1a\x3d\x5f\x90\xae\x4b\xc7\x07\x85\xc4\x5f\xac\xe6\x35\xb4\x6a\xd3\xb1\xa8\x47\xe7\x45\x6b\xd4\xd4\x86\xbf\xbe\x1e\xd8\x57\xdc\x2b\x6d\x5e\xc9\x95\xc4\x73\x1b\xaa\xb1\x7e\x92\x83\xf5\x2a\xea\x85\x75\x90\xfe\xdc\x19\xc0\x24\x99\x32\xb1\x04\xa8\xc4\x96\xaf\xc0\xb1\x3e\x64\x43\x82\x9b\xf8\xf1\x35\xdb\x32\x72\x21\x25\xf2\x91\x50\x4c\x3a\xc3\xb8\x3a\x22\x35\x1c\x97\x0a\x2b\xe4\x11\xe7\x37\x6e\x78\xfb\xbb\x6b\xaf\x9e\xad\x5a\xb9\x61\xe6\x33\xe8\x7a\xe6\xd4\xc1\x87\xa6\xec\x38\x17\x52\xfa\x29\xbf\xff\xfa\x35\x64\xc8\xf8\xd4\xd7\x76\x1d\x78\x87\x8c\x4f\xc5\x78\xd5\x60\x1e\xf3\x03\xdb\x1e\xdf\xc2\x21\x51\x1f\x0c\x63\xad\xc9\xe1\xd7\xe9\x8c\x8e\xb0\x23\x37\x2f\xc7\x9a\xc5\x96\xcb\x59\x2e\x7f\xa6\xd1\x71\x06\x7a\xa3\x66\x39\xd3\x98\x69\xd4\x7b\x9c\x56\x41\x4f\x0e\x2b\x52\x96\xec\xb4\x9f\xea\xf3\x4c\x95\xa6\x49\x2d\x3a\x05\xf1\x7a\xf3\x55\x26\x0f\x9b\x3d\x77\xf5\x63\x83\x7a\x8c\x38\x3f\x7f\xa5\x96\xda\x18\xdd\x7e\xfb\x43\x3b\xc8\x94\x95\x3d\x73\x1e\xbd\x8f\x99\xa1\xcc\x0c\x4f\x1e\x79\x68\xca\x96\xc7\x5b\x2b\x5b\xd5\x0c\xc7\x19\x23\x93\xf3\x56\xda\xd7\x7d\xc3\x6e\xc4\xe7\x48\x6c\xf7\x90\xd5\x68\xe6\x03\x1e\xde\x83\x32\x9c\x21\x14\xca\xc9\x0d\xf8\x79\x03\x29\x34\xf0\x1a\x11\xb0\x25\x7d\x65\x6a\x85\x4e\x42\x26\x69\x1d\x6a\x8a\x8a\x88\x09\x00\xa4\x36\xb6\xb6\x3c\x99\xe9\xe0\xe4\x35\xf6\x5e\xdc\x86\xc9\x2f\x26\xe3\x2d\xf2\x5d\x36\xa7\x08\x98\x49\xbf\x2a\x9f\x1c\xbb\x7f\x56\xf3\x8b\xf0\xda\xf2\xc5\x8f\x1c\x3c\xfc\xd0\x92\x65\xf0\xda\xc5\xe6\xb3\xee\x3f\xa6\x7c\xe2\xc4\x1a\x95\xfd\x69\x78\xe3\xad\xa6\xdd\x1f\x8f\x57\xfe\x78\xe4\xe3\x2f\xbf\x7d\xff\x28\xd4\x8d\xff\x78\xb7\xe9\x36\xe5\xf4\x53\xca\xb7\xca\xd3\x09\x9a\xa0\x33\xaa\x7d\xa0\x45\xd4\xc3\x23\x8b\xdb\x6d\x47\x58\xfb\x73\x8a\x15\xb2\x93\x0c\x44\x31\x24\xd1\x2d\x4b\x1d\x66\xcf\xa5\xd8\x27\x36\xea\x65\xd0\xe5\xab\x01\x56\x01\x32\xf2\xf7\x1f\x9c\xbd\x6b\xe3\xed\x9b\xfb\x0c\x18\xd9\xbe\x48\x77\x43\x7f\x78\x63\xd9\x82\x17\x1c\x7f\xc6\xd0\x4d\xb5\x47\x9f\x39\xba\x0b\x0e\x80\xc1\x3d\xd5\xc6\x3d\x66\xe5\x06\xe5\x2b\xe5\xe8\xbb\xd3\xd4\xf9\xb6\x5c\x1f\x8c\x87\x1d\xb4\x8f\xfa\xad\x82\x20\x92\x79\x04\x66\xb3\xc3\x69\x31\x8a\x22\x6b\x16\x90\xd9\x06\x78\x8c\x8b\xe6\x12\x2d\xd3\xba\x17\x6b\xfc\x81\x4e\x69\xd5\x3a\xb3\xd3\x8e\x2b\xf1\x69\xad\x9d\x21\x7b\x53\xd9\xed\x1d\x86\xf4\xeb\x50\xd8\xc6\xa5\x3c\xa4\x4d\x6e\xcd\x6a\x85\x45\x74\x8b\xc8\xca\xee\x2d\x73\x62\xd7\xe2\x23\x5c\xe1\xd5\x01\xfd\x13\x77\x92\xfb\x0f\xad\x3d\xed\x11\x15\xfd\x7a\xbd\xc5\xe0\x72\x61\xe6\x9a\xe5\x36\x38\x1c\x5e\xc2\x37\x44\xd9\x01\xfd\x7a\x41\x00\x06\x75\x52\x8b\x1f\x24\x55\xce\xb2\x64\xc4\x36\x92\x30\x34\x55\xfe\xa9\xcd\x6a\x89\x94\xb4\xa5\xa5\xef\x14\x55\x1d\x19\xdb\xd2\xac\x47\x51\x5e\xb3\xe3\x95\x12\x9d\xda\x22\x96\x33\xd6\xbe\x50\x6a\xbe\x7c\xea\xe2\x5b\x07\x75\xeb\x35\x2e\xa2\xdc\x38\x5c\x1d\xe0\x52\xdb\x9c\xcc\x6f\x69\xf2\x5a\xf4\x35\x64\x98\x3f\x67\xcc\xc2\xce\xab\xae\x8f\xfe\xee\x29\x15\xe7\xf8\xec\x59\x09\x8c\x8e\xb6\xd6\x19\x79\x93\x09\x9b\x0f\x56\x86\x37\xf3\xc8\xca\xda\xec\x56\x93\x60\xaa\x90\x8d\x12\x90\x2a\x65\xad\x71\x35\x60\x05\x1b\x19\xf3\x42\x3a\x08\xc6\x4d\xf7\x14\x1f\x63\x4a\xf6\x92\x64\xd3\xbe\x85\xf8\x5e\xe2\xe3\x5e\x42\xe4\xa7\x18\x86\xe6\xc3\x47\xe0\x10\x32\xa9\x56\xd9\x07\xc7\x28\x1d\x95\x2d\x68\xdc\xf5\x0b\x70\xb6\xf2\x14\xf3\x2b\xac\xd9\xbd\x46\xe9\xb0\x4c\x69\xbe\x7b\x3d\xfc\x24\x65\xd6\xcc\xdf\xe0\x58\x4e\x71\x2c\xa7\x38\x9a\x28\x8e\xce\xf8\x28\x9a\xff\x03\x8e\x0f\xc0\x25\xd0\x41\x86\xd3\x28\x5f\xc3\x80\x32\x5d\x79\x9f\xb9\x52\x7b\x33\xcc\x55\xbe\x63\xaa\x60\x8f\x35\xab\x94\x33\xcb\x94\x43\x6b\x56\xc1\x51\x18\x47\xb7\x32\x8c\x9d\x81\xf7\xd1\x8f\x35\xcc\x26\x36\x89\xf7\x43\xce\x63\x30\x70\x7e\x46\xe2\x32\x03\x16\x67\x85\x6c\xb1\xf1\x3e\xcc\x2d\x79\x1e\xd9\x6c\x1c\x66\x13\x24\x36\x94\x82\x5a\x24\xcd\xed\x19\x67\x41\x06\x15\x23\x16\x38\x69\x83\xed\x96\x30\x31\x26\x20\xaf\x00\xc2\xb5\xf0\x97\xda\x3f\xd1\xfb\x8a\x0e\x1a\xa1\x65\x9d\x72\xfd\xc1\xd5\xaf\xdc\xdb\xe9\x40\xd9\x13\xcb\x4f\x5c\xf9\xf2\xcf\xde\xcc\x93\xf0\xfb\xdd\xfb\x15\xb7\xa4\xfc\xf8\xe7\x23\xca\xaf\x9b\x6f\x5c\xb7\xb4\xcf\xfa\x45\x5f\xbd\xf2\xc2\x45\x72\xee\x3d\x30\xbe\x58\xa7\x01\x19\xa0\x77\x34\x9f\x95\xbc\x4e\xe0\x30\x9a\x4c\x1e\x87\x53\xe2\x7c\xfe\x0c\x87\x03\x56\xca\x0e\x87\xd1\xe5\xc2\x06\x9c\x0b\x09\x3a\xcc\xda\x8d\x36\x22\x50\x52\x63\x19\xa0\x81\x9d\x14\xce\x66\x53\xba\x83\x66\x61\x66\x04\x72\x09\x2b\x0a\x41\x54\xd6\xfb\x7b\xe5\xfa\xc5\xd3\xcb\x9e\xee\xb4\x7f\x88\xf2\xc3\x45\xac\x14\xbf\x03\xf3\x21\x54\xf4\xe8\xfd\xda\x3f\xe1\x2f\x4c\xcb\x8f\x2e\x9f\x7f\x7b\xd9\x9a\x3e\xa7\x0e\x62\xeb\x93\xf9\x0f\x2c\xf4\xc1\xef\xf6\xef\x56\x88\x80\x5d\x88\x65\x5d\x0f\x3a\x2b\x0a\xef\xad\xce\x0e\xdd\xc8\x65\xb6\x58\x80\xcb\x6d\xe7\x32\x7c\x2e\xcc\xe6\x19\x97\x19\xff\x2d\x7a\x3c\xb0\x5c\xf6\x58\x45\x63\xb9\x2c\xfa\xeb\x3b\x96\x23\x0d\x26\x82\x86\x60\x22\x78\xa0\x2a\x8c\x80\x8c\x50\xc1\xe8\xb2\x42\xac\x37\x5c\x35\xe8\xc0\x99\x03\xab\xa0\x94\xf3\xa8\xbb\xf6\x5f\xef\xd5\x81\xcf\xce\x2a\x8b\x51\x15\x3a\xaa\xdc\x73\xef\xd3\x7b\x0e\x3e\x5d\x6b\x7e\xf2\x19\x50\xf7\xee\x15\x68\xf2\xc2\x29\x27\xd4\xbb\xb4\x0d\xef\xe9\x64\x8c\x67\x13\xac\x15\x36\x0f\xeb\x3c\x92\xe0\xb3\xbb\x9b\x00\xe0\xf6\x49\x0e\x1d\xdf\xb4\x99\x9b\xa6\x01\xda\x3c\x1e\x4c\xa8\x4d\x3c\x4d\x3c\xc8\x89\xf2\x48\x51\x8f\x95\x6c\x6c\x32\x56\x93\x4e\x9f\xc9\x10\x08\x4f\x29\xa0\xb8\x4d\xa2\x83\xb6\x36\x42\x89\x8c\x90\x48\x68\xf3\x59\x6d\xd9\xc9\x4d\x94\x9f\xdf\x58\xfd\x6e\xd5\xd0\x2d\x47\x1e\x9e\x7e\xfe\x59\x38\x21\x56\x8d\x26\x28\x33\x4f\x9e\x1a\xb0\xfa\xc4\xaa\x71\x6d\xd6\xae\x84\xb6\xae\x13\x77\x3d\xd4\x77\xd5\xe8\x01\xb7\xf7\x2f\x68\x36\xb0\x7d\xef\x4e\x6b\x60\xb3\xb5\x77\x2a\xcf\x58\xd6\xdc\x39\xe8\xd6\x5e\x05\xd9\x2d\xbb\xb4\xba\x71\xd0\x25\xfa\x4d\xf3\xf1\x5d\x1a\x88\xf9\x6b\x88\xce\xe9\xca\x42\x99\x28\xc3\x60\xc4\x62\xc4\xeb\xcd\xcc\x34\x8a\x08\x9b\x6d\x21\x10\xc2\x96\x08\x00\x7e\x8b\xdf\x5b\x29\xfb\x6d\x06\x92\x7d\x59\x29\x5b\xd8\xfa\x7d\x65\xeb\x5f\x3b\x22\xb2\xe2\x37\xaf\x7e\xa3\x6c\x1d\xb6\xaa\x04\x46\x47\xae\x21\xfe\xdc\xd0\x7c\xa6\x6a\xd5\xca\xc5\xd3\xd7\x59\xce\x38\xbe\x3b\xff\xcf\x6f\xa6\x6c\x51\x3e\xfd\xe5\x9e\x11\x6e\xe6\xeb\xda\x21\x91\xe7\xce\x2a\x6d\x99\x5f\xef\x5c\x78\xeb\xed\x77\xdf\x21\x1d\xb9\xf8\xd4\xd1\x95\x33\x97\x9d\x9d\x35\xad\xfd\xc6\x59\xf7\x7c\xb5\x99\x7e\xc3\x1c\x2c\xab\xba\x63\x5a\xf7\x81\x9e\xd1\x3c\x1d\xef\x91\x48\x31\x86\x64\xe7\x39\x7f\xa6\x07\xcb\x2b\x8f\x07\x39\xdc\x34\xf3\xdd\x81\x10\xd6\x68\x52\x6b\x32\xd2\x32\xc2\x53\xc2\x8b\x0e\x36\x75\x66\x07\x09\x24\x87\x8b\xa9\x7b\xb9\x88\x65\xbb\x2b\xbf\x7d\x7d\xf6\x8f\xec\x7f\x84\xb7\xdc\xb1\xe9\xfe\x63\x07\xae\x9e\x42\x77\xc4\x62\xdd\xbe\x82\x10\x9e\xfb\xd7\xf5\xe7\x1e\x76\xde\x33\xeb\xe1\xad\x1b\x37\xc0\x97\x76\xef\x56\x5e\xff\x8a\xe0\xb7\x0f\xe3\x17\xc2\x74\x93\x41\xf0\x73\x39\x4d\xc4\x30\x35\xb0\xbc\x13\xdf\x44\x13\x66\x61\x26\x93\x0d\x1b\x18\xe5\xb2\xcb\x65\x73\x19\x79\x1d\x4f\xb9\x5c\x59\x32\x27\xbf\xc1\xbc\x5b\xda\x2e\x25\x8e\x92\x53\x6d\x3c\x9e\x98\xa3\x87\x6e\xbd\xf7\xbe\x17\xde\x42\xa3\x95\x8c\xde\x6f\x7f\x79\xed\xf5\xe7\xbe\xc8\x3d\x66\xdb\x5e\x05\x4d\x70\xe4\xe4\x09\x70\xe5\xda\xb5\xca\xd1\x43\xc7\x9e\xdb\xff\x90\x79\xdc\x1d\x74\xef\x16\x61\xdc\x5a\x73\xd7\xb0\xe5\x4f\x22\x8f\x22\xbe\xb1\x39\x59\x6e\xa3\x31\x4b\x44\xcd\x0a\x40\x76\x38\x7b\xa0\xec\xb6\xe4\xe7\x85\xad\x16\x4c\xd9\x92\x64\x49\x74\xde\x79\x1e\xcb\xd6\x34\x32\x8e\x63\xa6\xce\x3e\x41\xf5\xa7\x9e\x30\xf9\x2d\xd5\x99\x3f\x52\x5b\xd2\xca\xfa\x72\xf6\xd0\xa1\x7b\x96\xf6\x6f\x76\xed\xfd\x0f\xbe\xcf\xbd\xcf\xf7\xe0\xa6\x65\x2b\xf3\xfb\xce\xe8\x33\x7f\x41\xd9\xb6\xed\xff\xf8\x15\x9d\x1e\x37\xb8\x5b\x73\x47\x5e\x87\xde\xe3\xa3\xf7\x1d\x5a\xb6\x2e\x38\x7c\xe0\x80\xca\xd6\x65\xcd\xb3\xec\x81\xc1\x8b\x2a\x66\x2c\x81\xa3\xfa\x2b\xc3\x97\x24\x7d\x17\x6c\x39\xb6\xfd\x33\x40\x59\xd4\xe2\x36\x72\x1c\x2f\x02\x1e\xf8\xfc\xac\x5b\x15\xc9\x2c\xcb\x5b\x48\x15\xa5\xd1\x22\xea\xac\x3c\x71\x05\x95\x45\x1a\x09\xd0\x6b\x53\x0e\x38\x62\xf1\xbb\x9c\x91\x94\xbe\xff\x52\x67\x86\xed\x5a\xad\xbc\xab\x5c\x7b\xec\x88\x91\x1d\xf5\xef\xf3\xaf\x3c\xb1\x68\x7e\xf5\xbd\xaf\x7c\x7c\x1b\x33\xe3\x7e\xe5\x87\x77\x26\x2b\xef\x70\xd7\xaa\x7a\x5f\xfa\xe5\xeb\xe3\x07\x2f\xff\x33\xf6\x73\xbf\xa3\xef\x51\x7e\xc1\x98\x31\x82\xe7\x68\x7d\xa7\xe3\xb4\x36\x22\x0c\xf3\xd8\x57\xe2\x7d\xdc\x49\x9f\x7e\xc6\x5c\xc3\x5d\xfe\xab\x0d\xf5\xc3\xc0\xe9\x00\xa0\x91\x5a\x3d\x68\x30\x6a\x41\x80\xd5\x01\x32\x39\x1d\xcb\x07\xe2\x79\x7d\xa5\x28\xa5\x6b\x77\x48\x63\x1c\x70\xfa\x03\x7b\x1f\x20\x20\x28\x18\x08\x16\xe3\xf7\xf4\xa6\x3e\x71\xac\x6f\xea\x59\xb3\x59\x82\x34\xd4\x42\xc3\x29\x2c\x30\x59\x45\x6b\x85\xac\x17\x01\xfe\x9b\xb1\x10\x27\x88\x3a\x0b\xa8\xde\x28\xa0\x78\x62\xb2\x5d\x9d\x25\xa0\xb5\x00\x56\x43\xd9\x8b\xe1\xda\x63\xb0\x5a\x99\x4e\x7e\x8e\x29\x33\xe1\x5a\x65\x26\xcb\xc3\x0b\x4a\xfb\x1d\xca\xe5\x1d\x4a\x25\xdc\xb7\x03\xb6\xa1\xfe\x5c\x06\x7f\x33\x73\x89\xeb\x66\xe3\x49\x56\x15\xfe\xc1\xb6\x04\xfb\x0e\xbf\x0e\x18\x68\xc6\x47\x1e\x98\x1b\x8d\x7a\x05\x87\xd1\xa0\x47\x88\x67\x20\x0c\x85\x72\x83\x1c\xcf\x67\xe5\xe4\x64\x66\x06\x8d\x02\x9b\xdf\x24\x27\x14\xf2\x58\x3d\x15\x72\xb6\x15\x05\x73\x73\xbd\x02\x16\x56\x01\xc1\xc6\x41\x03\x5c\x3b\xca\x80\xaa\x65\x03\x07\xca\x0a\xe2\x59\x7e\xf4\x0b\x12\xbf\xa4\xd3\x65\x24\xee\x49\x8f\x53\x69\x71\xc4\x1d\x69\x1b\x71\xea\xc2\x48\x64\x68\x96\x88\xcb\xa6\x8b\xe7\x8b\xc0\x50\x7c\x76\x1d\xf3\xde\xe4\xad\xcc\xe6\xc9\x0f\x3f\xf8\xeb\xa5\x4b\x0f\xcc\xbb\xff\x59\xf9\xd0\xd4\xf9\xac\xe7\xa6\x19\xcc\x7b\xb1\x57\xe1\x5d\xca\x2b\xf0\x2b\x65\x01\x5c\xc4\xcf\x75\xcc\x9f\xef\x78\x2b\x66\x52\xee\x57\x8e\x72\xdd\x97\x2a\xdf\xd4\x42\xe6\xf7\xeb\x3f\x43\xb3\x32\xa2\x9a\xf5\xed\x5e\x7d\xfd\x13\x90\xf8\xfe\xf3\xdc\x8e\xc4\xf7\xcf\x8a\x76\x49\xfd\xfe\xac\xac\x9c\x00\xfe\xfe\x60\x38\x9c\x9b\x1b\xa0\xdf\x9f\x99\x53\x29\x87\xb2\xf0\x8f\x95\xec\x82\x15\x91\x0d\xc8\x4c\xdb\x00\x29\x65\x03\xe2\x3e\xe3\x82\xff\xc3\xb7\xdb\x13\x63\xfb\x98\xd3\xda\xb7\xbf\x91\xfe\xed\x87\x61\xa5\x72\x11\x7e\xae\xec\x82\xab\xb9\x65\xea\x87\xd7\x35\xf2\xe1\x4b\x51\xc1\x9a\xa5\xb5\x6f\xaf\x21\xdf\x5d\x54\xf7\x05\xfb\x0a\x9d\x03\x1c\x04\x05\xa0\x18\xac\x8d\xf6\xcb\x12\xf3\x02\x1e\x8f\x37\xfe\xe9\x85\x85\x2d\xf0\x97\xb7\x2c\x6a\x53\xd4\xc2\x2b\x72\x25\x6d\x8b\x0a\x5b\x15\x96\xcb\xad\xac\x2d\x22\xcd\x23\xe5\x72\x73\x67\xa6\xd3\x03\x6d\x4d\xcb\x65\xa7\x4d\x24\x75\x3e\x46\x8b\xeb\xbf\xef\x41\x24\x35\xf8\x99\x9a\x6b\x9f\x0c\xd0\xa5\x3a\x35\x92\xdb\x01\x35\x17\x70\x6a\x8f\x9b\xbc\x62\x94\xd6\xe2\x26\xb1\x3b\x2f\x6b\xbb\xa3\x8c\xca\xea\xdf\x7d\xde\xf4\xef\x7b\xf6\x0d\x32\xcc\x3e\x6e\xbb\xa1\xb6\x7d\xb7\xae\xed\xda\x75\xe9\xda\x09\xbe\x9c\xd8\xa9\x85\xda\x4e\x5d\x7f\x79\x78\x19\x74\x42\x2f\x53\xd2\x61\xe8\x12\xb8\xfe\xba\xfd\x64\x0b\xcf\x04\xb8\xf7\xd3\x17\xdf\xfd\xf4\xad\x17\x5f\x8c\x31\x89\x4d\x63\x80\x8c\xf9\xf2\x9d\x58\xa6\x71\x74\xd2\x5e\x10\x01\x93\x28\x3a\x39\xc0\x62\xa5\x48\x5f\x21\xdb\xed\x82\x05\xab\x6c\x08\x22\x80\x92\x49\x28\x09\xb7\x4d\xdc\x18\x8b\xd0\xdb\xdb\x56\xb5\x72\xc3\x5a\x91\x7a\xbe\x7c\x00\xb6\xbb\xb3\x63\xcf\x51\xfd\xce\xc2\x71\x7b\x1e\x98\x3a\x88\xeb\x7e\x7d\xf8\xee\x63\xf9\xcb\x37\x91\xfa\xf4\x1e\xff\x7c\xb1\x09\xa9\xc3\x92\x31\x5f\x9d\x43\xe7\xcf\x38\xb1\x5e\xd6\x2f\xea\xb5\x8b\x2e\x93\xc9\x0b\x80\xc5\xc9\x89\x58\x2d\x73\xbb\x06\x8f\x72\x03\x09\x21\x3d\xe1\xb2\x56\x19\xf9\x45\xcc\x60\x44\x9b\x60\x29\x97\x05\x6b\x4a\x04\x23\xd5\x40\x8c\x6b\x3a\x89\x38\x91\x5a\x3b\x0f\x25\x75\x60\x49\xc4\xc9\xce\x79\xe5\x89\xf1\xa3\x87\x8d\x9c\x7d\xb7\xf2\x26\xbc\x72\xfd\x93\x03\x70\x37\x6c\xfe\x98\xff\xa9\xd7\x5d\x1b\x6c\xcb\x66\xa3\x17\xaa\xaf\x5f\xa0\xd8\x92\x72\x75\xb5\x5e\x0c\x60\x3c\x4b\x29\x9e\x76\x90\x09\x86\x46\x9b\x8a\x26\x93\x1d\x38\xbc\x5e\x0e\xa0\x60\xc0\xef\x2b\x97\xfd\xd0\xe1\x71\x7b\x48\x99\x98\x24\x0e\x1e\x25\x01\x15\x43\x8a\xf7\x49\x8c\x76\x3a\xaa\xf5\x73\x8d\x1a\xc5\x97\xcc\xdc\x86\xb4\x55\x06\xd9\x54\xb6\x94\xe0\x3c\x74\x14\xc6\xf9\xdf\xf0\xc9\xc7\x1e\x8b\x75\x7c\x21\x76\xe1\xcd\x37\xe1\xac\x14\xb4\xdf\x38\x77\xee\xfa\x62\x6d\x80\x75\xf2\x6c\x25\xda\xc3\x3f\xdf\xc0\xf0\xbc\x8e\xf8\xaa\x33\x82\x41\x3a\x5b\x2f\x9c\xe9\xc7\xf7\x1c\xd9\xdc\x15\x32\xb6\x7e\xa0\x1e\xe9\x6c\x46\x2a\x01\xc8\xe8\x8e\x7a\x87\x9c\x10\x5e\xb9\x28\x8c\xcd\x7f\x22\xbd\x60\x24\x8f\x21\x36\xb8\x3b\x81\xb3\x7a\xf4\xf0\xdf\x7f\xf2\xac\x71\xcf\x1e\x08\x79\x24\xec\x7b\xba\x5d\x51\xcb\x36\x03\x6f\xd8\x06\x4b\x37\x40\x34\x3a\xa8\x9c\x2f\x55\x4a\xb9\x6e\xb5\x1b\x32\x60\x97\x01\xf0\x85\xbf\x9e\x72\x5a\xf6\xdb\xd7\xae\xa3\x24\x71\xe5\x35\x75\xaf\x09\x4d\xdc\x49\x63\xbf\x21\x9a\x8f\x58\x98\xc0\x3c\x3b\xf3\xff\x91\xf6\x1d\xf0\x55\x15\xd9\xff\x33\x77\x6e\x79\xbd\xf7\x5e\xf2\xd2\xfb\x4b\x08\xa1\xe5\xd1\x8b\x94\x24\xd4\x47\x11\x90\x22\x4d\x04\x29\x4b\xef\x1d\x0c\x08\x88\x82\x08\x08\xa8\x80\x0d\x34\x14\x65\x45\x5c\x59\xd6\x02\x2a\xe8\xaa\xab\xfe\x56\xdd\xb5\x97\x75\x57\xdd\x55\x21\xb9\xfc\x67\xe6\xde\xd7\x92\xe0\xfe\x7e\x9f\xff\x07\x09\x04\xf3\x66\xce\x99\x72\xda\x9c\xf3\x3d\xde\x88\xc9\x64\xb0\x0b\x6c\x76\x4e\x38\x34\x78\x54\x98\x0b\xf8\x6b\xe3\x01\x3d\x21\x9e\xa6\x5b\x7a\x54\x80\x3c\x6f\xc8\xe4\xb7\xe0\x22\xfa\x5f\x18\xc9\x58\xff\xb0\xbc\xfe\x19\xcc\xc0\x6f\xa4\x73\x33\x6f\xf9\x47\x70\xc5\xc9\x93\x6d\x32\xe4\xa5\xdb\x91\xea\x89\x8e\xc0\x60\x99\x1f\x72\x76\xf2\xc1\x98\x58\x51\xc8\xe3\xf1\x5a\xf2\xe9\x09\x02\xf9\x9c\x97\x2d\x28\x0c\x65\x67\xe3\xa3\x93\x6d\x08\xe8\x2d\x5e\xe9\xfc\xc0\xdf\x3c\x3f\xd1\x9a\x36\x45\x4e\x8b\x33\x94\xe0\x21\xb3\xef\x78\xa2\xdf\x38\xfb\xbb\x04\x33\xaf\xc2\xe9\xf8\x3c\x3d\x58\xd5\xb5\xf7\xa8\x87\x48\xd7\xf1\xe0\xac\x11\x77\xce\xf4\x64\xf0\x71\xed\x27\xe6\xf4\xc6\xd5\x8d\x7b\xa5\xfa\xda\xa7\xc6\x4e\x6c\x7c\xa5\xb9\xe4\x46\xab\x9e\x08\xca\x9e\xd0\x0d\x40\xaa\x27\x82\xd1\xfe\x5f\x30\xe6\x36\xfc\x4c\xf1\x8d\xca\x28\xbe\xd1\x5f\x1a\xa3\xd5\x7a\xf4\x5b\xb8\x23\xa9\xf1\x25\xec\x1d\xbd\x55\xcd\xb7\x8d\x3b\xa2\x90\x70\x47\x36\x20\x5a\xb3\xa1\xa6\x35\x1b\xdf\x37\x6a\xcd\x6c\x26\xa6\x71\x8b\xba\xda\x34\xfa\x29\x76\xba\xd3\xff\x5f\x6a\x76\xe5\x9a\x6f\x09\x6b\xd3\x1d\xfc\x2d\x3c\xee\x34\xda\x29\xbe\xb6\xd5\x2d\x18\x7f\xb3\xbe\x68\x03\xc8\xc0\x5d\xf4\x86\x9d\x6d\xd4\x17\x09\x05\x89\xf1\x15\x3f\x31\x93\xf1\xff\x70\xc7\xf4\x88\x21\x25\x33\xf8\x2b\xb4\x5b\xa5\x39\xa4\x92\x93\xf4\x79\xf8\x69\xd2\x3c\x86\x6c\x30\x0d\x02\x83\xa0\xec\x87\x4d\x49\x47\x9b\xe3\xfe\x3b\x6d\x5c\xbf\x34\xae\xd7\x7d\xd3\x71\x2f\x65\x8e\x0b\xe6\x83\x55\x37\x19\xf7\x3f\xb4\x31\xa0\x34\x6e\x88\x8e\x0b\x1c\x96\xff\xed\xb8\x64\x75\x6e\x32\xee\xcf\xad\xe9\x75\xfa\xff\xd7\xf4\x76\xbf\xb1\x53\x1e\x97\x62\x71\x91\x3c\x01\xc6\x95\xaa\x4f\xa2\xf3\x64\x65\xae\x37\x8b\x18\x2b\x97\x8d\xbf\x02\xb3\xdc\x33\x24\x63\x1e\x09\x63\xba\x56\x3a\xf3\x64\x9e\x7f\x7c\x87\x4f\x43\xbf\x1b\xdf\x01\x11\x74\x8b\x19\xd9\x0e\x31\x97\xa7\x4f\x87\x98\xc5\x82\xbf\x18\x4c\x7d\x3a\x90\xe2\x30\xa3\x56\x87\xbf\x53\x6b\xfa\x74\xa0\x10\xd6\x78\xec\x34\x00\x6b\x79\x78\x23\xc1\x47\x95\xeb\x26\x5b\xd2\xf6\x0b\xa5\x8d\xd6\x7a\x1b\x69\xef\x10\x8b\xb5\x55\xef\x90\x16\x74\x31\x7b\x00\xa5\x0b\xff\x4f\x11\x74\x89\x19\x51\x25\xa1\xab\x92\xd0\x55\x49\xe8\xaa\x24\x74\xe9\x31\x5d\x95\x84\xae\x4a\x09\x59\x9b\x50\x95\x80\xfe\x26\x43\xa7\xd3\x44\x7b\x8d\xd0\xfa\xbd\x0d\x72\xfd\xde\x11\xb9\xd6\x9e\xdc\xad\x53\x0e\x27\xd2\x65\x9c\x67\x8a\xad\xcd\xd5\xe3\x9f\x3f\x42\xce\x3f\xa5\x04\xff\x34\xea\x82\x27\xc2\x4e\x97\x29\x37\x55\x23\x44\xf1\xc3\x2e\x73\x23\x41\x00\x4c\x8b\xb5\xb7\x28\xdd\x7e\x8f\xc3\x01\xf4\x3a\xbf\x52\xc7\x2a\xd9\x60\x08\xb9\xdc\xae\x71\x71\xe0\xf6\xfb\xb0\x3d\xeb\x87\x1a\xe4\xf6\xeb\xf5\x7e\x37\xe2\xb1\xa3\x32\x36\xae\x61\x79\xdb\xd8\x38\xdf\x2a\x65\x94\xf6\x66\x4b\x15\x72\x12\xfc\x04\x29\xba\x90\x96\x3d\x64\x4d\xe4\x0f\x06\xcc\xc9\x94\xc1\x2a\x0a\xd3\x47\xb3\x06\x57\xac\x48\xe6\x0d\xc2\x91\x73\xe4\x84\xc1\xad\xcb\xc5\x2b\xb0\x04\xff\xfe\x08\x9e\x5a\xf5\x54\x32\x6d\x50\x3c\x29\xa7\x0b\xde\x72\xdb\xaa\xe9\x07\xa4\x37\xf2\xc9\xe2\x08\x76\x24\xed\x81\x5f\x01\xa6\xc7\x4a\x03\x7e\x7f\xb1\x22\x27\xa2\xc7\x27\xd8\xa6\xb0\x55\xb6\x0b\x04\x3c\xc0\x13\xc2\xc6\x86\x9b\xe1\xca\xb8\xda\x78\x59\x19\x30\xe9\xd5\x05\x58\x53\xa8\x0d\xce\x6c\x90\x7d\x06\x3a\x9f\x89\xd3\xee\x5b\xe5\x69\xa6\xaa\xdc\xf8\xaa\x8d\x3c\x8f\x64\x43\xb5\x28\x69\xbd\x92\x86\xbd\x58\xd1\xae\x2a\x8a\x35\x06\x66\x58\xea\x9e\x4c\x8d\xbb\xaa\x20\xac\x48\xe5\xec\x77\x81\x93\x99\x1b\xcc\xf8\x7f\xbd\xf4\xc2\xab\x17\x67\x1f\x29\x62\x14\x78\xb3\xbb\xdd\xe2\xb9\xf2\xe2\x43\xef\x66\x9d\x2c\x79\x76\xea\x02\x7b\xb3\x86\xb9\xd1\x67\x65\xed\xba\xa5\x0b\xb7\xd4\x2d\xef\x0d\xb9\x3f\x81\x1b\x90\x87\x10\x0a\x53\xc7\xfb\x76\x0a\xed\x8e\x35\x3d\x32\xe6\xe1\x47\x16\xce\xf1\xad\x1a\x39\x95\x39\x38\xef\xa9\xd1\xbf\xbf\xf0\xca\xb3\x63\x9e\x4a\xc3\xb5\x3b\x92\xc0\x87\x4b\x93\x9d\x14\xd7\xce\x1b\xfe\x2f\xd8\x73\x1b\xfe\x9e\xa6\x57\x7e\xc4\x7a\x25\x85\xe8\x96\xac\x23\x7a\x8d\x8e\x5f\x2c\x8f\xef\x90\xa4\xad\xd4\xa7\xe5\x89\x46\xbd\x95\x53\xa7\x61\xec\xd0\x1c\x39\xfe\x08\x50\xe3\xb5\xad\x8d\xe5\xa9\x20\x54\x4b\x50\x40\x4a\x35\xab\xc6\xc6\xb2\x5e\xab\xdf\x32\x4a\x6b\x6c\x88\x6b\x19\x46\x80\x2a\x41\xc5\x72\x04\x3d\x8a\x26\x81\x5d\x90\x5f\x56\x6a\x0a\x5a\x34\xdc\x4f\x64\x5c\xa5\xa1\x03\x31\xe1\x1c\xd9\x51\xc8\x84\x09\x12\x97\x1e\x16\xa7\x7c\xc9\x7c\x30\x95\x26\xcc\x71\x3d\x9b\xbe\x94\x52\xe5\xb8\x87\xbf\xb7\x6c\xda\x64\x91\x74\x99\x38\x94\xe6\x31\x51\x5d\x66\xe0\x99\xbd\x59\xb2\xce\xc2\xff\xde\x97\xd6\xd9\xd7\x4b\xff\x9e\x03\x52\x3f\x9f\xc0\xc2\x30\xe4\x48\xf5\xb5\xa4\x86\x33\x04\xda\x46\xc4\x48\x8c\x45\xef\x28\x19\x2b\x5b\x29\xad\xf6\xde\xa2\x9b\xa0\x62\xd0\x79\x2a\xc4\x61\xec\x36\xfe\x88\x21\x1b\x2e\xf4\x4a\x6b\x4d\xfe\x87\xe2\x19\xe8\xe3\xb2\x13\x98\xe4\x9b\xb1\x8d\x54\xcf\x35\x62\x29\x34\xd8\x98\xa8\xd9\xc7\x3f\xe1\x35\x92\x9f\x90\xf0\x9e\xd0\x89\x04\xde\x53\x1a\xd6\x8a\x89\x20\xc3\x58\x5c\x82\x21\x0d\xab\x54\xf2\x7f\x7b\x62\x3f\xd0\x84\xfd\xdf\xfe\xb1\x1c\x8f\x0d\x3b\x12\x56\x15\xd0\xb3\x2c\xb0\xba\x58\x9f\xd7\x65\x97\x12\xe2\x1c\x1c\xb2\xba\xdd\x7a\xd2\x4f\xc6\x42\xb3\x2d\x6f\xe6\xdd\xa7\xd5\x39\xfd\x86\x1b\xbf\xed\xb7\xdc\x77\xe6\xf8\x6f\xfb\xed\x2d\xe9\x1e\x1a\x2b\xd4\xb3\x2a\xe0\xb2\x59\xdc\x56\xa7\xd3\x02\x58\xd6\xeb\x73\xda\xec\xb6\x71\x71\xbb\x9d\xe5\x08\xf5\x1c\xb2\xb8\x5c\x94\x78\x73\x06\xf1\xad\x03\xeb\xd1\xf4\xa4\xae\xdf\xf0\xc5\xb7\xdd\xd4\x07\x6f\x93\xfa\xa4\x1f\x89\x92\xbe\x37\xc9\x3d\x2b\x00\x13\x63\xed\xf2\xb3\x72\xf3\x22\x61\x8f\x45\xa7\xd3\xdb\x78\x5e\x1f\xce\x65\x8b\x0a\x73\x23\xd9\x11\x6c\xe5\xea\xc3\x79\x21\xec\x64\x87\xac\x66\xab\x0e\x2a\xfc\x52\x05\x89\xb3\x55\x05\x49\x1b\xbe\x75\x62\x23\x24\x03\xfe\xff\xe0\x47\xc3\x2b\xff\x1b\xf7\x79\xc9\xff\xd2\x6d\x4e\xca\xa7\x07\x92\xf2\xa9\x3b\x3c\x25\x9f\x48\x6c\x71\xc0\xbb\xdc\xbe\xdf\x96\x4f\x60\x7e\x37\xe9\xc6\x54\xe2\x1b\x53\x57\x56\x91\x26\x9d\xa4\x1a\x88\x05\xf8\x1c\xd8\x49\x56\x9c\x05\xfb\xe3\x40\xab\xc5\xea\xd0\xa8\x74\x38\x2d\x7a\x29\xb7\xc8\x68\x33\x21\xa3\x49\x8d\xc6\xc5\xd5\xc9\xa7\x72\xf9\x21\x3a\xd1\x5d\x15\xaf\x91\xf4\x28\x99\x4a\xb7\x0e\x06\x9c\x30\x48\x25\x4d\xd0\x18\x65\xde\xee\xd4\xbb\x77\x6c\x8f\xf8\x57\xf1\x03\xf1\x8d\x43\x87\x60\xd9\x21\x38\x7f\xeb\x5d\x73\x1a\x98\x0d\xcd\xa3\xc4\x1d\x70\x1a\xf4\x35\x6f\xe1\x7a\x36\xbf\xca\xb4\xa3\x7d\x59\xf0\xfd\x9c\x8a\xf5\xad\x0e\x7b\xe9\x1d\x63\x5e\x9b\x92\xe3\x78\x3d\xe0\x81\xcb\xcd\xdb\x62\x36\x76\x6c\xdc\x66\x22\x9a\x55\xa9\x61\x49\x71\x52\x22\x4a\x44\x3a\xf2\xb7\x8a\x7d\x02\x2a\xec\x68\x25\x18\x49\x80\x24\x85\xbb\xa8\x1d\x30\xb1\x53\xff\x28\xee\xff\xdb\x0b\x67\x60\xa7\xc6\x69\x6f\x7d\xf2\x92\xf8\x53\xbc\xa1\x0e\x3e\x00\xcd\xf7\xa1\xdb\xdf\x15\xa7\x88\x7f\x18\x29\xfe\xcc\xff\xe3\xf0\x88\xf1\xbf\xfe\x0a\x87\x8f\x3f\x36\xa1\xe9\x44\x27\x68\x87\x13\x53\xb8\x4d\x7b\x13\xb8\x4d\xca\x6e\xe0\x0f\x92\x2c\x37\x53\x59\xbe\xa7\xd1\x60\xe6\xd3\xf1\x41\x2e\x4a\xb5\xc8\x04\x8b\xc9\x4c\xb1\xd3\xcf\x53\x59\xe3\xa4\xb2\x86\xc6\x10\x69\x1d\x3a\x30\x60\x5e\x49\x24\xe9\x50\x2c\xe6\xf1\x7a\xfd\x2e\x17\x50\xf3\x36\x2b\x32\x09\xd9\x6a\xb5\xd2\xc4\xd9\x1d\xc8\xc8\x06\xf0\xe2\x18\x4d\x46\x05\x8b\x04\x05\x52\x14\x15\xfa\x3d\x5b\xe2\x7e\x1d\xc7\xdb\xf8\xb1\x71\xbb\xcd\x94\xd7\x10\x37\x2a\x19\x93\x89\x98\x4e\x16\xa5\xa6\x8f\xcd\x64\x33\xb1\x3a\x5d\xb8\x21\xae\xfb\x50\x21\x20\x7a\x6d\xa3\xd1\xf4\x0a\x1b\x39\x39\x57\xee\xc2\x5a\x90\xd9\x3f\x26\x2a\x65\x10\xa7\xfe\x92\xd6\x3d\x92\x24\x13\x93\x6e\x6a\x72\x8b\x45\x14\x16\x78\x01\xff\x43\x36\xa2\xf8\x6d\xf6\xf4\xde\xb2\x23\x86\xc3\xd7\xfe\xb0\xa9\xf9\xf2\xc6\x0b\xf0\xca\x98\xb5\x77\xdc\xb9\xfa\x0b\x93\x2e\x62\xdd\x02\x9f\x5d\xdf\x6d\x26\xc1\x76\x1b\xd6\xb5\x7d\x55\xf7\xee\x55\xed\xbb\xb2\x67\x6f\xaf\xbe\xfe\x19\xec\x2e\x3e\xcf\xda\xab\xa7\xc7\x67\xde\x29\x7e\x9c\x37\xab\x44\x3c\x01\x07\x3d\x06\xdf\x20\xd0\x6f\x5f\x47\x8a\x8b\x23\xd9\xc5\xc5\x34\xee\x28\xd9\x93\x47\x41\x11\xe8\x00\x62\xa0\x3f\xb8\x1a\x8b\x77\xee\xd2\x25\xd6\x11\x45\x3a\xa2\xdc\xae\xa0\x77\x6e\x28\x0c\x72\xc3\x88\x6f\xef\x70\x1b\xcb\xcb\x79\x07\x3f\x60\xa0\x3b\x5a\x17\xd7\x87\xfc\xa1\x92\x10\xb2\xa1\x50\x0c\xaf\x50\x28\x14\x89\x20\xe4\xef\x17\x2b\xe8\xd1\x10\x2f\x88\x39\x83\x7d\x0a\x3a\xee\x77\x3f\xe5\xc6\xde\x55\xcc\xcd\xa8\x41\xbf\x59\xfd\x18\x23\xea\x47\x3a\xd6\x2a\xb5\x7d\x3a\x92\x3f\x8d\x4e\xfa\x67\xcc\xa6\xd6\xf7\x71\xf7\xeb\xd8\xb1\x9f\x1b\x15\x77\x56\x16\x5b\x8b\x6b\xe3\x46\x9d\x95\xc8\x14\x69\x39\x4b\xf0\x8a\x95\xd0\x66\x2a\xd8\xd0\xbb\x75\xcc\x18\xbc\xbc\xd2\x11\xa5\x0b\x4c\xab\x6c\x32\xea\x5a\x13\x85\x17\xd1\xc4\x92\xd3\xaa\x5b\x81\x75\xc2\x54\xf2\x4b\x22\x83\x23\xad\xd9\x8a\xdc\x72\x1d\xef\x01\x4c\x34\x5a\xc1\xeb\x6e\x6e\xbd\x0d\x03\xa3\x95\x90\xc9\xef\xe8\x0a\xf6\xe8\x3d\x71\x14\xcf\x77\x3d\xb1\x6a\xdf\x01\x78\xf1\xdb\x69\x73\xe7\x4f\x51\xfd\x3e\xeb\xe7\xb2\x52\xb2\x35\xe2\xbe\x71\x3b\xeb\xcf\xcd\x5f\xd2\x33\x3e\x99\x6c\xcd\x98\xe4\xd6\x7c\x59\x31\xd2\xd3\x49\xfc\x58\x2c\xae\xad\x13\x66\x19\xa6\xce\x5a\x38\xed\xf1\x5d\xb4\x03\xcb\xea\x39\x43\x46\x18\xbf\x2a\xf1\x8c\x28\xc7\x1b\x76\xbd\x72\xf4\x9e\x7a\xd2\x7f\x65\x42\x7d\xfd\x44\x6e\x82\xe5\x79\x6f\xe3\x3f\x93\x7b\x96\xb4\xd1\x8f\x26\x6c\x74\xec\xad\xfd\x3b\x0d\x5b\x07\x72\x8d\x36\x27\x4a\xbf\x3b\x92\x8d\xde\x98\xb0\xd1\x13\x7d\x04\x50\x67\x6c\xa3\x8f\xec\x1c\x33\xe5\xa4\xfd\x2c\xed\xcd\x45\xc7\xde\x23\x8f\x3d\x51\xc2\x36\x40\x61\xec\x92\x4c\x0a\x67\xb7\xf0\x7f\x69\xcf\x06\x3a\xf6\x73\xd2\xd8\x13\xa5\xb1\xb3\xf0\xd8\x13\xb3\x72\x54\xe9\x76\x88\x74\x47\xf7\x26\xfc\x1d\xe6\x4d\xc6\x03\x7e\x02\xce\x53\x88\xa1\x9e\xef\x99\x1b\xa7\x1b\x6d\xe6\x74\x8f\x07\x7f\x66\x2c\x8d\x3d\x1c\x31\x25\xb0\xe8\xdf\x84\x1f\x03\x40\x3f\xd3\x51\x72\x65\xc6\x34\xb6\xaf\x94\xe2\x0f\x2d\x30\xfa\x9f\x4c\xce\x73\x15\xfb\x55\x52\xaf\x34\x27\x8d\x0f\xb4\xec\x11\x29\xc5\x37\x9e\x4b\xce\x71\x95\xa9\xa3\xb2\x88\x4c\x81\x67\xb8\xdc\xd8\x31\x9a\x8a\x70\xdc\x48\xe0\x43\xef\x4d\xe2\x43\xbf\xc9\x64\x51\x3e\x18\x82\xf1\x4e\xd0\x3d\x0e\x35\x5a\x8c\x50\x9d\x41\xd3\x1c\x8a\x11\x7d\x44\xc6\x88\x26\x7c\xfc\x24\xf3\x91\x2d\xf1\xb1\xb5\x31\x1c\xd0\x5a\x32\x3e\x23\xcd\xf3\x64\x72\x9e\xab\xcc\x22\xa9\x97\x98\x9d\xca\xc8\x5f\x1a\xed\x7a\xa8\x6e\x85\x43\xfd\x5c\x72\x8e\xab\xd4\x9f\x24\x7c\x67\x93\x48\x47\xb6\x4f\x6b\xc9\xe0\xfb\x2e\x1a\xa7\xd9\x9b\xc4\x5c\x7d\x13\xfe\x98\xc9\x47\x03\xe6\x43\x8a\xd5\x24\x69\x5a\x49\x63\x35\x47\x64\x8c\x58\xc2\x3b\x03\x24\x64\x13\xab\x84\x6c\xb2\xb1\xd1\xa4\x67\x99\x8c\xcf\x48\xf1\xa0\x27\x93\xf3\x24\xf7\x83\x32\x02\xec\xfa\x36\xe3\x41\xcf\x25\xe7\xb8\xca\xcc\x92\x74\x83\x95\x46\x55\xfe\xd3\x68\xd5\xb2\x4c\x2b\x9c\xb5\xbd\x49\x9c\xb5\x37\x19\x9d\x7c\xae\x82\xd2\xb9\x3a\xda\x98\x89\x9a\x26\xef\x47\x5f\xca\x47\x7d\x8b\xfd\x08\x27\xf6\x23\xe0\x6d\xf1\x19\x69\x9e\x27\x93\xf3\xa4\xce\x55\x90\x9c\xab\x60\xcb\x1e\x7f\x52\xdc\xe9\xb9\xe4\x1c\xa9\xfd\x08\x93\xfd\x08\xbb\x5b\xfc\xbc\x84\x99\xb5\x37\x89\x99\xf5\x26\x53\x9a\xc9\xc7\x0e\xcc\x07\xa7\xcd\xe4\x83\xe2\x66\x1d\x49\xe0\x71\x25\xf9\x60\xb0\xd1\x40\xf7\x63\x36\xfe\x8c\xda\xda\xea\x5c\xed\xa6\x7c\x54\xca\x74\xcd\x90\x7a\x1b\x06\x29\x36\xd7\x1b\x8d\x41\x27\xd7\x1a\x9b\xeb\xb9\xe4\x1c\x57\x99\x35\xb2\xdd\x14\x24\xa8\x89\x41\xa7\x34\x7e\x0b\x0c\x9d\xbd\x49\x1c\x9b\xc4\x3d\x67\xa0\x57\x3a\x57\xa7\x1b\x5d\x76\x21\xb3\xaf\xc6\x52\x1a\x47\x3b\x92\xc4\x9b\x79\x13\x8a\x32\x1f\x11\x89\x8f\x1d\x8d\x21\xbf\x53\x93\xf1\x19\x69\x9e\x27\x93\xf3\xa4\xce\x95\x97\x9c\x2b\xaf\xb5\xcd\x58\xdd\x73\xc9\x39\xa4\xfd\xc0\xe7\x2a\x22\x47\xeb\x22\x5e\xa7\x26\x03\xab\xab\x3a\x1d\xab\x8b\xf9\x82\x99\x09\x28\x06\x8e\xa1\xac\x5d\x26\x56\x57\x75\x3a\x56\x57\xea\xe7\xf8\x82\xd2\x74\xac\xae\xfe\xf8\xe7\x52\x78\x5a\x69\x3f\xc7\x69\x8c\x5c\x5a\xbf\xd3\x73\x62\x75\x1a\x9e\x56\xfa\xbc\x2e\x3f\xd4\xcb\x3f\x47\x72\x1b\xb0\x5f\x57\x86\xed\xbb\x10\x18\x1e\x2b\xb2\xda\x94\x01\xb5\x57\xcd\xe8\xf1\xa9\x05\x5e\xc6\xc6\x86\xb3\x48\xb5\x5c\x40\xa9\xb4\xaa\xf1\x2f\xc6\xc9\xa0\xb1\x71\xc6\xe9\x34\x8d\x8d\x3b\xd9\xf4\x24\x64\x62\xc2\x10\x93\x24\xe3\xdd\x20\x91\x84\x66\x80\x95\x59\x80\xb4\xbb\xe3\xb9\xca\xc2\x8c\xd6\xed\x24\xf3\x84\x00\x87\xb0\x65\x4d\x5b\xe1\x70\x78\x6b\x7e\xe4\x38\xf6\x79\x27\xc3\x1e\x9b\x97\xcf\x79\xb0\xcb\xee\xa1\x3f\x1f\x59\xf3\xc7\x3b\x3a\xf6\x8a\xd5\xc2\x29\xcd\xff\x10\x6f\x3c\x32\x1e\x96\xff\xb1\xef\x9a\xdc\xf5\xf7\x3c\x31\xf3\x1f\xfb\xee\xbc\x6b\xc8\x8c\x41\xdb\x56\x8f\x3a\x32\x75\xd4\xdd\x7d\x3a\x3d\x81\x79\x39\x8c\xfd\x4d\x03\x3b\x10\x64\x83\xb1\x31\xab\xcb\x9d\xa5\x0e\xea\x74\xac\x02\x58\x82\x41\xc0\xba\xd9\x9c\x5c\x9d\x5e\xca\x49\xce\x52\xab\x5d\x3a\xfc\x8b\xf5\xb1\x9c\x84\x69\xc0\xfa\x7c\xf6\xda\xb8\xcf\xf0\xbf\xe5\x29\x62\xe1\x59\x99\x99\x1c\x9e\x15\x2a\x49\x26\x79\x8b\x46\xed\x98\x2b\xc3\x19\x71\xa5\x28\xc2\x2e\xb0\x4f\x51\xc1\xed\xe2\x5b\x7b\xfe\xfe\xe1\xea\x1e\x8b\x17\xdc\xb5\x2e\x72\xb4\xe2\xfd\xe7\x2f\xfd\x39\x56\x5d\xd5\xed\xef\xf7\x36\xff\xb1\xdd\x03\x03\x7e\x7c\xb0\xa6\xbf\xb3\xe2\x56\xf7\xce\xf2\xba\x5b\xe7\xf6\x9d\x3c\x63\xe8\xe8\x60\xc3\xfa\x27\x1f\xab\x6d\xa8\x2c\x59\x08\xd2\x30\x4a\xc9\xd9\x2e\x68\x3b\x1e\x9e\x16\xb5\x48\x61\xd1\xff\x9e\xd6\x32\xd5\xc5\x0a\x59\xb3\xd9\xe2\x74\xd8\xac\x2e\x8f\x57\xad\x52\x79\x5d\x0e\x0b\xe7\x0f\x78\x1c\x36\xc7\x96\x51\x36\x57\x43\xdc\xc6\xa9\x49\xb9\x64\x6d\x9c\x05\x02\x5e\x84\x0b\x92\x33\x96\x8c\x5b\xa4\xb9\x60\x72\x86\x79\xb4\x0d\x78\x74\x98\x0c\x61\x64\xa2\xd0\xc3\x9f\xe5\x10\x06\xd7\x43\x94\x50\xd2\x4b\x98\xd3\x14\x25\xfd\x6e\xee\x59\x29\x8a\x01\xa9\x9f\xd1\x19\x9f\x43\x13\x28\x89\xd9\x35\x0a\x05\xf6\x85\x95\x26\xb3\x45\x83\x77\x70\x5c\x5c\xc7\xaa\x10\x50\xd2\x92\x8a\x9a\x16\xa1\x14\x92\x66\x2b\x2d\x3d\x2d\xa5\x90\x12\xdf\xd1\x86\xbb\x56\x0e\x7d\xba\x7d\xe3\xd3\x8f\xfd\xe5\xec\x31\x71\x38\x77\xcb\xbe\xad\xb7\x0f\xb8\xfe\x19\xd7\xeb\xbe\xc7\xae\x7e\x7e\xed\x24\xf1\xb9\xb3\xf0\x59\x79\x95\xd6\xbc\x96\x80\x8e\x60\x5a\xac\x3a\x8b\xf7\x86\xda\x99\x4c\xf9\xda\x50\xa9\xdd\x1e\x0a\xf0\x6c\xa7\xce\xa1\x76\x5e\xe4\x46\xee\xea\xda\xb8\xdf\xed\xd1\x43\x4b\xb4\x36\x6e\xb2\x58\x90\x52\x59\x44\xda\xf7\x19\x50\x4e\xa6\xeb\x2a\x79\xdf\xd5\xd4\x29\xbb\x98\xec\x19\x25\xbf\xf3\x25\x63\x3e\xad\x5b\x9d\xd8\xdb\xc9\x05\x15\x04\x14\x92\x98\x91\x99\x6d\x4f\x24\xee\xa4\x3a\xdf\xcd\x45\x6b\xa6\x9c\x78\xf0\xe0\xe3\xd3\xd6\x14\x30\x4c\x23\xd3\xb5\xd3\x8a\x2d\x7d\x16\xf7\x7b\x76\x50\x9f\xa1\x33\x17\xce\x10\xeb\xe3\x77\x2c\x9e\x3a\x65\xd1\x1d\xa3\xd0\xc0\xea\x0e\xd9\x5d\x02\xbd\x3b\x57\xd4\x3c\x39\x7d\x38\xb4\x40\x07\xf4\x40\xd7\xc8\xdb\x16\xc2\x17\xaf\x9b\xf7\xdb\xd7\xff\x6e\xf0\xec\x2e\xcf\xf7\x58\x34\xef\xe8\xb8\xf7\xe1\xac\x2f\xce\x5f\xf9\xdb\x5f\x2e\xbe\xd4\x34\xa8\xb4\xab\xd7\x52\x7b\x6b\xb5\x74\x7e\xc8\x1b\xe2\x1c\x6e\x17\xc8\xc1\x7a\x6a\x42\xac\xa2\xd8\xe0\xe3\x2d\xc8\x8e\xb2\xb2\x72\xdc\x76\xd6\x90\xab\x32\xa8\xa2\x15\xbc\xc5\x52\x10\x0c\x16\x8c\x8b\xbb\xdc\xf8\x77\xd0\x15\x04\x5a\x90\x33\x2e\x8e\xbd\xd6\xb2\x71\x71\xad\xb9\xe5\x65\x92\xa0\x35\x8c\x89\xdd\x33\xa5\xd2\x27\xc9\x2e\x4a\xb2\xc0\x4a\xfe\x20\x7d\xc1\x49\xb5\x7e\xa5\xd4\x1f\xd3\x9a\x28\xcb\x20\xb7\x2d\x05\x9d\x14\x60\x16\x7d\xf0\x4b\xc3\xb2\x7b\x1e\x12\xbf\xfe\x4f\xb3\xf8\xfd\xb1\x35\x1b\x57\x7e\xf6\xe1\xc6\xd5\x0f\x37\x6c\xdf\x77\xcf\x26\xd8\xf5\xcc\x43\x7b\x4f\x3d\xfd\x28\xac\xe7\x76\x71\x7f\x3c\xb8\xe4\x84\x9d\xb5\x9d\xb9\xfb\xc5\xf7\xdf\x7b\x71\xf3\xef\x2d\x6c\x64\xe9\xf8\x4d\xf7\xb1\xab\xd8\xc1\x43\xe2\xb7\x2e\x5f\x38\x63\x39\xd7\xb4\x61\xc9\x96\xfb\x57\xad\xbc\x5b\xe2\x9d\xd8\x72\x03\xb8\xab\x98\xf7\x0a\xd0\x2b\x16\x29\xb0\x47\x7c\x2a\x54\x66\x34\x22\x2d\xef\xf6\xd9\x85\xca\x76\x5a\x17\xb6\xa6\x72\xeb\xe2\x00\x08\x41\x8b\xa5\x98\x74\xa1\x92\x99\x2d\xaf\x96\x12\xaa\xaa\x5b\x26\x0b\x4a\xd4\x57\x65\x72\x99\x9d\xc6\xa5\x5d\x6a\xf9\x99\x70\x12\x2a\x2b\x8a\x21\x33\x79\xe9\xa6\xba\xbe\x7d\x37\x2f\x5e\x3e\x6b\xd5\xfd\xe2\x8d\x2f\x3f\x17\xef\x5f\x75\xe7\x8a\xc5\x9b\xfb\xf6\xad\xdb\xb8\x74\xf3\x23\x0f\xdc\x77\xdf\x9e\xbe\x9b\xd1\xb4\x0d\x4b\xeb\x96\x85\x67\xf7\x78\x72\xd6\xf2\x27\x03\xac\xff\x95\xad\x7f\xfe\xe2\xcb\xb7\xb7\xfd\x09\xff\xf5\xc9\x15\xb3\x9e\xec\x31\x3b\xbc\xac\x6e\xd9\xfa\xd5\x8f\x6e\x7c\xf0\xa1\x83\x7b\x87\x6f\x1e\x48\x72\x76\x6f\x40\xb6\x81\xd6\x4c\x63\x8f\x9e\x47\x40\xaf\x52\x41\x0e\x70\x16\x2b\xe0\xcd\xd8\x7d\xd5\x98\x5b\x25\x98\x5e\x68\xd5\x86\xb2\xac\xb4\x4a\x8e\xb1\xd0\x74\xbb\x1c\x7a\x5a\x83\x7d\x51\x39\x49\xc9\x6d\x7a\x9d\x19\xbc\xe6\x5e\xe3\x03\xa6\xde\x03\x9a\xbe\xda\xca\xba\xf6\x6e\xbe\xfe\xb7\xd5\xcb\x06\x0c\x08\x91\x62\x7a\x49\xef\xec\xb8\xa1\x66\x6b\xd8\x0e\x6d\xd3\x80\xaf\x97\xd9\x4a\x68\xa8\x8d\x23\xfd\xff\x95\x86\x1d\xcc\x51\x92\x72\xdb\x3c\x0c\xbe\xb2\x63\x9d\xf9\x01\x4b\xef\x01\xcd\xab\x36\xa2\xec\xcd\x1b\x9b\xde\x9f\x35\xa7\xf7\xb0\x50\x59\x4e\x4d\x27\x90\x86\x3b\x37\x39\x69\xe3\x27\x7b\x91\x90\xa7\x13\x46\xad\x6f\xdb\xc6\xbf\x94\x7c\xc3\xdc\x23\x59\xf8\x51\x6a\xe1\xff\xbd\xb1\x2c\xda\xe2\x0d\xf3\xa0\xd8\x23\xd5\x53\xc6\x40\xf0\x37\xe7\x4b\xef\x4b\xf8\xdf\x93\x3d\x64\x0c\x32\x2e\x67\xc2\x36\xa4\x6f\x39\xe5\xad\xde\x99\xbc\xd2\x3b\x93\x3b\x81\xf6\x9b\xfe\xce\x44\x6d\x44\xfa\xae\x57\x9f\x78\xcf\x32\x26\xde\xf5\x3a\x9d\x62\x83\xe4\x39\x27\x48\x1c\x65\xa5\xd9\xdc\x27\x48\x9e\x74\xe8\x77\x26\xad\xae\x4f\x10\x91\xce\x97\x6c\x7a\x57\xbf\xd4\x13\x53\x65\x1b\x34\xfd\x9a\x7a\x5f\xa2\x4f\x77\x20\x54\xdc\x26\xfe\x70\x5f\x6a\xbb\x51\x7a\x08\xde\xa3\x4c\x4f\x3f\xe0\x8f\x99\x51\x34\xa6\x54\xf6\x89\xca\xdd\x04\x13\xbd\x07\xa5\x47\xa4\x34\x1b\x79\x72\xd2\x46\x4e\xed\x0b\xf1\xbd\xd4\xf6\xb6\x6d\xe4\x4b\xc9\xb7\xd9\x3d\x20\xad\x3f\x91\xd3\xdd\x1a\x4f\x39\x8d\x9f\xb4\xf7\x32\xea\x40\x02\x8f\xf7\x26\xfc\x24\xd7\x97\xa1\x5e\xad\xbc\xbe\xe5\x27\x90\x37\xb1\xb4\x5e\xb2\xb4\xf4\x3b\x03\x5e\x5a\xaf\xc4\x60\x92\x80\xc4\x2b\x59\x65\x1a\x66\xe0\xb4\x04\x66\xa0\x3c\x5a\x02\x47\x0f\xa8\x33\xfa\x23\x27\x31\x09\xeb\x13\x98\x84\x89\x37\x32\x0a\x4a\x08\xed\x99\x7d\xf3\xde\x11\x87\xa1\xff\xd0\x3c\x0a\x2f\xe8\x1a\x0b\x69\x8c\x0e\x00\x74\x46\x13\x6f\xe4\x7d\x7e\x82\xdd\x04\x0d\x0e\x0d\x8b\x90\xca\x08\x55\xee\xda\xb8\x56\xe5\x91\xeb\x6b\x69\xc1\x7a\x41\xab\x46\xea\xc6\x34\xfd\x44\xd4\x93\x31\x43\x25\x4d\xef\xd1\x51\x56\x42\x0f\xce\x5c\x7e\x1b\x3c\x9c\xd4\x3c\xdc\xa5\x6b\x73\x1c\x92\xaa\x39\x37\xef\x99\x61\xdc\x2f\xbf\x6e\x4c\x6a\x18\x06\x6c\xc0\xfa\xf7\x32\xb6\xd5\x72\x40\x94\xe8\x17\x83\x20\x28\x8a\x1d\x8e\x70\x4e\xae\xd7\x9b\xa3\x40\x15\x95\xc5\x39\x0e\xe4\xca\x0a\x86\x83\x8a\x60\x59\x6d\x3c\xe8\x31\x60\xc5\x8b\xe5\xac\xc1\x55\x50\x17\x77\xb9\x14\x6a\xbd\xc2\x2a\x41\xb0\x66\x64\xd5\x60\x05\x6c\xb8\x68\x4c\xd7\xbb\x69\x19\xad\x99\xb8\xe7\x72\x32\x44\x0b\xde\xb8\x74\xd6\xb6\xc7\x86\x0e\x9b\x24\x03\x8e\x33\xa5\xcb\xe2\x1b\x17\xf7\xe8\xb8\x74\x93\xcc\xeb\xc2\x19\xf0\x40\x92\x57\xe6\xc9\xbd\x0b\x9f\x3c\x98\xc2\x20\xbf\x6b\xd4\xc9\x97\x9b\x67\x3a\xd6\x2e\x94\xb8\x3f\x3a\x6e\x79\x4a\xb9\x32\x60\xe5\x8d\x6f\xd0\xab\xdc\x10\xe0\x94\xd0\x6e\x02\x36\xbc\x95\x5a\xb5\xde\x65\xe7\xf4\x5c\x76\x8e\xd3\x68\x32\xd6\xc6\x19\x2f\x36\x2e\xf4\x01\x35\xcb\x30\x4a\x9b\xc5\xa4\xd7\xd8\x94\xe1\xda\xb8\x32\x81\xbd\x71\x31\x2a\x6d\x56\xa6\x4c\x4c\xe2\xbd\xb6\xdc\xb1\x24\xd8\xab\x39\x9d\x3f\x57\x8f\x6e\xcb\x37\x62\x76\xce\xd5\x11\x76\x12\xc0\xaf\x3f\x62\xae\x3a\x04\x7a\x74\xaa\xa8\x81\x6f\x27\xf7\xef\xe8\x38\xa6\xbb\x5c\x64\xd7\x85\xb0\x32\x64\x64\xb5\xf4\x76\xd1\x0b\xdf\x8d\x75\xd4\x8e\x2a\xc2\x1e\xc9\x98\x58\x69\x96\x22\x10\x8d\xe6\x61\x9b\x5b\xcf\x30\x79\xc5\x6e\x37\xca\x53\xb0\xed\xab\x8d\xb0\xac\x80\x3c\x57\x3a\x2c\x3a\xb5\xa1\x32\x87\xc3\xa6\x53\xc0\xc7\x70\xf4\xc5\x32\x1d\x97\x20\xda\x0a\x53\x24\x2d\xc7\x25\x98\x5d\x99\xf1\x56\x49\x8c\x27\x21\x2a\x77\x73\x94\x70\xe8\x04\x6a\x3a\x91\xca\x41\x9e\x6e\x25\x79\x25\x68\x87\x25\x15\xaa\x3a\xbc\x76\xee\xda\xc5\x7d\x27\x85\x18\xe6\x00\xc3\x84\x26\xf5\x5d\x8c\xbf\x3f\x58\x8d\x38\xb1\x7b\xd7\xde\x0f\xed\xef\xdd\x9d\xf9\xa1\x5b\x9f\xfd\x0f\xf5\xea\x56\x7e\xeb\x61\x88\x60\x1e\x31\x98\xba\xd5\xcf\x86\x0f\x89\x63\x67\xd7\x77\x13\x3f\x17\x3f\x15\xdf\x11\xc5\xc3\xb7\x96\x33\xbe\xf7\xde\x80\xcf\xc0\xfd\x6f\xbf\xfb\xe7\x77\xc4\xf1\xe2\x80\xcb\xf2\x3a\xe0\xfb\xb9\x8e\xe2\xdf\xe7\xe3\x13\x3d\x2c\x56\x18\x72\x96\x30\x06\x43\x8e\xdf\x67\x2c\x50\x28\x8c\x4e\x7c\xa4\x83\xfa\xa2\x3c\x4f\x1e\x76\x33\x38\xc6\x63\x28\x8b\xd8\x23\xb5\x71\xb3\x56\x65\xb7\x19\x3d\xbf\xbd\x06\xa9\xc7\x5a\x28\x25\x0e\xd3\xde\x95\xd9\x39\x61\x3b\x3e\xcd\x55\x24\x0e\x29\x61\x09\xd8\xa3\x15\x55\x49\xf6\xa1\x21\xc1\xfc\x31\x0e\x55\x1f\x5c\xf5\x3b\xec\x8a\x8e\x0f\x50\xe6\x03\xe3\x07\xdd\x00\xf3\x57\x1f\xae\xc2\xcc\xbf\xd6\xb5\xef\xfe\x87\x36\x30\x3f\x6c\x78\x68\x7f\x9f\x6e\x6c\x07\xcc\xbc\xf8\xbd\x78\xa5\xf9\xaf\xbd\x06\xce\x12\x7b\xc3\x67\x67\x0d\xe8\xcd\x84\x60\x09\x34\x62\xc6\x9b\xdf\xbb\xfa\x06\xdc\x0f\x9f\x11\x07\xc1\x13\xe2\x00\x71\xfc\x25\xc2\xf7\x8d\x1b\x37\xb6\xb0\x97\xf0\xfe\x6b\xb1\xa7\x61\x07\xb3\x62\x1d\x35\x4a\xad\x42\x61\xb2\xe9\x75\x7a\x06\x21\x83\xd5\x0e\xb1\x4b\x61\x32\xf1\x40\xad\xd5\x3a\x11\xcb\xf2\xbc\x03\x32\x3a\x86\x04\xc9\x95\x1a\x83\x95\x15\x74\x3a\xde\xa4\x12\x10\x0b\x48\x63\xf7\xe8\x45\xe9\x64\x63\xdb\x50\x46\x53\x87\xa9\xd4\x2d\x93\x64\x34\x26\xa2\xb3\x52\x7f\x15\x14\x84\xe1\xaa\x30\x8c\xda\xcd\x51\x25\x13\xc5\xa4\xea\xa1\x5d\x08\xb2\xaa\x4d\xe2\x1d\x62\xe3\xc1\x01\xfd\xa1\xf8\x97\x11\xd7\x0e\x8a\xfb\xe0\x84\xa6\xc6\x62\x68\xaa\x0a\x6a\x7a\x7e\x72\x04\xdc\x80\xcb\x44\xdd\x5c\xae\xe7\xf7\x70\x7e\xf3\x77\x4d\xbd\x19\x33\xdc\x7b\x70\x62\xce\xdb\x8f\x35\xd1\xfb\x99\x77\xe3\x77\xec\x63\xb4\xcf\x54\x16\xb8\x23\xd6\xd9\xed\xc1\x3a\x21\xe0\x07\x2c\xa3\x51\xab\xad\x82\x42\x61\xb1\x5a\xf5\x2e\x86\x8d\x64\xf3\xca\x80\xce\xaf\x07\x2e\x05\xeb\x71\x00\x82\x63\x61\xb1\x38\x1c\xc6\xb1\x71\x87\x99\x0d\x61\x3b\x4a\x23\xb0\x2c\xa9\x79\x4d\xc9\x28\x92\x69\x60\xb8\x60\xb2\xb7\xc0\xa7\x22\xe0\x20\xf4\xcd\xa6\x2a\x9b\xc2\xfd\x55\x45\x11\x29\x28\x93\xfa\xc8\x4a\xb5\x25\x39\x42\x18\x4a\x0d\x65\x99\xef\x96\x30\x8e\x07\x67\xcd\x39\xf8\x44\x87\xf0\x11\xad\x4e\xb4\x0c\xb9\x57\xc6\x01\xfc\xc3\xaa\x35\x07\xa1\x31\x07\x7e\xd8\xff\xf6\xc7\x1e\x3e\x73\x12\x76\x62\x4e\xf4\x3d\x2b\x7e\xd6\x6f\x74\xd7\x88\xa7\xe9\xc3\x71\x14\x0a\x70\xc2\x7b\xa8\xfc\xb9\xc5\x48\x5d\x43\x01\x00\x19\xda\x4f\x67\x38\xad\xcd\x8f\x80\x19\xb1\x2e\x1e\xaf\x57\xab\xd1\xd8\x54\x7a\x21\x68\x70\x07\x80\x82\x51\x28\x95\x36\xc6\x96\x9d\x23\xa8\x82\xfa\x80\x01\xb8\x15\x9c\xd7\x09\xac\xe3\xac\x8c\x1e\x59\xad\x4e\xa7\xa9\x36\xee\xb4\x71\x58\x32\x69\xb5\x0a\xce\x70\x73\x66\x89\x80\x2a\x49\x04\xd6\x29\xab\x91\x6c\xe9\xd0\x9a\xdb\xe0\x15\x25\x78\xe5\xe1\xc8\xfb\xff\xf9\x71\xdf\x4e\x4f\x37\xbc\xb2\x32\xf0\xac\x3a\x24\x9e\xab\xaa\x1b\xb7\x52\x7f\xca\xfa\xf1\xe3\x73\x47\xfc\xb1\x01\x2a\x8b\x60\x69\xa8\x70\xeb\x8a\xf8\x36\x58\x09\x8d\xd0\x6f\x80\x0d\x62\xe7\x61\x47\x74\x3d\x8a\x9b\x8b\xc3\x53\x66\x68\xf6\x3e\x17\x11\x7b\xa1\xd7\x8e\x4f\x62\x8e\xa9\xce\x51\xbb\x73\x42\xb2\x5f\x0b\xb6\x3b\x49\xbf\x16\x25\xd0\x00\x8d\x4e\xaf\xa2\x16\xaf\x80\x4d\xde\x96\x5d\x5a\x4a\xd2\xa0\xaf\x4c\xf2\x3e\x51\xf8\xec\x64\xea\xfa\x77\x9b\x36\xbd\x00\x77\x88\x77\xe0\xcb\x35\x7a\x2f\x33\xa0\xf9\x99\xbd\x62\x6c\x6f\xda\x39\x32\x50\x04\x99\x1c\x8e\xe7\x95\x4a\xa4\xd1\x6a\x0d\x06\x23\xc3\xe0\xa9\x2c\x56\x33\xa0\xf5\x99\x46\x88\x4f\x0a\xd2\x69\x54\x88\x27\x0d\xa1\x2e\x90\x4b\x60\xa7\xe5\x0f\xad\x60\x88\x12\x75\x5d\xa4\xce\x30\x0c\x49\xb6\x68\x55\x54\x88\x5a\xb9\xaa\x30\xfa\x55\xbc\x74\x4e\xbc\x70\x10\xfe\x55\xec\x89\xa6\x0d\x3e\x38\x38\x57\xec\xb9\x7d\x3b\x7b\x54\x54\x36\x0f\x84\x8b\x9b\x9b\x90\x96\x89\xec\x5d\xbf\x7e\xef\xf7\xdf\x93\x75\x78\x0a\xeb\x5f\x1f\x7b\x0b\xf6\x7d\x6f\x8b\xe5\x38\xec\xd1\xec\xa2\x42\x1f\x00\xda\x42\x2e\xdb\xce\x77\xea\x1c\xad\x0a\xf9\x58\x94\x97\x57\x8a\x95\x50\x11\x34\xa1\xa2\xa2\x3c\x83\x41\x29\xc1\xa9\x1a\x10\xe9\xed\xe9\x70\x48\xb8\xa0\x74\xbf\xa5\xa2\xe5\xa8\x94\x47\x93\xe1\xf7\x26\xca\x5d\x48\x72\xa2\x9d\xd6\x6a\x48\x5b\x5c\x02\xb3\x73\xd2\xea\x5f\x4a\x60\x31\x23\x3d\x9d\x24\xa1\xd9\x68\x95\x07\xeb\xfb\xe2\xcd\x60\xaf\x97\xdc\x3d\xdd\xd8\x17\x1f\xd7\xfe\xf6\xf6\x7b\x96\xdd\xdd\xb7\xfb\x00\xfd\xda\xea\xb5\xf3\x36\x2e\x1f\x71\xdb\xca\x07\x56\xf7\x7b\xeb\xd5\x67\xde\xf2\x1c\xd4\xaf\x9e\xb9\x68\x6e\xe9\xad\xf7\x6d\x5d\xd6\x37\x17\x16\xec\x7e\x44\x75\xd5\xeb\xf0\x04\x67\x77\xcc\xdf\xf3\x70\xfd\x90\xf1\xf6\xe1\x23\x3a\x0f\x19\x12\xab\x75\x85\x72\x07\xcc\xac\xdd\xf9\xc0\xb2\xcd\x96\x3e\x03\xfa\xdd\x52\xdc\x29\x3f\x92\xd5\xb9\xdf\x78\xbc\x1e\xc7\xf0\x7a\xdc\x85\xfd\x11\x2f\xe8\x1e\xb3\x02\xbb\xd3\xab\xf6\xba\xec\xac\xcf\xef\x75\xb9\x5d\xb5\x71\xb7\x5e\x47\xf3\x90\xd5\x71\x9d\xdd\x81\xe5\x1c\xc9\xf6\x95\xfd\x92\x44\xc1\x76\x5a\xa0\x04\x1f\xee\x72\x1f\xf4\x43\xc2\x9d\xc4\x6e\x31\x16\x4c\xc5\xb0\x20\xf1\x2e\x3d\xb7\x4b\x5d\xb7\x1e\xc7\xbc\xe5\x81\x8a\x4e\x84\xa9\xb2\x81\x3d\x3b\x1c\x88\xf4\x18\xb8\x97\xb9\xb7\x79\x07\x6a\xbf\xd9\x5a\x52\xfb\x4a\xd8\xd3\x63\x76\xc7\x32\x5f\xfb\xde\x2f\x16\x06\x36\xa3\xac\xcd\x1b\x31\x8d\x51\x7a\x76\x77\x01\x1b\xa8\x8a\x79\x6c\x04\xab\x13\x68\x90\xdd\x81\xac\xe3\xb0\xab\xa6\x07\x6a\xb5\x5e\xaf\x18\x17\xd7\x03\x5a\x68\x97\xc0\x3e\x28\x49\x4f\xd8\x0e\x1a\xb1\xdf\x6c\x4c\xbc\x57\x65\x45\x03\xc0\x68\x61\x04\x23\x7c\xbe\xe2\x16\x38\xe4\x89\xc6\x35\x47\x5d\x27\xb3\xa0\xf2\x2d\xc8\x41\xcb\x8d\x0f\x19\x87\x0e\xae\xb8\xf8\xec\xbc\xf9\xde\x87\x4f\x89\xff\x16\xaf\x7f\x2d\x7e\xa9\x10\xd7\x10\xac\x7a\x4c\x07\x8b\x75\x9d\x05\xb4\x8f\x79\x2d\x80\x35\x18\x80\x0a\x11\xbc\xa8\xba\x38\x84\x5a\x40\x0a\xb8\x04\x2c\x11\x0c\x32\x6c\x73\xdb\x84\xc8\xf1\x8d\xb4\x88\x99\x91\xb1\x6d\x3d\x74\xc7\xf2\x17\x3c\xcf\xba\xde\x3d\x74\xf9\x83\x43\xf7\xc1\xe3\xdb\x16\xaf\x5d\x79\x41\xb7\xeb\x89\xab\x2f\x6d\x7d\x35\x5b\xbc\x88\xf5\x6c\x30\x59\xcb\xef\x03\xd9\x60\x69\xac\x8f\x5e\x93\x65\x77\xbb\x15\xac\x5f\x63\x02\x40\xe3\x60\xd9\x9c\x5c\x17\x2f\xf0\xe3\xe2\x76\x41\x9f\x65\xcb\xb2\x8d\x8d\x2f\xcf\x82\x20\x2b\x90\x55\x9a\x85\x6a\xb3\xfe\x99\xc5\xe8\x05\x02\x38\x94\x25\x64\xb1\x4a\x65\x98\xe0\x2c\xb2\xee\x74\x04\xe4\x54\x3f\xa4\x31\xb3\x67\xcb\x11\x8b\x36\x32\x11\x52\x40\xc8\x14\x4f\x2a\x1d\x01\x99\xe2\x3e\x07\x5b\xa2\x20\xe7\xae\x5c\x09\xf7\x26\x01\x90\x9b\xe0\x6d\x58\x27\xa9\x28\x0a\xf2\x47\x9f\x48\x28\xc8\xb0\xcf\x5a\xb4\x20\x85\x7f\x7c\x6c\xed\x53\x49\x00\x64\x06\xa8\xb1\x9d\xf5\x07\xcc\x37\x89\xe7\xf5\x8e\x85\x5d\x06\x83\x5a\xef\x34\x9b\x91\x45\x6f\xf1\x07\x5c\x88\x76\x28\x30\x02\xbc\xf0\x66\xcc\x9c\x95\x80\x91\xc8\xb5\xde\x44\x80\x45\x93\xa2\x24\xb3\x34\x81\xa4\xb5\xd1\x42\x7a\x63\xa5\x2c\xcf\x8c\x51\x48\xe0\x16\x82\xe4\xfe\xb1\x9d\xd7\xae\xfd\xb4\xe9\x87\xff\x59\xbd\xfa\x05\xa6\xfc\x9c\xe8\x7f\x68\x55\xf3\xeb\x15\xf3\x98\xef\x76\x4f\x13\xff\xfd\xe3\x57\x10\x2d\xd9\xcd\x8c\x68\x3e\xc2\x8c\xb8\xde\xed\xf0\xdb\x43\x6f\xdb\x71\x6f\x77\xe2\xa7\xa8\xf0\xfe\xfc\x81\x62\x5d\x0c\xa0\x76\xd1\xc1\x1b\x01\xec\x03\x5f\xa2\xbd\x25\xdd\x60\x6b\x6c\x18\xd6\x90\x2c\x6f\xb3\xba\x9c\x88\x67\x04\x60\x34\x68\x35\x4a\x5e\x41\xf0\x18\x58\xac\x59\xcd\xac\xd9\xe3\xd5\xd8\x39\xfb\xd8\xb8\xc1\x6d\xc1\xfb\xa2\xf5\x5b\x4a\x2c\x8c\x1e\x7f\xa9\xb1\x8c\xb5\x2c\xb7\x3c\x65\xf9\xc8\x22\xf8\xb1\x9e\x65\x95\x02\x87\x8c\x0e\xd6\x31\x36\xce\x48\x80\x69\x17\x25\xb3\x89\xda\x0f\xa4\xbf\x4c\x46\x6f\x86\x54\x2e\xbb\xdc\xbb\x5d\x3e\x86\x02\x36\x1e\x8c\x92\x08\x0d\xa3\x28\xa9\x9a\xb7\xc2\x20\xa9\x4a\x32\x87\xe1\x3b\xe3\xb7\x8e\x7f\x98\xf9\xba\x43\x43\x07\xff\x6d\xa7\x3e\x14\x3f\xb9\xc8\xf4\x6b\xba\x01\xcb\x4f\x89\x8e\xbc\x8b\xdf\x7f\xfc\x31\xd7\x13\x0b\x53\x71\xe4\x1e\x31\xba\x17\x21\xf8\xc8\xf5\x1f\xe1\x65\xc0\x82\x85\xe2\x08\x76\x14\xb5\x1d\xc2\xd8\xb7\x29\x00\xbb\x63\x23\x02\x59\x59\x46\x5b\x28\x98\x93\xad\xe7\x75\x76\x0d\x04\x05\xf9\x4e\xde\xa1\xd5\x12\x54\x55\xc1\xee\x70\xe4\x7a\x3c\x82\x11\x15\x16\xd9\x61\x28\x3f\x1b\xb2\xc8\x6b\x21\xa6\x3f\x3e\xb0\xb5\xf1\x02\x8d\x5e\xe5\xb4\x59\x02\x01\x95\xc5\xa0\x73\xab\xb0\x03\x94\x6a\x3f\xa3\x92\xdb\xcf\xc8\x55\xe9\x25\x26\x92\xb6\x58\x2d\x33\x4d\x13\x1b\x6b\x5a\xa5\xbf\x67\xf0\x0e\x51\x86\xc6\x35\xa7\xe9\x63\xa3\x95\xb6\xa0\x31\x67\x63\x35\x6c\x8e\x60\xe5\xcf\x3c\xf2\x70\x65\xf5\xed\x0f\xb8\xf6\x15\x7e\x73\x68\x74\xff\x17\xb6\xbe\xfb\xda\xaf\xdf\x8c\x1d\x74\xaa\xe1\x8d\xe7\xc4\xc8\xba\xbd\x1c\x34\x6c\xaa\x10\xef\x1f\xb2\x12\xce\xd3\x55\x4d\x84\x3f\x8b\x5b\xcd\xf1\x01\x45\x4b\xd6\xd8\xc4\x61\xf0\x6f\xeb\xe1\x04\xa8\x86\x7e\x27\xbc\x4f\x2c\xdd\x28\xee\x75\xc0\xab\x4f\xed\xc6\x07\x4f\x2c\x7e\x76\x0a\x0c\x6e\xba\x67\xe0\x47\x52\x3c\x88\xf4\x01\x1c\x47\xf1\xcb\xfb\xc4\xb2\xd4\x98\x5f\x03\x60\x55\xac\xd3\x85\x4c\x66\x8a\x5c\x60\x16\xec\x76\x7c\x97\xed\x48\xd0\x8d\x8d\xab\xd5\x42\x5a\x85\x65\x26\xea\x5b\x75\x06\xe6\x5b\x7a\x99\xa0\xb1\x52\x86\x4a\x45\xef\xaf\x5b\x77\xf5\xdc\x63\x97\xc2\x67\x4d\x77\x8d\xbe\x22\xfe\x0a\x05\xf1\x15\xf8\x6f\xe6\xbb\xfb\x4f\x5c\xf9\xe2\xe9\xf3\xfe\x79\x2b\xa1\xf3\xe4\xfd\xf0\xf7\x7b\x13\xf6\x51\x2f\x8a\x87\xeb\x01\xb5\xb1\x2c\x27\x26\xcc\x43\x28\xf3\xfa\x5c\xce\xc1\x71\x17\x24\xf4\xd5\x26\xe8\xc3\x6a\x41\x2f\x68\x69\xe2\xbe\xe0\xc9\x40\x06\x8b\xa6\xb5\x91\x4c\x95\xbf\xc1\x04\x94\x67\x76\x5a\xf5\x47\xa2\x02\x04\xf5\x80\x8c\x28\x26\xfb\x28\x8a\xeb\xe0\x22\x71\x2a\x73\xcb\xcb\x2f\x33\x53\xd7\x8a\x20\xd1\x49\x11\x36\xaf\x85\xdd\x69\xc1\x01\x03\x66\x8b\xc3\x39\x07\x37\x12\xdf\xb4\x10\xc1\x83\x72\x28\xbc\x5a\x86\xb1\x19\x14\x86\x70\x96\x0e\xa9\x03\xf8\x36\xa9\x59\x8a\x7a\xc8\x71\xf8\x6a\x21\x0a\x09\x97\xd2\xde\x99\x20\x16\xd2\x0a\x06\x8c\x95\x29\xd8\xcc\xaa\x68\x02\xfc\x83\x02\x54\x4b\x4d\x99\xd8\x6d\xe2\xaf\x93\x0f\x89\xe2\xf7\xd8\xfc\x12\x4e\x4c\x5d\xeb\x6f\x5f\x15\x2d\xe9\xd0\x34\xfa\xb1\xe3\xbb\x47\x0e\x7a\xea\xb1\x87\xc5\xe1\x30\xf0\xf6\x58\x38\x0b\x0e\x80\x75\x70\xdc\xe8\x01\xd7\xba\xd5\x75\xd7\x1d\xd4\xb1\xf5\x04\x9c\x7a\x21\xea\xb2\x42\xb6\x43\xd7\xe0\x75\xfe\x10\xeb\x94\x00\x28\x24\x31\x8b\x1c\x45\x50\x17\x08\xb8\xad\x0a\x6b\x51\xb1\xd7\x51\x1f\xf7\x7a\x8c\x06\x55\x16\x09\x56\x18\xb8\xfc\xda\x38\xe4\x32\x33\xc6\x0a\x5a\x10\x1e\xa9\xca\x68\xa7\x2d\x27\xb5\xa6\x43\x97\xa4\xe7\x63\x4c\x60\x99\x76\xfb\x96\xbf\x7e\x1e\x36\x2c\x3e\xd0\x8e\x51\xb0\x4f\x08\xed\xab\xb2\x4b\xcb\xfb\x2d\x59\xb9\xe9\xbe\x8d\x0b\x16\xae\xdb\xbd\xa9\x6c\xe5\xf4\x51\xd0\x06\x6d\x4c\xbb\xe1\x93\x7c\x3b\xb8\x8e\xdf\x36\xcd\xa8\xeb\xae\x39\xa8\xb9\x77\x07\xf3\xd8\x5b\x97\x2e\x7d\xf4\xf7\x0b\xef\x93\x2e\xba\xe4\x4d\x94\xea\x26\x52\xd1\x94\x63\x43\x48\xc1\x1a\x20\x30\x1a\x4d\x5a\x2d\xbe\xd8\x2e\xb7\x81\xe1\x09\x8c\xb3\x4d\x10\xb0\xee\xb1\x52\x8c\x5f\x19\xeb\x31\xed\x94\xb4\x28\xee\x90\xe4\x14\x4c\xb6\x92\x91\x74\x25\x44\x09\xac\xa8\xe7\xc5\xed\xff\x78\xe1\xe0\x41\xf8\xb7\xaf\x7e\x3a\xfb\x20\xdc\xf6\x4b\x02\x2b\x8a\xa9\x69\x7e\x91\xa9\xd9\xc5\xcc\x7a\xb1\xf1\xde\x4b\xae\xe6\xc7\xd0\xe5\x24\x56\xd4\x31\xf2\x16\x8b\xd7\xda\x83\xef\x9a\x83\xf7\x58\x39\xa5\x52\xa7\x52\x79\xbc\x3e\xab\xcb\xc5\xd4\xc7\x5d\x06\x05\x56\x27\xd2\xc3\x18\xa7\xd5\xaa\x4c\x7a\x95\x35\xad\xdd\x8d\xa3\xa6\x45\xd0\x81\xaa\x42\x6a\x52\x48\x55\x9c\x61\x02\x57\x93\x9d\x13\xc5\x0b\xdf\x85\xc1\x12\x85\xb5\xce\x9a\xb8\xea\x4c\x00\xce\x16\x57\x35\x2e\x59\xe2\x76\x3e\x96\xab\xe0\xca\xc7\xad\x19\x3b\x65\x32\xda\x65\x7e\x78\xcb\x76\xd1\x05\x3f\xdf\xde\xb3\xff\xeb\x13\x36\xcd\x9a\x35\xb5\xd2\x28\xc5\xe0\xd5\x72\x4e\xa4\x11\x6b\xbc\x29\xb1\xa8\xde\x6c\xd0\x59\xb4\x26\x93\x51\xab\x56\xf0\x2a\x8d\x86\x37\x00\xc4\x41\xa3\x91\xc3\x46\xb5\xd5\x26\xb0\x26\x0b\xc2\x96\xf4\xb8\xb8\x0e\x98\x54\x2a\xde\xa0\x41\x3c\x6d\xac\x8a\x69\xae\x4e\x68\xbf\x14\x6a\x07\x4d\xaa\x4a\xfe\x49\xbb\x1a\x54\x4b\x60\xb6\x44\x03\x60\x0e\x50\xb0\x32\x9a\x13\xb5\x63\xbd\x00\xab\x82\xac\xf2\x39\xf1\xab\x2f\x7f\xff\x95\xf8\xed\x99\xfd\x97\x77\xc3\x33\xbb\x2f\x37\xbf\xb0\x4a\xbc\xce\xf6\xdb\x2e\x6e\x23\x18\x1e\x70\xd6\xf6\xeb\xd7\xaf\x37\x3f\x28\x61\xdb\x45\xf0\x39\x7e\x0c\xdb\x91\x6e\x7c\x92\xef\xc2\x96\xb5\xdf\xee\xb1\x5b\xac\x26\x9b\x11\x7b\xf9\xc8\xcd\xb2\x3e\xa7\xc7\xe5\x82\x6e\xb7\x47\x65\x63\x83\x21\x23\xeb\xf1\x23\xb3\xc5\x2c\x55\x12\x63\x19\x63\xb1\x28\x5c\x36\xbd\x42\x5b\x1b\x57\x78\x52\x0a\x3c\x93\x07\xe9\x70\x60\x82\x65\x40\x49\xfa\x57\xb9\x12\x9e\xc8\x3c\x44\x10\xd5\x25\x81\x52\x03\x49\x49\x34\x8a\x9a\x83\x66\xcc\x8a\x39\x68\x42\xbf\x3e\xfd\xfd\xf5\xee\x73\xef\x8e\xf7\x2b\xcf\x2e\x1e\xb4\xb9\xd4\x24\xde\xf8\xe1\xe9\x7b\xcf\x6f\x81\xa7\xd7\x9d\x6b\xfe\x7b\xde\x7c\xf1\x85\x3d\xcc\x67\xdb\x9b\x9f\x78\xe2\xe8\x60\xf5\x7a\x7e\xfe\xca\x32\xa6\xcf\x76\x38\x54\x7c\x0c\x0e\x6d\x5a\x31\x13\x16\x88\x9b\x09\x8f\x65\x58\x56\x57\xe3\xf3\x13\x02\x25\x60\x58\xac\x28\x57\x61\x36\xfb\x9d\xae\x22\xbd\xde\xe5\x47\xa5\x65\xb9\xa6\xba\xb8\x33\xd7\x99\xeb\xe1\x3c\x58\x20\x7a\x6c\x1a\xec\x1d\x2a\x34\x1a\x8e\x03\x75\x71\x2e\x89\xcf\x15\x6d\x05\x30\x9d\x01\x22\x6b\x0e\x09\x95\xd4\x1d\x90\xe3\x74\x06\x4e\x48\xc3\x1a\xa3\xf7\x97\x0b\xe9\xa0\x17\x56\x75\xc1\x8e\x43\xf6\x8c\x8c\x5c\x2a\xb1\x83\x9c\x4b\x55\x2c\xae\x7f\xf9\x95\x7c\x26\x3b\x91\x49\x85\x5e\x4b\x66\x4c\x89\x87\x12\x19\x53\xe2\x87\x67\x4f\xc0\xab\xb5\x75\x7c\x5a\xc2\x94\x74\x06\x09\x16\xba\x9b\xed\x27\xf7\x48\xf0\xfa\x79\x35\xc0\x1e\x2f\x4f\x60\xba\xac\xd8\xd4\xf6\x48\x09\xac\xa1\xd6\x09\xac\x99\xe0\xf1\x91\xb6\x44\x91\x3d\x9c\x9d\x93\x8e\x54\x87\xc6\x57\x3e\xb8\xf4\xb5\xe7\xe1\xfa\x95\x7b\xca\xb0\x08\x7a\x8a\x17\x9e\xc0\x3e\xe1\x86\x9d\xeb\x16\x2e\x58\xbb\x63\xf3\xa9\xe9\x93\xa0\x83\x88\x9f\xf8\x58\xff\x1a\x3e\xfa\x45\xf3\xb9\x41\xdb\xfa\xcd\x80\x73\xdf\xfe\xd3\xa5\x8f\x3e\x78\xfd\xfd\x44\x3f\x0c\xb6\x16\xfb\x06\x21\x62\x95\x9b\x38\xec\xc8\xdb\xb1\x97\x1b\xce\xb2\x62\xff\xc5\x64\x35\xe8\xf1\x2d\x46\x81\x9b\xb6\x73\x68\xa3\x9b\x43\x45\x8e\x54\xa8\x7e\xb3\x5e\x0e\xfc\xe3\xaa\x9b\x77\x72\x60\xa6\xde\x37\xaa\x7a\x61\x7a\xf3\x8b\x54\xcf\x0e\x92\x5b\x49\x90\x86\x81\x9b\xcb\xce\xd6\x04\xb0\x03\x5e\x58\xe4\xc3\xa7\xc4\xed\x33\x18\xac\xf5\x71\xda\x78\x22\xef\xff\xdc\xaf\x23\x1d\x21\xeb\x37\x7b\x50\xec\xdc\xde\x6d\x50\x87\x9e\x35\x3d\x7f\xab\x0f\xc5\x1f\x1b\xf6\x18\x1f\xb1\xf6\xef\x33\x3b\xb3\x81\x07\x04\x9b\x31\x0f\x5d\xf1\xd9\xb7\x93\x5e\x14\x46\x93\x49\xc0\x87\x82\x07\x0e\xa7\x60\xc4\x46\x9c\xcd\xa6\xab\x8d\xdb\x0c\x48\x99\x86\xb2\x79\xb3\x5e\x14\x40\xae\xae\x48\xba\x63\x58\x56\x06\xd8\xae\xe2\x2f\x3f\x9e\xfc\xd2\x73\x3e\xfc\x3f\xb0\x6a\xfb\x3e\xda\xfe\x60\xc9\xab\x8b\xe1\x97\x4c\x8e\xf8\x4f\xf1\xcf\x4f\xde\xab\xbb\x00\x8f\x7d\xf0\xc7\x69\x77\x68\x6e\xdd\x37\x12\x48\xd8\x9f\x8f\xb2\x3d\x31\x3d\x64\x4d\x07\xc5\x0a\x6d\x2a\xa3\xc1\x90\xe5\xf5\xe6\x39\x18\x85\x8a\x2f\x2c\x72\x67\x63\x57\x3d\x4f\xc1\xb0\x6e\xa3\x9b\xb8\x07\x66\xea\x97\x91\x63\x40\x60\x9c\x2f\x66\x50\x28\xc5\xfe\xd3\xeb\x68\x09\x20\x2c\x89\x1f\x67\x57\x92\x1e\x0e\x32\xc6\x91\xd5\x42\x52\x78\x03\x04\x82\xba\x9c\xe0\x88\x10\xe2\x7d\x90\xd9\x72\x6a\xa9\xca\xd5\x7e\x71\x9f\xc8\x58\xc8\xfc\x74\xf2\x6b\xff\xf9\xd0\x67\xfb\xb6\x7b\xe3\x9f\x2d\x87\xd8\x87\xbf\x75\x65\x8f\x6d\x23\x9f\x1d\xe6\xff\x9d\x65\x90\x2e\x32\x3e\x3e\xb7\x7c\xd3\x3f\x48\x37\x87\xc7\xee\xd7\x5d\xf8\xe3\x07\xf7\xd6\x8f\x9c\xf6\xd9\x3d\x7b\xd7\xe5\xf6\x28\x98\x3e\x76\x8c\x3f\x47\xba\x7b\x58\x8e\xbe\x87\xcf\x8a\x1b\x5b\xd1\xdd\x63\x21\x8f\x26\x64\x62\x59\x60\xd3\xd8\x72\xf3\x2c\x50\x17\x21\x19\x9e\x06\xa5\x1f\xf3\xa1\xb4\x31\xce\xfa\x38\x93\x90\x96\x37\x35\x65\xb0\xda\x77\xc2\x70\x66\x27\x02\xd9\xa0\x49\x7f\x6e\x67\xdf\x2b\xef\xf7\xb3\x90\xde\x8a\xa0\x91\x18\x03\x4d\x33\x12\x7d\x08\xc4\x09\x1a\x98\x0b\x4b\xd2\xbb\x11\x1c\xfa\xf5\x45\x6c\x0d\x20\x6b\xb2\x15\x81\x24\x3b\x38\xc8\xbd\x8f\xbd\xb5\x7c\x62\x8b\x11\xd9\x11\x89\x98\x1c\xbc\xa3\xa0\xd0\x6d\xa5\xa7\x5c\xa1\xc8\xbd\x89\x00\x91\x0c\xb2\x96\x26\x4d\x06\xe9\x95\x24\x4c\x28\xa1\x5e\xfe\xb7\x56\x0a\xd0\xdd\xb5\x57\x87\x8e\x0b\x6f\xde\x4d\x61\x23\xcc\xd5\x1f\xb1\xee\x6c\xea\xd8\xb2\xa3\x02\xe1\x43\xae\x85\xc3\x5a\xd8\x4d\x10\x3c\x74\x5a\xad\x03\x38\x2d\x16\x01\x08\x1e\xaf\x03\xd4\xc6\x75\x0e\x9d\x43\xc5\xaa\x8c\xb5\x71\xac\xd0\xac\xb5\x71\xd6\xf0\x5f\x7b\x07\x48\xed\x14\x8c\x19\x6d\x69\xe5\x96\x97\x6b\xaf\x7d\xf7\xc5\x8f\xe2\xb7\x0f\x7f\x55\xb8\xcf\xf5\xc0\xed\x77\x1f\x10\x3f\x59\xbf\x5b\xc3\xf4\xe5\x76\xc1\x9f\x1d\xd0\x09\xb3\xf1\x0d\xfd\x41\xfc\x4e\xfc\x60\xcd\x92\xa2\x01\xf1\xd7\x4f\xc1\xab\x47\xf7\xef\x79\xb2\x05\x9d\x2e\x42\x27\x2f\x08\x4e\x33\x70\x38\xb4\x66\xad\xdb\x63\x71\xd6\xc6\x2d\xbc\x85\x37\xa8\x0c\x98\x42\x83\x8d\x38\x52\xaa\xff\x4a\x27\x4c\xcb\xe8\x91\xa8\x65\x8c\x95\x90\x14\x43\x99\xd0\xc6\x87\xb6\xc8\xde\xd0\xb7\xe2\xaf\xdf\x7c\xf3\x03\xfc\x00\x7b\x41\xcd\x67\x3c\x4c\xf7\x53\xaf\x53\xd7\x47\x7c\x5f\xfc\x87\xf8\x6f\xf1\x13\xe8\x83\x41\x87\x58\xfc\xd4\x6e\xf1\x8c\xb4\x9e\x25\x37\xbe\xe5\x38\xfa\x4e\x90\x07\xa6\xc6\xb0\xe8\x12\x42\x01\x90\x9b\xeb\xd6\x6a\x34\x16\x77\xc0\x9d\x5f\x60\x33\x12\x63\x20\x10\x0f\x39\xf3\x00\x16\x82\x41\x0d\xbe\xa8\x3c\x0f\x6c\xc8\xa7\xf2\xe1\x63\xef\x6b\x45\xbd\x54\xc2\x66\x94\x4d\x84\x82\x96\x38\x74\x12\x2f\x34\xa8\x26\x21\x5d\x9a\xab\xec\x52\x60\x8a\xfa\x1d\x58\xb5\x32\x61\x6c\xe6\x4b\xc1\xb9\xca\x1c\xe6\x6d\xd7\xb2\xb1\xa3\x57\xda\xf6\x15\xbc\xbe\x1b\x8e\xac\xbd\xcb\xa6\xce\xcd\xce\xeb\xdc\x6e\xd8\x2d\x03\x66\xe8\xd9\x4f\xdf\x13\x6f\x39\xad\x5d\xbc\x70\xe1\x06\xc4\xbc\xb5\x72\xce\xf0\x41\x45\x2b\x56\x88\x87\x5d\x2b\x7b\x74\xcf\xdd\xd2\x71\xe7\xa2\xdc\x4a\xf1\x3f\xe2\xc7\x4c\x8d\xe3\xce\x33\x8f\xbd\xf2\xdc\x20\xfa\x6e\xf9\x94\x24\x2f\x4d\x3c\x9a\x4c\xbf\xdf\x84\xbf\x8f\xd0\xef\xbf\xa0\xb6\x68\xe5\x8d\xef\x38\x01\xaf\x47\x14\x5b\x4b\x76\x97\xdb\x2d\xf0\xa1\x60\xd0\x5a\x92\xaf\x01\xa0\xa4\xcc\xc8\x73\x15\x95\x85\xd9\x64\x41\xb2\xe2\x65\x46\xda\xff\xb0\x24\x18\x74\xf9\x84\x42\xa3\xcb\x65\x2c\x14\x58\xe4\xf3\x39\x48\xe2\x56\x4b\x91\x2b\x2d\x0a\xed\x47\x23\x25\xe6\x14\xb4\xa8\x88\x49\xc5\x25\xe5\x1a\x37\x8a\xc2\x53\x19\xcd\x0c\x4b\xd9\xab\x12\x41\x4b\xfa\x83\x44\xd0\xa1\x09\x6f\x9f\x3f\xfd\x96\xe1\x84\xe5\xcf\x33\xe6\xce\x9a\x3b\x6e\xe4\x98\x59\x53\x6f\x7d\xc2\xff\x8c\xf5\xd5\x83\x9b\x9e\x0b\x6d\xf4\xe8\x4b\xca\x23\x9d\x43\x1d\x97\x0d\x1d\xb5\xc2\x15\x6c\x5c\xb8\x02\x06\xb7\x3e\x7c\xe4\x09\xdd\x47\xb7\x8e\x19\x3e\xee\xee\xd1\x03\xeb\xc7\x5c\x32\xdc\x7f\x74\xd2\x68\x07\x5e\x33\xbb\x71\x47\xc5\xc2\x59\xab\xaa\x2c\x9b\x48\x2f\xf7\x1b\xdf\xb1\x03\x28\x86\x73\x0e\xc9\x39\x01\x36\x83\x47\x08\x06\x3d\x3e\xb5\x8d\xcb\xcd\xf3\x69\x28\xf6\xb9\x46\x13\x71\x46\x58\x82\x7a\xea\xc4\x72\xdc\x69\x68\xd9\x1a\x04\x54\xb7\x00\x19\x4a\xc1\x0b\x25\x19\xe3\x05\x2a\xca\xad\x16\x41\x82\x7d\x0a\x07\x00\xec\xde\xad\x61\xd5\x82\x2d\x33\xe7\x13\x66\x56\x4c\x7f\xf2\xc0\xf3\x90\xf9\xf1\xd5\x6f\x3e\x58\xb0\x62\xe6\x6b\x2b\xc5\x1f\x6f\x00\x26\x7b\xe7\x8b\xe3\xe6\xc4\xeb\x87\x60\x06\x6a\xc7\x5e\xf9\x00\xaa\x60\xce\x81\x4d\xc7\x6b\x2c\x0b\xef\xba\xf5\xfe\xc1\xd0\x2e\xe5\x11\xce\xc4\x36\x61\x07\x6c\x2b\x55\xc4\x08\xc2\x23\xb0\x69\x6d\xd8\x7b\xa7\xc8\x08\x2a\x72\xa4\x4f\xc5\x55\xbc\xdd\x4a\x80\x2e\x6b\xa2\x17\x5a\xbc\x5b\x62\xe9\x26\x05\xd3\x65\x77\xbd\x92\x10\x4e\x52\xe8\x83\x95\xcc\xf2\x46\xc8\x8b\xd7\xd2\xda\xbb\x89\xd6\x06\xf4\x78\xd3\x90\x06\x67\xaa\xcb\x9b\xaa\x81\xde\xad\xad\xe2\x08\x8e\xc5\x32\x97\xd4\x50\x8e\x8c\x15\xb3\x08\x15\x19\x72\xec\x4a\xa5\x2f\x62\x88\x54\xb6\x73\x07\xeb\xe3\x6e\xb3\x4a\x5b\x86\x8d\x6b\xb6\x8c\x2d\xc3\x3e\x3b\xf6\x24\x6d\x66\x03\x10\xb0\x00\x76\x27\xa1\x11\xd3\x70\xb4\x1c\x69\xdd\x99\xd2\x54\x49\x2a\xa0\x90\xf1\x1c\x99\x68\x4a\x27\x3d\x34\x1b\x12\xd6\x87\xc4\x0b\x73\xfb\x91\x4b\x9e\x33\xc6\xd9\xa3\x7f\x61\x26\xff\xeb\xe2\xe9\x0b\x97\x66\x3f\x5a\xc4\x6c\xdf\x1a\xc8\xae\x2a\xaf\x8e\x75\x7d\x66\xd7\xea\x8d\x8b\xa2\x33\xc6\x0f\x5d\xd9\x4b\x1c\xb1\x69\xa5\xf3\x96\x3a\xd8\xf1\x0f\x57\x20\xc2\x32\xda\x0d\xd5\x53\xc7\xc3\xb2\x7b\xee\x43\xea\x47\x4c\x03\x7b\x5d\x5f\x22\xb6\x47\x6f\xbc\xf8\x3f\x2f\x7c\x74\xdf\x53\xb5\x63\x4f\xa7\x6a\x8c\xd8\x5b\x4c\x3c\xa9\x31\x92\x7b\x3a\xe5\x52\xff\x0e\x4b\x42\xab\x47\x60\xf4\x3a\x9d\x0b\x9b\x3e\x5e\x1f\xed\xdf\xa0\x07\x7a\x4e\x2d\xe1\x57\x73\x78\x77\xb8\x96\x96\x4a\xba\x08\xa1\xfd\x7b\x60\xd0\x48\x1f\x19\x2b\x4c\x19\x11\x7a\xa2\x3a\x2b\xc3\xcc\x42\xf8\xd4\xa0\x8f\x16\x8b\x68\xde\xe7\x3b\x8e\xfe\xd5\xfb\xac\x7e\xde\x8c\x5d\xbb\xf7\x3c\x7c\xf7\xb4\x5f\x19\xaf\x78\x6b\xcf\x7e\x8c\xef\x04\x64\xee\x79\xfc\x3e\xdd\xc8\x69\x1f\xbd\xfd\xf6\x85\xee\x1f\x48\x72\xb0\x0c\xeb\xf7\x07\x28\x26\x1f\xd1\x2b\x59\x0c\xb4\xe9\x78\x80\x4c\x0a\x96\xe3\x14\x08\x9f\x4b\x9e\xe4\x61\x20\x0b\x52\x43\x35\x96\xde\x6a\x0f\x4b\x21\x52\x65\x22\x33\x11\xb6\xe5\xe3\x1e\x91\x9a\x63\xc8\x60\x55\x04\xe6\xcc\x5e\x91\x23\x5b\x7f\xf0\x3f\x62\xc7\xcb\x70\x22\x9c\xf9\x9a\x58\xba\x7c\xe9\xf4\x69\x4b\xed\x91\x9f\xfb\xdf\x92\x93\x15\xc9\xd9\x85\x0e\x37\xf3\xcc\xb5\xa6\x31\x7f\x9d\x77\xc7\x8a\x15\x77\xe4\x8e\x1c\xfd\xde\xe0\x0d\x9b\xea\x8a\x2b\xa2\x12\x9d\xc2\x8d\x2f\xd9\x8b\x6c\x57\x6c\xa3\xb6\x07\x03\x63\x96\x2c\x47\x45\x05\x1b\x04\x6e\x83\xbb\x10\x55\x77\x50\x06\x2d\xb9\x25\xb9\x92\xf3\x66\x64\x2b\x0a\x0a\x7c\xda\x12\xbd\x4f\x4d\xa4\x74\x9a\xf3\x26\x05\xe5\x20\xf6\x79\xa4\xe0\x9b\x54\xd1\x83\x09\xae\x28\x86\x39\x3a\x64\xb5\x44\xcb\x29\x80\x64\x0e\xbd\x9e\xc8\x9e\xe4\xa0\x06\x22\xb2\xd4\x7a\x28\x09\x23\x3f\x53\x03\xf1\x41\x3a\xae\xb2\xe6\x69\x5c\x16\x6d\xef\x3e\x90\xe9\xbf\xad\xfd\x5d\xc1\x9a\x9a\x70\x91\x7d\x75\xb4\x9e\xf0\x55\x5b\xb6\xda\x5e\x14\xae\xe9\x12\xba\xab\xfd\xb6\xfe\xe3\xe7\xe5\x55\xd9\xac\x55\xb9\xf3\xde\xb1\xe6\x47\xfb\xdb\x4b\x4b\x4b\x1c\x63\xd0\xcb\xe3\x46\xdf\x59\x3e\xaa\xb2\x52\xbc\x72\xeb\x3d\x75\xd3\x16\x2c\x98\x36\x6c\xcb\x18\x58\x5a\x59\x39\xaa\xfc\xce\xd1\xe3\x86\xcf\xbc\xaf\x57\xaf\xfb\xee\x18\x21\xc5\xe4\x1a\xf1\x1e\x59\xf0\x1e\xd9\x40\x69\xcc\xae\xe4\x6d\x7a\xb3\x19\x7b\x3f\x76\x87\xd9\x63\x10\xf4\x48\x93\x61\xb6\xb4\xe5\xf3\x64\x76\x12\x08\x1b\x31\x3f\x93\xba\x1c\x5a\xf8\xf4\xc3\x8d\xb7\x2d\x5b\xb9\xeb\x64\x23\xcb\x3e\x3b\x6b\x0c\x81\x32\x6d\xae\xdf\xbb\xf0\xf8\x01\x66\xce\x35\x2f\xdc\xbd\x5c\x3a\xc3\x34\x7f\x15\xdf\x65\x0f\xc1\xe5\x64\x4d\x1a\xec\x31\x9b\x4d\x1e\x93\xd7\x67\xf6\x58\x19\x01\x1b\x7c\x7a\xbd\x1d\x4b\x44\xbd\x21\x23\x86\xd5\xb2\x21\x56\xc2\x4a\x4a\x78\x04\xe9\xe9\xaa\xcf\x42\x4f\xcf\xbe\x95\xdd\x96\xa5\xa7\xaa\xb2\x4f\xc3\x5c\xc3\xc3\xe6\x86\x89\x2d\xf2\x54\xa5\xf5\x20\x58\x60\x84\xa6\x08\x41\x85\xc7\x34\x65\x65\x45\x3c\x26\x93\x3d\x82\xb2\x73\x22\x56\x2b\x3e\xa6\x56\x8f\x4c\x5a\xa0\x15\x69\xb2\x45\x67\xff\x6d\xea\x32\xda\xdd\xb7\x45\x66\xa2\xe5\x7d\x6b\x62\x33\x7a\xde\x27\x68\x66\xe4\x3a\x08\x92\x0b\x64\x05\x83\x63\x05\x04\xe2\x87\x35\x69\xc9\xab\xae\xdd\x6c\x1a\x3c\xca\x0c\x5b\xb6\xd5\xd0\xff\x56\x5b\x0d\x39\x82\x99\xc8\x49\x68\xb3\xb1\x06\x89\x5d\x32\x5f\xbd\xf3\x8e\xd4\x5c\xe3\xab\xaf\xc4\x17\xe1\x8f\x52\xd0\xf2\x58\x43\x03\x1c\x96\x08\x57\xe2\xf5\xfc\xcf\x8d\xef\xd1\x1c\x7c\xbe\x74\x20\x12\xd3\x02\x95\x4a\x6f\xd0\xe2\x43\xa5\xd5\x2b\x10\x0d\xa1\x2a\x52\x82\x49\x02\x34\x4b\x96\x5f\x91\x72\xc6\xca\x20\x73\xaa\xba\x2a\x58\x58\x5e\x84\x2d\xad\x9f\xe0\x79\x18\xa9\xeb\xa5\x3e\xa0\x82\xb9\xcc\xbd\x0d\x78\xec\xcb\xa4\x30\x0d\x8f\xad\x06\x65\x31\x07\xc7\x92\x82\x6d\x8d\x36\xc1\x1a\x52\x03\x35\x15\x84\x99\x95\xa6\x09\x65\x64\x96\x11\xc9\x48\x2c\xf6\x32\x8a\x8a\xe7\x61\xac\xe9\x32\xac\x11\x5f\x64\x3b\x34\x34\xfd\xad\xa1\x01\xf9\xa4\xf3\x90\xe8\x55\x12\x00\x75\xb1\x7c\x2d\x5e\x42\x8f\xc1\x68\x0c\x86\x1c\x4a\x25\x83\x9d\x59\x4b\x6d\x9c\x77\x2b\xf1\x2f\xbd\xdf\xef\xab\x8d\xfb\xa1\xc6\xa0\xc7\xf6\x8b\x3e\x73\x61\x65\x6c\xc9\x56\xc8\x68\xd2\x73\x78\x94\x1e\x08\x99\x16\x7a\x20\xc2\x58\x14\xd8\xa5\xfe\x25\x86\x80\xdf\xc5\xaf\x1a\x39\x2e\x6c\x91\x96\xda\xe5\xca\x71\xaf\x62\xa6\x0f\xa9\xa2\xed\x4c\x74\x7c\x49\xe9\x5d\x77\x71\x22\xdf\xd0\xc0\x74\x56\x94\x96\x4c\x59\xc2\xc1\x6f\x24\x3d\x99\xa0\x9b\xf4\x0d\xb8\x2d\x56\xee\xd1\xe9\x04\x41\xc9\xe3\x83\x61\x37\x29\x95\xfe\x00\x52\xd9\x55\x75\x71\x60\x77\x38\x4d\xce\xba\xb8\xdd\x64\x37\x09\x56\x02\x3c\x69\x6d\xbb\xe3\x4a\x42\x59\xb6\x82\x77\x4b\xb6\x33\x4c\x3b\x22\x21\xa9\x7b\x1e\x8d\xc2\x57\x52\x2d\x12\x65\x3e\x3e\x7a\x54\x62\x80\x9b\xb8\x76\xe5\x64\x81\x50\xdf\x28\x44\x3b\xce\x64\xde\x5f\x29\x56\xe2\x23\xf3\xda\xea\xe9\x13\x16\x43\x67\x43\xb3\xee\xbd\x4e\xd1\xa9\x78\xdd\x3f\x11\x87\xa3\xbb\x31\xfd\x3a\x10\x8a\x19\x53\xe7\x06\x2a\x50\x7d\x32\x6c\x96\x3c\x34\x1c\x35\x76\xd3\x0e\x0d\xac\xae\xaa\x2a\xe9\x59\x24\x7e\x41\x26\x9a\x53\xd7\x5d\x7f\x50\x0f\x73\xb9\x17\x1a\x52\x77\x7c\x2d\x8d\x51\x4c\x8c\x45\x91\xdf\x0f\x78\xb7\x97\x73\x73\x4a\xec\x56\x03\xbb\x12\x28\x03\x41\xa3\x51\x0b\xa8\x1f\xed\xe1\x7c\x08\x6f\xac\x87\x77\xf1\x24\x27\x0d\xe9\x21\xa4\x2f\x9e\x35\xd5\x49\x10\xce\x96\xc8\x0b\xc9\x82\xce\x84\x8d\x26\x25\x11\xc8\x10\x9c\x09\x5b\x94\xa2\x73\xd2\xc7\x62\xe3\xb3\x8d\xcc\x4f\xe2\xd6\xe7\xdf\x5b\xfe\xc5\xf6\xdf\x7f\x95\x73\xa2\xea\xef\xe3\x77\x0e\x7a\xfe\xc1\x7a\xb8\xbc\xf9\x55\xee\x92\x38\xf3\x69\x71\xa7\x43\x7c\x71\xe3\xa7\x2b\xef\xdf\x65\x3d\x35\xf6\xd1\xf1\xf7\x9f\xd9\x06\x57\x35\x0d\xc6\x7c\x4c\xc1\x36\xc0\x54\x7c\xfe\x73\x88\xf7\x19\xf0\xda\x20\xcc\xd6\x0b\x82\x4a\x95\xed\x45\xb9\x79\x39\x0a\x9f\x9e\x0d\xbb\xc2\xf8\x34\x9a\xcd\x36\x97\x4d\x2b\x65\x61\x19\x93\x29\x48\x19\x92\xaa\x05\x96\x35\xf6\x37\x4b\xa0\x8c\x0e\x11\x6e\x29\xe6\x99\x67\xcb\xba\xc6\x06\x1d\xe5\xef\xe5\x20\x13\x9a\x32\x70\xc4\x70\x33\x93\x7b\xe7\xd0\xf9\x93\x8f\x94\x75\xed\x36\x80\x60\x5a\xef\x59\x7c\xfe\x30\x33\xb6\xe9\x89\xe7\xf3\x97\x97\x4e\x1e\x33\x6e\xe2\xb4\x91\x8f\x5f\x21\x0a\x60\xcf\xe2\x23\x47\x98\x39\xd2\x1e\x4c\xc1\x7b\x30\x01\xd3\x9e\x4d\x3d\x67\x8f\x15\xc2\x88\xa0\x56\xab\x54\x11\x0f\xca\xc9\xcd\x56\x78\xf5\x6c\xc8\x89\x9d\x66\x9d\xc9\x64\x75\xda\xd4\x9e\xff\x03\xed\x58\xfa\x57\xfd\x17\xd2\x1f\x15\x98\xf0\xa4\x9e\x37\x23\x1c\x6b\xa8\xf0\x83\x4b\xe2\x03\xdb\x20\x1c\x82\x09\x98\xee\x89\xd8\xee\x2a\x05\xb5\xb1\x7c\xbd\x42\xa1\x51\xda\x4a\x4b\x41\x6e\xd8\xe7\x03\x4a\x54\x56\x1e\x8c\x90\x44\x46\x9b\xcb\x65\x2e\x64\xcd\x2c\x59\x7b\x83\x46\x0f\x94\x14\x2a\x22\x09\x3c\x10\xcd\x80\xad\x4a\x96\xf9\x06\x33\xa1\x9c\xac\x52\x58\x34\x99\xc5\xd8\x5a\x6f\x30\x66\x79\x23\x78\x26\x34\x75\x40\x92\x9d\x05\x0b\x63\x44\x7f\x10\xa6\x98\x27\x09\x4b\xcd\x0f\x91\x9c\xc5\xd4\x5e\xa4\xd4\x88\x93\x70\x86\xd5\x08\xbc\x21\x4a\x7d\x73\xb0\xcf\x5a\x1d\xf3\xba\x14\x0a\xad\x09\x04\x4d\xc1\x50\xd8\xe5\xf5\x62\x36\xbc\x06\xab\x5e\xad\x27\x36\x9a\xf4\xde\x2f\xbd\xc7\xa4\x3d\xbb\x66\x32\x90\x4e\xaa\x94\x89\x29\xd7\x6c\x4c\x24\x4a\x6d\xc1\x02\xaa\xdf\x64\x24\xf4\xa9\xff\x7a\xe2\x98\xac\x82\x85\xdd\x9b\x24\xb2\xce\x49\x19\x96\x97\xcf\xfe\xa1\xb9\x04\xaf\x39\xe9\xe9\xf3\x0b\x7d\x37\xaa\x8a\x79\x38\xe0\x32\xe2\xfb\x66\x0a\x05\x31\x69\x5a\x89\x34\x93\x55\x60\xea\x93\xcf\x71\x6d\xd4\x8f\x70\x96\xa4\x7c\x68\x99\x23\x4a\x29\x63\x9d\xf3\xba\x14\xc6\x3a\x8a\x5f\x50\xa5\x9b\x46\xd9\x9c\x9d\x86\xc3\x3a\x98\x8b\xda\x4b\xfa\x36\x91\xfb\x89\x29\x93\xed\x17\x62\x3b\x19\xb0\xed\x64\x53\x03\x9d\x4e\xaf\x20\x95\xf3\xbc\xd1\x84\xd4\x7a\xce\xa0\x57\xe8\xe9\xbe\x67\x34\x7c\x93\xa3\xb0\x4a\x68\xb3\x93\xd8\x54\x18\x12\xf7\x9c\x24\xfa\xdc\x0e\x2f\x5b\x23\xec\xb1\x47\xc5\xaa\xdc\xa0\x70\x14\x9f\xc6\xc1\xbe\x7e\x4b\x99\xfb\xaf\x5f\x64\xce\x76\xe8\x7d\x5b\xd7\xe6\xdb\xf1\x44\x89\x3c\x65\xe2\x5b\xb3\xbb\xa9\x9c\x6f\x8f\xbf\x3f\x40\x63\x95\x21\x30\x39\xd6\xde\xa7\xb1\x23\xe4\x30\xf1\x56\x96\x85\xbc\x86\x0d\x67\xd9\x99\xba\xb8\xde\x0e\xd5\xc8\x6e\xe7\xb1\x1c\xa8\x8d\x9b\xf5\x7a\x77\x6d\xdc\xa4\x37\x28\xb1\x01\x23\x28\x6d\x3c\xc2\x3a\xcc\xda\x32\xb2\x96\xea\x80\x5d\x90\x51\xdf\x22\xc1\xb3\x4a\x9a\x33\xcd\x2f\xa2\xb8\xb6\x32\xd4\x29\x49\x48\x64\x6f\x13\xe7\xc3\x97\x9b\x0f\x74\x5d\xb5\xff\x91\x23\x0f\x75\x8b\x67\x31\xfd\xc5\xfe\x0f\x0e\x1a\x35\x6a\xe8\xd1\xb1\xf5\xcc\xec\x55\xe2\xae\xb5\xb7\x8c\x85\x01\x68\xc2\xce\x8f\x2b\x5c\x5a\xb3\x51\x3c\x3f\xf8\xe3\xd7\x5e\xff\x1f\x71\xf0\x55\xcc\x53\x05\xe6\xe9\x7e\x1a\xe7\xa1\xd2\x41\x9b\xe5\x83\xd0\x2c\x38\x1c\xe6\x2c\x2c\x1b\x7c\x16\x4b\xd0\xca\x1a\x82\x58\xcd\xba\x83\x36\xab\x8a\xb4\xad\x4b\x83\xbc\xa7\x40\xbc\x29\x1f\x59\x96\x0e\x49\x90\x7b\xda\x33\x48\x6a\x37\x61\x26\x89\x31\xd4\x15\x95\xab\xbc\x01\x73\x6a\xe0\xc0\x21\xbd\x5f\x7d\xfe\xdc\x2b\x7d\x86\x0c\x1c\x38\x08\x0a\xb0\xe0\xe0\xae\xf1\x6b\x1c\xce\xd5\xa3\x1e\x78\x10\x16\x32\x03\xa6\xbd\x74\xbc\xf1\xf4\x97\x90\x11\xaf\x7d\x7a\xe6\x99\xe3\x2f\x4d\x63\xa0\xd8\x28\xfe\xe5\x87\xe6\x75\x8b\xd7\x2c\x15\xff\x05\x73\x60\x7f\x9a\x0f\x41\x7b\x94\x52\x4c\x38\x1b\xf0\x62\x8f\x22\xcf\x6e\x51\xea\xf5\x2e\x1e\x1f\x17\x83\x86\xd5\xf8\xfc\x4a\x33\x69\xd4\x24\x40\x1e\xef\x04\x6f\xb0\xb8\xa0\x0b\x4b\x3a\x28\xf5\x18\x4a\xeb\x9e\x51\x93\x01\xf8\x40\x76\x80\x38\x6a\xc6\x6c\xbc\xea\xc4\x97\xb6\x99\x8c\x06\xce\x68\xae\xc8\xce\x31\x76\x81\x11\x8b\xcd\x8e\x3d\x38\x46\xf7\xfc\x1b\x70\xcb\xe1\xb7\x5f\x12\xa7\xbe\x3f\xe5\xae\xd9\x53\x9b\x9f\x99\x34\x6d\x06\x96\x59\x70\x8f\x1d\x62\x3b\x10\xfe\x5a\x0e\x57\x8b\xcb\x2c\xe2\x37\x62\xb3\x08\x8a\xc4\xc9\xe8\x4f\x7f\x7a\xd5\xd2\x74\xd2\xf6\xc6\x8b\x67\xde\xf4\xa0\x1e\xae\x4b\x44\xc6\x9d\xb9\xf1\x2d\xfa\x00\x1f\x37\x2b\xc8\x8b\x59\x74\x3c\x2f\x58\x05\x9b\x5d\x67\x36\xe3\x3b\x66\xb6\x69\xac\x3c\xf1\xef\x33\xef\x58\x59\x69\x55\xaa\x99\x18\x79\xf6\x08\xd3\xf7\xa9\x33\xb3\x26\x3e\x74\xb1\x31\xfd\x35\xf0\xb0\xf9\x87\xb3\xb0\xa9\xb9\x7b\xda\x4b\xa0\x3c\x1f\xc5\x17\x69\x7b\x3e\xf8\xff\x37\x1f\x6a\xb8\x7e\x22\x73\x3e\x82\x4b\x49\xb1\x94\x2b\x63\x66\x33\xcf\xeb\x04\x97\x80\x5d\x0f\x87\x03\x4f\xe8\xb0\x19\xd4\xb4\xbd\x89\xc1\x43\xf9\x4c\x4b\xfc\x4a\x06\x32\xaa\xd2\x1b\xa7\xd1\xc7\x66\x12\x75\x4e\x11\x40\x9e\xc7\x3b\xf6\x16\xb9\xe2\x71\xab\x47\x27\x58\xbe\x3e\xb0\xae\xbb\xee\x80\x1a\xe6\xc2\xe9\x93\x27\x45\x8d\x54\x97\xfc\x80\xe9\xb0\xd2\x78\x90\xcc\xb7\x60\x4d\xf2\x6d\x50\xeb\x05\x4f\x1b\x7c\xc3\xa4\xf8\x6a\xf1\xfa\xda\x82\x71\xb4\x0b\x4f\xdb\x34\x8a\x9d\x9c\xf1\xe6\x9a\x9a\xd3\x0f\xca\x63\x4e\x87\x86\xe7\x8d\x46\x7f\x20\xe8\xf0\x7a\xf1\xa4\x44\x94\xea\x95\xf5\x89\xe6\x33\x2d\x45\x7c\x72\x72\x89\x6d\x41\x16\xa7\x2d\xc9\x68\x5f\xd5\xae\x20\xe4\x2f\x16\xbf\x69\x45\x4e\xf3\x3d\x75\xdd\xb5\x87\x39\x1e\xcb\xd3\x2e\x29\xb2\x20\xf4\xc8\x6f\xd5\x5a\xe0\x8d\xe9\xb4\x00\xf0\x3a\x3d\x8b\xc9\x60\x13\xc9\x65\x12\x05\x44\xbf\xd0\x1c\x05\x39\xf8\x02\x3d\xd8\xa4\x52\x4f\xbd\x7d\xe2\x94\x17\x7f\xcf\xb0\xd0\x0d\x4b\xcc\x8f\x5a\xaf\xbe\x2f\x22\x20\xef\x31\x3a\x91\x18\x13\x68\x05\xad\x4e\xaf\x64\xeb\xf1\xad\x93\x1a\x79\x25\xc7\x94\x2a\x0b\xc9\x43\x64\x00\x38\xf1\x05\x79\xfe\xfc\x94\x89\xb7\x4f\x85\x4a\x18\xc0\x03\x3c\xf2\xc1\x15\xeb\xa3\x66\xf1\xaa\xf8\x29\xb6\xb7\x18\x70\x06\xd3\x39\x13\x9f\x1b\x2d\xa6\xab\x6f\x2c\x4b\xa9\xd1\xe0\x23\x02\x20\xb6\x5a\x4c\x3c\xe4\x6d\x76\xa5\x56\x8f\x15\x92\x5e\x0f\x19\x46\x57\x8b\x5d\x44\x35\xb4\xa6\x3d\xfc\xb7\x6e\x11\x25\x03\x44\x85\x93\x0f\xfe\x61\x18\xc6\x06\x6c\x39\x09\xe2\xc1\x19\x8d\xf0\xad\xb3\x6f\x2e\xdd\x02\xc7\xbf\x2f\x36\x7e\x08\x4d\x1f\xcc\x9d\xce\x76\x38\x78\xef\xf2\x7d\x61\xb1\x33\x3c\x0d\xaf\x89\x0d\x67\x47\x8f\x92\xfc\xbf\x04\x5d\x82\x44\x97\x46\xa9\x54\xe8\x15\x82\x60\x56\x91\xd6\x70\x66\xbd\x8d\xd4\x5a\xf2\xb5\x71\x85\xc2\xac\xb2\xe8\xcd\x02\xd6\x01\xd6\x54\xe8\xa2\x35\x59\x46\xb9\x88\x91\x08\xcc\x70\xd0\x09\xa3\xf8\x17\xad\x69\x0b\x13\x64\x99\x45\x33\xe6\x7c\x20\xfe\xe3\x43\xd8\xff\x7d\x71\xff\x96\xa5\x6f\xfc\x5e\x2c\x6a\xdc\x38\x6a\xf4\x59\xb1\x01\x5e\x83\xa7\xc5\xce\xa1\xfd\xcb\x77\x1e\xc2\xb4\x90\x3d\x78\x14\x9f\xb5\x2c\xf6\x16\x50\x41\xaa\x3f\xd4\x06\x60\xe2\x79\x83\xa1\xc0\x9f\x1d\x89\x38\xf0\xf9\xab\x6c\xe7\x28\x40\x21\x02\x16\x04\xb2\x67\x65\x33\x6a\x94\x9d\x1d\x32\xe8\x14\xf5\x71\x9d\x07\x61\x3d\x65\x32\xa1\x24\x50\x78\x46\xe6\x69\xab\x4e\x4f\x94\xe2\x44\x02\xaa\xd5\x92\x3a\x9b\x55\x3e\x26\x1a\x20\x69\x0a\x59\x09\xd0\x0e\x29\xae\x65\xb5\x60\xc5\xef\x43\x6c\xd6\x57\xaf\x9f\x9e\xb4\xa8\x3a\x3f\x94\x55\x20\x7e\xbd\x5f\xdb\x63\xca\x4c\xa8\xbb\x6d\xb2\x28\x6e\x1f\xf0\xf6\x2b\xc7\xaf\xba\x0e\x6a\xe7\x2d\xf8\x77\xc1\xc0\x19\x5d\xbb\x6e\x9c\xdd\x17\x56\xee\x79\xaa\xe3\xfe\xad\x9a\x83\x9c\x80\xef\xf0\x42\x7f\xe7\x3e\x81\xc7\x6a\x6a\x9d\xb1\x7e\x77\x0e\xd9\xf1\xc8\xda\xe5\x96\xbe\x7d\xef\x2b\xae\xce\xc6\xce\x61\x5e\xaf\x3b\x08\xef\x37\xf0\xf1\x79\x89\xe6\x14\x15\xc7\x54\x7a\x9b\x8d\x51\x2a\x9d\x2e\xad\x89\x8a\x16\x2d\x04\x1c\xf5\x7e\x41\xa6\x23\x13\x4d\xeb\xe7\xd1\x05\xa6\xbf\x76\x12\x93\x0a\xae\x1d\x54\xd5\xa9\xba\x5d\x67\xf7\x7d\x3b\xa6\x17\x96\x75\x1b\x70\xcb\xfd\xe2\x70\xf3\x01\x47\xe1\xd0\x29\xec\xd6\x27\x4e\x9a\x1e\x75\x4f\x5d\x71\x7d\x5e\xe3\x53\x69\x73\x07\x48\x9e\xab\x4e\x30\x1a\xed\xd0\xef\x0f\x86\x74\xf8\x1f\x6a\xe3\xc6\x80\xd5\xea\xa2\x64\x58\x3d\x9c\xd4\x6c\x8a\x83\x29\x00\xd2\xd6\xf8\xdd\x91\x68\x06\x21\x89\x84\x2b\x99\xca\xce\xf8\xd0\x76\x7d\xf1\xfe\x7d\x23\xcb\x08\x49\xc7\x8e\xdd\xff\x80\x4c\xe5\x8b\x5b\xd0\x5f\x9f\x3e\x4e\xc9\x6a\xea\xbd\xa5\x57\xe3\x53\x12\xad\x11\x7c\xdf\x19\x4c\xdf\x73\xf8\x6e\xd2\xb5\xb1\x1b\x0c\x2a\x84\x9c\x2e\x8d\x40\x89\xd2\x18\x80\xe5\x37\xd6\x46\xce\xea\x91\x12\x07\xf0\xaa\xc8\x8e\x1f\xaa\xd8\xbd\xed\x96\x5b\xba\x95\x15\x0e\x3f\xb8\xc7\xd1\xbe\xa2\xba\x53\x95\x38\xfc\xf1\xd3\x48\xbb\x7a\xb2\xfb\x51\xd3\xd1\x27\x9b\x3e\x9d\x3c\xbc\xd0\x71\xc0\x8c\xef\xca\x5d\xe2\x30\xba\x36\x1e\xec\x35\xd5\xc7\x7c\x5c\x38\x6c\xf0\xaa\xd5\x06\x1b\x00\x06\x43\x6e\x1e\x79\x74\x34\x80\x30\xc7\x62\x77\x59\xee\xc7\xa2\x8a\x5b\xa0\x80\x4d\x25\x24\x78\xd2\x1f\x53\x1d\x89\x32\xaa\x54\xca\x36\x35\x34\xf1\x11\x2b\x21\xef\x90\xf2\x89\xb3\xa7\xaf\x9d\xfc\x7e\x47\xfe\xce\x9c\x99\xbc\x70\x66\xaf\x21\x75\x2f\xf4\x5d\xdc\x77\xf3\xca\x58\x8f\xc4\x9e\x8a\x43\xbb\x96\x74\xe9\x3b\xb0\xba\x43\xbb\xb2\x91\xc7\xe6\x8d\x98\xf4\xfb\xce\xb3\x87\xcc\xdf\xe0\x60\x0b\x12\x3b\x6c\x68\xdf\x6e\xec\xa0\xb2\xae\xf4\x7e\x9d\xc0\xc6\xc6\xb7\xdc\x44\x7c\xeb\x3b\xc6\x6c\x8c\xd5\xca\xe1\x6b\x6f\xb3\x33\x14\xfe\xdf\x2a\x08\x46\xd6\x48\x32\x7c\x9e\x89\x1b\x09\x54\xdd\x85\xb6\x93\xe8\x88\x71\x14\x46\x12\x2c\x7b\xfa\xca\xa2\x6f\x8f\x75\x58\x20\xd6\xc2\xe3\x89\x56\x53\xf0\x48\x83\xf8\x39\x74\x35\x30\x5b\xe4\x2e\x53\xcd\xe3\xd3\xfb\x84\x59\x41\xbb\x98\x9a\xf4\x09\xb3\x58\xb0\xc0\xa1\x13\xdf\xbc\x33\x58\xfa\xf4\x2d\x1a\x82\x59\x5b\x77\x01\x93\x1b\x5d\xd1\xca\xa4\xeb\x1f\xc8\xb3\xb3\xed\x25\xd9\xd7\x97\xf4\x14\xc7\xf2\xc6\x03\x22\xd8\xd2\xca\x09\x01\xe0\xf0\x04\x0d\x24\x2b\xcb\xc3\x66\xe7\x84\x14\x4e\x97\x13\x4f\x0f\x5d\x2e\x0d\xf2\xe8\x49\xd6\xa5\xc1\x82\x4d\x8a\x04\x8a\x55\x9b\x99\xb3\xc9\x37\x00\x23\x05\xc8\x27\xe7\x3d\xad\x9f\x93\xd4\x80\x20\x91\x41\x6b\x83\x53\xe0\xcf\x27\x67\xcc\x90\x5d\x06\x1a\xf9\x9c\x3e\x1d\xee\x5c\xb9\x4b\x54\xde\xc6\x76\x10\x4b\xe0\x15\xb1\x64\x6d\xb3\xe4\x35\x90\x40\xe8\xe2\xb5\xf0\x4a\x53\xe7\xe3\x07\xbc\x23\xf6\x2e\x24\xeb\x37\x0f\xd3\x3f\x1c\xd3\x5f\x02\x6a\x62\x7e\xab\xd6\xa8\xf0\xe7\x2a\x72\x51\xd8\x5d\x84\x8a\x4a\xcb\x22\x1a\x12\xf4\x08\x69\xf5\xc0\x91\xea\xc9\x9c\xb1\x81\x99\x7d\x9d\x2a\x2b\xaa\x12\x71\x05\xe9\xfd\x27\x59\x68\x9c\x23\xc5\x64\xe4\x66\x26\x24\xfc\x0c\x98\xc9\x9f\x88\xff\x1c\x12\x0d\x16\x14\xd4\x2f\x89\xdf\xd1\xbd\xc7\xa3\x5b\x1b\x8e\x74\xef\x31\x73\xc4\x92\xfa\x82\x82\x40\xc5\x10\xf1\x07\x0b\x04\x6f\x6f\x99\xdf\x27\xe6\xf1\xe7\x6f\xbe\x7d\xf8\xd8\xb9\x73\xc7\xec\x3f\x77\x6e\xff\x98\xb9\x73\xc7\x8e\x98\xbc\x39\xdf\xef\xed\xd2\x77\xfe\x96\x2b\x62\xb3\x54\xbb\x78\x08\xf3\xd1\x83\xed\x60\xe2\xd1\x7c\x7a\x36\x7b\x62\x9d\xb4\x1e\xf3\xa5\x02\xb9\x31\xb3\x52\x05\x01\x8f\x18\x86\x57\x21\xb5\x06\xa9\xac\x3c\x09\xcb\x95\xd7\x44\x33\x21\xb2\xb1\x9a\x09\xd3\xe2\x1e\x18\x66\xe0\x9f\xe1\x89\x57\xc5\x9f\x8c\x15\xe1\x1c\xf1\xdb\x57\xd8\x0e\xd8\x0d\x3a\xdf\xee\xf4\xbc\xf9\xcd\x5d\x00\x09\xc0\x00\xf6\x0c\xb5\xdf\xf2\x63\x16\x83\x1e\x29\x90\x0b\xb9\x3d\xc8\x60\x50\xba\xac\x66\x8d\x34\x78\x39\x1e\xbe\xba\x24\x99\x4a\x45\xe0\x0c\xcc\xf6\x2e\x10\x7f\x0d\x23\xa6\x92\x17\x10\xe9\xce\x6b\xd1\x31\xf8\x2f\x6f\x5d\xda\x5a\xad\x2a\xdf\xf1\xda\xe9\xa7\xc7\x04\x73\xcc\xeb\x5f\x5c\x15\xb0\x2b\x34\x1a\x34\xe9\x38\xde\xbf\xbc\x57\x0b\x8e\xc2\xcb\x78\xf6\xb1\x50\xd1\xe5\x40\x3b\x71\x04\x3c\x3a\x75\x86\x6f\xe4\xd8\x61\xce\xe6\x87\x28\x9f\x3d\x30\x2d\x9b\xb9\xbf\x63\x5f\xa5\x38\x66\x37\x29\x75\x2a\xa4\xc3\xd7\xcd\xa6\xd4\xe9\x80\x91\xf6\x6f\x52\x1b\x89\x11\x70\x21\x55\x17\x2f\xd3\x03\x65\xa9\x40\xd8\xc5\x4e\x20\x51\xfe\x5d\x20\x3a\x9a\xc8\xd9\x82\xef\x9c\x17\x7f\x19\x25\xe4\x89\xaf\x9e\x83\x2f\xc7\x5f\xe0\xfe\x2e\xa5\x6a\x5d\xbf\xc2\xac\xfa\xd8\x77\x47\xd3\x77\x6c\x87\x6f\xce\x91\xf9\x3b\xe2\xf9\xef\xc1\x6b\xa1\xc0\xf6\x9c\x9d\xe3\x79\x56\xa1\x00\xa4\x71\x31\x50\xaa\x04\xc8\xb2\x1c\xa3\x97\xca\xef\xaa\x5b\xe4\xc6\x95\x4b\x06\x95\xf4\x9e\x62\x64\x78\xb1\xf2\x0a\x1c\x0e\xc7\xbd\x2e\xe6\xc1\x33\xcc\x2a\x51\x07\x7f\x68\x5e\x2c\xde\x22\xd7\x71\x63\x3d\xfe\x25\x9e\xc3\x42\xb2\x34\xcc\x06\xad\xda\x62\xd1\x99\xb4\x26\xab\x0d\x7b\x91\x34\x9c\xac\x35\x6b\xb0\x47\xa3\xb1\x66\x06\xe7\x5a\xa7\x11\x52\xc6\xb9\xe4\x3d\x27\xc9\xba\x72\x71\x37\x5b\x58\x50\x55\x19\xe9\xde\xe1\x9f\xcd\x8e\x44\x69\x37\xf3\xc6\x9c\xba\xee\xea\x87\x34\x30\x77\xa5\x5c\xda\x4d\xee\xfb\x8e\x1b\x03\xd9\xcd\xf4\xbd\x82\x44\x64\x0b\x6c\x66\x97\x0a\xe8\x58\x83\x0f\x1b\xb2\x56\x83\x35\x18\xb2\xd2\x5c\x5d\x64\xaf\x25\xe5\x12\x66\xbd\xcb\x60\xd3\x63\x63\x42\xa3\xd2\xcb\xbb\x80\x6f\xba\x84\x99\x9a\x49\x19\xad\xce\xc2\xba\x2e\x51\xa8\x50\x00\x79\x21\xa7\x2a\x41\x5e\x24\xc4\x0b\xd2\xe3\x2a\xa3\x9a\xf4\xfc\xf8\xf9\x1b\xb6\xdc\xdf\x5c\x1a\xda\x5c\x25\xbe\x21\x55\x73\x34\x4f\x63\x8a\x4b\x26\xf6\x7a\x7c\x40\xaf\x76\x9b\x8f\xed\x5b\x7c\xfb\x82\x85\xb7\x0e\xe9\x3c\x4f\xa6\xfa\x74\xdd\xe4\xc2\xaa\x9c\x22\xbc\x8e\x8b\xf0\x3a\x76\xa5\x79\x83\xfd\x63\xb9\x58\xe5\x31\x16\x9e\x67\x9c\x6e\x2d\xe7\xf1\x3a\xb1\xd7\x8e\x7d\x40\xa4\x43\x2a\x40\x13\x2d\x3c\x8c\x1b\xb8\x33\xe3\xd7\xe9\x71\xd8\xf4\x37\x60\x73\x66\x70\x31\xed\x41\x18\x06\x1b\xd1\x54\x71\xe5\x85\x8f\xe6\xbf\xb7\xe5\x3d\xd1\xfe\xb4\x79\xcf\x86\x8d\x07\x4f\x1f\xaa\x87\x1b\x9b\x6f\x61\x3b\x1c\x17\x77\x39\xaf\xff\x69\xf3\xa7\xcb\xcf\x9d\xd5\xac\xfd\xdd\x9f\x0e\xef\x6d\xdc\x06\x57\x49\x78\x80\xc3\xd8\x95\x98\xce\x00\xc8\x07\xb7\xc6\xda\x39\x79\x3f\x93\x6b\x32\x01\x5f\x18\x1b\x92\x0c\xaf\x2c\x2c\xb0\x92\x24\x05\x84\xb0\x34\xb5\x2b\xc2\x1a\xd6\x8a\xac\x48\x07\x74\xc1\xba\xb8\x5a\xe7\x61\x02\x24\xf5\x28\x45\xf7\xc5\x8c\xdc\x23\x10\x2d\x68\x93\x76\x81\xbc\x8d\xa5\xa9\xcd\x24\x03\xb0\xbc\x4a\x4e\xf0\x92\x59\xe9\xda\xa5\xfb\xc4\x25\x3b\xff\xb2\xbc\x71\xec\xb1\x07\xcf\xbe\x63\x7a\xf6\xc0\x60\xc2\x0d\x9c\x7a\x72\xfc\x93\x87\xfb\x0e\x5e\x40\xd9\x72\x34\x5f\x5c\x3d\xb3\x7d\xdf\xa5\x1b\xd6\xf7\x5c\xd4\x6f\xde\xaa\x7b\x6b\xfa\x3d\xf8\x0c\xe6\xed\x7a\xe1\xd4\xbb\x3b\x54\x76\x26\x65\xd8\x60\x2d\xbe\x37\x65\xd8\x0e\xb0\x83\x0e\x31\x9f\x46\x6b\x07\xbc\xd9\x0c\xb4\xc8\xe1\x24\xb6\x27\xd2\x20\x0d\xb6\x07\x94\xa4\x03\x79\xc2\x07\x69\x9d\xc4\x28\x95\xda\x94\x67\xb4\x25\x32\x49\xb5\x36\x67\x2a\x7a\x3e\x74\xa8\x61\xdf\xf4\x4d\xb6\x67\x7d\xff\x3e\xfd\xc3\x3f\xbf\xfe\x80\xf1\x99\xde\x79\xf9\xdd\x73\x53\x27\xe8\x76\x9e\x16\xbf\x15\x7f\xfa\x45\xfc\xc8\x28\x2e\x93\xee\x57\x26\x2d\x6a\x3b\x30\xb2\x2c\x50\x23\xa7\xc3\x02\x6b\xe3\x16\x8d\x45\x03\x14\x0a\x7c\xcf\x14\xff\x85\x96\x6c\xc6\x58\x21\x85\x0c\x89\x95\x1b\x90\x1b\x6c\x32\xfd\x3e\xfd\x64\xe9\x27\x3b\x9e\xfe\xda\xff\xac\x6d\xe3\x0c\xf1\xed\x43\x0f\xf5\xac\x80\xab\x8c\x50\x07\xd1\xf1\x9f\x57\x3e\xbd\x5b\x37\x61\xaa\x38\xfd\xe5\x77\x4c\xcd\x7f\x93\x68\xa1\xbd\x7c\x08\x2d\x1d\x09\x2d\xd0\x86\x69\xb1\xa9\xf1\xba\xd8\xa1\x46\xa3\x80\x94\x0e\x1b\xb4\xd4\xc6\xa1\x3e\x23\x35\xa1\x26\x33\x2d\x81\x04\x27\xd2\x0e\xa4\x94\x00\x27\x18\x99\x19\xe9\xc4\xc0\x42\x42\x0c\x77\x49\x9c\x66\x14\x7f\x10\x9b\x13\xe4\xc0\x7b\x31\x39\x4c\xb9\xb4\x36\x9b\xf0\x59\x8c\x61\x5b\xd1\x06\x3a\xc7\xbc\x6a\xc0\x73\x9c\xc1\x08\x8c\x76\x87\x81\x37\xf0\x16\xc6\x82\xfd\x2c\x0b\xc3\x28\xb0\xb7\xd5\x0a\xd7\x27\xb3\x50\xc0\x4c\x93\xaa\x48\x72\x9b\x14\xb3\xa2\x35\x11\x01\x66\x13\x14\x4f\x7c\x16\x38\x9f\xfb\xce\xbe\x07\xf6\x1c\xf8\x28\x74\xce\xfe\xaf\x67\x45\xf1\x47\x38\x98\xb9\x7e\xe4\x01\xdd\x05\xf1\x2d\xf1\xa2\x78\x4e\xbc\xf4\xb6\xe6\x81\xb3\xa4\xb3\x0e\x40\x89\x7e\xe2\x14\x2b\xd8\x89\xe5\xa1\xd9\xe0\xb4\xd9\x78\x0d\x45\xcb\xb4\xc5\xec\x76\x25\x52\xea\xa8\x21\xab\x44\xc8\x2c\xc1\xfb\xdb\x32\x5b\xb9\xba\x2e\xa7\x45\x75\xca\xd3\x9b\x87\x97\x03\x94\xec\x19\x1e\x21\x9d\x2c\x52\x7d\xc3\x7f\x86\x8a\x64\xcb\x70\x71\xca\x4b\x2d\xba\x86\x3f\x2c\x1e\x4b\xf5\x0b\x7f\xe1\x83\x0f\x08\x86\x15\x3e\x53\x1d\xa8\x3e\xfe\x1b\xb5\x93\x16\xdd\xf8\x8e\xc4\x0d\x69\xee\x49\x6d\xac\x50\xef\x11\x42\xc0\x66\xd3\xf8\x43\x1e\x2e\x37\xcf\xaf\xd2\xaa\x88\xe7\xaa\xfa\x48\x85\xfd\x30\x95\xca\x19\xa1\x29\x28\x06\xa9\xf4\x33\x63\x9f\x13\x4e\x58\x8b\x56\x52\x89\x74\x01\x62\x62\x04\x64\x04\xe9\x2a\x03\x4d\xe3\xad\x48\x62\x26\x02\xb4\xa5\xef\x96\xc5\x77\xae\x5a\xbb\xa8\x63\x4c\xfc\xea\xee\x0d\x0b\x36\xf6\x79\xfe\x86\x78\xfd\xbd\x1f\x57\x2c\xbc\xf3\x8e\x7f\xbc\xfe\x6f\xec\x19\x14\xde\x73\x72\xf8\xad\x75\x03\x47\xdf\xfd\x5c\xfd\xe4\x31\x17\x08\x80\xe9\xdf\x0f\x6d\xbf\x73\xa3\x25\x34\x7b\xc4\x96\xa3\xe2\xa7\x20\x99\xfb\xf0\x21\x87\x30\x27\xe3\x62\x26\x10\x60\x02\x82\x4b\x1b\x89\x38\x4d\x8c\xc0\xe4\xe6\x19\xac\xc4\xf4\xf4\xc4\x0d\x6a\x90\x53\x1b\xd7\xba\xd4\xd8\x4c\x70\x71\x6a\xb5\x97\xe6\x42\x84\xdb\xc8\x85\xc0\xde\x63\xb2\xb1\x5e\x75\xea\x61\x4b\x72\x2a\xd3\xd3\x22\x28\xac\x69\x22\xfd\xf4\xe6\x19\x12\x07\x26\x0b\x1b\xe7\x94\x54\x64\x15\x74\xab\xba\x49\xa6\xc4\xa0\xa5\xeb\x35\xbb\x0c\xbd\x07\x5c\x4d\x4b\x98\xc0\x7b\x76\x12\xef\x99\x83\xee\xd9\x77\xf4\xac\xf5\x95\xfb\x92\x98\x81\x0f\x84\xc8\xfb\x63\x88\x63\x18\xbf\xc3\xe8\xd1\x1a\xb5\x59\xe1\x80\x7f\xf0\xa8\x00\xe4\x9c\x06\x27\x39\xfd\x06\xac\x37\x2c\x44\x6f\x00\xb3\x2c\x7d\x6f\x5a\x98\x62\x4c\xeb\xcc\x44\xf3\x71\xa4\xf8\xa7\xf4\x66\x67\x26\x86\xad\xc4\x18\xb6\xcc\xad\xbf\xc2\x7f\xc2\x5a\xf1\xf8\xa0\x9d\xb7\xef\x3f\xbd\xfd\xc1\xe7\xc5\x0b\x9b\x86\x8d\x3e\x3d\xa0\x6b\xdd\xc7\x2f\xb3\x1d\x9a\xb2\x36\x47\x6e\xdb\x1b\xdf\xbc\x74\xd9\x4a\x34\xf0\x7a\xf5\xf4\xe9\x8e\x4e\xd5\xed\xbb\xf2\x39\xe7\xcf\xd3\xf7\x9d\x99\xe8\x13\xfa\x36\x8b\xef\xad\x42\xa9\x4c\x80\x6a\xab\x59\x8d\x96\x11\x54\x50\x80\x4a\xa4\xd6\xf3\x6e\x25\x7d\x4d\x4b\x3e\x98\xa5\x10\x51\xe5\x12\x62\x25\xac\xa2\x6f\x3a\x30\xac\x84\xb0\x23\x9c\xb9\xa6\xb1\x51\x8c\xbc\x05\x4f\x8b\xe5\xd8\x3a\xd3\xde\x06\xef\xb9\x56\x81\xf6\x37\xff\x08\xaf\x30\x53\xc9\xd9\x80\x4a\x1a\x4b\xea\x00\x38\x10\x8a\xa9\x58\x88\xed\x4e\x81\xd1\x43\x96\xde\x44\x28\x87\x3d\x92\xc1\x9f\x3c\xda\x35\x86\xb5\x36\xfd\xd4\xc8\x8c\xc0\x0c\xc9\xf1\x94\x4d\xe2\x70\x8e\xa3\x79\x09\xb9\xa4\x4e\x25\xec\xf6\xb2\x26\x93\xda\xe8\x36\xe6\xe5\x3b\xb2\xb1\xc0\x71\xd8\x4c\x1e\x85\xae\x9e\x08\x64\xe2\x18\x02\x03\x41\x64\x4f\xf4\xa9\x89\xb6\xac\x53\x81\xc9\xbc\xa1\x44\x0f\x73\xb9\xa2\x9f\x48\x22\x98\x96\xbe\xcc\x18\x97\xee\x8b\x32\xdb\xb7\x56\xd1\x26\xe6\x27\x59\x86\x66\x8b\x33\x7f\x4e\x24\x88\xb3\xfd\x86\x4d\x84\x21\xb9\x83\xf9\xaf\xcf\xc0\xd3\x47\x12\x19\xe3\xcd\x1f\x27\x92\xc4\x33\xf4\x89\x1f\x8c\x8a\x95\x6b\x75\x0e\x8f\x07\x7a\xb1\x3b\xeb\xd5\xa1\x40\xd0\xed\x07\xfe\xba\xb8\x03\xb0\xd8\x42\xd2\xb3\x7e\x96\x21\xf5\x29\x5a\x2d\x0b\x90\xd1\x6b\x35\xaa\x6a\xe3\x46\x39\x18\x20\xe1\xa9\x66\xa2\xe6\x67\x74\x69\x33\xdf\x44\xfb\xd1\xd2\xc8\x70\x65\x70\x2d\x8c\xb6\xd2\x82\xa4\xcc\xa0\x51\xbc\x0c\x2d\x50\xd5\x5a\x1d\xce\x5c\xbc\x7b\x77\x0b\xfa\xc7\xc4\xa2\x06\xbd\xdb\xef\x67\x81\x15\xdb\xb5\x7a\x14\x0c\xf8\xb0\x9b\x55\x17\x77\x23\x07\xb6\xad\xf5\x0e\xbf\x03\xd3\x8f\x1c\x06\x83\x03\x21\xa0\xa1\x46\x68\x4a\x49\xb6\x85\xfb\x9f\xc1\x81\x04\xec\xdf\xb6\xda\x24\x4c\x30\xfd\x48\x51\x44\x1b\xea\x33\x2a\x5e\xde\xbd\x78\x66\x6b\x1d\x2a\xfe\x67\xf1\x6e\x8a\x97\xfd\x2d\xc5\xcb\x76\xe0\x5b\x1b\x01\x13\x63\x95\x4e\x85\x2d\x1c\x36\x99\x7c\x3a\xc6\x98\x65\xb7\x5a\x8d\x0a\xec\x7b\x58\x23\x66\x02\x0e\xa1\x37\x42\xbd\x5a\x1d\xa0\xc2\xc9\x83\x2f\x32\x67\x0d\xdb\x00\x36\x41\x40\xf2\x01\x3e\x9a\xb2\xa6\x5b\xf4\x85\x89\xa6\xa0\x4f\xda\x82\xcd\x90\xc0\xb1\x93\x58\x19\x4a\x18\x64\x74\x2d\x40\x32\x0c\x04\x19\xbb\x49\x23\xa1\x63\xc0\x57\xe0\x04\xf1\xc1\x56\xd8\x18\x33\x09\x2c\x76\x12\x11\xa3\x79\x03\x2a\x27\x77\xa4\x1c\xcb\x26\x12\x47\x29\x01\xd5\x60\x4d\xac\x77\xa9\x43\x1b\x0a\x55\x9a\x82\xa0\x24\x5b\xad\x89\xf0\x79\x79\x11\x75\x49\xd0\xc1\x77\xc0\xee\x49\xa1\xb5\x10\xd5\xc6\x0b\x3d\x11\x6d\x18\xeb\x98\xb0\x3e\x08\xd5\xd9\xd9\xaa\xba\x78\x76\xb6\xd5\xef\x76\x57\xd5\xc6\xdd\x06\x2b\x41\x5d\xb3\xda\x0c\x49\xbf\x9c\xf0\x69\x92\x63\xa6\x8e\x9a\x9a\x96\xcf\xec\x19\x6d\x8b\x12\x91\x97\x94\xdd\x9b\x83\x8f\x26\x81\x0b\x6f\x63\x45\x10\x31\x36\x69\x52\x72\x6a\x61\x98\x17\x1d\x03\xba\x0d\x1e\x3f\x6b\x6c\x31\xf7\x95\xb8\x5f\xb5\xaf\xc5\x1a\x59\xfe\xb1\x62\x71\xe3\xa1\xf5\xf7\xe5\x8b\x27\xa5\x75\x5a\x33\xbc\xe7\x85\xc7\x1f\x3d\x3c\x17\x1e\x68\x7a\x7d\x69\xeb\xe5\x5a\x2e\x8e\x09\x7e\xfc\xca\xbf\xc4\x6b\xf3\xee\x67\x9e\x93\x57\x8d\x96\x8d\x01\xdf\x8d\xc1\xf4\x5c\x64\x81\x62\x50\x86\xd7\x6d\x59\xac\x47\x44\x0b\x2a\x2b\x3d\xed\x59\xb7\xbb\xc4\x6e\xcf\x17\x6c\xa5\xae\xf6\xa1\x90\xcb\xa6\x65\x3b\x74\x74\x95\x39\xca\x6a\xe3\xfe\xf2\xda\x78\x89\xdf\xcf\x39\xf4\x36\x68\x28\xc4\x06\xa9\x41\x95\x5b\x1b\x17\x18\x95\xad\xd2\xcd\x11\x07\x81\xb3\x26\xda\x8a\x93\xf8\x4a\x42\x0a\x91\x9c\xb4\x56\xc8\x7e\x89\x84\x8d\x44\x61\x2c\x71\x71\xda\x5e\x26\x28\x3f\x3a\x5b\x82\x19\xe7\x07\x52\x3f\xa8\xb2\x02\xe5\x95\x9b\x56\x17\xdd\xdb\xf2\x30\x35\xff\xab\x63\xff\x2d\x63\x27\xdd\x2e\x7e\xde\x6c\x4a\x1e\xa9\x5b\xc5\x83\x70\x56\x51\xaf\x9c\x5b\xee\x5e\x50\xd9\x7e\x5e\x9b\xa7\x6b\xcf\x8a\x09\xa3\x3f\x4f\x9e\x30\x71\x3b\x93\xdb\x3c\xab\xef\x2d\xa3\x28\x86\x10\x59\xb8\x07\xb8\x42\x7c\x93\x2a\xc0\xf8\x58\x54\x57\x56\xa6\x16\x5c\x45\x56\x8b\x25\x02\x40\x91\x80\x2a\xdb\xb9\x22\x46\xd6\x48\xc2\x23\x56\x68\x42\xf8\x6e\x19\x4a\x95\x2a\x65\x5d\x5c\xa7\x51\x19\xd8\x8a\xda\x38\x2b\xcb\xfc\x44\xec\x29\x33\x8c\xdc\xb2\x06\x8f\xc4\x90\x69\xe9\x51\xb8\x92\x60\x1c\x06\x33\x63\xc6\xa4\xda\x1f\x96\x13\xd4\xb6\x1c\x02\x65\x50\x15\x26\xb2\x82\x7d\xe0\xdd\x17\xc4\xf8\xdc\x3b\x96\xae\x09\x2e\x80\xeb\xba\x75\xbf\xef\x69\xfb\x83\x9a\x09\xf5\xc7\x82\x9d\x86\x56\x4e\x9f\x38\x49\x9c\xf4\x43\xb8\xd7\x9d\xeb\x96\x74\x2b\xfa\xbc\x53\x35\xac\xd9\xf3\xf0\xa2\xc5\xcc\x1f\x56\xff\xf0\x83\x71\xd9\x66\x4b\xdf\xfe\xf7\x16\xb6\xcf\xf1\x1a\xc3\xc1\xf5\xe2\xdf\x1e\x2e\xed\x9c\x1f\xcc\x1e\x30\xb3\x7e\x70\x9f\xe6\x49\x03\xbb\xd1\x3c\x72\x7c\xc7\x9a\xf0\x79\x21\x7d\x2c\x26\xc5\x4c\x5c\x6e\x2e\x13\x29\xe2\x03\x01\x87\xc6\x1c\x31\x97\x94\x86\x0a\xa8\xa1\x19\xb2\xd9\xdc\x52\x21\x9f\xcd\x83\x10\x54\xa9\xf4\x12\x86\x83\x0a\xe6\x48\xb1\xb7\x54\xe3\xf9\xa4\xb1\x5e\x00\x5a\xd4\xa9\x66\x06\xe3\x2a\x33\x23\xcf\x69\xc1\x5e\x3e\x2d\x9f\xa2\xca\x58\x42\xa3\x74\xc9\x78\x74\x22\xf4\xbb\xe3\xee\x83\x07\x1b\x87\x8e\x9f\xb6\x4d\x8e\xda\x95\xa6\x85\xa7\xa5\x28\x70\x55\x88\x74\xa9\x27\x0d\xeb\x9d\xd8\x73\xc4\xbc\xde\xf8\x16\xcb\xcc\x97\xf0\x3e\x97\x82\x4e\x60\x6e\xac\x9d\x0e\x2b\x5c\x21\xcb\xe9\xf7\xf9\x2a\x8a\x8a\x3a\x66\x33\x76\xa7\x20\x74\xee\xe2\x09\xd6\xc6\x3d\x06\x23\xdd\xe0\x7c\x2c\x39\xb2\xed\x1d\x19\x36\xdf\x9f\xef\x07\x74\xbb\xad\x32\xd0\xa7\x0d\x94\xa5\xc2\x65\xd2\xe6\x53\xfc\x7c\x19\x4b\xa9\x55\xd3\xb0\xa8\x5c\x08\x23\x31\x27\x6d\x3d\xc9\x67\xa2\x4c\x66\x93\x52\x06\xb9\x1f\x0c\x29\x8b\x61\x64\xd8\xa5\x9c\x84\xea\xd3\x43\x1b\x1a\x79\x60\xe2\x9d\x5b\x66\xae\x21\x67\xe0\xf8\xf1\xf6\xbd\x3b\xd7\xf4\xff\xf3\x9f\x60\x69\xc5\xc3\xae\xc7\x97\xce\x0a\x0d\x1e\x37\xb6\x6a\xce\xda\xfa\x87\x66\x4e\x98\xde\xbe\xbc\x64\x74\x55\xd7\x22\xcb\xc4\x89\x1b\x17\x31\x2f\xe3\x63\xb0\xba\x79\xfa\xd0\x5e\x95\x0d\x6f\x93\x4a\x19\xf1\x79\xdd\x85\x2b\xaf\x6f\x9d\x34\xbc\x6f\xf6\xd2\xe9\x23\x56\xf6\x5e\xd7\xbb\x57\x69\xc7\x76\x1d\xbb\xf6\x22\x3a\x91\xf4\xa8\x9b\xc8\xbd\x8a\xe5\xc6\x84\x58\x65\x7e\x59\x99\xdf\x9f\x15\x80\x2e\x97\xc7\xad\x35\x99\x94\x4a\x77\x00\x95\x47\x73\x8b\x6a\xe3\xb9\xd0\x47\x1b\xae\x96\x85\x0d\xee\x80\x55\x6d\xa8\x8f\xab\x3d\x9c\x8d\x14\xd3\xca\x99\x8a\x72\x87\xb1\x68\xcb\x26\x75\xe9\xcf\x29\xf8\x1e\x24\xb3\x4e\x0c\x41\x69\xf3\x53\xc9\x8a\xc6\x9c\x70\xa2\x00\x34\xad\x1a\x8b\x69\x10\x98\xd0\x94\x51\x8b\x66\x8a\x4d\x9d\xba\x15\xc7\x66\x54\xf6\xeb\x37\xec\x11\xf8\xde\x23\x0b\x16\x2c\x58\xd2\xa3\xbc\xc8\xdb\xb5\x9a\xed\xb0\x67\xf8\xf0\xc6\x57\x9a\x9e\x14\xdf\x33\x1c\x36\xed\x44\xc1\x7d\xbf\xa3\x70\x5a\x6b\xa2\x4d\x7d\xd1\xe9\xd5\x8b\xee\x5d\xa9\xd9\xa8\xe8\x33\x72\xbc\x64\xc3\x10\xcc\xa9\x53\xf8\xec\x17\x93\x3e\xc9\xa8\xb8\x18\xf8\x8c\x0e\xec\x5d\xe5\xe4\x18\x01\x2a\x29\x2d\xca\xcf\xe7\x6b\xe3\xf9\x36\xa5\x0f\x58\x2c\x58\x0a\x6e\x73\x40\x87\xc3\x62\x48\x24\x67\x45\x4b\xe4\x2b\xde\x76\xf3\x46\x29\x25\xcb\xc6\xfe\x36\x2e\x89\x84\xde\x98\x63\xed\xd5\x38\x10\xdc\xd8\xba\xf3\xc1\x9b\x21\x91\x88\xd7\xde\xdf\x74\x63\x30\x77\xe9\x7a\x7d\xdd\x88\xe1\x75\x37\xc5\x1f\xe9\xb2\xfd\x89\xde\x9d\xee\x4c\xe2\xb6\xee\xc4\xbc\x29\xb0\x75\xdc\x29\xe6\xe3\xb1\xc7\x05\xd4\x02\x07\x38\x8d\x96\x53\xd2\x2a\x07\x3d\x84\x2a\x1e\xf0\xe9\x66\x40\x5b\xa1\xb4\x68\x52\xcb\x1b\xe1\xb3\x8d\x88\x69\xfe\x3d\x33\xb5\xe9\x2f\x4c\x0d\x49\x1b\xdb\xd8\xf4\xfe\x66\xf4\x54\xd3\x5f\x51\x88\xce\xd9\x00\x20\xdb\x05\xcf\xa9\xc1\x5e\xeb\xed\xb1\x0a\xb3\xc9\xc4\x73\x82\x85\xd1\xab\xec\x0e\xa7\x53\xad\xd1\xd8\xf5\x16\x8e\x73\xb9\xb1\x99\x2e\xb0\xac\xc3\xa4\xb7\x9a\xf0\x2f\xa3\xc2\xae\xd3\x59\x8c\x56\x46\x01\xd5\xe4\x91\x28\x4a\x7e\x49\xae\x11\xed\xf8\x8a\x89\x28\x91\xbe\x6f\xd5\x83\x4f\x6a\xf5\xad\x86\x61\x14\x75\x43\xf2\x1f\xca\xf8\x66\xd1\xda\xad\x3b\xd7\xbe\xb0\x64\xdd\xee\xc5\x0f\xac\x5d\x74\x21\xfd\x1b\xa4\x64\xc2\xcd\xff\xc3\xbc\xd4\xfc\x32\xd3\x9e\xfc\xbe\x56\x99\xf9\x3d\xe6\xe5\x09\xbc\x7e\x7e\xcc\x8b\x80\xfd\x9c\x1e\xb1\x10\xab\xd1\x70\x5a\xa8\x54\x02\x85\x56\x61\x30\xea\xd4\xf5\xf8\xb4\xeb\xf0\x2f\x5e\xa9\xb5\xf2\xa8\x3e\xce\xc3\xe4\x6b\x67\x75\xa2\xc9\x77\x0b\x90\x8c\xb0\x91\xb6\xa6\x4d\xfc\x66\xfd\x4f\x36\x7f\xf3\x14\xba\x4b\xfa\x8a\x3e\x23\x79\xa1\xf0\x8b\x6b\x15\xd2\x9f\x40\xba\x8f\xc3\xd8\x1c\xb6\x3f\xf6\xcc\xaa\x63\x1e\x8b\x5e\x70\xf9\x7c\x5e\xc1\xeb\x0f\xb8\xf5\x46\x4d\x7d\xdc\x68\xf0\xb1\xc4\xc2\x06\xac\x9c\x3c\x6d\xb8\x98\xee\x79\xc8\xdb\x17\x49\xe4\xa7\x51\xf7\x59\xc8\x91\xd2\x83\x93\x79\x6c\x78\xe6\xd2\x1d\xb3\x1e\xba\xdf\x51\x59\x9a\x5b\x5c\x5a\x33\x05\x1a\xe3\xd3\xef\xdc\xd0\x78\x72\x5b\xed\xd0\x13\x97\xa0\x61\xfd\xac\x8e\xee\x9d\x79\xe2\x48\xf1\xb3\x83\x73\x9e\xda\xc5\x2c\xbf\xe6\x91\xe5\x04\x17\xc3\x74\xe5\x82\x9a\x58\x90\xd0\x95\x9b\x1b\xc6\x84\xe5\xe5\x47\x02\xf5\xf1\x88\x27\x41\x5e\x06\x71\x35\x2d\xeb\xeb\xff\x3b\x75\x66\x2a\x1b\x69\xc5\x4c\xe5\x4d\xe8\x84\x3d\x07\x97\x54\x3b\x06\x74\x7d\x7c\xe7\x4d\x08\xbe\xfe\xf4\x8a\x39\x96\xfd\xf6\xb3\x6f\x61\xdf\x17\x76\x87\x5f\xa3\xad\x3c\x30\x08\xa8\x80\xb9\x0d\x50\x19\x00\x63\xf8\xdf\xb6\xf0\x2a\xbc\xc6\xbd\x62\x7a\x9f\xc7\x60\x30\x2a\x04\xc1\x6e\x44\xfe\x80\xc5\xd9\x55\x05\xfb\x80\x38\xb0\xc0\x28\xbe\x46\x46\x58\x8c\xcd\x6e\x0d\xec\xfb\x74\x1c\xa0\x33\xb0\x2c\x99\xb0\x9e\x21\xdf\xf0\x3e\xcb\x42\x2d\x9c\x96\x69\x17\x4d\xe5\x67\xc3\xd3\x79\x77\x0e\x99\x3f\x67\x71\xaf\xfa\x11\x93\x17\xbf\x58\x56\x1a\x2a\x19\xc6\xb3\xb7\x0d\xe8\xb1\x78\xbb\xc8\xc2\x4f\x67\xd7\x2f\x9d\x22\x76\x41\x83\xae\xa8\xe7\xe9\x26\xf6\x98\x45\xf3\x83\x19\x78\x0c\x3c\xc7\x1c\xa6\xfd\x96\x0d\xd8\xd3\xd5\x23\x96\x55\x02\x9d\xce\x68\xd2\xeb\x05\x28\xa8\xcf\xc0\xbe\x8d\x71\x01\x8b\xa5\xb3\x98\xda\x51\x98\xa5\xc2\xf4\x58\xd0\xd2\x92\xd4\x43\x2b\x6d\x22\x9b\x91\x39\x17\x65\xf2\x16\xd7\x0e\xa9\xf6\xe6\x57\x04\x17\x73\xc3\xe7\xcd\x6b\xca\x9b\x34\x9e\x1f\xcb\x56\x77\x41\x79\x78\xa0\x4b\x78\x6d\x72\xd9\x1f\x81\x09\x94\xc5\xd4\x6a\xce\x64\xc2\x5b\x6f\xb6\x90\xd8\x53\x9f\xa7\xe3\x9c\xf2\xf7\x78\x11\x10\x2c\xc5\xab\x58\x0c\x92\x45\xc0\xc6\x44\xde\x71\xaa\x55\x64\x32\x99\xe2\x4d\x76\x2e\x87\x7c\xfd\x7a\xd9\x3c\x9e\xc8\xc0\x41\xf0\x6b\xa6\xdf\xec\xd8\x03\xb7\xf5\x16\xe6\x0a\x9b\x96\x8a\x77\x49\xfb\x31\x05\x7e\xc8\x5c\x60\x3f\x23\xf8\xcd\xa7\xd5\x1c\x30\x99\xcc\x16\xd3\x59\x3c\x09\xe6\x58\x9a\xf5\x39\x58\x02\x58\x3a\x63\xb2\x3c\x53\xce\x20\x27\x19\xa5\xd2\x03\x5a\x02\x05\x83\x39\x4f\x66\xf4\xf4\xa7\x33\x0e\x1a\xc8\x7e\xd6\x7c\x0a\xcf\x38\xae\x2f\x9d\x11\x36\x90\xf9\xc6\x82\x73\xa8\x17\x9e\xcf\x81\x57\x56\x2d\x00\x60\xd4\x38\x1c\x4e\x97\xde\x82\x79\x3c\x19\xd7\xe8\xf5\x4a\xc7\x39\x3a\x3b\x4b\x8f\x82\x12\x56\xa4\xc3\x79\xa5\xaf\x6c\xea\x69\xb1\x33\xcc\xa0\xe1\x74\x76\x76\x8e\x27\x9a\xfd\x84\x73\x60\x1f\x9b\xc7\x97\x35\x60\x10\xfb\x59\xd3\xf1\xea\x12\xd5\x6c\xc5\x95\xbf\xd5\xf6\x4c\x92\x82\xf7\xb9\x02\xaf\xf7\xe3\x98\x16\x82\x81\x37\x22\x66\x21\x91\x05\x01\xeb\x1e\x35\x01\xc0\x13\xd4\x82\xd5\xc6\x9a\xf1\x66\x63\xb3\x0b\xb2\xa4\xd3\x09\xcb\xaa\x19\x0d\xa1\x4e\x8d\x8f\x68\x5f\x4c\x9d\x9a\x2c\x4b\x32\xe7\xa2\x55\x09\x5f\x22\x8b\xda\x1c\x45\xc9\x54\x0b\x33\x36\x35\x0b\xb0\x64\x7f\x72\xc3\xdf\x76\xfe\x6b\xcc\xe4\x1d\x4b\xc5\x8b\x8b\xce\xdc\xb7\xf3\x2c\x3a\x0e\x2b\xc5\x0b\xa6\x05\xa3\x27\xcf\x61\xae\x37\x4f\x5a\xb9\x56\xbc\x26\xe9\xcc\x3b\xe0\x37\xec\x38\x4c\xa3\x0d\xf4\x8d\xd9\x55\x4a\x85\xa0\x35\xe8\x59\x08\xb0\x67\x65\x33\xb1\x5a\x25\x67\x77\xb0\x7a\xb2\x5f\x56\xbc\x56\xa5\x8d\x26\x08\xb5\x8a\x33\x84\x2c\x42\x05\x91\xec\xe9\xfe\x71\x4a\x34\x22\x92\x20\x87\xb0\xe8\x36\xdb\xec\x55\xe4\x15\xad\x06\x62\x2a\xef\x6e\x98\xa7\x76\xaa\xf4\x6b\xef\x7e\x7d\xe1\x12\x9b\x42\x77\xdf\xea\x95\x7e\xad\x69\xe5\x02\xf8\x0d\xfc\x36\x67\x59\x69\xdf\xe6\x2f\x99\x6b\xcd\xd7\xea\xab\x3b\x31\x43\x9b\xff\xbd\xae\xcb\x00\x86\x07\x04\x36\xea\x1c\x3a\x8f\xe9\x33\x82\xf6\x31\xa3\x5e\x50\xeb\xd4\x8c\x82\x35\x99\xf1\xdf\xd4\x40\xab\x20\xab\x45\x1a\x40\x90\xd5\x02\x89\xbd\x94\xb3\x63\x93\xaf\x66\x11\xe9\x76\x54\xe1\x95\x22\xc4\xe0\xdd\x84\x5b\xca\xc2\xd5\xed\xc7\x14\x88\x1f\xae\x7e\xa0\x7b\xc9\x43\xab\xc4\xcf\xba\x2e\x3f\xa7\x18\xcb\x8e\x98\xcb\xfc\x22\x8e\x7c\x6d\x33\xfc\xbc\x99\x7b\x7c\x05\x89\xaf\xc1\xff\xa0\x01\xcc\x3b\xdc\x25\x13\x4f\x10\x8c\xf0\xf7\x56\x34\x00\x9d\xa2\xdf\x73\x64\xfd\x18\x86\x45\xcc\x6b\xb4\xc7\xb4\x3b\xa6\x56\xe2\x03\xa7\x52\x0b\x02\xf9\x7f\x35\x97\xaa\x13\x57\x95\xdc\x53\xa9\xbe\x3f\x6a\x65\x98\x48\xc1\xc2\xb1\x71\x16\x6d\x1f\xbf\xa3\xfb\xc6\xa5\x2f\xdd\x64\x0c\x85\x82\x0c\x9f\x39\x86\x55\x2a\x68\x0f\x57\x32\xaf\xd1\x31\xb8\x4b\x37\x1b\x83\x01\x4a\xa5\x4a\xcd\x30\x6d\x8c\x11\xa6\x65\xc1\x9d\x21\xf3\xc7\xf8\xd8\x85\x85\x59\xdc\xa5\x97\x96\x6e\xec\xb5\xe3\xd6\xed\x64\x8c\x6c\x76\x01\xf3\x11\xf7\x23\x3e\xaf\xae\x18\x36\x25\xc8\xb3\x92\x4e\x2f\x68\x41\xc9\xeb\xe9\xc9\x64\x92\x0d\x5b\x49\x9f\xbc\xc2\x4c\x76\x7e\x55\x55\xfe\x90\x49\x93\x86\xb0\x97\xdb\x97\x95\x55\x0d\x9d\x3c\x7c\xf8\xed\xe4\x1e\xfe\x03\x8f\xf5\x28\x1d\xcb\x1b\x53\xa9\x90\x80\x85\x9d\x4e\x0f\xf8\x33\xb0\x37\xa8\xc9\x18\x8e\x46\x11\xa3\x56\x29\xa0\xc5\x3c\x3a\x74\xe2\xc4\xa1\x64\x48\x76\xc1\x94\x61\xc3\x27\x0f\xad\x2a\x2b\x6b\x4f\xe5\x48\x3b\x7c\x97\xee\xa1\xb5\x09\x3d\x63\x3a\xb5\xc6\x06\xf8\x24\xca\x19\xb9\x43\x4a\x02\x4a\x4d\x80\xce\x94\xcf\xd3\xc3\xa0\xc7\x52\x53\x92\x63\x72\xa7\x9f\xea\x16\x4f\x1f\x30\x15\x88\x4a\x83\x1a\xb3\x32\x82\x2f\x7f\x6a\x7c\xf8\x94\x8d\xd6\x65\x96\x7b\x67\xed\x3b\xbc\x65\x0d\xfc\x1a\xde\xa6\xdd\xb1\xbe\x61\xed\x5a\xd5\x94\x39\xe7\x4f\x3d\x7c\x41\xfd\x4b\x2b\x7a\x0c\x58\x2b\xaa\xb1\x41\xc6\x62\x7a\xcc\x50\xa2\xc7\x6c\xc6\xf4\x08\x82\x56\xa2\x47\xf8\xaf\xf4\x54\xa6\xf2\x8d\x92\xe1\xbd\x2a\x23\xd3\x6b\xcd\x96\xc3\xfb\x66\xef\xb4\x2c\xb3\x6e\x9c\x32\x3c\x3e\x35\xdf\x07\xbf\xfe\x45\x7d\xe1\xe1\x93\x2f\xce\x99\xa2\x5a\xbb\xb6\x61\xfd\x0e\xad\xb8\x8f\xc4\x81\xa7\x83\x3d\xec\x40\xf6\x98\x81\x07\xfe\x9f\x29\x26\x35\xfe\x7e\x02\xfd\x3e\xa8\x21\xf7\x7c\x3e\xf8\x8e\x1d\xce\x9e\x01\x3c\xc8\x8e\x19\x11\xcb\x73\x0c\x16\xfe\x0c\xe9\x52\xc5\xf0\xf8\xbe\x97\x44\x69\x97\xff\xb4\x97\xf5\x48\x58\x09\xc3\x30\xca\x0e\x7f\x54\x3c\x29\x9e\x79\x14\xee\x39\xf2\x1d\xd2\x35\xfd\x80\x5e\x93\xe4\x46\xe6\x78\x78\x30\x96\x3c\x24\x33\x78\x3c\x0e\xdd\x64\x3c\xfa\x6e\xcc\x9c\x39\x22\x4e\x7e\x14\xf6\x81\xb7\x3c\xfa\x1d\x7a\x0d\x8f\xa7\x93\xf4\x84\x9b\x3d\x41\xfa\xf9\x91\x5e\xed\x31\x03\x81\xb1\x52\x93\x1e\xeb\x8c\x72\xcb\x28\x8e\xd9\x41\x74\x73\xaa\xda\xc7\x8a\xb5\x82\x10\xae\xac\x8a\xa2\x13\x53\x3f\x60\xbe\x9c\x22\x1e\x66\xff\x48\xba\x05\x7c\x9f\x39\x4e\x28\x66\x54\x20\x84\xaf\x23\x0b\xd9\x2d\xa3\x20\xdf\x10\x87\x3b\x40\x4d\x5a\x45\x0d\x11\x54\x89\xce\x04\xcc\xf3\x72\x2f\x02\xf6\x84\xdc\x3f\x11\xdf\x87\x62\x76\x05\xb3\x9f\xea\x69\xdb\x29\x3c\x34\xcb\x41\x86\x9e\xdf\xcb\xa9\xcf\x63\x8d\xbb\x7f\xf6\x6c\x76\x05\xec\x8f\x7f\xa0\x8e\x7d\x1b\x2d\xe0\x06\x93\x9f\x8f\xa9\xc8\x8a\x00\xb4\x35\x0e\x76\x02\xd9\x4c\x22\x2f\x03\x95\x41\xb4\xa0\xf9\x2f\x4c\x0e\xfb\xf6\x72\x89\xef\xe7\xd8\x93\x48\x8d\xe7\xe0\xc8\x3d\xc1\x8a\x01\x5f\x59\x5e\xe0\x32\xe6\x91\xcf\x87\x39\x6a\x15\xe0\x73\xab\xde\xf8\x91\x3d\x69\x81\xc8\x2b\xc9\x6f\x38\x8e\x3d\xc9\x9c\x48\x7c\x1e\x70\x1c\xc9\x98\x10\x88\x41\xd3\xf2\xf3\x98\x53\xb3\x95\x19\xfc\xe3\x1b\xab\xd8\x93\xd7\xbc\x62\xb3\x05\x48\x3c\x8a\xd3\x98\xfd\x37\x4e\x61\x9a\xcd\x32\x8f\x08\x94\xb4\x62\x50\x9c\x46\xd3\x94\xf1\x0f\x0c\x11\xbf\x45\x0b\x6f\x4c\x4f\xf1\x88\xc0\xd6\x38\xba\xb7\x05\x8f\x0b\x9b\x3f\x60\x22\xe2\xb7\x32\x8f\xe7\xc4\x69\x48\x7f\x63\x25\xa6\xd1\x95\x4e\x63\x72\x9e\x74\x02\x4f\x60\x02\xc5\x69\x09\x02\x5b\x7c\x36\xb1\x3e\xad\x3e\x2b\x2d\xce\x39\xbc\x38\xe2\xb4\xc4\xe2\x30\xf0\x3a\xfe\x72\x95\xed\x80\x7f\x5a\x00\xb9\x31\x13\x07\x21\x96\x43\xf8\x92\x22\x85\x12\xf2\xac\x95\xbc\x78\xd4\x48\x99\x81\xe9\x55\x49\x42\x38\xc7\x58\x15\xb5\x33\x57\x27\x69\x27\xe1\xff\xd8\x0e\xef\xbe\x7b\xfd\xe2\xbb\xef\x62\x5a\xae\xa3\x09\xf2\x78\x4e\xc2\x3b\x40\x08\x2f\x17\xcd\x1c\x91\xc6\xa0\x8f\x3f\xf8\xe3\xf4\xa3\xe4\x73\x44\xa6\x82\xd1\xcc\x47\xf0\xdd\xdf\x96\xa9\x91\x9b\xc8\xd4\x13\x69\x22\x95\xc8\x54\x3c\xd6\xa3\x89\xb1\x12\x32\x95\x07\x2d\xc6\xba\x89\x40\x1d\x9d\x29\x4f\x9f\x01\x4f\x20\x17\x14\xf1\xca\x04\x62\x5a\x81\xe7\xf1\xd2\x2a\x15\x3c\x56\x19\xf8\xee\x5e\x92\x5f\x55\x12\x37\x37\x88\xfd\xf6\xa8\x35\x8a\x5c\xe2\xee\xc5\xb3\x17\x3f\x31\xe3\xb3\xcf\x40\xeb\x31\x00\xfe\x2c\x5d\x59\x8e\x13\xf0\xf6\x5c\x2a\xcf\x18\x03\x86\xad\x61\xac\xb9\x82\xc8\x85\x47\x80\xb7\xc3\xed\x9f\x7d\x36\x43\x1e\xe3\x10\x72\x31\xc4\xab\xcd\x8f\x99\x55\x80\xe1\x04\x4c\x09\xd2\x68\xf1\x30\x2a\x9e\x57\x92\x8d\xae\x4e\xf8\x8b\xd5\x46\xbb\x6c\x8c\x4a\xa3\xc9\x54\xe1\x11\xc9\xa0\x81\xa5\x4b\x67\x2c\x59\x42\xc6\x2c\x86\x66\xb4\x0f\x1e\xc0\xcb\x63\x3c\x49\x8e\x28\x43\xe4\x51\xfa\xf1\xdc\xd7\xbc\x8d\x99\x05\xcd\x77\xe3\x9f\x2d\xc2\xf2\x62\x3f\x96\x17\x5a\x7c\x42\x2c\x2c\x16\x17\x48\xad\xd3\xab\x58\x80\x45\x06\x10\xf0\xed\x4d\x17\x19\x29\x95\x95\x13\x95\xca\xff\xa3\x3a\xc8\x4c\x5a\xf2\xa8\x75\xb9\x71\x58\xfd\xd0\xa1\xc6\xe5\x8e\x87\xd9\x13\x0d\xf3\x6a\x7a\xf5\xaa\xf9\xdd\x16\xe9\x7e\x21\x4e\x43\xf5\x32\x02\x15\xb1\x10\xc2\xa7\x0f\x2f\x30\x80\xd5\x06\x50\x0b\xc6\x81\x6d\x80\x2d\xc5\x7f\x1c\x00\xc7\xc1\xc7\x80\x5b\x41\x5c\xb1\x92\x31\xb3\xef\xba\x75\x4c\x49\xf2\x02\x92\xa2\x49\xf4\x32\xa7\x21\x95\x91\xe4\x4c\xcf\x65\x97\xa0\x11\xbc\x1a\xaf\x97\x1d\x8c\x8c\x75\xc1\xb2\xdd\xc4\xf3\x0e\xa7\x52\xdf\x10\xd7\x2b\xfd\x4a\xc6\x80\x94\xc4\x96\x54\x22\x64\x6d\x88\x97\xa0\x41\xe8\x4e\xf4\x11\x62\xf5\xa8\x04\xd5\xd0\x6f\x96\xa3\xfd\xe8\x05\xa4\x40\x31\x9b\xb3\x0f\x5e\xdc\x82\x31\xb3\x25\xdf\x22\xd1\xeb\x2e\x03\x01\x41\x52\x48\x42\x46\xab\xc0\xd5\x77\xce\x5a\x45\xfa\xd0\x2d\x4c\x34\x9e\xe3\x7a\x0c\x9f\x3d\x7b\x78\x7c\xe6\x9d\x23\x52\xbd\xff\x20\x7c\x56\x1c\x8a\xec\xf8\x6f\x46\xa2\x1f\x14\xd8\xd1\x06\x1a\x8e\x33\x99\x15\x0c\x26\x94\xb9\x97\x1a\x6a\x25\xc9\xf9\x12\x40\x2c\xf4\xe1\x37\x2a\xb7\xf5\xa8\x42\xf6\x9a\xfe\x53\xa7\x0d\xee\xb3\x36\x36\xb8\xac\xa8\x5d\x67\x71\x96\x7b\xf2\xd0\x1e\xab\xf3\xb2\x96\x76\xcb\x2f\x75\xd0\x7c\x59\xbc\x77\x97\xb8\xa3\xc0\x09\x4a\x62\x4e\xa5\xca\x66\x57\xd9\x5d\x6e\x9b\x4e\xc7\xe1\x7d\xd3\xe1\xfd\x33\x6f\x8d\x2b\xc9\x06\x96\x17\xb4\xde\xc2\x62\x26\x1c\xd2\xe1\xcb\x4a\x62\x73\x3e\x46\xde\x4b\xc4\xe4\x0f\xa9\x1d\x10\x76\xfa\x2c\xea\x3b\xd5\x25\xf5\x35\x85\x43\x6a\xfb\x05\x23\xb9\xaa\x59\x86\x09\xec\x89\x48\x51\xc4\x9c\x15\x1b\x77\x5b\x3b\xfc\x97\x92\x3e\x9b\x66\x4a\xef\x7e\x5e\x4c\x83\x19\x9f\x1f\x4e\xaa\x28\x55\x28\xa9\x8c\x52\x03\x25\xe2\x79\x8d\x56\xc1\x70\xcc\x96\x51\x6a\x6e\x07\x48\x4b\x92\xb5\xa7\xc5\xcc\x68\x13\xc0\x20\xfd\x0a\x37\xbe\x71\x56\x7c\x5b\x6c\x47\xbe\xb2\x27\x2c\xdf\x7b\x3f\x27\xbf\x31\x9f\x37\x3e\x87\x93\x18\x17\xd2\xe0\x33\xea\x8b\x69\x20\xd0\x68\x14\x3a\xbd\x06\x9e\xe7\x54\xf8\x58\xbb\x2e\x95\x27\xdc\x82\xb2\x52\x94\x06\xe1\x81\x04\xd7\x67\x5e\x5d\xb4\xbc\xa2\xb6\xe3\xb2\xa1\x57\xf3\x07\x32\x5f\x85\x37\xf4\xe8\x94\xbb\xa3\x02\x6a\xcc\x78\x7f\x2c\xa8\x08\x9d\xe1\xae\xd0\x7b\x67\x53\x01\x9e\x65\x39\x05\xa3\x06\xbc\x56\xa3\x50\x73\x0c\xab\x14\x90\xa4\xc4\xd3\x30\x7b\x89\x70\xcb\x11\x72\xaa\x72\xaa\xec\x55\x76\x01\x9d\x19\x71\xed\xda\x88\xeb\xd7\xe9\x57\xb4\x36\xf1\x37\xfc\x95\x9e\xd3\x00\x78\x0e\xfb\x3e\x67\xf1\xfe\xbb\x40\xef\x98\x97\x81\x36\xbd\x85\x14\xf2\x2b\x59\x8e\x53\x22\x3d\xe4\xdc\x1e\x1e\xfb\x42\xc8\xc9\x68\x9c\xd8\x60\x7a\x26\xae\x61\x19\x3c\x61\x49\x9b\x85\xfc\x89\xd5\xa2\xa1\x20\x98\x2a\x84\xaf\x4a\x56\xf2\x33\xee\xeb\xab\x5e\xfc\xd3\x2a\xb1\x59\xd5\xaf\xae\x6f\xdf\xfa\x7e\xab\xcb\xa3\x6e\x47\x39\xd3\x95\x59\x24\x32\x50\x6c\x5e\x6f\x5e\x39\xb8\x4f\x3c\xde\x67\xf0\xca\x37\x3b\xc5\xc7\x55\xfa\xc3\xf4\x8c\x02\xf8\x15\x3e\x3f\x37\xb0\xad\x50\x45\xe5\x39\x26\x0d\x5b\xde\xc2\x59\x6a\xb1\x29\x60\xf9\x33\x58\x57\xb0\xd2\x77\x88\xba\x62\x19\x95\xce\x46\x19\xa8\x91\x56\x38\x93\xfa\x51\x5b\x73\x05\xec\x74\x0d\xce\x65\xba\x8e\x18\x81\x26\x4b\xb5\xf2\xb0\x0a\xfe\x15\xed\xc2\x3e\x77\x0e\xe8\x1f\xb3\x60\x39\x1b\xb0\xb8\x5d\x2e\x0d\x76\x08\x73\xf3\x34\x01\x64\xb7\x7b\xcf\x90\x08\x84\xdb\x7e\x96\x38\xdf\x40\x45\xbe\xc1\x4b\x8b\x7d\xe2\xf4\xee\x41\x2d\xb3\xd7\x53\x08\x25\x64\xbb\x93\x8f\x0b\x19\xd6\xa3\x1f\xfa\x18\xb4\xeb\x81\xad\x2b\xf6\x3a\x67\x18\x6e\x1b\xfe\x4c\xb0\xf3\x82\xdb\x47\x45\xb7\x6d\x5c\xb4\xd5\x3c\xd3\xba\x7b\xf0\xa0\x76\x5d\x6b\x17\x0e\xaf\x60\x5e\x98\x31\x6f\xd8\x74\x5b\xe7\xea\xf9\x59\x45\xfe\x80\xa7\xdd\x80\xea\xa9\x77\x8c\x98\xa0\x9b\x1a\x6d\x97\x5b\x6e\xb2\x05\xdb\x0d\x21\x3c\xb8\xb0\xad\xfb\x0c\xf6\xc1\xd4\xa0\x26\xe6\xe4\xb1\xfe\x56\x61\x9b\x8a\x74\xba\x56\x43\x22\xaa\x05\x15\xfe\x43\xc1\x9d\xa5\xbe\x18\x5d\x28\x52\xbf\x96\x01\xf6\x9c\xdc\x41\x35\xb6\x29\xe9\x2e\x22\x88\x0a\x2e\xfe\x69\x0d\xe4\x7e\x5d\x7f\xe6\xd4\xc6\x6b\x50\x89\xed\xec\x0e\xe2\x45\xb8\x11\xde\x25\xbe\x07\x73\xc5\xad\x22\xed\x89\x92\xb0\xb3\x4d\x3c\xb3\x8a\xae\xe7\x5c\x3c\xc5\x08\x6a\xef\x38\x62\x58\x3b\x40\xc8\x0b\xd4\xde\x2c\x89\x26\x9d\x9c\x20\xcd\x4c\x46\x23\x76\x89\x4f\xc3\x4f\xb9\x5e\xeb\x32\x3e\x47\x74\x95\x0e\x20\x0e\x41\xcc\x01\x62\x59\x28\x90\x0f\x9b\xaa\x4b\x12\x77\x33\xf1\x79\x63\x54\x1a\x61\xe0\x2e\xf4\xe9\x3a\x78\x5b\xcb\x31\xb4\x1c\x99\xbc\xad\x21\xa2\xd1\x36\xc6\x60\xf6\xae\x63\x8e\xfd\x7f\x8e\x01\x87\xaf\x43\xdf\xa7\xc6\x78\x4d\x5a\x03\x06\x9b\x21\xc4\x62\x24\xd7\x35\xe5\xe8\xe5\x41\xe9\x93\xa2\x07\x7f\x70\x1d\xd7\x93\xae\xc1\x1c\xfc\xb9\x91\x68\x96\xf4\x39\x36\xb5\x76\x19\x9f\x23\xe1\x61\x34\x52\x74\xce\x84\x0b\xd1\xac\xa6\x5f\xd3\x3f\x27\x60\x9b\x5a\x87\x6d\x04\x20\x59\x50\x3c\x5e\xc5\x4c\xa2\xa5\x2b\x21\x35\x14\xc6\x63\xac\x9f\x89\x07\x81\x5b\xc4\xb9\x68\x96\xb8\x08\x8f\x93\x2f\x0e\x47\x87\x6e\xdc\x89\x7d\x86\xfc\x98\x89\xc1\x1a\x1e\xdf\x2f\x9e\x58\x67\x0a\x8e\x59\x81\x75\x63\x49\xb9\xeb\x72\x79\x46\x3a\x07\x79\x63\x21\x61\x04\x7b\x15\x3a\xf4\xc9\xf9\xf7\x8e\x6f\xdd\x72\x8f\xf8\x25\x74\x9c\x3b\x47\x65\x4c\x31\xfb\x2e\xda\xc7\x7b\xa8\x7d\x47\x56\x13\x62\x9e\x00\xa6\x0c\xad\xe0\xb9\x0c\xd1\x28\xd1\x25\x83\xbc\x52\xe5\x4f\x7e\x73\x8f\xcc\x17\xcf\xce\xc7\xe3\xb8\xb1\x49\xf8\xff\x28\x7b\x0f\xc0\xa8\xaa\xec\x7f\xfc\xde\x57\xa7\xf7\x9e\x3a\x99\x14\x48\x80\x40\x86\x34\x5a\x86\xde\x43\x40\xda\xd0\x12\x7a\x91\x8e\xf4\x16\x3a\x2a\xbd\x49\x95\xae\x34\x0b\x82\x14\x51\x9a\x0d\x14\x45\xdd\x55\x17\x97\x55\x5c\xb1\x21\x8a\x05\xdc\x55\x32\x77\xfe\xe7\xde\x37\x33\x99\x04\xdc\xef\xff\x07\x64\x4a\x78\xef\xbe\x5b\xce\x3d\xe7\x73\xce\x3d\xc5\xcd\x74\x67\x2b\xca\x09\x58\x01\x23\xaa\xad\x66\x8d\x5a\x63\xb3\x5b\x54\x2a\xa3\x68\xa5\x5a\x74\xde\x95\xbc\xc8\x38\xe3\x44\x56\x4c\x23\xf7\xc6\x3e\xe1\x9b\x4c\x37\xc7\xff\xad\xa9\xa2\xc7\x34\x75\x2a\xb7\x16\x90\x9d\x5c\x46\x58\xd1\x9d\x4c\x3c\x45\x28\x02\x27\x01\x24\x56\x09\x98\xce\xa8\x3f\x3a\x09\x16\x9a\x8c\x92\xb9\x7b\xb1\x29\xf0\xe3\x39\x3d\x0e\x4e\xae\xa8\x98\x4c\x76\x62\xf7\xa1\x43\x0f\x6b\x8b\xaa\x75\x1c\x80\x17\x44\xdb\xe2\xa4\x87\xb7\x95\x25\xfb\xac\x7e\x2e\x83\xb6\x74\xb0\x07\xd9\x79\xe8\x10\x76\x2b\x6d\x5d\x22\xbd\xf1\x97\xe1\x3f\xa1\x2d\x58\x67\x4e\x14\x80\x50\x64\x15\x34\x09\x2d\x02\xc6\x8c\x7a\x03\x47\xe6\x53\xb4\xcb\x4e\x7b\x46\x3e\xfe\xf2\xd0\x21\xf2\xad\xa4\x34\x56\xbb\x0d\x10\x24\x34\x55\x8a\x0a\x86\x28\xd0\xde\x3c\xd8\x86\x98\x5f\x98\x05\x6d\x90\x6f\x0f\x1d\x7a\x41\x19\x1c\xdc\xb0\x92\xf4\xe1\x92\xc2\x7f\x67\x18\x07\x24\x5e\x14\xe3\xd8\x79\xa3\x1a\x46\x74\x25\x2f\x8e\xda\xc4\xbf\xc0\x29\x5c\xd2\x8c\xb2\xb2\x19\xd3\xbb\xf7\x98\x56\xd1\xb4\x7e\xfd\x66\xcd\xea\xd7\x6f\x7a\xab\xfb\xf8\x09\x65\x65\xe3\xc7\x97\xd5\x2f\x2c\xac\x5f\xbf\xb8\x58\x19\xf3\x4a\x6c\xe4\xf4\x5c\xab\x9a\xba\x09\xa5\xc5\x78\xfd\x42\x8d\xa9\x6e\x82\x5f\x20\x9f\x5f\x3d\x8a\x8d\xd8\x91\x44\xbe\xb4\x21\x0e\xe4\xb2\x91\xbb\xc0\xee\xd5\x02\x7a\x34\x47\xee\xd6\x6a\xd5\x2a\x95\x4e\xc5\x53\x60\x9e\x07\xd3\x8f\x6b\x1a\xc7\x94\xb6\xbc\xec\x95\x1b\x4a\x5b\x24\xed\xe3\xdb\x8d\xb4\x4e\xcf\x37\xbf\x85\xf6\x2f\x46\xda\x87\xd5\xa5\x1c\x97\x02\x75\x50\x81\x6a\x37\x4f\xab\x0f\xb0\xd6\x79\xaa\x09\x61\x3f\x7b\x75\x1f\xbd\x4a\x3e\x0f\xd1\x17\x6c\xb4\xe1\x94\x24\x72\x4b\x79\xa5\xe3\x0e\x7f\x4f\xc6\x72\x27\xc2\x33\x60\x86\x61\xe7\xd8\xec\x76\x68\xdc\x65\x51\x23\xbb\x08\xaa\x89\x1f\xa8\x26\xd6\xef\x28\x58\x92\xaa\xb1\x12\x85\x4a\xf8\x76\x76\xcf\xd2\xf6\x29\x85\x05\xea\xfe\xda\x86\xdd\x01\x29\x95\xb6\x4d\x1e\x66\x1e\x60\x1e\x46\xc6\x02\x3e\x6a\x51\x3c\x62\x74\x73\x78\x9f\xbe\x61\x06\xd5\x0b\xf0\x3a\xee\x12\xc3\xc0\x32\xf5\xbe\xa7\x2e\x5d\x08\x51\xa4\xb4\xb6\x3f\x27\x04\x04\x71\x6d\x7f\x01\x90\x28\xad\xbc\x7c\xa5\x86\x70\xa5\xc9\x8e\x29\xfe\x15\x5f\x7f\xfd\x75\x21\x74\xf5\x6a\xd5\xc6\xab\x57\x29\x3f\xda\x06\x18\xb8\x51\x54\x06\x50\xbc\x25\xc9\x6c\xe3\xc4\xf6\x3b\x13\xcc\xc0\x3d\xf9\x46\xe4\xf6\x42\xbc\x49\xec\xfe\x31\x2e\xab\x7d\x1f\xec\x3b\xe0\x7f\x8a\xba\x1b\x7f\x1f\x15\xe6\x78\x1b\xde\xb4\x90\xdc\x16\xaf\x90\x17\x3f\xa6\xf7\x01\xdf\x6a\x14\x7e\x36\xc2\x37\x99\x7f\x98\xf0\xe0\x7d\x34\x47\x6c\x23\x32\x66\x21\xb6\x91\x3e\xb8\xec\x81\xfb\x30\x70\x4b\xd0\x5c\x1f\xe8\x27\x4d\x8e\x02\xcf\xb3\x81\xd6\x4b\x3e\xfa\x98\xbc\x08\x34\xf9\x23\xdc\xf7\x05\xdc\x27\x53\xea\x07\x9e\xc0\xb8\x9a\x80\xa5\x78\xde\xe0\xaf\x7e\x6a\xbe\x9f\xff\x22\x64\x58\x8e\xbf\x7c\x9c\x3e\xf8\xf2\x65\x46\xd7\xb7\x48\x5f\xfe\xdf\xd1\x67\x73\xc0\xc0\x25\x99\xe9\x76\x71\x7d\x76\xfa\xa9\xdb\xd5\xad\xd5\xdc\xe8\x90\x2a\x78\x69\x99\x82\x57\x3a\xc3\x7d\x0b\xd1\x76\xe0\x85\x0d\x02\x36\x15\x15\x11\x32\xcf\x31\x96\xa2\xd1\x62\x95\x0a\x94\xce\xdc\x2b\x31\x46\x18\x49\x43\xc0\x9c\xee\x44\xaf\xd3\x47\xa9\x4f\xf6\xf2\x0b\x49\xef\xd3\x13\x3f\xf9\x64\xe2\x69\x7c\xe8\xe5\xdf\x70\x82\x01\x27\xfc\x46\xdb\x0e\x55\x49\xba\x70\x57\xd9\xa7\xf4\x89\xee\x16\x4c\xc7\x44\xb7\x5a\x35\xad\x31\x2b\x00\xb9\xf3\xdb\xd5\x85\x92\x4e\xb1\x02\x60\xb2\x11\xee\xfb\x86\xdd\x67\x3f\xc9\xc8\x3f\xfe\xae\xbc\xa8\xfa\x4f\x36\x82\xfa\x2f\xe9\xaa\x6d\x23\xe4\x65\xe1\x28\xee\x2c\xfe\x0d\xc6\x52\x37\x60\x51\xab\x40\x4e\x82\xd0\x91\xb0\xa4\x11\xd4\x95\x12\xb3\x2a\x79\xd8\x06\xf2\xc7\x89\x9b\xa8\x75\xc9\xea\xc7\x9d\x99\x75\xe9\xd6\x15\xe1\x4d\xdb\xc1\x83\x36\x4c\x0d\x55\xb8\xaa\xb5\x58\x15\x36\xc9\x2a\x1a\x3b\x1f\x30\x44\xf6\x8d\x4d\xd4\x57\xc2\xde\x41\xb9\x6f\xf8\x3d\xff\xca\x7b\xe3\xff\xd8\x39\xa4\xdd\x5f\xec\x1c\xb1\xaa\xd6\xce\xa1\x63\xf8\x51\xf8\x3b\xb6\x30\x9b\x92\xf1\x38\xcf\x09\x8a\x2a\x8b\xfd\x11\x81\x86\x2d\xd4\xd0\xa2\x18\x93\x70\xe8\xb0\xe4\xe3\x7a\x4a\xfb\xd9\xb5\x1c\x16\xa8\x36\x99\x17\xb9\x16\x24\x54\xe8\xb0\x70\x50\xf2\x2d\x5c\xa8\xcc\xcd\x75\x61\x35\x4e\x07\xbd\x44\x8f\x8a\x02\x3e\x8d\x56\x6b\x00\x19\x68\xd0\x08\x95\xb2\x11\xe5\x22\x8e\xbe\x94\xa0\x6e\x68\x3e\xda\x89\xce\xa1\x3b\x48\xc5\x14\xd3\x3c\x2a\x51\x71\xec\x40\xdc\x5c\x43\x0f\x9e\xb1\xc3\x38\x5a\x37\xb4\x4b\x27\x00\x8f\x96\xad\xc2\xea\x95\xd3\x9b\x76\x6c\xdf\x7c\xd6\x13\x94\xd7\x3c\x23\x7c\x8c\xfa\x89\x0b\x98\x3e\x4e\x55\x60\x1c\x5b\x3d\xca\xb0\xfc\xf6\x7e\xc7\x85\x8f\x8f\x1c\x61\xfa\x14\xf9\x5e\x78\x1d\x3b\xc4\xd9\x8c\x57\x24\x05\x74\x88\x97\x01\x83\xab\xa8\x20\xd9\x00\x42\xb8\x7a\xb9\x98\xdf\x09\xa5\x7d\xfb\x94\xbd\xa1\xbf\xed\x17\x5e\x3f\x05\x7f\x60\x5c\x4e\xf1\x72\xf8\x92\x9c\x83\x2c\x94\x63\x1a\x8c\x46\x09\x69\x34\x92\x64\xa5\xa6\x09\xbd\x91\x49\x0f\xd3\x5b\x91\x31\x28\xf6\x1e\x5e\x31\x01\x83\x00\x61\x06\x60\x5f\x7e\x0b\xfc\x85\x3f\xbb\x43\xbb\x94\x7e\x63\x7e\xec\xde\x7f\x62\xdb\x86\xd2\x82\x94\x34\xd7\xd0\xe4\x8d\x4d\x7b\x69\xf3\x66\xf0\xc9\xc0\x97\x8b\x00\x0b\x5f\x92\x86\x44\xe5\x93\x45\x02\x09\x05\x02\xca\xa8\xb6\xf3\x8a\x7c\xaa\x9e\x23\xeb\x5f\xc8\xa7\x4b\x0f\x88\x27\x71\xdf\x43\xe4\x13\x47\xe6\x03\x0d\x2f\x14\x6f\x32\x19\x50\x37\x60\x65\x32\x80\x03\x4e\xc2\x33\x21\x50\x29\x31\xfd\x56\x21\x63\x00\xaf\x79\xf1\x06\xb1\x88\x18\x20\xf3\xaf\x5d\x25\x27\x42\xf4\x05\xd4\xca\x5a\x72\xa0\xe6\x1e\xc1\x74\x53\x02\x74\xe0\x55\x14\xe2\x57\x4a\xf8\xe1\x7b\xc4\x0a\x1b\x5d\x31\x9b\x3e\x7a\xe5\x56\xc4\x6a\x8a\x0d\x74\x93\x30\xda\x0a\x5f\x16\x2a\x51\x13\xe5\x7c\xf3\x65\x04\x74\x08\xec\xa7\x84\xae\x77\x1e\xbd\xd5\xec\x6f\x12\x31\x98\x32\x19\x17\x84\x6b\x9f\x8d\xc8\x86\x84\x80\x56\x14\x00\xc3\x01\xe6\x50\xee\xc9\xa3\xa4\x9e\xa7\xd0\x89\x8f\xd6\x5e\x30\xfb\x0b\x26\x4d\xfa\x97\x72\x3f\x39\x1e\x69\x23\x32\x47\x07\xd8\x1c\xe5\x04\x6c\x4c\x0e\x4b\x5a\xb5\x96\xe3\x99\x20\xae\x3d\x49\xd5\x4a\x54\x06\x0c\xc3\xee\x65\xaf\x38\x9d\x9c\xb8\x7a\x0d\x44\x31\xbc\x0a\x47\x3f\x4b\xfa\xca\x46\x7f\x94\xf6\xaf\x0b\xc7\x70\xba\x34\x0c\xf6\x8a\x19\xd5\x0f\xd8\x8c\x26\x13\xaf\xd1\x0a\xbc\x96\xb7\x68\x78\x5e\x36\x19\x64\xd6\x3e\xac\x7b\xb1\xb2\x37\xab\x89\xab\xe6\x16\xe1\x81\xba\x6a\x6c\x93\xa4\xe3\xc2\xb1\xe8\x46\xc1\x47\x61\x0b\xd0\x7d\x79\x02\xf6\xe5\x2b\xf0\xac\x94\x80\x3e\x62\x8f\x92\x51\xa5\x56\x60\x4b\x71\x25\x8e\xfe\xcd\xa0\xec\xf9\x94\xfc\x9d\xbe\x16\x78\xfa\x36\xcb\x68\xe3\x90\x4e\x5d\x86\xea\x46\x1b\x9f\x16\x5f\x79\x7c\x76\x8b\x76\x1d\x9b\x4e\x5f\xc9\xd6\x63\x1b\xff\x03\x1a\xc6\xf0\xad\x33\xa0\x56\xcb\x48\x13\x77\x42\x85\x59\x1c\x20\x1f\x3b\x9f\x1a\x9e\x59\x67\xf6\xa0\xbe\xfc\x0f\x07\xc6\xac\x6a\xb9\x7c\xde\x3f\x6b\xdd\x9f\xc0\xce\x54\xd5\x6a\x4d\xdc\xf9\x14\x8e\x92\x7a\x0c\x03\x0f\x63\x6d\x88\x57\xfe\xb2\x0d\x8e\xb5\x11\x77\x3e\x55\xdd\x46\xf4\x7c\x6a\x50\xdf\x41\xb3\xeb\x64\x8a\x57\xfe\x39\x6f\x79\x60\xed\xa8\x03\xac\x8d\xbb\xfc\xf7\xe8\x4d\xf1\xb2\xd2\x86\xa4\x06\x98\x05\x23\xe1\xd5\xb5\xdb\xb0\xb1\x62\xb9\xbe\x7c\xff\x9b\xbd\xca\xea\x8d\x92\x06\x5d\x10\xd3\xd7\x2f\xca\x68\x9f\xfd\xf4\x87\xd0\x46\x7f\x32\x1a\x1d\x09\x57\x56\xcb\x20\x40\x6c\x8a\x39\x39\xc6\xb5\xad\x4c\x06\x95\x52\x43\xf4\xe8\x88\x21\x1a\x87\xbb\x91\x31\x68\x17\xb3\x43\x53\x19\x04\x42\x28\x76\x97\x52\xf9\x89\x01\x2f\xf9\x68\x9c\x05\x1a\x87\x4b\x48\x39\xda\x13\x7e\x19\x28\x3b\x31\xa0\xe5\xa9\xe1\x4f\xc5\x54\x3d\xc5\xa6\xc9\x1e\x98\xc7\xf6\x84\x62\xcb\xdc\x33\xe1\xee\xdd\x09\xa4\x7c\xca\xa4\xc9\x70\xef\x20\xb8\xf7\x02\xbb\x17\x38\x0c\x2f\x61\x7a\x33\x20\x71\xaa\x26\xc6\x6e\x66\x9b\x51\x66\x7e\x67\x76\x1f\xbb\xbb\xf3\xe4\x49\x4a\xae\x24\xb2\x4c\x78\x13\xcf\x94\x96\x43\x7f\x61\xcd\x01\xcb\x0b\xa0\xad\xe1\x0d\x74\x4f\x29\xcf\x55\x1c\x58\x40\x82\xcc\x5c\x1d\xda\xc1\xfd\x0a\x57\x17\x53\x5e\x8d\x5a\x08\x3c\x96\xff\xcf\xb5\xae\xd6\x7c\xb0\xfc\xc0\x59\x64\xf8\x19\xd2\x07\x95\x87\x3f\x02\x1a\xb6\x9e\xd0\x48\x20\x57\x10\xc5\xfe\xca\x04\xd3\x14\xee\xf1\x06\xea\xf2\xa8\x7d\x9a\xf4\x89\x33\x50\xe3\x70\x17\x68\xe3\x58\xf8\x80\x32\x7e\x68\x03\x51\xb6\xc0\x81\xfc\x8e\x98\x96\x69\x9a\xcd\x62\xc5\xa5\x5c\xb1\x03\x1f\x63\xc6\x69\xd2\x87\x59\xa7\x71\xb8\x2b\xdc\x7f\x9c\xdd\x0f\xf8\x96\xa3\xf7\x8b\xa2\x0a\x53\xf6\x16\xb1\x6f\xe3\xd8\x26\x75\x46\x6c\xd3\xc7\x99\x69\xfa\x0d\x6a\x99\xc6\xe1\xce\x70\xff\x4b\xe1\x57\x81\xa3\x00\x0e\xd2\xb0\xb2\x5c\xb4\x09\x9d\x62\x97\xe6\xcf\x83\x26\xe2\x89\x5a\xa6\xa3\x4d\x29\xd4\x13\x67\x9b\x7e\x49\x31\x4d\x93\xbf\x47\x4c\xd3\xb0\x2e\x97\xc9\x27\xb8\x38\x3c\x94\xc9\x68\xca\x1b\xf9\x9a\xf2\xbc\x98\x2a\xa6\xe4\x13\x65\xdf\x9a\x69\x1f\xd0\x36\x1a\x37\x74\x52\x42\x5a\x2d\xf0\x32\xc4\x86\x1f\x99\xc9\xc2\x38\x4f\xbb\x97\xc8\xb7\xfe\x5e\x79\x6d\x67\x6c\x23\x37\x15\x5f\x39\x05\xaf\x50\xdf\x1e\xbc\x3b\xbe\x0d\x5e\x55\xab\x8d\xea\x34\x47\x2f\xcd\x68\x9b\xd7\xcb\x4f\xbe\xdd\x46\x7e\xdd\x60\xd9\x67\xc2\x75\x68\x96\x8d\x70\xb8\xea\x1e\x39\x17\x7a\x2d\x3c\x1f\x60\xcf\x2f\xa1\x9f\x51\x44\x4e\x43\xbb\x8e\xb0\x91\xf1\x6d\xa0\xee\x88\x9c\x06\x95\x91\x53\x40\xea\xc3\xc5\x34\xe9\xc3\xc4\x34\x95\xa1\x30\xb6\x4b\x0f\xe8\x78\x76\xfe\x3c\xd3\xf1\xa2\x40\x83\xb5\xe0\xfc\xff\x2d\x43\x1f\x50\xf1\x70\x78\x0b\x29\x46\x43\xc2\x4f\x03\x3d\x27\x07\x0c\x11\x9e\x21\x20\xb5\x49\xcd\xc1\x73\x06\x5e\xf1\xc7\x48\xda\x19\xa5\x68\xff\x90\x7a\x75\xa6\x0e\xea\xfb\xfa\x95\x3e\x53\x73\x87\xf5\x7b\x16\xda\xe8\x44\xda\xa0\x13\x30\x6a\x5a\x93\x38\xd5\x64\x36\x1b\x0d\x06\x41\x8d\x04\x35\x6f\x37\xeb\xd6\x05\xcd\x01\xbd\xa9\x83\xd9\x2c\x1b\x39\x79\x65\xcc\xb4\xad\x44\x8b\x62\xa7\xdf\x5c\x4d\x18\xb6\xe8\x62\x51\x7f\x73\xb9\xd0\x2f\x27\xe3\x13\xe4\xa7\x62\x6f\xa3\x8c\xf5\xcd\x3b\x24\x26\xb5\x7c\x34\x6b\xd0\x20\x42\x5e\x11\x86\x48\xbd\xeb\x64\x73\x27\x86\xf1\x8f\xb0\x7d\xd0\x8b\xd6\xe5\x00\xc9\x93\xc6\x34\x40\x24\xea\x68\x3a\xd4\x1a\x66\x74\xec\x8c\xce\xf5\x03\x36\xf4\x43\xd4\x84\xde\xa7\x4d\xbc\x09\xbd\xdd\xe2\xcc\xa8\x09\x1d\xda\x7f\x0d\xd6\xa1\x35\xf0\x99\x38\x7a\x8c\x13\xd5\xad\x97\x2e\x85\x75\x1e\x44\xf9\x09\xbc\xcf\x8c\xea\x24\x8a\xad\x54\x25\xe2\x4a\xba\x9d\x22\x08\x21\x76\xd2\x93\xcf\x74\x2f\x3c\xf3\x71\x92\xb2\x9c\xfb\x95\xf4\xb9\x7c\x19\xb4\x2f\x4a\xfb\x3b\xc8\x1a\x3c\x34\x3c\x17\xb9\x51\xc3\x80\x1d\x19\x0c\x7a\xbd\x04\x08\x5a\x96\x24\x8f\x59\xa3\xe1\x5d\x36\x3d\x6d\x0c\xf0\x53\x5e\x64\x4f\x45\xb6\x15\x3d\x56\x33\x2b\x7e\x65\x7e\xc5\x97\x2c\xf6\x06\xe3\x75\x75\x6d\x33\x68\xc0\xe0\x06\x0d\x0a\x5b\x0e\x68\x59\xd8\xa0\xc1\xe0\x01\x83\x26\x93\x1f\x32\xf3\x17\x8c\xed\xd2\xba\x53\xdb\xb6\x9d\xda\x74\x1e\xbb\x80\x3e\xfb\x34\xf4\xbf\x6d\xb8\x3f\xd0\x01\xe0\x42\xc0\x39\x00\x73\x54\xb4\xd6\xad\x84\x2b\x81\x1e\x6a\x8c\xc1\x52\xac\x80\x9c\xe8\xd9\xf0\xf0\x2b\x37\x46\x7d\x0e\x20\x87\xf4\xb9\x63\x7f\xf2\x49\x7b\x44\xb7\x80\xf6\x5a\xb2\xf6\x40\xf3\x8f\xe8\x16\xa0\x5c\x48\x1a\x89\xab\x14\xd4\xb5\x1b\xac\xa1\x5a\x14\xfa\x71\x4b\x50\x2d\x3e\x1f\x75\xe3\x0a\x19\x4b\x5b\xbc\x43\xe5\x3e\x99\x8c\xd3\xc3\xd3\x14\x1b\x3f\xe0\x71\x0a\xc7\x41\xee\x6b\x84\xda\xbb\xe1\x7f\xa0\x6e\x32\xb9\x1a\x75\xa3\xda\x6d\xd2\xc1\x02\xcc\xd7\x02\xc4\x67\x96\xb6\xf8\x36\xed\x7f\x0d\x25\x9e\x88\x21\x09\x4c\xb6\xc2\x98\x47\x02\xef\x8a\xd7\x7d\x2c\x2a\x54\x69\x53\x8c\x06\x9e\x1a\x56\x03\xeb\xc3\x74\x9f\x1d\x7f\x65\x34\xe8\xf3\x80\xea\x43\x75\x1f\xf2\x2a\xb6\x84\x9b\xfe\x15\xaf\x64\xba\x0f\x79\x35\xa2\xfb\x90\xd1\x5c\x4f\xf2\x43\x54\xf7\xa1\x9e\xf0\xfe\x9a\xba\x0f\x19\xad\xe8\x3e\x1c\xf0\xe0\x3e\xc0\x83\xb7\x33\xde\x05\x33\x43\xed\x86\x0c\x74\x56\xb2\x27\xd4\x00\x59\x62\xc4\x6a\xa8\x30\x66\xfa\xf3\x19\x33\x1a\xb2\xfe\x6d\x45\xbf\xe0\x91\x38\xf4\xa0\x2e\x48\x59\x6c\x5e\x5e\xcd\xf9\x28\xfc\x7f\x99\x8f\x5f\x6a\x4d\x07\x26\xbb\xb1\x05\x97\x03\x27\x8f\xcc\x45\x6d\x3d\xb0\x3c\xd4\x8a\x3b\x8b\x2d\xab\xd9\x5c\x3c\x87\x13\xb9\xde\x78\xcb\x5f\x5c\xcb\xf5\xbe\xdf\x47\x38\x88\x13\xe7\xb2\x31\xa0\xf0\x4d\x0e\xf1\x5f\x29\xd7\x72\x02\x3d\xf5\x79\x4f\xb9\x56\x8d\xb3\x00\x85\x57\x0d\x1d\xca\xef\xe0\x17\x56\x0d\x19\xcc\x3f\x4d\xaf\xff\x26\xfc\x2f\x9c\x22\x7e\x1b\xbd\x9e\xce\x73\xec\x7a\x1f\xc6\x29\xa4\xef\x5a\x7c\x50\xfc\xf6\x8f\xdf\x25\x0d\xe3\x2f\x7b\x49\x29\x1a\x10\xbe\x0c\x34\x48\x6d\x2e\x1a\x0d\x10\x9f\x81\xee\xf3\xf7\xab\x67\x86\xaf\x71\xfa\x3d\x30\x7a\xf8\x4d\xf6\x56\x9f\x7e\xc7\xf3\x1f\x90\x36\x22\xa2\x5a\x82\x80\x2b\x99\x49\x24\xa2\xa0\xe4\xc5\x5b\x44\xf0\xcc\x1a\x16\x11\x2e\xdc\x06\xf8\xdc\xab\xe1\xab\x6c\xcd\x3d\x01\xd8\x56\x32\xb4\x20\x2b\x36\x95\x2b\xd5\xf7\xd3\xf0\x46\x3e\xdf\x67\x7f\x95\x2c\xc7\x33\xca\x5f\x81\xdb\x67\x90\x6f\x5f\x79\x45\x59\xef\x3d\x64\x23\x1e\x14\x5e\x08\xeb\x0d\xfc\x8b\x95\x18\x42\x4e\xa7\x56\xe7\x32\xc3\x07\x1d\xa7\x56\xdb\xa8\x82\x09\x43\x7a\x2f\xc2\xc1\xe8\x5b\x84\x7f\x59\x95\x24\xad\x4c\xd7\xf4\x31\x27\x4a\x25\x7c\xac\xca\xdc\xa9\xb0\xd9\x80\x66\x85\x9d\xcc\x43\xf4\xfd\x4a\x27\x16\xa7\x96\x16\x94\x96\xeb\xc9\x67\x9d\x28\xef\xea\x54\xda\xaf\xbf\xbf\x4e\xbf\x52\x3a\x8f\x19\xc2\x64\xf4\x99\x94\xc1\xf0\x88\x53\xe4\x54\x5a\x81\x9e\xd9\xe9\x34\x54\x0d\xac\x7d\x60\x17\x55\x3f\x2d\x4e\xfa\xe4\xb8\x33\xbb\xcf\xfa\x2c\x5e\xd4\x7b\xd1\xe2\x3e\x8b\x17\xf7\x5e\x2c\xbc\xdd\x6b\xe9\x92\x47\x96\x2c\xe9\xb5\x64\xf1\x23\x8b\x15\xbd\xed\x29\x61\x2c\x1a\x2d\x3d\x8e\x5c\x94\xa7\xd9\xf4\x7a\xc1\xac\xa2\x15\x1d\xdd\x36\x95\xd9\x24\x0a\x6c\xa2\x8a\xa3\xad\xc7\xc0\xb6\x01\xcb\xf9\x34\x81\x08\x3b\x80\x2a\xb4\x53\xc1\x93\xcc\x8d\xce\x2d\x7b\xa4\x5e\xa3\x24\x5f\x52\xf9\x94\xfa\x0d\xe1\x4d\xd4\x34\x2a\x49\xd7\x74\x95\x32\xb3\x9d\x8d\xf2\x9b\xa5\xb5\x29\xd5\x77\x51\xa5\xd7\x73\xe5\xe5\x37\x85\xfd\x18\x3a\x22\xe9\xb8\x5e\x72\xc3\xe8\x7e\xa4\x45\x7f\x79\xa4\x12\xa4\x4a\x5c\xcd\xa9\x62\x07\xa6\x5e\x7b\x06\xdd\xd0\x47\x84\x83\x94\x8c\x25\xdd\x88\x11\x67\x47\x8c\x50\xd6\xe7\x98\x70\x28\x7c\x47\xbc\x08\x98\x17\xb0\x2b\x4d\x68\x01\x4b\x84\x2a\x79\xd0\x9c\x3c\x71\xf0\x9e\x07\x25\x83\xcf\xdf\xfa\xf8\x8c\x37\xc4\x8b\xe4\xae\x0e\xab\x69\x3e\x2e\x64\x11\x0e\xe1\x52\x76\xaf\x3b\xa0\x11\xd9\xa1\x4a\xcd\x5b\x29\x62\xb6\xf3\xbe\x7c\x2b\x2e\x7d\x63\xc6\xe3\xe2\x45\x23\xf9\x8f\x0e\xeb\xd8\x73\xf7\x81\xfe\x39\x50\x7c\x8d\xc6\x49\x07\xcc\x16\xaa\xa3\x3b\x4c\x80\x9c\x45\xad\xd6\x5a\xa9\xa6\x4d\x5c\xc9\x83\x0d\xe8\x8f\xa0\x76\x26\x5b\xa3\xcc\xc0\x52\xcd\x0b\x56\x64\xb7\x6f\xd9\x32\x23\xd7\xaf\x1e\x9e\xf4\x7c\xbd\x8e\x6d\x5a\xa6\xf7\x37\x8e\x30\x8e\x16\xce\xa4\x64\xa4\x34\x2e\xc6\x1c\xbc\x8d\x5b\x3e\x8b\xad\xd3\x76\x81\x47\xc3\xff\x1f\xf4\xb1\xe1\xb5\x21\x3a\xe2\xc9\x61\xe1\x2a\x7e\x44\xfc\x0a\xc6\xab\x86\xbd\x99\x17\x70\xc0\xfd\x00\x93\x25\x8d\x5e\x2d\xe9\x25\x83\x56\x96\x35\x74\x02\x28\xca\xf5\x47\x40\x6e\xb5\x09\x40\x69\x9e\x4d\x46\x04\xdd\x1d\x7d\x6d\xea\x22\x72\x70\x13\x9e\xb3\x49\xfc\xca\x48\xee\xeb\xb0\x8a\xdc\x3e\x72\x84\x19\x75\x70\x18\xb6\x11\xda\x0a\xba\x93\x8e\xf2\x00\x9d\xa4\xd5\xea\x79\x55\xa5\x0e\x9a\xae\x86\xa1\xce\x38\x6f\x5b\x7f\x0b\xbb\xcb\xe0\xad\x97\xb9\x6a\x71\x95\xd7\x29\x4d\xd4\x6e\x5e\xc7\xf4\x99\x8f\x40\x9f\x49\x8b\xd8\x44\x41\x97\x12\x41\x99\x92\x2b\xa9\x49\x33\xde\x42\xf1\x20\xfe\x10\x3e\x8a\xe0\x0f\x8e\xe8\x61\x3b\xff\x1c\x9e\x17\xa3\x33\x4e\xc0\x1c\x56\x89\x42\x25\x93\x16\x35\xf9\x3e\x34\x42\x7f\x88\x9e\xff\xaa\x2a\x89\xff\xea\xf6\x98\x31\xaf\x8d\x19\x03\x7c\xa4\x3d\x8c\xe5\x2c\xc3\x4b\x8c\x8f\xc0\xb6\x10\xa0\x89\x98\x6d\x36\xca\x47\xa2\xe6\x0a\xff\xd2\xa5\xbf\x28\x18\x8a\xec\xa1\x38\x2a\x9c\x0f\xf7\xbf\x5b\xc3\x96\x2c\xf2\x40\xe7\x74\x9a\x95\xa7\x83\x46\xc7\x6c\xd0\xef\x32\x13\x74\x90\x5a\xa0\x99\xac\x11\xa6\xe2\x91\xe2\x1f\xc8\x83\x06\x06\x1a\x20\x9d\x47\x67\x70\xe9\xdd\x6e\x8f\x07\xe6\xd2\x22\x58\xac\x56\xc0\x63\x09\x5a\xd8\xb9\x06\x5e\xe7\x76\x8b\x26\x87\x43\xd4\x51\x96\x64\xa9\x14\xa3\x04\x98\x97\xcb\x48\xd0\x4f\x8b\x68\x9b\x8b\xa3\xfb\x21\x52\xf7\x31\x52\x35\x0c\x3a\xae\x70\x28\x9a\x9a\x0f\x18\x86\x43\x21\x4d\x56\x2e\xbe\xac\x4e\xd2\x50\x2b\x93\x53\x2d\xba\x35\x1f\xdc\x3c\xdb\xcd\x24\x55\xaf\xa6\xdd\x9b\x0f\x16\x5d\xd6\x59\x20\xac\x1a\x8e\x2d\x18\x6b\x9b\xb5\x61\x46\xa3\x71\x85\x8c\xc6\x36\x0b\x43\xf0\x68\x99\x63\x35\x12\x53\x51\xab\x40\x72\x4a\x62\x62\xb2\xdb\xad\xb6\x3b\x1c\xb0\x47\xbc\xa2\x5e\x6f\xb7\x80\x5a\x6b\x87\xbf\x49\x29\x1e\x77\x84\xc1\xe4\x46\xfb\x59\x03\x04\x3e\x1c\x53\x30\x0c\x24\x46\xce\x09\x9e\xce\xe9\xde\xa5\x6d\x4a\x61\x9e\x7a\x94\xb6\x61\x8f\x92\x7a\x3d\x3a\xb7\x49\x2e\xc8\x53\x8d\x31\x0f\x27\x47\x8e\x1f\x3f\x2e\x16\xa6\x66\x01\xa5\x06\x07\x16\x78\xb3\xbc\x85\x79\x0b\x1e\xfd\xf8\xc8\x11\x7c\x17\x28\x94\x23\x3b\x85\x0b\x78\xa2\xf4\x32\xf4\xb3\x11\x6a\x1f\xf0\x7a\xd3\xd2\xd4\x0d\x72\x95\x4e\xe6\x25\x67\x66\xe6\xa6\xe5\xb8\xdd\x69\x69\xd0\x5d\x87\x1a\xfa\xab\xde\x40\x53\xcc\xe5\x99\x94\x39\x85\x6e\xb2\x4f\xb1\x63\x9e\x3c\xf3\xff\xe8\x2a\xff\xd0\xdf\xee\xff\xab\x8e\xf7\xfa\xab\xff\x10\x2e\xd4\x1a\x0c\x56\xd5\xfa\x05\xa5\x99\x3b\x40\x77\xe6\xf0\x69\x05\xa3\x52\x0f\x0f\x35\x30\x54\x51\xc3\xcb\xb2\x80\xd5\x92\x32\xdd\x51\x8b\x55\xa4\xdb\xa2\x0c\xc2\x2f\xab\xd0\xee\xcf\xc7\xe6\x4d\xbf\x6f\xda\xf4\xfb\xef\xc7\x2a\x2b\x8f\xbd\x30\x6d\x9a\x62\x03\xe9\x83\x8e\x82\xce\x26\x51\x9d\x5a\xa2\xee\xa3\x02\x27\x8b\xf4\x3c\x18\x40\x40\x94\x47\x44\xac\xaa\xf9\xbe\x42\xd0\xab\x9b\x4e\x3b\x7a\x74\x0e\xe9\xf3\xd3\xea\xd5\x3f\x21\x57\xc8\x01\xb7\xdc\x62\xe7\x2f\x6a\x96\x0f\x91\xd6\x16\xaf\x8f\xf2\x51\x73\xd4\x16\x75\x46\xdd\x51\x10\x0d\x46\xa3\xd1\x24\x34\x13\x2d\x40\x8f\xa3\xb5\x68\x0b\xda\x81\x76\xa3\x67\x71\xb3\xc0\xb3\x5b\x3b\x3c\xf3\xcc\xde\xc9\xd3\xc6\x2c\x5c\x38\x7e\x69\xbb\x3d\x3d\xd6\xad\xeb\xbd\xa9\xe0\x89\x27\x9a\xac\x92\x77\x36\x98\x35\x2b\x6f\x9e\x63\xc8\x10\xcf\x08\xe9\x69\x43\xbf\x7e\x96\x41\xc9\x2d\x5a\xa4\xb5\xca\xcc\xe6\xbb\x76\xcd\x6e\x35\xe8\xe9\x11\xf3\x76\xae\xda\xb4\x67\xe9\x34\x7d\x97\x6d\x1d\xf7\x6a\x71\x37\xa4\xe9\xc6\x77\xd9\xdb\xe5\x80\x76\xdb\x33\x73\x2a\xcb\xf6\x0d\x5b\xb1\x62\xd4\x9a\x01\x1b\x36\x54\x6c\x0e\x2c\x5e\xdc\x66\x79\x9d\xc7\x1e\xab\x37\x23\x75\xec\xd8\xf4\x89\xa6\x9e\x3d\x6d\x7d\x71\x47\x57\x51\x51\x62\xb3\x86\x8d\x2b\xf7\xad\xd9\xbc\x7c\xc6\xc4\xbe\x1d\x9b\x35\x6e\xdc\xac\x63\xdf\x89\x33\x96\x6f\x5e\xb3\xaf\x52\xdb\x69\x57\xe9\x33\xcf\xec\xec\xba\x57\xb7\x5d\xe6\xdb\xb7\x57\x09\x9d\xa8\xfc\xa7\x44\xf0\x56\x5e\xe4\x83\x12\x11\x1f\xfd\x13\x13\x9c\xf1\x91\x73\x0f\x7b\x31\xfb\x4d\x6f\x28\xdc\x28\xe2\x2c\x14\x2d\x91\x5e\xf3\xa2\xff\xf9\x39\x1a\xbf\xc2\x6c\x1b\x14\xc7\x52\x67\xce\x0c\x9b\x2f\x2d\xbf\xb1\x3f\x2f\x2b\xf2\x6e\x8d\xbc\x3b\x23\xef\x38\xf2\x2e\xd7\xfa\x4e\x3d\xee\x80\xa7\x32\x5b\x0b\xfe\x3f\xae\xad\xfd\x3d\xa3\xd6\xb3\xa2\xcf\xce\x80\xfe\x50\x40\x2a\x52\xcc\xe6\xe7\x6e\x8d\xbb\x81\xbb\x86\x5e\xa3\xae\x0e\x5c\xeb\x71\xe3\xc8\xda\xc6\x45\x45\x8d\x37\x36\x2e\x2e\x6e\xfc\x47\x61\x41\x51\x7e\x3a\xfd\x4a\x00\x62\x14\x16\x3c\x5f\x94\x9f\x5f\xc4\xf5\x2e\x2c\x28\x28\xac\x5a\x7c\x63\x1c\xee\x2a\x2c\x23\xc7\x6e\x8c\xab\x52\x17\xc0\x1f\xee\x09\xfa\xba\x29\xbf\xa8\x28\x3f\x74\x30\xbf\xa8\xa0\xd0\x47\xbf\xe3\x77\xe8\x8d\x24\x48\xef\xf9\x83\xde\xbe\x89\xfe\x96\xac\x19\x37\x8e\x4f\xa7\x4f\x0c\xbd\x4a\x8e\x8d\xbb\x21\x2c\xba\x3e\x6e\xdc\xb8\xaa\x29\xb8\x74\x3d\x5c\x57\x0f\x7e\xc8\x87\xd0\xce\xd7\xf0\x01\x6f\x82\x0f\xfd\xe0\x43\x68\x32\x7d\xf8\xfd\xeb\xb8\xe3\x9f\x8d\xc7\x5d\xe7\x3e\x2d\xf0\x37\x09\xb5\xc8\xcf\x2f\xdc\xda\xb8\x71\x31\x97\x1a\xb9\x3a\x14\x2e\x2c\xcc\xff\x06\x2e\x24\x1f\x15\x35\x2e\xce\x86\xff\x86\x36\xab\xa6\x8c\x1b\x87\x3b\x5e\x57\xb0\xd6\x63\xc2\x5c\xb4\x52\xf2\x46\xcf\xc9\x39\x50\x42\x91\x4c\xcf\xc9\x25\x2e\x7a\x4e\x1e\x77\x8a\xa0\x9c\x93\xaf\xa4\xc7\xe4\xe2\x8c\xc8\x39\x39\x60\x6b\x61\x06\x1a\xc0\x7c\xec\xed\x27\xa9\x3b\x28\x32\x28\xce\xa0\x31\x04\x50\xc3\xd2\x36\xe0\xe1\xae\xf5\xcc\xbe\xfd\x31\x4e\x97\x96\x32\xfb\x76\x41\xc0\x6d\x36\x18\xa8\xaa\x68\x01\x8d\xd1\x22\x68\xb5\x46\x64\x30\xae\xe9\x2f\x23\xc3\x6e\xc0\x17\x79\xd1\xf4\x20\xd5\x20\xb3\xf8\x41\x63\x34\xb5\xf9\xd4\xd0\x22\x93\x8f\x4b\x4b\xa3\x8a\x24\xe9\xa6\x9c\xf5\x00\xa6\x25\xad\xd0\x67\xe1\x7b\xcc\x73\xce\xa9\xa5\xbe\x72\x48\x90\xa4\x6a\x4c\xcb\x63\xb5\xfc\x00\xa6\x8d\xb8\xba\xfd\x15\xac\x25\x4f\xc5\xc3\x5a\x98\x67\xd2\x1b\xad\x64\xfe\x08\xd4\x0e\xa8\xf8\x34\xd4\x74\x69\x88\xc9\x7c\xa7\xe2\xd1\xb0\x32\xde\xa1\x41\x59\xab\x58\x1b\x54\x5b\x64\x2e\x0d\x35\x3d\x1a\x14\x0e\x4a\x5b\xa8\x5e\xa7\xa8\x3b\x03\xcc\xef\x77\xa4\x37\x7e\x8e\xdd\xaf\x47\x1d\x02\x5e\xbd\x4e\xad\x96\xe9\x79\x2a\xd2\x72\x2a\x59\x36\x42\x6f\x0c\xd0\x9e\xac\x16\x68\x39\x27\x9d\xd2\x6c\x31\x75\xac\xc9\xf3\xc7\xd3\x81\xa5\x46\x36\xf0\xc8\xb3\x22\xee\x1c\x98\x3e\x92\x7b\x53\xe9\x75\xe4\xd1\x64\x3f\x73\xed\xc0\xe1\x7d\x40\x27\x03\x19\x9d\x28\x3a\x18\x50\x89\x41\x71\x41\xfe\x0b\x1d\x6c\xc0\xc3\x82\x3a\x30\xba\x27\x3c\x8b\x8f\x89\xc3\x61\xbd\x1c\xd4\x97\x19\xe9\xd4\xfc\xda\xfe\x14\xe0\xe6\x44\x0e\xf3\xac\xcc\x46\xa7\x78\xe7\xdd\x2b\xca\xca\x2a\x2a\xce\xcc\x2a\x12\x25\xe5\x9d\xf9\x1d\x87\x5b\xc2\x5c\x9e\x0d\xbf\x8e\x0c\xa8\x65\xc0\x6b\xa0\x52\x44\x27\xf0\x3a\xbd\x5a\x25\x69\x38\x0d\x67\xc4\x5a\x5e\x8d\x74\x92\x5a\xc7\x6b\xb5\xb2\x68\xa0\x96\xca\xe2\xdc\x58\xea\x06\x26\x5f\x9c\xc5\x31\xc3\x2d\xac\xbd\x33\x4a\x07\x59\xfe\xd4\x25\xee\x55\x03\x5b\x77\x2e\x6d\x35\x68\x85\x7b\xa9\xfa\x91\x77\xfc\x9d\x33\x66\xd5\x9d\x3f\xaf\xee\xcc\x8c\x2e\xf9\xab\x28\x1e\x39\xc7\x6c\x40\xaf\x21\x2b\xab\x8a\xd8\x2c\x90\x20\x1a\x33\x33\x3d\x1e\x4d\x2a\x42\x36\x8d\xa6\x9e\x2f\x29\x49\x5f\xd7\xe9\xa4\xf5\xc3\x8d\x51\x2f\x88\xbc\xd8\x93\xe3\xcc\x51\xc5\x11\xbf\x93\xac\x98\x5d\xd2\x49\xc7\x2d\xc6\x95\xda\x13\xe3\xec\x94\xb8\xed\xe8\xd2\xa0\xdf\x1f\xec\x36\x6a\x74\x69\xbf\xbc\xbc\x7e\xdd\x46\x85\x2e\x35\xaf\x57\xaf\x69\xd3\x7a\xf5\x9a\xe3\x5b\xd1\x4f\xbf\x97\x0e\xef\xd8\x71\x78\x69\xe9\xf0\x0e\x1d\x86\x97\xfa\x0b\xe0\xd7\xcd\x0b\xfc\x91\x77\x98\xb7\x22\x61\x24\xba\x24\x35\x8e\x20\x57\x81\x1e\xa3\xaa\x04\x59\xa6\xdc\xe2\x4a\xdc\xb1\x13\xac\x01\xef\x2b\xf4\x5a\xfd\xf2\xa5\xf2\x49\x81\x30\x82\x17\x71\x01\xf9\xe6\x18\xf6\x1c\x53\x68\xf9\x11\xd2\x47\x5c\x1a\x7e\x07\xd6\x30\x25\x60\xd0\x02\x1c\x00\x25\x92\x53\xad\x0e\xb2\x0d\x91\x77\x25\xa7\x9a\x24\x44\xce\x9b\xca\xfb\x69\xc4\x73\x7a\xa1\xb8\xf4\xfb\xd0\x07\xa1\xab\xdf\x2f\x19\x84\x3b\xdd\xbe\x8d\x3b\x0f\x2a\x20\x2b\xf1\x94\x85\xd3\xa6\x2d\x64\x6d\x0a\xe7\xc4\xa5\x52\x1e\xb4\x99\x1e\x30\x69\x59\x93\xb0\x49\x02\xac\x59\x1a\xfd\xc0\x3c\x3b\xf2\xaa\xd5\xa8\xff\xd5\xb0\x94\x57\xdd\x32\x6b\x5b\x4c\xe2\x77\x88\xd4\x56\x63\x0f\xa8\x69\x80\x02\xe6\x56\x07\x01\x2f\x47\x49\x8e\xf9\x73\xef\xb8\x7f\x42\xe8\x24\x26\xcd\x67\xe3\xfb\x84\xdf\x11\xee\x55\x7d\x3d\x8b\x4f\x78\xd8\xf5\xe4\x13\x76\xbd\xf0\xba\xb8\x44\x0c\x03\x1a\xc9\x0c\x98\xec\xb0\x29\xb5\x0e\x2b\xcf\x6b\x65\x83\x01\x55\x6a\xa9\x8a\x52\x5c\x4b\x75\x63\xc1\x80\x19\xe9\x11\x4e\x47\x75\x78\x18\x48\xa1\xb8\xa4\xfe\xf1\xa5\x5b\xc8\xf7\xe4\xbb\x55\x83\x1e\x4b\x5e\x52\xff\xe2\xec\xe0\x7b\x6b\xb1\xf1\xd0\xd6\x62\x31\xbc\xeb\xa9\xde\xbd\x7a\x0e\xd8\xb0\xb7\x4e\xfd\xde\x2f\x2a\x63\x82\x67\x2e\x95\x0a\x60\xbe\xa8\xe5\x5c\xab\x95\x64\x59\xc7\xab\x99\x59\x2e\xde\x2a\x87\x33\xe1\x29\x02\xe8\x88\xde\x54\xab\x08\x0a\xc4\xcb\xb7\x6f\x93\x13\x83\x96\xdc\xe2\x1a\x72\xb9\xb7\x84\xd7\xe9\x1c\xe1\x29\x64\x65\x6c\x5d\xf9\xab\x80\xf5\x18\x8f\x92\xa8\x81\x56\x90\xe9\x61\x93\x54\xe3\xbc\x28\x8f\x21\x3c\x9a\xc1\x86\xbf\xba\xa9\xca\xc3\x7f\x03\xf0\x6e\xec\x34\xca\xa3\x4e\xe1\xeb\x78\xb1\xf0\x1b\xf2\xa1\x5c\x54\x11\x30\x1b\x8c\x46\x1b\x5f\x37\x55\xa5\xb2\xd9\xea\xf3\x7c\x43\x29\x9b\x06\x35\x69\x82\x5e\xc9\x20\x19\x90\xd9\xac\x55\xbc\x62\xcd\xb8\xd1\x31\x57\x3a\x4a\x67\x3e\xac\x49\x88\x05\x06\xe6\xd5\x4a\x3d\x58\x1c\x23\x29\x73\x35\x3a\x64\xdb\xa6\x04\x47\xf3\x00\x15\x78\x59\x62\xde\x58\x2e\x57\x1a\xf5\x99\xc5\x72\x47\xc8\xcc\x90\x3d\x7a\xe2\x84\xad\xfb\xf6\x77\xed\xde\xbd\x8b\x5c\x99\x8a\xe5\x27\x56\x26\xd6\xb1\x3a\xfc\xf5\xda\x35\x15\x85\xdc\x99\x81\x56\xa3\x9b\x2f\x9d\x3b\xa4\x25\xbe\x3e\x73\xcc\x8c\x79\x3c\x9f\x5d\x5e\xda\xa4\x44\xf7\xfe\xe2\xb9\xe4\x54\x71\xb1\xd8\x4d\xdb\xa5\x6b\xef\x4e\xe5\x81\x71\xcd\x5a\x70\x7c\xb7\xee\x25\xad\x61\xac\xaf\xc2\x58\x3b\xc1\x58\xad\xa0\x4d\x05\x03\x06\x98\x7e\x9b\xd5\x03\xdf\xf4\xfa\x04\x0f\xa2\x03\x35\x04\x3d\xd4\x89\x5e\xf2\x48\x1e\x8d\xc9\xe4\x6c\xa9\x61\xa3\x35\xe1\x46\x48\x83\x78\xf6\x59\x43\x3d\x74\x6b\x56\x47\xab\x31\x4e\x3a\x48\x5b\x75\x1d\x7d\xc6\x25\x52\xcd\xf6\x2c\x45\x44\xbe\x3e\x7a\x58\x59\x85\xf9\xd1\x94\xed\x93\xf6\x1d\x3a\xb4\x0b\xb7\x99\xa7\x1d\x3c\x30\x38\x52\xe4\xbb\x2e\x5e\xd5\xca\x9f\xda\x3f\x78\xe9\xd2\x6b\xef\x90\x47\xcd\x83\x67\x8e\x9f\x39\x1e\x74\xce\x37\xf0\x2d\xd4\x5c\x42\x4c\xe7\x6c\x70\x92\x16\xd1\x13\x04\x95\xd8\x52\x8d\x1b\xb2\xc8\x59\x1a\x50\xa0\x44\x0a\xe7\x45\x72\xb0\xc7\xf1\x75\xaa\x1b\x41\x97\x9a\xcd\x9c\x39\x53\x5c\x36\x73\x66\xd5\x50\xee\x7e\x48\x84\x39\x38\x06\x73\xd0\x06\xe6\x40\x0d\x94\x9f\x17\x50\x83\xcc\x35\x89\xa2\x43\xd6\x47\xc6\x2a\xc3\x58\x39\x64\x65\x9f\xb9\xea\xb1\x56\xd3\xa6\x89\xa6\x3c\xa1\xf9\xf1\xe2\x4f\x64\x70\x1b\x72\x7c\xeb\x61\xdc\xe9\xc8\xb6\xca\xfe\x63\xc6\x56\x0c\x1a\x31\xbe\x9c\x1f\x45\x1e\x7b\xfd\x32\x7e\xf2\xcd\xb7\x9e\x5e\xbd\x6e\xdb\xa6\xcd\xeb\x41\x2f\xf9\x07\x3c\x3b\x4b\xf8\x1a\x9e\x5c\x1c\xd0\xeb\x55\xf4\x54\xc3\x6e\x77\x18\x74\x2a\x3b\x1b\x93\x39\x12\xd0\x69\x86\xe7\xea\x94\x98\xb9\x48\x54\x67\x6c\x82\x61\x60\xd5\xc5\x5b\xa2\x51\xc2\x99\xf9\xe6\xe7\x5b\x81\xa4\x9a\x25\x3c\x26\x70\xd9\xe3\x7b\xce\x1e\x2f\x7c\x4d\x12\xc7\xf7\x9a\x35\x05\xbf\x12\x3a\xb0\x77\x61\x97\x36\xf3\x57\xe1\x2a\x78\xfe\x7b\xf0\xfc\x4c\xe1\x2e\x72\xa2\x76\x01\x8b\xd5\x62\xa1\x86\x3c\x9d\xce\x25\x5a\x45\xab\xda\x68\xb4\x47\xa6\xc0\x08\x53\xa0\x86\xc1\x77\x64\x71\xc2\xb5\x97\x3b\xce\xad\x0f\x3a\x63\xaa\xb9\xd2\x51\x37\xec\x63\xaf\xb4\xea\xad\x9d\x63\x78\x6a\xfa\xe6\xfd\xbb\xb7\x4d\x5e\x6f\x9b\xe7\x78\x7c\x48\x6f\x7e\x2c\xf9\xb8\x63\x17\xd5\xb8\x25\x97\xdf\x38\xfb\xde\x8c\xb1\x9a\x27\x96\xd3\xfd\x77\x09\xfa\xd4\x04\xd6\x98\xd6\x69\xee\x1c\x30\x38\x92\x8c\x46\xa0\x3c\x49\xf2\x01\x16\xb2\xb5\x34\xc2\x34\x18\x61\x79\x55\x28\x35\xe2\x9c\x4e\xbd\xc5\x3d\x11\xd7\xf4\xdc\xea\xac\x25\x25\x96\xe2\xb8\x69\xa2\xe2\x20\x52\xa8\x82\x95\x87\xcd\x67\xa5\x6d\x69\x9a\xa3\xf8\xb2\xb0\xaf\xfa\x26\xf4\x5c\xb1\x10\x1b\x7a\x4e\xf0\x61\x3c\x4b\x98\x2a\x91\xc7\xbb\x0f\x1c\x35\x68\xd0\xc8\x01\x8f\x70\xc3\x3b\x95\x5c\x7c\x0b\xaf\x0e\xb4\x75\x96\xe0\x66\x55\xcb\x86\x17\x65\x77\xc7\xfc\xee\xc7\x37\xed\x78\x6a\xe5\x0a\x66\x97\xf8\x12\xdf\xc2\xf5\x59\xbf\x8b\x03\x1a\x95\xec\x30\xc9\x26\xb3\xd9\x69\x39\x85\xf3\x8e\x39\x78\x95\xf9\x6c\x34\xca\x9e\x75\xb4\x51\x2c\x40\xb7\xa4\xc6\x5a\x3e\x18\x62\x0f\xdd\x94\x0f\xc4\x45\xd6\xcf\x7e\x20\xa8\x5e\x70\x90\x9f\x59\x40\x3d\x26\x2e\xe8\xc3\x77\x40\xcb\x34\x9b\xb3\xc5\x91\x01\x2a\x7a\x52\xa2\x41\x95\x08\x74\x95\xe9\x15\x2c\x02\xe3\x4e\x2e\xe8\x52\xa3\xe3\x76\x83\x41\xad\x3d\x85\x1b\xbe\x94\x84\xd4\x91\x30\xe6\x12\xca\x92\x22\xd1\x19\xb1\x3e\x45\x4e\x6c\xf8\xb8\x04\x26\x71\xc5\x75\x0a\x6a\xf6\xb6\x69\x51\x69\xe9\x80\x59\xfc\x14\x91\xcb\x1c\xde\xa5\xe7\x60\x1b\xd7\x7a\xfb\xc4\xe1\x33\x8b\xba\x95\xf6\x87\x7e\xdd\x7c\xb4\xef\xac\x29\xa4\x1d\xd7\x77\x6f\x85\xaf\xb4\x75\xbb\xce\x6b\xe7\xaf\xa2\x63\x78\xb4\xef\xf4\x69\xa4\x1d\xd5\xa9\x61\x6f\x1f\x66\x31\xf9\xb9\x01\xb5\x68\xb1\x80\x48\xb6\xaa\x0d\xb0\x0f\x94\xf0\xf4\x46\x80\x57\xab\x63\xf2\x8b\xe3\xb7\x20\xff\x60\x44\xfe\x73\xff\x57\x40\x3e\x0e\xf7\xc1\x5f\xa0\x33\xe2\x6a\x64\x03\xfc\xa3\xd3\x1a\x8d\x2a\xe0\x25\x76\x60\x81\x12\x0b\xc2\xd0\xaa\x65\x1a\x52\xcd\x21\x4b\xcd\x9d\xff\x56\xdc\xfc\xf8\xa3\x27\x8d\x0f\xa4\xbd\x39\xd3\xb4\xe5\xfa\x5e\xfd\xd2\x7b\x2c\x5f\x9e\x96\xe3\xa9\x8f\x7f\x36\x1f\xc1\xa1\x81\x87\x0e\x0d\x24\x29\x85\xf5\x40\x16\x93\x83\x30\x1f\x7d\x61\xdf\xab\x61\xac\x46\xea\x6b\xc4\xd1\x24\x7f\x3c\xc7\x69\x54\x1c\x8d\x1e\x10\x69\xec\x16\x8b\x1e\xa8\xa1\x5d\xb0\xc3\x38\x1c\x49\xc5\xdc\x76\x2d\xb9\xb7\x70\x4f\x43\x83\xed\xe4\x42\x18\xdf\x7d\x62\x7c\xb6\x71\x6b\xce\xab\xd8\x7f\x4f\x40\xfb\xdd\x22\x71\x0a\x1e\x68\x5a\x90\xb1\x46\x10\xa9\x80\x85\x47\xf1\x3a\x59\x23\x00\x1c\x78\x58\xa0\x82\x62\xaa\xcf\x63\x16\x73\x65\x78\x71\x71\x0a\x6f\xff\x9f\x61\x0a\xd4\x7e\xfc\x87\x70\x98\x2b\x60\xb6\x0d\xea\xdf\xa2\xc4\x29\x8a\x95\xd4\x8b\x29\xde\xf6\x6c\xa5\x5e\x22\xfc\x1f\xe3\xaf\x7e\x21\x1c\xb6\x61\x7d\x12\xa9\xa2\xf7\x4e\x05\x5c\xfa\x52\x78\x86\x62\x13\x64\x76\x58\x89\xaf\x44\xd4\x26\x18\x73\x2f\x11\x15\x6b\xeb\x4b\x70\xe7\x72\x1b\xf9\x2d\x09\x0b\xe1\x30\xfa\x19\xee\xfb\x20\xbc\xc0\x24\xf3\x12\x2e\xa0\xdd\x80\xdf\x3d\x19\xad\xab\xcb\xd9\x91\x52\x07\xfc\xb6\x50\x24\x94\x82\xa4\x4b\x46\x23\x02\x2d\xf4\x28\x39\x41\x96\xac\x36\x9b\x94\x80\x84\x94\xd4\xc4\x84\x1e\xc1\xc4\x44\x17\x8f\xac\x26\x6b\x85\x75\xa2\xb5\xd2\x7a\xde\x2a\xa9\x79\xab\xd5\xe5\x32\x95\x05\x5d\x0e\x5e\x53\x16\x4c\x91\xe7\xcb\xab\x65\x90\x3a\x3c\x4d\x07\x94\x3b\x30\x96\x5a\x8e\x66\xc5\x32\xd7\x0a\x64\x66\x83\x8c\x14\x05\xaf\x4e\x76\x49\x79\x23\xe7\x4b\x43\x34\x41\xe9\x42\xcc\xdd\x3d\x76\x3b\xe5\xbc\xa9\x72\xda\xd3\xeb\xd7\xef\x60\xa5\xcc\xa7\xbf\x31\xf3\x5e\x18\xe1\x9d\xc7\xb9\xe4\x48\xf9\xef\xfe\xa3\xdf\xf8\xe7\xe7\xef\x8d\x19\xa7\xab\xd8\x11\xc4\xa9\x6f\x53\x8d\x91\x8b\xab\xb1\x9e\x80\x46\x05\x4a\xcc\x16\x59\x4a\x70\xc1\x86\x71\x49\x16\x21\x31\xc9\xed\xea\x11\x74\xbb\x79\x07\xb0\x66\xa3\x39\xc5\x3c\xdf\xbc\xda\x2c\xa8\x79\xb3\x39\xae\xf8\xba\x49\x9e\x28\x57\xca\x1f\xc8\x00\x9c\x95\x42\x11\x35\x07\x33\xe9\x61\xa3\xf9\x8b\x8a\xec\xd4\xf0\xfd\x97\x55\xd9\x43\x2f\x1d\x7f\x58\x61\xf6\xd0\x12\x18\x47\x38\x8c\x2b\xc8\x46\xd0\xac\x9b\x98\x00\xab\x31\x9f\xdb\x7f\x0a\x47\xb9\x3b\xe2\xef\xb0\xfe\xde\x9a\x31\xc0\xba\x97\xfa\x8b\xeb\x51\xcd\x88\x23\x46\x41\xf8\x9f\xdd\xde\x3c\x2c\x1c\xf5\xe2\xf4\x0c\x72\x83\x11\x73\xa1\x70\x94\xdf\x24\xb5\x8c\xd8\xd6\x80\xfe\x15\x27\x25\xb5\x5e\xa3\x51\x23\xde\x68\x50\x69\x35\xda\x35\x41\xb5\x46\x8c\x6f\x97\x46\xfe\xe5\xd5\xce\xf8\x56\xfd\x94\xc2\x88\x71\x9f\x53\x17\xbc\xb9\x6e\xe3\xea\xd0\xee\xb5\xf4\x91\x13\x32\xc8\x46\x8b\xe2\xc6\x01\xf4\x06\x7f\x84\x2b\x62\x3b\x4b\x26\x4a\x47\xc8\x2c\xf3\x45\x24\x33\x5c\x86\x6c\xc7\x38\x13\xcf\x9d\x22\x19\xc7\x0d\x66\x41\xce\xc0\x39\xf9\xa8\x24\x9f\x8d\xf5\x67\xbc\x8f\xfb\x27\x47\xcf\xe1\x32\x02\xce\x48\x3c\xe4\xb6\xfe\x46\x5c\x82\x27\xe0\x9d\xf8\x2a\xbe\x83\x01\xbc\xe6\x0e\xac\x8e\xf6\xa6\xca\xd7\xcf\x3f\xe0\x7d\x38\x87\x7c\x1c\x0e\x87\xaf\xc2\x2d\xaf\x8b\xed\x4c\x99\xa8\xce\x60\xf6\xbc\xd0\x5d\x78\x5e\xe6\x71\x6c\xe0\xb1\xf1\x54\xf8\xfc\x31\x7b\x62\x07\xfa\xfe\x92\xda\xd2\xe1\x54\xf8\xc6\x71\xa3\x11\x21\x78\x7e\x8e\xd2\x03\x25\x37\xdc\x68\xb1\x2d\xf0\x08\x33\xea\x17\xb0\x9b\x75\x3a\x80\xba\x02\x75\x49\x57\x21\xa4\x15\xb4\x16\xab\xc1\x0c\x13\x14\x70\x05\x0d\x06\x51\xe6\xca\x83\x65\x32\xde\x25\xbf\x28\x73\xb2\xac\x16\x79\x01\xf8\x74\x09\xcb\x12\x3f\x70\x92\x42\x36\xf1\xe5\xc1\xe3\x26\xd0\x6b\x8e\x84\xc1\xd0\xee\xb3\xc9\xe4\x5f\x20\x7d\xcf\x9d\xc3\x07\x5e\xb9\xff\x14\xac\x1d\x37\x21\xb4\x56\x6c\x1b\x7a\x87\x2b\xf8\xf3\x8c\x80\xa2\xeb\x08\xf3\x49\x91\x7b\x25\x1b\x5f\xbd\xf9\xd5\xf3\x19\x37\x3e\x8b\x35\x32\x3e\x23\x8c\xef\x4a\xcd\xf1\xd1\xf9\x81\x3d\x72\x44\xec\x07\xf7\xe7\xb5\xab\x9e\x1f\x58\x0f\x17\xac\x47\xe8\xb9\xe3\x0e\xb7\x84\xaa\xd7\x43\x99\x8f\x17\x60\x3e\x54\xa0\x91\x07\x03\x0e\x83\x5a\xad\xd5\xe9\x44\x6a\xd8\x55\xa9\x24\x8c\x39\xce\x68\xd2\x1a\xe8\x84\x38\x83\x5a\x41\xe2\x03\x2c\x6e\x95\x2f\x61\xa0\x13\xd4\x50\x6c\x41\x2c\x13\x6b\xee\xc0\x81\x74\xe0\x39\xd1\x40\xe8\xbc\xd8\x5c\x28\xf4\x44\xb3\xb1\xb2\xe0\x3d\x65\x2e\xba\xbe\x4a\x9e\xbe\xfc\xdf\xdf\x2f\xdf\xef\x4e\xe7\xa2\x43\xe8\x14\xd7\x81\x0b\x85\x9e\xe5\x82\xe4\x4c\x8c\xa6\xb9\xf0\xfb\x2c\x8f\x5f\x3f\xa0\xac\x6c\x34\x24\xe0\xc9\xaa\x53\x27\x23\x3b\xc3\x9b\xec\x96\xb4\x6e\x2d\x9f\x60\xf7\xaa\x8d\xbc\x97\xcf\xa9\x97\x95\x4d\xfb\x67\x0f\x66\xf1\x3a\x97\x4b\x9d\xe0\x49\x28\x0f\x6a\x3d\x16\x64\x29\x0f\x22\x21\xae\xfc\x01\x2c\x96\x3f\x3e\x61\x51\xb5\x3d\x25\xba\xd3\xf3\x10\xcd\x45\x4a\x4b\x1e\x78\xd9\x91\x66\x04\xd8\x3a\xe9\x26\xc8\x73\x66\x72\xf9\x8d\x2d\x05\xca\x00\xb8\x95\x5f\x61\xeb\xfe\xcd\xe5\x0d\x2e\x91\x46\x73\x66\x3c\xbd\x61\xc3\xae\x19\x73\x48\xa3\x4b\x0d\xca\x37\xef\x9f\x77\x33\xf4\x31\x0c\x4a\xec\x47\x4e\x91\x5f\xde\x25\xe7\x46\x68\xb7\xdf\xe8\x4f\x5e\xfb\xf4\x97\x3b\xd7\x5e\x0b\x0d\xb8\xb1\x5d\x3b\x1c\xb7\xbc\x72\x14\x5b\x36\x90\x67\x62\x43\x85\x75\xdf\x08\xeb\x36\x50\x6a\x69\xc9\xe4\xc7\xc0\x3e\x92\xf8\xe2\xdf\x10\x72\xbf\xcc\x73\x18\xfe\x9d\x0a\x7f\x79\xdc\xe3\xd2\x4b\x74\xdd\xf2\xf3\x11\xfd\x89\xdb\x7b\x6d\x2d\x12\xdd\x7b\xf0\x7d\x0f\xa3\x1d\xfa\x3d\x83\xc9\x24\x68\x5a\xe8\x0f\x6b\x2b\xb2\x7a\x46\x18\xb3\x18\x80\xf2\x20\xc7\x53\x2a\x8e\xaf\x91\xc4\xca\x70\xe2\x9d\xe7\xf8\xd9\xa1\x36\x62\xdb\xed\x94\x2e\x74\x70\xef\x79\x76\xaf\x01\x75\x0c\x64\x51\x87\x5a\x41\x03\xea\xb4\xc4\x9b\x8c\x49\x12\x36\x4a\x58\x0f\x9f\x39\x5e\x2b\xc0\x2f\xb5\x34\xac\x1d\xa6\xdb\xc2\x62\x24\x9d\x7e\x9a\x43\x15\xa0\x15\xb0\xd4\x81\x35\x93\x29\xf9\xf3\x81\x04\xec\xd8\xc0\x61\x2f\xce\xcc\xd2\xe1\x7f\xdd\xc5\x5f\x85\xf6\xf1\x25\xb9\xe4\x1a\xdf\x98\xbc\xe5\x4f\x5f\x2b\x1c\xbf\x5f\xba\x5e\x38\xab\x39\x3d\x33\xe4\xe1\xf5\x8b\xa6\x44\xc7\x35\x84\x8d\xab\x0e\x1b\x67\x47\xf8\xbe\x88\x7d\x6f\x1e\x1b\x77\x36\xfb\x9e\x83\x1e\xcc\xb7\xdd\x37\x50\x6c\xa2\x1e\xda\x40\xf9\x82\x27\xc1\xed\x2a\x0f\xe6\xba\xcb\xdd\x3b\xdd\x2f\xb8\x05\xa3\x7b\x35\xbc\x9d\x73\x7f\xe1\xbe\xe3\x0e\xbb\x65\x27\xef\x76\xd3\x5c\xdc\xe5\x41\xb5\xc0\x5b\xcb\x83\xbc\xb5\x76\x1a\xeb\x49\x39\xf1\xd1\xb0\x0f\x4d\xc2\xcd\x03\xb5\xc4\x92\x70\x0b\xa1\xf8\x24\xdc\xab\xc9\xd1\xb8\x24\xdc\xdd\x41\x0e\xd4\x48\xc2\x8d\x7b\x6f\xdd\xca\xc6\xf3\x0e\xf5\x91\x67\xe3\xa9\x17\x1b\xdf\xbb\xec\x3b\x8b\xad\xa6\x99\x68\x84\x8b\xb0\x36\x1a\xd0\xdc\x3c\x1a\xb5\x80\x11\x75\x66\x42\xbc\x4e\xdb\x4f\xc0\x9d\x01\xe4\x68\xd4\xbc\x2a\xc2\xa9\xfc\xb5\x97\xc0\x4b\x2b\x47\xb0\xba\x51\x7e\xe1\xe2\x65\x72\xb1\x61\x7a\x7e\x0a\x39\x7f\x19\xff\xf1\x16\xbf\x74\xcd\xb2\x0b\xbd\xab\x66\x89\x6d\xe1\x99\x0b\xe0\x19\x9d\xd9\x33\x1b\xd6\x9a\xe3\x46\x6c\x8e\x97\xc1\xf7\x76\xd0\x07\xaa\x93\x6a\x51\x9f\x40\xbe\x56\x05\x3c\x03\x0b\xb2\xa0\xd7\x69\x81\x16\x52\xb4\xb9\x5a\xce\x08\x2f\x25\xda\x72\xed\x7c\xed\x0b\xda\x2f\xb4\x72\x0a\xaf\xd5\x8a\x58\x00\x12\x14\x2c\x18\x95\x07\x31\xff\xd0\xf9\x8d\x86\xff\x51\xe7\x05\x5a\x49\x01\x7e\xe8\xa4\x6e\xe3\x9f\xaa\xea\xc5\x9f\x5b\x1b\x1a\x2a\x1c\xdc\xbe\xfd\x7e\x9f\xed\xdb\x79\x1e\x26\x0c\xfa\x16\x59\x6f\xe8\x5b\x1e\x9b\x9f\xbd\x4a\x5f\xa1\x67\xbe\x80\x19\x94\x65\x1e\xb1\x78\x45\xfa\xc0\x08\x03\xcf\x89\x0b\xa2\xf1\x47\x72\xb8\xed\xe5\x97\x9d\x0b\xfd\x47\x6c\x0b\x0c\xf9\xe0\xfd\x3e\xd1\x31\x97\xb3\x31\xfb\x59\xbb\x63\xe1\xfb\x6e\x68\x57\x87\x1e\x09\x64\x83\xc8\xc0\x2a\x8e\x33\x68\xb0\xa8\xc5\x5a\xbd\x81\x07\x54\x01\x84\xa3\x02\xd0\x9c\x44\x7d\x0f\x80\x37\xc6\x6f\x0a\xa5\x82\x04\x0c\xd1\xef\xaf\x11\x8b\x6e\x89\x65\x80\xf1\xe7\xab\xe9\x50\xbd\x98\x26\xe7\x1b\xcb\x79\x42\xff\xe1\xbf\xad\xfa\x19\xbf\x43\x1c\xfc\xb8\x3d\x5c\x06\xfe\xd7\xee\xed\x64\xf0\x1c\x62\xd8\xce\xd6\xa3\x4b\x6c\xaf\x17\xb2\xef\xc0\x01\x84\x03\xec\x7b\x33\xb6\x3e\xaa\xf0\x3d\xe1\x4d\xb1\x1b\x8d\xef\x42\x75\x51\xef\x40\x83\x24\x9b\x64\xce\x90\x78\xd9\xab\x77\x21\xbd\x8c\xf8\x9c\xec\x84\x4c\x73\x66\x45\xd0\x66\x4e\xce\x50\x65\x54\x04\x45\xd5\x1a\x33\x36\xab\xcc\x2a\xc9\xc2\x4b\x40\xf8\x25\x2c\xf3\xdd\xc0\x48\xf5\xde\x9a\xb9\x90\x63\x79\x18\x6c\x06\x9c\x83\xa9\xbf\x2b\x2b\xc2\x80\x9a\x52\x54\x04\xbb\x41\xa6\x1e\x8e\x00\xa8\x0b\x32\x68\x76\x77\x33\xb0\x51\xe1\xcd\x19\x9f\xae\xa8\xfb\x72\xdd\x27\xff\x31\x03\x4b\x37\x92\x5f\x4e\xba\x81\xe5\x8b\xfb\x37\x8b\xba\xf5\x7b\xab\xde\xde\xbb\x5e\xa7\xda\xb8\x9f\xbb\xf8\xc4\xb7\x8b\xae\x5d\x5b\xf8\xfd\xe3\xd7\xb1\x78\xe4\x08\xa9\xfa\x72\xdf\x4b\xa1\x0e\x17\x76\xef\x39\xcf\x9d\x7a\x31\x36\xc6\x83\x6c\x8c\x4d\xd9\x7a\x00\x25\x0a\xdb\x61\x3d\x12\x68\x46\x44\x63\x42\x82\x0e\x59\x1d\x2a\x11\x89\x0e\x3e\x29\xd1\xa8\xc3\xba\x8a\xa0\x07\x63\x9b\x5e\x52\xf8\x9d\xdf\x5f\x9c\xeb\x7f\x18\xd8\xa1\xe5\x87\x39\x25\x41\x69\x53\xcc\xac\x64\x4a\xa1\x3e\x0e\xc6\xc0\xb9\x9b\xbc\xfb\xd5\xee\x35\x8b\xfd\xdb\xfc\x4b\x56\xef\xbe\xf9\x4e\x13\xbc\x12\x3b\x7f\xc6\x47\x49\xe7\x13\x6f\xf2\x0d\xab\x3e\xb8\x74\x0c\xbf\x4c\xba\xfd\x4c\xbe\x27\x91\x1a\xb5\xb4\xb6\xca\x7a\xe0\x3d\x3e\x5a\x0b\x1c\x64\x14\x95\x56\x46\x35\xcf\x6b\xdd\x5e\x21\x3d\xe3\x7f\x0b\x28\x73\xad\xa4\x88\xb5\x65\x52\x81\x25\x2a\x93\x2c\xd5\x32\xc9\x84\xb8\x91\xf7\x70\xca\xf3\x7b\xa7\xd6\xbb\x44\x92\x96\x2e\x3c\xb2\xef\xc0\xa1\x45\x4b\x48\xd2\xa5\x7a\x53\xf7\x3e\x8f\x53\x40\x0e\xbd\x4a\x7e\x7c\x8d\x9c\x1c\x0b\x72\x68\x08\x56\x1d\xb9\xf1\xdd\xed\xeb\xcf\x91\x3f\x86\x80\x24\x1a\x87\x3b\xbe\x8a\x6d\xb8\x75\x8c\xe7\x48\x4b\x01\xc7\xd5\xa3\x38\x0e\x8d\x01\x3a\xd6\x22\x67\x40\xcf\x61\x9d\x98\xc9\x61\xce\x04\x12\x84\x09\x20\x94\x13\x95\x3f\x8c\xe6\xd8\x3d\xcd\x22\xf7\x58\xa2\xf7\xa8\xe9\x3d\x66\xbd\x56\x50\xd5\xba\x67\x01\xec\xd5\x35\xe2\xef\x20\xe7\x86\x30\x39\x57\x04\xb7\x5a\x41\x63\x02\x5a\xe4\x5c\x99\x75\x45\x23\x03\x27\xf0\x0f\xae\x7d\x81\xe2\x7d\x76\xed\x08\xe5\xda\x32\x76\x2d\xae\x63\xce\xc4\xcd\xeb\xe4\x68\x84\xb8\x6b\x8f\xb1\x1a\xec\xf4\xda\x51\x35\xae\x75\xc3\xb5\xdd\xdc\x89\x3a\x67\xdc\xb5\x4c\xd6\xb2\x6b\x15\x59\x5b\x94\xac\x5c\x6b\x82\x6b\x35\x26\xab\x22\x68\x23\xd7\xb2\x1a\x45\x4c\x2e\x4f\x53\xe4\xf2\x2f\xf1\x72\xf9\xe6\xf1\x94\x24\x05\x4f\xc5\xe4\x32\xc8\x4e\x36\x46\xd0\x53\xdc\x20\x87\xfb\x06\x1a\x7a\x44\x2d\x4a\x4d\xb5\x38\xec\x76\x80\x9a\x16\xd1\x42\xab\xb7\x1a\x8c\x2a\x1f\x2d\xf4\x63\xd2\x72\x26\x41\xab\x32\x71\x49\x65\xc1\xd9\xee\x27\xdd\x9c\x9b\xa3\x8a\x09\xd3\x4b\xa8\xfc\x54\xcc\x79\x71\x15\x73\x63\x54\x9b\xc1\xc5\x65\x60\xa6\xc1\x1b\x9c\xec\xb0\xd0\x33\x38\x25\x4b\x35\x2d\xa0\x00\xa4\xc2\x4f\x9b\x72\xf7\xbd\x0b\xd7\x3e\x9c\x77\xac\x3e\xe7\xcc\x7b\x35\xaf\xa7\x4a\x6c\x9a\x7b\xd2\xe5\x13\x43\x6f\x4c\x5e\x3c\x63\xbf\x27\x69\xf3\xf4\xe5\x33\x7f\x24\x61\x20\x03\x17\x4d\xb0\xbc\x74\xe6\xf4\xc7\xc6\x90\xf7\x86\xec\x22\x57\x46\x36\x5f\xed\xc5\x8d\x3e\xbf\xfc\xed\x1b\x7f\xfb\xfb\x65\x36\xae\x23\x30\xc7\x23\x95\x9a\x9b\xa8\x6b\xa0\x6e\x12\x28\xef\x0e\xb3\x0f\xa6\xc5\x9a\xa5\x11\xb3\x73\xac\x59\x99\x59\x99\x65\xc1\xac\x2c\x03\x6f\x70\x97\x05\x0d\x48\x9d\xc0\xd3\x5c\xf7\x8e\x58\x65\xc8\x48\x4d\xc3\x9a\xa5\x20\x62\xe9\x0c\xb2\x7c\x8a\x55\x45\x39\x43\x92\x93\x71\xb4\xee\x6e\x34\x4b\x37\x8d\xcd\x12\x46\xfe\x78\xfd\xe4\x32\x49\x3a\x7e\xf3\xdf\x6f\x7e\xf8\xc5\x86\x43\xe4\xee\xcc\xf1\xeb\x17\x04\xf6\x77\x5f\xb9\xf9\xfd\x37\x9f\xda\x8e\x37\xbe\xf5\xd5\xa0\xc9\x7d\xc9\xa7\xe2\x11\xb8\xee\x99\x50\x9f\xa4\x2b\x5c\xd3\x21\x13\xb7\x3d\x5b\xf5\x41\x4e\xa3\xad\xcb\x56\x3f\xbd\x4a\xbb\x8e\xed\xd3\x7c\xd2\x17\xd6\xa8\x09\x32\xa2\x40\x20\xdd\x20\xc8\x5a\x9d\xac\x42\x46\xa3\x4e\xc5\x9b\x4d\xd3\x84\xa5\x02\xd7\x54\xdd\x59\xdd\x1f\xd0\x80\x60\x30\x68\x13\x64\xa5\xf8\x14\xf5\xf7\xaf\x21\x4f\x99\x90\x52\xe3\x64\xec\x6c\x81\x01\xd9\x48\xbc\xaf\xa0\x10\xa3\x30\x36\xea\x3b\x09\x52\x01\xce\x7c\x93\x74\x6e\x9b\x7e\xce\x1d\x20\x75\x85\x26\xa1\x09\xa9\x57\x2c\xf6\x55\xdc\xed\xfb\xf7\x4f\x90\x6b\xe7\x7f\x13\x72\xe9\x9c\x4e\x04\x5a\xe9\xc5\x72\xac\xa6\x82\xd6\x96\x26\xbb\x0d\x49\xa9\xc8\x6a\xa5\xfa\xac\xe8\x4d\x4b\x4a\x4d\x81\x19\x14\x12\x8d\xbc\x23\x05\x39\x40\x19\x77\x38\x62\x99\xf6\x6b\x67\xa9\x55\x4a\x6a\x64\x45\x3c\xbf\x0b\x80\x0e\x92\x39\xbb\x8d\x42\x14\xc0\xad\x85\x4c\x8a\x6e\x2e\xea\x3e\xe4\xd4\xa5\x67\xd7\xac\xdf\x4d\x7e\xde\x8a\x9b\x55\x4e\x68\x46\xee\x7e\xfd\x0d\xf9\xf5\xd7\x9f\xc8\x05\xee\x36\xfe\xb4\xf7\x86\x59\x23\x5a\xfe\xbc\x65\xef\xeb\xa7\x04\x9b\x8a\xbc\x3d\x6f\xe7\x91\x51\x9f\x93\x3b\x58\x7d\xf3\x35\xec\xe9\x81\x3b\x2c\x5c\xad\xf0\xb8\x17\x22\x7a\x78\x16\x1a\x18\xc8\xcb\xd0\xd0\x2c\xbb\xbc\x20\x38\xbd\x7a\xb3\x46\xaa\x53\x57\xef\x4d\xf3\xa6\x95\x05\xbd\x5e\x9b\x4c\xd3\xec\x22\x17\xd6\xf2\x34\xd1\x2e\x4f\x0d\xd7\x65\x41\xd9\x11\x91\x87\xb9\x71\x79\xb5\x1f\x4e\x15\x19\xf1\x46\xd5\xc2\xfc\x9a\x05\x19\x99\x65\xc1\x9e\x4a\xdf\xb8\x71\x63\xcf\x05\x46\x97\xdd\xdb\xf6\xc9\xf5\x6d\xd3\x1f\x5d\xfa\xdd\x1b\x1b\xfe\xd6\xba\x32\x77\xed\xe8\xca\xe9\xe7\x7e\x0c\xa3\x4b\x8b\x27\xf7\xec\x3a\x6c\xf0\x90\x7d\x4f\x8d\xdd\xa4\xe5\xf4\xcb\x87\x2c\xd9\xde\x7b\x68\xdf\xf6\x6d\x7a\x75\xea\xdb\x77\xd9\xd0\xe1\xfd\x07\xb2\x31\x9d\x22\x1b\x85\x52\x58\x87\x34\xd4\x2a\xe0\x75\xa5\xa4\x18\x54\xaa\xf4\x24\x64\xb7\xfb\xd2\x53\x12\x93\x12\xcb\x82\x23\x04\x4a\x15\xbc\x60\x36\x6b\x92\x90\xe6\x14\x56\x33\x09\x99\xeb\x1f\x18\x57\xfb\xd0\x52\x9d\x3d\x87\xa5\xdf\x00\x22\xce\x62\x7a\x04\xcb\xce\x81\x70\xbe\xe4\xa3\xa5\xa1\x04\x60\xad\xd3\xa7\x4c\x99\xb3\x65\x63\xfb\x47\xe6\x39\x53\x97\x1e\x7b\xfe\xf4\x00\x5c\x8a\xc7\x77\xe8\x45\xf2\xf8\x34\x72\x97\xdc\x58\x8e\x67\x97\x0e\x75\x25\xf9\x3a\x0c\x0d\x0c\x5f\x59\x94\xd2\x23\xd1\xdf\xc9\xe7\x2b\x5f\x33\xf0\x35\x7c\x1d\x37\x93\xa4\x55\x4f\xfc\x46\x8e\x90\x3b\xac\xdf\xc7\x22\x35\xb8\x5d\xa8\x61\xc0\x65\x56\xa9\xd4\xc8\xa5\x76\xb9\x3d\x66\x9b\x4d\x28\x0b\xda\x4c\x3a\xa3\xda\x0e\xf2\xb1\xe4\x61\x05\xae\xb1\xf9\xa1\x75\xad\x23\x15\xb7\xe3\x2b\x5a\xc3\x33\x2a\x1e\x28\x66\x7d\x7f\x29\xc5\x19\x4f\x01\x2d\x14\x88\xef\x02\x16\x35\x43\x1f\x5a\x04\x52\xec\x46\xa3\xe4\x30\xd0\x90\x1f\xb7\xc7\x6e\xec\x1e\xb4\xdb\x79\x95\xca\xd2\x3d\xa8\xe2\xb5\x31\x5e\x90\x5b\xbd\xe8\xb8\xb8\x86\xad\x45\x61\x6a\xde\x3c\x0b\xce\xb3\x58\xbd\x1e\x6c\x4d\xe3\x78\xaf\x06\x0b\x05\x3f\xdf\xbc\xf1\x03\xfe\xf0\xce\x17\x24\x7b\xf5\x62\x31\xf4\x2f\x71\xc1\x9a\x55\x0b\x25\xce\x27\xce\xe5\xfe\x45\x16\x91\x15\x78\x2e\x7e\x8c\xfb\x89\xac\xae\x72\x62\x33\x4e\x21\xb7\xc9\x4d\xe1\x1a\xb9\x47\xbe\xc6\x09\x20\x91\xe8\x3c\x31\x9e\xcf\xf6\x7b\x93\x40\x2a\x3d\x00\xd7\x6a\x4d\x66\x83\x1e\xd8\x94\x11\x89\x26\x31\x55\xe4\x75\xbc\x28\xaa\x54\x3c\xad\x55\x84\xaa\x6d\x42\x35\x8d\x2f\x71\x19\x6c\xa9\x57\x38\xb7\xbc\xac\xe7\xf8\xe1\x83\xe6\x1f\x3b\xfa\x0c\xb9\x80\x7f\xc3\xfd\x26\x0c\x1f\x33\x63\xc5\xd1\xf3\x5c\xb7\x55\x54\x76\xdc\x06\xf9\x38\x9c\xd6\x66\x41\x7f\xb2\x3e\x4c\x86\xef\x3d\x58\x8d\x87\x76\x81\x4c\xa7\xcb\x80\x6c\x26\xa3\xd1\x26\xbb\x04\x9a\xa0\x14\x1b\x04\x9b\x01\x05\x8c\x96\x0e\x08\x69\x5c\x46\xbb\x06\xd6\x0f\x80\x7e\x5c\xfe\x4f\x3f\xb3\xb7\xd5\xa8\x7e\x47\xbd\xc9\x94\xf4\x85\xc0\x82\xb0\x8f\x87\xfd\x4f\xa1\x3d\xe7\xef\x9d\xdf\x24\x2f\xd9\xef\x4b\x18\x92\xde\x79\x58\xcf\xa6\xf8\xf0\xd9\xab\x9a\x5c\x55\x72\x11\x09\x9f\xe1\xdf\xbc\x3d\x2c\x4b\xb7\x58\x65\x2a\x5a\xb4\xfd\xfe\x93\x5c\xcb\x84\xa7\xd2\xfb\xcd\x0b\x5d\xa0\xfd\xdb\x0e\xeb\x3c\x17\xe6\x28\x19\x15\x06\x12\x92\x38\x0e\x3b\x35\x1a\xc0\xb6\x29\xa9\x46\xc9\x23\x95\x05\x9d\x36\x8f\x43\x83\x8d\x8c\x9c\x68\x4e\xe7\x5a\x04\xc5\x4c\x7f\x66\x7f\xf5\xb9\x4c\xfc\x79\x1e\x7b\x35\x6f\x7f\xf9\xd1\xe9\x95\xeb\x8e\xfb\x72\xdc\x49\x2d\x1b\xf6\x2f\x17\xf9\x31\x17\x5a\x8f\x4b\x21\x7d\xc4\xaf\x42\x3d\x9e\x78\xf2\xf9\x3d\xdc\x94\xaa\x0f\x3a\xb7\x53\x2d\xb0\x0d\x1a\x76\xb1\x6e\x26\x49\x84\x3e\x0d\x80\x39\x2b\x80\x3e\x19\x68\x4d\x40\x81\x97\x25\x11\x26\x45\x94\x79\xa3\x49\x27\x1a\x65\x41\x29\x96\x5e\x2b\x63\x2f\x00\x26\xd0\x6e\x30\x85\x4b\x59\x7e\x87\x50\xf0\xf7\x8b\x87\xc8\x88\xd7\x70\xe7\x8d\x8f\x37\x3a\xda\x98\x2f\x3d\x46\xda\x7d\x29\x34\xa9\xaa\x38\x8d\xbb\xed\x5d\x36\x3e\x92\x3b\xfc\x1c\xd9\x2a\xf8\x60\x6d\x1a\x02\xb6\xf7\x24\x22\xbb\x2a\x3b\x3d\xdd\xe2\xa2\xa2\x19\xa9\x1a\xe5\x09\x2e\xb7\xcb\xdd\x3d\x58\x3f\xf5\x14\xd6\x9c\x08\xba\xea\xbb\xea\x9b\x32\x81\x07\x9c\x8c\x14\xb3\x43\xd5\x10\xbf\x98\x9d\x04\xd6\x2e\x76\x64\x6d\xdc\x02\x47\x18\x58\x61\xbe\x2c\x52\x17\x55\x41\x31\x2d\x48\x82\xfd\x41\x66\x71\x6e\xe6\xd7\xbb\x8f\xbe\xb9\xf6\xe9\xc4\x30\x1a\xc4\x7d\x4e\x42\x9f\xbf\xf9\xcb\x7d\x72\x79\xe2\xf8\x59\x1b\xa6\xb5\xa6\x2c\x63\xfa\xd6\x43\x27\xfb\xe2\x21\x8f\x9d\x9b\xef\xe0\xb4\xab\x1f\x1b\x53\xe9\x51\x61\x79\xd5\xf2\x94\x99\x15\x83\xc7\x99\x17\x25\x5f\x58\xd3\x6d\x44\x42\x72\x7a\x8b\x41\xed\x2a\x18\xf7\x28\x6c\x97\x9c\x36\x68\xa5\x82\xbf\x62\xb5\xe0\x51\x0f\x36\x6e\x07\x7c\xdf\x03\xf3\xcb\x6a\x3b\x1b\x1c\x7a\x5a\x24\xcf\x6b\x40\x8e\x24\x47\x59\x30\xc9\x68\xb1\xab\x81\x0c\xd5\x8e\xb8\xda\xce\x35\xd2\x68\x99\x6b\x6c\x08\xbb\x09\xe4\x9f\xa5\x39\xad\xf8\x00\x92\xda\x0f\x02\xe7\x93\xec\xc6\x29\x3e\x5b\xd7\x56\x53\x46\x90\x15\x6d\x5e\xcd\xaa\x5b\xb6\xd0\xe1\x7a\xb4\x31\xff\x31\x7f\x24\x34\xa8\x4b\x5b\x58\xe8\x49\x4b\xb9\xcb\x1d\x42\xfb\xc9\x7f\xb6\xe1\x4b\x7f\x94\xb9\xf4\x9b\x74\x66\x96\x3b\x17\xed\x00\x5a\xec\x29\x74\x03\xe4\x9e\x8c\x1a\x05\xdc\x6e\xa0\x44\x2b\x75\x5a\x48\xa5\xa5\xf9\x8c\x26\x4d\x02\x0f\x4c\x59\xe2\xa3\xd9\xa8\x4b\x72\x6a\xb2\x36\xa5\x5e\x47\x04\x50\x50\x8c\x64\xa1\xe7\x94\xa9\x6e\xcc\xb0\x84\xd0\xf3\xb7\x8b\x8f\xee\x6c\x23\x08\xc7\x7f\xfd\x78\xd5\xcd\x79\x17\x0e\xaf\x21\x7f\x34\x7d\xa6\xf7\xfc\x15\x9c\xf0\x13\xf9\xa4\x65\x69\xb3\x12\xd2\x87\xff\xe9\x1e\xb6\xaf\x25\xbf\xed\xff\xf0\x47\x32\x9d\xbc\xde\xa1\xf3\xdf\xd9\x7c\xbd\x48\xb6\x0b\x75\x80\xdf\xa6\xa3\xd6\x01\x2f\x9f\x90\x66\xd5\x25\xe8\x32\x32\x39\xd9\x22\xa7\x01\x51\x0a\xb2\xd3\x99\x62\xf4\xf9\x52\x52\x40\xd2\xa5\x98\x8c\x8a\x9c\x50\x98\x09\x35\x2e\x47\xb6\x70\x75\x1d\x55\x5a\x5a\x3e\x92\x39\x5e\x52\xd6\x3f\x92\xcb\xc9\x12\x39\x45\xe4\x5e\xdc\x74\xb8\xf9\x93\x5b\x8b\x67\x0e\x6b\x99\x9e\x0b\x4b\xdf\x78\xcc\xdc\xd7\x8e\xf6\x7a\xe2\xab\xf5\x93\x4e\xb7\x98\x34\x85\xbf\x40\xbe\xfb\x47\x8f\x47\xbb\x37\x30\x67\x36\xeb\xd7\xa6\xde\xb8\x6e\x74\xb9\xd3\xfc\xf5\x52\x1b\x4e\x38\x58\xf9\x22\x2e\xde\x56\xda\x69\xf2\x5c\x36\x9f\x03\x68\x7d\x19\x58\x67\x13\x6c\xdf\x86\x01\xb7\x93\x86\x67\xe8\xad\x12\xe0\x0c\xad\x4d\x6d\x83\x35\x36\xf2\xee\x6a\xac\x56\x43\x4d\xa2\xd3\x19\xb1\x74\xd4\xa5\x31\x4c\xf6\x64\x2c\x37\xce\x62\x65\xfb\xbd\x30\x97\x05\xe4\xfe\xd7\x3f\x87\x11\xae\x87\x1d\x5c\xee\xb6\x0d\x3d\xdb\xbc\x36\x27\xf8\xca\x07\x38\xfb\xa9\xa7\xf1\x0f\xbf\x90\x5f\xb1\x9b\xd6\x6d\xc2\x19\xab\x24\x61\xde\xdf\xa6\xde\xfd\xe0\xd3\xb7\xc9\xd0\x0b\x28\xc6\x93\x13\xa1\x4f\x34\x9e\xc2\x65\x54\xa9\xb4\x5a\xde\xe1\x70\xb9\xad\xc0\x95\xad\x0e\x0d\x62\x68\xc1\xf8\x60\xda\x2d\x96\x66\x31\x46\x63\x5e\x25\x80\x31\x72\x00\x8c\xd7\xf6\xd8\x40\x49\x8c\xfb\x80\x3c\x31\xa7\xa8\xcc\x39\xb9\xa8\x72\x3a\x7f\x44\xa1\xab\x50\xcf\x65\x9a\x45\x92\x61\x7a\x25\x77\x59\x79\x7e\xa4\xfe\x28\xb2\xa1\xdc\x80\x4b\x2d\x51\x99\x65\x77\x18\xf9\x14\x9e\x33\x89\x66\xd9\x18\x27\xb0\x4a\xe2\x16\x2e\x26\xa8\x58\x51\x0b\x3a\x05\xf9\x8d\x39\xe0\x33\x16\xa1\xcd\x9f\x3f\x7c\x75\xed\x65\x6c\xdc\xbc\xa2\x63\xdd\x57\xf3\x9b\x70\x4d\xc9\xbf\xc9\xd5\x7f\x7c\xc1\x3d\x15\x1a\x4a\x3e\xfb\xf4\xfb\x85\xd8\x5f\x3a\x8d\xdc\x56\x74\x04\x5a\x0b\x67\x8b\xd0\x03\x64\x41\x2a\x6a\x1b\x48\x37\xa9\x53\x04\xc1\x22\xba\x81\xb7\xe9\xd5\x82\x37\x4d\x9f\xe8\x48\xec\x1e\xd4\x39\x4c\x29\x16\x09\x84\x27\x2f\xd9\x85\x84\xea\x42\xff\x0f\xad\x4c\x04\x7d\x92\x81\xda\x69\x69\x22\x0b\x85\x4d\x76\x18\x04\xc5\x4b\x8c\xf2\xd3\xdc\x38\x5d\xd8\x72\xff\xce\xae\xef\xef\x7e\x7c\xde\x3e\x6b\x19\x6e\xfc\xf4\xc6\x5d\x27\x0f\xf6\xef\xbe\x11\xb7\xe4\xf2\xc9\x1d\xf2\xa9\x9e\x8c\xc6\x4f\x69\x41\x07\xd0\x7d\x8d\x73\xbc\xcb\x13\x6f\x3e\x47\x2a\x4c\x5c\x9b\xd7\xaf\x93\x7f\xfd\x7e\xee\x0b\xf2\x45\xe8\xb4\x9e\xce\x59\x13\xc0\xcd\xab\x84\x32\xd0\x01\x86\x04\x9a\x63\x8e\xd3\x98\x2d\x16\xbb\xcd\x66\x35\x21\x5e\x23\x39\x9c\x66\xa3\x60\xea\x69\x1a\x66\xe2\xcb\xd1\x04\xc4\xe5\x80\x3a\xcc\xb9\x11\xd6\x23\xc0\x80\xc8\xca\x9b\x04\xd0\xca\xe5\xb2\xa0\xce\x64\xc7\x09\xd1\x32\xe7\xce\x62\x6a\x27\x84\x3f\xae\x92\x9a\xea\x2f\x00\x40\x7a\x0a\x17\xcd\x24\x0f\xdb\xc1\x4a\x53\xc8\xfa\xb8\x29\x64\xe3\xab\xf8\x93\xb3\x4d\x07\xf9\x53\x92\xd2\x0a\x3b\xf6\x9b\xd3\x6b\x0f\xce\x3c\x43\x26\xe3\xe3\x67\xef\x84\x46\xf3\xc5\xb8\xcf\xa3\x13\x8d\x8b\xdc\xe3\xb7\x93\x6b\x5c\x42\xa8\x7d\xd5\xa7\xd0\xef\xbe\x30\xdf\x93\xc4\x66\x40\x6b\x80\x51\x90\x46\x63\xd7\x5a\x8c\xbc\x04\xba\x39\xef\x72\x3b\x1c\x82\xc9\x88\xec\x3a\x3b\x6c\x03\x9d\x43\x13\x3f\xd1\xfe\xdc\xda\xd6\x82\x0c\x5a\x65\x1b\x84\x9b\x44\x27\xbb\x81\xf2\x19\xc6\xed\xe7\x8e\xef\x9e\xbb\xf3\x83\x1f\x77\xdd\xfe\x60\xf7\xec\x5d\xbb\x26\x73\x1b\x8e\x70\x4b\x43\x73\x7e\xfb\x98\x23\x8f\xe2\x8d\xdc\xc7\xbf\x71\x8b\x43\xb3\x0e\xaf\x13\x85\x77\x14\xda\xcb\x07\xda\xdb\x02\xfc\xad\x2e\xea\x11\xc8\xb1\xa2\xe4\x2c\xaf\x1a\x50\x49\x96\xd7\x23\xe9\xf5\xc9\x59\x1e\x21\x3b\xa7\x4e\x1d\xa7\x86\x4f\x77\xa6\x97\x05\xe9\xb9\x1c\x67\x35\x39\x1d\x49\x1a\x13\x93\x77\x51\xd4\x59\xab\xb2\x91\x85\x65\x64\x29\x8e\xe0\x14\xaa\x31\x65\x15\x3a\x2c\x91\xda\x45\x4a\xf5\xb0\xfc\x08\x6d\xb0\x0b\x9a\x63\x3f\x77\x72\x40\xc7\xf6\x9d\x47\x0e\x4e\xd9\x7e\x6a\xcf\xaa\x61\x8b\x5d\x82\x6b\xc9\xd0\x95\x7b\x4f\xee\x48\x19\x3c\xb2\x73\xfb\xce\xfd\x77\xe2\x0b\x5b\x4f\x7c\x78\xf6\xe2\x8f\x9e\xa5\xa9\xe4\xb5\x6f\xff\x4b\xbe\x58\x3f\x63\xe6\x3a\x9c\xfa\xc7\x37\xb8\xb5\x77\xa9\xe7\xbb\xb7\x5f\xfb\xe8\xe4\x96\xaa\x6a\x9d\x7a\x76\x54\xa7\x46\x63\x6e\x82\x9e\x7c\x82\xa3\x3a\x35\x55\x94\x3f\x3c\x6e\xb3\x44\x0c\xd8\xd5\xb6\x00\xb6\xff\xd8\x3d\xd3\x6a\xdc\x63\x57\xee\xf9\xe4\x38\xb0\x29\x54\xeb\x1e\x26\xbf\xa8\xee\x4e\xe5\x57\x9c\xfd\xc0\x05\xf7\x34\x75\x25\x44\x0e\x37\xe2\x74\x77\xa6\xe7\x2b\xba\x7b\x91\x4d\xd1\xf3\xa1\x7d\x2c\xda\x5d\x35\xae\x65\xeb\xc1\xae\x9d\xa5\x5c\x5b\x5f\xb9\x36\x1b\xae\xcd\xc9\xae\xef\xd1\x47\xaf\x05\xcc\x4b\xfb\xd0\x19\xb0\x42\x02\x68\x40\x0d\x51\x45\xa0\x08\xd5\xe7\xea\x70\xe6\x3a\xce\x34\x8d\xc6\x69\xe6\x1b\xe5\xc9\x19\x65\xc1\x5c\x0f\x28\x6e\x48\x36\xc9\xa9\xf2\x8b\xf2\x79\x59\x54\xf3\x72\xae\x9c\xab\xb7\xd9\x72\x00\x97\x63\x7d\x4a\xf7\xa0\xbe\x76\x51\x41\xd8\x07\xc5\x39\x39\x35\x57\x94\xae\x26\xab\x21\x83\x63\x9e\x95\x54\xeb\xf7\x46\xbe\xf0\x71\x7e\x1c\x4c\x5d\xa6\x21\x1b\xb8\x73\x96\x90\x7f\x72\xcc\xbf\x7e\xfe\xed\xb3\x23\x5f\x8d\x23\x18\xef\x3e\x75\x72\xe3\xc1\xca\x0d\x8b\x97\xad\x5b\xb5\xfc\xf1\x75\xf8\xfd\xc1\x8f\x1c\xed\x3d\x6d\xdb\x21\x21\xbb\x72\x73\x49\x51\x59\xff\xeb\xef\xbd\xff\xd5\x53\xb8\x05\xf6\xe2\xd9\x78\xc2\xf2\x59\x93\x97\x84\xde\x5a\xb7\x65\xc7\x9a\x35\x9b\xb6\x70\xcf\x14\x36\x5b\xd3\x8d\xf2\xab\x86\x30\xe6\xe9\x30\xe6\x1c\xe4\x87\x11\xdb\xdd\x26\xb9\x51\xba\x5d\x5b\x2f\x35\x35\x1b\x63\x6d\xba\x2c\x34\xce\xb7\xe8\x69\x29\x9d\x84\x20\x4e\xad\x07\x3a\x6b\x76\x3d\x0b\xfc\x15\xb3\xb2\x72\xbb\x07\xb3\x30\x2d\x53\xf6\x60\x0d\x45\x7f\x7c\x6d\x57\x7f\x0d\x9f\x75\x1b\x27\xd1\x0a\x8a\x85\x30\xb4\xe8\xee\xaf\x2e\x4d\x6d\xc9\xcf\x4c\x57\xfc\x6c\x2c\x56\x3f\xe3\x6e\xf0\x7b\x61\xfa\xe0\x25\xdf\x6f\x22\x1f\xba\x5c\x4d\x1a\x55\xb8\xc6\x74\x1b\x38\xca\xe5\xee\xd1\x6e\xe4\xd3\x83\xde\x26\x5f\x3e\x71\xe5\xd0\x1b\x57\xc5\xc1\xe1\xc5\xd3\xde\xff\x91\xfb\xe3\x73\xb2\xf6\x3c\xd6\x35\x1a\x38\xd0\xd7\xac\xd1\xca\x82\xa1\x7d\xf3\x06\x0e\xcc\x6b\xd5\x71\x07\x6e\x7a\x94\x1f\x7c\x64\xda\x96\xe3\xe4\x1a\xf9\x02\x5f\x26\x97\x67\x2f\xa2\xa7\x5c\xc0\x91\x4b\xc4\x7e\x20\x23\x8a\x02\x09\x00\xd7\xcd\x7a\x5e\xa7\xd3\xeb\xed\x0e\x83\xd6\x6c\xd6\x1b\x79\xbd\x05\xc9\xd5\x76\xbc\x92\x68\xea\xf9\x88\x6d\x57\x89\x49\x8c\xa9\xac\xb2\x72\x0e\xa6\x86\xb9\x16\x06\xb7\x1c\xda\xa4\x7f\x42\x7e\x66\x4e\xbe\x83\x1c\x78\x95\x24\xbe\x87\xa7\xe1\xc4\x46\x33\xc5\x7e\xd9\x8d\x16\x3a\x7d\xf5\x7c\xa1\x1b\x91\x53\xb1\x1d\xf8\xa3\xb2\xde\x94\xf6\xc9\x6c\xd6\x97\x2b\x40\xa3\x0b\x11\xad\x7a\xd1\x28\xb4\x30\x7a\x0e\x24\x96\x50\x3b\x1c\xfd\xbd\x59\x56\xb7\xc3\x34\xbf\x25\xdd\x49\x89\x22\xdb\x49\x6f\x1f\xf7\xb8\x8c\x7c\xf5\x4e\xa2\xfb\x08\xf8\x61\x47\x96\x57\xb1\x98\xc9\xa3\x3a\xe1\x1f\x84\xfd\x20\x0b\x69\xad\xcf\x47\x02\xf5\x92\x2c\xda\x8c\x8c\x34\x97\x24\xa5\x59\xf8\x3a\x75\x1d\x29\xc6\x14\xe0\xda\x46\xe4\x33\xf9\x38\x35\xef\xf3\x21\xb5\xd1\x91\xc0\xdb\x91\xbd\xba\x6a\xaf\x5f\x51\x53\x80\x86\x2d\xc5\x35\xc4\x93\x25\x92\xa6\xc1\xee\x8b\xd4\x51\xe3\xa3\xac\xa8\xd0\x87\xf3\xcc\xa6\x2c\xaf\x64\x36\xc5\x54\x86\x3a\xc2\xdc\xb9\xfe\xe6\x7b\x36\xbe\x9d\x27\xb8\xa7\x8d\xd9\xb0\x77\xe2\x1c\x3e\x63\xd7\xf0\xd0\x99\x61\xbb\x3b\x74\xdb\xd9\x5d\x68\xf2\x64\xdf\xef\xe7\xfd\x41\xee\x62\x6d\xe5\x93\x58\x73\xff\xa7\x0f\xab\xde\xc6\x53\xb1\xf6\xf4\x49\xf2\x5f\xb2\xf4\xb9\x1d\x78\x30\xd9\xb9\xfd\x79\xca\x5f\x0b\x60\x7c\x6b\x85\x16\xa8\x3e\x9a\x18\x48\x36\x1b\x38\x83\x00\xc2\x4a\xad\x16\xea\xdb\xb2\xb3\x9d\x59\x09\x09\x4e\xab\xcd\xe6\x14\x9c\x0d\x72\xb3\xdc\xac\x22\x56\x96\x23\xd9\xa7\x94\xee\x4f\x4e\xb4\x20\xce\x6a\xd4\x4a\xec\xf7\x5a\x23\x67\x8f\x78\xa0\xc1\x66\xac\x51\x04\x2b\xf6\xd7\x52\x1c\xf7\x91\xda\x83\xbc\x16\x73\x1c\xd9\x72\xb2\x13\x7b\x25\x00\x7a\x34\xa1\xbb\x29\x5a\x49\xa2\x39\xa6\xea\x80\xa5\x90\x1f\x11\xba\x46\xfe\xf3\xd3\xf4\xa4\xa2\xb4\x56\x9d\xe7\xcc\x2a\x48\x17\xb9\x54\xac\x9f\x30\x73\x7a\x76\xde\xcf\x81\xd6\x39\xf9\x85\x45\x43\x07\xe7\xa7\xf1\x29\x55\x5f\xe2\x32\x3c\xfa\x5b\xc3\x16\xeb\xe6\x97\xa7\x92\x9f\x3a\x72\x7c\xc2\x26\xb2\xe2\xdc\xb7\x7a\xf2\x1d\xf9\x87\x6e\xb7\xbe\x4d\xf7\x61\x86\x8d\xcf\xac\xc0\x8e\x56\x6c\x3d\x47\xc0\xf8\xe9\x19\x98\x01\x10\x06\x20\x7b\xab\x01\xf4\x28\xa3\x46\xd0\xb8\x3d\xb2\xb9\x3c\x28\x0b\xd8\x51\x11\x04\xb1\x6c\x45\x25\xef\xf9\xe3\x07\x15\x2d\x30\x4b\x71\x04\x3b\xd9\x32\x53\x58\x61\x8d\x1d\x6f\x71\xaa\x77\x3f\x55\x6a\xcb\x7e\x7a\xe9\x93\x58\x75\xd9\x3e\x78\x7b\x0a\x1e\x8c\x0b\xa2\x95\x65\xc9\x87\x64\x7b\x1a\x19\x2a\xf4\xa8\x3e\xdd\xa2\xbe\x28\x94\xe6\x00\x3b\x1b\x90\x07\xf9\x03\x1e\x7b\xb4\x4f\x09\x89\xb2\x05\xa0\x9e\x09\xbb\x80\x29\x62\x07\x4a\xac\x2e\xe9\xf7\x40\xa7\xf2\x59\x2f\x58\xc5\x64\x6b\x7c\xbe\x3f\xd5\xd9\x4b\xa1\xef\xee\xfe\xf4\xce\xeb\x1f\x3c\xbe\x65\xcb\xba\x35\x6b\x76\xae\x82\x4e\x6d\x4b\xc4\x29\xbf\x80\x62\xec\x26\xb7\xc8\x37\xbf\x93\xaf\x13\xc8\x70\xfe\xed\x4f\xff\xfe\xd1\xb5\x8f\xfe\xf9\x09\xd0\xc8\x24\x76\x3e\xda\x0f\x30\x41\x51\x20\xc9\xc4\x3b\x9c\x1a\xb5\xda\xc9\x03\x20\xb0\xa2\xf2\xa0\x55\x63\xd5\x48\x4e\x8b\xa4\x2f\x0f\x4a\x42\xb4\x48\x48\x71\xed\x0a\xca\x98\x9e\x0a\xd7\x76\x77\x29\x34\xfb\xb8\xc6\x5f\xdc\xc4\x69\x77\xf7\xff\xd0\xe6\x40\xd6\xf6\x51\xbb\x9e\xdf\xf3\x42\x93\x06\xe7\x70\xa2\x1d\xeb\xef\xfd\x81\x1b\xec\x3d\xd2\x72\xda\xbc\xb7\xce\xbe\x7d\x56\x43\x5a\xd2\xda\xb4\x30\x2f\x05\x30\x2f\xf5\x50\xe7\x80\xd1\xa1\x06\x2e\x83\x52\x53\x33\xd5\x7c\xfd\x06\x42\xa4\x4a\x9b\x60\x12\x4c\x3e\x9d\x2f\x5b\xf9\xe6\x4b\x64\x55\x2b\x4d\xb5\x3d\x50\x6b\x5a\x03\x45\xa6\x4a\xf0\xf9\x35\xbd\x71\x92\x39\x45\xd9\xa0\x90\x20\x9f\x29\x43\x7c\xdf\x06\xfd\xc7\x6e\x3d\x34\xb2\x00\x0b\xbf\xbc\xf4\x63\xea\x79\xd3\xfc\xa9\x3b\x37\x14\x0e\x5b\xdd\xa7\xc5\xcc\xf2\x26\xdf\xdc\x1a\x71\xac\xf1\xac\xad\x1d\x17\x2f\x9e\x9e\x5d\x98\x6e\x75\x97\x4d\x3f\x32\x19\x9b\x71\xf2\xc1\xad\x86\x7e\x63\x2e\x7d\x3e\x6e\x6e\x7b\x9f\x45\x9f\xda\x62\x78\x8f\xad\x7b\x92\x1d\x07\x72\x92\x58\x9d\xec\x8b\x30\xaf\xcd\x99\x8f\x05\x60\x2d\x8d\x8a\xc7\xb2\x92\x53\x4a\xa7\xa7\x87\x70\x02\x66\xc9\x63\x61\x8a\xd5\xbc\xca\x52\xbb\x38\x75\x71\x71\xdc\x4e\xc2\x66\x2f\xef\xcb\x67\xc7\x73\x76\xbc\x80\xdb\x87\x5f\x26\x96\x73\xfc\x6c\xe1\x20\xb1\x90\xb5\x1f\x86\xbe\x62\x67\xd5\x18\xab\x01\x93\x7a\x58\xdd\xd8\x40\xc0\xc0\xa9\x54\xa2\x20\xa8\xb5\x6a\x2d\x2d\x1a\x4b\x27\xcc\x18\x14\x39\x91\x53\x6b\x34\xb8\x2c\xa8\x31\xaa\x13\x1e\xf2\xc8\x58\xe9\x58\xcc\x1c\x37\x94\x47\x0a\x9e\xd0\x5e\x2e\xe7\x69\x32\xe5\x38\x6f\xe6\x8f\x00\x96\x7f\xe9\x74\x55\xb9\xf8\x6f\xc5\xdf\xfa\xf7\xf0\x8f\xc2\x0f\xe2\x7b\x28\x1b\x75\x0a\xa4\xd7\x75\x38\x32\xdd\x66\x84\x0c\xbc\x9b\xcf\xa9\x67\xce\xae\x6b\xcf\x86\xbf\x69\xda\xb4\xa4\xf2\x60\x1a\xd6\xc2\xa0\xb5\xd6\x07\x84\x9f\xd9\xff\x60\x56\x5f\xca\x25\xaa\x35\x6a\xe0\x0e\x92\x4c\xdd\xa3\x2d\xf9\xb1\x7a\x4a\x79\x8c\x89\xca\x58\xe8\x93\x51\x52\xd2\x34\xa5\x69\x7a\xa0\xe7\xc2\x65\x29\xf6\x25\x3f\xdf\x5c\x93\x94\x1a\xb0\xd5\xcf\x4a\x6d\x02\xbf\xea\xf7\x68\x5e\xb2\x85\xfb\x56\x28\xdd\x40\x9a\x6f\x18\x36\xce\xb8\xcb\xb6\xe7\xe8\x54\x6c\x1d\x3e\x68\xfb\xc6\x11\xda\xb9\xf8\xd6\x73\xbd\xba\xd5\x87\x5f\x76\x7c\xa2\x72\x3a\x79\xa7\x0f\xfe\x4e\xc1\xa4\xb3\x98\x7d\x6a\x01\x52\xa3\xf4\x80\x59\x25\xf2\x48\xa4\x95\x48\x84\x1e\x41\x95\x8a\xba\x93\x95\xbc\x51\x9c\x1b\x7f\x70\x0a\x50\xdc\xea\xcd\xc7\x7e\xde\x2b\xf4\x20\xb7\x2f\x7e\x17\x72\x60\xdb\xc5\xef\xb8\x5b\x5c\x55\x48\xe0\x56\x34\xe2\xde\x08\x29\x71\x3e\xa8\x0e\x09\x0a\x8f\xc1\x3e\x4b\x46\x43\x03\x8d\xcd\x06\x9d\x5a\x50\x39\x9d\x2e\xa3\x89\x17\xa0\x79\xea\x75\x63\x72\x89\x29\xa9\x5a\x8d\x4e\x6d\x32\x1b\xd4\x1a\x83\xd1\xa9\x31\x3a\x9d\x46\x0d\xcf\x27\x24\xd8\xca\x83\x09\x42\xc4\x55\x89\xc5\xd2\x31\x88\x1b\x89\x57\x34\xd7\x2c\xeb\x69\x66\x01\xef\xd8\x84\x44\xd0\xa4\x2d\xcd\xb1\x98\x85\x33\xb3\x70\x16\x56\x64\x2f\x33\x93\x09\x16\xe1\x31\xe0\x5a\xcf\x15\x5e\xfe\x62\x24\x29\x6f\x8e\x3f\xb2\x64\x93\x86\xcd\xf1\x87\x9d\x9e\x1e\x35\x64\x5f\xe9\x94\x51\x37\xd6\x9d\xc6\xc9\xdb\xf0\x07\x64\x3b\xe9\x3e\x6c\x73\xfb\x0b\xd8\x7c\xd2\x1b\x9e\x83\x1d\xf3\xc6\x93\xdb\xf0\x36\x7b\xd8\xc8\xa9\xe3\xd6\xcd\xfc\x81\x0c\xa2\xe3\xb2\x91\xde\x82\x47\xfc\x3b\x60\x83\xb2\x40\x1d\x8b\xde\xa0\x52\xcb\x1a\x9d\x51\x30\x8b\x22\x42\x6a\x83\x59\xb0\x3b\xd4\x2a\x59\x63\xd0\x19\x35\x2a\xa3\xde\xa2\xd2\xab\xf4\xbc\x45\xc9\x98\x5b\xfc\xf0\x71\x44\x82\xfc\x80\xd5\x65\xd8\x78\x99\x9a\xaf\xc4\xac\x8c\x4c\xfa\xc2\x65\x14\x0a\x48\xf0\x34\xb8\x58\x58\x8f\x6c\x6f\x87\xe7\xd5\x6f\x4f\x16\xb7\xc7\x13\x3f\x22\xfb\x8e\xe0\xed\xf8\xec\x98\xeb\x84\x14\xe0\x84\x5b\xef\xaf\x7b\x6e\xf5\x99\xe9\x93\x4e\xaf\x79\x19\xab\x0e\xf7\x7a\x23\xa4\x9c\x5b\xf7\x82\xfd\x31\x11\xf6\x63\x5d\xe8\x67\x96\x46\xcd\x59\xad\x16\xaf\x45\x9d\xe5\xf1\x24\xa8\x13\x40\xcf\xe0\x44\x8f\x45\xcd\x7b\xd3\x2a\x82\x5e\xd1\x69\x10\x0d\x00\x67\x44\x6b\xb4\xfc\xa3\xe9\x0d\xa6\xfe\x32\x67\x99\xb8\xa3\xf9\xa8\x58\x17\xd3\xb2\x22\x9a\x77\x2d\xc3\x9f\x1b\xfb\x59\x31\x77\x6f\xbe\x97\x55\x87\x96\xf8\x94\xe5\x2d\x52\xa7\x76\xdd\xfc\xc4\xde\x92\xb2\x8e\xad\xf6\x34\xef\xb0\x71\xcf\x23\x2f\x6f\x09\x5d\xe0\x4a\x56\xcf\xe1\x03\xb6\x67\xbb\xf4\xff\xf8\x9f\xfc\xc1\xaa\x91\xdb\x9e\x58\xb8\x8c\x7f\xb9\xaa\xff\xba\x65\x38\x81\xdf\x7b\xdf\xfd\xfa\x67\xa3\xd7\xef\x78\xc5\xff\x38\xab\x0f\xdd\x57\x18\x0a\xfb\xbc\x1e\xea\x16\xc8\x4a\xf7\x25\x20\x54\xcf\x50\xcf\x67\x53\xa9\xd4\x3e\x75\xfd\x06\xf6\xc4\x94\x7a\x2a\x9f\x51\xa8\x93\x52\xa7\x2c\xe8\x4a\x71\x18\x8c\x65\x41\x43\x42\xdc\xf9\xea\xff\x18\x06\x8e\xeb\xbc\x14\xeb\xb3\x52\x8b\xde\x57\x7b\x80\xdc\xe9\x46\x2d\x03\xdd\x0e\x7e\x71\x33\x74\x93\x4b\xd9\xba\x04\xfb\x86\xb7\xed\xdb\xc7\xca\xd5\x99\xd0\x6b\xda\x88\x03\x8d\x5a\xb6\xea\x2a\x34\x09\xf5\xd8\x3a\xfb\xfc\x3e\xae\xfc\xfe\xb5\x9b\x9f\x3e\xf9\xe4\x9e\x45\xc1\xd2\x8a\x61\x63\xfa\x1d\xf9\x90\xfb\x90\xfe\xcf\x81\x03\xdc\x14\xba\x2e\xe3\x99\x9f\x42\x3f\x90\x86\x25\x01\xaf\x60\xd3\xd0\x8c\x38\x1e\x1b\x9f\x90\xe8\xe4\xca\x83\x4e\xc1\x68\x66\xa2\x9a\x3a\x58\x18\x2c\xa0\x3f\x97\x44\x05\x50\xed\x2a\x8c\x54\x0c\xf9\xd2\x94\xee\x29\x95\xaf\xab\x13\x26\x39\xb9\x11\xc5\x6d\x5e\x7b\x7c\x6e\xd7\x03\x6d\xce\x9d\x7b\xe6\xc0\xbb\x37\xcf\x1d\x69\x3f\xb2\x81\xb0\xa2\x31\xf9\x78\xd3\xde\xdc\x1c\x6e\xf5\x9f\x67\x38\x57\xef\xbb\xd7\x3e\xfb\x25\x2b\x93\xf6\x69\x55\xa4\x4f\x89\xc0\xbb\x53\x2d\xb2\x1b\xa1\xc4\x44\xbd\xcc\x27\x25\x0b\xb4\x22\x24\xb0\x59\x8f\xa0\x41\x1a\x63\x8f\xa0\x46\x88\x15\x4d\x8e\xa1\xf9\xf8\x2e\x79\x23\x29\x7b\xa8\x85\xc4\xa9\xd4\xb0\xb6\x29\x07\x79\xf0\xff\xfc\xd4\xa2\x63\xcb\xce\xbf\x8c\xdd\x1d\x02\x4d\x9a\x4f\xcd\x7d\xb4\x62\xe5\x91\xe3\x5c\xdd\xfe\x65\x2f\xbe\x87\x0b\x71\x1d\xd3\xb3\xf6\x0d\xe4\xcf\xc9\x13\x1a\x3f\xff\x14\xfe\xcf\x9f\x67\x18\x0d\xef\x81\xb5\x1f\x0e\x34\x9c\x84\x9a\x06\x92\xcc\x7a\x7d\x92\x41\x76\x1a\x9c\xc9\x29\x66\x9b\x4d\x53\x1e\xb4\xd9\x0c\x46\x3e\x09\x44\x4a\x92\x01\x24\xca\x5b\x91\x8a\x5e\x35\x0c\xd4\x8a\x1d\xd6\x9f\xd7\x82\x57\x8a\xfe\x30\xf7\xbc\x68\x01\x6a\x4a\xa8\x7b\xaa\xb6\xac\x7e\xb4\x73\xdd\x8d\x2b\xd7\xac\x3b\x77\x6e\xd0\xaa\x76\x5f\xdd\xe9\xb2\xe6\xa7\xf7\xc9\xc7\xe4\xc7\xb4\xae\xcb\xae\xae\xff\xd7\x77\xfd\x42\x65\x62\x5b\x22\xfb\x33\x00\xdd\x7c\xf2\x26\xf9\xf6\x44\x39\x60\x9a\x64\xd0\x8b\xf2\x85\x4d\xa8\x0e\xe8\x45\xfd\x03\x16\x40\x95\xf5\x32\x92\xd4\x6a\x99\x4b\x69\x94\x21\x35\xce\x77\x9a\xa9\x04\x4a\x09\xe6\xa6\x95\x05\x39\xb9\x51\x8a\x90\xeb\x84\xbf\xc8\x66\xd7\x25\x80\x04\x77\xa0\xba\x54\x49\x34\x45\xba\x1c\xc3\x18\x66\x67\xbc\x1e\x18\x71\x4e\x73\x16\x80\x58\x90\x1d\x76\x6a\x7a\xa2\x76\x7f\xbb\x8f\x45\x9e\x31\xbf\xd4\xc8\x26\x6c\xdc\x02\x3b\xa3\x18\xa4\x01\xe6\x72\x0e\x54\x36\xf6\xcd\xe9\x90\x31\xe7\xbf\x3f\x75\x18\x55\xda\x2c\xa9\xd5\xe6\xa9\x03\x7b\x95\x0f\xea\x8d\xbd\x05\xe5\xff\x18\xbf\x6c\xd3\xb8\xd7\x66\xcf\x5f\xd7\xa1\xe5\xb1\xbd\xbe\x71\x42\xb7\xb2\xd2\x8e\x03\x1e\xcb\x5b\xf7\x0d\xf9\x85\x7c\x91\xec\x4b\xee\x3c\x7c\x56\x5e\x1e\xde\xbd\xaa\x77\xf9\xf0\x49\x33\x83\x2b\xda\x2c\xeb\xde\xae\x71\xe1\x2b\x69\x8c\x46\xfa\xc1\x98\xc7\x03\x8d\xd4\xa3\x9a\x42\x5a\x96\xc6\x6e\x30\x26\x21\x64\xb4\x67\x09\x0d\xea\x6b\x92\x2c\xd9\x28\xc3\x94\xc1\xe9\xf9\x8c\x8c\xec\xec\xd4\xf2\x60\xb6\xd5\x60\xb0\x58\x74\x15\x41\x8b\x10\x3b\xf9\x8b\xf7\x1f\xae\x7d\xea\x67\x6d\xdc\x82\x2b\xa4\xab\xe4\x4d\x8d\x55\x66\x32\x60\xd9\xc0\x44\x23\x1d\x6b\xa1\x83\x95\xd9\x4c\xef\xe7\x2f\xdf\xbd\xbb\xed\xfc\xa1\x4d\xc9\xd7\xe4\x6e\xfd\x93\xb9\x3f\x5e\xfb\xf2\x4e\xaf\x13\x2f\x3c\xb7\xb0\xd3\xc1\x3d\xb8\x47\xfa\x91\x3c\xf2\xf5\xbd\x3f\xc8\x3d\x3c\xae\xfb\xfc\x41\x9d\x32\x4d\xa9\x79\x5d\x9a\x7d\xfc\xb1\xf7\xc8\xe6\x33\xcf\x0d\x5e\x33\x24\x33\xb3\xc5\xa0\x0e\x93\xe6\x62\x6b\xc7\x47\x8a\xc6\x0c\x79\xf3\x87\x4b\x30\xae\x61\x30\xae\x9e\x30\xae\x3a\xa8\x43\x20\x25\x4d\xb4\xda\x8c\x1e\x0f\xb2\x89\x42\xdd\xec\x34\x23\xe7\xb4\x5a\x9d\x4e\x73\x19\xec\xcb\x3a\x75\x38\x2e\x83\x15\x87\xe7\x1c\xb5\x46\x54\x6b\x38\xc0\xc7\x61\x27\xa6\xe7\xff\xaf\x11\xc1\x96\x15\xda\xdd\xba\xf7\x1f\x72\xf7\x2f\x87\x73\x78\xe7\xcc\x6b\xb3\x0b\x3a\xbd\x75\xe6\x2f\x07\x32\x65\x76\xa6\x4f\xb1\x2b\x6a\x98\x7f\xec\x26\xe4\x45\xe9\xc0\xed\x73\x9c\xae\x34\x43\xb2\x51\x93\xee\xa3\xf9\x50\xb4\xe9\x06\x97\x98\x91\x29\x59\x3d\xd4\xb9\xcd\x99\xae\x31\x26\x3b\x45\x3d\xf2\xe8\xd3\xca\x83\x7a\x8b\x72\x32\xa7\x04\x9a\x3f\xa4\x0a\x74\x84\x08\xe5\x2c\xe6\x03\xcd\x53\x7f\x14\xc5\x36\x07\x23\x61\x8a\x4e\x0a\x2e\x6c\x81\xb1\x97\xe7\x8f\xec\x9e\x36\x26\xb5\x49\xa0\x6e\x23\xdb\x1c\xdc\xb4\xea\x25\x5c\x30\xc7\x9a\x57\xd7\xd3\xa0\x5e\xe6\x98\x69\xfb\x06\x3c\x56\xaf\x7d\xfb\xcc\x69\x20\xac\x3e\xf9\x49\xdc\xf4\xd6\xb0\x86\x3d\x33\x1b\x90\x4f\x42\x29\x6b\xd7\x72\x5f\xe2\xec\x06\x99\x9e\xdc\x26\x43\xdf\xea\x3f\xe5\xfc\xf9\x51\x23\xee\x6b\xb9\x0e\xca\x98\x80\xd1\x0b\x2f\x09\x2d\xe1\x93\x0f\xf5\x0c\xb8\xdc\x1e\xc0\x85\x16\x3d\xe2\x0c\xb2\x44\xa3\xd1\x3c\x62\x7a\x86\xc6\x91\xe4\xa0\x3b\xcd\x12\x94\xdd\x6e\x18\x8b\x60\xe2\x93\x8c\x26\x00\x7c\x26\x7b\xf4\x08\xed\x7f\x8d\x8b\xf7\x5b\x29\x46\xa6\x63\x93\x79\x2b\x0c\xcd\xca\x86\x66\xc4\xca\x72\xc1\xd0\x0a\xb8\x51\xe3\xae\xbf\xdd\x65\x4d\xd1\x28\x6f\xab\x66\x5d\x32\x66\x1e\x0c\xdd\x7f\x76\x96\xbd\xc8\xd7\xac\x65\xda\xa8\xa2\x35\x5d\x86\xcc\x4c\x2f\x2a\xee\x84\x37\x90\x10\xff\x62\xc5\x80\x09\xfe\x21\x83\x80\x49\x8c\x7b\xf2\x49\xbc\x0e\xfb\xf3\x33\x87\xf8\x27\x0c\xa8\x98\x36\xee\xf0\xe1\xaf\x14\xdd\x8c\xf9\xab\xb5\x05\xdc\x90\x42\x39\xbf\x29\x21\x41\xb4\x23\xa4\x11\xf9\x54\xaf\xc5\x55\x11\x34\x59\x2c\xbc\x5a\xad\xa3\xf8\x98\x4f\xaa\xa8\xed\x85\x58\x8b\xcd\x52\x27\x44\xaa\x9a\x15\x50\x53\x38\x5d\x0b\x6a\x15\xe1\x15\xcd\x88\x99\xe7\x47\x90\x5f\x7e\x25\xf8\xd1\x6f\xde\xc3\xa5\xe4\xad\x99\xf3\xcb\xcc\x33\xdf\xfd\xfe\xcf\x4b\xeb\xf6\xef\xdb\x84\x8b\x76\x6d\xe1\xf4\x24\x44\xfe\xcd\xf5\xc4\x1a\xdc\xeb\x99\x8d\x4d\xe6\x8f\x5b\x0e\xdf\xc9\xc5\x57\xce\x5c\x20\x23\xde\xa4\x7b\x9d\xda\xba\x1e\x01\xdd\x24\x0d\xe4\x81\xdd\x2c\x39\x01\xae\x25\x4b\x82\x2f\x3d\xd5\x53\x16\x4c\x4d\x85\x7e\xea\x15\x9d\x44\x6d\xe2\x6d\xf1\xe7\x07\xb1\xf3\xdd\xea\x33\x04\x81\x9d\xed\xa2\x8c\x02\xbf\x5d\x8c\xd2\x3e\xe3\xc5\x46\x9c\x4f\x09\x48\x78\x84\x84\xbf\xfe\x29\x04\x12\xa0\xe5\xb6\xb9\xe4\xb3\x0b\xcf\x74\xda\xb1\x6b\xc3\xa6\xca\x1d\x1d\x9a\xe6\x4e\x19\x7e\xfd\x0a\x9e\x75\xe6\x6f\x38\x1d\x3b\xa0\xab\x46\x8d\xb8\x49\x56\x95\x3d\xff\xf4\xe5\xbf\xaf\x9c\x3f\x7d\xbc\x56\xb5\xd4\x79\x22\x22\x4f\xcb\x99\x3f\x58\xab\x40\xaa\xc1\x6a\xd5\x00\x0e\x73\xab\xd5\x0e\x8d\x26\x31\x89\x33\xab\x74\x76\x98\x53\xb7\xd9\x6e\xd7\x38\x79\x8d\x45\x39\xbf\x2f\x8e\xb8\xb7\xc5\x0e\x17\xe2\x5c\x52\x80\xac\x59\x31\x45\x9f\x99\x1a\x98\x9c\x32\x8d\xa2\x62\x69\x1d\x53\x85\x72\xeb\x7a\xc3\xd6\x51\x67\x47\x6d\x31\xac\xb7\xe2\xe2\x8a\xb3\x43\x70\x11\xdf\xa9\x55\xcb\x94\xa2\xa4\x85\x55\xad\xf9\xd7\x16\x26\x15\xa5\xb4\x6c\x85\x4d\x3f\xfc\xc0\x64\xd7\xb2\xf0\x2f\x42\x3b\xf1\x1f\xc8\x8c\x8a\x03\x09\x1c\x32\x99\x68\x6a\x20\x8b\xd5\xa8\xd3\x60\x59\x23\x83\x04\x50\x73\x26\x8d\x91\x32\x13\x56\x6f\x56\xc1\x5d\x6f\x45\xd3\xdc\x47\x4c\x62\x5e\x73\x06\x4d\x15\x2e\x53\x57\x45\x91\x26\x63\x10\xda\x91\xd9\xe4\xc7\xe1\xe4\x93\x4e\x2e\xbc\x02\xb0\x3d\x5e\xc2\x3f\x5f\xd5\x7a\x58\x22\xdf\x7c\x03\x4e\xc5\x4f\x0f\x4b\x20\x5f\x52\x3b\x08\xac\xdf\x53\x42\x0b\xe0\x06\x9d\x02\x56\x35\xe6\x38\x83\x00\x32\x2a\x31\xd1\xeb\x14\x9c\x19\x99\xc9\xd4\xf8\x71\x32\x98\xec\x40\x11\x83\xc7\xcb\x41\xad\xd1\xcc\xb1\x53\xd5\xea\x6a\xa8\x71\x45\x27\x95\xce\xfc\x2f\x0b\x47\x4c\x75\xf9\x4b\xc3\x46\xe4\x17\xff\xcb\xa8\xc1\x7e\x11\xb3\x65\x2c\x64\x67\x81\xa5\x28\x15\x24\x4e\x87\x80\xd1\x90\x95\x85\x9c\x0e\x87\x57\x85\x54\xf5\x1b\x24\x58\x28\xfd\x59\x83\x09\x09\x5a\x67\xa2\x36\x1b\x20\x9f\xd6\x2e\xa6\x97\x05\x45\x53\x14\xf9\x45\xb1\x40\x8d\x71\x50\x31\x63\x51\xa4\x3f\x3b\xca\xc9\xa2\xc9\x58\x92\xb1\xd3\x47\x25\x6b\x03\x1e\xc7\x99\x16\x16\x16\x3c\xf6\xea\xf2\xff\xde\xfe\xfd\xb7\x89\xfb\x5a\x48\x03\x9f\x7f\x71\xf3\xb2\x80\xbc\x53\x4a\xef\xb6\x7a\xc9\xa9\x99\xad\x41\x97\x5e\xb6\x63\xe7\xaa\x27\x36\xef\x5d\x81\x07\xff\x82\x55\x7b\x7a\x90\x5f\xc9\x77\xe4\x27\x72\xab\x6b\xe9\xb2\xdd\x1d\xd3\x7b\xf5\x73\x38\xd4\x2d\x1e\xdd\xf1\x16\x5e\xf3\xd9\xdb\xef\x7c\xfa\xc1\xdf\xde\x8d\xd8\xb0\x8b\xd8\x19\x6c\x3b\x66\xbf\x9b\x4a\xfa\xf0\x6d\x58\x4d\xc9\xae\xa8\x86\x3f\xab\xb0\x99\xd1\xcf\x42\xa0\xeb\x42\xc0\xbd\x56\xd4\x3d\x90\xab\x37\x99\x8c\x34\xfb\x24\x60\x08\xbd\xa9\x2c\xf8\x82\xfe\x0b\xfd\x1d\x3d\x6f\xd4\x5f\x85\x0f\xbc\x96\xd7\xeb\x41\xdb\xd6\xd0\x83\x33\x6c\x01\xc0\x66\xff\x4b\x0f\xdb\x88\x71\xb2\x2e\x66\x9b\x92\x71\x0f\x89\xe6\x83\x37\xd5\xc5\x42\x21\x49\xfa\xfa\x47\x14\xbe\x89\x3f\x22\x99\x4f\x3e\xc5\xcd\x0f\x2d\xc0\x3e\x7c\x0d\x1b\x69\x4e\x71\x9c\xb5\xe2\xf9\x6d\x8b\xc9\x61\xe8\xd7\x26\xea\x23\xcc\xce\xcf\x1e\x09\x34\xd4\x8a\xc8\x24\x0b\x82\x09\x99\xec\x0e\x49\x84\x8e\x49\x5f\x48\x77\x24\xde\x28\x5d\x85\x0f\xd0\x31\x49\xb2\xe9\x40\x51\x0a\x02\xf4\xd1\x32\x5b\xe2\x5f\xbb\xfe\x82\x14\x05\x15\xa8\x90\x9e\xac\x01\x14\x87\xa5\xa0\x80\x9c\x2d\x94\x77\x13\xbe\xb6\x6a\x63\x68\x01\x37\x7f\xc3\x2a\x92\x89\xaf\xdf\xfe\xb1\xea\x06\x81\x0e\x3d\xbb\x78\xcf\xb3\x2b\xc8\x3d\xf2\x27\x09\x93\x7f\xa0\x9a\xbe\xbb\xbb\xd8\xf7\xd3\x40\x43\xad\xd8\x1c\x9f\x67\xdf\x27\xc1\x1c\x4f\x63\x3e\xc3\x99\xca\x1e\x85\xeb\xdb\x32\xdf\xde\x40\x20\x45\x25\x8a\x12\xcf\xd1\xa0\x58\x9d\x4e\x2d\xf1\x7a\x03\x16\x04\x59\x4d\xb3\x63\xc9\x3c\x92\x2c\x4a\xdc\x18\x0b\x0c\x37\xd7\xf2\x26\x55\x90\x2f\xef\xe3\x29\xbc\x4c\x00\x1d\x88\xdf\xf2\xdd\xd2\x3f\x0f\xdd\xff\xf1\xcb\x7b\xc2\x9a\xd0\x75\x2e\xfd\x3e\x28\x62\xa1\x6f\x39\x37\x83\xb5\xf0\x5c\x6a\xa7\x1b\xc9\xe6\xb0\x59\x20\x59\xa7\x56\x6b\x44\xc1\x68\x41\xc8\x66\x03\xf5\xd7\xee\x80\x59\xb3\x68\x8d\x9a\x44\x23\x08\x08\x3b\x73\xbb\x28\xf1\xff\xc5\x33\x4b\x30\xac\x11\x3b\xef\xa6\x45\x57\x0b\x0a\xad\xf0\xec\xf7\x79\x91\x7c\xb5\x85\x7c\x26\x6d\xfd\xf3\x52\xbe\xd1\xd1\xe0\xd2\x1d\xee\xef\x93\xa7\x54\xb5\xe7\x4f\x6e\x6f\x7f\x7f\x91\xf8\x55\x68\xfe\xc1\xc7\x77\xae\xe7\x16\xdc\x7f\x8b\xed\xb3\xce\x91\x33\x77\x0f\xca\x02\x6e\x91\x95\x06\x0a\x89\xd5\x08\xc2\x57\x67\xe4\xeb\xd4\x75\x26\x03\xf6\x31\xe9\xcd\x16\xc0\x40\x1a\x90\x50\xc6\x44\x3e\x23\xfe\x04\xde\x12\xf1\xae\x8d\x57\x4d\x62\xfe\x18\xca\x61\x7c\x12\x2d\x97\xa4\x64\xc7\x8d\x3b\x94\x8f\x79\xf8\x09\x3d\x3f\x3a\x33\x7e\x57\x40\x10\x68\xc9\xec\xe3\xb3\x66\xfd\xfb\xc3\x15\xff\x9c\x7a\x61\xdb\x8a\x79\x53\x0b\x0f\xf4\x9d\x3a\x9e\x13\xfe\x4b\x6e\xb4\xe9\xdc\xac\x64\xee\xb2\xfd\xfb\x97\x71\x17\xff\xc4\xa6\x35\xe4\xde\x81\x4f\xbe\x3b\xfd\x01\x79\xbd\x6d\xe9\x05\xe5\x7c\xa8\x0f\xac\xeb\x00\xba\xae\xb8\x43\x8d\x75\xce\xa4\xeb\x6c\x96\x81\x07\xb7\xe0\xac\xc8\x1d\x30\x63\x57\xc0\x64\xee\xe0\x0a\xe8\xf5\xf0\xa2\x56\x77\x70\x21\x33\x8b\xa2\x89\x6b\x23\x93\xb6\x41\xef\x09\xff\xfd\xff\xbc\x87\xc5\x28\x48\x07\xe0\x39\x75\xd8\x3d\xad\xc3\xa7\xd1\x5d\x64\x3f\x8e\xcd\x62\x26\x3e\x15\xde\x71\xdc\x60\xc6\xda\xb8\xf3\x26\xe5\xfa\x81\xb1\xeb\xc7\x00\x05\xfc\x9b\xd9\xec\x75\x8a\xcd\xfe\xbf\xc7\x4d\x06\xa4\x89\x3b\xfd\xc2\x30\x9e\xdb\xc2\x13\x40\xa3\x69\xa8\x6f\x20\x97\xd7\xb8\x9d\x66\xb3\xcd\xa2\x49\xb5\xa4\xfa\xd2\x13\xa9\xd6\x9e\xf8\x62\x22\xa7\xe3\x13\x13\x91\xdd\x65\xb3\xdb\xca\x83\x76\xde\xc2\x4e\x27\x04\x01\x58\x47\x49\x5e\x6e\xcc\x87\x83\x9d\x1c\x46\x2b\xbe\xc5\x56\x8a\x5a\xdc\xc4\x68\x51\x29\xd0\x7f\xa3\x6a\x12\xf5\x59\xf3\x32\x55\x09\x56\xd0\x26\xf1\xc3\x4b\x17\x7a\x87\x27\xb5\xac\x5f\xaf\x59\x59\xc5\x94\x37\xcf\x92\xcf\xf8\x42\xf2\xdc\x82\x65\x45\x27\x5e\xdc\x6a\x2b\x6b\x31\xd9\xef\x1f\x31\xfe\xed\x59\xe3\xf2\x42\xd9\xd4\x4f\x9f\x9c\x4d\x77\x1e\x7d\xf5\xc6\xe1\xb3\x30\x66\x16\x8f\x22\x1d\xb4\x64\xf2\x6d\xd9\x98\xa7\xa1\x19\xe8\x1e\x3b\x65\x93\x60\x92\x02\x92\x1a\xf3\xb1\x53\x36\x3a\xde\xc8\xda\x21\x17\x5a\x17\xa8\x70\x49\x5a\x07\x80\x0f\x93\xd1\x28\x4a\x5a\xc9\xed\x41\x7a\x93\x3e\x15\x18\x9f\x2a\x45\xc5\xe9\x45\x07\xaa\x08\xe6\x3a\xca\x1d\x9c\xd1\xb1\xda\xf1\x82\xe3\x9c\xe3\x0b\xc7\x1d\x47\xd8\x21\x3b\x79\x87\x43\xa5\xd7\x03\xde\x35\x99\xf4\x82\x0a\xf4\x6a\xea\xeb\xd5\x50\xac\x10\x27\x8a\xf0\x56\x29\x7e\x20\xde\x10\x69\x2e\x5b\x2b\x0b\x07\x9c\xc4\x44\x46\x6e\x3c\x57\x42\x91\x28\x96\x9a\x95\x97\x81\xaa\x2d\x5e\xea\x9e\xc8\x79\x53\x11\xa8\xb8\xa9\xd6\xc8\x09\x8f\xd7\x8e\x9b\xda\x71\xdb\xe1\xfb\x8a\x77\x6e\x24\x2f\x91\x3f\xc8\xd7\x9c\x0b\x3f\x32\xff\x40\xc6\x8e\x91\xbb\xf6\x6b\xf0\x61\x6e\x30\xc9\x7c\x7c\x6d\x4b\xb2\x02\x8f\xc1\x8f\x70\x47\xc9\xd1\x96\x93\x16\x7d\xf5\xfd\x5a\x46\xab\xdd\x60\xbc\xa3\x18\x4f\x2a\x78\x68\x1c\x88\xe2\xa3\x3d\x30\xce\x47\x1b\x03\xcd\x54\xfb\x68\xe3\x87\xf8\x68\xbf\x18\xbe\xcd\x7f\xc6\xda\xa8\xaf\xc4\x7b\x85\x7f\x16\x8e\x02\x0d\x79\x00\x4b\x77\x09\xd4\x95\xec\xce\xd4\x54\x21\x01\x09\x76\x3d\x12\x32\xd2\x9d\x29\x15\x41\xa7\x53\xb0\xdb\xa5\x0a\xa0\x1e\xad\xa9\x22\xa8\xb5\x0a\xa9\x15\x41\xc1\x52\x1d\x62\xfe\x00\xb6\x8b\xe2\x25\x89\x62\x25\x5e\x83\xa5\xc8\x11\x47\x0b\x6c\xb1\x7a\xcd\x4a\xd2\x66\x25\x1c\x40\x38\x7a\x65\xf7\x97\x2f\x27\x39\x4a\xa6\xcc\xc8\x4f\xb4\xa6\x36\x29\xce\x4a\x2d\xc0\x3f\x64\x1f\x7e\x7f\xcf\xb4\x7e\x8d\x8a\xfb\x8d\xc7\x8f\x3f\x77\x5d\x38\x4d\x7a\x92\xe7\xc9\xc9\x85\x9a\xc5\x72\xcb\x9d\xd8\xce\x5d\x0b\x9d\x7f\xef\xe8\xd8\xa5\xc4\x46\xe3\xe4\x51\x7b\x98\x03\xda\x7f\x0b\xa0\xbc\xae\x81\x4c\xec\x72\x99\x01\x83\x5a\x45\x13\x3d\x95\x13\x13\x93\x9c\x5a\x93\xb6\x22\x88\x01\x63\x21\x35\x60\x69\xbd\xda\x62\x40\x3c\x8b\x84\xa9\xc6\xcf\x35\xdc\xd6\xaa\x9d\x36\xcd\x91\x13\xd6\xea\xd8\x3d\x1c\xed\x38\x77\x7d\xc0\xe1\xf7\xaf\xec\x26\x3f\x92\x93\xbb\x77\xe3\x8e\xf8\xf3\x69\xfd\x86\x3e\xda\x6f\x3c\xb0\xf2\xf3\xef\xbd\xf0\xdc\x75\x6e\x66\x68\x19\xfd\xcc\x05\xaa\x5a\x45\x7a\x8a\x94\xb3\x43\xb6\x5f\x1d\x94\x9b\x1a\xf5\x20\x97\x55\xc8\xa1\x72\x38\x5d\x16\xa1\x3c\x58\x69\xc1\xc8\x82\x75\x74\x8b\x6a\x0d\x1a\x1a\x32\xa3\x8d\x06\xed\xc4\x6f\xd1\x49\x35\xf7\x28\xe5\xf4\x0f\xd9\x97\x76\x33\x7f\xa5\xf6\x66\xe4\xbc\xb5\x36\x61\x88\x62\x8f\x03\xd0\xa7\x1d\x6c\x0f\xbe\x13\xd9\x83\x7d\x22\x7b\xd0\x06\x7b\xd0\x63\x73\x22\x5d\xf5\x1e\x8c\xc6\xfd\x48\xdb\xe1\xfa\x4b\xec\x6c\xb1\x15\x7a\x0f\xfe\x03\xf8\x9a\x95\xf1\xb5\xfd\xc7\x4d\x56\xac\x8a\xe3\x6b\x36\xa0\xe1\x13\xac\xfd\xbf\xd1\xeb\x55\xdf\xc0\xd5\x4a\xfb\x76\xb8\xc1\xe8\x4c\xd1\x99\x6a\xec\x71\xea\x73\xd8\x90\x9d\x15\x34\x0e\xb8\xb5\xb0\xc2\x92\x5a\xe4\x38\xb5\x4e\x2f\xf3\x3c\xad\x10\x50\x1e\xe4\x2c\x28\x21\xea\x44\x55\x52\x33\x70\x86\x9d\x10\x98\xfd\x91\x1f\x4e\x47\xd6\x9c\xe3\x1c\xe7\xc8\x1a\xd2\x07\x1f\x14\xdb\xde\xef\x2f\xec\xff\xf3\x0c\xe9\xf3\x60\xac\x1c\xd0\x11\x1d\xd7\x06\x26\xef\xed\xa8\x7d\x20\x43\x42\x6a\x8b\x45\x80\x3d\x80\x1c\x4e\xb5\xb9\x9c\x86\xde\x27\x83\x72\x43\x39\x43\x79\x50\xe4\x05\x4b\x79\xf5\x1e\x88\x31\x87\x9c\x1a\x64\xa4\x78\xb1\x7b\x69\x28\x9d\xd9\x9b\x27\x50\xd1\x46\x3f\x14\x08\x1b\xc2\xdf\x84\x7e\xe3\x37\x85\xea\xe2\x56\xbf\xa2\xf0\xf9\x7d\xfb\xc8\xc7\xd8\xbf\x6f\x3b\x7e\xfc\xe4\x47\x62\xdb\xed\x64\xc4\x95\xf3\x33\xa7\x90\x3a\x13\xd1\x83\x31\x7c\x51\x9e\x49\xbf\x53\x9e\x09\xfd\x16\xc9\x28\x16\xaf\x69\x80\x7e\x77\x0c\xa4\xdb\x91\x49\x6f\x83\x0d\x80\x78\x5a\xb6\x8a\x93\x39\x87\x53\x6f\x02\x6d\x9e\xb7\x21\x15\xeb\xba\x45\xe6\x4e\x61\x95\xe2\x6b\xc3\x0e\x69\xe3\x22\xac\xe2\xcc\x14\x7e\x16\x02\x45\xeb\x6b\x58\x0a\xad\x5e\xd9\xcb\x4b\x9c\xec\x15\xd0\x0b\xbb\xaa\x36\xed\x9a\x3e\x70\x74\x4a\x6b\x6e\xc0\x33\xe4\x5a\x23\x6f\xb0\x23\x97\xb0\x29\xf4\x11\xde\x4c\x46\x71\x0d\x1e\xc3\x1d\xef\x62\xb2\x89\x2c\xfd\x8d\x5c\x9e\x5a\x3b\x4e\x2f\x42\xff\x30\xe7\xa0\xe5\x2e\x0c\xb4\x77\x27\x7a\x52\x78\x09\x89\xe6\x94\x14\xe8\xbb\xc3\x91\xe0\xd1\xd0\xf9\x45\xa2\x87\xf7\xa6\xba\xa5\x44\x5e\xe2\xb1\xd9\x80\x0c\x26\x43\xaa\x81\x37\x8a\x34\x10\xbc\x22\x98\x62\xc0\x25\x86\x3b\x06\xce\x60\xb0\x1b\xd5\x7c\x82\xc8\xf6\x47\x1e\x0b\xe5\x51\x02\x70\xa9\x09\x29\x16\xc8\x19\x77\xfc\x15\x7b\x61\x06\x19\xea\x45\xe1\x35\xe7\x62\x9e\xc6\xbe\x81\xae\x0f\x40\x9f\x19\xff\x00\x24\xf1\xd4\x5f\x96\x37\x62\x33\xe7\x70\x77\xfd\xcf\x69\xdc\xa4\x79\xce\xe5\xe7\x36\xd4\x2d\x6f\xb3\xab\x4d\x79\xdd\x0d\xcf\x5d\xae\xd3\x12\x37\x3d\xfd\x1f\x53\x6f\xae\x5c\xb2\x85\x96\x71\x57\x9b\x0f\xc6\xff\x20\xf3\x46\x0e\x31\x71\xfd\x43\xfb\x4d\x43\x46\xe2\x85\xa4\xce\x80\x96\xa1\x86\xdc\x4c\xd1\x1e\xda\xad\xd0\x74\x6b\xd8\x03\x13\xc5\x20\xcc\xc2\xbc\x40\xe7\x34\xbd\x25\xc5\xe5\x76\xeb\x53\xf8\x0c\x81\x57\x67\xf0\x19\x75\xb3\xd3\x0c\x7a\x83\x1e\xe4\x95\xa1\xdc\xc0\xad\x36\xbc\x60\x38\x67\xf8\xc2\x10\x36\x88\x06\x03\x4a\x34\xba\xb0\x93\x77\xb9\x12\x13\xed\xe5\xc1\x44\x01\x49\xc0\x27\x84\x0f\x84\x1b\x02\x1f\x95\xe1\x0f\x86\xdf\x33\x16\x81\x8a\x6b\x2f\xab\x22\xcd\xd3\xb3\x0a\x2d\xcc\x43\x0d\x18\x59\x7e\xcc\x53\x04\xf4\xb6\xf4\x48\xc5\x73\x7a\x9c\x64\xc0\xdc\xb8\x77\xc9\xef\xbd\xf6\x4f\xc7\xf2\x96\x17\xcf\xbf\xd3\xbe\xfd\xf1\xe7\x37\x57\xce\x7b\x31\xef\x85\x76\x58\x75\xe9\x6f\xa1\x35\xcb\x37\x3c\x3f\xf7\xb6\x6d\xcf\x2b\x5d\xc9\xcf\x4f\x4c\x9d\x35\x79\xc3\xac\xd1\xc3\x27\x4f\x5b\xd0\xfc\xb9\x03\x17\x77\x4e\xdb\xe9\x75\x1c\x9c\x33\xf3\x0c\xcd\x0f\x16\x89\x11\x44\x7a\xd4\x26\x90\xa9\xe7\x38\x4c\xf3\xed\x63\x95\xc1\xb8\x42\x87\x67\xe9\xf0\x68\x1d\xd6\x49\x98\x57\x2f\x12\xf1\x54\x11\x8f\x10\xb1\xb2\x9c\x03\x07\x0e\x54\xe2\x14\x07\xd6\x72\x26\xa6\x6f\x36\x19\x53\xd2\x6c\x5c\x88\xf7\x1c\xb1\x70\xa6\xcf\x0f\x99\x42\xff\x15\xdb\x56\xed\x5a\xb8\x46\x98\xfc\xe7\x19\x7e\x6c\x8f\x23\xf7\x37\xc5\xf1\xa9\x83\x51\x3e\xa5\xfa\x26\xfc\x13\xf0\x1d\xe0\x53\x06\xc6\xa7\xaa\x8e\x9b\x5c\x48\x8e\x71\x1e\xac\xf0\x41\xe8\xab\x15\x95\x05\xb2\xb5\x06\x9d\x45\x92\x65\xbd\x8e\xb3\x58\xac\x3a\xab\xdd\x46\x03\x73\x52\xb5\xbc\x46\xd4\x1a\x38\x33\x07\xfc\x80\xe3\xac\x70\x49\x44\x92\x14\x47\xaa\x94\xc6\xfb\x04\xc6\xa8\x8d\x1a\x99\xcd\x79\x14\x7f\x03\x05\xd3\x30\x4b\x03\xf6\x99\x7d\x07\xce\x0d\x7c\xba\xe3\xfd\x77\xc8\x3f\xea\x76\x28\xc4\xa1\xcf\x49\xaf\xf4\x11\xbe\x73\x20\x32\x8e\x0d\x1f\x87\x67\x93\x1e\xcd\x1e\xa9\x1b\xf2\x72\xcb\x8c\xce\xd0\x4e\x84\xc3\x04\x64\xf4\x40\x66\x1f\x6a\x14\x70\x61\xb3\x59\x65\xb3\x5a\x1d\x2a\xbb\xd5\x62\xc6\xe5\x41\x33\x2f\x69\xcb\x83\x92\xb5\x5a\x20\x9b\x71\x24\x2f\x99\x72\x80\x59\x53\x02\xc3\x6e\x06\xa1\xbc\x97\x2c\xcd\xc9\x1b\xb2\x6e\x71\x93\x44\x6b\x46\xf3\x2e\x4d\x0a\x3c\xcd\xb9\x4f\x5f\x11\xf6\x83\x9c\x9d\x4a\x5e\x58\xa6\xd9\x2c\x77\xd9\x8b\x13\xaf\xe2\x1b\xa0\x95\xfc\xcf\xd8\xcf\x1c\xf4\xb0\x78\xcb\x3d\xf1\xf1\x96\xbc\x80\x64\x41\x56\x01\x17\x67\x8c\xf3\xc1\x78\x4b\x6f\x24\xde\x92\x7f\x34\xf4\xfb\x39\x7e\xb9\xb0\xff\x7e\x7f\x1a\x74\x59\x3b\xde\xb2\xb6\x8e\x56\x3b\xe6\x91\x9e\xbf\x51\x59\xc3\xe6\xa9\x63\xa0\x8e\x41\x6b\xe6\x4d\x7a\x5e\x67\x34\xe9\x40\x03\x4d\x35\x34\x34\x70\x3c\xe5\x26\x9c\x41\x30\x68\xb5\xc8\xa8\xe3\xe9\x6e\x42\xd6\x6a\x8f\x7a\xca\x3c\xca\xab\x57\x50\x49\x97\x2d\x2a\xb9\x1e\xf2\x5a\x70\x85\xac\x5e\x3d\x8d\x55\x36\xb5\x58\xd6\xa0\xfb\xa0\x0e\x99\x4d\x0a\x8a\x3b\x87\xbe\xf9\x14\xef\xc6\x03\xdf\x0b\xdd\x2e\x1d\x3b\xd7\x96\x99\xba\xa6\xa9\x2d\xbf\xef\x1a\x7e\x65\x28\x89\xfb\xea\xfe\x1f\x9b\x2b\x9b\x40\x3f\x23\xb1\x97\xc0\xb3\xfb\x3c\x34\x6e\xb1\x12\x64\xde\x49\x26\xf3\xf2\x02\x6e\x95\x56\xc9\xe6\xa6\xa5\x59\xf0\x44\x5e\xcb\xc2\x48\x05\x0b\xae\x29\xf3\xe2\x58\x35\x9b\x3c\x45\xe6\x09\x27\x8f\x57\xcd\x3d\xc7\x69\xce\xed\x0a\x9d\x8c\x4a\xbc\xfb\xfd\xd9\x33\xca\xa1\xc9\x46\xf0\x0c\x5a\xb1\xc8\xa1\x92\x91\xc1\x60\x94\x8d\x16\xab\x96\x07\x9c\xa1\x95\x4d\x16\x03\x68\xb2\x25\xfe\x78\xcb\x48\x04\xc6\x55\x9f\x76\x51\x47\x06\xd8\x7c\xfc\x94\x67\x37\xb6\x78\xff\xca\xd9\x5b\xd3\xef\x9d\x3d\x8b\x3f\xcf\xb0\x9f\x79\x89\x6b\x1c\xba\xf1\x6d\x23\xee\x93\xc8\xd9\x4c\x10\x9e\x35\x85\x8d\xc7\x1f\x70\xc9\x02\x0c\x05\xa9\xb4\x48\x4b\xc7\x83\x79\x78\x0e\x5f\x11\x17\x05\xeb\xaf\x2d\xc2\xfd\x31\x01\xee\x37\x07\xf7\x60\x0f\xfd\x07\x43\x69\x2f\x9c\xa6\x3f\x51\x3d\xb9\x37\xcc\x19\x95\x25\x46\xd4\x22\x90\xac\x96\x24\xbd\xc8\x19\x11\xd2\xe8\x39\xbd\xc9\xac\x05\xac\x00\xcf\xe2\xc4\x8a\x78\xb0\x10\xff\x2c\xff\xc3\x11\x03\xfd\xb5\xd0\xa2\xca\xb5\x07\x63\xfa\x6f\x55\x04\x37\x44\x1e\x7d\xbf\x7d\xe8\xdd\x58\x8e\x84\x45\x11\xac\xd0\x3c\x90\x82\x2c\x16\x8d\x0a\x94\x09\xc1\xe1\x44\x14\x2a\xc0\x60\x23\xf0\x0d\x50\x82\xca\xf2\x80\x05\x34\xee\xfc\x89\x9e\x40\x47\x20\x66\xbe\xb7\x1a\x5d\x1a\x16\x03\x30\x08\x7f\x43\x40\x1d\xe0\x0c\xf8\xe5\x7d\xfb\xc6\x4d\xdd\xb7\x9d\x37\x5e\x79\xe5\xe4\x47\x00\xdf\xaa\x5a\xcd\x9c\x40\xea\x3c\x86\x58\x5c\xef\x68\xe8\xcb\x50\x16\xfb\x6d\x01\x5c\x19\x08\xa4\x02\x66\x12\x1c\xb2\xd1\x28\x58\x1d\xd0\x21\x97\x6c\xa8\x08\xca\xb2\x60\x83\xad\x67\xac\x08\x5a\x29\x68\xf1\xc7\x42\x48\x6a\xfa\x57\x44\xac\xb2\x39\x4a\xcc\x2b\xa0\x74\xaf\x8f\xf6\x86\x7e\xe5\x5b\x93\xf0\xcd\x7b\x87\x5b\xfc\x7e\x7f\x0f\x39\xd5\xb6\xeb\xfe\x6d\xd8\x79\x58\xc1\x2b\xa1\xf3\x97\x4e\xfc\x4a\x6c\x73\xc9\xef\x74\xd3\xa2\x1a\x58\x4a\x03\xbb\x0b\x28\x5a\x36\x99\x04\x2d\x33\x50\xc9\xc6\x72\xda\x19\xe8\x8b\xa9\x1a\x3f\x3d\x48\x72\x6c\x42\xfc\x0f\x01\x4d\xe7\x1e\x86\x98\x42\xef\x54\x03\x26\x1c\xd5\xd5\x61\xd5\xb7\x07\x46\xa8\xd4\x58\x6d\xb0\xdb\xb8\x84\x04\x83\xcd\x90\x98\x44\xd3\xc0\xe4\x9a\x79\xa4\x33\xe9\x52\x75\xbc\x5e\xc4\xa0\x24\x1a\x31\x2e\xc1\xe5\x78\x02\x06\x99\x7f\x0e\xdf\xc1\xbc\x8e\xc7\x81\xf4\xba\x1d\x30\x36\xeb\xcc\x2e\x58\x4d\x7b\x43\x7b\xc0\xce\x23\x7b\x99\x7d\x97\xfd\x45\xfb\x0d\xfb\xcf\x76\x49\xc7\xdb\xed\x66\xab\x4a\xa5\xd3\x01\x1c\xd5\x09\x35\xe3\xd7\x26\x45\x57\x9a\x7e\x9e\x5c\x43\x5d\x8c\x1d\x32\xb3\xbc\xf5\xd5\x5e\x08\xa9\x66\x13\xf2\xc6\x14\xed\x42\xfc\x2d\x3e\xa4\xd9\xb9\x7f\xe4\x8e\x8c\x03\x6d\xbe\x7b\x86\x73\x91\xaf\xc9\x1f\x7b\x7e\xed\xb6\xb3\x68\xff\xf0\x3d\x47\xb4\xdc\xe0\xb5\xff\xbe\xb5\x68\x52\xcb\xe7\xf6\x84\xba\x91\xe7\xc8\xa6\xe3\xe7\x5b\xae\x79\xe2\xbb\x5f\xe9\xbc\xf7\xa6\xb6\x5d\x18\xbb\x05\x25\xa2\x3e\x81\x5c\xb7\x5e\x02\x18\xab\x53\xa9\xd4\x56\xa4\x46\x49\xc9\x3a\x19\x86\xab\x3b\xa7\xe3\x74\xbc\x4e\xa7\xd6\x98\x1c\x15\x41\x93\xa0\xe1\xd5\x16\x3e\xa1\xfa\x54\xa1\xe4\x2f\xf0\xac\x39\x5a\xb4\x84\x85\x64\xf1\x3e\xa6\x11\xf9\x3d\xd4\x62\xca\x47\xa2\xb4\x80\x96\x9f\xba\x74\xf6\xa5\x37\xb4\x5b\x76\xef\xde\xa2\x7d\xeb\xa5\x57\x2f\x1d\x19\x33\x61\xdc\x98\x4f\xaf\x71\x07\xc9\x21\xb2\x05\xb7\xc2\xfe\xd0\x4e\x58\xaf\xe7\x70\x63\xdc\x98\x1c\x20\xcf\x62\x07\x56\x93\xff\x90\x5b\xa1\xbf\x2b\x74\xd3\x18\xe8\x26\x87\xe1\x05\x3b\x1a\x18\x68\xac\xc3\x58\xa3\x47\xc8\x20\x58\x34\x1a\xb5\xa0\x76\x38\xb1\xce\xac\x2b\x0f\x76\xa3\xf9\x7c\x4a\xcc\x13\xcc\xe7\xcc\x77\xcc\xa2\x8e\x37\x9b\x91\x2c\xdb\x80\xb0\x78\x4d\x4c\xb8\x54\xdb\x10\x6b\xe8\x76\xd5\x3c\x06\x2b\xc1\x83\x54\xf2\xf8\xb0\xd5\xe6\x80\x4f\xde\xd4\xc6\x78\xcd\x8e\x33\xf7\xbe\xc3\xff\x3e\xf7\x13\x59\x97\xb8\x79\x0d\x76\x91\x9f\xc9\x07\x5c\x2f\xcf\x95\x8d\xc7\x2f\xfc\x79\x86\x2b\x09\x5d\xe0\xdf\x9b\x31\x1f\x7f\x02\x3c\xbc\x12\xe6\x7a\x39\xb3\xd9\xb6\x61\x7d\x5f\x41\xcf\x45\xc4\xcf\x81\xe7\x65\xa0\x1e\x01\x7b\xa2\xd1\xee\x93\x24\x3b\x32\x1a\xed\x99\x59\x3e\x9d\x8e\x2f\x0b\xba\x93\x95\x03\x29\x9d\x5b\xe7\xb6\x24\x24\x24\xf6\x08\x26\x58\xd4\x65\x41\x4b\x7c\x08\x5c\x24\x71\x60\xcd\x38\x2a\xa6\x4a\xc4\xd7\xdc\x8f\x18\xa9\xa9\xdf\x6f\x41\x61\x41\xa1\x5d\x92\x0d\xbc\xdc\x02\xf3\x9b\x16\x6f\xdc\xb9\xf1\xc9\x8d\xbb\x57\xfc\xf6\xf9\x47\x7f\xfe\xf4\xfb\xf7\x63\xbf\xb9\xfc\xc4\x9d\xf7\x17\x6f\xdb\xd0\xb3\xae\xd0\xe0\x1d\xfc\xfb\x3b\xe7\x2e\x5c\xba\xf8\xfa\x19\xee\x53\x72\x9f\xfc\x09\x13\x1f\x82\x25\x29\xc5\x12\x6e\x7d\x22\x2b\xc1\xbb\xdb\xe3\x4e\x6c\x33\xe1\xe8\x9a\xca\xc7\x19\x5f\x39\x0d\x6b\xd1\x84\xc5\xc7\xb9\x90\x97\xfa\xb3\x48\xa6\x64\x5a\x11\xd2\x63\x32\x19\x6c\x1a\x83\x26\xcd\x27\x79\x5c\x1e\x57\xf7\xa0\xc7\x63\x30\x1a\xdd\x65\x41\xa3\xd1\x60\x2a\x0b\x1a\xec\xb5\xd9\x5d\x1c\x12\x8d\x50\x11\x1b\x8f\x82\x36\xed\x14\x6e\xd2\xdd\x6e\x55\x40\xa9\xcf\xeb\xc6\x91\x4f\xdc\xb2\x4b\x97\x1e\x7b\x74\xc1\x82\x7f\x5e\x20\x09\xc7\xb1\xed\x89\x89\xd3\x57\x93\xff\x82\xac\x1c\x37\x62\xa6\xd0\x64\xc5\xa2\x41\x73\x6c\xb2\x79\xd1\x98\xf5\xfb\x85\x26\x55\x9d\x7b\x0d\x1c\xfe\x08\xbe\x48\xce\x77\xe8\xd7\xa3\x0b\xf5\xff\x82\xbe\x53\xff\x2f\x96\xe7\x84\x22\x65\x9a\x3d\xa9\x2c\x28\x1a\x79\x7b\x8d\x3c\x27\xd8\x4e\xd7\x9f\xba\x75\x1d\x17\x9a\xac\xaa\xea\x09\xb7\xb0\xb5\x74\x80\x4e\x35\x8d\xdd\x6f\x45\x9d\x03\xe9\x82\x1e\x9b\xf4\x26\xab\x46\x2b\x5a\x2c\x2a\x95\x55\x6b\xb5\xd9\xd9\x49\xa2\xd1\x22\xe8\xd4\xba\xb2\xa0\xda\x4e\x8f\x4a\x1e\xae\x53\xc5\xb6\xbc\x82\xc5\x34\x58\xa6\x69\xb7\x23\x9a\x15\xb5\x86\xf0\x25\xe4\x8d\xf4\xfe\x01\x7c\x1f\x17\xee\xad\xfa\x66\xef\xf4\xd2\xf1\x39\xdc\xc4\x75\xfc\x11\x72\x8f\xcc\x5c\x11\xfa\x8c\x29\x56\x99\x95\xf8\x0a\xae\xa8\xea\x49\xb1\xc3\x12\xa0\xb3\x76\x8c\xee\x3a\x30\x7e\x47\xf3\x03\xbd\x0b\x7d\xf5\xa2\xc7\x02\x75\x3c\x49\x09\x5e\x41\x46\x16\xaf\x17\x64\xa1\x94\xe0\x70\x3a\x13\x13\xb4\x1a\x8d\x28\x25\x00\x02\xf4\xc8\x49\x82\x2c\x18\x53\xb1\x11\x2b\x5e\x70\x96\x5c\x23\x36\x1a\x9d\x1a\x93\x31\x41\xa2\xd6\xe4\xa8\x22\xc5\x2c\x22\xd5\x3a\x54\xbc\x4b\x5a\xb4\x7a\x95\xb9\x5a\x8b\x6a\x80\xb3\x40\x8d\x6a\x80\x79\xbf\x33\xaa\x46\x95\xe0\x88\x1a\x05\x80\xd7\xcc\xb9\x93\x0b\xf5\xa1\xd3\xb8\x9b\xbd\xd9\xbd\x97\x36\xb4\xec\xd7\x60\x6b\xc3\x60\x60\xc3\xff\xc7\xd9\x97\x00\x46\x51\x64\xfd\x77\xf5\x39\x3d\x57\x77\x4f\x4f\xcf\x3d\xc9\x4c\x26\x99\x5c\xe4\x20\x93\x83\x24\x1c\xcd\x7d\x06\x12\x40\x70\xb8\x12\x14\xb9\x04\x14\x04\x11\xb9\x05\x44\x41\x40\x0e\x11\x10\x01\x01\x2f\xc4\x03\x36\xa0\xa8\x2b\x08\x8a\x82\xa0\xae\xee\xae\xd7\xba\xba\xee\x7a\x9f\xbb\xba\xab\x9f\x90\xe6\x5f\x55\xdd\x73\x25\xe0\x7e\xdf\xdf\x08\x99\x84\x99\xae\x57\xaf\x5e\xbd\x7a\xaf\xde\x7b\xbf\x77\xf8\xdd\xfe\x05\xa0\xf1\x58\x9b\xb5\x26\x1b\x7c\x4c\xbb\xcd\x6d\x17\xc8\x16\x77\x13\x98\xf3\xfd\xd4\x16\x09\xbc\xaa\x75\x71\x4c\x9c\xfc\xbd\xf6\xdc\xf4\xe2\xb6\x3d\x24\xc3\x7b\x68\x2d\x84\xe6\xba\x06\xce\x3d\x8f\x1e\x0a\xad\xbf\x39\x6a\xcf\x90\x55\x0c\x40\xb7\xd1\x1a\xa0\x72\xa1\x1f\x95\x4b\xe5\xe6\x17\x84\x6c\x56\x1b\x5c\x0f\x9b\xcd\x4b\xa8\x50\x5f\xb7\x20\xb5\x7d\xa3\xf2\x26\x54\xda\xd0\x04\x51\x14\xaf\xd7\x01\x77\xa1\x48\xa0\x08\x1b\xf4\xeb\x13\x37\xa0\x1d\xe0\xbe\xae\xe4\x3b\xe9\x0a\x3a\xa4\xe3\x22\xe3\x44\x74\x36\x3d\x7c\xaf\xcb\x32\x39\xe6\xe5\xf7\x3b\xef\xf6\x6d\x5b\x01\x4c\x6f\x1f\x7b\xfa\xd4\xcf\xcb\x97\x59\xf7\x7a\xde\x79\xf1\xf4\xe7\x03\x97\x0d\x58\xf6\xd8\xb7\xce\xf9\xab\x3b\x8d\x6c\x3c\xd6\x3c\xed\xce\x31\xc3\xf7\xf4\x1f\xe8\xbc\x73\xc1\xf6\x95\x3d\xa7\xf7\x36\x91\xf6\x4d\xd3\x76\x1c\x80\x73\x44\xfb\x4e\x81\xeb\x69\x23\x2a\x55\x1f\x3c\xcb\x6d\x14\xcb\x32\x36\xc6\x2e\xac\x31\x03\x33\x65\x13\xd8\x55\x24\x20\xad\x28\x20\x37\x1e\x17\x7e\xb4\xaf\x98\x95\x28\xdd\x41\x42\xd7\xff\x12\x98\x62\x06\x3f\xbe\x7c\x90\xa3\x34\xf6\x04\x5d\xd7\xf6\x94\xf6\x35\x75\xdd\x85\xd3\xe4\x96\x9e\x93\xca\x2f\xde\x0b\x07\x41\x71\x10\x34\x1e\xd3\x0a\xfd\xa4\x2f\x50\x9d\x83\xe9\xb3\x1f\xf5\x3a\x07\xbb\x14\x05\x84\xe8\xb1\xd2\x69\x3e\xd2\xfb\xf0\xbd\xe3\xe0\xc7\x1c\x44\x3f\x35\x62\x33\x5b\x48\x49\x42\x6e\x92\xd5\xe2\x80\x7b\x02\x9a\x5e\x22\x09\x35\x40\x19\xa4\x8f\x74\x58\x14\xa3\x44\x1e\x09\x94\xae\xda\x32\xef\x4c\x33\x3c\x23\x2c\x2d\xba\x63\xf4\x7e\xeb\xec\x2d\x83\x5a\x4f\x7e\x32\x74\x00\x58\x7e\x4e\x3b\x95\x33\xab\x0a\xee\x4d\x2d\x3a\xe1\x06\x60\xd3\x9e\xbb\xa1\xb2\xed\x09\xd0\x26\x38\x35\x3d\x46\xc3\x42\x79\xf0\x60\x7a\xca\x54\x0f\x89\xae\xf8\x1c\xbc\x43\x76\x8a\x24\xda\x9c\x9c\x15\xd7\x96\x27\x92\xb5\xd3\x53\x87\xb1\xcf\x91\xe6\x16\xe1\x9d\x48\x5d\xab\xad\x28\xcd\x1d\x36\x7f\x7a\x45\x27\x6f\x71\xdd\xc0\x5e\xbd\xc9\xd3\x70\x17\x3e\xab\x5d\xd2\xfe\x3d\xcb\xb6\x9c\xdf\x02\x1a\xc0\x17\x38\x2e\x02\x88\xc9\x90\x0f\x7a\x8c\x66\x80\x9a\xc7\xd0\x82\xe0\x34\xa3\x48\x0d\x0e\xd3\x98\x13\x41\x1a\x55\x68\x14\xc8\x1e\x70\x87\x31\x84\x19\x2d\x17\xf2\x68\x13\xc1\x9a\xda\xf4\x04\xf1\xc4\x2d\x5e\xcd\x65\xe2\x35\xa6\x0e\xe1\x9a\xaa\xa7\x50\xb8\x66\xf0\xb6\xb6\x4e\x70\x41\xd3\xc3\x35\x90\xae\x23\x90\x2e\x0f\xce\x7b\xad\x52\xfd\x00\x75\xd4\x84\xb2\x63\x66\xac\x36\x60\x6a\x8a\x97\x01\xf8\x9f\x99\x81\x7b\x22\x7d\x5d\xda\x09\x0f\x32\xbb\x74\xf5\x04\xa6\x81\x0b\xad\xad\x1a\x83\xb8\x5f\x0d\xce\x5e\x38\x0d\xbe\xd5\x64\xa4\x20\x2f\x53\x33\x9a\x18\x17\xfb\x7b\x0c\x0b\xfd\x7c\x60\xe2\x39\x1a\x05\x1d\x59\xa0\x10\x69\x51\xe3\x04\xf6\x17\xd6\xbb\x1e\xfd\xf1\x17\x20\x9f\x0d\xdd\x6b\xe0\x76\xf4\xa2\x1b\xe1\xb3\x47\x24\xc7\x4a\xc6\x46\x8d\xd8\xe7\x20\x3c\x56\xbe\xea\x00\x70\x1f\x33\x8c\x89\xa7\x15\x8a\x43\xdb\x9a\x48\x56\x07\xa6\x15\x69\xcb\x61\xac\xe6\xc3\xb7\x51\xaf\x6a\x37\xb7\x6a\x37\x63\x55\x4f\x1d\x84\xcf\xee\x05\xc7\xba\x13\xd7\x63\x8f\xc3\x67\x5e\x3f\xf8\xf3\x2a\xe6\x1c\xf4\x91\xdc\x44\x90\x18\xaa\x16\x04\x04\xda\xea\xa4\x29\x86\x81\x82\xe5\x41\x2d\x03\xb3\x6d\x84\x1f\xd7\x85\x09\x50\xfb\x38\x59\x94\xe1\xc0\xba\x3a\x54\xe2\x79\x7a\xa4\xbb\x34\x49\x6c\x1c\xa3\x1c\x0f\xc5\xc2\xe1\x3f\xb9\x1c\x40\x64\x24\x3b\x60\x2a\xa3\xf9\x52\x2e\xbd\xea\xbb\x4f\xee\xfb\xe4\x5f\x3f\xfc\xe3\xbe\xaf\x3f\xbd\xb8\x04\xb8\xd7\xad\x21\x5f\xbe\x7d\x1d\x90\xc9\xac\x8b\xda\xdf\x15\x6d\x0a\xd8\x26\x83\xf0\x85\x36\x10\x70\x82\xe5\xda\x52\x59\xfb\x1a\x1e\xe1\xb7\x15\x53\x43\x9d\x7f\x38\x71\xea\x0f\x8e\x8b\xbf\x2b\x44\xbc\x9a\x00\x79\x33\x13\xcf\x67\xac\x51\x9b\x3a\x95\x7e\x08\xcb\x43\xb5\xaa\x90\x0c\xc3\x03\x33\xcf\x9a\x59\x2b\xb4\x7c\xcd\xa0\x29\x6e\x56\x4c\xf0\xd8\x3a\x6c\x08\x44\x7b\x3c\x80\x94\x40\xe8\x22\x01\x26\x41\x81\xd8\xbc\xef\xe2\xe3\xf0\xc0\x1d\x48\x3d\x7d\x71\x60\xdb\xa7\x60\x1b\x5a\x35\x40\xec\x80\xcc\x6b\x83\x2f\x25\xa2\x58\x55\x08\xe8\x7e\x71\x26\xc9\xe4\x90\x6d\x34\xd2\xc5\xbc\x92\x04\xcb\x68\x67\xe6\xeb\xc5\xc2\x52\x32\x3f\x51\x02\x43\xaf\x9b\x38\xef\x44\x6b\xeb\xe7\x7b\x37\x6d\x81\x62\x37\x6b\xe8\xc8\x4a\x92\x80\x92\xf7\xd6\xd8\x5d\x6b\xc0\x7d\x44\xc6\xde\xbb\x9c\x6f\x29\x20\xdf\xb2\x29\x8e\xf6\xfc\xff\xc2\xb7\x9c\xbc\x07\x88\x7b\x80\xb4\x27\x31\x1f\xea\xe9\xc4\x3e\x1a\x07\xf9\xf6\x7b\x6c\xfb\xf4\x52\x45\x7d\x0c\x9b\xdd\x8e\x86\x11\x25\x3b\x64\x99\x8a\x07\xb3\x64\x8e\x86\x87\xeb\xd1\xd1\xbf\x8c\x49\xe9\x5f\x11\x69\xdc\x9e\xff\x81\x5f\x1b\x36\xa4\x86\xd5\x59\x49\x90\xe8\x56\x9a\x5e\x02\xc7\x45\x7e\x65\x5f\x35\xd7\x0a\x99\xc7\x49\xd0\x61\x76\xb9\xad\x4a\x13\x14\x39\x60\x81\x86\x3b\x07\x8d\x61\x94\xb7\xce\xd9\x9a\xe2\x5c\x87\x70\x7e\x7b\xff\x32\x19\xc1\xa8\x82\x96\x55\xcc\xb8\xf8\x23\x3f\x3a\xff\xd6\xbb\xa7\xb5\x29\xda\x33\xe0\xe2\xd9\xdb\x6e\x99\xbb\xea\x35\xf2\xc6\xcd\xbb\x77\xec\xa7\x0e\xae\xd7\xaa\x35\x61\xdc\xb5\x13\x46\xe3\xfd\x30\x1d\xdd\xdf\x42\x7a\x90\x1f\x87\xb0\x91\x73\x05\x8a\xe2\x9c\x6e\xb3\x05\xae\xb0\xdb\xe3\x35\xcb\x90\x28\x33\x24\xca\x6c\xe6\x14\x93\xc0\x59\x9a\xe2\x4e\x44\x51\xd2\xbf\xec\x70\x25\x9e\x41\x52\x2c\x45\x10\x06\x75\x7c\x14\x13\x75\x62\xff\x7d\x8b\x6f\x9a\xbd\x64\x27\xf9\xd4\x7e\x9d\x28\xa4\x7f\x34\x61\xc2\xc4\x09\xa3\x35\x1b\x52\x16\xd0\x3e\x3b\x07\xe9\x2a\x34\xe8\xaa\x53\xb3\x10\x3d\x02\x64\x93\x53\x49\xa7\x48\x27\x28\xc1\xa1\x8e\xd4\x5c\x9e\x12\x72\x0d\xa6\xa2\x67\xeb\x0f\x88\x2f\xff\x4c\x27\xc1\x60\x0b\x94\x8f\x45\x50\x27\x75\x85\x76\x48\x90\x58\xac\x0e\x73\x7b\x3c\x22\x61\xe2\x24\xbb\x1d\x61\xf1\x67\x8b\x42\x53\x3c\x5b\x2c\x13\x8f\x8b\xdf\x8b\x97\x44\x26\x5b\xfc\x08\xbe\xa0\x44\x91\xf2\x0b\x6e\x78\x80\xbb\xdd\x7e\x3f\xd4\x1a\x7e\x11\x15\x13\x87\x4c\x37\x9a\x96\x99\xa0\x00\x8b\xa6\x16\xd3\x09\x13\x6d\x32\x19\x28\xa4\xb3\x2f\x7f\xa9\xdb\xc1\x89\x44\x80\x73\xd0\xfe\x32\xfc\xc6\x70\xba\x4f\x59\x41\xd0\x5d\xb5\x4b\x3f\x2d\x38\xb3\xc8\xf6\x82\xb0\x65\xce\xc6\x2d\xbc\x76\x1b\x58\x62\xda\xb2\xf9\xe6\x35\xe2\x89\xec\x7f\xb7\xfe\x04\x4f\xe9\x2c\xed\x3b\xed\xe3\xf8\xae\x66\xeb\xe4\xd9\x4f\x3d\xb7\xe2\xf0\x81\x69\x63\xed\x5b\x1f\xd7\xfe\x8a\x6d\xe0\x7e\x70\x8e\xdb\xe0\x1c\x1d\x44\x36\x31\x56\xed\x2c\xdb\x00\x10\xe1\x46\x16\x44\x2f\x2a\x61\x0c\x4b\x82\xa8\x10\x76\xc8\x6d\xe2\x0d\xe2\x23\x82\x82\x3b\x84\x30\xd3\x66\x17\x14\x4c\x17\x1d\x84\xf6\x95\xd8\x41\x30\x33\x80\x8b\x52\x07\x9f\x1c\x4b\x65\xdd\x90\xf9\xd8\xad\x4c\x54\xab\xe2\xc9\x7c\xf5\xa8\xf4\xfa\xc3\x87\x5e\x3f\x7b\xf4\xf0\x1b\xec\xc3\xfb\xf7\x83\x91\x37\x4c\x9d\x3a\xab\x6a\x42\xb7\x19\xb3\xc9\x1b\x3f\xb9\xa8\xbd\xa9\x69\xda\xff\x68\xef\x00\xf9\x3b\x74\x3a\xb5\x7d\xf2\xda\xc7\x7f\x79\x63\xed\xef\xaf\xfb\x10\xcf\xa1\x2f\x14\xe2\x0b\xc6\x7e\x1a\xac\xe6\x11\x14\xc5\x98\x15\x8b\xc5\x0c\xa7\x2e\xc1\x73\xd1\xed\xa2\xe0\x11\x0e\x85\xd6\x09\x4c\x26\x38\x17\x93\x60\x49\x9e\x56\xba\xf3\x42\xc4\x3a\x04\x7a\x8d\x42\x07\x10\x95\x74\xf7\xd1\x6b\x54\xf9\xd4\x03\x72\xb0\xf6\xf2\x6b\xe0\xea\xff\x79\xf7\x0d\xf0\x54\xeb\x57\xb7\xdd\x72\xfd\xa2\x36\x70\x16\x9e\x9d\xef\x54\x02\xfa\x9e\xad\x50\x8d\x9d\x05\xff\x1c\x37\x7e\xc2\x78\xfd\x9c\xc3\x76\x3c\xb2\xbb\x90\x1d\x2f\xb1\x44\xef\x43\x28\x8a\x46\x86\xe0\x01\xf1\xcc\xa5\xc3\xad\xc1\x90\xcd\x99\x11\x77\xd3\xdf\xbf\x30\xf9\xfe\xe9\x26\x02\x45\x7a\x29\xd2\x2f\x45\x29\xd2\x94\x1d\xb4\xc9\x19\xb9\x01\x55\x18\xff\xea\x1c\xf4\x46\x5b\xd4\x2c\xd9\x1e\x66\xc8\x50\x28\x2f\xec\xb1\x87\xed\xd1\x7c\x26\x92\x1b\x69\x8a\x93\xb9\x96\x40\x63\xdc\x64\xb1\x3c\x73\xe9\x84\xea\xe0\xad\x03\x72\x2d\xb9\x16\x22\xac\x48\xf0\x78\x93\xfc\x70\xd4\x1e\xe9\x45\x4e\x46\x6d\x66\x66\x02\xb5\xee\x9b\xca\x31\x94\x27\xa4\x38\xb9\x58\x75\x2c\xe4\xd5\xa1\x9b\xaa\xdc\x28\xb1\x3b\x89\x27\x13\xa9\x8a\x1d\x3b\x82\x10\x5b\x79\x6a\xda\x57\x60\xc2\x2d\xb7\x34\x54\x74\xef\x57\x8d\x61\x65\x56\xae\x64\xce\xdd\xbf\x62\x65\xfd\x9a\xf3\xda\x8a\x8b\xaf\x6c\x5f\xc3\xaf\x65\x07\x4c\xa5\x68\x0c\x2f\xf3\x18\x7d\x70\xc5\xa5\x4b\xba\x3f\x87\x6d\xd4\xbf\x1b\x31\xca\xcd\x84\x6e\xa5\xb2\xd0\x4a\x9d\xc2\xf2\x34\x91\x11\x43\xdc\x08\x79\xd5\x84\xf7\xe7\x0a\x75\x84\xdb\x4e\x50\xd9\x36\x11\x9a\xfd\x2c\xeb\x72\x13\x6e\x78\x86\x8b\x50\x6e\x6d\xd9\x36\x3d\x55\x8a\x49\x4b\x95\xf2\x53\x7e\x19\x6e\x4b\xd7\x8d\xae\x65\x50\x36\x5c\xa2\xab\xc5\x75\xc2\x45\xf3\x94\xcb\xe5\x37\xa0\x8f\x41\x06\xec\x71\xc6\x85\x4f\x7a\x70\x36\x21\x2f\xb8\xe1\x62\x7a\xc1\x15\x07\x39\xa5\xef\x56\x1d\x01\x79\x23\x20\x7f\x7a\xfa\xdf\x81\x13\xe2\x9a\x9b\xef\xde\x62\x01\x4b\xb4\xdb\x2c\x5b\x36\xcc\xde\x22\xbe\x60\x5b\xf4\xea\xad\xff\xbe\x44\xe8\x00\xc8\x87\x36\xd9\xc7\x4e\xdb\xff\xcc\x8a\x13\x8f\xdd\x38\xc5\xda\xbc\x2b\x0e\x42\x58\x26\x1e\x86\xf3\xcc\xa5\x07\xc3\xf3\x1e\xd7\x83\x12\x1b\x10\xbe\x0c\xce\x69\x1a\x92\xf6\x33\x92\x99\x1f\x75\x99\x29\x24\xf4\xec\x00\x33\x2a\xa8\x76\xda\xad\x14\xc8\xa8\x01\xcd\xc8\x3b\x83\xfb\xc7\x0b\x9f\xff\x30\xdc\x3f\x5e\x22\x44\x8c\x56\x4b\x4d\x6e\xaf\xcf\xc7\xba\x59\x21\x48\x0a\x64\x38\xc7\x1b\x82\x6c\xf4\x42\x65\xeb\xf5\xba\x59\x37\xb4\x30\xdd\x82\x0d\x3a\x58\x36\x17\xeb\x6b\x8a\xb3\x4a\x87\x04\x81\x34\xfd\xeb\x48\x53\xc2\x21\xc9\x48\x14\x40\xfc\x30\xa2\x14\x35\x32\x3e\xad\x50\xb6\x25\x15\x00\x6b\x5f\x7f\xfe\x8d\x07\x0b\x9c\xdd\x27\x4d\x28\xcb\x53\xf2\xca\x2b\x23\x8e\x2a\xf0\x6a\xec\xb3\x4f\x2b\xc9\x1b\xb5\xd7\xb7\x3e\x42\xbd\xa8\xf5\x7d\xe7\x1f\xcd\x96\xe5\x5c\xdf\x83\xcf\x91\x41\xa8\xaa\x99\x33\xc7\x75\x8c\x0b\x38\xff\xa7\xb0\x7f\xe0\x87\xf4\x77\x62\x64\x99\xb4\xd9\x24\x1e\x88\xa2\xe4\xe6\x25\x3e\x10\xf4\x43\xf3\xbc\x29\xce\x08\x00\xce\x02\x00\x1b\x61\x83\xe7\x87\x64\x4b\x9a\xc8\x29\xc2\x3b\x60\xdb\xa4\x5a\xd0\xe9\x26\x12\x3e\x4a\x8a\x81\x6e\x3a\x27\x0e\x93\xff\x80\xc1\x3b\xaa\xd1\x79\xf2\x07\xed\xc8\x0e\x72\x69\xf5\xb2\x5b\xe7\xae\xaa\xd1\xed\x69\xad\x1a\x1d\x2c\xe0\x67\x8d\x87\x76\x40\xfd\xa4\xeb\x26\x4c\x44\x7b\x16\xd2\x8b\xf6\x6c\x80\x18\xa9\x06\x29\x3b\x43\x42\xff\xdd\x23\xd8\x3d\xf6\x60\x16\xe3\xf3\x43\xae\x92\x7e\x8b\x9c\xdc\xb2\x56\xb8\x65\xfd\x16\xbf\xc5\xee\x51\xf0\x66\x8d\xfd\xd6\x46\xbd\xcc\x3e\x8d\x5c\x71\x7b\x1e\xe9\xb0\x31\xdb\x1a\xc8\xed\xc9\x1d\x89\x65\x0b\xfb\x82\x78\x4f\x7e\x85\x65\xeb\xe6\xe9\xfa\x8e\x94\xe1\x8e\xac\x92\x5d\x44\x7a\x6e\x53\x3b\x1f\x93\xe8\xfd\xbe\x9e\x31\x20\xa1\x48\xdc\x7b\xad\xa2\x6c\x63\x32\x74\x1d\xb6\xcb\xb1\x6e\x1c\xa7\xfb\xa4\xff\x4c\xd5\xe9\x13\xee\x6c\xb3\x94\xe6\x93\x1e\x81\xef\xd5\x7d\x9e\x4a\xd5\xcb\x9b\xcd\x04\x0d\xcd\x32\x82\x83\xf6\xa0\x1f\xda\x68\x50\x49\x66\x1a\x84\x3d\xae\x68\x10\x46\xa4\x23\xad\xd0\xc2\xd5\xf6\xec\xd3\x2d\xb3\x0b\xa7\xd1\xed\x3f\xd6\x27\x03\xe0\x3e\x58\xc5\x8c\x21\x4a\x89\x26\xb5\xa8\x30\xe8\x01\x80\xc8\x8d\xd8\xec\x26\x59\xb6\x47\x88\x20\x53\x56\x6e\x89\x86\xa2\xe8\xe2\xdf\x27\x86\x68\xa6\x93\xaf\x53\x73\xdc\xe3\xf2\xa1\x0c\xa2\x84\x57\x90\x2a\x3e\x71\xa7\x5d\x0b\xe9\x11\x00\x9c\xec\xa6\x1f\x80\x38\x7f\x56\x7f\x89\x7a\x09\x25\xe0\xfc\x50\xef\x08\xfd\x75\x0d\x99\xb5\xd5\xd5\xa3\x7c\xf0\x88\xe1\x83\x8a\x23\x63\xfb\x2d\x5e\xb7\x6f\xef\xe6\xcd\xa3\x47\x6e\xdd\x7e\xdf\xbe\x0d\x3d\xae\x2e\x88\x87\x4b\x06\x0d\x1f\x3e\x68\x64\x17\xf2\x7e\x6d\x56\xdd\x50\xb8\xbb\x51\x83\x1c\x77\xc5\xa8\x39\xda\x5a\xe8\xca\x1e\xd3\xb6\x3c\xf6\x18\xb4\xe3\x87\x81\x01\xe0\xa6\xea\xfa\xd1\x15\xda\x57\xf8\x26\xf0\xe3\xa5\x7a\x0d\x23\xc2\xa7\x7a\x08\xd7\x7c\x0f\x53\xf3\x79\x93\x55\xb0\xdb\x38\x96\x11\x45\xce\x6e\xa5\xcd\x32\x49\xba\xdc\x16\xb3\xd9\x25\x5a\x6d\x9c\x95\xe3\x15\xbb\x59\x60\x79\x1d\x6f\x29\xb9\xa1\x41\xf2\x8e\xaf\x1d\x6c\x25\x4e\x0a\x8e\x20\x14\xfd\x18\x90\xa9\x98\x8c\xb1\x98\xe8\xb9\x15\x77\xdf\xb5\xe7\x86\xd5\x07\xb4\xbd\x4f\x03\xcb\xa6\x3b\x9f\xfe\x78\xc4\xb8\x72\xba\x6e\xc1\xfa\x87\xb5\xf1\x5f\x82\x3b\xb4\x5b\xe0\x4a\xcc\x02\x4f\x80\x7f\x5c\x9c\xb5\x03\x0c\xbe\x77\xe7\xad\x70\x4f\x2b\x46\x6c\x01\xed\x69\xe8\x7d\x0b\x84\xc7\x63\x35\xc9\xb4\x89\x0e\x04\x09\x77\x73\xdc\x61\xb6\x98\x5b\xe2\x02\x34\xd5\x09\x8b\xc9\x46\x99\x3c\xa9\x08\x8c\x5e\x49\x93\xc4\x18\x48\xcf\xa1\x01\xe1\x44\x18\x46\x6f\xd4\x8f\x50\x57\x13\x91\x07\x30\x11\x07\x1d\x50\xf8\x61\xdd\xba\xe3\xe0\x35\xad\x8a\xbc\x29\x11\x80\xd0\x43\x32\xd4\x67\x9b\xcf\x9d\xdb\xdc\x76\xbf\x11\x84\xd0\x69\x7c\x88\x79\x0d\xd2\xe8\x23\xfa\xab\xb9\x26\x5a\x96\x81\xe8\xb2\x8a\x56\x7f\xc0\x04\x77\xb1\xc9\x24\x12\x22\xd4\x34\xa2\xc2\x39\x08\xa8\x31\x69\x12\xe9\x9b\xd3\xb1\xb4\x46\x39\xed\x02\x45\xd8\x8b\x45\x52\x8a\x53\x49\x12\x26\x3d\x30\x5a\xc7\x2b\xa0\xa4\x15\x14\x69\x7f\x06\xd2\xf9\xb7\xde\x7b\x59\xab\xd3\xde\x06\x7f\xfb\xf9\xd7\xb9\xab\x7e\xa1\xeb\xc0\x46\xed\x86\xb5\xda\xa7\x8f\xec\xbe\xff\x29\xea\xc9\x8b\x6f\xbe\x3e\x61\x32\x92\xe7\x1e\x50\x9e\xcf\x61\x1c\xed\x69\x6a\x8d\xdf\xe7\x33\xe5\xc0\xfd\x68\xb7\xe7\x4a\x26\x27\x54\x8d\xc8\x79\xcb\x8b\xba\xb3\x51\xc9\x19\x21\x38\x85\xe6\x78\x0e\x42\xee\xf3\x3b\x39\x4a\x72\xc0\xff\x71\xc8\x30\x11\x2d\xd0\xfb\x19\x4a\x69\x99\x9e\x69\x2a\x32\x3d\xbd\x1a\x03\x2d\x41\xcd\x8e\xf1\xfb\x92\xf1\x03\x84\x5b\x01\x4f\x46\x52\x3f\x19\xc9\x5e\xfc\xad\x8b\x63\x0d\x6a\xe7\xed\xfd\x7e\x7f\xe7\xab\x1f\xd9\x0e\xec\xdb\x77\xc0\x0b\x36\xaf\x7d\xb1\xcb\x03\x91\xfa\x61\x55\x0b\x6f\xe2\x41\x3f\x72\xe2\xc5\xbf\x56\x4c\x5c\xd2\xe5\xf4\x13\x00\x1a\x8e\x6d\xfb\x50\xcc\x9c\xbc\x66\xdf\x93\xdd\xa7\x8f\x2b\xfd\xf3\x7f\x36\xe2\xfd\x7a\x2d\x9c\xdf\x6e\x5c\xa3\x30\x4d\xed\xc2\x00\x20\xbb\x5c\x6c\x4e\x8e\x42\x06\x6c\x56\xb8\x04\x64\x20\x92\x9b\xed\x81\x87\xb9\x8b\x17\x1b\xe3\xbc\xe8\x22\x18\x68\x04\xca\x4c\x19\x03\xfc\x8c\xcd\xc6\xf8\x29\x92\xd2\x8b\xfc\xf5\xc9\x8d\x4f\xce\x2e\xed\x1a\x29\x7d\x82\x15\x89\x5b\x8d\x18\xba\xd4\xcd\x3c\xeb\x1d\xc9\x46\x30\x64\x3e\xe0\xf6\xef\x3f\x60\x3d\x7b\x74\xdd\x31\xcf\xe3\x96\xb1\x23\x67\x4c\x66\xc1\x50\xed\xb0\xed\x7c\xc3\x75\xd6\xc7\xe4\xdf\x6f\x3e\x7a\xde\x02\x3e\xd1\xb2\xe0\xf9\x50\xfc\x15\x71\xe9\xe1\x7b\xec\x63\xa6\x1f\x38\xb6\x42\xdb\x38\x65\xa6\xf5\xbe\x56\x68\x26\xa4\xea\x79\x4e\xe2\xd8\xaa\x13\xda\xb4\x51\x89\x84\xca\xc8\x62\xa6\x19\x91\x43\x81\x1e\x9e\xb1\x12\xb4\x4b\xa1\xa0\x8d\x8e\x32\x1c\x79\xab\x99\x62\x00\xef\xc0\x7d\x4d\xda\x2b\x21\x4c\x3e\x6e\x68\x86\x2f\x72\x23\x78\x4d\xe0\xdf\x20\x26\x00\x56\x00\xe1\xfc\x68\x3e\x7d\xf2\xcc\xf3\xb7\x3d\xb9\xf8\x79\x84\x06\x7d\x8d\x29\x3f\x6f\x18\xe8\x3b\xb4\x38\x4c\x3a\xdb\xbe\x41\x7f\x98\xbe\x8f\x66\x6d\x98\xf6\xe1\x87\x8b\x16\xeb\xb6\x36\xbd\x1a\xeb\x61\x07\xa2\xcb\x9a\xa0\xcb\xc1\x09\x98\x2e\x81\xa0\x9d\x32\xc5\x39\xb8\xc6\xb8\xc3\xc1\x0b\x66\x01\xd2\xa5\xfc\x1f\xe9\x42\x80\xa2\x02\x49\xaf\x3e\x73\xf7\xc2\xfd\x73\xef\x3a\x0b\x0e\xfd\xa9\x74\x58\xa8\xc8\x5e\x33\x04\xdc\xa8\xdd\x8d\xfe\x40\x0f\xe0\x85\xb3\x57\x6f\xae\x3c\xf6\x2a\xe6\x55\x0f\x48\xd3\x79\x9c\xd3\x11\x20\xa6\xa8\x55\x28\x25\xd0\xc3\xa1\xf2\x50\x9a\x91\xcc\xe8\xaa\xd0\x4b\x3a\x21\x99\x84\x93\xe1\x6d\x4c\x30\x8b\xa3\x2c\xa2\x05\xaa\x6e\x51\xb4\x39\x1d\x94\x9d\x82\x4e\xbe\x0d\xb3\x2e\xa6\x43\xda\xc7\x12\x70\x67\xc9\x0e\xb9\x15\x52\xf2\x9a\x3c\x99\xcd\x90\xa4\x57\x36\x64\x5c\x4e\xe3\xe7\xf9\xbd\xdb\x9b\xf7\x8e\xdd\xbe\xf7\x81\x67\xf7\xed\xfb\xf2\xcc\x9e\x61\x5c\x30\xa4\x02\xae\x87\x57\x49\xf0\x54\xe7\x6b\xdb\x74\x72\xeb\xa3\x59\xab\x6e\xfa\xf0\xc3\xab\x27\xc0\x79\x5c\x8b\xd6\x1c\xf2\x96\x24\x5c\xc4\xf5\x6a\x35\xc1\x01\x96\x65\x5c\x02\x24\x91\xb4\xda\x68\x80\x6e\xfa\x6c\x76\x45\x92\x1c\x0e\xbb\x99\xa1\x3d\x6e\x59\xb0\x9a\x44\x05\x5a\xb9\xa4\xa2\x50\x76\x33\xeb\x50\x00\x25\xe8\x8a\x3a\x35\x8f\x24\xba\x52\xea\x34\x82\x93\x48\xcc\x44\x07\x9a\x81\xc7\x79\x0c\xb4\x9f\x50\x98\x5a\xbf\xf0\x96\xaa\x3b\xc0\xf4\x5d\xb3\x47\x6e\x6f\x9a\xb5\x6f\xf1\xfb\xd0\x2d\x63\xc0\x2f\x60\x93\x36\x8b\xec\x05\xfd\x1c\x63\x31\xc0\x6c\x6d\x03\x5c\x90\x67\x8d\x98\x0a\x9c\xc3\x33\xb8\x16\x27\x8b\x68\x56\xcb\x82\xfe\x2c\x68\xd1\x30\x4e\x2f\x11\x08\xe0\x4c\x4d\xd9\xc9\x32\x8c\x33\x94\x6d\xb1\x7b\xed\x2d\xf1\x00\xe1\xf5\x3a\x7d\xbe\xac\xe6\xb8\x8f\xb2\xb1\x4e\x5d\x80\x13\x09\x9b\x1d\x01\xb3\x0d\x94\x95\xe4\x0d\x63\x16\x19\x04\x11\x0c\x9d\x06\x29\xb6\xeb\x3f\x40\xdd\x03\xc2\x40\x0e\x53\xe5\x9b\x0f\x0c\x6e\xed\x72\xfb\xc2\x17\x96\xae\xa9\x6b\x1d\xf6\xc4\x3d\xda\x19\xea\x3b\x4d\x78\x51\x9b\x43\x31\xf6\xf9\x7f\xfc\xe8\xfc\x5b\x27\xb7\xf4\xa3\xdb\xd6\x93\x73\x98\x81\xdb\x8f\xbd\x75\xfe\xfd\x77\x6e\x11\x48\xb5\xed\x18\x78\x0c\xcf\x23\x02\xe7\x71\x00\xae\x85\x0f\x7a\x17\x63\xd5\x32\xbb\x10\x70\xba\xe4\x60\x90\xe3\x4c\x7e\x05\x8a\x92\x62\x72\x0a\x4c\x56\xb6\x4b\x96\x83\x2c\x1f\xe4\x9b\xe2\xc1\xa0\xe0\x74\x42\x3f\xcb\x29\x98\x80\xa0\xa4\xcf\xc3\x28\x34\x8a\x65\xc0\xc7\xa6\x12\xf8\x93\xf4\xe7\xd8\x01\x9e\x40\x35\xa2\x3f\x8b\x54\x40\x58\xa6\x0f\x1c\xa8\xbf\x63\xc5\xa3\x8b\xd6\x74\x3f\x70\xf4\x3d\xed\x2c\xf5\xae\xf6\xea\x96\xc7\x1b\xb4\x6d\xda\xb0\x3f\xf7\xbb\x7b\x63\x1f\x5a\x6b\x02\x4f\xf6\xbd\x67\x43\xbf\x7e\xda\x5f\x9c\x24\xdb\xf6\xab\xfd\xfa\xd3\x4f\x52\xd3\xb4\x25\xc6\x9e\xd8\x87\x73\xc6\xf3\x88\xb9\x6a\x5d\x6e\x4e\x5e\x38\x27\xcc\x2a\x21\x22\x12\xb1\xdb\x9c\x0a\x94\x23\x7b\x80\xcd\xf6\xfb\x03\xd0\x5d\x0a\xe4\x47\x05\xab\x2f\xdb\xd7\x1c\x8f\x10\xd9\xd9\x81\x70\x38\xaf\x39\x1e\xa6\x82\x94\x62\xe7\x02\x89\x8d\x91\xb1\x28\xb1\x0e\xfa\x3f\x69\x2a\xa7\x2d\x0e\xd5\x71\x71\xaa\x6b\x12\xb2\x05\x97\x28\x42\xad\xbc\x7e\x5e\x35\xff\x50\xb8\x71\xf0\xfe\xa1\x23\x22\x0f\xf9\x7c\xb7\xef\xdd\x0b\x16\xbc\x4d\x9e\xd5\xf6\xcc\xfd\x91\x62\x6c\xe3\xb7\xbc\x3c\xef\xfc\x5b\xef\xac\x52\xf5\x65\xea\x7d\xd7\xb9\xb7\xce\xbf\xf0\x48\x97\xb6\x7b\xe0\xce\x79\x91\xec\x91\x5c\xab\x52\x38\xd7\x56\x1c\x1b\xcb\x25\xe6\xa8\xb5\x39\x6c\x84\x61\x19\xab\x9f\xa3\x73\x73\x9d\xb2\xcf\x2f\x3b\xfd\x4e\xc2\x66\xa5\xc2\x61\xc2\x4a\x44\xf3\x14\x47\x08\xc1\x13\xe7\x72\x14\x45\x30\x4c\x04\xc5\x0b\x81\xe0\x77\xda\xf4\xd0\x58\xc5\x6f\x4c\xf5\x0a\x33\x8d\xe9\x13\xa2\x32\xa4\x31\xb5\x9a\xd0\x51\x88\xc8\xa5\xad\x60\xe5\x5b\xe4\xd9\xb3\xb3\x6f\xad\x3a\x10\x6a\x68\x78\x74\xf0\x90\xf0\x81\x2e\x5d\xdf\x21\x37\xfd\xb8\x08\xee\x9d\x5f\xd1\xe2\xd9\xc6\x3d\xf9\xe7\x7e\xfd\x9e\x9b\x5f\x49\xa1\x65\xad\x5e\x72\xa4\x5f\xbf\x1d\xfb\x8b\xb5\x26\xea\x49\xb8\xa0\xf8\xbc\x1b\x02\x6d\xe0\x71\xec\xd7\xc4\x48\x62\x9d\xda\x24\x88\xd5\x83\x15\x67\x44\x76\xf5\x54\xf9\x28\xd1\xa9\x53\x54\x0d\x14\xba\x18\xe7\x60\xd1\x7c\xd5\xa8\x6e\xbd\x9b\xe3\x15\xc3\x5a\xe2\x85\x0c\xcd\xd0\x2d\xf1\x88\x0c\x4f\x46\x6b\x73\x1c\xea\x62\x3b\xd5\xad\x82\x11\x5c\x2e\x81\xa9\xe8\xc6\x0c\xf0\x0d\xe8\xd2\x1c\xef\x39\xc0\x97\xdd\x12\x77\xfa\x88\x32\x54\xf2\x0f\xff\xc2\xd8\x6c\x1e\xdc\xb8\x18\xfb\x72\x3a\x0c\x3c\xe4\x49\x26\x46\x55\xda\x99\xdf\x3e\xcb\x10\xee\x41\x68\xfb\xd5\xe0\x16\x55\xb8\x21\x9a\x00\x70\xd0\x4c\xcf\x3a\xa4\x70\x05\x2c\x4a\xb5\x42\xee\x54\xa4\x32\x92\x63\x27\x8d\x2a\xe6\x9a\xee\x34\x75\x1f\x4a\x44\x3c\xf2\xf8\xc6\xd5\x4b\x0e\xc6\x0e\xd7\xbc\x78\xef\x33\x3b\xf7\x8d\x0d\x0e\xa8\x1e\x51\xd2\x4b\x0a\xd8\x15\xdb\xd5\xf7\xb7\xde\x7d\xc7\xb6\x03\xe5\xc3\xe7\xad\xbf\xef\xde\x99\xf5\xfb\xeb\xae\xbf\x76\x7c\xc9\x84\x99\xdb\x06\x05\x47\xcd\x58\xd2\xfb\x8e\xbd\x23\x77\x3e\xb0\x79\xc6\xe8\x1e\x11\xb0\x79\xd5\xcd\x5b\xe6\x2f\xbc\x7e\xe1\xbc\xdb\xba\xdd\xf9\xb0\x0f\x8c\xd0\x9e\x7b\xb7\x77\x97\x86\xee\x59\x42\xf0\xd5\xc0\xef\xef\x5a\xfa\x50\xc8\xfd\xe4\xca\xb1\x2b\xc6\xd5\xe7\x3a\xa4\x50\xac\x70\x86\x3f\x1c\xb8\x6d\x52\x43\x20\x27\x70\xf7\xad\xa3\x67\x75\x17\xec\xae\xbc\xee\x71\x54\xeb\x04\x7d\xe5\x5f\x99\x47\xa1\xa7\xbc\x4e\xcd\xaa\x25\x9c\x8a\xd7\x93\xef\xf6\xd9\x8b\x4c\x9d\xfb\xf4\xee\xdd\x39\x54\x54\xe2\x33\x43\xbf\xcc\x3c\x74\x98\xda\x0f\x45\x5b\x95\x78\x89\x05\x9a\xa6\x8d\xf1\x3e\xaa\xc5\xe9\xb4\xa8\x7d\xe8\xc1\xee\xc1\xf5\x18\x51\x68\x70\x00\x21\x0d\x79\x55\x7b\x3c\x2b\xdf\xed\xf6\xf8\x54\x9f\xd4\x18\xf7\x89\x46\x9f\xcc\x0f\x21\x27\x5f\x4a\x78\xd1\x06\xfb\x75\xa6\x5f\x9e\xe7\x6e\xcc\x2d\xb2\xaa\x32\x5c\x95\x96\xdd\x79\x05\xb6\x2b\x7a\xb6\xe7\xe5\xf9\xbe\x75\xc0\xaa\x35\x2b\xaf\xaf\xd5\x8e\x3c\xb0\xed\xda\xf1\xf1\xd9\xd6\xbd\xb9\x7f\x7c\x3e\x93\xe5\x63\x6f\xbc\x63\xe3\x94\x05\xdb\x87\x1f\xfc\xdd\x8d\xc3\x8a\xb6\xd5\x8d\x1b\x3e\xb4\x64\xec\x74\xc8\xf0\xbe\xa3\x67\xf4\x59\xb8\x6b\xf7\xd0\x6b\xbb\x3a\xe5\x92\x21\xdd\x5e\xbd\x73\xe4\xd5\x83\x46\x0d\xea\xe7\x3c\xdb\x09\xc4\x53\xdc\x7e\xd3\xb7\x61\xf2\x75\x77\xf0\xa4\x6d\xc3\xcc\xe6\x55\x8d\x3e\x39\xbb\x34\x77\x6e\x76\x6e\xf6\xe2\xa9\x0d\xc1\x48\x70\x2b\xf2\x47\x2e\x19\x78\xfe\x41\xa2\x8f\x9a\x13\x94\x44\xc2\x2e\x52\x82\xc0\xb9\xdc\xee\xac\x6c\x13\xc7\x65\x05\x70\x4e\xb0\x64\xb7\xbb\xd0\xcd\x7f\x26\xa6\x7f\xca\x13\x49\x46\x60\xc2\x52\x4e\x29\x89\xd3\x7d\x29\xcc\xac\x0c\x58\xff\x95\x73\x87\xf6\x2b\x9a\xf4\xc0\xa4\x50\x49\xe7\x7e\x4d\x18\xdc\xff\xd3\x33\x75\x60\x5d\xc1\xb5\x2f\x3d\x83\xd0\xfd\xd7\xdf\x3e\x30\x2b\x85\xef\xff\x2f\xed\xeb\x04\xbe\xbf\x02\xf7\xde\x04\x7c\x47\xd2\x5d\xcd\x32\x7b\xbd\x16\x8f\x87\x71\x48\xd0\xc0\x80\x1e\xbb\x87\x96\x04\xc2\x6d\x75\x63\x18\x41\x4b\x20\x1d\x46\x30\xe3\xf8\x8a\x75\xc4\x11\xd4\xe9\x24\x11\x8e\xe0\xdd\x7b\xef\xda\xf3\xb7\x6f\x77\xcf\xb8\x6d\x78\xde\xfc\x87\x97\xb9\x8a\xba\xd7\xec\x9e\x4f\xee\x3a\x44\xce\x69\xbb\xfb\xe7\x4f\x75\x34\xc1\xa6\x27\xce\x90\x2b\xdb\x86\xdf\x32\xb3\x0c\x50\xa7\xf4\xbc\xb0\x54\xcf\x13\x54\xbd\x35\x40\x8d\x86\xed\x76\xd6\x19\x0c\x12\x2c\x51\x50\xe8\x77\x41\x95\x0e\x37\xbe\x3f\xe2\x8f\x50\x3c\x9f\x8d\x1b\x9c\x48\xed\x1a\x9c\x18\xb9\x28\xed\x11\x99\x53\x3d\x4e\x40\x0e\xe7\xc3\x57\x59\x2c\x02\x20\xc8\x83\xce\x69\x38\x44\x21\x44\x1a\x32\xd9\xef\x04\x03\x43\xb5\x0d\x1b\xd8\x8d\xde\x75\xcf\xfa\x2d\x62\x71\xb4\xeb\x94\x96\xf1\xe0\xba\xa2\x7c\x93\xf6\x96\xf6\x7d\x4e\xb7\xde\x3d\xae\x1b\xd7\x9c\xd6\x03\x45\x87\x8b\x7a\xc4\xa3\x5d\xd2\xfe\xe7\x4f\xe7\x6d\xc5\x55\xc5\x76\x0b\xd0\xb4\x19\xee\x4e\x95\x9d\xf4\x79\x21\x2c\xfd\x01\xd0\xb6\x37\x43\x8e\xa3\xba\xfc\x68\x8e\xcd\xc6\x06\x64\x19\xce\xab\xb0\xc8\xa7\x40\xfd\x6d\x81\xbb\x27\xd7\x97\x4b\x99\x4c\xd9\x8d\x71\x93\x48\x89\xed\xca\x90\xaf\x30\xaf\x14\xd2\x74\x0e\x97\x95\x31\x2d\xdd\x98\xd7\x27\x36\xe0\xd7\xef\xbe\xfd\x17\xf8\xf4\x97\xaf\xda\x6e\xe9\xdb\x8d\x59\xb7\xfe\xde\xb5\xfc\xc0\xea\xca\xd1\x43\x07\x81\x68\x8f\x6e\x96\xdb\x37\xdc\x79\x97\xd4\xbd\x47\xc5\xb0\xc1\xc3\xc8\x2c\xed\x1f\xda\x57\xf0\xc4\x96\xc8\x72\xed\x7b\xed\x8b\xc8\xeb\xa7\x9e\x3a\x16\x0a\x17\x86\xb3\xc3\x47\x9f\xd8\xbe\x27\x2b\x5c\x10\x26\x8c\xde\x2d\x4c\x67\x66\x18\xb4\x51\xcb\x55\x0f\x20\x58\x96\xb4\xd9\x14\x8a\x24\x9d\x8a\x59\x6c\x8e\x9b\xa1\x2f\xc2\x02\x5c\x60\x98\x00\x3c\x4d\x5d\x9d\x87\x91\x33\xed\x72\xfb\x41\xaa\xc1\x24\x47\x9e\x3f\xab\x71\x67\x80\x5a\xd0\xa9\xe9\x4c\xfd\xee\x01\xd7\x16\x4f\x2c\xee\x94\x55\xe2\x64\xfa\x5e\xbc\xf5\x96\xdd\xa0\x13\x79\xe8\x6c\x55\xf1\xec\xd2\xae\xbd\xf0\xd8\x23\xe0\xfe\x7a\x1d\xf2\xd2\x49\x94\xaa\x2e\x8b\x59\x14\x29\xe8\x20\x29\x94\xcb\x2a\x88\x16\x85\x60\x87\xc7\x89\x44\xd1\x6c\x7a\x4e\x71\x02\xc1\x4e\xaf\xfb\x47\x66\xb9\xcb\x5d\x23\x77\x07\xd4\x2f\xc9\xe1\x2e\x7e\xa4\xcd\x3f\xf1\x9d\xad\x8b\x7a\x6f\x68\x2e\x3d\x54\x1f\xf1\xe2\xdb\xf0\x40\x53\x0b\x5e\xfe\x9a\x34\xcf\x6c\xd6\xef\x79\xf0\xdc\xd9\xfb\x1d\x51\x1a\xf7\x0a\x23\xdf\x24\x3d\xc4\xbf\x71\xcd\x5b\xb6\x5e\xf3\xb6\xb0\x35\xe0\x25\x6d\x19\x77\x94\x98\x66\xe6\x11\xf8\x99\x3c\xe3\x33\x15\x06\xb6\x5d\x48\x47\x89\xdc\xdb\x1a\xf4\x59\xd3\xb0\xed\xa0\xcc\x64\xc3\x3d\x7a\x86\x19\x4d\x48\xd0\xf6\x44\x77\x38\x25\xf9\x1e\x8b\x39\xdb\x21\xf0\x56\x9b\xdd\x6e\x25\x1d\x66\x0f\x5b\x56\xee\x8f\xb4\xc4\xfd\xb4\x52\xdc\x12\x57\x64\x9b\x59\x10\xac\xd0\x6d\x62\x5a\xe2\x08\x7c\x4c\x47\xbc\x31\x4a\xa0\x8b\x33\x71\x56\x75\xd4\x5e\x3d\x8d\xa0\x07\xc0\x3d\xad\x28\x3b\x48\xa4\xc4\xe1\xa2\x46\xaa\x52\x87\x45\x50\x9c\xba\x0f\x4c\xbe\x50\x19\x0d\xe4\xd4\x0e\xcb\xb3\x69\xff\xdc\xf3\xd4\xba\xdd\xff\xac\xbc\xed\x95\x55\xf7\x6d\x5b\xb9\x6a\xc7\xf5\x0b\x6b\x76\xbb\x2a\x2b\x2a\xab\xdc\xae\xca\xf2\xaa\x2a\x8f\x36\xda\xb2\x9a\x9d\xbf\xac\x98\xae\xba\xf8\x1d\xe5\xb8\x70\xfa\xab\xe3\xf4\x10\x6d\x95\xf6\x12\xe8\x05\xe6\x81\xe5\x20\xb6\x42\xfb\x5c\xfb\xe2\xbb\x4f\x26\x4d\xff\xea\xe3\x0f\xbe\xb9\x61\xca\xf7\x89\xb9\xc2\x35\xe5\xe1\xfe\x28\x26\x46\xa8\x25\x0e\x3a\x2f\xd7\x4c\x14\x46\xa2\xf9\x05\x05\xd1\x00\x91\x4b\xb3\x9d\x4a\xf2\x73\x85\xc2\x68\x44\xf1\xc1\x0d\xe2\x0b\x70\xf6\xa6\x38\x27\x92\xae\x26\x1d\xbe\x22\x71\x69\x6b\xcc\xf9\x32\xb3\x4d\xb5\x36\x6a\x37\xb1\x8e\x7c\x20\xc7\x6a\x1f\x6b\xff\x58\xbb\x65\xf3\x1a\x3c\xaf\x6a\x97\x2b\xd6\xb9\xaa\xda\x0d\xc8\x0e\x1c\x20\xb3\xda\x5e\x27\x2b\x80\x17\xb8\xb5\x7f\x6b\x1f\x1c\x3d\xd8\x30\xe2\xe8\x43\x0f\x1f\xb9\x6a\xd8\x33\x17\xff\xde\x9e\x07\x06\x66\xc2\x6e\xa8\xdf\xf6\x11\x6e\x38\xcb\xeb\xd4\x9a\x1c\x6b\x28\xd7\x57\xe4\x21\x88\xa2\x5c\x2b\xdd\xa9\x24\x18\xf4\x85\x84\x50\x73\x5c\x11\x04\x47\xb6\x83\xe4\x29\x87\x43\xa0\x8a\x72\xf3\xf3\x73\xf9\xdc\xe6\x38\xc1\x8a\x2c\xc9\xb2\x94\xee\x18\x97\x8d\x37\xb0\x3a\x62\xfa\x7d\xbe\x94\xe8\x0e\xd6\xbe\xa0\x4d\x24\x39\x1d\x01\x08\x23\x6e\xd6\xe8\xcd\x3f\xe1\xf2\x8a\x3a\xda\x4a\x3e\x2b\x89\x3a\x2c\xa7\xbb\x9a\x9e\x7c\xf8\x71\xd7\xa8\xaa\xea\xab\xdc\x4f\x3e\x79\xf4\xa0\x7b\x64\x2c\x36\xc2\xfd\xc4\x91\x33\xbb\xdc\xc3\xcb\x3b\x0f\xf7\xec\xdc\xe3\x19\x56\x5e\xde\xe8\xd9\x0d\x35\xdf\xb7\xda\x43\x5d\x4a\xba\xd4\x74\xaa\x06\xe3\x80\x02\x4d\xc3\x86\x8a\xa2\xca\xca\xa2\x0a\xed\xb0\xf6\x0f\xb0\x70\x66\x7e\x59\x59\xfe\x0c\x6d\xa5\xb6\xf4\xa6\x68\xa7\xb2\xe8\x0d\x70\xde\x5d\x2f\x6d\xa0\xef\xa6\x1f\x87\xa7\x5d\x11\x31\x53\xed\x2a\x13\x05\xae\x9c\x40\x36\xcf\x07\x5c\x04\x5d\xdc\x09\xfe\xed\x05\x66\xca\xeb\x75\x89\xae\xc6\x38\x4e\x77\xe7\x29\x28\xe3\xa2\x2b\x2f\x2f\xa7\x80\x2a\x68\x8c\x73\x94\xc0\x64\x33\x24\xc3\x18\x61\x8c\xe4\x6c\x11\x27\x0c\xb3\x4e\x8f\x3a\xc6\x3a\xe0\xb0\x38\x6a\x10\xc0\x0c\x8d\xc0\xf6\x50\x8c\x27\x4a\xca\x4e\x97\x31\x63\x1d\xa9\x5c\xe7\x83\x1d\x74\x7d\xe3\x5c\xa7\x49\xd7\x94\x80\x1d\x6f\xbd\x5a\x72\xcd\xc4\x92\xd3\xef\xfc\x7e\xfa\x6c\xc7\xe0\xea\xaa\x81\xf2\xdc\x29\x53\xe7\xc8\x83\xaa\xe0\xab\x79\x53\xc9\xac\x5f\x80\xdf\x33\xe9\xda\x12\x0d\x5c\xd0\xbe\xf0\x5e\xdb\x22\x03\x3f\x00\x27\xdf\x72\x97\x77\xad\x2b\xf5\x9f\x3f\x7e\xf2\xbc\xa7\xb4\xae\xb6\xc4\xf7\x07\xb4\x87\x51\xad\xeb\x6b\xdc\x7b\x44\x19\x51\x07\x6d\xae\xc5\x6a\x9f\xa0\xd8\xbb\x4f\x97\xf2\xf2\xba\x88\xa5\x90\x65\x1b\x08\x4b\x9d\xab\x8f\x68\x1a\x3a\xac\xae\xb6\x25\xde\x50\x5f\xdf\xa7\x93\x4f\xf6\xa1\x03\xad\xae\x4f\xb5\x2c\x57\xf7\xa9\xa3\xfb\xdb\xfa\xf7\x5c\x1f\xef\x6f\x8b\x86\x6c\x50\x30\x22\x16\x0b\x6f\xc3\x37\xb4\x52\x12\xd7\x2a\x65\x60\x25\x9a\x1c\xb5\x43\xd7\x48\x4a\x42\x2a\x64\x99\x71\x4d\x8b\x76\x83\xfe\x43\x75\x4d\xea\x52\x17\x2a\x49\x6c\x64\x45\xaa\xab\x22\x55\x28\x8b\x0c\x43\xb7\x19\xbd\xc2\xe1\xdb\xc8\xaf\x42\xbd\x3a\xdf\x7f\xe8\x95\x43\x5b\xaf\x1e\xbd\xf5\xd0\x2b\xbf\xbb\xbf\x73\xef\x50\x8d\xad\xda\xd9\xbf\x61\xe1\xd4\xba\xa9\x59\xd9\x53\xeb\xa6\xdd\x3a\xb8\xbf\x5c\x6d\x9b\x6a\x71\xe5\x4d\x1f\x31\x94\xec\x3d\x78\xc3\xf0\xd1\x73\x6b\x8e\xe6\x2e\xf7\x1d\x5d\xd9\x75\x61\xcb\xb8\xe5\x3d\x99\xd1\xc1\x1c\x6d\x85\xf6\x84\x76\x50\x5b\x30\x73\x26\xb8\x1d\x5c\x05\x46\x82\x85\x39\xc1\x2d\x4a\x8e\xf6\x2e\xdc\x50\x17\xb5\x17\xaf\xea\xd7\xef\x2a\xd0\x13\x90\xf0\xab\x73\xc8\x4d\xaa\xd7\x14\x75\xad\xac\xbb\xa6\xff\xba\x65\x55\x5d\xba\x76\xfe\xf0\xc1\xd6\xd2\xae\x75\xe5\x90\xcf\xf9\x28\xe6\xc3\x6e\x81\x7e\x6e\x29\xd1\x93\x98\xaf\x76\xf2\x48\x35\x5d\x3a\xe5\xe6\x96\x66\x59\x09\x8e\xeb\x49\x59\x4b\x95\x2e\x92\xa9\x57\xef\xfa\xaa\xf5\xf1\x7a\x67\xcf\xb2\xb2\x2e\xce\xd2\x92\xc6\x78\xa9\x13\x4e\x52\x41\x96\xae\x14\x2f\xa2\x9d\x62\xd8\x6f\xf7\x37\xc6\xb3\xac\x56\xb3\xdd\x95\xc6\xe5\x1e\xb1\xd3\x06\x9a\x05\x02\x70\x3b\x5d\x51\x16\xc3\x7c\xef\xc8\x61\x9c\x63\xd7\x8e\xc5\x4a\xb2\x7b\x28\x3e\x9f\xc1\x6f\x72\x95\xfa\x72\xd1\xa6\xbf\x7d\xfd\xf0\xc3\xeb\x27\x4d\x59\xfb\xd0\x23\x5f\xff\x6d\xd3\xa2\xab\xc6\x77\x9b\x97\x95\x3d\xb7\xdb\xf8\xab\xb4\x37\xaf\xcc\x49\x32\xe7\xc3\x63\x5b\xb5\x8f\xb4\x7f\x6a\x9f\x68\xdf\x8c\x18\x01\x64\x90\x0d\x04\x10\xde\xfa\xcc\x5f\xbf\x3c\xde\xb5\xb8\xb8\xeb\x09\x7a\xe5\x65\x39\x87\xce\x26\x1c\x27\x60\xbf\x84\x67\x93\x88\x6b\x8e\x7e\x25\x27\x83\xa9\x84\xe5\x28\x20\xea\xca\x82\x38\x3c\x8b\xcf\x3d\xfd\x9e\x9d\x59\x0e\xdf\x27\x19\xef\x1b\x68\xc4\x33\x43\x28\xc2\x11\x76\x99\xc9\xcc\xba\x67\xed\x2a\x8c\x4b\xe9\x22\xea\xd5\x2c\xa7\x89\xa2\xed\x36\x1b\x6d\xa2\xdc\x1e\xbb\x9d\x31\x9b\xa1\xdd\x66\xa6\x69\x3f\x43\x34\xc7\x19\x39\xb3\xb5\x4e\x66\xa1\x08\xc2\xa1\xc4\x30\x9e\xe1\x74\x61\x25\xef\xe9\x59\x72\xfc\x1f\xdf\x93\x9e\x87\x3e\xef\x8b\xaa\x92\x1f\x7b\xf0\xb1\xd5\x42\xdb\x71\xb0\xd3\x0f\xa6\x82\x2a\xf2\xd0\xde\xc7\x7b\xce\x5e\xa1\x69\x50\x51\x7d\x8f\x5b\x8c\x40\x7a\xf6\xc3\x33\xa6\x90\x1e\x02\x75\x2f\xa4\x47\xa2\xdd\x84\x05\xc5\x5d\x28\x8f\xd7\x62\x01\x1c\x67\xc7\xd0\x9d\x4e\x0c\x36\x11\x48\x65\xdf\x75\xa0\x47\x47\xef\xec\x88\x95\x49\xf6\x79\xfd\x2d\x40\x7c\xf1\xd0\x07\x81\x63\xf6\x39\xd3\xb6\xaf\xdf\xbe\xa5\x5b\xa9\x36\x1a\xec\x86\x86\xd9\x45\x60\x03\xde\x83\xf7\xda\xc7\x4c\x3f\xf5\xd6\x1f\xde\x73\xb4\xbd\xac\xd3\x33\xeb\xd2\xc7\x74\x33\xf3\x3e\xae\xdd\x2a\xe4\x4c\x70\x2c\xda\x61\xb2\x9b\x59\xa7\xc2\xf2\x3c\x65\x85\x16\x95\x2c\x5a\x19\x8b\x08\x04\xc6\x02\x04\x01\x58\x18\xda\xe4\x30\x21\xe0\x3d\x7c\xc1\x5b\x66\x00\x65\xa7\x65\xb9\xa6\x50\x6a\xb8\x3c\x8a\x81\x7f\x22\x72\x5e\x0d\x83\xff\xc4\x28\xba\xb9\x50\xdb\x3d\x14\x4c\x2a\xd4\xee\x5b\xf6\xc0\x5d\xda\x43\x85\x60\x5c\x83\xf6\x40\x21\x98\xb8\x64\xf7\x9d\xd4\xc6\x6d\x13\xb4\xaf\x9b\xb7\xb5\x68\x55\xe0\xc7\xf1\xdb\x26\x00\x65\xc2\xf6\x66\x70\x4a\x53\x50\x3f\xe2\xbd\xf4\x42\xd0\xc2\xa0\x3e\xe7\x39\xaa\x9d\xb1\x58\x5c\x50\x4c\x5c\x94\x6c\xb2\xdb\x21\x31\xb1\x32\xd1\x68\xf6\x6f\x8c\x8c\x2e\xf9\x75\x60\x4e\x9c\xa9\xae\xc3\xb7\x81\x96\x81\x55\xda\x83\xbd\x4b\x2b\x7a\x0d\xac\x02\x63\xd1\x77\x66\x76\x45\x57\x67\x97\xae\x6a\xa5\xfe\x0d\x8d\xf3\x3c\xfd\x1a\x18\xc2\xbc\x08\xf9\x11\x56\x05\x42\x96\x79\xa7\x48\xad\x8f\x8b\x84\x99\xe7\x09\xa2\x0c\x6d\xba\x73\xa8\x6f\xb4\xae\xd5\x75\xeb\x96\xd5\x1d\xf5\x1a\x8c\xdf\xf2\x23\x59\x55\x15\xee\x15\x9d\x3b\x75\xf2\xb4\xca\xab\x8b\x26\xf6\xbb\x76\x0a\xfd\xda\x20\x35\xea\x1e\xb0\x21\xe4\x2c\x5d\xbc\x00\xc7\x8a\x76\xd3\x03\x89\x6b\x98\x73\xd0\xce\xf0\xab\x16\x9a\x20\x50\xb6\x21\xc9\xa0\x40\xe4\xb9\xda\x32\x63\x1a\xf0\xe9\x4a\xc4\x89\x7a\x50\x75\x03\xd7\xc4\x87\xce\x8f\x64\x31\xe7\x9e\x9d\x70\x7d\x6c\xce\x90\x4d\x1d\x9f\xc1\xe1\x67\x98\x4c\x97\x79\x06\xf4\x89\xf0\x36\xbf\x26\x90\x37\x7f\x68\x9c\x39\xb7\x69\xd0\xcc\xba\xeb\x27\xa0\x8b\x45\xd0\xf6\x36\x53\x4f\x96\x42\x7d\x25\xa3\x7e\x20\x28\xfe\xe7\xb4\xb1\x1b\xe2\x36\xb3\x4a\xc8\x1b\xe2\x04\x34\x31\x21\x63\xb1\x23\x7d\x3e\x39\x65\x60\x68\x0b\x36\x5d\x09\x97\x4e\x3e\x76\xdd\x9c\x3b\xfb\xdd\xbc\xda\xb3\x3c\xf4\xd1\xfe\x9e\x2b\x96\xde\x70\x60\x1c\xd3\xbd\xaa\x4b\x8f\xd2\x99\x37\xee\x3f\x52\xa4\xd6\xa2\x36\x87\x84\xe9\x62\x9e\x76\x80\xfa\x80\x79\x1a\xd2\x2c\x43\xbf\x34\x9f\xe8\x4c\xd4\x13\x7d\x89\x61\xc4\x03\xea\x55\x9d\x87\x95\x0c\xf6\xf6\xec\x39\x78\x18\x55\x2f\xd4\xc8\x35\x8d\xc1\xbe\x7c\x7e\xdf\x7c\x99\x89\x44\x64\xb9\x29\x2b\xd2\x8f\x1a\xdc\xbd\x77\x68\xc0\x80\xbc\x06\xb3\x50\x41\xd5\x58\x2b\x2b\xa5\x5a\x82\x29\xa0\x4a\x9c\x5e\xb2\xa8\x88\x2b\x1b\xdc\xbb\xa1\xa6\xb6\xc4\x5b\x56\xe6\x2d\xa9\xad\x69\xe8\x3d\xd8\xe4\xef\xd9\xd5\xe5\x47\xf4\xc7\x0c\x39\xd5\x8f\x26\x23\xb3\xc0\x10\x55\x77\x2c\xed\x37\x20\xf3\x36\x00\x5d\x45\xb9\x2b\x52\x3a\x15\x61\xc4\x89\xb1\x0a\x45\x4e\xbe\x02\xbf\xf9\x8a\xba\xcc\xef\xf2\x92\xaf\xc8\x8b\x73\xe6\x4c\x79\xef\x3d\x09\xff\x7d\x71\x1d\xfe\x46\x96\xe0\x6f\xbf\xae\xc2\xdf\x3e\xd2\x7f\xb7\x11\x7f\x6b\xf3\xe2\x6f\xd4\x4b\xf7\xdc\x83\xb0\xab\x59\xfc\x8d\xfc\x0e\x7f\xfb\xf5\x33\xfc\x8d\x8e\xa6\xff\xdb\xc5\x8f\xf1\xb7\x9f\xf0\xdf\x98\xf7\xd7\x6b\xcb\xa9\xdd\xcc\xe7\x1d\x78\x7f\x48\x9d\xe8\xf4\xd7\x77\xed\xda\xa7\xb6\x37\x63\x12\x24\xc9\x2c\x03\xc0\xf5\xeb\xdc\x69\x70\xc3\x50\xba\x2c\x9a\x9f\x5f\xd6\x99\x33\x9b\x7a\x57\xfb\x7b\x9a\x3d\x39\x39\x4d\x9e\x46\x13\xaf\xf6\x2e\x57\x4b\xca\xca\x0a\x02\x8a\x37\x1e\xc9\xcb\xcb\xaa\xab\xa9\xa8\x1d\xd6\x60\x96\xf8\xde\x7d\x0b\xfc\x81\xac\xda\x86\x41\x92\x34\xa8\xa1\x36\x2b\xe0\x2f\xe8\xdb\x9b\xb7\x30\x02\x93\xd2\x16\xc9\x85\xc0\x9c\x86\x7f\xc4\xc4\x99\xe6\x3b\x9f\x16\x04\xc5\x1a\xc4\x1d\x93\x32\xbe\x12\xb7\xbb\xee\xa4\x4c\x4b\xe8\x2a\x30\xc6\x2a\x31\x05\xdb\x4e\xd0\x7e\xae\x8a\xe5\x21\xa1\x54\xa0\x81\x1e\xa1\x50\x4e\x3d\x17\xcd\xe7\xf2\x41\x3e\x4a\xf4\x82\x9e\x96\x9b\xe2\x30\xc2\x5a\x4d\x7e\x0d\x02\x58\x43\x18\x80\x6e\xae\xaf\x2f\x30\xa9\xd7\x60\xfc\x57\xdb\xf4\x5b\xfb\x8c\x2f\xbc\xba\xe9\x3e\xfa\xa0\xf1\xa2\xdb\xa8\xf2\x32\x73\x7f\xa1\xb6\x6a\xd6\xc5\xbe\xf0\x25\xdf\x0f\xbe\xbc\xc1\x3a\xaa\xf3\x88\xce\xfd\x67\xd4\x55\xcd\xa2\xde\x1e\x55\x3e\xb2\x73\xff\x59\xb5\x55\x33\xeb\xf1\x27\x1a\x77\xd2\x7f\x35\x5e\xb4\x05\xf0\x33\x2b\xf1\xdf\xda\xcf\xa3\xe1\x1b\xfb\xcd\xec\x02\x3f\xc3\xe1\xcf\xcc\x44\xcf\xec\xae\x3f\x1e\x3d\xe9\x8e\x51\x9d\x4b\xd1\x48\xd5\x33\xf5\x3a\x30\x6d\x32\x7d\x96\x7d\x14\xfa\x5d\x41\x62\x86\x5a\x27\x91\x24\x3c\xb3\xfd\x01\xb3\xc5\xc2\xda\x6c\xbc\xc9\x14\x70\x02\x3a\x2b\xdb\x2f\x38\xb3\x9d\x65\x4e\x8a\xa7\x9c\x0e\xd5\xe1\x59\x1f\x77\x00\xd5\x62\xb3\x99\x10\x06\x9d\xc8\x02\x8a\x49\x74\x2e\xc5\xa0\xaf\xa7\x7d\xe2\xeb\xfa\x7e\x86\x36\x6a\x45\xaa\xc4\x3b\xc3\x7c\x40\xdf\x70\xa5\x70\x0c\x47\x2d\x2a\x6b\x80\x1c\xa2\x62\xba\x57\x1f\x23\xf5\xca\xe1\x3d\xcf\x1f\x5c\x33\x43\x6c\xfb\xe5\x3d\x6d\x07\xbf\x9f\x19\x37\x7d\xda\x78\x66\x3f\x9f\x28\x25\xbe\x30\xb5\xed\x18\xd8\x41\xcd\x18\xfa\xd4\x85\xad\xcc\x83\x80\x6e\x18\x30\xa0\x01\xf5\x66\x27\x89\x63\xda\x19\xfa\x14\xf3\x03\x9c\x93\x1f\xa1\xd7\x0a\xf0\x00\x57\x9c\x5e\x1f\x67\x32\x51\x66\x33\xcb\x30\x3e\xa7\x84\x7a\xb5\x09\x4e\x80\xe6\xe3\x70\xc3\xe9\x48\x76\x4a\x12\x48\x51\x31\x99\xcd\xcc\xf0\xb8\x59\xcf\x8c\x11\x4f\xe3\x78\x8c\x0e\x64\xfb\x1b\x53\xd1\x13\xfa\x8d\x79\x54\xd7\x80\x88\x94\x07\xa7\x82\x0e\xca\x18\xa9\xa7\xf7\x3f\x71\xf2\xe0\xba\x05\x38\xc5\x1f\x3c\xa5\xed\xb4\xec\xb7\x1e\x3f\x6e\xdd\x6f\x49\xa4\xfb\x5f\x9c\xa2\x15\x80\x1a\x72\x4b\xee\xa6\x6c\x94\xf2\x7f\x33\x50\x5f\x79\x45\x3b\xa1\xc7\x64\xe8\xb4\x58\x3a\xd4\xef\x82\xc5\xe3\x31\xd9\x68\x19\xfe\x3e\x10\x14\xdc\xcd\x71\x3b\x3c\x17\x5a\xe2\x16\x4e\x80\x5f\x34\x4f\xd1\x9e\xf4\xa2\xbd\x0e\xc1\x74\x07\x8a\x87\xc5\x92\xf5\x7b\x7a\x24\x3d\xa6\x44\x94\x8e\x75\x7c\xbb\x76\x1d\x7f\xe5\x95\x8e\xb5\x7c\xd4\xa7\x9b\xcf\x9f\xdf\xfc\xe7\x54\x39\x1f\xa4\xb1\x11\xe5\x7a\xc2\x33\xc2\xa0\x91\xa3\x64\x99\x10\xdc\x16\xc1\x12\x08\x72\xfe\xa6\x38\x2b\x39\xa4\xa6\x38\xe5\xe0\xe0\x97\x00\x04\x94\xff\xa9\x00\xd0\x1e\x87\xb4\x63\xc4\x5f\xd6\x69\x4b\x45\xd3\x23\x55\xc9\xb4\x9d\xb3\xad\xf3\xe7\x03\x2b\xce\x03\xed\x71\x2b\x28\xfd\x17\xca\x04\xfd\x91\x91\x8f\x1d\x5b\xd1\xf6\x31\x4e\x07\xbd\x7b\xc5\x85\x19\x7a\x36\xa8\x5e\xeb\xb8\x08\xe3\x2f\xf8\x88\x71\x6a\xa9\xd7\x25\xc8\x32\x3c\x07\xe1\x51\x26\xc0\xc3\xc7\x1f\x60\x48\x93\x45\x86\xb2\xec\xf2\xca\x1e\x5a\xf6\x78\x64\x9a\x82\xf2\xef\x40\xe5\xa1\xe6\x04\xd8\x35\xf6\x3a\x16\x63\xb0\xc8\x8c\x52\x09\x5d\x83\x27\x82\x71\x4e\xb8\xcf\xf3\x31\xa9\x7a\x65\x24\xae\xce\x84\x5a\x00\x7a\x9b\xcd\x63\xe6\x5f\xbf\x60\xfe\xc3\xda\xe7\xc7\xc1\xb9\xef\x00\x75\x42\x7b\xe6\x3f\xda\xcd\x43\x67\xce\xb8\xd6\x47\x1d\xda\x3e\x67\x59\xcb\x6d\xfd\xda\x34\xa6\xef\x9f\x4e\x6a\x6d\xdf\x96\xdc\x3c\x71\x46\xad\xd1\xbb\x71\x20\xdd\x00\x2d\xb4\x12\xe8\x47\xd6\x14\x32\x45\x34\xdd\x89\x2c\xa6\xa8\x20\x51\x5c\x94\xeb\xb2\xd9\xec\xf6\x22\x82\x2a\x2b\x65\x48\xce\xe7\x0b\x35\xc6\x5d\x3e\xb1\xb0\x53\x7e\x71\xb1\x24\xd0\x34\x67\x0f\x70\xf9\x8d\x71\x9e\x4b\x61\x3d\x2d\x2a\xf3\xf4\xa8\x45\x40\xc6\x46\xd6\x54\x6d\xe6\xbd\x41\xc6\x44\x44\x7d\x22\xc9\xfe\x8e\xa8\xd7\x9c\xa2\xa7\x81\x62\xa0\x42\xa3\x1d\x89\x3e\xb5\xbe\x13\xae\x99\x34\x61\xf4\x82\x5f\x47\x31\x74\x2b\xfb\x04\xa0\x19\xba\x7c\xd7\xf2\x57\x4f\xff\xfe\xd6\x55\xd7\x2f\xe8\x71\xc7\xf6\xab\xbb\xdc\x7c\x5d\x73\x84\xcc\xd1\xbe\xbe\x6b\xfa\x98\xeb\xaa\x9f\x37\xed\xd5\xe2\x0c\xfb\x70\x35\xdd\x79\xb2\x3c\x69\xbc\xf6\x93\xf6\xe1\x27\x27\xc7\x1c\xdf\xfe\xa7\xb3\x45\x4b\xc7\x4e\xbd\x06\xe3\xe3\x00\xfa\x66\xa8\x93\x38\x22\x4f\x75\x30\x2c\x20\x59\x12\xd5\x2a\x34\xc7\xe1\x91\x41\x31\xf8\x0e\xb9\x2c\xb3\x5a\x41\x4f\x0e\xa2\x4e\xb6\xb6\x15\x1f\x67\xfa\x82\x49\x1a\x71\xe1\x6a\xa6\x0f\xb2\x3b\x7f\x82\x6b\xcf\x42\xd9\xe4\x88\xa8\xea\x80\xcf\x65\x00\xaa\x45\x20\x48\xae\x31\x4e\x0a\xc9\xca\x93\xf4\x52\x77\xa3\x54\x1b\x3c\xd2\x4a\xde\xb0\xaf\x6d\x2f\x5d\x07\x36\xb5\x7d\x8c\x6d\xd8\x1a\xa3\x37\xb7\x0d\xe1\xd9\xb2\x66\x33\x30\x59\x28\x0b\x65\x17\x78\x1b\x61\x6b\x89\xb3\x50\xd4\x2c\x0e\xa3\x59\x77\x8f\x74\x78\xad\x04\x5e\x79\x45\x85\x8e\x67\xab\xe7\x88\xe0\x8a\x87\x48\xcd\xa3\xa8\x81\x37\x2a\x21\x3b\xfe\x28\xf9\x25\x39\x6e\xa7\xa6\x6e\x6e\x3b\x40\x8e\x42\xe3\x6d\x30\x6a\xe4\x6c\x44\x37\x35\x8b\xe2\x38\x2b\x63\x42\x3d\xdf\x05\x16\x47\x29\x28\x8b\xc5\x64\xb3\x91\x8d\x71\x9b\x60\x4a\xa2\xfa\x7a\x2e\x37\x22\xaa\xa1\x43\x1b\x09\x27\x91\xe1\x5a\xba\xd7\x5e\x6b\xbd\xf5\x56\xba\x6e\xbd\xf6\xfe\xca\x36\x8d\x24\x57\x82\x56\x34\xde\x13\x28\x46\x85\xb1\x3f\x86\xaa\x85\x84\xcf\xe7\xb7\x59\x65\x96\x0d\x5a\xfd\x74\x28\x4c\xb9\x9a\xe3\x04\x45\xf9\x03\x81\xec\xe6\x78\x00\xe5\x61\xf2\xbc\xd8\x1c\xe7\xfd\x70\x39\x5e\x32\x86\xbe\x2c\xdc\x65\x3b\x67\xdc\xa8\xa0\x85\x3f\xe0\xbb\x49\x49\x6f\x63\x3e\xb3\xee\x9e\x41\x3f\x7c\xf6\x3f\xdf\x3e\xf4\x6e\xdd\x91\xe2\x9b\x26\x6f\xdd\xb4\x71\x5b\x8f\xe5\x03\x71\x6f\x73\x6a\x4e\x5e\xa1\x76\x4a\x3b\xac\xdd\xa7\xad\xbe\x7d\x5b\x56\xf3\x00\x10\x04\x9d\x00\xf3\x4d\x4e\x49\x5b\xa1\x8e\x25\x8f\xeb\x51\x7a\x40\x3e\x85\x10\x2e\x84\x5f\x51\x5c\x26\xce\x4e\x10\x1e\xce\x45\x87\x73\xfc\xc1\xa0\xa3\x31\x1e\x0c\xba\xdc\x6e\x5f\x63\xdc\x2d\x98\x4c\xb4\x4b\xa1\x2d\xa8\x41\x67\x72\x91\xda\x25\x13\x67\xb4\xb3\x74\xea\xf7\x25\x35\x46\x3f\x53\xec\xc1\xea\x44\x4b\x18\xd8\x9d\xee\x31\xf7\xed\xb5\x87\xde\x2c\x3d\x9c\xb5\x60\xf2\xa6\x7b\xae\xda\x79\xcd\xdc\xc9\xad\xe4\x44\x6d\xc4\xdc\x9b\x36\xfd\x7d\xd1\xb8\xdd\x5f\x2f\xbc\x6b\x83\x6d\xe4\xe0\xdf\x1f\xbd\x71\xff\xa8\x90\x76\x2d\x5d\xb7\x56\x9b\x1b\x99\xf7\x57\x03\x6b\x48\x9b\x8a\x73\x1f\xf2\x89\x4d\x6a\x53\x30\x27\x27\x3b\x10\xc9\xf7\x78\xbd\xa1\x6c\x67\x7e\xbe\xc4\xf2\x84\xd5\x0a\x8f\x2c\x22\x9b\x2a\x2c\x88\xb0\x2c\x1f\xa0\xa0\xe3\xe9\x94\x08\x49\x94\x42\x12\x25\x30\x12\x68\x89\x0b\xb8\xc0\x96\x42\x05\xb6\xd6\x50\x58\x0d\x07\x9b\xe3\x61\x87\xc7\x61\xa5\x08\x93\x8e\x78\x17\xd3\x23\x54\xe7\x8d\xdc\x7a\x42\xbf\x34\x32\x6a\xe6\x12\xa7\x99\x9e\x26\x11\x33\x6a\x6f\x13\xfb\x40\x2a\xa5\xf2\x2f\x0f\xbe\x22\xc7\x70\xb2\x01\xae\x1c\x74\x99\xb3\x43\x5e\xfa\xb2\x20\x2c\xff\xee\xdf\xca\xfe\xcc\x0d\x91\xc9\x66\x60\x32\x71\xe4\x6f\x20\xb1\xbc\xd9\xf6\x2a\xd8\x46\x2e\xa0\x64\xba\xed\x01\x54\x2f\x89\xf8\x02\xd7\x33\x8f\x58\xa9\x46\xfd\xa1\x50\xd0\x17\xce\x43\x01\xa5\xa0\x23\x2f\x4f\xa0\x39\x02\x55\x4b\xb2\x44\x90\xca\x8f\xfa\xb8\x30\x4d\xe7\x1a\xd5\x92\xfe\xb8\x83\x0b\x21\xd7\x91\x12\x04\x73\x56\x28\x04\x8f\x9e\x90\xe2\x12\xa1\x92\x67\x15\x22\x75\x92\x9f\x4e\x74\x3c\x49\x36\x70\xfe\xef\x9c\xb8\x62\xfd\x64\x1a\x27\xbc\xee\x6e\xf6\xcb\xd7\x50\x72\x83\xf7\x79\xda\xec\x5d\x3d\xe0\x63\xd2\x63\xb9\x52\x15\xa5\x16\x41\x15\x26\x24\x63\xf6\x92\xa8\x92\x12\x63\xd2\x40\xb9\x46\x98\x34\x55\xc4\x0d\x6a\x57\x96\xf1\xf9\x8b\xc8\x4e\x84\x33\x6c\xc9\xcf\x0f\xe7\x12\xa4\xd0\xd9\xcf\xf0\xd5\x35\xb9\xa2\x20\x0a\x2d\x71\x51\x24\xb3\x7c\xbe\xac\x2c\x68\x12\x64\xd1\x65\x95\x2d\xf1\x32\xb2\x88\x24\xe1\xa1\xc6\xb2\x24\xc6\x49\x4b\x43\x86\x4f\xf5\xb6\xeb\xd8\xc1\x55\x9f\x32\x53\x89\x4d\xd9\xff\x0e\x43\x83\xc0\xad\x9d\x89\x1a\x3d\x72\x8a\xf2\xd2\xaf\x4d\x99\x88\x34\x4b\x9f\xea\x9c\x86\x48\xf3\xd1\xf1\xec\x65\x73\x6f\x1a\x11\x1f\xb5\x7c\x7f\x63\x4f\x66\xdf\xef\x30\x38\xcd\x82\x9b\x30\x38\xcd\x2d\x4b\xd3\xc0\x69\x1e\x7c\xcf\xbd\x68\x78\xf3\xac\x9c\xd5\x11\x54\x53\x0a\xf9\x80\x6a\x4a\x6b\xd0\x6d\x2a\x4d\xb9\xdc\x05\x35\x45\x55\x62\x90\xcf\xcb\x0b\x86\xab\x6a\xac\x65\x6e\x8a\xef\x52\x5b\x52\xd1\x14\x2f\x09\x84\x13\xe5\xa5\x3e\xc2\xe5\xf2\xf9\x64\x14\xa5\x2d\x20\x32\xca\x49\x8d\x2c\xb8\x0c\x16\x64\x62\xb3\x27\xb9\xd0\xa1\x9c\x34\x7a\xd9\x7a\xd2\x74\x1e\xc0\x37\xe5\x93\x63\x5e\xf9\x4b\x89\x5e\x5f\xfa\x6e\xeb\xd3\xa7\xe6\xdd\xb6\x68\xa5\x6d\xaf\xe7\xcf\x27\x4f\x7f\x3e\x68\x79\xbf\x65\x8f\xed\xda\x12\x9e\x7f\xcb\x94\x91\xa3\x87\xaa\xf5\x2e\xe7\xad\x2b\x51\xad\x69\xcb\xd4\x3b\xc7\x0c\x1f\x38\xba\xdf\x20\xe7\x1d\xb7\xee\x58\xd1\x73\x7a\x5f\x16\x15\x9b\x2e\xde\xe3\xbb\x69\xc4\xf5\xb3\xc3\x2b\x73\xba\xf5\x18\x3c\x44\x97\x89\x47\xe0\xde\xb8\x1f\xe3\x93\x8d\x57\xcb\x48\xa8\xeb\xcc\x12\xdc\x0c\x16\x8b\x28\x22\x24\x7a\xc9\x45\xb9\x3d\x2e\x87\x64\x76\x32\xa4\x13\x21\xe0\x10\x76\x11\xe5\x4b\x89\x0e\x86\xc1\x40\x38\x65\xc9\x2d\x60\x18\x5f\x3d\x3a\xcc\xdb\xf0\xe8\x63\x52\x45\x02\x0f\x07\x0b\x79\x02\x13\xe7\xd8\xda\x04\x24\xce\xfa\x1b\x5a\x8b\xb4\xab\xbc\x33\xf3\x31\x28\xce\x5b\x09\x4c\x9c\x17\xf1\x66\x5e\x6d\xf5\x21\x5c\x1c\xe2\x7d\x48\xef\x55\x70\x2f\xbb\x88\xeb\xd4\x4a\x9d\x5e\x96\xe3\x32\xe9\x55\x20\xbd\x2c\xe9\x6c\x8c\x0b\x24\x40\x98\xd7\x98\x68\x94\x7b\x09\x77\xb9\x90\x41\x74\xa2\xf7\xf0\x6f\xd3\x9d\x28\x57\x4d\xa3\x3b\xad\x64\xb5\xd3\xd0\x7d\x39\x1d\x8b\x56\xb5\xce\x68\xfb\x25\x0a\x57\x53\x58\x43\x5e\x62\x82\x5a\x4e\x7a\x3c\x5e\x81\x93\x65\xda\x09\xed\x42\x49\x14\x9d\x5e\xca\xe7\x77\x08\x8a\xe0\x36\x93\x70\xc3\xd1\x1c\xc9\x38\x49\x06\xb2\x9c\x92\xbc\x0e\xb3\x81\x38\x94\xe8\x7c\x91\xb0\x17\xdb\x63\x5d\xa5\x33\x1a\xbe\x4c\x43\x1f\xc2\xc5\x76\x88\xd7\xd5\x55\x37\x95\xd5\xa4\x21\x10\xdd\x7e\x53\x5d\x67\xcc\x6c\x07\x78\x5c\xdb\x5e\xd4\x98\x82\x21\xea\xa6\x3d\x0b\x6e\x15\x21\xc7\xd3\x6b\x80\x3d\xc4\x35\x6a\x8c\x74\xbb\x3d\x76\xce\xe1\xa0\x65\x48\xbb\x28\x08\xb2\x87\xf2\xfa\x24\xbb\xd3\xee\x32\x93\xae\x46\x4c\x7b\x19\x09\x64\x44\xbe\x4c\x89\x1e\xc5\x6c\x24\xd6\x1b\x79\x95\xff\x27\xfa\xf5\x1a\x61\x83\xfc\xf7\x5b\x6b\x23\xd3\x7a\x0d\x48\xd5\x09\x4f\xeb\x54\x8e\x59\x6e\x02\x83\xb4\xbf\x77\x9a\x91\x2a\x16\xd6\xf6\x81\x5e\x26\xa3\x5e\x98\x36\xf8\xee\x23\xe2\x6a\xa9\x99\xf5\x42\x4e\x3b\x14\x9b\xdd\x29\xcb\x76\xc5\x47\xfb\x03\x8a\xc3\x63\x33\x43\x27\x87\x07\x24\x3c\xff\x58\xd2\x0c\xbf\x68\xa7\xcf\x61\xa3\x29\x03\xe2\x35\xdd\xe9\x21\xda\x21\xd5\x1b\x8e\x45\xd2\xef\x49\xc9\x78\x42\xbe\xf7\xef\x3f\xfe\xf4\xd3\x29\x19\x47\xb0\x4f\x48\xc2\xa9\xff\xd9\x7c\xec\xd8\x66\xed\xd2\x5b\x69\xc8\x4f\x58\xc2\x8d\xf8\x30\xb4\x9b\x5e\xd3\xbd\x0b\xa7\x5d\x70\x28\x82\x22\xeb\xb4\xcb\xbe\x80\x1f\x92\x6c\x37\x7b\x1a\xe3\x66\xb3\xdd\xe9\x53\x10\xe1\xd0\x27\x22\x49\xda\x2e\xd0\x84\xd1\x91\x3a\x3d\x05\x3d\xb3\x0e\x3b\x71\x0c\x55\x64\x92\xdd\xbe\x22\xfb\xcd\x37\x5b\x3f\xfe\xb8\x63\x55\xf6\xd1\x15\x9b\x36\xad\x68\x3b\xd0\xa1\x32\x5b\xc7\x79\x7b\x0d\xe3\x30\x0d\x55\xf3\xad\x0c\x6b\xb6\xb1\x36\x54\x2c\xee\x74\x58\x1c\x2e\xc5\x66\x16\x19\x52\xc4\x0a\xc4\xea\x70\x30\x14\xe1\x44\xd6\x9f\x71\x71\x7d\x39\x32\x53\x54\x42\xeb\x39\x03\x48\x8b\xc3\x9b\xf0\x77\x0f\x2e\x4f\xb2\xf4\x8f\xda\x60\xef\x98\xc0\xf1\x9f\x90\x20\x0b\xa7\xd2\x19\xea\xa6\xda\x76\xd3\x7a\x3e\x7f\x57\x84\x99\x83\xf3\xdc\x1b\xd4\x02\xd2\xe1\x50\x64\x8b\x9d\x33\xd9\xac\x56\x93\x5d\xa6\x5d\x6e\xbb\x45\xe2\x48\xe8\x55\x42\x02\x6d\xb2\xc2\x09\xc9\xae\x66\x1d\x08\xcc\x58\x7c\x9c\xa3\x5d\xd1\x9d\xcc\x60\x9e\x14\xee\x0a\x3e\xc8\x2a\xaf\xec\x75\xea\xf9\x77\xc7\x47\xc0\xc4\x57\xb5\xaf\xe4\x9e\xbe\x56\xed\x3d\x24\xac\x62\x6c\x1c\xa8\xd7\x9e\xbb\x23\xd8\xf6\x14\xf8\xa7\xc9\xaa\x45\xa8\x27\x75\xfc\x2c\xa8\xd7\x0e\x61\x6c\xa3\x26\xb5\x84\xa3\x28\x1a\x35\xc5\x81\x1a\xcd\x42\x53\x22\x24\x0d\xb2\x8b\x13\xb9\xa7\xa0\x2b\x8c\x3a\xa8\xf3\x08\x8d\x10\x9a\xa4\x50\x13\x13\x8e\xc4\xd5\x42\x7a\xf9\x65\xba\x26\x4b\xa0\x6d\xc5\x92\x85\xbd\x18\x75\x0b\x41\x46\xad\x86\x2e\x49\xdb\x46\x04\xa7\x43\x56\x5f\x18\x8b\xf4\xac\x5e\xdb\x0d\x69\xd9\x88\x6b\x61\x1b\xd4\x42\x00\xdd\x42\x12\x5a\x48\x26\x8e\x63\xec\x90\x16\x60\x6d\x8a\x1b\xc5\x33\x66\x68\x18\xd9\xf1\x15\x47\x53\xda\x15\xc7\x95\xe9\x48\x95\x16\xa7\xd5\x9b\x2f\xd8\xb7\x26\x59\x71\xae\x57\xc5\x1a\x55\xe7\x80\x58\x69\xe4\xf2\xda\x88\x1e\x6a\xc8\xe0\x89\xd9\x46\xdb\xec\x02\x62\x08\xc7\xd1\x06\x42\x3e\x94\x27\x3a\x99\x2f\x91\x9e\x48\x7f\x19\x0e\x84\xa1\xb4\x53\x7e\xad\xe0\xf8\x71\xf0\x2e\x38\xfc\x63\x6a\xfe\x3b\x2f\x8c\x4e\xf4\x3e\x39\x8f\x7d\xa4\xfe\x6a\x2e\xb0\x58\xac\x24\xb4\xf0\x39\x2b\x67\x17\x6c\x02\x30\x27\xa7\x4e\x99\xac\x0a\xc5\x42\xa7\x49\x48\x61\x89\x19\x15\x8f\xed\xc7\x06\x52\xc2\x39\xc3\x73\xee\x05\x0e\x81\xf7\xb5\xf7\x5b\xb5\x61\xc6\xa4\xd7\x5e\x6c\x4a\xd4\xd9\xc3\xf1\x47\x42\xdb\xe4\x3e\x38\x67\x84\xbf\x52\x14\x26\xa8\x60\x30\x4b\x31\x99\xec\x59\x04\x9d\x13\x61\xa0\x9e\x42\x85\xe9\x00\x84\xa0\xef\x0a\x99\x4f\xe8\xb7\x0a\x59\xf8\xb6\xec\xbf\x7a\x4d\x68\xfa\xd5\x97\xf5\x9b\xf4\x5d\x15\x96\x46\x92\xd7\x5e\x35\x76\xc7\x8e\x87\x0e\xce\xb9\x3f\xba\xc7\xd5\xb7\x7e\x7c\xd3\x90\x61\xd9\x55\xc5\xf9\xfb\xb5\x4f\x99\xbe\x5a\xc9\x50\xed\x65\xed\x29\x6d\xbd\xb6\x65\xc3\x86\xac\xc6\xd1\x40\x04\xb5\x80\xfd\x5a\xf2\xe5\xb6\x15\xd2\x8f\x5e\x30\xea\x64\x31\xfd\x74\x3d\xf4\xf9\xc6\xa8\x4a\x36\x41\xf9\xa1\x8a\x85\xf4\x07\x08\xe8\xf3\x09\xa8\x46\x03\x63\xb5\xdb\xe3\x96\x00\x03\x55\x98\x3e\x9b\x2c\x0c\x3a\x0f\x84\x00\x4e\xbb\x4c\xd1\x7f\xd9\x20\x52\xda\x4c\xf4\x3e\x28\x29\x67\x2a\x81\x89\x8a\xe6\xd1\x70\xed\x7d\xdb\x1f\x7c\xdc\x98\xc7\xb8\xe1\x83\x1b\xaf\x1e\x0a\x67\x41\xd7\xb7\xfd\xa1\xee\xb3\x1f\xb5\x9f\xb4\xff\xe0\x39\xb4\xbe\xfd\xe4\xfd\xdd\xb5\xa5\xd4\xee\x8b\x13\x09\x92\x18\x71\xe9\x1b\xfa\x7b\x66\x0c\x51\x48\x54\x12\x63\xd5\x72\x27\x5f\x12\x10\xec\x79\xde\xf2\x8a\x9c\x9c\x72\x7b\x80\x67\xaa\xaa\xb3\x8b\x9a\xe3\xd9\xd9\x9c\xd5\x2a\x21\x10\xa8\x7c\x37\x07\x4f\x6b\x6f\x5e\x79\x39\x3c\xec\x38\x23\xb2\x9c\x00\xef\xef\x88\x91\x9b\x72\x02\x71\xe7\x35\x36\xa2\xa7\x54\xe8\xa5\x3e\x0a\x2e\xf5\xc1\x48\x01\x70\x55\x50\xe5\x0c\xba\x0e\x01\x38\x42\xe6\xae\x96\x2a\xa3\xf4\xf7\x8d\x93\xba\x8d\x2b\x9f\xbe\xaf\xed\xbb\x8b\x5f\x2f\x1c\x31\xac\x7a\xe0\x1d\xf7\x3e\x7e\x22\x6f\xd8\xe8\xeb\x1e\x58\x7f\xdb\xce\x09\xa3\xa3\xe5\x3d\x7a\x6b\xbf\xef\xd6\xb7\x5f\xf7\x39\x3d\x0b\xba\xfa\x82\x35\xe4\x09\x30\x08\x4c\xaa\x5e\x99\xa3\x7d\xf2\x1f\xed\x63\xed\xdf\xd2\x08\x90\x75\xe8\x1d\x60\xd6\xbe\x7d\xff\x31\xed\x1f\x57\x89\x9d\xa8\xab\x5b\x37\xad\xff\xa5\xef\xa3\xc0\xb3\xf5\x59\x7c\xef\x86\x70\x17\x76\xd0\x43\x88\x28\x51\x41\x34\xab\x0a\x9c\xbf\x5f\xb0\x47\x3c\xe5\xf9\xe1\x70\xb9\xdd\xcf\x33\xb1\xca\x2c\xdc\x7d\xce\x17\xcf\xca\x62\x21\x0f\x50\xff\xb9\x5c\x37\xeb\x6e\x8a\x7b\x22\xe5\xe5\x34\x4d\xb2\xae\xff\x13\x0f\xd0\x85\x10\x91\xe2\x01\x0e\x06\xd6\xe8\x20\x4d\x68\x6d\x39\x77\x45\x0d\x95\xc0\x40\x72\x77\x07\xf4\x8e\x7e\xd7\x8f\x19\x3e\x6a\xfe\x97\xda\x85\x7f\xbc\x36\x5c\x55\x8b\x8a\x67\xae\xda\xbf\xa3\x5f\x9f\xfe\x9b\x6e\x5e\xb0\x61\x4d\x79\x9f\xf2\x17\x6a\x4a\xcb\x2a\xab\xcb\x4a\xab\x22\x35\x79\x79\x20\x0c\x0f\x46\x3b\x28\xf3\x2f\x75\xfe\xeb\xe5\x73\xef\x53\x43\x3f\x9c\x77\xf8\x93\xbf\x1e\xd6\x7e\xde\x42\xe5\x83\x5b\x6e\xbe\x63\xcd\xdc\x69\x2f\x56\x56\x3e\xab\xc7\x5a\x47\x63\x8c\xe9\x28\xaa\x78\x24\xfc\xbc\xc7\xa2\x84\x43\xd0\xaa\x0c\x29\x1e\xb7\xe8\xe7\xf2\x0b\xd8\x30\x1b\xe6\x83\xc1\xdc\xe6\x78\x90\xb6\xcb\x2d\x71\x3b\xef\xe1\x79\xaa\x25\xce\xcb\x46\x91\x99\xf8\x52\x66\x63\xb7\x0e\x9a\x4f\x4f\x10\x70\x93\x4c\x9a\x69\x8f\x3a\xd3\x47\x89\xf4\xd0\x2c\xa8\x7b\xec\x29\x84\x1a\xbd\x5c\xfb\x39\xe1\xd7\x28\xe0\x67\xed\x42\x5a\xa0\x96\x7c\x14\xc5\x64\x11\x7a\xf4\xf1\xe2\x95\x43\xb0\x47\xb3\xb4\xb1\xa7\x0d\x5c\x0f\xfa\x24\xe3\xb6\x84\xd1\x4f\xb0\x0b\xf4\x71\x0a\x88\x85\x6a\xb1\x8d\x70\x47\xbd\xb9\x1c\x2b\x3b\x9d\x6c\x6e\x34\x8b\x60\x0b\x8b\x02\xe1\xa6\x78\x20\x10\x75\x13\xb2\x28\xb7\xc8\xa8\xbb\xf0\x09\x99\xe5\x29\x19\x55\x19\x86\xfc\x59\x03\x50\xa7\x1b\xb1\x29\xee\x36\x6a\x60\x97\x72\x1b\x38\x8a\x53\xe1\x3f\x24\x8a\x61\x8b\xd3\x50\x48\x8b\xf1\x35\x40\x07\x9f\xa7\x5d\x1d\xac\x11\xc8\x77\x43\x6d\xd3\xce\xc1\x89\x92\xb7\x01\xf2\xa7\xdf\x7d\x93\x7d\x42\x5c\x76\xf3\xae\xcd\x9b\xef\x9f\xb1\x5e\x7a\xc1\x71\x62\x43\xd2\xaf\x71\xff\xfd\x5f\x7a\x55\xec\x63\xdb\xec\x63\xa7\xbd\xf4\xc1\x5f\xcf\x4f\x9f\x69\x5d\xfe\xb4\x6b\x51\x5f\xc3\x9d\x69\xec\xcf\x83\x2c\x3d\x2f\x7a\x2a\xc2\x87\x24\x2c\x44\x8d\xea\xb7\x00\x60\x62\x69\x8a\xa5\xac\x36\xc2\xc4\x9b\xd0\x59\x41\xb3\x2c\x80\x4e\x6c\xf2\xd4\xec\xd8\x1f\x0a\x24\x4e\xa8\xaa\xb0\x42\xbe\x7c\xd7\xa1\xed\x5a\x5f\xba\x12\x2a\xb8\x9f\xd1\xf9\x88\x90\x94\x75\x4c\x12\x38\xce\x20\x5c\xfb\xd2\x45\xf5\x93\x34\x6d\xe1\x39\x96\x67\xad\x36\x8e\xe7\xe9\xa6\x38\xaf\x50\x50\xd5\xa5\x83\x93\xe0\xd1\x32\x07\xc2\x20\x25\xc6\x58\x18\xa8\x64\xee\xbe\x55\x3a\x54\xc9\x3b\xe8\x18\xa4\x0e\x26\x70\x23\x1f\xc1\xb8\x91\x5d\xf1\xb8\x7d\xe1\xba\xae\x36\xb0\x82\x3c\x0c\xdc\x73\x56\x9b\xcd\x04\x50\x4f\x0f\x81\x22\x4c\x26\xd2\x4a\x0b\x64\x40\x6f\x22\x92\xec\x42\x8b\xdb\x3c\x24\x0e\x42\x54\xab\x0a\x5c\x6e\xd4\xa7\x27\x46\x3e\xdf\xaa\x75\x3b\x0b\xac\x52\x65\xc4\x2a\x83\xc0\x19\x54\xfd\x48\xd7\xb5\x0d\x29\x7e\xe6\xc6\x68\x0d\x79\x16\x8d\x67\x8c\x4f\xd8\x89\x3e\x6a\x18\xe1\x4a\xd9\xec\x76\x74\x93\x44\xd3\x0c\x23\x88\x14\x67\xe2\xa0\x26\x84\x03\x33\x36\xb3\x71\x95\x8a\xec\xcf\xe4\xa5\xa1\x91\x3e\x98\x0a\x48\x1a\x27\x61\x55\x18\x23\x6b\x52\xb9\xa0\xab\x36\xe9\x79\x6d\x32\xa8\xd3\x16\xa1\xee\xb7\x73\xcf\x93\x1f\x6f\x43\x4d\x6f\xb7\x91\xd7\xb5\xdd\x4f\x5e\x9b\x31\x67\x19\xf5\x74\x81\x34\x38\xa0\xf1\xce\x10\x34\xcd\x33\x8c\x53\xb1\x9b\x1c\x66\x01\xd1\x01\xb9\x6d\x52\x98\xf4\x8c\x5b\x47\xad\x94\xea\x17\x1f\x33\x8a\xb6\x0a\x41\x8a\x82\x14\x1f\x40\x77\xed\x64\xab\x76\x12\x7e\x4b\xe7\xc7\x1a\xed\x6f\x20\x7b\x4d\x06\x47\x30\x4f\xe0\xda\xbf\x8c\x6d\xb5\xe1\x6a\xb1\x60\xb7\x5b\x20\xfb\x29\x33\x61\xa3\x21\x57\x78\x9e\xe3\x58\x2b\x2b\x4a\x04\x65\x33\xd3\x3c\xb0\x53\x56\x07\x92\x09\x28\x7b\xe9\x96\x9a\x3b\x13\x21\xcd\x8d\xc9\xab\xd0\x81\x06\x10\x63\x90\x54\xf0\x00\xfe\x1f\x23\x27\x83\x86\xf3\x5a\x03\xb8\xf1\x8e\xd6\x2a\x6d\x8d\xb6\xf6\x3c\xf8\x8b\xd6\x70\x9e\xea\x43\x82\xb6\x45\x6d\x1f\x61\xdf\xb8\x5b\xdb\x29\xf2\x45\x72\x25\xa6\x6d\x02\xa4\x6d\x16\xb6\xdd\xa0\xfd\x00\xe5\x83\x33\x99\x78\x82\xa5\x68\x68\xc2\x09\x82\xcd\x66\x25\xad\xa2\x04\xf7\x39\xe4\x9e\x4d\x10\x90\x3d\xa3\x70\xb4\x5e\xf9\x96\xb8\xcd\xba\x2c\x69\x06\x04\x82\x4e\x9c\x41\x1f\x79\xad\xf6\xfb\x93\x60\xb7\x76\xd3\x2b\xa0\x13\x28\x3a\xa3\xdd\x04\x7a\x4e\xda\x97\x0f\x9e\xd7\xfa\x90\x9d\x48\xbb\x36\x16\x3c\xd8\xf6\x93\x76\x15\xc6\x39\x41\x77\x93\x3a\xde\xa9\x40\xf4\x54\xc3\xbc\xc5\xc2\xd2\x56\xe8\x9d\x03\x01\x99\xb7\x66\x96\x63\x9b\xe3\x36\x8e\x12\x2c\x34\x34\x69\x49\x1a\xf7\x6f\xbb\x4c\x97\xfb\x44\xda\x34\x3e\xe4\x75\xe8\xf3\x04\x04\xea\x25\x4d\x23\x4f\x69\x1a\xb8\x43\xc7\x41\x45\xfb\xf4\xc2\xcf\x18\x09\x15\x10\x26\xc8\x93\x57\x0d\x6c\x97\x1c\xb8\x57\x05\x1b\x63\x82\x62\x64\xb2\xc1\xb1\x4d\xb4\x0d\xee\x57\x8b\x4d\x61\x05\x68\xcb\x09\xe9\x5b\x56\xa7\xa1\xfd\xe0\x72\x62\x54\x1d\x22\x27\x6c\x22\x8f\x6a\x97\xc0\x4b\x08\x26\xe7\x1f\xda\x25\xba\xee\xae\x8b\x7f\x4a\xc0\xbb\x50\x4f\xe8\xf2\xd2\x8c\xb0\x65\xb0\x6f\xd4\x5d\x0d\x99\x18\xab\xd3\x29\x38\x24\x49\x60\x28\xc5\x65\xa6\x9a\xa1\x1f\xc7\x3a\x9c\xa8\xe6\x12\xb5\x47\xa7\x88\x1e\xb1\xf4\x3b\x95\xcc\x7b\x6f\xe8\x5f\x84\x70\x57\x45\x1d\x44\x47\xbf\x2d\x44\xd8\xac\xda\x64\x8c\xcd\x0a\xb5\x15\x42\x67\x05\x33\x13\xe8\xac\x86\x55\x0f\x88\x1d\x90\x86\x0d\xf8\xde\x04\xd2\xc0\xb3\x02\x41\xa0\x96\xfd\x0e\x96\x72\x7b\x10\x50\xa1\xd5\x4a\x88\x9c\xa0\xc0\xdf\x1a\xa5\xd3\x7a\xb4\xf2\x32\x34\x84\x0d\xe0\x9e\x58\xaa\xd7\x20\xf6\x29\x06\x22\x04\x9f\xd6\xeb\x26\xf6\x3f\xd8\xab\x75\xd3\x3e\x03\xbf\x07\xe1\xf9\x84\x65\x92\x30\xe0\x6e\xd2\x30\x69\xdd\x28\xb2\x67\x31\x49\x14\x65\xa7\xe1\x51\xe3\x72\xd1\x26\xca\xe3\x25\x19\x3b\xd3\x1c\x97\xec\xd0\x97\x15\xec\x34\xc5\xbb\x1d\x4e\x5e\xc7\xa8\x4d\xab\x39\x95\x3a\x74\x3e\x01\x2c\x87\x5a\x8a\xe8\xac\xa9\x07\xf8\xf6\x40\xc2\xb0\xb5\xab\xa7\x2c\x94\x10\x6f\xa8\x85\xd7\xae\x45\xc8\xb5\x21\xe1\xa7\x2f\x0d\xee\x80\x7f\x69\x2e\x6b\x50\x07\xb0\x4d\xe1\x19\x79\x89\x21\x6a\x3e\xf0\x70\x92\x44\x3b\x78\xb8\x5f\xac\x0e\x0f\xe5\xf3\xcb\xa2\x42\x43\x8f\x90\xa3\x1d\x50\xed\xd1\x0e\xb8\xb5\xbd\x82\x0d\x6f\x9a\x74\xc2\x2e\x47\x19\xe2\x52\x92\x1e\x09\xd3\x99\x00\x3e\x9a\x34\xf1\xc6\x99\xf1\xd6\xd6\x49\xd7\xdc\x18\x29\x4f\x80\x1f\x81\x72\xed\x5d\xc9\xaf\x23\x20\x15\x7a\x3e\x38\xcd\xe8\x28\x48\x3a\xbe\xf2\x5c\x8c\xe5\x5b\xa6\xba\x11\x92\xaf\x89\x13\x38\x87\x4c\x59\x70\x18\x05\x6a\x62\x93\xe0\x30\xc0\x7c\x6b\xdb\x41\xde\x18\xdd\x01\x22\xb8\x5b\x13\x06\x5b\x69\x49\x43\xf3\xa5\xa6\x20\x34\xdf\xb6\x73\x64\xe8\xf3\xce\x6d\x45\x4c\x5f\xa3\x76\xdf\x8b\x31\x21\x06\x23\xbb\xf0\xd2\x97\xd0\x2e\xfc\x1d\xb4\x8f\x82\xf0\x34\x98\xa0\x96\x87\xdd\x6e\xd6\xce\xf3\x22\x1b\x24\x72\x5c\x2e\xa8\x5c\xf2\xa2\x6e\x56\x84\x3b\x38\x2c\x5a\x2c\x62\x10\x7e\x51\xb2\x9c\xd5\x1c\x97\x69\xca\x77\x99\xfa\x02\x29\x76\x85\x75\xc4\x5b\x5b\x2f\x15\x46\xf9\x4f\x28\x43\xc2\xe9\xf6\x21\xa8\xd4\x04\x7e\x06\x40\x05\xb6\xa5\x80\x5e\xda\x74\x6e\xc3\xbf\x7f\xb4\xdd\xbc\x54\xba\xdf\x35\xc1\xfe\xeb\xdf\xc1\x97\x17\x7f\x34\xdf\xbd\xad\x65\x65\x85\xf6\xc1\xfa\x35\x16\xb2\xbf\xe5\xae\x77\x97\xcc\x02\x95\xa0\xf3\x8a\xa5\x75\xf5\xf5\x15\xd7\x58\x41\x05\xa8\x6f\xeb\xdf\xf8\xf9\x27\x23\x47\x51\xeb\x3e\xfe\xe9\xb3\xef\x90\xbd\x0b\xe0\xbc\xf6\x63\xcc\x10\x3c\x2f\xa7\x20\x58\xe1\x71\xe7\xb6\xb2\x5c\x56\x30\xc8\x59\xe1\xbc\x08\x9b\xdb\xd6\x18\xcf\x75\x4b\x12\x34\x73\x59\x37\xef\xf3\x85\xd1\x0d\x30\x0f\x77\x0c\xdf\xb1\x95\xfd\x6f\xcc\x0b\x18\xb6\x0f\x19\x46\x85\xd0\x39\xc6\xec\xea\x01\x46\x82\x55\x8c\xd4\x24\xf0\x97\xb5\x2b\x27\xae\xf2\xec\x1a\xaf\x3d\xf3\xf6\x17\x5c\xe8\x92\xf4\xb0\xeb\x56\xd6\xf9\xc5\x69\x70\xfc\x39\xfb\xb2\x05\xf3\xd6\xd2\xe0\xe7\xe7\x5f\x1d\x3d\xac\xe4\x12\x01\xac\x80\xf8\xba\x5b\xf7\xfa\x8a\x1b\xff\xf6\x4d\xdb\x8b\x9e\x35\x8f\xdd\xff\xe4\x76\x42\x5f\x2b\xed\x35\xbc\x56\x21\x22\x1f\xd5\xbf\xe6\xfa\x7c\xbc\x64\xb5\xca\x3c\xcd\x84\x88\x3c\xaf\x97\x60\x78\xba\xa0\xd0\xc7\xcb\x7c\x73\x3c\x57\xb6\xdb\xe5\x10\xfc\x62\x5d\xae\x70\x73\xdc\x45\xb3\x41\x04\xd7\x8d\x60\xc5\x63\xe7\xff\xeb\xd4\x32\x17\x4d\x87\x39\xfb\xaf\xeb\xd6\xef\xa1\xd9\xb7\xbf\xf7\x9e\xf5\x37\x17\x6e\xc6\x4c\xbb\xf6\x3e\x88\x88\x70\xf9\xb2\x7f\x63\xf9\xd0\xfa\x69\x67\xf1\xfa\x65\x43\xcb\x7d\xa6\xda\xc5\x25\x49\xf6\x28\x41\x78\xed\x66\x0b\xcb\x85\xa0\x9b\x66\xb1\xd3\xf9\x05\x84\xe0\x85\x5a\x3d\xea\x95\x65\x2f\x0b\xbf\xac\x81\x40\xa4\x31\x1e\x10\x2d\x56\x95\xb7\x5a\xa9\x26\xd4\x80\x13\xeb\x7b\x14\xd5\xfa\x5f\xcf\x38\xb1\x9c\x2c\x03\xe7\x9d\xfb\x5f\x17\x74\x84\xf6\xd3\x2a\x6d\x9d\x78\xe5\x15\xfd\xc2\xa5\xfd\x05\x44\x0b\xc1\x47\x1d\x17\xf5\x32\x3d\x60\xd0\x5d\xdb\x39\xf6\x53\x47\x94\x3a\x8d\x73\x49\x2f\x00\x87\xd1\x5f\x23\xc4\x44\x01\x91\x53\xc0\xf8\x32\xb0\x35\x30\x5e\x28\xf3\x03\x7c\xff\x67\xc9\xf7\xeb\xb9\xa7\x39\x28\xf7\x34\xb7\x88\xf5\x67\xe4\x9e\x3e\x02\xcf\xea\x47\xf1\x1d\xc4\x70\xb5\x88\xc8\xf2\xb9\x10\x08\x44\x30\x0b\xea\xea\x2c\xb3\x9b\xce\x89\x10\x8a\xcf\xa7\x34\xc7\x7d\xbe\xa0\x87\xb2\x58\xdc\x1c\x67\x6f\x8e\x73\xee\xf4\xc0\x6d\xec\xf2\xa1\x20\x8c\x02\xeb\x22\xa0\x77\xcb\xa6\xfb\xed\xb9\x61\xbd\x12\x14\x5f\x9e\xb2\x1c\x79\xd7\x2f\x20\x6f\xe5\xbf\x76\x3e\xf5\x43\x97\xdf\x15\xad\xbd\xe1\xa1\x43\xda\xb7\xda\x07\x43\x8f\x1b\x91\x82\xa1\x0d\xe4\xc7\xb2\xf6\xd9\x7f\x9e\xd7\xbe\xda\xb2\xf9\xee\xac\xf1\xc3\xbe\xf9\xe4\xcf\x7f\xc0\x18\xc3\x7a\xc8\x60\x76\x67\x3c\x87\x57\x71\x1f\xab\x3a\x22\x42\x8c\x51\x4b\xc2\x59\x4e\x13\x17\xcc\xe2\xb2\x14\xc2\xe3\x84\x26\x23\x3c\xe1\x72\xf3\xc2\x28\x33\x03\xba\xae\x1e\x25\xe8\x42\x61\x5c\xa5\x43\x18\x37\xd6\x01\x1b\x54\x4a\x2f\x71\xbd\x5c\x34\xb7\x58\xc7\x04\x48\x5c\x09\xba\x08\x7a\xe4\x9c\xb7\xd6\x1b\xf1\xdc\x8d\x5b\x67\x9d\x5a\xb4\xac\xb5\xd5\xb8\x1b\x1c\x19\xfd\x14\x90\xe3\x1e\xf8\xea\x56\x1c\xd2\x7d\xf6\xe9\xa5\xbf\x1b\xaf\x85\xd2\xee\x08\x17\xe5\xba\xb4\x1f\x51\xce\xa4\x86\x72\xaa\xf0\x99\xd9\x5d\xcd\x06\xa2\x53\x51\xdc\x6e\x59\x74\x38\xbc\x26\x8f\x08\x9d\x19\x91\x72\x58\x78\x16\x6e\x68\xb7\x82\xfc\x9a\xd3\xb1\x24\x22\x2d\x2a\xe0\x71\x18\x11\xc8\x0e\x8d\x01\xaa\x1d\x7e\x10\xd6\xb3\x8c\xa8\x29\xda\xc9\x64\x6f\x80\x86\x78\xff\x68\x37\xf2\xbe\x47\x9f\x3f\xb8\x66\x55\x7a\x7b\x80\x95\xa0\x0c\xe4\x83\x8f\xf5\x34\x29\xcc\x63\x8b\x76\x86\x7e\x05\xf2\xd8\x4d\xf4\x57\xa3\xb4\x6c\x91\x15\x37\xdc\x96\xa4\x4b\x51\x3c\x5e\x19\x5a\x55\xb2\xc0\xdb\x51\x1d\x1c\x34\xaa\x78\x17\xa9\x0c\x8f\x93\x06\x42\xd0\xe9\xe2\x24\xae\x42\x62\x53\x19\xe8\x66\x32\xb4\xa9\xcc\x18\x7f\x3e\x83\x46\x2a\xbe\x6e\x89\x76\x67\xbd\x3a\x68\xe6\x28\x04\xd5\x59\xd3\xbb\x26\xd2\x89\x7c\xfd\xc0\x49\xed\x0c\xa8\xa1\x9e\xd6\x86\x68\x6f\xec\x1c\x64\x5b\xce\xcf\x82\x9f\x34\x81\xbe\x28\xff\x09\xd1\x77\x17\x94\x81\x22\xcc\xb7\x01\x6a\xae\x24\x8a\x14\x0b\xed\x74\xce\xed\x36\x53\x66\x8f\x17\xbb\x81\xac\x89\xa6\x24\x89\xb2\xd9\x9c\xa8\x5f\x4a\x47\x09\x4e\x47\xed\x34\x38\x98\xbc\x49\xcd\xb8\x45\x4b\x5e\xa9\xfe\xfb\x9f\x46\xce\xc1\xf6\x75\x69\x77\xab\x3f\x68\xdb\xb4\x35\x7a\xb6\x81\x1b\xe4\x23\xda\x8e\x43\xda\xec\x98\x77\xc3\xd4\x02\xc2\x6d\xe3\xdd\xbc\xd9\xce\xb2\x92\x59\xf2\x78\x09\xc2\x69\x76\xc2\x23\xc6\x19\xb0\x21\x10\x4f\x1b\xb0\xd9\xcc\x82\x45\x30\x2b\x86\x7b\x35\x3e\xf3\x66\xac\x36\xd3\xe4\x60\x8c\x0e\xcb\x29\x4a\xf5\xde\x6b\xe0\x56\x79\xc6\xf5\x4b\x6e\xd1\xbc\xad\xad\xe0\xf3\xd6\x8f\x5e\xfe\xdd\xf9\x9c\x65\xa3\x06\x1d\x3e\x02\x1e\x42\x97\x8f\xf8\xfa\x95\xf9\x48\xfb\x79\xd5\xbd\xc6\x7d\xb4\x2e\x73\x02\xd1\x57\x8d\x40\x47\x0b\x59\x8c\x66\xe8\x65\xda\x58\x9b\x28\x61\x77\x86\x27\x2d\x1c\xc5\x3a\x48\x1b\xb4\x40\xc8\x44\xc7\xe5\x0c\x8c\xf9\x0c\x8d\x29\x47\xd2\x6f\xa1\x29\xea\x9a\x35\xcb\x0d\x96\xed\x41\xfe\xdf\x8e\x34\x6e\x41\x09\x23\x74\x1e\x9d\xa1\xcf\x60\xbb\x7d\x98\x5a\xc4\x99\x48\xd6\x04\xc5\xd7\x66\xb3\x9b\xa1\x95\x78\x85\x8b\xe8\xe1\x57\xb8\x88\x4e\xae\xa3\x3b\xfd\x26\x1a\x67\xd8\x61\x97\xf8\x26\xc8\x92\xe7\x4e\x1e\x5c\xb7\x1e\xb2\xc7\x60\x06\x4e\xa2\x4b\xde\x45\x23\x1b\xbe\x33\xb6\xe1\x55\x68\x3f\x9b\x64\xa7\x93\x14\x04\xd1\x24\x2a\x2e\x0c\x08\x6f\x35\xa1\x44\x46\xa2\x39\xee\x70\x08\x26\xc3\x86\x37\xf2\x24\x32\xd2\xd0\x8c\x46\x3b\xed\xec\x78\xe4\x4c\x7d\xb9\x26\x65\xc6\x6f\x69\xdd\x03\xba\xa7\x9b\xf1\xbf\x3e\xa7\x4d\xd5\x75\x33\xb4\xe3\xb1\x9d\xea\x42\xbd\x02\x09\x17\xf4\xfe\x45\xe8\xe1\xb9\x78\xb7\x87\x46\xb0\x32\xb4\xc5\xe4\x12\x2c\xf6\xa6\xb8\xcd\x02\xf9\x70\xbe\x23\xea\x7f\xba\x5d\x9a\xe8\x14\x8e\x56\x25\x85\xc6\x89\x0c\xf8\xc5\xfb\x66\xa4\x00\x39\x91\x01\x7f\xe1\xb4\x36\x95\xf4\x83\x61\x63\x13\xf6\xe8\x72\x43\x3e\x82\xc4\x48\xb5\xc8\x01\x59\x61\xe6\x95\x20\x3c\x7c\x49\x32\xe0\xf7\x2b\x22\x95\x95\xad\x98\x19\x9b\x4d\x32\x9b\x49\xaf\x44\x89\x0e\xd2\xdf\x41\x4c\x1c\x86\x22\xcd\xc8\x81\x4c\x13\x17\xb9\x86\x43\xc5\x86\x54\x19\x90\x0d\x84\xdc\x1a\x0c\x91\x8b\x85\xa7\x37\x03\x2c\xa5\xd1\xfd\x77\x3e\x54\x17\xa5\xf7\x7c\x7b\x2c\x50\xe0\x8b\xf0\xc7\xfe\xb6\x14\x8b\x12\x35\x09\x08\xc1\xc8\x96\xeb\xb5\x41\xe0\xe8\x63\xf3\xb5\x3f\x5e\xdc\xc9\xf4\xd5\xdc\x4d\x5b\xc7\xcc\x73\x83\xaf\xb0\x74\xa1\x9e\x8b\x67\xf0\x3d\xbf\x87\x68\x50\xf3\xed\x16\x8b\x95\x63\x25\x0f\xdc\x78\x24\x09\x7d\x11\xc9\x4a\x79\x7d\x8c\xc9\xe4\xb4\x09\x56\x45\x22\x38\x85\x74\xa5\x29\xaf\xcc\x06\x8c\x97\x21\xfc\x32\x6d\x18\x21\xcd\xcd\xeb\xb2\x3a\xb4\x62\x9c\x8c\x35\x58\xaa\x21\x63\x3a\xc2\xaf\xae\xc5\xd0\xf9\x7d\x3b\x8e\x07\x22\x7b\x7c\x58\xda\xf9\xbf\xcb\x11\x45\xb7\x33\xd0\x9b\x37\x2a\x49\x48\x3b\x13\x25\x09\xc9\x4b\x73\x69\x38\x5c\x18\xb3\x1e\xe3\x6a\xf5\x41\xef\x25\xb7\x7f\x8b\x31\x07\xcb\x31\xe6\xe0\x1b\xad\xb1\x7a\x81\xca\xb0\x15\xf4\x67\x8f\x37\x9e\x8d\xfa\xcb\x11\x7a\x7f\x39\x8a\x54\x98\x28\x45\x12\xb2\xa4\x3f\x3f\xad\xbf\x9c\x3e\xc6\xc2\xc4\x18\xc4\xf4\x1f\x50\x75\x26\x45\xd6\x20\x98\xc2\x67\x2e\xbd\xd5\x5a\x15\x13\xa8\x76\x9f\x41\x36\xc9\x63\xd8\xa6\xb9\x83\x48\xf4\x0c\x7b\x06\x63\xfe\x3e\x42\xa4\x7a\x23\xee\x32\x7a\x23\xc2\x39\x3a\x31\x7e\x98\x15\x77\xf2\xf9\xa5\x55\x70\xa7\x3a\x29\x5e\x0e\x5b\x91\xdc\x6e\xd6\x79\xe2\x87\x13\x35\x67\x45\x53\xc8\x8a\xf0\xbd\x53\xe0\x7b\xaf\x63\xc6\x88\x2c\x68\x22\xd2\xf0\xd5\x45\x96\xf4\xe1\x9f\xa7\xa2\x3a\x6a\xf6\x76\x31\x0a\x9a\x00\xea\x77\xd6\x0f\xa0\xc6\xda\x98\x07\x1e\xc4\x03\x28\xe2\x56\xa6\xdd\x7c\x92\x58\x8d\xe8\x19\x88\x07\xc0\xf8\x44\x0e\x62\x02\x08\x65\x39\x33\x6b\x5a\x75\x3e\xdf\x9e\xb0\xe1\x52\x63\x90\x20\x1f\x15\xc2\x12\x79\x11\xdd\x8a\x6b\xc7\xb3\xd7\xd0\x18\xd8\x8e\x4b\x8e\x41\x82\x42\x54\x06\x4b\xe4\xe7\xe9\x76\x5c\x72\x0c\xdc\x83\x0a\x8f\xf1\x8a\x31\x46\x61\x62\x8c\x72\x34\x86\x5c\xda\x89\xca\x6b\x37\x06\xc6\x5b\xc7\x63\x7c\xae\x8f\xf1\x8b\xf1\x89\x52\x34\x06\xdb\xa9\x88\xca\xcd\xc0\x9c\x6c\x80\xef\xbf\x9d\x59\x4e\xf8\x90\xad\x48\x53\x70\xc7\xc8\x32\xef\x76\xdb\x44\x8a\xf6\x07\xec\x4e\xa7\xad\x25\xee\x74\x4a\x84\x2c\x4a\x22\x74\xec\x09\xd4\x7f\x27\xad\x15\x25\xaa\x04\x33\xfa\xdc\xa5\x19\xdb\xc9\x43\xa3\x5d\xef\x2a\x80\xae\x7c\x80\xd1\xad\x6a\xfe\x39\xed\x97\x51\x89\xdc\xa0\x1e\xe0\x99\x8b\x7f\xa6\x4d\x5a\xcd\xeb\xdf\x2f\xfd\xc6\xf9\xc0\x73\x0d\xda\x0f\x0f\xac\x5e\xb5\x79\x13\x58\xbf\xf3\x41\x6d\xb6\xe5\x2f\x87\x57\xbc\x39\x4f\x9f\xdf\xad\xf0\xdc\xed\x89\xf0\x92\xc9\x11\x69\x3d\xa3\x26\x24\x7a\x46\x91\x6b\x08\x12\x58\xb0\x6d\x2c\x20\x5b\x1a\x1e\x33\xa6\x0c\x39\xd3\x71\xed\x86\x27\x70\xed\xf8\x41\x86\x25\x2d\x60\xec\x74\x29\x85\x6a\x97\x7c\xf6\xed\xc9\xbe\x79\x69\x6b\xac\xe0\x35\x96\x8d\xa7\xa7\xf1\x5f\x7f\xfe\xc2\x24\x6e\x5e\x72\x8d\x15\x49\xff\x84\x8d\xc9\x58\xe3\xc9\xba\xac\x3a\x50\xcc\xa6\x9d\xac\x06\xf1\x7e\xf5\x7b\x59\xa2\xdd\x18\x18\xcb\x1b\xef\xd7\xe1\x99\xb2\x9a\x8d\x65\x35\xe8\xcf\xf8\x44\x3a\xae\x00\x42\xc9\x6e\x50\x8b\x15\x41\x60\x5d\x76\x3b\xc1\x12\x1e\xaf\x22\x34\xc7\x05\x65\x98\xb2\x54\xd9\xa0\xd0\xa8\x4b\x0a\xc5\xf3\x0e\x0c\x2e\x60\x6d\x6e\xdf\xb7\xbc\xfd\x61\xdc\x1e\x5c\x20\x24\x43\x87\x51\x46\xce\x62\x3b\x38\x01\x8d\x00\x11\x67\xdb\x26\xcb\xae\x0d\x9b\xee\xb3\x90\xb3\x5c\xed\xe1\x03\x2e\xde\x01\xfe\xf8\xc5\x37\x74\xcd\xdf\xbe\x00\x67\x74\xcc\x00\x03\xaf\x1c\x63\x53\x79\x51\x77\x3f\x97\x28\xb2\x6e\x41\x80\x34\xfb\xfc\x2e\x84\x06\xea\x82\xa6\x83\xcb\x05\xa9\x95\x11\x22\x18\x65\xed\xd0\xb9\xfc\xb2\xd4\x26\x6b\xbc\x1d\x00\xc1\xef\x1a\xe4\x42\xdf\x76\xe0\x85\x6f\xbf\xf8\xb9\xed\x8b\x9f\xbe\xd3\x5c\x5b\x36\xf0\x6d\x47\xb8\x0d\x5b\xd6\x6c\xb4\x91\xfd\xad\x77\x92\x59\xda\xf7\xda\x47\x20\x17\x1a\xa7\x6e\xe0\xd5\xbe\x6a\xab\x7d\xf6\xd4\xb3\xa7\xa8\xab\x1f\x7b\xfc\xf1\xc7\x88\x8c\x35\x44\xbd\x9e\xd3\xd7\x90\xa6\xb2\x99\x28\x4d\x11\xed\x56\x24\x63\x0d\xe9\xed\xe9\x6b\x48\x53\x61\x09\x7e\x02\x64\x07\xd3\x3f\x91\xe8\x67\x8b\x65\xf1\x43\x63\x0c\xc5\xa8\xa1\x8f\xe8\x75\xf7\x97\x5a\xc3\xd9\x4e\x7b\xc6\x67\x30\xe6\x31\x96\xc5\x36\x7d\x8c\x5f\x0d\x59\xcc\x43\xb2\x48\x45\xc2\x5c\xe6\x18\x7a\xdf\xc7\x09\x89\xbe\x8f\x69\x7b\xc9\x05\xf7\x12\x70\x7b\xd2\xfb\x3e\x26\x31\x1f\x87\x27\x30\x1f\x93\x7b\xc9\x25\xe1\x77\xa7\x30\x1f\x93\xcf\xbe\x3d\xf1\x6c\x48\x7f\x2c\xb1\x97\x02\x68\x02\x92\xcf\x78\x7a\x1a\x8f\xf4\xe7\x2f\x4c\x3c\x3f\xb5\x97\x02\x88\x7e\xe0\x33\x46\x68\x47\xff\xce\xe4\x18\x03\x40\x4d\x62\x8c\x10\x1a\x63\x9a\x2b\xfb\x0a\x63\x24\x70\x2b\x39\x72\x17\xc8\x4b\x7e\x06\x8d\x32\x3a\xe0\x4d\x1f\x05\x7f\x06\xdf\x81\xe2\xb9\xbc\x63\xcc\x45\x48\x7c\xc6\x8b\xc6\x31\xbb\x15\xae\xfd\x38\xf8\x7e\x12\xaf\xc5\xcf\xfa\x5c\xbe\x4b\x7c\x02\x8d\x62\x72\x2b\x12\x9f\xa1\x97\x3f\x86\xf6\x2a\xca\x2d\xe7\x11\xc6\x04\x41\x52\x14\xc3\x31\x9c\xd9\x82\xdc\x44\x96\x42\x61\x77\xd4\x17\x32\x15\x04\x33\xf2\xbb\x71\xc6\x4d\x9e\x11\x93\x52\xc2\x60\xf7\xda\x43\xdb\x51\xd2\xf4\x1e\x74\x8b\x8c\xb3\xa3\x09\xd4\x6b\x05\x3e\x1b\xe5\x91\xe3\x67\x53\x0c\xf4\xa2\x08\x13\x61\xb6\xf0\x24\xdc\x48\x02\x6b\x32\x51\x4d\x71\x93\x72\xf9\x67\x83\x64\xc8\x0b\xa5\x8d\xcf\xdd\xb7\x2a\x19\xee\x32\xfa\x0c\xe0\xde\x56\x98\x37\x1f\xb4\xdf\x0b\x59\x78\x2f\x04\x7c\x8c\xab\x1d\x6f\x30\x66\x39\xe6\xcd\x85\xcc\xbd\x90\x2d\xe9\xbb\xc7\xe4\xce\xe0\x4d\x0d\x5c\xb3\xb1\x46\x2e\x5e\x05\x2b\x08\x12\x41\xd3\x8a\x59\x72\x93\x12\xe5\xf3\x53\xb2\x53\x6e\x89\x13\x82\x13\x58\x29\x78\x72\xb9\x5c\xde\xe6\xb8\x8b\x92\xa0\xc7\x23\x39\x4c\xd0\xd7\x31\x05\x2e\x87\x72\x9b\x7e\x57\x94\xe6\xf4\xe8\x11\x3e\x31\xac\x7b\xb3\xdd\x80\x9e\x31\x8f\x39\x0b\xf6\x6b\xe3\xe2\xda\xe7\xf5\x03\x2b\xfa\x2e\x9c\xf9\x28\xce\xda\x27\x7f\xda\xac\xd5\x69\xff\xd0\xde\x15\xf7\x38\xb6\xcc\x27\x27\x6e\x26\x9b\x70\x3e\xfa\x42\x48\xaf\x0f\xdf\x4d\x8f\x83\xbe\x98\xc3\xe1\xa4\x38\xce\x63\x73\x12\xb4\x13\xd2\xcb\xba\xdc\x2e\xa8\xba\xdc\x6e\xa7\xd7\x0b\x17\xc0\x2b\x38\x39\x0c\x31\xe4\x54\x2c\x22\x7c\x71\x38\x6e\xe9\x48\xf0\x15\xa8\x35\xd2\xfa\x3b\x12\xac\xa7\xf8\x8f\xd0\x3e\x8f\x0d\xec\xdc\x7d\x49\x73\x22\xd5\x5f\xdb\x6e\x10\xbb\xf1\xd6\x64\xce\x7f\x2e\xa4\xf5\x3c\xce\xb7\x1b\xa4\xe6\x3b\x04\xd9\x62\x71\xb9\x3d\x0a\xe1\x74\x42\x0b\x40\x92\xdd\x04\x1d\xf0\x2b\x1e\x87\x40\x4b\x2e\x19\x41\x4b\x9a\xe0\x19\x11\x48\xa6\x59\xb9\xd3\x2e\x8c\x74\x48\x40\xbd\x7c\x84\x49\x8f\x16\x47\xf3\xd3\x02\x51\x2e\xfa\xfc\x9e\x65\xf5\x03\xeb\xba\x55\xf5\x8e\xa2\xfe\x52\x46\x78\x0c\x0c\xd1\x83\x66\xad\x43\xf6\xcd\xdd\x24\xee\x51\xba\xf6\x08\x8d\x1a\x4c\x0a\x7a\x9c\xac\xed\x12\x8e\x9d\x2d\xbe\x11\xd1\xbb\x18\xd2\x3b\x09\x63\xbb\x35\xa8\x91\xdf\xa6\x57\x90\x14\xca\x84\x59\xfa\x7f\x25\xb9\x14\x50\xe9\x24\x4f\xda\x78\x0b\x24\xb9\x4b\x6d\x5d\xee\xac\xd3\xda\x07\x27\xc1\x72\x6d\xe3\x2b\xf0\x70\xb0\x9e\xd1\x36\x82\x3e\xa3\xb6\x2d\xde\x02\x29\xee\x59\x91\x37\xf6\x51\x50\x9a\x11\x4b\xeb\xbc\xd0\x88\x3f\xea\xbd\x04\xe1\x69\x7c\x95\x5a\x6c\x65\x79\x81\x87\x3e\x20\x20\x29\x82\x93\x24\x11\x65\x65\x92\x1c\x2d\x3b\x78\xd6\x66\x87\xf2\x4a\x11\x28\x40\x29\x52\x26\x4b\xaa\x67\x7d\xfb\x68\x45\x8a\x70\x9c\xcf\x88\x5a\x1e\x22\x19\x45\x11\x48\x80\x03\xa5\x7a\x10\x72\x29\x98\xa0\xed\x07\x8f\x9c\xd7\xc3\x90\x8f\x68\x7b\x41\xb3\xb6\x4c\x0f\x45\xbe\xb2\xad\xed\x2e\x1c\x87\x9c\xbb\x8d\xac\xc5\x7c\x85\x34\x36\xe2\xfe\x10\x63\xd5\x6c\x91\x06\x80\x83\x3a\x42\xb2\x58\xcd\x36\x5e\xe2\x4d\x50\x1f\x99\xac\x12\x24\x52\x04\x0c\xcb\xa0\x9c\x12\x6b\xdc\x66\x66\x59\xca\x62\x12\x08\x4a\xf9\x6d\x42\x13\xdf\x51\x30\x2a\x49\x61\x82\x66\x6a\xb5\xf6\x21\xe2\x69\xa3\x76\x0e\x94\x6b\xa7\x0d\xbe\xbe\x0c\xaa\xb5\x57\xc1\x48\x14\x9b\x04\x9f\x6d\x02\x27\x11\x43\xb5\xee\x9b\x34\x1f\xbe\x47\x9e\x65\xf4\x20\x83\x67\x15\xea\xc0\x63\x25\x18\x41\x80\x2a\xcd\xa9\xd0\x12\xb2\x56\x79\x96\xb7\xa3\xf0\x2d\x8a\xcd\x75\x84\x6a\xd5\x61\x32\xba\x83\x18\xae\xf2\xc9\xc9\xad\x71\x86\xa1\x82\xcb\x61\x67\xcd\xff\x70\x23\xf0\x1e\xd7\x2a\xbf\xd3\xda\x4e\x80\x01\xff\xd1\xee\x79\x0c\x6c\x59\xfc\xd2\x2c\x92\xfc\xf5\xb9\x3f\x9d\xd4\x48\x79\x93\x61\x6f\x7f\x66\xc4\x5a\xfa\x63\x5a\x2c\xf0\x0c\x7a\x1c\xeb\xa6\x5c\xa2\xb7\x1a\xf1\x29\x22\x49\x7a\x43\x26\x8b\x25\xa4\x50\x79\x51\x26\xe8\x08\xb6\xc4\x3d\x39\xf0\x0f\xef\xe1\x45\xbb\x43\x46\x59\x94\x08\x02\xab\x36\xd5\x44\xcc\xc8\xb4\x49\x62\x0d\xeb\xd0\xfa\xe8\x1e\xc8\xc8\xb9\x89\x56\x55\xe6\xd6\x03\x03\x72\x1f\xd1\x4a\xde\xb0\xb7\x7b\xcf\x9e\x75\x7b\x6f\xdf\x71\x44\x1d\xf9\xd6\x63\xcf\x03\xd3\x97\x37\x69\xdd\x27\x4f\x5a\xb8\xf8\xd6\xed\x4f\x32\x7d\x2f\x96\xae\x9a\x37\xf7\x76\xf0\x07\xad\xf3\x1b\xcf\x6e\xd8\xf0\xa7\x53\x27\x3f\xd7\x86\x2d\xbe\x6b\xf5\x32\x50\xb2\x0b\xd3\x3c\x11\xd2\x3c\x83\x39\x47\x64\x13\x45\x08\x07\x34\xc4\x10\xa2\x68\x8d\xba\xbc\xde\x28\x43\x15\x77\x82\x56\x8f\x9b\x34\x99\x0a\x1a\xe3\x16\x93\x28\x47\x48\x74\xfd\x4e\x90\xae\x34\xa4\xe4\xc4\x9d\x5b\x7b\xda\xf3\xd2\x80\x36\x62\xf9\x52\xbb\x99\x44\xf3\x8d\x19\x88\x68\x06\x55\x35\xfb\x57\xcd\x5d\xb5\x70\xe0\xe4\x1c\x92\xdc\x5b\xaf\xe2\xc9\x4c\x59\x1d\xd5\xde\xec\xd9\x7f\x44\xd3\xde\xfe\xbd\xef\xde\x0f\xf7\x60\x21\x08\x00\x5f\xaf\xe1\xb3\xc1\x03\x17\x1e\x5e\x7d\x53\x62\x4a\x43\x47\x81\xf5\xef\xbe\xf1\xb7\xb7\xc0\xee\x3f\xea\xfb\x8b\x86\xf3\x79\x82\x89\xc3\xd9\x5c\xa5\x96\x14\x11\xb9\xac\xdf\x2a\x3b\x9d\x70\xa3\x65\x13\x6c\x71\x27\x3e\x94\x1d\xca\x6e\x89\xa3\xc0\x89\x87\xf2\x08\x70\x29\xe4\xa2\x22\x8a\xca\x87\x5b\x2d\xd5\x16\x30\x85\x3a\xd5\xe1\x1a\x1c\x8a\x8b\x91\xf0\xaf\x97\x3c\x64\xcc\xa9\x7d\x75\x04\xdd\xe3\xb9\x55\x07\x4e\x2d\x9a\xb2\x64\xb5\xb1\x40\xf7\xdc\xb9\x75\x5f\xb4\x6e\xd9\xb2\xeb\xa6\x0f\x9d\x53\x4c\x4f\x59\x32\xf7\xe4\xee\xc5\x3b\xb2\xdd\x4f\xac\x49\x2d\xd1\x89\x57\x56\xdd\xb2\x65\xfa\x82\x49\x37\x0d\x18\xa6\xcf\x87\x87\xf3\x39\x88\x73\x81\xe0\x7c\xcc\x16\x5a\x8c\xba\xb3\xb2\xb3\xdd\xa2\x93\xb0\xb0\x85\x45\x32\x6a\x28\xd6\x18\x87\x7e\x55\x56\xc4\x16\xf1\x35\xc6\x23\x2e\xb3\xd9\x66\xe3\x1a\xe3\x36\xf1\x7f\x37\x1f\x90\x56\xcb\xe0\x08\x27\xbb\xbc\xb9\x8d\x8b\xc8\xc4\x72\x95\x02\x60\x4a\xe0\xca\x95\x82\xc1\x8f\xbc\xbe\x71\xca\x9d\xcb\x79\x6b\x5d\xb7\xfa\x5a\x38\xb1\x3b\xd7\xd8\xf8\x07\xc0\x8f\x09\xdc\x38\x40\xee\x5e\x82\x90\xe2\x84\x19\xd7\xac\x6c\x9e\x7d\xa7\x3e\xb3\xfb\xf7\x4f\x1f\x07\x89\x15\xa1\xfd\x71\x0c\xae\x4f\x0e\x31\x52\xed\x24\x88\xbc\x2b\x3b\x14\xca\x09\x06\x5d\x5e\x5a\x64\x22\xb9\x5e\x1d\xe8\x90\x61\xe4\x50\x4e\x4e\xb0\x39\x9e\xe3\x10\xa0\x4f\x6a\x45\xf1\xc8\xd4\x74\xd2\x8b\x16\xda\x7b\x9d\x1d\x20\x0c\xd3\x2a\x54\x82\x46\x85\xce\xac\x77\x5f\xec\x58\x8f\x72\xff\x83\xdb\x5b\xef\x05\x13\x97\x6d\x68\x57\x7f\xe2\x7e\xe2\xce\x3f\xea\xc9\xb5\x80\x98\x02\x69\xef\x8b\x71\x8a\x47\xa9\x25\xb2\xd3\xe6\x43\xa6\x19\x41\xf8\xb2\x78\x27\xa4\x3d\xcb\xcc\xe3\x4e\x2f\x66\xc6\x8d\x13\xb0\x1a\xe3\x6e\x11\x19\x6b\x4d\x71\x46\x49\xcf\x58\xea\x58\x6d\x93\x0a\xc6\x61\x02\x7f\xb3\xc2\x84\x7a\x7d\xfe\xbe\x15\x67\x4f\xb6\xaf\x24\xb9\x6b\xc3\x0a\x64\x88\xfd\x67\xe1\x6d\x1d\x8a\x47\x84\xdd\x6b\xd0\xed\x03\x94\xa3\x43\x38\x2e\xd4\x4b\x0d\x99\xbd\x7e\x93\xd7\x24\x11\xa8\xe7\x58\x0e\x41\x08\x5e\xaf\xb9\x25\xee\xa5\xb2\x9c\x82\x13\x32\x5f\x40\x41\xc4\x8c\x1c\xc0\x24\x9a\x58\xa2\xc8\x32\x21\xf1\x90\x9b\x19\xdd\x8a\xe5\xb0\xb1\xcf\x69\x61\xef\x5d\xdb\xb7\x6e\x3e\x12\x74\xf5\xb8\xe9\x96\xaa\x80\x1c\xaa\xab\xcd\x0f\x55\x83\xaf\x7b\xf4\xea\xd9\x83\xea\xa3\x75\xfe\xc3\x33\x27\x4e\x53\xfd\xb5\x91\xda\x13\xda\xd3\xb7\x99\x57\x72\x3d\x77\x03\x85\x7c\xef\x62\xe9\xf2\x05\xf3\x56\x61\xb9\x17\x20\xbd\x1b\x31\x16\x68\x0f\x35\x04\x44\x47\xd8\xeb\xf3\x85\x45\x13\x9d\x13\xf1\x7a\x59\x51\x04\x4d\x71\x51\x50\x2c\xac\xa5\x31\x9e\x85\x33\x17\x33\xe9\xcd\xc0\x2d\x69\xdf\xaa\xa0\x9d\x2a\xaa\x22\xaf\x7e\xb2\xc0\xa9\x4e\x9b\x98\xea\x56\xf0\xf7\x5a\x7d\xc3\x6e\xbc\x03\x35\x2b\xf8\xe3\x27\x93\x12\xcd\x0a\xda\x6a\x6f\x9f\x9b\xd8\xaa\xcf\x9e\x43\x74\x4e\x83\x74\xde\x82\x75\xfe\x30\xb5\xd8\xcc\x79\xbd\xd0\x32\x42\xa1\x0a\xca\x01\x5d\x55\x5b\x4b\xdc\x25\xa3\x60\x45\x23\x0b\xf6\xb0\x4f\xb1\x24\x2b\xb1\x12\x65\xa2\x29\xca\xc8\xb6\x82\x9a\x3f\xd1\x3c\x26\xb3\xef\x4e\x66\xb8\xa2\x3d\xc1\x75\xda\x5b\xfb\xf6\x81\xd2\x84\xe2\xdf\xbc\x36\x75\x01\x9f\xae\xef\x9f\x37\x72\x9e\x50\x9f\xd1\xf9\xd8\x06\x1d\xa8\x46\x3b\xd0\xd8\x18\x77\xb9\x58\xc8\xcf\x32\x16\x18\xe4\xe9\x7d\x17\x0d\xf2\xfe\xef\xd4\x15\x6b\x1f\xb5\xb6\x82\x70\xab\xa1\xc9\xb7\x6e\xd5\x2f\xe2\xd1\xc5\x7c\x5b\x6d\x4a\x75\x1f\x7f\x25\xd1\x23\x7a\x18\xee\x11\x5d\x94\xf4\x8d\x0b\xd0\x5d\x22\x19\xc1\xb4\xbb\x10\xbe\x11\xe4\xaf\x42\x74\x55\x83\x28\x01\x50\xb1\x0a\x8a\xe0\x72\xdb\x6c\x0e\xd2\xc1\xb7\xc4\x1d\x32\x03\x48\x60\xd4\xd9\xb6\x93\x81\xf4\xc4\x40\x3d\xe3\xa8\x1d\xa9\xe0\x1e\x6d\x39\xf5\xbc\xb6\xfc\xba\x69\xd3\xa7\x1c\x39\xf3\xc2\xf1\x73\x28\xf5\xe8\xe2\xbf\xee\x5d\x7d\xc7\x76\x70\x40\xeb\x7b\xfe\x8f\xef\xe0\x3c\x3a\xbf\xd1\x57\x03\xd3\x40\x42\x7f\x43\x36\xdb\x64\x9b\xcb\x0d\xad\x35\x42\x84\xba\x56\x74\x41\x86\x29\x4d\xe9\x19\x83\x97\xa3\x41\x4e\x52\xd0\x0d\xc4\x0c\xa4\x18\x29\xec\xa7\x0a\xb4\xd3\xf3\x96\x2c\xb9\xe5\xc8\xd7\xc7\x5f\xf8\x4a\x3b\x4d\xd7\xad\x68\x6b\xdb\xbd\x6b\xd7\xee\xd3\x5f\x9e\xf8\xf4\xb3\xe3\x64\x54\x5f\xc3\x71\x90\x86\x3b\x99\x31\xfa\x39\x10\xa2\xdc\xbc\x24\xe6\x45\xa3\x62\x80\xe5\x29\x78\x0e\xb0\xbe\xa0\x0f\x1a\x17\x3e\x1f\x81\xc3\x61\x92\x64\xa3\xf3\xa0\x2f\x1b\x31\x1a\x66\x27\xda\xdd\xb6\xeb\xf2\x99\x7e\x0e\x30\x39\xb9\x08\xd9\x02\x65\xf0\x22\x85\x43\xa7\xf2\x3e\xeb\x81\x62\x24\x80\x86\x64\x37\x4b\x93\xd7\x7d\xa7\x7d\x7a\x70\xeb\x86\x3b\xe7\xbd\xbf\x16\xae\x60\xbf\xc3\xb1\x07\x17\xae\xbe\xef\xf1\x23\xfd\xfb\x9f\x3d\xf1\xbb\x9d\x80\x9a\xf7\x60\x5c\xbb\xe0\xfc\xec\xd9\x65\xfb\x9c\x39\xf7\xdc\x32\x6d\xff\xd8\xfd\x4f\x74\x5b\x79\xe3\xec\x29\xf3\x66\xaf\xbb\x71\xc9\xfc\x35\x40\x6c\x78\x7e\x0f\x5c\xe7\x27\xe1\x7c\x7a\xa2\x75\xa6\x26\x13\x7a\x9c\x74\x34\xee\x99\x1e\x20\xba\xa8\x41\x20\x8a\x6e\x53\xc0\xe1\xc8\x32\x05\x15\x5f\x73\x5c\x09\xe8\xa1\xd2\xf6\x8d\xd3\x8b\xd3\xf5\xd2\x65\x23\xa4\xa9\x7c\xdd\x8c\x16\xea\x7a\x98\xf4\x9d\x7b\x37\xd5\xab\x9d\x7a\x2d\xba\x4c\xa0\xf4\xd7\xba\xf5\x3b\xec\x7b\xc4\x2d\x84\x11\x2b\x1d\x4d\x07\xe1\xfa\x23\xda\xbc\x56\x3f\x2a\xf1\xf1\xcb\x74\x30\xcb\x6f\x6d\x8a\xfb\x05\x09\xba\x70\x92\x8b\xe4\xb0\x77\x41\x66\x3a\x6c\x49\x5c\x22\x26\xe1\x96\xa1\xe0\x5e\xfb\x20\x29\x1d\xd4\x3e\xef\xa6\x76\xea\x53\x53\xd7\x31\x4e\xba\x5c\x7b\xd7\xbe\x53\xec\xdd\x44\x57\xb4\x8f\x94\xea\xfe\xf3\x64\x6d\x31\x3d\x1b\xef\x9f\x4a\xdd\x26\xc5\xfe\xe6\x20\xf8\xf3\xc8\x54\x4c\x00\xdf\xd5\xeb\x3e\x3a\xea\x75\xf0\x0c\xee\x39\x37\x06\xdf\x07\x3c\xa2\x2d\xa5\x22\x97\x5e\x23\x9c\x44\x58\x95\x25\xc6\x6e\x37\x7f\x04\xa0\x51\xa1\x82\x46\xd0\x02\x68\x20\x12\x65\xe7\xc6\x8f\xaf\x40\xe6\x3c\xd2\xa4\xfa\x99\x64\x00\x22\x57\xc5\xf0\x81\x14\x99\x12\x2d\x8f\xe5\x4f\xea\xd5\x7f\xca\x80\xde\xda\xd2\xb2\xea\xd2\xd2\xea\xb2\xce\x57\x8d\xb7\x4c\x98\x60\x19\x7f\x15\xba\xcf\x03\xfb\x99\xa1\x54\x3e\xfb\x3c\xb4\xd1\xdd\x44\x84\x28\x50\x5d\x0a\xcf\x0b\x02\x05\x9e\xa4\xbe\xa7\x2e\x51\x14\xa5\xf2\xb6\x01\x94\x3f\xfc\x0c\x18\x0e\x15\xf9\xb9\xe2\xf1\xb3\x8d\x52\x75\x3d\x97\x1c\x6f\x94\x9a\xb4\xd7\x5c\xda\x6b\xb0\xbf\x34\x94\x53\x5a\x9a\x13\x2a\xfd\x34\xf1\x62\x4e\x09\x7c\x51\x1e\x0a\x95\xb0\x37\x84\x4a\x4a\xf4\x5f\xea\xdf\x9f\x44\xaf\xe1\xbf\xa1\x79\xbf\xcd\x0c\x25\x7f\x65\x2f\xa2\xbe\x13\x87\x08\x16\x0f\x7d\x0e\xc1\x47\xb9\xe1\x57\xa4\x26\x1f\x7e\x91\xbf\xee\x84\xff\x3d\x35\x1f\xfd\xbd\x93\xbd\x38\x2a\xf9\x1f\xb2\x9b\x49\x27\xfc\xfc\x51\x63\x4e\x39\xaa\xcc\xb7\x9f\x8e\xa0\xa4\x4d\x27\x73\x2e\xe9\xf4\x93\x6e\x48\x59\x79\x59\x24\x54\x42\x41\x92\xcb\xcb\xc2\x39\xa5\xec\xcc\x9c\x92\x12\x38\x0f\x44\x2e\xfa\x5d\x29\xe6\xe1\x61\xc8\x43\xaf\x31\x9e\x1f\xf1\xd0\x4b\x79\x7e\x7b\xd0\x97\xc4\x97\x32\xc7\x55\xd2\x69\x80\x62\x49\x2e\x80\x9c\x29\x2f\x47\x9c\x09\x85\xcb\x10\xeb\x5e\xb9\x21\x35\xb8\x4e\x4c\x69\x29\x98\xa5\x6d\x82\xfc\x3a\x05\xe5\xc4\x7c\xe9\x09\x82\x23\xec\x47\x09\x5a\xa4\x49\x9a\x40\xa2\x81\x9c\x65\x57\x4c\x41\x6a\xbf\xf3\x9c\x29\xf7\x1f\x18\x3e\x76\xfa\xf4\x07\xd6\xc3\xf7\xbf\xc1\x5c\x4d\x6a\xec\x23\xd0\xc5\xb1\x1c\xa2\x00\x26\xeb\x3c\xe2\x2f\xe4\xab\xb6\xed\xde\x7b\x59\xe2\x91\x47\x1e\x41\xeb\x50\xcf\x34\x52\x1b\xd9\x15\xf0\x9c\x0f\xa9\x36\x29\x40\x58\x02\xf0\x4b\x70\x03\xb7\xb1\x26\xe3\xf5\x1a\x3e\x1d\x07\x0a\x25\x27\x71\x51\xbd\xc6\xc0\xb0\x50\x2b\xf3\x6b\x8c\x29\x21\x1b\xf5\xb5\x40\xb4\xce\x3f\x73\x78\xaf\x8a\x91\xa5\x05\x35\x21\xf4\xc3\x8c\xa6\xee\x15\x8d\xd5\xa5\x9d\xd9\xda\x68\x9e\xea\x1a\x10\xbd\xa5\xe7\xf0\xfa\x3e\xb5\x65\xf8\x87\x82\x9b\x7b\x0e\xaf\x1c\xdc\xa3\x10\xd1\x71\x0a\xf2\xd7\xcc\x2e\x85\xf3\x93\x8e\x0a\x74\x36\x9a\x9f\x41\x40\x02\xdd\xce\xa5\x90\x3b\x67\x4f\xbd\xef\x20\x33\x74\xdc\xd4\x99\x7b\x36\xc2\xcf\xbc\x0c\x79\xc2\x5e\xfa\x9c\x60\x08\xd3\x21\x40\x43\x76\xa0\x2d\x92\x5f\x13\xe3\x28\x76\xc3\xe1\xc3\x1b\x0e\x6b\x4b\x5b\x5b\x5b\x09\x12\x3c\x05\xdf\x17\xbc\xf4\x2f\xf8\x6c\x99\x70\x3c\xcd\x71\x2a\x05\x28\xc9\x42\x94\xc5\xe0\xec\xca\xf4\xeb\x06\x64\xef\x31\x69\xeb\x43\x05\x0f\xec\x9a\x32\xf7\x12\x91\x58\x99\xe1\xeb\xf6\x4e\x9f\x36\xce\x6a\x2c\x4a\x7b\x7a\xa9\x6c\x0a\x9e\x7f\x3a\x93\xc7\xeb\x8b\x8e\xc0\xf7\xc0\xa9\xc7\x76\x4e\x99\xc3\x0c\xbd\xfb\x81\x99\x53\xc7\x5d\xba\x94\xf8\x8c\xc8\xd2\x6f\x23\x19\x06\xd9\xf0\xe7\x27\xf0\x33\x04\xc2\xa5\xf2\x16\xfd\x39\x26\xfd\x41\x15\xe7\xc7\x57\xa4\x1e\x15\x36\xbe\x93\x93\x0f\xee\x9c\x7c\x93\x36\x48\x7f\xf0\x86\xbd\x33\xaf\x6b\xc6\x4f\x47\x6a\x86\x18\xc7\xd4\xd3\xb3\xb9\x42\xf8\x34\x3f\x51\x4c\xd4\x40\x8d\x22\x7a\x29\xaa\xac\xac\x10\x14\xca\x55\x55\x7c\x63\x04\x44\x88\xb2\xf1\xe8\x30\x7c\x69\x7c\x87\x2d\x9e\x0f\x45\x23\x5a\x63\xb4\x92\x43\x5a\x86\x31\x00\x54\x72\x8c\x05\xe7\xd2\x5a\x6a\x93\x2f\x2e\x89\xc7\x97\x2d\x19\x5b\x5f\x7a\xf5\xf0\xab\x03\xb7\xd4\x14\x14\xd4\x75\x8d\xe6\xd5\x69\x6f\x07\xe0\xcf\x65\x75\xe3\x16\x2f\x19\x1b\x5f\xb2\xa0\x2e\x37\xda\xb5\xae\x20\xda\x85\x1d\x1e\x5f\xb2\x78\xcc\x98\xc5\x9e\xab\x47\x5e\x5d\x5e\x5f\xd0\xa5\x36\x3f\xbf\xb6\x4b\x41\x7d\x39\xfc\xd1\xb3\x78\x4c\x7c\xc9\x92\x78\x41\x97\xba\x28\xfc\x1d\xe4\xc9\x6c\xa6\x9e\x1a\x67\xcc\x41\x51\xcd\xde\x32\xb8\x56\x72\x23\x0f\x78\x44\xf9\x4b\xe3\x2b\x7e\x9b\x66\xf0\x04\xa4\x6b\xc9\xa2\xb1\x75\xe5\xa3\x46\x5e\xed\x9f\xdf\xa5\x00\x3d\x38\x5a\x87\x08\x40\xff\x80\x08\xe8\xd4\xa3\xa0\x0b\xfa\x7d\x17\xfd\x3e\xf6\x45\xb8\x06\x56\x76\x07\x21\x11\x1e\xb8\x85\x69\x9a\x17\x50\xd2\xb3\x21\x7a\x48\xef\xa2\xbb\x3d\x3c\x16\xba\xdd\x53\x74\xeb\x81\xb2\x8e\x1e\x9d\xe3\x9e\x34\xc9\x1c\x2e\x8f\xb2\x3b\x2a\xae\x9e\x6c\x9e\x0c\x86\xac\xb1\x96\xd4\x54\x64\xe8\x74\x84\x27\x27\x93\x76\x86\xf9\x88\x86\x8e\xb1\x4a\x37\xd2\x2d\x34\x4d\x3b\xcc\x58\xf2\xc6\xeb\x3a\x1d\x72\x59\x89\x54\x21\xc4\xb7\x98\x92\xb0\x4d\xa8\xc8\xda\x29\x43\xeb\x27\xe5\xc7\xca\xa3\x53\x26\x1f\x50\xc6\x8d\xb3\x4d\x1a\xda\xb9\x73\x55\x79\x79\x15\xce\xcf\x82\xba\x60\x3f\xd4\x05\x1f\x42\xb9\xb7\x1f\xa1\x20\xcf\x48\xac\x0a\x20\x6b\x18\x29\x5c\x15\xab\xa2\xcc\xda\xb1\x0f\x22\xda\x2b\xd3\xdf\x30\xf6\x88\xe9\xb2\x7b\xc4\xb4\xa1\xb5\x75\x43\xab\xbe\x47\xd2\xf5\x8b\xf8\x34\x4d\x50\x22\x12\x68\xa2\x0c\xcb\x60\x62\x7f\x50\x66\x24\x75\xc3\x37\xec\x99\x3e\x7d\xac\x2e\xbf\xf0\x33\x4f\xe0\xcf\x08\x84\x57\x45\x75\x0d\x16\xfd\x93\x02\x82\xcd\x3b\x6f\xc8\x58\xe2\xe3\x61\xe3\x3b\x39\x19\x3d\x06\x1c\x7d\xec\xfe\xc4\xc3\xe0\x5f\xd7\x8f\x81\x34\x9c\x81\xcf\x23\x2f\xfd\x02\x9f\x67\x6d\x55\x01\x00\x8c\xae\xe1\x00\x53\x55\x93\x9f\xa7\x70\x14\xa9\xfd\x7d\xfd\x01\x90\xb5\x41\x3b\x1c\x6b\x74\x7d\x1c\x1b\xe2\xcd\xd8\x53\x6f\x62\x9a\xda\xc9\x8f\x8c\x32\x80\xbc\x8d\x1c\xe0\x52\xf2\xf3\x1b\x72\x4d\x65\xfb\xaf\x1e\x39\xaa\xa2\xcb\xd8\x45\x4b\xe2\xa3\x97\xcd\x87\x42\x59\xd7\xa5\xb0\x00\x0a\x70\x8f\x4e\x48\x58\x91\x0c\x21\x61\xad\xcd\xd7\xe5\x07\x8e\x6f\xac\x35\x1c\xff\x3d\xbc\x36\x2f\x43\x7a\x4c\xec\x51\xc8\x6f\xcb\x21\x1a\x24\xcf\xb5\x74\x96\x33\x43\x11\xcb\x93\x3a\x64\x35\x7c\xaf\x74\x04\x89\x1d\x45\x1a\xc7\xc7\x78\x9c\x65\x93\x58\x4a\x76\x35\x5a\x4b\x34\x57\x7d\x8d\xe0\x58\xe7\xf1\xd8\x86\xee\x86\x3f\xbf\x81\xe7\xbe\x81\x59\x48\x75\x83\x73\x47\x67\x94\x78\x54\x41\x5b\x47\xe0\xb1\xb0\xb5\x3b\x01\x33\xb6\xcc\x06\x7d\xcb\x8c\x5d\x04\xb7\x4b\x61\x97\xba\xfc\xd4\x76\x41\x53\xd5\xb7\x0a\x49\xba\xb5\xa5\xe4\xd1\x4b\xdf\xe1\x67\xbb\x55\xab\x40\x28\x40\x55\xf6\x28\xa4\xc2\x53\x78\x04\x74\xc8\x32\x57\x38\xec\x48\x77\x99\x6e\x12\x94\xc1\xa3\x0d\x69\xd0\x92\x6b\xf0\x8f\xf8\x94\x4b\x1c\xb1\x04\x03\x6a\xe1\xfc\x36\x1b\x63\x40\x4d\x45\xd4\x13\xf9\xaa\x12\xf3\xfb\x6b\x89\x30\x50\xc3\x7b\xc2\x64\xb8\x44\xe1\x85\x7c\x9e\x82\x43\x62\x1c\xbf\x73\x09\x53\x85\xf9\x5f\x98\x2a\x79\x57\x32\x61\x6a\x13\x96\xcb\x67\xf0\x05\x3e\x7d\x6f\x2a\xd5\xe9\x2d\x05\x83\x12\xbf\x22\xcb\x43\xe1\x52\x34\x8d\x16\x48\xb6\xf1\xfe\xd2\x74\xa3\xe6\x7b\xe3\x77\xd8\x6a\x40\x67\x04\x05\x46\xc1\xf9\xcc\x83\xf3\xa1\xb0\x34\x06\x55\xb8\xc6\x40\x26\xbc\x40\xf5\xee\xf1\x92\x5e\x1b\x67\x30\x0e\x2b\x19\x06\xfa\x47\x35\x57\xe0\x1f\x18\x05\x06\xd4\xe0\x41\xd2\x6c\x85\xbd\x33\x67\xaa\x29\x2e\xea\xc7\x52\xda\x98\xe8\xac\xcb\x86\xfa\x47\xc2\x8e\xa6\x9b\x08\x02\x35\xb8\x27\x48\x06\x8d\x73\x0f\x8f\xaa\xdf\x3f\x45\xe0\xc8\x91\x2b\x8f\xfd\xf2\x0d\x60\xc0\xf5\x7b\xdb\x8f\xae\x7d\x33\x67\xe6\xcc\x39\x87\xdb\x13\x00\xa0\x9c\xec\x87\x72\xd2\x0b\xae\xa1\xe9\x10\x16\x8d\x4c\xc9\x4b\x89\x82\xf6\x2f\xe3\xc3\x38\xf7\x1a\xec\x87\x3a\xad\xf0\x52\x1f\xbc\xf6\xf6\x56\x64\xa0\xa2\x0f\xc7\x7e\xcb\x0e\x05\xfb\x13\x26\xdb\xe7\x49\xb2\x7e\x32\x6c\xb6\x9c\x24\x4b\x90\xfd\x0b\x79\x52\x98\x94\x2b\xb8\x0e\xfe\xa4\x40\xa5\x0d\xd4\x51\x86\x7f\xc3\xe8\xcd\xd1\xc7\xf9\x3c\x21\x28\x73\xcb\x30\x29\xa1\x32\x5d\xb2\xf5\xc1\xd1\x9b\x9e\x44\x62\x82\x25\x1c\xee\xf7\x4b\x5e\xb8\x7f\x57\x40\x79\xb0\xb6\x52\x1c\x54\x70\x48\x27\xc1\x21\xd1\xdd\xfb\x29\xd0\x5f\x3b\xb6\x78\x7a\x9a\x7e\x5f\x01\xd7\x90\x7d\x8a\x24\xca\x52\x8b\x44\x76\x9e\x05\xfa\x4f\xd7\xf6\xcf\x9b\x3e\x7d\x1e\xe2\x35\xe3\x21\x8f\x32\xcf\xa0\x79\xa9\x76\x6a\x18\xbf\x94\xdf\xcd\xbf\xc1\xd3\x84\x7e\x5a\x8e\xbf\x0c\xeb\x75\x1a\x99\xa9\xd9\x9d\xf5\x6d\x87\x9e\xf1\x10\xb4\xa3\xfb\x61\x3b\x9c\xe2\x9f\x01\x23\xa0\xfe\xb9\xe2\xe7\xfe\x93\xf8\x1c\x05\xe6\x43\x9e\x8e\xbc\xf4\x83\xc1\x53\xbf\x6a\x53\x04\xc1\xef\xd7\x99\x6a\xa8\x84\x0a\x87\x2e\xd9\x69\xcf\x72\x5f\xe1\x35\x98\x9f\xd8\x67\xf7\x27\xb8\xb7\x27\xf1\xa2\xc5\xd8\x58\x03\x75\x5d\x51\x3e\x20\x65\x96\x23\xfa\xc9\xd9\xe4\x51\xca\x0e\xe9\xb0\x1f\xa5\x08\xbe\x9c\x27\x79\x9d\xab\x1d\xa7\x80\xa4\x8e\x7c\x21\x52\x52\x02\xad\xfd\x12\xf4\xd9\x32\x28\xab\xbb\xf0\x7a\x98\x0e\x11\xa4\x2e\xab\xd0\xa9\x22\xcb\x6e\xd0\xf6\x7f\xf4\x91\x6e\x1f\x0c\xa0\x17\x50\x2b\x98\x21\xf0\x3d\xd2\x11\x92\x62\xe0\xd1\x08\xdf\x87\xef\x15\xf4\x10\x25\x18\x40\xd6\xb7\xbd\xcc\x0c\x79\x1b\xeb\xf3\xfe\x94\x99\x39\x04\xdf\x22\x3e\x4d\x40\xed\x6b\x82\x0a\x38\xb1\x10\xc9\x35\x66\x0e\x4d\x47\x63\x7b\xb5\x16\xf2\x30\xf7\x0e\x7c\xaf\x7c\x94\xa0\x28\x9a\x01\xf0\xcc\x2c\xd3\xb3\x7a\xf5\x3a\x4a\xd2\xbb\x5d\x6b\xe1\xe7\xff\xe7\x4e\x7d\x9e\x4c\x4f\xb8\xd6\x7f\x83\xf3\x84\xb2\x53\x66\xd8\x43\x57\x5c\xa8\x8d\x89\x85\x32\x3e\xfb\xff\xb3\xc6\x24\xf8\x01\x6e\xcc\x0f\xe8\x5a\x48\x23\x07\x35\x89\x15\x7a\x1c\x1c\x45\xf1\x26\x40\x33\xd0\x44\x1d\x4a\xf4\x38\x5d\x11\x93\x52\x7d\xe3\xd1\x55\x14\x05\xff\x80\x1f\xbe\xfe\xfa\x6b\xd4\x1c\x93\xb2\xa3\xbf\xd1\xf8\xac\x1b\x8e\x7f\x14\xeb\x04\x8a\xbf\xac\x4e\xd0\x57\x87\x9d\x8c\x06\xcf\x41\xab\x83\xe9\xd6\xa6\x43\x5d\x62\xfa\x5f\xe8\x92\x67\xd2\x74\x09\x80\xa4\x11\xd4\x23\xf4\x6b\x50\xeb\x56\xaa\x66\xd6\x6e\x15\xec\x82\x24\xd2\x5c\x4f\x33\x18\x49\xc4\x09\x1a\x34\xc0\x7f\xb1\xe2\xd7\x02\x9a\x46\xfa\x0d\x1b\xce\xb2\xaf\xec\x0e\xf0\xa5\x8b\x1d\x28\x38\xde\x3c\xb4\xcf\xa6\x07\x0e\x1c\x1a\xdc\x10\x02\x7b\xdb\x1e\x22\x7f\x38\xfa\xda\x98\x03\x5d\xd7\xee\x6a\xfb\xee\x00\x1c\x6b\x1d\xdc\x07\xdd\x2e\xed\x22\x78\xb8\x57\x39\xb4\x57\x99\x88\x1b\x1a\x74\x35\x70\xc3\x52\xdd\x5a\xe5\x99\xe2\x61\xf0\xd4\xf9\x3d\x4e\xe7\x9e\xeb\xf5\xbb\x0c\x11\x1a\xea\xcf\x42\xda\xbc\xc4\x20\x35\xcb\xee\xb5\x11\x16\x12\xd8\xac\x0c\x0b\x08\xd9\xe9\x24\x58\x2b\xed\xf7\x59\x48\x3b\x3a\x1e\x9c\xcf\x41\xe2\x18\xf8\x99\x06\x8c\x01\x53\x9b\x9e\xf1\x99\xb8\x0a\xac\xd5\x03\xa6\x72\x0c\x54\xcb\xd0\xc0\xb0\x93\x18\x48\x83\xe4\xa8\x88\xdc\x9d\xac\x19\xf2\x77\x70\x6a\x6b\xc0\x75\xdc\x6d\xee\x7a\xed\x14\x30\xf5\xcb\xb6\x1f\x8a\xab\xf2\xbc\x8d\xa7\x46\xe6\x74\x1f\xd7\x40\xbf\xd6\xb6\xf9\x2e\x40\x7e\xf4\xc1\xf5\x07\xb7\x4e\xd6\x22\xe4\x79\xa5\xc7\xe4\x65\xda\x4c\xb0\xe1\xc1\xcd\xf1\x6c\x9d\x56\xc8\x47\x7a\x31\xe6\x63\xad\x6a\x31\x11\xbc\x85\x65\x79\x49\x04\xc4\x73\x98\x77\x00\x34\xfc\x8e\x35\xf3\x66\xfd\x27\x1e\x73\x32\xa3\xab\xa1\xa3\x16\x03\x47\x86\x43\x2e\x2f\x34\x6e\xc3\x55\x61\xd4\x40\x75\x31\x58\x00\x9c\xdf\xad\xba\xf0\x07\xf2\x9f\x9b\x9f\xa1\xc3\x07\xbe\xd1\x7e\x68\xfb\xe0\xc0\x01\x32\xff\xa8\x9e\x17\x0f\x65\x8e\xfa\x10\x8e\xe9\x27\x54\xd5\x69\x72\x72\x4e\xd6\x67\xb3\x73\x2c\x6b\x0f\x06\x4c\x4e\xa7\x9f\xb3\xbf\x00\x07\xf2\x13\x3e\x3c\xa8\x1f\xf1\x26\x91\xa7\x9b\x56\x8a\xec\xa8\x5d\x7d\x02\x75\xdd\xc8\x22\xdd\x32\xba\x7d\x16\x40\xa4\xa6\x3b\xd9\x03\xe4\x97\x92\x28\x15\xae\x75\xe2\xb4\x3e\xb5\x95\x4f\x1c\x9d\x3d\xb2\xa1\xc2\x15\x7e\x3e\x27\xd2\xef\xe6\xeb\x7a\xd9\x0a\x2b\xba\xd5\xae\xa6\x5f\xcb\xee\x7b\xd7\xdf\xda\x58\xf0\x8b\xd2\xf5\xe6\xc5\xad\x47\x8f\xae\x1b\x1d\x74\xc4\x9e\xbc\xa3\xcb\xff\x23\xed\x3f\xe0\xa3\xaa\xb2\x07\x70\xfc\xdd\x57\xa7\xcf\x7b\xd3\x67\x92\x69\x99\xf4\x9e\x4c\x0a\xa1\x65\x90\x22\x52\x43\x68\x19\x20\xf4\xde\xa5\x87\x80\x10\x40\x69\x06\x54\x14\x14\x0b\x52\x14\x44\x44\x85\x08\x51\x16\xd0\x75\x6d\x60\xc1\xb5\xae\xe8\xd7\xb6\xba\xbb\xf6\xb6\xeb\x2a\xcc\xe3\x7f\xee\x7d\x6f\x4a\x02\xee\xff\xf3\xfb\xfd\xd6\x8f\xcb\x64\x30\xef\x9d\x73\xee\xe9\xf7\x94\xc3\xea\xcc\xc1\x7e\x00\x9b\x40\x15\x9e\x84\x03\xa3\xb0\x2c\x80\x20\x1c\x17\x18\x96\x39\x95\xe0\x2d\x95\x0a\xf1\x3a\x6e\x65\x8a\x21\x56\xdf\xcc\x91\xf6\x58\x6f\xd6\xbc\x1b\xb0\x3e\x4c\xee\xfe\x9a\xe1\x79\xf5\xf0\x3c\xec\x1f\x54\x46\x4c\x3a\x0a\x71\x2c\x8b\x24\x91\xa6\xf5\x1c\xc2\x78\xea\x29\x85\x65\xf5\xa9\x78\x26\xd1\x24\x8f\x0e\x2b\x8b\x69\x83\x98\xce\x12\xea\xff\xf4\xd3\x8c\xae\xfd\xae\x93\x72\x11\x7a\x07\xe8\xcc\x78\x2f\x7f\x4e\xbf\xd9\x7e\x37\x26\xb3\x22\x53\x3a\x78\xf1\xf3\xe4\x9d\xee\xa7\x18\x9a\x06\x85\xf6\x0c\x3c\x9c\xc1\xa7\x57\x9b\xd0\x3e\x61\x29\x44\xeb\x9e\x7e\x9a\x3d\x7f\x09\xd7\x7c\xa0\x06\x40\xf5\x01\xf6\x23\xca\x44\x55\x45\x6c\x46\x41\x63\x40\x48\x23\x9a\x69\x83\x91\x42\x46\x13\x7c\x36\x3d\x83\x06\x51\x1a\xf2\x08\x0c\x5f\x9c\x33\x93\x60\x22\x7b\x8e\x89\x26\x5d\x74\x55\xd5\x59\x95\xcc\x03\xf3\xba\x15\xdb\xda\x87\x4d\x92\x0f\xb3\xee\xb3\x59\xfe\xaa\x81\x35\xb1\x31\xf4\x03\xb3\x37\x04\x16\x9f\x21\x3c\xb0\x1e\xe8\x32\x08\x60\x34\x52\x45\x11\x1d\xc7\x1b\x0d\x06\xde\x6c\x32\xf2\x98\x22\x02\x90\x18\x53\x44\x48\x50\x24\x75\xf6\x24\x99\x9a\x0a\xd4\xc6\x1c\x17\x62\x76\xec\x68\x97\x7f\x6e\x47\x2f\x01\x1d\x9e\xa6\xdf\x3c\xb1\xfb\xd2\xc7\xec\x79\xcc\x6e\x65\xf8\x1d\xb8\xe6\x74\x0c\xfb\x31\xe5\xa5\xba\x45\x0c\x26\x0f\xcf\x78\xac\x0c\xe3\xf7\x39\xa4\x5e\x8a\x66\x70\x00\x4a\xf8\x34\x29\xf5\x08\x28\x34\x34\x39\x2b\x3e\x99\x56\xcc\xc8\x26\xa5\xe8\xca\x3e\x0f\x65\x8a\x46\x25\x99\x45\x68\x17\x69\x9e\x1e\xf4\xf3\xdb\xed\x15\x4b\x66\xdd\xb4\x2d\xd2\x30\x67\xfa\x84\x21\x9b\x37\xdf\x3f\x70\xf6\x97\xb6\x7f\x23\x27\xfd\x56\x2c\xbc\xf9\x9e\x3e\x13\x5f\xfe\xec\xc2\x73\xbd\x9e\xe8\xb1\x2c\x76\x4e\x8e\xc9\x1f\xb4\xe2\xf3\xa1\xfb\xa9\xe7\x93\x16\xd1\x91\x03\x32\x63\x2b\xd2\x8e\xf1\x7d\xad\xf1\xea\x13\x8a\xa9\x75\x0d\x13\x41\x0f\x5d\x84\xdf\xd3\x53\xd9\x27\x80\x35\x81\x68\xc0\x41\xc3\xb0\x0b\xd1\x91\x5e\x2a\xb9\x70\x48\x92\x64\x1b\xe6\x22\x66\x99\xcd\x44\x34\xe5\x35\x6c\x3d\x30\xcc\x57\xf2\x77\xe4\xb9\x47\xe0\x2c\xfc\xf0\x5c\x09\xeb\x52\x23\x83\x17\x04\x5b\x2d\x26\xa3\xaa\x4b\x4d\x98\x77\xd4\x23\x61\x3a\xeb\x52\xa5\xe8\x2f\x0f\x55\x06\x71\x54\xab\xbe\x4c\x62\xfd\xb1\xd7\xe4\x67\x51\x9f\x33\x27\x4e\x9e\x96\xff\x84\x22\x74\x98\x1e\x11\x3b\x72\xf8\xad\x77\x72\xde\x79\xeb\x70\xec\x88\xb2\x8f\xfc\x2d\x36\x87\x6f\x01\x5d\x59\x13\x31\x82\xe2\x66\x8d\x3a\xc1\x28\x58\x24\x4a\xec\xa5\x45\x75\x94\x0e\xb0\xc1\x2f\xd4\xc1\xcb\x35\x68\x80\x3a\x36\x34\x9c\x3a\x04\xb6\xac\x34\xab\x2a\xd3\x52\x59\x11\x22\x85\x05\x01\x49\x84\xe8\xc2\x70\x16\x59\x6e\xfb\x4a\x36\x3d\x8d\x06\xa1\xdb\xe5\x7a\x79\xc7\xbe\xeb\xdf\xa7\xae\xdc\x72\x91\x9e\x28\x0f\x90\xef\x95\x3f\x94\xad\xeb\x40\x26\xe3\xbc\xc7\x93\x29\x01\x3a\x0d\x18\x5a\x44\x99\xcc\x74\xdc\x7a\xd0\xf0\x52\x04\xaf\x55\x34\xe0\x35\x30\xce\x43\x12\x91\x44\x89\xa8\x3b\x76\xd0\xe5\x6a\xc2\x81\x97\xbf\xa7\x1b\x40\xe1\x61\x06\x44\xf5\x97\x37\x27\xf4\x9d\x89\xbc\xef\x63\xca\x43\x8d\x8e\xd8\x39\xbb\x8b\x61\x9d\x0e\x87\x28\x09\x2c\x2b\xe1\xea\x19\x17\xe7\xe8\x65\x86\x57\x4a\xd8\xa8\xa9\x46\x8b\x02\xd6\xe4\xd4\x73\xe5\x12\x20\x90\xed\xb2\xca\x64\xb0\xc4\x9d\x87\x05\xef\x53\x47\xe5\x16\x37\x22\xda\x97\xdc\x28\xe8\x11\xd8\x06\xbc\x57\xce\xd9\x13\xd1\x4f\x5c\x7c\x2e\xf6\x30\xda\x53\x38\xa1\x61\xe5\x7d\x91\x1b\x5f\x5c\x23\x55\x58\xbf\x3a\xbf\x74\xc0\x01\xf6\x63\xf9\x63\xf9\xe9\xd8\xe6\xc3\xe8\xc4\x63\xe7\xc7\xfe\x57\x7e\x23\xf6\x1f\xda\x3d\xa4\xad\x04\xb5\x9c\x5f\x31\x43\xd1\x23\x10\x0f\x5e\x4b\x8f\x0c\xbb\xa6\x1e\xf9\x8d\xc4\xbb\x59\xc0\x3c\x6b\x88\x3d\x29\x07\xde\x86\x6f\xb4\x8c\x24\xea\xb4\x2a\x65\x75\x84\xb2\xf4\xd5\x94\x75\xd6\x28\x74\x55\x50\x20\xd7\xcb\x38\xef\xbd\x06\x20\xdf\x17\x1c\x32\xe0\x89\xc3\x0f\xee\xe8\x73\x98\xb6\x3c\xb8\xa5\xdb\xe1\xe8\xf9\x93\xea\x1e\xf6\xc9\xf0\x1e\x11\x22\xa0\xbe\x11\x0b\x2b\x4a\x0c\x63\xb3\x89\x69\x3a\x1d\x5e\xc5\xc3\x72\xac\xfa\x46\x0e\xde\x68\xa4\x9c\xe4\xb3\x31\x2e\xdf\x57\x2d\xcb\x54\x8a\x54\xaa\xb0\x45\x87\x73\xb5\x8b\x54\x30\x40\x4b\x88\x97\x48\xc6\xa0\x27\x22\x9c\x3d\xbb\x6b\x5e\x1b\x5d\x86\xd2\x2f\x5f\xa1\xe4\xff\xc8\xbf\xff\x13\x09\x7d\xee\xb8\xbf\x69\x6b\xcf\xfb\x9e\xa1\xd7\xaf\xf8\xa9\xe2\xf0\xcf\xf2\xaf\x0d\xf2\x13\xf2\x0b\xa8\x08\x5d\x8f\x9e\x5b\x21\x7f\x56\xf9\xd5\xbb\x63\x9f\x7d\xb9\xe1\x29\xd2\x0f\xd2\xef\xca\xc7\xec\x78\xa2\xef\xca\x01\x5a\x86\xa3\x35\x5a\x2d\x0d\x62\x65\x36\xd1\x1c\x43\x19\x4f\x01\xcf\x6b\x80\xb4\x83\x49\x69\x8f\xd4\x61\x92\x56\x59\x69\x75\xa0\x1a\x81\xf9\xb7\x48\x61\x91\x66\xb9\x7e\xc8\xf6\x80\xdc\x7a\x1e\xf5\x6f\x6d\x7a\xf6\x65\xb9\xb7\x3c\x6f\x5f\x98\xf9\xcf\xe5\x86\xe9\xe8\x30\xba\x5b\x2e\x89\xfd\x72\xc9\x06\xef\x5b\x0c\x32\xde\x8f\x9c\x43\x8f\x88\xc1\xc8\xea\x4d\x60\x76\x4c\x92\xa8\x37\xb5\xa3\x11\x6d\x51\xbd\xde\xcc\x61\xd5\x61\x56\x35\x9f\x39\xae\x3a\x3a\xf4\xc2\x10\x47\x89\xe8\x59\xa2\x46\x24\x30\xf0\x12\xdd\x07\xab\x5a\xd0\xba\x5f\xff\x22\xd7\x13\x56\xbf\xf4\x04\x5b\x7f\x62\xb7\xfc\xf0\x61\xfa\x28\xbc\x77\x29\xf0\xfa\x28\x78\xaf\x83\x1a\x14\x31\x4a\x82\x89\xd3\x38\x4c\x26\x8d\xcb\xc9\x69\xe0\xc5\x27\xa2\x1c\x27\x69\xb5\xf1\xb3\xd1\x62\xa6\xa7\x2c\xe4\xb3\x94\xc2\x0d\x1d\x0b\x88\x88\x8b\x81\x12\x00\x04\x03\x14\x1c\x90\xa2\x71\x2a\x99\xfb\x1e\x3e\x46\x20\x41\x6f\x22\x23\x62\x40\xeb\x8c\x43\x87\xce\x9e\xa0\x0f\x9f\x7e\x86\x00\x24\xff\x2c\xff\xb3\x1e\x34\xcf\xdb\x6f\xe3\x33\x98\x07\x34\xa9\x06\xd8\xec\xd8\xc6\xe9\x31\xb7\xf2\x20\x85\xbc\xc4\x3b\x1d\x76\xbd\x1e\x89\x3c\x66\x6f\x44\xd8\xbb\xa3\xb3\x11\x67\x11\x42\x88\x12\x14\x06\x9f\x03\xbb\x1a\x78\x9b\x93\x40\x4f\x6e\x1f\xbd\x6e\xea\xdf\xb6\x8d\x2e\x14\xc6\xcd\xac\xd4\xdb\x9f\xf5\x58\x5f\xf9\x18\x14\xf5\xbe\x25\x6f\xbd\xb2\xfb\xe3\x83\xb7\x0e\x73\xd6\x6d\x5c\xfd\x5f\xf9\x5f\xef\x5e\x2c\xc4\x30\x0c\x00\xfa\xf4\x21\xba\xf6\xfa\x88\x43\xa7\xd7\x33\x22\x2f\x71\xc4\x25\x00\x9d\x2b\xf2\x3c\xd2\x71\x60\x07\x8e\x4b\x34\xa2\x4f\xa5\x88\x49\x62\x60\x47\xa7\x5d\xbb\xaa\xd0\x00\x77\x90\x11\xa9\xc4\x3b\x64\xfb\x5c\x1e\x4a\x9f\xbf\xfc\xcd\x17\x68\xf5\x90\xbe\x46\xc7\x59\xbb\xb9\x6a\xc6\x38\x14\x39\xcc\x06\x63\xbf\x07\xd7\xaf\xff\xf8\xe2\xed\xdb\x26\x64\xca\x75\x24\x26\xa7\xd6\x00\x4d\x06\x11\x19\xb7\x02\xa7\x88\x66\x8d\x15\x81\x6b\xa2\x61\xec\x36\x08\x58\x0c\x7a\x50\xc6\x43\x29\x96\xb2\x26\x3c\x1f\x9a\x90\x27\xc5\x4f\x71\xd6\x24\xe6\xc2\x84\x24\x06\x57\xb7\x80\x22\xae\xc4\xbb\xcc\xe1\xc4\xd0\xec\xf6\x30\xcd\xff\x7a\x41\x7e\x52\xfe\xec\xcd\x4f\x97\x6e\x8f\xfd\xc4\x78\x2f\x4d\x66\x1f\x40\x47\x9f\x7c\x55\xfe\x52\xce\x5b\xf1\xd6\x78\x34\xf4\xc2\x2d\xd3\x55\xfb\x06\xba\xe3\x2a\xfb\x36\xe4\x7f\xd8\xb7\xe0\x1f\xd8\x37\xe2\x0e\x61\xeb\x86\x40\x4f\xfc\x87\x3d\x4c\x7c\xf1\xba\x88\x1d\x02\x2b\xb7\xdb\x65\x70\xb2\x9c\x64\xb1\x70\x4e\x17\x38\xe2\x94\xbe\x1d\x8d\x3a\x01\x0a\xd7\x29\xb1\xae\x33\xf0\x06\x27\x68\xe0\x91\xf0\x36\x67\x9c\x21\xc3\x57\x4f\x79\x50\x87\x76\x2b\xf3\x79\xb1\xeb\x69\x2d\x57\x3e\xeb\x10\x1b\x64\xc2\x68\xc8\xbc\x11\x06\xd7\x59\xbf\xa9\xf6\xa6\xf5\x8e\x70\xfb\xb9\x79\xee\xda\xe7\x22\x99\x0f\xc9\x8f\xcb\xc7\xfe\x75\x86\x9e\xec\x5a\x79\x3b\xea\x27\xb7\x3f\xf0\xe0\x58\x3f\x2f\x7f\x3b\xf1\x83\xbf\xd2\xc6\xd8\xef\xf2\x5f\xe5\x8b\xab\xd8\x77\x08\x1d\x72\x54\xfb\xe4\xa6\x7a\x45\x4c\x26\xb7\x5b\x40\x56\x8d\x20\x58\xd3\x3c\x16\x1b\x08\xd1\xb1\xa8\xc6\x8a\x3d\x52\x23\xa2\xd1\xa9\x84\xbd\xaa\x4d\xd6\x8a\x75\x58\xe6\x6f\x0d\x29\xce\x39\xa6\x54\x01\x92\x6c\x26\x45\xb9\x82\x23\xf3\xc3\x59\xda\x89\x6c\x3f\x3c\x7d\x57\xfb\x03\x10\xfb\xe8\xc4\xbe\x75\x99\xe0\xb5\x7e\x2d\x7f\x1f\x2b\xc3\xf4\x8b\x3d\x83\x63\xa0\xb2\x99\x8b\x95\x1c\x28\x88\x0b\x03\xb6\x40\xcc\xe1\xd8\x2b\x70\x36\xa2\xc0\xb1\x64\xa8\x61\xa7\xbf\xc3\xdf\xc1\xdf\x69\xae\xa0\xf8\xdf\xd1\xfd\xd4\xbf\xd3\xa8\xbf\xa7\x51\x7e\x0f\x18\xfb\x28\xcb\x33\x7e\xf0\x01\x18\xca\x1b\x01\xc7\x18\xe1\x52\x1f\x16\xd1\xed\xd8\xde\xbf\x96\x12\x75\x82\x35\x0b\xd3\xd5\x9b\x37\xff\x93\xe5\xe9\x66\xe0\xd9\x37\xe0\xf7\x64\xf2\x7b\x02\x78\x8f\x16\x96\xe3\x39\x01\x7e\x97\x42\x02\xd2\x6a\x38\xc4\x2b\x4f\x08\xbf\x56\x9e\x3a\x6a\x2e\xf1\x24\x2b\xfc\x8b\x1a\x36\x6f\xfe\xc7\xfb\x5b\xb6\xfc\x03\x3f\x31\x76\x33\xdd\xac\xc8\x02\xd0\x7d\x30\xdb\x15\x9e\xaa\x83\xc8\x24\x83\xe5\x04\x5e\x0b\xc0\x82\xaa\xd6\x31\x9c\xa0\x37\xd0\x8c\x8e\xa9\x8b\xe2\x36\x4a\xad\xc0\x9b\x11\x97\x58\xf4\x5f\xd2\xb1\x15\x3e\xac\x2e\xbd\x0e\x92\x4d\x80\x7a\xc4\x0e\x3e\xbc\x4c\x5e\xba\xe4\x71\x74\xe7\xa1\x7e\xf7\xed\x42\x95\xf2\x79\xb6\x6b\x6c\x3d\x7a\x4d\x0e\x13\x19\xbc\x72\x09\xde\xfb\x2c\xe9\xe3\xb4\x52\x4b\x23\x3d\xf5\x82\x49\x10\x45\x86\xe5\xad\x56\xa4\x33\x99\x24\x84\x38\x70\xc9\xec\x2c\xc7\xd9\x44\x78\xbf\xce\x58\x17\x35\xeb\x10\x68\x0e\x9d\xa8\x43\xbc\x55\xcb\x6b\xeb\xa2\xbc\x99\xb3\x23\x13\xd9\x2f\x14\xf7\x60\x49\xdf\x10\x2e\x49\xc3\x7d\x1a\x05\x89\x3d\x28\x96\x64\x31\x54\x7c\xad\xb5\xe2\xd0\x00\xb0\xf1\x39\xe9\x41\x6c\xd5\xd9\x67\x63\x4f\xcb\xef\xed\xf8\x33\x92\x41\x8f\xde\x82\x86\xcb\x8f\xa1\x1d\x97\x2f\xfc\xcb\x85\x06\xc9\x6d\x78\xae\xf6\x73\x5b\xe4\x87\xd0\x40\xf4\x37\xa5\x9f\x44\xed\x4f\xa3\x72\xa9\x4a\xaa\x3b\xb5\x3f\x32\xad\x6b\x0e\x2f\x64\x18\x6a\xca\xec\x76\xaa\x26\xdd\x9b\x67\xb1\x78\x6b\x84\x1c\xae\x47\x4f\x77\x55\x66\x55\x5d\xb4\xcc\x3e\x2c\x9a\xdb\xb5\x2e\x9a\x9b\x5b\x52\x56\x5b\x36\xb4\xec\x6c\x19\xeb\x2f\x9b\x50\xb6\xbd\x6c\x4f\x19\x5b\x16\x71\x78\xfa\x97\x95\x69\x33\x02\x99\x6f\xa4\x7f\x9c\x4e\x53\xe9\x0b\xd3\x69\x1d\x93\x9e\x9e\xe9\x28\x64\xf0\x68\x09\xb3\x41\x8b\x0b\x69\x78\x6d\x7c\x5d\x5b\xbc\x50\x12\xa3\xda\x28\x29\x02\xdb\x78\x63\xb8\xa4\xa0\xe0\xea\x79\x13\xc9\x02\xab\x4a\x5a\xa9\xc8\x53\x76\xb5\x91\x91\x6a\x9c\x90\x1c\xc2\x15\xdf\xb2\x55\x99\xa5\x0c\xe0\xf7\xe2\x1d\xb2\x6a\x53\x0b\x9d\xc5\xb5\x0d\x8c\x8a\x5b\xfa\xfc\xa7\x69\x73\x46\xc5\x5d\x93\x5a\x5a\xe4\x13\x07\x23\xfd\x07\xf4\x16\x0e\x59\xef\x6d\x7d\xe2\xfa\x91\x7b\x1f\x7e\x84\xb9\x54\x53\x13\x99\x58\xb5\x72\xe8\xb0\xe2\xd8\xe4\xfa\x46\x46\xde\xa5\x6d\xa0\x7b\x4b\x68\xf1\xf8\xfe\x45\x88\x9a\xbf\x72\xe5\xfc\x03\x0f\xc8\xfb\x39\xb6\xdb\xc6\x05\xc3\xc6\x4a\xbb\x5a\xb7\x6e\x45\x69\x28\xd3\xf5\x6a\xfd\xd4\xe8\xae\x86\x28\x4b\x97\x4e\x8d\x1d\x3f\xba\xfb\xd1\xfb\x15\xfa\x8e\x04\x1e\x99\x06\x3c\x62\x83\x68\x26\x9b\x9a\x1f\xe9\xa1\xd7\x68\x1c\x21\x9e\xb7\x98\xfc\x0e\x07\xb2\x78\x4c\x16\x53\x4e\xae\x5d\x6f\xa3\x6c\x75\x51\xbf\xc6\x0c\x5e\xd1\xe3\x14\x63\xa6\xde\xa0\x3e\xa6\x18\x3d\xf8\x61\x16\xda\xe2\xa8\x8b\x5a\xec\xb4\x8f\x0c\xe2\xef\x54\x9e\x7f\x63\xe7\x05\xce\x8a\x92\x4b\x28\x91\xb0\xb2\x14\x42\x08\xdb\x43\x64\x02\x33\x0e\xc1\xc8\xee\x0a\xac\xe5\x91\xa4\x5e\x34\x8c\x5c\x8a\x1e\x7f\xe6\xdd\x81\x07\xb7\x06\x8b\x5e\x3c\x27\x97\x2f\x45\x79\xc8\xd4\x34\x7d\xfe\x8d\xf2\x4f\xdf\x37\x4d\x9f\xde\x44\x4f\x46\xef\x3f\x70\xdb\xd4\x7e\x5b\x7c\x8d\xe1\x3b\xee\x46\xef\xcb\x4f\xd4\xd7\x47\x87\xa3\xbf\xc9\x4f\x8e\xac\xaf\x1f\xa5\xd6\x25\x75\x21\x3d\x8e\xfd\x88\x3c\x3e\x04\x38\x77\x23\xf2\x28\x52\xb9\x10\x95\xb2\x1a\x30\x45\x92\x85\x33\xe0\x3d\xd4\x2c\x88\x01\x6b\xbf\x56\x34\x42\x11\xf7\x9c\x21\xfa\x0e\x20\x63\xbb\xc9\x5f\x80\x1f\x70\x07\x9a\x4f\xe7\x3e\xfd\xd8\x5f\xda\x4f\x9d\x3c\x49\x17\xc9\xdf\xca\x5f\x82\x10\xfe\xfb\xdc\x53\x97\x3f\x3a\x8f\xdf\xe5\x53\xdf\xa5\xa7\x5c\xb8\x53\xcf\xaa\xe5\x24\xbb\x1d\x69\x0d\x9c\x96\x73\x7b\x6c\x64\x58\x99\x64\xa6\x10\x26\xa5\x96\xd6\xda\xeb\xa2\x5a\x3b\x2d\x5e\x8b\x94\xe1\xce\x13\xd3\x88\x80\x59\xd5\x10\x05\x40\x0b\x65\x29\x90\xe1\xbb\xc6\xf2\x2a\xdf\x46\x0c\x97\x02\xe1\x46\x66\x2a\xc0\xf7\xe3\x8f\x18\xc2\x85\xe8\x5c\xec\x67\x0c\x25\xfa\xf2\x86\x73\x4f\xc9\x7f\x06\x61\x3b\x8f\x6d\xc3\x6b\xc0\x0c\x5f\x10\x38\x6f\x88\x64\x83\x2a\xc5\x6b\x11\x58\xf8\xde\x60\xc4\x6a\xc0\xcc\x03\x84\xe0\x44\x80\xb3\x8e\x61\x43\xba\xa4\x46\xf8\x83\xa6\xad\xb8\xf4\xc7\x25\x9f\xf9\xe2\xf2\x3f\xe9\x2b\xb1\xa7\xe8\xcc\xd8\x87\xf4\xd4\xb8\x9c\x2b\xf6\xf9\xf8\x95\x6f\x98\x4f\x40\xc6\x33\xf1\x1c\x40\x96\xb1\x3b\xcc\x69\xda\x8c\x8c\x34\x9f\xde\xc1\xf0\x59\xd9\x3e\x83\xde\xa0\xc7\x93\x92\x5c\x94\x1d\x82\x1a\x4b\x5d\xd4\x25\xb2\x2c\x98\xf1\xba\x28\xe5\x48\x29\x94\xfd\xe3\x59\xe8\xea\x04\x70\xe5\xde\x2a\x78\xed\xa2\x59\xf8\x83\x1e\x74\xf0\x85\xa2\x3d\x95\xaf\x4c\xbc\x31\xb9\x87\x59\xad\x97\x6d\xba\xe7\x3d\xdb\xea\x96\xc2\x03\xe3\xc7\xbe\xdc\xb9\x50\xd6\xb8\x7d\xde\xdd\x47\x14\x9f\x67\xa6\x3c\x9f\xed\x49\xfa\x73\x8c\x78\xda\x93\xde\x60\xd0\xe2\xaa\x37\xad\xd6\x64\x36\x18\x87\x8f\x35\xa4\x6b\x79\x7c\xbe\xb8\xe8\x4d\x3d\xe1\xf8\x88\xba\x8e\x33\x19\x92\x35\x6f\xf0\x2f\xce\x08\xa2\xbf\xcb\x1b\x98\x77\xe5\x31\xa8\x56\x36\xbe\xfc\x32\x73\x64\xdb\xb6\xcb\x9f\x6d\xfb\xeb\xb3\xcf\x02\xed\x8e\x01\xed\xf0\x8c\x68\x91\x2a\x8c\x38\x18\x5a\x6b\xa2\x4d\x92\x85\xd0\xcb\x8c\x29\x04\xd6\xcb\xa1\xf6\x7c\x76\xe0\x66\x2e\xc0\xa8\xc3\x33\x24\x30\xe4\x92\x8d\x47\x31\xf9\x5f\x15\xf7\x99\x27\x44\x86\x8e\xff\x1e\xed\x6b\xb7\x21\x6f\xce\xd4\x31\x33\x17\xd1\x53\xb6\xc6\xb8\x3d\x6d\x4a\xbd\xd2\x37\x8a\xae\x00\x39\xfa\x9d\x9c\xdb\xcb\xc0\x33\x2f\x93\x99\x78\x55\x91\x34\x8d\xc1\xc0\x21\x64\x32\x6b\x38\x3d\xcd\x6a\x41\x9f\x6a\x11\xd8\x32\x43\x92\x51\x48\x49\xa2\x3a\xe5\x4c\xb5\x65\xc0\x20\x42\x25\xee\x85\xaf\xb6\x0b\xc0\x22\x2f\xc7\x96\x2f\x5f\xde\x76\xea\x14\x7a\x07\xed\x99\xb6\x67\x1a\xba\x2c\x2f\xdc\xb3\x67\x8f\xbc\x16\xbf\x6b\x21\xbc\xbb\x91\xe8\xa9\x48\xc4\xaf\xa1\x39\x9c\xf5\xd4\xdb\x4c\x92\x24\x8a\x7a\x1e\x58\xc6\x46\xd3\x26\xc1\x2c\xe9\x91\xb2\x24\x00\xef\xcb\xef\xb0\x5e\x2e\xd1\x2e\x4e\x76\xf9\x92\x26\xf1\xa0\xd2\x24\x8e\xb3\x3e\xb5\x88\x3e\xbd\x57\xbe\xcc\x1f\x45\xae\x07\xab\x4c\xb6\xd2\x07\x91\xf1\x31\x86\x63\xb6\xdf\x77\x7d\x6c\x04\x88\xf3\x85\xe7\x9a\x77\x3c\x42\x97\x5e\x7a\x91\x3e\xb2\x48\xdd\x45\xdd\x0e\xf0\xd8\x08\xee\xa5\x11\x87\x9e\xa6\x28\xa3\x0e\x04\x84\x33\x72\x26\xb3\x8e\x31\x9a\x79\xda\x40\xc0\xa8\xed\xa4\xfb\x48\x46\x8b\xac\x19\x8a\xaf\x18\x42\xd3\xf1\x62\xa1\x23\x64\xa9\x50\x7c\x91\x10\xbc\x28\xbe\x44\x28\xd1\x73\x48\xf4\x57\x3d\x39\x87\xad\xf1\xfa\x3b\xda\x4e\xf8\xae\x92\x2a\x63\x77\x31\xff\x05\xef\xc2\x81\xb7\xa3\x98\x34\x36\x06\x6f\x2c\xe4\xa5\xe1\x51\x9e\xd2\x0f\x07\x27\x14\x9f\x7f\xc7\x55\x2b\x01\xd6\x6e\x63\x41\x75\x54\x64\x72\xf1\x0b\x6c\x90\x0a\x7a\x1a\x4a\x47\x0e\x88\xdf\xbf\x8f\x5d\x40\x12\xf2\x7f\x72\xfe\x8d\x0f\xdf\x7b\xf7\x02\xf3\xdf\xf8\x2a\xe6\xd3\x37\xdf\xff\x40\xeb\xd6\xbb\xf6\x6d\xc5\x34\xa8\xa4\xe6\xc0\x7b\xff\x0f\xfc\xc9\x92\x88\x8b\xd1\x39\x45\xd1\xc6\xeb\x58\x4f\x9a\x91\x1a\x1e\x35\x82\x58\xf1\xc3\xa3\x56\x7c\x51\xa9\x0e\xab\x4c\xc9\x7d\xa9\xf3\x55\x05\x5c\xb2\x98\x19\xc4\xb0\x90\x62\x69\x0c\xc1\x9c\xf7\x2f\xcc\x9c\x6b\xb8\xef\x19\xe4\x47\x56\x0c\x02\x59\x41\x78\x86\xc9\xd8\xb4\x79\x62\x8b\xf9\x84\xfd\x93\x23\x9f\x7f\xff\xc3\x27\xea\xc2\xc2\xed\x6b\x89\x0d\xcb\xba\xf2\x2e\x7b\x90\x1d\x4f\x59\x28\x0f\x95\x41\x45\x23\xe5\x3e\xbb\xd7\xc1\xba\x02\x2e\x81\x09\x88\x06\x83\x49\xd2\x70\x0c\x1f\xca\xb4\xfb\x1c\x5e\x36\xcd\xaa\xe1\x4c\x12\x0b\xb4\xb2\x0e\x8f\x8a\x22\xa5\x4b\x1b\x1e\x15\x04\x75\x75\x9d\xab\x44\xa9\xb3\xc4\x4c\xea\xac\x49\x1d\x34\x40\xb2\x21\x59\x81\xcc\xca\x8a\xea\x9c\x4a\x67\x55\x38\x20\xd9\x04\xa7\x3d\x87\xcf\x29\xaf\x46\x18\x15\x6b\x86\x80\x08\x01\x67\xe1\x55\xd4\x93\x97\xbc\xbb\xe5\xef\x74\xe9\xd8\x59\xaf\xdc\xfc\x43\xcb\xb8\xd8\xeb\x0d\x17\x3e\x5a\x37\x92\x2e\x1b\xf6\x46\xf9\xef\xdf\x3d\xbf\x6c\xea\xc1\xf6\xe1\x72\xda\x2b\x8b\xc7\x1e\x7c\x6c\xd8\x69\x27\xfa\xbc\xcf\xe6\x7d\x5b\xe9\xc1\x2e\xd9\xd7\xfb\xd6\x07\x5a\x31\x3e\xe9\x70\xbe\x6d\xa0\x0f\x3d\x54\x16\x55\x48\xad\x89\x0c\xca\x77\x83\x8e\xd2\xa7\xa5\x51\x79\x41\x51\xcc\x13\xdc\x6c\x51\xb1\x2f\xdb\x99\x5d\x17\xf5\xe4\x83\x55\xf6\x20\xb3\x67\xa8\x67\x8d\x67\xbb\x87\xd5\x33\x9e\x48\x66\x4e\x7f\x0f\xf6\x74\x3c\x1e\xad\xdd\xea\x74\x84\x88\x6b\x63\xd4\xff\x81\x6b\x43\x7c\x1a\x3c\x47\xf4\xc6\xab\xda\x58\x52\x32\xa3\xaa\x3f\xe3\xac\x4a\xd9\xc5\x1a\x90\x2a\xb9\x64\x23\x48\xdc\x81\xd1\x8c\x1e\xd6\x6b\x88\x69\x4b\xed\x97\x27\x86\x0d\x3f\x79\xff\xa1\xc3\xfb\x4e\x0d\x1d\x79\x54\x7e\x8e\xbe\x6b\xe8\xd8\xb1\x23\x0f\x8f\xaf\x97\xdb\xfa\x8f\x62\xe4\x3f\x69\xea\xe8\xde\xa7\x5f\x22\x1e\xcb\xc9\x93\x98\xdf\xe4\x7f\xc9\xff\x78\xf2\x49\xba\xd6\x95\x73\xf1\xc2\x85\x8b\xe8\xb1\x37\x63\x4d\x8f\xdd\x4b\x9c\x14\x9a\x7a\x17\x74\xdc\xaf\xa4\x57\x2c\x8b\xea\x17\xc9\x0a\x18\xed\x36\x0f\x95\x26\x08\x14\x2b\xd9\x8c\x7c\x76\x0e\x23\xb9\xbc\x2e\x6f\x7d\xd4\xe5\xd2\x79\x6c\x66\x5d\x68\x58\x54\xe7\x48\xe6\xbc\xaf\x31\x41\x9c\xec\xcd\x52\xb5\xbe\x52\xcb\x51\x5d\x09\xac\x18\xc6\xe8\x48\x56\x31\x59\xd2\xf1\x49\x6b\xd3\x86\x7b\x2e\x3c\xfb\xdc\x85\xbd\x2b\x9a\xb6\xb6\x4f\x1f\xf7\x6c\xf0\xb3\xb9\x8b\x96\xcc\x9f\x77\x23\xdb\x75\x7d\xbb\x8b\x75\x3c\xd7\xfa\xfc\x85\xbf\x9e\x6d\x7d\xde\xc6\x7a\x4f\xb6\xac\xd9\x84\x84\x58\x6f\x64\xd8\xbc\x7e\xdd\xad\x9b\x48\x2e\x9a\xf6\xb1\x03\xe0\x1c\x0d\x20\x95\x12\x2f\x50\x06\xc1\x60\x34\x51\x82\x96\x8c\x31\x53\xd6\x7d\x8b\x7f\x29\xef\x94\x84\x86\x77\x87\xf0\x6a\x74\x89\x69\xc5\xb2\x76\x1a\x4b\x1d\xed\xc3\x82\x48\x96\x9b\x7f\x8a\x9f\x0b\xfc\x31\x80\xf6\x81\xee\x81\xe7\x52\x46\x5e\x30\x0a\x26\x33\x6f\xd4\xe1\x28\x42\xc5\xbc\xd3\x73\x95\x73\x0a\x2b\x5d\xd4\x28\x82\x05\xf8\x34\x16\x69\xda\xf7\xee\x7b\x17\x3e\x8a\x6f\x4f\xc7\xb4\x3e\x8f\x77\x80\x01\xad\x75\xf1\x9e\x2c\x0a\x89\xc0\x38\x36\xbb\x41\x87\x6d\x30\x0e\xe2\x89\x07\x60\xff\xa3\x9e\xac\x60\x72\xd1\x97\x1b\xc5\x3d\xb9\x35\x6d\xe8\xf5\x63\xff\xf7\x7e\x3b\xb8\x1d\xa6\x59\xcb\x96\xce\x66\xbb\x1e\xbf\xf3\xbe\x36\xda\x24\xaf\x9c\x36\x71\xfc\x14\xfc\xde\x1a\x60\xfc\xef\xe1\xbd\x06\xca\x4e\x0d\x8c\x64\x81\x3b\xc4\xe9\xe0\x65\x12\x67\xd7\xeb\x75\x9c\xce\xe1\x84\x50\x80\x1a\x16\xb5\xd9\x68\x8d\xc6\x34\x2c\xaa\x31\xeb\x69\x12\x26\x75\x5c\xf9\x93\x3a\x92\x47\x71\x31\x71\xa3\x5a\xb6\x84\x97\x7a\x4a\x21\x77\xa2\x2a\x9a\xae\x95\x5f\x38\x8f\x1a\x7e\x7b\xff\x0d\xf4\x44\xdb\x57\xeb\x56\xcc\x59\x15\x43\xe7\xe4\x2a\xf4\x5e\x18\x71\x77\xed\xbc\xf4\x22\x3a\x87\x7e\x1c\xd7\x38\xbe\x51\xb1\xeb\xa9\xb0\x5d\x17\xc9\xd0\xeb\x74\x92\xa0\x85\x1f\xec\x0c\x63\x10\x18\x87\xd3\x00\x00\x69\x0d\x06\x16\xe9\xcc\xac\x6d\x58\xc2\x7b\x54\x03\xb8\xab\x46\xd7\x93\x35\x57\xc0\x75\x22\x4e\xbe\x39\xe3\x20\x31\xdd\xda\xe4\xba\x37\xde\xff\x4d\x3e\x74\x1e\x75\xbb\x1c\x5b\x35\x67\xc5\xba\xaf\xb0\xb7\x76\xe9\xc5\x9d\x77\x21\x2e\x8c\xde\x93\xab\x56\x03\x44\xb8\x0f\x07\xcc\x31\xeb\x22\xfe\x6b\x4e\xc4\x42\xb3\xac\xc0\x71\x1a\x2d\x67\x67\x04\x4a\x48\x2d\x64\x4f\x31\xb4\x56\x75\xfc\x6b\x1b\x33\x55\x3e\xd4\x26\x1f\x02\xf6\xbd\x7c\x03\x73\x12\x6c\xc9\x7e\xe0\xa5\x3e\xd8\xa6\x33\xcb\x88\x5d\xab\xa5\x1a\xd8\x56\xe6\x0c\xc8\x5a\x51\xc4\xa9\xa5\x38\x87\xc3\x68\xa1\xd8\xb4\x74\x0f\xe8\x74\x8f\x45\xab\xd3\x0e\x8f\x82\xb2\xbc\x5a\xa3\x5b\x83\xea\x25\x06\x38\x2e\xe5\xd5\x76\x13\x1d\x17\xaf\x60\x2d\x7d\x74\xce\xb2\x8a\x63\x0f\xc4\x5a\x99\xe1\xa7\xf3\xb9\xc2\x9a\xa1\x0b\x1b\x9f\x7c\x35\x56\x82\x8c\xf9\xe3\xa2\xeb\x76\xb6\xf1\x87\x21\x40\xa7\x99\x9e\xfb\x9b\x8e\x3d\xa4\xc4\x24\x2e\x80\xe1\x29\x02\x83\x0f\xf4\x79\x5d\xa4\x20\xe8\xf5\x66\xf8\xb4\x1e\x02\x8c\xc7\xc7\x85\x32\xfd\x19\xf5\x51\x5f\x5a\x7d\xd4\xef\xf3\xfb\x74\x9e\x3f\x80\x4d\x6d\x9c\x2a\xe8\x3c\x49\x14\xfd\x21\xa8\x88\x38\xcf\xf6\x10\x2a\x41\x5f\x12\x98\xe5\x91\xf4\xd6\x14\x98\x7f\x95\xff\xd5\x0e\xff\xbb\x16\xe4\xa8\xe7\x7e\xba\x48\xf5\x67\x6b\xaf\x44\xd9\x56\xf6\x17\x2a\x0f\xcf\xb4\x64\xb3\xb2\xec\xe9\x94\x56\x1b\x08\xb8\x24\x43\x3a\x57\x90\xef\xca\xa3\xf2\xea\xc1\x26\xc3\x37\xc1\xfa\x68\x40\xd2\x68\x35\xc3\xa3\xda\x0e\x70\x5f\xb5\xc2\x2a\x4e\xe2\xaa\x6b\x80\x9d\x80\xbe\x32\xfe\xf7\x40\xf1\xfb\x57\x3c\xf1\x60\x92\xe0\x8b\xc7\x4c\x9e\x33\x6f\xe2\xb1\xf3\xb1\x12\xfc\x37\x8f\xef\x8d\xb5\xd2\xab\x46\x2d\x5c\x7c\xcb\x71\x15\x83\xae\x3b\xe7\x36\x6f\x4f\x67\xba\xec\xb9\xf1\xc0\x5d\xc7\x46\x2d\x5c\xb6\x5e\xf1\xf7\xfa\x02\x9f\x6d\x24\xfe\x5e\xf4\xea\xfa\x73\xf8\x79\x07\xfc\x5c\x48\x7e\x6e\x24\x78\xff\x09\xf4\xf4\xbf\x48\xaf\x4a\x5d\x7c\x26\x89\xd6\xe9\xb4\x1a\x45\x86\xf3\xa4\xe1\x99\x24\x58\x7e\x29\x09\xcf\x24\x21\x51\x0f\x9f\xb2\xcd\x27\x91\x3d\xbf\xf6\xfe\xae\x14\x07\xbe\xe3\x44\x12\x9e\x1e\xa9\x7a\xed\x4d\x9b\x77\x97\xa2\xaa\xd8\x3f\xe8\x7f\xc9\x07\x0f\x3d\xa5\xf8\xeb\x53\xc7\xcc\x99\xbc\x19\xe5\x6d\xdd\x28\xff\x99\x79\x74\x97\xe2\xa7\x23\xea\xc7\x2b\x5f\x33\x17\xd9\x41\x54\x0e\xb5\x2e\x32\x90\x15\xbd\x3e\xca\xea\xca\xd4\xea\x74\x99\x56\x9f\xc8\xe5\xe6\x51\x39\x20\x45\xb6\x88\xcd\x0a\xa2\xec\x0a\x0e\xb5\x2d\xb0\xad\xb1\x31\x00\x7d\xd0\xec\x5d\xe3\xa5\x75\x8c\xd7\x1b\x0c\xa6\xd5\x45\x83\x22\xa5\x5d\xa8\x85\x9f\xb5\x5a\xa5\x6b\x2f\x11\x8c\x80\x35\x4d\x7e\xc2\x21\x49\xa3\x54\x53\x13\x5f\x8c\x7b\xd5\x88\xf2\xc4\x36\x66\x92\x1b\x50\x8c\x51\x62\xac\x7e\x4e\xa2\x65\x91\x7e\xb6\xdb\x8a\x19\x93\x47\x3c\x58\x79\xd8\x7f\x7e\xd7\xc1\x3f\xef\x6e\xe9\xf4\x23\x3a\x52\x37\x2c\x32\xea\x51\xdb\xb6\x1d\x3b\x37\x2e\x69\xe5\x57\xc5\x7f\xda\x75\x0b\xfc\xa4\xe0\x1d\x20\xfd\x88\x83\xa9\x02\xaa\x32\x92\xe6\xd6\xe7\x06\xed\xb9\x66\x86\x2b\x2c\x82\x8f\x7a\xca\x22\x7a\x05\xbc\x5f\x29\x93\x1c\x88\xa2\x41\x2c\xa9\xeb\x62\x92\x7b\x94\xca\xab\xf0\x75\x78\x7c\x5e\xbc\x0d\xdc\x7c\xa5\xa0\x5b\xc5\xa0\x04\x09\x26\x84\x32\x47\x2f\xed\xd2\x10\x1c\x53\x94\x71\xbd\xbb\xf1\xf6\x01\x5d\x9f\x7f\xba\xfd\x2f\x5d\x07\xdc\xde\xe8\xbe\x3e\xa3\x68\x4c\xb0\xa1\x66\x71\xc3\xe8\x95\x5d\xab\xab\x6b\x9a\x6c\xd5\xb5\x8b\x73\x2a\x32\x42\xeb\x8f\x8d\xdd\xd4\xfb\x8e\xbd\x7b\x76\xf4\xde\x32\xe6\xd8\xfa\x50\x46\x45\xce\xe2\xda\xea\xeb\xc7\x8e\x1c\x39\xa6\x3f\xce\xe9\x8d\x05\xc5\xb0\x0a\x78\x8b\xa3\xbc\x11\x13\x03\x6c\xc3\x0b\x1c\x3d\x0c\xc7\xeb\xaa\x25\x8a\x5f\x4d\x12\x45\xc7\xac\x92\x77\xb4\x11\x25\x47\xd6\x3b\xa4\xf2\x32\x3d\x98\xd0\x02\xcf\x76\x64\x88\x0e\x0d\x45\x24\x8e\xa7\x11\x8f\xf0\x6e\xc2\x61\x51\xc1\x4c\xf3\x71\xcb\x92\xb2\x99\x50\x99\x57\xc6\x32\x6d\x72\x09\x3c\xf8\xd2\x8b\x78\xd6\x70\xfc\xd9\xaa\xcd\xb4\xf0\x5c\x35\x15\xdf\x23\xf3\x67\x22\x07\x3d\x71\x9d\x86\x5b\x0f\xc1\xaa\xc5\x2a\xf0\xbc\xd5\x93\xe6\x42\x7a\x08\xfe\x4c\x7a\xbd\xc5\xc0\x2b\x7b\x0b\xc3\xe1\x0e\xeb\x05\x93\xa9\x34\x5c\x16\x93\x01\x64\x56\xda\xb4\x24\xbc\x10\x89\x7c\xc6\xcb\x4e\x68\xe3\xae\x6f\xd7\x3c\x76\xec\xc0\x93\x0f\x1d\x7b\x6c\xd5\x37\xf7\xa1\xaa\xb9\x67\x96\xa3\x29\xf2\xab\xf7\x3e\x41\xaf\x89\xb5\x3c\xfa\x20\xaa\x90\xef\x6f\x3a\x33\x5b\x26\x3d\x50\xb8\xb7\xd9\x4b\xe6\x78\x17\x45\x5c\x94\x95\x96\xb4\x92\x95\xb1\xdb\x24\xa0\x9f\x64\x16\x20\x44\x13\x1c\x89\x0d\x8a\xa9\x3a\x3d\x78\x8d\x99\x80\xcc\xcc\xab\xfb\x5c\xae\x9e\x04\x78\xe9\x45\x6c\x37\x77\xa0\xaf\xd8\x1a\xb2\xb3\xd1\x48\xf5\x89\x48\x0c\xcb\x73\x1a\x4a\x10\x34\x2c\x63\x32\xe3\xdb\xea\x76\xd4\xff\x64\x14\xac\x29\xab\xe1\xb9\x53\xa8\x10\xd7\xa1\xa3\xe2\xff\x95\xfb\x44\x4a\xea\x53\x8b\x04\xf8\x90\xcd\x3c\x32\x4f\x6e\x58\x70\x07\xda\x74\x1f\x5a\x27\x97\x84\x97\xa3\x51\xcd\x22\x02\x47\x46\xfe\x98\xf9\xec\xb2\x8f\x99\x76\x97\xfc\x2c\xea\x95\x43\xd1\x57\x7e\x03\x38\x9e\x05\x38\x70\x1e\x74\x6b\xc4\xc9\xe1\x01\xc3\x22\x25\x00\xcf\xb3\xac\xc9\x64\xb3\x03\x3b\xd9\xac\x18\x9a\x63\x60\xc6\xe1\x8f\x88\x3f\x6a\xb6\xfa\xad\x25\xd6\x2b\x56\xd6\xac\xf5\x6b\x4b\xb4\x57\xb4\xe0\x5a\x5b\xb5\x56\x30\x88\x16\x0d\xa7\xe9\x65\x40\xfd\xc9\x1d\x60\x21\x81\x18\x82\x3f\xf2\x33\x85\xa1\xbf\x46\x96\x34\x91\x26\xb5\x28\x71\x45\x72\x18\x5c\x87\xe4\xa8\x1d\xb8\x8c\xa1\x9b\xe4\xbb\x6f\xb9\x03\xbd\x45\xff\x4d\x9e\x84\x96\xc9\x5b\xd0\x33\xb1\xa7\xc7\x7c\x18\x47\x6b\x89\x7c\x6e\x91\x7c\x74\x09\xba\x0d\x7d\x21\xa7\x91\xfa\x44\xc0\x98\xf9\x0d\x70\x33\xc2\x09\x7a\xa9\x99\x11\xbb\x5e\x63\xf5\x78\x58\x93\xc6\x41\x51\x40\x68\x9f\x5f\x6f\x75\x5b\xdd\x18\x29\x51\x45\x8a\x01\x4c\xac\x2c\xc7\x59\x7a\xe9\x92\x58\x50\x1e\xf2\x99\x8d\x63\xd0\x21\xab\xd3\x29\x9d\x42\xae\xef\x48\xae\x2e\x18\x50\xba\x73\xe3\x39\x31\x6b\x85\x92\x1a\x63\x7e\x3b\xf5\x88\xdc\x8c\xc6\xa2\x51\x23\x47\x2e\x58\xfc\xc2\xcc\x49\xaf\xbf\xfe\x4a\xf5\x3f\xbf\xfc\x71\xd1\x1c\x86\xdd\xb0\x93\xf9\xec\xe7\xa1\xcd\x2e\x69\x3d\x9a\x3e\xf4\x3a\xf9\x75\xf9\xcb\x23\xf2\xbe\x06\x62\xf7\x8f\xc2\x39\x85\xc9\xfe\x59\x1c\xc7\xcd\x8c\xb8\x74\x82\x33\x8d\xe3\x44\x43\xc0\xe9\x44\xa2\xd5\x20\x1a\x42\x99\x0e\x9d\x84\x24\x8c\x8e\x36\x1a\x10\x10\x12\x69\xd1\xa9\xe2\x21\x02\xec\x34\xe5\x27\x9f\x69\xc0\xa9\xc3\xe0\x8d\x3f\x4c\x43\xc6\x73\x68\x4a\x12\x32\xbe\xa0\x96\x8b\x23\xa2\x22\x76\x74\x3c\x46\xa6\xdf\x9f\xb6\x0c\xc2\x88\x8d\xa7\xdb\xff\x01\xc8\xcc\xae\x22\x88\xb1\x45\x68\xcf\xcf\xb3\xaf\x5b\xd1\x67\xde\x86\x9d\xe8\xfc\x41\x8c\x0d\x6d\xc7\x98\x11\xdf\x11\x8e\x8e\x75\x91\xbd\xeb\x16\x5c\x13\x60\xe6\x74\xa0\xc2\xac\x36\xde\xa4\x42\xcd\x03\xa4\x1c\x65\x56\x4f\xa2\xf8\x1a\x79\x47\x2c\xef\x41\x65\x0d\x6d\x3c\xf3\xe8\x5a\xf2\xfe\x16\x79\x37\xea\xfe\x2b\xd2\x6e\x3b\x7b\xe2\xc8\x2b\x0f\xb6\x33\x5f\xec\xfe\xc7\x4a\xe6\xb3\xd8\x57\x27\xce\xc6\xe8\xb7\x40\xe6\xaf\x00\x5f\xfc\x1b\xde\xab\xa7\xc6\x46\x8c\x9c\x56\x2b\x30\xa0\x96\x74\x06\x23\xbe\x2f\xed\x1f\xb1\x44\xcd\x9c\x9f\x2b\xe1\xae\x70\xc0\xd7\x64\x17\x0c\xab\xc2\x83\x88\x1c\x6a\x3b\xf2\xf3\x55\x39\x3e\x7c\x49\xa8\x72\x70\x82\x7b\xa9\x2b\xf4\x07\xb1\xe3\x74\x56\xec\x22\x3d\x0b\x5e\x1e\xe7\x55\x80\xe5\x3d\xf8\xf1\x35\x02\x4b\x63\xc4\xa4\x61\x29\x3d\x0f\x51\x04\xa5\x07\x60\xd8\x6b\x01\xa3\xd5\x6a\x54\x60\xb4\x04\x18\xf4\xff\x07\x98\xc4\xc5\x99\xb5\x92\x4c\xa7\x27\xff\xbe\x47\xcf\x02\x40\xb2\x00\xa0\x0f\xd0\x57\x4b\x50\xfd\x22\x54\xb5\xe4\xb2\x4f\xb1\x83\xf7\xa1\x0f\xd9\x52\xee\x22\xc8\x4b\x5d\xc4\x6c\xa4\x04\xde\xea\x72\x81\xce\x67\x7d\x7e\x87\x1d\x00\x3a\x11\x75\x38\xd2\x98\x34\xf1\x0c\x79\x6f\x1a\x2a\x01\xd6\x04\x78\x8e\x47\x05\x81\x69\x47\x45\x64\x09\x07\x75\x8d\x1d\x2b\xca\x65\xbf\xe5\xaa\xc5\x1b\x95\x18\x1e\xac\x46\xa9\xfb\x2e\x7d\xb1\xff\x95\x8a\x0d\x79\xad\xb3\xf7\x1e\x39\xb1\xb7\x61\x4f\xa5\xfc\x19\x7a\xb0\xff\xa7\x37\x7f\x21\x5f\x61\x3e\xf9\x09\x69\x17\x37\xe7\x8d\x18\xfa\xea\xa9\xa7\xdf\xaf\x0e\x3f\xbe\x5c\x3e\x38\x64\x1c\xb2\x62\x78\x3f\x02\xfa\xfd\x40\xe8\xd7\x27\x62\x8a\xef\xa8\x62\x81\x7e\x02\x56\x5a\x11\x63\xb4\x44\xa8\x15\x86\x0a\x0c\xde\xcc\xd4\x49\x91\x92\xa9\xa5\x9d\x87\x69\xa5\x0c\x04\x65\x26\xc9\xda\xd6\x56\xf4\xeb\x76\xd0\x30\x10\x00\x31\x9f\xc9\xe3\xd1\x3e\x95\x4e\xb4\x1f\x7d\x45\x3f\x06\xef\xc5\x75\x1a\x98\x45\x38\xfa\x19\x78\x38\xc2\x8f\x4e\xd6\x69\xc0\x93\xe8\xc7\xb6\x6d\xc3\x27\x8e\x8f\xca\x82\x3e\x64\x46\xc3\xef\x88\x54\x35\xae\x41\x8a\xe7\x23\x15\x5a\x1a\x08\x6c\x3c\xa6\x25\x83\xeb\x92\x4a\xae\x95\x9a\x44\x19\x9d\x52\x93\x74\x97\xff\x94\x6e\x31\xd6\xf7\xec\x3d\xe4\x24\xea\x73\x37\xfa\x10\x69\x5d\x23\xc6\x4c\x9e\x48\x5f\xbf\x24\xd6\xff\xb6\x43\x40\x9f\xef\x41\xc6\xdc\x84\x3e\xd7\x45\x3c\x98\x3e\x3a\xb0\xe5\x94\x5e\xaf\x45\x2c\x6b\x30\x42\x18\x29\x20\x81\xd5\x5c\x45\x99\xab\x8b\x22\x95\x80\x91\xcc\x6a\x97\xb0\x99\x61\xe6\xca\xb7\x2c\x03\xf2\x3c\x7f\x40\x9e\x81\xde\x00\x12\x7d\xd0\x28\xaf\x07\x1a\x79\xd0\x97\x72\x5d\xec\x75\x8c\x6f\x6f\x40\xfc\x18\xbc\x9b\xa3\xb2\x4f\xe0\xa0\x95\x17\xd0\x19\xf2\x1e\xa6\x23\xd7\x26\x1d\x14\x4c\x79\x3b\xea\xdd\x8a\x3e\xc3\x34\xbb\x7c\xc7\x12\xc2\x93\xb7\x03\x0e\xdd\xe1\x39\x1e\xaa\x77\xc4\x65\x31\x99\xcd\xa2\x56\x63\x77\xb1\x14\xe5\xf1\xd8\x45\x26\x2d\x9d\x35\xba\x8c\xa0\xf7\x0a\xdb\x28\xad\x9d\x11\xdb\xf1\x63\x9d\x7f\x9c\xe2\x44\x52\x45\x2d\x52\xa6\x78\x82\x3b\xe6\x24\xc3\xe7\x1d\xce\x5a\x04\xaa\x8e\xf9\x93\x96\xe6\xbd\x96\x5f\xa7\x5e\x32\x89\x12\xb3\xe6\x29\xea\x8a\x36\x5d\xeb\xbb\xf4\x04\x9c\xf5\xae\x51\x8d\x1e\xcf\x8a\xe2\xd8\x38\xfa\x40\xb0\x4b\x97\x07\x62\xb3\x40\xa1\xd4\xbb\x66\x07\x27\xd1\x47\x81\x25\x92\x7c\x68\x00\xff\x51\xe2\x11\x10\x1a\xef\x70\x05\x4e\x34\x9a\xf4\x88\x03\xe0\x8e\x09\xb8\xf3\x0e\x40\x2b\x2f\xbf\x56\xe2\x53\xab\x42\x42\xb6\x18\x30\x03\x64\x23\xb7\xe6\x41\xf4\x5f\xbe\x05\x1e\x5b\xb5\x2f\x36\x17\x88\xf1\xc2\x88\x71\xf4\xd6\x0e\xef\x32\xe2\x77\x19\x39\x9a\x46\x06\x1e\x14\x03\xd2\x98\xcc\x06\xc4\xe3\x77\x69\xb8\xff\xf5\x2e\xab\xa4\xae\xa5\x27\x2b\xe9\x3f\x5a\xcb\xa3\xff\xee\x5d\xcb\xc9\x26\x4c\xf3\xd8\x52\xd3\x3e\xa6\xdb\x65\x1f\x7d\xe7\x98\xfe\x97\xcf\x29\x31\xfe\x46\xd0\x09\x7d\x41\x27\xe0\x9a\x74\xd0\xd3\x16\xde\x40\xa6\xec\x69\xcd\x09\x55\x54\x04\x72\x60\x27\x9f\x19\xcc\xb8\x57\xeb\x69\x9c\x5c\x21\x6b\xa4\xa8\xd4\xb6\x20\xb6\xef\x95\x4f\x3f\xbe\x22\x7f\xf6\x31\x75\xe5\xb6\xe3\xf7\xee\x39\x76\xec\xfe\xbd\x8f\x33\x9f\x7c\x27\x7f\x85\x2c\x3f\x7d\x8f\x0c\xf2\xcf\xdf\x3d\xf3\x1a\x16\xf9\x0b\x4a\x2f\x83\x15\x9d\x63\x9e\xe1\xf6\x82\xef\x98\x05\xd1\xa3\xd3\x2b\x3a\x1d\x0c\x1b\x02\x1f\x49\xb0\x3a\x44\x3e\x3b\xc7\x2a\x00\x8b\x78\xda\xd1\x0d\xb8\xb6\x20\xc0\x1a\x03\xf0\xf1\x38\xc4\x1e\x2c\x55\xd2\xb1\x47\xfc\xaa\x8c\x17\x4e\x00\xc5\xb7\xbd\xaa\x71\x86\x92\xf3\x72\xa6\x26\x80\x67\x0c\x9f\xdc\x32\xfc\xfa\x51\x93\x1e\x7e\xfc\xb1\x87\x26\x8e\xee\x5f\xbf\x76\x7c\x74\xca\xe2\x69\x37\xde\x38\x65\x11\xfb\xe4\xda\x85\x73\xf7\xa5\xa5\x3d\xd2\x74\xba\xed\xa9\x3f\x35\x1f\xf2\x3a\xef\x5f\xb4\x6c\xe5\x94\x3b\x57\xec\xb8\x79\xd3\x6d\x2b\xee\x04\xd8\x19\x20\xee\x8f\x70\x66\x3a\x4a\x02\xcf\xd7\x60\xe6\x38\x5e\x0f\x54\xb4\x58\xcd\x2c\x51\xab\x66\x33\x2f\x08\xa6\xd3\x84\x86\x02\x08\x09\x4f\x34\xc9\x35\xb3\x48\xea\x5e\x7b\x9c\x4a\x12\xb0\x2d\x0e\x96\x33\x3f\xb6\xed\x96\xbf\x6d\x45\x77\x3f\xfc\x44\xeb\xdf\x2e\x21\xf4\x16\xbb\xa7\xf5\xa0\xbc\x86\xf9\x6c\x6f\xeb\x9f\xe4\x16\x72\x86\xef\x83\x0c\x79\x55\x5f\x68\x44\xc4\x6e\x40\x48\x6b\x01\x26\xa5\x8c\x46\x93\x96\xd5\x3a\x9c\x06\xda\x42\x13\x40\x2c\x78\x9d\x84\x74\x26\xe1\xfe\x24\xb4\xc2\xd5\xd9\xa4\x94\xdb\x6d\xe2\x7f\x4a\xf1\xf4\x96\x00\x5e\x8f\x72\x57\xc9\xac\xfa\x55\xfe\xa4\x15\xbd\xf4\xf0\x13\xcd\x73\x91\xf9\xc4\x3b\xf2\x5b\x28\x3c\x61\x21\x68\x8b\xdd\xf2\x74\xe6\xb3\xbb\x6f\x99\xb7\xcb\x2e\x8f\xa4\x9f\x7f\x4c\xde\x3d\x41\xb1\x3f\x00\x27\xf3\x0b\xf1\x8b\x8b\x22\x06\x70\x62\x58\x9a\x06\x7d\xc5\x72\xec\xe9\x04\x44\xb4\x4a\x1a\x2a\xb5\x4a\x1e\xc5\xb7\x23\x1d\xb9\x55\x6e\x67\xd2\xb9\x86\xcb\x77\x30\xf3\x97\x28\xfa\xe3\x3d\xd0\xbb\xff\x81\x67\x4a\xb8\xee\xd5\x68\xe2\x58\x13\x6b\xb5\x18\xd9\x33\x1d\xcc\x79\xc9\x35\xea\x5e\x53\x76\x8a\x28\xc3\x15\xe8\x49\x27\xde\x6e\x6d\x59\xb5\x76\x53\xeb\xfb\xe8\xc3\x57\x1e\xa7\x57\xc4\x76\xdc\xbc\xf5\xf6\x4d\xf4\xd4\xd8\x5d\x6d\x6f\xe2\x77\x5d\xf9\x1a\xe8\xfc\x19\xbc\xcb\x41\xdd\x10\xf1\xea\xb4\x46\x49\xe4\x10\x65\xb3\x71\x46\x46\x6f\x77\x38\x5c\x06\xbd\xde\x69\x33\x72\xa2\x9d\xd1\x63\x39\x35\x22\x1d\x91\xd3\x70\xb8\x16\x37\x5e\x25\x0b\x06\x92\x53\x7c\x95\x49\x1f\x38\x70\xc4\x2a\x0b\x85\xad\x58\x53\x59\x1d\x4e\x6b\x98\xb9\x78\xe0\xa0\xc1\x64\x86\x87\x1d\x3c\x20\xff\x76\xe7\x39\x97\xf7\xe1\x5b\x0e\x5a\x32\x5f\x86\xd0\x82\x5e\x56\x58\x3f\xc2\x3b\xa5\x3e\xb6\x05\x14\xc7\x93\x37\x2e\x05\x83\xbf\xab\xcf\x83\xcc\x60\x45\x8e\x6c\x40\x8f\x4f\xd8\x9f\x49\x2f\xd8\xdc\x88\x54\x04\x21\x47\x40\x93\x9b\x6b\xb7\x9b\x19\xa6\xb4\x8c\xcf\x07\xb1\x89\x58\xa3\x3c\x4f\x49\x66\x93\xdf\x54\x62\x62\xcc\x8c\xc9\x24\x49\xfa\x53\xe8\x06\x52\x35\x56\x76\xdc\x95\x49\x65\x12\xe1\x0a\x78\xe3\x8a\x26\x75\xe7\xb0\x1a\xda\x77\x5a\xb1\xa6\x10\xb4\x02\x02\xe4\xc4\x10\x1b\xcc\x2e\x84\xbe\xd5\x76\xd2\xea\x1c\x32\xa1\x1c\x52\xfb\x27\x90\xe5\xfb\xe8\xe7\x85\x0b\x76\x1f\x78\x68\xf0\xb0\x61\x83\x84\xb5\x01\x24\x6c\x69\x4d\xcf\xb5\x3a\xc2\x85\xfd\xba\x71\x6c\x49\x53\xe4\xba\x59\x3d\x6e\x59\x3d\xb9\x17\xfa\xb0\x69\xf6\x8a\x9b\x18\x26\x7f\xc2\x90\xae\xb5\x86\xd7\x37\xac\x96\xdb\x6b\x6a\xb8\xa1\xfa\x41\x83\x47\x0d\x98\x10\x99\xd7\xbd\x27\xcd\x0c\x1d\x56\xdb\x5b\xd1\x65\xdf\x00\xee\xed\x2a\xee\x93\x23\x52\x5e\x40\xa3\xb1\x99\xcc\x45\x0c\x63\xb6\x01\xee\x79\x02\xc6\x5d\x17\xcd\xcb\xa3\xa4\x0e\x28\x17\xc7\x51\x6e\x03\x94\x31\xce\x65\xd8\x3c\x97\x5f\x63\xd1\x72\x6a\x46\x13\x6b\x16\x25\x09\x10\x2f\x71\xe0\x71\x72\x53\x4a\xd4\x33\x3b\x9c\xe1\x9e\xc8\xa9\x16\x3a\x90\x2b\x9e\xbf\xa9\x18\x0f\x19\xa4\x5b\x1b\x90\x7f\x4b\xc5\x38\x7f\x75\xaf\x3e\xb3\xba\x61\x8c\xd9\x9f\x13\x18\x57\xf6\xc1\x18\xa3\xfe\x2a\xc6\xc3\x07\x4f\xe8\x35\xbf\x6b\x02\x63\x1a\x15\x01\xbe\x7b\xd8\x9f\x80\x1f\x33\xa8\x01\x11\x83\x13\xb4\x8e\xd7\x2b\xf1\x52\x28\xd3\x76\x1a\x0e\xce\x84\x4a\x29\x0d\x15\x40\x37\x1c\x8b\xea\x35\xa7\x00\x2b\x06\xa2\x1d\xf8\x81\x62\x88\x07\x42\xf6\x1d\x92\xff\xab\xed\x34\x77\x44\xc9\xc7\x90\x3d\x71\xe1\x8a\xea\xb0\x20\xd9\x9c\xa1\xec\x4a\x94\xd2\x00\xc9\x04\x43\x0b\x46\xdc\xba\x0e\x99\x46\x2c\x0c\x21\x61\x29\xcb\x2e\xe5\xe5\xcd\xc3\x1a\x67\x8e\x1f\x3f\x63\xdc\x70\x7a\xda\x80\xda\x3f\xbf\x88\xb6\xf5\xea\x1b\xee\xb7\x49\xce\x9f\xd6\x25\x7f\x18\x62\xf6\x6e\xde\x79\xff\xae\x5b\x6f\x25\xf1\x4e\x29\xd8\x9c\xfb\xe0\x9c\x72\xa9\x0a\xaa\x1b\x75\x5f\x24\xbd\x32\x57\xd0\xe4\x41\xac\x43\x75\xf3\xf9\x8b\xac\x56\xbf\x31\xd4\x4d\x93\x2b\x74\xef\x91\xd6\x25\xab\x4b\x3b\x06\x39\xcf\x49\xfe\xc8\xad\xc4\x47\xe8\x8c\xe6\xe6\xfa\xf3\x4a\xf2\x6a\xf3\x98\xbc\x3c\x7d\x30\x8b\xf2\x21\x13\xe3\xf3\x65\x01\x56\xc7\x4b\x59\x3d\x8b\xff\x1b\x53\x54\x34\xea\x17\xa8\x6b\xe4\x04\x3d\x39\xd3\xab\x4a\x5b\x24\xe2\x26\x5e\xab\xac\x25\x69\x3d\x2a\x95\xcd\x1a\x24\x1f\xe5\x8c\x27\xa5\x3a\x9c\xb9\x7a\x25\x54\xad\xd6\xb2\x03\x73\x2b\x13\xf1\xab\xe9\x6a\x7a\xc6\xf8\xba\x89\xd2\x9c\xac\xbb\x17\xfc\xed\xfa\xea\x6d\x53\x16\x2d\xba\xef\xd1\xfd\x83\xea\xeb\x87\xea\x5a\x02\xf2\x4f\x8f\xf6\x1e\xb6\x5b\x3e\x45\xaf\xbb\x79\xed\x8c\x3e\xb5\xfd\x66\xd7\xc4\x2e\xeb\x27\x35\x8e\x9a\xc2\x31\xeb\x0c\xeb\x36\x5c\x17\x0e\x4c\x18\xf9\xd4\x94\xfa\x04\x2f\x54\xf5\x36\xbc\x3e\x79\x32\xba\x4b\xb2\xd3\x4c\xfd\x90\x1e\x7d\x7b\xcd\xed\xbe\xa5\x69\x7e\xd3\xfc\x04\x1f\xf0\x14\xe5\xa2\x32\xa9\xeb\x23\x46\x3f\x27\x8a\x66\x37\x44\xfd\x59\xd9\x8e\x74\x42\x37\x8b\xe3\x2c\x10\xc0\x8c\xca\xc1\x13\xc5\xc1\x62\x06\xfe\x92\xa3\x93\x6c\x50\x9b\x5a\xe8\xa6\x30\xb7\x18\xc4\x32\x6b\x33\xd1\xf6\x10\x51\x90\x42\x98\x60\xdf\xa1\xf3\x77\x8f\xfc\xd3\x88\x05\x21\xbc\x8d\x6c\x19\xbb\x92\x61\x08\x4f\xac\x8d\xb3\x01\x33\x47\xbe\xb1\xb6\xaf\x25\x27\xc3\xc5\x74\x99\xc6\x34\xc9\xef\xce\x05\xb6\x38\x77\x7f\xeb\x8e\x3d\xbb\xb6\xdd\x4a\xa5\xc2\x9d\xe0\x5f\x2f\x05\xfe\x1f\x2f\xaa\xfc\x8b\xe1\xfd\xff\xcc\xbf\x95\x64\x8e\xdb\x1f\xf3\x2f\x80\x8f\x56\x5e\x8b\x7d\xb7\x47\xfa\x82\xe3\xd8\xfd\xf2\xc6\x14\xfe\x6d\x55\xe0\xf6\x03\xdc\x8f\x01\xff\x5a\xc9\xc6\x64\xd1\x43\xe1\xbb\x28\x9b\xd5\x2a\x18\x19\x7c\x61\x80\xf9\xcf\x10\xf5\x44\xb4\x86\xfe\x1e\x8f\x4e\x14\x9d\x8a\xa2\x11\x51\x59\x1b\xcf\xeb\x74\x8c\xf2\xa3\x8e\x58\xa5\x94\x69\x67\xae\x8e\x29\xfb\xd4\xb5\x2f\xf1\x04\x69\xea\xaa\x97\x07\x67\x4d\xc5\xbc\xe5\xbf\xef\xc6\x03\x87\x0f\x3f\x88\xfa\xdc\x04\xdc\x13\x9d\xc1\x31\x83\x37\x6c\x03\xe6\x19\x1b\x7d\xf9\xe5\xd3\xe7\xe4\x39\xd2\x24\xc2\x24\x49\x98\xf1\x74\xe2\x05\x11\xd1\x6a\xe1\x05\xca\xed\x36\x18\x04\x0b\x5e\x05\x6e\xc5\x30\x8b\x51\xb3\xc5\x6f\x29\xb1\x80\x49\xb0\x58\xcc\x5a\xb3\x43\x01\xd4\x8c\x4a\x22\x26\x33\xef\xe7\x4b\x78\xf8\x1b\x1e\xbc\x51\x15\x03\x2d\x16\xaa\xd4\xcc\x6f\x6a\x7c\xda\x01\x8d\xb8\x49\x50\xdb\xd0\x40\x5c\xd4\xc4\x29\x53\xa8\x60\x11\xf9\x06\x23\x21\xff\x29\x8e\xc4\x3a\x82\x44\x1b\xc6\x01\x58\x5e\xc1\x01\xa1\x7a\xc0\xa1\x19\x70\xc8\xa0\x16\x47\x1c\x1e\xc6\xae\x13\xcd\xfe\x40\xc0\xec\xe4\x75\xf8\x9a\x9b\x77\xba\x9c\x2e\x85\xf6\x4e\x4c\x7b\xa7\x13\x1c\x20\x0b\xb1\x64\xa2\x68\x04\x0d\x10\xd1\x51\x7e\x64\x66\xfc\x7e\x8a\xf2\x2a\x18\x50\xc9\x33\xc0\x18\x24\x1d\xc9\x6b\x4e\x9d\x4b\x5e\x98\xe2\x04\x70\x7c\x85\x68\xd8\x9e\x91\x48\x63\xd3\xd3\x5a\xee\x98\x3e\xb2\xff\xc4\xd6\x85\x9f\xfb\xe6\x4b\x2d\xb5\xbd\xdf\xfe\x64\x70\x64\x73\xe6\x5c\xdf\xcd\xe8\xc3\x95\xb3\x07\xce\xd0\xd2\xc2\xc4\x7e\x63\x16\x9c\x30\x4d\xeb\x5e\xb1\x72\x62\x6b\xa4\xf7\x12\xff\xd8\x06\xa5\x76\x33\x8e\x5b\x88\x9a\x1f\x71\xb0\x8c\xcd\x6e\xf2\x68\x83\x41\x8f\x0f\xaf\xfd\xcd\xcc\xf2\xe2\x5a\x20\x8c\x9b\x39\x8a\xf7\x08\xf5\x37\x18\x28\xa7\xcd\xe6\x74\x82\x2f\x77\x03\xa9\xad\x2d\x23\xf1\x25\x38\xc7\x13\x59\x08\xfe\xe2\x21\x66\xca\xca\x4c\x62\xc1\xfe\x00\xad\xf8\x0d\x43\xa8\xb2\xbc\xb2\xe3\x51\xc5\x2b\x84\x66\x2e\xbe\xd9\x37\x37\x73\x73\x64\xf0\x27\x6f\xf7\xae\x8d\x0c\x14\xe6\xfb\x3e\xbf\xf1\xd6\xc9\xfd\x46\x4e\xdf\x81\x3e\x6c\x18\xeb\x5f\xd2\x3b\xd2\x3a\x71\x65\x45\xf7\xca\x52\xd3\x89\x05\x63\xae\x9f\x20\xd0\xda\x99\x03\x66\xaf\x24\x32\x4e\x9d\x01\x1b\xf5\x23\xe5\xa7\x0a\xa8\xe9\x11\x31\xdb\xcc\x32\x01\xbb\x46\xe3\xf5\x02\x2f\x15\x16\xb9\x4f\x81\x8d\xb2\x50\x21\x2c\xd6\x76\x0b\x96\x71\x03\x95\x87\x7f\xd0\x1a\x4e\x91\x04\x23\xe0\x14\xd1\x02\x52\x0b\x59\x9a\xa0\x55\x91\x40\x2b\x29\xfe\x9d\x3d\x91\x2c\x15\xa3\x1e\x28\x94\x9c\x58\x00\x96\xac\xaa\x3a\x6c\x46\xe0\xe8\x59\x53\x87\x72\x4c\xbf\x69\x8b\xb5\xd9\xb3\xa5\x9d\xbe\xfe\xe1\x5b\x57\x6e\xd9\x32\x64\x71\x80\x16\xe8\x45\x88\xd9\xe5\x9b\xd3\x30\x7e\x54\xfd\xc4\xe8\xdc\x33\x33\x47\x5a\xe6\xff\x5f\xf3\x9d\xcf\x9f\x7d\xf5\xec\x80\xbe\x99\xe3\x18\xfb\xe6\xd8\xd3\x7b\xf7\xd2\x8f\xdc\xba\xe7\xd6\x3d\x7b\x6e\x21\xf5\x84\x34\x9d\x4f\xbd\x41\xef\x67\xbf\x50\x6b\x68\xb5\x1c\x42\x3c\xf6\x6e\x05\x8c\x20\x8d\x83\xe2\x63\x63\x69\x9e\xb8\x53\x2f\xc6\xc3\xe2\xb8\xba\xb2\x87\x2a\xf1\xc2\x09\x7a\x7f\x53\x53\x13\xea\xdf\xd4\xc4\xdc\x1f\xe3\xe8\x4b\xc0\x13\x5d\xc0\x5f\xbe\x0b\xf4\xa3\x9e\xea\x15\x71\x42\x7c\x8f\xc3\x7b\x2d\x85\x58\x92\x03\xd1\x09\x08\x48\xa2\x39\x0d\xcf\xe7\x50\x79\xd2\x95\xaf\x4d\x2c\x54\xb4\xd4\x28\x14\x51\x32\x56\x4c\x4a\x78\xcf\xfd\x36\x66\xe5\x4a\xd4\xfb\x36\xf9\x1d\xd4\x0d\xfc\xf5\x71\x83\xe5\x1f\x59\x47\x6c\x31\x5a\x24\xb7\xcb\x83\x15\x5f\xfd\x26\xf0\x75\x87\x00\x3f\x66\x81\x45\xb1\x9b\x34\x1a\x6d\x16\xe5\x4d\x4f\xa7\xb4\x4c\x76\x8e\xdd\xe4\x32\x41\x24\x71\x9a\xb0\x9e\x05\xce\x4c\x8f\x4a\x8f\x79\x29\x6d\xdc\xdb\xad\x55\x72\x8e\x9d\xaf\xb2\x90\xa4\xd0\x1d\xc0\xc8\x09\x3b\xed\x8a\x39\x71\x86\xab\xe2\xcb\xe2\x94\xbf\xa4\x0b\xba\x0c\x19\x32\x6e\x25\xb3\x98\xa3\xb3\xa7\x0d\x1a\x31\xc9\x46\xf7\xbe\x6f\xe1\xb4\xa6\x2e\x43\x87\x8c\x05\x48\xff\x3e\xa7\x61\xe5\x62\xb9\x1f\xdd\xb0\x7f\x62\x68\x48\xef\x7e\x03\x6f\x5f\xb3\x4d\x66\xf1\xb7\xcb\x97\xc9\xfd\x88\x1c\xd5\x02\xbf\x6d\x03\xb8\x7d\xe0\xa3\x8b\x4e\x49\xb2\x68\x81\x32\x16\xc6\x1f\x70\xa6\xa5\x19\x7b\x99\x08\xcc\x69\x00\xb3\x0d\x33\x1e\x31\x86\x82\x9a\x39\xad\x50\x73\xd8\xb5\x9d\x9c\x01\xac\x86\xe3\x13\xb9\xae\x85\x82\x9d\xd9\x76\x36\x2f\x3f\xad\xa8\xee\xba\xd1\xa3\x67\x34\x63\xc0\x0b\xe7\x0d\x6f\x9e\x8f\xb6\xbf\xa9\x5b\xa2\x9f\x49\x57\xce\x1d\x9d\x00\xb9\xae\xd7\x9a\x6d\xf0\x26\x1f\xc8\xfa\xe3\x00\xa3\x16\xe2\x35\x88\xb9\x45\x92\x1b\x75\x38\x05\xdc\x21\x76\x03\x89\x11\xcb\x00\x2e\x2b\xf9\x4c\x5f\x33\xe6\x16\x83\xaa\x81\xeb\x60\x8e\x1f\x97\xdb\x76\x3f\x8a\x06\x1c\xb9\x77\xed\xd8\xd9\x73\x27\x8e\x9f\x3e\x7f\x02\x33\x53\x5e\xf2\xfc\x2b\x68\xeb\x0b\x2f\xe2\x49\xf6\x3b\xef\xde\x41\x68\xd4\x15\xde\xbf\x03\xde\xef\xa4\x7a\x47\x8c\x1c\xcf\x5b\x2d\x94\xc1\x62\x70\xb9\xcd\x0e\xa2\x2d\xad\x56\x33\xe8\x8f\x36\x8e\xbb\x96\xa6\x57\x94\x64\x07\x73\xdb\xf1\xc2\x2e\xb1\xa4\x88\xb1\x8e\x9e\xbc\xc9\x71\x93\x7d\xe7\x82\x7b\xf6\xed\xdf\xbd\xf4\x1e\x53\xb3\xbe\xe1\xba\xa7\x99\x39\xf7\x6f\xda\xaa\x9b\xbf\xec\xd5\xb3\xcf\x9d\x5f\x3f\x5f\x33\xe8\x06\xbc\x8f\x9b\x99\x49\xe8\x61\xa0\x0a\x22\xc6\x0e\xf5\x22\xa9\xaf\xff\x1f\x45\x23\x70\x06\x25\x18\xe5\xb5\x18\x79\x66\x26\xc6\x15\xe3\x8c\x71\x25\xb4\x66\x66\xc2\xb3\x4b\x22\x66\x9e\x33\x00\xa5\xe1\xd9\x94\x81\xa3\x69\xed\xa9\x0e\x14\x86\xa7\xa7\x34\x8a\xc6\x89\x1c\x56\xbc\x06\x85\xb6\x6b\x93\x34\x05\x5a\xde\x9b\xd4\x6f\x3f\x11\xdf\x0b\xdc\x4e\xbf\x85\x03\x59\x71\xc3\xd1\x76\x72\xbe\x0c\xc0\x6f\x5a\xe0\x31\xd5\xf9\x62\xff\x87\xf3\xa5\xbe\x3b\x27\x44\xe4\xa2\x04\x85\x6d\x3e\xda\x7e\x6d\xef\xeb\x91\xee\x2c\xb3\x92\x41\xcb\x18\x70\xc1\x32\xe6\x8e\xda\x7c\xf3\xda\x11\x63\xe6\x8c\x8d\x7b\x5f\x1b\xf8\xeb\xe5\x47\x99\xad\x1b\xed\xb4\x3b\x33\xdf\x72\x43\xed\xd9\xf3\xfb\x6e\xd9\x75\xef\xae\xd6\xed\x40\x97\x36\xf4\x31\xe3\xe2\xb6\x93\x1d\xa1\x46\xbd\xc9\xa4\xe1\x28\xce\x61\x37\xf1\x02\x4f\x78\x40\xaf\x15\xce\x10\xcd\x65\xe9\xc8\x85\x2f\x86\x3b\xe6\x08\x00\x54\x38\x71\x9c\xb1\x0c\x57\x87\xed\xb8\x8c\x80\xd8\x42\xc6\xd5\xad\xd7\x8e\x91\x63\x32\xeb\x37\x6d\xca\x28\xf0\x14\xa1\x1f\xa4\x23\x28\xd6\x78\xf8\x70\xa3\xec\xaf\x2e\xd4\x12\x39\x85\x73\xd9\x06\xfa\xd2\x4e\x75\x8d\x18\x28\xbb\x11\xa8\x66\xd7\x3a\x9c\x1a\x7b\x3b\x2a\x3d\x6e\x94\x24\x55\xbd\x48\xf0\x62\x43\x22\x27\xd0\xa1\x63\x31\x9c\xd8\x2a\x84\xdd\x53\x67\x08\x07\x98\xca\x52\xa1\xa7\xb1\x24\xae\x64\x97\xb0\x74\xfe\xfc\x11\xcd\xf3\xd9\x2f\xe4\xf4\xf9\x23\x57\x2e\x46\xcf\xc4\x0e\xed\x5f\x37\xa8\xcf\x9a\x6d\xe8\x32\xd1\x71\xdf\xd0\x4e\xe6\x53\x76\x3a\xc0\x10\x8e\x18\x35\x14\x0b\x31\xa1\x91\x62\x1d\x4e\x3b\x18\x9a\xfe\x4f\x45\x01\x28\x2d\xbe\x35\x78\xb2\x43\x95\x42\x6a\xe5\x47\xbc\x2c\xa1\xda\x9e\x28\x46\xf8\x06\x5d\xc0\xef\x92\xc7\xd0\x7d\xf6\xaf\x1b\xdc\x1b\xf4\x93\x8b\xbe\xbd\x23\x3c\xaa\x7e\xfd\x08\xf4\xeb\x97\x54\x36\x35\x28\x62\xf5\x79\xed\x14\x95\x8d\xb5\xac\x36\xdb\xcb\xe4\xe4\x66\x6b\xbc\x98\x0c\x6c\x86\x3b\x83\x84\xa5\x76\x8b\xc9\xfd\x4c\x82\x12\xe1\x64\x11\x5b\x8a\x9a\x52\x33\x35\xa9\x14\x29\x41\x0a\x49\x12\x94\x49\xe4\x3b\xe8\xbd\xaa\x96\x65\x11\x5d\x30\x79\x00\x56\xb3\x81\x99\xa3\x6f\x9c\x4a\xf4\x2c\xfb\xa5\x9c\x8e\xf5\x2c\xa1\xd7\xc4\xd0\xf0\x9e\xfd\x06\xf6\x1e\x82\x89\x86\xbf\x5e\xbe\x0c\xe1\x1d\xe6\xc8\x0c\xb6\xe9\x0c\x9c\x9f\x16\xac\x9d\x99\xa1\x11\xc5\x01\xf0\x1c\xcd\xe8\xf4\x1a\x1a\xdb\x3c\x4e\xc9\x97\x87\x6b\x3b\x5f\x65\xe2\x34\x07\x04\x52\xd6\x30\xfd\xe8\xed\xf2\xbf\xd7\xed\x2b\x35\xd9\x4e\xae\x43\x5f\xd1\x97\x64\xf3\xc1\x8a\xde\x74\x10\x68\xf3\x21\xfa\x88\xf9\x11\xf4\x41\x0e\xf0\xa6\x64\x71\x68\x0d\x2c\xe3\x65\x72\xf3\xbc\x5a\x47\xa6\x83\x02\xdd\x54\x76\xdc\xcd\xe3\xf9\x77\x20\x47\x01\xd5\xd5\x49\xb9\xb7\x47\x25\xea\x7d\x63\xd2\xb7\xa9\x45\x39\xd9\xa9\xb7\xf6\x49\xaf\xba\x18\xe5\x98\x68\xd4\x1a\x1e\x5e\xd0\xbd\xa2\x67\x75\xa0\xef\xcc\xe8\xda\x75\x2d\x6b\xb3\x2a\x26\x47\x32\x2a\xfc\x3d\x9c\xdd\x0a\xea\xc3\x39\xdd\x2a\xfa\xdc\x50\x5e\x8d\x3e\x0a\x95\xd7\xf7\xca\x1b\xbd\x76\xfe\xd4\x19\xcb\x97\x4f\x2f\x9a\xd4\xb7\x79\x74\x71\xa6\xb7\xbe\x3c\x64\x2f\x6c\x9c\x58\x60\x05\x19\x09\x82\x2e\x78\x14\xec\xb5\x0d\x22\xdb\x89\x11\x3b\xb8\x39\xda\x0c\x31\x8d\xa2\x44\x8b\x4f\xcb\xe5\xe5\x5b\x70\xd5\x0e\xc9\x60\xfa\xfd\x8c\xd1\x98\xd5\x4b\x4b\x58\xdc\x08\xd6\x1b\x6b\x06\x86\x72\x91\xb0\x2c\x25\xba\xa9\xfd\x1f\xc3\x2f\x11\x19\xb0\x85\x07\x27\x48\x2a\x66\x82\x0f\xa9\xbb\xd8\xf0\xec\x37\x35\x1c\xe5\xed\xcc\xa3\x0f\xdd\xd1\xdc\xc8\xb2\xcd\xf7\xee\xde\x74\xeb\xae\x69\x8b\x63\x3f\x66\xdf\xd8\x7d\xca\xd4\x65\x0b\x46\x0f\xae\x1f\x38\x79\x0c\xa3\xd9\xf6\xc0\x75\xdb\xfe\xca\x52\x87\x76\xb7\x2c\x7d\xb2\xd6\xbe\xed\x72\x5a\xf6\xfc\xc6\xe9\x0b\xa6\x5a\x27\x8f\xea\x53\x37\x67\x05\x9c\xa3\x07\xf0\x3a\x0e\x67\xad\xa1\xba\x44\xec\x60\x2f\x58\x8d\x86\x02\x8d\x43\x51\x5a\x1d\xce\xe2\x91\xfb\x11\x3c\xa0\xb0\x02\x33\x67\xfc\x76\x21\xc1\x96\xc4\xfd\xc8\x02\xc7\x23\x0d\x85\x91\x44\x67\xcb\xbf\xac\x3b\x77\x7e\x9d\xfc\xed\x19\x54\x44\xff\x1e\xdb\x42\x2f\x8b\x71\xf2\xdb\x24\xae\x22\xba\x1a\xe8\x07\x7e\x3a\xc4\x83\x0e\xde\x05\xf1\x14\x95\x4e\x59\x2c\xbe\x74\x17\x1b\x08\x32\x69\x76\xaf\xd7\xaf\xda\x48\x2f\x50\xcd\x4e\x29\x14\xb4\xa7\xd8\xc8\x94\x04\x30\x70\x43\xdc\x50\xe4\x98\x94\x88\x9d\xc9\xc8\x71\x82\x32\x4d\x24\x82\x73\x2a\x83\x60\x3a\xae\x1f\xba\x64\xe3\xdc\xf1\x2f\x3d\x1e\xae\x7a\x6f\x5c\xaf\xcc\x27\x77\xde\xfb\xf8\x7d\x7b\xde\x47\x3f\x31\x55\x43\xf6\x0d\xcf\x3f\x74\xe3\x8a\x0d\xcc\x2c\xfe\x8b\xa9\xb3\x57\xf4\xdd\x77\xaa\x7d\xff\xc6\x17\x6b\xbe\x1f\xd1\x48\xf2\x4d\x1f\x01\x5d\x7e\x60\xff\x03\x76\x34\x40\x0d\x8b\x48\x66\x1f\xcb\x5a\x38\xce\x65\xd4\x82\x54\x04\x33\xec\x69\xa7\x55\xe8\xb0\xf6\x2f\x3b\xee\xb3\xf0\x16\xc2\xb3\x0c\x8f\x65\x99\x53\xc8\xa5\xae\x7e\x4e\xdc\x2f\x86\x15\xbd\x5a\xae\x94\x6a\x82\xfe\x27\xe1\x46\xb5\x93\x07\xd1\x75\x4a\x62\xdc\x06\xd8\xa5\x9e\x88\xf9\xe1\xb1\x83\x4b\xf6\x1e\xde\xb5\xd1\x74\x64\xda\xf4\xb7\x17\x6e\x68\xe9\x56\x35\x79\xfe\x34\x66\xc5\x73\x6f\x6a\xf1\x1e\x71\xfe\x95\x33\x0f\xbe\xeb\x98\x98\x2b\xff\xb6\xb3\x95\x47\xf7\x20\xef\xf9\xc7\x37\xdf\x79\x46\x9e\xc6\xdd\x83\xe5\x57\x43\x9d\x65\x5e\x60\x7f\x01\x1a\x0e\x88\xb8\x74\x88\x96\x2c\x78\x3f\xb3\x55\x84\x83\xe5\x1d\x4e\x91\xb1\x52\x2c\x2d\x01\xad\x4b\xc1\x72\x0a\x04\x0f\xc0\x01\xfe\x6b\x1a\x55\xaa\x1b\xa3\x6b\x3b\x94\x0a\x2b\x49\x03\x26\x84\x48\x7c\xaa\x04\x10\x7e\x90\x72\x06\x85\xe8\x39\x9f\xaf\x45\x85\x4b\x4a\x8a\xd3\x2d\x92\x33\xa3\xa4\xa6\x7f\xcd\xc4\xb6\x35\xbf\x23\x5b\x0b\x7d\x87\x5c\x44\xf7\xfb\x69\x6a\x95\x30\xce\x74\x5d\xd3\x05\xb4\x4a\xb6\xc5\x5e\xbc\x72\x85\xce\xbf\xb2\x82\xde\xcf\x6c\x13\x05\x26\x9b\x9e\x1e\xdb\x46\xfa\xde\x5e\xbd\xb2\x82\xc9\xa5\x5b\x44\x81\x5e\x42\x51\xea\x77\x7d\xae\xcc\x66\x76\xd0\x8b\x45\x81\x5b\x4e\x71\xea\x77\x66\xf8\xef\xce\x90\xef\x56\x2a\xff\x1d\x40\x9c\x21\x4f\x62\x1e\x65\xb6\x11\xb9\xec\x13\x71\x5d\x25\x97\x3e\x1f\x08\x64\x96\xf1\x19\xd4\x07\x18\x2a\x72\xcc\x85\x45\xb0\x56\x71\x65\x49\x41\x86\xa5\xb3\xec\x65\xfd\x3f\x95\xbd\x95\xbb\xef\xdd\xd8\x7a\xf7\xf4\x45\xb1\x1f\x33\x97\xd5\x4c\x9e\xb6\x74\xc1\xe8\x41\x23\x6e\x98\x3c\x66\x27\x16\xbd\xd3\xcc\xd7\x58\xf4\x1e\x8f\xd8\x6f\xbb\xe4\xc9\x59\xd0\x38\x8d\x88\xde\xf5\x83\x41\xf4\xb0\x9e\x95\x27\x32\xa7\xe9\x45\xca\x1c\x09\x44\x99\xb4\x78\xc3\x3a\x6b\xa0\x58\xb3\xa8\x35\x99\x58\x16\xe2\xa4\x5e\x10\x72\x50\xe8\x3a\x3c\xf1\xa4\xe3\xd5\x9e\xc2\xfd\x38\xa1\x8c\xf5\x2d\xe2\x85\x50\x55\x35\x32\xaf\x3b\x98\x61\x64\x8a\x0f\xb4\xc8\xbf\x96\x39\xd6\x19\x4b\xe8\x45\x72\xe6\xf4\x5e\xe6\x7b\xd0\xc5\x58\xfe\xd6\x27\xa7\x9e\xc2\x39\x64\x78\x67\x3b\xdd\x42\xa6\x14\xf5\x8f\x58\x74\x3e\x1f\x25\x89\xa2\x0b\x3c\x84\xcc\x2c\xa3\xcd\x26\x48\xed\xa8\x57\x44\x17\xd4\x99\x05\xbf\x50\x22\x30\x10\xe3\xd4\x52\x69\xf0\x7b\xbd\x31\x67\x34\x86\xc9\x52\xe8\x4e\xf7\x08\x40\x33\xe2\xa7\x91\xac\x92\x8f\x78\xfe\xa1\x62\xa2\x7f\x51\x8a\x4b\x83\x6c\xd8\x81\x93\xdb\xea\x66\x66\x59\x36\x3e\x74\xe7\x64\xcd\x02\xae\x7a\xcd\xee\x07\xae\xa3\x25\xec\xdd\x4d\x98\x36\x7f\xc2\x7f\xd0\xd6\x17\x5f\x90\x17\x57\x96\x6d\x18\xdf\x65\xa4\xdd\x3c\xed\x3b\xe4\xc7\xde\xde\x2e\xf0\x6c\x41\x1e\xe1\x9c\x7f\xa0\xd7\x52\x6e\x2a\x03\x22\x26\x51\x0c\xb0\xac\x15\xbc\x58\x0f\x88\x63\x28\xd3\xeb\x7c\x06\x00\x34\xa0\xde\x6d\x01\xab\x15\x8b\x60\x2d\x88\x60\x84\x52\x76\xeb\xd5\x26\x1c\x0b\xcb\x1f\xc8\x1f\x51\x20\x4e\x29\x39\xfd\x2e\x21\x81\x0f\x3e\x7a\xf7\x2d\xa6\xe1\x0d\x53\xa7\xcf\x9a\x03\x32\xd8\xb5\x1a\x64\x10\x31\x58\x06\x7f\x43\x02\xff\xd2\xb3\x7b\xdf\x76\x4c\xb4\xec\xbc\x65\xe7\x36\x90\xc1\xcd\x77\x9d\x7f\x42\x91\xc1\xdd\x98\x57\x35\xf2\x60\xe6\x05\x7a\x1d\xf0\xea\xda\x38\xaf\x92\x3e\x7c\xdc\xf7\x87\x2b\xe0\x67\x45\xba\xea\x04\x4a\xcc\xf3\x78\xac\x62\x20\x98\xef\x76\x07\x45\x81\x2d\x2a\xb6\x67\xd7\x45\xad\x76\xf8\xba\x2e\x9a\x97\xc7\x48\x1a\xb3\xd7\xc8\x18\xeb\xa2\x21\xe6\xe3\xc0\xf7\x01\x7a\x6d\x00\x05\x02\x14\x43\xf6\x1d\x94\xe0\xee\xbd\x44\xaf\x73\x89\x12\x31\x77\x6e\xdf\x23\x87\xa3\xd8\xc2\xd4\x1b\x11\x81\xd4\xbc\xdb\x83\x76\x8b\xb2\x48\x1a\x34\xa6\xba\x7a\x8a\xee\x1f\x58\xb6\x70\xf1\x9a\xea\x47\xba\xf6\xab\xaf\xdd\x8b\x70\x6f\x5e\xec\xfb\x78\xff\xde\xe2\x2d\xbf\xd4\x37\x32\x68\x96\x36\xfa\xc8\xbc\xba\xbe\xbb\xf6\xd2\x6f\xc6\xea\xef\x5f\xb1\x68\x3f\x7d\x74\xf9\x56\xf9\x0b\xf9\x43\x97\x24\xb7\x8e\xef\x5f\x74\x85\x1a\xc7\xb4\x28\xdd\x78\xf4\x95\x3f\x03\xce\x83\xb9\x57\xa9\x22\xaa\x06\xef\x55\xf6\x07\x02\x15\x99\x9c\xdb\xed\xb2\x58\xad\x46\x57\x31\xb8\xd6\x5d\xbb\x59\x43\x78\x8d\xb2\xdf\xe1\x30\xd7\x45\x1d\xe9\xe9\x8e\x02\x57\x41\x59\x5d\x34\xa7\x40\x74\x21\x9d\x9d\xae\xae\x8b\x72\x64\xc3\x43\xd2\x9d\x26\x45\xb0\xab\x88\xdb\x76\x55\x03\x19\x71\xb2\x93\x3e\x7e\x4e\xc8\x86\x45\xa3\x52\x52\xe2\x09\x70\xb4\x9d\x95\xca\xd4\xca\xea\x30\x08\x7a\x0e\x2e\x91\xc1\xde\xb7\x85\x49\xbd\xde\x1c\x2c\x2f\x6a\xde\x1f\xa6\x35\xf4\x51\xde\xe3\xc9\x49\x5b\x47\xcf\x19\x51\xdd\x96\x6e\xf3\x7b\xf8\x75\x63\x26\x56\xb3\x6c\xf9\x43\x2b\x5f\x7b\xee\xf4\x8a\x8d\x77\x6f\xdd\x74\xcf\xa6\x26\x3a\x23\x76\x2e\x3a\xc5\xbf\x46\x57\xf5\x08\x73\x59\x53\x5a\x32\x73\x15\x37\xeb\x31\xa1\xa4\x74\xd1\x22\x7e\x49\xaf\x86\x99\x63\xe4\x6f\xe4\xcf\x3e\xff\xcb\x85\xcf\xde\x39\xff\x8a\x72\x97\x81\xe7\x9f\x7f\x00\x34\x29\xa4\xba\x50\x8d\x91\xd2\x22\x3e\x5c\x68\x72\xbb\xb3\x3c\xbc\xa7\xa6\x6b\x9e\xdd\x96\xe9\xcd\xac\x8b\x06\xc8\xc4\x7e\xaf\xd3\xeb\xd4\xb8\x91\xa6\x8a\x2c\xbc\x60\x4a\xeb\xa2\xca\xe9\x27\xf2\x23\xa4\x01\x29\x4e\x88\xe4\x90\x1d\x49\xa5\x81\xb2\x02\x5d\x52\xd2\xa5\x39\x95\x7f\x40\x04\x9c\x43\x05\x06\xe9\x90\x44\xad\x24\x38\xa2\x6d\xcd\x07\xca\x69\xfa\x1a\x44\xe0\x8f\x30\x42\xec\x83\x15\x1b\xef\xd9\xb2\x65\xd7\xa6\xa6\xa3\x33\xc7\x80\x7c\xbb\xe8\xaa\x31\x93\x9b\x2e\x74\x24\xc1\xe5\x7e\x8f\x54\x89\x4b\xf2\xd1\xc2\xcf\xff\xf2\xf6\xc7\xef\xbd\xfc\x0a\xf8\x80\x5b\x20\x6c\x1f\x08\xf8\x97\x52\x0d\x11\x63\x31\x32\x99\x7c\x1e\xb3\x39\xab\xac\x3c\x23\x0f\x6f\x6f\xf1\x47\x33\x10\x95\xee\x4d\x07\x66\xd0\xe3\x2d\xca\x6e\x4b\x5d\x54\xe3\x66\xe1\x1f\x73\xb1\xd7\x6c\x4e\x8e\x82\x07\xf6\x4f\x62\x9e\xd8\x13\x1b\x2f\x16\x08\x27\xf1\xc3\x2b\xa2\x92\xa8\xe3\xeb\x46\x35\x6f\x64\xc7\x6a\x0a\x5f\xe2\x04\xed\x74\x1f\x94\xc0\x0d\xb5\x79\xdc\x0a\xc2\x55\xf2\xef\x88\x7f\xee\xd3\xfe\x07\xf3\x7d\x27\x4b\x66\xce\x2e\x43\x5f\x33\x47\xe4\x15\x0a\x62\xf2\x64\xf4\x89\x82\x2a\xea\xb3\xcd\xfd\xda\x11\xa3\xe6\x76\xce\x50\x3c\xb3\x51\x07\xc2\xce\x5c\x81\x00\x95\xfd\x0d\x64\xbd\x18\xf8\xbe\x37\xb5\x21\xd2\xb7\x07\xa8\x2b\x23\xef\xa1\x4a\x8a\x8b\x23\x54\x79\x5e\x5e\x06\xc5\xe7\xf2\xb9\x7d\xfa\x56\x75\x75\x76\xad\x8b\x0a\x4c\x4f\x66\x58\x34\xcb\xd8\x33\xa3\xac\xa0\x6c\x58\x34\x47\x57\x84\x4a\x22\x6c\x41\x4f\xf8\x87\xf7\x79\xac\x4e\x51\x34\xe7\xa9\x5d\x60\x24\x48\x88\x37\x9e\x29\xf7\x77\xea\xd5\x47\x52\x18\xe2\xe9\xa1\x70\x42\xe9\x91\xd2\xc7\xec\x10\xd6\x7a\x20\x10\x3d\x51\x75\x65\x45\x6a\xa6\x86\xfc\xe1\x45\x40\x30\xa2\x18\x85\x8c\x1c\x37\x72\x84\xab\x55\x53\x87\x77\xae\x57\x97\x3b\xf1\x3d\x97\x75\xf3\xe0\x82\x47\x3c\xc2\x3a\x71\x68\x1f\xfe\x2e\x9e\xce\x98\x35\xb8\x61\xb4\x95\xce\x5d\x30\x72\xd9\x74\x23\xbb\xc1\xbf\xec\x50\xef\xba\xf9\xab\xfa\xf7\x28\xeb\x75\xdd\x60\xf9\xcb\x1e\x43\xd8\xaa\x71\x0b\xca\xd0\x5b\x79\xb4\xcc\xa3\x76\x57\xda\x90\xa9\xfe\xd8\xe9\xfc\x35\xa5\xd3\x1b\x27\x4e\x9d\x3d\xe6\xc8\x9b\xcb\x2d\xd2\x8e\x1a\x79\x28\xda\x48\xa7\xcb\x13\xe8\xc2\x6c\xf6\xc0\xee\xe6\x43\x87\x50\xdd\xe3\xf7\xd0\xfe\xba\xdd\xcd\xa0\x3f\x3e\x05\x3a\x7e\x03\x74\xcc\xa1\xc2\xd4\xd4\x48\x38\xd7\x25\x08\xa2\xa6\x90\xa2\x02\x39\x9a\x9c\x8a\x4a\x2d\xd0\x10\xb4\xa3\x98\x1b\x28\x44\x85\x75\xd1\x6c\x23\xca\x85\x7f\xd2\x35\xe9\xa0\x40\x5c\xe9\xa2\xd5\x4c\x69\x48\xdd\x6b\x52\x6d\x94\xa8\xb4\x8a\xff\xd1\xb1\xeb\x9d\x50\xa9\x98\xc9\x01\x12\x80\x51\x08\xe1\x94\x30\x90\xc9\x47\x27\x09\x44\xea\x0d\x24\xe4\x70\x3a\x9c\x95\xca\x00\x19\x66\x46\xaf\x75\x6b\x9a\xbb\xb6\x15\x16\xad\x5b\x39\x29\xb5\x7c\x7e\xc8\xba\x05\x93\x62\x23\x26\x1c\x7e\xbc\x96\x94\xd6\xa3\xc1\xba\xdc\xe2\x22\x93\xec\x42\x3f\xe9\xbb\x65\x37\x6e\x14\xff\x96\xac\xc2\xff\x35\x73\xf5\xf2\xfb\x5d\xf2\x93\xf4\x42\x5b\x8f\x5a\xe3\xc5\x39\xcb\x2a\x8e\x03\xee\x7f\x91\x47\xb3\x03\xd9\xc1\xc0\x43\xdd\x70\x17\x73\x55\xae\xc6\x66\x0b\xd8\x4b\xf0\xdc\xff\x1e\x85\xe5\x75\xd1\xdc\x42\x31\x64\xf6\xbb\xea\xa2\x26\x7f\xba\x24\xe9\xc0\x72\x38\x34\x01\x56\x02\x83\x2e\xd1\x66\xc6\x2f\xf9\x25\xda\x9e\x4e\xd7\xd4\x45\xd9\x84\x02\x25\x7c\x33\x61\x7c\x23\xb0\x8e\x42\x05\x65\xf5\x54\x87\xb4\x4f\x4a\x92\xc2\x8b\x12\x52\x84\x07\xfe\xa6\x28\x10\x89\xd0\xc5\x9e\xa2\x3c\x55\x37\xbc\x8a\x1d\x28\x2f\xfa\x7d\x14\xc7\x06\x54\x71\x72\x85\xda\x9c\xaa\x38\x85\xf9\xa3\x88\xe5\xd8\xd2\x07\x5a\x5e\x7e\xf1\xf4\xca\x9b\xe7\x34\xd5\x6e\xba\xe7\x96\x66\xac\x3f\xff\xa4\xd9\x77\x44\x83\xc5\x4a\xb3\xec\xa4\x80\x85\x8a\x65\x5e\x3a\x58\xc5\x96\x4d\xb7\x4e\x6d\x94\x7f\x91\x3f\xfa\xec\xcf\x63\xce\xde\xf3\xce\xb9\x17\x48\x7c\x5d\x85\xf7\x5a\x02\x4f\x14\x52\xe3\x23\x15\x59\x3c\xc4\x10\x56\x2b\x55\x54\xec\x75\xd4\x45\x0d\x5e\x50\x25\x9a\xba\xa8\x64\xe3\x7d\xac\xd9\xec\xf5\x7b\x69\x91\xf1\x9a\xbd\x66\x6b\x56\x7e\x3e\x5d\x1f\xcd\x17\x33\xcc\x56\xac\x42\x48\xce\x21\x51\xcd\x9a\x24\x47\x8a\x06\x05\x2a\x28\xd3\xe5\x53\x68\xd0\x41\x93\xe0\xfd\x61\x61\x2c\x3c\x74\xb8\xdc\xc9\xda\x17\x4e\xdd\xfb\xa2\xdb\xaf\x20\x9d\x1e\x6a\x73\xd9\x14\xa4\x4b\xd2\xdc\x8f\xe6\x6a\xb8\xf2\x89\x1b\x26\xcc\x9c\xce\xec\xb4\xfe\x74\xaa\x52\x4b\x30\x95\xcf\xa2\xf5\x3c\xc1\xf5\xf8\xa0\xd7\xa7\x6c\x59\xb8\x70\x56\xa5\xa4\xd4\xf2\x93\xd9\x1e\xd8\x4f\x18\x19\x29\x31\x62\xcb\xe0\xe1\xb3\x73\x32\xbd\x70\xc0\x99\x41\x62\x26\x5d\x69\xc6\x2c\xd6\x61\xce\xf4\x67\x02\x7a\x99\x10\x3a\xb3\x1e\x3b\xab\xad\x8f\xb2\x62\x4a\x5f\xea\x1f\xe0\xa5\x0c\xf4\x03\x88\xed\xff\x1b\x3b\xf4\xe9\xb8\x33\x6b\xbb\x65\x65\x76\x5f\x35\x3f\x89\xd5\x13\x09\xac\xe8\xa3\x6b\x9f\x99\xae\x7b\x48\xb7\xf5\xd0\xe3\x9d\xd1\xc1\x38\xe0\xbd\xb7\xd3\xd8\x81\x54\x35\x35\x29\x52\x5e\x5a\x95\x4b\xe5\x0a\x3c\x9f\x11\x74\xdb\xd2\x8c\x46\x8a\x0a\xa6\x31\x5d\x6a\xaa\xdc\xce\x0a\xa3\x54\x94\xcb\x32\x15\xce\x0a\xa7\x8f\xf1\x65\xd5\x45\x7d\x22\xa3\xeb\xb4\x3c\x93\x08\xad\x93\xd4\x67\xa6\x44\x7f\x24\xf5\xad\xee\x47\x43\x29\x99\x49\x6c\xbf\x4a\x10\x16\x4c\x3b\x78\xc4\xf1\x0b\x82\x78\xed\xa2\x8f\xf6\xc7\xf1\x15\x1c\x6c\xd6\x3f\x2e\x9c\xbb\x18\xdc\xe3\xbc\x6d\xed\xe6\x35\x23\x66\xac\x1d\x79\x4b\xc1\xc0\x75\xec\x2d\xfe\xb7\xce\x1d\x7f\x2b\x7d\x9f\x79\xfd\xfc\x95\x4b\x0a\x06\xcf\xed\x35\x70\x4b\x49\x9a\x93\x5f\x37\x29\x88\x0a\xee\x79\xf8\xe6\x56\xff\xe8\x61\x23\x46\xf4\x1c\xe4\xcd\xf2\xe4\xce\x3a\x96\x57\x39\xe0\xce\x7b\x6f\xda\x6a\xeb\x3f\x78\xc0\xc0\xbc\xea\x5c\xbf\xc5\x9e\xeb\x0b\x1f\x2c\xec\xae\xe4\xd9\x57\x5d\xf9\x81\xf9\x8d\x1b\x01\xbe\xcf\xdc\x48\x81\x96\x73\x3a\x0b\xe9\x8c\x0c\x6f\x71\x49\xae\xd5\x6a\xa8\x8b\x16\x80\x95\x17\x0b\xb5\x21\x07\x5b\x60\x2e\xf0\x17\xc0\x41\x5a\x0b\xac\x05\x7e\xe4\xf7\x60\x2b\x68\x04\x87\x48\x43\x96\x29\x71\x0c\x32\xc7\x37\xf1\xa7\x90\x44\x39\xdd\xf2\x82\x54\x2d\xa6\x96\x89\x55\x86\xad\x64\x31\xa0\xa4\x5c\xc4\x85\x15\xf2\xd8\x93\xf5\x1a\x3d\x50\x4e\x42\x8e\xcf\x1c\xee\xba\x02\x3d\x21\xd7\x71\x61\x5a\x39\x64\xae\x2b\x3d\x72\xd2\x2d\xfb\x1f\x79\x78\xdf\xbe\x6c\xe5\xac\xf3\x98\x23\xdb\x90\x47\xfe\x72\x9b\xbc\x83\x26\x42\x2a\xd0\xf7\x0c\x1d\x94\xb1\xb9\x78\xf3\x9d\xdf\x71\xf8\xc4\x19\x94\x8f\xf1\x3d\xa0\xf6\xd9\x05\xa9\x29\x91\x6a\x3b\x23\xd8\x58\x97\xe0\xca\x08\xb9\xec\x0e\x3b\xf8\x77\x44\x43\x51\x69\xa0\xad\x68\x8d\xdb\xca\x52\x66\xac\x9f\x44\x06\xd4\x15\xc5\x3b\xcc\x02\xc3\x33\x75\x51\x6c\xe1\x12\xe9\x9e\x8e\x38\x76\xd4\xd6\xe4\x72\x2b\x07\xd7\x99\x57\xa2\x04\xcb\x96\x3b\x95\x1e\x9a\x38\x47\x33\x23\xc3\x07\xe4\x1f\xe8\x53\x97\x9b\x51\xb8\x4b\x7a\x8e\x6f\x1d\xbd\x60\x64\xe5\x4d\x88\x8d\xed\x60\xba\xc8\xef\x0e\xc8\x27\xf8\xa2\xc7\x73\xe4\xa7\xb6\x6e\x46\xcb\x8d\x18\x93\x00\xea\xb1\x75\xb3\x7c\x97\xb5\x14\xb0\x24\xbe\xda\x01\xd0\xc1\x3d\x80\x8f\xfd\x70\x8a\x75\x91\xbc\x80\x43\xab\xf5\xb1\x4c\x8e\x28\x32\x3e\xa6\xb8\x24\x2d\xdd\x98\x8f\xa7\x8c\x18\xad\x94\x15\x8e\xd3\x61\x4d\xc7\xed\x26\x2c\x4b\x89\xf1\x2a\xd0\x70\x62\x4d\x62\xea\x6d\x56\xb2\xca\x84\xb0\x66\x40\xb2\x87\x13\x6d\xa8\x49\x9f\x55\xb4\xda\x12\x71\x27\xa8\x57\x7a\xc1\x93\x7f\xf5\x3d\x65\x69\x9e\x2a\xff\x4c\xcf\xfa\xf9\xa5\x53\xaf\xbc\xb6\xf8\x91\x62\x5a\xc3\x3e\xca\x1f\xef\xbf\x7e\xf8\x96\x9b\x96\x6d\x1f\xb9\xa1\x3f\x3b\x70\xeb\x5a\xcf\xc0\x61\xf2\x0b\x47\xdf\x94\xff\x0b\x4e\xf9\xa7\xf2\xf7\xb3\x26\xf9\xb6\x1b\xaa\x0e\x33\xdd\xd0\xcb\x97\xbb\x6e\x38\x3b\xed\xe5\x4f\xfe\xef\xcf\x10\x0b\xe2\x3a\xcf\x8b\xcc\x16\xf6\x10\xa5\xa7\x7a\x5c\x5d\x83\xeb\x8e\x98\xa3\x7e\x01\xf9\x85\x5a\x81\x16\x04\x2d\x8f\xf7\x2b\x94\x97\x84\x6b\xf0\x82\xa0\xff\x55\x7c\x6b\x91\x0f\x2d\x5f\x8e\x1a\x56\xa0\x8b\xa8\xb7\x7c\x9a\x7e\x4d\x7e\x1f\xe5\xc6\xc2\x84\x96\x4b\x81\x96\xa3\x81\x3f\x02\xa0\xb9\x87\x45\x0a\x32\x29\x8b\xde\xcc\x0a\xf9\x10\xfc\x98\x05\x03\xc5\x15\x15\xb3\xc1\xba\xa8\x45\x30\xb2\xac\xd7\xe8\xcd\x01\xef\x37\xdd\x6c\x30\x82\xa4\x18\x3b\xef\xb1\x01\xe6\x28\x48\xea\x02\xf5\x16\xac\x1a\x6b\x35\x12\xd1\xd5\x12\x36\xe0\xb0\xbc\xb3\x78\x51\x15\x09\x45\x53\x0a\x02\x97\xde\xf4\x7f\xeb\x03\x79\x05\x35\x4f\xc6\x1e\x65\xb2\xe4\x7f\x17\xf5\x68\x9c\xd3\xd8\x63\xed\x3f\xb6\x6d\xff\xbc\x19\x7d\xbb\x7b\xff\x43\x77\xdf\x7b\xf8\x91\x2e\x9b\x3e\x68\x0a\x74\xcf\xce\xeb\x5e\xb8\x79\xeb\xc6\x8f\x32\xbd\xe9\x55\xbd\x47\x2e\xd9\x3d\x6d\xdb\xc5\x15\xcb\x2f\xa2\x2f\x9e\x7c\xe8\x60\xdb\x89\x87\x0e\x1c\x53\xe4\x3c\xff\xca\x4b\x9c\x8e\xfb\x9a\x2a\xa3\x36\x46\xae\xf7\xf8\xb3\xa5\xfc\x7c\x7f\x5a\x7a\x7a\xc8\xeb\xa7\xb4\x65\x25\x26\x53\x81\xb9\xb4\xac\x8c\x63\x59\xb3\x9f\x29\x0f\x97\x95\x15\xa2\x3c\x6d\x30\x23\x38\x2c\x9a\x2f\x79\x3d\xac\x4b\x5f\x20\x32\xe6\x92\xec\x4c\x2a\x43\x74\x59\x41\xb5\x43\x08\xc4\x9a\x89\xa7\x57\xa2\x54\xb6\xbd\x18\xc6\x75\x65\xaa\x2a\x27\xf5\x2d\x1d\x52\x33\xea\x98\x96\x44\xf4\x43\x5a\x19\x7c\x48\xb9\x77\x2b\x80\x38\x15\x7f\x62\xe2\xb2\x9f\x23\x84\xaa\xb3\x53\x73\xfa\xb8\x76\x57\x40\x61\xe6\xbb\x29\x63\x0e\x95\xf5\x42\x37\x6b\x0f\x7d\x9d\xd6\x3b\xb3\x4f\xb4\xf1\x86\xd2\xe2\xbd\xab\x0c\xab\x37\x54\xce\x7f\xfd\x75\xa4\x6d\xa3\x51\xe3\x5e\x76\x90\xee\xc8\x0b\xb8\xe1\x6e\x77\xf3\x5f\xba\xd7\xc5\x5a\xd1\x65\xf9\x91\x6c\xd3\xcd\xae\xb4\x3e\x27\x8a\xba\xd1\x7f\x5d\xff\xd3\x4f\xeb\x63\x8f\xa1\xf5\xf4\x17\xf2\x4d\xe3\xd1\x15\x72\x1f\x05\x41\x20\x53\x4a\x66\x70\x14\x47\x1c\xac\x46\x83\xb4\x5a\xe0\x2f\x32\x23\x04\x38\x8a\xd6\xda\xf1\xcc\x88\xda\x94\xd6\x98\x84\x91\x22\xd8\xd8\xb1\xef\x1e\x42\xf7\xcf\x6b\x5b\xb4\xa8\x6d\x1e\x3d\x0b\xbd\x29\x97\xdc\x2c\xa7\xa3\xbf\xe3\x18\x5b\x7d\xb6\x85\xe7\x76\x93\xda\xa3\x5e\xc0\x5f\xb7\x82\xbf\xe4\x23\x11\x76\x63\xa4\x24\x2f\xa4\x4d\x4b\x43\xe9\x19\xf9\xf9\x56\x31\x5d\x2c\x2a\x86\x33\xb1\xfa\x28\x1f\xc4\xd6\x22\x1e\x12\x64\xf7\xd7\x45\x9d\x76\x87\x11\x62\x6e\xad\x51\x64\xcd\x24\x67\x97\x2a\xb3\x61\x95\xe2\x9d\xbd\x44\x32\xe6\xa5\x32\xc5\x03\x02\x27\xc0\x1e\xa2\x13\xf7\x3a\xa1\x8e\xfb\x9c\x7b\xcd\x4d\xf8\x3d\xa7\x5e\x30\x0c\x19\xec\x94\xb7\x60\x07\xa9\x6d\x2e\xdd\x6b\xf5\x2a\x21\xf6\xb1\x66\xeb\x6d\xdb\x36\xea\x69\xaf\xb6\x99\x9e\xf5\x4b\xdc\xeb\xf9\xfa\xb7\x9b\x65\x0d\xb8\x45\x72\x94\x69\x95\x5b\x1f\x7b\xf1\xb9\x63\xcc\xb0\xa3\x8f\x9e\xdc\x07\x72\x34\x02\xef\xf8\x52\xe7\xdb\xdc\x10\xc9\xf4\x30\x8c\x95\x76\xf3\xbc\x1e\x04\xd5\xe7\xf7\x28\x73\x6d\x34\x40\x5d\x33\x6d\x06\xc5\x6b\x76\xf0\x98\xc6\xe1\x6b\xf7\x8d\x84\x13\xc9\x24\x6b\x58\x15\x61\x40\x45\xc9\xa2\xf6\x40\x18\x91\x1e\xa0\x65\x6d\x8e\x11\x33\x9e\x42\xdf\x3d\x35\x6d\xda\x67\xaf\xbe\xf2\xe9\x0c\xda\xd2\xb2\x5c\xb6\x2c\x57\x8e\x83\x1c\x49\xf3\xc9\x17\x5f\x68\x6f\x96\x77\x6c\xd9\xda\xd0\xd0\xba\x09\x60\xcc\x07\x18\xf7\x01\x8c\x21\x38\x09\xf0\x00\xf2\xf5\x28\xc8\x6a\xac\x66\x43\x4e\x8e\xc3\xe3\x31\x6b\x82\x6c\x51\x71\x9e\x3b\x44\x85\x70\x94\x47\x51\x3e\xde\x07\xea\xd3\xe7\xb0\x9a\x35\x1c\xcf\x81\x5d\xe4\xcd\xea\x0e\xb5\x70\xf8\x1a\x0d\x2f\x29\x4b\xea\xe2\xa7\x01\x11\x0d\x16\x7a\x13\xc2\x04\xc7\xa9\x5f\x20\x3f\x3e\x14\xa7\xdd\x86\x97\x82\xa7\xa2\x92\xdf\xe8\x18\x3b\x4b\xfe\x2f\x7a\x71\xc8\xf2\x34\x7a\x70\xda\xf2\x21\xe8\x25\xf9\xd7\x19\xe3\x1c\x13\x06\x21\xf9\xa7\xbf\x7f\x2a\xff\x30\x80\xee\xb6\xfd\x50\x6c\xc7\x41\x7a\xd6\xb0\xed\xd3\xb7\x6e\xcd\x7e\x78\x65\xd3\xc1\xec\xad\x5b\xa7\x6d\xaf\xbf\xd9\x62\x79\x53\x8e\x21\xea\xed\x4c\x79\xd7\x99\x3d\x06\xc3\x9e\x33\x58\xaf\x3d\x0e\x7c\xd7\x1f\xe2\xd9\x4c\x88\x68\xeb\x23\x39\x05\x96\xb4\x34\x8f\x81\xc1\xd3\x1d\x05\x0f\x0b\x61\x6d\x2e\xa0\x96\x21\x7a\x10\x6d\x34\x3a\xed\xe6\x62\xd0\x71\x66\x07\xa7\x23\xfb\x99\x38\x75\x3f\x93\xc2\x77\x92\x1a\xa9\x74\xb2\x12\xa2\x90\xb2\x45\x97\x4f\xb5\x10\xb8\x1e\xfc\x1a\xf9\x8b\xfe\xe3\x95\x65\xc0\xab\x6b\xfb\xc7\xf3\x18\x6d\x57\x67\x2d\xe4\xef\xb6\xcb\xb2\xba\x20\xd8\xa6\x26\x30\xd8\x6f\xe5\xe8\x35\x73\x16\x1b\x00\xc7\x85\x80\x23\xd6\xdd\x63\x22\xd6\x20\x0f\x11\x87\x39\x87\x32\x99\xcc\xc0\x5f\x0c\x38\xdf\x22\xd9\x14\xec\xb5\xdb\xdc\xd8\x7d\xb1\x46\x6d\xe9\x26\xa4\xc9\x57\xf2\x16\x99\x57\xe5\x2d\x3a\xf5\xe5\x25\x33\x89\x1d\x12\x16\xe4\xdb\x94\x05\xc2\x9d\x93\x14\x53\x52\x93\x14\x6d\xea\x06\xe4\xd5\xa3\xfe\x28\x33\x81\x9e\xfb\xfd\x8d\xc4\x4a\xe4\x8e\x39\x09\x34\x5a\x1e\xcd\x2c\xe3\xce\x81\xef\x52\x1f\xf1\xfb\x11\xb2\x08\x26\x03\xe3\x62\x4c\x4c\x46\xc8\x91\x36\x2c\xea\xa0\x28\x51\x12\x87\x81\x17\x63\x36\x21\x82\xa9\xc9\xde\xe9\x08\x55\xcd\x11\x4f\x46\xa8\x88\x85\xe3\xfd\x11\x9d\xf6\x20\x2b\x75\x46\xaa\x0b\x1e\xb6\xd3\xfb\x47\xc8\xff\xa8\xea\x5b\x52\xbb\x7a\xc2\xdd\x77\xaf\xbb\x65\x60\x45\x51\xa8\x6f\xcf\xb7\x98\x93\x97\xff\x8e\x01\x36\x3f\x28\xdd\xb9\x9c\x39\xb9\x7e\xe5\x9d\xeb\x0c\x9b\x35\xfd\xc6\x4d\x5a\x4f\xce\xa4\x18\xce\xe4\x55\xf0\x4d\x4a\xa9\x9e\xd4\xf2\x48\x4e\x97\x34\x93\x91\x2b\x28\xd0\x94\x65\x58\xad\x79\x1a\x8d\x31\x8d\xa9\x8d\x64\x99\xf3\x04\x9c\x4a\x74\xf9\x7c\x95\x75\xd1\xa0\x4f\x2c\xa6\xf1\xf1\xd8\xa2\xc5\xc5\x2e\x9d\xab\x5b\x5d\xd4\xe6\xb2\xeb\x24\xf0\xc9\x4c\xba\xf4\x78\x13\x50\x5c\xfd\x75\xfe\x9c\x3a\x3b\x24\x71\x60\x9c\xb2\xa3\x25\xa4\x64\x7f\xb1\x0b\x1e\x90\x2a\x43\xea\x29\x5a\x12\xc5\x39\x60\x84\xd4\xed\x67\x4c\x45\xb2\x8f\xa8\x27\x62\x2e\x1a\x1c\x1e\xc7\x5c\xb9\x9b\xea\xda\x20\x23\x1d\x3e\xb6\x3c\xd5\xb7\x41\xfa\x71\xd7\x85\x03\xaf\x25\x3d\x9c\x5d\x7c\xbe\xeb\x93\xe9\x72\x17\xe2\xe7\xa0\x6e\x47\x67\xce\x42\x1a\x94\x86\xfc\x48\x02\x47\xe7\x4e\xa1\xea\x70\xec\x69\x79\x69\xfd\x7c\x0d\x33\x38\xc5\xd7\xa1\xbe\x06\x5a\x4d\x02\xfe\x75\x02\xf7\xba\x4c\x1c\x67\xd4\x0b\x82\xc6\x60\x84\x18\x91\x96\x24\xa3\x5d\xc3\xba\xdc\x56\x0a\x93\x46\x8a\x5a\xd3\x4d\x7a\x8e\x67\x59\x83\x59\x8b\x34\x76\xd6\x4c\x4e\x39\x3e\x00\x81\xd4\xe0\x24\x0e\x38\x41\x08\xf5\x86\x16\x9f\x6e\x4a\xaf\x4d\xfc\xd4\x99\x6e\xab\x73\xe4\x3b\x36\xb4\xb5\xa1\x8b\x6f\xc9\x37\xa0\x31\x37\x12\x4e\x95\xff\x7d\xe7\x72\xf4\xdd\x3c\x79\x0d\xf7\xea\xe5\x49\xb4\x51\x2e\x91\xcb\x55\xee\x04\x7e\xdc\x0f\xfc\x98\x47\xfa\x3b\x2b\x23\x06\x56\xaf\xd7\x6a\xcd\x3c\x2f\x4a\x46\x7c\x7c\x27\xa2\xc6\x74\x01\xf1\x5a\x02\x18\x6f\x4f\x99\xc3\x9c\xec\xc3\xe4\x54\x56\x8b\x4b\x10\xda\x5f\x50\xb9\x66\x6a\xdb\x68\xf9\x1f\x45\x91\x2b\x86\x3b\x97\x73\xaf\x2a\xb2\xa0\x07\xda\x4c\x01\xda\xbc\x08\xf1\x66\x98\x1a\x17\xb1\x99\x35\x1a\x6d\x98\xca\x0b\x04\x0a\x7c\xbe\x4c\x4a\xcb\x56\x54\x16\xf8\x08\xc3\x17\xd8\x33\x72\x14\xd1\xce\x48\x2f\x61\xad\x6c\x5d\xd4\xe3\x30\x5b\x45\x83\x99\xd2\xaa\x39\x96\xf8\xdd\x75\xaa\x6c\xa7\xb0\x4a\x30\x59\x61\x73\x75\xee\xc9\xde\x49\x44\xe2\x25\x43\xd6\xb2\x5e\x91\xa1\x8f\x74\x4e\x35\x4d\x56\x45\x7d\x12\xce\x33\x61\x77\xe4\xd9\x03\xb1\xbd\x78\x32\x40\x32\xb5\x14\x3b\x97\xdc\x7e\x7e\x14\x67\x95\x62\xad\xd8\x57\x7b\x02\xeb\x31\xc0\x35\x9b\x1a\x1a\x91\x1c\x46\xa3\x89\x0e\x04\x58\xc0\xd4\xc4\xe4\xe4\x66\xa8\x0c\x90\x91\x0e\x36\x4a\x0b\xf8\x89\x20\xed\x76\xd6\xd7\x89\x01\x3a\xca\x78\xd2\x0b\x56\xe0\x56\xb8\x5b\xc1\x31\x91\x38\x4a\x62\xc7\x0c\x58\x3d\xfd\xea\x49\x0b\x63\x12\x0c\x71\xed\xc1\x12\x71\x5c\x14\x5d\x7c\x14\x70\xb8\x1e\xfc\x9c\x2c\xaa\x1c\x62\x92\xec\x22\xbf\xc3\xe1\x34\x32\xd9\xd8\xde\x38\xd9\x70\x45\x28\x0f\xa2\xad\x90\xe8\x31\x3b\xd3\xc5\x52\x30\x36\x26\x5a\xbc\xca\xdc\x84\x53\xab\x53\x3a\x5b\x1b\x7b\x62\x39\x20\x31\x37\xaa\x53\xf3\xc7\x09\x9f\xeb\x57\xc9\x5f\xe3\xe3\xe8\x11\xa9\xaa\x26\x8e\xcd\x1f\xa4\x79\xe4\xe7\xb7\x5e\x24\x68\xf4\x1e\xb6\xd0\x48\x5c\x1b\x8e\xbf\x76\x92\x07\xdc\x75\xe0\xff\xc3\x70\x4e\x7e\xaa\x5f\xc4\x44\xbb\xdd\x3a\xa7\xd3\xcb\xb2\x62\x20\x98\x46\x0e\xc9\x14\x4d\x4b\x37\x59\xeb\xa3\x3a\x93\x28\x98\x59\x67\xc7\x13\x0a\xa7\xd6\x54\x25\xee\xca\x94\xe3\xc9\x09\x3b\x14\x1c\x14\xdd\x9b\x3c\x18\x74\xfb\xea\xf1\xfc\x61\x0d\x5b\xb0\x70\x7a\x66\x56\x66\xf7\x85\xcb\x94\x15\xf5\xf8\x4c\x98\x9e\x8b\xb6\xb4\x67\x6d\xc5\xd9\x8e\xe7\xda\xe4\x19\x29\x67\x81\xa8\x43\x70\x16\x59\xa0\x83\x2b\xa8\xc9\x91\x52\xd1\x6c\x2e\xf0\x65\x65\x3a\x74\x15\x15\x99\xac\x8f\xad\xac\x2a\x28\xf1\x38\x58\x43\x30\x08\x1e\x00\x95\x85\x2c\x4c\x56\x56\x50\x34\x80\x93\x2f\x8a\x3a\x43\xe7\x15\x8d\x61\x55\xfb\xc6\x1b\x94\x3b\xdd\xc0\x76\xd8\xda\xa8\xba\x01\xa9\x19\x0f\xba\x73\xaa\x03\x39\x7d\x8c\x9d\xcd\x52\x25\x65\xee\xbe\x44\xaa\xa3\x61\x72\xcb\xbd\xeb\x07\xa4\x64\x39\x4a\xc7\xef\xda\x7e\xd3\x0d\xb9\x2d\x8a\xb8\xec\x0c\xab\x49\x8e\x48\x9d\x27\x23\x77\xf0\xfc\xba\x44\x86\xa3\xb8\x7b\x7e\x56\x66\x8f\x01\x93\x7a\x02\xde\x2d\x70\x3e\x6f\x83\x7e\xca\xa2\x46\x45\x44\x97\xde\x66\x09\x04\xb2\x78\xaf\x8d\xb7\x65\xe7\x38\xd2\x94\x04\x86\x05\xdc\x6b\x87\xc5\x61\x09\x69\x43\x34\xd1\x20\xa1\x74\xad\x89\xa0\xac\x45\x9d\xf2\x3b\x05\x1d\x12\x90\x4a\xe3\x2b\xb1\x0f\x95\xd8\x15\x88\x1f\x55\x30\x45\x43\x04\x95\x25\x64\x2d\x95\xc1\xaa\x6e\x1e\xd4\x7d\x74\x61\xd9\x75\x83\x07\xa2\x33\xf2\xb7\x79\xc5\x45\xb9\xcb\xe4\x4f\xef\xdc\x5d\x11\xbe\x42\x99\x0a\x86\xcd\x63\xb7\xa3\xc9\x96\xfd\x69\xb3\xd6\x5e\x3e\x27\x7f\x24\xbf\xaf\xb9\x5f\xb7\x6b\xeb\xf9\xb6\xc7\xf5\xca\xf9\xcd\x93\x47\xb1\x13\xc0\x4f\x75\x00\x9f\x39\xcc\x26\x23\xc4\xa4\xb4\xdd\xe1\xa0\x79\x8b\x89\x73\xba\xec\x26\x33\x8b\xd5\x6c\x44\x1f\x65\x8d\x16\xa3\x91\x82\x60\x34\x9e\xa2\x10\xff\x12\xef\x3b\xea\x30\xd1\x24\x2b\x55\x8f\x05\xc9\x0d\x2d\xee\xfc\xa1\xaf\x7c\x17\x87\xed\x90\xbc\xfc\xd9\xef\x8c\x5d\x42\x39\xff\x39\xbb\x55\xfe\x59\x81\x08\xdc\xf9\x58\x24\xf7\x85\xa5\xcb\xe8\x3f\x2b\x70\x2d\x05\xb8\x1a\x00\x2e\x27\xd5\x10\x71\xe3\x99\xc7\xb4\xa0\xd1\x38\x75\x3a\xbb\xc1\x20\x6a\x79\x8a\xa1\x05\x97\xdb\x64\xc5\xa0\xd9\xa3\x26\x27\xaf\x65\x28\xd6\xc9\x3a\x75\x38\xa0\x11\x58\x33\x4d\x6e\x49\x6a\x15\x36\xc2\x90\x76\xb2\xdd\x61\x75\x8c\x90\x96\x58\xa9\xa4\xa1\x22\xba\x97\x1e\x87\x97\xde\xb7\xc8\xb7\xab\x0b\xef\x6f\x47\x59\x37\xaa\xb0\x77\xc5\x5b\xef\xe9\x42\xda\x84\x97\xde\xc7\x7e\x91\x1b\x13\xf0\x93\xfc\x0f\xc0\x9c\x47\x66\x32\xd4\x46\x1c\x3c\x65\x11\x04\xc4\x71\x06\x9a\x62\x6d\x76\x2b\x8f\xef\x35\x75\xd8\x96\x46\xb4\x51\x5d\x1a\x43\xd7\x45\x19\xf3\xd5\xbb\x49\x55\x5d\x5a\xad\x24\x72\x3a\x1c\xf8\x01\xfa\x2e\x9c\xb8\x89\xcd\xa6\x4f\xa9\xd0\xc4\x3c\x9b\x99\xec\xad\x9b\x2f\x7f\x90\x02\x05\xd6\x8f\xa3\xe5\x51\x5c\x15\xe8\x8e\x3c\xaa\x8a\x6a\x8e\x38\x2b\x18\x93\x39\x5b\x28\x2e\xb6\x87\x3c\x1e\x9f\x8f\x74\x4b\x55\x77\x09\xa6\x63\x50\x0a\xa2\xc1\x34\xbe\x74\x98\xda\x33\xb5\xc0\xf4\xb1\xe9\x7b\xd3\x15\x13\xa7\x57\xfa\xa6\xea\xa2\x92\xe8\xcc\xa7\xc0\x89\x85\xe8\xdc\xfe\x47\xcd\x52\x29\xd0\x5b\x52\x46\x35\x29\xb3\x45\x3a\xb4\x4d\x59\x94\xb6\x29\x1c\x89\xdb\x94\x70\x1c\x7c\xa5\x0e\xcd\x53\x34\x6e\x9e\x7a\x60\xff\x81\x8f\xfe\xf3\xf3\xc2\x15\x4d\xf3\xf5\x7f\x2a\x46\x1b\x5e\x7d\xbd\xd1\x13\x5c\x96\x0b\xf1\x92\xfc\xed\x83\x5a\xbe\xef\xc9\x31\x53\x76\x47\x5f\x58\xb3\xbe\xdf\x04\xdb\x91\x9d\x87\xda\x78\xb6\xdb\x86\x45\xf5\x63\x24\x94\x79\xea\x49\xb9\x78\xaf\xf0\xdd\x2e\xdd\xfd\x1a\x94\xdb\xa4\x7f\x6d\xd5\x8c\x8d\x63\xee\x1f\x4e\xa6\xa3\x0e\x6b\x98\x88\xef\x1d\xe1\x7c\xfe\x4b\xf6\x85\x17\x83\x17\x94\x97\x67\x73\x1b\x43\xa1\x00\x2e\xa2\x65\x03\xb6\x40\x49\xa9\x57\x74\x40\x28\xec\x76\x88\x52\x21\xf0\xb9\xe4\xd0\x07\xc1\x7d\xb7\xe3\x64\x10\xc8\xac\x90\x96\xea\xe6\xa6\xd4\x67\xd7\x74\x44\x1c\x2f\xb8\x4b\x20\x17\xca\x49\xf8\x82\xc1\x14\x57\x30\xdc\x21\x5a\x29\x52\x91\x1b\x46\xb3\x55\x0f\xac\x79\xfd\x59\xf0\xe7\x1f\xac\x02\xdf\xef\x31\xa1\xcf\x7f\xb7\xec\xda\xbc\xa2\xe9\x96\x7b\xb6\xac\x50\xb0\x5a\xb7\xbc\xdb\x9c\xb1\xc8\x81\x1c\x74\xd5\xe8\x69\xbe\x1d\x5c\xb7\x6f\x62\xb3\xd1\x9e\xb7\x5e\x7d\xf5\xe3\xcf\xff\xf2\x81\x72\xb7\x0a\xfa\xf8\x3d\xee\x03\x82\x63\x7d\x44\x0a\x09\x3e\xab\xd5\x95\x47\x99\xcd\x2e\xc1\x55\x52\x1a\x20\xaa\xc9\x19\x0d\xa4\x4b\x8e\xfa\xa8\x44\x69\x01\x51\x83\x56\x64\x01\x6d\x8a\xed\x10\xa0\x74\x2c\xcb\x4d\xc6\x27\xa1\x8e\x37\xaa\x71\xed\xa4\x1e\x2b\x46\xba\x43\x84\x52\xc3\xa6\x86\x28\x28\xad\x57\xbf\xae\xdd\x9a\x56\x46\xf2\x6b\x7b\xc8\xff\xbc\x76\x90\x72\x10\xe5\x9a\x0f\xd9\xef\xfc\xfd\xd3\x3b\xcd\xbb\xcd\x28\x97\xde\x13\x8f\x51\xf0\xfc\xf1\xd1\x9c\x00\xe7\xe7\x85\x48\x73\x76\xa4\x32\x93\xa2\x9c\x16\x5e\xf0\x19\xd3\xd3\x05\x27\x93\x05\x3c\x5a\x17\xcd\xcc\xb4\x79\x3c\x41\xec\xba\x58\x6c\x13\xf8\x05\x3c\x4d\xf1\x48\x62\x78\xde\x66\x63\xc0\xd7\x77\x98\x15\x37\xc0\x9c\x9e\x9c\xed\xef\x52\x07\x01\x77\xee\xfd\x4f\xb2\x71\xbc\x53\x25\x89\x62\x25\xaf\xba\xf7\x29\x3d\x2b\xdd\x77\xdf\xb9\xb4\xd5\xfd\x80\x8a\xdb\xcc\xbd\x3f\x5c\xba\xf4\x2f\xf4\xd1\x33\xe6\xdb\x36\xae\xbf\x87\x47\xbf\x3e\x73\x6e\x7c\xff\x22\xf9\x1e\x05\xa9\x27\xfb\x20\x1f\xf2\x20\x03\xf2\xc5\x9e\x73\x6d\x79\xf4\xfe\xc7\xef\x21\x3a\xef\x02\x9c\xdd\xa7\x80\x5f\x09\x60\x67\xf7\x32\x0e\x9d\x68\x2e\xce\xcb\x08\x85\xcc\x1e\x41\xc7\xf0\xa5\x65\x05\xd9\xf8\xf4\x82\xd1\x82\x74\xde\xed\x71\x7b\x80\x55\xdd\x94\xd1\x48\xcc\xa9\x51\x2c\xa6\x32\x32\x28\x2a\x90\x3a\x40\x15\x90\xea\xd8\x3f\x9c\xa2\x67\x92\x01\x4c\x87\xd6\x8f\x80\x35\x39\xe6\xc0\x9e\x18\x62\x94\x8a\x39\x3d\xf5\xec\x3b\x3b\x57\xcd\x69\x7d\xf3\x21\x34\xb0\x78\x9f\x61\xe1\x98\xc6\x29\x3b\xf7\x1f\x3c\xb8\x60\xda\x2b\x95\x7b\x54\xe4\xa7\xd8\x1e\xdd\x39\x77\x87\x91\xd6\xde\x3c\xa5\x65\xaf\x2c\xdb\xfa\x0d\x18\x35\x60\xf4\xc8\xcd\xd3\x27\x8d\x98\x7e\xa0\x50\xbe\x57\xa1\xc1\x23\xdd\xe3\x38\x33\x31\x82\xf3\xac\x48\x18\x6c\x92\xd6\xeb\x73\x86\xc4\xfc\xfc\x50\x36\x67\xf5\x69\x85\xd2\xb2\x6c\x9b\xd5\x06\x28\xda\x40\x40\x8b\x8a\x8c\x20\x90\xfa\x22\x87\xd7\x1b\x08\x00\xfa\x01\x31\x2e\x9b\x1d\xce\x93\x20\x8d\x2f\xb7\xae\x55\x5c\xd8\x41\x40\xdd\x28\x3e\x7f\x2a\xf4\x87\x13\x64\xc1\xc8\xa2\xb5\x2a\x62\x7b\x2a\x5f\x99\xb6\xe0\xe0\xc1\x94\x41\xb2\x07\xfe\xba\x6d\x76\xf3\xae\xb7\x9f\xbd\x65\x4a\xb3\x82\x16\x9a\x53\x78\x60\xda\xc8\x49\xd3\x93\x23\x65\x1f\x5c\x37\xe5\x66\x2d\x6d\xbc\x63\xde\xce\x47\xbb\x2b\xfa\xb9\x01\xf8\xb8\x3f\xf1\xed\xb2\xc1\x6b\xca\x0c\xf8\x78\x01\x9c\x57\xb7\xcd\x64\x34\x0a\x3e\xf0\xc3\xdd\x01\x3f\x9c\xa3\xd1\xef\x4f\xd7\xe1\xca\x90\x74\x87\x43\xc2\x07\x6f\x88\x3a\xd2\x49\x93\x55\x5d\x54\x27\x26\xfb\xab\x52\x26\xa2\xa4\x54\xf7\xa7\xf6\xf9\xa9\x78\x11\xcf\xd5\x1a\x96\x92\xd8\x9b\x50\x4a\xbf\x12\x7d\xa9\xa5\x79\xcc\x2a\xc7\x03\x85\xe7\x77\xbc\xf1\x91\xf6\x09\x05\xe5\x2f\x6c\x1f\x9e\x91\x47\x3e\x63\x5c\xb6\x70\xee\x1a\x8e\xee\x7d\xea\x95\xd1\x43\x8b\xd6\xaf\x96\x7f\x93\x7f\x8f\xf5\x51\x05\xb4\xdb\xa7\xdf\xd2\xb5\x98\x8b\x8f\xee\xa6\x68\x14\x83\xf3\xfc\x41\x9d\xcb\xd3\x3b\xe2\xa0\xb5\x5a\xab\x49\x10\x44\x16\x6c\xa0\x24\xd6\x8f\x95\x10\x67\x66\x05\xe2\x0d\x81\xbb\xaa\x27\xa7\x47\xa5\x24\x10\x52\xa2\x38\xd5\x6d\xc5\x5a\x94\x60\xa2\x80\x8d\x17\xb2\x31\x4b\xe4\x7f\x4e\x68\x1b\x8b\x21\x94\x07\xb5\xc9\xa3\x51\x6e\x0b\xdb\xf5\xf2\x24\xf9\x2b\x0c\x11\xff\xca\x91\x23\xc0\x57\x8f\x81\x2c\x05\x80\xc6\x21\x1c\xe7\x50\x6e\x77\x86\xc1\xc8\x5b\xad\x3e\x63\x06\x9b\x99\xa5\x68\x41\x07\x68\x41\x97\xc3\x01\xd4\xa4\x28\x87\x03\xdc\x0a\x51\x8b\x25\x89\xea\xc8\x45\xa9\xc9\x0c\x95\x9c\xc9\x3b\x89\x38\x51\x95\xf1\x99\xf6\x24\x61\xd1\x14\x73\xcb\xc4\x2d\x1b\x5b\xb6\xcd\x5a\x64\x7a\xda\xfb\xb7\x83\x9f\xfc\xf0\xfd\xe7\x5b\xa7\xab\x5c\x84\x86\xcc\x9d\xf9\xe6\x7b\x9f\x9d\x9e\x3d\xc6\xb4\xeb\x08\xbe\xa0\x90\xbf\x95\x3f\xbd\xfe\xa8\xca\x3f\xcf\x2b\x3d\x53\x7a\xa0\xe3\x73\x40\xc7\x20\xd5\x23\x82\xcd\x31\x65\xb7\xa7\x65\x84\xdc\x4a\x28\xea\x06\x9d\x46\x3e\x48\x76\x3d\x4f\x68\xa8\xef\xb4\xe7\x3c\x71\xd7\x99\x45\xc6\x03\x24\x2f\xbe\x54\xaf\x32\x99\x7d\xb1\xd3\x27\x56\xad\xa1\x4b\xba\x61\xd8\xb6\xae\xe9\x5e\x03\xe2\xbe\x6b\xc7\x1c\xe2\x4e\xbe\xfe\xd8\x23\xfa\xeb\xba\x02\x58\x5b\x76\x1c\x76\xe5\x0c\x99\xc1\x6c\x7a\xec\x29\xcb\x41\xf0\x24\xf1\xbe\x24\xe0\x61\x3c\x7f\x2a\x93\x1a\x16\x49\xa7\x32\x21\x92\xd4\xa5\x6b\xb5\x16\x5d\xa6\x2e\x2b\x5b\x9b\x69\x4e\x0f\x04\x38\x10\x50\x87\x4b\x4f\xe0\x74\xd9\x6d\x4a\x1a\xc1\xd6\x01\xce\xd4\xaa\xf7\x70\xea\x7d\x8a\x7a\xef\x93\x72\xee\xc4\x9a\x16\xd3\xc9\x42\xf8\xae\x4a\x14\x19\x5d\xd9\x2b\xb3\xb6\x8b\xfc\xcf\xc1\xc9\x60\x12\x5c\xc9\x7a\x12\x44\xd2\x8b\xe3\x4c\x01\x1c\x12\x8f\x25\x69\xd2\xef\x4e\xad\x07\xfe\x18\x00\xf0\x67\x81\xae\xcd\x07\xfe\xc8\x94\x74\x06\x11\x38\x44\x0c\xe8\x8c\x99\x7c\x76\x8e\xdb\xe9\x24\x9c\xe1\xd4\x4b\x92\x6e\x58\xd4\x29\x39\xa5\x0c\x53\x86\x57\xf1\x85\x33\xd2\x45\xa3\x09\x74\x91\xa9\xe3\xc5\x0c\xf1\xe4\xc9\x75\xf3\x35\xe6\xdd\x91\xc3\x88\xb3\x4e\x62\xdc\x1d\x4b\x46\x7f\x65\x24\x2f\x27\x31\xf3\x54\x5a\x77\x6d\xbd\xf9\xe1\xfd\xed\xf5\x68\x59\x6c\x24\xb3\x58\x5e\x8b\x0e\x34\xbd\xb7\xe5\x8d\x65\x7d\x7a\x2a\x0c\xf4\xea\xfa\xa5\xdb\x66\x6c\x6b\x59\x8b\x46\xb6\xee\x94\xdb\xbc\xf2\xb6\x19\xc7\xa6\xcd\x2d\xbf\x61\xa0\xc2\x40\xbd\xd4\xfe\xd3\x8b\xcc\x83\xec\xcf\xe0\xb6\x05\x71\xff\x69\xba\xdd\x64\x32\x3b\x78\x33\x9f\x11\xb2\xe0\xb6\x2a\x33\x2a\xa6\x34\x94\x3f\xde\x7f\x8a\xc7\xe1\xb8\xe3\xfd\xa7\x65\xd7\xee\x3f\x55\xa2\x63\x75\xf8\x3d\x29\x2d\x23\x35\xa2\x38\xa0\xec\x50\xe7\x78\x24\x63\xc1\x88\x5b\xd7\xcb\x3f\x8e\x58\x90\x41\xd3\xcd\xec\x52\x01\x2d\xab\xc3\xed\xa7\xd3\xc7\x8c\x64\x67\xe3\xf6\x53\x79\x61\xa4\xef\xc8\x20\xdd\xb8\xc1\x53\x36\x40\xbe\x7c\xff\xb6\x5d\xf7\xed\xda\xb6\x35\xd9\xbb\xf3\x0b\xf8\xfc\x43\x22\x46\xca\x60\xb5\x58\x38\xde\xc0\xbb\xdc\x78\x8d\x7a\xbc\x77\xa7\x2c\x62\xa0\x38\x91\xa3\xbd\x0c\xee\xe1\xa1\xe3\x4d\x34\x57\xf7\x3a\x26\x99\x0a\xc7\xf4\x1d\x5b\x4d\x71\x98\x48\x76\xdd\x3e\xf3\xcc\x75\xa3\xf4\xab\x4c\xbb\x96\xdf\xfd\xd0\xde\x7b\x17\xed\xb0\xdd\xe4\xd8\x3c\x79\x14\x33\x57\x7e\xe7\x86\x41\x9a\x79\x37\xbf\xf2\x97\x33\xaf\xad\x98\xab\xdb\xb2\x09\xe8\xd9\x05\x1d\x66\xee\x04\xd8\xbc\x54\x0e\xd5\x12\x49\xc7\x0b\x16\x34\x66\x53\x86\xc7\x63\xca\x86\x60\x49\x23\xe4\xe6\xd1\x7c\xb6\x83\x75\xb1\xae\x4c\xa5\x47\xdb\xec\xf2\xbb\x68\x23\xe3\x72\x51\x7a\xbd\x84\xbf\xd2\x47\xcd\x66\xbf\x19\xbe\x32\x9b\x71\xcf\x76\x1b\x9e\x77\xee\xbb\xaa\x57\x33\x19\xff\x26\x47\x75\x39\x6b\xae\x1a\x77\x99\x91\xc3\xe3\x5d\xd7\xa9\xc8\xd8\x6d\x78\x94\x2f\xbe\xef\xcb\x21\xb3\x30\x43\x19\x82\x83\x6e\x99\x3b\x38\xe4\x1e\x31\xa0\xf7\xde\xdd\x18\x3b\xeb\xd6\x49\xa3\x9d\x2d\x1b\x4f\xd4\x36\x8d\xed\x32\x38\x6f\xc4\xc2\x29\x25\xe8\xa3\x2e\xd5\x15\xbd\x96\x4e\xdf\x7f\xfa\x75\x8c\xe9\xfa\xbd\x13\xfa\x6e\xdd\xd7\x63\x7c\xcd\x78\x5f\xa9\x77\xe0\x7a\x65\xe7\x04\x78\x2a\x1f\x31\xc7\x79\x07\x95\x06\xb8\xcf\x8e\x64\x64\x30\x16\xbb\xe8\x16\x75\x46\x8d\x59\x93\x9e\xee\x76\x5b\xf5\x66\x86\xcb\xcd\xb3\x18\xed\x3a\x56\x0f\x87\xc4\xfb\x01\xdd\x93\x51\x0d\xaf\xe7\xf5\x94\xf9\x0c\x69\xe0\xcb\x4a\xc1\x33\x5e\x9f\xa1\xce\x90\xb6\xa4\xa2\x47\xea\xda\x2d\xea\x54\x1d\xf5\xb0\x9c\xd9\x39\x42\x65\x35\x29\x35\xa9\xb6\x0b\x0e\x8b\x17\x75\xea\x73\x9c\x74\xff\xe1\x43\xfb\xc7\x47\x06\x8c\x7a\xf5\xce\xda\xe9\xdb\x2b\x6a\x2f\xdc\xb6\xb0\xf9\x91\xdc\xc6\x79\xf3\x27\x4c\x9e\xbc\x60\x2a\xfa\xe8\xa9\x23\x8f\x3e\x95\x7f\x77\x5d\x63\xdd\x75\x95\xdd\x5c\xa5\x8d\x43\x7b\xcd\x92\xbf\x3c\xc2\x9e\x3c\x8b\x26\xdd\xbc\xba\xa5\xe5\x96\xd5\xab\xf1\x22\x1f\x90\x97\x66\xf6\x27\xd0\x07\x9b\x23\x0e\x81\xf7\xa4\xd9\x83\x06\x8a\x0a\x86\xc4\x34\x1e\xb4\x41\x48\x12\x25\x11\x1f\x62\x46\x74\xa8\x34\x41\x5a\x20\x31\x7e\xa9\x44\xaa\x95\x18\x09\x77\xac\x4a\x12\xe3\x33\x7b\x90\x89\xc1\xf1\x95\x4b\x69\x5b\xf5\x91\x9e\x6e\x2d\x69\xf1\x8c\x08\x75\xf8\x0e\x59\x6d\x7e\x48\xed\x5c\x8d\xc7\x50\xe4\x4e\xf9\xda\x6d\x10\x1d\x66\x64\x5e\x35\x43\x12\x0f\x6a\x6b\xbe\x7d\xdd\xaa\xdb\xf4\x4d\x86\x3b\x06\x0e\x1e\x3c\xa4\x57\x8f\xda\xc1\xbd\xfb\x2e\xb5\xaf\x34\x6e\x59\xb0\x62\xd3\xce\xfa\x06\xba\x6d\xea\xd2\xe5\x2b\x75\x0f\xf4\xad\xed\xd1\x67\x6a\xaf\xea\xaa\xbe\xb7\xe9\x67\x37\x2d\x9a\xb4\xba\xd4\x34\x99\xec\x55\x41\x5f\x31\x7e\x4e\x26\x33\xd8\xf5\x16\x03\x69\xed\xb4\x3b\x74\xa6\x78\x23\x77\xf9\x71\x3c\xc4\x44\x69\xf6\xe2\x70\x2b\x84\x32\xc5\x24\xb5\xea\x30\x51\x90\x20\xa5\x66\xf6\x73\xd4\xc4\xfe\x6d\xcd\x33\x66\x34\x8c\xab\xf1\x56\x95\xe4\x6f\x67\x37\xc7\x26\xd1\x7b\xc6\x8d\x9c\x39\x4e\x33\x89\x2f\xeb\xd5\x67\x9c\x62\xeb\x8e\x52\x6f\x32\x7e\xf6\x0b\x02\x83\x91\x11\x04\x03\x25\x49\x76\x07\x0f\x7e\x1f\x61\x24\xc6\x66\xd3\x21\x9d\x89\xc0\xa0\x43\xed\x00\x43\xed\x5f\x3a\x79\x3c\x35\xa9\x37\x0d\xa4\x53\x0b\xfb\x6d\x95\x4e\x92\x9a\xaf\xa4\x7b\xa4\xc0\x40\x5f\x41\x5f\xca\x9e\x71\xf2\x4f\x2a\x10\xb1\x71\xa4\xb6\x5e\xed\xe5\xb5\xf0\xdc\x5c\x02\x53\x04\xe8\x72\x2b\xe9\xdf\xaf\x8e\x18\x34\x02\x25\x8a\x92\x20\x39\x5d\x8c\x01\xc0\x78\x0a\xd4\x24\x23\x58\x71\x17\xaf\x48\x09\xc0\xdf\xb5\xe1\xda\xf8\x5c\xe0\x94\x06\xae\xce\x8d\x49\xca\xdc\x22\xc6\x9e\xb7\x60\xc4\xf2\x45\xcd\xd7\x0f\x6b\x98\xde\xdc\xcc\x33\x9b\x06\xf7\x59\x7d\x1b\xee\x3f\x5a\x32\x74\xf5\x4c\xf4\xe7\x4b\x5f\x21\x71\xa1\x4f\x91\xbb\xf7\xd1\x57\xf4\xbf\x49\x8f\xac\x99\xea\x17\x31\x9a\x05\x3d\x6b\xc0\x4b\x25\x44\xc9\x68\x38\x85\xfa\x53\x63\x71\x7f\xcd\x71\x1d\x8d\xf7\x84\xdf\xd0\x16\x15\x18\x86\x53\x9a\x55\xf0\x09\xa9\x37\xca\xf1\x33\x72\x26\xce\xa8\x32\x7e\xb1\xcc\xe0\xdd\xb6\x05\xc3\x87\x37\x0d\x1b\xd6\xd4\x84\xbe\x42\xb3\x1b\x50\x8d\xfc\x52\x83\xbc\x93\xb9\xbf\xa9\x09\xcf\x0a\xcb\x87\xf7\x2b\x7d\xbf\xee\xa7\xe0\xb5\x2c\x87\x92\x8f\x97\x52\x37\xd3\xe6\x37\xe1\x26\xa7\x18\xf7\xff\xee\x77\x14\x3c\xe1\x77\xf4\x54\x38\x62\x10\xf4\x7a\x50\x8c\x06\xe3\xff\x46\xab\xe3\x04\x9d\x04\x4a\x2a\x3a\xa9\xc8\x50\x0c\x1a\x4e\x9d\x65\x9a\x80\x8e\x22\x68\x30\x3f\x9e\x9e\xe2\x66\xd2\xed\x76\xa3\xe0\x37\x32\x3a\x46\x17\x08\x7a\xd3\x15\x6a\x7a\x81\x9a\x46\x07\xef\x50\xb4\xb5\x8e\x8f\x68\x4d\xfd\x79\x9e\xd2\xe0\x6e\x41\x8a\x92\x54\x15\x56\x99\xdc\x7e\xd6\xb1\xf6\xd6\x99\xb4\xf3\x44\x73\x75\x43\x89\xcb\xe4\x1c\xc2\x88\x44\x61\x59\x31\xd5\xbb\xcf\x5b\x35\x65\x4e\xcb\xca\xc6\xc6\xa6\x95\xdd\x7a\xae\xae\x28\xac\x7e\x78\xe5\xd9\x49\xd1\xe8\x18\xfa\xe9\xd8\xf5\x93\x3d\xb3\x37\x4e\x1d\x3c\x40\xcc\xcb\xcb\x29\x66\xa7\xe2\x93\xc0\xfc\xf8\x09\x75\x96\xfe\x16\x70\x30\x50\xb9\x27\x71\x1b\x91\xce\x68\xd2\x9f\x21\x43\x24\x94\xa1\x64\x9a\x38\x5c\xf1\xf6\x24\x35\x6e\x25\x7e\x1f\xf0\x1e\x3d\x36\x27\x2b\x33\xa3\x30\xe3\x6c\x33\xba\xa7\xa6\x44\xb7\x48\x77\x81\xbd\x11\x3f\xf7\x53\x78\xee\xd7\xf0\x40\xb2\xfb\x2d\xf5\x9e\x45\x9d\x87\x69\x84\xe7\x62\x16\xe7\xd5\x81\x43\x7c\xca\x3c\xcc\xd4\xfb\x16\x94\xbc\x6f\xb1\xe3\x96\x62\xf4\x69\x20\x63\x54\x9f\x95\xdd\xcf\xe6\x86\x50\x95\x66\xe6\x08\xd6\x71\x79\xf4\xcb\x17\x04\x82\xcb\x6d\x20\x5b\x3d\xe0\xbc\xf1\x7c\x35\x16\x21\x8a\x17\x68\x4c\x62\x44\xb1\x84\xc4\xe8\xea\xf9\x6a\x64\x6d\x23\xd3\x43\x1e\xbe\x02\x1c\x27\xcc\x36\xf3\xb1\x0f\xb7\x86\x3a\x43\xfa\xb8\x8b\xa8\x86\x88\xd5\x01\x12\xea\x15\x04\x4d\x51\x66\x66\xae\x46\x62\x8b\x4b\xb2\x0b\x4e\x11\x88\xb3\x51\xc5\x53\x01\xaf\xc3\xe3\x31\xa8\x4d\x69\x1e\x50\xcd\x56\x32\x3f\x46\x52\xdb\xca\x53\x2e\xda\x3b\x4f\xf2\x4d\x5e\xd9\xfc\x71\x83\x77\xa2\x85\x9a\x79\x07\xb7\x1e\x36\x91\xff\x63\x17\xf3\xb8\xcb\x7b\xf8\x24\x2b\xd3\xfb\xbe\x85\x53\xcf\xe6\x97\x67\x15\x0e\x63\x5e\x9b\x4b\xda\xb9\xd1\xe7\x73\x1b\x9a\x17\x75\x6c\xf6\x8e\x3d\xf2\xa6\x61\xb1\x71\x16\xce\x2d\x03\x5e\x83\x80\x3e\x21\xf0\xdc\x2c\xe9\x6e\x0b\xca\x00\xa1\xd0\xe9\x32\xdc\x4c\x66\x56\x48\xe3\x21\xed\x93\x7e\x87\x9f\x48\x87\xc5\x6c\x70\xe0\x96\x2b\xbd\xd2\x72\x75\xcd\xf6\xc9\x70\xa7\xee\xc9\x90\xf4\x47\xad\x93\xfb\x6b\x06\x03\xe8\x2b\xb2\xa7\x0d\x04\xb8\xe9\xc0\xac\xd1\x0b\xa7\x36\xe1\xaf\x70\x9b\xe9\xbc\x51\xb8\x6d\xf2\xd2\xdf\xd0\xc1\x41\x3d\xfa\x0e\xbc\x6e\xc8\x4d\xdb\x20\xd8\x83\x6f\x95\xae\x49\x65\x57\xef\x19\xe6\x23\x38\x0f\x7c\x67\x61\xe4\x1c\x0e\x8f\xdf\x64\xf4\x1b\x03\x41\x97\xb7\x97\xc2\x3c\x2e\x00\xd2\x04\x34\xd7\xe2\xd6\xdb\x63\x51\x4e\xfb\x0c\xee\x06\xc7\x0a\x3d\xd9\x13\xd8\xb1\xfd\x3a\xa5\x15\x3d\x79\x06\x09\x7a\xa3\xdb\xd9\x25\xa4\x25\x7d\xe5\x82\xe6\xeb\x46\x8d\x9e\x71\x36\xb7\x32\xa3\xa4\x8e\xbd\x6e\xbb\x4d\xe9\x47\x97\x59\xf4\xf9\xc2\x11\xcd\x8b\x62\x5f\xbf\x69\x58\x64\x98\x85\x61\xfc\x19\x60\xfc\x40\xed\xa1\x37\x93\x1e\x7a\x8e\xb2\x50\x7f\xd8\x42\x2f\x00\x78\xca\x68\xb3\xce\x2d\xf4\xa9\xee\xa5\x2d\x21\x67\xd7\xec\xa1\xbf\xae\xae\xc0\x9b\x9f\x7f\xf6\xba\x91\x0d\x33\x56\x62\xb6\x28\x9c\x57\xdf\x3c\x1f\xdd\x33\xcb\xb0\x44\xf7\x26\xdd\x13\x03\x98\xda\x43\x8f\x50\x2f\x6c\x7b\xd8\xbf\x93\x3d\xcb\x66\x3d\x1e\x75\xa6\xe1\x38\xde\x04\x62\xa9\x37\x9f\x05\xc0\x18\x42\x44\x0d\xfc\xcb\x11\xda\xa9\x9d\xa8\x35\xa9\xd7\x58\x5a\xe4\x70\xe2\xfa\x81\x10\xca\xce\xc1\x13\xfa\xd0\x49\xd4\x43\x72\x30\x4b\x16\xc9\x2f\x59\x02\xdc\x62\xf6\xef\xb2\x37\xad\xb8\x01\xbd\x1d\xe3\xd1\x37\x69\x91\xc5\x72\x21\xfd\x3b\x19\x70\xa8\xf4\xef\xff\x02\x47\x24\x12\x3f\xdc\x64\x33\x99\x38\xbb\xd1\x08\xc2\xea\x72\xdb\x4c\xa4\xc5\xd3\x66\x03\x6f\x46\xea\xd0\xd0\xaf\xbb\xaa\xa1\xbf\xf3\xfc\xb7\x8e\xbd\xfd\x1d\x0b\x84\x92\xdd\xfd\xf2\xf1\xe9\xe3\x05\x79\xb1\x30\x61\xea\x94\x89\x02\x6a\x15\xc6\x32\xb3\xe4\xc5\xcf\x9f\x43\x5b\x5f\x94\x0d\xcd\x2d\xab\xd7\xd0\xe3\x9a\x57\xb7\x2c\xc7\x70\x82\x4e\x7f\x9c\xe8\x2d\x07\x95\x4e\x8d\x8b\x58\x9c\xac\x4d\x6b\x36\xbb\x79\x4a\x34\x18\x28\x96\xf1\xfa\x84\x76\x50\xe7\x56\x0f\xef\x21\x8e\x83\x96\xc7\xbd\xb5\x36\x37\x72\x93\x1f\x4d\x08\x0b\x0d\x51\xe6\x71\x5f\x26\xd9\x42\x92\x2c\x5d\x50\xb4\x39\xee\x93\x12\xb3\xe0\x3b\xbc\xc6\x97\x93\xc0\xf7\xcc\x91\x7a\xa2\x2c\xd1\x09\x72\x44\x17\xb4\xdc\x8a\x8c\x0b\x6f\xdb\x20\x7f\x73\x67\xff\x41\x03\x6f\x90\x17\xb4\xde\xd0\xe7\x2c\x0a\x8a\xcf\x9d\x44\x53\x33\x91\x28\xff\x60\x7a\xfe\xa4\xbc\xd3\x27\x7f\x4c\x3f\x72\xeb\x6d\xc6\xd8\x51\xf3\x6d\x5b\xe4\xcb\x99\xf4\x10\xdb\x36\xa2\x0b\xab\xa9\x67\x99\x9d\xe0\x77\x96\x51\xb3\x22\x16\x2a\x27\xc7\x6d\xb4\x59\x39\xa3\xb5\x34\x58\x1a\x2c\x0f\x17\xe7\x29\x2a\x0c\xde\x1f\xd1\xb9\xd3\xb5\x1c\x2b\x66\x67\x66\x32\x24\x1a\xa2\xa8\x4c\x1c\xb7\x89\x94\x03\xff\x64\xb3\x89\xea\x1c\x28\xe5\x0e\x8d\x24\xc0\x9c\x35\xae\x64\xf3\x65\x0d\x39\x83\xf2\x44\x06\x03\x57\xef\xe7\x24\x6f\xcd\x54\x77\xda\x8f\xd4\x16\xd2\x44\x36\x03\x98\x1a\xed\x17\x27\x8f\x3e\x1e\xec\xb1\x62\xc6\xb8\xf2\xdb\x36\xaf\xdc\x6e\x9d\x6f\xbf\x67\xf8\xd0\xaa\x5e\x75\x4d\xa3\x2b\xee\xdd\xbe\x78\xe8\xf0\x40\x66\x41\xc6\x69\xba\xad\x47\xcd\xb2\xcc\x22\x7f\x20\xbd\x6a\x68\x97\x99\xf3\x1a\xa6\x98\x66\x85\xab\x72\xcb\x2d\x8e\x60\xd5\x88\x9e\x73\x97\xe6\x2f\x9c\xa6\x59\xa4\xb9\x80\x4c\x8a\x3d\x5b\x0a\xe7\x37\x1a\xce\x8f\x4c\x66\x34\x3b\x70\xa2\xc8\xe5\x36\xc6\xe7\x17\x1b\x49\xd0\xc0\xa9\x23\xee\x2a\xa9\x4e\xfb\x94\xb0\x85\x25\x1a\xa0\x53\x2a\x43\xb2\xa1\x0b\x65\xf9\xa5\x81\xcc\x3c\xeb\xb4\xe9\x37\xf8\x42\x05\x55\xe5\x67\x8d\x37\x4a\xbe\xae\x83\x98\xea\xa6\xb5\x86\x65\xd6\x81\xd1\xcb\xaf\x92\x3d\x47\xe8\x29\x78\xbf\x8b\xbb\x0d\xf4\xc0\xc8\x88\xa8\xa3\x28\xbb\xdb\x6d\x61\x4d\x26\x7f\xc0\xa5\x78\xfa\xc7\xa3\x76\xab\xd4\xcb\x08\xf2\xa5\xa7\xd2\x09\x73\xeb\x81\xda\xc9\x89\x1a\x95\xc9\x3c\xc6\x8b\x9d\xbc\xd0\x70\x87\xb9\x1a\xc4\xf0\x5f\x63\x88\xc0\x91\xc2\xd2\xac\xcc\x50\xbe\x76\xc7\xc8\x28\x19\x25\x50\xe8\xcb\x45\xb7\xbc\x64\xb8\xd1\x98\x5b\x33\xf4\x31\x14\x1b\xf7\xe8\xa3\xe3\x64\x7f\x97\x42\x1d\xbc\xf3\xbf\x10\x7f\xbd\x03\xf6\xc0\x05\xb1\xfc\xd8\x88\x0d\xbc\x43\x9b\xcb\x6b\x60\x18\x0d\x84\x9b\x19\x21\x9f\xc6\x8e\x47\xdc\x82\xa3\xcc\x21\x87\x43\xcf\xb8\x70\x8b\xba\xa8\x84\xf3\x06\x51\xb1\x0d\xff\x3f\xd6\xde\x04\x4e\xaa\xe2\x78\x1c\xef\x7e\xd7\xdc\xf7\xbd\xb3\xb3\xb3\xb3\xb3\xb3\x37\xec\x31\x7b\x72\xed\x20\xd7\x82\x08\x08\x28\x0c\x0b\xec\x8a\x08\x48\x44\x2e\xc1\x08\x2a\xa0\xe2\xcd\x25\xa0\xa8\xa0\xa2\x68\x04\x5d\x50\x19\x11\x14\x05\x15\x8d\x0a\x78\x24\xc6\x68\xd4\x44\x63\xd4\x6f\x94\xe0\x19\x12\x95\x7d\xf3\xaf\xee\x77\xcc\x9b\xd9\x45\xf2\xff\x7c\x7e\xc0\x1e\xbc\xa9\xae\xaa\xae\xae\xaa\xae\xaa\xee\xd7\xdd\x57\xdd\xda\x47\xe2\xd4\xdc\x0d\x70\x99\x29\x42\xd9\xfe\xa6\x9e\x38\x40\xc2\xe7\xb8\x43\xdd\x3a\x86\x9f\xc3\x93\x96\x8d\x1c\x49\xbd\xee\xe5\xe7\x2f\x9f\xdf\xd6\x86\x5d\x93\x67\x8b\x3b\xcf\x81\x09\xe2\x00\x1e\x21\x1e\x98\xbe\xf7\xc1\xeb\xce\x6f\xbd\x76\xed\xa4\xe9\x78\x44\xf7\x94\x15\x8b\x6d\x83\x2e\xbf\x80\xca\xdb\x0d\x7d\xd8\x0f\x7d\xa8\x45\x23\x12\xee\x8a\x88\x43\xcf\x55\x7b\xcd\x6c\x49\x7e\x35\x5b\x5d\x17\x2f\x35\x5b\xcc\xd4\x2c\x8b\x2d\x52\xac\x15\xc8\x4e\x17\x73\x37\x3f\x2b\x2f\xc0\x37\xd4\x0f\x62\x94\xc4\x08\x92\x21\xba\x7c\x44\x53\x24\xaa\xd7\xf4\xce\x7e\xba\xe9\x9d\x1c\xf3\x33\x6b\xcb\xb3\xc5\x15\xc5\xa1\x50\xf3\xc4\x01\xe7\x86\x8a\x42\x8b\x2e\xea\x5c\x0c\x3f\xce\x1d\x30\xb1\x39\x14\x82\x0f\x0e\xe0\x8f\xf7\xde\x39\x68\xd2\x90\x86\x90\x37\x34\x63\x78\x6b\xf5\xf0\xc1\xc3\xfa\x2e\x5c\x7d\xc3\xa2\xbe\xc3\x06\x0f\xaf\x6e\x1d\x3e\x03\x1e\x37\x0c\x99\x34\x68\x73\x8a\xe6\x06\x1f\x83\x7f\xfe\x1c\x7c\x0f\xb9\x8f\x9c\x33\x99\x39\x33\xb8\x66\x4e\x62\x5d\x9f\xc3\x7a\x2f\xe7\x32\x92\xc3\x56\xe8\xa9\x8c\xb3\xee\xd8\xb4\xfc\xb1\xc7\x96\x6f\xc2\x1f\xaf\xbd\x1f\x7f\x28\x86\x5e\x7e\x19\x7f\x26\xc6\xee\x5f\xab\xa1\xe1\x26\x34\x0c\x82\x15\x02\x30\x8f\xd7\x41\x0f\xae\x60\x91\x99\xd2\x60\x7b\xa5\x21\xbd\xff\x2d\xcf\xe9\x0e\xf2\x86\x06\xa4\x88\xb7\x6f\xdf\xb8\x71\xf5\xf2\xd1\x93\x9e\x28\x8f\xad\x8c\x54\xb2\xd7\xfc\xfe\x83\x8d\x0f\xe2\x3f\x8a\xe5\xb3\xe7\xe0\xfe\xd3\x5e\x1a\xdd\xf6\x1a\xea\x71\xee\x81\xde\x80\x11\x4f\x6e\x72\x36\xb0\x46\x13\x6b\x20\xc9\x0e\x0f\x40\x35\xe4\x55\xdc\x1e\xaf\xe1\xe2\x28\x5b\x6a\xc5\x6c\x94\x29\xda\x80\x4d\xf2\xb9\x07\xdc\xe7\xdd\x3c\xfe\xee\x77\xf5\x43\xba\xff\x06\xb8\xeb\x01\xf7\xdd\x14\x77\x22\x61\xd5\x33\x82\x8e\xc5\x02\x36\x19\x05\x7a\x55\xfe\x48\x7a\x4c\x79\xcd\x5e\xac\x43\x3a\xa5\x22\xd2\x37\x53\x5a\xcb\xdd\xf8\x2e\xd7\xce\xe0\x5f\x3d\x7e\x49\x4c\x32\xb5\xe2\x20\xfc\x21\xfe\xaa\x93\x69\x99\xd1\xd9\xfd\xfb\x19\x34\x16\xf9\x11\xe6\xf9\x0f\xa8\xfc\x26\x25\x1c\x2e\x9b\xc5\x24\xb8\xdd\x56\xa7\xc5\xe9\xf1\x3a\x6d\x76\x9b\x72\x6a\x59\xcd\x5e\x8b\xcb\xec\x92\x67\x32\x33\xad\x89\x29\xe1\x74\xbd\x66\x49\x21\x97\x07\x89\x0d\x35\xbc\x06\xdb\x50\x58\x62\x93\xa1\x92\x48\x7e\x6d\xf1\x43\xa2\x4b\xc3\xda\xdd\x2d\x35\xfa\x85\x86\x77\xda\x09\x87\x17\x75\xbf\x46\x72\x3b\x0b\x9e\xc7\x1e\x02\xfe\xbc\x10\x2d\x2d\x4e\xf8\x8d\x81\x00\x38\x46\xc1\xeb\x75\xda\x43\x82\xe0\xf0\xd8\x3d\x85\x11\x8f\xd3\x25\xbf\x54\xef\x93\x8e\xfe\xb2\xb1\x61\x96\xb1\xb0\x2c\x6b\x83\xc4\xb8\x26\x15\xb0\x7b\xe5\x53\x6d\xcc\x64\x61\x99\x84\xb2\x47\xe4\x0d\xbb\x60\xe5\xd2\x4d\x9e\xb9\x6f\x78\xa9\xd7\x10\x60\xe5\x4c\x9b\x4a\x4c\x2a\x49\x51\xb9\x03\xb1\x22\x9d\x7c\x68\xac\x79\xf8\x8a\x73\xc6\x4f\x99\x3e\xe7\xf1\x82\xbc\xe9\xb1\xb7\xf0\x8b\xe2\x14\xa6\x06\x3a\xb3\xfc\x9c\xf3\x97\xd4\xd7\x94\x30\xa3\xaf\x9a\x3f\xb9\x6d\xe2\x85\xfd\x86\x54\x8e\xbf\x88\x69\x26\x72\x5f\xb5\xaa\xb0\x24\x3f\x4c\xcf\xa5\x01\xd9\xef\x81\xbe\x05\xd0\xf4\x84\xdb\x62\x66\xbd\x7e\xc6\x29\x08\x8c\x37\x60\xe6\xf3\x82\x3e\x96\xf5\xd2\x28\x82\x65\x0d\xc8\x60\x93\x8e\xba\xb5\x18\xf6\xe3\xfa\xbd\x4c\x00\x05\x94\xe1\xaf\x51\x6f\xa9\x3d\xc3\xf5\x29\x52\x5e\x40\xce\x23\xf4\xf4\x28\x93\xe0\x08\x1e\xc4\x24\xc5\x5f\x6e\xba\xf3\xd9\xad\x37\xef\xb0\x5d\x55\xf0\xe8\x25\x8b\x96\x2f\x68\xc6\x26\xb1\x88\xfb\xfc\x5a\xd1\xb5\x7b\xcd\xbd\x2f\xdd\xb2\xca\xf0\xd4\x6d\x4b\x2e\x5f\x71\x09\xb6\x93\xb8\xa7\x12\xff\x9d\x7d\x50\xe0\xe9\x39\xb7\x7e\x34\x2f\x61\xb5\x79\x3c\x82\xd5\xeb\x05\xbb\x0b\xe4\x79\x08\x9b\x89\x48\x72\xbe\x67\x85\x67\x8f\xe7\x90\x87\xb3\x79\xc2\x9e\xb1\x9e\x0e\xcf\x7c\xcf\x3a\xcf\xfd\x1e\x9d\x89\xf5\x78\x58\xbd\xde\x29\x2b\x92\x1e\xc7\xc1\x48\x4d\xd9\x46\xaa\xb9\x40\xb3\x67\x58\xc4\xc8\x6b\xaa\xce\x9c\xb8\xe8\xc1\x1d\xf7\x6e\x7c\x18\x0f\xdc\x71\xa7\x78\xf8\xa2\x24\x27\xae\x61\x27\xcf\xb8\x68\x32\x87\x17\x73\x17\xb0\xff\x16\x7f\x10\x7f\xc6\x1c\xb6\x31\x76\xf1\xa7\xee\xc1\x2f\xbe\xf1\xe2\x1b\xec\x6f\x9e\x7d\xfd\x75\x1a\x8b\xb3\xe2\x13\xdc\x4b\x78\x9c\x50\x0e\x36\x4b\x6e\x2e\x1c\x9c\x28\x24\xc6\xcc\x33\x7a\x8b\xd1\x68\x15\xf4\x7a\xab\xde\xb0\xbe\x5d\xaf\x67\x13\x24\x95\x34\xad\x6f\x37\x6e\x52\x0a\x90\x79\xc7\xeb\xaa\xb5\x37\xc0\x2a\x27\xc2\xb0\x0d\x71\x97\xa7\x09\x92\x57\x1e\xbe\xaa\xfe\xf0\x42\x47\xe3\x43\xdd\x9d\x0f\x03\x95\x73\x62\xe2\xb3\x91\x3d\xfb\xf7\xef\xde\xbf\x1f\xe8\xde\x00\x4f\xae\xd1\xd2\x65\x58\x1e\x84\x91\x43\x97\x49\xf0\xfc\xff\x46\x97\x6d\x70\xc5\x3d\x6c\x4c\xa6\x7b\x7b\xc7\x0b\x7f\xc0\xc1\x87\xba\x75\x40\x38\x82\x87\xc7\xc4\x17\x64\xc2\xf4\x0c\xdb\xd5\xe2\x18\x34\x2b\xbd\x0b\x55\x91\x5b\xae\xca\x99\xb0\x59\x57\x5c\x8c\xcc\x0c\xe7\x75\xe4\xe5\x79\xfb\x94\xeb\xc2\x0e\xae\x0a\xb9\xfc\xa8\x3a\x7e\xac\x0e\xd4\x08\xd3\xbd\x36\x9a\x73\xde\x8b\xa4\xf9\x84\x4c\x1e\xe4\xa7\x7c\xd4\x83\x34\xaf\x90\x49\x84\xce\x2f\xbe\x29\x7b\x23\xe5\x11\xf8\x07\x93\x46\x6d\x65\xb5\x61\xc0\x80\x4b\x0b\x63\x85\x21\x98\x59\x8a\x43\xa5\x75\xe2\x98\x84\xdd\x6d\x35\x0a\x06\xbd\xd1\xee\xb4\x79\x9c\x76\x83\xc3\x5d\x13\x19\xe4\x0f\xb9\x2c\x7a\x41\x6f\x76\x3b\xec\x2e\xb3\x41\xa7\xb3\x33\xc0\xaf\xb8\x93\xfb\x0c\x4f\xe3\xff\x24\xdd\xe1\x61\x34\x18\x5c\x6e\x17\x5a\x97\x74\xb9\x8c\xa4\xa8\x68\x14\x04\xcb\xda\xa4\xb0\x5d\x3e\xbf\xa9\x52\x92\x4e\x5c\xbe\x5e\xc6\x4a\x5e\x94\x91\x0e\x70\x1a\xc4\xf4\xc7\x78\x5a\x51\x73\x67\xe7\xec\xc4\xbc\x1b\x57\x9c\xd3\x52\x3f\x65\xda\xa5\x43\xa2\xfc\x94\x58\x9f\xd8\xea\x79\x2d\x23\xca\x6a\xca\x80\xd6\xab\xdc\xbb\xb8\x8a\x7f\x17\xc6\xa5\x3a\xe1\xc7\x1c\xc7\x40\x5c\x21\x48\x67\xf4\xb3\x06\x96\x67\x18\x76\x5d\x92\xa1\x77\x0a\xda\x8f\x90\xaa\x24\x8e\x2b\xb7\x6d\x61\x9e\x9c\x02\x84\xab\xc4\xef\xc4\x9d\xb8\xdf\x09\x7e\xce\xa6\x95\x2b\xa9\xbc\xc5\x77\x01\x67\x3f\x8a\xb3\x34\xe1\x51\x70\x62\x6e\x1d\x75\x54\xd5\xe0\xa7\x30\xaa\x3e\x3e\xad\x52\x8b\x2b\x12\x6b\xf2\x45\x70\x3f\x71\xa7\xf8\x5d\xe2\x04\xee\xc7\xbd\xbb\xe9\xb2\x95\x14\x57\x86\x3f\x19\x17\xcf\x33\x02\x87\x01\x17\x17\xe6\xaa\x39\x96\xbc\x7e\x93\x8d\xcb\x55\x0a\x7c\xf1\x27\x4e\x88\xaf\xe2\x49\xd8\xc6\xbd\xbb\x72\xe5\xa6\x33\xf1\xc4\x83\x58\xe5\xbe\xf2\xd0\xc9\x23\x39\x3c\xe9\x4a\x63\x84\xa7\x57\x4f\x24\x60\x0a\x9c\xc4\x4f\x5c\x79\xd9\x26\xca\xd3\x0c\xc0\xb5\x1d\xc6\x47\x47\xf4\x89\xd1\x09\xac\x8e\x45\x1c\x87\xf4\x90\xfd\x28\xd8\x04\xda\x49\x18\x95\x23\xd3\xea\xe8\xa6\x57\xb9\x7a\x4d\x11\xeb\x4a\x75\xd0\xdd\x26\xbc\x7d\xe0\x27\xa7\xc4\x77\x07\x9e\xf8\x9a\x1f\x3c\x6f\xd9\xb2\x4d\xf3\x14\xf9\x65\xf0\xd7\x24\xfc\x3c\xc2\x1c\xe2\x74\x40\x43\x2f\x60\xa5\xd3\xc0\x2d\xaa\xae\xab\x3b\x3e\xad\xae\x2e\x1b\xb7\xab\x14\x98\xf6\x35\xf9\x96\x7e\x7d\x62\x20\xae\x3a\xf5\xc9\x40\xd2\xff\x79\x9b\x96\x2d\x9b\x07\x76\x30\x5f\x9c\x84\x2e\x4b\xbf\x01\x9e\x2c\x3f\x61\x32\xf2\x0e\x07\x72\x59\xc0\x1e\x59\x54\xfd\xee\xb1\x38\x61\xb2\x8e\x4e\x60\x2c\xdd\x86\x4a\x92\x54\x65\x1f\xf6\x5a\x76\x22\xc7\xf8\x9a\x6a\x8b\x9d\xa1\x81\x0d\xe2\x24\xec\x1f\xe4\x1d\x55\x13\x61\xa7\x70\x23\x9a\xb6\x02\xde\x2b\xb8\x6b\xd0\x1a\x21\x02\x2e\xb1\x28\x61\x85\x01\xe2\x90\x4e\x20\xa7\xb8\x23\x96\x9c\x54\xfe\x66\x1d\x9d\x5b\x00\xbb\xc4\xa1\x47\xe7\xf3\xc4\x1a\xd6\xec\xda\x25\x7e\x29\x44\x16\x75\x76\x2e\xda\x39\x1e\x31\xe2\xff\x89\x17\xe2\xae\xf4\xcf\x80\xc3\x02\xd9\x65\xb1\x5e\x67\x32\x19\xcc\x90\xe1\x82\xfa\x5b\x39\x5a\x7d\xb6\x5a\x20\xf2\xe0\x4c\x9c\xde\x00\x7f\xc1\x67\x09\x12\x6e\xf2\xbe\x37\x39\x6f\x27\xee\x90\x8e\x9b\x8e\x67\xca\x34\x74\x52\xab\xad\xf1\x81\x8b\x68\x2a\x6d\x80\x58\x24\xee\x6b\x8a\x63\xf1\xcb\x5d\xbb\x98\xfc\xf1\x3b\x09\xe9\x3d\xd2\x0f\xf1\x61\x1c\xd8\xb5\x8b\xde\xef\x83\xc8\xde\x71\x7e\x98\xb3\x04\x15\x23\xe4\xd0\x31\x5f\x30\xe4\x62\x79\xcb\x33\x2c\x83\xdc\x56\x4e\x17\xc3\x95\x0d\x0d\x04\x6e\xa5\x58\xc3\xdd\xcc\x8d\x01\xb8\xa1\x32\xdc\xd0\xf4\x07\xc8\xfe\x24\xcb\xec\x4f\x1f\x4e\x35\xd6\xd8\x58\x09\x94\xc0\x3e\x88\x10\xb7\x52\x98\x05\xb0\x31\x0a\x4b\xde\xca\xb9\x07\x79\x52\x6c\x11\x5f\xc2\xee\x4f\xbf\x97\x2a\x2c\xe2\x11\x01\x47\x95\x14\xf7\xde\xf4\x09\xee\x1c\xfe\x18\xc0\x0f\x43\xc8\x2e\x30\xf7\x8c\x46\x12\x1e\xf1\x10\xb7\x92\xf2\x46\xf1\xe8\xbf\x63\xdd\xf0\x81\xf5\x00\x62\xd3\x27\x54\x1c\xa4\x3d\xc0\xa9\xed\x09\x1c\xf3\xbd\x04\xc7\xa4\x3f\x4d\x45\x63\x46\x05\xee\x41\xf1\xa0\x16\x1f\xf3\x3d\xb3\x52\xc1\xf7\x4d\x2a\xa2\xc5\x77\x50\x8b\x0f\xe0\x9a\x14\x7c\x07\x53\xc5\x19\x7c\x0b\xc5\xa1\xdc\x52\xe1\x5e\x80\x2b\x01\xbe\x4b\x0d\x43\xf0\x51\x02\x8f\x96\x61\x12\x7b\xe5\x27\x60\x92\xe6\x4b\x98\x60\x24\x64\x06\x39\x2e\xf5\xe5\x99\xa9\x38\xa5\x6e\xd3\xbb\x4f\xa1\x7d\x33\x9f\x82\xf6\xc3\x49\x7b\xb4\x14\x6d\x97\xdb\x9f\x2f\xb7\x0f\x3a\x4a\x98\x48\x2c\x82\xdc\x31\x3c\x3f\x58\x40\x7e\x68\xdb\x13\x39\x5f\x42\xe5\x5c\x2a\xc9\x39\xfd\x3e\x95\x33\xe3\x01\xb2\xfb\x81\x57\x97\x27\x4b\xce\xb7\xa6\xbf\x20\x77\x49\x00\xfc\x08\x80\x07\x39\x1f\x44\x48\xf7\x14\x03\x03\xdf\xda\xa0\xc8\xfb\x12\x2a\x9f\x52\x59\x8e\xff\x54\xfa\xfd\x96\x8a\x8b\xe0\x01\xb8\x0c\x1e\x02\x77\x12\xe0\x4c\xfb\x18\xbe\xb8\x44\x70\x52\x82\xf2\xf8\x1d\xd4\xe2\x03\x39\x4e\x56\xf0\xbd\x9b\x72\x6b\xf1\x1d\xd4\xe2\x03\xb8\x89\x12\x3e\x26\x96\x83\xaf\x25\x0b\xdf\x97\xcc\x85\x0a\xbe\xb7\x53\xde\xa0\x06\x5f\x4b\x16\xbe\x2f\x29\x5d\xc0\xc7\x95\x56\x65\xe3\x9b\x94\x85\xef\x24\xd3\xa9\xe0\x7b\x3f\x15\x70\x69\xf0\x4d\xca\xc2\x77\x92\x99\x2a\xf7\xb7\xa2\x38\x0b\x1f\x8c\xc7\x0c\x5d\x25\xc0\x95\x51\xb9\x9c\x66\x96\x91\x1c\x6e\x1f\x83\x5d\x30\x20\x78\x7f\xfa\x27\xe8\x35\x36\x49\x86\x22\xdb\xd5\x6a\xd0\xfd\xe1\xc2\xef\xa1\x4d\x1b\xd5\x81\x21\xe9\x97\xb1\x0b\xc6\xe6\x56\xf0\x78\xbe\x84\x85\x65\x8a\x1c\x25\x2c\x83\x8b\x22\x16\x57\x56\xbb\x5c\x5a\xdd\xcc\x0d\x88\xb6\x60\x30\x19\x7d\x0c\x53\xb4\x96\x12\xea\x8d\xd6\x52\x34\xf0\x7f\xa3\x05\xfd\x9f\x41\xe5\x54\x26\xf7\xff\x4e\xda\x7f\x6c\x73\x59\x24\x22\x32\x7e\x80\x1b\x4e\x7d\x44\x9b\x0c\x77\x85\x24\x27\x43\x51\xbe\xc5\x9d\x2d\x77\x2d\xbe\xef\x98\x4d\x12\x3e\xa7\x27\xf2\x6b\xf8\xbe\x63\x2e\x93\xf0\xe9\x8a\x6b\xb2\xf1\x0d\xe5\x66\x08\x3b\x25\x7c\xd0\xaf\x65\x78\x09\x85\x27\xbb\xc9\xfe\x4d\xec\xa1\x90\xda\xc3\x3f\x52\xd1\x4a\x64\xd4\xd8\xc3\x6a\x68\x37\x9c\xda\x5f\x9b\xdc\x4e\xb2\x8b\xbb\x61\x92\x75\x25\x4c\x6c\x35\x88\x83\xab\xeb\x27\x49\x43\x6e\xf3\x12\xc8\x7d\x20\xb5\xb9\x72\xd9\xb7\xd5\x82\xcd\x01\x34\xb6\xf0\x25\xd8\x6f\xb2\xe8\x0c\x0a\x34\xdd\xe3\x44\xcf\x38\x11\x66\x41\x2c\x9d\x8f\x26\x24\x8a\xf2\x03\x01\xc6\x62\xf1\x52\x07\x1f\x2a\x20\x4b\x8a\xe3\x92\x5e\x98\xe2\x8d\x81\xbc\x0d\xed\x01\x63\xc2\xe8\xa0\xfb\x44\x8c\x2c\x23\x5d\x5a\x96\xe7\xb7\xbf\xd9\xcb\x1a\x9f\x23\x33\x6b\x4b\xf7\x26\xf4\x3c\xc8\x84\x6c\x10\x62\x86\xa6\x7a\x1c\x5c\x22\x5e\xf0\x1a\x1b\x3b\xfd\x21\x1b\xcb\x3e\xab\x84\x59\x75\xf8\x30\xe9\xdf\x42\xd0\x91\xb1\xc2\x74\xe8\x5f\x05\xed\xdf\xad\xa8\x04\x9b\x68\xff\x82\xd0\xbf\x8a\xfc\x10\x6f\xcc\xf4\x0f\xe0\xd7\x89\x93\xb9\x02\x7e\x3c\xc0\x8f\x22\xb2\x33\x8c\xfa\x12\x11\x89\xd7\x3a\x88\xc4\xff\x93\x82\x39\x30\x3f\x0b\x9e\xe8\x6d\x05\x95\x5f\xa5\x66\x6e\x20\xf8\x6d\x80\x1f\x5b\x6c\xbc\x29\x4b\x7e\x07\x00\x3e\x00\xf2\x73\x83\x04\xcf\x49\x44\x19\x97\xcb\xed\xf7\x98\x8c\x46\x8f\x9b\x85\x7c\xc4\xbb\xa1\xdd\x03\xf3\x2f\xa7\x33\xb9\x3d\x3a\x1b\x79\xbb\x4c\x67\x97\x2f\x7b\xa3\x15\x9e\x1e\x9b\x96\x20\x88\x76\xeb\xe2\x8d\xf1\xc2\x40\xe6\xdd\x92\x28\x11\xd5\x81\xa7\x0d\xec\xa5\x5f\xe1\xe9\x4f\x5f\xba\xf8\xea\xfb\x53\x78\xe4\x6b\xfc\xb0\x74\xff\x5b\x8f\x8b\xd7\x77\x57\x33\xcf\xdc\x7c\xc3\xd3\xf7\x76\xaf\xe1\x1f\x01\x11\x29\x7e\xb2\x82\xea\x6f\xa5\xec\xff\xba\x25\xfd\x45\x2a\xfb\x14\xee\x80\xea\x27\xcf\xd5\xc0\x81\x7f\xc1\xe9\xee\x94\xd7\xef\x36\x2a\xf3\x12\x95\xc9\x8d\x0a\x3e\xc3\x70\x1c\x55\x6c\x99\x3a\x0e\xe4\x90\xd1\x2a\xb6\x0c\x89\x84\x24\x97\x1b\xa9\x5c\xf2\x51\x5b\xa2\x84\x48\x26\x3f\x20\xc9\x26\xe0\xe6\x42\x05\xde\xbc\x40\xde\xfa\xa4\x27\xc0\xcb\xb2\xe1\x40\x34\xac\x5a\xff\x6a\x8d\xf7\xba\x33\xe7\x8c\xf2\x89\xf4\x90\x11\x13\x79\xa8\xfb\x8f\x0f\xf7\x22\xa6\x37\xc9\x3d\xa2\xa4\xff\xb7\x80\x7d\xa9\x72\xb2\x0b\x68\x99\x53\x92\xcb\x66\x78\xae\xca\x85\x3c\x2f\x50\xec\x78\x91\x56\xae\xcc\x37\x34\x16\x21\x72\xb5\xf9\xb2\xe5\xba\x48\x2b\x57\x19\x4e\x96\xab\xbf\x50\x95\xeb\x1b\xe0\x3f\x30\xc5\x57\x25\xfb\x0f\x19\x1f\xf6\x44\x4c\x42\x06\xdf\x3a\x3a\x0f\x10\x7c\xa3\x65\xb8\x65\x92\x9f\x41\xbe\x28\xc7\x64\xe0\xc8\xbd\x8a\x98\xfa\x5c\x8a\x4f\xff\x6f\x8a\x2f\x48\xcf\xc6\x0c\xf0\xc4\x75\x62\x9f\x47\x42\x2c\x0d\x95\x82\x9f\xce\xd3\xfb\xa1\xdd\x0f\xd0\xdf\x12\x34\xf7\x2f\x64\x96\x5f\x8a\x46\x41\xa4\x1b\x4f\x44\xa0\x9d\x91\x3a\xde\xf5\x56\xbc\xd2\x8a\x17\x58\x71\xa7\x15\x8f\xb3\xe2\x84\x15\x23\xab\x59\x20\xfe\x64\x1a\xfd\xa3\x62\x95\x75\xe6\x28\x8d\x3d\xfa\x52\x9d\x19\x82\x3f\x40\xd4\x6b\x61\x07\xd8\xd1\x20\x8b\x3d\xc7\x8e\xe8\xfd\xf6\xc2\xcb\xc8\x04\xd1\xf0\xe4\x44\x5f\x23\xc6\x26\xf2\xa6\xbf\xd5\x66\x73\x98\xc9\x89\xd3\x26\x93\x99\x63\x9d\x2e\x2b\x49\xb9\xac\x66\x5e\xb9\x58\xca\xc6\x43\xa8\x2f\xbd\xd6\x25\xc7\xdc\xad\xc7\x2b\x73\xde\x47\x51\x42\xcf\xda\x9a\x48\xe6\x9d\x37\xa6\xa1\x09\x52\x55\xf6\x0e\xcd\xeb\x6e\x6f\x76\x3f\xf2\xc1\x5b\xe2\x1b\xf8\x87\x19\xe2\x7c\x7e\xd8\xe9\xff\x23\xaf\xba\x75\xdf\xc5\x1f\x77\xff\x3d\xf4\x81\x6a\x57\x47\xe9\x78\xf5\x95\xe3\xbd\x2a\x65\x5c\xff\x96\x52\x4c\x8b\xdc\xd5\x4f\xe3\x14\x32\x5e\x63\x64\x38\xbf\x02\xf7\x81\x16\x8e\xc4\x1f\x1a\x7c\x10\x57\x6c\x56\xe0\xfe\x9a\xb2\x6a\xf1\x1d\xd4\xe2\x03\xb8\x6b\x14\xb8\x77\xb5\x70\xff\x02\xba\xa3\x29\xbe\x6a\x99\x6e\xb9\x02\x77\x2a\xa5\x33\x60\x5e\x86\xbb\x11\xe0\xa6\x52\x7c\x63\x65\xb8\xa0\xa4\x77\x2e\x93\x45\xab\x4f\x14\x1f\xf5\xb5\xd5\x64\xfe\x91\xf0\xa9\x3e\x57\xbf\x97\x31\xf2\x25\xd2\x00\xb2\x80\xf3\x75\x6e\xaa\x30\x9d\x56\x13\x1c\x68\x6c\xa2\xc2\x62\x34\xf2\x98\x6c\x2c\xe0\xad\x36\x18\x38\x9b\x9d\xa4\x76\x7a\xdd\xb8\xa4\x9e\x35\x19\xc7\xb7\x9b\xd8\x04\xb9\x04\x74\x5c\x92\x95\xdf\x53\xa1\x33\x49\x6f\x6f\x59\xd0\x65\x04\x72\x80\x06\xbd\x5c\x8e\x6c\x86\x70\xc1\x4f\xe6\x13\x7c\xf5\xe9\x0a\xfc\x88\xf8\x37\xfc\xa7\x7d\xa9\x07\xbb\x3f\x60\x4a\xd7\xae\x5d\xcb\x95\xaf\xfd\xe9\x86\xc7\x1f\xd7\x79\x57\x48\xfc\x1f\xd4\xca\x03\xe4\x76\xaf\x22\x0f\x31\xa5\xd7\xca\xe3\xa0\x56\x1e\x00\x77\xa3\x24\x0f\xb7\x39\x47\x1e\x93\xb2\xf0\x9d\x64\x76\x48\x70\x8c\x45\x27\x21\x93\xe0\x6e\x04\x38\x2d\xbe\x93\xcc\x6d\x12\x9c\xc7\x61\xd2\xe2\x5b\x45\xe7\x5e\x62\x23\x35\xb2\x8d\x1c\x93\x6d\xa4\x00\x6c\xe4\xba\xbc\x90\xcd\x9f\x35\x37\x5d\x0c\xf0\x33\x69\x3c\x30\x0e\x49\x16\xba\x45\x86\xef\xe3\x28\xc1\xf7\x94\x57\x99\x0b\xb2\xe0\x25\xfc\xb3\x14\xfc\x9a\xb9\x2c\x9f\xcc\x65\x79\xf9\xbd\xe2\x3f\x26\xe3\x17\x28\x3c\x81\xae\x04\xec\x6c\x79\x65\x06\x3b\xc1\x0d\xba\x71\x2e\x95\x45\x4d\xce\x1c\xa3\xa2\x95\x70\x02\xdc\x4c\x1a\x23\x8d\xcb\x86\x63\x54\x84\x39\xf3\x6e\x6d\x0e\xaf\xc4\x5f\x60\x9b\x43\xb0\x64\xf1\x4a\xce\x2d\xab\xe2\x8f\x81\xb7\x3a\xdf\x45\x73\xb2\x10\xca\x99\xfb\x6a\x73\xf8\x52\x51\x48\xed\x01\xae\x8a\x1b\x23\xb7\x27\x36\xe0\x50\x73\x02\x4d\x7b\xd0\x05\xc5\xc7\xdb\x73\xda\x1f\xd4\xb6\x07\xb8\x65\x6a\xec\xa8\x6d\x7f\x92\xf9\x8d\xdc\xde\x63\xcb\x6e\x3f\x29\xab\xfd\x49\x66\x05\x7d\x3e\x0b\xe2\x9b\x59\xd4\x87\xd7\x51\xfe\x45\x4a\x9f\x46\xbf\x05\xc4\x85\xa3\x82\x0a\x01\xe5\xc4\xcd\xd7\x41\x9b\x91\xc2\xc3\xd0\x66\x3c\xf1\xdf\xcc\x36\x2c\x69\xd3\x5b\xc8\x08\x96\xd8\x9f\xad\x5b\x19\x0a\xb5\xd5\x25\xf2\x82\xf0\xcd\xe7\x83\x6f\x0e\x77\x5b\xdd\x4a\xbb\x1d\x7e\xb3\x58\xe0\x37\xb3\x19\x7e\x33\x9a\xe0\x37\x83\xa1\xad\x8e\xf1\x13\x67\x8f\x8a\xaa\x33\x74\x1c\x95\xca\x9f\x86\x0c\x8f\x13\x54\x1e\xd3\xca\x3c\xc3\xb1\x4c\x09\x5f\x02\xdf\x51\x49\x9d\xdc\x5a\x3b\xcf\x48\x7c\xae\xcf\xe1\x93\x44\x13\x46\xd4\x90\x28\xe6\xd8\x46\xc2\x4f\x23\xe1\xa7\x91\xf0\xd3\x48\xf8\x69\x24\xfc\x70\x5a\x86\x54\x8e\x14\xbc\xb9\x32\x3b\x9d\x91\x59\x48\x92\x59\xf8\x0c\x32\xfb\x8d\xc2\x8b\x61\x14\xb5\xc0\x73\xd0\x3f\xd2\x6f\xa1\xfe\x89\x4a\x36\x9c\x00\x99\x85\x13\xfe\x60\x5b\x78\x25\xc8\x2c\x9c\xf0\x7a\xe1\x9b\xdb\x0d\xdf\x80\xbd\x30\x61\x0a\x26\x55\xbf\xa0\xe4\xaf\x8e\x1e\xf2\xc9\xf0\xd3\x9d\xe1\x27\x4c\xf9\x09\x17\x9c\x81\x9f\xb9\x39\xfc\x0c\xc1\x57\xfe\x3f\xe0\x87\xd8\x56\x07\xf5\x33\x71\x19\xeb\xcd\x92\x65\x33\x10\x15\x30\x51\x8f\x5f\x8f\xb2\x6c\x6b\x2f\xe8\xe6\x39\xd4\xcf\x4c\x20\x7e\x00\x2d\xed\x90\xa0\xcb\x81\xc6\xa8\x58\x99\x59\x9b\xb3\x4b\xb8\x67\x29\xb8\xd5\x5a\x0a\xe3\xa3\x39\xcd\x97\x29\x8f\x4f\x9f\x55\x4b\xa1\xb8\x8f\x29\xb8\x99\x7b\xf2\x25\xdc\xa5\x80\x5b\x1f\x2b\xed\x81\xfb\x6e\x8a\xbb\x21\x1b\x77\x80\xe2\x7e\x23\xe5\x0b\xf0\x16\x0d\xfc\xf7\xe4\xbc\x35\x8a\xfb\x02\x09\x77\x91\xe4\xbf\x02\xe0\xbf\x78\x5f\xc0\xe4\xd1\xe2\x06\xfb\xbf\x9b\xda\x69\x43\x76\xec\xcb\xa4\x5f\x57\xf1\x12\x9c\x00\xe7\xa1\xfe\xeb\x02\x19\x2e\xa4\xcc\x21\x6c\x4a\xc1\xa9\xe0\xa3\x73\x65\x83\x34\x57\x12\x7c\x9a\xb9\x92\x0d\xca\x73\xa5\x82\x93\xe6\x24\x17\xc8\xb0\x21\x29\x37\x81\xb0\x1a\x66\xd5\xa0\x83\x40\xca\xbe\x48\xc3\xa3\xec\x8b\x28\x8f\xaf\xa5\xfc\x19\x1e\xaf\x00\x38\x0d\x8f\xcc\xf7\xf8\xa6\x0c\x8f\xfe\x0c\x8f\x63\x41\xc7\xe6\x50\x79\x36\xca\xf2\x74\xc8\x3e\xb6\x06\x7c\x6c\x7e\xdf\x1a\x3e\x5b\x0f\x7e\x07\xf0\xc5\x54\x9e\x17\x4a\xf2\x74\x49\xf2\xac\x00\x79\xba\xcb\x2a\x04\xed\x58\x8d\x85\x3e\xcd\xe1\xa7\x28\xb8\xa1\x4f\xa2\xe4\xf7\x4c\x2a\x5a\x09\x27\xc0\x15\x73\xe7\xca\x38\x89\xdf\x35\x48\x70\x66\x15\x21\x85\x93\x78\x7d\x56\xc1\x67\x40\x4c\xbb\x92\x73\x34\x92\x9c\x63\x72\x75\x03\x9f\x6b\x43\x12\xbf\xaf\x29\xb8\xa1\xcd\xf9\x69\xab\xd4\xa6\x86\x98\xc7\xd0\xf2\xea\x1e\x76\x27\xd1\x39\xa5\xd2\xc1\xcc\x95\x0a\x9d\x3a\x42\x27\x58\xdf\xaf\x77\x3a\x02\xab\xd2\xc1\xcc\xec\xb4\x45\x6a\x53\x45\xe8\xe0\xbe\xf5\x3d\xe9\x10\xf9\x28\xb2\xa7\xb1\x14\xa3\xd1\x69\x18\xf5\xda\x8c\x7e\x50\x19\x29\x72\x57\x75\x49\x92\x3f\x40\x56\x2a\xfa\x31\x5a\xad\x63\x36\xe5\xcc\x99\x26\x32\x67\x1a\x4c\xbc\x2e\x6b\x3c\x5f\x20\xe7\xbc\x51\xf8\x49\x32\xfc\x34\x19\x1e\x0c\x0a\xcf\xf1\x05\xb0\x2d\x0b\x7e\xb4\x5a\xdf\x6c\xca\x99\x4b\x55\xd4\x12\x5e\xf1\x10\x39\x3f\x4e\xc1\x0b\x70\x4f\x28\xfa\xf7\x42\x4a\xc1\x4a\xf1\x1d\xd4\xe2\xd3\xcc\xad\xc6\x1c\x7c\x07\xb5\xf8\x00\x6e\xbd\x04\x57\xef\x57\x58\x94\xf9\x9b\x94\x85\x2f\x33\xd7\xda\x0c\xd9\xf8\x26\x65\xe1\x3b\x49\xc7\x18\xe0\xbc\x21\x9f\x16\xdf\x5a\xf1\x65\x6e\x20\xc5\xd7\x4c\xe1\x3e\x07\xfe\x2e\x43\x96\x67\x20\xc3\xf5\x79\x74\x0e\xb5\xd6\x7c\x00\xe0\xc2\x5c\x3f\x80\x9b\xac\x81\xb3\x3f\x49\x4a\x68\x3f\xa7\xc2\xa1\x80\x39\x53\x6b\x5e\x4b\xce\x65\xd3\xe0\xcc\xe4\x78\xc1\x52\x09\xa5\x92\x33\x4e\xca\xc2\xf9\x5d\x26\x67\xfc\x25\x15\xad\x96\x50\xf6\x82\x2f\xd3\xe7\x80\xeb\xd7\xf0\x49\x70\x14\xdf\xcf\xa9\x48\x30\x83\x0f\x74\x79\x20\x9d\xab\x9a\xb3\xe3\x0d\x06\xe7\x11\xfd\xc7\x79\x25\x4a\xcf\x55\x5d\x3e\x00\x6d\xc2\x74\x3e\x99\x9c\x15\x6f\xec\x83\x8f\xc7\x27\x1a\x98\x16\x12\x6f\xb4\x90\x78\xa3\x85\xc4\x1b\x2d\x24\xde\x68\x21\xf1\x46\x0b\x99\xdf\x5b\xc8\xfc\xde\x42\xe6\xf7\x16\x32\xbf\xb7\xe0\x3c\x07\x2d\x3e\xfe\x92\x2a\xae\xf5\x9b\x7b\x0b\x39\x50\x4f\x3e\x0d\x8c\x26\xb7\x0d\x4a\xb9\xad\x22\x80\xac\x98\x43\xe2\xf5\x22\x85\x57\x69\x5e\x45\x73\x11\x8f\xbe\x40\x25\xa4\x75\x51\x22\x1c\x6e\x2b\x22\x4c\xb0\x12\x17\xc1\x3c\x99\x0b\x89\x0d\x79\x1c\x8d\x60\x6b\x2f\x09\xf7\x03\x9e\x16\x4a\x7f\x04\xf6\xcb\xd1\xb1\x1b\x6c\x07\xb9\x23\x4c\x76\xdd\x69\x18\xc0\xdf\xc4\x93\x9a\x5f\x92\xda\x2e\xc8\x88\x42\x7b\xc0\x77\x22\x4f\x11\xa3\xad\xf3\x19\xc1\xce\x5e\xa2\x63\xda\x92\x63\x67\x66\xab\x0c\x28\xe1\x04\xb8\x9b\xe8\x98\x26\x7f\x15\x0e\xfe\x70\xc7\x68\xbd\xb1\x1f\xed\xed\x90\xf4\x2b\xb4\xce\x88\xfd\xc0\xea\xfe\xf4\x2b\xa9\x40\xbe\xc1\xa7\xa1\xef\x01\xf8\xfd\x74\xbe\x9f\x42\xe7\xfb\x21\x37\x93\x1a\x19\x11\x09\x40\xdf\x9c\x0a\x16\xe8\x02\x59\x7d\xcb\xc5\xbf\x14\xcd\x06\xfc\xa4\x77\x84\xc0\x6c\x7f\x30\x83\x1d\xf5\x86\x7f\xe9\x74\x49\x16\x84\xc0\xb4\xbc\x50\x06\xbb\x8a\x7b\xba\x8a\x7b\x2e\xc2\xe8\x33\x49\x1f\xfd\xb4\xd6\x94\x9f\x27\x61\xd7\xe8\xa3\x84\x7f\xb9\x8a\x7f\x2e\x56\x34\x98\x68\x16\x2a\xc8\x97\x28\xa8\xf5\x62\x89\xc6\x2c\x85\x86\xc6\x6f\x92\x1a\x22\x0e\xf4\xce\xff\x31\x05\xbf\x9a\x17\x85\xc8\x58\x06\x73\xf8\x87\x31\x92\xd6\xab\xfa\xe5\x8c\x91\x8a\x56\xc2\x09\x70\xfb\xe9\x58\x4e\xc9\x81\x53\x11\x52\xb8\x62\xa0\xbd\x93\xf2\xda\x3f\x67\xce\x26\xf5\x48\x87\xc5\xa6\xe7\xb2\x78\x05\xd1\x72\xf3\x28\xaf\xed\x59\xbc\xda\x1c\xb4\x7a\xc9\x9a\x34\xbc\x4a\xb8\x6f\x54\x70\xf7\x56\xd7\x93\xb0\x6b\x64\x2d\xe1\x5f\xae\xe0\xcf\xc8\xda\x45\x67\x3e\x87\x4c\x41\x95\x35\xa1\xf1\x28\xe5\x7f\x40\x0e\xff\x66\xe0\xdf\x69\x34\x73\xfa\x2c\xfe\xcf\x01\xbf\x75\x0b\xe5\x7f\x6a\x16\xff\x7e\xc2\xbf\xd7\x6f\x74\x68\xf8\x1f\x09\xb8\xaf\x17\x1e\x05\xd8\x81\x94\xff\xa1\xf4\x9d\x3a\x02\x6d\x07\xdc\x25\x0e\x13\x63\xc8\xc2\xbd\x91\xe6\x8c\x44\x0f\xa7\x51\xdc\x37\x29\xd0\x80\x5b\x70\x98\xb0\x41\x8b\x1b\xc6\xe7\x7a\x3a\x8e\x03\xe5\x38\x45\x2f\xc7\x33\x26\x8b\x8c\x56\xc2\x49\xf3\xc8\x7e\x32\x4e\x02\x67\x96\x73\x7d\x93\x05\x6b\xe0\x46\xc2\xdc\xa7\xc1\x07\x73\xda\x22\x19\x9f\x39\x07\xdf\x41\x2d\xbe\xcc\x1c\x29\x98\xb3\xf0\x1d\x50\xd7\xa4\xce\x95\xe1\x16\xc8\x70\x3e\xb9\x70\xab\x9d\xf3\x3b\x95\xb9\x0f\xec\xc9\x8c\x3e\x47\xd1\x84\x8f\xc1\xa1\x44\x59\x59\x5b\x88\xb8\xbf\x10\x19\x6d\x6f\x50\x9e\x5c\x41\x04\x95\xd9\xb6\x25\x98\x54\xdd\xbf\x57\xd1\x90\x10\xb5\xad\xc2\xbc\x1c\xdb\xa2\xe3\x47\xe1\xa7\x66\xc3\xd3\x04\x05\x05\x3d\x46\x47\x16\xfc\x4a\xf0\xcf\x37\xf3\x3f\x38\xa5\x75\x5b\x81\x59\xf1\x07\x5a\x9f\x1f\x48\xeb\xf3\xef\xa4\x06\xf6\x93\x16\x6e\x95\x3a\x21\x5e\x2f\xaf\x57\xd8\x91\x1b\xd5\x24\x9c\x08\xbb\x1d\x7a\x07\x66\x3d\x5e\x87\x73\x43\xbb\x83\xe7\xcd\x74\x7d\x82\x67\xb1\x07\xe5\x1e\xde\x56\x5b\x13\x91\xef\xca\x50\xd6\x21\x3c\x2e\x69\x11\x42\xb3\x00\xd1\xf0\x1a\x7b\x2c\xb3\xee\x80\xff\x49\x4a\xea\x64\x9f\xda\x9d\xc0\xe7\x35\xfc\x85\xa0\xcf\xe7\x26\xca\xf2\x82\x45\x76\x27\x7d\xef\xcc\x2e\x04\xf9\x58\x89\xa3\xa8\xc8\xd6\x99\x2c\x2a\x0a\x86\xc3\x9e\x8e\x64\x98\x0b\x3a\x39\x43\x47\x92\x73\x65\xde\xc0\x38\xd3\xc6\x28\xe9\xad\xd2\xcc\x96\xa8\x26\x97\xcc\x99\x23\x4a\xcf\x2d\x70\xe1\x02\xcc\x5d\x33\xf7\xc5\x6b\x6e\xba\x2a\x38\x65\xe9\xaa\xab\xef\xbc\xb7\x1c\x9f\x8c\xad\x1e\xda\x79\x65\xf3\xa1\xf7\x7f\xc4\x85\x8f\x88\xe2\xf6\x7d\x78\xfd\xca\x43\x97\x14\xde\x57\xba\x76\xc5\x0d\x57\xdd\x8d\xf3\x1b\xcf\x99\xfe\xd4\xef\x4e\x77\xb3\x2c\x1e\x88\xbd\x62\x5a\xfc\xbd\xe3\x6d\xd9\x6f\xab\xbe\xa9\x38\xcb\xe7\x30\xc8\xe6\xe0\x34\xf1\xd2\x4a\x80\xd3\xac\xa5\x03\xdc\x09\x25\xef\x78\x27\x55\x1b\x97\x46\x44\xf1\xa3\x74\x4e\x96\xd6\xe6\xdf\x60\x57\xc9\x79\x25\x51\x28\xa3\xdb\xcf\x65\xc7\x9f\xd2\x58\x9f\x52\xf0\x02\x7c\xa7\x78\x94\x8c\x76\x2b\x1d\xed\x63\xa9\x46\xcd\x68\xab\xf8\xf3\x14\xfc\x86\x3a\xe6\xb8\x92\x47\xd3\x72\xf6\xec\xa0\x5d\xd9\x01\xa0\xea\x2b\xa5\x21\x94\x28\x34\x0c\xfd\x98\x43\x4a\x9b\xfe\x64\x8a\xef\x3f\xb0\x4e\xd9\x0a\xa0\xb6\xc9\xa5\x13\xc7\x44\x2e\x81\x7d\x32\x99\xfd\xe9\x2d\x29\xa7\x47\x4b\x09\xda\x24\x28\x9d\x42\x95\x4e\x7f\xfc\xaf\xf4\xcf\xb4\xcd\x40\x07\x6d\x73\x69\xaa\xbe\x45\x4b\xa9\x17\x3a\xf5\xcc\x76\x85\xb7\x62\x42\xa8\x7f\x89\xef\x0c\xfd\x99\xa3\xd2\x19\xc0\xfc\x2e\xfd\x83\xd4\x66\x04\x21\x14\x1d\xd9\x72\xd6\xfe\x34\x64\xea\x0f\xa5\xb4\xfe\xe0\x2d\x3a\x03\x9d\xcf\x55\x3a\x03\x99\xb1\xe9\x53\xb4\x3f\x4d\x52\x7f\x8e\xa5\xce\x89\xe7\xf6\x87\xe8\x13\xf5\xbf\xc5\x59\x39\x2f\xf1\xab\x3f\x22\x4f\xc2\xcc\x52\xf9\xa9\xda\xa5\x8c\x2b\xd5\x2f\xea\x87\x87\xd2\xf8\xf1\xa6\x1f\x25\x2d\xfb\x33\xb4\x2b\x49\x31\x0d\x0e\xb2\x0b\xe3\x9d\x84\xa1\xff\x40\x20\xc8\x14\x36\x42\x14\xf2\x36\xd9\xc2\x41\x4a\xa7\xd3\x34\xfb\x0b\x72\xfb\xd9\x98\xe9\xa7\x9b\x12\xf6\x85\xcf\xd0\xcf\x6f\xd5\x7e\x0e\x62\xc6\xc8\x63\x5d\x23\xf5\xf3\x8d\x54\xfc\x6c\xe3\xd6\xc4\xcc\xcd\xa2\xc3\xfd\x0f\x74\x5a\x99\x51\xd9\x74\x5e\x3d\x3b\x9d\xe6\x4c\x7f\xac\xb4\x3f\x8e\x40\xef\x74\xa8\x0d\x4a\x74\x12\x74\xed\x5f\x43\xe7\xfd\xb3\xd3\x69\xc9\xa5\x53\x54\x7d\x86\xfe\x7c\xa3\xd2\x19\xcc\x24\xb3\xe9\xfc\xa9\x17\x3a\x54\x3f\x76\x2a\xfa\x21\xad\x77\xab\x7e\x07\xf4\xa3\x97\x6e\xf5\xa6\x1f\x77\xff\x4b\xd2\x8f\x4f\xe5\x56\x94\xa2\x2e\xde\x3f\x2f\xac\xb6\x52\x6b\xbf\x9a\x75\x7b\x98\x8b\x4b\xa4\x39\xd1\x62\xb1\x65\xaf\xdb\x1f\xd2\xae\xdb\x03\x1c\x2f\xf9\x41\x7d\x7e\x41\xd6\xba\x7d\xf6\x1e\x06\xf0\x57\x1b\xe5\x88\x81\xc4\x89\xc8\xe9\xc5\xa6\x2c\xff\x46\xf7\x2f\x50\xff\xd6\x26\xc3\x5f\x05\xfe\x8d\xf8\xc3\x0a\x70\x70\x6c\x24\x26\x23\xcf\xc2\x2f\xdc\xa7\xe2\xdf\x06\xf3\x0c\x8d\xd3\xbd\x34\x4e\xff\x3c\xe5\x8d\x62\x6d\xbc\x26\xe1\xdf\x29\xe3\x57\x73\x0a\xa6\x98\x4c\xad\xb1\xba\x0c\x76\x19\xf7\x5a\x3a\xc6\x65\xb2\xef\xfc\x54\x99\x89\x49\x65\x0e\x77\x04\xac\xbd\xee\xbf\x58\x4d\x7d\x67\x9b\xec\x3b\xdf\x57\xf4\xa2\x84\x88\x7c\x51\x59\x48\xa2\xa1\x69\x33\x97\xca\x28\x43\x27\xce\x78\x90\xb4\xa7\xc4\x27\xed\x29\xd9\x94\xb2\xbb\x72\xf6\x94\x5c\x40\xf7\x79\x64\xe8\xf4\x27\xf7\xb8\x51\x5d\x2a\x93\x74\x69\x5b\x2a\x5c\xac\xa5\xa4\x8e\x45\x86\x4e\x3d\xb3\x57\xe9\x4f\x11\x21\x54\x5b\xec\xe9\xb5\x3f\x63\x85\x25\x2a\x9d\x01\xcc\xb3\x4a\x7f\xea\x08\xa1\x0b\xea\x8b\x7b\xf4\x27\x97\x4e\x03\xb3\x54\xee\x4f\x4c\xea\xcf\xbf\x53\xee\xc2\x5e\xf7\xc8\x7c\xa3\xd2\x19\xc8\xcc\x43\xda\x1d\x2b\xfa\x3e\x05\x3d\xe9\x10\x5d\xa5\xbe\x93\xee\x09\x91\x7c\xa6\xba\x16\xe7\x7b\x9a\x6c\xd7\x20\xe4\xfe\x91\x72\x9a\xa5\x4d\x21\x1a\x3d\x23\xfa\xab\xee\x0b\x01\xff\xa9\x93\xb4\xd8\x2e\xdb\x47\x3e\xb5\x8f\x48\x30\xb3\x4d\x06\xf5\xb6\x3e\x0c\xfa\xb9\x34\x5b\x9f\xe5\x45\xe7\xca\xac\x75\x61\x88\xe5\xf4\x3f\x28\xf0\xe2\x27\x44\x3f\x03\x34\x33\x3c\x91\xb2\xbb\xe5\xe5\x2c\x49\xe7\xde\x00\xbe\x34\xeb\xd9\x59\xfb\x0e\xb2\xd7\xb3\x0f\x69\xd7\xb3\x81\xf3\x80\x6c\x7f\x30\x53\x68\xd6\xc7\x66\x01\xdc\x2c\x5a\x53\xac\xcb\x89\x57\x7c\x01\x6d\xad\xf0\x3a\x80\x1b\x49\xed\x79\x7c\x0e\x5c\x20\xa8\x85\xcb\xa9\xcb\x67\xfa\xcf\x90\xb1\x45\xf9\x85\x42\x76\xfd\x53\xaa\xc9\x9b\x14\xbc\x72\xff\x95\x6a\x35\x2a\x28\xca\x81\x27\xf8\xe7\x51\xdd\xa9\x93\x6d\xee\xb0\xa2\x07\x11\xe2\xe8\xa6\x44\xfd\xbd\xd6\xfd\x97\x51\x5b\x18\x2f\xdb\x9c\x1a\xe3\x44\xc9\x30\xce\x8e\xe5\xf5\x68\x33\x92\xf6\x23\x43\x27\x8e\x7f\x94\xed\x27\x22\xc5\x2b\xeb\x52\x79\x21\x6d\x2b\x68\x33\x99\xf6\x25\x43\xa7\x3f\xc3\xcb\x6d\x62\x92\xcd\x3d\x90\xca\x8f\xe4\xb4\x99\x95\x43\xa7\x9e\xd9\xad\xf0\x56\x45\x08\xb5\xf5\xed\x7d\x5d\x65\x14\xb5\xb9\xf1\xb2\xcd\x3d\xad\xb4\x21\xdb\x95\x98\x71\xb5\x91\x1e\x6d\x72\xe9\x68\xe2\x95\xea\x5f\x5f\xf3\xfa\x46\xa5\x33\x30\x33\x27\x87\x09\x1d\xbe\x22\xd8\x93\x0e\xd1\x27\x6a\x73\x75\xd9\x36\xa7\xce\x47\x3e\x4a\x2e\xdf\x9b\x69\xaa\xea\x17\xb5\x37\x69\xdd\xea\x26\x8d\x96\x91\x56\x01\xba\x60\x56\xa0\x19\xdc\x4c\xbf\xbe\x20\xf4\xc8\x7e\x4b\x5a\x27\x99\x01\x71\x11\xf5\xd8\xa0\x6f\x45\x85\x51\xc1\x91\xab\x6f\x3c\x4b\xe8\xe0\x8b\xa5\x3a\xc9\x25\x9a\xb5\x91\x68\x89\xa0\xcd\x7d\x73\x71\x0f\x49\xef\x22\x31\x57\x8a\xac\x30\xc1\x68\xce\x4d\x45\x8a\xb3\xe0\x73\x71\x0f\x79\x96\xe6\x59\x45\x34\xf2\x7e\x2e\x55\x5c\xda\x8b\x2e\x7f\x41\x6c\x45\xc2\x0f\xba\x4f\xf6\xef\x41\x8b\xbe\x14\xff\x9b\xa9\x58\x79\x4f\xfc\xc4\x56\x28\x7e\x02\xbf\x8c\xfa\x0a\x79\xa7\xd5\xef\x52\x65\x55\xbd\xf0\xbf\x4d\xc5\xbf\x4d\x8a\x19\x53\x4c\x19\xc5\x7f\x38\x55\xde\xd8\x0b\xff\x3b\x15\xfe\x29\x3c\x40\x57\x52\xec\x0f\xa5\xaa\x5a\x72\x64\x49\xc6\xfa\x0b\x7e\x95\x82\x1f\x7c\x8c\x80\xd4\xf5\x9d\xc2\x22\x09\x5a\x1a\x5b\x9e\x25\xbe\x43\xe2\x5b\xbb\x0e\xb4\x23\x15\x8d\xa9\x70\x6b\x01\x9f\xa6\xee\xaa\xf1\x6d\x2e\x4f\x76\xdd\xf5\x90\xb6\xee\xaa\xdd\x53\xf5\x73\x2a\x18\x3a\x53\xdd\x55\xe3\x8b\x23\xc4\x17\xfb\xf3\x75\xd9\xfd\x91\xea\x98\x26\xb5\x9e\xfb\x06\x3b\x5f\xf2\xc5\xe5\xd4\x17\xff\x90\x2a\x2c\x96\x70\xcb\xf2\x02\xfc\x7c\x31\xd5\x8f\x85\xb2\xee\x5d\x48\xe5\x4b\x66\x4b\x80\xff\x2c\x55\x10\x71\xea\x34\xf0\x04\xff\x8f\x54\x3f\x16\xf1\x54\xf7\x2e\x20\x6b\x0d\x64\xa9\x07\x29\xfc\x66\xe1\x1b\x92\xbe\x5f\xc2\x17\xa2\xf8\xaa\x52\xe1\xa2\xde\xf0\xd9\x15\x7c\x43\xb6\x51\x7c\xb1\x2c\x7c\x54\xbf\x16\xca\xfd\x49\xd2\x11\xc5\x55\x14\xdf\x82\x54\xb4\xb4\x27\x3e\xc1\x24\xe3\x23\xf0\xb3\xa1\xff\x80\xb1\xde\xa1\xae\x9b\x48\x3c\xde\xa7\xe2\xdc\x96\xfe\x8b\x14\x4f\x95\x52\x9c\xb3\x53\xa5\xf5\xbd\xf0\xb8\x53\xe1\x91\xd9\xd6\x4d\x79\xac\x56\x79\x04\xdd\x28\xa6\x3a\xb4\x50\x1e\xcb\xbf\x2a\x63\x79\x79\xaa\xa0\x50\xc2\x25\x8f\xf9\x8f\x5c\x3f\x09\x0f\xd9\x4b\xc0\x7c\x85\x32\xb5\xaf\x9d\x4a\xed\x0b\x64\xf6\xac\xc4\x8f\x81\xf2\xf3\x6c\xca\x68\xc9\x54\xbf\xd4\xda\x57\x4a\xa9\x9d\xa0\x21\xaf\x50\x89\x78\xe8\x08\xbf\x9a\xf2\x06\x8c\xd9\x3a\x51\x0c\x74\x1f\xa5\x3a\x39\x40\xd6\x71\x2c\xe9\x24\xa7\x96\xd5\x32\x35\x35\xaa\x93\x80\x97\xf0\xc7\x95\x67\xf8\xa3\x3a\x38\x40\x1e\x83\x85\xd2\x18\x48\x75\xe2\x5f\x52\x36\x57\x4f\xfe\xd4\xda\x0e\x81\x5f\x2c\xe9\x60\x31\xe5\xb0\x3b\x15\x0c\x67\xd5\xe7\xa4\xfe\xdf\xa7\xe2\x97\xe2\x5b\xa2\xe3\x2e\xa2\xe3\xae\xc2\x5e\x6b\x7f\x3b\xd5\xda\x91\x52\x33\x0f\x93\xda\x5f\xb8\x2a\x0b\xf7\x2a\x18\xbb\xf5\x42\x8d\xb3\x84\xa5\xf6\xad\xdb\x80\xba\xd1\xcc\x8c\x47\x38\x9e\xaa\x2c\xe5\x6d\xbf\x02\x7f\x14\xfd\x20\xc1\x57\x39\xa4\xbd\xe8\x35\x95\xbf\x0a\xff\x00\xfa\x09\xe0\xc9\x7c\x59\x2b\xcd\x97\xcf\xa7\x6a\x65\x0a\xea\x7c\x99\xdb\xa6\x0b\x9d\x90\xdb\xd4\x49\x6d\x9e\x48\x35\x9e\xad\xcd\x76\x5c\x9b\x4d\xe7\xe7\x54\x6d\xd9\x59\xda\xec\xc6\x25\xd9\x74\xbe\x49\x35\xf6\xda\x46\x37\x4a\x6d\xf3\x20\xc6\x72\x9b\xa1\x52\x9b\x37\x53\xd5\x03\xce\xd2\x66\x0f\x3a\x25\xb7\x19\x26\xb5\x79\xb9\x67\x1b\x9a\x5b\xd2\xd8\x8e\xe4\x7c\x82\x6e\xc3\x2d\x9a\x9a\x84\xe6\xf9\xd1\x8d\xf4\xb9\x98\xce\x7a\x0e\x72\x16\xff\xd4\xeb\xf3\xae\x33\x3c\xdf\x7e\x86\xe7\xbb\xa5\xe7\x69\x37\xad\xf5\x7f\xa1\x3e\x7f\x30\x1d\xeb\xf5\xf9\x1e\xe9\x39\xda\x03\x7d\x1e\x4c\x65\x3b\x4b\xd2\x2b\x5c\x06\x7d\x56\xf6\x58\xe9\xfb\x94\x1b\xb3\xeb\xed\xb9\xf0\x47\xb1\x85\xea\x15\xee\x4b\x6d\xe2\xcb\x54\x5d\x9f\x4c\x8b\x5e\xe0\x1f\x90\xc7\x8e\xc1\x71\x69\x19\xec\xe7\x54\x5c\xa6\xa1\xca\x34\xb7\x4d\x17\x76\xc8\x6d\xea\xa5\x36\x9f\xa7\x9a\xcf\xd6\x66\x3b\x1e\x02\x6d\x68\xbe\x44\x09\xe5\xc7\x2b\x8c\xb9\xb5\xfd\xdc\x36\xbb\xf1\x78\xa5\x0d\x25\x54\xd9\xdc\xa3\x4d\x7a\x04\xc9\x97\xa8\xdc\xcb\xa8\x1c\x37\x88\x13\x29\x2e\x3d\x42\x7c\x05\x7f\xcc\x5e\x0a\xcf\x5f\xa3\x9f\x1c\x4d\xe7\x23\xda\xa6\xfb\x70\x4e\x9b\x07\xba\xef\xec\xf5\x79\xd7\x19\x9e\x6f\x3f\xc3\xf3\xdd\xd2\x73\xba\xc7\x24\x40\xfb\x31\x47\x1e\xc3\x22\x79\x0c\x0b\xc8\xce\x85\x82\x3c\x73\xf6\xbe\xb7\x5c\xf8\xa3\xb8\x5c\x86\x27\x9e\xc7\x1d\x2d\x38\x0b\xfc\x03\x38\x4f\x91\x13\x4d\xc5\x51\xb1\x4c\x41\x23\xdb\xdc\x36\x5d\x99\x36\x31\xda\xa6\xfc\xec\x6d\xb6\x63\x4f\x0e\x9d\xe0\x59\xdb\xec\xce\xb4\x91\xe9\x9c\xa1\x0d\xb5\xf3\x39\xb2\x6f\x70\x28\x6d\x9a\x68\x9b\xa2\xea\xb3\xb6\xd9\x83\x4b\x95\x36\xcd\xa4\x8d\xb7\x67\x1b\xaa\x2b\x15\x74\xbc\x2a\xb5\xba\x92\x4e\xe4\x3c\x3f\x2a\x3d\xa7\xe3\xab\x7d\xae\xe8\xc9\x1f\x73\x9e\x77\x75\xef\xec\x15\x5e\xab\x27\xda\xe7\xb2\x9e\x74\x3f\x44\xf7\x1c\x7e\xa1\x3e\x7f\xb0\x3b\xd5\xeb\xf3\x3d\xd2\x73\xb4\x19\xec\x63\x1a\x95\xed\x5c\x79\xce\xf9\x48\xb2\x75\x69\x86\x3e\x98\xf2\x38\xac\x82\xc6\xd6\x73\xe1\x8f\xa2\xf7\x25\x78\x2f\x85\x7f\x32\x95\xe7\xf9\x55\xf8\x07\xd0\x17\xb2\x9d\x07\x25\x3b\x3f\x90\x0a\xca\x14\x54\x3b\xcf\x6d\xd3\x85\xfe\x2e\xb7\xc9\x97\xda\x3c\x9d\x2a\x3c\x5b\x9b\xed\xe8\xb3\x6c\x3a\xcf\xa5\x82\xce\xb3\xb4\xd9\x8d\xfe\x96\x4d\xe7\x99\x54\x61\xaf\x6d\xa8\x8e\x48\x6d\x1e\x44\x1f\xc8\x6d\xfa\x4a\x6d\xf6\xa5\x02\x25\x67\x69\xb3\x47\x6d\x53\x7d\xa6\x36\x54\xaf\x30\x1d\xdf\xaa\x1e\x7a\xa5\x7d\xae\xd5\x2b\xed\x73\xad\xff\xd1\x3e\xef\x3a\xc3\xf3\xed\x67\x78\xae\xd5\x2b\x4c\xf5\xa7\xaa\x87\x5e\x69\x9f\x2b\x7a\x25\xe5\xb2\x35\x4a\x2e\x0b\xfe\xca\x2a\xf9\x1f\x86\x2e\xb2\x85\x02\xbd\xd6\x25\x32\xf0\x47\xa9\x8d\x13\xf8\x02\x02\x5f\x14\x3a\x0b\xbc\xea\xaf\xe4\x1a\x03\x8a\x06\xce\x90\x5f\x67\xda\x74\x65\xda\x14\xd3\x36\x65\x67\x6f\xa3\xfa\x2b\x95\x4e\xcf\x5a\x46\x6e\x9b\xdd\x99\x36\x32\x9d\x1e\x6d\xd2\x8f\x91\x7a\x01\x95\x7b\x9d\x3c\xde\xfb\xe9\xf3\x1d\x39\xcf\x8f\x4a\xcf\xc5\xe2\x9c\xe7\x0f\x74\xff\xdc\xeb\xf3\x2e\xf9\xf9\xcd\x39\xcf\xb7\x8b\xd3\x7b\x7d\xbe\x5b\x7a\x8e\x1e\x82\xe7\x43\xa9\x6d\x2c\x95\xfd\x82\x28\xd9\xb9\xb4\x83\xe2\xb3\x54\x9e\x57\xa7\xdd\x2b\x97\x0b\x7f\x14\x9d\x94\xe0\x83\x14\xfe\x58\x2a\x9c\xf7\xab\xf0\x0f\xd0\x58\x97\xd8\x44\xa1\x64\x13\xef\xa5\x0a\x65\x0a\xaa\x1d\xe5\xb6\xe9\x92\xe3\x57\x06\x47\xa4\x36\x7f\x48\xc5\xce\xd6\x66\x3b\xae\x52\x7c\x3a\x25\x64\x28\xf4\xe9\x72\xc7\x2f\xb7\xcd\xee\x4c\x1b\x4a\xc8\x10\x3b\x43\x1b\x6a\xe3\x4b\x35\xf3\x8d\x26\x06\xfa\x21\x55\x50\xd9\x1b\x6f\x9a\x36\x7b\x72\x63\xa0\x9e\x6d\xc4\x8f\x48\xfe\x41\xc7\x6b\x80\xa4\x0f\xdd\xdf\xaa\x76\xab\x7d\xae\xd8\xf9\xd4\x9c\xe7\xbb\xbb\xeb\xe8\xf3\x2d\x34\x8f\xf9\x42\x7d\xbe\x47\x9a\x6f\x50\x03\xf0\x74\x37\xed\xfb\xb2\x6c\xbb\x25\xbe\x0a\xa3\xea\xca\xbc\xec\x3d\xeb\xb9\xf0\xaa\xdd\x92\xed\x89\x18\xd5\x57\x9f\x05\x5e\xb2\x5b\xd2\xe7\x06\xa9\xcf\xe9\x54\x83\x4c\x43\x95\x53\x6e\x9b\x2e\xb5\x4d\xa3\xd2\xa6\xdf\xd9\xda\x6c\xa7\xf1\x0f\x1d\x43\x4a\xc8\xd5\x50\xa5\x6d\xd1\x2b\x6f\xbb\x33\x6d\x28\x21\x57\xbf\x33\xb4\xa1\x63\xb8\x2c\x37\xce\x68\xa3\x71\x46\x3c\x71\xd6\x36\x7b\x32\x6d\x46\x9e\xa1\x4d\xfa\x31\x18\xaf\x8d\x64\x1c\xd9\x29\xd9\xfe\x21\xe7\xb9\xea\x1f\x72\x9e\x2b\xfe\xa1\x08\x9e\xdf\x41\xde\x31\x60\xa7\xa4\x25\x3d\xf9\xaf\xe4\x07\x72\xe0\x55\xff\x90\xf3\x5c\xf6\x0f\x62\x92\x3c\x27\xfa\x23\x3f\x7f\x50\x9c\xdb\xeb\xf3\x3d\xd2\x73\x39\xbf\xd3\xa9\x79\xd7\x21\xf4\xb8\xb6\xda\x75\x55\xaa\xac\x97\x5c\x95\xac\x3b\x51\x78\x81\x6d\x8e\x68\xa0\xc5\x54\x69\x05\x6f\xeb\x25\x67\xd1\xa9\x71\xfe\x21\xf4\x9e\x94\xf7\xf7\xa1\xfe\x67\x6f\xaa\xa2\x97\x9c\x85\xe2\x9f\x25\xe1\x9f\x91\x79\xeb\x64\x6c\x79\x55\x16\xac\x14\x7f\xea\xd4\xb8\xf0\x10\xfa\x58\xc2\x5d\x20\xfb\xb6\xa0\x26\x9a\x56\xe0\x29\xee\x39\x12\xee\x49\x48\x8d\xd4\x2f\xcc\x0b\x65\xc1\x4a\x31\x88\x4e\x8d\x0d\x0e\xa1\xfb\x91\xa6\x42\xb2\x3c\xe5\xec\x25\x9e\xa2\xb8\xe7\x4a\xb8\xfd\x99\x3d\x78\xe4\x40\x6f\x21\xbb\xbe\x08\xf3\x90\x4e\x9d\x87\x0e\xa1\x3f\x48\x32\x0f\x51\x29\xbe\xa4\x56\xd4\xb5\xf0\x74\xad\x6f\xbc\x2a\x73\x65\xc6\x2e\x0c\xe4\x0b\x3d\xfd\xb7\x4e\xf5\x5d\x87\xc8\x5b\xba\x99\xf9\x61\x47\xca\xd7\x8b\xbf\xa7\x7c\x2f\x95\x70\xe7\x65\xf6\xcb\x99\xbc\x81\x2c\x58\xc9\x0e\x75\xaa\x7d\x1c\x42\xcf\x4a\xb8\xab\x29\xee\x47\x53\x55\x1a\xaf\xa2\xc0\x53\xdc\xcb\x24\xdc\xfd\x91\xea\xb1\x5a\x2a\xfb\x66\xc1\xae\x82\xb1\x51\xeb\x0c\xf6\x52\x98\xd7\x7e\x46\x33\x1d\x3a\x56\x60\x86\x6a\xf5\xb1\x67\xad\x25\xa7\xdd\x51\xf4\x63\x76\xbb\x33\xd5\x5c\x68\xbb\x72\xb5\xdd\x03\xe8\x07\x34\x4d\x6d\x77\x96\xda\x4b\x0e\xcd\xae\x2c\x9a\x67\xa9\xc1\xe4\xb4\xdd\x8e\x5d\x39\x6d\x7f\xa5\x16\x93\xd3\x76\x77\x8f\xb6\xbf\x52\x93\x21\x6d\x95\xfa\x0a\xb4\x7d\x10\xfd\x27\xa7\xed\xaf\xd4\x66\x72\xda\xee\x41\xdf\xe6\xb4\xfd\x95\x1a\x0d\x3d\x53\x43\xa9\x95\x94\xe8\x36\x6c\x03\xef\x03\x2d\xe7\x20\xb9\x56\x93\xf3\xf9\xd1\xec\xcf\xc5\x74\xd6\xe7\xa5\x52\xcd\x46\x81\xe8\xe5\xf3\xae\xb3\x7c\xbe\xfd\x2c\x9f\xef\xce\xfe\x3c\xed\x26\x9f\xab\xb5\x9b\x52\xa9\xa6\xf3\x2b\x9f\xef\xc9\xfe\x3c\x3b\x47\x26\x7a\x4d\x6a\x36\x44\x76\x74\x4f\xaf\x7e\x2f\x71\x3e\x4a\x4d\x39\x17\xf6\x28\x99\x7f\xfe\x47\xd8\x07\x30\xab\x81\x35\xa6\x68\xda\x4e\x06\xa1\x17\xd8\x2e\x94\xfe\x9f\x61\xb7\xe3\xc2\xff\x19\x76\x37\x8e\xfc\x3a\xac\x6e\xa8\x0a\xfb\x20\xc0\x4c\xcf\x82\x6d\xcc\x81\x1d\xa5\xc2\xee\xc9\x92\x19\x81\x6d\x52\x60\xd3\x23\xe8\x3b\x70\x4a\xbe\x5d\x2a\xe5\x63\x54\xfe\x97\x48\x79\x59\xce\xe7\x47\xb3\x3f\xef\x3e\x9c\xf3\x39\xcd\xcf\x7e\xe5\xf3\xae\xb3\x7c\xbe\xfd\x2c\x9f\xef\xce\xf9\x9c\x9c\xeb\x90\xc9\xff\x41\x2e\x67\xf9\x7c\x4f\xf6\xe7\xa8\x01\x3e\x57\x63\x23\xaa\x5f\x56\xd9\x36\x2f\x47\x9a\x15\x86\x5e\x61\x69\x4c\xf8\x3f\xc2\xd2\x78\x50\x85\x25\x63\xd0\xa0\x8e\x57\x2e\x6c\x57\x0f\xd8\xc6\x33\xc2\x6e\xc7\xf1\xff\x19\xef\xee\x1e\xb0\x39\x78\x95\xd8\x8d\xea\x97\x23\x07\xb6\xed\x8c\xb0\x7b\x7a\xc0\x8e\x54\xf5\xeb\x31\x80\xcd\xc4\x59\xa5\x52\x7c\x47\xe5\xbf\x54\x8a\xf3\x72\x3e\x3f\x9a\xfd\xb9\x58\x9c\xf3\x39\x8d\xf7\x7e\xe5\xf3\xae\x9c\xcf\x6f\xce\xf9\x9c\xc6\x7f\xbf\xf2\xf9\xee\x9c\xcf\x93\xe4\x73\x35\xee\x2b\x95\xe2\xc1\x5f\xf9\x7c\x4f\xf6\xe7\x72\xbc\x97\x52\xe2\x3d\xba\xaf\x0a\x66\xd5\x12\x3a\xab\xfe\x35\x55\x5e\x9b\x13\xef\x49\xf0\xe3\x15\x78\xf2\x0e\x04\x81\x2f\x95\xe1\xcb\xca\x73\xe1\xe9\x9c\xa6\x53\xe7\x96\x43\x64\x57\x8c\x3a\xb7\xe8\xf7\x12\x4a\x8a\x4e\x52\x58\xb2\x7e\x2a\xc5\xaa\x32\x0c\x5d\x3f\xfd\x22\x55\x5b\xc5\x2b\xef\xfe\x50\x38\x25\x46\x85\x88\xba\xb9\x28\x0b\xa3\xfa\x4e\x93\xc4\xeb\x4e\xb5\x6f\x64\x0d\x08\x78\xad\x91\x79\xad\x19\xd8\x1b\xaf\x0a\xbc\xf2\x2e\x4a\x06\x6f\x8d\x82\x17\xa9\xef\x2c\x48\x7b\x55\xa5\xb3\x57\x48\xc4\x66\x25\x7b\x3f\x94\x2d\x68\x2a\x5e\xa4\xbe\x87\x20\xc1\xdf\x8a\x18\xe9\x9c\x11\xc6\x46\xe0\xed\x8e\x5e\xe1\x75\xea\x7a\xc2\xa1\xf4\xa5\x9a\x75\x8f\x53\xca\x73\xb6\x59\x5c\xaa\x99\x63\xd5\xbd\xb8\xb2\x9e\x9b\xf6\x31\x75\x01\xb7\xba\x17\x97\x9c\x83\xcd\xad\xc6\x2f\xf0\xc7\x90\x11\x85\x12\x66\x3d\x3d\x05\xd0\xac\x27\x97\xa6\xa3\xd6\xe3\x2d\xd5\x9a\x43\xe4\xc9\x4d\x58\xd1\x41\xb8\x21\xda\x80\x5f\x08\xf7\x59\xd1\xa7\xef\x24\xfe\xd8\x79\x93\x2e\x6f\x88\x8f\x8e\x3e\x4c\xce\x75\x15\x27\xe1\x1f\xd3\xab\x90\x19\x05\x13\x66\xb3\x60\x32\x59\xac\x7a\xf6\xfc\xa4\xde\x84\xaa\x8f\x2b\x07\xf6\x92\x1b\xb7\x32\x67\x65\xc6\xf1\x16\x8f\xdf\x1a\xa9\x2a\x59\x7b\xc3\xe9\x88\x4f\x58\x60\xda\x72\xc7\xff\x3b\x7e\xd2\xff\xe4\x9e\x64\xf6\xf1\xcf\x23\x1f\x8a\x26\x6c\x6e\x8f\x47\x6f\x30\xf8\x3d\xbc\x65\xa5\xd3\x80\x36\x92\x1b\x0c\xf3\x8e\xd3\xa3\xd4\xd4\x7b\x54\xfa\x32\xe4\x1a\xa7\xe8\x20\x26\x5e\x57\x00\x5f\x4d\x71\x2b\xc6\x27\x2a\x26\x8e\x19\x11\x6e\x6a\x34\xb4\x9b\x6a\xce\x6f\xad\x9a\x38\x66\x58\xc1\x4c\xc7\x54\xc7\x4c\xee\xc9\x58\x9f\xd8\xa0\x96\x59\x97\x0e\x84\x9f\x57\x6e\xfa\x2d\x39\x9f\xc0\xc1\xbd\xcc\xdc\x2b\x1c\x86\xdf\x74\x28\x8c\x86\x26\x0a\x75\x1c\x62\x39\xd6\x11\xcc\xcf\xb7\x3b\x1c\x85\x01\x87\x5e\x9f\x6f\x71\x73\x09\xcc\x73\xfc\xfa\x76\xc4\x6d\x92\xef\x75\xcf\xf3\xdb\x8f\xd5\xd5\x91\xc3\x78\x15\x6e\x32\xe7\xc6\xc9\x87\x1d\xba\x54\xe6\xb0\xca\x1c\x83\x0f\x3d\xd4\xfd\xc5\xc3\xff\x29\x19\x3d\x7c\x70\x7e\xbc\x46\x3f\xc1\x32\x6d\x4c\xd9\xe8\xe1\x89\x60\xbb\x6d\x82\xb9\xa2\x8d\x3b\xb2\x7f\x3f\x86\x7f\xc6\xa2\xb2\xa2\xe6\xfa\x55\x8b\xe0\xc7\x65\x1d\xd3\x1b\x73\xf3\x27\x6a\x7b\xbf\x93\xf4\x43\x89\x37\x02\x39\xf1\x06\xb5\xbd\x39\x92\x7f\x20\x30\xb9\x39\x95\xbd\x94\x6d\x26\xef\x75\xfc\x1a\x0e\x6a\x3f\x73\x24\x7b\x33\x4a\xf9\x40\x14\xf2\x01\x43\xb4\xa6\x97\x5c\x6d\xa7\x8a\x97\xe2\x93\xdb\x68\x6c\x4d\x3c\x45\xf7\x35\xea\xd4\x75\x99\x43\x62\x25\xf5\xcb\x75\x74\xbd\xe6\x94\xf2\x9c\x6d\xee\x9e\x44\xfd\xdd\x29\x5a\x6f\xd7\xa9\xf5\x76\x2d\x7c\x05\x85\xaf\xd4\xc2\x6b\xde\xb1\xaf\x94\x6d\x67\xbe\xb4\xee\x1d\xf7\x39\xd5\x73\x58\xc8\xdd\xfe\xdc\x6a\xe6\x72\xd0\x55\x1e\xd9\x51\x4b\x02\xf2\x3d\xc1\xce\x73\x1c\x83\xed\xd8\xe1\xb4\x5a\x79\x6c\x24\xb7\x0d\x9b\xf7\xb6\xdb\x79\x24\x8f\x36\xb9\x8b\x2e\xfb\x9e\x2b\xa2\xc9\x51\xb6\x21\x1e\xc9\xe8\x33\x73\xf9\xa2\xe7\xbf\x10\xdf\x96\x94\x9a\x7b\xdc\x8c\x0b\xac\xaa\x62\xab\x74\x7f\x9b\x4d\x97\xe5\x38\x24\xd3\xc5\xac\x11\xcb\x74\xf1\xaf\xd2\x8d\x7b\xd8\x68\x03\xab\xb1\xa3\x3b\xbe\x78\x7e\xd1\x44\xc5\x96\xac\xe2\xdf\xcd\xb8\x50\x43\x98\x49\x7f\xc3\x2d\x67\x0e\x0a\x5f\x20\x3f\x8a\xa2\xe1\x09\x57\x24\x10\x88\x46\x0d\x1e\xaf\x17\x6c\xab\x38\x12\x89\x16\x44\x0b\x80\x6c\xc2\xd0\x0e\x36\x86\xbc\xbc\x25\xba\x1f\x8f\x40\xad\xb2\x76\xcb\xef\x28\x64\x94\xdc\xd1\xbb\xe1\x35\x12\xcb\xd3\x69\x98\xfa\x3e\x63\x84\xd5\xe3\x5b\xab\x2e\x18\x37\xa2\xa0\xb1\x4e\x3f\xd5\x7e\xf1\x26\x99\xd3\x93\xa1\xe2\x50\x7d\xcb\x45\x17\xb7\x84\x63\xe1\x86\xe6\x5b\x2f\xaf\xca\xf0\xac\xe6\xe8\x29\x25\x47\x67\xee\x3e\x40\xb3\x57\x3b\xcd\x5e\x1f\x49\xb9\x82\xd6\xec\x3d\x89\x12\xfc\x78\x05\xde\x30\xea\x35\x0a\xef\xa0\xf0\xfb\x52\x4e\x57\x6f\xf0\xc2\x7f\x24\x78\x72\xb6\xcd\xef\xa5\x2c\x79\x0b\xe4\x4b\xe6\xa7\x59\x86\x50\x22\x61\x45\x83\x0a\xfb\x45\x06\xf6\x0d\xa2\x5d\xcd\xc8\x7d\x26\x58\x6a\x0b\x12\xdf\xdb\xde\xd6\x64\xf4\xcf\xa7\xf2\x4a\x7b\xe5\xe3\xb0\x5a\xbb\xd8\x8c\x20\xa7\x41\x05\x09\x03\xa0\xf5\xc9\xef\x1e\x3e\x95\x8a\x54\x59\xb5\xc7\xf3\xa4\xe5\x3d\x9b\x74\xcf\x5a\x95\x3a\x6f\xfd\xa8\xbe\x3f\x85\x6c\xbe\x9c\x3d\x9b\x12\xfc\x74\x15\x5e\x9d\xb7\xe8\xf9\x5f\xd8\x6a\xcb\x86\x17\x7f\xa4\xf0\x3a\x75\x4d\xe2\x90\x48\xf7\x86\xa4\xaf\xa4\x6b\x1b\xa7\x94\xe7\x60\x7b\x5b\x7b\xb3\x29\xbd\xd6\xa6\xf4\x7a\x1e\xb8\x32\xff\xff\xb0\xa9\xa8\xdb\xeb\x8b\xf6\xc5\x03\xb1\x64\x53\xc7\x26\xf5\x05\x9d\x09\x4b\x36\xf5\x70\x74\x74\xbc\xf1\xf2\x0b\xcf\xeb\xd5\xa6\xf4\x5a\x9b\xd2\xeb\x31\x6b\xc6\xe6\xff\x1f\x36\xa5\xd2\xa5\x36\x35\x59\x22\xab\xd8\x94\x86\x70\xb6\x4d\x8d\x4c\xe4\x07\xb5\x36\x15\x0c\x46\xc3\x60\x47\x09\x62\x4f\xd1\x68\xf8\x39\x6c\x46\xed\x28\x4a\x8c\x4a\x3a\x2a\x37\x1e\xa7\xb3\x98\xb3\xe5\x7f\x36\xab\x0c\x5f\x67\x34\xab\x2d\x32\xb3\x3d\xcc\x4a\xc3\xb6\x5a\x43\x4a\x29\x35\x24\x39\x46\x94\x2b\x65\x3f\xa4\xfc\x85\xba\xec\x35\x22\x09\x7e\xbc\x02\x2f\xc7\x88\xf2\x4a\xe5\x0f\x29\x9f\xbf\x37\x78\x6a\x57\x4b\x25\x5b\xc1\x92\x5d\xfd\x45\xb1\x15\x4f\xc6\x56\x24\xd8\x2f\xb2\x61\xc1\xae\x86\xf5\x02\xbb\x0d\x7c\xfb\x44\x9a\x5f\x2c\x92\x6b\xea\x2e\x69\x9f\x4e\x31\x8d\x00\x7f\x48\x15\x17\x66\x9d\x11\x91\x0b\x7f\x14\x06\x81\xc2\xc7\x28\xfc\xe7\xa9\xf2\x62\x73\xcf\xda\xda\x4e\x55\x2e\x52\x7c\x49\x17\xfa\x09\xf6\x70\x55\xaf\xfd\x3c\xac\xd6\xee\x36\x93\x63\xa8\x65\xbb\xcd\x97\xed\xf6\x87\x54\x49\xad\x0e\x65\xdb\x6d\xf6\xde\x27\xc1\x30\x12\x49\xf3\x2a\xd9\xfa\x85\xcc\xee\xac\x7d\x55\x12\xec\x74\x75\x9f\x54\xc6\x66\x8d\x04\xda\x94\xf3\x8e\xa4\xf8\x1c\x85\xd7\xa9\xeb\x11\x87\xa4\x75\x0d\xf1\x24\x5d\xbf\x38\xa5\x3c\x07\x9b\x75\xa9\xeb\xa0\x1d\x34\xdf\x8d\x67\xd6\x41\x11\x9b\xfe\x8a\x7b\x9b\x79\x91\xff\x8c\xdc\x7f\x86\x2c\xa8\x21\x11\x10\x78\xde\xa0\xd7\x9b\x40\x24\x46\x93\xc9\x6a\x66\x30\xb3\xbe\xdd\x64\x10\x30\x09\x86\xde\x94\x0e\x64\xd3\x28\xb2\x7c\xc6\x71\x43\x5c\x47\xad\x19\x0c\x2b\xce\xbc\xd8\xd5\xf5\xd5\x92\xc3\x4f\x3d\xdf\xd5\xc5\xbd\xfd\x6c\x97\x05\xeb\xcc\xe2\xbf\x9e\xed\x95\x16\xc7\xf3\xba\x1e\xb4\xc0\x81\x00\xad\x37\xe3\x67\xa6\x15\xa3\x16\xac\x93\x69\x89\x9b\x9f\x3a\xbc\x64\x00\x25\x96\x34\x8b\x3f\x59\x2c\xcf\x92\x98\xf9\x28\xf7\x12\xfe\x9b\xa0\x03\x5f\x11\x49\x18\x11\x4f\x4e\xc7\x17\x74\x3c\x03\xfe\xe1\xa9\x76\x9e\x1e\x64\xad\xb9\x95\x8a\x9e\x97\x8d\x37\xbd\xfe\xd6\x30\x68\x55\x18\x13\x3f\x8a\x68\x72\x6d\x9d\x9a\x8f\x1e\x42\x47\x35\x71\xba\xba\x33\x32\x03\xcb\x8d\x55\x6a\xb0\x6a\x2c\x8f\x6b\x1b\x6a\xf2\x34\x67\xfe\x50\x38\xa5\xf6\x4a\x72\xa0\x36\xd4\x33\xd3\x57\x6b\xb4\x3b\x95\x1a\xad\xba\x0f\xae\x9e\xae\x12\x0d\xce\xae\xe7\x52\x9c\x3b\x15\x9c\x6a\xfe\x23\xe3\xac\x97\x71\xa6\x6b\xc8\xda\x25\xd5\x99\x3a\xd9\xcf\x4b\xb5\x98\x2b\xe9\x9a\xe6\x29\xe5\xb9\xe4\xe7\x09\x3c\x5d\x9b\xd0\xa9\x6b\x13\x2a\x3c\x5d\xe3\x38\xa5\x3c\x57\xe0\x51\x7f\x9a\xf3\x4e\x91\x9e\x3b\xe4\x5c\x95\xc8\xa0\xa5\xba\x22\x68\xd4\xe6\x33\x8f\x31\x43\xf9\x97\x60\x6c\x20\x7f\x60\x58\xf2\xe6\x8d\xa0\x63\x57\x92\xa0\x3f\xef\xb8\x66\x5c\x5c\xe4\x3c\x71\xdd\x0f\xd7\xbd\x05\x0d\xdc\x98\x0d\xfd\x0c\x6d\x4f\x40\xee\xf1\x0c\xcd\x3d\xca\x13\x16\x46\xca\x3d\x18\x06\x09\x48\xa0\x43\x4b\x72\x10\x25\x8c\xd1\xe4\x21\x19\x9f\xba\x57\xf1\xf3\xaa\xab\xc4\xe9\xf7\xc4\x6f\x50\x05\xaf\x23\x19\xc2\xd3\x98\x61\x38\x72\x90\xb3\xe4\xae\x81\x07\x47\xd4\x51\x31\x91\xd7\xfd\xf4\x7f\x82\x9f\x9c\x5b\x5e\x08\xb0\x9f\xf0\x37\x22\x2b\x44\x57\x45\x26\x64\x34\x9b\x4d\x48\xe0\x10\xcf\xb1\xd8\x66\x61\x4d\xbc\x95\x61\xf4\x2c\x0f\xb3\x20\xcb\x62\x83\x0e\x03\x22\x72\x6c\x79\x35\xe0\x53\x4e\x30\x84\x08\xb5\x4e\x3d\x95\x0e\x08\x44\x1d\xba\xd2\xa6\xd2\x26\x5f\x93\x4f\xe7\xd3\x95\x56\x4c\x5c\xd1\xb4\x73\xa7\xfc\x6f\x85\xf8\x0d\x9f\x5c\xd9\xf4\xe8\xef\x9a\x77\xed\x6a\xfe\xdd\xa3\x4d\x2b\xa9\xfc\xd2\x7f\x16\xbf\xc1\x7b\x81\x07\x23\xaa\x49\x78\x0c\x0c\x8f\xf4\x2c\x8b\x10\x2f\x98\x38\x1d\x86\xbf\x82\x51\x40\xe4\x00\xe6\x16\x4a\x14\xf2\x91\x3a\xe5\xba\x46\x7a\xce\x75\x53\x94\x1c\xc7\x59\xda\x84\xf7\xfe\xad\xe9\x86\xff\x8e\xc7\xa3\x6e\x68\xe2\x76\x7e\xd8\x74\xcd\xcf\xf3\xf8\xbf\x5f\xd3\x4c\xce\xba\x1e\x0d\x7d\x2c\xa3\xf8\xab\x12\x2e\x3d\x27\x18\x58\x56\x10\x10\x36\x91\xd3\xc7\x0d\x98\x76\x4a\xba\x14\x32\x83\x9c\xe0\x86\x9e\x44\xa1\x07\xd0\x8f\x48\xd9\xf8\xff\xde\xd0\xf4\x37\xc0\x8f\x47\x41\x17\x36\x5e\xd3\xf4\xe1\xc7\xcd\xd7\x50\x1d\xd9\x85\x5f\xe6\x8a\x98\xd1\x4e\x41\x27\xdd\xed\x2a\xff\x1f\x64\xef\x05\x3b\x65\x39\x1e\xa3\x03\x49\x7c\x50\x36\x50\x82\xb5\x21\xe2\xd9\xc5\xfe\x16\xbf\x7c\xcb\x2d\xa4\xef\xa7\x00\xfe\x3d\x05\x1e\x34\x87\xcb\xc0\x63\xf9\x10\xfa\x88\xc7\xc8\x7d\xd2\x13\xde\x03\xfe\x5a\x81\x47\xd5\xbd\x82\xc3\x5c\xff\x0b\xe8\xf0\x3b\xe9\x1b\x68\x8e\xd8\x98\xb0\xe8\x18\xc6\xc0\x61\xac\xe7\xf8\xe7\x92\xdc\xfe\xf4\xe1\x84\xd5\x60\x6f\x03\x1c\xcf\x25\x31\x39\x85\x90\x20\xaa\x44\x7e\xf8\xa6\x9e\x86\x5f\x5b\xa3\x03\x94\x3c\xf9\xe2\xde\xfb\xa5\x82\x7b\xef\xa3\xce\xce\xe3\x9d\x9d\xe4\xae\x85\x35\xec\x74\xb6\x15\x74\x97\x85\xb9\xc3\xca\x92\x5b\xfb\x18\x8e\x47\x78\xab\xa2\xb5\x1a\x87\x14\xc1\x6c\xeb\x4e\xf1\x3f\xb8\x89\x3f\xd6\x7d\x07\x35\x64\x68\xbf\x0e\xda\x0f\x56\xda\x43\x63\xe9\xce\x3e\x76\x6b\x3b\xce\x6d\xef\x8a\x00\xf4\x4e\x6c\x10\x5f\x67\xa7\x33\x97\x77\xdf\x21\xb5\x9f\x26\x6e\x66\x6d\x98\x85\xf6\x85\x09\xbb\xda\x1e\x6d\x6d\xe7\xf0\xbd\xed\xa8\xb2\x07\x86\x69\x14\x83\xb8\x59\xc2\x80\xf1\x5a\xa0\x9f\x50\xe8\x23\x96\x9c\xb7\x41\x4e\x3d\xdf\xda\xce\xe4\xd0\x37\xe0\x88\x8b\x79\x45\x7c\x1d\x1b\x76\x66\xe8\x33\xe8\x49\x76\x3a\x97\x47\xdb\xeb\x50\x3c\xe1\xd7\x71\x1c\x2f\x08\x8c\x24\x08\xbd\x01\x7a\x02\xa2\xd0\xb1\x4a\xec\xa6\xb9\xb2\x4e\x23\x96\x08\x7c\x31\x17\x53\xd1\x30\x75\x1a\x09\x49\x52\x62\xd0\x53\x40\x23\x28\xd3\xa8\x4e\x78\x79\x81\xf6\x53\x40\x1c\xa7\x37\xe8\x58\x22\x2c\x1e\xf7\xa0\xa0\x44\x86\xd0\xe9\x08\x7c\x31\x97\xd2\x8e\x77\xbf\xa9\x91\xa0\xd4\x0b\xc0\x2f\x6e\xe2\x82\x98\x91\xf5\x23\x28\xe3\xd7\x21\x81\x25\x14\x20\x18\x45\x84\x82\x9e\x0a\x14\x48\xa8\x64\x7c\x67\x23\x23\x6e\xca\x90\x01\x3b\xd9\x0d\xfd\x60\xc9\xde\x49\xdd\xfb\xe9\x42\xea\x7d\xdf\x47\xf4\xba\x69\xa0\xb0\x2f\x5d\xc9\x79\xf9\xa3\xc8\x04\x3d\xf4\x19\xc1\xd7\xe8\x74\x66\x8b\x89\xe3\xb9\x17\x93\x46\x5e\xc7\xbf\xd4\xae\x03\x46\xab\x5b\xb3\xe8\x2b\x12\x8c\xb2\x7c\x03\xcf\xc6\xd9\x98\x87\xe9\xb2\x2e\xb6\x8a\x5b\xf0\x9c\xbc\x97\xf3\xf0\xa5\xec\xc7\xbf\x8c\xe1\x9e\x72\xec\x70\xe1\xcb\xc5\x3b\x5c\x3b\xb2\xe8\x78\xd0\xb8\x44\x05\x72\x38\x58\x9b\xce\xcc\x99\x6d\xac\xd5\xea\xf5\x39\x4d\x66\xd3\x8b\x49\x87\xd9\x6a\x7e\xa9\xdd\x8a\x90\x4e\xd0\xbd\x98\xc4\x02\x27\xbc\xd4\xce\xa1\x6a\x85\xb2\xbf\xb5\x87\x0c\x14\x46\x3c\x31\x57\xd4\x05\xac\xb8\x54\x7e\x62\xac\x8b\xf3\x8a\x77\x01\x37\x84\xa9\xa2\x22\x95\x35\xf1\xae\xa2\x22\x5c\xb1\xc3\x25\xde\x81\x2f\x77\xed\x70\xe0\x19\x78\x86\xca\xa7\x43\xbc\x4f\xbc\x8f\xe8\xe6\x38\xbc\x81\x5d\xce\x1e\x04\x99\x78\x9e\x41\x82\x60\xb6\x90\x2b\x4b\xaa\xe3\xd5\xea\x3d\x96\xd2\x5d\x3b\xf4\xd5\x7f\x76\xf9\xef\x16\xcd\x7f\xe8\xc1\x05\x8b\x1f\x61\x76\x2d\xd9\xb1\x63\xc9\xe2\xfb\xc9\x1a\x32\x8b\x96\x80\x3d\x4c\x46\x1f\xd2\xb1\x35\xa1\xbe\x09\xaf\x49\x4f\x2a\x44\x2c\xa7\x67\xcd\x16\xd0\x4f\x04\xa3\x4a\xca\x5c\xd5\x75\x75\xca\xad\x4c\x99\x1b\x29\x22\xf2\x01\xb4\xe4\x8b\xdd\xb5\xbb\xfb\xc0\xe3\xdd\xfb\xf7\x7c\x48\xff\xa8\x3e\x9b\x7b\x07\xe6\x3c\xcf\x33\x1c\xe8\x8c\x80\x58\x06\x49\x2e\x94\x56\xdd\xc8\x3c\x13\xf1\x54\x4c\xc0\x1f\x71\xd7\x11\x4f\x3c\x16\xfc\xf0\x79\xe0\x87\xcb\xe5\x36\x18\xf4\x4b\x20\xea\x45\xfa\x84\x95\xcb\x75\x22\xd0\x4a\x3c\x0f\x7f\x34\x81\xbb\x6e\xec\xcf\x05\xfc\x46\x69\x7e\x70\x42\xbb\x93\xfc\xf5\xd0\x8b\x82\x84\x19\x31\x0c\xcf\xea\x31\x44\x40\x60\x5a\xc4\x71\xab\x6e\x5b\xf2\xd8\x84\xee\xc9\x23\x13\x8f\xe0\x8f\xd8\x77\x7e\x29\xe0\xfe\x8e\x9f\xca\xc2\x61\x22\x73\x80\x91\xd7\x83\xee\xf3\x0c\x64\x58\xe4\x2e\x10\xd6\x20\xb0\x74\x62\x23\xb8\x34\x93\x80\x06\xa3\x27\xa2\x60\x15\x97\xe0\xdb\x14\xcc\x63\xc5\xaf\xb3\x71\xf7\x4d\xb8\xb1\x20\xe8\x59\x93\x09\x72\x29\x72\x9d\x28\x8c\x80\x81\xde\x50\x50\xad\x22\xd7\xa4\x6e\x2c\x3d\xfe\x93\x52\x88\x9e\xc4\xb7\x01\xea\x8f\x80\x06\x17\xc6\x9e\xb1\xe2\x18\x42\x82\xf4\x5f\x27\xd7\x5b\xaf\x87\x71\xb4\xa1\x3c\x14\x43\xb5\x68\x20\x6a\x43\x37\x25\xc6\x82\xa5\xe2\xaa\x68\xb4\x24\x14\xc2\x2c\x6b\x19\xda\xbf\xff\xa0\x06\x30\x2c\xaf\xc5\x02\x11\x20\x37\x6a\x64\xdd\xe0\x7d\xc9\xe6\xba\x67\xda\x9b\x47\xc0\xcf\x40\xb0\x7c\x5f\xb2\x30\xf8\x4c\x3b\xb9\x95\x82\x2b\x2c\xac\x86\xff\x05\x8c\x81\x7d\x49\xce\xf8\x4c\x3b\xe7\x82\x9f\x1f\x81\xd3\xab\x54\xaf\x8b\xa1\x17\x8a\xd3\xff\x55\xe6\x1e\x3e\xeb\xcc\x3a\xc7\xd4\x15\xc5\x71\x4c\xaf\xf3\x91\x14\x52\x73\x3d\xb2\xab\xce\xd1\xcb\xd3\xc6\x33\x40\x6f\xdc\xc0\x8c\xd8\x28\xda\x97\xcc\xbf\x72\xe1\x15\x57\x2c\xfa\xa8\x4f\x63\x4b\x4d\x5d\xe3\xcc\xed\x9f\x5f\xb9\x70\xf1\xd2\x45\x1f\xd7\xd4\x37\xd7\xd6\x34\xc7\xeb\xf0\x9d\x04\x60\x11\x7d\x42\x00\x2e\xc1\xb7\x31\x2b\xf0\x55\x9b\x37\x6e\xde\x72\xcf\xc6\x4d\x9b\xc4\xf7\x67\x4c\x99\x74\xc9\x25\x93\xc4\x7d\xe2\xfb\x9b\xb7\x6c\xd9\x4c\x9e\x5c\x32\xe9\xc2\x59\x1d\xd3\x92\xf8\x36\x02\x74\xf7\x26\xe9\x11\x01\x02\x3b\x3b\xc5\x9e\xc7\xbc\x47\xfd\xab\x8f\xe4\x3f\x64\x02\x43\xc4\xfd\x6b\x2c\x2d\xca\xc6\x99\xc7\xd7\x94\x7f\x02\x90\x2b\x88\xdf\xc7\x1e\xf6\x3c\x76\x9f\xec\x93\x23\x30\xf3\x31\x8c\x0e\x06\xdd\x40\xc2\x3e\xda\x34\x5e\x5d\xa7\xf5\x51\xd0\x9e\x7c\xb1\xb7\xaf\x2d\xfb\x44\xf4\xc8\x88\xba\x57\x31\xf4\x3c\xd7\x47\xd8\xf3\xb8\x72\xea\x17\xbf\x14\x9f\xa0\x2b\xd3\x5f\x62\xe2\x1d\xbf\xc4\x13\xe8\x1c\x37\x05\xad\x61\xa7\xb1\x8f\x23\x3d\xaa\x4b\xf8\x90\x5e\x4f\xcc\x06\x63\x83\x91\x01\x3d\x83\xa9\x85\xfd\xa6\x1d\x9d\x94\x43\xc4\x81\xd5\xf1\xac\x29\xa0\xb6\x26\x86\x1b\x70\xdc\x63\xc0\x1e\x66\x97\xf8\x04\x1e\xf7\xa4\xf8\x24\x3e\x7f\x0d\x9e\xd7\x8a\x17\x87\xc5\xdb\xc5\x0d\x21\xc0\x7f\x39\xe0\x5f\x28\xe3\xf7\xb3\x7a\x81\x47\xbc\x9e\x25\x04\xf4\x3a\x96\xbc\x5e\x26\xf4\x46\xc0\xa7\x1c\x61\x1b\x6d\x30\xe0\x86\x38\xe0\x2f\x7c\x0a\x8f\x17\x9f\x78\x02\xd0\x87\xf0\x7c\x7c\x45\x58\x5c\xd3\x4a\xd5\x16\xfd\x0b\x78\xfc\x84\x1f\x2a\xfb\x20\x1b\x1a\x90\x08\x31\xe4\x10\x64\x12\x68\xda\x38\x9b\xdd\x61\xc0\x98\xb1\xf0\x1c\xbf\x2d\x69\xe6\x8c\xa0\xd0\x20\x79\xb5\xd4\xa1\xbd\x40\xca\x27\x8b\x92\x1c\x96\xab\xfe\xbc\x77\x93\xff\xc8\xab\x2f\x31\x01\xfa\x03\xe2\x91\x67\x7e\x3e\xf8\xfa\xeb\xca\x4f\x1a\xdb\xff\xc2\x3f\xce\xbd\x23\x98\x9d\x3a\x74\x0e\x74\xe6\x66\x3a\x0f\x1c\x23\x97\x14\xf1\xc3\x80\xa7\x7c\xf0\x27\x98\x81\x69\x14\xe6\x7d\x01\xf9\x91\xe6\xca\x79\x72\xb2\x0a\x28\xf6\x39\x4b\x99\x43\x8b\x01\x16\xfa\x42\xde\x2e\x65\x5e\x93\xc7\x9d\xf4\xa5\x2d\x51\x62\x23\x27\x3a\x9b\x89\x13\xb5\x3b\xcc\x96\xfb\xdb\x0d\xfa\xfb\xdb\xcd\x06\xb3\x01\x32\x34\xee\x7e\x32\x35\xe3\xfb\xdb\x91\x53\x73\x0b\x93\x64\x56\xca\x85\x7d\x64\xa0\x64\x5f\xcb\x6a\xbe\x18\xfe\x65\xe9\xcf\x87\x1f\x72\xdf\x7d\xf8\xa1\xd8\x0e\x5f\x49\xc9\xef\x2a\xbe\xc6\x46\xea\xfd\x82\xd1\xa8\x37\x43\x08\x64\x33\xb3\x16\x0b\x32\xf2\x2c\xb2\xd8\x4d\x36\x1b\x38\x37\xce\x42\x84\x4c\x6f\x87\xa1\x9e\x47\x71\x3d\xc4\xc9\x69\xe7\x2d\x36\xee\x88\x42\x68\x17\xa5\x37\x18\x13\x2f\x74\x04\x5c\xdc\x91\x23\x8a\x17\x02\x07\xa7\xfa\x21\x46\xa5\xcd\xca\x9e\x4e\xa7\x33\x40\x1c\x62\x30\x1a\x41\x00\x20\x01\x9e\xc4\xaf\xbf\xe2\xe9\x58\x87\xe4\xea\xb6\x91\xfb\x6e\xce\x27\xae\x8e\xd0\x10\xb7\xe1\xa7\x54\x67\x87\xd3\x76\xa0\xf1\x2d\xd0\xa0\xf3\x0a\xb8\x37\x98\x83\xb1\x92\xbd\xc4\xeb\xa8\x43\x66\x23\x6c\xc5\xc4\x57\xf1\x27\xaf\x42\x28\x5e\x42\xa6\xcd\x4c\xbb\x5b\x21\x32\x82\x39\x42\xc0\x30\x25\xe9\x10\xb9\xc9\x87\xe9\x31\x47\x10\x1e\x82\x18\x30\x7c\xfb\xad\xec\xc7\x0f\x88\x23\x68\xff\x1c\x80\xe3\x1b\xc8\x13\x04\xc8\x14\x2a\x12\x4e\x4e\x6f\x34\x62\x1d\xcf\x43\xba\x00\x7c\x98\xf4\x94\x11\xb5\x5f\x64\x8a\x90\x16\x98\x80\x25\x92\x24\x34\x95\xea\x7c\x15\x13\x5f\xf9\xe6\x9b\x57\x26\x5e\x7b\xed\xb5\xc0\x1b\xff\xf4\xc7\x1f\x3f\xfd\xf4\xc2\x85\x0b\xb4\xe3\x66\x81\x1c\xc7\xab\x17\x8c\xac\x05\x1b\x21\xbf\x32\x59\x0d\x16\x0b\x98\x19\x67\xca\xcc\x12\xb2\xf0\xe4\x51\x52\xc6\x48\x3b\x42\x7e\x75\x80\xc4\xad\xea\xf8\x60\x7c\x09\x58\xd6\xf5\xdc\x36\x88\x6f\x06\x24\x0a\x2d\x7a\xbd\x01\x79\x0c\x1e\xaf\xcf\xe2\x70\x70\xff\x48\x3a\x1c\x36\x13\x36\x25\x4c\xce\x36\x93\xc1\x0e\x46\x80\xaa\xa7\xd5\x55\x57\x4e\x8b\x57\x6b\x2e\x6a\x93\xe3\xb9\xac\x9b\x64\x95\x1b\x70\x59\xa6\x71\x78\xdb\x05\x2b\xb9\x2b\x05\x26\x7a\xf1\xa8\xcb\x2f\x62\x74\x78\xed\x94\xe1\x33\xa7\x8b\x9b\x70\xfa\xb6\xf9\x83\xfb\x5d\x76\x95\x38\x36\x9d\xc6\x38\x3d\x9b\x3d\xce\x5c\x6b\xd7\xf1\x33\xd2\xff\xea\xbe\x8d\xd8\x20\x0e\xa7\xe7\xb2\x5d\xcc\x2a\x78\x36\x07\xa1\xee\xb5\xf4\x59\x41\xfa\x52\x76\x0f\xb3\x12\x9e\x2d\x84\x67\x6b\xe8\xb3\xbc\xf4\x6f\xd9\xbd\xcc\x62\xc8\xc0\x6b\x98\x99\x32\x5c\x18\xe0\xba\x28\xdc\xa5\x12\x1c\xb0\xde\x08\xf2\x5a\xc7\xbf\x8b\x0a\xd0\xdc\x44\x0b\xef\x87\xfe\xe9\xdd\xa8\xc0\xe4\x74\xda\x0a\xdc\x7e\x3e\x5c\x68\xf7\xe8\x3d\x9d\x49\x8b\xde\x60\xee\x4c\xda\xf4\xd8\xc6\x92\xeb\x7c\xdc\x8c\xdb\xd1\x99\x74\x3b\x11\x0a\x32\xc1\xce\x24\xf1\x34\x52\x45\x33\x63\x97\xe4\xda\xba\x4c\x7c\xa7\xb9\xc1\x98\x4a\x45\x9e\xa7\x7c\x52\x30\x20\x7f\x95\x30\x8e\x7a\x27\x39\x7d\x89\xf9\x6f\x9f\xbd\xdb\x6e\xb9\xfd\x6e\xa6\x43\xbc\x00\xdf\x20\x5e\x8d\x8f\x74\xdf\xfc\xfd\x37\xe2\x3f\xb7\xbe\x5d\xcc\x3d\x7e\xef\x93\x07\x8f\xec\xc7\xf8\xe9\xdb\xc4\x3f\xdd\x2a\x1e\xb8\x0d\xbf\xc5\x80\x63\xe0\x7f\xc2\xfc\x86\xeb\x49\x9c\xb6\x30\xbd\x8e\x5b\x0a\x7e\xa5\x10\x91\xca\xf4\x2d\x89\xe1\xa5\x41\x9f\xdf\xe9\x0a\x17\x42\xa4\x46\x42\x61\x0b\x57\xe8\xf2\x07\x85\x3e\x7d\x03\xde\xe2\xf2\x88\x81\x67\xbc\xee\x72\xb3\x81\xd1\x23\xb3\xde\x0c\x3d\x77\xfb\x9d\xf6\x44\x89\xd1\x6e\xec\x48\xda\x5d\x15\x51\x14\xed\x48\xb2\xe1\x02\xf0\xbd\xad\x75\xc7\xeb\x32\x61\x2b\x39\x8c\xbc\x8e\xa6\xcd\x60\x4e\x64\xc1\xaf\xc5\x99\xb9\x86\x20\xeb\x6c\x72\x55\x11\xbc\xbe\xa6\xb8\xce\x0b\x39\x30\x6e\x74\xf9\xac\x38\x5a\xaa\x8b\x36\x95\xc0\x37\x57\x89\xc3\xee\x6c\xc5\x71\x57\x49\x29\xc0\xb0\x6e\x9f\x4b\x60\x98\xb7\x27\x0c\xab\x59\xdb\x76\x5e\xcd\xa3\x1e\xf1\xf4\x3b\x97\xdd\x3f\xee\xfb\xed\xa5\xc1\xb5\x45\xa3\x86\x37\xad\x4d\xfe\xf6\xeb\x2f\xa2\x6b\x87\x9e\x33\x5e\x3c\x51\x3b\xe1\x03\xd3\x1b\x0b\x2e\xe1\x2f\x34\x14\x6d\x3f\x75\xfe\xb2\xc1\xf5\xa7\x6f\x61\xb1\x6f\xf0\x8b\x7b\xf1\xf4\x2b\xbc\x75\x07\x71\xf5\xd3\xb8\x11\x27\xf0\x64\xcf\x52\xf1\x99\xb8\xee\xf4\xf8\x31\x51\xc6\x34\xfb\x5c\xe6\xa9\x4a\x31\x2d\xe5\x0a\xe4\xae\x8c\xa5\xfc\x14\x54\x8e\xa6\x27\xea\x50\x81\xde\xe3\x61\x99\xe2\x68\xd4\xe7\xf7\xdb\x98\x02\xae\xa2\xd2\xec\xe8\x48\xea\xcd\x66\xde\xc7\x17\x17\xf3\x3e\x36\x58\x58\x58\xda\x91\x2c\xe4\x18\x4f\xd0\xd3\x91\x0c\xba\x32\x17\x3b\x3a\x91\x8f\x8c\x79\xb5\x23\x2e\x5d\x9e\x9f\x7d\xba\x3e\xb9\x18\xcf\x47\xee\xa8\xf2\x4a\x37\x29\x2b\xb7\x54\x49\x72\x28\x44\xe4\xc2\x3c\x10\x0c\x39\xd8\x8a\xc1\xfd\x8e\x08\xbb\xf4\x5c\xe5\x82\x59\xc5\xb1\xe2\x01\x0b\x96\x1e\x9a\x45\x3a\x2f\xfe\x24\x7e\xce\xf8\x1f\xf9\x72\xd8\xa3\xb1\x6d\xb3\x1f\x7b\x98\xd9\x29\xce\xb8\x18\x3f\xbc\xe8\xd6\xfd\xb1\xdb\x66\x19\x1f\x36\xbe\x98\x7a\xce\x8d\x79\xd2\xf1\xb9\x78\x02\xf3\xe4\x83\x5d\x83\x17\x5e\x2f\x8a\x52\x1f\xc9\x1e\xdd\xd1\x30\xe7\x38\xd0\x84\x44\x1f\x1e\x1b\x0c\x56\xa3\x9d\x31\xb2\x4e\x97\xde\x6c\x01\x95\xe6\x2d\x98\xeb\x48\xda\xf0\x21\xcc\x80\xdf\xc7\x16\x6c\xb0\xd9\x10\x3c\x60\x0d\x4e\xd4\xfa\x6b\xda\x2c\x47\xd9\x44\x71\xc9\x5f\xe2\x4d\x1a\xe2\xf0\x3f\xbc\x9e\xd9\xd1\x3d\x15\xdf\x24\x5e\x75\x68\xcf\x1e\x76\x39\xb7\x53\x1c\x7a\xdf\xd1\x55\x62\x37\x66\x57\xb1\x2f\x6e\x95\x78\x1a\x07\x3c\xcd\x02\xb9\x57\xa1\x07\x12\xa3\x4b\xc2\xd1\xa8\xb9\x9c\xe3\xec\x06\x73\x15\x42\x7e\x9f\xd9\xd7\xa7\x6f\x89\xd1\x64\x5c\x9c\x8c\x9a\x8a\xac\x36\xeb\xe2\x64\xd8\xd6\x6a\x9a\x6f\x5a\x61\x5a\x67\xe2\x6c\x36\x6c\x66\x4d\x36\x93\xad\xdc\xed\x0e\x2e\x4e\xfa\xfd\x6e\x1d\x5f\xce\x95\x2f\x4e\xda\xab\x0a\xab\x98\xaa\xfd\xe9\xc3\x7b\xbd\x25\x6d\xe4\xe7\x3e\xbb\xab\xad\xaa\x8a\xf3\xd3\xab\x84\x2b\xa7\x65\xdd\xc1\x28\xf7\x68\x9a\x43\xea\x50\xbc\xc7\xf5\x92\x71\xf5\xfa\x69\x0c\x23\x14\x69\x18\x84\xe9\xfd\xb1\x0d\xe4\x4b\xbe\x67\x98\x8c\x96\x40\xee\x69\x91\xfe\xba\x75\x91\xba\x26\x6e\x96\xe3\x89\xf5\xdd\xc3\x67\xb7\x3d\x0b\x7f\xde\x3c\xb2\xf1\xb5\xa2\xdd\xee\xf9\x6d\x8b\x16\xe0\x2d\xe2\x1c\xf2\xb5\x13\x7f\xb6\x3b\x84\x9b\xee\xdc\x7e\x4f\xe3\xf2\xdf\x04\xd6\x6e\x59\x33\xfa\xe5\xd7\xaf\x9a\xd7\xd2\x3a\x7a\xf1\x35\x13\xd7\x6c\x59\xab\xfb\xf3\xe4\x27\xa8\x7c\x2e\x4e\x37\x73\x33\xf9\x04\xaa\x40\x33\x12\x71\x97\xd9\x6c\xb7\x84\xca\xf2\x21\x95\xce\xab\xa8\xe0\x50\x30\x3f\x5a\x54\x94\x8f\x58\x0b\x5f\x59\x95\xe7\x72\xf9\xca\xf4\x3e\xfd\xb8\x24\xe6\xca\x59\x4b\xc8\x67\x8f\x32\xc8\x42\xae\x7b\x38\x16\x6f\x25\xa1\xb5\xd4\x3f\x47\x96\x0b\xa2\x96\xea\x6c\x51\x42\xca\x48\x03\x1b\xc5\x0d\x99\xeb\xe1\x35\xd7\xc2\xbb\xe2\x3a\xf5\xc2\xf2\x4a\xcc\x3a\x18\x57\xd7\x36\x3c\xaa\x76\x70\x62\xec\x4e\x61\xb3\xc0\x14\x5d\x7a\xde\xa4\x49\xae\x7d\x77\x5f\xc2\x2f\x9d\xf5\x68\xed\x60\xbc\xf6\x7d\xb1\x93\x75\xcf\xb8\x67\xf9\xe1\x1d\xdd\xdb\xd9\x09\xcf\x57\xac\xa8\x99\x35\xad\x63\x06\xde\xfb\xfd\xe3\xef\x74\x57\x33\xbb\xef\x59\x2e\xee\xec\xde\x04\xb3\x71\x00\xc6\x7f\x0f\xe8\x64\x10\x85\x51\x14\x95\x42\x3f\xef\x49\x5c\x80\x23\x45\x15\x5c\x19\x2a\x2b\x2f\x67\x6d\xe1\xfc\x52\xae\xd8\x6a\x2d\x64\x21\x22\x61\xb9\xe2\x92\x12\x54\xe0\xf0\xe6\x39\x58\x27\xe7\xac\xac\x62\xf2\x4a\x59\x41\x27\x74\x24\x7d\xf9\x85\xac\x2e\x1a\xf6\x82\xb2\x80\xc6\xba\xca\x59\x53\x31\xa7\x2b\x33\x59\x74\x26\x9d\x89\x73\x58\x58\xc4\x39\xc9\xc5\x17\x71\xc5\x4b\x39\x68\xb8\x22\xdd\x91\x2f\xfd\xe2\x93\x87\xdd\xa7\x0c\xba\x54\x89\x50\xee\x52\xa4\xd7\xf3\x46\x58\x59\xb9\xc9\xe8\x3b\xe2\x2e\xe5\x6a\x61\x32\x85\x62\x78\xc8\xc7\x4b\xc9\xdd\xe4\x51\xec\x8b\xb3\x43\x0f\x8a\x47\x76\xdd\x02\x7f\xfe\x7a\x00\x0f\x7b\x7c\x35\xfc\x11\x5f\xba\xa3\x5b\x3c\xfa\xe3\xdc\x5b\x99\xa1\x06\xdd\x68\x51\x6f\x1d\x86\xef\x16\x67\xe3\xbb\xef\xfd\xf2\x5e\xbc\x4e\x5c\x48\xbe\xe0\x57\x71\x36\x53\xff\xe5\x97\x5f\x76\xef\x4f\xdc\xc8\xbc\x93\xa2\xb1\x6e\x9f\xf4\x29\x2e\x05\x32\x32\x80\x95\x34\xa0\x91\x68\x6b\x62\x3c\x8c\xbb\xd7\xe8\xb0\xdb\xcb\xf2\xfb\xa0\xfe\xad\xad\xcd\x6d\x75\x3c\x2f\x08\x6d\x28\xdf\xc8\x9f\x3b\x6a\x50\x63\x53\xe3\x15\xc9\x32\x6f\xd8\x12\x2e\xb9\x22\x19\x8d\x86\xc3\xfd\x9b\x5a\x5a\x9a\xea\xb8\xc5\xc9\xa6\xba\xa6\x3a\x8b\x6e\xb0\xcb\xe2\xba\x22\x39\x1c\x26\x38\x4b\x40\x57\xbb\x38\x09\x69\x86\x72\x04\x20\xe4\x27\xb2\x0d\x48\x21\x25\x9d\xca\x40\x10\xd5\x8a\xbd\xf4\x36\x8b\x65\x3c\x1c\x2d\x20\x54\x92\x8b\x8c\xe2\x85\x38\xfb\x0e\xd3\xd2\xbe\x58\x6b\x30\x64\xca\xf3\x62\xa2\x4c\x10\xf3\x34\xba\x32\x57\x49\xab\x57\x74\x33\xc3\x77\x6d\x18\xb8\xfd\x0f\x78\x04\x73\x79\xe7\x94\x51\x33\x4c\x97\xd9\x07\xe6\x15\xf5\xa9\x39\x6f\xf0\xf4\x49\xc3\x27\xeb\xe7\xf1\x51\x57\x53\x43\xfc\xfa\xd3\xdf\x9e\x77\x7e\x73\xe2\xdc\x73\x03\x53\xfa\x8f\xd8\xbc\x79\x68\x9f\x60\xbc\xfe\x51\xf6\x3f\x0f\x1f\xe9\x5e\xc4\x0f\xfb\x65\xce\x84\x99\x13\xc6\x39\x26\xc7\xca\x8a\x07\x45\xea\x2f\x69\x1e\x7b\xe1\x85\x6d\xe6\xaa\xe8\xc8\x58\x4b\x34\xc9\xfc\x05\x62\x8c\x4b\x16\x89\x5b\x2f\x5a\xbb\xf6\x22\x71\xe5\x18\xdd\x45\xa6\xed\xf8\x0e\x5a\xdf\xf0\xc3\x5c\x70\x0c\xe4\x6d\x41\x5e\xd4\x1f\xad\x49\x8c\x36\x43\xe2\xe2\x22\x71\xaf\xc5\x62\x35\x14\x84\x42\x0d\x95\xb5\x35\x51\x9f\xaf\xa6\xd2\xc0\xf1\x03\x06\x36\x44\xfb\xe4\xf5\x89\x77\x26\x51\xed\x82\x5a\xc6\xc4\xd6\xd6\xf6\xb1\xe7\x45\x3a\x93\x05\x05\x79\x2e\x33\xe3\x62\x3a\x92\x2e\x17\xc7\xf3\xce\x8e\x24\xaf\xa8\xa1\xe6\x90\x43\xbf\x7a\xbd\x39\xf5\xab\x44\xc2\xb9\xd2\x8d\x67\x5d\xcb\xc2\x92\x68\x4d\xba\xe6\x56\xe7\x62\x15\xf9\x29\xb2\xd6\xde\x82\x2e\x4d\x25\x25\x92\xa8\x0b\x18\xfc\xf6\x1f\x9b\xbb\xfe\xf0\xdc\xcb\x33\xa7\x9f\xfc\xcb\xac\xab\xbc\xf9\xf3\x2e\x63\x9d\xdb\xd6\x5d\xb7\xb9\x70\xa3\x6b\x5c\xeb\x1d\x91\xa1\xd3\xa7\x4c\xae\xc6\xde\x2b\xd7\xd9\xef\x74\xff\xe6\x9a\xd6\x79\x73\xa6\x36\x32\xad\xdd\x2f\xf2\xc3\x5e\x7e\x6a\xf5\xd3\xd1\xee\x35\xec\xf1\x05\xf3\xc5\x8a\x25\xdd\xef\xdd\xbd\xf5\x9a\x75\xe1\xc9\xe7\x3d\x56\x37\xb4\xbe\xac\x78\xec\xc2\x09\x38\x76\xd3\x35\xee\x3b\xee\x1a\x35\xba\xaa\x62\xfc\x6f\x41\x7e\x02\x4d\xd0\x8e\xab\x36\x4d\x6e\x9f\xea\x8b\xee\x4d\x4c\xf1\x47\x0b\xcb\xb9\x52\x9f\xcf\xe3\x74\x58\x39\x8b\xd7\x62\x2e\x2d\x0a\x57\x22\x96\xd3\x71\xfa\xa0\xde\x10\x28\x08\xc5\xb8\xe2\xbc\xbc\x60\xb0\xb8\xb2\xd4\xcb\x57\xd7\xe8\x4c\x25\xe5\x90\xc8\xd9\x3a\x92\x5c\x7e\x61\x15\x67\x67\xc3\xd1\x4a\xce\xe5\x76\x75\x24\xfd\xc8\x6d\x87\xbf\x96\x3c\x2f\x5b\x5c\x5a\x6a\xb0\x10\x99\x82\x80\x14\xeb\x8e\xcb\xe6\x9c\x31\x6b\x2a\x4e\xb0\x60\xb2\xc0\xec\x53\xef\xdc\xf2\xb5\xc8\x66\x0d\xb9\x6c\x54\x07\x5f\xac\xfc\xb7\x01\xcc\xb8\x21\xce\x82\x7d\xbb\xe2\x38\xde\x04\x66\xdd\x14\xc5\xf0\xa3\x29\xea\xc5\xba\x78\x29\xb7\x26\x31\xb9\xf8\xea\x4d\xad\x6f\x5f\xbe\x73\xc1\xdb\x89\x8d\xcb\x8a\x2f\x1c\x34\xe8\xf9\x7a\xe6\x44\xdd\xf3\xe2\xa4\x5b\x43\x5f\x88\xad\x37\x27\xbe\x60\x56\xf8\xc6\x89\xa8\xf9\x3c\x0f\x0e\xf5\x6d\x0f\xb3\xfb\xa8\x61\xe7\x98\xfb\xe9\x6f\x88\x9d\xaf\xf9\xee\xbb\xef\xde\x64\xca\x0e\xad\x94\x6a\xbf\xb5\x20\xbb\xfb\xb8\xa3\x90\x87\x85\xd1\xe4\x84\xdd\x65\xe7\x05\x7f\xd0\x62\x0d\x0a\x76\x2b\x17\x29\x0c\xec\xc7\xe7\x3d\x23\x38\x04\x87\xdd\x66\x77\x0d\x36\xe3\x89\xf4\xc6\xe7\x31\x00\x2d\xfd\x6e\xc3\xe7\x21\x2b\xfc\xbf\x35\x3b\x31\x6c\xcd\x3d\x4a\xb3\xae\x80\x9c\x9a\x49\x14\x85\xda\x2a\x26\x8f\xe9\xc5\xf3\x71\x07\x39\x65\x13\xdf\xd3\x75\x38\xb9\xbf\x76\xd1\xfc\xae\xfd\x78\xc0\xfe\x27\xe6\x2f\xac\x39\xd0\xfe\xe2\x63\xdc\xd1\xb9\xff\x7c\x43\xfc\xef\xe9\xbb\xef\x1f\xf1\xcb\xdf\xb8\xa3\xbf\x34\x30\x1f\x74\xbf\x33\xe2\xa1\xcd\xcc\x83\xdd\xe3\x8f\x7e\x35\x47\x5a\xb7\xbb\x55\x7c\x8f\xbb\x93\xae\x9f\xfe\x91\xae\x01\xbf\x03\xd1\xb5\x8b\xdc\x4c\xd8\xc7\x47\x6e\x26\xa4\x73\x5a\x3b\xd8\xd7\xc5\x30\xe7\x97\xa1\x1b\x13\x6d\xc5\x08\xe9\x8b\x70\x89\xd5\x57\xc2\x3a\x9d\xe5\xa1\xfc\x7c\x9d\x5e\xef\xac\x28\xc7\x30\xf2\x8b\x93\xa5\xf6\x98\xc7\xeb\x59\x9c\x2c\xf2\xb6\xda\xb1\xcd\x0b\x13\xbe\xdd\x6b\xf7\x9a\x02\x81\xf0\xe2\x64\x28\x14\x00\xdf\xbe\x38\x59\xa3\x83\x84\xd1\x14\x20\x93\xfb\x34\xc9\x92\xfe\x97\x89\x5d\x76\xf4\xca\x75\xa9\xc4\x6e\x1a\x9b\x7c\xf4\x7e\x78\x32\xf8\xa5\xf5\x4d\xf0\xdd\xa9\x58\x90\xa0\x83\x89\x5d\xe7\x8b\xb0\x97\x8a\x0d\x8e\x7b\xef\x3a\xf7\xd6\x8b\x46\xcf\x7c\x61\xee\xc7\xe9\xd0\xf5\x57\x72\xdc\x95\xab\xfa\xe1\x97\xe7\xee\x6b\x1f\x7f\xeb\xfa\x1d\x9b\xdc\xf8\xb8\x18\x83\xcc\xff\x2f\xf8\xad\xc7\xb7\x56\x0e\xbc\x69\x48\xcb\xb7\xdf\xae\x3f\xb7\xb2\x78\x2d\x7e\xaf\xa1\xf5\xf6\x99\x1b\x1e\x5b\x33\x66\x14\x91\x01\xb9\xee\xe7\x28\xd8\x88\x1b\x8d\x4b\x94\x3b\x91\xdb\x6a\x73\x61\xbb\xc5\x0c\x69\x2f\x0f\x71\x98\xcd\xcd\x7b\x3d\x2e\x96\xd1\xe9\x75\x10\x7c\x9b\xf5\x7a\xde\x6a\x64\x11\xaf\xcc\x61\xca\x75\xf7\xbd\xc4\xd7\xf4\xe6\xa6\xa8\x4e\x8e\xc1\xe0\x2f\x8e\x93\xc0\x04\xb3\x5f\x8b\xc5\x79\x9b\x0e\x6d\xdf\x7e\xa8\x1d\x7f\xfa\xa9\x68\x61\x06\x8a\xb5\xf8\x0f\xcc\xfc\x7b\xc4\x4a\x66\xfe\x03\x4c\x63\xf7\x1b\xe4\xeb\x81\xee\x0d\xc0\x19\x3d\x2b\x1f\x78\xf3\xa1\x0b\x13\x7d\x7c\x24\x50\x74\x3b\xad\x46\xa3\x3f\x80\xdc\x1e\x77\x47\xd2\xa4\x37\x73\x36\xde\xca\xd9\x9d\x58\x60\xcc\x76\x08\xd1\x05\xbb\x99\x33\x7a\x58\x23\x89\x13\xa5\x55\x3c\x29\x13\xf0\x41\x2a\xd0\xa2\x29\xad\x2b\x75\x09\xec\x88\x79\x78\x0f\x7c\x01\x9b\x7c\x43\xac\x01\xbe\x48\xc1\xd2\xc3\xbc\x42\xee\xdb\x27\x5f\x2f\x48\x3f\xe0\x6b\x18\x57\x0f\x81\xe3\x07\x8f\xdf\xbf\xeb\x61\xf8\x12\xa7\xe1\xc4\xce\x7b\x1e\x7b\x04\xbe\xf0\x6d\x5b\x69\x0c\xc9\x23\x24\x3e\xcb\xbd\xca\x97\x23\x27\x6a\x42\x43\x20\xa2\x4c\x82\x5e\x9d\xd7\x8c\xc6\xd4\x1b\x8c\xb5\xb1\xb6\x88\xf7\xfc\x0b\xf2\xf3\xcf\x8f\xc4\x8c\xf5\x48\xd7\x3e\x65\x68\xac\x32\x76\x51\xb2\xb6\xd2\xde\xff\xa2\x64\x78\xc2\x45\x49\x6f\xdb\xf9\x11\x2e\x1c\x4e\x18\x5c\x6d\xf6\xca\x70\xd8\x5e\xc9\x06\xfa\x8e\x9a\x1c\x98\x7c\x51\x92\x1d\x7c\x51\x52\x60\x59\x97\x31\x00\xfd\x7a\x95\x4c\x81\x95\xd2\x74\x48\xbb\x78\x35\xa8\x19\x04\x55\xbd\x24\x76\x19\x3b\x8b\x49\x5e\x59\x27\xe8\xa2\x8d\x4d\x2e\x1a\x48\x61\xf8\x3f\xd5\x32\x3a\x17\xfa\x9a\xf2\x70\x93\x15\xeb\x1a\x1a\x21\xcc\x6a\xf2\x09\x3a\xaf\xd3\xe3\x66\x84\x98\xb6\xa8\x29\x80\x1a\x90\x5f\x9c\x30\x87\x62\xc9\x9b\xc7\xeb\xb8\x57\xe7\x4c\x8d\x36\xe4\x17\xfb\xdd\x4b\xa2\x9e\x51\xbe\xe9\x63\x27\xcc\xec\x2e\x4b\xcc\x6c\xf6\x9e\xdf\xd8\x32\x60\x70\x7d\xbc\xd6\x53\x72\xe1\x80\xb1\xf7\x97\x2d\x7f\xa5\xa6\xad\xa4\x30\x5e\xb7\x69\xd7\xec\x47\x19\x6b\x6d\x65\x2d\x68\x4e\xdf\xfa\xee\xc7\xce\x1f\x52\x53\x70\xe1\xd4\xf3\x96\x8f\x5a\x2a\x9e\x5f\x56\x3b\x24\x16\x1a\xf9\xdf\x2b\x6e\x0a\x17\xbc\xb9\xaa\xb6\x7d\x01\xbe\x74\xf9\x6f\xae\x14\x1f\xea\x37\xa0\x6e\xe8\x90\x44\xbf\x61\x45\xb7\xe3\x32\x3c\xbe\x93\xaf\xc8\xaf\x3f\x77\xf0\x79\x11\xef\xc0\xa9\xbc\xf8\xf5\x57\x4f\x8a\x7f\xba\xe7\xf3\x0b\x26\x4c\x19\x33\x61\xf2\x34\x76\xcf\xef\xc4\x45\xe2\xb7\xed\x9d\x9b\x71\x60\xdb\xeb\x27\x4e\xcf\x28\x6a\x2b\x8d\x81\x2f\x1b\x20\x4e\xe2\xc8\x3a\x5e\x04\xf5\x41\x53\x12\xb5\x01\x0f\x44\xae\x79\x90\x84\xd8\x79\x3e\xcf\x98\xef\xf1\x09\x7d\xab\x5d\x9e\x00\xeb\xab\x64\xf2\xd8\x98\xdf\xef\x8b\xc5\xc2\x9d\xc9\x18\xeb\x73\xea\x2d\x9d\x49\xbd\x1b\x92\xaa\x23\xda\x33\x81\x41\xec\xc4\x7b\xe7\xa8\x3c\x89\x38\x58\x97\x54\xf8\x2d\x6d\x90\x62\x8d\x52\x13\xa3\x8b\xe2\x20\x66\xa4\x80\x43\xa7\x88\xd3\x37\x08\x73\xad\xff\xb7\xd7\x77\xcf\xed\x6d\xe3\x26\x0c\x1b\x94\x70\x2e\xfb\x74\xe7\x8a\x47\x71\xc9\x43\x5d\x3b\xb6\xad\xbc\xf6\xce\x47\x06\xc5\x6b\x12\x0d\xe5\x4d\xa3\xb9\x7d\x07\xc5\xa9\xdd\x77\x8e\x49\x5c\x7b\x8b\xeb\xde\xa2\x01\x4d\xf1\x73\xf0\x8b\x62\x3b\x76\xfd\xcc\x14\x88\xef\xe1\xa1\xf8\xc4\xfa\x95\x5b\xee\x5c\xd4\x30\x7c\x48\xf3\x18\xf1\xda\x55\xff\x47\x62\x34\x12\xc7\x1e\x02\x9b\xc9\x87\x2c\xab\x94\x66\x33\xa3\x1c\x96\x82\x48\xac\x9c\x0b\x95\x95\x16\x1a\x8d\x2e\x9b\x29\x8f\x63\x42\x21\x54\x6a\xe8\x48\x96\xf0\x16\x2b\x74\xb1\x90\xb1\x86\x83\x0e\xa7\xa3\x33\x59\x06\xa9\x76\x69\x61\x69\x4d\xe9\x13\xa5\x87\x4b\xdf\x2e\x05\x67\x5f\x68\xad\xb1\x3e\x61\xe5\x6c\x56\xf0\x79\x4e\xb2\xa0\xea\x36\x98\xdb\x4a\xad\x4e\xa7\xb5\x94\x35\xb9\xdd\x55\x1d\x49\x37\x6b\x52\xf2\x32\x29\xe3\xac\x24\xee\x6e\x9a\x43\xf6\x0d\xca\xcf\x4a\xec\xa7\xd5\x3a\xf8\x2b\x99\x1f\xd1\x5e\x2a\x35\x32\xe5\x91\x94\x26\x13\xd2\x36\x10\x7f\x07\x4f\x21\x33\x07\x9f\xd1\xc8\xd7\x35\x45\x3c\x8e\x08\x84\x18\x5c\x07\x37\x73\x4d\xf3\x67\xdb\xc4\x2f\x0f\x91\x90\x16\x1f\x7b\xf6\x8b\x9a\x55\x17\xe1\xc3\x6c\xf7\x2b\x4c\xb3\x20\x1e\xde\x31\x41\x34\x61\x71\xfc\xbe\x53\xec\x93\x85\x05\xab\x17\x2e\xef\x16\x99\x93\xab\x67\xac\xfe\xfa\xda\x79\xab\x9d\x9e\xd2\x19\xf9\xa7\x2e\xb8\x00\xbf\x38\x5e\xaa\x49\x54\x71\x63\x41\x27\xbc\x54\x52\x73\x12\x4d\x3e\x43\x81\xc7\xca\x71\x01\x13\x1f\x41\x4e\x87\x03\xf1\x06\x2e\x5a\xec\xce\x33\xe5\x75\x24\x3d\x21\xf8\xf2\x08\x26\xe8\xb4\xc9\x04\x09\xaa\x89\x2b\x08\x08\x01\x12\x47\x09\xa0\x1b\xf1\xe3\x99\x1a\x04\x89\x51\xc1\x2d\x56\xe6\x06\xa7\xf2\x17\x58\x22\xdd\x31\xd6\x50\xc2\x38\xec\xe4\xde\xf5\x02\x0c\x6e\xbd\xd4\x11\xe1\xed\xbc\xc3\x8a\xb1\x03\x8c\xcf\xc1\x9d\x37\xef\xa5\xf6\xab\x3f\xfd\x37\x7e\xef\xea\x35\xaf\xb6\x3c\x36\x6c\x2b\xbe\xf5\xf4\xbf\xb0\xe5\x96\x1b\xf0\x2d\x8d\xf3\x2b\x57\xb7\x0d\xd7\xbf\xfc\xb2\x07\x2f\xc0\x0d\xcc\x6d\xd1\x25\x4b\x2d\xf7\x6d\x6d\x7e\xb9\x40\x34\xf8\xc5\xfc\x26\xae\xd2\xd3\x2d\x2e\x13\xe7\x08\x25\xf9\x78\x1c\xf4\x51\x89\x7f\x7c\x10\x01\x15\xa1\x5b\x13\xe7\xea\x02\x79\x21\xae\x50\x10\x7c\x2c\x87\x91\x87\x73\xf3\xee\x42\x93\xd5\xe6\xe4\x5c\x46\x97\xde\x1f\xcc\xe7\x0a\x0d\x06\xbb\xb9\x90\x37\xf2\xc6\xe2\xa8\x9e\x83\x64\x1c\x62\x1c\x6c\x09\x22\xbb\xc3\xde\x91\xcc\xf7\x38\x2c\xf0\xd7\x58\xe8\x62\x05\xa3\x36\x8b\xc9\x19\x68\x69\x72\x73\xb6\xc4\xa5\xd8\x46\x0e\x75\x68\x98\x13\x57\x02\x1d\x32\xb8\xae\x28\x0b\x41\xa4\x0b\x86\xbb\x09\x7c\xae\x0b\xa2\x1c\x0f\x1f\x29\x8d\x34\xc5\x4b\xaa\xb1\x4e\x60\x77\x4f\x3c\xba\xf1\xe6\xd7\x57\x76\xff\x65\xe5\xeb\x37\x6d\x78\x7d\xa2\xf8\x19\xbe\x60\xf7\xab\x5d\x78\xd2\xe9\xe7\xf0\xf3\xe3\xc4\xcf\x1a\x52\x7d\x8b\xf5\xfa\x2a\xe6\x93\x4f\x37\x8b\x77\xe2\xb9\xe4\x6b\xf3\xa7\x9b\xf1\xdb\x62\xcd\xe6\x4f\x3f\xdd\x7c\xdd\x8a\x60\x3e\xbd\x67\x1c\xd9\x60\x8e\x7f\x01\xe6\xf8\x06\x74\x3c\x71\x7d\x59\x2c\x9c\xcf\x05\x21\x63\x35\x9b\xdd\x9e\x92\x50\x28\x68\x31\xf2\x0c\x87\x6c\xb6\x60\x4d\x6d\x6d\xd0\x83\xb8\xc6\xa6\x32\x96\x63\x3b\x92\x31\x2e\x6c\x32\x9b\xa0\xcf\xe6\x56\x0e\x73\x66\xce\x1c\xf7\xa3\x1a\x7b\x4d\xa2\x86\x25\x3f\x0a\xe1\x97\x71\x35\x9d\x35\xdf\xd6\xe8\x0c\x6c\x4d\x4d\x3c\xde\xa7\x23\x19\x77\x85\xdd\x30\x5d\x86\xdd\xd5\xee\xf9\xee\x15\xee\x75\xee\x43\xee\xb7\xdc\x7f\x73\x1b\x6c\xac\x9b\x6c\x3c\x70\xbb\xfd\x7e\xb0\x2f\x3f\xa7\x54\xe5\x88\x91\x2c\x94\x7f\x27\xbf\x4a\x75\xab\xdc\x28\x21\x93\xf4\xa9\x71\x78\x9d\x24\x42\x17\x0d\x0c\x06\x31\xad\x18\x84\x07\xae\x26\x02\xb1\x41\xa9\x54\xca\xa4\xf6\xc4\xe8\x68\xac\x20\x3b\xef\x26\x1f\x13\x29\x2a\xee\xe0\x26\xae\x2d\x9a\x7e\xe5\x3d\x0b\xba\x17\xb2\x97\xe8\xc5\xcf\xaf\x59\xef\x3f\x58\xf5\xc9\xbb\x9f\xfe\x9b\xbd\xed\xd5\xf0\x94\x05\x2b\xd6\x97\x31\x9f\x9f\xbe\xd4\xf8\xf0\xfd\x9b\x77\xe7\x1f\x18\x25\x36\xfd\x24\xfe\x80\x17\x15\x15\x6c\xee\xd3\x5a\x5d\x1e\xda\x9c\x57\xf0\xa7\x4b\x16\x44\x9e\xd8\xf4\x5c\x57\xc3\xe6\xb2\x7e\x55\x91\x62\xeb\xe6\x50\xc9\xa2\xab\x97\xae\x8c\x89\xf7\x1c\xa7\x31\xe3\xc2\xb4\x9b\xd6\xf9\x7c\xa8\x00\xcd\x4b\x0c\xf6\x3b\x75\x90\xa8\x04\x3d\x56\x96\x31\x32\x56\x27\x17\x2e\x14\xf2\x3d\xf9\x60\x4a\xde\xce\x24\xcb\x82\xfe\xe9\x82\xb6\x60\x47\xd2\x6a\x33\xdb\xec\x86\x42\x43\x0d\xc8\xd2\xb0\xd2\xb0\xde\xf0\xb6\xe1\x13\x03\x6f\x30\xd8\x5c\x34\x94\x5a\xe8\x88\xdb\x65\x0b\x8b\xc7\x73\x2c\x4b\x5d\x08\xc2\x9c\x0b\x92\xb9\x52\x07\xe9\x28\x2f\xdb\x97\x13\xb2\x32\xec\x76\xfa\x1c\x10\x18\xfc\x11\xbb\xaf\x78\xb4\xe0\xca\x73\x77\xb6\xdf\x7f\xb3\xf8\xf9\xd5\x5f\x9d\x3e\xf5\xed\xd5\xe2\xec\xdb\x37\xdc\x75\x23\x7f\x61\x91\xf8\xe7\xc1\x53\xae\x75\xfd\xf2\x7e\xc9\xc9\xc1\xe2\x93\x91\x8f\x3e\x74\xe1\xd9\x38\x81\x47\xe2\x49\xb6\x2b\x4e\x7f\xfc\x5f\xf1\x7b\x1f\x57\xed\x16\x7f\x4c\xa7\xc5\x8d\x5c\x10\xcf\x17\xbe\xb2\x43\xb7\xba\xef\xc5\x61\x9a\x13\xa3\xf4\x8f\x60\x63\xe3\x90\x11\x3c\x49\x5f\x54\x87\x6e\x48\x8c\xae\xad\xab\xae\xa9\xab\x41\x51\x87\x20\x98\x10\xaa\xaf\xc8\xcf\x2f\x0f\x85\x7c\xd1\x68\xbc\x56\xa8\xf6\xa3\x7c\x7b\xfe\xb7\xf9\xac\x89\xcd\xcf\x2f\x2c\xcc\xdb\x97\x2c\x29\xdc\xdf\x5e\xd2\x67\x5f\xd2\x56\x01\x0e\xb6\xa2\xa2\x44\x67\xb0\xee\x4b\xb2\x86\xfd\xed\xac\x1b\x7e\x06\x94\x25\x4b\x29\x2d\xab\x54\xf5\xa5\xb5\x55\xa9\xd3\x6b\x12\xdf\xcc\x5b\x0e\xea\xe2\x79\x21\xab\x9d\xc2\xe9\x9b\x22\xbe\xcc\xb4\x2f\xa7\xc0\x64\x85\x93\x3b\xbe\x76\xe5\xca\x5b\x56\xdf\x8c\x8d\x9b\x9a\x07\x9d\xd3\xdc\xd2\x3a\xb0\xff\xe9\xe4\xb0\x96\x09\x9e\x35\x96\xeb\x66\xdc\xb4\xe6\xf6\x9b\xa6\x2f\xf3\xac\x33\x56\xf6\xb9\xe6\x09\xb2\x60\x84\x37\xbd\xfe\xe7\x3f\xbf\xfe\xc7\x3f\x88\xed\x0f\x6f\xb8\x63\xc7\x3d\x5b\x36\x31\xcf\xad\x7f\x78\xa7\xe1\xaa\xbb\xff\xf6\xca\x1b\xef\xdf\x74\xb5\xa9\xed\x82\x5f\x22\x64\x51\x89\xc1\x05\xe9\x13\xec\x36\x7e\x33\x78\xd9\x12\x74\x5b\xc2\x11\xf2\x42\x6a\x65\x33\xb0\x10\x5f\x7a\xd9\xd2\x32\xb3\x65\x3f\xf6\x3f\x9d\x34\x9b\x8d\x36\x23\xfc\x96\xb0\x24\x6d\xb6\xb0\x8d\x31\xb0\x36\x5b\xa0\x18\x92\x0c\xff\xbe\x64\x71\xb1\x0b\xb9\x0a\xc9\x87\x8e\xa4\xcd\xd5\xea\x1a\xeb\x9a\xef\x5a\xe1\xe2\x0d\xac\x4b\x40\xfb\x71\x20\x95\xe4\x38\xc1\x8b\xa4\xec\x55\xcd\x5d\xe5\x9c\x56\xa9\x11\x92\xff\xaa\x3a\x23\x87\x44\x64\xfb\x2e\x03\x82\x18\x88\x05\x08\x7b\x9a\xa4\x4b\x06\x20\xe8\xd1\x81\xac\xe4\x45\x5b\x47\xa3\x93\x79\x35\x3e\xc6\x31\xac\xec\xc3\xc5\xab\xe3\xe7\x8f\x6d\xb8\x7e\xf9\xa5\xd7\x3e\xb1\xae\x6d\x6b\x5b\x53\x5d\x7c\xd6\xb5\x63\xe6\xcc\x13\x5f\x7f\x64\xd3\x9e\x60\x78\x64\x38\x9f\x39\x77\xe3\x96\x87\x6e\x39\x20\x1e\x1e\xff\xe3\x25\x57\x72\xee\x8b\x6f\x98\x7d\x95\xc8\x0f\xc3\x2e\xa2\x23\x5e\xf8\x76\x00\xc4\x61\x45\x7e\x54\x0c\xd9\xc6\x25\x89\x06\x64\x36\x5b\x62\x61\xb7\xc5\x2d\xd8\xf4\x3c\x2f\x04\xca\x6c\x82\xad\xbc\xc2\x59\xb4\x2f\xe9\x74\xc6\xbc\xb1\x12\x88\x3f\x9c\xde\x7c\x50\x0b\x2f\xf6\xda\xcc\x58\xc7\x1a\x90\x40\xd3\x4b\xf2\x6f\x9a\x9a\x54\x49\x1d\xcb\x6c\x97\x76\xaa\xbf\x92\xf0\xdb\x47\xeb\x64\x71\x5c\x42\xf2\x29\xaa\x13\x0e\xbb\x36\x0c\x21\x2a\x01\xd1\x2e\xde\x25\x7e\xcf\xb2\xb7\x1f\xc6\x5e\xfd\x1a\xa6\xed\xb7\xd7\xff\xfb\xa7\x95\x57\x6e\x2e\x6f\x6c\xae\x2a\x6d\xe8\xd7\x47\x3c\x82\xf7\x72\x79\x93\x5b\xe6\x9d\xfe\x07\x3f\xec\x97\xbf\x3e\xb0\x88\xb5\xff\xfc\x1c\xf3\xd4\xdb\xcf\xe0\x9b\xf0\x8d\xcf\x1d\xbd\x6b\xc5\x35\x77\xdf\xb9\xea\xaa\xee\x13\x37\xdf\x2c\xad\x87\x86\x51\x09\xd7\x05\x3e\xc0\x06\x23\x5e\x8a\x6a\x50\x67\xa2\xde\xd7\xa7\xa0\x20\x5c\x56\x6c\x0f\x17\xeb\x91\x1e\xd5\xd6\x85\xfa\xbc\x96\x0c\x55\x25\xaa\x0a\x5f\x4b\xa2\x2a\x52\x24\x05\x6b\xa8\xb2\x99\x5d\xaf\x25\xcd\x38\x1c\xce\xe3\xf2\x5e\x4b\xca\x7b\x52\xc8\xe2\x05\x74\x95\x8c\x22\xb9\xb5\xfa\x78\xa5\x32\xb7\xb4\xc8\x5a\x5f\x47\x74\x9d\xe1\xa2\x45\xc5\x10\x62\x39\x8b\x21\x1e\x75\xea\xec\x08\x7a\xc7\x78\xec\x28\x5e\x87\x62\x64\x6f\x83\xb4\x1a\xef\x52\x4a\x14\x5c\xd7\x5a\xf1\xa7\xa7\x9e\x10\x7f\x5a\xbf\x16\x1b\x9e\x78\x02\x1b\xd6\x4e\x15\x4f\x7f\x79\xd7\x87\x4b\x51\xfa\x9f\xff\xc4\x4c\xf7\xad\x2b\x70\x7c\xed\x5d\xeb\xaf\x5d\xd7\x71\xfe\xae\x7d\xe3\x26\x32\x3f\xfd\x43\x7c\x76\xe7\x2e\x3c\xf4\xf3\xbf\xe3\xe1\x8f\xed\x12\x9f\xfb\x07\xee\x83\x47\x6c\x10\x3f\x7f\x4d\xfc\x93\xb8\x0f\xb7\x7d\x28\x3e\xc1\xb6\x5e\x3b\x7f\xe9\xed\x18\x0d\x6b\x13\xff\x78\x01\xd9\x7d\xc0\x8e\xe2\x5e\xe3\x8f\x22\x3b\x8c\xf7\xac\x44\x23\xc7\x9a\xcd\x7a\xa3\x0e\xf2\x49\xbb\xcb\xef\x74\x7a\x5c\x56\x08\x3d\x5d\xf6\x40\x9e\x03\x72\xca\xd7\x92\x58\x10\xac\x06\x2f\xb2\x99\xc3\x66\xc6\xac\xb7\x71\x61\x0e\xa6\x24\xd7\x3b\x64\xb0\xa7\xc1\xbf\x56\xea\xe5\x72\x16\xb1\xa4\xb1\x96\x76\xf2\xc9\x45\x6f\x1d\x1b\x65\x4a\xc9\x70\xbb\x7c\x4d\x2e\x18\x6e\x1a\x4d\x45\x3c\x5c\x87\xf0\x5a\xf2\xee\xea\x4b\xb7\xee\xb7\x0c\xbc\x6d\xcb\xe9\x0b\xe7\x3f\x86\x5f\x67\x47\x31\xc8\x29\x3a\xf1\x0d\x57\x8b\x88\x59\x25\x56\x47\xef\xc3\x17\x76\xaf\x60\x62\xdd\x1f\x32\xb1\xa9\x53\xa5\xdc\xb8\x3f\xdd\x33\x3a\x05\x45\xd1\x88\x44\x14\xc2\x1d\x53\xc0\x14\x01\xbb\x0d\x7a\x22\x6c\xa4\x38\x66\xf6\xfb\x0d\xc1\x3c\x70\xde\xa6\x3c\x27\x72\x76\x24\xc9\x62\x0c\x75\x53\x72\x24\x90\x51\x4a\xcd\xab\x57\x75\xc8\x01\xe6\xd5\xd8\x1f\x7b\x22\x0d\x34\x8b\xa0\x5a\xe8\xf4\x91\x2d\x38\x75\xbe\x12\xa6\xc1\x8e\x98\xd9\xff\xc6\xe1\xdd\x0f\x2d\xa9\x7a\x4d\x0c\xdd\x78\xdd\xe3\x3b\x1e\xdd\x75\xfd\x6a\x31\xf4\x5a\xd5\x92\x87\x76\xe3\x30\x3f\x45\x3c\x28\xfe\xeb\x79\xf1\x99\xcb\x4c\x5b\x3f\x99\x81\xf5\x8f\x7f\xf2\x7f\x27\x3e\xea\x12\x7f\x9a\xf1\xc9\x56\xd3\x3c\x3c\xf2\x20\x76\xe3\x21\x74\x1e\xea\x48\xff\x95\xbb\x9e\x6b\x83\x79\x28\x8c\x26\x26\x5c\x96\x70\x98\x73\x7b\x3c\x7e\x98\xc6\x0b\x23\x6e\xb7\xc5\x11\xb6\x50\xcf\x12\x0e\x93\x17\xc8\xe0\xd7\x54\x52\x6f\x47\x0e\xf8\xe5\xa9\x24\xd8\x6a\x6b\xb6\x75\xa1\x5e\x5e\x49\xe0\x8b\x4a\x88\xbe\x11\x8f\xe1\xf4\x44\x1c\x6a\xd2\xee\x72\x10\x77\xaa\x73\x30\x8b\xee\xfb\x76\xf5\x8d\xff\xb9\x73\xcb\x0f\x37\x9e\x7e\xa5\xee\xa1\x0b\x6e\x38\x30\xa6\x6d\xc6\x47\x9b\xe3\x0f\x4e\xda\xbb\xa4\x68\x03\xd6\x6d\x7b\x04\xa5\xd7\xaf\x15\xc5\x87\xc5\xad\x8d\xc3\x2f\xbb\xb6\xe2\xde\x65\xcc\xad\xd8\xd3\x30\x78\x89\xf8\x15\xb1\x21\x21\x9d\xe6\x5e\xa1\xeb\xf7\x26\xf0\x19\x0d\xa8\x2b\x31\xc3\x22\x80\xfe\x60\xc6\x68\xb0\xf2\x90\x9b\x9b\xbc\x1e\x4f\xdf\x28\x8b\xca\xcb\x82\x36\x5b\x19\x8a\x9a\xcc\x8c\x5e\xdf\xd8\x14\xec\xeb\x2c\x71\x06\xf6\x25\xbd\x5e\xa7\x93\xd3\x97\x54\xee\x4b\xa2\xf2\xf5\xe5\x0f\x94\x3f\x51\xce\xd9\xd8\xf2\xf2\x12\x5e\xb0\x08\xfb\x92\x10\xf1\x5b\x70\xab\x05\xeb\x4b\x2c\x96\x12\x3d\xcb\x98\x0d\x2c\xcb\x32\x24\x84\x6f\x95\xb7\xbe\x66\x8a\x15\x19\x0f\xaa\x96\x33\xb2\x12\x4c\xd5\xeb\x68\xb6\x95\x1a\x70\xd4\x80\x4b\xa3\xba\x28\x84\x74\x98\x8d\xf7\x56\x11\xa4\x29\xa7\x4e\x1a\x7f\x08\x81\x0b\x18\x6e\xea\xe9\xee\x79\x2c\xd3\xfd\x76\xff\x3f\x0e\xba\xec\x1f\x9d\x9f\x8a\x27\xc7\x3e\xc0\xb6\xaf\x58\x32\xe7\x1a\xf7\x0c\xeb\x90\xe1\xb7\x04\xea\x27\x4f\x6e\x2b\x5b\xba\xe0\x8d\xd0\xc5\xce\x45\x03\x5a\x83\x8d\x6d\x53\x47\x57\xf1\xc3\x7e\x7e\x8e\x1f\xd6\xed\xfd\xe0\x03\xe6\xab\x6e\x2f\x93\x14\xff\xda\x3d\x74\xf6\x82\x69\xb3\xbd\xfd\x13\xf3\x8b\xab\x0a\x83\xa1\xf8\x88\xfa\x99\x73\x9f\xb6\x5e\x52\xdf\x37\x5c\x11\xf6\xe6\x37\x8c\x05\xbd\x7e\x1d\x82\xff\xd7\xb8\x7e\xc8\x40\x76\x03\xea\x58\xc6\xc0\xf3\x0c\xc4\x27\x26\x7a\xcb\xb1\x9e\x45\xf2\xf5\xc6\x36\xd4\x9a\xeb\x61\x69\x47\x49\x91\xce\xa1\x5c\x6b\xec\x4e\x75\x63\xe6\xdc\xee\x8f\x98\x62\xae\xdf\x2f\xaf\xde\x86\x5b\x6f\x95\x6a\x4f\x8e\xf4\x37\xe4\x0e\x48\x7b\xa9\xfe\x2b\xf1\x04\xdd\xf3\x72\xf2\x5b\x72\x86\xeb\x09\xfc\x78\x77\x2a\x9d\x4e\x7f\x41\x3f\x3f\x1f\x3e\xff\xba\xb7\xcf\x11\x86\x98\xe2\x65\xb9\xfd\x47\xd2\xe7\x5f\x93\xb3\x62\xbf\xc5\xcf\x77\xa7\x50\x71\xc2\xcd\xb1\x4c\x95\x1f\xbe\xd5\x54\xe1\xea\x2a\x5c\x85\x3b\xed\xd8\xee\x98\xd6\xe0\x90\xae\xf3\x6e\xa5\x17\xa9\x01\x1e\x03\xc5\x43\xe8\x9c\x48\x87\x25\x3c\xa7\x73\xf1\x0c\xa7\x78\x46\xe2\xea\x91\x78\x24\x4a\x80\x80\x7a\xc1\x13\x53\xf9\x39\x99\x8e\x48\x78\xf4\x19\x3c\x65\x09\x1f\xa0\x68\xa6\x78\xfa\xe3\xea\xfe\xb8\x3f\xc1\x53\x43\x51\xf5\xc4\xd5\x02\xb8\x1e\xa2\xb8\xbe\x49\x0f\x94\x70\x3d\x2d\xe1\xda\x06\xb8\x6a\x12\xf9\x80\xa6\x9c\xe0\xa2\x1d\xeb\x30\x63\x33\xea\x44\x90\xcd\x60\x89\x37\x8a\x91\xfc\x53\x71\xc2\xe3\x2e\x88\xf1\x0b\xb9\x31\x90\xfb\xce\x49\x14\xb9\x5d\x02\x09\x3b\x75\x2e\x36\x2f\x68\xf7\x8d\x4b\x2e\x70\x63\x52\xa6\xed\x74\x2f\x70\xaf\x74\x1f\x76\x0b\x06\x37\xc9\x62\x0b\x82\x05\x10\x93\xdb\xbd\x36\x61\xbe\xb0\x42\x60\x8d\xac\x90\x80\x27\x82\x60\x34\xb2\xe3\x92\x46\xbb\x36\x4a\x27\x9a\x0f\x01\x7a\x65\xd6\xee\x41\x4c\xbd\x97\x14\x71\x3b\x1d\x76\x46\x55\xf1\x46\x76\xe6\xaa\xb5\x97\x2e\xb2\x1e\x08\x7d\xf0\xbb\x4f\xbe\xfd\xe6\xb3\xc7\x3e\xf5\xec\xb3\xad\xea\xbc\xf5\x26\xa6\xe8\xef\xcf\xcf\x9d\x62\xbd\xeb\x71\xf1\x53\xf1\x1b\xf1\x5f\xe2\xa7\xcf\x6e\x35\x5f\x36\xe7\x1d\xc2\xbf\x1e\xcd\xe4\x8e\x30\x43\x91\x05\xf5\x49\xb8\xcd\x36\x13\xe4\x9e\x0c\xc3\xf3\x56\x16\x25\x4c\x68\x8f\xfc\xbe\x2f\x9d\x00\xe5\x5d\xcb\xd4\xa7\x42\x0e\xe0\xf5\x45\x4b\x4a\x21\x78\x89\x93\x58\xff\xcb\x96\x41\x6d\x2b\xd6\xad\x5b\xd1\x36\xa8\x85\xfd\x18\x97\x0f\xb9\x6e\xf3\xc8\xe2\x91\x9b\xaf\x1b\x72\x21\xdd\x3b\xb1\x34\xfd\x32\x7b\x21\xb7\x02\x68\x94\x24\x1c\x06\xb3\x99\xb1\x58\x20\xf0\x46\x26\xc3\x7c\x06\x33\x3c\xaa\x3e\x32\xad\xae\x45\x79\x17\x58\xea\x21\x0d\x8b\xe2\x5e\x9f\x07\x12\xd4\x28\xd3\x3f\x83\x8f\x7d\x20\x43\xe9\x74\x34\x8b\xff\xf2\x84\xd3\x84\x18\x83\x20\xd8\xcc\x56\x83\x39\x61\x31\xef\x49\x32\x16\x54\xfd\x26\xe5\xfe\x4d\x99\xfb\x3a\xba\xb1\xbd\xa4\x94\xe0\xa6\x15\xa9\x48\x03\xfb\xb9\x16\x25\x5e\xa1\x65\x3e\x87\x77\x06\x21\x83\xc9\x44\x79\x67\x3a\x0d\xd8\x20\xf4\xc2\x7b\xac\xb1\x89\x60\x06\xd9\x78\x7d\x8e\x38\xb3\x21\x83\xee\x41\xad\x90\xb4\xb2\xf7\xa1\xd6\x44\xc8\xec\xb4\x7a\x3c\x4e\x67\x40\x19\x01\xbf\x55\x6f\xf2\x30\xd2\x28\xc0\x20\x48\x63\x50\x07\xff\xb4\xe3\x20\xfd\x92\x33\x1a\x9a\xde\x69\xc6\x85\x11\x33\xbf\x6b\x46\x48\xfd\x45\xd3\x57\x1f\xdd\x49\xe6\x76\xfb\x0c\x36\x9b\xd9\xec\xf3\xf9\x03\x66\x9f\xb5\xd3\x83\x3d\x20\x60\x65\xcc\x8e\xd1\x7e\xd3\xef\xca\xcb\x13\xaa\x7e\x6a\x47\x4f\x23\x0d\xcd\x38\xaa\xbf\x68\xc7\xb3\x9b\xc9\xfc\x4e\xf7\x02\x2e\x4d\xb7\x51\x7e\x58\x14\x44\x13\x12\xe5\x02\x0a\x04\x82\x16\xec\x74\xda\xed\xc1\x60\x7e\xc8\x1e\x74\xa2\x00\xb6\xb1\x01\x6f\x02\xb1\x7b\x92\x08\x79\x6d\x9c\x65\xbe\x80\x05\x83\xc2\x5d\x5c\x92\xda\x31\x30\xa4\x2c\x36\x95\x22\x31\x0f\x49\xaa\xeb\x0c\xcc\xe2\xa5\xf8\x13\xb1\xf0\x95\x9e\x1c\xcf\x19\xc7\x4d\x3e\x33\xcf\xe8\xd2\xf4\xe7\xdc\xc5\xfc\x2b\x90\x85\x56\xa1\x19\x89\xa6\x00\x2a\xd1\x87\xed\x2e\x17\x8c\x75\x9f\xbe\x61\xbb\xdd\x62\x29\x3a\x3f\x69\xb3\x84\x2d\xd5\x96\xb1\x96\x0e\xcb\x7c\x8b\x60\x67\x2d\x16\x3e\x3f\x10\xc8\xcf\xf7\x8e\x4b\xe6\x23\xbe\x7c\x5c\x92\x57\x03\x01\x24\x17\x75\xe4\x99\xd0\x91\x89\xc3\xe4\x81\xc7\x6e\x23\x96\xf2\x2d\xf2\x66\xa0\xd7\x17\x6f\x94\x62\x1b\x5d\x13\x4c\x73\x4e\x96\xae\xca\x33\x52\xb8\xed\xe4\x2e\x9e\xba\xf3\xeb\x0d\x4f\x1f\x99\x78\xfb\xcb\x4b\x66\xde\x13\xe3\xf8\x3b\x36\x0c\xb8\xb5\xbe\xf4\xea\x65\x7f\xf8\xc7\x07\x9e\x1b\x2f\xb8\x64\xc7\xdc\xf9\x33\x3b\x1e\x5e\xc2\xee\xda\x2b\x5e\x27\xfe\xfb\x96\xd7\xf7\x2d\xfd\x65\xef\xcc\x8b\x27\xb6\x36\x1e\x79\xa7\xb4\x78\xe3\x20\xf1\x44\xf7\x7f\x92\x8b\x56\x8b\x3f\xad\x5a\x7c\xe3\x66\x4c\xb6\x8d\x9b\x21\x60\x38\xcc\xaf\x42\x3c\x64\xa0\x23\x13\x31\x96\x11\x04\x4e\x8f\x0d\x1c\xe6\x4c\xe6\x90\x80\x6d\x02\xb6\x70\x02\xcb\x70\x1c\x3c\xc5\x10\x7f\x43\xac\xe6\x54\xbc\x9b\x23\x5e\x0d\xd1\x25\x5d\x9c\x50\xba\xe4\x94\xc2\xc9\x78\x03\x8e\x63\x0f\x66\x71\x04\x9b\xf1\xc7\x3f\xe2\xcf\xba\x77\xcc\x10\xdf\x60\xeb\xc5\x57\x37\x70\xdf\xfe\xe2\xdc\xc8\xfd\x2c\x7e\x7d\xfa\x19\x76\xa4\x14\x2b\x5e\x2a\xb6\x90\x3b\x7c\x90\x0e\x15\x25\xec\x2c\x87\x74\x9c\x4e\x6f\xe0\x19\x52\x20\xa3\xbb\xaf\x5b\x2b\x35\xbb\x0e\x31\xdd\x25\x17\x71\xb0\xbb\xba\xaf\x3d\xc4\xfe\x24\xb6\x08\x73\x7f\xba\x53\x67\xfe\xef\x8f\x12\xae\x20\xe0\x7a\x12\x70\x99\xd0\xa8\x44\xb1\x8e\x65\xb1\x9e\x61\x8c\xac\x01\x0b\x46\x6c\x34\x5b\x58\x40\xdd\x91\xd4\x93\x97\x3c\x58\x6c\x40\x06\xe8\x8d\x9c\x29\xb4\x92\xd5\x88\xac\x28\x39\xee\x54\xbd\xb5\x8b\x6c\xe3\x04\x45\x33\xe0\x88\x27\xc8\x2c\xef\xde\xcc\x9d\x73\xfa\x29\xa6\xad\xfb\x51\xf6\x41\xb1\x65\x1e\x5b\xc4\xba\xe6\x6e\xe9\x0e\x75\xeb\xb6\x48\x3c\x2c\x61\x3a\xb9\xc9\xcc\xf7\xda\x77\x5c\xba\x92\x78\x6f\xf6\x3b\x2e\x4b\xd8\xcf\x98\xce\x3b\xee\x20\x73\x9a\xbc\xdf\xd2\x2e\xe8\x4e\x52\x5f\xfb\x2d\xde\xc1\x7c\xc8\xbc\x05\xed\x63\x09\x2f\x7d\x69\x83\xec\x44\x27\x2b\x69\xad\xf0\x2c\x61\x75\xb4\x11\xae\xa7\x55\xaa\x3b\x70\x49\x7a\xf6\xed\xd7\x78\x07\xae\x14\xff\x04\xf4\xc7\xa4\xbf\xe7\xae\x11\x26\x82\xbe\xd6\x24\x7c\x18\x09\x82\x9e\x67\x74\x7a\x46\x6f\x30\xf2\xcc\x9e\x24\xcf\xeb\x02\x02\x15\x6b\x8b\x26\x36\x91\x07\x8e\x8f\x62\x88\xfa\x5d\x38\xce\xdc\x32\x57\xfc\x7c\x1f\xb6\x7e\x8f\x77\xaf\xb2\xb2\xfe\x25\xdd\x63\xf8\x9b\x48\xdd\x33\x84\x8e\x72\x8f\xb1\x7f\x46\x6e\x54\x88\x2a\xd1\x94\x44\x43\xa9\xdf\xce\x47\x38\x53\x01\xd9\x39\xde\xc7\x53\x6c\x2d\xee\x4a\xfa\x23\x7c\xc4\xce\xea\x9d\xd6\x60\x85\xbe\xa2\x2b\xc9\xb6\xea\x3b\xf4\x69\x3d\xab\x4f\x04\xab\xda\xf4\x09\xa7\xb7\x4d\x4f\x5e\xa3\x99\x16\x97\xdf\x98\xa5\xd5\x29\x8d\xe8\x49\xd1\x4f\xae\x41\xb0\x99\x5a\x83\x8b\x6c\x23\x8b\x81\x55\xd0\x59\x12\x2c\x84\xa7\x86\x21\xad\x22\x3c\xf6\xc0\xb2\x03\x57\x36\xdf\x37\xfe\xda\xfb\xb6\x2f\x7f\x66\xf1\x75\xbb\x57\xdc\x2d\xbe\x39\x70\x76\x4d\x9f\x59\xe7\xb4\x4d\x9f\x2e\x76\x56\xcd\x1e\x32\x62\xea\xd4\x91\x4b\x98\x31\x8f\x7c\x8c\xf3\xae\xbd\xf3\xdd\x3d\x8f\xbd\x2f\x7e\x8e\x3d\x7f\x1a\x7f\xed\x75\x2b\x57\xae\x5b\xfc\x9b\x8d\x3f\xaf\x5c\x79\xc7\x82\xc5\xb7\x49\xe3\x57\x0f\x22\xdf\xc2\xfd\x1e\x6c\x22\x98\x30\x83\x1b\x67\xc9\x9b\x84\x20\x38\xf2\x9a\x98\x22\x31\x18\x44\xb2\x35\x28\x52\x3f\x9d\x13\x7e\xd9\xca\xfd\xfe\x97\xbb\xa6\xd3\xb6\x5b\xd3\x22\x57\xc3\xe9\x91\x0b\x45\x12\x36\x17\x32\x19\x91\xd1\xed\xe1\x6d\xd0\xda\x44\x64\x5e\xad\x55\x65\x9f\xa3\x9e\x1e\x1f\x81\xa5\xed\x28\xb4\x64\xb0\xf5\x8a\x77\xae\xbb\xfe\x8f\x57\xce\x3e\xf2\xc0\x83\x87\x19\x06\xdd\xf9\xcd\xea\x1b\xbe\xdf\x04\x69\x16\xf3\xc2\x3f\xfe\xfe\x92\xbc\xff\xe9\x6b\xb1\x85\xfd\x94\xff\x0c\x72\x8d\x92\x84\xd3\xcd\x71\x06\xab\xd5\xe7\x77\x82\x8e\x39\x75\xe6\xae\xa4\x0e\xd1\x52\x46\xd6\xdb\x3d\x04\xb3\xba\xb0\xd0\x40\x6b\x15\xe0\x2c\xd9\xcb\x27\x24\x77\x3f\x34\xb6\x69\x40\xcb\xae\xdd\x8f\x4c\xaa\xaa\xe5\x27\x5f\xb9\xe8\x97\x3e\x8f\x3f\xe3\xda\xe8\xff\x27\xf7\xce\xe3\xfb\x9c\x9b\x82\xd4\x1f\x5e\x86\xc7\x71\x9d\xec\x8f\x30\xa7\xf4\x41\x57\x27\x46\x97\xe8\x83\x1e\xbd\xa7\x6f\x75\x79\xb4\x2b\x99\x57\x9e\xf0\xe5\xb7\x95\x93\x12\x65\x79\x41\xa2\xa4\xa0\xc0\xdf\x95\xec\x28\xc0\x05\x09\xa7\xa7\x0d\x15\xd8\x0b\xc0\xf6\x0a\xdc\x26\x13\xdf\x95\x34\x11\x40\x13\x01\x34\x41\x7c\xe7\xec\x4a\xea\x5b\xe5\x5d\x96\x72\x6e\x9e\x29\x4e\x49\x5b\x9b\xa4\x87\x75\x59\xb6\x0f\x51\x12\xf5\x8c\x0d\x24\x75\x0a\x63\xa2\x0a\x4d\x1e\x2b\x66\xe9\xf7\xa8\xf6\x53\x5f\x01\x66\xa7\x0e\xdb\x30\x72\xf5\xc4\xd6\x45\x23\x16\x6d\x3e\x6f\xe3\x70\x5b\x72\x4c\xe8\xba\x45\x03\x16\x0f\x83\x6f\x4b\x26\xd0\x8f\x86\x5c\x31\x78\xfe\x96\x59\xab\x37\x4e\x62\x4e\x55\xe6\xf5\x89\xc5\xd7\x4f\xac\x0a\xf0\x05\xb6\xe9\x9b\x2b\x4a\xc4\xcf\xa6\x6e\xec\x13\xab\xca\xab\x2e\xaf\x5e\x33\xb1\x6f\xdc\x4d\xe4\x7e\x05\x6a\xe2\x26\xf1\x76\x18\xdb\x5b\x12\x93\x2c\x76\x07\xe2\xb0\xd9\xa8\x13\x58\xce\x84\x19\x48\xa1\xcc\x56\x3d\xe7\xb2\x72\x56\xb7\xc7\xae\x37\xe8\xbb\x92\x16\x53\x8d\x61\x9c\xa1\xd3\xb0\xc0\xc0\x8d\x83\x6f\x2b\x0d\x4f\x18\xde\x36\xf0\x36\x88\x39\x58\x83\x83\xe7\x40\x26\x0c\x0a\x73\x2b\xb8\xfb\xb9\x3d\xdc\x21\x8e\xe7\x88\x65\x90\xc2\xc5\xc2\xf8\xab\xaa\x28\xa6\x2d\x7c\x35\xdb\x2b\xc9\x21\x03\x5d\x40\xa2\xa5\x70\x5a\x02\x8f\xb8\x68\x09\x9c\x8d\x90\xf4\xda\x83\x7f\xd8\xb2\xe1\xae\x7f\xe1\xa6\x17\x44\x13\x33\xf0\x9e\x75\x5b\xb0\x47\x7c\xf0\x10\x13\xc2\x93\xc5\xbf\xe1\xc8\x26\x7c\xd9\x26\x5c\x2c\x7e\xb4\x49\xdc\xb4\x09\xec\xf9\x0a\xf4\x23\x37\x89\x1b\x27\xef\xd9\x1e\x9b\xa8\xd6\x73\xc8\xa4\x83\x3c\xc6\x6c\x21\x7d\x30\x18\x78\x4c\x38\xe5\x88\x0b\x9b\x8f\xef\xc7\x7b\xf0\x5b\xf8\x1b\xcc\x8f\xc3\xd8\x86\xc3\x98\xc1\x30\x80\xff\x1f\x6f\x6f\x02\x18\x45\x91\x35\x8e\x57\x55\x5f\xd3\x73\xdf\x33\xc9\xe4\x98\x64\x72\x00\x81\x4c\xc8\x24\x04\x08\x90\x56\x6e\xb9\x6f\x07\xe4\x08\x81\x70\x07\x0c\xe1\x06\x41\x0e\x51\x41\x30\x82\x07\x1e\x88\x0b\x88\x37\x28\x01\xa2\xbb\x8a\x8a\xc7\xae\x82\xb8\xab\xbb\x78\xeb\xa2\xae\xc7\xea\xea\x7e\xba\xee\x7e\x24\xd3\xf9\xbf\xaa\xee\x99\x4c\x0e\xdc\xcf\xfd\xbe\xdf\x7f\x92\x9e\xa9\xee\xae\x7a\xf5\xea\xd5\xab\xf7\x5e\x5d\xaf\xa6\x4f\xd7\xf9\xad\xdd\x78\x52\x44\x13\x74\x58\xbf\xea\xb8\x4f\x9b\xd3\xb5\x8b\xfb\xcd\xde\xbd\xb1\xde\x7b\xf7\xe2\x39\x80\x03\x41\xcb\xe9\x3e\x1c\xfe\x3c\x5b\x57\x3c\x46\x29\x94\x78\x64\x24\x22\x12\x4d\x66\x09\x30\x90\x30\x5b\xa7\xfc\xa6\x88\xc3\x62\x85\x48\x44\x6e\x19\xd9\x44\x8e\x11\xce\x46\xc6\x90\x99\x84\x6e\xaa\x99\x3e\x3d\x42\x2f\x27\x5b\x7f\xdf\x11\x03\x4c\x17\xf8\x0b\x9a\xc4\x6d\x7e\x90\x9b\xda\x1c\x00\xc9\xbb\xea\x1c\xde\x71\xb7\xfa\x90\xfa\xd0\xbe\x6f\xea\xeb\x29\x8f\xd7\x01\x0e\x53\x74\x1c\x46\x29\x3d\xda\xe1\x20\x0a\x84\x70\xcb\xf8\x4d\xfc\x31\x9e\xb3\xf1\x63\xf8\x99\x3c\xc7\xe3\x37\x11\x0e\x83\x44\xa6\xbb\x47\xa7\x4f\x2f\xa6\x28\x74\x8a\x41\x19\x55\x1e\x58\x27\xc1\x54\xc0\x80\x91\xe0\x9b\x7d\xf8\x6a\x7c\xf5\xdd\xea\x8a\x73\xb1\x9b\x28\x06\x14\x07\xe8\xfe\xf1\x57\xf2\xe5\xd0\x83\x97\x69\xcb\x16\xe8\x46\x53\xde\x68\x22\x06\xb0\x82\x91\x70\x94\xe9\x2a\xe4\x6f\x23\x42\x22\x0e\x19\x3b\x72\xb3\xe0\xfb\x66\xfc\x01\xfe\xa0\xf9\x1e\xce\xa9\xae\x52\x57\x91\x75\xf8\x79\x55\x89\x6d\x9b\x44\x10\xae\x55\x77\x01\xef\x2e\x47\x0d\xfc\x14\xd0\x49\x02\xca\x57\xbc\x74\x23\xa2\x08\x95\xfc\x78\xd4\xc6\x55\x70\xdf\x41\xff\xbd\x02\x63\x5a\x95\xe1\xe9\xad\xf2\x0d\x3b\x42\x2e\xa8\x39\x71\x0f\xa6\x9a\x4a\x9d\x48\x06\xdc\x86\x30\xc9\x88\xed\xe3\x89\xf8\x30\xb4\x81\x54\xc5\x68\xa0\x4e\x86\x3c\x76\x13\x93\x8c\xe7\xce\x25\x5c\x0a\xe1\x90\xb6\xea\x97\x4d\x66\x32\xaf\x07\x1e\x72\xb4\xfe\xd0\xed\x43\xe6\x16\x87\xf2\x0b\xd2\x03\xde\x48\x41\x6c\x9f\x94\xf1\x15\x96\x87\xf7\xce\xef\x99\x53\x90\x73\xe7\x11\xb6\x87\x3b\xb6\x8f\x1c\x4d\xc0\x26\x2e\x57\xa7\xb0\x23\x0e\x37\x89\x2b\x05\xe6\x46\xa1\x94\x64\xd4\x3f\xb8\x27\x09\xb6\xf8\xf0\xbf\x2e\x7e\xab\x36\x25\xc3\x6e\xf9\x89\x14\xf0\x17\xc8\x6f\xe8\xaa\xa8\x13\x04\x78\x1a\xa3\x46\x8c\x9e\x8a\xe2\xe6\xf6\x3b\x49\xff\x4c\x0a\xb4\xfa\x60\x65\x65\xf8\x50\x3d\x2e\x13\x8e\x6e\x82\x50\xd1\x25\x7d\x13\x84\xe6\x5a\x02\x7a\x36\x19\xf5\xf5\xe2\xc3\x3f\x7d\xaf\xd3\x86\xe6\x21\x80\x1d\x63\xe4\x05\x41\xc4\x12\xaf\x22\x8e\x65\x84\x9a\x35\x7b\x10\xf2\x8a\xaf\xd5\xa0\x2b\x4c\x49\x06\x79\x3a\xf6\x4e\x3d\xf9\x4d\x7d\x53\x0d\x5b\xdf\xff\x13\xcd\x33\x0e\x83\xe3\x79\xba\xd3\x50\x4d\x46\x36\x19\x06\xc7\x36\x47\x19\xc9\xd3\xf5\x80\xf4\xa5\x0f\xf9\xdb\x74\xbc\x69\x59\x01\x6f\x01\x65\x9e\x02\xf5\x25\x72\x12\x11\x00\x40\x43\x94\x34\x33\xf4\x0b\x5a\x91\x60\x3a\x0c\x8a\x40\xba\xc4\x86\x8a\x0f\x37\xbb\xea\x75\x5a\xb1\x72\x33\x1c\x80\xf3\x29\x0e\x97\x18\x88\xa7\x28\x88\x8e\x38\x44\x00\x87\x2e\x14\x07\xee\xdb\xa6\xcd\x09\xda\x31\x1c\x24\xe8\xd3\x99\xc1\xa8\x94\x24\x03\x27\x8b\x6a\x3b\x44\x5a\x01\xb5\x62\xc3\x48\x0a\xf8\xbc\x53\xcf\x10\x4a\xa6\x0b\x83\x97\xaf\x58\x04\x00\x28\x23\x83\xa0\x72\x97\xda\x91\x26\x0e\x2e\x81\x58\x88\xa1\xa6\xe1\xf6\xd3\xf7\xfc\x6d\x3a\x2c\x56\x4f\x12\xea\xa6\x58\x05\x30\x8f\x88\x8c\x01\x18\xdd\x6d\x97\xc4\x14\xd4\x28\x64\x9c\x91\x28\x27\x5b\x12\x0c\x1c\x42\x2b\x0c\x98\xa4\xa9\x86\x11\x5c\xe7\x2d\x86\x1b\x85\x47\x88\x41\x04\x78\xdc\x25\x01\xff\x1b\x78\x0e\x5a\x5e\x46\xb9\x2e\x0c\x3f\x46\xfe\x38\x7e\x00\xcf\x84\x4a\x15\x97\x20\xcb\xc4\x68\x34\x8b\x16\x6c\x96\xa1\xbc\x06\x0d\xc9\xe3\x51\x81\x42\xd5\x77\x5d\xb6\xc2\x8d\x24\x83\xce\xd2\x4b\xcf\x88\x19\xcf\x81\x61\x4d\x5a\x7e\xc2\xab\xf8\x0b\xdc\x32\x26\xf7\x0b\x15\x63\x7c\xdf\xb3\xc0\xb3\xfa\x11\x62\x71\xd4\x9b\xe2\xdd\x98\xd6\xfd\xce\x9c\x2e\xd0\x81\x12\x4d\x99\xd0\x5e\x3e\xae\xaf\x57\xef\xd2\x65\x18\x5e\x18\xdb\xc7\x55\xb1\x36\x23\xa1\xa0\x62\x25\x1c\xe8\x47\xd1\x20\x4b\x04\xc8\x0b\x55\x5e\x5c\x11\x49\xd6\xe7\x50\x3f\xec\x5a\x58\x5f\x8f\xe7\x6b\xed\x48\xb6\xb7\xb6\x25\xc0\x4f\x46\x7d\x14\x1b\x6f\x30\xc8\xb2\xd1\x24\xd2\x5d\x26\x2a\x2f\x31\x14\xf9\x58\xbc\x65\xc5\x51\x44\x3a\x7d\x1d\x09\x7e\x4a\x2c\xe4\xd6\x9a\x19\xa3\x03\xb7\xac\xfe\x42\x7d\x73\x36\xb5\xb3\x17\xea\x7c\x20\xa3\x1e\x8a\x45\x32\xf0\x9c\x81\x33\x22\x13\x11\x65\x11\x00\x9f\x88\xca\xcd\x06\x4e\xd5\x96\x39\x32\xc7\x14\xad\x23\xd1\x1e\x7d\x4f\xa2\x83\xbf\xa0\xee\x04\x70\xac\xf9\xf2\xb7\x35\xd5\x08\x21\x9d\x06\x0c\x77\x01\x6a\xb0\x5c\xb1\xf2\x82\xc9\x28\x40\xe7\x03\x3a\x50\x16\x51\x06\xd0\xa7\xa2\x62\xcc\xd4\x2a\x19\x74\xfc\x23\x71\x22\xb7\xe6\xc3\x70\xd7\xbf\x17\x72\x4b\x62\x39\x40\x25\x22\x40\x96\x50\x88\x4b\xcf\xf0\x4b\xb5\x72\x68\x6d\x83\xd1\xaa\x4c\xb1\x4a\xc4\x60\x30\x9a\xa0\xdf\x64\x94\xd4\x78\x6d\x36\xc5\x6b\x33\xd6\x19\xa9\xb4\x2a\x2d\xcd\xd2\x85\x09\x10\x09\x04\x0a\x5e\x05\xe5\xba\xd4\x95\xfb\x48\x83\xcf\x55\x31\x3a\x15\x2a\x76\x8d\x4e\x26\x64\x04\xe2\x88\x1d\x5b\x4c\x1b\x42\x71\xf1\xcd\x9b\x0e\x23\xb7\x84\xd2\x49\x93\x52\x5a\xc3\x21\x1a\xdc\x56\x3a\x89\x12\xc1\x12\x06\xbb\x83\xe7\xcd\x46\x99\x61\x6e\x8c\xb1\x22\x9c\x80\x22\x48\x58\xab\x8b\x56\x66\x6c\xa5\x13\xed\x10\x96\xe2\x10\x1b\x54\xad\xaa\x8f\xe5\x10\xa1\x5e\xdd\x49\x04\x6e\xd9\xa5\xae\xc2\x10\x56\x8a\x7a\x26\x93\x28\xcf\x03\x6f\x52\x3a\x59\xa8\x08\x01\x9e\x32\x70\x9c\x49\xd4\x32\x13\x63\x71\xe9\xd4\x94\x90\x4e\x05\xed\x38\x2a\x12\xdf\x1c\xa0\xcb\x28\x5d\x6e\xbe\x0a\x85\xd3\xf6\x18\x2d\xd4\x65\x81\x0c\xb2\xc0\x64\x10\x64\x22\x80\x09\x0c\x01\x00\x7c\x32\x4a\x0c\xcd\xa2\xde\x0a\x0a\xda\x30\x94\xd6\x5a\x21\x4c\xfe\x50\x8f\xeb\x9a\xf7\xd4\x5f\x60\xb2\x8f\xbf\xae\xd9\x45\xf9\x49\xc7\x5b\xa7\x13\x11\x00\x9e\xc1\x6c\x31\x72\x9c\xc5\x60\x62\x18\x1b\x9a\x18\xea\x27\xa2\x24\xa6\x67\xd0\x29\x9d\x58\x36\xfa\xf7\xc2\x7a\xf2\x41\xf3\x1e\x68\x75\xb8\x2e\xd6\x24\x3e\xdc\x34\xb3\x5e\x28\x86\x72\x68\x3e\x14\x56\x31\x59\xcb\xf8\x49\x16\x09\x31\x19\x19\x3f\x5d\xfa\xc5\xfc\x14\xd1\xf9\xa9\x8b\xc6\x4f\x5c\x9f\x4b\x6f\x68\xf2\x92\xc9\x08\xc6\x4f\xa0\x9d\xe8\x44\x05\x36\x1a\xf8\x4b\x90\x15\x6e\xd5\x32\x1d\xf9\x09\x6b\x30\xe1\x8f\xab\x02\xdc\xeb\x34\x96\xa2\x62\x8d\xfb\x56\x93\x69\x0c\xae\x4e\x27\x83\x89\x4e\x80\x00\x3f\x61\xac\xf1\xd3\xa9\xa8\xb1\x49\xe4\x2f\xc5\xf3\x88\x5d\xbe\xdd\xd1\x6c\xb2\x22\x1a\x3f\x35\xef\x21\x1f\xd4\xab\x52\x7d\xac\x09\xd7\x41\x29\xf8\x07\x9a\x7b\xd5\xb7\xd5\x71\x26\x34\x00\xca\x01\x52\xda\x64\x82\x56\x0e\xb5\x62\x54\x7f\x8e\xa5\xda\xc9\xa9\x36\x6c\x95\x50\x7e\x71\x05\xf8\xaa\x2e\xad\x12\x72\x85\xe9\x19\x13\xea\xa9\xd8\x8c\x26\x89\x88\x26\xd1\xcc\x59\x4c\xba\x62\x85\xfa\x6f\x36\xb4\xd6\x7f\x82\x76\x6d\xb4\x2b\x33\x5a\x28\x9b\x81\x1c\xa1\x72\x5b\xd7\xb2\x4c\xee\x72\x89\x3c\xa8\xcf\x1e\x1b\x1a\xaa\x38\xac\x82\xe0\x40\xd8\x26\xcb\x66\x03\x36\xd8\x1d\x66\x1b\x2b\x8f\xb9\x89\x89\x61\x45\x06\x39\x6c\x24\x97\x64\xa4\x32\xae\x4e\x9c\xbe\xdf\xa7\xdd\xd2\x36\x3a\xaf\xa8\x29\x24\x8d\xfb\x9a\xea\xeb\x2f\x30\x49\xc6\xd8\x2f\xb6\x4f\xb6\x03\x03\x36\x67\xcb\x76\xc6\x82\x49\xfa\xde\x84\xfa\x29\x0e\x99\x12\xd7\x6c\x01\x26\x04\x1d\xf8\xf3\x6c\x98\xcc\x87\x6d\x18\x31\x94\x60\xc5\x38\x2f\xfe\xf4\x3d\xf7\x11\x4a\xc8\xa1\x04\x5d\x9d\x60\x5d\x98\x8c\xa2\xd1\x82\xcc\x26\x41\x35\x74\x30\x31\x22\xc9\x3c\x99\x64\x67\x50\xba\x1a\x81\x27\x99\x26\x4b\xd8\x1b\xfc\x75\x40\x56\xc4\x25\xf2\x48\xd0\x55\x34\x1a\x65\x13\x47\x4c\xc4\xee\xb0\x48\x92\xdd\x6a\x61\x65\xb2\xc6\x0c\x3a\x5d\x0d\x4d\xa6\x56\x9d\xd9\x49\x73\x4e\x56\xa0\xb4\xf3\xc7\xa4\x1f\xd4\x2b\xad\x53\xca\xaa\xf5\x4c\x04\x6a\x1a\x15\x38\x56\x13\x82\x44\xb3\x2d\x40\xe6\xd2\xb2\x2a\x8a\x0d\xac\x1f\x8b\x99\x33\x99\x2c\x06\x4a\x5b\x83\x96\xb5\xdc\x94\x6c\x0c\xc5\xe2\x4d\x31\xc9\x08\x70\xb4\xb5\x89\x74\x6b\x00\x38\x36\xf6\x0e\xff\x67\x20\x2f\x54\x25\xf7\x11\xa5\x03\x4a\xb6\xb7\x4c\xa8\x44\x71\xc9\x46\x51\x30\x0a\xc0\xb4\xc8\x6c\x04\xf2\x76\x30\xba\xf4\x36\xef\x68\xa3\x45\x12\x0a\x17\x72\xd1\x34\xae\x6e\x7f\xe9\x36\x18\x97\x28\x97\xc0\x76\x1e\x0f\x57\x9c\x08\x9b\x8c\xd8\xe8\xb0\x5b\x0c\x06\x87\x95\xe3\xec\x36\x2b\x13\xc1\xb6\x26\x99\xe3\x39\x16\x14\xf9\x98\x49\xe7\xdb\xf8\x0a\xbc\xa4\xf2\xf5\x49\x70\x2e\xd0\x35\xa2\xb5\x1c\x0f\x68\x99\x26\x46\x57\x8d\x79\x89\xd0\x94\x09\xf5\xfa\x11\x2d\xaf\x70\xa1\xbe\x3e\x6e\x57\xe9\xbc\x44\xe9\x4b\x88\xc5\x6c\x92\xa4\xb6\xf4\x8d\x25\x1b\x87\x4d\x3f\x4b\x5f\xd6\x5e\x18\x7d\x99\x21\xa7\x1b\x5c\x5c\x1f\x68\x27\xba\xd1\xd5\x6a\x7f\x32\xfa\x02\xf7\xca\x44\x36\x9b\x80\xbe\x12\x77\x49\xee\x60\x84\x76\x4a\x5f\x3d\x57\xc8\x85\x09\x55\x5c\x97\x10\xab\x9a\x4d\xca\x25\xca\x95\xa0\xaf\xc1\x24\x00\xf3\x3a\xec\x36\x9e\x77\x98\x65\xd9\x6e\x31\x33\xa2\x5a\x62\x82\xcc\x84\x2d\x68\x3b\x90\xb6\x09\x6d\x77\x59\xfa\x26\x74\x52\x69\x16\x2d\x26\x93\x4c\xb1\x26\x9d\x89\xd5\x9d\xfc\x9f\x99\x10\xe4\x5e\x03\x1e\x06\x21\x5c\x9f\x6c\x1f\xbb\xd0\x64\x25\xd5\x22\x3b\x1c\x22\x71\x3a\x3d\x6e\x9b\xd1\xe8\x41\x82\xe0\x76\x80\x88\x30\xf3\x4c\x48\x9c\x8a\xca\x42\x93\x3d\x6e\x32\x5b\x28\x2f\xeb\xb8\xb4\xb1\x9c\x1d\xad\x22\xa3\x9d\xfa\x6a\xdd\x0a\x18\x97\x1e\x09\xe1\xac\x4b\x11\x5d\x42\x33\x51\xd2\x06\xb7\xe1\x8a\xd7\x69\x34\xda\x4c\x2e\x89\x89\x69\x37\xef\xb1\xb8\x65\xba\x60\x96\x32\x81\x29\xea\x24\xd6\x66\x90\xdb\xf6\x78\x0b\x8f\xaf\x7e\x4c\x54\x4d\x24\xb9\x95\xb7\xb6\x00\x5d\x05\xc6\x25\xf8\x05\x60\x47\x5a\x67\xba\x14\xd7\x5a\x04\xab\x3b\xb6\x9e\x26\x81\x0f\xad\x37\x07\xf2\xa1\xd9\x4a\xaa\x5b\x14\x7d\x92\xe0\x70\x10\xbb\x64\x4f\xf1\x73\x56\x6b\x8a\x47\x96\xfd\x82\xc7\xeb\x61\x14\x23\xde\x26\x9b\x56\x85\x8a\x31\x6a\x36\xc6\x1c\xa2\xea\x4c\x20\x99\x44\xbc\x76\x95\xd9\x1e\x5d\x2e\xb9\xe1\x44\x74\xe1\x44\xab\xf6\x42\x52\x03\xd2\xab\x99\x55\xf1\xa5\x67\xb4\x86\xc4\xc4\x15\x1b\xe7\x44\x64\x39\x7f\x8e\xc9\x4c\xe7\x49\x04\x7d\x76\x72\x09\xa1\x70\x85\xde\x5b\xc7\x59\x8e\x2c\xfe\x5c\x53\x84\x3f\x07\xb1\x7a\x69\xf1\xa1\xac\x70\xd7\x1a\x9f\xb6\xee\x70\x87\xf8\x10\xeb\xbd\xd6\xf8\x0c\xbe\xeb\x94\x0e\x5f\x45\x15\x1d\x33\xa0\xea\x49\x8f\x4f\xe6\xc5\xe3\xe3\xce\xe2\x93\x79\x34\x8a\x1e\x9f\x54\x27\xe0\x3b\x4e\x62\x24\xb4\x46\x2f\x8e\x43\x6f\x8d\x8d\xa8\x47\xc0\x58\x13\x3f\x4f\xef\x3b\xd1\x56\xe6\x62\x2b\x6f\xb5\xfd\x84\x05\x28\x8c\x22\xa8\x0c\x95\xa3\x0a\x34\x10\x0d\x45\x23\xd0\x18\x34\x01\x4d\x41\xd3\xd0\x4c\x54\x85\xe6\xa1\x45\x68\x29\x5a\x8e\x56\xa1\x75\x68\x23\xda\x82\xb6\xa3\x1d\x68\x37\x7e\x4d\x59\x68\xcd\x1b\x32\x79\xad\x50\x53\x63\xcb\x1f\x3a\x65\x9d\xb0\x54\xcc\xe8\x35\xfa\x66\xa1\xba\x5a\xca\x2c\x1b\xb3\x43\x98\xe7\xec\x36\x60\xea\x75\x42\x6d\xad\xab\xa0\x62\xda\x46\x61\xb9\x31\xbb\xef\x55\xbb\x84\xd9\xb3\x4d\xa1\xf2\x11\xbb\x85\xaa\xaa\xe5\xf3\x96\xf2\x8b\x56\x91\xd4\xe2\xf1\x37\x08\x0b\x17\x72\x81\xc8\x84\xed\xc2\xa2\x45\xb7\xfa\xc2\x03\x67\x6e\x11\x56\x79\x0b\xaf\x9c\xb1\x59\x58\xb5\x72\x65\xfd\xbc\xaa\x45\xf3\x17\x35\x62\x1e\x44\xdb\x9c\x59\xf3\x67\x4e\x9b\x32\x71\x8a\x76\x77\xcd\xd5\x13\xc7\x8c\x98\x30\x76\x82\x76\x37\x72\xd8\xd8\x81\x15\x43\x07\x0d\xd5\xee\x94\x7e\x83\xca\xcb\x22\x45\x11\xed\xae\x77\x49\x51\xb8\x20\x3f\x27\x5f\xbb\xeb\xde\x25\x27\x94\x19\xf0\x07\xb4\xbb\x60\x9a\xdf\xe7\xb2\x51\xc3\x83\xde\xb9\xed\x66\x36\x3e\xa9\xdd\x81\xfe\xd8\xb2\x71\xdd\xea\x75\xf4\x2e\x33\xba\x69\xfd\xea\xf9\x13\xc7\x0e\x2a\xca\xf1\x9b\xd1\xea\xd5\xc8\xec\xcf\x29\x1a\x34\x76\xe2\x7c\xe3\xd6\xba\x65\x8b\x97\x2e\xd6\x52\xac\x5a\xbe\x74\xf7\x8e\xed\x5b\xb7\xc3\x5d\x43\x74\xe7\x8d\x5b\x2f\xa1\x78\xd3\xf3\xc7\xb7\xa3\x38\xb5\x75\xe8\xfa\xa7\xc3\xfa\xe4\xff\xed\x2f\x65\x17\x9f\xee\xbf\xc0\xc7\xb6\x6d\xb2\x05\xba\x7a\xb0\xb3\x9f\x9e\x45\x74\x7b\x66\xae\x7e\x09\xbf\x30\x2c\x5d\xe6\xb9\xef\x32\x71\x92\x9f\xe3\xcb\x84\xe7\xcd\xc3\x77\x6b\x57\x6c\x5f\x75\x35\xbe\x5b\xbb\x9a\x5a\xfe\xfd\xf3\x73\xda\xa3\xe6\xb3\xd5\xd5\x64\xde\xbc\x79\x6a\xb5\x76\x9d\x6b\x8d\x7d\xae\xd3\xa7\x34\x41\x67\xf0\x84\x2e\xb3\xe9\xa7\x72\x56\xeb\xa7\xaa\x63\xb8\x92\x7e\x66\xcf\xa0\x9f\xd9\x2c\xac\x3d\x96\xbe\x65\x89\x71\x88\xdd\x21\x34\x8c\xb5\xc1\x37\xfe\xef\xda\x20\xda\x83\xee\x44\xf7\xa0\xfb\xd1\x41\x74\x04\x3d\x8a\x8e\xa2\xe3\xe8\x14\xfa\x35\x3a\x8d\xce\xa0\x57\xd1\xeb\xe8\x3c\x7a\x0b\x5d\x40\xef\xa3\x8f\xd1\xa7\xe8\x0b\xf4\x57\xf4\x1d\xfa\x01\xfd\x13\x35\xa1\x16\xcc\x41\x57\xd8\x84\x6d\xd8\x85\x7d\x38\x80\x33\x39\xd3\x71\x52\x3c\xfb\xc1\x46\x6c\x3c\x29\xfc\xe9\x4f\x5c\xa4\xea\x48\x23\x36\x29\x1e\xe1\x42\xc6\xe8\x5d\x4f\xfc\x24\x7c\xf4\x51\xe6\x98\xdd\x47\xff\x29\x7c\x2c\xf6\xaa\xfe\x55\x23\xb6\x9e\x14\xfe\xf0\x07\xa9\x6c\xde\xc1\x46\x6c\x83\x48\x6f\x65\x8f\xbf\xee\xa9\x4b\xc2\xc5\x8b\xa1\x09\x1b\x8f\x37\x09\x9f\x1a\xfb\x2e\xdc\xdf\x88\x9d\x27\x85\x37\xde\x30\x95\x2f\xba\xbf\x11\xbb\x20\xd2\xf9\xbc\xc9\x9b\x4f\xaa\xc2\x5f\xfe\x92\x3f\x65\xcb\xa9\x16\xe1\x0b\xeb\x80\x9a\xbb\x1b\xb1\xf7\xa4\xf0\xda\x6b\xb6\x8a\xa5\xf7\x34\x62\xdf\x09\xe1\xf5\x6e\x53\x6f\x78\xa6\x11\x93\x93\xc2\xd7\x5f\x17\x4c\xdb\xfe\xeb\x46\xcc\x9d\x10\xfe\xea\xbc\xb2\xf6\x8e\x46\x9c\x7a\x52\x78\xe5\x15\xd7\xc0\xe5\x77\x36\xe2\xc0\x09\xe1\xd5\xc2\x19\x37\x3f\xd7\x88\xc5\x93\xc2\xdf\xfe\x16\x9e\xb9\xe3\x74\x23\x96\x94\x4c\xe1\xbb\xef\x5e\xfd\xeb\xeb\x5f\x9c\xff\xf4\xad\x8f\x2f\x18\xdf\x3f\x93\x7a\xd5\xda\x47\xfe\x4b\x78\xef\xbd\xc0\x88\x75\x8f\xfe\x20\xbc\xff\x7e\x23\x0e\x1e\xf7\x0d\x5d\xb5\xa7\x11\x67\x9e\x10\xce\x78\x87\xac\xbc\xad\x11\x67\x1c\x17\xce\xbc\xf8\x62\x23\xce\x52\xe4\x33\xaf\xbe\x7e\xfe\x2d\xe1\xc2\xdb\x17\x68\x3b\x76\x44\x9f\x7f\xe9\xb7\x67\xdf\x14\xde\x3e\x7a\xfc\xd4\xaf\x4f\x0b\x8f\x3e\xf4\xa8\xf6\xf4\xb1\x63\x0d\x8d\xbf\x11\x1e\xda\x73\xe7\x3d\xf7\x1f\x14\x8e\x1c\x3a\xa2\x3d\xbd\x75\xef\x5d\xf7\x1e\x10\x0e\x6d\xdc\xb2\x7d\xc7\x6e\x41\x97\x16\x8e\xe8\xfa\x4d\x5b\x6f\xdc\x29\xac\x9e\xb7\x68\xe9\xf2\x55\x42\xd5\xac\x2a\xed\xe9\x9c\xf9\x8b\x97\xd5\x09\xb3\xc6\x4c\x98\x32\x6d\xa6\x30\x62\xd8\x08\xed\xe9\xc8\xb1\x13\xaf\xbe\x46\x18\x56\x56\x5e\x31\x70\xa8\xa0\x4b\x2d\x47\xb4\xa4\x77\x3f\x65\x90\x50\x94\x19\xca\x2f\x08\x0b\xba\xbc\x72\x44\xd3\x82\x39\x5d\xba\x0b\x7e\xc9\x64\x73\xf9\x04\x5d\x52\x99\xa2\xbc\xc1\x6c\x77\x0b\xe8\x9f\x4d\x2d\x4f\xd3\xca\x3d\x2e\xfc\xf0\xfd\x0f\xf0\xe6\x78\xf4\xc7\x7f\x35\x3f\x8d\x11\xc4\xf1\x09\xdf\xbf\xfd\xd0\xa1\xd5\xb3\x86\x15\xf9\xd1\xf7\xdf\x23\x7f\xd1\xb0\x59\xab\x0f\x3d\xf4\xb6\xb1\x11\x1b\x14\xf9\x83\x4f\x3e\xfb\xf2\x1b\xe1\x9d\xf7\xdf\x81\x34\xa7\xa2\x1f\x7f\xfa\xc5\x5f\xbf\x13\xde\xbf\xc2\xd5\xca\x21\xa0\xc0\x4c\xd8\x00\x17\x8f\xa2\xd8\x8c\xed\xd8\x8d\xfd\x38\x0d\x9e\xb2\x0e\xa1\xbe\x87\xd4\x1f\xd6\x03\xed\x44\x9c\xaf\xdd\x56\xd3\xff\xed\xef\x2f\x17\x71\xff\xf3\x1f\x3a\xf3\xea\x09\x95\x75\x72\x09\xff\x3f\x3c\xcf\x6d\xf7\x2c\x2e\x54\xf3\x3b\xb9\xa4\xcb\xc0\xf1\xfd\xc2\xf8\xf8\x17\x3e\xa7\x82\xb3\xed\x7f\x13\x08\xe3\x73\x6d\xff\x9b\xe7\xfe\x2f\x62\x31\x31\x9d\x88\x03\x92\x99\xbb\xbb\x43\xbc\xea\x0e\xc0\x3a\xe2\xd5\x31\x4e\x53\xcb\xff\x04\x07\x5d\xe8\xcf\xee\x20\xfa\x67\x5d\x46\x0d\x5c\xf6\x79\x65\xeb\x47\x53\x0f\x33\x92\x94\x44\x65\x92\xaa\x68\xa3\x30\x66\x27\xab\x0d\xed\x83\x7a\x33\x7b\x92\xea\x8e\xc1\x68\x38\x1a\x85\xc6\xa1\x49\x28\x8a\xa6\xa3\x4a\x34\x17\x2d\x40\x4b\xd0\xb5\x68\x05\x5a\x83\x36\xa0\xeb\xd1\x36\x74\x13\xba\x05\xd5\xa3\xdb\xd1\x3e\x74\x1f\x7a\x00\x1d\x46\x0f\xa3\xc7\xd1\x93\xe8\x04\x7a\x1a\x3d\x8b\x5e\x40\x2f\xa3\xdf\xa1\x73\xe8\xf7\xe8\x8f\xe8\x5d\xf4\x21\xfa\x33\xfa\x1c\x7d\x85\xbe\x45\x7f\x47\xff\x40\xff\x8d\x62\x18\x63\x01\xcb\xd8\x82\x1d\xd8\x83\x53\x70\x3a\xce\xe2\x1c\xca\xa2\xd4\x39\xab\x0f\x7f\x26\xbc\xfc\xb2\x2e\x74\x46\x2c\xaa\x7f\xf4\x7b\xe1\xf5\xd7\x87\xcd\xbf\xf1\xa1\x7f\x08\xbf\xcd\x98\xb5\xee\x81\x4f\x84\x17\x5e\x08\xcc\x5d\xf3\xab\xcf\x85\x17\xc7\x2c\xdd\x71\xf4\x1b\xe1\xfc\xf9\x91\x8b\x77\x3d\xf6\x77\xe1\x6c\xf6\x35\x1b\xef\xfb\x40\x78\xf6\xd9\xcc\xca\xf5\xfb\xff\x2c\x3c\x37\x61\xf9\x9e\xe3\x5f\x0a\x6f\xbd\x35\x76\xd9\xce\x63\xdf\x0a\x6f\xe6\x5d\xbd\x65\xdf\x3b\xc2\xd3\x4f\x87\xa6\x6f\xba\xfb\x43\xe1\x99\x7f\xb6\x3c\x0b\x9a\xc9\x86\x83\x20\x59\x7c\xd8\xa7\xc8\x13\xeb\xf6\x36\x7c\x25\xbc\xdd\xad\xf9\x59\x10\x6b\x16\x26\x71\x3c\xd8\xa3\xd8\xf3\xa3\x5b\xef\x78\x57\x38\x59\x44\x65\xa4\x30\x68\xd0\xbf\x9e\x03\x19\x67\x00\xb1\x94\x05\x11\xfc\xd8\xaf\x98\x4e\xbe\xfd\xcc\x9b\xcf\x9d\x7d\xf1\xb7\x9c\x11\x83\x32\x52\xec\x43\xe7\x6d\x3f\xf2\xa3\xf0\xea\xab\x82\x6c\x71\x78\xa0\xdb\xda\x88\xb3\x15\x53\x61\x71\xaf\xbe\x03\xae\x14\x11\x2a\x88\x3d\x87\x79\x6c\xc4\xe9\x90\xdc\x09\x7f\x21\xc5\xac\xcb\x59\xef\xc0\xd7\xde\xf8\x03\x68\xaa\xe3\xc2\x2b\xe4\x15\x66\xd5\x3d\xfd\xec\x0b\x2f\x37\x62\xcf\x09\x81\x34\xfe\xe6\xf9\x97\x1a\xb1\xfb\xb8\x20\x1c\x11\xd8\x2b\xe5\xd1\xa3\xc7\x41\x29\x9e\x10\x8e\x54\x3c\xf2\xc4\x53\xa0\x29\x8f\x0b\x0f\x8a\x0f\xb2\x57\xfb\xee\x7b\xe0\x70\x23\xb6\x9c\x10\x44\x50\x16\x87\xa8\x63\x79\x41\xde\x2e\xb3\x57\xfd\x76\xd4\x83\x56\x92\x4e\x08\xdb\xcb\x6f\xbe\x15\xb4\x92\x78\x5c\xb8\xc1\x78\x03\x7b\xb5\x7a\xdd\xc6\x2d\x4c\x0d\x1a\x57\xad\xbd\x6e\x33\xe8\xc6\xe3\x82\x65\x9e\x45\x53\x04\xbd\x41\xb3\xb4\x08\xf3\xca\x16\xd6\xd4\xaa\x42\xb5\xb5\x5a\x7b\x7a\xf5\x35\xb3\xe6\x34\x0b\x56\x50\x2f\x55\x4d\x82\x63\xa8\x43\x57\x25\x23\xc6\x4c\xf8\xa7\x30\x34\x72\xd5\xe8\xf1\x3f\x09\x43\x9c\x43\x18\xf0\x77\x40\xea\x37\xe2\xb4\x13\x82\xf3\xc2\xfb\x1f\x7f\x0a\x8a\xf5\xb8\xe0\xf9\xd1\xc3\x5e\x15\x7d\xf9\xcd\xf7\xa0\x30\x95\x34\xe1\x47\x72\x44\xdc\x6e\x9c\x67\x1d\xea\xfc\xf1\x47\xe7\x50\xeb\x3c\xe3\x76\xf1\x08\x31\x7a\x07\x81\xb6\x04\xa5\x7d\x5c\x78\x15\xbf\x0a\x29\x4e\x46\xb1\x1a\x06\xa5\x01\xca\x15\x54\x8f\xf7\x07\xa6\x46\x52\x33\xb2\xf3\xba\x09\x5e\x14\xd7\x0a\x6c\xb9\xda\xff\x6b\xe5\xe0\xb7\xbf\xe2\x2b\xd6\x1c\x78\xfd\x3f\xd3\x10\xd0\xbb\x8a\x94\x86\x3a\xb9\x22\x9e\xce\xae\x90\x27\xe2\xe8\xe4\xc2\xed\x22\xfa\xe0\x59\x7e\xd2\x25\xb5\x7b\x2f\xc0\xb3\xb2\xe4\x7b\xb8\xb2\xe0\x92\x4a\x43\x9e\x5c\xf8\x75\xc1\x6f\x28\xe9\x6a\x9f\xfe\xdf\xbe\x6f\x97\x3f\x6e\x7f\xaf\xe3\x48\xd3\xa5\x63\xc8\x57\x87\xd9\xe6\x17\xde\x73\x70\xf1\x6f\x34\x15\x57\xb7\x7e\xe6\xb5\xfe\x25\x7f\x9a\xee\x8a\x3f\x4e\x16\xc9\xfa\xb3\x58\x4b\x3c\x5d\xf3\xd9\x79\x38\x02\x72\x19\xec\xf1\x04\xa8\x44\xc2\xf6\xf7\xad\x80\x08\x4e\x12\xe9\xe4\x1c\x7b\x37\x8f\xfe\xd3\xd8\xec\xa2\xdf\xb1\x7d\x38\xbb\x92\xfe\x87\x66\xe1\xac\xd9\xec\x3f\x49\xec\xbe\x30\x5b\xfd\x78\x96\xfa\xa1\xf6\x3f\x03\xbe\xc5\x85\xf1\x57\xcf\xb7\xd7\x0f\xcf\xc7\x03\x67\x5a\xd3\xab\x1f\x77\x10\xff\xad\x8f\x12\xb1\xc4\x73\x71\x91\x9f\xad\x07\x20\x57\xc8\xa0\x92\x01\x3d\xa3\x81\x99\xad\x25\xd5\xa2\x43\x44\x36\xc6\xb0\x0a\xad\xe0\x27\xf3\x13\x35\x5f\xe3\x02\x6a\xeb\x6b\x3c\xcb\x91\xb5\x8a\xfb\xb8\x39\x8b\x9f\xd8\x9c\x85\xa8\xdf\x51\xc4\xbf\xce\xff\x8e\xf5\x3d\xa8\x97\x3e\x42\x64\x81\xe3\x0c\xfa\x2a\xc8\x70\x24\x69\x0e\x96\x26\x75\x39\xb2\x1c\x84\xff\x5d\x53\xd9\x48\xbe\x27\xfd\xe1\x37\x34\x9d\xe7\x7b\x22\x8c\xe7\xe3\x8d\xdc\x1c\x6e\x1d\xc0\x49\xa5\xfe\x1b\x31\xf5\xd9\x69\x67\xf0\xc3\xe7\xa6\x27\xd6\x2e\x50\x8f\x83\x73\x54\x1e\x37\xe3\x8d\xb8\x99\xcd\x2f\xb4\xa6\x93\x50\x1f\x85\xce\xf9\x48\x18\x1b\x64\x24\x81\x58\x53\xcc\x51\x06\x44\xe6\x10\x21\x22\x3c\x78\x32\x4a\xd8\x72\x14\xfb\x4b\xda\xa6\xb9\xd6\xc5\x66\xba\x2b\x43\x0d\xf8\x48\xf5\x5e\x0a\x5f\x1d\x8b\x67\xab\xfb\xd9\x7a\xe9\x21\xfc\xcb\x24\xfb\xb2\xf4\x30\xf0\xcf\x36\x0d\x24\xd9\x6a\x0e\xdd\x7b\x8b\x8a\xf9\x67\xf9\x27\x00\x6f\xcf\x29\xba\x64\x05\x71\x38\x11\xdb\xd1\xa7\x67\x51\x99\x8c\x6d\xe4\x6a\x32\xb9\x98\x5f\xdf\xb4\x95\xae\xdb\x6b\xf9\x1c\xe8\xf7\x18\xc4\x07\xd8\x3c\x75\xb8\x9b\x04\x5b\xc6\x25\xfc\x9d\x4d\x0b\xf8\xc7\x62\xfb\x63\xf7\x20\x7d\x6f\xef\xe7\x00\xbf\x52\x87\x0f\xb8\xb4\x83\x2f\x13\xfe\xd9\xd8\x23\xb1\x87\xf8\xca\xa6\xad\xfc\x7a\x2d\x0d\x81\x34\xfb\xf4\x3c\xda\xa6\xa0\xf3\x90\x98\xdf\x47\xb3\x68\xea\x43\xe6\xea\xeb\x9a\xa2\xc2\x01\x24\x20\x19\x8d\x55\xba\xf0\x9c\x88\xb0\xc8\x19\x0c\x50\xad\x12\x9d\x17\x34\xc9\x02\x91\x24\xce\xc0\x89\xc7\xa2\x36\x0e\xcb\x74\xb5\xea\x31\xe6\xac\x3c\x69\x2b\x62\xff\x70\x24\x92\xbc\xfc\x4b\xf3\xf7\x41\xbd\x6f\xca\x38\x22\xf3\x64\xd7\x78\xb5\x0c\xff\x6e\x3c\x7e\x5d\xb5\xaa\xfb\xf1\x6c\x3c\x8b\x9c\x27\xbf\x8f\xf5\x24\xa5\xb1\xd7\x63\x2f\x92\x01\x74\x5d\xd1\x41\xf4\x2b\xbe\x1b\xdf\x95\xf9\x62\x29\x52\x8c\x7e\x83\xc1\x8e\x50\x30\xcb\xec\x86\x6a\xa4\x9b\x27\x79\x3e\x8d\x55\x68\x62\xd7\x5c\x72\x75\xba\xe2\x6b\x14\xa9\x43\x95\xec\x42\x5c\xe6\xa6\xab\xee\x06\x60\xba\x17\x27\x94\x6d\xc5\x07\x57\xff\x7e\xcd\xda\x3f\xac\x59\xf3\xfb\x75\x6b\xdf\x5c\x3d\x79\xf6\x91\xaa\xd9\x0f\xcf\x99\xfd\xe8\xec\xca\x87\x67\x93\x39\xf4\xf9\x5b\xf0\x6a\xf5\xea\x37\xd7\xce\x7e\xb8\x72\xd6\x23\xb3\xe1\xcd\xec\x87\x29\x23\xcd\x47\x93\xf9\xb9\xfc\x78\xe0\x34\x1b\xdb\x67\x95\x0f\x7d\xeb\x32\xe8\x57\x0f\x85\x3e\xf5\x14\xe8\x4f\xcf\x83\xbe\xf4\x2a\xb4\x11\x2c\x8c\xde\x63\xe7\xcf\x9f\xb8\xb8\xf7\xea\xd5\xfd\xd6\x77\x59\xb6\xac\x7b\x5d\x70\xd6\xac\x9c\x39\x86\x61\xc3\xcc\x23\x91\xa2\xf0\x83\xec\x45\x45\xee\x92\x92\x41\x23\xe7\xd4\xad\x5f\x2c\xf9\xaf\xbe\x26\xcd\x7f\x8d\x7f\xd3\xf5\xa3\x57\xd6\xae\x6c\xc4\x29\x27\xa3\x57\xd5\x0e\xb9\x6e\xed\x75\x2c\x78\xe5\xda\x5e\x35\x0b\x6b\x58\xb0\x78\x61\xc6\x8c\xa9\x33\x58\x30\x75\xaa\x77\xf2\xf8\xc9\x2c\xe8\x1c\x2f\x0e\xe8\x3b\x80\x05\x49\x5f\x6b\x61\xb7\x42\x08\x2a\xde\xa8\xb1\x5b\xed\xda\x85\x53\xc7\xf7\xed\xd6\xad\xef\xf8\xa9\x0b\xd7\xd6\x4a\xb3\xf3\x66\x57\xb3\xad\xa3\xb3\xf3\xf2\xb2\x21\xf0\x54\x34\xcf\xce\xe6\x86\xec\x2f\xb5\x7a\x31\xd0\x86\x8e\x92\x76\x63\xff\xfc\x77\xa2\x82\xdb\xfa\xd9\xbb\xcc\x17\x5d\x1e\x1b\xca\x2e\x2d\x89\x14\xe7\xeb\xbf\x2e\xfd\xd7\xa7\xff\xc6\xdf\x4b\xed\xee\xdb\xff\xb6\x7f\xdf\xfe\x3e\xb7\x1d\xfc\x78\x7e\xdc\x47\x25\xbd\x7b\x97\xec\xa5\x5f\xff\x2c\x2b\x2d\x2b\xcd\xa1\x21\xb5\xac\x17\x7c\x1e\x2f\x2b\x2d\x2d\x23\xe3\xe9\x77\x2c\x95\x3e\x20\x5b\x12\x71\x63\x4f\x94\xf4\xee\xd5\x8b\x45\xc6\xbf\xa5\xef\xd4\x6b\xe8\xf7\x3f\x69\xe4\xbd\x34\xc4\xdd\x01\x5f\xdd\xe1\x4e\x7d\xab\xac\xac\xf4\x53\xb8\xc1\x7b\x20\x30\x95\x02\x5b\x05\x5f\xf8\xe9\x5e\x91\x3e\xb1\x41\x10\xda\x57\x52\xd2\x9b\xa4\xe9\x91\x54\x0e\x02\x9f\xd1\x64\x7f\xec\x5d\xd2\xbb\x1b\x04\xa0\xad\x3e\x81\x6e\xe2\x33\xb9\x4b\xc8\x82\x5c\x27\x79\xa3\xd1\x6a\x93\xa0\xb1\x9e\x4b\x08\x40\xc6\xd4\x28\x94\x8d\x4a\x81\xc5\x49\x75\xcd\xbb\xb5\xaa\x7a\xea\xa4\xaa\x2e\xbd\xc0\x5d\xaa\x7b\x6f\xe1\x29\x55\xc5\xdc\xc9\xc5\x7f\x5c\xc5\xd6\xe6\xe5\xd2\x73\x56\x78\xea\xdb\xd5\x45\x65\x33\x6f\x06\x81\xe4\xc1\x6e\x3b\x74\xaf\x01\x66\xf8\x5c\x62\x6e\x8e\xae\xc9\xcb\x72\xe0\x76\xad\x24\x97\xdf\xd2\xcc\xaf\x7c\x7d\xd5\xca\x73\x2b\x57\x9e\x85\xef\x15\xfc\x96\xa6\x0d\xe4\x8a\x95\x67\x57\x42\x18\x1e\xae\xa2\x5e\x73\x93\xf3\x08\x31\x0f\xab\x6e\x73\x9a\x3b\x0d\x72\xca\xc5\x39\x86\x20\xb6\xfb\x21\xaf\x0f\xdf\x80\xff\x76\x13\xd6\x2c\xc7\x76\xed\x34\xbf\x13\x0c\xc6\xcd\x7e\xa4\xb2\x12\x1a\x21\xfb\x1e\xd5\x11\x9d\xc4\x3b\xf8\x4e\x46\x0d\x74\x43\x0d\xde\xc6\xcd\xe0\x56\x00\x2d\x53\xa8\x6e\xb0\x22\xe4\x96\xa4\xd4\x00\xe7\xd3\x75\x03\x67\xe7\x40\x37\x70\x46\xa3\x83\x89\x12\xe3\x65\x74\x03\x5b\x10\xa8\xf9\x4f\xf3\xb5\xd9\x48\xcc\xcd\xb8\xb3\x72\xd0\xb2\x41\x7b\xe6\xce\x1b\x7a\xd5\xc8\xea\x21\x43\xaa\x67\x5f\x35\x6a\x26\xd9\xb0\xe8\x96\x2b\x6a\x07\xcf\xab\xbf\x6a\xe8\xbc\x21\xd5\xd5\x43\x86\xce\x5d\x40\xfd\xe4\x04\x10\xe1\x9f\xe4\xef\x62\xf2\xac\x00\xa4\xc6\x60\xb4\x5e\x71\xe7\x05\xbb\x17\x57\x14\x07\x07\xf3\x08\xe4\xdb\x50\x10\x70\x43\x06\xf4\x6e\x6c\xf9\xe4\x94\x6c\x19\xd6\xbb\x77\x79\xf9\x15\xcc\x6a\x2e\xed\x1a\xea\x4a\x27\x36\xec\xd1\x70\xa8\x5c\x31\xdb\x87\x95\x87\xca\x43\x50\x99\x54\x12\x3e\x15\x65\x62\x10\x7e\xcc\x28\x7c\xb6\xa0\xd5\x1b\xb1\xd6\x42\x75\xc9\xd8\xaa\x84\x75\xa7\x0a\x54\x42\x6a\x3b\x87\x3d\xfa\x4e\xe2\xf6\x12\xb2\x4c\xdf\x1a\x4e\xf7\x78\xe4\x26\x85\xb1\xbe\xef\x93\x91\x24\x3f\x70\x1f\xb6\xef\xdf\x8f\x6d\xfb\xef\x53\xbf\xdf\xbf\x5f\xfd\xfe\xbe\x8a\x9d\x3f\xdc\xb2\xf3\x87\x9d\x3b\xff\x0b\xbe\x6f\xf9\xa6\x6b\x7a\x7a\xb7\x6e\xe9\xe9\x5d\xf1\xf1\x78\x48\x9d\xdf\x77\xc3\xe8\xb1\xeb\xfb\xf4\x5d\x76\x7e\xe8\xf2\x29\x85\x64\xd4\x7e\x6c\xbf\x2f\x9e\x98\x02\x83\x64\xb7\xfc\xb8\x83\xa6\xff\xd1\xa2\x25\x89\x27\xed\xaa\xfe\xd7\xe8\xbe\xe5\xa3\x7a\x3e\xd9\x65\xd0\x60\xc4\x27\xd1\x33\x00\x72\xb8\x14\xcd\x56\x5c\x69\xd9\x5e\x7b\x17\x7b\x76\x21\x6f\x40\x86\x32\xd4\x2b\xd3\x95\xe2\xd2\xe6\x2e\x73\x53\xc2\xa5\xa5\xc5\xc5\xdd\x69\xaf\xc5\x13\xb5\xa5\x60\x1b\x50\x7d\x4c\xf1\xd2\xe2\x8d\xc5\x42\x4a\x71\x4a\x31\x25\xde\x4b\xcc\x15\x85\xbe\x73\x3e\x2e\xe0\x34\x8e\xbd\x1c\xcd\x98\x6b\x01\x7d\xdf\x8b\x90\x14\xc6\xec\x6c\x45\xcd\xd3\x50\x47\x12\xe1\x82\x4e\xc8\x52\xd8\x63\x4a\xed\xf0\xf3\xcb\xfa\x02\x75\xc6\x6c\xe8\xd3\x81\x2c\xb8\x57\x12\x1d\xe8\xaf\xba\x7d\xd0\xa0\xae\x4f\xf6\xa4\x04\x81\x76\x9e\xda\x72\x03\xff\x14\x9f\x01\x74\x88\xa0\x99\x8a\xab\x4b\x4e\x56\x16\x57\x68\xb1\xdb\x7d\xa2\x98\xca\x71\x25\xa5\xbe\x02\xe0\x11\xe8\x39\xf9\x7c\xf6\xac\x9c\x2c\xc6\x2f\x62\x4f\xad\x0d\x70\xcb\x44\x2c\x8a\x96\xcc\x1c\x9c\x83\xc2\xd3\x23\x11\xb8\x0a\xe2\x13\x0b\x05\xc9\x8e\xc7\x23\xfa\xca\x01\x97\xaf\x57\x19\x18\xf6\x5e\x7a\x14\x0c\xf3\x57\x23\xd2\x13\x61\x44\xe6\xe0\x25\x5f\xca\x2f\x63\x1e\xbc\x7a\x95\xe5\xbb\x92\x08\xf2\xc9\xa1\x29\xf3\x86\x55\x4f\x39\x1c\x39\x3c\x44\xfe\xea\x2b\xe3\x60\x08\x4c\xa9\x1e\x36\x6f\xca\xa1\xc8\xa1\xc1\xc6\x2f\xbf\x94\x87\x1c\xba\xf7\xf0\xea\xd5\x87\x8f\xac\x5c\x79\x84\xdb\x71\x78\xb0\xf1\xab\xaf\xe4\x21\x49\x71\x86\xc8\x5f\x7e\x69\x1c\x0c\x01\x0d\x8a\xba\x76\xe5\x11\x1a\xf5\x08\xb3\xff\xfa\xa1\x21\xdc\xad\xfc\x5e\xe4\x45\xd9\xc0\x03\x5e\x9f\x57\xb0\xb9\x5c\xd8\x9d\xee\x30\x99\x04\x37\x17\xca\x71\x3b\xbd\xc8\x4b\x87\x7f\xa3\x36\x88\x4e\x52\x69\xb1\x4d\x51\x2b\xa4\x34\x73\xc4\x60\x08\xb2\x96\x6f\x68\x6d\xf9\xc5\x3a\x07\x14\x24\x1d\x9e\x90\x54\x7c\xe8\xa1\xc4\x5d\x29\x52\x27\x80\xd4\x6b\x22\xed\xf6\x24\x97\x16\x5f\xfd\x75\xed\xde\xa3\xeb\xd6\x1d\xdd\x5b\xfb\xf5\xd7\xc3\xbe\xee\xbe\x75\xc6\xcc\x2d\x5b\x67\x4c\xdb\x8e\x57\xbf\x66\x7d\x64\xd9\xba\xa3\x47\xd7\x2d\x7d\xc4\xf6\xda\xb0\xaf\xbf\x26\x7d\x67\x6c\xbd\xe1\x9a\xe9\xdb\x36\x53\x59\x7d\x08\xd5\xf2\x3c\xf7\x07\xe4\x41\x59\x68\xb1\xe2\xf7\x22\x8b\x68\x30\x98\x4d\x26\xab\x80\xd2\xec\xc8\x9e\x1d\x12\xac\x9c\xcb\x95\x42\xd1\x4f\x89\x16\xb9\xb0\x8b\x13\x2d\x26\x49\xb1\x19\x32\x0d\x61\x03\x27\x83\x85\xc6\x71\x99\xac\x30\x1c\x6a\x75\x04\x91\x7a\xee\x6c\x9f\x3e\xf6\x97\x5a\x9d\x1b\xb2\xbd\x2a\xcc\x95\x40\x62\x43\x25\x93\x6b\x38\x8c\xb3\x7c\x8e\x30\xc6\x7a\x3b\x2f\x4b\x2a\xd0\xa1\xa3\xeb\xaa\xc7\x61\x7c\x91\xe0\x11\xbe\x32\xb7\xda\xa2\xd0\xc2\x0d\x4b\x14\xeb\xde\x75\x47\x15\x8c\xdd\x65\x3e\xf5\x04\xb9\xa8\xb6\x8c\xab\xa6\x45\x4c\x94\x8c\xda\x9f\xd5\xd4\xcf\x2c\xff\x28\x94\xac\x48\x49\x35\x7b\x44\xbb\xc7\x11\x10\xb2\x43\xb2\xdf\xec\xf1\x64\xfa\xc3\xfe\x0a\x3f\xe7\xf7\xdb\xa9\x51\xda\x27\x3c\x5d\xdf\x75\xcc\x08\x4f\x85\xaf\xd7\x47\xf5\x03\xdb\x4f\x0d\x38\x79\xb2\x4a\x01\xad\xf8\x0e\x9b\x32\x10\x58\x64\xd3\xae\x25\x9b\x17\xdc\x58\xd5\x6f\x6b\xee\xd1\xfa\x58\xb0\xfe\x68\xde\xd6\xf2\x39\xdb\xab\x6e\x5c\xb2\x8b\x7f\x74\xf2\x1f\x27\x57\xdf\x39\x66\xf1\xe6\x3e\x05\xdb\xee\xec\xdd\xfb\xce\x6d\x05\x7d\x36\x2f\x1e\x75\xdb\x92\x49\x17\x26\x31\xbc\x2a\x01\xaf\x45\x80\x57\x37\x8a\x97\x23\xd5\xe4\x49\xf5\x06\x85\x82\xee\xd6\x74\x47\x6a\x6a\x66\x7a\x38\xbd\x22\x9d\x4b\x4f\xf7\x74\x8e\x17\xd3\x5a\xa2\x54\x16\x17\x8c\x1d\x91\x8b\xf8\x28\xa7\x50\x2d\x3d\x69\xfd\xa0\x81\x91\xb2\xed\x0f\xdd\x58\xd5\xff\x46\x1d\xc9\x9c\xed\x15\x73\xb6\x3f\xb4\xbd\x2c\x32\x70\xd0\x7a\xfe\xd1\xfe\x4b\x94\x81\xdb\x72\xb8\x9b\xae\x5d\xbc\xb9\xbc\xab\x86\x6a\xd7\xf2\xcd\x8b\x6b\x6f\xe4\x72\xb6\x0d\x54\x96\xf4\xa7\x34\x6c\x69\x01\x1a\xce\x47\xa9\xf4\x8c\x20\xb7\xc5\x2c\xf0\x81\x34\x99\xd9\xf1\x14\xa5\x9e\x45\x42\x49\x5e\x3e\x29\x2d\xd1\x1c\xc6\x46\xe2\x6a\x95\xb3\x12\x0f\x19\xb9\x6a\xeb\x5f\x07\xd6\x2a\xd1\xfa\x0c\x31\xe3\xb6\xab\x95\xda\x81\x7f\x5d\x1c\xed\x85\x07\xfd\x7e\x3f\x4e\x7f\x60\x48\xad\xb2\xa5\x6a\xce\x66\x65\xf9\xe0\x07\xd4\x4f\xb7\xdd\xb0\xaa\x27\xa5\xcb\x56\xc8\x6b\x18\xf4\x61\x4c\xb4\xbf\x20\x9a\x2d\xd0\xab\x0a\x87\x13\xdb\xc0\x9c\xae\x88\xd3\xe5\x21\x5c\x88\x6c\xfd\xef\x4f\xcd\x9f\xfe\x37\xfd\x22\x93\x38\x9c\x46\x5d\xc0\xab\x9f\x71\xea\x67\xea\x2b\xb8\x2f\x5d\x57\x98\x8a\xfc\xdc\xc3\x7c\x35\x4a\x43\x39\x8a\xcd\x29\x49\x16\x2e\xc5\x92\x92\x9e\x21\xba\x8c\x60\x4c\x87\x23\xe7\xc2\xed\x7c\x94\x53\xf5\x93\x97\xef\x68\x3d\x05\xc5\xe7\x88\xe8\xd5\x2f\x71\xee\x50\xd7\x9a\xa9\x37\x4e\x1e\x3c\xed\xa6\x09\x7d\xbb\xe5\x99\xd7\x4c\x19\x55\x56\x84\xed\x79\xcb\xaf\x98\x7f\x38\x23\xf6\xc8\xa0\xaa\x41\xbd\xaf\x98\xe3\xe3\x06\xd5\xad\x8b\x1e\xae\x1e\x76\x63\x84\xb6\xa9\x65\x2d\x7f\xe0\xfb\x81\x6d\x42\xe7\xc2\xae\x53\x46\xa4\x79\x4d\x26\x47\xba\xc1\x90\xe2\x48\x09\x66\xdd\x64\xc4\xc6\xb4\x1b\xd3\xf0\xbc\x34\x3c\x31\x0d\xa7\xdd\x24\x63\x39\x3d\x3f\x1d\x7b\xd2\x31\x9f\x8e\xd3\xfd\x6b\x32\x6f\xca\x24\x99\xbe\x55\xbe\xed\x3e\x32\xd9\x87\x7d\x7e\x24\x8a\xee\x9b\x32\x70\x86\xdf\x5a\xe1\xc6\x6e\x90\x95\x80\xfd\x74\x67\x1f\x30\xa2\x22\xd4\x75\x00\xfd\x67\xbf\xfa\x4f\x52\xc1\x98\xdc\xc8\x4d\x94\x48\x68\x53\xbe\x5c\xb8\xc3\xb9\xa5\x02\x37\x43\x2b\x58\xec\xfb\x78\x11\xc9\xce\x1b\xd5\xbe\xc4\x1e\xfb\xbe\x3b\x2b\x19\x3e\x3e\x2e\xf6\xe7\x78\x29\x07\xce\x69\x1e\x3b\xa8\x8a\xfc\x6b\xdc\xea\x71\xb4\x9c\x77\xb5\xf4\xe6\x4b\x84\xb3\xac\x9c\xab\x15\x45\x34\xd9\x38\x29\xcd\xc5\x79\x41\xf8\x13\x89\x04\xb3\x32\x9d\x3e\x9f\xcb\x9b\x92\x6e\x73\x66\x98\xd3\x52\x31\x6f\xca\x14\x0c\x66\x67\xba\x97\xb7\x5b\x0c\x99\x7c\x2a\x1f\x90\xed\x96\x80\x2c\x07\x2c\x76\xde\x2d\x71\x4e\x54\xf1\xd2\x2b\x71\x47\x82\xda\x96\x9d\xd6\x5d\xb6\xda\x5f\x71\x18\x87\x35\x53\x4e\x73\xd4\xcb\x86\xaf\xa8\xdf\x43\xea\x54\x50\x2a\x2d\x63\x57\x04\x0a\x17\x71\x94\x79\x24\x47\x99\x00\x2f\xf8\x92\xdf\xce\x52\x1b\x66\xfd\x16\x3e\xb3\xf0\x48\xfa\xab\xbe\xa3\x36\xe0\x67\xa3\xd0\xd9\xee\x7f\x40\xbd\x07\x0f\x88\xde\x1f\xc5\xff\xa0\x5f\x43\xd5\x4f\x0e\xe0\x6b\xd4\xd7\x21\xac\x9a\xa2\x9b\xf0\x3f\x0e\xa8\x26\xca\x97\x33\x75\x1f\xda\x1e\xd0\x72\x3d\x6d\x26\x97\xcb\xc0\x5b\x1c\x0e\xe4\x46\x20\x24\x9c\x84\x23\xb3\xa0\x47\x6a\x15\x25\x71\x56\xd4\x24\xd9\x24\x10\xf0\x9c\xc4\x49\x08\x7a\xff\x2e\x7d\x07\x28\xa2\x5b\x26\xfb\x30\xdf\x94\x1d\x3b\x32\x74\x2d\x4d\x31\xf5\xe9\xc0\x8c\xd3\x84\xa3\xe1\xc4\x72\x9a\x2c\xcf\xb7\xbb\xe0\x73\x1a\x6f\x53\xd7\xe3\xad\xea\x3a\x72\x00\x7f\xb6\x6d\xef\x36\x7c\x46\xed\x0f\x3f\x6a\xe3\xbd\x6c\x2d\xed\x7e\x84\xb8\x42\xa8\x0b\x17\x1a\xa4\x84\x00\x47\xde\xe0\xe2\xc0\xee\xf4\x50\xfc\xc6\xea\xf8\x8d\x05\xfc\x28\x6a\x32\x46\xd4\xf5\xaf\xe6\x50\xac\x2d\x3a\x89\x1e\x73\x12\x22\x71\x6f\xc7\xc4\x5c\x03\x9f\x06\xfa\x45\xcc\x90\x35\xc9\x8e\x7d\x04\x3f\xb1\x1f\x29\x8d\x44\x9d\x46\x01\x34\x5a\xe9\xe2\x74\xb9\x2c\x29\x29\x48\x10\x45\x23\x42\x69\xe9\x5e\xdb\xac\xa8\xe8\x75\xc9\x32\x50\xca\x2b\x7b\x65\x64\xe2\x50\x4a\x3b\xd2\xc4\xd1\xe8\x70\xb0\x55\xc4\x91\x0f\x76\x2f\x3d\x3b\x1a\x5a\xa5\x83\x39\xd8\x8a\xb0\xed\x79\x94\x30\xa1\xfc\xc0\x66\xb2\x68\x62\xde\xe9\xb4\xd4\xcc\x54\x71\xf3\xd4\x59\x59\x69\xe4\x00\x79\x9a\x2f\x0a\xcf\x5f\xcf\x11\x31\xf6\x94\x10\x2e\xaa\xad\x15\xd4\x6e\xf7\x52\x7e\xf5\xb0\x73\x1e\x07\x33\xdb\x6d\xa4\x92\xef\x77\x8b\xa2\xc9\x2b\xd9\xa1\x5f\x9d\x96\xee\x17\x66\x46\x7d\xb2\x51\x9e\x15\x75\x1b\xfd\xf0\x27\x99\xcd\x50\x7b\x66\x4e\x6a\xe3\x07\x3d\x6e\xde\xc6\x15\x9a\x5e\x6d\xd8\xdd\xea\x53\xcf\x91\x55\xcc\x4b\x25\x59\x21\x56\x7b\xd4\x05\xce\xcc\x55\x1f\xd6\xab\x5f\x9c\xbe\xe5\x16\x7c\xf6\x6f\x98\x7b\x5e\x6d\xfc\x09\x4f\x57\x0f\xaa\xb7\x3f\xca\x3d\xb9\xe1\xa5\x9a\x98\xca\xcd\xde\x86\x67\xfc\xf1\x45\xf5\xe5\x6d\xbf\xd3\xcf\x02\xfb\x15\x3b\xb3\x70\x30\xeb\xeb\x8f\x53\xba\xb9\xbc\x5e\x7b\x1a\x42\x26\x8f\xdb\xed\xb7\xdb\x45\x13\x17\xcc\x72\xf9\xd2\x7c\x33\xa3\x69\x69\x66\x8f\xd3\x1c\xa0\x68\x1a\xb8\x99\x51\x43\x5a\xeb\xd2\x4e\xea\x18\xaf\x8d\xb3\xf6\xf8\xbe\xd5\xe4\x33\xcc\xf3\x4a\x75\x87\x3d\x12\x0e\xc1\x5f\x49\x57\x0c\xf7\xbd\x70\x65\xb8\xa4\x5f\xf1\x90\x01\xd7\xef\xc0\x17\xbf\xfa\xf1\xd7\xf7\xe1\x5b\x3f\x50\x6f\xfb\x1b\x51\xd4\x37\xd5\xef\xb1\xff\xb6\x3b\x96\x8c\x1b\x69\xdf\xef\xd8\x7b\xa3\xf0\x87\x17\x1a\x6e\x3f\x9b\x1a\x7b\x94\x54\xe0\x5d\x1f\xab\xdd\x36\x31\x9f\x44\x35\xea\xd5\x7c\x3d\xf0\x61\x57\x54\x84\x7a\xa1\x72\xf4\x88\x32\x37\xbf\x5b\x51\xdf\x3e\x1e\xd1\xdd\xb5\x6b\x4f\xce\x62\x2d\x0f\x15\x16\xfa\x9d\x06\xb1\x24\x82\x45\xe4\x72\x51\x67\x6d\x56\x0e\xf1\xfd\xfa\x1b\xfa\x18\x23\xdd\xf2\xbb\x8d\x8d\x96\x84\xcb\xc3\xe3\xa2\x92\xd3\x63\x2b\xcf\x2c\x27\x29\x5c\x79\xb9\x3d\x84\xf3\xbd\xc1\xc0\xb8\x68\xd0\xe3\xc2\x76\xe3\x58\xb6\xa3\x9c\x84\x2d\xbb\x2d\x2d\x16\xce\x02\x16\x27\x54\x68\x05\x73\x60\xa6\xf9\x8e\xa4\x2b\x4f\x23\xda\x36\x72\xb0\x39\xe2\x3d\x12\x67\xb2\x43\x15\x67\x92\x87\x2a\xdd\xcd\x5b\x00\x33\xdd\x1e\x71\x69\xee\x26\x9c\x59\xc5\x3e\x57\x84\xf3\x7a\x1c\xad\x04\xcb\x0f\x59\x71\x01\xe6\x5c\x03\x48\x7f\x2c\x09\x6e\x9f\xcb\x8a\x71\x49\xbe\x54\x56\xf3\xdc\xa9\x0f\x7f\x32\x6c\x2a\x1a\xb5\xa6\xc6\xf4\x9b\x42\xbc\x75\xce\xb8\x93\xbb\x7e\x5f\xdb\xad\x3c\x35\x6b\xd0\xd0\x39\xd3\x44\x71\xf0\xa9\x2d\xa6\x86\xef\x2b\xef\x9a\xb4\x57\xdd\xae\x1c\x59\xb7\x98\x58\xac\xa3\xa6\xa9\x57\xe3\x47\xae\xfc\xfa\xa1\x06\x11\x67\x7a\xc7\x4f\x75\xe0\x9c\x14\x7c\xa7\xda\x7d\x46\xa3\x5a\x38\x76\x9c\xb4\xcc\xbe\x60\xd9\xfa\x79\xea\x62\x12\xc0\x33\xf7\x8d\x8b\x72\x5f\xce\x0b\xe3\x55\xb6\x1a\xac\x0c\xef\xf2\x04\x1d\x9d\xbc\x05\xe8\x3c\x0f\xe8\x9c\x06\x3c\xb2\x4c\xe9\x22\xa4\xa7\x07\xbc\x16\xb3\xcc\x1b\x7c\x3e\x31\x23\x85\xf3\x4b\x7e\x12\xa0\x5e\x75\x03\xce\x60\x96\x3f\x90\x6e\x49\xf1\xf2\xa0\x3f\x6c\x8d\xd8\xa8\x38\xa2\x6e\xaf\x84\x33\xcd\xd4\x13\x7f\x54\x16\x38\x6c\x63\xae\x4e\xf5\x05\x8f\x71\xe7\x92\x15\x6d\x5c\x20\x25\x39\x17\x64\x1b\x05\x23\x74\x47\x2f\x50\x87\xce\xac\xc6\xa9\x93\xcf\x85\x5c\xc0\x52\x01\x1c\x7a\xee\x91\xbe\xab\xb1\xe5\xa9\x5d\x4f\x79\x26\xaa\x8d\xf9\xeb\x6e\x38\xf8\xf0\x83\x1b\x46\xbe\xbc\xfb\x87\xd4\x86\x37\xde\xe0\x1e\xdb\x85\x53\xd5\xbf\xe0\xdb\xd4\x9a\x5d\xb1\x14\x25\xfb\xa6\xc2\x7c\xf5\x0a\x92\xd7\x6f\x02\xb9\x5f\xed\x81\xdf\xa2\xb2\xe4\x57\xea\x7c\xfe\x04\x6b\xa7\xe3\x95\x1e\x26\x49\x32\x98\x79\xde\x46\x30\xb6\x19\x6c\x76\x87\x49\x04\xc9\x61\xb2\x9b\x8e\x99\x38\x17\x67\x32\xf1\x16\xb0\x41\x9d\x3c\xf5\x18\xed\x24\x01\x7d\xd9\x78\x45\x24\xee\x43\x20\x59\x1d\x6a\xb8\xe7\x6a\x2b\x03\xb5\xd5\xd5\x70\xf1\x27\x9e\xdc\x17\xfb\xe9\xf4\x69\x62\x3c\x7d\x20\xf6\x5b\x7c\x17\x59\x1a\xab\x17\x06\x53\xd7\xb8\x4d\xd3\x00\x97\xa7\x01\x97\x5d\x8c\xce\x15\x4a\x30\xcd\xe3\xf1\x1a\xe9\x61\x5c\x5e\x29\x3d\xc3\x07\x36\xab\x59\x1a\x17\x35\x7b\x8c\x01\xce\x31\x96\x76\xeb\xe9\x8a\xc9\x38\x03\x56\x74\x38\x5b\x59\x3f\xfc\x24\xc2\x10\x28\xd1\x76\x64\x33\x34\x68\x03\x9c\xdf\xf7\xe0\x86\x63\x47\x56\x1c\xdc\xde\x6d\xd6\xa4\x8d\xfb\x1a\x1a\x24\xcc\x5d\xbf\xb0\xea\xe8\x1b\xb1\xa7\x62\x9f\x03\x52\x4f\xd4\x2e\x2d\x39\x76\x7b\x6c\xb3\x70\x56\xbd\xae\xff\x66\xa3\x66\xdf\xee\x02\xdc\x5e\x63\x74\x1a\xa3\x74\xb1\xc8\xb2\x11\x49\x56\x9b\x4d\xc4\x98\x07\x0d\x64\xe4\xec\x0e\x83\x45\x42\x16\x24\x5a\x4d\x9c\xd1\x29\xe2\x99\x51\xd1\xc9\x27\x93\x28\xd9\xb4\x8c\xb4\x59\x83\x2e\x63\x86\x25\xd3\xad\xb4\x3b\x4a\x6a\xf1\xb9\x1d\x4f\x5e\xa9\xa6\x1c\x04\x42\xf5\xfb\x33\x27\xc7\xee\x64\xb4\xba\xee\x61\xb5\x00\x88\x35\x93\x3c\x40\xf1\xf9\x06\xf0\x99\xc3\xfc\x91\x8d\x55\xba\x1a\x45\x51\xb2\xf0\x26\xb3\x99\xb3\x5a\xa9\xe3\x63\x09\xf0\x11\x8c\xbc\x85\x9e\x54\x63\x33\x60\xc9\xc3\x59\x81\xad\x3d\x38\x81\x50\xc5\xcf\x21\x84\x93\xb1\x01\xec\xf8\x39\x07\xc3\xea\x6d\x5b\x1b\x1a\xf0\xfb\x6f\xa9\xc3\xf1\xe2\x4a\x7a\xc2\x02\xfe\x61\xb6\xba\x54\x38\xdb\x5c\x49\x2c\x6a\x58\x4d\x65\x34\x1a\x0e\x38\x6d\x61\x3e\x0e\xfa\x29\x99\x46\x9e\x40\xf7\x4c\x96\x45\x9e\x6e\xd9\x65\x87\x08\x48\x1c\x6f\xe4\x8c\x33\xa3\x9c\x53\xc3\x24\xe1\x5e\x34\x59\x74\xea\x4b\x9b\xe9\x5e\x07\x0f\xce\xe2\xb7\x3c\xd9\xbc\x8a\x2b\x8e\xf9\xb8\x17\x9b\xdf\xe0\x58\xce\xbb\xf9\xd4\x7b\x77\x34\x5d\x84\xfc\x0e\x41\x7e\x5d\xf9\xbe\x90\x5f\x7f\x25\x53\xc2\x26\x83\x81\x88\x22\x87\x21\x3f\x63\x40\xe4\x78\x6e\x6c\x94\xb7\x61\x09\x49\xc0\x2f\x1e\x94\x94\x9d\xbf\xa2\x6d\x86\x91\x78\x6e\x50\xe6\x43\xe4\xf6\xd8\x1e\xae\x77\x6c\x21\xf9\xf5\xc1\x9b\xb8\xbc\x1d\x37\x35\xbf\x17\xfb\x10\xdf\xa5\xfb\x81\xfc\x86\x1f\x2a\x4c\x45\x56\x94\x82\xfa\x2a\xe9\x36\xc9\x4c\xdc\x6e\xd0\x68\xa9\x01\x0b\x67\x04\x1d\x61\x36\xf2\xbc\x73\x66\x94\xf0\x2e\x4c\x35\x59\x44\xf3\x1c\x86\x92\x9a\x77\x44\x3b\x9f\xaa\x14\x5a\x30\x72\xd8\x11\x48\xbd\xb2\x08\xb6\x3b\xa1\x51\x3b\x40\x10\x12\x7e\xe8\x73\xd5\x07\x55\xf5\x3b\xec\xc0\xd2\x93\x0b\xb6\x65\x36\xff\xf0\xe8\xb1\x7d\x53\xc7\x1c\x7d\xf4\xf0\x88\x99\x78\x19\x1e\x85\xc7\xe1\x59\xd7\x8c\x8a\xcd\x50\xbf\x53\xbf\x5b\xc3\x0d\xd8\xc4\x0e\x1e\xc1\x68\x16\xf5\x87\xca\x8f\x06\x23\xa9\x87\x62\x91\x0d\x92\x68\x76\x9b\x0d\x9c\xc7\xeb\x24\x20\x82\x4e\x45\x9d\x76\x83\xcd\x2c\xd1\x93\x2a\x98\xc0\x89\x97\x5c\x3f\x1a\x87\xea\xa3\x88\xcb\xeb\xab\xc0\xcc\x81\xb2\x8f\xbf\x21\x90\xd5\xad\xd8\xa7\x7e\xf1\x47\x75\xd5\xf3\x7f\xb3\xf4\xb6\xf7\xdd\xd5\x6d\xed\xfc\x09\x03\xb9\x5f\xd9\xfb\x0e\x6a\x3e\xcb\xf7\x8d\x29\x5d\x5e\x2e\x3d\x89\xdf\xbc\x69\x43\x57\xba\xf6\x14\x21\xc1\x0d\x75\x9e\x05\xb6\x48\x3e\xe4\x6c\xb3\x72\x18\x39\x9d\x1c\xa8\xc9\x40\x20\x24\x1b\x0c\xd9\xc0\x93\x92\xdf\x9f\x31\x33\xea\x07\xcd\xe9\x34\x63\x89\xf9\xfb\x8b\x24\xfc\x50\x25\x46\xae\x5a\x5d\xc7\x6b\xf3\x08\x26\xea\x2e\x35\xc4\x51\xe4\x7a\xb9\xe8\x77\x00\x6b\x8e\x48\x34\x8f\xe1\xdc\x6f\xdf\x9c\x3a\x26\x3d\xb0\xec\xed\xb7\x9e\x5d\xe2\xb0\x67\xdf\x7c\xb4\x2a\xa5\x28\x34\xce\x54\x36\x65\x4c\xea\x00\x6b\x81\xdf\x99\x9d\x6f\xc2\x3b\xf1\xfc\x5d\x5b\xd5\x0c\x61\x70\xf3\xb3\x37\xfd\xfe\x01\x32\x55\x5d\x30\x2f\x86\xa7\x92\x49\x93\xe7\x17\x99\xa5\xdd\x62\x9f\xc1\x8c\x7e\x1e\x3a\x78\x07\xf4\xcb\x85\x32\xf8\x0c\x92\xdd\xed\xe2\x31\xf2\x82\xe9\xcc\xc9\x99\x99\xf9\x20\x84\xf2\xd2\xb2\xa9\x30\xb7\x46\xd3\xec\x3c\x58\xa4\xb2\xcd\x6b\xc7\x06\x8f\x56\x0c\xea\x9f\xa3\x75\x05\x79\xfb\x32\x70\x61\x6c\xc3\xac\x10\x19\x9c\x07\x48\x1c\x71\xf9\x4a\xca\x9c\x03\xb0\x2f\xa9\x18\x67\x57\x3a\xba\x78\xf2\xd6\xbd\x7e\xea\xa9\xe9\xf4\x00\x42\x5f\xa8\xe6\x85\x05\x65\xa9\xa5\xe1\x05\x73\xf5\x82\x74\x31\xe2\xa3\x83\x1f\xbf\xe6\x6e\x75\x12\x50\xff\x01\xff\x98\xe8\xa4\xf4\x59\x37\xe3\x4d\xea\xc6\xaf\x06\x3f\x86\xa7\xfe\x7d\x31\x47\xcb\xd2\xff\x0a\xc6\xa3\xd7\x03\x2f\x8c\xe0\x07\x23\x3f\xca\x46\x53\x95\xbc\x80\x23\xc5\x93\x22\x88\x9c\x81\x10\xe8\xf7\x58\xfd\x08\x59\x3d\x06\x3e\x94\xc3\x39\x02\x8e\x71\x51\x31\x10\x20\x7e\x9b\x29\x08\x85\x3b\x11\x35\xd9\x3d\xc4\x13\xdf\xca\x96\xe4\x75\xa4\xd5\x47\xab\xe6\x0f\xcd\xa9\x3b\x43\xe3\xe8\x48\x50\xeb\x30\x89\xcf\x9b\x89\xa1\x80\xa0\xa8\xf5\x21\x05\x7e\x84\xba\xf8\x8f\xaf\x2c\xec\xb9\x24\x6f\xf3\xe2\x6b\xae\xad\xaa\x99\xe4\xca\xb1\xda\xfb\xfe\x14\xbb\x90\xbd\x20\x3b\x3d\x3d\x4c\x5d\x8b\x91\x50\xce\x86\xfc\xda\x61\xd5\x9b\x57\x57\x45\x37\x95\x7c\xda\x73\x7b\x69\xe9\x49\xf2\xe2\x47\x25\xa3\xcb\x47\x65\x17\xe4\xb3\xba\x79\x8d\x1d\xe0\x46\x7d\xb0\xf4\x54\x02\x02\xa6\x27\x56\xd2\x13\xfb\x66\x46\xc7\x0a\xf8\x80\x70\x4c\x20\xd4\xcf\x99\xe6\xe6\x0d\x70\xd6\xdc\x59\x25\xef\xbf\x63\xdb\x14\x6e\x02\x49\xba\x26\xae\x6c\x0e\x30\x1b\x3e\x05\x6c\xf8\x06\x90\x1d\x12\x2a\x50\xbc\x98\x1e\xee\x41\x0c\x32\xe6\xc7\x45\xc3\x18\x3e\xa2\x64\x63\x27\x76\x50\x90\xed\x9c\xbc\x68\x1b\x4b\xce\xe1\x2f\xd4\x14\x48\xaf\xf6\xda\xa2\xba\x00\x0c\xa3\x7d\x0e\xc8\x87\x87\xf9\xf1\xc0\x4f\x19\xa8\x5c\xc9\x34\x0b\x69\x36\x2f\x42\x36\x59\xe0\x33\x83\x72\x8a\x2b\x65\x6c\xd4\x65\x37\xd8\xd3\x6c\xc4\x36\x36\x4a\xbc\x49\xdb\x2b\x50\xdb\x23\x3c\xb1\x3d\x2b\x88\x1c\x25\x4e\xea\x7a\x8f\x9d\x5c\x45\x89\xec\x64\xa3\xd2\x29\xa0\xd9\xf8\x87\x63\x8d\xea\x07\xea\x17\x1f\xbf\xec\x59\xbf\x69\xf7\x3d\x77\xef\x3f\x72\xfa\xd9\x29\x63\x6f\x7d\xe0\x0e\x52\x1a\x3b\x05\x5d\xf4\x94\x2f\x70\xb7\xe0\x8d\x81\xf7\x1a\xdf\x38\x2b\x93\x2b\x5e\x78\x5b\xfd\xe0\x1f\x2f\xbc\xa5\xfe\x10\xfb\x8d\xf4\x8e\xb6\x5f\x6b\x3c\xda\xc1\xad\xe3\xb6\xeb\x67\xc7\xa6\x0a\x98\x6e\x76\x31\xc8\x04\x6b\xe7\x36\x73\xa2\x80\x6c\x5c\x26\x47\x38\x3a\x5c\x18\x8e\x7b\x43\x76\xb4\xd9\x21\x4b\x5d\xca\xc3\xc5\xad\x8b\x5d\x20\x5d\xe9\x45\x3e\xff\xfe\x57\xdf\xc7\x7e\x84\x2f\xb6\x77\xe9\x2a\xee\x24\x6a\x68\x3d\x6b\x91\xa7\xfb\xac\x11\xa2\x1b\xf3\x79\xe8\xbe\x54\x9c\xeb\xd3\x66\xda\x98\x1e\x9e\x47\xbb\x1c\x27\xef\x9e\xb4\x8e\x5f\xbe\x67\xcf\xb3\xc4\x1b\xfb\x9a\xc1\x39\xce\xfd\x13\x6f\xd7\xe1\x64\xb2\x93\xb6\x25\xea\xf2\x87\xe3\x18\x98\x48\x44\x9f\xe1\x60\x0e\x8b\x64\x9c\x0f\x78\x45\x3c\x78\xbb\xba\x67\x0a\x5e\xa2\x6e\xb9\x5b\x98\xa3\xee\x99\x8c\x97\x5c\xbf\x67\x0f\xc0\x52\xff\xc6\xcf\xc4\x4e\x1d\x56\xba\x62\x06\x40\xb4\xdc\x44\xc3\x28\x72\x96\x2e\xfe\x60\x7e\x27\xb5\x9d\x76\xd4\x8f\x35\x76\x52\x2f\x78\xea\x03\x77\xf3\x33\xd7\x54\x02\x10\x9c\x80\x21\xd0\x73\x27\x31\x3d\x39\x18\x09\xf4\xa8\x60\x3d\xb5\x96\x16\x98\x4e\xfd\x1b\x3e\xb2\x21\xf6\x01\xff\xce\x8f\xea\x1e\xca\xc7\x2d\xa0\x94\xdf\x90\x56\x22\x19\x65\x2b\x56\x76\x16\x2a\x67\x34\xd1\xd3\x50\x0d\x89\xd3\x50\xdb\x4c\x55\x33\x1d\x18\xc1\xdc\x1b\xea\xc5\x3d\xea\x45\x3c\xcd\x81\xab\x44\x63\x2c\x46\x38\x1f\x9e\xa4\x3e\xa2\xd9\x24\x6d\x60\xca\x92\xc4\x43\x1f\xd0\x64\xe0\x79\x22\x91\x8e\x30\xa1\xc5\x62\x6d\xeb\x08\xc0\xbc\xcf\xa1\x1e\xc6\x19\x7b\x70\x86\x30\x5d\x7d\x04\x4f\xf2\x11\x2e\x16\xd3\x78\xe3\x5f\xdc\x83\xe4\x6d\xe9\x1c\xa3\x51\x57\xc5\x49\x4f\x23\xa4\x87\x22\x63\x2c\x70\x02\xbf\x7f\x9a\xc0\x69\xbe\x66\x5a\x0f\x36\x8f\xc4\xcf\xca\x64\x07\x20\xde\xb3\xa0\xf7\x7b\x1f\x5c\xe0\xff\x40\x9a\x9a\xde\xbd\xeb\xae\x8e\xf0\xe8\x59\x9b\x74\xee\x1e\xc4\x91\x24\x89\xfb\xa7\xb1\x43\xbc\x3b\x83\x07\x92\xd2\x13\x2a\x25\x6f\xbf\xd7\x7b\x41\xc9\x05\x80\xd1\x84\xbb\x6b\xf0\xf0\x61\xf2\xb6\x5e\x87\xdd\x14\x47\x07\x78\x8d\xb8\xbb\x3e\xe5\xd9\xe7\x67\x00\x02\x10\x0d\x20\xa5\xa3\x7a\x80\x5f\x80\x7b\x03\x4c\x19\xe5\x2a\x76\x42\xcf\x30\x17\x25\xc9\x08\x95\x43\xdd\xd3\xd2\xaa\x8d\x38\x22\x71\x2e\xd3\x80\x69\x4b\x61\x1c\x59\xb8\xf7\x77\x1b\x8e\x6e\x20\x77\x09\x63\xfe\xf2\x97\xbf\xe0\x2a\x0a\x0b\x00\xf6\x86\x90\x4c\xc7\xc3\x0c\x02\xe0\xc7\x63\xba\x87\x94\x07\xc3\x04\x85\xcf\xb5\x07\x05\xdd\x40\x7d\x15\x0d\xee\x1d\x9b\x0f\xb0\xbe\xc3\x55\x00\x4a\xab\xdf\x34\x75\x0a\xb9\xbd\xa5\x0e\xfa\xfb\xdd\x14\x27\x01\x7c\x10\x9d\xaa\xe7\x90\x41\xa2\xe7\x47\x40\x1d\x47\x52\xcf\x15\xb7\xf7\x94\x14\x00\x6d\x1e\xca\x97\xd2\xfe\xfa\xd8\xc5\x47\x6e\xbf\x4d\x9d\x82\xd3\xd5\x4f\x9f\x7b\x8e\xd6\x2d\x11\xd0\xef\x08\xf5\x11\xa9\xb7\x25\x76\xd2\x24\xb4\x7b\x81\xe7\x08\x74\x4b\x22\x2f\xb5\x39\xfd\x34\xf9\x48\x4b\x6e\xd1\xf9\xf3\xb1\x19\xe7\xcf\x03\xfd\x8d\xe8\x47\xee\x45\x6e\x61\x7c\x2d\x08\x8f\xe8\x9e\x07\x83\x8c\x88\x40\xcf\x41\x3c\x5b\x9c\x2c\x23\xe2\x4e\x56\x8c\xa4\x31\x36\x8c\x34\x92\x3f\xed\xdd\xab\x66\xec\x65\xfe\xcb\x89\x91\x44\xc9\x19\xd6\x8e\xdc\xa7\x04\x9e\x97\x44\xc2\x53\xb1\x90\x98\x04\x05\x9d\x59\x1a\x21\x67\x4a\xc7\x45\x9e\xe6\xff\x1a\xab\x21\xb7\xfd\x59\xdb\xdb\x6a\xe4\xc6\x26\xa7\x13\xa5\x9f\x4b\xa7\xce\xc5\xf7\xb0\x74\x1c\x9a\x08\x15\x91\x0b\xe9\x3c\x60\xbb\xa5\xa3\x29\x4a\xd8\x65\x06\x31\x4f\xbc\x29\x29\xa9\xe9\x24\x3d\x23\xd3\x87\xbc\x76\xef\x31\xef\x27\x5e\xde\xc1\x79\x8d\x20\xa0\x8d\xd4\xbf\x15\xe8\x83\x80\x4b\xb0\xa5\x62\xa6\x18\x23\xf1\xfd\x62\xda\x32\x88\x36\xee\x53\xf5\xa9\x03\xdd\xd7\xbf\xee\xc8\x88\x1d\x5b\x16\xf1\xb8\x28\x2d\x69\xbd\x1f\x68\xb8\xeb\xae\xcd\x37\x8c\x28\xe9\x11\x1a\x3c\xe0\x2d\xb5\xa1\xa1\x81\x3b\xd5\x3c\x9c\x3b\xb5\x65\xed\xde\xcd\xe6\x9b\x0c\x43\xae\xa9\xdc\x82\x17\x3c\xf6\xd8\xa5\x4f\xa8\x6e\x04\x7d\x92\x8c\xb3\xa2\x04\xe3\x18\x93\x94\xd4\x80\x0f\x25\xe3\x08\x28\x7a\x75\x14\x13\x18\xb6\x31\x3a\x2f\x8f\x5a\x27\x68\x75\x40\xaa\x79\xb8\x70\xf6\x52\x09\xf3\x01\x4a\x8c\x38\x8f\x9c\xe1\x5f\x77\xe6\xd1\xa3\x98\x1d\x12\xff\x03\x42\xea\x09\x64\x6c\xc0\xb3\xac\xd8\x4a\x9d\x6c\x82\x84\x4f\x17\x1e\xe4\x8e\x89\x9f\x42\x77\xc8\x76\x5c\x44\x46\xae\x11\x4f\xa0\xc7\x09\x14\x27\x1c\x78\x47\xb4\x99\x07\xee\x58\xc3\x1d\x77\x1c\x7f\x60\xea\xe8\x51\xd3\xc4\x4f\xeb\x1f\x3b\x76\xcb\xa8\xe9\x33\x46\xb6\xb4\x60\x13\xee\xc7\x41\x1e\xf6\x7c\xfe\x6f\xc0\xb6\x21\x7b\xbe\x60\x68\xc1\xf4\xec\x71\xc1\xc0\x0c\x4e\xea\x9b\x6c\x6a\xcb\xc7\x7c\x2d\xc4\x11\x05\x87\x9b\xde\xdb\x81\x14\xcf\x00\x5e\x22\xdf\xc2\xde\x97\xc1\xfd\x10\x7a\x0f\xed\x84\xde\xaf\x83\xfb\xf1\xec\x9e\x63\xf7\x8f\xc1\x7d\x26\xbb\x37\xb2\xfb\xfa\x96\xb7\xf8\x7c\xf1\x7a\xb8\x37\xb1\xfb\x2d\x74\x8c\x8d\xbd\x37\xb3\x7b\xb0\xb1\xb9\xf7\xd9\xbd\x8f\xdd\xe7\x27\xde\xa7\xb0\xb6\xba\x91\x10\xb8\x9f\x0f\xad\xa2\xbb\x62\x11\x39\xba\xfe\x06\xcb\x06\x91\x60\xb0\xc1\x27\x3d\x15\xc5\x7c\x23\x1e\x41\xcf\xdb\x68\x33\x14\x99\xd8\x39\x9e\xc5\x8f\x6c\x8e\xe0\xed\xbf\xc6\x3b\x08\x79\x06\x3f\xa6\x4e\x64\x79\xa4\xb4\xfc\xc4\x1f\x13\xfe\x0c\xb4\xf6\x33\x5a\xff\x0b\x5f\x82\xbc\x9c\x8a\x09\xa7\x7a\x53\xb1\x2f\x35\xe8\x70\xe6\xe2\x82\xe9\x8e\x52\x88\x6b\x80\xb8\x8f\x24\xc7\x8d\xfd\x1d\xe2\xba\x1b\x58\xd4\xc6\x96\x8f\x1b\x52\x83\xfe\x14\x2d\x76\x02\xf6\xf3\xf1\xf8\x40\xe9\x1f\x50\x63\xcb\x93\x34\x1d\xa1\x1d\xde\xb0\x92\x49\xf2\xbc\x79\x38\x3f\xaf\x3b\xcd\xe3\xd5\x74\xac\xa4\x43\xbd\xae\x4b\xc7\x7b\xd3\xf1\xe6\xf4\x5f\xa5\x13\x3a\x04\x5e\x8a\xa6\x4f\x2f\xd5\x41\xa2\xf6\x38\x24\xc3\x64\xb8\x84\x1b\x18\x48\xc0\x45\xf1\xe6\x75\xa7\xc8\x24\x81\xc3\xe9\x90\x01\x02\x48\x78\x7a\x5b\x98\xf6\x96\x14\x56\xaf\x79\xb4\x5e\x1d\x22\xff\xb7\x6f\xc1\xa2\x7a\x12\xa7\x36\xb6\xcc\x68\x48\x4d\xb5\xb8\x72\x0b\x20\x26\x8d\xa7\x1e\x6a\x13\xef\x3b\x88\xe7\x6a\xc0\xe9\x7c\x3a\xa6\x51\xd3\xd3\x69\xd4\xe9\x7a\x5c\x9d\x57\xb4\xb8\xc0\xc3\x2d\xbb\x54\x10\xce\x8a\x0b\x0f\x08\xe1\x2e\xa1\xab\x43\x44\x0a\x0d\x0d\xad\x0a\x71\x9e\x10\x24\xfe\x95\x62\x0c\x85\x20\x35\x0e\xd9\x43\x1a\x8a\x05\xd3\x29\x92\x1a\x7e\xa3\x01\xd6\x06\xd6\x1e\x90\x0e\x6b\x41\xcb\x51\x94\x73\x12\xbb\x5d\x38\xdb\x05\xc9\xff\xae\x58\x5c\x2e\x64\xce\xc5\xae\xdb\x5d\xf8\x4d\x17\x40\xd0\x41\x68\xf5\x40\x37\x61\x7f\xc8\xd2\x63\x3d\xbd\x0b\x8d\x44\x43\x95\x12\x3c\x24\xf3\x64\x26\x39\x9c\x89\xdd\x99\x78\x42\x26\xce\xce\xc4\x28\xb3\x28\x73\x16\x98\x65\x99\x99\x29\xa9\xb9\x38\x33\x9c\x39\x26\x93\xbc\x9e\x89\x53\xc0\xee\xce\xc4\x7b\x33\x0f\x65\x12\x44\x11\x4b\x60\x98\xc0\x31\xde\x16\xf2\x68\x5b\x60\x79\x74\x69\x99\x87\xba\x9f\xc4\x5e\x13\x9e\x64\x02\x1c\xff\xa5\xb8\x4c\x26\xc2\xe5\x62\xd3\x1d\x26\x5c\x61\xc2\x61\x13\xb6\x99\x30\x6a\x05\x56\xda\xa6\x0d\xe5\xd1\x36\xc4\xe0\xb4\x50\x38\xc7\x49\x0a\x2d\xe8\x8f\x8a\xd7\xe5\xe2\xc4\x5c\xe2\xba\xc3\x85\x0f\xbb\x70\x85\x0b\x87\x5d\xd8\xe6\xc2\x49\x58\x31\x38\xf8\x3a\x28\x73\x57\x68\xbb\x79\x02\x5f\xad\xc1\x99\x07\x34\x9b\xa2\x74\xc1\xc6\x89\x46\xfc\x07\x23\xbe\xde\xf8\xa4\xf1\x05\x90\xf4\x46\x8c\x8c\x41\x63\x91\xf1\x56\x23\x3f\xd4\x88\xb9\x41\x46\xec\x32\x1e\x34\x12\xd2\xd8\xf2\xb8\xe2\x32\x02\xa3\xe6\x62\x69\xb7\x84\x37\x4a\x78\xa6\x84\xc7\x48\xad\x18\xcf\x9c\x3e\x1d\xfe\xaf\xd5\x98\x94\xe5\x09\x75\xce\x3d\xcb\x7f\x08\x79\x0a\x99\x2c\x4f\xf5\xbf\x01\xf7\x2b\x94\x14\xec\x19\xea\xc1\x77\x78\xf0\x24\x0f\xae\xf3\x60\x97\x07\x6f\xf6\x40\x8f\x30\xe8\x81\x4c\xf6\x2a\x76\x8f\x47\x96\x73\xb1\xbf\xc2\x8f\xc3\x7e\x6c\xf3\xb3\x1c\x5a\xe9\xab\xf3\xd3\x36\xb0\xfb\xa7\xf2\x1f\x03\x5d\x24\xc6\x7b\x3f\x40\x69\x4a\x4e\x62\x29\x0b\x7b\xb3\x80\x30\xff\xad\xa4\x64\x65\x89\x56\x60\xa0\xf3\x21\xfc\x4c\x08\xef\x0c\xe1\xf5\x21\x3c\x33\x84\xc7\x84\x74\xda\xc4\xa9\x0c\x78\xd6\x93\x21\x5c\x3f\x46\x1b\xc3\x1a\x8d\x36\x6b\x41\x56\x2d\x57\x46\x60\x29\x2c\x6d\x84\xd2\x72\xe7\x24\x7c\x41\x02\x9b\x42\x34\xe2\x95\x46\xfc\x47\x23\x2e\x31\x62\x20\x5b\xc8\x88\xb7\x18\x8f\x1b\x49\xb6\x11\xbf\x60\xc4\x8c\x74\x94\x70\x9c\x4e\xb8\x83\x46\x4c\x7c\x10\x74\xc1\x2f\x90\xaf\x81\x51\x0f\xe8\x44\xff\xe2\xb4\xba\x96\x7e\x5f\xcb\x9a\x75\xa2\xfd\xcd\x52\x37\x32\xb9\x97\x27\xc8\x7a\x9d\x2f\x02\xba\x15\x28\x19\xd8\x63\xc3\x27\x6d\xf8\x76\x1b\xce\xb6\x61\x9b\xcd\x46\xc4\x5c\xfa\x13\xb6\x55\xd8\xde\xb4\xf1\x1d\xda\x49\x5c\xde\xe6\x51\x79\x4b\x69\xf4\xdb\xa3\x68\x94\x52\x8e\xdd\x9e\x41\x9e\x3a\xcf\x56\x0f\x7f\xc6\x83\xff\xac\x51\xbe\xc8\x33\xd6\x33\xcb\x73\xc0\x73\xcc\xf3\xa6\xc7\x90\x07\x35\x60\xc9\xc5\x9e\xf3\x1e\xfc\x8c\x07\xef\xf4\xe0\xf5\x1e\x3c\xd3\x83\xc7\x78\xda\x92\x2e\x91\x4f\x5c\x8e\xe7\x51\x39\x4e\xf3\x01\xeb\x1b\xfa\x1f\xd8\x31\xd4\x81\x3d\x0e\x9c\xed\xc0\xc8\x01\x75\x72\xa9\xc1\xe1\xe3\xa5\x5c\x2d\x69\xbc\xac\x56\x26\xd3\x69\x3d\x5a\xb4\xb4\x3d\x8f\xa2\x81\x8a\x13\x07\x86\x06\x4e\x05\x48\x4a\x00\x5f\x1f\xc0\xc1\xc0\xac\x00\x10\xf0\x4f\x4a\x4a\x20\x4b\x94\xfe\x7d\x9d\xea\x3c\x82\x73\x81\xff\x36\xb2\xf2\xdb\x92\xe4\xc4\x28\x25\x0b\x4b\xae\x32\xd7\x50\x17\xf7\xa0\xeb\xa4\x8b\x4c\x74\x6d\x75\xbd\xe4\x7a\xdb\xc5\x83\xe8\xf0\xb9\xa0\xb6\x5c\xb4\xb6\x7e\xa3\xb8\x5c\x2e\x1e\xf8\xd0\x05\x0d\xad\x0b\x6b\x5c\x6f\xbb\x92\x99\x7d\xa6\xde\xda\x99\x5c\xff\x86\x9f\xcd\xf2\xb1\x6b\x65\x20\x47\xa1\xe7\x9c\x45\xcf\x6b\xf2\x86\x30\x09\x85\x5c\x69\xb9\xe4\xdf\x32\xa2\x46\x8f\xe5\xea\x46\x5d\x6e\x38\x35\x58\xcb\x8e\x82\xdd\xe8\xc6\x29\xe7\x53\xf0\x33\x29\x78\x67\x0a\x5e\x9f\x82\xc7\xa4\x60\x67\x4a\x6b\x72\x9a\x6e\x05\xd0\x71\x32\x4b\xe7\xd2\xd2\xd5\x1d\x45\x21\xc5\x87\x83\xe7\x83\xf8\x99\x20\xde\x19\xc4\xeb\x83\x78\x66\x10\x8f\x09\x62\x67\x30\x9e\x54\x4f\x7b\x15\xa4\x1d\xc4\xd2\x7a\x74\x3a\x65\xa9\x6f\x53\xbf\x38\xf8\xea\x00\x1e\x1a\xc0\xee\x00\x46\x01\xa8\xc0\x5d\x8a\x27\x10\xa0\x22\x2b\x50\x11\xc0\xe1\x00\x9e\x15\x58\x16\x20\xb6\x40\xb2\xd0\x4a\x94\x63\x23\x94\x63\x24\x83\xe9\xd5\xf0\xf9\xe1\x1d\xe0\x60\x13\x71\x0f\x77\x63\xbf\x1b\x4b\x6e\x80\xf7\x81\x62\x71\xa7\x22\x5b\x2e\x49\xbf\x3d\x1d\x2f\x03\x5d\x74\x6d\x1c\x8a\x86\x57\x5c\xff\xe7\x51\xfd\x9f\x68\x07\x40\xd9\x4e\xdb\xc1\x1d\x36\x5c\x61\xc3\x61\xfa\xa0\x3d\x46\xba\xee\x7d\x84\xc1\xf2\xeb\x36\xd4\x33\x2d\x4f\xa2\x34\xc5\x71\x79\x8d\xd8\xc6\xe6\xc8\xa3\x36\x07\x4b\x17\x06\x1c\x06\x2a\xa9\xd8\x1f\xc2\x47\x42\xa7\x42\x64\x48\x68\x65\x88\xfc\x31\x84\xb7\x86\x70\x76\x08\xcf\xa2\xea\xeb\x9f\x8a\x3b\x14\x92\xa9\xf4\xb1\x85\xc2\xa1\x8a\xd0\xad\xa1\x03\x50\xfd\x22\x4a\x16\x63\xa5\xba\x6d\x07\xd6\xd6\x19\x71\x08\xc0\xa7\xe7\xe2\x8b\xfc\xdf\x51\x92\x8e\x13\x9e\xd4\x75\x9c\xc8\xff\x74\x0f\x42\xd6\xa7\x11\x6e\xd9\xd4\xa0\xa9\xb6\x82\xd2\xd6\x36\xce\xe2\x69\x6d\xfc\xa7\xb3\x7a\xbc\xed\x0d\x1e\x8f\xc1\x92\x88\xc7\xf8\x83\xc5\xd3\xf8\xe3\xa7\x17\xf5\x78\x99\xa0\xd2\xc1\xe4\x65\xf1\xc0\xa6\xa2\x67\x7e\x35\x88\xd7\x23\x07\xba\x52\xf1\x3a\xec\xb2\x11\x09\xd0\x99\x12\x44\x9b\xd1\x2e\xba\x9c\x36\x51\xe4\x1d\xa7\xf1\x68\x24\xe3\x51\x10\x99\x87\x6f\x82\xaf\xa2\xe3\xae\x74\xdc\xc6\x11\x69\x77\x26\xa3\x8b\x8e\x05\x45\x70\x2f\x57\x59\x44\xb2\x12\x09\x87\x4e\xde\xf7\xcc\x64\x7c\xe6\x8e\x34\xef\x69\x9f\xb1\x5f\xd5\x3c\x3c\xff\x2b\x3e\x4c\xc6\xab\x57\xc5\xf6\xec\xc4\xe4\xe3\xf7\x17\x3d\x76\x47\xb5\x1a\xa2\x78\x34\x7f\xc5\x9f\x46\xbc\x58\x0c\x7d\xba\x54\xc5\x2c\xf3\x82\x60\x92\xd1\xee\xa8\x2c\xec\x85\xbe\xa1\x36\xf2\xc7\xe0\x67\xf3\x52\xa8\x57\x4e\x56\x84\x87\x8e\xc7\xa9\x19\xdb\x56\xe3\xeb\xb0\xc5\x2f\x9c\x5a\xb9\xf9\xb9\x13\x9a\x0f\x86\x18\x7f\x9a\xf3\x33\x38\x69\x8a\x05\x3a\x2f\x74\x16\xc1\xb0\x3b\x8a\x92\x00\x69\x67\xfb\x07\x79\x5f\x28\x2f\xa7\x00\x73\x7e\x6c\xc6\x1b\x57\x6f\x9b\xa1\x9e\xfa\x2b\x20\x70\xe2\xb9\xcd\x2b\x29\x3e\xcd\xfc\x4b\x08\x09\x6f\x82\x7d\x0d\xf8\x48\x06\x03\xb2\x9a\xb8\xdd\x51\x93\x01\xc0\x9c\x2b\x88\x0f\x43\x38\xb4\x45\x7e\x52\x88\x8d\xea\xce\x3a\x36\x64\xda\xb5\x03\x9c\xb7\x05\x3f\x78\x66\xd5\x05\xbe\xc9\xd7\xd5\x57\x58\xbc\x7b\x83\x7e\x5e\x24\xe2\x5f\xe2\x04\x80\x67\x85\x1e\x9d\x45\x94\xac\x36\xc9\xa4\x30\x88\x7b\x69\x57\x5a\xf7\xcf\x4e\x9d\x03\xe8\x27\x42\x44\xac\xcc\x2f\x7c\xe5\x93\x83\xb7\x6e\x76\xef\x4d\x59\xf2\xd4\xda\xd1\x8f\x5f\x2d\xdc\xe3\xef\x56\x32\xb0\xfa\xda\xd2\x6c\x0f\x1d\x5f\x7b\x5f\x8d\x92\xef\x5a\xf6\x43\x3f\x2d\x4f\x31\x42\x9f\x9a\x76\xd4\x99\xbb\x3f\xf3\xc9\x69\x88\xd8\x09\xa1\x0e\x32\xdb\x2c\xc1\x2c\x75\x41\x2f\x09\xbf\x3f\xe6\xe5\x47\xd5\x68\x16\xce\xc9\x55\x3f\xa1\x70\x04\xfe\x18\xf7\xa9\xd0\x80\x4c\xa8\x8b\xe2\xe6\x88\x6c\x24\x46\xb3\x45\x86\x3e\xe7\xce\x69\x48\xdc\x15\x45\x7b\xe8\x49\x42\xc9\x0b\x95\x01\x52\x90\x8b\xe8\x88\x12\x52\xa7\xde\x2d\x1f\x12\xae\x59\xb8\x60\xba\x70\x48\xe6\x8f\x61\x7e\xd4\xb0\x61\xa3\xd4\x66\x36\x06\xf8\x3e\xbf\x9d\x7c\xc7\xfa\x92\x59\xad\x38\x0a\x60\xb0\x9b\x9f\x9a\x26\xec\xd1\xdd\x22\x77\x44\x8f\xdf\x1e\x47\x8f\xc1\xf8\x35\xf9\x4e\x44\x1a\x0c\x00\x00\x60\xf4\x72\x3e\x35\x8d\xec\x6d\x07\xc3\xc3\x85\x4a\x5d\xe4\x3b\x80\x21\xa2\x2c\xf5\x83\x5c\x1c\x64\xf4\x5f\xa1\x4e\xe1\x06\x41\xbf\xdc\x4e\xcb\x68\x13\xcd\xd0\xe1\x77\x38\x6d\xd6\xb1\x51\x9b\x8d\x93\xc7\x46\xb9\x00\x6a\xe3\xbf\x88\x0e\x75\x09\xda\x82\x24\xed\x3c\x3e\xe6\x0f\x6a\xd0\x27\xe7\xc7\x1c\xea\x71\xc7\xba\x4d\x37\xab\x0b\xc8\x88\xb4\x5f\xff\x21\xd5\xb1\x33\x7b\xeb\x2a\xee\xe5\x5d\x0c\xcf\x5c\x32\x8a\xbc\xca\xce\xea\x19\xaa\xa4\x58\xcc\x66\x22\x82\x09\x41\x88\xcd\x2e\x89\x9f\x45\x91\x84\x65\x4e\x92\x38\x63\x23\x76\x9c\x34\x63\x84\xe1\x51\x23\x76\x26\x7c\x5d\x45\xc2\x6d\xd6\xcb\xc6\xbb\xf7\x11\x87\x15\x87\x4a\x29\x9d\x1d\x11\x0f\x1e\xbe\xdd\xbd\xb0\x47\xf1\xfc\xc0\x9a\x3a\x32\x6a\x11\xc1\xf9\xbd\x57\x55\x94\xc6\x96\x2f\x82\xf2\x5d\x22\xa3\x38\x5e\x18\x87\x52\xd1\x18\x25\x2d\x25\xc5\xe5\x92\x24\x94\x66\xb6\x58\x90\xdf\x8f\x6c\x66\x6c\xe5\xcc\x66\xbb\x5d\xfe\x2c\x6a\x6f\xc4\xae\x93\xd8\x8f\xfc\x6d\xb3\x4f\xac\x74\xc3\xe1\x08\x3b\xf6\x5d\x77\x50\x15\xa6\x93\xa3\x03\x30\x5d\x20\x56\x12\x6a\x3d\x26\xcc\x2d\x01\xd7\x67\x79\x2e\x05\x16\x4d\x1d\x3f\x64\x69\xff\x72\xc3\x66\xcb\x8e\xa5\xab\xd7\x1c\x58\x31\xc2\x81\xd7\x93\x51\x95\x03\x6a\x07\xf5\x9f\x55\xba\x66\x40\x7f\xa1\xba\x6e\xd9\xbc\x2d\xab\xa3\x43\xf3\x17\x69\xed\xe0\x6b\x52\x4e\xbe\x05\x3c\xbb\xa0\x9d\xca\x40\x5b\x2e\xb6\xf3\x81\xb4\xb4\x6c\x8f\xc3\x23\x22\x8b\x64\xe9\x26\xe6\xda\x1d\x0e\xfb\x67\xd1\xdd\x0e\x3c\xc6\x31\xd3\xb1\xd4\xc1\xd9\x1c\x99\x8e\x30\x04\x36\x3a\x76\x3b\x44\xd9\xe1\xe0\x32\x41\x03\x59\xb9\x40\x20\x33\x13\xca\x90\x49\x37\xb0\x1b\x39\xe3\x67\xd1\xb1\xf4\x08\x55\xe8\x06\xbb\x13\x87\xa8\x26\xca\x44\x3d\xb0\xcf\x98\x7e\x6d\x2d\x1b\x03\xc3\xfe\xb0\xb3\x4f\x44\xf7\xb3\x52\x1c\x8e\x20\x88\x10\xef\x34\xeb\xc7\x30\x94\x96\x14\x00\xe1\xe3\xcb\xf6\x12\x65\x16\x25\x4f\x06\x26\xdf\xde\xbc\x6a\xd1\x8d\xb6\x1b\xe5\x2b\x8a\x7a\x5d\x79\x7b\xd7\xdc\x41\x4a\xaf\xae\x3d\xae\x14\xb7\x5b\x6e\x58\xb0\x64\xdd\xc0\xc1\xe3\x47\x70\xa9\x73\xd7\x2e\x9b\x63\xe9\xd7\xbf\xdf\x15\xab\x97\xf4\xb9\xb2\xb4\xb8\xa2\x8f\x79\x4e\x6d\xcd\x35\x57\x4e\x4a\x25\xce\x39\x6c\x0c\xfb\x65\x32\x82\x2b\x05\x3e\x31\x22\x1b\x1a\xa1\xe4\xc8\xb2\x01\x63\xab\x48\x88\xc3\xc2\x23\xde\xc2\x7f\x16\x35\x08\x9a\x8b\xf9\xfb\x2d\xa7\x2d\x82\xc5\x82\x4d\xe2\x33\xd8\x01\x0c\xc6\x66\xbc\xe8\x78\xb9\x36\x4a\x42\x4f\x45\x4c\x78\xae\x09\x53\xde\x0f\x95\xd2\x11\x4d\xe0\x14\x4e\xe4\xb2\x1c\xe4\xd7\x1b\xd5\x9b\xf0\x82\x5b\xd6\xfe\x2b\xfb\x4b\x2c\x93\x6f\x1e\x78\xa0\x0a\xff\xa4\x9a\xe7\xe2\x77\x23\xea\x69\x7c\x05\xe3\x59\x9e\x0c\x21\x4d\x80\x4b\x2a\x9a\xae\xe4\x78\x3d\x76\xbb\xd3\xe1\x80\xfe\xb9\x8b\x2e\xb5\x4e\x73\x78\x3f\x8f\x3a\x1c\x7e\xbf\xe5\xb3\xa8\xdf\xef\xe4\x9c\x9e\xcf\xa3\x4e\xca\xbe\x1c\x30\x92\x28\xc6\x89\xdd\xe6\xcc\x1b\xd4\xce\x07\x6e\x62\x68\x84\xad\x71\xd1\x4f\x72\xa1\x54\xa5\x0e\x66\xb3\x24\x3a\xb3\x41\x9a\xb6\xac\x7c\x3f\xb4\xcd\xd4\xa7\x78\x45\x5d\x97\x62\xcf\xf5\x59\xf8\x11\xf5\x45\x57\xc9\xf8\x65\xeb\xb8\x81\x6b\xb7\x9c\xb6\xf5\x0a\xef\xbd\x31\x23\x03\x9f\xbc\xf6\x42\xf9\x75\x8c\x87\x9a\x81\xd7\x39\x36\x07\x5a\xa8\x38\x40\x55\xc8\x06\x10\xf7\x66\x0b\x92\x8d\xf2\xe7\x51\x23\x25\x15\x8f\x9d\x28\x31\xe8\xaf\xb5\x67\xd6\x9c\xac\xc4\x13\x2a\x71\xd2\x33\x03\x39\x6e\xfd\xf4\x82\x6d\xd7\xde\xa9\xae\x25\x12\xff\xc9\x63\x8d\xcf\xd6\x1e\xc2\xe9\xaf\x5c\x4b\xc7\xb1\xb0\x83\x28\x9c\x08\x3c\x6a\x42\x1e\xd4\x1d\x2d\x51\x8a\xbb\x65\x64\xa1\x7c\x31\x2b\x2b\xdf\xeb\x48\x33\x7b\xd3\xbc\x3d\x0a\xbb\x65\x64\xc8\x56\xd9\xfa\x59\x74\xa6\xbc\x54\x26\x36\x39\x53\x0e\xcb\x1c\xfc\xc9\x39\x29\x39\xdc\x67\xd1\x1c\x60\xcb\x86\x14\xd7\x67\xd1\x14\x46\xa3\x24\x0a\xcd\xd4\x8e\x03\x41\x7d\x1c\x1d\xfd\x3a\xb3\xb3\x2d\x92\xd6\xc5\xbb\x4a\x58\x90\x4a\x59\x7d\xad\x5b\x59\x69\x62\x36\x88\x31\xe3\xa2\xc2\x48\xef\x2e\x91\xc2\x70\x4f\xcf\xca\xbe\x7d\xe0\xff\x86\xeb\xd6\xaf\xbd\x7e\xcd\xdc\x75\x0b\x6b\xd6\x54\x5f\xd9\x87\xdf\xd4\xaf\x67\x79\x71\xef\xbe\x25\xea\x17\x9b\x06\x5c\xb9\xb5\x5c\x59\x5c\xb7\x7c\xc9\x9e\x3c\xae\xe7\xc6\xe8\xe2\x85\xd7\x6c\x2a\xe4\x5c\x53\x99\xce\x14\xd4\xd3\x2d\xe7\x5a\xe8\x39\x0d\xb6\x06\x0e\xf1\x6c\xaf\x98\xe6\xa9\x86\x8e\x4e\x36\xfd\x56\x3d\xfd\xfc\xf3\x74\x0c\xb7\x42\x18\xd6\xf2\xbd\xb8\x13\x39\xe9\xb8\x2b\x9d\x99\x47\x46\xa3\x28\xba\xe8\x3e\x35\x1b\x0a\x9f\x2d\xb6\xbf\x92\x38\xdb\x82\xe9\x58\x5a\x14\x29\x1f\xd0\x65\x6d\x27\x04\x72\xe4\x54\xa4\xdb\xb0\x21\x99\x53\x17\x7e\x3b\x6e\xda\xb2\xc1\x45\xc2\xc5\xcc\x6c\x7f\x55\xc6\xed\xe5\x93\x4c\xee\xa9\x5c\x06\xab\xdb\xdd\xa0\x29\xe7\xb2\x33\x76\xba\x2b\x5e\xaa\x36\x05\x41\x3f\x60\xc7\x86\x78\xfd\x80\x9d\x84\xcc\x4a\x3a\xb5\x03\x98\x49\x3b\x59\x87\x7c\x85\xd7\x37\x77\xc3\x0f\xaa\x2f\xe0\x1f\x76\xed\xda\xc5\x65\x50\xd9\xcc\xa9\x7f\x12\x9e\xc2\x05\x52\x81\xee\xdb\xa3\x44\xf1\x1a\x64\x1e\x71\x9c\xc4\xf3\x66\xd9\x84\x14\x01\x04\xf2\xad\xd3\x78\x10\x89\x43\x50\x45\xb1\xee\x82\xfc\x6c\x71\xfc\xa0\x3c\xa7\xb6\x64\x93\xae\x4c\x8d\x78\x72\x21\x97\x1b\x0f\xc6\x1e\x3d\x88\xef\xa6\xa7\x5e\x09\x4f\x35\xc2\xe7\xd2\x46\xa4\xe7\xf3\x10\xcb\x87\xee\xfb\xb2\xa0\x3e\x4a\x0a\xb4\x31\x8e\xe7\x8d\xa2\x2c\x5b\x8c\x46\xab\x49\x12\x25\xc8\x87\x87\xae\x25\xcb\x2a\x72\x56\x5f\xd8\x94\xc8\x28\xbe\xf5\x2a\xe2\x11\x42\xa5\x3e\x3d\xcb\x01\x17\xd5\xa6\xcd\xdf\xd1\x3c\xa5\x02\xf3\xa3\xc6\x3f\xd1\x1c\xb5\xfc\xce\x43\x7e\x11\xc8\xcf\x80\xcc\xa0\xdb\x86\x2a\x41\x9e\x33\x18\x44\xc8\x54\x36\x9b\x2d\x92\x28\xda\x2d\x16\x87\xd5\x28\x1b\x21\x53\x78\x8e\x2d\xb2\x9e\x6d\x71\x9f\xa4\xb5\xf9\xad\xeb\xd3\xf4\x01\x6e\xc8\x5d\x0a\xe5\x97\x46\x7c\xf1\x32\xdf\x75\xcf\x9b\x67\x7e\x7f\xcf\x9d\xdb\x35\x14\x8c\x8f\x3f\x6a\xae\x54\x3f\xd2\xb0\xe8\xa4\xcc\x46\x8b\x45\x24\xd4\xae\xe0\x65\x51\xd4\xcb\x4c\x88\x70\x99\x32\xb7\x9a\x8f\x9e\x50\x6e\x29\x9b\xe3\xa0\x59\xce\xdf\xac\x36\x5d\xfc\xf6\x20\xb6\x1d\x14\xaf\x33\x3e\x6a\x56\x37\xe8\x85\x26\xea\xdf\x84\xdf\x60\x97\x5e\x97\x3d\xc0\x62\x01\xcb\x80\x17\x78\x83\xc4\xef\x8e\x4a\xf4\xfc\xa0\x5b\xa7\x69\xf5\xa8\x9d\x1e\xa2\x59\x6b\x71\xa7\x6a\x11\x0f\x6d\xfd\x53\x0e\xbe\xca\xaa\xee\x37\x8d\x8d\xdf\x6f\x64\x30\x5f\x14\xce\xe0\x0a\x06\x33\x00\xd6\x7e\x10\x61\xb3\xcf\xef\x4f\x33\x99\xcd\x69\x7e\xbb\xdd\xb0\x2b\x6a\xb7\xbb\x39\xde\xbd\x2b\xca\x81\x55\xca\x99\xf9\x46\x3c\x94\x16\xa4\x20\x49\xee\xb5\x6e\x0e\x61\xed\x98\xca\x98\x6c\xcd\x27\x7d\x88\x4e\xa9\xfb\xbc\xba\x59\x87\x5d\x34\xeb\xbd\x91\x89\x93\x72\x7a\xf4\x30\x4c\x33\x15\x8c\xac\x28\x9b\x30\x21\xbb\xa8\x40\xbc\xc6\xdc\x6d\x84\xf8\xd8\x46\xf5\xae\xbc\xdc\x50\x97\xf1\xc3\xba\xe4\xe6\xe5\xe5\x8e\xbb\x8a\xcd\xd1\xaa\x65\xfc\x73\xf8\x77\xc2\xf5\xc0\xbb\x01\xc5\x84\x4c\x66\xa8\x4d\x64\x14\xa9\xf5\x13\x89\x9c\x2b\x66\x13\x1e\x6c\xf1\x68\x88\x9e\x9e\xc5\x2e\xfc\xbb\xa9\x5d\xc2\x7f\x0c\xb3\x6b\xaa\x70\xfd\x99\xb9\xf0\x39\xc3\xda\xfb\xe7\xfc\x31\x72\x46\xf8\x9e\xb5\x31\x0f\xd8\xb6\x1c\x21\x46\x49\xdb\x84\x08\xa4\xd4\x0d\xbe\xf8\x3a\xfe\x78\x2d\x69\x36\x1f\x5d\x1b\x15\x21\x78\xa2\x7a\xaf\xe9\x90\xf9\xf4\x69\xf3\x21\x13\xd8\x7b\xca\xab\xaf\xaa\xcf\xb3\x7a\x79\x87\xd5\x0b\xe5\x83\xae\x74\x36\x05\xb3\x59\x07\x09\x6c\x20\x83\x41\xd8\x24\x1d\x40\x15\xa9\x67\x23\x8e\x3e\x61\xcd\x7e\x8e\x73\x3a\xab\x75\x4a\xaf\x4d\xb4\xc6\x71\x6f\x4a\x1e\xad\xca\x1f\xdf\xa8\xd7\x77\x2b\xdc\x7c\xc5\xc1\xd1\x39\x45\x83\x41\x36\xf2\xbc\x28\xe2\x4d\x72\x3b\xb0\x74\x0d\x63\xbc\xfd\xd0\x63\x4c\xf3\x68\xdb\xd9\x43\x4f\xa8\x63\x6d\x27\xbf\x6d\x7d\xfb\x50\x3a\x2a\x57\x52\xc0\x08\xf1\xa7\xa4\x18\x5c\x6e\x77\x06\x10\x24\xc3\xcd\x83\xb9\x94\x96\x62\x37\x20\x56\xd1\xc5\xc5\x20\x0a\xe8\x89\xe5\x49\x75\x1c\xc7\xbe\xd3\x3a\xe6\x68\xfb\x29\xdd\x78\x99\x3a\xbe\xeb\xe2\x17\x9b\x85\x33\x6d\x2b\x19\xcf\x37\x6f\x31\x42\x5b\xd2\xf0\x9a\xa0\xcd\x1f\xd1\xf6\x2c\x40\x4b\x12\xb1\x1d\x10\x0c\xda\xec\xf6\x60\x9a\xd9\xed\x06\xeb\x0d\x9a\xb2\xb4\x1b\xc4\xa5\xdd\xa0\x71\xe2\x07\xd3\x8b\x19\x17\x38\xdb\x61\x99\xf0\x5a\x4c\xcf\xf3\x0b\x95\xe2\xce\x39\xb2\xe0\xa0\xfa\xf7\x83\xf8\xe1\xcb\xa0\x2b\x4d\xa0\x2d\x4f\x5d\xd6\x8e\x2b\x49\x4b\x54\x38\x8c\xaf\x16\x9f\x61\x7e\x2d\x4b\x94\x54\x99\x4e\x15\x49\x26\x44\x8d\x5e\xbc\x3b\x0a\x86\xaf\x94\x29\x85\x25\x90\xb1\x8d\x78\x30\x74\x9b\xa6\xd3\x66\x8f\x23\x49\x6b\x61\xc1\x54\x87\xe6\x4e\xab\x2a\xb8\x7d\x7b\xd1\xbb\xe7\xd5\x93\x62\xfe\x4d\xea\x3f\xdc\x18\xa7\xff\x0b\xea\xe8\x04\xc0\x1f\x21\xfe\x04\xf0\xa9\x54\x49\x45\xc0\x4e\x32\x96\x25\xb3\x59\xb2\x22\x85\x53\x64\xcb\x30\x8e\x33\x49\x9b\x8c\x02\x83\x4f\x27\xea\x8a\xc3\x05\xa9\xe7\xf4\xf6\x9e\xa8\x21\xc8\xc4\xc5\x84\x59\xa4\x2c\xe2\x19\xb4\x7d\x7b\xfe\xd9\xaf\xe7\x7f\x49\xde\x5f\x20\x2e\xb9\x49\x3d\xfa\x9d\x67\xc7\x0e\x4f\x07\xfd\x10\x51\x3c\x06\x19\xf1\x92\x64\x86\x16\x41\x5d\x98\x63\x45\x42\xcf\x1b\x75\xe1\x99\xfa\x41\x71\xaa\xde\xe6\x92\x5b\x7c\x9c\xc6\xd4\x9b\x21\xa3\x28\xe9\x4f\x59\x59\x2a\x60\xe4\xdb\xbe\xb1\x8d\x7e\x73\xa0\x21\x4a\x8e\x80\x78\x83\x85\x07\xab\xc1\xe9\xe2\x4c\x66\xd3\xd8\x28\x82\xb2\xd9\xed\xb6\xb1\x51\xbb\x0d\xe4\x99\x61\x6c\x54\x4a\xd6\x76\x6c\x25\x4f\xfb\x95\xcd\xd4\x11\x8c\x43\xd3\x7e\x6c\xb5\x2e\xd5\x80\x7f\xfa\x93\xa6\x03\xbf\xfa\x8a\x6a\x41\xb2\x60\x9b\xfa\xc8\xae\x5d\x78\xf2\x36\x3c\x70\x17\x1d\x1b\xb8\xbe\xe5\x1b\xfe\x56\xa9\xc4\x99\xc7\xcd\xa6\xa7\xa8\xc9\x57\xfd\x80\x1c\x92\x74\x00\xcb\x78\x3e\x4a\x39\x49\xf2\x1d\x79\x3c\x47\x1a\x5b\x3e\x6a\xe8\xd2\x55\xb0\xd1\x91\x82\xd2\x52\x54\xa0\x8f\xf3\x74\x9e\xf6\x01\x9c\xf5\x1f\xa7\x7d\x1c\x35\xff\xc7\x69\x9f\xc0\x96\x5f\x9c\x36\x9f\xbc\x4a\x06\x21\x56\x62\xa4\x42\xea\x3c\xc5\xc6\x73\x7d\xe8\xe1\x24\x7d\x48\x5e\x02\x4c\xd7\x9e\x49\x60\x1c\xf0\xfb\x33\x70\x1e\x40\x2d\x71\x38\x25\x14\x4e\xc9\x7f\x08\xe7\x71\xf4\x97\xff\x13\x38\x4f\xfc\x42\x38\xb7\x03\x9c\xe9\x0c\xce\x42\x8d\xb6\xaf\x68\xd4\xf9\x80\xd1\x16\x3b\x1c\x79\x1c\xc1\x8d\x2d\x27\x1b\x9c\x2e\xab\xd8\x8e\xb6\x9d\xa7\x7d\x00\xc5\xfe\xe3\xb4\x8f\xa3\xf7\xfe\xe3\xb4\x4f\xa0\xaf\x7e\x71\x5a\x4a\xb7\x3c\x9d\x1f\xde\xd5\xe8\xc6\x91\x10\xa5\x5b\x08\xdb\x75\x30\x0f\x36\xb8\x02\x49\x60\x3a\xa5\x5b\x2b\x9c\x07\xd0\x67\xff\x27\x70\x1e\x47\x67\xff\x4f\xe0\x3c\x81\x2e\xfe\x22\x38\x07\x01\xce\x20\x06\x67\xa5\x46\xdb\xaf\x34\xea\x68\xed\x14\x7b\xf5\xc4\x3f\x34\xf8\xfc\x12\x6a\x47\xdb\xce\xd3\x3e\x80\xd3\xfe\xe3\xb4\x8f\xa3\x4b\xff\x71\xda\x27\xb0\xe7\x17\xa7\xa5\x74\x1b\xaf\xf1\x03\x36\xc4\xe9\xd6\x85\xd2\xad\x0b\xf6\x24\xc0\xf8\x83\x49\x60\x3a\xa5\x5b\x2b\x9c\x07\x70\xee\xff\x09\x9c\xc7\xe3\x72\xe6\x7f\x09\xe7\x09\xcc\xff\x22\x38\x4c\x67\x49\x19\xce\x3c\x34\x92\xa6\x47\x2b\xd1\x2a\xbc\x10\xb9\x14\x13\x71\x91\x3c\x52\x65\x73\xf2\x84\x8d\x27\x17\xe8\x63\x9d\xfb\xd5\x29\x7c\xa9\x10\x45\x59\xa8\xbf\x12\xf4\x3b\x9d\x2e\x9e\x2e\xf2\xe4\x5c\x5c\x76\xc8\x1f\x08\x58\x66\x46\x03\xbc\x87\x73\x39\x11\x5d\xf9\xae\xef\xf1\xe8\xb0\x42\x2f\x7e\xe4\x53\x99\x36\xfa\x46\xbb\x92\x56\x76\x56\x16\xd8\xa0\x9e\x08\xeb\x02\x3b\xec\x84\x6c\x99\x79\xa8\x7c\xe3\xd4\x85\x9b\x16\x56\xad\x1e\x7d\xdb\xe4\xd3\x7c\xa3\xc4\xaf\x68\x3a\xf5\xf8\x9f\xd4\x29\x57\x5d\xb5\xbc\xe6\x4f\xff\x4d\x76\xfc\xee\xd1\xc5\xc7\xaa\x9a\x5f\xe0\x0d\xb8\xff\xdd\xa3\x9a\x9a\x5a\x62\xd7\xa8\x2f\xaa\x9a\x0f\x58\xba\x2f\xa5\x9b\x30\x98\xed\x6a\x4f\x77\x5b\x1d\x0e\xa7\xcf\xec\x01\x7d\x2f\x38\xf9\xd4\x80\xdf\xea\xe2\x3c\x4e\x27\x67\x98\x19\xe5\xd2\x12\xde\xbf\xdb\xa2\x18\xd1\x07\x09\xd9\x18\xe1\x00\xdc\x9f\x6e\xfb\x4c\x9c\x9a\xcd\x77\xdb\xb0\x76\xfc\x15\x25\x5d\x7a\xf4\xf4\xc4\xce\xd9\x1f\xf9\x88\xd8\x9d\x8f\xdd\x70\xc7\x2d\xd6\xbb\x4c\x69\x57\x4c\x98\xc1\x2f\x3c\x36\xba\x79\xaf\x30\xb8\xe9\xbd\x5b\x37\x73\x6e\x9d\x6e\x50\x5f\x94\x6e\xd9\x60\x1b\x84\xd2\xbc\x5e\x1f\xf4\xdf\x7c\x16\x30\x51\x43\x39\x69\x99\x99\x8e\x99\xd1\x4c\xde\xe7\xe3\x52\x38\xba\xbe\x5b\x92\x38\x57\x7c\xf0\x05\x8c\xbe\x8a\x76\x87\x3c\xc7\x17\x39\x26\x1d\x2e\xda\x1f\x6b\x44\x4c\xc7\xc9\x44\xe4\x4b\xff\x71\xf1\xe4\xfb\xdd\x8f\xfb\xaf\x5f\xba\x79\x6f\x5b\x22\x92\xf1\xea\x05\xf5\xcc\x8e\xbb\x32\xa6\x4c\xfa\xe1\xa3\x7f\x31\x3a\x3e\x8e\x57\xea\x64\xa4\x36\xf4\x59\xb4\x10\x17\x83\xac\x31\x21\x2f\x0a\x9e\x72\xd2\x41\x55\x9f\x4d\xfe\x35\x2e\x47\x60\x51\xe1\xfe\x48\x77\x97\x1e\x29\x6e\x7b\xae\x7c\x9b\x53\xc4\x71\xf1\xfe\x3b\xef\xb8\xe7\xf6\x03\xf7\xde\x7e\xdb\xc8\x09\x93\x47\x8d\x1e\xff\x2b\xfc\xf5\xb3\x67\x5e\x38\xfd\xe2\x73\x2f\x9c\xde\xb1\xe9\xfa\x9b\xb7\x6e\xd7\xc6\xf5\xaf\x46\x1b\xd0\x11\xae\x0a\x89\x28\xa8\xc8\x48\x14\x89\x44\x08\xe6\x9f\x81\xbc\x10\xee\x47\x87\xc5\xe2\xe6\x7f\xcf\x22\xb6\x6d\x2e\xe2\xc8\x7c\xf5\xcd\x8d\x1b\x48\x74\xf5\xce\x35\xb1\x54\x6d\x0d\xda\x87\x68\x03\xce\x01\x7c\xd3\xd0\x18\x25\xdd\x62\xb5\xe2\x80\xe4\x76\xa7\xa7\x82\xb5\x29\x39\x90\x45\xb1\x3a\x87\x41\x67\xd9\x61\xfc\x3c\xea\x68\xc4\xe5\x27\x71\x2a\x4a\xfd\x9c\x0e\x92\xf6\x6b\x3b\x48\x5a\x40\xfb\x92\x09\x33\x56\xeb\x57\xe6\xc6\xc7\x48\xdb\x0d\x18\xb2\x51\x52\xf5\xc3\x9c\xb5\x73\xae\x19\x3c\xa4\x7f\xdf\x09\x86\x1b\x4c\xf7\xae\xd9\x52\x3f\x71\xdc\xda\x49\x1e\x7c\xe7\x86\x81\x43\xd6\x0f\x51\x26\x74\xef\xd5\xbb\x57\x69\xfa\xd5\x8b\x96\xcd\x19\xbc\xb2\xd7\xb8\xc1\x39\x35\x14\xd7\x37\x81\xb6\x45\x80\x6b\x08\xad\x51\x22\xfe\x14\x77\x66\x66\x96\x2d\x85\x47\xc0\x11\x39\x66\x84\x72\xb2\xec\x36\xbb\xed\xb3\xa8\xcd\x9e\x69\x0f\xdb\x39\x23\x67\xb7\x73\x69\x7e\xc5\xe6\x1c\x06\x9d\xd6\x34\xef\xe7\xd1\x34\x28\x41\x03\x27\x7f\x1e\x95\x1a\x5b\x9e\x3f\x01\x25\x63\x63\xa3\xfd\x19\xc7\xb4\x8e\x8d\x16\x24\xce\xa6\xa4\x03\x52\x1d\x9c\x1b\xc4\x07\x45\xbd\xfa\x98\x68\x19\xfb\xa5\x63\x3a\xf1\x51\x60\x8f\x17\x17\xdd\x7d\xdb\x96\x83\xd6\x3d\xce\x5d\xc3\xc6\x3f\x53\x61\x8d\x4c\x19\xb5\x73\x9b\x79\x27\x94\x72\xeb\x9e\x27\x5e\xc5\x23\xe6\xad\x5d\x32\x23\x75\x99\x52\xbe\x70\x51\xb8\xe7\xdc\xd9\xb6\x69\x35\xcb\x66\x6c\xcf\x22\xcc\x3f\x35\xf4\xc1\xa0\x3e\xae\x80\x3a\xa5\xdb\x58\xfb\x29\x7e\x9b\x20\x38\xec\x22\xf4\x15\x31\x1d\xc1\xb3\xf1\x9f\x47\x0d\x36\x1b\xa1\x63\x9f\xe5\x6c\x83\xba\x36\xf6\x19\xe9\x30\x74\xc0\xba\x90\x89\x81\x4f\x1b\x16\xa5\xc8\x9b\x75\x6a\x35\xbe\xe5\xfa\x6b\xbf\xc9\x39\x6e\xf1\x37\xe3\xb4\xfb\xef\x9f\x88\x7f\x50\xbb\x5d\x8b\x8f\x96\x7e\xec\xa1\x73\x27\xea\x79\xa0\x6f\x4f\x6e\x1a\xf4\xfe\x66\x2b\x41\x9f\xdb\x4d\x4f\x57\x77\x79\x5d\x48\x14\x84\x0c\x20\x70\x86\xd3\x66\x03\x59\xc5\xb9\xdd\xbe\xcf\xa3\xee\x46\xdc\x97\x11\x53\xd4\x89\xc9\xc6\x3e\x93\x89\xa9\x99\xe6\x11\x47\x87\xae\x57\x2b\x21\x83\x89\xc1\xe5\xbc\xd6\xe1\x4f\x46\x47\xdc\xf3\xf0\x0e\xb5\xa5\xe7\x1e\xf7\x98\x01\x23\xa7\x0c\x1f\x5b\x31\x2e\xb8\x22\x1d\xc7\xd4\x5a\x47\x68\x62\xc5\xe6\x3b\xf0\xda\x0d\x7b\x7e\xe7\x2f\x2f\x9d\x30\x74\xe0\xf8\x2e\x19\xf8\xce\x15\x4f\xa6\x85\xb6\x6b\xf4\xbb\x80\x16\xe0\xae\xc0\x23\x74\xcf\xfe\x08\x25\xe8\x48\x4f\x37\x9b\x4c\x22\x12\x43\x3e\x84\x42\xa9\x8e\x03\xee\x63\x6e\xe2\x76\x73\x56\xf9\x7e\x33\x36\x9b\x59\xc3\x0c\x26\x1a\x66\x78\xba\x43\x1f\x4a\x4e\xac\xab\xa7\x03\xe2\xed\x9a\xaa\x7e\xd2\x36\xc3\xb3\xcd\xd9\xff\x5d\xef\xdd\x72\xc7\x7d\x47\xf6\xbe\x54\xb6\x3d\x6d\xc6\xe8\x69\xbe\x59\xc3\x56\xd6\xd7\x0f\x19\x37\x70\xd8\xf0\x21\x83\x47\xe3\xa5\xab\x76\xff\xe6\xf8\xab\xaf\xef\x4b\x19\xb9\x6e\x43\x76\xcf\x4d\xeb\x46\x0c\xbc\x6a\xd0\xe0\xd1\xa3\xb5\x36\xb8\x1e\x87\xb8\x6b\xa0\xce\x8b\x14\x27\xf4\xe4\x0d\xc8\x60\x92\x10\x88\x10\x83\x6c\xf8\x3c\x2a\x3f\x83\xfb\x22\x9e\xd5\x75\xf2\x90\x8a\x3e\x7a\x2b\x26\x46\x6f\x71\xe8\xfe\x0d\x7b\x37\x1d\x56\x07\x93\x21\xa4\xf9\x51\xf5\x9d\xc7\xef\xc0\xa1\xc6\xa5\x74\x2c\xea\x82\xde\x6e\x52\x80\x26\x3d\xd0\x64\x25\x94\x61\x49\x75\xb9\xbc\xb2\x85\x47\x5d\x45\xb1\x30\x84\x50\xa1\x57\xce\xca\xcb\xca\xfb\x2c\x9a\x95\x05\xcd\x26\x8d\x4d\x89\x40\x5b\x29\xf8\x2c\xaa\x55\x6a\xfb\x23\xdc\x2f\xdb\x30\xe8\xe6\xba\xb6\x5e\x0c\x32\x30\x07\xcd\x83\x51\xc8\xa7\x13\x8b\xd2\xaa\xe8\xbe\xdd\xbb\xf7\xcf\x1a\x3b\x62\xcc\x9d\xd7\x6d\xbc\x7b\xdc\xc8\x71\x95\x87\x6e\xbe\x69\xf0\xe0\x9b\x9c\xe3\x46\x0c\x1f\x7b\xdf\xe8\xab\xf0\x95\x0b\x96\x2e\x9b\x37\xac\xda\x4c\x6c\x33\x06\x4c\x5e\xbc\x30\xda\x7f\x86\x95\x98\x66\x63\xf7\x82\x05\xbd\xfa\x5c\xec\x5b\xae\x94\x5d\xaf\xb0\xfa\x7e\x07\xea\xbb\x1b\x94\xcd\x8f\x72\xd0\x04\xa5\x8b\x2b\x33\x53\xb4\x98\x41\xe8\x8a\xb9\x29\x08\xe5\x7a\xc7\xa4\xcd\x4c\x5b\x9a\x76\x34\xed\x74\x9a\x90\x96\xc6\xd9\xe5\x4d\x96\x5b\x2d\xc4\x62\x81\x7a\xef\x0f\xc4\xe0\xa0\xf6\xdb\xd4\x7b\x32\x71\xf5\x62\x25\x39\x28\x89\x73\x2b\xdb\x85\x9f\xec\xc5\x40\x7d\xe7\xde\x2d\x7b\xef\xbf\xeb\xe0\xdc\x1b\xd3\xb6\xdb\x46\x17\xc4\xeb\x7e\xe4\x08\xad\xee\xc9\x9c\x55\xbb\x7f\xdd\xf0\xdb\xd7\x26\x8c\x4a\xe9\x9a\xbf\x9a\xd6\xfe\x86\xf1\xca\xc8\x21\x83\xaf\xba\x4a\xe3\xd9\x09\xd0\xa7\x7f\x5c\x4a\x45\x02\x9b\xfb\xc8\xb5\x59\xe9\xe1\x22\x92\x64\x32\x9b\xed\x6c\x5c\x07\xdb\x8d\x36\x6b\xa6\x95\x58\x0d\x3c\x8f\x69\x17\x1f\x9b\x0d\x5a\xf7\xfe\xa5\x82\x3e\x61\xfb\xb9\xd6\x01\xa9\x4e\x46\x2c\x4b\x7d\x1e\x36\xf6\x55\xea\x8a\xbc\xfd\xee\xc5\x59\x75\x0b\xde\x27\x1f\xcd\xff\xe4\xac\x94\x6a\x3e\x66\x3c\xea\x7e\xf8\x61\x37\xb6\x52\x1c\x26\x01\x0e\x8f\xe9\x38\x0c\x55\x42\x14\x07\x8a\x00\xa0\x61\x67\x63\x56\x60\x57\xf0\x34\x6b\x5e\x47\x25\x8e\x01\x64\x4e\x91\xa0\x43\xe3\xc5\xed\xf3\xe7\x3c\x74\x88\x01\x27\xf2\x5f\x30\xeb\xe2\xbb\xe4\x3a\x1d\x01\x71\xbe\xf1\x98\x59\xbd\x3f\x8e\x01\xc5\x61\x3d\xe0\xb0\x15\x70\xb0\xb3\x19\xbb\xdc\xd4\x14\x90\x34\x2e\xa7\xd3\xeb\xf3\x05\x40\x33\x09\x02\x92\xe5\x80\x27\xc5\xb5\xc9\x66\xb5\x12\x89\x22\x23\x79\x5d\x71\x3a\x14\x83\x14\x4c\x8d\x9f\x24\x9d\x38\xaa\xb6\x15\x17\x5c\xd2\x3a\xee\x4e\x97\x51\x17\x4b\x09\xb4\x70\x4a\x79\xa4\x8b\xbb\xef\xc0\xbb\x06\xf6\xea\x3f\xc2\x11\x47\xef\x78\xc8\xae\xb8\x67\x75\xef\xed\x1b\xfd\x76\x32\x8e\x2f\x02\x8e\x15\x80\xa3\x0f\xc4\xc6\x38\x25\x2f\x3d\xcd\xef\x4f\x0d\x66\x66\xba\xdc\xee\xac\x94\xd4\x54\xc9\x60\xc8\xf2\xa7\xd9\x0d\xa0\x4e\xd3\x90\x9b\x37\x53\x24\xcd\xa9\x41\x0d\xc9\xb3\x05\xc5\xc5\xda\x96\x86\xb8\x50\xec\x58\x63\x9d\x8e\x45\xd9\x70\x08\x94\x37\xd4\xe3\xe5\x06\xcf\x9e\xbd\xf3\x9e\xdf\x9f\x79\xf3\x1e\xf1\xea\xb6\xc3\x51\xcb\x06\x9a\x6f\xd9\x6d\xd4\xf0\x7e\x15\xf0\xee\xc3\xea\xd7\x85\xca\x14\x9f\x36\x02\x2f\xdb\x1d\x0e\xb7\x51\x96\xdd\xbc\x43\x96\xf1\xf3\x16\x51\x1f\x34\x3a\x0b\xc4\x7c\xa9\x93\x71\x3d\x8d\x9f\xa0\x21\xc4\xe7\xb9\xa1\x25\x5c\xfc\x70\x73\xf4\xfa\xc3\xce\x45\x8e\x85\x13\x27\xce\x77\x2c\xf2\x1e\x04\xce\xba\xcd\xf8\xe7\x6d\x75\x83\xca\x7a\x0f\x5c\x7d\x7d\x27\x79\x0b\x3c\x0f\x2c\x95\xc8\x9b\x40\xde\xc2\xbf\xcf\x9b\xf1\x92\xab\x4d\xde\xd7\x6c\xfe\xf0\x62\xb0\x4d\xde\xe2\x0d\xc6\xdb\xcc\xea\x8e\x44\xe6\xad\x79\x5b\x40\xab\x55\x28\x69\x56\x9f\x2f\xcd\x45\xb7\x40\x98\x32\x78\x8e\xcb\x48\x0b\x04\x24\x13\xc7\x49\x76\xcf\xf3\x12\x62\x08\x14\xa7\x6a\xc3\x9a\x8c\x83\xda\x08\x39\xe0\xe7\x36\xb9\x73\x49\x1c\x55\x80\x4b\x8b\x71\x1b\x4c\xaa\x74\x9e\xba\x6a\x78\x68\x84\x70\x38\x8e\x10\xb6\x32\xae\x2a\x2a\x29\x4b\xe6\x25\x13\xc8\xae\xc1\x0a\x20\x64\x90\x39\xd9\x1d\xcc\xca\xca\x05\x76\xca\x4d\x77\x9b\x65\xce\x0c\x7f\x59\x0e\xff\xf3\x62\x2b\x76\xc5\xf1\x6d\x31\x9d\x8c\x69\x32\xfa\xb0\xf1\x68\x2b\x2e\x63\x27\x4d\x6a\xac\xc4\xce\x85\x64\xc3\x9a\xd5\xdb\xac\x93\xd2\x6f\xda\x9e\x3e\xc9\x73\x7d\x4a\x68\xd0\x15\xfd\x03\xe3\x1c\xd3\x80\x83\x94\x9c\x21\x4a\x79\x2a\x65\x27\x53\xb7\x91\xc2\xe1\x85\xd3\x27\x4c\x98\x53\xf5\x3e\x28\xff\x7e\x57\xf4\x09\xc2\x4f\x66\xba\x52\x9e\xc9\x64\x15\xff\x24\x7e\x5c\xcc\x63\x72\xa2\xbf\x92\xd6\x41\x56\xd9\xb1\xc2\xf3\x46\xeb\x26\xb3\x61\x8f\x36\xfc\xd8\x27\xcc\x46\x1f\x3b\x4a\x87\x9f\x93\x4e\x62\x5e\xb2\x74\x6a\x9f\x6f\x85\x92\x2e\x89\x26\x93\x0c\x42\x01\x18\x48\x97\x4f\xbc\x42\x40\x2a\x89\x9b\xac\x46\x3d\x63\xc7\x65\x73\xd6\xe4\x92\x8f\x6e\xcc\x60\x79\x2f\x02\xb9\xf4\xc7\xb3\x9f\xcc\xff\x88\xbc\xbf\x40\xa8\x03\xb1\x34\x41\xfd\x2f\x9a\x37\xcd\x77\x31\xe4\x7b\xbb\xb8\x02\x39\x50\x00\xea\x28\x18\x48\xf5\x78\xfc\x6e\x97\x8b\x4e\x84\xc4\x65\x52\x1a\x91\x40\x22\x79\x53\x37\xf9\xdd\x89\x32\x47\xce\xfe\x8f\x24\x91\x36\x03\xc8\xb5\x8a\x22\xeb\xc8\xfe\xa5\xa9\x43\xa2\xcf\x5f\x39\x7c\x5a\xb7\x52\xaf\x4e\x0d\xe1\xc7\xee\xae\xb1\xfe\x65\x45\x83\xe5\xbc\x19\xc4\xa9\xe1\x16\xa7\x4b\x23\xe0\x37\x5c\xfc\x0e\xc9\xd0\xb3\x1c\xae\x64\x63\x24\x08\x06\xe0\xec\xf4\x8c\x8c\x6c\x10\x46\x0e\xa7\x33\x5b\x44\xa9\x4e\x23\xd8\x16\xc6\x0c\xab\xd7\xc0\xef\x61\x13\x5d\xff\x4e\x0e\x71\x09\xda\x74\x3e\x3a\x5e\xa5\x53\x0b\x37\x5e\x46\x22\x09\x6f\xe9\x68\xce\xef\x30\x6f\x43\xd4\xe3\x80\xf3\x28\xf1\x7b\x76\x02\x4b\x99\x92\x62\xb5\xd9\x1c\x66\x33\x30\xbf\xec\x04\xcc\x9d\x32\xe7\x80\x3f\x9b\x48\x67\x5c\x8a\xcf\xea\xcc\xde\x41\x1e\x70\x49\x9c\xce\x81\x74\xf4\x08\x78\xeb\x49\xe7\x8a\xb4\x67\x9f\x49\x5f\xe1\x39\xfe\xf7\x77\xcf\xab\xaf\xf1\x4f\x3e\xb2\x63\xdf\xbe\x5d\x47\xf0\x70\xf7\xc5\xf4\x77\x3b\xe6\x0b\x95\x66\x76\x38\x92\xf2\xa5\x8d\xed\xdf\xe5\x9b\xdc\xc2\xb8\x5c\xe0\x22\x0f\xde\xfe\x94\x67\x45\xfa\x33\xcf\xa6\xad\x70\x9e\xdc\xa1\xbe\x76\xfe\x5d\xfe\xc9\x87\x6e\xd9\xb7\x6f\xe7\xc3\x78\xf8\xbb\xe9\x17\xdd\xf1\x7c\xa5\x02\xc8\x97\xca\xa0\x74\xd0\x13\x0e\x87\xd9\xe3\xa1\x39\x33\x29\x14\x48\x4d\x95\x39\xce\xea\x7a\x5e\xcb\x1b\xda\x78\x9f\xf6\x86\x73\xa2\x57\xd5\xa6\xdc\x1d\x38\x29\x99\x06\xe3\xa7\x27\x4d\x2b\x27\x68\xf1\x5e\x99\xbf\x2a\x63\x47\xf9\x24\x53\x97\x1a\x2e\x23\x41\x93\xef\x00\xb7\x10\xc5\x2d\x33\x18\x04\xac\x72\x40\xfe\x00\x62\x39\x69\x71\x11\x14\xb4\xfb\x75\xba\xb4\x17\x3f\x6d\xa6\x2e\x92\x71\xeb\x7c\x56\x25\x09\x3f\xf9\x32\xac\x93\x40\x75\x7d\x07\xd6\x41\x18\x2d\x14\x1e\x24\x4e\xf1\x5e\x7a\x96\xab\x62\x02\x66\xe7\x08\x11\x25\x6e\x93\x26\x1e\x53\xcf\x25\xaf\x7a\xd2\x6a\xe7\x00\xad\x12\xe1\x41\x56\x15\x90\x7e\x18\xc8\xdc\xef\xc5\x7b\xb4\xf4\xf1\xb5\x57\x2c\xfd\x90\x76\xe9\x5d\x8c\xab\x86\x51\x4e\x12\x0e\x33\x0e\x62\x6b\xd6\x84\xc3\xe4\x0e\xf1\x21\x68\x6f\x05\x8a\x43\x36\x70\x1c\x9b\xd4\x15\x45\x23\x2f\x6f\x12\x49\x62\xd2\xa5\xcd\xdc\x35\x9b\x07\x61\xad\xa9\x2c\x42\xee\x80\x46\xfd\xe5\x7c\xf5\x90\xf0\xb4\xfb\xe6\x9b\xdd\xdf\x75\x80\x89\xe8\xe6\x3c\x68\xba\x40\x7f\xa3\xc4\x6f\x12\xf1\x65\x61\x26\xe6\x6f\xf0\xaf\x0e\xa9\x6c\xf6\x46\x38\xfc\x1d\x05\x4a\xd7\xd3\xf4\x10\xde\x20\x53\xc5\x1b\xd8\xdc\x4d\xbe\x62\xd7\xa6\xf5\x0d\xb2\x40\x10\xd1\xe6\xf4\x87\xea\x73\xfa\xed\xf6\x5e\xd1\x59\x66\x7c\xea\x60\xec\xad\xc3\xc2\x1b\xda\xe4\x32\x6e\xf9\x52\x38\x42\x4e\x88\xf7\x83\x8d\x9d\xab\x58\x3d\x5e\x2f\x70\x48\x8a\x57\xb0\x6c\x72\xca\xba\x56\xa2\x53\x3f\xc9\x93\xa2\xda\x19\xc7\x6d\x55\x0f\xc6\x7f\xed\x36\x71\xec\xa8\x50\x6e\x9e\x69\xa9\x29\x3c\xbe\xa2\xfb\xc4\xb1\x57\x65\xe5\x76\x31\x2e\xb3\x57\x09\x47\x72\x7b\xe4\x86\x87\xcd\x9a\xdd\x8b\xfd\xde\x5c\x03\xf8\x07\x85\xc3\xd0\x16\xef\x65\xe7\x34\xf5\x54\xdc\x90\xa5\x49\x14\x91\x56\x61\xf4\x50\xc1\x4d\x09\x8d\x78\xae\xb8\xa3\x43\x19\xad\xee\x22\xec\x3b\xf8\x32\xd4\x60\xec\x65\xad\x1a\x3f\x4d\x7f\x8f\x5e\x48\xdb\x8b\x0b\x79\x1c\x17\xf7\x83\x6d\x10\x52\x2c\x3c\x18\x05\x9c\xc9\x6a\x33\xf2\x9b\x92\x4d\x81\xb6\x87\xad\xb7\x6a\x7f\x32\x77\xdb\x09\xe7\x0a\xc7\x92\x69\xd3\x16\x39\x56\x78\x1a\x84\xc3\x37\x2f\x2d\xed\xd7\xbf\xa4\x76\x3b\xc0\x9d\xc8\xbf\xc5\xad\x11\xc6\xb3\x73\x92\x8d\x18\xf1\x02\x26\xbb\xa3\xf8\x01\x7d\x51\x5e\x7c\x22\x7c\x0d\x9d\x08\xe3\xdf\xda\xa8\x8d\xb7\x86\x5b\xde\xe2\xf7\x8b\xd7\xdb\xf3\x04\xd3\x2a\xba\x87\xe5\x7b\xd5\xaf\xad\x19\x16\xdd\x68\x8a\x62\x25\xe9\x43\x99\x03\xa9\xec\x74\x8c\xe8\xce\x92\x9f\x94\xee\xe9\x21\xba\x90\xdc\xe7\xf2\x61\xbb\x4f\xf1\x2d\xf3\x71\xc8\x17\xf4\x15\x41\x70\xac\x6f\x16\xdc\x6e\xf2\xdd\xea\x3b\xe0\x3b\xe6\x7b\xde\xf7\xa6\xcf\xd2\xd8\xf2\x4a\x83\xcf\x67\x30\xe4\x16\x4c\xa7\xeb\x8b\x5b\xd7\x87\xb7\xcd\xd7\x21\x69\xf9\xa2\xde\x4a\xfe\x7f\x06\xb9\xd3\xb5\xfb\xdf\xb5\x4c\xe2\x8c\x28\x4b\xf1\x60\xde\x8e\x83\x76\x7c\x9f\xdd\x4e\x57\x2b\xdb\x67\xda\x71\x91\x3d\x79\x63\x4a\x27\x69\xbf\x68\x59\xc4\xd2\xba\x09\x5d\xf0\x1c\x8c\x2f\x75\x26\xd8\x56\x64\x63\xcb\x94\xb5\xa4\xda\xfa\x66\x75\x23\x5d\xb7\xeb\xcc\x33\x7c\xc2\x68\xf7\x65\x13\x42\xc5\x4a\x80\xee\x33\xc4\xfd\x1a\xfb\xe1\xfc\x7e\xd8\xdb\xaf\xba\xdf\xca\x7e\x9c\xd0\x0f\x97\xf4\xdb\xda\x0f\xda\xeb\xa8\x86\x7e\xfd\x90\x23\xb7\x40\x5f\x0a\x4e\x3f\xa8\x33\x58\xdf\x7e\x89\x40\x62\x78\x00\x52\x4e\x4a\x0e\xbe\x31\x07\x0b\x39\x83\x73\xc8\x9b\x39\x39\x7a\x62\x9a\x54\x4b\x77\xa8\x4d\xba\x6f\xa0\x85\xdb\x14\x19\x92\x5d\xd0\xe2\x3a\xb4\x78\xed\xf7\x7d\xfd\x9f\xed\x0d\x42\x22\x7a\x09\x70\x97\x5a\xfe\x06\x2d\xc7\x07\x52\x3d\xcc\xce\xe7\xc9\x55\x5c\xfd\xfa\x04\x50\x16\x56\xb2\x0e\x64\x91\x2c\x8f\x2c\xf7\xcf\xb7\x71\x88\x3a\x53\x06\xee\x3e\x3b\xfd\xda\xe2\xe2\xe2\x9e\x45\xbe\xa4\xde\x6e\xb2\x9b\x4e\xe9\x32\x2e\x3b\x3d\xc9\x71\xa0\x99\xbc\x54\x98\x9d\x5d\x58\x14\x0c\x16\x7d\x51\x18\x64\x81\xc2\xba\x30\xdc\x85\xb3\x82\x61\x52\x54\x98\x1d\x2c\x2a\x82\xc7\x85\xc1\xac\x30\x84\x0b\x5f\x5d\x3a\x5b\x8b\x1c\xce\x82\x87\x34\xe1\xd1\x20\xbc\x0c\x16\x15\xfe\x57\x76\x8f\x1e\x10\xa1\xf0\xa8\xfe\xae\x10\xd7\xa8\xcc\x6f\x12\x8f\x3e\x55\x37\x71\x5f\x42\xd9\x38\xe6\xe1\x29\x13\x05\x14\x90\x2c\x99\x28\x05\x2b\x29\x07\x52\x48\x4a\x86\x44\x77\x83\x42\x69\xfa\x84\xa1\x34\x59\x9e\xac\x9f\xc3\xf6\x53\x3c\x54\x7d\x9a\xcc\xed\x88\x57\xe9\xc2\x01\x9d\x63\xd0\x9a\xbf\x04\x7d\x19\x7a\x0a\x12\xcb\x3f\x88\xe8\x46\xb5\x03\xe9\x24\x3d\xcb\x94\x94\x3f\x2e\x65\xb3\xdf\x9e\x9f\xc3\x01\x8f\xab\xc1\x43\x17\xe2\x1b\x3b\x22\xa1\x7e\xb3\x62\xe1\xc2\x15\xc7\x3b\x45\x84\xa0\xba\x96\x6f\xf8\x72\x31\x00\x58\x14\x81\x28\x2b\x29\x24\xf9\x56\xce\xe3\xa6\xc2\x76\x00\x91\xb1\xd7\x97\x41\x3c\x6e\xba\x5c\xba\x90\x3a\xee\x23\x65\xb8\x34\x47\xf0\xe4\x71\xd7\xf5\x1c\x3c\x32\x75\xf8\x0d\xd5\xfd\x42\xc3\x97\x8e\x1a\xb7\x6c\x70\xa6\x5a\x8b\xc3\x53\x6d\x91\x31\x3d\x95\x75\x0d\xcb\x6b\x1b\x36\x5c\x39\x7c\xe3\xc3\xb3\xd4\x8b\xf8\x0e\x5c\xf8\x25\xbe\x30\xa9\x7e\xf9\xe4\x40\xea\xb8\xda\xdb\xa6\x8d\xdc\x32\xab\xac\xd7\xcc\x2d\xdc\x2b\xea\xb3\xb3\x1c\x7d\x6f\xb8\xbf\xb2\xe6\xe4\x96\x61\x83\x36\x9e\x5a\xbe\xec\xd8\xf6\xca\x2c\xdc\x77\xd5\x6f\x26\x6e\x9d\x40\x6b\x28\x03\xd7\x68\xde\x39\xe0\x33\x19\x3d\xa1\x87\x31\xb2\xe1\x5c\x3d\x4c\x90\x04\xd2\x55\x0b\x73\x28\x15\x6f\xd1\xc3\x3c\xc4\x79\x4e\x0f\x0b\xc8\x8a\xbf\xd1\xc3\x22\xb2\x92\x14\x3d\x2c\xa1\xb5\x60\xb5\x68\x61\x03\x72\x73\x67\xf4\xb0\x8c\xac\xdc\x4f\x7a\xd8\x88\x97\x8b\xdf\xea\x61\x13\x4a\x33\xdc\xa3\x87\xcd\xa8\x50\xf6\xea\x61\x0b\x2a\x95\x9f\xd4\xc3\x56\x94\x6a\x4c\x07\x4c\x30\x0f\x12\x87\xee\x25\xd0\xc3\x18\xca\x22\xe8\x61\x02\xf8\x94\xea\x61\x0e\x95\xe0\x51\x7a\x98\x87\x38\xfb\xf5\xb0\x80\xd2\xf0\x1b\x7a\x58\x84\x70\x93\x1e\x96\xd0\x8f\xa4\x8b\x1e\x36\xa0\x2e\xdc\x3e\x3d\x2c\xa3\x34\xee\x1d\x3d\x6c\x24\x7f\xe1\xe3\x79\x99\x50\x6f\x43\xa5\x1e\x36\xa3\x6b\x0c\x8d\x7a\xd8\x82\x16\xca\x83\xf5\xb0\x15\x95\xc8\x5f\xa0\x41\x68\x01\x9a\x07\x57\x1d\x5c\x6b\xd1\x5c\x34\x07\x05\xe1\xaa\x84\xfb\x4a\x08\x55\xa1\xa5\x68\x19\x5a\x83\x6a\x59\xac\xf9\xf0\x34\x88\xba\xc0\xd3\xae\xf0\x5b\x0c\x5c\xd3\x13\xae\x20\x1a\x0a\xb1\x96\xc2\xfb\xc5\x90\x3e\x88\x06\x42\xb8\x16\x52\xd1\xef\x4a\x06\x77\x29\xaa\x41\x85\xd0\x7b\x18\xf8\x6f\xa1\x15\x43\x68\xbc\x8e\xc5\x30\x96\xba\x3b\x84\x86\x43\xfa\x2a\x80\x80\x06\x2d\x98\xb7\xa0\x6e\xc1\xda\xb9\x73\x82\x73\x2a\xeb\x2a\x83\x55\x4b\x97\xad\xa9\x5d\x30\x6f\x7e\x5d\xb0\x4b\x55\xd7\x60\x71\x51\xcf\xa2\xe0\xd0\xa5\x4b\xe7\x2d\x9e\x1b\x1c\xb8\xb4\x76\xd9\xd2\xda\xca\xba\x05\x4b\x6b\x0a\x8d\x03\xdb\x47\x2b\x0e\x8e\x07\x10\xc3\x2a\xeb\xba\x07\x87\xd7\x54\x01\xdc\x91\x80\xd0\x6c\xc8\x36\x19\xe1\x20\x1a\xc5\x7e\x97\xc2\xeb\x05\xb3\xe7\x6a\xc0\x82\xa3\x96\xd6\xc0\x03\x8a\xe2\x3c\xb4\x02\x0a\x5c\x09\x69\xd0\xf8\xb9\xf3\x56\x2c\xae\x84\xc0\x15\x68\x39\x20\x3a\x17\x52\xcd\x61\xd0\x82\xa8\x07\x5c\xff\x06\xfa\x15\xcb\xab\xe6\xd6\xcc\x99\x5b\x1b\xec\x11\xec\x90\xd1\x2f\x45\x6c\x32\x8b\xbb\x3c\x11\xb3\x18\xa8\x56\x04\x7f\x85\x40\x5b\x34\x79\x6e\xed\x72\x1a\xb5\xb8\xb0\xa8\xa8\xb0\x67\xe7\xc0\x3b\x01\xfd\x73\x98\x2c\x80\xbc\x82\x8c\x53\xea\xd8\x1b\x5a\xec\x25\x8c\x28\x8b\xe0\xd9\x52\x54\xfd\xb3\xf5\x19\x84\x78\x73\x19\xf7\x2d\x87\x37\x73\xd9\xdd\x1c\x06\x95\xc2\x9e\x04\x31\x26\xb0\x58\x63\x59\x4a\x4a\xd6\x3a\x96\x5b\x0d\x8b\x35\xb1\x93\x1c\xc7\x40\x8e\xd5\x90\xbe\x8a\x71\x62\x3c\x66\x15\x83\x4d\x39\x5a\x83\xbc\x14\xc2\xf3\xf5\x0a\x5a\x08\xd5\x58\xcb\x30\x98\xc3\xd2\xc5\xcb\xb6\x9c\xf2\x5b\x12\x7d\x17\x2c\x0f\x56\x06\xeb\x6a\x2b\xe7\xcc\x5d\x52\x59\xbb\x28\xb8\xb4\xba\x2d\x0f\x05\x6b\xe7\xce\x5b\xb0\xbc\x6e\x6e\x2d\x3c\x5c\x50\x13\x9c\x54\x38\xa1\x30\x38\xb6\xb2\x6e\x6e\x4d\x5d\xb0\xb2\x66\x4e\x70\x62\x22\xe1\x98\xea\xea\x05\x55\x73\xd9\xc3\xaa\xb9\xb5\x75\x95\x10\x79\x69\xdd\x7c\xa8\xfd\x85\x2b\x6a\x17\x2c\x9f\xb3\xa0\x8a\xe6\xb6\xbc\xb0\x33\x5e\xea\xbc\x61\xb5\xf2\x4f\x12\xd3\x23\xa0\x1c\xa5\xd8\x4a\x46\x87\x51\x2c\x3a\xbd\x5f\xae\x25\x99\x50\x37\x77\xe5\xdc\xe0\xa8\xca\xba\xba\xb9\xcb\x69\xe4\x2b\x21\xc2\x72\x9d\xf8\x5a\xc5\xd2\xbc\x56\x30\x46\xaa\x81\xe7\xb4\xd2\x56\x01\xc9\x28\x81\xe6\xb3\x70\x25\xab\xf8\x39\x0c\x24\x6d\xcc\x35\x7a\xea\xd9\xd0\xbc\x83\x3f\x9b\x79\x50\x4f\x5b\xa9\x33\x50\x0d\xe3\xb7\x95\x7a\x89\x56\xea\xb9\x51\x56\xa8\x66\xdf\xcb\x59\xbe\x35\x90\x47\x10\xc2\x95\xac\x6a\x82\x0c\x5b\x5a\x6d\xd5\xed\xb0\x08\xb2\xaa\xad\x64\x8c\xa2\x31\xe7\x12\x78\x5b\xc7\xe2\x56\xc1\xf3\xc5\xf0\xb7\x46\x17\x6c\x4b\x80\x96\x5a\xae\xb3\x75\xd1\xb5\x8a\x09\xc2\xf9\x89\xf2\xd3\x54\x1a\xed\x47\xc3\xef\xaa\xac\x6c\xc6\x8e\x6d\x69\xa3\xb1\x79\xb5\xde\xf0\x82\xec\x58\xaa\x65\x10\x5e\xca\xca\x12\xa7\x68\x0f\x56\x9b\xb4\x3c\x73\x19\x96\x34\x54\xc9\x04\xed\x6c\x48\xb1\x98\xe5\xab\xe1\x35\x9f\x31\x73\x25\x63\xc5\xb9\x3a\x6b\xd6\x31\xec\x97\x27\xb1\xb4\xc6\xc0\x41\x56\x02\x0a\x7d\x30\xc3\x96\x8a\xd7\xb9\x3a\x65\xa7\x80\x58\x1e\xd9\x29\x44\x8d\x7a\xc9\x4d\x89\xd6\xcc\x62\x86\xef\xf2\x24\xd8\x35\x0c\xdb\x39\xec\xd9\xd2\x04\xa5\x69\xac\xc5\x7a\x4e\x5a\x89\x17\x33\xf1\xbf\x28\x51\x4b\xd5\x8c\x43\x35\x6a\xce\x61\xd0\x7a\x5c\x86\xde\xd5\x8c\x36\x75\x7a\xae\xff\x1f\x7b\x6f\x02\x27\x47\x51\xbf\x0f\x77\xdd\xd5\x9b\xcd\x1d\xc2\x61\x80\x10\x20\x5c\x21\x64\xbb\x6b\x66\x77\x39\x22\x7b\x74\x43\x42\x48\x80\x24\x10\x10\x81\xc9\xee\x64\x77\x60\x77\x67\xb3\x3b\x9b\x4b\x44\x44\x44\x44\x44\x40\x44\x44\x40\x40\x04\x44\x44\xe4\x16\x11\xb9\x09\x10\xee\xfb\x3e\xe4\x88\xdc\x42\xb8\xaf\xb7\xba\xfb\xd9\x9d\xce\x1e\x18\xfc\xe9\xef\xf5\xff\xbe\xff\xe4\xd3\xf5\xfd\x76\x75\x75\x3d\x55\xd5\xd5\xf5\x3c\xdf\xee\x99\xd9\x62\xdc\xa2\x66\xfb\x3f\xb9\xee\xc9\x0c\x2b\xda\x73\x7b\xe2\xab\x98\xdc\xfe\xc9\xfc\x2f\x0d\x18\xb9\x5c\x3c\xbe\x45\x9c\xd7\x19\xaf\xcd\x25\xb4\xa5\x3d\xb9\x9d\xeb\x73\xdd\xf6\xf6\xb4\x37\x73\x43\xb1\xa7\xbb\xd0\x91\x9f\x32\x71\x69\x6b\xa1\xa9\x75\xe2\xd2\x5c\xf7\xc4\xe6\x7c\x77\xa1\xa5\xc3\x1e\x5e\xb8\x7c\xe2\xda\xb7\xc7\x44\x7b\x34\x67\x17\x80\x8e\x8e\xe2\x12\x7b\x73\x2d\xb1\xa7\x75\xe5\x17\x75\xe5\xbb\x5b\x0b\x1d\x2d\x13\xbb\x73\x1d\xdd\x13\xbb\xf3\x5d\x85\x45\xa8\x62\x62\xa9\x35\x57\x8a\x96\x8b\xf6\x7c\xa9\xab\xd0\x94\x6b\x6b\x5b\x6e\x89\xaa\xbd\xd3\x9e\xba\xd0\x32\xd3\xd2\x42\xa9\x35\xc2\xef\x2a\xd8\x3b\x76\x76\x7e\xe9\x45\x53\x7b\x5b\x63\xd7\x94\x45\x76\x85\x9e\x58\x68\xef\xec\x2a\x2e\x89\x1b\xba\x7d\x77\x53\x57\x3e\xdf\x61\xf1\x72\xcd\xb9\x85\x85\xb6\x42\xc9\xd6\xd5\x9a\xeb\xca\x35\xd9\x95\xc6\x2e\x37\x85\xa6\xee\x78\x25\xb1\x0b\xc8\xc4\xce\x5c\xc7\xf6\x41\x4f\x57\xb1\x33\x6f\x1b\xbb\xdf\x6e\xb3\xca\x05\x6d\xf3\x92\x55\xa8\xbb\xd8\xb6\x24\xdf\x1d\x97\xee\xc8\xe7\x9b\xbb\xa3\x55\xac\xd9\x76\xb5\xcd\x9e\x64\x81\xdb\x8a\xc5\xc3\xa2\x2e\x2d\x2a\x76\xd9\x66\x36\x97\x5a\xb7\x4f\xb5\x7b\x51\xb1\xa3\x64\x4f\x2d\x4e\xcc\x35\x37\xdb\xbe\xdb\x01\x2b\x36\xf5\xb4\x47\xeb\x9b\x5d\x73\x4a\xbd\x8d\xcb\x35\x75\x15\xed\xb1\xce\xb6\x5c\xc9\xd6\xd2\x1e\xad\x63\xad\xf1\xdd\xdf\xe9\xec\x68\x83\x88\x1d\xec\x9c\x88\xfe\x4f\x8d\xd7\x80\xf4\xea\xd6\x84\xb5\x6d\x2a\x66\xca\x0e\xf6\xc4\x52\xa9\x73\xc7\x1d\x76\x58\xba\x74\xe9\xd4\x1c\x96\xb8\x26\xbb\xc2\x4d\xb5\x8d\xda\xe1\x5f\xaf\x36\x9a\x2c\x9d\xf1\xb4\x4e\x2f\x5d\x5d\xf1\x04\x89\xea\x6c\xb7\x13\xe7\x4b\xa1\x4b\xcb\x3b\xf3\x98\x2c\x5d\xdd\x53\x5b\x4b\xed\x6d\x09\x39\x26\xb0\xbd\xab\x68\x4f\x6a\xdd\xee\xbd\x9f\xe6\x5a\xe2\x9b\x15\x93\x54\x27\x56\x81\x10\xf3\x7f\x62\xbf\x1a\xa2\x15\xb0\x3f\x95\x57\x25\x24\x3e\xcb\xb2\x47\x47\x34\x8d\x7b\xe2\x35\x3f\xba\x96\x73\x67\xcc\x9a\x38\xa7\xd3\x4e\x93\xd0\x5e\xa3\x89\x28\x30\x65\x62\x2f\xdd\x57\x45\x5c\xbf\xf6\x70\x25\x6b\x51\xc1\xee\x97\xe2\x8e\x77\xc7\x77\xd2\xd4\x78\xb0\x5a\xec\xf1\x39\xb6\x65\xb3\xfa\x86\xc1\x4e\xc2\x42\x67\xa9\x7b\x6a\x77\xa1\x6d\x6a\xb1\xab\x65\x87\x39\xe1\xac\x44\x83\xc7\xff\x3e\xdf\x3c\xfa\xad\x97\x3e\xbd\xde\xf7\xcf\x5d\x10\xe7\x52\x27\xfa\xe6\x8b\xb0\x6a\x56\x39\xd1\xd7\x89\x2a\xac\x36\xad\xb4\x3a\x74\x84\x8d\xbd\x46\x39\xa3\x9d\x31\x36\xfa\x18\xe7\xac\xe7\x8c\xb7\x71\xe6\x06\xce\x86\xce\x46\x36\x22\x9b\xe0\x6c\xec\x6c\x62\x23\xa3\x89\xce\x66\xce\x24\x1b\x1f\x6d\xe1\x6c\xe9\x4c\x76\xb6\xb2\x5a\x71\x1b\x67\x5b\x67\x3b\x3b\x3c\xdb\xdb\xc6\xee\x00\xc5\xe8\x3b\xc6\xc9\x38\x59\xa7\xda\xa9\x71\x6a\x6d\x07\x77\x72\x76\x76\x76\x71\xa6\xdb\x78\x75\x57\x4b\xa2\xf5\x76\xb9\x6e\xb4\xcb\x63\x68\x97\xc3\xdd\xed\x05\x98\xe9\xec\x61\xbb\xb6\xa7\x5d\xd0\xe7\x58\x5d\xb1\xb7\x55\x27\x73\x6d\xfb\xe7\xdb\xe1\xde\xcf\x59\xe0\xec\xef\x1c\xe0\x7c\xc3\x39\xd0\xf9\xa6\x73\x90\x73\xb0\x73\x88\x93\x23\xd1\x5f\xfa\x39\xda\xf9\xbe\xf3\x17\xe7\x54\x67\xb5\x73\x8c\x73\x82\xf3\x23\xe7\x4c\xe7\xb7\xce\x79\x84\x39\xc7\x11\xee\x7c\xcf\xf9\xa9\xf3\x8e\xf3\xae\xf3\x63\xab\xf3\x8f\x25\xd2\x79\xc6\xf9\x87\x73\x96\x73\x91\xf3\x9e\xb3\xc6\x79\xdf\x39\xd7\xf9\xbd\x73\x87\x73\xbb\x8d\x61\x16\xda\x21\x3f\xd1\x4e\x89\xbb\xec\x65\x5d\xe9\xdc\xe9\xdc\xeb\xac\x72\xee\x76\xee\x71\xfe\x6e\x97\xa8\x07\x9d\xfb\x9c\xfb\x9d\x3f\xd8\xa1\x7f\xdb\x39\xc9\x79\xc4\x79\xc8\x79\xd8\x5e\xb0\xd7\x9c\x37\x9c\x1f\x5a\x7d\x52\xb0\x4b\x6b\x34\x2b\x3b\x9c\xb3\xed\x05\x5a\x1c\x93\x4b\xb7\x9d\x60\xa5\xe8\xf3\x62\xce\xab\xce\x32\xab\xdb\x97\x3b\xdf\x72\xbe\xed\x1c\xee\x5c\xe3\x9c\xe3\x7c\xc7\x39\xc2\x39\xd2\xf9\xae\xf3\xba\xf3\xa6\x73\x2d\x51\x44\x13\x97\x54\x90\x61\xa4\xd2\xf9\xcc\xf9\x9c\x0c\x27\x23\xc8\x48\x32\xca\xf9\x82\x38\x64\x34\x19\x43\xc6\x12\x42\xc6\x91\xf5\xc8\x78\xb2\x3e\xd9\x80\x6c\x48\x36\x22\x5f\x23\x13\xc8\xc6\x64\x13\x1b\x10\x7f\xe8\x7c\x44\x26\x92\xcd\xc8\x24\xb2\x39\xd9\x82\x6c\x49\x26\x93\xad\xc8\xd6\x64\x1b\xb2\x2d\xd9\x8e\x4c\x21\xdb\x93\xa9\x64\x07\xe7\x63\xe7\x51\x32\x8d\x54\x11\x8f\xf8\xc4\x90\x0c\xc9\x92\x6a\x52\x43\x6a\xc9\x8e\x64\x27\xb2\x33\xd9\x85\x4c\x77\x5e\x70\xfe\x46\xbe\x4e\x76\x25\x75\xa4\x9e\x34\x90\x46\x12\x90\x90\xec\x46\x76\x27\x33\xc8\x4c\xb2\x07\x99\x65\xe3\xa0\x4b\x9d\x3f\x92\xd9\x64\x0e\xd9\x8b\xec\x4d\xf6\x21\x73\xc9\x3c\x32\x9f\xec\x4b\xf6\x73\x3e\x71\x3e\x75\x5e\x74\x5e\x22\x0b\xc8\xfe\xe4\x00\xf2\x0d\x72\x20\xf9\x26\x39\x88\x1c\x4c\x0e\x21\x39\xb2\x90\x34\x91\x66\x92\x27\x8b\x48\x0b\x69\x25\x05\x72\x28\x39\x8c\xb4\x91\x76\xe7\xcf\xa4\x83\x14\x49\x27\x59\xec\xbc\xec\xbc\x42\xba\x48\x37\x29\x91\x1e\xb2\x84\x2c\x25\xcb\xc8\x72\xb2\x82\x7c\x8b\x1c\x4e\xbe\x4d\x8e\x20\xdf\x21\x47\x92\xef\x92\xa3\xc8\xf7\xc8\xd1\xce\xf9\xe4\xfb\xe4\x18\xf2\x03\x72\x2c\xf9\x21\x39\x8e\xfc\x88\x1c\x4f\x7e\x4c\x4e\x20\x3f\x21\x27\x92\x93\xc8\xc9\xe4\xa7\xe4\x14\xf2\x33\x1b\xcc\xfe\x9c\x9c\x46\x7e\x41\x4e\x27\xbf\x24\x67\x90\x33\xc9\x59\xe4\x57\xe4\x6c\x72\x0e\x39\x97\xfc\x9a\x9c\x47\x7e\x43\xce\x27\x17\x90\x0b\xc9\x6f\xc9\x45\xe4\x77\xe4\x62\xf2\x7b\x72\x09\xf9\x03\xb9\x94\xfc\x91\x5c\x46\x2e\x27\x57\x90\x2b\xc9\x55\xe4\x6a\x72\x0d\xf9\x13\xb9\x96\xfc\x99\x5c\x47\xfe\x42\xae\x27\x7f\x25\x37\x90\x1b\xc9\x4d\xe4\x66\x72\x0b\xb9\x95\xdc\x46\x6e\x27\x2b\xc9\x1d\xe4\x4e\x72\x17\x59\x45\xee\x26\xf7\x90\x7b\xc9\x7d\xe4\x7e\xf2\x00\x79\x90\x3c\x44\x1e\x26\x8f\x90\x47\xc9\x63\xe4\x71\xf2\x04\x79\x92\x3c\x45\x9e\x26\xcf\x90\x67\xc9\x73\xe4\x79\xf2\x02\xf9\x1b\x79\x91\xbc\x44\x5e\x26\xaf\x90\xd5\xe4\xef\xe4\x55\xf2\x1a\x79\x9d\xbc\x41\xde\x24\x6f\x91\xb7\xc9\x3f\xc8\x3b\xe4\x5d\xb2\x86\xbc\x47\xde\x27\x1f\x90\x0f\xc9\x47\xe4\x63\xf2\x09\xf9\x94\x7c\x46\x3e\x27\x5f\x50\x87\x12\x4a\x29\xa3\x9c\x0a\x1a\x7d\xf0\x4b\x53\x97\x56\xd0\x61\xb4\x92\x0e\xa7\x23\xe8\x48\x3a\x8a\x8e\xa6\x63\xe8\x58\x3a\x8e\xae\x47\xc7\xd3\xf5\xe9\x06\x74\x43\xba\x11\xfd\x1a\x9d\x40\x37\xa6\x9b\xd0\x4d\xe9\x44\xba\x19\x9d\x44\x37\xa7\x5b\xd0\x2d\xe9\x64\xba\x15\xdd\x9a\x6e\x43\xb7\xa5\xdb\xd1\x29\x74\x7b\x3a\x95\xee\x40\xa7\xd1\x2a\xea\x51\x9f\x1a\x9a\xa1\x59\x5a\x4d\x6b\x68\x2d\xdd\x91\xee\x44\x77\xa6\xbb\xd0\xe9\xf4\xeb\x74\x57\x5a\x47\xeb\x69\x03\x6d\xa4\xd1\xe7\x4d\x76\xa3\xbb\xd3\x19\x74\x26\xdd\x83\xce\xa2\x7b\xd2\xd9\x74\x0e\xdd\x8b\xee\x4d\xf7\xa1\x73\xe9\x3c\x3a\x9f\xee\x4b\xf7\xa3\x0b\xe8\xfe\xf4\x00\xfa\x0d\x7a\x20\xfd\x26\x3d\x88\x1e\x4c\x0f\xa1\x39\xba\x90\x36\xd1\x66\x9a\xa7\x8b\x68\x0b\x6d\xa5\x05\x7a\x28\x3d\x8c\xb6\xd1\x76\xda\x41\x8b\xb4\x93\x2e\xa6\x5d\xb4\x9b\x96\x68\x0f\x5d\x42\x97\xd2\x65\x74\x39\x5d\x41\xbf\x45\x0f\xa7\xdf\xa6\x47\xd0\xef\xd0\x23\xe9\x77\xe9\x51\xf4\x7b\xf4\x68\xfa\x7d\x7a\x0c\xfd\x01\x3d\x96\xfe\x90\x1e\x47\x7f\x44\x8f\xa7\x3f\xa6\x27\xd0\x9f\xd0\x13\xe9\x49\xf4\x64\xfa\x53\x7a\x0a\xfd\x19\x3d\x95\xfe\x9c\x9e\x46\x7f\x41\x4f\xa7\xbf\xa4\x67\xd0\x33\xe9\x59\xf4\x57\xf4\x6c\x7a\x0e\x3d\x97\xfe\x9a\x9e\x47\x7f\x43\xcf\xa7\x17\xd0\x0b\xe9\x6f\xe9\x45\xf4\x77\xf4\x62\xfa\x7b\x7a\x09\xfd\x03\xbd\x94\xfe\x91\x5e\x46\x2f\xa7\x57\xd0\x2b\xe9\x55\xce\x63\xce\xf3\xf4\x6a\xe7\x09\x7a\x0d\xfd\x13\xbd\x96\xfe\x99\x5e\x47\xff\x42\xaf\xa7\x7f\xa5\x37\xd0\x1b\xe9\x4d\xf4\x66\x7a\x0b\xbd\xd5\x79\xd2\x79\xca\x79\xda\x79\xce\x79\xdc\x79\x96\xde\x46\x6f\xa7\x2b\xe9\x1d\xf4\x4e\x7a\x17\x5d\x45\xef\xa6\xf7\xd0\x7b\xe9\x7d\xf4\x7e\xfa\x00\x7d\x90\x3e\x44\x1f\xa6\x8f\xd0\x47\xe9\x63\xf4\x71\xfa\x04\x7d\x92\x3e\x45\x9f\xa6\xcf\xd0\x67\xe9\x73\xf4\x79\xfa\x02\xfd\x1b\x7d\x91\xbe\x44\x5f\xa6\xaf\xd0\xd5\xf4\xef\xf4\x55\xfa\x1a\x7d\x9d\xbe\x41\xdf\xa4\x6f\xd1\xb7\xe9\x3f\xe8\x3b\xf4\x5d\xba\x86\xbe\x47\xdf\xa7\x1f\xd0\x0f\xe9\x47\xf4\x63\xfa\x09\xfd\x94\x7e\x46\x3f\xa7\x5f\x30\x87\x11\x46\x19\x63\x9c\x09\x26\x59\xf4\x67\xd4\x5c\x56\xc1\x86\xb1\x4a\x36\x9c\x8d\x60\x23\xd9\x28\x36\x9a\x8d\x61\x63\xd9\x38\xb6\x1e\x1b\xcf\xd6\x67\x1b\xb0\x0d\xd9\x46\xec\x6b\x6c\x02\xdb\x98\x6d\xc2\x36\x65\x13\xd9\x66\x6c\x12\xdb\x9c\x6d\xc1\xb6\x64\x93\xd9\x56\x6c\x6b\xb6\x0d\xdb\x96\x6d\xc7\xa6\xb0\xed\xd9\x54\xb6\x03\x9b\xc6\xaa\x98\xc7\x7c\x66\x58\x86\x65\x59\x35\xab\x61\xb5\x6c\x47\xb6\x13\xdb\x99\xed\xc2\xa6\xb3\xaf\xb3\x5d\x59\x1d\xab\x67\x0d\xac\x91\x05\x2c\x64\xbb\xb1\xdd\xd9\x0c\x36\x93\xed\xc1\x66\xb1\x3d\xd9\x6c\x36\x87\xed\xc5\xf6\x66\xfb\xb0\xb9\x6c\x1e\x9b\xcf\xf6\x65\xfb\xb1\x05\x6c\x7f\x76\x00\xfb\x06\x3b\x90\x7d\x93\x1d\xc4\x0e\x66\x87\xb0\x1c\x5b\xc8\x9a\x58\x33\xcb\xb3\x45\xac\x85\xb5\xb2\x02\x3b\x94\x1d\xc6\xda\x9c\x0b\x59\x3b\xeb\x60\x45\xd6\xc9\x16\xb3\x2e\xd6\xcd\x4a\xac\x87\x2d\x61\x4b\xd9\x32\xb6\x9c\xad\x60\xdf\x62\x87\xb3\x6f\xb3\x23\xd8\x77\x9c\x5f\xb1\x23\xd9\x77\xd9\x51\xec\x7b\xec\x68\xf6\x7d\x76\x0c\xfb\x01\x3b\x96\xfd\x90\x1d\xc7\x7e\xc4\x8e\x67\x3f\x66\x27\xb0\x9f\xb0\x13\xd9\x49\xce\xcf\xd9\xc9\xec\xa7\xec\x14\xe7\x97\xec\x67\xec\x54\xf6\x73\x76\x1a\xfb\x05\x3b\x9d\xfd\x92\x9d\xc1\xce\x64\x67\xb1\x5f\xb1\xb3\xd9\x39\xec\x5c\xf6\x6b\x76\x1e\xfb\x0d\x3b\x9f\x5d\xc0\x2e\x64\xbf\x65\x17\xb1\xdf\xb1\x8b\xd9\xef\xd9\x25\xec\x0f\xec\x52\xf6\x47\x76\x19\xbb\x9c\x5d\xc1\xae\x64\x57\xb1\xab\xd9\x35\xec\x4f\xec\x5a\xf6\x67\x76\x1d\xfb\x0b\xbb\x9e\xfd\x95\xdd\xc0\x6e\x64\x37\xb1\x9b\xd9\x2d\xec\x56\x76\x1b\xbb\x9d\xad\x64\x77\xb0\x3b\xd9\x5d\x6c\x15\xbb\x9b\xdd\xc3\xee\x65\xf7\xb1\xfb\xd9\x03\xec\x41\xf6\x10\x7b\x98\x3d\xc2\x1e\x65\x8f\xb1\xc7\xd9\x13\xec\x49\xf6\x14\x7b\x9a\x3d\xc3\x9e\x65\xcf\xb1\xe7\xd9\x0b\xec\x6f\xec\x45\xf6\x12\x7b\x99\xbd\xc2\x56\xb3\xbf\xb3\x57\xd9\x6b\xec\x75\xf6\x06\x7b\x93\xbd\xc5\xde\x66\xff\x60\xef\xb0\x77\xd9\x1a\xf6\x1e\x7b\x9f\x7d\xc0\x3e\x64\x1f\xb1\x8f\xd9\x27\xec\x53\xf6\x19\xfb\x9c\x7d\xc1\x1d\x4e\x38\xe5\x8c\x73\x2e\xb8\xe4\x8a\x6b\xee\xf2\x0a\x3e\x8c\x57\xf2\xe1\x7c\x04\x1f\xc9\x47\xf1\xd1\x7c\x0c\x1f\xcb\xc7\xf1\xf5\xf8\x78\xbe\x3e\xdf\x80\x6f\x18\xfd\x9d\x06\x3e\x81\x6f\xcc\x37\xe1\x9b\xf2\x89\x7c\x33\x3e\x89\x6f\xce\xb7\xe0\x5b\xf2\xc9\x7c\x2b\xbe\x35\xdf\x86\x6f\xcb\xb7\xe3\x53\xf8\xf6\x7c\x2a\xdf\x81\x4f\xe3\x55\xdc\xe3\x3e\x37\x3c\xc3\xb3\xbc\x9a\xd7\xf0\x5a\xbe\x23\xdf\x89\xef\xcc\x77\xe1\xd3\xf9\xd7\xf9\xae\xbc\x8e\xd7\xf3\x06\xde\xc8\x03\x1e\xf2\xdd\xf8\xee\x7c\x06\x9f\xc9\xf7\xe0\xb3\xf8\x9e\x7c\x36\x9f\xc3\xf7\xe2\x7b\xf3\x7d\xf8\x5c\x3e\x8f\xcf\xe7\xfb\xf2\xfd\xf8\x02\xbe\x3f\x3f\x80\x7f\x83\x1f\xc8\xbf\xc9\x0f\xe2\x07\xf3\x43\x78\x8e\x2f\xe4\x4d\xbc\x99\xe7\xf9\x22\xde\xc2\x5b\x79\x81\x1f\xca\x0f\xe3\x6d\xbc\x9d\x77\xf0\x22\xef\xe4\x8b\x79\x17\xef\xe6\x25\xde\xc3\x97\xf0\xa5\x7c\x19\x5f\xce\x57\xf0\x6f\xf1\xc3\xf9\xb7\xf9\x11\xfc\x3b\xfc\x48\xfe\x5d\x7e\x14\xff\x1e\x3f\x9a\x7f\x9f\x1f\xc3\x7f\xc0\x8f\xe5\x3f\xe4\xc7\xf1\x1f\xf1\xe3\xf9\x8f\xf9\x09\xfc\x27\xfc\x44\x7e\x12\x3f\x99\xff\x94\x9f\xc2\x7f\xc6\x4f\xe5\x3f\xe7\xa7\xf1\x5f\xf0\xd3\xf9\x2f\xf9\x19\xfc\x4c\x7e\x16\xff\x15\x3f\x9b\x9f\xc3\xcf\xe5\xbf\xe6\xe7\xf1\xdf\xf0\xf3\xf9\x05\xfc\x42\xfe\x5b\x7e\x11\xff\x1d\xbf\x98\xff\x9e\x5f\xc2\xff\xc0\x2f\xe5\x7f\xe4\x97\xf1\xcb\xf9\x15\xfc\x4a\x7e\x15\xbf\x9a\x5f\xc3\xff\xc4\xaf\xe5\x7f\xe6\xd7\xf1\xbf\xf0\xeb\xf9\x5f\xf9\x0d\xfc\x46\x7e\x13\xbf\x99\xdf\xc2\x6f\xe5\xb7\xf1\xdb\xf9\x4a\x7e\x07\xbf\x93\xdf\xc5\x57\xf1\xbb\xf9\x3d\xfc\x5e\x7e\x1f\xbf\x9f\x3f\xc0\x1f\xe4\x0f\xf1\x87\xf9\x23\xfc\x51\xfe\x18\x7f\x9c\x3f\xc1\x9f\xe4\x4f\xf1\xa7\xf9\x33\xfc\x59\xfe\x1c\x7f\x9e\xbf\xc0\xff\xc6\x5f\xe4\x2f\xf1\x97\xf9\x2b\x7c\x35\xff\x3b\x7f\x95\xbf\xc6\x5f\xe7\x6f\xf0\x37\xf9\x5b\xfc\x6d\xfe\x0f\xfe\x0e\x7f\x97\xaf\xe1\xef\xf1\xf7\xf9\x07\xfc\x43\xfe\x11\xff\x98\x7f\xc2\x3f\xe5\x9f\xf1\xcf\xf9\x17\xc2\x11\x44\xd0\xe8\x57\x33\x85\x10\x52\x28\xa1\x85\x2b\x2a\xc4\x30\x51\x29\x86\x8b\x11\x62\xa4\x18\x25\x46\x8b\x31\x62\xac\x18\x27\xd6\x13\xe3\xc5\xfa\x62\x03\xb1\xa1\xd8\x48\x7c\x4d\x4c\x10\x1b\x8b\x4d\xc4\xa6\x62\xa2\xd8\x4c\x4c\x12\x9b\x8b\x2d\xc4\x96\x62\xb2\xd8\x4a\x6c\x2d\xb6\x11\xdb\x8a\xed\xc4\x14\xb1\xbd\x98\x2a\x76\x10\xd3\x44\x95\xf0\x84\x2f\x8c\xc8\x88\xac\xa8\x16\x35\xa2\x56\xec\x28\x76\x12\x3b\x8b\x5d\xc4\x74\xf1\x75\xb1\xab\xa8\x13\xf5\xa2\x41\x34\x8a\x40\x84\x62\x37\xb1\xbb\x98\x21\x66\x8a\x3d\xc4\x2c\xb1\xa7\x98\x2d\xe6\x88\xbd\xc4\xde\x62\x1f\x31\x57\xcc\x13\xf3\xc5\xbe\x62\x3f\xb1\x40\xec\x2f\x0e\x10\xdf\x10\x07\x8a\x6f\x8a\x83\xc4\xc1\xe2\x10\x91\x13\x0b\x45\x93\x68\x16\x79\xb1\x48\xb4\x88\x56\x51\x10\x87\x8a\xc3\x44\x9b\x68\x17\x1d\xa2\x28\x3a\xc5\x62\xd1\x25\xba\x45\x49\xf4\x88\x25\x62\xa9\x58\x26\x96\x8b\x15\xe2\x5b\xe2\x70\xf1\x6d\x71\x84\xf8\x8e\x38\x52\x7c\x57\x1c\x25\xbe\x27\x8e\x16\xdf\x17\xc7\x88\x1f\x88\x63\xc5\x0f\xc5\x71\xe2\x47\xe2\x78\xf1\x63\x71\x82\xf8\x89\x38\x51\x9c\x24\x4e\x16\x3f\x15\xa7\x88\x9f\x89\x53\xc5\xcf\xc5\x69\xe2\x17\xe2\x74\xf1\x4b\x71\x86\x38\x53\x9c\x25\x7e\x25\xce\x16\xe7\x88\x73\xc5\xaf\xc5\x79\xe2\x37\xe2\x7c\x71\x81\xb8\x50\xfc\x56\x5c\x24\x7e\x27\x2e\x16\xbf\x17\x97\x88\x3f\x88\x4b\xc5\x1f\xc5\x65\xe2\x72\x71\x85\xb8\x52\x5c\x25\xae\x16\xd7\x88\x3f\x89\x6b\xc5\x9f\xc5\x75\xe2\x2f\xe2\x7a\xf1\x57\x71\x83\xb8\x51\xdc\x24\x6e\x16\xb7\x88\x5b\xc5\x6d\xe2\x76\xb1\x52\xdc\x21\xee\x14\x77\x89\x55\xe2\x6e\x71\x8f\xb8\x57\xdc\x27\xee\x17\x0f\x88\x07\xc5\x43\xe2\x61\xf1\x88\x78\x54\x3c\x26\x1e\x17\x4f\x88\x27\xc5\x53\xe2\x69\xf1\x8c\x78\x56\x3c\x27\x9e\x17\x2f\x88\xbf\x89\x17\xc5\x4b\xe2\x65\xf1\x8a\x58\x2d\xfe\x2e\x5e\x15\xaf\x89\xd7\xc5\x1b\xe2\x4d\xf1\x96\x78\x5b\xfc\x43\xbc\x23\xde\x15\x6b\xc4\x7b\xe2\x7d\xf1\x81\xf8\x50\x7c\x24\x3e\x16\x9f\x88\x4f\xc5\x67\xe2\x73\xf1\x85\x74\x24\x91\x54\x32\xc9\xa5\x90\x52\x2a\xa9\xa5\x2b\x2b\xe4\x30\x59\x29\x87\xcb\x11\x72\xa4\x1c\x25\x47\xcb\x31\x72\xac\x1c\x27\xd7\x93\xe3\xe5\xfa\x72\x03\xb9\xa1\xdc\x48\x7e\x4d\x4e\x90\x1b\xcb\x4d\xe4\xa6\x72\xa2\xdc\x4c\x4e\x92\x9b\xcb\x2d\xe4\x96\x72\xb2\xdc\x4a\x6e\x2d\xb7\x91\xdb\xca\xed\xe4\x14\xb9\xbd\x9c\x2a\x77\x90\xd3\x64\x95\xf4\xa4\x2f\x8d\xcc\xc8\xac\xac\x96\x35\xb2\x56\xee\x28\x77\x92\x3b\xcb\x5d\xe4\x74\xf9\x75\xb9\xab\xac\x93\xf5\xb2\x41\x36\xca\x40\x86\x72\x37\xb9\xbb\x9c\x21\x67\xca\x3d\xe4\x2c\xb9\xa7\x9c\x2d\xe7\xc8\xbd\xe4\xde\x72\x1f\x39\x57\xce\x93\xf3\xe5\xbe\x72\x3f\xb9\x40\xee\x2f\x0f\x90\xdf\x90\x07\xca\x6f\xca\x83\xe4\xc1\xf2\x10\x99\x93\x0b\x65\x93\x6c\x96\x79\xb9\x48\xb6\xc8\x56\x59\x90\x87\xca\xc3\x64\x9b\x6c\x97\x1d\xb2\x28\x3b\xe5\x62\xd9\x25\xbb\x65\x49\xf6\xc8\x25\x72\xa9\x5c\x26\x97\xcb\x15\xf2\x5b\xf2\x70\xf9\x6d\x79\x84\xfc\x8e\x3c\x52\x7e\x57\x1e\x25\xbf\x27\x8f\x96\xdf\x97\xc7\xc8\x1f\xc8\x63\xe5\x0f\xe5\x71\xf2\x47\xf2\x78\xf9\x63\x79\x82\xfc\x89\x3c\x51\x9e\x24\x4f\x96\x3f\x95\xa7\xc8\x9f\xc9\x53\xe5\xcf\xe5\x69\xf2\x17\xf2\x74\xf9\x4b\x79\x86\x3c\x53\x9e\x25\x7f\x25\xcf\x96\xe7\xc8\x73\xe5\xaf\xe5\x79\xf2\x37\xf2\x7c\x79\x81\xbc\x50\xfe\x56\x5e\x24\x7f\x27\x2f\x96\xbf\x97\x97\xc8\x3f\xc8\x4b\xe5\x1f\xe5\x65\xf2\x72\x79\x85\xbc\x52\x5e\x25\xaf\x96\xd7\xc8\x3f\xc9\x6b\xe5\x9f\xe5\x75\xf2\x2f\xf2\x7a\xf9\x57\x79\x83\xbc\x51\xde\x24\x6f\x96\xb7\xc8\x5b\xe5\x6d\xf2\x76\xb9\x52\xde\x21\xef\x94\x77\xc9\x55\xf2\x6e\x79\x8f\xbc\x57\xde\x27\xef\x97\x0f\xc8\x07\xe5\x43\xf2\x61\xf9\x88\x7c\x54\x3e\x26\x1f\x97\x4f\xc8\x27\xe5\x53\xf2\x69\xf9\x8c\x7c\x56\x3e\x27\x9f\x97\x2f\xc8\xbf\xc9\x17\xe5\x4b\xf2\x65\xf9\x8a\x5c\x2d\xff\x2e\x5f\x95\xaf\xc9\xd7\xe5\x1b\xf2\x4d\xf9\x96\x7c\x5b\xfe\x43\xbe\x23\xdf\x95\x6b\xe4\x7b\xf2\x7d\xf9\x81\xfc\x50\x7e\x24\x3f\x96\x9f\xc8\x4f\xe5\x67\xf2\x73\xf9\x85\x72\x14\x51\x34\xfa\x86\xa9\x12\x4a\x2a\xa5\xb4\x72\x55\x85\x1a\xa6\x2a\xd5\x70\x35\x42\x8d\x54\xa3\xd4\x68\x35\x46\x8d\x55\xe3\xd4\x7a\x6a\xbc\x5a\x5f\x6d\xa0\x36\x54\x1b\xa9\xaf\xa9\x09\x6a\x63\xb5\x89\xda\x54\x4d\x54\x9b\xa9\x49\x6a\x73\xb5\x85\xda\x52\x4d\x56\x5b\xa9\xad\xd5\x36\x6a\x5b\xb5\x9d\x9a\xa2\xb6\x57\x53\xd5\x0e\x6a\x9a\xaa\x52\x9e\xf2\x95\x51\x19\x95\x55\xd5\xaa\x46\xd5\xaa\x1d\xd5\x4e\x6a\x67\xb5\x8b\x9a\xae\xbe\xae\x76\x55\x75\xaa\x5e\x35\xa8\x46\x15\xa8\x50\xed\xa6\x76\x57\x33\xd4\x4c\xb5\x87\x9a\xa5\xf6\x54\xb3\xd5\x1c\xb5\x97\xda\x5b\xed\xa3\xe6\xaa\x79\x6a\xbe\xda\x57\xed\xa7\x16\xa8\xfd\xd5\x01\xea\x1b\xea\x40\xf5\x4d\x75\x90\x3a\x58\x1d\xa2\x72\x6a\xa1\x6a\x52\xcd\x2a\xaf\x16\xa9\x16\xd5\xaa\x0a\xea\x50\x75\x98\x6a\x53\xed\xaa\x43\x15\x55\xa7\x5a\xac\xba\x54\xb7\x2a\xa9\x1e\xb5\x44\x2d\x55\xcb\xd4\x72\xb5\x42\x7d\x4b\x1d\xae\xbe\xad\x8e\x50\xdf\x51\x47\xaa\xef\xaa\xa3\xd4\xf7\xd4\xd1\xea\xfb\xea\x18\xf5\x03\x75\xac\xfa\xa1\x3a\x4e\xfd\x48\x1d\xaf\x7e\xac\x4e\x50\x3f\x51\x27\xaa\x93\xd4\xc9\xea\xa7\xea\x14\xf5\x33\x75\xaa\xfa\xb9\x3a\x4d\xfd\x42\x9d\xae\x7e\xa9\xce\x50\x67\xaa\xb3\xd4\xaf\xd4\xd9\xea\x1c\x75\xae\xfa\xb5\x3a\x4f\xfd\x46\x9d\xaf\x2e\x50\x17\xaa\xdf\xaa\x8b\xd4\xef\xd4\xc5\xea\xf7\xea\x12\xf5\x07\x75\xa9\xfa\xa3\xba\x4c\x5d\xae\xae\x50\x57\xaa\xab\xd4\xd5\xea\x1a\xf5\x27\x75\xad\xfa\xb3\xba\x4e\xfd\x45\x5d\xaf\xfe\xaa\x6e\x50\x37\xaa\x9b\xd4\xcd\xea\x16\x75\xab\xba\x4d\xdd\xae\x56\xaa\x3b\xd4\x9d\xea\x2e\xb5\x4a\xdd\xad\xee\x51\xf7\xaa\xfb\xd4\xfd\xea\x01\xf5\xa0\x7a\x48\x3d\xac\x1e\x51\x8f\xaa\xc7\xd4\xe3\xea\x09\xf5\xa4\x7a\x4a\x3d\xad\x9e\x51\xcf\xaa\xe7\xd4\xf3\xea\x05\xf5\x37\xf5\xa2\x7a\x49\xbd\xac\x5e\x51\xab\xd5\xdf\xd5\xab\xea\x35\xf5\xba\x7a\x43\xbd\xa9\xde\x52\x6f\xab\x7f\xa8\x77\xd4\xbb\xce\x65\xce\xe5\x6a\x8d\x7a\xcf\xb9\xca\xb9\xda\xb9\x45\xbd\xef\x5c\xe1\x5c\xe9\xdc\xaa\x3e\x70\x8e\x72\x6e\x72\x7e\xe0\xfc\x4e\x7d\xa8\x3e\x52\x1f\xab\x4f\xd4\xa7\xce\x6d\xea\x33\xf5\xb9\xfa\xc2\xb9\xde\xf9\xab\x76\x34\x71\xae\xd3\x54\x33\xcd\xb5\xd0\x52\x2b\xad\xb5\xab\x2b\xf4\x30\x5d\xa9\x87\xeb\x11\x7a\xa4\x1e\xa5\x47\x3b\x1f\xe8\x31\x7a\xac\x1e\xa7\xd7\xd3\xe3\xf5\xfa\x7a\x03\xbd\xa1\xde\x48\x7f\x4d\x4f\xd0\x1b\xeb\x4d\xf4\xa6\x7a\xa2\xde\x4c\x4f\xd2\x9b\xeb\x2d\xf4\x96\x7a\xb2\xde\x4a\x6f\xed\x1c\xaf\xb7\xd1\xdb\xea\xed\xf4\x14\xbd\xbd\x9e\xaa\x77\xd0\xd3\x74\x95\xf6\xb4\xaf\x8d\xce\xe8\xac\xae\xd6\x35\xba\x56\xef\xe8\x9c\xa6\x77\x72\x4e\x77\x7e\xe1\xbc\xa5\x77\x76\x6e\x76\x7e\xe3\x9c\xac\x77\xd1\xd3\x9d\x33\x9c\x0b\x9c\x9f\xe8\xaf\x3b\xa7\x38\x3f\xd3\xbb\xea\x3a\x5d\xaf\x1b\x74\xa3\x0e\x74\xa8\x77\xd3\xbb\xeb\x19\x7a\xa6\xde\x43\xcf\xd2\x7b\xea\xd9\x7a\x8e\xde\x4b\xef\xad\xf7\xd1\x73\xf5\x3c\x3d\x5f\xef\xab\xf7\xd3\x0b\xf4\xfe\xfa\x00\xfd\x0d\x7d\xa0\xfe\xa6\x3e\x48\x1f\xac\x0f\xd1\x39\xbd\x50\x37\xe9\x66\x9d\xd7\x8b\x74\x8b\x6e\xd5\x05\x7d\xa8\x3e\x4c\xb7\xe9\x76\xdd\xa1\x8b\xba\x53\x2f\xd6\x5d\xba\x5b\x97\x74\x8f\x5e\xa2\x97\xea\x65\x7a\xb9\x5e\xa1\xbf\xa5\x0f\x77\xfe\xa4\xbf\xad\x8f\xd0\xdf\xd1\x47\xea\xef\xea\xa3\xf4\xf7\xf4\xd1\xfa\xfb\xfa\x18\xfd\x03\x7d\xac\xfe\xa1\x3e\x4e\xff\x48\x1f\xaf\x7f\xac\x4f\xd0\x3f\xd1\x27\xea\x93\xf4\xc9\xfa\xa7\xfa\x14\xfd\x33\x7d\xaa\xfe\xb9\x3e\x4d\xff\x42\x9f\xae\x7f\xa9\xcf\xd0\x67\xea\xb3\xf4\xaf\xf4\xd9\xfa\x1c\x7d\xae\xfe\xb5\x3e\x4f\xff\x46\x9f\xaf\x2f\xd0\x17\xea\xdf\xea\x8b\xf4\xef\xf4\xc5\xfa\xf7\xfa\x12\xfd\x07\x7d\xa9\xfe\xa3\xbe\x4c\x5f\xae\xaf\x70\x6e\x70\x6e\xd4\x57\xea\xab\xf4\xd5\xfa\x1a\xfd\x27\x7d\xad\xfe\xb3\xbe\x4e\xff\x45\x5f\xaf\xff\xaa\x6f\xd0\x37\xea\x9b\xf4\xcd\xfa\x16\x7d\xab\xbe\x4d\xdf\xae\x57\xea\x3b\xf4\x9d\xfa\x2e\xbd\x4a\xdf\xad\xef\xd1\xf7\xea\xfb\xf4\xfd\xfa\x01\xfd\xa0\x7e\x48\x3f\xac\x1f\xd1\x8f\xea\xc7\xf4\xe3\xfa\x09\xfd\xa4\x7e\x4a\x3f\xad\x9f\xd1\xcf\xea\xe7\xf4\xf3\xfa\x05\xfd\x37\xfd\xa2\x7e\x49\xbf\xac\x5f\xd1\xab\xf5\xdf\xf5\xab\xfa\x35\xfd\xba\x7e\x43\xbf\xa9\xdf\xd2\x6f\xeb\x7f\xe8\x77\xf4\xbb\x7a\x8d\x7e\x4f\xbf\xaf\x3f\xd0\x1f\xea\x8f\xf4\xc7\xfa\x13\xfd\xa9\xfe\x4c\x7f\xae\xbf\x70\x1d\x97\xb8\xd4\x65\x2e\x77\x85\x2b\x5d\xe5\x6a\xd7\x75\x2b\xdc\x61\x6e\xa5\x3b\xdc\x1d\xe1\x8e\x74\x47\xb9\xa3\xdd\x31\xee\x58\x77\x9c\xbb\x9e\x3b\xde\x5d\xdf\xdd\xc0\xdd\xd0\xdd\xc8\xfd\x9a\x3b\xc1\xdd\xd8\xdd\xc4\xdd\xd4\x9d\xe8\x6e\xe6\x4e\x72\x37\x77\xb7\x70\xb7\x74\x27\xbb\x5b\xb9\x5b\xbb\xdb\xb8\xdb\xba\xdb\xb9\x53\xdc\xed\xdd\xa9\xee\x0e\xee\x34\xb7\xca\xf5\x5c\xdf\x35\x6e\xc6\xcd\xba\xd5\x6e\x8d\x5b\xeb\xee\xe8\xee\xe4\xee\xec\xee\xe2\x4e\x77\xbf\xee\xee\xea\xd6\xb9\xf5\x6e\x83\xdb\xe8\x06\x6e\xe8\xee\xe6\xee\xee\xce\x70\x67\xba\x7b\xb8\xb3\xdc\x3d\xdd\xd9\xee\x1c\x77\x2f\x77\x6f\x77\x1f\x77\xae\x3b\xcf\x9d\xef\xee\xeb\xee\xe7\x2e\x70\xf7\x57\x3d\x1d\x85\x69\xd3\xea\xa6\xc1\x36\xba\xc5\x25\xf9\xae\xee\xa6\x62\x57\x9e\xb5\xf7\x54\x55\xb4\x17\x9a\x9b\x8b\xa5\xa9\xd3\xa6\x55\xa9\xba\xf6\xe8\x41\x67\x87\xca\x25\x56\xd6\x2d\xec\xca\x2f\xc9\xcb\x5c\x6c\x54\x5d\xb1\xa5\xd8\x91\x3f\x4c\xe5\x12\x3b\xac\xa1\xa9\xd0\xd5\xd4\xd3\xbe\xa8\x2d\xbf\x6c\x58\x53\xd9\xaf\x68\xb0\xd5\xe5\x9a\x9a\xf2\x1d\xa5\x8a\xa6\x3e\x57\x36\x36\xe5\xa2\x2a\x9b\x13\xd3\x68\xeb\xcf\x95\x54\x00\xc0\x3c\x00\x83\x04\x30\x1f\x9b\x8a\xa0\x5c\x51\xbe\xcf\x55\x01\x9a\x91\x4f\xac\x0c\x92\x1a\xf3\xb1\x19\xb6\x5b\xaa\x51\x2d\xa9\x46\xed\x56\xae\xab\xa5\xcf\xad\xdc\xad\xa9\xd8\xde\x9e\xc3\x4e\x4b\x6a\x67\xd8\xee\xa9\x7a\x5a\xcb\x3e\xdf\x7d\x61\xae\x8b\xb7\xda\x44\xce\x28\x15\xda\x9a\xf3\xb2\x10\x1b\x35\x03\x3d\x29\xa0\x27\x33\x92\x9e\x14\x92\xa1\x9b\x81\x36\x17\x12\x4b\x67\xcc\xa4\x85\x43\x87\xcd\x4c\x61\x1c\x5a\xf6\x2b\xf7\x48\xb7\xea\xb0\xb5\x76\x5a\xa2\xe7\xe6\x6d\xb9\x8e\xe6\x42\x93\x9c\x95\x6b\xea\x29\xe5\x65\x5b\x6c\x2a\x67\xa5\xcb\xb5\xa5\x76\xe4\xac\x64\x80\xda\x62\xc3\x67\xd9\xde\xf3\x36\x9b\xc8\xd9\xc9\xf9\x1d\xc9\xf9\xb3\xd3\xe7\x77\xa4\xcf\x9f\x9d\x9c\xdf\x91\x0c\x70\x47\xae\xb3\xd8\x5d\xea\x2a\x76\xb6\xe6\x59\xd0\xd1\xc2\xf2\x1d\x2d\x6a\x0e\x3a\x5f\x44\xe7\xe7\x24\x9d\x2f\xc6\x66\xf8\x9c\xd6\x9e\x8e\x96\x5c\x57\x4f\x7b\x5b\xae\xa7\x34\xbc\x98\xde\x93\xfb\x24\x6d\xe8\x4a\xda\xb0\x4f\xba\x0d\x5d\xe9\x36\xec\x93\xb4\xa1\x2b\x31\x73\x93\xb3\xba\x63\x33\x6c\x6e\x6a\x18\xbb\x53\xc3\x38\x2f\x5d\x5b\x29\x5d\xdb\xbc\xa4\x9a\x52\x32\x22\xf3\xa2\x4b\x5a\x8a\x2e\xe9\xfc\xe4\x92\xf6\x24\x97\x74\x3e\x7a\xd5\x83\x5e\xcd\x4f\x7a\xd5\x13\x1b\x31\xbf\xab\xd0\xd1\x22\x7a\xa2\x74\xf8\xfc\xb5\x7a\xd8\x93\xde\x53\xf3\x71\xe9\x7b\x70\xd7\xec\x97\x6a\xed\xd2\x94\xbf\x7f\xca\x5f\x5e\xf6\xe5\x01\x49\x5f\x57\xc4\xa6\xe2\x80\xf2\x34\x5e\xd1\xe7\x8a\xb6\x62\x47\x4b\x77\x7c\x7b\x57\xd5\x4c\x83\xad\x82\xf5\x60\x7d\x58\x03\x9b\x81\xcd\xc2\x56\xc3\xd6\xc0\xd6\xc2\xd6\xc1\xd6\xc3\x36\xc0\x36\xc2\x06\xb0\x61\x62\x6b\x81\x5f\x0b\xfc\x5a\xe0\xd6\x02\xb7\x16\xb8\xb5\xc0\xad\x05\x6e\x2d\x70\x6b\x81\x5b\x0b\xdc\x5a\xe0\xd6\x02\xb7\x16\xb8\xb5\xc0\xad\x0d\xc5\x9c\xd6\x62\x97\x0d\x7e\xa2\x34\xc9\xab\x43\x9f\xeb\x80\x5d\x07\xec\x3a\x60\xd7\x01\xbb\x0e\xd8\x75\xc0\xae\x03\x76\x1d\xb0\xeb\x80\x5d\x07\xec\x3a\x60\xd7\x05\x62\x7e\x8c\xd9\x53\xc6\xac\x47\x7f\xeb\x81\x5d\x0f\xec\x7a\x60\xd7\x03\xbb\x1e\xd8\xf5\xc0\xae\x07\x76\x3d\xb0\xeb\x81\x5d\x0f\xec\x7a\x60\xd7\x03\xbb\x1e\xfd\xae\xc7\x78\x37\x60\xbc\x1b\x80\xdf\x00\xfc\x06\xe0\x37\x00\xbf\x01\xf8\x0d\xc0\x6f\x00\x7e\x03\xf0\x1b\x80\xdf\x00\xfc\x06\xe0\x37\x00\xbf\x01\xf8\x0d\xc0\x6f\x00\x7e\x23\xf0\x1b\x81\xdf\x08\xfc\x46\xe0\x37\x02\xbf\x11\xf8\x8d\xc0\x6f\x04\x7e\x23\xf0\x1b\x81\xdf\x08\xfc\x46\xe0\x37\x02\xbf\x11\xf8\x8d\xc0\x6f\x04\x7e\x00\xfc\x00\xf8\x01\xf0\x03\xe0\x07\xc0\x0f\x80\x1f\x00\x3f\x00\x7e\x00\xfc\x00\xf8\x01\xf0\x03\xe0\x07\xc0\x0f\x80\x1f\x00\x3f\x00\x7e\x08\xfc\x10\xf8\x21\xf0\x43\xe0\x87\xc0\x0f\x81\x1f\x02\x3f\x04\x7e\x08\xfc\xb0\xb6\xa2\x2e\x5a\x4b\x92\xdb\x3c\xd7\xe7\xaa\xba\x20\xb1\xb9\x7c\xb2\xda\xcd\xe9\x6e\xcb\x75\xb7\x26\x7e\xb1\xec\xc7\xb5\x78\xd3\xa6\xc1\x56\xc1\x7a\xb0\x3e\xac\x81\xcd\xc0\x66\x61\xab\x61\x6b\x60\x6b\x61\xeb\x60\xeb\x61\x1b\x60\x1b\x61\x03\xd8\x64\x34\xbc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\x7e\x15\xf0\xab\x80\x5f\x55\x5d\x39\x37\xbd\x5a\x77\xa7\x76\x50\x02\x2d\xa9\x42\x4b\xaa\xd0\x92\x2a\xb4\xa4\x0a\x2d\xa9\x42\x4b\x3c\xb4\xc4\x43\x4b\x3c\xb4\xc4\x43\x4b\x3c\xb4\xc4\x43\x4b\x3c\xb4\xc4\xc3\x48\x78\x18\x09\x0f\x23\xe1\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfa\xc0\xf5\x81\xeb\x03\xd7\x07\xae\x0f\x5c\x1f\xb8\x3e\x70\x0d\x70\x0d\x70\x0d\x70\x0d\x70\x0d\x70\x0d\x70\x0d\x70\x0d\xfa\x6d\x80\x6f\x80\x6f\x80\x6f\x80\x6f\x80\x6f\x80\x6f\x80\x6f\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\x7e\x35\xf0\xab\x81\x0f\xfe\xf7\xc0\xff\x1e\xf8\xdf\x03\xff\x7b\xe0\x7f\x0f\xfc\xef\x81\xff\x3d\xf0\xbf\x07\xfe\xf7\xc0\xff\x1e\xf8\xdf\x03\xff\x7b\xe0\x7f\x0f\xfc\xef\x81\xff\x3d\xf0\xbf\x07\xfe\xf7\xc0\xff\x5e\x2d\xf0\xa1\x03\x3c\xe8\x00\x0f\x3a\xc0\x83\x0e\xf0\xa0\x03\x3c\xe8\x00\x0f\x3a\xc0\x83\x0e\xf0\xa0\x03\x3c\xe8\x00\x0f\x3a\xc0\x83\x0e\xf0\x6a\x81\x8f\x30\xc7\xab\x03\x3e\xb4\x80\x07\x2d\xe0\x41\x0b\x78\xd0\x02\x1e\xb4\x80\x07\x2d\xe0\x41\x0b\x78\xd0\x02\x1e\xb4\x80\x07\x2d\xe0\x41\x0b\x78\xd0\x02\x5e\x1d\xf0\xeb\x80\x5f\x0f\x7c\xe8\x01\x0f\x7a\xc0\x83\x1e\xf0\xa0\x07\x3c\xe8\x01\x0f\x7a\xc0\x83\x1e\xf0\xa0\x07\x3c\xe8\x01\x0f\x7a\xc0\x83\x1e\xf0\xa0\x07\x3c\xe8\x01\x0f\x7a\xc0\x83\x1e\xf0\xa0\x07\x3c\xe8\x01\x0f\x7a\xc0\x83\x1e\xf0\xa0\x07\x3c\xe8\x01\x0f\xfc\xef\x81\xf7\x3d\xf0\xbe\x07\xde\xf7\xc0\xfb\x1e\x78\xdf\x03\xef\x7b\xe0\x7d\x0f\xbc\xef\x81\xf7\x3d\xf0\xbe\x07\xde\xf7\xc0\xfb\x1e\x78\xdf\x03\xef\x7b\xe0\x71\x0f\x3c\xee\x81\xc7\x3d\xf0\xb8\x07\x1e\xf7\xc0\xe3\x1e\x78\xdc\x03\x8f\x7b\xe0\x71\x0f\x3c\xee\x81\xc7\x3d\xf0\xb8\x07\x1e\xf7\xc0\xe3\x1e\x78\xdc\x03\x8f\x7b\xe0\x71\x0f\x3c\xee\x81\xc7\x3d\xf0\xb8\x07\x1e\xf7\xc0\xe3\x1e\x78\xdc\x03\x8f\x7b\xe0\x71\x0f\x3c\xee\x81\xc7\xbd\x10\xf8\x21\xf0\x43\xe0\x87\xc0\x0f\x81\x1f\x02\x3f\x0c\xdd\x96\xae\xdc\x92\xbc\x25\xbc\x85\x6e\xcc\xe4\x91\x17\x1f\xf3\xa7\x79\x6e\x1c\x89\xa4\x72\x0c\x6c\x06\x36\x0b\x5b\x0d\x5b\x33\xbc\xb5\x58\x3c\x2c\xb7\xb0\xb8\x24\x7d\x56\x1d\x6c\x3d\x6c\x03\x6c\x23\x6c\x00\x9b\x8c\x85\x0f\x16\xf7\xc1\xe2\x3e\x58\xdc\x07\x8b\xfb\x60\x71\x1f\x2c\xee\x83\xc5\xfd\x2a\xb4\xa2\xaa\x06\xb6\x16\x16\xf8\xe0\x6e\x1f\xdc\xed\x83\xbb\x7d\x70\xb7\x0f\xee\xf6\xc1\xdd\x3e\xb8\xdb\xf7\xbc\x4a\x1b\xeb\x2c\xcc\xb7\x15\x97\x96\x3b\x05\x02\xf7\x41\xe0\x3e\x08\xdc\x07\x81\xfb\x20\x70\x1f\x04\xee\x83\xc0\x7d\x10\xb8\x0f\x02\xf7\x41\xe0\x3e\x08\xdc\x07\x81\xfb\x20\x70\x1f\x04\xee\x83\xc0\x7d\x10\xb8\x0f\x02\xf7\x41\xe0\x3e\x08\xdc\xf7\x81\x0f\x22\xf7\x41\xe4\x3e\x88\xdc\x07\x91\xfb\x20\x72\x1f\x44\xee\x83\xc8\x7d\x10\xb9\x0f\x22\xf7\x41\xe4\x3e\x88\xdc\x07\x91\xfb\x20\x72\x1f\x44\xee\x83\xc8\x7d\x10\xb9\x0f\x22\xf7\x41\xe4\x3e\x88\xdc\x07\x91\xfb\x20\x72\x1f\x44\xee\x83\xc8\x7d\x10\xb9\x0f\x22\xf7\x41\xe4\x3e\x88\xdc\x07\x91\xfb\x20\x72\x1f\x44\xee\x83\xc8\x7d\x10\xb9\x0f\x22\xf7\x41\xe4\x3e\x88\xdc\x07\x91\xfb\x20\x72\x1f\x44\xee\x83\xc8\x7d\x10\xb9\x0f\x22\xf7\x41\xe4\x3e\x88\xdc\x07\x91\xfb\x20\x72\x1f\x44\xee\x83\xc8\x7d\x10\xb9\x0f\x22\xf7\x41\xe4\x3e\x88\xdc\x07\x91\xfb\x20\x72\x1f\x44\xee\x83\xc8\x7d\x10\xb9\x0f\xa2\xf6\x41\xd4\x3e\x88\xd8\x07\x11\xfb\x20\x62\x1f\x44\xec\x57\x07\xa2\x54\xec\x28\x76\x0f\x6f\x2e\xe4\xbb\xf2\xdd\x85\xee\x78\xaf\xa2\xae\xad\xb3\x35\x17\xbb\x6e\xae\xa3\x58\xca\xb7\xe5\x0b\xb9\xca\xa0\xb3\xbb\x60\x63\xf6\x38\x5b\x07\x25\x1c\x9f\x51\x84\x57\x39\xa7\xbd\x10\x3d\x71\x48\x76\xe6\xa7\x0a\x57\xcc\x69\xcf\xb7\x24\x85\x46\x17\x6c\xf1\xb5\xb0\x44\x8c\xc5\xeb\xf3\xa5\x9c\xd8\x2d\x67\xf5\xb3\x02\x0e\x3f\xc0\x66\x31\x8b\x23\xe6\xb5\x5a\x8f\x47\x40\x62\x8f\x5c\x67\x67\x4e\xce\xca\xb5\x2f\x6c\xce\xd1\x3d\x7b\xe8\xec\x1e\xba\xa0\xa0\x80\x4c\xf7\x2a\xb0\x7d\x5a\x8b\x62\x6e\xa1\xa5\x3d\xc7\xe6\xe5\x7a\x14\x5a\xc1\xf6\x6a\x2d\xb0\x06\xbb\xed\xd5\x5d\xa8\x9c\x91\x6a\xc1\x48\x14\xe8\xdd\xaf\xc8\xf5\x75\xbc\x32\x9f\xee\x6e\xbe\xb7\xbb\x85\xde\xee\x8e\xeb\x59\xfb\xd4\xa4\x33\xf1\xf9\x7c\x61\xd4\x99\x96\xa8\x33\xa2\x39\xdf\x56\xca\x29\xd4\xc5\x57\x44\x5d\x8a\x0e\x96\xe2\x2e\x45\x95\x89\xc3\xe2\x2e\xb5\x25\x5d\xea\xe8\xa1\xcb\x0a\xaa\x98\xf4\x87\x75\xb5\x16\x65\x77\xd4\x99\x2a\x11\x1b\x56\xb2\x7d\x02\x2e\xeb\xb4\xfd\x69\xb2\x9b\xdd\x15\xc5\x68\x80\x2b\xd3\x63\x3b\xb2\x5f\xf3\x2a\x8b\xe9\xab\xd3\x93\xbe\x3a\xc5\xbe\xab\x93\xcc\x09\x90\xa4\x0f\x92\xf4\x41\x92\x3e\x48\xd2\x07\x49\xfa\x20\x49\x1f\x24\xe9\x83\x24\x7d\x04\xc7\x3e\x82\x63\x1f\xc1\xb1\x8f\xe0\xd8\x47\x70\xec\x23\x38\xf6\x41\xaa\x3e\x48\xd5\x07\xa9\xfa\x20\x55\x1f\xa4\xea\x83\x54\x7d\x90\xaa\x0f\x52\xf5\x41\xaa\x3e\x48\xd5\x07\xa9\xfa\x20\x55\x1f\xa4\xea\x83\x54\x7d\x90\xaa\x0f\x52\xf5\x41\xaa\x3e\x48\xd5\x07\xa9\xfa\x20\x55\x1f\xa4\xea\x83\x54\x7d\x90\xaa\x0f\x52\xf5\x41\xaa\x3e\x48\xd5\x07\xa9\xfa\x20\x55\x1f\xa4\xea\x83\x54\x7d\x90\xaa\x0f\x52\xf5\x41\xaa\x7e\x98\xe0\x1b\x84\xc3\x06\xe1\xb0\x41\x38\x6c\x10\x0e\x1b\xd0\xa9\x01\x9d\x1a\xd0\xa9\x01\x9d\x1a\x84\xc3\x06\xe1\xb0\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x01\x91\x1a\x10\xa9\x41\x10\x6c\x10\x04\x1b\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x70\xa8\x01\x87\x1a\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x70\xac\x01\xc7\x1a\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x70\xb0\x01\x07\x1b\x70\xb0\x01\x07\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x04\xc3\x06\xc1\xb0\x41\x30\x6c\x10\x0c\x1b\x3c\x1c\x37\x78\x38\x6e\x10\x1c\x1b\x3c\x1c\x37\x08\x92\x0d\x82\x64\x83\x20\xd9\x20\x48\x36\x08\x92\x0d\x82\x64\x03\xfe\x37\xe0\x7f\x03\xfe\x37\xe0\x7f\x03\xfe\x37\xe0\x7f\x03\xfe\x37\xe0\x7f\xd3\x58\xe3\xe6\x16\x15\x0a\x55\xd3\x6a\x7a\x57\x26\x28\x00\x03\x05\x60\xa0\x00\x0c\x14\x80\x81\x02\x30\x50\x00\x06\x0a\xc0\x40\x01\x18\x28\x00\x03\x05\x60\xa0\x00\x0c\x14\x80\x81\x02\x30\x50\x00\x06\x0a\xc0\x40\x01\x18\x28\x00\x03\x05\x60\xa0\x00\x0c\x14\x80\x81\x02\x30\x50\x00\x06\x0a\xc0\x40\x01\x18\x28\x00\x03\x05\x60\xa0\x00\x0c\x14\x80\x81\x02\x30\x50\x00\x06\x0a\xc0\x40\x01\x18\x28\x00\x03\x05\x60\xa0\x00\x0c\x14\x80\x81\x02\x30\x50\x00\x19\x28\x80\x0c\x14\x40\x06\x0a\x20\x03\x05\x90\x81\x02\xc8\x40\x01\x64\xa0\x00\x32\x50\x00\x19\x28\x80\x0c\x14\x40\x06\x0a\x20\x03\x05\x90\x81\x02\xc8\x40\x01\x64\xa0\x00\x32\x50\x00\x19\x28\x80\x0c\x14\x40\x06\x0a\x20\x03\x05\x90\x01\xa3\x67\xc0\xe8\x19\x30\x7a\x06\x8c\x9e\xc1\xca\x91\xc1\xca\x91\xc1\xca\x91\xc1\xca\x91\xc1\xca\x91\xc1\xca\x91\xc1\xca\x91\xc1\xca\x91\xc1\xca\x91\xc1\xca\x91\xc1\xca\x91\xc1\xca\x91\xa9\xed\xc5\x41\xbb\xb1\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xb0\x72\x64\xea\x42\xd1\xdd\x9a\x5f\x92\xab\xb0\xb1\x43\x6e\x51\x77\xbe\xa5\xd8\x96\xb8\x9d\x36\x69\x1d\x16\xbb\x8b\x73\xed\xb9\x52\xb7\x68\x2d\x74\x15\x16\x8b\x52\xb7\x55\xe5\x22\x2e\x28\xe2\x32\xb2\xf7\x70\xd1\x06\x02\x49\xa5\xf5\x75\x72\x71\xcf\xc2\x9e\x52\xb7\x6c\xce\xb5\xe4\xbb\x5b\x45\x7b\xbe\x94\x6f\x11\xed\xb9\xc5\xb9\x45\xbc\x2b\xb7\x28\x6f\xcf\xec\xce\x2f\x56\xd1\x37\xdf\xa2\x17\xe3\xdd\xb1\xd1\xdd\x45\x8b\xda\xdd\xb3\xd8\xed\xe9\xec\xcc\x77\x1d\x1c\x65\xb5\x15\x97\xe6\xbb\xac\x93\xd4\xdb\x90\x1d\x96\x80\x2d\xb6\xc0\x1d\x3c\xd7\x96\x5f\xc4\x6c\xc0\x22\x5a\x0a\xed\xf9\x36\xd1\x6c\xf7\x4b\xb4\x35\xcf\x96\xe4\x96\x88\x15\xb9\xe5\x85\x0e\x66\x43\x15\x56\xb2\xdb\xf2\x62\xb3\x5e\x54\xe8\xc8\xb5\x1d\x96\x5b\xc4\xec\x26\x6c\x53\xf3\xc8\x6a\xcf\xb7\x33\xbb\x25\x3b\x1d\x3d\x1d\xcc\x6e\xb2\xdb\x1e\x3f\xac\x95\x47\x95\xa8\xf8\x40\x67\x9e\x76\xe6\x2b\x62\xb7\xd4\x6d\x43\x15\x11\xa7\x6c\x71\xd1\x76\xc8\xf6\x90\x47\x5d\xb1\x31\xce\x12\x69\xc1\x97\x24\xc6\x82\x4a\xbb\x45\xa6\x25\x8a\x64\x5a\x5d\x6b\xba\x5b\x6d\x9d\xf1\x30\x55\x35\x26\xf7\x8a\xb5\x55\xb0\x1e\xac\x0f\x6b\x60\x33\xb0\x59\xd8\x6a\xd8\x1a\xd8\x5a\xd8\x3a\xd8\x7a\xd8\x06\xd8\x46\xd8\x00\x36\x4c\x6c\x15\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\x7e\x15\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\xef\x01\xdf\x03\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\xbe\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\x7e\x0d\xf0\x6b\x80\x5f\x03\xfc\x1a\xe0\xd7\x00\xbf\x06\xf8\x35\xc0\xaf\x01\x7e\x0d\xf0\x6b\x80\x5f\x03\xfc\x1a\xe0\xd7\x00\xbf\x06\xf8\x35\xc0\xaf\x01\x7e\x2d\xf0\x6b\x81\x5f\x0b\xfc\x5a\xe0\xd7\x02\xbf\x16\xf8\xb5\xc0\xaf\x05\x7e\x2d\xf0\x6b\x81\x5f\x0b\xfc\x5a\xe0\xd7\x02\xbf\x16\xf8\xb5\xc0\xaf\x05\x7e\x1d\xf0\xeb\x80\x5f\x07\xfc\x3a\xe0\xd7\x01\xbf\x0e\xf8\x75\xc0\xaf\x03\x7e\x1d\xf0\xeb\x80\x5f\x07\xfc\x3a\xe0\xd7\x01\xbf\x0e\xf8\x75\xc0\xaf\x03\x7e\x3d\xf0\xeb\x81\x5f\x0f\xfc\x7a\xe0\xd7\x03\xbf\x1e\xf8\xf5\xc0\xaf\x07\x7e\x3d\xf0\xeb\x81\x5f\x0f\xfc\x7a\xe0\xd7\x03\xbf\x1e\xf8\xf5\xc0\xaf\x07\x7e\x03\xf0\x1b\x80\xdf\x00\xfc\x06\xe0\x37\x00\xbf\x01\xf8\x0d\xc0\x6f\x00\x7e\x03\xf0\x1b\x80\xdf\x00\xfc\x10\x38\x89\x26\xab\x0a\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x50\x1d\xca\xfd\xe2\x77\x9d\x72\x69\x62\xf6\x4b\x3e\xda\xb8\x34\x36\xee\x7e\xbd\x0f\xd8\xdd\xa5\xbd\x5e\x72\x1e\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x50\x1b\xb8\x75\xbd\xef\x2b\xdd\x5c\xaf\x57\x51\xd7\xf7\x66\xb6\x22\xd7\xe7\x8e\xaa\x2b\x7f\xd4\x33\x1e\x86\x51\xb9\xfe\x19\xa9\x12\xf1\xb0\xa5\x4b\xc4\x19\xe3\x52\x25\xfa\x2a\x1e\x97\x1b\x24\x33\x5d\x57\xfc\x66\x39\x5d\x57\x9c\x31\x36\x55\xa2\xb7\xe5\x63\x73\x03\xf3\x86\x25\x1f\x0d\x4f\x3e\x86\x96\x4b\xf9\x49\x7e\xdc\x2e\xe4\xc7\xfe\xc8\x24\xbf\xaf\x25\x23\x73\x6b\xef\xe3\xbc\xb8\x0d\x38\x2f\xf6\x47\x24\xf9\xbd\xb0\x23\x72\x6b\xed\xba\x41\x9f\xd7\x97\x57\x11\x94\xc7\xb9\x5c\xbf\x0c\x92\x8f\xf6\x26\xb5\x8e\x0a\xfa\x0f\x72\xbe\x7f\x46\xd0\x7f\xd4\xf3\xfd\x47\x3d\x18\x6c\xd4\xf3\x83\x8d\x7a\xd0\x7f\xd4\xf3\xfd\x47\x3d\x18\x64\xd4\xf3\x03\xf3\x2a\x66\x94\xfb\x56\xe8\x73\xdd\x19\x7d\xa3\x50\xe8\xf3\xe6\xf4\x79\xc5\xbe\xb3\xe7\x94\xcf\x2e\x96\x5b\x37\xa7\x7f\xd7\x8b\xfd\x33\xe6\xf4\x1f\x8b\x62\xff\xb1\x98\x33\xd8\x58\x14\x07\x1b\x8b\x39\xfd\xc7\xa2\xd8\x7f\x2c\xe6\x0c\x32\x16\xc5\x41\xc6\x22\xfe\xd8\x6f\xf2\x71\xc9\x62\xd9\x8d\x73\xe3\x46\x25\xb9\xb1\x3b\x22\xce\xed\x6b\xc4\x88\xe2\x5a\xbb\xc9\x39\x31\x78\x72\x4e\xec\x0e\x8f\x73\x7b\xd1\x86\x17\xd3\x7b\xee\xfc\x3e\xaf\xa7\xaf\x3d\xf3\xcb\x15\xf6\x94\xdd\xf9\xe5\xa6\xf5\x94\xdd\xf9\xe5\x56\xf6\x94\x5b\x39\x7f\xed\x56\xf6\xac\xdd\xca\xf9\xe5\x56\xf6\x94\x5b\x39\x7f\xad\x56\xf6\xa4\xf7\xe4\xfe\xc9\x32\xbb\x3c\x36\xee\xfe\x7d\x6d\x5e\xde\xd7\xe6\xfd\xcb\xd5\x2f\x2f\xdf\x2b\xfb\x27\xf7\xca\xf2\xe4\x63\xf0\xd1\x9a\x16\x42\xb3\x85\xd0\x6c\x21\x34\x5b\x08\xcd\x16\x42\xb3\x85\xd0\x6c\x21\x34\x5b\x08\xcd\x16\x42\xb3\x85\xd0\x6c\x21\x34\x5b\x08\xcd\x16\x42\xb3\x85\xd0\x6c\x21\x34\x5b\x08\xcd\x16\x42\xb3\x85\xd0\x6c\x21\x34\x5b\x08\xcd\x16\x42\xb3\x85\xd0\x6c\x21\x34\x5a\x08\x8d\x16\x42\xa3\x85\xd0\x68\x21\x34\x5a\x08\x8d\x16\x42\x93\x85\xd0\x64\x21\x34\x59\x08\x4d\x16\x42\x93\x85\xd0\x64\x21\x34\x59\x08\x4d\x16\x42\x93\x85\xd0\x64\x21\x34\x59\x08\x4d\x16\x42\x93\x85\x5e\x2f\x1e\xfa\x07\x4d\x16\x42\x93\x85\xd0\x64\x21\x34\x59\x08\x4d\x16\x42\x93\x85\xd0\x64\x21\x34\x59\x08\x4d\x16\x42\x93\x85\xd0\x64\x21\x34\x59\x08\x4d\x16\x42\x93\x85\xd0\x64\x21\x34\x59\x08\x4d\x16\x42\x93\x85\xd0\x64\x21\x34\x59\x08\x4d\x16\x42\x93\x85\xd0\x64\x21\x34\x58\x08\x0d\x16\x42\x83\x85\xd0\x60\x21\x34\x58\x08\x0d\x16\x42\x73\x85\xd0\x5c\x21\x34\x57\x08\xcd\x15\x42\x73\x85\xd0\x5c\x21\x34\x57\x08\xcd\x15\x42\x6b\x85\xd0\x58\x61\xa6\xb7\x5e\xb4\x1f\x9a\x2a\x84\xa6\x0a\xa1\xa9\x42\x68\xaa\x10\x9a\x2a\x84\xa6\x0a\xa1\xa9\x42\x68\xaa\x10\x9a\x2a\x84\xa6\x0a\xa1\xa9\x42\x68\xaa\x10\x9a\x2a\x84\xa6\x0a\xa1\xa9\x42\x68\xaa\x10\x9a\x2a\x84\xa6\x0a\xa1\xa9\x42\x68\xaa\x10\x9a\x2a\x84\xa6\x0a\xa1\xa9\x42\x68\xaa\x10\x9a\x2a\x84\xa6\x0a\xa1\xa9\x42\x68\xaa\x10\x9a\x2a\x84\xa6\x0a\x11\xab\x87\x88\xd5\x43\xc4\xea\x21\x62\xf5\x10\xb1\x7a\x88\x58\x3d\x84\x86\x0a\xa1\xa1\x42\x68\xa8\x10\x1a\x2a\x84\x86\x0a\xa1\xa1\x42\x68\xa8\xb0\xa6\x17\x0f\xfd\x85\x86\x0a\xa1\xa1\x42\x68\xa8\x10\x1a\x2a\x84\x86\x0a\xa1\xa1\x42\x68\xa8\x10\x1a\x2a\x84\x86\x0a\xa1\xa1\x42\x68\xa8\x10\x1a\x2a\x84\x86\x0a\x11\xab\x87\x88\xd5\x43\xc4\xea\x21\x62\xf5\x10\xb1\x7a\x88\x58\x3d\x44\xac\x1e\x22\x56\x0f\x11\xab\x87\x88\xd5\x43\xc4\xea\x21\x62\xf5\x10\xb1\x7a\x88\x58\x3d\x44\xac\x1e\x22\x56\x0f\x11\xab\x87\x88\xd5\x43\xc4\xea\x21\x62\xf5\x10\xb1\x7a\x88\x58\x3d\x44\xac\x1e\x22\x56\x0f\x11\xab\x87\x88\xd1\x43\xc4\xe8\x21\x62\xf4\x10\x31\x7a\x88\x18\x3d\x44\x8c\x1e\x22\x46\x0f\x11\xa3\x87\x88\xd1\x43\xc4\xe8\x21\x62\xf4\x10\x31\x7a\x88\x18\x3d\x44\x8c\x1e\x22\x46\x0f\x11\x9b\x87\x88\xcd\x43\xc4\xe6\x21\x62\xf3\x10\xb1\x79\xd8\x00\xdc\x06\xe0\x36\x00\xb7\x01\xb8\x0d\xc0\x6d\x04\x6e\x23\x70\x1b\x81\xdb\x08\xdc\x46\xe0\x35\x02\xaf\x11\x78\x8d\xc0\x6b\x04\x5e\x23\xf0\x1a\x81\xd3\x08\x9c\x46\xe0\x04\xc0\x09\x80\x13\x00\x27\x00\x4e\x80\xfe\x05\xb8\xae\x01\x70\x03\xe0\x06\xc0\x0d\x80\x1b\x00\x37\x00\x6e\x80\x7e\x06\xc0\x0f\x80\x1f\x00\x3f\x04\x5e\x08\xbc\x10\x78\x21\x70\x42\xe0\x84\xc0\x09\x81\x13\x02\x27\x04\x4e\x08\x9c\x10\x38\xc9\x33\x10\x6f\x5a\xc2\x73\xd6\x36\xc2\xf6\xe6\x87\x89\x4d\x78\xcd\xda\xcc\xf0\xf8\x87\xd0\xe2\xaf\x69\x36\x2f\x6c\x1b\xbe\xb8\xa7\x18\xfd\x0a\x67\xf4\xcd\xcd\x7c\x33\xca\xe0\x9c\x84\x6b\xac\xad\x87\x05\x86\x07\x0c\x2f\x90\xed\x85\x8e\xf8\x0b\x73\xf9\xa6\x62\x07\xce\xf6\x8d\x9b\x5f\xd6\xd4\x96\x6b\xb7\xb5\xbb\x5d\xb9\xe6\xe8\x27\xfd\xf2\xcb\x92\x63\x19\xb4\x2a\x8b\x9a\xb3\xa8\x39\x8b\x9a\xb3\xa8\x39\xdb\x5b\x2e\x74\x3b\xba\x7b\x3a\xf3\x5d\x85\x62\x57\x92\x93\xac\x0f\xd6\x56\xc1\xa2\x5f\xc9\xfa\x60\xad\x49\x6c\x1d\xca\xd5\xa1\x5c\x9d\xc7\xdb\x0a\x5d\x39\xec\x64\x60\xb3\xb2\x33\xdf\x9d\x2f\xf5\x66\xd7\xc0\xd6\xca\xee\xd6\xfc\xe2\x7c\x1b\x6f\x2e\x76\xb4\xf0\xe8\x47\x02\x71\x00\xcd\xab\x43\xf3\xea\x30\x50\xf5\x00\xab\x07\x58\x3d\x1a\x55\x8f\x46\xd5\xa3\x51\xf5\xc0\x4d\x5e\x5e\x7a\x55\x89\xa8\xf1\xaa\x12\xb1\x61\x6d\x16\xb6\x9a\xcd\x69\x6d\x77\xf3\xdd\xa5\x42\x7b\xae\x84\xcb\x52\x95\x50\x9e\xb5\x81\x2e\x76\xe4\x4b\xad\x85\xae\x66\xb7\xb4\xb4\x18\x3b\xdd\xae\xcd\xca\x47\xbf\xd9\xdb\x5a\x59\x6a\xed\xca\xc3\xef\x1e\xb6\xa8\xb0\xa4\xd7\xaf\xec\xb6\x57\xb9\x03\x3b\x49\x55\x35\xc6\xcd\x75\x75\x15\x97\xb6\xe5\x17\x95\x54\xec\xf5\x74\x56\xc4\x36\xfe\xfd\xdf\xe4\x60\x73\x71\x69\x47\xe2\x2d\xb4\x60\x2e\x8a\x35\x77\x54\xf6\x79\x0b\xbb\x63\x35\xe7\xe1\x6b\x3f\x9e\x57\x95\xa9\x28\x76\x95\x5a\xa3\x6f\x26\xe6\xda\x2a\x0b\x1d\xa5\x68\x76\xc5\xbf\xd4\x3a\x2c\xbf\xb8\xa7\xb0\xc4\xce\x88\x8e\xa6\xbc\x68\x2d\xf6\x74\xe7\x87\xdb\xc9\xd7\x56\x6c\x89\xa6\x49\x47\xb1\x54\x11\x15\xb6\xba\xb2\xad\xd4\xd9\xe7\x2e\x8c\x5f\x8b\x79\x78\xe7\xea\xe1\x5d\xab\x87\x77\xa4\x1e\xde\x85\x5a\x6b\x60\x6b\x60\x71\xdc\x43\x3e\xe6\x6f\xc6\xc7\xbe\x8f\xfd\x0c\xce\x4f\x34\x84\xb5\xa8\x3f\xd1\x10\xd6\xa2\x7c\xa2\x21\xac\xcd\xc2\x56\xc3\x02\x2f\xd1\x12\xd6\xd6\xc1\xd6\xc3\xf6\xe2\x34\xc2\x06\xb0\xc9\xf4\xc9\x64\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x3e\xee\xae\x0c\xee\xae\x4c\x74\x77\x75\x2e\x6c\x2b\x36\x1d\xa6\xec\xb5\x8a\xac\x48\xf6\xda\x16\x25\xb6\xab\x84\xfd\x52\x77\x6b\xae\x39\x2f\xe2\x54\x35\x1f\x16\x5b\x77\x51\xa1\xad\xcd\x2e\x15\xc5\xe4\x1e\xc6\x9b\x5b\x0f\x6f\x5e\xad\xad\xaf\x48\x4a\x74\xd9\x2b\xac\x4a\x5d\x85\x5c\x4b\x4f\x67\x62\xbb\xb0\xdf\xdc\x91\xd8\xb6\x45\x32\x8a\xb7\xda\x92\xd9\x92\x69\xc0\xb8\x34\x84\x6e\xa1\x63\xc9\xc2\x1e\x5b\x49\x29\xf2\x92\x32\x15\xc5\xce\x7c\x07\x32\xbb\xdb\x0b\x76\x8a\xe6\x9a\xf2\x76\x2e\x2d\xe9\xdb\x61\xdd\x3d\x1d\x72\x51\xbe\xdd\xce\x26\x1e\x25\xa2\xbb\xd3\xb6\x97\x37\xb5\xf5\x2c\x14\xad\xf9\x9c\x45\x6f\x2e\xe4\xda\xed\xc2\x34\xac\xbd\xa7\x1b\xf3\x2b\x3f\x22\xe5\xdb\x15\x2a\x6e\x41\x36\x51\x5b\x5e\x03\xae\x44\x03\xae\x44\x03\xae\x44\x03\xae\x44\x03\xae\x44\x03\xae\x44\x03\xae\x44\x03\xae\x44\x03\xae\x44\x03\xae\x44\x03\xae\x44\x03\xae\x44\x03\xd6\xb9\x06\xac\x73\x0d\xd5\xc0\xa9\x06\x4e\x35\x70\xaa\x81\x53\x0d\x9c\x6a\xe0\x24\xaa\xce\xc3\x13\xe3\xba\xea\x3e\x5b\x03\x5b\x0b\x5b\x07\x5b\x0f\xdb\x00\xdb\x08\x1b\xc0\x86\x89\x4d\xa2\x14\x6b\xab\x12\x5b\x83\xfa\x6a\x50\x5f\x0d\xea\xab\x41\x7d\x89\x8a\xb3\x22\xa5\x11\x36\xa8\x4c\xde\x00\x1f\x1c\xbf\x2a\x1f\x69\x6f\xdf\xbc\x0d\x49\xa3\x1f\x7f\x8d\x5e\x2d\xeb\xe8\x0d\xf6\xd2\x82\x9d\x4b\xf1\xbb\xeb\xc8\x93\xad\xf9\xc8\xa8\xc3\x72\xc9\x81\xf8\x45\x75\xe4\x55\xf6\xbe\xac\x8e\x76\x74\xf4\x3a\x39\x2e\x57\xca\x2d\x89\x8f\xda\x9a\x0f\xee\x6c\xeb\xe9\x8e\x7e\x4f\x74\x58\xf4\x32\x1a\xef\xd6\x2b\x62\x3f\x76\x47\xc7\x59\xf1\x0b\x79\x1c\x1c\x95\xca\x89\x33\xdc\xa8\x41\x71\x53\x2b\x22\x2f\x79\xd9\x1e\x67\xb6\xe7\x3a\x0b\x8b\xdd\x85\xf9\x52\x52\x7c\x58\xfc\xca\x1d\x7e\xdc\xf8\xc4\xd7\xad\xf9\xc4\x71\x97\xe4\x96\xe0\x70\xfc\x2a\x1e\xb9\xa5\xde\x82\xae\x1d\x94\xc4\x1b\xd1\xfb\x62\x1e\x07\xfa\xbc\x61\x71\xdf\x91\x6b\x3b\x0e\xaf\xa3\x07\x95\x55\x26\x2f\xe9\x93\x9d\xe1\x78\x4b\x8f\x66\xf4\x3a\xc3\xe2\xd7\xf4\x38\x73\x71\x11\x35\x57\x44\xc3\x07\xb7\x3c\x04\x6e\xa9\xb7\xc9\xda\x36\x3e\xf9\x38\x83\xed\x70\xf4\x79\x85\xe8\x72\x44\xd6\xd2\x62\x64\xe2\x11\x89\x5b\x17\x5f\x66\xbc\x60\x08\xf1\x82\x21\xc4\x0b\x06\x6b\xfd\x51\x3d\xc9\x6f\xbe\xf6\x7d\xb9\x72\x78\xd3\xf2\x2e\xbb\x2a\x14\x9a\xe2\xe7\x6a\xa3\xe2\x2f\xc4\xa7\x0e\x8f\x4e\xf9\x5d\xd1\xe7\xb5\xf3\xda\x5e\x96\xb6\x7c\x77\xf7\xa1\xc3\x2c\x93\x2d\x8a\x7e\x88\x37\x62\x0b\xcb\x6f\xbd\xfe\xf0\x98\xd7\x7a\xf7\x2a\x17\x15\x7b\xba\xca\x3b\x76\xa2\xf5\x95\x8b\x69\xae\x6f\x2f\xe6\xbb\xbe\xbd\xde\x07\x14\x53\xed\x3c\xaa\x1a\xd1\xf7\x64\x22\xda\x35\xc3\xd1\x82\x42\x7c\x70\xa4\xed\x59\xf4\xbd\x97\xe8\xbb\x31\x53\x9b\x72\x9d\xa9\xfd\xaa\x7e\xfb\x0d\xfd\xf6\xa7\xa5\xf6\xab\xfb\x9d\xef\xf7\xed\xf7\x0e\xd0\xc1\xc5\x52\xf4\x43\xe7\x6e\x3c\x50\x53\x6d\x2e\x4a\x9a\x7e\x35\x99\x7e\xc8\xfe\x20\xfb\x35\xa9\xfd\xaa\x08\x3d\xb5\xdf\xd0\x6f\xdf\xf4\x96\xaf\x5c\x98\xeb\x2a\x4c\x45\xe7\xc7\xc6\x07\xeb\xab\x92\x02\x55\x51\xa5\xd3\x06\xc9\xab\xea\x97\x67\x06\x29\x67\xfa\x95\xcb\x0e\x52\x5f\x76\x90\xfa\xb2\x83\xd4\x97\xed\x57\x5f\xed\x20\xed\xab\x1d\xa4\x7d\xb5\x83\xb4\xaf\x76\x90\xf6\xd5\x0e\xd2\xbe\xda\x41\xda\x57\x3b\x48\xfb\x6a\x07\xb6\xaf\x21\x33\xb0\x7d\x6b\xe5\xf5\x2f\x67\x06\x29\xd7\xbf\xbe\xec\x20\xf5\x65\x07\xa9\x2f\x3b\x48\x7d\x83\x8d\x5f\x4d\xef\x24\x1b\x24\xaf\x7f\xb9\xec\x20\xe5\xb2\xfd\x70\xfb\xd5\xb7\x56\x5e\xff\x72\xd9\x41\xca\xc5\xf5\x45\x5f\xc8\xb2\xc4\x5c\x88\x1f\x67\xea\xa0\xa3\x25\xbe\x19\x7b\x1d\xaf\xd7\xf1\xf5\x8a\x7c\x57\x31\xf2\x94\x5d\x2e\x62\x6b\x97\x8a\xc8\xba\xf1\x32\x11\x79\x3a\x5a\x22\x12\xa7\x90\xdc\xe2\xaa\xbb\xb0\x2c\x2e\x13\x2f\x11\xb1\x17\x2f\x0f\x71\xa1\x8e\x42\x52\xd1\xc8\x7e\x4f\xa9\x47\xf6\x7b\x26\x3d\x62\xed\xa7\xcf\x23\xfb\x3d\x66\xae\x28\xbf\xb3\xa8\x28\xbf\xa6\x70\xfb\xde\x4a\x54\x94\xdf\x41\x8c\xe9\x87\x34\xb5\xad\x69\x4c\x3f\x30\x9b\x35\x7a\x6d\xbc\xb5\x0b\xc5\xf5\xd8\xac\xe1\x65\xd4\xbe\xbd\xde\x0a\x2a\xfb\xb0\xfb\x0e\xf5\x9e\xa6\x93\x32\x3d\x4d\x3a\x39\xb5\xa7\x69\x78\xb9\xee\x28\x3b\x5e\xb7\xad\x33\xac\xf7\xcd\x59\x94\x99\x9c\xdd\xd3\x34\x32\xfd\x7b\x24\xd1\x81\x64\x09\xb3\x07\x92\x1f\x36\x39\xb8\x2b\xbf\x28\xdf\x65\xc3\xcc\x51\x31\x87\xc4\x4c\x03\x36\x2a\x67\xf4\xd1\x62\x42\xc2\xc3\x7b\x77\xe3\x4f\xeb\x8d\xed\x23\xa0\xf2\xc7\xf6\x46\xf4\xe5\xf5\xdb\x8d\x3f\xb1\x37\x2a\x25\x3d\xe2\xdc\x98\xe0\x41\x92\x3d\xf1\x87\xf6\x6c\xd8\x55\xdf\x08\xdf\x4b\xf9\x7e\xe4\xf3\xb9\x07\xd7\x07\xc9\x5f\xc9\xd1\x0e\x75\x46\x3b\xe4\x8b\x2f\xac\x8f\xdf\xeb\x5e\xb5\xcb\xb9\xf7\x46\x76\x65\xc3\x8a\x0b\xe2\xfd\x93\xbe\x38\x25\x3e\x12\xfd\x61\xc8\x65\xce\x91\xf1\xaf\x7c\x8f\x76\x1c\x7e\xbb\x43\xf8\x4a\xbe\xc6\x61\xfc\x3d\xfe\x9e\xf5\xdf\xe7\xef\x5b\xff\x03\xfe\x81\xf5\x3f\xe4\x9f\x5a\xff\x33\xfe\x99\xf5\x3f\xe7\x9f\x5b\xff\x0b\x7d\xb9\x43\xf4\x15\xfa\x0a\x87\xe9\x2b\xf5\xb3\xd6\x7f\x4e\x3f\xe7\x50\xfd\xbc\x3b\xdb\x21\xee\x1c\x77\x6f\x87\x46\xbf\xbd\x64\xfd\x79\xee\xbe\x0e\x73\xf7\x73\xf7\xb3\xa8\x1c\xbf\x29\x4e\x52\x5b\x85\x33\xd5\x59\xe0\x50\xcb\x22\x6d\xce\x88\xd6\xfc\xc2\x2e\x67\x83\xb8\x5c\xf4\xd7\xae\x9c\x3e\x2f\x2e\x1d\x91\x8e\xed\xa3\xe3\x8c\xfc\x27\xbf\x3b\x3e\xde\xd6\x99\x75\xa6\x3b\xa1\x33\xdb\xd9\x37\xfe\x63\x03\x47\x3a\x27\x38\xa7\x3a\x67\x39\xe7\x3b\xd7\x39\x4f\x39\x2f\x3b\x6f\x3a\xef\x3b\x9f\x13\x49\x46\x90\xf1\xb6\x0e\x62\xff\xbf\x6d\xad\x72\x08\x3b\x31\xd9\x67\x57\x25\x96\x1f\x93\xd8\x8a\xd0\x62\xd8\x1e\x8c\xea\x1a\x75\xcb\xe8\xf1\xa3\x5b\x93\xbd\xd1\x17\x8f\xd9\x62\xcc\xf9\x63\xb7\x4e\xf6\xc6\x9e\x3c\xf6\xc5\x71\xd9\x71\xc7\x26\x7b\xe3\x56\xad\x37\x7b\xbd\xdb\xc6\xef\x9e\x9c\x3f\xfe\xb2\xc4\x6e\x78\x68\x62\x27\x8c\x8f\x4b\xe9\x4d\x6e\xda\x74\xda\xa6\xc7\x6d\xfa\xe2\xc4\xe9\x13\x4f\x9b\xf8\xce\x66\xb3\xe2\xdc\xe1\x9b\x1d\xbb\xd9\x35\x9b\xad\x9e\xb4\xc1\xa4\xdd\x27\x2d\x9b\x74\xe1\xa4\xc7\x36\xd7\x9b\xd7\x6c\xde\xba\xf9\x69\x9b\xaf\x8c\x8f\xd3\xcd\x1f\xdb\x42\x26\xf5\x6c\xb1\x6d\x62\x27\x3f\x92\xd8\x6d\x4f\x4d\xec\xf6\x0f\xc4\xbd\x22\x55\x27\xc3\x9e\x6e\xc7\x2b\xb2\x57\x39\x84\x9e\x4a\x3b\x6c\x7a\x86\x1d\xad\x59\xce\xe9\xce\xd9\x76\x54\x2e\x76\x2e\x73\xae\x71\xae\x77\x6e\x71\xee\x74\xee\x73\x1e\xb1\x63\xf4\x82\xb3\xda\x8e\xd2\x1a\xe7\x63\x7b\x92\x24\x95\x64\x0c\xd9\x80\x6c\x42\xb6\x20\xdb\x92\x69\x24\x4b\x76\x26\xf5\x64\x77\x32\x9b\xcc\x23\x07\x90\x43\xc8\x22\xd2\x46\xba\xc8\x32\x72\x04\x39\x9a\x1c\x47\x4e\x24\xa7\x92\x33\xc8\xb9\xe4\x42\x72\x09\xb9\x82\x5c\x4b\x6e\x20\xb7\x91\x55\xe4\x01\xf2\x18\x79\x86\xbc\x48\x5e\x25\x6f\x93\xf7\xc9\xa7\x94\x52\x4d\x47\xd0\x71\x74\x23\x3a\x91\x4e\xa6\x53\xa8\x47\x6b\xe8\x74\xda\x48\x67\xd2\xbd\xe8\xbe\xf4\xc0\xf8\xef\x1d\x9e\x6a\xd3\x71\x71\xba\x32\x4e\x9d\x72\x4a\x5b\x62\xff\xa9\xfe\xf9\xe4\xc4\xfe\x39\x5f\xbc\xd0\xdf\x4f\xca\x10\x9e\x2a\xb9\x49\xff\xb3\x86\x4a\xbf\xb8\x25\x95\xb3\x6c\x40\xda\x2c\xce\xe9\xf3\x87\xaa\xe1\x85\x2f\xab\xf9\x8b\x43\xfa\xfb\x83\xd4\x33\xc4\x98\x90\x55\xfd\xc7\x04\x39\x03\xd0\x31\x0e\xfc\x5f\xe9\xf5\xc0\x3a\x51\xe6\x90\x41\xdb\x4c\x1d\xc9\xbf\x10\x13\x1c\x47\xaf\xd0\x2b\x9c\x4d\xec\x6a\x71\xa5\xb3\xa9\xbe\x5a\x5f\xef\x4c\xd4\x37\xd8\x95\x63\x6b\x77\x0f\xbb\x66\xec\x1e\xdf\x6b\x6f\xc7\xf7\xb9\xb4\x57\x77\x91\x38\xd4\xfa\x13\x9c\xe8\x2f\x71\x4d\xb2\xf3\x34\x5a\x3b\x08\x5b\x1d\xd7\x4a\x6c\x3d\x51\xe9\x0f\x53\xa5\xa3\xfc\xdb\xec\xfd\x4d\x9c\x55\xb6\xf4\x18\x67\xb2\x33\xc5\xf1\x9c\x1a\xbb\x06\x34\x3a\x33\x9d\xbd\xec\x2a\x70\xa0\xb3\xd0\x69\x8d\xff\x14\xc3\x0a\xbb\x1a\x1c\xe3\x1c\x1f\x9d\x47\x17\xf4\xa6\x64\x57\x7a\x9d\xf5\x2f\x67\x75\xb6\x8e\x1b\xe9\x04\x9b\x7a\x51\x8e\xe3\xb1\x15\xbd\x29\xca\x4f\x76\x76\xb6\xe5\x6f\x4a\x9d\x7b\x0d\x3d\xd2\xa6\x97\xd0\xfb\x6c\xfa\x79\x9c\x7f\x2e\xb5\xab\x2c\xbd\x84\xdc\xde\x9b\x3a\x63\x84\x14\x95\x62\x84\x18\x2d\xc6\x25\xbf\xa3\x6b\xc7\xa3\xfc\x9b\x7e\xd1\x2f\xfa\xdd\xa0\x6f\x8c\xfb\xf5\x6e\xb9\x5f\x51\x0b\xec\x4a\x7c\x8f\x43\xed\x08\xda\xbb\x95\x78\xa4\x86\x4c\x27\x8d\x64\x26\xd9\x8b\xec\x4b\x0e\x24\x0b\x49\x2b\xe9\x20\x25\xb2\x82\x1c\x49\x8e\x21\xc7\x93\x93\xc9\x69\xe4\x2c\x72\x1e\xb9\x88\x5c\x4a\xae\x22\xd7\x91\x9b\xc8\x4a\x72\x0f\x79\x88\x3c\x41\x9e\x23\x2f\x93\xd7\xc9\x3b\xe4\x43\xdb\x42\x4e\x2b\xe8\x28\x3a\x9e\x4e\xa0\x93\xe8\xd6\x74\x2a\x35\x74\x47\xba\x2b\x0d\xe9\x2c\xba\x0f\x5d\x40\x0f\xa2\xcd\xf4\x50\xda\x49\x97\xd0\xc3\xe9\x51\xf4\x58\x7a\x02\x3d\x85\x9e\x4e\xcf\xa6\xe7\xd3\x8b\xe9\x65\xf4\x1a\x7a\x3d\xbd\x85\xde\x49\xef\xa3\x8f\xd0\xa7\xe8\x0b\x74\x35\x7d\x93\xae\xa1\x1f\x33\x87\x49\x56\xc9\xc6\xb0\x0d\xd8\x26\x6c\x0b\xb6\x2d\x9b\xc6\xb2\x6c\x67\x56\xcf\x76\x67\xb3\xd9\x3c\x76\x00\x3b\x84\x2d\x62\x6d\xac\x8b\x2d\x63\x47\xb0\xa3\xd9\x71\xec\x44\x76\x2a\x3b\x83\x9d\xcb\x2e\x64\x97\xb0\x2b\xd8\xb5\xec\x06\x76\x1b\x5b\xc5\x1e\x60\x8f\xb1\x67\xd8\x8b\xec\x55\xf6\x36\x7b\x9f\x7d\xca\x29\xd7\x7c\x04\x1f\xc7\x37\xe2\x13\xf9\x64\x3e\x85\x7b\xbc\x86\x4f\xe7\x8d\x7c\x26\xdf\x8b\xef\xcb\x0f\xe4\x0b\x79\x2b\xef\xe0\x25\xbe\x82\x1f\xc9\x8f\xe1\xc7\xf3\x93\xf9\x69\xfc\x2c\x7e\x1e\xbf\x88\x5f\xca\xaf\xe2\xd7\xc5\x73\x23\x8c\x52\x79\x9e\xbd\x36\x6b\x22\x9f\xac\x89\xfd\x55\xb1\xbf\x2a\xf2\xe9\x84\xb8\xcc\x84\xd8\x9f\x1d\xfb\xb3\x63\x3f\x75\xee\x5a\x7e\xba\xcc\x10\xe5\xc9\x73\x71\xfd\xcf\xf5\xc7\xa5\x0b\xe2\x32\x0b\x06\x9c\x7b\x5d\xec\x5f\x37\x00\x6b\x72\xec\x4f\x1e\x50\xbe\x33\xf6\x3b\x63\xbf\x31\xf6\x1b\x07\xf8\x69\xac\x74\xfe\xb4\xd8\x9f\x16\xb7\xed\xa6\xb8\x6d\x37\x7d\x69\x1f\x87\x1a\x87\x2f\xf7\xf5\x80\xfc\x21\xc6\x79\x5d\xc6\x67\xad\x76\xa6\xdb\x76\x5c\xec\x7f\xb8\xce\x7e\xd2\x9e\x53\xbe\xcc\x5f\x6b\x9e\x24\x7e\xeb\x80\xf6\xa7\xdb\x19\x5f\x3b\x32\xa2\x8c\x45\xce\x1b\x50\xff\x7d\xe5\x32\xa8\xf3\xc4\xd8\x7f\xa4\xec\xaf\x55\x67\x5c\x0f\xab\x8c\x7d\x1d\x97\xd9\x35\x55\xe7\x91\xa9\x6b\xba\x60\x08\x5f\x0f\xb8\xd6\xcf\xa5\xda\x96\x1e\x93\xc9\xe9\xb9\x17\x97\x44\x3b\xcb\x69\x32\x03\x71\xbf\x4c\x4b\xa5\x6f\xa6\x70\x53\x3e\xae\xd7\x89\xfd\xfc\x75\x67\x83\xd1\x7d\xbf\x87\x1e\xfd\x1a\xfa\x83\xf1\xaf\xa0\x3f\xc6\x9f\x8d\x7f\xf3\xfc\x65\xbb\x26\x7e\x62\xb5\xa7\xd5\xad\x56\xe3\x45\x7f\x9c\x27\xfa\x83\x7d\x8e\x13\xfd\x3d\x9a\x83\xec\xd6\x6c\xb7\x43\xed\xd6\x69\xb7\x25\x76\x3b\xdc\x6e\x47\xd9\xed\x58\xbb\x9d\x60\xb7\x53\xec\x76\xba\xc5\x38\xdb\xda\xf3\xcb\x73\xf4\xdf\x96\x76\xa4\xe6\xfd\x88\xd8\x3f\xbd\x6f\x1d\x9f\xfa\x7f\xd7\xf1\x7f\x69\x1d\x9f\x1d\x69\x7e\xa4\xd3\x52\xe9\xa2\x72\xca\xf6\x2c\xa7\xe9\xfc\xb5\xd2\x03\xbf\xf4\xe8\x80\x94\x9c\x97\x4a\xd7\xa4\xd2\x54\xfe\x50\xe7\x5a\x05\x52\xce\x69\x4c\xa5\x0b\x52\xe9\x29\xe5\x94\x5c\x53\x4e\xe9\x8e\xe5\x94\xdd\x10\xe7\x7f\xde\xbf\x1e\x96\xf4\xa5\x2d\xf6\x8f\x8e\xcb\xdc\x34\xa0\xfe\x75\xee\x29\xd2\xf4\x59\x3a\x95\xa6\xc6\x7f\xa8\x71\x5e\x97\xf1\x49\x5a\x88\x76\xa6\x71\xef\xfb\x6a\x29\x69\x4d\x8d\x5b\x6b\xff\x91\x44\x9a\x9a\x27\x69\x5c\x36\x3d\x75\x34\x3d\xfe\x23\x52\xe9\x94\x72\x4a\x2f\x2c\xa7\x64\x83\x54\x9a\xf4\x31\xfe\xdb\x58\x64\x55\x2a\x4d\xf7\x3d\x7d\x6e\x6b\xaa\xb5\xe9\xfc\xd4\xb8\xad\x75\xed\x52\xe9\x5a\xd7\xda\xa4\xca\xa7\x47\x26\xdd\xf7\x45\xe5\xbe\xac\x35\x0e\xa9\x76\xa6\xeb\x5f\x6b\x9e\x0f\x4c\xe7\xf5\xf3\xd7\x7d\x1d\xdf\x88\xaf\xe4\x77\xf3\x07\xd6\xfa\xeb\x15\xcf\x0f\xf2\xf7\x2a\xde\xe1\x6b\xf8\xa7\xfc\xf3\xe4\xd7\x9a\x9d\x8d\x9c\x75\x59\xc1\x1d\xac\xe0\xc9\xdf\xe3\xbd\xcc\x6e\xd1\xbd\x73\xbd\xdd\x6e\xb1\xdb\x9d\x76\x8b\xc6\xe5\x11\xbb\x3d\x65\xb7\x17\x6c\x6b\x56\x5b\xfb\xa6\xdd\xa2\xb1\xfb\x38\xba\x45\x07\xdc\x03\xe3\x86\x48\x87\x2a\x33\xd4\x59\x03\xcb\x0f\x95\xe3\x0d\x59\x0f\x8b\x63\x20\x12\xed\x47\xa5\x9c\xe8\xc9\x87\x8d\xfe\xf9\xfb\x96\xfb\x68\xf4\x14\x26\x75\x05\xa2\xb1\xdf\xd4\x1e\x1d\xf1\x65\xbc\x69\x6b\xa4\xb6\xc6\x9d\xe3\x3a\x9d\x7e\x35\xfe\xb3\x73\x07\x47\xfc\x27\x6d\x8c\x67\x86\x13\xcf\x09\x12\xcf\x89\xcd\xfe\xd3\x6d\x1c\x04\x31\x6a\xe3\x4c\xb4\xf1\x90\xb8\xc6\x51\x36\xdd\xf0\x2b\xcc\xcc\xde\x79\x39\xd4\xa8\x57\x0c\x56\xd7\xff\x02\xee\xc8\x7f\x72\xde\xbf\xb5\x05\x83\x5e\xcb\xff\xf7\x5b\x30\xd4\xd8\x53\xc7\xac\x35\x8b\x46\xff\xd3\xd9\xf3\xe5\xf7\x56\xd4\x13\x83\x9e\xcc\x5c\xc7\x1a\x87\xba\x6e\x09\xce\xff\xb0\x8d\x43\xcc\xf4\x7f\xa1\x8d\x83\x8e\x6b\xb9\x8d\x33\x9d\xb6\x54\x1b\xc7\xfc\x8b\xd7\xef\x9f\xcf\x95\xa1\xc6\x3d\x6a\xc1\xc2\x7f\x4b\x0b\x06\x9f\x2b\x5f\x86\xfb\xbf\xd6\xf3\x41\xaf\xe6\xff\x42\xcf\x07\xbb\xf6\x78\x42\x7c\xf6\x7f\xf9\x13\xe2\xb7\xa3\x18\x6b\xa8\x94\x2e\x49\x9e\x18\x0c\x9e\xbf\x56\x79\x27\xe5\x1f\x3f\xe0\xdc\x95\xa9\xf4\x4b\x11\x07\xa6\xe4\xa0\xfe\x69\x3a\x7f\xc8\x73\x9d\x75\x3e\xfa\xe5\x25\x07\x8e\xc9\x7d\xc9\x93\x81\xfe\x39\x83\xd4\x7f\xfc\x80\x11\x58\xf7\x5e\x3f\x37\xc4\xd1\x8b\xa2\x68\x18\x69\x39\x7f\xdd\xb5\x24\xe3\xf7\xf1\xe7\xf8\x4b\xf1\xdb\xad\x48\xd9\x46\x77\xc5\x46\xd1\x53\x92\xf8\x59\xc9\x3e\x71\x7a\x66\xdc\xab\x64\xfe\x9e\xf5\xdf\x3d\x7f\xf9\x46\x71\x8b\x8f\x8e\x5b\x7c\x5c\xd9\x67\xab\x53\x4f\x13\x9e\x28\xe7\xa4\xf3\xd9\xc4\x54\xda\x39\x78\x99\xe4\x79\x4c\x3a\x7f\xad\xf4\xaa\xfe\x88\xec\xc0\x28\x45\xab\x92\xa3\x66\x40\xba\xba\x3c\xd6\xe9\xf6\x23\x3f\xdd\xaa\x54\x9d\x49\x6d\x62\x5c\xf9\xac\xb4\x3f\x30\x1d\x72\x4c\x8e\x4b\xe5\x27\x39\x67\x0d\xc0\x4d\x97\x1f\x6a\x04\xbe\xb4\xd7\x6b\xe1\x1e\x9d\x1a\x8d\x74\x5a\x46\x5c\xf7\xf9\x4b\xf9\x43\xfc\xd1\xf8\x0d\x68\x45\xa2\x83\x48\xf2\xe4\xf0\xf0\xff\x73\xe6\x2c\x5b\x1d\x47\xa0\xbb\xc7\xe9\xc4\x38\x6a\xf9\x30\xf6\xcf\x8d\xfd\x31\x71\x84\xf8\x79\x39\x27\x9d\xcf\x67\x39\x7d\xd1\x77\x72\x6e\xba\x0c\x6a\x7b\xa2\x7f\x3e\xbf\x34\xf6\xe3\xe7\x1b\xf4\xc5\xd8\x5f\x91\x8a\x8b\xd3\xf5\x9c\x16\xa7\x95\x03\xd2\xd5\x29\xdc\xd5\xfd\xdb\x8c\x1a\xd2\xf5\x2c\x2a\x23\xae\xd5\xc2\x74\xba\x7a\x40\x3a\xd4\x98\x2c\x29\x8f\x40\x3a\x67\xa8\xd1\x48\x8f\x40\xba\xef\x18\x81\x81\xbd\x4e\xd5\x89\x36\x4c\x4f\x95\xbf\xae\x9c\x26\x88\x71\xfa\x55\xe6\xec\xfd\xfc\xc5\xb5\xe6\xec\xad\xce\xd6\x36\xbd\xd9\xee\x27\x91\xda\xf4\x94\x3e\x19\xdb\x77\xc6\x3f\xd7\x3c\xc4\x19\x1f\xff\x0d\xca\xe8\x2f\x50\x6a\x31\x4c\x8c\x14\xeb\xeb\x6b\xe2\x77\x61\xd1\x5f\xb2\x8a\xfe\x8e\xd5\x3d\xfa\x7e\xfd\xa0\x7e\x5c\x3f\x15\xfd\x55\x27\x8b\xc6\x9c\x4d\x9c\x2d\x9c\x6d\xa3\x33\x07\xc1\x23\xfc\xb5\x38\x7d\xe5\x3f\x50\xf3\x9a\xff\x70\xcd\xaf\xfd\xc7\x6a\x7e\xfd\x3f\x56\xf3\x9b\xff\xb1\x9a\xdf\xfa\x17\x6a\x8e\x66\xe2\xa4\x21\x66\x62\x52\xef\x57\xaf\x31\x69\x69\x6f\x8d\x51\x4c\x25\x63\x15\x9d\x28\xe8\x35\x6b\x5d\xbf\x75\x2d\xff\x04\xae\xca\x57\xab\x7f\xdd\xcb\x27\xf5\xbf\xb1\xce\xe5\xef\xff\x8a\xe5\xef\xc6\xb5\x5f\xd7\xf2\xaf\xe0\x8a\xae\x6b\xf9\xd7\xbe\x62\xf9\xbb\xbf\x62\xf9\xfb\xbf\x62\xf9\x27\xbe\x62\xf9\x27\xbf\x62\xf9\x35\xa9\xf2\x93\xec\xca\x4a\xed\x9d\x31\x01\x67\xac\x97\xaa\xf1\x29\xa7\xf7\x13\x12\x44\x8c\x5e\xc7\xd2\xef\xa2\xf4\xff\x21\xda\xc2\x6a\xb0\x53\x7b\x3f\xe5\x61\x95\x55\x94\x9e\x96\xca\x39\x3a\x95\xc6\x39\xbc\xa6\x7f\xce\xc0\x14\x75\x0e\x38\x77\x90\xf4\xa1\x54\x9a\x42\xe4\xb3\x52\x39\x9d\x03\xd2\x54\xfe\x5a\x58\x43\xa1\xa4\x52\xf1\x54\xb9\xfe\xb4\x9f\xd4\x93\x4e\x87\x1c\x93\xab\xca\x39\x28\x79\xd5\x3a\x8c\xc3\x10\x7d\x4f\x63\xa5\x5b\x32\x48\x3d\x89\x7f\xc4\x80\x71\x58\xfd\x95\x3e\xf1\xd3\xfb\x24\xab\x4f\x5b\x24\x9f\xe4\x41\x9a\xcc\xd9\x55\xff\xdd\x73\xf6\x2b\xbf\x5f\x4b\xbf\x0b\x9b\x92\xf2\xbf\xf4\x4d\xe2\x50\x67\xfd\xe7\xd2\x75\x6f\x0f\xde\xbd\xee\x53\x4e\xbf\x32\xe2\x75\xeb\x3a\x1a\xff\xf3\xbe\xaf\xf5\x56\xab\xfc\x8e\x6f\xdd\xe7\xec\xbf\xf2\xf4\x6d\x43\x8b\x10\xa1\x47\x6f\xef\xba\x9c\xe8\x73\xb7\x8e\x73\x84\xdd\x22\x85\x7e\x9c\xdd\x4e\xb4\xdb\xa9\x76\x3b\xc3\x6e\x91\x9a\x8f\xde\x0a\x5e\x62\xb7\x2b\xec\x76\xad\xdd\x6e\xb0\xdb\x6d\x76\x8b\xde\xda\x3d\x60\xb7\xc7\xec\xf6\x8c\xdd\xa2\x68\xe8\x55\xbb\xbd\x6d\xb7\xf7\x6d\x4f\x76\x8c\x38\x66\x9d\xd2\x0d\xd6\xb9\xe4\x57\x4c\xed\x3d\x19\xa5\x1f\x97\x53\xdc\xc7\x57\xfd\xb7\xdf\xc7\x71\x0c\xde\x38\x20\x5d\x97\x4f\x7c\xa4\x4a\x26\x4f\x49\xfe\x0d\x9f\x22\x59\x77\xf4\x2f\x4d\xff\x49\x7b\xae\x1b\xc2\xff\x1f\xa4\xe4\xc4\x7f\xff\x68\x24\x75\xf6\x7e\x06\x2c\xae\xf9\xa1\x72\x9a\x2a\xb9\xee\xf7\xf1\x97\xbf\x13\x89\x9e\x2e\x46\x9f\xbd\xd8\xd5\xf9\xaa\x9f\x30\xea\x7d\x1a\x37\x54\x7a\x71\xca\xbf\x33\xf5\x3c\x69\xe8\xb3\x3a\x9c\xff\x1f\x70\xe1\x3f\x59\xb5\xd7\xac\x43\x99\x13\xcb\xbe\xb3\xf2\x7f\x83\x23\x87\x6c\xc9\x50\x9f\x71\xf9\x0f\xa7\xff\xa6\x5e\xff\x7f\x82\x0b\x59\x67\xc4\x3d\x2c\xba\x3f\xcb\xfe\xc0\x34\x3a\x7a\xd5\x10\x65\x56\xc7\xe9\x9d\xa9\x74\xe8\x7a\xfa\xd7\x39\x04\x6e\xf4\xed\x0d\xb2\xab\x53\x7e\xaa\x16\xc7\x84\x9f\xbd\xd8\xfb\xff\xf3\xce\x41\x62\xc4\xa8\x4c\xf4\xbf\x32\x8e\xeb\x56\x7e\x51\x83\x38\xcf\x71\x92\xef\xcf\x4c\xb7\xe3\x99\xfe\xfe\xcc\xe4\xe8\x1a\xee\xb9\x47\xe3\x44\x67\xd4\xdc\x7d\xea\x6d\x8a\x6f\xd0\xd0\xbe\x6f\xd3\x24\xdf\xc1\x61\x4d\x4d\xed\xb6\x55\xcd\x6d\x85\x16\x67\x42\x5b\xb1\xa9\xcd\x46\x94\xd1\xd5\xa7\xf8\xf6\x50\xef\x37\x74\x84\x45\x1e\x67\xa3\xcc\x2d\x9c\x29\xc8\xdb\x1a\xdf\x99\x99\x02\xbb\x73\xf4\x69\xf5\xf8\xb9\x6f\xbc\x4f\xa3\x16\x4a\xb1\x24\xf2\xd9\xf3\x36\x1d\x93\xf4\xdc\xe1\xd1\x77\x84\xc4\xb0\xb8\xfd\xb6\x45\xe4\x0c\x3b\x1b\x6a\x9c\x7a\xbb\xa6\xed\xeb\x1c\x62\xd7\xd3\x92\x9d\x09\xc7\xda\xf5\xed\x3c\x7b\xc5\x6f\x70\x9e\x70\x5e\x8c\xbe\x78\x43\xc6\xd9\x55\x6c\x6b\xe2\xd9\x15\x2c\x24\x7b\x91\xe8\xfb\x2c\xdc\x9d\x67\x47\x70\x4d\xec\xcd\xef\xf3\xf6\xed\xf3\xe6\x5a\xef\xdd\x18\xef\xf6\x3e\x6f\x65\x9f\x77\x47\x9f\x77\x67\xec\xd9\xf9\xee\x54\xea\xa7\xac\xff\xb6\xbe\xab\xef\xd8\xaa\x3e\xef\xee\x54\xa9\x7b\x22\x5f\x5f\x6e\xd3\xd7\xe2\xef\x5b\x8d\x70\xc6\xd9\x7b\x81\xf2\x57\xdc\x3d\x6d\xfa\x96\xbe\xb7\xef\xac\xfb\x62\x2f\x2a\x33\xca\x19\xef\xee\xe1\x30\xfe\x2e\x7f\xdb\x9d\x15\xa3\xdc\xdf\x57\xea\x81\x3e\xef\xc1\x3e\xef\xa1\x3e\xef\xe1\x3e\xef\x91\x3e\xef\xd1\x3e\xef\xb1\x3e\xef\xf1\xd8\x53\x16\x69\x03\x67\xa2\xbd\x3a\xd3\x9c\xac\xb3\xb3\xbe\xd9\x62\x7e\x64\x5b\x7b\x73\x8c\xfd\x91\xbe\xc9\xda\x0f\xed\xfe\x4d\xf1\xfe\x87\xfa\x89\xb8\x2f\x37\xda\xf4\x23\x7d\x83\x4d\x3f\x8c\xeb\x7a\x12\xbd\x55\xf6\x2e\xb6\xf7\x93\x5d\x09\x84\xc3\x84\xb2\x57\xad\x42\x0c\x17\xc3\x9d\x91\x62\xa4\x18\xe5\x8c\x12\x63\xc4\x58\x67\x8c\x58\x4f\x6c\x18\x7f\x4e\xc9\x89\xe7\xf2\xa4\x78\x4e\x44\x73\x24\x9a\x07\xc2\x9e\xeb\x88\x0a\x31\x56\x44\x9f\x0f\x62\xf1\x4a\xf0\xfe\x90\x9f\x88\x98\x69\xe7\xd9\x28\x5b\xc3\x14\xdb\xf6\x5d\x31\xda\xb7\xc6\x63\x7a\x8b\x4d\xdf\x8c\xdb\xf6\x74\x14\x31\xc6\xde\x33\x7d\xde\xb3\x7d\xde\x95\x28\x97\xc6\x75\xfe\x9f\x00\x00\x00\xff\xff\x8d\x59\x6d\xda\x40\xc8\x04\x00") + +func liberationmonoRegularTtfBytes() ([]byte, error) { + return bindataRead( + _liberationmonoRegularTtf, + "LiberationMono-Regular.ttf", + ) +} + +func liberationmonoRegularTtf() (*asset, error) { + bytes, err := liberationmonoRegularTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationMono-Regular.ttf", size: 313408, mode: os.FileMode(420), modTime: time.Unix(1459927770, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationsansBoldTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xbd\x67\x7c\x54\xd5\xf6\xc7\xbd\xf6\x39\x53\x43\x42\x26\x3d\x10\x60\x26\x84\x04\x90\x12\x20\x0c\x4d\xca\x00\x49\x08\x45\x09\x3d\xa1\x06\xa5\x2b\x82\x04\x7b\x01\x14\xa5\x0b\x76\xbd\xa2\xa0\x57\xbd\x8a\x28\x41\x51\x8a\x5c\x45\x04\xb1\xa1\x54\x41\x44\xc1\x50\xa2\x82\x82\x0a\x16\xca\xcc\xf3\xdd\x67\x26\x18\x50\xef\xbd\xcf\xff\xf3\xbc\x7b\xb8\x77\x65\x9f\xb3\xf7\xaa\xbf\xb5\x76\x3b\x41\x15\x25\x22\x09\xfc\xb0\x49\xb3\xfc\xfc\xfe\x57\x8c\x4c\x3d\x6b\x88\x7d\xcc\x54\x7a\x6b\x75\xcb\xcd\xcb\xbf\x23\x38\xb5\xb9\xd8\xe3\x73\x79\x9f\xdd\xad\xb0\x77\xbf\xc2\xde\x71\xcb\xc4\x9e\xb6\x58\xa4\xc7\x67\xdd\xfa\x0d\xe8\xd2\xbb\x4f\xd3\xea\x8c\x7f\x2c\xe2\xda\xd6\xbb\x5f\x76\x0b\xb5\xe3\xe3\x55\x22\x6a\x0d\xfc\x25\x57\x4f\x1c\x39\x39\xfe\xb1\x21\x9b\x44\x2e\x9b\x29\xe2\x68\x7a\xf5\x8d\x53\x7d\x13\x47\x5c\xf3\xb4\x48\xfb\xdf\x44\x8c\xd9\x63\x26\x8f\x9d\x78\xe7\xc8\x37\xe2\x44\x9a\x21\xe3\x5c\x35\x76\x64\xe9\x64\x89\x93\x6a\xe8\x6b\x89\xbc\x67\xec\xb5\xb7\x8c\x59\x3f\xf8\xf1\xaf\x44\xc6\x9e\x14\x5b\x7a\xe3\x71\xa3\x47\x8e\x92\xef\x67\x7e\x8a\xfe\xf6\x8c\xb7\x1a\x47\x47\xf5\xd4\x98\xfb\x78\xd7\xfe\xd6\x1b\x37\x71\xea\xcd\x7b\x6e\x99\x74\x37\xba\x53\x45\x1a\x5c\x7b\xcd\xe8\x29\xd7\x85\x3e\x69\xb8\x44\x6c\x73\x6a\x89\x24\x0d\xbe\x76\xd2\xd5\x23\x93\x6f\x88\xc1\x97\x4e\xd3\x19\x9f\x3c\x71\xe4\xcd\x93\xab\xe7\xd8\xb1\xa5\x1e\x43\xde\x77\xdd\xc8\x89\xa3\x17\xb5\x2d\xdd\x23\xb6\xa7\x6e\x16\xa9\xf6\xe4\xe4\x49\xa5\x53\x67\xfd\xb6\xbc\xbd\xd8\x96\xa1\x6f\x5c\x8d\xc9\x53\x46\x4f\x9e\xfb\xb4\x6d\xad\x48\x9b\x71\x00\xb6\xc8\xc2\xce\x10\x79\xf1\xeb\x63\xcd\x46\xc4\xb6\x3f\x6d\x78\x5d\xa2\xff\x7c\xfc\x60\xed\x82\xca\xf6\x5c\xe6\xb9\xf3\x51\x93\x5c\xb9\xf0\xea\x41\x65\x31\xf0\xd3\xd9\x31\x78\xa5\x74\x8d\x5a\x76\x2e\xf3\xcc\xad\x51\x93\x22\xfd\x17\xfe\x44\xa5\xe9\x9e\xa8\x34\xd5\x57\xfa\xcb\x50\x71\x60\xc5\x23\xd9\x3c\x89\x79\x85\xd9\x9f\x5c\x29\x31\x6d\x07\x8c\xf5\x62\x17\xb1\xff\xc3\x9e\x83\xca\xb4\x70\x6b\x6e\x97\x31\x46\xbc\xcb\x6e\x54\x73\xda\x0c\xfd\xc7\x76\x50\xa2\x42\x85\x72\x73\x08\xb5\xe9\x5a\x77\xf3\xce\xfd\xba\x8a\x4f\x7c\xa1\x73\xf6\x9d\xc1\x3e\x2a\xc7\xd9\x51\xbd\x5a\x22\xea\xed\x03\xbf\x12\x53\x3b\xfb\x0c\x8d\x84\x54\x77\x88\x6c\xd5\xdc\x46\xdb\x08\x2d\x93\x77\xcc\x8f\x64\x96\xad\x54\x32\xa0\x34\x67\x6d\xc9\xb1\x6f\x91\xc1\xaa\x42\x26\x32\x36\x06\x32\xcc\xda\xe2\xb0\x2d\x97\x81\xf0\xcf\xe3\xbd\xd0\x6a\xdb\x4a\x22\xfc\x7d\xa0\x19\x50\x37\x28\x1b\xf2\x42\x9d\xa0\x9e\x50\x11\xd4\x59\x8f\x21\xb3\x19\x7a\x57\xeb\x80\x06\x58\xed\x21\x19\xee\xdc\x2a\x37\x60\x4b\xdb\x9b\x03\xf5\xb7\xda\x81\x32\x87\xb1\x39\x8e\xb6\xe1\x77\xec\xcc\xd1\x7a\xf5\xb3\xd5\xbf\xcc\xe2\x0d\x8f\x0f\xfc\x83\x8f\xe7\xcb\x19\x4f\xe1\xf9\x36\x9e\xab\x3b\x17\x88\x41\x1b\x0f\x65\xd0\xdf\x01\xfb\xa5\xe8\x4a\xa2\xad\x81\xfd\x26\xb6\xd2\xd0\x71\x9e\xbb\xa0\xbb\x3d\xe3\x3a\xfe\x42\xda\xfe\xba\xa5\x3f\xc3\x7a\x3e\x24\x0b\x91\x81\x42\x07\xe9\xb7\x9e\xc1\x67\x96\xc5\x7f\xc8\xe2\xd7\x6d\x7f\xb3\xb6\x25\x5f\x60\xe9\x3e\x24\xd3\x78\x76\x39\xda\x86\xce\xd0\x56\x87\x3c\x36\x91\xbe\xf0\xa4\x1b\x1d\x64\x31\x6d\x23\xec\xf7\x89\x60\xbf\x91\xf1\x1c\x28\x09\x6a\xab\xe5\x34\x0f\xad\x9f\x31\x8f\xfd\x88\xf8\x8c\x5f\xb4\xaf\x32\x14\x99\xfe\x1a\x7b\xdd\x67\xbb\x26\x74\xc2\xcc\x91\xc1\xb6\x51\xd2\x9c\xbe\x1c\xa8\x31\x34\xc8\xb6\x58\xee\x8d\xe0\xbd\x00\x2a\x81\xfa\x1a\xc7\x2d\xf9\x61\x8e\xe5\x32\x3c\x42\x63\xf1\x71\x4a\x04\xf7\x3f\x11\xc5\x6c\xb3\x72\x31\x30\x9c\x8b\x4a\x02\x83\xbd\xf8\x3c\x8e\xf6\x25\x68\x0f\x3c\xae\xca\x3c\x5c\x4a\x3a\xbf\x91\xbc\xdc\x76\x11\x91\x8b\x48\x7e\x17\xe2\x53\xcb\xbf\x22\xf0\xed\x62\xe5\xe2\x12\xc2\xe6\x06\xec\x4f\xa1\x7d\x59\xfb\x52\x05\xff\xc2\x3f\x11\xb8\xd0\x2a\x2b\x17\x55\x49\xe7\x22\x6c\xdb\xa3\x63\xd5\xb9\xff\x8b\xd6\xaa\x81\xff\xd0\xce\xb1\x6f\xb0\x62\x73\xe9\xdc\x5b\xf1\xe8\xfe\xff\xd2\x5a\xb8\x1c\x8a\xe0\xf3\x17\x6d\xa4\xbe\x17\xd2\x56\xa7\x8d\x22\xc6\xc7\x23\x74\x3c\x42\xeb\xa1\x7f\x83\x41\x11\x94\xa7\xe7\x05\x74\xbf\xa3\x9b\xa5\x5f\xc7\xe4\x65\xfc\x79\x4b\x4f\xf8\x7d\xa1\x9e\x2f\xf0\x4c\x88\xb4\xd6\xbb\x99\x14\x69\x77\x5b\xad\x5e\x03\xe2\x23\xb6\x67\xfd\xa9\x7d\x29\xf4\x9d\xfd\x03\xb9\x47\x3f\x47\xfc\x2c\xbc\xb4\xa5\x5e\xfa\x33\xd7\x2c\x5c\xf4\x3c\xb8\xa4\x6d\x63\xcd\x4b\xe6\xc6\xdf\xb5\x7a\xce\x46\xe6\x4d\x0a\x3e\xd5\xa8\x7c\xd7\xf5\xa2\x73\xf6\xbf\xb6\x7a\xbe\xeb\x39\x67\xcd\x77\x9d\xdf\xc8\xbc\xd7\x73\xef\xd2\x96\x98\xef\xd3\x18\x3b\x56\xb2\xca\x6e\x88\xc4\xba\x81\xc2\x07\x0f\xf4\xb5\xa9\x92\x6b\x97\xe3\x35\x8b\xa7\xc8\x5a\x0f\xf6\x59\xf9\x2c\xb4\x7f\x4a\xbe\x4c\x19\x6e\x3b\x14\x5a\x05\xdf\x0b\x56\xad\xa7\xb2\xe6\x4c\xb1\xd6\x08\x8d\xb5\x54\xe6\x21\xb2\x4e\x7a\x9c\x27\xf4\xba\x05\x7f\x04\x4b\xc7\x4e\x64\xca\xa4\xd0\x99\x4a\xfb\x33\x78\x76\xb6\xec\x2f\x8c\xcc\x37\x5d\xf3\xfd\x6d\x5b\x65\xb0\xf1\xb5\xa4\x46\xf0\x91\x4a\x9c\x1c\xff\x64\x2e\x7d\x24\xd3\x1c\x13\x64\xbc\x8e\xdf\xd1\x30\x1c\x33\x63\x2d\x89\x2f\x40\x5b\x13\x2a\xb0\xb5\x92\x06\x50\xeb\xc8\xfa\xdc\xc1\x3c\x23\x71\xb6\x67\x58\xa3\xf5\xba\xd6\x41\x9e\x35\xcf\xca\x2b\xb6\x97\xc1\x83\x3d\x20\x8a\x75\xd5\x8d\xcf\x2e\xe2\x74\xe3\x83\xb3\x16\xfe\x13\x4f\x54\x3b\xfa\xc4\x7a\x9f\x55\x39\x47\x22\x6b\xc0\x2b\x95\x35\xf0\xbf\xe6\x28\x82\xe9\x45\xf3\x4d\xaf\x37\x7a\xce\x47\x74\x65\x5e\x34\x1f\xc0\xef\xd2\x7a\xb3\x62\x6b\x25\x89\xd8\xff\x57\x55\x9f\x2b\xe5\x5c\x5d\xc1\xaf\x6f\x78\x8f\x88\xd4\xf2\x5f\xd9\x51\x91\xfe\xe8\x0b\xfe\x84\xe7\xa9\xaf\x72\xbe\x1a\x6d\x83\x07\xa1\xef\xb0\xf3\x31\xf4\x61\x44\xae\xa0\x4a\xcc\x33\xcd\xda\xa1\x17\x22\x75\x7e\x4d\x24\xc6\x5e\x17\x62\xbe\xb4\xbe\x9f\xa2\x0e\x1a\x4a\xd7\x0b\xf3\x7c\x89\xcc\xa7\xb6\xfa\xdb\xa3\x65\x24\xd4\x3f\x52\x9b\xb9\x97\xf8\xf3\xa7\xf9\x76\x69\x5b\x59\xef\x66\x30\x14\x74\xbc\xc4\x7a\x18\x2d\xb1\x7a\xbf\x72\x3e\x2d\xc3\xa0\xfe\x91\x75\x5d\xd7\xb3\x5b\xd7\xbc\xf6\x87\xe7\xde\x96\xad\x86\xd2\xd2\x3c\x20\x8d\x18\xd7\xf5\x9a\xa8\xf7\xcd\x88\x5d\x77\x64\x3d\x39\xe8\xc8\xb9\x90\x0f\x21\xce\x34\xc6\xc5\xaa\xb5\xd2\xd0\x89\xc8\x1e\x79\x4f\x64\xff\x6c\xaf\xf7\xaf\x48\x9f\xb6\x97\x6f\xf9\xdf\x59\x0a\xa9\xbb\x3c\xc8\x6f\x9f\xc5\xde\x37\xd7\xaa\xb7\xd8\x0b\x7c\x65\x56\xad\xbb\x6c\x9f\x58\xbe\x4d\xb3\xd6\xe7\xf0\xbe\x9b\x0c\x5d\x6b\x76\x94\x5c\xe3\x05\x6a\xff\x73\x9d\x73\xc6\x76\x59\x7b\xf0\xb4\x08\xb1\xfe\x87\x9e\xb3\xec\x1f\x93\xf9\x16\x2e\x2f\x41\x1b\xa5\x8f\x3d\x84\xdd\xda\xe2\xad\x42\xb3\x22\xb4\x10\x8a\xb2\xbd\x24\x73\x2d\xb2\xf6\xed\xd0\xc1\x08\xad\xb5\xf5\x91\x5a\x3a\x5f\x91\xb9\x96\x68\xfb\x8d\xb3\xcc\x0b\x17\xed\xe9\x1e\xdb\xfd\x60\xa8\xf1\x9b\x2c\xb9\xba\x16\xa1\x9a\xf4\xeb\x7d\xab\x6f\xa4\x0d\xd7\xe3\x31\xfc\x25\x5e\x2b\x46\xd6\x5b\xf3\x25\xeb\x7c\x64\x9a\x4f\xc9\xec\x08\x46\x9a\x77\x90\xab\x13\x6b\xe8\x1c\xe6\xdd\x0a\xe4\xee\xc2\x6e\xbe\xd4\x70\x3c\x06\x9d\x92\x0c\x87\x9f\x5a\x99\x8b\x9e\x3c\x49\xb6\xdd\x25\xb3\xed\x9f\x49\x5d\x4d\xc6\x8f\xd2\x08\x6a\xac\xee\x13\x9b\x61\x93\x56\x50\x5d\x28\xd6\x14\xea\x27\x3b\xf4\x8b\x51\x1e\xfa\x55\x9f\xe1\xf4\xd9\x2e\x72\x5e\x9b\x17\x39\xbf\x95\x6b\x82\xaf\xad\xa6\xc8\x99\x4c\x53\x53\x4d\x8c\x49\x98\x54\x35\xda\x7a\xd0\x9d\x61\xb2\xde\xeb\x42\x9d\xa1\x37\xa1\x75\x11\xd2\xfa\xbe\x86\xfe\x51\x85\x12\xc0\x72\x0b\xed\xfb\x50\x7d\xa8\x17\xef\x3f\x41\xcf\x42\xbb\x79\x37\x8d\xef\x43\x67\x54\xba\x34\x37\x0d\xce\x30\x3f\x84\x82\x96\x3f\x1e\x79\xe4\x52\x82\xf7\xaa\x30\x85\x8e\x58\xe7\x32\x91\xbb\x69\x67\x45\x68\x73\x84\x1e\x0e\xfb\x15\x7a\x3b\x42\xa7\x22\xfd\x2f\x56\x25\xb3\xa9\xd4\xd1\xc4\x73\x3b\x91\xf3\xbb\x45\x82\x23\xa1\xfb\x45\xce\x0d\xa7\xe5\x5c\x7c\x9e\x4a\x0b\x3e\x25\x12\x2a\xa5\x7d\x13\x8a\xe5\x39\x40\xdb\x38\xcc\x17\x7a\x03\x6a\x13\x79\xd7\xbc\xcb\x79\xbf\xee\x0f\x92\x44\xda\x86\x11\xe2\x6e\x15\x2a\x81\x67\x16\xed\x71\x68\x01\xd4\x3d\x42\xdd\xe8\xef\x47\x9b\x1c\xbe\x17\x58\xf6\xd6\x85\x6d\x85\xee\xe1\xf9\x2c\x6d\x41\xd8\x9e\x96\x0f\xae\x0c\xdb\xb7\x68\x49\xc4\xf6\x6d\x10\x77\xa6\xf3\xaf\xd3\x6e\x8e\xbc\xe3\xf3\x79\x2d\x53\x07\x59\x8e\xfa\xa1\xf9\x11\xfb\xf8\x12\x2c\xa3\xcd\x86\xb8\xe3\x9d\x67\x57\x0b\xf6\x0d\xdb\x0e\x2e\x0d\xfb\x1e\xd4\x63\xff\x8c\xd8\x8b\xe1\xb9\x43\x44\xee\x19\xe8\x48\x98\x2f\x18\xa4\xaf\x17\xf2\xf8\x1d\x9a\x14\x8e\x29\xf8\x6e\x44\xef\xa4\x30\x05\x0f\xd0\x72\x77\x13\x1d\x43\xd7\x08\x46\xcd\xa1\x7e\x7f\x4f\xc1\xfb\xc2\x31\x86\xb4\x8d\x85\x91\x78\x5f\x89\xd8\xc6\xd7\xf3\x27\x18\x6b\x0a\x5d\xc6\x3b\xf7\xbc\xe0\x6c\x72\xf8\x39\x34\x18\xfa\x34\xb2\xf6\x14\x5a\x7b\x13\xf7\x0c\x68\xad\xb9\x46\xae\x63\xcd\xd2\xf5\xbb\x99\xbd\xb6\xa9\xb3\x93\xd4\x33\x3f\x94\x7a\x8e\xc7\x43\x47\x9d\xd7\xc8\x74\xc7\xaa\xd0\x36\xd6\xb7\x17\x2b\xef\x1f\xb6\x4f\xad\x73\x5d\xbf\xc8\xf9\xb4\x43\xe5\xd9\x56\xef\xe7\x91\xfb\x45\xf5\xca\xbb\x87\x3d\x2b\x3c\xbf\x2f\xdc\x57\xd8\xa7\xad\xbb\x07\x6b\xb1\xe3\x7e\xe9\xa4\xef\x1d\x8e\x5b\xa4\x84\xfd\xb9\x9f\x75\x56\xd6\x6b\xf4\x31\xd6\xa3\xc5\x72\x05\x7c\xd7\x58\x77\x1a\xbd\xa6\xd0\x67\x2b\xe7\x2c\xa2\xd7\xbf\x7d\x32\xd0\xfc\x58\xae\x30\x57\xb0\x26\xc0\x63\xeb\x47\x6c\x9a\xef\x46\xeb\x2c\xe7\xb6\x1d\x91\x45\xb4\x62\x2e\xb2\xc6\x0b\x1d\x3e\xb9\xcc\xf6\xb3\xdc\xc2\x9e\xd2\xdb\x7e\x0b\xba\x1f\x90\x78\xad\xd3\xbe\x16\x9d\x4f\x48\x8c\xc3\x29\x33\xf4\x3a\x88\xfd\xcf\x2d\x5b\x7a\xef\xa4\xd5\x7d\xd8\x1c\xcb\x73\xaa\x3e\x37\xb8\x0c\xf1\xea\x56\xaf\x97\x8c\x5d\x69\x1f\x2f\x89\x55\xf6\xb8\xdb\x23\xf7\xa2\x39\x7a\xcd\x72\x98\xac\x5f\xed\xa5\xb6\x63\x12\xb6\xca\xc5\xcb\x99\xe6\x11\xd6\xe0\xf1\xec\x65\x77\xc0\x33\x97\xf6\x7e\xdb\x1e\xf6\xd4\x81\x32\xd0\xa2\x7a\xdc\x55\x76\x71\x9f\xf8\x1a\x7d\x4b\xb1\x5b\x9d\x7d\x6a\xa6\x34\xd0\x36\x6c\x3f\x82\x59\xf8\x5c\x7f\x50\xdb\x33\x77\x11\xc3\x2e\xd6\xed\x81\x17\xce\xc1\xfd\x2d\xbc\xf5\x1a\xfa\xb3\xb5\x5f\xb7\x89\xdc\x11\xdb\x58\x67\xa4\xc1\x9c\x49\x92\x58\x87\xe7\xf0\xbc\xd2\x3a\x87\x5f\x6e\x9d\xbd\xfc\xa1\xdd\x7a\xef\x72\x6d\x10\x97\x6b\x3a\x3c\x02\x4f\xb9\x95\xdb\xd9\xb6\x33\xa1\xdf\xf5\x79\xcf\xca\xf9\x86\xc8\x19\x41\xcb\xbf\x66\xdd\x13\xe7\x38\x2f\xe7\xfc\x68\x4a\x53\xcd\x6b\xf1\x6b\xb9\x27\x59\xf7\xab\xde\x39\x37\x44\xee\x44\x5b\x2c\x8c\x52\x6c\x67\x44\x39\x76\x49\x37\xeb\xae\xb9\x97\xfe\x25\x72\x9d\x2b\x8a\x33\x49\x7d\xf8\x4f\x4b\xb2\x73\xb7\x65\x5b\xfb\xd8\xca\x15\xb0\x9e\x33\xac\x7a\xfd\x91\xf3\x23\xb1\x99\x03\x88\x35\xd1\xba\x27\x16\xda\x97\x73\xaf\x63\x9f\xa4\xff\x3e\x8b\x94\xdc\x67\x4f\x92\x24\x0b\x83\xf0\x79\xbd\x30\xd2\x5a\xf7\x55\xf3\x98\xb4\xb3\xce\x96\x62\xed\x3b\xd5\xad\xfd\xe6\x39\xe9\xc7\x1e\xb8\xd0\xb1\x01\xbd\xbb\x25\xcb\xa1\xf9\x75\xff\x35\xd2\xd2\x7a\x7e\x29\x14\xba\x70\xaf\xe2\x3c\xa0\xed\x33\x56\x68\xed\x83\xfa\xae\x1b\x08\xed\xb3\xce\x0f\x1b\x24\xc9\x19\xb0\x6c\x45\x69\x3f\x2c\x7f\xf4\xde\x87\x8e\xa8\x0e\x52\xec\x68\x27\xd1\xec\x4f\x59\xc4\x9b\xe5\xfc\x84\x58\x87\xcb\xfd\xf6\x81\xa1\x73\xba\x96\x9d\xe3\x78\x1f\xcb\xdd\xe4\x16\x19\x40\x1d\xde\xe1\x7a\x0a\x6c\xf7\x32\x6e\x5a\x67\x81\x5c\x6b\x6e\x38\xe5\x86\x0b\x67\x99\x7b\x38\x77\x34\x06\xe7\x48\xeb\xfa\x85\xfd\xf0\x23\xfa\x67\x52\x97\x35\x25\x43\xdb\x73\xfa\xa5\xb0\xd2\x2e\xd8\x5f\x6d\xf9\xbf\x5c\xd2\x58\x0b\x9e\x86\x58\xb7\x42\xf7\x86\xe9\xfc\x07\xac\xe7\x99\xd0\x35\x56\x0e\xf1\xdb\x3a\xdb\x1f\x0b\xe7\x58\x63\x67\x1e\xa1\x9e\x1f\x24\xb6\x39\xcc\xa7\x01\xdc\x15\x96\xd0\xff\x01\xe7\x0a\x9d\x7f\x72\xa0\x6b\xc0\xca\x03\xf9\xb7\x62\xff\xa3\x15\xda\x6a\x8e\x14\xf6\xfb\x73\x92\x69\xd5\x0f\x78\x38\xdd\xe4\xf5\x0d\x59\xe8\x36\x88\x73\x84\x55\xbb\x97\xdb\x96\xc8\xe5\x95\xf7\x08\xeb\x6e\x13\xce\x95\x58\x73\x3d\xd2\xea\x9a\xd1\x79\x73\xec\x90\x54\xfb\xdd\xd4\x1d\xb5\xa3\xf3\x57\xa5\xb5\xe6\x82\x63\x9f\x54\xb3\x4f\xc4\x6e\xa4\xd5\x75\x7e\xc1\xd7\x27\xe1\x79\x9f\x18\xa9\x53\xab\x56\x22\x3e\x5d\x68\xc3\xba\x86\x55\xce\x25\x9d\xe3\xbf\x3b\x83\x5f\xb8\xb3\x7e\x1a\xb9\xff\x44\xda\x4b\x71\xd1\xad\x3e\xf7\x54\xc1\xd7\x6a\xff\xf6\x8c\x4a\xed\xeb\xfa\xd3\x73\xc5\xaa\xa1\x4b\xda\xca\x78\xf5\x5c\xd4\xf5\xa8\xe7\x8c\x55\xab\x95\xf9\x89\xe0\x74\xa1\xdd\x20\x03\xac\xb3\x7e\x47\x19\xec\xbc\x95\x5a\x79\x59\xfa\x38\x36\xc9\x15\xf6\xae\xac\x31\x3d\xe4\x0a\x57\x4d\x6a\xf0\x39\x49\xd2\x77\x01\xe7\x98\xc8\x1d\xa2\xcc\x5a\x33\x53\xec\x4f\x48\x3b\x7d\x77\xd3\x67\xd2\x4a\xcc\x2a\xef\x0e\x95\x77\xc8\xf0\xbe\x27\x8d\x68\x27\xd2\x0e\xd7\xdf\x3c\x79\xbe\x12\x1a\x47\xad\xe9\x73\xc3\x9a\xc8\xbe\xdd\xf0\x8f\x6f\x7b\xba\xef\xfc\x2f\x91\xfe\xa1\x91\xfd\x5f\xef\xe1\xc8\x87\x26\x84\xc7\x43\x57\x85\xc7\x82\x89\x91\xf1\xe1\x61\x1e\xfd\xe7\xfc\xb2\xc8\xb9\x81\x7d\x3a\xb8\x13\xfa\x29\x4c\xfa\xdd\xda\x8b\x3b\x44\xf4\x0e\x8d\xf4\x69\x8a\x8f\xb4\x1f\x70\x56\xba\x47\x8f\xd9\x66\xa8\x53\x95\xe3\x7a\xef\xab\x7c\x36\x87\xcb\x3f\x30\xe2\xb7\xdf\x40\x9e\xbd\xd2\x97\xbb\x76\x27\xf6\x80\x86\xf6\x71\xf2\x98\x31\x41\x5e\x31\x8e\xb3\x26\xfe\x43\x5e\xb1\xcf\x90\x67\xf5\xbb\x6d\xb1\xd4\xb7\x4d\xa4\x76\x1f\x94\x7c\xfb\xbb\xf4\x7f\xca\x39\x8d\x7e\x53\xdf\xdd\x1f\xa1\x6e\x7e\x42\x76\x8c\xdc\x63\x6f\x4d\x9e\xc6\xb1\x46\x1c\x90\x28\xfb\xe5\xdc\x7d\x90\x73\x5c\x2f\x6d\xed\x6f\x71\x9f\xd9\x8d\x9e\x08\x99\x9d\x64\x8f\x2d\x08\x71\x5a\xe1\x4c\x2b\xd4\x5b\x2f\x6a\x26\xcd\x9a\x1f\x8f\xa3\xe3\x71\x9e\x15\xeb\x21\xf5\x45\x8d\x2e\xb2\xc5\x4a\x67\xbd\xf7\xb1\xef\xc4\x5a\xeb\xdf\x31\xeb\xce\x5e\x18\x59\x3b\xbb\x45\x28\x8b\x9c\x75\xb1\x3d\x20\x57\x5e\xf8\xf6\xf3\x2d\xf7\x00\xbd\xc6\x41\xd6\x9c\x0b\xef\x7d\x3d\x1c\xf5\x58\x23\x0f\x4a\xf7\x0b\xe7\x78\xfd\x4d\xee\x80\xf8\xcd\x9f\xf0\xf3\xb8\xc4\x5b\xeb\xa0\x9e\x9b\xba\xee\xd0\xa1\xf7\x4f\x5d\x1b\xe6\x21\xa9\x63\xbf\x9f\xb3\xc3\x33\xd2\x1a\x12\xf3\x9f\xd2\x18\xde\x7a\x9a\x6c\xa6\x64\x9a\xb7\x4b\xa6\x9a\xc2\x39\xe1\x2b\x49\x30\xcb\xa4\x85\x59\x47\x1a\xda\xea\xca\x65\xe6\x4d\x52\xd7\xbc\x99\xb5\x3e\x4b\xb2\xcd\x5b\x25\xdf\x1c\xc2\x59\x77\x39\xcf\x37\x49\xba\x79\x1b\xf7\xa8\xc4\xd0\x59\xd3\x2e\x89\x16\xa5\x4b\xb6\xed\x0d\xfa\xd3\x25\xc7\x0c\x9f\x89\x9b\x69\x32\x3e\x95\x36\x50\x2b\xd3\x27\xcd\xf5\x59\xd9\xf8\x50\xb2\x6c\x33\xe9\xff\x49\x1a\x98\x05\xf0\x45\x31\x1f\xbb\x63\x53\x93\x4f\x9a\xa9\xf5\xe2\xb6\xc6\xba\x70\x36\xd0\x7c\xdf\x86\x7e\x33\x7b\x49\x35\x33\x8d\xfb\xc1\xb7\xa1\xdf\xcd\xae\xf0\xed\x83\x5c\xe1\xb3\x37\xf7\x85\xa6\x9a\xdf\xe2\x4b\x93\x26\x16\x4f\x17\xf4\x46\x78\x9c\x25\x1a\xbb\xd0\xab\x7a\x6e\xe8\xf3\xb7\xb3\x76\x68\x3d\xef\x9a\x96\x71\xf7\x2d\xd3\xc4\x3d\x30\xc4\xd8\x3b\xe0\xe9\xb3\xbe\x33\x9d\xc4\xc7\xfd\xd2\xd7\x71\x96\x3b\x54\xf8\x0e\x97\x6c\xdd\xa3\x5e\xb0\xee\x52\x51\x91\x6f\x76\xfa\x5b\x66\x86\x23\xd3\x5a\x5f\xf4\x9a\xd4\xa3\xca\x77\x55\x7d\x47\xcb\xd3\xfb\x91\xb9\xce\xfa\xee\xea\xb2\xf6\x36\xee\x5b\xb6\xf0\xb7\xda\xca\xfb\xe5\x1f\xf7\xca\x8e\xd6\x37\xe9\x85\xe1\xf3\x1f\x32\xfa\x1e\xd9\xca\xc2\xb5\x05\x18\x69\x9c\xdc\xe0\x95\xad\xb1\x54\x27\x25\x4d\x93\xc6\xcb\xba\x3f\x4d\x15\xa7\xc6\xc2\x22\x9e\x8d\x1b\x59\xe2\xef\x93\x4e\xaa\x90\x7b\x74\x77\x6a\x6b\x26\xb9\x99\x89\x9e\x11\xa1\x6f\xcd\x11\xd2\xda\x38\x43\x6e\xc0\x9e\xdc\x37\xb1\xee\x2e\x6d\x25\x16\xdc\xab\x99\x01\x71\x30\xc7\x5a\x18\xdf\x49\x0e\xd4\x48\x63\x6a\x1c\xe6\xae\x7b\x18\xfb\x6f\x59\x7e\xd4\x37\xbe\x11\x7d\x77\x78\x20\x4c\xa1\x5b\x22\x67\xf9\xf7\x2e\xa1\xa2\x30\x59\xf7\x05\xeb\x3c\x5d\x65\xbd\xfe\xeb\xef\x74\x55\xbe\x4d\x56\xf9\x96\xf8\xf7\xed\xff\xf8\xcd\xd2\xca\xa7\xce\xd3\x9f\xbf\x51\xfe\xc7\x96\xf3\xc3\xa3\x61\x92\x34\xda\x7d\x95\xdf\x72\x2e\x6d\x6d\x55\xbe\x4b\xc2\x77\xec\x92\xf6\x65\xbd\x67\xe9\xba\xb8\xb4\xfd\x0f\x38\xcc\xb1\xfd\x87\x6f\x95\x55\xbe\x99\x84\xf9\x07\xfe\x21\xf7\x17\xdf\x2e\x2b\xdb\xa1\xff\xed\x1b\xe6\x5f\x7d\xcb\xfc\x8b\x36\xee\x7f\xfe\xa6\x39\xd0\x3a\x0f\xba\x2a\xdb\xca\x7d\xe9\xbf\xb5\x7f\xda\x27\x07\x5e\xf8\x2e\xf8\x97\xdf\x41\xad\x5c\x2d\x13\xcf\x85\xef\x1a\xd6\xb7\x3d\xf6\xf3\xb5\xe1\x33\xb2\xed\xaf\xbf\x8f\xeb\xd6\xfd\x5f\xc6\xff\x7b\xfb\xbf\xd5\x60\xca\xdf\x8d\xe3\xa7\xfe\x1d\x4a\x61\xe4\x7b\xeb\x9f\xbe\x13\x5e\xd2\x76\xf9\xdb\xf1\xc8\x77\xd8\xff\xd6\x5e\x9a\xa3\x0b\xdf\x60\xff\x4b\x7b\xd1\xf7\xe8\xbf\x68\xad\x3b\xe0\x7f\xa0\xc8\xfd\x34\xc7\xf1\x33\xfb\x66\x98\x12\x23\x94\xab\xc9\xba\x33\xfe\x05\x39\xea\x84\x7e\xd5\xe4\xe4\x16\x5d\x95\xac\xbb\xe5\x7f\x20\xc7\x42\xee\x33\x90\xcb\x2b\x72\x09\x25\x69\x02\xeb\x59\x61\x0a\x6d\x8e\xd0\xf7\x11\x7a\x5d\x93\xa9\x44\x69\xb2\xdd\x8f\xad\x8b\x29\xc9\xa2\xbf\xfa\x7d\x8d\xce\xc3\x93\xa1\xef\xa1\x43\xae\x01\xd8\x82\x9c\x1f\x84\xc9\xda\xbf\xff\x03\x39\xee\x12\xe5\x0c\x22\x73\x95\xe4\x3b\x5f\x09\x9d\xd2\xf7\xdb\xff\x48\x9f\x84\x0e\x69\x72\x71\x53\xd0\xe4\x3c\x53\x49\xa1\x53\x9a\x2a\x71\xaf\xc4\xb1\x12\x17\x62\xf6\xe9\xb8\x2f\xf8\x5c\x69\x3f\xa2\xf7\xff\x90\xc7\x4a\xb2\xf2\xf8\xdf\xf3\x02\x3e\x0b\x43\xbf\xfe\x39\x2f\xa1\x53\x9a\xfe\x7b\xdc\xe4\xf5\x7f\x88\xfb\x3f\xf9\x0e\x45\x55\x3e\xb3\x6e\x7c\x07\xfd\x12\x6e\xf5\xf7\x36\x74\xfc\x95\xdf\x47\xa5\x2b\xd4\xdb\x39\x48\xb2\xa1\x3c\xbd\xa6\xfe\xf1\x8d\x11\xb9\xb6\xa1\x07\xf5\x9a\xaf\xf7\x89\x08\xfd\x03\x7a\x2d\xfc\xbb\xae\xd0\x77\xe6\x07\x9c\x99\x3e\x90\xde\x55\x65\xfe\x54\x07\xfa\x3b\x88\xa6\xc8\x7b\xe4\xf7\x8c\x19\x8e\xa3\xa1\xf3\xce\x1e\x32\x45\xcf\x03\x73\x0d\x7b\x34\x84\x8e\xa7\xfe\x0a\x1f\xe7\x68\xc9\xa7\xfe\x4e\x3a\x1f\xa1\xfd\x24\x74\xd2\x31\x81\xbd\x7c\x99\xec\x81\xf6\xb3\x56\x5a\xbf\xe4\xaf\x6c\x8d\x97\xac\xbf\x1e\x20\x6a\x80\x75\x8f\xb3\x7e\x8f\xae\xf4\xe9\xfa\xa5\xca\xbb\x40\xe8\x33\xc8\x07\xed\x61\xff\xee\xc5\x19\x49\xdf\x8b\x3b\xba\x22\xf2\xd6\xef\x5d\xae\xd1\xbf\xd3\xbb\xf0\x5d\x76\xae\x6e\xd1\xff\x68\x15\xba\x0d\x19\xfd\x7d\x7a\xb6\xb1\x55\x3a\x23\xf7\x75\x44\xdf\x15\x91\x73\xbf\x45\xda\x2e\x63\x0d\xd5\x31\x19\xc0\x99\x1e\x02\xb7\x65\x32\x14\x1a\xc6\x59\xf6\x1d\xf0\xba\x53\x0d\x0c\xce\x8a\xdc\x05\x2a\xe5\x3c\x11\x8a\xd3\xef\x7a\x8f\x87\xf4\xef\x9c\x1b\x41\x4d\xcc\x46\x72\xad\x75\x2e\x35\xc2\x67\x1d\xeb\xfb\x2c\xcf\x91\x75\xbf\x7f\xe4\xbc\xe1\x84\x92\x22\xfb\x71\x0d\xd7\x06\x79\xca\xbd\x95\xfd\x99\x53\x8b\x33\x5e\x56\xd9\xd2\xe4\x4e\xc6\x75\xbd\x58\xfb\x9f\xab\x2c\x8c\x95\xf5\x6d\x2c\xfc\xed\x4c\x3f\xd7\xd1\xba\x88\xe9\x5e\x67\x12\xe7\xdc\x6f\xa5\xa1\xeb\x18\x7b\xcf\x11\xf1\x11\xd3\x1d\x9c\x0f\x07\xd8\xb6\x4a\x11\xcf\x06\x77\x83\x92\xc8\xef\xaf\x73\xa0\x29\x50\x7f\xfd\xbb\x6c\xe8\x9f\xe1\x3b\xac\x7a\xc6\x26\xca\x73\x69\xab\xc9\x3c\xc5\x5d\xfe\x88\x34\x72\x3c\x22\x1f\xdb\x57\xc9\xbd\xfa\xef\x20\x58\x98\xb4\x95\x05\xb6\x51\x62\xd0\x57\xe0\xdc\xad\x1e\xb3\x6f\x51\x35\x8c\xe6\xa1\x69\xf4\x35\x82\x6a\xdb\x5e\x92\x51\xd6\xef\x92\x35\xed\x96\x27\x91\x1b\x65\xdb\x6d\xd4\xb5\xed\x56\x76\xfb\x4b\xa1\x5f\xec\xa2\xf6\xda\x5f\x32\x16\x58\xcf\x7f\x6a\x2f\x25\xf5\x79\x78\x4c\xb7\x9a\xaa\x8e\xfd\xbf\xed\xff\x5f\x08\x7c\x2f\x22\x63\x37\xed\x58\xeb\x99\x1b\x2c\xf1\xdc\x06\x39\x8c\xcf\x64\xa2\x26\x5d\x97\xce\x63\xea\x29\xe8\xfe\xca\x16\xdc\x4c\x78\xfe\x65\x7b\x47\xae\xa2\x7d\x15\x6a\xa8\x09\xfe\x52\x57\x23\xb5\xd2\x75\x8d\xda\xee\x1c\xa0\xf2\x1d\xa2\xf6\x41\x7d\x6c\x01\xb9\xdc\x1e\xe0\x8c\xbe\x41\xc6\xd8\x92\x38\x3b\x8b\x6c\x72\x58\x39\xa0\x76\xac\xdf\x69\x73\x07\x38\x14\xfa\x49\xff\x0e\x29\x72\x06\xd4\xe7\xf5\x77\x2f\x3a\x3f\x86\xcf\x85\xd6\xef\xc2\x1c\x69\xd4\xd9\xe7\xe2\x72\x0d\xe1\x7c\xf3\x95\x75\x46\xc9\xb0\xf5\xe7\x4c\x76\x3b\xbc\x6b\xe5\x4a\xfd\xf7\x21\xa8\xdf\x4e\xd0\xcb\xd4\xd0\x6f\x9a\x90\x7b\x5c\x93\xfe\xbb\x15\x95\x44\xff\xb3\x9a\xb0\xf5\x9b\x9e\x07\x66\x2d\xf2\x5f\x21\x25\xd0\x48\x6c\xe9\xdf\x13\x67\xe8\xbb\xad\xfe\xae\x6e\xdd\x57\xf5\xdd\x96\x7b\x72\xe5\xfd\xb8\xea\x3d\x58\xdf\x6f\x23\x77\xdb\xc1\xfa\x9e\x5b\x95\xac\xbb\x75\x25\xfd\xe9\x8e\x1d\x5a\x67\x1c\x0f\x6d\x0d\xdf\xaf\x43\xeb\x2e\xba\x5f\x73\xb7\xae\xbc\x57\x5f\xb8\x53\xff\xc5\x7d\x5a\xfb\xa8\xf5\x6a\x39\xcd\x63\x2f\xb2\xe2\xef\x16\x21\xeb\x77\x0b\xd6\xfa\xb4\x4c\xc6\x12\xeb\xbf\xd5\x16\xb9\x1e\x1a\xab\xff\x6e\x48\x98\xf4\xef\x50\xac\xdf\xa3\xc4\xd2\x7e\x0a\xbd\x02\xe9\xef\xf4\x66\x15\x4a\xfd\x83\xf4\xef\x3f\x82\x19\x91\xf6\xb6\x08\x2d\x89\xfc\x1e\x62\x69\x15\xde\x88\xac\xc5\x57\x95\xf7\x12\xd2\xbf\xe7\xb8\x94\xfe\xae\xff\xaf\xf8\xfe\x20\xfd\x77\x1f\x68\x3f\x81\x7e\x8f\xb4\xdf\x47\xda\x8d\xb6\x41\xb2\xf4\x12\xba\x02\xea\x1b\x69\x35\xe5\x9b\x1e\xc9\xa7\xf5\x47\xa8\x37\xd4\x04\x2a\xa0\x5f\xb7\xf5\xa0\xcc\x08\xd5\x87\xb2\xe9\xd7\xcf\xb5\xa1\x14\xa8\x55\x84\x9a\xd1\xdf\x30\x22\xdf\xab\x0a\x0d\xa7\xbf\xd7\x5f\xf8\x51\x18\x19\xcf\xaf\xe4\x8d\xf0\x65\x43\x6d\xa1\x4e\x95\x44\x7f\xa7\x88\x0d\x7f\x15\x7b\xad\xe8\xf7\x5f\x62\xab\x52\xcf\xb8\x4b\x75\x57\xd1\x7f\xa9\x1f\x03\xa1\x41\x50\x71\xa4\x1d\x08\xdf\x50\xda\x36\x50\xeb\x08\xe9\xe7\x36\xf4\xeb\xb6\x1b\x94\x57\x95\xe8\xd7\xed\x8c\x08\xb5\x8d\x50\x3b\xfa\x75\x7b\xff\xa5\xf4\x37\x7e\x5c\x1a\x47\x6f\xf8\x34\x96\xcd\xaa\xc4\xac\xf1\xae\x1d\xc1\x39\x3b\x92\x8f\xca\xdc\xd4\x8b\xe4\xa5\x20\x92\xbf\xde\x95\x39\x8d\xe4\x31\xbf\x4a\xce\xad\xfc\x47\xf2\x7e\x91\x1f\xd4\x4c\xeb\x48\xed\x58\xf5\x13\xa1\xca\xba\xfa\xc4\xfa\x86\xf1\x5f\xce\x77\xfa\xf7\x2c\xd0\x0f\x91\x33\xb1\x6e\x57\x55\xa5\xff\x76\x8e\x85\x67\x77\x84\x56\x6b\xfa\xf3\x38\xe7\x9a\x0f\xe4\x49\xeb\x77\x4e\xb4\x91\xdf\xb3\xe5\xd1\xee\x8f\x7c\x2f\x5c\x0f\xed\x80\xbe\x80\x0e\x41\xbb\xa0\x7d\xd0\x6a\x91\xf3\x3f\x84\x5b\x2b\xae\x2d\x55\x48\xbf\x2f\x62\x7c\x6b\xb8\x0d\xce\x8b\xcc\x6f\x4d\x4f\x85\xdb\xf0\x1f\xdb\x83\xa1\x6b\x2c\xd2\xeb\x96\x5e\x03\x59\x7b\x2a\xc9\x5a\xc3\x58\xf3\xe0\xef\x00\x8d\xd7\xa4\x7f\x9f\xa5\x8f\x3a\x11\xaa\x15\xfe\x9b\x90\xb6\x7a\xbc\x29\xeb\xdd\x66\xd3\x4b\x55\x50\xa6\x8b\x43\xee\x94\x3b\xcd\x49\xe6\x0d\xe6\x9d\xe6\x5c\x73\xbe\xf9\xb4\xf9\x89\x3d\xc1\x5e\xdb\xbe\xc5\xfe\x9d\xfd\x54\xed\x0f\xeb\x3c\x51\xe7\xa9\x3a\xbf\x7b\x93\xbc\xb5\xbd\x79\xde\x2b\xbc\x83\xbc\xc5\xde\x21\xde\x61\xde\x3b\xbc\xab\xbc\x9b\xbc\x3b\xbd\x5f\x78\x4f\x78\x4f\x79\x83\xbe\x58\x5f\x5d\x5f\x96\xaf\x99\xaf\xa5\xaf\x9d\xaf\xbd\xaf\xa3\x2f\xd7\x37\xdc\x37\xc9\x77\x83\xef\x66\xdf\x34\xdf\x43\xbe\xd7\x7d\x27\xd3\xed\xe9\x09\xe9\x29\xe9\x75\xd3\xb3\xd2\x9b\xa6\x5f\x99\xde\x3f\x7d\x78\xfa\xcc\xf4\x87\xd3\x5f\xa8\x6b\xd4\x75\xd4\x8d\xad\x1b\x5f\x37\xa9\x6e\xcd\xba\xde\xba\x0d\xeb\x36\xaa\x5b\x50\x77\x64\xdd\xd1\x19\x46\x86\x27\x23\x3d\x53\x32\x8d\xcc\xe8\x4c\x4f\x66\x62\x66\x6a\x66\xad\xcc\x7a\x99\x8d\x33\x5b\x66\xb6\xcf\xbc\x36\x73\x7a\xe6\xcc\xcc\xd9\x99\xf3\x33\x1f\xcc\x7c\x3a\x73\x79\xe6\xab\x99\xeb\x32\xd7\x67\x6e\xca\xfc\x38\xf3\xd3\xcc\xcf\x33\x8f\x66\xb5\xcf\x0a\x64\x75\xc9\x2a\xc9\xba\x3a\x6b\x4c\xd6\x35\x59\x93\x1a\x4f\x6c\x7c\x53\xd3\x94\x7f\xa5\xff\x6b\xfe\x59\xe3\x6c\xab\xb3\xed\xcf\x76\x3c\xdb\xf9\x6c\xee\xd9\xde\xc1\x8c\xd0\xb9\x50\xc8\xfa\x9b\x99\x4b\xcd\xa9\xe6\xad\xe6\x4c\xe2\xbf\xcf\xfc\xa7\xb9\xcd\x5e\xd3\x7e\xbf\x7d\x9b\xfd\x64\x6d\xa9\x1d\x24\xfe\xa5\x5e\xf1\xa6\x7a\x7d\xde\x02\x6f\x61\x24\xfe\x11\xde\xe9\xde\x37\xbc\xef\x79\x3f\xf3\x7e\xe9\xfd\xc9\xfb\x8b\x4f\x7c\xf1\xc4\x7f\x99\xaf\x85\xaf\xed\x85\xf8\x27\xf8\xa6\xfa\x6e\x22\xfe\x45\xbe\xa5\x91\xf8\x93\x23\xf1\x5f\x91\xde\x2f\x7d\x08\xf1\x2f\xba\x10\x7f\x1c\xf1\xd7\xa8\x5b\x27\x12\x7f\x49\xdd\x51\x56\xfc\xbe\xbf\x89\xbf\xf0\x42\xfc\x8b\x32\x97\x66\x2e\xbb\x10\xff\x87\xc4\xbf\x97\xf8\xdb\x5d\x88\x7f\x74\xd6\x04\xe2\x2f\x69\x7c\x3d\xf1\xa7\xfc\x6b\xf6\x59\x75\xb6\xf6\xd9\x36\xc4\x1f\x38\xdb\xf5\x6c\x7e\xd0\xa7\xe3\x0f\x1d\x0a\x6d\x0c\xbd\x15\x5a\x17\x7a\x3d\xb4\x2a\xf4\x5a\xe8\xd5\xd0\xca\xd0\x4b\xa1\x36\xa1\x66\xa1\x46\xdf\xf8\x2a\xbe\xaf\x38\x56\xf1\x5d\xc5\xe1\x8a\xf2\x8a\x83\x15\x5f\x55\xec\xaf\xf8\xa2\x62\x5f\xc5\xe7\x15\x7b\x2b\x3e\xab\xd8\x5d\xb1\xab\x62\x47\xc5\xf6\x8a\x4f\x2b\x3e\xa9\xd8\x5a\xf1\x51\xc5\xfb\x15\x9b\x2b\x36\x55\x6c\xa8\x78\xbb\xe2\xad\x8a\xb5\x15\x4b\x2b\x1e\xae\xb8\xbf\x62\x51\xc5\xdc\x8a\x5b\x2b\x26\x55\xf8\x2b\xd2\x2b\x12\x2b\xe2\x2b\x5c\x15\xf6\xa3\xc1\xa3\x07\x8f\xee\x3f\xfa\xd9\xd1\x95\x47\x9f\x3f\xfa\xd0\xd1\xcb\x8f\xb6\x39\xda\xec\x68\xf6\xd1\x26\x47\x2f\x3b\x5a\xff\x68\x9d\xa3\xb5\x8f\xaa\x23\xdf\x1d\xf9\xe6\x48\xaf\x23\x9d\x8e\x34\x3b\xd4\xf7\x50\x9f\x43\x05\x87\xf2\x0e\x75\x39\xd4\xe9\x50\xfb\x43\xfe\x43\x4d\x0f\xd5\x3f\xe4\x3b\x14\x53\x7e\xa6\xfc\xd7\xf2\x53\xe5\x3f\x96\xff\x50\x5e\x5e\xbe\xaf\x7c\x77\xf9\x27\xe5\x5b\xcb\xdf\x2b\x7f\xa7\xfc\xed\xf2\xd5\xe5\x2f\x95\x17\x95\x0f\x28\xef\x5f\xde\xba\xdc\x5f\xde\xb2\xbc\x79\x79\xd3\xfd\x1d\xf7\x5f\xbe\x6f\xf1\xc8\x27\x47\xb6\x8e\x79\x37\xe6\xc5\x98\x17\x62\xfe\x15\xf3\x7c\xcc\x73\x31\xcf\x46\xed\x72\x9d\xbb\xf4\x6f\x08\xff\xff\xee\x8f\xc3\x88\xd2\x8d\x92\x3f\x21\xa1\xac\x4b\x96\xfe\x63\xfc\x17\x1d\x61\x49\x93\x0b\x9a\x9d\xd5\xc4\xc9\x85\xc8\x2d\x51\x52\x4d\xa2\x25\x46\xaa\x4b\xac\x78\x24\x4e\xe2\x25\x41\x12\x25\x49\x92\x25\x45\x52\xa5\x86\xd4\x94\x34\x56\xa1\xda\x52\x47\xbc\xcc\xbe\x74\xa9\x2b\x19\x52\x4f\x32\x25\x4b\xea\x4b\x03\x69\x28\x97\x49\x23\x69\x2c\x4d\xa4\xa9\x64\x4b\x33\x69\x2e\x2d\x24\x47\x5a\x8a\x5f\x5a\x49\x6b\x69\x23\x6d\xa5\x9d\x5c\x2e\xed\xa5\x83\x74\x94\x4e\x12\x90\xce\xac\x7e\x5d\x25\x57\xf2\x24\x5f\xba\x49\x81\x74\x97\x1e\xd2\x53\x7a\xc9\x15\x72\xa5\xf4\xe6\x94\xd6\x47\xfa\x4a\x3f\x6e\x3a\x03\x58\x15\x07\x49\x91\x14\xcb\x60\x19\x22\x43\x65\x98\x0c\x97\x11\x52\x22\x23\xf1\xff\x5e\x99\x25\x73\x64\x9e\x3c\x28\x8f\xc9\x53\xf2\x4f\x79\x46\x9e\x95\xe7\xe5\x39\xf9\x97\xbc\xc8\xcd\x72\x99\x2c\x97\x97\x65\x05\xa7\xd4\x32\x59\x29\xaf\xc9\xeb\xb2\x4a\xde\x90\x35\xb2\x5a\xd6\xcb\x9b\xf2\x6f\x79\xcb\x79\x4c\xa6\xc8\x28\x19\x2d\xe3\x9d\xdf\xcb\xcd\xf2\xb4\x4c\x96\x6b\x5c\x97\xc9\x8d\x32\xc1\xd5\x43\x66\xcb\x3f\x5c\x79\x9c\xda\x7b\xb9\xae\x90\xb1\x72\x93\xab\x83\x2b\xe0\xea\x64\x4e\x71\x15\xc8\xb5\x72\xbb\x39\x44\x5e\x90\x75\x32\x43\xae\x96\xeb\x5c\xb9\xaa\xbf\xab\xbb\xab\xa3\x4c\x94\x3b\x9c\x3f\xc8\x55\x72\x97\xdc\x23\x8f\xaa\x44\x95\xe4\xfc\xca\x79\xc0\x59\xe1\xfc\xc6\x79\xc8\x79\x58\xd6\xba\xe6\xc9\x3b\xaa\x9d\xf3\xbc\x2b\xcd\xf9\xbb\xf3\x8c\x6b\x93\x6b\xb3\xf3\xb8\xdc\xe2\x3c\xe2\xfc\xd6\x79\x5a\x66\xca\x7c\xb9\x5b\x16\xc8\x5c\x59\x28\x8b\x38\xa7\xdd\x27\x0f\xcb\x23\x44\xf8\x90\x2c\x66\xe7\x7a\x42\x7e\x36\x66\x1b\x4f\xc9\xf5\xc6\x3f\x8c\x27\x8c\xc5\x72\xab\xb1\xc4\x78\xd2\x98\x23\x12\xe8\x36\x64\x70\x71\xd1\x80\xfe\xfd\xfa\xf6\x29\xec\x7d\xe5\x15\xbd\x7a\xf6\xe8\x5e\xd0\x2d\x3f\x2f\xb7\x6b\x97\xce\x81\x4e\x1d\x3b\xb4\xbf\xbc\x5d\xdb\x36\xad\x5b\xf9\x9b\x37\xcb\x6e\xda\xa4\x71\x83\xfa\x59\x99\xf5\x32\xea\xa6\x7b\x53\x13\xe3\x3c\xb1\xd5\x63\xaa\x45\xb9\x5d\x4e\x87\xdd\x66\x1a\x4a\x1a\xfb\xca\x54\x49\x5e\x99\x99\xe9\x8b\xcb\x1f\x99\x91\x97\x31\xb2\xa0\x49\x63\x5f\x5e\xea\xb8\xdc\x26\x8d\xf3\x32\xf2\x4b\xca\x7c\x23\x7d\x65\x34\xb6\xac\x8c\x82\x02\xab\x2b\x63\x64\x99\xaf\xc4\x57\x96\x45\x33\xb2\x4a\x77\x49\x59\x00\xce\x31\x97\x70\x06\xc2\x9c\x81\x0b\x9c\xca\xe3\x6b\x2f\xed\xb5\x89\x0c\x5f\xd9\xd6\xdc\x0c\xdf\x1a\x35\xb8\x4f\x11\xcf\x0b\x72\x33\x8a\x7d\x65\xdf\x5b\xcf\x57\x58\xcf\xb6\x2c\xeb\x25\x86\x97\xf4\x74\x24\x2c\xaf\xb4\xb7\xbe\xbc\xb2\xfc\x1b\xc7\xcd\xcd\x2b\xc1\x47\xb5\xb2\x5a\x54\xd7\x8c\xae\xa3\xa3\x9a\x34\x96\x95\x51\xd5\x78\xac\xc6\x53\x59\x83\x8c\xc9\x2b\x55\x83\x8e\xca\x7a\x30\x1a\xe4\xb5\x5b\x69\x88\x2b\x46\x9b\x25\xd2\xbc\x91\xa3\xca\x0a\xfb\x14\xe5\xe5\xa6\xa5\xa7\x17\x37\x69\xdc\xbd\xac\x7a\x46\xae\x35\x24\x5d\x2d\x95\x65\x8e\xae\x65\x4e\x4b\xa5\x6f\xbc\x76\x5d\xe6\xf9\x56\x36\xde\x30\x77\xfe\x1a\x8f\x5c\x55\xd2\x28\x7a\x54\xc6\xa8\x91\x43\x8b\xca\xcc\x91\xc8\xce\x35\xf3\xe6\xce\x9d\x55\x16\xd7\xa8\xac\x61\x46\x6e\x59\xc3\x5b\x0f\xa7\x12\xf9\xe8\xb2\xc6\x19\xb9\x79\x65\x8d\xb4\xd6\x9e\x7d\x2f\xd8\xe9\xf9\x87\x49\x55\x66\xcf\x64\xc3\x98\x7b\x5a\x08\x27\xe3\xfb\xe3\x17\xf7\x8c\x8c\xf4\x38\x32\x3d\xa7\x45\x3f\x96\x19\x5d\xcb\x54\xdf\xa2\x74\xfd\x27\x2d\x1f\xac\xe7\xce\xcd\xcf\xf0\xe5\xcf\x2d\x99\x3b\x72\x4d\x68\xfa\x55\x19\x3e\x4f\xc6\xdc\x95\xd1\xd1\x73\x27\xe7\x01\xb7\x14\x16\xa1\x62\x4d\x68\xdd\xbc\xb4\xb2\xfc\xf9\xc5\x65\x9e\x92\x71\xaa\x5d\x71\x24\xf4\xfc\xbe\x3d\xcb\x12\xfa\x0c\x29\x2a\x33\x32\xf3\x7d\xe3\x46\xd2\xc3\xff\x3b\x65\xa4\xb7\x49\x4b\x8f\xbb\xc0\x53\xf8\x77\xc3\x02\x2c\x80\x03\xc2\xe9\xe9\x1a\x86\x79\x6b\x02\x72\x15\x2f\x65\xd3\xfb\x14\x85\xdf\x7d\x72\x55\xda\xab\x12\xc8\x6e\x54\x5c\x66\x94\xe8\x91\x0d\x95\x23\x49\x03\xf4\xc8\xf4\xca\x91\x0b\xe2\x25\x19\xe4\xb6\x67\xbf\xa2\xb9\x65\xb6\xcc\xee\xa3\x32\xf2\x40\x7c\xde\xc8\xb2\xe9\x57\x51\x5d\x13\x74\x62\x32\x3c\x65\xd5\x7f\x49\x4b\xcf\x98\x1b\x1f\xe7\x6b\x9b\x5d\x6c\xf1\xfa\xf0\xaa\xfb\xa8\xf1\xbe\x32\x7b\x16\x20\x21\x55\x55\x80\xba\xd1\x22\x73\x3d\xd6\x4b\xf5\x5f\xc2\xcd\xf7\x69\x18\xc8\x8a\x8b\xf7\xb5\xcd\x40\x8d\xd6\x93\x97\x91\x57\x12\xf9\xff\x8d\xe3\x52\x51\xe0\x03\xe8\x82\x46\xe1\x42\xe8\x5f\x54\x16\xc8\xe5\x21\x30\x32\x92\xb1\xbc\x95\xcd\xb2\x91\x18\x59\x42\xc2\xc6\xe7\x5a\xc9\x2c\xcb\xce\x98\x5c\x96\x98\xd1\xe5\x42\x76\xb5\x5b\x79\xe3\xfb\x15\x59\x22\x11\xb1\xb2\xc4\xae\x65\x52\x72\x75\x44\xaa\x2c\x3b\xcf\x9a\x57\xbe\xbc\xb9\x25\xb9\x61\x17\xb4\xae\x8c\x3e\x45\x6b\x25\x27\x74\x70\x65\x4b\x5f\xda\x6b\x7a\xe9\x2c\xce\xd5\xcc\xc9\x5d\xa9\xb2\xac\xbc\xb9\x45\xa3\xc6\x94\x79\x4b\xd2\x46\x31\xef\xc6\xf8\x8a\xd2\xd2\xcb\x02\xc5\x64\xb8\x38\xa3\x68\x74\xb1\x2e\x3b\x10\x6a\x78\x30\xcd\x2a\x8e\x62\xab\x56\xfa\x17\xf5\xec\x97\xd1\xb3\xcf\xe0\xa2\x36\x11\x47\xc2\x03\x5a\x9d\x2d\x33\xef\x12\x35\x19\x45\x69\x61\x35\x14\x60\x99\x2b\xd3\xe5\x2b\x32\xd2\xcc\x62\x18\x3d\x74\xf8\xf2\x79\xc8\xe8\xd2\x9e\x9f\x65\xce\x4c\x17\xe4\x01\x70\xab\x57\x17\x6e\x97\xf6\xbe\x22\x95\x26\x95\xdc\xb8\x51\xd6\xd0\x97\x37\x3a\x37\xc2\xa7\xdf\x2f\x52\x6a\xd7\xe5\xd4\xb5\xa0\x52\x9b\x43\xbf\xa2\xa7\x6b\x41\x5a\x7a\x71\x7a\xf8\x4f\x93\xc6\x06\xc3\xbe\x88\x61\x24\x5c\x1a\xd4\x82\xca\x21\x96\x29\x06\x5c\xd4\x67\xd7\x02\xab\x4b\x63\x99\xaa\x8b\xde\x57\x94\x31\x3a\xa3\x38\x63\x9c\xaf\x2c\x50\x58\xa4\x63\xd3\xf0\x58\x28\x47\xc0\xb0\x30\x8f\xe4\xaa\xff\x45\x6f\x55\xc0\x02\x26\x49\x67\xb8\xf2\x45\x83\x59\x96\xdf\x28\xad\x2a\xb8\x65\xdd\xac\xf7\x0b\xaf\x05\x97\x0c\x77\xaf\x1c\xf6\xcd\x75\x65\xf4\xec\x37\x57\x2b\xcf\x88\x28\x14\x3c\xef\x5e\x26\xba\x84\x03\x6d\xe2\xd2\xac\xb5\x40\x4f\xe8\x0c\xd6\x5e\x9f\x87\x29\x6d\x4d\xe8\xb9\x2b\x03\x01\x3d\x99\xc7\xb5\xd3\x4a\x32\xba\x8f\x9a\x9b\xd1\xaf\xa8\xbd\xc5\xcd\x7a\x72\x47\xda\xad\xda\x56\xbc\xf4\x54\x3d\xfb\x77\x69\xd2\x98\xa5\xad\xcb\xca\x0c\x35\xbb\xcf\xca\x80\x9a\xdd\x6f\x70\xd1\x5a\x0f\x67\xe4\xd9\xfd\x8b\x5e\x35\x94\xd1\xb5\xa4\x4b\xf1\xca\x7a\x8c\x15\xad\xf5\xb1\x69\x58\xbd\x86\xee\xd5\x9d\xfa\xc5\xa7\x5f\xb4\xa6\xbe\xbc\xb8\x2c\xfe\xb4\xb5\x01\x91\xe9\xd6\xa8\xcd\xea\xb0\xde\xaf\x5e\xa3\xc4\xea\x73\x55\xf6\x29\xb9\x7a\x8d\x11\xee\xf3\x84\x0d\x65\x59\x86\x02\x9c\x41\xae\x5e\x63\x0b\x8f\x04\x2a\xb9\x6d\xf4\xb9\xc2\x7d\xd3\xad\x3e\xeb\xcf\x4a\xd1\x90\x05\xa2\xec\x01\x57\xc0\x1d\x88\x36\x62\x8c\xb4\x95\x4a\x77\xbd\x4a\xcf\x3a\xce\x2a\x6e\x25\xaf\x45\xab\x18\x95\xb6\x12\xa9\xbe\x56\xf7\x1a\x35\x7d\xa5\x3b\x90\x16\xe6\x98\x0e\x47\x20\xec\xe1\xec\x01\x7f\x98\x1e\x30\xb8\xe8\x35\x4e\x34\x2a\xcd\xfa\x89\xa1\x2e\xfa\x0f\xe5\x92\x3a\x8e\x64\xb3\xad\xe4\xf9\x46\xe9\x42\xb9\xbd\x78\xdc\xdc\x92\x62\x3d\xd9\x24\x99\xd4\xf0\x7f\x55\xa6\x32\x3a\x92\xa6\x8c\x8e\x38\xe2\x88\x2e\x8b\xca\x18\xdd\xa5\xac\x5a\x46\x17\xdd\xdf\x49\xf7\x77\x0a\xf7\x3b\x74\xbf\x93\x12\x55\xc9\x0a\xf1\xe9\xe4\xbe\xb0\x4c\xe9\x0a\x18\x52\x94\xce\x94\xf4\xd5\xfc\x20\x6d\xae\xe7\x7b\x9d\xa9\x62\x16\x95\xb9\x9e\x23\x4d\x3a\x0f\x50\x9d\x44\xa9\xb6\x32\x40\x75\x8c\xb4\x5d\x54\x80\x93\x96\x57\x75\xa6\xe5\xda\xa2\x2e\x97\x1c\xd5\x8e\xfe\x36\xb4\x8c\xcb\xb3\xfc\x3c\x05\x19\xaa\x85\x74\x50\xcd\x19\x69\x8e\x64\x36\x6d\x33\xde\x75\xdb\x58\x35\x94\x10\x92\x0d\xe9\xbf\x8c\xf7\x06\xf4\xd7\xa7\xad\x1f\x79\xcf\xe2\x3d\x93\x36\x33\xf2\x9e\xa1\xea\x5a\xfc\x75\x23\xef\x8d\x18\xa7\x95\x42\xe5\x24\xa3\xd9\xd6\xcf\x15\xca\x16\x28\x54\xdb\xce\xab\xb7\xcf\x2b\xcf\x79\x35\xe9\xac\x0a\x9c\x55\xd3\x4f\x2f\x3a\xbd\xf4\xb4\xf9\xe3\x49\xbf\x37\xfb\xe4\x92\x93\xc6\x88\x13\x2a\xfb\xc4\x88\x13\x93\x4e\x2c\x39\x71\xe0\x84\xfd\xe8\x61\x9f\xf7\xc8\xe1\x0e\xde\xf2\x83\xf5\xbd\x5f\x1f\xec\xe0\x3d\xd0\xe1\xcb\x01\x5f\x75\x30\x07\xc8\x97\xcd\xbe\x34\xbe\x54\xe6\x80\xec\xce\xd5\x54\x1d\x74\x7b\xf8\xe9\x83\x02\x90\x19\xda\xa0\xea\x04\x1a\xd4\xa8\x95\xbf\xdf\x0c\x79\xe5\x0b\xb5\xcf\xd6\xde\xbb\x6b\x47\x2d\xef\xce\x1d\x59\xde\x92\xed\x8b\xb6\x6f\xd8\x6e\xea\xa6\x8c\x87\x83\xdb\xed\x6b\x42\x1b\x5e\xdb\x5e\xa3\x76\x3e\xed\xaa\xed\x51\x31\xf9\xb1\x6b\x54\x72\x20\x56\xbd\xfd\x56\x96\x37\xf0\x66\xc3\xce\xf9\x81\x37\xeb\xd6\xcf\x5f\xa3\xd2\x03\x59\x6f\x74\xf0\xca\x1a\x35\x69\x8d\x5a\xb3\x3a\xca\x2b\xab\x95\xac\xf6\xad\x0e\xac\x2e\x59\x3d\x79\xb5\x5d\x37\x8b\x56\x6f\x5b\x7d\x72\xb5\x7d\x8d\xf2\x05\x62\x0a\x60\x7d\xbd\xe4\x75\x63\xe9\xeb\xdb\x5e\x37\xd0\x1c\xa8\xfe\x7a\xb5\xea\xf9\xb1\xaf\x8e\x78\xd5\x58\x69\xb6\xf7\x6a\xb7\x6b\x48\x27\xa8\x37\x64\xca\x42\x7e\x2a\x9c\xaf\x11\x68\x90\xd5\x30\xdf\xbb\x22\x7b\x45\xa7\x15\x4b\x56\xd8\x62\x57\xa8\xc0\x8a\xea\xc9\xf9\xf2\xf2\xe4\x97\xa7\xbf\x6c\x1e\x7c\xf9\xe4\xcb\xc6\x4b\xcb\xfc\xde\x65\x85\x59\xde\xb5\x2a\x4d\xd5\x7c\xb5\xbd\xf6\xa8\xe6\x1b\x2a\xf6\x45\x15\xfb\x82\x5a\xaf\x52\x54\x02\x67\x62\xaf\x4a\x0a\xdc\x59\xd8\xde\xfb\xd4\x13\xf5\xbd\x4f\x42\x8b\xa1\xe9\x4f\xa8\xc7\xf2\x1b\x78\x97\x3c\xba\xe2\x51\xe3\x91\x7c\xbf\x37\xf6\x21\xef\x43\xc6\x83\x8b\xb2\xbc\x0f\xdc\x9f\xe5\x8d\x5d\xe8\x5d\x38\x69\xe1\xb4\x85\x0b\x17\xda\xef\x9b\x9f\xe5\xed\xbd\x40\xc5\xce\x57\x81\xf9\xd5\x62\xf3\x63\xe7\x78\xe7\x18\xf7\xde\x13\xeb\x1d\x71\x8f\x6a\x75\x57\xfe\x5d\xc6\x8d\xd8\xbe\x01\x9a\x0a\x95\x42\x0d\x27\xab\xb4\xc9\xca\x9c\xac\x4e\x4d\x56\x9f\x4d\x3e\x3a\xd9\x18\x37\x59\x15\x4f\x56\x6b\x42\x27\x03\x77\x4c\x06\xce\x49\xd7\x15\x78\xaf\xcb\x6f\xe1\xad\xa9\x52\x07\xd4\xc8\x49\x1d\xe0\xcc\x31\x07\x38\xc8\xcb\x48\x64\x4b\x46\xb4\xf0\x8e\xa0\x1d\x3e\xb8\xc0\x3b\x34\xbf\xbe\x77\xc8\xe0\x9b\xbd\x83\xf3\x9b\x7b\x13\x5a\xc4\x0f\xb0\x93\x5d\x5b\x0b\x73\xc0\x24\x53\xc5\x9a\x9d\xcc\xde\xe6\x24\x73\x9a\x69\x1f\xd1\x4f\x05\xfa\x35\x68\x9c\x1f\xe8\x57\xa7\x2e\x3f\x12\x52\xf3\xaf\xe9\x7b\x5b\xdf\x79\x7d\xcd\x3e\xbd\x6b\x79\x0b\xa1\x1a\xbd\x1b\xf6\x36\x8a\x7b\x8f\xef\x6d\xac\x51\xf1\x81\x26\xf9\x99\xde\xee\xf9\x35\xbc\x05\xf9\xe9\xde\x6e\x04\xfd\x5b\x3e\x20\xa8\x5a\x05\x69\x03\x92\x5b\x24\x0d\x88\x53\xb1\x03\x3c\x2d\x62\x07\x70\x5e\x1d\xa0\x24\xe4\x5d\xa3\xe2\x5e\x4d\x73\xd3\x78\x02\x4d\x68\xbd\xb1\x9d\x62\x47\xc4\x4e\x8b\xb5\xc5\xc6\x66\xc7\xf6\x8e\x9d\x14\xbb\x30\xf6\x40\x6c\x28\xd6\xd9\x89\xbe\x13\xb1\xe6\x24\x51\xbd\x45\x4d\x4f\x56\x76\xb5\x46\x2d\x5a\xd9\xbf\x5f\xa3\x46\x3d\xd7\x38\x43\x1c\x85\x9c\x85\x43\xca\xd4\xec\xb2\xcc\x7e\xfa\x67\xa0\xcf\xe0\x32\xc7\xec\x32\x19\x30\x78\x48\xd1\x4a\xa5\xee\x2b\xbe\x67\xc1\x02\xe9\x52\xbb\x67\x59\x8b\x7e\x45\x65\x25\xb5\x8b\x7b\x96\x8d\xe2\x21\xa0\x1f\xa6\xf3\xe0\xa9\xbd\x32\x59\xba\x14\x97\x4e\x2d\x9d\x7a\x43\xa3\xc8\x1f\x55\x3a\x55\x37\xa2\x9b\x52\x1e\x4a\x4b\xf5\x90\xd2\x5d\x17\x58\xac\xee\xd2\xd2\xa9\x53\xa7\x4a\x58\xa4\xb4\x51\xa9\x34\xd2\x3f\x19\x50\xfc\x94\x52\x8b\x11\x1e\xcd\xac\x75\x45\xfe\xaf\xf4\x4f\xd1\xe6\x2c\x33\xca\xe2\x2c\x9d\xaa\x99\x2c\xe1\x1b\xf4\x4f\xeb\x4d\xf7\x6a\x45\xd6\x1f\x2c\x94\x5e\x30\x6f\x69\x0e\x37\xa9\xf6\x8f\xed\x1f\xcb\x1d\xf6\x19\xdc\xf4\x6e\xb1\x7e\x5e\xf4\xc7\xd6\x8e\x95\xe9\xa6\xf0\xdf\xc7\xaf\xfa\x33\x38\x28\xf4\xeb\xff\xf5\x02\xfb\x57\x7f\xc2\xff\xbc\xb0\xaa\xc1\x0a\x75\x5a\x8e\x55\x19\x78\x47\x76\x72\xd3\x2a\x93\x4f\x2f\xba\xbe\xd6\x57\x0d\x95\x83\x36\x5e\x0e\xcb\x29\x79\xef\xef\xb4\xa2\xcf\xab\x7a\x59\x8f\x07\x64\xbb\x6c\xe6\x0e\xf8\xd7\x7c\x86\xbc\xa8\xce\xcb\x5e\xa6\xf5\x74\x16\x8a\xf3\x56\x5f\x27\x96\xa2\x61\xf8\xb3\x8c\xbe\x1b\x64\x81\x3a\xa7\x6e\x51\xe9\xb2\x54\x79\xac\xd1\xe6\xe8\xae\xae\x6c\x7f\xa1\xab\x83\x0a\xc9\x41\xbc\x7b\x48\x0e\xca\x43\x2a\x57\x0e\xda\x4b\xcd\x1a\x0c\xec\x35\x36\xcb\x62\x73\x86\xb1\x55\x3e\xc2\xe7\x2b\x8d\x05\xf4\x85\x64\x8f\x7c\xac\x9a\x29\x6e\x9a\xdc\x4e\x9f\xb7\x14\x94\x62\x6f\x41\x55\x8d\xa6\x70\xb3\x7d\xcc\xba\x1f\x46\xfe\xd8\x5f\x09\xae\xb7\xcf\x38\xdf\x4c\xe2\x42\xbf\x70\xa7\x5d\x6f\x21\x30\x8d\xdb\x63\xc9\x05\xa1\x93\xea\x07\xb5\x48\xc4\xa8\xa1\x5c\xaa\x32\xa7\x6f\x55\x0e\x3a\x0b\xcc\x09\xc6\x1b\x86\x71\xfe\x41\x5e\xee\xe7\x7e\x7b\xbf\x8c\x54\x9f\xc3\xbd\xc0\xec\x7c\x49\x38\xcb\x82\x93\x82\xe3\x94\xdd\xba\x63\x97\xab\x3e\xdc\x4f\xdf\x92\x57\x82\x6b\x83\xcf\x72\x0f\x5f\x61\xec\x66\xcf\xf8\x49\x9e\xb7\x25\x39\xd8\xa5\xcd\xaf\xc5\x63\x9c\x91\xd8\xe0\x2e\xf5\x5d\xe8\x67\xb1\xfe\xc6\xa7\x79\xb5\x54\x3b\x1f\x1b\x3a\x1d\x56\xe6\x98\x61\xbb\x49\x92\x6c\x9f\xeb\x1a\x0a\x6d\x0e\x4e\x03\xd7\xad\xf2\x13\xe8\xef\x56\x35\x22\xf6\x7a\x5d\x4c\x46\x11\xb4\x0a\x3d\x07\x89\xda\x87\xe7\xef\x53\x2b\xfb\x39\x11\x90\x05\xf7\x64\x68\x9b\x48\xd4\x28\x68\xbd\x48\xb5\x68\xa8\x3d\x74\x2d\xb4\x58\x24\xba\x1e\x74\xbb\x48\x4c\xa2\x48\x75\x9e\xab\x2f\x17\x89\x9d\x2e\xe2\xc9\x85\x78\x8e\x9b\x29\x12\x8f\x8d\x04\x64\x93\x02\x10\x32\xc9\xd8\x48\x46\x26\xa5\xa5\x48\x2a\x3c\x69\xb8\x91\xf6\x9b\x48\xad\x17\x44\x6a\x37\x80\x3e\x16\xa9\x03\x6f\x9d\x93\x22\x5e\xf0\xf5\x59\xc7\x2c\x08\x9e\x74\x6c\xeb\x7f\xdc\x26\x83\xfe\x7a\x3c\xd7\xc3\xb7\x4c\xe4\xb2\x86\x8a\xd4\x6f\x23\xd2\xe0\x59\x91\x86\xe8\x6d\x48\xdb\x08\x1f\x1a\x95\x89\x34\xa9\x05\x81\x54\x53\xe4\x9a\x32\xd6\x14\xff\x9a\x22\x97\xcd\x7b\x36\xb1\x37\x43\xb6\x39\x93\xa3\x39\x32\x2d\x0a\x45\x72\xf0\x2f\x07\x9d\x2d\x1f\x12\xf1\x37\x83\xd0\xd1\x0a\xf9\xd6\x8d\xa1\xf9\x22\x6d\xe8\x6f\x8b\x9e\xb6\x1b\x44\xda\x81\xc3\xe5\xf8\x77\xf9\x63\x22\xed\x89\x55\xff\x8a\xb0\xc3\x52\x91\x4e\xc4\xd1\x19\x7f\x3a\x23\xd7\x15\x3c\x73\x79\xce\x3d\x2c\x92\x87\x5c\x1e\x38\xe7\x63\x27\x9f\x4a\xea\xb6\x57\xa4\x00\xfe\xee\xc8\xf6\xe8\x2f\xd2\x13\x0c\x7b\x82\x51\x2f\x78\xae\xc0\xcf\x2b\xc1\xa7\x37\xb1\x16\xe2\x47\x21\x36\x0a\xf1\xab\x0f\x63\x7d\xc1\xbb\x2f\xfd\xfd\xb0\xdd\x0f\xff\xfa\x33\xd6\x1f\xfd\x03\x6e\x86\x4e\x89\x0c\xc4\xd7\x41\xe4\x6e\x10\x7d\x45\xc4\x57\x04\x76\xc5\xe8\x28\xe6\xb9\x18\xff\x07\x63\x7f\x30\x36\x07\x93\xf7\xc1\xf0\x0c\x41\xdf\x90\x02\x08\xdb\x43\xe9\x1f\x8a\xdd\xa1\xd8\x19\x86\xfe\x61\xe4\x62\xd8\x54\x08\x7c\x86\x6d\x0b\xff\xd5\xe3\xe1\xc4\x31\x1c\x3b\x23\xf0\x77\x04\x7e\x8f\x40\x66\x04\xb1\x8e\x60\xdd\x2a\xa1\xaf\x04\x9f\x46\x62\x67\x24\xb1\x8f\xc4\xf6\x55\xf8\x73\x15\xf1\x5e\x85\xcf\x57\x33\x4e\x39\xc9\x28\x74\x8c\xe2\x61\x14\xbe\x8f\x22\xe7\xa3\xc1\x6e\x34\x39\x1d\x83\xdc\x18\xea\x65\x0c\xf9\x1f\x4b\x2e\xc6\xe2\xeb\x58\xf4\x8f\x45\xff\x58\x7c\x1d\x87\xaf\xe3\xf0\x75\x3c\x3a\xc7\x13\xcf\x78\x74\x8e\x27\x17\xe3\xf1\x67\x02\xb8\x4f\xa0\x6f\x02\xf5\x7b\x0d\x58\x5d\x43\x7b\x2d\x35\x7b\x2d\x31\x5c\x4b\x0c\xd7\x12\xc3\x44\xea\x71\x22\xd8\x4e\xc4\xc7\x89\xe8\xbb\x0e\x7d\xd7\xa1\xef\x3a\xc6\xaf\x63\xfc\xba\x5d\x22\x93\xf0\x65\x12\xfe\x4d\xc2\xbf\x49\xf8\x33\x09\x7f\x26\x11\xdb\x64\x6a\x69\x32\xfe\x4c\x46\x7e\x32\x76\xaf\xc7\xaf\xeb\xf1\xeb\xfa\x6f\x44\xa6\x30\x36\x85\xb1\x29\x8c\x4d\x41\xf7\x14\xf0\x2b\xc5\x76\x29\xb6\x4b\xc9\x45\x29\x79\x2e\x05\x3f\xfd\xaf\x8f\x98\x4a\x2e\xa6\x82\xc7\x54\x74\x4c\x45\x7e\x2a\xba\x6f\x40\xfe\x06\x7c\xbb\x11\x7c\x6e\x44\xf6\x26\xb0\xbf\x09\xd9\x9b\x90\xbd\x09\xd9\x9b\x90\x25\xbd\x72\x33\x31\xde\x8c\x9d\x9b\xb1\x73\x33\xf5\x73\x0b\xb5\x7b\x0b\x7c\xb7\xc0\x77\x2b\x76\x6f\x25\xe6\xdb\xe8\xbb\x8d\x39\x76\x1b\x79\xbc\x0d\x9e\xdb\x89\xe7\x76\xe4\x6e\xa7\xde\x6f\x67\x2e\xdd\x0e\xdf\xed\xc4\x79\x07\xef\x77\x80\xf3\x9d\xe0\x7c\x27\x3a\xef\x44\xe6\x4e\x30\xb8\x13\x99\x69\xf8\x3e\x0d\x2c\xa7\xa7\x42\xe8\x9c\xc1\xfb\x0c\xf2\x33\x03\x3b\x33\xf0\x67\x06\xf2\x77\x61\xe7\x6e\x74\xcf\x64\x6c\x26\x63\x33\x99\x0f\x33\xc9\xe7\x4c\xf2\x31\x93\x7c\xdc\x43\x2c\xf7\x50\x1f\xf7\x80\xd3\x3d\xd4\xda\x3d\xe0\x7d\x2f\xbc\xf7\x82\xed\xbd\x60\x7b\x2f\xd8\xde\x0b\xb6\xf7\xd2\x3f\x8b\x3c\xcc\x62\xce\xce\xc6\xd6\x1c\x74\xcc\xa1\x76\xe6\x9c\x13\x99\x4b\x9e\xe7\x82\xd5\x5c\xb0\x9a\x8b\xde\xb9\xe8\x9d\x47\x2c\xf3\xf0\x6d\x1e\x7d\xf3\xf0\x63\x1e\x7c\xf3\xe1\x9b\x4f\xdf\x7c\xe6\xe8\x7c\x74\xce\x87\x6f\x01\xf6\x17\x60\x7f\x01\xf6\x17\x80\xc5\x02\x74\xdf\x07\xae\xf7\x61\x77\x21\x7d\x8b\xc6\x41\xc8\xde\x8f\xde\x07\xa8\x81\x07\x89\xe7\x41\xea\xe6\x21\x70\x78\x18\x4c\x1f\x06\x93\x87\xd1\xf3\x08\x58\x3f\xca\xfb\xa3\xe4\xf9\x31\xfa\x1e\x87\xef\x71\x30\xfa\x07\xf8\x3d\x41\xfc\x4f\x90\xbf\xc5\xe8\x7c\x12\xff\x9f\xc4\xde\x93\xc4\xfa\x14\xed\x53\xd4\xfe\x12\x78\x96\xc2\xbf\x14\x1b\x4f\xe3\xdf\xd3\xe4\xf6\x69\x30\x7f\x86\xf7\x7f\x92\xd0\x67\xc1\xe2\x59\xe2\x7f\x0e\xf9\xe7\xf1\xe7\x5f\xe0\xfd\x2f\xec\xbc\x40\x1e\x5e\x40\xcf\x8b\xf4\xe9\x7f\x27\xc8\x32\xf2\xf6\x12\xbc\x2f\xd1\xbf\x1c\x1f\x5e\xa6\xef\x65\x7c\x78\x05\xcc\x5f\x81\x7f\x05\xf2\x65\xc4\x5b\x46\x9c\x2b\xb1\xbd\x92\xb8\x5e\x85\xf7\x35\x6c\xac\xa2\xde\x56\xc1\xfb\x3a\x71\xbc\x81\x8f\x6f\x80\xc3\x6a\x7c\x5a\x4d\xbd\xad\xc6\xf6\x6a\x62\x5c\x03\xfe\x6b\xd0\xbf\x06\xd9\x35\xe8\x5c\x03\x3e\x6b\x58\x0f\xd6\xe0\xc3\x1a\xe6\xe7\x1a\xf8\xd6\xc2\xb3\x16\x9c\xd6\xa2\x73\x2d\x38\xad\x45\xe7\x3a\xf4\xac\x23\xf7\xeb\xa8\x8b\x75\xd8\x5e\x07\x16\x6f\xe2\xc7\x9b\xe4\xf7\x4d\xe4\xdf\xc4\xd6\x7a\x7c\x5d\x0f\x0e\xff\x26\xf7\xff\x46\xfe\xdf\xe4\xed\xdf\x9b\xd8\x2e\x91\x7d\x8b\xb5\xf1\x2d\x62\x7c\x1b\xbb\x1b\x90\xd9\x40\x1c\x1b\x18\xdb\x00\x76\xef\x90\xd3\x77\xf0\xf7\x1d\x70\x7b\x87\x9a\x78\x87\x5c\x6f\x04\xef\x8d\xf8\xb9\x11\xde\x8d\xe4\x69\x23\xfc\x1b\xb1\xbb\x11\x3b\xef\xa2\xff\x5d\xfc\xda\xc4\xf8\x26\x74\x6e\xc2\xfe\x26\xb0\xde\x8c\xcd\xcd\xf8\xbc\x99\xb1\xcd\xf8\xfc\x1e\x76\xdf\x23\x9f\xef\xd1\xf7\x1e\xb2\xef\x91\x93\x2d\xf8\xb8\x05\x5c\xb7\x10\xf7\x16\xe6\xe4\x16\xe4\xde\xa7\xce\xde\xc7\xef\xf7\xc1\xfe\x7d\xf2\xf5\x3e\x3e\x7d\x80\x4f\x1f\xe0\xcf\x07\xd8\xfd\x00\x5c\x3e\x64\x4e\x7e\x88\xbd\x0f\xc1\xec\x43\xf0\xfe\x10\x1f\x3f\x42\xff\x47\x60\xfe\x11\xb2\x1f\xa1\xef\x23\x6c\x7c\x8c\xad\xad\xd8\xdc\x0a\x4e\x5b\x99\x3f\x9f\x60\xef\x53\x62\xdb\x06\xdf\x76\x9e\xb7\xa3\x6f\x07\xfe\xef\x80\x67\x07\x8b\xc4\x0e\xea\x78\x07\xfa\x76\x80\xe7\x4e\xf2\xb4\x93\xdc\xed\x24\xc6\x5d\xf0\xec\x82\x67\x17\x3c\xbb\xa8\xf3\x5d\x8c\xef\x66\xed\xd8\x8d\xdd\xcf\x18\xdf\x03\x76\x7b\xc9\xd3\xe7\xf8\xb9\x8f\xbc\x7c\x41\x0c\xfb\xf1\x67\x3f\xf9\xfb\x12\x8c\xbf\x24\xae\xaf\x88\xf7\x00\xfa\x0e\x22\x77\x10\x5c\xbf\x26\xbe\x72\x78\xcb\xb1\x73\x88\xbe\xc3\xc4\x77\x04\x9c\x8f\x60\xff\x28\x18\x57\x10\xc7\x37\xbc\x7f\x43\x2d\x7c\x8b\x8e\xef\xf0\xf7\x18\xfa\x8f\x51\x77\xc7\xe1\xf9\x1e\x5d\x3f\xd0\x77\x02\x2c\x4e\xe0\xc7\x49\xd6\x97\x1f\xc9\xcf\x4f\xf4\xfd\x4c\xdf\xcf\xcc\xe5\x53\xe4\xfc\x34\x31\xfe\x02\x56\xbf\xe0\xf7\xaf\xe8\xfa\x15\x5f\x7f\x23\x8e\xdf\xa9\x17\xfd\x8f\x3f\x9c\xc1\xd6\x59\xf4\x52\xba\x72\x0e\x9d\xe7\xc8\xd5\x79\x62\x3d\x8f\xbf\x41\xc6\x82\xbc\x87\x1e\xe2\x62\x58\xc4\xad\x3a\x1a\x3a\xc9\xc1\x72\xb1\x28\xb3\x00\x5a\x25\xca\x36\x59\x94\xbd\x97\x28\x87\xcb\xfa\x27\xe0\x94\xb3\x10\xfa\x58\x94\x6b\x14\x74\x50\x94\x7b\x26\x44\x1b\xd5\x06\xda\x26\xaa\xda\x38\x51\xd1\x9a\xbe\x11\x15\xf3\x98\xa8\xea\xa9\xd0\x29\x51\xb1\x37\x8b\x3e\x84\x2a\x0f\x3c\x71\x4b\x39\x04\x37\x80\xe6\x8b\x4a\xa8\x05\x2d\x17\x95\x88\xfe\x44\xde\x93\xfa\x43\xe7\x44\x25\xff\x26\x2a\x65\xba\xa8\x54\xfa\x53\xf1\xaf\x46\x4b\x08\xbd\x35\x91\xab\xf9\xbe\xa8\xb4\x17\x44\xd5\xf2\x40\xeb\x45\xd5\x0e\x40\xf0\xd6\xc1\x37\x6f\x22\x84\x9f\xbe\x0d\xa2\xd2\xd1\x93\x91\x2b\x8a\x73\x8d\xca\x44\x3e\xeb\x5a\x0e\xe1\x43\x45\x35\x40\x47\x03\x62\x6c\x88\xdf\x97\xd1\xd7\x88\xb8\x1b\xa1\xb3\xd1\x7e\x51\x8d\x6f\x87\x8e\x8b\x6a\x82\xaf\x4d\xf0\xb9\x29\xf6\x9b\x62\x3f\xbb\x19\x04\x1e\xd9\x9b\x20\xf4\x37\xf3\x41\xc8\x36\x5b\xc3\xb1\x5a\x1f\xad\xc1\xab\x39\x3a\x5a\xd0\xb6\x00\xcb\x16\xf8\xda\x82\xb1\x1c\xe4\x73\xe0\xcb\x21\x6e\xfd\xaf\x2a\x6a\x89\x8f\x2d\x89\xb3\x25\xbc\x2d\x89\xd1\x5f\x0f\x2a\x81\xf0\xc7\x8f\xdd\x56\xe0\xd1\x0a\x6c\x5b\x81\x49\x2b\x72\xd1\x1a\xbf\x5b\x83\x71\xeb\x32\x51\x6d\xd0\xc9\x59\x49\xb5\x45\x67\x5b\x9e\xdb\x61\xa7\x1d\x71\x5e\x4e\x3c\x97\xa3\xb3\x3d\x3e\xb6\x47\xb6\x03\x18\x74\xa0\xaf\x03\x39\xe9\x40\xfe\x3a\xe0\x47\x47\x6c\x77\xc4\xb7\x8e\xe0\xd4\x71\x8d\xbe\x28\x40\xf0\x75\x02\x8f\x4e\xc4\x13\x00\xcb\x00\x79\x0e\xa0\x27\x40\x7e\x39\x6b\xa9\xce\xf8\xdd\x19\x7c\xbb\x30\xd6\x05\xb9\x2e\xc4\xd0\x15\xdb\x5d\xc1\xbb\xeb\x54\x08\x1f\xbb\xe2\x63\x2e\xb6\x72\x79\xcf\x25\xaf\xb9\xc8\xe6\x82\x6b\x1e\x71\xe6\xd1\x97\x47\x0d\xe4\xed\x85\xc8\x45\x3e\xfe\xe5\x83\x6f\x3e\xf6\xba\x61\xbb\x1b\x72\xdd\xb0\xd9\x0d\xdd\xdd\x88\xa3\x80\xbe\x02\xf2\x5f\x80\x0f\x05\xe0\x5c\x80\x4c\x77\xe2\xef\x0e\x3e\xdd\xe9\xeb\x0e\xfe\xdd\xc9\x51\x0f\x7c\xe8\x81\x0f\x3d\xc8\x4f\x0f\xea\xa0\x07\xfa\x7b\xd2\xd7\xb3\x31\x04\x2e\x3d\x9f\x85\x88\xb1\x27\x78\xf6\x22\xff\xbd\xf0\xa3\x17\x7e\x5d\x81\xfe\x2b\x88\xeb\x0a\x78\xae\xc0\xde\x15\xf8\x71\x25\xb1\x5d\x49\x0e\xae\xa4\xef\x4a\xf4\x5c\x89\xcd\xde\xf4\xf5\x46\xae\x37\xf8\xf6\xc6\xdf\xde\xc4\xd5\x9b\x7c\xf5\x26\xd6\x42\x7c\x2e\xa4\xbf\x10\x7f\x0a\xa9\xeb\x3e\xc4\xd4\x67\x36\x84\xbd\x3e\x87\x45\xf5\x45\xb6\x2f\xf6\xfa\x82\x4d\x5f\xf2\xdb\x0f\xff\xfb\x91\x93\x7e\xe0\xd0\x0f\x1f\xfa\x21\xd3\x1f\x5c\xfb\xa3\x6b\x00\x3e\x0c\xa0\x1d\x48\x2d\x15\xe3\x43\x31\xb1\x17\xa3\xb7\x18\xfc\x06\x13\xcb\x60\x72\x33\x98\xf7\xc1\xbc\x0f\x61\x1e\x0d\x01\xd3\x21\x60\x30\x14\xbe\xa1\xf4\x0f\xc5\xff\x61\xd4\x0b\xe7\x49\x35\x0c\x1b\xc3\xd0\x3f\x9c\x18\x87\x53\xef\xc3\xe1\x1d\x4e\xdf\x70\x7c\x1f\x8e\xcc\x70\xfc\x1f\x0e\x76\xc3\xb1\x37\x02\xff\x47\xe0\xc3\x08\xf8\x47\xa0\x7b\x04\x3e\x95\x90\x87\x12\xf2\xc0\x39\x53\x95\x80\x7d\x09\xba\x47\x2e\x12\x75\x15\x7a\x38\x67\xaa\xab\xc0\xf9\x6a\x62\x19\x0d\xdf\x68\xfc\x1a\x8d\xde\xd1\xc8\x8e\xc1\xcf\x31\xf0\x8d\x21\xf6\xb1\x60\x3b\x16\x1c\xc7\x92\x97\xb1\x60\x32\x16\x9b\xe3\xf0\x6d\x1c\x3a\xc6\xa1\x63\x1c\xb5\x38\x1e\xdf\xc7\xe3\xd7\x78\x30\x1a\x8f\x0c\x67\x4c\x35\xc1\x06\x21\x33\x01\x99\x09\xd8\x9d\x40\xff\x35\xf0\x5c\x03\xcf\x35\xd4\xfe\x44\x70\xbc\x8e\xfc\x4e\x06\x83\xc9\xc4\x70\x3d\x18\x5f\x4f\x2d\x5f\x8f\x4c\x29\xf3\xa1\x14\x7f\x4b\x89\x6b\x2a\x18\x4e\x65\xdd\xb9\x01\x5c\x39\xef\xa9\x9b\xc0\xfc\x66\x74\xdc\x02\x46\xb7\xd0\x77\x2b\x3a\x6f\x85\xf7\x36\xfc\xbc\x9d\x7c\xdd\x01\x06\xd3\xf0\x6f\x3a\x72\xd3\x89\x6d\x3a\xf9\x9f\x81\xff\x77\xa1\xff\x2e\x6a\xe8\x6e\x70\xbc\x9b\x9a\xe7\x8c\xa5\xee\x25\x9f\xb3\xb1\x37\x17\x1d\x73\x99\xab\x73\xf1\x73\x1e\x7e\xcf\x43\x6e\x1e\x7d\xf3\x89\x6d\x81\x26\xfc\xb8\x0f\x3f\xef\x23\xe6\xfb\x88\x79\x21\xb6\x16\xa1\x67\x11\x3a\xee\xa7\x96\x1e\x20\x3f\x0f\xa0\xf3\x41\xea\xeb\x41\xf2\xf2\x10\xd8\x3d\x04\x06\x0f\xf3\xfc\x08\x32\x8f\x52\x0b\x8f\xa2\xe3\x31\xfa\x1f\xa7\xd6\x1e\x07\xc3\x7f\x80\xfd\x13\xd8\x5e\x4c\xad\x2d\x06\x8b\x27\x89\xe5\x29\x74\x2d\x61\x7c\x09\x3e\x2f\xc5\xce\xd3\xf8\xf1\x34\x63\xcf\xe8\xbf\x12\x8b\xfd\x67\x18\xe3\x3c\xa4\xfe\x49\xae\xff\x49\x4c\x9c\x8b\xd4\x3f\xc1\xf7\x59\x7c\x7e\x16\xdd\xcf\xd1\xff\x1c\xfd\xcf\x91\xf3\xe7\xc0\xe9\x39\x6a\xe1\x79\xda\x7f\xc1\xf7\x22\x35\xb0\x0c\x9e\x65\xe4\x78\x19\xcf\x2f\x61\xff\x25\xf0\x5a\x0e\xd6\x2f\x23\xf7\x32\xb1\xbc\x42\x1c\xaf\x90\x83\x57\xf0\x63\x05\x76\xcb\xb0\x5b\x06\x6f\x19\x36\x57\xb2\xb6\xac\x04\xa3\x95\x60\xb6\x8a\xfe\xd7\xb1\xf9\x3a\xef\xaf\x63\xe3\x0d\x7c\xe5\xac\xa4\xde\x60\x6e\xbe\xc1\x5c\x5b\xcd\xda\xbb\x1a\x9d\xab\xf1\x65\x35\xb6\x57\xe3\xe3\x1a\xf0\x5f\x47\xce\xd6\x51\x5b\xeb\xf0\xe9\x4d\xe4\xd7\x23\xfb\x16\xfe\xbc\x4d\xbe\xde\xc6\xde\x06\xfa\xdf\xc1\xf6\x46\xb0\xdd\x48\xce\x37\xd2\xf7\x2e\x18\x6e\x22\xdf\x9b\x68\x37\x53\xa7\x9b\xa9\xd3\xf7\x90\xdb\xc2\xfb\xfb\xe0\xfa\x3e\xf8\xbe\x0f\x5e\x1f\xd0\x7e\x48\xfb\x11\xfe\x73\x9e\x50\x1f\x91\xeb\x8f\xe0\xf9\x88\xda\xd8\x4a\xbd\x6d\x25\xce\x4f\xa9\x9f\x4f\xc9\xc3\x36\xc6\xb7\xa1\x63\x07\x18\xec\x22\x86\xdd\xd4\xca\x6e\xd6\xc4\xcf\xb0\xbb\x07\x0c\xf6\x90\xcb\xbd\xf8\xbe\x97\xb1\xbd\x3c\x7f\x8e\x8e\xcf\xc9\xe7\x3e\xf2\xb6\x0f\x1b\xfb\xf0\x8d\xb3\x82\xda\x4f\x4e\xf6\x13\xf7\x97\xe8\xff\x0a\xfb\x5f\x81\xfb\x57\xd8\xfc\x8a\xf1\x83\x60\xf6\x35\x54\x8e\xbf\x87\xe0\x3d\x44\xff\x61\xe2\x3b\x82\x1f\x47\xb1\x77\x94\xf7\x0a\xe2\xfa\x86\xfc\x7f\x03\x66\xdf\x62\xff\x3b\xb0\x38\x06\x5e\xc7\xc1\xf1\x07\xf4\xfd\x80\xcd\x13\xac\x09\x27\xe9\xff\x11\xb9\x9f\xc0\xf0\x27\x6c\xfd\x04\xef\x4f\x8c\xfd\x4c\xce\x4e\xe1\xd3\x69\x72\xf4\x0b\xb6\x7f\x03\xd3\xdf\x89\xe1\x77\xe6\xc0\xef\xc8\x9c\xa1\x4e\xcf\x10\xe7\x59\x30\x39\x8b\xfc\x59\xfc\x3a\x47\x0e\xce\xa1\xfb\x1c\xf8\x9c\xe7\x3d\x54\x60\xfd\x9b\xec\x0c\xd9\x2f\x86\x9a\x2f\x86\xd1\x06\xe2\x99\x73\x82\x61\xd3\x7f\x7b\xbb\x17\xb4\x41\x0c\x7b\x33\xe8\xb0\x18\x8e\xc7\xc4\x70\x2e\x15\xc3\x45\xeb\x7e\x56\x8c\xa8\x32\x31\xaa\x15\x89\x11\x6d\x83\xb6\x89\x11\x33\x5b\x8c\xea\x85\x62\xc4\xd6\x82\x36\x89\xe1\xb9\x16\x3a\x2e\x46\xdc\x64\x08\xf9\xf8\xa1\x62\x24\xf8\x20\xfa\x12\x7f\x13\x23\xe9\x94\x18\xc9\xc8\xa5\xa0\x8b\x73\x81\x91\x0a\x7f\x2a\xf6\x6a\xd4\x83\xe8\xab\x89\xdd\x9a\x8c\xa7\xdd\x0e\xc1\x5f\x6b\xaa\x18\xb5\xe1\xab\xfd\x82\x18\x75\xd0\x55\x07\x79\x2f\x7d\xde\x99\x62\xf8\xb0\x91\x3e\x4a\x8c\xba\x50\x06\xcf\x19\xd3\x21\xe2\xc8\xc0\x6e\x3d\xda\x4c\x74\x64\x11\x6b\x16\xfe\xd7\x0f\x40\x07\xc5\x68\x00\x6f\x83\x6f\xc4\x68\x88\xfc\x65\xd8\xbc\x0c\xde\x46\x8b\x20\x78\x1a\x61\xb7\x31\x71\x35\x6e\x0f\x61\xa3\x31\x3c\x8d\x1f\x82\xde\x87\xf0\xa5\x09\x7e\x34\x49\x85\xc0\xa8\x09\x63\x4d\xd6\x40\xc4\xd5\x94\xf8\x9a\xf6\x87\xe0\xc9\x86\x27\x1b\x4c\xb3\xc7\x41\x8b\x21\x74\x36\xa3\xaf\x19\xf6\x9b\x9d\x14\xa3\x39\xf8\x35\xc7\x66\x0b\xf0\x6a\x81\x4c\x0b\xf0\xe3\x8c\x61\xb4\xc0\xa7\x1c\xfa\x72\xc0\x32\x07\xdd\x39\xf4\xe5\xa0\xbb\x25\xba\x5b\x12\x47\xcb\x5d\x62\xf8\xa3\xa1\x5c\x08\x3b\xad\xc0\xaa\x75\x89\x18\x6d\x18\x6f\x03\x7e\x9c\x25\x8c\xb6\xe8\x6d\x0b\x3e\xed\xd6\x8b\x71\x39\x7e\xb7\x67\xbc\x03\xfe\x76\xc0\x87\x8e\xc4\xd3\xa9\x01\x84\x9e\x00\x58\x75\x46\x57\x67\xec\x75\x6e\x0c\x2d\x17\xa3\x0b\x6d\x17\xe2\xee\x42\x6c\x5d\xd0\xd1\x15\xf9\xae\xd8\xe8\x0a\x8e\x5d\xc9\x6b\x57\xe4\x72\x89\x8b\xb3\x81\x91\x87\x6c\x1e\x3e\x71\x1e\x30\x38\x0f\x18\xf9\xd4\x43\x3e\xd8\x76\xc3\x56\x37\xe2\xec\x46\xad\x74\x83\xaf\x1b\x75\x55\xc0\x78\x01\xfa\xd8\xff\x0d\xf6\x7e\xa3\x47\x22\x04\x4f\x0f\xfc\xed\x01\x3e\x3d\x88\xb1\x27\x31\xf4\x6c\x09\x91\x83\x9e\xe0\xd3\x13\xb9\x5e\xd8\xe8\x45\x7f\x2f\xfa\x7b\x91\x9f\x5e\x60\xc7\x7e\x6f\x5c\xc9\xfb\x95\xe8\xb9\x12\xbc\xd8\xdf\x8d\xde\xd8\xe9\x8d\xfe\x42\x62\x29\x04\xcf\x42\xf2\x5b\xc8\x58\x1f\x62\xed\x43\xad\xf7\x21\xee\x3e\xe8\xed\x03\x5f\x1f\xf4\xf6\xc1\x5e\x5f\xfa\xfb\xe2\x7f\x5f\x6c\xf5\xc3\xe7\x7e\xbc\xf7\x03\x53\xf6\x74\x63\x00\x73\x60\x00\x39\x18\x40\xce\x07\x10\xdf\xc0\x9b\x21\xe4\x06\xa1\x67\xd0\xf2\xf0\x67\xc1\x22\xfa\x8a\xf0\xa7\x98\x98\x06\xe3\xe7\x60\xe2\x19\x4c\x7d\x0e\x41\xcf\x10\xb0\x1a\x0a\x8e\xec\xeb\xc6\x30\x70\x19\x86\xbd\xe1\xf0\x0f\xc7\xfe\x08\x70\x29\xc1\xaf\x12\xf8\x4b\x18\x2b\x21\x0f\x25\xf8\x56\x42\xde\x46\x82\xfb\x55\xd4\xde\xd5\xb4\xa3\xe0\x19\x05\xd6\xa3\xc0\x7f\x34\x3a\x47\x13\xf7\x18\x6a\x62\x0c\x3a\xc7\xf2\x3e\x16\xd9\xb1\xe4\x74\x3c\xf3\x61\xfc\x5e\x88\x78\xc7\xe3\xff\x04\x62\x9a\x80\xcf\xd7\xf0\x7e\x2d\x98\x4c\x44\xee\x3a\x30\xbc\x8e\x79\x71\x1d\xe3\x93\x98\xef\x93\x79\xbf\x9e\x5c\x5d\x8f\xff\x53\xf0\xab\x14\x5b\xa5\xd8\x2f\x85\x7f\x2a\xf6\xa7\x92\x9f\xa9\xc8\xdd\x80\x6f\x37\xe2\xe7\x8d\xc8\xde\x08\xfe\xec\xc5\xc6\x8d\xc8\xdc\x44\xbd\x72\x65\x33\xd8\x93\x8d\x5b\xd0\xc5\x9e\x6c\xdc\x8a\x6f\xb7\x12\xe7\x6d\xe0\x76\x1b\xb9\xb9\x9d\xf6\x76\x6a\xf0\x76\xf8\xef\xc0\xd7\x3b\xf0\xfb\x4e\xe6\xe1\x9d\xe0\x37\x0d\x99\x69\xd4\xd6\x74\x70\x9b\xce\xf8\x0c\x30\x9c\x41\x7b\x17\x98\xdd\x05\x16\x77\x93\xdf\x99\xf8\x30\x13\x7f\xef\x01\xd3\x7b\xc1\x6d\x16\x7e\xce\x46\x6e\x36\xd8\xce\x21\xc7\x73\x99\x4f\x73\x99\x1f\xf3\xb0\x3b\x0f\x1c\xe6\x83\xd9\x02\x7c\x5f\x00\xff\x7d\xc8\xde\x07\xce\xf7\x81\x01\xfb\xb6\xb1\x10\xbf\x17\x81\xd3\x22\x70\xba\x1f\xbe\x07\xf0\xfd\x01\x74\x3c\x88\x3f\x0f\x22\xfb\x10\x76\x1f\x62\xec\x61\xb0\x79\x84\x39\xf0\x08\x31\x3f\xc2\xf8\x23\xd4\xe7\x23\xe0\xf9\x28\xf5\xfb\x28\x75\xf6\x28\xfa\x1e\x05\xdb\xc7\x90\x7b\x1c\x1d\xff\xc0\xce\x13\x60\xb7\x18\xfe\x27\xa9\x8f\x25\xc4\xb3\x94\xb8\x9f\xc6\xd6\x33\xd8\x61\xaf\x36\x9e\xa5\xbe\x9f\x83\x9e\xc7\xcf\xe7\xc1\xe7\x5f\xd4\xd4\x0b\xe8\x79\x91\x1c\xbe\x08\x2e\xcb\x68\x97\xd1\xff\x12\x7e\x2c\x07\xaf\x97\xc9\xf7\x2b\xd4\xef\x0a\xfc\x2f\x43\x47\x19\x31\xae\x84\x5e\x25\x07\xaf\x81\xd3\x2a\x6a\xfc\x75\xec\xbe\x4e\x4c\x6f\x80\xff\x6a\xe2\x5b\x0d\x3e\x6b\xc0\x6f\x2d\x3e\xac\x83\xde\xe4\x7d\x3d\x39\xf9\x37\x79\x60\xaf\x35\xde\x26\xa6\xb7\xc9\xed\x06\x9e\xdf\xc1\xb7\x8d\xc8\x6c\xc4\xe6\xbb\xc4\xb7\x89\xb1\x4d\xc4\xb4\x19\xdf\x37\x13\x3f\xf7\x7f\xe3\x3d\xe6\xc3\x7b\xd8\xdf\x42\xdf\x16\x62\xdb\x82\x9d\x2d\xf8\xf7\x3e\xed\xfb\xf8\xff\x01\x78\x7c\x40\x6d\x7c\x88\x7f\x1f\x92\xa3\x8f\x88\xef\x63\xf8\x3e\x66\x2e\x6d\x05\xcb\xad\xf4\x7d\x02\xdf\xa7\xf4\xb1\xff\x1a\xdb\xb0\xbb\x1d\xdf\xb7\x93\xbb\x1d\xe0\xb8\x03\xdd\x3b\xf0\x77\x27\xf8\xec\xc2\xfe\x2e\xfa\x77\x83\xc5\x6e\xf8\x76\x83\xcd\x67\xe8\xfe\x0c\xff\x3f\x83\x67\x0f\x39\xdf\x03\xa6\x7b\x88\x9f\xfb\xbb\xb1\x17\xff\xf6\x12\xc3\x5e\x7c\xdd\x8b\xee\xcf\xf1\xf1\x73\xe2\xf9\x9c\x79\xfb\x39\x35\xfa\x39\x18\x7e\x4e\x2d\xef\x23\x47\xdc\xf1\x8d\x7d\xc4\xb8\x8f\x5a\x63\x1f\x37\xf6\x11\xf3\x17\xc4\xf6\x05\x7e\x7d\x01\xff\x17\xf4\x7f\x81\x9d\x2f\xb0\xb9\x1f\x4c\xf7\xc3\xbf\x9f\x18\xf7\xe3\xc7\x7e\xea\xf5\x4b\x72\xfc\x25\xf9\xfd\x12\xfb\x5f\xe2\xeb\x97\xf4\x7f\x09\xbe\x5f\xa1\xe3\x2b\xf2\xf6\x15\x7d\x5f\x51\x6f\x5f\x51\x3b\x07\xf0\xeb\x00\x7e\x1c\x20\xce\x03\xf8\x76\x00\xbd\x07\xc0\xe1\x20\x7e\x1c\x44\xc7\x41\x74\x1c\xa4\x96\x0e\x92\xdf\x83\xe4\xe7\x6b\x6a\xf5\x6b\xf8\xbf\xc6\xbf\xaf\xc1\xef\x6b\xfc\xfb\x9a\x1c\x95\x13\x6f\x39\xb8\x96\xe3\x47\x39\xfd\xe5\xf4\x97\xd3\x7f\x88\xfe\x43\xd8\x3c\x44\xff\x21\xfa\x0f\xa1\xe3\x10\x79\x3b\x0c\x7e\x87\xc1\xe3\x30\xf5\x75\x98\xb9\x75\x18\xff\x8e\x80\xc9\x11\xe6\xd0\x11\xfa\x8f\xd0\x7f\x84\xbc\x1c\xc1\xc7\xa3\xd8\x3c\x8a\xcd\xa3\xe8\x38\x4a\xdf\x51\xf0\xa8\x60\xff\xab\xc0\xe7\x0a\xb0\xa8\x20\xc7\xdf\x10\x33\xe7\x13\xe3\x1b\x6a\xf0\x1b\xfa\xbe\xc1\xfe\x37\xc4\xf1\x2d\x7c\xdf\x12\xc3\xb7\xc4\xf6\x2d\x7d\xdf\xe2\xd3\x77\xf8\xf4\x1d\x7d\xdf\x91\x9b\xef\xc0\xe1\x3b\xe4\x8f\x61\xe3\x18\x36\x8e\x81\xef\x31\xf2\x75\x1c\x7d\xc7\xc1\xf5\x38\xef\xc7\xf1\xfb\x38\xb2\xc7\xc9\xeb\xf7\xd4\xf1\xf7\xd4\xc2\xf7\xf4\x7f\x8f\x9d\xef\xc1\xeb\x7b\xfc\xf9\x81\x3c\xfc\x40\x7e\x7e\x00\x97\x1f\xe8\xff\x01\xfe\x13\xe8\x3c\x81\x8e\x13\xe0\x7d\x02\x3b\x27\x88\xe5\x24\x7a\x4f\x82\xeb\x49\x62\x3c\x49\xde\x4f\x22\x7f\x12\xbd\x3f\xe2\xe7\x8f\xd4\xd2\x8f\xac\x51\x3f\x32\x6f\x7e\xa4\x16\x7e\x02\x8f\x9f\x90\xff\x09\x5b\x3f\x91\xc3\x9f\xc8\xed\xcf\xe4\xeb\x67\xfc\xfc\x19\x3b\x3f\x53\x8f\x3f\xe3\xeb\xcf\xc8\x9f\xc2\xaf\x53\xe0\x7c\x0a\x8c\x4e\x61\xeb\x14\x78\x9e\x26\x87\xa7\xf1\xe9\x34\x75\xf9\x0b\x78\xff\xc2\xda\xc0\xd9\xcb\xf8\x05\x0c\x7f\x41\xff\xaf\xd4\xc3\xaf\xe4\xec\x57\xb0\xfe\x95\xfa\xfb\x15\x3d\xbf\xe1\xc7\x6f\xf8\xf1\x1b\xbe\xfd\x86\xbd\xdf\xe1\xf9\x1d\x9e\xdf\xe1\xf9\x1d\xbf\x7e\x87\xe7\x0c\x3c\x67\xf0\xff\x0c\x3c\x67\x88\xf3\x2c\x7e\x9e\x05\xcf\xb3\xc4\x79\x16\x3f\xcf\x82\xe7\x39\xe2\x3c\x47\x3e\xce\x91\xa3\x73\xe0\x71\x0e\xbe\xf3\xf4\x9d\xc7\xf7\xf3\xc4\x73\x1e\xbe\xf3\xe8\x0f\x12\x4f\x10\x3c\x83\xf8\x15\xc4\xaf\x20\x73\x23\x84\xbe\x10\x75\x10\xc2\x46\x08\x3c\x42\xd8\x0d\x7d\x23\xa6\xd4\x82\x0a\xa1\xd9\xd0\x06\xe8\x94\x98\xaa\x01\x34\x14\x5a\x04\xed\x12\xd3\x80\xc7\x80\xc7\x98\x09\xad\x81\x8e\x8b\x69\xfa\xa0\xfe\x10\x7d\x9c\x15\x4d\xf3\xa0\x98\xb6\x68\xa8\x25\x54\x02\x21\xcb\xb9\xd1\xb4\xa1\xcf\x8e\x3e\x3b\xfa\xec\xf4\xd9\x37\x41\xbf\x89\xe9\xa0\xcf\x51\x04\x21\xef\x28\x83\x0e\x8b\xe9\x4c\x85\x72\x21\x78\x9d\xf3\xa1\xf5\x10\xb6\x5c\xd8\x77\x61\xdf\x05\xaf\x8b\x3e\x17\x3a\xdd\x8d\xa1\x51\xd0\x62\x08\x1f\xdd\xe8\x8c\x82\x2f\x0a\xf9\xa8\x6b\xa1\x87\x20\x78\xa3\xd0\x5b\x0d\xbf\xaa\xb5\x87\x26\x43\x2f\x40\xf8\x1a\x9d\x08\x15\x40\xf4\x45\x3f\x06\xe1\x6b\x34\x78\xc4\x78\xa0\x36\xd0\x38\x88\xfe\x98\x6d\x62\x56\x77\x41\xc8\x57\x87\xb7\xfa\xb3\xd0\x5e\x31\x63\x05\x22\x86\x58\xfc\x8a\xbd\x19\x5a\x0a\xbd\x0f\x9d\x14\xd3\x43\x1c\x1e\x74\x7b\xe8\xf7\x10\x9b\x07\xbd\x71\xe0\x15\x47\xbc\x71\x60\x10\x07\x5f\x1c\x7c\xf1\xf0\xc5\x07\x20\x6c\xc5\xd3\x1f\x0f\xb6\xf1\xf8\x96\x80\xbd\x04\x7c\x48\x20\x8e\x04\xec\x25\xec\x17\x33\x11\xbf\x12\x89\x2d\x11\xde\x44\xb0\x49\x04\xf3\x44\xfa\x93\x6c\x10\x58\x24\x81\x79\x12\x31\x27\x7d\x2c\x66\x32\x7d\xc9\xc8\x27\x23\x9f\x8c\x7c\x32\x7c\x29\xf4\xa5\xc0\x97\x42\xce\x52\x6e\x87\x96\x43\xd8\x4a\x05\x87\x54\x7c\x4d\xa5\x2f\x15\x5f\x53\xc1\xab\x06\x7e\xd5\x20\xde\x1a\xe8\xac\x41\x5d\xd4\xa0\xbf\x06\x31\xd7\x24\xe6\x9a\xc4\x5c\x93\x98\x6b\x92\x8b\x9a\xf8\x5b\x93\xd8\xd2\xe0\x4f\xeb\x05\xa1\x23\x0d\xbd\x69\xd8\xab\x85\xbf\xb5\x88\x8d\xf3\xba\x59\x0b\x1f\x6a\x21\xcf\xb9\xdd\xac\x4d\x0c\xb5\xa7\x43\xe0\x5d\x07\x7d\x75\xe0\xa9\xc3\x7b\x1d\xde\xbd\xbc\x7b\xf1\xd1\x0b\x4e\x5e\xec\x7a\xd1\xef\x45\xbf\x0f\xfd\x3e\x7c\xf4\x81\xa7\x8f\xb8\x7d\x60\x97\xde\x0c\x22\x1f\xe9\xf8\x96\xce\x7b\x5d\xe4\xea\x12\x6f\x5d\xea\xa1\x2e\x18\xd4\x3d\x27\x66\x06\x7d\x19\xd4\x52\x06\x78\x65\x50\x0b\x19\xd4\x52\x3d\xfc\xaf\x47\xdd\xd4\xc3\xa7\x7a\xc4\x9a\x59\x0f\xe2\x3d\x93\xf7\x4c\xde\xb9\x1f\x98\x59\xc4\x9e\x85\xae\x2c\x74\x65\xa1\x2b\x0b\x5d\xf5\xd1\x55\x1f\x5d\xf5\xc9\x53\x7d\x7c\xad\x4f\x5f\x03\x74\x71\x7f\x30\x1b\x80\x7b\x03\xea\xa4\x21\xfe\x37\xc4\xaf\x86\x60\xdc\x10\x5f\x1b\x52\x13\x0d\xf1\xff\x32\x7c\xbf\x0c\xb9\x46\xc4\xdf\x08\xff\x1b\xe1\x6f\x63\x9e\x1b\x13\x7b\x63\x62\x68\x0c\x66\x8d\xc9\x45\x13\x72\xd1\x84\xbc\x35\xc1\x0e\xf7\x09\xb3\x09\x7c\x4d\x79\xce\xc6\xa7\x6c\x78\xb3\xe1\xcd\x46\x3e\x9b\x5a\x6f\x86\xed\x66\xd8\x6e\x86\xed\x66\xcc\xa9\x66\xd8\x69\x4e\x9d\x37\xc7\x2e\xf7\x09\xb3\x05\xb6\x5b\x30\x2f\x72\xc8\x3b\x77\x08\x33\x87\x58\x72\xf0\xb1\x25\xef\x2d\x99\xa3\x2d\xd1\xd5\x92\x98\xb9\x47\x98\x2d\x89\xc5\x4f\x7d\xfa\xf1\xd3\x8f\x2f\xad\xf0\xa3\x15\xb9\x6f\x85\x4c\x2b\x74\xb7\x62\xbc\x35\xf1\xb7\xa6\xf6\x5a\x83\x65\x6b\x30\x6f\x8d\x5c\x6b\xfc\xe0\xbe\x61\xb6\x21\xde\x36\x4b\xff\x0f\x04\xb6\x6d\x89\xb7\x2d\x76\xda\x62\xa3\x1d\x36\xda\x11\x6f\x3b\x6c\x70\x67\x31\xdb\x31\xde\x8e\x58\x2e\xc7\xdf\xcb\xc1\xe3\x72\x6a\xa8\x3d\xf9\x6a\x0f\x06\x1d\xa8\xa3\x0e\x60\xd6\x01\x1f\x3a\x92\xab\x4e\xe0\xde\x89\x98\xb8\xcf\x98\x01\x70\x08\x30\x1e\xa0\x86\x02\xe0\xd2\x99\xb8\x3a\x53\x53\xb9\x60\x98\x4b\x8d\xe6\xb2\x06\x70\x6f\x31\xf3\xb0\x97\x87\xad\x3c\xea\x2c\x0f\xbe\x7c\xe2\xce\x67\x8c\x7b\x8b\xd9\x0d\xbe\x6e\xd8\xe9\x86\xfe\x02\x7c\x2a\xc0\x9f\xee\xd4\x45\x0f\xf0\xeb\xc1\x7b\x4f\xec\xf5\x64\xbc\x27\x73\x99\xfb\x89\xd9\x93\x5c\xf5\x62\xac\x17\xb2\xdc\x4d\xcc\x2b\xb1\xd5\x1b\xbb\x85\xf4\xf5\xc1\x4e\x5f\x72\xd8\x8f\x76\x20\x3a\x06\xa1\xbb\x08\x3b\xc5\xe0\x39\x18\xec\x86\x50\x1b\x43\xd1\x37\x14\x5b\xc3\xe9\x1f\x41\x0e\x4a\xd0\x3b\x12\x1f\xaf\xa2\xd6\xae\xc6\xbf\x51\x60\x34\x0a\xdc\x47\x63\x73\x0c\x39\x1e\x0b\x8d\x83\xc6\x23\x37\x1e\x7b\x13\x90\xb9\x86\xfa\xbe\x16\x7d\xd7\x32\xe7\xae\xa5\x2e\xae\x05\x8b\x89\x60\x31\x11\x2c\x26\x12\xe7\x44\x74\x4c\x64\xed\xbc\x8e\x7a\xb8\x0e\x3b\x93\xf0\x6d\x12\xb8\x4e\xc6\xb7\xc9\xe8\xbe\x1e\xbf\xa6\x50\x53\x53\x78\x2e\x65\x3e\x97\xf2\x5e\x8a\x5c\x29\x3e\x4c\x65\x8e\xde\x40\x4d\xdc\xc0\x9a\x78\x23\x75\x7e\x23\x36\x6e\x22\xbe\x9b\xd1\x7f\x33\x7d\xb7\xd0\xde\x02\xff\x2d\xe4\xe8\x56\x6a\x82\x3b\x80\x79\x2b\xb9\xbb\x0d\x3c\x6e\x43\xd7\x6d\xf8\x73\x1b\x38\xdd\xce\xd8\xed\xc4\xcd\x7d\xc0\xbc\x03\x99\x3b\xd0\x79\x07\x31\xdd\x49\xff\x9d\xc4\x73\x27\x71\x4f\x23\x26\xee\x04\x26\x77\x02\x73\x3a\x39\x9d\x4e\x1c\x33\xd0\x31\x03\xbf\xee\xc2\xd7\xbb\xc8\xeb\x5d\xc4\x7a\x37\x71\xdc\x0d\xff\x4c\x6a\x68\x26\xf1\xdf\x03\xb6\xf7\xd0\xde\xcb\x3e\x70\x2f\xed\x2c\x74\xce\x02\xdb\xd9\xd4\xcc\x6c\x7c\x9c\xc3\x9c\x9b\x03\x06\x73\xe1\x9b\x8b\x9f\xf3\xa8\x41\xee\x0b\xe6\x7c\xe2\x99\x8f\xcd\xf9\xf8\x32\x1f\xfe\x45\xd4\xfc\xa3\xf4\x3f\x85\x0f\x4f\x11\xfb\x12\xe4\x96\x60\x63\x09\x31\x2d\xc1\x87\x25\xd4\xdd\x52\xfc\x58\x4a\x8e\x97\x52\x7b\x4b\x79\x7f\x1a\xdc\xfe\xc9\xf8\x3f\xf1\xf5\x59\x78\x9f\x45\xff\x73\xe0\xf3\x3c\x98\xfc\x8b\xb8\x5e\x00\xaf\x17\xc9\xc3\x32\x7c\x59\x86\xce\x97\xb0\xf3\x12\x35\xbf\x9c\xba\x5c\x8e\xcc\xcb\xf8\xf2\x0a\x18\xaf\x60\x5e\xaf\x00\x9b\x32\x64\x56\x52\xf7\x2b\xc9\xd7\x6b\xe0\xb5\x0a\xff\x56\x81\xd3\xeb\xc4\xfc\x3a\xb5\xfa\x06\x18\xbc\xc1\xd8\x6a\xec\xae\xc1\xbf\x35\xc4\xb7\x16\xff\xd7\x51\xc3\xeb\xd0\xfb\x26\x78\xbd\x49\xac\xeb\x69\xd7\xeb\x96\x78\xfe\x0d\xdf\xbf\xf1\xed\xdf\xc8\x70\x1f\x30\xdf\x22\xff\x6f\x51\x2f\x6f\xb1\x0e\xbc\x85\xae\xb7\xb1\xf1\x36\xf1\xbc\x0d\x76\x6f\xa3\x63\x03\xfe\x6e\xc0\xef\x0d\x8c\xbf\x83\xcc\x46\xf8\x37\x82\xed\x46\xec\x6c\x44\xe7\x46\xf8\x36\xe2\xeb\x46\xea\x74\x23\xb9\xe5\x1e\x61\x6e\x44\xee\x5d\xf2\xf6\x2e\x7c\xef\x52\xef\xef\x12\xff\xbb\xe0\xf8\x2e\xbc\x9b\x90\xdf\xc4\xdc\xd9\x84\xce\x4d\xd4\xd5\x26\x30\xda\x44\xed\x6e\xc6\xa7\xcd\xc4\xb5\x99\xf8\x37\x13\xc7\x66\x30\xde\x4c\x5e\x37\x33\x1f\xde\x03\xe7\xf7\xc0\xe1\x3d\x6c\xbe\x07\x66\xef\xe1\xf7\x7b\xd4\x15\xf7\x11\x73\x0b\x79\xdc\x02\x4e\x5b\xa8\xe5\x2d\x60\xfa\x3e\xbc\xef\xa3\xeb\x7d\x74\xbd\x0f\x66\xef\xa3\xef\x7d\xf4\x7d\x80\x1f\x1f\x60\xf7\x03\x6c\x7e\x00\x0e\x1f\x82\xd1\xc7\xc8\x7d\x8c\x8d\xad\xc4\xbc\x95\xbc\x6d\x25\x87\x9f\x50\x2f\x9f\x60\xe7\x13\xf4\x7d\x8a\xaf\x9f\x92\x1b\xee\x2c\xe6\x36\xec\x6c\x03\x83\x6d\xcc\xc3\x6d\xc4\xba\x4d\xf7\x81\xd7\x76\xf0\xdc\x4e\x9c\xdb\xd1\xbf\x1d\x7d\xdb\xc9\xc9\x76\x70\xd9\x8e\xff\xdc\x6f\xcc\xed\xc4\xb7\x1d\x3c\x76\xe0\xd7\x0e\xf2\xbe\x03\xdf\x76\x90\x8f\x1d\xf8\xb2\x03\x9c\x77\xe0\xdf\x0e\xb0\xd9\x81\xbd\x1d\xe0\xb8\x03\xdf\x76\x10\xdb\x0e\xe2\xde\x49\x7c\x3b\xf1\x67\x27\xb1\xef\xa4\x8e\x76\x22\xb3\x93\xb9\xb0\x13\x5f\x77\x12\xd3\x4e\xf0\xdc\x49\xcc\x3b\xa9\x9d\x9d\xd4\xc3\x4e\xec\xec\xc2\xce\x2e\xec\xec\xc2\xce\x2e\xec\xec\x22\x96\x5d\x60\xb6\x0b\x9e\xdd\xe8\xda\x8d\x8f\xbb\x91\xd9\x8d\xef\x9f\x81\xc5\x67\xc4\xb1\x07\xfd\x7b\xf0\x7b\x0f\x3c\x7b\xa9\xbd\xbd\xe4\x6b\x2f\xb8\x7c\x4e\x5c\x9f\x83\xe1\xe7\xe0\xbd\x0f\x5f\xf6\x91\xff\x7d\xc4\xff\x05\xcf\x5f\x80\xef\x17\xc4\xf9\x05\x7a\xf6\xf3\xbc\x1f\xff\xf7\x63\xff\x4b\xea\xe5\x4b\xec\x7d\x49\x0c\x5f\x31\x37\xbe\x82\xe7\x2b\x62\x39\x00\x7e\x07\x88\xf5\x00\xd8\x1d\x04\xab\x83\xd8\x3e\x88\xcf\x5f\xc3\xf3\x35\xf1\x7c\x4d\x7f\x39\x7e\x97\x63\xbb\x9c\xe7\x43\x3c\x1f\x82\xff\x10\x3e\x1d\xc6\xef\xc3\xc4\x7d\x18\x7c\x8e\x90\xb7\x23\xd4\xce\x11\x70\x3a\x8a\xaf\x47\x89\xe7\x28\x38\x57\xe0\x6b\x05\xb2\x15\xd4\xe0\x37\xd8\xfa\x86\x78\xbe\x81\xe7\x5b\xfa\xbf\xa5\xff\x5b\xfa\xbf\xa3\xff\x3b\xb0\xfe\x8e\xe7\x63\xe8\x3c\x86\xec\x31\xf2\x73\x1c\xac\x8e\xe3\xf3\x71\xfa\xbf\x47\xe7\xf7\xf4\x7f\x8f\xec\x0f\xf0\xfc\xc0\xf3\x0f\xf0\x9c\x00\xa3\x13\xe8\x3c\x41\xff\x49\x74\x9e\xc4\x87\x93\xf8\xf6\x23\xfd\x3f\xa2\xf3\x47\x70\xfc\x09\xd9\x9f\xf0\xf3\x27\x78\x7e\xa6\xa6\x7e\x46\xe7\xcf\xc4\x78\x8a\xe7\x53\xf8\x70\x0a\xfe\xd3\xf0\x9f\x86\xff\x34\xf3\xe4\x17\xec\xfe\x02\xcf\x2f\xc8\xfe\xca\xf3\xaf\xe4\x94\xbb\x82\xf9\x1b\x7e\xfe\x86\xad\xdf\xf0\xe7\x77\x64\x7f\x47\xf6\x77\x64\xcf\x20\x7b\x06\xd9\x33\x60\x7e\x16\xdc\xce\xc2\x73\x16\xac\xce\x61\xf7\x1c\x18\x9e\x43\xcf\x79\x78\xce\xe3\xf3\x79\x72\x1c\x04\xab\x20\xfe\x04\xe1\x09\x81\x67\x88\xe7\xd0\x2a\xb1\x89\x0b\x1a\x0a\xad\x11\x9b\xf2\x40\x3c\xab\x17\xa0\x73\x62\x33\x0a\xa0\xc5\xd0\x29\xb1\x99\x01\x68\x11\x74\x58\x6c\xb6\xf6\xd0\x43\xd0\x5e\xb1\xd9\x13\xa1\x42\x68\x93\xd8\x1c\xb9\xd0\xed\xd0\x06\xb1\x39\x6d\xd0\x28\xe8\x59\x08\x19\x57\x3d\x88\x77\x17\xef\x2e\xde\xdd\xbc\x73\x5e\xb7\xb9\x79\x77\xf3\x1e\xc5\x7b\x14\xef\x51\xbc\x73\x46\xb7\x55\xe3\xbd\x1a\xef\x9c\xcf\x6d\xd5\x8e\x8b\x2d\xba\x19\x34\x15\xc2\xcf\x68\x7c\x8b\xc1\x56\xcc\x74\x08\xbb\x9c\xc7\x6d\xd5\xc7\x41\x8c\x71\x0e\xb7\xc5\xe2\x77\x2c\xbe\xc6\xe2\x9f\x87\x31\x0f\x3a\xe2\xe0\xe7\x8c\x6d\x8b\xc7\xd7\xf8\xd9\xd0\x6f\x62\x4b\xc0\xd7\x04\x6c\x25\x96\x40\xd8\x48\xc2\x46\xd2\x36\xb1\x25\x83\x41\x32\x32\xc9\xc4\x9d\x82\x0f\x29\xb4\xa9\xbd\x20\xfa\x6a\xe0\x57\x0d\xec\xd4\x24\x3e\xce\xbd\xb6\x9a\xef\x8b\x2d\x0d\xfe\x34\x62\xae\xe5\x83\xe0\xe1\x4c\xfb\x07\xdd\x0c\xe1\x4b\x6d\xdd\xbf\x0b\xc2\x4e\x1d\x64\xeb\xd4\x82\x1a\x43\x8c\x7b\xf1\xdd\x8b\x3f\xbe\xc7\xf4\x7f\x43\x47\x0c\xfd\xdf\x75\xb1\xb7\xb0\xcf\xe0\xf6\xe5\x14\x6f\x20\xc6\x61\xd8\x4d\xc3\x74\xbb\xec\x26\x8b\x90\x74\xda\x9a\xbd\x35\x2e\x5e\xb5\x6d\x1b\x97\x13\x97\xd3\xbc\x59\x42\x7a\x5c\x7a\x42\x5c\x7a\xdc\x56\xdb\xe8\xb3\x4f\xf4\x32\xb7\xda\x67\x9c\x99\x66\xf7\x9f\x4d\xb1\x7d\xab\xff\xd6\xa2\x21\xef\x88\xa8\x8a\xb0\x2e\x75\x30\x10\x32\x9d\x4e\xc3\x66\x73\xbb\x94\xb2\x1b\xa6\xcd\xfe\xe4\x10\xdb\x5d\x6e\x35\xd5\xad\x46\xb9\x55\x7f\xb7\xca\x77\xab\x16\x6e\x55\xd7\xad\x92\xdd\xca\xe6\x56\xa7\xdc\xea\xb0\x5b\xed\x72\xab\x4d\x6e\xb5\xca\xad\x9e\x75\xab\x87\xdc\x6a\xa6\x5b\x4d\xa9\xe4\xcf\xb5\xf8\xeb\xb9\x55\xa2\x5b\x19\x6e\x35\x2e\x2c\xb0\xc3\xad\xde\x73\xab\x37\xdc\xea\x79\xb7\x7a\xc0\xad\xee\xba\x58\xa0\x95\x5b\xf9\x2c\x01\x87\x5b\xfd\xe2\x56\xe5\x7f\x65\xe0\x46\xb7\x1a\xe3\x56\x03\x2d\x66\xbc\x51\x1e\xb7\x12\xb7\x3a\x59\xe9\xce\x86\x2a\xdc\x93\xdd\xaa\xc4\xad\x0a\xdd\x2a\xe0\x56\xcd\x2a\x7d\xc1\xf7\x36\x61\x5f\xb6\x59\xdc\x65\x95\xdc\x81\xe2\x99\x55\xc2\x0d\xfb\x51\x55\xf3\xa6\x2a\x3a\xc3\xee\xb6\xac\xa2\x33\xec\x65\xd8\xc5\xa9\x95\x0c\xf8\x66\xa0\xc2\x39\x7c\xd8\x88\x61\x91\x3f\xd7\x57\xfd\x33\xe5\xa2\x3f\xc3\x87\x5d\xfc\xe7\xfa\xeb\x47\xfc\x07\xee\x3f\xf3\xff\xa1\x5b\xb2\x1b\x49\x6a\xa7\xf8\xb6\xd9\xba\x18\xe2\x72\xac\x62\x50\x19\x66\xba\xa2\x18\xd4\x96\xa3\x3e\x95\x15\xdc\xa7\x7c\x6a\x99\xb9\xe7\xcc\x34\x55\x3d\xf8\x13\xb5\x30\xcb\xbc\xcb\xcc\x8d\xd4\x55\x93\x40\xb2\x69\x38\x1d\xe2\x50\x6e\xbb\xe1\x70\xbb\x6c\x8c\xbf\x38\xc4\x61\x50\x60\x39\x8d\xe2\x24\xc7\x2a\xb1\x11\xc3\x87\xc5\xfd\xa1\x18\x32\xeb\x7f\x91\xa6\x12\x82\x6d\xf9\x19\x67\xde\xa5\x42\x41\xa5\x42\xe1\x3a\xcb\x60\xe2\xf5\xb5\x97\x4a\x9a\x78\xe5\xcd\xc0\x8d\x36\x25\x35\x6c\xa9\x76\x67\x1d\x6f\xb2\x2d\xc5\xe1\xaa\x5d\x2b\xc9\x96\xe8\xae\x56\x3d\x36\xde\x96\x10\x95\x92\xea\xb0\x27\x26\xb8\xa3\xa2\x12\x52\xed\xb6\x9a\xd1\xd1\xb5\xbd\x35\x6d\xe9\x3e\x9b\xd3\x55\xcd\x16\x1d\x13\xfd\x4a\xb1\xaa\x5e\xbb\x8e\x2d\x46\x62\x6b\x79\x6d\x9e\x38\xcf\x2b\xc5\xf1\x49\xc9\x35\x6c\x71\xb1\x31\x2b\x62\x8c\x4f\x63\x42\x31\x46\x6c\x5c\xef\xb8\x15\x71\xe6\xa7\x71\x2a\x26\x2e\x26\xce\x9e\x98\x92\x6a\x26\xac\x74\xb8\xa3\x4c\xbb\x64\xa7\xe4\x74\x4a\xc9\x89\x6f\xdb\x36\x3b\x7b\xd8\xf5\xc3\xae\x8f\x4b\xd1\xb1\xa4\xe4\x5c\x68\xe3\x55\x4a\xdb\xb8\xf8\x14\x6b\xee\x58\xff\x8b\x8f\xbc\x47\x88\x48\xcd\x9c\xa4\x0c\x33\x23\x21\x1d\xca\xf0\xe7\x58\x94\x63\xa6\x43\x39\x49\xe9\xb4\xe6\x82\xbc\x3d\xbf\xf4\x5d\x5c\x18\xdc\x5a\xf8\x78\xef\x27\xd6\xe7\x7f\xfa\x43\xff\xc7\xfb\xaa\x9c\xfe\x8b\xfb\x3f\x7b\x7e\x52\x81\xf2\xe7\x9b\xc3\x83\xab\x1e\x0e\xde\xad\xee\xd0\xf4\xb0\xea\xf5\x90\x9a\x11\x9c\xa6\xe9\xa1\xe0\x2a\xeb\xef\x7c\x9b\x92\x16\x1a\x67\x1b\x68\x3f\x29\x0d\x24\x5b\x5a\xc9\x82\x40\xdf\xb4\x0c\xbf\xcd\x56\x23\x3b\xc6\xde\x4c\xa2\xdc\x8d\x92\x7c\x5e\x6f\x92\xdd\x2d\xf6\x36\xad\xfd\x31\x8e\x98\xa9\xc5\x12\xe5\x89\x6a\x16\x15\x88\x9a\x1e\xb5\x28\xca\xe1\x36\xa3\xa2\x4c\x47\xf5\x96\xf5\xb2\x33\x1a\xa6\x36\xbc\xa1\xb8\xb6\x4f\x55\xf3\x29\x9f\x2f\xad\x65\xb6\x23\x36\x55\xa5\x06\xaa\x79\x0a\x52\x1d\x92\x9d\xdd\x68\x18\x38\xe4\xe4\x64\x0f\x1b\x66\xe5\xd3\xfa\x5f\x4e\x6a\x36\x39\x8d\xe4\xb7\x0a\x0c\x39\x39\x39\xd6\x0f\xe2\x4f\x74\x38\x93\x32\xfc\x4d\x55\xfd\xcc\x3a\x2a\x25\xae\xa9\xca\x68\x6a\xf8\x5b\xb6\x6a\xed\xcf\x49\xaa\x63\xa4\xd8\xe9\x8f\x4b\x69\x61\x4b\x56\x8e\xa4\x44\xc6\x55\x4b\xdd\xd1\xca\x36\xf0\xe7\x1f\x26\xee\x39\x99\xa5\x24\xe1\xfa\xf1\x66\xaa\xed\x99\xe7\x06\x1f\xf9\x62\xe2\xdd\x2b\xae\x49\x0f\xfe\x16\x3b\xa8\xb0\x5a\x6d\x55\xff\x81\xf3\xaf\xae\xf3\x5e\x5e\xa2\x7a\xd4\xcb\x9b\xfa\xa5\x5a\xfc\xfa\x16\xf7\x8a\xe5\xae\x37\xdf\xc9\xbe\x7e\x7c\x94\x9a\x65\xd8\x33\x47\x3f\x31\xf9\xf9\x37\x5c\xf7\xde\x6b\xef\xbe\xe0\xee\xfa\x83\x46\x54\x0b\x2e\x35\x4a\xde\x34\x66\x54\x7f\xa0\x71\xbb\x2c\x5f\xb0\x5d\x8b\x4e\x0d\xd2\x83\xf7\xc7\xea\x5a\xb3\x4b\x4e\xe8\xa4\xa3\xc2\x7e\xbf\x54\x93\x58\xea\xad\xbe\xe4\x18\xee\x40\xa8\x96\xd4\x75\x54\x8f\x8d\x8e\x69\x90\xd0\xb4\x46\x8d\x84\x98\x58\x4a\xdb\xdf\x32\xb9\xf9\x1b\xc5\x9e\xe4\xd5\x43\x3c\x8d\x68\x9d\xd5\x1d\x6e\xef\x1b\xc5\xa6\x7b\xf5\x10\x33\x93\xb6\x46\x4c\xea\x43\x7e\x75\xb7\x5f\x4d\xf5\xab\x51\x7e\xd5\xdf\xaf\xf2\xfc\xaa\x95\x5f\x65\xf9\x55\x8a\x5f\x9d\xf2\xab\x43\x7e\x25\xdb\xfc\x6a\xa3\x5f\xad\xf2\xab\x67\xfd\xea\x01\xbf\x9a\xe9\x57\x37\xfa\x55\x89\x5f\xf5\xf5\xab\x80\x5f\x35\xf3\xab\xba\x7e\x95\xe8\x57\x36\xbf\x1a\xfb\x8b\x5f\x1d\xf5\xab\xcf\xfc\x6a\x83\x5f\xbd\xea\x57\x4b\x2b\x05\xa6\x58\xea\x07\xfa\x55\x0b\x8b\x3b\xde\xe2\xfe\xc9\xaf\xca\xfd\x6a\x97\x5f\xbd\xe7\x57\x6f\x54\x51\x3d\xc6\xaf\x0a\xfd\xaa\x8b\x5f\xb5\xb4\x1c\x31\x2c\xce\xc3\x96\xda\xf7\x2a\xfd\x78\xc4\xaf\xee\xf5\xab\xab\x2c\x97\xf3\x23\x2e\x07\x6e\xd2\x6e\x38\xfc\xaa\xf5\x8e\x2a\x1e\xc3\x79\x8b\xa5\xb3\xbb\xa5\xb0\x5e\xa5\xaf\xb8\xfa\xb9\x5f\xad\xf5\xab\x67\xfc\xea\xa1\x2a\xa6\xdb\xfa\x95\xcf\xf2\x50\x89\x5f\x9d\xf4\xab\x83\x96\x8b\x6f\xfa\xd5\x4b\x7e\xb5\xc4\xaf\x26\x5b\xa1\xe3\x5f\xae\x5f\xa5\xf9\x55\xac\x5f\x39\x8d\x11\x17\x2d\x51\x17\x2d\x67\xff\x79\xe1\xfb\x0f\xcb\xde\x25\xcc\x23\xaa\x2e\x7b\x9d\x3a\xe9\x7f\x60\x25\xd5\x6a\x2e\x29\xe2\xb8\x70\xfd\x66\xd4\xcd\xa2\x62\x73\x5a\x24\xab\x0c\x95\x93\xd9\x22\x39\xa9\xb2\x4b\xb5\xcc\xca\xa8\x4b\xe1\x26\xe7\xb4\xb8\xe8\xd9\x51\xb1\xea\x95\xb2\x57\x97\xaf\x5b\xb5\xec\x6c\xe7\x4f\xcc\xc7\xb6\x9f\xdd\xfd\xda\xcb\xaf\x97\xbd\xf2\xea\x72\x7b\xf3\x0e\x3d\x0a\x3b\x04\x7a\x76\x0f\x9c\x8b\xe5\xa9\x63\xe7\x9e\x3d\x3a\xa9\xb2\x7d\x47\x0f\xef\x3f\xf8\xf5\xa1\xf3\x53\xec\x33\x3c\xe5\x5f\xed\xab\x38\xb2\xff\xd0\x97\xe7\xbc\x4b\x66\xcf\x7d\x72\xe9\xdd\xb3\x8d\xf5\x4f\xce\x9e\xf5\xd4\x53\xb3\xf4\xf7\xd3\xc1\xa1\xe3\xf6\x59\xf6\x39\x52\x4f\x9a\x49\x3b\x19\x1d\xe8\x90\x90\x98\x59\xad\x91\xdd\x4f\x0d\x57\x4b\x4c\x6b\x62\xc6\xe6\xc4\x25\xfb\x9a\xc7\xb4\xbf\x3c\x27\xd6\x6c\x62\x73\xa5\xb6\xa9\xdb\xa6\x77\xb1\xaf\x79\x72\x9c\xad\x6e\x6c\x82\x37\xc1\xa8\x6e\x26\x24\xb8\x6a\xd7\x4d\x76\x35\xe8\x5b\xcc\x02\xdd\x49\x87\xcd\xe2\xa6\xa7\x30\x6b\x95\x9e\xc5\xd6\xb2\x55\x05\x03\xce\x03\xcc\xd5\x48\xf8\x49\x89\xd5\x95\x33\x39\xa5\x55\xeb\x14\x87\x93\x30\x5b\x27\x69\x18\xea\xeb\x1f\x95\xc1\xa7\x74\x34\x4c\x7a\xc2\x28\x0c\x7e\xa6\xac\xc7\xa6\xd7\x5f\x78\xf7\xca\x85\x2f\x5d\x7d\xff\xb8\x56\xdb\x73\xef\x18\x38\xb4\x73\xcb\xd6\xbd\x06\xbe\xdc\x6d\xd9\xf6\x8a\xa0\x19\xdd\xab\xf3\x15\x7d\x5a\x8d\x1f\xd2\xbc\xef\xf3\x13\x96\xdf\x35\xb9\xf3\x78\x35\x63\xd6\xce\xbe\x8f\xcc\x58\xfc\xe2\xd2\x39\x57\xdc\x3e\xa1\x70\xc5\xd3\x4f\x6d\xcd\xff\xf6\xcd\xee\x9e\x8f\x92\x3b\x5e\x3e\x63\xb7\xf9\x64\xdb\x82\x81\xdd\x06\x4d\x68\xd2\x31\xff\xdc\xa6\xb5\x1b\xfa\x3c\x7e\xf5\xcd\xcd\x44\xc9\x44\xb6\x8d\x3b\xac\x3d\x88\x95\xca\x34\x0c\x9b\x5d\xef\x3b\x7a\xdb\x69\x14\xde\xc8\x22\x9b\xcd\x55\x5f\xd4\x54\x1e\xbd\xc5\x20\x33\x26\x38\xc8\x78\xc1\xfe\xb1\xc4\x48\xdd\x80\x47\xff\x17\x11\xa2\xcc\x18\xa7\x69\xc6\xea\xff\x06\x5e\x1a\x05\x11\x81\xa0\x79\x33\x0d\x81\xca\x32\xe2\x3c\xf1\xad\xd3\x1d\xba\x49\x51\x0b\x9f\x9c\x3f\xff\x49\x55\xe3\xa9\x85\xf7\x2d\x09\x0e\x2a\x57\x1b\x55\x2a\xab\xd6\x3b\x5f\x1f\x0e\xb6\x0f\xfe\x10\x3c\x11\xec\xf4\xad\xfe\xb7\x53\xa0\x3f\xb7\x52\x7f\x8c\x38\x1d\x66\x94\x38\xa2\xfe\xa4\x3f\x02\x70\xab\xf8\x38\x8f\x51\x3f\x3d\x59\x37\x4e\x63\xe9\x82\x45\x5a\xfd\xbc\x79\x4f\x05\x07\x7d\xa7\xde\x56\xf1\x2a\x41\x6d\x2e\x3f\x14\xec\x18\x3c\x1e\xfc\x2e\xd8\xf1\xb0\xfe\x77\x5a\x38\x8c\x59\x66\x1a\x31\x57\x97\x41\x81\xa6\x5c\x98\x1c\x6e\x7b\x94\x9d\xfd\xce\xe6\x8a\xaa\x1e\x13\x63\x44\x45\x19\xb1\x1e\x9b\xcb\x74\x1b\x51\xaa\x5a\xb5\x28\xb7\xc3\x65\x8f\x71\x8a\x5d\xd9\xed\x31\x7a\x37\xce\x1e\x96\x73\xd1\x8e\xa5\x8f\x7e\xf1\xfa\x3d\x7c\x04\x8c\xb3\x76\xad\xd6\x29\xce\x14\x67\x7d\x67\xfd\xd6\xf5\x5b\xa7\x98\x39\xea\xf8\xb1\xdc\x33\xeb\xd6\x3c\xf0\xf0\xba\xb7\xce\xe4\x9e\x88\xdf\x63\x9b\x34\x6e\x73\x87\xdd\xb7\x9c\x3b\x77\xdb\xce\x0e\x9b\xc7\xa9\x78\x7c\x1a\x28\x4f\xdb\x8a\x6d\x2b\x59\x43\x33\x03\x71\x6e\x11\x87\x69\xc6\x44\x73\x8e\xb7\xbd\x5c\xec\xb6\xbf\x5a\xe5\x10\x50\x79\xb4\x88\xcb\x88\x4b\xf7\xa7\x63\x2f\x3d\xc9\xd8\x52\x1e\xbc\x5e\x2d\x2c\x57\x0f\x18\x6d\x83\xe3\xd4\x63\x07\xd5\x63\xc1\x71\x07\xf5\xda\xac\x64\x5e\xf0\x5d\x55\xa6\x9a\x4b\x14\x58\xc6\x99\xb6\x28\x82\x8c\xae\xe6\x72\x3f\x31\xc4\x65\x7b\x61\x88\x8b\x43\x4b\xa3\x2a\x87\xd7\x4c\x36\x9b\x8c\x8e\xca\x8f\x6a\x55\x96\xd3\x76\xed\xe5\x3d\x66\xa8\xf4\x2e\x37\xaf\xe9\xdd\x6d\x59\x2f\xfd\x57\x2e\xd1\x57\xa8\x1e\x37\x8a\x8c\x05\xd4\x4b\x72\x20\x4a\x38\xb2\x2a\x59\x57\xac\xd6\x47\xca\x85\xd0\x13\xfc\xe9\x49\x85\x86\x4b\x3d\x7e\xea\x94\x65\x9f\x1f\xcb\x91\x35\x25\x25\x10\x65\xea\xff\x06\x9e\xa8\x27\x86\x08\x86\x2b\xcb\x8b\x08\xe2\xe6\xa9\x74\xd5\x3c\xf8\x29\xfc\x89\xa1\x3d\x46\x26\xb9\x37\x25\xfe\x0d\xc3\xae\xff\xab\x00\xf0\x76\x8a\x53\x96\x7f\x29\x2a\x47\x25\xaa\x8c\x1f\x82\xe5\x0d\xed\xa7\xcf\x54\xd3\xe7\x9c\x3e\xa1\xe3\x36\xaf\xfd\x11\x70\x4b\x93\x06\x81\xc4\x44\x7b\x34\x1b\x52\xed\x5a\x6e\x4f\x69\xb1\xdb\x69\xa6\x96\xb2\xad\x84\x27\x6a\xd5\x38\x95\xc7\xc8\xf0\xc5\xb5\x8c\x67\x56\xc6\xeb\x2d\x33\xa3\x6e\x75\xa5\xf7\xcf\x9c\x16\x1d\x95\xcd\x7b\xfa\x74\xb0\xd6\x84\x5d\xaf\x9c\xf9\x26\x78\x34\xab\x7f\xe1\x80\x41\x99\xf5\x07\xf4\x29\x1c\x54\xdf\x78\x27\xf8\x44\x70\x91\xb1\xfb\xbc\x0a\x3c\x16\x7c\x24\xf8\xf0\xbb\x7b\x87\x8f\xd8\xf3\xee\x3b\x9f\x0f\xbf\x7a\x1f\x7e\xcf\x88\xfc\xb7\x20\xa3\xa4\x51\x20\xd1\xe6\x32\x8c\x6a\xd1\x76\x5b\xc0\x74\x38\x5c\x4a\x14\x47\x86\x54\x8d\x90\xe4\xb0\x60\xd4\xdc\xda\x22\x92\x47\x62\x27\x83\x76\x7f\x26\x77\x86\xa4\x19\x6a\x58\xf0\x15\x35\x52\x45\xa9\xae\xdb\xcd\x77\x76\x7e\x79\xe4\x6c\xe1\x76\xf4\x76\x43\x6f\x3a\xf1\xd5\x92\x0e\x01\x6f\x4d\x89\x8e\x71\x26\xd4\x4a\x88\xe1\xa2\x52\xdb\x29\x9e\xe8\x68\x8f\xc7\x5d\xca\x4e\x2a\x35\x4b\xc3\x26\xac\x40\x31\x93\xad\x4b\xb2\xea\x34\xc9\xf1\x77\x54\xad\x49\x6d\x4b\x16\x1a\x67\x66\x47\x15\x5e\x8f\x6c\xce\xf4\xa4\x6e\xad\x3f\xfa\xc7\x43\x37\xad\x1d\x3c\xa2\x7a\xf0\x48\xea\xe9\x9d\x87\x4f\x5d\x79\xeb\xc3\xf3\x4b\x6b\x19\xf7\xbd\x7b\xcb\xd1\x3b\x6e\x5e\xdc\x73\xcd\xc8\x91\x9e\x4d\x9f\x6c\x5b\x7f\xf5\xd2\x59\x37\x4e\x9e\xd2\xb9\x22\x5c\x57\xd9\xa1\x6f\x6d\x0d\xf1\xab\x81\x3c\x1c\x28\x71\x3a\xd2\x6a\x25\xd5\x8d\x16\xa9\x9b\xe9\xa9\xe5\x70\x34\xbc\x2c\x33\x8e\x93\x62\x69\xf1\xba\x38\xf5\x78\x9c\x9a\x1d\xa7\xf2\xe3\x54\xfb\x38\x55\x33\x4e\xb9\xe3\x54\x74\x5c\x9c\xe9\x8d\x4d\x1b\x91\x66\xc4\x98\x69\x69\x5e\x2f\x39\xf2\x3a\x4d\xc2\xf0\x39\x4b\x9c\x93\x9d\x65\xce\x0d\x4e\x7b\x33\x67\xc0\x39\xdd\xb9\xc8\xb9\xcd\x69\x77\x3a\x75\x06\x99\x75\xd7\xff\x11\x9c\x3e\x07\xb3\xee\x56\x6e\x4b\xa4\x56\x2e\x5d\x77\x55\xa2\x2d\xa3\x6e\xbd\xfa\x99\x7a\x25\xf5\xb7\xcc\x6a\xa4\xfc\xe1\x07\x2b\xfc\x56\xf5\xac\xf0\x39\x59\xd5\x51\xb6\x86\xc1\x73\x27\x0f\x05\x4f\xa5\xa8\x3a\x69\x1f\x8f\x9e\x3c\xfb\xde\xab\x86\xde\x72\xeb\xc8\x61\x83\xae\x71\x05\x2b\x92\x95\xb1\xed\xcb\xdf\x9f\x78\xe0\x99\x15\x6a\xd6\x7b\x7b\xb7\x6f\xae\xf1\xd1\xa8\xb1\xc3\x47\x1d\xba\x7a\xe8\xa0\xab\x4b\x8a\x12\xdf\xf8\x64\x4b\xd9\xcc\x65\xb5\x6c\x09\x2b\xa8\x43\x2f\x79\x1a\x67\xe5\x3f\x5e\xda\x05\x6a\xc5\xd9\x1d\xf1\x06\xb3\xc0\xae\x12\xb8\x91\xc7\xd9\xa6\x16\xbb\xec\x71\x71\xaa\xba\xc3\xa1\x48\x93\xb5\x6b\xe4\xfc\x71\xae\xb7\xe6\x74\x64\x5a\x53\x0b\x7e\xc5\xbc\x4e\x52\xec\x1c\x0e\xa7\x4a\x37\x97\x07\x4f\x9d\x9f\x66\xf4\x53\xed\xd6\x07\xdb\x38\x8d\x9a\xb9\xc1\xb5\x6a\xb1\xf2\x06\xbf\x56\xde\x9d\xe6\xc2\x73\x93\xb6\x1b\x4f\xb5\xba\x33\xbe\xcd\x04\xfd\xaf\x07\x54\xd2\x89\xf9\xa0\xeb\xb0\x96\x94\x06\xba\xc6\x27\xa4\xa6\x24\x26\x4a\x82\xd3\x91\x9a\x40\x76\x92\x13\x1c\xb6\xda\x75\x12\x6a\xd6\x24\x35\xb1\x35\xbd\x35\x47\xd4\xe4\x06\x51\xb3\xa6\x99\x98\x98\x32\xb5\x38\x91\x55\xb6\xb4\xb8\x93\x73\xa1\xf3\x80\xd3\x3c\xe1\x54\x01\xa7\xba\x00\x7d\x25\xf6\xc0\xfc\x97\x07\x56\x6b\xf9\x8b\xd7\xeb\x5e\xa2\xe8\x3d\x2d\x53\x4f\xa5\x30\xda\xce\xf4\x84\x74\x0e\xea\x7a\xff\xb3\xb5\x0b\x7e\xfb\xf3\xae\x50\x1d\x55\x23\x79\xf2\x80\xf1\x77\xdc\x38\xe1\x86\x1e\xc1\x1f\x9a\x9b\xbd\xcf\x97\xa5\x8c\x79\xfc\x83\x1f\xd5\xee\x83\xc1\x5f\xdf\x7e\x3d\x65\x70\xdf\x7b\xef\x9c\x74\xcf\x10\xb3\xc6\xf6\xe0\xe2\xc1\x67\xf4\x1c\xef\x49\x4c\xba\xd6\x52\xb8\xd5\x5c\x11\x68\x58\x27\xde\x11\x13\x9d\x2a\x12\xed\x30\x33\xeb\x25\xa5\x4d\xe5\x42\x92\xe4\x36\xdd\xb1\x4c\x81\x18\x55\xdd\x8c\x89\x61\xe2\xa7\xff\x31\xf1\x73\xc2\x1e\x5b\xbe\xe7\x54\x3d\xa2\x58\x55\x62\x64\xd4\x95\x38\x8f\xe0\x5e\x8a\xdd\xda\x84\xad\xa9\x61\xaf\x72\x1a\xb1\x35\x3c\xf7\xd5\xef\xc1\xd3\x2a\xf6\xdc\x6b\x9f\x36\x0a\xfe\x9a\x35\xf3\xfa\x19\x4d\x96\x8e\xfe\xf7\xfe\xe0\xd1\x49\x23\x87\x4d\xbe\x61\xc4\x88\x09\x6a\xeb\xd7\x6c\x8b\xc3\xd4\x20\x75\x8b\xba\xe3\xa9\xe7\x33\xe7\x95\x1f\xed\x59\x78\xf2\xb3\x9b\xa7\xdd\x74\xd5\x6d\x4f\xcf\x0a\xcf\x97\x22\xea\xa3\x06\x79\x89\x91\xcb\x02\x89\x51\x76\x87\x43\xaa\x71\x5c\xae\x2e\xd5\xa2\xab\x95\x16\x47\x3b\xec\xba\x2a\xfe\xa8\x07\x0d\x68\x0b\xdc\x73\x44\x19\x49\xe9\x2d\x6b\xaa\x04\x96\x7a\x5b\x8d\x11\x2f\xde\xd9\x3d\xf8\xc5\xd0\x57\x8e\x9c\xcf\x35\xdf\xb1\x3d\xf3\x48\xf0\x68\xf0\x50\x70\xe7\x0b\x65\xaa\xbb\x1a\xa0\x7a\x55\x58\x77\x99\xce\x60\xd5\x12\xac\x6a\x80\x55\x53\x8d\x56\x43\x87\x37\xa6\x66\x42\x3d\x91\x84\x64\x77\x8c\xc3\xd1\x2c\x3b\xd9\x9d\x9e\x95\x9e\x75\x43\x71\x7a\xba\xe9\xf1\xd4\xbe\x81\xd5\xc3\x6c\x7c\x43\xd5\x65\x52\x03\x65\x35\x7f\x3d\xa7\xac\xdb\x47\x53\x55\x79\xa6\xb1\x26\x91\x75\x80\x49\x4a\x04\xad\x84\x96\x7f\x00\xd7\x32\x78\xe6\xe7\x1f\x83\xbf\x2e\xbe\x7b\xca\xfc\xd3\x07\x8f\x9c\x9e\x77\xc3\xec\x27\x82\xeb\x87\x0e\x7b\x63\xcd\xd0\x21\xe9\xfb\xc7\x4c\xbc\x76\xd2\xc4\xb1\x6a\xc1\x7b\x5f\xec\xdb\x3c\x6b\x6d\xb2\xad\x46\x59\xe9\xcb\xef\xbf\xbb\xaa\xf4\x95\x14\x5b\xf2\x6b\xea\x97\x51\xc3\xde\xf9\x70\x78\x50\xbe\x9c\x3a\xf1\xf6\x29\x53\xa8\x81\x6e\xc4\x55\x3f\x52\x03\xfd\x02\x4d\xeb\xc4\x53\xd3\x94\xb4\x23\x9e\x1a\x88\x4d\x9f\x5a\x1c\x1d\x1b\xeb\x8d\x35\xdc\x66\x6c\x6c\x92\x99\x94\x56\x5a\x9c\x64\x2d\x29\xf2\x47\x11\x5f\x52\xc2\x17\x2a\xa1\x32\x36\x4f\xb8\x72\xb5\xe3\xad\xab\x2b\xeb\x80\xca\x2a\x11\x7f\x51\x25\xd4\x0f\xfe\x70\x6e\xdd\xce\xc6\xca\x55\x7f\xc1\x8d\xd3\x8c\xac\x97\x47\xad\xfb\x42\xa9\x63\xe7\x7f\x0d\xee\x29\x1d\x31\xec\x9a\x09\x23\x06\xdf\x64\xec\x09\xce\x09\xce\x5f\xb2\x3c\xf3\xc1\xf2\xaf\x7a\x0e\x38\xbf\xf7\xab\x33\xc1\xa7\x9f\xb8\xfb\x89\x59\x37\xdd\xb0\xe0\x36\xeb\x5e\xbe\x99\x62\x38\x62\x8b\xb2\xbe\xff\x74\x09\x54\x98\x4e\xfd\x65\xce\xcd\x26\xb1\x78\x48\xac\xca\x56\xbd\xd5\x24\xb5\x50\xd9\xa3\x4d\x15\x48\xae\x5b\xa0\x6c\xf6\xc5\x43\x6c\x0b\x2b\x3f\xa9\x78\xdd\x2a\xd6\xad\x42\x6e\x75\xa2\xf2\x43\x0a\x43\x23\xdc\xaa\xb7\xf5\xa9\x45\xdc\x6a\xdc\xa7\x6e\xf5\xb6\x5b\xad\x70\xab\x45\x6e\x35\xdd\xfa\x70\xd2\xa9\x52\xe6\xa0\x5b\x4d\x73\xab\x49\x96\x40\x33\xeb\x5b\x0b\x5a\x0e\x58\xfc\x4b\x2d\xfe\x6c\xcb\x00\x5a\xda\x9c\xb4\xb8\xd1\xb2\xc4\xb2\x30\xad\x8a\xfd\xb0\xcc\x06\x4b\x20\x6c\xb9\x93\xa5\x2b\xfc\x45\x28\x6c\x7e\x49\xa5\xed\xf0\x57\xa0\x58\xeb\x63\xcc\x9f\xae\x19\x7f\xbe\x5c\x5c\x32\x30\xfc\xe2\xbb\x89\xf5\x7d\x25\xbb\x51\x78\x2e\xff\xf1\xb9\x4d\x7f\x5d\x81\x36\x2b\x5f\xf0\xa0\xf2\x19\x27\x55\xcd\xe0\xd1\xf3\x1e\x55\x23\x58\x11\xfe\x0e\xf2\x2e\xe7\x9f\x0a\x0b\xef\xea\xaa\x7b\xe0\x7b\xb3\x7a\xf5\x68\x89\x76\x99\x9e\xd8\xbf\x41\x3c\x3a\x66\xf1\x90\x68\xd7\x0b\x43\xa2\x17\x7a\x54\x89\x47\x15\x7a\x94\xd7\xa3\x62\x3d\x2a\xe4\x51\x27\x3c\x6a\x9b\x47\x6d\xf0\x28\x86\x46\x78\x54\x6f\x8f\x6a\xe6\xd1\xff\x8a\x8a\x71\x9f\x7a\xd4\xdb\x1e\xb5\xc2\xa3\x16\x79\xd4\x74\x8f\x9a\xec\x51\x9d\x2a\x65\x0e\x7a\xd4\x34\x8f\x9a\x64\x09\xc0\xed\xb3\xb4\x1c\xb0\xf8\x97\x5a\xfc\xd9\x96\x01\xb4\xb4\x39\x69\x71\xa3\x65\x89\x65\x61\x5a\x15\xfb\x61\x99\x0d\x96\x40\xd8\x72\x27\x4b\x97\xc7\x92\x0c\x9b\x5f\x52\x69\x1b\x91\x80\x65\xfe\xff\x23\xd4\xab\xc2\x9e\xf2\x07\xec\x35\xd4\x1f\x87\xc5\x2d\xca\x97\xd3\x76\x4d\x20\x6f\xc6\x85\x0c\xf4\xe5\xd0\xd8\xe7\xb9\x6e\xfa\x1f\xd7\xd6\x67\xdb\x3b\x38\xdb\x6e\x15\x87\xb4\x0c\xd4\x32\x1d\xfa\x53\x34\x05\x6f\xb3\x19\xf6\x4e\x0e\xe5\x30\x47\x18\x88\xa9\x58\x43\x19\xc2\x56\x33\xcc\x3a\x60\xb7\xed\xc0\xfe\x68\x19\xd4\xc6\x54\x92\x5b\x25\x0d\xb4\x99\xe7\xde\x36\x3b\x1b\x36\xd5\x45\xcd\x3a\x1c\x7c\x33\xb8\xfe\x10\xf9\x1d\xa0\x32\x6c\x45\xb6\x86\xd6\x37\xb4\xa1\x81\x8e\x4e\x53\xff\xfb\x2f\xdd\x9c\xd6\xab\x39\x6c\xf6\x97\x8b\x0f\xd8\x54\xac\xcd\x6b\x5b\x68\x33\xdd\xa6\x2d\x90\x58\xa3\xc0\x16\x2b\x0c\x29\x79\xb9\xb8\x99\x9a\xac\x0c\x9f\x0a\xa8\x12\x1e\x96\xaa\x0d\x8a\x5e\xeb\x94\x41\xac\xe1\x88\xc3\xcf\x95\x5e\x70\xae\x55\xd0\x00\x9b\x79\xf6\xbc\xcd\x34\x7b\x1c\x38\x70\xfe\xf3\x2f\xbf\xbc\x38\xbe\x16\x81\x34\x87\xc1\xa9\xd8\xe9\x72\xd8\x0d\xc3\x1c\x61\x53\x3e\xed\x80\xb2\xe9\x7f\x97\x0b\x07\xd9\x61\x2d\xac\x08\xab\x46\xd7\xda\xef\x56\x7e\x15\x37\xd0\x0c\x9c\xdb\x60\x33\xef\x38\xa4\x72\x55\xde\xe1\xe0\x2d\xc1\xb7\xc2\xf5\x3b\x9c\x7d\x63\x22\xeb\x5e\x4d\xa9\x23\x3d\x02\xbe\x3a\x69\x89\x49\x4e\x57\x75\x11\x57\x5a\x92\xcd\xe7\xad\x9e\xea\x72\xd5\x4a\x4d\xab\xf5\xe4\x90\xb4\xa4\xc4\xc4\xd4\xd4\xb8\x35\x2a\xe9\xd5\xe2\x54\x5b\xe4\xb0\x99\x5d\xb9\xe0\xc5\xff\x79\x29\x77\xc4\x2a\xae\xa3\xe9\x91\x53\xe1\x1f\xe7\x22\x9b\x9e\x4e\xb6\x89\x83\x6e\xea\x95\xdb\xd5\x0c\x9e\x76\x8c\x1d\x75\x4d\x51\xe9\x84\xd1\x73\xa2\x83\x87\xd2\x54\xea\xc1\xef\x55\xec\xf9\xee\x2a\xdd\x66\x8c\xfc\xc7\x80\xd6\xcd\x47\xb5\x1f\xb3\x34\xbf\xc7\xf5\x79\x45\x63\x6e\x1c\x19\xfd\x51\xf9\x9e\xb3\x9d\xad\x4f\x9b\xf8\x7d\x43\x70\xbd\x73\xa0\xfd\x15\x09\x48\x6f\x99\x15\xe8\x55\xcb\xd5\xa8\x6d\x81\xc7\xd5\xb9\x73\x8d\x1a\xa9\x19\x22\x2d\x6a\x78\xda\xda\xfb\x14\x36\x6f\xee\x8f\xf1\xf6\x8c\xe9\xb9\xbb\xd8\x16\x93\x98\xbb\xbb\x38\x35\x31\x25\xd1\x93\xb8\x21\x71\x5b\xe2\xc1\x44\x5b\x6c\x8c\x37\xc6\xa8\x66\xc6\x24\xc6\x24\xfa\x3b\x74\xa8\xbf\xbb\xb8\xc3\x3e\x7f\xf6\xee\x62\xff\x17\x55\x36\x2a\x42\xd3\x8b\xf9\xb0\xb8\x1c\xcf\x26\x1d\x71\x78\x07\x6d\xab\x8f\xbf\x97\x7c\x89\x08\x07\x6d\x84\xbf\x3c\xb4\xce\x88\xac\xf0\xfa\x06\x90\x92\xd3\x3a\xc7\x0c\xaf\xf0\x1a\x09\xa3\x5e\x46\x5d\x9b\x91\x94\x18\x6f\xcb\xf1\x65\xfe\x3f\xac\xbd\x79\x60\x14\x45\xf6\x38\x5e\xaf\xfa\x98\xab\x67\x7a\xce\xee\x39\x92\xcc\x4c\x4e\x20\x60\x42\x0e\xc2\x69\x46\x44\x41\x50\x13\x10\x81\x31\x86\x44\x41\x05\x3c\x08\xb7\x20\x1a\x50\x0e\x01\x15\x14\x5d\x0f\xe4\x58\x65\x5d\x45\x84\x88\xd1\x8d\x27\x78\x1f\x78\xe0\x0a\xab\x88\x0a\x2a\x5e\x0b\x0a\xbb\xab\xae\x42\xd2\xf3\xab\xaa\xee\x9e\x4c\x02\xee\xf7\xf3\xc7\x4f\x0c\x19\xa6\x5f\x55\xbd\xae\x7a\xf5\xae\x7a\xef\x95\x2a\x52\x89\x87\x2b\xdd\xde\xfc\x78\x19\xaf\x0b\x03\x6a\x2a\x50\x58\x6c\x19\xd7\x7c\xe8\xe6\x4b\x27\x89\x62\xd9\xeb\x57\xad\x7f\x62\xf1\x37\x77\xbc\x7a\x8e\x58\xf4\xe0\x9c\x82\x92\x68\xed\x5d\x17\xdf\xaf\x1d\xda\x79\x5c\xbb\xeb\xc3\x8d\x10\x7b\x05\x0a\xa1\xe8\xcc\x47\xb5\x9d\x8f\x1d\xd5\xee\x7f\xbb\x03\x5e\x02\xff\x7f\x60\xf2\xf3\x1d\xf3\xe7\x4d\x9c\x78\xcf\x45\x97\x4d\x1e\x7a\xe3\xe5\x95\x78\xdf\x33\xda\xde\xc7\xea\x46\x17\xe4\x4c\x5d\xb6\xfb\x99\x87\x21\xe7\xe1\x6d\xf7\x69\xe2\xd6\x61\x65\xbd\x56\xfd\x70\xdb\x76\x70\xde\xf5\x77\x6d\xf6\xaf\xaf\x6a\xfb\xef\x5d\xb7\xa0\x61\xcc\x4e\x98\xfa\x03\x44\xe0\x9d\xf6\xa7\xb5\x67\xbe\x68\xb8\xfe\xc6\x6f\xe6\xcf\x5c\x32\x76\xe3\x6e\x46\x2f\xe5\x08\x09\x77\x12\x3d\xc3\x82\x64\x6c\x49\xa4\x9c\x80\x24\x6c\x25\x9b\x83\xe3\x45\x81\xd8\x7e\x16\xce\xed\xb1\x48\xb8\x21\xe9\xb4\x0a\x12\x51\x3b\x38\x1e\x79\x97\x79\x60\xb6\x07\x26\x7b\xe0\x22\x0f\x9c\xed\x81\x0a\x0f\x14\x78\x40\xf1\x00\xf6\xc0\x7f\x3c\x70\xd8\x03\x7b\x3d\xf0\xba\x07\x9e\xf1\xc0\xc3\x1e\x58\xeb\x81\x25\x1e\x98\xe3\x81\x2b\x3d\x30\xd6\x03\xe7\x30\xf8\x7c\xb2\x43\x3d\xc0\x7b\x60\xca\x2f\x1e\xf8\xc6\x6c\xf0\x94\x07\xd0\x26\x0f\xdc\xc5\x5a\x90\x11\x2e\xf7\x40\xad\x07\x86\x7a\xa0\x8c\xb5\xd0\x47\x38\xee\x81\xaf\x58\x83\xd7\x3c\xb0\xc3\x03\x9b\x3d\xb0\xc6\x03\x37\x9b\xf0\x63\x3c\x30\xcc\x03\xfd\x18\xbc\x9b\xc1\xff\xcc\x30\xfa\x87\x09\xff\x90\x07\xee\xf6\x00\x79\x83\xb9\xec\x0d\x74\x78\x82\x51\xa1\x07\xfc\x1e\x10\x13\xd3\x3d\xd0\xff\xdf\x66\x93\x57\x3c\xd0\xea\x81\x47\x18\x3e\x3a\xfc\x58\x66\x9a\x10\x60\xaf\x07\x00\xb1\xde\x49\xbf\x2d\x1e\xd8\xc4\xfa\xd5\xa7\xa5\xd6\xec\xd4\xcf\x3a\x7a\x8d\xf5\x72\x37\xeb\xa5\x89\x01\x0c\xd3\x91\x23\xed\xad\x19\xa7\x0e\x99\x2e\xb5\x99\x0d\xff\xc7\x53\x84\x53\xfd\x6f\x0d\xff\xaf\x73\x87\xea\xb2\xea\xf2\x01\x64\x87\x97\x53\x46\x9d\xa9\xd4\x90\x8d\x30\xc0\x43\x4d\xf2\x38\x51\xf3\xe3\x10\x27\x72\xd8\x05\xf4\xcc\x80\xbf\xf6\xc6\x8e\xef\x6e\xd4\xf6\x63\x0c\x97\x62\xd4\x31\x46\xb4\x67\x6d\x80\x7b\x56\x15\xc3\x14\xed\x3e\x7a\x5e\xc5\x3f\xaa\xe4\x5f\xaa\x55\xc0\x3d\xb7\xb2\xd2\x1c\x68\x05\xa1\xa9\x69\xcc\x5f\xa2\x12\x3b\x67\x69\x62\xb4\xe4\xb3\xf9\x22\x11\x5e\xb6\x11\x2d\xdc\xc6\x73\xf1\x98\xe4\x8f\xf8\x23\x0d\x49\xd9\x1f\xf5\x63\xbf\xe0\x57\xa4\xf3\xfc\x7e\x5e\x10\x7c\x0d\x49\x42\x61\x59\x0d\x49\xde\xbb\x29\x0e\x6b\xe2\xb0\x28\x0e\x4d\x71\x68\x8c\x43\x6d\x1c\x12\x71\x28\x65\xff\xc7\xe2\xd0\xf9\x3e\x5d\xb5\x50\x53\x73\xef\xba\x9d\x75\x4b\x83\xef\x49\x38\x55\x8c\xa7\x1a\xa8\xae\x80\x12\xcb\x89\xea\x9f\xf4\xeb\xb2\x7e\xc2\x34\xed\x50\x0a\x75\x54\xe3\xa5\x80\xc1\xb6\xf4\xd6\xc7\x9f\xd2\x96\xcd\x9f\xa7\xb5\xc0\x98\x1b\x67\x8c\xd1\x0e\x6b\x2b\x61\xf1\x1d\xb7\xc0\x5d\xbb\xfe\x2e\x2c\x7e\x6a\xfb\xf5\x7f\xc9\xf6\x6f\x87\x7d\x0d\xb5\xda\xc3\xe3\x35\xdb\x1b\xda\x35\x57\x31\x9d\x7d\x6c\xea\xa8\xb0\x9a\xf0\xde\x20\x1a\x93\x28\x53\x6c\x6e\x19\x13\x2b\x83\xe3\xc2\x21\x89\xbc\x98\xdb\x4d\x73\x6a\xdc\x18\x23\x9c\xc0\x8b\xf0\x2e\xbc\x07\x0b\xd4\x81\x46\x34\xfb\x86\xa4\xe8\x2b\x0d\x43\x3d\xea\x34\x57\x67\x10\x0d\xb4\xb8\x8b\x41\x5e\x10\xf3\x09\x84\xbb\xc4\xa8\xf5\x41\x78\x0b\x75\xe5\x33\x45\xd3\xcb\x45\xc0\x31\x05\xe0\x22\x6d\xe7\x21\x6d\xab\x76\x3b\x5c\x09\x63\x7f\x83\xfe\xd5\x5a\x7b\xfc\xe5\x5b\xde\xfa\x60\xdf\x5e\x90\x2e\x7b\xf7\x4d\x58\x0c\x97\x40\x1d\xcc\x7e\xf3\xe5\xe1\xd3\x6e\xfc\xed\xd8\x7f\x52\x74\xef\xd3\x75\x9a\x41\xd6\xc9\x46\x6c\xd0\x8a\x44\xb6\x2c\xd8\x91\x80\xfc\x3e\xd1\x45\x10\xe2\x04\x99\x2c\x86\x77\x91\x1f\x4a\xfd\x10\xf3\xd3\x19\x3f\x8d\x5f\xc4\x8f\x79\x3a\x8d\x31\x04\xd4\x64\xf6\x50\xfd\x77\xc6\xe3\xda\x9b\xef\x74\xbc\x01\x1a\x4c\x86\x65\xda\xc7\x47\x0f\x7c\x78\xe2\xa5\x43\x78\xf7\xa7\xda\xf3\x5b\x85\xc5\xda\xfd\xda\x93\x5f\x1f\x6b\x1f\xce\x8a\xec\xb0\xf1\x45\x32\xbe\x03\xcd\x4e\x8c\x14\x6c\x36\xf2\x81\xc8\x5a\x3b\x67\x41\xbc\xe4\x14\xac\x84\x3e\x84\x66\x61\xa3\xc0\xc9\x64\x56\x53\xe4\x17\x27\x28\x81\xf3\x64\x01\xfc\x82\x40\x28\x46\x10\x10\x00\xdf\x90\x04\x0e\xd9\x1a\x92\xc8\x9b\x70\x42\xa9\x13\x62\x4e\x82\x6a\xfd\xa9\x54\xc1\xc4\x33\x9b\xd0\xf4\xa1\x18\x75\x85\xc5\x8d\x9f\x15\xfc\xd8\xf6\x8f\xf0\xf1\x0e\x37\x37\x4e\x58\x7c\x58\xdb\x70\x58\xbb\xfd\x30\x32\x70\xe4\xef\x63\x73\x34\x22\xd1\x0b\x04\x41\xb4\x62\x62\xf8\x3a\xe8\xc0\x32\x80\x83\x68\x81\xce\xbe\x23\x00\x04\x8b\x85\x2c\xa3\x85\x13\xbc\xa5\x0e\x88\x39\x80\xa2\xd0\x8d\x2a\xd3\xca\x10\xe8\x63\x92\xbf\xa1\x05\x7f\xd8\x51\xa2\xed\xe7\x65\x7e\xbd\x76\xfe\xe1\x8e\x93\x64\x6c\x83\x8e\x9e\x63\x3e\x9c\x91\x89\x9e\x61\x97\xdf\xc7\x5b\x5c\x3e\xc1\xc2\xe7\x64\x8b\x02\x59\x1a\xd1\xe1\xf1\xa8\x0d\x49\xbf\xdf\xc3\x3b\xc8\xa0\x0e\x5f\x69\x0e\xc4\x72\xc0\x7c\xeb\xf2\x92\x4e\x9b\x2c\x93\x7e\x88\x9d\x52\x49\x3d\x80\x69\x22\x22\x04\x95\xa6\xa1\xc2\x59\x9f\x0c\xd2\x1e\xc5\x57\x36\x69\xf7\xbf\xae\x3d\xaa\xdd\x01\xb3\x89\x7d\x7a\x7c\xb9\x76\xbc\xf7\x0b\xcd\x7b\x3e\x39\xf8\xd1\xd9\x15\xaf\x7e\xda\x71\x62\xd6\xcd\x70\x23\x4c\x84\x4b\x61\x96\x76\xe7\x98\xab\xaf\x6b\x3f\x72\x4c\x3b\x69\xac\xe3\x10\xb6\x8e\xd7\x26\xce\xb5\x70\x1c\x2d\x28\xee\xe0\x1d\x92\xd3\x82\x1b\x93\x96\x58\xe0\xe6\x0b\xc8\x5f\x70\xc1\x73\x16\xb8\xcf\x02\x03\xa9\x89\x65\x63\x82\xa4\xd1\x09\xb5\x4e\x32\x81\xb0\xc8\x09\x4d\x4e\xd8\xe5\x84\x4d\x19\x6b\x58\xcf\xd8\x9a\xc1\xae\xa8\xd7\x26\xc3\xf5\xa8\xbf\x12\x9b\x44\xe3\x0f\xaf\x74\x3c\xa0\xed\x87\x22\x7c\x25\xf9\xb9\xb4\x63\xb3\xb0\xb8\xe3\x03\xdc\xf7\x44\xb3\xb1\x86\xd0\xc2\x7c\xd6\x57\x26\xce\x61\x3e\x45\x42\x33\xde\x43\x02\xf9\x12\x36\x09\xb0\x46\x80\x45\x02\xd4\x0a\x90\x10\x80\x28\x82\xc7\x05\xd8\x65\x3e\x6a\x12\xa0\x51\x80\xa8\x00\x04\x78\x8f\xf9\x3d\x01\x3e\x9d\x26\xac\x3b\x9a\xd3\x2e\xca\x15\x50\x44\x79\x23\x1d\x3f\x9a\x3a\xca\xd1\x33\x7c\x0f\xea\x97\xc8\xe1\x39\x87\xcb\xe5\xe4\x38\x9f\xd7\x29\x11\xb1\x4a\x44\x2d\x61\x77\x3c\xf2\x35\xf9\xa0\xd4\x07\x8c\x3f\x97\x98\xfb\xcc\xa4\x18\xa1\xd3\x47\xc2\x9c\xb8\x7e\x11\x4b\x07\x8e\x14\x41\x81\xf7\xf2\x71\x13\xea\xb4\xef\x70\xf5\x09\xff\x4b\x7b\x8b\xaf\x9d\x3a\xf7\x3a\xfc\xf5\x77\xed\x43\x3e\xfb\xd5\xa4\x5d\xa1\x95\xad\x4b\x79\x22\x42\xd7\xc5\x0e\x44\xd5\x75\x38\x6c\xc0\xd3\x0d\x46\xe6\xc0\x9c\xec\xae\x4e\x72\x63\x76\xc1\xc2\x66\x96\x0a\x02\x7e\x82\x26\x6e\x63\xd3\x7b\x03\x4c\xe8\x78\x04\xaf\xc2\xcb\x97\x76\x68\x64\x8e\x17\xe3\xe6\x8e\xad\xed\x1f\xa1\xf4\x5e\x21\x13\x4f\x98\x48\x5e\xc2\x43\xe7\x59\xb4\x90\x89\xe6\xe8\xe6\xac\xb5\x80\x41\x9e\xc6\x1a\xea\x93\x44\x36\x1e\xe9\xf3\x67\x61\xf1\xc9\x49\x87\xd3\x7d\x88\x71\xd2\x87\x0a\xd7\x26\x52\x01\xa4\xba\x9d\x2e\xd5\x15\x0a\xf2\x76\x8b\x4f\xf5\x15\xf9\x38\xab\x3d\x68\xef\x61\xe7\x6c\x76\x5f\x40\xa6\x91\xdc\xde\x55\x21\xb8\x3a\x04\xa3\x42\x30\x28\x04\x91\x10\x9c\x0c\xc1\xb1\x10\xbc\x16\x82\xc7\x43\xb0\x31\x04\xe4\xe9\xec\x10\xd4\x85\xa0\x26\x04\x15\x21\x70\x84\xe0\xaa\x54\x08\x0e\x87\x60\x77\x08\x9e\x0f\xc1\xf6\x10\xdc\x1d\x82\x1b\x42\x30\x3d\x04\xc3\x42\x50\x1c\x82\x28\x03\xfa\x39\x04\x07\x42\xf0\x01\x83\x39\x75\x80\xdd\xac\xf7\x55\xac\x61\x1d\xfb\xbe\x24\x04\x7c\x08\xaa\x8e\xb0\x67\xad\x21\x58\xc7\x86\x25\x6d\xf2\x59\x77\xa4\xcd\x5e\x73\xbc\x25\xac\xbb\x86\x10\xe0\x44\x08\xaa\xd9\x80\xc7\x43\x70\x88\x8d\xb6\x29\x04\xcd\x0c\x55\xf2\x7d\x2c\x04\x4f\xa1\x50\x86\x51\x46\xe9\xad\xe1\x7f\x5b\x5f\xff\xeb\xd0\xce\x14\xfe\x74\x3b\x0d\x60\x2a\x70\x86\x2b\x91\xee\xa5\x8a\x7e\x55\xd8\xc2\xe5\x39\x40\x09\xd0\x95\xf1\x45\xa1\x0a\xe2\x1e\x21\x02\xb6\xe1\xb9\xda\xdf\xb5\xab\x25\xed\x04\xac\x6a\x57\x4a\xab\x81\x83\x15\xdc\xb8\xec\x81\x9f\x69\xff\x99\xd6\xfe\x13\xe7\x85\x79\xdf\x8f\x6a\xdf\x22\x2c\x6e\x3f\x7a\xfe\x8b\x5f\x71\x83\xd2\x7b\x8e\xf1\x04\x27\xaa\x4d\x94\x20\xbb\xdd\x69\xe1\x79\xc1\x29\xc8\x2e\xb0\x3a\x88\x70\x21\x9b\x5f\x86\x5a\x19\x12\x32\x2c\x92\xa1\x49\x86\x5d\x32\x6c\x92\xa1\x54\x86\x98\xdc\x7d\xf3\x0f\xe8\xbe\xed\x0d\x0c\xa1\x90\xec\x06\x0f\xf7\x75\xc7\x03\x5e\x82\xda\x68\x3c\xdd\x0b\x22\x3f\x64\x43\x63\xfb\xcb\x84\x9e\x9e\xbb\x77\x21\x57\x4e\x51\x21\x72\x8e\xf2\xd3\xaf\x09\x3f\x95\x88\x64\x1e\x91\xe8\xed\xb3\x38\x89\xba\x1b\x0a\xdb\xdd\x0d\x49\x3b\xcf\x2b\x64\xff\xf9\x36\x85\x61\x51\x18\x9a\xc2\xd0\x18\x86\x44\x18\x88\x34\x3e\x1e\x86\x58\x38\xad\x68\xfc\x81\xec\x33\x18\x29\x11\x7f\x38\x2f\x97\x1a\x01\x54\x02\x7e\xbd\x4d\x7b\xe1\x13\xad\x55\x5b\x0e\xd7\x43\x0d\xf9\x33\x5f\xfb\xe8\x93\x57\xdf\xf8\xe4\xf3\x9d\x6f\x7c\x8c\xdf\xfc\x4c\xdb\xf1\x24\x2c\x87\xb1\x70\x11\x2c\xd4\x16\x69\x4f\x1e\x06\x4e\x4b\x7d\xfb\xbd\xf6\x0b\xab\xf9\xa6\xcb\x64\x37\xdb\xb3\x3e\x82\x6b\x4f\x59\x14\x2d\x12\xc1\x36\xe0\x17\x08\xb6\x54\xfc\x58\x89\x5c\xb6\x72\xa2\x77\x51\x00\x9a\x02\xd0\x18\x80\xd2\x00\x44\x03\x90\x3e\x5c\xed\xe4\xfd\x03\x06\x74\x1a\x32\xc4\x7e\x61\x7c\xb2\x8c\x17\x4c\x85\xc7\xbd\xf0\xbb\x8d\xda\x43\x44\xab\x9b\xdf\x01\x1e\xed\x63\xed\x84\xf6\x01\x0c\x58\xb0\x84\x7b\xf5\xd6\x7f\xcc\xd1\x08\x0a\x3f\x7c\xfa\x85\x56\x35\x9f\xcd\x9f\x76\x2d\x9b\x3f\x05\xe5\xa2\x64\xa2\x5f\xb6\x47\x25\xf6\x24\xe7\xf2\x08\x79\xf9\xfe\x30\x11\x44\xbc\x43\x24\x62\x88\xb0\xb5\x58\x43\x92\xe3\x5c\xbe\x45\xf9\xd0\x94\x0f\x8d\xf9\x90\xc8\x87\xd2\x7c\x38\x9e\x0f\xb1\x7c\x48\x53\x20\x95\x4f\x54\xcb\xe9\xce\xe4\xc0\x8d\x2c\x94\xc7\x55\x59\xd8\x39\x67\xfe\x69\xa7\x56\x3b\xf2\xdf\xdc\x1b\xa6\x0f\x1a\x8c\x6f\x9a\xfd\xf0\x3f\xce\xd2\xbe\xd6\x5e\xef\x3a\xc9\x9f\xed\xa2\x93\xac\x7d\xab\xad\x28\x9b\x34\xc1\xfe\x4e\xd6\x33\x1f\x45\x88\xc8\x1a\xd0\x7d\xb6\x7f\x06\xde\x98\xeb\xf5\x8c\x46\x03\xa8\x3e\x51\x0e\x92\xe4\xb5\x79\x09\x9b\x74\xd9\x90\xd3\x49\xf4\x54\x55\x91\xbc\x18\x7b\x1b\x92\x44\x69\x13\x04\x0f\x53\x4e\x91\xb7\x49\x85\x4d\x2a\x94\xaa\x10\x53\x29\xa5\x32\x85\x3a\xd3\x0b\xda\x5d\xf7\xd4\x49\xd6\x98\x7d\xaa\x7d\xda\xc0\x58\x02\x7e\xb4\xf6\xac\xf6\x08\x59\x81\x5d\xed\xe0\x7d\x74\x35\xdc\xa8\xdd\xa9\xb5\x6b\xcb\xe0\xe6\x85\x8b\xb0\xda\xf1\x83\xb0\x78\xff\xee\xbb\x3f\xce\xed\x68\xe1\x3e\xdc\xad\x35\x36\xe9\xfc\x71\x10\xa1\x65\x91\xac\x45\x2f\xa2\x63\x96\x48\x28\x3b\x2b\x57\xb1\x88\xa2\x92\x85\xf8\xde\xc5\x52\x2e\x17\x0a\x91\x35\xc8\xce\x0e\xf1\x9c\x9d\xa8\x9c\x96\x98\xa5\xd4\xc2\xd1\xc3\x11\x6c\xb1\x70\xbe\xce\x63\x91\xf2\x3f\x74\xd8\xc6\x63\xf9\x4c\xd4\xc4\x2a\x69\x68\xc8\x19\x7c\x65\x45\x3e\x51\x9a\x99\xb6\x19\x63\x21\x23\x39\x9c\x20\x6a\xef\x11\x7a\xf9\x97\xf6\x6e\x6f\xc8\xce\x7e\xf4\x1e\xa8\x1c\xbe\xf8\x6f\x1b\x16\x4e\x3e\xb7\x08\xa2\x40\xf6\x20\x58\x0a\xb5\xaf\x94\xe5\x37\x69\x3f\x0f\x68\x7a\x7c\xf7\xf6\x2b\xfb\xc1\x9f\x3e\x38\xb0\xeb\xd5\x92\xa6\x2b\x5e\x18\x7c\x61\x45\x41\x41\x9f\x21\xe3\x66\x8f\xda\xb9\x7b\xf3\x8b\x45\x75\x97\x3e\x5a\x75\x6e\xdf\x82\xe2\xf3\x2e\x5b\x4e\xdf\x8d\x90\x15\x4f\xef\x65\xb2\xc0\xb0\xc4\xf7\x80\x79\xc2\x8e\x6c\x56\x7a\xa6\x49\x67\x1e\xbc\xba\x7b\x50\x0f\xe8\x4a\x47\xb7\xa5\x63\xc9\x56\x31\x17\xa2\x1e\x18\x36\xc8\x84\x99\x72\x92\x01\xed\x36\x7d\x96\x4b\x32\xc2\xc2\xf4\x2e\x0e\xb0\xa7\xad\xac\xfd\x6c\x1b\xd4\x99\x8d\x89\x90\x24\x6d\x8f\x30\xc7\xe9\x6b\x36\x58\xc7\x5a\x45\xd8\xf7\x55\x3f\xb3\x36\xcf\xb3\x6f\x49\xb3\x1b\x98\x9b\x74\x14\x6b\x59\xcc\xfa\x25\x9d\x3e\xce\x1e\xd5\xb1\xef\x1d\xcc\xa1\x8a\x0f\x32\x87\xe7\x6a\x86\xa7\xee\x51\x45\x19\xae\xce\x86\xfa\x53\xf8\xf7\xff\xf2\xc7\x75\xb5\xf0\x3a\x77\x7f\xfa\xa0\xc5\x3c\x1b\x8a\x07\x38\x41\xdb\xaf\x0d\xe0\x9f\xe1\xd7\x9f\x9c\xc4\xaf\x3f\xac\xeb\xb5\x37\x10\x3a\x1a\xc9\x74\x92\xf3\x12\xbd\x9d\x2e\x81\x77\xf1\x44\x23\xe1\x75\x5d\xda\xd7\xe8\x83\x5a\x1f\x24\x7c\xb0\xc8\x07\x44\x31\xd9\xe5\x83\x4d\x4c\x3d\x89\xf9\x32\x99\x33\xa3\xa4\x0c\x96\x28\xc4\x88\xc0\x22\xda\x89\xa2\x2b\x2a\x64\xff\xe2\x8f\xb4\xcf\xb5\xdd\x50\xb4\xf1\x81\x0d\x5b\xa0\x48\x7b\xda\x0f\x59\x60\xe5\x66\xb4\x3f\xf2\xd7\x27\x9e\x7e\x8c\xab\x6d\xdf\xa0\xfd\xac\xed\x67\xf8\xb8\xc8\x5e\x1c\xc1\xce\xc3\xfa\x27\xa2\x36\x3b\x20\x91\xda\x46\x76\x4e\x72\xec\x92\x60\xa3\x04\x8d\x12\x94\x48\x60\xc3\x9c\x08\x5e\x42\xc7\xd5\xe5\x0c\x11\x33\x16\x8c\x0d\xdf\x13\x80\x88\x06\xb5\x9a\xfc\xe2\x86\x6a\xfb\x3a\xfe\x0b\x15\x90\x1b\x29\x09\x94\xd3\xc3\x62\x22\x9e\xe6\x4d\xd8\x31\xae\x95\x5b\xa1\xef\x23\x8c\x90\x65\x15\xd3\x33\x12\x89\x6f\x14\x15\x90\xcf\x2d\xf3\x56\x8b\x64\xb7\xd9\x24\xde\xa7\x0a\xa1\xa0\x2e\xa5\x2b\x98\xd0\x4f\xeb\x03\xad\x4c\xee\xf3\xa1\xfc\xd0\xb0\xd0\xe4\x10\x3f\x2d\x2d\xd9\xd7\x98\x92\xbd\xd6\xd4\x24\x88\x42\x70\x84\x69\x22\xab\x42\x8f\x87\xb0\x3f\x54\x11\x1a\x1b\x9a\x1d\xe2\x33\x75\x81\xb4\xee\x91\xd9\x68\x40\x6b\x68\x6f\xe8\xe7\x10\x67\xea\x10\x75\x21\x5c\x6a\x2a\x12\x44\x53\xc0\x69\x55\xa1\x26\x34\x3d\xb4\x3a\xc4\xb9\xd9\xd7\x07\x43\xd0\xc2\x34\x9e\xa6\x10\xc8\xa1\x9a\x50\x43\x88\xb3\x2a\x32\x6f\xe3\x7c\x52\x81\x04\x12\x51\x94\xa8\xec\x27\x52\xbf\xba\xbc\xbc\x1c\x26\x66\x90\x4d\xc3\x8c\x3f\xd0\x16\x4e\xa1\x35\xfa\x65\xc6\x8c\x77\xce\x3b\x57\x58\x44\x3d\x05\x10\xf7\xa9\x67\x82\x2f\xee\x53\x7c\xd5\xe4\x97\x18\xd5\x1e\xda\x99\x17\x0c\xe6\xbc\x41\xc4\xcc\x3d\x50\xfc\xee\x19\x59\x95\x4f\xc0\xc8\x1d\x81\xb2\x50\xe5\x16\x28\xe6\x4a\xd6\xac\xbf\x65\x45\x3b\x51\xcc\xdb\x67\x7e\xb6\xaa\x03\x7f\xd5\xe1\x1d\xab\x7d\x32\xfb\x5b\x8e\xd6\xa0\x22\xe8\x22\x61\x18\x93\x83\x3d\x13\x01\xe4\xc0\x9c\xd5\x26\x0a\x9c\x60\x73\xf0\x76\xd1\x29\x51\xdd\xb5\xbb\xce\x4a\xb8\xac\x0d\xd2\xff\xf3\x2e\x6d\x03\xf9\xf3\x16\x7c\xaf\x9d\x05\xfd\x89\x04\x18\x00\xfd\xb4\xb1\xb0\x0f\xf7\x25\x76\xc1\x37\xf8\x41\xcd\x05\xff\xee\x98\xdc\x11\xa1\x63\xe5\x91\xb1\x2a\xc9\x58\x56\xe8\x9f\xd8\x2f\x02\x60\xcc\x5b\xac\x02\x6f\xe5\xed\x36\x62\x9d\x73\x1c\x58\x79\x0b\x78\x2b\xec\x90\x6f\x07\xa2\x43\xff\x6c\x87\xd7\xec\xb0\xd9\x0e\x4b\xec\x30\xdb\x0e\xc3\xec\x40\x1e\xf9\xd9\xa3\x6b\x0e\xdb\x61\xaf\x1d\x5a\xd9\xe3\x55\x76\x68\xb2\x03\x6e\xb4\x43\x29\xa1\x67\x3b\x1c\xb7\xc3\x21\x3b\xb4\xd8\x61\xa3\x1d\x16\xb1\x67\x09\xf3\xfb\x83\x76\xd8\x65\x87\x35\xec\x7b\x02\xec\x66\xdf\x0f\x4c\xb1\x06\x7b\xec\xb0\xc9\x0e\xcd\x76\xa8\xb5\x43\xcc\x0e\x72\x46\x47\xab\x59\x2f\x64\x80\x1a\xd6\x2c\xca\x1e\xed\xca\x18\xa0\x81\x8d\xa1\x0f\xff\xc7\xaa\xe2\x29\x7c\x26\xed\x46\xea\xaa\x60\xa6\x0f\xa2\x4b\xd2\x9b\x9e\x8a\x37\xe6\x5e\x31\x0c\x85\x38\x57\xad\x7d\xaa\xd9\xa1\x12\xc6\xc0\x38\xa8\xc4\x43\x3b\x5e\xc2\x43\xb9\xea\x8e\xad\x78\xac\xbe\xef\x86\xd0\x9b\x64\x99\x3d\x7d\x5d\xe2\x5c\x2b\xe6\x2c\x36\x0b\x8f\x79\xbb\xc3\x62\xb0\x79\x6c\x05\x62\xf8\x83\x77\xb5\x03\x30\x72\xc0\x71\x07\x1c\x72\xc0\x1e\x07\xec\x72\x40\x8b\x03\x36\x39\x60\x8d\x03\x16\x39\xa0\xc9\x01\x8d\x0e\xa8\x75\x40\xc2\x01\x5d\x18\x61\xc3\x0c\x33\x70\xa2\xcb\xa1\x33\xa5\xd2\x4a\xa0\xdc\x10\xe2\xfc\xa3\x27\xef\xc1\x27\x3a\xc6\x70\xbf\x76\x88\x5c\xde\x87\xdc\xdb\xdf\xbd\xd7\x5e\x4e\x71\x9b\xa5\x8d\xc7\x77\x0a\xef\x12\x75\xab\x30\xe1\x17\x10\x47\xd6\xde\x4a\x28\xe9\x97\x24\x10\x02\xf9\x25\x49\x63\x89\x32\x95\x16\x76\xac\xc1\xbc\x07\xb3\x70\x8e\x76\x14\xfc\xda\x78\xcb\x9c\x97\x4e\x58\x77\xd2\xbe\x02\xa9\x8f\x71\xa1\xf0\x1e\x8b\x4b\xe1\x04\xe8\x1a\x97\x22\x40\x39\x40\xb9\xf6\xd5\x4f\x90\xd7\x53\xf8\xf5\x84\x9d\xc0\x87\xc8\xd8\x55\xe6\xd8\xd8\xc2\x03\x95\x7d\x02\x19\x5b\x20\xbd\x9d\x76\xec\x4a\xc6\xdd\x3d\x21\x50\xb4\x7f\x92\xf1\xc7\xef\x14\x7e\x7b\xe9\x37\x1a\x3e\x83\xfa\x10\x02\x6e\x26\x73\x2c\xa2\x82\x84\x5b\xe0\x01\x44\x4e\xe4\xac\x16\x62\x91\x01\x4f\x23\x92\xca\x4b\xca\x3a\x8f\x8d\x49\x57\x36\x9c\x47\x58\x24\xf7\x80\xf6\x9c\xf6\xc2\xd7\x44\x39\x1d\x0a\x2b\x30\x66\xce\x90\xe6\xf6\xc5\x08\x52\x47\x53\x22\xbf\x34\x35\x96\xbc\x4b\x28\x21\xe9\x41\x36\xcf\x27\x11\x00\xa0\x92\x99\xc5\xc6\x2b\x59\xc8\xd4\xfa\xf9\xfb\x4f\x5c\x78\xa1\xbe\xce\x43\xf9\x8d\xb8\x5a\xf8\x82\xd8\x82\x7d\x13\x51\xc4\x73\x54\x9a\x93\xf9\xbc\xad\x4e\x46\x20\xa3\x12\x54\x8d\x1a\x50\x33\xda\x88\x8e\x91\x37\x66\xc7\x28\x19\x72\xc4\x06\x95\x71\x5f\x00\xfe\xa4\x6d\x05\x7c\x92\xdf\x08\xfe\x62\xed\x50\x94\x70\xec\xc1\xa9\xa3\xfc\x22\xfe\x42\x54\x88\xca\xd1\xb5\x89\xea\xfc\xa2\x22\x8b\x25\xe0\x92\x7b\x73\x9c\x1c\xe0\x2a\x2b\xc4\x1e\x63\x92\x64\xbf\x26\x5d\x53\x5d\xb8\x0f\xe1\x47\xb2\x2b\xea\xc2\x36\xde\xe5\xf5\x3a\x46\x27\xbd\xee\x50\x09\x2a\xa9\x49\xe6\xc7\x91\xb2\xb3\x12\x6a\x2a\x81\x69\x6e\x65\x9d\xb4\xd2\xc0\x7c\xb1\xde\x6e\x8e\x93\xb4\x01\x5e\x59\xd1\xaf\x3a\x7d\xf0\xa1\xc7\xc3\x30\x49\x57\x15\x70\x71\x54\x5f\xcd\x13\x7d\x16\x17\x36\x8f\x05\x60\xc5\xfa\x96\x03\x7b\x7e\x18\x39\xf6\xc2\xf3\x6c\xda\x81\xc8\x91\xdd\xef\x7d\xd1\xb3\x34\x96\x13\xea\xd1\xa3\x4f\xce\xb4\x2b\xec\xe2\xdc\xe4\x9a\xcb\xc7\x14\x0f\x1f\x34\xf4\xda\x33\xfd\x8f\xaf\x7b\xb4\x05\xf3\x55\xd3\xae\x1a\x3e\xc6\xb5\xe1\xe1\x77\x9e\xd3\xe6\xd6\x9d\x23\xde\x27\xda\x45\x7e\xca\x15\xfb\xb0\x8d\x98\x19\x23\x06\x5f\x30\x6a\x44\xf3\x70\xaa\x8b\x2f\x27\x73\xb0\x9a\xd0\x89\x82\xe2\x68\x70\x22\x96\x2d\xca\xb2\x53\x25\x1a\x6c\x5e\xae\x3f\x5c\x93\xf4\xf8\xdd\x2e\xe4\x08\x70\xb1\x9a\xa4\xc8\x29\x4d\x79\x40\xf5\x6d\x16\x6d\x59\x5d\x9e\x69\x12\x18\x31\x4d\x14\x6d\xa2\x90\xc6\x99\xb4\xb6\x94\xeb\xe1\x4d\xe9\xf3\x6b\x7e\xf5\xc7\x6f\xcd\x7a\xb4\x0f\xb6\x09\xda\x31\x2b\x84\x78\xbe\xe1\xe4\xae\xf7\xb4\x03\xd7\xcc\x98\x39\x6f\xce\xcc\x83\x38\x4e\x64\xf7\xc7\x93\x27\xe6\x2d\xf0\xd4\x3f\xc0\xef\xd3\x2e\x6f\xd9\x43\x64\xfd\xaf\x6d\x3b\x76\xb6\x6e\xdd\xa5\xd3\x40\x2d\xc1\xb5\x8a\xac\x57\x10\x0d\x4d\xe4\xfb\x03\x76\xea\x0c\xb5\x05\xb8\x70\x48\x74\xd6\x24\xed\x76\xd1\x8d\xfc\x8d\x7e\xec\xe4\xfc\x7e\x84\x3c\x35\x49\xf2\x4e\x9d\x0e\xd0\x53\xfc\x9f\x42\x67\xdc\x05\xf5\x5a\x79\xdc\xf4\xe0\x5d\x70\x61\x3c\xe6\x57\xa2\xce\xbb\x7e\xdb\x79\x22\xa6\x7d\x23\x35\x4e\xd8\xff\x79\xed\x35\x4e\x08\xcb\x8b\xff\xee\x87\x02\xa2\x8c\x4a\x50\xbc\xeb\x31\xd7\x45\x93\xb4\x7b\xb4\x95\x57\x4c\x76\x4e\xdf\xd6\x60\xda\x84\xfc\xa5\xc6\x3c\x9e\x99\x88\xa9\x9c\xd7\xeb\xcb\xb6\xf9\x6c\xb9\x79\x5e\x24\x91\x99\x94\x25\xb7\x18\xad\x49\x72\xa2\x82\x02\xfa\x3c\xea\x13\x59\x9e\xe1\xc3\x30\x66\x32\x7e\x06\x54\xe6\x11\x9b\x85\x06\x2c\x52\xfc\xca\x8b\xc8\x6c\xfa\x55\x63\x26\x29\x9e\xdc\xf9\xbc\x83\xaf\x4b\xbd\xf8\xfe\xfe\x37\x67\xfd\x95\xec\x4e\x08\x59\xb5\xaf\xe7\xcc\x9c\x71\xdd\xe7\xd3\x17\xc8\xf3\x7b\xbc\x06\x45\x60\x03\x27\x14\x34\x36\xec\x80\x55\x27\x63\x93\x6f\xc5\x79\xdb\x5f\xfc\xdb\x0b\xda\x9a\x57\x19\xae\x74\x1e\xfb\x90\x79\xf4\xa2\x10\x9a\x9e\x38\x5b\xb5\xbb\x3d\x8a\xc3\xc1\x71\x1e\x3b\x17\x09\x2b\x8e\x31\x49\x25\xee\xf6\x8c\x90\x15\x70\x09\x8a\x82\x44\xd1\x47\xf6\x81\x1b\xb9\x46\x27\x9b\xd9\x91\xaf\xdb\x8d\x94\x8d\x11\x98\x1e\x81\x86\x08\xd4\x44\xa0\x24\xa2\xb3\x4c\xea\x69\xaa\xaf\xef\x16\xa9\x53\xdc\x4d\xa6\x9a\xd3\xee\xf5\x04\xe2\x8c\xdc\x05\x0c\x64\x07\x90\x77\xc6\x23\x7f\x26\x66\xb7\xfd\xe7\x1f\x7e\xed\x18\x39\xe7\x9a\x7b\xc8\x2b\xcc\xd2\x36\x4d\xba\x9a\x83\xcd\xd6\xeb\xfc\x84\x9f\x04\xc8\xd4\xc7\xb4\xdd\xda\x3f\xac\x1b\xfe\xbc\x58\xd5\x3e\xe5\x9e\x5c\xb9\xf0\x96\x5b\x0c\x79\x8b\xb7\x91\xb9\x0f\xa0\xb3\x13\xf9\x4e\x1f\x59\x24\x8c\x03\x7c\x80\x57\x15\xbb\x3c\x3a\x69\xa7\x0e\x3a\xbe\x26\xe9\x13\x64\x08\xec\x54\x61\x91\xca\xb6\xaa\x1e\xd1\x68\xd8\xe0\x65\x3a\xeb\xd2\x83\x5e\xc8\x6c\xe7\x55\x96\xb3\xf8\x12\x35\x40\xe7\x3c\x1b\xca\x03\xb0\x5f\xfb\x7e\xc3\x86\x07\x37\xd6\x4c\xea\xd9\x73\xc4\xa0\x7d\xdc\xc2\xf6\x25\xdc\xc2\x97\x66\xac\xbd\xc3\xfd\xb4\x6d\xc0\x88\x8b\x5f\xd2\xed\xda\x0b\xf9\x4b\xf8\x1a\x42\x01\xc5\xe8\xb2\xc4\xc0\x60\xae\xdd\x1e\xe5\xb9\x22\xaf\x97\x8b\x72\x7d\x7a\x47\xe4\x40\x41\x4d\x52\x0d\xb8\xe5\x9e\x35\x49\x49\x0e\x20\xcb\xe8\xe4\x38\xfe\x4a\x7e\x2e\xcf\xe5\xf2\x65\x3c\x16\x08\xc6\x98\x47\x91\xa6\x3e\x94\x3a\xca\xea\xf5\xa9\xec\x42\x24\x9d\x13\x49\x37\x5c\xda\x89\x37\x04\xaa\x3a\xe9\x45\x2d\xaf\xe8\x57\x15\x17\x09\x33\xe1\x39\x4a\x31\x8c\xb0\xf1\xd8\x37\xfe\x95\x05\x21\x79\x52\xed\x9c\x6b\x30\xae\x4f\xbd\xb8\xe7\x1f\xef\x1e\xad\x13\x6c\x02\xd8\x45\xed\x84\x3c\xef\xba\x2f\x0f\x36\xcd\xd3\x2e\xbc\xf7\xb6\xf8\x59\x23\xd7\xdc\x31\xe0\xea\x37\xa9\x5e\x4d\x68\x28\xf6\x6a\xde\xf5\xbe\x6b\xee\x68\xff\xf2\xbb\xa3\xdc\x17\x7f\x7d\x5e\xbb\x4f\xdb\xf8\xbc\xbe\x17\x57\x93\x59\x9d\xcc\xe6\xbc\x36\x51\xe2\x95\x65\xb7\xd5\xe2\xb6\xa8\x8a\x07\xb9\x2d\x81\x00\xc7\x39\x6a\x93\x9c\x9b\x98\xb5\x6b\x54\x38\xae\x42\x0b\x33\x71\xc9\x67\x62\xeb\x1e\xa3\xd3\xaf\x2b\x05\xe9\x90\xc4\xea\xae\xde\x05\x83\x1b\x12\x85\x9f\x12\x3c\x73\x1a\xfa\x2d\xb0\x79\xc0\xd6\x79\x5b\xdb\xb4\xef\x5f\xbe\xf2\x46\xed\x3b\x42\xf1\xdc\xe5\x0b\x9b\xf6\xbe\xdb\x31\x06\x4f\x84\xec\xed\x2b\x3a\x5e\x14\xde\xd5\xae\xbe\x76\x0a\x5d\x07\x82\x1b\x3c\xca\x62\x38\x2d\x68\x5c\xa2\x1f\x67\xb1\xb0\x43\x79\x41\xe6\x03\x80\x2e\x22\xd2\x57\xb7\xfc\x5a\x98\x15\xa7\x47\x97\x44\x33\x82\x5a\x5a\x58\xfc\x48\xa7\x02\x63\x9a\x26\xd5\x19\xe1\xaf\xec\x34\x9e\xe0\xb5\x9a\x46\x7a\x10\x5e\xd6\xf1\xc1\x07\x27\x39\x7e\xe0\xc9\x37\xc8\xf8\xa9\x43\xda\x78\x78\x8c\x8d\xef\x46\x6f\x26\x6e\xb5\x70\x4e\x27\x92\x24\x8f\x57\x22\x16\x41\x6d\x92\x8f\xe8\x48\xec\xf2\x42\x8b\x17\xb6\x7b\x61\x91\x17\x6a\xbd\x90\xf0\x82\xdb\x0b\x7b\xbc\xb0\xc6\x0b\x8d\xec\x9b\x63\x5e\xd0\x61\xd6\x30\x98\xa6\x0c\x30\xe4\x85\xfe\x29\x2f\x1c\xf4\xc2\x07\x5e\xd8\xc4\x1a\xec\xf4\xc2\x46\x2f\x34\x7b\xa1\xda\x0b\xb2\x17\x0e\xb1\xbe\x36\xb1\x7f\x46\xd9\x37\x96\x4c\x25\xbd\xbb\x82\x9e\xa1\xbe\x19\x8a\x81\xc1\x96\xcc\x5d\xc1\x5e\x38\xb7\xa8\x52\xd5\x4d\x31\xbf\xb8\x86\xbc\xf9\x97\x93\xcf\x2d\x1f\x51\x09\xa1\x3b\xe9\xfb\xff\x7e\x89\xed\x0d\xbe\x7a\x12\x3f\xf7\xe4\xb9\xab\x1f\x48\xd3\xc8\x1c\x32\x0f\x0e\x54\x95\x88\x20\xb0\x5b\x6d\x36\xbb\xc3\x61\xe1\x78\xde\x29\x81\xc5\x2a\x13\xc9\x8f\x02\x25\x4e\xea\xc9\x2d\xab\xae\xd6\xfd\x72\x64\xbc\x32\xaf\x4e\x0b\x65\x5d\x7d\xc6\xc4\x06\x3b\x38\x9f\x4e\x36\xdc\x0c\x67\x68\x4b\xe0\x7e\xf8\xe7\x58\x6d\x9a\xf0\x6e\xfb\x36\xd8\xa5\x5d\xd2\x71\x4d\x9a\x2e\x8d\xb5\x3f\x37\xd1\x87\x68\x28\x02\xd5\x94\x02\xba\x33\x5e\xf7\xc1\x37\x9b\x3e\xf8\x63\x7f\xe4\x83\x3f\xc5\xf7\x4e\x56\x59\x78\xf7\x04\xad\xe5\x8a\x96\x23\x24\x6e\x20\x7b\xbc\x10\xad\x4d\x4c\x54\x0b\x11\x8a\x5a\xa3\x39\x6e\x8b\x35\xc7\xda\xa3\x28\x97\xf3\x73\xb5\x49\xb7\x1a\xe6\xfc\x6e\x49\x8e\x5a\x51\xe0\x70\x0f\xd8\xdb\x03\x96\xf4\x80\xb1\x3d\x60\x50\x0f\x38\xd0\x03\x9e\xef\x01\xeb\xcc\x7f\x96\xf4\x00\x1c\xed\x01\xa8\x07\x1c\xea\x01\x7b\x7a\x40\x4b\x0f\xd8\xd8\x03\x16\xf5\x80\x46\xf6\x2c\xbd\x34\x0d\x19\xea\x35\xf3\xb8\x56\xab\xdd\x62\x37\x4d\xcd\xab\x73\xcb\x54\x14\x16\xc5\x73\x20\x50\x4e\xf7\x92\x5a\xde\x65\x47\x59\x3c\x9c\xb4\xf9\xe2\xab\xb5\xef\x04\x0e\x24\xce\xce\x57\xac\xbb\xe6\xb7\x4a\xb1\xea\x81\x79\x1b\x1e\xd1\x7e\xd8\x3c\x66\xaa\x80\x1b\x20\x7b\xdb\xca\x8e\x17\xb8\x11\xe3\xa7\xf7\xf6\xfd\x25\xba\xb0\xe9\xe8\x4d\xd7\x7d\xfc\x76\xc7\x68\xfa\x60\xe3\x6d\x1d\xdb\xf5\x79\xe0\x27\x93\x79\x08\xa2\x9a\x44\x09\x0a\xba\x2d\x16\xab\x35\x18\x0e\xb9\xfd\x74\x0a\xe8\xeb\x93\xb7\xdf\x14\x86\x35\xcc\xf1\xd9\x12\x06\xfd\x73\x53\x18\x8e\x85\x33\xf6\x7f\x59\x66\xd0\x61\xfa\x14\xe6\x74\xef\x40\xb0\xe7\xce\x67\x5b\xdf\xc0\x9a\x71\x03\x8a\x10\xd9\xfb\x19\x98\x12\x8e\x30\xda\x94\x71\x6b\x89\x8c\x73\x10\x0e\x55\x9a\x08\x7b\x44\x89\xa8\xaf\xaa\x62\x93\x6b\x92\x36\x37\xe7\x27\x92\x58\x21\xcc\xa8\x51\x85\xd3\xfa\x62\xdd\x28\x9e\x9b\xf6\x17\x16\xe6\xc5\xa8\x66\x16\xe3\xd7\x6a\x9f\x69\x5a\x07\x8d\xf3\x02\x8e\x30\x47\x22\x83\x6e\xba\x3e\x85\x6e\x9c\x0b\x1c\xd1\x97\x7f\xd7\xf6\x41\x6f\x22\x7a\x04\x28\xd6\x0e\x6a\xff\x7a\x79\x9b\x76\xe7\xd3\x2f\xea\x31\x34\xcb\xb5\xf1\xfc\x6a\x7e\x34\x52\x75\x1d\x2b\x88\xbc\xd9\x36\x9b\x03\x39\xf2\x72\x03\x44\x33\xf0\x06\xdc\x2e\xd9\x1e\xf9\x7f\xe8\x58\xe9\xb8\x71\xaa\x63\xb1\xa5\xac\xd0\x27\x87\x29\x59\xee\x4e\x1d\x6b\xff\x1b\x33\x1f\xeb\x23\x8a\xda\x77\x56\xf0\x08\x16\xa2\x63\xbd\xb8\x47\x3b\x40\xb8\x3b\xe1\xf1\x38\x57\xfb\x97\xb6\x7f\x52\x7d\xce\x7d\xda\x65\xfc\x3f\xef\x6f\xf4\x4e\xab\x78\x93\xe8\x58\x3f\xc3\x35\xaf\xb5\x6c\xdf\xa9\xe3\x3a\x96\xe0\x4a\x65\x98\x1f\xe5\x50\x5c\x85\x80\xd3\x29\x85\x91\x84\x62\x51\x6f\x16\xd1\x62\xbc\x8a\x33\x42\xd4\xae\x60\x0d\x31\xad\xdc\x4d\xb1\xff\xa1\x0f\xfa\x98\x30\x32\x64\x51\xdc\x43\x24\x54\x3c\x17\x43\x5a\x22\x8d\x3d\xf0\xe6\xd1\x3a\x07\x0f\x2e\x51\xfb\x41\xc0\xf5\x5a\xfb\x8b\xef\xe3\x23\xb3\x67\x7c\x79\xf0\xba\xf9\x38\x8b\x48\xfa\xa2\x57\xcf\x98\x21\x5f\x73\xfb\x49\x05\x5e\x59\xf7\x16\xd1\x67\xe4\x27\x76\x6a\x77\x30\x05\x86\xd1\x1e\xd6\x08\x8e\x0a\xd1\xb4\x0a\xac\x44\x45\x41\x72\x50\x75\x7a\x6b\x93\x56\xa7\x5b\x90\x51\x60\x63\x10\x9a\x83\xb0\x27\x08\xdb\x83\xd0\x10\x84\x92\xa0\xe1\x64\x42\x5d\xd1\xa4\x7b\x3b\x4d\x62\xd8\x14\xf6\x01\xcf\x6a\x83\xc2\x7a\x26\x26\x0c\xed\x17\x1f\x56\x31\x75\x0e\x37\x38\x39\xef\x0c\xef\xdf\x72\x66\xd6\xf7\x91\x8f\xc8\x5b\xfe\xda\xf1\x23\xe3\x35\x23\x68\xec\x3f\xc1\xa3\x07\x9a\x99\x38\xc7\x22\xc6\xfd\x91\xb0\x13\xa1\xb0\x5f\xe4\x7b\xf6\x8a\x3b\x55\x4e\xcd\x19\x9d\x7c\x25\x02\x8d\x11\x62\x3b\x44\xa2\x11\x6c\xe7\x23\x11\xd5\xcd\xd9\x47\x27\xfd\x96\x7c\xe6\x42\x55\x6a\x7b\x41\x4b\x2f\x28\xed\x05\x89\x5e\x50\xd2\x8b\x39\xb5\x67\x32\xb7\x6a\x3a\x72\xb8\xc1\x88\x2f\x3f\x6d\x30\x6c\x61\x51\x95\x19\xea\x5c\xc4\xf2\xf2\xa8\xbe\x68\x31\x4e\x61\x15\x35\x87\xe3\xa3\x5a\xea\xeb\x83\x3f\x16\xfd\x37\x70\xd5\xa2\xb9\xd7\x8c\x9f\xf2\xd3\x23\xe3\x8f\x1d\x78\xf9\x48\xf6\xef\xd2\xc4\x2b\x27\x4f\xbe\xa0\xae\xf9\xf5\x79\xc3\x61\xf0\xfa\xa7\x6e\xbf\xa7\xe0\x82\xc4\xe0\x44\xc5\x90\x40\xc9\xe8\xc5\x13\xd7\x3d\xf1\xa7\x3b\xc2\x43\xcf\x2a\x1f\x5c\x52\xe5\x0d\x57\x9d\x3f\x8f\xda\x93\xa9\x9f\x88\x2d\xdb\x9f\xec\xa6\x41\x89\x6c\x9f\x24\xd9\x9d\x56\x27\xcf\x2b\xaa\x53\x10\x05\xa2\x7c\x8b\x56\xab\x28\xa7\x95\x6e\x86\xbb\xa7\x6b\xca\x48\xda\xee\xa1\xca\x55\x55\x79\xa0\x3c\x90\x67\xd8\x3b\x22\x6c\x5e\xb8\x6c\xc5\xbd\x13\x5a\xde\x7b\x6f\x70\x75\x7c\xc8\x14\xef\xf2\x15\xf8\xa6\x97\x34\xed\xa5\x8e\xf7\x6b\x46\xb9\xb6\xe5\xb2\xb9\x6e\xa6\xfa\x35\x3f\x90\x74\x4f\xf8\x8d\x8b\x70\x1b\xa4\x58\x95\xa0\x4a\x8c\x31\xc2\x6f\xbc\x8a\x14\xb0\x20\x79\x53\x10\xd6\x04\xe1\x78\x10\x5a\x82\xa0\x7f\x6e\x0a\xc2\xb1\xe0\xff\x83\xdf\x00\xa3\x47\x26\xd4\xd4\x78\x61\xa5\x11\x9a\xe5\x81\xfb\x76\x5d\x79\x23\x55\xac\x7f\x96\x84\xfe\x4f\x10\x5e\xc3\x0f\xec\xf8\xb3\xf6\xf5\xf6\x15\x78\x58\x7b\xdb\xca\x29\x6b\x86\xdf\xd0\xf4\xd1\xbb\x78\x3b\xc5\xcd\x4a\x78\xe1\x34\x82\x9b\x1d\x2e\x4a\xa4\xe8\x35\xa5\xa2\x8d\x58\x23\x98\x73\x48\x77\x4b\xb0\x48\x82\xcb\xa5\x99\x12\x1e\x2b\xc1\x50\x09\x2a\x24\x28\x94\xc0\x2b\x01\x2f\xc1\xcf\x12\x7c\x2b\xc1\xdf\x25\x80\x5d\x12\x6c\x96\x5a\x25\xbc\x48\x5a\x23\xe1\xc9\xd2\x6c\x09\x27\xa4\x5a\x09\x13\x60\x37\x83\xbc\x8a\x80\xee\x91\x0e\x49\xb8\x55\x7a\x4d\xc2\x9b\x24\x58\x42\x7a\xc6\x8d\x12\x0c\x93\xc6\x4a\x38\x26\x81\x5f\x82\xbd\xd2\x61\x09\xef\x96\x60\x8d\xb4\x49\xc2\x4b\xa8\x83\xb3\x49\xc2\xc6\xf3\x52\x09\x13\x88\xe3\x06\x50\x8b\x04\x74\x8c\xbb\xa5\xcd\x12\x9f\x90\x20\x5f\xaa\x90\x30\x92\xa0\x0a\x37\x49\x8b\xa4\x16\x69\x97\x74\x5c\x12\x1a\x24\x40\x92\x5b\x4a\x48\xdc\x1e\x09\xb6\xd3\x5e\x61\xba\x04\xb5\xd4\x69\x5a\x2d\xe1\x66\x69\xb5\xb4\x53\x3a\x26\xa5\x24\x81\x7c\x25\x4b\x51\xf2\x25\x67\xb1\x61\x59\x84\x96\x80\xee\x4d\x9d\x98\x76\xff\x50\xe7\xcf\xc4\x53\x1d\x42\xdd\xfc\x41\x0d\x99\x8e\xa4\x53\xdc\xb0\x3e\x85\x39\x02\xf1\x01\xad\x45\xbb\x11\x7a\xbe\x28\xf7\xb7\x9f\xf9\x26\x14\x92\x25\x79\xb8\xec\xad\x9e\xef\xe3\x46\x4a\x23\xa9\x13\x44\x36\x0f\xa1\x37\x41\xc1\x73\x89\x14\x20\x8f\xcb\xc9\x5b\x44\xbb\x9d\xf7\x70\x56\x9f\xdf\xaf\xd8\xac\xd6\xc0\x6a\x05\xe6\x2b\x70\xb5\x02\xf5\x0a\xd4\x28\x30\x48\x81\x3e\x0a\x44\x14\x70\x2a\xf0\xbb\x02\x47\x14\xf8\x5c\x81\x0f\x14\x78\x4c\x79\x56\xc1\xeb\x14\xb8\x5d\x81\x66\x13\x7c\x94\x02\x43\x28\x6c\xb1\x82\x09\xf4\x94\x94\x02\xfb\x95\x1f\x14\xbc\x5b\x81\x17\x15\x78\x5c\x81\xf5\x0a\xac\x50\xe0\x06\x05\xae\xa5\xb0\x75\x0a\x26\xd0\xc5\x0a\x84\x14\x70\x28\x40\xf8\xd8\x8f\x0a\x1c\x50\xe0\x3d\x05\x9e\x65\xe0\xf7\x2b\xb0\x8a\xc2\xde\xa8\xe0\x3a\x05\xce\xa3\xb0\x83\x14\x9c\xad\x00\x10\xc3\xeb\x79\xe5\x80\x72\x44\xe1\xb6\xd3\xb1\x57\x29\xb8\x46\x69\x50\x70\x05\xed\x28\xa2\xe0\xfe\x04\xcb\x83\x0a\x90\x71\x5b\x15\x58\x47\x11\x5c\xad\xe0\xc9\x0c\xbf\x6a\xf6\x2e\x64\xac\xc3\x4a\xa2\x9a\x42\xec\x54\xe0\x6e\x65\xb3\x82\x09\x56\xd3\xe9\x08\xa3\x14\x4c\x9e\x1e\x53\x00\xef\x52\xf6\x28\x78\xb5\xb2\x5d\xc1\x4d\x0a\x28\x09\xbb\x73\x04\x52\xc0\xea\x73\xf2\x56\xd9\x63\xb7\x5b\xc8\x3e\x27\x8a\x46\xda\xbb\x5b\x5c\xdf\x25\xeb\xf2\x54\x4f\xee\xff\xca\x5a\xef\x16\x3b\xd6\xb9\xca\x06\x2f\xf3\xaa\x69\x0e\x61\x7a\x7f\x2d\xcc\xf9\x5b\xcd\x7c\xbf\x6a\x95\x2f\x2e\xc4\xb5\x8f\xb7\x4a\x79\x15\xdb\xb4\x8f\xb5\xef\xc1\xba\xc3\x15\xda\x02\x7d\x1e\x71\x45\xb2\x1e\x04\x1e\xdf\xdd\xe7\xc9\x43\x1d\xd7\xf1\x03\xdb\x5f\x1f\x39\x07\x2f\xec\x58\x52\xb1\x6a\x09\xfe\x9b\x71\x06\x40\x74\x94\x81\x44\x07\x48\x24\xf2\x91\xc3\x6a\xb3\xf3\x60\x11\x05\xcc\x71\x82\xc5\xe6\x10\x9c\x12\x15\x16\xc7\x9d\x70\xc8\x09\x1b\x9d\x50\xe3\x34\x8e\xdf\x32\x2d\x2d\x33\x3c\x3f\xee\x60\xde\xc8\x08\x53\x44\xcb\xdb\x35\x22\xec\x6f\xd3\x96\x43\xc9\x77\xdf\x42\x5f\xf2\x7b\x35\xdc\xaa\x5d\x8f\x4b\xb0\x43\xdb\x00\x97\x77\xfc\xd6\xf1\x3e\xe3\x59\x6e\x22\x4b\xa7\x90\xf1\x03\x94\x1e\x1d\x76\x9f\xcd\xe5\xf1\x7a\x5d\x44\xb2\x28\xaa\xc7\x2e\xfb\x5c\x36\x24\xd4\x26\x51\xe4\x4f\x2a\x2c\x53\x61\x96\x0a\x93\x54\x62\x9a\xa8\x30\x54\x85\x32\x15\xf2\x55\x20\x36\xbf\xa8\xc2\xbf\x55\x38\xa4\xc2\x1e\x15\x5e\x51\xa1\x55\x85\xcd\x2a\x90\x06\x37\xab\x30\x9b\xa9\x2f\x63\x18\x7c\x85\x0a\x85\x2a\x78\x55\xe0\x55\xc2\x2c\x54\xf8\x4a\x85\xbf\xab\xf0\x1a\x6b\xf0\x90\x0a\x77\xab\xb0\x44\x85\xb9\x2a\x5c\xa9\xc2\x58\x15\x86\xb1\x01\x72\xcd\x01\x7e\x55\x61\xaf\x0a\x6f\x30\x33\x8d\x00\xdf\x95\x01\x9c\x38\x1d\x24\xc1\x63\x87\x0a\x86\x45\xb7\x84\x61\xa1\x77\xaa\x9f\x61\xfa\x19\x16\x55\x04\x8b\xdd\x6c\xfc\xd9\xec\xdf\x89\x41\xe4\x8b\xc3\xec\xbb\xe7\x55\x78\x9c\xe1\x44\x9e\x0c\x62\x2f\x8a\x54\xc0\xc7\xd9\x6b\xea\xf6\x39\xd1\xcc\x6a\x59\x77\x6e\xf6\x2c\x23\x66\xa1\xa1\x1b\x91\x65\xd0\x56\x43\x17\xe2\x3a\x0d\x1d\xfe\x61\x14\x63\x83\x7e\xda\x45\xe3\x17\xcb\xcb\xab\x3b\x9d\xbc\xba\x78\x20\x46\x0f\xf3\xc1\x55\x31\x36\x44\x69\x12\x5c\x00\x91\x2b\xce\xaf\xec\x3d\xb8\xa6\xba\x48\x1b\x0b\x3d\xb7\xf4\x18\x12\x3a\x6b\x13\x14\x6a\x63\xc7\x3d\xab\x8d\x77\xbe\x65\x2d\x9c\x30\x95\x2f\xd1\x84\x6b\xbf\x6c\x38\x02\xa9\x93\xb7\xef\xd9\xc4\xe8\x61\x0c\x42\xdc\x33\x84\x1e\x6c\x68\x58\xa2\x08\x8b\x16\x00\x4e\xb4\xf2\x0e\xbb\xc8\xf1\x44\x88\xf1\x32\x58\x90\x85\x10\x44\x20\x61\x7a\xa8\x9b\x1d\xa0\x2b\x04\xa7\xf5\x40\x97\x9b\x0e\xe8\xc0\x18\xe8\xd0\x7a\x73\x76\x4d\xc4\xc5\x6f\xe2\x47\x77\xbf\xdd\x71\xe9\x7b\x74\xbc\xb8\x36\x1e\xff\x9b\xd8\x42\x79\xe8\xec\x44\x9e\x92\x93\xe3\xe0\x3c\xb9\x9c\x85\xcf\x2f\x08\x5b\x2d\x56\xcb\x2f\x49\xab\x55\x8e\xcb\xde\x5f\x92\x32\x42\xf1\x2e\x2e\xe1\xee\x67\xcf\xc6\x44\x10\xa9\x48\xf4\x8c\xca\x33\x81\xfc\xee\x37\x08\x02\x4c\x5b\xd2\x13\x70\xa8\xef\x92\x7c\x83\xfb\x2c\xfb\xf3\x75\xf3\xe6\x5f\xb3\x7e\xe5\xeb\x03\xeb\x46\xcf\xba\xb4\xa1\x69\x74\xdd\x40\x6d\xfc\xfa\x3b\x60\xc4\xcc\x19\xf8\x55\x61\xc6\x0c\x18\x71\xd7\xfd\x2f\x4d\x99\xaa\x7d\xd4\xb0\xd2\xc7\x2b\x2b\xea\xb5\x8f\xa6\x5d\xb5\x93\xe0\xfa\xa0\x36\x00\x1e\x62\x76\x5b\x65\x22\x4e\x23\xaa\x10\xd2\x8d\xb6\x52\x01\x62\xa7\x84\x55\xa5\x17\x8f\xfa\xc0\x89\x30\xd7\x13\x31\x1e\x04\x51\x1b\x60\x59\xfb\xdb\xb5\xa4\xbf\x62\xf2\xee\x9a\xf9\xee\x92\xa2\xf0\x39\xe1\x9c\x3c\x0f\x79\x77\x6b\x38\x12\x8e\xfc\x92\x0c\x87\xbd\xe4\xd9\x2f\xc9\xbc\x88\xd7\xf3\x4b\xd2\x8b\xfe\xf7\xbb\xab\x4c\x43\x30\x12\x8f\x3c\x46\x3a\x1f\x73\xd8\xaa\x01\x17\x7d\x79\xb1\x18\x8a\x07\xd4\xd7\xcc\x98\x58\x37\xbb\xa6\x7e\xc0\xeb\x2b\xd7\x5f\x37\x7f\xfe\x75\x9b\x96\xbf\xfe\xcf\xab\xa6\x41\x9f\x4b\x57\x2a\xbc\x6f\x45\x23\xf4\x99\x3a\xe5\xa5\xfb\xef\xd2\xda\x9a\x66\x0a\xaf\xe2\xd9\xd3\xb5\xb6\xdb\x37\x30\xba\x18\x8d\x79\xbe\x81\x1b\x41\x78\x6e\x61\xc2\x6f\xf5\xa9\x8a\xd7\xe1\x10\x9e\x48\x22\xc7\xf6\x3a\xe4\x7e\x22\x49\xd4\x8b\x92\x32\x1a\xad\x66\x28\x2e\xba\xeb\x87\x39\x8e\x2b\xa9\x8f\x8a\x05\x39\x10\x34\xb8\xb1\xa3\xee\x1c\xb5\x7c\xdc\xf0\x79\x67\xcd\xd8\x30\x75\xc5\x92\xc9\x7d\x96\xcd\x4c\xcc\xc1\x7c\xaf\x70\x49\x71\x9f\x7d\x63\x4b\xce\x08\x5e\x7a\xa0\x77\x3e\x4a\xb1\x02\x1d\xf4\x3f\xb7\x48\xaf\xec\x23\x3a\xff\x2b\xda\xb3\xf0\x3d\xa1\x4b\x9a\x13\x74\x5e\x42\xb2\x60\x1e\x03\xd8\xac\x02\xb1\xcf\xdb\x20\x9c\xd8\x0f\x68\x7d\x1d\xc8\x37\xd8\xe0\x6a\x76\x26\x9d\x3e\xca\x3e\xc0\xbc\x27\x93\x33\xce\xaa\xc9\xa3\xa9\x27\x59\xe5\x14\xfd\x40\xfb\x71\x76\xa6\xad\x97\x47\x19\xc4\x8e\xa8\xf5\xc6\x87\x99\x8b\x45\xef\xb1\xce\x3c\x83\x3f\xc2\x1a\x3e\x6f\xd6\x66\xd1\xab\xb7\xe8\x47\xe4\x46\xf5\x16\xfd\x81\x7e\x44\xae\x9f\xcc\x47\x58\xb1\x16\x7c\x28\x23\x2d\x48\x77\xee\x74\x4b\x0b\x6a\xc9\x48\x49\xd2\x01\xd0\xe9\xd3\x82\x1a\x4e\xa3\x9b\x9c\x46\xee\x75\x7b\xa8\x53\x4f\xd7\xe2\x2b\x2c\x35\xc8\x57\xee\x7b\x0b\x62\xda\xa7\xb1\x6f\x63\x5c\x6f\x9a\x9b\x70\xf2\x76\x6e\x5f\x7b\xb1\xee\xab\x28\x4f\x7d\xc9\xd3\x33\xc9\x28\xba\x2c\xd1\x2f\xdb\xe9\xb3\x5a\xdd\x36\x55\xe1\x88\x5a\x6d\x73\xf2\xb1\xb8\x3b\x3c\x37\x29\xab\xa0\xaa\xee\x5a\x6e\x13\x87\x11\xb1\x39\x39\x8e\xb3\xdb\xd1\xdc\xa4\xdb\xee\xb6\xdb\x3c\xa2\x2d\x44\xa4\x15\xab\x6e\xd2\x19\xe8\xeb\xa1\xc6\x43\xa6\x04\x33\xb4\x5c\xe6\xdd\x06\x5a\xcb\xa3\x90\x18\x0a\x5e\x56\xc0\x03\xd2\x51\xbf\x0a\x3e\x7f\xc2\x3c\x17\xd1\x1e\x0e\xed\x78\xe8\xe3\xe3\x47\x3e\x7b\xe8\xb1\x4f\xb3\xb4\x6f\xe5\xa6\x09\x0b\x17\x2d\x85\xb1\xd7\x4e\x96\xee\xdf\x1d\xd8\xf9\x62\x00\xdc\x47\xbe\x87\x70\xa8\xad\xcd\xf7\xfc\xbd\xae\xba\x49\x6d\x9b\xb7\x3d\x43\xcf\xa6\x88\x9c\x9d\x28\xfc\x09\x15\xa2\x19\x89\xb2\x5c\x3b\x9f\x8d\x22\xd1\xa8\x64\xf5\xfb\xac\x3e\xbe\x10\xf1\xa8\xa8\x47\x8e\xdd\x61\x9f\x93\x8c\x38\x1c\xbc\xdb\xad\xce\x49\xfa\xfd\x6e\x8b\x90\xcb\xe7\xce\x4e\x26\x0a\xa1\xb0\x2d\xb5\xeb\x19\x6f\x60\x44\x61\x21\x1f\x64\xd1\x3c\xf5\x86\x57\xb0\xa4\x33\x69\x32\xad\xb2\x7b\xd3\xd6\xb0\xe1\xf1\x00\x1a\x89\x44\x58\xd2\x10\x30\x7d\xb6\xa6\x01\x94\x4d\x18\x63\x9c\xc6\xc7\xc4\xc9\xab\xf3\x13\xa3\x7f\xbf\xb7\x63\xe4\x95\xa3\x5e\xd8\xf1\x8f\xbd\x8f\xbd\xd2\xfb\x87\xc0\x98\xa1\x75\xb5\x90\xa3\x7d\x35\x66\x32\x2c\x9c\x72\xb5\x07\xae\xde\xba\xf3\xbd\x81\x6b\xa6\x5e\xba\xe5\xb7\xb7\x3f\x58\x79\x7f\xc9\x05\xe7\xce\xba\xf1\xcb\x2d\x97\x5c\x75\x57\xff\x49\x13\xe9\x1e\x19\x80\xb6\xf0\x03\xf8\xad\xac\xbe\xc8\x98\x44\xaf\xac\x10\x87\x72\x3d\x0e\x17\x72\xf5\xe8\xe9\x95\x83\xe0\xe4\x82\x81\x40\xf4\x89\xa4\x1c\x20\x1f\x03\x01\x3b\x6f\xb1\x14\x3c\x91\xfc\xc0\x42\x58\x3a\xb3\xe5\xdc\x6f\x94\xe9\x79\xa0\xf4\x23\xf9\x5d\x66\xfa\x6e\xca\xf5\x32\x2b\xbe\x0a\x9a\xa9\x4f\x77\x73\x95\x6a\x51\x02\x7e\x9a\xbd\x2f\xe6\xe5\xd2\x0c\xfe\xc2\x2a\xbf\x92\xce\x1d\x5e\x36\x78\xe9\xfa\x5b\xae\x98\x37\xff\xf2\xe5\x1b\x6e\x1d\x3c\x70\xd9\x86\xa5\x93\xe7\x2f\xb8\x7c\xf9\xfa\xe5\x03\xbf\x5a\x30\xfe\xe2\x1b\x16\x8c\x1b\x77\x03\xde\x7a\xfd\x15\x4b\x1f\x5c\x3a\x68\xd0\xf2\x0d\xcb\x27\x5d\x3f\x77\xd2\xd2\x4d\xcb\x07\x0d\x58\xb1\x61\xc5\xa4\x05\xe3\x6e\x58\x78\xf1\xb8\x1b\x16\xe8\xb4\xc7\x6c\x16\x42\x7b\x0a\x9a\x9f\xc8\xf1\x79\xfd\x36\x1e\x59\xad\x1e\xa7\x4d\x72\x0b\xe0\x06\x6f\x40\x51\x6c\x5e\x4e\x0d\x5a\x1c\x92\xa3\x0d\x7c\xcf\x24\x79\x89\x93\xdd\x32\xf9\x98\x50\x92\x7e\xe4\xae\xd1\xd5\x7e\x4c\x6c\x04\xb7\x35\xe0\xe5\xac\x5e\xfd\x30\x97\x15\xda\xf1\x18\xa9\xc5\xe5\x19\x02\xcb\x3b\x20\x43\xa3\x2a\xd7\xa3\x98\xd8\x02\xb1\x3f\x34\x90\xb8\x8a\xfc\x30\x25\x0b\x6b\xe0\xd7\xb6\xc1\x18\x6d\x9b\x76\x5c\x6b\x81\x5a\x4c\xfe\xe1\xd7\xee\x06\x2a\x77\xbd\xe4\xf1\x53\x77\x3d\xb4\xf6\xe8\xd1\xb5\x0f\xdd\x85\xdf\x37\xcf\x81\xb1\x21\x3f\xb6\x31\x9f\xef\xa8\x44\x6f\x9a\xd7\xc8\x03\x58\x6d\x02\x12\x10\x3d\x2d\x4d\x57\x84\x8a\x99\xb1\x3b\x8b\x4c\x4e\x90\xb1\x8b\x4b\xd8\x1b\xe8\x9b\xb8\x6b\x82\x1f\x95\x2d\x27\x40\xc4\x9b\x39\x7b\xfb\xaf\x27\xef\xe1\x1c\xed\xbf\xb0\x71\x2b\x53\x11\x3e\x26\xac\x45\xe5\xe8\x4c\xb4\x3c\x51\x98\x93\x3d\x24\x30\x40\x1d\x50\x6c\xe7\xb9\x7c\xf5\x8c\xaa\xbe\x15\x15\x5e\xaf\xca\xf5\x2d\xce\x16\xab\x13\x55\x67\x0c\x09\x9c\x11\x40\xe1\x70\xbc\x0d\xe4\x44\x20\x89\x72\xf6\xe4\x60\x7b\x4e\x0e\x0a\xbb\xc3\xb1\x30\xe7\xe0\xc2\xc8\x42\x9f\x48\xc9\x26\x7e\x11\x7f\x9c\x27\x8c\x80\x6c\x1e\x7a\xa8\x42\x35\x13\x9a\x33\x5a\x32\xd1\xf4\x05\x30\x9f\x9f\xbe\xc7\x4d\x6f\xa9\xf9\x91\xee\xf5\x4e\x27\x00\x8d\xb0\xc2\x74\x17\x18\x65\x4f\xd2\x0e\x03\x1a\x8d\x45\x93\x68\xab\xd8\xdf\x50\xc1\xea\x7e\x10\xe8\x7e\xb8\xfa\x95\x23\x91\x63\xce\x99\x97\x34\x4d\xed\x37\xe9\x96\x47\xff\x7c\xf1\x75\xe3\x9f\x3e\xf9\xc3\xc1\x7f\x15\xfd\xe8\xbf\xe1\x86\x05\x37\x95\x5e\xf5\xec\xfb\x8f\x5f\x77\xd5\x25\x97\x1f\x81\x8f\xe6\x3d\xf1\x72\xbf\xc9\xb7\xbe\x2a\xac\xbd\x7d\x69\xe8\xcc\xb3\x07\x9d\xd5\x73\x40\x71\x76\xe1\x98\x05\xe3\xeb\x57\x47\x6a\x9e\xfc\xeb\x93\xab\xee\x29\xa8\x1d\x75\x56\x6d\xe9\xe0\x3e\xbd\xfb\x3e\xd8\x54\xbf\x28\xaf\xf0\xd6\xb1\xf7\x6c\x6e\x7f\x7d\xf8\xf9\x71\xf5\xe6\x9e\x55\xbd\xa2\x76\x7d\xed\xdc\xfc\x76\xbc\x4e\x58\xc9\xd6\x6e\x61\xe2\x62\x0b\x8f\x88\x42\x44\x96\x0e\x10\xdc\x5e\xc7\x4f\xcf\x3c\xe0\x3d\x46\x6c\x6b\x94\x28\x1e\x3c\x02\x25\xe2\x3d\xc9\x5f\xe1\xec\x11\xc8\xcd\xd2\x45\x5b\xcc\x15\x8d\x31\x91\xa0\xcb\x82\x46\x33\x33\xf5\xac\x2e\xce\x6f\x9a\x55\x58\x4c\x78\x65\x59\x17\x67\x00\x99\x38\xc2\x14\xe3\xe4\x07\x5e\xd9\xdf\x31\xe7\x1f\xfc\xf6\x03\xe4\x3f\x82\x55\x2c\x75\x5c\x78\x83\xf0\x37\x99\x70\xea\x01\x68\x66\x62\x58\xd0\x1a\xeb\x53\x54\xee\x46\xa8\xbc\x8f\x95\x1f\x38\xa8\xa2\xb0\x2a\xaf\x57\xde\x3b\xc9\xd2\xaa\x77\x92\x72\xaf\x68\x2f\x9c\x28\x05\xb9\x34\x5a\x8a\x53\xa5\x80\x4a\xdd\xa5\xd8\xc6\xf5\x2a\xed\x55\xca\x4b\x92\xff\xad\xa4\xc4\xf3\x59\x6f\x25\x79\xdf\x69\xb2\xc8\x66\xcc\x64\xe7\x65\xa7\xf3\xf5\x60\x3d\x0f\xac\xc2\x4b\x33\xe4\xbc\x96\xcc\x2c\xb1\xb2\x7c\x6f\x01\xe3\x10\x55\xaa\x91\x55\x96\xc1\x04\x85\x37\x5e\xd6\xb6\xbf\xfc\xba\xf6\xc4\xf3\xaf\x40\xed\xcb\xaf\xc0\xe8\x5d\x4d\x9b\xb5\xc3\x0f\xaf\xd7\xbe\x7f\xfc\x61\x08\x6d\xde\x0c\x59\x0f\xb7\xbf\x33\x77\xda\xd0\x2b\xb3\x36\x0d\xdc\xb6\xf0\xe5\x8f\xde\xdd\x79\xf3\xf6\xd2\x07\xc3\x97\x9d\x73\xed\x74\xfc\x2a\x6d\xfa\x36\x5c\xf0\xe2\xcb\x50\xfb\xca\xab\xda\x8e\x57\x68\x8b\x07\xb5\x6f\x1e\x7b\x58\x3b\x4c\x5b\xfe\x65\xf9\xdd\x23\xcf\x29\xb9\xb1\xe9\x8b\x77\x76\xef\x6d\x9a\xd3\x73\xc8\xb0\xdb\xc8\x5a\xf6\xc1\xfb\xf0\xaf\xc2\x2a\x32\x53\x3d\xd1\x55\x89\xaa\x1e\x0e\x49\xe2\xc4\xbc\x3c\xd5\xc7\xf9\x7a\x15\x8b\xf9\xdf\xd2\x13\x75\xb9\xda\x01\xb2\x63\xa3\x03\x87\x38\x47\x42\xf6\x8d\x70\x38\x64\xd9\x76\x38\x29\x7f\xa1\xc4\x50\xec\x70\x32\x3b\x8c\xda\x20\xa7\xeb\x61\xba\x91\x10\x49\xab\x2e\x14\x77\xba\xbd\xcd\x34\x75\xfa\xd2\x05\x55\xb4\xb6\x84\xa5\x88\x39\x8b\xb3\x81\xcc\x88\x51\xe0\x26\x4f\x2c\xa2\x47\x64\x16\x9a\x37\x07\x70\xd9\x2c\xc8\x5a\x3b\xe5\x4a\xfb\x4b\xde\xf5\x37\xad\xbc\xc7\x1b\xef\x7b\x56\xbf\xe1\xa3\x05\x6e\x44\xcd\x90\xf1\x97\x4e\x38\x13\xef\x9b\x7a\xd9\xfb\x02\xee\x35\x6f\xa2\xed\xf2\xa9\x0b\x66\xfc\x58\xda\x57\xb8\xd6\x7b\xde\x90\x15\xb7\x34\x9e\x15\xc1\x5c\x69\xd9\xc5\x8c\x5e\x2f\x45\xb7\xf3\x2a\xb7\x95\xf0\x50\x0f\xba\x28\xd1\x4b\x76\x88\x58\x72\x3a\x6d\x1e\xba\x61\x09\x13\xc5\x0e\xde\xeb\x73\xd8\x65\x59\x24\xaf\xce\xfd\x58\x67\x43\x22\xfa\xb1\x0e\x83\x78\x0c\x85\xaa\x75\xd6\x68\x56\xe0\x2a\xcf\xcc\x97\x4a\x2f\x77\x01\x54\x42\x79\x80\x83\x40\xdc\xfc\xc0\x15\xd1\xba\x37\x3f\x69\x80\x3a\x86\x6b\x1a\xe0\xa3\xe4\xd3\xed\x30\x75\x38\x4c\x2f\xd0\xee\xd2\xee\xcd\xcb\xf8\x48\xf3\x3d\x08\x7e\xe3\xb9\x10\xe1\x7c\x23\x12\x7d\x81\xa7\x91\x12\x74\xff\x34\xa3\xd5\x88\xaf\x21\x7f\x6d\x44\x07\xc9\x46\x22\xc6\x6f\x03\x9a\x4e\xbe\xdd\x8e\x52\x88\xa0\x8a\x30\x87\x9f\x48\x72\x3b\x18\x61\x32\x21\x35\x63\x66\x3a\xb8\xbe\x80\xc5\x86\x70\xf3\xda\x3f\xe7\xb9\xdb\x61\xeb\xa1\x8e\xd9\x44\x8f\x34\x6a\xb1\x10\x3d\x92\xde\x35\xcd\x77\xd9\x27\x7d\x50\x3f\x74\x73\x62\x54\xd0\x1a\xef\xdd\xbb\x67\x79\x5e\x5e\x7e\xac\x4f\x9f\x33\x7a\x12\xb8\x9e\xf9\x56\xbe\xaa\x7f\x2c\xbf\x77\x79\x6e\x79\xee\xdb\xc9\x82\xb2\xb7\x93\x28\xdf\x9d\x8f\xe5\x82\x68\x01\xce\xe1\x0a\x12\x6a\x78\x44\x7e\x79\x41\x41\x79\x3e\xf7\x47\x1b\x46\xa5\x1b\x86\x11\x84\xb1\x5f\x3c\x5d\x6c\x36\x33\x8e\xe8\xff\xb2\x73\x04\x2e\x8f\x16\xb2\xd1\x0b\x09\xf8\x38\xaa\xd9\x07\xc8\x56\xfa\x3f\x6c\x1b\xed\x9c\x1d\x73\x76\xc0\xc8\xfb\xef\x6b\xbc\x70\xdf\x81\x51\xe7\x2c\x5d\x33\xf4\xec\xff\xe7\x8e\xf9\x2f\x0c\xd0\xde\xe4\x4a\x16\xcf\x98\x38\x37\xa4\xb5\xe0\x41\x03\x06\xff\x3a\x1c\x41\xea\x98\xb0\x95\x5f\x28\xd2\x1c\x71\xf5\x69\x44\x63\x7b\x70\x1b\x64\x3d\x99\x04\x5a\xa4\x46\x8f\x86\xa1\x86\x1e\xbf\xf0\xe4\x2c\xfe\x76\x61\xeb\x44\x46\x83\x97\x70\x11\x7c\x40\xb8\x93\xc5\xa0\x17\x27\x02\x3e\xd1\x49\xa8\x2c\x14\xe6\x94\x6d\x49\xaa\x23\xba\xb7\x25\xed\xe9\x2c\xdc\xae\x61\xe6\x7a\x0a\x2a\xdb\x26\x96\x8c\xe2\x02\xf8\xc0\xf3\xcb\x96\xbc\x70\xf1\xda\x09\xcb\x9f\xdb\x50\x7f\xee\xf0\x86\xcb\x87\x9d\xdd\xc8\x8f\xbb\xf9\xd9\x67\x96\x8e\xbb\xeb\xa2\x67\x6f\x3e\xb7\xf1\xb2\x73\xce\x99\x74\x39\x1b\xbb\x2f\x59\xec\x0a\xfe\x57\x56\x6f\x6d\x68\x22\xcf\xe1\xe2\x9d\x2e\x1b\x80\x53\xc4\xd8\xe3\x96\x9c\x4f\x24\xcd\xc2\x41\x0d\xd4\x58\xdb\x25\x60\x81\x26\x56\x97\x67\x20\x63\xa8\x01\xa6\x03\xb6\xb3\x94\x10\xcd\x70\xc6\x0f\x1d\xd2\xa6\xc3\x9d\x87\xe0\x2e\x9a\xe8\x8c\x5f\xd5\x1e\x87\x8b\x0f\xc2\x58\x6d\xeb\xc1\x8e\x21\x07\x0f\x52\xbd\x19\x3f\x83\x9b\x85\xbb\x50\x08\x9d\x97\xe8\xa1\x22\x87\x64\xf1\x06\xbd\x64\xcc\x70\xc4\x82\x64\xd9\x11\x75\x94\x38\x38\x17\x97\xe6\x2a\x48\xfd\x26\x89\x3e\xcf\x2c\x4e\xa3\xd7\x6f\xe9\x5a\xc6\xa9\x28\x5d\x9f\xc6\xe0\x21\x44\x09\xa3\x09\xca\x81\x4a\x9c\x3d\xad\x6e\x7c\x62\xf4\xc5\xf6\x57\x9c\xf7\x2d\xbc\xe5\xee\xfb\xaf\xba\xc0\x0d\xd3\xf0\x33\xf3\x87\x4c\x1d\xd4\xff\xbc\xa2\xba\xcb\x85\x49\xf3\xa7\x4f\xba\xf1\xf2\xa1\x67\xc6\x57\xea\xba\x55\x6f\xbc\x15\xdf\x44\xf0\x2b\x40\x37\x24\xce\xb7\x88\xc1\x90\x2f\xea\x40\x28\x9a\x2b\x87\x44\xb1\xb0\x28\xd7\x25\xcb\x2e\x82\x97\x1c\x95\x4b\x64\xce\xf8\x65\xe3\x09\xb2\x59\xc1\x84\xec\x1d\x11\x0c\x66\x65\x29\x87\x93\x59\x5f\x70\x04\xfb\x45\x16\xa8\x65\x65\x69\x88\x42\xc3\x1d\xec\x5e\x87\xa6\xd8\xa3\x57\xff\x9a\x71\xfa\x0a\x34\xba\xbc\x27\x8b\x5b\x59\x91\x51\x7f\x26\xfd\x7a\xcc\x70\xc7\x37\xfd\x69\xe5\xf2\x0d\xce\x17\xed\x53\xae\x5c\xd5\xbf\xbc\x3a\x71\x46\xf1\x04\xfb\x73\x8e\xfb\x6f\x5c\xb4\xfa\xbc\x9a\x8b\x26\x70\xcd\x93\x9a\xa6\x4c\x91\xea\x1b\xeb\x6f\x2a\x29\x2e\xea\x9d\x94\x26\x5e\x77\xd5\xc5\x89\x3a\x37\xb6\x5d\x4a\xde\x73\x3c\xbf\x11\x5f\xcc\x62\xb2\x8a\x12\x61\x24\x5a\x04\x7c\x5b\x9d\x2c\x80\x2c\x94\x08\xd5\x42\x03\xcb\xb5\x3b\x26\x58\x84\x74\x38\x16\x3d\x45\xf6\x91\x35\x1e\xdf\x0e\x58\xdb\xca\x6f\x8c\x42\xac\x58\x3b\xaa\xcf\xd9\x32\x6d\x1c\x1f\x27\x36\x68\x16\x3d\x2b\xf6\x38\x9d\x2e\xac\xaa\x61\x57\x38\x3b\x27\x48\x66\x2b\x22\xfa\x6b\x93\x36\x4c\x63\x67\xa8\x9a\xa9\x9f\x38\x95\x77\x4f\xe3\x30\x7d\xf7\xc6\xf9\x58\x46\xe0\xb0\x5f\xe5\x02\x4e\x2e\x7e\x49\x4d\xc5\x68\x95\xe7\xe9\x19\xf2\xc5\x97\x24\x93\x10\xb2\x4e\xee\x3d\xee\xc2\xd2\x5e\xc5\x23\xb4\x5b\x84\xc3\x1d\x0f\xff\x69\xd9\x7d\x1b\xf1\xd0\xf6\xb6\x9b\x8d\xd8\xf8\xe1\xda\x6f\x7c\x09\xd1\x91\x65\x74\x56\x22\x2c\x88\x32\xb1\x8a\x45\x3b\xe7\xf6\x20\x8b\xdb\x42\x64\xba\xc5\xe2\x04\xc4\x3b\x89\x8d\xac\xb6\x26\x9d\x1c\x4d\xdf\x2f\xaf\x4e\x67\x80\x9b\x99\xfb\x19\xf5\xb2\xe8\x1f\x5d\x3e\xc7\x03\xdc\xd6\x07\x5f\x5d\xf7\xd8\x2b\xaf\x6f\xc3\x73\xf8\x7f\x9f\x10\x85\x13\x27\x44\xee\xa5\x67\xb7\x3c\xb6\x73\xb5\x3e\xf6\xed\xd8\x07\x4f\x70\xc3\x68\x75\xc8\x84\x93\x9d\x63\x23\x58\x97\x94\xf5\x2c\xfe\x74\xed\x2a\xaa\x9d\xde\x0e\x31\x02\x4b\xab\x57\xd1\x76\x8d\xda\x78\xf8\x99\x7c\x22\xa2\x2e\xf1\xa4\xc7\xeb\x75\xcb\x32\x59\x1f\x41\x09\x78\x9d\x4e\xce\x1d\xe0\xac\x77\x25\xb9\xc8\x6b\xcc\x77\xbc\x99\x3a\x87\x61\x89\x02\xb3\x15\x18\xab\xc0\x30\x05\xdc\x0a\x60\xa4\xc0\x71\x05\x0e\x29\xb0\x47\x81\x5d\x0a\xb4\x28\xb0\x46\x81\x45\x0a\x34\x2a\x50\xab\x40\x8c\x01\x75\x83\xd9\xc4\x60\x08\x40\x29\x7b\xd4\x3f\xfd\xac\x85\x3d\x6b\xca\x68\xa0\xf7\x48\xba\x8b\x9a\x5f\xee\x62\x8d\x4b\xd8\x3f\xad\x13\x33\xcd\xed\x3f\x34\xc3\xd9\xc3\xce\x8c\xe6\xb4\xf1\x9d\x51\xbc\x46\x3f\x6d\xa2\x3b\x80\x79\xef\x74\xc2\xaf\x2a\xa7\x99\xba\x3f\x3f\xb8\xb6\x4f\xff\xbc\xbe\x2b\xfa\x0f\x2d\x74\x9d\xb9\x3a\x3e\xb1\xee\xc8\xc4\x46\x71\xae\xe5\x9c\xbc\x5c\xbc\x75\x8c\x30\x86\xfa\xe9\x08\x7f\x99\x26\x2c\x43\x76\xc2\x5f\xe8\xa9\x81\x45\xe4\x11\x2b\xa8\x85\x78\x37\x8f\x1d\x1c\x9f\xe0\xda\x52\x87\x12\x2e\x87\x7b\x04\x27\x7e\x46\x0b\x6c\x1d\xd6\x19\x8c\x6e\xb7\x16\x87\xdf\x33\x2d\x3c\x56\x48\xd3\x08\x18\x29\xf7\x58\x2a\xab\xc8\xe7\xc0\x98\xb6\x27\x5a\xb7\x6f\x21\x0c\x04\xf6\x5e\xb3\x60\x4e\xc7\x63\x2c\x27\x86\xea\x4d\x6f\x13\xbd\xc9\x81\x54\xd4\x2b\xe1\xf3\xb2\xf3\xea\x60\xc8\x26\x7f\x93\xb4\x7d\xc1\x05\xbe\x49\x72\x4c\x27\x3a\x35\x6b\xa8\xb3\xbc\x61\x17\x6e\xfe\xf6\x53\x1b\xef\xdb\xd1\xb2\x61\xd3\xb6\xb7\x06\x9d\x77\xde\x59\x89\xb3\x47\x25\xf8\xbe\x0f\x3d\xd7\xb6\xf9\xa1\xb6\x1d\x8f\x4e\xbb\x6c\xd2\x94\x69\x57\x5e\xc1\x78\x79\x3d\xd1\x15\x82\x86\x2e\x33\x3a\xd1\xd3\x21\x63\xd1\xe5\x74\x7a\x6c\x02\xd1\x65\x90\x4d\x94\x79\x1f\x21\x21\x87\x03\x7b\xac\xd8\xfa\x63\x9d\x8b\xf0\xf2\x1f\xeb\x2c\x22\xfe\x63\x55\xa6\x8b\x26\x53\x55\x09\x5c\x65\x39\x04\xa0\xdc\xfc\x50\x0f\x48\xfb\x09\x88\xc6\x71\x80\x7c\x38\x4a\xf8\x80\x76\x3b\xd1\x5e\xe0\xba\x02\xed\xce\xe1\x4c\x91\x31\x3f\x12\xfd\x82\x48\x3a\x71\x94\xb0\xcc\x5d\x88\x6e\x90\x90\xbb\xc8\xd2\x81\xf7\x20\xe4\xb1\x58\x05\x6e\x47\xc7\x28\xa4\x90\x7d\x81\x3d\x41\x60\xc7\x54\x4d\x12\x57\xef\xa9\x44\xd5\x95\x95\xb4\x5d\x2a\x25\x9e\xdf\xa5\xdd\x0b\xb4\x1d\x9a\xcd\xbd\xd7\x71\x1e\xb2\xec\xc0\x72\x90\x40\x92\xd7\x27\xb0\x57\xb1\x31\xee\x32\x7b\x77\x17\xe9\xbd\x7b\x44\x34\x67\x10\xa2\x63\x00\x16\x83\x88\x98\xc4\x09\x68\x02\x73\x0c\x32\x6f\x33\xb5\xcd\xfc\x62\xc2\xaf\x68\x5d\x8c\xd1\x89\xb8\x0b\x59\x23\x11\x4b\x4e\x8e\x1f\xf9\x03\x28\x10\x8d\xd1\xc2\x18\xd9\xc1\x9c\xec\xf5\x75\x39\x32\x2b\x8c\xf1\x3c\x04\x50\x12\x05\x21\x72\xda\xd2\x18\x03\x06\x98\x31\x1c\xc6\xbc\xd1\xe0\x50\x22\x90\xe2\x2e\x5d\x6f\x65\xea\xbd\xc0\x8a\x41\x50\x63\x74\xe6\xf8\x79\x17\x9c\x7d\x36\x07\x0e\x71\xca\x24\xa3\x3a\x06\x64\x47\xb4\xef\x0f\xfd\xa8\xfd\x0b\xff\x4d\x3b\xd8\xdf\x2c\x8e\xf1\xe7\x61\xa3\x9a\xce\x35\x8b\x63\xf0\x3b\xb5\x7f\x83\x8b\xbc\x33\xab\xd1\x60\x51\xbd\x85\x28\x9f\xcd\x67\x07\x8c\x23\x93\x11\x7c\x06\xbb\xdd\x42\x21\xf6\xb4\xa5\xde\x69\xf5\xf8\x79\x4b\x41\x31\x79\x5b\xfa\x83\x4e\xd3\x46\x83\x6f\x29\x97\x49\x48\x98\xb6\x71\x5f\xe2\xf6\x99\x0d\x32\xe1\x8b\xd3\xf0\x29\xb8\x1d\xb1\xf9\xc4\x1e\x0f\x69\xa0\x20\xc5\xdd\x39\x42\x1a\x3e\x6a\xc2\xdb\x70\x1a\x9e\x21\x15\x42\xa1\xc2\x53\xe1\xc5\x7d\x69\x78\x00\xca\x38\xc3\x09\x99\x63\x0d\x38\xec\x07\xa2\xe2\xb1\x16\xac\x49\xe7\x18\x2e\xb3\x0d\x7e\x10\x5e\x42\x0f\xa1\xfe\x89\x9e\x1c\xae\x51\xa6\x2b\xf4\x20\x8d\xdf\xa4\xec\x52\x88\x22\xac\xd8\x14\x28\x50\xce\x51\x30\x61\x8c\xe5\xca\x24\x05\x83\x8e\x2f\x65\x43\xb4\xc7\xfa\xfa\xca\x4a\xb6\x7f\xc8\x2e\xb1\xb4\x30\x19\xe1\x47\xf7\x24\x2e\xc5\x3e\x8e\x98\x01\x1e\x9b\xd3\xe9\x17\x1c\x16\xe4\x72\x21\x9e\x0b\x28\x56\x0f\xcd\xf6\xf2\xe1\x86\xa4\x4d\x6a\x48\xca\xb6\x66\xdb\x46\x1b\x27\xdb\x56\xdb\x52\xe4\x17\x67\x53\x02\xe7\xd9\x14\xe9\x3c\xd9\x06\x7e\xc1\x67\xf3\xd9\x90\xc0\x21\x67\x43\x92\x43\xde\xd5\x84\x21\x4f\x57\xa0\x81\x1d\xed\xb1\xe3\x0f\x62\x16\xe9\xdc\x6e\x40\x89\x1e\x5f\xc9\xc4\x7f\x71\xa7\xa7\x85\x3c\x29\xa3\x27\x77\x86\x3f\x80\x65\x35\xd3\xd3\xb4\x74\x6a\x3a\xe4\x89\x5c\x9c\x7b\x58\x3b\x73\xab\xf6\x01\x7e\x81\x7f\xb3\xe3\x6c\xdc\xdc\xb1\x18\x7f\x7b\xf2\x3f\x43\xfa\xfe\x04\x97\xea\x45\x18\xbe\xd6\xd6\x7f\xae\x2d\xfd\x9a\x7f\x74\xba\xe6\x64\xeb\x39\x56\x1b\x4f\x6b\x11\x90\xb9\x2b\x64\x7b\x69\x01\xd0\x82\xe2\xd2\xdf\x20\x27\x9e\x13\xb2\x71\x05\x26\x9d\xb0\x1c\x7c\x46\x27\x3d\x0c\xda\xaa\x64\xb4\x05\x92\x24\x14\x82\xb3\x2d\xf5\x6a\xab\xd3\x8d\xec\x5d\x68\xab\x7b\x1b\x0d\xb6\xe9\xb4\x05\xb4\x8d\x34\x58\x92\xcd\x06\x99\xf0\xc5\x69\xf8\x14\xcc\xd2\x69\x05\x9c\x4e\xd2\xc0\x0b\x44\x19\xb4\x67\xd0\x0a\x83\x67\xb4\xd2\xc3\xa0\x95\x59\x3a\xad\x60\x86\x15\x06\x37\x72\xbb\xf4\x16\x26\xad\xa4\x3e\x21\xc2\x74\x1f\xc3\xa9\x37\x69\x23\x5a\x3b\x16\xb3\xb7\xe0\x79\x32\x80\xd0\x96\x7a\xae\x55\xb0\x22\x9c\x31\x06\x0d\x3c\xbc\x32\x03\x5e\xf3\xe8\x6f\x40\xe1\xf9\x91\xbc\xc5\x04\xa6\x7d\x3f\x4e\x60\x6f\x63\xf8\xeb\xb0\xa9\x37\x58\xdf\x82\x40\x60\xed\x6d\xa9\x54\x2b\x51\xdd\x33\xfa\x4e\x7d\x4c\xe0\x2f\x67\xf8\x33\x78\x1b\xbc\x65\x60\x4f\xb1\xc1\x60\x45\x56\x51\x87\xd7\xb1\x67\x74\x69\x35\x6a\x31\x38\x09\x87\x6a\x4c\x54\xba\x02\xc8\xa7\xaa\x36\xa2\x8c\x09\x59\x11\xc5\x62\xb5\x10\x72\x5c\x69\x7d\xc0\x8a\x07\x5b\x81\x93\xad\x64\xa2\xad\x56\xc1\x6e\xf7\x36\x24\xed\x9c\xa0\xb2\x4a\x0d\x59\xd0\xb5\x18\x86\x1e\x8b\xd2\x25\xf0\x8c\x19\x5a\x65\xe9\xba\x0d\x79\x44\xc6\xa5\x6b\x37\x50\x62\xcb\xa8\xdf\xb0\x78\xb1\x59\xc1\xe1\x9f\x9f\x7f\x08\x93\xb5\x07\x4f\xec\x3c\xa8\x57\x71\xc0\x63\x0e\xe0\xb1\xb4\x90\xc3\x97\x3f\x69\x6b\x0f\x68\xf7\x00\x67\xae\xf1\x10\xc6\x0f\xfa\x1a\xfc\xe0\x0e\x63\x8d\x5d\x2e\x32\x4d\x2a\x52\xf3\x05\x29\x63\xfe\x59\x4e\x2e\x9b\xff\x32\x83\xee\xde\x35\xf8\x47\x28\x44\x26\x29\x2c\x86\xb3\x2d\xe8\x7f\xc0\x6b\x38\x6c\xf0\x33\x0a\x1e\x1a\x1b\xca\x32\xc1\x75\x9a\xd3\xe1\x8b\xd3\xf0\x29\x78\x5d\xe7\x99\xe1\x30\x81\x8f\xd2\x55\x8b\x86\x3a\x47\xc8\x68\x13\x35\xdb\x90\x77\x78\x49\x6f\xc3\x50\xca\x6d\x4b\xfd\xd6\x9a\x5b\x72\xba\x36\x6c\xad\xcb\x0c\x5a\x25\xc4\x81\xb2\x13\x36\x8e\xb5\xe2\x70\x36\x1d\x2a\x3b\xa2\x37\x33\x17\x9c\xd6\x80\x7a\x94\x1f\xc7\x6f\x21\xfa\xc3\xf0\x44\x0f\xde\x2e\x5a\x31\x42\x76\x2b\xe7\x94\x2c\x6e\x30\x8b\x4c\xad\x81\x5d\x60\x41\xe4\x9f\xb4\xda\xd4\x71\x10\xa0\x2d\xb5\x8b\xec\xc6\x11\xb0\x83\x48\xf3\xe2\xfa\x19\xe5\x5d\x2d\x22\x1b\x54\xd9\x40\xb5\x01\x41\x62\x1c\x59\xb1\x4d\x1b\x48\x27\x8d\x1b\xb4\x4d\xec\x2f\xed\x41\x38\x17\xae\x84\xc6\x07\xb5\x87\xe8\xbf\x37\x68\x0f\x6d\x82\xcb\xb5\x07\x58\xbd\x96\xb1\xa9\xbf\x09\x87\x85\x97\x89\xb2\x9e\x4d\x6c\xa0\xfa\x44\x45\x30\x1e\x8a\xf1\x39\x4a\x0e\x52\x1c\x56\x3f\xf0\x9c\xdd\xc5\xb9\x0a\x8b\x42\xb1\x60\x9c\xcf\x8b\x78\x23\x0d\x49\xab\x03\xfc\xbc\x57\x0c\x04\xbc\x3e\x31\x8f\x70\x49\x1b\xd1\xb8\xe8\x01\x80\x1e\x48\xc4\x8a\x1b\x53\xb3\xdf\x3c\x04\x50\x07\x94\x13\x16\xc7\xea\xb3\xab\x55\x85\xac\x80\x89\x4a\x94\x3b\xc5\x1b\x60\xe6\x7e\x91\x05\x2a\x8a\x80\xc8\x4c\x6f\x81\x5f\x05\xa2\x14\xe1\xb5\x0f\xec\xa7\x79\xbd\x6f\x3c\x38\xe6\xe5\x3b\x9a\x66\x6e\xd3\x5e\xfc\x74\xef\xdd\x75\xdc\x65\xe3\x3a\xbe\xae\x5b\xf0\xe6\xc7\xed\x6f\x8c\xc5\x91\x4b\xe7\xbc\xf1\xc9\x79\x9f\xbe\x0e\x33\x68\x6e\xef\xc8\x39\xbb\x27\x6a\x5f\xb7\xd2\xe4\xea\x0b\x16\x73\xf2\xee\x85\xed\xed\x55\x20\x1c\x7b\xaf\x99\x43\xe5\x5a\x8a\xae\x13\xcb\x77\x64\xf4\xd3\xdf\xa0\xb7\xf3\x74\x3e\xe7\xf5\x12\xf2\xf4\xb5\xa5\x5e\x68\xf5\x29\x9c\xab\xcb\xda\x76\x6f\xa3\xc1\xef\x06\x9f\xa3\x6d\xbc\xd7\x78\x03\x66\x83\x4c\xf8\xe2\x34\x7c\x0a\x56\xe9\x63\xf8\x7c\x04\x3e\xd8\x96\xd2\x5a\x83\xde\xd3\x8d\xc1\xe8\xa7\xbf\x41\x3f\x77\x98\xbc\x8e\x62\x46\xe4\x18\x52\xfc\x7a\x9b\xb4\x5c\x64\xf9\x6a\x0c\xaf\xc1\x06\x5e\x4f\x1b\x78\xd9\xc8\x38\xb6\x06\x9b\xc4\x5b\xd3\x78\x65\xe4\x94\x3b\x91\x42\xec\xff\x42\x9f\x5d\x14\x2d\x2e\x64\x41\x6a\xd0\x27\x10\x06\x42\x98\x48\x83\x6f\x3a\x91\x76\xf6\xe9\x76\xec\xb3\x93\xc7\x34\xbf\xdc\x3c\xa9\xd2\x7d\x36\x5d\x32\x47\xd2\xd9\xe4\x01\x96\x4f\x6e\x54\xd2\x11\xdc\xf3\x7f\xd8\x44\x13\xca\xa1\x08\xc6\x68\xe0\xd6\x3e\xbe\xe5\x16\x9a\x52\x3e\x7f\x29\xfe\x72\xd9\xfb\x33\xb5\x6f\x84\xc5\x3f\x7c\xfd\xc9\x75\x0b\xb5\x82\x66\x1a\xf7\x9b\x3a\xca\xd3\x98\xeb\xbe\x68\x54\xa2\x97\x84\xd4\xc2\x3e\x9e\x9c\x68\x54\xf0\x14\x22\xa1\xbc\x4c\xea\xa3\x72\x79\x5c\x5e\xb8\x36\x99\x87\xa2\x1c\x67\xa3\xd1\x9f\x1b\xcb\xa1\xb6\xdc\x2c\x72\xe2\x7e\xad\x3a\x4d\x61\xa7\xd8\xd0\x45\x95\xe9\x18\x3b\xaa\x69\xa7\xeb\x95\xb1\x20\xcc\x7c\xa3\x90\x2d\x0d\xb7\x53\xf8\xc7\xde\x7e\xee\xae\xd9\x65\xcb\x4b\x46\x8f\x3c\xbf\xfe\xb1\xaa\x01\x43\xca\xea\x27\x5c\x75\x8d\xf6\x1d\x4a\x1d\x7f\xff\xa7\x78\xd9\xa0\xb2\x78\xcf\xe6\x47\xa1\xff\x43\x5b\x8a\xdf\x57\xf3\xcf\x19\x50\x91\x1c\x72\xed\xfd\xfd\x26\x96\xf5\x1b\xdd\xe7\xac\x0b\x9b\x6f\x6f\x77\x70\xc7\xfe\xf9\x9f\xd6\x75\xfd\x2e\x1e\xd6\xaf\x4f\x4f\x7f\xa8\xcf\xc4\x1b\x75\x1d\xb5\x82\xbc\xdb\xf5\xc2\x17\x64\x7d\x86\xfd\x46\x65\xef\xd9\x68\x9b\xce\x47\x2a\x2a\x3c\x85\xb8\xb2\x2d\x75\x7f\x6b\x65\x7f\x2e\xd2\x85\x0e\xba\xb7\x99\x0b\x31\x83\xbf\xd1\x36\x15\xb1\x8a\x2a\xb3\x41\x26\xfc\xef\x26\x3c\xbe\x15\xbd\xa9\x8f\x51\x59\x49\xe0\x07\xb6\xa5\xbe\x6a\x1d\x58\x71\xda\x31\x5e\x4b\xb7\xd9\x80\x5a\x32\xf0\x1a\xd2\x96\xfa\x7b\xeb\x90\x91\xa7\x6d\xb3\x32\x8d\xd7\x34\xf4\xb1\xc9\xdf\x68\x2b\x0e\xf7\x6f\x4b\x7d\xdc\xda\xbf\x9f\xde\xcc\xe0\x6f\x66\x3b\xf1\x9e\xf4\x58\x0f\x82\x1d\xf5\xd4\xdb\x55\x55\xd1\x76\x04\xc5\xfd\x69\x14\x4d\xbe\xc8\xa1\xa1\xa9\xa3\xe2\x5b\x46\x8e\xd7\x40\xb4\x29\x31\x31\xbf\xa0\xa0\x7f\x0e\x0e\xf6\xae\x8a\x46\x1d\xbd\xbd\x3e\x5f\x5f\x8b\xa5\x77\x0e\x37\x78\x90\xbd\xcf\x98\x64\x55\x94\xfc\xb0\xdc\x97\x2a\x70\x09\x55\xf6\x2a\xbb\xc2\x57\xc8\x8a\x3c\x3a\x19\x56\x64\x6f\xd4\x3b\xdd\xdb\xec\xe5\xed\x9c\xd7\xab\xb8\x73\x8b\xf8\xa2\x9a\x64\x73\x3e\xb8\xf3\x21\x3f\x1f\xf1\x4a\xc3\x60\x88\x0d\x66\xf4\x94\xbe\x63\xc1\x88\xe0\x34\xcf\xc1\x4c\x3f\x7f\x67\xa1\xfa\xf2\xf4\x59\x66\xda\x64\x8d\x15\x89\xf1\xd3\x24\x87\xd1\xa3\xc1\x8c\x94\x99\x82\x32\x7a\xe2\xa9\xe7\x87\x19\xe9\x33\xfc\x37\xda\x3b\x0b\x97\x6a\xdf\xff\xf9\xa9\x2f\x3e\x3d\x5e\x3b\xe1\xe2\xf3\x6d\xda\x81\xf0\x8f\x7b\xf6\xcf\xbe\x79\x0f\xcd\xa8\x99\x7b\x35\xcb\xa8\x39\xf9\xf8\x39\xb3\xcf\xba\x6f\xca\xb8\x3e\xa3\xb8\x72\x33\xb7\xe6\x9b\x6f\xb6\x3e\xf0\xc8\x76\x81\xaf\xba\xe6\x8a\x91\x35\xae\xf5\x9b\xaf\xbe\x9a\x66\xd9\xf8\xee\x7a\x88\x66\xd9\xbc\x76\xe1\xcd\x23\xfa\x18\x29\x63\xf8\x47\x3d\xe3\x86\xae\x47\xad\x36\x9e\xe6\x62\x91\xf5\x38\xd7\xd0\x07\xf3\x0c\x7d\xd0\x96\x13\xe2\x02\x69\x7d\x90\xe5\x1a\x31\x3a\x1c\x81\x74\xda\xfd\xdc\x94\x9b\x84\x46\x22\x6d\xa9\x83\xad\x91\x1c\xce\xd6\x85\x46\xba\xb7\x99\x0b\xa3\x0c\xda\xa5\x6d\xc2\x97\x87\xb3\xcd\x06\x99\xf0\xbf\x9b\xf0\x84\x76\x0f\x1a\xb2\x3f\x12\x21\x0d\x62\x9e\x58\xb8\x73\x84\x34\xfc\xca\x74\xff\xd3\xd0\xcf\xa6\xed\x40\xb1\xe2\x70\x8e\x23\x27\x4b\x6f\x91\xd6\x07\x77\x11\x21\xfb\x22\xc3\xe9\x3f\xfa\x7b\xa4\x6e\x42\x86\x46\xe8\x61\x1a\xe1\x9f\xbb\x68\x84\x0c\xaf\x99\x84\x59\x36\xa5\xdb\x88\x68\x6e\xc4\xd0\x09\x49\x0b\xfe\xa2\xae\x3a\xe1\x13\x04\xf6\x0e\xf6\x0e\x0c\x16\xdf\xfa\x84\xae\xed\x08\x84\x85\x11\x52\xcf\xd4\x08\x69\xdf\x54\x3f\xc5\x93\xd8\x3b\xe8\x7d\x4f\xeb\xd4\x09\x3d\x7f\xa4\x13\xd6\xa6\x7e\xe2\xd7\x0a\x07\x89\x46\x58\x80\x26\x26\x2a\xbc\x01\xc5\xe7\x0e\x22\x57\x38\x64\xb7\x45\xb8\x98\x8d\xb3\x15\x15\x06\x7d\xc8\xcd\x7b\xc2\xa1\x50\xc0\xeb\x71\x49\x39\x52\x4e\x4d\xd2\x23\x79\x24\x31\x80\xc4\xbc\x9a\xa4\xa8\x98\xbe\x16\x16\x72\xa0\x7b\xde\x89\x2d\x6b\xdc\x3b\x60\xa4\xf0\xb2\x02\xf4\xc8\x13\x60\x41\xf4\x95\x15\x54\x38\x17\x16\x09\x95\x55\x85\x45\x71\x45\x2d\x08\x70\x66\x40\x7d\x59\x3f\x6e\x02\x0c\xd2\x0e\x6a\x1d\x27\xb5\xcf\x20\x0e\x78\xea\xc0\xc4\x38\xed\xb3\x47\x26\x6c\x81\x82\xc6\x04\x48\x93\x69\x74\xfd\xc2\x79\x37\x2e\xe3\xff\xad\xed\xd2\xae\xe6\xb5\x93\xda\xa7\x60\xff\xee\x7b\x10\x63\xb7\x4e\x5a\xd0\x76\xee\xf0\xa9\xa5\x67\xcc\x78\xa1\xfd\xb9\x4d\xab\xb5\x0f\xef\x5e\xbf\x46\xa7\x4b\x96\x97\xc0\x78\xd2\x68\x46\x0b\x1b\xc0\x6e\xe8\x8d\xa1\x10\x99\xc9\x5c\x29\xb7\x44\x52\xbb\xd1\xc2\x5a\xb6\x46\x63\xf4\x75\xa5\xa5\xc4\x28\x7d\x2a\x0a\x99\x47\xb5\x2d\xb5\xaf\x55\x0d\x8b\xe8\x14\xfa\xcc\x6c\x33\x17\x16\x18\xf4\x49\xdb\x28\x13\x95\x90\x88\xba\xd3\xe7\x5a\xb6\xb6\x63\x74\xfa\xa4\xc9\xbb\x74\x0c\x55\x25\xf0\x59\x54\xa1\xcb\x52\x4e\x3b\xc6\x6b\xe9\x36\x1b\xd0\x6f\x19\x78\xe9\xfa\x66\xef\xd3\xb6\x59\x99\xc6\x6b\x1a\x64\x99\x74\x4d\x5b\x11\xea\x46\xe1\xa0\x98\xa9\x38\x72\x44\x5e\x6e\xe1\x2b\x88\xde\x48\xcf\x5e\x1d\x68\x64\xa2\x48\xb4\x63\x2c\x10\xb5\x41\x72\x5a\x6d\x4f\x24\x91\x15\x5c\x1c\x31\x0d\x68\xc1\x52\x04\xe0\xe3\x08\x41\xf2\x4f\x24\x85\x8c\x53\xa2\xb4\x4b\x3d\xd3\xb3\xaf\x9f\xa5\x02\xab\x59\x4a\x7e\x3f\xf7\x53\xc7\x0a\x9e\xeb\x58\xf6\x13\xf7\xf2\x0f\x3f\x68\xd7\x1f\x3a\xa4\xcd\xf8\xe1\x07\xa6\x2b\x42\xea\x6d\xfe\x53\xfe\x5a\xe4\x23\x54\x19\x47\x17\x26\x8a\xb3\xd5\x1c\x85\xf7\x47\xfc\x96\x88\x57\x16\xac\xbc\xdd\x43\xaf\x0e\xc8\xcb\x51\xb2\x55\x3e\x14\x73\x86\x6a\x92\x6e\xa7\xdb\xc8\x95\x40\x66\x76\xdc\x1f\x29\x87\x2c\x8f\xa3\xc8\x92\x57\x55\x58\x99\xd6\x11\x05\xa6\x12\xc6\x74\x0d\xd1\xc8\xe9\xd8\xb5\x64\xc6\xdf\x5e\x9f\x4b\xd3\x3a\xde\xbc\xe5\x8a\xb6\xb6\x19\xed\x87\x3d\x70\xef\xe0\x6b\x52\x08\x7e\x75\x6b\x53\xcf\xbc\xd2\x4c\xf0\x48\x2e\xfc\xf8\xae\xa3\x34\xc3\xe3\xa2\x99\xef\xdf\xf1\x9f\x4b\x87\xc3\x7b\xe7\x68\x77\x4e\x1c\xa6\x55\x8c\x60\xf3\xcf\x62\xd4\x19\x5d\x4c\x30\x78\xdd\x7e\x9d\x47\xd0\x75\xa6\xfa\xda\xd6\xd6\x60\x24\xe0\xe8\xb2\x66\xdd\xdb\xcc\x85\xeb\x0d\xdd\x8b\xb6\x51\x1b\xd5\xb0\xd9\x20\x13\xfe\x77\x13\x9e\xf0\xba\x76\x7d\x8c\x60\x90\xc0\xeb\xc6\x81\x7a\xda\x31\x56\xa6\xc7\x98\x06\x61\x53\x27\x64\x14\x08\x11\x1c\x09\xe9\x6d\xd2\x3a\x21\x8b\x5d\x65\x78\x5d\x6a\xe0\x75\xae\x81\x17\xa1\x24\x50\x1a\x95\x90\xdd\x9b\xa9\x13\xae\xa6\x39\x2e\x44\xff\xf2\xa3\x28\x4a\x24\x72\x23\x44\x47\xf5\x07\x6c\x7e\x5b\x2c\xee\x8b\x50\x2e\x22\x4b\x8a\x18\xa4\xf9\xaf\x89\xca\x41\x23\x44\x7a\x5e\x58\x5d\x5d\xfc\x47\x19\xb0\x3e\x33\x7b\x38\x90\x91\xf0\x92\x91\x49\xbc\x5a\xcf\x1e\xde\xf9\x7e\x3a\xd9\x05\x1f\x98\xde\x34\x63\xee\xbc\xeb\xbe\x14\xde\xd5\xca\x1e\x7d\x53\xfb\xae\x5d\x4b\x69\xdf\xe8\xa9\x2e\xdc\x93\x5b\x1f\xf9\xdb\xc3\x0f\x3f\xc9\xe6\x42\x7f\xaf\x95\xe9\xf7\x9a\x86\xfe\x65\xce\x05\xdb\x59\x10\xb6\x87\x83\xfa\xab\x75\xf5\x1b\x89\x8f\xa5\xfd\x46\xab\xe0\x36\xb8\x90\xc9\x17\xa6\x52\xbb\x91\xdb\xd3\xc5\x37\xc5\xf2\xca\x85\x3a\xaa\xab\xe8\xf0\x94\x47\xd3\xbd\xdb\xaf\x1f\xd5\xbd\xda\x52\x47\x5a\x2b\x2a\xbb\xe9\x45\xba\x6f\xca\x9d\xf6\x67\xf1\xb0\x2c\xd3\xff\xe5\x03\x5f\xe4\x34\x63\x7c\x95\x1e\xe3\x01\x88\x64\xe8\x5e\x55\x6d\xa9\x6f\x5b\xab\xaa\xbb\x8f\xa1\x5d\x4e\x6b\xb3\xa6\xdf\x63\x3d\xf7\x34\x3d\xc3\x7b\x92\xb2\xb9\xbf\xb6\xaa\xaa\x45\x1f\x80\xc1\x0e\x26\xf3\xb4\x88\xc9\x77\xbd\xff\xf5\xf8\x32\xf2\xc0\xd7\x8a\x07\xc9\x83\x88\xdd\x38\xb9\x75\xd0\xa0\x08\xe9\xbd\xde\x84\x67\xb5\x2a\x99\x0d\x51\x68\xd8\xd3\x95\x06\xbd\x10\xab\x15\x42\xf7\x87\xb2\x0c\x27\x51\x06\x4f\xac\x62\xf4\x75\xae\x41\x5f\x57\x99\xf0\x84\xbe\x42\xf3\x43\x59\x86\x12\x91\x61\x7f\xaf\x66\xb6\x50\xa1\x61\x0b\x19\xf6\x3d\x50\x03\x1c\xa2\xa5\x51\xd3\x0b\xd5\xc9\xd7\xab\xd8\x3e\x39\xd7\xd8\x27\xdf\xa6\xe1\xc9\x00\x51\x5f\xd4\xd4\x52\x3a\xfd\x01\xab\xc5\x4f\xcd\xfe\xf1\x3a\x78\x09\x5c\x9d\xf8\xc7\x43\x91\xd3\xe1\xff\x6e\xba\xff\x75\xac\xde\x16\xd1\x7f\x42\x81\x50\x24\x43\xff\xe9\x86\xb7\x0d\x41\x5b\x5a\x1e\x91\x8e\x23\x59\x91\xf8\xff\xc4\x7b\x05\xfa\x47\xa6\xfc\x8a\x70\x91\x78\x17\xbc\x59\xcd\x4d\xd6\x7f\x91\xd1\xff\x95\x3a\x1d\x50\x1b\x11\x07\xda\x52\x3b\x5b\x03\x11\xe1\x54\x1f\xc3\xcb\xc2\xbb\xee\x42\x7a\xbb\x07\x99\xcb\x93\x7c\x1d\x1a\x85\x7c\x09\x07\xee\x85\x70\xcf\xeb\x7b\xf6\xf4\xf9\x18\xbc\xe9\x23\x37\x7c\x49\x6e\x11\xdd\x95\xce\x75\xdf\x4f\xf6\x7a\x0e\xd1\xc0\x67\x27\x8a\x0a\x72\x7c\x11\x27\x8a\x46\x79\xce\xe2\xb3\xf4\x2a\x16\xb3\x73\xb2\xc7\x24\xb9\x1c\x25\x77\x74\x32\x44\xfd\xbc\x4a\x4c\xe1\x6c\x9c\xd2\x96\xda\x95\x50\x5d\x9e\x11\x39\x4a\x8e\x02\x45\x6e\xa2\x3d\x3b\xdd\x8a\x3d\x40\x4c\xb7\x62\x48\xa7\x66\xe9\xc1\x30\xc5\x69\xad\xb9\x9b\xb7\xa9\xdc\xf0\x37\x11\xb9\xc2\xf2\x87\x54\x3d\x57\x3e\x9e\x91\x2b\x5f\x19\xaf\xcc\xcc\x94\x1f\x04\xe1\x25\x4b\xac\xda\x71\x96\x30\x8f\x5e\xf8\xe0\x93\xb7\x58\xc6\xbc\xf6\x15\xe4\xce\x9e\x35\xe3\xba\xcf\x67\x5c\x2f\x9c\xb5\x6a\xd5\x96\xf6\x8b\x27\xdf\xca\x32\xe7\x23\x40\x54\x28\x08\x35\x36\xec\xb8\x69\x4b\xfb\x9e\xbf\xee\xd8\xf2\x8c\xf6\xd0\xf3\x69\x1f\xe2\x63\xa6\x0f\x91\xf0\x80\x89\x84\x07\x10\xbe\xcb\xdc\x51\x52\x5b\xea\xc7\x56\xc9\xd9\xcd\xaf\xa9\xeb\x99\x75\x69\xbd\x74\x15\xfa\xc5\xd8\xd3\x59\x59\x54\x91\x95\xc2\x91\x2e\x7a\xa9\xee\xd7\x74\xa7\xfd\x94\x3c\x5c\x96\xe1\x3b\x95\xdb\x52\xff\x6d\x95\xd5\xd3\x8e\xf1\x55\x7a\x8c\x07\xc0\x9d\xa1\x5f\x13\x79\x70\xb2\x35\xbb\xa0\x9b\x7e\xad\xbf\xcb\xa7\xe9\x77\x59\x07\xd7\x12\x5a\x57\x9e\xd6\xdd\xad\x6d\xa9\x13\xad\x92\x2b\xed\x71\x4d\x8f\xf1\x6e\x7a\x8c\x75\x8c\x67\xd2\xf7\x60\x83\x84\x2d\xe1\xac\xae\xef\xa1\x8d\xa7\x75\x58\xd3\xfd\xaf\xc7\x3f\x32\xde\x01\x3e\xd9\x47\x78\xc7\xb4\x56\x9f\xcf\x6e\xcf\xe0\x1d\xb5\xda\x14\x5a\x8f\x20\xdd\xff\x7a\xf8\x00\x79\x28\x5f\x8a\xb7\xa5\xce\x6a\x8d\xc7\x3d\x9e\x4e\xbe\xd4\xcd\xf7\x4b\xe8\x7d\x7a\xc6\x1c\xb9\xda\x52\x1d\xad\x2e\xff\x69\xe7\xa8\xd3\x3e\x58\x81\x3e\xc9\xc4\x3f\xcb\x9e\x95\xdb\x05\x7f\x56\x2f\x95\x8d\xd1\xcb\xe0\x35\x6f\x1a\x7b\x30\x27\x87\x0c\x92\x17\xc8\xcb\x76\x65\xf2\x62\x96\xf7\xcf\xfa\x1f\x69\xf0\x9a\x1f\x8c\xfe\xfb\xf4\x21\xfd\x97\xe1\xb2\xde\xde\xac\x53\xfa\x77\x9b\xfd\x93\x75\x7e\xcf\xe8\x3f\x3b\x9b\xf4\x1f\xcb\x8b\xf5\x38\x4d\xff\x5f\xa5\xfb\x7f\x00\xfa\x19\xfd\xf7\xee\x4d\xfa\x2f\xb1\x96\x54\x9d\xda\x3f\x5b\xdf\x5e\xc6\xfa\x7e\x64\xf0\x32\xda\x7d\x76\x2c\x3b\xea\xea\x72\x56\xa3\xf7\xff\x6e\xba\xff\x75\x90\x9d\xd9\x7f\xef\x70\xef\x33\xba\xf6\xaf\x0d\xa0\xf5\x64\xd3\xf3\xf3\x3b\xbe\x50\xe7\x7d\xf9\x3d\xf2\xcd\x99\x49\xf7\x2b\x9e\xe7\x36\xfa\xb5\xb6\xc3\x0a\x26\x6b\xdd\xba\x90\xea\xed\xeb\x5d\x4e\xfa\x5d\x5d\x05\x33\xba\xee\x81\x21\x6c\xee\x8b\x8d\xb9\x5f\xdb\xc5\xb7\x2f\x78\x25\x3e\xd3\xb7\xcf\xea\x10\x58\x16\x10\xf8\x51\x06\xfc\x19\xa8\x86\xc1\xab\x2a\x2e\x04\xb2\xb6\x8a\x5b\x4c\x53\x03\x66\x75\xc1\x9e\x15\x16\x13\x7d\x53\x45\x2b\x13\x17\xa9\x0e\x8e\xb3\x5a\x78\xbf\x84\x90\x5b\xf6\xf1\xbe\x60\x48\xf1\x8a\x16\xb1\x21\x29\x3b\x2c\x2a\x6e\x4c\x3e\xa7\xc2\x7d\x2a\x0c\x54\x61\xba\xa5\xd9\x82\x2d\xaa\x45\x75\xda\x58\xa9\x59\x56\x63\x2b\x11\x82\x45\xac\x42\xd6\x2e\x56\x40\xab\x94\x55\xd9\xd4\x4f\xaa\x3b\xab\x4d\x52\x97\x97\xee\x0f\x60\xdc\xac\x0b\x3b\x4b\x6b\xcb\x7a\xd1\x59\x1a\xc2\xcc\xa2\x61\x19\x77\xa3\x5c\x8e\x8f\x77\xac\xd6\xf6\xdf\x70\x03\x14\xe1\x19\x90\xb5\x70\xa1\x76\xb8\x63\x35\x2d\x47\xcb\x07\xb6\xbc\x42\xfe\xdb\x72\xf2\x08\x57\xfb\xfa\xeb\x08\x90\xdd\xa8\xc7\x90\x8d\x1a\x13\x3e\xab\x25\xac\xca\xb2\xd7\xef\x76\x07\x2d\x5c\x34\x27\xec\xf5\x79\x69\x60\x69\x2c\xa9\xfa\x7c\x5c\x80\x96\x68\xa0\x05\x1a\x10\x27\x6f\x8a\xc2\x9a\x28\x1c\x8f\x42\x53\x14\x8e\x45\x59\xb2\xc9\x4c\x53\xab\x66\x27\xea\x19\x11\xbc\x9d\x77\x04\x9d\x52\x9f\xc1\xc0\x9b\x86\x5b\x77\xab\xd3\xb0\x74\x29\x84\xa0\x4c\x7b\xdf\xca\x0d\x64\xb9\xd9\x0b\x70\x3f\x96\xb1\xfd\x0d\x7f\xef\x16\xc2\x76\x6f\xbd\x76\x0a\xb1\x65\xef\x27\x42\xe5\x2f\xcc\x4f\xae\x9f\x6f\xe0\x77\xf4\x15\x67\x87\x2d\x4e\xec\x0c\x77\xb3\x7d\x19\x3c\xb3\x8d\x74\x5b\x79\xc3\x5f\x4d\x78\x22\x21\x09\xa1\x74\x87\x3f\x4a\xe0\x6b\x19\xef\xee\xad\xf3\xe1\xd4\x5b\xba\xfe\x06\xa2\x48\x8f\x67\x80\x17\xba\x9c\xb7\x30\x78\xc6\xb7\xf5\xfe\x57\xbd\x85\x0c\x68\x6a\xb8\xa3\x4c\x68\xd6\xff\x0b\x04\x7e\x11\xdb\xcf\x3a\xfe\xfc\xcb\x19\xf8\x5b\xc0\x22\x77\x83\x7f\x91\xc0\x2f\x66\xfb\x59\xef\xff\x81\x5f\x33\xf0\x3f\x15\x1e\x4d\xd0\xc6\xc3\x67\x8c\x9f\xb2\xfe\xf1\x7a\x42\xad\xf2\x93\xe0\xa0\xce\x13\x87\x03\xeb\xc0\x04\xee\x1c\x02\xf7\x36\xdb\xc7\xe7\xeb\x70\xbf\x53\x38\x4c\x04\xc7\xde\x56\x59\x36\xb4\x3b\x7d\x8f\x41\x0b\xe3\x0f\xfa\x7c\xac\x4b\xbd\x63\xf0\x07\x76\x5a\x85\x79\x31\xed\x99\x60\x31\x25\x77\x92\xbf\xb6\xb0\xfc\x90\x33\x13\x45\x7a\xbd\x63\x19\x05\xfe\xaf\xd5\x14\xba\xd5\x52\xb8\x93\xe8\xee\xb4\x4e\x06\xc5\x83\xf0\xa9\xe7\x89\x5e\x61\xe0\x81\xfa\xc0\x5e\xa6\x03\xba\xc0\x3b\xdd\x7b\xcc\x9b\xf2\x72\xa5\xde\x5d\x5e\x5c\x5f\x6f\xcc\x03\xb1\x31\xb8\xaf\x98\xde\x72\x3e\x83\xbf\x00\x0f\x20\xf0\x59\x09\x7f\x69\x98\x58\x68\xfe\x66\xff\x76\xff\x07\x7e\x0e\xf9\xdd\xfe\x84\x9f\x63\xe7\xb4\xf5\xac\x5d\x94\xf0\xff\x5c\xc6\x53\xfa\x18\x3c\xe2\x52\x83\xa7\xe8\x8e\xf4\x6d\x5d\xbc\xe8\x38\xf5\x88\x36\x1e\x2f\x17\x7e\x47\x36\xa4\xa0\xe3\x89\xcd\x4e\x8f\xcd\xca\x71\x20\x82\x5f\xf4\x7b\x3c\x41\xd5\x2b\xdb\x5d\xb5\x49\x7b\x84\xb3\x82\xf5\x8e\x3a\x51\x06\xa0\xf7\xb8\x54\x43\x03\x34\xc3\x46\x38\x46\xcf\x4b\x76\xb1\x1c\xe4\xed\x41\x58\x14\x84\xda\x20\x24\x82\xe0\x66\x09\xe9\x6b\x82\xd0\xc8\xbe\x39\x16\x34\x60\xd6\x30\x98\xa6\x0c\x30\x14\x84\xfe\xa9\x20\x1c\x0c\xc2\x07\x2c\x8d\x99\x34\xd8\x19\x04\x3d\xa7\xbd\x3a\x08\x72\x10\x0e\xb1\xbe\x36\xb1\x7f\x46\xd9\x37\xff\xe7\xda\x1e\x25\x13\xeb\x67\x98\x85\x6f\x32\x2b\x7c\x74\x06\xcd\x40\x20\xaf\x28\xcf\x92\x57\x09\xe5\x5d\xca\x7d\xe0\xe5\x1b\x77\xf3\x1f\x6d\x02\xfc\x8d\xd6\x91\xae\xfa\xf1\x7c\xd6\xae\x5d\x59\x70\xe6\x6f\x13\x33\x2a\x7f\x30\xf9\x3f\x80\xd6\x89\x26\xf3\x7d\x86\x21\x1f\xe8\x45\xad\x84\x62\x7d\xd4\x25\xec\x93\x78\x47\xa7\x3c\x5f\xad\x0d\xa0\x35\x42\x08\xec\x85\x3a\x2c\xcc\x4f\xc3\xee\xcf\x84\x35\xeb\x89\xb0\x7c\xce\xfe\x89\x08\x72\xb2\xca\xe0\x36\x9b\x9d\xe7\x24\x87\x13\x5b\xec\x64\xeb\x58\x05\x99\x67\xa9\xab\xac\xcc\x2f\x7d\x2f\xc8\xbc\x2c\xf1\xff\x52\x50\x84\x1f\xa8\x25\xcc\x82\x22\xfa\x5e\xe1\x37\x33\xbb\xa6\x44\xb7\x6b\xd0\x13\x94\x76\x9e\x06\xca\x39\xc4\xb6\xd4\xb5\xad\xa2\x0d\xf1\x9d\xba\xd2\x34\xb2\xb7\xa7\x58\xae\x24\xf0\x35\xfa\x39\xb0\xaf\x46\xdf\x59\x44\x18\xf1\x17\x74\xf1\xf9\xd1\x79\xa2\xf5\xad\xd3\x7d\xff\x0e\xf7\xeb\xef\xee\x6c\x4b\x1d\x6e\x75\x8a\x46\xbf\xe6\x3c\xd1\xba\x26\xe9\x7e\x7f\x1f\xc8\x24\xae\x03\x39\x0c\xcf\xa0\x89\x2b\xdb\x4f\x7a\x7f\x27\xf1\x4c\xaa\x77\x25\x1c\xe0\xe2\xc0\xf9\x66\xba\x43\x53\xaf\x27\xf3\xc9\x29\x6c\x3f\xd5\xe8\xf0\xd0\xa2\xdb\x01\x20\x21\x70\xcc\x4f\xb3\x96\xea\x4e\xdd\x2b\x13\x5f\xa2\x27\xec\xeb\xb8\x83\x62\x21\xae\x15\xad\x26\xb2\x46\xbf\x33\x3a\xfb\x25\x70\x6b\x08\x9c\xa5\xb5\xc9\xb6\xc8\x86\xeb\xf5\xb5\x44\x46\x6d\x6f\x27\x1a\x95\xc8\xb7\x4a\x16\x87\x83\xc7\x48\x42\xb2\xcb\x0e\x36\x6c\xe1\x39\xb2\xe5\xb0\x95\xfc\x71\x08\x1c\x72\xd0\x8a\xdf\x19\x9e\x47\x8f\xe1\x32\xf7\xa6\x4b\x39\xeb\x4e\x74\xca\x60\x2c\x95\x55\x64\x79\x0b\x02\x02\xad\x05\xbe\x62\x05\x14\x41\xb9\xf6\x1e\xfe\x19\xbe\x3e\xeb\xcb\xa1\xf8\x85\x8e\x0f\xd7\x1e\x5c\xab\xcd\x36\xee\x10\xf4\x92\xb5\xea\xc9\xea\xd3\x5c\x91\x38\x13\x4b\x4e\x5a\xc8\x5c\xc4\x03\x1d\xe0\xa8\x14\x80\x8c\x4b\x38\x39\x6f\xe7\x69\xd2\x30\x82\x40\x0b\xab\x26\xdf\xec\x84\x46\x27\x44\x9d\x70\xcc\x09\x7b\x58\x89\xf9\x16\x56\x6e\xbe\x0b\xbb\x63\x48\x12\xb2\x2b\xab\x2f\xaf\x27\x04\xa8\x07\x47\x19\x45\x0d\x75\xfc\xaa\x02\xf0\xa8\xf6\xdd\x8d\x37\x42\x68\x31\x7e\xaf\xa3\x1c\xf7\x3d\xe7\xe3\x73\xf0\x6b\x1d\x9f\x8c\xdc\xd7\x79\xf6\xad\x9a\x67\xdf\x56\x0d\xbe\x33\x6c\x63\x6a\x6b\xb8\x2e\x71\x79\xcc\xa3\xef\xca\x0c\x9f\xe7\x17\xa6\xcf\x93\xd8\xd2\x4b\x32\x6d\xe9\xc9\xa1\x2c\xd3\xe5\x69\xe8\xff\x64\x7f\x0e\x61\xeb\xd8\xd7\xa0\xbb\x76\x9d\xee\x02\xd4\x5c\x08\xb8\x8c\xde\xf5\xbe\x09\x8d\x4e\xe6\x6b\xcc\xbe\x09\xec\x3a\x5d\xd7\x8b\x59\x62\x21\xa3\x5b\xd4\x45\x6f\xeb\x6b\xe8\xe5\xb7\xea\x7a\x39\xb3\x8f\xdc\xb4\x63\xb7\xd2\x79\x62\x9f\x81\xf7\xef\x69\x5f\xed\x0a\xf4\x6f\xbd\x8d\x6e\xea\x52\x9b\x2a\x12\xef\xf4\xd6\x32\xd9\xf9\x4f\x32\x4e\x6f\x42\xe3\x45\xa4\xcd\x5b\xb4\x95\xe5\x70\x8a\x56\x60\x2b\x7b\x12\x42\x6d\xa9\x67\x12\xb9\xa1\x90\xcd\x56\x80\x64\x16\xd7\xce\x55\xa3\xe9\x08\xbb\x51\x0c\xed\xa2\xa9\x8e\x4d\x68\x13\x3a\x84\x78\x7a\x13\x78\xa5\xfe\x82\x80\x96\x12\x19\x34\x4a\xb8\x07\xe5\xa3\xb3\x13\x05\x8e\xdc\xb0\xdf\x1f\x08\x70\xb9\x5c\x61\x41\x58\xce\x91\x1b\x92\x39\x7c\x90\x0b\x78\x69\x4d\x7d\x16\xfb\x47\x0b\xeb\x9b\x19\x39\xd5\xd5\xd5\xdd\xee\x21\xd4\x0b\xeb\x57\xe9\xf7\x78\xd2\x34\x51\x76\x59\x0f\xad\x29\x1e\x57\x02\xe5\xf4\x72\x23\x6f\x08\xdc\x98\xbb\x75\xc9\x53\x23\xdf\xa9\x18\x53\x52\x3d\x32\xb6\xe8\xce\xcb\xb6\x4c\xd2\xf6\xf3\x10\x73\xf0\x43\x01\x3d\xf8\xc3\x9e\xfd\xfe\x9a\x49\x8f\x0f\xeb\x7b\xd6\xad\xb7\x41\xd1\x73\x8f\x5c\xfe\x68\x43\xfb\xb3\xfc\x30\x18\x32\xff\xe6\xe6\x35\x9a\xa6\x7d\xab\xfd\x45\xdb\xab\x9d\xd0\xe9\x97\xd6\x95\x99\xcc\xea\x8d\x25\x13\xfd\x2c\x51\xd5\xe5\x92\x65\x1c\xe5\xf2\x72\xd5\x48\xc4\x5e\x9b\x8c\xb8\xfd\xb2\x1c\x40\x3c\xcd\x31\xdf\x94\x07\x6b\xf2\xe0\x78\x1e\xb4\xe4\x81\xfe\xb9\x29\x0f\x8e\xe5\x41\xb7\x0a\x57\xa7\xbe\x51\x5a\x08\xfc\x41\x51\x1e\xbf\xc8\x9d\x43\xe4\xc1\xc8\x8a\x53\x6a\xf3\xdc\xa9\x8d\x27\x62\xe1\xac\xcb\xa8\x39\xd1\xbd\x46\x4f\xfb\x87\xac\x44\x54\x3a\xde\xe1\x31\x33\xde\x81\xd8\xd5\x6f\x18\xbe\xb5\x48\x44\x8f\xfb\x0a\x77\x89\xdb\xd0\x7d\xdc\x75\x69\xbf\xf8\x2a\x76\xae\x49\xe1\xa9\x03\x14\x2b\xbc\xa2\x8a\xa7\xc6\x79\xb8\xd3\xf1\x14\x3c\x3b\xdb\x36\x63\x30\xb2\xa8\x4d\x9d\x95\x6f\x39\x9d\x1f\xfd\xab\xf4\x18\x0f\x40\xad\x31\x06\x73\x11\x86\x2c\xa1\xf8\x69\xc6\x08\xa6\xc7\xe0\x70\x5f\xd3\xef\xae\xc7\x6c\x84\xa7\x87\xf3\x32\x03\x36\xd2\x63\xbc\x9b\x1e\x63\x23\x2c\xee\xea\xab\x57\x27\xab\xb1\x2e\xbe\x7a\xea\x77\xf9\xd5\xd2\x22\xdc\x46\x04\x5c\x8c\xd8\x2e\xe3\x22\xb2\xcf\x17\x73\x7a\x62\x9c\x48\x14\x93\x78\x6e\xd0\xe5\x70\x11\xbb\xc5\x4b\x7e\xe4\x66\x79\x23\x0d\x2d\x5f\x2d\xa7\xc8\x2f\x4e\xa6\xd7\x9c\xc8\xe0\x17\x64\x1a\x65\x26\xe7\xd8\x6c\x0e\x2e\xc7\x87\x7c\x7a\x88\x59\x2e\xe0\xe9\xb9\xd0\x90\x0b\x35\xb9\x50\x9d\x0b\xf5\xe9\x30\x33\xfd\x04\x93\xa5\xdc\xa4\x6f\x3c\xc9\xb8\x22\x52\x4d\x17\xe9\x72\x81\x79\x8d\x8c\x9a\x11\x66\xa6\x7b\x6b\xbd\xe5\x65\x55\xdc\xa1\xc2\xab\xfb\x69\x3b\xb4\x15\x30\x0f\x6a\x87\x2f\xe1\xfe\xdc\x71\x05\x9e\xd8\xf1\x10\x7e\xad\xdd\x37\xfc\xb2\xb7\xfe\x71\xe0\xe5\xd9\xfd\xb0\x95\x28\x4f\x63\xc8\x9f\x59\x0e\x33\xf4\xec\x4e\xdf\xef\x87\xbf\xd1\xda\xfd\x88\x9d\x13\x90\xf9\xb2\x8c\xe2\x2f\x44\x61\xb2\x53\x8b\xd1\xac\x44\x75\xcc\x82\xa5\x48\x0f\x9f\x2f\x12\xb1\x78\x83\xa1\x50\x4f\xaf\xc5\xdb\xbb\x4f\x0f\xdf\x98\x64\x0f\x7a\x80\xdb\xa3\x07\xb1\x12\x73\xec\x39\x35\x49\x97\xdd\xad\xe4\xf1\x79\x35\xc9\x66\xa6\x5d\x05\x83\x88\x57\x16\xf5\x81\x6e\xe7\xb4\xe9\xb0\xed\xe2\xe2\x6e\x55\xb5\x8c\xd3\x59\xba\xb7\x69\x46\xa6\x5e\x15\xaa\xdb\x71\x6c\x67\x8d\x28\xe3\x30\x56\x98\xf2\xd3\x2d\x6b\x4e\x98\xa5\xa2\xd0\xca\x65\x3f\x64\x9c\xc1\xb6\xff\xc5\x2c\x1b\x05\x27\xcd\x33\xd8\x8d\x1b\xcd\xe2\x51\xf7\xdf\x9f\x71\xfa\x8a\xcb\xf4\x3a\x52\xf8\x5f\xec\xe4\xd5\xe0\xb3\xeb\x99\x6c\xa8\x34\x64\xc3\x7b\xe6\xd9\x13\x0d\xab\x74\x2b\x21\xde\xd9\x4d\x36\x70\x0e\x26\x1b\x2e\xd6\x65\x03\x7a\x26\xf3\x7c\xe1\x3c\x35\xcc\xcb\xdd\x65\xc3\x7a\x26\x1b\x2a\x0d\xdd\x4d\x60\xb2\x81\xba\x92\xf6\xb6\x66\x2b\x46\xef\xa6\x6c\xa0\x75\x98\x8c\xbe\x89\x4e\x32\x80\x49\x91\x9c\xb6\xd4\x84\xd6\x1c\xd5\xe8\x37\x8d\x73\xb1\xd9\x67\xa7\x8f\x52\xa1\x38\x07\xdb\x52\x8f\xb5\x06\x73\x4c\xb4\x8d\x3d\xd8\x9f\xe0\x1d\x62\xb2\x81\xf5\x8d\x57\xf4\xef\x3c\x49\x09\x51\xef\x76\x28\x6a\x22\xce\xf6\x20\xab\x63\xcf\xe6\xa5\x9f\x31\x2f\x7b\x8d\xf7\x2c\x26\xf2\xa7\x78\x45\xf1\x19\x5d\xcf\xe4\x58\xed\x26\x36\x2f\xe3\x0c\x99\x39\xc0\x80\xef\x49\x46\xe8\x59\xd7\xb3\x77\x57\x78\xbd\xff\xe2\x74\xff\x29\x98\x61\xd8\x10\xbd\x7b\x93\x01\xfa\x16\xf6\x2d\xee\xc2\x13\xf4\xfe\x7f\x37\xfb\xc7\xb7\xa2\x37\x0c\xf8\x5e\xbd\xc8\x00\x25\x5c\x49\xcf\x2e\xf0\x83\x98\xcf\xec\x4f\x66\xff\x68\x01\x3c\xa2\xcb\xd9\xd2\x92\x52\xb3\x67\x86\x37\xe1\xf9\x51\x36\xe7\xe3\x0c\xb8\x1c\x1d\xee\x0c\xff\x19\x3d\x33\xe0\xba\xe1\x4b\xe6\xfc\x12\x63\xfc\x62\x3a\x21\x7d\xe4\x3e\xe5\xff\x13\xdf\x15\xc8\xf4\x49\xf5\xa4\x13\x52\x6c\x2f\xee\xdb\x05\x5e\x25\x78\xbc\xc7\xe8\xa4\xca\xc0\x63\xa2\x8e\x47\xf0\x82\x60\xd0\xd0\x1b\x29\x1e\x21\x56\x03\xb9\x3f\x81\x1b\xaf\xc3\xa1\x95\x3a\x5c\xf6\x88\xec\x6c\xae\x33\x6e\x94\xd5\xea\x67\xf8\x56\x19\xf8\xc6\x8d\xf1\xad\x56\x1a\x16\xc9\xdb\xdd\xbc\x98\x31\x7e\x28\xf5\x13\xb7\x8f\xe9\x98\xe3\x0d\x5d\x77\x3a\xd3\x5d\x9d\x90\x8d\xb2\x63\xd9\xb8\x2e\x3b\xdb\xe1\x30\x7d\x8c\x19\x77\x01\xc8\x30\x31\xf1\x5f\x10\x04\xbb\x28\xda\x24\x17\x16\xc8\x76\x96\xe8\xc5\x39\xc4\x92\xa0\x75\xa2\x6d\x36\xc1\xc9\x09\xde\x5a\x0f\x24\xcc\x9b\xe5\x78\xf3\xd2\xb7\x5d\xec\xe2\xb5\xcd\x1e\x58\x65\x5e\xbc\x36\xd6\x03\x83\x4c\x98\x29\x27\x19\xd0\x6e\x76\x77\xdb\x1a\x76\x3b\xdb\x58\xf3\xe2\x36\xbd\x8b\x03\xec\x69\x2b\x6b\x3f\xdb\x03\x75\x66\x63\x87\x07\x48\xdb\x23\x1e\xd8\xc3\x2e\x77\x5b\xc7\x5a\x45\xd8\xf7\x55\x3f\xb3\x36\xcf\xb3\x6f\x49\xb3\x1b\x3c\x30\xdd\x03\xa3\x58\xcb\x62\xd6\x2f\xe9\xf4\x71\xf6\xa8\x8e\x7d\x4f\xda\xa4\x3c\x80\x0f\x7a\xe0\x03\x0f\xac\x66\x78\x96\x7a\x20\xe6\xa1\x97\xcb\xfd\xff\x7b\x35\x80\xe9\x1d\xca\xf4\x10\xe9\x89\x2e\xd4\x77\x65\x04\x83\xb2\xdb\x02\x0e\x1f\xd6\xf6\x7f\xfd\xb5\x7e\x63\x80\xb6\xf6\xa5\x8e\x3b\xf0\xcc\x97\xe0\x5a\xe3\xde\x00\xb3\xae\x58\x36\x9a\x92\xe8\x4f\x25\x9a\xcb\xab\x38\x2c\x9c\x4d\x10\x14\x8e\x8b\xe6\x78\x6c\x76\x1b\xe5\xe1\x92\x64\x97\x03\xac\xd4\x98\x77\xba\x08\xb2\x58\x23\x36\x8b\x9c\x9b\x13\x51\x28\x5d\x72\x8c\x25\x42\x95\x9b\x71\x37\xdd\xaa\x8f\x65\xfa\xda\x88\x92\xa6\x57\x0b\x48\x17\x22\x63\x3f\x19\xc5\xc8\x9a\x9b\xf5\x72\x64\xcf\x3e\x6b\x16\x24\x3b\xf0\xd2\x37\xb4\x22\xd9\x37\x2f\xad\x36\x4b\x92\xa5\xe3\xf3\xa2\xe9\x58\xbb\x74\xcc\xba\x1e\x04\x18\x41\x91\x1e\x9d\x7e\x85\xf4\x39\xec\x6b\xe9\xb3\xdb\x0d\xc6\xb9\xa0\xce\xd5\x62\x34\x9e\x2f\xd6\xa7\xdb\xd9\xad\x1e\xcf\xb7\xd9\x1c\x83\xe8\x3b\xb7\xc3\x79\x6c\x0c\xbf\x9f\xfa\x43\x91\xd7\x77\x9a\x31\xea\xd2\x63\xac\x02\x7f\x86\x4e\xad\x52\xff\xb8\x1a\x3c\xdd\x18\x4c\x47\xea\xdf\xf5\xec\x51\x7f\x8f\x00\x0a\x64\x9f\x66\x8c\xaf\xd2\x63\x3c\x00\xc3\x0d\x78\xf6\x22\x61\x1c\xce\xed\x1c\x21\xdd\xff\x73\xe9\x77\x78\x10\x76\x12\x1d\x8f\x9d\xb9\x06\x02\x34\x26\x91\x88\x65\x6f\xb7\x98\x44\x36\x86\x78\x4d\x7a\x8c\x07\x61\x84\x79\x4e\xcb\x9c\xf6\x74\x9b\xab\xdd\xce\xac\xf5\x71\x82\xe9\xf7\xe0\xe0\x00\xea\x12\xfb\xe8\x1b\xe3\xcb\x3a\xcd\x38\x93\x98\x1e\x36\xc1\xd0\xc3\xea\xbb\x9e\x8d\x07\x87\x05\xe3\xdd\xc7\x21\xbc\x7a\x24\xe3\x7d\xfd\x8d\xf3\x0d\xaa\x83\x16\x25\x14\x90\x43\xd1\x50\x49\xa8\x9a\xdd\x97\x30\x3d\xd4\x1c\x5a\x1d\xb2\x11\x69\xa5\x25\x5b\x43\x21\x59\x97\x56\x33\x0d\xd9\xd9\x4c\xf8\xe7\xa5\xfc\xc0\xf4\xb8\xeb\xf1\x52\x83\x2f\x46\xb3\xb3\x25\x29\xcd\x17\xd9\xbd\x12\x8c\x2f\x0e\xd4\xe5\x0e\x9e\x95\x79\x7e\x98\x83\x73\x82\xb6\x8c\x78\x16\xbd\x06\x1a\xe3\xe3\x97\x18\xb1\x26\x4f\x18\xf0\x54\xad\xa4\x27\xfd\x01\xab\x3f\x63\x6d\xf4\xd8\xcf\xe2\x74\xec\x67\x0a\xc6\x1b\xf0\x76\x3b\x3d\x74\x42\xb2\xcd\x0c\xfe\xf4\x74\xc6\x05\xfc\x6e\x9e\x9f\x13\xb9\xb6\x37\x73\xed\xb3\xac\x59\x8a\x19\x18\xd0\xd9\x3f\x8b\x47\x65\xfd\xdb\x00\x88\xbe\x4b\xe3\xf6\x30\xe5\xb5\x64\x7e\x9d\xd4\x34\x74\x3a\xf4\x41\x3a\xe3\xfd\x58\x5d\x7f\x26\xcf\x87\x18\xf2\xfc\x66\x43\x3e\x53\xb4\xec\x57\xd8\x9d\xd0\x45\x3e\xb3\xda\x4a\x4c\x9e\xd7\x1b\x7a\x8e\x19\x5b\x6b\xa7\x01\x54\xe7\xd9\x9d\xc8\x9a\x09\xcf\xfa\x67\x3e\xd0\x21\x86\x8f\xa2\x87\xe1\x03\x65\xfd\xdb\xed\xd2\xe9\xfa\x7f\xd7\xec\x1f\xaf\x43\x2f\xea\xeb\x65\x97\xec\x92\xd1\x75\x27\xde\xc5\x66\xbf\x44\x8e\xf5\xc9\x9c\x4f\xc9\x2d\x79\x21\x53\x8e\xea\xfd\xfe\x9e\xee\x77\x05\xf5\x9e\xd0\xfd\x6a\xa7\x78\xeb\x87\x71\x5e\x64\xed\xdc\xaf\x84\x67\xde\x81\x10\xbe\x41\x78\x17\x39\xd1\xe8\x44\xb9\x28\x49\x4e\xa7\xec\x92\x02\x9c\x75\x74\x92\x33\xee\xc0\x6a\x61\xb7\x5f\x35\xcb\xd0\x28\x43\x54\x86\x63\x32\xec\x61\x57\x62\xb5\xb0\xeb\xb1\x32\x5d\x85\x28\xc3\x0f\xc8\xa2\xbe\x3b\xcb\x5e\x13\x6b\xef\x0e\xb3\xe0\xb5\xf6\x3d\xff\xb8\x51\xeb\xfa\xe4\x0c\x7a\x06\x6c\x37\xea\xc6\xe7\xa0\x5e\xe8\x9a\x44\x4e\x0e\x64\x59\xf8\x00\x57\x50\x90\x15\x95\xb3\x04\x99\xeb\x5d\xac\x28\xd8\x6e\xb3\x85\xb1\x25\x07\xe5\xd0\xc3\x07\x35\xc9\x93\x7d\x85\xa5\xdc\x9a\xa4\x24\x85\xc9\x2e\x0e\x78\x7b\x10\x6e\x6e\x44\x94\x55\xeb\x89\xfd\x19\xe5\x5e\xe8\x27\xcf\x80\x8c\x8b\x74\x55\x23\x36\xc4\x3c\x6a\xd0\x23\x44\x3c\x5d\xcb\xce\xe7\x65\x44\x89\xf4\xb3\xd3\xc3\x87\x7e\xda\x3b\x34\x56\xe4\x95\xdd\xfb\xde\x99\xfd\x58\xb1\x5e\x7c\x7e\x29\xd7\x38\x6d\xd6\xf5\x33\xa6\x5f\x3f\xfb\x6a\x76\xfa\x7b\x67\xcb\x1e\xed\x47\xed\x84\xf6\x9b\xf6\xdd\x15\xf5\xac\x00\x3d\xb7\xa9\x63\xee\x8e\xcd\x4f\x6d\xfd\xeb\x93\x5b\x75\xfb\x83\xfc\x27\x8e\x27\xfa\x43\x88\x58\xdb\xbd\xd0\xf8\x44\x6f\x91\xb3\x15\x79\x94\xa2\x9c\x1c\x67\xd8\xa6\x38\x6d\xe4\x8d\xfd\x7e\x67\xa8\x28\xbb\x21\x59\x54\xe4\x0c\x15\xca\x21\xb9\x21\x19\xe2\x9c\x39\x0d\x49\xa7\xb7\x33\xf7\xd8\xe3\x35\xcb\x4b\x75\xbf\x23\x98\xe5\xea\x80\x79\x9f\x68\x80\x5d\x2f\x4a\xef\xb4\x57\x2d\x2c\xbd\xcf\xbc\xe3\x89\x33\xc3\xa3\xb9\x93\xc4\x7e\xb0\xb2\x8b\x45\xd9\x45\xa3\x59\x4b\xa3\xff\xc8\xf9\xdb\xbd\xdc\x97\xfa\xe5\xa2\xb7\x2f\x19\xb3\x60\xae\x7e\xdd\xa8\xb0\xb8\x75\x1b\xbb\x61\x74\xcd\xae\xbf\xf3\x8f\x5f\x57\x7e\x91\x67\x6a\x63\xf3\xda\xf6\x1e\xf4\x9e\x51\xfc\x34\xbb\x74\x14\x21\x33\xae\xfb\x3a\xe3\xfe\xaa\xb3\x13\x79\x56\x64\xf7\xf9\x04\x7a\x60\xa6\x2a\x2c\x33\xc4\x2e\x10\xa5\x89\xdd\xe5\x49\x2f\x56\xf5\x96\xaa\x50\xdf\xbd\x6c\x56\x97\x8c\x5c\x33\xb0\x9b\xda\x83\x65\x8a\x11\xd8\x1d\x13\xae\xbb\xe1\xc7\x3f\x77\xe4\xf3\x05\x1d\x18\xf6\xfd\xd8\xae\xed\x5b\xb9\x52\x5b\x0c\x4b\xc1\x05\xdb\x17\xbd\x7a\x0d\x4d\x3d\x7a\xfc\xe3\xb7\xeb\xa7\x6a\xd7\xa0\xcc\xfb\x09\x82\x28\x17\x8d\x4d\xf4\x72\x23\xd1\x43\xa6\x3c\x84\x90\x33\x3f\xcf\x62\x71\xf9\x7d\x3e\x87\x4b\x89\xd4\x24\x15\xc5\xe5\x08\xb8\x3c\xb5\x49\x7a\x71\x0c\x8d\xef\xee\x2c\x63\x9d\x41\x5a\x3a\x41\x0d\xe8\x4c\x53\x3c\xf5\xde\x82\x34\x65\x65\x16\xd5\x3d\xf0\x5a\x9a\x76\xf0\xb7\x5a\x39\x25\xa8\x17\x3e\xd4\x0e\x7c\x3e\x7d\xc1\xbc\xa6\x83\xd8\xa9\x69\xda\x97\x06\xe1\xf0\xfb\xf6\xfd\x8b\x50\xd3\x77\x29\x04\xe3\x9e\xde\xf2\xf0\xd3\xf4\x1d\x90\x31\xaf\x2e\xa2\xa9\xf4\x4b\x44\x2c\x82\x83\xc8\x6e\x99\x7c\x19\x54\x1d\x3e\x7a\xd3\x99\x60\xe3\x04\x3f\x9d\x52\x94\x81\xf0\xe9\xa6\xb2\xa8\xb2\xa0\xfc\x34\x73\xb9\x02\xae\x18\x75\x9a\xb9\xe4\x8e\xac\xce\xff\xba\xe3\x2d\x63\x36\x09\x1e\xc6\x5c\x86\x88\x0d\x3d\x32\x51\x10\xb6\x28\x84\x62\x63\x31\xbf\xc5\x5f\x58\xe0\x72\xd1\xa2\x5f\x5e\x3e\x08\xde\x00\x9f\x5d\x93\xe4\xdd\x76\x62\x33\xdb\x33\xa6\xb1\xda\xc3\x52\x6c\x33\x66\xd0\xc4\xed\xb4\x3b\x91\xa2\x9a\xb1\x19\xe1\x51\xfd\xbe\x87\x8f\xdf\x4a\xcf\xe4\x6a\xa8\x1f\x05\xaf\x18\xd7\x3f\xf0\x67\xe8\xf7\x3d\xd0\x4b\x20\xcc\x3d\x38\x66\x75\xfe\x9e\xf6\x8b\xcd\x1b\x20\x00\xf5\x27\xf2\x7d\x16\xbb\x0f\xf7\xcc\x44\x8e\x5b\x96\x31\xa7\xd8\x6c\x5c\x38\x84\xb1\xe8\x76\x4b\xfa\xc5\xb7\x3c\xbd\x1b\x57\xf2\x75\xa1\xcb\x6e\x38\xd3\x6d\xc6\xd1\xbb\xc6\x75\xa7\x45\x6e\xbe\x79\x17\x66\x05\xc6\x5b\xb5\x5f\xa6\x68\xa9\x8b\xe0\xac\x43\x30\x16\x66\x69\x0f\x68\x5b\x7f\xd3\xde\xaa\x06\x5e\xbf\xfb\x96\xdf\xa6\xfd\x7c\xd9\xbb\x6f\x6a\xcd\xda\x23\xda\x5f\xb4\xdb\xcc\xcb\x6f\x99\x37\x5b\xbf\x67\x55\x3c\x47\x7c\x1c\x15\xa0\x4b\x12\x67\x44\x0b\x44\x1f\xe1\xcc\x41\x54\x50\xe0\x2b\x2a\x0c\x06\x15\x22\x05\x24\xc9\xad\x64\x45\x1b\x92\x59\xf1\xcb\x92\x59\x8a\xc2\x35\x24\x15\xde\x4d\x76\x94\xdb\x97\x9e\x66\xf7\x6b\xc5\x19\x58\xa7\x11\xef\x4c\xa9\x05\xf3\x8e\x55\x33\x25\xd4\x74\xbd\x54\x66\x72\x6e\x7e\xbe\x8e\xf1\xdb\xcd\xcf\x0d\x04\x18\xad\xbd\xf4\xa5\x79\x97\xef\x47\x77\x3d\x72\xf7\xa8\x0b\x06\xe6\x0c\xaa\xe4\xde\x34\xae\xee\xbd\xe9\x8e\xcb\xde\x79\xdb\xbc\xd1\xf7\xbc\xc1\x77\xdc\xed\x79\x57\x3a\x67\x84\xf6\xb2\x79\xe7\xc6\x7f\x85\x52\x22\xc7\x47\x27\x7a\x66\xe7\xd9\x1d\x48\x75\x70\x79\x79\xde\x82\x7c\x55\x0d\x20\x14\xb0\x13\xbd\x3c\x1c\xad\x4d\x86\x03\x01\xae\x26\x19\x70\xcb\x96\x9a\xa4\xac\x64\xbe\xce\xa9\x6f\xa3\x66\xbe\x4a\xfa\xe2\x8d\x3c\xe3\x66\x08\x95\xc5\xbb\x1b\x17\x2f\x70\xfe\x8c\x2b\x38\x16\xed\x59\xa6\xdf\xcd\x31\xe7\x32\xeb\xfa\x3b\xf4\x97\xc0\x1f\x67\x5e\xc5\x61\xde\xd0\x51\x78\xcb\x52\xcf\xdb\xe4\x1d\x8e\x67\xc6\x2f\x79\xcd\xf8\x25\xca\xcb\x27\x92\xfd\xe8\x27\x56\xc7\x90\x44\xd4\xe6\x72\x85\x05\xf2\x2e\x42\x34\x47\x92\x04\x8f\x27\xd4\x90\xf4\x58\xc8\x0f\x27\x84\x3b\xf7\x64\x71\x27\xd3\xce\x24\x24\x23\xf1\xad\x93\x4f\x67\xde\x5d\x2c\x4e\xd4\x73\xdf\x0c\xd6\x8c\x0b\x4f\xbd\xc2\xb8\x93\x1f\x6b\xf7\x6a\x4f\x99\x57\x19\x13\x1c\x27\x18\xf7\x5d\x4a\x04\xcb\x21\x89\x98\x13\xf1\x6e\xb7\x0d\x89\x36\x4e\x09\x70\x5e\x7a\x2d\xa2\xdd\x42\xc3\x14\x2c\x9c\x5d\xa6\x29\x37\xa7\xf0\xe1\x8c\x3c\x2e\x8a\x15\x2b\xb0\x41\x48\xbd\xc0\x4f\xc5\x48\xae\x38\xa1\xe3\x28\xec\xeb\xc0\x84\x09\xe7\x1f\xd3\xbe\x85\x62\xc2\x31\x96\x6a\x8b\x57\xae\x84\xed\xaf\x7e\x0c\x17\x7f\x7d\xa2\xf9\xfb\x97\xdf\x87\xbb\xa7\x22\x94\x79\xb7\x09\xe5\xc1\x63\x12\xbd\xbc\xd6\x9c\x1c\x89\x70\x60\x9b\xc4\xe5\xe7\x89\xa2\xdd\xeb\xf3\xc9\x76\xc6\x74\x09\x32\x01\xbb\xad\x36\x69\x07\x9d\x25\xff\x0f\x1e\xac\x76\xaf\x14\xce\x22\xb7\xe2\x66\x48\x17\x2d\xe4\x80\xc1\x6d\xd6\xac\x18\xfb\xe1\x0b\x27\x1b\x78\x5e\x2b\xc7\xdf\x5a\xb5\x63\x82\x0d\x9f\xf1\xd7\x59\xaf\x7e\x06\x05\x07\x9b\xe6\xcd\x6f\xfa\x1c\x3b\x51\x0a\xc2\x7b\x5a\xfe\xb5\xef\x64\xf1\x03\xf5\xee\x05\xf9\x0d\x93\x20\x0a\x58\xdb\xf8\xcc\x43\x8f\x3d\x43\xe3\xde\xb5\x09\xac\x16\xbc\x17\x45\xd0\xd0\x44\x2e\x67\xa5\x45\x29\x2c\x84\x49\xa8\x12\x92\xb2\xb3\xdc\x81\x9a\xa4\xdb\xcd\x85\x89\xfa\x14\x10\x2d\xb5\x49\x31\xd2\x89\x77\x57\x3e\x6c\x08\x69\x3f\xb6\x08\x34\x4a\x03\x68\xe9\x2c\x42\xad\x64\xc9\xdd\xe9\x1a\xf1\x07\xdf\x87\xba\xf6\x2b\x70\x48\xbb\xac\xb1\x69\xf1\x6f\x5b\xc0\x0a\x41\xed\xd3\x5f\x89\xc2\x3f\x1b\x38\xdc\xe3\x0b\xed\xab\xbc\x8e\xd6\xdd\x50\x7c\xce\xd1\xc7\xfe\xfa\xfb\x32\xed\x1b\xed\x17\xb8\x42\x5b\xd7\xd2\xc6\xf6\x9a\xe1\xa3\x70\xa0\x81\x89\xa8\x88\xb1\x03\xd9\x04\x07\xef\x94\xd8\x4d\x56\x02\xb2\x51\x0f\x85\x8d\x43\xd0\x79\x1c\x76\xca\x82\xd3\xaa\xa0\xc6\x62\x93\x9f\x5a\x6e\x5c\x87\x1b\x1f\x6f\xff\x88\x1f\x7b\x18\x66\x1d\x86\xcb\x0f\x9f\x68\x36\xee\x2f\xbd\x81\xf0\x51\x91\xd0\xff\xa8\x44\x81\xca\x71\x52\xb6\x85\x06\xc1\xf8\xa3\x39\xd9\xd9\x6e\x9b\x42\xc6\x53\x14\x37\xd1\xde\xc8\x78\xbc\x1b\x65\x30\xa8\x8c\xfa\x98\xe9\xbd\xd0\x59\xb7\x88\x6c\xe4\x78\x0e\x91\x22\x64\x13\x78\xd2\x85\x77\xaa\xe2\x8c\x63\x59\xf0\x37\x7f\x7e\x46\xea\x18\x28\xbd\xa0\x8d\xbf\x05\x5e\x85\x7e\x30\x71\x93\xb6\xf7\x9d\xf7\xb4\xfd\xeb\x6d\xdc\xb7\xbe\x96\x07\x16\xdc\xdb\xfb\xfd\x0f\xdf\x78\x75\x2f\xd7\x08\x53\xb4\x5b\xb4\x6d\x9f\x6b\x4f\x3d\xb9\x1d\x46\x7d\x79\xfe\x90\x47\x5f\xbc\x72\x1a\x9d\x9f\x89\x84\x0e\xf7\x09\xf7\x10\xfe\x9a\x24\xfa\x57\xd0\x2a\xbb\x5c\x79\x56\x2e\x37\x2f\x9b\xcb\xe3\x8a\xfe\x3f\xd6\xde\x03\x3c\xaa\x6a\xfb\x1b\xde\xfb\xec\x53\xa6\x9f\x39\x33\x73\xe6\x4c\xcd\xb4\x4c\x0a\x21\x04\x12\x42\x08\x75\x04\x04\x44\x20\x05\x10\x46\x44\x8a\x08\x0a\x4a\x51\x69\x0a\x22\x88\x08\x28\xa2\x88\x15\xc5\x82\x22\x2a\xa2\x08\x22\x2a\xa0\x57\xbd\xa2\x22\x0a\x72\xb9\x7e\x62\x57\x94\xeb\xc5\x7a\x6d\x08\x99\x9d\x6f\xef\x53\xa6\x84\x78\xff\xef\xfb\x7f\xde\xc7\x67\x00\x93\x99\x39\x6b\xb7\xd5\xf6\x5a\xbf\x5f\x89\x28\x5a\xe3\x71\x60\x55\x88\xd0\x8a\x02\xac\x56\x89\x58\x56\x16\x44\x29\xfd\x60\xbb\xc2\x17\xb8\x02\x7a\x9e\x97\x26\x07\x8a\x69\x8f\x17\xf9\x83\xe2\x05\x29\x9c\x6e\xc0\x74\xb4\x53\x2d\xdf\xcb\xb3\xcc\x35\xc4\xe2\x6f\x5e\x87\xff\x05\x7d\xc7\x8f\x42\xd7\x00\xfc\xeb\x39\xff\xbc\xec\x9a\x5b\xef\xea\xd9\xf3\xf1\x07\x96\x2f\xf9\xee\x02\x68\x1a\x80\x3f\xf0\x7c\xf9\xea\xb2\x2d\xde\x41\x99\xcd\x87\x5f\x79\xab\xf7\xf7\x13\xc6\x4e\x9e\xf0\x55\xfa\xe2\x89\xd3\x33\xe3\xfe\xae\x62\xed\xc3\xd6\x1d\x24\x96\xa2\x5c\xe0\x2e\x72\xc2\xe3\x16\x11\x72\x9c\x28\xba\x10\xf2\xb8\x05\x9a\x90\x22\xcb\x2c\x58\x26\xa4\x59\x56\x70\xaa\x4b\x80\xf4\x4e\xb5\xfa\xaa\x8a\x8a\xc2\x13\xae\x35\xdb\x3a\x63\x1a\xd6\x85\xea\xc4\xe8\x4c\xe0\x8f\x0f\x19\x3b\x20\x78\x56\xad\xc1\x07\xfe\x11\x9e\xe7\xf9\xd8\x3e\xac\x81\x7b\xf2\x18\x9d\xcf\xcd\xe4\xf9\x66\x6e\x2b\x50\x88\x3f\x5b\x65\xb5\x99\x14\xc1\x62\x71\x3a\xec\x76\x9b\x62\x53\x7c\x7e\x8b\x43\x74\xcc\x49\x0b\x40\xec\x2c\xa6\xc4\x46\x91\xb5\x22\x32\xc3\x1e\x0f\x9a\x93\xf6\x08\xd6\x60\x8e\x1a\x96\x02\xd3\xe5\x5d\x0b\x64\x6f\x63\x73\xc6\x4a\x84\x35\x42\x02\xc5\xdc\x89\xba\x9a\x3a\xf5\xda\x48\x41\x5f\x38\x53\xde\xb3\xea\x6d\x9e\x7f\x14\x1f\x39\x8d\x8f\x9f\xde\x90\xdc\x10\x0c\xec\x7c\xb0\xc3\xb4\x38\xfb\x19\x67\xeb\xd7\x7b\xfa\xde\xd3\x22\xfb\xf3\xde\x1b\x6f\xbf\x45\xb2\xe7\x6c\xeb\x64\x62\x5b\xcb\xc1\xc5\xa9\xda\x40\x34\x6a\x72\xa3\x52\x07\x32\x39\x38\x13\xaa\xe8\xe0\x76\x4b\xb1\x98\x55\x52\x97\x3e\x34\x31\xad\x48\x59\x5e\xf3\x62\xa2\xc7\x75\x56\xf3\xc2\x4d\xd0\xd6\xd2\xb6\x65\xe8\x3a\x93\xde\xbc\x8d\x85\xfd\xef\x5c\xe7\x1f\xae\x33\xac\xec\x5f\x52\x9e\x0f\xee\x69\x18\xda\xa3\x59\xee\x73\x06\x38\xf0\x68\xce\xa6\xf2\x68\x16\x11\x2f\x27\x86\x58\x08\x24\x86\x93\x59\x87\xcb\xe4\x77\x00\xd6\x61\x62\xa3\x11\x2b\x19\x23\x23\x33\xb2\x15\x91\xc0\xa4\x6f\xf5\xeb\x7a\x37\x8e\x3e\x02\x97\xa1\x09\xdc\x14\x4c\x11\xd2\x58\x42\xc7\x08\xa9\x73\x77\x2d\x29\xd5\x39\xc5\xba\x39\x60\x57\x38\x1c\x9e\x0b\xbb\x60\xdf\x94\xb3\x1e\xbd\x73\xdd\xa6\x9e\x97\x7c\x1d\xee\x52\x29\x5b\x2b\xe2\xf1\x8e\xdc\x92\x96\x0d\x68\xd2\xe9\xd5\x2f\x3c\xdb\xe3\x86\xd5\xb7\x2d\xed\xbb\x79\x0f\x5e\x90\x4c\x9f\xdf\x5c\xdf\x25\xd8\xb9\xb2\x23\xd0\xfa\x2d\xf9\x3f\x89\x4d\x88\x81\x41\xa9\xa4\xc3\x62\xb1\xfa\x50\x38\x6a\x45\x51\x44\x2d\xba\xd3\x5a\x64\x83\x45\xa2\x95\x3c\x99\x92\x81\x80\x60\x63\x96\x17\x40\xbb\x66\x94\x74\xb4\x96\x42\x66\xa8\x92\xde\x30\x9f\xf1\xa7\x26\x07\xe5\x56\x4d\x79\x40\x9d\x5c\xfc\xa7\x6f\x0c\xf6\x1f\xed\x8e\x71\xfc\xf8\x97\xa1\xcf\xf3\xed\x2f\x77\xe6\x53\x00\xd1\x0b\xc6\x1f\x96\x2d\x82\x90\xb9\x3a\x73\x0b\x2e\xce\xd6\x2e\x50\xce\x76\x27\x4f\x6b\x8d\xb4\xfa\x03\xa6\x5e\xd5\xb5\xd5\x29\x1f\xcf\x9a\xac\xd0\x64\x36\xdb\x6d\x82\x95\x56\x1b\x50\xe8\x13\x06\x99\x5d\x79\x69\xce\x82\xde\x16\x0a\x55\x65\xa4\x39\x57\xc2\xd2\x95\x2b\xf1\x87\x2b\x51\x4f\x66\x60\xe6\xc5\x63\x99\xc7\x99\xd1\x39\xae\xf4\x3b\x89\xf5\x1e\x96\x2a\xb3\x40\x37\x62\x25\x97\xcb\x23\x22\xc4\x02\x8f\x87\xf5\xca\x4e\xa7\x04\x21\x2b\x21\xc0\xba\xe8\x29\xa7\x27\x5e\xa0\x80\x5d\xd9\xd2\xbb\x76\xf4\x13\x6d\x69\xd1\x0a\x58\x9c\xb1\xec\x3e\xcc\xa7\x53\x1f\x3a\xe8\xfc\x01\xc1\x9a\xae\x05\xa4\xea\xac\x1d\xae\x24\x87\xbe\xeb\x60\xbc\x3f\x9f\x5b\x5d\xe3\xe6\x39\x42\x96\x65\x78\x2a\x64\x85\x32\xf2\xb0\xc0\xeb\xf5\x50\xba\x62\x37\x11\xd0\xa7\x98\x1c\x8d\x69\x93\xdb\x05\x69\xec\x6e\x4e\xbb\x5c\xac\x5b\x04\xac\x0a\xee\x4f\x6d\xb9\xee\xd9\x15\xc8\x27\xe5\x09\xa8\x9d\x14\xed\x88\xe4\x17\xdb\x3c\x7d\xef\xc4\x51\xae\x73\xe5\xde\x75\x85\x35\x37\xdb\x57\xdd\x2d\xbd\xc5\x09\x03\x07\x61\x90\x25\xf3\x81\x64\xee\x00\x93\x54\xeb\x33\xce\x58\xa3\x26\x6d\x8d\xa0\x59\xfe\xab\x35\x72\xe7\xad\x91\xe7\x1a\xe8\x5f\x44\xf6\xcd\x35\xa8\x07\xb3\x36\x33\xe3\x25\x4a\x33\x4f\xf1\xd9\xc9\x1c\x5c\x42\xbe\x5f\xa4\x3a\x05\x31\x8c\xdd\x01\x59\xc1\x22\x10\x07\xcc\x6a\x33\x9b\x4c\x3c\x6f\x23\x7b\x8e\x78\xa6\xa2\x48\x36\xb8\xcd\xc1\x0a\xcd\x44\x1b\x3b\x18\xb3\x4d\x66\x88\xbf\xd4\x9c\x76\x38\xf5\xe4\x45\x8d\x94\xf3\x6f\xd4\x75\x6b\x13\x66\xba\x74\x8a\xc5\x64\x69\x8c\xe2\xbb\xaa\x28\xa7\xb0\x94\xeb\x06\x43\xcd\xb0\x43\xf2\xb9\x21\x2f\xc1\x23\xf8\x28\xfe\xa3\x15\xe0\x0f\xe0\xdd\x22\x3e\xce\xde\xb8\xe0\x9d\x09\xc3\x9f\x6a\x3c\xdd\x1f\x85\x5b\xbe\x62\xab\x12\xf3\xd5\xf9\x58\xd9\xfa\x9d\x30\x85\xec\xd9\x62\x30\x30\x95\xf0\xc0\x44\x38\x60\x15\x04\x4b\x20\x61\x41\x25\x49\x9b\xdd\xe3\xb1\x16\x9b\x82\xc8\xea\x62\xa3\x4a\x74\x62\xda\xa9\x50\x7e\x66\x2d\x1d\xde\xb7\x46\xe3\xd9\x3c\x83\x42\x2c\x07\x91\x15\x2b\x35\xc0\xb3\x74\xfe\x8b\x2c\x7c\x16\x7b\xd3\xa4\x8b\x67\x2c\x86\xa5\xf8\x7d\x1b\x5b\xff\xc8\xac\x25\x8f\x94\x0b\x83\xb6\xad\x7a\xee\x0d\x58\x3a\x79\xf2\xb4\xa5\x44\x53\x8c\x5d\xb7\xf2\xe9\x95\x68\xd5\xa9\xeb\x36\x5f\x3c\x66\xd2\xd4\x19\x63\x3f\x78\x0b\xfd\xd6\x32\xf6\x8e\x15\x9b\x6e\x40\x77\x19\x76\x4e\xf5\x65\x15\x30\x38\x55\xec\xf4\x0a\x08\xf1\xc4\x3e\x7b\x79\xaf\xdf\x67\x32\x29\x10\x0a\x8a\x43\x9a\x90\x76\xb8\xc9\x4b\x60\x15\x24\xa8\x58\xb2\x6d\xd5\x73\x7d\x81\x7a\x36\x6b\x64\xed\x2a\x75\x7b\x16\xe5\x89\x08\x0b\x8f\xaa\xb4\xed\x78\x53\xe6\x5e\xd7\x9a\xc7\x34\xeb\x97\x63\x6f\x57\xd9\xdc\x57\xef\xdb\xea\xf9\x86\x1a\xc1\x87\xb4\x1a\x8a\x31\x6a\x0d\x85\x02\x6a\x53\x01\x1b\xe5\x15\x51\x14\x93\xdf\x47\xa2\x4b\x93\x55\x34\xc9\x20\xe8\x46\x8d\x69\xb7\xb1\xd0\x79\x28\x53\x59\xdb\x9b\x2d\x8c\x68\x8f\xac\xc8\x94\xab\x87\x20\x0f\x12\x8c\x4a\x88\x55\x97\xe8\x85\x10\xa7\x1f\x37\xea\x07\xb8\x3b\x5d\x3c\x7b\x8f\xe1\x6f\xf3\x07\x89\xee\x90\x89\x76\x6d\x4e\x79\xdc\x2e\x00\x9c\x8c\x17\x85\x2c\xc8\x92\x88\xbb\xdd\x82\xc7\xc9\x50\x20\x5e\x17\xf1\x5a\x05\x0f\xb2\x93\x78\xc5\xce\x0a\x24\xac\x14\xdc\xed\x39\xdc\xb9\x88\xc5\xe8\xcc\x73\x0a\x4a\x3e\xd9\xbc\xd2\xad\x36\x41\xdb\xab\x72\xbc\xe8\xfc\xc1\x9f\xd9\x02\xd2\x79\x09\x5e\x52\x77\xcd\x22\x28\x64\xbe\x31\x98\xe7\xd9\xa7\xf1\xdf\xd2\x8d\x05\xec\xf3\xa7\x7e\xee\xfb\x00\x64\x33\x03\x0b\x29\xe8\x35\x2e\x26\xee\x19\xe2\x7f\xd3\xde\xb0\xb3\x53\x71\x97\x04\x80\x18\x30\xcb\xc4\x9f\x30\xc7\xa2\xa2\xe8\x76\xb9\x78\xb7\x68\xf3\x35\xa4\x6d\x4e\x3e\x9c\xeb\x32\x35\x20\xb5\xeb\xdb\x38\x9a\x5a\x5f\xbe\x40\xd1\x90\xda\x8c\x20\xdb\x58\xca\x3d\x73\xf3\x9d\x0a\xfe\xfc\xdf\xfa\x0d\x3c\x09\x0f\x64\xeb\x3a\x2a\xff\x1e\xed\xea\x7d\xd9\x62\x74\xc9\x93\x87\x4a\xbe\x3c\x99\xa5\x6c\xfa\xe3\x54\xf7\xed\x44\xf8\x63\xda\x7d\xfb\xf3\x40\xe7\x42\xe2\x97\x92\x75\x90\x40\x08\x8c\x48\x75\x04\x92\x83\x38\x67\x01\xb3\xd9\x23\xa1\xa2\x30\xe0\x1d\x0e\xde\xc6\xc8\x36\x79\x42\x5a\xb4\xd9\x94\xf1\x69\x1b\xcb\x7b\x26\xa4\x79\x12\x9d\xf1\x6e\x5d\x93\xe7\x2e\xc8\xc8\x42\x38\xdf\x68\x8b\x2e\x20\x25\xa4\xbc\xda\x89\x64\x8d\x04\xab\xeb\x24\xbd\x6e\x82\xbb\xe4\x95\x81\xdf\xce\xc2\xcf\xe2\x7b\x68\xd4\xbe\x6f\x13\xdc\x7b\x4e\xcb\x3d\x7d\x6a\x7b\xf5\xd9\x77\xf0\x08\x91\x6b\xe0\xe9\x9d\x1d\x7b\xc2\xeb\x48\xc4\x4e\x62\xf6\x11\xc3\x4f\xbe\xc1\xcc\x77\xa0\x7d\x62\xcb\x4f\xbf\xe2\x16\x75\xce\xc9\x99\xbb\x88\xcc\x39\x95\xfd\x9c\x54\x89\x15\x00\x4f\x80\x17\x1d\xbc\xc7\x41\x64\xb7\x5a\x91\x59\x0c\xda\xa4\x46\x32\xe3\x66\x45\x65\xc4\x72\x15\xe6\xcc\xb4\xa4\x70\x1b\xbf\x88\x78\x45\x54\x39\xe4\xc4\x4d\x48\x89\x9c\xc4\x5e\xb4\x37\xb5\xf3\xe2\x3f\x49\x34\xa9\x40\x66\xcf\x4d\xf0\xe2\x61\x99\xcd\xf8\xd1\xaa\x0e\xf1\x0e\x4b\xe6\xcd\xeb\xdf\xa1\x12\x96\x43\x33\x89\x86\xca\xc6\x8c\x39\x65\xe6\xbc\x99\xbe\x36\x66\xbf\xe5\xd9\x3d\x3b\x77\x03\x23\x26\xe7\x32\x2a\x1e\x75\x11\xd1\x12\x09\x46\x10\xe4\xa0\xc7\x23\x2b\x0e\x87\x1c\x8d\x70\x9c\x6c\x09\xba\xc7\xa7\x83\x41\x8b\xec\x0a\x00\x0b\xa0\x30\x35\x06\xde\x5a\x3b\x3b\x3d\x57\xbc\x94\x8b\xcb\x29\x57\xbe\x8e\x33\xc1\xe9\xb9\x54\x78\xbe\x1e\x98\x3f\x94\x81\xd2\xa2\xe3\x1b\x28\xd8\x04\xba\x10\x9f\xa2\x28\x13\x57\x2f\xcb\x85\xe6\xdf\x1e\x59\xf9\xcf\xab\xb0\x93\x7d\xf2\xfb\x4f\x71\xdd\x02\x4d\x5e\xad\xdf\xf1\x08\x91\xb6\x0c\x8c\x4a\x55\xfa\x8b\x89\x0b\x14\x01\xc4\xcb\x44\x1d\xca\x05\x21\x14\xf0\xfb\x51\x48\x74\x37\xa6\x45\x2f\x79\x85\xac\xc1\x10\x89\x8f\x43\x4e\x54\x5a\x38\xcd\x39\x25\x77\x66\x58\x5c\x48\xf6\xa5\x62\xfa\xaa\x06\x35\x0c\xdb\xe1\xfc\xba\xea\xc9\x72\xda\x06\xf9\xf4\x7d\x5d\xae\x56\x88\x7d\x5d\xae\x27\x28\x49\x7c\x3c\x77\xa6\xce\xfb\x35\xe5\x7c\xda\x0c\xc9\x5f\xb0\xf2\x1e\x1b\x77\x98\x13\x6e\xf8\x79\x1f\xfe\x8c\x9c\xd1\x3c\xee\xaf\x95\x78\x27\xd7\x53\xc5\xb2\x52\x88\xde\x29\x73\x40\xab\x87\xe8\x17\xc4\x3a\xad\x14\x56\xd3\xca\xfa\x7d\x80\x15\xc8\x32\x90\x58\x91\xf3\x30\xe3\xd3\xc4\x4f\xe0\x10\xab\x7b\x49\x79\x8e\xf5\x1b\x6d\x16\x42\x8f\x9b\x89\xd1\x33\x40\x3e\x68\x92\xdb\x9c\x4d\x69\xb7\xe0\x9d\x18\xab\x38\x1f\x75\x2d\xd0\xb5\x79\x0d\x5c\x84\x6f\xc3\x2d\x24\xb8\x8a\x2e\xbc\x0e\xef\x64\xb6\xe1\x7b\xb8\x25\xcf\x7c\xb8\x7f\xdd\x07\xf1\x8c\x97\x9d\xbe\x1f\x4f\xd0\xf1\x19\xa9\x5e\x09\x92\xf3\x59\x41\xec\x61\x3c\x06\x9c\x92\x04\x4a\x4a\x4b\xad\x24\xfa\xab\xec\xe8\x74\x7a\x4a\x4a\xca\x3d\x1e\xfb\xc4\xb4\x87\x2d\x4f\x8c\x4f\x97\xff\x55\x4e\x30\x6f\xbf\xb8\xbb\xf6\x61\xeb\xfa\x90\x98\x35\x46\x71\x17\xba\x15\xc7\x68\x3a\xde\x81\x44\x48\x31\xd8\x28\x8c\x3c\xc7\xc4\xa2\xc5\x8d\x15\xe7\x4e\x99\xbb\xb4\xdf\x13\xb3\xeb\xf1\xaf\xd7\xde\xe8\xc5\x5f\x96\x40\x2b\xd9\xda\x22\x0c\x96\x0d\xbe\xf8\xba\x3b\xd7\x5c\x3d\x17\xd6\xde\xb1\x39\x0c\xc3\xe7\x65\x3e\xc3\x1f\xe2\xc3\xf0\xce\xe6\xf9\xa3\x7b\x75\x28\x12\x8b\xbb\x0c\xaa\xdb\x7c\xc1\xd8\xd2\xdd\x8f\xbe\xf9\xea\xf0\x2b\x47\xf5\xee\x94\x88\x85\x2e\x1c\xbc\x7b\xf2\xec\x2a\xbc\xe8\xa8\x16\xe3\xb0\x15\xc4\x16\x95\x82\x54\x2a\x16\x8b\xc7\x05\x8f\xdd\xe1\x08\x12\xb5\x59\x5e\x26\xd8\x63\x41\x36\x29\x25\x8b\x9a\xd2\x49\xaf\x64\x69\x4a\x4b\xce\x7c\x3c\xdc\xfc\xa1\x18\x23\x81\x49\x03\xa8\x24\x8b\xf8\x99\x8f\x26\xa7\x82\x45\x17\x8f\x4c\x3f\x01\xc1\xd8\xa1\x93\x27\x4f\xb9\xd0\xf6\x67\xf8\xc7\xd7\x3e\x3c\x71\xfe\xd6\x2f\x2f\x1d\x7d\xf9\x9c\xc5\x97\xc8\x7f\x94\xfc\xf4\xc5\xe7\xad\x00\xf6\x9a\x7c\xfd\xc8\x5a\x57\xf7\xaa\x5e\x35\xfd\xce\x0a\xac\xbe\xeb\xc9\xfb\x27\x2c\x6d\xac\x94\x7b\x77\x3d\xab\x67\xdf\xe1\xc9\x75\xb7\x68\x7d\xb5\xe7\x13\x5f\x6a\x0d\xcd\xb1\x21\x0d\x23\xd9\x87\x47\xa3\xee\xdc\xfb\xe4\x3c\xc7\xc1\x90\x94\x23\x2c\xd9\x05\x41\x52\x88\x3a\x2a\x4e\xa0\xe8\x2e\x18\xd9\x99\x46\xc4\x1d\x76\x05\xc8\x3f\x53\xf6\xb4\xcb\x29\xda\xc8\x39\x31\x93\x57\xd0\x50\x9d\xda\xf1\x68\x93\x07\x57\xaf\xa7\xa8\xcd\xa7\x43\x90\xf9\x44\xd4\x0f\x69\x70\x93\x0f\x91\xef\xbb\x76\xfa\x63\x8f\xcd\x73\x0f\x73\x0d\xb8\x02\x3f\xdf\xb1\x6b\xfa\x92\xf9\x35\xc5\xc5\xd5\xd5\xc5\xc5\x35\x1c\x7f\xe1\x8c\x57\xf7\x9e\x9e\xb6\x5a\xe0\x0e\x4b\xf0\x1c\x76\x9b\x77\xd6\xd8\xb2\xaa\xaa\x32\xf2\xd2\x6a\x11\xb4\x5a\x15\x72\xa6\x47\xa6\x3a\x20\x45\x11\xc3\x26\x0b\x6f\x97\x24\x5e\xe4\xa3\x11\xaf\x17\x59\xcd\x4e\x93\xd9\xd4\x90\xb6\x9b\x45\x8d\x41\x30\x00\x1a\xd3\x81\xbc\x6c\x91\xe6\x6e\x39\xdf\x68\xe3\xff\x19\x01\x4e\x75\x6f\x9a\x31\x6a\xcb\x7f\x66\xf8\x2f\xb0\x78\xee\xbc\x25\x39\x1a\xb4\xbb\xef\x1b\x3a\x76\xf0\x47\xab\x7b\xa1\x1b\x97\xe7\xb1\xa1\xe1\x37\xd7\x3c\xe8\x79\x4b\xcc\xd5\x50\xd3\x7c\x91\x13\xd4\xa4\x7c\x44\x63\x8a\x36\x5a\x01\xea\x92\x38\xce\x22\xba\xec\x67\xaa\xc9\x1c\xae\x7d\x5b\xe5\x28\xab\x35\xf1\xaa\x3a\x7c\x6c\x1d\x5a\x8b\xbb\xe3\x0f\xd9\xfb\x27\xa8\xea\xef\xda\x75\xc7\x4e\x5f\xc4\xde\x6f\xd4\x6a\x6c\x20\x3a\x2f\x0a\x1a\x52\xa5\x45\x0e\x85\x13\x90\x4c\xf4\x9c\x82\xe2\xb1\xa2\x22\x40\xc2\xed\xc6\xb4\x95\xf7\xa9\x55\x1a\x32\x2f\x82\x50\x1e\x1b\x9c\x36\x31\xaf\x9f\xa9\xa8\xb3\x25\x19\xb5\x79\xa4\xbb\x3a\x7f\x43\x5b\x8a\xb8\xe5\xd9\xe8\xa1\x80\x29\x6e\x81\x11\x3c\xa4\xb2\x8c\x71\xd0\xa8\x4f\x22\x1b\xae\x6b\x2a\x88\x2c\x1c\xe0\x9c\x4e\xb7\xcb\x6e\x22\xbe\x12\x09\xb7\xec\xc4\x35\x81\x64\x7a\xa0\x31\x3d\x9a\x22\x36\xa8\xea\x34\xba\xd3\x98\xf1\x70\xd5\x1f\x56\xd8\x9d\xb8\x7b\xb7\x54\x70\xc0\xd8\x21\x4f\x3d\xc1\xde\x7f\xec\xd8\xe9\xfa\x86\x61\xf6\x8f\x3d\xbb\xdf\x62\xff\x46\xbe\xeb\x1a\xe2\xb3\x6d\x24\xcf\x0b\x92\xdd\xee\x76\x49\xb2\xec\xb0\xfa\x79\xe4\x47\xe1\x90\xcb\x45\xc2\x76\x1f\x75\xd8\x1c\x69\x87\x03\xb8\x6d\x2c\x02\xa6\x5c\x56\x4a\x75\xcd\xcf\x74\xd5\xb4\x69\x89\x02\x35\xf0\x8d\x69\x3e\x3a\x39\xcf\xc4\xcd\x51\x81\x7b\x9d\x80\xd9\x8f\x3f\xc7\x07\x89\xce\xec\x72\xff\x23\xb0\x74\xfa\x95\xc4\xbb\xd9\xb2\x1b\xbf\xe8\x81\x3e\xe2\x72\xce\x6e\xd9\x84\xb7\x3c\xf7\x38\x6a\xc4\xc0\x71\xfd\x74\xc8\xbe\xbf\xfb\x93\xf0\x51\xfc\x0b\x3e\x0a\x74\x2e\x3d\x6e\x3f\xdb\x83\x9c\xcc\xb1\xa9\x80\xdd\xe6\x74\x9a\x3d\x3e\x9e\xf7\xc0\x98\x27\x56\x9c\xb0\xdb\xe3\xc1\x50\xc8\x17\x37\xbb\x69\xe4\xe7\x4c\x9b\xcd\x3e\x87\x10\x17\x7d\x72\x11\x71\x84\x8b\x8c\xeb\xda\x7c\xa9\x6b\xda\x3a\xe8\x46\x70\x61\xf0\xea\xe5\xc9\xed\xf1\xd2\xfc\x6e\x69\x82\xcf\xe7\xd8\x9b\xb1\x98\x08\xff\xe2\x1e\x0e\xe1\x5f\x89\x8b\xcc\x4d\xff\x39\x9f\x6c\x2f\xf3\x87\xed\xa6\x19\x64\x04\xaf\x1f\x0d\xec\x1d\x3d\xb3\xa3\xff\xd6\x4e\x27\xfe\xb1\x5f\xe3\xdd\xbb\xb4\xf5\xdf\xc4\x79\xbb\x0e\x24\xc1\xa0\x54\x71\xc4\x2f\xd8\xfd\x76\x36\x14\xb7\x38\x59\x6f\x3c\xce\x96\x96\x44\x84\x30\xb2\x58\x2d\xe3\xd3\x01\x2b\xa2\xc5\xae\xd9\x19\x27\x2b\xae\xd4\xe4\x27\xf2\x5d\x06\x9c\x2a\xa7\x41\x85\xd7\xf1\x09\x9a\xfa\x31\x74\x25\x45\x7e\xa2\x76\x2b\x5e\xaa\x21\x8c\xa1\xda\xf7\xf0\xbe\xcd\x87\x3e\xb9\xae\x17\xfe\x0f\xb3\x6a\xe3\x23\xef\xef\xda\x75\xf8\xa1\x8d\xcc\x32\xfc\x6b\x8f\xeb\x3e\x3c\xb4\x19\xef\xf3\xde\x01\xe5\x17\xf6\xc3\xb2\xa9\xd6\x63\x78\x7f\xe3\x17\x0f\xbe\xf9\xf9\xe7\x6f\x6e\xf8\xaa\x11\xd6\x1e\xb3\x4e\xc5\x1f\xee\x7f\x1e\x7f\x7b\x27\xd0\xf6\x0c\x37\x80\x5b\x07\x02\xa0\x5b\x2a\x64\xe6\x65\x27\x09\x48\xf9\x50\x50\x40\x3e\xe2\x53\xfa\x88\xc4\x3e\x16\xd9\xc6\xa7\x91\x61\xb9\xda\x00\x25\x68\xf8\x16\xda\x16\x51\xe5\x74\xa9\x25\xe7\x2a\x29\x90\x97\x1b\x80\xb7\x13\xf7\xfd\x67\xfc\x19\x2c\xbd\x61\xd9\x8a\x07\x86\x8e\xbe\xa0\x62\xc0\xf9\xb7\x3c\xf9\x1c\xda\x85\xa3\x38\xbb\x4b\x1e\x7d\xfa\x4e\xd8\x0b\xb2\xcb\x97\x92\x9d\xfc\x8b\xce\xa5\xcd\xbd\x47\x6c\xaa\x8b\xc6\xdc\x2e\xc9\x21\x4a\x22\x8f\x3c\x6e\xb3\x59\x22\xfa\x9b\xf8\xed\xac\xc4\x8a\x3a\xd7\x47\xee\x4e\xc7\xc8\x38\x41\xb7\x7a\x77\x23\xa8\x46\x07\xaa\x6d\x36\xcc\x13\x3f\x77\x5f\x34\xea\xfe\xd5\x97\x0f\xec\x91\xac\x09\xe2\x83\x24\xce\xb5\xc0\x5a\x54\x09\x9f\x98\x3c\x76\xc9\x0b\x7d\xca\x3a\x66\x5a\x32\x7b\x99\x7e\xa8\xaf\xc6\x97\xc6\xdd\xae\xea\x97\xee\xa9\x60\x50\x66\x18\xc5\x2b\x7a\xe3\xb1\x60\xd0\xe6\x55\x99\xd2\xbc\xa2\xea\xb2\xea\x0a\xb7\x8d\x32\xa9\xd6\x72\xf3\xd9\xa7\x53\xf3\xa6\x45\x85\x7d\x55\x02\x41\x97\x52\x17\x84\x7d\x20\x7b\xff\xb5\xf3\xc7\x77\xef\xd6\xb1\xc6\x89\x2f\x1e\xb6\xf7\x4e\xca\xe2\x35\x66\x52\xd2\xa5\xb2\x78\xd9\x86\x5b\xcd\x4d\xef\x77\xbc\x83\x3b\x32\xe4\xf5\xe2\x9e\x55\xa7\x07\x1e\xd8\x68\x7f\xd3\x34\x62\x72\x67\xca\xe5\x15\xc7\x99\xf2\x24\x4c\x32\xb7\xdd\xbc\x88\xce\x53\x57\x5a\xe7\xa1\xea\x97\xb3\x53\xc5\x66\x86\x28\x3f\x51\x44\xbc\x8d\x75\xbb\x2c\x12\x90\x26\xa6\x05\x00\x1c\x2c\x8b\xc6\xa7\x59\xe4\xb0\x8e\x4f\x3b\x0a\x13\xf6\x6d\xaa\xe6\xd4\x64\x9d\x41\xe6\xa5\x62\x75\xd6\xc2\x58\x57\xf8\x1b\x74\x64\x9a\xd1\xef\x74\x09\x71\x1f\xfc\x2a\x4a\x9c\xbe\x03\x36\xe1\x4d\xa8\x3f\x1c\x7d\xfc\x00\x5e\xf3\x77\x7c\xe9\xf1\x43\x6a\x79\x0f\x91\x27\x05\x00\xda\x47\xce\xb4\xa4\x7a\xfb\x0e\x86\x37\xdb\x00\x72\xe4\x24\x6a\x36\x24\xa2\x44\x63\x0e\x6b\x63\xda\x21\xff\xa5\x44\x59\x63\xab\x72\xb2\xc8\x42\x8d\x1c\x13\xa8\x4c\xee\x44\x0a\x5e\xf0\x3a\xb6\xa3\xf2\xfd\x1f\xe2\x07\xf7\x31\x43\x5a\x16\xfd\xf3\x28\xb3\xe0\xf7\xfd\x6f\x9d\xdc\x76\xfa\xc0\x3e\x08\x89\x1c\x01\x3c\x9c\x5d\xaf\xea\xc1\x01\xa9\x62\x59\x94\x58\xe4\xf4\x78\x2c\x3e\x24\xfa\x88\x2a\xa4\x7d\x14\x0e\x79\x62\x9a\x75\xb0\x0e\xe0\x72\x49\xe3\xd3\xae\x6c\x56\x9b\xe6\x30\xdb\xe2\x62\x51\x23\x95\xbb\x9d\xa5\xac\x5b\xda\x24\x79\x01\x3d\x86\x4c\xd3\x07\xf8\xc4\xb9\x90\xe9\xb6\x66\xea\xed\x0f\xec\x7f\xf3\x3a\xf8\x50\x66\x38\x1b\xc0\x25\xbf\x42\x69\x0d\xfe\x15\x0f\xdf\xf9\xb7\x8b\xaf\x9f\xfd\xea\xf3\x4f\x6c\x3f\x0e\x1f\x23\xf3\x55\x69\xc3\x9f\x9c\x7c\x09\x7f\xa3\xe6\x24\xc0\x60\x22\xe7\x5b\xaa\x9c\xfd\x53\xc5\x36\x93\xc9\x85\x04\x87\xcf\x4f\xd6\xca\xcf\x12\x39\xe5\xf1\x69\x51\x98\x98\xf6\x89\x3e\x11\x98\x29\x66\xab\xb9\x5d\x39\xf3\x2e\x94\x81\xd4\x95\x52\xc4\x51\xb3\x91\xbb\x2a\x50\x2f\x68\x99\xb5\xf8\x07\xfc\xe6\x75\xff\x5e\x8f\x4b\xd8\x40\x66\x38\x7c\xe8\xba\xb7\xde\x7e\xe0\xf6\xa9\xb7\xd6\x42\xe6\x5c\x7c\x02\x0f\x87\x03\xa0\xb2\xb9\x65\xb5\x00\x0f\x1f\x38\x8e\xd3\xc7\xb7\x3f\xf1\xfc\xab\x57\x2c\xbd\xf8\x6f\x3b\xb5\x75\x2d\x23\x72\xc6\xc9\xba\xfa\xc1\xb9\xa9\x12\x97\xc3\xe1\xb3\xd8\x3d\x88\xb5\x78\x24\x96\x0d\x06\x10\x12\xed\xb2\x2c\x88\x0e\x97\xe8\x22\xae\x93\x28\x80\x86\xb4\x10\x6a\x53\x6d\xd2\x36\xb2\xd0\x5c\x11\x1d\x4e\x18\xd0\xb4\x70\x9e\xd4\x4e\xa6\x7e\xf4\x95\x16\x28\xfb\x70\xe6\xe0\xaf\xf8\xeb\x4f\xdf\xc6\xeb\xd0\xf2\xcc\x7e\xd8\x38\xe5\xf9\x87\x7f\x1e\x3f\xcd\xbe\x73\x1f\xe4\x3f\x7b\xf3\x3f\x1e\x38\xf7\xb5\xfd\xf8\xbe\x3d\xb7\xad\xc7\xdf\x6b\x72\xd6\x11\x39\x45\x22\x67\x07\xe2\x1b\x94\xc9\x7e\x6f\xb1\xe0\xef\x00\x1c\xe1\x00\x89\x20\xc2\x80\xed\x58\x61\x89\x77\x88\x07\xdc\x6e\xe2\x55\x91\x80\x48\x11\xd5\x40\x28\x54\xb8\x03\xeb\xf3\x79\x1c\xf2\x38\x63\xa9\x9c\xda\x4d\x9b\x0a\xbd\xd7\x09\x66\xf7\x01\xcd\x6d\xe7\xfb\xb4\xac\x18\xc7\x5f\x7d\x78\xdd\x81\x2b\x27\x6c\x7f\x71\xc6\xd4\xea\x69\x9b\xa6\xc0\xaa\xcc\x37\x68\x39\xde\x74\xf0\xb9\xf4\x33\xef\xcd\xbd\x78\xc6\xe4\x49\x57\x5b\x2f\xba\x6f\xfb\xd0\x35\x93\x47\x2f\x6e\xec\xe0\xeb\xdd\xb1\xb2\xca\x73\x2b\x94\xf6\x6f\xc4\x1f\x72\xcb\x6f\x6a\x9a\x37\xb2\x3a\xdc\xbb\xbc\x7b\xbf\x0b\xc6\xa8\xf8\xef\xe4\x8c\xc7\x88\x2e\x8c\x50\x96\x0f\x93\xd9\xac\x04\x7d\x2e\x44\x1c\x54\x11\xc5\xa2\x26\x53\xc0\xe6\x89\x80\xc8\xc4\x34\xd1\x8a\x01\x9b\x8d\xa3\xf1\x7f\x40\x21\xc6\xa6\xdd\x93\x9e\x2b\xf7\xc9\x8e\xcb\x1d\xeb\x46\xd9\x06\x74\x80\x37\x4a\x37\x40\xcf\x19\xaf\x9e\x34\x0a\xfd\x7c\x1e\xfc\xf3\x81\x17\xce\x1f\xef\xc0\x5f\xfb\x7e\x3b\x7c\xec\xd7\x29\x33\xf0\xfb\x97\xec\xee\xc4\xdc\xd2\x52\xd2\x61\xd5\x5c\xfc\x35\xd3\xb2\x7a\xce\xae\x89\x13\x9d\xaf\xbf\x7b\x70\xf7\x4d\xd7\xbf\x3c\x6a\xdd\xe5\xc7\x5f\xbb\x60\xfb\x74\x2a\x77\x6f\x12\x47\xd4\x92\xbd\x1d\xa0\x6b\xc1\x78\x4c\xac\x2f\x20\x92\x9d\x63\x42\xa1\x20\x89\xe3\x00\xeb\x23\x5a\x89\xb5\x02\x14\x00\x01\x62\x15\x91\x7a\x53\xe6\xfe\xaf\x35\x4a\xd9\xab\x5a\x5a\x1e\x53\x43\xa3\x22\xad\x6e\xc2\xf0\xba\x63\x52\x62\x20\x3a\x92\xf9\xbe\x18\x42\x68\xc2\x27\x31\xd1\xf3\xa7\xfd\x30\x50\xb6\x63\xfe\xb4\xf9\x37\xe3\xaf\xb6\x72\x4b\x8e\xfd\xf0\xaf\x2f\xfe\xc4\xad\x6f\xef\xb4\x6f\x5d\xbc\x6c\xd1\x02\xf8\x21\x91\x53\x6a\xfd\x0e\x6d\x53\x31\xb4\xc9\xfc\x32\x42\xc0\xce\xfa\x3c\x82\xc3\x6e\xf7\x09\x44\x52\x87\xc3\x42\x24\x6d\x22\x92\x5a\x54\x49\x89\xfe\x17\x2d\x52\x5e\x49\xca\x7f\xad\xa6\xca\xc9\x2a\x69\x34\x08\x59\x25\x42\x65\x2d\x42\x23\xf1\x59\xd5\xf0\x9d\x1f\x3f\x79\xf1\xd7\x12\x28\xba\xa6\x8c\x49\x9f\x3f\x7d\x01\xc6\x0f\xb0\x3d\xf6\xef\xc2\x77\x3f\xfe\xe2\x53\x0f\xb9\x46\x0c\x1b\x3e\xea\xc2\x26\x38\x9b\xc8\x49\xfb\x87\x47\x91\xb8\xa0\x84\x46\xc5\x2e\x50\x56\x6a\x32\x47\x5c\x7e\x9f\x0f\xf0\x66\x88\xcc\x20\x62\xf6\xfb\x65\x96\x31\x43\x06\x36\xa4\x79\x46\x94\x43\x4d\x69\xb9\xd0\xf1\x55\x23\x82\x7a\xda\x0b\x58\x93\x9f\x2f\xa7\x16\xcb\x9d\xab\x42\x36\xc8\x9a\xce\x24\x76\xde\xac\xc5\x05\xa5\x4d\xab\xb7\xae\x6b\xcc\x31\x3a\xcf\xb9\x7c\xf4\x25\x27\x36\xa7\xd1\x42\x1a\x1f\x0c\x2b\xad\x4e\x44\xcb\x9a\xaf\x1d\xaf\xb3\x39\xf7\x3c\xab\x6b\x6f\xb9\xd3\xe8\x5b\xa7\x67\xf3\x15\x37\xb3\x4d\x24\x56\xf0\x53\x86\x05\x41\x61\x59\x8e\xec\x5c\x2e\x18\xb0\x98\xcd\xbc\x42\xfc\x75\x2e\x68\x77\x53\x4c\x96\xbf\x48\x75\x6a\xee\x06\x47\x23\x05\xaf\x46\x28\x5f\x04\x39\x2d\xf7\xd9\xcd\xc5\xde\x8c\x1f\xc6\x57\xe3\xe3\xd0\x2c\x70\x6c\xcd\xe3\xb3\x97\xee\x1c\x8f\xbf\x3c\x3a\x6b\xe1\xbf\x3f\x66\xee\xc3\x7f\xc7\x13\xef\x7f\x97\xfb\xaa\x76\xe6\xd8\x09\x33\xf6\xdd\x0f\xc5\xa7\x6f\xce\x3c\x35\x5f\x6d\xb7\x20\x73\xfb\x08\xf9\xe3\x1e\x95\xf7\xd1\xf3\xbc\x4e\xd7\x4f\x0e\xd0\x81\x5c\xc7\x78\x8d\xf4\xc8\x6f\x2a\xf9\x3e\x43\x51\x2f\xd1\x30\xf5\xbd\x02\x88\x50\x56\x04\x56\x10\x80\xd9\xc4\x11\x67\x9e\x7c\xa6\xfa\x40\x75\x01\xb5\xb7\xf6\xdf\xd6\x9f\x5e\xfe\x89\x7e\xdc\xe0\xef\x6f\x26\x67\x7a\x2c\xf9\x0e\x37\x3d\x1b\xac\xc9\x66\x83\x92\x5d\x04\x24\x3e\xb0\x73\x88\x1c\x41\x37\x70\x13\xf3\x04\xac\xa2\x53\x9c\x98\x36\x39\xc9\x74\x39\x19\x5a\xbf\xf7\x86\xd6\x77\x7a\x06\xad\x59\x9e\xb3\xee\xd6\x18\x4c\xb4\x7a\x37\x8d\xd1\x24\xd6\x0c\x57\xfd\x06\x57\xe1\xb9\xf4\xf5\x9b\xf6\x17\xdb\x13\xde\x86\x67\x1e\xc2\xbf\x1f\xc2\xb3\xe1\x9a\x43\x2a\x3c\x1d\x89\x9f\x69\xb1\xcd\x71\xb5\x46\x85\x35\xee\xab\x2c\x33\x85\x0a\xa7\x8a\xeb\xe3\x2c\x05\xbd\xb9\x7d\xe4\x6f\xc1\x0c\x04\xd1\xf8\xbd\x79\x11\xf7\x67\xf6\xf7\xe3\xb4\xdf\x33\x2b\xf9\x65\x46\x5f\x9d\xe9\x1e\xf5\xf7\x83\xb4\xdf\xb3\x5f\x69\xbf\xe7\xee\x01\x7a\xef\xbd\xe9\x6d\xa3\x57\xd8\x29\x80\x4a\xfa\x7b\x0d\xbb\x85\xbf\x59\xed\xab\xd0\x7e\x3e\x4c\xff\x79\xae\xf7\xbe\x41\xfb\x39\xed\xbd\xd7\xbe\xc7\xbc\x55\xfd\x9e\x2e\xda\xf7\x50\x39\xb4\xef\x11\x66\xa9\xef\xd7\x7e\x3e\x4c\xff\xf9\x8d\xd9\xef\x6f\x2a\xf8\xfe\x36\x78\xf1\x66\x00\x6f\x03\x79\x78\xf1\x6e\xd6\xed\x6f\x07\xff\xea\xcf\x2c\x3e\xd5\x4a\xf0\x16\xc8\xe1\x95\xd6\xed\x6a\xfd\x78\x47\x5d\x6f\x14\x2a\xe8\x1d\x6d\x83\xbb\x6d\x06\x79\xb8\xdb\x02\x45\x4e\x13\xec\x30\x0f\x8b\xa9\x95\xec\x37\x66\x4d\x1e\x26\xe3\xca\xad\x79\x98\x8c\x02\xcc\x7f\x77\x7b\x18\xd1\x64\x0c\x7a\xcf\x8f\x06\x12\x1d\x02\xa1\x78\x3b\xbd\x8c\x39\x5c\xc0\x95\x10\xea\xef\x57\x4b\xcf\xfd\xc0\x1f\x29\xe8\xb9\x69\x83\x07\x4c\xbe\x7f\x15\xc8\xe1\x01\xcb\xb4\xb6\x5f\x0e\xe6\xba\xa2\xda\xc5\x8b\x5b\x69\xf4\x1c\xa8\x78\x71\x81\x5d\xad\xbf\xef\x08\x44\xbd\xed\xf5\x03\xe4\x9e\x53\xc3\x7c\x4c\x3e\x13\x4b\x59\x11\x2d\x8a\xa7\x0d\x8d\x14\x68\xee\xd4\x8e\x70\x48\x7b\x98\x5e\xb6\x5d\x9b\x7d\x1e\xbf\x46\x7b\x1e\xd9\x77\xd3\xa0\x4f\xef\x43\xf0\xc2\xae\x20\x48\xeb\xea\x83\xc4\x73\x31\x79\x93\x5a\x81\xbd\xfa\x49\x58\xa1\x41\x54\xb6\xf3\xec\xae\x0c\xc5\xed\x2a\x4a\x49\xf4\xa1\x61\xf5\xd9\x45\xa6\x22\x77\xe1\x83\xb3\xcf\x3d\xd5\xf6\xb9\x26\x0c\x2f\x6f\xfd\xea\x7f\xf1\xdc\x5a\xe6\xcb\xec\x73\xf5\x31\x47\x41\x34\xd4\xfe\x73\x55\x4e\x81\x82\xe7\x92\xb5\xb1\xff\xaf\x9e\xdb\x8d\xf9\x57\x76\xae\x23\x11\xf5\xb9\x0a\xdd\x9a\x4a\xd1\x5f\xcd\xf5\x99\x63\xce\x80\x97\xff\xe7\x67\x6b\xf7\x32\x14\x77\x89\x28\x4f\x3f\xb5\xc0\x4e\x49\x52\x2c\x56\xaf\x17\x21\x4b\x30\xe0\x74\xf2\xc0\xa2\x34\xa7\x45\x0b\x14\x91\xc5\xc2\x93\xe0\xa1\x29\x0d\x9c\xbc\xbb\x39\x77\x3f\x93\xad\xff\x38\x33\xad\xa3\x2a\x60\x58\x4d\xaf\x0a\x12\x71\x46\xaa\x8d\xa9\x91\x69\xd2\x05\xb5\x12\x21\xa6\xe6\x57\xc8\xe3\xdf\x7f\xfd\xf6\x77\x66\xe7\x9c\xcb\xee\x28\xc5\x7f\x5c\x09\x27\x5c\x34\x1d\xe1\x0b\x4c\x33\xd8\xe1\xf8\x33\xe2\x17\xff\x8a\x3f\x27\x6e\x5e\x07\xd3\x86\x87\x96\x28\xb0\xa4\xa5\x81\x36\x40\xb6\xa3\x27\x6a\x98\x4f\xb5\xf9\x62\x11\x43\x9b\x49\xc8\x5f\xc1\x5d\xad\x2d\x3b\x82\x01\x9d\xfc\x21\x6f\xbe\x54\x9d\xa1\xee\xcd\x01\xda\x7c\x81\x4f\x75\x5c\xae\x4f\xc9\xde\x2c\x49\x29\x6c\xdf\x58\xdf\x3e\x48\x4e\x22\xa6\x7b\xac\x7b\x9d\xfa\x0f\x8a\x54\x94\x9b\xb7\x8a\x3c\xae\x8a\x9c\x0c\x75\xcc\x31\xa3\x77\x97\x2a\x2b\xc4\x28\x24\x72\x6d\xc3\x3d\xd1\xe6\xd9\xcc\x7a\xf0\x69\xeb\x5b\xd9\x67\x47\x53\x1e\xd4\x33\xd6\xb3\x07\x79\x24\x43\xa1\x99\xc9\x5f\xc6\x83\x61\x45\xad\x71\x2e\x55\xae\x09\x7e\x03\xf9\x8e\x15\x9a\xdc\xe8\x15\xd8\x1f\x78\x9f\x63\x7c\x6a\x1b\x25\xec\xb5\xc3\xa7\x64\xbb\x39\xc9\xfb\x55\xec\x63\xb5\x17\x68\xb3\xf6\x7e\xa6\xbb\xd6\x13\x81\xfa\x48\x25\xa8\x8f\xb9\x4f\x6f\xa1\x28\x1f\xe7\x85\xde\x3b\x76\x22\xfe\x6e\x02\x5c\x91\x2a\x89\x43\xaf\x8c\x12\xd0\x2c\x0b\x88\x0f\xf1\x89\xa4\xd3\xeb\xb5\xbb\x69\x40\x2b\xb2\x64\x47\xb0\xac\xdd\x6d\x4e\x80\x84\x76\x0f\x49\x76\x87\xdd\xed\xf6\x8f\x4f\xbb\x59\x7b\x64\x7c\xda\xee\xfe\x0b\x17\xb8\xcd\x56\xa1\x35\xfd\xb9\x74\xa4\x4a\x02\x4a\x6f\xec\xe5\x6c\xc9\x4d\xd4\xcd\xe5\x57\xbb\xc6\xd0\x18\x38\x92\x56\xda\x5c\x75\x55\x7e\xad\x0d\xfc\xe9\x46\xa3\xc8\xe6\xed\xc5\x47\x7a\xe1\x87\xe1\x67\xd7\x1d\xc5\x9b\xd6\x4d\xcb\xd5\xda\xe0\xdb\x8c\x12\x9b\xb3\xea\xb4\xbd\x9f\x24\xf1\xca\xf3\x6a\xae\xbd\x0b\x98\x9f\xaa\x2f\xf1\xa0\xb2\xb2\x60\x40\x89\xc7\x62\x95\xc0\xaa\x58\x6b\xaa\xe3\x45\xa0\xa8\xb8\x29\x5d\x14\xf2\x88\xa6\xaa\x86\x34\x27\x39\x44\x53\xc4\xc4\x88\xc8\x64\x02\x0e\x47\x45\x43\xda\xe1\x0c\x96\x82\xd2\x5d\x30\xb2\x3d\xed\x53\x31\x47\x0c\xb6\x42\xe3\x54\x10\xf7\x4e\xf5\xa4\x0c\x72\xae\x5c\x1d\xaf\xc1\xfa\x5a\x13\xab\xab\xad\xd3\x6a\x1d\x6b\xb5\x22\x48\x12\x8d\xc5\x88\x47\x45\x66\x81\x57\xbd\x40\xea\x61\xd7\x69\xd0\x97\x6a\x3a\x2d\x89\x14\xc8\x30\x7d\x1e\xbc\xfc\xed\x7f\x7c\xf8\xd6\x77\x63\x39\x33\x07\x2d\xfc\x45\x33\xe3\xb8\xf5\xd0\x8e\x6f\x3b\xc0\x60\xe7\x65\x9b\x3b\xb4\xfc\x81\x02\xf3\x66\x7c\xf1\xd9\xcc\xf9\xc9\xfa\xe9\x4d\x03\xa0\xfb\x24\x09\xcc\x9d\xaf\x25\xe6\xbb\x2f\xbb\xa5\xe5\x95\x71\x5b\x1e\x5f\xbc\x20\x39\xf9\x3e\xe6\xe1\xfb\x9e\xc2\xdb\xf0\xae\x27\x41\xd6\x76\xe5\x61\x9e\x11\xfd\x65\xe0\x0e\xaa\x98\x67\xd1\xe2\x68\x89\xc3\xf4\x5f\x30\xcf\x56\x82\x9f\x40\x1e\xe6\x59\x95\xb9\xaa\xb6\x00\x33\x4c\xad\x87\x51\xbf\xbf\x93\xfe\xfd\x0b\x35\x3b\xa4\xc2\x7a\x89\xbb\x5a\xb7\xef\x10\x65\xae\xd0\x0e\xa9\x35\x2a\xc2\x28\x03\x1b\x86\x7c\x86\x25\xd2\xa9\x9f\x91\xd4\xcf\xfc\x7f\x67\x7e\x86\xf2\x94\x7c\xa5\xf6\xd1\x56\xab\xfe\xce\xfd\xcc\x9a\x2c\x5e\xf5\xed\x2a\xc6\x5c\xb3\xf6\x73\x3a\x3e\xe3\xfd\xfc\x97\xfa\xfb\x4b\xc9\xfb\xe7\xea\xf6\xea\xef\xf0\x46\x10\xd8\x86\x3a\x11\xed\x9b\xb2\x74\xaa\x04\x42\x12\x55\x56\x72\xfa\x99\xd4\xec\x37\xfd\x4e\x03\x8b\x80\x7e\x96\xf2\x96\xa8\x9f\xa5\x58\x9c\xe4\xb3\x15\xea\x67\x2b\x3a\x00\x3e\x89\x68\xdb\x6f\xde\x67\xd5\x3c\x09\x9d\x0f\x8a\x77\xa3\x8e\xcd\x0d\xf2\x30\xe0\x22\x8e\x48\x12\xf9\xf2\xe6\xcf\x43\x9e\xe5\xa0\xf3\x4d\x09\x6f\xd5\xf9\x7e\x42\x7f\x3f\xc5\x12\xa4\xa8\xdb\xc5\x8a\x94\xe7\xbb\x3c\x86\x47\x33\x2b\xe8\xfb\x29\xc7\x00\xf5\x5d\x1e\x33\xd8\x33\xc8\xbb\x9d\x23\x9c\x5e\x74\x06\x07\x8b\x65\xa6\xea\xc7\x95\xaa\x7e\x59\x6f\xc3\x8f\x53\xfd\xcc\xdc\xcf\xc7\xe9\x3f\xd7\xfc\x4b\x1d\x43\x92\xfe\x5c\xf7\xe3\xb4\x7d\xa4\x64\xb1\xe1\x30\xc4\xba\x9c\xf1\x38\xed\x57\x1b\x56\x14\x6b\x67\x1f\x7d\x6a\xec\x23\x30\x17\xa6\xf4\x7d\xd4\xa5\x0b\xd9\x47\x95\x7d\x2b\x3b\xe7\xf6\x91\x5e\x03\xf3\xbe\x5a\x4b\x72\x4e\x2a\x09\x64\xbb\xc7\xe9\x94\x38\x93\x64\x37\x21\xbf\x8f\xe7\x25\x97\x47\x9c\x90\xf6\x78\x24\xaf\x0b\x49\x2e\x0b\x9a\x98\xb6\xb8\x8d\x8c\x75\x41\x9a\xbd\xb0\x0c\x26\x5b\x61\x16\xa3\x35\x68\x1a\x16\x1b\xf9\x8f\xeb\xad\xd6\x97\xe1\xf2\xdf\x7f\xcc\xdc\x4b\xef\x27\x99\x29\xb0\x14\xbe\x92\x2b\x2d\x3b\x76\x72\x5d\xe6\x11\x6e\x49\xe6\x3d\x0a\xf8\x40\xef\x4f\xc7\xb0\x64\xef\x01\x07\xf0\x81\x2e\x29\xc5\xe4\x25\x31\x16\x6d\xf3\x08\xf8\x4d\x5e\x2e\xc5\x23\xab\x4b\x2d\x49\x55\xe5\x09\x1c\x38\x70\xa0\xfd\xe8\x4a\xd6\x63\x2b\x9d\x63\xa0\xd8\xc5\x7e\x85\xaf\xc2\xa3\xf0\x27\xd0\x79\xee\xd3\xd7\xae\x3c\x72\x15\x3e\x3c\x6b\xd9\x75\x77\x42\xf1\x34\x5a\x8c\x6f\xcb\xfc\xf0\xf2\x71\xa1\x7c\xd3\x94\x51\x2b\x7e\x7b\xf1\xf1\x4d\x0f\x2c\x6e\xd9\xb2\x0a\xde\xdc\x0e\x86\x4c\x06\xf6\xca\xf3\x15\x9d\xbb\x5a\x9f\xde\xe1\x74\xf3\xf6\x76\xf0\x58\x72\x38\x32\xfd\xd5\x33\x4d\x3e\x53\x54\xa4\xe1\xb1\xbc\xb4\x23\x58\x64\xf3\x15\x62\xca\x52\x5b\x68\x1a\xa0\xd9\x42\x72\x06\x28\xa7\xd2\xed\xea\xba\xff\x02\x2b\x41\xe7\x54\x94\xad\x8c\x56\x76\xae\x4c\x55\x36\x56\x12\xd3\x9c\x44\x6c\xd9\xd4\xb2\x0a\x62\x1b\x11\xe3\x85\x06\x05\x94\x6a\xe0\xfa\xd6\xd6\x1a\x38\x5f\xaa\xad\x14\x3e\xce\xda\xca\xfb\x68\x0f\xab\xba\x37\x2e\x22\xbb\xa9\x5b\x2a\xc4\x36\x45\x9b\x3a\x37\xa5\x9a\x1a\x9b\x58\x0d\xfe\x9f\x1d\x3a\x76\x68\x03\x0a\x26\x55\x1a\x80\x8f\x72\x34\x00\xba\xa4\xf4\x9b\x0d\xfb\xa9\xce\xc9\x0a\x6d\x6f\x22\x6a\xb7\x89\xfd\x94\x55\xa8\x54\x38\x61\x87\xec\x63\x1d\x6d\xed\xe7\xa7\x86\xfd\x04\x73\xe9\xb5\x83\x6a\x3f\x7b\x12\xfb\xd9\xf3\xba\x9e\x7d\x84\x70\x21\x46\xed\xf3\xdc\x31\xf5\xfb\xef\xd5\xbe\xdf\xe0\x94\x41\x25\xc4\x2b\x28\x19\x59\x52\x5e\xc8\xef\xa1\x62\x5f\xab\xdf\xff\xa2\x3e\x3e\x1d\x47\x1c\xc5\xc9\xf7\xc7\x27\xc5\x93\x82\x94\xff\x7e\xcd\xef\x48\x1a\x7e\x07\x73\x88\xb9\x0c\xa6\x35\x0e\x04\x0a\x96\x82\x28\x8e\xef\xd4\x1d\x8a\x27\xdf\xf5\xa0\x9f\xb3\xa9\xb1\xd2\x3b\xd9\x58\xe9\x10\xfc\x1c\xe8\x9c\x0b\x7d\xfb\x52\xac\x91\x9e\xbb\x5a\xc7\xef\xe8\xd9\x5d\x0b\x97\x72\x9f\xd3\x9e\x57\x9e\x7d\xde\x61\xe6\x28\x3c\x8f\xc6\x58\x2a\x34\x8b\x87\xf2\xd7\x78\x02\x6d\x78\xc2\xb4\xb8\xec\x70\xf6\x59\x87\x55\x9f\x83\x7c\x86\x3e\x89\x92\x3b\x1c\xdd\xd1\xbd\x4f\x61\x5c\xa6\x63\x7a\x96\x64\xf1\x42\x0f\x31\x73\xe1\xf9\x5a\x8f\x28\x75\xbd\x19\x8a\x05\x76\xf3\x0e\xb7\x13\x5a\x0b\xe5\x8b\xb6\xc1\x25\x3d\xa4\x32\x1f\xaa\xe3\x4a\x26\xe9\xb8\x62\xbb\x5a\x6f\xdf\x11\x2b\x42\x96\xc2\xcf\x69\xcf\x2b\xcf\x3e\xef\x30\xf3\xba\x3a\x2e\xf5\x69\xf4\x6c\x64\x76\x38\xbd\xd0\xda\x0e\x86\xe8\xe1\xec\xb3\x0e\x33\x3d\xb5\x71\xd1\x27\x31\x45\xf4\x33\x45\xc5\x85\x3a\x15\x93\x59\x66\xfa\xa9\xe3\xd2\x70\xf6\x0e\x81\x1d\xc6\xb8\x44\x91\x8e\xcb\xba\xab\x75\xce\x0e\xab\x49\x0b\x23\xb3\xf2\xe1\x7f\x93\xcf\x0d\x55\xc7\xf5\x8b\xfe\xb9\xbd\x46\xcf\xac\x28\x4a\xda\xe7\xae\x3d\xf3\x73\xad\xef\x90\xcf\x5d\xa5\x8e\x4b\x7b\xde\x61\x18\x25\xe3\xa2\xba\x97\x3e\x0e\x9a\x90\xc9\x51\x10\xdf\xbe\x4d\xde\x7f\x85\x3a\xa6\x5f\xf4\xf7\x17\xe9\xba\x9a\x3e\x86\x72\x08\x14\xbc\x5f\x8f\x6f\x4b\xb3\x58\x3d\x87\x98\xdd\x70\xac\x36\xdf\xc5\xc5\x74\xff\x45\xa9\x5c\xd1\x70\x01\x37\x91\x8e\x2d\x91\x8f\x75\x73\x88\x09\x19\xeb\x14\x8b\x49\x1a\xa7\xd1\x8a\x1d\xe1\x00\xdf\xe6\x73\xda\xf3\xca\xb3\xcf\x3b\x8c\x02\xda\xfe\xa3\x4f\xd3\x89\x90\x12\xed\x62\xf7\x1c\xce\x3e\xeb\x30\x33\x47\xb7\x27\xf4\x51\x4c\x00\x05\xa2\x05\x31\xf5\x32\x15\x9b\xa4\xd4\xc0\x26\x21\xb2\x8d\x31\xc6\x14\x8b\xe9\x7c\x4b\x71\x22\x1b\x67\x2f\x9c\x6b\xa2\x11\x90\x45\x1d\xd3\x28\x7d\xef\x2d\x34\xd6\x28\x1e\xa7\x6b\x44\xb6\xc4\x5d\x3b\x8a\x82\xac\xf3\xcc\xbd\x77\xbf\x3a\xa6\x5a\x5d\xbe\xfd\xda\x98\xe8\xd3\x18\x12\x8f\xef\x22\xf1\x38\x57\xa8\x97\xa7\x93\x67\xb9\xd5\x31\x8d\xd2\xd7\xe9\x65\x4d\x2f\xd3\x27\x51\xbd\x9c\xd9\x11\x8c\x69\x0f\x6a\x13\xc3\x97\x66\x7b\xd4\x0f\x31\xeb\xb4\x71\x69\x61\x34\x43\x41\x54\xd6\xec\xf0\x7b\xf5\xa8\x32\x2b\xdf\x50\xad\xd7\x27\x9b\x2f\x38\xa4\xf6\xb6\x17\x8e\xeb\x56\x32\x2e\x6f\x9b\xb3\xa8\x3d\xaf\x3c\xfb\xbc\xc3\xcc\xd7\xfa\xde\x53\xfd\x19\x2f\xe3\x0d\x15\xe0\xb5\x68\x79\x89\xc3\xd9\xe7\x1c\x66\x2e\x2b\x1c\x53\x2b\x19\x53\x9b\xbc\x44\x4f\x5c\x92\x8f\x91\x62\xfa\x13\xfe\xbb\xf5\x7b\xda\x83\x5d\x53\x51\xd3\xb5\x00\x23\xa5\x24\x1f\x23\x85\xbc\xef\x2a\xed\x7d\x5d\xe2\x5d\xaa\xf3\xde\xa7\xe0\xfa\x7c\x0c\x13\xf2\xbe\x9b\x81\x8a\x60\xe3\xa4\x11\x24\xf1\x2b\xf2\xf0\xd0\xfd\xb8\x24\x1f\xc7\xc4\xf4\x27\xd8\xa1\x7d\x67\x51\xaa\x28\xc2\x7b\xf4\x37\x42\xe2\xa7\x8d\x62\xfb\xa8\x35\x49\x03\x52\x31\xb7\x50\xee\x74\x82\x48\x44\xf0\xdb\xed\x25\xc4\xf8\x54\x76\x2c\x72\xba\xdd\xce\x22\x24\xc4\xe3\xa1\xf1\xe9\x38\xab\x5f\x2a\x29\xf5\x55\x55\x85\xe5\x48\x39\xfe\x6a\x07\x2b\xd4\xf6\x41\x34\x0f\xcc\xb3\x5c\x6d\xb7\x62\xbd\xa8\x47\x28\xa5\x78\x62\x6a\x71\xbf\x50\x04\xd9\x3e\xf5\x53\xef\x78\xed\xb7\x3f\x7e\xfe\xe5\xb6\x86\x58\xa0\x1f\x3e\x86\x8f\xbc\x00\x9d\x9b\x06\xdf\x74\xe5\x4b\x0b\xdf\xbc\x08\x32\x4f\x3d\xfc\xcb\xf5\x75\x4d\x83\xce\x82\x5d\xc7\x3f\x70\xc3\xac\x89\x23\xba\xff\xd0\x63\xf2\xec\x9b\xce\x1b\x74\x4d\xb2\x7c\xda\xe8\x2f\xba\x5f\x3c\x66\xd6\xe8\x4b\x16\x6c\xbe\xf9\xfa\x25\x53\x5f\x5b\x34\x79\xc9\x88\xa1\x7b\xd5\xb1\xf4\xc7\x4d\xe8\x73\x76\x38\xd1\x92\x83\x52\x71\x67\x34\xea\x16\xe2\x82\x0f\x84\xc3\x24\xd6\xf3\x75\x28\xe7\x79\x5f\x34\xea\x8b\xc7\x2d\xbe\x90\x05\x35\xa5\x2d\x4e\x90\x5f\xb1\x59\x58\x5e\xa5\x0d\x88\x0c\xa7\xb0\x1e\x49\xeb\x74\x76\x40\x75\x60\x6a\xae\x9b\xe7\x6a\xfb\xb0\xcc\xc1\x69\x93\x46\x5c\x25\x7f\xed\xff\x63\xcf\xd1\xdf\xcf\xea\xd7\x6b\xd0\xe5\xfb\xf0\x2e\xfc\xcd\x9b\xb0\x74\x75\x58\x79\x02\x4f\x9a\xb5\xe9\xb2\x5d\x43\x99\x63\x4d\x13\x47\x8f\xec\x76\xcb\x03\xaf\x6c\x99\xb4\xb4\xae\xec\x81\x8b\x17\xee\x5d\x35\x25\xfa\xa1\x78\xd1\x86\x4b\xbb\x8c\x0b\x9e\x3d\xe8\x9f\xee\x68\xe8\xec\x29\x6d\xb0\xe9\x2a\x74\x5f\xfb\x56\x90\x87\x29\x2c\x32\xf9\x51\x44\xab\x81\x29\x7c\x8e\x4b\xc7\x14\x26\xef\xef\x08\x8a\x72\x18\x07\x7e\x93\x3f\x22\x09\x79\x3e\xe9\xcd\x24\x86\x70\xab\x77\xe6\x5d\x53\x7e\xbb\xd9\x6c\x81\xc4\x99\xf6\xb8\xed\x76\x2b\xb4\x58\x91\xc5\xe5\xe4\xc7\xa7\x9d\xba\xdf\xd7\xb7\x6d\x75\x10\x8d\x7c\xa5\xae\x34\xcc\x55\x91\x29\xa9\xf7\x17\x95\x38\x37\xfe\xa4\x6e\xde\xc4\x2d\xcb\x55\xaf\xef\xdd\x59\xf0\x07\xe2\xfe\x1f\xbb\xf5\xae\x61\x4b\x4f\x1f\xe6\x96\x2c\x1d\xd8\x84\x4d\x94\x67\x0d\x8f\xe6\x5f\xe2\xde\x01\x71\x50\x09\xea\xc1\xa2\x54\x3f\x6b\x22\x12\x45\x52\x57\x22\x74\xb9\xaf\x13\xc7\xf9\x24\x3b\xea\xd9\x23\x12\x21\xd1\x48\x97\xa0\xd5\x2a\xdb\x6c\x26\x99\x32\x1e\x05\x63\x30\x58\xd2\x90\x0e\x3a\xbb\x30\x8d\xe9\x2e\x5e\x99\x04\xb3\xb2\xd7\x54\xd7\x90\x36\x05\x0b\x2b\x40\x8d\x2a\x50\xb5\xbe\xdd\x28\x6c\xd7\x6f\x13\xab\xb3\xd7\x18\x0a\xf5\x5e\x93\xdd\xb4\x15\xa5\x41\x2b\xd9\x9b\x75\x14\x62\x85\x4f\xe4\xe1\xb2\x67\x09\x1c\x68\x18\xab\xef\x03\xf5\x8a\x83\x1d\x79\xe5\xad\x9b\x77\xbf\xf7\xe4\x94\x5d\x13\x67\x6d\xee\x78\x7d\x88\x1d\xdb\xba\xe7\xdd\x0f\xf7\xa9\x30\xed\xd0\x8f\x4f\xcc\xb9\x62\xf6\x8c\x4f\x66\x5e\xcd\xdc\x7a\x6e\x9f\x9e\xf3\x8a\xa5\x6b\xce\xe9\x7b\xee\xcc\xa6\xc7\x6e\x5a\xb3\x39\x35\x74\xf9\x5d\xa9\x15\x43\x16\x57\xbc\x4e\xbc\x72\x33\xb4\xc3\xe4\x84\xf1\xcf\xc2\x9b\x5a\x46\x3f\xbd\xe7\xf9\xdd\xf8\xd6\xd7\xb0\xbf\xa6\xbe\xa6\x63\xcd\xa0\x7a\xea\x9b\x4f\x24\xfa\x66\xab\xda\x3b\xd6\x19\x8c\x4b\x55\x59\x81\x88\xe2\x26\x31\x5e\xe4\x12\x59\xb9\x22\x58\x22\xcb\xc1\xea\x2e\xc9\xa4\xcd\x45\x5c\xdd\x48\xc4\x67\xe3\xca\x26\xa6\xc9\x04\xda\x58\x5f\xa7\x89\x69\x9f\x1b\xb4\x6d\x62\xa4\xe3\xce\x5b\x46\xbd\xe7\x46\x2b\x41\xa0\xf9\x0a\xfd\xae\xa9\x56\xbd\xd7\x93\xd5\x7e\xfe\x58\x54\xed\x2c\xab\xa5\x57\x99\xb4\x9f\x3f\x96\xe5\xea\x1d\x30\xa2\xf1\xeb\xd9\x57\x8e\x18\xf5\xf1\xf7\xdf\xad\x5c\x8e\xbf\xc4\x27\xf1\x1f\xf8\xcb\x55\x4b\xe6\x5f\xf1\xfd\x11\x38\x08\xff\xbe\xf0\xfa\xa5\x37\x2e\x5b\xc8\x2e\x1f\x74\xee\xd6\x71\x97\x4f\x1d\xf3\xc6\xab\x3b\xbe\x6d\x60\xc3\x5b\x6f\xda\x77\xf4\xe3\xd7\x56\x3c\x1b\x62\x8b\xef\x99\x72\xf7\x53\x2d\xa3\x3f\xb9\x62\xe6\x35\x57\x5e\x61\xf4\x6b\x6e\xe5\x0e\x91\xb1\x56\xd1\xae\x5d\xbf\xdd\xe2\x0d\x39\x2d\x96\x10\x1f\x65\x51\x59\xa2\x13\x4a\xa0\x2e\x9d\x03\xb6\x28\xef\x26\x0b\xcf\xbb\x79\xb7\x0d\x80\x92\x6c\xad\x96\x7e\xc5\xad\xb1\xfa\xb6\x37\x3e\x2e\x37\x0e\x67\x52\xc9\xaf\x91\xa9\x63\x25\x8d\x54\x9c\x8c\x36\x19\x95\xf4\xe5\x66\x96\xe0\x16\xfc\xc1\x4d\xcb\xae\x5c\x00\x3b\x4c\x1b\x50\xbd\xe8\xaa\x59\xf3\xaa\x07\x4c\x83\x1d\xe6\x5f\xb5\xec\x26\xfc\x4f\x9c\x81\x96\x15\x4b\x97\xac\xf4\x7c\xf3\xf6\xea\xdd\x21\xb6\xea\x89\xd9\x90\xb9\xee\xee\xee\x93\xcf\x59\x3c\x7b\xf6\xe2\xc1\x53\xea\xee\xbe\x0e\xe3\xd9\x4f\x54\xb1\xa1\xdd\xab\xdf\xfe\xe6\x0d\x08\xe7\xcc\x9b\x3b\x17\xb7\x6a\x77\x47\xbd\xf1\x09\x76\x8f\xda\x3f\xd7\x3d\x15\xb4\x4b\x12\x72\x39\xac\x26\x84\xac\x1e\x37\x67\x15\x29\x16\x9e\x16\x71\xb9\xf2\xba\x91\xdb\xf6\xae\x27\xd5\x05\x2a\xa5\x37\xb1\x31\xfd\x52\x19\xcd\xbc\x77\x47\x87\xaf\x22\x37\xb4\xfc\xc2\x9c\xa2\xe5\x17\x19\xfe\xf8\xad\xcb\xa6\x5d\x1b\x1b\x51\x33\xe3\x10\x7a\xeb\xf8\x81\x96\x1a\xfa\xec\x01\xf8\x04\xfa\x42\xad\xb7\xe8\x96\x0a\x30\x3c\x2f\x5a\x04\x04\x2c\xc0\x4d\x79\xe8\xd5\x1a\x0b\x20\x34\xa6\x81\x7c\xe6\xa3\x8d\xeb\xdf\x1a\xfd\x71\xb1\xa8\x21\xc0\x00\x26\x44\x6b\x2b\x32\xc7\xa1\x17\x0e\x4f\x7c\x12\xb9\x61\x1f\xb3\x79\xff\x5b\x99\xb1\x7f\x6a\x0f\x07\xb9\x18\x40\xc5\x2d\x29\xd6\x71\x4b\x96\x41\x47\x96\xef\x41\xa2\x78\x86\x92\xbb\x5d\x9f\x3c\xe7\xff\xaf\x07\xff\xd2\x7c\x57\x1a\x3a\x51\xfe\xb8\xcf\x76\xd4\xd6\xb5\xf5\xc9\xf3\x31\xfc\x9d\x14\xdf\x6b\x47\x36\x8f\x92\xc5\xea\x57\x7f\x3e\xa4\xdd\xbb\x8f\x1a\x44\xfd\x86\x4e\xa9\x30\x62\x7e\x2a\x82\x9f\x13\x13\xd5\x5a\x04\x7f\x2c\x52\xb3\x49\x24\x68\x2b\x66\x8b\x0d\x44\x44\xfa\xcc\x71\xe3\x6a\x29\xa3\xae\xe1\xbf\xa9\x79\xd2\x66\x3d\xa7\x1d\x37\x72\x2a\xb0\x2b\xe8\xbd\x8d\x8d\xd1\x9c\x4a\x3c\x16\xa5\x39\x15\x4a\xeb\xe9\x27\xff\x60\x17\x17\xc1\x99\x45\xb0\xa1\x08\x8a\xe4\x09\x1a\x82\xa2\xea\x99\x48\x14\xe9\x24\x9b\xba\x6d\x4f\xce\xee\x48\xa6\xb9\x9a\xe7\x49\xc8\x40\xbd\xbd\x24\xbd\xd7\x48\x76\xc9\x7a\xb0\xed\xc9\xc4\xfc\x9d\x7d\x0a\xcf\xcd\xca\xd4\x63\x1b\xa5\x63\x3a\x95\x4a\x44\x3a\x52\x99\x3a\xa7\x2a\x3a\x0f\xee\x9c\x0a\x85\xc9\x1f\x1e\x65\x70\x63\x67\xd8\x39\x65\x76\x0e\xee\x9c\x15\x4a\xaa\xa0\x0c\x70\x46\x1e\x48\xc3\xbf\x3c\x9a\xf5\x71\xd7\xc3\x7d\x94\x8b\x41\xe5\x88\xa0\x0e\x21\x08\x84\xda\xb9\x33\xca\xf9\xd2\xeb\xa1\x1f\xe8\x78\x96\x1a\x5f\x55\xcb\x0e\xc5\xcf\xb7\xc7\x43\x9a\x1b\x73\x9d\xba\x36\x3a\xdf\x99\xea\xb7\xb3\xd1\x48\x7b\xf8\x94\x79\x63\x5e\x0f\xe3\x5a\xbe\x5a\x1d\x73\x62\x1b\xa2\xee\x77\x4a\x0a\x87\xc8\x98\x19\xce\x4b\x57\x21\x3b\x42\x23\x65\x0d\xb2\xf8\x3f\x1b\x0c\xfc\x1f\xf2\xf9\x51\x6a\xce\xda\xe0\x9a\x68\xdd\x61\xb3\x66\xd9\x25\xb3\xf8\x42\x63\xb3\xf8\x42\x37\x01\x03\xfb\x56\xc5\xb2\x85\x7e\x5f\x01\xef\x50\x2b\x26\xef\x17\xd5\xfb\xdc\x08\xad\x4a\xb5\xb9\x02\x10\xba\x5c\x0e\x0f\xcf\xc7\x1c\x51\x08\x15\xb7\xcd\xa6\xd8\xed\x66\xc5\x0d\x15\x72\x2c\x15\xaf\x39\xdc\x90\x36\xe7\x99\xb9\x7c\xcb\x06\x6b\x34\x25\x97\xeb\xcf\x68\x6b\xd4\x6a\xa5\x7c\xcb\x05\x37\xe7\x59\xae\x2e\x0b\x43\xcc\xba\x9c\x89\xe2\xde\x39\xb5\x31\x6b\xa5\x06\x2d\x19\xb2\x98\x1b\xf4\xe7\xee\x3c\x7b\x44\xef\x41\x69\xfe\xb9\x1c\x74\x05\xd3\x52\x75\x1d\x42\xa1\x2a\x6f\xc2\x5b\x6e\xe5\x79\x41\x28\x4f\xa2\x6e\xb5\x5e\xaf\x60\x49\x24\x2a\x8b\x8b\x23\x95\xa2\xc3\x21\x58\x44\x41\x76\x11\x73\xed\x72\x56\xfa\x1b\xd3\x95\xde\x48\x75\x43\x3a\xd2\xc6\x5c\xf7\x6d\x6b\xaa\x0b\x8a\x69\xaa\xb5\x8a\xc1\x76\xbb\x95\x0c\x7f\x8c\x16\xda\xe8\x23\x55\xf3\x4f\xda\x38\xcf\xec\x65\xea\x31\xeb\x6c\x3a\xf0\x81\xb3\x27\x35\xd3\x91\x07\x99\xc5\xe7\xf6\xb9\x6a\xb8\x6b\xfa\x80\xbe\xe7\x32\xe3\xcf\x68\x72\xca\xbc\xde\x21\x41\xa7\x22\xd4\x39\x45\xe7\x62\xd0\xd2\x4c\x4d\xfd\xf8\xba\xfe\xea\x3c\x88\x80\x63\x6d\x2a\xfe\x5b\x19\x98\x9e\xea\x16\x00\x8a\xbb\x88\x68\x53\x77\x02\xd8\x81\xdb\xed\x0d\xa2\x0e\xe5\xc4\x55\xb3\xdb\xbd\x0e\x87\xd9\xe7\x45\xb1\xc6\x34\x42\x66\x6f\x58\xf6\xca\x0d\x94\x94\xd1\x4c\x0c\x97\x59\xce\xab\xb5\xd0\x4a\x42\x80\x51\x72\x91\x57\xa0\xa8\xce\x43\x75\x76\x6d\xdb\x19\x72\xae\x32\x1b\xe6\x06\x0f\x77\xf5\x9e\x3f\xe2\xde\x67\xdf\x58\xdf\xb8\x68\x6a\x23\x1d\x6c\x40\xab\xc5\x80\x97\x0c\xac\xbe\x61\xb8\x6b\x46\x63\xed\x40\x26\xdc\x31\xf9\xf8\xca\xd5\x4f\x84\xaa\xfb\xd0\xf1\x9d\x3d\x01\x5e\xae\x16\x6c\xbf\xa8\x0e\xb3\xa7\xda\x03\xf7\x39\x1e\x0d\x1f\x27\xf6\xc2\x06\x22\x29\xb2\x9a\x16\x07\x63\x37\x89\x1a\x36\xaf\x0e\xc1\x04\xf5\x9e\x69\x77\x3e\xec\xfa\x2a\x03\x6b\x5d\x05\xd3\x35\x30\xd6\x89\xef\x37\xae\xf5\x3b\x61\x80\xee\xfb\x75\x27\x3b\xa8\x7b\xa8\x6b\x18\x99\x4c\xfe\x84\x0f\x99\xcb\xa5\x4e\x40\x32\x03\xd4\xa3\xde\xe7\xf3\x14\x85\xc3\x1e\xc1\x62\xb5\x9a\x3d\x01\x68\x96\xbb\x94\x78\xc8\x8c\x45\x3d\xce\xba\x0a\x7a\x87\x81\x1c\xde\x6c\x93\xa0\xd1\x2b\x28\x69\xad\x82\xf5\x67\xc0\x2f\xd1\x57\xae\x2d\x45\x8e\xe9\x28\x0d\x79\x1e\x9e\xce\xda\x95\xe7\xe8\x25\x73\x08\x30\xc2\x80\x0f\xde\x9c\xfb\x4c\x07\x06\x9f\x66\x2b\xb6\x2d\xcf\x73\xf1\x34\x60\x98\x16\xd6\x70\xf4\x3e\xd0\x21\x61\x98\x18\x05\x83\x99\x3a\x76\xeb\x33\x17\x4e\x29\xf0\xf0\xf0\x24\x15\x2b\xe6\xa4\xee\xe7\x3d\x6b\x20\xc4\x00\xcd\x27\x16\x7a\xb1\x4d\x64\x5e\x3a\x92\x28\x71\x4a\xaa\x5b\x99\xd9\x8b\xfc\x7e\x3e\x5c\x89\x02\xd5\x20\x21\x82\x80\x88\xba\xd7\x91\xc3\x65\x26\x27\x2d\x5c\x54\x14\x15\xc4\x40\x30\xd9\x19\x75\x6e\x48\xdb\x90\xb3\xa2\x6b\xb4\x6b\x43\xda\x15\x3d\x73\x56\x74\xec\x9b\xf6\xe7\xc4\xad\x4d\x41\x5d\x4c\xc5\x2e\xc9\x22\xe1\x68\x9d\x3b\x75\x2a\x3f\x51\xae\x5d\x27\x77\x99\x33\xf2\xa3\x7d\x57\x6f\xa9\x80\x90\x81\x95\x3b\xae\xdf\x7d\xc8\xe8\xe2\xf9\x17\xc7\x8c\xc3\x2d\x7b\xde\xe5\x5e\xd3\xda\x77\x32\x65\x57\xcd\xfe\xe2\xb3\x19\x0b\x98\x10\xb4\xc1\xd2\xa9\x17\x6c\x7d\x66\xc2\x54\xfc\x29\xfe\x25\xd7\xd4\x03\x5f\x1d\xdf\x8b\x44\x47\x50\xd4\xba\x79\xe0\xdc\xa7\x5e\xc6\xb7\x90\x99\x01\x2c\xa8\x69\x7d\x9b\xbb\x4d\xc5\x0a\xf3\x02\x3f\x08\x81\xf9\xa9\x1e\x26\xc1\xed\x13\x99\xa0\x3b\x28\x3a\x6d\x1c\x4b\x22\x14\x96\x67\xad\x76\xb6\x28\x6c\x36\x0b\x8a\x22\x90\xc9\xb2\x08\x4c\xc8\x41\x02\x54\x1f\x51\x3c\x2c\x0f\x5c\x6a\xd3\x0f\xe2\x03\xbb\xa0\xfb\xd9\x34\xef\xca\xeb\x5f\x7a\xc3\xe8\xbd\x6d\xe7\xc0\x49\x39\xe8\x7d\x8a\xbc\x8f\x62\x28\x51\x17\x83\x31\xc5\x5d\x83\xcc\xb0\xc6\x5d\xc5\x08\x0e\xe8\x16\x6a\xa0\x3b\xc1\x5e\xbe\x08\xbf\xf2\xd9\xc6\x30\xfe\x17\xd9\x0f\x17\x0c\x5a\xbb\xf1\x17\x38\xaf\x65\xc5\xf4\x9d\x4a\x85\xcc\x5b\x42\xaf\x36\xdf\x98\xd9\x77\x57\x2d\xbc\x04\x4f\xea\xc6\x2d\x79\x1d\x8a\xb8\xd7\xe9\x93\xcc\x40\xd8\xdc\x7f\xc5\xd9\xde\xe2\x0b\xf0\x3b\x77\x63\x13\x0c\xa8\x7e\xef\xdb\x9c\x86\x49\x56\x02\xc6\xa4\xaa\x69\x0f\x16\x2b\x7b\x2d\xd6\x88\x28\x5a\x6d\xe1\xb8\xe2\x65\x4d\x65\xa5\x31\x14\x20\x2e\x33\x70\x15\x8f\x4f\x7b\x14\x9b\x99\x15\xe4\x94\x8b\x15\x28\x42\x00\x6d\x9f\x7c\x47\xcd\xcd\xbf\x9b\xcf\x38\xad\xe4\xd7\xb5\x6b\xc0\x00\x6a\x49\xa2\xca\x2b\xc8\xe4\x88\x05\x15\xae\xa4\x94\x78\x6e\x1a\xe3\x34\x8f\x82\x59\xe4\x9d\xdd\x37\xd5\x6e\xbc\xe0\x86\xc5\xb4\x8d\x6f\xf3\x35\xf5\x1b\xc7\xdd\xda\x1b\xb7\xf8\xba\xe2\xc4\x08\x7c\x74\x32\x3c\x32\xf8\xfc\x37\xdf\xfb\x87\x8a\xc0\xd3\xe3\x82\x87\x26\xc2\xee\xaf\xd1\x86\xbe\xca\x8b\x36\x5e\xb4\x6b\xd0\x90\x9a\x96\xdd\x1d\xe1\x2f\x27\x96\xa0\x6e\xe1\x93\x64\x7c\x66\x62\xeb\x1a\xd4\xf1\x25\xc1\xa8\x54\x67\xbb\xc3\x25\x49\x81\x60\x44\x40\x2c\x2b\x70\x72\x5c\x0c\x3a\x4c\xa5\x25\x31\x8f\x52\x6c\x29\x26\xbb\x59\x74\x05\x38\x86\x07\x76\x12\x98\x2b\xe4\xa4\x53\xf7\xfe\x0d\x3a\xba\x37\xf4\xc1\xd5\xd7\x17\xda\x07\x1d\xe3\x18\x25\xdc\x25\x1a\x0e\x0f\x59\x27\x7d\x50\x3a\x42\x8f\x3e\x36\xa6\xf9\xca\x71\xff\xdc\xf8\xe7\xb3\xd0\x71\xb2\x61\xc0\x6b\x1b\x3f\xbd\xb7\x18\x7f\xcd\x89\xf8\x8b\x4e\x67\x1b\x30\x3d\xf8\x01\x17\xe4\xc3\xf1\x0f\x3d\x31\x3c\x04\xe2\x5b\x60\x57\x8a\xc9\x23\xc1\x35\xb8\x7e\xe2\xcb\x8e\x44\x71\xe6\xd9\x62\x0d\xae\x87\xe9\x36\x7d\x28\xe3\x37\x03\x9d\xbf\x46\xe3\x03\xe8\x9d\x8a\x30\x80\xf2\x01\xa8\x08\x33\xa2\xc3\xc2\x20\x66\x22\xd9\x7e\x08\xb4\xa5\x02\x68\x5b\x46\xad\x95\x1d\xa8\xc0\xa3\x7a\x21\xd6\xca\xc5\x8b\xc9\xb1\x98\x81\xd7\x32\xbf\x32\xab\xf7\x33\xe5\x99\x0f\xf6\xe3\xd1\xc7\xa8\xdd\x51\x5a\xdf\x66\x0f\x90\xb9\x74\x12\xcf\x61\x38\xf1\x1b\x24\x86\x71\x51\x4a\x09\x8e\xb7\xf0\xc8\xce\xca\x1e\x49\xb2\xb0\x2c\xb2\x91\xff\x73\x01\xb7\xd9\x62\x1e\x9f\x76\xd0\x66\x1a\x8d\xc3\xc7\xd7\xf7\xf5\xec\x7e\xcf\x6e\x76\x7a\xa1\x4d\xf1\xb0\x21\xa2\x95\xef\x09\x48\x4b\xc0\xc8\xc6\xa8\x91\xb9\xba\x04\xc2\x7f\xe2\x0f\xf1\x8f\x1b\xe1\x0e\x5c\x8f\x3e\xaa\xde\x58\xdd\x1d\x77\x3f\xef\x3c\xf6\x7e\x7c\x63\xcb\xc7\x70\x0a\x9e\xcc\xac\x65\xce\x3a\x76\xee\xb9\xc7\xae\xbf\x9e\xcc\x45\x83\x86\xf1\x4b\xf4\xfa\x90\x54\x59\x27\x8f\x10\x2f\x0d\x06\x81\x23\xee\xe8\x51\xdf\xa5\x82\x04\xec\xc1\xa0\x0c\x05\xb6\x54\x2a\x65\x9b\xd2\xa5\xde\xa4\x57\xf2\xe5\xda\xc1\xf4\x7e\xb0\x1c\x70\x8d\x7e\xdf\xdc\xa5\x73\x5f\x98\x5f\x50\xa8\xf5\x13\x0a\xfa\xed\xba\x57\x61\xd5\xa0\x8d\x6c\x6a\x45\x7d\x97\xda\xf4\x42\xec\x62\x49\x69\x49\xc3\xc6\xba\xcd\xd3\x68\xa1\xe1\xb1\xad\xe9\x1f\x3f\xfa\xdb\x89\xf0\x9f\xb6\x0b\xa7\x4c\x9e\x3c\xec\x7c\xc8\x3c\x3e\x06\xb7\x7e\x15\xb6\x74\xef\x9b\xee\xe1\x1e\xe6\x1a\x9d\x6a\xbe\xf1\xda\x85\x0d\x93\xe5\x27\xee\x1a\x38\x4a\x2d\x3e\xac\x6c\x5a\x32\x61\xfd\x53\x77\xde\x12\xe8\x77\x56\x4d\xaf\xce\x75\xae\x6e\x23\x97\x4d\xba\x7f\x3b\x3c\x6b\x48\x6f\x81\x7b\x4b\xea\x33\x6f\xf3\x25\x17\x7b\xb4\x58\x6a\x34\xfa\x5a\xad\x71\x1e\x9c\x2a\x71\xf2\x02\x60\x78\x04\x78\x10\x0c\xf0\x48\x8b\xa5\xa0\xa0\x45\x53\x2e\x91\x38\x40\x76\xf2\x0a\xe6\xf5\xd7\x1a\xa5\xa0\x05\x7d\x62\x35\xd9\x0a\x61\x75\x40\xfa\x78\xaa\xc8\xf6\xcd\x46\x59\xfd\xae\x6d\x1c\x3a\xbb\xbe\xac\xc7\xe8\x54\xef\x29\x63\x87\xf5\x9d\x39\x4f\x0b\xb7\x2e\x70\x4c\xb9\x74\xf2\x28\xdb\x47\x52\xc5\xb9\xe3\x87\x2f\x07\x46\xad\xff\x21\x15\x77\x6c\x40\x2a\x6e\xb6\xc8\x5e\xe4\xb4\x78\x9d\x28\xe0\x37\x9b\xed\x8a\xe2\xb5\x03\x0f\xd9\x95\xc0\xee\x75\xd9\x79\xda\x8a\xdd\x36\x59\x50\x58\x7f\x4d\x7b\x14\xba\x19\xd4\xce\x2a\x08\x99\x5a\xc3\x4c\xb6\x8c\x97\x19\xfe\xe8\x73\xeb\xd7\x2f\xba\x2f\x86\x5b\x7a\xc0\xb2\x8f\x89\xf0\x67\xcd\x3e\xb8\x02\x7f\x58\xcf\xc4\xb7\x3f\x76\xdb\x43\x97\x5f\x3d\x68\xf7\x3b\xf8\x93\x96\xe5\x27\x1e\x08\xe2\x1d\x4c\x95\x9d\xca\x56\x41\x8c\xde\x43\xec\x70\x12\x69\x56\xa5\x14\xd1\xc9\x72\x66\xe0\xe4\x00\x52\xbc\xa2\xe8\xe6\x64\xb7\xad\x21\xdb\xbc\xee\x6a\x2b\x06\x89\xd5\xb5\xe6\x9c\x3c\x9e\x69\x2f\x7a\xe8\xce\xb5\xf8\xf8\x03\xd7\x0c\x1c\xd9\x6f\x94\x19\x9f\x08\xfc\x67\xdb\xfb\xc7\x99\x87\x6f\x7e\xad\x12\x1f\x85\x5b\xb8\x05\x8b\x67\xce\xb9\x68\x84\xe3\xe1\x7d\x5f\xe8\x98\x88\xdc\x34\x35\xfe\x2e\x02\xa5\x60\x66\xaa\xa7\xd9\x5f\x1c\xe1\x79\x9b\xcb\x59\xec\x0b\x85\xa0\x93\xf8\xde\xce\xf2\xb2\x62\x65\x62\xba\xb8\x98\x09\xba\x5c\xbe\x00\xe8\x00\x18\x24\x02\xe8\xe4\x69\x4b\x3b\x93\x18\x9f\x66\x90\x93\x18\x1a\xa7\xab\x6d\x49\xd1\xf8\x71\x7a\x8e\xa5\x22\x3f\x64\xd7\xd7\x57\xcd\x43\xd0\x6a\xcb\x36\x70\x89\xd4\xdb\xd0\xc0\x21\x63\xd1\x2c\x50\xe2\x4a\xe6\x86\x42\xa4\xc4\x95\x6c\xbf\x5b\x6f\xc6\xab\xa0\x80\xff\x84\x4b\xa0\x94\xc5\x49\x64\x4c\x68\x41\x0e\x29\x11\x0e\xb8\xf8\xa2\x4b\x2e\x7b\x7d\x06\x8a\xe9\x08\x89\x0c\xf0\x90\x38\x6a\xbb\x8a\x1b\x16\xa2\xb1\x86\xc5\xe6\x71\xb1\xc1\x20\x74\x71\x3e\x9f\xc9\x66\x73\x15\x85\xad\x01\x0f\xf0\x4c\x4c\x9b\x88\xea\x12\x79\x32\x50\xda\x46\x60\x34\x1d\xa9\x5e\x55\x01\x01\x98\x54\x93\x87\x9d\xa4\xc2\x55\xc4\x34\xc8\x0a\x59\x6d\xeb\x91\x6a\x13\x64\xa7\xf4\x86\x31\xd9\xe9\x99\x0d\x4b\x99\xcb\x61\xe9\x95\x57\xe2\xbd\xf8\x08\xfe\x12\x1f\x9c\xcd\xec\x5b\xbf\x31\x73\x3b\x9a\xc1\xb8\x33\xdf\xd3\xd7\xfe\x65\xb4\xbd\x0b\x2a\xd0\x7e\x3b\xee\xbc\xfd\xc9\x2b\x16\xe2\x2d\x6a\xfc\xe5\x00\x90\x1b\xcc\x2d\x75\xf1\x68\xb8\xea\x1f\xad\x6c\x5d\x4b\xe2\xfa\xcf\x55\xfe\xb3\x00\x59\xb3\x1e\xc8\x2f\x13\xbb\xc8\x78\x7c\x3e\xd6\x2a\xba\x05\x13\x64\x58\xc6\xe4\x66\x43\x41\x81\x63\x58\x67\xc0\x13\x20\x5b\x9a\x36\xfa\xda\x14\x4e\x19\x9f\x36\x73\x48\xf2\xb1\xbe\x09\x69\x40\xfb\x7e\x6b\xda\xa2\xe7\x1b\xae\x40\x41\xab\xbb\x9e\xd1\x56\xc1\x41\x88\xcd\x4c\x48\x9a\x56\x4c\x20\xb2\x4c\x88\x66\x40\xdc\x31\xc9\x9d\x80\x9f\xd6\x6e\xac\x7d\x16\x4d\xaa\xda\x58\xd5\xb0\xf7\x29\xd8\x09\x5f\xf4\x1c\xb3\xab\xe5\x09\x18\x79\x0a\x77\x7d\xe6\x99\x19\x33\xb8\x25\xe3\xc7\x1f\xc3\x1b\x8e\xe1\xd5\xc7\x50\x4f\x38\xa9\xa5\x09\x5e\x4a\x8e\x65\xd6\x26\x06\x89\xc7\x47\x6b\x0e\x36\xa7\x2a\x38\x4f\xd4\x9d\x14\x6d\x8c\x49\x60\x91\xc3\x6e\x47\x2e\xc1\xe7\xf7\x27\xa4\xd2\x48\x44\x70\x09\x1d\x2b\x7c\x3e\x9b\x28\x02\x5b\x2c\x91\x8e\x25\x69\xf7\x69\x24\xed\x2e\x8d\x94\x36\xa7\x4b\x22\x11\x5b\x79\x39\xb0\x79\x98\x06\xda\x1f\x18\xb4\x84\x9a\xd3\x16\xa7\x2d\x46\xdb\xe0\xec\xc4\x9c\x02\x0f\x6d\x41\x6a\xd2\xf2\x64\x05\x61\x57\xee\x9c\x6b\x88\xd8\xed\xe2\x56\xe8\x05\xdf\x9a\xdf\x58\xdf\x8e\xa9\x95\xc8\x6c\xa8\xf0\x52\x0e\x88\xc8\x71\xac\xa9\x2b\x71\x93\xa8\x93\xf3\x28\x75\xcc\x90\x2b\x46\x1f\xd9\xf8\xc7\x33\xd0\xf2\xeb\x88\x41\xaf\x6f\x3c\xf6\x2a\xee\x75\x53\x97\x73\x28\x97\x40\xfd\x4f\x4f\x5c\x34\x1d\x6d\x5c\x90\x7c\x8a\xf7\xf6\xc3\xbb\x1c\x67\x79\x22\x78\x28\x3c\xbd\x06\x9e\x45\x2c\x6e\xd4\x03\xd7\xe2\xca\x75\x78\x95\x09\x1f\x4b\x2c\x51\xd6\xad\x45\xdb\x56\x2d\xfc\xd3\x8e\x4f\x35\x75\xbb\xf1\x99\xc6\x6e\x9a\x6e\xa3\xb5\xed\x97\xaa\xb8\xa6\xa3\x53\x1d\x65\x85\x45\x4e\x9b\xc3\x62\x71\x2b\xc8\xa6\xa0\x60\x80\x65\x81\xe4\xb5\xd9\x6d\x13\xd3\x6e\xbb\x1d\x48\x92\x93\xc2\xe2\xa9\x6c\x28\x7f\x55\xe2\x95\x6f\x8d\x0d\x9f\xc2\xa8\xbe\x57\x51\xb7\x25\xa3\xca\xcb\xc3\x33\xb6\x8f\x4e\x94\xc2\xa4\x6b\xd2\x79\x63\xc6\xfe\xfc\x33\x3e\xce\xf4\x5d\xba\xf4\x94\x67\xef\x3f\x2a\x2e\xbf\x74\xee\x8c\xef\xf6\xc3\x8e\xc7\xc9\xbe\xfe\xfa\xe3\xdf\x69\x9c\x4f\xe2\x27\x26\xa1\xf2\x0b\xfb\x68\xe5\x36\x22\xbe\xaa\xd3\x65\x95\x05\xc1\xe1\x73\xb9\x02\x7e\x8a\x13\xde\x48\x2c\xb4\x05\xd8\x44\xaf\x3c\x22\xed\x85\xf9\xb1\x55\x1b\x77\x21\xd7\x85\xa1\x9f\x3d\x23\xe2\xd2\x5c\x07\xb5\xed\x94\x47\xc4\x7c\x68\xd1\xd7\xd5\x57\x43\xff\xd5\x57\xdf\xb6\x02\xfa\xf5\x20\x8c\x41\xfb\xe1\x66\x3c\x66\x7f\xe6\x85\x35\xf7\xf2\x9b\xde\x7b\xcf\xc0\x8a\x68\x26\x36\x22\x40\x34\xe1\xe8\x54\xa5\xcf\xc6\x81\xa4\xbb\xc8\x66\x03\xc0\x5d\x5e\xe6\xf3\xf9\xed\x76\xd1\x6f\xe6\x26\xa4\xcd\x88\xbc\x44\x3f\xf2\xc6\x29\xf8\xa3\x18\xcc\x69\x88\x42\x3c\x80\xf6\x40\x4f\x38\xad\x1f\x55\x05\x68\xe9\x4d\xfb\x9e\x8b\xb3\xee\x27\xad\xab\x94\xa8\x35\xa7\x08\x1e\xdc\xb5\xb5\xbd\x8b\x06\x94\x5c\x19\xdb\x7c\xd3\x86\xc3\xef\xe2\x83\x0f\xc3\xab\xe1\xb0\x8f\x1e\x79\x24\x95\x59\x70\xf9\xf3\xbd\x7a\x6f\x1e\xfd\xfa\xd1\x77\xa3\x0d\xc3\xec\xdf\x98\xad\x4f\xbf\xb1\x64\xe2\x33\x70\xe0\x47\x70\x14\x5c\x76\xd1\xf0\xd3\x83\x6a\xaa\x50\x45\xa7\x0a\x7c\xea\xc4\x97\x6a\x63\x8f\x3a\x2e\xae\x8c\xd8\x97\x28\xb1\x34\xe7\xa5\x2a\x6d\x42\x69\x00\xc4\xdc\x6e\x5e\x10\x02\x14\x08\x0a\x79\x64\x59\x41\x62\x98\x38\x9c\x61\xa7\x52\xde\x90\x56\xbc\x4e\x5b\x63\xda\x69\x21\xaf\x60\x9b\x73\x52\x08\x1f\x9a\x73\x3a\xa1\x5e\xf4\x56\x30\xba\xfc\xcb\x03\x77\x1e\x9f\x6b\x5f\x2b\x0f\x2d\xbc\x3e\xbe\x4d\x37\xe5\x2e\x0b\x8c\xf0\x11\xad\x89\xce\x77\x5f\x7a\x5b\xcb\x83\xda\x00\xb7\xbc\x75\x2c\xef\x7a\x00\xaf\xd3\x63\xc6\x2c\xe6\xc4\xfd\x6a\x0f\x9f\x9f\xea\x73\x27\xb4\x7b\xc9\x1e\xb7\x7b\x11\x8f\x4c\xac\xcb\x6e\x67\x83\x01\x46\x25\x83\xf4\x0a\x82\x99\x28\x3c\xb3\x9c\x6d\x04\xd3\xf4\x79\x81\xe3\x51\x53\xd0\xd6\x11\x83\x31\x03\x04\xbf\x0d\xdc\x01\xdb\x84\x5f\x68\x05\x14\x12\x9f\x99\x92\x0f\x77\xf0\x39\x2c\x5b\x78\x1d\xa3\x64\xbe\x65\x94\xaf\x99\x1b\x34\xb8\x83\x67\xd0\x21\x15\xee\x00\x92\x9d\x0c\x28\xd7\x06\xb1\x3c\x63\x52\x95\x8a\xe8\x0f\x05\x4c\xb2\xdf\xcf\x12\x77\x3b\x40\x02\x37\x93\x29\xc0\xfa\x42\x20\xd4\x98\x96\x01\x08\xb0\x62\x40\xb6\x3b\x1b\xd3\x76\x57\xa3\xd6\xcf\x91\x4d\x0e\xe5\x35\x85\x15\xb0\x50\xaa\xf4\x54\xc4\x04\x19\x59\x21\xc6\xc0\x39\x13\x74\x04\xa5\xe0\x55\x5a\xf6\xa7\x3c\x35\xa6\x5f\xb7\xd8\x80\xae\x17\x5d\x29\xdc\x73\x2f\x3e\x7e\x15\xd3\x1d\xb2\x77\x5e\xe2\x7a\xbe\xe8\x8a\x71\x95\xe2\x09\xf1\xae\x3b\xf6\xe3\xdb\xe1\xe5\xfa\xdc\x9e\xa7\xce\xad\x8a\x80\x65\xf5\xb8\x81\x8b\xb3\x31\x92\xd9\xc6\xf1\x36\x5e\x42\x5e\xd9\xe5\xe2\x6d\xc8\x43\xce\xed\xc4\x34\x20\x07\x97\x77\xda\x10\x6f\x74\x96\x66\x2d\x65\x61\xb5\x96\x46\xea\x4e\xf3\x33\xaa\x87\x5d\x5b\x53\x1a\x53\x62\x24\xa6\xac\x8b\xb1\x9f\xcd\xfb\x19\x1f\x25\xff\x7d\xf8\x9f\xf9\xa3\x60\x6d\x23\x23\x34\xc1\xda\xcc\x9c\x5b\xf1\x17\xec\xaf\xfb\xb1\x9f\xb6\x98\xc2\xe3\xfb\x57\xaf\x5e\x9d\xd9\xd2\xa2\xae\xbd\x9a\x67\x54\x7b\x8f\xc2\x20\x9d\xaa\x0a\x3a\x2d\x4e\x49\xf1\x71\x48\x86\x01\xb7\x1c\x90\x23\x45\xc1\xa0\x20\xa3\xb0\xcb\x4d\xe6\x10\x28\x6e\xb7\xe0\x97\x45\x81\xec\x6a\x81\xec\x6e\xc1\xd8\xd9\xed\x88\xaa\x9f\x58\x1d\xf1\x89\xca\x8a\xf2\x3b\x51\x11\x11\x1a\x11\x83\xe7\x8e\x91\xb0\x17\xfd\x7e\xd9\x0b\xdf\xe7\x35\xa1\x7e\xf9\xd6\xfc\x05\xb0\x7c\x0a\xec\x3f\x01\x96\x64\x3e\x1f\xfb\x0a\xb2\xec\xcf\xac\x30\x7a\x50\x99\xae\xfb\x61\x67\x7c\x10\x76\x6e\x79\x1e\x0e\x57\x6b\x58\x5b\x7f\x24\xba\xbb\x86\x9c\xcd\x12\x50\x03\x16\xa5\x4a\x82\x72\x69\xb1\xc9\x24\x3b\x44\xb1\x23\x42\x72\x6d\xd7\x60\x30\x06\x1c\x4e\x47\xd4\x81\xcc\xc8\xe1\x88\x25\x8b\x8b\x5d\xb1\x52\x41\x33\x67\xa5\xa5\xae\x18\xa8\x6a\x48\x03\x67\xcc\xaf\x21\x7c\xc5\x88\x3a\x6d\xca\xe2\x71\x9f\x89\x97\x48\x8f\x2e\xa5\x65\x3e\x03\x8d\x47\x73\x69\x69\x2a\x4d\x34\xfa\xf0\x38\x1d\x43\x4a\x6b\x47\xee\x83\xd4\xfc\x50\x37\xa4\x42\x6b\x68\xa4\x58\xcc\x37\xf7\x3f\xf3\xd1\xc1\x6f\x87\x8c\x1c\x7e\x8e\x19\x26\x83\x27\xf6\x1f\xf8\xb4\xbc\x73\xb4\xc8\x5f\x56\x56\x59\x34\xed\x62\x0b\x3f\x37\x7d\xeb\xa4\xe6\x8a\x41\x3d\xfb\x5d\xde\x87\x1d\xfe\xe4\xfa\xcd\xcf\x30\x6c\xdd\xb4\xa9\x83\x9a\x1d\x1b\x36\xbe\xfd\x22\x5c\x35\xf6\x6c\xfe\x6e\x12\xa8\xb1\x97\x5c\x7c\x24\xf3\x07\xc3\x26\x06\xf7\x1a\x76\xee\xe0\xc5\x83\x0c\xac\x52\x32\x27\x14\xe3\x98\x78\xeb\x76\x10\x08\x08\x51\xb7\xe0\x2e\x49\x12\x65\x65\x77\x90\x18\x4e\x24\x0e\x7c\xb8\x21\xed\x75\x3a\xe3\x0d\x69\x67\x3e\x2c\x5d\x5b\x7c\x63\xad\x2c\xcf\xd0\x4e\x3a\xd7\xf4\x7f\x53\x4b\x26\xfc\x13\x6f\xfe\x4b\x95\x94\xd9\x32\x79\x85\x7c\x6d\xf8\x2f\xd4\x11\x91\xfd\x06\x22\xfb\xea\x9c\xec\xc0\x1e\x08\xf0\x51\xa2\x6b\xa9\xec\x66\xe2\xc9\xb0\x66\x91\x95\x55\xa9\x9d\xea\x08\xfe\x47\xd9\x93\x3a\x16\xb3\x7e\xac\xbb\xc5\xb2\xb9\x29\xa4\x5d\xda\xd1\xa4\x14\x7c\xd8\xca\xe3\xdf\x79\x13\x74\x52\x8e\x6c\xd0\x56\xf8\x27\x55\xd9\x99\x91\x1a\x3f\x36\x09\x62\xff\x20\x8e\xe6\x47\x13\xc6\xc3\xcb\xa8\xec\x70\x96\x2e\xbb\x86\xd3\x7d\x04\xc4\x40\x47\x8a\x87\x23\x04\xcb\xca\xec\x64\x04\x32\x40\x9d\x2a\x05\x21\x12\x0e\x85\xac\x11\x49\x6e\x4c\x4b\x3e\xf2\x8a\x58\xe5\x48\xb2\x21\x1d\x71\xa2\x8a\xff\x7b\x3c\x1c\x63\x4c\xf9\x88\x38\x05\x79\x47\x0d\x13\x27\x0f\x68\xfa\x99\xfb\x02\xcb\x12\xae\x26\xe7\x12\x2d\xd3\x88\x3f\x2a\x48\x30\x1a\x68\xd3\xbb\x57\xde\x63\x11\x0e\x73\xc2\xa2\x66\x0d\x89\x3a\x87\x3b\x4d\xef\xcf\x12\x64\x5d\x54\xdc\x69\xd1\xc9\x39\x59\x8b\xd7\xcb\x06\xfc\x34\xc4\xe2\x80\x5b\x0f\xb2\x4c\x39\xb8\x8b\xbf\xc2\x9d\xe6\x68\x4c\xad\xfa\x42\x2a\x6a\x98\x16\x72\xd1\x4a\x77\x26\x76\xc3\xa1\xeb\x44\x18\xb0\x5f\xd6\xf8\xc9\x87\x63\x26\xd8\xf0\xd7\x91\x96\xbd\x27\xa1\x03\xff\xea\x19\xbf\x75\xa6\x7d\xf2\xc5\x70\x2e\x9c\x4e\x02\xaf\xc7\x5f\x21\xee\xff\xaf\xf8\x14\xfe\x88\xce\xb9\xa9\xf5\x55\xb6\x8e\xc8\x15\x06\x49\x30\x2b\x55\x8f\xe2\x21\xa4\x70\x36\xab\x55\x91\x38\x00\x21\x57\xa4\x28\x5c\x69\x89\xcd\x66\x02\x81\xa8\xe8\x81\x6e\xe4\xf1\x98\x88\xaf\x64\x8a\x13\xc7\x36\x1e\x0f\x98\x4c\x62\x43\xda\xe4\x2c\x0e\xd0\x64\xe7\x99\xe0\xa8\x14\xd6\xb3\x6d\xad\x82\x94\xe7\xca\x2b\x6a\xca\x9c\x7a\xaf\x5e\x45\xad\xd2\x97\x94\xec\x6d\x49\x29\x0f\xbb\x92\x93\x4f\xd6\xe1\x99\xcd\x3d\x86\xf4\x82\x8e\x93\x2f\x9f\x8a\xe2\xaf\x29\x94\x33\xf3\xf8\xa6\xed\xbb\xff\xf8\x60\xef\x9a\x2a\x66\xe4\xc6\xcb\xae\x3e\x6b\xf5\x4b\x7d\xee\x4a\x8f\x98\x7b\x1f\xcd\x10\xbd\xf2\xb8\x83\x82\x39\x0f\xbc\x72\xcd\xb2\xfb\xb7\x4f\xef\x0d\xd9\x8b\xe6\x8e\x37\x7c\x90\x3e\xc4\xf7\x0b\x11\xdf\x8a\xf8\x20\x09\x8b\x5f\x66\x5d\xe1\xb0\x2c\x5b\xca\xcb\x88\xbd\x66\x39\x4e\xb0\xbb\xa1\x3d\x4a\xbb\x17\x05\xb2\xaf\x04\x2f\xf0\x53\xad\xad\x3b\x80\x67\x56\x33\xb4\x83\x61\xde\xd6\xe7\x50\xd3\xd9\x1e\xcd\x21\xc9\xcb\x67\xb3\xd7\x6e\x5a\x5f\x58\xa0\xb0\xa4\xaa\x47\x70\x16\xbe\x59\x3f\x2d\x78\xf4\x53\x4f\x67\x0a\xeb\x11\xfe\xfc\x7c\x91\xed\x30\x67\x43\xef\x14\x9c\x75\x7a\x27\x37\x38\x7b\x5e\x3a\xf2\x9e\x78\x3c\x04\xca\x6c\xc0\xd6\xa9\xd2\xed\x16\x89\x7b\x85\x44\x1f\x31\xe7\xbe\x08\x79\x89\x48\x16\xc9\xb0\x44\xa7\xb9\x43\x43\xda\xfc\xdf\x8e\x4b\x2e\x50\xa6\x87\xff\x0c\x8d\x55\x53\x5a\x9b\x77\x6c\xe4\xfc\x71\x8d\x6c\xa3\xbb\x18\x26\x7b\x6a\xb2\x25\x18\xdf\xb5\xd5\x5f\xcf\x5e\x61\x9c\x99\xcc\xc6\xec\xe8\x18\x30\x50\x3f\x2f\x6e\xb5\xb3\xb7\x82\x45\xc8\xa2\x58\x7d\x66\xb3\x24\x59\x43\x41\x12\x52\x38\x14\x4b\x73\x5a\xa1\x34\x6d\x8a\x02\x1c\x0e\x8f\x8a\xa4\xc8\x37\xb5\x3d\x3e\x67\x40\x6e\x17\x44\x14\xaa\xfe\x8a\xa9\x6d\x13\xf4\x04\x21\x8d\x78\x8d\x29\xdf\xf2\x43\x3d\x34\x97\xde\x71\xd9\x9c\xcc\x90\xdf\xbf\xfd\x15\x5a\xf0\xe9\xdf\xc6\xcd\x30\xc1\x47\xd8\x69\x9e\xb5\xeb\x94\x25\x0f\x6d\x30\xc1\x0e\xb0\x96\x42\x5f\xe1\xef\xf1\x27\x68\xdb\xf5\xd7\x2f\x5a\xd9\x5e\x2f\x94\x22\x9d\xd1\x0b\x65\xfb\xdf\xf5\x42\xe9\x16\xf2\xff\x71\x2f\x94\x26\x33\x3f\x44\xf5\xcd\x93\xe0\xa2\x54\xd7\x40\x22\x61\x63\x91\xab\x28\x12\x29\xf6\xbb\xfc\xa5\x25\x0e\xa2\x91\x12\xc5\x52\xb1\x54\x84\x02\xc8\xcf\x3a\xfc\x2c\xeb\x77\x20\x19\xc8\xb1\x66\xda\x9f\x1c\xa2\x63\xc8\x07\x91\xf2\xa9\x45\x68\x4a\x3d\xd1\x4e\xae\xfa\x36\xf9\x43\xc3\xca\x2b\x75\x7a\x82\x50\x51\x2f\x45\x65\x7d\x48\x49\x63\x44\x12\xe7\x62\x6a\x9e\x3f\xd9\x79\x6f\xc8\x59\xd7\xb7\x43\xff\x92\xb3\x17\x2e\xbd\x72\x45\x12\xff\x41\x47\xb7\x35\xfe\xbc\x3e\xba\x8f\x71\xa3\x4c\xcc\xfa\xd6\x92\x95\xc3\x7a\x28\x9e\x1d\xdd\xa7\x5f\xe3\x23\xcb\xf1\x99\x3a\xc6\x8b\x8f\x6a\x63\x84\xa3\xcf\xa2\x85\xb0\x54\xff\x9e\xdd\xfa\x1d\xfa\x3b\x19\x67\x29\x45\xe1\x2b\x4e\x4a\x4e\xc5\x52\x44\x16\x86\x0f\x3a\x93\x7c\x79\x19\x1f\x0c\x04\x82\xcd\xe9\x62\x20\x11\x7b\x09\xec\x76\xb2\x9d\x88\xd3\x1b\x3b\x63\x3b\xb9\xea\x5d\xf5\x46\x2b\x4e\x1b\xdc\xd9\xbc\xba\x9c\xfc\xac\x68\x8d\x9c\xc5\x71\x50\x1c\x90\xb1\x1f\xfd\x61\xdd\xdc\x99\x57\x7f\xf6\xec\xce\x6f\x02\xdf\x9b\x26\x0d\x1f\x3c\x7c\xf9\x1d\x0f\x2d\x4f\x37\x0e\xbe\x4c\xfa\xb9\xfc\x63\xcf\xa6\x75\x97\xad\x75\xb2\xee\xc5\x13\xaf\xdb\x78\xef\xed\xde\x01\x43\xfb\xf7\x1a\x36\x68\xdb\xd0\x91\xa9\x86\xf4\xb9\x1d\xd7\x3d\x48\xc7\x51\x4b\xc6\xf1\x9c\x31\x0e\x4b\x52\x2a\x52\x7c\xe4\x6c\xf8\xec\xb1\x22\x3a\x8e\x18\xf1\x4e\xec\xcd\x69\x16\x28\x41\x87\x03\x04\x83\x64\x1c\x41\x27\x10\xfe\x6f\xc6\x91\x6b\x1a\x4f\xd4\x66\x93\x8c\xb9\x62\x3b\xb5\x32\x87\x87\xdf\x6f\xff\xb8\xfc\x67\x69\xfa\x39\x8d\xe9\xe5\x0f\xdd\x79\xc3\xf0\xc1\x0d\x13\x4d\xdf\xfb\x8f\xef\xdc\xf1\xc9\xa2\x6b\xae\xbb\xe7\x67\xcf\x83\xeb\x3a\x0e\x39\xbf\x21\x35\x72\xe8\xb6\x41\xc3\x7a\xf5\x1f\xd6\xdf\x7b\xfb\xbd\xeb\xaf\x9d\xb4\x34\xc0\x38\xd6\x5c\x72\xd7\x53\x6a\xce\x91\xe8\xae\x05\x64\x1c\x35\x60\x46\xaa\xa7\xa5\x4b\x45\x49\x24\x3b\x94\xca\xa2\x2e\x7c\x6d\xd7\x32\xe2\xa3\x14\x55\x04\x2b\x2b\x8d\x21\x95\x29\x8e\x60\x99\xa3\xec\xaf\x87\x45\x37\x1f\xad\x11\xcc\x0e\xad\xbe\xbe\x00\x64\xa3\xe6\xff\x60\x88\x64\x6f\x7a\x73\x5b\x33\x3b\xdc\xaf\xda\x1f\xee\x0d\x7b\x2a\xef\xf5\x86\x2e\xd7\xf6\xe8\x94\xd5\xd1\x1e\xf7\xfd\xc5\xe0\x47\x9d\x13\x9e\x7f\x27\xdd\xa5\x13\xc6\x8c\x8b\xeb\x93\xc0\x80\x66\xa2\x2f\xea\x54\x7d\x91\x00\x5d\x52\x01\xa7\xd7\x6b\x0e\xa2\x58\xcc\xe6\x0b\xb2\xc9\x62\x37\x68\x26\x1e\x41\x11\x51\x69\x45\xb9\x41\xea\x83\xd1\xcd\x0d\x9f\x2d\x9b\xd2\xc7\x51\xaa\x56\x22\xe9\x68\xcd\xaa\x4f\x70\xd5\xa2\x15\x37\x2c\x68\x4c\x8f\x5b\x36\x77\xfc\xf0\xa1\xbb\x7e\x38\xb6\x68\xc5\xc9\x23\x2d\xf8\x18\x0c\xa1\xf5\x7b\x5e\xd9\xfe\x1a\x91\x72\xd0\xce\xb3\x1b\x7a\xf5\xdf\xbe\xe1\x9a\xfd\xb5\xf6\x65\xd3\xee\x79\xce\x40\xb3\x24\x6b\x24\xe2\xd1\xcc\xbd\x24\xbe\x91\x89\x27\x99\xb0\xcb\x32\xbd\xe3\x72\xb9\x90\x20\x28\x5e\xa2\xc4\x64\x8f\xdc\x90\xe6\x3d\xb2\xc5\xde\x90\xb6\x88\x4d\x69\x4b\x36\xa2\xd1\x32\x7a\x79\xbc\x69\xda\xe6\xaa\x93\x8c\xa4\x8d\x11\xcb\xd0\x64\xce\x31\xe8\xdb\xb0\xc1\xa0\x08\x3a\xb2\x17\x2d\x6c\x59\xb6\x77\x85\x4e\x13\x74\xd9\x5e\x3d\x7f\x30\x5c\xb5\x73\x65\xa0\x1a\x4c\x48\xd5\x84\xc4\xf2\xf2\x04\x10\x78\xbe\x13\xd1\x43\x5d\x6b\x22\x25\x8d\xe9\x48\x82\xbc\x7c\xce\xa0\xcb\xe7\xeb\xd8\x90\xf6\x39\x89\xe9\x73\xb9\x3a\x37\xa4\x5d\x32\xb2\x34\xb5\x05\x09\x31\x76\x8b\x81\xd7\x95\x97\x47\x55\x4d\x1e\x9b\xc8\xcb\x36\xd5\xe5\x6c\x9f\x52\x23\x9d\x61\xf9\x24\xcd\xf0\xe1\x53\xa7\xde\xf8\x39\x04\xfd\xe2\x45\x8d\x73\x2e\x63\x98\x71\xad\xaf\x1c\xf8\xe7\x3b\xdf\x8d\xe5\xb6\xdc\x93\xb5\x7f\xb4\x9b\x6e\xd6\xbc\xd8\xf1\xef\xee\xba\x39\x76\xd6\x90\x5b\x6f\xa9\x9f\xbe\x0f\x16\x91\xa9\x36\xc3\xe8\x6b\xb0\x74\xd5\xdd\xba\x0d\xdc\xf2\xd8\x4b\xf8\x6e\xfc\xc0\x4b\xc0\xe8\x6b\x62\x1b\x5c\x3c\xed\x6b\xd2\x79\x34\xa6\x92\xfd\xa2\x66\x8e\x21\x6b\x91\x9c\x4e\xd6\x6b\x09\xb1\xac\xa5\x28\x2c\x49\x82\x9d\x81\x8d\x69\x86\x11\xec\x76\x37\x8d\xd9\x05\xe2\xbf\x08\xde\xff\x82\xb9\x9f\x4d\x35\x90\xbd\x94\x50\xa1\xaa\xb4\x96\x49\xd5\x1b\xcb\x31\x20\xd5\xa1\xf3\xdf\x86\x1f\x5c\x7d\x7c\x29\x3e\x89\xff\x01\xcb\x5a\x5e\xc1\x1d\xf0\xbf\x7d\x3b\x17\x2d\x5b\xb3\xaa\xff\xd8\x8e\xf0\xe2\x43\xb8\xc7\xe0\x5e\x2a\x69\x86\x09\x56\x6d\x7d\xb8\xf4\x91\x6d\x9b\x9f\x79\x51\x56\xa8\x6f\x89\x1b\xd9\x69\x6a\x7d\x5b\x88\x72\xc5\xd8\x44\x20\xb3\xc8\xec\x94\x1c\x76\x09\xd9\x15\xb3\x0b\x21\x73\x51\x58\xa4\xf0\x33\xbc\xd3\x2e\xf2\x01\xb2\x9d\x42\xb9\xcc\xc8\x19\x1e\x96\xe1\x35\x42\xc5\x9b\x83\x23\xd7\x70\x90\x69\xd5\xaf\x5e\x08\xf9\x6d\xff\x49\x4f\x3d\xb0\xe1\xd9\xb3\x9a\xf1\xf5\xb0\x1c\xb2\x50\x84\x25\xb8\xac\xaa\xec\xbc\x8e\x1d\x3a\x54\x42\x71\xc1\xb6\x8b\xd7\x6e\xd8\xb8\xba\xc7\xb6\x75\xa8\x67\xe6\x1e\x66\xea\xe9\xb3\xbb\xdc\x38\xf0\xa1\x71\x5d\x7b\xf6\xd0\xf9\xa8\x0e\x92\xf9\xb5\x82\x4a\x9a\xc9\x94\x42\x65\x3c\xeb\x88\x77\x54\x1c\xa8\xa3\xd9\xd1\xd1\x51\xd5\x29\x14\xf2\xf3\xbc\x3f\xe1\xf5\xda\xfc\x49\x8f\xdf\xd3\x98\x8e\xfa\x9d\x36\xd0\x90\xb6\x79\xdb\x56\x8f\xd4\x48\x67\xa2\x6f\xab\xc2\x27\xb5\x83\xaa\x96\x3c\x2a\x51\x3a\x82\x52\xad\x12\xbb\xa6\x3a\x02\xeb\xb2\xd0\x57\x22\xa4\x20\x1e\xcc\xe5\xc9\x4e\x89\xce\x5d\xe2\x95\x25\xf8\xed\xea\xc9\x23\xcb\xd3\x8d\xe7\x0d\x5a\xb4\xf6\x85\x11\xe7\x0c\xaa\xb8\xfe\xc2\xb5\x8b\x06\x9d\xd7\x98\x2e\x1f\x39\xa4\x3a\xb0\xa5\x73\x79\x62\xdc\xd0\xc6\xb1\xb1\xf2\xce\xaf\x9c\xec\xb5\x7a\xdb\x93\x63\x06\xbd\x31\xe3\xc1\x15\x2b\x46\x0c\x9b\xf1\xc6\xa0\x31\x4f\x2e\xbd\x6c\x7c\xe5\x49\x8a\xd9\x86\x47\xb3\x23\xc9\x7a\xa8\xb8\x5c\x50\xe2\x2d\x16\xe2\x4f\x79\xdc\x56\xab\x43\x70\x89\x96\xa0\x03\x35\xa6\x1d\xde\xbc\x56\xb7\xb6\x20\xc5\x06\xcc\xb3\xa4\x87\xe6\x3a\xf4\x1a\x3e\xd1\xe9\xf9\x79\xf9\x70\x6b\xa7\xc2\xcc\xa4\x69\x17\x69\x08\x6b\x06\x4e\xf8\x64\x15\x93\xeb\x9c\x54\xd2\x27\x38\x8b\x44\x93\x20\x3a\x05\x67\x3c\x06\xa2\x51\x27\xf2\x90\x70\xce\x13\x24\x2f\x64\x72\xca\xc8\xda\x98\x46\xba\x4b\x51\x93\xef\x9b\xe6\xcd\xa4\xba\x63\xf5\xaa\xa3\x58\x0e\x3b\x39\x3f\x98\xf3\x08\xf0\x11\x0d\x31\xf9\x5f\x6a\xdd\x51\xd6\x11\x35\xa1\x49\x6a\x39\x51\x33\x73\xa1\x86\xf7\xce\x6e\x37\xfc\xcf\x73\x2e\xbf\x44\x97\x97\x72\x62\x13\x79\x3b\x80\x31\xa9\x2a\x47\x5c\x08\x94\xf9\xfd\x01\x97\x20\x04\x3a\x56\x80\x0e\x1d\x02\xa8\x28\xde\x98\x2e\x4a\x92\x17\x0a\xc8\x48\xa6\xf2\x5a\x1c\x8d\x69\x8b\xb3\x31\xa7\x03\xdb\x7a\xd6\x05\xd2\xe7\x89\xaf\xd5\x85\x51\x65\x58\xfb\x3f\x0c\xe4\xfe\x47\x3a\x5f\x15\xea\x51\x75\x5d\xfb\xc3\xe1\xb6\x3d\x69\xe5\x0f\xdb\x16\x31\xcf\xb6\x3b\x2a\x86\x18\x4a\xa0\xe6\xbe\xad\x40\xa4\x79\x01\x91\x35\xd9\xa0\x99\x37\x59\x4d\x64\x0b\x38\x29\x1a\x7a\xa3\x86\x86\x2e\x9a\x65\xbb\x6d\x44\xda\x0e\x73\x9c\x6a\xed\xb1\x60\x16\x62\xa3\x53\xa4\x43\xef\x02\xe8\xbf\xe6\x1a\x7c\x7c\x01\xf9\x9b\x59\xab\xe6\xb6\x71\x3d\xdc\x87\xba\xd1\xdc\x36\x04\x97\xb5\x7e\xc7\xd4\x93\xbd\x67\x07\x25\x29\xb7\xc0\x30\x94\x6f\x0e\x88\x16\x81\xcc\x19\xd7\xa8\x01\xf2\x18\xd0\x74\x7a\x42\xbd\x00\x3a\xf1\x32\xe8\xef\xd6\x27\x9c\x18\xdb\x6b\xe3\xed\x64\x9f\x79\xfb\xf6\xe6\xbf\xb0\x3f\xf3\x12\xbd\xf7\x25\xe3\x3a\x45\xbe\xd7\x0a\xea\x53\x21\xd6\x04\xcd\x26\xde\xcc\x5b\xad\x76\x1b\x07\x55\x75\x28\xf2\x16\xb3\xa5\x51\xab\xef\x2a\xb8\xe8\xcd\xcb\xdd\x53\xed\x47\x06\x52\x23\xc7\x6a\x6b\xa0\xeb\x5d\x66\xe7\x7b\xef\x65\x86\xbc\x8b\xa6\x1d\x3c\x98\x99\x72\xf0\x60\x16\x27\x93\xd9\xac\xd6\x08\x9e\x9f\xf2\x3b\x44\x96\x23\x71\x3b\xb0\xba\x4d\x6e\x40\xef\x5e\x1d\x66\xca\xad\x62\xa2\x40\xf7\x3b\xd3\x26\x13\x30\x5b\x5d\xea\x3f\xad\x56\x33\xa4\x05\xbc\x7d\x73\xd8\xb6\x05\x61\xbd\x94\x8f\xe5\x43\x0b\x0f\x88\x5e\x48\x10\x9d\xa0\xdd\xa9\xd6\xd0\xdb\xd5\x7d\x1d\x42\x4b\x26\x5d\x0c\xfd\xa5\xf1\xc5\xe3\x2f\x65\x3e\x62\x2a\xeb\x6e\xbd\x9a\x67\x06\x65\xfa\x32\x1d\xeb\xef\x9c\xcb\x65\x1e\xd0\x62\x41\x8a\x73\xff\x9a\x5a\x8b\xa0\x80\x61\xa9\x12\x20\x32\x36\x09\xc9\x26\x06\x21\x93\xdf\xe7\x72\x5b\x49\x9c\x61\xb5\x22\x3b\x64\x25\xb6\x39\x2d\x4a\x44\x01\x43\x54\x88\x7b\xaf\x0a\x57\x70\x09\xae\xe7\x4c\xd4\x25\x56\xb5\x6d\x4f\x9a\x33\xad\x89\xd5\x52\xae\xa2\x1a\xe6\xb5\x79\xf8\xb8\x6b\xfe\x1d\xb7\xcf\x51\xa0\x7f\x1e\x9e\xe5\x9a\x30\x01\x1e\xc7\x7e\xf8\xaf\xb5\xb3\xae\x58\x0b\x3f\x6d\x79\xe7\x91\xc6\x91\xd9\xf3\xc4\xac\x55\xeb\x87\xc8\xda\x5b\x78\x1e\x21\xd1\xc1\x42\x40\x96\x05\x98\xf2\xe2\xeb\xdc\xda\x43\x1d\x3c\x5e\x0f\x9d\xdf\x7f\x74\x83\x11\x23\x8f\x7e\x72\x1b\xef\xd7\xa3\x61\xfd\xbb\xcf\x63\xb7\x90\xef\x0e\x93\x75\xa9\xe4\xfd\x7e\x33\x70\x8a\x22\x40\xe1\x30\x08\x72\x9c\x6c\x36\x83\x48\x91\xd3\x69\xf3\xfb\x01\x82\x64\x25\x10\x09\x87\x91\x68\x73\x35\x65\x11\x00\xd5\x4d\x2e\xb5\x07\x11\xae\x1f\x56\x6d\x5d\x54\x36\x72\xea\x58\x81\x44\x36\x70\xd4\xc1\xe4\xa4\x35\x64\xc3\xbf\x89\x3f\x78\x7c\x37\xfe\xf0\xf7\x6d\xa7\xba\x41\x38\xec\xde\xa5\x73\xd7\x6f\xf3\x43\x05\x5f\xc2\xbd\x83\x67\xbc\x86\xd7\x86\xbf\xdd\xf9\x2d\xfe\xcf\x8a\x25\xbd\x6e\x5a\xbb\xfe\xf6\xe5\x7b\xe0\x05\x2d\xb7\xa9\x18\x9a\x27\xf8\x3b\xc9\xde\x2d\xa1\xd6\xd1\x0b\x93\x49\x73\x34\xec\xe4\x79\xb3\x39\x5c\x56\x2a\x39\xbd\x48\x51\xec\x25\x42\x11\xb1\x8f\x28\x1e\x20\x2a\xc7\x13\xf0\xb6\x41\xe3\x57\xf2\x57\x4b\x65\x4d\xc9\xd7\xd3\x1a\x4e\xa6\x56\x61\x97\x07\xc9\xaf\x72\x65\x49\xac\xf4\xc8\x79\xd3\xa0\x9f\xe2\x65\x22\x0b\xdb\x75\xfd\x65\x27\x6b\xf9\xba\x7b\xe7\x6d\xd8\x04\x95\x47\x9a\x2f\xe5\x34\x65\xbe\x75\x15\x33\xa0\x65\xd7\xe8\x99\x1d\x3d\x8f\x44\x16\xce\xfa\xee\xda\x19\x1f\xbc\xc5\x3c\x4d\x7f\xf1\xc0\xcd\x4c\x93\xb6\xb6\xc4\xa6\xf0\xb7\x90\x31\x44\xc9\x18\x8a\x9d\x30\x12\x31\x2b\xd4\xae\x04\x14\xb3\x12\x8f\x59\x9d\x92\xe4\x89\x0a\x3e\x62\x5c\x50\xc8\x43\xe6\xde\xe1\x69\x3b\x84\x9a\x36\xba\xb1\xcd\x18\x34\x5b\xd3\x46\xfa\x5a\x43\x7a\xfc\x63\xf5\xfa\x2b\xf2\x04\x3f\x6f\x5a\x4e\x6e\x62\x84\xae\xbc\xf2\xb2\x3c\x99\x9f\x58\x62\xc8\x4c\xeb\x66\x37\xb0\x0d\xa0\x0a\x8c\x4d\x75\x96\xab\xaa\x40\x31\x30\x95\x85\x45\x41\x30\x85\x4d\x5d\x3a\x7b\x9d\x14\x55\xde\x64\x15\x81\x49\xae\x40\x14\xba\xdf\xef\x76\x46\x8b\x89\xb1\x27\x8e\x66\xb4\x8d\x93\xab\x32\x59\xb4\x59\x06\x7d\x13\xc7\xda\x43\xf5\x57\x6a\xfe\x52\xf1\x23\xdb\x23\xa3\xa6\x1b\x15\xb2\xda\x82\xd4\xdc\xb7\x60\xc3\x26\x5d\xf1\x2f\x21\xbf\xa5\x75\xb1\x5b\x57\xe5\xd5\xc5\x7e\x77\xcd\xec\x0f\xde\xca\xb0\x86\xf2\xdf\x0e\xc3\x9b\x6e\xc8\x50\x5c\xd3\xd6\x47\xa9\x0d\x23\x63\x8c\x51\x6c\xc9\x70\x8c\xf7\x7a\x63\xa2\xc3\x11\x23\xae\x06\xcf\x8b\x8c\x28\xca\x16\x17\x35\x59\xfe\x30\x19\x5e\x84\xbc\xf2\x0d\x57\x5b\xd8\x2e\x0d\x34\xb9\xa0\xd8\xd7\x18\x5c\xde\x30\xd6\xe4\xf3\x14\x50\xab\xbb\xe1\x51\x4d\xf0\xfc\x2a\xde\x26\xbd\xb4\x77\xa6\x2e\xb2\xb1\x1e\xdc\x70\x43\xd6\xa0\xd7\xc1\xf3\x42\xcc\xeb\x15\x88\x17\x54\x50\xb4\x5c\x14\x20\x26\x97\xf8\x0a\x45\xff\x93\xac\x7f\x51\xa0\xec\xc9\x5e\x0d\xd6\x9e\x59\x8d\xac\xaa\x97\xda\x4d\xf7\xb5\x53\x7a\xdc\x92\x51\xd5\xcd\x96\x67\xa8\xac\x37\x13\x5f\xe6\x42\xd5\x8e\x75\x4d\xf9\x4c\x1c\xc7\x43\xab\x15\x00\x5e\x74\x10\xc7\xdb\x6c\xe6\x6d\x82\x08\x79\x95\xe1\xa4\xad\x0b\xab\x89\x56\x0e\x29\xdb\x04\x25\x1a\x20\xbb\xb9\x86\xbd\x10\xb7\xe0\xb8\xe5\x14\xd1\x2c\xaf\x5b\x4e\x31\x7f\x5c\x32\x25\xf3\x01\xd9\xc1\xf2\x8d\xcd\x8c\x0b\x20\xad\x7e\x5e\xf5\x47\x9d\xc4\x7e\x8f\x49\x75\x76\x78\x3c\xbc\xe8\x26\x26\x87\xf7\x29\xa2\x07\x3a\x38\x87\xa7\x21\xdd\xd1\xd1\xcb\xc1\x20\xbb\x03\x3a\x58\x87\x03\x99\xcd\x36\x15\x8b\x5f\xca\x4b\x8a\xe7\x15\xc4\x54\x00\x7a\xff\xd2\x76\xba\x40\xcc\x60\x41\x48\xc6\x51\x8c\x41\xd5\x6e\x32\x6f\xec\xed\xf8\x63\x8c\x75\xf6\x03\x12\xa6\x28\x99\x63\x5f\x46\xe0\xc9\xf0\xf1\xcf\xe2\xd8\xee\x5e\xc4\x14\xe1\x3f\xf1\x91\x2c\xf7\xc1\x67\x13\xf0\x09\x28\x67\x22\x90\x5f\xba\x4c\xc7\x05\xe2\x87\x13\xd9\xbd\x20\x02\x66\xa5\x7a\x13\xa9\x15\x45\xb2\x23\x39\xc8\xc9\x5c\x2c\x6a\xb1\x90\x49\xb3\xba\x42\x62\x47\x91\x41\x40\x84\x22\x2f\x8a\x5e\xab\xc9\x4f\x93\xc9\x56\xe2\x4b\x59\x45\x2f\x89\x61\xbc\x32\x53\xd4\x90\x66\xda\x50\x0a\x14\xd4\xf7\x14\xb8\xd9\x59\xd6\xa2\x24\x9f\x65\x18\xd0\x89\x5e\xd5\xff\x90\x33\xa6\x31\xac\xa1\x1b\xe6\x3d\xa4\x0f\xec\xfe\x39\xcc\x5b\xb8\x3f\xbc\x03\x4f\x87\x7b\x32\x75\x8e\x56\x40\xa9\x1d\xa0\xbd\xf6\x1c\x63\x64\xfd\xab\xf6\x7f\xb6\xff\xe4\x01\xa6\x08\xce\xa4\xac\x0e\x74\x6c\x4d\x64\x6c\xb3\xd5\xdc\x64\x82\xf2\x0c\xd8\xcc\x66\x05\xc5\x25\x45\x89\x27\x8b\x2d\x16\x4f\x28\x1c\x8e\x78\x3c\x24\x2a\xf0\x38\x45\x3e\xc2\x37\xa4\x03\x91\x9c\xd2\x6b\x2f\xd5\xaa\xb7\x35\x1a\xf1\x16\xad\xd6\xa1\xff\x90\xba\x96\x24\x55\x0e\xb4\x44\xb4\x54\x2d\xff\xad\x75\xa2\x89\x99\x3f\x2f\x9c\x78\xde\x44\xc8\x5c\x38\xea\x6f\x3f\xe1\x53\xf0\x7a\xb8\xfa\x8b\xf7\xf1\x77\x83\xd8\x41\xf8\xbb\xf7\x8e\xa1\x55\xaf\xbf\xfb\xcc\x7d\xf7\xaf\x7e\xe9\xa5\x5b\xee\x83\x43\xff\xb1\xf7\x75\xfc\x3e\xfe\xff\x30\xfe\xcf\x0f\x3f\x40\xcf\x49\xe6\x3c\xb5\x76\x87\x72\x3a\x6c\x23\xf6\x52\x02\x3e\xb2\x32\x43\x53\xa5\x16\x2f\x09\x1d\x43\xc0\xcf\xba\xec\x2c\xb0\x53\x54\x4a\x08\x82\x72\x58\x08\x93\xa8\x5e\x70\x7a\x43\x30\xd4\x90\x76\xc2\xf6\x4a\xbc\xdb\x82\xd7\x41\xa9\x84\x4e\x7a\x92\x1c\x3c\x96\xfe\x43\xa0\x8d\x0e\xa5\xc4\x91\x49\x12\x4b\x44\xf4\x38\x33\x1f\xe3\x7f\xc2\x38\x99\x56\x89\xbc\xe2\xf8\x9f\x18\x0a\xd7\xae\x5c\xbc\xa2\xe5\x8b\x95\xd7\xae\x20\x76\x04\xde\x41\xd3\xaa\x80\x6c\xb6\xa4\x09\x5e\x8b\x97\x9a\xf0\x47\x38\xd3\x0a\xf0\x11\x01\x4f\x47\xfb\xb6\x3e\x67\xcb\x44\xcc\x7b\x9f\x7c\x6a\xb7\x99\xf9\xc2\xfa\x9c\x56\x77\x72\x82\xa1\xf6\xd3\x0b\xba\xa4\xfc\x4e\x13\xf0\x7a\x7d\x0a\xf1\x67\x39\xaf\xc8\xe5\xee\xae\xbd\xf9\x77\xd7\x46\xe1\x86\x46\x5b\xa3\x9b\x47\x26\x47\xfd\xc2\xdc\xa2\x1b\x44\xed\x8e\xba\x7f\xed\xa5\x73\xd8\x1e\x2d\xaf\xa7\xe7\x75\xca\x5e\x4f\x3f\xf1\x18\xe3\x36\x9e\x4d\xe6\xf1\x8c\x67\xc3\xff\x87\xcf\xe6\xde\x39\x5d\x5d\xf8\x6c\xf4\x28\x7d\x36\x1e\x8d\xe6\xab\xf7\xce\xfd\x53\xc5\x1e\x3f\x07\xa1\xdd\xef\x0f\x05\xed\x0e\x87\x14\x10\x25\x12\x96\x4a\x5e\xfa\x32\x13\xc7\xda\x4c\xcc\x97\x39\xab\x2f\xb3\x15\x14\x39\xd7\x53\x95\x26\xa7\x18\xa5\x44\xee\xa6\x99\x8a\xa4\xa9\xc5\x87\xd6\xb2\x35\x73\x27\x19\xf3\x71\xfa\x0a\x55\x1f\x6e\xda\x09\x3b\xdd\x3a\xc5\x98\x11\x5d\x8f\xab\xf5\x05\x32\xa8\x49\x05\x88\xda\x96\x01\x50\xbc\x26\x41\x00\x48\x04\x41\x9b\xd8\x98\xd6\xd8\x42\xce\x9c\x14\x2d\xa0\x38\xb3\x72\x40\x96\xd6\x14\x96\x0c\x5c\x3a\x87\x98\xb5\xaf\xf3\x8a\x05\x9e\x78\xac\x65\x40\xc1\xb3\x29\x3b\x4c\xd2\xe7\x88\x38\x78\x8f\x27\x12\x89\x45\x89\xb9\x0b\x31\xa2\xaa\x53\x9c\xf4\x15\x22\x06\x24\x44\xa6\x27\xf4\x17\x93\xa2\xf5\x19\xe7\xd9\xbb\x3c\x61\xf2\xe6\xe9\x0c\xb9\xb4\x89\x7a\x74\x03\xea\x55\x20\x5d\xe6\x1e\x75\xae\x9e\xdc\xa6\xc7\xc1\xc8\x45\xf4\x86\x0d\x24\x53\x12\xc7\x03\xde\x61\x07\xc0\xc2\xcb\x16\xa6\xb1\xa0\xf5\x59\x53\x0c\x64\x65\xc8\x63\x55\x48\x19\x9a\x7c\x42\xae\xfa\xb1\xff\xc4\xc7\x3f\xfa\xd7\xbc\x73\xd0\x30\x05\xef\xcb\x1c\x61\x3a\x40\x17\x74\xf9\x35\x9f\xc6\x42\xc6\xbf\xda\xf8\x6e\x1b\x2f\x08\x0e\xbb\xcd\xc6\x08\x41\x86\x78\xd9\x4c\xe1\x77\x6b\xb3\x4d\x2f\x3b\xd5\x2f\x27\x2e\x81\xe5\x9c\x79\xff\xfa\x08\x1f\xff\xe7\xd8\x7a\xb6\xd6\x8f\x7f\xc0\x3f\xb4\x54\xa2\x7f\xc0\x7a\x9a\xc3\x59\x45\xec\xdd\x63\xaa\xbd\xf3\x10\x0f\x4f\xb6\x5b\x2c\x02\x63\xb3\x5a\x05\xe2\x96\x33\x92\x20\x30\x5e\xd9\x01\xb4\x72\x00\x62\x7c\x6c\x8c\x8c\x3c\xcd\xc4\xc3\xce\x65\x71\xce\x24\xf8\xaa\xd7\xe9\x06\x29\x07\x31\xcd\x28\x53\x1a\x2b\xe2\x3e\x74\xad\x80\xf0\x11\xfc\x0d\x3c\xfe\xe3\x89\x39\xb3\x61\x3f\xfc\x36\xfe\xe9\xe5\x83\x7b\x0e\xbc\x02\xb7\xe3\x61\x6c\x8f\xfb\x36\xcc\xbb\x33\x84\xcb\xe1\xf6\x2d\x77\xdc\xa5\xc6\x3b\xf9\x72\x0d\x4e\x79\x00\x42\xbc\x05\x32\x8c\xc4\xd3\xfb\x79\xde\xe2\x95\xed\x1e\x4d\x2c\xbb\xdd\x02\xad\xa2\xc5\xd1\x9c\xb6\xc8\xed\x8b\x95\x93\x2a\xc7\x75\x47\x3d\x4f\xa4\x49\xc5\x4c\x84\x4e\xd8\x0d\xef\x9d\x3d\xe7\xc4\x8f\x24\xbc\x09\x30\xaf\x1c\xd8\x73\x90\xb9\x91\xc8\x55\x1e\xbc\x7b\xee\x86\xfb\xd8\x1e\x78\x18\x2e\xbb\xeb\x0e\x6d\x1d\x06\xeb\x75\xd7\xd5\xe0\xb2\x54\x1f\x8f\xdb\xcd\x57\xc4\x4a\x40\x75\x75\xc0\x1e\xb3\x77\xad\xe9\x54\xde\x98\xee\x14\x0c\xf0\x25\xa8\xd8\x59\x8c\x9a\xd2\x80\x18\x76\xc6\x42\xe2\xee\x62\xaf\x53\x69\x4a\xbf\xef\x81\xb3\x3c\x30\xe8\xa9\xf0\x30\x1e\x8f\x93\x2c\x5a\x4d\xd5\xb8\x71\xe3\x54\x91\x8d\x5b\xa1\x36\x65\xd9\x64\x28\xd5\x5a\x4f\xd6\xff\x51\x61\xb6\xec\xc9\x71\x11\xc0\xbe\x3a\xf8\xeb\x5f\xd4\x64\xdf\x31\x91\x6c\xe9\xd1\x0d\x9b\xd6\xc3\x1a\x1d\x07\xb6\xfd\x52\xec\x4e\x57\x2d\xb2\x1d\x90\x9e\x7a\x1a\x8e\x35\x7a\x94\x98\x3f\xb8\x7f\xa8\xe8\x45\x41\xa7\xd7\xcb\x9a\xcd\x01\xbf\x56\x44\x44\x5e\x6a\x41\x1d\x9f\x8b\xf9\xaa\xf2\x18\x13\x68\x0d\x5d\x89\xa1\x79\xf2\x59\x12\x3d\xfc\x35\x15\x17\x78\xea\x06\xf7\xeb\xbd\xfb\xd5\x74\xbf\x0e\xc3\x06\xf5\x7b\x11\x8f\x76\x08\x47\xe4\xc6\x39\xec\x94\x37\x9f\x73\x7f\x20\x8f\x99\x7e\xfa\xee\x7d\x3b\x0b\x9e\x1f\x05\x4d\xa9\x8e\xa2\xc9\xe4\xf0\x47\xa3\x50\x22\xfa\x00\xc2\x78\x8c\x23\xe1\x26\x47\x0e\x04\xe7\xa0\xfc\x13\x69\x29\x2a\xcb\xfe\xc6\xb4\x1c\xa4\xaf\x02\xbf\x3e\x5f\xae\xbc\x04\x76\x4d\x81\x5c\x46\x2e\xbb\x24\x9b\xcc\xb6\x1e\x36\x24\x5c\xbf\xfe\xc5\x57\x75\xa1\x0f\xef\x45\xf7\xe8\x52\xb6\x2c\xdd\xdb\x71\xdf\x4e\x4d\x74\x8d\x7f\xa3\xf5\x05\x22\xef\x1b\xec\x30\x32\x5f\xd5\xa9\x90\xd7\x49\x3c\x37\x14\xf0\xdb\xcc\x44\x4f\x0a\xaa\xae\x24\xaa\x4a\x2d\x1a\xcd\xa9\xab\xbc\x09\x83\xb9\x02\x19\x9d\xd2\x44\x2f\x54\x67\x3a\xff\xed\xa5\xfe\x03\x07\x77\xe8\x3f\xe2\x6f\x7b\xfc\x75\x55\xfd\xeb\xce\xc2\xa3\x9f\x7b\x93\xf9\x62\xfa\x18\xf9\x03\xf7\x8e\xb7\x32\xb1\xd1\x83\x4b\xe4\x23\x32\x39\x47\x21\xb2\x5f\xef\x23\xf3\x15\x06\xe5\xe0\xc2\x54\x17\x87\xab\x18\xf9\x6c\x24\x08\xb5\x15\xf9\x6c\xe1\xb0\xaf\xa2\x43\xb8\x34\xe5\x72\x95\x4a\x92\x5c\x8a\xc8\xc2\x21\x32\x83\xa8\x94\x4c\x58\xa9\x57\x8e\x35\x68\xd3\xa6\xf9\x65\x55\x79\x55\x87\x01\xe7\x81\x36\x39\x66\x35\x6f\x5b\xb0\xa8\x02\xd9\xa1\xa5\x9a\x32\x55\x7f\xce\x69\xc9\x66\x75\xd3\x32\xd7\x1b\xf3\x18\x5a\xd8\x65\xf3\xac\x49\x2f\x4c\xde\xf2\xee\xee\xcd\xb7\x5e\x89\x6f\x18\xda\x67\xf0\x42\xa9\x78\x5e\xcf\xbe\x43\xd8\xd1\xc6\xa4\x9e\x33\xbf\x69\xc9\xa0\xbb\x96\x0f\xeb\xbb\x79\xcd\xcd\x9b\x9a\x8e\xd7\x76\x1f\xd8\xb5\xb2\xba\x9e\x72\x8d\x00\xc8\xdc\xc6\x9d\x4b\xec\x51\x9f\x54\x84\x63\xdd\x36\x9b\x5d\x60\x2d\xac\xdd\xae\x78\x01\xf1\x8f\x05\xab\xcd\xda\x90\x66\x6d\x36\x33\xa0\xe9\xa1\x2a\x23\x15\xd2\x76\xe9\xb5\xd2\x24\xba\xdc\x42\xa2\x96\x56\xe3\xe9\x33\x0e\xf9\x85\xcb\x73\x5c\x2b\x97\x70\xe7\xde\xb8\x32\xb3\x94\x36\xed\x31\xd5\x1a\x83\x48\x3e\x1f\x8c\x0c\xfa\xa5\xa2\x44\x02\x8b\x83\x13\x1c\x08\x29\x5e\xe2\xc6\x9b\x78\xbb\x4a\x74\x62\xe1\x45\x20\xe5\x2a\x4d\xdb\x30\xc0\xe4\xc1\x7d\xc3\x78\xc9\x19\xd4\x2f\x32\x0f\x9f\x5a\xb8\x46\x93\xa3\xba\x6f\x6d\xcd\x85\x78\xf4\x9d\x2b\x58\x81\xca\xd1\x72\x6e\xc3\x39\xb6\xc3\x12\xd0\xeb\xce\xd9\x77\x88\xbe\x0c\x12\x9f\x75\x7c\xaa\xca\x17\x50\x60\x2c\xa6\x08\x9c\xc9\xc9\x44\xa3\x26\x93\x92\x2c\x26\xb1\xba\x3d\x68\x8a\xf9\xfc\xbe\xe6\x34\x07\xfd\x7e\x3b\x0a\x8a\x76\xd9\x4d\xa2\x76\x77\x7e\x52\x38\xbf\x56\xad\xa6\x9d\xba\x7a\x43\xb9\x6b\xc7\x23\x8f\xaa\x43\xab\xdc\x35\xca\xd1\xe1\xdd\x70\x23\xf4\xcf\x9f\x9f\x4f\xd8\x31\x7d\x3a\xfc\x70\xd2\x12\x3c\x8e\x68\xd4\xa9\xf0\x1e\x3c\x75\x1b\xce\x92\x75\x5c\xbc\x0d\xde\xd3\xb2\x6c\xfd\xd5\x61\x19\x7f\xa5\xce\xeb\xb9\x64\x3c\x4f\x91\xf1\x54\x53\x36\x38\xd4\xc9\x5b\xd4\xa9\xc8\x09\x4c\x7e\x67\xb9\x29\xe1\x34\x39\xbb\xd6\x40\x7f\x80\x1c\xed\x2e\x01\xd1\x56\x72\x46\x7e\x3e\x3f\x27\x6f\x44\xeb\xf4\x46\xc7\x43\x73\xee\x74\x4b\xea\x48\xf1\xdd\xa8\xfa\xaf\xd5\x58\x8f\x18\xe3\xae\x4d\xd5\xaf\x3d\x21\xfb\xd4\xc4\x7e\x9d\xba\x77\xba\xe9\xd4\x83\x0f\xfd\xbe\x42\x29\xee\x5a\xd2\x6f\xd2\xdb\x17\x5c\x99\xe8\x90\xb8\x6d\xfe\x82\x5b\x12\xe5\x89\x2b\xc6\xbd\x85\x66\x56\xc9\xc3\xa6\x5e\x7b\xf6\x4d\x07\x2f\x9f\x7e\xe0\xd6\xae\x17\x34\x8f\xec\xed\xaf\xda\x3f\x6d\x5c\xd5\x84\xa9\x57\xf5\x5b\x7c\xdf\x7d\x8b\x53\x57\x5e\x3a\xa9\x53\x7a\x06\xd0\xf9\x54\x58\x7a\x0f\x1f\x00\x55\x29\x9f\x84\xd4\x98\x02\x85\x82\x16\x12\x19\x35\xd2\x0a\x01\xaa\x03\x9c\xf9\x2d\xc7\x39\xc2\x0c\x22\x1f\xbd\x42\xcf\xf2\x2d\x6a\xa0\x09\x42\x6d\x1f\xc8\xb4\x6e\xdc\x8c\xff\xf8\xf3\xfb\x8f\xa1\xff\xc2\x8b\xbe\x18\x70\xb6\x7b\xb8\x2b\x79\x2d\x3b\xfc\xe0\x71\xfc\x1c\x7e\xf0\xe8\x09\x66\x65\x66\xed\xda\xc5\x70\xdf\xf2\xd9\x26\xf6\xa0\x60\x51\xe5\x30\x11\xbb\x4a\xef\x6c\x2c\xa0\x32\xe5\x45\x0c\xc5\x21\xe1\x19\x0b\x8f\x6c\x56\x44\xec\x27\x55\xdd\x86\x71\x2f\xec\x99\x22\x96\x33\x86\xe8\xbd\x06\x8a\xc1\xbb\x60\x23\xbc\x1e\x7f\xb0\x47\xec\x6e\xe9\xb3\x0f\x1f\x25\x1e\xe3\x1b\xcc\xb8\xea\x37\xcb\xdf\xcd\x3c\xa8\xea\xbc\x53\x24\x80\xed\x4d\x9e\xe1\xa1\xb8\x07\x76\x07\x2b\x10\xd3\x0d\x68\xaf\x14\x32\xb9\x3d\x66\x93\xc9\xeb\x91\x81\x48\xb9\x25\xfa\xea\xed\xd4\x7a\x68\x97\x4b\x49\xc6\xdc\x5e\xa5\x8e\xd2\x5d\x20\x91\x3c\x10\x55\x41\x81\x3c\xd6\x0b\xcb\xb7\x38\x23\x5d\xb7\xc2\x72\xe8\xc3\x27\x9f\x75\xf8\x9f\xc0\x87\x37\x15\x73\xe2\xe3\xb8\x85\x04\xd5\x97\x0d\xb8\xe7\x33\x66\xed\xe9\x37\x50\xcf\x21\x73\x32\xcb\x98\x85\x8f\xfa\x07\x67\x1c\x9a\xcd\xd6\x38\x3c\xbf\x22\xbe\x7c\x5d\x2a\x24\x9a\xcd\x08\x59\x5c\x6e\xab\xc5\xe2\xf6\x29\x2a\x67\x08\xa2\xbc\x08\xc0\xea\xa6\x71\xfd\x81\xfa\xaa\x8a\x8a\xbc\xd0\x4d\x77\x67\x74\xbd\x26\x42\x3a\x0b\x4c\x29\x95\x0a\xf6\x81\x68\x9c\x51\x96\x09\xb7\xe0\x0f\x28\x37\x88\xaf\xdf\x83\xb4\x09\x66\xd8\x5e\xee\x2b\xad\x24\xf3\xf4\x21\x78\x3a\x0e\x51\xf9\x85\xdf\x61\xc8\x5e\x79\x60\x23\x95\x47\x21\xf2\x2c\x20\xf3\x63\x02\x1d\x52\x6e\xb2\x20\x0c\xc7\x23\x86\xac\x82\x99\x65\x39\x46\x54\xf3\xc9\x35\x67\xc4\x8f\x31\x49\xbb\x0a\x93\xe0\x1e\x7c\xbe\xca\x93\x67\x81\x25\x78\x1c\xdc\xc5\x2c\xc5\x23\xe1\x96\xcc\xb5\x78\xb0\xde\x27\xc5\x6e\x53\xe7\xbe\x77\x2a\xce\x5a\xdd\x36\x87\xcb\x26\xba\x90\x47\x76\x92\x7d\xe6\x14\x6d\x24\xec\xb6\xc9\x02\x31\xd3\x02\x93\x57\xa4\x5a\x78\xfd\x5c\x5d\x4d\xeb\xc8\x0d\x57\x82\x1c\x67\x03\x86\x02\xed\xd3\x7d\x86\xcc\xd5\x46\x87\x14\x33\xe4\x7c\xcd\x3f\x18\xa6\xb7\x46\x11\x5d\x34\xa0\xb5\x96\x6b\x26\x32\x28\xc4\x0a\x8f\x4d\x75\xb6\x32\x72\x98\x95\xc8\xa0\x91\x4f\xb2\x20\xce\x8c\x78\xb3\xc4\xc6\x63\x0a\x72\x04\x1a\xa8\x57\x29\x08\x64\xdb\x09\x62\xd8\x82\x88\xe9\x96\x69\xd6\xba\x30\x98\xae\xd0\xe9\xe2\x94\xbc\x44\xa8\x6a\x70\xb8\x6e\x75\x86\x68\x35\xd9\x56\xed\x18\xf1\x38\x55\xca\x04\xda\x97\xbd\xc7\x54\x89\x9b\x0d\x51\x7f\xbb\xe6\xe0\xc2\xa5\x77\x3d\xb7\x15\xff\xdc\xa5\x8e\x61\x1b\xbb\x9c\x57\xff\x70\x4d\xcf\x09\x6e\x43\xf0\x97\x37\xde\x7a\xcd\x4d\xf7\x9c\x37\x07\x9e\x18\x3c\x7c\x58\x85\x86\xd3\x34\x9a\x75\xa8\x71\xd8\xd0\x54\x89\x43\x30\xdb\x2d\x76\x01\x29\x48\xf2\x29\x92\x12\x0a\xfa\x7c\x56\x41\xf0\x58\xed\x16\xab\x85\x26\x34\xd4\x8c\x40\xb0\x0d\xef\x40\x3b\xf8\x2f\x2a\xb1\x46\x3e\x51\x89\x9e\x75\x56\x39\x4c\x18\xb4\x74\xfa\x23\xcf\x4d\x81\x23\x32\x6f\xa2\xe5\xf8\x8e\xbf\x7f\x89\xbf\xfd\xcf\xfb\xf8\x4f\x1f\x94\xad\xf3\xfe\xb5\xf2\xfe\xdb\x56\xec\x81\x63\xf7\xbf\x86\x6f\x77\x9f\xd8\xfb\x3d\xfe\xfd\xed\xed\xf6\xb1\x33\xc8\x7c\x07\x88\x9c\x5d\x88\x9c\x11\x62\xe3\xe7\xa7\x8a\x93\x61\x06\x99\x40\x24\x12\x74\x2b\x51\x13\x51\xf9\x1e\x22\x70\x90\xaf\xe8\x40\x76\x1d\x31\xf3\x76\x7b\xa9\x9c\x64\xa8\xef\xec\x4f\x27\x93\x6c\xa9\xe2\x91\x89\xee\x91\xc5\x52\x2b\x35\xfa\x6c\x82\x58\xcc\x02\x6e\xfb\x36\x0c\x0a\xf5\xed\x30\x61\x6b\xd6\xbf\xa4\x94\xd7\x34\x2b\xb5\xf6\x6d\xc6\x47\x9c\x81\xa4\x6a\xcd\xd4\xb6\xd7\xcb\xfd\xc9\x3b\x5f\x5f\xb5\x6f\xda\xbe\x97\x37\xee\xd8\xba\x73\x56\x6e\xb4\xdd\xbb\x77\x69\x39\x3a\xb3\xf9\xce\x61\xab\x6e\x68\x1a\x80\x2f\xaa\xaa\xbf\xaa\xe9\xb6\xb1\xb7\xde\x73\xdd\xcd\xb7\xe4\xc6\x7d\xe9\xb4\x81\x43\x1e\xe9\xde\x6f\xe4\x0d\x75\xea\xd9\xee\xa7\xf3\x6f\x28\x94\xc3\xcb\x46\x4c\x3f\xe0\x89\xe5\xf5\xfb\x9c\xc4\xc5\x62\x89\x73\x65\x63\x6d\xac\x93\xd5\xee\x68\x0c\x5a\x96\xbc\x6a\xcb\x98\xa4\x56\x5a\xe6\x5a\xed\xaa\x29\x6d\x8c\x20\xc1\xdb\x3a\xf5\x8a\x1d\x9b\x36\xb7\x79\x96\x1d\xff\x1c\x81\xe0\x95\xdf\xa0\x75\xdf\x56\x66\xa6\x8d\x87\xfd\x56\x2f\x9d\x76\x7e\xff\xc7\x5e\xc5\xdf\x65\xf6\xe3\x1f\x8a\xf0\x5c\x60\x70\x06\x74\x51\xe5\xe8\x96\x0a\x11\xdd\xa2\x28\x40\x62\x01\xeb\xf7\x09\x24\x34\x75\x43\xb2\x43\xdc\x56\xb7\xd0\xae\x20\x46\x3a\xb9\x84\x58\x1e\xa0\x12\xca\x6b\x9e\xbd\x96\xc8\x87\xfb\x9e\x7a\x13\x5a\x7f\xfb\x1b\x68\x8d\xe0\x9f\xed\x33\x47\xcc\x9d\x76\x2c\xde\xbb\x23\x5c\x15\x86\xee\xfd\x19\xe8\x79\xf5\xb1\xfe\xe7\x4f\x5b\xba\x1a\xef\xe5\x6d\x19\x7a\xe7\xd0\xaf\xf5\x04\x99\x0f\x8a\x7d\xda\x5d\x95\x03\x28\x12\xcb\x2a\x7e\x1f\x24\x07\xdf\x0a\xad\x50\x50\x10\x95\xc8\x28\x1c\x70\x19\xbc\xe0\x79\x73\x02\x25\x4a\x61\x05\xf2\x18\x31\xd4\x42\x54\x89\xd9\xb2\x75\x1f\xfe\xed\xb7\xbf\xb5\x46\xa0\x98\x15\x84\x5b\x82\xe7\x16\xe1\xef\xdf\xce\xe0\xef\x74\x51\x60\x3f\xde\xc6\xcc\x54\xb1\xa2\xc9\xbe\xac\x53\xeb\x19\xfa\xa4\x8a\x04\xde\xc3\xcb\x8e\x90\x1c\x2a\x0a\x0b\x02\xf2\x78\xfc\x44\x0b\x37\xa4\x91\xd3\x4f\x3c\x35\x7f\xf0\xbf\xd7\xc4\xba\xf3\x4a\x48\xf5\x26\x10\xb5\xd9\x98\x66\x01\x47\x42\xc7\xaf\x46\xe5\xe8\xec\xd9\x33\xe7\x19\xfd\xc5\xcb\x7f\xc7\x27\x19\x85\x84\x76\xa5\x6a\xc9\xe8\xfd\xcf\xe0\xaa\xa7\x9e\xd4\x5a\x8a\x69\x31\x03\xc8\x71\xea\x3a\x75\xcc\x13\x20\x31\x80\xe9\x0e\x94\x94\x83\xf9\x31\x00\x17\x07\xe0\xcc\x00\xec\x1b\x80\x01\xa0\x21\xc4\x68\xd8\x01\xf4\xae\x7b\x3d\x39\x6b\x0e\xe2\x7d\xc6\x69\x0c\x22\xb0\xa2\x18\x08\x38\x3c\x6c\x91\xc5\x41\x2c\x5c\x71\x42\x8c\x37\xa7\x6d\x62\x48\x64\x9c\x48\x14\x89\x05\xf2\x37\x13\x9b\xea\x08\x34\xb7\x65\x53\xd2\x22\xbe\xfc\x83\xa4\xe6\x25\x62\x39\xd0\x33\xa2\xcc\xc8\xf4\x1b\x7c\x36\x92\x71\x27\xb5\x86\x39\x7f\xcf\xc1\x49\x23\xa6\xcf\x3c\xb2\x35\x33\x0f\xba\x7f\x1a\x33\xac\xa2\xc3\xe0\x0b\x7f\x3a\x3d\x67\xea\xf8\x45\xa7\xd9\x1e\xab\x6e\x1a\x7f\x75\x20\x74\xe3\xe4\x55\x0f\x31\x4b\xfc\xdd\x3a\x57\xd5\xfa\x32\xdd\x07\x9d\x33\xb0\x9f\x76\x8f\x98\x5f\x93\xd4\x39\xe5\x8f\x45\x78\x14\x72\x7a\x2d\x21\x6f\xc8\x28\x49\xf2\xdb\x9b\xd2\xfe\xbc\x92\xa4\xac\xf6\xca\xe6\x30\xe5\xbc\xca\xa4\xd2\xa8\x56\xb3\xa8\x16\x6b\xd0\x3f\x18\x79\xf0\xf0\x0b\xe7\xdd\x70\x41\xba\x71\xc1\x0d\x2b\x16\x40\x06\x86\xf0\x57\xa7\x8f\x9c\x5c\xb9\xf0\xd8\x8f\x68\x7d\xff\x5e\x0d\x67\xef\x1c\x3c\x22\xd5\xf0\xfa\xb3\xaf\xec\xd9\x8e\x8f\xe0\xd3\xf8\x14\xfe\xc7\xce\xbb\xa7\x2d\xb3\xd7\xee\xbf\x66\x83\xce\xd7\x59\xcc\x75\x06\x25\x60\x4a\xaa\xd6\x2e\x7a\xa3\x20\x58\x52\x62\x13\x39\xaf\xe8\x2d\x2b\x0d\x06\xfd\x00\xb8\xfd\xe1\x78\x63\xda\x61\x27\x2f\x87\xdb\x1f\x0d\x37\xa6\xa3\x4e\x3f\x31\x66\x7e\xa7\xdb\x94\xf3\x65\xdb\xab\x11\x6d\x53\xfe\xaa\x17\x1a\xe4\x55\xc2\xd4\x16\x96\xc9\x28\x2e\x83\x42\x3d\x0c\xd1\xc0\x6c\x49\x4c\x41\xb5\xcc\xa2\x4b\x44\x58\xac\xb1\xf8\x33\x1f\xe8\xa5\x31\x4b\x0a\x4a\x66\xea\xa0\x5f\x7a\xcb\x76\xf6\xe0\x0f\xb2\xb5\x12\x03\xd5\xfb\xec\x9a\x94\x9f\xe1\x79\x0e\x9a\xcd\x16\xce\x62\xb7\x41\x53\x43\x1a\x42\x0b\xb2\x8a\xbc\x25\x7b\xc1\xd0\x56\x49\x40\x29\x0b\x3c\x2c\xc1\xc7\xe1\xf5\x30\x80\xbf\xc1\x8b\xf0\x37\xc4\xa3\x26\x3e\xc0\xe9\x37\xe0\x7b\x98\x1a\x02\xb2\x4f\x69\x0e\x71\x87\x7a\x5f\xec\x01\x45\xb4\x2e\x23\x84\xac\x76\x8f\xd9\x2f\x11\xff\x0b\x45\x23\x26\xd1\x25\x8d\x48\xbb\xa0\x85\x0f\x10\xe3\x6b\x0f\xc8\x40\x6e\x68\x13\xa0\x18\x7e\x68\xb6\x05\x28\x1b\xa2\x18\x17\xc5\x6a\x7c\x4c\x7b\xe0\x54\xa7\x9f\x3a\xd8\x5e\xb8\xfc\xd1\x57\x5f\x79\x61\x2a\xf4\xdf\x77\xdf\xbb\xe7\x42\x3f\x1e\x3f\xbc\xc7\x15\x6b\x7a\xe1\xd1\x4f\xaf\xbb\xed\x61\x74\x79\xcb\xed\x07\x5c\x6f\x1c\xa2\xed\x70\xa7\xa2\xa3\x46\xf6\xb8\xaa\x73\x5f\x75\x4e\x10\x9e\x81\xbe\x55\xe7\xe4\xec\x94\x0c\x2d\x26\x33\xf1\x84\x80\x55\x40\x88\x65\xad\x76\x1b\x6f\x86\x82\xd6\x7e\x02\xa1\x99\x4c\x8f\x4a\xe7\x5e\xa3\x13\xcc\xbf\xd1\xde\xcd\x9c\x19\xd6\x69\x33\x44\x1c\x26\xd8\x0d\xc6\x16\x10\x41\x8e\xe3\x6b\xf1\xfb\x70\x21\x9e\x4a\xa6\xca\x3b\x12\xde\x79\xaa\x2b\x6a\xc6\x29\xb8\x89\x59\xa7\xf9\x88\x2b\xc8\xa4\x8d\x22\x32\x70\x14\x7b\x85\x85\x00\x0a\x3c\x23\x42\xe2\x27\x41\xfd\xd4\x66\xb3\x76\xe5\xea\x22\xa0\x51\x19\x12\x83\xc0\x1d\x6c\x8f\x96\xdb\x8d\xfa\xf3\x10\x77\x84\x4c\x61\x12\xa4\x53\x9d\x1c\x40\x0e\x86\x00\x08\xc6\xcc\x41\x73\x69\x89\xc3\x61\x23\x63\xe1\x6d\x2e\xb9\x31\xed\x52\xc8\xcb\x06\x82\xb6\x88\xca\x65\x9d\x28\xe4\xb2\xfe\x8b\x6a\xed\xdc\xfa\xeb\x50\x21\x5a\xce\xb0\x20\x5d\x91\xab\x57\x43\xbd\x75\x74\x90\x8f\xf6\xfd\x3a\x61\xd3\x3a\x6d\x77\xe2\x13\x1a\x42\x08\x1e\x6d\x20\x81\x98\x29\x54\xc8\xdf\x61\xf9\x2d\xeb\xd4\xfd\xf9\xe7\x27\x68\xbf\x81\x09\x92\xb3\xab\x11\xe2\xc1\x75\xf1\x53\x92\xd9\x48\x04\x86\x7d\xa1\x50\x58\xf0\x78\xc2\xb1\xa8\x44\xd3\x2c\x64\x28\xc1\x08\x88\x34\xa5\x7d\xc0\xce\x70\x00\x70\x8c\x9d\x0d\x4b\x6c\x58\x2d\x3c\x50\x01\x2b\x75\x3e\x9c\x36\xd6\x2e\x77\xeb\xf8\x17\xf6\x57\xbb\xcf\xa9\x8d\xf5\x83\x0d\xed\xd9\xe1\xff\x9f\xb5\xff\x80\x8f\xaa\xd8\x1e\x07\xf0\x39\xb7\x6d\xef\xe5\x6e\x36\xd9\x24\x9b\xcd\x26\x6c\x36\x21\x21\x9b\x4d\x42\xcd\x82\xf4\x96\x80\xb4\x15\x43\x00\x91\x8e\x90\xd0\x3b\x08\xd2\x94\xa2\x02\x76\x40\xe1\x21\x2a\x4a\x47\x6c\x80\x8a\xa0\x4f\x10\x7b\xf7\x89\x8a\xa2\xd8\x78\xea\xc3\xa7\x90\xd9\xff\xcc\xdc\xdd\x64\x93\xc0\xfb\xfe\xfe\x9f\xff\x3f\xb0\x77\xf7\xde\x3b\xe5\xcc\xcc\x99\x33\xe7\x9c\x39\x73\x0e\xf4\xc7\xfb\xf1\xb7\x78\x1f\x44\xa0\xb0\xe5\x8a\xdc\xfb\xf9\x15\xca\xb9\xd5\xa1\xa4\x0d\xa5\xac\x0d\xd1\x48\x91\xc9\x68\xf4\x78\x32\x78\x87\x3a\x35\x43\x40\x84\x3b\x52\x7b\x33\x75\xd6\xaa\xa8\x4c\x04\x80\x74\x8e\xe7\x06\x44\x53\x79\x93\x9b\xc8\x64\xb2\xdb\x24\xe8\x94\x75\xfa\xff\xa5\x05\x2c\x22\x41\xf8\xda\x4b\x37\x6d\x04\x9c\xc6\xfb\xa1\xff\x35\x97\xf0\x4a\xbc\x6f\xc5\xf3\xbd\x5b\xae\xe3\xf8\x9d\xe7\x57\x28\x7e\x6a\x62\x3f\xa9\x65\x32\x87\xe9\x59\x9f\x5c\x34\x2e\x52\x96\xeb\x94\x73\x72\xec\x76\x37\x6f\xc9\xd4\x68\x2c\xce\x14\x21\xd0\xca\xe9\xb7\xfb\xab\xa2\x3c\xe1\x71\xcc\x92\xdd\x64\x05\xbd\x87\xa1\x55\x16\x41\x2b\x47\x8e\xcc\xce\x37\x34\x9a\xc6\x34\xee\xa9\x92\x96\x35\x0d\x51\x94\xd4\xa2\x16\x07\x02\x14\xeb\x08\x6f\xf2\x59\x00\x22\x86\xf0\x7d\x9b\x9e\x05\x80\x14\xfe\x9e\xfa\x47\xb9\x0d\x57\x5a\xc5\x8f\x02\x80\x83\xbb\xb9\xd9\x59\x00\xb8\x13\xdf\x46\x58\xed\x33\x9c\x2f\x7e\x14\x80\x43\xf5\xc3\xb8\x5d\x6c\xfe\x0c\x51\x8d\x22\x6d\x6d\x83\x3a\xa0\xa5\x91\x6e\xb9\xee\x02\xa7\x37\x33\xd3\xd2\xda\x6e\xe7\x8b\x2d\xe5\xa4\xb5\xee\x7c\xd9\x29\x75\xea\x68\x26\x04\xcd\xeb\xf5\x48\xc1\xa0\x9d\x4c\x29\x64\xb7\x02\x72\xe8\xc3\xb4\xcd\xf6\xd6\x55\x51\xbb\x49\x6a\x47\x27\x94\x27\x7b\x40\xd4\x73\x0d\x47\x95\x49\x67\x3b\x9a\xb9\xbf\x6a\xaa\x09\xbc\x5e\x1f\x34\x5a\x88\x34\x89\x37\x68\xb1\xcb\x49\x7d\xd3\xb2\x63\xb8\x77\xe2\xe6\x23\x7b\xae\x94\x03\x97\x37\xad\x5f\xc2\x7e\xa4\x46\x8d\xbf\x89\xf7\xd6\x35\x7a\xaa\xd1\xb0\x64\x59\xbb\xbe\x15\x71\xcb\x92\xfa\x85\x63\x56\x35\x74\x1f\xa5\x5d\x02\xc1\x93\xb0\x66\x03\xe9\xbb\x5c\xc2\xc7\x84\x51\x27\xb4\x24\xd2\xbd\xd4\x1b\x4e\xc9\x45\xee\x92\x12\x59\x6e\x25\xd9\x5b\xeb\xf5\x76\xc4\xa5\xfa\xdb\xa7\x78\x35\x91\x8a\x94\x90\x1c\xaa\x8a\x96\xa7\xa7\xfb\x65\x93\x03\x54\x36\x8d\xc9\x14\x64\x27\x47\x8a\x2a\xa3\xb9\x1a\x87\x9f\x6f\x5f\xe2\xe6\xdd\x04\xa9\xe2\x88\x43\x7a\xc4\xa5\xb8\x85\x89\x1b\xd6\x56\x34\xf7\xab\xd2\xbc\xfb\xa8\x60\x76\x3d\x2c\x6a\x2a\xa8\x25\x21\x94\xa6\x41\x6c\x13\xaf\xa8\x0b\xea\xd3\x5a\x60\xd7\x92\xfa\x43\x90\x9b\x24\xc3\x5d\x5d\xdd\x88\x68\xbd\xb9\xb4\x46\x81\xee\xda\x48\x97\x90\xef\xb8\x5f\x1a\x71\x6f\x10\xb7\xbb\x7e\x9f\x22\xee\x11\x1c\x24\xcc\x85\x94\x21\x96\x13\xa9\x95\xd9\x21\x43\x41\x50\x25\x49\xd9\x76\x43\x10\x15\x16\xa6\xa7\xb9\xdd\x04\xe5\x4a\x42\xad\xd3\x3c\x69\x95\xd1\x0c\xe4\x31\x1b\x54\xc1\x6c\x41\xe6\xe5\xe2\x1b\xa3\xb2\x62\x87\xdc\xf4\xa8\x44\x45\xe8\x64\xb2\xef\x99\x46\xca\xa1\x58\x08\x7a\x9b\x69\xf1\xd3\x39\x87\x39\xd0\xa8\x01\x84\x46\x75\x7f\x19\x53\x05\xc2\x11\x38\x39\x68\x52\x83\x22\xbf\x77\xf5\x57\x2f\x8f\xc2\xa1\xfa\x81\x8a\x92\x92\xdb\x3e\xf5\xc6\xa1\xe3\x7f\x7e\x7c\xa8\xe3\xed\x0e\x15\x42\x3b\x47\x5c\x8d\xdf\x3a\x64\xc9\x1b\xb2\x76\x22\x3e\xb1\x72\x35\x37\xf9\x28\xbe\xb2\xa9\xa0\xac\xa8\x9d\xa3\xb0\xef\xa2\x11\x15\xa5\xf5\xe7\x2a\x23\x4a\xbb\x09\x9f\x7e\x8f\xf8\x3e\xa2\x71\x37\x66\x46\x2a\x32\x5c\xa2\x8a\xd7\xe6\xe7\xf3\x56\x97\x2e\xe0\xf7\xbb\x5c\x7c\x51\xa1\x5a\x62\xd1\x23\x89\xa4\x68\x92\x82\x09\xa5\xa6\x3f\x40\x8f\xb3\xf9\x73\x07\x44\xfd\x8e\xd4\x0c\xb2\x16\x78\xc9\xa7\xf9\x69\xaa\x86\xb0\xce\x4d\x97\xeb\x06\x6c\x09\x59\xdb\x36\xc6\x76\xa6\x8a\xcf\x70\xd3\xbd\x81\x24\xfd\xbb\x54\x56\x5c\x66\xa1\x7d\xc1\x22\x3d\x93\x46\xbf\xfc\xe2\x2b\xc3\x6e\x60\x1b\x06\x09\x65\xfc\x48\x77\x76\xd6\xcb\x1d\x94\x98\xcf\x18\x7b\x92\x76\x0f\x14\xad\xbc\xec\xfe\x50\xcd\xed\xad\xff\xba\xb2\x0f\x6d\x77\xec\x27\xe9\x16\x32\xde\x2a\x54\x86\x36\x47\x06\xf9\xb3\xb3\x51\x51\x5e\xba\xdd\xea\x74\x9a\x0c\x3a\x5d\x7a\x5a\x38\x28\x14\xa9\xda\x96\xa7\x05\x53\x0a\xc2\x82\x9a\x33\x71\x85\x1c\x67\x90\xb8\x82\x82\x90\x31\x24\x55\x46\x43\x4e\x6f\xab\xca\xe8\xcd\x7e\x30\xf9\x33\xfc\x9c\x86\xf7\xfb\xbd\x66\x87\xc1\x68\xa8\x8c\x5a\xcd\x46\xb3\x3a\xa5\x2a\xaa\x8e\xaf\xec\x27\x13\x7b\xeb\x94\xe9\xaf\x4e\xf6\x89\xc0\xac\x35\xda\xb6\x55\x3e\xc9\xb1\x1f\x13\xb2\x58\xfc\x8c\x9c\xd8\x52\x33\xfc\x3f\x8e\xd6\x19\x41\x9c\xa2\x1c\x9c\xbb\x3a\x72\xe5\x0e\x45\x77\x1c\xce\xf1\x55\x66\x05\x9b\x1c\xb3\x3b\xf0\x30\x3d\x66\xf7\xd6\x63\x83\x1e\x84\xf4\x5b\x66\xd5\x1c\xdf\xb8\x28\x1e\x45\xfc\xe3\x6e\x9d\x0a\xf3\x47\xac\x4d\x3a\x6f\xd7\x77\x2e\x3d\x6f\x77\x47\x9f\x76\x2c\xfe\x2f\x1e\x2a\xcd\x20\xf4\x26\x84\x6a\x22\x25\x4e\x1d\xef\xf1\xa4\x87\xbc\xde\x9c\xec\xac\xac\xf4\x02\xab\x4e\x0c\x97\xe4\x15\x0e\x88\xe6\x41\x66\xb6\x3f\x9b\xf4\x92\xdf\xcc\xab\xd2\xb3\x1c\x46\x82\x3b\xc6\x54\x66\xb4\x9e\xa4\xe7\x24\xa3\x9f\xa4\xed\x69\x32\x51\xe2\xdb\x5e\x8e\xeb\x5b\x54\xb1\x10\x7a\x49\x21\xc1\xe3\x9c\xfa\xf6\x84\xcd\x4f\x13\x93\xda\x93\xf8\xfb\xc6\x73\x08\x42\xbb\x84\xc1\x52\xb2\x6d\x15\xb3\x0b\x5a\x70\x75\x39\xbf\xe0\x68\x6d\xfc\x84\xc2\x60\xc6\xb3\x13\x99\xe4\x5d\xd2\xde\x3c\xc2\x47\xb7\x92\x9d\x4e\x4d\xb6\xc7\xcc\xe7\xe5\x21\x64\xce\xe6\xf3\x83\xb9\x12\x75\xb1\xe4\x91\x35\x01\x01\xd9\x6c\xee\x01\x44\x84\x02\xc5\x28\xb4\x89\xa3\xa5\x66\x2e\xc2\xa8\xc9\xa1\x53\xf8\xbf\xf6\xf4\xbc\x99\xb9\x8e\xf5\x90\x32\x12\xcc\xeb\x77\x2d\xbd\xce\x56\xde\x2f\x44\x84\x7a\xeb\x9c\x78\xfa\xca\xf0\x0e\xdd\xc2\x3d\xae\xb3\x8f\xf7\x8f\xa7\x6e\xa9\x64\x73\x9d\xc8\x1f\xe2\x48\xd2\x16\x35\xe1\xb6\x3b\x46\x32\x74\xa2\xc4\x6b\xb5\xe4\x99\x8a\x27\x22\x08\x88\x1a\x5e\x43\x2d\x28\xb5\x12\x53\x05\x37\x31\xaa\x4d\x52\x4a\x87\x92\x8c\x26\xc9\x7f\x0b\x10\x18\xf9\x95\xf5\x4f\x71\x2b\xae\xf6\xe4\x06\x50\x9b\x48\xba\xc8\xf3\x53\xeb\x87\x70\x4f\x2a\xb6\xc9\x42\x31\xa9\x53\x26\xf4\xe5\x1f\x91\x76\x81\x56\x1e\x57\x4a\x7e\xa6\x37\xdb\x93\x9d\xcf\x67\x15\xb4\xf6\x65\xb5\xce\x92\xf5\x08\x1c\x5a\x9d\xd1\x29\x1b\xf4\x7a\xa3\x43\x25\x8b\x45\x85\x4e\xbd\x5e\xd7\x2a\xc5\x9b\xed\xad\x8c\xe6\x67\x67\xeb\x5a\x59\x98\x18\xa0\x8d\x5a\x2c\xba\x56\x05\x59\xd0\xca\x43\x6f\xf5\xd1\x56\xe0\x30\xea\x8c\x44\x78\xd2\x25\x69\x0e\x15\x05\x76\xa3\x2f\xe6\x26\x4e\x0d\x9a\x44\x8f\xb5\x26\x69\xe7\x1a\x14\xd0\x5e\x1f\xdf\x9a\x0f\x9b\x80\xf7\xf1\x21\x5b\x05\xd8\x42\xb6\x0c\x72\xc9\x25\x4f\x21\xf1\xb4\xac\x53\xe2\x31\xbf\xe8\xd4\x74\x49\xab\x91\xf4\xf2\x8c\x53\xfb\xf6\x4d\xb1\x68\x6a\xff\x39\xd5\xaa\xa9\x7d\xe6\xe0\xa9\xe9\x6a\x39\xfe\x50\x23\xaa\x66\x29\x4f\x61\x99\xad\x4d\x7e\x26\x5f\x36\x02\x2f\xe6\x0e\x63\xcd\xf0\x6c\x98\x83\x57\x55\x15\xc2\x9f\x23\x61\x59\x4a\x9d\x3a\xf1\xbc\x4d\x6a\x26\x59\xb7\xd8\x0b\x36\x6e\x54\x3e\xf9\x9b\xf4\xa1\x0a\x99\x50\xdf\x88\x1f\xa9\x41\x23\xe8\x45\x83\x46\xad\x37\xa8\x0d\x16\x33\x88\xa2\x41\x62\x21\x9b\x8d\x92\xc6\xe0\x90\xf8\xaa\xa8\x04\x4d\xb6\xc3\x5b\xd8\xa9\x27\xa6\x98\x2f\x31\x8f\x94\x0f\xff\xf7\x2f\x78\xe2\x2f\x7c\x9d\x72\xe5\xbf\x05\x0d\xfe\x13\x2e\xfc\x5d\xa2\x7c\x33\xbe\x3a\x8b\xc8\x3a\x5d\x85\x6e\x44\xae\xbc\x21\x92\x6d\x95\xe4\xd4\x54\xb7\x4e\x72\x13\xa9\x32\x9d\xea\x78\x4d\xa9\xa9\x0c\x10\xea\x6b\xc5\xcc\x93\x59\xdf\x60\xa7\x96\x6c\x15\xd2\xe8\x63\xca\x9f\x70\x04\x90\xd8\xe6\xf4\x40\xa3\x75\x68\x49\x99\x50\x58\xb2\xfd\x8e\xdd\x47\xf6\x94\x8f\x9d\x3f\xe6\xe5\xd7\x5e\x66\x07\x12\x2e\xa8\x5f\x9e\x7a\xeb\xfb\xa7\xa1\xdb\x83\x8e\xf7\x52\x3f\x7d\xff\x79\x76\x2c\xa1\xcb\xdf\x1e\xd8\x34\x65\xbc\x02\x9f\x74\x3f\x81\xcf\x8f\x2a\x23\xf9\xe9\x6e\x99\xc0\xa8\x93\xb2\xf9\x5c\x76\xbe\xdf\x65\x6a\x0e\x9d\x37\xbd\x2a\xea\x4d\x23\x9f\x26\x4b\x57\x92\xd9\x48\x1c\xe9\x8b\xff\x27\xac\x49\xfa\x72\xa1\xa8\x64\xfb\x8a\x38\xc8\xc7\x4f\x32\x90\x8f\xdf\x30\x60\xf2\x2d\xaf\xbe\x9b\x04\xf6\x67\xef\xc5\xc1\xbe\x72\xee\x22\xb9\xfd\xfc\xec\x31\xe6\x8b\x29\x08\x17\xb9\x93\x12\x32\xab\xf8\x7c\x98\x83\x14\xd9\x34\x9f\x3c\x3b\x25\xa9\x88\x1c\x53\x11\x91\x5d\x2a\xb3\x27\x7e\xbe\xc2\x9b\x49\xe4\x18\xb3\xcb\x4d\x0f\x56\xbc\x00\x79\x64\x46\xf3\xd0\x8a\xa9\x0e\xcc\x27\x8a\x8b\x9b\x1b\x4e\x32\xed\x52\x9c\x96\xfa\x68\x0b\x24\xf6\xad\x1c\x46\xc8\xa1\x67\x11\x4c\xf0\x7d\xee\xcc\x01\xb3\xe7\x1f\x5d\xde\x7d\xd0\xb1\xb9\x13\xe4\x61\xf6\x9c\x56\xc3\x38\x5e\xe8\x37\xb4\xf2\xbe\x75\x38\x0d\x9e\x7a\x63\x61\x0d\x1e\xcf\x57\x8d\x9c\xa2\x16\x36\x69\xa2\xa1\x68\x47\x45\xa7\x24\xa0\xa3\xd0\x5e\x8c\x11\x89\xc5\x8c\xda\x44\x74\x92\x85\x37\x20\x32\x8d\xad\x16\xfd\x0b\x90\x4b\x5b\x00\x59\xfb\x55\x6a\xe1\x08\x04\x08\x70\x04\xba\x8a\x26\xf6\x49\xb6\x70\xc8\xc1\x27\xbc\xeb\x84\x08\x99\x5f\x70\xec\xd5\xde\x79\xbe\x62\xdf\xb1\x5b\xc4\x29\xf7\xdc\x73\x65\x80\x74\x17\x5f\x78\x03\xef\xbf\xfa\xd4\x98\x29\x8a\xbf\xe0\x52\xb8\x08\xdf\x08\xbf\x93\x3e\x6a\x0d\xea\x78\x1f\x65\xc1\x67\x70\x56\x38\x8f\xec\xa8\x38\x62\x20\x22\x2a\xf5\xb5\xe6\x50\xa9\xd5\x82\xfd\x79\x02\x83\x00\x79\xfb\x8d\x66\xdd\x11\x08\x32\x08\x9a\x1a\x95\x32\x13\x29\xd9\x47\xf7\x31\x93\x8d\xa3\xe0\x9f\xe2\x61\x41\x00\xde\xdf\x27\xe2\x77\xb6\xca\xeb\x51\x25\x9c\xaf\x7f\x6e\x65\x81\x71\x6e\xda\xe4\x6e\xda\x9d\xba\x39\xb3\x60\x16\x3d\x43\x87\x5e\xe2\x86\x90\x7a\xdd\xa8\x7d\xc4\x24\x52\x77\x0c\x08\xd9\xe2\xb6\x5a\x47\x20\x77\xbf\xdd\x69\x21\xb5\xee\x17\x79\x4d\x43\xf3\x43\xcd\x6d\x5a\x9b\xda\x68\x75\x84\xa6\x60\x3c\x3b\x34\x27\xcb\x71\x63\xea\xa4\x5b\x79\x6f\x55\xb7\x5c\x7b\xa1\x8f\x42\x72\xf5\x9f\xc3\xd4\x9b\x04\xf5\xf4\x65\x1f\x8c\xee\xab\xfb\x87\x76\xce\x4c\x98\xad\x8c\x45\x08\x2e\xf2\x88\xc0\x43\xed\x66\x3a\x47\x5c\x2d\xed\x66\xec\xcc\x60\x86\x0e\x8c\x11\x69\x09\xd2\xc4\x35\x4d\xa1\x6b\x1a\xcc\x50\xea\x96\x30\x98\x09\x25\x0c\x66\x60\xc6\x73\xef\x7d\xd6\x7b\xe0\xae\x07\xf1\xc1\xe3\x70\xfb\x5d\x4b\xd7\xf2\xfb\xa1\x18\x1f\xb4\x4c\x1a\x3c\x73\x3c\x47\xd6\x22\x7c\x60\xe2\x04\xb6\x0f\x78\x19\x2e\x0a\x6d\x09\x2c\x36\xd4\x8f\x40\x02\x66\x95\x5a\x67\x34\x88\xa2\xce\xcc\x6b\xac\x36\xad\xc6\xe6\xd0\xd8\xad\x1a\x0a\x09\xe9\x37\xc8\x3d\x68\xd6\xe9\x40\x7d\x84\x81\x44\x20\xa0\x70\xb5\x29\xba\xe6\x06\x21\x30\x3a\xac\x52\xc8\x30\x21\xc2\x32\xb9\xf0\xb3\xff\x39\x53\x67\x4f\x59\xfa\xcf\x63\x07\xe7\xa6\x4e\x3f\x53\x9b\xa6\x9d\xbe\x8f\xa0\xc9\x3b\x85\xe3\xa4\xdb\x30\x70\x7f\x93\xa1\x83\xe3\x38\xb2\x22\xa4\xd8\xb2\xc5\xfe\x24\xe3\xf6\x23\x83\xad\x2c\x62\xb5\xa8\xf4\x7a\x5e\x6d\x32\x9b\x1d\x1a\xb5\xda\xae\xd7\x9b\xd4\x74\xe8\x78\x01\xb1\x31\x2b\x2e\xa6\xdb\x71\xc9\xb0\x30\x95\x58\x99\x82\xb3\x65\x10\xb2\x39\x65\xba\x46\x80\x11\x76\x77\x2f\xee\xd2\xa9\x6b\x16\xfe\xe2\x9f\xd3\x03\x69\xaa\xd2\x29\xaf\xe3\x2f\xca\x17\xbd\xa4\x59\x2b\x76\x19\xc5\xfd\x8e\x1f\x9c\x3f\xcd\xfd\x16\x4c\xb8\xfa\xc5\x86\x19\x0c\x8f\xa7\xf0\xb7\xc3\x42\x16\xcf\x57\xab\xc4\xd6\xe2\x6f\xe7\xbb\xb2\x7b\x91\xe1\xf4\x9d\x7c\x05\x3c\x23\x2e\x25\x6f\xd3\x23\x7a\x51\xab\x25\xb8\xae\xd7\xa9\xd5\xe4\x65\xe1\xe9\xa4\xf3\x25\x74\x0a\x95\x94\x96\x85\x8c\x84\x57\xb2\xdc\x59\x52\xfe\x6c\xa7\x6e\x8b\xf9\x8a\x57\xe7\x3e\xd7\xaf\xff\xe3\x3d\xf1\x15\xd4\xac\xac\xcc\x88\x41\xa4\x45\x69\xb5\x7a\x9d\x46\x43\xaa\x6a\x2c\x2c\x8e\x8c\x54\xff\xec\xeb\x44\xe4\x37\x0b\x3c\xa3\x14\x27\x2e\x8d\x17\x07\x62\x0b\xb8\xa8\xd3\x51\x8d\x5e\xc7\x71\x48\x6a\x0e\x17\x58\x7c\x84\x95\x21\x33\xab\x23\xc0\x93\x8b\xbb\x75\x7a\xb6\xbc\x44\x5c\x8a\xaf\xf4\xdc\xd5\xaf\xff\xe1\xf9\xaf\x32\xb8\xbe\x16\x66\xc3\x29\xb2\x54\xe9\x91\x3b\xa2\x15\x11\x4f\x20\x32\x1a\x24\x3d\x2a\x7c\x2b\x69\x7e\xda\x28\x9b\xa4\x04\x4a\x90\x7c\x5f\x87\xdb\x8c\x9d\xb0\x60\xfe\x44\xe1\xc7\x82\xec\xca\x59\xe3\xab\x47\x8c\x6b\x51\x8e\x86\x57\x11\x4a\x4f\xca\x41\x4d\xcb\x51\x94\x97\x21\x07\xd5\x54\x86\xe0\xd4\xc4\xf9\x0b\xc7\x8f\x6d\x13\x16\x66\x8f\x1b\x31\x62\xdc\xac\xca\xec\x02\x52\x4e\x5b\x4a\x6b\xc5\xc7\x09\xcf\x12\x8e\xc8\x3a\xbd\xde\x89\x44\xab\x15\xb9\x64\xb5\x83\xd7\x01\xcf\x83\x8e\x37\x21\x86\xa3\xf1\x80\x2c\xa1\xe2\x16\x9b\x27\x74\x96\x34\x3f\x55\x0d\xce\x40\xf1\x7d\xbd\xfa\x84\xfb\x68\xf6\xdb\x9f\x5c\xb4\x7d\xcf\xf2\xe9\x04\x39\x1f\x30\x7c\x76\xeb\xa0\x5e\x1d\x5b\xd7\x2d\x7b\xfe\xe9\x3b\x9f\xb7\xd7\xa3\x16\xf5\x13\xd6\xcc\x69\x11\x9c\x82\x4b\x36\x82\x4d\xe7\xb0\xd9\x1c\x3a\xd2\xb4\xff\x59\x7f\xcb\x33\xea\x84\xb2\x58\xa0\xa8\xee\x8e\x3d\xdb\x17\x3d\x69\xdf\xaf\x21\x40\xf4\xba\xaf\x38\x00\x17\xeb\x6d\x2f\xdc\xf9\xf4\xf3\xcb\xea\x5a\x77\xea\x39\xe8\xd6\xcf\x0c\x78\x1c\xc5\xc1\x21\x68\xa1\x10\x15\xce\x10\x1c\xcc\x40\x4d\xef\xbd\x6c\xbc\x5a\xa3\xb7\x84\x45\xc2\x3b\x64\xac\x73\x22\x16\x49\xe4\x00\xf1\x82\xc0\x21\x5e\xad\xe2\x24\x01\x50\x61\x88\x45\xd8\x4e\x72\xc9\xe2\xf7\x69\xc0\x07\x5e\x61\xd1\x37\xf8\x45\xfc\xc2\x79\x58\x09\x5d\xde\xe2\x23\x57\x8f\x0b\x7c\xcb\xf2\x10\x08\x74\x2b\x9c\x13\x24\x52\x9e\xc8\x5f\xbb\x3c\x2f\x84\x34\x10\xe2\xfe\xc4\x47\xf1\xdc\xf3\xd0\x0d\xba\x7e\xf3\x96\xc0\x5f\x3d\xce\x47\x94\x73\x5c\xc2\x56\xee\x2b\xf1\x2f\xa4\x41\xe5\x91\x2c\x8d\x9a\x91\x3f\x1d\xaf\x06\xf5\xba\xe1\x74\xf7\xde\x04\x85\x50\x01\x35\xb0\x18\xb6\xc2\xaf\xa0\x22\x15\x54\xd7\x2a\xcc\x21\xc4\xa7\x35\xc5\x7f\x5f\x2e\x35\x05\x22\x95\x7c\xb5\xf5\x4d\xe1\xbd\x6d\xc0\x7d\x2b\xbc\x90\x76\xfc\x78\x1a\x74\x6a\x59\x07\x02\x49\xe4\xb5\x6a\x9d\x4a\x40\xc2\xba\xe1\xa2\x09\x81\x09\x15\xa2\x0a\x54\x83\x16\xa3\xad\xe8\x57\xc2\xb0\xd1\x3a\x8a\x9b\xd7\xe1\x83\x70\x48\xa6\xe2\x1c\x5c\xf8\x16\xe3\x6d\xef\x09\x6f\x6e\x15\xb6\x42\x47\xcf\xcb\x2f\x7b\xd8\x8a\xa9\x13\x6e\x85\xad\x2c\x8e\xb9\xed\x30\x75\xd4\x22\xf0\x04\xd6\x86\x90\xe7\x84\x69\x0b\xc1\xd6\x8d\x1b\x49\xa2\x71\xca\xfc\xce\x16\x0e\x70\xab\xc4\xe1\x24\x7d\x38\xe2\xe7\x78\x51\xe0\x60\x43\x74\x2a\xb7\x9e\xdb\xca\xf1\x54\x70\xad\xe0\x6a\xb8\xc5\x9c\xc8\x45\xb2\x73\x7b\x72\x11\xb7\xa7\x27\x87\x0a\x83\xc1\xea\x5a\x45\xad\xa9\x44\xc2\xcf\xe6\xc6\xd4\x3f\x2c\x0e\xdf\x45\xcb\x5b\x24\xec\xe7\xf2\x49\xfd\x22\x9d\x4f\x9c\x20\x92\x45\x5e\x25\x91\x21\x2b\x3c\x93\x3c\x2f\xc3\x24\x9b\xb8\x68\x37\x70\xf8\x82\xb0\x3f\x15\xc5\x72\xfe\x68\x91\x17\x89\x3c\x88\xd0\x32\x2f\xf8\xc3\x5e\xd9\x01\xf7\xe1\x0b\xc0\xed\x16\xf6\xff\x91\x13\x4b\x65\xed\xc6\x43\x61\x6b\xec\x68\x63\xbb\x81\xbf\x46\xbb\x49\xa2\x78\xbb\xb3\xf0\x73\xdc\x8a\xd8\x28\x92\xde\x72\x08\x90\xd2\x4d\xa1\x78\x9b\x64\xd2\xa6\x2c\xda\xa6\xad\xbb\x58\xda\xce\x78\x32\xfc\x1a\x5b\x11\x87\x4b\xe0\x39\x81\x53\x49\x88\xbf\x26\x5c\x37\x31\xb8\xf0\xe4\x38\x5c\xe8\x05\x3c\x99\x9b\x90\xc8\x4b\x68\x9e\x40\xfb\xa3\x79\x5e\xa5\x3f\x5e\x60\xfd\x81\x27\xc7\xfb\x83\xa3\x91\xfb\xe0\x92\xd0\x8e\xc5\xa4\xcf\x8a\x18\x49\xcd\xa2\x20\x6a\xd4\x12\x27\x71\x94\xfc\xbe\xc5\xe2\xc6\x27\x41\x40\x16\x36\xf0\x92\xf5\xe4\xd2\xc8\x59\x23\xa1\x14\xff\x73\xe4\x2c\xa1\x1d\x7e\x1f\xf2\xaf\x9c\x84\x7c\x0a\xcb\xf3\xbc\x31\x5e\x9e\xe5\x10\x22\x65\x91\x2a\xe2\x60\xc4\x33\xd3\x8c\x4a\x16\x85\xc6\xa2\x5b\xe0\x14\xfc\x1c\xa7\xb1\x7a\x7a\x86\xa4\x25\x8d\x2d\xbb\x16\x8d\xfd\xa8\x91\xc4\x92\x72\xbe\x22\xe5\x9c\x4c\x94\xa3\x42\x1a\xfe\x5a\x34\xd6\xdf\x84\xc6\x9e\x8c\xd3\xd8\x5b\x1a\x48\x2c\x29\xe7\x41\xf4\x0c\xa7\xe2\xb4\xa4\x37\xc8\x5a\xa4\x22\xdd\xc0\xf3\x1a\xb5\x28\x71\x1c\x1b\xbb\xd0\xe9\xa4\x15\xc4\xef\x25\xd2\x7d\xc8\x11\xe2\x54\xf8\xde\xb9\x0b\xe6\x3c\xb3\xe0\xdc\x39\x65\xdc\x9b\x94\x81\x08\x86\x09\x82\x46\x4d\xa4\x20\x15\x19\x92\xd3\xd4\x83\x7f\xd2\x2a\xe4\x73\x50\xbb\x3e\x2f\xa7\x9a\xb3\x60\x2e\x4c\x81\x75\xe7\xce\x2d\x68\x52\x86\x8e\xd0\x1e\xb3\x96\xfc\xe4\xa9\x10\x2c\x8a\x1a\x7a\x86\x91\x81\x72\xe6\x9a\x25\xc5\x21\x22\xa5\x11\x90\xc0\x39\x7e\xfc\x82\x39\x73\x68\x79\x36\xf4\x37\x77\x1f\x7c\xca\xc6\x85\x27\xb8\x48\x28\x45\x61\x71\x7c\x5c\xca\xc2\x5e\x87\x8d\x5b\xfe\x77\x1c\xfe\xd8\x29\x42\x43\xee\x14\xbf\x26\x7c\xda\xd2\xc8\x18\x9d\x89\xa7\x8e\xa3\xf9\xbb\x86\x23\xd5\x86\x68\x4b\x12\xa2\x41\x8b\x4d\x7b\xe8\xa9\xae\x0a\xd3\x54\x13\xef\x34\x9b\x32\x4d\x11\x53\x95\x69\x9a\x69\x89\x69\x9b\x49\x55\x45\xbe\xf6\x9a\xce\x99\x04\x64\x32\x9b\xb8\xf2\x08\x79\xbe\xcd\xf4\x36\x79\x20\x22\x53\x91\x69\xa4\x69\x03\xb9\x15\xd5\x23\xaa\xeb\x46\x54\xd7\x92\x4f\x1d\x2a\x24\x3f\x82\x71\x82\x14\x5f\x16\x73\x43\x8a\xcb\x16\xc2\x44\x40\xee\x7d\x47\x75\xdb\xcd\xe3\x7b\xf4\x98\x60\xdc\x61\x7d\x4e\xd8\x7a\x78\x6d\xbf\xe8\xd0\xca\x8d\x7b\x58\x9f\xbd\x2e\xd4\xc3\x57\x8c\x2e\xd1\x36\x92\x46\x92\x36\x26\x66\x27\x3d\x26\xfc\x3a\xa4\x08\xf5\xf4\x48\x30\x41\xca\x5c\x61\x1a\xe7\x93\x26\x93\xfe\x95\x51\x6e\xc4\xa1\x47\x64\x15\x91\x52\x5c\x1a\xd3\xc6\x28\xaf\xd9\x38\x9c\x77\xdc\x1d\xe5\x29\x15\x0a\x26\x23\x7f\xe2\xe4\x3f\x59\xc1\x54\x8d\xbe\xba\x4a\x39\xdf\xbd\x93\x26\xdd\xbb\x69\xc2\x84\x4d\x8b\x7b\x95\x86\x7a\xf7\x0e\x85\x7b\x8b\xb7\x4d\xd8\x44\x1f\x6c\x9a\x10\xea\xdd\x33\x5c\xde\xb3\x37\x85\xaf\x2f\x21\x0d\x6f\x23\x07\xb2\x20\x5f\xc4\xac\xd2\x6a\x79\x33\x6f\xb3\x4a\x0e\x64\xb8\xbb\x31\x8a\x42\x73\x86\x80\xb1\x4e\x09\x63\xcb\xb6\x53\x17\x0d\xed\xf1\x40\x45\x97\x36\x05\xa5\xed\x2a\xf0\xd0\xc9\x37\xf7\x59\xe1\xcf\x9b\x1e\xce\x0b\xa5\xae\xf6\x92\x71\xfb\x8d\x8c\x1b\x16\x4f\x20\x17\xda\x12\x19\xee\x74\x6b\x52\x1c\x06\x83\xb8\x21\x8a\x0c\xeb\x87\x23\xeb\x86\xa8\x5a\x87\x40\x87\x82\xa8\x3d\x1a\x8e\xe6\xa3\x87\xd0\x8f\x74\xf0\x04\x77\xb6\xbb\xc4\xcd\x0b\x6e\x3b\xf9\xea\xea\x1e\xe3\x9e\xe1\xde\xe8\xde\xe1\x3e\xe1\x7e\xdf\xfd\x87\x5b\x67\x27\x6f\xbb\xba\x07\x91\x87\xcb\xc9\xc3\x83\xe4\xe1\x79\xb7\xd6\x7d\x24\x76\x3c\x92\x59\x1a\xe9\x69\x76\x43\xa6\xbb\xca\xbd\xc4\xbd\xd7\x7d\xce\x4d\x88\x4f\x91\x7b\xa4\x7b\x83\xfb\xb8\xfb\x92\x5b\xea\xcc\xd5\xd0\x11\x25\x44\x5c\x19\xd2\xe2\x60\xd3\x41\x6d\xcd\x51\x26\xc4\x47\x4f\x38\xa4\x73\xf1\xc1\xe5\x32\xf2\xa3\x83\xfa\xa4\x07\x82\xc6\xd5\xea\x36\x37\xf7\x2d\xb8\x69\x50\x2f\x4f\xab\x02\xe3\x4a\x55\xad\xb0\x35\xa7\x30\xa7\x75\xbf\xda\xda\x1b\xc8\x77\x9b\xde\x8f\xac\x52\xfc\x07\xee\x10\xb6\xf1\x12\xa3\xe5\x3a\xba\xda\x49\x5a\x81\xb0\x7d\x06\xbd\x86\x61\xab\xf4\x3f\x57\x3b\xd2\xcd\xc5\x71\xba\xe8\x0b\xdb\x42\x0e\xe5\x5a\xbc\xee\xab\x1f\x87\x91\x8f\xb0\x2d\x0b\xb4\x41\x1c\xa3\x57\xd2\xaf\x1f\xc0\x78\x6e\x2c\xdf\x96\x48\x90\x64\x2e\x9a\x40\x63\x45\xc8\x62\x36\x11\x66\xd7\x04\xa2\x8e\xcc\x45\x32\xa7\xdb\x16\x9a\xcf\xd0\xc6\x59\xdb\xd2\x15\x94\xf7\x27\x7b\x19\x2a\x04\x55\x10\xe4\x46\x87\x42\xf3\x96\xa5\x68\xfa\xf0\x5c\x59\xdc\x79\xd0\xe8\x51\x3e\xb3\x42\x37\x78\x3e\xc4\x3d\x2e\xfe\x4c\x5a\x53\x14\x71\x0a\x5a\x49\xcd\x11\x4e\x58\x4d\xe6\xbd\x56\x05\x02\x10\xca\xac\xd1\x31\xa6\x83\xed\x90\x35\x55\x54\xd8\xca\x72\xcb\xe4\x32\x59\x25\xab\x72\x55\xfc\x8f\x3f\x4c\xf8\xfe\xfb\x09\x3f\x90\xeb\x8f\xfc\xd6\xdf\x7f\x9d\xf4\xcb\xaf\x93\x2f\xfd\x32\xe5\xdf\x94\xde\xc7\xfe\x46\x47\xb8\x3f\x88\x6c\x61\x21\x52\x61\xf7\x48\x9a\xde\x64\x47\x82\xc5\x68\x30\xd3\x53\xd9\x1a\x2b\xef\xd4\xf0\x9a\xb4\x54\xbb\xc9\x24\x99\x0d\x54\xfa\x71\x21\x89\x10\xea\x6b\xc8\x61\xc9\xd6\x55\x71\xa7\x2f\x8a\x4f\x8c\x50\x2a\x84\xa0\x24\x57\x89\x21\x06\xbf\x76\xcf\x9b\x39\x65\xe2\xbc\x9c\x4e\xb8\xfe\x8d\x7d\xcf\x9d\xc2\xc7\x3b\xb4\x6b\xe7\xc9\xe0\x76\xdd\x3e\x3d\x7b\x6c\x6d\xdd\xad\xad\x6a\x67\x72\x3d\x70\x7f\xd8\x7f\xf5\xc9\xee\x53\x66\x54\xf4\x0f\xb0\x7e\x68\x03\x3f\xa2\x4b\x84\x5f\xe6\x51\x8a\x32\x8f\xe1\x79\xf0\x91\x17\x79\xa8\xa2\xa2\x61\x3e\x93\xea\xdb\x1c\x83\x1f\x05\xe7\x95\x8b\x4a\x9e\xcf\xb8\xb7\x84\xdf\x68\x3c\x9a\x88\xd5\x6b\x57\x49\x06\xea\x7f\xdd\xee\x46\x42\x30\x2f\x35\x5d\x3e\x02\xad\xf6\xab\xb4\x7c\x42\xc8\x6e\xd2\x7b\x8d\x53\xbb\xd1\x39\x4f\x4b\xb5\x67\x3a\x27\xa7\x73\xdc\x5b\xfb\xef\xbb\xff\x31\xf7\x2e\x63\xcf\x21\x83\xba\x75\xec\xf6\xd0\xcc\x8e\x5b\xef\xbf\x63\x8b\xfd\x49\x4d\xa4\x6b\xd7\xae\x69\xa1\x6e\x79\xb7\x4d\x6a\xcb\xbd\x5e\xbb\x60\xf4\x44\x77\x69\x41\x7e\xd0\x1f\x34\x66\x96\xdf\xdc\x75\xca\xbc\x49\xb7\x58\x8b\x0a\xb2\x83\xee\x0c\xbb\x59\xeb\x6a\x37\x3c\x16\x8b\x61\xc2\x4b\x5f\x12\xce\x9b\x55\x7c\x1b\xa0\x56\x5a\x94\x9f\x8d\xf3\xd7\x56\x89\x5b\xc6\xfa\x61\x33\x19\xb0\x79\x0c\xbf\x5d\x11\x0d\x21\xd8\xbc\x4a\x02\x22\xf8\x15\x86\x1a\x8f\xe9\x78\x7d\xd4\x1f\x31\x37\xef\x00\x3e\x0b\xe7\x45\xef\x53\x4d\xf2\xb1\x15\x5d\x04\xda\x91\x6a\x0d\x0d\xb2\x00\x2a\x54\x58\xd8\x4c\xbf\xa0\x94\x60\x09\x29\x65\xb4\x39\xc0\xbf\xfd\x14\xc4\xcf\x2a\xff\xff\x54\x0e\xb7\xe2\x29\xee\xa1\xff\x3f\x94\x03\x9d\x9f\xe2\xcf\xa1\x96\xfd\xc1\x93\x07\x92\x8a\x23\x42\x5f\x61\x43\x7e\x6a\x00\xa1\xe4\xc5\x69\x24\xeb\x53\xa2\x22\x17\x8c\x26\xf9\x7a\xf1\xd3\x94\x7c\x02\xd0\x7c\x71\xfe\x3d\xd9\x70\x22\x64\xf1\x72\xbd\x70\xca\x4c\xa8\xe3\xa7\xd5\x73\xc9\xf9\xd8\x3a\x4e\x58\x00\x9e\xc2\x0d\x12\xe1\xa9\x09\x4f\xd3\x4c\x4b\x43\xf5\x93\x4a\x09\xeb\x66\x92\x22\x60\x31\x5e\xca\x4f\xc3\x4b\xe9\xb8\xc6\xbe\xc5\xc3\xb8\x93\xb1\xd5\x56\x42\x6e\x11\xfa\xef\x08\xb6\xfe\xf8\x84\x27\xb9\x95\x52\x1a\xe3\xbb\xa8\xa4\x0a\x02\x35\x80\xd6\x00\x21\x68\x0a\x45\x49\x2e\x9b\xb4\x89\x8e\xf2\xca\xfa\x87\x29\xc7\xc8\x8d\x11\xef\x59\x83\xd7\xad\x61\xe5\x2c\xe3\x2b\x78\x22\xa7\x13\x7e\xdf\x46\xa8\x86\x43\x50\xa9\x24\x8d\xd9\x66\x33\x5a\x34\x16\x87\x5d\x65\xb1\x58\x35\x46\x81\x15\xd8\x08\x6f\xd2\x0e\x0e\x15\xa6\x4b\x89\x2c\xed\x15\x1b\x7e\xf1\x0b\xdb\x74\x38\x72\xc7\x62\xc8\xc0\x81\xe2\xf6\x87\x97\x91\x1f\xc2\xcb\xb3\x0e\x0f\xd9\xb5\x19\x84\xe3\x0b\x0f\x0c\xa4\xdf\xca\x99\xb7\x87\x38\x5f\xec\x45\x22\x1b\x39\x9e\x15\x41\x4d\x58\x1b\x22\x69\xc5\x25\x22\x85\xd7\x0b\xc9\x65\x21\x1e\xca\xf7\x2d\xae\xac\x5c\xbc\x0f\x3f\x04\xde\x2d\x5b\xf0\x97\xa8\x79\x5e\x10\x89\x34\xc5\x51\x06\xbc\xb8\x21\xaf\x68\xf3\xe5\xaa\x7c\x36\xa8\x53\xf2\x76\xc5\x5f\x6e\xd9\x02\x5e\x05\x07\x5e\x23\x6b\xe8\x77\xb1\xdf\x49\xde\xb4\x88\x4e\x24\xdd\x05\x12\x15\xc7\xe8\x68\x26\x73\x7a\xb2\xdf\xa1\x92\x1d\xfe\xd7\x94\x5a\x8f\x2a\x05\xb5\xc8\x4f\x70\x48\x44\x04\x00\xe0\xc5\x66\xf9\x0d\x10\x2e\xcb\x0d\x8b\xf0\x9d\x52\xf7\x7f\xe3\x05\x70\x68\x13\x1e\xca\xd9\x63\x1f\x32\xbe\x81\x8c\x5b\x82\x6f\x70\xf0\x26\x4d\xf3\x71\x13\xaf\xc7\x2e\xd8\xa7\x0c\xac\x9a\x36\xad\x6a\xc0\x6d\xa3\x43\x79\x79\x6d\xda\xe4\xe5\x85\x7e\x18\x78\xdb\xe4\x41\x37\x4e\x9e\x32\x30\xaf\xa4\x24\x2f\x58\x5a\xaa\xb4\xb5\x33\x7a\x95\x08\x82\x5f\x10\xbc\xb5\x1c\x6a\x2a\xa6\xb4\x29\x2a\x80\x24\x51\xe0\x55\x45\x12\xa0\xf4\xfd\x18\x7a\x95\xfb\x92\xe5\xd1\x31\xbc\x52\x83\x4e\x67\x00\xbd\x9a\x97\xe2\x5d\x0c\x8a\x06\x8d\xb2\x7d\x4c\x9a\x08\xb1\xeb\xc7\xac\x9c\x2f\x1a\x4b\x53\x4a\x6c\x51\x1e\xd2\x0a\x92\x40\xf8\xf3\x6b\x95\xe7\x67\x12\x86\x97\x5d\xa1\x0d\x13\x34\xea\xff\x62\x5f\xaf\x32\x71\x23\x21\x83\xc5\xfe\xc0\x6b\xb9\x43\xb1\x4d\x34\x9e\x4f\x44\xe7\x4c\xd5\xb8\x1d\x64\xe9\x41\xa2\x81\x74\xe0\x17\xc5\x27\xcc\x27\xfe\x17\x97\xc0\xc1\x8f\xad\xaa\xfa\x76\x4d\xf5\x07\xb4\x0b\xd4\xc1\x41\x5d\x03\x03\xfb\xdc\xe0\xce\xcf\xd6\xcc\x13\xf3\x07\xe1\xb5\xbe\x80\xaf\x30\x32\x76\x5c\xfb\xac\xbc\xac\x76\x25\xa3\x27\xc4\x75\xc0\xaf\xc1\x2b\xf0\x2d\xe3\x0b\x55\x28\x3b\x62\xe2\x55\x88\xd0\x1e\x15\x61\xeb\x11\x15\x96\xa8\x62\x28\x2e\xe4\x34\xac\xa6\xd4\x40\x8b\x7c\x5e\x83\x4c\x7a\x52\x5b\xd8\x4f\x6d\xd9\xea\xcd\x54\xbb\x4f\xc7\xe5\x09\x61\x09\x27\x25\xe8\x10\xa5\x0a\x84\x9e\x50\x3a\xd4\x30\xfa\x4c\x64\x25\xfc\xf8\x13\x50\xfd\xc3\x0c\xf1\x74\xed\x67\xca\x78\x36\xc9\xc7\x73\x88\x23\xf9\x44\x2a\x3a\x37\xe6\x03\x45\x1a\x90\x66\xfc\x00\xd5\xc2\x92\xcf\x6a\x95\x7c\x78\x02\x27\xc5\x0e\xc5\xeb\x23\xf2\x19\x91\x4b\x9a\xe5\x93\xe9\xde\xab\xf7\x89\x19\x3f\xe0\xed\x7d\x48\xae\x66\x79\x08\xe2\x10\x69\x92\x6b\x06\x23\x30\xf9\x85\x93\xf0\xf6\x1f\x66\xe0\x09\x0c\x48\x40\xe9\x78\x28\x6f\x8e\xbd\x1f\xa7\x4a\x88\x5a\x9b\x69\xd4\x02\x30\x99\xe3\x4c\x53\xaa\xa4\x38\xad\xe1\xcd\xf5\xc6\xc7\xe0\xe9\xed\x64\x5e\x2d\xfc\xd7\xbf\x9a\x94\x11\xa7\xb7\x14\x75\x15\x51\x39\xb9\x6e\x9a\x9b\xe5\xe5\xaa\x58\x56\x92\xaf\x1d\x99\x5b\xb5\x84\x31\xd5\x90\xba\x0d\x9c\x0a\xa9\x04\x5e\xab\x03\xb5\x9a\x0c\x18\x55\xde\x25\xd6\x6c\x32\xb3\xbc\xb2\x8f\x27\x0c\x9b\xca\xcb\xd5\xe2\xea\x9d\x33\x5f\x7b\x6d\xe6\x4e\xd8\xfe\xfc\xaf\x90\x6a\x84\xd4\x5f\x29\x0c\xf5\x1f\x48\xd9\xb1\x65\xaa\x4e\x04\x06\xf5\x3e\x36\x6f\x12\xd2\x33\xfe\x85\x21\xb9\x94\x9d\x98\x33\x80\x47\x49\xd9\xc8\xd4\x2c\x2d\xc3\x62\x3c\x8a\xa1\xaf\x94\x1d\x47\x5d\xb2\x6c\xdf\x2d\x6c\x85\x3a\xf1\x2f\xb3\x8a\x5b\x85\xef\x56\xf4\xfb\x57\x47\x48\xbe\x58\x86\x2a\x48\xf0\x39\x23\x62\x21\xb8\x2c\x66\x1a\xc0\x64\xc8\x30\x14\x1a\x78\x83\x95\x4d\x93\xea\x3a\x8a\xd7\xd7\x43\x69\x3c\xf8\xba\x28\x2d\xf9\x5a\xa0\x34\xe0\x33\x62\x36\xb4\x61\xf8\xac\xde\x47\xc5\x7c\xd6\x9f\x0e\x2f\x3e\xc3\x74\x24\xa7\xa9\x8e\xa4\x7e\x97\x14\xe1\x3a\x4b\xeb\x58\x1a\x26\xeb\xd1\x36\x79\x1d\xf5\xbb\x84\x07\xa4\x48\xff\xfe\xac\xdd\x5b\x84\x27\x60\xb4\xf8\x13\x91\xf3\xf4\x07\xb4\x02\x65\x8f\x8b\x4f\x93\x74\x7c\x13\x91\x8b\x6b\x2a\x71\x3d\xd1\x20\x71\x41\x6c\xba\xf0\x3b\xba\x4b\x7c\x25\xb9\x0e\x6a\x71\xb9\x96\x88\x59\xbf\x33\x31\x0b\x71\xf8\x05\xe1\xdf\xd0\x3d\x3e\xf7\x8c\x07\x89\x00\x4b\x85\x32\xe5\xdc\x28\xdd\x5c\x21\x08\xe4\x98\xf2\x49\xfd\xcc\x0f\x85\x7f\x7f\x46\xfe\x94\xf1\x30\x89\xef\xc5\x3e\x22\xfd\x69\x41\xe6\x43\x66\x81\x53\x19\x4c\xca\x0a\x46\x68\x0c\x5f\x12\x77\x58\xa6\xa8\x2e\x7d\xe1\xe2\x0b\xf7\x96\x94\xeb\xca\xa6\xad\xdd\x38\x6c\xc4\xe6\x75\xd2\xf2\x4e\xea\xb1\xba\xca\x5e\xe1\x9e\xaa\x0e\x73\x18\x3d\x8c\x08\x8b\xd1\x31\x11\x33\x7a\xad\x3f\x60\xd2\x38\x78\x56\x16\xa9\xfd\x3a\xd4\xf9\x58\x0b\xe2\x2c\x56\xb4\xa0\xce\x1c\xce\x17\xb6\xc1\xba\xb8\xec\xa1\x3f\xa0\x11\x54\x8a\x3e\x90\xcd\xe0\x06\x79\x02\x3f\x7f\x2d\x81\xa2\x19\x1e\xad\x4e\xe0\x51\xec\xb0\x70\x2b\xea\x1d\x1f\x57\xa6\x52\xa3\xd2\x89\x25\xd4\xbb\x51\x97\xc6\xc5\xca\x49\x9a\xd7\xe3\xfd\xa9\x3f\x20\x31\xfa\xc1\xea\xe5\xa9\xfa\x89\x7c\xca\x37\x6c\x00\xb4\x61\x03\xcd\x81\x1f\xa0\xb9\x9a\xc2\x6a\x3c\xa8\xe2\x96\xe8\xe8\x72\xe7\x66\xb9\xc2\x21\x9b\x83\xea\xfb\xc8\xb5\xd3\x8f\x5f\xad\xab\xcf\x27\x17\xf1\xd1\x20\xbe\x9c\x05\x40\xaf\x34\xff\x2e\xe1\x61\x18\x26\xed\xa1\x72\x35\xb2\x1e\x36\xaa\x54\x88\xd3\x35\x30\x15\xca\x98\x37\xc5\x99\x55\x60\xbf\x6b\xe3\x73\x04\x6d\x46\x76\xeb\x39\x82\xa0\xcd\x3e\xf1\xdc\xd9\xb3\xf8\xc5\xa7\xd7\xf7\x27\x7f\xf7\xef\xa0\x63\xbc\x5b\xd8\x01\x83\xc4\xf7\x18\xee\x91\x89\xae\x8b\x8f\x8a\x85\x4d\x0e\xe6\x0d\xd3\xd7\x1a\xba\xde\x6a\x7c\xc4\xba\x7f\xc3\x86\xfd\xd6\x47\x8c\x63\xc4\xc8\x80\x3e\x1b\xb6\x6e\xdd\xd0\x67\x00\xed\xab\xdb\xf8\x0a\x74\x37\xd3\xf3\xeb\x0f\x34\x6c\x3b\x50\x58\x1a\x76\x1b\xee\xb9\xc6\x6e\x43\xd3\x7c\x0d\x3b\x0c\xa4\x9f\x1b\xf7\x15\xee\x6e\xb9\xad\xd0\x2c\x5f\xc3\x76\x02\x5d\x29\x1a\x76\x11\xd6\x5e\x63\x13\x01\x90\x9d\xaf\x80\xb2\x96\xf5\x25\xef\x63\x94\x5d\x63\x1f\x23\x16\xc0\x93\xd1\x47\x4c\xa7\xa7\xdd\x8f\x96\x10\xa4\x75\x53\x6c\x60\x14\xac\x4b\x13\xf5\xdf\xf5\xd2\xf2\x8c\x82\x7d\xd4\x54\xdf\x07\xb1\xae\x78\x28\xda\x16\x3b\x41\xb0\x47\xda\x4b\x80\x21\x2b\x87\x45\x51\x1b\x6d\x5b\x70\xee\x5c\x07\xa6\xc8\x62\x65\x8e\x24\xe9\x5e\x8c\xa7\x03\x9a\x4e\x45\x8d\x7b\x1c\x3e\x4b\xf6\xb9\x73\x0b\x3a\x30\x65\x15\x9b\xab\x2b\x85\xe7\x61\xae\x74\x0f\xab\x3b\xbe\x98\x29\xfb\xf6\x61\x2f\xcc\xdd\x5e\xbf\x8f\xfb\x8d\x24\x68\xbb\x95\x95\xf9\x13\xf7\x17\x19\x73\xa5\x2f\x04\x41\xd2\x26\xc6\x8c\x75\x83\x97\xf6\x88\x7d\xd2\xf4\x85\xa0\xda\xfd\x22\xbf\xd4\xb8\x6c\x12\x08\xef\xbe\xf8\x85\x87\xe4\x5b\x8b\xfb\xa3\xba\xd8\xc7\x48\x4f\xe9\x1d\xe9\xf9\xb7\xd8\x71\xed\x46\x4d\x5e\x5d\x5c\x91\x87\xfb\x37\x6a\xf2\x68\x7d\xbd\x48\x1b\x0e\xc7\x0e\x30\xca\x43\x35\x78\xca\xf2\xc7\x56\x67\x45\x4f\x76\x18\xdf\x3b\x6f\xc1\x6c\x3c\x94\x69\xee\x9a\xa6\xe7\xa9\xbe\x4e\x51\xf9\x91\x3e\x8a\x6b\xe9\x0e\xcf\x5e\x30\x0f\xa6\xbc\x11\xd7\xd1\xc5\x7a\x90\xf4\x47\x48\x7a\x1d\xe9\x23\x15\xed\x23\x5b\x92\x0e\xee\xc8\x7c\xf6\x87\xdf\xa8\xab\xab\x9d\x3b\x97\xf5\xd5\x8d\xf8\x43\x78\x3a\xb6\x5e\xa1\xdb\x9c\x42\xb7\xc9\xdc\xc1\x37\xf2\x37\xe1\x0f\x9f\x7b\x8e\x95\xe9\x24\x8b\xa1\x0b\x8d\x21\xf3\x42\xbb\x9f\x9e\xce\x67\xfd\xe9\x4f\x3a\xeb\xdd\x11\xc0\xf5\x48\xdc\xbb\xd1\x98\x7d\x71\x0b\xa1\x23\x8a\xee\x9f\xac\x9f\x5c\x3c\x2f\xaf\xa1\x53\x42\xc9\x9b\xb4\x7d\x0b\xae\x84\xb3\xa1\x31\x47\xe2\x9e\x85\xf6\x31\x19\x65\x3a\xbe\x07\xdd\x15\x1b\x45\x64\x14\x2b\x7a\x0f\x29\xb4\xfb\x79\x5c\x07\xdd\x62\xfd\xe2\xb4\x1b\xd1\x13\x80\xa8\x30\x14\x4a\xa6\xdd\x93\x29\xed\xc6\x75\x09\xda\x4d\xe8\x2d\xe9\x93\x63\x71\xfe\x58\x7f\xa0\x81\x2d\x26\x7d\xf8\xff\x4c\x6f\xaf\xc1\x0c\x43\xec\x0e\xdc\x16\xcd\x8b\xed\x27\xbc\x81\x76\xbf\xa0\x62\x85\xb2\x32\x99\xd4\x12\x0e\xcd\x0b\x86\x56\x8f\x98\xfc\x9f\xd3\xbd\x66\x76\x1c\xd3\xfd\x2c\xe9\xeb\x2b\xb8\x1a\xac\xb1\xdf\x18\x14\x6a\xde\xe0\x88\x43\x21\x36\x3a\x80\x0d\xd3\xa5\xa4\x8c\x05\x77\x00\xeb\xd1\xdd\x37\x0f\xe8\xd7\x6f\xc8\xa8\xf9\x15\x5d\xd3\xed\xd9\x39\x79\x29\x73\xef\x3a\x7d\x6b\x9d\x61\xbe\xae\x75\x70\x90\x7d\x92\xa0\x16\xf9\xb1\x0a\x4e\xf5\x24\xed\x3b\x4d\x7e\x59\x08\x1c\x06\xa4\x52\xfa\xd8\xd6\x42\x55\x17\x9e\xba\xa8\x5b\xf9\x96\xe2\x50\x83\xa6\xae\xcb\xdc\x9c\xc0\xad\x85\x8a\xa6\x8e\xd1\x7a\x52\x4e\x6f\xb6\x97\x40\xd6\x4e\x3e\x99\xd6\x37\xec\x1f\xe0\x95\xe4\xe7\x5c\xc6\x8b\xe9\x0f\x10\x51\x47\xd5\xb8\xc2\x50\x97\x81\x74\x7e\xe1\x1b\x1f\xe3\x7e\xc3\x43\xff\xf5\x2f\x58\x48\xd2\xef\xc3\x5b\xa1\x32\xb6\x18\xd9\x51\x4a\x44\x6b\x35\x18\x78\x5e\xb5\xc4\xa4\x65\xeb\xad\xfb\x74\x5c\xdd\xc5\x42\x5b\xe4\xb2\xa1\x08\x11\xc4\x50\x2e\x50\xc9\xdd\x32\xec\xa6\xb2\xb2\xe1\x37\x8d\x19\x7f\xf3\x4d\xb7\xdc\x7c\xd3\xd2\x09\xb3\x3b\x76\x5c\x30\xa6\x96\xfc\xd1\xb5\x0a\x4f\x81\xba\xd8\x16\x33\xe9\x76\xbc\xfb\xbf\xd3\x19\x6c\x77\xe3\x61\xe4\xd9\x6a\x32\x1e\xd6\x67\x39\x49\x2d\xad\x1f\xce\xab\x91\x62\xcb\x94\xbc\x4b\x05\x75\x89\x5d\x2a\x3c\xd3\x73\xdf\x7d\x1e\xb0\x93\xf2\xb6\xe2\xc9\x70\x4b\xec\x2e\x52\x9e\x80\x77\xfc\x97\xcd\x25\xbc\x0b\x4f\x80\x61\xa4\x3c\x03\xc1\x34\x9d\xb0\x84\x31\x23\x6e\xda\xb7\x2a\x65\x29\x50\xb8\x26\xe0\xd6\x1f\xb1\xed\x30\x8e\xe8\xd9\x6d\xa4\x79\xbb\xee\xf9\xd9\xf7\xaf\x8a\xf4\xec\x19\x59\xfc\xa8\xd2\x5f\xf3\xf1\x5c\x58\x19\xdb\x42\xbd\x0b\x45\x2c\x56\x35\xf3\x70\x81\x90\x43\x44\x06\xb3\x81\x23\xd2\x45\x75\x28\x14\x2a\xac\x2e\x66\x03\x76\x2d\x05\xe4\xae\xeb\xe9\x1f\xf1\xdc\x6b\xe8\x1f\x01\x9f\xc5\x7b\x20\x14\x1b\xaa\xac\xd7\x0a\xff\x23\x52\x3e\xec\x2c\xe5\xc3\x9e\xd8\x45\xe7\x55\xfd\xa1\x98\xc4\xf5\x8f\x0d\x32\xab\x50\x97\xfa\x37\xe2\xf3\xea\xb5\xab\xf5\x50\x1e\xeb\x18\x5f\xc3\x95\x3d\x12\x86\x9d\x94\x1a\x30\x8a\xf0\x1a\x37\xbd\x7e\x2d\x37\x1d\xd7\xbd\xf9\x26\xbe\xf3\x8d\x37\x48\x9f\xcd\x47\x67\x60\x25\xfc\x46\xf8\x85\x2d\x78\xf5\xd5\xd6\xac\xfe\x17\x50\x0c\xba\xc1\xbb\xac\x7e\xb6\x3f\xa1\xe8\x0a\xa0\x5b\xfd\x2c\x6e\x0d\x8a\xbd\x47\xf9\xc0\xc3\x28\xc6\x5d\x23\x0d\xd7\xed\x4a\xad\xb0\x5e\x49\x83\xd3\x63\x17\xe1\x5b\x7e\x77\x32\x2e\xfa\x41\x26\xcf\xf9\xd2\xbb\xaf\x9e\xbe\x9d\xcf\xdb\x74\x95\xa6\x8b\x49\xb1\x8f\xd0\xdf\x71\xfe\x84\x53\xf8\x64\x15\x19\xe2\xbf\xc1\xf7\x0e\xfe\x3a\x20\xfe\xe7\x6f\x9d\x32\x47\xee\x22\xf4\xba\x36\x4e\xaf\xf5\x0a\xbd\xe6\x93\x77\x70\x66\xc4\x77\x70\xf0\x2b\x49\x5b\x38\xcd\xf0\xbd\x41\xe4\x68\x94\x34\x60\x6e\x13\x49\x83\x63\x6b\xd9\x8b\xb1\xb3\xf1\x7e\x54\x29\x39\xd8\x7c\xa4\x87\x60\xc2\x3e\xc7\x8b\x78\x15\xcc\x19\x7d\x90\x64\x98\x83\x2f\x1e\x3c\x48\xeb\xd8\x8b\x1f\x83\xaa\xd8\xed\xc8\x89\x3c\x11\x3d\xaf\x56\x9b\x90\x5e\x6f\x91\x96\xd8\x28\x8b\xe9\x56\xb4\x24\x0a\x81\x63\x7e\x96\x7d\x25\xbe\x04\x43\xc2\x4c\x58\xe5\xaf\x34\x01\xef\xcd\xb7\xdc\x94\x95\xa7\x99\x66\xbc\xb5\xef\xf0\xb2\xb2\x21\xfd\xc6\x1b\xf0\x47\x59\xee\xda\x5a\x77\x56\xd5\xf0\x8e\x1d\x6f\x52\x74\x67\xb1\x42\x61\x1e\x7a\x57\x4a\x27\x74\x50\x45\xd6\xd9\x14\xba\x38\xa8\x72\x55\xb9\x71\x35\xed\xbb\xd5\x33\x67\x54\xcf\x99\x53\x3d\x63\x66\xf5\x2c\xe1\xa3\xea\xb9\x73\xab\x67\xce\xac\x9e\x3d\xbb\x7a\x26\xcb\xfb\xb0\x70\x1b\x1a\x23\xd5\x12\x3c\x56\xef\x13\xcc\x84\xc4\x50\xbe\xb7\x13\x50\x22\xae\xf8\x09\x60\x07\xec\xa9\x3b\x80\x31\xad\xfb\xf5\xcb\x29\x4a\xcd\x4c\x8d\x4e\xcd\x29\x70\x67\xb8\xc5\x2f\x8a\x3b\x66\x8a\x51\x95\x3b\xd3\xd6\xa6\xac\x43\x7a\xe7\x3e\xea\xe1\x92\x2b\xcb\xde\xa6\xbc\x1d\xc1\xbb\xfa\x03\x52\x36\xd7\x57\x95\xce\xfa\x4b\xbd\x8f\x0a\xf0\xa7\x15\x9c\xf3\x53\xc9\xe0\x80\xf0\xc0\x95\x71\x44\x3a\xc8\xee\xdf\x7f\x37\x15\x10\x00\x0f\x14\xf6\x23\xc4\xf8\x46\xb2\x9e\x2c\x41\x71\xbe\x82\xf1\x20\x9b\x9a\x6c\x8d\xb2\x7d\xe7\xfd\xf0\x4c\xf3\xb4\x16\xc6\x83\x34\xdd\x82\x25\xe5\x6e\x13\x76\xc3\x28\xf1\x20\x91\x97\xac\x87\x1d\xa2\x61\x89\x95\xae\x55\x27\x42\x6e\x22\xfc\x5f\x67\x6a\x72\xf7\x5d\x57\x42\x12\x76\x5f\x43\xe8\xa7\xfc\xda\x1a\x44\xe3\x06\x6b\x28\x66\x10\x42\x93\xe0\xd7\x1a\xf4\x5c\x77\xb7\xe9\xc0\xb4\x5b\xa2\x66\xee\xfe\x41\x8a\x56\x0b\x21\x1e\x17\x12\xbe\xfc\x1d\xf1\x3c\x69\x87\x86\xda\x29\x3d\xcb\x2f\x51\xe9\x74\x5a\xa6\xec\xa0\x52\x4b\x03\x67\x45\xba\x41\x59\x01\xef\xea\x06\xf0\x05\xa4\x7e\x72\x75\xc4\x87\xc2\x56\x2f\x64\xfb\xf1\x39\x33\x5b\x0e\x21\x46\x30\x15\x3d\x1a\x5b\xca\x78\x5c\x5e\xbd\xc4\x40\x3b\x85\xad\x84\xce\x46\x7b\xbc\x50\x37\x87\xcb\xe8\xcd\x0f\xf7\x1c\xfc\xd8\xf7\x5e\x59\x5a\xae\x1b\xd0\xe3\x1e\x85\xaf\x7a\x92\xf0\x55\xb9\x0c\xb3\x79\x95\x08\xd7\xa1\xfd\xc2\x93\x8c\xf6\x73\xd8\x40\x90\xfc\x52\x6c\x51\x4b\x9a\x22\x92\x0c\xf4\x83\x0d\xfc\x37\x57\x3d\xfc\x37\x3f\x4d\x9c\xf8\xd2\xc4\x89\x6c\xad\xee\x48\xe0\x7b\x95\xad\x41\xca\x0a\xd3\x30\xe3\xa8\x2c\x41\x57\xa3\xb6\x6b\xd6\x5c\x5d\xb3\x86\x2e\x48\x8a\x28\xc1\xf8\xc7\x09\xa4\x4d\x87\xd8\x38\x2b\x6a\x33\xb6\x72\x51\xee\xe8\x51\xaa\xb4\xc0\x13\xa8\xd2\x02\xf0\x63\xc2\x2c\xb8\x45\xd2\x20\x0f\x4a\x8d\x18\xed\x9c\x49\x9b\xa1\x2d\xd4\xf2\x5a\xad\x45\x4c\xa1\x3c\x44\x88\x12\x63\x52\x51\x4e\xc3\x50\xd3\x69\xe1\x8c\x8f\x36\x0d\x4e\x9c\x5b\xe5\x77\x24\xc6\xbb\xec\xc6\xf6\x35\xed\xb2\xe4\xf8\x88\x77\x2b\x1e\xd6\x6d\x84\xe8\x33\xb3\x41\x0f\x8e\x0f\x8f\x35\xb3\x61\xcf\x9f\x57\x4a\xc6\xef\x5b\xe1\x47\x48\x21\xb2\x23\x4f\x6a\xf6\xd2\x39\x9e\xa2\xb1\x70\x9c\xc5\xe2\xd4\x0b\x42\x3a\x55\x9d\xd3\xba\x43\x85\xcc\xd0\x81\x08\x3f\x0e\xf9\x9a\xe8\xa6\x22\x6f\xba\xad\x09\x65\x46\x3a\x96\x3a\x33\x33\x54\x63\xd4\xbe\x2e\xa5\xde\xce\x1d\xc3\x0e\x5f\x9a\x7a\x94\xe8\xbb\xe1\xf7\x35\xd2\xdd\x0f\x3e\x78\x29\xcd\x9b\x96\x5b\x3c\xb4\x7f\x61\x9a\x37\xb5\x75\xde\x8d\x03\x8a\x0e\x3f\xf8\x20\xa5\xef\xdb\x08\x0e\x8d\x92\x3e\x27\xf8\x1d\x42\x6d\x23\xde\xc2\x0c\x53\x6e\x46\x6e\x61\x2e\x9f\x9b\xeb\x76\x88\x09\xc5\x80\xc1\xaa\x31\xd1\x79\x93\xef\x73\x53\xe4\x27\x1d\xc2\x2e\xa1\x13\x16\x76\xbd\xde\x44\xe0\xff\xbf\x9c\x1e\xdd\xae\xfb\x46\x7c\xbf\xf9\xc4\xc1\x6f\x5e\x4b\x7f\x06\x18\xe3\xd1\xc0\xc5\xe8\x5c\x8a\xf3\xb9\xa2\x8a\x10\xd7\xdc\x32\x47\x28\x0c\xdc\xba\xef\xd7\xad\xfb\xfe\xe2\xc1\x05\x0b\x0e\x1e\x5e\xb0\x40\xa1\x7d\x7d\x19\x1f\x7d\x9a\xb0\xea\x84\x6b\x14\x39\x2e\xbe\x5f\x4d\x3b\xdc\x57\x46\x78\xe9\x72\x9a\x16\x0f\xbd\xb0\x6e\x1d\xb5\xd9\x75\xd5\x53\xff\xd0\x17\x19\xed\xa0\x73\xce\xc1\xe2\x01\x15\xa0\x30\xea\x88\xba\xa1\x3e\x68\x00\x8a\xa2\x51\x68\x02\xaa\x45\x73\xd1\x52\xb4\x1a\xdd\x8d\x1e\x40\x8f\xa0\x47\xd1\xe3\x50\x16\xd9\x2e\x6d\xd9\xd2\x57\xb5\x75\x6b\xdd\xac\x89\xb7\xdf\x7e\xdb\x8a\xee\x8f\x0d\xbc\xe7\x9e\x21\x9b\x4b\xd7\xac\x69\xb7\xae\xf5\xbc\x79\xc5\x8b\x9c\xa3\x47\xbb\xc7\x1a\x6f\xba\xc9\x3a\x22\xbd\x53\xa7\xac\x2e\x39\x79\x7c\xbf\x7e\x79\x5d\x46\x8c\x5d\xb4\x6e\xf3\x63\x2b\x66\xe9\xb6\xf7\xed\xf9\xe0\xce\x9d\x0f\xf5\xda\x0e\xba\xca\x4a\x2d\xea\xbb\x60\x49\xd5\x8e\x31\x77\xdd\x35\x7e\xc3\xcd\x1b\x37\x8e\xbc\x3f\xb2\x7c\x79\xd7\x55\xf9\x73\x5a\xcd\x98\xa1\x7f\x38\x73\xf2\xe4\xec\x69\xe6\x41\x83\xec\xc3\xa0\x97\xab\xbc\x3c\xad\x43\x51\xc9\x92\x1d\x1b\xee\x5f\x35\xe7\xe1\x69\xc3\x7a\x75\x28\x29\xe9\xd0\x6b\xd8\xb4\x87\xe7\xac\xba\x7f\xc3\x8e\x25\xfa\xde\xfd\xb7\xed\xdc\xb9\xb5\xdf\x76\x5e\xd5\xa3\x87\x5a\xe8\xcd\xd0\xdd\x12\x0a\xc5\xbf\xe2\x67\x0f\x13\x7f\x49\xe7\x4d\x9a\x5d\xae\xf1\xc0\x02\x89\x23\x18\x71\xfb\xf0\x26\x21\x4a\xaf\x7b\x89\x7f\x15\x37\x9a\x55\xd3\xe9\x2a\x52\x56\x81\x4c\x72\xbf\xdd\x97\x15\x2e\x09\x15\xe7\xc6\xbf\x6d\xf1\x6f\x39\xfe\x0d\xf1\x6f\x55\xb3\x7b\x6a\x70\x40\x08\x11\x13\xa5\xe0\xff\x48\xdb\xfc\xde\xdf\xac\xae\x44\xdd\x7e\xaa\xc4\xf0\x52\xd8\x2c\xd4\x8c\xe1\xe2\x94\x73\xd0\xaf\xfe\x25\x7a\x4a\x91\xbb\x61\xca\x14\x4c\x44\xf3\xf2\x92\x4d\x25\x6d\xdb\x96\xfc\x55\x56\x5a\x1e\xce\xa6\xb7\x98\x30\xde\x65\xa5\xcf\x94\x87\xc3\xe5\xdc\x90\xb2\xd2\xd2\xb2\xab\xcb\xcf\x4d\x81\x7e\xc2\x4a\x7c\xe0\xdc\x94\xab\x9a\x52\xf2\xc7\xad\xa1\xd7\xcd\xe1\xf2\xf2\x70\xfd\x13\xe1\xf2\xd2\x32\x1f\xbd\x87\x7f\xd2\x8c\x38\x4a\xf3\xfc\x45\xb3\x6f\xa6\x4f\xf1\x86\x29\x53\xf8\x6c\x5a\x63\xfd\x8b\xf8\xc0\x94\x73\xc2\xb2\xcf\xa7\x4c\x99\x72\x75\x3a\xf4\xbf\x97\xa4\xcb\x27\x1f\xfc\x0e\x29\xe7\x5b\xf2\x03\x36\x93\x1f\x37\x91\x1f\xf5\x75\xb4\xf2\x2b\x9f\x43\xaf\xbf\x4b\xa6\x7c\xce\x7d\x54\x1a\x6a\x57\xdf\x29\x1c\x2e\x7b\xb0\xa4\xa4\x2d\x97\x19\x4f\x5d\x1f\x2b\x2b\x0b\x7f\x47\x12\xe2\x77\xcb\x4b\xda\xe6\x91\xd7\xa4\xcc\xab\xd3\xa7\x4c\x81\x5e\x9f\x93\x39\x33\x55\x98\x84\x36\x48\x44\xda\x26\x74\x35\xbe\x9d\x41\x48\x80\xc8\x76\x21\x36\x28\x9b\x10\x62\x5a\x62\x1b\x83\xca\xc4\xc2\x6c\x54\xc7\x6c\x0a\x95\x95\xfc\x7a\x32\x71\x92\x01\x21\xe3\x3d\x5f\x15\x3e\x80\xce\x84\x36\x51\x5d\x8e\xfd\x59\xb5\xc9\x04\x3a\xc5\x16\x84\x6d\x62\x27\xb4\x39\x94\xe7\x56\x64\x34\xc2\xfb\xac\x81\x94\xf5\xeb\x9f\x54\x6f\x1c\xd9\xa7\xf7\xe8\x7b\xb9\x67\x84\x0f\xce\x9e\xe5\x54\x0f\xad\xea\x5e\x35\xa0\xdb\xed\x8f\x32\x5e\x07\x0f\x44\xef\xc6\x2e\x13\x5e\x87\xc8\x1d\x6a\x22\x2b\x81\x4e\x14\x35\x2a\x45\x56\x3c\x43\x8d\xbd\xaf\xcf\xfd\xe0\x3d\xc9\xdc\x0f\xe9\x07\x42\x3b\x36\xb0\xfd\x99\xa4\x7e\x50\x29\xbb\x39\x77\x37\xdb\xcd\x41\xcd\xd2\xc7\xb7\x71\xc8\x0a\xdb\xa4\xdf\xfe\xdb\x98\x9e\xc3\x5f\x92\xd5\xec\x21\x96\xde\x40\xa1\xd5\x80\x5e\x4b\x04\xa5\x78\x4e\xba\x15\x59\x6c\x3e\xd9\xa6\xc8\xa1\x14\x50\xa6\x6c\x44\x29\xc5\x5c\xdc\xb7\xa8\xaa\xff\x92\x7d\xf1\xd2\x66\x35\x6c\x4a\x41\x6c\x1d\x19\x8b\xe9\x89\xb1\xd0\xb7\xe4\x77\xeb\xae\x61\x15\x4a\x79\xa6\x2b\xc2\xfd\xb0\x47\xec\x4b\xfa\x4d\xbd\x4f\x13\xd7\xe3\x26\x49\xc9\xb0\xa7\x24\x27\xa7\x84\x7e\x84\xdf\x94\xef\x12\xa5\xcd\x37\x90\x36\x1f\x8d\xbd\x86\x8c\x28\x10\xb1\x1a\x24\x23\xd2\x83\x4e\x4f\xfe\x69\x54\x22\xaf\xd1\x18\x15\xad\x45\x31\x3b\x48\x4b\x27\xbc\x99\x31\x1d\x71\xe3\x00\x36\x06\xb9\xa1\xfc\x5a\xef\x9c\xe8\xb0\xee\x3d\xa3\xc3\xe7\x78\xeb\xd4\xe3\x8e\x15\xd7\x78\xc6\xb6\x9b\x3b\xb7\xfd\xad\x9e\x9a\xe2\xe5\x94\x0f\xda\x4d\xfa\x69\x00\x91\xe3\x6d\x28\x03\x05\x91\x37\x62\x14\x79\x93\xcf\x13\x08\xa8\x78\xd9\xe7\xb3\x18\x12\x63\x5b\x4c\x8b\x37\x9f\x49\x08\xd6\x0d\xc0\xcb\xcd\xc5\x7c\x7f\xd2\x6f\x18\x30\x65\xe0\xcd\x65\x65\x37\x53\xb9\xbf\xba\xb4\xb4\x3a\x49\xf6\xc7\x9f\x26\x69\x01\xba\x74\xa1\x7a\x80\x2e\x5d\x1a\x34\x01\xc1\x84\x46\x00\x62\x6d\x84\x25\xe8\xac\x34\x96\x69\x26\xe8\xa6\x27\xa7\x6c\x11\x10\x44\xe3\x7d\x65\x5e\x5b\x48\x75\xb6\xa6\xb6\x03\xbe\x4c\x2e\xe2\x13\xf8\xa3\x97\x20\xf0\x92\xd2\x77\x37\xe2\xa1\xe2\x0a\x22\x63\x30\x9d\x77\x62\x13\x8b\x80\x2f\x09\xde\xcc\xec\xdc\x10\x3d\xf6\x94\x5d\x26\xae\x18\x8d\xa7\xe0\xcf\xf1\xa7\x78\xca\xa8\x67\xc7\x80\xf6\x8f\x9f\x20\xaf\x5f\xfe\xb1\xa3\xc7\x5f\x5a\x34\x79\xa6\xc2\xa3\xdf\x28\x9c\x10\x57\x48\x9d\x59\x39\x04\xf7\x1a\x64\x95\xff\xbb\x1c\xa9\x73\x63\x41\xb4\x9c\xc3\x42\xaa\x38\x2c\x59\x97\x4f\xe3\x4a\x3f\x2d\xbc\x7e\xa5\x5c\x1c\xf6\x58\x1c\xe6\x17\x85\xd4\xd8\x88\x06\xbd\x30\x49\xa3\x4a\xa4\x79\xec\x31\xd4\x00\xcf\x1d\x92\x48\x56\x4f\x82\xd5\xc8\x24\xe8\x4c\xe4\x9f\x4d\x9d\xd8\xdc\x8a\x6f\xa8\xf9\xb3\x1b\xe4\x19\x51\x88\x4b\xbd\x82\x63\x1e\xfe\x18\x7f\x34\xef\xa6\x9b\xcd\xcf\x5a\xce\xdc\x33\x0f\x02\xd0\x6a\x5e\xb4\x9a\xde\x08\x6f\x75\xed\xda\xa3\xcf\xaa\x3d\xca\xb5\x45\xbb\x79\x6d\xc3\x9e\x01\xe4\x90\x92\x05\xc2\x5a\x67\x7b\x33\x05\x59\x38\x5b\x85\x3f\xba\xf8\x1b\xfe\xcf\xad\xcf\x8e\x82\x8d\xe0\x87\x6c\xb8\x77\xb4\x70\x62\xf6\xf4\x49\x8b\x5f\x3a\x7e\xec\xa8\xd2\xa6\xd1\xfc\x3b\x8c\x47\x90\xf6\x22\xa6\x5f\xf4\x86\x65\x55\xd8\xfb\x34\x7f\x69\xdd\xba\xab\xe6\xbd\x0b\x0e\x1f\x5c\x40\xf5\xe4\xeb\xe0\x33\x98\x41\xcf\x53\x88\xb7\xe0\x79\x8a\x9d\x04\xde\x47\x9e\x0d\x64\xcf\x26\xd0\x1d\x76\xc6\xcb\x6e\x83\x8b\xa8\x86\x9d\xf3\x50\x21\xe7\x51\x24\x2a\x07\x2b\x10\x3b\xe0\x41\xed\x57\x2a\x14\x76\x8f\x27\x3d\x31\xf2\xd8\xb1\x63\xf4\xf4\xc6\xd5\x85\xdc\xdf\xf5\x12\x29\x6f\x7d\x43\x1d\x75\x78\x44\x43\x1d\x9f\x93\x3a\xce\x93\x67\x73\xf0\xea\xf8\xb3\x67\x48\xba\xc1\x2c\xdd\x8b\x78\x61\xfc\xd9\x63\x24\xdd\x48\x7a\x26\x46\x1c\x8f\x6b\x15\x3d\x3e\x3e\x00\x17\xa1\x3f\x41\x2d\x3b\xf2\x1d\x42\x76\xbb\x99\xb7\x1c\x05\x1f\x52\x23\x73\x93\x73\x30\xca\x79\x6f\xa6\xfe\x6c\x76\xee\x25\x64\x51\xdd\xdd\x78\xd8\xe5\x98\x28\xf4\x1d\x96\x7c\xc8\x45\x70\xe2\x6f\xee\xa3\xba\x85\x5f\xe1\x22\x67\x67\xf0\x4c\xab\x3f\x16\xdf\x43\x68\x4d\xfa\xe1\x33\xe1\x77\x32\x6f\xd3\x0f\xa8\x24\x89\xa7\x27\x4c\x10\xe4\xed\x37\x98\xb4\x47\x58\xc5\x21\x1a\x10\x82\x56\x6b\x29\x21\x68\x1a\xf7\x0c\x1f\x3f\xd1\x7a\x46\x3c\xac\xa1\x67\x4a\xb2\x65\x7a\xa6\x84\x94\xde\x63\x65\x41\xcf\xe1\xf1\x23\x25\x78\x0d\xd5\x13\xe6\xc1\x17\xe8\x63\xf1\x3e\x52\xe7\xec\x98\x37\xde\x07\xcb\x49\x7b\x17\xb1\xbe\x9a\x8f\xef\x8a\xf7\xc1\x2a\xf2\x6c\x9e\x70\x9e\xb4\x37\xf5\x10\xa8\x54\xbc\x5a\x54\xce\xdb\xf0\x49\xc7\x3a\xc8\x64\xd5\x81\x4f\x03\xd4\x52\x40\x03\x4f\x3d\xf5\xf4\x9b\x60\x88\xa1\xb7\x1e\x79\xf8\x6c\x0c\x81\x89\x14\x60\xc7\x3f\x91\xd5\x67\xda\x5f\x7f\xe1\x7b\xf0\x0c\x85\x66\x7e\x22\xec\xe7\x06\x32\x5e\x91\xda\xf8\x35\xdd\x13\x67\x26\xae\xaa\x4f\x66\x03\x77\xbe\x51\xdc\x24\x79\x6e\xc2\x93\xe1\x3d\xa6\x1f\xa7\x79\x24\x55\x72\x1e\xd1\x41\x10\xaf\x0c\xde\x9b\x8d\xf1\xf9\x79\xa9\x24\x4b\x2c\x86\xce\x12\xda\x77\x26\xb6\xd4\xac\xe2\x55\xcc\x4a\x95\xda\xe6\xc4\x63\x68\x5a\x25\xce\x89\xe2\x3e\xc6\x99\xaf\x1a\x17\x4a\x43\x83\x22\x81\xb4\x94\x14\x07\xaf\xd5\x68\xec\x0e\x13\xef\xe0\xd3\x3d\x5a\xad\x64\xb7\x4b\x6e\xb7\x94\x92\x82\x24\xc9\x50\x19\x95\xcc\xd4\xed\xe3\x35\x02\x6c\xb6\x0c\x36\xa4\x1c\x6f\x11\xb3\x1a\xe2\x21\xb1\x23\xb4\xe6\xb8\x5f\x21\xde\xe2\xb5\x70\x03\x2f\xe3\x3f\x92\x8f\xcb\x7e\x91\xf0\x2c\xf4\x07\x70\x76\xe6\xdc\xa5\xf1\x78\x2c\x5e\x13\xf7\x2c\xb4\x1f\xcc\xf8\x12\x85\xbd\x31\x1e\x68\x02\x76\xa7\xd0\x10\x16\x94\x46\x45\xb2\x89\xa2\xcd\xed\xb6\x11\xd8\xff\x77\x70\xd0\xeb\xc3\x7e\x9d\x38\xa1\x74\x53\xfd\xfa\xb1\x42\xf1\x2c\x02\xfd\x75\xe2\x85\x26\xa0\xa7\x63\xf1\x2a\x7e\x15\x2e\x08\x5a\xb3\x84\xd2\xd9\xf8\x3e\x47\xe4\xad\x18\x93\xd9\x73\x23\x6e\x32\xbe\x22\x77\xd7\x70\x93\x08\x26\xb1\x50\xac\x10\x6b\xc4\xc5\xe2\x56\xf1\x57\x51\x25\x52\xeb\x3f\x66\xce\x19\xc7\x14\xfe\x39\x2a\xba\x27\x84\x76\x42\x39\x6e\x13\x76\xf2\xbd\xa5\xc1\x71\x39\xe4\xc6\x88\x5d\x23\x09\x40\xd8\x03\x22\x18\x1b\x4d\x3a\x95\xa4\x5a\x3b\x5c\x2b\x51\xe3\xc7\xb4\x14\x5f\x4f\x49\xfc\x5f\xd5\x20\x7a\xaa\xbc\xb8\x89\x1b\x02\xe5\x04\x84\x2d\xd4\xa8\x3a\x80\x09\xed\x7f\x3e\x84\xef\x79\x1d\xfa\xbe\x2e\xec\xf4\xc2\x3a\x3f\x9e\x15\xf8\x17\xf9\xa3\x6d\xcc\x46\x48\xbc\x5b\xbc\xdd\x9c\x43\x7f\x59\x54\x7c\xdb\xd8\xa4\xd8\x16\xc0\x07\x39\x2b\xcf\xd9\x8e\xc4\xc2\x91\x98\x8d\x8c\x92\x5f\x2d\xc3\xfb\xe4\x73\xbf\x0c\xe4\xfa\xa8\x4a\xce\x25\xeb\xfc\x50\xf9\x71\xf9\x59\x59\x52\xc9\x32\xb9\x9d\x2d\xdf\x27\x9f\x92\x3f\x92\x2f\xc8\x7f\xca\x9a\x7f\xf6\x20\x2f\xef\x63\xaf\x4f\xd1\x04\xca\x6b\xfa\x92\xa5\x2e\x93\xc7\x91\x5b\xfa\x4e\xf5\xa0\x2c\x43\x99\x0c\x4a\x92\x95\x24\x89\x58\x9e\x2b\xf7\x20\xbf\x1f\xa7\xbf\x69\xd2\x1e\x24\xb1\x52\xf8\x9f\xb2\x5a\xc5\x6e\x57\xc6\x73\x5f\x90\xd5\x6a\x49\xfe\x4e\xe6\xde\xcd\x91\x2f\xcb\x5c\x77\xf9\xb0\xcc\x49\xb2\x53\xe6\xb6\x0c\x91\x37\xcb\x3b\xc9\xed\x77\xb2\x98\x43\x7e\x90\xa7\x43\xc8\x1d\x7f\x9b\x53\x1e\x2b\xcf\x92\x79\xa7\x5c\x4a\x7e\x6c\x26\x8f\x4e\xca\x92\x24\xe7\x90\xdb\x21\xf2\x0a\x72\xfb\x21\xc9\xa1\x6e\xdb\x9d\xdc\xcd\x22\xd9\x3e\x94\xc5\xee\x72\xe4\x69\x5a\xd4\x65\x59\x90\x48\x16\x4e\x23\xca\x0e\xf9\x56\x99\x5f\x77\xab\x7c\x87\xbc\x49\x3e\x24\x7f\x2b\x8b\x0e\xb9\x1b\xf9\xf9\x1f\x59\xa0\xef\xc2\xe4\x2d\x7d\xfe\x1a\x79\xa3\x1e\xde\x4d\x1e\x2c\xcf\x94\xff\x21\x7f\x40\x5e\x4b\x34\xd5\x3f\x94\x74\x34\x1f\x1f\x10\xe4\x6c\x79\x90\xbc\x43\x3e\x28\x8b\x82\x5c\x22\x77\x95\x67\x90\x9b\x13\xf2\x1f\xb2\x6a\xbe\x9d\xbc\xa2\xf7\x27\xe4\xf7\x65\xa9\xab\xbc\x91\x3d\x16\x04\x79\xb9\x7c\x5e\xe6\x7b\xdd\x2b\x7f\x23\xff\x2e\xf3\x37\xc8\xf7\xca\xdb\xa9\xbb\x16\x76\x77\x0b\x27\xc3\x1c\x1a\xfa\x40\x31\x71\x66\x9f\xc6\x9f\x49\x0f\xaf\xfd\x44\xf9\x0a\x5a\xc2\xa8\x22\x4c\xf0\xe2\x35\xce\x06\xdf\xf2\x5d\xad\x12\x9a\x5b\x4e\xf1\xa4\x35\x42\xd2\x32\x82\x27\xb9\xa8\x15\x2c\x8c\x63\xca\xcc\xd8\x16\x94\x73\x10\x8c\x3c\x98\x8e\xc4\x6e\x8b\x58\x09\x93\x0f\x7e\x66\x0a\x5b\x89\xd6\x23\x61\x1b\x82\xea\xea\xb0\x52\x22\x8a\xe3\x9a\x74\x88\x95\x11\xa4\xe7\x3a\x13\xd8\x86\xb2\x13\x65\x4c\x88\x58\x4c\x26\x41\x48\x94\xb1\x07\x9d\x45\x62\xa2\x04\x25\x3f\xdf\x99\xe5\xcf\x87\xbb\x93\xf2\xb7\x3e\x48\x66\x0e\xa8\x8e\xc4\xaa\x22\x6e\x15\x61\x15\xfc\x24\xf7\x62\x02\xc1\x59\xf4\x25\xfa\x95\xac\xfc\x28\x82\x2e\x21\xbe\x09\x2c\xb1\xef\x62\x3f\x49\x37\x28\x7e\xcf\x46\x2a\x25\x15\x90\x92\x7a\x44\x5c\x5c\x2a\xcf\xa5\x08\x29\xf6\x94\xec\x94\x92\x94\xae\x29\x83\x52\xc6\xa4\xcc\x48\x59\x9e\xa2\x39\x12\x2b\x8e\xb8\x53\x52\x54\x2a\x3f\xa0\xa9\x08\x38\x13\x03\xb1\x06\x09\x64\x0d\x19\x49\x5b\x5a\x5b\x53\x1b\x0e\x07\xab\xe3\x55\xd0\xf6\x2e\x41\x48\xd5\x8b\xc1\xdb\x81\xb3\x13\x78\x25\xbe\xed\xa9\x2d\xa8\xfc\x59\xd0\xf1\xa0\x27\xcc\xf4\x91\xd8\xfa\x48\xa6\x5e\x4f\x1b\xac\x94\x46\x81\x3e\x46\xc0\x8e\x21\xb5\x19\x55\xa1\x0d\xe8\x6d\x24\x50\xb0\xab\x1b\xe1\x7e\x9b\xf4\xe1\x28\x0a\x37\x3f\xbc\xb7\x02\xb7\x4c\xe0\x2e\x8b\x18\x21\x87\x87\x6c\x73\x76\x66\x76\x51\x76\x24\x5b\x38\x12\x93\x23\x72\x76\xb6\xd7\xeb\x27\x45\x7e\x89\x08\xb4\x95\x88\x9b\x46\x20\x7a\x9b\x76\x44\x6d\x13\x38\x63\x4f\x10\x62\x7d\x87\x34\xd8\x9a\xc3\x4f\x62\xbd\xda\x2e\xd6\x9e\xbc\xb0\x1d\xe0\x39\x30\x1f\x89\x7d\x72\xd0\xec\xe4\x35\x7e\xd2\x77\xe1\x78\xbb\x42\x8c\x66\xd0\x33\x7a\xd9\xec\x9e\xf0\x2d\xe2\x44\x76\xef\x67\x74\x72\x35\x02\x81\x9e\x8d\x13\x91\x27\x62\xe4\x05\x24\xa8\x24\x91\xab\x89\x8a\x3c\x4f\xe3\xd6\x07\x1b\x8d\x73\x1c\xf4\x78\xb3\xf0\x4c\x3d\x87\x3f\x11\x97\x9e\xbf\x32\x46\x5c\xc2\xd6\xbc\x1b\x49\x79\x93\x59\x7e\x23\x2a\x89\xb8\x25\x0e\x90\xd6\x28\x8a\x5a\x8e\x37\x9b\x34\xcc\x53\xa8\x34\x32\xca\xd3\xe8\x21\x15\x8a\x73\x16\x6b\xdb\xa6\xc7\xf2\x41\x24\x45\x97\xf9\x21\x27\xd7\xc8\xf3\x5c\x19\x44\xe1\xf3\xbf\x2f\x00\x7f\x11\x5f\x6e\xeb\x06\x5d\x76\xbb\x4b\xe2\x52\xb8\x32\xfa\xeb\xaf\xad\xdc\xf3\x0f\xdd\x2c\xf9\x6f\xdb\x5a\xbf\x32\xd1\x0e\x89\xb5\xa3\x15\x6b\x57\x47\x84\x84\x5d\xec\xbe\x63\x43\x3b\x3b\xb2\x7b\x6a\x5c\xc1\x27\x7c\xe7\xb1\x33\xbf\x69\xa8\x36\xd2\x83\xe3\x75\x16\x41\xd6\x09\xba\x74\x0f\xe2\x6b\xa2\x19\xd4\x32\x9c\x8e\xe9\x1e\x32\xa2\xa2\x4c\xd8\x01\xb7\xd1\x68\xaf\x89\x1a\x05\xb5\xbb\x26\xaa\xb6\x6d\x4b\x87\x25\xe9\x30\x2d\x1d\x46\xa6\x43\x24\x1d\x8a\xd2\xe1\x52\x3a\x64\xa6\x53\x5c\x62\x7f\xcd\x5d\xe5\xd5\x26\x3b\x65\x6d\xab\x18\xe3\xf8\xed\x9c\xa0\xf8\x6a\xf3\x66\x22\x28\xe1\x7c\x59\x9c\xc3\x6e\xa5\x41\xbe\x2f\x73\x7d\xea\x0f\xf1\x3f\x3f\x83\x5f\xfc\x18\x1f\xc4\x2b\x61\x0e\x54\x92\x7f\x73\xf1\x7b\x1f\xbf\x7a\xf2\xe3\x2f\x8e\x9d\xfc\x88\x6f\x7f\x7e\xda\xe7\x78\xff\x3e\x58\x09\x83\xe0\x46\x58\x80\x97\xe0\x7d\xe7\x81\xc7\xb1\xef\xbe\xc7\xff\x61\x7a\x6a\xa5\xcd\xb0\x97\xb5\x39\xbf\xa1\x0f\x0e\xb2\x7b\xb6\x37\x44\x46\x08\xc4\x9e\xe2\xed\x48\x8b\xca\x23\x19\x5a\x8d\xa0\x52\x53\xff\xba\x02\xaf\xd7\x09\x1a\x5e\x8d\xac\xc7\xf5\xb0\x55\x0f\x23\xf5\x50\xa8\x07\xea\x42\x10\x55\x14\x57\xb4\x6d\x71\x9a\x8d\x3a\xd5\xa5\xde\x75\xc5\x9e\xf8\x2c\xfe\x32\xe8\x71\xb7\x21\x02\xf4\x69\x4e\x03\x41\xe0\x67\x6e\x9a\x39\x66\xf7\x55\x6a\x13\x11\xaf\x5f\xf2\xb2\xfa\x8b\x9a\x8d\x49\x1b\x65\x4c\xc8\x98\xbd\x47\xd2\x52\xfe\x5c\x87\xda\x47\xd2\x09\xb7\x24\x11\x94\x11\xf5\x06\x9d\xb6\x26\xaa\xd3\xa9\xc8\xc2\x5d\x13\x95\xac\x74\x80\x28\x06\x35\x0d\x1d\xa9\xc4\x58\x69\xdb\xb6\x58\x39\x0d\x46\xd0\x28\x4c\x3f\xb3\x85\xb6\x57\x4e\x09\x37\x5f\x59\xca\x9f\xbf\xfa\x2c\x41\xd5\xab\x3d\xce\x9f\xe7\x86\x9e\x3f\xaf\xf4\x51\x1c\x0f\x08\x0c\xc5\x71\xfc\x67\x30\x11\x08\x7c\x11\x0b\x52\xf1\x82\x4a\xd0\xa8\x45\x6e\x24\x99\x01\x02\xb2\xd2\x1e\x48\x3e\xed\x91\xf0\x65\x27\x64\xd6\xaf\xc7\x9f\x0a\x07\x85\xb5\x57\xa6\x8b\x4b\xff\x5e\xdc\xd0\xff\xa2\x99\xb5\x2f\xa4\xf0\x98\xa4\x7d\xeb\x49\xd9\x7a\x42\xab\x7c\x2a\x9e\xd7\xaa\x39\x4e\x02\x1d\xe8\x0c\x46\x5e\x25\x90\x96\x69\xc8\x03\xad\xc0\x83\x16\x91\xe6\xd2\xda\x14\x6f\x10\x2c\xea\x54\xa3\x6b\x68\x76\x06\x4f\x31\x8f\x0a\x85\x35\x74\x6f\x86\xb4\x95\xe0\xd3\x4d\x70\x1c\x0f\xe0\x2f\xd4\xf7\x80\xe9\x78\x16\x6f\xb8\x08\x57\xe0\xc0\x0f\xe7\xf1\x9d\x2b\x70\x97\xf3\x0c\x1e\xea\xb7\xf7\x0c\x83\xa7\x8c\xdd\xfb\x08\x7c\x61\x76\xdf\x81\xf5\x7f\x45\xec\x3f\xd2\x8d\xe2\x9d\x04\x07\x32\x51\x00\x7e\x89\xc4\x9c\x62\xa6\xcd\x9f\xa9\x41\x6e\xaf\xc9\xa4\x71\xf3\xc1\x3c\x21\xc7\x96\x53\x13\x75\xda\x22\x76\x41\xf4\x6b\xfd\x64\x9a\x68\x35\xb6\xfb\x82\x50\x17\x84\xd1\x41\xb8\x31\x08\x5d\x83\x10\x0e\x42\x4e\x10\x9c\x41\x10\x83\xf0\x7b\x10\xce\x07\xe1\x83\x20\x9c\x0c\xc2\xe1\x20\x3c\x1e\x84\xcd\x41\x58\x1e\x84\x99\x41\x18\x1b\x84\x21\x41\xe8\x11\x84\xd2\x20\xe4\x06\xc1\x41\xb0\x25\x08\xe3\xfe\x08\xc2\xb7\x41\xf8\x30\x08\xaf\xb1\x0c\xdb\x83\x80\x36\x04\xe1\xf6\x20\xcc\x60\x39\x06\xb2\x1a\x8a\x82\x90\x15\x04\x7b\x10\xa4\x20\x5c\x66\x35\x90\x0c\x07\x83\xb0\x33\x08\xf7\xb0\xe2\x09\x38\x63\x58\xf1\x91\x20\x14\x07\x21\x9b\x81\x23\xb0\xc4\xdf\x05\xe1\xdd\x20\x9c\x60\xa5\xef\x08\xc2\xc6\x20\xac\x48\x24\x2e\x49\x2a\xb6\xec\xb7\x20\x7c\x1d\xb9\x39\x08\xef\x07\xe1\x95\x20\xc0\x5e\x96\x7a\x1a\x4b\x5a\xc5\x80\x48\x65\x25\x9e\x67\x29\x0e\xb2\x5a\x09\x88\x83\x82\xd0\x3e\x08\x99\xac\x14\xd2\x94\xcf\x58\x4d\xa4\x8e\xf9\x41\x98\x14\x84\xe1\xac\x0e\x73\x10\x38\xb2\x88\xaa\x68\x7c\xa0\xc4\x5f\x6d\xe2\xaf\x2e\xfe\x57\x43\x2f\x23\xaa\x9b\xfc\xd5\x36\xfd\xab\xab\x6b\x92\xb8\x45\xf2\xa4\x0c\xa8\xe2\x4c\xb1\x82\x4a\x6e\xf2\x03\x99\x5d\x27\xae\x11\x1d\x87\xfa\x02\xa3\x3e\x3a\x21\xec\xcb\xca\xce\x09\x97\x20\x6f\x88\xa0\x56\x28\x13\x39\xec\x12\x69\xa9\x03\xec\xce\xf6\x60\x21\xac\xba\x98\xb7\xe5\x1f\x36\xf7\xfd\x3b\xea\x37\x96\x1e\xc0\x97\xef\x82\x52\xc8\xc8\x03\x67\x1e\xa4\x43\xd9\x5d\xf8\xf2\x81\xd2\xfa\x8d\xdb\x1f\x70\xdb\xfe\xb1\x85\xfb\xf4\xfe\x27\xeb\x6b\x77\xd7\xbf\x78\x6a\xf5\x5f\xdb\xae\x80\x7d\xcb\x16\xfc\xd3\x95\x47\xff\xbb\xfa\x14\xf7\xed\xb6\xa7\xb9\xf5\x4f\x32\x1c\xb4\x12\x1c\x54\xce\x8c\xb7\x67\x73\x64\x24\xa1\x11\x29\x64\x8e\xa4\xc2\xee\x48\xcc\x02\x60\xe4\x1c\x2e\xad\x4a\xc5\xb9\x78\x4f\x9a\xc5\xc8\x1b\xe9\xc4\xe7\xc1\x69\x52\xf3\x60\x5d\xe5\x81\xe9\x1e\x92\xc5\x03\x03\x3d\xd0\xc5\x03\x25\x1e\xc8\xf1\x80\xe4\x81\xdf\x3c\xf0\xb5\x07\xde\xf7\xc0\x49\x0f\x3c\xe1\x81\xcd\x1e\xb8\xdd\x03\x33\x3c\x30\xd6\x03\x76\x0f\x70\x1e\x18\x47\x52\x9c\xf7\xc0\x87\x2c\xc5\x61\x0f\x3c\xe6\x81\x7b\x3c\xb0\xdc\x03\xb3\x3c\x30\xc4\x03\xdd\x3d\x50\xec\x81\x6c\x0f\x38\x3d\xf0\x9d\x07\xde\x60\x69\x76\x7a\x60\xa3\x07\x56\x24\x0a\x4a\xae\xef\x72\xa2\xb2\x9d\xac\xb2\xb9\x2c\xc1\x90\x44\x09\x24\x41\x19\xa9\x0f\xce\xb1\x54\xc7\x3d\x70\xd0\x03\x3b\x3c\x70\x27\x2b\xa9\xca\x03\x5d\x3d\x10\xf4\x40\x86\x07\x04\x06\xd4\x9b\x2c\xc1\x06\x02\x4e\xa4\xb5\x07\xc6\x78\x60\x90\x07\xda\xb3\xb2\x10\x81\xfd\x92\x07\xbe\x64\x6f\x17\x7b\x60\x24\xcb\x5e\xe4\x01\x33\x7b\xa7\x6a\x44\x80\x9a\x6b\xa1\x09\x45\x94\x11\xd7\xc1\xa7\xba\x26\x7f\x2d\x53\xd5\x50\x24\x8a\x47\xc4\x6b\x26\xb1\x84\x12\x8e\x3d\xc9\x52\x46\x03\xb6\x30\x34\xf1\x5a\xe2\x6e\x45\xc8\xda\xc6\xbf\x8e\x7f\x68\x85\xbf\xc7\xbf\x82\xbc\x76\x87\x06\x64\xcd\xf6\x75\x20\xe3\x4b\xf8\x02\x3c\x85\x07\xc3\x53\x00\x44\x14\x3d\x8b\x0b\x1e\x59\xcd\xfd\x55\xaf\x5a\xb5\x05\xde\xc3\x6d\x88\x34\x17\x53\xe4\x72\xc2\x4f\x48\x32\x59\xa7\x7d\xd4\x6b\x4c\x7a\x8a\xa4\x4b\xd1\x39\x4c\x0e\x42\x90\xb4\xbc\x97\xcf\xf6\xeb\xf5\x2e\x75\xaa\x3b\xb5\x26\xea\xd2\xb9\xad\xc8\x4a\xb0\x43\x88\x7b\x8d\x89\x07\xca\x08\x25\x45\x4d\x6c\x70\x96\x43\xe0\x65\x91\xab\x54\xa5\x21\x42\x3c\x69\x28\xcb\x84\xe6\x51\xa6\x46\x69\xc5\x72\x0e\x17\x36\x23\x3e\x0c\x7d\x61\xde\xfb\x1f\xd6\x45\xc0\x5e\x3f\xea\xd0\x63\x1f\x9f\x78\xf5\xd3\xed\x87\xea\x6f\x05\xeb\x0d\xb7\x7d\x7c\x16\xe6\x89\x9b\xf1\x51\xfc\xfd\x87\xf8\xfd\x51\xba\xf3\x10\x1e\x72\x61\xe3\x9b\x5f\x7c\x7e\x7a\xe3\x85\x21\xf8\xcd\xf3\xba\xd1\x50\xf0\x01\xa4\x40\x84\xf1\x68\x1f\x11\xc6\x68\xb4\xf4\x81\x35\x87\xae\xc3\x16\x49\x03\xaf\x13\x6e\x22\x62\xe2\x40\x10\xc4\x1c\x0e\xd4\x48\x2d\x21\x8e\x31\x69\x88\x5d\x1a\x68\x33\xcb\xd3\x81\xf2\x75\x1a\x80\x81\xa4\x3f\x3c\x11\x0d\x07\x1a\x0d\xcd\x65\x38\x12\xbb\x72\xd0\xa0\x13\xd4\x49\x19\x49\x3e\xaa\x73\xf8\x50\x3c\x4f\xf8\xc1\x5b\x14\x2e\x1b\xa8\x1d\xaf\x3d\xa2\xe7\xfc\x96\x1c\xce\x2f\xfb\x5b\x49\x66\x9a\x03\x05\x95\x7a\xfa\xc5\x7e\xe2\x9f\x12\xcf\x13\x9e\x74\x9c\x92\x1e\xfd\x42\xa0\xe5\x22\x31\x08\x58\x72\x20\xd0\x3f\x90\xaf\xe5\xfd\x86\xa2\x97\x8a\xbe\x28\xe2\x3f\xd6\x17\xa5\x15\xe5\x17\xf5\x2d\x12\xce\x29\xbf\x3a\x90\xdf\x37\x17\x4d\x2e\x5a\x50\xf4\x70\xd1\xee\xa2\x17\x8b\x4e\x17\x7d\x5e\xf4\x53\xd1\xd5\x22\x53\x5a\xc3\xab\xbb\xc8\x8b\xc4\x63\x9d\x9e\xa4\x7b\x91\xdc\x5c\x2d\x12\xf7\xa2\x8c\xa2\x8a\xa2\x9a\x22\xde\x54\x94\x51\x54\x58\x54\x59\x34\xb5\x68\x7d\xd1\x9e\xa2\xb3\x45\xea\xc3\xca\x93\x0a\xf2\xac\x86\x3c\x5d\x4c\x9e\x6f\x2d\x3a\x46\xde\x7c\x59\xf4\x6b\x51\xac\xc8\x94\xd1\xe4\x15\xcd\x42\x1f\xeb\x4c\xac\x94\x63\x24\x55\xac\x48\x5a\xe1\x29\xea\x58\x54\x5d\xc4\x1b\x8a\x3c\x45\x05\x45\xfd\x8a\xa6\x14\xad\x2d\x7a\xba\x48\xb5\x4e\xb9\xef\x48\x9e\x54\x93\x67\x0b\x8b\x1e\x61\x0d\xfb\xb9\xa8\xbe\xc8\xe0\x49\x7a\x4c\x12\x47\xde\x2b\x3a\xc3\x5e\xe8\x0c\xac\x04\x25\x65\x7d\x91\x6a\x04\x50\xb0\x17\x5f\x03\xf0\x31\xd7\x06\x9c\x02\x64\xc8\x68\xf6\x78\x0f\x6b\x11\x05\xdc\x60\x8a\x97\xa2\xa4\x54\x95\x70\xeb\x8b\xc0\xd4\x50\xce\xe2\x78\x19\x9a\xb6\x2d\xcb\x56\xda\xae\x4f\x14\x90\x5c\xb2\xd2\x57\x86\x8a\x86\x12\x68\x4a\x95\x22\x2d\xd6\x8c\x68\xfa\xdd\xf4\x56\x91\x23\x83\x54\x66\x9b\x84\x87\x09\x63\x18\x2e\x4d\x88\xe3\xd2\x62\x05\x97\x20\x85\xe0\x46\xca\xf4\x94\x34\xbd\x9c\x8c\x4b\x94\xdf\xbc\xcc\xd2\x4f\x52\x24\xa6\x3f\x95\xd4\x5a\x92\x5a\xeb\xd0\x1a\x14\x49\x44\x29\x9b\xc6\x93\x18\xc4\xe4\x96\xd9\x8a\xdc\x42\x25\x2e\xe4\x3e\x4c\xe4\x16\xf2\x3f\xed\x48\xec\xf7\x83\x69\x59\x44\x28\x51\x44\x17\xfa\x51\xf4\x69\x1f\x32\x9d\x54\x36\xea\x1e\xf1\x99\xcc\x66\x9b\x4b\x6f\xcb\xc8\x48\x91\x9c\x0e\x87\x94\xe3\x77\x3a\x08\x9b\x92\x55\x19\xd5\x6b\xcc\x7c\x5a\x25\x59\x28\x58\x54\x38\xe6\xc3\x4f\xf1\x9d\x19\xe7\xdb\x8a\x13\x4e\xda\xe2\x0e\x91\x1a\x7c\x3c\x96\x96\x79\x25\x4e\x65\x95\xbd\x39\xb9\x90\x14\xee\x85\xbf\xb9\xd3\xee\x85\xef\xbf\xf3\xcd\xe7\xcb\x5e\x2a\xe2\x53\x8a\x41\x53\x3c\x49\x9f\x39\x1e\xff\xd6\xc6\x89\xe5\xc1\x23\xa3\x4b\xac\xce\x99\xc3\xc6\x0e\xfd\x79\xe5\x3c\xb0\x91\x39\x9f\x06\xee\x3b\xe6\x2d\x98\x3a\x1c\x1f\x9f\x8e\xdf\xfc\x73\xce\x4c\x68\x7d\xe2\xc9\x7f\x3e\xbe\xff\xc5\xfd\x4c\x3e\x5a\x87\x87\x0a\x8f\x88\xa7\x91\x03\x05\x50\x34\x52\x60\xcb\xb0\x64\x68\xd3\xd2\x90\xcf\x62\x41\x4e\x8d\x86\x30\x7e\xc1\x3c\x5b\x66\x46\x66\x46\x65\x34\x33\xd3\x98\x62\xcc\xa9\x8a\x1a\x91\x26\x95\x4f\x69\x0c\x97\xd8\x24\x58\xfa\x35\xa2\x57\x31\xa7\xd0\x6c\xa7\xc5\xe7\x6c\x08\xd7\xcc\xc2\xee\x37\x04\x61\xf2\x85\x1b\x48\x9e\xf0\xc8\xcf\x1f\x3f\x79\x87\x46\x8d\xbf\xfb\xeb\xcf\x0f\x2e\x7c\xb9\x79\x77\xbd\xae\x70\x55\xe7\xda\x79\x4f\x6f\x59\x5c\x5b\x3d\xa4\x76\x0c\x6c\x3a\xf5\xf5\x88\xe1\x53\xf1\x47\xe2\xee\x9f\x3f\x3f\xb4\xab\x7e\xa8\xe7\x2c\x7e\x3b\xbb\x70\xf9\xf4\xc5\xb7\x9f\x74\xd6\xdd\x52\x75\xf3\x9a\xfb\x19\x9d\x56\x13\x5c\x99\x24\xb4\x23\xd2\xd4\xc7\x91\x9d\x1a\xad\xd6\x60\xd4\x99\x45\x20\x44\xcc\xc8\x5b\x2d\x3a\xd1\x6c\x48\xd5\x20\x53\xa5\x15\x62\x56\xd0\x59\xdb\x5b\x39\x9d\xb5\x8f\x75\xb8\x75\x92\xf5\x05\xab\x38\x39\x48\x1e\xf4\xb1\xde\x69\x7d\xc8\xfa\x99\xf5\x8a\x55\xd5\x87\xfc\x78\x8a\xbc\xf8\xcc\xfa\xa3\x55\x52\xd2\xbd\x60\x15\xda\xd1\x34\xf3\xe3\xa9\xa4\x87\x94\x62\x86\x93\x84\x82\x5a\xb0\x0e\xb2\x72\x53\x4b\xac\x5d\xc9\x37\x4f\x6f\xce\x5b\xf9\x8e\x82\x75\x86\x95\xcb\x26\xcf\x66\x58\x97\x5b\xdf\xb7\x8a\x82\x35\xdb\xba\xd1\xba\x83\xbc\xfb\xc3\x2a\xa9\x8e\x5b\x81\xab\xa9\x6d\x98\x00\x49\xba\x94\xea\x5a\xca\xe4\x27\x9f\x9d\x55\x30\x86\x0a\x15\xb6\x74\x90\x3b\x01\x0d\xec\x21\xa9\xbc\xa5\x65\x6a\xc8\x7b\xdf\x98\xc3\x49\xb9\xd6\x37\x20\x17\xcf\xac\x4e\xc7\xff\xf2\x76\x15\xda\xd5\x2f\xc9\x7b\x2a\xd0\x7a\x6b\x29\x37\xff\xca\xd5\xdf\x7f\xfc\xe2\x43\x36\xee\x43\x08\xee\x2e\x67\xf1\xad\xd3\x69\x34\x5d\x43\x6a\xaa\x9b\xe7\x5d\xe9\x16\xc9\x85\x2c\x16\x57\x66\x86\x85\x77\xbb\x1d\x69\xa9\xfa\x34\x7d\x65\x34\x0d\x39\x34\x95\x51\x87\xb3\x59\x30\x86\x50\xf2\x68\x5b\x95\x53\x2e\x90\x88\xd5\x4e\xfd\xb6\xe6\xb2\x53\xb6\x14\xa3\x51\xd8\xec\xa7\x82\x01\x3f\x7a\xf8\xe4\xb5\x9b\x17\x4c\x5b\x70\xfb\xf2\x7b\xe1\x86\x65\xd3\x97\x5e\xde\x71\x15\xff\x00\xef\xe0\xd7\xf9\xc1\x70\xe1\xb6\x93\x93\x8b\x3f\x7a\xe4\xee\x6d\x0f\xf3\xaf\xa8\xf0\x67\xb3\xeb\x1f\xd8\xf8\xed\x22\xd0\xfc\x04\x8b\xb6\x41\xbb\x7b\x8f\x2a\xeb\x2f\x5b\x1f\xc8\x9c\x6b\x85\xc6\x46\xca\xd3\x2d\x39\x59\x06\x0b\xaf\x95\x89\xec\x92\x17\x30\x78\xb3\xbc\xd4\x57\xbc\x37\xcd\xcb\x99\x79\xaf\xd7\xae\xb2\xa7\x0e\x8c\x9a\x5c\xa0\x13\x5c\x2e\xbb\x59\x85\x06\x44\xcd\x1c\x70\x1c\xf5\xd5\x1f\x2a\x6c\x1a\x27\xac\xc1\x7f\x7c\x03\x0a\x93\x06\xb1\x5e\xf6\x17\x97\xc9\xd4\xba\x87\x59\xcb\xb6\x74\x06\x43\xbd\xb7\xb3\x06\x73\xc6\x35\xcb\xd7\xf7\x9a\xbd\x79\xcc\xa9\x2f\x1e\x59\x36\x7b\xd5\x85\xe3\xab\x0f\xf7\x78\x2c\xef\xd6\x6e\x83\x86\xad\x7d\x61\xe3\xc2\x2e\x83\x77\xad\xbe\xab\x4f\xf7\x56\x3b\xef\xab\x5d\xad\xe3\xf4\x2b\x26\xde\xf1\x48\xdf\xea\xf9\x6d\xcb\x3b\xb7\xed\xdb\x6b\x5f\x7a\xb7\x4e\x3d\x7b\x53\x1f\xd1\x78\x2a\xbf\x9e\x8c\x49\x16\x2a\x89\xc8\xee\xcc\x4c\x8d\xc6\x83\x64\x39\xdb\x97\xe9\x49\xf7\x0c\x88\x22\x93\x3e\x1d\xe9\x8f\x80\x99\x45\xa1\x6e\x9b\x14\x97\xbb\x38\x71\x1e\x98\x9d\xf7\xa5\xa6\x76\xb9\x34\xf0\x0e\xb0\x03\xc1\x08\xc2\x2a\x1a\x37\x42\x0d\xd0\xb5\x55\x8f\x51\xe5\x1b\x6a\xbb\xb4\xf7\x3d\x5b\x16\x18\xbc\x60\xeb\xea\x7e\x64\x80\x34\x8b\xf1\x6b\xdc\x4b\xf8\x0f\x7c\x1e\x76\x96\x77\x0b\x7a\xcc\xad\x7a\x4e\x1b\x7a\xc3\xde\xf2\xde\x37\x57\xb4\x2a\x6d\x95\xe9\xab\xba\x7d\xcc\x2b\xf0\x33\x18\x04\xe1\xa5\xa3\xf8\xbf\x38\x42\xe0\x64\x74\x98\xd1\xbd\xaa\x48\x11\x72\x99\xd5\x6a\x8d\x4b\xe3\x4e\x31\xdb\xed\x42\x55\xd4\x6e\xd6\x53\x97\xe2\xa9\xdb\xdc\xb0\xc1\x0d\x97\xdc\xb0\xd7\x0d\xca\xef\x69\x6e\xf8\xd5\x0d\xd5\x71\xfe\x8e\xfa\x73\xac\x68\x16\x5f\x88\x39\xe4\xce\xb9\x66\x30\x5a\xbe\xdf\x80\x09\x53\xe7\xe3\xef\xb2\xc1\x60\x71\xf0\x91\x5d\xf3\x9f\xdf\x49\xa0\xf0\x6c\xaa\x7b\x7c\x43\xfd\x0b\xfc\x8d\xf3\x27\xe7\x4e\x08\x4c\xab\x3e\xf4\xfa\x95\x95\xcc\x26\x0e\xdd\x44\xf0\xe4\x2f\xf1\x4d\xa4\x25\x14\xc0\x41\xe4\x5b\xbf\xdd\x60\x40\x36\xa3\x51\x22\xec\x9b\xd3\x66\xac\x8c\x9a\x6c\x90\xca\xdb\x6c\x3a\xb5\xda\x32\x20\xaa\x46\xbc\x6e\xc0\x35\x02\xc0\xb6\xf0\x17\x6f\xe6\x18\x79\xf6\x16\x5b\x81\x05\x7d\xb5\xb1\xf8\xaf\x7f\x5d\x3a\x7f\xee\x47\x78\xe7\xd7\x2f\x71\xc1\xf3\x2a\xbc\x92\xaf\xa9\x7e\x4e\x05\xf3\x54\xdc\x17\x78\x19\xbe\x0b\x16\xc2\x0c\xee\x17\xbc\xfe\x6a\x4f\xf8\xfa\x87\xbf\x84\x3a\xdc\x1a\xde\x45\x09\xd9\x1e\x7e\x27\x34\x4a\x83\x4a\x23\x3e\x0d\x8d\xf3\xad\xd3\x0a\x26\xe4\xc8\xd0\x2d\xd6\x71\xbf\xea\x60\xa4\x6e\x9b\x6e\xaf\x8e\x5f\x42\x2e\xc7\x75\x6f\xeb\x04\x85\x18\x24\xc5\xfd\x0e\x11\x74\x54\x02\x57\x9f\x4a\xcf\x04\x77\xd0\x9f\xb9\xb2\x1b\xdf\xff\xea\x13\x1d\x16\xb7\x42\x71\xdf\xf8\x33\x99\x1f\xf8\xf2\x48\x2a\x32\x50\x07\xf0\x6a\x42\xd3\xa9\x42\xc5\xc0\xa9\xb4\xa0\x02\xb5\x68\x62\xae\xb9\xa9\x47\xae\xb6\x71\x6b\x1d\x6b\xf2\x19\x73\x2f\xa8\x1a\x5c\xbf\xf3\xbd\xf1\x17\x8b\x09\x97\x9c\x02\x6b\xc1\x87\x97\xc3\x03\x70\x6a\x22\xde\x2e\xb4\xc3\x56\xf8\x05\x17\xd7\x6f\x64\x6d\xd2\x90\x3a\x07\x49\x80\x9c\x10\x8c\xbc\x2d\x38\xb5\xf4\x80\xb0\x06\x69\x2d\x82\x4b\x16\xb4\x5a\x1b\x19\x82\xaa\xa8\x4d\x83\x1c\x95\x2e\x68\x4f\x66\xa6\x0b\x62\x2e\x78\xc1\x05\xcb\x5d\x30\xc9\x05\xc3\x5d\xd0\xc7\x05\x25\xec\xf9\xe4\x2b\x2e\xf8\xcc\x05\x0f\xb9\xe0\x4e\xf6\x94\xa4\x0e\xba\xe0\x47\xf6\x90\x64\x78\x8a\xbd\x22\xd9\x66\xb8\x60\x0c\x4b\x60\x4f\x14\x94\x5c\x4a\xbb\x1f\x13\x49\xef\x64\x49\x95\x77\x82\x0b\xce\xb9\x80\x7b\xdb\x05\x7b\x5c\xb0\xc4\x05\xd3\x5c\x10\x71\x41\xa6\x0b\x2e\xb1\x17\xc7\x5c\xb0\xcd\x05\x1b\x5c\x30\xd5\x05\x95\xec\x79\x86\x0b\x90\x2b\x59\xa0\x69\x10\x43\x9a\x89\x28\x2d\x24\x98\x11\x49\x19\x48\x3f\x27\x7b\x8e\x4c\x52\x5b\x05\x80\xa3\x74\x93\x46\x65\xa2\xa6\x72\xca\x69\x31\x59\x18\x84\x3f\x7d\xb0\x54\x32\xf5\x72\x1d\xc6\x1f\xc1\xa7\x05\x37\x54\x14\x10\xde\x6f\xf0\xd8\x8d\xbb\xfa\x70\xba\x97\x0a\xdb\x7d\x5c\x8e\x6f\xe4\x7f\x59\xbc\xae\xad\xed\x95\xf4\xad\x1f\x2b\x38\xb5\x01\x8f\x14\xaa\xc9\x98\x7b\xd0\xd0\x48\x48\x4c\x49\x71\xdb\x4c\x26\xb3\xdb\x9c\x91\x9e\x62\x31\x99\x53\xd5\x8e\xaa\xa8\x4e\x54\x3b\x91\x63\x5b\x06\x6c\xc8\x80\x4b\x19\xb0\x37\x03\x94\xdf\xd3\x32\xe0\xd7\x8c\xe4\xe9\x19\x52\xd8\x94\xe6\xd1\xa2\xbd\xad\x79\xe6\x89\x3a\x27\xbe\x9e\x7b\x1b\x03\xa8\xcb\xfc\x00\xea\x59\x89\xef\xbf\xab\x64\xa8\x2c\x08\x14\x57\x8e\x8c\x9a\x07\x29\x6a\x7d\x7e\xb8\xd4\x71\xba\x28\x2f\xd8\x13\xaf\x15\x3f\xad\xdf\x8e\xcf\x3f\xbe\x81\xeb\x72\xf5\xc8\xed\xd3\x98\x1d\x2e\xc1\x19\x99\xc6\x00\x81\x8d\x91\x18\x4f\x35\xbc\x5a\x24\x22\x15\x6f\x36\xe9\x45\x93\x4a\x70\x6c\x34\xc3\x12\x33\xd4\x99\x61\xb4\x19\x06\x99\xa1\x8b\x19\x4a\xcc\x90\x63\x06\xab\x19\x04\x33\xfc\x61\x86\xef\xcc\xf0\xae\x19\xe0\xb8\x19\x0e\x9a\x61\x87\x19\x36\xb0\x0c\x33\xcc\x30\xc6\x0c\x55\x66\x88\xb0\x0c\x66\x96\x7a\x1c\x49\x7e\xce\x0c\x6f\x9b\xe1\x04\x4b\xbd\xcd\x0c\xa4\xf8\xe5\x66\x18\xc9\xca\xee\x6a\x86\x4c\x33\xd8\xcd\x70\xde\x0c\xef\x9b\xe1\x4d\x96\x60\x03\x4b\x30\x2d\x29\x4d\x51\x22\xd9\xa5\x44\xca\xbd\xac\xe2\x8d\x89\x5a\x95\x2a\xb3\xcd\x80\xcc\x50\xc6\x91\x54\xc7\x59\x92\x25\xac\x98\x1a\xf6\xde\xcc\x5e\x12\x40\xf6\xb0\x1a\xa6\x32\x50\x2b\x22\x5e\x33\x14\x9a\x21\x66\x86\x5f\xcd\x70\xcc\x0c\xeb\xcd\xb0\x58\x79\x63\x86\x0c\x33\x98\xcc\xc9\x58\xd8\x5c\x58\xae\x19\x71\x5d\xfd\xcc\x75\xe5\x69\xa6\xf5\xa9\x4d\x52\xcd\x84\x2a\x9a\x21\x27\x10\xc1\xd4\x0b\x5e\x28\xb5\x86\x09\x4d\x76\x0a\xf2\x87\x7b\xf1\x7f\x30\xb5\xb9\x10\xa7\x8e\x6a\x03\xae\x62\xbe\xff\x01\x5c\xfe\x9e\xd0\xee\xea\xa1\x2d\xe0\xde\xb2\xf2\xb6\xd1\x49\x6b\x59\x11\x1a\x18\xc9\x0d\xa4\xa7\x67\xbb\x91\xd3\xa8\x56\xe7\xe7\xe6\x3a\x8b\xdb\xe4\x32\x4f\xc6\xee\xfc\x82\xfc\x82\xca\x68\xc0\x8f\x8c\xf9\xf9\x3a\x3f\xd2\x25\xd6\xb6\xc2\xb6\x6d\xad\x6d\xd9\x44\x49\x5a\x1f\x8a\x1b\x3c\x05\xb2\x95\x0e\x5a\xae\x74\x84\x13\x52\xd6\xe7\xb2\xb0\x8a\x9a\x1c\x0b\x54\x7e\x76\x18\x39\xe8\x5a\x30\x74\x79\x93\x65\xef\xb6\x77\x36\x3c\xf8\xe4\xba\x65\xb8\x2f\xb7\x0e\xdf\xb7\xe1\x99\xfd\xbb\x07\xc3\x8e\xb2\x9e\x6d\x7c\x2d\x97\xbe\x59\xa7\x96\x3b\x39\xfd\xd2\x5b\x6e\x5a\x94\xa2\x56\x1f\x7b\xce\xff\x4c\xe5\x30\xe3\x31\x47\xd7\xe9\x28\x21\xdb\xde\x4b\xf7\xd7\x69\xb4\x22\xd2\xe6\xbc\xd8\x4f\xe2\x0f\x2c\x6e\x54\x24\xe2\x25\xfc\xad\xde\x6a\xb3\xa5\x18\x65\x59\x9f\xce\x7b\x33\x8d\x48\xf6\xc8\x95\x51\x8f\xc9\xe6\xd0\x08\x95\x51\x4d\x23\xf7\x8c\x42\xcd\x7d\x9a\x2b\x21\x8f\x43\xc5\x8a\x2f\x96\x30\x3d\x67\x46\x86\xa0\xd4\xda\x11\xb2\xa8\x15\x7d\x88\xb4\xed\xe3\xf2\xa2\x9c\x0e\xf6\x89\x33\xd7\xae\xc6\x9b\xf2\x5a\xe3\xaf\xda\x05\x3f\xba\xc1\x33\xb1\x50\xd4\xf0\x0b\xea\x0f\xf4\x2c\xd3\x1f\x71\x6d\x5a\xc5\x4d\x5f\xf0\x35\xde\xb8\xff\x22\x0c\x7c\x71\xb9\xff\xa4\xd1\x74\x94\xf0\x7d\x73\x09\xbf\xbf\x5d\xa8\x44\x16\x94\x46\x23\xe7\x59\x91\x8b\x71\xf9\xe9\x1e\xa3\xa3\x32\x6a\x34\x13\xd6\xde\xdd\x94\xb5\x4f\x5e\x9c\xed\x5c\x23\x17\x4f\xb7\xf9\xad\x62\x09\x0b\xb9\x4b\xb9\x3d\x61\xfb\x95\x77\x5e\x9c\x4f\x26\xfd\x27\x60\xff\xf9\x11\xbc\x0e\x7f\x7a\xd7\xcc\xcf\xa7\xdf\x33\xae\x96\x13\xfe\x8d\x3f\x59\xdd\xa1\x2d\x1e\xca\xff\xf2\x07\x38\xef\xc1\xff\xd9\xb1\xef\x2d\xbc\x07\x5f\x5a\xf4\x3c\xe9\xb3\x4a\x82\x27\x1f\x13\x78\xfc\xa8\x38\xe2\xcc\x30\x69\x50\x8a\x26\x25\x37\x07\x99\x3c\x7a\x4f\x16\x95\x39\x3c\xe6\x38\xcb\x13\x52\x48\x67\x23\xcf\x19\xe7\x78\x32\x14\x57\x2e\x0d\x88\x20\x84\x4b\xac\xd4\x98\x4b\x45\x20\x33\x02\x0c\xca\xef\x37\xb1\xd3\xc0\x07\xe6\x74\x68\xbd\xbf\xac\x70\xf8\xdd\x75\xe3\x06\x76\xc8\xba\xfb\xdf\x0f\x7f\xb5\xe8\xce\x9a\x49\x03\x6e\xaf\x82\x97\xda\xf5\x0e\xf9\x1d\xae\xfc\xf5\xb5\x1d\x1f\xea\xdc\xfb\xe6\x4e\x39\xe1\x5c\x5f\x7a\x61\xe4\xa6\xf9\x03\x0f\x40\x9f\x7f\xac\xdd\x34\x66\xd6\xf7\x09\xdb\x09\x71\x00\x93\x27\x52\x49\xbf\xc9\xb2\x64\xd1\x51\x7f\x0c\x1e\x9d\x5d\x63\x27\xa3\x69\x4a\x96\x88\x92\xb0\x36\xde\x6f\x82\x97\x6d\xab\x04\xe8\x21\x23\x47\x3a\x88\x25\xb9\x09\x3f\xfd\xc2\x3d\xf8\xeb\x18\xc2\x7f\xe1\x6f\xa0\x2f\x84\xb8\xdb\x5f\xdd\x31\xac\x0a\x7f\x3a\xb6\xf7\xa6\xbd\x97\x17\x2c\x83\x7f\x9e\xc3\xe0\x04\x2d\x68\xc0\x7f\x54\x12\x6a\x3f\xec\xf3\xf1\x91\x13\xbb\xf1\xb6\x1d\x0a\xad\xb7\xc6\x7e\xe4\xa7\xb1\xb8\x70\xdd\x23\x79\x16\x0d\x61\x1f\x74\x4e\x67\x8a\xcb\x4e\xb8\x1b\xbb\x93\xba\xf2\xaa\x8c\xaa\x4c\xe7\x52\xe0\xed\x14\xd8\x96\x02\x1b\x52\x60\x5a\x0a\x8c\x4c\x01\x65\xda\x37\xba\xa2\x56\xd8\x09\x99\x19\x5b\x49\x71\xfc\xf2\xc6\xf1\x8f\x06\xef\x49\x01\x30\x0e\xdc\xe8\x74\x4d\x2a\xe1\x1e\xc7\x67\x43\x91\x9c\xa0\x2b\x7b\x76\x3e\xfe\x80\x5f\xe0\x32\x9c\xd4\x5b\x8e\xd6\xbf\xd8\xad\x8b\x7a\xbf\xd6\x4a\x98\xa3\xa5\x0c\x2e\x26\x4b\x13\xb8\x1c\xa8\x5b\x24\x60\x42\x1a\xc6\x73\x59\x55\x26\x5e\x4f\xdd\x03\x6f\x93\x61\x83\x0c\x97\x64\xd8\x2b\x83\xf2\x7b\x9a\x0c\xbf\xca\x49\x2b\x4f\x22\x5c\x62\x83\x72\xac\x49\xb8\x46\x32\xce\x1c\x21\x43\x56\xb2\x3a\xd6\xc7\x2e\x7d\x03\x29\x35\x93\x67\x8c\xe9\xd3\x06\xd2\x4b\x6e\xe0\xda\xe3\xcf\xf1\x07\x5f\x7c\x4f\x03\x35\xae\x5a\x7d\xf4\xeb\x69\xe0\x1a\x3a\x1e\x7f\xcf\xc6\x0f\x0f\x15\x27\x0a\x03\x51\x0a\xf2\xc2\xc3\x91\x98\x1b\x65\x08\x36\x41\x34\x98\xcd\x1a\x8d\x88\x78\x5f\x96\x21\x4d\x4e\x23\xb2\x83\x6c\xce\xb0\x49\x36\xc2\x0a\x4a\x4e\x21\x75\xb5\x0f\x66\xf9\x60\x88\x0f\xba\xfb\x20\xc7\x07\x1a\x1f\x5c\xf6\xc1\x77\x3e\x38\xec\x83\xe5\x3e\x98\xe1\x83\xb1\x3e\x68\xeb\x83\x80\x0f\x9c\x3e\x10\x7c\x30\x8e\xbc\x7e\xc3\x07\x2f\xf8\x60\xb3\x0f\x56\xb0\xcc\x24\x45\x2f\x1f\x94\xb2\xfc\x4a\x66\x92\xe0\xa0\x0f\x76\xfa\x60\xae\x0f\x26\xf8\x20\xea\x83\xae\x2c\x01\x29\xfd\x8a\x0f\x7e\xf6\x01\xbc\xed\x83\xe3\x2c\xd1\x0e\x1f\xdc\xe9\x83\xc5\x3e\x18\xc3\x12\x95\xf8\x20\xdb\x07\x3a\x1f\x94\x5d\xf2\xc1\x79\x1f\xbc\xe9\x83\x87\x58\x0a\x02\xc9\x70\x1f\xf4\xf1\x41\x85\x0f\x0a\x7d\xc0\x99\x7d\x80\x7c\x70\xce\x47\x4b\x3a\xe6\x83\x3d\x3e\xd8\xe0\x83\x69\x3e\x18\xe9\x83\x4a\x96\x28\x33\xe2\xf5\x81\xc9\x07\xa4\x9c\x2f\x7d\x70\xd6\x07\x5b\x7d\xb0\xde\x07\x53\xd9\xfb\x22\xf6\xaa\xe5\x2a\xa3\x8c\x4e\xcd\xb5\x57\x91\x9a\x66\xc9\xae\x91\x26\xb1\xbe\x34\x09\x8c\xdf\x54\x6f\x1b\x1f\x6c\xd1\xe2\xb3\x64\x23\x4b\x89\x95\xe2\x1f\x53\x82\x52\x99\xcb\x2a\x9a\x7d\x59\x0e\x4b\x27\x10\x27\xe2\x1f\xf0\xdf\xbf\xe0\x18\xfe\xed\xe3\x1f\x1c\xd5\x63\x97\x2c\x78\xe6\xf9\x63\xe7\xf1\xcf\xeb\xe7\x2f\x59\xc3\x85\xf1\xaf\xf8\x23\x03\x9e\x00\x9b\x74\x84\x30\xe8\xfe\x04\x7b\xee\x01\xd7\x1b\x5b\xf6\x1e\xd7\x70\xf2\xc9\xd3\xf8\xb3\x3f\x60\xd2\x85\xfa\x1f\xa5\xd7\x29\x9e\x1a\x88\x04\x71\xb7\x50\x45\x24\xe0\xc1\x91\x62\x9b\xdd\xee\xd1\xa9\x35\x1e\x8d\xa8\x35\x39\xa4\xcc\x0c\xbb\x08\x26\x53\x86\x89\xd3\x88\xe4\x01\xef\x70\xa8\xed\xba\x54\xb5\x09\xb9\x69\x5c\xd1\xad\x99\x50\x99\x09\x6c\x0e\xc5\xc3\xbc\x92\xe9\x43\x17\x5f\x4b\x93\x18\x9f\xb6\xe2\x74\xc8\x80\x52\x22\x9f\x6b\xe2\xc1\x3e\x29\x83\x97\x1b\xe7\xf0\x7e\xe8\x3d\x7e\xd4\x68\xa3\xdb\xfb\x10\x04\xf0\x6a\x78\x04\xbf\xff\x6a\x61\x8a\xa6\xc4\xf8\x21\x7e\x1f\x4e\xcc\x0e\x47\x4a\xfd\x81\x56\xad\x06\x0b\x55\x9d\x37\x7f\xd5\xba\x77\x67\xe8\x56\xdf\xff\xea\xdb\xb0\x77\xec\x30\xcf\x62\x0f\xee\xc3\x77\xfc\x7d\xf2\xd8\x80\xf9\x98\x62\x4b\xb4\x94\xe0\xf6\x4a\xb1\x03\xe1\x50\x67\x44\x62\xa2\x64\xb5\x20\x9d\x53\xa7\xb7\xe8\x25\xde\x9d\x82\x9c\x06\x67\x65\x54\x6b\x70\xca\xb2\x68\x31\xe9\x52\x07\xb9\xa1\xbb\x1b\x9c\x6e\xf8\xcb\x0d\x3f\xb8\xe1\x43\x37\x3c\xe7\x86\x27\xdc\xf0\x90\x1b\x56\xb8\x61\xb4\x1b\x94\x04\x29\x6e\xd0\xb9\x61\xc2\x1f\x6e\x38\xdf\x34\xd1\xac\xa4\x44\x76\x37\x48\x49\x6f\x37\xbb\x61\x2e\xc9\xe3\x86\x5e\x6e\xc8\x72\x03\x98\xdd\x20\xb8\xe1\x33\x37\x9c\x75\xc3\x0e\x37\x6c\x74\xc3\x7c\x16\x03\xae\xc6\x0d\x11\x37\x94\xb8\xe3\x09\xda\x5e\x71\xc3\x39\x37\xbc\xef\x86\x17\xdc\xf0\x94\x1b\xee\x64\xb1\xe2\xc6\xb8\xa1\x8f\x1b\x52\x93\x9e\xcf\x48\x3c\xac\x70\x03\x87\xdc\xf0\xb6\x1b\x8e\xb9\x61\x0f\x13\x2d\x1b\x82\xcb\x99\x0f\xb9\x81\xbc\x53\x27\x61\x6f\xcd\xff\x42\xca\xea\xda\x86\xf7\xb5\xd7\xe5\x90\xe2\x68\x1b\x2a\x6c\x82\xb3\x0d\x6b\xb5\xbf\x13\xc7\x68\x93\x24\x92\x6b\x76\x9c\x4e\xc9\x16\x2f\x7f\x47\xcd\x2d\x05\x60\xbb\x8c\x2f\xe3\x7a\x7c\xf9\x2f\xb0\x8d\x5f\x05\xb0\x17\xda\x2d\xac\xe3\x46\xd6\x6f\x88\x7d\xc1\xe1\x49\xb0\x89\xfb\xe6\x2f\x6e\x5a\xfd\xa3\x0f\xdd\x29\x08\x77\xd2\xb1\x1c\x10\xfb\x49\xaa\x25\xeb\x61\x2e\x4c\x8a\xc4\x24\x83\x2d\x37\x37\x27\xc3\xe5\x4a\xcb\xd1\x18\xc4\x40\xab\xb9\x01\xc8\x09\x74\x0f\x0c\x09\x8c\x0d\x08\x9a\x00\xfc\x15\x80\xc3\x81\x93\x81\xef\x02\xfc\xea\xc0\x03\x01\xae\x2e\x00\x63\x02\x30\x24\x00\x81\x40\xdb\x00\x27\x04\x60\xfc\xe5\x00\x7c\x12\x80\x37\x03\xf0\x04\x7d\x3e\x36\xb0\x22\xb0\x39\x20\xb4\x0d\x80\x14\xc8\x09\x70\xdf\x05\x2e\x07\xb8\x37\x02\xf0\x42\x00\x76\x04\x80\xbe\xe2\x26\x04\x60\x78\x00\x7a\xd1\x5a\x4a\x03\x1c\xa9\xe1\x87\x00\x7c\x16\x80\xcd\x01\x5a\x0d\x4f\x6a\x9f\xc4\xca\x2f\xa1\x09\x80\xbc\x2e\xbf\x12\x80\xaf\x03\x84\x62\x05\xe0\x44\x00\x9e\x0a\xc0\xd6\x00\xcc\x67\x50\xf4\x09\x40\x45\x00\x52\x03\xc1\x00\x77\x89\x08\x37\x7b\x03\xc7\x03\xe7\x02\x3c\x79\x5d\x15\x18\x19\x58\x12\xe0\xc9\x4b\xb2\x1a\x56\x06\x6a\x02\x8b\x03\xc7\x02\x5f\x06\x44\x72\xa7\xe6\x73\x72\x1c\x5a\x3e\xcb\x91\x45\xcd\xf7\x1c\xce\xb4\x67\x35\x5a\xcd\x80\x68\x2a\x0d\xf5\x9f\xa0\x19\x8d\x81\x07\x80\xce\xb7\x66\x42\x18\xa5\x4e\xd7\xa2\x5b\xd7\x90\xc5\x12\xe7\x50\xe2\x7e\xb9\x1b\xc2\xef\x95\x11\xd9\x88\x08\xf9\x99\xb9\x4a\x58\xb0\x12\x14\xa7\x41\x2c\x60\x8a\x97\xff\x66\xc4\xe0\x51\x37\xdf\x31\x57\xfe\x0b\xf4\xe7\xcf\xe2\x9f\x7a\x08\x3d\xf0\x4f\x67\xcf\x83\xfe\xbf\xf2\xac\x55\xd5\x35\x43\x46\x01\x07\x9f\xae\x7b\x78\xfb\xc1\xc7\xde\x95\x5f\xf2\xe3\xb7\xff\x43\x88\xd4\xf7\xbf\xfc\x02\x2e\x80\xcb\x50\xe8\x7f\x41\x3e\xf3\xf8\xa1\xed\x0f\xaf\x7d\x41\xb1\x95\xf9\x84\x2c\x4c\x63\xc4\x35\x09\xfd\x34\x9a\xf8\x46\x7c\x47\x45\xab\xb5\xe4\x70\x60\x3c\x12\xfb\xea\xa0\x51\x1f\xb7\x97\x89\x6f\xc5\xa0\x84\xae\x9a\xe5\x63\xba\x6a\x34\x11\xfd\x96\xd8\x8b\x71\x3a\x69\x4e\xf7\x91\xd8\xbf\x0e\xba\x5d\x71\x75\x75\x93\xbd\x98\x7b\xa9\x3e\x9c\xf2\xab\x4c\x7f\x3e\x24\xbe\x17\x43\x73\x39\x23\xce\x14\x25\x47\x42\x7f\xae\xd4\x73\xbe\x41\x27\xde\x16\x5c\x71\x7d\x3b\x49\x0f\x4e\x6d\xf3\xf4\x0c\x77\x59\xfa\xf9\x4a\x7a\x6e\x78\x3c\x7d\x2b\x92\xbe\xd5\x90\x56\x41\x97\xa1\x21\x3d\xe2\xd1\x38\x52\xfe\x22\xf1\x03\x22\xab\xb6\x42\x25\x68\x5c\xa4\x63\x00\xa5\x1b\x0a\x9d\x4e\x49\xb2\xf9\x0c\x48\x2c\x0d\xa7\xe6\x57\x45\x57\xe4\xc0\xb8\x9c\xd9\x39\x5c\x8e\xd9\x85\x52\x41\x97\x6a\x4e\x35\xf3\x13\x32\xa1\x67\xe6\xb0\x4c\x2e\xd3\xa4\x05\x03\xaf\xe5\x8b\x6f\x4c\xf0\x5e\x54\x69\x13\xaa\xae\x66\xe7\x08\x46\x54\x93\xb1\xad\x6e\x16\x14\x92\x71\x63\xd4\xc8\xa5\xc4\x9a\x9d\x88\xef\xa2\xa8\x2c\x65\xa6\x69\x52\x82\x26\x31\xc5\xb4\x2d\xc9\xfc\x5f\x58\x84\x7f\xfb\x0e\xff\x8d\xbf\xd9\x08\xad\x9e\xbf\x7f\xef\xd1\xed\x03\x1e\x29\x74\xf9\x84\xb2\xa7\xab\xbf\xb8\x84\x3f\x5f\x10\xa9\xcb\x70\xdc\xd2\xb3\xa2\x7f\xca\xec\x29\xb7\x2e\x9c\x3f\x6e\xea\x4c\x78\xe8\xcd\xf3\xb0\x02\x26\x7d\x07\x03\x5e\x9e\x3d\x79\xee\xea\x9c\xf4\xa2\x6d\xed\xba\x65\x95\xf7\xfa\x8a\x5b\xda\xb1\x75\xb6\xd5\xed\xbb\x7a\x76\xfc\x8c\x99\xe3\x6e\x9d\xcd\x0c\xb0\x39\xe4\x22\x7d\xb1\x8b\xf4\x45\x3e\x0a\xa3\x31\x91\xf2\x82\x60\x56\x10\x42\x39\xa9\x6a\x59\x6f\xd5\xab\x73\x40\x2c\x2b\x0d\x14\x55\x45\x21\xab\x20\xab\x2a\x1a\x2c\xb0\x5b\xaa\xa2\x76\x63\x55\xb4\xc0\x5e\x60\x17\x4d\x01\xd2\x09\x01\x31\xbd\x2a\x2a\x36\x76\x82\x35\x1e\x14\x15\x35\x84\x68\x6f\x16\x30\x05\x7c\x12\xa7\x1c\x7d\x28\x63\x6e\x05\xa4\x78\x4c\x7c\xbb\x4a\x69\x32\x91\xa6\xd8\xb6\x7b\x69\x28\xd3\x12\xf2\x26\xba\x42\xd8\x35\x5d\xbf\xee\xc2\x03\xcf\x1d\x35\x99\xda\x39\xba\xca\x43\x27\x8f\xaf\x33\x99\xba\x57\xf4\x5f\xd0\x4f\xd8\x89\xff\xbb\xf4\xd3\xa7\x61\xe7\x74\x7c\xef\xc0\xc1\x5d\xfb\x3d\xc6\x9d\x3a\x8f\x9f\xf9\xc7\x9d\x77\xe4\xf5\xee\x95\x5d\xec\xb4\x9c\x2c\x1e\x17\xcd\xef\xd3\xa7\xa0\x5b\xe9\xa2\xbf\x1e\x1c\xff\xd2\x92\xc7\x4e\xd5\x9f\x78\x65\x57\xf7\xee\x63\x99\xef\x0e\xba\xbf\x28\xe9\xc4\xc3\xc8\x8a\xc2\x64\x71\xe0\x44\x41\xe0\x0c\xbc\xdd\x66\x34\x0a\x92\xc4\x09\x5a\xf3\xc8\xa8\x56\xe0\x39\x6a\xf3\x75\xa2\x49\xf8\xc9\x86\xa8\xde\x71\x25\x95\xe2\x87\x85\x32\xff\x2a\xbe\x02\x7f\x8a\xb5\x10\x86\x81\xa0\x6d\xbb\x6c\xc4\xd0\x5d\x9d\xa6\xde\x38\xa0\x7d\x0e\xd7\xa5\xfe\x28\xd7\x85\xaf\xa8\xdf\x0d\x67\xc7\x0c\x19\xd8\xf9\xe0\x80\x0a\x82\xbb\x19\x08\xa9\xce\x8b\xa7\xcd\xb9\xfc\x32\xf8\x84\x61\x6f\x71\xac\x3b\x81\x4c\x7b\x90\xcc\x29\x3e\x87\xce\xa1\xc4\x3e\xa8\xa4\xa3\xfb\xa0\xfc\xb2\xf8\x3e\xe8\xf0\xc4\xdc\x73\xbb\xe9\x3e\xa8\xeb\x48\xec\x81\x83\x2e\xa7\x60\x68\x36\xf7\xc8\x1a\xbd\x4f\x3c\x6d\x95\xb8\x76\x6c\xbc\xfb\x93\xb9\x32\x8b\xf0\xc8\x36\x14\x40\xc3\x22\x41\x5f\x56\x96\x99\xe3\x45\xab\x2d\xd5\x6c\x17\x45\x73\x30\x2f\x2b\x0b\x69\x75\x3a\x03\xe2\x5d\x36\x64\xa3\x51\xc4\x73\xd3\x0d\xe9\x95\x51\xb5\xc1\x99\x14\xce\xb9\x31\xae\x7c\xb2\x49\x33\x3b\xb1\xd7\xe0\xd1\xcb\xd9\x84\x9c\x95\xf9\xa8\x86\xde\x9b\x44\xd2\x94\x1f\xfd\xa5\x56\x73\x67\x24\x51\xb4\xe9\xb3\x44\xa9\x53\x9b\xab\xff\x6d\xd3\x49\xa1\x6a\x23\x06\x8f\x1c\x21\xb4\x7b\xf3\xe1\xb7\x1a\x09\xda\xe9\x2d\xf8\xc1\xba\x53\x05\xad\xdf\x98\x4a\x49\xda\xe3\x8f\xaf\x7b\x78\xa7\x12\xe3\x59\x1c\x28\xf4\x42\x21\x32\x9f\xcb\x0b\x32\x9d\x45\x6e\xb0\x88\x9c\x4e\xe7\xce\xcc\x11\xc5\x70\x89\x56\xeb\x44\xc8\xe9\x70\x38\x33\x32\x38\xa7\x89\x73\x18\xd5\x34\x6e\x48\x81\x87\xa0\xb2\xd3\x97\x5b\x15\xf5\x05\xc8\xa7\x79\xc8\x2b\xaa\x12\x48\x36\xdd\x6e\xd8\x06\x09\x29\xd1\x29\xbd\x54\x33\x41\x47\xbc\xd1\x41\xbc\x0c\x5e\x49\x09\x41\x5f\xd6\x34\xe6\x95\xa2\x20\xe0\xcf\xd4\x9f\xc4\x8f\x8f\x9d\x11\xe9\x5c\x50\x94\x95\x3e\x33\xf7\xde\x47\x8b\xca\x45\xae\x10\xa6\x4c\x98\x17\xe9\xdc\xb9\x7c\x8b\xe2\xab\xa4\x7b\x9f\x29\x75\x45\xe5\xdc\xb1\xfa\xce\xab\x60\xc8\xe3\x53\xc7\x1a\x2f\x68\x0c\xcf\x3d\x79\xe3\xde\xe9\x1c\x77\xfa\x2e\xfc\xe8\xe3\xb5\xa3\x8d\xf8\x6d\xc5\x9b\x49\xe7\x0e\xbd\xe4\x3d\x77\x91\x57\x89\xd8\x95\xd4\x96\xcf\x44\x64\xc5\xf2\x48\x9a\x09\x39\x05\xb3\x4e\x40\x3a\xde\x93\x86\x20\xa2\xb2\xd5\x44\x55\x02\x11\x5b\xa2\x46\xb0\xc6\x37\x04\x83\xc8\xed\x32\x9f\x69\x6a\x76\x4d\x59\x60\x33\xf2\x16\x0b\x56\x07\x65\x89\x93\xed\xf1\xb8\x55\xf8\x0f\xfc\x31\xb5\xc2\xfb\x02\xba\x3c\x81\x3f\xc4\x97\x41\x95\xb0\xc4\xc3\x43\x61\x5b\x2b\x58\x08\x41\x6a\x86\xf7\x34\x7e\xee\x33\x32\x09\x96\xe5\xe3\x1a\x61\x5a\x53\x7b\x3c\x45\x26\xa2\xfa\x0b\x16\x7b\x37\x1c\x49\x35\x22\xbb\x60\xa2\xfe\x68\xf9\x54\x37\x4a\x55\x59\x89\xf4\x68\x06\x79\x60\xd4\x00\x8e\x06\x30\x93\x82\x16\x29\x40\x32\xcb\x04\xaf\x62\xbd\x60\xa1\x14\x33\x53\x11\xd2\xe0\xbb\x97\x3f\x80\x4c\xe0\x89\xe8\x2a\xbf\xf7\xf2\x6d\x8b\xe6\xc4\xd0\xc2\x59\xcb\x17\x13\xe8\x1e\xf3\x43\xd6\xbf\x40\x84\x20\xfe\x12\xff\xfb\x5f\xf8\x5c\x0e\xae\xe6\x4f\xbd\xfc\x0c\xbe\xfb\xd0\x4b\xcf\x2a\x72\xed\x02\x84\xc4\xe9\xa4\xff\x5c\xa8\x6b\x24\xcb\x85\xac\xa2\x5e\x27\x92\xde\x73\xa7\xe8\xf5\x1a\x59\x46\x1a\x07\xd4\x44\x1d\x0e\x0d\xb2\x6a\x4c\x35\x51\x8d\x90\x88\xbc\x5c\x78\x0d\xc2\xa0\x18\xc5\x51\xed\x10\x21\xf7\x99\x36\xb1\x61\xd7\x86\xe0\x05\xb7\x69\xc7\xef\xb7\x6f\x06\xff\x19\xf8\x65\x29\xbe\xea\x7d\x79\xd9\x33\xcf\xbe\xb5\xa7\x77\x15\x8a\x39\xb6\xfd\x7d\xdf\x11\xd0\xad\xc3\x73\x7a\x4c\x5c\xb8\xff\xd9\x9d\xc7\xed\xd8\x40\xe1\xa2\xfd\x55\x48\xfa\x2b\x9f\xea\xd3\x8d\xb9\x0e\x35\x52\x67\x14\x98\x4c\xba\xdc\xdc\x6c\x9d\x8e\x74\x97\xce\x9c\x9d\x57\x15\xcd\xbe\x66\xf0\xe5\x62\x25\xe0\x8d\x48\xdd\xb4\xf2\xe1\x26\xf1\x97\xd9\xb6\x0d\xef\xb0\xb3\x33\xe4\x61\xb6\xf4\xf0\xb6\xc8\xd0\xa7\x0f\x2c\xee\x97\x74\x5e\x62\xd2\x6d\x79\x55\xb5\x3d\x7a\xaf\x99\x14\xe9\xb9\xe4\xc0\xac\xa3\xef\xf7\xfe\x78\xf8\xfc\x59\x63\xf2\x8a\xe4\xbc\xee\x53\xf7\x2c\x03\x35\xb4\x62\x67\x27\x9e\x78\x6c\xf0\xe4\x6e\xf9\x4e\xb9\xb0\xe7\x6d\x83\x3b\x2f\xab\x6e\x53\xf4\x7d\x9a\xbf\x83\xb2\xd7\x20\xdc\x2f\x2e\x45\x3a\x14\x89\x64\xa8\x74\x1a\x9e\x27\x08\xa9\x13\x0c\x7a\xf2\x5c\xd4\x70\xa4\x1f\x35\xa2\x60\x15\xd5\xd4\xb4\xb6\x45\x87\x36\xdb\x04\x09\x33\x23\x43\x66\x70\xcb\x77\xc7\x13\xf1\x27\x82\xa9\xde\xc5\xbd\x04\x2b\x5e\xa8\x3f\x26\x2e\x3d\x8f\x57\xe1\x51\x6c\x1c\x57\xe1\xa1\xfc\x20\xb6\xff\x70\xcd\x3a\x2b\x59\x9d\xa9\x22\x21\x01\xa2\xe9\xff\xa8\xd3\x4f\xdd\x1f\xc4\xeb\xe4\x6e\x7d\x13\xff\xc2\x9d\xc6\xdd\x61\xfd\xb0\x63\xf5\x11\xf1\x9b\x37\xf1\x54\x3c\x8f\xd4\x97\x11\xfb\x49\xfc\x4e\xdc\x88\x0a\x68\x1c\x69\x64\x11\x5d\xbe\x80\xc7\xe7\x11\x75\x42\x61\x6b\x7b\x41\xbe\x5c\x40\xfe\x19\x73\x72\xb2\x46\x46\x73\x32\x6b\xa2\x39\x82\x51\x3b\x32\x6a\x24\x0d\x36\xda\x12\xf4\x26\x1e\x8f\x51\x39\x7b\xd6\x4c\x09\x6a\xe4\xe3\x7e\x72\x94\x90\x45\x25\xb6\x32\x09\x11\x82\xc3\x2b\x94\x27\xdc\x40\x79\x40\xdc\x6c\x2b\x29\xf4\x56\x74\xce\x6f\x9f\xb9\x39\x7b\xcd\x03\x1d\x1d\xab\xeb\xbf\xfc\xd3\x63\x2b\xca\x4b\xeb\xd4\xa5\xa0\x9d\x77\x13\x79\xe6\xf6\xf3\x0f\x0b\x57\xe6\x5c\xf9\xf7\xa7\x43\x06\xf6\x34\x7d\xae\xd6\xaf\x9e\xb1\x1e\xf2\xa7\xf5\xc0\x8f\xed\xd1\xcd\xf9\xf6\xa3\x13\x0d\x4f\x3b\xbf\xf2\x3c\xa7\xf8\x9c\xf7\x90\x3e\x4b\x63\xbe\x21\x68\x9c\x63\x00\x5e\xa3\x92\x24\xb5\xa0\x11\x74\x5a\xb5\x50\x15\x55\xab\x39\x09\x38\x87\xa2\x3e\x0d\xb6\x70\x9a\xaa\x01\x9f\xcd\x1b\x86\x10\xef\x15\xd2\xf0\xa7\x17\xcf\xd5\xb7\x81\xc0\xc5\x8b\xdc\x87\x7c\xfa\xd5\xaf\xb9\x89\x6d\xf8\x36\xf5\xcb\xa8\x3e\x09\x47\x25\x37\x99\x77\x69\xa8\x77\xc4\xe4\x76\x58\x2c\x1a\x3e\xc5\x6e\xd0\x88\xe9\x1e\xd9\x7d\x04\x6c\x11\x57\xd4\xea\xa8\x89\x72\x2e\x9b\x6c\xb5\xca\x36\x17\x27\xea\x45\x11\x11\x84\x51\x66\xa0\xf9\x44\xfc\x94\x78\xb0\x91\xdb\x60\x96\x4d\xaa\x5c\x7a\xc0\xce\x4a\x88\x99\x98\x9b\x0f\xd6\x8e\x00\xb9\x90\x93\x4b\x2e\xad\x81\xbb\x03\xff\xf0\xfd\x0c\x30\xc2\x02\x82\xc0\xf7\x7d\x89\x87\xe0\x76\x53\x41\x0b\x45\xeb\xea\x37\x8e\xe0\x0e\x39\x0b\xea\x03\x23\xb8\x67\xab\xce\x08\x4f\x7d\xfa\xd9\xc5\xdf\x70\x37\x22\xf7\x0f\xc6\x03\x32\xde\xe3\xd7\x43\xab\x0b\x02\x7e\xef\x30\x54\xdd\x36\x14\x6f\x3f\x0c\xfd\x07\x74\xa5\xe3\x8f\x87\x08\xeb\xc4\xf7\x90\x13\xb5\x8f\x18\xb4\x22\xb2\xe8\x35\x02\xdd\x78\xd2\xb2\x40\x67\x96\xa8\xc8\x91\x8e\xe2\xb5\x44\xa0\xe7\xd5\x82\xc1\x91\x9a\x08\xfa\xd1\x08\x31\x33\x21\x2e\xc9\x15\x73\xfd\x39\xec\xe2\x2f\x13\x90\x95\x92\x36\xd1\xca\x2f\x93\xf1\xf2\x1a\xd8\x96\xd5\x0e\x8f\x1a\x01\x75\xaf\xe3\x47\x1e\x87\x09\xf0\xc8\x2b\x99\x6e\xfc\xf9\x8d\x0b\xd7\x2f\x7f\xe1\xf5\xb7\x86\x8f\x38\x7d\xec\xb9\x13\xf3\x5e\x5b\x87\xb7\xe1\x2c\xfc\xcc\x14\xfc\x65\x5d\x0d\xb8\x15\x9a\xb6\x19\x0f\x55\x45\xc9\xfc\x0b\xa2\xca\x48\x2b\x7d\x7a\xaa\xc3\x9a\x2d\x8a\xb9\x56\x94\x9a\x2b\x14\xe4\x4b\x7a\xbd\xc9\x86\x08\x55\x43\x26\x7f\x9a\x8d\xf7\xba\x4c\xae\x51\x51\x0d\x79\xd4\x28\xf7\x98\x4f\x5c\x63\xe7\x88\x75\xb0\x2d\xec\xa5\x0b\x1b\x43\xcb\xdc\x78\x3c\xad\x84\xa6\xac\xc9\x0f\xf2\x6e\xb3\xf0\xcb\x6d\x3d\xda\xed\xbc\x63\xd6\x03\x05\x83\x8e\xcd\xd9\x73\x0a\x72\x6e\x9a\x34\x76\x41\xfc\xda\xaa\xe7\xe6\x75\x78\xe8\x85\xa1\x8b\xe7\x0e\xac\x1c\x34\x28\x5a\xf9\xc5\x2b\xfc\xe5\xab\x37\xdd\x73\xe7\x8e\x95\xfc\xfd\x89\xef\xbf\xef\xdd\xfe\xca\x30\xda\x9e\x09\x78\xa8\xb4\x8e\xcc\xed\x3c\x34\x30\x92\x67\xf5\x65\xa6\xba\x5a\x69\xb5\xc8\x25\x66\x22\x21\x3f\x68\xb5\xa6\xe8\xf4\x7a\x47\xc0\x9b\x62\xf2\x7b\x1c\x64\x71\x37\x39\x9c\xa2\x44\xa6\x79\xd3\x80\xd8\x8a\xf9\x5e\x53\x72\xad\x58\x71\x53\x58\xbd\x4a\xbb\x7c\xcd\x1a\x96\xd8\x6c\x8a\x7f\x4b\xeb\xfa\xdc\x7f\xef\x95\x01\xc2\x98\x49\x37\x0a\xc1\x07\x97\x2f\x58\xeb\x2e\xdd\xb2\x7c\xcb\x4e\x90\x77\x0c\x99\xa8\x5c\x52\xb4\xdb\x8e\x0d\x3a\x33\x79\xf9\x63\xe3\xc6\x4c\x9c\x3e\x73\xfc\x47\x6f\x70\x7b\xea\x1f\xc5\xdf\x3c\xb9\x94\x1b\x40\xbf\x9f\x59\xc3\x51\xdc\x59\x48\xd6\x1c\x87\x78\x0f\x72\xa3\x9e\x11\x3f\xa1\xec\x26\x51\xa3\x51\xab\x4d\x69\xa9\x5a\xad\x46\xe2\xf5\x35\x51\x9e\x27\xdf\x1a\xab\xcd\x59\x13\xb5\xb9\xc8\x47\x40\x8d\x01\xd8\x5a\xd2\x2c\xc5\xe8\x85\x2d\x33\x94\x64\x49\xd4\x04\xa2\x84\x1d\x5b\xa4\xac\xa9\x04\x0f\x3c\xba\xed\xce\xd5\x90\x8b\x3f\x39\xf2\x8f\xbf\xf0\xb7\xd3\xde\x5a\x39\x76\xb0\x2f\xa7\xe7\x6d\xb7\xf2\xaf\xae\x59\x5f\xca\x3d\xfa\xf7\x62\xce\x14\x01\xd5\xcf\xf7\x9e\x9d\x62\x79\x57\xb5\x90\xc0\xb7\x86\xcc\xff\x1a\xf1\x7d\x42\x07\x3a\x46\xbc\xf6\xff\x0f\x67\xef\x01\x1f\x55\x95\xfe\x0f\xdf\xe7\xd6\x69\x77\x6e\x99\x3e\x93\xc9\xb4\x34\x48\x20\x21\x3d\xb4\x0c\x1d\x14\x48\x40\x04\x47\x85\x24\x8a\x88\x8a\x0a\x88\xc0\x82\x08\x28\x22\x88\x8a\x85\xc5\x2e\xb8\xa0\xa2\xa2\x20\x62\x57\x40\x45\xec\x8a\x2b\x56\xc4\x2e\xac\xa2\x0b\xae\xa8\x2b\x64\x4e\xde\x73\xce\x9d\x99\x4c\x0a\xee\xef\xff\x7e\x02\xc9\xcc\xbd\xe7\x9e\x7b\xea\xd3\xce\xf3\x7c\x1f\x09\xaf\xaa\xa0\x64\x0f\x72\xa1\x5c\x8b\xda\x98\xb0\x60\x55\x20\x60\xf1\x90\xec\xda\x1e\xf0\x58\xc8\x89\xee\x6e\x2a\xff\xa7\x13\x2d\x67\x33\xc3\xd4\x48\xaa\x91\x54\x9e\x32\x31\x08\x99\x35\xc2\x0d\x2f\xdd\x36\x6f\xf3\x33\x30\x28\xb0\x34\xaf\x6f\x69\x3c\x9e\x38\x6f\xda\x12\xf0\xb1\x7d\xcf\x98\xba\xef\x6d\x18\x0e\x33\x2d\xd2\xc7\xb6\xd1\xc3\xfe\xbc\xeb\xaa\x2d\x2b\xd9\x21\xc7\x2b\x71\xbb\x6e\xc6\xb2\x4e\x0f\xe2\x1f\xcb\x0c\x8e\x87\x2d\xa2\x5b\x62\x34\x4d\x0a\xe6\x58\x2c\x92\x49\xe6\x9a\x12\xb2\x2c\x99\xdc\x9e\x96\x84\x5b\x32\x71\x12\x91\xde\xd5\x3d\xd9\xee\x42\x1d\xc6\x8c\x7a\x8f\x60\x5a\x4a\x47\x8c\xd2\x53\xdd\x45\x22\x12\xc8\x42\x18\x08\xbc\x63\xd3\xba\x5b\x97\xa2\x4f\xa1\xb0\xf9\xee\x96\x7f\xfc\xb2\xf4\x76\xb4\xe3\x5f\xa8\x27\x3c\xbc\xf5\xcd\x29\xd0\xb8\xf3\xf5\x8a\xe4\xd9\xc2\xd2\xe4\xb1\x48\xce\x2d\xe8\xf0\xce\xc3\xe8\xb1\x67\xde\x99\x7f\x9c\xc8\x38\x36\xac\x57\x6d\xe0\xe7\x61\x29\xbb\x82\x19\x1e\xcf\xcb\x01\xa1\xa7\x1a\x8d\x96\x06\x8b\x38\x41\xac\xaa\x94\x9d\xbd\x82\x45\xa1\x7c\x67\xc8\x19\x52\xcb\x99\x7c\x55\x75\xf9\x48\x8e\xd1\x8a\xfa\xfa\x3d\x15\x46\x2c\x3a\xf1\xdf\xd7\xb2\x4c\x3e\xa4\x95\x1e\x51\xa2\x52\x75\xb4\x30\x05\xb8\x44\x1a\x4b\x71\x4d\xaa\xda\xa3\xc9\xdd\x9e\x6a\x63\x01\x90\x32\x5c\xf2\x81\xde\x13\xfa\x1f\xdc\xbf\xe0\xdc\x7e\xd5\x9e\x71\x9f\x0d\x5b\x38\xaa\xdf\x99\x8d\xe3\x2b\x9a\x27\xb1\x0f\x3d\xf0\xe8\xcb\xff\xfd\x68\xf2\xa3\x43\xaa\x93\xf7\x9f\x72\xea\xca\x8b\xc2\x33\x87\x6d\xe7\xe7\xdd\x3b\x62\xca\xdc\xbb\xd1\x61\xf4\x65\x5d\xd4\x33\xe5\xcc\x9b\xc6\xe7\xf7\xca\xdf\xb0\x75\xf8\x65\x37\x2f\xbd\x67\x7b\xbf\xb2\xe1\xe8\xd7\xde\x75\x0b\x7a\x19\xf1\x01\xc4\x8f\xe7\x07\x4c\xb3\x7b\x31\xf5\xf1\x68\xac\x87\xd5\xad\xa8\xb9\x0c\xa3\xba\x7b\x60\xa6\x67\xc5\x4a\x03\x5f\xec\x28\xc6\xdc\xae\xd8\xe1\x90\x5b\x8c\x45\x9b\x49\xa8\xdb\x49\x2f\x76\x54\x0e\xe4\x6b\x06\x62\x49\x29\x12\x25\x99\xc3\x31\xc9\x26\x22\x89\x40\x54\x85\x88\x61\x1b\xc9\xc7\xbd\x8e\x84\xf3\x26\x16\x9f\x3a\x6d\xee\x55\x83\x1f\x9e\x55\x87\x5a\xff\x28\x41\xdf\x14\x80\x82\xa9\xb7\x02\xde\xba\xd9\xbb\xd1\x6f\x0b\xe6\x42\xd5\xea\xd5\xce\x20\x70\x0d\xc9\x37\xd0\x27\xe8\x6d\x58\x3b\x7e\xfe\xa4\xfe\x3d\x73\x95\xbc\x3e\x23\x6a\x36\x3d\x5d\xf8\xc2\xfd\x6f\xbc\x34\x71\x49\xd3\xe8\xc1\xb9\x53\x46\xbe\x70\xd6\xb9\x25\x23\x7b\x9c\x3a\x7f\x29\x9a\x9b\xc2\x1b\x26\xfd\xf9\x12\xf7\xa7\x88\xa9\x89\xe7\xaa\x81\xa8\x28\xba\x8a\x02\x7c\xcf\x1e\x45\x51\xa7\xca\x7b\x39\xaf\xde\x98\xf0\xf2\x5c\x7e\x63\x07\x67\x8d\xac\xbe\x60\xe2\x21\x62\xfd\x3e\x0f\xef\x36\xae\x73\x6f\x44\x49\x48\x2b\x3e\x35\xfc\xc3\xe7\xa3\xff\x5c\x8d\xf6\xa1\xbd\xc5\x63\x2e\x5a\xf2\x44\x56\x67\x74\xb0\x82\x0c\xce\x07\xdf\x46\x7f\x2e\x9e\xb5\xf1\xfe\x4b\xbf\xbb\x63\x44\x8f\xf2\x7d\xef\x8c\x5f\x70\x66\x7d\x59\x51\xaa\x0f\xcf\x6e\x7a\xfd\xe5\x9b\xb7\xd5\x8e\x8c\x9c\x3d\xa2\xe5\x8c\x92\xbe\x78\x9d\x85\x49\xb6\x76\xdc\xee\x28\x93\xcf\x0c\x8b\xe7\x3b\x19\x25\x8f\x8f\xe5\xe7\xeb\x31\x4d\xcf\x91\x34\xbe\xb0\x80\xc9\xd3\x43\x56\x6f\x08\x93\x0e\x3e\xc4\xeb\xf9\x2d\x09\x5d\xcf\x22\x86\x59\x09\x6b\x35\x8a\x91\x82\x97\x59\x4d\x4a\x97\xa5\x52\xa2\x02\x34\x7e\xa4\xd0\x40\x95\x33\x14\x1d\x8f\xc3\x0a\xec\xcd\x81\xfa\x55\x0b\x46\xac\xee\x3f\xa2\xe8\xec\xfc\xda\x61\xb9\xcd\xd0\xd2\x5a\x0e\xcd\x4d\xc1\x11\x35\x05\x89\x9e\x23\xfa\xaf\x1e\xb1\xe0\xfa\x81\x5f\xef\xd9\xc3\x2f\xab\x5a\x78\x4e\x55\xd5\x5b\xb1\xe2\xd2\xfe\xaf\x26\x27\x7c\xf0\x01\xbb\xf9\xd5\x01\xbd\x7b\xe6\xbd\x55\x55\x75\xee\x82\x56\x3f\xdc\x86\x2e\x60\x8c\xdc\x83\x0c\xbf\x17\xcb\xb8\xb9\x4c\x84\x99\x10\xef\xad\x87\x18\x99\x8f\x84\x23\x4a\x58\xf5\xa9\x0a\x1e\xd9\xa8\xd9\x1d\x70\x37\x26\x64\x5d\xf2\x32\x5e\x3d\xc4\xab\x7c\x40\xd5\xec\x61\x35\xdc\x90\x50\xd3\xf9\xad\x49\x8e\x4c\xa3\x27\x1d\x4d\xfc\x59\xdd\x32\xc8\x60\x76\xa7\x52\x3e\x0f\x98\xfb\xb1\x17\x9e\x3a\x70\xd1\xb8\xdb\xe7\x8d\x98\x38\xaa\xf6\xd4\xe8\x38\x98\xd0\x3a\x14\x4e\x6b\x0c\x8f\xa9\x1d\x35\x71\xc4\xbc\xdb\xc7\x2d\x1a\x78\xea\x8b\xb0\x80\x1b\x39\x6d\xc2\xe8\x0b\xde\x1a\x51\x59\x36\x1b\x55\xec\xd8\x01\xef\xcc\xee\x5d\x3d\xe2\xad\x0b\x46\x4f\x40\x7e\xf4\x3b\xd1\xc1\xb0\x2c\x78\x2b\x96\x97\xdc\xb8\x1f\x83\xe2\x11\x0f\x63\x11\x82\x41\xd5\xa2\xe2\x17\xf9\xb1\xc8\x22\x4b\x92\x4b\x76\x41\x73\xc2\xc5\xc8\x78\x7b\xc8\x8e\x0e\x32\x3b\x3d\x7d\x6e\x4f\xdf\x47\x8c\x25\x61\x5e\x94\xaa\xb1\x9e\xe3\x32\xb4\x1d\x55\xc7\x6b\xaa\x82\xcb\x58\x88\xc2\x02\xff\x0f\x74\x1c\xbd\xb6\xd6\xf1\x30\xb0\x50\x04\xc3\xd0\x3a\xb4\x13\xbd\x88\x1e\xb8\xe4\x27\xb8\x19\xce\x6d\xb9\xf5\xf9\x97\x5f\xde\xf1\xca\xf3\xb0\x98\x3f\x50\xbb\x64\xf1\x95\xe8\x5f\xc7\xd1\x09\xf4\x25\x4c\x84\x2a\xa6\x0d\x86\xbc\x38\xb1\x75\xd8\x3d\x6b\xfe\x7e\xf7\x7d\x14\x3b\x81\xd8\xd1\xf8\xd3\xf9\xd3\x70\xcb\x87\x62\x8a\xa5\x59\x19\x4d\xf4\x30\x0c\xa6\x2c\xa1\x9c\xc6\x44\xc8\xdf\x90\x08\x85\x48\xce\xa1\xc6\x84\x59\xe5\x9c\x0d\x9d\xdd\x96\x8a\xbb\x38\x2d\x39\xf1\xb4\x51\x5d\xb2\xc2\x15\x8b\xda\x0d\xb5\xb8\x3a\x25\xb7\x92\x41\xe7\x4f\x47\xbf\xfc\x79\x0c\xfd\x17\x1e\x84\x1b\xdf\xdb\xb9\x67\xd7\x65\x75\x8b\xae\x9c\x39\xff\xdc\x29\x43\x87\x9c\xdb\xb2\xfb\x5d\x58\xb8\xe3\x7d\x88\x02\x0f\x21\x88\xbe\x57\x7a\xee\xdd\x17\xdf\x79\xff\x94\x29\xe3\x26\xb9\x5e\x77\x3d\x89\xdb\xaa\x12\xe0\x0d\x4c\xff\x23\xcc\xa8\x78\x9e\xc3\x93\x6b\xb5\x06\x6c\x9a\x47\x64\x3c\x36\x72\xaa\xc6\x39\x9d\xb6\x1c\x8b\xdd\x6f\x6f\x4a\xe4\xfa\xfd\xb6\x1c\xce\xa6\x33\xd9\xd9\xce\xbb\x26\x90\x4d\x43\xfc\x17\x1a\xc9\xe0\x89\x1b\x3f\x19\x61\xb2\x0b\x30\x59\x4d\x79\xf2\xbb\x39\x64\x37\x3f\x6a\x1f\x38\x36\x1f\x7d\x5d\x30\xa6\xde\xfe\xa8\x45\xde\x74\x47\x21\x84\x0a\xee\xd9\xc8\x79\xc2\x17\x07\x7b\xd4\x06\xeb\x6b\x5b\xef\xe5\xce\xa9\x1b\x18\xac\xed\x11\x99\x11\xbc\xf3\x16\x18\x88\x5e\xbe\x13\xb7\xb7\xa8\xed\x17\xee\x2c\xe1\x13\x46\xc3\xfc\xca\xaf\x5a\xad\xac\x60\x11\x34\xce\xa1\xdb\x14\x8b\xd9\xcc\xf2\xbc\x85\x75\x83\x44\x05\xc6\x27\x12\xaa\x45\xc9\x48\x60\x86\x09\x42\xdd\xbd\xa7\x9d\x15\x90\xa0\x39\x12\x17\xcd\xc5\x24\x92\x83\x40\x70\xc5\xb8\x08\x77\x16\xfa\x32\x17\xfd\x7c\x5e\xee\x9e\x53\xbc\x50\xe4\x84\x8b\xcf\xb3\xe0\x42\x8f\xb5\x0e\x99\x9a\xc3\x0d\x58\x83\x15\xe2\x7b\xa7\x06\xd0\xd7\xc4\x4e\x82\xd7\xe7\x19\xfc\x20\xcc\x97\xc6\xc4\x71\x37\x05\x77\x81\xdf\x2a\xf8\xc3\x7c\x71\x4f\x6a\x1f\x31\x8c\x23\x96\xc6\x04\x35\x90\x28\xb1\x50\x63\x22\x86\xe5\xa8\x98\x3b\xa3\xaa\x64\xd9\x45\xb2\x99\xd3\xff\xb2\x86\x78\x52\xea\x4b\xbb\x0d\x64\xe0\x10\xc3\x06\xb2\xf6\xde\x2c\x1b\x48\xfb\xa5\xb4\xf9\xe3\x92\xf3\xec\x5f\x9b\xe5\xa7\xee\xef\x60\xfe\x48\x5f\x31\xec\x09\x67\xa6\xec\x09\x39\x98\x7a\x0f\x88\xe7\xca\x78\xc9\xc6\x3c\x58\x71\xf1\xf4\xec\x21\x8a\x9c\xdf\x1e\xf0\x63\x2a\xe1\x57\xb9\x82\x06\x23\x17\x7e\xc6\xa2\x50\xd7\x45\xc5\x74\x92\x13\xdf\x42\xc2\x53\x09\xaa\x0f\xa1\x0f\x58\x59\x48\x07\x26\x66\x99\x65\x6f\x45\x47\x0e\xcf\xd8\xdc\x4b\x49\x3c\xb6\xf3\xf1\x07\x6c\x7f\x16\x37\x9f\xfe\xc8\xc1\x6b\xeb\x89\x79\x8a\x18\x1e\xd0\x67\x57\xce\x5f\x74\xf5\x95\x97\x5f\xbd\x84\xed\x79\x02\x7d\x74\xea\xc0\xcb\xe7\x94\x2f\xbe\x27\xe0\xb6\x4c\x7e\x0e\xfa\x80\x03\x4f\xc7\x20\x74\x10\xfd\xfe\xfc\xa6\x87\x9f\x7d\xec\xe9\xad\x19\x9f\x8e\x1a\xea\xd3\x31\x9c\xda\xe8\xbf\x42\x93\xe0\x21\x62\xb7\x63\xc6\x74\x8c\xcf\xe3\xef\xa0\x7b\xb5\x11\xaf\xff\xab\xb0\x1c\xec\xc4\x3a\x53\x11\x27\x8a\x8a\x22\x58\x39\x3c\xe8\x16\xb1\x84\xeb\xcf\xb1\x9c\xcc\x81\x9d\xe7\xf0\xba\xd7\x99\xc6\x84\xae\xd8\xcc\x8d\x09\x9b\xab\xb3\x9b\x61\xd3\xe4\x0a\x28\xcd\x40\x63\x19\xe7\xf0\x58\xd7\xcd\x85\x7e\x98\x3e\xa6\x3d\x07\xd8\x55\xd7\x5e\x25\x43\x02\x6d\x52\x96\x5e\xf3\x07\xfa\x05\xfd\x8a\x7e\xc4\xd2\x9e\x0d\x14\xee\xd2\xf9\xf3\xdf\x9a\x7b\xd9\x5b\x94\x73\x59\x41\x7f\x8b\xd2\x10\xdc\xae\xab\x69\xbb\x46\xc7\x8b\x34\xbb\x9d\xc8\xb3\x8c\x80\x97\x96\x52\xa2\xf6\x57\x71\xbb\x54\xdc\x2e\x55\x35\x83\x19\x2f\x32\xb3\x0b\x77\x24\x01\x4a\x37\xed\x4a\x4f\x8c\x5e\x97\xc2\x3f\x4f\xb7\xa7\x8a\x70\x51\x2c\x9a\xe1\xb9\x19\x87\x99\xbf\x0c\x6e\xac\x9d\x1d\x43\xbf\xfc\x71\xcd\x52\x05\x6d\x82\x84\x7c\xd5\xb5\xdc\xa5\x58\x51\x47\xbf\xe1\x9f\x7f\xbf\x75\xd9\xdc\xb7\xfe\x36\xaf\x43\x0c\xe2\x7a\x3a\x9e\xab\xf1\x9a\x59\x4d\xc7\x77\x57\x66\x7c\x57\xd3\xf8\xc7\x82\xb4\x8f\x24\x89\xd1\x64\x6c\xcc\xc0\x78\xae\x85\x11\x44\xc6\x66\x12\x44\xb3\x8d\xb3\xcb\x66\xb3\x04\x3c\x2f\x91\x94\x84\x12\xc7\x88\x7a\x1a\xa3\x43\xeb\x46\xa9\x20\x82\x2f\xc4\x08\xf5\x20\x67\xb1\x9a\x10\x40\x1b\xfe\x89\x36\xa0\xe3\xb0\x0a\x06\xe3\x9f\x95\xfc\xd2\xe4\xc7\x6c\x9f\x13\xf3\xb0\x0c\xf9\x3b\x6b\xa1\x01\x93\x40\xda\x26\x9c\x4d\xc7\x30\x1e\x8f\x08\xa2\x5d\xd3\x54\xfc\x6e\xab\x8a\xe7\x57\x73\x89\x01\xac\x16\xb2\x0d\x09\xbb\xa4\x80\x15\x0f\x9e\xab\x83\x6a\x53\xdf\xf9\xed\x31\xa0\x70\x29\x11\x07\x96\x0b\x6b\x1c\x24\xf3\x4a\x65\x0d\x37\xed\x43\xf4\x9d\xfa\x3b\xcc\xd9\x5e\x67\x55\x2b\xb7\xc0\x25\xbf\xeb\xdc\xe5\x77\x4d\x3b\xf1\xad\xf0\x6d\xf2\xbd\x67\xa6\xcd\xdd\x84\x5b\xb4\x87\x9d\x73\xfe\xdd\x78\x6f\x41\xca\x6f\xc7\xc7\xe4\x31\x13\xe3\x25\x9a\xdd\x1c\x96\x65\xdd\xee\x67\xec\x56\x86\x2b\xc8\xc7\xfb\xcb\x6d\x53\x35\xb5\x21\x61\xd6\x34\xce\x1e\x70\x07\x1b\x12\x6e\x95\x8b\x66\x71\x87\x54\xfe\xe5\x0c\xe1\xed\x62\x48\x4d\xbb\xf7\x04\x81\xa0\x66\x47\x08\x44\xf1\xc9\xdd\x7c\x9e\x78\x02\x7d\x3a\x7f\x3e\x38\x7f\xbe\x17\xdd\xd0\xc5\xd5\x67\xfe\xee\x8b\x2f\xde\xcd\xbe\x78\x0c\xdc\xb7\xa2\x5f\xef\xcb\x78\xfb\x90\xf9\xad\xc5\xf3\x7b\x19\x99\x5f\x18\x99\x3d\xdf\x6a\x01\x99\x6f\x15\x6b\x0f\xac\x95\xad\xcd\x2a\x57\x40\xca\x91\xeb\xb0\x9c\xed\x9b\x8e\xab\x96\x3c\x7a\x01\x89\xab\xd6\x24\x53\x12\x0f\x3c\xc3\x78\x9f\x02\x4d\x13\x0a\xc8\x91\xd9\x86\xed\x76\x0d\xac\xc6\x31\x93\x96\x89\x03\x11\x44\xf1\x43\x35\xf5\x8c\x19\x80\x60\x5b\x6f\x8b\xdf\xce\x82\xcd\x46\x6c\xf6\xaa\xa8\xda\x19\x4b\x3e\x66\xee\xae\x32\x57\xdc\xd5\xec\x9a\xe9\xba\xc9\xb5\xde\xb5\xcb\xb5\xd7\x65\xf9\x58\xc5\x57\x66\xe2\x6f\x7b\x5d\x42\xd8\xd5\xe8\x5a\xe2\xda\xea\xfa\xca\x25\x30\xb8\x64\x33\x2e\xb5\xcb\x75\xd4\x25\x3e\xf8\x7f\x28\x33\xef\xff\x50\x66\x44\x98\xbe\x9f\xeb\x84\xa7\xd0\x7e\x90\x00\x8c\xa7\xed\x27\x71\x33\xde\x0f\x31\x66\x56\x3c\xee\x92\x20\x18\xcc\x8d\x05\xc3\xb9\xb9\x76\x89\xcb\xcf\xc3\xdb\xc1\xd7\x94\x08\xf3\xcd\xfc\x7a\x9e\x63\x78\x50\x39\x9e\x8f\xe8\x4c\x38\x82\x45\x9c\x08\x97\xab\xd3\x84\x76\x66\x4e\x51\xac\x56\xbd\x29\x61\x75\xa4\x7c\x80\xc8\x56\xaf\x6f\xf7\xeb\x37\xa2\xc3\x99\x8e\x86\x06\xc3\xda\x4b\x39\x4a\xb0\x43\xe2\xa9\x01\x06\x3d\xa6\x5a\x1b\xf1\xf0\x17\x16\x24\x67\xfc\xeb\xf3\x8f\xbf\x59\xf9\xc2\xf0\x37\x2b\xc7\x97\x9e\x35\x76\xde\x4d\x4d\xff\x3c\x0d\x7d\x8a\xea\xf8\xa7\xf8\x7b\xd0\xd6\x8a\xca\x8f\x7f\xa8\xfe\x63\xff\x69\x4d\x8f\x0c\xed\x33\xed\x56\xf3\xcd\x33\x0b\x72\x92\x17\xf1\xf7\xa4\xe3\x9f\x49\xbc\x7f\x8b\xe4\x51\x0b\x4d\x08\x66\xd1\xa8\x9d\xdd\x98\xb5\x04\x9e\x02\x51\x74\x16\x82\xe5\x99\xb6\xc7\xe2\x6d\x16\x91\xe1\xf2\x43\x72\xbd\xdc\x20\x73\x8a\xdc\x24\x2f\x96\xb7\xc8\xef\xc9\x47\xe4\x36\x59\x7a\xdf\x2e\xc3\xb7\x76\x39\x57\xee\x2d\x8f\x95\x2f\x91\xaf\x94\xef\x95\x77\xc8\xff\x96\xcd\xb9\xf2\x40\x7c\x61\x0a\xbe\x74\x23\xbe\xf4\x18\xbe\xf8\xae\xfc\x85\x8c\x64\x9b\x1d\x5f\xbc\x12\x5f\x78\x17\x97\x42\xb2\xf4\x84\x2c\x4f\x96\xd9\x57\x65\x39\x28\xf7\x92\xc7\xc8\x17\xcb\x8b\xe4\x7b\xe4\x17\xe5\x9f\x65\x73\x50\x1e\x80\x2f\x4c\xc6\x97\x6e\xc0\x97\x1e\xc5\x17\xdf\x91\x0f\xc8\x49\xd9\x46\x9e\x58\x84\x2f\xbc\x83\x4b\x25\x65\xe9\xef\x36\xf9\x6c\x99\x7d\xd0\x26\xe7\xc8\x25\xf2\x68\x79\x86\x7c\x85\x7c\xb7\xfc\x82\xfc\x93\x6c\xce\x91\xfb\xe3\x0b\x67\xe3\x4b\xd7\xe3\x4b\x9b\xf1\xc5\xb7\xe5\xcf\xe5\x56\xd9\x46\x9e\xb8\x02\x5f\x78\x1b\x97\x6a\x95\xa5\x79\x0c\xe9\x14\xbb\xd2\x40\xdd\x6c\x90\x2f\xc5\x1d\x5c\x27\xef\xc4\x1d\x34\xd3\x4e\xc7\xf7\xe3\xdb\x97\xca\xab\xf1\xc5\x2d\xf8\xf2\x7b\xf2\x97\xb8\xe7\xb6\x4e\x03\x81\x35\xef\x5e\xb8\x59\xdc\x05\xa4\x23\x03\x68\x57\x6e\xa0\x5d\x39\x20\x9b\x65\x7c\x81\xb4\xd9\xe8\x08\xe9\x06\x69\xb9\xf5\x1e\xfc\x87\x85\xf4\x3b\x77\xca\x29\xd8\x4f\x32\xcc\x4d\xb4\x11\xab\xb3\xde\x67\xaf\x53\xf0\xbd\x26\xda\x34\xe3\x2a\x79\xad\x65\xa7\x0c\xac\x31\x33\xa4\x81\x5f\xca\x62\xd7\x3a\xd6\xd1\x46\x7e\x49\xcb\x2b\xe4\x5d\x46\xef\x8c\x4b\x26\xbc\xe0\x9b\x8c\xf0\xaf\x2c\x60\x91\xa6\x6c\x94\x91\xcc\x6f\xbc\x23\x8a\x19\xb2\xc5\x09\xad\x26\x74\x64\x21\xd6\xbf\x7c\xcc\xa2\x78\x83\xd3\xe3\x31\xb1\x98\x43\xc8\x9c\xc9\xcd\x71\x01\xbf\xd3\xd3\x94\x08\x39\x41\x71\x2e\x76\xae\x76\x6e\x71\xb6\x39\x05\x0f\x96\x4c\x19\xab\x55\x6b\x4a\x28\x76\xbc\x4d\xec\x76\x2b\x4f\x4c\x99\x61\xb6\x8c\x65\xc3\x6c\x33\x3b\x93\x5d\xcf\x7e\xc5\x1e\x65\x45\x96\x15\x1c\x34\x5c\x64\x56\x37\xf1\x22\xb3\x8a\xbb\xec\x91\xfc\xb0\xc3\xc3\x46\x52\x20\x0a\x0e\x43\x77\x33\x78\x39\xe7\x00\x7e\x7a\xeb\x46\x54\x87\x1e\x47\xb7\xc2\x39\x30\x06\x0e\x2e\x69\x8b\xbc\xb0\x74\xfb\x5b\x16\x36\x9a\x3c\x20\xef\xdd\x07\xb6\x16\x74\x31\x2c\x85\x33\x61\x32\xcc\xa6\x87\x0f\x2f\x6d\xfd\xee\x85\x37\xe8\xbe\xe8\x87\xfb\x27\x52\xbe\x58\xdd\x1d\x96\x42\xdb\x87\x78\x97\x34\x53\x1a\x97\x8a\xe9\xdc\xc3\x30\x5f\x90\x53\xc9\x54\x4c\xe7\x33\x6d\x28\xbe\x95\xc6\x75\x86\x48\xa2\x97\x7a\x3a\x19\x5b\xe8\x98\x4b\xfb\x42\x74\x7a\x56\xd3\x59\xc0\x6b\xa7\x94\xde\x5e\x47\x6f\xe3\x09\x6c\xa0\xd3\xb6\x13\xdf\x11\x37\x76\xf8\x46\xe6\x7f\x1d\x2e\xc3\x93\xfa\x16\xd3\x15\x2a\xcc\x26\x75\xad\xc6\x77\xf9\x52\x5c\xc7\x97\x64\x83\x36\xe0\x3b\x5c\x7d\x9b\x4c\x97\x16\xbd\x02\x8c\xdc\x28\x2f\x91\x6f\x92\xd7\xcb\x5b\xe5\xaf\x64\xa9\x59\x9e\x49\x3f\xee\x92\x8f\xca\xe2\x12\xfa\x61\x2f\xbe\x2e\xe0\x99\xee\x02\x35\x33\xab\x63\x5c\x6a\xa8\xed\x27\xee\x10\x1d\x87\x5e\x54\x06\x35\xb5\x1d\x35\xcd\xa7\xf6\xa8\x18\xd3\x1c\xaf\x95\xdc\xde\x48\x44\xc8\x61\xec\x82\x9b\xe1\xf3\xf3\xbc\x98\x10\x2a\xde\xc5\xde\xd5\xde\x2d\x5e\xde\xc3\x78\xa1\x27\xe7\xf5\xba\x23\x6e\xa9\x39\xe1\xe6\x6c\x5a\x73\xc2\xe6\x10\x22\x58\x3d\xd4\xdb\x79\x66\xfb\x6c\x4f\xe9\xc6\x95\x80\xd8\x29\xb1\xec\x6f\x81\x0c\x44\xbf\x4e\xb8\x7b\xa4\xdc\x4d\x78\x26\xfe\x10\x36\xcd\x5f\xf8\xf3\x7d\xc9\x31\xe8\xfe\x3e\xd5\xd3\xee\xbe\x61\x58\xae\x3d\x58\x77\xca\xa0\xe8\x10\xee\x5a\xd8\x7c\x18\xa1\x8f\x56\x5d\x87\x1e\x86\xb3\xb1\x00\xb5\x65\xc9\x2b\x33\xf8\x1b\xd0\x46\xb4\x02\xed\x5c\xa1\xfd\x21\x5d\x0f\xfd\x8e\xc2\xa7\xc9\xf7\xf6\xbf\x39\xf9\x3c\xf4\x37\xda\x37\x3c\xe7\xa6\x6a\xdc\x37\x07\xee\x5d\x73\xbc\x4a\xf5\xf9\x64\xc1\x89\xe5\x21\x13\xf5\x61\x0c\xe6\x78\xbd\x92\x0d\xf7\x44\x55\x6c\x8b\x6d\xab\x6d\x5b\x6c\xb8\x87\x36\xdc\x43\x9b\xcd\x67\xb7\x70\x02\xe6\x0c\x66\x21\x7d\xe0\x48\xe4\x24\xda\xa5\x54\x58\x72\x37\xfe\x01\xa9\xbe\xb5\xff\xd0\x3e\x11\x95\x2c\x6c\xaa\x26\x7d\x7a\x20\x79\x80\x98\xe3\xd8\x18\x14\xc2\x69\x46\x5f\x92\xc0\xa5\xba\xc2\x9e\x9d\xdc\x88\x85\xa9\xf7\xd8\x3e\x59\x5d\x20\xfc\x0b\xcb\x73\x0b\x71\x1f\x5c\x44\x2b\x37\x49\xa0\x28\xaa\x4b\xd1\x55\x49\xf5\xb8\x19\xdd\x81\xb9\x12\xb1\xb5\x02\xc7\x49\x0e\x4e\x95\xa8\x48\x47\x85\x96\x4e\x81\x42\x69\x7e\x44\x3d\x16\x88\x37\x72\xda\x6e\x48\x39\xd0\xfe\x57\x0e\xff\x8c\xbe\x5b\x71\xeb\xed\x0f\x66\xd8\xce\x4b\xa7\x7d\x73\x04\x85\xe1\xa5\xdb\xae\xac\x4a\x36\x51\x6e\x63\xec\x21\xfe\x7b\x22\x4b\x70\x6f\x51\x59\x02\xc1\xe6\x94\xbf\x8a\x03\xcb\x12\x8e\x53\x1d\x6e\xc6\x9a\xed\xdf\xb2\x02\xcb\x11\x35\xb4\xfc\x1b\x29\xd9\x23\x6a\xc8\x1e\x0e\x52\x5e\x7d\xa6\xed\xf6\xed\xaa\x03\x4c\xd9\xb2\x47\xdb\x9f\x78\xdf\x0a\xd2\x40\xfc\xcc\xbe\xff\x92\x67\x8e\x63\x35\xfa\x14\xf2\x8c\xd3\x89\x9f\xf1\x3c\xd3\x76\x6c\xbb\x27\x68\x55\xda\x9f\x21\x32\x2f\x9a\x2e\x90\x79\xb6\xc2\xf0\xb8\x53\x60\xad\x8c\x88\x65\x77\x96\xb3\xc9\x20\x34\x27\x2c\xac\xce\x3c\x03\x5a\x7c\x2f\x16\x7c\x1b\x65\x18\x2a\x43\xb1\x0c\x4e\x19\x4e\xc8\xb0\x5f\x86\xe7\x65\xd8\x28\xc3\x32\x19\xe6\xc8\x30\x95\xde\xad\x94\x21\x40\x76\x3c\x5c\x70\x4c\x86\xef\x64\xd8\x2b\xc3\x6e\x19\xee\xa2\x25\xce\xa2\x0f\x1f\xa5\xd7\xb7\xcb\xb0\x4a\x86\x85\x32\x9c\x2a\x43\x1e\xad\x71\x1f\xad\xee\x91\xf4\x75\x5c\x5d\x63\x56\x8d\xbc\x0c\x35\xfb\x69\x5d\x8f\xd0\xea\x66\xd2\x12\x13\xe8\xed\x13\xb4\xc6\xb7\x64\xc0\xec\x60\x8d\x0c\x17\xd1\x4a\xfb\xd1\x97\x9d\xa0\xf5\xee\xa6\x6d\x9c\x40\xaf\x18\xad\x93\xd8\xa6\x29\x5d\x1c\xb7\x4e\x1e\xff\x7f\xf2\x7b\xd4\x7a\xbb\xbb\xb8\xd3\x31\x75\xfb\x32\x66\xcf\x45\x05\x78\xd1\x5e\x00\x41\x54\x88\xa6\xc3\xed\xc2\xd2\x13\x97\xf1\x37\x1c\x5f\x8c\xa6\x77\xc5\x23\x32\xf6\x9c\x80\xb5\x02\x8a\xf1\x3c\x29\x5e\x8e\xc5\x44\x3c\xd9\x26\x7c\xd1\xe3\xb6\xe0\xd5\xaa\x58\x16\x5b\x56\x5b\xb6\x58\xf0\x56\xb3\xe0\xad\x66\xb1\x38\x44\xd1\xdc\x94\x10\x39\xc1\x41\xc8\x48\x99\x07\x26\x77\x56\xaa\xba\x89\x2a\x4b\x6d\x35\x57\x07\xc2\x21\xcc\x23\x9b\x2c\xc0\xe7\x27\x59\xf8\x22\x45\x2a\xe6\xc3\x8d\xa9\xfd\x25\x2c\xfd\x16\x6d\x4b\x6f\xac\x93\xe0\x26\xb5\xa4\x71\x93\x80\x24\xae\xec\x82\x9b\xa4\x91\x03\xe9\x14\x6e\x52\x4b\xb2\xa1\x23\x6e\x92\x8e\xd7\xe0\x8d\xf8\x79\x3b\xf5\xe2\x8e\xb9\xcc\x9a\xcc\xb1\xa2\xc4\x28\x66\x59\x52\x58\xdc\x7b\x19\x53\x4b\x19\xab\xf1\x26\xc1\xd4\x8c\x7b\x2a\xb1\x78\x51\x92\xb1\x4f\x59\x00\xbb\xe1\x8c\x15\x44\xff\x21\x50\x91\x94\x46\xe2\x39\x91\x44\x56\xe2\x3f\x7c\xf6\x78\xeb\xfc\xe3\x77\x8f\x9c\x19\x1c\xc0\xb9\xd0\xb7\xe8\x78\x28\xd8\x54\x79\x2c\x39\x07\x6e\x47\xd3\xd9\xeb\xaf\x86\xa5\x6f\xc3\x8b\x27\x2e\xe3\xee\xf8\xf1\x6d\xb4\xea\x92\x76\x1c\x9b\x0c\xb6\x12\x03\x6d\xc7\x19\x46\x1a\x86\xdb\x1a\x86\xaf\xe2\x6d\x6e\x8f\x1e\x0e\x2b\x44\xe0\xb7\x5a\x88\x5e\x18\xf4\x7b\xa4\x48\x4e\x20\x10\xbd\x25\x0a\xcb\xa2\x30\x3b\x0a\xcd\x51\x18\x1f\x85\xa1\x51\x28\x8f\x42\x5e\x14\xd8\xa8\x1e\x65\xff\x13\x85\xaf\xa2\xf0\xcf\x28\xec\x8e\xc2\xb6\x28\x6c\x8c\xc2\x55\xf8\x01\x76\x4e\x97\xd2\x2a\x79\x00\xce\x3f\x16\x85\x6f\xa2\xb0\x2f\x0a\x7b\xa2\xf0\x8f\xe8\xb6\x28\xbb\x86\x3c\x01\xb8\xfc\x39\x51\x98\x10\x85\xe1\xb4\xbc\x33\x9a\x17\x65\x71\xf1\xec\xd2\x46\xed\x6b\x49\xd9\x65\x51\x76\x1a\xa9\x7a\x42\x94\x35\x2a\x77\x47\x81\x8f\xc2\xef\xa4\x15\xfb\xa2\x2c\x2e\x09\xeb\xa3\x80\x6b\x5e\x12\x85\xa9\xd1\x39\x51\xb6\x91\x36\x24\x1c\x2d\x8b\xb2\xce\x28\x30\x51\xa8\x39\x1a\x85\xef\xa2\xb0\x97\x74\x6d\x63\x74\x77\x94\x9b\x19\x3f\x83\x94\x85\x46\x52\xdf\xd0\x28\xcb\xd0\x97\xef\x25\xb5\xd0\xfb\x4b\x48\xeb\x70\x4d\x61\xdc\x0d\x95\xdc\x38\x1a\x65\x77\x46\x61\x66\x74\x7d\x94\x6d\x20\x55\x83\x12\x05\xc9\x2f\x49\xbc\x12\x02\xd0\x15\xc5\xad\x5a\xb8\x20\x9f\x23\x52\xac\xa1\xf2\x52\x92\x86\xb6\xae\x34\x03\x9b\x08\x53\x3a\x3a\xd9\x76\xe3\x3f\xdb\xd4\x39\x12\xe9\x2f\xb0\x3d\x3a\x6c\x7e\x7a\x8c\xe6\xa9\xcb\x06\x05\x27\x5a\x3c\x56\x3c\x80\x80\x3c\x71\x24\xfa\xb9\x02\x2f\xa8\x72\xa2\x4f\x73\xa2\x84\xaf\x8a\x31\x8d\xd3\xc3\x63\x74\xac\xd9\xef\x86\xd7\x7a\x5d\x76\x02\x4a\xf6\x5c\x72\x76\x29\xe4\x94\x9e\x7d\xe9\x1e\x28\x39\x71\x59\x2f\x78\x0d\xed\x46\x1b\x6a\x47\xb0\x53\x55\x5b\x72\x09\x67\x8b\xbe\x00\xb7\xa1\x17\xb6\xb5\xb0\x93\x92\x0f\x35\x6d\x87\xa1\xe8\x82\x17\xa2\xad\xc7\xd8\x25\x39\xc9\xbb\x0d\x7e\xd5\xbb\xed\x27\xfe\x7e\xe1\xef\x58\x3b\x5d\x16\x6f\x8c\xd8\xf3\x38\x8f\x57\xcf\x35\xe7\xf1\x5e\x8e\xcb\xcd\xe3\x8a\x0a\x23\x76\xd9\x2e\x63\xe9\xd2\x7e\xa9\x7d\xb5\x9d\x5b\x6c\x3f\x62\x6f\xb3\x63\x71\x52\x0c\x28\x1e\x2c\x57\x7a\x3c\x81\x80\xab\x29\x11\xe0\x19\xb1\x29\x51\xc6\x03\x51\xcd\x66\x62\xe5\xec\x28\x2f\xf0\x3c\xe6\xe3\xf5\xe5\x29\xc1\x32\xa3\x87\x11\x63\x18\x95\x2b\x99\xba\x8e\x7e\xc6\x46\xbe\x4a\x21\x9a\x57\x98\x9f\x32\xdf\x16\x53\x1b\x8c\x61\xeb\xcb\xaf\xce\xab\x28\xa7\x47\x1c\x24\x1a\x86\x67\xaf\xfc\x09\x7d\x3d\x0c\x4c\x67\xff\xb4\x74\xf9\xba\x87\xfa\xf5\xbb\xed\xa6\x85\x33\xf6\x8d\x46\xc7\x86\x81\xeb\xe3\x43\xe0\xbd\xf1\xba\xdb\xee\x47\x1f\x39\x5f\x7c\x6d\x72\xf2\xa2\x96\xf3\x12\xdf\x36\x4f\x3d\xab\xf9\x8f\x01\xef\xec\x79\x6d\xd3\xd2\xcd\x31\xf7\xe6\x65\xbb\xbe\x33\xfc\x37\x08\xbf\xa3\xb4\xef\xec\x78\xb5\x0d\x33\x21\x93\x2c\xb0\x2c\x39\xeb\xb1\xdb\x04\x9b\x20\x02\x67\x66\xf4\x66\x05\x1a\x15\x88\x2b\xb0\x44\x81\x99\x0a\xec\x52\x60\xbd\x02\x65\x0a\x84\x15\xcc\xdb\x21\x35\xa5\xb3\x49\x58\x07\x0d\x32\x2d\xed\x88\xbd\x49\x4c\x96\x64\x12\x9d\x78\xfa\x08\x1f\xaf\x81\x15\x20\x9a\xd8\xf3\x60\x34\x3a\x6e\x4a\xae\x13\x96\xb6\xbe\x73\xd1\x26\x7e\xf8\xf1\xc5\x5c\xfd\xd8\xad\x27\x5e\x61\xb2\xf8\xf0\xc0\x0c\x1f\x3e\x0e\xb7\x60\x9e\xea\x8e\xcb\x60\xb7\x63\xa6\xaa\x89\x9a\x87\x91\x32\x1c\xd5\xf0\x7d\xf9\x1e\xf7\x43\x67\x86\xc6\x23\x36\xab\x24\x5b\xac\x9a\x28\xb1\x9a\xa6\x4b\xba\xd3\x61\x91\x55\x96\x55\x5b\x12\x2c\xab\x5b\x31\x49\xe1\x8c\x86\x76\x8e\x36\xd2\x52\x60\x2d\x46\xa6\x16\xba\xe6\x80\xae\x39\x3b\x49\x1c\xb6\x12\x0a\x2b\xe7\x35\xbd\x0b\x25\xe8\x8f\x2b\x4a\xe1\x7b\xb4\x13\x5d\xe7\x1c\x1b\x44\x9f\x61\x09\xe8\xa1\x85\xb7\xe3\x65\x75\xd1\x8b\x31\xb2\xac\x64\x77\x72\x83\xb1\xae\xb0\x9c\x2a\x38\xa9\x2c\x57\x1a\xf7\x82\xaa\x3b\x4c\xaa\x83\x73\x39\x1d\xba\x0a\x58\x82\xe3\x44\x6b\x73\x42\x74\x64\xdb\x48\xdb\x3d\x1d\xbb\x11\x37\xb9\xff\xa2\x0b\x3a\xc9\x97\xcf\xa0\xef\xba\x8a\x93\xc7\x17\xff\x35\xee\x59\xf1\x49\x31\xc8\x6a\xfe\xdf\x31\xc8\xfc\xc9\xbf\xa3\xcf\xf8\xc7\xfe\x02\x83\xac\xb3\xbd\xaf\x33\x26\x18\x7e\x37\xe0\xfb\x32\x1d\xa7\xba\x78\x40\xb5\xc8\xb2\xd5\xae\x28\x36\xab\x15\x8f\x95\x6c\xb1\x88\x76\x2b\xc7\x88\xcd\x09\x26\x35\x54\xd9\x19\xbf\xcb\x0d\xe7\x6e\x0a\xed\x4a\xfc\xba\xa9\x4b\x2b\x71\x11\xc5\x73\xc6\xc2\xe9\x23\xae\xef\x39\x3e\x31\xa2\x74\x48\xbf\xea\xe4\x3e\xa8\x80\x65\xd0\x13\x8a\x93\xbf\x0e\xbb\x6c\xb5\x33\xe6\xfb\xbd\x67\x5e\xc3\x5c\x6e\x63\xf2\x0c\x76\xd3\x89\x17\x6f\xba\x86\x64\x3d\x1a\xd1\xf6\x9b\x78\x43\x06\x8b\x6c\x39\xc5\x22\x0b\xe7\x3b\xcc\x11\x85\xf1\x77\xc4\x22\x4b\x01\x91\x89\x0e\xb7\xa3\xc0\xc1\x69\x16\x87\xc5\x61\x76\xf2\x66\xc7\x1d\xc5\xb0\x8a\x42\x81\x41\x33\x05\xe6\x8a\x53\xf4\x2d\x03\xb6\xeb\x18\x85\xed\x7a\x9e\x62\x76\x9d\x45\x31\xbb\x8a\xe9\x2d\xc6\x80\x20\xdb\x47\x71\xbb\xd6\x53\xe8\xae\x39\x14\xed\xcb\x78\xf2\x44\x31\x1c\x2e\x86\xb7\xe8\x93\x6b\xd2\x70\x60\xd9\xf5\x1e\x4e\xd7\xbb\x8a\xd6\x9b\x47\x2f\xd6\x64\x6a\xdc\x48\x6f\x18\x35\xe2\x17\x86\xb2\x6a\xdc\x98\xae\x91\x6d\xa6\x55\x86\x68\x63\x8e\x14\xc3\x7b\xb4\x21\xab\xe3\x4a\x31\x5c\x5a\x0c\x4d\x14\x5d\xcc\x80\x0f\xcb\x22\xe0\x27\x63\x07\xdd\x71\x81\xce\x0e\xfb\x4d\x46\xb8\x45\xca\x85\xdb\xb0\x57\x76\x89\x15\xaa\xf8\x7f\xc5\x08\x9b\x7a\xef\xfd\x25\x15\xb7\x6f\x4c\x2e\x6c\x48\x63\x84\x0d\x01\xf7\x90\x34\x46\x58\x43\x72\xe1\x86\x3b\x2a\x4a\xfe\x7f\x62\x84\x11\x79\xfd\x0d\xea\x5b\x57\x1d\xf7\x12\x59\x5d\x60\x19\xab\x95\x95\x6d\x58\x44\x37\x0b\x2c\x16\xda\x0d\x99\x3d\x05\x31\xe9\xed\x12\x52\xdd\x2e\x9f\x56\x68\xfc\x7b\x27\x9e\xc3\xf2\x69\x1d\x04\x5f\x69\x17\x4f\x4f\x5c\x96\x4c\x61\x49\x5f\x42\xfd\x54\x96\x32\x1a\xd3\x2b\xee\xb6\x63\xf2\x67\x92\x34\xc9\xa1\xa7\xb4\x26\x05\x0b\x3c\x44\xbe\xab\xa0\x86\xde\x6c\xd7\x0a\xea\x83\x92\xf1\x0c\x22\x5e\x29\xdc\xbf\x0f\xbd\x7d\xf4\x00\xe4\x2c\x5e\x7b\xef\xe3\x44\x8b\xc3\x1a\x12\x7c\x85\xea\xef\x9d\x57\x45\xfc\x4f\x52\xfb\x5e\x5a\x4a\xf5\x90\xbf\xc7\xdb\x4c\x56\x89\xe7\xf0\xe6\xb4\x72\xb2\xcd\x4c\x32\xbb\x71\x0c\x87\x37\x9e\x7e\x55\x5a\xf4\x1f\x4f\x95\x83\x72\xaa\x3d\xe8\x54\x3f\xf8\x8f\x0c\x07\xa9\xb8\xbf\x47\x86\xad\x32\xfc\x43\x86\x9b\x64\xc0\xe5\x67\x67\x95\xaf\xa6\xe5\xdd\x32\x88\x32\x4c\xff\x46\x06\xa2\x9f\xec\xa2\xda\xc8\x7a\xaa\x23\x18\x4a\x4c\x80\x98\x0c\x00\x2b\x30\x5f\xd1\xfa\x8c\x02\x1b\xb3\x0a\x60\xe5\x22\x4c\x95\x96\xec\x62\xbb\xb3\xca\x60\x5d\x23\x4e\x75\x93\x4c\xb1\x5a\x5c\xee\x30\xd5\x52\x0c\x15\x07\xf7\x82\xc5\x0a\x4e\x99\x0c\xaa\x0c\x47\x64\x78\x4f\x86\x2d\xf4\x2a\xbd\x18\x0f\x13\x2d\xe5\x08\x7d\xf7\x7a\xda\x11\xe3\x0e\xae\xb4\x94\x2a\x30\xa6\xee\xc2\xb2\xbb\x45\xc2\xeb\x5e\x18\x6a\xfa\x4b\xbc\xbc\xb4\xc3\x54\x07\xb5\xa6\x22\x4b\xad\x59\x09\x41\xd8\x8b\xff\xbf\x0f\xc1\xf4\x92\x21\x5a\x4d\x7a\x7d\x9a\xbc\x78\x1e\x15\x58\x1b\xd7\x6c\x8a\x82\x79\xb8\xd5\x24\xf1\xbc\x09\x38\x4d\xb5\x13\x65\xb2\x8d\xcc\xa8\x35\x3d\xa5\x6b\x34\xb8\x4a\x83\xb9\x1a\x4c\xd5\x60\xa2\x06\x43\x35\xa8\xd6\x20\x4f\x03\xb7\x06\xbc\x06\x07\x35\xf8\x48\x83\x97\x35\xd8\xae\xc1\x3f\x34\x80\x9b\x34\x58\xa2\xc1\x1c\x0d\x9a\x35\x98\xa0\x41\xa5\x06\x56\x0d\x53\x2d\x0d\xf6\x6a\xb0\x5b\x83\xad\x1a\xac\xa1\xb7\xf1\xbd\x62\x0d\x9c\x1a\xe0\x5b\xdf\xa5\xef\x6e\xcf\xba\x7b\x2a\x7d\x58\xa5\x2f\x39\xaa\xc1\x57\x59\x35\x6c\xd4\xc8\x6b\x96\x69\x30\x93\x36\xaa\x91\x36\xaa\x8c\x36\xca\x28\x5f\xf3\x1d\x2d\xba\x91\xb6\x85\xc5\x2d\x89\x6b\x10\xa6\x75\xec\xa2\x97\x8c\x2b\x21\x0d\xda\x68\xad\xb8\xca\xf5\xe9\xeb\xb8\xb2\xfa\xb8\x99\xde\x64\xb4\x6e\x30\x1e\x66\x77\x8f\x7e\x78\x12\xbc\xba\x29\x59\x62\x6f\xc7\xb8\xfa\xb4\x6b\x44\x45\x7d\x17\xd5\x28\x7b\x22\x89\x96\x44\x26\xf3\x79\xfc\xff\x39\x4c\x04\x8e\xb7\x4f\x27\xa1\x02\x70\xbb\x71\xd6\xea\xc6\x3c\x7c\x73\x4a\x2f\x1d\x17\xef\x6d\xe7\x64\x87\xc3\x62\xe2\x4c\x58\x31\x23\x6a\x69\xca\x5a\x8b\xd5\x52\x19\xab\xa5\xb2\xec\xb0\x52\xc4\x52\xce\x84\xd5\x52\x93\x7e\x72\x95\x34\x4d\x90\xc8\xb9\xb1\xa1\x94\x56\x45\x34\x48\x69\xa4\xfc\x2b\x87\x11\xd1\x49\xfb\xa1\x5a\xf6\x08\xbb\x08\xeb\xa3\xb7\xc3\x25\xa0\x70\x8d\xfb\xf7\x10\xe3\xd5\x3d\xdf\x25\xdf\x43\x67\x51\x8d\x94\xa3\xb4\x63\x34\xa5\x89\x0e\xcc\xd3\xcf\x8e\xd7\x38\x3d\x26\x4d\x13\x18\x2c\x38\x7a\x38\x9f\xd7\xa4\xe2\x46\x9a\x16\x9b\x56\x9b\xb6\x98\x70\x23\x4d\xb8\x91\x26\x93\xe6\xc2\x7a\xb3\xd6\x94\x70\x0a\xfa\x51\x1f\x7c\x45\xe3\x95\x27\x93\x28\xcb\x8e\x26\xab\x93\x59\xe1\x3a\x28\xcf\xf8\xab\xd0\x40\x1a\x3b\x04\x0a\xe1\xa9\x94\xfa\xbc\x1e\xa6\x81\xc2\x32\xf8\x8a\xa1\x42\xa7\x4d\x53\x07\x53\xf2\x49\x96\xbe\x4f\xda\x3d\x31\x5e\x69\x63\x68\xab\x05\x97\xb3\xfb\x16\x1b\x0d\x16\xf4\xb8\x0b\xbe\x72\xc1\x4c\x17\x94\xb9\x48\x93\x67\x65\xdc\x99\xbb\x28\xfc\x27\x69\xaf\xa1\xec\xe3\x96\x75\xa7\xea\x67\x4c\x68\xc0\x54\x63\x79\x68\x32\xb5\x73\x2f\x8d\x8f\xb3\xc9\xb2\x47\xc4\x1a\xbd\xd7\xe3\xe1\x75\x2e\xe0\x17\x78\x2c\x78\x10\x74\xf7\xc5\x58\xa6\xda\x22\xb4\x09\x82\x87\x13\x04\x46\x71\x31\x4d\x09\xc6\xab\x7a\x59\xc6\x1b\xf7\x36\x7a\x97\x78\x77\x79\xf7\x7a\x45\xab\xd7\xeb\x72\x28\x36\xac\xa6\xd8\x30\x51\x30\xe3\xee\xf1\xd9\x07\x42\x15\xa5\x53\x52\x8a\xc8\x49\x6d\xdd\x99\x13\x60\xe2\x92\xa4\xa7\xad\xde\x5c\x8d\xce\xde\xbb\x7d\xaf\x9c\x3c\xc0\x46\x2d\x6f\x3e\xb9\xf4\x85\x48\xdb\x12\x38\x08\x63\xe0\x1c\xb4\x06\x6d\x45\x75\x1b\x5b\xa7\xef\x7b\xe3\x85\xef\xb6\xbe\xb4\xe8\xc2\x11\xb0\x02\xad\x46\xff\x40\x0f\xa2\x2b\xe1\xd6\x16\x74\x2c\x35\x07\x6d\x3f\x49\x3f\xe2\x3e\x92\x3c\x2e\x23\xe2\x05\xb2\xd9\x6c\xf1\xdb\x25\x27\x63\x91\x18\x2e\x12\xd6\x3c\x4d\x09\x8d\x97\x4d\xcd\x09\x19\x0b\xf2\x9c\x45\xe7\x83\x4d\x09\x3e\x25\x00\x52\x6f\x4c\x26\xdb\xfc\x90\x19\x74\x8a\x6d\xcc\xa5\xb6\x99\x9e\xf1\x24\x48\x85\x54\x48\x3f\xae\x47\xfb\xde\x44\x07\xd1\xc3\x39\xe8\x5f\xc4\xac\x09\x81\x18\x9c\x0e\x0e\x2c\x29\x4c\x41\x1f\x3c\xf7\xe8\xd6\x67\x77\x3c\xfc\xd8\x73\xec\x6b\x07\xd0\xf6\x6d\x70\x0a\x14\x18\xd6\x4d\xf0\x42\x6f\xb4\x14\x6d\xfd\x01\xb5\x31\x87\x7e\x46\xc7\x81\xb6\x3f\x96\xd1\x9b\x5c\x4c\x22\x5e\x6e\x03\xdd\x62\x31\xcb\x0c\x63\xe7\x79\x33\x70\x1e\x37\x68\x36\x0d\xf3\x6b\x0d\xcb\xd2\x92\xb3\x29\x21\x71\x16\x46\x57\x68\x18\x7c\xd8\x53\xe6\x59\xef\xe1\x26\xcf\x9a\x9c\x92\xaa\xb3\x81\xd5\xb2\x95\x41\x42\x34\x68\x2c\x4b\x5e\x05\xed\x0f\x38\x30\x5b\x27\x0b\x29\x06\x8b\x56\x6f\x02\xc7\x09\x76\x17\xfa\x14\x3d\x80\x9e\x8d\x2d\x5e\x04\x57\xa1\xe5\xa8\x95\x6d\x8c\x7e\xbc\xe6\x2d\xac\x01\xb0\x9e\xe4\x0f\xdc\xfb\x53\x67\xc1\xfa\x74\x8e\x88\x25\xd4\xdf\x61\x28\x6d\xfb\x14\xfc\x7d\xbd\xf0\x05\x5e\xff\x51\xa6\x3e\x1e\x89\x88\xae\x1c\x46\x51\x5c\x79\xb1\x88\xcd\xc6\x35\x24\x6c\x36\x73\x80\xd1\xcd\x0d\x09\xdd\x3d\x33\x0f\x9a\xf3\x60\xd6\xac\x2c\xcf\xfd\x6c\xd8\x83\xb4\x3b\x67\xca\x53\x83\x2b\xd7\x0d\xf7\x0d\xad\x52\x1f\x08\x79\xf9\x2e\x91\xb7\x83\xa4\x73\x0b\x66\x2e\x5e\xbe\x78\xfe\x15\xd7\xcd\x7d\xe9\xc4\x4f\x78\xf4\x8f\xa1\xc3\xe8\xcf\x8a\x4b\xb7\x82\x15\x36\x7f\x88\x66\x6d\x19\x2d\x9c\x0f\xbf\x6d\xbe\xef\xbe\xcd\x0f\xfe\x63\x3d\xfb\x34\x3a\x81\x8e\xa3\x3f\x50\x12\x86\xc0\x98\x87\x81\x7d\x76\xd1\xe8\xca\xc3\xee\xf8\xf9\xbb\x1e\x85\xbe\x24\x9e\x90\xe0\x1d\xdd\x45\x70\x64\x30\xc5\x09\xe3\xdd\xdb\x3b\xc8\xb2\x3e\x87\xd9\xa7\x28\xb2\x2c\x9a\xb9\x68\x44\xf0\x79\x7c\x9e\xf1\x09\x9b\x2f\xc7\xc7\xaa\x9c\xcf\x27\xdb\xed\xde\xf1\x09\xbb\x22\x2b\xe3\x13\x72\x17\xaf\x8c\xec\x71\x37\x7c\x7a\x0d\xa4\x4e\x8d\x64\x71\xa7\xa0\x13\x78\xeb\x42\x5a\x17\xf7\xa5\xb1\xec\xd8\x07\xe1\xa3\x25\x97\x2d\x5f\x75\x64\x7f\x72\x07\xf8\xbf\x5d\x36\x63\xf6\xca\x4f\xf6\x2e\x38\xaf\x79\x36\xdf\x17\xfd\x32\x65\xa1\x4b\x52\xaf\x9a\x71\x0f\x6e\x66\xeb\xe5\x43\x1a\x4f\x1f\x0a\x5b\x51\x6b\xdf\x51\x43\x06\xa6\xf0\x9a\xb8\x5c\xdc\xfe\x14\xd6\x39\x50\x9b\x5d\x43\x42\x50\x88\xb7\x4c\x17\xac\x73\x2e\x17\xad\x42\x07\xf9\xbe\x3b\x5a\x97\xf1\x46\x4c\x99\x1d\x4d\xe7\xff\x8d\x3f\x13\xa5\x6c\x4c\x3c\x87\xb7\x13\x8f\x05\x8e\xb8\x49\xd8\x44\x49\xb2\xa9\x9c\xd3\x61\x03\x3c\x87\x8a\x26\x12\xa6\x6f\xb6\x73\x26\xc1\x84\xeb\xcf\xf2\xdb\xeb\x62\xb7\x4b\xed\x9e\x18\x2b\x45\x04\xc3\x76\xe7\x30\x78\x14\x37\xf8\xa7\x21\xe7\xc1\x9a\xe4\x4b\xbf\x2d\x1a\x39\xbd\x94\xfd\xcf\x2d\xbf\x71\x57\x24\xdb\x5e\xdc\x81\xa6\xb3\x13\x67\xc2\x43\x70\x6e\xeb\xb2\xe4\xc3\x98\x5b\xa5\x7c\x6a\x7a\xd1\x35\x36\x92\xda\xeb\x8e\xe0\xfd\xf1\x22\x6e\x67\x84\xf9\x3d\xfe\x94\x16\xb6\x47\xcc\x26\xb7\x27\x1c\x89\x98\x3c\x02\x1b\xf4\x4b\x7c\x4e\x20\x10\xe3\x78\x3e\x1a\x64\xfd\x58\x7a\xb6\xb3\x58\xca\xb5\xdb\x39\xb7\x62\x56\x22\x39\x9c\xab\x94\xe0\x13\x94\xc6\x1a\x62\x8b\x63\xeb\x62\x3b\x63\x47\x62\xd2\x25\x4a\xac\x3e\xd6\x84\xbf\x6f\x89\xbd\x47\xbe\x97\xe2\x2f\x97\xe2\x9b\xef\xc5\x04\x25\x16\xa2\x25\x57\xd3\x92\x6d\x31\xd3\x00\xf2\xbd\x89\x7e\x7f\x0f\x7f\x97\xc8\xa3\xe4\xc1\x23\xa4\x2c\x79\x90\x3e\x66\x65\x62\x33\x63\x6c\xff\xe6\xd8\xde\x18\xab\xc6\x1a\x63\x4b\x62\xbb\x62\x47\x63\x02\x13\x0b\xe3\xeb\x5f\xc5\x78\x53\x97\xb4\x07\x34\x4b\x8d\x11\x77\x57\x91\xc2\xa9\xd1\x08\x9a\x56\x6a\xe9\x74\x3a\x48\x8f\x16\x72\x69\x1b\x16\xeb\xc1\xd7\x06\xb2\x69\x1b\x16\x27\xc6\xb4\x18\x7b\xc6\xe0\xd0\x97\xe8\x63\x18\x18\xab\xfb\x04\xf4\x15\xc5\xf5\xe5\x3d\x5a\x8b\xca\x07\xf4\x5e\x01\xfa\x27\x95\x45\x30\x10\x7d\xfc\xa5\x7f\x44\x2b\xbc\x61\x45\x25\x6c\xbf\xe0\x79\xb0\x08\xb5\x9d\x36\xb9\x90\x85\xcf\x50\x01\x5b\x90\x38\x03\x00\x5d\xdd\x12\x49\xbe\x0a\xfb\xac\xa8\x06\xaf\xab\xaa\xb6\x9f\xb8\x27\xf9\xb1\x4c\x21\x73\x59\x3c\xee\xf1\x6a\xb9\x5e\x7b\x24\x97\xe7\x2c\xf9\x3c\x97\xcf\xf5\x28\xa2\x26\x2c\xbc\x0d\xec\x01\x06\x53\x21\x0b\x87\x7f\x59\x79\x62\xb9\x72\x8e\x4f\x04\x54\x46\x1a\x97\x60\x78\x95\x67\x79\x9e\x71\x37\xf4\x20\xf6\xec\x72\x03\x3c\x2f\xc3\x2a\x52\x66\xab\x8e\x00\x90\x19\x67\x26\x21\xe3\x2a\x40\x91\x1e\x53\x16\x2b\x31\xcb\x3d\xcd\xd8\x4c\xf0\xf3\x13\x9f\xf7\xf8\x45\xbb\x68\x54\x63\x62\xf9\x7d\x6b\xaf\x19\x3b\x72\x7c\x93\xf4\xb3\xef\xd0\x53\xdb\x0f\x2c\x5a\xb8\xe4\x8e\x5f\x9c\xeb\xd7\x94\x9c\x72\x66\x43\x7c\xc2\xe8\xc7\x47\x8c\xe9\x3f\x64\xec\x60\xf7\xad\x77\xde\x75\xe5\x39\x57\xf9\x59\xfb\xea\xe9\xb7\x3d\x4a\xf6\xcf\x8d\x78\xff\x13\xec\x2b\x85\xe9\x19\x77\x0a\x26\x93\x24\x69\x32\xa3\xd8\x78\xbb\xe4\xc2\x4c\x10\x8b\x7d\x93\xd3\x48\x67\x90\x95\x58\x90\x6c\x67\xc3\xf8\x54\x5d\x83\xff\xc2\x1a\xbb\x08\xbb\x20\x88\x5a\xed\x22\x1a\x83\xf6\xe1\x5d\xeb\xef\xfd\x66\x21\x27\x9c\xd8\xc3\x16\x94\xdf\x12\x68\x3d\xc1\x13\x3f\x14\xfa\x2e\xe1\x98\x5e\xc0\xfd\x90\xb2\x41\x91\xc4\x4d\xc4\x06\xa5\xaa\x5a\x01\x38\x4c\x0e\x9f\x5d\xcc\xb2\x41\x91\xf2\x2c\x6e\x9b\xce\x0c\x8c\x07\xad\x76\x93\x4e\xcc\x4f\xba\x43\x32\x99\x64\x9b\xcd\x69\xb7\xaa\x2a\xcb\xea\x36\x97\x44\xb2\x37\x90\x36\x1a\x6b\x08\x2a\x52\xcb\xa9\xdd\x02\x88\xb7\xdf\x40\x2e\x6b\xb1\x44\x6e\x04\x7f\xcf\xa2\xde\x75\xd7\x80\xfe\x6e\x49\x5f\xbc\x36\xbe\xfe\x21\x54\x41\xe8\x02\x2a\x63\x03\x03\xce\x03\x0d\x5d\x3d\xbe\x0c\xaf\x85\x37\xad\x68\x10\x6e\x87\x0b\xef\xc5\xe5\x34\xee\xb4\x57\xdc\xcb\x6a\x8c\xc3\xaa\x11\xbb\x93\x86\xe9\x8c\xa6\x48\x72\x43\x42\x72\x33\x94\xda\x74\x60\xa2\xd4\xaa\x63\x49\xc5\x98\x18\x76\x27\xdc\x0e\x6e\x06\x7a\xb3\xaa\x7e\xe4\x25\x93\xf3\x9a\x3c\xbe\xe2\xda\x7e\xfd\x86\x72\xfd\xb8\x2b\xd0\x7c\xb4\xef\x8e\x21\x26\x61\xa7\x79\x3a\x94\xc1\xaf\x27\xf6\x30\x29\xda\x66\xf8\x52\x41\xff\xf8\x7e\x06\xeb\x1f\x82\xe1\x50\x65\xb8\x53\x39\x59\x2b\x2b\xda\x25\x45\x03\xd1\x75\xaa\x1b\xf2\xdc\x70\xcc\x0d\xfb\xdd\x70\x97\x1b\x96\xb9\xe1\x22\x37\xf4\x73\x43\xb1\x1b\x6b\xf3\xc0\xbb\xe1\x82\xef\xdc\xb0\xdd\x0d\x73\xdc\x30\x34\x7d\xf5\x84\x1b\x0e\xbb\x61\x9f\x1b\x9e\x77\xc3\x2a\xfa\xc0\x04\x37\x54\xd2\xd2\xf8\xe2\x1a\x37\x2c\x74\xc3\x54\x37\x18\x55\x5b\xdd\x50\x77\x82\x56\xff\x96\x1b\xb6\xba\x61\x23\x2d\xd1\xa9\xba\x23\xf4\xee\x4e\x37\xb0\x5b\xdc\x70\x93\x1b\x66\xba\xa1\xc1\x0d\x21\x37\x1c\x75\xc3\x57\x6e\xd8\x45\x2f\x2e\x76\x43\xb3\x1b\x1a\xdd\x50\xe6\x86\xb0\x1b\x14\x77\x57\xf5\xa1\xa9\x7b\xe8\x89\x4e\x8a\x43\xb6\xee\x68\x50\x12\x83\x82\x74\xa4\xc5\xff\x8f\x7e\x64\xc9\xeb\xf9\xbe\x9d\xfc\xc8\x0c\x4c\xc0\xe1\x34\x26\xaf\x1f\x56\x69\xb1\x64\xc5\x8a\xa2\x60\x11\x6c\x58\x81\x6d\x48\x84\x00\x16\xc3\x6a\x60\x01\x2c\x82\x8b\x4b\x2f\xc5\xd2\xec\x64\x11\x5d\x0f\xd4\x30\xad\xbf\x1a\xfc\x98\x77\x2f\xa2\xab\x6e\x02\x6c\x3e\xb1\x07\xde\x43\x7d\xf0\x4b\xba\xc1\xc8\x4a\xbf\x9f\xda\x12\x05\x91\x05\x11\x4c\x66\x89\x27\x48\x45\x22\x8d\x33\xed\x60\x4b\x4c\xbf\x87\x1f\x9e\xae\xff\xc4\x1e\xee\x0a\xca\xf0\x70\xdd\xd7\x12\xdf\x41\x7e\x1c\xae\xfb\xb4\xae\xbe\x9b\xf8\x5d\x44\x28\xd8\x46\xde\x05\x77\xc4\xdb\x38\x91\x15\x25\xce\x64\xe6\x5d\x9c\xc4\x48\x0d\x09\x46\x59\x6e\x86\x73\xcc\x30\xc1\x0c\x43\xcd\x50\x6d\x86\x02\x33\xfc\x6e\x86\xef\xcc\xf0\x91\x19\xf6\x98\x61\xad\x19\x70\x81\xb9\x66\x98\x96\xbe\x2b\x9a\x61\x7a\xe6\xde\x1c\x7a\x63\x62\xfa\x9e\x6e\x06\x2c\xdb\x1d\x33\xc3\x41\xfa\xfc\x53\x66\xf8\x87\x19\x6e\x31\xc3\xb2\xac\x92\xf8\x35\xe5\x66\xc8\x33\x83\x93\xd6\x65\xbc\x6c\x9f\x19\x76\x9b\x61\xbb\x19\x1e\xa0\xd5\x66\xca\xe3\x66\x0d\xa7\x95\x67\xca\xd7\xfe\x9e\xae\x3d\xfb\x01\xa3\x13\xd0\x68\x86\xb8\x19\x2a\x69\xf1\xa3\x66\xf8\x2a\x5d\xf1\x1a\x33\x2c\x31\x03\x3b\xd3\x1c\x2f\x80\x66\x33\x94\x99\x21\x6c\x06\xd5\x0c\x8c\x19\xf6\x9a\x61\x97\x19\x66\x9a\xc9\xf5\x38\xbd\x8e\x2f\x9a\xa6\x74\xb1\xc5\xa5\x16\x69\xd3\x49\x4f\x6c\x4e\x9e\x08\xa0\xeb\xb9\x6d\xda\x92\x91\x5a\xd9\x46\x66\x0c\x32\xc5\x7d\xb9\xf9\xe8\x7d\x3c\xc9\xef\x53\x81\x86\x23\x79\xf4\x18\x15\xcf\xef\x74\xbe\x2f\x9e\xcf\xb3\x29\x5e\xc4\x78\x34\x49\x7c\x54\x78\x1b\xcb\x0d\x25\x4c\x35\x6c\x88\xb7\xe5\x94\x5b\x2c\x81\xa8\xb5\x48\xef\xc5\xe8\x56\x86\xab\xad\xe9\x59\xc5\x55\x35\x24\x14\xce\x5d\x9a\xef\xca\xc7\xeb\xd9\xa5\x06\x18\x4b\x60\x59\x2d\xcc\xad\x85\x69\xb5\x30\xb8\x16\x2a\x6b\x21\x5a\x0b\xce\x5a\x10\x6b\xe1\x58\x2d\x7c\x54\x0b\x7b\x6a\x61\x5b\x2d\x6c\xac\x85\x5b\x6a\x01\x97\x9c\x43\x4b\x4e\xa8\x85\xa1\xb5\x50\x5d\x0b\x79\xb5\xe0\xa6\x85\xa7\x1f\xac\x85\xdd\xb5\xf0\x14\x2d\x6a\xd4\x38\xb1\x16\x86\xd3\x1a\xdd\xb4\x2e\x5c\x60\x1f\x2d\x83\xab\x4b\x15\x9a\x5a\x0b\x71\x5a\x07\x5f\x0b\xdf\xd5\xc2\xae\x5a\xd8\x5e\x0b\x6b\xe8\x4b\xca\xe8\x75\x95\xde\xaa\x3d\x5a\x0b\xfb\xe9\xa3\xc6\x63\x67\xd1\xb7\x1b\x8f\x1d\x4b\xd7\xba\x95\xde\xbd\xa9\x16\xcf\x66\x2d\x34\x92\x8a\xf1\x9c\x86\x6b\x21\x54\x0b\x6d\xb5\xf0\x25\xad\x7d\x7d\x2d\xac\xab\x85\xc5\xb5\xd0\x44\x5f\x80\xef\x2a\xb5\xd9\x96\xa9\xc9\x9d\x67\xf5\xa4\x16\xd8\x93\x4d\x63\xf6\x7c\x13\x08\xd7\x93\x81\x39\xa5\x34\x00\x12\x25\x95\x06\x8a\x24\xa0\x91\x19\x68\xeb\x42\x7c\x81\x80\x3a\xa5\x74\x04\x12\xcd\x97\xaf\xa6\xb5\x05\xf1\xd1\x37\xb6\x9f\x7f\x4f\x4f\x51\x44\x27\xd8\x09\x3f\x3e\xf6\xe2\xeb\x4f\x5d\x74\x67\x11\xcb\x82\x30\xe9\xd0\xa3\xbb\x5a\x27\x9c\x77\x6e\x4b\xcb\xae\x96\x0b\xd8\x6b\x5f\x6e\x9e\x7e\x7e\xf3\x2b\x6c\x14\xfd\x82\x3e\x6d\x69\xca\xbd\x1d\xb5\xb0\x89\xdd\x50\x04\x26\x90\x21\xff\x9c\xc9\xdb\x60\x55\x72\xc7\x6b\xe8\x4b\xf4\xeb\xa3\x3b\x9f\xd8\x85\x6e\x7a\x6d\x0b\xcc\x78\x79\xdb\x63\xbb\xc8\xda\xb2\x63\x3a\x34\x95\xae\xad\xb3\x52\xbe\xbe\xd3\xf9\x4f\x52\x58\xa9\x32\x2f\x49\x16\x8e\xb1\x98\xcd\x8c\x6c\xb3\x10\x51\xd9\x8a\x95\x6a\x62\x1d\xc3\x64\xc3\x95\x31\xc6\xd5\x77\x22\x8a\x15\x59\x16\x9c\xd5\xe0\x27\x54\xf1\x96\xdf\xb0\x9c\xbf\x8c\x50\x2c\x2a\x0b\x1b\xf9\x03\x28\xd6\xa5\xce\x94\xc5\x3d\x22\xd6\x0b\x41\x33\x6b\x4e\x87\x88\x05\xdc\x46\x2c\x82\x99\xd3\x12\x40\x07\x75\x2a\x23\xa9\x10\x9f\x6b\xfa\x0e\xc9\xb0\xe6\xc2\x45\xf7\xf6\x3e\x7d\x36\xf8\xd0\xa1\xd3\xef\x58\x75\xcb\x7a\x4c\x7e\xaf\xbc\x5b\x0e\xc3\x2f\x98\x02\xaf\xcb\xad\xbd\x7f\x2d\x3c\x95\xa2\xb9\xa2\x97\xf4\x0d\x1e\x8a\xb7\x99\x04\x33\xc3\x03\x08\x0c\x87\xfb\x26\xb2\x8a\x09\xeb\x19\x0d\x09\x70\x5d\x95\xf6\x19\x99\x28\xc3\xf0\x8e\x76\xdc\xdf\xa9\x1d\xf7\x23\x6a\x50\xdd\x4e\xed\xb8\x6b\x64\x58\x4e\xcb\x4f\xa3\x96\x55\x5c\x3e\x4a\x0b\xb3\x32\x4c\x3f\x96\x65\xf5\xdd\x96\xb6\xc0\xce\x4d\x1b\x61\x87\x53\x23\xac\x9b\x1a\x87\xbf\x4b\x57\xfa\x94\x0c\x0f\xc8\xb0\x36\x5d\xac\x93\x65\xd8\x68\x81\x51\xe1\x76\x5a\x72\x79\xba\xe4\x70\x5a\xcc\x49\xad\xc7\xc4\x9e\xfb\x29\x6d\x1d\xb1\xce\x2e\x4b\x1b\x68\xd9\x38\xb5\xf9\x32\x29\x9b\x6e\xbc\x94\x58\x75\x71\x81\xd5\x32\x34\x53\xf3\x6d\x19\x35\xdf\x7e\x45\x3d\x63\xb6\xd2\xeb\x19\xcb\x2e\x93\x6d\xd6\xcd\xa6\x6f\x4d\x69\x8a\x78\x72\xc0\xcd\xbf\x82\xdc\x9c\xfc\xbf\x6d\xbb\x3d\xb2\x58\xac\xe8\x3d\x3e\x0f\xf3\xc9\xfe\xf8\x7f\x3f\x10\xd3\x2b\x0a\xd3\x48\x63\xdd\x8a\x9b\x89\xcc\x0b\x4f\xc5\x35\x93\xd5\x6a\xb7\xcb\x86\x9d\x5e\xce\xd8\x76\xad\xe9\x95\x6b\xc6\xab\xf8\x16\x6a\x46\x9d\xa3\xc1\xb4\x2e\xb6\xdd\xdf\xa9\x61\x77\xb7\x06\xdb\xa8\x21\x75\x0d\x2d\x69\x58\x81\x27\x68\x30\x5c\x83\x72\x0d\xa2\x1a\xe8\xd4\xe0\x7a\xfe\xef\xd4\x8a\x9b\xb1\x04\x3f\x40\x1f\x58\xde\xb1\xea\x02\x5a\xf4\x18\xb5\x19\xef\xd3\x60\x8f\x06\x4f\xa5\x5f\x7f\x8e\x06\xc4\xf2\x5a\x99\x65\xc3\xc5\xd5\xed\xa7\xef\x5f\x43\xed\xbc\x8d\xd4\x64\x5b\x49\xed\xb8\x4e\x6a\x9b\xad\x39\x46\xab\xd9\x9a\x6e\xde\x92\x74\xdb\x32\xb5\x9c\xa0\x55\x3c\xaf\xc1\x5d\x1a\xac\xc2\xbb\x83\xdc\x8d\x47\x20\x40\x1b\xb1\x9f\xbe\xdb\x78\xa2\x1f\x35\x46\xe3\x27\x58\xc3\xe6\xdb\xd4\x79\x5e\x4e\x32\x75\xd9\xf4\xf3\xff\xec\xc9\x40\x25\xba\x94\x86\xfd\x3f\x6d\xbf\xab\xf1\x2c\x0f\x30\x66\xbb\x9d\x7a\xb4\x53\x10\xa2\xe7\x17\x60\x59\x7a\x09\x9e\x73\x1b\x26\x46\x03\xe2\x21\x9b\x59\x96\x25\x8d\xe3\x24\x8f\xdb\xe6\x1a\x9f\xb0\xd9\x24\x4c\x56\x1a\x12\x16\x2c\xce\x8f\x4f\x48\xae\x6e\xd3\x52\xa5\xc4\x49\x30\x10\x90\xa8\x99\xd7\x97\x31\x65\x70\x8f\x1e\xfe\xd7\xd1\x6f\x92\x3f\xa3\x55\xec\xea\x17\x16\xcf\x9a\x71\xf5\x8b\xec\xb5\x77\x6e\xbc\x6f\x13\x77\xc5\x0e\xac\x11\x15\x8d\x38\x6d\xec\x50\x26\x65\x6f\x11\x89\x2c\x67\xa1\x36\xde\xa1\xf1\x7c\x8b\x15\xaf\x35\xc5\xe9\xf1\x60\x62\xe9\xf5\x59\x1c\xe3\x13\x16\x8b\xe4\x32\x29\x92\x75\x7c\xc2\x29\xb9\xf6\xfa\x60\x89\x0f\x3a\x18\x74\xbb\xd8\x72\x33\x0d\x6a\x6f\x0e\x4d\xc0\xf9\xec\xe1\xff\xfc\xf1\x7d\xf2\x43\xf0\xef\xbb\x6a\xfe\x9c\x6b\x3e\xe4\x96\x81\x8f\x34\x6a\xdd\xc3\x98\xe6\xe1\x36\x8d\x1a\x37\x7a\x38\xca\x27\xe2\x21\x1e\x1f\x22\x63\xae\x4d\xb5\xab\x6f\x3c\x44\x5a\xa5\x70\x12\xe7\x74\xa5\x5a\x64\x34\x08\xb7\xc7\x05\x61\x57\x06\xc6\x2f\x0b\x38\xe1\xe4\x6d\xe9\xdc\x8e\xce\x6d\xa0\xbc\xa4\x12\xcb\xa1\x01\xac\x6f\x07\x99\xd9\xf1\x41\x16\x49\xf2\xa8\x1a\x5e\xbf\x8c\xc9\xc3\x85\x72\x4d\x0a\xa6\xf8\xbc\xd9\xec\x77\xfa\x31\xd9\xad\x04\x08\xc3\x12\x22\x70\xfb\xdd\xfd\x54\x90\x55\xb0\x72\x8a\x1a\x52\x59\x55\x50\x55\xa7\x13\xab\x63\x4e\x95\xe9\xa0\x68\x13\xbb\xec\xe4\x2c\x17\xe4\x2e\x68\x74\x0e\x9a\xc3\x34\xcb\x30\x9b\x49\x64\x4a\x62\xa8\x2a\x69\x0e\xd3\x0b\x2e\x90\xd0\x5b\x50\x25\x4d\x9f\xd6\x21\x97\xe9\xef\xcb\xfe\xb9\x04\xa6\xcb\x53\xcf\xbb\xea\xb6\x1d\x37\x2c\xea\x90\xca\xb4\xf9\x51\x32\xae\x6d\x3f\x89\xd7\xe0\x7e\xe9\x4c\x0e\x73\x7a\xbc\xcc\x2b\x8b\x0e\xc3\xfb\x54\x64\xb8\xdc\xa0\x0d\x0b\xd5\x8a\xad\xd4\x56\x6f\xe3\xec\x9c\xcd\xa6\x72\xaa\xbb\x21\xa1\xaa\x16\xc5\xec\xe2\x02\x59\x98\xb2\x9d\xe0\xd5\x3b\x04\xfe\x53\xa4\x4f\xa6\x30\x66\xec\x86\xea\xbc\x8a\x94\x91\x96\x1e\x5a\x8a\xd7\xa0\x43\x7f\x7e\x8d\x8e\xba\x76\xa3\x83\xe0\x7f\x3d\x04\xca\x67\x4c\x1b\xc8\xe8\xb3\x39\x97\xfc\x34\x67\xc6\xbf\xd9\x5c\xf4\x07\xfa\x18\x98\x6f\x89\xea\x81\x26\x7c\x7a\x08\x7d\x8d\x8e\x10\x5c\x99\xa7\x5e\x60\x58\xcc\xf1\x19\x3e\x07\xaf\x09\x99\x71\x32\xa3\xe2\xf9\x0c\xe7\xb4\xd9\xac\xc0\xb2\x9a\x28\x72\x24\x60\x8b\x73\x30\x0c\x5e\x1d\x78\xfa\xcc\x66\x65\x7c\xc2\xac\xd8\x32\xda\xc8\x5f\xd8\x60\x89\x33\x81\x91\x12\x80\x34\xd8\x11\x8b\xba\x9c\xfd\x80\x1d\x8c\x8e\xa2\x77\x60\xf0\xec\x79\xbf\xfe\x08\x87\xd0\x41\x76\xd7\x3b\x2f\xee\x85\x27\xd0\x18\xf8\x38\x70\xf7\xdc\x3b\xef\xc6\xcc\xf9\x09\xf8\xe4\xb6\xbf\x67\x74\x96\x5e\xc2\x17\x7a\x01\xb1\x8d\x69\x12\x33\x84\x79\x81\xfa\x94\xb2\xa1\x90\x56\xc0\xe6\x3c\xd3\xb6\x63\x7b\x4e\x88\xb3\x74\x88\x67\x31\x9e\xb9\x2e\xf3\xcc\x85\x0c\x31\x9c\xfb\xe3\x0a\xc7\xfa\xfd\x5a\x01\xc7\xe6\x5a\x73\x73\x3a\xc0\xc6\x01\x63\xc1\xb2\xf4\x54\x2c\x3b\x17\x30\x57\xc7\x8b\xa5\x3c\x9f\xdb\x6e\x77\xe8\x8a\xe2\x65\xf3\xf8\xa2\x42\x9f\xa6\x6b\xe3\x13\x6e\x3d\x27\x1c\xb6\x34\x26\xd4\x30\x30\x61\x35\x1c\x0e\x73\x66\x2e\x4c\x52\xc7\x46\xec\xda\x48\x3d\xac\x87\x15\x27\x39\x4a\xe0\x1b\x13\x4c\x60\x7d\x11\xdc\x54\x04\x47\x8b\x60\x66\x11\x1c\x29\x82\xc9\xed\xc0\xad\xc6\xc1\x7d\x71\x26\x88\xa4\x03\x64\x62\x45\xda\xb9\x38\x5a\x58\xe5\x21\x90\x03\x6a\x0a\xec\x3f\x56\x45\x0e\xee\xc9\x8f\x53\x4a\x43\xfe\x3b\x45\x6e\xd8\xd4\xe1\x15\xa7\x54\xbe\x34\x6d\x11\x3a\x74\xcd\x35\xe0\x83\x6a\xf4\xa6\x89\xaf\xdb\x3c\x6f\xf3\x33\x37\xa3\x49\xe6\x3d\xfc\xa0\x16\x76\x36\x04\xb7\xac\x4c\x7e\xcf\xdf\xf6\xf0\xaa\x55\x0f\xaf\xb8\x78\xfa\x15\x33\xf7\xbd\xdd\x7a\x7c\xf5\x9d\x24\xb6\x0c\x13\x29\x3a\xb6\xdc\x77\x74\x9c\xe6\x32\x9f\xa4\xfc\x7b\x45\xad\x00\xc4\x49\xa2\x99\x6f\xc7\xaf\x23\xb1\x7c\xa9\xfc\xc8\x01\xba\x6f\xcd\x66\x8f\x57\xd1\x75\x8e\xd3\x48\xae\x2f\x92\x90\x54\xe3\x15\xc5\xc8\x8c\x9c\xb0\x5c\x60\x61\xfb\x59\x40\xb6\x80\xd5\x62\x11\xd5\x66\x0f\x38\x3d\xc0\x78\x40\xe6\x3c\x1e\xfc\x8a\x54\xe6\xe1\xf4\xbe\x9d\x6c\x9c\xa6\x74\xb7\x6f\x33\xfe\xd6\x9d\x72\x27\x93\x84\xea\x7a\x2a\x7d\x72\xe7\xd4\xc9\x6f\x59\xa0\x0a\xbd\x65\x79\xcf\x48\xa0\xbc\xf4\x9f\x9d\xb2\x27\xff\xbe\x03\x1d\x32\xd2\x27\xe3\x31\x18\x89\xfb\x14\xe2\x1b\xb0\x9c\x3b\xd1\x88\xb7\xc3\x1d\xdd\x44\xe3\xed\x46\x53\xff\xe4\xcf\x30\x43\x39\x4f\xb8\x4e\x2d\x60\x7e\x35\x30\x08\xdf\x64\x40\x8c\x1f\x22\x71\x03\x04\x49\xd0\xc4\xd2\x98\x01\xe2\xe0\xbf\x0e\xf7\x8d\x91\xc3\x72\x99\x8c\x05\x64\x46\x56\xf1\xc7\xb8\xdc\x28\x37\x53\x47\x7e\xc3\x65\xff\xa8\x6c\xdb\x4b\xee\x94\xd1\x3b\x33\xf1\x1d\xc3\xab\xff\x2b\x72\x47\xa5\xcf\x92\x07\x88\xdf\x3f\x29\x6e\x4e\x97\x4d\x97\x24\xe5\x2c\xeb\xb2\xaf\x1a\xd7\xcc\xe1\xd4\x73\xe4\x29\x91\x49\xdd\x35\xee\x49\x17\x33\x59\xdf\x44\x52\xf2\x26\x5c\x0a\xb7\xd0\xb8\xc6\xf7\x33\x3e\x71\xcd\xa9\x78\x03\xde\xa8\x97\x54\x25\x74\x8d\x2e\xc8\x8e\xb6\xea\x12\xff\x89\x69\xa0\xab\xed\x27\x89\xe4\x95\xf1\x33\x31\xa6\x31\x5e\xc2\x6a\x8e\x40\x80\x09\x79\xac\x1a\xe3\xe1\xf3\xf3\x1c\xb1\xf1\x09\x87\x43\x67\x74\x68\x48\xe8\x69\x73\x5a\x00\x93\x15\x57\x3c\x3f\xe3\x09\xdc\x91\x1b\x77\x8c\x51\xec\x6a\x64\x8b\x18\x5c\x28\x3f\xc3\x9c\xa7\xa2\x7f\x76\x32\xba\x55\x80\x4a\xb8\x12\x3a\x92\xe2\x8d\x9d\x4d\x70\x68\x0c\x61\x52\x5b\x52\xfc\x89\xf2\x47\xf1\x30\xd5\x41\x02\x24\xf7\x8b\xee\x70\x28\x92\x87\xb3\x5b\x28\xfb\xc6\x6b\xdd\x14\xd0\x49\xe2\x14\x5d\x97\x6c\x9a\x22\x61\xaa\x68\x95\x5c\x59\x3c\xfb\x55\x02\xf6\xf3\x6a\x37\x11\x03\x19\x7e\x99\xfe\x69\xe7\x9b\x82\x9d\xf2\xcd\x3f\xd1\x7d\x84\x76\x43\x13\xf8\xb7\x92\xb6\x3e\x6e\xf0\x4f\xc3\x5c\x44\x4c\x47\x1d\xf8\xa8\x85\xe8\x68\x98\x66\x05\x99\x99\xf1\x61\x4c\x10\x0f\xa8\x64\x23\xf9\x3a\x08\xec\x89\x6e\xb1\x5a\x70\x1b\xad\x2e\x9f\x0f\x2b\x4e\xaa\x0f\x18\x9f\xea\x0b\xfb\x9a\x7d\x33\x7d\x4b\x68\x56\x36\x9f\xcc\x98\xb2\xd2\x1c\x64\xb2\x1b\x18\x9e\x88\x84\x46\xfd\x15\x81\x8a\xfc\x25\x65\xe2\x46\x77\x47\x92\xd8\xea\x6e\x48\x51\x72\x81\xe1\xf7\x46\xed\xbf\x94\x16\x1d\x36\x68\x11\xd4\xa7\x63\x0d\x88\xb9\x78\x8c\xc3\xcd\xd8\xb2\x63\x0d\x0c\xfb\xf2\x17\x69\xfb\x32\xe6\x0b\xff\x34\x62\x0d\x5c\x2e\x5c\x5e\x7f\xa6\xed\x9e\xed\xba\x4b\x91\x3a\xf0\x05\x6a\x2f\x21\x36\x69\x62\x2f\x21\x36\x69\xe6\x3b\xe3\x19\x82\x0a\x0a\xbe\x67\xda\x5a\xb7\xfb\x42\x16\xbd\x43\xac\x01\xd1\x7b\xa9\x3d\x10\x1e\x88\xcb\x16\xab\x80\xd5\x41\xb0\x9a\xb0\x6e\x68\x35\xfc\x42\xc0\xd0\x0e\xb1\xa2\xb8\x90\x3a\xf2\x4f\x96\x61\x94\x0c\x75\xd4\x73\xdf\x4c\xdd\xf9\x0f\xd3\xc0\x83\xb7\x64\x78\x51\x86\x87\x64\xb8\x23\x1d\x2f\x70\x01\x8d\x2f\x18\x93\x76\xfc\xf7\xc9\x60\xc5\x17\x7f\xa0\x4a\xda\xb3\xd4\xe9\x06\x17\x5d\x29\xc3\xdf\x68\xbd\x46\xa5\x01\x5a\x28\x89\x55\xb8\xfd\xd4\x01\xc7\x08\x2d\xc0\x2a\xd9\x62\x19\x2e\xa5\xf5\x0d\x4d\xc7\x0c\x9c\xa0\x0a\x9d\xf1\xe6\xe7\xd3\xef\xc4\x05\x1a\xe8\x0b\x8d\xa0\x82\xba\x4c\xf3\x8c\xba\xd6\xa4\x03\x19\xfa\xa5\x6b\xc1\x77\xbf\xc4\x3a\xe2\x56\xea\xd4\xb3\x8e\xbe\x04\xab\x7e\xf5\xd4\xa9\x07\xab\x84\xf1\x9c\xbd\x34\x88\x61\x3d\x55\x0a\x9b\x68\xed\x65\x24\x90\xa9\xa3\x6a\x98\x91\xf5\x9b\x4e\xaa\x38\x64\x2b\x87\x4d\x27\x87\x1a\xce\x2a\x99\x76\xa6\xef\x04\xb9\x97\xa5\x18\xc6\xe0\x28\x5a\x67\x18\x1a\xd0\x3a\xa2\x2b\x5c\xc3\x2d\x3c\xb1\x87\x04\x32\x00\x93\x68\xfb\xc9\xfc\xbd\xb0\x96\x29\x67\xce\x8c\x97\x14\xe6\xe5\x32\x85\xde\xbc\x3c\xbd\x97\x28\xea\x95\x15\x36\x9b\xab\xdc\xe7\x73\xe5\xe7\xdb\x5d\xa5\x39\xae\x9c\xa6\x04\xe7\xe2\x7b\x46\xec\x91\xa6\x84\xc5\x9e\x85\x39\xd5\x1e\x29\x5c\x97\x8d\x30\x69\x1c\x46\xd0\x68\x70\x82\xb6\x49\xa1\xff\xf8\x58\xb8\x50\x8c\x44\xf3\x28\x18\x60\x0a\xb3\x24\xac\x39\xf5\x94\xbd\x82\x48\xa4\x7a\x95\x1a\xc1\xd2\xa8\xb0\x6f\xca\xbd\x67\xc0\x38\x98\xf1\x08\xda\x71\x00\xed\xff\xf8\x33\xf4\xc5\x17\x68\xe7\x23\x30\x03\xc6\x25\xd6\x9d\xbd\xac\xb8\x65\x28\x9a\xf1\xfd\xee\x4b\x76\xc6\xc1\x5e\xbf\x63\xe6\xee\xef\xd1\x8c\xa1\x2d\xc5\xc2\x88\x92\x18\x5a\x89\x36\xed\x47\x4f\x3c\xb1\x62\xc5\x13\x30\xfa\x73\x38\x03\xe6\xc5\x4a\x3e\xf4\xc5\x90\xef\x7b\xf4\x4b\x7d\x2d\x0c\x42\x3b\x6b\xeb\x41\xf9\x1e\x0e\xc5\x7c\xa4\xff\x36\x4c\xe3\x72\x29\x36\x7e\x7d\x3c\xec\x62\x75\x4d\xc3\x4b\xda\x2a\x4b\x0e\x56\xf0\x79\x25\xc9\xe2\xd1\xac\x8a\x43\xb6\xc8\x8d\x09\xd1\xe2\x62\x3a\x20\x52\x75\x56\x49\xdc\x34\xfb\x02\x27\x92\x24\x18\x8e\x6a\xbd\x86\xc3\xbf\xb5\xca\x42\xe1\xa7\xf2\xdb\x9f\x45\xbf\xcd\x6f\xb9\x10\xfd\x86\x6e\x87\x1e\x87\x06\x9f\xa7\xcd\x85\xfc\x43\x0f\x96\xf1\x7d\x17\xde\xfc\x32\x5a\x76\x14\xa6\xff\x6b\x09\xc9\x8a\xd1\x04\xc2\x42\x98\xd1\xfa\xe4\x11\xe8\x75\xcb\x3d\x86\xfe\x26\xae\x4d\xc5\x71\x35\xc4\x7b\xf0\x26\x9f\x0f\x34\xa7\xcd\xa1\x89\x36\x3e\x98\x23\x39\x18\x47\x4b\x82\xc7\x3b\x98\x35\x79\x9b\x12\x98\xde\xb1\x9c\xe6\x6b\x4a\x68\x7a\x67\x8c\xbc\x8e\x46\x37\x43\x82\x76\x44\x52\xd4\x2a\xd2\xee\xc2\x93\xf6\xdf\x29\x80\x47\xa0\x90\x0a\xa2\x4f\xfe\x94\x24\xfe\x26\x43\xd1\xe9\xc2\xf0\x55\xd7\xa1\xfb\xe0\x3c\x50\xf8\xb7\x9e\x7a\x6a\xc7\x8b\x07\x76\x13\x57\x1e\x39\x79\x2f\xf5\x37\x31\x74\xcd\x31\x98\x06\x6b\x98\xe3\x35\xc4\x35\xde\xa4\xeb\xa0\xb8\xad\x9a\x22\x5a\xf9\x9c\x80\xc9\x4f\x90\xd5\xdc\xb8\x91\x0a\xc3\x82\xa4\x31\x5a\x03\x6e\xb9\xa2\xe8\x98\x34\x77\x0c\x88\xd7\x3a\x28\x7b\xe9\xb6\x1a\x98\x7e\xae\x08\x39\x53\xa7\x2d\x4d\xf3\x8b\x02\xac\x17\xf9\x61\x28\x7a\x01\x54\x38\x40\x14\x2e\xf4\x15\xdb\xd7\x60\x6f\x7c\x5f\xb8\x05\x5d\xb2\xe3\x37\xf4\xf2\xba\x87\xb9\x2b\x92\x15\x29\x76\x41\xfc\xdc\x30\x6f\xbe\x19\xaf\xf9\x08\x73\x71\xbc\x96\x8b\x44\x18\xcd\xac\xaa\x0e\x07\x1f\xc2\xb2\x9c\xd7\xe7\x0b\x31\x5c\x34\x66\xb1\x80\xd7\xcb\x80\x23\xcc\x85\x9b\x12\x2a\xc7\x31\xc0\x31\xba\x24\x13\x48\xce\x1c\x77\x53\x22\x27\xcb\xe7\xba\x53\xb8\x7c\x36\xd0\x86\x96\x89\x80\x48\xab\xf0\x15\x7a\xe7\x78\xcf\x8a\xb0\xc3\x23\x52\x9f\x13\xe2\xd0\x55\xf8\x46\x00\x26\x40\x1f\xf8\x7e\x29\x89\xf9\xdc\xf6\x8a\x85\xf5\x26\x0f\xc9\xaf\x6f\x23\x31\xa1\xe3\xd1\xab\x5f\xa0\xf7\xd1\xba\xe0\x1b\xc2\xd2\xe4\x0b\x10\xc3\x3c\x85\x04\x7f\xee\xdc\xf6\xdd\x8e\xd7\xc0\xd6\xf2\xf6\x6b\x50\x0f\xbd\x93\x0f\xd2\x3e\xde\x8c\x75\xb0\x42\x2c\xa3\x46\x99\xeb\xe2\x63\x75\x5f\x98\xf4\x2f\xcc\x11\xb4\x58\x1f\x13\xf6\x71\x79\xb1\x84\xf5\x02\x2b\xdb\xcf\x0a\xb2\x15\xeb\x92\x98\xa1\x3b\x22\x11\x55\xe1\xb0\xec\x4a\xfa\xaa\x30\x2e\xc9\x4e\x70\x3d\x9b\x69\xbe\x24\xc6\x8b\x05\x56\xaf\x37\x18\x74\x35\x24\x82\x9d\x04\xd6\xf4\x08\x10\x59\x95\xf6\xd8\xb8\xde\x99\xed\xd3\xf4\x7e\x15\x29\x6d\xad\x3b\xe1\x35\x16\xcd\xc3\xfa\xdc\xcd\xe0\xbb\xdb\x0f\x96\xcf\xbb\x17\x61\x97\xec\x5d\xfe\x0d\xfa\xd3\x75\x27\x96\x01\x46\x7d\x7e\xa4\xb3\x14\xfb\xfb\xb7\x88\xf8\xd9\xb2\x6d\xad\x78\x2d\x9e\x49\x7d\xb3\xec\x58\x6e\xc9\xb3\x5b\x64\x22\xb1\x88\xac\xa8\x72\x8a\xdd\xce\xf1\x66\xc0\x34\x3a\x21\xcb\x3c\x16\x63\x74\xde\xd6\x94\xe0\xb9\x74\xf2\xd5\x8c\x7b\x0a\x99\x49\x30\xe8\x57\x06\xc5\x25\xc6\x91\xf4\x36\x11\x3c\x4f\x31\x02\x3f\xd4\x6f\xd6\x56\xf4\x0d\xcb\xc2\xd9\x2c\x83\xbe\x7f\x74\xe6\xa1\x59\xeb\x61\x28\xb4\x21\x20\x4e\x62\xe4\x2f\xbf\x09\x55\x19\xb1\xa6\x98\x47\x5f\x48\x6d\xc6\x1a\x33\x2c\x1e\x91\x2d\x36\xdc\x1e\x56\x12\x45\x07\xa7\xcb\x32\x69\x8f\x0d\x53\x35\x9b\x8d\xb4\xc7\xa5\xf2\x0a\x05\xa8\xe8\xda\x14\xdc\x98\xee\x9a\xc2\x55\xf4\x86\x42\x11\x3e\x18\x39\x03\xfd\x00\xab\xa1\x11\xae\x46\x3f\x5c\x34\xf2\x1d\x71\x7f\x51\x89\xc7\x04\x67\xa1\xfb\x89\xb5\x83\xfc\x65\xdd\x73\x17\x37\x47\x0c\xdf\x35\xe9\x12\x4a\x57\xdc\xcc\xb9\xf1\x0a\x93\x24\xb9\xad\x2e\xab\x8d\x57\x54\xce\x81\xd5\x5b\xd5\xc6\x79\x3d\x6e\x37\x23\xd8\x2d\x3a\xa7\x37\x25\x5c\x78\x45\x08\xc0\x99\xb0\xaa\xce\xe8\x82\xb3\x1d\xf9\xd3\x53\x41\xb7\x6b\x45\x3b\xc0\x70\x47\x65\x25\x4d\xfe\xa9\xe9\xca\x91\x6a\x2e\x6e\x30\xfe\xac\x01\x47\x82\x21\xe0\xa2\x3f\x8c\xe1\xdb\x3c\xeb\xd0\xcc\xc7\xd1\x37\xcf\xa3\xef\x39\x75\x1d\x0c\xc5\xeb\xfb\x6c\x76\xa3\x31\x8c\xe4\x3f\x2e\xc2\xa4\x86\x13\xb7\xff\x66\x4c\x17\xcf\xa4\x67\xd3\x3e\xe6\xac\x78\xa9\x49\x72\x59\xad\xce\xac\xe6\x4b\x7c\xc0\xef\x72\xa5\xda\x3f\x2e\xe1\xe4\x38\x01\x14\xda\x7c\x97\x57\xa0\xa3\xeb\x29\xaf\xd7\xfe\xba\xe1\xdd\xb7\x3b\x86\x27\x82\x8c\x36\x5e\xa6\xe0\x78\x33\x33\xd6\x64\xe8\x97\xbc\xcb\x3a\xe8\x90\xf3\x7d\x93\x9f\xb3\x79\xc6\x90\xa7\xff\xa7\x86\x1e\xb7\xfd\x74\xdc\xf6\x3c\x1a\x77\x9c\xcb\x34\xc7\xcb\x54\x77\x50\xcb\xb5\x6b\x60\x67\x15\x13\xb0\x26\xb3\xc7\x6d\x66\xdd\x5c\x38\x94\x93\x63\x56\x18\xde\xce\x63\x72\x6e\xb7\x2b\x1e\xd6\xac\x2b\xb9\x4d\x09\x25\x7b\x9d\x76\x83\xd0\xd1\xc5\x1d\x27\x05\x8b\x44\x9c\x16\x68\x50\x03\xe4\xb2\xa9\x30\xd8\x42\x47\x84\x7b\x1b\x7d\xeb\xbc\xf1\x4e\xf4\xcd\xec\xbd\x37\xa3\xeb\x05\x1d\x5d\x7f\xf3\x7b\xb3\xd1\x37\xf7\xac\xda\xf0\x39\x3a\x85\x8d\x27\x77\xb1\xf1\x15\x0b\xd1\x2b\x30\x68\xf5\xa7\x97\x4a\xec\x39\xc9\x7b\xa5\x4b\x3f\xbb\x11\xed\x84\x01\x0b\x57\xfc\x0c\x97\xe3\xbe\x10\x2c\xc4\xeb\xf0\x3c\x78\x69\x9c\x71\x99\xec\xf0\xdb\xed\x4c\xc0\x6a\x05\x9b\xe0\x74\x30\x20\x88\x22\x38\xb0\x9a\x60\xb7\x5a\x45\x9b\x97\xf5\xb1\xe3\x13\x3e\x9f\xcd\x09\xa2\xcb\x16\x68\x4c\xd8\x94\xee\xf6\x5c\xe7\xa3\xec\xf6\xbe\x60\x79\x26\x1a\x84\x48\x55\xa6\x23\xf4\x8b\xd1\x91\x1b\xd1\xcf\x87\xd1\xcf\xcd\x4f\x5c\x85\xde\xe5\x47\xa1\x77\x97\x6e\x6b\x46\xff\x9e\x3b\x67\xd5\x83\xe8\x49\xb8\xfd\x87\x2d\x9f\xb6\xdc\x7f\x81\x05\xfe\x85\xbc\x96\xe9\xf7\x9f\xf3\xe9\x96\xd9\xf3\x1e\x87\x82\x4c\x9c\xf4\x48\x12\x0f\x88\x75\xb4\x8b\xe2\xb5\xa2\x2d\x2a\x49\x8e\x18\xcf\x3b\x05\xbf\x3f\xe0\x70\x72\xe1\x30\x23\xdb\x98\x00\x5e\x5a\xf9\x79\x6e\x3d\xc4\x85\x30\xf5\x8f\x18\x9b\x41\x76\x06\xc8\x66\x88\x75\xdd\x0c\x15\xd9\x89\x9a\xba\xfb\x49\xad\xab\xac\xc9\x28\xce\x9e\xa7\x1a\xbc\x37\x1c\x64\x6f\xb0\x77\x77\x98\x14\x3d\x35\x59\x93\xd1\x67\xdc\x16\x3c\x41\x78\x8b\xdc\xdb\x71\x52\xda\x27\xec\xb1\xd1\xc9\x57\xb9\x5e\x74\x8e\xf0\x5e\x91\x5a\x68\x9e\xb7\xb0\xd1\xc7\x90\x24\xe9\x61\x9e\x77\x08\x1e\x8f\x57\xc7\xd3\x13\x24\x7d\xf4\x3a\x6c\x7c\x34\xe2\xd4\x72\xb8\x9c\xc6\x44\xae\x44\xfb\xa8\xc8\x0e\x2f\xde\x31\x42\xb8\x1d\x76\xf7\xff\x57\x1f\x53\xf3\x84\xbf\x1b\xf3\x57\x13\x23\x1d\xc4\x3b\x88\xad\xef\x30\x5d\x74\x0e\x07\x1d\xe6\xca\xf0\xb4\x61\x02\xef\xcd\x9e\x31\x12\xe1\x80\x27\xf2\xe2\x41\xe8\x6f\xec\x28\x3c\x7b\x06\xc6\xf2\x33\xe2\x6f\x4c\x03\xb3\x26\x1e\xb0\x5a\x82\x23\x0a\x06\x95\xf6\x29\x2e\x61\x5c\xae\x92\x48\x9f\xa1\x83\x46\x58\x4c\xe3\x1a\x6b\x06\x56\xf5\x25\x78\xb4\x7d\x12\x55\x4a\x29\x98\xb9\xd2\x3e\xf1\x81\xbd\x7b\xf7\x91\x25\xef\xd8\xa1\xd1\x48\x14\xcb\xb1\x56\x7d\xac\x54\x1c\xed\x23\x45\xa5\xa8\xde\xa7\x4f\x8f\xa6\x44\x1f\x7e\x12\x0b\xac\xce\x94\x56\x4c\xae\x6f\x47\xf9\xc5\x0c\x3c\x9d\x69\x2c\xdd\x43\xbf\x57\x3d\x80\x19\xdd\xee\x62\xf0\xb6\x23\x32\xb5\x77\x5f\x70\x56\x94\x0f\xa4\xa8\x54\x91\x4a\x82\xa5\x46\xb1\xb4\xf0\xca\x25\x48\x83\x1d\x03\xf2\xf4\x7c\xae\xc2\xd1\x01\xeb\xce\xc8\x53\x45\x53\xa2\x72\x92\x1d\x60\xe2\xdc\x3e\x17\xcd\x9c\x3b\xe0\x86\x7b\x38\x74\xf0\xd4\x58\xd3\xac\xc5\x43\x6e\x7b\xfa\x8c\x87\xde\xbf\x73\xd9\xb0\xec\x90\xbd\x19\x90\xff\xf4\x9e\x9b\x2f\x0c\x9d\x1e\x3f\x77\x40\xa3\x16\xd0\xfd\xf6\x96\x0d\x4f\xde\x78\xdd\x9a\x4d\xe5\xa7\xcf\xb9\x76\xdb\xe3\x17\x4e\x9b\x14\x2e\x8c\x3c\x78\x47\x73\x5e\x49\xde\x96\x9b\x2e\x5e\x3e\xd2\x21\x17\x8d\xec\x97\x89\xe9\x83\x61\x03\x61\x2a\x7a\xfc\xcb\x41\xfd\xc6\x26\xfc\x2e\xdf\x93\x91\xe7\xaf\x26\x21\x7e\x8f\x5c\x73\xc6\xc2\xd3\xca\x73\x14\xb9\x9c\xc8\x14\x43\xd1\x24\xee\x3f\xc2\x0d\x4c\x23\x73\x75\xbc\x72\xf8\x30\x53\x85\x5a\x12\x0b\x04\xdd\x9e\xbe\x0c\xe3\xb1\x05\x4b\x4b\x2a\x86\x99\xc6\x8f\x1b\x35\x98\xab\x2d\x95\x6d\xb2\x6d\x7c\xa2\x76\xb0\x5b\x1e\x3e\x58\x96\x07\x0f\xe7\x82\x03\xc6\x06\x22\x05\x44\x08\x54\x12\x91\x40\x30\xee\xf7\xf7\x08\x06\x1d\xe3\x13\x41\x35\xed\x53\x58\xea\x57\x0f\xec\x36\x4c\x07\x14\x6c\xb7\xe3\x88\x77\xc2\x7e\x23\x43\xec\x49\x8f\x27\x96\x24\x3a\x78\x8b\xd5\x74\x18\xd0\xf4\x78\xba\x8c\x1c\xb3\x52\x0a\xd9\xd1\x98\x9c\x18\x91\x42\xe8\xec\x0c\x1d\xbe\xf0\x8e\x05\x0d\xbd\xaa\x67\x5c\x43\x5c\xca\x1a\x5a\x4c\x3f\x3b\x56\x5f\xba\x0d\x0f\x68\xc1\xd8\x7e\xe7\x0f\xc4\x03\x1a\x0a\x9c\x75\xd1\xdf\x16\x2d\x5c\x7e\xeb\xb8\xcd\x0f\xae\x9c\x3c\xa0\xae\xcf\x69\xe3\x26\x55\x5f\xba\x40\xfc\x91\x2d\x8c\x15\x0e\x1c\x79\xf6\x90\xe5\x0f\x2c\x9b\x72\xf9\xb0\x1c\x4f\xb4\xaa\x67\xcd\x80\x00\x75\x3e\x1b\x33\xc4\x3d\xeb\xfa\x20\x0c\x47\xef\xbc\x32\xbc\x1a\x0f\x6c\xef\xbb\x42\xcb\x27\x53\x57\xb4\xab\xa6\x9e\xb9\xb4\xd1\xe7\xea\x57\x99\x57\x96\x13\xcd\x59\xbd\x32\x56\x88\xff\xdc\x8b\xc7\xb8\x19\xf3\x07\x1f\xa6\x49\x39\x4c\x3c\x1e\xb6\x5a\x74\x00\x85\x75\xfb\x2c\xac\x8f\xcb\x0d\x32\x9c\xc2\x35\x25\x74\x87\xa2\xb0\x1e\xd5\x62\x64\x39\x30\x58\x41\x17\x09\x3f\x4d\xfd\xa3\xbd\xb9\xf6\x08\xd8\x8e\xa9\xed\xcf\x58\x7c\xd6\xa0\xca\xde\x57\x80\xe7\x7e\x7d\xe0\xb0\x2e\xd9\xed\x73\xfa\x9e\x89\x15\xa8\xc3\xc9\x55\xa3\xfa\x75\x4a\x6f\x0f\xcc\xe5\x24\x8f\x10\xa6\x29\x3e\xa6\x7f\x3c\x17\x53\x7a\xab\xd5\x63\xe3\x25\x87\x4d\xe2\x02\x7e\xaf\xe0\x50\x6c\x01\xc6\x23\x7b\x68\x36\xa1\x8c\xc6\x54\x5f\xd1\xa5\x7d\x1d\xf2\xe1\x18\xed\x74\x57\x74\x4c\x87\x73\xe1\xaa\x33\xeb\xc2\xe7\x83\xe3\x72\xe7\x65\x5d\x53\xe2\x40\x8f\x89\x77\xbc\xca\xce\x6c\xc5\xea\xec\x4a\x7a\xce\x94\x8a\x47\xc4\x52\x5f\x2e\xd3\x9b\x99\x1f\x3f\xa5\x30\x27\x47\xea\x85\x25\x19\x89\x29\x2b\xcd\x53\x9c\xa1\x61\x0a\x7c\xa8\x80\xa8\xb8\x95\xe1\xca\x44\x85\x3f\x25\x04\x9f\x85\x60\x71\x68\x75\x68\x5d\x88\xe3\x94\x50\x28\xd4\x10\x6a\x0a\xf1\x66\x41\x09\x29\x21\x2b\x6f\xf5\x11\xec\x23\xbe\x27\x96\x0f\xb3\xf0\x50\x29\x45\xa0\x98\x67\x93\x67\xe1\x7f\xa9\xd5\x59\xd7\x01\x20\x95\x60\xc8\x1b\xea\x2e\x56\x75\xf3\xa3\x34\x91\x93\x71\xda\x82\xb7\xb3\x81\x00\x6b\x64\xe8\x96\xaa\x27\x3c\x04\x83\xbe\x80\x06\x98\xbf\x09\xed\x3a\xf0\x09\x7a\xe1\x31\x6e\x6b\xfd\xe5\x33\xce\xed\x7d\xce\x05\xde\xf7\x1f\xdd\xf8\x41\x4e\x60\x1a\x8a\x0d\x39\xb7\xe9\xfc\x11\x79\xd3\xa2\xbe\x0f\x1e\xde\xb0\x2f\x70\x21\xfb\xda\xe7\x30\xfc\x51\x74\x0d\xda\xfc\x25\x7a\x6a\xdb\xe3\x30\xa6\x26\x37\x3f\xb7\xd7\x73\xaf\xbd\xba\x4d\xf5\xc3\x58\xfc\xd9\xe7\x78\x72\xe7\x8b\x5b\x7a\xd1\x31\x49\xf9\x55\x61\xd9\xd3\x8b\x75\xb4\x0b\xe3\xc3\xf2\x1d\x0e\xd1\x83\x39\x9b\xc8\x14\x15\x6a\xbe\x5c\x5b\x81\xaf\xda\xb7\xc7\xc7\xed\xf3\x41\xb5\x6f\xb8\x6f\xa2\x6f\xad\xef\x01\x9f\xd0\xc3\x56\x67\x7b\xc3\xc6\x1d\xb0\x41\x9d\x6d\x94\x2d\x61\xbb\xc3\xf6\x90\x4d\xf0\xd9\x7c\x36\x2e\x6a\x76\xbb\x38\x35\x05\xa1\x46\x8c\x63\x27\x1d\x85\x14\x00\x26\x83\x35\x1b\xa3\xcf\x35\x64\x18\xaa\xc1\x18\x0e\x2a\xf6\x8b\x8d\x58\x8e\x92\x80\x83\x30\xfa\xb2\x15\x25\xd1\x01\xb8\xb5\x6c\xd0\x80\x61\x95\x25\x95\xbe\xef\xdf\x89\xd4\xc0\xc4\x8a\xd1\x83\xfa\x45\x6b\x06\xf8\x0e\x9e\x75\x85\xb3\x92\xcd\xc5\x4a\x5e\x18\x7d\x84\x57\xe1\x71\xb4\x0f\x8a\xe1\x46\x6f\xae\x57\x85\x82\xe3\x3a\xfa\xc5\x1b\xf4\x3a\xd0\xe7\xf3\x97\xe9\x84\x4e\xd9\xf1\x1e\x5a\x80\xd7\x81\x93\x29\x8e\xbb\x39\x96\x15\x15\xce\xed\x62\x39\x1b\x96\x65\x6d\x3c\x88\xcd\x09\xd0\xbb\x44\xcc\x12\x01\x03\xb3\x2b\xea\x2d\x97\x9d\x1b\x64\x30\xfa\x30\xf9\x07\x54\x42\x34\x50\xda\x2b\xf0\x56\xc5\x96\x55\x93\xee\x9d\xb4\x74\xd2\xa9\x53\xfa\x08\x4b\x5b\xe7\x9d\xb1\xed\xb9\x46\x76\xe6\xdd\xb7\x0c\x3f\x75\xd3\xf8\xe5\xa9\x78\x5d\x2c\x13\x45\xf1\x78\x3b\x99\x82\xb8\x93\xbc\xdb\x8e\xdf\x6d\xd3\xb0\xbc\xa3\x8a\xc0\xaa\x60\x40\xaf\x67\x5c\x26\x8d\xd7\x3a\xdc\x9e\x7a\x70\xb4\xf3\x00\x89\xdd\x8f\xb6\xa2\x45\xd0\xe3\x45\xa5\x36\x5a\x74\x41\xed\xdf\x97\xcf\x58\x38\xa7\x3c\xbf\x57\x95\x1b\x0b\x97\x1b\xca\x5f\x9f\xbb\x14\x06\x3f\x72\xed\xb0\x0f\x82\x03\xe2\x29\x1f\x15\x71\x81\x14\xd6\x0b\xf8\x7c\x62\xcf\x63\xdf\x67\xaf\x85\x09\x46\xae\x91\x70\x98\xa0\xfa\xe4\x3c\xd3\x16\xde\x9e\xe3\x63\x95\x8e\xb9\x46\x68\x5b\x85\xb7\xf1\x73\x05\xa9\xe7\x7c\xe9\x1c\x25\xe1\xb0\x66\x3c\xd7\x42\x9e\xb3\x67\x67\x16\xe2\x48\xde\x0a\xd3\x3f\xf1\xf8\x6a\x58\xaa\x28\x64\xce\x88\x97\xca\x76\xab\xc5\x92\xab\xc7\xbc\x5e\xdd\xcc\xd9\x85\x1e\x45\x36\x5b\x40\xb6\x58\x5c\x01\x86\x6b\x49\x30\x02\xfe\xef\x0a\x44\x48\x78\xbb\xab\x00\xab\x13\xed\xaa\xb3\xba\xbb\x38\x83\x56\xde\x31\x63\x47\xfa\xf0\x87\x58\xb7\xeb\xf1\x08\x05\x68\x04\x35\xa4\xd7\x54\x24\x73\xde\x87\xd7\x91\xf0\xe8\x79\xa3\xab\x4a\xce\x38\x27\x5f\x47\x57\x40\x8f\x1f\xf6\x42\x01\x5a\x71\xca\xfb\xa8\x11\x7d\x83\xda\xf0\xcf\xf7\xe0\xc6\x6b\x4c\x00\x1f\x3a\x70\xf5\xdf\x92\xf8\x1f\x9a\x24\xbf\x6e\x3a\x6d\x6a\x19\x5f\xda\xba\x9f\xcb\x3f\xb1\xfd\xa3\x97\xf8\x99\x34\xb2\x64\x21\x34\xc3\x59\x30\x07\xad\x42\x0f\xfc\xf6\x1f\xe4\xfb\x0f\x26\x76\xc6\x1e\x42\x93\xa4\xad\x78\x4e\x49\x7f\x7b\x12\x6b\x3e\xee\xad\xae\xe7\xe6\x79\xbd\xb9\xa4\xbb\x25\xc5\x36\x9b\x4b\xb6\x28\x81\x48\x43\x22\xa0\xba\x8a\x68\x0a\x74\xae\x11\x77\x9c\x9c\x80\x75\xca\x51\xd2\x9d\xe1\xa8\x9b\x7e\xb2\x69\x17\xa8\xb4\xe3\x93\x93\xd2\x0f\x7e\x55\xb7\x5d\xbd\xe2\x9b\x3d\xbb\xbe\xfe\xfa\xd5\x37\x3e\x43\xff\x1e\x3b\x78\xc8\xb8\x82\x41\x85\x43\xc7\x77\xed\x25\xf7\x1a\xde\x62\xef\x43\x1f\x00\x60\xa0\x0c\x7d\x8e\x8e\x3d\xb4\xe7\xb5\x4d\x33\x1f\x4a\xec\x26\xb1\x28\x6d\x2b\xc5\x16\xe1\x4f\xc6\xc3\x94\x32\x83\xe2\xa1\x48\xa0\xb0\x57\xa0\x97\xde\x53\xcc\xd5\x75\xb1\x4f\x59\xa0\x57\xa4\xb0\x97\x37\xaf\xb0\x30\xcf\xdb\x8b\xb7\x31\x36\xa6\xb4\xd4\xe0\xd2\xa5\x1d\x76\xbe\x5e\x97\xe5\xcb\x4d\xd3\x92\xe4\x1b\x7b\x89\x27\x9f\x05\x3b\x70\x04\xee\x9a\xc0\x8e\x16\xa6\xd1\xda\x5d\x4e\xdd\x33\x10\xb8\xc1\xfd\x5a\x72\xd0\x97\xe8\x39\x18\x04\x05\x39\x2d\xfd\xfa\x35\x07\x21\x0f\x86\xa0\x67\xd1\x57\xf8\x5b\xed\x94\xe0\xdd\x1b\x36\xdd\x16\x9c\x5c\x57\x37\x25\x78\xc7\x43\x9b\xf1\xa7\x79\x75\xa5\x7e\xb8\x0a\xfa\x42\x2d\xcc\xcb\x29\xad\xad\x2b\xcd\x41\xd7\xa2\xb7\xd0\xbb\x68\x41\x6e\x69\x1d\x3c\x56\x59\x9c\x0b\xdc\xbb\x6f\x24\x83\xc5\x95\x95\x25\xc1\x3f\xdf\x7d\x17\xb5\xe6\x96\x54\xd2\x98\x9b\xb6\x35\xfc\x7f\xf9\xbf\x33\x2e\xa6\x98\xf4\x33\x2f\xd4\xd3\x17\xf2\x59\xdc\x4c\xd4\x62\x61\x7a\x95\x84\x7c\x79\x3d\x7d\x39\x85\x3d\x7b\x16\xe6\xf8\x78\x41\x15\xfe\x57\x3f\x31\xa9\xaf\x21\x49\x44\x29\x02\xb9\x64\xf4\xa9\x80\xcd\x77\xba\x8d\x24\x51\xf8\x77\x95\x9a\xea\xaa\x18\xfb\x73\x7f\x6d\x53\x53\xed\xfe\xff\xfe\xf6\x81\x77\x62\x65\xd5\xe9\xbe\x0f\x7e\x83\xc8\x59\xe3\xfd\xe3\xca\xfb\x8c\xf3\x8f\x3b\xfb\x7e\xef\xa4\xaa\xea\x49\xde\xfb\xd9\xdc\x1f\xa1\x87\x77\xf4\x68\x1f\xfa\xf4\xf0\x8f\xe8\x23\x5f\xcf\x8a\x8a\x9e\x3e\xe8\x71\x78\xcd\x53\x39\x05\xbd\x7b\x17\x04\x9e\x5c\x0b\xd1\x01\x25\x95\x55\xc5\xfd\xe9\xda\xa4\xf6\x5b\x53\x1e\xa6\x37\xc3\xb0\x2c\x7c\x43\xbc\x07\x63\x2d\x1a\x3d\xfc\x94\x53\x7a\xbb\xb8\x40\xd1\x98\x51\x95\x45\xf1\x40\x51\x34\xc0\x8d\x6b\xec\xdb\xb7\x38\x1a\xcd\x03\xeb\xf0\xe2\x61\xa5\xa5\x79\xc5\x76\x09\x4b\xc6\xdb\x13\xf6\xe2\x53\x4f\x21\x22\xb2\x2b\x71\x6a\xf1\xe0\xf2\xe2\xf2\xa6\x84\xb7\x98\x1f\x50\x93\x57\xd3\x94\x08\xe5\x75\xb2\xf1\x7a\xd5\x3d\xc6\x9e\x4d\x6d\x59\x75\xcf\x9e\x72\xbd\xae\x53\x1a\x15\x2d\x0d\xc5\x41\x30\x63\x48\xbf\x8d\xdc\x25\x31\x02\x75\xee\xc9\x65\x3d\x59\xa6\xe0\x68\xde\x49\x6d\xc1\x59\x86\x60\xfc\x00\x41\x98\x74\x39\x25\xe9\x5d\x77\xe2\x81\xa9\x17\xde\xd5\xb8\x68\xfe\xb6\xa3\xcf\xdd\xfd\xfa\xc0\x59\x53\x27\x20\x31\xcb\x4c\xbc\x1a\xa1\x8b\xbe\x45\x87\xba\xb1\x13\xdf\x78\x60\xe5\x75\x9f\xdf\x98\xb2\x12\xa3\xb5\x1e\xdf\x85\x07\x7b\x8a\x1b\x2b\xeb\xfa\xf7\xb9\xec\xfc\x87\x3f\x9a\x1a\xee\x1d\xe0\x93\xc7\xda\x6d\xc7\xa7\x0c\xbd\xb1\xab\xf1\xb8\x69\xd6\xac\xa6\x94\xe1\x18\x86\xc5\xce\xee\xb9\xf9\xfa\x79\xe3\x99\x34\x8f\x15\xbf\x16\x7f\x64\x22\x4c\x35\x13\x67\x66\xc5\xfd\xd1\x5e\x42\x4d\xff\xfe\x66\x1f\x17\xb4\x0a\x9e\xa0\xc0\x04\xb9\xc1\x83\x62\xbd\x6a\x4c\x65\x3d\xb0\x04\xbc\x3d\x51\x66\xea\xdf\xcf\xb0\x87\xf6\x37\x69\x4c\x63\x42\xd3\x58\xbf\x49\x75\xda\x59\x7b\x63\x22\xcc\xb6\xcb\x4c\x15\x46\x90\x5a\x7a\xd8\xc9\xa7\x3d\xe5\x99\xb1\x4e\xe9\x1c\xe5\x04\xc9\x3c\x46\xa9\x62\x85\x2b\x95\x54\x27\x15\x46\xa1\x46\xaa\xa8\x43\x47\x24\x7a\x92\x99\x48\x0d\x2c\x77\xfb\x15\xb7\xa3\xff\x62\x96\x5a\xd2\x8a\xda\x6e\x5c\x15\x9f\x79\x46\x62\x56\xfd\xaa\x1b\x51\x5b\x2b\x94\xa0\x0f\xd1\x1f\x77\xb0\x3d\xbb\x8e\x7c\x32\x4c\x47\xb1\xb8\x9e\x1e\x2a\x9b\xa0\xf4\x20\x7a\x6e\xcb\xf6\xbc\xf2\x8a\xd8\x93\x8f\xc1\xf0\x83\xe8\x7d\x5c\xe3\x09\xf4\x99\x70\x65\x87\x51\x46\x53\xd3\x23\x87\xf9\x0f\x5d\xbb\xe2\x13\x98\xff\x68\x14\x6f\xf3\x55\xa1\x08\xf3\x2d\x12\x1b\x31\x60\x80\x50\x00\x03\xcd\x03\x2b\xf4\x4c\x6c\x04\x2e\x4f\x6d\xf5\x42\x13\x2e\xaf\x1b\xe5\x39\xde\x38\xb7\x8a\x46\xb5\x02\x88\x3d\xd3\x76\x64\x7b\xcc\x6b\x65\x3b\x9c\x5b\x9d\x8b\x65\xd5\x33\x31\xaf\x72\x33\x83\xe3\x11\x8b\xd9\xcd\xa8\x58\x98\x33\x73\x5e\x8f\xc5\x02\x2e\x97\x44\xf2\x2c\x51\xa3\x2e\x38\x9a\xb2\xc4\x02\x92\x65\xa9\xcb\xd2\xa6\x69\x8c\x52\x80\x7d\xe9\x94\x3c\x3a\x4d\x10\x74\x0d\x42\x9f\x63\xce\x31\x0c\x3e\x5b\x84\x5a\xa3\x8f\x2f\x7c\x71\xe7\xfe\x97\x46\x0c\x20\x39\x8c\x3c\xb0\x0c\x2a\x60\x0a\xcc\x42\xf3\x47\xcc\x58\x78\xe2\xa7\x9f\xd0\x9f\x9e\xe4\x8c\xac\x1c\x41\x6e\x82\x6f\x66\xb5\x18\xed\xb2\xe0\x76\x59\xad\x92\xcb\x05\x12\x13\x30\x0c\xb0\xe0\x68\xc8\x60\xc6\x66\x40\x90\xbb\x36\x8b\xcd\x4e\x15\x94\x0a\xdd\x87\x7f\x3e\xfb\x46\x96\x37\xc0\xa7\x0b\x2f\x1b\xdd\x97\x64\x7d\x8a\x42\xe0\xdb\x76\x2f\x80\xbf\x3f\xf6\xa2\x3b\x79\x1d\x1d\xab\x00\xc3\xf0\xc4\x6f\xda\xc1\x14\xc6\x75\x5d\x93\x4c\x76\x8b\xc5\xa4\x71\x4e\x3c\xca\x2e\x8d\x44\x03\xef\xa6\x76\x48\x3d\xeb\xcd\x52\xbe\x24\x48\xf9\x5c\xcc\x91\x5f\x23\xd4\xe0\xff\x8e\x0a\x8e\x7f\xb4\x1c\x2d\xac\x85\x65\x15\xe8\x8a\xb3\xfe\xbc\x10\x2d\x28\x87\x6b\x6b\xc9\xef\xe5\x17\x1d\x5f\xc0\xad\xfc\xb8\xe5\xe3\x96\x4f\x5a\xd0\xdd\x70\x1f\xfe\x43\xbe\xc0\xfd\x28\x97\x01\x74\x1f\x7f\x26\x34\xe1\x77\xbb\x18\x71\x2b\xcf\x94\x52\x70\xef\x58\xc4\x48\xbb\x47\xfd\x66\x8c\x64\x09\xd0\x34\xa2\x1c\x3d\x3a\xbc\xa2\x6a\xe8\x90\x6a\x38\x6d\x78\x45\xf9\x08\xe1\xb4\xaa\x61\xb6\x9a\xfe\x43\xaa\x6b\x86\xd8\xaa\x07\x0c\xc3\xfd\x40\x1b\xf8\xd7\xe1\x3c\xe1\x5b\x46\x67\x3c\x71\xab\xc9\x6c\x66\x69\x82\x56\x85\x61\x4a\xdf\x9e\x5c\x8e\xb5\x25\x4c\xb7\x49\xd2\x67\x96\xea\xe1\x86\x22\xd8\x6a\xff\x5b\xe1\xd8\xc4\xb4\xfa\xa6\x69\x55\x67\x4d\x38\xbd\xf4\xf2\x05\x02\xff\xfa\xb2\x1e\xe5\x3d\x9e\xc5\x1c\xe2\x9a\xb5\x0c\xb4\x2d\xe7\x4f\x63\x16\xd2\xbc\x3a\x96\x6d\x1c\x16\x9e\x4b\xdf\xc1\x1b\x8f\xab\x70\xc5\x9c\x44\x89\xac\x5a\xf0\xdb\x8c\x29\x2b\x2b\x8a\x85\xb7\xdf\x1b\x3e\x75\xe0\xe5\x23\xa9\x2c\xd8\xe1\x19\xc9\x8c\x7b\xf5\x36\x41\x85\xc1\xba\x68\xac\x9a\xec\xbc\x85\xc5\x15\x2b\xa7\xcc\xf8\x4d\x18\x3b\xea\xf2\x01\x53\x87\xbf\x47\x9f\x49\xbe\x21\x5c\xc2\x0e\x14\xff\x8d\xe9\xb9\xed\x09\xc9\x6e\x05\xa6\xb4\xe2\x9d\x6e\x48\xa9\xdb\x93\x0b\x1e\x76\xa0\x3b\xf1\xc8\x45\x33\x6f\x1a\x85\xb7\xe5\x8f\xcf\x8e\xbe\x7f\xce\x9c\xf5\x09\xe1\x92\x8a\xbe\xc6\x7e\xeb\x5d\x5d\x5d\x41\xf6\x87\xa9\x35\x1f\x3d\xcc\xed\x17\x9e\xc6\xed\x70\x50\x89\xad\x0f\xd3\x8f\x72\x8b\xe9\xf1\xda\x58\xee\x70\xee\xd4\x81\x43\xc2\x23\x47\xe6\x8f\x51\x2c\xe5\x5c\x8d\xad\xb2\x52\xab\x13\x98\x22\xae\x97\xd3\xc7\xf6\xec\x29\x95\x9e\x3a\x64\x4c\x4d\x5d\x2f\x5f\x69\xa9\xaf\x57\x5d\xcd\x98\x21\xa7\x9a\x02\x83\xfa\xbb\x03\xb8\x59\xa5\x29\x45\xbd\xd4\x60\x8f\x06\xf5\xf7\xa4\xc4\x37\x4f\x45\xfb\x15\x12\xe0\x49\xd2\x5f\xa8\x15\xe5\x2e\x47\xe6\x13\xfc\xe5\x27\xae\x9b\x6b\xf9\x99\x4f\x6c\xeb\xec\xd9\xe7\x7f\xfa\xa9\x46\x7f\xb7\xde\x40\xff\xb0\xbd\xe8\x9f\xe3\xd7\xd0\x3f\x5f\x1a\xd7\x6e\xa6\x7f\x92\x3e\xfa\x87\xdb\xfd\xf7\xbf\x63\xb2\x83\x44\xfa\x87\xfd\x37\xfd\x73\xfc\x20\xfd\xc3\x17\x64\xdf\x6b\xfd\x8a\xfe\x39\x46\x7f\x33\x74\x0c\x2f\x42\x4b\xb9\x75\xc2\xa1\x2e\x63\x78\x4e\xbc\xb2\xa6\xaf\x2f\x27\x96\xdf\xab\xd4\x64\x8e\x0f\x29\x2d\x72\xe5\xe4\xe7\x36\x8c\x29\xef\x6b\xd1\xcc\x43\x86\x15\x05\x72\x72\xeb\xc6\xf4\x3d\x45\xd3\x4e\xe9\x3b\xa6\x2e\x37\x27\x50\x34\x6c\x88\xd9\xa6\x08\x4a\xbb\x60\xd1\x3e\x82\x1d\x7f\xd4\x3d\xc6\x4f\x9f\x32\x8f\x2b\xbd\x64\x34\x82\xc7\x5e\x21\xba\x2a\x5c\x69\xdf\x8f\xaa\x8a\xfc\x0a\x23\x3f\x8b\x2b\xc6\x91\x35\x21\x15\x14\x4a\x85\x24\x53\x42\x61\x8d\xdb\x53\xe3\x21\x06\x24\xa9\xb0\xba\xa6\xb0\x86\xe4\x53\xa8\xf1\x88\x92\x47\x1a\xe6\xcf\x99\x3a\xf8\x54\xfa\x2b\x79\xe1\x82\xa1\x93\x7b\x9c\x31\xee\x2e\x7e\x73\xea\xc3\x80\x89\x65\xa5\x96\x11\x4a\x5d\xd5\x25\xad\xc3\xf0\x47\xf3\x70\xfc\xf1\x52\xdb\xc4\x3e\xa7\xf5\x19\x31\xa3\x6f\xd5\x25\xdc\x07\x13\xcb\x26\xf4\x19\x71\x49\x5d\xd5\xc5\xfd\xe8\x13\x8d\x77\xf3\x5f\xa4\x3e\x24\x73\x68\x9d\x95\xf4\x37\xfa\x63\x12\x2e\x38\xfc\xe2\x5a\xfc\x8c\x44\x9f\xb9\x98\xd4\x39\xd0\xa8\x9e\xd4\xb4\x62\x62\x9f\xde\xe4\x4d\xd5\x17\x13\xb9\x6c\x05\x9a\x2e\xbc\x2b\x0d\xc4\x32\x76\x88\x49\xc4\x4b\x02\x39\x39\x76\x1b\x96\x83\x15\xbb\xc7\xed\x96\x48\x8c\x9e\x5d\x8a\x84\x95\x08\x04\xdc\x3e\x5d\xc2\xba\x39\x0f\x36\x89\x13\x75\xcd\xc8\x8d\xb7\xa7\x3e\xa5\x8e\xaa\x5f\x94\xef\x2e\x87\xc9\x9a\x9e\x8d\x00\xd9\x6e\x33\x8a\x90\x30\x28\x1a\xc4\x47\x81\xa4\x2a\xb8\x18\x56\x47\xa1\xb0\x82\xd0\xcb\x0a\x3b\xcb\x5f\x97\x30\x25\xd7\xa1\xad\x29\x68\xa9\xdb\x0e\x1e\x47\xff\x5d\xb1\xe5\x4c\xf1\x2b\xcb\xa3\x8f\x5a\xbe\x12\x13\x8f\x1b\xe8\x52\x69\xb4\x29\x82\xb3\x20\x5d\x35\xfa\x86\x85\xaf\xbd\xb6\xe0\xc6\xd1\xc6\xd9\xc4\x8d\x68\x3a\x7f\x54\x38\x86\x57\x49\x84\x39\x3d\xde\x23\x98\x9b\xeb\xd0\x78\x1e\x18\x87\xcf\xeb\xb5\x9a\x6d\x36\xab\xc3\x1a\x8b\x06\xbd\x01\xa7\x55\x35\xa9\x26\x5e\xb3\x2a\x16\x97\x83\xe5\x31\x85\xdf\x53\xd1\xa1\x13\x9d\x50\x2c\xb3\xd2\x08\x63\x6a\x1b\x4b\x05\x21\x46\x52\x41\x89\x1d\x7b\x71\xf4\x93\x5f\x36\xcc\x32\xa2\x12\x41\x4c\x45\x29\x46\x3a\xf4\x63\x07\x71\x12\xce\x84\x29\xa6\x02\x17\x5b\x97\x71\xdf\x64\x75\x86\x25\x1d\xa2\x18\x07\xe4\xfc\x79\x42\xbc\xa7\xdd\x27\x09\x36\xd5\xe7\x33\x0b\x4e\x7c\x23\x98\xa3\x48\x26\xa9\x25\x61\x33\x99\x04\x8b\xea\x6d\x4a\xa8\xaa\x60\xa0\x87\x0a\x27\x3d\x80\xae\xab\xeb\x78\xc0\x92\x42\x38\x30\x5c\x67\x28\x98\x78\x17\xa4\x83\x95\x2b\xa1\xf0\xe6\x9b\xe1\x8b\x9f\x92\x9d\xd0\x0e\xf8\xde\x5b\x37\x6c\xd8\xfa\xc5\x81\xd7\xd3\x98\xa1\x2c\xc1\xdb\xe1\xd7\xa6\xce\xa0\x13\x71\x87\x49\x54\x64\x4d\xd7\x2d\xa2\x1b\xab\xe1\x39\x01\xd5\x64\x36\x61\xa9\xeb\xe9\x84\x6c\x36\x8b\x56\x8d\x9e\x48\xdb\xb0\xec\x25\x5a\x41\xd4\xc7\x27\x44\xd7\xff\x6e\x75\x45\x26\xb0\x3b\xbb\xd5\xd9\x5e\xbf\xc6\x21\xf4\xa2\x45\xe0\xbf\xfe\xfa\xb4\xe7\x2f\x39\x80\x36\x7c\x7d\x92\x47\x53\x5e\x4b\x06\x7e\x44\x3e\xc5\x4d\xf4\x33\x43\xe2\x31\xb7\x8f\xb1\xf1\xb2\x47\x56\x3c\x16\x87\x83\xe7\x05\x8b\x90\x13\xe0\x1c\x24\x9b\x94\x28\xe8\xa2\x4e\x90\x22\xbb\xf3\x3e\xd6\xeb\xca\xcb\x53\xe9\x52\x52\x0e\x55\x04\xdc\x0d\xef\x71\xae\x92\xf8\x7f\x94\xe3\x7d\xef\xa9\xe6\xcd\x17\xde\x8c\xfe\x81\x3e\x65\xff\x96\x04\xed\xac\x99\x77\x6d\x40\xc7\xd1\x7b\x50\x57\x55\xb2\xe2\xae\xab\x25\x36\x54\x8a\x54\x61\xe9\x0f\x1f\xde\xff\xb7\x4b\x6f\x63\x43\x5f\xa0\x1a\xdb\x8a\xdb\xae\xce\xa7\xe3\x49\xe2\xe6\x76\xf2\xe3\xf0\xec\x93\xec\x5d\x25\x3d\x18\x1f\xe7\x8f\xf8\x73\x3c\x11\xbb\xd9\x6c\xf1\x58\x4a\x8a\x35\xd1\xc7\xf0\xac\xd3\x99\x4b\xfc\x8f\x65\x25\x10\x60\x2d\x01\x36\xaf\x21\xc1\xba\x33\x8d\xad\x6f\x4f\xbc\x93\x35\xfb\xb4\xc9\xf9\x62\x7b\xcc\x4f\x65\x61\x24\x17\x5c\x15\x24\xd2\x47\xa3\xed\xcf\xc4\xf8\xd0\x2e\x70\x0f\x8d\x3f\x7f\xce\x23\x3d\x44\x11\x1d\x32\x81\x26\x48\x7c\xd3\x89\x17\xde\x3f\xf3\xba\x15\xef\x7c\x39\x73\xde\xdc\x4b\x07\xf6\x5e\xbe\xe2\x5c\xd5\xdd\x73\xda\x99\x24\xb4\x87\xff\xf1\x8e\x66\xfd\xc2\xca\xd7\xd0\x17\xe8\xd7\x5f\x6f\xbd\xee\x3a\xf6\x4e\x98\xb1\x7b\xeb\x96\x9d\xc1\x6b\xaf\x9b\x3a\x32\x8d\x79\xc9\x3d\x2b\xe5\x30\x12\x93\x1f\xd7\x19\x4e\x10\x39\xd1\x6c\xc2\x75\x26\x00\x24\x4e\xa0\x56\xd5\xd2\x8e\xd1\x85\x86\xf3\x3d\xbb\xf3\x78\xf2\x0f\x02\x7f\x09\x77\x25\x97\x52\x04\x4c\x23\x16\x7f\x80\xf0\x4f\x5c\x57\x5e\x76\x5d\x24\x4e\x51\x70\x01\xc3\xd4\xd7\xd7\x77\x5b\xd5\xc8\xdf\xd0\x0c\x12\xa7\x08\xb7\x27\x1f\x36\x02\xf3\x09\x26\x84\x81\xc5\x29\x93\xac\x18\x22\x96\xbd\x38\x99\x9c\xcd\x2b\x76\xb3\xcc\xc8\x2d\x09\x11\xcf\x89\x55\x67\x85\xa6\x04\xdb\xbe\x18\xb2\x17\x29\xa6\x1e\xf4\x25\xe4\x1d\xae\x74\x16\xc4\xd8\x4a\xee\x93\x64\x03\xf4\x43\xaf\xa2\x4f\x57\x72\xb5\xec\xa8\xef\xd0\x5d\xaf\x27\x6f\x66\x2f\x35\xec\x55\x6a\x0a\x4b\x80\xbe\x93\x93\x24\x9b\x45\x30\x31\x26\xc6\xae\x88\x16\xab\xa5\x21\xc1\x59\xad\xb2\xc9\x25\xb3\x0d\x09\x59\xe9\xee\x9d\x64\x01\x96\xa7\xb1\x06\xf0\x5e\x30\x1c\xe1\x28\xe6\xc0\x8b\x2f\xa2\x83\x8b\x17\xf3\x7d\x77\xa0\x1f\x77\xa2\x04\x3c\xb8\x13\xf6\x51\x8c\xa1\x49\x42\x14\xf7\x31\xc4\x9c\x1a\x2f\xf4\x58\xf9\xdc\xdc\x90\x43\xd7\x43\x21\xd6\xca\x61\xfa\xee\x6a\x4a\x28\x21\x93\x9f\xe4\x3e\x32\x99\x98\x10\x1e\xd0\xa6\x04\xd3\xde\x59\xbd\x2e\xad\x80\x76\x0a\x8e\xa0\xd1\x81\x58\x92\x4b\x6b\x96\x14\xc7\x2d\xac\xa5\x11\xe7\x57\x12\x70\xd4\x09\xa7\x4f\xed\x0f\x0c\xf4\xb8\x19\xfd\xe7\xc9\xb5\xbf\x4e\x3e\xd4\xf4\x77\xe8\x7f\xd7\x3d\x43\x16\x4d\x22\x33\xfa\x2d\xda\x56\xe0\x53\xd0\x1d\xe8\xb5\x0f\xd0\x3b\xf7\x35\x9e\x7b\xc5\x04\x78\xf3\xe3\xef\x83\x3d\x92\x37\x1a\xf9\x1d\x28\x5e\x44\x2e\x33\x2e\xde\x53\x12\x45\xa7\xcf\xe1\x70\xca\x8c\xd3\xc3\x70\xe1\x90\xcf\x25\x71\xce\x80\xd2\x98\x08\x04\x5c\x4e\x97\xcb\xdb\x98\x70\x29\x9c\xa5\x31\xc1\x05\x3a\xe4\x53\xa0\x34\x45\xaf\xeb\x20\xb7\x93\xdf\xf9\x46\x06\x93\xb4\xc6\x96\x46\xc8\x77\xd1\xa8\xb7\x5c\xe0\xef\x42\x3f\xfd\xb1\x6e\xff\xa8\x7d\x55\x17\x9e\xb2\x70\xd1\xaf\xf1\x15\xb9\xe8\x20\xe7\x46\xfc\x9c\xe5\x77\x7d\xb5\xe8\xdc\x3f\xd1\xcf\xa7\x4f\x5c\x50\x56\x70\xc7\x46\x28\x21\xad\xe7\xfb\xfe\x88\x0e\x17\xcd\xfd\x8e\x60\x9d\xa2\xe9\x52\x3f\x3c\xce\x79\xcc\xb2\x78\x99\x9e\xa7\x30\x12\x1f\xf1\xf3\x1e\x4b\x20\x37\x18\xf4\xe4\x11\xd8\x53\x8b\xdb\x63\xb5\x58\x3c\x24\x2b\x84\x5f\x92\x2c\xb9\xe1\x18\xa6\xac\x2d\x89\x08\xaf\xf0\xc4\x22\xa0\x27\x74\x45\x09\x13\x58\x4f\x46\xd4\xc3\x81\xe6\x44\x38\x9d\x87\x2a\xeb\xf8\x39\x65\x16\x48\xa1\xe9\x75\x3e\x0d\xcc\xca\x54\xf2\x57\x78\x9c\x24\x9a\x25\x66\x60\x72\x86\xc6\x38\xfe\x02\x93\xb3\xf6\x9a\xe3\xb5\xff\x0b\x94\x33\xf9\x2f\x82\x7d\x94\x06\xe6\x84\xb6\x23\x58\xae\x78\x02\xcf\x5d\x3e\x33\x37\x5e\x64\x33\xb3\x11\x3e\x37\x3f\x9a\x97\x97\xeb\x15\x5c\x02\x5e\xe2\xd6\xa0\x2a\xe6\xe6\x16\x2a\x05\x11\x9b\x4d\xc9\x07\x96\x97\x38\xb3\xcb\x4c\x58\x83\x9e\xf0\x62\x3d\x2c\xe8\x56\x14\xd1\xea\x82\x68\xbb\x16\x96\xd5\x7f\x4f\xa6\xf3\xd4\x3f\xa3\xae\xdc\x80\x0b\xc8\x74\x9f\x50\xb9\x48\x8c\x42\x35\x68\x27\x83\x72\x70\xe0\xee\xf3\xcf\x17\x7e\x19\x1a\xdc\x3a\xc2\x7f\x32\x30\x87\xba\xd8\xbe\xc4\x2f\x14\xa6\xe1\x2f\xc1\x1c\xce\x0b\xa2\xab\x93\x0f\x1b\x78\xa4\x78\xcd\x12\x3c\xd2\x4a\x66\x56\xbc\x57\x79\xa8\x47\xac\xb4\xd4\xcf\x08\x4a\x51\x8f\x1e\x2e\xa7\xd3\xaa\x30\x7c\x75\x55\x79\x6e\x28\x94\x4b\xdc\x3b\x8a\x4a\x42\x21\xae\xa4\xa4\xa0\x29\x51\xc2\x4b\x32\x99\x7c\x6b\x42\xd2\x28\x7e\x8e\x83\x73\x18\x41\xfe\xd4\xfe\xd0\x9e\xf7\x2a\x7d\x36\xd7\x21\xd2\xc1\xb0\x8c\x19\x79\x99\xdc\x2e\x67\x24\xe5\x9e\x5c\x55\x59\x58\xf0\xbf\xd1\x48\xf9\xfb\x7f\x7c\x2f\x80\x8e\x95\xb4\x84\x87\x8e\xbd\x5a\xfe\x04\xfd\x3a\xa4\x2b\x2c\xe9\x70\x70\x7d\x44\x61\x49\xd7\x6c\x82\x9b\x1e\x3a\xe0\x99\x36\xec\x17\x5d\xbb\x31\x78\x57\xef\x3a\xe9\xb9\x97\x3b\x60\x94\xbe\xfb\xaa\x81\x51\xfa\x08\x19\x8b\x2a\x34\x89\xe2\x5a\x54\x31\x73\xe2\xde\x3c\xd5\xef\x08\x87\x6d\x85\x25\x8c\xcf\xef\x17\x05\xa1\x0f\x53\xc8\xd7\x54\xf7\xae\x24\x73\x9e\x97\xe8\x5d\x3e\x3e\xd1\x3b\x10\x53\x54\x55\xc1\x22\x41\x4f\x5f\x50\x55\x7b\x06\x7b\x9a\xc7\x25\x7a\xba\x83\x6e\x72\x5c\x49\x58\x5b\x7d\x77\x43\x61\xa4\x85\xed\x6e\x38\x84\x4a\x2a\x8e\xff\x1f\xa0\x2d\xb2\x47\x0d\xde\x91\xd7\xed\x29\xc8\xc6\xb9\x20\x87\x92\x19\x9c\x8b\x17\x36\x64\x06\x6b\x41\x49\x7f\xcb\x3d\xab\xb2\x41\x2f\xc6\x0c\xc9\x06\xbd\xb8\xe6\x41\x7d\xea\x70\x3a\x50\x06\xc6\x1b\x8f\xe9\x1d\xe3\x66\x1a\xe3\x1e\x8b\x26\xb1\xac\xcb\xe5\xb6\xda\x65\xd9\xed\xf5\xd8\x55\xd6\xd9\x92\x60\x35\xb2\x02\x94\x04\xcb\xaa\x22\xc3\xb9\x75\xd5\xda\x9c\x50\x53\x7b\xdf\x30\x49\x51\x4b\x54\x36\x10\x58\x06\x71\x22\x83\x77\x6a\xec\xe9\x34\xe6\x69\xf9\xcc\xe9\x69\xcc\xd3\x31\xd7\x1f\xef\x87\xae\xd3\x1b\x53\xa0\xa7\x33\x37\x18\xa0\xa7\xe9\x6d\x6b\xf5\x52\xe0\x53\xa0\x72\x34\xe0\x7d\xeb\xc6\x92\x9c\xdb\xaa\x9b\x68\x3b\x6d\x8a\xdd\x2e\x99\x4c\xb8\xa9\x8a\xc6\x3a\xf1\x8c\x6d\x4b\xb0\xba\x71\xa8\xcc\xb2\x9a\xc4\x28\x58\x96\xb0\x35\x24\x34\xd7\x5f\xb4\xb6\x63\x83\xb3\x77\xa1\x16\x4b\xe3\x64\x94\x95\xd6\xf6\xb8\x92\xe2\x64\xec\xbb\xe0\x97\x5e\xed\x38\x19\xf9\xa7\x9f\x46\xb6\xd9\xf8\x32\xb2\xcd\xe0\xf6\x34\x56\x46\x1a\x37\xd6\xc3\x5c\x1a\xaf\xb5\xb9\xcd\x6e\x8f\xee\x51\x78\xa7\xc3\xae\x48\x1c\x87\xc9\xa9\x0f\x53\x12\xc1\x62\x11\x3c\x1e\x5e\xb0\xe9\x2d\xc4\xd3\x4b\x90\xd8\x96\x84\xc4\xe0\xff\x12\x6f\x17\x38\x27\x9f\xc9\x4a\x54\xdc\x29\xef\x65\xda\xdc\x93\xa5\x0c\xe8\x75\x19\x3f\x30\xd1\x08\x81\x2a\xaf\xc1\x97\x33\x50\xb3\x5a\x8c\xd5\xaa\x4b\xd0\x67\x78\xd1\xf5\xbc\x20\xf1\x64\x16\xda\xec\x47\x17\xb0\xb3\x5d\xc9\x0d\x64\xe4\xf3\x61\x19\x3a\xbe\x16\x72\x53\x90\xb3\x56\xf4\x2a\xc3\x64\xe1\x8f\x78\x99\xa6\x78\xd0\x62\x35\xe9\xba\xe0\x60\x3d\x1e\xaf\xea\x75\xd8\xad\xbc\xe2\x53\xfc\x9a\xc3\x69\xc7\x12\xb5\xdb\xc8\x95\x6b\x62\x45\x07\x2b\x8a\xac\x83\x53\xbd\x2e\x4b\x0a\x0a\xc2\x38\xc0\x4f\x6d\x8c\x3a\x8d\xe2\x93\x60\x56\x50\x9e\x75\x82\x6f\x8c\x3e\xe0\x76\xbb\xea\x21\x85\x52\x82\xc5\x87\xd4\x04\x38\x43\xda\x69\x7d\xe6\x66\x90\x4a\x36\x9e\x96\x53\x64\x4c\x01\x09\xe0\xad\xfb\x78\xfa\x7f\x52\x60\x25\x63\xf7\xc0\x40\x89\xce\x01\x93\x9a\x03\x3f\x33\x3d\x5e\xa4\x3a\x64\x5e\xd7\x34\x9b\x2c\x7a\xfc\x5e\xde\xe4\xf1\x80\x57\xf6\xe6\x04\x24\x3f\xe3\xa7\x1e\xb3\x5e\xd6\xe4\x6e\x49\x98\x1c\x64\xa1\x5b\x12\x26\x93\xd7\xc6\x72\xba\xb7\xcb\x14\x54\x74\x42\xaa\x6a\x6f\x3e\x5d\x3e\x5a\x4a\xfe\xef\x82\xf2\x8b\x65\x2e\xa2\xb4\x64\xad\x7a\x8a\xf4\x4b\x17\xfd\x4a\xfe\x0b\xac\xb6\xa0\xd6\xf4\xc2\x27\x68\xbf\x64\xd1\xf3\xbd\x0d\x79\xcc\x8a\xe5\xb1\x13\x58\x87\xf1\x63\xba\x1d\x70\xb8\x55\xcc\xa7\x7d\x2e\xa7\xa2\x9a\x7c\x80\xa5\x6f\xd5\xe9\xf4\xe7\x04\xcc\xc0\x02\xd5\x64\x44\x96\x55\x78\x8b\x97\x6e\x04\x8b\xdb\x50\x68\x2c\x16\xbf\xc2\x83\xa2\xb8\xfc\x34\x2e\xcd\x70\xa8\xed\x5e\xa3\xc9\x66\xd4\x74\x3f\x64\x54\x9a\x4e\x40\x43\x91\x6b\xaf\x58\x04\xbe\x1b\x6e\x68\xdf\x17\xed\xf8\x31\x86\x62\xf3\x41\xfb\xde\x68\xc7\x90\xf1\x33\x8c\xe8\xc1\x73\xe2\xc4\xda\x83\xcf\x66\xb5\xc8\x98\xda\x68\x9a\x6e\x15\x25\x9d\x91\xc8\x91\x2c\x41\x53\xa6\xfc\x46\x25\xa8\xca\x8c\x48\xd3\x9f\x39\xdb\x45\xbe\x8a\x4c\xeb\xb3\xe8\xaa\x5e\x97\x02\x84\xe8\x3a\xee\x11\x3f\xfb\x7a\xb7\xa3\x8e\x9a\xb2\x89\x4d\x66\xcc\xef\x31\xc6\x1c\x6b\x3b\xfc\x37\x34\x7f\xd7\xe9\x71\x97\xac\x5a\x78\x4c\x66\xcc\x16\x1e\x0b\x79\xe0\xb4\xe0\x76\xf2\x3a\x1d\x61\x5e\x25\x23\xac\x26\x78\xde\xc9\x9a\x15\xc5\xe9\x62\xa1\x31\xc1\x2a\xdd\x36\xb5\xc3\x42\x01\x02\x8e\xd8\x69\x44\xe1\x12\xf4\x34\x7b\x6e\x37\x03\xca\x35\xfe\x98\x4d\x69\xd2\xa3\x99\xc6\x8f\xdd\x42\xf0\x39\x09\xd2\xbe\xcd\x0c\x26\xac\x28\x2a\x76\x01\xec\x9c\xa6\x2a\x60\xe2\x9a\xf1\x52\x06\x8b\x88\x55\x18\xb0\xb5\x1f\x72\xb7\x1f\x23\x74\x8e\xa2\x8c\xc4\x3a\xc6\x14\xf3\x4f\xae\x4b\xde\x49\x53\x75\x4c\x83\xc2\xd9\xc7\xdb\x53\x73\x50\x58\x59\x23\x06\xe4\x79\x8a\x9b\x84\xdf\x6f\x92\x04\xd6\x02\xb2\x6c\xb7\x5b\x24\xfc\x7e\x93\x05\x30\xe5\x05\x02\x0b\xa5\xd8\x5d\x16\xa1\x21\x61\x71\xfd\xc5\xfb\x2b\xda\x51\x5b\x28\xe5\xcd\x42\x88\xb9\xfc\x97\x7b\xdb\x21\x62\x8c\x70\xe6\x14\x4c\x4c\x3a\xcf\xdb\xe7\x29\x1d\x29\x2c\x9b\x18\x42\x61\x89\xe1\x5c\xb1\x4b\x6c\x33\xa1\xa6\x66\x81\x63\x78\xdd\x6c\x6b\x4a\x98\x3b\xae\xa2\x8e\x79\xda\xb3\xa2\x8f\xb0\xac\xcd\xbb\xd3\x1d\x67\xf7\xa0\x96\xf6\x8e\x7f\x77\xe2\xdc\x14\x26\xd1\x3f\x52\x3a\x52\x18\xac\x56\x9b\xc4\x9a\x78\x93\x8d\xb3\x2b\x60\x21\x7d\xb6\x71\xb2\x62\xb2\xb9\x38\x11\x4b\xfd\x4a\x77\xef\xac\x68\x77\xc8\x49\xc1\x98\xa4\x7a\xcb\xce\x45\x1b\xb3\x11\x71\x7e\x6c\xdd\x9a\xdd\x57\x34\xc9\xb4\x92\xea\x4a\x89\x78\x2f\x2c\xb6\x31\x52\x28\xc4\x70\xbc\x8f\x04\xad\x61\x6d\x49\x92\x04\x17\x6f\xc9\x69\xc2\x5b\x9e\x17\xa8\xb4\x86\x3b\x6e\xc0\x6d\xa7\x1a\x91\x3e\xaa\xa3\xa3\xdf\xf9\xe0\x39\x2d\x98\x1b\x3f\x59\xc7\x72\x59\xca\x93\x94\x41\xe7\xee\x7b\xfd\xb9\xd9\xca\xd3\x94\xb5\x44\x79\xba\x62\xa1\x01\xda\x9d\x3c\xe0\x2f\xe8\xac\x3b\xd5\x24\x17\xa7\x72\xe3\x49\xe5\xb8\x3f\x21\xe6\xbc\x78\xa5\x49\x92\x9c\x01\xbc\xad\x3c\x5e\x99\xf1\x3a\x09\x48\xa3\xc9\xc4\x7b\x83\x6a\x43\x22\x18\xf4\xfa\x02\xfa\x38\xac\x44\xf9\x9c\x5e\x97\xcf\xdd\x90\xf0\x61\xca\xd6\x90\xe0\xb3\xb4\xa8\x8a\x76\xd3\x4c\x7b\x52\xe8\xce\xfd\xa1\x29\xc1\x53\x38\xde\x29\x29\x33\x33\xd3\x58\xa3\x62\xa4\xf2\x6b\x7f\x5f\x7f\xed\x53\xa3\x1e\x9e\xb8\xec\xa6\x45\x37\x2c\x1f\xfb\x37\x63\xf8\xb9\xa7\xd7\x9e\x75\x04\xef\x9a\x7f\x1c\xbe\x62\xc8\xa8\x2b\x47\x3e\xbe\xf9\xf6\x3b\xfd\x68\xb6\x01\x21\x84\x94\x20\x3a\x42\xec\x21\x24\xb7\xd2\x2c\x61\x2d\xa6\xd1\x15\xcc\x25\xf1\x7e\x39\x66\x73\x61\xd4\xcd\xf5\x72\x17\xf6\xca\x67\xd4\x32\xc9\x56\x19\x0c\xfa\xb1\x6e\xe0\xef\x29\x36\x25\x7a\xf6\xd4\xfd\x8c\x8a\x49\x19\xa3\xfb\xfd\xa1\xa6\x84\x9f\xb7\x97\x35\x25\xec\x0e\x3d\x9f\x78\x70\x75\x17\xe1\xd7\x89\xe9\x77\xf2\x11\x18\x08\x55\x69\x94\x44\x0a\xea\x2e\x12\xd7\xa2\x2a\xe2\x69\x94\xf2\x19\x21\x67\x51\x05\xf8\x42\x4a\xa0\xac\x28\xaf\xe1\x1e\xef\x51\x53\x52\xd9\xa7\x6f\x1c\x0e\x8f\x9e\x73\xcb\x8c\xd9\xf7\x3d\x8d\x7e\xb8\x6d\x25\x08\xcf\x5e\x30\xb9\xa9\xa6\x66\xc5\x0d\x2f\x3c\xbe\xe8\x99\x4d\xeb\x1e\x18\x58\xe9\xbb\xb2\x11\x84\xbe\xdf\x4e\xbe\x65\xe9\xb2\xd5\xe7\x7d\x86\xf6\xe6\x55\x56\x6e\x87\xc1\x6f\x7c\x0d\xe3\x9f\x29\xf8\x50\x3d\xfe\xe7\xd1\x36\xe6\xd3\xc3\xff\x02\x13\xfa\xcf\xb4\x5f\x9a\x4b\x0d\x5b\x1b\x1e\x0b\x7e\x16\x3f\x86\x29\x60\xca\x98\x8b\xe2\x2e\x57\xb8\x77\x61\xae\xad\xb8\xd8\xab\x4b\x92\x37\xb7\x77\x9e\x50\xde\x27\x40\x0e\x3b\xe3\x85\x78\x4a\x79\x4b\x6f\xb6\x31\x41\x62\x68\x2c\x58\x4f\xb6\xa8\x7c\xef\xc6\x04\x13\xc3\xff\xc3\x24\xfe\x95\x77\x8d\x4b\xf0\xe9\xe4\x83\xa9\xa4\xa5\xdd\xc6\x3d\xa6\x30\xda\x49\xd7\x09\x3a\x64\x7b\xc7\xdd\x15\x46\x6c\x35\xe9\xb9\x84\x99\x82\x64\x07\x7a\x7e\x40\x8f\xe1\xb9\x8d\x13\xc6\x4e\x3a\xff\xbf\xe8\xc8\xbf\xde\x3d\x7d\xc2\x29\xbe\xb2\x09\xe7\x5c\xbf\xb8\xb8\x66\xd5\x95\x4b\x56\x9e\x51\x32\x3b\x04\xe5\x13\xee\x1d\x35\xb2\x67\x24\x54\xe8\x8c\xc5\x20\x0f\xa4\x24\xd4\xc5\x5e\x71\xbc\x7c\xdf\xe3\xaf\xc4\x9f\x6e\xdc\xf2\xdc\x4b\x0f\x3f\x7c\x8b\x43\xdd\xe1\xb1\xb3\xd2\xb3\x4f\x8f\xd8\x58\x12\x79\x90\xe4\x10\x43\x93\x08\x16\x3d\xe6\x1b\x67\xc7\x83\x79\x26\x62\xbf\x08\xfb\x64\xd9\xc4\x87\xf9\xc2\x02\x87\x43\x0d\x85\xa2\x2a\xc3\xb7\x24\x18\x91\xf0\x36\x2d\xc1\x58\x54\x77\x53\x42\xe5\x2d\x8e\x28\xde\xad\xd1\x34\x04\x69\x07\x07\x98\x6e\xfd\x5f\x32\xfa\x53\x5e\xd7\x63\xc7\xea\x1a\x81\x15\x48\xc8\xd1\x5d\x86\x16\x60\x47\x3b\xd0\x7d\x30\x0d\x26\xc0\x0f\xcb\x51\x6b\xe4\xa5\xab\x5f\x7f\xef\xc3\x37\x16\x3f\xd7\x17\xe0\x66\xb4\xda\x8f\x26\x51\x45\xa9\x4f\xb5\x15\x16\xc1\x78\xea\xe5\x42\x42\x47\xfe\x7b\xe4\xd7\x36\xe6\xca\x1b\x5b\xd0\xfa\x92\x96\x53\x7e\x61\x52\xe7\x92\x24\xb6\x99\xf4\xad\x24\xcf\xe4\x74\xe4\x86\x7c\xb2\x23\x24\xf3\xa6\x10\xee\x9c\xd3\xa9\xe6\xe6\x46\x55\xd5\x43\x23\xf6\xdd\xd1\xc0\xf8\x44\xd4\xc5\xf0\xe3\x69\x57\x31\x8b\xec\xe0\xee\x52\x7f\x92\xd5\xdc\xa9\x6f\x9d\xce\x2e\x55\x23\x1e\x04\x88\x2e\x04\x9f\xa6\xfa\x76\x30\x99\x7d\x90\x79\x80\x46\x83\x68\xaf\xdc\x11\xc8\x74\xcb\x02\x51\x94\x75\xa6\x89\xae\x3b\x6f\xaa\xbc\xea\xcd\x9c\x73\xc6\xfc\x42\x72\x49\x61\xbe\xf5\x0e\x8d\x07\xa9\x8a\x07\x40\xe4\x78\x0b\x2f\x9a\x78\x9b\xcc\x8b\x8c\xc9\x6c\x22\x8c\x42\x84\xe6\x84\x98\x81\x3b\xa6\x36\x8d\xec\x4c\x0a\x69\x1e\x45\xb3\x46\x5d\x71\xfc\x21\x23\x59\x54\xeb\x24\xa2\xb3\xd0\x24\x51\xc0\xf4\x45\xd3\x29\x86\x18\x7d\x07\x96\x9b\x81\x13\xc0\xca\xcb\x36\x2b\x48\x1c\xcf\x61\x42\xa6\x10\xe0\xb4\xcc\x49\x6e\x97\x77\x44\x8c\xea\x29\x3b\x64\x6d\x1b\xd0\xfb\x04\xe7\x6a\xc1\x2f\xdc\x15\x3b\x76\x24\x07\xa7\x74\x7a\x22\xe3\x62\x6a\xcb\x98\x98\xbc\xb8\x6a\x02\xe0\x59\xd6\x62\x16\x49\x72\x9c\x94\x2f\x68\x2a\x41\x6e\x16\x7b\x85\x88\x03\x22\xec\x6b\x44\x02\x82\xbe\xc7\x41\x80\xbe\x6c\x7d\xf2\x25\xb6\x9e\x1b\x9c\x7c\x8d\xad\x23\xfe\x6a\x78\xbe\x2f\xa4\x18\x21\xb8\x4e\x1b\x63\xb1\xb1\x0c\x63\x97\x45\xd1\x8c\x05\x9b\x80\x81\x10\x6f\x54\x99\x1e\x0a\xea\xad\x36\x10\x48\x62\x1e\x78\x10\xb5\x50\x1f\x35\x5b\xfd\x6e\x28\x40\x13\x49\x08\x34\xdf\x37\xf9\x78\xf9\xeb\x65\x7b\xd9\xff\x8f\xb1\xe7\x00\x8c\xaa\x48\x7b\xe6\xcd\x2b\xfb\xb6\xbd\xed\x25\x9b\xb6\xd9\x54\x02\x09\x64\x49\x42\x42\x5b\x10\x91\x26\x09\x11\x90\xa5\xa3\x02\x8a\x22\x82\x20\xd2\x05\x45\x50\xc0\x82\x15\x54\x44\x0e\x51\x51\x01\x01\x91\x03\xc1\x2e\xa2\x62\x2f\xa7\x58\xce\x8a\x87\x1d\x39\x4e\x81\x9d\xfc\xdf\xcc\x7b\xbb\xd9\x4d\xe0\xfe\x23\x0a\xc9\x66\xf7\xcd\xf7\x7d\xf3\xd5\x99\xaf\xf4\x3f\xf5\x2a\xbd\x10\x65\xc0\x6d\x07\xfb\x99\x23\xab\x16\xc1\x6e\xb1\x5a\x1d\x9a\x28\x5a\x05\xb3\x1d\xd9\xc7\x41\x20\x84\xac\x92\xa0\x0f\x7d\x6e\x53\xda\x50\x97\xea\x12\xc5\x4a\x31\xdc\xac\xec\x45\xb7\xa1\x51\x8c\xe8\x21\x03\x2b\xfa\x32\x6a\xa6\xb7\x03\x9a\xab\x49\x96\x30\x99\xe1\x96\x58\xf3\x5d\xe2\x0d\xa1\x1a\xa5\xe1\xe8\x42\xb1\x58\x9e\xd9\xa6\x09\x10\xd3\x6a\x1a\x76\x38\x3c\x6e\x59\x46\x80\xa9\x23\x64\x77\x21\x57\x43\xdc\xc2\xba\x36\x55\x25\x13\x56\xd3\xa9\x99\x2c\x45\x8b\x86\x5b\xf0\xe7\x15\x69\xd5\xe1\x69\xb8\x4b\x26\x19\xe0\xe7\xd7\xe8\x11\xfa\x5a\x3a\x29\x5e\xf8\xe1\x07\x9d\x16\x6c\x5e\x52\x03\xf7\xe1\x2e\x88\xb5\x93\x4c\x82\x45\x94\x55\xb3\xd9\xae\xc8\xc0\x96\x56\x70\x9d\xec\x22\xf8\x52\x26\xcc\x92\x16\xb1\x0a\xaf\xb5\x72\xe5\x74\x33\x9e\x11\x10\x1a\x32\xe5\xd2\x0f\x9b\x54\x3e\xb9\x82\xff\xc7\x3c\xba\x61\xe7\xd1\x75\xf0\xf5\x1a\xfe\x81\xf6\xc2\x5d\x70\x1d\x7c\xd5\x80\xa3\x51\xbf\xe9\x24\x1b\xb8\x26\x7c\x27\xdc\x4f\xed\xf8\x58\xe2\x12\xaa\xf1\xc1\x01\x98\xf7\x86\x1d\xc7\x7d\xbc\x8b\x62\x79\x67\x81\x0f\x58\xd9\x84\x65\x49\xd0\xdd\x61\x8b\x24\x01\xa4\x9a\xe8\xe5\x0e\x60\xba\xd3\x17\x35\x14\x40\x2a\xfc\x6e\x0b\xae\x85\xc3\x1a\x32\xc0\x25\x57\x76\x3d\x4d\xe9\x87\x78\x25\x5d\x86\x2b\x8f\x7c\x8f\x3b\xc1\xbf\xa6\x25\xbf\xe3\xe5\xf4\x5a\xa1\x12\x42\xd4\x75\xf8\xa2\xc4\x9f\x74\x25\x17\x07\x80\x35\x40\x2f\x95\x1f\xe6\xb4\x8c\xc5\xc2\xa2\xcd\x24\x59\xcc\xc8\xc6\x07\x75\x3b\x2c\x36\xf0\xc4\xb4\x71\x71\x19\x11\x93\x68\x13\xc7\xc7\x6d\xae\x54\x03\xa5\xd6\xc2\x97\xde\x5e\xce\xa9\x0f\x9f\x0a\x07\xc8\x67\xf4\x75\x41\x61\x7d\xd5\x4f\xfd\x44\x17\x4b\x8b\xbf\x3d\x7d\x61\xb2\xb1\x3a\x84\x0d\xec\x7c\xed\x52\x69\x28\xa7\x53\x2f\xbe\xb6\x00\x8b\x9b\x25\x1b\x12\x1d\x4e\x7d\xed\x06\x58\x5b\x63\x6b\x37\xe8\x2d\x83\xcf\xbc\x76\x72\xf1\x48\xda\xe2\x91\x0a\xe1\xf0\xb7\x7a\x57\xb0\xd3\x4f\x7c\x2e\xd6\x83\x02\x48\xf6\xf5\xd1\x7b\x39\x5d\x09\x6b\xdf\xce\x67\xe3\x9d\x1f\x2b\x71\x81\x13\xaa\x80\xdd\xc3\x1e\xe2\xf7\x79\xb1\x26\x4c\x88\x03\x6f\x9b\x6c\x22\xab\x70\xc3\x0e\x13\xc1\xae\x16\x06\x4a\x77\xa1\x5a\x7b\xe4\x5c\x07\xb5\x1e\xfe\xc0\x78\xe8\x9e\xc7\x8e\xbc\xf9\xeb\x17\xc9\x01\x10\xf3\x4f\x0a\x91\x0b\xbe\x3c\x96\x1a\x01\x61\xc4\x06\x17\x00\xdf\xdc\xce\xcf\x6b\x86\xc4\x9c\xaa\x6c\xc7\x5e\xab\xc5\x6b\xb7\x90\x80\xdf\x6a\x97\x35\xc6\x29\xde\xb8\x2c\xdb\x7d\xc4\x05\x4e\x32\xb1\x2b\x3e\xcd\xae\x36\xc4\xed\xde\xff\x05\xae\x96\x86\x66\xba\x1e\x6e\xd5\xd4\x6c\xee\xef\x1b\x86\xaf\xbd\x29\xad\xab\x99\x11\x34\xa4\x3a\x9b\xa5\xcf\xc3\x08\xa0\x09\xb1\x2a\xb7\x28\x3a\x24\x2f\x42\x01\x1b\xec\x59\x80\x64\x05\x9d\x4e\xe0\x62\x64\xf1\xe2\x09\x71\xaf\xd7\xe2\x76\x23\x8b\x43\x61\x65\x9f\x13\xc0\xcc\xf9\x2c\xa9\x59\x19\x69\xc6\xfa\x2c\xb6\xcd\xf0\xa9\x65\x85\x01\x9a\x24\x25\x3b\xee\xad\xd1\x47\x69\x5c\x31\xe9\xb9\x02\x46\xcb\x09\x33\x9e\x9b\x7c\x39\x9b\xa6\x51\xea\xa1\xef\xe0\xa0\x4e\xcf\x15\xf3\x2d\xf8\x55\xda\xd3\x1a\xe6\x83\x35\x5a\x7a\xc0\x05\x20\xde\x2a\x34\x59\xad\x16\xd9\xe1\x20\x4e\xec\xf7\x3b\x2d\x00\xb3\x87\x34\xc6\x9d\x56\x9b\xe6\x22\x01\x8f\xc7\xaa\x06\x34\x36\x2f\x9c\x53\x12\x64\x8b\x9f\xbd\xa4\xbb\x13\x46\x63\xb8\x14\x28\x0c\x46\x6f\xa4\x3a\x49\xc9\xd5\xd3\xca\x2e\x63\xed\xe1\xae\x28\x9e\x56\xdf\x43\x27\xe5\x1a\x82\xe3\x74\xab\x92\xab\x77\x89\x2b\xb1\xbc\xfd\xb4\x99\x93\x53\x9f\xf3\x13\xe6\x73\x92\xba\xc5\x72\x59\x1f\x5b\xd5\x64\x72\x7a\xdc\xa2\x8d\x65\xca\xc3\xb2\xda\x04\x08\x8a\x9c\x2e\xa2\x3a\x93\x83\x19\xcf\xd0\x55\x2a\x35\x26\x38\x7d\x2e\x23\xde\x76\xd3\xfe\x31\xbf\x7e\x41\xbf\x5d\x74\xf7\xad\x4f\xb1\x7b\x99\xc4\xe7\x9d\x0a\xbe\x3c\xc6\x26\x32\x02\xb3\x25\x20\x8a\x37\x7a\x93\xb0\x7e\x0f\x2e\x19\x0d\xe4\xbe\xa8\xa5\xf9\x27\x79\x39\xf8\x63\xf9\xe0\x8d\x4e\x88\x75\xca\x47\xc8\x1f\xc9\xca\x72\x4a\x76\xb5\xd0\xaf\x4a\x7e\x52\x5a\x62\xb1\x78\xf2\xf3\x05\x4f\x96\xe4\x94\xc6\xc5\x23\x4e\xa7\xe0\xf1\x84\xc7\xc5\x3d\xa2\x90\x33\x2e\x2e\xb8\x33\x3a\x5f\x9d\xa9\x92\x37\x93\x8a\x6c\x6c\x2b\xe1\x69\x49\xb5\x7e\xe6\x7d\xfa\x79\x93\x78\xa7\x47\x09\xeb\x39\xfe\x38\x9f\x84\x2b\xb0\xdc\xed\x7a\xda\x9d\x7e\x47\x37\xe7\xd8\x37\x3c\xe9\x7f\xc7\xdd\xfb\xbc\x3c\x70\xbb\x7c\xa0\x80\x2f\x54\x4e\x07\xdd\xcf\xdc\x31\xf7\x9e\xf6\xf4\x65\xba\xc3\x27\xbc\x6a\xdd\x8b\x87\xd2\x7b\xc1\xc5\xcf\x7d\x6c\xc3\x05\xe3\xf2\xba\x76\xe9\x5f\x87\x71\x0e\xee\x4f\x57\xd2\xad\x3d\x06\x6e\x7d\x73\xd2\x14\xe2\xa7\xf3\x9f\x7f\xd9\xc0\x55\xca\xe5\x3d\xa3\x0a\xd1\xec\x58\x2c\x2b\x14\xf2\x84\xbd\x5e\x1b\x31\x4b\x05\x1e\x89\x78\x48\x71\x91\xa2\x20\x87\x97\xd8\x48\x53\x3c\x6c\x0b\x3b\x9c\xfd\x34\x1b\xb6\x4b\x36\x1b\x72\x38\x72\x9b\x80\x9d\x51\x16\xc4\xe8\x59\x56\x60\xfe\x21\x99\xcd\x67\xd2\xfb\x2d\x9d\xb1\xb6\x30\x45\x01\xa9\x00\x95\x14\xa6\xb0\x67\x67\xf8\x2e\xa7\x37\xcc\x55\x06\xcb\xf1\x65\x85\xcd\x15\x98\x74\x3d\x42\x4f\xd9\xe8\xc1\xa2\x9d\x39\x75\xfd\xb2\x30\xf9\xf4\x5f\x27\x12\x03\x66\x5d\x71\x57\x09\x56\xeb\x7e\xdb\x7c\xf1\xe5\x04\x6f\x34\x5d\xe9\xc1\xe2\x7f\x94\x4f\x86\xce\xed\xd8\xbb\x53\x79\x07\xf2\xde\x77\xf4\x0d\xfa\x91\x69\xdd\x43\x8b\xfd\x77\xae\x26\x4f\xdd\x3c\xff\xfa\xeb\xf5\xfd\xa5\xbf\xf3\xfd\x8d\xa0\x32\x74\x45\xac\x36\x37\x2f\xcf\x5b\x1c\x08\x68\xa4\x20\x62\x55\x4a\xbc\x0a\x89\x78\xc5\xf2\x76\xaa\x8a\x72\x73\x5d\x11\x14\x0b\xf0\x2a\x99\x62\x4d\x43\x2e\x57\x21\x04\x5b\x22\x0a\x8d\x8b\x87\xf9\x10\xb5\xd6\xdb\x7c\xc6\x34\xbf\x74\x44\x8b\xff\xeb\x46\x83\x03\xee\x8c\xb8\xf9\x6e\x93\xd5\xbf\xd3\xaf\x43\x67\xdf\x69\x6c\xba\x9a\x3e\xf0\xc1\x24\x63\xbb\xed\x21\xf8\xa5\x70\xb6\xcd\xee\x4f\x0f\x94\xd1\x66\xe9\x25\x7d\xcb\x75\xfc\xf9\x9e\xe7\x01\x7f\xdf\x1c\x1b\xc4\xf6\x3c\xc2\xf6\x3c\x37\xcf\x2c\x15\xb2\x5d\xcf\x13\x4b\x4b\x14\xc5\x91\x87\x62\xfa\xc6\x47\xd8\x80\x5e\x81\xb4\xda\xfe\xfc\x96\xed\xcf\xe2\xdb\x9f\xc3\xf6\xbf\xea\x8c\x0c\x30\x6e\x4c\x06\x81\xce\x42\x1d\xe1\xac\x6c\x20\x33\xca\xe8\x8c\x20\xbc\xfb\xcc\x21\xcb\x19\xf9\xe0\x22\x7a\xfc\xed\x29\x06\x27\x58\x43\x18\xfd\xe3\x8c\xac\x70\xb2\x88\x52\xf1\x09\xce\x0c\x67\x98\x67\xcc\x67\x3a\x2a\xe5\xae\x62\x72\x40\xef\x65\x22\xf4\xc7\xb5\x2c\x27\x34\x1c\x96\x8a\x71\xe1\xee\x66\xba\xb3\xb0\x9d\x1c\xca\x98\xb5\xca\xfb\xca\xf3\x9e\xdc\x47\x8c\x9e\xdc\x4b\x8c\x9e\xdc\x3c\x91\xb4\x08\x15\x95\x8b\xa1\xf4\xb9\x70\x10\xef\x45\x40\xf5\x84\x21\x26\xea\x60\x11\x14\x93\xc9\xee\x05\x05\x22\xe4\xe7\x87\xb3\xec\xf6\x30\x44\x9a\x61\x8b\x25\x8c\x84\x3c\x36\x1c\x2e\x8c\xf8\x51\x4c\x98\xcd\xa0\x60\x66\xa3\x2a\x95\x30\x7d\x26\x6f\x28\xf9\xe5\x32\xee\x4f\x7a\x08\xfc\x44\xd3\x87\xbc\x2c\x6d\x37\x75\x8c\x51\x81\x59\x8d\xe8\x4d\xb8\x24\x37\xda\xbd\xf1\x24\x3b\xde\xac\x3b\xe7\x67\xac\xd0\x03\xf4\x3b\xfd\x2a\x7b\xe3\xbd\x23\xb6\xcf\x7e\x87\xdf\xa9\x3c\x18\xec\x79\x35\xbe\x9b\x4e\x18\x39\x34\x97\xbe\x76\x1c\xde\xb2\x89\x1d\xc9\x7c\xf6\xd1\xbc\x6d\xe3\x12\xab\x8d\xbb\x95\x0b\xc5\x7b\xc1\xae\xe4\xa3\x78\x2c\x0b\x05\x72\x72\x73\x21\x8e\x50\xbd\x60\x46\xbc\x9a\x20\x78\x0b\xc2\x66\xb3\xec\x0d\xb8\xf5\x8b\x95\x40\xc0\x9b\xe3\xd3\xbc\x5e\x19\xbc\x3b\x39\x94\x7e\xa4\x97\x3a\x83\x39\x13\x32\x58\x74\xb6\x3a\x89\x29\xd7\x8f\xfb\x8c\x73\x50\xe1\x2b\xfc\xcc\xb2\x13\xeb\x17\x3c\x77\xfe\xae\xa1\xd7\xdc\xba\xf4\xde\x8d\x1b\x58\xc3\x9f\xe4\x79\x68\x81\x30\xbc\x33\xed\xb1\xe1\xc7\xf9\xbd\x9b\x66\x9d\xb7\xfd\xf1\x0d\x8f\xd0\x5e\xe9\x17\x30\xdd\x8d\x5a\x1b\xf0\x83\x1e\xe7\xf7\x2e\x5d\x63\x39\xd8\xe1\xf6\xf8\x5d\xaa\xc3\x45\x82\x01\x8b\x45\x76\xa9\xaa\xc3\xeb\x97\x8d\x31\x79\x86\x97\xa1\xdf\xd5\xb6\x34\x68\x88\x9e\x65\x4e\x5e\x94\xa5\x58\xe9\xb3\xf2\x26\x3f\xb0\x42\x9f\x95\x77\x4e\xfe\x39\x64\xf7\x3d\xdf\x9f\xbc\x7f\x1a\x1f\x97\xb7\x8c\xee\xbf\xd1\xf9\x1f\xe5\x16\xdc\xe7\x3b\xfc\x49\x6a\xe0\x0e\x46\x5e\x80\xc9\xc2\x6d\x36\xd8\x46\x02\xa1\x02\xf6\xda\xdc\x5e\x30\xd7\x01\xd5\x0d\x61\xa0\x5b\xd3\xbc\x36\xd5\xd6\x18\xc7\x6a\xb2\x9b\x48\x54\x2f\x85\x79\x35\x03\x28\x16\x0e\x0a\x76\x92\xd1\xe1\x09\xa0\x22\xdf\xcd\xa1\xaf\xd7\x57\x76\xee\x3b\xee\xdc\xb4\x5e\xea\x4b\xff\x01\x71\x22\x9d\x78\xe4\xce\xe1\x85\xa9\x5e\x4e\xcc\x07\x32\xce\x10\xd9\xcc\x3e\x90\xf4\x41\xb1\x22\x27\xf8\x0f\xb2\x20\x10\xc5\xe7\x33\xb3\x5c\x63\xa7\x1e\xf8\x82\x6b\x6f\x73\x83\xbb\x08\xae\xb2\x3e\xf6\x35\xea\x78\xb9\x95\x37\x56\xd7\xea\x98\x0d\xb7\x9c\x9f\xa6\x33\x6a\xcb\x39\x2a\x2e\xa1\x6f\xd2\xcf\x92\xcc\x99\x76\x94\x7c\x19\x7d\x9e\x3e\xa9\x73\xa4\x71\x3e\xc8\xfb\x0a\xf9\xc0\x97\x2d\x6e\x03\x9f\xd3\x06\x10\x36\x30\x08\x4d\xa2\x46\x80\x92\xe0\x4c\xff\x2f\x3c\x98\x01\xa0\x27\x0d\x40\xd2\x9e\x9d\xf6\x19\xbd\x70\x8e\xd2\x3f\x75\xfe\x5b\x75\x5d\x4b\x67\xa9\xd3\xc5\xcd\xf4\x04\x63\xbb\x2d\x5b\x93\x67\xee\x1f\xf0\x18\xe3\xbc\x58\xc4\x6e\xb3\xb2\x33\x77\x15\x63\xab\x55\xfa\x9f\xcf\xdc\xeb\x5a\xb7\x66\x4f\x3f\x75\x27\x11\xf1\xb6\xb9\x2d\x44\x03\x06\x6b\x75\xec\x6e\x9c\xbb\xbf\xc1\x63\x8d\x33\xc3\xd0\xa0\xc3\xc0\x12\x8e\x5a\x87\x60\xff\x23\x0c\xe4\xe1\x39\x2d\x74\x01\x76\x4a\x23\x87\xc1\x47\x2c\xe6\xf0\xf2\x98\x63\x48\xac\xcc\xe5\x36\x49\x36\xaf\xd7\x21\xb9\x1d\x10\x74\xb8\x9d\x31\x1b\x9a\x00\xd1\x86\x53\xb6\x08\xe3\xe2\x16\x8b\xd3\x2e\x13\xa7\x67\x7c\xaa\x13\x4d\x86\x77\xcf\x4c\x4a\xeb\xc3\xcd\xd6\x51\x07\x73\xf2\xa3\x6c\xee\x5c\x4b\xd8\xf1\xd8\xc9\xf9\x99\x71\x07\x9b\xc4\x2c\xac\xe4\x32\x37\x06\xe8\x13\xe6\x3c\x34\x2c\xe6\xc6\x82\xdd\x02\xfe\xbd\xcf\x22\xf8\x80\x83\x04\x14\x73\x4b\x7a\xf4\x01\x5e\xbd\xd5\x61\x6a\x64\x36\xd0\x63\xd5\x52\x3d\x9a\xff\x07\xf8\xf8\x30\xe2\x6a\x25\x05\xa5\x11\x8c\x90\x45\xbf\xcf\xe5\x81\x07\x0e\x18\xdd\x95\x2f\x15\x86\x7f\xa5\x07\x1d\xa9\xfe\xca\x06\x0f\xc9\xbb\x81\x76\xb9\xa8\x21\x56\xea\x74\x65\xe7\x84\x82\x18\x87\x3c\x4e\x97\x2f\x44\xf2\xf3\x7c\x3e\x77\x2e\x36\xbb\x5c\x92\xdd\x6d\x1f\x1f\x0f\xba\x09\x0e\xa5\x05\x6c\x46\xdc\xd8\xf6\xf8\x3e\xa9\x26\x3a\xf7\x64\x35\xcd\xb0\x85\x60\x8d\xf3\xb8\x8a\x0d\x81\x27\xa9\x27\xb7\x4a\x33\xe3\x26\x41\x29\x38\xef\x3f\xef\x51\x6d\x84\x28\xcb\xf4\x24\x5e\x71\xba\x6f\x01\xab\xb9\xbc\x09\x38\x8d\x0c\xbf\xff\x9a\xfc\xac\x45\x89\x84\x9d\xb8\x2a\x70\xb5\x7b\xd6\xbe\xd3\x9b\xa5\xc5\xa7\x7f\xa2\xff\x59\x38\x92\x9c\xdb\x32\x4b\x10\xf8\x4f\xfa\x8a\xeb\xb4\x21\xb1\x76\x10\x64\xba\x31\x28\x35\xd6\x05\xce\xc1\x15\x1b\xb6\x78\x45\x85\x75\xf5\x74\x5b\x35\xd9\xd1\x18\x97\xbd\xd8\x9b\x59\xb4\x60\x60\xd1\xea\x06\x2a\xc9\x89\x9d\x6b\x71\xeb\x69\x05\x4c\x2c\xf6\x0e\x73\xd1\x5f\x5a\x0d\x2c\x00\xd6\x64\xf3\x09\x4e\xdf\xd4\x7a\x6e\x81\xce\xa6\x19\x7d\x0b\x1b\x5a\xe6\x74\x2b\x0e\x57\x31\x9b\xd3\xed\x54\x54\x11\x2f\xd7\x6d\xbd\xe0\x70\x80\x03\xe3\x26\xee\x90\xa8\xa4\xd5\x98\xf0\x39\x47\xd2\xd7\xf0\xfe\x3e\xbc\x26\x72\x2d\xd6\x6b\x4c\x84\xce\x9d\x9d\xc5\x42\xed\xee\xe6\xb7\x77\xd6\xf6\x24\xd9\x19\xfd\xd4\xf8\x1a\xf2\x87\xa9\x35\x30\x5e\xa1\xd7\x51\x12\xc1\xef\x97\x8a\x89\xe0\x65\x6e\x88\xd7\xad\x2f\xd4\x52\x7f\xa9\xaf\x75\x73\x72\x2d\x34\x05\x1d\x4d\x7e\xae\x6b\x57\xd6\x9f\xb3\x6e\x77\xf3\xd7\x3b\xeb\x6a\xf5\xe5\x5a\x3e\x07\x10\x29\xba\x0f\xb4\x9c\xaf\xdf\x1b\xe2\x9f\xd7\xf8\x3c\x83\x47\x5b\xe6\x5e\x73\x9c\x4b\x0d\x9c\x2f\xd6\xeb\x64\x40\x63\x14\x63\x6d\x77\xf3\x5f\x3b\xd9\xec\x96\x33\xf4\x0a\xfd\x3a\xd9\x2b\x14\xf0\xce\x36\xe8\xc4\x5a\x85\x0a\x39\x72\x4e\x51\x4b\x77\x51\x63\x1e\xeb\x3c\xe9\x6e\x87\x8c\x87\xa0\xb4\xd9\x3d\x0e\x59\x08\xa5\xe6\xb5\xce\x63\x34\x61\xbf\xe7\x34\x79\x24\xd9\x7b\xb4\xa8\x88\xd1\x24\xe2\x89\x84\x3d\xd6\x16\xc4\xd2\xfb\x95\xb2\x67\x70\x7a\x7c\x9d\xa4\x47\x38\xcc\xe8\x91\xc7\x40\xcf\xcb\x31\x93\x0c\x7a\xe8\x3e\x20\x5b\x4b\xf7\x01\x55\x2c\x0c\xd4\xd7\x12\x70\x69\x29\xab\x7f\x2d\x46\xc5\x85\xba\x0f\x98\x5c\xcb\xf0\x01\x6f\x4e\xfa\x80\x68\x0a\xbe\x21\xf9\x99\xb2\x32\x56\xfb\x5a\x42\x4a\x8a\xc4\x8c\xcf\xe8\x33\x9e\xf9\x3a\xaf\x19\x38\x45\x93\x9f\xa9\xa8\x60\xeb\xb4\xcf\x6d\xdf\x8e\x14\x66\x7c\x86\xcf\xd4\xe1\xeb\xfc\x60\xe0\xf4\x64\xf2\x33\x95\x95\x6c\x9d\x0e\xb6\x0e\xe5\xa4\x28\xa3\x07\xab\x3e\x4b\x9a\xe5\x32\x0c\x88\x15\x91\x40\x20\x2b\xc8\xea\x88\x6d\x6e\xd9\x96\x25\x93\xec\x90\xdd\x8e\xfc\x7e\x33\x3c\x84\x5d\x94\x9b\x1d\xe3\xe2\xe6\xcc\x08\xb6\x75\x38\xe3\x4a\x0e\x50\xc0\x7a\x0b\x84\x48\xe6\x6c\x68\x1c\xbe\x89\x9c\xa0\x6f\x3e\xf6\xd4\xf2\x53\x1b\x93\xd3\xa0\xaf\xbd\xf5\xf1\x07\xba\xe2\x60\xe2\x4a\x69\xf1\x2b\x74\x4f\xf0\xe7\x97\x6e\x78\x6b\x1a\x9b\x02\x3d\x67\xf2\xbc\x9b\x9e\xc2\x0c\x2f\x0f\xd8\x6d\x3b\xeb\x8b\x2f\x0c\x6d\x99\xb5\x2c\xaf\x4b\xce\x5a\x16\x56\xe0\x9b\xf1\x39\xbc\x6f\xa1\x93\x8d\x5a\x46\x4e\x07\x36\xb5\xed\x5b\x38\x2a\xd9\xb7\x10\xde\x9f\x97\xde\xe7\x10\xb9\x5d\xc9\xa6\x85\xd5\x69\xcf\xff\x30\xf9\x7c\xa0\xfd\x06\x78\x7f\x70\x97\x80\x5d\x92\x80\xdd\xbb\x9b\x7f\xd8\xe9\x76\x60\x43\xc0\x7a\xea\x72\xa2\xaf\x71\x73\xaa\x37\xe2\x14\x5c\x93\xa4\xbd\xdf\xcf\x68\xef\x05\x5d\xa6\x29\x19\xfb\xc5\x7b\x08\x70\x59\xae\x32\xd6\x79\x35\xc9\x83\xac\x96\x9a\x08\xb9\xbb\x9b\x9b\x77\xe6\x66\x2b\x28\x53\x26\x79\x9d\x3d\x97\xe5\x26\x63\xad\x40\xf2\x73\x39\x39\x8c\x77\x43\xac\xad\x62\x28\x28\xa3\x56\xb5\xd4\x46\xcf\x02\xd6\x6f\x38\xc4\x7a\xd0\x05\x9d\x4e\x14\x70\xb9\x14\xa4\xe4\x64\x07\x5c\xe3\xc0\xff\x16\xcd\x66\x2f\x6c\xb2\x28\xda\x5b\xe6\xd7\x9d\xe1\x40\x25\x6d\x7a\x1d\xf3\xc9\xaa\x44\x17\x66\xed\x9d\x73\xb1\x11\x87\x49\xdf\x6c\xa1\xcf\xfe\x83\xee\xa4\xcb\xf0\xb5\xb8\xe1\x73\xdc\xfb\xb1\x44\xcd\xd6\xf7\x3d\xa7\x3f\xf0\x7e\xfc\xc4\xa6\xf7\x42\xa4\x20\xf4\x8e\x70\xe0\x33\xba\xfd\x29\xbc\x0c\x0f\xc5\x17\xe0\xf9\x4f\xd2\xbf\x27\xaa\xde\xdd\xf7\xcc\xc7\xe4\xd3\xbf\x6f\xde\xb4\x0f\xb5\xea\x27\xe0\x04\xbf\x7b\x44\xac\xa3\x17\xd8\xd1\xa3\x69\x32\x92\x83\x01\x4d\x83\x58\xd3\xa3\x35\xc4\xdb\x7b\xba\x79\x20\xfe\xf4\x60\xbb\xe8\xf1\x10\x55\x75\x35\xc4\x55\x07\xb1\xb6\x74\x77\x6e\x09\x35\xc7\x8d\x29\x47\x7c\x30\x54\x26\x22\xcc\xab\x4c\x56\x7a\x57\xb9\x39\x16\x2c\xce\x16\xef\xa0\x9f\x51\x9a\xa0\xff\xc4\xf9\x98\x60\x15\xfb\x13\x1f\x7f\x9d\x4d\x3d\x8e\x45\x57\x7c\x1a\xc6\x3f\x3a\xe6\x08\xb9\xf4\x2f\xfa\x21\x6e\x8f\x65\x2c\xe1\x72\xfa\x65\x62\x11\xf6\xde\xb6\x54\xf8\x8a\x9e\x58\xb1\xa8\x65\x66\x35\xdb\x5f\x71\x8d\xb1\xbf\x07\x74\x9e\x10\x49\x24\x22\x15\x8b\x24\x8c\xc2\x79\xe9\x9b\x9b\xbe\xb7\xe2\xda\xcc\xbd\x15\x09\xeb\xbe\x2c\x92\x1c\xb6\xb7\x39\x21\xb9\x15\x4f\xf0\x19\x8c\x9c\x67\xbf\x30\xd6\xba\x24\x59\x5f\xcf\xa2\x53\x01\xe7\xb1\x92\xc5\xbc\x1c\xbf\x2b\xf3\x73\xbc\x2f\x38\xe7\x5b\x6a\xe8\x8c\x7f\x24\xf9\xb6\xa8\x88\xf1\x6d\x44\x8e\x84\x91\x3f\x03\x46\x3e\xff\x9a\xcb\xdf\x07\x86\x3c\x9d\x6b\xc8\x1f\x58\x20\xec\xf7\xf8\x7d\x16\x2d\x5d\x9e\xf4\x1e\xa0\xa3\x92\x3d\x40\x85\x15\xe8\x88\x21\x7f\x41\xd6\x03\x14\x07\x03\xc9\x06\xa0\xfa\xfb\xf5\xe7\x7f\x98\x7c\x3e\xe0\xd2\x3f\x09\x53\x28\xc4\x70\x09\xfa\x82\x7e\x8b\x96\x01\x93\xbe\xc6\xcd\xc9\x35\x00\x8f\x5f\x93\x9f\x61\x32\x01\x9f\x34\x85\x82\x66\x57\x5b\x3c\x94\x40\x6a\x1d\x82\xb7\x64\xae\xe3\x5b\xec\xcb\x3b\xe3\x3a\x6f\xa6\x70\x79\x10\x5f\x98\xb9\x4e\xe0\xaa\x40\xb8\xd5\x3a\xfc\x3c\x98\xe3\xf3\x0f\x03\x9f\x19\xc9\xcf\x04\x83\x6c\x1d\xbf\xe4\xf7\x2a\xce\x8c\xcf\xf0\xf3\x58\xbe\x2f\x7f\x1a\xf8\x7c\x97\xfc\x0c\x37\x92\x38\x20\x05\x7c\xae\xcc\x7e\xda\x2c\xdf\x92\xe5\xf4\xab\xa8\x63\x2c\x20\x41\x1c\x63\x92\x11\xb1\x98\x65\x93\x2a\xb0\x8b\x47\x1e\x40\xb4\x74\xa3\xc8\xbc\x76\xf4\x26\x0f\xbc\xc5\x09\x89\x86\xbb\x4e\xbe\xc8\x6f\x21\x20\xd2\x5c\x23\x5d\x97\xf4\xcb\x78\xee\x3e\x7f\xb6\x49\x95\x31\x06\x8e\xb4\x98\xc1\xfe\x49\x0d\x71\x41\xc3\x72\x86\x17\xd6\xe6\xba\x51\x7f\x3c\xae\x7d\x54\xb8\x95\xae\x58\xf4\x3b\xbf\x68\x48\x6c\xd6\xfd\x07\x65\x10\xa7\xcd\x67\x86\x3d\xbd\xb3\x85\xdf\x25\x9d\xdf\x29\xe3\x77\x7f\x26\xdf\xf2\x3e\xff\x9c\x3e\xa7\x75\xfa\x08\x4a\x1b\x39\x39\x06\x9f\x33\xa5\x7f\x8e\xdd\x0f\xc2\xfe\x4d\xe0\x3d\xd1\xc6\xc6\x3a\x59\xfd\xfe\x90\x2b\x28\x9b\xcd\xb0\x0f\x10\x8f\xe6\x64\x9b\xcd\x41\x41\x0d\xa1\x10\x2f\x80\x08\x0a\x1a\x44\xaa\x9a\x77\x42\x5c\x0b\x66\x94\x42\xbc\x5c\xde\xf6\xfc\x36\xbd\x0d\x63\xb4\x55\x61\x44\x54\x2f\x2d\xe5\xd1\x75\x77\x1c\x49\x2b\x93\x98\xf6\xc0\xc3\x1d\x67\x66\xd7\x57\xae\x58\xde\x52\x2e\x71\xfc\xa9\xa7\x1e\xb7\xc8\x6f\x59\x17\x8c\x4c\xd5\x4d\xd0\x0b\x39\xed\x43\xa0\x03\x3b\xa8\x1e\x8f\x23\xe0\x23\x8a\x92\xe5\xf3\x49\x18\x60\x56\x14\x5f\x48\x0e\x04\x03\xa0\xf0\x82\xc1\x90\xcf\x1b\x12\x1a\xe2\x21\xcd\x0a\x6a\xd0\x9a\x59\x16\xf0\xdf\xa0\x4d\x96\x54\xb4\x01\x35\x55\x60\x31\x6c\xe9\xfd\x1c\xd4\xc5\xd7\xa6\x0a\x2d\xf6\x3d\xb5\x67\x83\x45\xde\x63\x5d\x30\x55\xaf\xb8\xd0\xef\x1c\x2f\xe4\x77\x8e\x59\x68\x68\xac\x3d\x22\xb2\xea\x92\x44\xc5\x64\xb2\x4a\xa2\x88\x05\xbf\xd5\x2a\x64\x87\x64\x19\x9c\x4a\x41\xd4\xd8\x4c\x60\x0f\xfc\xdf\x72\xa7\xdc\x3a\x45\xa1\xae\xae\xf5\x2d\x5e\xda\x95\x23\x6f\xec\x6c\x9c\xa4\xb0\x2e\x0f\xc2\x13\x67\xb8\x7c\x9c\x36\x7d\xcb\x1d\x57\x0f\xab\xaf\x3c\xaf\xbe\xba\x67\xe6\x2d\x64\xe2\xe5\x27\x56\x2d\xb9\xc7\xf9\xbe\xb5\x5d\x87\xf2\x99\xe3\x8d\xfb\x48\xfd\xee\x36\x88\xc6\xc5\xb2\x19\xec\xa2\x49\x07\x5a\x31\x01\xf8\x26\x36\xcd\x56\x96\x05\x91\x20\x16\xe4\x79\x40\xa2\x08\x80\xae\x09\x5e\xcd\xd5\x08\x98\xc0\xff\xc9\x8c\x84\x8c\x1b\xc9\x56\x77\x23\x7a\x05\x15\x49\x5d\x45\x66\xa2\x51\x22\xd4\xb6\xbe\x94\x0c\x2c\xd8\x74\xd7\x04\x40\xe1\xdc\xaa\x41\xad\x2e\x27\xe7\x3d\x79\xfd\xaa\x35\x80\x41\xe7\x6e\x35\x57\x72\xda\xeb\x33\xe0\xc1\x5a\x0e\x8a\x15\x8a\x36\x13\x32\x49\xb2\x6c\xb5\x20\x22\x08\x76\xcd\xa2\xb9\x5d\x66\xa7\x53\xb1\x69\x8c\xfa\x56\x0d\x5c\x19\x92\x4c\x42\xad\x73\xd5\xe9\x19\x84\x69\xe9\xa7\xd1\x96\x54\xcd\x30\xa7\x38\xbb\x83\x36\xbe\xb9\x1e\xd7\xd3\x85\x29\x2a\xdf\x02\xc6\xef\x6b\x7c\x0b\x7d\xdd\xb8\xfe\x5d\x47\xdf\x27\x31\xa1\x17\x27\xf3\x73\x6f\x24\x56\x70\xba\xcf\xd2\x7b\xe5\xb0\xf9\x46\x00\xdf\xf0\x58\x3b\x9b\xa8\xc3\xc7\xc1\xd3\xac\x16\x1d\x42\xd1\xa6\x09\x66\xf0\xe0\x1a\xd9\x3d\xbd\x26\xc1\x2f\x34\x6f\x12\xca\x24\xff\xd6\x65\xd8\x6f\xe3\xaf\x14\xa4\xa1\x24\xa4\x16\xf6\xcd\xf9\x58\xa4\xef\x18\xa4\x7c\x0b\x9b\xe9\x5f\xf8\x5c\xfa\x36\xbf\xf7\x3d\x87\x9e\x16\xee\xc4\x9b\x18\x29\xe9\xc8\x37\x68\x2d\xa3\x2d\x3e\x88\x8c\xbe\x89\x52\x09\xd0\xd1\x0c\x14\xad\x8a\x05\x2d\x48\xb4\xdb\x15\x05\x79\xdc\xc4\xc1\xaa\xe4\x4c\x12\x31\xd9\x5a\x46\x56\xb7\x99\xd1\xe1\x36\x46\x2f\x84\x0b\x0a\x8b\x3c\xac\x34\xae\x40\x1e\x46\x7f\xc4\x2f\xe2\x92\x44\xed\xaf\xf4\x7b\xdc\x0e\x6b\x78\x06\xbd\xf3\xe6\x15\x78\xeb\xcb\x9f\x0b\x9d\x4e\x2e\xfa\xe1\xa5\x57\xf0\xb2\x89\x28\xe9\x33\x88\xa3\x79\x4c\x79\x1e\x87\x65\x64\xf3\x4f\xca\x6b\xfc\x2e\x31\x02\x12\x55\xee\x56\x14\x31\x2f\x88\x2c\x76\x94\x67\x27\x45\x85\x6e\xb7\x64\xb5\xfa\x24\x12\x66\x70\xc1\xbf\xbe\xd0\xb8\xb8\xcf\xe5\x50\x27\xc4\x1d\xee\xb6\x25\x41\x6d\xae\x99\xf8\x49\xb0\x01\xad\x23\x5a\x15\x84\x48\xde\x11\x2e\xd0\x1b\xa6\x00\xec\xe1\xaa\x1e\xb8\x3b\x06\xf0\x47\xea\xe0\xbf\xf0\x12\x0e\xd0\xa2\xbb\x0e\xd6\x0d\xf9\xfe\x59\x03\x91\x5b\xee\x1d\xd4\x82\xc9\xe9\x9e\xb4\x19\x63\xfc\x77\xda\x40\x0b\x1b\x47\x0c\x39\x07\xf0\xaa\x99\x3e\x6c\xc5\x44\x86\x07\xe0\x25\x9f\x90\xde\x44\xb9\xa8\x0c\x5d\x18\xeb\x60\x43\xd9\x28\xaf\xc8\x23\x99\x3c\x79\x26\x52\xde\x2e\x14\xf2\xdb\xed\x7e\x59\x76\xfa\x73\xb0\xbf\xa0\x21\xee\x77\x98\x59\x16\x97\xcf\x59\xd2\x10\x77\xfa\xd2\x32\xd8\xd2\xba\x12\xb4\x45\x05\xb3\xd3\x12\x00\xd8\xcb\x91\x88\x30\x2c\xd2\x67\x7b\xa5\x8d\xf5\x12\x87\xee\x9f\x70\x29\x0e\xd1\xb2\xbf\x7d\x54\x83\xbb\xed\x58\xf0\xe1\xa7\x9f\x1c\xb8\xfa\x91\x0e\x02\x18\x64\xfa\xe3\xac\x19\xd3\xaf\xfc\x7c\xda\x5c\xbc\xf3\xdf\x8b\xaf\xfb\xf9\x3b\x5a\x38\xfa\xd2\x49\x63\x71\x0e\x76\xb3\x01\x5e\xe3\xc7\x6d\xc7\x2b\x4e\x5f\xb8\x75\xdf\x33\xcf\xd2\xdb\x5e\x02\x9e\x1e\x02\xfb\xd3\x45\xba\x0b\xa2\xdf\xc6\x58\x59\x9e\x95\x04\xac\x85\x25\x2e\x13\x29\x11\xdb\x95\x39\x9d\xde\xa2\x22\xe4\x35\x29\xac\x61\x32\xf2\x7a\xb5\x71\x71\xaf\x88\x0a\x26\xc4\x51\x1b\xc7\xfa\x0c\x7b\xa3\x37\xb6\x61\x87\xf1\x67\xac\x61\x11\xfc\xec\x5e\x88\xef\x98\x34\xe6\xcb\x1f\x6d\xd2\x1d\x4f\x9d\xa1\x76\x65\xd6\xcc\x18\x51\x2e\x1a\x07\xfb\xe6\x79\xeb\xa3\xcb\xc7\x65\x16\xac\xb8\x62\xd3\x86\xdf\x38\x37\xb9\x61\x80\xcb\xf9\xb0\x47\x03\xc0\xdf\x2e\x65\x79\x06\xb9\x84\xf8\xcd\x85\x25\x4e\xd9\xcc\x70\x71\x38\x3c\x80\x8b\xc7\x63\x6b\x62\xd3\x5f\xc2\x8d\xfa\x75\xde\x99\xe3\x40\xe3\xde\xae\xf8\xbf\xd6\x9f\xf8\x92\x5b\x25\x5e\x7d\xe2\xfb\x9b\x5a\xd7\x9c\x2c\x5b\x35\x6c\x02\xdb\x20\xcf\x83\x4f\xb4\x2d\x33\xb1\x5d\x16\xbf\x60\xa8\xbe\x35\xba\x7d\x1c\xc2\xcf\x0b\xef\x42\x61\xb6\x07\x61\x6f\xb6\x57\xcd\xcb\xb5\x6b\x9a\x98\x9d\x2b\x46\x0a\xec\x76\x57\x5e\x98\x0d\x21\x97\xa4\xb0\xcb\x65\x65\x97\x74\xe1\xec\xf1\xf1\x70\xe6\xc0\xf9\x33\x66\xad\xea\xe3\xa2\xcf\x56\x44\x94\xa3\x17\x9e\x90\xa5\x67\xae\x1a\x7a\x64\xfa\xc9\xbb\xf1\xfd\x6d\x8a\x84\x36\xdf\x78\x7f\xea\xfc\xfe\x7c\xf0\xd7\x8a\x80\xde\x61\x46\x6f\xd5\xe7\xc3\xb9\x9a\x23\x9c\xef\x90\x72\xf3\x01\x6e\x4d\x03\x6d\xe6\xb6\x36\xc5\x21\xd4\xcc\x6d\xe5\x5c\xb9\x5a\xdf\x16\xeb\x67\x5b\x67\x25\x37\x07\x95\x74\x5e\xdf\xa6\xb6\x67\xc1\x5d\xb3\x7f\xc7\xb5\x67\x20\xf1\xaa\xcb\x67\xe8\x67\xb1\x26\xe0\xef\xcd\x3c\x2f\xb8\x6f\xac\x10\xd9\xb4\x5c\xc9\xe4\xcf\xb5\x99\xc4\x70\xbe\xdf\xef\x09\x06\x3d\xb2\x9c\xeb\x71\xe7\x6a\xe3\xe3\xb9\xc4\x4c\x26\xb4\x1c\x0f\xe8\x6a\xa7\x8d\x9c\x32\x21\xf5\xb5\x68\x9a\x6a\x67\x9b\x0b\x11\xc9\x33\x76\xc2\x73\xa0\x67\xca\x8e\x1f\x69\x7b\x27\x82\x9f\xbf\x61\x41\x92\x61\xbf\x3e\x29\xbc\xd2\xfa\x72\x44\xe7\x07\x36\x0f\xa3\x94\xcf\x72\x06\xba\x3a\xf2\x91\x5d\x56\xb3\xf2\xed\x2a\x10\x15\x7c\xa5\xfc\x7c\x47\x43\x3c\x5f\xcb\x26\x59\xbe\xac\xc6\xb8\xc5\xe7\x4b\xbb\x1a\x69\x93\xe9\x6b\x80\x9b\x52\x2a\xd5\x6d\x6e\x4a\xc4\x1b\xc7\x8d\xd3\x55\xc9\x89\x5f\xcf\x70\x5d\xc2\x00\xd6\x59\xf5\xdb\x3f\xf1\xce\x56\xf7\x26\xc9\xfe\xe0\xef\xf1\x7b\x25\x36\x01\xc8\x6b\xf3\x38\x1c\x4e\xc9\xe4\xb4\x99\x48\x30\x00\xfa\xd0\xe5\x01\xd2\x7a\x3c\x4e\x9f\x8b\x38\x5d\xe9\x04\x6e\x75\x25\x91\xc9\xb4\xe9\x24\xee\xde\x72\x3b\x21\x75\x1f\x37\x8e\x93\xf6\xc4\xaf\x2d\xb7\x00\xe9\x24\xfd\xf6\xcf\x3b\x93\xf7\x01\xdc\xe7\x07\x7d\xf0\x03\x3f\x8b\x05\xd8\x24\xc1\x8d\x7d\x3e\xbf\xc5\xee\x77\xdb\x49\x56\xd0\x6a\xf5\x07\xf8\xd1\x2b\xf6\x93\x80\xe6\xf7\xf2\xd3\x6e\xdf\xff\x00\x9b\x7e\x4d\x92\x4e\x54\x1d\x42\x3d\x21\x3f\x49\xcc\xd3\xff\x6a\x49\x54\x4f\xdc\x98\xa4\xe1\x17\xc7\x9d\xc9\x19\xae\x2c\xb6\xde\xc3\xce\x04\x51\xbb\xd4\x99\xe0\x64\x76\x2e\x29\x14\x72\x1e\xf0\xc3\xef\xd7\xf2\x7e\x02\x75\xb1\x1c\x0c\x1c\xe0\xb0\xbb\x55\x56\xaf\xae\x58\x9c\xc8\xe1\x04\x43\xee\x24\x16\x71\x42\xdc\xe2\x6e\xc9\x92\xcc\x4c\x42\xe0\x39\x2c\x99\xbc\xca\x73\x32\x53\x34\xd4\x33\x33\x13\x91\x74\xfa\x09\x1f\x7e\xfb\x2d\x5f\xbf\x1e\xd6\x2f\xe2\x75\x1e\xb0\xbe\xe8\x32\xdb\x90\xe0\xb2\x89\x3e\xaf\xc5\xa2\x21\xe2\xe1\xd3\x78\x34\x4d\x01\x9f\xd1\x77\xf6\xf5\x79\xa2\x58\x6b\xfe\xe3\x43\x49\xd3\x78\x8e\x0d\x27\xa5\x7d\xd2\xb9\x8c\xd3\x83\xcd\xcc\xff\x50\xba\xcb\x25\xe3\x26\xfe\xf3\xb9\xcd\x3f\x91\x57\x38\x7d\x72\x8c\xfb\xcc\x0b\x25\x0f\xbf\x27\xe8\x1d\x8b\x60\x47\xae\x4b\x75\x04\x5d\x62\x7e\x9e\xaa\x3a\x2c\x16\xd9\xe1\x0d\x8e\x8f\x7b\x43\xf0\xbf\xec\x4e\xbf\xd5\x3c\x63\x0a\xf1\x19\xaf\x35\x5b\xc2\x88\x9a\xea\x33\xdd\x6e\xde\xfa\x48\xd1\x8c\x48\x9f\xdc\xee\xd5\x6d\x6f\x38\x4f\x0e\x3c\xb0\xc5\x6a\xfa\xde\x76\x7e\x03\xbf\xe3\xbc\x90\xcf\x86\xce\x43\xf5\xb1\x30\x02\x38\xcd\x0e\x57\x10\xb4\x8f\x03\x35\xc4\x1d\x1a\xbf\x28\xf6\x79\x83\x8d\x00\x2c\xfb\x3f\xbd\x01\x5e\x3a\x7c\xad\xaf\x37\xd3\xa1\x73\x0a\x35\x6d\xc4\xf6\xee\xf5\x3a\x74\xb5\x6d\xee\x3a\x4f\x6d\x7a\x6b\xaf\xd5\xf4\x9e\x6d\xf0\x60\xb2\x8d\xf3\x21\x9d\xca\xce\xd4\xc0\x5f\xeb\xac\xfb\x6f\x00\xef\x48\x3e\xdb\x48\x3f\xab\x14\x20\xbe\x5d\xc1\xcf\xcf\xeb\x93\x39\x04\x72\x77\x3e\xe3\x73\x24\xaf\x19\xee\x43\x17\xa1\xfd\xcd\x6f\x00\x9f\x84\x63\x6e\xa7\x64\xb7\x9b\xbf\x64\x2d\xf3\x62\xb8\x11\x8f\xc7\x22\x76\xb0\x3e\x42\xbc\x91\x50\x94\xd7\x4c\x71\xe5\x9e\x83\x23\xac\x39\x4b\x75\x94\x59\xd2\xfd\x93\x8a\x3b\x46\x4b\x2e\x39\xa7\xef\xa4\x7e\xe7\xd0\x45\x95\x35\x15\x15\x35\x95\x9d\x46\x8c\xb4\x8c\x1d\x6b\x19\x75\xa1\x7e\x8e\x56\x2e\x0d\xc6\x5b\xe4\x67\x91\x05\xb4\x4c\x04\x95\xc6\x7c\x5e\x55\xd5\x34\x82\xb7\x92\x5f\x49\x33\x21\x24\xa6\xda\xfa\x91\x50\x78\x37\xee\x01\xba\xf0\xcd\xf2\x31\xd3\xf5\x32\x7b\xb7\x91\xe6\xce\x68\x55\x9b\xf6\xbd\x92\xf6\x7d\x79\x45\x7e\x41\x45\x45\x41\x7e\xc5\x77\xc9\x6f\x66\xc0\x37\x1d\x3a\xc0\x37\xf2\xb4\xfc\x0e\x1d\xf4\x17\xf5\x7f\xb7\xf2\xef\x3b\x76\xe4\x78\x4f\x95\x06\xa3\x3b\xe4\xd3\x00\x93\xe5\x29\x96\xd0\x0d\x4b\xbf\x09\x4b\x2a\x7e\xf8\x8a\xd4\x96\xc0\xd7\x1d\xf7\xc1\x9f\x6d\xd7\xb0\xbf\xef\x93\x4f\x0f\x4f\xfd\xd1\x6b\x02\xc6\x02\x4e\xc8\xc0\xa9\x20\xe6\x56\x5b\xa3\xa3\x79\xd3\xd0\xc9\xc4\x25\x1d\xfe\xf1\x00\x6d\xc7\xca\x48\x7e\x85\xd0\x31\x3f\xbf\x63\x65\xb8\xa0\x42\x9e\xaa\x83\xcf\xc0\x65\xaf\x55\xe8\x34\x1c\x0f\xeb\x1d\x30\xd6\x0b\x31\x1a\x06\x49\xe0\xbf\x2f\xfa\xb2\xe3\x65\xe6\x3f\xb4\xac\xe5\x4d\x87\x01\x18\x13\x97\x70\x72\x30\xd2\xe4\x87\x2b\x19\xed\x0e\x4c\x6b\x59\x5d\x87\xa6\xa2\x02\x5f\x49\x57\x03\xbd\x06\x03\x9f\xdc\xdd\xbc\x05\x29\xc8\xf1\x0c\xd1\x67\xdf\xeb\x3d\xa6\x3a\x75\x54\x40\x45\x78\x41\x37\xf4\x99\x39\xe9\xfe\x27\x9a\x46\x5f\x36\x65\xfd\xad\x7a\x4f\xa8\x4b\xa5\x11\xe8\x5e\xf9\x51\x80\xde\xf2\x14\xc1\x1c\xb4\x43\x8c\xc6\x25\xb5\xf7\xc2\x1f\x19\x3d\xfa\xe8\xa3\xec\x7d\xf4\x43\xa9\x11\x97\xcb\xd7\x83\xbd\xcc\x8f\xd9\x9c\xd9\xc8\x92\x0d\x5f\x9a\x1f\xfb\x8d\x7d\x19\xc3\x1a\xc5\xe8\x92\x44\x58\x45\x80\x5f\x29\xae\x4e\x36\x86\xd2\xa3\xd6\x5a\x03\x2d\xf0\x57\xef\xcf\x2e\xaa\xcb\x9a\xda\xd4\xab\x72\x48\x75\x69\x6d\x3e\xff\x61\x48\x8f\xaa\x0b\x3a\xb7\xef\x24\xd7\x15\x17\xc5\x7c\xfd\x8a\xaf\xed\xd5\x54\x3d\xa0\xae\x92\xff\x50\x36\xab\x57\x53\x4d\xff\x1e\xed\x38\x1c\xbb\x81\x27\x90\xbc\x08\x70\x74\x3f\x43\x34\x31\x8f\xe1\x68\x40\xc0\x1a\x60\x71\xff\xc6\xe7\x9d\x36\xfd\xd2\xb5\x5b\xa4\xc1\xa3\x2f\x9d\xfa\xe0\x6a\x23\xe7\x9b\x2e\xc2\xbd\x9b\x8f\x20\x09\x99\x9e\xc2\xac\xf5\x15\xeb\x61\x55\x52\x1b\x55\x70\xef\xdb\xb6\x6f\xbf\x6d\x07\x5d\xb4\x73\xe7\x4e\x24\x34\x97\x71\x1a\x1e\x63\xcf\x47\xde\x98\x0a\xa1\x54\x8c\x60\xe2\xb4\xa0\xca\x28\x6f\xd6\xd5\xa9\xa3\x1f\xb0\x60\x3e\x94\x94\xb6\x55\x77\x6f\x5e\x37\xf1\x9a\x66\x94\xdc\xa3\xa6\x55\x1b\xa6\x5c\x36\xda\x6a\x6c\x8f\xbe\x3e\xf0\x46\x3f\x03\x6e\x51\x23\x79\x44\x20\x3a\xdc\x87\x18\xdc\x4e\x78\x96\x17\xc8\xb6\x65\xed\xa4\xab\xa5\xc1\xb7\xaf\x9f\x3a\x91\xcd\x40\x33\x3e\xe3\x90\x45\x76\x6e\x22\x30\xdc\x8d\x67\x68\x28\x3b\x66\xb5\x5a\x2c\xc6\x93\x4c\xfa\xa3\xaa\xe0\x59\x5c\x2a\x93\x8f\x0b\xa7\x3d\x96\xf6\x7f\xe2\xfe\xd4\xc3\x6f\xdd\x00\x7f\xb1\x34\xf8\xc4\x09\xa9\xab\x60\x56\xca\x10\xcb\xae\x2f\x47\xb5\xa0\x61\x1c\x41\x42\x2a\x2b\xcb\x70\x99\xbb\xba\x5a\x6d\x8c\xe0\x08\xaa\xe4\x93\x34\x5e\x1e\xd3\x46\xe4\x4b\x80\x4d\x8a\x6b\x3d\xa9\xd2\x26\x59\x62\xbd\x52\x4a\x92\x3d\xd2\xaa\x7c\x4a\xb2\x46\x08\xde\x31\x72\x61\x7c\xd4\xc2\xf9\x63\xba\x76\x18\xd1\x34\x22\x67\x4e\x6d\x49\x69\x7d\xb7\xe2\xc2\x7a\xfa\x7e\x0e\xfc\xdc\xa1\xeb\xe8\x05\x0b\x47\xc5\x17\xce\xa9\x2f\x2c\xee\x56\x5f\x5a\xdc\x45\x6e\x8a\x2f\x5c\x30\x32\xbe\x30\x30\x62\xe8\x88\xca\x6e\xa5\x5d\xea\x4a\x4a\xea\xba\x94\x76\xab\x84\x1f\x03\xec\xf5\x85\xf1\xd2\x2e\xf5\xc5\xf0\x1a\xef\x0b\x24\x75\xc5\x3f\x19\x38\x78\x63\xe6\x60\x25\xec\x98\xbb\x51\xc5\x2a\x83\xfc\xe5\x31\x55\xff\x1d\xe6\xee\x0b\xe3\x23\xae\x5b\x38\xb2\xae\xd3\xf0\xa1\x23\x42\xb3\xbb\x94\x96\x75\xa9\x2f\x29\xae\x67\x00\xcc\x1f\x35\x72\x01\x03\xa0\xa2\x7b\x69\x97\x2e\xa5\xf0\x3f\xc8\xcb\x68\xe0\xbf\x47\xe5\xb5\xc8\x89\x02\x20\xce\xa2\xa8\x6a\xcc\x50\x26\x39\x50\x6f\xe6\xa6\xaf\xc3\x4f\xca\x74\xc3\xfc\xe8\x85\x17\x16\xf8\x27\x4e\x34\x87\x3b\x16\xcb\x6b\xab\x46\x4c\x32\x4f\xc2\x83\x6e\xb6\x76\xa8\xad\x42\x6d\xf5\xbb\x46\x64\xf9\x4b\x09\x23\x29\x26\x35\x4a\xe3\x25\x51\x72\xeb\xbc\x37\x46\xd7\xef\x7e\x0f\xcf\x93\xad\x80\xa0\x3b\x9a\x8c\x90\xa2\xfb\xcf\xed\x3b\xe9\x9c\xbe\x97\x94\x44\x3b\x16\x4f\x9a\x34\x72\xa4\x65\xf4\x68\xf3\xc8\x51\x9d\x3a\x55\x77\xec\x58\xdd\x09\x9e\xdf\x8f\x6e\x04\x3f\xed\x73\xe0\x7d\xfb\xd3\x04\x09\x58\x48\x6a\x05\x3f\xb8\x2b\xd1\xea\x5b\xe9\xdf\x0f\x47\xe8\x81\x29\x6f\x33\x58\xc6\x02\x2c\x1b\x32\xe5\xc4\xcd\xe5\x64\xc3\x6d\x3b\x77\xde\xb6\x53\x17\x13\x78\xdf\x14\x78\xdf\x76\x43\xd7\x88\x88\x38\x18\x3f\xa3\x4a\xce\xcc\x49\x01\xd9\xfe\xf8\x03\x93\x66\x36\xdd\xba\x7e\xca\x94\x51\x48\xe7\x5f\x90\xc1\x7e\xfc\x33\x1a\x0a\xea\xfc\xab\x7f\x92\xb5\xc2\x4b\x31\xaf\xd7\xf8\x78\xd8\xf8\xf7\xf1\x07\x26\xcf\xc0\xcf\x6c\x5e\x37\x79\x06\x7b\xd6\xe5\x23\x41\xb6\x2e\xd7\xed\xe2\x45\x00\xc3\xfd\xcd\x7f\xc2\xf3\xac\x3b\x63\x98\xcd\x86\x06\xb4\x00\x5e\xa9\xba\xb6\xa4\xc8\xab\xdc\x4f\xbf\x59\xb5\x19\xe7\xdd\x4a\xb7\x47\x1b\x7d\xff\x8c\x0e\x0a\x32\xdb\xca\xf6\x6f\x23\xc8\x94\x22\xbe\x8b\x36\x22\x1d\x2e\x8f\xd4\x15\x2c\x70\x8a\x7f\xdc\x95\x36\x6c\x0b\x36\x2a\x58\x49\xf1\x0f\xf9\x2f\x7c\xdd\x3d\x34\x62\xe8\xf0\xaa\x2e\xf1\x45\xd7\x8d\xb8\xf0\xba\xd9\xc0\x94\xf5\x5d\xca\x4a\x81\x81\xbb\x57\x30\x66\x65\x3c\xc4\x98\xb5\xae\x04\xf8\x07\xd6\x37\xf6\x1a\x64\xfa\x53\x8e\x03\xd8\x28\xb4\x41\xde\x05\xf4\xb6\x3c\x25\xe2\x94\x8d\x4b\x23\xb9\x34\x98\x93\x9c\xed\x23\xbc\xf7\x56\x79\x19\xbc\xd7\xf9\x34\x63\x3b\x22\x18\xa6\x84\x21\x9d\xda\x4a\x79\x19\xdf\x4b\xa6\x3f\x74\x7a\x03\xae\x6f\xa1\xed\x88\x9f\x1d\x25\x36\x4b\x8d\xa0\x3f\xaf\x87\xd7\xde\xa1\x1f\xea\xf8\x37\x97\x49\xf3\xd0\xc7\x80\x3f\xb3\x5b\x8e\x5d\x5e\x26\x3e\x9a\xaa\x2b\x3c\xa6\x52\xd3\x2c\x7c\x9a\xd8\x7c\xbc\x30\xce\x24\x64\xd4\xfc\xd9\x4c\x34\xea\x8b\x75\x91\x61\x2f\x32\x74\x75\x71\x81\x67\x6f\x03\x7c\x1b\x9b\x7f\xe1\xcf\xf6\xc7\xac\x1a\xf2\xe2\x98\x77\xbd\x57\xf0\xaa\x84\xaf\xc0\x0c\xaf\x72\x16\x03\xd8\xc8\xd4\x27\xb3\xaf\x49\xbb\x7b\x51\xb8\x12\xbe\x4d\x33\xbb\x12\x7d\x1f\x70\xec\x60\x3c\x1f\x34\x15\xea\x8a\x4a\x62\x9e\x68\x28\x54\x87\xc2\x38\x16\x5e\x1f\x16\xc2\x1d\xc0\x93\x29\xd1\xd8\x6a\xfc\xbc\xf2\xcd\xa4\xeb\x22\xfd\x0f\xae\x4b\xd1\x59\x5e\xa7\xef\xb7\xf5\x69\x3a\xe4\x47\x3a\x74\x88\xe4\x77\xc0\xfd\x93\x2f\xa5\xfc\x85\xf1\x00\xb3\xf1\x5a\x45\xba\x97\xf3\xab\xf1\x5a\x0a\x1f\x42\x8f\x01\x3e\x0e\xc0\x87\x70\x6e\xcc\x89\xc1\x3e\x63\x37\x0a\xe2\x58\x70\x7d\x50\x08\xda\x14\x83\x68\x5c\xd1\x48\x10\x6b\xd4\x9e\x85\x76\xf4\x18\x3e\xaf\x0b\x80\x53\x59\xc9\xc0\x32\x40\xdb\x30\x75\x6a\x2c\xb9\xa4\xe1\x55\xa0\xb4\x35\x99\xcd\xcb\x03\x1d\xe4\x64\x39\x6f\xc4\x8f\x72\x70\x2c\x67\x7d\x8e\x90\x63\x58\x3f\xbe\x2a\x37\xf0\xd5\x11\x58\x39\x72\xd6\xb5\xd7\x5f\x89\xcf\x9b\xb2\xa1\xf5\xe2\xf4\xa7\x19\x53\xa7\xce\xd8\xde\x66\x7d\x0c\x3c\xb2\x11\x78\xa4\x37\xec\xa1\xe9\x29\xce\x16\x99\x5c\x97\x62\x03\x7a\xcc\xd8\x7f\xe0\xab\xee\xf0\x99\x97\x9a\xfb\xf0\x7d\xb7\xef\x64\xce\x2a\xdf\x61\x67\xab\xcf\xa6\x83\xf8\x52\x72\x3b\x7e\x48\xda\x69\x7a\xdc\x20\x7c\x41\x8b\xa9\x46\x04\x9e\xbd\x08\x9e\x9d\xe4\x29\xd8\x83\x50\x8a\x99\xd2\x16\x6a\xcb\xbb\x67\xe3\xa2\x97\x2a\x0a\xf4\x75\x7e\x60\xbb\xcf\x30\x98\x95\xe2\x68\xfd\x17\x7c\x71\xf6\xa6\xad\x8c\x43\x92\xfe\xef\xe8\xe6\x20\xda\xd8\x7c\x3d\xf0\x82\x75\x27\x91\x59\x9b\x6c\xd0\x47\xb0\x24\x84\x7c\x1b\x71\x3f\xba\x7b\xc1\x14\xdd\x7e\x8c\x06\x5a\xb0\xf7\x29\x48\xde\x26\xb0\x5e\xa5\xc9\x0d\xaa\x9e\x86\xfb\x5d\x4e\x37\xce\x9a\x32\x65\x16\xa7\xb3\xb4\x09\x35\xca\x7d\xb9\x3f\x4d\xd4\xdd\xb8\x27\xe8\x8e\x56\xa4\x4e\x02\x23\x9d\xd0\xa5\xae\x23\xd3\x99\xc6\xe7\x40\x67\xfd\xce\xe9\xe3\x02\xfa\xfc\xd6\xfc\x9b\x41\x9f\x50\xcc\xe6\xd5\xb4\x50\x48\x27\x90\x21\xd6\xac\x11\x73\x34\x93\x3a\xfe\xb3\x7c\xff\x4b\x52\x34\xd6\x25\x17\x5f\x9f\x92\x1b\x83\x59\xfa\x1b\xc0\xf4\x4b\xca\x09\xe0\x22\x4c\x47\x8d\xc4\xce\xee\xfd\x63\xb0\xa6\xda\x51\x1d\xaf\x12\x55\x27\x50\x1b\x8c\xd8\xff\xc2\x7e\x9d\x0d\x3b\xe8\x34\x3b\x08\x34\xab\xe5\xb4\x35\x3d\x05\x2e\x04\xe7\x39\x08\x96\x6a\xaf\xa4\x1b\xbf\xfc\x12\x74\xeb\x52\x71\x8e\xf0\x82\x34\x08\x7e\xef\x7c\x1a\x0c\x0b\x18\x2a\x64\xb4\x55\xd2\x63\xee\xa5\x42\xb7\xc4\xcb\xd2\xa0\xf7\x39\xfd\xa5\x17\xc0\xa6\x94\xc3\x5b\x1c\xcf\xa0\x8e\x04\xab\xa0\x40\x01\x12\x0e\x4a\x72\xaf\xe4\x72\xb6\x59\x18\x1f\xa7\xe3\x85\x55\xca\xc7\x4c\xbe\x77\x22\x49\x64\xa6\x98\xdf\x62\xe9\x55\x9d\xf8\xf8\x1a\x3a\x5e\x9d\x7d\xe2\x26\xd4\x86\xee\x6d\xf6\x41\x40\xaf\xc0\x03\xbf\x13\xcd\xf0\x2c\x05\x75\x8a\x99\x89\xa2\x20\x51\x34\xa9\x18\xbc\xc1\x73\x76\xc6\xb1\x28\x4a\x7b\xf1\x39\x28\x8e\x44\x5c\x8f\xf4\x43\xc1\xf2\xb4\x72\x4c\x37\x3b\x50\x81\xff\x5f\xc1\xf9\x2c\x7d\x41\xf8\x0d\x67\xd1\xef\x13\x0e\x56\x75\xc3\xe8\x2b\xfb\x61\xad\x5d\x5c\x26\x19\x5d\xcf\x46\x56\x79\x12\x17\x64\x20\x2b\x93\xe3\x29\x20\xc7\xa6\xff\x5f\x8e\x77\x27\xe5\x18\xa3\xb5\xc0\x50\x61\xf1\x13\x64\x47\x55\x31\xb3\xc5\x6e\x95\xed\x44\x73\xd8\x2d\xbd\xcc\x38\x06\x90\xdb\x01\x72\x11\x29\xfc\x7b\x11\xd7\xa1\x8c\xa8\x9d\xb9\x75\x3d\x70\x57\xec\xd5\x47\x15\x79\xc3\x6b\x07\x3f\xba\xfb\xc1\x3b\x26\xf5\xc5\x73\x12\x73\x84\xdf\xf6\xbd\x3b\xea\xd8\xcc\x67\x68\xcd\x31\xa4\xf7\x5c\xba\x48\x10\x9a\xd7\x21\x15\x64\x44\x61\x32\x22\x45\xfc\xe0\x47\xd5\x82\xa0\x08\xc2\x4e\xd7\x4d\x8e\xed\xf8\xd0\xbf\xd6\x7b\xbd\xeb\x97\xe9\xf1\x42\x6f\xf0\x2a\x1b\x01\xae\x20\x1a\x10\xcb\xd5\x82\x76\x64\x97\x15\xab\x60\x03\x19\x74\xb3\xc6\x07\x36\x31\x94\x65\x15\x34\x50\xc9\x76\xcf\x5e\x00\x52\x86\xcf\xd4\xf1\x5e\x33\x75\xad\x06\xc4\xf0\xf6\x20\x55\xa9\xbb\xa7\x1e\xb8\x27\x0e\x2b\x76\x41\x6f\x12\xa2\x90\xb0\xbb\x87\x50\xbb\x00\xf7\xc3\x77\xf5\xec\x6d\xf7\x62\x4f\xc0\xdc\x7d\xf2\x74\x3c\x8b\xee\xa1\xb6\x9a\xf6\x39\x3d\xe8\x0f\x43\x0b\xbb\xc5\x1b\xc4\x4f\x12\x6f\xd7\xad\xbd\xfe\xf0\xcf\x97\x3c\xb8\x7c\x22\x15\x85\x9d\x79\xb3\x77\xd2\xbb\xf1\xba\xc7\xef\xbc\xb0\x40\x87\xb7\x09\x9c\xf9\x8f\x01\x5e\x0d\x75\x89\xd9\x2c\xb2\x49\x46\xaa\xe8\x70\xca\x66\xd5\x6c\x90\x52\x05\x28\x21\x0c\xe1\xdf\xe3\x16\x52\xa6\xc6\xb4\x00\x74\xd5\xe1\x7c\x31\x08\x6e\x25\x6b\x0f\x02\x36\x7e\x31\xde\xc4\x2a\xd0\x97\x9e\x9a\x27\x1c\xbb\x7e\x1d\x39\x72\xec\x38\x3d\x4a\x23\xc7\x8e\xe1\x3d\x5b\xf5\x3c\xd7\x9e\xb0\x77\xeb\x39\x8d\xba\xc6\xdc\x56\x9b\x2c\x49\x8a\x3b\x60\x93\xb2\x42\x8a\xdb\x6d\x0b\x06\x03\xfb\xf9\x62\x41\x58\x4c\x46\x36\xc6\x83\xa9\xb1\xe4\xd1\xf4\x83\x97\xaa\x5c\xec\x77\x87\x89\x9d\x28\xe1\xda\x1e\x42\x4f\x5c\xc1\x1a\x21\xe3\x41\x4b\x57\x8d\xec\xb2\x8d\xfe\x71\x49\x4d\xa7\xa2\xec\x6a\xfa\x73\x59\xe1\x80\x59\x93\x1b\x73\xa2\xbd\x06\x2c\x13\x3f\x39\x67\xe7\x0f\x09\x19\xef\xd7\xc2\xf5\xa3\xff\xdc\xf9\xf0\xfd\x63\xf2\x02\x37\xae\xed\x71\x8c\xc1\x54\x06\x74\x98\x0e\x30\x29\xa8\x3c\x66\x85\xe8\x1f\x11\x62\x52\x59\xc9\xf3\xbe\x14\x13\x61\x06\x4a\x26\xea\xec\x06\x8e\x69\x4c\xf2\x31\x3d\x96\x18\x2f\xf6\x5b\x0b\xd8\x1e\xe3\x32\x76\x2f\x3c\xef\x15\x78\x1e\xb3\xc7\xb5\x31\xcd\x8c\xb0\x24\x62\xa0\xac\x20\x60\x8b\xc5\xac\x63\x68\x81\x87\x4a\xfa\x63\xa3\x3d\x5b\xa7\x80\x1b\x4f\xc7\x9c\xa4\xb0\x48\xbe\xcf\x89\xf7\x80\x75\xb6\x13\x0b\xfd\x7d\xc9\x43\x54\x12\xac\xb8\xe4\xa4\x70\x2c\x61\x17\xde\x5d\xb3\xe0\xd8\x31\xfa\x03\xa7\xed\x16\xf8\xeb\x59\xbe\x6e\xf0\x69\x30\xc6\xa2\x44\xf6\xe0\x7a\x9d\xc9\x7a\xea\x42\xac\xcf\xa1\xdc\x82\xed\xf4\x98\xf8\xc9\xa9\x12\xf8\x4c\x14\x00\x7e\x5b\x3c\x89\x6c\x28\x16\xb3\xc8\x0a\xb6\x28\x56\xd1\xae\x31\x75\xd0\x2b\x66\x8e\x0b\x16\x2b\xc6\x8a\xcd\x66\xdd\x87\x7b\x01\xd0\x36\xdc\x05\x04\x4b\xa7\x84\xd1\x39\xac\xae\x45\xb2\xb0\x93\xcd\x42\x60\x95\x70\x35\xb5\x45\x4e\xe1\xed\xa9\x7d\x6b\xe9\xb1\x0b\x26\xd0\x47\xc5\x20\x3d\x15\x89\x4c\x18\x93\xd8\x2c\x8c\xb8\xe2\x8e\x76\x57\x63\x19\x25\xe1\x15\x4f\x00\xbc\x36\xa0\xbb\x59\x92\x6d\x56\xd9\x6a\xd7\x14\x51\x27\x90\x02\x60\xdb\x90\x9c\x22\x50\x4b\xfb\x49\xbd\xb9\xaa\x93\x33\x5e\x98\x1c\xb9\x6e\x3d\xfd\x37\x3d\x26\x04\x71\x29\x56\xe8\xef\xc2\x96\x47\x6f\x3f\x1d\x14\x3f\xf9\x37\xfd\x31\x01\x71\x0c\xd8\xb8\x9f\x24\x97\xf8\x0b\xca\x02\x7e\xb3\xca\xc4\x16\x08\xb8\x08\x09\x65\x7b\x1d\xbd\xac\x7c\x19\x2f\xa0\xc4\x36\x18\x01\xb3\xb3\x9f\x11\xee\x8a\x52\x95\xff\x29\x7e\x93\xf2\x11\x3b\xae\xe5\x43\x97\xf4\x26\x16\x4a\x35\xef\xf3\xe9\x40\xc2\xb3\xf4\x27\x7a\x1a\xdb\xaf\x5b\x39\x73\x45\xcf\xc1\x23\x47\x8c\x1d\x73\xe3\x47\x7b\xe9\x57\x1e\x30\xbd\x16\xe1\xab\x44\xd1\x5d\x37\x8f\xda\xb3\xe5\xc9\xc7\xeb\xfe\xdd\x85\xfe\x8b\x1e\xa2\x77\xd3\xed\x3a\xee\x42\x5f\x63\xaf\x42\x31\x33\x6c\x96\x24\x8e\x63\x16\x60\x37\xdb\xac\x43\x63\xce\xb0\x5b\x89\xa9\xfc\x73\x25\x74\x11\xf9\x13\x3e\x67\x41\x91\x67\x40\x34\x81\x68\x8a\xbc\x2f\x45\x30\x8c\xbb\xa3\x96\x66\x9d\xbc\x82\x20\xc5\x41\xe4\x4f\xfa\xfb\xd2\x07\xe8\x78\xbc\x0d\x78\x87\x2e\x12\x9b\xee\x9b\x77\xec\x77\xa6\xb7\x11\x78\xf7\xe4\x34\x3c\xd3\x85\x3a\xc7\xcc\x76\x51\x05\xf5\xe9\xf6\x68\x76\x43\x09\x68\xf0\x5c\x11\x49\x86\x28\xd4\xb7\xe8\xd3\xd4\x86\x38\x50\x19\xae\x0e\xb3\xa8\xd2\x58\xcc\x49\x4e\xd3\xb7\xe9\xbb\x74\x27\xee\xbe\xe3\x89\x27\xb6\xd2\xe7\xf0\x48\xa1\x49\x18\x4a\xff\x41\x3f\x38\xb6\x73\x77\x68\xef\x8e\x63\x89\x2d\xb0\x6e\xdf\xe6\x57\xc4\x4e\x32\xab\x4b\xa8\x8e\x59\x55\x99\x58\xad\x9a\x4c\x1c\x4e\xa4\xf5\x52\x71\x37\xa6\x75\x0d\x25\x54\x07\xb8\xd5\x18\x2d\xeb\xd2\xb5\x40\x6d\x21\xaa\xee\x6c\xf0\x02\x9b\xcd\xf1\x02\xce\xc7\xb1\x2f\xa9\x88\x3d\xd8\x8b\x5f\xa4\x15\xf4\xa2\x23\x63\x71\xcd\x9e\xed\xc2\x5a\x3a\x82\xce\xa6\xaf\xd3\xe2\x79\x5c\x3e\x81\xef\xa4\x3c\xc0\x17\x34\x0c\xc3\xd8\x04\x41\x3f\x46\x76\x4d\x50\x0c\x8c\x05\xcc\xbb\x0a\x18\x6a\xef\x0c\x18\x33\xe1\xcc\x17\xb9\x25\x04\x8c\xa5\xbc\x53\xb7\x0a\xbd\x19\xfb\x9d\x7e\x40\x18\x7a\x1d\x68\xb7\x3f\xe8\xbf\x70\x20\x61\xc1\xfb\x37\xaf\x62\x7b\xd6\x09\xd6\x2b\x17\xbf\x44\x01\xd4\x18\x73\x2b\xa2\xe6\xf0\x7a\x3c\x0e\xb7\x4f\x12\xe5\xac\xa0\xdb\xe7\xf0\xf4\x62\x24\x76\xc0\x42\x92\x81\xb2\xc4\xc4\x16\x54\x84\xce\x90\x5d\x32\xc6\xb4\x66\xb6\xdf\xc4\xf9\xae\x20\x36\x74\x6f\x81\x6c\x61\x43\x7b\x6b\x49\x98\xb5\x0c\xe9\x83\x9a\x7f\x48\xcc\xc3\xb3\x26\x2e\xba\xe6\xc1\x73\xe7\xd0\x7f\x2e\xab\x6a\xff\x27\x2e\x1f\xdb\xed\x5d\xf1\x4b\xfa\x21\x7d\x29\x71\xd3\x31\x7c\xd5\xfb\xcf\xfc\x48\xbf\xa7\x41\x41\x7e\xf6\x72\xbc\x6e\xdb\xe8\x4b\x19\x5f\x82\x5f\xdf\x5a\x87\x74\x3f\xbb\x0e\xf9\x6b\x13\x7c\xa6\x1f\xd7\x21\xcc\x8e\x80\x3d\x26\x4c\x92\x60\x17\xcd\xaa\x41\x4d\x33\xa7\xa6\xd0\x96\x9a\x49\x35\xca\xa0\x37\xee\xa3\x73\xb1\x57\x78\x3b\x31\x07\xcf\x29\x1c\x3a\x64\xf6\xe6\x27\x36\x0f\x3e\x86\x5f\x5f\x76\x75\xa7\x63\xa3\xdf\xdb\x0b\xfb\x16\xe5\x77\x1f\x9f\x20\x07\xca\x41\x75\x31\xab\xc7\x11\x34\x9b\x1d\x22\xc9\xcd\xb3\xf9\xf6\xf2\xc7\xdb\x70\xd7\x1d\x4e\x51\x12\xf7\x1a\x54\xac\x4b\xd6\xac\xa7\xcb\xb2\x1b\xd4\x53\x84\x99\x2d\xa7\x57\x1f\xc5\x83\xe5\x1c\xec\x48\xb2\xef\xd2\xae\x1d\xf7\x09\xbb\x70\x07\xac\xd1\x37\xe9\x07\xf4\x53\xfa\x3d\x1e\xde\x1d\x77\x78\xf4\x9e\xdb\x37\x0a\x57\x5f\xfc\x71\xfd\x31\x4a\xbf\x6f\xa4\x2f\xd0\x3d\x38\x0a\x06\xe7\x8e\x29\x27\x3b\xd0\x65\x2f\x7e\x3a\xe0\xfe\xe5\xcc\x8e\x34\xbf\x2b\xae\xe0\xfa\x0c\x6c\x9b\x48\x04\xc9\xa4\xf2\x4e\x4e\xc0\x5a\x12\x22\x36\xb4\xdf\x50\xa2\xdd\x90\x09\x11\x06\x9c\xa1\xf9\x33\xb7\xb4\xb6\x90\xcd\x86\xac\x71\x39\xc3\x0e\x41\x94\xca\xb0\x70\x2b\x5d\x87\x8b\x70\xc9\xf4\xf1\xd8\xf7\x21\x2d\xa4\x0d\x87\xc5\x4a\xf2\xc6\xe9\x2d\xa3\xf0\xcd\x78\x2a\x8d\x24\xbe\x4b\xb8\x99\xef\x09\x12\xfd\x12\xdf\x83\x6e\x31\xab\xc5\x2e\x89\xa2\xcd\x0e\xbb\x60\xb7\xec\xc6\xb1\x5d\x71\xbb\xdd\xa1\x69\xe6\x7d\x29\x79\x96\x92\x7a\x22\xb3\x43\x0d\xe3\x27\xa6\x54\xf5\x79\x8e\x60\xd4\x9d\xc2\x4d\xb8\x0a\x9b\xe8\xef\x37\x3c\xfc\xe7\xf1\x04\x15\x3f\xf9\x91\xfe\x78\x6a\x93\x58\xb4\xf5\x4e\xfa\xc6\xef\x24\xa0\xf7\x95\x12\x0f\xc0\xba\x5e\xd4\x1f\x7c\x7a\xbb\x64\x32\x39\x15\xbb\xe8\xf7\x99\x24\xbe\x30\xfc\xa8\x3a\x5d\x06\x27\x38\x31\xcb\xf3\x13\x53\x52\xdd\x3a\x0b\xd8\xdf\xa2\xe1\x8d\xe5\xd9\xf6\x78\x1d\x8c\x45\x40\xa7\xec\x5a\xfd\xc0\x91\x3f\x12\xa7\xf1\x49\x5c\x0c\xd2\x75\x1f\xed\x82\x5f\x04\xbd\xb2\x79\xfd\x03\xf4\xf8\x31\xe1\x37\xfa\x0b\xfd\xb2\x29\xf1\xc4\x31\x9e\x9f\x8a\x91\x19\xe8\x51\x0d\x70\x79\x40\xc2\x3d\x8a\x6c\x81\xd7\x34\x87\x03\xcb\xc4\xeb\xf3\x58\x2c\x58\x93\xf7\xa4\xd4\x65\xb4\x4d\xeb\x57\x5d\x71\x56\x60\x90\x24\xf0\x33\xb8\xfb\x45\xc0\xf1\x12\xc6\xd3\x63\x65\x93\x77\xe3\xea\xc1\x53\x1b\xed\xc3\x06\x6b\x5e\xec\x0b\x78\x0f\x7c\x03\x1a\x79\xdd\xe4\x9b\x9e\xc6\xfe\x59\x8f\xef\x9b\x9e\xbb\xe2\xc9\x3f\xe9\x77\x47\x7f\xa8\x30\x66\xfa\x2f\x00\x18\x9c\xe0\x0f\xfa\x1d\xb2\x53\x92\x44\xe2\x34\x5b\x2c\x4e\x70\xb3\x5d\x6e\x87\x2c\x63\xb3\x08\x0a\x7f\xa7\x53\xc0\x58\xd8\x9b\x26\x20\x7a\x2f\x4e\x7d\xfa\x78\xfa\x58\x1a\xe6\x0f\x32\x62\xe0\x74\x9f\x50\xbc\xfa\xd4\x11\x61\x3d\x38\xe1\x7d\xf0\xbc\xde\x5d\xad\x3e\xec\xf5\xda\xbb\xcf\x9c\x88\x2b\x8f\x91\x23\x09\x9a\x7f\xdd\xbc\x23\xff\x5a\xb9\xe6\xb2\x32\x3a\x8b\xeb\xbe\x79\x40\x97\x37\xb8\x7c\xbb\x81\x53\x1c\x58\xd0\x4c\x26\x8b\xe0\x16\x3d\x5e\x10\x76\xab\x85\x6b\x5e\x50\xff\x29\xc7\x47\xd0\x39\xa5\xf5\xd4\x27\xfd\xc2\x95\xb0\xc1\xdb\xa0\x78\x9d\x7c\x1e\x52\x24\x8c\x9f\xa5\xc7\xa2\xc2\x14\xfa\x03\x7d\x94\xee\x7f\xf6\xd0\x55\x2b\x13\xfb\x84\x93\xa7\x96\x8a\xf3\xf0\x97\x2f\x1c\xa6\xdf\xd0\xae\x37\xe0\xbc\x11\xb8\x68\xf3\x55\x23\x75\x5b\x06\x76\xa7\xc5\x96\xc9\xc8\x6a\xcb\xb4\x65\xf5\x19\xb6\x0c\x94\xee\x99\x6d\x99\xf0\xae\x61\xc9\xd8\x33\xeb\x9a\x4f\xc8\x11\x78\x66\x0e\x1a\x15\xf3\xd8\x35\x84\xbd\x4a\xc0\xe4\xf7\xfb\x7c\x26\xac\x89\x79\xb9\x01\x65\x37\xee\x1d\xd3\xe2\x39\x01\x6c\xd5\x07\x42\x7b\xed\xc8\xb7\x1f\x96\xf3\x1a\x0a\xdf\x9b\x54\x51\xbc\x43\x2e\x9b\x03\x9d\x62\x4d\xa0\x7f\x55\xea\x62\xd2\x2e\x68\xd8\x1f\xad\x2a\xe4\x1d\x80\xcd\x58\x16\xc3\xe0\x97\x83\x2f\x5a\x2b\x1c\xc2\x9e\x5c\x6b\xef\xd9\x8b\xef\x2e\x0b\x9c\xc4\x8e\xa5\xbe\x9e\xd8\x1f\xcb\x5b\x72\x82\x0e\xa7\x8b\x8f\xe2\xd0\xd4\xfe\x7d\x7a\x15\xd8\xc4\x4f\xe8\xe6\x55\x1b\x47\xe7\x45\x0e\x0d\x7b\xee\x25\x21\x94\xf8\x89\xc2\x9f\x95\x3d\xc5\x6f\x12\x9b\xed\xb6\x9e\x0b\xd6\x73\x5c\x40\xef\x4a\x21\xee\x2b\x77\x8b\xd9\xec\x41\x93\xa2\x04\xb1\x5b\x64\x63\x5d\x41\xb6\xb6\xf3\xde\x8f\xf5\x3b\x6c\x58\xc0\x7b\x53\x66\xab\xa5\x47\x47\xda\x4e\x31\x6d\xe7\x4b\x89\xb5\xc7\xae\xeb\x5a\x70\x64\xb0\xbc\x5f\xd8\x8d\xf3\x4f\x81\x53\xb9\xf6\xb3\x86\x4d\xeb\xfa\x38\xfb\x36\x16\x80\x1b\xfb\x07\x3d\x92\x88\x0a\x07\xd7\x2f\x4c\x1c\xdf\xf2\xd6\xb8\x63\xd1\x2b\xa6\xf2\x3b\x47\xe6\xaf\x15\x8b\x9f\x38\x8a\x25\x09\x21\x87\x22\x49\xc2\x94\x56\xaf\xab\x99\xaf\x0b\x7d\x33\x5e\x57\x05\x1e\xcf\xa2\x8f\x45\x59\xb8\x1a\xec\x3e\x41\xae\x9d\x58\x94\x30\xc0\x00\xe6\xfd\x90\x11\xd2\x46\x20\xe2\x59\xb1\xf3\x26\xc0\x54\x16\x74\x7b\x0d\xef\xe7\x7e\x02\x8b\x59\x03\xcf\x60\xc5\xa4\x4a\x58\xd6\x3f\x14\x3d\xa4\x0f\x19\xd0\x3f\xe7\x4e\x7d\xf6\x63\xf8\xcb\xc5\x1e\x90\x58\xca\x1e\xc2\xe7\x00\x88\x4f\x8b\xf5\xf0\x04\x33\x8a\xc6\xb2\x14\x59\x35\x9b\x20\xde\x94\x90\x55\xb2\x98\x49\x63\xdc\x6c\x96\xb1\xe4\x55\x65\x2d\xd5\x40\x53\xef\x87\xac\x8f\x82\x62\xdc\x57\x12\x66\x43\xf1\x2d\x82\xf8\x34\x3d\x3a\x86\x16\x8f\xa0\xbf\xe1\x47\xf0\x28\xfb\x86\x07\xff\xf3\x1f\xb1\x3e\x71\x0b\xde\x4e\x07\xeb\xeb\xc8\x66\x5e\xe7\xe8\x46\x97\xc5\xea\x14\xbb\x6a\xb3\x39\x10\x71\x23\x8b\x5d\xf4\x8a\xa2\xc7\x9a\xad\xb6\x57\x05\x02\xfa\x4f\x93\x55\x15\x49\x6e\xa1\x91\x55\xf5\x49\xa2\xd7\xe4\x92\x5c\x7c\x4c\xad\xad\x31\x55\xd5\x97\x31\x4f\x3e\x55\x6c\x10\x35\x7a\x91\x46\x53\x6d\xb6\x40\x53\x12\xa3\x99\x0f\xff\xc2\xce\x08\x11\xfe\x4d\x1f\x9f\x4d\x3f\xc6\xbf\x92\x04\x0d\xe0\xbd\xf4\x5c\x41\x3e\xfd\xe3\x05\x3b\xb1\x4a\x01\xde\x37\xbf\x79\xe3\x8f\x43\xf8\x73\x7c\x3b\x9d\xa6\xdf\x43\x0e\x6a\xfe\x49\x7e\x4f\x1c\x8c\x8a\x21\x22\xa8\x47\xb7\xc7\x06\x04\x04\x6b\xad\xcb\xed\x56\xda\x5b\xad\x79\xb5\x5d\x72\x3b\x29\x85\x45\x45\xb9\xb9\xb5\x0a\xe9\xd6\x55\x10\x50\x61\x21\x72\xb9\x50\x20\x90\x85\x2c\x5d\x72\xbb\x34\xc5\xdb\x6b\xb9\x58\x23\xb9\xb9\x59\xa8\xa4\x00\x15\x0c\x89\x8b\xc8\xa1\x75\xce\xea\xdc\x14\xf7\x65\xf9\x32\x27\x70\xf1\x64\x04\x36\x68\x3d\xa3\x47\x45\xdb\x06\x06\xa9\xfc\x5c\xa3\xff\x64\xbe\xbf\x86\x8f\xf9\x97\x35\x23\xcb\x8b\xf5\x69\xd0\x9b\xc8\x09\xce\xea\xb0\x31\x88\x56\x2a\xb0\xe3\x1c\x63\x44\xad\x51\x3a\x22\x54\xe2\x9a\xf9\x4b\x71\xe0\xa1\x1d\x5f\x7c\xfa\x5b\xe3\x88\x61\x83\x54\x5c\x94\xf5\xf3\x3b\x9f\xcc\x5c\xf2\xce\xbf\x4e\x08\xbb\xae\xb9\xfc\xae\x12\xfa\x9f\xab\xc5\x61\xe7\xce\xec\x75\xef\xa5\xc3\x3b\x0c\x3c\x7d\xe8\xe2\xcb\x09\x1d\x6d\xba\x52\x1c\xfc\xdd\x77\x4f\xac\xdd\xb4\x55\x12\x6b\xaf\x98\x38\xa0\xc1\xfe\xc0\xc6\xcb\x2f\x07\x99\x69\xe7\x5e\xbd\x61\xb1\x1f\x17\xbf\x3c\x78\x49\xbf\x0e\x82\x18\xe9\xd7\xed\xfc\x81\x09\xb7\xde\xe8\x81\xf0\xf9\x43\x9f\xf1\xfc\x0c\x36\x61\x65\x7c\xac\x0a\xbb\x21\x9c\xf4\x3a\x1c\x24\xab\x50\x2d\xb4\x28\xb9\x84\x28\x65\xa5\x38\xa2\xaa\x59\x6e\xab\x39\xdb\x2c\x38\x88\xd9\xac\x58\xad\xc1\x86\xb8\x55\x53\x0a\x1b\xe2\x8a\xb7\x75\x75\x49\xd4\xc8\x99\x6d\xdd\xf2\x94\x4f\xa5\x89\xf0\x83\x12\xbd\x63\x7d\xd8\x68\x9b\x57\xc4\xf4\xa4\x17\x3c\x1a\xb7\x5e\x74\xcf\x12\x13\x3f\x7d\xf6\x9a\x5d\xdb\x13\x17\xcf\x9c\x29\x8c\x39\xf4\x4c\x6d\xf9\x5b\x74\xde\xe0\x49\xf4\x38\xb6\x5e\xd4\x14\x2a\x1d\x3e\xb6\x99\x2e\x1e\x8d\x9f\xef\x74\xfd\x0d\xcb\xf1\xf3\x6f\xe0\xad\x73\xaf\xeb\x3e\x3c\x32\xbf\x77\xf4\xdf\xdd\xe8\x0d\x55\x5d\xfc\xf4\xaf\xee\xa9\x5c\x98\x5a\x5e\xa3\xd7\x97\xcb\x25\xb3\xfd\x8d\x80\xab\x09\x2c\x5c\x69\xcc\xe3\x04\x59\x92\x90\xdb\x85\x1d\x0d\x71\xac\xb1\x5c\xdb\x16\x36\x6e\xf1\x9d\xa3\xdc\xa8\x7b\x50\xa4\x24\x59\x51\x7f\x2b\xde\x01\x3a\xcc\x4a\x7f\x38\xed\x5a\xbe\x64\xfe\xe2\x35\x62\x3d\xfd\x91\x9e\xa2\xf4\x8b\x83\x4f\x6e\x7e\x62\x53\xe2\x42\xbe\x56\xc8\x58\xcb\x0a\xda\x70\x50\xac\xd8\x2f\x9b\xbd\x41\x6b\x10\x9b\x59\x73\xd9\x50\x56\xc0\x8a\xac\x8d\x71\x2f\x42\x66\x41\xf0\xb0\xba\x01\x73\xb0\x31\xd5\xbc\xf3\xec\x8d\x63\x79\x9e\x6a\x0a\x20\x20\xa2\x64\xc0\xc4\x07\x79\x84\x66\xa6\x00\xa3\x17\xcc\x14\x34\x0e\xdc\x9e\x3d\xc2\x0a\xbc\xd5\x00\x10\x3f\xff\x1f\x06\xe2\x91\x37\xfe\xa3\xd7\x32\x00\x03\xbc\xc9\xfb\xa7\x0d\x8a\x95\x12\xc5\x82\x24\x90\x70\x0b\xb2\x59\x4d\xd9\x52\x7b\x96\x16\x2d\x81\xd0\x4b\x2c\xea\x17\x1b\x19\x85\xd4\x0c\x0a\xa5\x89\x77\xfa\x6c\x0c\x4e\xb1\x94\x60\xdf\x4a\xf2\x12\xbf\xe1\x6f\x68\x8e\x50\x61\x08\x31\x3b\xa7\x62\xf5\x79\x20\xbb\x25\x68\x70\xac\x24\x6c\xcf\x0d\xe4\x3a\xcd\x45\xfe\x40\x40\x24\x45\xa4\xac\xd4\xef\x0f\x89\x22\x0a\x85\x3c\x4d\xf1\x90\x03\x29\xac\x63\x4a\x43\x19\x1e\x73\x86\x34\xcb\x96\x5e\xd8\x86\xd0\x49\x2d\x5d\xfd\xff\x6b\xcf\x6f\xfc\xf3\x8e\xcf\xca\xce\xda\xe6\xfb\x77\xcf\xfa\x3b\xcf\xde\xd9\xfb\x9e\x27\xf9\xfe\xde\x46\xaf\x64\x8d\xd7\xb8\x8e\x2f\x8a\xb9\x64\x41\x90\x30\x36\x81\xa6\xbc\x20\x2e\xc8\x8a\xc6\x26\x9b\xf4\x74\xbc\x95\x7e\x16\x29\x79\xc3\xd5\xbc\x3d\xdc\x63\xf4\x08\x3b\x80\x7c\xe9\xed\xb7\xc5\xc4\xa9\x57\x8d\xbe\xa3\xbd\x80\x26\x4b\xe1\x7b\x07\xaa\x89\x65\x81\xee\x25\xaa\xdd\x4e\x5c\x4e\xa0\x84\xd5\x6a\xe1\x93\xdb\x95\x86\x36\xc9\xa6\x2d\xb3\x11\x75\xdc\x8b\x18\xee\xd5\x20\x5b\x2c\xb3\x07\xff\x63\xd7\x4b\xb9\xd8\xa3\x9d\xd3\x6d\xf9\x09\xc1\x71\xd8\xf3\xc0\xe6\xf0\xa8\x01\x7b\x05\xf1\xcd\x44\x64\xf7\xdf\x93\x75\xbb\xe2\x2c\x96\x83\x43\xae\xe0\x30\x68\xc0\x0f\xc3\x78\xcf\xd5\x5e\xb1\x7c\x93\xd5\x2a\x11\x8c\xcd\x88\x68\x76\x55\x95\x4d\x26\x40\x51\x26\x04\x83\x3e\x03\xd6\xc5\x2d\x93\x5b\x5a\xab\xc3\x68\x32\xe4\x54\xaa\x59\xc5\x76\xad\x57\x01\x65\x3f\x2c\x51\x7f\xdd\x75\x58\xfb\xe3\x0f\xfc\x0c\xbe\xbd\xe1\xeb\x46\xfc\x2a\xdd\x75\xeb\xf7\xb7\xd0\x17\x0d\x3e\x94\x46\x33\x1d\x84\x7b\xc6\xbe\x30\x49\x92\x6c\x77\x3a\x1d\x0e\x0b\xf3\x7d\x9d\x32\x1b\xf2\x28\x34\xc4\xed\x8a\x86\x2d\x6c\xdd\x81\x3e\x5c\xe8\xc3\xc7\x7d\xf8\xb0\x0f\xdf\xe7\xc3\x37\xf8\xf0\xe5\x3e\xdc\xd5\x87\xcb\x7d\xd8\xe3\xc3\xa2\x0f\x5f\xf6\xad\x0f\xef\xf4\xe1\x99\x3e\xdc\x27\xf9\xea\x29\x1f\xfe\xd1\x87\x3f\xf0\xe1\xbd\x3e\xbc\x82\x7f\x60\xa8\x0f\x77\xe6\xef\x86\x17\xef\xf4\xe1\x79\x3e\x7c\x89\x0f\xeb\x8f\xb6\xf8\x70\xdd\x29\xfe\xf8\x37\x7c\x78\x9b\x0f\x6f\xe4\xef\x68\xf5\xb8\x5f\xf9\x6f\x9f\xf3\x61\x61\xab\x0f\xdf\xe6\xc3\x57\xf9\x70\x83\x0f\xe7\xf9\xf0\x6f\x3e\xfc\x4f\x1f\x7e\x9e\xbf\xb8\xc8\x87\xc7\xfb\x70\xa3\x0f\x77\xf4\xe1\x7c\x1f\xd6\x7c\x58\x01\xf7\x2c\xf9\x67\x3a\xfb\x33\x8e\xfd\x35\x23\xf5\x67\x6c\xfa\xef\x5a\x7e\x35\x36\xed\x43\x99\x35\xea\xad\xab\xe6\x5b\x17\x75\xb3\x4a\x6f\x32\xa9\x55\x45\xf7\x09\x57\xeb\x52\xee\x53\xaf\xb2\x12\xef\x64\x2f\xf2\x31\xdc\x1f\xe8\x12\x0b\xb1\x19\x50\x36\x8c\xed\x8a\xdd\xe9\xb0\x5a\x35\x51\xb4\x4b\x9a\x66\xb2\x7b\xdf\x71\x32\x79\xd4\xfd\x8e\xd6\x9d\xd2\x79\xba\x20\x1f\x90\x14\x36\x06\x26\xe1\x3b\x8d\x79\x48\xa7\xf5\xf9\x48\xa9\xe1\x47\xb0\x6a\x72\x1c\x52\x4a\x5f\xdf\xc1\xf5\xb5\x9e\xab\xc7\x6a\xb5\x23\x3c\x57\xcf\xc7\x65\xee\xbc\xe6\x53\xe2\x63\x62\x0f\xc4\x5a\x06\x96\xc6\x5c\x9a\xea\x21\x44\xf5\xfb\xac\x56\xd9\xe9\x94\x91\x2e\x73\xad\x7a\xb7\x33\x43\xcc\x94\xa5\x3e\xc2\x16\xb3\xb4\xf7\x30\x9b\xf9\x21\xcc\xc6\x0a\x2e\x87\x80\xf9\x24\x28\xc6\x0f\x21\x3e\xd1\x5e\xd8\x82\xa7\x3d\xbd\x4f\xec\xd1\xaa\xd6\x91\x7e\xba\xf0\xda\x66\xb4\xe0\x1a\x4c\xf4\x33\xc0\xf3\x50\x19\xc0\xe0\x40\x01\x90\x7a\xa7\x13\xd9\x64\xe4\x31\xcb\x62\x56\x50\xd3\x88\xea\x25\xa8\xb2\xb2\x55\xd8\xe1\xee\xcc\xd6\x66\xaa\x87\xb0\x93\xb8\x70\x3e\xeb\xdb\x43\x2a\x84\xf3\xf8\x08\xc7\x56\xdd\x33\xa7\x6d\x19\x27\xd8\x4f\x80\x06\x3f\xc6\x1a\x6f\xe2\x50\xb2\xf1\x26\xfd\x5e\xbb\xee\x1d\xdd\xef\x29\x6e\xde\x22\xbe\x2e\x2e\x03\x6f\x2d\x0b\x15\xa0\xa9\xb1\x12\x87\x4d\x26\x41\x5b\x3e\x21\x92\x29\xd7\xe7\xcf\x71\x69\x36\x73\x61\x44\x31\x7b\x3c\x28\x37\x17\xf9\xfd\xa0\x48\xcd\x4e\xc4\xa2\xdb\x3c\x16\xdd\x22\xb3\xe6\xe2\xdf\x42\x78\xad\x31\x75\xd2\x33\xb3\x09\x5c\xba\x3c\xb7\x6a\x1d\xc0\x4f\x15\x81\x9d\x4a\xaa\xfd\x35\xbc\x6f\xb1\xe2\xf7\x96\xc8\xa4\x40\xc1\x40\x4f\x5c\x55\x8b\x59\xae\x80\x30\x8f\xd5\x82\xc6\xe7\x7f\xbc\xfa\x27\x56\x0c\x7a\xc1\x8c\xb7\x6e\xf9\x63\xf4\x79\xf8\xd0\xb9\xf4\xf6\xb1\x7d\x68\xe7\x7e\xcf\x58\x70\x21\x16\x9e\xbf\x61\xfa\x33\xaf\x5c\x43\xff\x49\x13\x07\xae\x9f\xb8\x7b\xf7\x74\x92\xed\xa4\x97\x75\xbb\x02\x23\x6a\x76\xe0\x7b\x7a\x4c\xba\x61\x11\xc7\xb5\x77\xf3\x4f\x4a\x77\xb0\x13\x59\xa8\x10\x95\xa3\x59\xb1\x58\xbe\x22\x58\x43\x21\x77\x69\x20\x18\x2c\x73\xb9\x4a\x15\xd2\xa1\xbd\x39\xb7\x21\x6e\xb6\xbb\xca\x9a\xe2\x42\x00\x59\x5d\xe0\xd4\x59\x5d\x81\x80\xcb\x4a\xec\xc8\x5e\xd4\x14\xb7\xfb\xc4\x48\x03\x6b\x3f\xef\x03\x3b\x62\xcc\xbd\x4f\x6a\x50\x3f\x9b\x2a\x5e\xc9\xeb\x60\xeb\xf4\xc1\x2a\xe9\xe5\x60\x46\xcb\x73\x5c\xe5\x67\x2d\x8c\x79\x55\x6c\x2b\xdf\x8d\xa5\x17\xf3\x96\xcd\xf9\x49\xcf\xad\xe8\x97\xeb\x6f\x3b\x99\x60\x77\x4d\x34\xd1\x8c\x6e\xbe\xf1\x5f\x69\x0e\x1b\x19\xb5\xf0\x5a\x0c\x8c\x04\xcc\x25\xa5\x1c\xb6\x07\x1f\x4c\xb2\xe0\x9a\x35\x69\xae\x5a\xe2\x2d\x9d\x1b\x13\x5a\xaa\x1f\xd7\x60\x90\x85\x73\x40\x4e\x72\x50\x19\x6a\x8c\x95\xf8\x14\x8b\xcb\x6d\xb5\xb8\xb3\x2c\x25\x62\x38\x2b\x4b\x2c\x6f\xe7\x57\x14\x64\xd1\x0a\x9b\xe2\xac\x09\x97\x45\x43\xb9\x43\x52\xe6\x22\x2d\x0d\x39\xda\xa6\x9a\x4c\xb7\x9b\xbc\x99\x6f\x6d\x35\xfc\x13\xd6\xf3\x1f\xc2\x2d\xe3\xfb\x4b\x92\x76\x94\xed\x6f\xbf\xfb\xbe\x9b\x7b\xe3\x55\x63\xaf\xc5\xa6\x19\x13\x2f\xba\x02\x9b\xe6\x8c\x9d\xb1\x74\xee\xb7\x0f\x5c\xb5\x60\xe1\xb4\xab\xe6\xcf\xf7\x4c\xde\x37\x77\xe9\xae\xa0\x58\xfc\xe2\x55\x4b\x16\x2d\x5a\x32\xe3\x85\x22\x31\xf8\xcc\x0d\x73\xf7\x4d\xde\x7b\xdd\xdc\x69\xd7\xcc\xbe\x72\x1e\xef\x4f\xdd\x28\xe4\xf2\x7a\x66\x2b\x2a\x8e\x39\x15\xd9\x0a\xa1\xb4\xdd\xa6\x80\xdb\xc9\x86\x1f\x39\xf4\x6b\xbc\xb4\x61\x6c\xa9\xb9\xe6\x8c\xf0\xf9\xce\xc6\x4c\xd1\x14\x72\xf5\xaa\x63\xfa\xfb\x0b\x5b\xe8\xed\x5c\x46\xb9\x1e\x11\xb2\xf5\xe7\x4b\x10\xa7\xcb\x56\xbb\x4d\xb2\xaa\x2a\xd8\x11\xd5\x77\x86\xe7\xf3\xe3\xb4\xea\xb0\x71\xbc\x36\x1b\xa3\x6b\x17\xe2\x62\x7a\x04\x58\x19\x34\x81\x90\x4d\x6f\xdf\xf2\x02\xfd\x0d\x74\x42\x3b\x76\x13\x20\xa0\x95\xa0\x23\x97\xc3\x5e\x98\x41\x0a\x59\x5d\x14\xc6\x82\xa6\x28\x82\xd7\x63\x41\x4d\x71\x8b\x85\x08\x5e\xe2\x6e\x4a\xb5\x25\x6f\x53\x17\xc5\x53\xbf\xf5\x0b\xc3\xa2\xb0\xe1\xc0\xe1\x4d\xf4\x7b\x21\xef\xc8\x89\x3f\x8e\xd2\xbf\xb0\x69\xc2\xe8\xc9\x93\xfe\xc4\xab\xe9\x95\x62\xfd\x96\x47\x1e\xde\xb2\x75\x74\xbf\xc1\x23\x90\xc0\xb2\x5d\xc4\x6c\x6e\x9f\x3d\xa8\x0f\x9b\x7c\xe5\x71\xca\x1e\x96\x62\x24\x83\x1d\x12\xbc\x6e\x5e\x8f\x67\x83\xf0\x4c\xb5\x0a\x5e\x55\x6b\x8a\xab\x5a\x3a\x03\xe0\x68\x6a\x8a\xb2\xb1\xef\xac\x88\x4d\x6f\xe3\xcc\xb4\xb5\x9b\xb5\x6f\xee\x8a\x85\xde\x80\xeb\x21\xdc\x7b\xc6\xec\x3f\x8e\xe2\x23\x00\xd6\xf3\x87\xf6\xbd\x83\x77\xd0\xf3\xf1\xc7\xa1\xfb\xaf\x59\x7b\xff\xa9\x57\xc1\xcd\xfc\xc7\x3d\x77\xe9\x79\x35\xe9\x30\xf5\x8d\xb9\x6d\x66\x8f\x02\x00\x39\x15\xe4\x01\xe5\xac\xf8\xbc\x36\x4d\x07\xca\x66\x13\xb1\x45\x13\x81\x2e\x62\x66\x07\x98\x8c\x26\xa5\x7a\xe8\xc4\x6b\xc6\x58\x16\x12\x3b\x58\xf4\xeb\x50\x11\x01\x67\xd1\xe0\xbf\x8e\x5f\x3b\x9d\xee\xc7\x51\xec\x78\xf1\x9d\x7d\x87\x9e\x17\x96\xe1\x1d\xa7\x5e\xbd\x7f\xed\xec\xfb\x42\xf8\x63\x7a\xfe\x13\x77\xdd\xa3\xe7\x9c\x83\xf2\x60\x7d\x81\x15\xbc\x26\xd6\x0c\xf1\xba\x84\x08\x84\xe0\x5e\xa2\x70\x1f\x4a\xbb\x51\xc5\x17\xa9\x78\xa8\x8a\xfb\xa8\xb8\x46\xc5\xc5\x2a\x3e\xa1\xe2\x6f\x55\xfc\x91\x8a\x5f\x55\xf1\xdd\x2a\x86\x37\x5c\xa3\xe2\x49\xc9\xdf\xca\x2a\xbe\x34\xf5\xbb\x99\xfc\x17\xc3\x93\xbf\x73\xa9\x58\x54\xf1\x71\x15\x7f\xcf\x3f\xbf\x4b\xc5\x1b\x54\xbc\x5a\xc5\x37\xa4\xbd\x13\x96\xa9\x52\x71\xa1\x8a\x3d\xfc\x59\xfa\x62\x1f\xa8\xf8\x65\x15\xef\x54\xf1\x26\xfe\xd8\xd4\xfb\x01\xac\xbe\xfc\xe1\xa9\xf7\x77\x39\x91\x7c\x7a\xfa\x07\x74\x24\x70\xa3\x8a\x63\x2a\xee\xcc\xdf\xfe\x9b\x8a\xff\x99\x7c\xf0\x9d\x2a\xbe\x4e\xc5\xc2\x55\x6a\xac\x18\x8f\x57\x31\xec\x74\xbe\x8a\x1d\x2a\x86\x38\xfe\x1d\x15\x3f\xaf\xe2\xab\x54\xf6\x7a\x8c\xbf\x0e\x2f\x9a\x32\x3d\x8f\x71\x2d\xde\xc7\xb8\x36\xce\x49\xa6\x07\x33\xbd\x95\xaf\xd2\xfa\x9d\xfa\xef\x50\xea\x68\x20\x79\x11\x6b\x34\x7f\xe5\x69\xfc\xf4\x7b\x9e\xbe\x7f\xfa\x06\x32\x9f\xd9\xfd\x45\x20\xbf\x43\xb9\x5f\x3a\x9b\xef\xe7\x00\xd4\x5e\x5c\x23\xaa\x60\x73\x3b\xc7\xfc\x36\x8f\x03\x36\x92\x80\x7d\xcb\x0a\x3a\x60\x47\x91\x62\x0d\xa8\x26\x2b\xcb\x57\xa9\x74\x19\x09\xba\x99\xfe\x88\x3b\x9c\x5f\xad\xdf\xc1\xb1\x1e\x42\x10\x84\xeb\x41\x40\x24\x3c\x40\x18\x87\x73\xb6\xde\x94\x78\x96\xf4\xbb\x70\x5a\x7b\xf7\xc3\x79\xf3\xaf\xfa\xe0\xcd\xc4\x10\xdc\xe7\x85\x49\x0b\x70\x50\x22\xf4\x38\x31\x8b\x75\x4f\xcc\x7e\x62\xb7\x6e\x7b\x9b\x50\x7b\xe9\x10\x87\x23\x1b\xe5\x83\x04\xe6\x2b\x81\xbc\x50\x28\xdb\x41\xf2\xb3\x6d\xc4\x93\x1d\xf0\x90\x82\x70\x7e\x4e\x30\x3b\x27\x3b\xc7\x04\x2a\x46\x31\xb1\x89\xb5\x95\x87\x38\x54\x87\x52\x1d\x8e\xa2\x2d\x27\x06\xec\x60\xee\x2c\xb0\x61\xbd\x0a\x39\x82\x17\x9e\x19\x48\xfa\xc1\x61\xf8\x73\x06\x50\xf1\xd4\x4f\x84\x15\x1f\x71\xba\xf5\x6f\xf6\x8b\xf7\x4a\x15\xa8\x18\x9d\x1b\x0b\xfb\x9c\x8a\x2d\x2b\x17\x28\x57\x50\xe0\xc9\xca\x42\xa5\x25\x0e\x25\xaf\x18\x81\xd1\x28\xce\x13\xad\xb9\x29\x0a\xa6\x26\xaf\xa7\x85\x57\x49\x75\x71\x66\x42\x2a\x49\x90\x9d\xfc\xd7\x25\xe1\xfe\x0c\xe2\x2d\x37\xa7\x43\xfc\xd3\xc2\x2b\x3f\x3e\x98\x18\xc2\x7e\xf1\xe0\xca\xc4\x56\xe1\xb1\x8d\xc3\xa7\xa4\xc0\xee\x7c\xdf\x15\x7f\x56\xcb\xb5\x6b\x67\xaf\xdb\x84\xfd\x1b\x9b\x2e\x93\x18\x0f\x98\x40\xaf\x4c\xe1\xf5\x01\xf1\xb6\xf5\x02\xf0\x7b\xf0\x10\xc9\x2e\xfe\xf3\x18\x3d\xf7\x81\xc7\x94\xdd\x20\xee\x6e\x8a\x95\x7a\x35\xa7\xc3\xe3\x09\x38\x89\x19\x62\xca\x00\xc9\xc9\x16\x45\x97\xc6\x9a\x66\xb8\x3c\x4e\x17\xc4\xf9\x2e\x4d\x8f\x2b\x5b\x95\x9c\x44\xa3\x6d\xc6\xfe\x44\xdb\xc6\x95\xe5\xb8\xba\x96\x5d\xa4\x4b\xba\x75\x4c\xc5\x92\xf1\x4b\x2e\x9e\x3d\xe1\x5f\xd4\x4b\xaa\xe9\x91\x0d\x2b\xa7\x1d\xd2\xa3\xc8\xa1\x83\x47\x35\x3e\xf0\xd9\x5b\x7b\xfe\xf0\x3f\x70\xcf\xc4\x75\xc3\xf4\x73\xd2\xe6\x9f\xc9\x6e\xb1\x01\x45\x40\x63\x16\x45\x10\xb2\x05\xb2\x55\xa7\xcb\x95\x27\xcb\x6a\x80\x14\x15\xda\x9c\x79\x11\x91\x78\xbd\xda\x90\xb8\xd7\x41\xc2\x43\x32\x1a\x78\xf8\xdb\xce\xff\x02\x2e\xe2\x5d\xff\xb8\x05\x67\x20\x82\x77\x92\x16\xf1\x32\xbb\xcd\x26\x13\xec\xce\x39\xbc\xe3\xfd\x0f\x57\x2e\x58\xb3\x6c\xd3\xdd\xd9\x7f\xf1\x1f\x56\xcd\x5f\x7d\x0b\xfc\x80\x9d\xab\xee\xd9\x70\xe7\x94\x9b\xcd\x13\xbb\x0f\xbe\xfe\xfa\x2c\xf6\xc3\xe5\x2b\xcd\x13\x7b\x0c\xe0\xbe\x07\x46\x2e\x90\xc7\x37\xc1\x5e\x97\xa3\xfe\xb1\x42\x3b\xca\x25\x41\x77\xb0\xd8\x2d\x17\xcb\x1d\xda\x83\x63\x95\x6b\xb7\xfb\x8a\x14\x45\xf4\x39\x0a\xcc\xa2\xb9\x31\x5e\x2a\xb6\x9c\xa0\x19\xbd\xff\x32\xe9\xaa\x0f\xa2\xe4\x93\xfb\x0d\xaa\xf6\xc4\x25\x15\x42\x72\x9a\x80\x1d\x6b\x58\x4f\xa8\xaf\xf5\xf3\x5c\x7a\x61\x5a\x59\xc7\xbb\x47\xdd\xbd\x20\x56\x38\xb6\x02\xcc\x6d\xcd\xb4\xda\xf6\xd9\x5f\xee\xdd\xfb\x65\x4e\x87\xea\x69\x35\xc1\x58\x55\xc5\xb8\x48\x6c\xfe\x3d\x23\xef\xee\xf4\x76\xaf\xf3\x87\x9d\xf7\x49\x4e\xbb\x8a\xc8\xc0\x65\xe7\x34\x8c\xa8\xba\xe3\x99\xdd\xab\xab\x46\x36\xc6\x96\x0d\x8c\x54\xb4\xcb\xf9\xe4\xbc\xa1\x83\x51\xea\xdc\x83\xf5\x11\x90\x50\x5e\xcc\xce\x46\x99\xc8\x8a\xe8\x95\xc0\x39\x90\x0c\x7b\xd9\x72\x1f\xcd\x95\x14\x2b\xfc\x67\x45\x58\xfb\xd9\x64\x8a\x74\xde\x14\x06\x27\x9f\xc7\xfb\xe9\xb1\x93\x00\xa7\x80\x25\x19\xd4\xb6\x49\x90\xbd\xfa\x48\x4a\x94\xba\x07\xae\x4b\xbb\x8a\x60\x5f\x62\xdf\xe4\x1c\x92\x53\xaf\xea\x63\x2f\xf4\xda\x67\xc3\xbf\x70\xc9\x52\x17\xfe\xfc\xc5\x10\x1f\x2f\xe3\xf5\x67\x3d\x62\x79\xc8\x62\xf1\x59\xdd\x0e\x51\x71\x58\x15\x92\x15\x34\xdb\x7c\x36\x76\x30\xe0\xb3\xfa\x25\xa7\xd1\x8e\x38\xad\x48\xbc\xd5\xf0\x97\x1e\x02\x6f\xa6\x26\x4b\xf0\x77\x61\xaa\x53\x72\x98\x2c\x1d\x77\x71\x07\xec\x3e\x41\x4f\x80\xc3\x73\xe2\x2f\xec\xbe\x7c\x29\xf8\x34\x0a\xae\x5f\x30\x03\xab\xf4\x48\xf3\xe7\x02\xdd\x87\xcf\x11\xbe\xf9\x0b\x07\xe9\x9f\x0f\xac\x10\x84\xaa\x64\x7d\x21\xaf\x49\xf2\xa0\xca\x58\x00\x79\x04\x97\xc5\xe5\x21\x3e\x2f\xf2\xba\x80\x96\x2e\x08\x14\x1b\xe2\x26\x5f\xfa\x18\xf5\x96\x56\x18\x6d\x3b\x2d\x92\x2b\xce\x50\x36\xd8\xb6\xec\xe8\x55\xf0\xbf\x72\xf1\x51\xf2\xb2\xf4\x06\xcb\x89\x46\xd1\x98\xd3\x62\x16\x91\x42\x44\x45\xb4\xdb\x04\xb3\x59\x42\xe2\x5e\xdc\x0e\xf6\x48\xc2\x45\xa9\x8a\xf9\xb4\x93\x12\xe6\x60\x94\x84\x95\x08\x8e\xaa\x2c\x35\x49\x10\xe8\x30\xba\x7a\xd8\x6b\x78\xcc\xcf\x78\x34\xad\x28\x1f\x87\x3d\x37\xe3\xa3\x94\x92\xaf\x4e\xe7\x91\x7e\xb7\xd1\xaf\xf1\x83\xdc\xff\x2e\xc4\x3f\x4a\xa3\xa5\x37\x21\x2e\xf6\xa0\xd1\xb1\x22\x8b\x62\x77\x0b\x1e\xd1\x83\x54\x9b\x0d\x31\x16\xb2\x03\xe2\x26\xa7\x53\x12\xdc\x56\xd5\xa6\x62\xb7\xea\x56\xa5\x7d\x00\x81\x08\xb0\xd8\x80\x58\xed\x58\xe2\x54\x4f\x66\x09\xc6\xa4\x94\x4b\xc6\xf1\xb1\x3e\x60\x0c\x80\xab\x66\xc0\x19\xe7\x67\xce\xb0\x17\x47\x14\x12\x15\xee\xa3\x6f\xcd\x7a\x07\x7f\x46\x62\x34\xc2\x5d\xb1\xbf\x12\x3d\xdb\xf5\x5a\xf2\x33\xfe\x91\x41\xba\xfe\xe4\xfd\xf4\xdf\xeb\x49\xbf\x3b\xe8\x77\xdc\x4e\xd5\x02\x7d\x96\x03\x7d\x6c\xa0\xe1\x72\x50\xf7\x98\xdf\x6e\x32\xf9\x91\x3b\x14\x12\x91\x98\x97\x9b\x65\xb1\xb9\xb1\xdb\x2d\xba\xa4\xbd\x00\x5f\x88\x43\x68\xd0\x69\x4c\x34\x9a\xe9\x90\x19\x23\xe1\x9d\x2c\x6c\x65\xb5\xbe\x58\x3f\x6c\x64\x27\xb5\xac\xb5\x68\x15\x59\xfe\xf2\x16\x1a\xc6\xbb\xf0\x25\x23\xc7\xcc\x9c\x4b\x9b\x9b\x86\x7c\xf7\xfd\xb0\xf3\xbb\xbc\xd0\x8c\xe5\x3d\x44\x5a\x76\x27\xf9\xea\xaf\x61\x33\xbd\xf6\x79\x78\x40\x9f\x2e\x27\xba\xd3\x07\x56\xd2\x6f\x00\x3e\x04\xf0\x6d\x00\xf8\x5c\x28\x08\x31\xec\xb0\x58\x24\xcb\x6a\x75\x3b\xed\x28\x2f\xcf\xef\x37\x01\x8c\x0e\xd9\x51\x28\x47\x7c\x4e\x59\xce\x83\xb8\x00\x83\x6e\xc9\x55\x19\xac\xfe\x56\xb0\x72\x18\x71\x0b\xf1\x8c\x2b\xaf\xaa\x16\xb8\xf9\x29\x33\xc0\xae\x80\x25\xf5\x29\x9d\x4b\x98\xe9\x22\x49\x1c\x74\xe0\x6b\x6b\x19\xf8\xd5\x37\x0e\xaa\x3a\x78\x1d\x7d\x1e\xe0\xee\xa2\x23\xc1\xc0\xc7\xdb\xd7\xe1\xdb\xff\x1a\xd3\x75\x5d\xb7\x81\x57\xf9\xe9\x0f\x42\x27\x86\x85\x5e\x77\xd5\x1e\x70\x58\x02\x38\xb0\xb3\xe4\x22\x3d\x0b\x05\x89\x6e\x97\x8d\x13\xd5\x9e\x02\x34\x5d\xea\x3d\x02\x37\x9d\xa2\xa2\x5f\x17\x03\x00\x4b\x4e\x7f\x44\xe7\xe3\x51\xc7\xb1\xf2\xfa\x43\x77\xde\xb2\xf9\xba\x35\xe4\xeb\x23\xf4\x57\xf2\x15\xfd\x71\xfd\xa3\x89\x09\xbb\x99\x8c\x15\xc2\x3a\x9d\x60\x1d\x36\xe3\xc2\xad\x10\x33\x3b\xa2\x35\xb3\x23\x5a\x1b\xf8\xb5\x92\x88\xd9\x72\x6a\x92\xbf\xa2\x8c\x2c\xe9\x3b\xc8\x33\x20\x53\xac\x54\x28\xfc\x9e\xf8\x58\x40\x14\x09\xe7\xc2\x53\xbf\x7a\xe8\xaf\x87\xe8\xa9\x87\x5a\xaf\x21\x0b\x82\x05\x36\x81\x1d\x03\x8b\x7c\x0d\x13\xa7\x3d\x3e\xd3\x1a\x49\x07\xab\x3a\xcc\x52\xcb\xd8\x97\xb3\x50\x38\x17\x9e\x8f\x60\x9d\xdf\xf1\xd1\x87\xb0\x04\x8b\x9c\xce\x63\xf3\xbe\xf0\x61\xf2\xae\xf4\x09\x78\x4e\xc0\x8f\x1e\xb7\xdb\x94\x65\x27\x26\xbb\x64\x22\xb9\x39\x1e\x8f\x93\xf5\xbf\xf0\x3b\xf7\xe2\x62\x9e\x46\x52\xde\x22\xb7\x6d\x87\xf2\x80\x59\x60\x99\xbf\x4e\xde\xd5\x80\xcd\xde\xc9\x77\x2b\xc6\x84\x16\x9f\xe0\x38\xff\x8e\xb2\xa3\x78\x43\xff\x7f\x2f\x3f\x7a\x3a\xf1\x33\x1e\x32\x7a\x77\xce\xc2\x91\x2b\xee\xba\x5b\x58\x58\x51\x7c\xd3\x5a\x7a\x47\xe3\x18\x6c\x3b\xf1\x6f\x2c\xd3\x44\xdd\x80\x86\x6d\x8f\x3e\xf2\x77\xae\xc7\x8a\x00\xff\x0b\x39\xfe\x75\x31\x2f\x28\x77\x0b\x1b\x70\xc5\x06\x89\x08\x3a\xf7\xa9\x7c\x53\x51\x26\xf7\xb5\x39\xf4\xe2\x1d\x2b\x79\xbf\x7c\xe1\x56\x3a\xf6\xb5\xd7\xf0\x86\xd7\xf0\x51\xbc\x99\x0e\x87\xfd\x9c\x85\x57\x9c\xce\xe3\x6b\x0d\x85\xd7\x72\x60\x2d\x96\xaf\x82\x58\x1a\x15\xde\xc3\x9e\xcd\x9e\xdc\x92\xaf\x02\xcf\x18\x7a\x90\x6d\x11\xfb\x10\x46\x6e\xfc\x99\xf0\x30\x7c\xc6\x81\xca\x63\x76\xd5\x2e\x12\x62\xd5\xcf\x86\x2d\x56\x06\x18\xcb\xcb\x2c\x37\xb6\x26\xfd\x1a\x35\xd5\x80\x35\x79\x20\x7c\xd1\xdd\xeb\x83\x07\x02\xd3\xbb\xf5\x78\x0e\x2f\x7b\x1c\x7f\xb6\xfc\x8e\xbc\x7b\x9a\x06\x0b\xea\xdf\x12\xf1\xfb\x9f\x60\xeb\x54\xc1\x92\x4f\x73\x3a\x9c\x13\x0b\x62\xb3\xa2\x2a\x2c\xb1\x50\x05\x89\x84\x90\xce\xa6\x28\x12\xc6\xa2\xa9\x2d\x2d\xd8\x26\xb1\x0b\xbe\x3a\x9e\x00\x50\x95\x0c\xe3\x40\xbd\x72\x8a\x30\x45\x2b\x1c\xa4\x8f\xce\x06\x92\x6c\x3b\x4a\x27\x03\xc2\x47\xf1\x6b\x63\xe9\xdd\x40\x97\x1e\xf8\x45\x3a\x3a\xc1\xfa\x47\x94\xe1\xc3\xc2\x71\x69\x0d\xd8\xe4\x10\xcb\x75\x06\x8d\x2e\xf3\xf4\x32\x86\xd8\xa1\x94\x3d\x66\x94\x09\x7b\xcb\x0e\x0a\x02\xb0\xd3\xfe\xd3\x9f\xdf\xc7\x69\xda\x0e\xe0\xfe\x13\xe0\x0e\x00\x6f\x79\x7c\x08\x5c\x6f\x36\x22\x2d\xe0\x06\xf3\xe8\x76\x83\xab\x67\xdf\x8d\xdb\xed\x14\x55\xd5\x07\xb1\x28\xb3\x09\x40\x1e\xdd\x48\xb6\xe6\x2d\xd6\xd8\xd3\x82\x23\x16\xec\x37\x4e\x51\xf3\x70\x4f\xcc\x6c\x53\x5f\x19\xf7\x7b\xf2\x96\x27\xfb\x0b\xf2\x76\x6c\x7b\x5c\x0b\xbb\xf2\x1f\x83\x37\x1e\x15\x46\xce\x3c\xdf\x4f\xff\x4c\x7c\x24\xb4\xc3\xa6\xd0\xa5\xc3\x12\x9b\xc8\x57\x89\x0f\x6b\x96\xf6\x9d\x2e\x54\x1a\xfb\x5d\x00\xb0\x0d\xe5\xba\xb8\x2e\x66\x53\x40\xae\x2c\x36\x51\xb2\x49\x9a\x9d\xa5\x2e\x14\x81\x91\x6a\x07\x6f\x92\xe1\x3b\x53\x4a\xc0\x7a\xf6\x6c\xc5\x5b\xaa\x7e\xa8\x1b\xc5\x60\xb1\x81\xbb\x2e\xa3\xe3\xac\xdb\xbf\xc3\x8f\x58\xb7\x03\x04\x89\xf9\xb5\x89\x5d\xc0\x28\x89\x99\x83\x85\x5e\xc6\x9a\x11\x58\x73\x58\x72\x4d\x9b\x20\xab\xe0\x8d\xc0\xf3\x35\x3b\xe6\x6b\xaa\xb0\x8e\x95\xaf\x29\x9d\x7d\x4d\x46\x69\x8f\x3e\x53\x94\xf5\x0a\xdd\x6e\xc5\x8f\x7c\xb7\xdd\x4a\xc7\x31\xae\x4c\x3c\x37\x78\x26\x21\xa7\xf3\x84\x01\xb5\xf3\x13\x44\xd7\x87\x95\xf8\x73\x72\x42\x3a\xcc\xf3\xe5\x41\x1f\xba\x64\x2b\xe2\xdd\xe9\x54\x26\xd4\x5e\x44\x0c\xa1\xce\xd0\x87\x88\x4b\x30\x62\x13\xc2\xd2\x6a\x8d\xc8\x09\x7a\xfa\xab\x6f\x9a\x51\xf3\xb7\xdf\x60\xfc\xe6\x9d\x37\x2c\xbd\xf3\xae\xeb\x97\xad\x26\xff\xfc\x99\x1e\xc5\x9e\x5f\x7f\xc3\x16\xfa\xc7\x2f\x7f\x7b\x7a\xc7\xc3\x1b\x9f\x7d\x06\xd6\xed\x0b\x46\x31\x2a\x7d\x01\x31\x4e\x27\x34\x3c\x56\x88\x2c\x79\x2e\x51\x23\x11\x55\xd3\x7c\x91\x0e\xd9\x25\x3e\x5f\x76\xb4\xaa\xb8\xd8\xea\xce\xcb\x73\xe5\xe7\x5b\xdb\xc9\x72\xd0\xca\x20\xaa\x44\x41\x1d\xa2\xa4\x87\xca\xd0\x3e\x4b\xaf\x25\x9c\x84\x0c\x3c\xeb\xea\xf4\x6b\xa4\xa4\xcf\xad\x1f\xa1\xb8\x0d\x1c\xe0\x8d\xf8\xae\xba\x6e\x4d\xfd\x07\x36\xce\xb9\xeb\xb1\xc6\x21\xc3\x2e\x79\x69\xc7\xb6\x03\x17\x0d\x6d\x1a\xfc\xd8\x6d\xff\x18\x7b\xe1\xd0\x91\x4f\x8f\x18\x2e\x15\xd5\x75\xee\xd9\xeb\xdc\xc1\x2b\x97\xad\x9a\x3f\xf0\xda\x90\xe0\x9a\x3b\xf9\xa6\x07\x1e\x58\x3e\x61\x91\x8b\x04\xa7\xf7\xbd\x6c\x61\x62\x62\x63\xe3\xb0\xc1\x4f\x0c\xd5\x69\xdb\x09\x88\xde\x17\xf6\x93\xf5\xe1\xa9\x8c\x69\x9a\x24\xb1\xfc\x20\xd9\xe3\x16\x35\x4d\x91\x99\xb7\x63\x47\x8a\xee\xed\x64\x38\x3b\x86\x1d\x04\x63\x13\x61\x07\x4e\x4a\x67\xc3\xec\xf4\xdd\xfb\xb7\x5f\x0e\xe2\xad\x4f\xec\x79\x7d\xc7\xdb\x1f\xc6\x87\x8a\xb7\xdf\xb1\x8b\x6e\x20\x5f\x6d\x5c\xfb\x00\xdd\x3f\x8a\xef\xe5\x51\xf2\x37\xce\x3f\xe0\x4e\xc6\xfc\x60\x09\xb0\xcb\xa6\xba\x40\x29\xda\x41\x1b\xf8\x7d\x82\xcb\x65\x78\x59\xce\x33\x7b\x59\xce\xe4\x49\x13\xeb\xf0\x14\xd1\x57\x67\x64\x63\x23\xc2\x78\xf4\x28\xbc\xf0\xc5\x8f\x07\xf1\x97\x4f\xee\xbe\xea\x62\x4c\x4e\x6e\xa3\xe0\x2f\xc4\x9b\x40\x2d\xcc\xa1\xcb\xc8\x57\x6b\x6e\x9d\x7c\x4f\x16\x1d\x27\x3c\x75\x2b\xfd\x74\x28\xe3\xe7\xb0\xc1\xcf\xcc\xbf\x06\x5d\xc2\x5a\x4f\x99\x54\x01\x84\x7a\x07\x12\x45\x49\x97\x69\x67\xb4\x67\x5a\x62\xaf\x3e\xd8\x49\xc8\x3b\x48\xdf\x20\x9d\xa5\x76\xa7\x9f\x27\xb1\x87\x1e\xe2\xb2\x11\x02\x7e\x19\x0f\xcf\xe2\x56\x5b\x26\x56\x4d\x23\x60\xb5\xc5\xa4\x19\xd5\xf5\x68\x3a\x97\x16\x70\xa1\xd3\xf7\x9f\x7d\x23\xe3\x1d\xaf\xbe\x77\xf0\xea\x09\x53\x67\x1c\xfc\x0a\x7f\x76\x60\xaf\x30\x35\xf1\xb7\x05\x33\x16\xcf\x12\x86\x27\xd6\xed\x7b\x87\xd7\x5d\x9c\xc2\x47\xa5\x2c\x58\x23\x0b\xbc\x53\xb3\xdf\x96\x65\xce\xca\x36\x87\x82\xe6\xbd\x5c\xe2\x1c\xb8\x68\xa7\xdf\x66\xc3\xea\x6e\xae\x41\xb9\x2e\xea\xd9\xe2\xc6\xb0\x2b\x72\x02\x0c\xa5\xb1\xf6\xc2\x51\x37\x9b\x7a\x14\x75\xe7\x12\x6f\xad\x3b\x2a\x46\x7e\x59\xa2\xe6\x39\xb2\x96\xfc\x72\xe2\x8d\x6b\xab\x48\x87\x05\xff\x9c\xa3\x38\xed\xe6\xea\x99\x6f\x80\x1e\xe8\x51\xbc\xc9\x34\xf4\xba\xc4\x8b\x20\x9d\x1f\xff\xe1\xfa\x52\x28\x4f\xfc\x5a\x30\xa2\xb1\x9b\xf4\x87\x50\xc6\x79\xc8\x03\xfa\xf5\xa4\xf8\x07\x97\x93\xf3\x63\xa1\x90\xaf\x50\x29\x29\xf1\xd9\xb5\x72\x42\x34\x1f\x89\x56\x15\x16\x15\xb9\x4a\x65\xd9\x6e\x71\xed\xc6\xa5\x4f\x07\x43\x15\x15\x61\x43\xfb\x82\x42\x67\xea\x32\x19\xc9\xb5\xe9\x87\xec\xe6\x52\xd0\x13\x67\xde\xb5\xea\x7d\xa5\xbd\xba\x93\x1f\x91\xdd\x10\xee\x19\x42\x74\x62\xca\xb5\xb7\xdf\xfe\x60\x97\xce\x35\x9d\xe4\x03\xae\x87\x6e\xba\x69\xad\xaf\xd8\xe3\x73\x86\x42\x79\x9e\x7e\xe7\x2a\x62\x63\xf7\x8b\xe2\x3d\x3b\x96\xf6\x1d\x8d\x0f\xcf\x9e\x36\x73\x01\x21\x25\x4d\xbd\xaa\xea\xcd\x57\x5d\xbd\xf2\x46\x7a\xb4\xa6\xab\x74\x05\xf8\xf9\xa4\x7f\xbf\x7b\xf0\x55\x02\xa9\xeb\x56\x53\x3d\xad\x01\xb5\xc1\x6f\x48\x2c\x9f\x21\x16\xf2\x16\x96\x28\x8a\xd7\x4b\x34\xc0\xaf\xa8\xb0\x30\x0c\x18\xbb\xc2\x15\xa1\x10\x0a\x86\x01\xc9\xed\x1c\x57\xa6\x04\x18\x7a\x3a\xf9\x5b\xe1\x98\xe6\x75\x64\x64\x72\xf8\xf5\x78\x5b\x1f\xa1\x52\xdd\x83\xf0\xce\x4a\x35\xa4\x36\x35\x30\x50\x08\x70\x24\x3b\x77\xf9\x7f\x90\x14\xff\x30\x90\x1c\x7c\xae\x81\x24\xf6\xa5\x21\x49\x6f\x4b\x43\x92\xc9\xe5\x61\xe1\x67\xc0\x31\x00\x5e\xf3\xb9\x31\x37\xb2\x05\x83\x4a\xae\x5b\x71\x17\x46\xc0\xeb\x67\x43\x41\x09\xe8\xf7\x12\x64\x06\xc6\xca\x46\x3e\x5c\x8a\xf2\x81\xdb\x74\xbd\xdb\xb3\xa7\xab\x75\x18\xae\xb7\xf5\xa9\xa9\x8d\xca\xb0\x59\xfe\x08\xf0\x5c\x24\x55\xfc\xe9\xe7\xca\x8c\xcf\x85\x13\xca\x4d\xe2\xd3\x92\xfc\x77\xa2\x90\x1e\x4f\x2e\xba\x65\xf5\x4d\x1b\xba\x91\xc6\xf3\xef\xbd\x67\xe0\x05\xe2\x15\xce\xb1\x6a\xb7\x99\x74\x74\xf6\xcd\xca\xa8\xac\x15\x6f\x3f\xbb\xe7\xfd\x65\xb4\x79\xfe\x52\x7a\x92\x26\x6e\x66\x71\x48\x18\x1f\x16\x6f\xe7\x7b\x52\x85\xea\xd0\xec\x58\x65\x40\xb0\xd4\xb0\x1c\x1d\x96\x9a\x53\x6e\xb5\xe6\xd5\xd4\xe6\x76\x54\x72\x6b\x14\xd2\xb5\x5e\x10\xb2\x02\x81\xac\xda\x5c\x08\x4f\xca\xcb\xb3\x0a\x4b\x0a\x0a\x58\xcd\x7b\xe9\x2e\x97\x4f\x8b\x46\x7d\x59\xc6\x46\x31\xb0\x39\x47\x56\x39\xd3\x4e\x16\xce\x34\x33\xa6\x25\x29\x40\xbf\xc1\x69\xbb\x7f\xbc\xd4\xb5\x3b\xd6\x6f\x73\x4a\x6a\x24\xd6\x4f\xa2\x07\x69\xc9\xc3\xc1\x53\xde\x1b\x36\xe2\x85\x2b\xe6\xdd\x7b\xc7\xc6\x2e\x5d\xeb\xaa\xa5\x03\xae\x8d\x37\xdf\x39\x38\xbe\xea\xc1\x47\xf0\x3f\x2e\xe8\x3b\x29\x6b\xe7\x20\xe1\xf8\x79\x17\xdf\xd0\xb3\x43\xa0\x73\xe2\x83\xd8\x00\x91\x7e\x2d\x0f\x14\xff\xd8\xb0\x61\xf6\xb4\x6b\xe6\x0b\x6c\x47\x3b\x77\x31\x4f\x9f\x31\x68\xd0\xe1\x77\xed\x53\xa6\x8d\x72\xbc\xb3\x62\xe6\x90\x7c\x62\x0a\x55\x16\xd5\x54\x27\x7e\x1b\x35\x76\xcc\x68\xbe\xa7\x51\xf0\xed\x7e\x07\x0f\xce\x0b\x9b\x75\x1e\xf3\x5e\x64\x2d\x3b\xdb\x8a\xac\x05\x61\x45\x71\x3b\x1d\x0e\xb3\xdb\x06\x9b\x1a\xe1\x9b\x1a\x04\x4f\xb0\x14\xe5\xa5\x8c\xa9\x3e\x68\xb8\xb5\xdd\xd2\x63\x1f\x26\x75\x1e\x25\xc2\x75\x96\x12\x6d\x55\xcf\x2b\xfc\xbe\x7a\x79\xe3\x8c\x1c\x41\xdd\x23\x3f\x47\x48\xaf\xcd\x8b\x57\x1d\x18\x70\xfe\xf9\x43\x60\x5b\xc9\x94\xbd\xef\xf7\xeb\x35\xb8\xc3\xc0\x8b\xc9\xa5\xf4\xb3\xf9\x77\x1c\x7a\x76\xc9\x82\xa5\xd7\xcd\xbb\xd1\xb0\x43\x9f\x09\xbf\x72\x58\xf3\x18\xff\x11\x87\xcf\xe7\x0e\x41\xa0\x1b\xce\xd7\x34\x2b\x04\xc1\x56\x27\x07\x15\x71\x50\xad\x00\x6a\x0e\x78\x19\x29\x50\xcf\xc8\x7f\x99\x5c\x17\x2d\x61\x1a\xd6\x4f\x5a\x98\xaf\x26\x8d\xed\x04\xe1\x39\xf9\xc5\x86\xc1\x8c\xf5\xf0\x51\xe0\xb8\x9b\xdf\x7e\x76\xef\xbb\xcb\x16\x62\xdf\xe9\xdb\x7c\xb7\xe1\x25\x73\x6f\xa4\xa7\xe8\xe9\x95\x00\x67\x47\x90\x93\x77\x81\xef\x58\x7c\x39\x30\x56\xe0\x70\x3a\xcd\x3e\x8b\x85\xf8\xcd\x66\x12\xca\xb2\x58\x58\x32\xc0\x29\x9f\x90\xe3\xeb\xe0\xeb\xee\x23\x80\x83\xcc\xb4\x81\xc3\x9e\xd4\x77\x3c\xc4\x19\x33\x3d\xda\xea\x24\x50\xb7\x05\xfc\x90\x2a\x07\xeb\x23\x57\xfc\xb2\x31\x78\x07\x2f\x7f\xe4\xa9\x9d\x8f\x3c\xf8\x08\x2d\x3d\x7f\xd0\xc4\xd0\xce\x41\xc7\x7a\x0f\x10\x70\xae\x3c\x10\x1f\x3e\xf4\xd2\xb3\x6f\x1e\x7e\x57\xbe\xfc\x1a\xe0\x00\xe1\xbe\xf1\x71\xbe\xed\xad\x60\xac\x8b\x79\x00\x46\xbf\xd9\xe2\xf3\x11\x62\x0e\x65\x01\xa0\x32\x80\xb3\x17\x28\xe8\x4e\x52\xb0\xaa\xca\x99\x69\x61\xd3\xf4\x52\x06\x1f\xbb\x0d\xee\x9d\xa3\x43\x84\xff\x61\x40\x94\xe2\xd0\x74\x88\x12\x13\x75\x46\xc4\xa8\x0b\xc0\xb3\x96\xcb\x6a\xcf\x98\x2f\x4b\x76\x98\x0b\xd9\xe4\x8a\x22\x00\x25\x97\x14\x91\xd2\x12\xa7\xc7\xc6\xa8\x54\x18\x6e\xa1\x52\xb4\x55\x0a\x4e\x52\xde\x32\xbc\x22\xd0\x8c\xa9\xf0\x8c\xf7\x69\x30\x24\x50\xc6\x57\xde\xfe\xf0\xc5\x4d\x83\x1b\xef\x9e\xbb\xe0\x7e\xe7\x43\x52\xac\x4b\xa7\xea\x51\x13\xaf\x1c\xd9\xbd\xa6\x72\x80\x6d\x63\x3d\x3e\x7c\xf5\xe5\x03\x2f\xb5\x10\x6d\x64\xef\x91\x33\xaf\x9c\xac\x55\xd6\x54\xb6\xab\x89\xce\xaf\xe9\xda\xa1\x4b\xb7\x2e\x79\x9f\xea\xe7\x78\x35\x00\xf3\xbd\x00\x73\x11\x83\x39\xcf\x96\xe3\x27\x82\xcf\xef\x17\x1c\x39\x39\x6a\x24\x22\x94\x14\xfb\xdc\x59\x0c\x66\x22\xff\x0f\x30\xff\xd7\xbc\xa1\x64\xda\xd0\x45\xc7\xea\x37\xda\x06\x54\xd6\x74\x8f\x4f\x9b\x1c\xaf\xee\xd4\x25\x26\x3d\xe4\xba\x6f\xc1\xbc\xbb\x1e\x1d\x7a\xf9\xc3\xf8\xf0\xa7\x79\x00\x5b\x87\xfa\xda\xf9\xd1\x9a\x76\x95\xd5\x1d\xb5\xc9\x57\x4e\x1b\xb1\xaa\x18\xab\x13\x07\x5c\x3e\x57\x97\x1f\xb4\x9b\xeb\xef\x7c\xd4\x0e\x6c\xb0\x57\x24\xc5\xae\x70\xc0\x6a\xcd\xcd\x75\xb5\x2f\x0f\x04\x42\x56\x9b\x4d\x0b\xed\x07\x05\x5e\x88\xbc\xb0\xf5\xa5\x48\xc3\xed\xb6\x8b\x0a\x00\xdf\x5e\x07\xbe\xc5\x5d\xcd\xf4\x53\x3b\x75\x2c\x4a\x1d\x50\x77\xc7\xb5\xe9\x02\xc5\xf4\xbb\x02\x4e\x0b\x17\x29\xdd\x37\x5d\xb5\x7c\x83\xe7\x39\xcb\x39\x35\x83\x07\x0a\x42\x8f\x2d\x4b\x56\xde\x71\xd3\x43\xdd\x45\x49\x7c\x5a\xdc\x25\x0f\x19\xb8\xe6\xde\x41\x43\x76\x5f\x7e\x91\xbf\xa2\xf3\xc5\x93\x4b\x07\xae\x7c\x6d\xcf\xbe\x83\x37\x39\xc7\xab\xdb\x12\x87\x36\xfd\x4d\xd8\x33\x7b\x09\xfd\x73\x89\xe1\x93\xa2\xb7\xd1\x6f\xe2\xb7\x3c\xff\xa9\x38\x66\xd5\xf3\x9f\x54\x13\x11\x64\x65\x0f\xa0\x20\xf3\x80\xd6\xf1\x6a\x55\x7a\x31\xa6\x37\x52\xed\x06\xd7\xec\xb7\xe7\x9e\x7b\x0e\x4f\x58\xbd\x9a\x5c\x9f\x90\x85\x93\xb0\x8f\xc5\xe0\xbf\xbc\x09\x7a\xc5\x82\xfa\xc4\xfc\x10\x77\x9a\x58\x1a\x1a\x04\x9c\x6c\xcc\xb4\xd5\xc6\x22\x70\x93\xb4\x0f\x14\x8b\x09\x1e\x9c\x8a\x3c\x0d\xdd\x97\x9a\x93\xd9\x72\x4d\x81\x49\x4b\xe0\x89\x4f\xbf\xd2\x04\xab\xc9\x6f\xd1\x04\xf6\x81\x83\x19\xef\x4a\xbf\x16\x7d\x89\xc7\x70\x37\xfa\x11\xad\x84\xb5\x3b\xe2\xa3\xe2\x30\xd8\x93\x42\xd4\x3f\xe6\x2b\x44\x76\x45\x31\xe5\x64\x9b\x50\x36\x29\x2e\xf2\x6a\x1e\x62\xb7\x9b\x2c\xbb\x71\xc9\x76\x94\x63\x62\x41\x64\x3e\x21\x01\xe6\x20\xa5\x82\x48\xb6\x21\xfe\x36\xc9\xf8\xce\xce\xbc\x5c\x13\x42\xa7\x92\xa8\xcf\x1b\x65\x5c\xe4\x8f\x1a\x7e\x51\x84\xff\x52\x71\xe2\x23\xd3\xba\xf6\x7b\x4e\x7e\x46\x15\x22\x53\xfa\x3f\x5a\x24\x16\x5c\x36\x74\xea\x55\xfb\xaf\xea\xd2\x4f\x00\x30\x9f\x38\x38\xf7\x22\x3a\x59\x68\x9c\x55\xd3\xaf\x71\xc4\xe0\x4d\x17\x5c\x70\xef\x2a\x9a\x0d\xaf\xce\x98\x40\xc7\xea\xbc\x5f\x8a\xf6\x0b\x07\xc5\xe3\xa0\x89\xfb\xc4\x5c\x42\x0e\xbb\xdd\xd0\x94\x9c\x1c\x2d\x9c\xef\xf3\x7a\x35\xd7\x3e\x20\x15\xb0\x0f\x84\x0c\x41\x26\x01\xcc\x96\x96\x19\x4c\xd4\x3a\x46\xe0\x59\x85\x45\x05\x25\xd5\x7e\xe6\xe1\xb6\x85\x9c\xf9\x72\xb2\x20\x9f\xd3\x29\x52\x15\xb9\xbe\xcf\xf0\xe7\xe4\x5d\x2a\x29\x99\x35\x64\xd6\x82\x49\xfb\x95\x15\xa4\xb2\x0f\xfe\xe8\xe0\x9c\x8b\x53\xc0\x36\xdc\x7d\x5b\xe2\xc5\x49\x57\x18\xf6\xe2\x30\xf1\x01\x6d\x59\xbe\x0e\x78\xdb\x4e\x1e\x13\xfa\x7d\x2c\x26\x2c\x45\x9e\x33\xc7\x84\xad\xfa\x4f\x70\x37\x92\xf8\x5e\x79\xea\xf1\x97\x5f\xd9\xba\x63\xff\x81\xe1\x4d\x5b\x86\x0e\x79\x8a\x5c\xfa\xf7\x0f\x3e\xdc\xbd\xfb\xfd\xd7\x5f\x58\x3e\x97\xd2\x05\xac\x96\xa5\x02\x74\xc1\x87\xb0\x96\x0f\xd5\xb2\x5a\x16\xf0\x86\x88\xea\xf1\x90\x00\xb8\xda\xec\xa0\xc4\xc9\x96\x54\xd2\x0f\x4a\xda\xa6\x2d\x25\x65\xc8\xe9\x48\xbf\x40\xc1\xd7\x2e\xdb\xe1\x78\xde\x34\xa0\xe6\x9e\x3b\x67\x3a\x5f\x70\x6f\x5e\xba\x69\xcf\x33\xf8\xf0\xea\xb9\xe6\xf3\xce\xc3\x26\xd4\x7c\x9d\x79\xd6\xcd\xef\x3c\xbf\xf7\x10\x3f\x3f\x21\x97\x10\xbf\xf8\x0b\x04\xd7\xe1\x98\xb5\x25\xaf\xc1\x4c\x74\x8e\xc9\x4c\x69\xd0\x6f\x3b\x22\x1c\xc9\xaa\x97\xb7\xe9\xb8\x91\x4b\x76\xbf\xf7\xfa\xf3\x0c\x29\xfd\x3c\xe6\x30\xf1\x93\x89\xfa\xf3\x5a\xf2\x18\x04\x55\xf7\x86\x5a\xa5\x48\x30\xed\x15\xd5\xe9\x77\x72\x4b\xd3\xf0\x03\xfb\x77\x3c\xf5\x12\x99\x48\xe9\xdc\xe5\xcf\xbf\xfe\xde\x6e\x6e\x73\x80\x67\x7e\x01\x9e\x31\xec\xb7\x23\xa4\xaa\x66\x1f\x42\x66\x36\xd6\xdc\xc6\xe6\x00\xd9\x0c\xff\xb1\x0c\x5c\x4c\xe6\x6a\xe4\xa6\xb9\x1a\x67\xf6\x1f\x0d\x4f\xc3\x9f\xe2\x18\xbe\x73\x8e\x94\xa3\xf1\xcb\x9d\x37\x82\xa3\x21\x8a\xcf\xc9\x7b\x4c\x24\xf6\xf8\x92\x95\x07\x40\xc1\x34\x0e\x5a\x43\xa6\xec\x7b\xaf\x5f\x6c\x31\xfd\x8c\xcc\x9e\x30\xb8\x74\xe8\xca\xb7\xf7\x62\xbc\x72\xee\xfc\x1b\x39\x6f\xab\xf8\x73\xfc\x8c\x74\x0f\x18\xbf\xae\x31\xaf\xd3\xa2\xda\x44\x9b\x2c\x58\x04\xaf\xc7\xe9\x44\x8a\x55\xe4\xe7\x71\x25\x2c\x5b\xd1\xd8\x4d\x80\xc5\x68\x05\x59\x57\x97\xcc\x37\x66\xfb\xc9\x0e\xbe\xa2\xb5\x51\x96\x1c\xcb\x06\xc8\xd4\x7a\x65\xec\xdb\x36\x66\x72\xb7\xd9\x2b\x57\x0e\xf5\x96\xf7\xc5\x9f\x3f\x87\x5f\xbc\x71\xc7\x8e\x1b\xe9\xcc\xa9\xe6\xb9\x01\x43\xae\xc0\xc7\x39\x08\x7a\xcd\x8b\x6a\x62\x0e\xbb\x2c\xb3\x5b\x78\x8f\x1f\x02\x25\xcd\xaa\x78\x99\x54\x59\x41\xaa\x08\x72\xea\x74\x69\x13\xf7\xb2\x83\x13\x4f\x32\x54\xf4\x47\x8a\x0d\xef\xc6\x79\x24\x29\x39\xfd\x1e\x9e\xb9\x50\xfc\x96\x0e\x03\x99\xc1\xf7\x26\xb6\xcd\xac\xe9\xd7\xf0\xf0\x9d\xb7\xe1\x6f\xf5\x73\xac\x66\x12\x14\x77\x03\x0f\xb7\x8f\xb9\xed\xc4\xea\x52\x10\x61\x59\xeb\x7e\xe4\x03\xbd\x64\x31\xe9\x3d\x19\x2a\xdb\xde\x6f\x57\x55\xeb\x95\x26\x0c\xc5\xd4\x0d\x72\x3b\xfc\xc0\x8b\xb3\xc6\xd1\x59\x42\xb7\x2b\x6b\xfa\x0d\x18\x36\xe8\xb6\x15\xb4\xbd\xf0\xf2\xf2\xf3\xe2\xaf\xca\xfb\x54\x52\x3a\x67\xe8\x9c\x25\x5c\xff\x1d\x06\xfd\xf7\x2d\xe8\xbf\x7e\xb1\x00\xc7\x37\x92\x1b\x0a\x45\x54\xd0\x7f\x9a\xdd\x43\xbc\x5e\x6b\xa1\x92\xbd\x47\xc7\x7b\x27\xc9\xcf\x77\x05\x52\xae\xb8\x71\xd3\x74\x06\xf5\x97\x49\x01\xee\x6c\x47\x8c\x90\x29\x6a\x8c\xf2\x11\xd6\x4d\xab\x1b\x90\xa6\xfe\x8a\x2e\x1b\x62\xa8\x3f\xa0\xce\x50\x46\x9d\x35\x89\x6d\x86\xfa\x1b\x31\xf8\xde\x55\x98\xbd\x3a\x63\x02\xde\x00\xf1\xf5\x9f\x60\x2f\x8e\x01\xcc\x2a\x8a\xc4\x54\x49\x15\x54\x8b\x60\x36\x09\x8c\x27\x58\xae\xb2\x71\xf0\x8e\x93\xaa\x0d\x47\xb0\x11\x47\xe3\x6f\xbe\xa5\x7f\x1d\x5c\xdc\x51\x72\x3f\x74\x00\x1e\x71\x92\x0e\xdf\xe6\xeb\xc5\x7a\xfa\x00\x1d\x2c\x20\x6b\xbd\xb8\x2f\xd1\x37\xe6\xc9\xb2\x3a\x7c\x56\x92\x2f\xe7\xcb\x25\xc5\x08\xb9\xb3\xac\x56\xd1\x0d\x32\x1c\x53\xf3\xc0\x16\xe5\xa8\x6a\x81\x98\x16\x8f\x38\x5b\x59\x65\x97\x71\x08\x61\x5c\x70\x82\x14\xb0\xeb\xcd\xd4\xb0\x74\x88\x42\xfc\xba\xef\xc8\x24\x07\x6f\xca\x2e\xbe\xac\x7a\xd2\xb0\xf2\x58\x97\xda\x92\xa2\x81\x55\x45\x6b\x16\x2e\x5c\x53\x54\x35\xb0\xa8\xa4\xb6\x7b\xd7\xf2\xa1\x93\xab\x2f\x2b\x16\xe6\x57\x74\xaf\x89\xae\x89\xd6\x77\x1e\xdf\x7d\x6c\x87\x4b\x17\x2f\xbe\xb4\xc3\xe8\x9e\xe3\x3b\xd7\xc3\x4b\x35\xdd\xb9\x9e\xad\x01\xb9\xfe\x4b\x6a\x06\x9e\x2d\x03\xb9\xf6\xb9\xf3\x7c\x11\x90\x14\x1f\x48\x77\x36\x48\x77\x79\x3b\x59\x26\x76\xf3\x7e\x90\xea\x62\x64\xc7\x05\xe0\x70\xa6\xa4\xda\xe9\x3a\xf3\x85\x37\x97\xeb\x92\x08\x38\xba\x11\x67\x72\xc8\x7b\x2e\x96\x5a\x5c\xa4\x96\x48\xf7\xaf\x0d\xab\x67\x8e\x94\xa5\xe7\x1f\x7b\xec\xce\x35\xf7\x5c\x7a\x75\x22\x91\x3b\xaa\xe3\xe0\x21\xd3\xaf\xba\xf0\xfc\xae\x3d\x07\x9c\x47\x94\x55\x0f\xf6\x3e\x67\xe0\xbb\xa4\xf9\xd1\xb5\x8b\x67\x6d\xeb\xe9\xbd\xfd\xe3\x40\x64\x5c\xe3\xf0\x71\x2b\x1c\x8d\x7d\xa3\x7d\x47\x5f\xc5\xce\x4b\xfe\x02\xf8\x8f\xc3\x7e\x3a\x50\xbb\x98\x1d\x34\xb7\xc3\x6c\x76\x21\xa7\x24\xd9\x55\xc4\x38\xcf\xce\x4c\x57\xcf\x2a\xe3\x98\x19\x08\xcd\xe9\x4b\xa2\x6e\x56\xeb\x26\xc0\xb6\xca\x10\xe7\xd4\x2a\xaf\xdf\x66\x0e\x0a\xc4\xae\xdd\xf9\x1a\x3d\x1e\xf3\xbc\x12\x6c\x0f\x8c\xd4\x3d\x6f\x66\xbe\xbf\x57\x1d\xfe\x2e\x51\xfe\xe4\xc6\x47\x58\x6c\xc0\x74\xaa\x19\x68\xa5\xf2\xc9\x1f\x01\x3f\x09\x11\x2d\x10\x90\xbc\x48\xd3\xbc\x39\xd9\xc4\xef\x77\x05\xcd\x16\x4b\x70\x2f\xd0\xc9\x84\x5c\x49\x0b\x15\x75\x66\xc8\x79\xb2\x7b\x79\xe7\xe2\x12\x5d\xcf\x91\x12\x7f\xea\x44\xd0\x51\x54\xc2\xce\x9e\xce\xed\x75\xde\xab\x43\xcf\x7f\x72\xe4\x25\x9f\x35\x8c\x78\xed\x91\x27\x9f\xc5\xdd\x3e\x10\xfa\x90\x58\xc3\xaa\x01\x83\xbe\x98\x34\x9d\x78\xa4\xb7\x06\x3e\x35\x7b\xfd\x8b\x7b\x37\x61\xfb\x55\x5f\x4c\xbe\x91\xed\x63\x15\x7a\x96\x6c\x06\x1e\x0c\x82\x87\xd8\x2f\xe6\xb6\x21\x35\x4f\x14\xdd\x92\x43\xcd\x42\xaa\x84\x48\x41\xd8\xba\x0f\x94\xb2\x04\xe4\xc8\x46\x7e\x5c\xba\x33\xcf\xed\x26\x72\x8b\x38\xea\x87\xb8\xfe\x8c\x74\x2a\xbe\x95\xcc\x1d\xd2\x13\xfc\xfc\xfc\x14\xc6\xaf\xef\x29\x53\xd3\x5e\x67\x0d\xd9\xbc\x7f\xfb\x86\x6d\xbb\x56\x3f\xa8\xf5\xec\x3b\xaa\xf1\x9a\x45\xd7\x3d\xb0\x77\xc2\xd0\xa7\xc9\x35\x2f\xbc\xab\xd2\xaf\x70\x8e\x7a\xf0\xd9\xad\x2f\x64\x2f\x74\xac\x9a\x7e\xfd\x12\x09\xcf\x59\x79\xdb\x9b\x5b\x31\xfa\x1b\x5d\x6e\xd6\x7b\x8c\x9c\x44\xfb\x89\x15\x6c\x4a\x08\xf5\x88\xb9\xdd\xa2\xcd\x24\x2a\x6a\x96\x9a\xe3\xca\x16\x45\xd9\x66\x73\xc9\x4c\x2a\xcd\x40\xc8\xb2\xed\x41\x3f\xe2\x76\x90\x3b\x21\x2d\xd7\x06\xec\xc2\x80\x11\xd3\xcd\x5a\x24\xf4\xc4\x51\x82\x23\xa4\x12\xdb\x05\x12\xc1\x15\x02\x8f\x68\x6e\xeb\x79\xe1\x64\x73\xe9\x65\xaf\x37\xe3\xe0\x9b\x4b\x83\x01\x31\xe2\x5c\xf9\x26\x8e\xce\x6a\x57\x1c\xcc\x0e\x85\xea\xc5\xe3\x0d\x5f\xb4\xbb\xe8\x3b\x9a\x95\x78\x1e\x77\xea\xdd\x47\x1b\x15\xa1\x1f\x09\xfd\xff\xd3\x37\xcf\x72\xa3\xaf\xb9\x19\x75\x6a\xbe\x16\xfd\x46\x56\x39\x14\x52\x82\x6e\x4f\xdc\xc2\xef\xd7\x2b\x9a\xaf\x05\x6f\x61\x31\xbc\x56\x81\x91\xf1\x5a\x69\xf3\x14\xe1\xa0\x30\xc3\xa1\x48\xd7\x22\xe3\xb5\xe6\x3f\x9b\xaf\x15\x8e\xf1\xd7\xe6\xe9\xaf\xc1\x1e\x75\xa0\x8d\xc2\x6f\xe4\x76\x2e\x6b\xf5\xb1\x2c\x77\x9e\xd3\xc7\x04\x0d\x04\xce\x90\x35\x42\x82\x41\xbb\xb9\xd8\x0e\xca\xba\x92\x31\x8d\xe3\xe5\x33\x55\x2a\x14\xfd\xef\x02\xf6\xdb\x7f\x15\xb0\x35\xff\x9f\x7c\x01\x1e\x7f\xd1\x41\xc2\x71\x8e\xc7\xc2\x14\x1e\x9d\xe8\x95\xc4\x21\xcc\x83\x7d\x2b\x46\x55\x31\x9f\xdd\x66\x43\x72\x41\x81\x0f\x90\xf0\x95\x7a\x65\x52\x54\x14\xb4\xe7\x05\x93\x38\xbc\x92\xe6\x68\xe8\x58\x18\x86\x3f\x57\x60\x01\x5e\xa4\x33\x8b\xf0\x92\x2a\x2e\xed\x9c\x81\x38\xfe\xbe\xbe\xff\x35\xb9\x6a\x8f\xd9\x8b\x67\x5f\xad\x3c\x96\x7b\x5e\xf4\x8e\x1d\x4d\x2f\x3c\xf1\xf4\xbe\xd7\x86\x0c\x1f\x16\x1f\x3a\x64\x1b\x36\x3d\xfe\x46\xe7\x76\x8d\x0d\x05\x17\x4e\x71\x6b\xf2\x65\x47\xff\x7d\xe0\xa3\x7d\xbb\x66\x5f\x7d\xc5\xc2\x6b\x16\xc0\x9e\x54\xd1\xf3\xc9\x66\xe1\x06\x80\xfb\x3a\x80\xfb\x76\x3d\x0f\x88\x0e\x22\x56\x61\x09\xbc\xb6\x38\x85\xcb\xa2\xe6\x9f\x14\xb3\x38\x18\xa4\xa6\x04\x5d\x19\xab\xb3\x15\x7a\x3c\xe6\x60\x56\x96\x1b\xd0\x70\x13\xb3\x9b\x94\x95\xda\x6c\x62\x30\x28\xe6\xe5\xe5\x88\x85\x9e\xa6\x78\x61\x61\x8e\x45\xd4\xb4\x70\x53\x5c\x73\x20\x13\xeb\xe1\x9d\xe3\x1f\x12\xcf\x69\xd5\x5f\x3d\x9a\xd9\x2e\xbe\x4d\xb9\x57\xb2\x37\x79\x75\xaa\x69\xbc\xb7\x26\x73\x2a\x2f\x3b\x63\xc2\xc6\x40\xd6\x11\x3f\xfe\x82\x83\xcf\x3f\x8f\x83\x57\xdd\x9c\x31\x94\xf7\xf0\x9c\x6b\xf0\xeb\xc9\xc9\xbc\x6f\x7c\x20\x6c\x4d\x3c\x44\xbf\xc1\x39\xc2\xb8\xba\xf3\xd3\x06\xf3\x2e\x5b\x96\x1a\xcd\x8b\x84\xe6\xed\xcd\x3f\x89\xb7\x4a\x6f\xa2\x0e\xa8\x0b\x9a\x12\xab\xa9\x30\x97\xb5\x2b\x74\x90\xce\x9d\xfd\xd9\x39\x39\x11\xbf\xbf\x9d\x99\xd4\xd7\x15\xe7\x08\x65\xc1\xb0\x00\x5f\x11\x2c\x89\x4e\xf8\x52\xbc\x5e\x5b\x6d\x43\xdc\xe6\x53\x3a\x35\xc4\x15\x47\x7a\x7f\x6a\x9e\x35\xd7\x53\xff\x47\x57\x6f\x19\x29\x46\x29\x87\xaa\xc4\xcb\x8f\x92\x5c\x4e\x87\xa0\x1f\x30\x01\x6e\x60\xe8\x4b\x00\xc7\x48\x0f\x21\xea\x07\xbd\x07\x41\x44\x6d\xd4\x2e\xe0\x16\x26\xc0\xfb\x1c\x92\x28\x8e\x3b\xf5\xfc\xa1\x8f\x5f\x9b\xf9\x58\xb9\xa0\x4a\xf4\x57\x93\x5a\x54\x66\x9e\x6f\x2a\x1f\xda\xc7\x85\x83\xd6\xf6\x85\xea\x5c\xa9\xfd\x50\x7c\xe9\x15\xd3\x67\xcc\x9e\x35\xe3\x4b\x71\x0e\x1e\xb4\xed\x1d\xfa\x39\x3d\x41\x8f\xd3\x8f\x27\x8e\x89\xcc\x75\x8e\x59\x4b\x7e\xc3\x95\xb1\x49\x93\xbb\xe2\x41\xbb\x71\x7d\xe7\x8b\x2e\xeb\x9e\x78\x74\xf7\xf6\xe7\x76\x3e\xf1\xbc\x1e\x8f\xb2\x3e\xc8\x9d\x0d\x9a\x5c\x11\xab\x8d\xf8\xd5\x8a\x0a\x52\xd6\xae\x5d\x21\xc9\xce\xe9\xac\x69\x39\x24\x83\x26\xae\x08\x06\xd7\xd7\xec\x93\x5d\x2e\x20\x86\xcb\x61\xad\x69\x88\x5b\x7d\xbc\x80\x20\x55\x5f\xc3\xb2\xc3\xa3\x49\xe2\xa4\x51\x25\xed\x90\x31\xaa\x53\x05\xfc\x9c\xb0\x71\x90\xd5\xd2\x67\xbf\xfa\xec\x54\xe1\x9d\xf7\xa7\x38\x25\x13\xfd\x4d\x56\xc5\x51\xcd\xfb\xde\x32\xba\xee\x9b\x92\x54\x71\xe2\xa0\xcd\xa0\x0a\xbd\xcd\xe8\xc3\x0f\x54\x39\x3d\xe3\x92\xe5\xde\x85\x39\x2f\x63\xe0\x1d\xa3\x0b\xff\xa6\xd6\x54\xd9\x9c\xea\xc9\xdf\xfc\x1d\x10\x66\x0f\xd0\xa4\x1c\xdd\x13\xcb\x8f\x94\x4b\xb2\x5c\x86\xad\x2e\xb7\x3b\x2b\x90\x0d\x71\xb5\xad\x43\x7b\x49\x0a\xb9\xdd\x21\xbf\xdf\x16\x0a\xd8\x77\x63\x6d\x7b\x3c\xc0\xb3\x75\xad\xf1\x40\x20\x84\xb1\x2d\x64\xb6\x08\x16\xf6\x42\x30\x2e\x08\x21\x9b\x37\x3f\xd2\x10\xcf\x2f\x1a\x12\xcf\xc7\x28\x2b\x94\xd5\x10\x2f\x0b\x69\xa9\x4c\xaf\xf2\x54\xaa\x73\x4b\x95\x64\x79\x6b\xf1\x01\xea\xf9\x53\x2c\xa5\x77\xc1\x36\x28\x13\x29\x01\x29\x4a\x51\x8c\xf9\xed\xfa\x01\x86\x57\xef\xf3\x1b\xf5\xe2\x4f\xec\x06\x41\xce\xf5\xd3\x1f\x5a\x08\xb5\x6e\xdd\xfd\x0f\x36\x5c\x5c\x56\xd6\xaf\xeb\x87\x64\x3e\xbd\x56\x27\x82\x40\x1f\xc6\x07\x0c\xc2\xe0\xec\xfd\xd3\xef\xb8\xc5\xf1\xb4\x5a\xd7\x6f\xd8\x7e\xbd\xf7\xd9\xb3\x08\x29\x93\xc4\x06\x54\x89\x6a\x51\x0f\xf4\x45\xac\xb2\xa8\xb8\xb8\xa0\x5d\xa7\xf2\xf2\x76\x59\x1d\x2b\x2b\xeb\x91\xa7\x8b\xa8\x9a\x6d\x66\x51\x92\x50\x3b\x12\xeb\x19\xca\xca\x72\x14\x15\x81\x53\xc2\xfa\x60\x48\x0e\x1b\x98\x5c\x6d\x57\xdc\x66\x93\x1c\x5d\x08\xff\xb6\x4b\x17\xc9\x51\x8f\x19\xa1\xfc\xf1\xfa\x7a\xc9\xd1\xb1\xa2\x29\xde\xb1\xa3\xe4\xe8\xd4\xbe\x29\xde\xa9\x93\xe4\x28\x28\x63\xbf\x73\xc7\x0b\x0a\x24\x87\x86\xca\x25\x6f\xe7\x6e\x81\x6e\x8d\xf1\xdc\x80\xa3\xa5\xd4\xb4\xd5\xc8\xf6\xff\xef\x9f\x68\xaa\x4a\x23\x9a\x56\x76\x95\x36\xb3\x24\x75\x44\x18\x76\x16\x33\xda\x32\xd2\xb2\x53\xb9\xce\x25\x61\xf0\x54\xd2\x8f\x24\x72\x30\xdf\x02\xcc\x66\xc1\x17\x97\x04\xb1\x54\xcd\xc2\x37\xa5\xc8\xe7\x07\x21\x97\x89\xf5\xf0\x4d\xf4\x48\x7e\xb5\x30\x7f\xea\x24\x13\xb6\xa6\xd2\x35\xa3\xf7\xcf\x59\xb7\xa9\xa0\x9d\x30\x57\x9a\x3c\x9a\xfe\x6b\xdb\x4e\x7c\xc9\xc6\xa1\x53\x84\xc4\xcd\x2b\xdf\x17\xd7\xf7\xbf\x04\xef\xcf\xb6\xd1\x20\xfe\xb3\x73\xd7\x45\xab\xd5\x87\x6f\xbe\x54\x4f\x02\x9d\x37\xfd\xe3\x83\xeb\xeb\x3b\xcf\xbd\xc3\x4a\xef\xc7\xd3\x9c\x41\x3a\x59\xe8\x57\xda\x13\xe7\x6c\x5a\xda\xdb\x1e\xc2\xff\xc7\xd9\x77\xc0\x47\x55\xa5\x8b\x9f\x73\xeb\xf4\xde\x27\x93\x69\x99\xf4\x42\x32\x09\x21\xd4\x11\x51\x20\x2a\x04\x44\x49\xc4\x2e\x2a\x82\x05\xec\x88\x14\xeb\xae\x62\xc5\xde\x70\xc5\x86\x0d\x50\x07\x8c\xeb\x2a\xa8\x28\x2a\x71\xdb\xdb\x75\x77\x9f\x6d\x55\x56\x77\x6d\xb8\xab\x6b\x25\x77\xfe\xdf\x39\xe7\xde\x3b\x77\x26\x03\xf8\xfe\x84\x30\x21\xbf\xaf\x9c\xf2\xf5\xd3\x3c\xab\x88\x6d\x83\xb9\x11\x1b\x60\x6e\x32\xa8\x15\xdd\x9b\x4b\x27\x53\xa9\xea\x4c\x03\x42\x99\x40\xad\x64\x25\xf7\xad\xc8\x19\x79\x54\x5b\x32\xe9\xb1\xd9\x3c\xc1\x40\x40\xf6\x38\x4d\x74\x0a\x9c\x4e\xd9\x53\x2b\xb2\xd7\x93\x6b\x6b\x65\x4f\x03\x9e\x35\xd0\xd0\x20\x7b\xaa\x6b\xd8\xef\xaa\xab\x65\xb2\xe9\xd3\x1f\x69\xee\x1b\x88\xa8\xb6\x6f\xbf\x43\x9e\x2d\x39\x4c\x94\x2d\xd1\x7c\x6d\x68\xf7\x36\xb8\x30\xac\x13\x71\x77\xd6\x25\xbb\x21\xdc\x0f\xd2\x21\xe5\x27\x1f\xbf\xf8\xea\x5c\xe9\x60\xf6\xac\xbb\xe0\xf1\xc1\xea\x2c\x77\xf1\xef\x86\x67\x9d\xf4\xfa\xa2\x17\x8f\x5a\x8c\xfb\x9d\x0d\x1d\x6e\xa5\xa5\x64\xf0\x96\x2d\xf9\xd3\xd0\xd3\xb8\xab\x47\xd9\x13\x50\x36\x72\x2b\xaa\x0e\xf0\xce\xc2\xb1\xd5\x64\xbc\x1e\x55\xe6\x0a\xd7\x0b\xb3\xc0\xee\x75\xc3\x78\xd5\x83\xc5\xcb\x64\xfd\x3c\x67\x32\x9b\x21\x84\x6a\x8d\x46\xf9\x9e\x31\xa9\x94\x3b\xe0\xf7\x57\xbb\x1b\x1a\xaa\xcd\xe6\x6a\xbb\x9d\xaf\x76\x08\x54\xdb\x1d\x74\xc0\xcc\x03\x0e\x07\x5f\x8d\x70\x46\x95\x60\xb7\x33\x34\x6a\xe6\x40\xc8\x55\x0d\x36\xb1\x3a\x50\x9b\xe1\x33\x7d\x03\x7c\x54\xbf\x99\x44\xbf\x56\x5c\xd5\xf3\x72\x25\x2f\x2f\x50\x92\xe1\x0a\xaa\xd5\xea\x3a\x7f\xb2\x68\x16\xdd\xea\x68\x19\x1d\x0a\x8c\x5a\x56\x35\x95\x7a\x0d\x01\x6f\xb6\x2b\x9f\xb8\x35\x85\x8f\x98\xb0\x5b\x94\xc1\x9d\xfc\xe6\x0f\x7f\x7b\xf5\xdc\xc7\x1a\x24\x49\xd0\xdc\xc7\xe2\xf7\x17\x5f\x70\xfe\x59\x1f\x28\x0f\xe3\x59\xcf\x73\x54\xf9\x39\xfe\xe6\x3b\x8e\xf7\x2c\xec\xdc\xa1\xbc\xa7\x7c\xad\xfc\x5b\xf9\xdb\x29\x47\x55\xdf\xbe\x99\x9a\x08\x7e\x19\x3e\x7d\xfb\xa6\x8d\x5b\xe9\x9d\x81\xe4\x82\x54\x90\xb9\x26\x74\x7d\x2e\x59\x93\xc9\x44\x3c\x09\x62\x2c\xad\x4d\x28\x82\x5a\x9a\xbd\x1e\x8f\xa3\xa6\x06\x52\x63\x87\xc5\x82\x1c\x56\x4c\x87\xce\xca\x31\x43\x69\xb5\x3a\x12\x09\xe4\x68\x68\x4c\x36\x92\x5f\x78\x06\x92\x49\xe4\x70\x22\x7f\x30\xd2\x37\x10\xac\x82\x6f\x97\xf6\x14\xd2\xbe\x6d\x63\x31\xbb\xd0\x8f\x1f\xb1\xc3\xc7\x45\x2f\xa2\x09\x17\x57\x34\x8b\x45\xe3\x79\xbd\x55\x1b\x20\x1f\x13\xac\x86\x5c\xff\xe4\xd1\xc9\x29\x9d\xa7\x9d\x67\xd1\xec\xa6\x17\xaf\x67\x36\x91\xdb\x73\xeb\x02\xcf\x33\xd5\x67\x1f\xd3\xe2\xfc\xcc\xf9\xe8\xc3\x13\x99\xd1\xc4\xca\x2b\x6c\x2c\x78\x0f\x7d\x8b\xe3\xb2\x5c\xdc\x0c\x3d\x16\x5d\x81\x60\xb0\xca\xe5\x46\xee\x74\x0a\xa1\xb8\xd9\x1c\x0f\x06\xe3\xd1\xa8\x3b\x5e\xe5\xa1\x23\x51\xe5\x65\x23\x51\x55\x15\x17\x45\x77\xdc\xe1\x94\x54\x1f\x22\x49\x71\xb7\x3f\xce\xf5\x0d\xc4\x5d\x86\x83\x30\xfb\x18\x81\x92\x01\x60\xfd\xc7\xa4\x3a\xe6\xaf\xe8\x23\x22\xc4\x82\xf1\x9e\x9e\x79\x6f\x15\x3b\xa8\x7c\x52\x1c\x06\xf1\xed\x8f\x2e\x98\xce\x1f\x16\x54\x76\x1c\xae\xf5\xef\x25\xfc\x98\x3a\x00\x58\xc4\x52\x98\xe6\x2f\x05\x88\xa5\x8e\x87\xb9\x1f\x8d\x56\xe7\x1a\xba\x50\x34\xd6\x91\xcd\xa2\x60\x28\x14\xab\x49\xcb\x52\x1a\x82\xe2\xc6\x18\x8a\x8d\xe9\xae\xa9\x49\xc8\x32\x9f\x88\x86\xfa\x06\x3a\xa2\x51\x2f\xb5\x39\xa0\x5c\x89\x51\x5d\xa4\xb3\x6e\x30\xf7\x7c\x22\x51\x07\xae\xd1\xc5\x5b\x66\x95\xbf\xb8\xa8\x7f\xa0\x6c\xa5\xf3\xcb\xc6\x15\x4b\x2d\xd4\xf2\x09\x69\xe3\x9e\xf3\xba\x56\x5c\x97\x02\x13\x4d\xac\x4c\x6d\xf9\xb2\x0a\xb9\xf3\xa5\xa3\x3b\xeb\x93\x03\x42\x5c\x29\x7c\xf4\xfe\x17\x75\xdf\xf9\x4f\x5d\x75\xde\x19\x47\x9d\x7c\xf3\x43\x3d\xe9\x46\xbf\x7c\xd9\xb8\xe9\xae\xdd\x6f\xbf\xf8\x59\xec\x07\xdb\xb1\xa7\xcc\x9f\xdf\x7b\xcc\x35\xf9\x9e\x29\xc2\x65\xfd\x41\x3c\xfe\x9e\xa7\xaf\xbd\x25\x73\x58\x6e\xdc\x01\x9d\x13\xfc\xb1\xce\x94\xb7\x6e\xec\xb1\xab\x22\xcd\xe3\xef\x7a\xe2\xd6\xeb\x22\x93\x0f\xc8\x8e\x6f\xed\xf6\x55\xb7\xa7\xcf\x7c\xe2\xc0\xd1\x30\x56\x2f\x16\xbe\xe4\x6e\x15\xc7\xa0\x66\xf4\x50\xae\x21\x56\x5d\xdd\x04\x56\xc6\xc5\x07\xab\xfd\xe1\x4c\xc6\xe1\xe1\x6b\x9a\x9a\xf8\xd6\x96\xc6\x46\xe4\x75\xc7\x62\x6e\xb3\xd9\x0d\x39\x85\xbb\xc4\xd4\xd8\xc0\xd4\xb8\xc3\x61\xe4\x4e\xd5\x44\x6a\xd8\xe3\x61\x91\x08\x72\x87\x5c\x6e\xd7\xcc\x01\xbf\xdb\x89\xea\x8b\x67\x9c\x8b\xf7\x2d\xec\x5d\x68\x5c\xaf\x7a\xca\x4c\x4d\xb6\x64\xd9\x5e\x24\x0b\x63\x25\x51\x85\x5a\x0d\xd4\x24\x0a\x22\x5a\xb6\x4f\x41\xc2\x0f\x5c\x7c\xa5\x5d\x13\x9e\xc0\x55\xb7\xf5\x6f\x7a\xf3\x4d\xab\x26\x58\x4e\x71\xfc\xa4\xe4\x84\x05\x9e\x5f\x5c\xf5\x9a\x6a\x58\x70\xec\x05\x45\x79\x41\x8b\x37\xb0\x6b\xe6\x21\x8e\x0d\x29\x52\x47\x4a\x80\xfe\xfc\x55\x18\x8b\xd2\xe8\x96\x5c\x35\xe7\xf0\x25\x84\x88\xc9\x84\x22\x4e\x6f\x12\x21\x97\x37\x25\x64\x6a\xc2\x61\x37\xfc\xc6\x6d\x13\xa8\x10\xd9\x6c\x30\x46\x1c\xfd\xd1\xe1\x40\x6e\x5f\x82\xfe\xe8\xf3\x21\x77\xa0\x9a\x89\x56\x20\x80\xdc\x6e\x57\x1f\xd8\x65\xfa\xde\x90\xbf\xb2\x68\x55\xf8\x28\x7b\x8b\x88\xd5\x2c\xb2\x5d\x5e\xba\xb4\x95\xa6\x76\x84\x1e\x64\xe0\x03\x59\x7d\x38\xe4\xa4\x7f\xca\x8f\xcd\xd5\xda\x40\x4c\x5a\xf6\x9c\x62\xe7\x1b\xfe\x3b\xbe\x5e\x1b\x8a\xa9\xd7\x3e\xcf\xf5\xee\xc0\xe3\x2c\x74\x1c\x92\x9f\xed\x7c\x5d\x19\x72\xd1\x41\xa8\xff\xf2\x4d\x88\xc3\xaf\x52\x66\x80\x3f\x9a\x49\xd7\xb8\x8e\xcb\xb5\x59\x92\xc1\x68\x30\xc6\xd7\xba\xdd\xb1\xe6\x26\x41\x20\x07\x52\x6d\x56\x2b\x39\xdd\x8f\x1c\x30\xd9\x0e\x87\x0f\xd1\xa3\x18\x2e\x5f\xcd\xcc\x01\x5f\xd5\x5e\xde\x83\x2a\x73\xc4\xec\x2f\x5d\xfd\x0c\x8a\x4c\x0b\x20\x2f\x49\xaa\x6e\x44\x4f\x4b\x3a\x6b\xbc\x64\x72\x49\x39\x5f\xe2\xae\x7f\xf5\xdf\x55\xca\x27\xce\x93\xfa\xce\x3b\x9d\xe3\x8e\x41\x85\xe7\x7f\xff\xd6\xd0\xe7\xf3\x44\x48\x46\xbe\x95\xb0\xe4\xbc\xe0\xcc\x0f\xc0\x7b\x08\x33\x6f\xbb\x26\x79\x40\xef\x0d\xd7\x3d\xb0\x43\xd9\xa5\x7c\xaf\x7c\xa7\xfc\xfd\xe5\xf4\x85\xde\xd3\xaf\xe3\xe3\x9f\x7c\xbe\x27\xf5\xf0\x73\x78\x01\x3e\xe1\x39\x5a\x2f\xac\xc5\x7f\xe3\x5e\x16\x7e\x8d\xac\xa8\x33\xe7\x20\x2b\x55\x64\xdf\xa8\x60\xb5\xd9\x65\x32\x99\xcf\x0c\xc8\xb2\x24\x20\xb3\x44\x32\xe8\x8e\xb2\x83\x6e\x23\xb6\x8b\x5a\x94\x3f\x0d\x0e\xe2\xe6\x67\xf1\xdf\x70\x56\x79\x93\xfb\x40\xf9\x07\x8e\x0e\xc7\x59\x5e\x33\x1b\xfc\xfb\x0d\x20\x4f\x55\xa8\x1e\x1d\x95\x0b\x49\x76\x4b\x4c\x8e\x20\xde\xce\xa5\x23\x31\x4f\x84\xf7\xf0\x8d\x0d\x4e\x84\x12\x2c\xc0\x84\xe4\xdd\x64\x91\x4d\x72\xdf\x80\xc9\x19\xa8\x9d\x39\x10\x88\x96\x9d\x70\x29\x3b\x14\x60\x68\x0f\xc9\xde\x27\x61\x7a\xae\x85\xbc\x6c\x10\xf0\xb0\x57\x8b\xc9\xaf\x3d\x86\x64\x6e\x34\x17\x8c\xc7\xba\xfe\x3a\xfc\x1a\x7f\xa5\xf2\x7d\xb2\xfd\xee\x2d\x57\xfe\xb0\x6e\xdd\xf7\x97\x7d\xc3\x8d\xbf\xea\x97\xbf\xbc\xea\x9a\x2b\x2e\xbf\x96\x9b\x6a\x6e\xf6\x35\xa7\x6f\xd8\xf9\xf2\x96\x60\x2c\xe9\x9b\xa2\x7c\xb5\xee\x8e\xaf\x2e\xbd\xe2\x8b\x3b\x7e\x83\x45\x65\xe2\x3d\x0f\x3c\x78\xf7\xaf\x1e\x59\xcf\x6a\xed\xe1\xc2\x1b\xd2\xa5\xe2\x8f\xa8\x13\xad\xcc\x4d\x31\xc9\x1d\xed\x8d\xc1\xa0\x2b\x3b\xca\xe9\x6c\x71\xd5\x37\x37\x67\xd2\xc9\xa4\xab\xad\x5d\x16\x47\x77\xc5\xaa\x47\xd5\xd6\xb4\xb7\xe2\xa6\x74\x0d\xa4\x20\x9d\xee\xe6\x2a\xc1\x55\x5f\xe3\xaa\x8e\x44\x7c\x33\x07\x22\x01\x93\xcb\xcf\x5b\xfb\xb4\xa3\xa3\xe4\x96\x32\x72\xc0\x73\x12\xd9\xbd\xc7\x82\x16\x30\x13\x3d\xb8\x4d\xbb\x1c\xc7\x10\x28\xeb\xdd\x57\x17\xba\x92\x54\x58\xc8\x27\xa6\x4a\xe1\xa7\x97\xe9\xa7\xc1\xe6\x1a\x8c\x07\x99\x3b\x6f\x16\xcb\xfc\x1f\xc6\xae\x3d\xef\xf1\x41\xe5\x9f\x2f\x9e\xb4\x44\xf9\xa4\x80\x3c\x27\xdb\x3c\xa3\x17\x2c\x3b\x79\xd2\x84\xfb\xd7\xb8\x88\x05\x79\xf9\x65\x2c\xe0\xf0\x0f\xf7\x2b\x27\x4a\xfc\x89\xcb\xcf\xfa\xd3\xd0\xf0\x6c\xee\x58\x1c\x7b\xe4\xfa\xe1\xe7\xb9\x53\x94\x27\x4e\xe2\x6c\x1b\x52\x2d\xb3\x5e\x1c\x75\x20\xb7\x82\x5a\x93\xd3\x70\x3f\x77\x3d\x4c\xfe\xf4\xe1\x77\xc9\x5d\xc6\x60\x09\x11\x97\xa6\xf7\x73\x74\xc0\xcc\x9b\xac\xd8\x2c\x98\xcc\x76\x9b\x6c\x45\xd0\x5b\x01\x21\x33\xe7\x34\x93\x94\xd5\x70\xdc\xa3\xb8\x09\xc4\x4b\x85\x0b\x9a\x0b\x82\x16\x58\x8a\xc3\xcb\x96\x29\x9f\x2c\xe5\xd6\xe0\xf5\x4a\xff\x4e\xa5\x07\xef\x28\x14\x34\xfa\x1e\x49\xbc\x8b\x9e\x1b\x20\xef\x4b\x7f\x08\xb1\x64\x35\xaa\x01\xed\x3d\x25\xd7\x59\x8d\x1b\x92\xb1\x24\x4e\xd5\xfb\x78\x08\x74\x5c\x36\x6c\x6b\x6e\x32\x99\xbc\xa1\x60\xd0\x8b\x53\x0e\x47\xac\xde\xe9\x14\xbc\x4e\x5b\x34\x92\x81\x69\x70\x09\xf1\x99\x03\x42\xa0\xe4\xf2\x3f\xf5\x3e\xf2\xd2\xbd\x1f\x59\x12\x10\xea\x4b\xd7\x98\xad\x0c\x40\xec\x47\x86\x9d\x26\x7e\x7a\x5c\x08\x79\xb4\xf6\x10\x31\xa8\x34\x27\x7c\xd8\x1f\xf8\x9f\x27\x69\xd0\xa7\x7c\xb2\x6c\x99\x16\x09\x3e\x32\xe4\x9b\x3b\xfc\xf0\x0b\x31\xe5\x20\xe7\x39\xc7\x1f\x7b\xae\x13\x3f\x17\xc5\x83\xef\x7d\x49\x62\x3d\xe5\x04\xfe\x84\x9d\x2f\xb0\x18\xf0\xb3\x8f\x14\x48\x7f\x57\x5d\xc3\x7d\x78\xed\x0a\x6c\xa5\x7b\xc6\xc0\xf7\xdf\x4c\xcf\xaf\x44\xd1\xf4\x5c\xda\x62\xf6\x62\x57\xc8\x19\x0e\xdb\xcc\x08\x63\x73\xac\x0a\x87\x2d\x16\xaf\xd3\x6a\x15\xdd\x76\xa7\xe8\xef\x1b\x10\x0d\xe7\xa9\xcb\x2f\xb9\x31\xc8\x52\x5a\xdb\x92\x41\x4f\x1f\xd0\xaf\x2c\xdd\x53\xe4\x0b\x08\x37\xcf\xdb\xf3\xc9\x3f\x86\x8f\x3f\x1e\x87\xf1\x4d\x38\x3c\x6f\xf8\xe5\x05\xc7\x63\xe5\x8c\x53\xf1\x5b\xce\xbf\xff\xf4\xfd\x47\xce\x9d\xf8\x0e\xe5\x54\xf2\xad\x34\xdc\x70\xf1\x65\x57\x41\x1b\x2d\xd0\xc6\x2f\xa1\x8d\xa4\xb6\x75\x72\x2e\xeb\xf0\x84\x63\x02\x36\x07\x6a\xaa\x50\x1c\xfb\x33\x36\xa7\x25\x63\xae\x81\xc6\x36\xd4\xe3\x8c\xc5\x12\xf7\x43\x63\x5d\x31\xa7\xcb\x49\xb2\x1c\xa7\x98\x9c\x59\x6c\xb3\xe1\x94\x5b\x69\xcb\x8b\xcf\x9f\xaa\x55\xed\x34\xf1\x04\x10\x70\x40\xf3\xe9\xcd\x83\x7e\x08\x3c\x92\xf0\x7f\x72\x79\x2c\x9d\x11\xba\xc1\x44\xf8\x72\x06\x77\xe5\x9e\x7b\xef\xff\xf6\x2a\xdc\xb7\xb8\xe3\x9a\x2f\xf0\x87\x87\xcd\x76\xe2\x3d\x8e\x99\xb3\xf0\x87\x5f\x5c\xd5\x75\xe6\xf0\xf5\xe7\x5d\x61\x1b\xfe\xda\x76\x25\xde\x70\xd5\xd0\x19\x0b\x77\x5e\xbb\xf3\xda\x05\x43\x3b\x46\x9f\x33\xab\xf7\x82\x9e\x1d\x43\xa7\x5c\xaf\x64\xaf\xbe\xf0\xc2\xab\xa9\x8d\xfb\x05\xc9\x61\xc4\x21\xf0\x99\xad\xe8\xa4\x5c\xa7\x99\x87\xc0\x21\xe2\x8d\x35\x36\x46\x6a\x10\x82\x94\xdc\xe7\x4b\xc6\xab\xab\x43\xc9\x28\x0e\xf9\x93\x75\x33\x07\x92\x2e\x57\x0b\xf8\x0e\x57\x40\x32\xf7\x0d\x48\xa0\x0b\x92\xf6\xe0\x51\x56\x97\xbd\x11\x89\x08\x7b\x1c\x53\x5d\xb5\x94\x8b\x8f\x8d\x4e\xc0\x92\xb1\x96\x95\x64\xbb\xa5\x8c\x36\x4f\xb8\x7e\xee\x3d\x0f\x1e\x32\x77\x6c\xdb\x25\xe9\x26\xbd\x80\x85\xc3\xac\xa6\xa5\xbc\xad\x16\xad\xb8\xe4\xbf\xaf\xff\xf2\xc9\xc7\xdc\xff\x63\x5b\x3e\x55\x56\x6b\x56\xc2\x9f\x95\x13\x59\x21\x4b\x2d\x55\x71\xf4\x5d\xa4\x57\xa0\xaf\x49\x88\xa2\x4e\xcc\x75\x06\xe4\x54\x2a\x14\xe2\xea\xed\x5c\xc2\x1e\x69\xf1\xf9\x5c\xb2\xc9\x24\xb8\x02\xd8\x05\x1a\xe5\x72\x09\x21\x72\x5c\xda\xd2\x38\x73\xc0\x12\x88\x25\xfa\x06\x62\x08\xbe\x4b\x1e\x77\x32\xbc\x05\xa9\xf7\xb6\xc3\x58\x9f\x24\xaf\xd7\x8e\xa8\x4d\x51\xb7\xa3\x8e\x80\xb7\x58\x93\xe2\x7b\x2f\x59\x59\x5a\x90\xc2\xe1\x25\xb4\xeb\x35\x6a\x0d\xea\x0f\xcb\xe7\x94\xd5\x9f\xf0\xea\x1f\xff\xa9\x14\x68\xbf\xb9\x6f\xb4\xd2\x13\xd9\x83\xae\xcc\xe5\x36\x40\x3f\x53\xe8\xe8\x5c\x67\x24\x95\x4a\x60\xaf\x1b\x3b\x1d\xbc\xd3\xcc\xf3\x35\xe9\x60\x64\x26\xa4\x47\xb3\x06\x82\x18\xb9\x3d\xee\x99\x03\x09\x8f\xd3\x89\x67\x0f\x38\xfd\x23\x66\xd4\x70\xd9\x49\x53\xf1\x92\xb8\x2c\x5b\x37\x60\x17\x8a\x1b\xa6\x32\x5d\xb1\x72\xb4\x48\x9d\xbe\xab\x4a\x8a\x45\xc3\x63\xd4\x76\x2f\x9f\xc3\x5f\x5c\x56\x23\x22\xf3\x34\x43\x4a\x41\x1c\xd3\x8e\xc6\xa1\x2b\x72\x53\xeb\xda\x5a\x12\x02\x1f\xb2\xc6\xab\xdb\x3a\xda\xac\x7c\xb7\xc7\x63\x4d\xf0\x13\xc6\x87\x42\x51\x41\xa8\xa1\x1b\x77\xe2\xad\x90\xe9\xc4\x9d\x51\xa7\xbf\x0b\x62\x59\x97\xb3\x67\x26\x74\xa7\xa6\xae\x6f\xa0\xa6\x01\xbe\xa3\x34\xca\xd1\xe2\x1b\xe3\xd4\x19\xef\x66\x28\xb9\x46\x67\x84\x8f\xd2\x2e\xf8\xd1\xf6\xf8\xb0\xf9\xa4\x7b\x7c\x92\xd4\x67\x15\x1f\xd0\x9d\x40\x8c\x90\x60\xd8\x47\x37\x07\xc2\x1f\x1c\xd6\xc2\x9f\xc2\xb6\x37\xd5\xe8\x07\x5b\x24\xfc\xdb\x1b\xd6\xf5\x66\xeb\xbb\x5a\x3a\xde\x56\x7e\x54\x03\x21\x65\x86\x1a\x08\xf5\x2c\xda\x81\xab\xb1\x04\xd3\x9d\x60\x91\xd0\xf0\x9f\x94\x7b\x37\x3f\x6c\xfd\x1f\xcb\x01\x13\xef\xce\x7c\xf2\x39\xff\xde\xc3\xcf\x29\xb7\x2b\xf7\x3e\xc7\xde\xc6\x9e\x2b\x2c\x81\x39\x0f\x91\xbb\x0c\xa5\x80\x9d\xf7\xfa\xfc\x7e\x6b\xc8\xeb\x74\xba\x42\xae\x48\xd8\x6b\x27\x51\x4a\x74\xc0\xeb\xb5\xf9\xdc\xd8\xe7\x74\xf9\x6d\xc1\xd9\x03\x36\x3f\x2f\x81\xef\x36\xa9\x45\x06\x5d\x81\xb5\x5b\xe4\x8c\x1b\xde\xa8\x7d\x12\x8d\xf3\x4d\xab\x56\xe0\xad\x93\x66\x9c\x15\x40\x56\x73\x64\x9e\x73\xca\xfb\x4b\xc9\x1d\x4b\xf8\x52\xdc\xaa\x5c\x8e\x1b\x4e\x3f\x4c\x9d\x67\xfc\xe9\x1c\x65\xa1\x38\xb4\x67\x03\xde\xa6\x1c\xa5\x24\xe8\xd9\x72\x90\xd3\x34\xb4\xd9\x05\x71\x5c\x15\x6f\x96\x05\xc1\x61\xe6\x3d\x6e\x11\x0b\x32\xd1\x3d\x1b\x58\x52\x1b\x68\x9d\xcd\xd8\x36\xc3\x21\x9b\x20\x15\x3a\x83\x3a\x3d\x7d\xc9\x83\xe0\x6b\x69\x43\x40\x59\xc4\x21\x5d\x3b\x80\x17\xd8\x39\xd9\x0b\x32\xd5\x81\xce\xca\x8d\xaf\x89\x23\x7f\x47\x07\x6a\x8a\xc5\xe2\x4e\x59\x36\x35\xc4\x4d\x28\xce\x77\x66\x03\x10\xcb\x38\x9d\x4d\x56\x27\x32\xf9\x5b\x79\x2f\xdf\x37\x10\xf6\xba\x9a\x62\xb3\x07\x9a\xfc\xa9\x4c\xdf\x40\x0a\x04\x2a\x55\x41\x37\x2a\x6d\x44\x32\x6c\xef\x29\xc6\x35\x23\xeb\x7f\xfe\x72\x15\xa2\xe5\x3f\x37\x6f\x7b\xe0\x88\x45\xca\x27\x23\x6a\x7e\xe7\xa9\x83\x7c\x0f\xa9\xf7\x15\x4f\x7a\x1b\x6b\x7c\x8a\xa8\x6b\x16\x01\x78\xe8\x8a\xe1\x8d\x34\xde\x23\x76\xfe\x8f\xd0\xff\x1a\x34\x90\x6b\x4b\x09\x42\x34\x1a\xf3\x5a\xad\x4e\x1b\x17\x8b\xd9\x6a\x33\x3e\x2f\x39\xcf\x60\xf3\x07\x65\x52\x36\x11\xa2\x64\xf8\x13\xe9\xbe\x81\x04\x0c\x7f\xa2\xdc\xe8\x4d\x2a\x5b\x8f\x2d\xa6\x7c\x7a\x17\xca\x7a\x6b\xec\x27\x7f\xe2\x25\xb7\xbd\x78\xca\x72\xad\x77\xf4\xdc\xfc\x99\xda\x9c\x15\xcf\xdb\xab\x7d\xfa\xd3\x90\xde\x21\x54\xf4\x57\x10\x27\xd5\x80\xbf\x3a\x32\xd7\x96\x41\x26\x3e\xc4\xdb\x1b\xe3\xc1\x60\x28\x64\x47\xfc\xa8\xb6\xb8\x8f\x73\x08\xae\x54\x0a\x7c\x55\xca\x15\x75\x86\xa2\xc4\x5f\x81\xbb\xd2\x0c\x9b\x2e\xe3\x25\x27\xba\xb5\x35\x5b\xf7\xde\x5c\x54\xc0\xd0\x25\xea\xa3\x5c\x15\x5d\x14\x8b\x8f\x8a\x75\x32\xe5\x6d\x56\x18\xe3\x52\x5f\xdd\xa8\x7b\x28\x16\x1d\x09\x9f\x16\xeb\x63\x7a\x3d\x0c\x1d\x04\x3a\x41\xea\x61\xe4\x6c\x66\x6b\x94\xe3\x3c\x49\xc1\x1a\x0e\x0b\x1e\xa1\x26\x4d\xde\x33\x92\x9d\x2e\x6f\xdf\x80\x0b\x02\x22\xf0\x50\x61\x32\x4d\xd5\x90\x98\x56\xc3\x34\x55\x97\x4c\x93\xf6\xdc\xba\x41\x87\x59\xe7\x98\xd2\x8c\xa8\x67\x19\x26\x68\xc3\x25\xbf\x2a\x2f\x63\x9d\xaf\xcd\x0f\x3f\xbe\xa4\x7a\xa5\xdc\x67\x98\x1b\x8c\xa6\xc1\xdc\xc4\xa9\x8e\x9d\x9c\xeb\x14\x51\x75\xd0\x92\xa9\xa9\x41\x6e\x97\xab\xa9\xda\x82\x50\x75\x67\x36\x93\x49\xba\xdd\x49\xab\xd5\x9e\x4c\xd6\xcf\x82\x50\xc2\xee\x9b\x35\x60\x0f\x54\xb4\x41\x23\x96\x2f\x4a\x85\x8d\x6a\x96\x58\x3e\x4b\x86\x9a\x0d\x37\xa2\x52\x23\x40\x8f\x85\xb8\xaa\x41\x8b\xae\x36\x94\x6a\xbe\x7c\x68\xae\xa1\x44\x73\xd8\x51\x98\x7b\xa4\x5f\x35\x5b\x27\xa5\x8b\x35\x9a\xb6\x59\x97\x1c\xab\x17\x67\x46\x75\x7b\x46\xcf\xb9\xfc\x44\x5a\xc7\xfa\xbb\x32\x97\xdf\x28\xfe\x09\xb2\xc4\xb9\xb9\x76\x57\xc8\x1c\x0b\xd4\xd6\x9a\xd3\x21\x3e\x64\x6e\x6c\xb0\x7b\xfa\x06\xec\xae\xbe\x81\x40\x86\x4c\x11\x68\x53\x75\x00\xbe\x90\x1d\x09\x7d\x03\x08\x3a\x8e\xd4\x4e\x6b\xf7\x67\x34\x35\x35\x31\xc3\x9b\x2d\x06\x4e\xf4\x9c\x87\xf6\x52\x64\xd1\xc1\x56\x70\x3b\xd2\xb2\xa6\xa3\x7d\xdd\xd3\x26\x4f\xf8\xcd\x4b\x03\x93\x1b\x0f\x9b\x3a\x19\x0f\x5e\xb9\x66\x6a\x53\xb2\xb3\xb1\xe5\x7f\x7f\xad\xcc\x75\xc8\x7f\xf6\xf7\x9d\x27\x9c\xf2\xda\x66\xef\x5f\xfc\xfd\x8b\xf6\xfc\x55\xb9\xf7\xa1\xdb\x2d\x2f\x9a\xc7\x8f\xb9\xeb\xec\x1d\x5b\x90\xfa\x26\x27\x7d\x7f\x3e\x88\x26\xe7\x32\xc8\xe1\xb5\x71\x5c\xd0\x69\xf2\x06\x85\x70\x28\xe0\x74\x3a\x40\xf8\x1c\x68\xf6\x80\xc3\x2f\xc2\x84\x89\x16\xf8\xd6\x27\xad\xf4\xc6\x75\x1a\x01\x65\x4a\xac\x5b\x12\x93\xab\xd1\x26\x62\x6f\x92\x8f\x3d\xa2\xce\x83\x92\x57\x96\xe3\x86\xe7\x9d\x63\x2c\x13\x77\xe0\xda\xbc\x6e\xbb\x84\xb1\xc3\xf7\x77\xbc\xd6\xf0\x5b\xee\x78\xf5\x4d\xfc\xc5\xf4\x0c\xfe\xfc\x5c\x30\x20\x09\xbc\xcb\x65\x97\x64\x8b\x19\x7c\xbf\x39\x12\x06\xad\x30\x9b\x68\x89\x2b\x32\xe0\x80\x08\xce\x66\x76\xca\x7e\xc1\x49\x74\xc3\x17\xec\x1b\xf0\x81\x6e\xf8\x4a\xbc\x5b\xd9\xc3\xf8\xc6\x0d\x38\xec\x36\x3f\xa2\x22\x56\xac\xbf\x8e\x5f\x34\x5d\xe8\x92\x19\x7b\xca\x9f\xc6\x77\x5e\xa3\x29\x47\xd9\xcb\xf8\x97\x96\xe8\xc6\x14\x90\x91\x1d\x34\xdf\xe9\xcd\xd5\x83\x36\x38\x3c\x4e\xaf\xcd\x86\x24\x3e\xe0\xf7\xd0\x9c\xc1\xe5\xb4\x7b\x6d\x30\xbc\x95\x7c\xb2\x7a\x2f\xb9\x5a\x3f\x20\xfb\x00\x98\x2e\x18\x15\x20\xd9\x45\x2b\x08\x38\xc9\xef\x50\xc7\x76\xf8\x74\xae\x8a\x54\x90\x86\x3f\xe1\x7a\x35\x2f\xbc\x83\x5b\xbf\xf3\xf5\x61\x75\x1f\xfc\x78\x65\xae\xb8\x50\x98\x01\xd1\x70\x0f\x5a\x91\x4b\x3b\x42\x2d\x90\xd8\x5a\x2c\x75\x2d\xf1\x44\xa2\xc3\xd7\x52\x57\xe7\x1b\x37\x36\x1e\x4f\x3b\x9c\xce\x74\x73\x63\xa3\x3b\x1d\x6c\x65\x41\x44\x30\xe8\x4e\xa7\x21\x82\x4c\xbb\xdc\x5d\xe4\x6d\x74\x19\x64\x59\xe6\xe0\xbb\x82\x02\x1b\xe2\xab\x11\x9b\xa7\x3d\x45\x49\x11\xd9\x1e\x41\x9a\xba\x91\xf4\x47\xdd\x8a\xaa\x9f\x6c\xca\x18\x4f\x36\x61\xd9\xc1\xf9\xd5\xf7\x15\x84\x55\x97\xb4\x8d\x9d\x9b\x7b\x70\xed\x21\xbd\x26\xe9\xfc\x2f\xef\xd9\xf4\xa7\xbf\xfc\xab\x77\xce\x8c\xe9\x66\xe5\xed\xe8\x67\x3b\x7f\xfb\x6e\xc3\xa8\x44\xb5\xd2\x77\xc3\x89\xb3\x9b\xa6\x8e\x9b\x7c\xc6\xc4\x39\xcb\x6d\xff\xe3\x7e\xec\xc9\xa9\x8e\x93\x8e\xfc\xf3\x63\x77\x3d\xb8\x49\x14\xba\x17\x9e\x3a\x75\xb6\xe3\xde\x75\x43\x83\xca\xf9\xf3\x0e\x92\xf0\x4c\xf5\x9a\xd6\x69\x2b\xa7\xb2\x58\x74\xae\xb8\x11\xc6\x88\xe4\x47\xf3\x73\x5d\xbc\xab\xa6\x26\x10\x48\x55\xa5\x42\x8d\xe6\x90\x79\x54\x9b\xcb\xe5\x21\x37\x10\x78\x9c\x36\xf0\x37\x36\x17\x0a\xcc\x1e\x40\x7e\xa9\x99\xbc\x08\x1b\xaf\x82\xa0\x34\x02\xdf\x95\x92\x86\x8a\x7b\xc9\xe9\x48\x8c\x58\xcd\xee\xa4\x11\x66\xd6\x6d\x18\x21\xde\x90\x37\x1c\x6a\xcc\x1a\x04\x17\xb6\x4a\x4b\xc8\x88\x1c\xf2\xd0\xdd\xd7\xa8\x89\x43\x69\xd6\xd0\x7f\xf8\xa9\x8f\x0e\xaf\x56\xbe\x27\x03\xf1\xf8\xa6\xc3\xb8\xb4\x96\x38\xb0\xbe\x4e\x14\xff\x0c\xd9\x6e\x07\xb9\x8f\x38\x5c\x53\x93\x68\xb5\xd4\xbb\x3d\x3c\xcf\x27\x12\x96\xce\xac\xdb\x6d\x17\x44\x51\xb6\x07\xc2\x60\xcf\xa0\x77\x01\xbb\xbd\x69\x26\x58\x37\x79\xd4\xcc\x01\x39\x80\x6a\xc0\x9a\xa5\x8a\x16\x4d\x7f\x2a\x5c\x7f\xb0\xd7\xd8\xe3\xa0\x31\xb6\x06\x7d\x2b\x5d\xbf\x67\x46\x8e\x99\x6e\xd6\x71\x07\x36\x2e\xe0\xaf\x78\xe8\x2e\x63\xaa\xb4\xf1\xce\x13\x8e\xf0\x1c\xe2\x9f\xd0\x0d\x3d\x8f\x2e\x56\xb4\x8e\x2b\x73\x9f\xd8\x38\x6c\x4c\x98\xce\xbe\xfa\x76\xf7\xeb\xa2\x7c\xf0\xd4\x9f\x3a\xa0\xfb\xa2\x8d\x1f\xd2\xb3\x26\x32\xd7\x7d\xd0\x7f\x19\xe6\xba\x1a\x65\xd0\xf9\xb9\x5c\xca\xea\xaa\x0a\x54\x79\x3c\x16\x2b\x9f\xb6\x58\xf8\xba\x5a\x97\x4b\x8a\xc5\x90\x94\xb2\xce\x1e\x48\x25\x5d\xee\x69\xce\x14\x76\x88\xa9\x14\x92\xa4\xf8\xec\x01\xc9\x85\x1c\xe4\x5e\x9b\x70\x00\xc2\x46\x1f\x7c\x57\x50\x86\xe3\x8e\x3d\xa6\x69\xc4\x2a\x84\x61\x57\x03\xa9\x9a\x93\xeb\xee\x8c\x5b\x59\x8c\xf3\xae\x1d\x79\xe1\x7a\xbf\x51\x7e\xc4\x96\x6f\x8a\xbb\x59\xa8\x12\x3c\x74\xf7\x29\x2b\xb4\xed\x2c\x60\x6d\xfd\xd8\x86\x13\xfa\x46\x16\xe5\x4e\x36\xe3\x27\xd4\xab\xdb\x59\x68\xac\x21\x10\xd9\xee\x40\xa7\xe6\xba\xa2\x12\x0f\x9e\xba\xb1\xb6\x66\x14\x3d\x77\x32\xaa\xb6\x96\xa7\x33\x5e\x53\x63\x6f\x6f\x47\x76\xbb\x6f\x36\xcc\x34\x4a\x92\x2e\xb6\x34\xf6\x0d\xb4\xd4\xc3\xf7\xcf\x76\xd8\xd9\xe2\x65\x3e\x3f\xe3\x7c\x4a\x49\x97\x39\xfb\x5f\xbf\xba\x63\xd5\xb2\xe5\xef\x6c\xde\xf2\x71\xe4\x0b\xd3\x89\x33\xa6\xcd\xb8\xf2\x96\xfb\xae\x1c\xe8\x9b\x76\xba\xfb\xdf\x6a\xb7\x8f\xf1\x3d\x71\xdb\x69\xd7\x39\xb8\xc8\xa5\x27\xae\xb8\xeb\xce\x9b\x02\x53\x0e\x3d\x70\xfc\x61\x53\x9f\x3c\x74\x4e\x6e\xe6\xc0\x21\xcd\xca\x35\x5a\xcf\xe9\x3b\x4d\x73\xe9\xfd\xb7\xa4\xcf\xa3\x63\xe6\x48\x3b\xaa\xf3\xfa\x7c\xed\x11\x7b\x5d\xbb\x94\x6c\x6f\x4e\x42\xa7\xbd\xde\x20\x42\xc1\xda\xda\x9a\x60\xd0\x35\x1b\xc2\xe1\x1a\x7e\xd6\x40\x4d\xa0\xb5\xa9\x6f\xa0\x15\xd2\xc9\xd6\x7d\x75\xba\x2c\x01\x60\xfb\x39\x7f\xc6\xa5\xb8\x74\x31\x44\xeb\x74\x97\x1b\xd7\xee\xf5\x7e\xdc\xbf\x2c\x3a\x56\xed\x34\x3e\x74\x1f\xf7\xe4\xb6\x9e\xc9\xfa\x8c\xcf\x50\xe5\xfa\xf7\xd0\xe7\x38\xaa\x25\x7b\xb4\x42\xe9\x34\xef\x34\x3b\xc5\x58\x75\x75\x4d\x50\x0c\xd6\xd7\x81\x50\xbb\x5c\x88\xe7\xbd\x28\x58\x03\x1d\x0e\x7a\x11\x8a\x92\x75\x01\x6f\x62\xf6\x80\x37\x60\x33\x83\x53\x92\xcb\xd2\xb0\x91\xab\x1d\xa5\xb7\x02\x67\xf5\x43\x52\x28\x68\x30\x5d\x5d\xec\xea\x08\xc3\x3d\x8e\xea\xed\x8d\xd9\x8f\xb1\xe0\x78\x4e\xed\x59\xcf\xa7\x0f\x92\xcb\x1b\x89\x64\x2b\xdf\x9d\x83\x8f\xd7\xaf\x6c\x54\x86\xbf\x1f\x1e\x50\x3b\x36\x79\xd5\x55\xe4\xd6\x46\x2a\xdb\xb8\x76\xcf\x4c\x2a\xd3\x1c\xc9\x83\xb9\x61\x9a\x53\x92\x3b\xf1\x32\x12\xc7\xd9\x6c\x3e\xe4\x46\x0e\x47\xc0\xef\x74\x7a\xdc\x87\x0f\x78\x30\x8b\x60\xcc\xe0\x66\xcd\xe0\xb9\xcc\xe5\xf6\x59\x3f\x36\xa3\xea\x64\xa6\xc4\xf6\x42\xc6\x99\x21\x7e\x76\xfd\x22\xb5\xb5\xb7\x90\x0b\x85\x71\x38\xaf\x9b\x54\x61\xec\xcb\xbf\x23\x6f\x9d\x12\xff\x4a\xee\x50\x05\xdf\x71\x44\xae\x45\x04\x3b\x62\x0d\xa5\x52\x31\x0f\x9f\xa9\xb1\x58\x9c\x08\x39\x83\x41\x68\x92\x3c\x73\x00\xb2\x71\x7e\xe6\x80\x7f\x2f\x1e\xa3\x82\x88\x69\x96\x53\x3b\x31\x41\xfc\x23\xc7\x6e\xca\x2c\x97\xa4\xe3\x0c\xf7\x98\x5e\xf2\xc7\xcb\xd8\x05\xa7\x2b\xb5\xb6\xe3\x93\x0e\x3f\x09\x2f\xc2\xe7\xb3\xfb\x4f\x95\xb7\x95\x1f\x95\x6f\x94\x3f\xf7\x2c\x55\xc7\x78\x1d\xd2\xe2\x5b\xee\x3b\x88\x6f\x13\x10\xbb\x34\x98\x1c\x51\x84\x7c\xbe\x54\x92\x77\x38\x92\xa1\x58\xdf\x40\x08\xa2\x5a\x37\xe4\xca\x4e\xb7\xd3\x6d\x0d\x59\x21\x70\xb1\x8a\xf0\x5d\x12\xd7\x92\xa0\x16\x17\x5d\xbe\xb6\x37\x56\xaf\xf3\xc3\xb8\x8e\x88\x6e\xf1\x77\xb7\xdd\x63\x39\xd3\x33\xd3\x35\x37\xfb\xd0\xdd\x25\x31\xad\x65\xcb\xd3\xae\x13\x4d\x02\x69\xe2\x76\x88\x67\xf9\x51\x6a\x3c\x4b\xc6\x7c\x25\xc8\xfa\xf3\x10\x67\x25\x21\x3b\x6c\x71\x5a\x23\x92\x64\x36\x5b\x71\xc2\x6f\xb5\x26\xd2\xa9\x48\x34\x1a\x94\x93\xce\x18\xb4\x36\x16\x08\x9a\x41\xd6\x21\xf8\xea\x1b\xf0\xd8\xe1\xbb\x5c\x0a\x46\x9e\xaa\xd7\x56\x8f\xe8\x69\x0f\x56\x77\x30\x88\x85\x1e\xb5\xb8\xf1\xed\xdb\xc8\xc5\x70\x2b\xd5\x31\xbe\x59\x90\xb1\xb8\xe8\xdf\x8f\x0f\x42\x4c\x7b\x9f\xf2\xd1\xc6\xab\xb8\x29\x7b\x96\x29\xdf\xa9\xc2\x12\xbe\xa1\xf5\xb3\x3f\xed\xe4\x36\x92\xb6\x93\x35\x00\x07\xb4\xbd\x16\x9d\x92\xeb\xb2\x7a\xe2\xbc\xcf\x11\xce\xd8\xdd\x6e\xc9\xe7\xcb\xd4\xd7\x81\xc0\x84\xc3\x4e\xab\x35\xe5\xe4\x21\xac\xe5\xf9\x94\xd3\xed\x70\x3a\x60\xdc\x9d\xa9\xf8\xac\x81\x54\x6c\xb6\xa1\x38\x51\x5c\x73\xda\x9b\x7e\xb2\x8b\xc0\x54\xd3\x44\x5f\xd4\x61\xe1\xa3\xe0\x26\xcb\xdf\xfa\xd2\x2c\xeb\x50\x83\x65\xe9\x71\xe7\x2e\x99\x74\xc9\x1d\xa7\xe0\x49\xc3\xef\xf0\x57\x2a\xb7\xe0\x87\x95\x9f\xbe\x5a\x7f\xe9\x61\xd3\x58\x1f\x77\x1f\x79\xda\xbc\x53\xa6\xcf\xce\x3c\x8f\xf1\xce\x97\x95\x2f\x1a\x95\x1d\xdb\xdf\xeb\x6b\x99\x90\xb3\x3d\x42\xc4\xa8\x8d\xed\xfd\xe6\xbe\x12\xbe\x86\xbc\x22\x89\x0e\xc9\x05\x04\xb3\x84\x6c\xa1\x90\x14\xf3\x78\x24\xb2\xb7\xc1\x6c\xb7\xd9\x04\x33\x3d\x02\x43\xce\x98\xc5\x91\x13\xd7\x93\xd7\x72\xf7\x75\x04\x86\xdd\xb1\xe3\x93\xe8\x49\xdb\xe2\x09\x18\x66\x4e\x79\x7d\xf9\xf1\x1b\x59\x24\x67\xa8\x2d\xc5\x23\xd4\xec\x1c\x2b\x77\xa2\x7b\xb6\x7f\xfc\xb9\xf8\x81\xaa\xab\x3b\x7a\xd9\x09\x6a\x8c\x97\x5d\x89\x25\xcc\x5f\xcd\x62\xf6\x76\x68\xf3\x5f\xe9\xb9\xa6\xb6\x9c\x53\x3b\xd3\x64\xb1\x48\x5e\xaf\x4d\x22\x67\x9a\x5c\x7b\x39\xd3\x64\x38\xad\x1a\x94\xc9\xd9\x3f\x97\x7a\xf0\x19\x5f\xf7\xd0\x33\xcf\x3e\x7c\xc5\x23\xbe\x17\xdd\xe7\xde\x7c\xdb\xe8\x5e\xd3\x36\xd7\xd3\xf8\xed\x37\x9f\xdb\xfa\x87\xab\xcf\xb3\xac\x2a\x28\xdf\x4f\x9d\x6a\x59\x7a\x13\x8d\x45\xcc\xf8\x05\xee\x43\xe1\x3f\xa8\x0a\xd5\xa0\xd9\xb9\x64\x92\xb7\x06\xab\x70\x2c\xe8\x16\x45\x1e\x07\x85\xda\x8c\xcd\x16\x89\xfb\x7c\x11\x8f\xc7\x84\x22\x55\x49\xb2\x13\xab\xfe\xa9\x64\x3a\xa2\x1f\xaa\x77\x67\xb5\x0b\x85\x47\x5c\xe4\x43\x57\xa8\xea\xca\x36\x33\xb8\x83\xc5\xb1\xcb\x90\x5b\xec\x60\xf8\x2e\x3e\xa7\x66\x74\xc3\xe0\x23\x57\x3c\xe2\xdd\x66\x9a\x3c\xfe\x26\x7c\xfe\x99\x17\xad\x7a\x64\xcd\xaa\x13\xf1\x79\x67\x4e\x3b\xa2\xe5\xb8\x95\xf8\x85\x85\x3d\xb9\x39\x67\x3e\xff\xc7\xd5\xe7\x58\xc6\x1e\x5c\x40\xed\xb3\xe6\x1f\x7b\xe6\xca\x43\xaf\x39\xf8\xf0\x03\xb5\x33\xf3\xbc\x4f\xb2\xd1\x3b\x84\x8f\xcd\xd5\xfb\xcd\xde\x90\x0b\x09\x61\x4f\x98\x73\x44\x3d\x09\x73\x94\xe7\xcc\xb5\x19\x14\xf6\x87\x42\x7e\x37\x24\x43\xfe\x6a\x87\x43\x72\x79\xfd\x64\xff\x7f\x5a\x3f\xbd\xac\xdf\x45\x94\xa5\x9b\x0e\x3a\xca\x42\x0b\xed\xc4\x47\xc0\xed\x2f\x9e\x5f\x0b\xd6\xd6\xc9\x5d\xdd\xb5\x20\x12\xc1\x6e\xbf\x7a\xfc\x92\x9c\x88\x9a\xf8\xd6\xf6\x4d\x8f\xbf\xf2\xf2\x93\xd3\x6a\x9b\xc7\xbe\xba\xe4\xa0\x45\x3b\x26\x37\x3d\x33\x85\x1d\x6b\x13\x4f\xde\xa5\xec\xe2\x9e\xfd\xdd\x6f\xee\x5f\xf7\xeb\xe0\x09\x07\x1d\x79\x69\xfb\x98\x29\xc9\x64\xdf\x15\xc3\x4f\x2e\x39\xf9\xad\x05\x67\xd1\x7d\xea\xea\x99\x57\x8f\x24\x9e\xae\xde\x67\xf1\x29\x7e\x8b\x9e\xc9\x1e\x97\xb3\x0b\x9c\xcf\x2e\x71\x5e\x6c\xe7\x82\x01\x72\x3f\xc6\x53\x76\xa7\x65\x10\xa7\xf3\x88\x1c\x23\x18\x04\xb9\xd6\x8f\x2d\x8e\x58\x8e\xae\x58\x39\x3f\xe8\x85\xd3\x4f\x5f\xb4\xa8\xf3\xa0\xaa\xaa\xae\x9a\x1b\x85\x63\x87\xaf\xe1\xce\xbd\xb2\xef\xb4\x93\xac\xab\xe4\xd6\x96\x09\xec\xac\x56\x14\xfd\x16\xbf\x45\xcf\x4b\x75\xe5\x02\x3e\x1b\xf2\x88\xbc\x47\x96\x6d\xc1\x80\x93\xf7\xfb\x25\xbb\xcf\x67\xc1\x94\xf1\xf6\x9e\xb6\x0e\x56\xb5\x2f\x3d\xa5\xe5\x25\x1f\xe4\x7c\x96\x5e\x44\x20\x4b\xad\x8f\x1b\x19\xf3\x7d\xf8\x66\xe5\xf4\x2b\x95\xdf\xab\x9c\x71\xec\x4a\x76\x4f\xde\x28\x34\xc8\x7d\x2e\x7c\xed\x92\xc4\x33\x0a\xa4\x2d\xcd\xf8\x53\x6e\x07\x8c\x85\x0f\x8d\xc9\xf9\x1d\xc8\x63\x96\x3c\x60\xb8\x40\xa0\x10\x92\x79\xab\xd5\xe3\x94\x7f\x8d\xd3\xc8\x43\x8f\xa6\x66\x0d\x97\x3d\x18\x0f\xb4\x95\x1c\x53\x22\x9f\x69\x77\x37\x67\xad\x3b\x6f\xd6\x05\xcb\x5e\xb8\xfc\xe0\x39\x5b\xb7\x8a\xfc\xda\xfe\x99\xb7\x5d\x87\xc9\x19\xae\xe5\xc7\xe1\xdb\x7f\xfa\x14\xc7\x6e\x63\xb1\xbb\x0c\x73\x71\xba\x58\x40\x56\xfa\xaa\x95\xd7\x69\x96\xad\x56\x1b\x79\xfe\xd4\xe5\xb6\x70\x9c\xcc\xf3\x22\x39\x40\x86\xe8\xf5\x3b\x76\x10\x30\x62\x53\xd4\xab\x67\x98\xbb\xd7\xb6\xc5\x7a\xe9\xc5\x65\x6c\x60\xc8\x8b\xad\x03\xb3\x67\x6f\x9d\x03\xbc\x81\xfe\xf4\x2b\x71\x93\xf2\xe7\x2b\x95\x67\xf8\xcb\xd6\xac\xa1\xf6\xe1\x53\xf5\x1c\x2e\x7d\xff\x4c\x14\xe8\x91\x19\xbe\xf4\x3e\x29\xe8\x45\xfb\xd6\xad\xc2\xae\x61\x49\xb5\x29\xff\x77\x1c\xda\x37\xc0\xb1\xa2\x51\x39\x37\xe9\x18\xe9\x97\xcd\xae\xf6\xeb\xd7\x6a\xbf\xca\xfb\xe3\x2e\xef\x0d\xeb\x89\xb1\x1f\x88\x5c\xf6\xf4\x02\x77\x0e\x8c\x1b\x89\x97\xaa\xd1\xd4\x9c\xcb\x66\x77\xcb\x61\x9f\x25\x6c\xaf\x22\x17\x9b\xc7\x4d\xe4\x10\x89\x1b\x26\x2e\x95\xb7\x48\x92\x3d\x42\x6e\x9e\xf1\x03\xbf\x06\xed\xf4\x1f\x39\xc9\xc4\x6e\xa0\xd2\x77\x01\xb5\x8f\xea\xa6\x8a\x38\x0e\x33\xce\xa0\x99\x64\x24\x31\x2d\x52\x11\x55\xfc\x7e\xf1\xe5\x97\xae\x38\x78\xeb\xc2\x85\xd7\x76\x6c\x55\xfe\xd1\x55\x77\xd8\x89\x0d\x2f\x5c\x74\xda\x29\xe7\x70\x0b\x87\x6f\xbd\xd1\x76\xed\x1a\x61\xe3\x9a\x35\x3f\xbd\x33\x7e\x5c\xc3\xec\x64\x0b\x7d\x07\xf4\x05\xbc\x16\xda\x68\x47\xa9\x67\xa0\x11\x3c\xef\x24\x3b\x9b\x52\x4f\x59\x4c\xfa\xd1\x5a\x6d\xf9\x9d\x1e\xc7\xee\xd2\x5c\x33\x58\xdc\xe8\xa2\x25\x5b\xfb\x6b\x53\xfe\xc3\x5f\x38\xfb\x32\xe1\xd0\x9f\x36\xf6\x9b\x6e\x16\x4c\xf4\xbd\x85\x17\x70\x1f\xed\x77\x7b\xce\x6a\xe6\x79\xd9\x29\x0b\x82\xc7\x2d\x12\xe3\x23\x13\x1f\xf4\x94\x13\xd9\x28\xf5\x2c\x3b\xac\x85\x0d\x77\xae\xd1\x1a\x2a\xe9\x9a\xaa\x39\x47\xf6\x2f\xde\x7a\xf8\x92\x85\x99\x03\x12\xf8\xc8\xfe\x71\x42\x60\xcf\x69\x9b\x2f\x3b\xdb\x76\x33\xe1\x33\x19\xf4\xa2\x01\xe6\x4e\x44\xd5\x5b\x04\x8c\x91\x24\xd3\xc3\x72\x82\x76\x58\xce\x6d\x78\x7e\x31\xeb\x4e\x72\x0d\x4a\x78\x2b\xae\x27\x27\xe4\x86\x6f\x25\x73\xdf\x86\x5e\x10\xe6\x08\xdf\xa0\x16\x34\x90\x8b\x78\x5b\x92\xd1\x16\x7a\x4e\xba\x36\x6a\x42\x51\xbe\xad\xd5\xe7\xf4\xd2\x73\xd2\xcf\xd1\xe3\xd9\x26\xdc\x98\x6f\xe0\xf9\xa0\x9b\x78\x83\x54\x4d\xb5\xde\x7e\x36\x4f\x23\x97\x29\xd4\x82\x77\xd9\xc9\xe3\xd1\x86\xf5\x09\x76\xd6\x84\x18\x07\xed\x7c\x32\xfe\x58\x3b\x3c\x3d\xf9\x66\x72\x76\x7a\xe1\xe1\x67\x2c\x5e\xb2\x30\x38\xd7\x97\xa8\xeb\x5f\x3c\xa6\xb7\xec\x04\xf5\xc3\x0f\x1f\x31\xfb\xf6\xeb\x86\x3f\xbe\xec\x1c\x59\xbc\xc5\xd4\x8f\x3f\x79\xfd\x9c\xe3\xb5\x73\xd4\x1d\xe8\x79\x61\x16\x8c\x0d\x39\x71\x15\x74\xe1\x78\x24\x28\x59\x2c\xe6\x60\xdc\xcc\xa7\x92\x56\x97\xdb\xed\x4b\xc8\xa1\x5f\xb3\x43\xb1\x79\xbe\xaa\xca\xe1\x2b\x3f\xfe\x98\x2d\xbb\x12\xc7\x78\xfe\x31\xed\xae\x70\xf6\xb1\xcb\xcd\xfd\x8a\x9c\x7d\xfc\x75\x66\xd1\xf4\x47\xd2\x42\xe6\xb4\xd9\xa7\x2f\x7e\xe1\xac\xb1\xd3\xf5\x73\x8f\x3f\xfd\x0d\xff\xfa\xc8\xa9\x0f\xf5\xcf\xb8\xe3\x1a\xfc\x0f\xf8\xdd\xb9\xc7\xd1\x20\x18\x17\xfe\x85\x5e\xe0\x6b\x60\x1e\x12\x68\x72\xce\x1d\x4d\x88\x7e\x7f\xc2\x61\xb7\x27\x52\x49\x49\x14\x1d\xdc\xf3\xf4\xa8\x1c\xb9\x93\xc9\x0c\x23\x5f\x55\x1d\x2a\x4a\xce\x88\x23\xdf\xf4\x00\xb2\xf1\x84\x77\x5a\x1d\x58\xc3\x50\x5f\xa5\x1f\xf4\xde\x7a\xd9\x94\x23\xcf\x5e\x18\xec\xf7\xa5\x6a\xfb\x85\xb1\xda\x31\x6f\x7a\x20\x7d\xe9\x49\x4a\xfb\x65\xe7\x98\x04\x18\x56\x36\x9e\xdd\xd0\xc6\xf3\xb5\x36\x46\xfc\x76\x49\x92\x13\x7e\xbf\x9c\x4a\x42\x4b\x65\x0b\x69\xa3\x0c\x6d\xe4\x90\x1b\xda\x18\x0e\xc6\xf6\xdd\x46\xac\xc9\x44\x1b\x36\x9e\x46\x67\x6a\x45\x86\x94\x0b\x5f\x36\x75\xce\x56\x8e\xdf\x62\xe6\xa8\x89\xee\xaf\x4b\xf8\x0f\x8f\x2c\x5a\xcc\xdf\x0a\xb6\x99\x4c\xff\xc9\x07\x93\xc6\xde\x76\xfd\xf0\x07\xfd\xa6\x5b\x04\xd3\x39\x97\x21\x76\xe6\x9f\x7b\x03\xe6\xdc\x46\xee\x47\xc3\x56\x2b\x22\x6f\x8e\x20\xc9\x61\xb7\xd2\xe0\x4f\xa2\x0d\x94\xe1\x27\xb3\x7e\x9c\x74\xc4\xfd\x68\x38\xad\x5d\xca\x56\xe7\xce\x72\x6f\x3c\xa9\x3c\x27\x3d\xfa\x32\xce\x4a\x8f\x02\xed\x60\xef\x34\x65\x19\x28\xcf\x7f\xee\xc0\xe7\x91\x7d\x35\xc5\x73\xf0\x2e\xea\xa7\xfd\x0e\x9f\x4f\x72\x7a\xbd\xec\x34\xbc\xd3\xec\x73\x38\x78\x1b\x3d\x14\xef\xd6\x8f\x66\x8e\x8c\x35\xcb\xcf\xc7\x67\x52\x72\xb2\x96\xef\xe8\x4e\x06\x8a\xe7\xe3\x95\x1b\xef\xf4\xe3\xb9\xde\xb5\xb7\x07\x95\x27\xa2\xfa\x29\xf9\x03\x5e\x7e\x79\xf8\x87\x67\x9f\xa5\x7b\x7c\x5a\x60\x7e\xde\x02\x9b\xe3\x46\x21\x88\x70\x0f\xcd\x79\x2c\x01\xb7\x5b\xae\x42\x61\xc1\x63\x17\x90\x9d\x4f\x26\x4c\xbf\xc6\x64\x27\x63\x43\xde\x1f\x8b\x59\x64\xd0\xe2\x7c\xa0\xaa\xca\x85\x0d\xe7\x0c\xa9\xf0\x1b\xab\xec\x6a\xa5\x5d\x3d\x64\x08\xbf\xa2\x05\x05\xd9\xed\xed\xac\xad\x73\x4f\xc4\x19\x72\xe4\x10\xec\xe0\x83\x9b\x5e\x7b\x79\xf3\xb3\x9b\x5f\x7e\x6d\xd3\xd3\x03\x47\xcd\x3d\x7a\xf8\x83\xa3\xe7\x1e\x35\xf0\x02\x8e\x49\x7f\x7a\x2a\xff\x07\x09\xdb\x95\xaf\xa5\x3f\xe4\x9f\xfc\xb3\xa4\x7c\xc4\x3d\xb2\x72\x85\x34\xfc\xbd\x7c\xc5\xd2\x0b\xaf\x94\x39\x93\xb4\x82\xf9\x2d\xf4\x3c\xf7\x5b\x18\xc7\x76\x74\x50\xce\xd7\x58\x3b\xca\xe6\x49\x84\x6d\xb5\xa3\xa4\x44\xc2\x96\xed\xc8\x78\xc9\xf5\x7e\xf5\x4f\x21\x3e\x0d\x4d\x7d\xaa\xb1\xbe\xa5\x68\x79\xe0\x6f\x47\x85\x34\xca\x6b\xd8\x5e\x3b\x72\x53\x2d\x57\x5e\x13\x99\x80\xff\xe6\x98\x76\xe4\x9c\x83\x72\x93\x5f\xbb\xe2\xde\xdb\xaf\x58\xeb\x7b\xd4\x9c\x9b\x32\x65\x4a\x76\xd2\x13\xe7\x4e\x78\xea\xb6\xf9\x53\xfa\xd3\x35\x07\xb4\x2d\x5a\xcc\xbd\x38\xba\xa5\xb9\xa9\xb6\xd9\x5e\x7b\xd6\x89\x67\x2c\x5b\x74\x92\x77\x54\x4b\x4d\x63\xb2\xce\x5e\x3b\x7e\xde\xd4\x25\x17\x27\x66\x0d\x98\x6f\xb4\x9d\x73\xd9\x37\xd4\xfe\x0f\x72\xf5\x30\x17\x21\xd4\x90\xb3\xba\x60\x1a\xcd\xe6\x48\xd8\xe5\xb1\x13\xbf\xc2\x8b\xc5\x7b\x3f\xb2\x86\x4b\x34\xba\x59\x94\x34\x11\x97\xae\xc2\xf8\xa4\x0b\x73\x0d\x8d\xcd\x89\x8c\x7b\xd5\xe5\xb9\x86\xaa\xce\x51\xad\x97\x0c\x3a\x6f\x75\x46\x3b\x26\xf2\x91\xeb\x56\xd8\x6f\x77\xe6\xa6\xef\xd9\x75\xdd\x0a\xa6\xa3\x56\xf0\x3b\xcf\x8a\xb7\xa1\x18\x9a\x9e\x0b\x39\xb9\x80\xdd\x6d\x31\x55\xf1\x10\x29\x49\xf1\x6a\xbf\x9f\xb7\xba\x4c\x26\xbb\x99\x58\x73\x2f\x11\xc7\xa7\x40\x38\x8a\x6a\x5a\x76\xd8\x3e\xa8\x19\x3d\xe2\x8f\x60\x14\xcb\x4f\xdc\xab\xce\xe9\xc5\xbe\x59\xfd\xfa\xc1\xfb\x53\x17\xf5\x8c\x69\xc3\x33\x4f\x6a\xe2\x8e\x3b\xb6\x78\x00\xff\x9d\x93\x17\x3b\xae\xb3\xd2\x38\x4a\xc2\xef\xf0\xe3\x41\x3f\xc3\x90\xa7\xf5\xe7\x92\xb2\xd9\xc1\xc5\xc4\x98\x19\x27\x42\x81\x84\xcf\xec\x4b\xa7\x1c\x4e\x67\xd8\x14\x0f\x04\x44\x1c\x0c\xda\xf8\xb0\x76\x2c\x3f\x52\x7a\x2c\xbf\xb8\xf5\xac\xec\x00\x47\x56\xdb\x81\xa9\x46\x06\xc1\x74\x1b\x2d\xfe\xaa\x5b\xb6\x68\x8c\x90\xf4\xfb\x20\x16\x8c\x6d\x9d\x3d\x5b\x7a\x86\x93\xf8\x69\x0f\x9e\x7f\xf1\xf4\xe9\x78\xf2\x81\x73\x95\x8f\xc0\x50\xff\x9d\xbc\xf1\xb1\xfc\xe9\x73\x47\x47\x2f\x7e\xf0\x96\xeb\xa7\x2e\xc7\x89\xe1\x6b\xce\x3c\xc2\xe7\x78\x9d\xf9\x14\x68\x7f\x33\xb4\xbf\x95\xdc\xa3\xc9\x37\x36\x66\x90\xc9\x13\x89\xc4\xfd\x8e\x8c\x29\xee\x30\x39\x46\xb5\x61\xbf\xbf\x25\x40\x06\x38\xa5\xdf\x76\xaa\x06\x4d\xe5\x8b\xf7\xd4\xd2\x40\xb8\xa2\x4a\x23\xa8\x7e\x37\x08\x2c\x7d\x0f\x91\x5c\x95\xcd\x69\x17\x13\xd2\xb5\xc6\x71\x98\x6f\x3e\xa0\x25\x5e\x1b\xff\xed\xc3\x8f\xbd\x7a\x84\xab\x65\xf2\x55\xb9\xc3\x42\xb1\xd0\xfc\x59\x7d\x27\x85\xaa\x42\x33\x27\xfe\x52\x38\x22\xe9\x1c\x3d\xbd\xbf\xfd\x96\xc7\x1f\xbf\xe5\xd4\x2b\xc2\x9e\xe4\xf5\x87\xe6\x92\x07\xf6\xce\x6a\x3b\xea\x8c\x45\x47\xb7\xcc\x3a\x64\x4a\xf2\x80\x43\xc8\x1b\xdb\x90\x63\x3c\x0b\xed\x1f\x71\x47\x5e\xdd\xcf\xbe\x23\xef\xbc\x07\xd6\x6e\x1d\xdb\xdb\x3b\x76\xeb\xaf\xf0\xdb\xb7\xae\xc5\x7f\x56\x26\x92\xb7\x00\xf0\x4b\x4a\xd3\xda\x5b\xe9\x18\x35\x01\x8f\x6d\xf4\xac\x73\x5b\xce\x66\x33\xbb\x79\x73\x80\xe7\xa3\x11\x1f\x88\x66\x3d\x24\xbb\x16\x7a\xc1\x83\x7e\x7b\x54\x87\xf1\x5e\x53\xed\xce\x23\x8d\xa7\x76\x0d\x1b\xc6\xef\x2f\x59\x9c\x7f\xf4\xfe\x9b\x81\xf3\x1d\x6d\xad\x2d\x29\xff\x80\xf0\xf5\x2d\xf7\xfd\xeb\x87\xbb\x1f\xc0\xaf\x2b\xbd\xc7\x9f\x80\x0f\x38\xe1\x30\xd3\x4d\x22\xb9\x06\xa4\xf4\x0e\x01\x89\x33\x73\x56\xb3\x85\x37\x93\xc8\x92\x5c\xa7\x5a\xc7\xba\x58\xbc\x43\x20\x8b\xd3\x3c\x24\x74\x7c\x1a\xcb\xbb\xb0\xfc\xfa\x25\xf5\xa6\xec\x95\x3b\x48\x70\x8c\x1f\xbd\xa6\x66\x83\x32\x87\xf6\x69\x36\xd0\xfc\x15\xa5\xd9\x94\xb3\x9b\x24\x5e\x46\x9c\x24\x21\xab\x85\xa7\x43\x27\xeb\x97\x6d\x96\xde\xd6\xe5\xd5\x16\xcd\xfc\xb3\xf1\x51\xca\x4b\x9c\x5b\x59\x8f\x97\xe2\x4f\xaf\xc1\xef\x5f\x7f\xad\x92\xbe\x81\xd9\x3d\xbe\x13\xe8\xfa\xd0\x84\x9c\x5b\xb0\x20\xb2\xd4\xe3\xf0\x78\x6d\x1e\x5b\xc0\xef\x74\x31\x45\xb5\x91\xbb\x82\x38\xd9\xa0\xa8\xe5\xcb\x8a\xc4\x7b\x14\x4d\x99\xbe\x54\xc7\xdd\x32\x37\x55\x7b\x60\xeb\xa2\xb3\x94\x69\xf8\x2c\xe5\x09\xae\x56\xb9\x09\x5f\x8f\x1f\xe9\xa7\x56\xaa\x9b\xb4\xe2\x3a\xa5\x86\xe5\x37\x1d\x78\x1e\xbf\x0e\xda\x11\x80\x28\xfd\x90\x5c\xa4\x0a\x42\x49\x2e\xe8\x72\x71\x82\xc9\x2c\x72\x26\x2e\x11\x0f\x70\x61\xbb\x9d\x13\x25\xc8\xf8\xf2\x55\x66\xb3\x8f\x33\xdc\x71\x48\xcf\x42\xbf\x6a\xa8\xff\xf4\x14\xef\x88\xec\xd6\x5a\x93\xd5\x6a\xd2\x4d\x58\x92\xa9\xf7\x97\xb3\x1d\xb8\xa3\x46\x79\x47\x6b\xdb\x43\xb3\xaf\x3f\xa2\xff\xd4\x15\xe7\x3c\x1b\x69\xc6\xc7\x8e\x4e\x8e\xab\x3b\xab\x17\x3f\x34\x45\x1d\xac\x2b\xce\x9b\xdf\x7f\xf2\x69\x6d\xc7\xe3\xa3\x3a\x46\x77\x33\x5b\x57\x07\x3e\xe3\x6d\x68\x73\x84\xdc\x64\x19\x72\xc8\x76\x4b\xd0\x6c\xb7\xf3\x6e\x77\xb0\x2a\x1a\x0a\x59\x65\xd9\x67\x51\x03\x57\x1f\x1d\xba\xb2\x37\xad\xd4\x08\xb5\x87\xdd\x3c\x6c\xb8\xfd\x9f\xd7\xce\xfb\x93\x05\x7f\x7c\xc1\xc0\xf4\x33\x97\x1f\xf4\xb1\xb2\x82\x3b\xf9\xbb\x5f\xde\xfe\xec\x23\xd7\x3f\xe5\xfe\x8d\xf9\x08\x7c\xd0\x09\x67\x9d\x7c\xc2\x15\xff\xbd\xfe\x6a\xa5\xe0\x7c\xf8\xb2\x07\xb6\x5e\xb7\xd2\x3c\x75\x2a\x7b\x4b\x82\xdc\xb7\xb5\x51\x54\x90\x05\x62\x82\x00\xe4\xce\x1e\xaf\xc3\x21\xf9\xec\x76\x88\x09\x42\x41\x87\xd7\xcb\xbb\x4d\x24\x0d\xb0\x96\x06\x04\x65\xd1\x00\xd9\xee\xce\xb9\x5d\xc9\x0e\x8f\xb6\x4d\x96\x27\x2b\x33\x1b\x1f\xb8\xeb\xa6\x07\xf1\x84\x07\x6e\x55\x5e\xba\x58\x2e\x20\xee\x80\x49\xab\x78\x8c\x85\xf1\xfc\x97\xca\xd7\xca\x8f\x58\xc0\x4e\xce\xa5\xfc\x30\x3c\x1f\xcf\xb9\xff\x49\x3e\xa5\x0c\x3e\x78\x3f\x6d\x93\xb2\x46\x78\x08\x9f\x29\x1d\x01\x79\x82\x19\xf2\x1c\xd7\x66\x09\xb2\x66\x90\xb6\xb6\x8e\x8e\x37\x3b\x3a\xda\x47\x91\x54\xd4\xeb\xef\x86\x2c\x4a\x84\xef\xcd\x5f\x8c\xcb\xbe\x36\x5c\xf3\x1a\xe0\x5c\x9d\x51\xce\x4e\xfe\xe1\xbd\xf7\xe0\xef\xcf\xa1\xc3\x77\x79\xb3\x7e\x3e\xa3\xd2\x39\x67\xdc\x17\x9b\x95\x35\xaf\xe1\x43\x81\x52\x12\x5f\x97\x51\xce\x57\x29\xe1\xc2\x52\x65\x06\xea\x2f\x3c\x8c\x9a\x90\x23\x1f\xf4\x63\x7f\x04\xb5\x65\x87\x5c\xbf\x25\x37\x49\x11\x4b\x48\x1e\xcd\x24\x76\x8f\x7c\xd2\x8b\x02\xd8\x31\x7a\xba\x7d\x9d\xd9\xc6\xfe\xe3\x4e\x48\x64\x12\xf0\x37\xd3\x94\x69\x6e\xed\x30\x65\x0f\xce\x66\x67\x38\x1d\x87\x80\x89\x54\xce\xab\x8b\x47\x9d\x01\x17\x04\xa8\x16\x87\xd7\x6d\xf7\x7b\x5c\x26\x8f\x7f\x54\x55\x26\x5c\x97\x96\x25\x41\x08\x27\x9d\x5e\xa7\xcd\xe4\x01\x19\x52\xee\x15\xfe\x8c\xaf\x90\x64\xe4\x41\x9e\x2d\xd8\xed\xb6\x59\x6c\x64\x5f\xff\x10\x71\x2d\xd4\x3c\x93\xfd\xb2\xb5\x5d\x59\xd0\xae\x89\xdc\x38\x8c\xaf\x18\x3d\x71\xe1\x82\xd3\x27\x5d\xb8\x7c\xf3\x99\x0d\x47\xcd\x3f\xe7\xc0\x5a\xb1\x3b\x5e\x13\xbf\xf7\xa6\x55\xa9\xfa\x14\x91\x49\xe5\x55\xe1\x31\x3c\x56\x7c\x0b\xc6\xc7\xf2\x14\x07\xff\x02\x2d\x92\x7b\x75\x07\xc5\xa4\xf2\x2a\x1e\xf7\xd5\x74\xe5\x33\xe5\x3e\xf1\xf0\xcb\x6e\xba\x1d\x8d\x80\xe7\x05\xc8\xc7\xb2\x6f\x12\xf8\x4c\x77\x30\x89\xc7\x2a\xf7\x29\x9f\x4d\xff\x0a\x8f\x13\x1e\xbb\xfd\xa6\xcb\x46\xc2\x8b\x98\x27\xaf\x90\x10\x78\x51\xae\x23\xf4\x8f\xc3\xfe\xe9\x5f\x29\xaf\x88\x6f\x55\x84\xc7\x22\x87\xda\x86\x28\xbc\x5c\x97\x21\xf4\x5f\xf9\x6a\x3a\xf6\xe3\xe3\xc4\x56\xbd\x3d\xfd\xc2\x56\xbc\x5e\xdc\x0d\x16\x2d\x9c\x23\xcf\xd0\x72\x18\xbe\x20\x9d\x6c\x1b\x52\xdf\x5f\x21\xc3\x12\xec\x06\x7e\x72\x46\x59\xf7\xc1\x6e\x3c\xba\xf7\xf3\x5d\xca\x1b\xe2\xee\x65\x17\xdc\x71\xd3\x25\x2b\xee\x1c\x41\x03\x4b\x60\x34\xe0\x4b\xe6\x4b\x69\x88\x75\xd0\x86\x60\x37\x5e\xaf\xbc\xb1\xeb\xf3\x5e\x3c\x7a\xf7\x07\xe2\xd1\x77\xae\xb8\xe4\xa6\x3b\x2e\x58\x46\x6c\xf8\xb5\xca\x5c\x74\x6e\xe1\x0d\xf0\x53\xc1\x9c\xd9\xca\x99\x44\xc1\x8e\xec\x26\x2a\x24\x6f\x76\xb8\xb6\xc3\x20\xf1\xee\xba\x2c\x4b\x23\xb5\xaa\xd6\x62\xfe\x58\x11\x3b\x5a\x1a\x7d\x96\xb0\xbb\xa6\x53\x99\x8b\x83\x47\xcc\xa8\x6f\x11\x4f\x16\x7b\x7a\xc8\xfb\x77\x85\xb3\x84\x45\xe8\x06\x98\x6b\x89\x8c\x05\x4f\xe6\x06\xe4\x8d\xcf\xf8\xe5\xa0\x3f\x73\x23\x4e\xae\x5d\xab\xbc\x2f\x1e\xf9\xe4\xca\x99\x33\x57\x3e\x49\x6c\xa2\xf2\x3e\x90\xb8\xab\xf0\x35\x7d\x9b\x1f\x7a\x22\x5b\xb0\xd5\x64\xe2\x55\x4c\xd0\xd9\xed\xae\xed\x30\x98\x20\xe9\xdd\x75\x5d\x62\x90\xcf\x06\xbb\xb3\xbc\xf2\xfe\xda\xb5\x38\xb9\xe9\xc9\x55\x33\xfa\x56\x3c\xf9\x3d\x23\xf6\x18\xa3\x4d\xeb\x5a\x59\x65\xae\x78\xa3\x78\x89\xa7\x16\x81\xe1\x75\xcb\xdc\x27\xdc\x87\xc0\xcb\x99\x33\xf3\x5c\x00\x05\x5c\x82\x9c\x69\x72\x77\x75\xb1\x1a\x18\x59\xdf\x59\x25\xcc\x00\xd8\x29\x2a\xec\x89\x1a\xec\x58\x7e\x6c\x27\x5f\x65\x80\xbd\x0a\x21\x71\xa1\xf4\xbf\x00\x9b\xa1\xb0\x77\xe1\x7e\xec\x40\xa1\x2d\x7c\x3a\x2d\xd6\xf2\xc9\xc1\xc2\xd3\xf9\x64\x5a\x44\x04\x03\x91\x6f\x82\xf3\x0b\x7a\xd7\xc0\x5b\x80\x73\x90\x8a\xf3\x00\xd8\x2c\x4b\x9e\x4b\xa5\xdc\xb5\x04\x8a\xd0\x55\xd6\x88\x0b\x69\x7b\x29\x5d\xb3\x87\x27\x05\x31\xe7\x93\x84\xe4\x1b\x45\x92\x8c\x1e\x58\x87\xeb\xc5\x21\x8d\x1e\xc0\x92\x44\xdc\xf6\x0c\x97\x46\xe9\x8c\x55\x05\xa4\x34\x37\x1a\x69\x72\x5f\xb3\x31\x78\x12\xa2\xfb\xc2\xa7\xf9\x74\xaa\x94\xe6\x46\x23\x4d\x80\xbd\x9c\xc2\x72\x99\xc1\xc2\x8f\xf9\x4c\x8d\xd5\x00\x4b\xf6\x17\x5c\x2f\x07\x01\xb6\x16\x21\x57\x1d\xba\x08\x7f\x4a\x70\x4c\x0a\x7d\x0a\x19\xfa\xd5\xda\x2a\x6a\xfd\xea\x83\xb1\xed\x16\xdf\x03\xd8\x83\x55\xd8\x66\x02\x8b\xce\xc7\x21\x0d\xb6\x38\x06\x30\xb6\x4b\xe8\xd8\xd6\xa9\xe3\xb4\x80\x8e\x2d\x07\x51\x6a\x2d\xe7\x1b\x2c\x6c\xcb\xfb\x02\x52\xe9\xd8\xce\x81\xb1\x3d\x9a\x8e\xed\x54\x86\x83\x6e\x65\x63\x9b\xc9\x94\x8c\xed\x12\x3a\x0e\x75\xea\x78\x9d\xc1\xfa\x06\x24\xef\x29\x92\x54\xfb\xb6\x06\xe8\x0d\x69\xf4\x00\x76\x9c\x3a\xb6\xce\x74\xc6\x1c\x28\x19\x5b\x03\x4d\x7d\x6c\xb9\xc0\x60\xe1\xe3\x7c\xc0\x5f\x4a\x73\xa3\x91\x26\xc0\x1e\xcd\x68\x66\xc4\x4c\x4d\x09\xcd\x9e\x12\x9a\xff\xe4\xae\x63\x34\xa3\x83\x85\x1b\xf3\xd1\xaa\x52\x9a\x3d\x25\x34\xff\xc9\x2d\x66\x34\x1b\x83\x8d\x4d\x25\x34\xfb\x4b\x68\xee\xe6\x76\x30\x9a\x91\xc1\xc2\x50\x3e\xe2\x2b\xa5\xd9\x5f\x42\x73\x37\x77\x01\xa3\xd9\x90\x68\x48\x1b\x69\xc2\x3c\x49\x72\x13\xc0\xd5\xd3\x31\x7a\x95\x23\x87\x91\x62\x39\x33\x87\xbd\x5e\x98\x29\x0c\xe3\xfa\x41\xde\xe7\xc7\x56\xa6\x38\xf4\x1f\xf5\x6d\xca\x16\x89\xd0\x9f\x46\x64\x81\x7b\x89\x6f\x2d\x5c\x07\x7c\x56\xa3\xdd\x85\xff\xc2\x9c\xf1\x46\x7d\x28\xe3\xb1\x83\x7b\x15\x78\x44\x9e\xe1\xb0\x9f\x70\xf0\x0f\x16\x0a\x79\x48\x2f\x34\x0e\x5d\x5d\x15\xe8\xbf\xcc\x2f\xdc\x3b\x7d\x18\x17\x89\x8e\x4b\xbd\xda\xd7\x5d\xb4\xaf\xd8\x5b\xed\xb5\x33\xb2\xec\x3d\x4d\x18\x93\x16\x6a\x1b\xa6\xa9\x70\x33\xd8\x98\x24\xdd\xc9\x28\x6f\x31\x8c\xf3\xd2\x12\x7a\xff\xe1\x86\x18\x3d\xbf\xe8\x4f\x95\xd0\x5b\x5a\x42\xef\x3f\xdc\x2c\x55\xbe\xbc\xe9\x51\x25\xf4\xe6\x42\xff\x5d\x8c\x1e\xd5\x9b\x47\xe9\x38\x08\x98\xac\x59\x04\x73\x76\xae\x26\x50\xd3\x8c\xb9\x0c\x97\x4c\x32\x65\xc3\xfa\x3c\x12\x9d\x6b\x11\x3f\xd4\xc6\x41\xd3\x39\xee\x4e\x5c\xc5\x70\xf9\x0e\xa9\x63\x2c\x30\xe3\xc1\x4b\x94\xe1\xc2\xb8\x0b\xb7\x53\x1d\x6c\x50\x75\x70\x0e\xe8\x60\x20\x67\xc7\x76\xbb\x58\x8b\xad\x21\xab\x5d\x36\x6b\x1a\x08\xf0\x69\x30\xe0\x1b\xe4\x00\xc0\x4f\x57\xf5\xef\x42\xdc\x4b\xe1\xc3\x61\xae\x16\x07\xe7\x07\xc3\xa2\xdf\x00\x4f\xee\x18\xf9\xb5\xf4\x08\xc0\x37\x52\xf8\xd5\x78\x27\x9e\x81\x7c\x39\x1b\x4e\x00\xf9\x44\x24\x01\xd9\x1d\x03\x57\xf5\x5b\x99\x21\x1c\x25\xf6\x01\x7c\xaf\x0a\xdf\x06\x73\x09\xf0\x1c\x34\x9d\x6b\x6b\x6d\x6b\xf5\x54\x19\xe1\x89\xdc\x4c\x90\x7e\x0f\xf0\x4d\x6a\xfb\xaf\xc7\x02\x6d\x8f\xd3\x09\x0c\xc0\xb9\x39\x45\xab\xa1\x3d\xe4\xdd\xa1\xf9\xd2\x97\x00\x7f\x88\x0a\x3f\x00\x21\x63\xb1\xfd\x9d\xc1\xb0\x5b\x36\xc0\x13\x5b\x32\x81\xce\x73\x93\x6a\x1f\xb6\xb0\x79\x36\x50\xa6\xef\x02\x83\x1d\x99\x4f\x75\xe9\x10\x15\x6e\x0a\xd5\x3b\x1c\x1c\x2c\x7c\x97\xd7\x89\x1a\xda\xfc\x67\x9d\x26\xc6\x37\x10\x59\xcf\x39\x35\x7d\x72\x63\xb7\x4a\x9b\x29\x93\xde\xee\x61\x9d\x3e\xc6\x35\x20\x29\x54\x07\x63\x31\x0e\x70\xa2\x44\x43\xa2\x2a\x9f\xa2\x0e\x12\xb9\xd2\xdb\xef\x92\xd0\x45\x73\x90\xda\xde\xb9\xc5\xf6\x92\xdf\x1f\x8a\x74\xfb\x61\xec\xaf\x80\xaf\xfc\x7e\x01\xe9\xaf\x13\x39\x83\x25\xfd\xed\x2f\xe9\xaf\x80\xa3\x00\x07\xfd\x0d\x93\x76\x84\x93\x86\xfe\x16\x6e\x53\x96\x72\xf7\x53\x9a\x4c\x2e\xff\x43\xe5\x92\x8d\x61\x04\xf3\x1a\x4d\x15\x8e\xd0\x3c\xb4\x04\x8e\x83\xf1\xa8\x16\x65\x9d\x77\x14\x64\x30\x4b\x6d\x05\xa5\x67\xee\x24\xc5\x37\x54\x9d\x73\xf3\x1c\x9d\x75\xf8\x70\x59\x5c\x22\xa3\xac\x8e\x05\x8c\x61\xe1\x7f\x01\xef\x42\xe9\x47\xc0\xfb\x1a\xfa\x5c\x8b\x16\x42\x18\x24\x99\x94\xf4\x47\xc8\x9f\xb3\xf2\x0e\x07\x82\x61\x34\x99\x98\x86\x74\x11\x66\xea\x5c\xe5\xa9\xef\x6b\x65\x3e\x0f\x13\x3d\x27\xf2\xe2\x76\x13\xf9\xe2\xed\xae\x11\xf2\x75\x1e\x6d\xdb\x0c\x15\x9e\xac\xd0\x84\x48\x0c\x0c\xe2\x65\x1f\x2c\xec\xca\x1b\x31\xd4\x31\x5f\x23\xe6\xe9\xf8\xb4\xaa\xb2\xf3\x3c\x93\x1d\x00\xdf\x99\x2f\x8a\x99\x26\x67\xe7\xd1\x31\x9a\xa1\xc2\x76\xea\xb0\xef\x97\xc1\x12\x9f\x65\xa0\xab\xfb\x2c\xec\x1c\x2c\xbc\x92\x77\x3a\x4a\xe9\x6e\x34\xd2\x55\x7d\x16\x83\x7d\xbb\x0c\x16\xda\x2b\x3c\x40\xe9\xb6\xa9\x6d\x38\x9d\xcd\xa7\xcc\x81\x60\x8a\x46\x9d\x80\x78\x95\xd0\x9c\xc9\xe0\xf0\x6e\x06\x27\x22\x51\x2e\xce\x3b\xa3\x27\xad\x65\xf4\xc0\x8e\xaf\xc6\x07\xe2\x03\x75\xba\x96\x3c\x4c\x8a\x16\x5f\x14\x3e\x53\xd6\x70\x33\xa5\x8f\x19\x4d\x02\x5b\xd8\x81\x57\xeb\xb4\x01\x56\x92\xb8\xa2\xcd\xdf\x68\x6c\xa7\x1e\xe3\x60\xf3\x60\x61\x77\xde\x6c\xd2\x9a\x8a\x28\xdd\x8d\xdc\xcc\x62\x5b\xb9\xaf\x35\x19\x95\x31\x79\x55\xc5\xe8\x5f\x4b\x68\xee\xd6\x68\xda\x09\x4d\xbb\x6c\xa4\xf9\x84\xd2\xcf\x5d\x67\xa0\xb9\x5b\xa3\x69\xe5\xac\xa2\x91\x26\x24\xb0\x49\x2a\x63\xa3\xd4\xb8\xea\x54\x55\xc6\x62\x31\x90\xb1\xf0\x82\x70\x95\x33\x68\x90\xb1\x5f\x00\xfc\x5a\x1a\x63\xf5\xb1\xd8\x8a\xfa\x63\x02\xdf\xdc\xec\xae\xc5\xf5\x8b\xea\x9b\x6c\xd5\x46\x1b\x46\xe8\x53\x1b\x3f\x8a\xd9\x3c\x8e\x57\x6d\x7c\x34\x4a\xe8\x73\xe1\x68\x05\xfa\x43\x1a\x7d\x80\x9f\xa4\xd2\x6f\x6c\x24\xf4\x71\x7d\x63\x29\x7d\x65\x8d\x94\xa4\x63\x32\x8a\xcd\xb3\x50\xcf\xfa\x19\x46\x3a\x65\x35\x8e\x95\xd6\x0a\x33\x35\xba\x00\xb7\x88\xc1\xd5\x8b\x3a\xc5\xa2\x7d\x24\xed\x6d\x57\x6d\xf4\x4b\x6a\x7b\xa9\xce\x39\xb3\x4e\xb7\x64\x2f\x6d\xaf\x6a\x8b\x66\xa9\xf0\x8d\x6a\x7b\xab\xaa\xa0\xbd\x11\x73\xa4\xca\x16\xaa\x68\xd3\xdb\x4b\x6d\x3a\xd8\x38\x8d\xb2\x16\x77\xcf\xa7\xed\x9d\xa5\xc2\xb1\x58\x00\x47\x44\x9d\xa2\xa6\x67\x06\x7a\xaa\x9e\x01\x9c\x1b\xb9\x5d\x25\xf4\x36\x1a\xe9\x01\xdc\x62\x26\x3b\x55\x83\x85\x3d\xf9\xaa\xa8\x46\xb2\xd4\x0e\xb7\xab\x72\xa6\xd2\xf4\x23\xbf\xb3\x84\x66\x7f\x09\xcd\xdd\x1a\xcd\x04\xa1\x99\x88\x18\x69\x12\x5f\xfc\x11\xb5\x4d\x1d\xb4\x3f\xaf\xf1\xe4\x55\xa2\x50\xce\xc1\x73\x49\x62\x35\x93\x96\x64\x8b\x8c\xf4\x08\xab\xf8\xbe\xb8\xec\x00\x9c\xd9\x44\xdf\xc0\x9e\x9d\x5b\xf8\x0e\xf8\xbc\x22\x6c\x54\x96\xa1\xc8\x93\x3c\xe4\x0b\x7b\x72\x96\x4c\x07\x92\x32\x3c\x19\x6e\x2d\xbc\xa8\xc0\xef\x75\x9e\xdc\x1b\x1a\xcf\x59\x04\xca\x90\xfc\x3b\x58\xf8\x67\x5e\x67\x4a\xb9\x6a\x31\x0d\xe1\x4b\x63\x3b\xca\x17\xfc\x5d\xa4\x84\xaf\x50\x47\xf9\xd6\x75\x02\x5f\xa1\xba\x7a\x9f\x7c\x5f\xe5\x7d\x2c\x5e\xe5\xb9\x44\x82\x76\x74\xb0\xf0\x43\x3e\x99\xd2\xfb\x6a\x88\x57\x6f\x92\xfe\xa8\xf7\x75\x18\xdd\x50\x78\x8e\xc6\x20\x51\x88\x41\xa0\xaf\x71\xf0\x6d\x39\x4b\xbc\x9a\xf4\x75\x3f\x3c\x77\xf0\xf5\xda\xd8\xa6\x08\xcb\x14\x79\x9d\xa0\xd2\xd8\x1a\xf8\x29\xf8\x7c\x95\x5f\x12\xf8\x91\xb8\x2d\x2e\x8e\x64\x56\x8c\x21\x5c\xd4\x66\x64\x55\x3f\xb3\x9c\xc9\x3c\x17\x0e\x43\x08\xe1\x97\xfc\x21\x13\x32\xea\x08\x3d\x2f\x4c\x6c\xc6\xe1\x6a\x3e\x76\xb6\x0a\x5f\x57\x07\x81\x55\x7a\x42\xba\xd6\x81\x4a\x6d\x86\xe8\xa2\x3a\x98\x55\x75\xaa\x97\xe5\x66\xc1\x20\x21\x3f\x58\xf8\x63\xde\x1f\x34\x95\xe5\xbd\xec\x4c\xb2\xc6\x83\xe0\xa8\x3c\x48\x72\x46\x22\xde\xcc\x08\x1e\xf7\x50\x1e\x5d\x2a\xfc\xb1\x8c\x07\xed\x02\x04\x4e\xbf\x82\xc0\x49\xb4\x97\xf2\x20\x05\x04\xca\xe3\x08\xc0\x91\xb8\xbb\x4e\x41\xc4\xbb\x46\x22\xa0\xe8\xa1\xc1\xc2\xf7\xf9\x50\x44\x70\x95\xe9\xfa\x3d\x54\x8f\xba\x0c\xba\x0e\xf9\x10\x90\xff\x7d\x91\xbc\xa6\xef\xe4\x0c\x97\x4a\x1b\x60\xb9\x9b\x98\x2e\x01\xe1\xe1\x22\x61\xdd\x67\xdf\x43\x7d\x56\x97\xea\xb3\x96\xa8\x3e\x8b\xd0\x8f\x3c\xc9\x41\x1c\xf4\x97\x9c\x25\x1c\x12\xcd\x19\x2e\x14\x12\x8d\xb2\x42\xf9\xd0\x18\xf7\x08\x12\x87\x70\xab\xcf\xf8\xaf\xce\x2d\xf2\x24\x8e\x50\xc9\x8e\x84\x91\x2b\x03\x41\xa9\x71\xe2\x55\x5b\x63\xe8\x4f\x31\x0f\x0d\x93\xfe\x00\x3b\x43\x7f\x8e\x06\x9f\x66\xe8\x0f\xf8\xb4\x6b\x59\x7f\x58\x2e\x18\x36\xf6\x67\x1c\xc8\xaf\x24\xed\x02\xd8\xd1\xea\x5c\x1c\x07\x19\x3b\xb1\xa1\x24\xb9\xc7\xcd\xde\xe6\x56\xc9\x38\x77\xd3\x40\x76\xe3\x74\x1e\x8e\x54\xf3\x80\x7f\x1a\x7d\x50\xa3\xb9\xb1\xb9\x04\x7e\x1c\x8c\x97\x24\xde\xaa\xd1\x87\x71\x5a\xc1\xec\x59\xb3\x45\xa7\x4c\xda\x31\x0d\x6c\x6e\x9c\xb6\xf9\x48\x15\xce\xc6\xe0\x1a\x45\x9d\xa2\xde\x5e\xaa\x6f\x8c\xde\x1b\x2c\x5f\x24\x31\x74\x47\x07\x89\xa1\x5b\x0e\x6b\x19\x25\xa1\x92\x18\x9a\xb5\xf9\x7f\x75\xda\x6f\x70\x30\x42\x0c\x67\xd4\x28\x10\x50\xdc\xd4\xd7\xd4\x5a\x86\x53\xce\x67\x27\xf7\xa8\xc6\x27\x9b\x25\x7c\xba\xcc\x5d\xed\x95\xf8\x48\xef\x30\x3e\x60\xbb\x10\x7a\x57\xd9\x42\xc7\xe8\x7d\x88\x06\x3b\x9f\xc4\x8d\x83\x85\x1f\x73\xb1\xc6\x06\x5f\x24\xc3\xc5\x3b\xf1\xbd\x9d\x78\x65\x27\x3e\xab\x13\x77\xe6\xcc\xb6\x69\x9d\xb8\xa1\x81\x4d\xba\xbb\x89\xbc\x05\x5d\x9c\x7b\x3a\x86\xda\x1c\x81\xcc\xdd\x85\x67\xe2\x90\x3e\x96\x41\x32\xf6\x7c\x73\x2b\xd8\x0b\xdc\xd4\x54\x9e\x23\xd2\x71\xd5\xe6\x8b\xe0\xa2\x0f\x0c\xe3\x4b\x70\x1b\xb9\xc6\x66\x82\xab\x71\x2f\xe2\x06\xc1\xbf\xbe\x49\xf5\xb4\x5b\x95\x8d\x6a\xd5\x1f\x5b\xad\x20\x1b\x66\x64\xb6\x8a\xc6\x9c\x29\x5c\xf8\x92\xbb\x51\xba\x19\xe0\xe7\xaa\xb2\x61\x41\xaf\xa9\x39\x16\xc0\x07\xcd\xc1\xb0\xe4\x33\xc0\x07\xa1\x6d\x6f\x52\x99\xee\x2e\xcd\x9d\xcc\x24\x97\xd0\x89\xd3\xb6\x84\x41\x77\x6e\x14\xc7\x68\xb4\x41\x6b\xe6\x33\xf9\x08\x8e\xd3\xa9\xd2\x36\x83\xaf\x35\xd0\x2c\xfa\x5a\x2b\xa1\x69\xb5\x94\xd2\xdc\xc8\x3d\x58\xa4\x09\x7a\x72\xb6\x1a\xbf\x54\x87\x43\x25\x34\xfb\x4b\x68\xee\x56\x6b\x30\x24\x6e\x30\x1b\xf2\x13\x37\xc4\x7d\xff\x31\xd0\xdb\x8d\x57\x31\xb8\x58\x73\x2c\x68\xa0\xb7\x4c\x39\x5b\xec\xa5\xf4\xc6\x50\xb8\x8f\xb9\x8f\x59\x1d\x92\xc3\x41\x3e\xe8\x17\x9c\x86\x3a\xe4\x4a\xe5\x6c\xe1\x68\x61\x2c\xc0\xf6\xab\xb0\x67\x69\xb0\x55\xb8\x2a\x12\xb0\x1a\x60\x97\x29\x4b\x4b\xe8\xfe\x47\x8b\x1d\xa2\x28\x5a\xcf\xa8\xaa\x34\x97\x96\xd0\xfc\x0f\xab\x83\xd2\xd8\xe1\xdb\x7c\xa2\x25\x60\x88\xf9\x97\x41\x3c\x62\xa4\xa9\xc7\x23\x61\x1c\xf6\x96\xd0\xec\x2f\xa1\xb9\x5b\xcb\x23\xaa\x07\x0b\x5f\xe5\xab\x43\x25\x34\x41\xb7\x7a\xa9\x6e\x8d\x61\xf1\x08\xf7\x8e\x5a\xf3\x89\x10\xcd\x8a\x90\x4a\x64\xa4\x56\x1b\x06\x56\xf3\x21\xef\x9c\x1f\x4d\xe3\x91\xfe\x0a\xf1\x08\xa9\x93\xd4\x0a\xb5\x59\x53\x20\xc3\xc5\x62\xe5\x72\x5c\xce\x6f\x88\xf6\xa1\x2a\xe7\x82\x84\x31\x46\xd3\xc6\x18\x8a\x55\xa9\xfc\xb4\x60\x44\xe3\x29\x6d\xd1\x78\xa2\x85\x38\x8a\x9b\x59\x5c\xa0\xd6\x57\x52\x72\x2a\x09\x3c\xf9\x64\xb2\x9c\xa7\x03\x7c\xdc\x34\x39\x0e\xb8\x3d\x94\x27\x87\xc9\xa6\x1f\x52\xff\xf0\x81\x2a\xf8\x38\x5f\x92\xb3\x18\xeb\x19\xf4\x9d\x64\x71\x3b\xc0\x0f\xd0\xf1\x5b\x8b\xc8\xe5\x0a\x81\xcd\xd8\x07\x56\xd5\x47\xfc\x90\x01\x83\xd0\x07\x9b\x30\x8d\xce\x4b\x4f\xa9\x5d\xb5\x21\x9b\x83\x2b\xd6\x97\x4c\xa0\x63\x0b\xe9\xbc\x0c\x94\xda\xd5\x32\x38\x0e\x21\x79\x35\x8d\x2b\xc6\xd2\xb8\x62\x98\x3b\x00\x51\x0f\x4b\x7c\x18\x66\x4e\xa6\xca\x1c\x34\xfa\x64\xf6\xce\x38\x8d\x2d\x8e\xa2\xb1\xc5\x81\x78\x19\xc3\xf1\xfb\xa1\xd1\x01\xe2\xc7\x03\x61\x93\xaf\xc4\x8f\x97\xf3\x51\xb8\xbf\xab\xe3\x42\xf8\x84\xce\x0a\x45\x35\x26\x95\x79\x9c\xcf\xd5\xaa\xf0\x84\x87\xff\x78\x08\x77\x7c\xc6\x71\xa4\xf4\x69\x8d\x65\x2c\xab\x97\x70\xe7\x69\x76\x9b\xf4\x04\xb4\x86\xaf\x8a\x30\x16\x9a\xdd\x56\x79\x5c\xad\xf3\x58\x88\x5f\xd3\x70\x48\x4f\x38\x92\x29\x05\x19\x1b\xdd\xd6\x33\x3e\xff\xab\xf1\x81\x5c\xe9\xec\x92\xdc\x0a\x32\x20\xb3\x21\xb7\x52\x79\x0c\x69\x3c\xc0\x96\xee\x50\xfd\x66\x28\x44\x06\x0b\x05\x42\x26\xa3\x6d\xe4\x94\x35\xf2\x6a\x3a\xbf\x63\xd5\x9c\xe9\x0e\xa6\x4f\xac\xce\xa2\x11\x57\xef\x79\x5e\x43\xdf\x7b\x57\x69\xc3\x1c\xab\xf9\xb6\x81\x2a\x19\x1b\x0f\xc8\xe4\x14\xda\xe6\x71\x6a\x1b\x8e\x56\xdb\xcc\x6a\x66\xa2\xdd\xc9\x1b\x6b\x1a\x0e\x3d\xbf\x9a\xa7\xda\xf3\x7f\xa8\x6d\x76\x3a\xdd\xac\xc6\x56\x02\xcf\xe8\xff\x59\xa3\x0f\xb1\xfb\xd1\x65\xf5\x2d\xd1\xad\x62\xe8\xe3\xc8\x78\x5c\xad\xf1\x40\x0b\xd1\xae\x22\x0e\x19\x7b\xc8\xa5\xca\x71\xd2\xc0\xa7\x8b\xf6\x63\xbc\xda\x8f\x23\x68\xfc\x88\x6d\x36\xe8\x86\x65\xb0\xa0\xe4\x2d\x36\xc1\x54\x22\x77\x2e\x88\x51\x17\xd0\xbe\x1c\xad\xf6\xe5\xbf\x6a\x5f\x48\xa8\x85\x83\xf6\x60\xd8\xe2\x31\xf4\x65\x02\xb4\x6b\x3d\xb5\x19\x13\xa8\x9c\x16\x70\x9b\x0a\xef\x72\x01\x13\xb7\xc7\x6d\xe5\x8c\xf5\x51\xfa\xc6\xbe\xf8\x03\xc0\x1f\x43\xe9\xff\x12\xdd\xac\xc3\x03\x7d\xe8\x85\x15\x1b\xe1\x27\x80\x5e\xae\xa7\xf3\x3b\xa1\xd4\xf7\x59\x49\xf3\xad\x76\x95\x38\x7b\xbf\x5f\x59\x43\xdf\xef\x57\x69\x83\xef\xfb\x1f\x1d\x76\x0f\xc0\x62\x03\xec\x04\xf0\x7f\x06\xba\x45\xff\x67\x27\x72\x63\xb7\x95\xd2\xdd\x68\xa4\x0b\xfe\xaf\xa0\xc3\xee\x01\x58\x23\x5d\x52\x27\x32\xd4\xfd\x8a\x74\xc3\x24\xf8\x0e\x87\x8c\x75\x4e\x17\xc4\x01\x77\x49\x17\x69\x7e\x10\xe6\x14\xa1\xaf\xd8\x9c\x12\xe3\xcc\x11\x7f\xa4\xfa\xec\x52\x1d\x94\xce\xd7\xf5\xe3\x6e\xfc\x2d\x44\x0f\xaa\xde\xaa\x38\xfe\x32\x1d\xa4\x73\x2a\x9d\xae\xcf\xe9\xdd\x38\xa9\xc9\x0e\x99\x54\xd0\x75\x4b\x55\x80\xcd\xaa\x8e\x33\x1e\x6c\xfa\x2a\xa9\xc1\xa3\xad\x01\xae\xc2\xe4\x7d\xa0\xc0\x66\x2e\x07\x08\x39\xd2\x97\xdc\x04\xbe\xaa\x68\x67\xaf\x83\xbc\x63\x19\xa9\x7b\xe3\x03\x54\xb9\xc9\xa9\x75\x6f\x5a\xd8\x73\xba\x9c\x6e\xbb\xa4\x4b\x1a\x46\x57\x81\xaf\x39\x55\xbc\x15\x25\xd1\xb4\x5c\xad\xe8\x48\xf0\x21\x57\x3c\x8e\x82\x21\x2b\x18\xc6\x74\xca\xe1\xa8\x0a\x79\xaa\x3c\xc7\x0d\x54\x09\xbc\x74\xfc\x00\x6f\x3a\x6e\x80\xf7\x1a\x0e\x32\x95\x3f\x31\xc1\x2e\x99\xa2\x27\x7c\xd8\xf3\xc4\x9d\xc9\x34\xbd\x94\xd0\x81\xe9\x05\x6c\x28\xd9\x21\x04\xb1\x20\x9e\xaa\xbc\xfb\xed\x19\xcb\x5b\x26\xcd\x5f\x79\x9b\xf2\xd7\x03\x7e\x38\xf5\xc1\x05\xcb\x7b\x94\xbf\xe1\x18\x4e\xbe\x81\xeb\x2e\x50\xde\xc2\x27\xe2\xfc\x1f\xbf\x0d\xbf\x1d\xbc\xf0\xb4\xd7\xb6\xe2\xa6\xfe\x43\x6e\xbb\x7d\xcf\xab\xfc\x24\xdc\x8a\x1b\xd6\xdc\xae\x6c\x9d\x86\xd4\xb5\xd4\x35\xc6\xb5\x54\xbd\x3e\xc2\x81\xf4\x7a\x85\x62\x9c\x33\x1e\x64\xd7\xb0\x8e\x0a\x70\x71\x96\x8b\x74\x0d\x16\xbe\xcc\x77\x75\xab\xe3\xc7\x68\x82\xae\xde\x48\xf5\x88\xad\xcf\xee\x14\x78\x35\x37\x8c\xc7\x49\x42\xe9\xf3\x47\x04\x63\x0c\x49\xe7\x47\xfc\x49\xa7\x6d\xe3\xfb\xa8\x4f\xe1\x26\x4f\x86\x09\xea\x21\xc5\xb6\x9e\x89\xda\x04\xa9\xed\x29\xe3\x61\xde\xc3\xbd\xcf\xe4\x80\xe7\xaa\xaa\x88\x7f\x8f\x9d\x10\xf3\x08\x72\x05\x39\xa8\xd5\xf8\x58\x04\x6e\xbc\x86\x93\x03\x51\xe0\xb9\x03\x26\x1f\x30\x5a\x5b\x11\x56\x71\xca\xf9\x0c\x73\x1f\x69\xf5\x85\xea\x6a\xc2\x07\xfc\xf4\xdd\x79\x5f\x58\x28\xab\xc5\x9b\xcb\x78\x89\x94\x17\xc5\x23\xbd\xe2\xb9\x31\x83\x85\x55\xf9\x31\x13\x8c\xec\x2a\xf5\x4b\xa1\xfc\x68\x1b\xeb\xea\x08\xbf\xfa\xf1\xf5\xe1\x8a\xfd\x3a\x4f\xe7\x25\x15\xfb\x75\xe8\xa1\x84\xd7\x61\x99\xc3\x26\xec\xa7\x5f\x85\x22\x9f\x51\xa3\x08\x9f\x10\x0e\xd5\x54\xe2\x23\x3b\x75\x3e\x72\xb1\x4f\x47\x1e\x49\xf8\xcc\x1d\x2c\xbc\x97\x9f\x3b\x6b\x44\x9f\x88\x8c\x69\xbc\x20\x8e\x2b\xe0\xeb\x0c\xb2\x96\xca\xf9\x79\x50\xf4\x2a\x60\x46\x96\xef\xdd\xa2\x94\xe1\x48\xed\x4f\x8b\xad\x54\x19\x21\xf2\x47\x6d\xed\x14\x9a\xd3\xfc\x92\xc4\x4a\x94\x46\x42\xa5\x31\x69\xec\xa4\x1c\xef\xcf\x70\x63\xab\xc6\x76\x91\xcf\xae\x2e\x77\x19\x8d\xb2\x3e\x5b\x50\xb1\xcf\x64\x15\x9a\xe7\x20\xbe\x4d\x56\xec\x73\x42\xef\xb3\xa9\xd8\xe7\xce\x4e\xd2\xe7\x6e\x52\x8b\xef\x9e\xb4\x9f\x79\xb4\xe0\xff\x0f\x5e\xe6\xff\x4f\x5e\x5c\x91\x17\x71\x5c\x3c\xe7\xc5\xde\x68\x45\x5e\x13\x75\x5e\x96\x0a\xbc\xde\xfb\x19\xbc\xf8\x72\x5e\x35\xb8\xa6\xbd\x22\xaf\x26\x9d\x97\xb5\x02\xaf\x0f\xf2\xdd\xfd\x95\xe5\xc6\xa5\xc9\x0d\x93\x17\xb6\x4e\xc5\xe6\x9c\x18\x29\xa2\xe4\x7c\x10\x05\xe3\x20\x37\xbc\xcf\x57\x59\x6e\x3e\xd4\xe5\xe6\x4e\xec\x55\xe5\x26\xa9\xca\xcd\x81\xe3\x0e\x9c\x42\xe4\xa5\xbb\x01\x7a\x0b\x9f\xa4\x49\xa5\x34\xae\xa2\xf5\x0c\x7d\xfd\x17\x70\x1f\x67\xb1\x96\xdd\x6d\x77\x96\xac\xff\xae\x31\xae\xff\x02\x5c\x23\xb3\xa5\xd1\x50\x34\x66\x5c\xff\x2d\x5d\xff\xe6\x76\xf2\x7f\x57\xe3\x06\x1a\x47\xba\xad\xee\x00\x36\xc6\x58\x74\xed\x9b\xda\xc7\x69\xaa\x7d\x54\xd7\x0c\xb8\xfa\x7a\x30\x90\xf1\x4c\xbc\x46\xa5\xde\x64\x58\x5f\x8f\xe8\xf4\xd7\xe2\x39\xf8\x48\x16\x3f\x03\x79\xbf\xa0\x2f\x5a\x37\x15\x6b\x93\x2d\x34\x0f\x99\xa6\xe6\x21\x7f\x66\xf1\x36\x97\x26\xa5\x3c\x87\xbe\x78\xdd\x54\x79\x8f\xc0\x1e\xee\x8f\xa5\xf1\x76\xf8\xcc\xb0\x03\x97\xc6\x6f\x84\xc7\x79\xd4\x1e\x4e\x2b\xb7\xbd\xb5\xb5\x44\x06\xea\x4e\xac\xab\x62\x6c\x74\x9c\x72\x3e\xc3\xdc\xeb\x48\xdd\x8b\x10\xa1\x59\xa3\x8b\xec\xf1\x70\x8d\xd8\x8b\x10\xa4\x7b\x05\x8a\xbc\x44\xae\x57\x93\x37\x32\x60\x60\xb9\x07\x0b\x4f\xe4\xab\xd3\x46\x76\x95\xfa\xa5\x70\x6f\x68\xfd\x22\x3b\x80\x38\x5c\x33\xa1\xc6\x5f\xa1\x5f\x53\xa8\xed\x9d\xa6\xda\xde\x83\xb5\x7e\x75\x74\x10\x5e\xd9\x19\xd9\xf4\x7e\xfa\x55\xe0\x7e\xab\xf1\x69\x6e\xa6\x7b\x2c\x64\x5f\xa2\x02\x9f\x16\x6a\x7b\xa7\xa9\xb6\xf7\x28\x8d\xcf\xf8\xf1\x84\xcf\x84\xe8\x84\xee\x72\x3e\x44\x6e\x35\x3e\xd4\xee\x5e\x6c\x90\x5f\x52\x07\xf2\x54\x7b\xec\x98\xcb\xd0\xf5\xff\xf2\x7d\x06\x20\xcb\xd4\xde\x4e\x53\xed\xed\x3b\x06\x99\x26\xb9\x77\xc2\x91\x88\xf2\xe6\x0c\x17\x8d\x96\xe7\xc1\xb3\x20\x7e\x0a\x17\xd7\x6c\xb9\x9d\xdc\x64\x55\xbe\x49\x4a\x80\xcd\x21\xb3\x43\x5d\x11\x53\xe5\x1b\xe0\x79\x2a\xdf\x5f\x33\xf9\xe6\x5a\x54\x78\x8f\x07\xe2\x68\xb3\xad\x0c\x1e\xfa\x85\x37\x15\xd7\x98\xd5\xf5\x40\x88\x4b\x45\x12\xef\x16\x97\x1b\x4b\xd7\x25\x0f\x35\xc0\x82\x4e\x1a\x2a\x59\xea\xde\x20\xf1\x23\x5a\xb3\xec\x28\xc9\xa7\xb8\x08\x8a\x54\xc9\xa8\x44\xc7\x6f\xa2\x3a\x3e\xbb\x24\x86\x27\x35\xe6\x42\x3e\x18\x2e\xd9\x73\x53\xba\x4e\x00\x71\xd0\x34\x5d\x6f\x61\x9a\xab\xe3\xd5\x69\x19\x95\xe9\xf9\x4d\x74\x1c\x66\xab\x7a\x7e\x87\x0a\x5f\x53\x03\x8a\x18\xad\x89\x26\x4a\xea\xac\xe5\xeb\x10\x7b\xf8\x2a\x4d\x26\x32\x19\x62\x8b\x6b\xe7\xd7\x46\x65\x34\x42\x8e\x1e\xa5\xba\x31\x5b\xd5\xc3\x25\x1a\x0e\xd9\x41\xc3\x73\xe9\xf9\xe9\x50\x59\x8d\xb3\x9c\xcf\x30\xe5\x43\xf5\x89\xc5\x24\x31\x12\x03\xc5\x46\xac\xb1\x4c\xa6\x6b\x1e\x45\x5e\x22\xcd\xcb\x29\x1e\xe9\x10\x4f\xf6\x29\x3d\x98\x8f\xc4\xa5\x32\xbc\x72\x7e\x4a\xb1\x5f\x2c\x36\x69\x1f\xd7\x9e\xaa\xd0\xaf\x9b\xa8\x1e\xce\x56\xf5\xf0\x7c\x0d\x87\xec\x42\xe3\xb9\xb6\x43\xda\xe2\xfb\xe9\x57\xa1\xc8\xa7\xa7\x87\xae\x1d\x61\xc3\x22\x99\x81\x0f\xd5\xc3\xd9\xaa\x1e\x5e\xa8\xe1\x8c\x19\x43\xf8\xf4\x48\x3d\xd9\x72\x3e\x44\xb6\x34\x3e\xd4\x8f\xed\x56\xf3\xcb\x1d\xaa\x1f\x03\x21\x8b\x22\xf0\x63\x69\x9c\xae\x26\x9f\x24\xb4\x2c\xf5\x41\x54\xee\xa8\x3e\xce\x66\xfa\x88\x39\x83\xfc\x65\xe8\x5e\xc2\x42\xce\x93\x4c\x21\x08\x9f\xaa\x70\x55\x90\x7c\x06\x83\x25\xae\x4c\x1d\x5b\xe9\xf7\xa4\x16\x83\x4f\x54\x6b\x31\x31\x16\x6b\x93\x99\xe4\xd2\xc4\x11\xa7\x6b\x2d\xfe\x92\x58\x1b\xfa\x2c\x6e\x22\xf5\x18\x7c\x92\xba\x9e\x74\x08\xc3\xa1\x4b\x3d\xc0\xf8\xbe\x7c\xb2\xc6\x5c\x5a\xf3\x29\xe7\x33\x4c\x6c\x8f\xce\xa7\x66\xb0\x90\xcb\xd7\xd4\xed\x87\xcf\x81\xe8\x5b\x03\x9f\xd4\x60\xa1\x3b\x9f\xca\x54\xe4\xd3\xa4\xf1\x01\x1d\x9b\xce\x70\xda\xdb\x81\x4f\xdd\x60\xe1\xd1\x7c\x5d\x73\x45\x3e\x3f\x69\x7c\x54\x3d\x03\x1c\x22\x29\x64\x53\xe4\xad\xf9\x4c\x63\x45\x3e\x71\x8d\x0f\xb8\xa0\xd7\x68\xad\x8e\x6b\x02\x36\x4d\x83\x85\xd5\xf9\xa6\x31\x1a\x9b\x2e\x9d\xc7\x76\x8d\x07\xf8\x54\x85\xc1\x37\x00\x8b\x86\xc1\xc2\xf9\xf9\x86\xd1\x1a\x0b\x55\x46\xa4\xdf\x13\xfb\xa3\xd2\x67\xf6\x07\xec\x0a\x4c\xc9\xd5\xf9\x74\x46\xa5\xad\xd9\x20\x71\x13\xb1\x41\x6a\xfb\x75\x1b\x04\x53\xb1\x24\x9f\x4c\xab\x74\xd5\x5a\xee\x1a\x63\x2d\xb7\xb8\xfe\xed\x45\x5e\x7f\x49\x2d\x77\x8d\xb1\x96\x0b\x70\x63\x91\xb6\x1e\xf6\x43\x3e\x14\xd9\x47\x2d\x17\xe2\x97\xff\xa8\xf6\x9a\xec\x57\xc3\x41\x2e\xa8\x16\x56\x55\x3b\x45\x6b\xaa\xd4\xae\xf5\xab\xe3\x7d\xa5\x0a\x4f\x26\x16\x57\xf9\xab\x92\x01\x63\xbc\x03\xf4\xa5\xfb\xa9\xec\x2c\x61\x32\x8a\x1f\x66\x35\x46\x4a\x1e\x8c\xcd\x99\xf9\x58\x42\x28\x9d\x53\xe0\x21\xee\xa4\xb2\x73\xb6\x2a\xa3\x17\x30\x1c\xe2\xf1\x31\xc8\xdb\x7a\x90\xb7\x94\xab\x04\xa7\x9c\xcf\x30\x1e\x63\xe0\x53\x3d\xa8\x14\xf2\xd5\xc9\xfd\xf0\x39\x10\xbd\x6b\xe0\x93\x19\x54\x7e\xc8\x67\xea\x2b\xf2\x69\xd2\xf8\xc0\x78\xfd\x97\xe1\x90\xa5\x1b\x0c\x93\x36\x90\x4f\xd6\x56\xe4\xf3\x93\xc6\x07\xc6\xec\x7a\x86\xd3\xde\x4e\xb6\x65\x0c\x16\x4e\xcd\xd7\xb7\x54\xe4\x13\xd7\xf8\x80\x8c\xde\xc0\xea\xc9\xe0\x0c\xa0\x69\x85\x23\xf3\x99\x0e\xc1\x20\xa3\x8c\xc7\x76\x8d\x07\xc4\x89\x5e\x06\x4f\x56\xf5\x9a\x07\x0b\xa7\xe4\x9b\x7b\x34\x16\x5d\x4c\x96\x24\xba\xb7\x4b\xa5\xaf\xad\xaf\x92\x29\x99\x93\x8f\xc5\x05\x83\x8c\x82\x3c\x89\x3b\x89\x3c\xa9\xed\xd7\xe5\x09\xa6\x62\x72\xbe\xa6\x36\x65\x58\x8f\xa4\xb5\x3d\x5a\x1f\x1e\xaf\xce\x43\x8a\xf5\xd5\x6c\x66\xb5\xbd\xa1\xbc\xc5\x5e\xb1\xb6\xf7\x9e\x56\x07\x82\x79\x58\xcd\x70\x02\x01\x52\xda\x1b\x2c\xdc\x90\x0f\x46\x8a\xd5\x3d\xc6\x07\xda\xd4\x45\x75\x61\xbc\xa1\x7e\x0e\x6d\xb2\x10\xdf\xad\x97\x0f\x8b\xf4\xa9\x3e\x00\x7d\x17\xa9\xc5\x5e\x67\x68\x6b\x93\x5e\x87\xdc\xc9\x17\x6b\xba\xd0\x58\x87\xc3\xe1\x2d\xb6\x54\x6f\xe7\x4f\x5a\x3b\x61\x1e\xa7\xab\xf0\xc4\x05\xe2\xa8\x39\x9a\x28\xa9\x41\x32\xfa\x71\xbd\x8d\x1c\x44\xee\x74\x4e\x3c\x40\xdd\x43\xda\xe9\x89\x6b\x0c\x8a\xf4\xb7\xeb\xf5\xb0\xb5\xe8\x77\x6a\xad\x3c\x0e\xe4\xe3\xd6\x78\xb3\x46\xbe\x18\xeb\xbf\x25\x8d\xf2\xd4\xf2\xd4\x76\xc8\x6b\xb0\x03\xcd\x27\xb6\x8f\x6c\xf7\xe1\xda\x06\x0b\x7f\xcd\xb7\xd5\x4a\xae\x72\x7b\x59\x82\x33\x84\x3e\x67\x38\x4d\x4d\x0c\x67\xfd\xfe\x71\xee\xa3\x7c\xa8\xef\x27\x9c\x78\x82\xf6\x7c\xbe\xad\x8b\xa1\x95\xee\xcb\x30\xe2\x6d\x28\xe2\x11\x6e\x3f\x1b\x6f\x1d\xee\x1d\xc1\xef\x87\x7c\x5b\xe7\xfe\xf0\x36\x16\xf1\x74\x7e\x7b\xc5\x93\x2f\xd2\xf1\xee\x47\x3f\x96\xf2\xeb\x19\x2c\xfc\x26\xdf\x73\xf0\xfe\xf0\x36\x15\xf1\x18\xbf\xbd\xe0\xd1\xbc\x9b\xc6\xb1\x24\xef\x96\xe4\x35\x57\xd1\x1d\xf6\x2e\x17\xaa\x2d\xad\x89\x19\x60\x86\x2a\xc0\xc0\x1f\xe9\x79\x71\xc8\x55\x87\x6a\xe8\xce\x61\x49\xbe\x8f\xf8\x83\xcd\xa4\x9c\xc5\xc0\xf6\x06\xb7\xa1\x22\x9c\x6f\x04\xdc\x3a\x1f\x83\x8b\xc5\xf6\x0d\xb7\xb1\x22\xdc\x14\x02\x27\x07\x0c\x70\xf7\xf7\x31\xb8\x48\x64\xdf\x70\x9b\x2a\xc2\x1d\x56\xf8\x9c\x7f\x8c\xce\xef\xa9\x4c\xde\xd1\x7a\x18\x6f\xb6\xd7\x01\x14\x24\x6b\xce\x36\x5a\x8c\xb9\x45\x39\xfc\x10\xfa\x15\x95\x75\x4c\xb6\x53\xe3\xec\x60\xe1\xeb\xbc\x11\xa3\x22\x8f\xfb\x28\x0e\xcd\x53\x69\x44\x41\xd0\x3e\xce\x67\x7b\x18\x5a\x71\x4e\xcb\xf1\x36\x14\xf1\x08\xb7\x9f\x8d\xb7\x0e\x7d\x05\x78\x34\x7f\x54\xf9\x8d\xce\x8e\x31\x22\x55\xc0\xd9\x58\xc4\x51\x79\x8d\xc0\x29\x7c\x07\xf2\xf4\x5b\x3a\x67\xf5\xe8\x35\x36\x7a\x05\x3b\xa2\x3b\x2f\x6d\xb6\xa2\x4c\x55\x80\x1b\x2a\x44\x47\xc2\x11\x99\x92\x8f\x65\x70\x5c\xbf\x41\xf6\x48\x3a\x5f\x26\x7b\x65\x70\x1b\x7e\x26\xdc\xba\x9f\x09\xb7\xb1\x22\xdc\x22\xb2\xbf\x8e\x8e\xd1\x69\xaa\x6d\xcc\xa9\xb2\x42\xf6\x64\xe1\x74\x57\x3a\x52\xb2\xb7\xb0\x1c\x7e\x08\x24\x91\xc1\xc7\x89\xf1\x4d\x7b\xf7\x03\xaf\xdb\x44\x8e\x32\xe0\x30\xc4\x7a\xff\xca\xa7\x1b\x18\x52\x71\xbe\xcb\xf1\x36\x14\xf1\x08\xa3\x9f\x8d\xb7\x0e\x1f\xab\xcd\xb9\xca\x6f\x4c\xba\xde\x88\x54\x01\x67\x63\x11\x47\xe5\xb5\x17\x1c\xf9\x04\x1d\xe7\x7e\x18\x87\x43\x8c\x7c\x5a\xc2\x2d\x63\xf7\x83\xb3\xa9\x88\xc3\xf8\x54\xc0\xc1\xa0\xf3\x22\x9d\xc7\x26\x5d\x1e\x83\x15\xe4\x6c\x24\xdc\x50\x21\xb3\x17\x79\xbc\x85\xc1\xed\x57\x1e\x4b\xe1\xf6\x2e\x8f\xa5\x70\x7b\x97\xc7\x52\xb8\xca\xf2\xe8\x27\x70\xd4\xc6\x69\x70\xf7\x27\x19\x5c\x20\xb0\x6f\xb8\x4d\x15\xe1\x7e\x81\x10\xfe\x37\x9d\xdb\x45\x0a\xf5\x21\x2f\x52\xcb\x46\x17\x76\x7d\x83\x85\x0f\xf3\x3e\xab\x60\x5c\xaf\x2c\x87\x1f\xfa\x2d\x85\xa7\x8b\x9b\xec\x18\x50\x09\x7c\xe1\x15\x84\xb8\xe9\x06\xf8\xfb\x5e\x51\xa5\x94\x70\xa0\x27\x87\x76\xe6\x7d\x11\x86\xa2\x4a\x29\xb5\x1f\xe5\x78\x1b\x34\x3c\xc2\x69\x1f\x78\x5f\x00\xde\x12\x03\xde\xba\x2f\xca\xf9\x7d\x4d\x56\x66\xf6\x8b\xb7\xf1\x8b\x72\x7e\x95\xf1\x36\x03\xde\xf9\x54\x66\x19\xde\xfd\x2f\x1e\x62\xe4\x57\x3d\x58\xf8\xdf\x7c\x75\xd3\xfe\xf1\x36\x69\x78\x8c\xdf\xde\xf0\x88\x1c\x73\x17\x52\x39\x69\x2e\x97\x77\x41\x28\x95\xf7\x32\x38\x5d\xde\xc9\x41\x07\xa3\xbc\x0b\x26\x06\x57\x26\xef\x1a\xd8\xde\xe0\x36\xfc\x4c\xb8\x75\x3f\x13\x6e\x63\x45\x38\x3f\x81\xa3\x72\xdc\x5c\x26\xef\xfb\x83\xdb\x54\x11\x8e\xd5\x84\x46\x69\xb5\x1a\xb0\xe7\x31\x66\x9f\x69\xcd\x92\x4b\x98\x12\x41\x69\x44\xfd\xcd\x00\x3f\x84\x93\x2c\xce\x25\x7b\x9d\xb9\x04\x09\xbe\x8d\x18\x15\x79\xdc\x87\x3d\x5a\x3c\x47\x98\xf0\x04\xed\xa3\x7c\xa2\xb6\xbc\xc6\x55\x8e\xb7\xa1\x88\x47\xb8\xfd\x6c\xbc\x75\xb8\x83\xd9\x67\x9d\x1f\x97\xc8\x48\x95\x6a\x63\x45\x9c\x8d\xb8\x5d\xc3\x51\x79\xe1\x72\x9c\xc2\x17\x90\x4b\x4e\x85\x39\xab\x45\x1d\xf3\x99\xe4\xf1\x54\xa2\xb8\x74\x1a\x69\xe7\x33\x3e\x2a\x83\x19\x2a\xc8\xe5\x30\x30\x46\x9f\xcb\x05\x3a\xf7\x1d\x5c\x55\x49\xbc\xa9\x01\xa9\x32\x32\x02\x6e\xc3\x5e\xe1\xce\x61\x70\x24\xbb\xd5\x65\x6e\xff\x70\x1b\x2b\xc2\x91\xda\xc4\x1c\x6a\x0b\x2e\x50\xe3\xc3\x61\x16\xef\x91\xd1\x24\x9b\xe3\xfe\x0d\x73\x2e\xa3\xf2\xdc\xbc\x04\x67\x08\x7d\xc7\x70\xe8\x11\x04\xc0\x79\x77\xff\x38\xf7\xa1\x4f\x34\x1f\x4e\x85\x91\xa0\x6d\x83\xf9\x2e\xaf\xa1\x96\xe3\x6d\x28\xe2\x51\xa9\xfc\xb9\x78\x2c\x1f\xa2\xfe\x55\xe5\x97\x4a\x64\xca\x6a\x9b\xe5\x38\x1b\x8b\x38\x2a\xaf\xbd\xe0\x50\xdb\x76\x81\x9a\x07\x7d\x81\x0e\x31\xf6\xab\x91\xa4\x94\x8d\xdd\x15\xdb\x67\xc0\xdb\x54\xc4\x63\xbc\xf6\x82\x47\x7c\xfb\x09\x74\x5e\xc7\xb3\x93\x8f\x45\x5b\xe7\xf5\x96\xf9\xf6\x77\x19\x1c\x39\x31\x63\xb0\x61\x1a\x18\x83\x3b\x18\x21\xd3\x01\x0c\x8e\xec\x92\x23\x72\x72\x70\x05\xb8\xc2\x37\x40\xef\x5a\x6a\x73\xc6\x6b\x36\xa7\x22\xbd\x59\xa0\x13\xcc\xb7\x2c\x63\xf2\xc4\x99\xd4\x98\xb0\xa5\x05\x84\xa3\x43\xe8\x68\x08\x19\xcf\xb3\x94\xc3\x0f\x61\x85\xc9\x12\x4d\x4f\x3a\x06\x0b\x9f\xe7\x8d\x18\x15\x79\xdc\xc7\xd5\x6a\xf3\x44\x98\x70\xb8\x43\xee\x18\xc3\x70\xf4\x79\x2a\xc7\xd9\x50\xc4\x61\x39\xc3\xcf\xc0\x59\xc7\xa5\xca\xf8\xf0\x1d\xdd\xfb\xc1\xd9\x58\xc4\x51\xf9\xec\x05\x87\xca\x02\xc3\xb9\x9f\xb3\x6b\xb1\x20\xe3\x33\x1e\x8d\x9f\xbe\x1f\x9c\x4d\x45\x1c\xc6\x67\x24\x4e\xe1\x23\x90\x9d\x01\x62\xaf\xf8\x79\x93\xe9\xdc\x28\x3f\x30\xc9\x69\x6d\x2d\xda\xb4\x32\x18\xcd\xa6\x19\x60\x88\x6c\x99\xdc\x44\x66\xf8\x79\xf8\xc7\x12\x3f\xaa\x01\xe9\x32\x58\x06\xb7\x61\x6f\x70\xf2\x15\x2a\xdc\x99\x25\x7e\x74\x7f\x70\x1b\x2b\xc1\x51\x59\xbd\x82\xc8\xaa\x0e\x77\xff\xcf\x84\xdb\x54\x91\x2f\xad\x59\x88\xbb\xf4\x9a\xc5\x36\xf4\x20\xab\x97\xd3\x9a\x51\xdd\x60\xe1\xf0\x7c\x5d\x63\xa5\xfa\x4f\x11\x87\xef\x51\x6b\x7a\x0c\xa7\x76\xb0\xf0\x59\xbe\xb6\xa1\x0c\x87\xe6\xa8\x14\xe7\x54\xda\x9a\x6d\x8b\x91\xae\x09\x4d\x83\x85\xcd\xf9\xa6\xd6\x91\xb9\xba\x0e\x0f\x3c\xd0\x7b\x6a\x6d\x8d\xa2\x34\x4e\x6c\x6c\x29\x81\xa7\x39\x07\x85\x3f\x4d\xed\xc7\x8f\xac\x66\x48\xd3\xbb\xe8\x60\xe1\x4f\xf9\x68\x75\x31\x63\x2b\xe6\x84\x45\x1c\xe8\xc7\x02\x95\x07\x45\x8a\x1c\x1d\x89\x95\xe4\x78\x09\x12\x33\x53\x78\x16\xeb\x6d\xbb\x14\xe9\x31\xb6\x6d\xb0\xf0\x8b\xbc\xcd\x39\x32\xc6\x2e\xc2\xf3\x3d\xff\x36\xec\xb6\xb4\xba\xad\x8e\x22\x74\x31\xde\x20\xf0\xaa\x2f\xd7\xfa\xc0\x42\x9a\x10\xb9\x50\x22\x14\xad\x14\xa3\x14\x71\xa0\x0f\x39\xd6\x07\x86\x14\x6c\x0c\x46\x4a\xe2\x20\x6a\x9b\x69\x9b\x2e\x50\x79\x3c\xca\xc6\x89\xfa\x44\xe0\x71\x29\xf0\xa8\xe4\xdf\x8a\x38\xea\x7c\xb3\x3d\x0d\xa4\x20\xeb\x0b\x46\x4a\xd6\x3a\xa9\xfe\x52\x78\xa6\xbf\xdb\xf0\xcb\x8c\x07\x35\x93\x60\xfc\xef\xcf\x37\xb6\x54\xb2\x7b\x45\x1c\xbe\x87\x3b\x54\xe5\x41\x91\x1a\xa6\x36\x34\x97\xd8\x56\x72\x56\x5e\xaf\xed\xb9\xea\xc0\xb7\x7f\x85\xe6\x03\x9e\xcc\xd1\x75\xbe\x27\x39\x60\xf3\x5c\xce\xd2\x98\x01\x39\xe4\x8c\x47\x21\x2a\xe0\x0e\xa1\xdf\x96\xe2\xb6\x0d\x16\x7e\x99\xb3\xb4\x11\xb9\xa7\x32\xbd\x0f\xdc\xfb\xd0\xc7\x06\xdc\xea\xa7\x78\xc2\xf8\xd6\x9c\xb5\x91\x54\x31\x79\x9d\x33\x45\xaf\x84\xbf\x61\x04\x3e\x30\xbf\x25\x67\x6d\x63\xf8\x1a\xf7\xbd\xe2\xaf\x23\x75\x89\x72\xfc\xb7\x01\xbf\xf3\xe7\xe1\x6f\xdc\x37\x3e\xa9\x5b\x8e\xc4\x97\x57\xea\xf8\xf7\xc3\xb8\x9f\xa6\xe3\x97\xd6\x48\x9f\xac\x54\x23\x2d\xc3\xdf\xf4\x7f\xc4\x67\xf7\xc3\x0c\x69\xfb\x86\x20\x76\x5d\x49\xe5\x45\xe6\xfe\x81\x4a\x2a\xa2\x15\x60\x87\xca\x61\xb5\x94\x9c\xd8\x5f\x65\xae\xb1\x86\xe9\xaa\x25\x76\x9f\xc0\x0a\xee\xca\x35\xd4\x11\xf0\x1b\xfe\x8f\xf0\xeb\xca\xe0\x4b\x6b\xa5\x23\xe1\x37\xee\x13\x7e\x0a\x81\x2f\xd6\x4c\x01\xfe\xfe\xbe\x52\xf8\xb2\x1a\xeb\x08\xf8\x4d\xfb\x84\x5f\x44\xee\x19\x90\x66\x30\x5b\x49\xc6\x1d\xb0\x2e\x25\xf0\xf4\x3e\x18\xb2\xdf\xa4\x3a\x5d\x1d\x06\x73\x89\x47\x9e\xd7\x28\xc7\x1d\x1a\x81\x9b\xf6\xa4\x89\x71\xc6\x23\xcf\x47\x32\xdc\x51\x3a\x2e\xad\xab\xe9\xb8\xd5\x4f\xd1\x14\xfb\xd3\x9c\xb5\x9a\x54\xc8\x38\x9d\xb9\x2e\xaf\xe5\xf8\x1b\x4a\xf0\xa3\xb4\x26\xe5\x8b\x33\x64\x8d\x3b\x43\xae\xcc\x9f\xd6\xd9\x4a\xf1\xab\xc7\x56\xd7\x57\x60\x5e\x19\x7f\xe3\x48\xfc\xf8\xfc\x78\xfd\xbe\xf9\x53\x7d\x61\xf8\xa4\xfe\x76\x9a\x8e\xbf\xbf\x3a\x5c\x29\xee\xa6\x12\x5c\xca\x5b\xc5\x62\x85\xb9\x32\xde\x85\x2f\x40\x46\x0c\xb5\x36\xaa\x6d\x3c\x93\x42\xba\xcb\x68\x44\xad\x78\x04\x3c\xad\x15\xef\x0d\x9e\xc8\xb8\xb1\x56\x56\xd4\x39\x71\x7c\xe5\xda\xda\x08\xf8\x0d\xff\x47\xf8\x75\x65\xf0\xe1\xf0\xbe\xe1\x37\xee\x0b\xbe\xf0\x0d\x81\x2f\xd6\xe6\x88\xce\x95\xc1\x97\xd4\xe8\x2a\xc0\x6f\xda\x17\x3c\x9a\x05\xe3\xa9\xc7\xdb\x64\xf4\x49\xbe\x41\x47\xf3\x04\x55\x6f\x5a\xc4\x96\x7a\x3b\xe8\x0d\x39\xab\x59\xaa\x37\xe5\xb8\x43\xf8\x1b\x03\x6e\xe4\x49\x92\x7e\xfc\x3d\x67\xe9\x68\x21\xe8\xc4\xc5\x1a\x7c\x5c\x39\xee\x7d\x24\x6f\xd1\x71\x89\xce\xb5\x10\x64\x6b\xcb\x18\x3b\x11\x1d\x8d\xb9\xae\x73\xe5\xf8\x1b\x4a\xf0\xa9\xdc\xb5\x5a\x5b\x19\xb2\xc6\xda\x28\xf3\xe5\xf8\xeb\x38\xff\x48\xfe\xdf\x01\xff\xee\x9f\xc7\x7f\x63\x09\x3e\xe3\x9f\x6a\xed\xde\x37\x7f\x2d\xff\xa0\x3a\xf7\x0d\x3a\xa4\x84\xff\xf8\xc1\xc2\x27\x39\xeb\xf8\xe9\x15\x48\x54\xc0\xdf\xb4\x6f\x7c\xed\x26\x2d\x1d\x1f\x03\xbe\x9e\xa7\x50\xad\x0b\xaa\x5a\x74\x01\xd3\xa2\x9a\x9a\x62\x4e\x53\x06\x4b\x73\x9a\xca\xb0\x44\xbe\x8d\x39\x8b\x41\xdf\x3a\x54\xf9\xeb\xe8\x28\xd3\x87\x32\xf8\x0d\xfb\x83\x37\xe6\x30\x06\x1f\xa7\xe5\x50\xed\xed\xfb\x86\xd7\x7c\xdc\xba\x4a\xf0\x54\x7f\x0c\x39\x4d\x51\xdf\x84\x8a\x39\x55\x05\xf8\x4d\xfb\x82\x57\xf3\x9a\x0f\xb5\xbc\x86\xbb\x53\xcb\x6b\xe8\x1e\xa5\xfa\xc1\xc2\x60\xbe\x7e\x54\xc5\x5c\xa8\x4f\xc7\x59\x8d\xf9\xc2\x7f\xc9\x5e\xa0\x7a\x86\xf2\x6a\xbe\xbe\x4e\x32\xec\xb3\xa0\xf1\x8f\x96\x3b\xc1\x7c\x6d\x43\x6a\x9f\xb9\x51\x2c\xf6\x84\xf4\xe9\x98\x9c\xa5\x96\xc6\x9e\xda\x5d\x68\xc6\xd8\x93\xec\x0d\x52\xf3\x2e\x86\xe3\x7c\x92\x6b\x1f\x2c\x6c\xcd\xb7\x37\x49\x2e\xe3\x3e\xa2\x12\x3e\x10\xb3\x87\x0c\x38\xa1\x67\x11\x57\xf8\x20\x67\xc9\x34\x94\xb2\x31\xf6\x69\xbb\xde\xa7\xb5\x88\x9c\x67\x85\x3e\x91\xe4\xbb\x95\x54\xec\x5b\xc7\x8d\xec\xd3\x76\x8d\x17\x83\x37\xf6\x89\xe0\xe4\x2c\x14\xa9\xbc\x4f\x6c\xcf\xb9\x4b\x3f\xab\xc0\xf6\x7f\x93\xfc\x85\x6c\x39\x37\xec\x6e\x47\x06\x78\xe9\x5e\xfd\xfc\xc9\x6a\xfc\x0b\x3c\x85\xb4\x8d\x1c\x48\xf3\x0e\x16\x7e\xca\x7b\x3d\x1a\x02\x81\xb7\xd0\x75\xf3\x5d\x1a\xbc\xbc\xad\xc0\xee\xa2\xe1\xb4\xd2\x8e\x46\xb3\x08\xc3\xf7\x14\x96\x33\x18\x8f\xa7\x2c\x96\xd4\xcf\xd2\xa8\x31\xa4\xed\x19\xae\x2a\x53\x15\xd0\xce\xd2\x20\x8c\x3e\x15\x9a\xf1\xef\xc5\x21\xe0\x5b\x95\xb3\x9a\x80\xb0\xd9\x6c\xb3\x9a\x45\x84\xda\x86\xb4\xab\xac\xe9\xa5\xba\xe4\x8e\xf0\xf4\x44\xdc\x95\xee\xc2\xbf\x4f\x8d\x5e\xdd\x36\x66\xa1\x38\x74\xcd\x21\x17\xcd\xec\x59\x30\x69\x1b\xa1\xf3\xad\x32\x17\x7f\x53\xb8\x04\xd9\x51\x4b\xce\x8a\xac\xa2\xd5\xe9\xb0\x99\x72\xf4\x9d\xcd\xa7\x06\x4c\x3c\xfb\x60\xef\x0d\x45\x42\xae\x37\xf5\x67\x0c\xc4\xe2\xc3\x41\x13\x70\x16\xdf\xee\x0f\x39\x92\xcd\x5d\xd3\x8e\x58\xf7\xcf\x64\x50\xba\xdc\x3a\x6b\xea\x1a\x54\xb9\x9d\x16\x8b\xd5\x66\x26\x17\x72\x0e\x75\xfc\x1f\xda\x59\xf8\x46\x78\x9c\xdb\x2c\xe6\x51\x18\xd5\xe4\x9c\xfe\x80\xc9\x1c\x88\x9a\x23\x7e\xbb\x59\xb4\x7b\xc8\xad\xa7\x6f\x76\x6c\x77\x6d\x67\x77\x09\xab\xd7\x25\xb7\x72\xe4\x66\xdb\x34\x79\x2f\xab\x9a\x23\xef\xf2\x64\x1d\x1c\xfe\xac\xbe\xef\xd0\x29\xd1\x4c\x83\xe5\x62\x53\xd3\x9c\x29\x0d\xb3\x0f\x39\x30\xd2\x5c\x63\xbe\x48\x6c\x9e\x23\x3c\x9e\x6e\x48\xb7\xe5\x4e\x39\x75\x5c\xaa\x31\x35\xb6\xf3\xc4\xd3\x26\x90\xf6\xf3\xc0\xf7\x43\x6e\xb3\xec\x01\xbe\x31\x94\x44\x93\x73\xd5\x91\x58\xb2\x3a\x56\x6d\xf6\x07\x02\x69\x93\xd9\x9c\x82\x26\x20\xe4\xf1\xc4\x45\x7b\x34\x1e\xaf\x26\xb7\xa7\x02\x7f\xe8\x1a\xb9\x89\xd7\xd8\x24\x4f\xf1\x22\xe7\x4a\x2d\x23\xef\x66\x24\xc9\xdb\x19\x7b\x6f\xe1\xbc\x57\x86\xcf\x7b\x49\xb2\x94\x37\x53\xf9\xeb\xdb\xf0\xa7\x18\xc3\x69\x75\x06\xaa\xf3\xaa\x7e\xb0\x18\x8e\xde\xe3\xb0\x35\x67\x89\x54\xdb\x82\xa5\x37\x45\x68\xb8\x82\x16\x3b\xab\x38\x23\x69\x82\x7e\x1f\x6b\xa0\xe9\xcf\xd9\xf0\xec\x70\xac\x94\x5e\x71\xdd\x98\xea\xea\x69\xaa\x6e\x93\xda\x13\xd9\x53\x94\x82\x34\x3b\xe5\x4c\xb5\x69\x25\x0f\x43\xdc\xaf\xc1\x03\x1f\x99\xd9\x11\x15\x8f\xec\x15\x1f\xe5\x1c\x35\x01\x18\xd1\xfb\x47\x4a\x63\x90\x03\x11\x92\x6e\x15\x77\x91\xb5\x79\xb5\x4e\xbf\xed\x41\xb5\x62\x82\x6a\xb1\x7b\xb0\xb0\x38\xef\x76\x63\x5c\x62\x4f\x67\x96\xe3\xf0\x3d\xb7\xd2\x31\x72\x0d\x16\x2e\xce\x59\x5c\x2e\x80\xa7\xf8\x86\x31\x6a\x03\x9c\x37\x29\x4e\x93\xc6\xe7\x46\xea\xfb\x34\x38\x80\x39\xa8\x1c\x86\xef\xb9\xa6\x1c\xa6\xe4\x8e\x35\xaa\xe3\x7f\xa7\x3a\x8e\x43\xf1\x90\x47\xbf\x38\x8b\x43\x48\x68\xe6\x2e\xa7\xba\xe3\x42\x8d\x39\x8f\xcd\x49\xf5\xdc\x69\xf6\xb8\xad\x76\xab\x5d\x55\x22\x7a\x95\xab\x7a\x91\x32\x7b\xe6\xc3\x6b\xd0\x25\xbe\x2b\xe9\xf5\x7f\xcc\x14\x8a\x8b\xbe\x8b\xf1\x41\x45\xb5\x52\x9e\xc3\x89\x8c\xf2\x4e\xb2\x12\x2f\x6b\x91\x17\xb0\xb2\xfe\x2c\x5e\x5d\xde\xa4\x9f\x57\x79\xe1\x89\x07\x61\xfc\xae\x91\x57\x12\xd7\x64\x14\xd2\x4f\x0e\x74\xaa\x19\x74\x2a\x00\xbc\x6a\xd0\x94\x5c\x9c\x59\x85\xda\x4c\x22\x99\xac\xf5\xfa\x7c\x99\x44\xc8\x67\x35\x5b\xac\x31\x0b\x7c\xb9\x42\x45\xc6\xe4\xad\x2b\xa3\x4a\xd1\x47\xe6\xca\xad\x47\xa6\xb2\xe2\xff\x41\x6d\x16\xda\xab\x7a\x15\xdb\x3a\x79\x84\x25\x00\x1f\x7f\x13\x34\x7c\x2e\xf5\xd9\xb4\xc6\xc6\xdd\x39\x44\x25\xcc\x62\x71\xd3\x5b\xda\x9e\xcd\xdb\xfd\x25\xeb\xd8\x9f\x01\xfc\x4c\xea\xaf\x19\xfc\xea\x1d\xc4\x5b\x63\x3b\x03\xff\x20\x6f\xb7\x69\xe0\x2c\x86\x20\x77\xcd\x9d\x2c\x7b\x19\xbc\x7a\xd7\x1c\xf1\x22\x97\xe3\x36\x94\xca\xf9\xf8\x60\x90\xdc\x36\x47\xd8\x71\xd8\x61\x75\xd8\x05\xb1\x98\x82\x69\x79\x51\x45\x1a\x7c\x0f\x72\xfe\x1f\x68\xdc\x09\x34\x1e\xa2\x7a\xc8\xda\xbd\x76\x3d\xdd\x39\xe8\x85\x76\x7b\xc9\x65\x74\xde\x44\x69\xbb\x9f\x06\xf8\x73\x65\x8f\x5e\xab\xbc\x75\x2b\x42\xc9\x9c\x95\xe7\x30\xdb\x8a\x46\xb0\xfe\xaa\x63\xa9\xcc\xd4\xbc\xef\x79\xc0\xbd\x84\xfa\x64\xba\xfb\xca\x2c\xbc\xc4\x2a\x71\x82\x20\xd6\x92\xbb\xe1\x9c\xb8\x64\x8f\x54\xe1\x53\x80\x9f\x41\xef\xd0\x61\x67\x42\x56\x17\x5e\xc5\x07\x52\x9b\x22\x13\x04\xa4\x5f\xbc\xa6\xda\x14\xd0\x57\x3e\x47\x75\xb1\xb9\x54\x5f\x65\x59\xd7\xc5\x99\xe5\x30\xd4\x0e\x18\x60\xca\x74\xa3\x39\xe7\x15\xe1\x57\x16\xbb\xdd\xe5\xf2\x58\xa8\x22\x72\x48\xd2\x65\x14\x6b\x92\xa9\x6a\x47\xda\x17\x08\xa6\x5b\xf1\x04\xac\x6a\xe2\xc2\x31\x6d\xab\xdb\xeb\x34\x4d\xdc\x36\x69\x41\xcf\x41\x2b\x66\x5d\xa3\x6b\xe2\x08\x3d\x04\x87\xce\x59\xac\x4e\xe7\x5e\x59\x55\xe0\xc4\xf4\x90\x71\xd2\xf4\xb0\xc8\x69\x2f\x7a\xd8\x9b\xf3\x82\xfe\x89\xc8\xc2\x21\x1e\xb4\x30\xc3\x59\x62\x3e\xab\x75\xb0\xb0\x2d\xe7\x36\xdb\xa6\x59\xac\x16\xab\x94\x70\x39\x43\x5b\x43\x5c\x08\x9a\xf0\xce\x31\x1d\xdb\xd9\x83\x8f\xae\xed\xa4\x19\x38\xdb\x41\x1f\x68\xeb\xa0\x1e\xae\xd8\x96\xbd\x69\xa3\xda\xb8\x7d\x69\xa3\xd6\xe2\x91\xda\x68\xa8\x15\x7f\xa8\xd5\x8a\x21\x86\x0e\xa0\xe2\xde\xdd\xf0\x60\xe1\xad\x7c\x38\x59\xb1\xbe\xdc\xa7\xe3\xb0\x7b\x5f\x41\xba\xc3\x0c\xe5\x9d\x7c\x38\xa4\xa1\x14\xd7\x25\xbd\x0c\x9e\xfa\xd3\x1b\x71\x1b\x3d\x97\xfe\x17\xe0\x55\xf7\x0c\x4d\xa3\xe9\x2a\xbb\x92\xb3\x26\xe2\xb2\x37\xc3\x16\xc3\x0d\x79\x9e\xee\xa3\xca\x68\x31\x1a\xb4\xc6\xdd\x0e\xda\x59\xf7\x0c\x4f\x96\x94\xe9\x1d\x26\x40\x2b\x12\x06\x5a\x1c\xed\x4a\x25\x5a\x4b\xc1\x57\xde\x4f\xeb\x5c\xe7\xa8\x7b\x12\x9a\xd0\xa5\x24\x7f\x20\xa7\x6f\xc8\x5a\xca\x8f\xf9\xba\x6a\x6b\x69\xdf\xcb\x71\x86\x80\x2b\xc5\x49\xa7\x19\xce\x57\x23\x71\xd8\x78\x6d\xd7\xc7\x6b\x2d\x7a\x83\xc6\xe7\x6c\x5b\xf0\x60\xe1\x6f\xf9\x78\xf3\xc8\xf1\xf2\xe8\x35\xff\x5b\xd1\xe7\x48\xb3\x06\xdd\xdd\xd4\x1a\x00\xd6\x5f\x74\x2c\xdd\x1a\x14\xb4\x3d\xcb\x2e\x7d\xcf\xb2\x40\xef\x02\xd3\xf6\x6f\xdb\x48\xc0\x6d\xf3\x95\xed\xdf\x66\xf7\x39\xdc\xab\xef\xa3\x5e\x8d\x0f\xa7\x31\x3a\xb6\x31\x94\xe1\xbc\xcd\x6a\xd8\xe7\x5c\x18\x06\xdf\xfc\x0a\xd5\xf5\xf1\x54\xd7\x89\x7d\x3d\xae\x42\xbd\xe8\x6c\x84\xe4\x06\x15\xee\x1b\x66\x13\x9e\x2d\x81\x52\xf7\x2b\xfe\x95\xd6\x70\xb2\x65\xfb\x15\x39\x9f\x4f\xa3\x85\x78\x64\x15\xee\xe5\x9f\x10\x77\xa9\xf7\xf4\x13\xeb\x81\xb1\x45\x32\xdb\x2d\x66\x8b\xd3\xc1\xcb\x56\xab\x45\xa2\xb7\xf6\x83\xe6\xbc\xa9\x1f\xe1\x57\x9f\xeb\xa2\x26\xa3\x5b\x8b\x0c\x7f\x24\x36\x63\xc9\xdf\xf6\x1c\xfb\x96\x70\x2f\x33\x17\x2e\x1a\xf9\x55\xe0\x41\x9e\x77\xff\x99\x3c\xa8\xb1\xc8\x68\x3c\xfa\x88\xb5\xc0\x51\xc6\x84\x59\x0a\xc6\x84\xc6\xf2\x6b\x81\xf1\x2e\xca\xa7\x2e\x17\x11\x24\x59\xe4\xae\x99\xe7\x14\xb1\x53\x6c\x13\x27\x89\xc7\x89\x2b\xc5\x7b\xc5\xdd\xa2\x0c\x0e\xfb\x98\x25\x4d\x84\x8f\xd6\x05\xbc\x8c\x34\x5d\x6b\xb5\xa1\xf6\xa1\xad\xc3\x10\xdd\xc2\x6f\xaa\xf5\x04\xb5\x6e\xd4\x30\x58\x78\x22\x67\x69\xa0\x75\x23\x72\x2e\xa2\xbc\x6e\x44\xee\xfc\x52\xd7\x70\x64\xfe\x78\x16\x3f\x75\x26\x3b\x5b\x43\xc5\xbb\x0e\xcb\x78\xf0\x3d\xdc\x91\x06\x1e\x24\x76\x9d\x55\xdf\x5c\x4a\xbf\xab\xb8\x46\xb4\x5d\xa3\xcf\xad\x25\xf7\x97\x53\x3f\x43\xce\x4d\xb4\xe3\xf6\x89\xda\x12\x91\x91\xcf\x76\x8d\x0f\x83\x2f\xa9\x9f\x11\x9c\xf2\x8e\xb0\x71\x38\xb8\xf0\xb9\xec\xa4\xb2\xd6\xa1\xee\x41\xde\xb6\x9e\x4a\x51\x55\x95\x2e\x6b\x5f\xd1\x3d\x32\xbb\xb4\x3d\x32\x90\x37\x76\x33\x49\x8b\x46\x75\x3f\x76\x30\xc8\x6c\x92\xd0\xe1\xe7\x61\x8b\x81\x0e\xae\xab\x2b\xd2\xa1\xeb\xd2\xbb\xb4\x75\x69\x9d\x8e\x01\x06\x75\x40\x6c\xfa\x2d\x39\x43\xc4\xcf\x7b\x9f\xf5\x21\xc0\xc6\x76\x54\xcd\xa8\xc6\xa8\x45\xcf\x3f\xff\x22\xdc\xcb\xc5\xa8\x2c\xb8\x37\x0b\xe0\x79\x79\x90\x30\x26\x5c\xe4\xb5\x15\x22\x54\x7f\x21\xb2\xa4\x49\x11\xc5\x79\x07\x72\xc1\x97\xa8\x6f\xab\xce\xd9\x38\x33\x68\x82\xd9\x6c\xb5\x71\x92\x05\x50\xb3\xda\xcb\x7e\x2c\x9e\x2b\x7a\xb3\x97\x98\xaf\x28\x3a\x04\x2a\x8b\x85\xb7\x94\xdd\xa8\x51\x94\x41\xfa\xdd\x9b\x31\xc7\x91\x97\x12\x55\x9f\x48\x1f\x43\x74\x37\xce\x11\xe5\x1f\xfe\x29\x85\x08\x6c\x02\x60\xff\x2e\x5e\x89\x1c\x68\x54\xce\x6f\x83\xd1\x91\x04\x8c\x9d\x0e\x8e\x33\x99\x64\x6c\x15\x45\xb3\xcc\xd2\xb6\x36\xfa\xfe\x07\x7b\x92\x46\x7b\x57\x31\xed\x96\xeb\xba\xeb\xba\x83\xdd\x41\x39\x28\xd7\x35\xce\x59\xd9\xfd\xc8\x23\xea\xdf\x95\xca\x6e\x71\x60\x55\xf7\xfa\x87\xc7\x3c\xfa\xe8\x98\x87\xd7\x77\xaf\x22\xbc\xfe\xa2\xec\xc6\x4f\x03\x2f\x0b\xea\xcc\x05\x4d\x3c\x8f\xcc\x1c\x34\x4d\x14\x25\xc9\x2a\xc8\xe4\x72\x58\x0b\xe9\x2e\x7b\x2d\x59\x65\x55\xf2\x10\x11\x70\x4b\x43\xf3\x93\x75\xdd\xf8\xe9\xf7\xbb\x2f\xff\x7e\x36\xee\xbd\xbc\x5b\x78\xe4\xed\xee\xe5\x3f\x9e\x21\x7e\xb8\x7c\x0c\x79\xd7\xe1\x50\xe8\x4f\x3d\xe5\x01\xfd\x31\x09\x82\x64\xe6\x79\x49\x42\x18\xfa\xc2\x9b\x79\x33\x30\xd1\x38\xa8\x7d\x31\x3c\xc7\x05\xc4\xa1\x1f\xd0\x9b\x64\xfd\xec\xef\x2f\xef\x7e\x1f\x78\xe0\x5e\xe8\xc8\x4d\xcb\xbb\xdf\x7e\x77\xcc\x72\x3a\xb6\x7b\xf0\x36\xe1\x2c\xf0\x8e\x3c\xe8\x88\x99\x17\x91\x80\xd1\xb3\x03\x18\xb5\x35\xa9\xe3\x0b\x4a\xed\x17\x84\x73\xf0\xb6\x9d\x3b\xe9\xbc\x4e\x04\xf8\x4e\x0a\x1f\xc8\x59\x10\x27\x88\x14\xfe\x37\x68\x52\x93\x2e\x10\x49\xff\x44\xfe\x5b\x86\x80\xe1\xef\x36\x13\xda\x17\xbc\x1b\xe0\x4d\x48\xa7\x5f\x02\xcf\x69\xed\xa1\xf0\xac\x41\x46\x78\x90\xe1\x0d\x60\x78\x0f\x03\xdb\x2c\xe1\xcb\x68\xdc\xf8\xb9\x82\x84\x2b\x0a\x73\x40\xc7\x26\x23\xa4\xfc\xe8\x92\xc8\x27\xd0\x5d\xcd\x4f\xc2\x1b\xc4\x4b\x60\x1c\xd3\x10\x69\x59\x2c\x90\x88\x58\x6d\x26\xcb\xda\x79\x82\x69\xfd\x3c\x81\x27\x45\x0f\xc3\xab\x60\x5e\xf2\xee\x5a\xd6\x81\xfd\x59\xf7\xea\xce\x31\xcf\x4c\x3c\x68\x25\x3f\xe9\xe5\xa5\xcf\x1e\x36\xe3\xe1\x69\xca\x4f\x25\xf4\xcc\x28\x03\x36\x58\x06\xa3\x2b\xcb\x16\xab\x2c\xac\x9f\x67\x92\xd7\xce\x33\x19\x08\xea\x2f\xcd\x91\x37\x8d\x61\xb6\xf1\x86\xf6\xf1\x5b\x2e\x5b\x89\xe3\xc2\x0b\x4b\x9f\x9a\xb3\xfe\x56\x2c\x10\x7a\x57\x2b\x2f\xe3\x8d\xf0\xa3\x05\xd5\x43\xf4\x2e\x08\x26\x19\x21\x93\x09\x9a\x68\x06\x6a\x84\x2a\x4c\x89\x81\x20\x7d\x15\x53\x4b\x84\x80\xe6\xc6\x6c\xcf\xb3\x93\xa6\x5e\x82\x13\x93\x2f\x1c\x9c\x79\xe8\xfa\xe9\x40\xc9\xd8\x46\xe8\xb3\x80\x39\x13\x36\x59\x61\x4c\xd7\x0f\x98\xb9\xb5\x03\x66\xbd\x89\x3d\xfa\x9b\xb5\x3e\x55\x0f\x1f\x5d\x79\xd9\x96\xf1\xed\xe2\x25\xca\x9e\x5b\xd7\x1f\xfe\xf4\xd2\x97\x21\x56\xbd\x8d\x9f\xc4\x2f\xa0\xe3\xe7\x47\x07\xe5\x6a\xe8\x08\xba\xfc\x7e\xaf\x15\x59\x5d\xe4\xca\x62\x2b\x0a\x04\xfd\x16\x32\xa0\x5e\x13\x19\x52\x27\x19\xd3\x2c\x79\xb4\x9a\x3d\x5c\x0d\x6c\x8e\x3b\xf6\x98\xe2\x4b\xf2\xc4\x1d\xe9\x63\x9c\x2c\xfe\xc8\x1d\x38\xba\x67\x0b\x8c\xf7\x70\x56\x1f\xf7\x8b\xb7\xb0\x71\x37\x4c\x40\xb1\x3d\x66\xe4\x45\xd3\x73\xb5\x82\x49\x32\x9b\x4d\x0e\x8f\xcb\xeb\xf5\x20\x8f\xcb\x03\x2d\x32\x79\xfc\x3e\x87\x40\x66\xc4\x2d\x93\x39\xf1\x98\x2a\xb7\xa8\x44\x25\xf5\x59\x12\xf5\x9f\xf8\x05\xd9\xb1\x83\x57\xc0\x7c\x29\xb3\x3b\xc6\xb1\x89\x7b\x71\xe9\xb3\x7d\x64\xe2\xb6\x2d\x7f\x7a\x36\x9d\x40\x68\x8f\xf2\x32\xbf\x80\xce\x9f\x1f\xcd\xc8\xd5\xd1\x19\x84\x31\x72\x38\x9d\x5e\x0f\x0c\x13\xf2\x62\xab\xe4\x35\x05\x82\x3e\x33\x99\x51\xa7\x40\xe6\xd4\x4b\xde\x56\xd9\x57\x83\x46\xcc\xb3\x58\xfc\x91\x5f\xd0\xd9\x33\x38\xae\x57\x6b\x17\x0c\x15\x8e\x4f\xbe\xf0\xd9\x19\x53\x1f\x3d\x14\x0b\x2f\x5d\xfc\x74\x1f\x0c\x15\x11\x2d\xd0\x91\x65\x30\x56\x67\x8b\x97\xb8\x6a\xe5\x8f\xbf\x42\x2e\x59\xfe\x18\x6f\xa7\x32\x7c\x75\xe1\x7c\xfe\x53\xb0\xd1\x56\x34\x36\x17\xb0\x9a\x41\x25\x64\x49\xe0\x79\x3b\x44\x52\xa2\xb0\x6d\xc0\x02\xfe\x7d\x10\x07\x9e\x9e\x27\x93\x37\x4b\x27\x19\x1b\x6a\x78\x5b\x17\xf3\x69\x5e\xec\x12\xf9\x24\x9f\xf1\x73\xf7\x04\xee\x0a\x28\x79\x7c\x68\x15\x2a\x54\xe1\xc3\xf8\x6d\x3f\x6d\x11\x7a\xa3\x43\x31\x7c\xa1\xf2\xcb\xd8\x10\xe5\xf9\xcb\xc2\x39\x94\xa7\x1f\x2d\xc8\xd5\xf0\xc8\x07\xa9\xa0\xd5\x61\x12\x05\x9b\x0c\xae\x51\x14\xbc\x1c\xe7\x12\x84\x60\xc0\xe6\xf5\x78\xb7\x0d\xd8\x61\x26\xa1\x05\x39\xdb\x3c\x97\x09\x73\x78\xdb\x80\x0c\xc6\x1f\x7e\xf1\xd4\x3c\xe8\x98\xde\x20\xf2\x24\x7a\x49\xd3\xdc\x9a\x90\xb9\xd9\xdd\x48\xa4\x79\x59\x68\x5e\x86\xf7\xc2\x3f\xde\xb4\x17\x7e\xe1\xc5\xef\x29\x8f\xe1\x23\x5c\x7f\x71\xe1\x23\x94\xc7\x22\x11\x3c\x47\x79\x1c\xfe\xa3\x3c\x8a\x8f\x8c\xf0\x7f\x22\x6d\x9e\xaf\xdc\x1d\x1b\x8a\x2a\x6f\x28\x6f\xc2\xff\x94\xbb\xf1\x7c\xf8\x1f\xce\x92\x3e\x1c\x80\x97\x73\xab\xf9\xd7\x61\xdc\xbc\x5b\x90\x64\xb7\x99\x41\x97\xda\xb2\x6d\xaa\x41\x33\xbe\x29\xc9\xad\xde\xb0\xf4\x82\xc7\x1f\xbb\xf0\xa2\x27\xb8\x07\x96\x6e\x78\xe2\xa2\x8b\x1e\x7b\x0c\x2c\xdb\x07\x30\xd0\x21\xdc\x0e\x3f\xc9\x40\xa3\x35\x17\x80\xb0\xce\x24\x0b\x48\x30\xf1\x36\xbb\x19\x8b\x82\x78\x17\xe8\xbb\x40\x1c\x15\xe9\x95\xf1\x41\xd4\xf6\x51\x49\x77\xf1\x4b\xfc\x1e\x27\xf6\xf4\xe3\xea\x3d\x87\xe3\x04\x6e\x57\x7e\xa7\x7d\x6b\xbe\x49\xf8\x03\xf8\xec\x50\x8e\x78\x5f\x8e\x93\x20\xdb\xa3\xcd\xc4\x9a\x7f\x20\xbe\xc7\xdf\x78\x38\x7e\x47\xb8\x94\x38\x9c\x99\xc4\xdf\x1c\x06\xfe\xa6\x81\xe2\xf9\x9f\xe1\x11\xf8\x1b\x62\x48\x34\x2c\xaa\xb5\x49\x40\x53\x0e\xc3\xef\x1c\x2e\x5c\x3a\xf3\xc7\x6a\xf1\x26\xe6\xa3\x3d\x80\xf7\xa5\x78\x19\xf4\x28\x91\xb3\x23\x8e\x13\x79\xde\x84\x45\x11\x82\x0a\xea\x9f\x8a\xde\x89\xf9\x25\xc2\xfa\xcb\xed\x73\xb6\xe3\x77\xf8\x3f\xfc\x54\x2d\x7c\x88\x9f\x32\xd0\x20\x6f\x22\xfb\x2d\xa2\x08\xb8\x40\x89\xe7\x6d\x40\xc8\x62\x91\x78\x33\x79\x26\xca\xe8\xb8\x4b\x7d\x1d\xed\x4e\x52\xa3\xab\x9c\x87\x57\x6b\xb4\x67\x2a\x9f\xa1\x12\xfa\xad\x39\x1f\x96\x24\x93\x60\xb5\x9a\xcc\x66\x1b\x44\xcd\x90\x8b\x9b\x79\xa1\x8c\xbc\x4e\x9d\x07\xaa\xb4\xdf\xf0\xf5\x25\x5e\x0d\xa4\xdf\x01\x1e\x42\x1c\xfb\x67\x2a\x33\x08\x0b\xa4\xed\xb7\x23\x7f\x5c\x92\xfc\x16\x7c\xc8\xa8\xa1\x30\x2c\xff\x45\x24\xbe\xcc\x81\x22\x28\x83\xda\x21\x77\x99\xc6\x59\x73\x05\xa7\x24\xf9\x0f\x1c\x3b\xb6\xb3\x39\x9d\xae\x8d\x71\x3c\x78\x73\x3e\xc6\xdb\x26\x74\xda\x3a\xa7\xf7\xb6\x1d\xdc\x7d\xf0\x96\x81\x86\x5c\x47\x6e\xcb\x40\xb4\xa3\xbb\x63\x70\x5e\xa2\x3b\x6c\x0e\x6d\x19\x10\xcc\x83\xf3\x04\x0f\x7c\xca\x9c\x84\x43\xe7\xf6\xe2\x53\x7a\xf1\x91\xbd\xb8\xa7\x17\x37\xf5\xe2\x58\x2f\xb6\xf7\xe2\x6f\x7a\xf1\xc7\xbd\xf8\xa5\x5e\x9c\xef\xc5\x0f\xf5\xe2\xab\x7a\xf1\xb2\x5e\x7c\x46\x2f\x9e\xd3\x8b\x0f\xee\xc5\xbe\x5e\x2c\xf5\xe2\x05\x3f\xf4\xe2\xcf\x7a\xf1\xbb\xbd\xf8\x77\x14\xee\x81\x5e\x7c\x6b\x2f\x66\xe4\xa6\xf7\xe2\x71\xbd\xb8\xa5\x17\x7b\x7a\xb1\xd0\x8b\xbf\xed\xc5\x7f\xeb\xc5\x3b\x7b\xf1\x23\xbd\xf8\xae\x5e\xbc\xba\x17\x2f\xef\xc5\xf3\x35\x72\x0d\xbd\x38\xda\x8b\x81\xda\xbf\x7a\xf1\xdb\x95\xb8\x32\x6a\x29\x8d\x71\x37\x23\xf7\x7a\x2f\xce\x9d\xf9\x5c\x2f\xbe\x83\x12\x3c\x9b\x12\x64\xdd\x60\x04\xed\x94\x26\xb4\xf0\x8f\xbd\x78\x7b\x2f\xde\x42\x9b\xb7\xb4\x17\x2f\xea\xc5\xc7\x68\x34\x6b\x7a\x71\x80\xd2\x2c\x6b\xe1\xb5\x5a\x47\x8e\x34\x50\x93\x31\x58\x55\xc3\x9f\x25\x25\x7f\xce\x36\xfe\x29\x81\x2b\x85\x3c\x7b\xef\x80\x2a\x04\x9a\x34\x09\x1c\x2a\xb9\xa1\x4d\xb7\xe9\xba\x5d\xa7\xb7\xb4\x15\xcd\x12\x7c\x75\xd0\xf2\x49\x32\x8d\xb3\x99\x84\x5b\xb3\x18\xb8\xb3\x96\xbd\x96\x9a\xed\x18\x2d\x56\xfe\x35\xde\xcb\xaf\x57\xbc\xc2\x37\xef\xd8\x73\x2f\x8e\xdd\x74\xdd\xb5\x37\x5e\x8b\xb9\xf6\xf1\x93\x3a\xb3\x13\xc7\x75\x72\xa7\x19\x7e\x75\x40\x36\x3b\x09\x7e\xd5\x3c\x02\x4a\xbc\xc4\xa2\xdc\xf9\xf8\x73\xcf\x6c\xda\xb2\x49\xb9\xf3\xe2\x33\x17\x5c\x7a\xf1\x99\x8b\xde\x31\xfe\xe6\xf4\x15\xf0\x1b\xfc\x0f\xe5\xce\x8d\x83\x25\x40\xd4\xa6\x1f\xc1\x5f\x84\x77\x80\x2f\xe6\x21\xd6\x77\x60\x90\x67\x0e\x89\x10\xb7\x3d\x32\x0f\xf3\x5a\x9c\xc7\xf4\x28\x8a\x93\xfc\x11\x39\xdc\xb1\x96\xbf\x88\x93\x87\x7f\x20\x3a\x03\xb8\xfc\x26\xea\x9b\xbe\xa5\x99\xf5\xb7\xf8\x5f\x74\xfd\x11\x0b\x83\xf8\x5f\x79\x41\x42\x9c\xbe\xfe\x58\x78\x9e\xbf\x48\x48\x03\x6c\x9d\xfc\x6d\x61\x01\xcd\x24\xbf\x25\xb6\x14\x3c\xda\xb7\xf4\x26\x59\xd2\x96\xa3\xd1\xb5\xdc\xa1\xfc\xe3\xc8\x84\xda\x73\x21\x89\x03\x3f\x8c\x4c\x9c\xc9\x0c\xd6\xe3\x8b\x79\x1c\xe8\x3c\xfa\x62\x9e\xb4\x1b\x85\xa9\xf3\xc8\x36\x19\x5f\x25\x04\x47\x8b\xbb\x70\xd6\xcf\x63\x3f\x3e\x56\x51\x30\xf7\xb9\x82\xd1\xb5\xf8\xb4\xa9\xf8\xac\x8c\xb2\x46\xb9\x2d\x4d\xe9\x1f\x03\xf4\x0f\xd3\xe8\x8b\xe0\xe5\x11\x27\x21\xc9\x6c\xe1\x4c\x5f\xcc\x93\x25\xb0\x7b\xc0\x66\x04\x7d\xed\xad\x59\x52\xa3\xcf\x02\xf9\x63\x30\x52\xbe\xc4\xa8\x80\xae\x4d\xe3\xd3\xf0\x99\x19\xe5\xc6\xa9\xca\x6d\xcc\x86\xbc\x08\x96\xc8\x47\xc6\x03\xec\x3f\x8c\x07\x12\xe8\xdd\x36\xee\xa7\x78\xce\x32\xc8\xb5\xe4\x2d\x56\x4e\x3d\x73\x09\xf6\x6c\x85\xb8\x81\x6f\x96\xe6\xb0\xd8\x1d\x89\x58\xe0\xf0\xb3\x03\x5c\x31\x76\x27\x6f\x40\xf2\xcd\x7b\x66\xf3\x1b\xc4\x0d\x0f\x81\x6d\x27\xf7\xa3\xff\x8e\xce\x93\xf7\x19\x2c\xf0\x22\xb4\x3c\x44\x9e\xa8\x67\xd0\x4d\x18\x67\x37\xbd\xce\xaf\x7c\x1d\x20\x04\xf4\x0a\x30\xf8\x07\xf8\x69\xe6\xa3\x9c\x10\x63\x65\x90\xc9\x06\xc3\xc9\x5b\x9d\xbc\x2c\xbb\x5d\x08\x99\xb1\xc9\x64\xb6\xdb\xcd\x36\x9b\x19\x3c\xb7\x19\x32\x3c\xa7\xe0\x21\x5a\xe0\x56\x9f\x7c\x54\x1f\x7e\x64\xf7\x15\xba\x83\x30\x08\x41\xea\x76\x92\x6e\x6c\xf8\x7e\x85\xbc\xfd\x5a\xfc\x16\x9e\xc2\x11\xe5\xe3\x9f\x66\xe0\xb0\xf2\x09\x9f\x24\x3f\x2b\x8b\xc9\xcf\x06\xfb\xed\x84\x78\x25\x22\x38\x9d\x76\x11\x02\x4e\x1b\xb6\xd9\xed\x2e\xab\x93\x2c\x62\x08\x76\x99\xa7\x56\x5c\xcd\xef\x0c\x86\xbc\x68\xcb\xb3\xee\x34\xa4\x10\x69\xfa\x7c\x3e\xb1\xe7\xdb\xc1\x59\x6c\xdf\xae\xd9\x73\x70\x15\xaa\x45\xe7\x74\x7e\x3c\xf3\x48\x58\x96\xcd\x66\x0b\xf8\x44\x8b\xc5\x06\x99\x18\x59\xc9\xa0\xcf\xd2\x55\xf6\x48\xc4\x67\xf0\x6e\xe6\x34\xee\xc1\x63\x95\x57\x67\x11\xa7\x41\x78\x28\xf7\xe0\xa7\x54\xb7\x81\x0b\x2e\xe0\xf1\x15\xf0\x20\xfe\x56\x20\x9e\x40\x82\xa0\x4d\xcd\x6e\xb3\x1d\xd4\xb1\x41\x68\xd5\x38\xe7\x55\xfc\xf7\x57\x21\x75\xab\xc5\x67\x2a\x6b\x90\x8e\x77\x35\x92\x88\xbf\x05\x1c\x70\xf0\x20\x2c\x82\x08\x29\xd3\x08\x7f\x4b\xda\x10\xc5\x40\xe3\xab\xaf\x54\x8f\xf8\xac\x32\x15\xfa\xe7\x06\x1a\xbb\x21\xb7\x94\x20\x6a\xed\xc8\x05\x20\xb3\xc4\xb2\x28\x22\x92\x5c\xca\x66\x0b\x7c\x09\xd8\xa4\xfa\xc4\x91\x19\x2c\x6d\x1a\x49\x2e\xbb\xeb\xe4\x60\xe3\x9c\x57\x76\xef\x7e\x65\xce\x8a\x15\x2b\xa0\x8d\xe2\xe6\x77\xdf\xdd\xbc\x79\xc9\x92\xc5\x46\x9f\x6b\x27\x3e\x57\xb0\xdb\xad\x26\x8b\xc5\x6a\x75\x80\xdc\x40\xca\x24\x58\x8b\x3e\xb7\x74\x04\xb5\x79\x32\xce\x52\x48\x9f\x24\xe5\x6e\x6d\x8e\x50\x9a\xdb\xc2\xdd\x41\xf3\x63\x37\x1a\x9f\x8b\x49\x2e\xce\x29\x72\x16\x13\xc6\x22\x24\x02\x82\x53\xf8\xc7\x80\x49\x74\x3a\x21\xf8\x7e\x07\xbf\x8b\xb4\x87\x8c\x0d\x76\x59\x4d\x48\x68\x1d\xa2\x2b\xd9\x45\x5a\x00\x13\x2d\x39\x71\xb6\x8b\xeb\x78\x46\x59\x8f\xc7\xff\xcf\xa9\xca\xc7\xd6\x48\xd5\xb5\x6f\xf0\x93\xaf\xb9\xe6\x66\xbc\x49\x99\x76\x0d\xfe\xb5\xb7\xad\xf1\xa5\x97\x88\x3d\xe8\xe2\x1e\xe7\x56\x81\xc6\x54\xa1\x85\xb9\xf1\xb2\x24\x05\xdd\xde\x80\xe0\xf1\xdb\x10\xf2\x54\xc7\x9c\x9e\xb8\x87\xf3\xf0\x1e\x4f\x24\xe2\xdc\x35\xe0\x8c\xc4\x23\x5c\x90\x8f\x44\xcc\x5e\x6f\xe0\x1f\x03\xde\x77\x78\xf3\xae\x81\xe3\xe5\xc5\x32\x27\xcb\xfc\xfb\x90\x9b\xb4\x1d\x43\xef\xf8\x74\x7b\x50\x4f\xa8\x0d\x9c\x16\x0b\x6e\x49\x4e\xa0\x99\xa9\x60\x36\x5b\x7c\xb6\x5c\xbb\xee\x93\xbc\xd6\x9b\xf6\x42\xe8\x23\xd3\xd7\x5e\xb9\x55\xbf\xba\x76\xe9\x2d\xae\x17\x5c\x47\xb6\x8f\xed\xec\x3c\x20\xf5\x54\x0c\xef\x56\x36\x5a\x82\x33\x5b\x17\x5f\xce\x3f\x76\xde\xd5\x8b\x8e\xb7\xf5\xe7\xc6\x77\x4d\x6c\xc5\xb7\x5c\xfd\x4b\x6f\xf4\x72\x66\x37\x9b\x60\x1c\x17\xd3\xfc\xae\xb1\x98\x7f\xda\xac\xc8\x64\x36\xfd\x63\xc0\xfc\x0e\x4f\x06\xcf\xe8\xce\x58\x45\x11\x52\xb6\x34\xa4\x6e\x60\x67\xb8\xc5\xb7\xcf\x7f\x71\xf1\x3a\xe5\x14\xee\x40\x11\x3f\xf7\xc3\x6d\x97\xff\xf4\xd2\xd5\xf4\x7d\x74\x18\x9f\xa5\xe2\x0d\xf4\xed\xe9\x46\xd4\x9f\x6b\x0e\x9a\xbd\x76\x2f\xb2\x4b\x11\x6f\xb5\x3d\x85\x6a\xc1\x78\x36\x37\x05\x2c\x35\x89\x44\xcd\xae\x81\x44\xa2\xde\xe5\xaa\xda\x35\xe0\x7a\x8f\xaf\xdf\x35\x40\xc6\xc4\x30\x20\xf4\xa3\x67\xe4\xa3\xce\x9e\x92\xa0\xbb\xbb\x4b\x7b\x7b\x9c\xac\x13\xfa\xab\x71\x5d\x27\x79\xef\x39\xdb\x11\x54\x3f\x47\x73\x4b\xef\x5a\x7d\xed\x1d\x47\x4e\x1c\x7f\xd0\xea\x2b\xaf\xb8\x61\xfa\xd8\x83\xfb\x7e\xdb\x0f\x7f\xdc\x67\x9c\x76\x46\x57\x27\x7f\xc9\x29\x67\x2d\x39\x69\xda\x31\x66\xce\x71\xd4\xd8\x23\x17\x9c\x74\xf4\xb8\xff\xc7\xdb\x7b\x00\x46\x55\x6c\x8d\xe3\x73\xe6\xb6\xed\xbd\xa6\xee\x66\x93\x6c\x7a\x42\x36\x85\xd0\xb2\x14\x21\x10\x4a\x80\xb8\xb0\xb4\x24\x80\x10\x40\x7a\xef\x20\x88\x22\xfa\x30\x52\xed\x88\x88\x80\x82\x0a\xa4\x80\x15\x51\x10\x11\x51\x11\x11\x51\xf1\x3d\x7c\xf6\xf7\xf4\xe9\x7b\xea\x4b\xb2\x37\xff\x99\x7b\x77\x93\x0d\xe0\xfb\x7d\xdf\xff\xfb\x7e\xbf\x4d\xee\xde\xb2\x77\x66\xce\x9c\x39\x6d\x66\xce\x9c\x19\x43\x7a\xb7\xe3\x7e\x1f\x39\x72\xd4\xe5\x71\xe3\x27\xe7\x48\xb8\xba\x1d\x0b\xf8\x14\xfb\x28\x11\x9e\x5d\xfc\x36\xe4\x70\x18\x88\x1c\x74\x28\x63\x9c\xa4\x27\x6c\xb1\xb0\x5f\x06\x2d\x4a\x3a\x04\x2b\xf5\x4a\x48\xfb\xb5\x43\x2c\x4f\x98\x18\x65\xad\x4d\x88\xda\xeb\x4b\xc0\xf6\xc8\x26\xfc\xd8\x9c\xd3\xa3\xd7\xc0\xc3\xec\x5e\xa2\x3f\x31\xe3\x99\x34\x68\xd6\x0c\x2c\xc0\x9a\x51\x7d\xab\xc7\x8a\x4f\x40\xdb\x26\x26\x36\x29\xb7\x77\xb7\xdb\x97\x8a\xc3\x64\x3d\x61\x69\x9b\x86\x9b\xf1\x5a\x83\xc0\x4d\x42\x28\x24\xc7\x1a\xc9\x23\xcf\xde\x97\x9e\x4d\x6b\x7f\xd6\xa5\xad\x96\x21\x24\x41\x9e\xcd\x23\xcf\xee\x93\xf4\xa8\xd8\xb6\x18\xff\x84\xe7\x1a\x04\xa6\x0b\x2c\x92\x9f\x91\xb4\xb5\x24\x2d\x7d\x6f\xba\xfc\x1e\xa9\x27\xa9\x06\x3b\x83\xbb\x88\x12\xd1\x02\x7f\x3f\x7b\xa2\x33\x3e\xde\x82\x8c\x44\xfc\xa1\xd8\x44\xce\xed\x12\x74\x35\x41\xab\xa3\x26\xa8\x8f\x03\x1d\x17\x07\x16\xa8\x09\x3a\x2d\x89\x56\x48\xb4\x80\xca\x02\x3a\xbd\x1a\xf4\x8c\xda\x6a\xb1\x58\xd5\xd4\x8e\x8f\xaf\x09\x22\x93\xd4\x9e\x86\x37\xec\x44\x9a\x50\xb2\xa6\x56\x94\x51\x62\x46\x4a\xec\x99\xed\xdd\x9c\xf6\x9e\x4e\x12\x2e\x2c\x30\xd1\x6d\xe4\xb9\xc8\x36\xf2\x3e\x6a\xe2\x87\xff\xe0\xca\xc7\xcd\xad\x9f\x3e\xf7\x55\x8c\x28\xaa\x03\xc3\x27\x2f\x9a\x32\x1f\x2f\x14\x67\xc1\x34\x71\x07\x1c\x84\x9d\xe0\xf9\x4d\x84\x94\xc3\x3b\xb4\xe5\x63\xdf\xdc\x73\xec\x79\xb8\xeb\xf8\xbb\xc7\x3f\x3f\x2e\x8d\xd3\x57\xb6\xd5\x71\x9b\xb9\x16\x94\x84\xd2\x50\x36\x3a\xe0\xef\xa6\xd3\x6a\xe3\x13\x94\x0a\x45\x12\x4a\x40\xac\xc9\x68\x74\x38\xd3\x59\x27\x9b\x9b\x93\x95\xa5\xb1\x58\x34\x26\x93\xc6\xe1\x48\xd4\xa0\x38\xad\xbe\x26\xa8\x55\x65\x66\x6a\x3c\x9e\x44\x4d\x8a\xbb\x26\xa8\x52\x34\x81\xd9\xef\x08\xaa\x04\x56\x93\x5a\x15\xd4\xa4\xd5\x04\x35\x4c\x9c\xd9\x9a\x92\x98\x52\x15\x4c\x4c\x20\x3f\x1e\x0e\x26\x9a\xa4\x71\x16\xc2\xc9\xa5\xa5\x61\xeb\x30\x4c\xd0\x44\x39\x1a\x4e\x49\x08\xb9\x4e\x61\x76\xd8\x0c\xa6\x76\xeb\x44\xc2\x08\x57\x9c\x8a\x0b\x0d\x28\xa5\xd8\x27\xd8\xec\xd2\x17\x97\xea\x65\x7a\x41\x31\xc7\xb3\x7a\xf0\x14\xa7\x7a\x05\xb3\xcd\x6e\x4e\xf5\x82\xc5\x6e\xe6\xa1\xa8\xcb\x7d\x1b\x20\x0b\xdc\xce\x83\x8e\xfe\x65\xf1\x07\x33\x1b\x07\x89\xad\xb6\xb4\xb7\xab\xef\xcb\x03\x18\x22\xbe\x7f\xc5\x7a\xd0\x3e\xa4\x57\x62\xb0\xd7\xc0\x6b\xa5\xc3\xc4\xaa\x6e\x47\xfe\x36\xfb\xbd\x6a\xe8\x79\x06\x7a\xc0\x9c\xf8\x19\x53\x59\xfd\xb2\x23\x35\x97\x07\x94\xe6\xb4\xee\x33\x2f\x5f\x54\x73\xe2\x6d\x61\xdc\x6d\x6a\xcb\x7a\x58\x96\xa2\x66\x5e\xb2\x81\xe8\x6c\x58\x82\x7f\xad\xa4\x74\x42\xe3\xa2\x6d\xe6\xb6\xa3\x2c\xb4\xc8\xdf\x43\xe5\x70\x30\x26\x26\xd6\xed\x4d\x4d\x8d\x89\x45\xee\x58\x77\x4e\xb6\xd7\x9b\x1c\x13\x93\xcc\x30\xc9\x3c\x9f\xac\x56\xa9\x12\x92\xf5\xa6\xea\xa0\xde\x52\x15\xd4\xeb\x13\x92\x93\x33\xaa\x82\xc9\x6c\x82\xa3\x3a\x98\x60\xee\xcc\xef\xe1\xb3\xcf\xf8\x07\xc8\x31\x76\xf8\xd9\x58\x6c\x76\x63\x81\xd7\x9d\x00\x56\x1f\x9d\x7d\x8c\x6c\x4e\x5b\x44\x11\xe3\x71\x21\x1a\x04\xd9\x65\x96\x89\x08\x56\xce\x9b\xad\x00\x0d\xa3\x62\xd3\xfd\xa3\xfb\x14\xbb\xfa\x16\x4e\x5b\xf8\x4a\x10\x60\xb8\xf8\xca\x9f\xc5\x67\xc5\xfb\x60\x0a\x54\xc2\xb7\x1b\xc4\x56\xf7\x89\x75\x6f\x9d\xc7\xa7\x5f\xf8\x3e\x1f\x46\x6e\xaf\x35\x35\x26\xcc\x1b\x9f\xad\xff\x5e\x7f\xe0\xe9\xfe\xde\x4f\x6b\xde\x3e\x03\x6b\x61\x0c\x8c\x85\x05\xe2\x92\x01\xd3\x57\xfe\x2e\xf1\x0b\x21\x73\xb6\x1f\x91\xa1\x46\xb4\xd2\x3f\x94\x03\xa5\x52\xa7\x11\x18\x95\x41\x65\x30\x99\x15\x1a\xad\xa6\x2a\xc8\x69\x81\x25\xb5\xd6\x26\x6a\xab\xb4\x8c\x9e\x7c\xb5\x69\x89\x39\x05\xa5\xf0\x1c\x5c\x05\xd6\x80\x20\x0f\x2a\xa0\x1a\xd6\x00\x97\xc1\x68\x41\x4b\x0c\x2a\x3d\x22\xef\x33\x4a\x93\x24\x7d\xa9\xfc\x73\x84\x39\x67\x02\x9d\x77\x89\xee\x61\x10\x64\x48\xb3\x3e\xf2\x56\xfc\x32\x8b\x50\xf3\xa3\x90\xb2\x0c\xec\xc5\x2b\x43\xeb\xa8\x15\x22\x5e\xbb\xe3\x0e\xe6\x45\xf6\x05\x71\xc1\x7b\xaf\x6c\xa3\x56\xee\x36\xe6\xbb\xf7\x08\xec\x74\x8d\xf4\x04\xd2\x86\xb9\x68\xb7\x3f\x91\xe8\x96\x5c\xe4\x4a\xf6\x1a\xb5\x5e\x95\xd3\xe1\xc8\x44\x99\x7a\x35\x31\x78\x54\x4c\x97\x3c\xaf\x5a\xa3\x26\x74\xdd\x10\x4c\xd6\x78\xf4\x06\x3d\xa5\xff\xe4\xa0\xcb\xa0\x37\xe4\x1a\x4a\x0d\x8c\x9a\xd1\x18\x34\x06\xd6\x6a\x8d\x5b\x18\x74\x3a\xad\x02\x97\xc9\x66\x2e\x08\xfa\x73\x21\xb7\xa9\xed\xb5\x06\x93\xb5\x2c\x37\x97\x75\x50\x4d\x97\x29\x2b\x37\x7a\x15\x55\x2d\x59\x18\x18\x23\xb5\xb2\xcb\xfa\xd9\x24\x37\x78\x3b\x47\x48\x7a\xc7\xe3\x2e\xec\x85\x7b\x02\xa9\x5e\x21\x3d\x24\x89\x6f\x17\xa4\x16\x8e\x87\x88\x84\x20\x1a\xc0\x9d\x5f\x54\xcc\x4e\x48\xfc\x60\x47\x68\x50\x79\xbf\xa4\x97\x0e\x1f\x3e\xfc\xd1\x87\xfb\x5f\xcf\xfa\xd6\x3a\xa2\xcf\xd8\x0a\x48\x10\xff\x42\x8f\x21\xd3\x60\x45\xed\x0c\x23\xcc\x78\xf6\xd5\x73\x99\xe5\xd3\x07\xf2\xdb\xe6\x6c\xab\x3d\x73\xfe\x9e\x07\x73\x87\xf4\x9f\xbf\x72\x38\xb9\x63\x27\xdf\xdd\x7d\xd2\x04\x82\xa7\xbb\xda\x7a\xf0\x8f\x71\xe9\x44\x97\x55\xfb\xf3\xed\x0e\x87\xcb\x95\x68\xf3\x7a\x21\x8d\xea\x80\x0c\x84\x34\x4a\x65\x5a\x22\x93\x95\x99\x6e\xb0\x39\x59\x8b\xd2\xc3\x5a\xd8\x8a\x60\xac\xc5\x60\xd7\xe8\xd3\x5c\x88\xb6\xe3\x29\xd2\x07\x3b\x55\x1a\xae\xa2\xbd\x24\x52\x4d\xa3\xaf\x53\xf7\x50\xe2\x76\x28\x34\x48\xaa\xc2\xdd\x4e\xdb\x74\xe3\x65\xb3\x4f\x90\xd4\x1b\x8d\xed\x2d\xff\x5c\xc8\xc0\x42\xd8\xb1\xe7\xd6\x19\xe2\xd7\x32\x65\x17\x3c\x7c\xfb\x99\x81\x17\x9e\x5c\x57\xd0\xe7\xb1\xbd\xe2\xb7\xf4\x87\x6f\xff\xf9\x06\x26\x3d\xe5\xf8\x43\xf7\x84\x5e\x62\xca\xee\xa9\x35\x3f\x95\xb8\x62\xce\xe3\xb0\xf4\x3b\xc3\xa5\x33\xa1\xe1\xb8\x0a\xe2\xf7\xde\x19\x7a\xee\x1f\x62\x39\xb1\x6a\x89\xae\x46\x1c\x1d\x37\x8e\x25\x92\x9f\x2e\x7e\x4e\x47\x5b\xfc\x23\xdc\x89\x06\xab\xcb\x9b\xce\xb0\x16\x27\xd8\x63\x59\xab\x4a\xa7\x51\xe8\x18\x43\x42\x72\xaa\x91\xe5\x38\x83\xc5\x6a\xb0\x66\x66\xa4\xa7\xe3\xb4\x34\x9c\x9a\x8a\x13\x3d\x6a\x26\x36\x96\x55\x78\x19\x62\xa4\x99\x53\xf4\x8c\x3d\x68\x07\xde\x1e\xe7\xd2\x30\x0e\x87\x95\xf4\xcb\x8c\x56\x53\x64\x1b\x76\x62\xd4\x54\x8d\x27\xa6\x8d\x51\xba\x94\x2f\xae\xe3\x76\xfa\xd0\xde\x71\x96\x88\xc0\x4c\x08\xdb\x4c\x49\x9c\x98\x88\x56\x6a\x26\xba\x99\x30\xc1\x17\x7a\x38\xe9\xf0\x7a\xc0\x63\x07\x9f\xd7\x39\x07\x86\x7f\x09\x4b\x81\xa7\xdd\x74\x71\xef\xaf\xe2\x6e\xb1\x79\xce\x9c\x39\xcc\xac\xe7\x43\xe2\xad\xd7\x86\x6c\xc7\x87\xba\x0d\x0d\xe5\x66\xfa\x99\x7f\xc0\xfd\xa4\xb3\x41\x8e\x4f\xee\xfe\x44\x2c\x87\x7a\x7a\x7c\x72\x37\xfd\x88\x8f\x35\xe0\x9f\x1f\x20\xba\xe3\xb1\xb6\x1f\x14\xcb\x09\x6e\x92\x50\x39\xaa\xc4\xc9\x44\x77\x04\x6e\x55\x58\xb5\x66\x52\xf5\x5b\xba\x0e\x36\xdb\x39\x67\x5c\x1c\xc7\x99\x51\x57\xd6\xa3\x1b\xae\xd5\xea\x4a\x7b\xf5\xca\xf3\x78\x02\xba\xe1\x9a\x61\xc1\x38\xde\xc6\x8f\x08\xda\xed\x4e\x5b\x69\x69\xf7\xee\x7d\x9a\x40\xef\xb7\x04\x87\x77\xb7\xd9\xba\x0f\x67\xb2\xf5\xfa\x8a\x61\x84\xd5\x5d\xd9\xa9\xd9\xf4\x87\xb6\x60\x46\x06\x4e\x35\xeb\x4c\x0f\x05\x60\x53\x00\x46\x05\xa0\x24\x00\x19\x01\x88\x0d\x80\x26\x00\xbf\x07\xe0\xe3\x00\xbc\x15\x80\x63\x01\x38\x10\x80\x87\x03\x70\x77\x00\x6a\x03\x30\x3a\x00\x03\x03\xd0\x2d\x00\x99\x01\x10\x02\x30\xf5\xdb\x00\x7c\x12\x80\xb3\x01\x78\x29\x00\x3b\xa5\x37\x82\x01\x18\x14\x80\xb4\x00\x28\x02\xf0\xef\x00\x7c\x17\x79\xe1\xe9\x00\x6c\x0c\xc0\xb2\x00\xcc\x08\xc0\xb8\x00\x20\x92\x8d\x33\x00\xea\x00\x84\x02\xf0\x63\x00\x4e\x05\x60\xbf\x54\xce\x7d\x01\x58\x1d\x80\xca\x00\xf4\x97\x20\x22\xe5\xc4\x07\x40\x1f\x80\xe2\x2f\x03\xf0\x61\xd4\x7b\x9b\x03\xb0\x20\x00\x53\xa4\x97\xd2\x25\xb0\x51\x00\x7e\x0e\xc0\x57\x12\xcc\xcf\x04\x60\x7b\x00\xee\x88\xbc\x43\x0a\xeb\x19\x80\xd4\x00\x58\x02\xc0\x07\x80\x40\x7d\xc6\x1f\x2f\xbd\xb8\x57\x7a\x91\x40\x96\x17\x80\xa4\x00\x80\x21\x00\x98\x64\x24\x4c\x18\x5f\x45\xfe\x6e\x36\xa2\xf3\xc7\xe3\x39\xe4\xc7\xaa\x9b\xbc\x76\xc3\x4b\xe1\xc1\x1c\x9f\x2f\x57\x96\x51\x54\x42\xd9\xa9\x84\x92\xef\x49\x47\xc8\x17\x1e\x71\x8e\x1e\x6e\x36\xb6\x8f\xf0\x44\xab\x27\x3a\xc3\x99\x22\x99\xa6\x84\x30\x75\x90\x09\x74\x90\x32\x9f\xb5\x5a\x04\x5f\xb1\x4f\xa2\x5a\xc9\xb7\x36\x25\x6c\xd0\x27\x80\x6c\xd1\x7b\x73\x98\x4e\x22\x8d\x58\x3e\xf6\x04\x0c\x05\xa9\x24\x03\x3a\x36\xb4\x65\xd0\xc0\x95\x73\x6b\xbb\x7e\xb6\x73\xd6\x3f\xa0\xdb\xbf\xc1\x98\x18\x18\xbd\x72\xcb\x96\x34\x5f\x72\x2a\xfe\xe6\xf5\x23\x87\x8e\x26\x9c\xd6\x07\x87\x8d\x2f\xeb\x5d\xbe\x7c\xfe\xd0\xbc\xc3\xcf\x6c\x7b\xde\x7e\x46\x39\xb0\xf4\x96\xbe\xdd\xca\x5e\x58\x7e\x4b\xf3\xc2\xf5\x0f\x94\x8f\xdc\xbc\x5a\xe1\x58\xb6\x1c\x76\xcf\x9d\x3c\x3b\x74\x85\x5b\xfb\xf9\xdb\x63\x87\xff\xfc\xf3\x5e\x71\xf3\x2d\x25\xba\xf2\xd5\x1b\x96\xdc\x11\xd3\x33\xcf\x9b\x91\x94\xa1\x77\xa4\x74\x0b\xf8\xe7\x2f\x5d\xbd\xc2\x98\x57\x10\x9b\x1c\x9b\xa4\x4b\xee\x33\x15\x3f\xb6\x6c\xb6\x98\xbc\x80\xda\x52\x1b\xdb\x7e\x50\xce\xe5\xa8\x4f\xb1\x15\xf5\x24\x7a\xaf\x6f\x97\xbc\x3c\x8f\x2d\x3e\x2e\xae\x38\x03\x69\xe9\xf6\x10\x26\xa5\xce\x44\x3a\xe5\xac\x2e\xc3\xc6\x96\xf6\x2a\xee\x12\xef\x61\x9d\xd9\xd9\x05\xc3\x83\xd9\x06\xa7\x6b\x78\xd0\x69\xc6\x26\x62\x39\x61\x4c\x84\x88\x91\x68\x48\x06\xb1\x92\x60\x88\x28\xff\xc8\xae\x07\x72\x23\x44\x8d\x84\x4b\x0a\xaf\x5d\x62\xca\x06\x23\x48\xc3\xe2\x14\xbd\xbc\xa0\x84\x82\x74\xa2\x08\xf3\x8b\xa4\xad\x11\x3a\xe1\x16\xdf\x80\x5b\x36\x01\xd8\xe1\xe2\x31\x71\xaf\x78\x19\xbf\xd6\x0a\xa6\x7d\x9b\x61\xa5\x58\x27\xb6\x8a\x1b\xe0\x8e\x15\x6b\xb8\xbe\x62\xdb\xb5\xab\x7f\xf3\xfe\x66\x9d\xba\x66\xe1\xcc\x51\xb5\x5f\x1e\x0a\xfe\x78\xe5\xc4\xf7\xf1\xff\xd6\x4c\x98\x32\x79\xf2\x90\x31\x80\xf7\x8f\xc6\xf6\xd0\xb7\xdc\xda\xcb\x67\xb7\x5e\x4a\x0a\x3d\xcf\xbc\x7f\x56\xac\x9e\x13\x7a\xef\xd1\x23\xf7\x6d\x4b\x19\xe2\xef\xde\xbb\xa0\xa7\x35\x7b\xf8\xda\xea\x87\x0f\x6e\xff\x53\x4c\x9f\xde\xbe\x1e\x79\xc5\xa6\xa2\xca\xf5\x74\x8c\x98\x0e\x14\xdf\x47\xf0\x47\x25\x2d\x5d\xe3\x94\x83\xba\xa0\x02\x62\x47\xf5\x2e\xc8\xc9\x65\x12\xed\xb6\x84\xc4\x44\xe0\x6d\x16\x3d\x5f\xa4\x2f\xcc\xcd\xc9\xf1\xd9\xdc\xde\x4c\x86\x35\x9b\x1d\x71\x28\x9f\xb5\x58\x6c\xea\xec\x2e\x02\xab\x1f\xab\x07\x5e\x9f\x94\x9c\xc6\xb2\x06\x83\x36\x21\xc6\xc6\x28\xb5\xb2\x78\xfd\x03\xf9\x5a\xd2\xde\xd9\x8e\x20\x50\x9e\x29\x21\x04\x29\x90\x83\x71\x4b\x7f\x44\x94\x7a\xc9\xc1\x10\x31\x2b\xff\x11\x71\xea\x73\xfb\x8a\x23\xa2\xd5\x5d\xec\x21\xd2\x55\x48\x9e\xb6\xdb\xf3\x66\x68\xae\xb8\x7b\xaa\x78\x69\x8a\xb8\x7b\x6e\xeb\x1b\x9e\x27\xa6\x4d\x85\xcc\x31\xd0\x7b\x3c\x0c\xaa\x82\xee\xa3\x20\xb3\x45\xf5\x59\xc2\x2e\xfc\xec\x43\x09\x97\xc5\x49\x27\x5d\xeb\xc5\x37\x7a\xbb\x99\xde\x49\x3d\xc5\xc0\x2d\x6e\xe6\x1f\x9d\xa4\xed\x27\x11\x19\x0c\xf7\x87\xb6\xcb\xa2\xf7\xa5\x97\x70\x8f\x07\x48\x5f\xff\x28\x42\xfc\x04\xf6\x32\xd2\x13\x33\x7d\xb4\xdf\xa0\xd5\x99\x0d\x1c\xef\x88\x8d\xe5\x0d\x3a\x36\xd1\xe5\x6c\x82\x92\x46\xde\xc8\x1b\x89\x31\x62\xee\xad\x81\x3e\x28\x88\x0c\xd0\x8d\xbc\x2d\x5f\xeb\xa1\x04\xe9\xc8\x7d\x69\x87\x91\x49\x99\xba\x34\x9a\xa6\xa8\xf1\x94\x4f\x34\x2d\x61\xd6\x02\x42\x1c\x74\xf4\x86\x30\x1c\xa1\xa2\x5e\x50\x48\xce\x06\xec\xc1\x3f\xbd\x70\x66\xfc\x37\x39\x33\x17\x8a\x67\xbf\x82\xed\x5f\x43\xaf\x85\xb5\xd9\x7f\xbd\xd2\xca\x5e\x9e\xf5\xc3\x49\xf1\xab\xdf\xb7\x6f\x2b\x6d\x21\x37\x2d\x5e\xc6\x1d\x3a\xda\x73\xdb\x76\xfc\x48\x68\x84\xf8\xb1\x18\x92\xfa\x1d\xab\xd0\x4b\xcc\x8b\xdc\x3b\x28\x9e\xf4\x3b\xb2\xd0\x34\x7f\xb1\xc0\x28\x95\x09\x71\x31\x4e\x07\x61\x15\x2e\x33\xd9\x64\xca\xca\xcc\xca\xc9\x76\x5b\xf9\xb8\x38\x26\xde\xa1\x55\x31\xd5\x56\xb0\xc6\x5b\xe3\x21\x55\x4f\x77\x7f\xd3\xa7\xaf\xc9\x22\xf6\x3c\xa0\xd2\xdc\xf1\xbe\x37\x32\xf3\x8d\x74\x58\x66\x7c\x87\xf9\xd0\xd1\x35\x96\xec\x25\x5f\xc4\xb1\x01\x0a\xc3\xa2\x86\x4e\xef\x16\x76\xcc\x4e\xd9\x0b\xbd\xc4\x78\x32\x87\x87\x91\xe9\x28\x32\x31\x9a\xf0\x96\x33\x55\x55\xfc\x49\x46\xb8\xa5\x71\xc3\xb6\x47\xfe\x34\x78\xb5\x1b\xce\xbd\x37\x72\xe4\x90\x91\x8f\x0f\x0f\x84\xbe\x63\x72\x5b\xdf\xe7\xa6\x4f\x9c\xb8\x38\x34\x63\x42\x99\x50\x11\xb7\xf6\x74\x43\xe3\x9b\xdd\x7b\x5b\xfb\x2e\x58\x1c\x7a\x7d\xe1\xaa\x79\x1b\x7e\x5d\x2f\xde\xb9\x8a\xd8\x49\xaa\xb6\x1f\xd8\x61\xc4\x9e\xf4\xa2\x46\x7f\x5c\x72\x62\xa2\x3d\x35\x21\x29\x49\x67\x50\xab\x4d\x2a\x9d\xc3\x6e\x67\x58\x1d\x9b\x96\x9e\x1a\x31\x26\x3d\x1a\xb7\xc1\x68\xa0\xc6\x64\xff\x60\x82\x51\x6f\x04\xbd\x31\xd7\x58\x6a\x7c\xce\x78\xde\xc8\x11\x9b\xd2\xa8\x31\x0a\x16\x4b\xec\xfc\xa0\xde\x91\xe8\xc8\x75\x54\x39\x58\x25\x31\x23\x2c\x82\x80\xe6\x07\xfd\x4c\x05\x83\x11\x63\x60\x5c\x8c\x9f\xd9\xc5\xfc\xc4\xf0\x0c\x23\x38\xa5\xd1\x94\xb9\x52\x77\x4b\x1e\x49\xe9\x30\x32\xe7\x5e\x67\x65\x76\x74\xb1\x22\xb2\x5b\x1e\xdc\x48\x21\x96\x23\x47\x0c\xcd\x24\xc4\x78\x8a\x7d\xde\x62\xf2\x65\x72\xb7\xf7\x45\x05\x37\xf9\xb3\x93\x2f\x13\x7e\xa0\x2c\xa0\x02\x6b\xe2\x5f\x5f\xfe\x8b\xd8\x1a\xbf\x36\x6d\x08\xc6\x0b\xd3\x46\x95\xc2\xa9\x86\x2f\xe3\xc5\x6f\x54\x95\x83\x26\x4d\xd3\xc3\x80\x78\xf1\x7d\xcc\x40\x65\x82\xf8\x5e\xdc\xe9\x71\x23\x0c\x2f\xbd\x0c\x2a\x50\x6c\xf3\x75\xdd\x86\x99\x97\x9e\x31\x0c\x1a\xf1\xa7\x87\xb6\x75\xf5\x6d\x13\xcf\xd0\x7e\x04\xb5\xbf\x8e\x12\x99\x60\xa1\x33\xc9\x3a\x85\x9a\x61\x78\x41\xd0\x2a\x35\x0c\xc6\x46\x64\xd2\x98\x6c\x56\xb5\xde\x82\x48\xff\x49\xc1\x22\x64\x22\xc6\x94\xd6\xd4\x6e\x4c\x75\x4c\x19\x46\x8d\x6e\x45\xf8\x9b\x9a\x4c\x46\x1f\xb8\x69\x3b\x93\x6f\x8f\x40\xed\x25\x62\x1d\x79\x07\xe1\x2e\x30\x3a\x74\x0a\xdf\x26\xc6\xc3\xb7\xe2\x1e\xd1\x33\x74\xa5\x78\x79\x0e\x33\x04\x17\x84\xde\xa1\xc7\xf7\xa1\xc7\xf0\xc4\xea\x90\x48\x37\x81\x03\x79\xcf\x3f\x02\x9f\x1d\xcd\xf6\x17\x9b\x8d\x3a\x83\xdd\xac\x51\x18\x0c\x56\x30\xaa\x74\xac\x91\x63\x9c\x0e\xa5\xd2\xa8\x50\x18\xb5\x5a\xa3\xcd\x66\xd4\x68\x8c\x76\xbb\xd1\x64\x32\x9a\xcd\xac\xd1\x24\x30\x2c\x53\x15\x94\x1c\x2e\x24\xe5\xda\xa9\xe7\xdb\xb9\xa3\x67\x8f\xb6\xfb\xc3\x43\x8e\x29\x74\x22\x8e\x58\xf6\x29\x56\x8e\x1e\xe4\x8e\x2b\x4c\x29\xe4\x9e\x83\x5c\xb1\x84\x6d\x10\xbb\xc2\x2d\xe2\x8b\xf4\x10\x2f\x8b\xef\x93\x67\xef\xe3\xb3\x8b\x60\xdc\x97\x5f\x7e\xbb\xfa\xfb\xd5\x4f\x91\x43\x3c\x7d\x6a\xd1\xf7\x8b\x9e\xa2\xa1\xbe\x89\x9d\x8b\xc4\xe9\x8a\xbb\xf9\x2c\xd2\x5f\x2b\x40\xa5\x68\x08\x1a\x8d\x1e\xf5\x27\x66\x0e\xf5\x99\x4c\xe9\xb1\x43\xfd\xa9\xd6\xfe\x23\xd3\x53\x87\xf6\x57\xf6\xe4\x5d\x5d\x91\x2b\x88\xc6\x28\xe3\x4d\x03\xa5\x3e\xbd\xbe\x9b\x74\xf2\x54\x48\x27\x7f\x2c\x25\x5c\x5b\x30\x3d\x93\x33\xe9\x3d\xa9\x7e\x7f\xaa\x47\x6f\xe2\x32\xd3\x15\xf9\xf1\xce\x3e\x12\x79\x3b\x4d\x85\x81\xf8\x00\xb9\x3c\x12\x64\xe2\x4d\x61\x2f\x04\x47\xd4\x60\x88\xf4\xc9\x94\x66\x8f\x0c\xa7\x22\xde\xbe\x76\x59\xbf\x75\xf2\x4e\xf0\x24\x79\x09\x31\xb8\x8b\x8a\xcd\xd2\xb8\x11\xd8\x90\xd5\x82\xe9\xd6\x3f\x51\x5c\x1d\x03\xc5\xac\x50\x58\x94\x5c\xdc\x0b\x8a\x7d\x3c\x50\xa5\x27\xab\xb9\x14\x3a\x5e\x68\x2a\x2c\xc0\x1e\x9e\xc1\xbc\xd0\x31\x7b\xa4\xb8\x7b\xe7\xe3\xb7\xf7\xe9\x6d\x4b\x11\xbf\xcc\x4a\x9c\x97\x7a\x7c\xf7\xfd\x87\x5a\x26\x7f\x0d\xfc\x61\xf1\xea\x33\xc7\xde\x58\xfd\xf0\xb8\xda\xe9\xb7\xba\x86\xc5\xad\xb9\x7b\x8c\xf8\xc9\x3d\xa3\xc0\xb3\x66\xe1\xbc\x51\x53\x2b\xf0\x47\xa5\x43\x27\x0f\x18\xda\xad\x25\xee\xde\x65\x4b\x5f\x9b\x7b\xef\xfc\x39\xb5\xc3\x82\x6d\xdd\x86\x66\x15\xfb\x5c\xdd\x46\x40\xcf\x27\x1e\x19\x28\xbe\x3b\xad\x5f\xf9\x9d\xf0\xb7\xa7\xb7\x3f\xca\x3c\xa3\x13\xcf\xb7\x9e\x13\x17\x5e\xbd\xe3\x8e\x71\x43\xcb\xa6\x1a\x0c\xb8\x2b\x4c\x98\x98\xd4\xb5\x30\xa5\xab\xb2\xba\x57\x5c\x79\x73\xed\xae\xa5\xfb\xd7\x2f\x1f\x3d\x63\xfe\xf8\x26\x18\xff\xd6\x55\xb0\xdd\x29\x2e\x10\x2f\xfd\x90\x98\xdc\x3d\x23\x3f\x6b\x24\xf5\x97\x16\x47\xb1\x45\x44\xa6\x24\x11\x2d\x39\xcf\xef\x89\xb7\x65\xf1\x2c\xa3\x77\x99\x95\x1e\x26\xdd\x15\x1b\xe7\x62\x94\x5c\x5e\x4c\x6e\x56\x16\x8a\x8d\x45\x36\x5b\x0c\x8a\x73\xc8\xc3\x33\x71\x71\x31\x48\xa3\xaf\x0e\x6a\x8c\x35\x41\x8d\xdd\x1c\x63\x42\xa9\x35\x41\xc4\xca\xa3\x0d\xa5\x6f\x64\x46\x0f\x30\x3a\x22\xf4\x47\x1a\xc1\x7e\xdd\x1e\x4b\x74\x4c\x51\x0f\x66\x3a\xb2\x48\x30\x5e\x48\x30\x47\xcd\x09\xc6\x2b\xb8\xc1\x5e\x8c\x29\xfa\x23\xb2\x34\x11\x8a\x8b\xf0\xdf\x1e\x3f\xb0\xfd\xf6\x25\x59\x4f\x3e\xb2\x7e\xdc\xa8\xf2\xf9\xba\x6e\x0f\x6d\xef\x27\xfe\x1d\xd8\xa7\xd7\x8c\xcd\x7f\xae\xc5\x97\x96\x91\x9d\x1e\x9f\xe5\xe7\xb6\x3f\xb5\x63\x6b\xa8\x49\x1c\xb3\x65\xea\x7d\xf7\x99\x3e\x4b\x5d\xe4\xb8\xf5\x67\xf1\xa7\x13\x7b\xe1\xfb\x97\xcf\x43\xee\x3b\xe3\x1e\xdc\x2f\xbe\x97\x5f\xd0\x35\x77\xf1\x7d\x13\x6b\xee\x21\x30\xd3\xfd\xd3\x02\x84\xf7\x62\x88\xc5\x90\x4c\x7a\x66\xdb\xfd\xd9\xa9\x49\xb1\xb1\x2a\x05\xe9\x6b\xf0\xaa\x94\xe4\x04\xb3\x39\xc6\x61\x03\x8b\xca\x92\x99\x91\x6c\xf2\xe8\x6c\xb6\x04\xb5\x3d\x5e\x19\xe3\x88\x81\x98\x14\x1e\x99\xa8\x97\x77\x8a\xde\x54\xe6\xb0\xc3\x1c\xfb\x1a\xfb\xfd\x76\x26\xd7\x0e\x08\x19\x10\x36\x11\xb6\xb6\x9b\x18\x6c\x31\xd5\xa6\x43\x3a\xa6\xce\x32\xe3\x4b\x4d\x12\x79\x52\xbb\x38\x93\xb2\xe2\xdc\xb0\x6a\x09\x1b\xb8\x61\x19\xd3\xfe\x2c\x22\x40\x65\x49\x93\xcf\xda\x89\xd6\xb1\x53\x83\x82\xf6\xd7\xdb\xfb\x66\x5e\x3a\x54\x9d\x5f\xec\x26\x3d\xd7\x54\x8f\xdb\xb4\x18\x2f\x3d\x03\x90\x3d\x7e\x00\xe0\xb2\x89\x5d\xda\x1a\x48\xef\xec\xf2\xe2\xc5\x8b\x99\x8b\x0c\x95\x3d\x2d\xf7\xf4\x0d\x35\x63\xdc\xef\x3e\xf1\x3c\x7b\x2b\x64\x3d\x72\xff\x52\x4f\xde\xd2\x07\x76\x8b\xc9\x8c\x61\xe9\xc8\xb4\xb4\x91\x1f\x8e\x1d\x0b\xbb\x86\x23\x69\x5d\x4b\x65\x5b\x3e\x77\x9c\xa7\xd6\x41\x0a\x5a\xe5\x4f\xb5\x39\x19\xad\x46\xe3\x54\x1a\xe3\xe3\xf9\xa4\x84\x44\xc6\xe2\x64\x12\x9c\x8c\x37\x55\xab\x45\xbc\xdd\x56\x45\x3a\x62\x88\xe7\x05\x4a\x22\x31\x41\x83\x87\xf7\x54\x05\x95\x3c\x8b\x92\xaa\x82\x88\x18\xa2\xc8\x1c\x97\x50\x13\x8c\x8b\x0c\x49\x45\x4d\xeb\x76\xa2\x95\x0e\xdb\xa1\x43\x4e\x51\x9b\x9f\x4b\xa6\x83\x4e\xd4\xd7\xd6\xc6\x52\x8d\xe1\x35\x12\x66\x2c\xa4\x13\x1a\x3c\x2b\x58\x3d\x60\x31\xd9\x8d\x3a\xc0\xa7\xc4\xf7\xc5\x97\xa1\x37\x74\x79\xfa\x02\xc4\x97\x8a\x3f\xb9\xb7\x4e\xaf\xde\x57\xbc\x07\x0e\x4f\x16\xdf\xa9\x7f\x5a\x6c\xdc\xbf\xeb\x89\x7d\x06\x07\xe9\xba\xf6\x87\xbe\x30\xdb\xb9\x72\xb9\xb6\xe1\xc0\x88\x5b\xe7\xe8\x5b\xb3\x95\x3d\x72\x4f\x7e\x12\x6a\x9e\xba\x4a\xfb\x32\xb3\xed\x9c\xd8\x96\xc0\x9c\x8d\xf9\x15\x31\x92\x60\x7b\x4b\x92\xcd\xb1\xc8\x8d\x96\xf9\x7b\x33\x38\xd1\x64\x05\x56\xa1\x4e\x14\xcc\xbc\x4a\xa5\x25\x0c\x60\x36\x10\x85\xea\x49\x12\x62\xed\xc8\x5e\x13\x64\xe3\xf4\x08\x74\x74\x0d\x3e\x56\xeb\xcd\x16\x73\x4d\x50\xe1\xb0\x58\xb0\xd6\x68\xc2\x89\x55\x41\x4a\x07\x52\xe5\xa3\x75\x8b\x3c\x3d\x71\x9d\xaa\x89\x0c\x59\x4a\xf6\x48\x97\x3c\xa3\x64\x31\x5a\xdd\x94\x06\xcc\x92\x3d\x69\x26\xcd\x5f\xec\xe6\xdc\x5e\x77\xb1\x2f\x97\xee\x9c\xbf\xba\x01\xc6\xd5\xc3\x1d\xe2\xdb\xa5\xbf\x1d\x98\x2f\x7e\x3a\x2b\xf4\xd6\x4c\xf1\xf2\xfc\xbd\xbf\x94\x8a\xef\x62\x01\x8e\xf7\x10\x5f\x2e\x3b\x12\xe3\xe7\x93\x98\xcd\xf0\xb3\xa8\xbb\x70\xf0\x82\xf8\x06\xf4\xa0\xc7\x85\x83\x07\x0f\x5e\x18\x7c\xce\xb6\x40\x9e\xbb\x48\x68\xfb\x81\xcb\x27\x72\x21\x03\x2d\xf0\xf7\x48\xb5\xa6\x1b\x59\x45\x42\xa2\xcd\x60\x00\x9d\xa0\xc8\x48\x4e\x76\x78\x3c\x0a\x5d\x22\x9b\x95\x29\x08\xea\x84\x04\xb5\x31\x23\x43\x87\x90\xda\x91\x9c\x6c\x4d\x49\x71\xab\xd5\x6c\x4d\x50\xcd\xba\xe3\xaa\x82\xee\xce\xe3\x8f\x52\x8d\x4a\x22\xa7\x0e\x95\x14\x3d\x50\x23\x6b\x55\x77\x61\x81\x9b\x58\x04\x29\x44\x24\xbb\x58\x6a\x69\xe9\xb0\x20\x0d\x3f\xd1\xae\x1d\x87\xdd\x2e\x4a\xf8\xa4\xfd\xdd\x09\xcc\x23\xe2\xbf\x26\xaf\x72\x89\x57\xf3\xc4\x1f\xc1\x00\xee\xd1\xcf\xe7\x6e\x78\xfc\x20\x7e\xa1\x75\xe0\xd6\xed\xdf\x0f\x81\x94\x25\xa2\x27\xf4\xea\xd0\xf5\x59\xc7\xeb\x43\x7f\x66\xb5\x86\x7d\xf9\xdd\x0a\x37\xad\x7c\xfb\xd5\x0b\xb9\x03\x8a\x52\x2f\x18\x6a\xc6\xae\xed\x22\x5e\x80\xfd\x17\x06\x4c\x4a\x8b\xd0\xfb\x66\x42\xef\x31\xa4\xa5\xa7\xfa\x63\x34\x56\xa5\xd1\xc9\x27\x38\x63\x62\x19\x26\xc6\xca\x78\x92\xb4\x5a\xde\x62\x89\xa2\xf1\x44\x3e\xb1\x5a\xa2\xf1\x84\xea\x30\x8d\x3b\x62\x6a\x82\x8e\x3f\xa2\xf1\x9b\x68\xe1\x3f\x20\x6c\x2e\x4c\xd4\x36\x89\xa8\x89\xd6\x10\x4f\x42\x11\xa4\x3d\xfd\x21\x98\x7a\x89\xad\x89\x3b\xa7\x4d\x7f\xa8\x0b\x40\x85\xf8\x97\xb7\x9e\x16\xcf\xee\xda\xb6\xf3\x51\x7d\x1c\x2c\x87\x52\xe8\x07\xb3\x08\x4d\xeb\x4e\x34\x0e\x98\xb0\x48\xd7\x9a\xab\x5f\xbd\xac\xe6\xc4\x49\xed\x4b\xcc\xb6\x0b\xff\x8e\x67\x4e\xc7\xfd\xd2\xd6\x26\x6e\x60\xde\x82\x87\xf9\xd7\x0d\x02\xd2\x8a\x6b\xe8\xfe\x7a\x44\x06\x16\xb5\xfd\xc4\x5f\xe5\xea\x88\x9d\x94\x42\x24\x60\x21\xaa\xf2\x77\x55\x29\x95\x36\xbb\x81\xc9\x73\x65\xc4\x30\x76\x6f\xba\x2b\x86\x2f\x2e\x4a\xe3\x53\x1d\x9e\xec\x86\x60\xbc\xa7\x31\x18\xef\x23\x67\xa7\x4d\x85\x78\x44\xf4\x31\x8f\x1a\x83\xbc\x96\x9c\x05\x3a\x36\x1f\x36\x0e\xc3\xce\x1b\x9d\xfb\x03\xb2\xde\x6d\x57\xad\xed\x3d\x46\xba\xba\xc5\xae\x03\x2e\xca\xd7\x0b\x48\x67\xc8\x1c\xed\x92\xf1\xe4\xe1\x17\x5f\x7c\x6e\xdd\x01\xc7\x4b\x8a\x3e\xdd\x6f\xbd\xa5\x7f\x65\x8f\x7e\x8a\x97\x8c\x2f\xb0\xc7\x8e\x1e\x7a\xfe\xf0\xb3\xc7\x8f\x1e\x68\xb9\xe5\x5d\x66\xe7\xfb\x03\x7b\x0e\xaa\xe8\xe9\x2f\x1f\xe8\xc7\xda\x6f\xae\x5c\xfa\x6e\xd3\x46\x4d\x69\xf9\xe6\x07\x76\xd4\x0d\xe9\xab\xba\xf7\xf1\xf1\x9f\x7c\xf5\xe5\xa7\x5f\xfc\xf9\x5a\x68\x1e\xb7\xb6\x35\xf7\xf1\xbb\xef\x79\x74\xd7\xba\xbb\x25\x59\x97\xde\xf6\x03\xb3\x8b\xdb\x46\x70\x90\x84\x2a\xfd\x19\x0c\x1b\x63\xb1\xb0\x2e\x87\x43\xab\x56\xb2\xca\x64\x8f\xca\xee\xb2\x0f\x0b\x6a\x5d\xc4\x2a\x76\xf1\x46\x63\xfc\x88\xa0\x91\xe5\x51\x45\x90\xb7\xa1\xce\xdd\x1f\xe3\x8d\x93\xa1\x61\x67\x08\xba\x7e\x07\xbb\xe9\x92\x5f\xa1\xb0\x98\x09\x4f\xa9\x61\xc1\x6a\x91\x2a\x69\x25\xed\x8e\xfb\x57\xdc\x6a\x7f\xa0\x52\xac\xdf\xff\xf8\xfa\x3b\xe1\x83\x57\x9f\x7e\xf1\xdf\x7f\xf9\xa1\xa8\x64\xe1\xf4\x65\x27\xa7\xcf\x10\x2b\x9f\x7e\x72\x6f\xde\xc9\x3c\xd8\x70\xf4\xa5\x87\xff\xf4\x9a\xf8\xe5\xd0\x33\x0d\xcc\xfd\xb7\x54\x6e\x15\x9f\xcf\x3c\x82\xa4\x76\xdc\x88\x90\x62\xb5\xe4\x8f\x60\x24\x7d\xa2\x74\xb4\xdc\xdf\x9d\x35\xe8\x93\xc1\x91\x80\x4d\x6a\x85\x42\xa9\xd4\x3b\x4c\x6c\x66\x86\xd5\xdb\x10\x8c\x75\x37\x04\xf5\xd6\x44\x2b\x56\x32\xd6\x58\x6b\x2c\x52\x91\x4e\x9d\x9e\x03\x15\xcb\x69\x38\x8d\x52\xaf\x62\x94\xd0\x04\xee\xc6\x20\x8b\x94\xa6\xdc\x4c\x18\x4f\x94\x97\x2f\x2c\xb6\x4a\x24\xab\x7f\xbc\x31\x72\x15\x35\xd1\x14\xe9\xfe\xd2\xb1\x03\x6a\x56\x82\x8d\xce\xcb\xb9\x21\x95\x76\xf6\xa2\xfd\xf8\x84\x68\xc7\x9c\x7f\xe2\xe5\x2d\xbb\x42\x63\x4c\x3f\x13\x2d\xf9\x8c\xe9\x67\xa6\xcf\x91\xc7\x77\x1e\x7e\xfe\xb1\x5d\x87\x3e\x2a\xf2\xf7\xee\x5e\xd2\xa3\x4f\xf7\xbd\x7b\xd9\x01\x7b\x27\xb6\x9e\xe0\xd6\xb6\x3c\xff\xfc\x4c\xc6\xd7\xbc\x1a\xcf\xde\x7d\xbc\x69\xcf\xee\xa6\xc3\xfb\xa6\x8c\x1d\x3f\xf9\xb6\x9a\x2a\x5a\x7f\x57\xdb\x4f\xdc\x29\x22\xb7\xf4\x44\x97\x67\xa0\x7c\x34\xca\x9f\x9d\x9b\x92\x92\xea\xca\x74\x28\x0c\x8a\xd4\x4c\x06\xf9\x52\x53\x59\x6f\x6e\xf2\xdb\xc1\xdc\x5c\xd6\xab\xb1\xbc\x15\xd4\xb0\xde\x9c\x33\x41\xaf\x9e\x8d\x7b\x2b\xc8\x46\xf8\xf6\xba\x29\xd2\xb0\x56\xca\x8f\xb6\x1b\xa9\x89\x98\x4c\x27\xd3\x92\x7d\xf9\xac\x49\x28\xc0\xc9\x9e\x24\x16\x5b\x2d\x26\xd6\x97\x9f\x6c\x62\x2c\x7c\x26\xd0\x01\x54\x5a\xd1\xf0\x08\xd3\xa9\x13\xe2\x73\x27\xde\x14\x0f\xbe\xf8\x3a\x54\x9c\x78\x1d\x86\xbf\x36\x67\x8f\xf8\xe5\x93\x8f\x8a\xdf\x3c\xb3\x1f\x62\x1e\xdd\x03\x71\x4f\x5e\x7d\xe2\xee\xb7\x0f\xc0\xcc\xfb\x77\x1d\xda\xf9\x7c\xfd\xe0\x01\xf8\x24\x4d\x71\x06\x86\xbc\x7c\x02\x2a\x5e\x3f\x29\x1e\x7e\xfd\x49\x70\xee\x79\x44\xfc\xeb\xfe\xfd\xe2\x35\x9a\x00\x3c\xcb\xb6\xb6\x30\xaa\x3b\x97\xaf\x11\x7f\x2f\x97\x68\x78\x25\x83\x04\x96\xb4\xbf\x8d\x68\xec\x21\xfe\x14\x87\x93\x57\x01\x43\xdd\x0f\x9c\x0a\xb5\x5a\xe5\x54\x25\xba\xec\x16\x5d\x6c\x5c\xec\xdb\x41\x93\x9a\x07\xa7\x53\x81\xe3\xa8\x55\xe2\xf3\xe5\x52\x9b\x43\x52\x3e\xbe\x4e\x6b\x5c\x8c\xf2\x64\x01\xa9\xb1\xc7\xe8\x33\xdb\xec\xc5\xc4\x0c\xf1\x18\x0b\x8a\xf5\xd4\x49\xd5\x6b\xb3\xa6\x50\x57\x02\xea\xd0\xee\xd9\xfb\xfb\x26\x5b\xa6\xff\xfe\x5f\x9e\x52\x24\xe4\x3c\xb4\x6e\xdb\x10\x41\x84\xa3\xbf\xe0\xdd\x0c\xc2\x6b\xc5\x0b\x5d\x66\xef\x82\xec\xd0\x6a\xa8\x34\x3c\x52\x3e\x53\x6c\x82\xb2\xa6\xcd\xf1\xbb\x45\x15\xfc\xba\x69\x93\xec\xef\x44\x74\xec\x7b\xa4\xdd\x3c\x68\x80\x3f\xd9\x9a\xe0\xe4\xd5\x4e\xb5\x5b\xcf\x28\x19\x77\x2c\x9b\x9c\xa2\xd1\x38\x1c\x8a\xd8\x98\xd8\xaa\xa0\x9a\x58\x9a\xa6\xaa\x76\x4b\xd3\x17\x9e\x10\xf6\x45\xc4\x6a\x78\xfe\x2a\x9f\xc0\xeb\x42\x46\xc2\x5b\x45\x3e\x3a\x69\xd3\x0b\x0a\x23\xe4\x66\xa7\xdd\x9d\x7c\xbb\x34\xeb\xc7\x98\xa1\x3b\x4c\x39\xf7\xee\xac\x9e\xa0\x09\x6d\x7a\x6c\xc7\xe9\xfa\xa3\x6f\x3d\xfa\x48\x68\x3d\xe8\xfc\xb3\xde\x3f\x0f\x53\xb9\xed\xe2\x2b\xe2\x37\x17\xc5\x0b\x35\xea\x2f\xa1\x70\xe8\x17\x4f\xbe\xfd\xf9\x67\x67\xf7\x5e\x1d\x2c\x9e\xfd\x52\x5d\x0d\xd9\x97\xc0\x29\x85\x71\x23\x78\x1f\xdd\xf6\x39\xbb\x82\x2d\x23\x36\x42\x22\xaa\xf0\x1b\x13\x75\x3a\xd6\x61\xd5\x68\x58\xb7\x8b\xa8\x0b\x6d\xa2\xb6\x09\x12\x1b\x82\x89\x89\x48\xa1\x88\x23\x97\x47\x83\x0a\x03\x32\x92\x8b\xc3\x41\x64\xbb\x71\x46\xbe\x7d\x82\x3b\x32\x6b\x91\x94\x4a\x09\x8d\x72\x8d\x89\x54\x46\x1a\x75\xa3\xa2\xd2\x6c\xa4\xb2\x53\x30\xe2\x19\x8f\xfd\x74\xe7\x86\xdf\xb6\xef\xfc\x65\x43\xeb\x9b\xf9\x4f\xde\xba\xfe\xd8\xd0\xb2\x89\x9f\x6e\xf3\xed\x1e\x75\x64\x61\x52\x1d\x08\x8f\xee\x45\x6d\xf7\xff\x49\x14\x9f\x12\x1f\x29\xea\x7f\xfb\xaa\x8c\x87\x97\xe1\x7b\xc0\x5a\xd8\x7b\xa1\xf8\x1d\xe5\x19\xdc\xf6\x91\xf0\x2f\xee\x1d\x24\xa0\x5c\xe4\x43\x45\xe8\x5e\xff\xe0\x24\xb7\xdb\xa2\xf0\xe5\xe9\xb4\x5a\x6f\x2c\x12\xba\xe4\x33\x2c\x8b\x0b\xf2\x41\x88\xcd\x53\x28\xbb\x16\x93\x34\x3a\x83\x0e\xeb\x93\x40\xcd\x27\xa5\xe9\x2c\x2c\xb1\x01\x52\x1a\x82\x85\xb8\x21\xc8\x26\x14\xfa\x7c\x85\x09\x2c\xcb\xe5\xab\x8d\x0d\x41\xb5\x99\x2b\x20\x42\xe4\x70\x90\x83\x76\xce\xca\x95\x0d\x60\x79\x32\xd2\x5e\x22\x09\x12\xdf\xf5\x1a\xa2\x43\x51\x78\xdd\x02\xd1\x02\x4a\x2a\x3a\x5c\x7f\x38\xe2\x68\xb5\x24\x80\x3d\x81\x48\x2c\x0f\x70\x8c\x0f\x7f\x1b\x10\x77\x8f\xfa\x14\xa6\xfc\x06\x93\xd9\xfc\x53\xaf\x88\x7b\xba\x9f\x34\x4f\x1b\x3f\x61\xfc\xd8\xfb\xef\x5e\xd2\xfb\xb5\xe7\xf6\xee\x8f\x7d\x5d\x57\x31\x74\xaf\xbb\xe7\xdc\x75\xf3\x6e\x49\x12\xa7\xb6\x9e\xaa\x63\xba\xb5\x3a\x56\x34\xe3\x8a\x2f\xbe\x60\x56\xb4\xae\x17\xf7\xae\xbb\x2b\x94\xd8\xbf\x67\x4e\x49\x56\xd7\xb8\x38\xff\x6d\x83\x97\xad\xbc\x7d\x65\x4c\x49\xd7\xb1\xf1\x29\xb1\xce\xb8\x2e\xfe\x4a\xf6\xfe\xe6\x18\xee\xab\xed\xe2\x2e\x42\xbb\xd5\x08\x31\x8f\xb2\xdd\x90\x12\xf5\xf0\x27\x72\x08\x04\x86\x72\x9c\x5a\xc5\x73\x15\x41\x3d\x4f\xec\x40\x9e\x07\x85\x1e\x70\x45\x10\xac\x28\xb2\xdf\xac\x3c\x82\x12\x19\x5d\xa2\xf6\x6d\x3a\x14\xba\xe9\x9f\xd1\xcd\x3c\xda\x7a\x12\x7b\x44\x0e\x5a\x20\xe6\xec\xd5\xb3\xf0\xa6\xec\x9f\x30\xa1\xed\x5f\xfc\x04\x6e\x83\xc1\x2b\x84\xf0\x4b\x34\x4e\x0a\x5a\xae\x41\x44\x8b\x2f\x64\xbe\x08\x0d\xa4\xb1\x2f\xa4\xdf\x1f\x68\xff\xdd\x2b\xff\x62\xe0\xd1\x02\x79\x5d\x5e\xdb\xef\x7c\x19\x49\x4f\xd2\xb9\x50\xe4\x2d\xa3\xa0\x50\x30\xe7\x43\x83\xe9\xbe\xec\x2c\x83\x4d\x4e\xd0\xb8\x34\x6b\x34\x18\xb9\x10\x8c\x2f\x1c\x6f\x2c\x44\xa5\x91\x7d\xd9\x2b\xa5\xf4\x72\xfe\xfb\xa4\xdd\xec\xa4\x94\x46\x1e\x2d\x4c\x93\x57\x1e\x33\x58\x70\x92\x84\x7e\xb4\x06\x31\xe3\xe5\x94\x24\xdd\x54\x29\xdd\xda\x1b\xd3\x29\xf8\xfc\xff\x94\xee\xc9\xa8\x74\x5b\x3b\xa5\x13\x96\x20\x94\xec\xb7\x33\x18\x48\x3a\x29\x21\x66\x7d\xc8\x67\xf0\xb9\x7c\x7e\x1f\x4b\x80\xee\x04\x37\xdd\xfb\xd2\xc3\x0e\x35\xf1\x98\xae\xc5\x02\xd8\x8d\x26\xf3\x13\x70\x3f\xa4\x95\xfc\xaa\xd5\x9c\x12\x63\x8e\xd3\xe8\xf4\x5a\x4d\x64\x0d\x96\xb1\x7d\x56\xd4\x66\xf7\xa4\x7a\x0b\x89\xda\xe6\x89\xf9\x89\xd7\x96\xf4\x2a\x5b\xbd\x79\xf3\xea\xb2\x5e\x25\xcc\x67\x90\xde\xf7\x8e\x6d\x03\x93\x07\x6e\xbb\xa3\x6f\x40\xca\xd7\xd0\x76\x12\xff\xc4\xae\x26\xf9\x26\xfb\xf5\x44\xdc\x12\x2a\xd0\xe9\x91\x5a\x89\xb5\x6b\x38\x94\x1b\x73\x8e\x2e\x3c\x8e\x5a\x10\x03\xbc\x40\x33\xb6\xd9\xad\xa9\x5e\xa3\x07\x2e\x76\xe4\xc6\xec\xea\x28\xa7\xd5\x73\x23\xcc\x6a\x24\xc1\xac\xe5\x74\x7a\x8d\xf6\x46\x98\x53\xbd\x34\x53\xba\xd6\xa2\xd8\x5d\xc8\xad\x8e\xce\x0b\x56\xff\x27\x98\x19\xad\x56\xa1\x21\x88\x50\x23\xac\x5c\xc3\x13\x6c\x7c\x16\x73\x1d\xcc\x29\x45\xc5\x34\x63\x82\x12\x22\x47\x7d\x38\xb3\x23\xb7\xdd\xd1\xa8\x41\x9d\x60\xb6\x53\x3f\x35\xa4\xe6\xb1\x52\xc9\xdb\x35\x46\xab\x4e\x67\xe4\x8d\x0e\x27\x52\x5f\x07\xfa\xcd\xb1\x1e\x55\x9b\x68\xfc\x63\xb1\xe3\x3a\xaa\x25\xda\x2f\xa2\xea\x66\xa7\xbe\x8d\x7a\x05\x69\x11\x64\xa5\xac\xe9\x70\xda\x35\x3a\xeb\x1a\x93\x9f\xb6\x8d\xd4\x34\xb4\x96\x31\xd1\x95\x8d\x52\xf4\xd1\xad\x14\x55\xfb\xa8\xf6\x6a\xbf\x88\x6e\xb7\x10\xee\xb8\x46\x98\xc0\x52\x26\xc1\xc2\x90\x3e\x64\x2f\x7f\x9c\x59\x43\x6c\x2d\x3d\xeb\x14\xa8\x83\x61\x7c\x5c\xac\xc1\xe4\xb4\x31\xc8\xc6\xea\xb5\xbc\x52\x5e\xa1\xfe\xd9\xe7\xe7\x0c\x9d\x90\xdf\xe1\xb1\x42\x14\x9a\xf9\x8f\xa0\x32\xc0\x17\xa2\xeb\xcd\x1b\x41\xab\xad\x60\x47\xff\x01\x70\x92\xfe\x2a\x6c\xfb\x9a\x79\x81\x7b\x89\xd8\x8c\x19\xe8\x16\xbf\x27\xc5\xa1\x48\x30\x99\x90\x02\x65\x66\x69\xdc\x23\x82\x7a\x8d\x26\x2d\xd6\xe1\x88\x8d\xb5\x0e\x0b\xc6\x22\x2e\x6d\x58\x90\x6b\x57\x5b\xd2\xf4\x1d\xed\xc9\x66\x46\xb5\x65\xbe\x64\x21\xd1\x91\xde\xd4\xb0\xe2\xb2\xfb\x64\xb7\x3a\x5e\x28\x26\xb7\x26\xa0\x52\x5b\x07\x92\xf9\x67\x62\x5e\x18\xb6\xf9\xed\x35\x4f\xbe\xb0\xf8\xd5\xa5\x83\x97\x25\xb2\x30\x7d\x76\xe1\xe2\x94\xec\x9a\xf9\x2f\xbd\x27\xb6\xea\x03\xc5\xfe\xdb\xfb\x0e\xe8\x35\xe1\x01\x66\xd3\x5b\xe2\xce\x5f\x57\xbd\xf3\xda\x6e\xc8\xdc\x11\x18\xec\x8f\x39\xf8\x4a\x5a\xdc\xb9\x12\xf1\x6a\xe8\xbb\xf2\xf1\x0b\x3f\x9e\x56\x73\xbb\xb4\x86\x1d\xd3\xa8\x20\xec\x31\x62\x03\x71\x84\xc2\x0e\xfa\x17\xaa\x88\x58\xe3\x95\x00\x3c\xcb\x68\x35\xbc\x92\xf4\xbe\x95\xc4\x80\x30\xdd\xaf\x85\x39\x5a\xa8\xd6\x42\x85\x16\x88\x08\x72\x69\xc1\xa0\x85\x9f\xb4\xf0\x9e\x16\x76\x69\x61\x8d\xf4\x3c\x4f\x0b\xc3\xb4\x80\xb4\x50\xf2\x85\xf4\xc3\xf3\x5a\xb8\x5f\x4a\xe3\x97\xde\xd6\x6b\xe1\xaa\x16\x5e\x95\x12\xc8\xd9\x55\x48\x19\x91\x04\xed\x73\x9f\x1d\x33\xa2\x9d\x26\x49\x23\x7a\x20\xda\x41\xab\x4b\x9e\xaf\x10\xdc\x60\x05\x62\x5b\xb9\x51\x26\xdc\x07\x73\xa0\x2e\xd4\xa8\x2c\x3b\x8f\xfb\x89\x57\x2f\xb1\x07\x5a\x02\x97\xd8\xa6\x24\x31\x34\x8c\x91\xfc\x24\xdf\x11\x4b\xb8\xb7\x49\x3d\x05\xc2\xbb\x46\x86\x25\x86\x9f\xa0\x50\x72\xb8\x3a\xc8\x51\x17\x6d\xea\x2e\x57\xda\x79\x31\x9a\xbc\xc2\x85\x7d\x3e\xd4\x57\xbc\xcc\x8a\x62\x09\x5f\xf9\xef\x67\x85\xb2\xdf\x9b\x48\x5e\x1b\x48\x5e\xd4\xcf\x46\x8d\x26\xfa\xf5\x44\x81\x29\xb1\x42\x41\x7d\x58\x55\x1a\x2d\xd3\xd4\xf6\x8d\x3f\x45\x65\x2c\x63\x58\x52\x42\x55\x10\x63\x25\xc1\x24\xc4\x43\x36\x30\x2a\x16\x1c\x3a\x63\x19\xf5\x6b\xa3\x48\x45\xb2\xfd\x92\x49\x94\x9b\xa4\xe4\xe4\xbb\x76\x67\x9a\x88\x8b\xbe\xb9\x50\x09\xb4\x6f\xa0\x04\xb7\x75\x03\x9e\x10\x6a\x60\xe7\x86\x30\x36\x84\x3e\x65\xca\xc5\x92\x5d\x8c\x82\x51\xec\xbc\x16\x1a\x10\xea\xfa\xa5\x3c\x16\x71\x2b\x2e\x61\x47\x33\x4e\x79\xfd\x22\x48\xeb\x1d\x0f\x06\xe1\x70\xe7\xf5\x91\xb7\x92\x56\x2e\xf9\xe2\x0b\x22\xef\x23\x3e\xd9\x06\x5e\x08\x49\xe9\xef\xc3\x66\x38\xc8\xf4\x23\xe9\xed\x7e\x15\xe1\x7f\x96\xe8\xe8\x87\xc3\xc0\x82\x1c\xfe\x81\xa0\xe5\x3e\x70\x91\xf7\xe8\x4a\x1f\x9a\x06\xb7\x7d\xcd\x4e\xe7\x2b\x09\x07\x3c\xe0\xaf\xe6\x30\x20\x1e\xf3\x0c\x51\x95\xa4\x57\xc4\xe1\x83\x41\x8e\x13\x90\xb3\x4d\x05\x57\x55\xf0\xaa\x0a\x1e\x57\xc1\x6a\x15\xcc\x8e\xba\xae\x52\x41\xae\x0a\xf4\x2a\xe8\xfe\x93\x0a\xde\x53\xc1\xf3\x2a\xf8\x51\x05\xe7\x55\xf0\x9c\x0a\xee\x57\xc1\x1c\xe9\x62\xb3\x94\x66\x98\x0a\xda\x27\xc9\x3b\xa6\xce\x23\x53\xe6\xb9\x25\x61\xd7\xf3\x0e\xc7\x35\x22\x01\x3c\x40\x4c\x6e\x33\xf8\xf0\x9c\x7d\xe2\xcf\x4d\x50\x7c\x05\x1e\x39\xee\xc4\x3f\xef\x0d\xdd\xc9\x55\x48\x71\x97\x50\x19\xfa\x98\x9b\xc9\xbc\x81\x2c\xc4\x1e\xcd\x44\x41\xbf\x31\xd5\x65\xb0\x73\xac\x2a\x9e\xb4\x69\x56\xb6\xd5\xa3\xf5\x34\x81\xb3\x31\x68\x32\x68\x63\xd2\x85\x74\x72\xed\xb7\x11\xb2\xc9\x15\x4a\x85\x61\x02\x43\xbf\x56\x0b\xe7\x85\xab\x02\xa9\x66\xee\xf8\xb9\xbe\xf0\x9a\x30\xdf\x75\xab\x2f\xf2\x23\xe3\xe7\x51\x23\xe5\xf4\x2b\x25\x49\x88\xd8\x69\x5c\x54\xef\x9e\x9b\x79\x7c\xe3\x47\xcb\xd6\xbd\x5d\x77\xf4\xd8\xbd\x53\x9f\xea\xbd\xfa\xcd\x9d\x8d\xe2\x53\x4b\x26\x64\x4d\xea\x7f\x4b\x30\x20\x26\x14\x8e\xe9\x31\xa0\x6a\xcc\x90\xee\xd5\x78\xc0\xc3\x1f\xfe\xf8\xd7\x73\x7b\x1f\x7f\x6f\xf6\x9a\xaf\xce\x26\xbc\x39\x61\xca\xac\xc0\xe8\x99\x2f\xce\xbd\x75\xf6\xa8\xca\xd9\x55\xb2\x6e\xd9\x89\x10\x5f\xcd\x9e\x96\x7c\xbc\x89\xf6\x66\x78\x81\x7a\x69\x77\xc4\xd7\x02\xc9\xab\x11\x76\x4e\x60\xa7\xb7\x74\x65\x4f\xb7\xec\x98\x20\xa7\x73\xb6\x89\xec\x41\x56\x81\xcc\xc8\xe3\xd7\x9b\x91\x9a\x50\xb8\xc5\x4a\xf4\xa9\xfe\x50\x90\xa4\xa7\xd6\xa9\x2f\x8a\x65\x38\x63\x01\x9d\x13\x90\x66\x2f\x23\x4e\xa6\xe0\x5c\xf0\xfe\x1d\xeb\x2e\x2c\x9e\xfa\xc6\xae\xdd\xaf\x61\x8c\xb6\xff\x78\xe7\xfa\x9f\xb7\x8a\x08\xe3\x57\xbe\xfc\xcb\xeb\xa2\xbc\x66\xa2\x6d\xb5\x58\x82\x5f\xe1\xce\x13\xdd\xe3\xf5\x9b\xf5\x56\xd6\xaa\x50\x38\x1d\x1a\x63\x45\x50\x43\x00\xaf\x90\x88\x4f\x36\xfa\x3b\xd6\xc7\x26\xa5\xca\xe3\xdf\x46\x8a\x48\xd9\xdd\xce\x6a\xb4\xf0\x31\x99\xe3\x2c\x7d\x0a\x1f\xfe\xf0\x95\xd1\x7d\xf3\x6f\x19\x52\x71\x41\x2c\xd1\x09\x97\x9d\x6f\xb2\xab\x8f\x9e\x31\x5f\x71\xde\x36\xa1\x65\x75\xc3\x69\x59\x86\x67\x82\x89\x2d\x61\x8b\x91\x15\x65\xa1\x72\x7f\x66\xa2\x32\xc3\xac\x34\x67\xe7\xa4\xbb\xdd\xb1\x07\x83\x36\xf7\x73\x63\x6d\xde\x83\xc1\x04\x9b\x49\xad\xe6\x0e\x06\x91\xfa\xb9\xb1\xc8\x70\x30\xa8\x28\xa5\x2b\x84\x73\xc7\xe7\x67\x66\x86\x1b\x59\xbe\x88\x16\x1c\x04\x32\x49\x72\x17\x4a\x2d\x2c\x05\x2e\xd3\x01\xd3\xf9\x29\x6d\x70\xe9\x71\x4e\x79\x5d\xf9\xfa\x60\xdf\x45\xfd\x67\x3d\x51\xb8\xe2\x4f\x4b\x87\x6d\x98\x57\xba\xa4\x92\x3c\x5b\x3b\x6e\xc0\xe2\xde\x73\x1f\x1b\xb9\x6b\xf0\x94\xfe\x71\x1b\xe6\xf9\x17\xe2\x7f\xa6\xc7\xe4\x7a\xbb\x5c\xac\x74\xe6\x65\x8e\xbb\x92\xed\x11\x13\xb2\x62\xb2\x33\xb3\x2f\x56\xe6\xc4\xb8\xb4\xe3\xae\x64\x25\x53\x3e\x8c\x47\x29\x6c\x19\x97\x49\xda\x6b\x85\x7f\xa4\x46\xad\x55\x19\x04\x62\x6f\x32\x80\x35\x4a\x93\x8e\x53\xea\x94\x56\x8b\x41\xa1\x54\x1c\x0c\x6a\x0d\x6a\x30\xa8\xef\x57\x63\xb5\x41\x59\xa1\xc4\x48\xe9\x52\xfa\xc9\xc5\x1a\xe5\x2e\x25\xaf\x66\x94\x46\x8e\x25\x95\xc6\xe8\x2a\x0b\x7a\x36\x91\xdd\xcc\x32\xac\xdf\xe2\x2c\x63\x49\x3b\x10\xfa\x3e\xd5\xee\x16\x3e\xf7\x14\xb9\xed\x54\x7f\x79\x9e\x42\xf0\x14\x53\x96\x23\xe6\xb9\xd9\xc7\xf8\xac\x6e\xc6\x6d\x85\x73\x6b\x2f\xae\xbd\x02\x03\xf6\x8a\x66\x3c\xe6\xce\x0b\xeb\x5a\xc5\x1d\x7b\xb1\x1e\x3c\xa2\xf8\x19\x0c\xba\x0a\x58\x14\xaf\x8a\x0d\x9f\x11\x5e\x9c\x8c\xfe\xc9\x0e\x60\x2b\xc2\xeb\x3e\x2a\xfd\x1a\xb5\x80\x15\x74\x81\xab\x56\xa3\x54\x34\x01\x6a\x08\x2a\x95\x1c\xb0\x1c\xb9\xf4\x2b\x83\x7a\x16\x34\x0c\x0b\x28\x7c\x07\x89\x50\x0a\x0c\x20\xc9\x91\xbd\x7d\xde\xd5\x91\x1b\xb5\xce\xc6\x27\x4b\x40\x08\x1f\x93\x99\x6b\xad\xf1\xf2\xc1\xbc\xb4\x75\x6b\xa8\xeb\xd6\xad\x30\x79\xeb\x56\x99\x46\xba\x10\xf1\xe7\xe3\x4c\xd2\xfa\x84\xee\xfe\x78\x81\x45\x2a\xba\xd8\x46\xad\x11\x08\x0e\x05\x20\xd6\x08\xe6\x78\x26\x0f\xfb\x31\x21\xed\xdc\xf1\xbe\x5c\x22\x76\x7a\xe6\xfa\x7c\x37\x14\x68\x04\xab\x12\xa4\xf2\xba\xb0\xb8\xf5\x35\xc6\xdf\x22\x92\x2a\x2d\x86\xde\x30\xe6\x9a\xf8\x8d\xf8\xed\x35\xf1\xda\xd5\xab\x37\x96\x59\xe2\x8f\xbb\xae\x4c\x9e\xc3\x98\xc9\x63\xfd\x2c\x66\x41\x52\x5a\xe3\x7d\x37\x2f\x91\x2a\x0d\x30\x4a\x25\x32\xa5\xad\x27\x58\x4c\x4a\xc4\x10\x7f\x0d\xec\xe0\xb8\x26\xee\x15\x5f\x0d\x6d\xa4\x25\x62\xf4\x28\x29\xaf\x98\xa5\x2b\x6e\x94\x44\x33\x1a\xb0\x82\x43\x3c\x8b\x14\x2c\xa3\x56\xd1\x6b\x22\x26\x24\x41\xd1\xb1\xfe\xd3\x67\x54\x82\x31\xc5\x4d\xbe\x1f\x85\x73\x70\xae\xb5\x01\x37\x8b\xeb\xc4\x75\x78\x39\xe6\x43\xcd\xa1\x3b\x47\x60\x1e\x0e\x88\x92\xbd\x4c\xda\xf2\x28\x3b\x00\xff\x4c\xe4\x4e\xba\xdf\x41\xa3\x0b\xf1\x02\xb0\x07\x83\xd4\xe1\xb4\x0a\x36\x03\x0b\x61\x76\xca\x6d\xef\xdd\x75\xc9\x2b\x96\xd6\x50\xd2\x66\x39\x74\x14\xf7\x7a\x40\xac\x44\x80\x93\x42\x0f\x31\x1f\xf0\x07\x08\xaf\xc6\xf8\x55\x08\x14\x60\xb7\x19\xd5\x44\xb1\xe5\xe6\x9e\x8b\x12\x62\x1e\x63\xc4\xed\x9e\x08\x59\x89\xdd\x04\xde\x8a\xeb\xb7\xec\x5b\x55\x5a\xee\x4b\x49\xd0\x1a\x52\xdd\x86\x64\x25\x1f\x7a\x48\x08\xbc\xf1\x6b\x69\x5e\x5a\x81\x4a\x91\xe1\xf5\x7a\xa6\xc9\xb2\x8e\x0b\x3d\x84\xeb\x49\x19\x16\x5a\x06\xb6\x28\x2c\x56\x5a\x06\xba\xae\x0c\x9f\xb1\x63\x50\xce\x2e\x71\x77\x51\x21\x4e\xda\xf2\xe4\xfa\xee\x43\xf3\x93\xdd\x31\xaa\xc4\x44\x43\xbc\x9d\x3f\xf0\xfb\xbe\x93\xff\xea\x99\xeb\x2d\x34\xb0\xe9\x29\xbe\xd5\x92\x8c\xfb\x15\xa7\x70\xf5\xb8\x81\xd0\xb5\xa3\x5e\x0e\x73\xd0\x04\xf8\x70\x10\x5a\x3b\x22\x0b\xd0\x50\x07\x2a\xee\x55\x9c\x52\x57\x27\xc3\xf4\x71\x68\x0b\x9e\x26\x94\x51\x5d\x7c\x04\x33\x2c\xd3\x04\xfc\xd1\xb1\x8c\x88\x9a\x25\x6f\x5c\x90\x01\xf2\xc0\xc7\x75\x75\x42\xd9\xaf\xe5\x52\x1a\x7c\x5f\x68\x8b\x54\x0e\x87\x52\x8f\x30\x84\x8a\x48\x9a\x86\xb1\x58\xe0\x44\xc4\x48\x05\xa2\x56\xd9\x9a\x22\xc9\xc3\x59\x50\x7c\x7b\xf0\x7d\x4c\x5a\x68\x5a\x1d\x6e\xa8\x6b\x99\x25\xc3\x1b\xda\xc2\x24\x84\xf3\x21\x54\xce\x49\xf9\x10\xd2\x10\x31\x27\xe5\x83\xaf\xcf\x87\x91\x16\xa8\xaa\x98\xb4\x3a\x52\x81\xe6\xcf\xd8\x07\xc2\xf0\xd0\x7a\x93\x3a\x70\x28\x39\x92\xcf\xd1\xb1\xac\x20\xe5\x72\x94\xe6\x12\xa9\x4c\x7b\x85\xa8\x0f\xc8\x7d\x75\x78\x47\xeb\xc7\x42\x59\xcb\xac\x3a\x19\x77\x4c\x82\x94\x47\xea\x11\x0e\xf3\x38\x0c\x0b\xd3\xfc\x9f\x60\xf1\x19\x55\x78\x07\x85\x85\x7d\xa0\xf9\xb3\x28\xdc\x90\x7c\x04\x94\x5d\xcf\x01\x10\x7b\x45\xca\x89\x55\x0a\xe2\x75\xf0\x74\x64\xd6\xa1\x1f\x29\x92\x08\x58\x04\x4b\x12\x5c\xd1\x78\x92\xf2\xcc\x3a\x2a\xb0\x58\x41\x81\xf3\x2b\xc7\x22\x05\x2f\x12\xf8\x84\x4e\xf0\x45\xf2\x6c\x87\xd0\x23\xc1\x28\x03\xf9\x6b\x39\x41\x99\x94\x9f\xd4\x7e\xc4\x96\xa8\x67\x94\xc4\x48\x15\x3a\x32\xa4\x4b\xa1\xa3\xa8\x86\x4e\xe1\x47\x41\x49\xc9\x47\x6a\x02\xee\x55\xda\x92\x84\x8a\x5a\x66\xb1\x0f\xb4\xd3\x9e\x04\x63\x6e\xbd\x40\x4c\xb2\x0e\x20\x99\x66\x8a\x87\xff\x98\x27\x75\x3f\xb2\x4a\xa8\xdc\x21\xc1\x49\x9b\x24\x02\x27\xc9\x53\x4d\x24\xa3\x52\xd0\x72\x0a\x05\x96\x9c\x69\x78\xbf\x7a\x2c\xd2\xa8\x48\xe5\x15\x44\xbd\x90\x9c\x8f\x04\x39\x5a\xff\xb0\xcb\x41\x3b\x0a\x8c\x9d\xf2\x77\x87\x51\x21\xa1\x37\x52\x8c\x0c\x3e\xb1\x2e\x7f\x85\xb9\x5c\x3d\x33\x5d\xd2\x09\x39\xc4\x2a\x15\x04\x25\x91\xbd\x0a\x8e\x95\xda\x8c\x0b\x45\x6a\xd0\x12\xe9\x66\x75\xc4\xe6\x64\xc2\x72\x9e\x20\xa5\xb9\x37\xe1\xad\xcb\x75\x75\xe2\x4e\x99\xbf\x30\x5c\x26\x6d\xf7\x81\xc4\x5f\x02\x4a\x3b\xc2\xb1\x0a\x92\xa1\x70\x74\xac\x4c\x18\x6c\xc3\x58\x81\x21\x28\x27\xf4\x90\x5f\xea\xeb\x44\xa1\x1e\xe9\x20\x59\x41\xad\xcc\x7a\xca\x7a\xc2\x7e\x61\xfa\x22\x70\x2a\x51\x8f\x7a\x3a\xae\xa5\x42\x32\x9e\x31\xcf\xab\x95\x22\x2b\x48\xe0\xb2\xa1\x08\x27\xb6\x74\x8c\x9f\x4b\x10\x77\x2c\x9b\x0c\x7b\xcf\x87\xb9\x52\x42\x0a\x33\xbd\xee\x52\x5d\x6b\x92\x24\x17\x2e\x87\x69\x44\x89\xba\x1e\xe1\x95\x2a\x25\x01\xf6\xe8\x58\xcc\xa9\x08\x0d\x0b\x0d\x63\x41\x4d\x7a\x70\x3c\x29\xa2\x3e\xa8\x6c\x65\x15\xa2\xec\xcd\x88\x7c\xe1\x1a\x84\x6b\x61\x0d\x2f\x27\x37\x72\xf5\x62\x3c\xc9\x5a\xe2\x7c\x8a\x76\xce\x13\xc1\x8d\x54\x17\xda\x2f\xec\x77\x44\xc9\x6b\x78\x09\x37\x0c\xd2\xc8\xb8\x21\x5d\x1e\xd2\xfd\x26\xa5\x34\x06\xf9\x90\xba\x43\xbc\x84\x2b\xe5\x0b\xb7\x42\xe6\x75\x72\x26\xfc\x7d\x99\xf9\xb4\xb5\x9e\xa0\x0f\x2f\x20\x85\x93\xaa\x35\x1f\x67\x67\xd3\xda\x85\xf9\x49\xc2\x61\xb7\xa3\x4a\x9e\x51\x31\x32\x0a\x69\x94\x29\x85\xc8\x33\x12\x0a\xf9\x16\xac\x94\x19\x2b\x74\x13\x14\xca\xad\x5e\x28\x2f\x98\x57\x51\xe4\x11\x99\x04\x73\x49\x1d\x9b\xd3\x99\xcf\x23\x3c\xfb\x81\x84\xbf\x6e\x37\xe0\xcf\xaf\x1a\x8b\x54\x04\x6b\xfc\x8d\xbc\xd6\x19\x83\x4c\x64\x41\x3e\x91\x79\x9f\x52\x04\xca\x52\x4f\x26\x5a\x2c\x97\xd1\x8e\x3f\xb5\x42\xa3\x90\x4a\x41\x8c\x86\x91\x5a\x89\x55\x2a\x35\x2a\x19\x7f\xaa\x10\x16\x44\x89\x98\x0f\x07\xb9\x3f\xc6\x1f\x9d\x19\x2a\x04\xfa\xe5\x66\x3e\xa8\x6b\xad\xc7\x0b\xea\xc4\x78\xbc\x80\x99\xde\x9c\xce\xf5\x97\xea\x56\x47\x69\x90\xf2\x0a\xa1\x69\x25\x2a\xa9\x27\x74\x27\xd5\x8e\xca\x38\x85\x42\x2d\x35\x17\xc1\x5e\x28\x22\xec\x5a\xda\x85\x5d\x66\x67\x02\x6c\x5f\xe5\x14\x96\x78\xb2\x30\x6e\x4d\x22\xd5\x94\xe8\x2f\x2c\x4f\x94\xa8\xf0\x08\x96\x4a\x20\x94\xa1\x90\xf0\x47\xaa\xc8\xaa\x69\x44\x5f\xdc\x10\xc4\x8a\x56\xc4\x37\x4b\x8e\x61\x99\x9d\x89\x4f\x66\x79\x52\x16\xd3\xbb\x0e\xae\xb5\x26\xd7\x5d\x92\x44\x2a\xe7\xa1\x42\x95\xd0\x5e\xb8\x0e\x32\xee\x14\x92\x5c\x11\x68\x0b\x69\x38\x89\xf6\x54\x2c\xab\x55\xa8\xa5\x3a\x28\x5a\xa4\xca\xd4\x13\x52\xe0\x65\x56\xed\x5c\x9d\xe8\x02\xc3\xdf\x97\xeb\x98\xf2\xd6\x64\xc2\xba\x70\x2d\x74\xaf\x50\xd6\x7c\xbc\x8e\xbb\x44\xaa\x46\xe9\x02\xe6\x4a\xb2\x5c\xa6\x3d\xac\xc2\x1d\xb4\x27\x34\xff\x77\x69\xcf\x27\xd3\x1e\x11\x6a\x12\xed\x31\x9f\x37\xa7\x87\x65\xb1\x24\x73\x28\xed\x21\x41\x25\x48\x35\x93\xe9\x9c\x25\xb4\x07\x2a\x05\xdb\xcc\x63\x0c\x1d\x8a\xe3\x26\xb4\x07\x72\x01\x14\x81\x1f\x90\xaa\x5c\x93\xc9\x2f\x4c\x7c\x92\xbc\x94\xca\x88\xc6\x5f\x34\xed\x29\x01\xda\x69\xaf\x85\xe5\x9b\x23\xa5\x85\xfe\x98\x77\x69\x79\x6e\x9f\x4c\x7b\xad\xc9\x4c\x79\x9d\x28\xd4\x85\xee\x85\x6b\xa4\x6e\x5c\xff\x16\x49\xa0\x76\xe8\x57\x35\xea\xdd\x40\xd0\xa7\x0a\x2b\x04\x25\xa5\x3e\xad\x5a\xfc\x4f\xf4\xd7\x59\x06\x76\xa2\xc1\x76\xbd\x1b\xd6\xbd\x12\x19\x12\x59\x11\x96\x51\x92\x5e\x53\xa3\xd2\x23\x72\x71\x54\x34\xf1\xbc\xa0\xa1\x88\x25\xaa\x88\xd5\x0a\x6a\x11\x29\xae\xb7\x14\x7c\xed\x08\x35\x76\xa6\x49\x49\xb4\x4b\x54\x49\x04\x13\xd5\x14\x61\x5d\x2f\x49\x78\x44\xfa\x52\x91\x32\x19\xd2\x82\x7a\x54\xd1\xa0\x51\x28\xf4\x4a\x83\xcc\x02\x08\x0c\x20\x41\xa0\xe3\x79\xa3\x46\x2f\x55\x52\xd3\x22\xc9\x7d\xd2\x3b\x61\x43\x2a\xdc\xac\x04\x49\x1e\xfb\x6e\x42\xa6\xbe\xf6\x89\x43\x59\x1f\xca\x96\xd0\xf4\xba\xba\x4b\x92\x94\x94\xc8\x35\xb4\x45\x59\x4f\x08\xb6\x35\x49\x59\x4f\x49\x36\xca\xfe\x20\x18\xa8\xa7\x34\xab\x51\xc9\x3a\x98\x10\x2d\xd1\xc2\xd1\x64\xab\xbe\x81\x6c\xa3\xe8\xb6\x13\xe1\x7a\xda\x49\x37\x42\xbb\xbf\x96\x53\xc9\xd9\x2e\xd7\xc2\x38\xef\x19\xc6\xb9\x50\x3f\x96\x98\x65\x54\x43\xb0\x92\xf6\x57\xf3\xa2\xe2\x06\xe3\xa7\x03\xe5\x9d\x8c\x34\x0f\x85\xc1\xa3\x22\x34\x2c\x69\xd3\x76\x53\x88\xf3\x50\x84\x33\xed\xe5\xc9\xf8\x1e\xd6\xc0\xab\x54\x4a\xb5\x41\x26\x68\xcc\x18\x64\x82\x16\xb4\x5a\x83\x5e\x23\x11\xb4\x3e\xc4\xa8\xc5\x88\xfa\x6b\x41\xac\x24\x7f\x6e\x46\xd5\x11\x49\x47\x5b\x9c\xf6\x54\x65\xc1\xda\x5b\xb2\x0f\x28\x65\xd7\x49\xd2\x55\xd6\xee\x84\xc0\x65\xf9\x8a\x65\xbb\x87\xc8\x75\x5a\xff\x3e\x8d\x6a\x86\xd1\xb2\x12\xb1\x11\x19\xab\xa0\xcb\xaf\x14\x72\x63\x2b\x5b\xa2\xcd\xb5\x50\x84\x8d\x3b\x09\xda\x68\xa3\x2d\x6c\xa3\x10\x02\x0f\x4d\xe3\x5e\x25\x58\x27\x6d\xcc\x7c\x4e\x31\x12\x65\x13\xaa\x91\xbf\x9e\xd1\xb6\xf3\x33\xdb\x4e\xe5\x48\xc3\xab\x44\xc5\x0d\xe6\xe1\x75\x72\x23\xba\x3c\x8f\x6c\x28\xca\xaa\x3f\x6c\x2a\x86\xed\x2d\xa6\xbd\x8e\x9c\x14\x79\x61\x24\xd1\xfe\x06\xaa\xfd\x09\x23\xeb\x18\xc6\xc0\x61\x03\x96\xa8\x5c\xab\x50\x18\xf5\x3a\x49\xd4\xeb\x5b\x94\x52\xff\x84\x5c\xf2\x6c\x48\x1d\x26\xf2\xc8\xf2\x95\xe8\x2a\x87\xb9\x4d\xc2\xb6\x4f\xe6\x38\xab\xbb\x90\x90\x39\xc5\xb6\x4c\xe9\x78\x41\x73\x6f\xd2\xea\x9f\x53\x1c\x70\x97\x24\xd9\x12\xb6\x01\xc3\x74\xd7\xa7\x11\x29\x14\x1a\x0e\x6b\xe4\x9e\x80\xa0\x56\x6b\xdb\xf1\x1e\x8a\x36\x69\x5b\xfe\x13\xde\x25\x06\x93\xf0\x2e\x19\x9e\x61\xf3\x90\xf9\x9c\x30\x96\x64\x22\x76\xd8\xcd\x14\xef\xa4\x88\x88\x0d\x24\x17\x2c\x93\xba\xc0\x34\x2b\x6f\x30\xa1\x6f\x8e\xf7\xf0\x34\x09\x29\x4f\x12\xd8\x70\xad\x5d\x64\x4b\x26\x35\xc5\x7b\x94\xde\xd3\xa3\x11\x8d\x4a\x8d\xc6\xa0\x68\x27\x76\xce\x20\xdb\x77\xac\x5e\x6f\xd4\x6a\x24\x5c\x6b\x43\x9c\xa4\x7e\xa9\xb2\x55\xb5\x74\x28\xdb\xce\x68\xef\xa8\x75\x87\x1e\x2c\x74\xd3\x9a\x4b\x82\x2e\x74\x6f\x98\xe2\xc5\x78\xee\x55\x49\xbc\xb2\xb3\x09\xc1\x13\x01\x5f\x17\x65\xe7\x9b\xd1\x18\xbf\x56\xad\xd7\x5b\xb5\x4a\x83\x81\xc7\x66\x8b\x99\xca\x19\x2d\x95\x33\x16\x13\x91\x33\x1a\x56\xb2\x60\x1a\x83\x4a\xae\xc5\x20\x13\xe2\x91\xa0\x96\x52\x7e\x18\x9e\xa8\x0e\x40\x44\xe6\x18\xa3\xba\x01\x61\xd1\xd3\x2e\xf3\xdb\x45\x50\xbb\xe4\x0f\x8b\xa2\xb0\xf8\x97\xe5\x51\x34\x7c\x01\xbf\x92\xb5\x9a\x94\x4a\xbd\xc6\x42\xb0\xc3\x36\x12\x8c\x71\x66\x85\x45\x21\xb3\x88\xd6\x82\x0c\xa4\xa9\xb4\x3a\xad\x04\xa5\x09\xeb\x5a\xa9\x66\x90\xd6\xa8\x5c\xd7\x66\x11\xf8\x8c\x9d\x3a\x7f\x72\x7c\xa7\xc2\x0e\xb3\x45\xe2\x1d\x31\x9e\x36\x66\x58\x49\xc8\xad\x29\x35\x2a\xf5\x2f\x6a\x87\x8d\xb6\xa7\x11\xd9\xd1\xcc\x06\xac\xd7\x73\x1a\x87\x86\x82\xa4\x19\x6b\x55\x2a\x1d\x16\xb5\xda\xae\x70\x50\xdb\x90\xaa\x49\x9d\xce\xc9\x59\x6d\x56\x4a\xca\xea\x20\xb6\xb5\x20\x53\xb3\x3e\xd2\xc0\x1a\x55\xc8\x28\x44\xf3\x55\xf8\xa2\x03\x9f\xc6\x76\x06\x8b\x02\x9c\x89\xe6\x34\x5f\x58\xc6\xd1\x46\xbf\x14\xc5\x71\x61\x02\x90\x1a\xbf\xf9\xb8\xcc\x79\x92\xd4\x93\xe7\x14\x10\x9e\xc9\x3d\x23\xc9\x60\x53\x83\x14\xe6\xa5\x99\xc6\x63\x6b\xef\xad\x18\xdd\xdc\x33\xcd\xb7\x72\xcf\xe0\x99\xec\x15\xf9\x7d\x52\x6f\x72\xd7\xf1\x3e\x95\x07\xb9\x37\xbc\x1f\xda\xc2\x7e\xd2\xf1\xbe\x94\xbf\xb9\x31\x9c\xbf\xd8\x11\x17\x26\x3a\x81\xb2\x3e\xfc\x3e\xfe\xe8\xa6\xef\x4b\x01\x3d\xc9\xfb\xf8\xa3\x50\x06\x39\xe4\xf7\xf1\xc5\xa8\xfc\x81\x45\xdc\x8d\xef\x93\xbc\xdb\xdf\xcf\x40\x53\x43\xff\xe2\x9e\xe1\x9f\x6c\x8f\x3d\x63\x96\xbc\x59\x23\x2b\xa4\xa8\xdf\x47\x31\xea\x8e\x4a\x51\x5f\x34\x00\x95\xa3\x61\x68\x24\x1a\x85\xc6\xa2\x2a\x34\x09\x4d\x45\x33\xd0\x6c\x34\x1f\x2d\x46\xcb\xd1\x6a\xb4\x0e\xdd\x85\x36\xa1\xcd\x68\x0b\xda\x81\x1e\x46\x8f\xa3\x27\xd1\xd3\xb8\xab\x7f\xe6\x13\x8f\x3e\xb8\xad\xee\xa9\xa7\xf6\xcc\xbc\xf5\x96\x6c\xed\xd2\xa5\xb7\x57\xf6\xcb\xd2\x2c\xb9\x6d\x48\x61\x3c\xb7\x71\xe3\xe4\xc1\x05\x71\xec\xdd\x73\x83\xbd\xd3\x8d\x2b\x57\xce\x19\xed\x4f\x33\xac\xa8\x19\x5e\xe2\x54\xde\x77\x5f\x75\x45\x57\x87\xe2\xde\x85\xe3\x7b\xa6\x58\xd7\xae\x5d\x30\xae\x47\xb2\x65\xcd\x9a\x7b\x57\xdc\xbd\x84\x5b\xbf\xeb\x91\x9d\x5b\xef\xdf\xb3\x67\xda\xc0\x2e\x6e\xb8\xf3\xce\xda\xb2\x3c\x17\x5a\xbf\x7e\xff\xbe\xa7\x37\x6f\xba\x6b\xfd\x5d\x4d\xc0\x34\x04\x9f\x9c\x3a\x69\x46\xed\x0c\x72\xe9\x57\x05\x77\x4d\xae\xae\xad\x1a\x3b\xaa\x72\x94\x7c\x3b\x6e\x74\xe5\xe3\x23\x87\x95\x97\x95\xcb\xb7\x8f\x54\x0c\x2e\xeb\x5b\x3a\xa0\xdf\x00\xf9\xd6\xdf\xa3\xdf\xc3\xdd\x8b\x7d\x79\x3e\xf9\x76\x67\xd7\x82\xbc\x4c\x6f\x6e\x56\xae\x7c\x9b\x96\x9c\xb5\x23\x31\xd6\xe3\xf2\xc8\xb7\x5b\xe3\x1c\x2e\xbb\x59\x4f\x0d\x1f\x7a\x6b\x31\x68\xb6\xa8\x05\x86\x76\x0c\xe9\xed\xfd\x44\x3f\xad\x5b\xbd\x7c\xc9\x72\x7a\x5b\x1a\x5c\xb3\x62\x89\xad\x12\x62\xcb\xc0\xd9\x0f\x62\xf3\x20\x36\x0b\x2c\x2e\xa8\xad\x2c\xeb\x97\x97\xe5\xd2\xa0\x25\x4b\x90\xc6\x95\x95\xd7\xaf\xac\xb2\x56\x75\xfb\x9e\x7b\xef\x8e\x5d\xdf\x7d\x3d\xd6\xaf\x07\x25\x5e\xbf\x78\xfe\xec\xdb\x67\x93\x3c\x8e\x04\x17\xcc\xb9\xbd\x3d\x44\x9d\x34\xda\x3b\x9e\xc8\x14\x53\xc7\x7a\x06\xc9\x6f\x5c\x0a\xf1\x10\x76\x14\xee\x70\xda\xfa\x5f\x7a\xd2\xe1\x02\x66\x6c\x5f\xee\x44\x3e\xf9\xf2\x49\xf6\x44\xee\x78\xfc\xff\xef\x46\x3e\x53\x8f\x76\xab\x27\x25\x7c\x70\x51\xd7\xc2\x7f\xe1\xb9\xfd\x7f\xf0\x3e\xfc\x87\x6b\xe3\x4d\x8e\xa9\xb5\xb5\xf0\x18\x39\x76\x4d\x9d\x1a\xaa\x23\xe7\xc7\xe5\xe3\xfc\xd4\xa9\x62\x75\x6d\xad\x38\xb1\xb6\x96\xd5\x92\x73\x8d\x7c\x9c\xef\x78\xfb\xfc\x4d\x9f\xfe\x41\x1e\xe7\x3b\x9e\xb6\xbe\xde\x71\xdd\xf2\x4b\x47\x4a\x7a\xee\xf8\x70\x49\x13\xe9\xa7\xa6\xba\xe3\x33\xe9\xc6\xeb\x1a\xfa\x99\x38\x81\x7e\x26\x4a\xd7\xf2\x63\xe1\x6f\x52\x62\xf0\x48\x77\xe2\xd5\x89\xe2\xd5\x6a\xf1\x33\xf2\x5f\x23\x7e\x5e\x23\xfc\xbd\x1a\x55\x12\x99\xf4\x7f\x4d\x66\xa0\x67\xd0\x73\xe8\x08\x6a\x44\x2f\xa2\x57\xd1\x49\x74\x1a\x9d\x45\xe7\xd1\x05\x74\x09\x5d\x41\x57\xd1\x35\xf4\x35\xfa\x1e\xfd\x88\x7e\x41\xbf\xa1\x16\xd4\x06\x0c\x08\xa0\x06\x3d\x98\xc1\x0e\xb1\x90\x08\x1e\xf0\x42\x26\xe4\x82\x0f\x8a\xa1\x3b\x94\x42\x5f\x18\x00\xe5\x30\x8c\xa9\x3c\x82\xf3\x27\xee\x6d\x02\x55\x03\xf7\xd1\x47\x8c\x6f\xd2\xd3\x4d\xa0\xf6\x5b\xb9\x4b\x09\x43\xff\x74\xe8\x57\xee\xf3\xcf\x13\x87\x6d\x7e\xee\x37\xee\x2a\x5f\x34\x65\x77\x13\xe8\x1a\xb8\x0f\x3e\x10\x8a\xa7\x3e\x49\x57\x86\x5b\xb9\x0b\x49\x23\x56\x1d\x6e\xe6\xfe\xf2\x17\xcf\xc8\xd5\x47\x5a\xb8\x6b\xaa\x6e\xd3\x1f\x6b\x02\x53\x03\xf7\xee\xbb\xea\xee\x33\x1e\xa7\xde\xde\x56\xee\x7c\x6a\xe0\x8e\x06\x91\xfb\xea\x2b\xef\xa8\x75\x8d\x6d\xdc\xd7\xba\x5e\xb3\x1e\x6a\x02\x5b\x03\xf7\xf6\xdb\xfa\xd2\xd9\x0f\x37\x81\xbd\x9e\x3b\x9b\x31\x66\xc3\x71\xaa\xdd\xb8\xef\xbe\xcb\x1c\x7b\xd7\x8b\x84\xad\xeb\xb9\xef\x4d\x7d\xe6\x6d\x6f\x82\x98\x06\xee\xd4\x29\x73\xdf\xf9\x3b\x9a\x20\xb6\x9e\x3b\x9d\x33\xe1\x9e\x57\xa8\xb5\xc7\xfd\xfd\xef\xb9\x55\x9b\x5e\xa5\x9d\x0e\xee\x47\x5b\xff\x45\x0f\x34\x41\x42\x03\xf7\xfa\xeb\xf6\x01\x8b\xb7\xf4\x36\x43\x22\x51\xb6\x27\x21\x15\x72\xa0\x08\x7a\xc1\x20\xa2\x1d\xfa\x93\x3f\x2f\x41\x40\x31\xa9\x7c\x39\xb9\x1f\x00\x03\xfc\xda\x93\x3f\x9e\xfe\xfe\xec\xd7\xe7\xaf\x5d\xb8\x7a\x49\x73\xa5\x09\xfa\xf8\x0d\x31\x83\x96\x1d\xf8\x99\xfb\xe4\x93\xd8\xf2\xe5\xcf\xfc\xc2\x5d\xb9\xd2\xdb\x04\x15\x04\x79\x99\x04\x71\xdd\x61\x18\x49\xd7\x97\xfc\x25\x41\x06\xe4\x43\x37\x18\x4a\xee\xfb\x90\xbf\xe1\x47\x4f\x9e\x3e\x7b\xfe\x42\x13\xf4\x6d\xe4\x2f\x5d\x7a\xed\x8d\xb7\xde\x79\xaf\x09\xfc\x0d\xfc\x87\xcf\x1d\x69\x7c\x91\xc0\x58\xda\xc8\x3f\xf3\xcc\xb3\xcf\x1f\x6d\x7a\xa9\x09\x7a\x34\xf0\xfb\xb6\xec\x78\xf8\x71\x82\xc3\xee\x8d\xfc\xd3\x4f\xdf\xbf\x75\xe7\x23\xbb\x9a\xa0\x6b\x03\xbf\x67\xf5\xba\xbb\x36\x6d\x6e\x82\xe2\x46\x7e\xf9\xf2\x15\x6b\xd6\xdf\x7d\x6f\x13\x14\x34\xf0\x4b\xa6\xce\x98\x3d\x7f\x71\x13\xf8\x1a\xf9\x49\x93\x26\xd7\xde\x3e\x67\x41\x13\xe4\x35\xf0\xd5\xc3\x46\x8e\x1a\x5b\xd5\x04\xb9\x8d\x7c\x79\xf9\xe0\x8a\xca\xd1\xe3\x9a\x20\xab\x81\x2f\x2b\xee\x5e\xda\x97\x48\xed\xcc\x46\xde\xe7\x2b\xe8\xda\xc3\xdf\xaf\x09\xd2\x1a\xf8\xbc\x44\x8f\x37\x93\x88\x6b\x6f\x23\x1f\x1b\x1b\xe7\x4a\x4e\xcb\x6a\x82\xe4\x06\xde\x21\xa8\xf5\x66\x7b\x13\x78\x1a\x79\x86\x61\x15\x1a\x83\xa5\x09\x5c\x47\x79\xf4\x5b\x4b\xdb\x71\x89\x84\xca\xeb\xf9\x5f\x7e\xf9\xe7\xef\xad\xc7\x01\x01\x0b\x65\x7e\x3b\xff\xd3\x87\xfb\xf6\x2c\xa9\x2e\xcb\x73\xa0\x9f\x7e\x42\x8e\xbc\xb2\xea\x25\x7b\xf6\x7d\x48\x3a\x9b\x8a\xa3\x9f\x7e\xf1\xe5\x37\x3f\x34\x41\xbf\x46\xfe\xe3\x8f\xaf\x5e\xfb\xfa\xfb\x1f\x7b\x5b\x60\x00\xe2\xd1\x95\x28\x32\x1c\x86\x78\x42\x96\x6a\xd0\x90\x2e\xb2\x05\x1c\x10\x07\x83\xc9\x13\x05\x0a\xaf\x08\x0e\x9f\x3a\x09\xef\x70\xc0\xb6\xff\xe9\x09\xda\xaf\xda\x2f\xa8\x60\xfe\xdf\xc9\xbc\xd3\x49\x96\xd1\xc5\x37\x39\xb8\xff\x07\xcf\x53\xae\x7b\x16\x91\xef\xde\x9b\x1c\xc2\x1f\xe4\x63\xff\x6f\xbe\x0f\xff\xcd\xe7\xe6\x70\x5e\xf6\xff\xc3\xd9\x18\x7e\x77\xaa\x24\xe8\xc9\xff\x7b\xd2\x3f\xb9\x68\xb9\x97\x28\x0a\xf9\x5f\x7e\x3a\x75\x6a\xeb\x98\xff\xc1\x5b\xf0\x58\xf4\x3b\xaf\x4f\x9d\xca\x3c\xd5\xf9\x25\xf2\x3f\xf5\x86\xcc\xa6\xfe\x17\xde\x69\xf9\xe5\xbf\x02\x83\x9c\x74\xea\x1f\x7d\xd3\x73\x58\x73\x4d\xbc\x41\x7f\x55\xff\x81\x2e\xfb\xc3\xe7\x35\x1d\x1f\x59\xc7\x4d\x88\xd2\x74\x35\x51\xfa\xae\x93\xd6\x9b\x18\xad\xfb\xaa\x23\x1a\xb0\x26\x9c\x39\x39\x48\x66\xf4\x96\xbc\x4e\x5e\x42\x74\x87\x2c\x62\x6f\x5f\x24\xba\x70\x20\x1a\x82\x86\xa3\x5b\x51\x10\x8d\x47\x35\xe8\x36\x34\x0d\xcd\x44\x73\xd1\x42\xb4\x14\xad\x44\x6b\xd1\x9d\x68\x23\xba\x0f\xd5\xa1\x6d\xe8\x41\xf4\x28\x7a\x02\x3d\x85\xf6\xa3\x83\xe8\x05\x54\x8f\x8e\xa1\x97\xd1\x09\xf4\x26\x3a\x83\xce\xa1\xf7\xd1\x45\x74\x19\x7d\x86\xfe\x8c\xfe\x8a\xbe\x45\x7f\x43\xff\x40\xff\x42\xff\x46\x21\x00\xe0\x40\x09\x5a\x30\x82\x15\x9c\x10\x0f\x6e\x48\x81\x74\xc8\x86\x2e\x50\x08\x25\xd0\x13\x7a\xc3\x2d\x30\x10\x86\xc0\x70\xa6\x9f\xff\x76\xd4\xbf\x76\xc5\xfe\x6f\x62\xb8\x33\x67\x24\xb9\xc7\x31\xc3\x66\x6f\x7b\xee\x9f\xdc\xf9\xf3\x83\x6f\xbf\xf7\xd9\x7f\x73\xef\x4c\x5e\xfd\xd4\x97\x09\xdc\x9b\x6f\x4e\x5b\xb9\xf7\xdb\x58\xee\xd4\xc8\xf9\x9b\x8f\xfc\xc4\x5d\xb8\x50\x31\xe7\x81\xe7\xff\xc5\xbd\x57\xbd\xee\x89\x2f\x92\xb8\x13\x27\x6e\x5b\xb3\xfb\xaf\x89\xdc\xeb\xa3\x16\xef\x68\xfc\x81\xbb\x74\xa9\x72\xc1\xfd\x47\xff\xc1\x7d\x38\xee\xae\x47\x3f\x4d\xe5\x5e\x7e\xb9\x66\xfd\x63\x7f\xf6\x70\xaf\xb4\xbc\x42\xa4\x5c\x2c\xd1\x1b\x15\x44\x47\x74\x87\xee\x0d\xa3\x97\xec\x6c\xfa\x1b\xf7\xf1\xab\xa0\x20\x82\x2f\x1d\xca\x48\xff\x82\x23\x10\x96\x34\x8e\xbf\xfb\xa1\xcf\xbc\xdc\xf1\xb6\xde\xf1\x44\x4e\xba\x89\x86\x1a\x4c\x7e\x28\x85\x52\xd4\x4a\xa4\x64\x1c\x64\xc1\x70\x72\xdf\x83\x48\x5f\x3b\xa9\x5a\x3f\x94\x43\xee\x0a\xc9\x1f\x75\x24\x48\x85\x81\xc4\xa8\xe0\xa0\xa8\x51\x92\xf4\x5c\x59\x59\x6f\x15\xd0\xd1\xc7\x04\xc8\x83\x21\xe4\x07\x3f\xf9\x2b\x82\x1e\xfe\xb8\xe3\x1f\xbf\xf2\xe1\xeb\xef\x9d\x7a\x87\xd1\x40\xff\xf2\x19\x9b\x9e\xf9\x9d\x3b\x7b\x96\x53\x6a\x8d\x56\x0e\xa0\xb7\x12\x46\x10\x2c\x3a\x88\x5a\xbb\x85\x58\x28\x1c\x51\x6d\xf9\x8d\xf9\x45\xdd\x7a\xf5\xe1\xfa\xf7\x6f\x82\x91\x87\xdf\xfd\xe0\xa3\x63\x44\xdb\xf5\x6a\x1c\xc0\xbf\xfd\xf6\xcb\x27\xde\x3c\x73\x8c\x22\xb7\x9e\xc7\x2f\x11\x55\x77\x0c\x0a\xa0\x6b\x3d\xcf\x71\x44\xd7\x1d\xa3\x26\x46\x7d\x3f\xfe\x99\x43\x87\x1b\x8e\x11\x1d\x99\xd3\xd8\x97\x3f\x70\xe0\xd1\x27\x9e\xda\x7f\x8c\x36\x4b\x3d\xcf\x3f\xb2\x6b\xcf\xbe\x63\x90\x0c\x69\xf5\xbc\x52\xb9\x79\xdb\x8e\x63\x04\x47\xee\x7a\x3f\xbf\xe9\x4f\x5b\xb7\x1f\x83\x18\x70\x35\x96\xf2\xf7\xdc\xb3\x82\x68\xc2\x63\x04\x4d\xf6\x7a\x5e\xb5\x7c\xd5\x1d\x1b\x8e\x11\xfd\x61\xab\xe7\xb5\x5a\xa2\x08\x8f\x51\xb3\xa6\xbe\x07\x3f\x63\xd6\xbc\x45\xc7\x40\x05\xba\xc6\xee\xfc\xf4\xe9\xe3\xaa\x27\xd7\x1e\x23\x38\x52\xd4\xf3\xba\xb1\x55\x93\xa6\x1e\xa3\xda\xcb\xef\xe0\x8d\x46\xa2\x26\x5b\xda\xba\xf2\xe5\x43\x47\x04\x9a\xc5\x62\x7e\xd0\x20\xaa\xa6\x8e\x41\x3f\x28\xab\xe7\x4d\x57\x88\x9e\x3a\x46\x6d\xa1\x7a\xde\x6a\xfd\xe1\xa7\x7f\x1e\x83\xc1\x50\xe1\x4f\x2d\xe0\x7f\x8f\x49\x48\x4a\xcd\xc8\xe1\x6d\xf8\x19\x7e\x93\x6a\x86\xae\xdc\xf4\xbb\xcd\xf6\xbb\xa9\x5c\x37\x43\xb5\x89\x7f\x06\xab\x1d\xe7\x2f\x5c\x3a\x46\x0d\xa9\xc6\x32\xfe\xec\x59\xf8\xfe\xc7\x5f\x8e\x51\x73\xca\xaf\xf1\xf1\xbf\xfd\x26\xe9\xd7\x3c\xde\xd1\xae\xd5\x6e\xd0\x69\xb9\xff\x7b\x3a\xe7\xff\x9d\x5e\x0b\x77\xc2\x7d\x85\x9e\x9b\x1c\x3e\xeb\x1f\x1d\x1e\xab\xcf\x78\x93\x03\xae\x7b\xd1\x4e\x9e\x79\xa3\x0e\xe1\xba\xdf\x39\xf2\xac\x38\xfa\x9e\x1c\x6e\x72\x08\x85\x1e\x6b\x0a\x39\x9b\xc9\xd9\x13\x75\x5c\x9f\xfe\xff\xf8\xfb\x75\xe5\xc3\xf5\xf7\xd7\xc1\x19\x49\x2f\x84\xe1\xa2\xf0\xd8\x49\xbe\xf6\xeb\xf2\x37\x5f\x7f\x1f\x4e\x1f\x39\x73\x17\x9b\x33\xa7\x77\x7c\x66\xd0\x3f\xfa\x89\x9c\x23\x9f\xe6\x6d\x1d\x8f\x3e\x22\xff\xd3\xa7\x5f\x24\xff\xe1\x67\xa1\xef\xa6\x87\x7f\x6c\x3d\x30\x03\x4a\x67\x5c\x9c\x01\xcf\xcc\xe8\xc8\x26\x2a\xaf\xce\xf7\xed\x19\x61\x9b\x74\x73\x51\xfa\xc7\xdf\xd3\x37\xda\x0b\x98\x41\xf3\x16\x03\xe4\x97\x8b\x91\xd4\xed\x67\xfa\xce\x0c\x29\x51\x68\x0b\x24\xd5\xd0\x7f\x4f\x35\xb8\x27\x4a\xff\x9d\x34\xd0\x89\xf6\xce\x12\xf9\x9f\x40\xbe\xf9\xe9\x91\x9f\x5e\xbb\x5e\xa9\xbd\x16\xb9\x38\x19\xad\x6b\x6e\xd0\x59\x1d\x8f\xda\xdf\xe2\xcf\x45\xf4\x54\x44\x5b\x92\x52\xc3\x45\xd4\xb4\x67\x2d\x67\x7b\xa2\x3d\x33\x39\xa3\x8e\x0c\xa4\xc4\xf2\x98\xd7\x72\xb4\x90\x1d\xc3\x56\xca\x7b\xbe\x20\x8e\xa5\x5e\x65\x91\x08\xfb\x34\xea\xd7\x72\xe6\x6a\xab\x9b\xad\x6c\xa5\xfb\xa8\xd1\x48\xb2\xe7\xd9\x33\x52\xdf\x2f\xc1\xaf\x61\x91\x40\x84\xb1\x42\xc9\x22\x8e\x41\xb9\xe7\x3e\x3b\x17\xe5\x1e\x48\x93\x52\x07\x5a\x9e\x3d\xd3\x52\x3c\x98\xed\x42\x4f\xec\xca\x96\xf3\x6c\x17\x52\xe6\x4c\x58\x8d\xa7\x31\xcb\xa5\x32\x19\xcc\xb1\x80\x3b\xf6\xb9\x91\x46\xb5\xa6\x89\x2c\xb4\xc2\x6a\x68\x95\x7d\xc5\x3a\xde\x97\xca\xe5\x18\x1e\x33\x58\xa9\x10\x80\xc7\xd7\x97\x0b\xe1\x68\xc0\x72\x16\x83\xc5\x47\x68\x2e\x62\x05\x4c\x14\x1f\x0b\x8f\xf1\x21\xa4\x40\xb8\xf6\xa6\xf5\xa5\x9e\xd0\x0a\xf4\x3b\xf9\x39\xb4\x93\xce\xff\x92\x24\xfc\x60\xf6\x10\x81\xc0\xdc\x88\x01\xd1\x90\xc7\xe1\xb7\xa9\xfb\x9f\x5b\x49\xde\xc0\xa3\x71\x80\x3d\xd4\x32\x42\xf2\x57\xa8\x6b\xfb\x2b\x3f\x86\x7d\x96\xbc\x4f\xf3\x66\x19\x79\xff\x1c\x39\x6f\x25\x86\x3a\x09\x09\xcf\x86\x1e\x0b\x3d\x2c\xfb\x3d\x3d\x46\xde\x1f\xcc\x6e\x69\xcf\x9f\x02\xd3\x91\xbf\x12\xf3\x83\x43\x07\x42\xfb\xd8\x2d\x2d\x23\x08\x10\xd7\xe5\x8f\x70\xc7\xdb\x12\xde\x8c\xc0\x8f\xa1\xd9\xb7\x94\xe0\xdb\x10\xdd\x82\x00\x31\xff\xe4\xf6\x4a\xfb\x57\xf5\xf0\xc7\x0a\x2c\xc3\x03\x52\xf0\x0a\xac\xe4\x30\xa7\x52\x93\x6f\x81\xe0\x8f\x11\x14\x74\xd7\x81\xd2\xb0\x43\x5f\x47\xd4\xd9\xb0\x87\x5d\x3e\x0d\x9d\xae\x04\x9f\x92\xc5\x39\xb5\x62\x4f\x38\x59\x0b\xa7\x44\x41\xbc\x4a\x43\x9b\xe0\xf7\xf1\xc5\x50\x36\xfc\x59\x4c\x14\x4d\xf0\x77\xda\x4e\x4f\xa3\xdd\x6c\x0e\x9b\x2e\xad\xb3\x24\xed\x64\x40\x0e\x05\x52\xb8\xdc\x16\x4d\x1c\x4b\xda\xe9\xd3\x4e\xf4\x11\xf1\xa1\xb5\xd0\xf5\x00\x39\x50\x6c\xa1\xbe\xa2\x74\x45\x9e\xbc\x06\xe0\xe9\x25\xef\x2f\x5d\xf6\xc1\xd2\xa5\xef\x2f\x5f\xf6\xde\x92\xc0\xc4\xa7\x27\x4d\xdc\x3f\x79\xe2\x33\x13\x6b\xf6\x4f\xc4\x93\xe9\xf3\x0b\xe4\xa7\x25\x4b\xde\x5b\x36\x71\x7f\x4d\xf5\x81\x89\xe4\x97\x89\xfb\xa5\x2d\x01\xd0\x44\x14\x60\xab\xd8\x11\x84\x52\xf4\xd2\xba\x3b\x2f\xd1\xf8\xc5\xa8\x14\x0d\x40\xc3\xd0\x28\x54\x85\xa6\xa2\xd9\x68\x31\x5a\x8d\x3e\xf0\xdf\x5e\x51\x5b\x5b\x79\x7b\xd7\x25\x4b\x7a\xac\x48\x9b\x33\x27\x6b\x81\xab\xba\x3a\x79\xb2\xa2\xac\x4c\x33\x18\xf9\xfd\x6c\x3f\x43\x5e\x9e\xa5\xa0\xa0\xdf\xe0\xc9\x0b\x56\xdc\x2e\x38\x46\x8f\x8b\x73\x38\xc6\xad\x5d\x33\x68\xde\xbc\xa1\x8b\xfa\x2c\x5b\xd6\x7f\x55\xfe\xf4\xe9\x45\xb3\x62\xc6\x8c\x49\x98\x60\x1a\x31\xc2\x16\xc0\xdd\xba\xf1\xbd\x54\x19\x19\xba\x9c\x45\xab\x66\x4d\x08\xf4\xca\xc9\xe9\x15\x98\x30\x6b\xd5\x22\x61\x4a\xea\x94\x89\x49\xa9\x34\xfa\xb2\xa4\xb8\x22\xfa\xd1\xe7\x8b\x8e\xa9\x75\xd3\xaf\x28\x67\xd3\xff\xc2\xeb\xd4\xed\xda\x93\x54\x58\xe0\xcb\xf7\x86\xcf\xe6\xf0\xd9\x1e\x3e\x47\x7e\x17\xae\xbb\xbf\xfe\x7c\xfd\xef\xd7\xdf\xa7\x5c\x97\x7f\xa4\x3c\xe6\xe3\x82\xae\x5d\x0b\xb6\xd2\xaf\xdf\x8a\x0b\x8b\x0b\x93\xe9\x95\x58\x5c\x44\x3e\x07\x8b\x0b\x0b\x8b\xf1\x08\xfa\x1d\x8a\xa1\x0f\xf0\xba\xf6\x77\x43\x87\x0a\xba\x16\x15\x49\x2f\xc3\x5b\xf4\x37\x71\x1c\xfd\xfe\x8d\xbe\xbc\x95\x5e\x31\xdb\xc9\x57\x16\xb9\x13\x2f\x14\x17\x17\x5e\x23\x37\xb0\x85\x5c\x8c\xa1\x99\x2d\x26\x5f\x70\xac\xc8\x57\x12\xea\x47\xae\x1e\x2c\x28\xe8\x8a\xe3\xc2\x2f\x89\x0c\xb9\xf8\x92\x26\xbb\xd8\xb5\xa0\x6b\x06\xb9\xa0\xfc\x7f\x18\x6d\x64\x3d\x4c\x33\xd2\x22\x9b\x5f\xc9\xaa\xf4\x3a\x41\x2f\x3b\x67\xb6\x0b\x20\x89\x2a\x91\x27\x09\x15\x12\x1a\xc5\xd3\x67\x5d\x9e\x27\x8a\x8d\x0d\xa2\x38\xfb\x12\xd3\xbc\xe0\x93\xe9\x8d\xa2\x08\x4c\xc3\xed\x17\x17\xcb\xb2\x29\x9d\xc8\xc4\x67\x59\x1a\xbb\xdc\x4c\x69\x5e\x83\x89\x34\x23\xe9\x0d\xa4\xcf\x7f\xbd\x6c\xa2\x41\x81\xe0\x3a\x3a\x4f\x67\xd7\xb5\xb2\x8b\xce\x2e\x5e\x74\x6e\xd1\xa2\x77\xc8\xf7\x42\x76\x5d\xcb\x4a\xdc\x7b\xd1\x3b\x8b\xc8\x35\x79\xb8\x98\x46\x86\x8f\x2e\xc3\x43\xf7\xa2\xd3\xc4\xc5\x61\xd6\x62\x21\x25\xa5\x24\x1b\x1c\x84\xc7\x68\x0d\x3e\xfb\xec\x5d\xc3\x67\xef\x76\x8a\xdb\x1c\x2e\xf3\x3a\x5e\xf3\xde\x04\x86\xe1\x13\x0f\xd4\xd4\x10\x46\x92\xbe\x87\xdc\x08\x50\xfb\x6f\xe4\x3b\x1a\x38\x09\x07\xf3\xe1\x4e\x3c\x89\x59\x48\x70\xea\xa4\x38\xd0\x21\x8b\x80\x84\xd8\x18\x3b\x63\x54\x5d\xcf\xf7\xd2\xd2\x80\x70\xe4\x68\x7b\xa7\xe5\xde\x78\xd2\x8e\x9a\x7e\x73\xfa\x6d\xb9\x6d\xea\x80\x41\x83\xa7\xf4\xef\x3f\x65\xe2\xa0\x21\x55\x78\xe5\x8c\xfb\x7a\xcf\xbb\x65\x6a\xdd\xa0\x01\x53\xfb\x4f\x99\xd2\x7f\xc0\x6d\xd3\x88\xfd\xfe\x02\x91\x83\x4b\x89\x1c\x54\x23\x07\x4a\x46\x79\xa8\x1b\x9a\xe3\x2f\xd5\x74\x73\x26\x16\x65\xa6\x24\xa6\x20\x33\x8f\xf8\x1e\xdd\xd3\xe2\x92\x72\x92\x0a\xbb\xd4\x76\x81\x60\x17\x18\xd0\x05\x9c\x5d\xa0\x8b\xaf\xab\x3e\xa9\x2a\x69\x76\x12\xa3\xe8\xea\x57\xea\xca\x92\xba\x26\x75\x65\xf4\x7a\x25\x28\x6d\x54\x81\x7d\x3a\xfe\x9c\xbc\xff\xe6\x84\xf1\x86\x73\x3e\x79\x44\xdd\xe8\x33\x9c\xcb\xbf\x89\x54\x04\x0b\x12\x92\x90\xb7\x00\xb9\x5d\x48\x28\x40\x5e\xea\x83\x6b\x41\xf6\x7c\x14\xbd\x9a\xbd\x53\xd4\x02\xea\x21\x6f\x97\xd6\x45\x2c\x15\x77\xb6\x86\xc4\x87\x00\x26\x92\x06\xc4\x30\x71\x8c\xf8\xee\xc7\x9f\xec\x78\x10\xf2\x3f\xbe\x0c\x79\xa1\xb1\x39\x2e\x57\x76\xb6\xcb\x95\x03\x17\xb2\x5c\xae\xdc\x5c\x97\x2b\x2b\xf4\xdd\xe0\x2d\x75\x83\x7b\x4d\x3c\x76\x6c\x22\x2e\x13\x89\x4e\x83\x29\xa1\x66\x98\x2e\x6e\xfb\xf7\x65\xd2\x97\x79\xe8\xc1\xcb\x1f\x8b\xef\x02\xe9\xa6\x04\x5c\x39\x91\xc4\xd2\x59\x7c\x75\xe3\x46\xcf\x71\x1a\x8b\x99\x85\xf7\x09\xce\x1e\x94\x70\x66\x27\x34\x94\x8d\x26\xfb\x4b\x92\x35\xa6\xb4\x04\x87\xc9\x41\xd0\x85\x72\x72\xdd\x56\x7d\xac\x3e\x3d\xbb\x36\x1b\x82\xd9\x50\x9e\x0d\x3d\xb3\x21\x3b\x33\x55\xaf\x4f\xd4\x57\xe9\x67\xeb\x59\xc5\xb0\xd4\xaa\x54\xac\x4f\xd5\xa7\xd2\x4d\x78\xde\x91\x22\xa2\x11\x3c\xbd\xdb\x81\xa7\x77\xf3\xa3\xd6\xf4\x84\x9d\x5b\xa2\xb0\xc4\x45\xb5\x75\x4a\x74\xf8\x06\x8a\x18\xaf\x84\x98\x07\xaf\x43\x4c\x08\xdd\x04\x17\x87\x28\x1a\x7a\x0d\xae\xdb\x32\xb8\x33\x2e\x96\x45\x55\x9c\x9e\xc5\x4f\x8f\x1f\xf7\x6c\xdc\x48\xfd\xac\xfa\xb7\xcd\xe7\x75\x6c\x77\xd2\x23\x2d\x46\x95\xfe\x2e\x85\x06\xb5\xa0\xc2\x19\x19\x36\x67\x4e\x6a\x52\xbc\xc7\xe3\x54\x31\x25\x5d\xbb\xac\x71\xbe\xe7\xfc\xc2\xc9\xac\x76\x42\x9e\x13\x72\x9d\xe0\xcc\xd4\x67\x94\x66\x0c\xcb\x60\x14\x19\x28\x77\xc2\x78\x42\x1d\xe4\x73\xae\x3d\x5a\x6e\xbb\xe4\x95\x9d\x78\xac\x09\x40\xb7\xb3\xb3\xd1\x91\x1d\x9e\xee\x6a\xa7\xc3\x02\x31\x8b\x53\xbd\x82\xb7\x38\x95\x06\xf7\x2b\xa2\x1b\xde\x15\x15\xdb\xc3\xd5\x2e\xa6\xeb\x60\x98\x8d\x7d\xfa\x4c\xea\x71\x3c\xbb\x29\xc0\x5f\xba\x64\x2c\x6f\xea\xd2\x90\x3c\xa8\x57\x61\x9f\xa5\x93\x5f\xca\x6c\x18\x6a\xb8\x74\x49\x53\x71\x34\xed\xe5\x59\x73\x13\x37\x9d\x38\xb9\x71\x53\xf5\xa4\x37\xd8\xee\x97\x79\x6f\x76\x43\x76\xd3\xdc\x05\xbd\x56\x56\x93\x97\x62\x32\x0c\x8a\xcb\x97\x8d\x03\x8f\x66\x37\x4d\x5e\xd9\x6b\x4d\x15\xc9\x61\x88\xb6\xe7\xa9\xbb\xef\x7e\xa3\xa6\xe6\x9e\xbb\x4f\xd1\xba\x7f\x82\x2a\xd8\x54\x76\x2d\xe1\x14\x2f\x0a\xf8\xf3\x93\x0d\x6a\x93\x4e\x67\x45\xf1\x76\x96\x45\x6a\x26\x3d\xcd\x64\xd5\x23\x87\xc1\x51\xe1\x60\x1c\xc8\x05\x3f\xb9\xc0\xa5\x43\x68\x0d\xc2\x0a\xe4\xf4\xa7\xa4\x95\x39\x05\xc2\x18\x99\x9f\x4e\x18\x9f\x7f\x6e\xee\xbc\xdc\xf1\x3e\x89\x19\xc2\xfa\xc8\x17\x8e\x41\x04\xe1\x65\xd7\x76\x39\x14\xbc\x3c\x8b\x4c\x5d\x4d\x22\x6b\xf9\x68\x65\x73\x00\x7f\x3a\x78\x46\xbf\x43\xf3\x16\x8d\x0c\xdc\x3f\x9d\xee\xc9\x31\x88\x46\x45\xf6\x74\x1d\x57\xb2\x7c\xc4\xa8\xee\x3d\x4b\xc6\xe3\x3e\xea\xc1\xcb\xca\x57\x3d\x15\x18\xb9\x6c\xe6\x6e\xed\xde\xfe\x62\x33\xf0\xfd\x71\x5d\x61\x55\x49\x60\x69\xaf\x9e\x95\xdd\xaa\x0a\x68\x7d\x86\xa3\x66\xf6\x39\x52\x9f\x2c\xd4\x15\xf5\xf2\xbb\xf3\xb2\xd8\x44\xc6\x5b\x64\x71\x7b\xdd\x25\xdd\xb2\x12\x33\x7c\x28\x79\x4d\x32\x4e\xce\xbe\x5f\x0d\x6a\x7d\x06\xc8\x6d\xf7\xce\xf8\x30\x6f\xb7\xef\xb3\x2d\x2f\x53\x4a\xf5\x12\xe6\x2c\x2e\xf2\x49\xab\x57\x48\x05\xac\x82\x14\x52\xca\xa2\x07\x2a\x25\x05\xd9\xc5\x3e\xec\x04\x2f\x44\xe8\x95\xb6\x5b\xdb\x96\x4c\x05\xcf\x2b\xdc\xfd\xba\x8f\x4e\x4f\xd6\x1a\x78\x83\x86\x65\x75\xe6\x94\x64\xed\xdf\x2a\x9f\x5b\xb0\xe0\xe0\xfe\x65\x03\x46\x3e\x14\x5c\xb1\x6a\x54\x70\xd9\x0a\x16\x65\x66\x72\x5a\x62\x24\xb3\x46\xad\x46\x17\xdb\x63\xe2\x50\x9f\x4b\xc9\xf3\xbd\xc7\xe4\xff\x7d\xf8\xcc\x95\x87\x9e\x5c\xb6\xe4\x40\xa6\x6b\x59\xb0\x6a\xd1\xca\xd1\xa3\x56\x10\x4d\xd4\x9d\x2e\x45\x63\xcf\x23\x37\xca\xf3\xc7\x98\xe2\xd4\x76\x3d\xcf\xdb\xe3\x98\x24\x8f\xd2\xe9\x57\xa8\xcb\x9c\xc6\x61\xc4\x88\xc1\xd2\x6a\x82\xdc\xcc\xce\x3b\x56\x01\x5d\xee\x0e\x76\x69\x5d\x40\x02\x4e\x04\x77\x31\x11\xf2\x3d\x21\x12\xb0\x9f\x28\x33\x97\xb3\x7a\xc7\x7d\xfd\xf1\x1d\xa3\x1e\x9d\xc4\x0c\x7b\x72\xbd\xa2\xf5\x1b\x7e\xc5\xb3\xa3\xc6\x1c\x08\xde\x11\x9c\xb4\x69\x3d\x7b\xbe\x7a\xff\xa6\x55\xeb\x07\x54\xaf\x79\xf5\xf1\xbd\x13\x94\x29\x29\x35\xcf\xd6\xe9\x5e\x5d\x33\x2e\x78\xf7\x88\xc5\xc7\xa9\xee\xec\x81\x88\xc1\xcc\x9e\x46\x05\xa8\xab\x3f\x1e\xeb\x0b\xd2\x88\xf8\xd0\xb3\x85\x45\xc9\x99\xb9\x0a\x97\x85\x55\x27\xaa\xc1\xa4\x36\xd1\x61\xa1\xc8\x5e\x89\xe3\x29\xa6\x3b\xa0\xa4\xeb\xd9\x8b\x7b\x31\x85\x5e\x59\x11\x51\xa8\xf2\xed\x52\x2b\xc8\x2b\x1a\x84\xa2\xe2\x08\x1d\x49\x8a\x2a\x81\xb1\xb3\xfd\x5b\x1b\x14\x77\x2d\xae\x2a\xc4\x25\x87\x83\x43\xd6\xf6\x7f\x60\x7c\xaf\xc9\xa9\x46\xf5\xee\xb9\x0b\x76\xdd\x52\x69\xb0\x79\xa7\xf5\x1b\xf8\xc8\x82\xae\x8b\xaa\x7a\x72\x5d\x66\xae\x9e\xe7\x89\x2d\x5a\xb2\x6d\x70\xee\x92\x45\x83\x57\x0d\x99\xff\x18\xf8\x7a\xa7\xa5\xa4\x2e\xdd\xbe\x6b\x46\x60\x62\x1a\xa3\x18\x3a\x78\xc1\x82\xa7\xba\x8c\x98\xb6\xea\xc1\x25\x85\x56\x5a\x9f\x29\x6d\xdf\x92\xbe\xcf\x52\xc2\x1b\x0e\xbf\x0a\x69\xcd\x5a\x81\x71\xc6\xa8\xda\x4d\x70\x69\xb1\x57\x0e\xe4\x42\x64\xa7\x03\xbb\xbc\x87\x00\x21\x72\x1d\xe0\x89\xb6\xb1\xcf\x8f\x29\x2f\xda\x74\xdb\xa8\xcd\xa9\x49\x7f\x1a\x5d\xb3\x79\xf4\xec\x7b\xd7\xda\x03\x0d\x3f\x2c\x9f\xbc\xb6\xcf\x8c\x8d\xf3\x96\x2c\x5e\x78\xf7\xc4\xc0\x2b\x1b\x8f\x5c\x94\xfa\x1d\x7d\xda\xbe\x66\x3e\x20\xb8\xd3\xa0\x58\xbf\x5a\x45\xb7\xf6\xd4\xea\xca\x55\xa0\x42\xce\xdc\xf1\x91\x89\x55\xba\xc8\x19\xd9\x79\x24\xa4\xe2\x54\x6f\x11\xc2\x42\x19\x28\x97\xf5\x13\xdf\x1d\x99\x72\x6c\xeb\xad\x0b\x80\x61\x4f\xaf\x14\x77\x6c\xec\x2f\x4e\xdb\x3a\x00\xb8\x57\xa7\x6c\x84\xa0\xdc\xa7\x79\x03\xc5\x33\xdd\x09\x4f\x38\x89\x6d\x60\x55\x71\x58\xa7\x73\x5a\x9c\x1c\x13\x1b\xa3\x55\x28\x72\x69\x1c\x41\x23\x61\xe2\x77\xc6\x97\xe4\x96\x74\xa6\x17\x9f\x95\xa2\x9a\x6e\xbf\x57\x90\xea\x8d\x5e\xf1\x01\xdf\x0e\x7e\x70\xe6\x84\xdc\x92\x79\xfe\x2d\x33\x4a\xba\xad\x1c\x9a\x95\xc3\xae\x9d\x7c\x62\xcb\x81\xed\x4b\xd7\x2c\x59\xf2\x98\x5a\xe4\x97\xef\x28\xca\x19\xb2\xc0\x2c\xad\x61\xbe\xc8\xfe\xc8\xde\x85\xe2\x90\x0b\x55\xf9\x0b\x13\x34\x1a\x14\xaf\xd7\xc7\x58\x63\x04\xc4\x26\xb9\x75\xf1\x81\x78\xe8\x1b\x0f\xf1\xda\x84\xa2\x04\x48\x49\xa0\xe6\x0f\x93\x00\x8a\x84\x38\x57\xec\xe8\x58\x88\x4d\x8c\x73\x98\x54\xac\xb4\xf8\x86\x74\x3f\x24\x3d\x32\x21\x3c\x95\x7d\x43\x00\x08\xaa\x4e\xc2\x8b\x87\x29\x8c\x46\xae\x1d\x62\x3b\xb9\x4b\x81\x94\x42\x8e\xfd\xb1\x68\xf9\xc0\x92\x92\x65\x43\xf3\x32\x42\x9f\x6c\x9c\x5f\xd2\x6d\xc5\xb0\xec\x6c\x7c\x3c\x74\x3f\x4e\x0d\x7d\x02\xfd\x86\xce\xad\x2c\xca\x1d\x3e\xdb\x04\xaf\x6d\x13\x17\x2d\x7c\xb8\x30\x7b\xf0\x12\xc6\x8c\x7f\x3a\x2c\x4e\xdd\xb6\x70\x27\x61\xaa\xbc\xb6\x18\xe6\x03\xee\x1d\x69\x3e\x73\xb6\xbf\xc8\x91\x68\xe2\x79\xbd\x5a\x88\xb1\x61\x1c\x67\x66\x04\x06\x69\x95\x48\xe9\x76\x69\x35\xc4\xb6\x31\xd8\x18\xa5\x42\x91\xc8\xc6\x68\x4c\xf1\xb6\xc4\x18\x93\xcd\x66\x8a\x49\x64\xad\x82\x95\x92\xbe\x6c\xe6\x47\x00\x27\x16\x84\xe1\x8d\x7c\xc3\x39\xc3\xb9\x4e\x86\x84\xaf\x23\xc6\x1b\x15\x46\x02\xf5\x51\x27\x87\x50\x58\x2c\x1d\x3e\x63\x0a\x39\x8a\xad\x82\xb1\x98\x23\x3f\x30\x1f\x7c\x50\x2d\xbe\x5e\xfd\x01\xf9\x54\x43\x2f\x7a\x16\xdf\x15\x5f\x87\x5d\x13\xc9\x97\x7d\x07\x51\x9a\xa5\xc1\xc3\x41\xf8\x66\xfc\xe1\xf1\x50\x22\xfe\x7d\x0b\xcc\x14\x8f\x4f\x3c\x3c\x51\x8c\x9b\xb8\x11\xbe\xdc\x22\x3a\x24\x3a\x21\xa4\xcd\xee\xe1\xd6\x22\x2b\xaa\xf1\x77\xb1\x1a\x8d\x7a\x1a\xa7\x8c\xa8\x76\x8d\x06\xcc\x7a\xad\x9e\xd8\x63\x56\x2b\x8b\x68\xe0\x04\x0d\x0d\x27\xae\x36\x1a\x15\x26\x93\x1e\x33\x7a\x4d\x55\x50\x6f\x6a\x8f\x52\x21\x09\xfe\x12\x39\x32\x99\x31\x3a\xa4\x51\x24\x84\xbc\x31\x1c\x98\x2e\x6a\x0f\x89\x70\x4c\x3a\xd5\x46\xf0\xc2\x0c\x71\x1b\x3d\xf0\x77\x2d\x3f\x6e\xdc\xb8\x91\x69\x86\xbb\xc4\xa5\x27\x5e\x3c\x71\xf9\x4b\x78\xf9\xc4\x8b\x14\x4e\x0b\x29\x3c\x85\xb4\x83\x19\xdd\xea\xcf\x30\x53\x28\x35\x7a\x30\x6a\xb5\x14\x52\x42\xaf\x66\x64\x1e\x16\x24\x70\x6a\xb1\x5a\x6f\xd0\x0f\x0b\x2a\x0c\x06\x2d\x06\xad\x15\x95\x96\xca\x4b\xce\x91\x1c\x3a\xad\xd3\x2e\x8a\x1d\x41\x97\x22\xe1\x39\x23\xd1\xcc\x65\xc8\x2c\xcb\xc1\xb9\x92\x7c\xc4\xaf\x97\x2f\x5f\x4e\x60\xfa\x40\xcc\x21\x30\x89\x7d\xc3\x30\xb5\xfd\x1c\xc6\x5d\x0c\xb1\x9c\x1c\x76\xac\xd2\xb3\x26\x00\x16\xb3\x71\xb1\x36\x9b\x41\xa5\x62\x0d\x1c\xaf\xe7\xa5\x20\x94\x7a\x3d\x6b\x30\x21\x3a\x39\xac\x0d\x9a\x4d\x26\xd6\xc0\xb0\x50\x15\x64\xa3\xf0\xd7\xbe\x5a\x2f\x0c\x68\xa7\x08\xec\x3e\xd9\x59\x47\x76\xc6\x92\xb7\x79\xef\x4e\x57\x69\xcb\xfb\xbc\x83\x07\x23\xbc\xa7\xb5\x50\x91\xe1\xe5\x36\x2a\xb2\x46\x0d\x32\x81\x57\x91\x96\xa3\xbd\x4b\x98\x3b\x15\x8f\x11\xef\xf9\x12\x5f\xcc\x1f\xb8\xaa\xb6\x14\xe3\xd0\xba\xfc\x81\x8f\xca\x31\xac\x68\xac\x3a\x03\x81\x5d\x4f\xb8\x74\x9c\x3f\xcf\x69\xd5\xe8\x35\x40\xd4\x96\xd6\xce\x33\x09\xf1\x0e\xbd\xde\xca\xc8\x91\xe9\x08\x46\x9d\x55\x41\xa4\x26\x37\x6a\x35\xd6\x9a\xb0\xa5\x23\x30\x5d\x7b\x78\x12\x14\x89\x4a\x17\xc5\x9f\x61\x7b\xcf\xe8\x93\xa3\x42\x47\xc2\x10\x52\x3b\x2f\xdc\xfe\xf9\x45\x1b\xf1\xd2\x10\x18\x57\x7e\xfd\x18\x0d\x3c\xb8\x91\xf9\x7a\xdd\x3a\xf1\x3c\x08\xe2\xbf\xa1\x64\xf1\x5d\x6c\x12\x54\x7d\x7b\x71\xe3\x47\x0b\x44\x03\x33\x6a\xea\xcc\x45\xab\xcf\x6e\x5c\x2e\xf7\x2d\x36\x8a\xa3\xb8\x47\x39\x6a\xbf\xb8\xd0\x08\x7f\x96\x12\xec\x8c\x45\x1f\xcf\x30\xc4\x6a\x71\x3a\x2c\x16\x7d\x92\x3b\x1e\x57\x05\xe3\xe3\x91\x41\xa3\xa8\x0e\x6a\x78\x72\x20\x93\x21\xae\x2a\x68\x08\xc3\x1d\x1d\x76\xb2\x23\x7e\x8e\x31\xbc\x67\x25\x0d\x65\x6d\x09\x2f\x5e\x95\xa2\x87\x5f\x1f\xd5\x5a\x0e\x57\x5d\xd8\x33\xa1\x5f\xf2\x32\xcf\xfe\xba\x9b\x44\xad\xc6\xf6\xd0\x99\x61\x43\xb4\x5f\x29\x34\xcf\xbf\xc9\xd5\x77\x8a\x4c\x8d\x58\xd4\x43\x1c\xc5\xae\x21\xb4\x9c\x89\xba\x10\x8b\xa5\x27\x3a\xe4\xcf\x41\x85\x45\x46\x0b\x97\x69\x32\x9b\x1d\xa9\x3d\xb3\xb2\xe2\x1d\x19\x99\x99\x8c\x5a\xa3\xc9\x67\x1c\x4c\x69\x2f\xb5\xda\x92\x93\x63\x89\x8f\xb7\xa4\x7a\xbd\x1e\x8b\x40\x83\xd4\x1f\x0d\xf6\x10\x84\x22\xea\x93\x90\x18\x14\x04\x8f\xc5\x04\x99\xb1\x7a\x83\x51\x31\x22\x68\x34\x58\xba\x57\x04\x2d\x7a\x54\x58\x11\x44\x36\x4f\x2c\x79\xe7\x70\xd0\x63\x8b\x0a\x58\x15\x71\x81\x96\x36\x0b\x8b\x0a\x3a\x77\x43\xf0\x7f\x5f\x54\xa0\x1d\x5f\xfb\x1a\x57\x4e\xd6\xd2\x3e\x73\x38\xee\x1e\xdd\x16\x81\xa1\x4b\x9f\xc3\x48\x63\x68\xc8\x6f\x62\xf1\x32\x1e\xf0\x30\xa4\x4b\xc9\x59\x6c\x76\xb3\x8e\x74\x46\xbc\x82\x0f\xaa\x36\x3e\xf4\xe1\x25\x7d\x8f\xa1\x03\x95\xe2\x95\xd8\xef\xcf\xda\x84\x51\x4f\x8e\x5f\xb0\x32\x3d\xcf\x95\xe0\x4c\x4b\xcb\x4e\x98\x7e\x9b\x8a\xaf\xdc\x5a\xf5\x24\x9c\x0b\xf6\xef\x1f\x14\xef\x4c\x72\xfa\xbb\xfb\x61\xb9\x21\xb5\xc8\xa4\xde\xbb\xe5\xa9\xe7\x39\xd0\x0c\x18\xa1\x7b\x7c\x37\xc0\x6a\x71\x4a\x6a\xc3\xbd\xe2\xa2\xb1\xb7\xf0\x3b\x79\x15\xcf\xd6\xde\xb6\x33\x4b\x1c\xc3\x3c\x26\x9e\x89\xfd\xd3\xa8\x25\xd9\xbd\x75\x10\xa7\x1b\x0e\xfe\x5b\x72\x0e\x48\x3e\xb4\x27\xc5\x51\xcc\x25\x82\x73\x27\xa1\xf7\xa9\xfe\x02\x83\xd1\x68\xb7\x9b\x18\x96\x55\x2a\xd5\x82\x2e\xc6\x64\x12\x84\x84\xf8\x98\x18\x6c\xb7\x63\x8d\x46\x65\xc0\x56\x03\xb0\xb1\x71\x4a\x95\x72\x58\x50\xa7\xd2\x23\xeb\xb0\xf6\xf8\x4b\x11\x5f\xce\xe8\x9d\xd6\xc2\xa1\x40\x7c\x51\x18\x93\xc3\x31\x79\x19\x8f\x59\x0a\x3f\x2f\x45\x9c\x37\xfb\x40\x5e\xfd\xcc\x33\xc5\x1e\xd8\x73\x4b\xc1\x9b\x4f\xfe\xee\xdc\xb8\x63\xf4\xf3\xaf\x1f\x7f\x32\xf4\x67\xb6\x47\x77\x77\xcf\xda\xb9\x33\x66\x98\xac\x62\x25\x8e\xe9\x7a\x2b\x5e\xf5\x0a\x31\x87\x1f\x68\xa9\xed\xe7\xd7\x1d\x4a\xc2\x7b\xbf\xa1\x72\x70\xa3\x58\xcb\xed\x96\xf8\x76\xa0\x3f\x59\xc1\xb2\x1c\x5d\xd0\xa0\xd1\xeb\x75\x9c\xce\x60\xd4\x83\x82\xa9\x0e\x2a\x14\x40\x8c\x09\xce\x04\x9a\xea\x20\x84\x45\x8c\x14\x43\x52\x8e\x70\x7b\xfd\x26\x4e\x74\x38\x2f\x6a\x5f\x53\x9f\xd1\xc3\xee\x7b\x20\xf4\x90\x78\x19\xbc\x78\x0a\x78\x6f\x6b\xc6\xe3\x42\x44\xca\x85\xce\xe3\x2e\x2d\xf3\x43\x0b\x08\x0c\x9b\xc5\x5a\x56\xc6\xe5\x20\x7f\x0a\xd8\x6c\x0e\x9d\x46\xa1\x50\x3a\x1d\x0e\x65\x6c\x8c\x5e\xa7\x33\x39\x41\x05\x4a\xab\x89\xad\x08\x9a\x0c\x60\x1b\xd6\x1e\xcd\x48\x02\xc4\x70\x4a\xda\x21\xad\x53\xbc\xec\x30\x10\x91\x1d\x37\x08\xfb\x09\x91\xbd\x99\xe8\x92\x84\xaf\x1e\x3a\x31\x85\x08\x61\x70\x2a\xd8\x92\x67\x17\x3f\xdb\x34\xff\x1f\x78\x02\xc4\x3f\xb7\x31\xf4\x32\xf7\x8e\x38\x63\x66\xed\x8a\x39\x1f\xbe\x23\x1a\x42\x07\x22\xf8\xa9\x97\xf0\x33\xc2\x9f\xa6\xa6\xbb\x0f\xaa\x74\x04\x41\x3a\x8a\x2a\x02\x1b\x67\x34\x10\xf4\x60\xcc\xeb\x41\x79\x23\x8e\x24\xd8\x3a\x4b\xde\xc8\x9f\x14\x6f\xc6\xed\x01\x41\x82\x0f\xdc\x4a\xea\x3e\xcf\xbe\x38\x49\xe4\x0f\x49\x98\x5a\x0e\xa3\x43\x7b\xe1\xf4\x9b\xcd\xf8\xae\x3b\x43\x22\x41\xd7\x5a\xbc\x3a\xf4\x6c\xe8\x74\x28\x1c\x27\x93\xe2\x6c\x16\xc1\x99\x1e\x8d\xf1\x3b\x29\x40\x61\xd8\x3a\xe0\x22\x8d\x87\x29\x3f\x1b\x69\x03\x2a\x79\x50\xea\x39\x2b\x68\x3a\xb0\x17\x66\xd7\x9b\xb4\x61\xfb\x5e\x3c\xd7\xc3\xc7\xac\xec\x2e\x5e\x5d\x4a\x31\x07\x77\x40\x8e\xb8\x1e\x3c\xb3\xff\x01\xdf\x55\x8a\xd3\xb9\x77\x5a\x0f\xc1\x6b\xe2\x18\x31\x83\x62\x8d\xc2\xd7\x93\xc0\xb7\x4f\x8a\xeb\x51\xe8\x8f\x55\x31\x84\xac\x10\xc3\x2b\x11\xab\xd5\x00\x23\xf0\x55\x41\x81\x61\x54\x55\x41\xc6\xd4\xde\x92\x12\x14\x51\x86\xa3\xb4\x42\x8b\x46\xf2\x03\x37\xbb\xaf\xb9\x75\x33\x6e\x0e\x8d\x60\x7e\x0d\xf1\x8c\x47\xac\x85\x9d\xef\x33\x67\xbe\x3e\xd7\xea\x93\xcb\xea\x27\xd6\x32\xa7\xd9\x6e\x74\x15\x85\x3f\x51\xad\xa2\x03\xce\xc0\x0a\x2a\x52\x96\x1a\x04\xd2\xd3\xa9\x08\x72\x7a\xba\x61\x76\x38\x0e\x56\xd8\xa5\x9b\x7c\x5f\x57\x66\x3a\x44\x4a\x34\x7a\xf0\x47\xa1\x59\x38\x4e\xd4\x32\xe9\xa1\xaf\xf1\xa0\x7f\x9c\xc6\xfb\xce\x9e\x09\x8d\xa3\xa3\xea\x58\xda\x23\x69\x95\x14\xeb\x2f\x0e\xf9\xfd\xae\x18\x62\x2d\x20\xbd\x9e\x30\xbc\x46\xa3\x05\x40\x5a\x06\x99\x54\xf6\xaa\xa0\x8a\x65\x0c\xa4\x8a\x51\xa1\xfd\x4a\x6f\x20\x07\x1a\xac\x90\x97\xe2\xf9\x19\x90\x3b\xdf\x5e\x4c\x2c\x32\xa2\x83\xa5\xf0\x6a\x52\x48\xbf\xda\xc7\x2f\xbe\x2b\xbe\xb7\x1b\x96\xc1\x90\x2b\x7b\xf6\xf8\x43\x4b\x67\x36\xf6\xe8\xb9\x6f\xd4\x1b\x9f\xbc\x3b\xfc\xb6\xe7\xa1\xff\x15\xb8\x15\xd6\x4f\x1a\xda\xbc\xfa\x2d\x5f\x2e\x93\x99\x93\x29\x36\x7f\xff\x17\xf1\x6f\x14\x27\x0a\xa2\x8f\x93\xd9\xa1\xc4\x0e\xa3\x2b\xdf\x15\x5a\x95\x52\xab\xb4\xda\xac\x76\x84\x14\x4a\xbd\x99\xa9\x08\x9a\x0d\x0a\x6d\x45\x50\x11\xc5\x4a\x26\x39\x52\x72\xb8\xf5\xa5\x4e\xb7\x14\x1d\x9d\x0e\xc4\x9b\x6d\xf6\x52\x90\xe2\x54\xdb\xd9\xd7\x9c\xe9\xf1\x69\x5d\x2c\xe2\xd7\xe2\xf3\xe2\x4a\x48\x7f\x59\xdf\x35\x29\x6d\x69\x46\xdd\xdc\x65\x1b\x98\xee\x26\x63\x7a\xd7\x10\xc3\x76\x0b\x3d\x99\xff\xd6\xa2\xb5\xb0\x78\xed\x8a\x4a\xb9\x8d\x88\x85\xa0\xa8\x25\x38\x4b\x44\xc3\xfc\xe9\x2a\x65\xac\xc3\xae\x35\x1a\xac\xc4\x76\xb1\x6a\x63\x59\xec\xc2\xee\x58\xab\x96\x61\xb4\x56\xc6\x48\xc4\xa8\x8a\xe8\x0f\xae\xba\x23\xd8\x5e\x69\x78\xe6\x57\x9a\xa9\x35\xd9\xa3\x84\xa3\x14\xe4\xdf\x2e\x85\xbf\x26\x70\x32\xa9\x5e\xa2\x26\x08\xb8\x26\x7b\xac\x04\x33\x0d\xad\x2d\xd4\xde\xb1\x6a\x72\x97\x9c\x5c\x9f\x41\xfc\x41\xdc\xfd\x6a\xac\xcb\x9a\xfe\x0a\x31\x0f\xb6\x41\xe6\x97\xb6\x7e\xc7\x61\xd0\xe1\xf8\x8c\xd8\xa7\x92\x76\x72\xdb\x87\xbd\xe1\x29\xe9\xd1\x72\x9e\xc9\xbd\xfd\xb5\x95\xcf\xb5\xbe\xcf\xad\x6d\x55\xcc\x83\x32\x26\x29\x64\xba\xf3\xb7\x05\xf8\xef\x0f\xdf\x41\x6d\xb4\x66\xba\xdf\x33\xc1\x6b\x22\x6d\x79\x15\x6b\x64\x1c\x0a\x87\x5b\xe1\x72\x3a\xb5\x46\x95\x4a\xd0\x2a\xf4\x20\x58\xe3\x58\x2d\x3b\x2c\x68\xd3\x1a\x3a\x1c\xf6\x25\x5e\xf3\x85\x63\x51\x87\xed\x82\x74\x20\xf0\x4a\xe0\x9a\x09\x6e\x23\xe0\xd2\x71\x00\x19\xef\x9c\x5b\xbc\xf4\xac\xc6\x53\x70\x48\xbc\x24\x7e\x03\x8a\xc3\x3a\xe7\x01\xc8\xde\xab\x8b\xd5\x2d\x4a\x58\x4f\x90\x3d\x99\x36\x43\x91\x1e\x6f\xcd\x7e\xe1\x8b\xd0\x2c\xb6\x5b\xeb\x9b\x83\x16\xe2\x15\xa1\xf5\x05\x9b\xfa\x63\xcd\xfa\xa5\x95\xaf\x9a\x8c\x69\x25\x92\x7d\xe3\x21\x76\xe5\x74\x02\xb3\x93\x5c\xcd\xf6\x3b\x92\xd4\x36\x21\x51\xab\x8d\x51\x31\xac\xd2\x1c\x23\x28\x09\x57\x32\x29\xc9\x49\x36\x2a\x2c\xd4\xc1\xa4\x24\x9e\x51\x29\x86\x05\xe9\x72\x3a\x7d\x63\x90\xee\xd5\xac\x37\xc4\xd1\xdf\x94\x41\x83\x41\x8a\x3b\xda\x99\x66\xa2\x6d\x9f\x30\x2f\x99\x3a\x78\x8a\x28\x74\x33\xa9\x21\x23\x78\x8b\x3b\xfa\xe0\xbc\x60\xb7\xd9\x99\x82\x70\x78\xed\x22\x5c\xa8\xea\x75\x1a\x52\xc5\xb9\xe2\xf3\x87\x97\xf6\x5c\xa5\x4a\xdc\xb2\x76\xfa\xda\xca\x9a\xac\x98\x84\xa1\xf9\x71\xb1\x3a\x43\xf9\xb5\xf4\x77\x71\x75\xcb\x29\xf8\x29\xfb\xb1\x8c\x84\x40\xc5\xa2\x8d\xcb\xa6\x8c\x5f\x53\xbc\x72\xd8\x7c\x3c\xb0\x2c\x25\x3e\x21\x23\xb7\x8b\x44\x63\x1b\x49\x3d\x6d\x52\x5c\x22\xaf\xdf\xcc\x63\x62\x55\x92\xfe\x13\x0f\xd5\x41\x9e\x67\x58\x86\xca\x9a\x70\x6c\xa0\x4e\x53\x79\xf4\x8f\xb5\x45\x14\x54\x44\x39\x49\x32\x16\x21\x26\x8b\xc8\x15\x29\x3f\xe0\x38\x1e\xf3\x4a\x05\x90\xa6\x05\xe0\x05\x3d\x6f\xbd\x49\x7e\xf2\xae\xd5\x46\xd8\x0f\xeb\xc4\x95\xe2\x57\x6c\x37\xb1\xf2\x55\xb1\x0b\xc9\x83\xb6\xc3\x50\x22\x37\x66\x92\x76\x50\x92\x76\x28\xf1\xc7\xc7\x0b\x1e\x97\x03\x99\x1c\x1e\x13\x41\x7f\x9c\x41\xcf\x0c\x0b\xea\x0d\x82\xc7\xea\x19\x16\xb4\xda\xda\xe5\x14\x5d\xcd\x17\x15\xe3\x94\x94\x11\x8e\x07\xd3\x8b\x58\x40\x74\x83\x34\x93\x95\xee\x88\x86\xa4\x88\x31\x56\x69\x34\xcc\xce\x4e\x28\x1b\xd6\xad\x68\xd9\x7d\x22\x9f\x39\x62\xe5\x98\x73\xdf\x88\x87\xc4\xd7\xc5\x93\xe2\xa1\x99\xe7\xee\xad\xac\xf9\xd3\x62\xdc\x6b\xdf\x81\x41\x81\xd0\x4b\xc2\x17\x30\x72\xc1\xf2\x21\x59\xe2\xb5\x5f\xc4\x6b\xe2\x59\xc8\x83\xc4\x87\xff\xb1\xe1\xa2\x66\xdf\x86\xe7\x3e\xe3\x08\xbc\x15\x68\x08\x1e\xcd\x7c\x2a\xcd\x89\x26\xfb\xf5\x2c\x12\x30\x46\x04\xa3\x88\x47\x98\xc5\x91\xf1\x97\xe8\x19\xb7\xc2\x14\x2b\x90\xa3\x02\x2b\x42\xbf\x63\x05\xce\xfa\xe7\x4b\xff\x0c\xdd\x46\xbe\xe4\xf5\x6e\xa5\xcc\x8b\xe8\x64\x78\x1f\x5a\xdd\x51\x8e\xb4\x0a\x90\x6e\x39\xe1\x0b\x69\xff\x51\x1f\xdd\xa3\xe4\xe4\x3d\xf7\x7c\xf6\xf4\xd3\xcc\x8b\xd8\x28\xee\x7f\x84\xa6\x39\xc8\xfc\x0a\x7b\xb9\x73\xe1\x34\x54\xd3\xb2\x1d\x69\x0a\x7d\x8c\x17\xec\x95\x4f\x3f\x9d\x5a\x03\x4b\x6a\xb8\xbc\x47\xc4\x8c\x89\xb0\x70\x12\x49\x27\xfe\xce\x8e\x05\x65\xb8\x2c\xcd\x11\xaa\x73\x50\xae\xef\x9d\x7c\x39\x95\xdd\xea\x2e\x24\xa9\xea\x43\x3f\x92\x34\x7f\x5b\xbf\x1e\x41\xf8\xfd\xe3\x88\x43\xaa\xc3\x34\xec\x12\x79\x59\x5e\xab\x59\xe8\x03\x65\xe8\x47\xd8\xb4\x81\x1d\xbb\xfe\x8a\x2c\xcb\x1e\x64\x42\xcc\x54\xa1\x1f\x69\x47\x97\x5f\x47\xa9\x8c\x63\x54\x6a\x42\x1f\x0a\x46\x11\xd9\xb0\x35\x32\xb6\x03\xf2\x38\x25\xf8\x80\x99\x2a\x7e\xf7\x84\xf8\x2d\x8c\x48\x86\xd1\xdc\x67\xa2\x0b\xbe\x88\x83\x72\xf1\xe8\x0d\xf9\x29\x38\xc4\x11\xdd\xa8\x26\x8a\x5c\xc0\xc2\xf5\xf9\xd1\x40\x93\xf2\xe2\x1e\x92\xdf\xbe\x64\xf1\x10\xd8\x9f\x00\x1b\x37\x50\x3c\x0a\xe5\x71\x34\x04\x1b\xa5\xb3\xd7\x99\xbd\xf0\x8d\xf0\x4e\xa4\xdd\x04\x06\xb3\x84\xd5\x15\x1c\x70\x40\xf8\xe0\x26\xed\x46\xec\x6a\xb7\xb4\x85\xef\x5b\x5f\xb9\x08\x1f\x7e\x02\x2e\xae\x02\xaf\x68\xf9\x04\x74\xe2\xcf\x37\xe6\xc7\x03\x70\x54\x8d\x60\xc2\x0f\xac\xb4\xc3\x6d\x7b\x7e\x91\x59\x42\xb7\xd9\x27\x6d\x0d\xfc\x8d\xf8\x89\xeb\xab\x18\xf1\x0b\x66\x2f\x5e\x01\x07\xc4\x9f\x41\x27\xc1\x07\x24\x3f\xee\x7f\x92\x1f\x44\xe5\x07\xe2\x1e\xd2\x76\x05\xa4\xed\x94\xc8\xd2\xc8\x71\x4a\x46\x10\x40\x0a\x66\x27\x0d\x21\x48\xab\xe5\xc3\x2e\x2b\xe2\x1e\x7c\xff\xb5\x0d\x4f\x6c\xe0\x8e\xaf\x3f\x7d\x5a\x5a\x5f\x23\xee\x21\x5f\x05\x50\x25\xa5\x65\x59\x0c\x44\x6c\x28\xa5\x4d\x87\xcf\xc9\x69\xc3\xae\x2d\x56\xb7\xb8\x87\x24\xbc\x16\x9a\x03\x55\x57\x4e\x9f\x5e\x2f\xad\x97\xfa\x5d\xbc\x1d\xbf\xd0\xb6\x85\xb0\x43\x9c\x5f\x8d\x11\x0d\xf5\x22\xb0\x80\x29\xa5\x9d\xcb\x0f\x0b\x7a\xda\xcf\xf6\x78\x05\x8f\xd9\x87\x5f\xf8\xcb\xaa\x45\xd7\x42\xaf\x8b\xb7\x6f\xdb\x06\x5e\x8a\x87\x37\x41\x07\x7f\x25\xb2\x81\xe2\x21\xc9\xaf\x43\x2c\x4b\x40\x57\x28\x09\x01\x10\xfe\x0a\x4f\x80\x44\x07\x6a\xea\xbc\xc9\x32\xe3\xa2\x1b\x2a\x87\xfe\x2e\x6d\xa8\x2c\xc9\x97\x5b\x49\xcf\xfd\x34\x9b\x1e\xf1\x61\x10\x30\x8d\xf5\xa3\x54\x20\xcc\xb1\x12\xf1\x77\xe2\x54\x79\xbd\xde\xad\x78\x5e\xe8\x4f\x78\x1e\x33\xe8\xea\xff\x47\xdc\x7b\x00\x46\x55\x7c\x7d\xa0\x73\xa6\xdc\x7b\xd3\x3b\x21\x40\x42\x20\xf4\x40\x02\x09\x11\x82\x40\x02\x44\x7a\x93\xde\x02\x84\x14\x12\x4a\x12\x92\xd0\x44\x9a\x35\x8a\x8a\x62\x43\x51\x41\xec\x5d\x14\x15\xbb\x20\x08\x0a\x88\x74\x14\x01\x15\x10\xfd\x0b\x22\x55\x81\xe4\xee\x3b\x73\x76\x37\xd9\x85\x60\xfd\xde\x7b\x84\x9c\xcc\xce\xce\xfc\xe6\xb4\x99\x39\x73\xef\xdc\xb9\x87\x2a\xbf\x3e\xe0\x3c\xdb\x83\x8d\x87\x1d\x70\x9b\xf3\xdd\xd2\x6f\x0b\xce\x9d\x1b\x18\xb6\xba\xcf\x2c\x23\x67\xc9\xd3\x8e\x02\x3b\xc4\x6b\xba\x7c\x96\x48\xc3\xf2\xda\x9e\xe1\xef\x50\x79\xc0\x0e\x94\xe6\x5d\x21\xe7\xbb\x38\x68\x2c\xd2\xf8\xdd\x58\x4a\xcf\x47\x83\x5c\xf6\x8f\x66\xa3\xd3\x93\x84\x34\x23\xa2\xeb\xfa\xf8\x07\xfa\x32\xe9\x6b\xc6\xd4\x0f\x8d\xbc\x7e\x64\x28\xd3\xef\x59\x1c\x30\xb2\xae\x0a\x08\xf2\x95\x11\xc0\x06\x8f\x04\xf6\x5b\x7d\x48\xab\x0f\x89\xf5\xf5\xc9\x65\x55\xb1\x41\xd5\x43\x7a\x1e\xef\x93\x74\xc7\x06\x5a\x4c\x97\xda\xdc\xaf\x16\x74\xbf\x50\x32\x39\x42\xa4\x6a\xdd\x41\x54\xe5\xed\xf6\x4f\x4f\x3c\xf1\xd8\xf2\x01\xd9\xcd\x9b\xf7\xbc\x76\xb7\xac\xdc\xb6\xed\x12\xc6\x30\x97\x3e\xd3\x27\xb2\x8a\x1b\x3f\x9a\x76\xff\x3d\xc1\x6f\xf9\xa4\xf6\x1c\xfa\x11\xab\x9a\x4f\x9d\xfc\x47\xb1\xfe\xe9\xf1\x4c\x84\x44\x45\x2a\x5f\x4b\x19\xc2\xa8\x5b\x27\x30\xec\xfa\x91\x68\x4a\xcb\x07\xe7\xd0\x48\x9f\x20\x40\xef\x88\xf8\xad\x2e\xa4\xd5\x85\xc4\xba\x4e\xb6\x93\xd2\xd2\x2e\x63\xd9\xcd\xb1\x7e\x4f\xea\x55\x99\xed\x00\xb5\x2f\x63\x54\x6d\xb9\xd8\xf6\x0a\x16\x1d\x0e\xf6\x2a\x9a\xe6\x03\xf9\x75\x68\x13\xe5\xa3\xdf\xa8\x2e\xcf\x42\x8a\xfd\x16\xfa\xfa\xf3\xea\x59\x18\x61\x1c\x66\x01\x68\x57\x43\xdf\x92\xd6\x4f\xca\xa7\x61\x90\xb2\x35\x33\xa9\xea\xb5\xbb\xc9\xce\x3b\x10\x30\xe2\xed\x95\x2b\xdf\xde\xda\xbb\x4b\xe7\x7e\xc6\xe1\x47\x9f\x7a\xf6\xe1\x6e\x23\x46\x74\xd3\xd8\xec\x21\xd9\x44\x7e\x1d\xec\xc4\x6e\xaa\x7c\xf8\x24\x7d\x96\xab\x3c\xc9\x27\xc1\x5c\x16\x89\xe3\xe1\x00\x3f\x48\xf3\x83\x44\x3f\xa8\xef\x07\x7e\x2c\x44\x5f\x6a\x75\xbe\xf3\x9d\x35\x77\x6c\x97\x8b\x90\x2f\x43\x85\xd2\xe7\xae\x18\xa3\x0e\xa4\xcf\xae\xef\x51\xaf\xd3\xe8\xb3\xa0\xcf\x4b\xf1\xf3\x06\xfa\x2c\xe9\xf3\x40\x9c\x8f\x2b\xe8\xb3\x1f\x7d\xee\xee\xd8\x20\xdb\x18\x0b\xf1\xb3\x3f\x7d\x7e\x15\xf1\xea\xd3\xf7\x01\xf4\x19\x3b\x99\xf8\x83\x3e\xd7\xa6\xcf\x9d\xf0\xfb\xba\xf4\xb9\x0e\xf9\xf9\x28\xf8\x5c\xce\x95\x33\xf5\x89\x25\xe9\xfe\x06\x8e\xe3\x20\x2c\x1f\x83\x03\x2e\x9b\xba\xbc\x31\x52\xbf\xb5\xbe\x1d\x4b\x5b\xef\xf1\x02\x4b\x8f\x80\x61\xee\xa5\x03\x70\x3b\x84\xc0\x22\xf8\x1c\xbd\xfd\x65\x7b\x08\xe2\xa7\x3a\xce\x1b\x71\x46\x77\xd4\x7b\x14\xe9\xfd\x94\x7a\x99\xda\xbd\x22\x9f\x6d\xaf\x21\xbf\xa9\x3c\x2b\xa3\x1d\xab\x42\x5c\xf5\x58\x72\x7a\x43\x48\x8f\xc1\x15\x7e\xa7\x18\x78\x26\x06\x96\xc5\xc0\xf8\x18\x18\x1a\xa3\xf3\xae\x8d\x81\x46\x31\x20\xf1\xcb\x90\xaa\xf3\x1e\x53\x50\xd5\x2e\x3d\x5f\x15\x97\x6d\xfb\x4f\xb8\x5d\x1d\x51\x64\xaf\x26\xda\x5e\xc1\xda\xe6\x6f\x38\xf3\xed\xa7\xbd\xf2\x7f\x73\xe7\xbb\xec\x4b\xf9\xd8\xfe\x59\x3e\xb0\xf2\x1d\x96\x98\x5e\x1f\x1c\x31\x70\x32\x06\xb6\xc5\xc0\xc7\x31\x10\xa4\x79\x19\x4d\x8d\xc7\xc7\x80\xe1\x6e\x3c\xc5\xe9\x3a\xee\xb6\x07\xa1\x2f\xec\x25\x2c\x70\xf9\xf4\x4e\xca\x4f\x43\x1b\xaf\xa0\x7c\xee\x6c\x03\xbf\xee\xcb\xe2\xd3\xeb\xc1\xc0\x3a\x90\x56\x07\x12\xeb\x40\x50\x1d\xa8\x03\x43\xea\x40\x46\x1d\x68\x5b\x07\x0c\xfc\xe4\xd9\x40\x8a\xb7\xef\x35\xd1\xbe\x47\xf8\x8f\x79\xf9\x60\x13\x25\x5d\x32\x68\xdb\xd4\x42\x3f\x1f\x12\x0c\x7d\x82\xa1\x51\x30\xd4\x0d\x86\x60\x27\x94\xc3\xe1\xd0\x37\xb1\x9c\x7d\x0f\x85\x0e\x36\xe4\x59\x5f\xc2\x77\x6c\xd5\x67\x43\xca\x8b\x98\x6f\x38\xf3\xa3\x9d\xed\x3e\x8d\x31\x61\xa8\xfc\x15\xf3\x2d\x67\xbb\x9c\xe4\x72\xbc\xc7\xbb\x57\xf7\x61\xdd\x2e\xf3\x65\x2f\xb3\x88\xf4\x00\xd8\x46\xc7\x7e\x06\xa4\x07\x85\xf4\x0c\x60\x21\xf1\x5a\x02\xed\xeb\xf6\x7c\xf2\xf5\x26\xca\xd7\xc5\xff\x52\xaf\x3e\xd3\x44\xf7\x19\xd2\xcf\x76\xc7\xfb\xcc\x67\x35\xc4\x86\x41\x58\x88\xb3\xae\xbb\x1f\x35\xd1\xfd\x88\xca\xec\x65\xc1\x2c\x34\xdd\x0f\xca\xc2\x20\x23\x0c\xda\x52\x51\x92\x4f\x9f\xa9\xa6\xe2\xe5\x21\x2c\x1b\xe8\x2c\x2b\x9a\x62\x59\xd4\x07\x0c\x89\x82\x8c\x28\x68\x1b\x05\xf1\x51\x10\xe5\xd6\x07\xeb\x49\x72\xeb\xf6\x83\x5d\x72\x7c\x8e\x82\x63\xfb\xb7\x90\xd6\xa8\xfd\x64\xd4\x41\x63\x2a\x13\xe2\xd2\xf1\x76\x97\x8e\xd1\x39\xcb\x62\x20\x83\xee\xe9\xc4\x54\x61\xde\x6a\xcf\x97\x9f\x52\xf9\x30\x57\xf9\xf9\x18\xab\x07\xbe\x03\x5f\x45\x41\x30\x36\xae\x0d\xab\xcb\x61\xfc\x2e\x37\x52\xb9\x70\x57\xb9\xe9\x6c\x05\x0b\x43\xb9\x8a\xa3\x3c\xcb\x4e\x73\xf9\x80\xbe\x77\x31\x97\xca\xd7\x72\xe9\x61\x92\xfd\x3b\x6b\x90\x1e\x01\x45\xa1\x30\x2e\x14\xd2\x42\x01\x72\x42\x21\x3c\x14\x58\x28\x84\x92\x46\x58\xa6\x4b\xff\x73\x90\xa7\xcd\x54\x37\xd2\xd5\xd6\x8b\x2c\x95\x45\xac\xe2\xe1\x6b\x1c\x9f\xbc\x13\x16\xde\x93\x37\x0a\x87\x70\x2d\x70\x7c\x8a\xe7\xd8\xd4\x44\x8f\x4d\x1e\xf6\xa2\xbe\x4b\xf9\x51\x4e\x1c\xdd\x77\xff\x43\x9f\x75\x8f\x79\x4d\xf4\x98\x47\xf6\x42\x3f\x63\x01\xef\xc0\xe8\x3a\x10\xee\xec\x0a\x29\xae\xb1\x13\x3e\xa0\x31\x43\x39\xc7\x28\x48\xa9\xee\x77\x46\x7c\x55\xbf\xfb\x9d\x27\x56\xfb\x15\xe5\xfb\x39\xf3\xe1\x30\xe5\x93\xce\x29\x3f\xdc\x55\x7e\x2a\x8d\xb5\x58\x5e\x25\x1b\x8b\x59\x18\xbb\x2e\xbd\xb6\x04\x23\x58\x85\x62\xa8\xed\x17\x16\x1a\xea\xc7\x40\x86\x47\x04\x1b\x86\x0c\x5b\x03\x1d\xde\xf0\x05\xf9\x1e\xe8\x93\x8b\xaf\xa1\xf7\x76\xa6\xd1\xed\x1e\xef\x57\x45\x86\x38\x17\x0c\xfa\xf5\x67\x9d\x21\x0d\x1a\x98\x81\x18\x28\x47\x36\x38\xfa\x20\x04\xf6\x86\x07\x3b\x77\x0d\xac\x05\x11\x51\xbe\x1d\x0b\x4a\x98\x63\x96\xfd\xbe\x6c\xc0\x0b\xed\xde\x95\x5b\xdb\x3f\x7e\xf3\xfe\xdf\x72\x1e\x5b\x94\x63\x3f\xed\xdc\xa7\xe9\xe8\x21\x57\xf0\x22\xa3\x25\xce\xd0\xd6\x2a\x5a\x56\xe8\x53\x97\xa5\x19\x17\xda\x80\x17\xfd\x62\x9f\x9a\xb1\xe6\x02\x4f\x54\xb7\xf2\xfc\x39\x70\xd7\x15\xe5\x99\xde\xa1\xd2\xa6\xb5\x88\x0d\x8b\x6b\xd2\xa8\xe9\xbb\x3c\xf1\xc2\x9a\x19\xf6\x6f\xff\x33\x5a\xda\x65\x73\xf2\xb9\x13\xbf\x17\x96\x9f\xa2\x7e\x62\xfe\xb8\x72\x41\x75\xf9\xea\x7d\x0e\x49\x14\x55\x3a\x17\xf8\x71\x7a\xb5\xaf\xf8\x94\xc9\x5b\xb3\x46\x4c\x88\x78\xbf\xce\x96\xa7\xee\x01\x7f\xf9\x63\xfd\x84\x9e\x7d\x1e\x7b\xb9\x8b\x1b\x63\x25\x62\xfc\x0f\x31\x82\xdf\x42\x0c\x53\xf8\xea\xe8\x92\x62\x53\xe1\x3c\x8f\x5f\xdf\xb0\x69\xd8\xf8\x1d\x0f\x10\xfb\xac\x7a\xba\x1a\x24\xd8\xb9\x1f\x55\xad\xa5\x7d\x9a\x01\xf4\xf4\x7c\x34\x6b\x40\xef\x5b\x49\x64\x5d\x5c\x7b\x16\x27\xb1\x19\xec\x4c\xfa\x4d\x46\x4c\x4c\xa8\x59\xbf\x7e\x68\x60\x93\x26\x41\x4d\x9b\xf6\x1b\x38\x2d\xb7\x76\x8b\xf1\x93\x87\x66\x66\x76\xef\x3d\xb0\xeb\x88\xb4\x0e\x22\x2c\xac\x43\xc7\xe4\x11\x03\xbb\x4f\x6e\x91\xeb\x1b\x1f\x5a\xa7\x61\x42\x42\x5c\xdd\xf8\xf8\x99\xe0\x17\x11\xe1\xcb\x42\x43\x67\xf9\x37\xaa\xe7\x17\x97\x50\xab\x65\xf7\x09\x13\xda\x65\x96\xb5\x6e\x3b\x66\x68\xc7\x21\x43\x3a\xf5\x80\xba\x85\xf9\x2d\xcb\xda\x0e\xed\x51\x37\x3f\xbf\x6e\x8f\xa1\x6d\xcb\x5a\x9a\xf5\x62\x9b\x85\x8b\x84\x84\xb0\xfa\x4d\x45\xbc\x19\x24\x44\x54\x94\xb4\x82\x45\xbd\xab\x3e\xc6\xe6\x71\x75\x37\xa4\xea\x56\x9b\xbe\xe9\xf9\x99\x33\xd6\xf6\xd8\x2e\x43\xb7\x09\x23\x2f\xbb\xe2\xea\xfc\x49\xa2\xff\x1e\xf7\x7b\xe3\xf4\x9b\x9c\x94\x3e\xc4\x21\x4e\xbf\x4e\x0f\xff\xe2\x92\x2f\x45\x6f\x5d\xd7\x6f\x0f\xf1\xc8\x57\xfa\x7e\x5e\x72\xe3\xea\xd7\x8f\xd2\xfb\xb8\xc3\x8d\xc6\xfa\x8d\x1b\x21\xc9\xb1\xfa\xb2\x46\x0c\x08\xd7\x7b\x5d\x23\x5d\x7f\x21\xb8\x41\x4d\x2f\x1e\xb1\x58\xce\x21\xe8\x56\xb9\xd6\xfe\x10\xba\xf1\xb4\x9c\x9c\x4b\x37\xe9\x94\x9c\x67\x7f\x78\x28\xe7\x42\xb7\x43\x39\xce\x34\x74\xbb\xf8\x54\x4e\x8e\x88\xd1\x29\x5d\x36\xe7\x90\x62\x99\xe3\x22\x26\xfb\xb7\x68\x9d\xd4\x72\xec\x17\x39\xf6\xe2\x65\x8b\x5f\xbf\x07\x62\xfa\xf5\xcf\xce\x7b\x7c\xe4\xb0\xd8\xd8\xd7\x12\x73\x73\xdb\x76\x5a\x6b\xa7\xdb\x5f\x3f\xb8\x64\xc9\x43\x0f\x2c\x99\x36\x72\xcc\xf8\xe1\xa3\xc6\x64\x8e\x94\xf3\x0e\xe5\xe4\xe4\x54\xcc\x83\x6e\xb0\x3f\xe7\x62\x5a\xce\x21\x59\x07\x19\xc0\x04\xec\x87\x6e\x15\xf3\x72\xb0\xc5\x43\x87\xc7\xcd\x0c\xed\x93\xd1\x6d\x1c\xfc\x30\xaa\x72\xe3\x4d\x37\x9e\x9a\x32\x5b\xc4\xaf\xcf\xc8\x0b\xf1\x9b\x0c\x71\x5d\x53\x6d\xfb\xc8\x75\xbd\x71\x6d\xd8\xcd\x1e\xb5\xf5\xeb\xdd\x9f\x7f\xbe\xfb\xa5\x47\x1e\x7d\xf1\xd5\xe5\x0f\x3b\xd7\x0c\x13\xed\x54\x18\xe3\x78\x03\x3d\xac\x29\xc6\x52\x3e\x3a\xfe\xf5\xf3\x35\x4d\x69\xe1\xf0\xf7\xa6\x8f\x7f\x4f\x5c\x19\xc7\xaf\x4f\xf5\x5c\x74\xaa\x70\x7d\xb6\xba\x7e\xe3\x37\x8c\x89\x4f\xbe\x63\xec\x94\x73\x5b\x7a\x4d\xef\x94\xd3\x9d\xce\x41\x76\x7c\x88\x7d\xe7\x17\x75\x96\xf9\xb1\x76\xe9\x0d\x2c\x1f\xe9\x13\x20\xfc\x2d\x9c\x9a\x8d\xfb\x47\x62\xe4\x1a\x84\x9e\x9b\x86\x5e\x3b\x9f\x2d\x67\x27\xf5\x9b\x57\x9d\x2f\x88\x44\x6f\x20\x57\x48\x72\x9f\x1e\x9b\xac\xef\x20\x61\x07\x81\x21\x9b\x36\x5a\xdf\xf9\xbe\xf2\x8a\xef\x77\xd6\x46\xb9\xe2\xe9\xd7\x37\x6e\x5c\xf5\x14\xf1\x3d\x4d\x9c\x85\x3c\x5c\xeb\xf8\xb0\xe6\xe9\xb5\xa4\x65\xf8\x68\xbe\x8b\xcc\xf9\xe6\x62\x53\x98\xf7\xe2\x72\x14\x1b\x4d\x5b\x9f\xb9\x35\xd3\x7b\x83\xa1\x9b\xf3\x3c\x27\xe7\xf2\x64\xaf\x19\x1d\x73\x46\x6d\x73\xe9\x42\x7e\x00\x63\x8c\x5e\x88\x99\x94\x5e\xcf\xa9\x0b\x5f\xbf\xf1\x66\xb1\xb9\x00\x31\xcd\xe5\x12\xd2\x11\xf7\x5e\x4b\x3f\xb2\x99\xb9\x25\x33\x33\x35\x31\xd3\x6b\xd7\xb2\x3e\x7e\x5e\xdf\x36\x9e\xd8\xb2\xd9\xfd\x88\xad\xfa\x0f\x9f\x9e\x58\x85\x3d\x5c\x5d\xe4\x43\xcc\x48\xec\xcb\xf5\xd3\x43\x14\x37\x0d\x26\x16\x8f\x1e\xc7\xf4\x99\xad\xfe\x3d\xf5\xe9\xbe\x99\xee\xc3\xa9\xa1\x71\x4a\x83\xc8\x08\x78\xc9\x7e\x19\xf8\x25\x75\xf1\x74\xbc\x5d\xdf\x55\x7f\xa8\xbb\xbe\x64\xfa\x14\x54\xac\xaf\x40\xe9\xfa\xca\xb3\x7e\x58\x4a\xbb\x06\x11\x6a\x78\x05\x70\xfb\x65\x75\xb1\xbe\x1d\x7f\x5a\xdb\xe5\x28\xd6\xff\xcc\x8c\x47\xd9\xa2\xd3\x83\x85\xc5\xad\xc5\xa3\x8d\x71\x5c\x9f\x17\xe3\xdf\x93\xeb\xea\xb4\xb4\xd1\x87\xe2\xc5\x35\x8d\x33\xe3\x52\x20\x99\x7f\xb6\x7c\xb3\xdc\xb9\x02\xf8\x51\x23\x32\xfa\xe1\x87\xa3\x21\xdc\x1b\xa7\x75\x7a\x14\x03\xa5\x84\xe5\x6b\xf9\x99\x92\xc9\xc5\xa3\x95\x97\x3c\x49\xee\x93\x39\x9c\x5b\x1a\x74\x97\x85\x94\xe4\x48\x7d\x07\x0c\xb6\x1c\xb5\xed\x15\x3b\xe5\xe6\xe5\xea\x22\x84\x47\x2f\x5d\x1a\x4d\xeb\xb3\x20\xc4\x7e\xd4\xd8\xed\x3a\xe3\xb0\x36\x82\x0a\x89\x91\x3d\xce\x60\x70\xf7\x68\x59\x03\xb8\x87\x69\x71\xb1\x8f\xfd\x3f\x02\x76\x6f\xa8\x9c\xbe\x4e\x5d\xdc\x8f\xff\xc8\x1f\xb7\x21\xe6\x7e\xb3\x3e\xab\xcd\xda\xa7\xc7\x5a\x3e\x11\xb5\x6a\xd5\xf1\x89\x8a\x08\x08\x50\xf7\x8e\x64\x01\x8b\x47\xb3\xd0\x7b\x47\x5a\x97\x21\xc7\x57\x1d\x29\xe2\xc2\x6e\x98\xc0\x5d\x77\xdb\x93\x93\x62\xb8\x6b\xec\x86\x8a\x96\x23\x87\xf4\x89\x69\x1e\x1f\x78\x87\xd5\x66\x4c\xdf\x56\xa3\x86\xf4\x8a\x6e\xd6\x2a\xf0\x76\x73\x9a\xba\xd8\x24\xb1\x49\x42\xbf\x69\xd3\xba\xe1\xdf\x36\xbd\xf5\x8d\x76\xee\x78\x55\x5d\x14\x86\x59\x9b\xce\x41\xd1\xb2\x29\x5c\x64\x05\x80\xbf\x8f\xd0\x7e\x60\xd4\xac\x38\xf7\x4b\xd6\xe3\x52\x50\x67\x91\x44\x93\x6e\xd9\xfb\xcb\x08\xfc\x55\x17\x1b\x56\xc4\x9f\xc1\x5f\x2d\xe3\x25\xf5\x1b\xff\xd8\x0c\xc6\x39\xa2\x4d\x7a\x5d\x5f\x3f\xbf\x20\x29\x44\xa0\x2f\x21\x33\xf3\xde\x91\xde\x5e\x76\x85\x70\xd8\xdb\xaa\x26\x24\x18\x7d\xdf\x7a\xbf\xa7\x82\x26\x75\xef\x99\x1f\xf8\x74\xd8\xc7\xea\xb7\x95\xf3\x3a\xf7\xee\x95\x76\xeb\x32\x8a\x6d\x85\x5c\x0e\x4c\x1d\x0c\x36\x59\x37\x7b\x2d\x63\xff\x28\xaf\x36\xe6\xd5\xa2\xbc\x19\xff\x34\xcf\x0e\x52\x3b\x1d\x7b\xcd\xf8\x50\x83\x6f\xa6\x6b\x3f\x71\xf2\x79\xc7\x1e\x75\x09\x67\xc4\xe0\xb7\x82\x24\x37\xfd\x03\xe9\x32\x89\xd6\x95\xbe\x38\x6d\x36\x75\xed\x18\x8b\x88\x4b\x49\xba\x66\xfb\x1d\xdd\x52\xfc\x3a\xa6\x3f\xfa\xf8\xdb\x37\x76\x1c\xa0\x86\xb6\xf7\x9d\xe2\x7f\x7d\x9f\xe2\x88\xa4\xc2\x46\x57\x62\xe3\xe7\x39\xd8\xfe\xed\x6a\x7d\xb0\xc9\x9f\xb0\xef\x70\xb5\x5f\x53\xde\x72\xcc\xcb\x56\x3f\x60\xde\xa3\xf6\x3e\x57\xde\x7d\x98\x57\xa2\x2e\x60\x5e\xb9\x4d\xc7\xc6\x20\xaf\x2b\xec\x25\x8e\x77\x1d\x59\xe8\xd3\x18\x7b\x60\x47\x73\x5d\xdc\xb0\x57\x40\x94\xbd\x64\xdb\xb6\x7f\xa4\x9b\xbf\xa9\xeb\x2b\x64\xfa\xb7\x32\xfe\x1f\xe7\x39\x4a\xed\x25\xec\x2e\x47\x56\xa8\xe9\x13\xca\x76\xfe\xbf\x93\xf7\xff\x57\xbb\xff\x5f\xc8\xf1\xef\xf3\x70\x00\xd0\x07\xe5\xbd\x48\xd7\x2c\x6b\xa5\xe3\xa0\xc3\x94\xc4\xc9\x58\xdf\x09\x71\x5f\xed\xd3\xfb\x9e\xee\x83\x28\x7d\xf9\x0c\xe3\x55\xfb\x4b\xf5\x1e\x24\xe1\x38\xef\x3c\xcb\x23\xf4\x6d\x3f\x1f\x6e\x18\xfa\xbc\x69\x1d\xa5\xe9\xeb\xf1\x18\x80\x25\x2b\xfd\x76\x72\x7d\x9a\x96\xb9\x02\xfd\x7c\xc5\x8a\xcd\x3c\xa7\xf2\x31\xf5\xde\xd2\xa5\x4b\xbf\xbe\x13\x31\x2e\x20\x46\x08\x62\x38\xe3\xd7\xd0\xb7\xb1\x0f\xf8\xfb\xfb\x99\x1e\x18\x11\x38\xd3\xb4\x0b\x73\x21\x41\xc8\xb1\x87\x6e\x3f\xee\x44\x32\xe3\x83\x1f\x09\x5c\x66\x2f\x46\x28\xcd\xbf\x37\x3f\xc1\x7a\x9f\x64\x70\xb0\xe1\x1f\xe8\xcd\x54\x92\xf3\xd2\xaf\x0b\x0e\x47\x4b\x33\xae\x29\xce\x38\x6e\xee\xec\x65\x5f\x7d\xba\x7d\xd9\xc3\x4e\xfe\x7c\x17\xdf\xed\xdf\x0d\x71\x4f\x20\xae\xf2\xe2\xd1\xd7\x30\x02\x7c\xaa\x79\x14\x91\x38\x23\xa6\xb8\x4f\x83\x89\xbe\xfd\xa1\x63\xbe\x2b\x56\x40\xa1\x66\x71\x59\xe0\x23\xc1\x5f\x13\x87\xdc\x8b\x3f\xff\x37\x4d\xd7\xad\x08\xd7\x7d\x8b\xc6\xa8\xa3\x01\xc8\xc0\x7c\x97\x7e\x50\x3b\xba\xce\x3a\xf5\x16\xa4\x51\x9d\xba\xac\x53\x7a\x93\x48\xab\x08\xd7\xd6\xc1\xe1\xe1\xf4\xb2\x0c\x7e\x1c\x70\x0a\x87\xf4\xa8\x98\x9e\xfe\x00\x97\x00\x82\x00\x2c\xf0\xa3\x2b\xc2\xfa\xe5\x20\xf1\xd3\x4a\x92\xf4\x75\xf2\xcc\x64\xd7\xc1\xb2\xaa\xa1\xf3\x78\x7d\x9a\xa6\xe8\x58\x6e\x1c\xd1\x91\x31\xdd\x26\xac\x4a\x1e\x32\xb4\x51\xab\x56\xd6\x68\xbf\xf8\xbe\x69\xed\x06\x0f\x6e\xd8\x3a\xde\x18\xe3\xdf\xa2\x8f\x19\x7f\xe7\xf1\x26\x8d\xe3\x9a\x0d\xea\xd9\xac\x71\x93\x26\x8d\xaf\xef\xdd\x14\x7d\x65\x05\x2a\xfc\x1d\x8a\xad\x9a\xa4\x07\x9b\x00\x4c\xe2\x8a\xcf\x52\xa6\xa9\x0f\x9d\xd7\x4f\x2b\x85\xa6\x26\x06\xaf\xf7\x98\x7d\x1b\xc4\x85\x50\xc4\x1d\x92\x2c\xde\x29\xb7\x9f\xb6\xb7\x42\x2e\xb4\x28\x17\x8f\xc3\x98\x72\x7b\x0f\xb4\x60\x35\x61\x32\xe9\xe7\xfb\xf7\x31\xef\xb5\xbf\x27\x4c\xbe\x9b\x37\x2a\xb7\xaf\x83\xf7\xff\x0f\x30\x6f\xb3\x7f\x81\x22\x88\x2d\x87\xe5\x62\x54\x79\xe5\x28\xfe\xac\x27\xa6\xa5\xaf\xec\x1b\x7a\xf5\xe7\x63\x4a\x5c\xe3\x82\x90\x97\x23\xd2\x3e\x8b\x6a\xb8\xf9\xf6\x69\x82\x93\x17\xca\x2b\x32\xc4\x07\x88\xd5\xaf\x0a\xab\x51\x7a\x90\xe6\xce\xd7\x47\x99\xc2\x30\x4c\xd0\x37\x88\x08\x2c\xb9\x6a\x13\x07\x71\xe7\x03\xed\x7c\x80\xd0\xd6\xd8\x79\x63\x70\x95\xdc\xb3\x5c\x6e\xb4\xb7\xc0\xad\x59\xf6\x2e\x68\xab\xf9\x1b\x54\x25\xb3\xbe\x43\xe4\xb2\x0d\x62\xfa\x80\xf2\x71\x63\x7a\x4b\xdc\x00\xda\xe9\x27\x97\x35\xe8\x03\xf6\xe2\x09\xd0\x03\xda\x96\x8b\xe7\xa0\x28\xcb\x5e\x03\xf4\x6c\x62\x15\x9f\x74\x37\x43\x9f\xe4\x87\x1d\xd5\x47\x29\x13\xa4\x9b\xcd\xcb\x74\xd8\xce\x29\x72\x65\xcc\x38\x7e\x73\x39\xef\xcd\xb7\x8c\xad\x5c\xc6\x4b\xbc\xb0\x7c\x34\x96\xdb\x26\xda\x22\x96\xaa\x09\x2b\x05\x25\x86\xb0\x10\xb7\xc8\x83\xe1\xcd\x6f\xcb\x8f\xf3\x67\xe0\xd6\xc9\x76\xbe\x9d\x28\x0a\x08\xb3\x7b\x95\x1e\x63\x70\x8d\x42\x36\xd1\x16\x31\xa5\x37\xa2\xf3\x79\xc4\x2a\xb8\xe7\xec\xe2\x51\xf0\xea\xf7\xe5\xe2\x49\xb8\x21\xcf\x9e\x54\xf9\x98\xb8\xe8\xc4\xe2\xc5\x9e\xb2\xea\x7b\xcd\x0a\x47\x43\x43\x5e\x5d\x56\x5e\x5c\x6e\x8f\x1d\x85\xc6\x40\x97\x5e\x90\x63\xef\x83\x66\xc4\x57\x4a\x15\x5f\x4d\xd2\x43\x9c\xf6\x15\x06\xe7\x86\x10\x0a\x4c\xa7\xb8\xb4\x0a\xae\xd9\xc2\xab\xed\x41\x93\xd1\x18\x68\xe1\xd9\x95\x7b\xf8\x91\xfe\x95\x87\x78\x03\xe6\x85\xeb\xe5\xd7\x5c\xe8\xa1\xae\x4a\x8b\xc9\x5b\xbd\xf9\x24\xdc\x90\x6a\xe0\x2c\x48\x40\xc9\xed\x55\xfc\x48\x9f\xca\x37\xa1\x15\xc4\x22\xee\x80\xcb\x7d\x47\xe3\x5e\x06\x7b\x55\xdf\x79\xde\x9e\x55\x06\x39\x60\x95\xf3\x65\xfc\x89\x9e\x95\x2b\xf9\x58\xe2\xb5\xd5\x3f\xb3\xb7\xe6\x13\x22\x9d\x88\x4f\xd8\xe3\x67\xc0\x03\x7f\x94\x43\x20\x64\xf3\x2f\xba\x57\x76\xbf\x20\xde\x24\xcc\x9e\x2e\x4c\xc3\xf9\x24\x31\xe3\x96\x29\xa5\x00\xfd\x24\xf1\xe5\xf6\xae\x72\xc5\xa8\x99\x68\x24\xd5\x29\xe3\xd2\x23\x72\xa2\x8b\xaf\x7f\x67\xe7\xeb\x4a\xd1\x24\x7c\x18\x3f\xdc\xd3\x65\x10\x60\x8d\xfe\x93\x9d\xd7\xd8\x9d\x6e\x74\xda\x39\xaa\xe2\x80\x1c\x99\x54\x71\x40\xc4\x39\xed\xdc\xb8\x4a\x77\x2d\xd2\xc3\xaa\xfb\xb2\x0b\xd9\xba\x12\xd9\x13\x3b\x85\xc0\xd7\xd9\x6d\xe7\xc1\x08\xdd\xa3\x97\x57\xde\x2a\x9b\xa5\x54\xfc\xc4\xf3\xde\xf0\xc6\xfe\x57\x3e\xf4\xa6\xdd\x6d\x0e\x94\x42\x3d\xd4\x84\xbd\x4a\xf6\x4c\xaa\x98\x0b\xa1\x7c\x1a\xe2\x36\xfd\x2f\x3e\xf4\xa0\x9d\x3d\x1b\x6e\x06\xff\x72\xb8\x5e\xd8\x49\x15\x23\xc4\xf3\xa4\x87\xc4\x2a\xfd\xd6\x49\xf7\x35\xf4\x31\xb7\xbe\x86\xab\x77\x27\x5f\xd6\xb7\x23\xdd\x43\x45\xcf\xf9\xf0\xca\xae\x72\xe8\x21\x45\xbb\x8a\xf0\x3d\x72\x9d\x4b\x66\x6f\x9b\x3b\xc7\xb1\xab\xd9\x3c\xa5\xca\xe6\x9d\xe6\xa0\x79\xce\xc8\x31\x1e\xb6\x89\xf6\x1e\xbb\xa5\xe6\x89\x1b\x5c\x09\x97\xc5\x93\x3d\xef\xc5\x5f\x61\xf1\x6b\xe6\x42\x3f\x3d\x5c\xec\xad\x68\xae\xae\x6f\x5d\xd1\x5c\xec\xd5\x98\x91\x55\xba\x6b\x96\x1e\xe2\xb6\xb7\x46\xf5\x11\xae\xd1\x3b\xf9\xf2\x3b\xfc\xde\xd6\x5e\x63\xb7\x9e\x07\x23\xa1\x4b\xb9\x98\x5e\xb1\x48\x0d\x48\xac\x88\x14\x53\x16\x38\xf9\xbd\xe6\xdf\x63\xbb\x55\x3a\x60\x3e\xf4\x87\x96\xe5\x7c\x71\xe5\x34\x35\xb8\xd5\xa5\xc3\x7c\x2a\xac\xaa\x19\x5b\xdb\xfc\xef\x60\x43\xe3\x2a\xec\x79\x50\x06\x66\x39\xb4\xb7\x37\x69\xec\x39\x17\xc5\x5d\x4e\xbe\x5b\x57\xcd\x3d\xf5\xd2\xfd\x15\xd3\x8f\xba\xfb\x58\x68\x31\xe1\xb6\xbe\xf3\xfe\x5d\x73\x40\xb4\x64\x8d\x66\xc7\xdb\xfd\x17\xc2\xfd\xbf\x94\xab\xc1\x09\x97\x4c\x79\x01\x31\x9a\xbb\xec\xfe\x77\xc7\x0b\x6d\xf2\x2e\x0b\xa1\xb3\x86\x70\xdb\x66\x40\x15\x1f\xb1\xe9\x81\x28\xa1\xa1\x84\x7e\x30\xcb\x00\x61\x54\xa3\x44\xa6\x56\xf9\x74\x53\x68\xa0\x25\xdb\x62\xbf\x95\x85\x92\x9d\x95\x17\xec\x35\x59\x50\xe4\x94\xa9\x6f\x95\xbe\x5a\xa6\x87\x6b\x7d\x21\x27\x02\x23\x13\xc3\x14\x5e\x88\xc1\x5b\x29\x96\x88\xf4\xd4\x59\x53\xb7\x3d\xde\xb1\xd7\x8e\x86\x65\xda\x89\x96\x40\x8a\xbd\x3f\x0f\x66\x63\x1c\xd0\xf6\x2f\xf0\xa5\xe9\x81\x8f\x16\xf9\x13\xfc\xa5\xf6\x37\x43\x09\x9f\x37\xe7\x0b\xed\xf3\xf9\x30\xbb\x72\x2d\x4f\xab\x19\xdf\xb9\x53\xe6\xaf\xf1\x53\x40\x55\xe1\xdf\x62\x1f\x1f\x4c\xf8\x3f\x8b\x57\x34\x7a\xc5\x4e\xd1\x0a\xb1\xc7\x56\xf5\xab\x66\xe9\xa1\x06\x93\x9c\x22\x2c\x25\x28\x90\xe7\xea\x4a\xcd\x90\xd5\xaa\x61\xef\xb6\xcf\x5c\x8f\xb0\xd7\x94\xcb\x3b\x8e\xa1\x4e\x2a\x3a\x89\x4f\xdd\x3c\x57\xfb\x80\xf6\x7e\xd3\xd2\x83\x28\x57\x57\xfa\x40\x08\x1a\x8f\x7c\x60\xdd\x58\x78\xac\x5c\xae\xb3\x0f\x14\xc0\x6c\xef\xd8\x2f\x36\x3d\xc0\xd9\xe7\xa5\x0e\x83\xaa\xa3\x35\x4f\x14\x53\x87\x7e\x9a\x27\x87\x5d\x0c\x43\xe0\xda\x72\xb9\xfe\xfb\x72\xa8\xe5\x15\x97\x7a\xf4\x17\xa9\x4c\xfc\xf1\xd1\x3b\x5c\x5c\xfb\x64\x92\xaf\x1a\x99\x2e\xc3\xa8\x59\x4f\xe0\xbc\x00\x6e\x40\x36\xb9\x6b\x2f\xe6\x15\xb8\xba\x8f\xff\x13\xdc\x27\xec\x9d\x30\x1f\x82\xcb\x21\x85\xbf\x5a\x5e\x79\x5a\x34\xf2\xc6\xa5\xb1\xce\x39\xfe\x0a\x69\xe0\x0f\x5d\xea\xbc\x0c\xd5\x1d\xf5\xba\xa2\xac\x57\xec\xf5\xf0\xc4\xa9\x72\x71\xb8\xbc\x32\x4d\xf7\x24\xd7\x3d\xa3\x2a\x1b\x87\xe9\xbe\x24\x05\x22\xea\xf7\x36\x29\x43\xb8\x30\x5d\xfb\x42\x3d\xfa\x54\xf5\xf8\xf9\xae\x9d\x3f\x1e\x62\x20\xab\x5c\xce\xaa\xdc\x0d\x4f\x4e\xb0\xf7\xf3\x61\xde\x7e\xe9\x9e\x2f\x0d\xed\xf7\x38\xab\x29\xc3\x53\x03\xc9\x5b\x2f\xf7\x7a\x8f\x51\x2e\x77\x3c\x5c\xab\x7b\xd5\xeb\xf6\xbb\xf0\xd8\x78\x7b\x03\x4e\xcd\xc1\x1e\x31\xa6\xd7\x7c\x79\x05\xf0\x55\x67\xb6\x3c\x7b\xd5\x04\x68\x01\x99\x18\x1d\xc1\x8c\x31\xf6\xdb\x18\x1d\x55\xf3\x4b\xbb\xa5\xaa\x62\x10\xa9\xa4\x09\x66\x0d\xbb\xb9\x3c\x23\xeb\xe8\xb1\xfc\xd6\x72\x68\xca\x8f\x64\x57\xce\x11\x4b\x3d\xb0\xc8\x37\x5d\x31\xf0\x65\x16\xaa\x31\x0a\x46\x81\x47\xc3\xeb\xfb\xca\x79\x29\x3c\x9a\x6d\x0f\xb6\xb3\xe5\x68\xaf\xfe\x52\xc5\x1b\xcd\x95\x7f\xc9\x9b\xee\x36\x39\x99\x90\x56\xce\x73\xe0\xb1\x5c\x7b\x2d\x1f\xed\x35\x7f\x37\x4f\x0f\x77\x5a\x85\x22\x24\xa5\x30\x92\x91\x9e\x06\x4f\xbc\x9a\xc1\x7b\x4c\x47\xf8\x21\xe5\x32\xba\xe2\xa8\xc8\xea\x5e\xf9\x88\xd0\xaf\xc5\x4a\xad\xb2\x49\xab\xf4\x5a\x64\x13\xf4\x24\x8a\x90\x9c\xc8\x2e\xcb\x78\x21\xd7\x34\x69\x0e\x9a\x01\xed\x29\x78\xaf\x9c\x26\x7a\xf4\xa8\x7c\x92\x2f\x7e\x8b\x74\x90\x76\xb9\x3f\x39\xf1\xff\x89\x3f\xad\xb3\xfb\xcf\x84\x4c\x1d\x27\x95\xda\x4f\x8b\x11\x9d\x2a\x87\x42\x7b\xde\xd3\x0b\x1b\xc7\x39\xe7\x18\xea\xe4\xfd\x4a\x8f\x8a\xac\xd1\xa3\x9e\xb2\xa7\xce\xc4\xf5\xa4\x6f\x39\x0c\x13\x51\x9d\x2a\x93\xc4\x53\x5e\x3c\x7b\xf8\x01\xce\x29\x16\x9d\x23\xa9\xd1\xae\x58\x0d\x45\xba\x17\x05\x63\x66\xc2\xa3\x87\xb0\xeb\x8b\x0e\x9d\x2a\x0e\x6e\xd6\x11\x93\x0b\xcf\xdb\x0f\xfe\x9e\x8f\x6a\x3f\x18\x3e\x13\x92\xca\xa1\x95\xe8\xda\xa9\xf2\x45\x11\xef\x11\x27\x78\xf5\x7b\x97\xb1\x2c\xe1\xe4\xb0\x2a\x9e\xad\xc1\x0d\x30\x4c\x98\x0b\x6d\xdd\x71\x93\x4f\xeb\x8a\x69\xce\xb9\x39\xc5\x63\x3e\x8a\xa8\xb6\x93\x0b\x19\x83\x10\x9f\x2b\x90\x6b\x72\x83\xfe\x73\xa1\xa3\x3b\x76\xf2\x69\x53\x31\xba\x86\xd8\xc9\x85\xef\x1c\x57\xfe\x2e\x7e\x4d\xf1\x93\x5f\xab\x8a\xf8\x1a\xe2\xa7\x7f\x81\x5f\x73\x0c\xe5\xdb\xea\xd2\xfa\xaa\x18\xea\x1a\x8f\xf5\x7b\x90\x3b\x86\x12\xfa\xed\xab\x64\x43\xb7\x57\x5c\x11\x49\xb5\xd6\x90\xcb\xbe\x2b\xd7\x68\xd7\x63\x24\xe5\xd2\xb5\x6b\x1e\x45\xff\x72\xc5\x52\x42\x1f\x10\x64\xd4\x30\xce\x54\xb9\x42\xbf\xf9\xb8\x04\x41\x98\x8a\x1b\xc4\x57\xde\x31\xd0\x3f\x8c\xa7\xbe\xb7\x5f\x2a\x82\x99\x3a\x9e\xaa\xfc\xb4\x0f\xbf\xe1\x2a\xf1\x54\x55\x3c\xf2\x0f\xe2\xa9\x1d\xf6\x7b\x45\xee\x78\x2a\xc6\xf6\x47\xf0\x1a\xe3\xa9\x88\x6a\x7c\x69\x0a\x41\x67\x23\x59\x86\xd7\x4a\xac\x66\xfc\x55\xf6\xfe\x22\x77\x3c\x35\xd8\x4e\x47\xfc\x1a\xe3\x29\x0f\x7c\xc4\x46\x1b\xfd\x19\x7e\x8a\x07\xfe\x32\xfb\x54\x91\x2b\x9e\x9a\x6e\x8f\x45\x78\x0a\xa8\xbc\xf0\x69\x7d\x6a\xd0\xfa\xd4\x10\x1c\x87\xb1\xab\xaf\x4f\x3d\x80\x9f\xb0\x7f\x2d\x82\x57\x74\x44\x35\xc8\x9e\xa4\x71\x9d\x21\x15\xe2\xe6\x7b\xfa\x82\x9e\x11\x2d\x53\x70\x8c\xd4\x6a\xf4\x85\xaa\xa8\xea\x64\x11\x2c\x28\x97\xf3\xec\x8e\xfd\x2e\xb7\xdf\xdf\x8d\xcd\xf4\x04\x38\xb9\x3f\x3f\x5c\x2e\xb7\x55\x7e\x95\xaf\x51\x3c\xe7\x67\xf7\x58\x4d\x3a\x14\x7a\x12\x34\x2e\x8f\x7e\xbc\x46\xd4\xa6\xee\x11\xf5\x23\xfb\xfd\x09\x30\x09\xe6\x63\xb0\x62\x2f\x1d\x03\x0f\x50\xac\x56\x6d\x9b\x04\x2f\xdb\x88\x1a\x90\x83\xaf\x98\x07\xae\x8c\xd6\xf9\xc2\xaa\x68\x9d\x5f\x77\x19\x7e\x2d\x4f\xbe\xe9\xaa\xa2\x29\x3c\xe7\xb0\xcb\x79\xaf\x29\x5a\x87\xa8\xaa\x68\x5d\x0c\xf0\xb2\x3d\xce\xbd\x68\x7b\x4e\x63\xae\xd0\x43\x8b\x30\xae\x3a\xf7\x82\xa8\x42\x2e\x38\x3a\x11\x17\xfa\xc5\xe5\x38\x1e\x1c\x19\x03\xeb\x2a\x9e\x96\x8d\x6a\x8c\x0f\x98\xc4\x31\x05\xad\x7f\xf5\x79\xa1\x29\x8e\xb4\xda\x01\xd6\x66\x62\x58\x2d\x3e\xb7\xd7\xe6\xc2\x63\xe7\xaf\xb8\xa6\xea\x8e\xab\xb9\xe2\x1e\xc1\x8b\x57\x64\x2d\xdc\x91\xf5\x31\x7b\x04\x0c\x83\xd4\x72\x39\xca\xee\x52\xae\x2f\x38\x79\xc6\xc0\x1e\xd7\x1f\x38\x86\xe9\x6e\x4b\x25\x26\x5f\x76\xc5\xd7\xac\x8a\x7f\x4f\xdb\xd9\x90\x07\xcd\xcb\xc5\x23\x76\x39\x74\x80\x46\x35\xc6\xd4\xff\x34\x56\x7f\xdc\xde\x05\xd9\x38\xec\x43\x23\x98\x59\x6e\x6f\x10\x8f\xfc\x87\x98\x1a\xdc\x97\xda\x3e\x87\x3b\xc0\xc0\x58\xb2\xdc\x96\x72\x14\xe1\x0d\xfb\xb7\x31\xb5\x72\xce\xad\x9f\xd8\x13\xc7\x81\x0f\x4c\x2b\x97\x8d\x2a\x43\x60\xd1\x58\x5b\x64\x11\xee\xf0\x9a\xe7\x56\x37\xb2\xa7\x7b\x5e\xe1\x9d\x1e\x73\x6b\xf1\x58\x08\x85\xfc\x72\xb1\xa0\xf2\x43\xb8\x79\xac\xfd\x07\xbf\xe1\x94\x53\x0f\x23\xff\x2f\x62\xf6\x92\xd1\x18\x16\xf4\x28\xe7\x53\x70\xc8\xbe\x29\xcf\xde\x0d\x49\x7c\x94\x17\xef\xff\x2a\x66\x5f\x6a\xdf\x3b\x01\xfa\x40\x3c\x46\x58\x30\x65\x8c\xfd\x09\x46\x58\xd5\x7a\x76\xcd\x7f\x9c\xc6\x2a\x34\x1b\x8d\x79\x97\xc7\x57\x55\xe1\x7a\xd3\x71\xfc\x86\x72\xfe\xc9\xd8\xca\x27\xe4\x06\xa7\xdc\x63\xfe\x7d\x7c\x5d\x96\x09\x89\xe5\x28\xf0\xa2\x5c\x7b\x87\x58\x84\x58\xed\x6b\x8c\xab\x5c\xa6\xff\x1b\x71\xd5\x17\x76\x5a\x11\xc4\xe3\xe2\x44\x7c\x5a\xd1\x89\x7f\xdd\xc7\x8e\x92\x19\x9a\xc7\x76\x57\x89\xab\x5c\xa6\xff\xbb\x71\xd5\xc0\x22\x5c\xf9\x8c\x2b\x17\xad\x2a\x76\x6a\x70\x7f\x91\xff\xb3\x53\x07\x57\xe0\xff\xbb\xb8\x0a\xf1\xd3\xa0\x77\x39\x4f\xc3\x09\xf5\xeb\x3e\x95\x3f\xf3\x3e\xbc\x39\xe1\xb7\x77\x54\x7a\x8f\xdd\x4e\x7c\xc0\x29\x4a\x29\x03\xe7\x40\x1f\xb7\xcd\x30\x32\xf8\xec\xaa\x2d\xbc\xab\x5b\x18\x85\xcb\x6d\x18\x69\x3f\xcd\xbf\xed\x53\xf9\x1e\x74\x11\x13\x3c\xf4\xee\x8a\xab\x18\x70\x8c\x61\xfe\x56\x5c\x75\x7d\x11\xdc\x7d\xa9\x5c\x73\x9b\xe3\x8a\xab\xda\xff\x8b\xb8\xea\x0e\x8d\xd3\x85\x60\x0e\x4b\xd7\x5c\xda\xe3\x1f\xc5\x55\x71\xae\xb8\xea\x57\x7b\xfe\x6c\x9c\x3e\x76\xcb\x0b\x15\x99\x49\x42\x5f\x33\xbb\xee\xff\x22\xa6\x3a\x62\xbf\x32\x07\x1e\x87\x7e\xe5\x62\x16\x84\x56\x6c\x41\x64\x7b\x15\x0c\x20\x3e\xaf\xbb\xdc\xf6\xce\x6b\x54\xff\x2c\xa6\xfa\xd2\xfe\x74\x0e\xac\xd4\xb3\x6a\x36\x9c\xaa\xe4\x6d\xc4\xc5\xca\x63\x3c\xca\x03\xff\x96\x7f\x1e\xb3\x79\xc6\x54\x6f\xd9\xdf\x3a\xf1\x1f\x17\xd3\x2b\x33\x92\x44\x45\xc5\x0a\x91\xc9\xbc\xf8\xa7\x3e\xe7\xbe\x4e\x75\xb5\xab\xfe\x91\x57\x46\x55\x2f\xdb\x47\x9d\xd0\xa2\xb2\x72\x24\x2a\xc6\x7d\x9d\xf1\x3a\xef\x98\x8a\x62\xa1\xbf\x8e\xa9\xf6\x21\xd6\x1d\xb2\x5e\x65\x07\x6d\x3c\xe2\x6f\xa1\xe7\x3d\x31\x94\x5e\xe9\x75\xa0\xc7\xa5\x2a\xaf\x2b\x55\x9a\x2d\xcd\xd5\x21\xfb\xf9\x99\x30\x01\xfa\x96\xcb\x75\x9b\x2b\xc7\x75\xe2\xef\xea\xcd\xc2\xd5\x58\x55\x73\xa0\x62\x57\x8b\xac\x3c\xc6\xab\xb8\xaa\xc8\xea\x67\x7b\xd5\x0c\x28\x81\x8e\x18\x58\x55\x96\x76\xe2\xfb\x30\xb0\x22\x1e\xaf\x5c\xbf\xbb\x6d\x64\x18\x68\xa5\x3f\x5f\xbf\x7b\x04\xee\xaf\xce\x80\x57\xb5\x13\x8c\x84\xbb\x2a\xa7\xf5\x10\x3d\xec\x21\xbc\xd7\x7f\xc3\xf7\x74\x82\xd7\xed\xaf\x9c\xf8\x6f\xf1\x5f\x2b\x57\x23\x7c\x65\xac\xb8\x91\xf8\xef\x50\xa5\xe3\xa6\x74\xad\x52\xcf\xe1\x57\xbb\xaa\x51\x43\x60\xfd\xbc\xbd\x6f\x3a\x06\xd6\xe8\x02\xf7\x57\xae\xef\x2e\x7a\x56\x3c\x28\x4d\xb7\x5e\xbc\xe7\x06\x89\x73\xc3\xdf\x8b\xad\x36\xcd\x84\xd7\xca\xc5\xbb\x95\xcb\x3b\x89\x7e\xcb\x5d\xfb\x3a\xfe\x31\x8f\x21\xc2\xed\x10\xfb\xec\x07\x47\xe3\xec\xd7\xb3\x5c\x8e\xb6\xb3\xed\xa5\xd9\x30\x94\x97\x56\xed\x17\xa9\xbe\x76\x25\x4c\xd3\xe0\x86\xe5\x03\xf8\x85\xd2\xbe\x7f\x05\x8f\x3e\xc4\x61\x48\x9c\x48\xac\xfc\x70\x34\x7f\xa2\xbc\x5c\x7c\x5b\x79\x43\x36\x3f\x7c\xf4\xe2\x7c\x6f\xbc\xaa\x38\x40\xd1\x58\xfd\x4f\xe2\xf7\xef\xec\x03\xa3\xa1\x27\x0c\xc3\xb8\xc8\x7e\x3f\x1b\x26\xd1\x35\xb6\xfb\xfe\x43\xfc\xee\x11\x05\x7f\xe0\x70\xea\x01\xba\x42\x1b\xfb\x70\x36\xcc\xb2\xb7\x88\x5b\xbc\xf5\xdb\xa2\x3a\xbe\xd6\xd3\xa3\x52\xc2\x3b\xf0\x0a\xf1\x8c\xbc\xc0\xac\x5e\x5f\x1d\x1c\x4b\xd0\xbc\xef\x85\x3c\x98\x55\xb9\x53\xce\xad\x31\xbe\xfe\x3b\x3e\x10\x52\x1d\x5f\xf3\x07\x28\xbe\xe6\xf1\x57\xc6\xd7\x7a\xfd\xf7\xf7\xe2\xeb\xfd\x76\x5f\x18\x04\x9d\xca\xc5\xde\x4a\x5c\x15\x3d\x75\xd5\x3d\x15\x84\x76\xf5\x98\x4a\x54\x85\xae\x27\xed\xf1\xd0\x5f\x5f\x63\x69\x64\x27\x95\xf3\x42\x3d\xbc\xd4\x84\xa9\xe8\xba\xf5\x9f\x62\x7a\x84\xc3\x7b\xec\x65\x50\x1f\x57\x28\xfc\x7e\xfb\xd3\x72\xb8\x9d\xd7\xbb\x62\x4d\xa1\x83\x2a\x1f\x5f\xe0\x5c\xc7\xd7\x55\x81\x5a\xb5\xcc\x2e\x30\x1c\xb2\x3e\x76\xed\x23\xc1\x98\xaf\xdc\xfe\x45\xae\x41\xf7\xf4\x5c\x43\xb5\xa8\x8e\xaf\x40\x28\x3d\xda\x5b\x86\xb0\x3c\xa2\x88\xf5\x35\x47\xd7\x74\x95\x95\x01\xba\xfd\x8e\x8a\x04\x98\x9d\xf7\x8b\xbc\xbb\xc6\xb5\x25\xc5\x57\x88\x8c\xa2\x7b\xc6\x27\x35\xde\xa9\x41\xec\x94\x6a\x70\x7f\xb8\xb1\x5c\x0c\xad\x78\x09\xc1\x7f\x17\xfb\xd6\x5e\x76\x5d\xe1\x5f\xe1\x7b\x5c\x13\x1f\x0d\xd1\x30\x99\x22\x2c\xc4\xb7\x2f\xf2\xf9\x18\x61\xfd\x09\x7e\x4d\xf1\xd5\x5f\xe0\xa7\x41\x2f\x8c\x69\x31\x7e\x47\xfc\xfd\x90\x22\x96\x5c\x76\xcf\x2d\x00\xe3\x2b\x5e\xd3\x55\xab\xd4\xea\xe8\x8a\xc6\x01\xbb\x8d\x3d\x71\x2c\xcc\x04\xbf\x72\x98\x51\x60\xbf\x20\x5d\xf3\xe1\x00\xef\xf8\xea\x6f\xc4\xed\xba\x2b\x21\xd2\xb5\x84\xf3\x9d\xfb\x7a\x68\xf5\xfd\xc8\x3a\xe9\xbe\x7a\x5e\xd5\x77\x23\x9d\xd1\x90\x57\x1f\x72\x47\x56\xbf\xd8\x53\x17\xc2\x1b\x3a\xb2\xba\x64\x26\xa8\xc1\x97\x5d\xef\x73\x8f\x75\x14\xfb\x98\x02\x27\x26\xe9\x8a\x4c\xaa\xee\x98\x7a\xe8\xac\x71\xf5\xdc\x71\xc1\xbe\x6b\x1e\xac\xd2\x73\xc7\x5d\x17\x2f\xcd\x69\xa5\x06\xdb\x9b\xa0\x7d\xcd\xf7\x62\xd5\xd5\x90\x53\x6b\x9c\x4e\xbf\xb5\x5f\x9c\x4f\xc8\xbc\x37\x9c\xb8\xf4\x05\x42\x57\xee\xc6\x51\xa4\xc6\xfb\xd3\x7f\x07\xdb\x73\x2a\xfd\xd4\x7e\x6a\x1e\x7c\x85\xd8\xff\x13\xc1\x15\x3e\x89\x6a\x40\xc5\x7e\xd1\xb8\x86\xfb\xe9\xae\x6b\x54\x7f\x7a\x3f\xdd\x03\x76\x8d\xfd\xe6\x5c\xf8\xc2\x75\x5d\xb8\xb5\xba\xde\x1d\x4b\x35\xf7\xbe\xe7\xa7\xaf\x4f\xe9\xf8\xcc\x69\xf2\xab\xdd\xf3\x5b\x08\x1f\x13\x0e\x19\xeb\xb2\xbd\x07\xae\x38\xca\x15\x45\x25\xd7\x18\x43\xed\xb2\x07\xcf\x87\x35\x7a\xca\x5c\xb7\xa7\x22\xbc\x9d\x14\xd0\x83\xd5\xb8\x2f\x42\xd1\xbe\x08\x44\xf3\x71\xb1\x73\xd5\xf8\xe9\xac\x9d\x3b\x1b\xde\x82\xc1\x18\x3f\x55\x44\x27\xc9\x54\x77\xfc\x74\xc5\xfe\x90\xea\xb9\xcd\x0b\xf7\x4f\xae\x4b\x1d\xb1\xef\x9e\x03\x1f\x62\x84\xce\xa7\x61\x84\x3e\x37\x49\xf6\xb4\x57\xf1\x61\x35\x62\x93\xad\x75\xe0\x24\xaa\xb0\xaf\xdc\x7b\xe2\x69\xed\xbd\xf6\xe3\xf3\x60\x2f\x24\x97\x7f\xc6\x27\x55\x7c\x95\x22\xd3\x2b\x17\xe2\x72\xd5\x6b\xbf\x8c\x47\xec\xfc\x57\xf7\x01\xbc\xec\xfd\xee\x8d\xf0\xa9\xb6\x77\x5c\xc5\x81\x24\x39\xb2\xe2\x80\x8c\xaa\x71\x7f\x87\x9e\x33\x39\x37\x85\x73\xc0\xb8\x72\x4f\x8f\x3b\x6a\x5a\x33\x07\x3e\xc5\x35\x4a\x45\x79\x92\xfc\x64\x31\xbb\x72\x8f\x91\x33\x0e\xff\x53\xdf\xd1\xab\xfc\x7b\x67\xf2\x63\xe5\x72\xe2\xa5\x47\x32\x54\xa7\x9a\xf7\x3e\xa1\x0e\x39\xf7\x30\xcd\x65\x57\xa2\xaa\x44\xfc\xc3\x9e\x32\x03\x56\xc0\x84\x72\xf1\xe6\x85\xca\xee\xdd\xf9\x17\x90\xad\x8f\x44\xa8\x69\x8f\x96\x72\xed\xef\xbb\xaa\x1f\x79\x44\x48\x7f\xd8\x8f\x95\x41\x39\x8c\xc0\x08\xa9\x32\xb7\x27\xdf\xef\xda\xa3\x95\xf2\xdf\xfd\x68\x87\xbd\x7c\x32\x06\xc9\x7d\xcb\x21\x16\x5a\x55\xbe\xd9\x87\x1f\xb1\x57\x89\x27\xbd\xf6\xc0\xfd\x6b\x5b\x3b\x81\x79\x83\xca\x43\xfd\xf9\x91\xca\x3d\x72\x76\x8d\xfb\xb7\xfe\xda\xd6\xce\x21\x7d\x4d\x29\xbc\x4f\x60\x3d\xf9\x61\x7d\xdb\xf8\xf2\xfd\x83\xce\x3e\xce\x39\x0e\xeb\x56\x0d\xb6\xae\x0a\x8d\xbf\xb7\x07\x8d\x82\x7b\x61\x64\x39\x2e\x3a\x1f\xb3\x27\xe5\xc1\x0d\x24\xef\x15\xfb\x1b\xb5\x7d\xfe\xc4\xe6\x84\x47\xf3\xf8\xb7\x76\xbf\xc1\xf0\xa8\xf6\xea\x02\x3b\xd1\xce\x9f\x0c\xb7\xf2\x67\x8e\xd7\xbc\xff\x52\x5f\x6b\xfd\x2b\x59\xb5\x43\xce\x1d\xc7\x7f\x28\xe7\x25\x95\xcb\xc6\xf2\x2d\xbc\x37\xab\x71\x7f\xe8\x5f\x8e\x43\x1e\xfe\xb3\xc5\x7e\x77\x02\x4c\x83\x29\x18\x1d\xd9\xab\xb3\xa0\xd4\x75\xcf\xb1\x5f\x4d\x7b\x36\x04\xa0\x91\xbd\x6e\x3c\x26\x57\x5d\x63\xb9\xc2\xc6\xeb\xc6\x90\xe4\x18\x00\xec\xca\x82\x5b\xed\x2d\x72\x23\xab\x71\x2f\xe6\xdf\x90\x9b\x6c\x3c\x0a\x56\x96\x43\x33\x7b\x5f\x0e\x2c\x10\x8f\x5f\x76\xbd\x95\xf6\xe8\x39\xef\x41\x83\xe4\x5c\x59\x4a\x56\x47\x70\x5e\xf1\x1b\xb8\xe3\x60\x5c\x5a\xdc\x07\x81\xb0\xb0\x5c\x7c\x50\x91\x51\x4e\x7b\x8a\x6a\xbc\x2e\x4c\x78\x3e\x4a\xfa\x78\xe1\x5d\x1e\xb5\xa6\x54\x41\x06\xeb\x9b\x0d\x4d\x2a\xbe\x29\x97\xcd\xbf\xf2\xc2\xf4\xba\xdf\x5c\x33\x6a\x64\x8d\xb1\xf0\x0f\xf6\x62\xa8\x07\xa5\xe5\x3c\xa3\xf2\x83\x72\x7e\x86\x1b\x57\xdd\x17\xf2\xf7\x78\xad\x8e\xb0\x93\x61\x4c\x39\xb4\xb0\xf7\x94\xc3\x18\x52\x29\x03\xbb\x9d\x2c\x87\xcf\xd5\x38\xe6\xa7\xcf\x58\xb1\x2c\xa6\x2f\xdd\xe9\x8d\xf1\xfa\x94\x14\x1d\x55\x9b\xf4\xa8\x18\xfd\xc2\xe7\xa3\x9a\x26\xee\x49\x6c\x86\xbf\x4d\x47\xa9\x71\x7b\x8b\xf0\xdf\x5e\xe7\xbe\xf8\xcf\x69\x5f\xbc\xde\x5f\xef\xff\xa6\x60\x96\xe9\xda\x17\xef\xdc\x57\xaf\x99\xa8\x7b\xfb\x43\xc7\x78\xb7\xca\xc7\x78\x8e\x73\x4b\xbd\xfd\x84\xde\x1e\x5f\x43\x5d\xc3\xc7\x55\xd7\xf9\xdc\x80\xd2\x4f\x1e\xe8\x67\x06\xec\x37\xf5\x1e\x77\xe7\x23\x03\xfb\x5c\x75\xdd\x7b\xeb\xf5\x33\xb3\xc8\xbd\xbf\x7f\x70\xdd\xda\xc1\x8c\x25\x26\x6d\xd1\x4f\x09\x20\xf7\x61\x35\x6e\x97\x0f\x23\xe4\xf9\x57\xd9\x2d\x3f\x18\x1b\x53\x6f\x79\xef\x97\x87\x19\xba\x59\x6c\x53\x78\xb4\xa9\x4f\x09\xae\x9b\xee\xa7\x9b\x8d\x8a\x8e\x8e\xa9\xeb\x6a\xd9\x79\xb2\xcd\x55\x1b\x6f\xe7\x7a\x72\xe1\x6a\xcd\xf7\x72\x3e\xc7\x70\x39\x07\x07\x9d\x0f\x49\x70\xfb\x82\xba\x08\xc3\xe9\x79\x02\xad\x2f\x1f\x10\xa8\xeb\x6f\x93\xd6\xa3\xae\x11\xb4\x41\x04\xc4\xa5\x84\x4d\x5c\xb1\x02\x3e\xb2\x5f\x79\xe8\x8c\x71\xff\xd2\x60\xfb\x50\x20\xc4\x79\x3d\xbb\xe0\xaf\x75\xe5\xeb\xeb\x0f\xc2\xdf\x72\x1e\x3d\x53\x75\x62\x53\xa4\xfb\x71\x8a\xeb\x57\xac\xe8\xee\x7c\x92\x02\x31\xf6\xb9\x9f\xa3\xb8\xfc\x79\x11\x7d\xec\x96\xb0\xfc\x08\xc4\xe9\x2d\x2e\xe1\xcc\xcb\x9f\x17\x41\x94\xa5\x4b\x8f\xdd\x89\x7e\x8c\x61\x0f\x8f\xa3\xf3\x00\x93\xd2\x6b\xfb\x81\x8f\x0f\xae\xe6\x2c\xff\x00\xd3\x8f\xf9\x0d\xd4\x87\xfa\xfa\xf0\x20\x1f\xef\x93\x7c\xab\xce\xef\xad\x3e\xb8\x57\x1f\xc2\x52\x6b\x36\x44\xcd\x99\x63\x1f\x9b\xcd\x97\xc0\xf3\xf6\x88\xcd\x76\x2a\x6c\xd4\xcf\xbe\x3b\x8e\xcb\x3d\x66\xa7\xd0\x26\x22\x5b\x9f\xaf\x61\x3e\xc9\x7e\x83\x69\x21\x26\x5f\xc4\x4e\x3a\xce\xe1\xdc\x10\x2c\x78\xb2\x4c\x35\x52\xdb\x1b\x61\x8d\x65\xfb\xf6\x21\x4d\x58\x7c\x48\x0a\xe0\x2f\x4b\x4c\x49\xa9\xa1\xfe\x4a\xe8\xed\x51\xbf\x9e\xae\x9f\x44\xf5\xdc\x20\xba\x2a\xfe\x62\x6d\xe7\xb3\xf7\x97\xd5\x7f\x95\xfd\xf8\x9f\xda\x7f\x0d\xd2\xff\x45\xfb\x2b\xdd\xf5\xf9\xa3\x70\x8d\xe3\xf7\x10\xd3\x7c\x12\x24\xec\xd1\xed\x4b\xd1\x85\x37\x8b\x6d\xd6\x1a\xab\xf2\xc6\x8d\xaf\xd2\xfe\x95\xf5\xb5\x1e\xfe\x4b\x7d\xad\x87\xff\x52\xff\xb5\xea\xf6\xd3\xff\xa4\xbe\xe3\x6b\xf4\xaf\x4c\xb3\x33\xd6\x9f\x6c\x93\xfd\x1d\x5f\x43\x49\x88\xc1\x17\x7d\x71\x5e\xd7\xe6\x50\x5b\xd4\xf5\xaf\x5b\x4f\xaa\xc6\x22\x3a\xda\xbb\x36\x3d\xa7\xa5\x5f\x64\x74\x8b\x47\xfd\x95\x38\x48\x7a\xd5\x8f\x14\x31\xfe\x31\xd1\x57\xad\xbf\x01\xeb\x0f\xf2\xa8\xff\xaa\x63\xc3\xe5\xed\xff\x69\xfd\xcb\xdb\x7f\xed\x1f\xb6\xbf\x1a\xeb\xcf\x22\xfd\xe9\xfa\x4d\xf8\xa3\x27\xc8\xfa\xc8\xc5\x1e\xa7\xf7\x35\x81\x00\x1e\x10\x81\xf5\xc1\xd7\xf7\x2a\xf5\x6f\xa9\xaa\xef\x94\x7f\x0f\xb6\x8f\x38\xb8\xea\x0e\xc1\xf6\xc3\x45\x0c\x8f\x69\xa2\x19\xa8\x5b\xd7\x13\x20\x84\xf4\xef\xdd\xbe\x96\xff\xfd\xaa\xfa\x6e\xf9\x6b\xac\x5e\x23\xff\x28\xbf\xe3\x84\x77\xfd\xc8\x3f\xad\xcf\xe6\xa3\xff\x0c\xa1\xfe\x33\xd3\xd5\xff\xcf\xb9\xfa\xcf\x77\x8e\xf3\xac\xc1\x6a\x0e\xb1\xa2\xc5\x1a\xc7\x96\x74\xdf\x16\xcd\x99\xd9\x58\x34\x6f\x7e\x19\x48\x0d\x18\x2b\xa1\xe1\x7f\xc6\xa8\x1e\x07\xfe\x3d\xc6\x6b\xff\x9a\x8f\x95\x6e\x0c\xec\x4f\x41\xce\xf1\x80\x5d\x44\x8f\x68\xb0\x5a\xf0\x04\x88\x5a\xe3\xf8\x32\xdd\x37\xaa\x01\x62\x40\xad\x5a\x7f\x89\x81\xfa\x08\x44\x9b\x98\x4e\xac\x6a\x3e\x10\xa3\x45\x92\xe6\xa3\x69\xd3\xbf\xc6\x78\x95\x7d\xeb\x81\x11\xf7\x97\x18\x6d\x5a\x33\x56\x13\xce\x6b\x5e\xbc\xd4\x59\x75\x55\x10\xf4\xad\xdd\xe8\x5b\xe3\xcd\x63\xee\xbe\xc1\x26\x6d\x38\x88\x08\x9f\x38\x16\x70\xa1\xb5\xea\x58\xcb\x2e\xe0\x8c\x1e\xc4\x21\xd0\x08\x0c\x40\x0f\xe3\x55\x5d\x84\x10\xb4\x1c\x35\x63\x88\x54\x7d\xdf\xf0\x6f\x63\xbc\x83\x18\x73\x2e\xc7\xe0\x8f\x3a\x7e\x63\x15\x68\x99\x4f\x1c\xb3\xb8\x60\x29\xe9\x0d\xab\x30\xe4\xf2\x86\x30\xbf\x21\x34\x4c\xf7\x0b\xec\x19\xd4\x10\xf0\x7f\x43\x0f\xd8\x90\xcc\x4c\x7d\xd0\x90\x13\x9d\xfd\x25\x3e\xf2\x1a\x80\xf8\x4d\xd3\x23\xab\xf1\x07\xd4\x04\x5a\xc5\xaf\x4b\xe7\xc7\xdc\x3a\x67\x93\xd8\x61\x07\x69\x8e\x3d\xe1\x94\x9a\x1d\x44\xa9\x63\xde\xe0\x50\x67\x8d\x63\x5b\xba\x5f\x9d\x28\x54\x3e\xaf\x72\x25\x27\xd0\xd5\x71\x44\x2a\xd4\xff\x8f\x38\xdf\x39\x48\x42\xf0\x73\x6a\x90\xdd\x8f\x12\xba\x70\xb6\xfc\x6b\x1c\xe4\x2b\xfe\xef\xe1\xa0\xbe\xe7\x9a\xbd\x42\x9b\xe8\xab\xa9\x21\x86\x65\x37\x4b\x62\xb5\xd2\x71\x98\x0d\x08\x69\xc2\x7d\x26\xf8\xf8\x2b\xd3\x3d\x4d\xd3\x3a\xe6\x71\x7b\xb8\xd2\xe7\xed\xd6\x63\x19\xe9\x8d\x6a\x85\x86\x86\xf9\xb2\x30\xc9\x44\x4c\x74\xad\x5a\x61\xe1\x5c\x8d\x1b\xc9\x4d\xfc\x0d\x0b\x17\x61\xa1\x51\x81\xe3\x46\x46\xb9\x8e\xda\x4d\x0b\xae\x3a\xcb\x3e\xc4\xf3\x68\x64\x15\xdc\xa0\x61\xd3\x14\x3a\x19\x2e\xc4\x75\xfe\xa8\x7e\xf5\x82\x3e\xc0\x86\x45\xa8\x7c\xbb\x68\xc4\x94\x01\xad\x73\x06\xdc\xf7\xc2\xc3\xab\xed\x03\x10\xdc\xf5\xe0\xdd\xa7\xa1\x5e\xa8\x5d\x10\xb6\xc3\xaf\x78\xbe\xc8\x7c\xea\x9e\xc7\x17\x56\xe0\x12\xed\xd9\xd1\xe3\xed\xdf\x7e\xd6\xfc\xe9\x33\xf7\x3b\xe1\x5a\x23\x92\x75\x4f\x6f\x14\xe4\xef\x1f\x10\x6a\x59\x11\x01\x22\x42\x44\xd5\xf6\xf1\x09\x0c\x0e\x0e\x08\x64\x22\x6b\x24\x93\xf8\x1b\x10\x16\x28\x02\xf4\xe1\xad\xc9\x1e\xcc\xa5\x7a\xf2\x47\x71\x21\xf2\x17\x99\x74\x4d\x27\x80\x5a\xc4\x1b\xe8\x83\xf6\x43\xc2\x0d\x19\x93\xd3\x3d\xb9\x67\x4a\xe5\xc8\x50\xfb\x22\x5c\xcf\x8b\x42\xc1\xb8\xcf\x1e\xee\xf3\x99\x4c\xcb\x4e\x92\x3d\x9e\x18\x5f\xb1\x56\x2d\xac\xf0\x79\xf8\x46\x7e\xe4\x82\x63\xf1\xa3\x4e\xdd\x39\xce\x90\xee\x62\x58\x8f\xf4\x38\x16\x13\x18\x13\x1a\x64\xd4\xae\x1d\x14\x5b\x3f\x34\x34\x38\x28\x28\x38\x06\xe3\x70\x11\xe1\x3b\x6e\x64\x84\xac\x2b\xc6\x8d\xac\x1b\xe6\x7d\x84\xb2\xf7\x11\xcf\xae\x03\x2c\xe9\x64\x84\x4e\xce\xa3\x5b\xa3\xc1\xa5\xba\xd8\x10\x3a\xba\xb5\x51\x53\xf8\xc4\xef\xa1\xe5\x8f\x3f\x7f\xef\x8b\x55\xda\xe3\x81\xf6\xe7\xf6\x36\xfb\x90\xbd\xc9\x17\x8e\x2e\x5a\x70\xf1\xc4\x8c\xaf\x9e\x7b\x7c\xe1\x2e\xbe\x01\x35\x58\xb9\xac\xd8\x7e\xdc\x7e\xb0\xe2\xbc\x8e\xd5\x0f\xb1\x89\xd0\x40\x14\x32\x5f\x8c\x7a\xc3\x56\x05\x5a\xef\x43\x6b\x16\xce\x04\x24\x31\x7d\x34\xa2\xf3\x54\xbf\xd8\x90\x2b\xce\x9f\x81\x06\xf7\x2e\xb1\xbf\x5b\xf4\xc8\xfd\x8b\xde\x6a\xd5\x29\x2d\x31\xb1\x53\xa7\x44\xf8\xe5\xc3\x8d\x70\xcb\xa6\xf7\x3f\x5e\xbf\xb8\x70\xca\x7d\xf7\x4d\x2e\xd6\xba\x70\x5c\xc7\xa6\xb1\xf7\x31\x4e\x32\x58\xe4\x9b\x9c\x4b\xf6\x3e\xe8\xb7\x6b\x4a\x48\xd4\xf8\xa1\xfa\x39\x69\x7a\x95\x48\x72\x88\xb1\x76\xfb\x33\xd3\xf8\xa8\xa9\x77\xce\xa9\x0c\xc4\x35\xdf\xb7\xac\x04\x1a\x23\x5f\x75\x59\xc4\x1b\x7e\x3e\x41\x9a\x2d\x7d\xed\xad\x8d\x3e\xfe\x50\x87\xd9\x8d\x53\x3a\x43\x3b\xfd\x7e\x38\x7d\xce\x82\xeb\x9d\x37\x81\x60\xe2\xff\x06\x11\xf6\xb7\xd1\x93\x26\x65\x25\x8f\x1f\x15\xfc\x76\xc8\x92\x1b\xcb\xef\x6d\xd1\x77\x5c\xcb\x81\xe1\x50\x52\x32\xed\xda\xd2\x81\xbd\xbb\xd7\x1f\x96\x6b\x95\x94\x4e\x9b\xd8\x66\xc8\x80\xeb\x62\xd3\x63\x17\xd1\x1a\x73\x27\xcb\x83\x56\xd8\x5e\x43\x56\xff\xed\xc0\xa0\x20\x51\x3b\xa2\xde\x1a\x68\xfd\x86\xe9\x23\xd6\x90\x2e\xf4\x39\x91\xa1\xb4\x08\x71\x9e\x73\xd8\xb4\x1d\xaa\x21\xa5\x6d\x3c\xae\xb2\xf1\x0f\x2d\xa2\xdc\x6c\x98\xb5\xa0\xd5\x03\xf7\xdf\xb6\x22\xe0\x9d\xa0\x29\xc5\xf7\x76\x4d\x5b\x98\xdc\xa6\x55\xaa\x7c\x2b\xe8\x91\x1b\x6e\x7e\xf0\xb6\x47\xa0\x47\xfe\xec\xd9\x53\x83\x26\x8d\x1b\xbd\x68\x64\xf3\x84\xa4\xc4\x80\xfc\xb2\xc2\x71\xf3\x5b\x35\x40\x5b\x7c\x80\x32\x67\xa0\xae\x7c\x59\x30\x6b\xa2\x9f\x2c\xe7\x4c\x4a\x2b\x28\xc8\xe0\x5a\x6b\x01\xcc\xa8\xd2\x9a\xeb\xf5\x26\xb8\xda\x88\x88\x4b\xd1\xc7\xc3\xe2\x8a\x03\x52\xda\x19\x66\xf2\xbe\x57\x70\xbd\x3f\x6a\xdd\x14\xfb\x18\xd4\x5e\xb3\x0d\xcc\x07\x1f\x9c\x03\xdf\xdb\x8d\x17\xc2\xc4\xd8\x7a\x71\x0e\xe7\x7a\x7a\x07\xda\x3c\x11\xdb\xa9\xcb\x1a\xa6\xfb\x06\x45\x86\x9a\x22\x2a\x4a\xd4\x0a\x7b\x1f\xe1\x7d\xaa\x4c\x8f\xad\x44\xa6\x7a\x8b\x7b\x0d\x09\x6a\xc6\x85\xe1\xd2\xc9\xa4\x17\xc6\x25\x3e\x77\xf7\xdc\x47\xc2\x56\x87\x67\xb7\xef\xda\x39\xb5\x53\xab\x97\x62\xe0\x77\xfb\xd5\x80\x0e\xfd\x66\xdf\x03\xc5\x73\xee\x99\x52\x10\x38\x2a\xbd\xd3\x35\x69\x89\xf0\xfa\xc2\x65\x8d\x9d\xcf\x9a\xef\xc7\xb6\x9b\xa0\x9e\x23\x58\x03\xd6\x08\x27\xf4\x10\x11\xe0\x13\x16\x26\x82\x7c\xb4\x85\xeb\x7b\xb6\x1e\x9a\x1a\x5a\xdd\xbe\xeb\xe5\x46\xfa\xa0\x6e\xf3\x0a\x5f\x6c\xf2\xe0\xad\x0f\x3c\xbe\xe2\xa1\x9c\x85\xd1\xaf\x44\x64\xcc\xf0\xed\x58\x50\x7c\xcb\x5b\xed\xda\xb5\xe9\xd0\x29\x39\xa9\x1d\x4c\x9e\xbd\xe8\xbd\x35\x9b\xbf\x18\x9a\x17\xd1\x6b\x63\xe7\x9b\xcb\xda\xa5\xb7\x4f\xbc\xb6\x7f\x3a\xe9\xe1\x30\xea\x3b\x1a\xf5\xe0\xcf\x42\x3e\x60\x0a\x55\xec\xcb\xfc\x9c\x2a\xc6\x66\x03\x79\x44\x5c\x5b\xf4\x31\x7d\x75\x22\x7a\xe6\xf8\xa4\x0f\x93\xb3\xe7\xda\xb3\x79\x07\xfe\xc3\x0b\x6b\x56\x8d\xcd\x7a\x65\xd5\x73\x8b\xf4\x5a\x7b\x17\xca\x13\x8f\xf2\x44\xb2\x58\xd6\x1c\xf5\xe9\x13\xe1\xe3\x13\x17\x13\x23\xea\x90\xcb\x36\xf5\x14\xc8\xfd\x06\x4c\xf7\xcb\xae\xdc\xaf\x6c\x72\x1f\xfc\x14\xd7\x30\x22\x1c\xc5\x09\x73\x27\x20\xfe\xb1\xc5\xf7\x3c\xd1\xb7\x63\x6a\xc7\xbb\xef\xbc\x7d\x49\xa7\x76\x9d\x7b\x6f\x1d\x3f\x6e\x7c\xeb\xc4\xb0\xb2\xa2\xd2\x2e\x89\xd0\x67\xea\xcc\x19\x53\xba\x66\x85\x45\x8c\x68\x37\xa6\x68\x52\x76\xca\xc8\x88\x90\x91\x60\x8c\x1a\x35\xbe\x95\xfd\x5b\xc1\xe4\xd2\x74\xe7\xf5\x87\x6f\x5c\xfa\x0e\x47\xfe\x50\xdf\x31\xa6\xf0\x0b\x0b\x08\x10\xb5\xc3\x34\x7b\x3e\x57\xd5\x37\xd9\xbb\x9d\x5b\xf3\xb1\xc2\x4b\xdd\x2b\x1f\x9a\xba\xa0\xde\xcb\xb5\x7b\xcc\xf4\x6f\x5f\x5c\x74\xd3\xd2\xbb\xa0\xd9\x47\x69\xad\xdb\xb4\x4b\x49\x6e\x9d\x06\xbf\x7f\xf1\xd9\xa8\xdc\x5a\xfd\x3f\xe9\x7c\xc7\xf4\x1b\x6e\xb3\x4f\x76\xe9\xdd\x35\x35\xa5\xc7\xb5\x4e\x5e\xde\x51\x6f\x73\xe7\x39\x0c\x41\xb8\x32\xf7\x0d\x0c\x94\xe0\x5a\xde\x3b\x3b\x96\x5e\xd9\xa7\x44\xba\x0e\xfe\x09\x4b\x86\xf6\x5f\xff\x30\xbe\xac\x60\x3f\x3f\x98\xff\xdd\x16\x33\xde\xff\x75\xdf\xd7\xc2\x5f\x78\x21\x9c\xce\x00\xae\xfc\x55\xbd\x0d\x3d\xab\xb0\xfc\x0d\x83\xab\x40\xdf\x6a\x2c\x11\x41\xd7\x08\x92\xc3\x5c\x68\x5f\x8d\xff\xe1\xeb\xdd\x5b\xbe\xcb\x3f\xc8\xf7\x17\x18\xb3\x7d\x5f\xf7\x1f\x6c\x9f\xd6\x60\x6e\xbe\xe0\x63\xc4\x0a\x66\x75\x58\x74\xba\x7f\x64\x98\xe4\x11\x51\x51\xfe\xdc\xf4\x0f\xab\xba\xf8\x10\xfc\x65\xf0\x7a\x7d\x76\xb6\xeb\x58\x17\xfd\xf6\x2f\x7d\xac\x8b\x59\xcd\xed\x90\x6b\x93\x9b\x85\x77\xe8\xb6\xb4\xdb\x35\x9d\xfa\x84\xb8\xb8\x36\xd6\xc7\x05\xa7\x87\x8f\x6f\xd9\x3e\xb2\xff\xae\x2a\xde\xed\x75\xd8\x9e\xf3\xfa\x4c\xac\x3e\x35\x2a\xd8\x62\xac\x76\xbd\xf4\xc0\xf0\x9e\xf5\xea\x85\x49\xff\x74\x9f\xb0\x9e\xfe\x75\x62\x75\xcb\xf1\x49\x49\xc9\x89\xf1\xc9\xda\x75\xae\x76\xad\x26\x08\xf4\x79\x3c\xa8\xb4\xab\x5d\xac\xf9\xf0\xe1\x65\xdb\x3f\xfd\x6a\x99\x51\xe0\x7d\xb1\xa6\xb8\x9b\xff\xdd\x8b\x7d\x9d\x76\xd9\x88\xfc\xa4\x92\x2e\xc3\x58\xf8\x3b\xc1\x3e\x3e\x01\x12\x02\x0c\xcf\xeb\x2e\x4e\xcb\x78\x1d\xd1\x13\xf7\xc3\x81\x9b\x46\x2e\x7c\x26\x74\x72\xc8\xa4\x21\x43\xf2\x43\x26\xd7\x7a\x0a\x4d\xb4\xc4\xf7\xfb\x5b\xcb\x32\xda\xb5\xef\x36\x6b\x61\x8d\xb8\x5c\x79\xe3\x92\x95\xc2\xbc\x70\xc7\xdc\x74\xe0\x87\x58\x2f\x5c\xe3\x61\xdf\x25\xfe\xf6\xa2\x2a\x60\x2f\x9e\x03\x58\xb4\xb6\x59\xdd\x88\xd0\x60\x5f\x21\xcc\xe0\x08\xb3\xfa\xe2\x9a\xd3\x66\xc2\x0b\x5e\x78\x58\x10\x07\xef\x24\xf0\x6a\x2a\xdb\x65\xc3\xde\xbd\xe2\xfa\xa8\xb7\xdd\x2d\x42\x20\x59\xb1\x75\xdb\x76\xee\x6b\x7a\x4e\xfb\xf9\xb1\x46\xac\x71\x7a\x70\x6c\x78\x6d\x4b\xf8\x47\x0b\xfc\x31\x42\x6a\x1b\xee\xf6\x9d\x9b\x48\x92\x83\xb7\x92\xed\xaa\xcf\x12\x6b\x47\xc7\x38\x79\x9f\xe2\xc4\x21\xef\xd6\xc0\xa1\xd1\x77\xdc\x1e\x3d\x34\x62\x61\x54\x5c\x46\x97\x4e\x75\xaf\x0f\x19\x8d\xd6\x4b\x6f\xd4\x3d\xfd\xda\x3a\xda\x94\x7e\x2d\xfa\xaa\xb7\x27\x65\x0e\x1e\x9c\x93\xbd\x3f\xac\x56\x58\xc7\x2e\xa9\xb1\xf8\xa7\x7e\x74\xfa\xb5\xf5\x35\x4f\xf7\xca\xe5\x3c\xd5\x68\x42\xfd\x21\xf8\x2d\xaf\xae\x75\x79\xcf\x82\x64\x18\xff\xf5\x97\x65\x37\x54\x1d\xab\xd5\x04\xbb\xd6\xbb\xf5\x3e\xf9\xa4\x1e\x74\xd6\xf2\x55\x6e\x95\xcb\x61\x46\x15\x96\x57\xd7\xaa\xee\x59\xee\x03\xba\x4e\x95\x7d\xf9\xf5\xcf\x47\x81\x3b\x8f\xd1\x2a\xc3\xae\xd5\xca\x5e\xa7\xc1\x9c\xba\x42\xbe\xc0\x36\xa6\xb3\x10\x7d\x2d\x32\x3d\x20\xb0\x76\xb8\xe4\xb5\xea\xd4\xd1\x9d\x2b\xdc\xab\x73\x6d\xf1\xee\x5d\xfa\xd0\xa4\xce\x20\xaa\x59\x9e\xd9\xb7\x53\x4a\x9d\xee\x23\x3f\xe9\xda\x6b\x74\x8b\x14\xc3\xcd\xbb\x3a\xdb\x32\x6c\x60\xed\xe2\xd6\xd7\xf9\x34\x19\xcb\x43\xed\x9f\x5c\x52\x70\x7b\x91\x7c\x10\xca\xcc\x20\x7a\x67\x01\xda\x28\x22\xc0\x87\xc5\xd6\x61\xa1\x75\xf0\x47\x05\x34\x8c\x71\x1d\xd4\xe4\x32\xd1\x7a\xed\x27\x61\x35\x1d\xaf\xc5\x55\x95\xa0\x0f\x37\x1b\xd8\x37\xa3\x6e\xe3\xe6\xbe\x37\x5a\xf1\x43\x32\x9a\x0f\xea\xd3\xad\x4e\xcb\x46\x3e\x37\xa8\x96\x43\xec\x55\x4e\xf9\x77\x2e\xc7\xda\xcd\xe3\x12\xd3\xf3\x26\x5e\xdb\xb0\x45\xc3\x0e\x6d\x27\x14\x74\xba\xc6\xfe\xae\xde\xca\x95\xf5\x48\x17\x74\x56\x93\x19\xab\xcf\x4f\x66\x91\xe9\x3e\xbe\x22\x50\x04\x9a\x21\x4e\x87\x25\x7f\x49\xbe\xdc\x5b\x21\x05\xe7\x5a\x05\x0f\x7f\xe4\xf7\x54\x70\x7e\x8f\x1e\x05\x81\x4f\x87\xbe\xeb\x60\x2f\x03\xb7\x8f\xc9\xe5\x6f\xdf\xdd\x6f\xe4\xf0\x01\x0f\xbc\x06\x13\xeb\x32\x47\x13\xe7\x19\xf9\xff\xa2\x0d\xe1\x3c\xe7\xcd\xab\x8d\x5d\x18\x3e\xf0\x97\x3d\x9b\x38\xdb\xc4\x51\x57\xe3\x3f\x81\xf8\x13\xcc\xce\x88\x5f\x9f\xc5\xa5\x07\xe9\x5e\x17\x5d\x57\xe0\x8f\x67\xd7\x73\xeb\xf5\xcb\xab\xf6\xbe\x5a\x2e\x13\x27\x71\xaf\x76\x07\xde\xdf\xb6\xbd\x5f\xbb\xe2\xbb\x1f\x18\x31\xf6\xa1\x7b\x3c\x9a\xff\xa3\xb3\x95\xe7\x37\xa0\x57\x4a\x4f\xb3\xe3\xac\x6a\x39\x27\x52\xff\x6f\xaa\xf9\x88\xab\x1b\x19\xe8\x2b\xcc\xc0\xd8\x58\x33\xac\xae\xe7\x10\xb0\x25\xc9\x69\x5d\x6f\x3e\x6a\xb6\x35\x3c\xf2\x01\xf2\x32\xe9\x3a\x7d\xe8\x58\xe8\x1a\x79\x55\x7b\xcb\xe5\xaf\x2e\xea\x8f\xff\xee\x7b\x1e\x6e\xb9\xdc\xde\x7a\x6d\x3b\xd9\xf3\x3c\xdc\xe0\x26\xf2\xd4\xfb\xce\xd3\x60\x77\xe3\x2c\x1c\x9a\xee\xc7\xcb\xea\x41\x46\x3d\x68\x5b\x0f\xea\x39\xcf\x80\xbd\xb2\x8e\xa1\xeb\xb0\x9a\xce\xe5\xfd\x0d\x16\x8a\xde\x97\xe7\x23\xfa\x4f\xb0\x54\xc4\xb3\x90\x74\x1f\x0e\x2b\xfc\x61\xa0\x3f\xf8\xd3\x29\xb6\xb4\x36\x1e\x68\xcf\xd7\x67\xa7\x86\x36\xb1\xce\x10\xc6\xcf\x7c\x35\xab\x29\xff\x57\xbe\xd2\x95\xff\xb4\x57\xfe\x09\xfe\x7c\x8d\xe7\x65\xff\x9f\x9d\xcf\xcc\x0c\xbb\x93\x3d\x1f\x16\x38\x7e\x75\xbd\xfb\x37\x91\x5d\xcb\xd2\x58\xbb\xf4\x7a\x75\x1b\x34\xc0\x75\x1b\x4b\x85\xf4\xd4\x15\xa9\x3c\xb5\x69\x44\x50\x50\x53\x1f\x21\x9a\x76\xee\xdc\xaa\xa9\xbe\x05\x84\x7e\xa6\x0f\xdb\xd7\x86\xce\x9c\x96\x94\x94\x98\x94\x98\xdc\xba\x8d\x72\x87\x55\x18\xbe\xb4\xf3\x48\x9b\x1e\xe9\xc6\x57\xc9\x37\xd1\x71\xed\x4e\x09\xb1\x0d\x13\x12\x1a\xc6\x26\x1c\x75\x27\x4a\x5a\xc5\xc6\xb5\x6a\x15\x17\xdb\x8a\x27\xb9\xb3\x78\xeb\xd8\xd8\xd6\x89\x0d\x1a\x26\x7c\x56\x38\x5e\xbf\xd3\xd7\x99\x4b\x7f\x5f\xa3\x74\xeb\xd6\x27\x5d\x79\xf8\x59\x17\x4e\x68\x04\xa3\xed\x67\xb4\xbc\xd2\x2e\x40\x79\xe7\xa0\xbc\x02\xc7\x58\x7d\x97\xa6\x79\x7a\x84\xe0\xdc\xac\x5f\x3f\x8c\x45\x41\x7a\xd4\x8a\x28\x1e\x65\xc6\xc4\x04\xd0\x21\x55\x89\x2e\xe1\xb4\x43\xa3\x74\x29\x0d\x22\x3c\xb9\x8f\xb8\x9c\xfb\x02\xe8\x01\x2d\x91\xd7\xc4\x44\xcd\xb3\x8b\xef\x4d\x85\x2b\xa7\x4e\x4d\x77\xf3\x83\xbc\x69\x3e\x6b\xe0\xc7\xc4\x71\x03\x7b\x36\x6b\x93\x1e\x05\x86\x61\x2e\x90\xd2\x2f\x2e\x2e\x92\x45\x43\x7a\xf4\x8a\x68\x1e\xed\xd7\xb0\x61\x88\xdf\x65\x3c\xd5\xd9\x82\x2b\xd5\xd6\x6d\x40\x1f\x84\x1a\x11\xf7\xe7\xbc\xed\x2d\x84\x1e\x93\xe0\xa1\x2b\xb9\xb3\x8f\x97\x4c\x9d\x5a\xf2\xc6\x55\x18\xe4\x6c\x98\xe3\xb8\xbc\xc5\xa8\x83\xdc\x25\x60\xe8\xde\x36\x81\x37\x0d\x14\x11\xe1\xba\xeb\x76\xe6\xc0\x22\x63\x38\x2e\xff\xb0\x4b\xeb\xd7\xfc\x76\xe6\xed\x20\x54\x45\x34\x12\x13\x62\xdb\xf5\x6c\xd6\x6d\x72\xdf\xe6\xf5\x3a\x8c\xec\xd4\x3d\xab\x63\x5d\xfb\x37\x58\x14\x95\x90\xd6\xa0\xc7\x9d\x9f\x2f\x9c\xff\xd9\xed\x3d\x7a\xcd\x7f\x61\xbc\xbd\x69\x1f\x9f\x6b\xef\x83\x63\xd7\x4d\xcf\x1b\xd1\xac\x76\xdf\x82\xdb\x06\x77\x2d\xbe\x3e\x21\x71\x50\xa9\x28\xb4\xef\x89\x49\x5d\xb0\x64\xc8\x94\x77\x6f\xeb\x7b\xdd\xc2\xf7\xa6\x17\xbe\x7c\xcb\xb8\x06\xd0\x01\xae\x2f\xfe\xa8\x8f\x73\xf7\x06\x8b\x18\xc6\x40\xdc\x85\xdd\xc1\xc7\xa7\x27\xda\xb2\x91\x63\x35\xd2\x8e\x8e\xfd\x4c\x88\x6b\x75\x5a\x64\x10\xed\x41\xb4\x3f\xd1\xe1\xf4\x6d\x26\xd2\x70\x16\xee\x58\x8c\x31\x84\xc0\xfc\x46\xac\x9d\x23\x1f\x69\x2a\xd1\x0e\x94\xdf\xd1\x91\x81\x74\x24\x7d\x3b\x0a\xcb\x37\x62\x63\x74\xda\x3c\x82\xdf\x36\x67\x41\x8e\x68\xa4\x21\x44\x1b\x61\x4e\x22\xe2\xec\x47\xaa\x71\x12\x09\x27\x91\x70\x12\x09\x27\x91\xea\x26\x52\xdd\x64\x2a\x99\xcc\x82\xec\x3f\x90\x86\x10\x6d\x84\xe5\x53\xb0\xd6\x7e\xa4\x1d\x88\x76\xc4\xf2\xed\xa8\x95\x76\x2c\x18\x6b\xb5\xa3\xb6\xda\xb1\x68\xa2\x31\x44\x75\xad\x76\x2c\x09\xcb\xb7\x63\x19\x94\xee\x4e\xb4\x27\xd1\xbe\x94\x3f\x88\xd2\x43\x09\x61\x18\xa5\x47\x10\x1d\x45\x74\x0c\xd2\x54\x6c\x25\x03\xa9\x6e\x25\x15\x5b\xd1\xe9\x68\x4a\xc7\x10\x6d\x44\x65\x32\x28\xdd\x93\xa8\x46\x4e\x25\xe4\x54\x42\x4e\x45\xcc\xd5\x48\xb5\x8c\x1d\x10\x6d\x31\xd2\x60\xc7\x5e\xa4\x21\x94\x8e\xc6\xf2\x1d\x10\x4d\xd3\x46\x94\x93\x41\x25\x7b\x52\x4e\x5f\xf4\xfb\x0e\x88\xa6\xd3\x43\x89\x8e\x20\x3a\x06\x69\x47\xd2\x55\x47\xd2\x43\x47\xe2\xb0\x23\xe9\xa1\x23\x62\xe6\x23\x8d\x21\xda\x08\x79\xee\x48\x1c\x76\x24\x0e\x3b\x22\xe6\x6a\xa4\x83\xe8\xdb\xc1\x94\x33\x84\xd2\x23\x28\x3d\x12\x69\x2f\xf3\x08\x6b\xcc\x86\x12\xb7\x43\x89\xcf\xa1\x98\xd3\x97\x8d\xc4\x9c\x7c\xa4\x21\x48\x47\x61\x7a\x35\xd2\x10\xa4\x63\x28\x7f\x8c\xce\x17\xd7\x8a\x3e\x8e\xcf\x91\x0e\x22\x3a\xcc\x31\x0c\xe9\x70\x47\x77\xa4\x23\x28\x27\x93\xd2\xb9\x8e\xd5\x48\x8b\x88\xce\x46\x9a\x8e\x65\x36\x22\xcd\x44\xda\x45\x74\x03\x86\x34\x03\x4b\x76\x41\xff\xd4\xb4\x8f\xe3\x0d\xa4\xfd\x29\x3d\x88\xd2\x23\x88\x8e\x26\x3a\x16\xdb\xed\x22\xc6\x23\x4e\x17\x91\x45\x34\x9b\x72\xf2\x28\x5d\x40\x74\x32\xd1\x29\x44\x0b\x89\x4e\xa3\x32\xd3\x89\xce\x22\x7a\x23\x1b\x83\x74\x1e\xa6\xbb\x12\x3f\x5d\x89\x9f\x0c\x92\x28\x83\x24\xca\x20\x89\x32\x48\xa2\x0c\x92\x28\x83\x24\xca\x20\x89\x32\x48\xa2\x0c\x92\x28\x43\xfb\xb3\xe8\x8e\x9a\xa9\x8f\x34\x44\x53\x94\xa8\x01\xd2\x1e\x44\xfb\x13\xcd\x72\x7c\x84\x74\x32\xd1\x1b\xd9\x58\xd1\x83\xda\xea\x41\x6d\xf5\xa0\xb6\x7a\x50\x5b\x3d\xa8\x95\x3e\x88\xf0\x39\xd2\x1e\x44\xfb\x13\xd5\x7c\xf6\x21\x3e\xfb\x61\xdd\x95\x48\x07\x11\x1d\x41\x74\xac\x63\x3b\xd2\x6c\xa2\x79\x44\xf3\x89\x4e\x22\x5a\x4c\x74\x1a\xd1\xe9\x44\x67\x11\x9d\x43\x74\x1e\xd1\x05\x48\xfb\x13\x57\xfd\x89\xab\xfe\xc4\x55\x7f\xe2\xaa\x3f\x71\x35\x88\xb8\x1a\x44\x5c\x0d\x22\xae\x06\x11\x57\x83\x88\xab\x21\xd8\x97\x2f\x22\x0d\xd1\x14\x4b\xe6\x23\xed\x41\xb4\x3f\xd2\xa1\xa2\xc4\x71\x00\xe9\x0c\xa4\xc3\x48\x57\xc3\xb4\x27\x23\x0d\xa1\x74\x34\xd1\x18\x4d\x45\x37\x76\x1a\xa9\x46\x40\xad\x38\xc6\x20\xed\xe3\xd8\x8f\xb4\x3f\xe5\x0c\xa2\xb4\xb6\xc8\x30\xf4\x0a\x9d\x1e\x4b\xf9\xe3\x88\x66\x13\xcd\x25\x9a\xe7\x78\x19\xe9\x44\x4a\x17\x10\x9d\x4c\xe5\x0b\x29\x5d\x44\x74\x1a\xd1\xe9\x44\x67\x12\x9d\x45\x74\xb6\xe3\x56\xa4\x37\x50\x5a\x7b\xcb\x30\x31\x97\xd2\xf3\x88\xce\x47\x3a\x9c\xa4\x18\x4e\x52\x0c\x27\x29\x86\xeb\xfe\x88\x34\x46\x53\xf2\xed\xe1\xe4\xdb\xc3\xc9\xb7\x87\x93\x6f\x0f\x27\xdf\x1e\x4e\xbe\x3d\x9c\x7c\x7b\x38\xf9\xf6\x70\x92\x62\x38\xf9\xf6\x70\xf2\xed\xe1\x24\xcb\x70\x94\xe5\x65\xa4\x79\x94\x53\x40\x74\x32\xd1\x29\x44\x0b\x89\x4e\xa3\x92\xd3\x89\xce\x22\xaa\x79\x1e\x4e\xdc\x8e\x20\xab\x8d\x40\x6b\x6a\xaa\xed\x35\x82\xec\x35\x12\xad\x7f\x14\xe9\x02\xa4\xa3\xb0\xf5\xfd\x48\xb3\x89\xe6\x11\x9d\x46\x74\x3a\xd1\x59\x44\xe7\x10\x9d\x47\x74\x01\xd2\xd1\x84\x36\x9a\xd0\x32\x49\xde\x4c\x92\x37\x93\xe4\xcd\x24\x79\x33\x49\xde\x4c\x92\x37\x93\xe4\xcd\x24\x79\x33\x49\xde\x4c\x92\x37\x93\xe4\xcd\x24\x79\x33\x49\xd2\x4c\x92\x34\x93\x24\xcd\x24\x49\x33\x49\xd2\x4c\x92\x34\x93\x24\xcd\x24\x49\x33\x49\xd2\x4c\x92\x34\x0f\x7d\x6c\x23\xd2\x19\x44\x67\x3b\xde\x16\xf9\xd8\xca\xdd\x48\xc7\x3b\xb6\x21\xcd\xa6\x74\x2e\xf6\xc1\x7c\x6a\x25\x1f\x5b\xd1\xf9\x93\x28\x3d\x99\xd2\x53\x88\x16\x51\x99\x69\x54\xbe\x84\xbe\x9d\x4e\xe9\x19\x94\x9e\x45\xe9\x39\x44\xe7\x11\x5d\x80\x74\x0a\xb6\xf5\x01\xd2\x6c\xa2\x79\x44\xf3\x89\x4e\x72\x1c\x46\x5a\x4c\xe9\x69\x44\xcb\x88\x4e\x27\x3a\x8b\xe8\x1c\xa2\xf3\x88\x2e\x40\x3a\x15\xd1\x8e\x21\x9d\xe0\xf8\x1e\x69\x36\xa5\xf3\x88\xe6\x13\x2d\x26\x3a\x8d\x68\x19\xd1\xe9\x44\x67\x52\xf9\x59\x94\x9e\x43\x74\x2e\xe5\xcc\xa3\xf4\x7c\x4a\x2f\xc0\x74\x31\xe1\x17\x13\x72\x31\x21\x17\x13\x72\x31\x21\x17\x13\x72\x31\x21\x17\x13\x72\x31\x61\x16\x13\xce\x34\xd2\xf3\x34\xd2\xf3\x34\xd2\x73\x09\xa2\x6d\x44\x9a\x4d\x34\x8f\x68\x3e\xd1\xa9\xa8\xb1\x12\x44\xd3\xe9\x32\xa2\xd3\x89\xce\x22\x3a\x87\xe8\x02\xa4\xa5\x84\x59\x4a\x98\x33\x08\x6d\x06\xa1\xcd\x20\xb4\x19\x84\x36\x83\x70\x66\x10\xce\x0c\xc2\x99\x41\x38\x33\x08\x67\x06\xe1\xcc\xc2\x16\x8f\x21\x2d\xa1\xf4\x0c\xa2\x9a\xc3\xd9\x88\xa9\x69\x36\xd1\x3c\xa2\xf9\x44\xa7\x11\x2d\x23\x3a\x9d\xe8\x2c\xa2\x73\x1c\xbb\x91\xce\xa3\xf4\x02\x4c\xcf\x21\xcc\x39\x84\x39\x07\x31\x77\x8b\x79\x94\x33\x8f\x72\xe6\x51\x2b\x0b\x28\x67\x01\xe5\x2c\xa0\x32\xab\x71\x94\x88\x42\x1a\xe2\x60\x48\xa3\xb1\xaf\xad\xc6\xf1\x41\xd3\xa9\xd8\x0b\x56\xb3\xb9\x48\xdf\xc3\x19\x24\x59\xbc\x4f\x74\xad\xd8\xc0\xfa\x22\xdd\xc2\xa2\x90\x6e\xc3\x92\x6b\xc5\x57\x44\x77\x38\xb6\x22\xdd\xe9\x78\x14\xe9\x2e\xac\xb5\x56\xec\xa6\x9c\x7d\x8e\x1c\xa4\x07\x29\xfd\x3d\xd5\xfa\x81\xca\x9f\x26\x7a\x86\xa8\xad\xf3\x11\x7f\xa9\x58\x27\xd6\x62\xdd\x75\x62\x23\x96\x5f\x27\x36\xe1\xb7\xeb\xc4\x16\x4a\xef\xa0\xf4\x4e\x4a\xef\x22\xba\x9b\x72\xf6\x50\x7a\x1f\xd5\xda\x4f\xf4\x20\xe5\x7c\x47\xf4\x2c\x96\xf9\x14\x31\x1f\x45\xba\x81\xd2\x1b\xb1\xcc\xa7\x84\xfc\x29\x21\x7f\x8a\x52\x68\xba\x83\xf2\x77\x12\xdd\x45\x74\x37\xe5\xef\xa1\xf4\x3e\xa2\xfb\x09\xe7\x3b\xca\x3f\x43\x08\xe7\x89\xfe\x81\xdf\xae\x27\x4d\xae\x27\x4d\xae\x27\x4d\xae\x27\x4d\xae\x27\x4d\xae\x27\x4d\xae\x47\x4e\xe6\x23\xdd\x80\x08\xeb\xa9\xf5\xf5\xa4\xc3\xf5\x24\xdd\x7a\xf1\x3d\xd1\xc3\x94\x7f\x94\xca\xff\x88\x3a\x59\x2f\x7e\xa6\x9c\xe3\xd8\xfa\x7a\x71\x82\xf2\x7f\xa5\x9c\x93\x94\x73\x8a\x72\xce\x12\xad\x20\x5a\x49\xd4\xa1\xa9\x64\x48\x37\x88\x4d\xa8\xe1\x0d\x62\x17\x51\xad\xb7\x0d\x28\x91\xa6\x3f\x52\xce\x4f\x2c\x19\xe9\x49\x4a\x9f\x45\xba\x91\xca\x6f\x24\xde\x36\x92\x65\x37\x8a\x9d\x58\x66\x23\x22\x68\xba\x8f\xbe\xdd\x8f\x9e\xb0\x91\x6c\xba\x11\x39\x39\x2a\x36\x91\xd5\x36\x91\x5c\x9b\xa8\xee\x26\xaa\xbb\x89\xb4\xba\x89\xb4\xba\x89\xb4\xba\x89\xf4\xb9\x89\x34\xb9\x19\xdb\xea\x8b\x54\x6b\x60\x33\xb5\xb2\x99\x5a\xd9\x4c\x7c\x6e\xc6\xb6\x74\xfa\x20\xb6\xb2\x99\xda\xda\x8c\xdc\x6a\xaa\xfd\x67\x0b\xe6\x24\x8b\xad\x94\xbf\x95\x72\xb6\xa2\x2d\x8e\x8a\x6d\xa8\xe7\xad\x48\x37\x50\x7a\x23\xd1\x2d\x94\xb3\x8b\xa8\xb6\xe9\x36\x6c\x5d\xe7\x1f\xa5\x9c\xe3\x98\xde\x8e\x11\x82\xa6\x21\xf6\x56\xa4\xd1\x94\xa3\x2d\xb8\x1d\xd1\xfa\x22\xdd\x80\xb6\xdb\x4e\x68\xdb\xc9\x7f\xb6\x23\xa6\xce\xd9\x4a\xe9\x6d\x44\xb5\xbc\xdb\x51\x5e\x9d\xde\x45\x74\x37\x51\xdd\xe2\x76\x92\x77\x3b\x59\x79\x3b\xb6\xab\xeb\xfe\x48\x39\x27\x35\x45\x4b\x1d\x15\x3b\x88\xf3\x1d\xc4\xf9\x0e\x6a\x65\x07\x71\xbe\x83\x5a\xd9\x41\xbe\xba\x83\x7a\xc1\x0e\xc2\xdf\x41\xc8\x3b\x50\x9f\x3a\x67\x3f\xe5\x1c\x24\xaa\x75\xb2\x83\xfa\xda\x0e\x71\x8c\xd2\xa7\x29\x7d\x8e\xa8\xd6\xd2\x4e\xf4\xd8\x64\xa4\x21\xe8\xb7\x3b\x49\xde\x9d\x24\xef\x4e\xf4\xd8\xad\x62\x27\xf9\xea\x4e\xf2\xd5\x9d\x62\x23\xea\x79\x27\x71\xb2\x93\x78\xd8\x89\x72\xbd\x81\x54\xeb\x70\x27\x4a\xa4\x73\x0e\x53\xce\x8f\xe8\x93\x3b\xd1\x63\x75\xfa\x17\xa2\xc7\x09\xe7\x04\x7a\xf2\x4e\x94\x54\xa7\x7f\xa3\x5a\xa7\xe8\xdb\xd3\x94\x73\x96\xd2\xe7\x89\x5e\xa4\x6f\x2b\x88\x56\x12\x75\x68\x8a\xfa\xd9\x8a\x9e\xa1\x7b\xd9\x2e\xea\x65\xbb\x90\x67\x9d\x13\x43\x54\xf7\xb2\x5d\xd4\xcb\x76\x21\xe7\x79\x48\x37\x60\x8b\xbb\x90\x67\x9d\xa3\x79\xde\x45\x3c\xef\x22\xfd\xec\x22\x5b\xec\x42\xfd\x68\x7a\x98\xf2\x8f\x10\xd5\x76\xd9\x85\x52\x68\x7a\x8c\x4a\xfe\x84\x12\xed\x22\x89\x76\x89\xff\x11\xfd\x85\xe8\x71\x2a\x73\x82\xbe\xfd\x95\x72\x4e\x52\xce\x6f\x94\x3e\x45\xf4\x34\xe5\x9c\xa7\x56\x7e\xa7\x9c\x0b\x44\x2f\x12\xd5\x3d\x74\x17\xca\xf5\xa8\xd8\x4d\x76\xdf\x4d\x3c\xef\x26\x9e\x77\x53\xaf\xd9\x4d\xbd\x66\x37\x79\xd1\x6e\xea\xb3\xbb\x91\x73\xec\x1b\xd8\xfa\x56\xb1\x87\x3c\x64\x0f\x4a\xb7\x19\xa9\x1e\xc1\xf6\x90\x8c\x7b\x68\x0c\xdc\x43\xbd\x72\x0f\x8d\x81\x7b\xd1\x1f\xfa\x22\xd5\xfd\x7d\x2f\xf5\xf4\x6f\xc8\x43\xf6\x23\xda\x1b\x62\x3f\x8d\xed\x07\x88\x87\x03\xe4\x7b\x07\x68\x9c\x3c\x80\xf8\x3a\x67\x0b\xa5\xb7\x52\x7a\x1b\x7d\xbb\x83\xd2\x3b\x1d\x6d\x90\xee\x41\x9e\x0f\x20\x6f\x79\x48\x0f\x52\x49\x8d\x79\x00\x31\xf3\xc4\x41\xf2\x9f\x83\x34\x32\x1c\x24\x6e\x0f\x12\xda\x41\x92\xe8\x20\x8d\xde\x07\xc9\x16\x07\x51\xf3\x3a\x47\xfb\xea\x41\x92\xee\x10\xf1\x73\x88\x10\x0e\x11\xc2\x21\xaa\x7b\x88\xc6\x8a\x43\xd4\x0b\x0e\x91\xff\x1f\x22\xcd\x1c\xa2\xbe\x7c\x88\x10\x0e\x11\xc2\xf7\x34\x56\x7c\x8f\xde\xbe\x55\xfc\x40\xdf\xfe\x40\x36\xfd\x01\x6d\xaa\xe9\x71\xca\x39\x41\xe9\xd3\x44\xcf\x12\x3d\x4f\xf9\xce\x5a\x97\x28\xc7\xd6\x94\x7a\xe8\x61\xea\xbf\x87\xa9\x67\x1d\x46\x3f\xd1\xf4\x18\xd1\xe3\x44\x4f\x10\x3d\x49\xf4\x34\x22\x1c\xa6\x99\xe2\x30\x22\xeb\xf4\x39\x4a\xeb\xf9\xe2\x30\x22\x63\x0e\x61\x1e\x41\xaf\xee\x8b\x34\x04\xad\x70\x84\x46\xfe\x23\xc4\xdb\x11\xc2\x39\x42\xbc\x1d\x25\x59\x8e\xba\xd2\x67\x29\xad\x79\xfb\x91\x38\xf9\x91\x78\xf8\x91\x5a\xff\x91\xca\xfc\x48\xed\xfe\x48\x12\xfd\x48\xf3\xd4\x8f\x24\xd1\x31\xb2\xfb\x31\xe2\xfc\x18\x61\x1e\xa3\xf1\xe7\x18\xd5\x3a\x46\x65\x7e\x22\x19\x7f\xa2\xde\xf1\x13\x95\xfc\x89\xf0\x7f\x22\xbd\xfd\x44\x92\xfe\x84\x6d\xe9\x6f\x4f\x12\x3d\x4d\xf4\x2c\xd1\x73\xf4\xad\x96\xf1\x27\x92\xf1\x17\x71\x1c\x5b\xf9\x85\x64\xf9\x85\x5a\xf9\x85\xca\xfc\x42\xa3\xd0\x2f\xa4\xdb\xe3\x24\xc5\x71\x6a\xeb\x38\x95\x3c\x4e\x25\x8f\x13\xff\xc7\x89\xab\x13\xc4\xd5\x09\x2a\x79\x82\x38\x39\x41\x25\x4f\x50\xc9\x13\x54\xf2\x04\x21\x9f\x20\xcc\x93\xe4\x51\x27\x89\xf3\x93\x54\xfe\x24\x69\xf5\x24\x69\xe9\x24\xd5\x3a\x89\x5a\xd2\x39\x67\x29\x7d\x9e\xd2\x7f\x10\x25\x04\xb2\xce\x29\xf2\x9c\x53\x84\x73\x8a\x70\x4e\x11\xce\x29\xc2\x39\x45\x7a\x3e\x45\x08\xa7\x48\xcf\xa7\x08\xe1\x14\x21\x9c\x22\x84\xd3\xa4\xf3\xd3\xc4\xf9\x69\x2a\x73\x1a\xcb\xe0\x1c\x46\x16\x3c\x83\xd6\xcf\x43\x1a\x82\x3e\x70\x86\x78\x3e\x43\x3e\x7c\x86\xf4\x7c\x86\x64\x3c\x43\xdc\x9e\x41\xbb\x27\xe3\xaf\x2e\x7f\x96\xca\x9f\xa5\x71\xfb\x2c\x8d\xdb\x67\xd9\x5c\xfd\x2d\x69\xe9\x2c\xf1\x7c\x96\xf4\x79\x96\xd0\xce\x12\xe7\x67\x09\xf3\x2c\x71\x7e\x96\x6c\x77\x16\x47\x2a\x9d\x3e\x4d\xe9\x33\x54\xf2\x1c\xe5\x9c\xa7\xb4\x96\xe2\x2c\x49\x71\x8e\xf8\x3f\x47\x1c\x9e\x23\xe4\x73\xa4\x87\x73\x84\x76\x8e\xf8\x3c\x47\xda\x38\x47\xda\x38\x47\x7a\x38\x47\x75\xcf\x53\xdd\xf3\x34\xdf\x9d\x27\x4e\xce\x53\xeb\xe7\xa9\xdd\xf3\xe4\xcf\xe7\xa9\xdd\xf3\x54\xeb\x3c\xb5\xfb\x3b\xe9\xed\x77\xf2\xd2\xdf\x49\x03\x17\x29\xe7\x22\xb5\x55\x89\x6d\xf5\x45\xfa\x07\x52\x9b\xf0\x6d\xe2\xcd\x26\x4b\xd9\xd4\x8a\x4d\x1c\xda\xc4\xa1\x4d\x08\x36\x71\x68\x93\x15\x6c\xe2\xcd\x41\x75\x1d\x54\xd7\x41\x75\x1d\x54\xcb\x41\xb5\x1c\x54\xcb\x41\x7e\xe2\x20\x0f\x71\x90\x6f\x3b\x34\x87\x32\x48\xdb\x02\x29\xda\x02\x69\x34\xe5\xc4\x10\xc5\x39\x54\x76\xc1\x6f\xe7\x23\x0d\xc1\x32\x5d\xe8\xdb\x2e\xf4\x6d\x17\xd7\xb7\x73\x1d\x5b\xcd\xc3\xe6\x61\xc7\x6a\xf3\x08\x13\x8e\xc5\x48\x87\xe9\x34\x8e\x9c\xab\xcd\x9f\xc5\x9b\x8e\x64\xa4\x1f\x10\xdd\xe9\xe8\x8b\x74\x9f\xa3\x0d\xd2\xfd\x8e\xbe\xfa\xd2\x2a\x8b\x81\x42\x7d\x7d\x95\xfe\x0d\x63\xaf\xba\xd2\xc0\x82\xa0\xb1\x2b\xcd\x99\x84\x34\x57\x5a\xb0\x3a\x70\x83\x2b\x2d\x59\x38\x7c\xec\x4a\x2b\x16\x08\xa7\x5d\x69\x83\x85\xd1\xd3\xc4\xfa\x9f\xc9\x6e\x10\xc9\xae\xb4\xc5\xc2\x31\x0e\x73\xa6\x7d\x58\xa0\xf4\x73\xa5\x7d\xa1\xc0\xf8\xd5\x95\xf6\x63\xf5\xac\x25\xae\xb4\x3f\x4b\xf0\x09\x70\xa5\x03\x58\x8a\xcf\xf3\xae\x74\x20\xab\xe3\x1b\x8e\x9c\x80\xf4\xc1\x4f\x2f\x13\x57\x3a\x0d\x28\x8b\x72\xa5\x39\xb3\x20\xc5\x95\x16\xac\x2d\x64\xb8\xd2\x92\x35\x83\x07\x5d\x69\xc5\xea\xc1\x2e\x57\xda\x60\x4d\xf4\x29\x7a\x94\x36\xd9\x59\xde\xc9\x95\xb6\x58\x33\xf1\xaa\x2b\xed\xc3\xea\x89\x13\xae\xb4\x2f\xdf\x21\xeb\xb8\xd2\x7e\xac\xbd\x35\xc2\x95\xf6\x67\x63\xac\xd7\x5c\xe9\x00\x36\xc9\xa7\xa3\x2b\x1d\xc8\xda\xfa\x1c\x64\x19\xac\x80\x4d\xc4\xdf\x32\xfc\xbd\x81\xe5\xb2\x1c\x16\x8b\xbf\x59\xf8\x39\x0b\x53\xd9\xac\x88\x15\xb3\xd9\xac\x84\x4a\xe5\x63\x6e\x2c\x6b\x86\xb9\xcd\xf1\x6f\x12\x6b\xcd\xda\xe0\x6f\x2c\xeb\x81\xa5\x8a\xf0\xfb\x29\x58\x3f\x96\x75\xc3\x74\x09\xd6\xd2\x34\x8b\x70\x8b\x58\x21\x4b\x60\xbe\xf4\xcd\x9f\xa3\x25\x61\x6a\x90\x8b\x8b\x9e\x54\xbb\x25\xa6\x7a\x61\xfd\x6c\x7d\xed\x3f\xa3\x60\x62\x41\x59\xc1\x0d\xb9\x39\xb1\x39\x59\x65\x59\xb1\xd9\x45\xc5\xb3\x4b\x0a\x26\xe6\x97\xc5\x36\xcb\x6e\x1e\x9b\xd4\xba\x4d\xeb\xd8\x1e\x45\x45\x13\xa7\xe4\xc6\x76\x2b\x2a\x29\x2e\x2a\xc9\x2a\x2b\x28\x2a\x4c\xf0\xed\x76\x79\xb1\xa4\xd8\x41\x08\xd1\x33\xab\xac\x65\x6c\xaf\xc2\xec\x04\xfd\xd2\xcf\x02\x36\x01\x9b\xf5\x64\x38\x96\x0d\xc6\x4f\x85\xac\x14\xbf\x2e\x98\x90\xeb\x04\x8b\x1d\x9c\x55\x88\x19\x5d\xb1\xc4\x14\x64\x92\x75\x2d\x9a\x82\xb4\x0b\x16\xca\xc6\xea\x85\x98\xa5\x41\x62\x59\x2b\xfc\xfd\x0b\xd0\x2e\xa5\xd9\xb9\x85\x39\xb9\x25\xb1\xad\x62\xaf\xc0\xff\xf3\xaa\xb1\xd5\xed\x5f\x56\x33\xd6\xc9\xcf\x30\xaa\x5a\x5a\x55\x31\x09\x75\xd7\x1a\x7f\x12\xf4\x1b\x38\x87\xe5\x96\x94\xea\xf2\x49\x09\xad\x5b\x27\xb4\xa9\xb9\x2d\x77\x4b\xad\x6a\x6a\x49\x37\xd4\xca\xd9\x50\xcd\x7c\x16\x10\x8f\xda\x7d\xca\xe8\x1b\xad\x94\xa9\xf8\xb7\x84\x4d\xc6\xbc\x22\x96\xf7\xa7\x46\x8e\xc5\x72\xb9\xe4\x92\xa5\xf8\x4d\x2e\x7d\xca\x21\x54\x8d\x3d\x14\x4b\x0c\xa6\x52\x03\xa9\xa6\x56\x7a\x19\xb5\x56\x48\xa5\x86\xd4\xd0\xe2\x00\x6c\x31\x0f\xeb\x67\x93\x7b\xba\x4b\x66\x13\xb6\x76\x73\x27\x72\x11\xa6\xf3\x5d\xe6\x9b\xc4\xa6\x93\x93\x96\x62\x49\x5d\xcf\x2d\x5b\xa9\x76\x42\x0f\x9d\x17\x94\xc6\x66\xc5\x96\x95\x64\xe5\xe4\x4e\xcd\x2a\x99\x1c\x5b\x94\xe7\xed\x58\xb1\x25\xb9\x13\x0b\x4a\xcb\x72\x4b\x30\xb3\xa0\x30\x76\x68\xc2\xe0\x84\xd8\x81\x59\x65\xb9\x85\x65\xb1\x59\x85\x39\xb1\x43\xaa\x2a\x0e\xc8\xcb\x2b\xc8\xce\xa5\xcc\xec\xdc\x92\xb2\x2c\x2c\x5c\x54\x96\x8f\xbe\x31\x69\x7a\x49\x41\x69\x4e\x41\xb6\x6e\xad\x34\xa1\x26\x4f\xab\xb9\xb7\x55\x7b\x97\x47\x4f\x60\xa8\x39\xad\xb1\x19\xa4\x87\x7e\x54\x5c\x7f\x2e\x75\x56\x19\x5c\x96\x3b\x23\x37\xb6\x5f\x56\x59\x59\x6e\xa9\x2e\xdc\x15\x0b\x94\xba\x94\xef\x34\x6c\x17\x52\xca\x54\xfc\xa4\x0d\x36\x13\xd5\xa5\x95\x93\x4f\xe9\x2c\x32\x7a\x0e\xc1\xe9\xde\x5d\xe8\xaa\x39\x01\xfb\x7b\xec\x9f\x36\x1c\xeb\xaa\x9b\xe5\x72\x9e\x42\xfc\x29\xc2\xb2\x4e\x69\x74\x9d\x96\x2e\xa7\xc8\x23\x5a\x4a\xed\x16\x62\x1b\xb1\x98\x76\x77\x89\x52\xd2\x47\x01\x39\x97\x27\x17\xb1\x64\xd6\x2c\x72\x12\xa7\x63\x4e\xc5\x6f\xcb\xa8\x6c\x36\xe6\x4f\xc1\x9f\xd9\xae\x91\x6e\x2a\xea\xd1\xd9\xea\x04\xd7\x58\x36\x93\x46\xc6\xfc\x2a\xd9\xb1\x7c\x83\x86\xe4\x7e\xd5\xba\x70\xba\x74\x9e\xab\xcf\xc5\x52\x6e\x31\xa6\x8b\x88\x77\xb7\xf6\x5a\x91\xe5\x34\xff\xb9\xc4\x95\x4e\x65\xd1\x48\x3b\x01\x6b\x4c\xa1\x76\x9c\x7c\xe4\x93\xe3\x66\x91\xdb\xe5\xba\xdc\xb0\x8c\xb8\x2d\xf5\x70\x5f\xa7\xb3\xc6\x12\xc7\x1a\xfd\x3a\x72\x59\x3d\xbe\xe6\xba\x34\x39\x1c\xc7\xe5\xbe\x35\x22\x3a\xb5\xe5\xd9\x6d\x4a\xa9\x9b\xcf\x20\xbd\x55\x63\x17\x12\xb7\x39\x94\x57\x54\xa5\x59\x5d\x6a\x8a\xab\x25\xa7\xc4\x53\x68\xfc\x9f\x5c\x65\x95\x3c\xf2\x46\xa7\xf6\x72\x08\xad\xd5\x55\xf4\x9b\x47\xba\x29\x73\xb5\x5a\x44\x1c\xe5\xe0\x8f\xd3\xce\x4e\x8f\x2a\xc2\xba\xd3\xc9\x6a\xce\xae\xee\xf4\xf5\xb2\x2b\x34\x97\x45\xfa\x2d\x72\xd5\x2b\xc6\x6f\x74\x5b\x4e\x5e\xa6\x3a\xbb\x6e\xd7\xac\x52\xec\x8a\xd8\x71\xbb\x94\x14\x4c\x2d\x6a\x19\x3b\x33\xbf\x20\x3b\x3f\x76\x66\x56\x69\x6c\x4e\x6e\x69\xc1\xc4\x42\xfc\x72\xc2\xec\x58\xef\x8e\x10\x8b\xdf\x66\x61\x57\x2f\x2c\x2c\x9a\x81\xdd\x68\x46\x6e\x4b\xec\xd6\x79\x25\xb9\xa5\xf9\x05\x85\x13\x63\x4b\xf5\xa8\x5b\x9a\x5b\x52\x90\xe7\x82\x88\x2d\xcb\xcf\x2a\xd3\x03\xc3\xd4\xdc\xb2\x92\x82\xec\xac\x29\x53\x66\xe3\x3c\x35\xb5\x18\xab\x4e\xc0\x89\x69\x66\x41\x59\xbe\x6e\x3d\x6b\xca\x8b\x09\x4e\x2e\x70\xd4\xc8\xc3\x21\x39\xb6\x60\x6a\x71\x49\xd1\x0c\x62\xaf\x55\x69\x76\x49\x6e\x6e\x21\xb6\x93\x95\x93\x35\xa1\x60\x4a\x41\x19\x62\xe4\x67\x95\x64\x65\xe3\x58\x82\x03\x4a\x41\x76\x29\x8d\x15\x38\x44\xc4\x16\x67\x15\xb6\xba\x6e\x7a\x49\x51\x71\x2e\x32\x39\xbc\x47\xdf\xea\x82\xc8\x96\x73\x9c\x29\x2d\x9a\x32\x23\xb7\x94\x4a\x17\xe6\xe6\xe6\x94\xea\x71\x2a\x07\x45\x9c\x82\x95\xb0\xe1\x29\x45\x45\x93\xb5\x28\x79\x45\x25\xc8\x5e\x4e\x59\x7e\x2b\x0f\x7e\xf3\x8a\x0a\xcb\xb0\x6a\x51\x6c\x56\x4e\x0e\xca\x8c\x8a\x2a\xca\x9e\x3e\x55\x8f\x60\x38\xaa\x94\xb9\x99\xcb\xca\x2e\x29\xc2\xef\x8a\xa7\x64\x95\x21\xca\x54\x3d\x52\xe5\x53\x1f\x2f\x66\x1d\x58\x22\xfe\xcc\xa4\x9f\x04\xea\xe9\x9e\xe3\x57\xb6\x6b\xf4\x4a\x70\xf9\x47\x22\x56\x2c\x2b\x2b\xee\x90\x98\x38\x73\xe6\xcc\x84\x2c\xd7\x20\x96\x8d\x63\x58\x02\x32\x95\xf8\xef\x61\xb5\x8b\x14\x93\x33\x7b\x0e\x50\x25\xe4\x16\x1a\x73\x2a\xba\xcb\x9f\x36\x5d\x36\xbb\x38\xd7\xe5\x24\x25\xa5\x09\xf9\x65\x53\xa7\x38\xa7\x3f\x67\xb3\xee\x71\x72\xba\xc7\xc8\xec\xee\x45\x83\x71\x6a\xeb\x4b\xd3\x50\xb1\xab\xef\x77\x77\x79\x7d\xec\x65\x08\x7a\x9c\xbb\x7c\xee\x6e\xe3\x9c\xb5\xfb\xe2\xfc\x50\xa8\x9d\x77\x3a\x8d\xea\xda\x96\x83\x7b\xf5\x8d\x1d\x50\x8c\x6e\xd2\x1d\x6d\x14\xeb\x2a\xd0\x32\xd6\x3d\xbf\xb7\xd1\x93\xbb\xb7\xba\x9c\x23\x50\x01\x7e\x2e\x23\xc1\x4b\xa9\xff\x24\x90\xb2\x26\xe2\xf7\x03\x90\xb3\xbe\x55\x6a\x40\x27\x2c\x28\x2e\x2b\x4d\x28\x2d\x98\x92\x50\x54\x32\x31\x71\x40\xf7\xbe\xae\xd8\x9b\xfe\x39\x9a\xb2\xbd\xac\x86\x7f\xbe\x75\x29\x56\xe7\x18\x65\x4a\x8c\x67\x0d\x8c\x5d\x2d\x8c\x53\x7d\x31\x26\xf5\xc7\xf8\x33\x50\xef\x2b\x64\x21\x2c\x54\xef\x0b\x65\x11\xac\x16\x8b\x64\xb5\x59\x14\xab\xc3\xea\xb2\x7a\x2c\x9a\xc5\xb0\xfa\x28\x75\x03\xd6\x90\xc5\xe9\x1d\x96\xac\x09\x6b\x8a\x31\x62\x73\xd6\x82\xc5\xa3\x7e\x5a\x21\xb7\x89\xae\x48\x31\x99\xb5\x65\x29\xec\x1a\xd6\x8e\xb5\x67\xa9\x28\xe1\xb5\xac\x23\xeb\xc4\x3a\xb3\x34\x96\x8e\xa3\x73\x57\x9c\x19\x33\x70\x54\xec\x8e\xa3\x60\x4f\xb4\x40\x6f\xd6\x07\x65\xeb\xc7\xfa\xa3\x94\x03\xd9\xf5\x18\x80\x0c\xc6\x60\x61\x28\xea\x7b\x38\x1b\xc1\x46\xb2\x51\x6c\x34\x1b\xc3\x32\xd9\x58\x36\x8e\x8d\x67\x59\xc0\xd9\x53\xec\x16\x76\x2b\xfb\x90\x3d\xc4\x7e\x62\xb7\xb1\x7b\xd8\x22\xf6\x38\x7b\x81\x3d\x0d\x82\xdd\x09\x92\xdd\xcc\xee\x67\xa7\xd9\x19\x76\x37\xc6\xf7\xe5\x60\xb0\x83\xec\x14\x7b\x82\xbd\xc8\xce\xb1\xb3\xec\x3c\x5b\xc9\x5e\x61\x9f\xb3\x8d\xb8\x76\x99\x80\x3a\xbf\x17\x7d\x62\x33\xda\x75\x13\xfb\x82\x6d\x63\x5b\xd8\x56\xf6\x25\xfb\x19\x47\xa6\x9d\xec\x2b\xb6\x9d\xbd\x86\xba\xff\x8d\xdd\xc7\xf6\xb0\x5d\x6c\x37\x5a\xec\x17\x76\x82\xdd\x81\x21\x48\x01\x8e\xa8\xda\x2d\x0b\xd9\x0a\xb4\xd0\x34\x9a\x53\x4a\xd1\xc3\xca\x70\x04\x9e\xc9\xfe\xc7\x66\x61\xbc\x3e\x9b\xcd\xc1\xb5\xf1\x8d\x6c\x0d\x7b\x92\xcd\x67\xf3\xd8\x02\xb6\x90\x1d\x67\xbf\xb2\xf7\xc0\x04\x0b\x7c\xc0\x17\xfc\xc0\x9f\x55\x32\x1b\x02\x20\x10\x82\x20\x98\x39\x80\x41\x08\x84\x42\x18\x00\x84\x43\x04\xd4\x82\x48\xa8\x0d\x51\x50\x07\xea\x42\x3d\x88\x86\x18\xa8\xcf\xfe\x60\x17\x20\x16\x1a\x40\x43\x88\x83\x46\xd0\x18\x9a\x40\x53\x68\x06\xcd\xa1\x05\xc4\x43\x4b\x68\x05\x09\x90\xc8\x2e\xb2\xbd\xd0\x1a\xda\x40\x12\x24\x43\x5b\x48\x81\x6b\xa0\x1d\xb4\x87\x54\xe8\x00\xd7\x42\x47\xe8\x04\x9d\xd9\x0f\xec\x30\xa4\x41\x3a\x74\x81\xae\xd0\x0d\x32\xe0\x3a\xe8\xae\x5f\x41\x04\xbd\xa0\x37\xf4\x81\xbe\xd0\x8f\xbd\xce\x56\x41\x7f\x18\x00\x03\xe1\x7a\x18\x04\x83\x61\x08\x0c\x85\x61\x30\x9c\x5d\x62\x15\xec\x08\x3b\x0a\x23\x60\x24\x8c\x82\xd1\x30\x06\x32\x61\x2c\x8c\x83\xf1\x90\x05\x13\x20\x1b\x72\x20\x17\xf2\x60\x22\xe4\x43\x01\x4c\x82\xc9\x30\x05\xa6\xb2\xf7\xa1\x10\x8a\xa0\x18\xa6\xb1\x1f\xd9\x31\x28\x81\x52\x28\x83\xe9\x30\x03\x66\xc2\x2c\x98\x0d\x37\xc0\x1c\xb8\x11\xe6\xc2\x3c\x98\x0f\x0b\x60\x21\xdc\x04\x37\xc3\x2d\xec\x59\xb8\x15\x6e\x83\xdb\xa1\x1c\xee\x80\x3b\x61\x11\xdc\x05\x77\xc3\x3d\xb0\x18\xee\x85\xfb\x60\x09\xdc\x0f\x0f\xc0\x83\xf0\x10\x3c\x0c\x4b\xe1\x11\x78\x14\x96\xc1\x63\xf0\x38\x3c\x01\xcb\x61\x05\x3c\x09\x2b\xe1\x29\x78\x1a\x9e\x81\x67\xe1\x39\x78\x1e\x5e\x80\x17\xe1\x25\x78\x19\x5e\x81\x57\xe1\x35\x78\x1d\x56\xc1\x1b\xf0\x26\xac\x86\xb7\xe0\x6d\x78\x07\xd6\xc0\xbb\xf0\x1e\xbc\x0f\x1f\xc0\x87\xf0\x11\x7c\x0c\x9f\xc0\x5a\x58\x07\x9f\xc2\x7a\xd8\x00\x9f\xc1\x46\xd8\x04\x9f\xc3\x17\xb0\x19\xb6\xc0\x56\xf8\x12\xb6\xc1\x57\xb0\x1d\x76\xc0\x4e\xd8\x05\xbb\x61\x0f\xec\x85\x7d\xf0\x35\x7c\x03\xfb\xe1\x5b\x38\x00\x07\xe1\x10\x7c\x07\xdf\xc3\x0f\x70\x18\x8e\xc0\x51\xf8\x11\x8e\xc1\x4f\xf0\x33\xfc\x0f\x7e\x81\xe3\x70\x02\x7e\x85\x93\xf0\x1b\x9c\x82\xd3\x70\x06\xce\xc2\x39\x38\x0f\xbf\xc3\x1f\x70\x01\x2e\xc2\x25\xa8\x80\x4a\xb0\xc1\xc1\x19\x07\xce\xb9\xe0\x52\x1f\xd1\xc5\x4d\x6e\x71\x1f\xee\xcb\xfd\xb8\x3f\x0f\xe0\x81\x3c\x88\x07\xf3\x10\x1e\xca\xc3\x78\x38\x8f\xe0\xb5\x78\x24\xaf\xcd\xa3\x78\x1d\x5e\x97\xd7\xe3\xd1\x3c\x86\xd7\xe7\xb1\xbc\x01\x6f\xc8\xe3\x78\x23\xde\x98\x37\xe1\x4d\x79\x33\xde\x9c\xb7\xe0\xf1\xbc\x25\x6f\xc5\x13\x78\x22\x6f\xcd\xdb\xf0\x24\x9e\xcc\xdb\xf2\x14\x7e\x0d\x6f\xc7\xdb\xf3\x54\xde\x81\x5f\xcb\x3b\xf2\x4e\xbc\x33\x4f\xe3\xe9\xbc\x0b\xef\xca\xbb\xf1\x0c\x7e\x1d\xef\xce\x7b\xf0\x9e\xbc\x17\xef\xcd\xfb\xf0\xbe\xbc\x1f\xef\xcf\x07\xf0\x81\xfc\x7a\x3e\x88\x0f\xe6\x43\xf8\x50\x3e\x8c\x0f\xe7\x23\xf8\x48\x3e\x8a\x8f\xe6\x63\x78\x26\x1f\xcb\xc7\xf1\xf1\x3c\x8b\x4f\xe0\xd9\x3c\x87\xe7\xf2\x3c\x3e\x91\xe7\xf3\x02\x3e\x89\x4f\xe6\x53\xf8\x54\x5e\xc8\x8b\x78\x31\x9f\xc6\x4b\x78\x29\x2f\xe3\xd3\xf9\x0c\x3e\x93\xcf\xe2\xb3\xf9\x0d\x7c\x0e\xbf\x91\xcf\xe5\xf3\xf8\x7c\xbe\x80\x2f\xe4\x37\xf1\x9b\xf9\x2d\xfc\x56\x7e\x1b\xbf\x9d\x97\xf3\x3b\xf8\x9d\x7c\x11\xbf\x8b\xdf\xcd\xef\xe1\x8b\xf9\xbd\xfc\x3e\xbe\x84\xdf\xcf\x1f\xe0\x0f\xf2\x87\xf8\xc3\x7c\x29\x7f\x84\x3f\xca\x97\xf1\xc7\xf8\xe3\xfc\x09\xbe\x9c\xaf\xe0\x4f\xf2\x95\xfc\x29\xfe\x34\x7f\x86\x3f\xcb\x9f\xe3\xcf\xf3\x17\xf8\x8b\xfc\x25\xfe\x32\x7f\x85\xbf\xca\x5f\xe3\xaf\xf3\x55\xfc\x0d\xfe\x26\x5f\xcd\xdf\xe2\x6f\xf3\x77\xd8\x3e\xf6\x3d\x5f\xc3\xbe\xe1\xef\xf2\xf7\xf8\xfb\xfc\x03\xfe\x21\xff\x88\x7f\xcc\x3f\xe1\x6b\xf9\x3a\xfe\x29\x5f\xcf\x37\xf0\xcf\xd8\x7e\xf6\x2d\x3b\xc0\xbe\x63\x5f\xb3\x43\x7c\x23\xdf\xc4\x3f\xe7\x5f\xf0\xcd\x7c\x0b\xdf\xca\xbf\xe4\xdb\xf8\x57\x7c\x3b\xdf\xc1\x77\xf2\x5d\x7c\x37\xdf\xc3\xf7\xf2\x7d\xfc\x6b\xfe\x0d\xdf\xcf\xbf\xe5\x07\xf8\x41\x7e\x88\x7f\xc7\xbf\xe7\x3f\xf0\xc3\xfc\x08\x3f\xca\x7f\xe4\xc7\xf8\x4f\xfc\x67\xfe\x3f\xfe\x0b\x3f\xce\x4f\xf0\x5f\xf9\x49\xfe\x1b\x3f\xc5\x4f\xf3\x33\xfc\x2c\x3f\xc7\xcf\xf3\xdf\xf9\x1f\xfc\x02\xbf\xc8\x2f\xf1\x0a\x5e\xc9\x6d\xee\x10\x4c\x80\xe0\x42\x08\x29\xf4\x89\x82\xa6\xb0\x84\x8f\xf0\x15\x7e\xc2\x5f\x04\x88\x40\x11\x24\x82\x45\x88\x08\x15\x61\x22\x5c\x44\x88\x5a\x22\x52\xd4\x16\x51\xa2\x8e\xa8\x2b\xea\x89\x68\x11\x23\xea\x8b\x58\xd1\x40\x34\x14\x71\xa2\x91\x68\x2c\x9a\x88\xa6\xa2\x99\x68\x2e\x5a\x88\x78\xd1\x52\xb4\x12\x09\x22\x51\xb4\x16\x6d\x44\x92\x48\x16\x6d\x45\x8a\xb8\x46\xb4\x13\xed\x45\xaa\xe8\x20\xae\x15\x1d\x45\x27\xd1\x59\xa4\x89\x74\xd1\x45\x74\x15\xdd\x44\x86\xb8\x4e\xef\xdf\x11\x3d\x45\x2f\xd1\x5b\xf4\x11\x7d\x45\x3f\xd1\x5f\x0c\x10\x03\xc5\xf5\x62\x90\x18\x2c\x86\x88\xa1\x62\x98\xde\xbf\x21\x46\x8a\x51\x62\xb4\xd0\x3b\x10\xc6\x8a\x71\x62\xbc\xc8\x12\x13\x44\xb6\xc8\x11\xb9\x22\x4f\x4c\xd4\x3b\x0c\xc4\x24\x31\x59\x4c\x11\x53\xd9\xf3\xa2\x50\x14\xe9\x3b\xeb\xa2\x44\x94\x8a\x32\x31\x5d\xcc\x10\x33\xf5\xdd\x69\x71\x83\x98\x23\x6e\x14\x73\xc5\x3c\x31\x5f\x2c\x60\xcb\xc5\x42\x71\x93\xb8\x59\xdc\x22\x6e\x15\xb7\x89\xdb\x45\xb9\xb8\x43\xdc\x29\x16\x89\xbb\xc4\xdd\xe2\x1e\xb1\x58\xdc\x2b\xee\x13\x4b\xd8\xc3\xe2\x7e\xf1\x80\x78\x90\x2d\x13\x0f\x89\x87\xc5\x52\xf1\x88\x78\x54\x2c\x13\x8f\x89\xc7\xc5\x13\x62\xb9\x58\x21\x9e\x14\x2b\xc5\x53\xe2\x69\xf1\x8c\x78\x56\x3c\x27\x9e\x17\x2f\x88\x17\xc5\x4b\xe2\x65\xf1\x8a\x78\x55\xbc\x26\x5e\x17\xab\xc4\x1b\xe2\x4d\xb1\x5a\xbc\x25\xde\x16\xef\x88\x35\xe2\x5d\xf1\x9e\x78\x5f\x7c\x20\x3e\x14\x1f\x89\x8f\xc5\x27\x62\xad\x58\x27\x3e\xd5\x77\x52\xc5\x67\xfa\x6e\xa5\xf8\x5c\x7c\x21\x36\x8b\x2d\x62\xab\xf8\x52\x6c\x13\x5f\xe9\x3b\x71\x62\xa7\xbe\xe3\x23\xf6\x88\xbd\x62\x9f\xf8\x5a\x7c\x23\xf6\x8b\x6f\xf5\x1d\x0a\x71\x48\x7c\x27\xbe\x17\x3f\x88\xc3\xfa\x5a\xbb\xbe\x72\x2e\x7e\x12\x3f\x8b\xff\xe9\xeb\xd4\xe2\x84\xf8\x55\x9c\x14\xbf\x89\x53\xe2\xb4\xbe\xda\x2a\xce\x89\xf3\xe2\x77\xf1\x87\xb8\x20\x2e\x8a\x4b\xa2\x42\x54\x0a\x5b\x38\x24\x93\x20\xb9\x14\x52\x4a\x25\x0d\x69\x4a\x4b\xfa\x48\x5f\xe9\x27\xfd\x65\x80\x0c\x94\x41\x32\x58\x86\xc8\x50\x19\x26\xc3\x65\x84\xac\x25\x23\x65\x6d\x19\x25\xeb\xc8\xba\xb2\x9e\x8c\x96\x31\xb2\xbe\x8c\x95\x0d\x64\x43\x19\x27\x1b\xc9\xc6\xb2\x89\x6c\x2a\x9b\xc9\xe6\xb2\x85\x8c\x97\x2d\x65\x2b\x99\x20\x13\x65\x6b\xd9\x46\x26\xc9\x64\xd9\x56\xa6\xc8\x6b\x64\x3b\xd9\x5e\xa6\xca\x0e\xf2\x5a\xd9\x51\x76\x92\x9d\x65\x9a\x4c\x97\x5d\x64\x57\xd9\x4d\x66\xc8\xeb\x64\x77\xd9\x43\xf6\x94\xbd\x64\x6f\xd9\x47\xf6\x95\xfd\x64\x7f\x39\x40\x0e\x94\xd7\xcb\x41\x72\xb0\x1c\x22\x87\xca\x61\x72\xb8\x1c\x21\x47\xca\x51\x72\xb4\x1c\x23\x33\xe5\x58\x39\x4e\x8e\x97\x59\x72\x82\xcc\x96\x39\x32\x57\xe6\xc9\x89\x32\x5f\x16\xc8\x49\x72\xb2\x9c\x22\xa7\xca\x42\x59\x24\x8b\xe5\x34\x59\x22\x4b\x65\x99\x9c\x2e\x67\xc8\x99\x72\x96\x9c\x2d\x6f\x90\x73\xe4\x8d\x72\xae\x9c\x27\xe7\xcb\x05\x72\xa1\xbc\x49\xde\x2c\x6f\x91\xb7\xca\xdb\xe4\xed\xb2\x5c\xde\x21\xef\x94\x8b\xe4\x5d\xf2\x6e\x79\x8f\x5c\x2c\xef\x95\xf7\xc9\x25\xf2\x7e\xf9\x80\x7c\x50\x3e\x24\x1f\x96\x4b\xe5\x23\xf2\x51\xb9\x4c\x3e\x26\x1f\x97\x4f\xc8\xe5\x72\x85\x7c\x52\xae\x94\x4f\xc9\xa7\xe5\x33\xf2\x59\xf9\x9c\x7c\x5e\xbe\x20\x5f\x94\x2f\xc9\x97\xe5\x2b\xf2\x55\xf9\x9a\x7c\x5d\xae\x92\x6f\xc8\x37\xe5\x6a\xf9\x96\x7c\x5b\xbe\x23\xd7\xc8\x77\xe5\x7b\xf2\x7d\xf9\x81\xfc\x50\x7e\x24\x3f\x96\x9f\xc8\xb5\x72\x9d\xfc\x54\xae\x97\x1b\xe4\x67\x72\xa3\xdc\x24\x3f\x97\x5f\xc8\xcd\x72\x8b\xdc\x2a\xbf\x94\xdb\xe4\x57\x72\xbb\xdc\x21\x77\xca\x5d\x72\xb7\xdc\x23\xf7\xca\x7d\xf2\x6b\xf9\x8d\xdc\x2f\xbf\x95\x07\xe4\x41\x79\x48\x7e\x27\xbf\x97\x3f\xc8\xc3\xf2\x88\x3c\x2a\x7f\x94\xc7\xe4\x4f\xf2\x67\xf9\x3f\xf9\x8b\x3c\x2e\x4f\xc8\x5f\xe5\x49\xf9\x9b\x3c\x25\x4f\xcb\x33\xf2\xac\x3c\x27\xcf\xcb\xdf\xe5\x1f\xf2\x82\xbc\x28\x2f\xc9\x0a\x59\x29\x6d\xe9\x50\x4c\x81\xe2\x4a\x28\xa9\x94\x32\x94\xa9\x2c\xe5\xa3\x7c\x95\x9f\xf2\x57\x01\x2a\x50\x05\xa9\x60\x15\xa2\x42\x55\x98\x0a\x57\x11\xaa\x96\x8a\x54\xb5\x55\x94\xaa\xa3\xea\xaa\x7a\x2a\x5a\xc5\xa8\xfa\x2a\x56\x35\x50\x0d\x55\x9c\x6a\xa4\x1a\xab\x26\xaa\xa9\x6a\xa6\x9a\xab\x16\x2a\x5e\xb5\x54\xad\x54\x82\x4a\x54\xad\x55\x1b\x95\xa4\x92\x55\x5b\x95\xa2\xae\x51\xed\x54\x7b\x95\xaa\x3a\xa8\x6b\x55\x47\xd5\x49\x75\x56\x69\x2a\x5d\x75\x51\x5d\x55\x37\x95\xa1\xae\x53\xdd\x55\x0f\xd5\x53\xf5\x52\xbd\x55\x1f\xd5\x57\xf5\x53\xfd\xd5\x00\x35\x50\x5d\xaf\x06\xa9\xc1\x6a\x88\x1a\xaa\x86\xa9\xe1\x6a\x84\x1a\xa9\x46\xa9\xd1\x6a\x8c\xca\x54\x63\xd5\x38\x35\x5e\x65\xa9\x09\x2a\x5b\xe5\xa8\x5c\x95\xa7\x26\xaa\x7c\x55\xa0\x26\xa9\xc9\x6a\x8a\x9a\xaa\x0a\x55\x91\x2a\x56\xd3\x54\x89\x2a\x55\x65\x6a\xba\x9a\xa1\x66\xaa\x59\x6a\xb6\xba\x41\xcd\x51\x37\xaa\xb9\x6a\x9e\x9a\xaf\x16\xa8\x85\xea\x26\x75\xb3\xba\x45\xdd\xaa\x6e\x53\xb7\xab\x72\x75\x87\xba\x53\x2d\x52\x77\xa9\xbb\xd5\x3d\x6a\xb1\xba\x57\xdd\xa7\x96\xa8\xfb\xd5\x03\xea\x41\xf5\x90\x7a\x58\x2d\x55\x8f\xa8\x47\xd5\x32\xf5\x98\x7a\x5c\x3d\xa1\x96\xab\x15\xea\x49\xb5\x52\x3d\xa5\x9e\x56\xcf\xa8\x67\xd5\x73\xea\x79\xf5\x82\x7a\x51\xbd\xa4\x5e\x56\xaf\xa8\x57\xd5\x6b\xea\x75\xb5\x4a\xbd\xa1\xde\x54\xab\xd5\x5b\xea\x6d\xf5\x8e\x5a\xa3\xde\x55\xef\xa9\xf7\xd5\x07\xea\x43\xf5\x91\xfa\x58\x7d\xa2\xd6\xaa\x75\xea\x53\xb5\x5e\x6d\x50\x9f\xa9\x8d\x6a\x93\xfa\x5c\x7d\xa1\x36\xab\x2d\x6a\xab\xfa\x52\x6d\x53\x5f\xa9\xed\x6a\x87\xda\xa9\x76\xa9\xdd\x6a\x8f\xda\xab\xf6\xa9\xaf\xd5\x37\x6a\xbf\xfa\x56\x1d\x50\x07\xd5\x21\xf5\x9d\xfa\x5e\xfd\xa0\x0e\xab\x23\xea\xa8\xfa\x51\x1d\x53\x3f\xa9\x9f\xd5\xff\xd4\x2f\xea\xb8\x3a\xa1\x7e\x55\x27\xd5\x6f\xea\x94\x3a\xad\xce\xa8\xb3\xea\x9c\x3a\xaf\x7e\x57\x7f\xa8\x0b\xea\xa2\xba\xa4\x2a\x54\xa5\xb2\x95\xc3\x60\x06\x18\xdc\xd0\xc7\xd6\x2a\xc3\x30\x4c\xc3\x32\x7c\x0c\x5f\xc3\xcf\xf0\x37\x02\x8c\x40\x23\xc8\x08\x36\x42\x8c\x50\x23\xcc\x08\x37\x22\x8c\x5a\x46\xa4\x51\xdb\x88\x32\xea\x18\x75\x8d\x7a\x46\xb4\x11\x63\xd4\x37\x62\x8d\x06\x46\x43\x23\xce\x68\x64\x34\x36\x9a\x18\x4d\x8d\x66\x46\x73\xa3\x85\x11\x6f\xb4\x34\x5a\x19\x09\x46\xa2\xd1\xda\x68\x63\x24\x19\xc9\x46\x5b\x23\xc5\xb8\xc6\x68\x67\xb4\x37\x52\x8d\x0e\xc6\xb5\x46\x47\xa3\x93\xd1\xd9\x48\x33\xd2\x8d\x2e\x46\x57\xa3\x9b\x91\x61\x5c\x67\x74\x37\x7a\x18\x3d\x8d\x5e\x46\x6f\xa3\x8f\xd1\xd7\xe8\x67\xf4\x37\x06\x18\x03\x8d\xeb\x8d\x41\xc6\x60\x63\x88\x31\xd4\x18\x66\x0c\x37\x46\x18\x23\x8d\x51\xc6\x68\x63\x8c\x91\x69\x8c\x35\xc6\x19\xe3\x8d\x2c\x63\x82\x91\x6d\xe4\x18\xb9\x46\x9e\x31\xd1\xc8\x37\x0a\x8c\x49\xc6\x64\x63\x8a\x31\xd5\x28\x34\x8a\x8c\x62\x63\x9a\x51\x62\x94\x1a\x65\xc6\x74\x63\x86\x31\xd3\x98\x65\xcc\x36\x6e\x30\xe6\x18\x37\x1a\x73\x8d\x79\xc6\x7c\x63\x81\xb1\xd0\xb8\xc9\xb8\xd9\xb8\xc5\xb8\xd5\xb8\xcd\xb8\xdd\x28\x37\xee\x30\xee\x34\x16\x19\x77\x19\x77\x1b\xf7\x18\x8b\x8d\x7b\x8d\xfb\x8c\x25\xc6\xfd\xc6\x03\xc6\x83\xc6\x43\xc6\xc3\xc6\x52\xe3\x11\xe3\x51\x63\x99\xf1\x98\xf1\xb8\xf1\x84\xb1\xdc\x58\x61\x3c\x69\xac\x34\x9e\x32\x9e\x36\x9e\x31\x9e\x35\x9e\x33\x9e\x37\x5e\x30\x5e\x34\x5e\x32\x5e\x36\x5e\x31\x5e\x35\x5e\x33\x5e\x37\x56\x19\x6f\x18\x6f\x1a\xab\x8d\xb7\x8c\xb7\x8d\x77\x8c\x35\xc6\xbb\xc6\x7b\xc6\xfb\xc6\x07\xc6\x87\xc6\x47\xc6\xc7\xc6\x27\xc6\x5a\x63\x9d\xf1\xa9\xb1\xde\xd8\x60\x7c\x66\x6c\x34\x36\x19\x9f\x1b\x5f\x18\x9b\x8d\x2d\xc6\x56\xe3\x4b\x63\x9b\xf1\x95\xb1\xdd\xd8\x61\xec\x34\x76\x19\xbb\x8d\x3d\xc6\x5e\x63\x9f\xf1\xb5\xf1\x8d\xb1\xdf\xf8\xd6\x38\x60\x1c\x34\x0e\x19\xdf\x19\xdf\x1b\x3f\x18\x87\x8d\x23\xc6\x51\xe3\x47\xe3\x98\xf1\x93\xf1\xb3\xf1\x3f\xe3\x17\xe3\xb8\x71\xc2\xf8\xd5\x38\x69\xfc\x66\x9c\x32\x4e\x1b\x67\x8c\xb3\xc6\x39\xe3\xbc\xf1\xbb\xf1\x87\x71\xc1\xb8\x68\x5c\x32\x2a\x8c\x4a\xc3\x36\x1c\x26\x33\xc1\xe4\xa6\x30\xa5\xa9\x4c\xc3\x34\x4d\xcb\xf4\x31\x7d\x4d\x3f\xd3\xdf\x0c\x30\x03\xcd\x20\x33\xd8\x0c\x31\x43\xcd\x30\x33\xdc\x8c\x30\x6b\x99\x91\x66\x6d\x33\xca\xac\x63\xd6\x35\xeb\x99\xd1\x66\x8c\x59\xdf\x8c\x35\x1b\x98\x0d\xcd\x38\xb3\x91\xd9\xd8\x6c\x62\x36\x35\x9b\x99\xcd\xcd\x16\x66\xbc\xd9\xd2\x6c\x65\x26\x98\x89\x66\x6b\xb3\x8d\x99\x64\x26\x9b\x6d\xcd\x14\xf3\x1a\xb3\x9d\xd9\xde\x4c\x35\x3b\x98\xd7\x9a\x1d\xcd\x4e\x66\x67\x33\xcd\x4c\x37\xbb\x98\x5d\xcd\x6e\x66\x86\x79\x9d\xd9\xdd\xec\x61\xf6\x34\x7b\x99\xbd\xcd\x3e\x66\x5f\xb3\x9f\xd9\xdf\x1c\x60\x0e\x34\xaf\x37\x07\x99\x83\xcd\x21\xe6\x50\x73\x98\x39\xdc\x1c\x61\x8e\x34\x47\x99\xa3\xcd\x31\x66\xa6\x39\xd6\x1c\x67\x8e\x37\xb3\xcc\x09\x66\xb6\x99\x63\xe6\x9a\x79\xe6\x44\x33\xdf\x2c\x30\x27\x99\x93\xcd\x29\xe6\x54\xb3\xd0\x2c\x32\x8b\xcd\x69\x66\x89\x59\x6a\x96\x99\xd3\xcd\x19\xe6\x4c\x73\x96\x39\xdb\xbc\xc1\x9c\x63\xde\x68\xce\x35\xe7\x99\xf3\xcd\x05\xe6\x42\xf3\x26\xf3\x66\xf3\x16\xf3\x56\xf3\x36\xf3\x76\xb3\xdc\xbc\xc3\xbc\xd3\x5c\x64\xde\x65\xde\x6d\xde\x63\x2e\x36\xef\x35\xef\x33\x97\x98\xf7\x9b\x0f\x98\x0f\x9a\x0f\x99\x0f\x9b\x4b\xcd\x47\xcc\x47\xcd\x65\xe6\x63\xe6\xe3\xe6\x13\xe6\x72\x73\x85\xf9\xa4\xb9\xd2\x7c\xca\x7c\xda\x7c\xc6\x7c\xd6\x7c\xce\x7c\xde\x7c\xc1\x7c\xd1\x7c\xc9\x7c\xd9\x7c\xc5\x7c\xd5\x7c\xcd\x7c\xdd\x5c\x65\xbe\x61\xbe\x69\xae\x36\xdf\x32\xdf\x36\xdf\x31\xd7\x98\xef\x9a\xef\x99\xef\x9b\x1f\x98\x1f\x9a\x1f\x99\x1f\x9b\x9f\x98\x6b\xcd\x75\xe6\xa7\xe6\x7a\x73\x83\xf9\x99\xb9\xd1\xdc\x64\x7e\x6e\x7e\x61\x6e\x36\xb7\x98\x5b\xcd\x2f\xcd\x6d\xe6\x57\xe6\x76\x73\x87\xb9\xd3\xdc\x65\xee\x36\xf7\x98\x7b\xcd\x7d\xe6\xd7\xe6\x37\xe6\x7e\xf3\x5b\xf3\x80\x79\xd0\x3c\x64\x7e\x67\x7e\x6f\xfe\x60\x1e\x36\x8f\x98\x47\xcd\x1f\xcd\x63\xe6\x4f\xe6\xcf\xe6\xff\xcc\x5f\xcc\xe3\xe6\x09\xf3\x57\xf3\xa4\xf9\x9b\x79\xca\x3c\x6d\x9e\x31\xcf\x9a\xe7\xcc\xf3\xe6\xef\xe6\x1f\xe6\x05\xf3\xa2\x79\xc9\xac\x30\x2b\x4d\xdb\x74\x58\x8c\xbd\xc1\xde\xb4\xc0\xe2\x96\x60\x6f\xb3\x77\xd8\x7a\x4b\xb2\xd5\xec\x2d\xb6\xc1\x52\xec\x26\xb6\x8e\xdd\xce\x5e\xb2\x0c\xcb\xb4\x2c\xcb\xc7\xf2\xb5\xfc\xd8\x67\x96\xbf\x15\x60\x05\xb2\x8f\xd8\xc7\x56\x90\x15\xcc\x3e\xb0\x42\xac\x50\x2b\xcc\x0a\xb7\x22\xac\x5a\x56\xa4\x55\xdb\x8a\xb2\xea\x58\x75\xad\x7a\x56\xb4\x15\x63\xd5\xb7\x62\xad\x06\x56\x43\x2b\xce\x6a\xc4\x7e\xb7\x1a\x5b\x4d\xac\xa6\x56\x33\xab\xb9\xd5\xc2\x8a\xb7\x5a\x5a\xad\xac\x04\x2b\xd1\x6a\x6d\xb5\xb1\x92\xac\x64\xab\xad\x95\x62\x5d\x63\xb5\xb3\xda\x5b\xa9\x56\x07\xeb\x5a\x76\x97\xd5\xd1\xea\x64\x75\xb6\xd2\xac\x74\xab\x8b\xd5\xd5\xea\x66\x65\x58\xd7\x59\xdd\xad\x1e\x56\x4f\xab\x97\xd5\xdb\xea\x63\xf5\xb5\xfa\xb1\xa5\x56\x7f\xf6\x28\x7b\x84\x9d\xb4\x06\xb0\x4f\xd9\x33\x6c\x89\x35\xd0\xba\x9e\x3d\xc6\x9e\x63\x8b\xad\x41\xec\x01\xf6\xa0\x35\xd8\x1a\x62\x0d\xb5\x86\x59\xc3\xad\x11\xd6\x48\x6b\x94\x35\xda\x1a\x63\x65\x5a\x63\xad\x71\xd6\x78\x2b\xcb\x9a\x60\x65\x5b\x39\x56\xae\x95\x67\x4d\xb4\xf2\xad\x02\x6b\x92\x35\xd9\x9a\x62\x4d\xb5\x0a\xad\x22\xab\xd8\x9a\x66\x95\x58\xa5\x56\x99\x35\xdd\x9a\x61\xcd\xb4\x66\x59\xb3\xad\x1b\xac\x39\xd6\x8d\xd6\x5c\x6b\x9e\x35\xdf\x5a\x60\x2d\xb4\x6e\xb2\x6e\xb6\x6e\xb1\x6e\xb5\x6e\xb3\x6e\xb7\xca\xad\x3b\xac\x3b\xad\x45\xd6\x5d\xd6\xdd\xd6\x3d\xd6\x62\xf6\xae\x75\xaf\x75\x9f\xb5\xc4\xba\xdf\x7a\xc0\x7a\xd0\x7a\xc8\x7a\xd8\x5a\x6a\x3d\x62\x3d\x6a\x2d\xb3\x1e\xb3\x1e\xb7\x9e\xb0\x96\x5b\x2b\xac\x27\xad\x95\xd6\x53\xd6\xd3\xd6\x33\xd6\xb3\xd6\x73\xd6\xf3\xd6\x0b\xd6\x8b\xd6\x4b\xd6\xcb\xd6\x2b\xd6\xab\xd6\x6b\xd6\xeb\xd6\x2a\xeb\x0d\xeb\x4d\x6b\xb5\xf5\x96\xf5\xb6\xf5\x8e\xb5\xc6\x7a\xd7\x7a\xcf\x7a\xdf\xfa\xc0\xfa\xd0\xfa\xc8\xfa\xd8\xfa\xc4\x5a\x6b\xad\xb3\x3e\xb5\xd6\x5b\x1b\xac\xcf\xac\x8d\xd6\x26\xeb\x73\xeb\x0b\x6b\xb3\xb5\xc5\xda\x6a\x7d\x69\x6d\xb3\xbe\xb2\xb6\x5b\x3b\xac\x9d\xd6\x2e\x6b\xb7\xb5\xc7\xda\x6b\xed\xb3\xbe\xb6\xbe\xb1\xf6\x5b\xdf\x5a\x07\xac\x83\xd6\x21\xeb\x3b\xeb\x7b\xeb\x07\xeb\xb0\x75\xc4\xfa\x7f\xd8\x7b\x17\x38\xb7\x8a\xf3\x7c\xf8\xdc\xa4\xd5\x68\x2f\x5e\x1b\x07\x6c\xc7\x5c\x92\x3f\x25\x40\x28\xb5\xce\x19\xdd\x08\xa5\xe8\x72\x86\x9b\x83\x29\x60\x62\x08\x01\xe4\x5d\xad\x57\x58\xbb\x5a\xef\xc5\x18\x42\x0c\xa5\x34\xa5\x14\x02\xa5\x94\x52\x97\xa6\x94\xd2\x60\x08\x4d\x53\xd7\x75\xd3\xd4\xa5\x84\x24\xd8\x49\xbc\x26\x80\x21\x14\x03\xb1\xc1\xc6\x06\x0c\x36\x60\xcc\xa5\xe0\xfd\xde\x99\xf3\x48\x3a\x3a\xab\x35\xeb\xa4\xe9\x97\x7e\xdf\xdf\xfe\xcd\x3b\x97\x33\xf3\x3e\xef\xbc\x33\x3a\xcf\x3b\xd2\xd1\x6a\x7b\xe4\xe5\xc8\x8e\xc8\xce\xc8\x2b\x91\x57\x23\xaf\x45\x76\x45\x5e\x8f\xbc\x11\xd9\x1d\xd9\x13\x79\x33\xf2\x56\xe4\xed\xc8\xde\xc8\x3b\x91\x7d\x91\x77\x23\xef\x45\xde\x8f\x7c\x10\xf9\xaf\xc8\x87\x91\x8f\x22\xfb\x23\x63\x4c\x63\x3a\x33\x98\xc9\x2c\x16\x62\x61\xd6\xc2\x22\x8c\xb1\x28\x6b\x65\x6d\xac\x9d\x75\xb0\x29\xac\x93\x4d\x65\xd3\xd8\x21\x6c\x3a\xfb\x04\x3b\x94\x1d\xc6\x66\xb0\x99\x6c\x16\xfb\x24\x9b\xcd\x0e\x67\x47\xb0\x23\xd9\x51\xec\x53\xec\xd3\xec\xff\xb0\xa3\xd9\x6f\xb0\x63\xd8\x67\xd8\xb1\xec\x38\x76\x3c\xfb\x2c\x3b\x81\xfd\x26\x3b\x91\xfd\x16\x9b\xc3\x62\xcc\x66\x0e\xe3\x2c\xce\x12\x2c\xc9\x52\x2c\xcd\x4e\x62\x9f\x63\x27\xb3\xdf\x66\xa7\xb0\xdf\x61\xa7\xb2\x0c\xcb\xb2\x1c\xcb\x33\x97\x09\x76\x1a\x3b\x9d\x9d\xc1\xce\x64\x67\xb1\xb9\xec\xf3\xec\x6c\x36\x8f\x9d\xc3\x7e\x97\x9d\xcb\xce\x63\xe7\xb3\xf9\xec\x02\xf6\x05\xb6\x80\x5d\xc8\x2e\x62\x5f\x64\x17\xb3\x2f\xb1\x4b\xd8\xa5\xec\x32\x56\x60\x0b\x59\x17\xeb\x66\x45\xd6\xc3\x16\xb1\x5e\x56\x62\x97\xb3\xc5\xac\xcc\xfa\x58\x3f\xab\xb0\x01\xb6\x84\x0d\xb2\x21\x36\xcc\x46\xd8\x52\x76\x05\x5b\xc6\xae\x64\x57\xb1\x2f\xb3\xab\xd9\x57\xd8\x72\x76\x0d\xbb\x96\xfd\x1e\xbb\x8e\xfd\x3e\xbb\x9e\xfd\x01\xfb\x2a\xfb\x43\x76\x03\xfb\x23\x76\x23\xfb\x63\x76\x13\xbb\x99\x7d\x8d\xdd\xc2\x6e\x65\x7f\xc2\x6e\x63\x7f\xca\x6e\x67\x7f\xc6\xee\x60\x7f\xce\xee\x64\x7f\xc1\x56\xb0\xbf\x64\x77\xb1\xbf\x62\x5f\x67\x7f\xcd\xee\x66\x7f\xc3\xee\x61\x7f\xcb\xee\x65\x7f\xc7\xbe\xc1\xee\x63\x2b\xd9\xfd\xec\x01\xf6\x4d\xf6\x20\xfb\x7b\xf6\x2d\xf6\x0f\xec\xdb\xec\x1f\xd9\x2a\xf6\x4f\x6c\x35\xfb\x67\xb6\x86\xfd\x0b\xfb\x0e\xfb\x57\xf6\x5d\xf6\x6f\x6c\x2d\xfb\x77\xf6\x10\xfb\x0f\xf6\x30\xfb\x1e\x7b\x84\x7d\x9f\xfd\x80\xfd\x90\x3d\xca\xd6\xb1\xf5\xec\x47\xec\xc7\xec\x27\x6c\x03\x1b\x65\x1b\xd9\x63\xec\xa7\xec\x71\xf6\x04\x7b\x92\x6d\x62\x4f\xb1\xa7\xd9\xcf\xd8\x33\xec\x3f\xd9\xb3\x6c\x33\x7b\x8e\x3d\xcf\x5e\x60\x3f\x67\x5b\xd8\x56\xf6\x22\x7b\x89\x6d\x63\xdb\xd9\xcb\x6c\x07\xdb\xc9\x5e\x61\xaf\xb2\xd7\xd8\x2e\xf6\x3a\x7b\x83\xed\x66\x7b\xd8\x9b\xec\x2d\xf6\x36\xdb\xcb\xde\x61\xfb\xd8\xbb\xec\x3d\xf6\x3e\xfb\x80\xfd\x17\xfb\x90\x7d\xc4\xf6\xb3\xb1\xa8\x16\xd5\xa3\x46\xd4\x8c\x5a\xd1\x50\x34\x1c\x6d\x89\x46\xa2\x2c\x1a\x8d\xb6\x46\xdb\xa2\xed\xd1\x8e\xe8\x94\x68\x67\x74\x6a\x74\x5a\xf4\x90\xe8\xf4\xe8\x27\xa2\x87\x46\x0f\x8b\xce\x88\xce\x8c\xce\x8a\x7e\x32\x3a\x3b\x7a\x78\xf4\x88\x96\x91\xfe\xd2\x9c\x39\x99\x39\xc8\xf3\xac\xb2\xb4\x38\x38\xd4\x55\x19\x2c\x9a\x7d\x23\xb1\x70\x5f\xa9\xbb\xbb\x32\xdc\x92\xe9\x93\xef\x35\xf7\xb7\x14\xbc\x3c\x9c\x59\x38\x58\x5c\x5a\x0c\x17\x54\xd6\x92\xa9\x2c\xaa\xf4\x17\x17\xb7\x14\xbc\xbc\x35\xd7\x55\x1a\xec\x1a\xe9\xeb\x29\x17\x97\xb5\x76\xd5\xcb\xd1\x1c\xa9\x2a\x74\x75\x15\xfb\x87\xa3\x5d\xb5\x62\x38\xdf\x55\x90\x2a\xbb\xbd\x2c\x4f\xfa\x0b\xc3\x2d\x2e\x00\x8b\x00\x74\x3d\xc0\xa2\xca\xa2\x6e\x5d\x51\xb1\x56\x6c\x71\x61\x46\xd1\xcb\xc3\xae\xa7\xb1\xa8\xb2\xd6\xd3\x7c\x46\x2d\xf2\x19\x75\x5a\x5d\xd7\xa2\x5a\xb1\xed\xb4\xae\x4a\x5f\x5f\x01\x95\x45\xbe\x4a\xeb\xe9\x3e\x3d\xbd\xf5\xb2\x75\xfa\xc2\xc2\xa0\xd5\x4b\x22\x7c\xc6\x70\xa9\xdc\x5d\x0c\x97\x54\xd6\x72\x06\x66\x52\xc2\x4c\xce\xf0\x66\x52\xf2\x5c\x77\x06\x6c\x2e\x79\xb9\x71\xc6\x99\x46\xe9\xf2\xd6\x33\x7d\x18\x97\xd7\xcb\x6d\x67\xf9\xad\x5a\xdc\x50\x59\x24\x3f\xba\x28\x17\xfa\xbb\x4b\x5d\xe1\xb9\x85\xae\x91\xe1\x62\xb8\xac\xb2\xb6\xb9\xfe\x7e\x65\x5f\x25\x3c\xd7\x73\x50\x59\x65\xd6\x5c\x9a\xbd\x55\x26\x11\x3e\xdb\x1b\xdf\xef\x8d\x3f\xdb\x3f\xbe\xdf\x3f\xfe\x6c\x6f\x7c\xbf\xe7\xe0\xfe\xc2\x40\x65\x68\x78\xb0\x32\xd0\x5b\x34\xdd\xfe\x45\x66\xb1\x7f\x51\xcb\x3c\x4c\xbe\x82\xc9\xcf\xf3\x26\x5f\x51\x59\xfb\xbc\xde\x91\xfe\x45\x85\xc1\x91\xbe\x72\x61\x64\xb8\xbd\xe2\xaf\x85\xcf\xf5\x6c\x18\xf4\x6c\x38\xd7\x6f\xc3\xa0\xdf\x86\x73\x3d\x1b\x06\xbd\xec\x3c\x6f\xd4\x90\xca\x5a\xcf\xf3\xb9\x71\xc8\xe7\xc6\xf3\xfd\xda\x86\xfd\xda\xce\xf7\xd4\x0c\x7b\x1e\x39\x5f\x2e\xe9\xb0\x5c\xd2\xf9\xde\x92\x8e\x78\x4b\x3a\x1f\xb3\x1a\xc1\xac\xe6\x7b\xb3\x1a\x51\x59\x68\xfe\x60\xa9\x7f\x51\x68\x44\xca\xf6\xf9\x0d\x33\x1c\xf1\xd7\x5a\xe6\x63\xe9\x47\xf0\xaa\xf9\x82\xcf\xda\x2b\x7c\xe5\x0b\x7d\xe5\x2b\xeb\xe5\xf0\x45\xde\x5c\xaf\x52\x59\xf4\xa2\xfa\x36\xbe\xaa\x56\x0c\x95\x2b\xfd\x8b\x86\xd4\x4b\x3b\x96\x9a\x83\x3c\x86\xdc\x46\xee\x20\xe7\xc8\xe3\xc8\x13\xc8\x93\xc8\x53\xc8\xd3\xc8\x33\xc8\xb3\xc8\x73\xc8\xf3\xc8\x5d\xe4\xc2\xcb\xd3\xc0\x4f\x03\x3f\x0d\xdc\x34\x70\xd3\xc0\x4d\x03\x37\x0d\xdc\x34\x70\xd3\xc0\x4d\x03\x37\x0d\xdc\x34\x70\xd3\xc0\x4d\x03\x37\x2d\x42\xf3\x7a\x2b\x83\x74\xfc\x94\xd2\x6b\xcb\x60\xce\x19\x60\x67\x80\x9d\x01\x76\x06\xd8\x19\x60\x67\x80\x9d\x01\x76\x06\xd8\x19\x60\x67\x80\x9d\x01\x76\xc6\x0d\xcd\x57\x98\x23\x75\xcc\x2c\xe6\x9b\x05\x76\x16\xd8\x59\x60\x67\x81\x9d\x05\x76\x16\xd8\x59\x60\x67\x81\x9d\x05\x76\x16\xd8\x59\x60\x67\x81\x9d\xc5\xbc\xb3\xf0\x77\x0e\xfe\xce\x01\x3f\x07\xfc\x1c\xf0\x73\xc0\xcf\x01\x3f\x07\xfc\x1c\xf0\x73\xc0\xcf\x01\x3f\x07\xfc\x1c\xf0\x73\xc0\xcf\x01\x3f\x07\xfc\x1c\xf0\xf3\xc0\xcf\x03\x3f\x0f\xfc\x3c\xf0\xf3\xc0\xcf\x03\x3f\x0f\xfc\x3c\xf0\xf3\xc0\xcf\x03\x3f\x0f\xfc\x3c\xf0\xf3\xc0\xcf\x03\x3f\x0f\xfc\x3c\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x05\xf0\x45\x3a\x9a\x91\xf7\x12\xef\x65\x5e\xa8\x15\x5b\x32\xae\x97\x17\x8a\xde\xdd\x6e\xde\x50\xb9\x30\xd4\xeb\x95\x2b\xf5\xb2\xd2\x62\xcf\x99\x83\x3c\x86\xdc\x46\xee\x20\xe7\xc8\xe3\xc8\x13\xc8\x93\xc8\x53\xc8\xd3\xc8\x33\xc8\xb3\xc8\x73\xc8\xf3\xc8\x5d\xe4\x9e\x37\xec\x18\xf0\x63\xc0\x8f\x01\x3f\x06\xfc\x18\xf0\x63\xc0\x8f\x01\x3f\x96\x6c\x3b\xcf\x7f\xb7\x1e\xf2\x55\xd0\x03\x96\xc4\x60\x49\x0c\x96\xc4\x60\x49\x0c\x96\xc4\x60\x89\x0d\x4b\x6c\x58\x62\xc3\x12\x1b\x96\xd8\xb0\xc4\x86\x25\x36\x2c\xb1\xe1\x09\x1b\x9e\xb0\xe1\x09\x1b\xf8\x36\xf0\x6d\xe0\xdb\xc0\xb7\x81\x6f\x03\xdf\x01\xbe\x03\x7c\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x12\xec\xf2\x13\xe9\x8e\x5e\x2e\x0e\x0d\xa1\x05\x16\x38\xb0\xc0\x81\x05\x0e\x2c\x70\x60\x81\x03\x0b\x1c\x58\xe0\xc0\x02\x0e\x0b\x38\x2c\xe0\xb0\x80\xc3\x02\x0e\x0b\x38\x2c\xe0\xf0\x00\x87\x07\x38\xf0\x39\xf0\x39\xf0\x39\xf0\x39\xf0\x39\xf0\x39\xf0\x39\xf0\xe3\xc0\x8f\x03\x3f\x0e\xfc\x38\xf0\xe3\xc0\x8f\x03\x3f\x0e\xfc\x38\xf0\xe3\xc0\x8f\x03\x3f\x0e\xfc\x38\xf0\xe3\xc0\x8f\x03\x3f\x0e\xfc\x38\xf0\x13\xc0\x4f\x00\x3f\x01\xfc\x04\xf0\x13\xc0\x4f\x00\x3f\x01\xfc\x04\xf0\x13\xc0\x4f\x00\x3f\x01\xfc\x04\xf0\x13\xc0\x4f\x00\x3f\x01\xfc\x04\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x11\x09\xd8\x88\x04\x6c\x44\x02\x36\x22\x01\x1b\x91\x80\x8d\x48\xc0\x46\x24\x60\x23\x12\xb0\x11\x09\xd8\x88\x04\x6c\x44\x02\x36\x22\x01\x1b\x91\x80\x8d\x48\xc0\x46\x24\x60\x23\x12\xb0\x11\x09\xd8\x88\x04\xec\x34\xf0\x11\x11\xd8\x88\x08\x6c\x44\x04\x36\x22\x02\x1b\x11\x81\x8d\x88\xc0\x46\x44\x60\x23\x22\xb0\x11\x11\xd8\x88\x08\x6c\x44\x04\x36\x22\x02\x3b\x0d\x7c\x1c\x76\xec\x0c\xf0\x11\x15\xd8\x88\x0a\x6c\x44\x05\x36\xa2\x02\x1b\x51\x81\x8d\xa8\xc0\x46\x54\x60\x23\x2a\xb0\x11\x15\xd8\x88\x0a\x6c\x44\x05\x36\xa2\x02\x3b\x03\xfc\x0c\xf0\xb3\xc0\x47\x64\x60\x23\x32\xb0\x11\x19\xd8\x88\x0c\x6c\x44\x06\x36\x22\x03\x1b\x91\x81\x8d\xc8\xc0\x46\x64\x60\x23\x32\xb0\x11\x19\xd8\x88\x0c\x6c\x44\x06\x36\x22\x03\x1b\x91\x81\x8d\xc8\xc0\x46\x64\x60\x23\x32\xb0\x11\x19\xd8\x88\x0c\x6c\x44\x06\x36\x22\x01\x1b\x11\x80\x8d\x08\xc0\x46\x04\x60\x23\x02\xb0\x11\x01\xd8\x88\x00\x6c\x44\x00\x36\x22\x00\x1b\x11\x80\x8d\x08\xc0\x46\x04\x60\x23\x02\xb0\x11\x01\xd8\x88\x00\x6c\x30\xba\x0d\x46\xb7\xc1\xe8\x36\x18\xdd\x06\xa3\xdb\x60\x74\x1b\x8c\x6e\x83\xd1\x6d\x30\xba\x0d\x46\xb7\xc1\xe8\x36\x18\xdd\x06\xa3\xdb\x60\x74\x1b\x8c\x6e\x83\xd1\x6d\x30\xba\x0d\x46\xb7\xc1\xe8\x36\x18\xdd\x06\xa3\xdb\x60\x74\x1b\x8c\x6e\x83\xd1\x6d\x30\xba\x0d\x46\xb7\xc1\xe8\xb6\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x10\x6c\xd1\x60\x61\x69\x91\xa8\x6f\x21\x53\x9c\x2e\x4b\xea\x9a\x33\xc7\x66\xea\x4c\xe2\x6b\xe1\xc8\xe3\xc8\x13\xc8\x93\xc8\x53\xed\xbd\x95\xca\xe2\xc2\xc2\xca\x52\xff\xa8\x0c\xf2\x2c\xf2\x1c\xf2\x3c\x72\x17\xb9\xe7\x0b\x07\x7c\xee\x80\xcf\x1d\xf0\xb9\x03\x3e\x77\xc0\xe7\x0e\xf8\xdc\x01\x9f\x3b\x31\x58\x11\x4b\x21\x4f\x23\x07\x3e\x58\xdc\x01\x8b\x3b\x60\x71\x07\x2c\xee\x80\xc5\x1d\xb0\xb8\x03\x16\x77\x6c\xbb\x8d\x38\x72\x61\xb1\x5c\xb9\xa2\x3e\x29\x50\xb9\x03\x2a\x77\x40\xe5\x0e\xa8\xdc\x01\x95\x3b\xa0\x72\x07\x54\xee\x80\xca\x1d\x50\xb9\x03\x2a\x77\x40\xe5\x0e\xa8\xdc\x01\x95\x3b\xa0\x72\x07\x54\xee\x80\xca\x1d\x50\xb9\x03\x2a\x77\x1c\xe0\x3b\xc0\x07\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x51\x3b\x20\x6a\x07\x44\xec\x80\x88\x1d\x10\xb1\x03\x22\x76\x92\x6e\x68\xb8\xd2\x5f\x19\x6a\xef\x2e\x15\x07\x8b\x43\xa5\x21\x55\x8b\x66\xca\x03\xbd\x05\x55\x64\x85\xfe\xca\x70\xb1\x5c\x2c\x15\xda\xdc\x81\xa1\x12\x9d\xde\x55\x73\xc4\x1d\xc6\xf5\x33\x2a\x28\xb5\xcd\xeb\x2b\xc9\xf7\x1e\xbc\xca\x7c\x5f\xe7\xe8\xbc\xbe\xe2\x22\xaf\xd3\xd4\x12\x75\x6f\xc0\x0a\x29\x2c\x2b\x5b\x1c\x2e\x84\x4e\x2b\x50\x24\xdd\x02\x1c\xeb\x22\x6a\x32\x09\x27\x74\x7e\x2f\x95\x2c\x09\x14\x3a\xab\x30\x30\x50\x08\xcf\x2d\xf4\x2d\xec\x2e\x18\x9f\x1f\x31\xce\x1e\x31\x16\x94\x5a\x80\x6c\x9c\x53\x32\xcf\xed\xad\x84\xce\x2b\x2d\xea\x2b\x98\xe7\x17\x46\x5a\x60\x85\x79\x4e\x6f\xc9\xcc\x51\x3a\x67\xa8\xd4\x76\x86\xcf\x82\x29\xe8\x50\xad\x47\x0b\xb5\x89\xb7\x15\xfd\xd3\x2d\x56\xa7\x5b\xaa\x4e\x77\xfa\x48\xe3\x50\x6f\x32\x6a\xbc\xb5\x50\x4e\x66\x91\x9c\x4c\xa8\xbb\x58\x1e\x2e\xb4\x40\x97\x75\x95\x9c\x92\xbc\x38\xac\xa6\x24\x95\x85\x16\xab\x29\x95\xbd\x29\xf5\x8f\x18\xcb\x4a\x2d\x15\x6f\x3e\xe6\x60\x6f\x25\x3c\x24\x27\x13\x0b\xa9\xcc\x1c\xa6\x39\x01\xd7\x1c\xa0\xf9\x74\x51\xa2\x6a\xa8\x22\x1d\xdc\xe6\xf7\xed\x94\x80\x79\x6d\x15\xff\xea\x8c\xf8\x57\xa7\x52\x5b\x1d\x6f\x4f\x80\x24\x1d\x90\xa4\x03\x92\x74\x40\x92\x0e\x48\xd2\x01\x49\x3a\x20\x49\x07\x24\xe9\xe0\x98\xec\xe0\x98\xec\xe0\x98\xec\xe0\x98\xec\xe0\x98\xec\xe0\x98\xec\x80\x54\x1d\x90\xaa\x03\x52\x75\x40\xaa\x0e\x48\xd5\x01\xa9\x3a\x20\x55\x07\xa4\xea\x80\x54\x1d\x90\xaa\x03\x52\x75\x40\xaa\x0e\x48\xd5\x01\xa9\x3a\x20\x55\x07\xa4\xea\x80\x54\x1d\x90\xaa\x03\x52\x75\x40\xaa\x0e\x48\xd5\x01\xa9\x3a\x20\x55\x07\xa4\xea\x80\x54\x1d\x90\xaa\x03\x52\x75\x40\xaa\x0e\x48\xd5\x01\xa9\x3a\x20\x55\x07\xa4\xea\x80\x54\x1d\xe1\xe1\x73\x1c\x8c\x39\x0e\xc6\x1c\x07\x63\x8e\x83\x31\x07\x9d\x72\xd0\x29\x07\x9d\x72\xd0\x29\xc7\xc1\x98\xe3\x60\xcc\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x41\xa4\x1c\x44\xca\x71\x1c\xe6\x38\x0e\x73\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x70\x28\x07\x87\x72\x1c\x86\x39\x0e\xc3\x1c\x87\x61\x8e\xc3\x30\x07\xc7\x72\x70\x2c\xc7\x61\x98\xe3\x30\xcc\x71\x18\xe6\x38\x0c\x73\x70\x30\x07\x07\x73\x70\x30\x07\x07\x73\x1c\x86\x39\x0e\xc3\x1c\x87\x61\x8e\xc3\x30\xc7\x61\x98\xe3\x30\xcc\x71\x18\xe6\x38\x0c\x73\x1c\x86\x39\x0e\xc3\x1c\x87\x61\x8e\xc3\x30\xc7\x61\x98\xe3\x30\xcc\x71\x18\xe6\x38\x0c\x73\x1c\x86\x39\x0e\xc3\x1c\x87\x61\x8e\xc3\x30\xc7\x61\x98\xe3\x30\xcc\x71\x18\xe6\x38\x0c\x73\x1c\x86\x39\x0e\xc3\x1c\x87\x61\x8e\xc3\x30\xc7\x61\x98\xe3\x30\xcc\x71\x18\xe6\x38\x0c\x73\x1c\x86\x39\x0e\xc3\x1c\x87\x61\x8e\xc3\x30\xc7\x61\x98\xe3\x30\xcc\x71\x18\xe6\x38\x0c\x73\x1c\x86\x39\x0e\xc3\x1c\x87\x61\x8e\xc3\x30\xc7\x61\x98\xe3\x30\xcc\x71\x18\xe6\x38\x0c\x73\x1c\x86\x39\x0e\xc3\x1c\x87\x61\x8e\xc3\x30\xc7\x61\x98\xe3\x30\xcc\x71\x18\xe6\x38\x0c\x73\x1c\x86\x39\x0e\xc3\x1c\x87\x61\x8e\xc3\x30\xc7\x61\x98\xe3\x30\xcc\x71\x18\xe6\x38\x0c\x73\x1c\x86\x39\x0e\xc3\x1c\x87\x61\x8e\xc3\x30\xc7\x61\x98\xe3\x30\xcc\x71\x18\xe6\x38\x0c\x73\xbc\x4d\xce\xf1\x36\x39\xc7\xe1\x98\xe3\x6d\x72\x8e\x43\x32\xc7\x21\x99\xe3\x90\xcc\x71\x48\xe6\x38\x24\x73\x1c\x92\x39\xf8\x9f\x83\xff\x39\xf8\x9f\x83\xff\x39\xf8\x9f\x83\xff\x39\xf8\x9f\x83\xff\x79\x3e\xc5\x0a\x3d\xa5\x52\x6c\x4e\xaa\x7a\x67\x42\x04\xc0\x11\x01\x70\x44\x00\x1c\x11\x00\x47\x04\xc0\x11\x01\x70\x44\x00\x1c\x11\x00\x47\x04\xc0\x11\x01\x70\x44\x00\x1c\x11\x00\x47\x04\xc0\x11\x01\x70\x44\x00\x1c\x11\x00\x47\x04\xc0\x11\x01\x70\x44\x00\x1c\x11\x00\x47\x04\xc0\x11\x01\x70\x44\x00\x1c\x11\x00\x47\x04\xc0\x11\x01\x70\x44\x00\x1c\x11\x00\x47\x04\xc0\x11\x01\x70\x44\x00\x1c\x11\x00\x47\x04\xc0\x11\x01\x70\x44\x00\x1c\x11\x00\x47\x04\xc0\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\x11\x01\xc4\xc1\xe8\x71\x30\x7a\x1c\x8c\x1e\x07\xa3\xc7\x71\xe7\x88\xe3\xce\x11\xc7\x9d\x23\x8e\x3b\x47\x1c\x77\x8e\x38\xee\x1c\x71\xdc\x39\xe2\xb8\x73\xc4\x71\xe7\x88\xe3\xce\x11\xc7\x9d\x23\x8e\x3b\x47\x3c\x5d\xc5\x81\xdd\xb8\x73\xc4\x71\xe7\x88\xe3\xce\x11\xc7\x9d\x23\x8e\x3b\x47\x1c\x77\x8e\x38\xee\x1c\x71\xdc\x39\xe2\xb8\x73\xc4\x71\xe7\x88\xe3\xce\x11\xc7\x9d\x23\x8e\x3b\x47\x1c\x77\x8e\x38\xee\x1c\x71\xdc\x39\xe2\x19\x11\x1a\xea\x2d\x2e\x2d\x44\xe9\xec\x50\xe8\x19\x2a\x2e\xaa\x94\xbd\xe2\x00\x89\xde\x56\x55\x5c\x52\xe8\x2b\x0c\x0f\x85\x7a\x4b\x83\xa5\x25\xa1\xe1\x21\x8a\xca\x43\xaa\x63\x48\xf5\x09\x57\x2f\x57\xe8\x20\xe0\x29\xcd\x66\xc2\x4b\x46\x16\x8e\x0c\x0f\x85\xbb\x0b\x8b\x8a\x43\xbd\xa1\xbe\xe2\x70\x71\x51\xa8\xaf\xb0\xa4\xd0\x63\x0d\x16\x7a\x8a\x34\x72\xa8\xb8\xa4\x45\x7e\xfd\x50\x7e\x44\x3e\xa4\xb2\xc8\x50\x85\x50\x87\x46\x96\xb0\x91\x81\x81\xe2\xe0\xa5\xb2\xa9\x5c\xb9\xa2\x38\x28\x9f\x99\x50\x7a\x73\x89\x56\x0f\x6c\x09\x01\xf7\x5b\x85\x72\xb1\xc7\xa4\x03\x4b\x68\x51\xa9\xaf\x58\x0e\x75\x53\x7d\xd8\xe8\x2d\x9a\x4b\x0b\x4b\x43\x57\x15\xae\x2c\xf5\x9b\x74\x54\x31\x87\x29\x5d\x59\xe9\x8e\xf4\x94\xfa\x0b\xe5\xc5\x85\x1e\x93\x52\x88\x4c\x2d\xa2\xa9\xaf\xd8\x67\x52\xf2\x2a\xfd\x23\xfd\x26\xa5\xf0\x10\x5d\x5f\xdc\x6b\x49\x25\x2d\xea\xc2\x40\xd1\x18\x28\x46\x55\x71\x78\x88\x8e\x2a\x21\x25\xcd\x25\x15\x9a\x10\xcd\xd0\x92\x53\xa1\x33\xce\xd2\x30\x81\x2f\xf5\x32\x02\x0d\x53\x92\xd9\x22\x79\x92\xe9\x65\x94\x0d\xf5\x92\x4e\xe5\xa6\x58\xde\x7b\xad\x50\x1e\x43\x6e\x23\x77\x90\x73\xe4\x71\xe4\x09\xe4\x49\xe4\x29\xe4\x69\xe4\x19\xe4\x59\xe4\x39\xe4\x79\xe4\x2e\x72\xe1\xe5\x31\xe0\xc7\x80\x1f\x03\x7e\x0c\xf8\x31\xe0\xc7\x80\x1f\x03\x7e\x0c\xf8\x31\xe0\xc7\x80\x1f\x03\x7e\x0c\xf8\x31\xe0\xc7\x80\x1f\x03\x7e\x0c\xf8\x36\xf0\x6d\xe0\xdb\xc0\xb7\x81\x6f\x03\xdf\x06\xbe\x0d\x7c\x1b\xf8\x36\xf0\x6d\xe0\xdb\xc0\xb7\x81\x6f\x03\xdf\x06\xbe\x0d\x7c\x1b\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x1c\xf8\x71\xe0\xc7\x81\x1f\x07\x7e\x1c\xf8\x71\xe0\xc7\x81\x1f\x07\x7e\x1c\xf8\x71\xe0\xc7\x81\x1f\x07\x7e\x1c\xf8\x71\xe0\xc7\x81\x1f\x07\x7e\x1c\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x39\xe0\xe7\x80\x9f\x03\x7e\x0e\xf8\x39\xe0\xe7\x80\x9f\x03\x7e\x0e\xf8\x39\xe0\xe7\x80\x9f\x03\xbe\x00\x8e\x17\x93\xc5\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x26\x45\xf8\x0b\xea\xb3\xce\xf0\x15\x5e\xf6\x05\xef\x21\xc7\x2b\x54\xc6\xbe\x50\x7d\x83\x9d\x5d\x51\x2d\x79\xe3\xc0\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\x5c\xf0\x8c\x0b\x9e\x71\xc1\x33\x2e\x78\xc6\x05\xcf\xb8\xe0\x19\x17\x3c\xe3\x82\x67\xdc\xb4\xcb\x32\xd5\xcf\x2b\x59\xa1\x5a\x8a\x66\x6a\x9f\xcc\x46\x0b\xb5\x62\x67\xa6\xfe\xd0\xa7\x72\x43\x67\x21\xd8\xe0\xeb\xa1\xdc\xe6\xef\xa1\x1a\xa6\xfb\x7a\xd4\x14\x4f\x2f\x34\x69\xf4\xeb\x52\x9f\x2c\xfb\x75\xa9\x86\x43\x7c\x3d\xaa\x96\x1f\x52\x18\xdf\xd6\xea\x3d\x24\xee\x3d\x90\x56\xf0\x95\xbd\x76\x65\x17\xda\x55\x79\x8a\xd7\x5e\xb3\x64\x4a\xa1\xb1\x8e\x71\xca\x06\x8c\x53\xe5\x0e\xaf\xbd\x0a\xdb\x51\x68\xa8\x32\xb7\x56\xaa\xb5\x45\xdd\xba\x9f\xeb\xfa\xc3\xae\xf7\x90\xaf\xa7\xb5\xd3\x0d\x3a\xb9\x18\x6c\x70\x83\x5e\x2f\x06\xbd\xee\x36\xf3\x7a\xb1\x99\xd7\xdd\xa0\xd7\x8b\x41\xaf\xbb\x4d\xbc\x5e\x1c\xdf\x16\x3d\xa3\x3e\xb7\x52\xad\xc8\xce\xa8\x79\xa1\x54\x2b\xcd\xab\x95\x2a\xb5\xd1\xf3\xea\xa3\x2b\x75\xeb\xe6\x05\xa7\x5e\x09\x36\xcc\x0b\xfa\xa2\x12\xf4\xc5\xbc\x66\xbe\xa8\x34\xf3\xc5\xbc\xa0\x2f\x2a\x41\x5f\xcc\x6b\xe2\x8b\x4a\x13\x5f\xa8\x07\x80\xbd\x07\x27\x2b\xf5\xa2\x6a\x55\x46\x79\xad\xaa\xd8\xa1\x5a\x6b\x46\x74\x54\x1a\xaa\xde\x18\x05\xee\x8d\x51\xc5\x76\xd5\x5a\x45\x6b\xaf\xf8\x6b\x6c\x7e\xad\x34\x52\xb3\x67\x7e\x5d\xe1\x48\xbd\x38\xbf\x6e\xda\x48\xbd\x38\xbf\x6e\xe5\x48\xdd\xca\xf9\x8d\x56\x8e\x34\x5a\x39\xbf\x6e\xe5\x48\xdd\xca\xf9\x0d\x56\x8e\xf8\x6b\xe1\x0b\xbd\xdb\xec\x95\x2a\x63\x17\xd6\x6c\xbe\xb2\x66\xf3\x85\x75\xf5\x57\xd6\x5f\x2b\x17\x7a\xaf\x95\x2b\xbd\x07\xe2\xe5\x3d\x4d\x20\x66\x13\x88\xd9\x04\x62\x36\x81\x98\x4d\x20\x66\x13\x88\xd9\x04\x62\x36\x81\x98\x4d\x20\x66\x13\x88\xd9\x04\x62\x36\x81\x98\x4d\x20\x66\x13\x88\xd9\x04\x62\x36\x81\x98\x4d\x20\x66\x13\x88\xd9\x04\x62\x36\x81\x98\x4d\x20\x66\x13\x88\xd9\x04\x62\x34\x81\x18\x4d\x20\x46\x13\x88\xd1\x04\x62\x34\x81\x18\x4d\x20\x26\x13\x88\xc9\x04\x62\x32\x81\x98\x4c\x20\x26\x13\x88\xc9\x04\x62\x32\x81\x98\x4c\x20\x26\x13\x88\xc9\x04\x62\x32\x81\x98\x4c\x20\x26\x13\x76\x15\x0f\xf3\x43\x4c\x26\x10\x93\x09\xc4\x64\x02\x31\x99\x40\x4c\x26\x10\x93\x09\xc4\x64\x02\x31\x99\x40\x4c\x26\x10\x93\x09\xc4\x64\x02\x31\x99\x40\x4c\x26\x10\x93\x09\xc4\x64\x02\x31\x99\x40\x4c\x26\x10\x93\x09\xc4\x64\x02\x31\x99\x40\x4c\x26\x10\x93\x09\xc4\x64\x02\x31\x98\x40\x0c\x26\x10\x83\x09\xc4\x60\x02\x31\x98\x40\x0c\x26\x10\x73\x09\xc4\x5c\x02\x31\x97\x40\xcc\x25\x10\x73\x09\xc4\x5c\x02\x31\x97\x40\xcc\x25\x10\x6b\x09\xc4\x58\x22\x5e\xd5\x0b\xfb\x11\x53\x09\xc4\x54\x02\x31\x95\x40\x4c\x25\x10\x53\x09\xc4\x54\x02\x31\x95\x40\x4c\x25\x10\x53\x09\xc4\x54\x02\x31\x95\x40\x4c\x25\x10\x53\x09\xc4\x54\x02\x31\x95\x40\x4c\x25\x10\x53\x09\xc4\x54\x02\x31\x95\x40\x4c\x25\x10\x53\x09\xc4\x54\x02\x31\x95\x40\x4c\x25\x10\x53\x09\xc4\x54\x02\x31\x95\x40\x4c\x25\x10\x53\x09\xc4\x54\x02\x67\x75\x81\xb3\xba\xc0\x59\x5d\xe0\xac\x2e\x70\x56\x17\x38\xab\x0b\xc4\x50\x02\x31\x94\x40\x0c\x25\x10\x43\x09\xc4\x50\x02\x31\x94\x40\x0c\x25\x52\x55\x3c\xcc\x17\x31\x94\x40\x0c\x25\x10\x43\x09\xc4\x50\x02\x31\x94\x40\x0c\x25\x10\x43\x09\xc4\x50\x02\x31\x94\x40\x0c\x25\x10\x43\x09\xc4\x50\x02\x31\x94\xc0\x59\x5d\xe0\xac\x2e\x70\x56\x17\x38\xab\x0b\x9c\xd5\x05\xce\xea\x02\x67\x75\x81\xb3\xba\xc0\x59\x5d\xe0\xac\x2e\x70\x56\x17\x38\xab\x0b\x9c\xd5\x05\xce\xea\x02\x67\x75\x81\xb3\xba\xc0\x59\x5d\xe0\xac\x2e\x70\x56\x17\x38\xab\x0b\x9c\xd5\x05\xce\xea\x02\x67\x75\x81\xb3\xba\xc0\x59\x5d\xe0\x8c\x2e\x70\x46\x17\x38\xa3\x0b\x9c\xd1\x05\xce\xe8\x02\x67\x74\x81\x33\xba\xc0\x19\x5d\xe0\x8c\x2e\x70\x46\x17\x38\xa3\x0b\x9c\xd1\x05\xce\xe8\x02\x67\x74\x81\x33\xba\xc0\xd9\x5c\xe0\x6c\x2e\x70\x36\x17\x38\x9b\x0b\x9c\xcd\x45\x0e\xb8\x39\xe0\xe6\x80\x9b\x03\x6e\x0e\xb8\x79\xe0\xe6\x81\x9b\x07\x6e\x1e\xb8\x79\xe0\xe5\x81\x97\x07\x5e\x1e\x78\x79\xe0\xe5\x81\x97\x07\x4e\x1e\x38\x79\xe0\xb8\xc0\x71\x81\xe3\x02\xc7\x05\x8e\x8b\xf9\xb9\x58\x57\x17\xb8\x2e\x70\x5d\xe0\xba\xc0\x75\x81\xeb\x02\xd7\xc5\x3c\x5d\xe0\xbb\xc0\x77\x81\x2f\x80\x27\x80\x27\x80\x27\x80\x23\x80\x23\x80\x23\x80\x23\x80\x23\x80\x23\x80\x23\x80\xe3\xbd\x07\x62\xcf\xf1\x78\x94\xf2\x18\x72\x1b\xb9\x83\x9c\x23\x8f\x23\x4f\x20\x4f\x22\x4f\x21\x4f\x23\xcf\x20\xcf\x22\xcf\x21\xcf\x23\xaf\xe2\x0a\x2f\x8f\x01\x2f\x06\xfd\xb1\x44\xbb\xfa\xeb\x77\xea\x4b\xa1\xdd\x0b\xcb\xed\x4b\x46\x2a\xf2\x8f\xab\xca\xef\x89\x16\xbb\xd1\x07\x63\x6d\x60\xd9\xc0\xb2\x81\x65\x03\xcb\x06\x96\x2d\xc2\x7d\xa5\x7e\xf5\x55\xbd\x62\x57\xa5\x1f\x5a\x1c\xce\x8a\xcb\xba\xca\x85\x3e\x42\x61\x83\x85\x6e\xf9\x77\x1c\x8b\xcb\xbc\x6b\x71\x8c\x4c\x00\x21\x01\x84\x04\x10\x12\x40\x48\x54\xfb\x89\xb6\x9e\xca\xc8\xe0\xd0\xc8\x40\x71\xb0\x54\x19\x6c\xeb\x29\x2d\x2d\x56\x2b\xed\x43\x64\x7c\x7f\xad\x56\x94\x7f\xa4\xb8\x5a\x63\xb5\x76\x4f\x4f\x1a\xab\x91\xc6\x6a\xa4\xe1\x9d\x34\x56\x23\x8d\xd5\xc8\xa0\x5f\x06\xfd\x32\xb6\x55\x2e\x0d\x16\x50\x81\x2b\x33\x89\xf0\x40\x71\xa8\x38\x5c\x6d\xc6\x4a\x65\xd2\xe1\xa1\xde\xe2\x92\x62\xd9\xea\xae\xf4\x2f\xb2\xe4\xdf\x95\xc4\x05\x4c\x2a\x83\x49\x65\xe0\xe6\x2c\xc0\xb2\x00\xcb\xc2\xa8\x2c\x8c\xca\xc2\xa8\x2c\x70\xbd\x8f\x58\xed\x18\xb6\x4c\xcc\x0b\x89\x28\x4f\x20\x4f\x9a\xf3\x7a\xfb\x58\x71\x68\xb8\xd4\x57\x18\xc6\xa2\xc6\x3c\x62\xa6\xdc\x8d\x54\xfa\x8b\xc3\xbd\xa5\xc1\x6e\x36\x7c\x45\x45\x15\x86\x18\x35\x29\xc7\xf5\xb6\x0d\xf7\x0e\x16\x51\x1e\x6a\x95\x7e\x46\xb9\x4d\xb9\x19\x15\x4f\x55\x8a\xb3\xc2\xe0\x60\xe5\x8a\x72\xb1\x67\xb8\x45\x95\x46\x06\xa2\x2a\x57\x7f\x29\xda\xbb\xd8\x5d\xb9\xa2\xdf\x2b\x2d\x24\x30\x86\x6e\xdd\xfd\x6d\xb5\xd2\xc2\x21\x15\x73\xda\xf8\x9a\x92\x6d\xc7\xe2\xd1\xca\xe0\x70\xaf\xfc\x26\x65\xa1\xdc\x56\xea\x1f\x96\x7b\x53\xfd\xf9\xde\xd6\xe2\x92\x91\xd2\x52\xda\x47\xfd\x5d\xc5\x50\x6f\x65\x64\xa8\xd8\x4e\x5b\xb7\x5c\x59\x24\x37\x57\x7f\x65\x38\x2a\x3b\x53\xf4\x5b\x1e\x1e\xa8\x15\x17\xaa\x0f\xef\x6c\x7c\x32\x6c\xe3\x13\x61\x1b\x9f\xe4\xda\xf8\xc4\x96\x72\x8e\x3c\x85\x1c\xd7\x6d\xb4\x63\xf7\xc7\x1d\xd4\x1d\xd4\xe3\x18\xef\x45\x3a\x94\x43\xbf\x17\xe9\x50\x8e\xfe\x5e\xa4\x43\x79\x02\x79\x12\x39\xf0\xbc\x88\x87\xf2\x0c\xf2\x2c\xf2\x2a\x4e\x1e\xb9\x8b\xdc\xdb\x3e\xf1\x04\xf0\x13\xc0\x4f\x00\x3f\x01\xfc\x04\xf0\x13\xc0\x4f\x00\x3f\x01\xfc\x04\xf0\x13\xc0\xc7\x6b\x32\x8e\xd7\x64\x5c\xbe\x26\x07\x16\x96\x2b\x5d\x8b\x5b\x68\xad\x64\x1e\xf2\x6a\xe5\x1e\x2f\x1f\x1c\x46\x7d\x78\xa8\xb7\xd0\x5d\x0c\x29\xd9\xd2\xbd\x58\xe5\xac\xa7\x54\x2e\xd3\x8d\xa6\xe2\xbd\xf2\xf1\xf9\xb2\x8d\xcf\x87\x29\xcf\x46\xbd\x1e\x83\xb4\xc2\x2d\xc3\x83\xa5\xc2\xa2\x91\x01\x2f\x1f\x44\xbd\xbb\xdf\xcb\xcb\x3d\x61\x79\x2a\x2c\x7b\xbb\x25\x9e\x83\x5f\x72\x82\x95\xfa\x97\x2e\x1c\x21\x25\xc3\xb2\xe4\xf5\x89\x56\x06\x8a\xfd\x68\x1c\xea\x2b\xd1\x16\x2d\x74\x15\x69\x2f\x2d\xad\x55\xcc\xa1\x91\xfe\x70\x4f\xb1\x8f\x76\x93\x25\x45\x68\x68\x80\xec\xb5\xba\xca\x23\x0b\x43\xbd\xc5\x02\xa1\x77\x97\x0a\x7d\x74\x3b\x6b\xed\x1b\x19\xc2\xfe\x2a\x76\xf8\xca\x74\x5f\x53\x16\x24\xbc\x98\xd0\xce\x61\x25\x72\x58\x89\x1c\x56\x22\x87\x95\xc8\x61\x25\x72\x58\x89\x1c\x56\x22\x87\x95\xc8\x61\x25\x72\x58\x89\x1c\x56\x22\x87\x95\xc8\xe1\xee\x98\xc3\xdd\x31\x97\x04\x4e\x12\x38\x49\xe0\x24\x81\x93\x04\x4e\x12\x38\x5e\xec\x69\xe3\x7d\xed\x4c\xb2\x96\xa7\x90\xa7\x91\x67\x90\x67\x91\xe7\x90\xe7\x91\xbb\xc8\x85\x97\x7b\x67\x29\xca\x63\x5e\x9e\x82\xbe\x14\xf4\xa5\xa0\x2f\x05\x7d\x5e\xac\x49\x21\x55\x0c\xb9\xed\xe5\x9e\x7e\xca\xdd\x36\xef\x73\xeb\x4b\xd5\x07\xfc\x53\xe8\xe5\x5c\xa4\x83\xb4\xfc\xbb\xc1\xf2\x03\xf1\x88\xfc\xdc\xfd\x8a\x12\xed\x2d\xf5\x89\xbb\x2c\x85\x7b\x8b\x32\x6b\x59\x5c\xf0\x2e\xa8\x8f\xd7\x65\xa9\xad\xfa\x11\xbb\xac\x44\xe4\x87\xe0\xaa\xdf\x70\x61\xa9\xba\x4a\x9a\x2f\x1d\x28\x8f\x0c\xc9\x3f\x49\xdb\x2a\x3f\x42\xc7\x13\x01\x51\x55\x56\xc5\xa9\xaa\x49\x3d\x46\x80\x8b\x9d\xbe\x16\xd5\xc0\xa4\x41\xca\xd4\xa8\x2c\x79\x8f\x08\xa8\xc6\xbe\xc2\x40\x69\x09\x5b\x58\x1c\xf6\xba\xb7\xaa\x07\x05\x50\x56\xc6\x7b\xe5\x48\x6f\xd1\x2b\xb0\xa5\x85\xa5\xb8\xac\x1e\x20\x40\xeb\x70\xb5\x23\x23\xa7\x78\xa5\x8e\xea\xe3\x04\xb8\x50\x2b\xb5\xaa\xb9\xa3\x95\x26\x8e\x52\xff\x08\x94\xb5\x79\x8f\x16\x78\x95\x76\x3c\x5b\x00\x33\xaa\x85\x56\xf5\x70\x01\x46\x2e\xa9\x40\x73\x54\xba\x0f\xc5\xba\x0b\xd8\x70\xd5\xe4\x08\x19\xef\x3d\x84\x41\x13\x96\x4f\x59\xc8\xe5\x90\x39\xd1\xa4\xcc\x94\x47\x94\x75\x6a\x99\xf1\xb1\x88\xc0\xc7\x22\x02\x1f\x8b\x08\x7c\x2c\x22\x28\xa4\x6a\xf5\x7d\x3f\x94\xa9\x37\x02\x4f\xec\xba\x72\xb0\x53\x7d\x9f\xdf\x77\x69\xaa\xaf\x3c\x28\x1f\x32\x2f\x46\xd4\x3b\x20\x27\x8e\x74\x45\xd4\xdb\x2f\x54\x68\xaf\xbf\xa1\x24\x9b\x95\x0a\x2a\xb4\x56\xdf\x79\x96\x8d\xea\xed\x0f\x2a\x4c\xf1\x7f\xb3\x5f\x5e\xf0\xa0\x47\xba\xa2\x9e\x5a\xda\x35\xb1\x7a\xd1\xae\x17\x9d\xa8\x07\xa7\x3a\xd4\x8a\x76\xbd\xe8\x74\xd4\xde\x74\x51\x9d\x1a\xab\x76\x63\xd5\x89\x7a\x06\x29\x6d\xb5\xa2\x1d\xf5\xac\x91\xad\x53\x7c\x93\x92\xf5\xf6\xea\xfb\x3c\x01\x0b\x78\xbd\x18\xaf\x5b\xcb\xeb\xc5\x78\x23\x32\x6f\xac\xc6\xeb\xe8\x3e\x9b\x78\xbd\xe8\xeb\x90\xa8\x17\x93\xf5\x62\xaa\xc1\x32\xbb\xa1\xe6\x34\xd4\x78\x43\x2d\xde\x50\xf3\xe9\x4e\x37\x5c\x48\x36\xd4\x1a\xc1\xd2\x1d\x0d\x4e\x99\xd3\x58\x8d\x35\x56\xed\xc6\xaa\xd3\x58\xe5\x8d\xd5\x78\x6b\x7d\x7d\xe6\xf8\xca\x31\x5f\xd9\xf6\x95\xd5\x44\xe5\x17\x7f\x4b\xde\xe2\xd1\x26\x97\x5f\xe0\x92\x5f\xf2\x3a\xb1\xab\x30\xe0\xab\xc7\x02\xf5\x5c\xa0\x3e\xc7\x57\x4f\x06\xc6\x3b\x0d\x75\xdb\x8d\x23\x25\x02\xf5\x64\xa0\x9e\x0a\xd4\xd3\xbe\x7a\x42\xe6\x81\x7a\x22\x50\x4f\x06\xea\xa9\x40\x3d\xdd\xea\xab\xfb\xae\x25\x03\xba\x93\x4d\xae\x27\x03\xf5\x54\xa0\xee\xd7\xed\xef\x9b\x0a\xe8\x4e\x05\x74\xa7\x9a\xf4\x4f\x05\xea\x7e\xdd\xfe\x6b\xe9\x80\xee\x74\x40\x77\x3a\xa0\x3b\xdd\x64\xbc\x5f\x77\xd5\xdf\x89\xea\x1a\x04\xea\x89\x40\x3d\x19\xa8\xa7\x02\xf5\xaa\xee\x44\x40\x57\xb3\x7a\x32\x50\x4f\x05\xea\x7e\xdb\x92\x81\xf1\xc9\x80\x6d\xc9\x80\xbe\x64\x40\x5f\x32\x60\x9b\xbf\x6f\x2a\xa0\x3b\x15\xd0\x9d\x6a\xd2\x3f\x15\xa8\xfb\x75\xfb\xaf\xa5\x03\xba\xd3\x01\xdd\xe9\x80\xee\x74\x93\xf1\x7e\xdd\x55\x9f\x24\x03\xeb\x95\x0c\xac\x57\x32\xb0\x5e\xc9\xc0\x7a\x25\x03\xeb\x95\x0c\xe8\x4a\x34\xa9\x27\x02\xf5\x64\xa0\x9e\x0a\xd4\xfd\xba\xfd\x63\x83\x58\xcd\xae\xa7\x02\x75\xff\xbc\x53\x81\xf1\xa9\xc0\xf8\x54\xc0\xb6\x54\x40\x5f\x2a\x60\x9b\xff\x5a\x3a\xa0\x3b\x1d\xd0\x9d\x0e\xe8\x4e\x37\x19\xef\xd7\x5d\xb5\x3b\x15\x58\xaf\x54\x60\xbd\x52\x81\xf5\x4a\x05\xd6\x2b\x15\x58\xaf\x54\x40\x57\xa2\x49\x3d\x11\xa8\x27\x03\xf5\x54\xa0\xee\xd7\xed\x1f\x9b\x0c\xe8\x4e\x36\xb9\x9e\x0c\xd4\x53\x81\xba\x5f\xb7\xbf\x6f\x70\x1e\x41\xec\x66\xfd\xfd\x3e\x4d\x07\xc6\xa7\x03\xe3\xd3\x81\xf1\xe9\x80\x6d\xe9\x80\x6d\x55\xdd\xe9\xc0\x7a\xa5\x03\xeb\x95\x0e\xac\x57\x3a\xb0\x5e\xe9\xc0\x7a\xa5\x03\xba\x12\x4d\xea\x89\x40\x3d\x19\xa8\xa7\x02\x75\xbf\x6e\xff\xd8\x64\x40\x77\xb2\xc9\xf5\x64\xa0\x9e\x0a\xd4\xfd\xba\xfd\x7d\x53\x01\xdd\xa9\x80\xee\x54\x93\xfe\xa9\x40\xdd\xaf\xdb\x7f\x2d\xe8\xa3\xe0\xbc\x82\xb6\x78\xe3\x29\x34\xa7\x93\x7c\xa9\xeb\xd2\xca\xb0\xfc\x41\x26\xc4\x23\x3c\x10\xaf\xf0\x40\x7c\xe3\x34\xa9\xa7\x7c\xf5\x98\x8c\x71\x7c\xf5\x5c\xa0\xce\xab\xfd\xdb\x16\x16\x06\x4b\xd5\xbf\xad\x72\x88\xba\x98\x8d\x79\x1d\x62\x52\xe9\x9c\x26\x6d\xb1\x40\x1b\x6f\xd2\x8f\x07\xfa\x25\x9a\xe8\x4b\x34\xd1\x97\x68\xa2\x2f\x11\xd0\x97\x6e\x62\x5f\xba\x89\x7d\xe9\x26\xf6\xa5\x9b\xd8\x97\x6e\x62\x5f\xba\x89\x7d\xe9\x26\xf6\xa5\xc7\xdb\x97\x8b\x8f\xb7\xaf\xa1\x2d\xd8\x8f\x37\xe9\x17\xd4\x97\x68\xa2\x2f\xd1\x44\x5f\xa2\x89\xbe\x66\xfe\x4b\x55\x37\x59\x93\xb6\x60\xbf\x44\x93\x7e\x89\x00\x6e\x40\x5f\x43\x5b\xb0\x5f\xa2\x49\x3f\xa5\x4f\xfe\xfd\x82\xe1\x62\x77\x49\x9d\xbb\x22\x6e\xff\x22\x15\xf2\x57\x0b\x76\xb5\xe0\x44\xae\x2a\x0e\x56\x64\xa9\xa5\xd2\xaf\x4e\x09\x2d\xc3\x57\xa8\x3a\x53\xef\xc3\xca\x52\x44\xbe\xf3\xed\x15\x4a\xde\x79\xac\x65\xa8\xa4\xce\x7b\x4c\xbd\x25\xab\x4a\xea\x7d\x59\xd5\xa9\xbf\xe4\x29\x9a\x12\x78\xa8\x63\x4a\xe0\x11\x8e\x8e\xc6\x87\x35\xa6\x04\x9e\xca\x88\xd6\x1f\xf1\x89\xd6\x9f\xea\x61\xb5\x87\x78\xa2\xf5\x47\x76\xa6\x05\x90\x4e\x2c\x77\x4d\x0b\x80\x51\xd3\xd4\x46\xbc\xc6\x4e\xde\x21\xa9\xdc\xd5\x5e\x47\xad\xd5\xaa\x0a\xda\x6a\xd8\xb5\x4b\xb5\x61\x23\xde\x47\x3a\x27\x0e\xf5\x56\x06\x87\x5b\xd5\x17\xb2\xbd\x72\xa7\x7a\xbf\x41\xbd\x2b\x81\x77\x2e\xea\x0d\xb5\xb7\x50\xbc\x37\x6c\xda\xab\x55\xf5\x7d\x94\x43\x6a\x6f\x56\xd4\xbf\x98\xd2\x51\x6b\x0b\x54\xd5\x77\x52\x3a\x7d\x6f\x53\xa9\x56\xf5\x66\x10\xde\x50\x91\x5b\x24\x4e\xb7\x80\x78\x36\x8f\xb2\xed\x2b\x3b\xb2\x6c\x9d\x77\x69\xd6\xd5\xf0\x6b\x9c\x11\xcd\xd0\xa2\x9a\x39\x36\x26\x7f\x67\x52\xfd\x36\xa6\xa6\x2d\xd3\xae\x55\xbf\x1c\x34\x55\xd3\xac\xf5\x9a\x6e\xfd\xc8\x7a\x47\x33\xad\x7d\xd6\x3e\x2a\xbf\x6b\xbd\x4b\xe5\xf7\xac\xf7\xa8\xfc\xbe\xf5\x11\x95\xf7\x5b\xfb\xa9\x3c\x66\x91\x86\x90\x16\x79\x54\xd3\x23\xeb\x22\xeb\x34\x33\xb2\x3e\xf2\x16\x95\xdf\x8e\xbc\xad\x19\x91\xbd\xd1\xa9\x9a\x1e\x9d\x16\x9d\xae\x19\xf2\xaf\x89\x52\xf9\xb0\xe8\x4c\xcd\x8c\xce\x8a\xce\x22\x54\x0b\xbf\x53\xa4\xfb\x52\x54\x5b\xa8\xdd\xa1\x59\x74\xab\x2f\x6b\xb3\x16\x0d\x16\x17\x6b\x76\x6f\x71\xe1\xa0\x76\x4a\xb9\x30\xdc\x2f\x7f\xf7\x48\x33\x3e\x7f\x56\xfe\x28\xad\xf3\xbc\x73\xb3\x24\x35\x8d\x66\xa0\xab\x5f\x31\xd2\x50\xd6\x6a\x65\x43\xfd\xc2\x51\xc3\x95\xae\xae\xbe\x01\x6d\x96\x92\x47\x75\x97\x4b\x8b\xb4\x63\xcb\x95\x2e\xf9\xeb\x4a\x5a\xcd\x1e\xf9\x9b\x48\xb2\x56\xb5\x28\x4c\xbe\x39\x54\x3b\x42\x3b\x86\x7a\x25\xd0\x3a\x87\xfa\xca\x1e\x1c\x79\x9e\x7a\x51\x6e\x84\x95\x0e\xdd\x38\xd5\x6b\x6f\x79\x90\x64\x38\x9c\x92\x65\xf3\x45\x92\xd3\x28\x45\x24\x92\xf4\x4e\xa8\x4d\xb6\x87\xa8\xbf\x7e\x97\x36\x53\x4b\x69\x59\x9a\xdf\x05\xda\x65\xda\xe5\xda\xb0\xb6\x5c\xbb\x41\x5b\xa1\xdd\xab\x7d\x4b\x7b\x58\x7b\x56\xdb\x46\x1d\xa3\xfa\x74\xfd\x08\xfd\x58\xdd\xd6\x4f\xd6\x85\x7e\x8e\x2e\x7f\xed\xd4\x8a\x1e\xa6\x19\xb4\x4a\xb2\x34\xa3\x56\x9a\x59\x2b\x1d\x4a\xa5\xbd\x0a\xef\xd9\x5a\x69\x73\xad\xf4\x5c\xad\xf4\xbc\x2a\x19\x34\x8b\xb6\xc8\x6e\x2a\xbf\x19\x79\xa1\x76\xed\xe7\xb5\xd2\x16\x5f\xaf\xad\xb2\x4c\xab\x6e\x58\xbb\xd4\x6e\xea\xd0\xa6\xd3\x5a\x1b\xd6\xce\x68\x27\xc9\x3d\x91\x17\x6b\xa3\x5e\x52\x25\xd9\xa7\x53\x3b\x34\xda\x41\x3b\x67\xaf\xf5\x66\x74\x8a\x42\xd9\x56\xeb\xb5\xbd\x56\x7a\xb9\x56\xda\x51\x2b\xed\xac\x95\x5e\xa9\x95\x5e\xad\x95\x5e\xab\x95\x76\xa9\x52\x0b\x21\xcd\x50\xbf\x5a\x3a\x87\x56\xec\xe4\xc8\xd3\x84\xf9\x01\x59\xfb\xb4\xc2\xfe\x20\xf2\x14\xe5\xef\x53\xfd\x29\x55\x7f\x3f\xf2\xba\x9a\xcb\x26\x92\x1f\x44\x9e\x24\xf9\xbe\xd2\xf5\x06\x66\xdb\x62\xbd\x62\xbd\x26\x7f\xa8\x36\x14\xa6\x9d\x1e\xa1\x55\x8b\x86\x3a\x42\x1d\x9a\xfa\x9d\x05\xad\x53\xfe\xce\x82\x36\x2d\x74\x68\x68\x96\x36\x5d\xed\x1c\x83\xf2\x4f\x93\x86\x13\xd4\x5e\x09\x91\x0c\xa9\x5f\x6c\x68\x0d\x4d\x0f\x1d\x2e\xf7\xaa\xfa\x85\x87\x77\xe5\x3e\xa3\xf6\xc3\x35\x2d\x72\x73\xe4\x66\xed\x88\xc8\x8f\x23\x8f\x6b\x47\xd2\x7e\xb8\x9c\xc6\x74\xea\x9f\x36\xb8\x29\xac\x05\xda\x6c\xed\x24\xda\x17\x67\x6a\xe7\x6a\x17\xd1\x2b\xe3\x72\x6d\x50\xbb\x4a\xbb\x4e\xbb\x51\xbb\x8d\x76\xc7\x3d\xda\x03\xda\x2a\xed\xbb\xda\x23\xda\x8f\xb5\x27\x68\x97\xbc\xa8\xbd\xaa\xbd\xa5\x7d\x40\x7b\x25\xac\xb7\xb1\xf3\x34\xd3\xf8\xa6\xf1\x4d\x76\xae\xca\x1f\x60\xbf\xab\xf2\xfb\xd9\x39\x2a\x5f\xc9\xe6\xa9\xfc\x3e\xf6\x79\xca\x1f\xa0\x7e\x73\x55\xfe\x00\x3b\x4b\xe5\xf7\xb3\x33\x55\xbe\x92\x9d\xa1\xf2\xfb\xd8\x69\x94\xdf\x4f\xfd\x84\xca\x1f\x60\xae\xca\xef\x67\x79\x95\xaf\x64\x39\x95\xdf\xc7\x32\x94\xaf\xa4\x7e\xa7\xaa\xfc\x01\xf6\x3b\x2a\xbf\x9f\x9d\xa2\xf2\x95\xec\xb7\x55\x7e\x9f\xfc\x85\x5b\xe3\x3e\xea\xf7\x39\x95\x3f\xc0\x4e\x52\xf9\xfd\x2c\xad\xf2\x95\xec\x6c\xcd\xa0\xd6\xf3\x49\x7e\x93\x65\x49\xae\x64\xa7\x93\xbc\xff\x97\xf0\x48\x05\x1e\xe9\x87\x47\xfa\xe0\x91\x32\x3c\xb2\x18\x1e\x29\xc1\x23\xbd\xf0\xc8\x22\x78\xa4\x07\x1e\x29\xc2\x23\x5d\xf0\xc8\x42\x78\xa4\x00\x8f\x5c\x06\x8f\x5c\x0a\x8f\x5c\x02\x8f\x7c\x09\x1e\xb9\x18\x1e\xf9\x22\x3c\x71\x21\x3c\xb1\x00\x9e\xf8\x02\x3c\x71\x01\x3c\x31\x5f\xe5\xf7\xb1\x01\xe5\x8b\x6e\xe9\x05\x76\x11\xc9\xfb\xd8\xe5\xd2\x47\xbf\x84\x47\xfe\x18\x1e\xb9\x11\x1e\xf9\x23\x78\xe4\x06\x78\xe4\x0f\xe1\x91\x3f\x80\x47\xae\x87\x47\x7e\x1f\x1e\xb9\x0e\x1e\xf9\x3d\x78\xe4\x5a\x78\xe4\x1a\x78\x64\x39\x3c\xf1\x15\x78\xe2\xcb\xf0\xc4\x55\xf0\xc4\x95\xf0\xc4\x32\xec\x8d\x2b\xe0\x91\x11\x78\x64\x18\x1e\x19\x82\x47\x06\xe1\x91\x25\xf0\xc8\x57\xd5\x1e\xb9\x49\xf9\x65\xa9\xf2\xc8\xd5\x72\xa7\xfc\x12\x1e\xb9\x0f\x1e\xf9\x06\x3c\xf2\x77\xf0\xc8\xbd\xf0\xc8\xdf\xc2\x23\xf7\xc0\x23\x7f\x03\x4f\xdc\x0d\x4f\xfc\x35\x3c\xf1\x57\xf0\xc4\x5d\xf0\xc4\x5f\x62\x6f\xac\x80\x47\xfe\x02\x1e\xf9\x73\x78\xe4\x0e\x78\xe4\xcf\xe0\x91\xdb\xe1\x91\x3f\x85\x47\xfe\x04\x1e\xb9\x15\x1e\xb9\x05\x1e\xf9\x1a\x3c\x72\x33\x3c\xf2\x75\xb5\x3b\x56\x2a\x8f\xdc\xa6\x3c\x72\xe7\x2f\xe9\x91\x1f\xc0\x13\xdf\x87\x27\x1e\x81\x27\xbe\x07\x4f\xfc\x07\x3c\xf1\x10\xf6\xc6\xbf\xc3\x23\x6b\xe1\x91\x7f\x83\x47\xfe\x15\x1e\xf9\x0e\x3c\xf2\x2f\xf0\xc8\x1a\x78\xe4\x9f\xe1\x91\x7f\x82\x47\x56\xc1\x23\xff\x08\x8f\x7c\x1b\x1e\xf9\x07\x78\xe4\xef\xe1\x91\x07\xe1\x91\x6f\xc2\x23\x0f\xc0\x23\xf7\xc3\x23\xdf\x55\x1e\x79\x58\xed\x94\x6f\x29\x8f\xac\x56\x1e\xa1\xe8\x40\x8e\x57\x7c\x7e\xa6\xbc\xe7\xd2\x5d\xfb\x04\xe2\x8b\x53\xc1\x70\xcf\x28\x1e\xfb\x19\xc9\xdd\x8a\x0f\xf6\x50\xe9\x5d\x55\x7a\xb3\x56\x7a\xab\x56\x5a\x8f\x7e\x8d\xf7\x7a\x19\xcf\x5c\x40\x1e\xf6\xc7\x33\xc7\xa8\x78\xc6\x56\xf1\xcc\xa9\x4d\xe3\x96\x03\xc7\x30\xe6\x62\x0a\x02\xb5\xe9\x4a\xce\x92\xe7\x60\x62\x3a\x39\x87\xa9\x88\x57\x34\x9a\xc9\xc7\xfd\xb2\xe3\x2c\x9a\xe7\x29\x9a\xd0\xce\x26\xeb\x2e\xd1\x7a\xb4\x7e\xed\x6a\xda\x0b\x77\x6a\xdf\xa0\x78\x63\x8d\xf6\x90\xb6\x49\xdb\xab\xed\xa7\xd5\xef\xd0\x0f\xa5\x98\xe3\x18\xfd\x44\x3d\xa1\x9f\x42\x3a\x19\xc5\x2a\x9d\x5e\x6c\x13\x99\xa1\x22\x19\x3d\xfa\x1d\xaa\xb7\x50\xbe\xcd\x6b\x6f\x8d\x22\x7f\xd6\xcb\xa7\xae\xf0\x22\x9e\xc3\x1e\x9d\x31\x63\xc6\xe5\x33\xd6\x7a\xb5\x99\xda\xcc\x65\x33\x3f\x98\x75\xb5\x57\x9b\xf5\xf2\x27\x53\x9f\xbc\xf1\x93\xcf\x79\xb5\xd9\x47\xcd\xbe\xe7\xf0\x59\x87\xdf\xe5\x8d\x3f\x22\xec\xe5\x47\x3d\xe4\xe5\xff\xe7\x72\xd5\x2b\x72\xcc\xa1\xc7\x5c\x7f\xcc\x0b\x9f\x49\x7d\xe6\xb6\xcf\xec\x3a\x56\x1c\x7b\xb7\x6a\x6d\x3f\xf6\xb9\xe3\xda\x8e\x3b\xf9\xb8\xf2\x71\x77\x1d\xb7\xe1\xb8\x0f\x8f\x3f\xe1\xf8\x8b\x8f\xbf\xe9\xf8\xb5\xc7\xef\xfa\xec\x6c\x75\xdd\xf8\xec\x09\x9f\xbd\x48\xfe\xc6\xbb\xa6\x7f\x76\xb9\x8a\xdc\xf4\xcf\x9d\xe3\xe9\xfd\xdc\x02\x2f\x3f\xc5\xf2\xf2\xcc\x0f\xbc\xdc\xf5\x62\x41\xfd\xf4\x87\x91\xaf\x57\x6b\xa2\x9f\xbe\x8d\x5e\x1e\x0f\x90\x87\x35\x2d\xa6\x7e\x9f\xb8\xac\x6d\xd4\x97\x1b\x27\x1a\x09\x6d\xa3\x56\x36\xb6\x98\xaf\x6a\x65\x6b\xae\xb1\x85\xa2\xe7\x8d\xc6\x89\x5a\x39\x4c\xff\x64\x1f\x79\x4d\xc9\x13\xbd\xff\x18\x5b\x56\xbd\x36\x1a\x5b\xe4\x55\xaf\xd5\x1b\x2b\xdb\xa8\xd6\x19\x6a\x1b\xfb\xd9\xd8\xcf\x42\xd3\x94\x3c\x4c\xc9\x99\x52\x46\x7e\xa4\xe4\x46\x25\x9f\x54\x72\x93\x92\x4f\x29\xf9\xb4\x92\xdb\x94\x7c\x4d\xc9\xd7\xa5\x8c\x76\x28\x39\x45\xc9\x4f\x48\xa9\x1d\x1e\xd2\xc7\xbe\x3f\xf6\xfd\x90\x31\xb6\x62\x6c\x45\xc8\x52\xe5\xb0\x76\x9c\x76\x5c\xa8\x45\x95\xa3\x4a\xb6\x2a\xd9\xae\x64\x87\x92\x53\x95\x3c\x44\xc9\xe9\x4a\xce\x92\x32\xb2\x41\xc9\x51\x25\x1f\x53\xf2\x71\x25\x9f\x57\x72\x8b\x92\x2f\x29\xb9\x43\xc9\x9d\x4a\xbe\xa2\xe4\x1b\x4a\xee\x51\xf2\x4d\x25\xdf\x92\x32\xda\xa9\xa4\x42\x54\xf6\x4a\x2f\x18\x63\xbb\xc6\x76\x85\x4c\x65\xa9\xa5\x5a\x5a\x94\x8c\x2a\xd9\xaa\x64\xbb\x92\x6a\xce\x64\xaf\x94\x87\x28\x39\x5d\xc9\x59\xca\x2f\x1b\x94\x1c\x55\xf2\x31\x25\x1f\x57\xf2\x79\x25\xb7\x28\xf9\x92\x92\x3b\x94\xdc\xa9\xe4\x2b\x4a\xbe\xa1\xe4\x1e\x25\xdf\x54\xf2\x2d\xe5\xd9\x4e\x25\x15\x22\x45\x76\x86\xca\x67\xd7\xec\x96\xf2\xd7\xd9\xe2\x13\x26\x65\x69\x9b\xf2\xff\x78\x7b\xa7\xa9\x76\xbf\xd5\x87\xa9\x96\x99\x4a\xce\xc2\xde\xa5\x72\xc3\x3c\x36\xaa\x16\xff\x6c\x9e\x54\x2d\x9b\x94\x7c\x4a\xc9\xa7\x95\x1c\x3f\xcb\x6d\xaa\x7d\xfc\x5c\x5f\x53\xed\xaf\x2b\x39\xd1\xbc\x3b\xe4\x55\x7a\x3d\x48\xe9\xf3\x01\xbd\x36\xa8\x45\xbd\xfa\xa4\xd5\xde\x9c\x7c\xf3\xc0\x0c\x3c\xab\x27\xb2\xd4\xb3\xcb\x67\x45\x03\x9a\x87\x20\x77\x85\xd4\x6a\x29\x59\x7d\xdd\xc9\x72\x54\xc9\x56\x78\x59\x4a\x35\x9a\xbc\xec\xf9\x57\xca\xe9\xf0\xa9\xe7\x4d\x29\x47\xe1\x47\x29\x1f\x87\xbf\xa4\xdc\xa2\xe4\x4b\xf0\x94\x94\x3b\x95\x7c\x05\xde\x91\x72\x8f\x92\x6f\x2a\xf9\x16\x3c\x22\xa5\x42\xd4\x7e\x73\xc2\x5d\x11\x81\xbd\xff\xff\xda\x1b\x9f\x84\x3f\x7e\x9d\x5f\xc9\xba\x16\xab\xfd\x6a\x60\xd8\xf7\x7b\x81\x1d\xea\xb7\x02\x0f\x09\x7d\x02\xbf\x11\x38\x3b\x74\xb8\xfa\x2d\x22\xf9\x4b\x44\xf2\x77\x88\x82\xbf\x42\xf4\x5c\x64\x4b\xe4\xc5\xc8\xb6\xc8\x4e\xfc\xda\xd0\x9e\xda\x2f\xc6\xa8\x77\x77\x8c\x3b\x8c\x7e\x92\x77\x51\xa4\x31\x97\xa2\x9e\xbb\x29\x9e\x78\x90\x22\xcb\xef\x50\x44\xf1\x03\x8a\x2d\x7f\xaa\x3d\xad\x3d\x47\xd1\xe5\x4e\xed\x0d\x8a\x2f\x10\x5f\xea\xd3\xf4\x19\x14\x63\x1c\xad\x1f\xaf\xcf\xa1\x28\xe3\x64\x3d\xab\x9f\xae\x9f\xad\x9f\xaf\x5f\xa4\x5f\xa6\xf7\xe8\x65\x7d\x50\x5f\xa6\x2f\xd7\xaf\xd7\x6f\xd4\x6f\xd5\xef\xd0\xef\xd2\xef\xd1\x57\xea\xdf\xd2\x57\xeb\xdf\xd5\x1f\xd6\x1f\xd5\x37\xe8\x4f\xe8\xcf\xe8\x2f\xe8\xdb\xf4\x57\xf5\x3d\xfa\x3e\xfd\x43\xc3\x30\x22\x46\x87\x31\xdd\x98\x65\x1c\x65\x1c\x63\x9c\x60\xd8\x46\xca\x38\xc5\xc8\x1b\x67\x1a\xe7\x18\x17\x18\x17\x93\x2f\x4e\x0e\xdd\x11\x90\x5a\xbd\xac\x9f\x10\x6c\x69\xd2\x53\xc9\xb1\xe5\xcd\x35\x4c\xd8\x32\x4e\x43\x93\x16\x7f\xfb\x39\x3e\xd9\x1d\xfa\x9b\x03\xe8\x9f\xc8\x1e\xbf\xb5\xdf\x1e\x57\x1e\x6f\xdb\x81\xed\x9f\xa8\xc5\x8f\x3e\x7e\x5e\x07\xb4\xf9\x63\xa4\xea\xb9\x7f\x53\x5d\xfa\xae\x52\x94\xde\xf0\xfe\xc9\x7a\x8a\xc1\x8f\x54\xef\xa2\x1c\x45\xfb\xf6\x2d\xed\x58\xda\x9b\x53\xb5\xd3\x65\xac\x66\xbd\xa9\x79\xef\xe4\x79\x23\xe5\x3b\x9e\x33\x34\xf9\x6e\x9c\x17\x31\x4f\x43\x1f\x8a\xb3\x49\x23\xc5\xda\xf4\x1a\x99\x45\x91\x3c\xbd\x1a\xb4\x59\x4a\xe3\x6c\xea\x31\x5b\xa3\x1d\x4e\x67\x04\xf9\xae\x1d\x45\x86\xc6\x02\x65\x89\x4e\xd8\x72\xf4\xfb\x0d\x08\xba\xf6\xa8\xf6\x75\x92\x1b\xa8\xf7\x34\xed\x18\x3a\x57\xd8\x5a\x8a\x22\xee\x3c\x9d\x34\xce\xa1\x98\xfb\x62\x3a\x83\xf5\xaa\x5f\x97\xbf\x4a\xbb\x56\xfb\xaa\x76\x13\xe9\x7b\xd4\x58\x40\xf2\x59\xa3\x4c\xbe\xdc\x68\xac\xa5\xf2\x2a\x53\x5a\xbf\xcc\x98\x5d\x6d\x19\xdb\x68\x9e\x5b\x95\xc6\x02\xd5\x7f\x81\x4e\x33\xd1\x6f\x55\xe5\x95\x52\x52\xf9\x76\x92\xdf\x31\x7e\x4a\x72\x85\x6c\x31\xdb\xa4\xb4\x3a\xeb\x52\x9b\x16\x6a\x09\xb5\x87\xa6\x84\xa6\xd1\x2b\x5f\xfd\x2e\x28\xf9\xb0\xfe\x1b\x64\x78\xe5\xab\x79\xed\xad\xcf\x4b\x5a\x60\xed\xb3\x36\x6a\x46\x68\xb6\x7c\x85\xeb\xb6\x9e\xd2\x4f\xd1\xf3\xfa\x99\xfa\x39\xfa\x05\xfa\xc5\xfa\x42\xbd\x57\xef\xd7\x87\xf5\xab\xf4\x6b\xf5\xaf\xea\x37\xe9\xb7\xe9\x77\xea\x5f\xd7\xef\xd5\x1f\xd0\xbf\xad\xaf\xd1\xd7\xea\x8f\xe8\xeb\xf5\x8d\xfa\x26\xfd\x59\x7d\x8b\xfe\xb2\xbe\x4b\x7f\x4b\x7f\x4f\xdf\x6f\x58\x46\xd4\xe8\x34\x0e\x35\x66\x1b\x9f\x36\x8e\xa5\x88\x98\x1b\x27\x19\xa7\x1a\xc2\x98\x6b\x9c\x4b\x73\xbc\xc4\xe8\x36\x2e\x37\x06\x8c\xa5\xc6\xd5\xc6\x75\xc6\x0d\xc6\xd7\x8c\xdb\x8d\x15\xc6\xdd\xc6\x37\x8c\x07\x8d\x55\xc6\x77\x8c\x87\x8c\x1f\x18\x3f\x36\x7e\x6a\x3c\x6d\x3c\x67\xbc\x68\xec\x34\xde\x30\xf6\x1a\x1f\x98\x9a\x19\x36\xdb\xcc\x69\xe6\x0c\xf3\x08\xf3\x68\xf3\x78\x73\x8e\x99\x30\x4f\x36\xb3\xe6\xe9\xe6\xd9\xe6\xf9\xe6\x45\xe6\x65\x66\x8f\x59\x36\x07\xcd\x65\xe6\x72\xf3\x7a\xf3\x46\xf3\x56\xf3\x0e\xf3\x2e\xf3\x1e\x73\xa5\xf9\x2d\x73\xb5\xf9\x5d\xf3\x61\xf3\x51\x73\x83\xf9\x84\xf9\x8c\xf9\x82\xb9\xcd\x7c\xd5\xdc\x63\xee\x33\x3f\xb4\x0c\x2b\x62\x75\x58\xd3\xad\x59\xd6\x51\xd6\x31\xd6\x09\x96\x6d\xa5\xac\x53\xac\xbc\x75\xa6\x75\x8e\x75\x81\x75\xb1\xb5\xd0\xea\xb5\xfa\xad\x61\xeb\x2a\xeb\x5a\xeb\xab\xd6\x4d\xd6\x6d\xd6\x9d\xd6\xd7\xad\x7b\xad\x07\xac\x6f\x5b\x6b\x2c\xb9\xa2\xcf\x86\x84\x94\xe1\x7b\xd5\xfe\x91\xe5\x05\xb2\xac\xdf\x2b\xcb\xfa\xbd\xaa\x7d\x8e\x6a\x9f\xa3\xca\xb7\xab\xf2\xed\xaa\x4f\x42\xf5\x49\x8c\xeb\xbf\x52\xf5\x59\x19\x2c\x37\xf4\xdf\xa0\xca\x1b\x82\xe5\x89\xc6\x9a\x5c\x96\x4d\x3e\x4e\xcf\xd5\xaa\x7c\xf5\xb8\xb1\x3e\x3b\x8d\x6b\x55\xf9\xda\x71\x65\xff\xbc\xf2\xaa\x9c\x1f\xe7\x87\x2d\x4a\xff\x16\x65\xc3\xe9\xca\x86\xd3\x55\x9f\xb5\xaa\xcf\xda\x60\xff\x83\x2e\xfb\xfd\x3f\x91\x9f\x27\xe1\x1f\xbf\x9d\x7e\xdb\xfc\x36\x4f\xa6\xdc\x60\xcf\x44\xe5\x5f\xc1\x3e\x39\xd8\xbd\xd1\xb0\x1f\x26\xda\x03\x13\xad\xfb\x2f\xb1\xd6\xb0\x50\x49\x63\x76\x5d\x7a\xa3\xe0\xff\x85\x3e\x39\xd1\x7a\x35\x9f\xe3\xe4\x19\x64\x6a\xed\xf7\x9d\xe5\xaf\x3b\x6f\x52\xbf\xea\xfc\x9f\xd6\x16\xf5\x1b\xce\x3b\xac\x77\xad\x0f\x23\xeb\xd4\xfb\x2f\x82\x92\xfc\x8c\xea\x5c\x4a\x0b\x28\x5d\x42\xa9\x9b\xd2\xe5\x94\x06\x28\x2d\xa5\x74\x35\xa5\xeb\x28\xdd\x40\xe9\x6b\x94\x6e\xa7\xb4\x82\x30\xee\xa6\xfc\x1b\x94\xbf\x26\xed\x23\x16\x91\x72\xb5\xb2\xd5\xf2\xb5\x78\xf2\x6e\x29\xc7\xee\x1a\xd7\xee\xc9\xe9\x0d\x2d\xfd\x75\xd6\x0c\x77\x54\xcb\xb8\x8f\x9f\xf8\x7f\xef\xe3\xbf\xd0\x7d\xfc\x76\xf5\x29\x9f\x27\xe7\xf8\x64\xa4\x2e\xcd\x53\xea\x92\x98\xb3\x26\xf5\x84\x4f\xf6\xd6\xa5\xbf\x4f\x43\xff\x13\x7c\xfd\xaf\xf6\xc9\x0d\x3e\xb9\xa5\x2e\x8d\x67\x7d\xd2\xa7\x67\xac\xb3\xb9\x1e\x8a\x13\xea\x72\x65\x5d\xea\x7b\xeb\xd2\x58\x50\x97\xe6\xc3\x3e\x2c\x7f\xfb\xc5\x75\x9f\x98\x03\xf5\xb1\xe6\x51\x75\x69\x6c\xf3\xc9\x05\x93\x90\x0b\x7d\xd2\xdf\xee\xf3\xff\x84\x7e\x9e\x84\x7f\xfc\x76\xfa\x6d\xf3\xdb\x3c\x19\x89\x15\x5c\x19\x2c\x43\x96\x3f\x7e\x9f\xa0\xfd\x20\xf7\x49\x93\x3e\xb7\x1e\x70\xee\xfe\xb1\x13\xec\x81\x89\xd6\xbd\xc9\x5a\xaf\x9c\xec\x5a\xeb\xa7\xd6\xed\xf4\xfb\xc1\x6f\xa7\x5f\xbf\xdf\xe6\x06\x79\x75\x53\x39\xf9\xfb\xf8\x2c\xeb\x47\xd6\x46\xeb\xc9\x86\x5f\xe3\x7f\xb1\xc9\xef\xef\xbf\x6d\xbd\x63\x7d\x64\x8d\x79\xbf\x7e\xaa\xcd\xd2\x26\x73\x07\xd7\x70\x07\xd7\xe8\xcc\x2b\x7f\xa1\x59\xa3\x73\xaf\x46\x27\x5f\x8d\xce\xbe\x1a\x9d\x7e\x35\x4d\xfa\xf7\x69\x4a\xcf\x51\x92\x4f\x03\xec\xa4\xfc\x0d\x4a\xd2\x77\x1f\x68\xf2\xd6\x2c\x63\xed\xe9\x24\x7f\x53\xce\x6d\x6c\x97\x2a\x6b\x4d\xa4\xec\xf9\x49\x4d\x9b\xe0\x6a\xf3\xfe\x5a\x43\xff\x89\x5a\x6c\xf2\xe9\x0c\x85\xfe\xa2\x6c\xf7\x49\x53\x9d\x81\x74\xd5\xdb\x56\x7d\x0f\x21\x69\x58\xef\x12\xf7\x4d\xf0\x59\xb6\xd6\x71\x20\xde\x24\x8d\x06\x69\x3c\x59\xe9\xd4\x02\x1a\x3f\x6e\x6c\x73\xc4\x8f\xb1\x51\xed\x0c\x4d\xed\x09\x5d\xed\x89\x4f\xfd\xaa\x6d\x6c\x82\x28\x6d\x3c\x13\x36\x5e\x56\xf3\xff\xcc\x83\xd8\x99\xd5\x7d\x39\x91\xd7\xa3\xcd\x74\xfd\x0f\xe0\x4e\xf9\x98\x71\xff\xad\x16\x34\x5d\xcb\xff\xf7\x2d\x98\xc8\xf7\x86\xc6\x1b\x76\xd1\x27\x3e\x76\xf7\x1c\xf8\xb5\x25\x67\xc2\x31\x93\x33\x27\xa9\x71\xa2\x75\xf3\x70\x7e\x49\x1b\x27\xd8\xe9\xbf\x80\x8d\x4d\xfd\x5a\xb7\xf1\x4c\xad\xec\xb3\xf1\xd0\x5f\x70\xfd\x3e\x7e\xaf\x4c\xe4\x77\x69\xc1\xc2\xff\x16\x0b\x9a\xef\x95\x03\xe1\xfe\x8f\xcd\xbc\xe9\x6a\xfe\x0f\xcc\xbc\xd9\xda\xe3\x5d\xe5\xbb\x7f\xbd\xdf\x55\xd6\x4f\x55\xe7\xad\x3d\x3e\x79\x53\xbd\x8c\x33\xdc\x4d\xc1\x3e\x0d\xed\xeb\x7d\xe7\x36\x9f\x06\xf4\xd9\xe3\xeb\xb3\x7e\x02\xac\x9b\x26\x68\x59\x5f\xd7\x33\x91\x1c\x6f\xf3\x44\xf6\xa0\xdd\x2b\x9f\x3c\xae\xbc\xe7\x80\xf2\x80\x3e\x99\xd0\x1b\x37\x4d\x62\xee\x13\xcc\x5a\xeb\x1e\x37\x23\x55\x1e\x9b\x5b\x97\xbe\x51\x93\x8f\x25\x4d\xeb\x71\x6b\xab\xf5\xb2\x7a\xe6\xaf\x43\x31\x89\xa6\xcd\xd2\x9a\x9c\xc7\xb1\x7f\xbf\xfe\xeb\xbd\x7f\x2d\xf5\x6e\x82\xb9\xc9\x7b\x57\x49\x95\xaf\x97\xd2\x4a\xa9\x95\xe9\x55\xed\x11\xd5\x72\x59\x5d\x7a\xed\xe6\x80\xf7\xfe\x8d\x6f\xd4\x0d\x75\x89\xb1\x73\x7c\x63\x3b\x95\x3c\xba\x2e\xcd\x87\x55\x39\xec\x6b\xb9\x58\xca\x90\x7a\x07\xc4\x1a\x56\x2d\xf7\x8c\x93\x3b\xeb\x65\xd8\xef\xb3\x79\xbc\x3d\x9e\x4e\x4f\x5b\x78\x46\x5d\xbf\xbf\xec\xe9\xf1\xcb\xc9\xfb\xe4\xc0\xde\x68\xf0\x80\x6f\xee\x07\x9e\xb5\xf7\x1e\x9e\x67\x83\xa7\x13\x3d\xaf\xf7\xc9\x81\x9a\x9c\xfc\xfe\x35\xac\xa7\xac\x67\xd4\xf3\xd7\x51\xcd\x7b\x66\xe8\x7f\xdf\x9e\x3d\x5a\x9d\x37\x4f\x57\x27\xc7\x6b\xb5\xda\x19\xd6\x7b\x8f\x42\x5b\xad\xe4\x1e\xd5\xf2\x61\x5d\x7a\xed\x56\x4a\xf5\x7f\x4f\xb5\xb7\xd5\x5b\x3c\x89\x53\xb0\x3a\x99\x9a\x3b\xb5\xda\x99\x37\xa4\xd5\xf5\xfb\xdf\x2b\xc0\xe9\x55\x69\xb3\xbe\xad\x64\xa7\xd6\xfc\x1d\x83\x9d\xf5\xb2\x67\xbf\xdf\xe6\xf1\xf6\x40\x67\xa7\x4f\xf3\x78\x79\x74\x50\x4e\xde\x27\x13\x7a\xe3\xe8\xa0\x07\xfc\x73\x3f\xf0\xac\x3d\x9d\xb0\xe1\x3d\xdf\xa8\xb6\xa6\xde\x3e\x98\x3d\xfb\x84\xb5\xbd\x71\xcf\x6a\xc7\x6a\xde\x73\x76\xde\x49\xed\x14\x5f\x7c\x72\x58\x6d\xc4\xc7\xc7\x3c\xba\x76\xa8\xfa\x74\x3c\x14\x0a\x87\x58\xa8\x2d\xd4\x19\x9a\x11\xf9\x89\xfa\x2c\x6c\x73\xe4\xb9\xc8\x0b\x91\x9f\x47\xb6\x46\xb6\x45\x5e\x8e\xec\x8a\xec\x96\x9f\x79\x13\x9a\xa9\x1d\xa1\x1d\xad\x1d\x2f\x47\x36\xc1\xd3\xad\x5d\x4a\xee\xfc\x15\x68\x7e\xe7\x57\xac\x79\xd7\xaf\x4c\xf3\xeb\xbf\x32\xcd\xbb\x7f\x65\x9a\xf7\xfc\x02\x9a\xe5\x4e\xfc\xf4\x04\x3b\xd1\xd3\x7b\xf0\x1a\x3d\x4b\xab\x1a\xe5\xe7\xd7\x61\x15\x45\x7b\x11\xf4\x3b\x0d\xeb\x37\xd9\xfe\x9b\xb1\x2a\x07\xa7\x7f\xf2\xfd\x3d\xfd\x6f\x4c\xba\xff\x13\x07\xd9\x7f\x23\xd6\x7e\xb2\xfd\x77\x62\x45\x27\xdb\x7f\xd7\x41\xf6\xdf\x78\x90\xfd\x9f\x38\xc8\xfe\x9b\x0f\xb2\xff\x73\x07\xd9\xff\x1d\x5f\xff\x4f\xd3\x9d\xd5\xa0\x57\xc6\x6c\x8c\x98\xe9\xd3\xf8\xbc\x56\x7d\xaa\x42\x0f\x4d\x9b\x64\xef\xbd\xe8\xad\x4f\xf1\xbe\x25\xd5\xab\x3d\xab\x7d\xa8\x1b\xfa\xb1\x14\x2b\x9c\x4f\xf1\xc1\x30\xc5\x01\x7b\x88\xe7\xe5\xe7\x44\xcb\x8c\xeb\x28\xdd\x64\xac\x32\xd6\x1a\xab\xcc\x43\xcd\x53\xcd\x85\xe6\x32\xf3\x6b\x4a\x6e\x30\x5f\x34\x77\x59\x83\xd6\x36\x6b\x5f\x48\x93\x3d\x42\xc7\x84\x78\x68\x39\xc5\x4c\xfb\x42\xc7\x84\x8f\x0a\x9f\x1d\x5e\x10\xbe\x2e\x7c\x7b\xf8\x11\xaa\x3d\x12\xfe\x69\xf8\x55\xfa\xbf\xa7\xc5\x6e\x29\xb7\xac\x8a\xcc\x8e\x9c\x12\xe9\x8e\xdc\x18\x59\x1d\xf9\x2e\xb1\xcc\x1b\xec\x74\x76\x5b\xb4\x2d\xfa\xf5\xe8\x0f\xa2\x2f\x46\xf7\x44\xf7\xb5\x6a\xad\x27\xb5\x76\xb7\xde\xd6\x7a\x57\xeb\xc6\xb6\x48\xdb\xa7\xdb\x78\xdb\x05\x6d\x03\x6d\xdf\x68\x7b\xb8\xed\xd9\xb6\x0f\xdb\x4f\x6c\xbf\xb8\x7d\xb0\xfd\xf6\xf6\x97\x3b\x3a\x3b\x12\x1d\xf9\x8e\xb3\x3b\x16\x74\x5c\xd7\xf1\x60\xc7\x23\x1d\xcf\x75\xbc\xd8\xb1\x47\x8b\x68\x47\x8f\xad\xd6\x4e\x1e\xdb\x6c\x7e\x6e\x6c\xb5\x99\xa7\x74\x1a\xa5\xb3\x29\x7d\x81\xda\xbe\x34\x26\x57\x6f\xfa\xd8\x2d\x1a\xd3\x4c\xea\x97\x1c\xeb\xd5\xd2\x94\x4e\xa2\x96\x93\xc7\xf2\xda\x85\xd4\x76\x11\xf5\xb9\x78\x6c\x75\xcb\x36\x6a\x33\xb5\x29\x63\x87\x6b\x53\x29\x1d\x4d\xb5\x16\x1a\xb3\x79\xdc\x98\x6a\x5f\x4b\x5d\x9d\xb2\xff\x3d\x6d\x2a\xa5\xa3\xa9\x87\x49\xfd\x36\x53\xbf\xcd\xd4\x6f\xb5\x36\x55\xe9\xea\xa4\x9e\x52\xdf\xe1\x94\x8e\x50\x7a\x7b\x35\x9b\x7a\xe4\x29\x17\x94\x4e\xa7\x34\x97\xea\xe7\x52\x3e\x9f\xfa\x5e\x40\xf9\x02\x4a\x17\x51\xba\x98\x52\x3b\x69\xc9\x43\x4b\x9e\xb4\xdc\x42\x5a\x6e\x51\x5a\xf2\x94\x9f\x4e\xc9\x3f\x7a\x01\xe1\x92\x7d\x6a\xd4\x2d\x34\xea\x67\x34\xea\x16\x1a\xb5\x99\x46\x6d\x56\x73\x22\x0f\xd1\xa8\xcd\x34\xea\x0d\x1a\xb5\x99\x46\x6d\xa6\x51\xd2\x03\x34\x17\x6f\x46\x0d\x56\xf7\xd2\xc8\x5e\x1a\x99\xf7\xe1\xad\x56\x78\xe7\x51\xf9\x7c\x65\xed\x2d\xe4\xc7\x5b\x34\xbd\x65\x9b\xf6\x1b\xca\x83\x72\xec\x2d\x54\x9b\x4b\xbb\x73\x0a\xf5\x98\x4a\x49\x96\xc8\x27\x94\x98\x79\xd6\xd8\x8f\xcc\x73\x29\x5d\x30\x76\x01\xad\x92\x30\x17\x50\xf9\x4b\x94\x17\x69\xd5\x2a\x94\xae\xa4\x5e\x06\x5d\x59\x47\xad\xeb\xb4\x43\xcd\x1c\x1d\xfc\xf2\x74\xfd\x34\x4a\x67\x8d\xad\xa2\xd5\x15\x34\x7e\x15\x8d\x5b\x65\x7e\x91\xd2\x25\x63\xbd\xe6\x65\x34\xae\x40\xa9\x8b\xca\x3d\x94\x97\x28\x2d\xa6\x54\xa6\xd4\x4f\x69\x09\xb5\x8f\x50\x5a\x46\xe9\x6a\xed\x62\x73\x39\xd9\x14\x9d\x8c\x25\x6a\xad\x23\x64\xfd\x91\x64\xfd\x91\x64\xc7\xa7\xc8\x8e\x4f\x91\x0d\x9f\x22\xbc\x87\x08\xe3\x21\xd2\x77\x89\x16\x1a\xa7\x8b\xf4\x50\x6b\x9e\x5a\x4e\xa3\x74\x36\xa5\xea\x8c\xa6\x50\xdf\x7b\xa8\xef\x3d\x84\x77\x0f\x59\xff\x38\x59\xfd\x38\x59\xfd\xb8\xd9\x4b\xe9\x72\x4a\x03\x94\x96\x50\x1a\xa1\xb4\x8c\xd2\x97\x29\x2d\xa7\x74\xed\xd8\xe3\x5a\x88\xf6\xdc\x07\xb4\xe7\x3e\x20\xdd\xbd\xa4\xbb\x97\x74\x93\x7f\xcd\xc1\xb1\xe7\xcd\xa5\x63\xcf\x6b\x9f\x52\xb6\x7a\x2b\x78\x24\xad\xe0\x91\xb4\x82\x47\x9a\x39\xed\x2d\xf4\xbf\x98\xd0\x37\xcb\x31\x64\xc1\x66\x35\xe3\x2f\x52\x2e\x7d\x78\x29\x25\xe9\xbf\xa2\xf2\xe1\x83\xe6\x22\xca\x4b\x94\x16\xd3\xf5\x7e\xca\x2b\x94\xaa\x7e\xbc\x02\xbe\xbc\x72\xec\x0f\xcc\xab\xe0\xd3\xaf\x50\x4e\x7e\x35\xaf\x21\x7b\x66\x07\xac\x50\xfb\xe8\xa0\x57\xb2\x48\x56\x4c\x76\x35\x2d\xe5\xeb\x0b\x7c\x7e\x36\xc8\x6f\xdb\xc9\x67\xdb\x69\xcf\x5d\x42\x73\xe8\xa2\xd4\x43\x69\x09\xa5\x11\x4a\xcb\x28\x7d\x99\xd2\x72\x4a\xd7\xd2\xce\x37\xc9\x87\xeb\xc8\x87\xeb\x68\x56\x6b\xb4\x69\x34\xe6\x66\xb2\xe6\x31\x1a\x77\x33\x59\xf2\x10\x2c\x79\x8c\x56\x48\x5a\xf3\x18\x59\xf3\x18\xf9\xe4\x21\xd2\x77\x33\x8d\x5c\x4d\x3a\x6f\xa6\xd1\xab\x49\xef\xcd\xa4\xf7\x66\xd2\x7b\x33\xe9\xbd\x59\x6b\x27\x4d\x6b\x49\xcb\x5a\xd2\xb0\x96\xd6\x78\x2d\x69\x78\x89\xd6\x78\x2d\x8d\x5c\x6b\x0e\x53\x1a\xa1\xb4\x8c\xd2\x97\x29\x2d\xa7\x74\xed\xd8\x5a\xad\x93\x46\xed\x30\x17\x8e\x6d\xa5\x91\x3b\x68\xe4\x0e\x1a\xb9\x83\x46\xed\xa0\x51\x3b\x68\xd4\x0e\x1a\xb5\x83\xd6\x61\x2b\x8d\xdc\x41\x23\x77\x90\xff\xb7\xd2\xe8\x1d\xe4\xff\xad\xa4\x61\x07\xed\x6f\xa9\xe1\x40\xa3\xe5\x48\x1a\xa1\xb5\x52\xcf\x75\xd4\x73\x1d\xf5\x5c\x47\x3d\xd7\x99\x7d\xca\xcb\xeb\xa8\xe7\x3a\xea\xb9\x8e\x7a\xae\x23\x8c\x75\xa4\x77\x9d\xda\x6b\xca\x4f\x0a\xa1\x71\xdc\x44\x63\x2c\xd2\xb8\xa3\xc1\xbf\x12\x73\x0d\x8d\x5d\x43\x63\xd7\xd0\xd8\x35\x34\x76\x0d\x8d\x5d\x43\x63\xd7\xd0\xd8\x35\x34\xf6\x29\xb2\x6e\x0d\x8d\x7f\xaa\x61\x6d\x9e\xd2\xc2\xb4\xbb\x66\xd2\xce\xd2\x68\x67\x6d\xa7\x9d\xb5\x5d\xeb\x1b\x5b\xa5\x7d\x85\x12\xdd\x85\xc6\x1c\xf2\xdd\x0f\xb5\xb9\xe6\x06\x6d\xa6\xf9\x18\xed\x80\x9f\x52\x7a\x62\x6c\xd4\x7c\x72\x6c\x85\xb9\x89\x76\xd9\x53\x54\x7e\x66\xac\xdb\x7c\x81\xf2\xad\xd4\xe7\x45\xba\xfe\x16\xa5\xb7\x29\xed\xd7\x66\x92\x86\x3b\xb5\x0e\xf3\x7b\xd4\x73\x1d\xf5\x58\x4f\xad\x1b\x28\x7f\x82\xf2\x27\x29\xdf\x44\xe9\x29\x2a\x3f\xad\xb4\xac\x32\x37\x53\x92\x9a\xb6\x50\xda\x4b\x96\x4c\xa5\x91\x2b\xcc\x1f\x52\x8f\x75\x74\xa5\x3a\xfa\x31\xa5\x61\x15\x69\x58\x55\xb3\xe1\x69\xca\x3d\x0d\x2b\xd4\x68\x89\xbf\x8f\xd2\x7b\x34\x8f\x59\x13\xcd\x90\xb4\x5f\x43\xda\x47\xa1\x75\xbb\xb2\x6b\x2b\xa5\x97\xa8\xbe\x9d\xae\xbf\x3c\x76\xa7\xf9\x0a\x95\x77\x91\xd6\xd7\xa9\xfe\x06\x95\x77\x53\xf9\x4d\x2a\xef\xa5\xf4\x21\xa5\x8f\x28\x8d\x8d\xad\xb2\x34\xd2\x19\x31\xd7\x93\x0f\x36\x51\x92\xb3\x7a\x86\xd2\xcb\x54\xde\xa9\x39\xe6\x6e\xca\xf7\x52\x54\xc1\x54\x8f\xc7\xaa\x5e\xa4\x2b\x9b\x28\x3d\x43\x6d\xc4\x23\xca\x83\xbb\xd5\x6b\x6c\x5d\x83\x55\xa3\x0d\x73\x95\xf3\xa4\x39\xd2\x8e\x59\x4f\x63\x94\x2f\xa1\x47\xa1\x52\xfe\x02\xe9\xd9\xaa\x90\x67\xca\xd5\xa0\x33\xeb\x56\xcd\xa1\x75\xdf\xea\xd5\xc9\x2b\x12\xe3\x7b\xa4\xcb\xf3\xad\xe7\xd7\x4d\xf0\xe3\x16\xaa\x6f\x57\xb3\xde\x4e\x11\xd1\x94\xfd\xb4\x0e\xfb\x47\xab\xbe\xa3\x51\x73\x69\xd4\x35\x6a\x94\xb7\x22\xd7\x98\xa3\x94\xd7\x2d\xdd\x4e\x9a\xb6\x63\x5d\x95\xa5\xca\xa7\xdb\xa9\xdf\xcb\xca\x7f\xa3\xe4\xab\xed\x74\x4f\xa8\xe2\x57\xd7\xd5\xd3\x32\x8a\x9d\xb1\x1d\x6b\x3a\x4a\x6b\xba\x9d\x76\xc5\xf6\xda\xfe\xda\x81\x59\xbc\x83\x99\x1c\x41\xeb\xeb\xd0\xfa\xce\xf4\xad\xef\x68\x6d\x6d\xd7\x91\x3f\xaa\xbb\xe6\x29\xcc\x6e\x2b\x95\x5f\x52\xeb\xbb\x82\xd6\x77\x95\xf9\x1a\xa5\x5d\xd4\xff\x75\x5a\xef\xdd\x94\xef\xa1\x3e\x72\x8d\xdf\xa2\xb2\x5c\xe7\x7d\x94\x3e\xa0\xb6\x0f\x29\x7d\x44\x69\x6c\x6c\x3b\xcd\x61\x94\x62\xd2\xfa\xce\x1a\x25\xe4\x51\xdf\xce\xea\x21\xf4\x3b\x09\x79\x55\x0d\x59\xce\x41\x7a\xe3\x45\xa0\x6f\xa3\xe4\x79\xe5\x1a\x73\x07\x5d\xdb\x09\x6b\x5e\x6d\xb0\x68\x05\xed\xba\x55\xb0\x6a\x55\xcd\xaa\x7d\xa4\xe3\x5d\x2a\xbf\xaf\x2c\xab\xee\xc0\x15\xb5\x55\xf5\x90\xeb\xbb\xc6\xdb\x8d\x5b\xc6\x7e\x42\x5a\x47\xb5\x16\xe5\xf3\xc7\xa8\xf6\x84\xba\xea\xbd\xea\x68\xe7\xa9\x57\x9d\xdc\x27\x73\xd5\xce\xdd\x2d\xe3\x60\xe9\x77\xba\x4f\x6d\x19\x5b\xa5\xee\x07\x1d\xbe\x7d\x23\x5f\x93\xa3\x0a\x69\xb4\x61\xaf\xc6\x68\xed\xee\x24\xc4\x1e\xd2\xbb\x0a\x23\x7b\x68\xbf\xaa\xf5\xa8\xdd\x07\x56\xd5\x5e\xfb\x5b\xd4\xeb\xcd\x5b\x59\x69\x5f\x2b\x30\x46\xf1\x3a\x58\x55\xbb\x63\x78\x7b\xc2\xdb\x9f\xd5\xde\x86\xda\xe7\xef\x51\xa9\xcd\x6b\x57\xbe\xdc\x2e\xaf\x91\xff\xbc\xfb\xd1\x5e\x75\x3f\x18\x95\xbd\xcc\xff\x92\xf7\x26\xb5\x82\xdb\x69\x36\x72\x6f\xca\x5d\xf5\xb2\xc4\x57\xa3\xb6\xab\x51\xbb\xd5\x48\xef\x4e\xb2\x97\x72\x6f\xb7\xad\xa2\xd1\xde\xfe\x95\xf7\xcd\xb9\xb4\xf6\x8e\xba\x53\xec\x82\xff\xe4\xab\xcd\xaa\xbe\xee\xe4\x2b\x5e\xa2\xd1\x7d\xe1\x45\x68\x7f\xdd\x77\x7f\xdc\x5b\xbb\x47\x8d\x6a\x61\xb5\xbb\xa5\x0d\x3b\xd5\x3d\x60\x14\xaf\xd3\x51\x62\x3c\xcf\xc2\xd1\x9a\x85\x3b\x6b\x56\x8e\xa2\xe7\x68\xd0\x42\xd2\xb7\xcb\xbb\x97\xf8\x5f\x29\x72\xd6\x74\xa5\x3a\xdb\xdd\x3e\xdf\x48\xa4\x48\xcd\x17\x3b\x03\x57\xdf\xc1\xd8\x36\x6f\x95\x9a\xf8\xf7\x6d\xef\x8e\x5d\xf3\x71\xd5\xbf\xad\x4d\x57\x24\x30\xfb\x5a\xef\x50\xed\x35\xee\x5d\xf9\x89\xe7\x3d\xf2\x74\x0f\x79\x7a\xae\x6f\x8f\xf8\xec\xa3\x3b\xdb\xf4\x6a\x8f\xda\x1d\xe0\x2b\xf4\xaa\xdf\x8a\x7d\xf2\x32\x46\xed\x6c\x58\xdd\x51\x7a\x2d\x61\x85\xe9\x9a\x9c\xe1\x3e\xca\xab\x96\x44\x95\x15\xdb\xe1\xa9\xaa\xdd\xbb\x7d\xb6\xbf\x87\x7d\xc0\xe0\xcf\x51\x78\x0d\xeb\x01\x9d\x98\x1d\xee\xbd\xd5\xfb\xb1\x51\xbb\xd3\x1b\xa4\x6f\x2e\xf5\x9a\xeb\x43\x6c\xee\x5f\xe5\x93\x80\x6d\x3b\x9a\xac\x82\xb7\x02\xab\x14\x6a\x68\x9c\x5f\xfa\xe4\xde\xa0\xd6\x6b\xa8\xb5\xa7\xa1\xf5\x2b\x94\xf4\x96\x97\xe8\xbc\x60\xd2\xd9\x45\x9e\x9e\x64\xbc\xbe\x9a\xd6\xe4\x9f\x68\x8f\xaf\xa5\xf4\x24\x59\xfa\x0c\xbd\xb6\x37\x93\x3e\x5d\x93\x67\xb4\xe9\x74\x07\x3c\x4e\xfb\x2d\x5a\x81\xb8\x96\xd4\xd2\xda\x49\xda\xc9\xda\x19\xda\x7c\xed\x42\xed\x22\x8a\x24\x3f\x47\xe7\xde\x8c\x99\x35\xf3\x26\x45\xa9\xe6\x59\xe6\xe7\xcd\xb3\xcd\x73\xcd\xf3\xcd\xf9\x26\x45\xf5\xe6\x02\xf3\x42\xf3\x22\xf3\x8b\xe6\x97\xcc\x1e\xb3\xd7\x2c\x9b\x7d\xe6\x80\xb9\xc4\x1c\x34\x87\xcc\xa5\x74\x4a\xbe\xd2\xfc\xb2\xb9\xdc\xbc\x56\x3d\x05\xf9\x6f\xe6\xf7\xcc\x47\xcc\xef\x9b\x3f\x30\x7f\x68\xae\x33\xd7\x9b\x3f\xa1\x33\x34\xdd\x6d\xcc\xc7\xcd\x27\xcc\x27\xcd\x4d\xe6\x53\xe6\xd3\xe6\xcf\xcc\x67\xcd\xcd\xe6\xf3\xe6\x0b\xe6\xcf\xcd\xad\x74\xc2\x7e\xc9\xdc\x66\xd2\xaa\x98\x3b\xcc\x9d\xe6\x6b\xe6\x2e\xf3\x75\x73\xb7\xf9\xa6\xf9\x96\xf9\xb6\xb9\xd7\x7c\xc7\xdc\x67\xbe\x6b\x7e\x60\x7e\x64\xee\x37\xc7\xac\x29\x56\xa6\xe5\xa5\x96\x6d\x2d\xaf\xd0\x9c\xa2\xe4\xb1\x99\x24\xf1\xee\xc0\xff\x92\x4f\x11\x76\xa9\x27\x62\x3b\xa5\x34\xb6\x49\x69\xaa\xef\x9a\x58\x77\xa9\x96\x39\x4a\xe6\x55\xcb\x33\x75\xe9\xb5\x9b\x1f\xd6\xfb\x9b\x3b\xa5\x0c\x79\xcf\xd7\xee\xf2\x8d\x5d\x59\x6f\xb1\x86\x95\xbc\xc1\x27\x15\xae\x75\x59\xbd\xc5\xd3\x16\xda\x53\xc7\x02\x8a\x4f\x7a\xa3\x50\xde\x15\xb4\x79\xbc\x3d\xb8\xaa\xb4\xb5\xcc\xae\xeb\xf7\x97\x61\xa1\x5f\x4e\xda\x27\x07\xf6\x46\x83\x07\xfc\x73\x3f\xe0\xac\x31\x2a\xe5\x9b\xe9\x0d\x75\xcd\x90\x75\x9f\x1c\xcc\xa7\x08\xde\x33\x2b\xfe\x4f\xbe\x6a\xdf\x2d\xc2\x9e\xdd\xf0\xeb\xbd\x67\x1b\x9e\x3d\xf6\x3d\x4d\xda\xf0\x5c\xe8\xb8\xe7\x45\xb5\xf5\xaa\xfd\x84\xfa\x27\x3b\xfa\xbd\xea\xaa\xff\x69\x61\xa5\xa7\xe1\xb9\x50\xef\xb9\xd6\x5b\x7d\x9f\xf8\xdc\xee\x2b\xfb\x9e\x6e\xf5\x3f\xf9\x89\x27\x51\x6f\x0d\x8e\x45\xf9\xf6\x71\x36\x8f\xb7\x67\x8e\xa6\x7d\xec\x13\xb9\x9b\xea\xf2\x60\x7d\x32\xa1\x37\xd6\x06\x3d\xd0\x30\xf7\x03\xcf\xda\xf7\x8c\xab\xff\xb9\x56\x4f\x33\xe4\x09\x35\x39\xf9\x3d\xfb\x8b\x3c\x67\x33\x93\x10\x7a\x28\x49\x5b\x07\x35\xf9\xf7\xbd\x34\x6d\x39\xa5\xeb\x29\xdd\x48\x49\xce\xea\x0e\x4a\x77\x51\xba\x87\x92\x5c\xe7\x6f\x51\x92\x9f\xde\x7d\x97\xd2\xc3\x94\x1e\xa5\x24\xe7\xf1\x04\xa5\x67\x28\xbd\x40\x49\xce\xf4\x55\x4a\xf2\x53\xc4\x7d\xea\xc9\xf2\xe9\x55\xb9\xff\xc3\x7a\x79\xbc\xdc\x7f\xe7\xb8\x16\xd5\x7f\xff\x4e\x5f\x79\xd2\xd2\x7b\xa2\x7d\x4c\x5a\xa5\xef\x7f\x50\xb5\xfb\x24\x5e\xc7\x6b\x7e\xcd\x5f\xc7\xde\x37\x7d\x16\xd4\x3f\xe9\xc7\xf7\x7a\xd4\x37\x7a\xf0\x3d\x1d\xaf\x7d\x65\x5d\xa2\x7d\x43\x5d\x9a\xc7\xd7\xaf\x7a\xdf\xd6\x41\x9f\xab\x7d\x63\xbd\x6f\x09\x5d\xeb\x93\x1e\x56\xde\x67\xc3\x96\xfa\x73\x06\xf8\x26\xce\x82\x03\xca\x67\xc7\xd9\x3c\xce\x1e\x4f\xa7\xa7\xad\xfa\x4d\x9f\xa0\xac\x7e\xe3\xc9\x27\x27\xed\x93\x89\xbc\x01\x3f\xf8\x3d\xe0\x9f\xfb\x01\x67\x8d\x6f\xde\xa8\xe7\x39\xf4\x13\x94\xbc\xd5\xa7\xf9\xf8\x00\xe2\xe4\x5f\xc7\x07\x7e\xfa\x51\x3e\x47\x74\x12\xa5\x53\xb5\x83\xfd\x2e\x11\xe6\x80\x27\xbd\x4e\xad\x3f\x99\xa2\x3d\x57\x6f\xc1\x7c\xce\x57\x72\x6f\xbd\xff\x78\xa9\x5b\xf2\x7b\x43\xff\x6b\xb9\xd0\xff\x3d\x87\xef\x34\xe7\x42\xaf\x1d\x77\xe7\x09\xb8\x50\xf9\xbb\x09\x17\xe2\xb9\x0a\x6f\xec\x8c\x7a\x59\xbb\xa9\xce\x43\x0d\xdf\x82\x38\xf0\xb7\x5c\x6e\x1f\x67\xdb\x78\x7b\x6e\xff\x78\x2e\x6c\xf8\x36\xc5\x41\xfa\x64\x42\x6f\x8c\xe3\x42\xff\xdc\x0f\x3c\x6b\xe8\x3c\x20\x17\xfa\xf4\xfc\x7f\x82\x0b\x29\x9f\x5e\x8d\x2c\x48\x4e\xf7\xb5\xd4\xe5\x73\x75\xef\x37\xf4\xb9\x5b\x4a\xfd\x54\x25\x4f\xa8\x4b\xf2\x6f\xbd\xcf\x38\x49\xfb\x4f\x96\x97\xf9\x7c\x7d\xab\x6a\xf7\x49\xf9\xf7\x8e\x48\x6f\xfd\xf9\x19\xd9\x16\xfe\x68\x5b\xf5\xff\xfe\x81\x26\x9f\x06\xcb\x3e\xf2\x7f\x9b\xfa\x04\xf7\xb9\xb1\xa3\xf1\x89\xae\xa6\xec\x96\xae\xf8\xed\x7b\x1e\x93\xf9\xfa\x33\x7a\x8f\x51\xf5\x3f\xd9\xd3\xf6\xff\x04\x00\x00\xff\xff\x0b\x43\xea\xef\x90\x66\x05\x00") + +func liberationsansBoldTtfBytes() ([]byte, error) { + return bindataRead( + _liberationsansBoldTtf, + "LiberationSans-Bold.ttf", + ) +} + +func liberationsansBoldTtf() (*asset, error) { + bytes, err := liberationsansBoldTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationSans-Bold.ttf", size: 353936, mode: os.FileMode(420), modTime: time.Unix(1459927768, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationsansBolditalicTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xbd\x77\x60\x14\xd5\x1a\xff\xfd\x9c\x99\x2d\x49\x20\xa4\x90\xd0\x42\xd8\x4d\x42\x02\x18\x20\x81\xd0\x42\xdb\xa5\x85\xde\x09\x26\xd2\x02\x02\x46\x8a\x94\x80\xa2\x14\xc1\x8b\x8a\x08\x02\x8a\x15\x50\x54\xae\x28\x20\x86\x5e\x44\xa5\x17\x15\x01\x05\x04\x15\xc1\x50\x82\x02\x8a\x8a\xa8\x40\x76\xde\xcf\xcc\x6e\x20\xa0\xde\x7b\x7f\xef\xfb\xfb\xef\xcd\xe5\x9b\x33\x73\xe6\x39\x4f\xf9\x3e\xcf\x39\x73\xce\x2e\x78\x45\x89\x48\x59\x7e\xd9\x24\x35\x23\xa3\x57\xe7\x81\x55\x2a\x3d\x22\xf6\xde\x74\x4a\xe5\xb6\xad\xdb\x64\x4c\x91\x71\x75\xc4\xae\x07\x71\x3f\xa3\x6d\xb7\xae\x3d\x8d\xa3\x73\x82\xc4\x5e\x7a\x9c\x48\xfb\x59\x6d\x7b\x66\xb6\x8c\x19\xf9\x74\x1f\x9e\xcf\x15\x09\x2a\xe8\xda\x33\xa5\xae\xfa\x7c\x7f\x03\x11\xb5\x11\xf9\x9c\x7b\x47\x0e\x1c\x1d\xf9\x52\x9f\x9d\x22\x77\xcd\x12\x71\xd4\xbe\xf7\xc1\x71\xee\xa1\x73\xf2\xf6\x89\x34\x5d\x2c\xa2\xcd\x18\x3a\xfa\xbe\x91\x53\x06\xae\x8f\x10\x49\xdd\x22\xe2\x5c\x7b\xdf\xc0\xbc\xd1\x12\x21\xc1\x62\xd7\xfe\x60\x7c\xf8\x7d\x23\x1e\x1e\x5a\x30\xe3\x9d\x54\x91\xfb\x16\x8b\x2d\x2a\x28\x77\xc8\xc0\xc1\x6a\xe8\xf4\xbd\xe8\x6f\xca\xf3\x06\xb9\x74\x94\x59\x12\xda\x96\x7b\xfc\x91\xaa\xb9\x23\xc7\x4d\xf8\x7d\xf3\x57\x93\xd1\x5d\x41\xa4\xfa\xb8\xe1\x43\xc6\x3e\x10\xf2\x59\x48\x27\xb1\x4d\x7c\x9b\x20\x3b\x8c\x18\x75\xef\xc0\xe8\x6b\x95\xf3\x45\x3c\xd5\x79\x3e\x61\xe4\xc0\x09\xa3\xcb\xe8\x76\x74\xa9\x97\x18\xef\x7e\x60\xe0\xc8\x21\xa5\xdb\x3f\x7e\x51\x6c\xcf\x5c\x11\x29\x75\x7c\xf4\xa8\xbc\x71\x6d\x96\xf6\x2c\x23\xb6\x57\x0e\x8a\xe4\x56\x1b\x3d\x76\xc8\xe8\x1b\xd9\x17\xf0\xbf\xd1\x68\x08\x4b\xb5\xb8\xd3\x44\x76\x2d\xeb\x7b\x6c\x40\x58\xd3\xdf\x34\x97\x49\x93\xc8\xa7\xcf\xc5\xb6\x2b\x6e\x6f\xa4\xdc\x28\x0a\xf9\x26\xa8\x99\xe8\x62\x3e\x54\x96\x00\xbf\x9d\xcd\x7d\x5d\xa4\x55\xc8\xb2\x1b\x29\x7f\x7e\x16\xf2\x8d\x0c\x96\x68\x29\xf1\x13\x12\x6b\xca\x84\xc4\xaa\x1e\xd2\x8b\x67\x0e\xac\x84\x4b\x8a\xf4\x15\xd1\x63\xf4\x5e\xe4\x4a\x89\x6e\xfb\x4e\xdb\x22\x76\x11\xfb\x2b\xf6\x34\xa9\xa2\x62\xac\xf6\x1e\xfd\x90\x0c\xd5\x22\x83\xec\x5a\x29\xa7\x4d\xd3\xb4\x60\xcd\x76\x4a\x42\x8c\x6e\x32\xc1\x40\x6d\x9c\xa9\xbb\x4e\x8b\x9e\xad\xb8\x72\x1b\x37\xec\x5f\xf8\xba\xab\x34\x67\x73\xb5\x3a\x47\xd4\x47\x27\x7f\x27\xa6\xc6\xf6\x69\x26\x13\x52\xc6\x11\xf0\x44\x4b\x0f\x60\x99\x74\xd5\x3f\x91\xaf\x6d\x79\xd2\xc2\x96\x67\xfc\xe6\x8c\x95\xd1\xf6\x3d\x52\x47\x15\xca\x6e\x9e\x75\xd0\x96\x19\x9d\xf4\x58\xc9\xb2\xad\x90\xc9\x5a\xba\x71\x91\xbe\x46\x8c\xab\xcd\xf5\x5a\xc6\x64\x82\x38\xc6\x9d\xa2\x0d\xa7\xfd\x96\x36\x0a\x0c\x00\x73\x40\x0c\x48\x65\x4c\x36\x28\x8f\x8e\x49\x60\xa2\xd5\x9e\x96\x8d\xce\xfd\xf2\x82\x7d\x8f\x71\x14\x7b\x55\xc1\x60\xab\xed\x2d\x55\x79\x56\xd5\x91\xee\xbf\xc7\x56\x55\x74\x54\x34\xaf\xad\xfe\x65\x96\xac\xff\x79\xef\x5b\x72\x5c\x57\xe4\xf9\x3c\xae\x1f\xe2\x7a\xb9\x73\x36\xba\x7b\x1b\x6f\x70\xbd\xc2\x76\xda\x38\x48\x1c\x1f\xa3\x6b\x14\x6d\x0f\xec\xe3\xb7\x31\x43\x5b\xa6\xf0\x5d\x42\x18\x97\x40\xeb\xa1\x6d\x6c\xb6\x66\xdc\x8c\xf9\xd3\xec\x67\x0c\x30\x4c\x1f\xac\x6b\xf8\x49\xb0\xe4\x4f\x9b\xf2\xc6\x17\xb4\x4d\xf4\x58\x6b\x7c\x79\xc6\xf5\xe6\xde\xe4\xe4\x01\xfc\xba\x17\x1b\x6f\x81\xe5\x36\x31\xae\x22\x53\x56\x6b\x26\x1f\xe9\xb1\xc6\x10\xec\x3f\x18\xe0\xde\xe4\xaa\x13\x32\xfb\x69\xdb\x81\x6a\xc8\x6c\xe5\xfe\x28\xcf\x9e\xb4\x9f\x95\xe6\xda\x55\xc9\xb5\x9e\xad\x90\x8e\x26\xf7\x66\x9f\x6d\xb8\xf1\x93\x9e\x26\x1f\xd8\x06\xcb\xdd\xf4\xb5\x05\x39\xc0\xb0\x2d\x34\x0e\x21\x3b\x8c\xeb\x0f\x40\x16\x18\xa4\x5d\x94\xa1\xf4\x25\x39\x56\xc8\xa0\x00\x1e\xc0\xc7\x4a\x7e\xde\xff\x8a\x20\x31\x5e\x83\xc3\xee\x26\xb7\x25\x61\xe6\xa1\x24\x90\x29\x5f\x9c\x87\x3b\x81\xaf\x53\x68\x13\xac\x5c\x94\x04\xb9\x08\xe4\x37\xc1\xe2\xfd\x6f\x00\xbf\x77\x59\xb9\xb8\x03\xfe\x3c\x58\x88\x31\x5b\x2b\x57\x37\xf3\x70\x07\x06\x4b\x1b\xda\xbb\xac\x5c\x94\x84\x99\x8b\xd3\xc6\xe7\xb4\x1f\x98\xb1\x9a\xf6\xfe\xda\xe2\x3f\xf6\xfe\x43\x5b\xd5\x7e\x41\x1a\x9b\xf1\x9b\x3e\x58\xf1\x98\xfd\xff\xa5\xb5\x78\xa1\xa6\xfe\xa9\x0d\xd4\x77\x42\x71\xeb\xe7\xd9\xf8\x39\xc0\x77\xc2\xad\xd6\xf8\x1e\x7c\x5d\x7c\xef\x68\x69\xe9\x37\xf9\xac\x68\xd6\xa9\x35\xde\x7f\x6f\x72\x53\x35\xc0\x95\xa9\xeb\xb2\xd9\xea\xc9\xfe\x7b\xfd\x88\xd9\x1a\x97\x78\xee\xb8\xd3\xf6\xcd\x76\xb9\x04\xd9\xf7\xf9\xaf\xfd\x7e\x16\xc7\x71\xab\x65\xf1\xbb\x8f\xb9\x66\xf2\x51\xd5\x9c\x07\xfe\xd6\xf8\xf1\xe6\xbd\x39\x2f\x99\x1b\xff\xd4\x9a\x73\x96\x3a\x35\x73\x39\x0f\x9f\x7a\x07\xee\x2b\x99\xf5\x62\xe6\xec\x7f\x6d\xcd\xf9\x6e\xce\x39\x6b\xbe\x93\x67\xda\x39\xe6\xbc\x37\xe7\xde\x9d\x6d\x80\x93\x04\x47\x7f\xc9\xb6\x2f\x0b\xc4\xba\xec\x66\xec\x89\x25\x72\x5d\xde\x71\x37\x32\xbd\x59\xe3\xcc\x7a\x2b\x30\xae\x73\x1d\x65\xbf\x2e\xc3\xed\x55\xa5\x25\xfa\x14\x72\x5f\x59\x5c\xfc\x2e\x6b\x9c\x13\x6e\xe6\x29\xa4\x38\x0f\x5c\xeb\xa6\x3f\xce\xf6\xd2\x96\x1a\x93\x62\x2e\x1d\x6b\x58\xb7\x06\x88\xc7\xd9\x44\xee\xb3\x7f\x2b\x9d\xed\x17\x25\xdb\x5c\x4f\x02\xf3\xad\xb1\x95\xbf\x4d\xc6\x21\xed\x3b\x79\x09\x3e\x6c\x8c\x6b\x13\x58\x5f\xe6\x39\x26\x30\x97\xd6\x4b\xa6\xc3\x23\x83\xb0\xf3\x88\x7d\xb3\x3f\xe6\x40\x7c\x27\x68\xff\x0d\xae\xd9\x1a\x50\xd3\x0d\x8c\xc5\x81\xf5\xd9\xae\x5f\x33\x7d\x91\x14\xdb\x65\xa3\x90\x75\x66\x89\x7e\x5d\x56\xda\xde\x95\x1e\xe6\x3b\x20\x84\xf8\x83\xf1\x39\x88\x38\x83\xf1\xc1\x59\x19\xff\xc7\x4a\x42\x48\x63\xfa\xc4\xba\x4f\x28\x9e\x23\x37\x6b\x2f\x50\x03\xff\x6b\x8e\xfc\x9c\xde\x3e\xdf\xcc\xf5\xc6\x9c\xf3\x81\x79\x50\x74\xdb\x7c\xc8\xfb\x6b\xdd\x59\xb1\x35\x30\x16\x98\xb5\x5e\xd2\xe7\xe2\x71\x41\xed\xe0\xef\x31\xe3\xc8\xad\x5a\xfe\x8b\x1d\x33\xf7\x77\xfd\x65\xde\xdf\x31\x5f\xd1\xff\x21\x98\x75\x67\xac\x25\x62\x2e\x51\xef\xfe\xb5\xee\xb6\x98\x6f\xaf\xef\xde\xb6\x57\x8d\x7c\x5b\x0d\xe3\xd9\x9b\x7e\x2d\xc3\x97\x5e\xcc\x9b\xd2\x52\x0f\x34\x28\xce\xdd\x9d\xfe\xfc\xd3\xbc\xbb\xe9\x47\xa0\xde\xf5\x57\x8d\x01\x8e\x76\xc4\x56\xd6\xd8\x6e\x72\xe3\x7c\x5d\x5a\x3a\x17\x49\xf3\xc0\xfb\x95\x7a\xe6\xbd\x77\x5a\x92\x41\x4b\xf4\x2a\xcb\x56\x0d\x19\xab\x9f\xb4\x64\x2e\x21\x13\xc4\xfb\xf2\x4d\xbf\x5d\xa3\x63\xf1\x7a\x42\x8d\x99\x76\x9a\x20\x73\x8a\x79\x7d\x95\xe7\xdd\xad\x5a\x33\xf7\x0b\xfe\x35\x38\x29\xb0\x9e\xf3\xae\x37\xd6\x05\xfa\x1a\x07\xd6\x20\x0f\x75\xdd\x48\x3f\x2c\x95\x6c\xd1\x52\xca\xde\xd7\xf8\xd1\xf6\x9c\xb4\xe0\x1d\x9c\xe3\x7f\xbf\x82\x5d\xd6\xfa\x3e\xd4\xf6\x99\x98\xfe\x65\x05\xd6\x74\x73\x9d\xfb\x05\xde\x5b\xe9\xcd\x8d\x73\x5c\x7f\xae\x4d\x37\x7e\xe7\xde\x6e\xdb\x21\xe1\xe4\x31\x33\x00\x64\x7d\x97\x2c\x3e\x53\xa5\x96\xc5\xcb\x21\xf1\x3a\xde\x95\x74\x47\x98\x34\xc3\xdf\x65\x25\xf0\x39\x79\x0a\x31\x73\x05\x7a\xdb\xd6\x8b\xdb\x42\x9e\xb1\x5b\x7b\xc6\xf7\x87\x85\x65\x92\x66\xcb\x30\xfa\xe2\xdf\x05\xae\x13\xf1\xef\xbc\xed\x0f\x69\x66\x7b\x5f\xee\x43\x6e\x91\x23\xdd\x9a\x4b\xcb\x6d\x0f\xc8\x68\x8b\xbf\x67\x99\x6b\xd4\x22\xd8\x66\xd3\xa4\x17\xc8\xb5\x69\xc6\x11\xe2\xa9\x62\xe5\xe7\x2a\x3a\x9e\x93\x2a\x56\x8c\xac\xb7\x7a\x4b\x23\xc3\xe4\x48\x7f\x45\x6a\x98\x9c\x22\xfb\x3e\x63\x4a\x31\xbf\x1a\x3b\x1f\x95\x3a\xc1\xcf\x51\xc7\x8f\xe3\xdb\x8b\xd2\xdb\xb1\x41\xba\x39\xcc\xba\xae\x4f\x6c\x1d\x0c\xc3\xd6\x06\x9e\x1f\x63\x5d\xfc\xb7\xa4\x9b\xd0\x1b\x89\x07\xb4\x54\xb3\x8c\xad\x5a\x53\x69\x07\xaa\x69\x4d\xad\x7d\x41\x3b\xdb\x68\x79\x46\x6f\x26\xc9\xe6\x1e\x8e\xbd\xdd\x6e\x78\xfb\x20\x00\x1f\x7b\x9e\x7b\x4d\xe8\x4e\x99\x09\x5e\x0d\xec\xc9\x4c\x54\x05\xec\x89\xa4\x13\x78\x0e\x99\x69\xb4\x4b\xcd\x7d\x85\xb9\x4f\xa2\x7d\x1f\x5e\xa6\xd3\x56\xa4\x35\x6b\xba\x1b\xfd\x09\xb4\x9f\x81\xf7\xc0\x03\x60\x0a\x78\x8c\xe7\x05\xb4\x8b\x78\xce\xfe\x51\x4e\x03\x73\x4f\xd2\xda\x5c\xe7\x81\xb9\xef\x19\xa3\x37\x97\x67\xd5\x28\xf6\x2e\xd7\x88\x23\x55\xca\xe1\xcb\xf3\x7a\xb8\xbc\x70\x27\xac\x3d\x8c\x1f\x2f\x82\x04\x9b\xc8\xbf\x68\x1b\x82\xca\xa0\x33\x30\xf7\x40\x75\xfc\x32\x70\xb1\xcc\x78\x0a\x74\xe5\xfe\x5d\xec\x7b\x02\xbe\xb3\xff\x34\x7e\xd3\x6b\x1b\xf9\xe0\x2d\xae\x39\xc7\xf8\xbe\x10\x31\xd8\x79\xfb\xd6\x89\xdc\xf0\x72\x7d\x3f\xd7\x8f\xd0\xea\xfe\xdd\xbf\xd1\x8c\xfb\xc6\xb4\xc7\x01\x66\x8d\x0e\xf4\x03\xe3\x1d\xc0\xd9\xc2\x60\x07\x67\x54\x04\x6f\x81\xa5\xe0\x23\x70\x11\x30\xd6\xc7\x39\xc8\xf7\x03\xd7\x6c\xb7\x8d\x3a\x80\x73\x85\xc1\xce\xdf\xf7\x35\x38\x0a\x4e\x8b\x14\x21\x5f\xf4\x0d\xd7\x7f\xf2\x2c\x83\xb6\x66\xe0\x39\xf6\x7c\xf3\xfc\x7e\x19\x5d\x69\x2b\x83\x56\xa0\x36\xf2\x27\x68\xb1\x5d\x74\x83\x36\x0a\x64\x71\xed\xa1\xed\x06\x38\xfb\xf8\x16\x71\xff\x06\x6d\x08\x78\x85\xf1\x4d\x68\x6b\x81\x43\xa0\x3d\xf7\xb4\x52\x97\xeb\x31\x5c\x3f\x07\xd6\x80\xb2\xfe\x18\x7c\x7b\x68\x63\x00\x31\x17\x3d\x1d\xf0\xc3\x8c\xa1\x5e\x40\x96\x38\x7c\x9c\x07\x7d\xe7\xe1\x8b\x73\x93\x84\x81\x2a\xf4\x3f\x44\xdf\x36\xb0\x2b\x10\x23\x76\xa4\x06\x68\xce\xf5\x29\xd0\xc2\xcf\xa1\xef\x6e\xda\x87\x69\xb7\xfb\x39\x30\x5e\xf2\x9f\x44\x8c\x4f\xb8\xdf\x04\xce\x71\xfd\x26\xed\x66\xbf\x0d\xdf\x97\xe0\x24\x78\x1f\x7f\x7e\xe4\x59\x0a\x20\x3e\x83\x13\x95\x6f\x16\x79\xad\x49\x1e\x7f\x36\x6b\x29\x70\xce\x30\xd7\x91\x18\xf3\x9c\x01\x5e\xe6\xd9\x6e\x73\xed\xe3\x7a\x83\xe3\x88\xbc\xec\xf4\xc8\xcb\xfa\x3e\x79\xd9\xb1\x4d\xd2\x9d\x63\x64\xb7\x63\x8f\x91\xef\xdf\xc7\xfa\xcf\x1f\xb6\xef\xb8\x1e\x60\x6c\xf5\xef\x4f\x8d\x83\xc5\x7b\xdb\xc0\x5e\xb7\xaa\xb9\x36\x16\x9f\x3d\xec\x2d\x8d\x3f\xac\x73\xc7\x87\x81\xf3\x0a\xef\x69\xeb\xec\xc1\x5a\xec\x98\x2f\x39\xe6\xb9\xc3\xf1\xba\x2c\x73\x78\x8c\x53\xd6\x78\x73\x2f\x72\x95\x39\x6b\xae\x83\xa7\x25\xd1\x5c\xd7\x58\x53\x86\x9a\x7d\xb6\xdf\x8d\xc3\xf8\x3d\xc2\x56\x20\x0d\xcd\xe7\xfa\x4f\x52\xc7\x94\xb1\x3d\x28\x23\x2c\xb9\x27\xb9\xce\x33\x96\xd8\xbe\xb0\xf6\xf6\xf7\xeb\x2f\x5b\xcf\x3d\xf6\xd5\x3c\x3b\x46\x5f\x4b\xe9\x64\xef\x2a\x5e\xbd\x0d\xba\xd0\x69\x7f\x5d\xbc\xb6\xd7\x8c\x4e\x8e\x14\xf6\xfa\xef\x32\x4f\x8a\x6d\x99\xef\x4e\x5a\xb3\xcf\xf6\x2f\xce\x37\xef\x1b\xbf\xd8\x8b\xe0\xe5\x67\x79\xc7\x6c\x59\x2f\x5b\xf3\xac\x85\xfd\x7e\xe3\x78\x89\x77\xdc\x2c\xf3\x3d\x60\xed\x17\xb7\x19\x47\x1c\xba\xd4\xb3\x35\x15\x97\x63\x94\x4c\xc7\xdf\x37\x9d\xed\x8d\x7f\x3b\x63\x8d\xf7\xec\xfd\x64\xaa\x15\xff\x32\xe3\xa4\xed\x4b\x63\x0d\xf1\x26\x81\x7a\xd6\x1e\xe9\xb0\xc4\xda\xbf\x93\x2e\xb6\xc5\xac\xa3\x65\x24\x4d\x9f\x2e\x3d\xb0\xf1\xb5\xed\x67\xde\x45\xfe\xf7\xac\xc5\x33\x7b\x3f\x8f\x7e\xc4\x38\x1f\xe0\xff\x73\xf3\x9d\x05\xdf\x2e\xfb\x05\xe3\x38\x71\x66\x70\x1f\x1d\x38\x23\x46\x17\x9f\x49\x9c\xe5\x64\x9e\xed\x7b\xae\xb7\x5a\x67\xc1\x8a\xc5\x67\x13\xd3\xe7\xa0\x6d\xc6\xe3\x41\xbd\x25\xd1\x71\x18\x99\x0b\xc8\x6c\x03\xc3\xa5\x21\xad\xb5\x27\xb0\x07\x72\x69\x8d\xdf\x63\x8c\xb2\xf4\x0d\x37\x96\xe1\x73\x8c\x25\x0b\xac\x71\x8f\x1a\x8f\xdf\x76\xe6\xdc\x16\x38\x13\xed\xb1\x38\x9a\x67\xea\xe4\x1d\xd9\xc5\x3a\x6b\x1e\xa1\x7f\x99\xac\x72\xd2\x3a\xd1\x4b\xdd\x3d\x6f\xee\x9d\x2c\x5b\x5b\xe5\x2e\xfc\x49\xb0\x1f\xb1\xf2\x1d\x62\xbb\x22\xfd\x78\x27\x54\x63\x5d\xaf\x62\xfb\x45\x9a\x5a\xef\xca\x33\xe4\x99\xf7\xe4\xcd\xf3\x4a\x19\x7c\xb8\x66\xac\xe4\xbc\x91\x60\x3b\x72\xf3\xac\x93\x60\x9d\x3b\x91\xb7\xde\x7f\xe6\xde\x32\xca\xac\x7d\xe3\x2d\x7b\x32\x63\x58\x6b\xad\x77\xe3\x44\xf6\x20\x6f\x4b\x67\x7c\x48\xb2\x6d\x05\xc3\x24\xdc\x61\xea\x59\x6f\xbc\x79\xf3\x5c\x85\x2e\x1d\x3e\x6c\xd3\xac\xfb\xf2\xb7\xce\x58\xec\x1f\xb6\x19\x2b\x99\x33\x89\x96\xbd\x32\xd6\x9e\x25\x70\x7e\x92\xcc\x90\x7e\xf2\xa8\xa3\xb1\xf4\x71\x3c\x27\x03\x1c\x7b\x38\x13\xef\x20\xd6\x21\xe6\x5e\xdf\xd4\x6d\x2c\x71\xe6\x72\x7f\x9f\x84\x39\x1e\x36\x7e\x74\x38\xa5\x6c\x10\x6b\xbe\xf3\x0b\xa9\x66\xaf\x6a\xec\xb1\x45\x1b\xfb\x99\x1b\xe7\xa8\xcf\x2d\x37\xf7\x32\x19\xb2\x94\x3c\x8c\x2a\x6e\x83\xcb\xcb\x40\xe7\x57\xd4\xe3\x1b\xd2\x92\xf7\xba\x0b\x7b\x63\x9d\x2d\xa5\x63\xb1\x5d\x8b\x7b\x4d\xe2\x6d\x2b\x0c\xd6\x41\xa3\x1d\x48\x66\x21\x71\x01\xa7\x7f\xbd\xb9\xc1\x5a\x71\x63\xb8\x95\x43\x73\x2f\x66\xee\xed\xb7\x5a\x35\x59\xd5\xe2\xee\x15\xea\x79\x0b\x71\x7d\xcf\x7b\x67\x9b\x38\xed\x99\x5c\xbf\x26\xf1\x56\xfe\xc9\x81\x59\x03\x56\x1e\xc8\xbf\x15\xfb\x1d\xad\xc3\x25\xcf\xda\xce\x31\xcf\xcd\xfa\x21\x2f\x8e\xeb\xc4\x36\x47\x12\x83\x7e\x92\x24\x67\x47\xce\x0f\xfb\x99\x6f\x8f\xdf\x3a\x33\x9a\x75\xe2\xcf\x95\xbc\x63\x7e\x36\x00\x7a\x03\xcd\xac\x19\x33\x6f\x8e\x6b\xf2\x84\xfd\x3d\x19\x82\x9f\x2b\xcc\xfc\x99\x35\x14\x68\x6b\x58\xe7\x85\x53\xd4\x64\xaa\x71\x2d\xd0\xfe\x61\xd6\xf8\x4d\x5f\x33\xf0\xe1\x1d\x7f\x9d\x5a\xb5\xb2\x87\x31\x47\x44\x2f\xf6\xad\x58\x97\x55\xc3\x17\xfc\xf9\xfd\xa7\x3d\xf8\xcd\x3d\x30\xe7\x9b\x92\xed\x5f\x78\x39\x6d\xfc\x60\xee\x7b\x6e\xf2\x1b\x68\xff\x71\x8f\x4a\xed\x9b\xf5\x67\xce\x15\xeb\x6c\x76\x67\x1b\xf0\xd1\x9c\x8b\xe4\x23\xde\x9c\x33\x56\xdd\x7e\x6f\x2c\x64\xdd\x79\xbe\x98\xa7\x5b\x2d\xf3\x85\xbd\x91\xf3\xa8\x34\x75\x8e\x97\xb6\xce\xe3\xb2\xd4\xf1\xb1\x4c\xc1\xbf\xe1\xf8\xd7\x32\x28\xc4\xd8\xec\x9c\x6e\x6c\x0f\xea\x02\x4f\xc3\xa4\x96\xe5\x07\x7b\x30\x47\x9a\xcc\x0b\x7e\x93\xf8\x59\x97\xcc\xb5\xb6\x98\xb3\x80\x9f\x4d\x8a\xcf\x90\xfe\xf7\x2f\x5b\x64\x91\x32\xb4\xe1\xc0\x7c\xa7\x9b\xef\x3c\xde\xa5\x06\xcf\x8c\x69\x20\x8f\xbe\x85\xf4\xbd\xe1\x87\x71\x0f\xf7\xfb\xb8\x06\x86\x8f\xeb\x1d\xe0\xd5\xc0\xbb\xd7\xdc\x6f\xb0\x17\xf0\xed\xe7\x79\x22\xed\x59\xff\x73\x49\x40\xf6\x7b\xbf\x3e\xdf\x50\xff\x38\x03\x9b\x3e\x53\xd7\x48\x3f\x8c\xf2\xb4\x4b\xfc\xef\x57\x53\xbf\x65\x63\xbc\x1f\xd6\x3b\xde\xdc\xc7\xb8\xd8\x2b\x31\x56\xa2\x6c\xd3\x54\xb3\xe2\xe7\xe6\x67\x40\xb4\x4f\xf1\x3c\x44\xef\x2f\x69\xb4\x6f\xd8\xc7\x1b\x5f\xdb\x5d\xc6\x45\xd6\xda\xe3\xb6\xb7\xe5\x71\x7b\xae\x64\x68\xc3\xd8\x3f\x5e\x94\x31\xf6\x57\xa4\x9d\x7d\x9a\xcc\xe6\x7e\xa3\x6d\xa1\xfc\xcb\x36\xd2\xf8\x9e\xfd\x6b\x17\xfb\x0e\xfa\x0f\x18\x27\xb4\x61\xc6\x0d\x3d\xcf\xf8\xce\xfe\x02\xcf\x7e\x31\x36\xdb\x87\x72\x0e\x6d\xc8\x9e\x39\x57\x5e\xb0\x9d\x34\xae\xd8\x9b\x18\x37\xcc\x71\x8e\x31\xb2\xd9\xfe\xa1\xf1\x25\xf5\xd7\x0e\x6c\x34\xa1\x7b\x54\xba\xcd\x07\xb6\x18\x8b\x1d\x0d\x8c\x17\xa9\xb7\x8e\xb6\x5f\x8d\x22\x6b\x7e\x1c\xe7\x7c\x7d\x5c\x9c\xfa\x79\x5a\xea\x8b\xf5\xe7\x08\xe4\x47\x9a\xef\x3e\xfd\x3b\x6a\xd9\x5c\xb7\xb6\x10\xdb\x69\xff\x3b\x9e\xb6\x8e\xf5\x79\xe3\x69\x49\x25\x67\x49\xb6\x57\xf1\xe1\xb4\xb4\xb5\x9e\x2f\x35\xf7\xf5\xac\x43\xeb\xa9\xa5\xe5\x32\x20\xf0\xee\xeb\x61\xff\x4a\x6a\xd2\xe6\xde\xfc\x6c\xce\xfc\x3c\xa0\x81\x44\xea\xbf\xa0\xfb\xa2\xf1\x11\x75\x67\xbe\x67\x17\x59\xeb\x1d\x3a\x58\x9f\xe6\x9b\xb5\x61\x8b\x62\x5e\x9c\x90\x9a\xfa\x0d\xde\x51\x37\xd8\xe3\x97\x92\xbe\xfa\x31\x0b\xf7\xd8\x1a\xcb\x34\xfa\xba\xab\x55\xd2\x47\xd7\xa8\xc9\x08\x79\x40\xcf\x96\x21\xb6\x45\xd2\x5f\xff\x5d\x7a\xf1\xac\x8f\x6d\xa0\xcc\xe6\x9c\xfd\x92\xfe\x0e\xe7\xfb\x16\xf2\xa8\xde\x5d\x16\x30\x76\x0a\xbc\xef\xd5\xcb\x4a\x0b\x30\x96\xbd\x70\x3f\xdb\x19\x99\xa2\xf7\x90\x1e\xa0\x2f\xfb\xe1\x51\x26\xb4\xb9\xbc\x1f\xe7\xb2\x27\xe8\x29\xf5\x55\x7f\x7c\x2d\x23\x9d\x6c\xdb\xa5\xad\x9e\x2e\xcd\xf5\x61\xec\xa1\x9b\x4a\x6f\xab\x1d\x26\xd9\x7a\x3f\x49\x60\xbf\x3f\x91\x33\xc1\x20\xd0\x1f\xb9\xb1\x7a\x03\xce\xf8\x63\xa5\x8a\x9e\x0b\x8f\x31\x32\x47\x1f\x2e\xc3\xf5\x8b\x92\xab\xd7\x30\xbe\x54\xfd\x8d\x83\x9c\x17\xbe\xd3\x1b\x19\x57\x90\xab\xad\xe7\x1a\xeb\x91\x71\xe9\x3d\x38\x43\x5c\x14\x1b\x32\x7d\x9d\x99\x32\x36\x70\x1e\x63\xdf\x6e\xac\xe0\x5d\x3f\x8b\xb9\xff\x22\x08\xe2\x3c\x35\xc3\x04\x7c\x3a\x79\xb6\x21\xf0\xb9\xc3\xc7\x7a\x3d\x69\x64\x6b\x6e\x2c\x73\x96\x35\x26\xb2\xd6\x04\x83\x20\x6b\xcd\x7d\x9f\xb3\xdb\x1f\xc6\xe9\x12\xfa\xde\xb4\x1f\xe4\xfc\x67\x7d\x46\x62\x3c\x7b\xeb\x73\x55\xe3\x0b\xf4\x2e\x30\xdf\x47\x7a\x92\x2f\xdf\xbf\x5e\x1a\x6f\x59\xfa\xfd\x9f\xd5\x16\x9f\x2f\x3d\xfe\x73\xa5\xb1\x85\x5c\x57\xb7\x3e\xd3\xc9\xe3\xec\xfb\x0c\x67\x57\xf3\x5d\xd5\x80\xb5\xa3\xb9\xb4\x87\x23\x93\xa7\x04\x7d\xbc\x0c\x34\xb9\x54\xeb\xa4\xaf\x5a\x67\x6c\x83\xd3\xbb\xe0\xf1\x71\x78\xad\x05\x9a\x06\x50\x4b\xab\x6f\x6c\xa1\x8d\x87\x9f\x93\x5a\x16\xf5\xbb\xdd\x42\xb6\x9e\x6e\x3c\x85\xbc\x57\x1f\x2d\xdd\xe1\xfb\x01\x6a\xe7\x61\xed\x94\x84\xaa\xf5\xc6\x8b\xf0\xde\x1a\xce\x63\xf5\x09\xe4\xbf\x91\x8c\x07\xa3\xe0\x34\x48\x7b\x55\xa2\xb4\x57\x8d\xab\xfa\xab\x12\xa7\x9d\x67\xce\xb9\xe5\x19\xe6\xac\xb9\x97\xad\x66\xce\x59\xc0\xde\xdd\x30\xe7\x7d\x39\xff\x3b\xcc\x98\xee\x3f\x3f\x18\xa5\xfd\x7b\x67\xf3\x7b\x00\x5f\x89\xcf\x4c\xfe\xe1\x73\xba\x12\x9f\x4d\x5a\x9f\x49\xfe\xb7\xf6\x7f\xfc\xcc\xd2\xfa\xdc\x70\x99\x74\xf8\xa7\xcf\x28\x4b\x7c\xc6\xf2\x9b\x79\x56\xbe\xf5\xd9\xa5\x11\xad\xa5\xfb\xae\x17\x7f\x76\x52\xfc\x59\xce\x9d\x6d\xe0\x73\xc9\x1f\x02\x6d\x61\xa0\xf5\xdb\x4d\xf7\x5d\x36\xdf\x59\x66\x5d\xdc\xd9\xfe\x07\x1e\xfe\xe3\x67\x95\x25\x3e\x33\xa9\x5a\xfc\x59\x9b\xd5\xfe\xf5\xb3\x9c\x92\x9f\x65\x7e\xfd\xdf\x3e\xc3\xfc\xcb\x67\x3d\xb7\xda\x39\xd4\xb9\x79\x36\x68\x4b\xfb\xfc\xff\xfc\x99\x66\x6f\x31\x3f\x5f\x79\xa0\xb8\x2d\x7e\x2f\xfd\xb7\xf6\x6f\xde\x93\x25\x3f\x17\xfc\xcb\xe7\xa0\x56\xae\xf0\x33\xf0\x5d\xc5\xf2\xc0\x67\x7b\x09\xf6\x4d\x7f\xdd\x23\xfc\x5f\x6f\xff\xc7\x1a\xfc\xa7\xb6\xc4\xe7\xe1\x3f\x81\x4b\xff\x2d\xe7\xff\xd8\x06\x3e\x87\xfd\x6f\xed\x9d\x39\xba\xf9\x19\xec\x7f\x69\x4b\x7c\x1e\xfd\xb7\xad\x75\x06\xfc\x0f\x28\xfe\x5e\xc6\xf1\xab\x78\x41\x2e\x18\x03\x5e\x02\x87\x4c\x58\x67\xc6\xbf\x81\xa3\x0a\xef\xb0\x2a\xd2\xde\xb9\x52\x6a\x81\x4c\xd0\x02\xe4\x5a\x67\xcb\xff\x00\xc7\x1c\x0b\xed\x83\x5c\x52\x0b\x64\x06\xda\x5e\xe0\x45\x13\xe6\x79\x32\x00\x6f\x89\xeb\x9b\xd0\x95\xa4\x82\x5e\xb6\x79\xd2\x02\xdc\x1f\x68\x73\xc1\x8b\x16\xfe\xee\xfb\x1a\x33\x0f\x8b\xa4\x32\xf0\x06\x21\x0f\xee\x77\xee\xc3\xef\x7d\xe8\x31\xdf\xdf\xff\x01\x8e\xc7\xa4\x97\x19\x5f\xd0\x83\xb2\x81\x76\x82\x79\xbe\xfd\x8f\x78\x13\x3b\x6f\x62\xe7\x45\x0b\xf7\x3b\x0f\x60\xe7\x00\x3a\x0e\xc8\x18\x13\xc5\xbc\x17\xf3\x58\xcc\x4b\x71\x7c\x37\x7d\x2e\xb6\x1f\xd0\xfb\xff\x35\x8f\xff\x43\x5e\x2a\x03\xef\x3f\xe5\xe5\xff\x30\xee\xdc\x7f\x8a\xfb\x3f\xf9\x5e\x12\xda\x32\x55\x97\xb5\x63\x74\xa0\x1d\x01\x16\xff\xad\xdf\x8f\xc9\x13\x8e\x73\xf2\x2e\x31\x3e\xe1\xbc\x5b\xde\xb5\xbe\xd3\x5d\x26\x63\x02\x78\xe7\x6f\x6a\xa8\x5e\xa0\xb5\xce\xf2\xfa\x10\x79\x42\xdf\x67\x7e\x96\x67\x7e\xa6\x63\x7d\x17\xf2\xce\x5f\xea\xc0\xfc\x1c\xc4\x44\xe0\x3e\xf0\x3d\xe3\x0a\xec\x2e\x70\x76\x90\x97\x99\x07\x5e\xc6\x85\xfa\xa1\x22\xfe\x8e\x1f\xe7\x10\x99\x4b\xfd\xd5\x73\x0e\x97\xd7\x4c\x9e\xac\xcf\x6e\x96\xa9\x18\xd0\xc9\x3c\x08\x98\x5f\xf2\x17\xb7\xda\x72\xeb\x03\x42\x51\x99\xf4\xe5\xf9\xbf\x47\x57\xec\xc4\x65\x79\xf1\xf7\xfc\x86\xf9\xf9\x96\x1b\x98\x9f\x61\x75\x42\xa6\x27\xa8\xc9\x39\xeb\x92\x09\xeb\x7b\x97\xe1\xc6\x8c\x5b\x9f\xcb\x1a\x3f\x9a\x9f\xcd\xa2\xff\x03\x3f\x58\x9b\x39\xc0\x32\xc6\xfc\x2c\xb9\xae\xb6\x5f\xee\xc1\xee\xe3\x01\x7d\x9d\x69\x23\x8b\x61\xda\xe5\x59\x3b\x75\x41\x76\xe8\x47\x2c\xc4\x12\x67\x7b\x10\xc7\xbe\xbb\x2b\xef\x9d\x9f\x54\x6f\x5f\x2f\xee\x7b\x95\x18\x17\x1e\x40\x84\x79\xcf\xb3\x0c\x90\x09\xde\x06\xfd\xf4\x64\xf6\xa0\x65\x8d\x6f\xd8\x83\x96\xd1\x87\x19\x06\x7b\xc1\x65\x5c\x9b\xdf\x1d\x79\x03\x9f\xc1\x98\xdf\x27\x1c\x35\xbf\xb7\x0e\xbc\x8f\x43\x82\x8e\x48\x93\xe0\x4d\xbc\x9f\x67\x1b\xc7\x9d\x91\xd2\xc5\x16\x63\x7e\x4f\x20\x95\x79\xa6\x99\xef\xbf\xa0\x7c\xe3\x23\xe4\x5f\xbb\xf5\x9d\x3d\x75\xd4\xdb\x28\x32\x75\x11\xd3\x09\x67\x34\x67\x8a\x38\xa9\x1a\x9c\xcc\x7e\xfb\xac\xb8\x89\x69\x93\x23\x91\x7d\xf1\x7e\x19\x04\x67\x7f\xd8\x14\x6b\xbc\xff\xfb\xeb\x76\xe0\x31\xf0\x02\x78\x0e\xac\x36\xcf\x04\x41\xa2\xde\xb0\x71\x56\xbb\xb3\x35\xa1\x5f\x61\xbe\x9e\x95\x64\xc7\x0b\x72\xca\xbe\x56\x96\x98\x7f\x97\xc1\xe2\x24\x5d\xa6\xd8\x06\xcb\x24\xfa\xba\x3b\x8f\xa8\x97\xec\x7b\x54\x45\xad\x8e\xf1\x28\x7d\xad\x41\x13\xdb\x72\xe2\x1c\x2c\x77\x5b\x38\x22\x8b\x18\x37\xd8\x76\x44\x8b\xb7\x1d\x51\x76\xfb\x72\xe3\xaa\x5d\xd4\x31\xfb\x72\x6d\xb6\x75\xfd\x97\xf6\x4e\xa8\xe3\xfe\x67\x66\x6b\xa2\xe4\xb3\xff\xd3\xfe\xff\x05\x6c\x1e\x6f\x83\x76\x84\xf6\x3e\xeb\xfa\x08\x75\x7b\x44\x26\x02\x87\x76\x54\x46\x9a\x30\xeb\xda\x79\x41\xbd\x0a\xe6\x15\xb7\xf0\x96\x8c\xcc\x52\xdb\x36\x19\x44\xbb\x1a\x98\x9f\x2d\xd4\x40\x3e\x2f\x28\x59\xad\x0a\x1a\xae\x0e\x39\x33\x55\x86\x43\xd4\x57\xa0\xbb\xcd\x2b\x4d\xec\x5e\xce\x41\x5b\x99\x87\x9c\xc3\xa9\xe1\x9d\x0e\x2b\x07\xc6\x01\x6a\x80\x79\x62\x5c\x67\xef\x71\x24\xf0\xf9\x59\x98\xb5\xdf\x58\xe6\x3b\x76\xdb\xfe\xcd\xda\x17\xfa\xbf\x0b\x73\x34\x82\xef\xc3\xf2\x40\x50\x1f\x59\xe5\xf8\xd6\xdc\xa3\xf0\x7c\x24\x6b\xc2\xf3\xc8\xbe\x2e\xe6\xe7\xfa\xec\x8f\x8d\x77\xc1\x49\xf0\xaa\xf9\x39\x3b\xf9\x8e\x30\xc1\xb3\x6b\x01\xbc\x4e\x7f\x12\x35\x66\x7e\x07\xd0\x94\xfb\x67\xf4\xca\xd6\xdf\x6f\x19\x0e\xf2\xb1\xdb\xc1\x84\x79\xe6\x35\xcf\xf6\xd6\x79\xd5\x3c\xdb\x72\x4e\x2e\x3e\x1f\x97\x3c\x07\x9b\xe7\xdb\xc0\xd9\xf6\x1e\xf3\x9c\x5b\x12\xd6\xd9\xba\x18\x7f\x39\x63\x73\x7e\xbe\x68\x5c\xf6\x9f\xaf\x39\xcb\x94\x3c\x5f\x73\xb6\x2e\x3e\x57\xdf\x3c\x53\xff\xcd\x79\xda\x3c\xa7\x9b\x7a\xcd\x71\xa6\x8c\x3d\x4b\xd6\xe3\x73\x1c\xe8\x02\xee\x02\x0d\xac\xf5\xc9\xfa\x6e\x46\xaa\xa8\x3d\x92\x05\x58\xfb\x54\x2d\x10\x4d\xdf\x5b\x81\xef\x51\xd6\x83\x51\x81\xef\x63\xcc\xcf\xd4\x0b\x4a\x60\xeb\x2d\x98\xdf\x7f\xf8\x1a\x05\xda\xfd\x81\xcf\x2f\xcc\xcf\x32\xcc\xef\x21\x66\x97\x90\x0d\x8c\xb5\xe4\x4a\xc8\xde\x09\x23\xe7\xaf\xf8\xa7\xfe\xbf\x93\xbb\x05\x73\xef\x17\xf8\xde\xe1\x50\xa0\xbd\x80\x6f\xa6\xaf\xaf\xda\xee\xe6\x5d\x74\x3b\x3a\x83\x1e\x81\xd6\x44\x86\x1e\x4e\x5e\xef\x96\xfa\x01\x74\x05\xb5\x40\x3b\xfa\xcd\xb6\x2a\x48\x0c\xa0\x1a\x48\xa1\xdf\xbc\x8e\x05\xe5\x41\x83\x00\x52\xe9\xaf\x11\x18\xdf\xa9\x04\xfa\xd3\xdf\xe9\x6f\xfc\xe8\x16\x78\x9e\x51\x2c\x1b\x90\x4b\x01\xe9\xc0\x53\x0c\xfa\x3d\x01\x1b\xf5\x4b\xd8\x6b\x40\x7f\xfd\x3b\x6c\x15\xeb\xc9\xbd\x53\x77\x09\xfd\x77\xfa\xd1\x1b\xdc\x0d\xb2\x03\x6d\x6f\xe4\xfa\xd2\x36\x02\x0d\x03\x30\xaf\x1b\xd1\x6f\xb6\x6d\x41\x9b\x92\xa0\xdf\x6c\xa7\x05\x90\x1e\x40\x63\xfa\xcd\x76\xde\x9d\xf8\x07\x3f\xee\x8c\xa3\x2b\x72\x26\x97\xa9\x25\x62\x36\xf9\x8e\x0d\xf0\x9c\x12\xc8\x47\x71\x6e\xaa\x06\xf2\xd2\x2e\x90\xbf\xae\xc5\x39\x0d\xe4\x31\xa3\x44\xce\xad\xfc\x07\xf2\x7e\x9b\x1f\xfe\xef\x9f\xcc\xcf\xf3\x8c\x29\xfe\x33\xb8\xcf\xfc\x4e\xef\x0a\x78\x12\x54\xb5\xbe\x77\xfe\x2f\xfb\xbb\x12\x7f\x3f\xe9\x6f\xf1\xdf\xf6\xb1\xff\x4d\xde\x3a\x97\xed\x33\xbf\x87\x67\xed\xdc\x27\xa3\xf0\xf1\x00\x38\x06\x56\xf8\xbf\x23\xf3\xad\x04\xac\x85\xbe\xbd\x60\x6b\xe0\x3b\x35\x73\x6e\x3e\x40\xcb\x8a\x6f\x8c\xa5\x65\xf5\xf7\x1d\x2e\x01\xf3\xf3\xc4\x8b\x20\xcf\xff\xbd\xa7\x8f\x1d\x8d\xef\xe5\xdb\xe1\xff\x61\x9d\x4a\xb5\x60\xae\x5b\xe6\x1a\xc8\xda\x53\x0c\x6b\x0d\x63\xcd\xf3\x7f\xef\x58\x54\x64\xc2\xf6\x95\x84\x99\xdf\x43\x98\x67\x25\x86\xeb\x01\x54\xf6\xff\x4d\x49\x5b\x55\xee\x94\x75\x6f\xb3\x99\x4b\x96\x4f\xa6\x8a\x43\xa6\xc8\x14\x7d\x94\x3e\x5e\x9f\xa2\xcf\xd4\x67\xe9\xaf\xeb\x9f\xd9\xcb\xda\x63\xed\x7b\xec\x3f\xd8\xaf\xc4\x7e\x5c\x65\x41\x95\x57\xab\xfc\xe9\x8a\x76\xc5\xba\xda\xb8\x3a\xbb\xee\x76\x65\xbb\xfa\xb8\xfa\xb9\x26\xbb\xd6\xba\x76\xba\xbe\x70\x7d\xed\xfa\xc9\x75\xc5\xe5\x73\x87\xb9\xe3\xdd\x49\xee\x54\x77\x3d\x77\x63\x77\x53\x77\x73\x77\x6b\x77\x7f\xf7\x28\xf7\x78\xf7\x04\xf7\xa3\xee\xf9\xee\x75\xee\xcb\x71\xf6\xb8\xb2\x71\xe5\xe3\xe2\xe3\x92\xe2\x6a\xc7\x75\x89\xeb\x15\xd7\x3f\x6e\x7a\xdc\xf3\x71\x6f\xc7\x6b\xf1\x8e\xf8\xb0\xf8\xc8\xf8\xe8\xf8\x4a\xf1\xae\xf8\x1a\xf1\xc9\xf1\xed\xe2\x07\xc6\x0f\x49\xd0\x12\xc2\x13\xe2\x12\x39\x02\x24\x96\x4e\x0c\x4f\x8c\x4a\xac\x90\x58\x39\xb1\x6a\x62\xcd\xc4\x7a\x89\x4d\x13\x47\x24\x4e\x4d\x9c\x9e\x38\x23\x71\x56\xe2\x73\x89\xaf\x27\xae\x48\x5c\x9d\xb8\x39\x71\x4b\xe2\xce\xc4\x4f\x13\x0f\x24\x1e\x4f\x3c\x97\xd4\x34\xc9\x9b\xd4\x32\x29\x27\xe9\xde\xa4\xa1\x49\xc3\x93\x46\xd5\x1c\x59\xf3\xa1\xda\xe5\x97\xc6\x2d\x9d\x75\x5d\xbb\xde\xe0\x7a\xd3\xeb\xcd\xaf\xb7\xb8\xde\xfa\x7a\x57\x5f\x82\x71\xc3\x30\xac\xbf\xa1\xb9\x58\x1f\xa7\x3f\xa2\x4f\x27\xfe\x67\xf4\x37\xf5\x83\xf6\x4a\xf6\x79\xf6\x83\xf6\xcb\xb1\x12\xeb\x23\xfe\xc5\x2e\x71\x55\x70\xb9\x5d\xed\x5c\xdd\x02\xf1\x0f\x70\x4d\x75\xad\x77\xed\x76\x1d\x75\x9d\x70\xfd\xe2\xba\xea\x16\x77\x24\xf1\xdf\xe5\xae\xeb\x4e\xbf\x19\xff\x30\xf7\x38\xf7\x43\xc4\x3f\xd7\xbd\x38\x10\x7f\xb9\x40\xfc\x9d\xe3\x7a\xc6\xf5\x21\xfe\xb9\x37\xe3\x8f\x20\xfe\x8a\xf1\x55\x02\xf1\xe7\xc4\x0f\xb6\xe2\x77\xff\x43\xfc\xdd\x6e\xc6\x3f\x37\x71\x71\xe2\xb2\x9b\xf1\x7f\x4c\xfc\xc7\x88\xbf\xf1\xcd\xf8\x87\x24\x0d\x23\xfe\x9c\x9a\x63\x88\xbf\xfc\xd2\x19\xd7\xd5\xf5\xd8\xeb\x8d\x88\xdf\x7b\xbd\xd5\xf5\x0c\x9f\xdb\x8c\xdf\x38\x6d\x6c\x37\x3e\x34\x36\x1b\xeb\x8c\xb5\xc6\x1a\x63\xb5\xb1\xca\x58\x6e\x34\x32\x52\x8d\xe4\xf3\xee\xc2\x4b\x85\x17\x0a\x7f\x28\x3c\x53\x58\x50\x78\xaa\xf0\xdb\xc2\x6f\x0a\xbf\x2e\xfc\xaa\xf0\x78\xe1\xb1\xc2\xa3\x85\x47\x0a\x0f\x17\x7e\x5e\x78\xa8\xf0\x40\xe1\x67\x85\xfb\x0b\x3f\x29\xdc\x5b\xb8\xab\x70\x67\xe1\xd6\xc2\x8f\x0a\x3f\x2c\xdc\x54\xb8\xb8\xf0\xf9\xc2\x79\x85\x73\x0b\x67\x16\x3e\x52\x38\xaa\xb0\x7e\x61\x5c\x61\x54\x61\x64\x61\x50\xa1\xfd\x9c\xef\xdc\xa9\x73\xdf\x9c\x3b\x7a\x6e\xd5\xb9\xb7\xce\xcd\x3f\xd7\xe4\x5c\xa3\x73\xa9\xe7\x52\xce\xd5\x3a\x77\xd7\xb9\x6a\xe7\xaa\x9c\x8b\x3d\xa7\xce\xfe\x70\xf6\xfc\xd9\x4e\x67\x3d\x67\x53\x4f\xf7\x38\xdd\xfd\x74\xbb\xd3\x6d\x4e\xb7\x3c\xed\x39\xdd\xf4\x74\xfd\xd3\xb5\x4f\x57\x3b\xed\x3e\x1d\x5a\x70\xad\xe0\xf7\x82\x2b\x05\x3f\x17\xfc\x58\x50\x50\xf0\x55\xc1\x91\x82\xcf\x0a\xf6\x17\xec\x2e\xd8\x56\xf0\x51\xc1\x86\x82\xe5\x05\x59\x05\x99\x05\xbd\x0a\x1a\x16\xd4\x2f\xa8\x57\x50\xa7\xa0\xf6\x37\xcd\xbf\x69\xf2\xd5\xc2\x81\x8b\x06\x36\x0c\xdd\x11\xfa\x4e\xe8\xdb\xa1\x4b\x43\xdf\x0a\xfd\x77\xe8\x92\x90\xc3\x41\x37\x02\x7f\x83\xf8\xff\xbf\x3f\x0e\x2d\xc4\x6c\x94\xfc\x85\x09\x65\x1d\xb6\xcc\x1f\xed\xbf\xe8\xf0\x8f\xd4\x39\xa8\xd9\x59\x4d\x9c\x1c\x8c\x82\x25\x44\x4a\x49\x69\x09\x95\x32\x12\x26\xe1\x12\x21\x91\x52\x56\xa2\x24\x5a\xca\x49\x79\xa9\x20\x15\xa5\x92\xc4\xb0\x0a\xc5\x4a\x15\x71\x31\xfb\xe2\x24\x9e\x7d\x45\x55\x49\x94\x24\xa9\x26\xd5\xa5\x86\xdc\x25\xc9\x52\x53\x6a\x49\x6d\x49\x91\x54\xa9\x23\x75\x25\x4d\xea\x49\x7d\x69\x20\x0d\xd9\x6d\xa4\x4b\x63\x69\x22\x4d\xa5\x99\x34\x17\x8f\x78\xa5\x85\xb4\x94\x56\xd2\x5a\xda\x48\x86\xb4\x95\x76\xd2\x5e\x3a\x48\x47\xe9\x24\x9d\xa5\x8b\x74\x95\x6e\xd2\x5d\x7a\x48\x4f\x4e\x62\x99\xd2\x5b\xee\x96\x2c\xc9\x96\x7b\xa4\x8f\xf4\x95\x7e\xd2\x5f\x06\x48\x8e\x0c\xc4\xff\x27\xe4\x49\x79\x4a\x9e\x96\xe7\xe4\x25\x79\x55\xde\x94\x37\x64\x89\xbc\x25\xff\x96\xa5\xf2\x0e\x27\xcc\x65\xb2\x42\xde\x95\xf7\x64\xa5\xe4\xcb\x2a\x59\x23\xeb\x64\x2d\xbb\xc0\x8d\xb2\x41\xb6\xc8\xfb\xf2\x81\x7c\xe8\xbc\x20\x63\x39\x53\x0d\x91\xfb\x9d\x97\x64\x02\xbb\xdf\xd1\x32\x3c\xe8\x2e\x79\x50\x86\x05\x75\x90\x19\xf2\x4a\x50\x1b\x76\xef\x9d\x82\x3a\xcb\x7d\xf2\x50\x50\xb3\x20\x6f\x90\x47\x1f\x1b\xd4\x4e\x46\xc8\x24\xbd\x8f\xbc\x2d\x9b\x65\x9a\xdc\xcb\x9e\xbb\xb5\xea\x15\xd4\x3e\xa8\xb9\x8c\x94\xc9\xce\x1f\x65\x90\x3c\xc6\xf9\xf3\x45\x15\xa5\xa2\x9d\xdf\x3a\x4f\x3a\x0b\x9d\xe7\x9d\xa7\x9d\x67\x64\x53\xd0\xd3\xb2\x4d\x35\x76\x16\x05\xc5\x38\xff\x74\x5e\x0b\xda\x19\xb4\xcb\x79\x51\x1e\x76\x9e\x75\x7e\xef\xfc\x4d\xa6\xcb\x2c\xf9\x97\xcc\x96\x99\x32\x47\xe6\xca\x3c\x79\x46\x9e\x97\x17\x88\x70\xbe\x2c\x64\xd7\xb9\x40\x7e\xd5\x66\x68\xaf\xca\x18\xed\x15\x6d\x81\xb6\x50\x1e\xd1\x5e\xd3\x16\x69\x4f\x89\x78\xdb\xf6\xb9\x27\x3b\x2b\xb3\x57\xcf\x1e\xdd\xbb\x75\xed\xd2\xb9\x53\xc7\x0e\xed\xdb\xb5\xcd\x68\xd3\xba\x55\xcb\x16\x5e\x4f\xf3\x66\x4d\x9b\x34\x4e\x6f\xd4\xb0\x41\xfd\x3a\xa9\x29\xb5\x6b\xd5\xac\x5e\x2d\x29\xb1\x6a\x42\x7c\x9c\xab\x42\x54\x44\x78\x58\x99\xd0\x52\x21\xc1\x41\x4e\x87\xdd\xa6\x6b\x4a\x6a\xba\xf3\x55\x4e\x9b\x7c\x3d\xd1\x1d\x91\x31\x30\xa1\x4d\xc2\xc0\x76\xb5\x6a\xba\xdb\x54\xc8\x6d\x5d\xab\x66\x9b\x84\x8c\x9c\x7c\xf7\x40\x77\x3e\x8d\x2d\x29\xa1\x5d\x3b\xab\x2b\x61\x60\xbe\x3b\xc7\x9d\x9f\x44\x33\xb0\x44\x77\x4e\xbe\x17\xc9\xa1\x77\x48\x7a\xfd\x92\xde\x9b\x92\x2a\xdc\xdd\x54\x9a\x9a\x26\x12\xdc\xf9\xfb\x5b\x27\xb8\x37\xaa\x7b\xba\x67\x71\x3d\xbb\x75\x42\xb6\x3b\xff\x92\x75\xdd\xd9\xba\xb6\x25\x59\x37\xa1\xdc\xc4\xc5\x31\xc2\xf2\xca\xf4\xd6\xdd\x26\x3f\xe3\xc1\xdc\x99\x6d\x72\xf0\x51\xad\x2a\x15\xd2\x2a\xa1\xd5\x90\x90\x5a\x35\x65\x55\x48\x29\x2e\x4b\x71\x95\x5f\x3d\x61\xf4\x2a\x55\xbd\xb9\xb2\x2e\xb4\xea\x6d\x1a\xaf\xd2\x24\x28\xd4\x34\x4b\xa4\x6d\x06\x0e\xce\xef\xd6\x3d\xab\x4d\xeb\x98\xb8\xb8\xec\x5a\x35\xdb\xe7\x97\x49\x68\x6d\x3d\x92\x56\x96\xca\x7c\x47\xab\x7c\xa7\xa5\xd2\x7d\xbf\xe9\xba\x3c\xed\x5e\x55\x73\xeb\xcc\x59\x1b\xc3\x65\x50\x4e\x72\xe9\xc1\x09\x83\x07\xf6\xcd\xca\xd7\x07\x32\x76\xa6\xde\x66\xe6\xcc\x27\xf3\x23\x92\xf3\x6b\x24\xb4\xce\xaf\xf1\xc8\x99\x0a\x44\x3e\x24\xbf\x66\x42\xeb\x36\xf9\xc9\xa6\xd6\x8e\x3d\x6e\xda\xe9\x78\xcb\xa4\xca\xb7\x27\xf2\xc2\x98\xf9\x9b\x10\x4e\xc2\xa5\x8b\xb7\xf7\x0c\x0c\xf4\x38\x12\xc3\x7f\x13\xf3\x32\x5f\x6b\x95\xaf\x7a\x64\xc5\x99\x3f\x31\x19\x70\x3d\x73\x66\x46\x82\x3b\x63\x66\xce\xcc\x81\x1b\x8d\xa9\x83\x12\xdc\xe1\x09\x33\x57\x95\x2e\x3d\x73\x74\x1b\xe8\x96\x6e\x59\xa8\xd8\x68\x6c\x7e\x3a\x26\x3f\x63\x56\x76\x7e\x78\x4e\xae\x6a\x9c\x1d\x08\x3d\xa3\x47\xc7\xfc\xb2\xdd\xfb\x64\xe5\x6b\x89\x19\xee\xdc\x81\xf4\xf0\xc7\x93\x10\xd7\x28\x26\x2e\xe2\xa6\x4c\xb7\x7f\x7a\x2c\xd0\x02\x39\x30\x1c\x17\x67\xd2\xf0\xf4\x46\xaf\x0c\xe2\x26\x7f\x6a\xf7\x2c\xff\xbd\x5b\x06\xc5\xac\x16\x6f\x4a\x72\x76\xbe\x96\x63\x3e\xd9\x5a\xfc\x24\x3a\xd3\x7c\x32\xb5\xf8\xc9\xcd\xe1\x39\x09\xe4\xb6\x63\xcf\xac\x99\xf9\xb6\xc4\xf6\x83\x13\xda\xc0\xf8\xd3\x03\xf3\xa7\x0e\xa2\xba\x86\x99\x89\x49\x08\xcf\x2f\x73\x35\x26\x2e\x61\x66\x64\x84\x3b\x3d\x25\xdb\x92\x75\xe3\x55\xfb\xc1\xf7\xbb\xf3\xed\x49\x90\xc4\xa8\x92\x03\xa8\x1b\x73\xc8\xcc\x70\xeb\xa6\xcc\x55\x7f\x73\x29\x06\x03\x49\x11\x91\xee\xf4\x04\xd4\x98\x7a\xda\x24\xb4\xc9\x09\xfc\x79\x30\xb7\x02\x0a\xdc\x10\xdd\x2e\xd9\x5f\x08\xbd\xb2\xf2\xbd\xad\xb9\xf0\x0e\x0c\x64\xac\xcd\xaa\xd4\x14\x46\x0c\xcc\x21\x61\xf7\xb7\xb6\x92\x99\x9f\x92\x30\x3a\x3f\x2a\xa1\xe5\xcd\xec\x9a\x6e\xb5\xb9\xbf\x67\x96\x35\x24\x30\x2c\x3f\xaa\x55\xbe\xe4\xdc\x1b\x18\x95\x9f\xd2\xc6\x9a\x57\xee\x36\x33\x73\x5a\xfb\x5d\x30\x75\x25\x74\xcf\xda\x24\x69\xc6\xa9\x55\xf5\xdc\x31\x6b\xcc\xa5\x33\xbb\xb5\x29\x5c\xae\x15\x55\x96\xd4\x66\x66\xd6\xe0\xa1\xf9\xae\x9c\x98\xc1\xcc\xbb\xa1\xee\xac\x98\xb8\x7c\x6f\x36\x19\xce\x4e\xc8\x1a\x92\x6d\x96\x1d\x0c\xd5\x38\x15\x63\x15\x47\xb6\x55\x2b\xbd\xb2\x3a\xf6\x4c\xe8\xd8\xfd\x9e\xac\x46\x01\x47\xfc\x0f\x4c\x75\xb6\xc4\x36\x77\xa8\x49\xc8\x8a\xf1\xab\xa1\x00\xf3\x83\x12\x83\xdc\x59\x5a\x8c\x9e\x8d\x60\x38\x1d\xee\x0c\x2e\x12\x5a\x36\xe5\x77\xbe\x33\x31\x08\x84\x43\xb8\xd5\x6b\x16\x6e\xcb\xa6\xee\x2c\x15\x23\xc5\xd2\xb8\x91\x5f\xc3\xdd\x66\x48\xeb\x80\x9c\x79\x7f\x9b\x52\xbb\x59\x4e\xad\xda\x15\x6b\x73\x98\xb7\xe8\x69\xd5\x2e\x26\x2e\x3b\xce\xff\x53\xab\xa6\xc6\x63\x77\xc0\x30\x23\x82\x4c\x52\xdb\x15\x3f\x62\x99\xe2\x41\x10\xf5\xd9\xaa\x9d\xd5\x65\x72\x59\xc1\x2c\x7a\x77\x56\xc2\x90\x84\xec\x84\x5c\x77\xbe\xb7\x5b\x96\x19\x9b\x49\x8f\xc5\x72\x80\x0c\x8b\xf3\x40\xae\x7a\xdd\x76\x57\x82\x2c\x68\x92\x38\x1e\x17\xdf\x98\x64\xe6\x67\x24\xc7\x94\x24\x37\xbf\xad\x75\x7f\xf3\xb6\xdd\x1d\x8f\xdb\x17\x3f\x76\xcf\x0c\x4a\xe8\xd8\x73\xa6\xa9\x3c\x21\xa0\x50\xf0\xbc\x7d\xbe\x98\x25\xec\x6d\x14\x11\x63\xad\x05\xe6\x84\x4e\x60\xed\x75\x87\x33\xa5\xad\x09\x3d\x73\x95\xd7\x6b\x4e\xe6\xdc\xc6\xa6\x92\x84\xf6\x83\x67\x26\xf4\xcc\x6a\x6a\x49\xb3\x9e\x4c\x8e\x79\xc4\xb4\x15\x29\x1d\x55\xc7\x5e\x2d\x6b\xd5\x64\x69\x6b\xb9\x2a\x41\xcd\xe8\xbe\xca\xab\x66\xf4\xbc\x27\x6b\x53\x38\x7b\xe4\x19\xbd\xb2\x56\x6b\x4a\x6b\x95\xd3\x32\x7b\x55\x55\x9e\x65\x6d\x72\xf3\xd2\xb0\x7a\x35\xb3\xd7\xec\x34\x6f\xdc\xe6\x8d\xa9\xa9\x07\x37\x41\x96\x7c\xcc\x26\xaf\xc8\x54\xeb\xa9\xcd\xea\xb0\xee\xef\xdd\xa8\xc4\xea\x0b\x2a\xee\x53\x72\xef\x46\xcd\xdf\x17\xee\x37\x94\x64\x19\xf2\xb2\x07\xb9\x77\xa3\xcd\xff\xc4\x5b\x2c\x6d\xa3\x2f\xc8\xdf\x37\xd5\xea\xb3\x7e\x56\x89\x49\x99\x37\xc4\xee\x0d\xf2\x06\x7b\x4b\x6b\xa1\x5a\xcc\x2a\x65\x76\xad\xa6\x67\x33\x7b\x95\x60\x25\x6b\x4a\xab\x50\x15\xb3\x8a\x51\x3d\xac\xee\x8d\x6a\xea\xaa\x60\x6f\x8c\x5f\x62\x2a\x12\x5e\xbf\x87\x33\x32\x6f\x99\xce\xbc\x27\x6b\x0d\x3b\x1a\x15\x63\xfd\xc6\x50\x4b\xf3\x87\x72\xa9\x90\x4b\xb2\x79\xad\xb4\x71\x0f\x36\x0b\x65\x52\x76\xee\xcc\x9c\x6c\x73\xb2\x49\x39\x52\xc3\x1f\x95\xaf\x12\x9a\x93\xa6\x84\xe6\x38\xe2\x28\x9d\x1f\x92\x30\xa4\x65\x7e\xa9\x84\x96\x66\xbf\xc7\xec\xf7\xf8\xfb\x1d\x66\xbf\x93\x12\x55\xe5\x14\xc3\xa7\x92\xfb\x6e\xf9\xca\xac\x80\x3e\x59\x71\x4c\x49\x77\xa5\x7d\x31\x33\xc3\x2f\x99\x99\xca\x66\x51\x99\x19\x7e\xb6\x56\x8b\x4c\xe5\x11\xa5\xd2\x25\x53\x35\x0f\xb4\x2d\x95\x97\x9d\x96\x4b\xb5\xa0\xe5\xd8\xa2\x9a\x48\x9a\x6a\x4c\x7f\x23\x5a\x9e\xcb\x12\x7e\x5f\x01\x9a\xaa\x2b\xcd\x54\x1d\x9e\xd4\x61\x64\x0a\x6d\x2a\xf7\x66\x5b\x53\xd5\x10\x83\x91\x35\xe8\xbf\x8b\xfb\xea\xf4\x57\xa3\xad\x16\xb8\x4f\xe2\x3e\x91\x36\x31\x70\x9f\xa0\xe2\x2d\xf9\xf8\xc0\x7d\x32\xcf\x69\xa5\x9b\x72\x92\xd1\x14\xeb\xf7\x7b\xca\xe6\x6d\xa2\x0e\x16\xa9\x8f\x8a\x54\x78\x91\x1a\x75\x5d\x79\xaf\xab\xa9\xbf\x29\xb9\xa4\xbc\x17\xd4\xb9\x33\x6e\xd7\xd9\x33\xcd\x5c\x05\xa7\xa2\x5d\xdf\x9d\x6a\xe6\x3a\xd9\xec\x44\xe6\xb7\xcd\xf4\x4c\x39\x91\x7a\x42\x3b\xa1\xf4\xcc\x94\x16\xa5\x54\x79\xd4\x84\xf3\xdb\x0d\xbc\x40\x37\xb6\xaa\xf2\x5e\x57\xc5\xca\x19\xdf\xe8\x86\x6b\xef\x0e\xc3\x95\xba\x43\x7d\xd8\x36\xd2\xb5\xb9\xeb\x60\xd7\xa6\x1c\xc3\xb5\x71\x6d\x39\xd7\xa8\xf7\x59\x4d\xcc\x71\x31\xde\x18\xe5\xde\xa0\xc2\xd7\xb9\xd7\x79\xd7\xe9\x39\x6b\x47\xaf\x9d\xba\x56\x0f\x5b\x3d\x60\xb5\xb6\x4a\x6f\xea\xda\xa8\xa2\xbc\xc6\xca\xba\xae\xfc\x65\x86\x2b\x65\x8d\x67\x4d\xd7\x35\xfa\x9c\x35\xca\xbb\x26\xa9\x46\x86\xeb\xbd\x94\xf7\x3c\xef\xbd\xf6\x9e\x2d\xec\x3d\xe5\x7d\xaf\x4c\xb9\x8c\xd7\x56\xaa\x77\x11\x5b\xbe\xac\xbe\x6b\x59\xb7\x24\xd7\xab\x0b\xaa\xb9\x16\x2d\x48\x74\x2d\x04\xb2\x20\x67\x81\x36\x75\xc1\xe5\x05\xda\x6b\x1d\x0d\x57\xd8\x7c\xd7\x7c\x2d\xec\x29\xd7\x53\xda\x73\x73\x93\x5c\xcf\xce\x4b\x72\xcd\x99\x95\xe4\x7a\x06\x84\xcd\x76\xcd\xd6\x06\xcc\x1e\x35\xfb\xd1\xd9\xc6\x6c\x5b\xd7\xd9\xca\x3b\xbb\x6c\xf9\x8c\xb0\x59\xea\xf1\xb6\x75\x5d\xaf\xfd\x4b\x4d\x1b\x69\xb8\xa6\x12\xd4\x83\xe8\x1f\x0f\xc6\x81\x3c\x90\xf2\xb0\xe7\xe1\xae\x0f\xeb\x63\x46\xb9\x5c\xa3\xdb\x86\xb9\x46\xb5\xad\xe2\xaa\xa4\x2a\x64\x56\x4c\xab\x90\xe9\x4c\xd3\x33\x1d\x0c\x59\x3a\x52\xd5\x18\xa9\x46\x70\x35\x90\x01\x39\x03\xea\xba\x06\xd0\xde\xdb\xb6\xb2\xab\xe2\xa0\xef\x07\x69\xee\x41\x91\xd1\x19\x35\x06\xa5\x0f\x6a\x3f\x48\xef\xdf\x36\xc6\xd5\xaf\x8f\xe1\xea\xdb\x27\xcd\xd5\xa7\x6d\x5d\x6f\x0f\x57\x94\x8a\xcc\x2c\x5b\x37\x32\xd3\x0e\xe5\xb6\xba\x7a\xe6\x28\x5d\x85\xe9\x1e\xbd\xab\x3e\x4a\x7f\x54\xb7\xbf\x90\xad\xe6\x0e\x53\x5d\x7b\x0e\xe8\xa9\x79\x7b\x56\xaf\x99\xe1\xed\x59\x25\x9e\x5f\x65\x2b\x64\x0c\xef\x31\xb1\xc7\xd3\x3d\xf4\xee\x5d\x2b\xbb\xba\x81\x8a\x5d\x6b\x74\xd5\xb2\xbb\xde\xdf\x55\xdb\xa8\xca\xad\xc1\xc9\xf1\x9b\x55\xb4\x3c\xae\xa2\xbd\x2d\xb4\x6e\x5d\xd4\xe2\xce\xf9\x9d\xb7\x76\xd6\x3b\xb7\x8d\x72\x75\x22\xde\x8e\xa0\x43\x5b\x97\xcb\x68\xaf\xda\x13\x54\x3b\x6e\xa5\xad\xaa\x1c\x33\xd5\x55\xae\x6e\x74\x66\x84\x0a\xcb\x0c\xaf\x1b\x96\xc9\xbe\x32\x53\x09\x49\x55\x11\xab\x63\x2a\xd2\x84\x7b\x6b\xd1\xba\xc2\x3c\x61\x03\xc2\x1e\x0d\xb3\x85\x85\xa5\x84\x75\x0d\x1b\x15\x36\x27\xec\x64\x98\x11\xe6\xf4\xd0\xf7\x53\x98\x3e\x4a\x54\x57\x51\x53\xcb\x29\xbb\xda\xa8\xe6\xae\xea\xd5\x33\x39\xb9\xe3\x46\xa7\xc1\x96\xc5\xd9\xad\x4f\xbe\x9a\x91\x9f\xd8\xd3\xfc\xed\xed\x7e\x4f\xbe\x63\x46\xbe\x64\xde\xd3\x27\x6b\x95\x52\xcf\x64\x3f\x3e\x7b\xb6\xb4\x8c\xed\x98\x5f\xb7\x67\x56\x7e\x4e\x6c\x76\xc7\xfc\xc1\x5c\x78\xcd\x8b\xa9\x5c\x84\xc7\xae\x2a\x27\x2d\xb3\xf3\xc6\xe5\x8d\x1b\x9f\x1c\xf8\x51\xe3\x92\x93\xc7\x25\x0b\x57\xe3\xf2\xf2\x92\xf3\xb8\xcb\xe3\x3a\x2f\x4f\xe5\x49\x9e\x25\xa4\xac\x87\x79\x08\x25\x5b\x0f\xfc\x7d\x74\xe6\x05\x14\xe4\x25\x8b\x39\x70\x7c\xe0\xb1\xa9\xc2\x2f\x30\xce\xbc\xb6\x6e\xd1\x86\x3a\x6b\xac\x4a\x1e\x67\xe9\x1b\x6f\x8e\xb7\xc4\x92\x95\xf5\xcc\xfc\x41\x2c\x4f\x92\x4b\xfc\x04\x6c\x54\xb0\x7f\x6a\xff\x54\x26\xdb\xa7\x71\x12\x7b\xd8\xfa\x7d\xdb\x8f\xad\x31\x2b\xc7\x43\xe6\xdf\xa7\x37\x56\xfb\xff\x56\xbd\xff\xb7\xef\x6e\xf3\x13\xaa\xff\x7b\x3f\x41\xc5\x07\xc7\x6a\x2a\x42\xbe\x13\x43\x45\xab\x58\x56\x89\xef\x65\x9b\x7c\xc1\x49\x28\x5f\x0e\x14\x4b\xda\x3f\x55\xbc\x64\x58\x91\xe2\x55\x2d\x55\x46\xce\xc8\x15\xd9\x2d\x17\xd4\xed\x67\xd5\x65\xc8\x4d\x53\x91\xc8\x45\xc8\x71\x15\xc5\xd9\xe9\xa4\x1c\x92\x5d\x9c\xd1\x9e\xe7\x64\x75\xae\xa4\xa8\x25\x37\x83\x35\x50\x53\x2d\x65\x93\x4c\xc5\x6e\x91\xe5\x89\x47\xbe\x56\xfd\x58\xd1\x96\xc9\x54\x19\x2f\xb3\xd5\x0d\xfa\xfa\x16\x8f\x52\x75\x54\x45\x55\x46\xd9\x58\x4a\xfe\xee\xe7\x94\x72\x70\xb6\x3a\x25\xf3\x55\x6b\x39\x65\xcf\xd3\x2b\x72\x4a\x3c\xa2\x15\xca\x8b\xfa\x34\xce\x5b\x57\xe4\x13\x4e\xa1\xe6\xcf\xa1\x9b\x23\x46\x73\x7a\x7c\x2f\x70\xf5\x28\x67\xce\x3b\x7f\xde\x08\xb4\xb3\x6f\xf9\x5d\x94\x2a\x11\xc6\x55\x59\xcd\x79\x73\x11\x1d\x8f\x72\xba\xcb\xb9\x29\x7f\x99\xe3\xb7\xeb\x0e\x1d\x1f\x16\x5f\x38\xdb\xe9\xc3\xb4\xf5\x9a\x56\xf4\x1c\x37\xf3\x38\x7f\xce\x93\x81\xea\x38\xc7\xfa\xd9\x7a\x8b\x3b\x0d\xfb\x46\xf9\x72\xad\x8b\x97\x64\x87\xfc\xa2\x1d\x91\xe5\x5a\x4f\x99\xac\x1d\xb8\xa5\x8d\x2a\x89\x76\xc0\xbf\xfe\x9d\x84\x6b\xd7\x24\xcc\x77\x58\xfd\x60\xfc\x6a\x7e\x3b\x41\xdf\xbd\x52\xaa\x28\xcc\xf8\xcd\x2f\xe7\x98\x66\x7b\x48\xa2\x6d\xc7\xad\x7a\xda\xe5\x7b\x14\x5e\xf7\xcb\x2f\x4a\x93\x23\xaa\xe2\xdf\xf2\xc8\x0b\x17\x9c\x81\xef\xb5\x78\x47\x6b\x27\x03\x8e\x15\xd4\xcb\x38\xf0\x29\x6f\x6e\xb2\x12\xd2\x09\x1c\x14\x29\x55\x0f\x0c\x06\x2f\x01\xee\x4b\x67\x81\xad\x22\xa1\xb0\x52\xa6\x3a\xa0\x2f\x0c\x7d\xe1\xbd\xc0\x4e\x91\x08\xf4\x44\x8e\x06\xf4\x97\xed\x06\xb0\x11\x95\x0a\xe6\x8a\x44\x23\x53\xbe\x32\xc0\x46\x05\xfa\x2b\xa2\xa3\x22\x75\x5f\x89\x67\x31\xf4\xc7\x9c\x12\xa9\x3c\x43\xc4\xfc\x77\xe8\xb1\xdf\x88\x54\xa1\xbf\x0a\xfe\xb9\xf1\x27\x6e\xbe\x48\x3c\x7a\xe2\x19\x9b\xb0\x58\xa4\x2a\x3e\x25\x72\x9f\x38\x5d\x24\xa9\x26\x58\x22\x52\x0d\xdf\xaa\xa1\xa3\x3a\x76\xab\xe3\x4b\x8d\xaa\x80\xd8\x92\x91\x4b\x46\x57\x32\x7e\x27\xa3\xab\x96\x5b\xa4\x36\xf6\x6a\xe7\x8b\xa4\x10\x57\x2a\xba\xea\x94\x16\xa9\x8b\x5c\xdd\xf3\x22\x69\xf0\x50\x8f\xad\x58\x3d\x74\xd4\x6f\x24\xd2\x80\xfb\x86\xc4\xda\x70\x8b\x48\x23\xfc\x4e\x27\xc6\xc6\x5e\x91\x26\x70\xd3\x04\xf9\xa6\xe8\x69\xc6\x75\x33\x62\x69\x3e\x49\xc4\x83\x5d\x0f\x99\xf2\xe2\x53\x0b\x74\xb4\x64\x5c\xab\x11\x80\x67\xad\xd1\x9b\x81\x9f\x6d\xc9\x7f\x3b\x6c\xb6\x23\xbe\x0e\x36\x91\x8e\xf8\xd4\x11\x3b\x9d\xd0\xdd\x19\x74\x81\xff\x2e\x70\xd1\x05\xff\xba\x1e\x13\xe9\xc6\x64\xee\x46\xac\xdd\xe9\xeb\x11\x25\xd2\x93\xfb\x9e\xad\x45\x7a\xe1\x87\xb9\x68\x64\x62\x3f\xf3\x6d\x91\xde\x15\xc0\x42\x91\xbb\x19\x7f\x37\xf6\xef\xfe\x43\x24\x8b\x18\xb2\x88\x3b\x9b\xf8\xb2\x89\x35\x1b\x2e\xb3\xf1\x2b\x9b\xbe\x7b\x90\xeb\x83\x9e\x3e\xd8\xee\x83\x7c\x9f\xc3\x22\x7d\xf1\xa7\x2f\x63\xfa\xe2\x63\x5f\xec\xf7\xdd\x0b\x90\xed\x47\x1c\xfd\x88\xb1\x3f\xdc\xf5\x67\x5c\x7f\xe2\xe9\x8f\xaf\xfd\xe1\x7c\x00\xb9\xcc\x81\xf7\x1c\x6a\x21\x07\x3e\x72\xe8\x1b\x88\x9f\x03\xd1\x3d\x10\xff\x07\x31\x76\x10\x63\xef\x65\xec\xbd\x8c\xbd\x97\xb1\xf7\x22\x77\x2f\xf1\x0f\x41\x66\x08\x35\x33\x84\xbc\x0e\xa1\x6e\x86\x12\xcf\x50\xe2\x19\x8a\xaf\x43\xc9\xdb\x50\xf2\x36\xf4\x8a\xc8\x7d\x8c\xcf\x65\x7c\x2e\xe3\x73\x19\x9f\x8b\xed\x5c\xea\xe4\x7e\x38\xbd\x9f\xfb\x61\x70\x3c\x8c\xd8\x87\x51\x23\xc3\xf0\x77\x38\xf1\x0e\xc7\xaf\x11\x4d\x01\xfa\x47\xa0\x7f\x04\xfa\x47\xa2\x7f\x24\xcf\x46\x52\x1b\x23\xe1\x73\x24\xb9\x1a\x49\x1e\x1f\x80\xbb\x07\xa8\xbd\x07\x26\x00\xb8\x7c\x00\xbf\x47\xc1\xf3\x28\xb8\x18\x05\x3f\xa3\xe0\x7f\x34\xfd\xa3\xe9\x1f\x43\xff\x18\xfa\xc7\xc0\xd1\x18\x38\x1a\x03\x47\x63\xf0\x71\x2c\xb9\x1f\x4b\x9d\x8f\x45\x76\x2c\xb5\x32\x96\xf8\xf2\xe0\x21\x8f\x18\xf3\xd0\x91\x07\xc7\x79\x8c\x1f\xc7\xf8\x71\x8c\x1f\xc7\xf8\xf1\x3c\x7b\x10\x1f\x1f\xc4\xff\x07\xf1\xff\x41\xfc\x7f\x10\xff\x1f\xa2\xae\x1f\xc2\xc7\x87\xf0\xf1\x21\x74\x3d\x84\xae\x09\xc8\x4e\x20\xd6\x09\x70\x32\x01\x7b\x0f\x13\xd3\xc3\xe4\xec\x11\xf4\x3d\x82\xdc\x23\xc4\xf2\x08\xb1\x4c\x84\xa7\x89\xf0\x34\x11\xd9\x89\xc8\x4e\x84\xbb\x49\xf8\x36\x09\x3d\x93\xa9\x99\xc9\xf0\x31\x99\xb1\x93\x19\x3b\x85\xb1\x53\xf0\x65\x0a\xbe\x4c\x81\xd3\x47\xe1\x7c\x2a\xbe\x4e\xc5\xd7\xa9\x3c\x9f\x46\x3d\x4c\x23\x1f\xd3\x78\x3e\x0d\xff\x1e\x43\xe6\x5f\xc4\x30\x9d\x71\xd3\x19\x37\x1d\xbf\xa7\xd3\x3f\x1d\xbf\xa7\xe3\xf7\xe3\xf8\xfd\x38\x7e\x3f\x3e\x0b\x90\xf7\xc7\xf1\xe7\x09\x38\x78\x02\xdf\x9f\x40\xef\x13\xf4\x3f\x81\xee\x27\xd0\xfd\x24\xb9\x78\x92\xfb\x19\xd4\xce\x0c\x6a\x87\xdd\x81\xcc\xa0\x76\x9e\x22\xa7\x4f\xe1\xe7\x53\xf8\xf9\x14\xb2\x4f\x61\x6f\x26\xf3\x65\x26\x7d\x33\xb1\x37\x13\xce\x67\x62\x6f\x26\xf6\x9e\x26\x97\x4f\x93\xe7\xa7\xa9\xeb\xa7\xa9\xeb\xa7\xe1\x65\x16\xb1\xce\x22\x0f\xb3\x88\x65\x16\xf1\xcf\xc6\xa7\x67\xe8\x9b\x83\xcf\x73\xc8\xf3\x1c\x64\xe6\xc2\xcd\x3c\x6c\x3f\xcb\xdc\x7e\x96\x79\xf2\x1c\xbe\x3e\x87\xce\xf9\xf8\x68\xfe\xd3\x96\xe7\xe1\xfb\x05\xf2\xfd\x22\x5c\xbe\x88\xfd\x97\xb8\x7e\x19\x1e\x5e\xc6\xbf\x57\x90\x5b\x40\x9d\x2c\xc4\x9f\x85\xe8\x59\x48\xdf\x22\xda\x57\xf1\xfb\x55\x7c\x7e\x0d\x5f\x5f\x83\xf3\xc5\xc4\xf4\x3a\x76\x5f\x67\xdc\xeb\xf8\xfa\x06\xf1\xbd\x49\x5d\x2f\x41\x6e\x09\x7e\xfd\x9b\x1c\xbc\xc5\x7a\xb0\x94\xf9\xbf\x94\x5a\x5e\xca\x98\xb7\x89\xed\x1d\xf8\x78\x87\xe7\xcb\x88\x75\x19\xfc\x2d\xa7\x6f\x05\xfc\xbf\x4b\xac\xef\x52\x6b\x2b\xc9\xed\x7b\xf8\xf8\x1e\x3e\xe5\xe3\x43\x3e\xef\xa6\x55\xe8\x5a\xcd\xb8\x35\xc4\xb3\x86\xf8\xd6\x92\x93\x75\x3c\x5b\x0f\xc7\xeb\x79\xb6\x9e\xda\xdf\x40\x1e\x36\x90\xbf\x0d\xc4\xba\x81\x98\x37\xe2\xd7\x46\xfc\xdd\x48\xed\x6c\x44\x66\x23\xf5\xb3\x11\xb9\x8d\xd8\xdc\xc4\xb8\x4d\x3c\xdf\x84\xbf\x9b\xe0\x76\x13\xdc\x6e\x42\xef\x66\xe2\xd9\x0c\xb7\x9b\xa9\xf1\xcd\xe8\x79\x9f\xfa\x78\x9f\xfa\x7d\x9f\xf8\xdf\xa7\xbe\xde\x47\x66\x0b\x7c\x6f\xc1\xf7\x2d\xf4\x6d\x41\xe7\x16\x6c\x7d\x80\xef\x1f\xc0\xc7\x07\x70\xf0\x01\x7c\x7d\x48\xbc\x1f\xd1\xbf\x15\x7f\xb7\xc2\xc1\x56\x7c\xd8\x8a\xec\x56\xec\x6f\xc5\xfe\x36\xec\x6c\x23\xaf\xdb\xc8\xe1\x36\xb8\xd8\x46\x8c\xdb\x89\x79\x3b\x5c\x6d\xa7\xee\xb6\xc3\xc7\x76\x78\xd9\x41\x5d\xed\x20\x57\x3b\x89\x6d\x27\xd7\x3b\xe9\xdb\x09\x8f\xbb\xc8\xdb\x2e\x78\xda\x85\x0f\xbb\x88\x79\x17\x36\x77\x23\xb3\x1b\x99\xdd\xe4\x78\x37\xdc\xed\xa6\x6f\x0f\xb9\xd8\x03\x4f\x7b\xe8\xdb\x43\xdf\x1e\x72\xbd\x17\x3b\x7b\xe9\xdb\x4b\x8e\xf7\xd2\xb7\x97\xbe\x7d\xe4\x74\x1f\x7d\xfb\xe0\x6b\x1f\x5c\xed\xa3\xef\x63\xc6\x7e\x4c\xdf\xc7\xf4\x7d\x0c\xdf\x1f\x93\x9b\x8f\x89\xff\x13\x6c\x7f\x82\x0f\x9f\x32\xf6\x53\xe4\xf6\x33\x76\x3f\x1c\x7e\x06\x3f\x07\xa8\xe7\x83\xc4\x7a\x88\xb1\x87\x18\x73\x88\x78\x3f\x87\xeb\xcf\xa9\xcb\xcf\xe1\xe8\x73\xe2\xfa\x9c\xbe\x2f\xe0\xf5\x0b\xd6\xa3\x2f\xf0\xe1\x0b\xf4\x7c\x01\x5f\x87\xf1\xff\x30\xfe\x1f\xc6\xd7\x23\xc8\x1f\xe5\xfe\x28\x31\x7c\x09\x1f\xc7\x90\x3b\x8e\xdc\x57\xe8\xfc\x9a\xbc\x7c\x03\x67\x27\xe8\x3f\x01\x97\xdf\x52\xaf\x27\xc9\xe3\x29\x74\x9e\x62\xec\x77\xf0\x5d\xc0\xf8\x02\xb8\x3f\x8d\x8e\x33\xcc\xd7\xb3\xf8\x70\x16\x9e\xce\x91\xd7\x42\x7c\x38\x0f\xcf\xe7\x19\xf7\x3d\xcf\x7e\xe0\xfa\x82\x09\x78\xbe\x88\xff\x97\xc8\xc9\x8f\xdc\xff\x48\x4d\xff\x84\x5f\x97\x89\xfb\x67\x78\xfe\x05\xff\x7f\x25\xf6\x5f\xc9\xff\xaf\xd4\xc4\x15\xb8\xf9\x0d\x9b\xbf\x31\xcf\xae\x32\xee\x2a\xf1\xff\x8e\xed\xdf\x19\xf7\x07\xf3\xff\x4f\x6a\xe4\x1a\xf2\xd7\xe0\xec\x3a\x7e\x5d\xc7\xde\x0d\x7c\xbe\x41\x5b\xc4\x7d\xd1\x31\xff\xbf\x43\x31\x26\x70\xbc\x6c\xc7\xc9\x17\x68\x41\xe0\xa0\x28\x3d\x15\x78\x45\xd9\xdc\xe0\x8a\x28\xfb\x16\x51\x8e\x46\x60\xad\x28\x67\x37\xf0\xa9\x28\xf6\x34\x8a\x3d\x8d\x0a\xae\x09\x76\x8a\x0a\xc9\x11\x55\xca\xc4\x29\x51\xa5\xe7\x8b\x0a\xad\x0a\x6e\x88\x2a\xc3\x75\x18\xd7\xe1\xa5\xc1\x37\x6c\x71\x47\x03\xc6\x45\xe6\x02\x9e\x97\xcd\x02\x7f\x88\x8a\xc2\x46\xf4\x60\x51\xe5\x5a\x03\x7c\x28\xdf\x17\x9c\x17\x55\x61\xaa\xa8\x8a\xd8\xae\x88\xde\x4a\xe8\x8a\xc1\x46\x0c\x3a\x2a\x57\x06\x73\xc1\x61\x51\xb1\xf9\xa2\xaa\xcc\x12\xe5\x62\xbc\x7b\x84\xa8\xb8\xad\xa2\x12\x88\xa1\x6a\x3d\x51\x89\x8c\x4d\xa2\xaf\x1a\xcf\xab\x63\xab\x3a\xf2\x35\xd0\x7f\x17\x7a\x92\xf1\xab\x26\x31\xd7\x44\x4f\x2d\xe4\x6b\x2d\x11\x55\x3b\x0a\xcc\x10\x95\x42\xec\x29\x2b\x44\xa5\x76\x02\xc8\xa7\x62\xbf\x8e\x0d\xf0\xbc\x0e\xe3\xea\xa0\xbb\x0e\xbe\xd5\x21\x96\xba\xf8\x5c\x17\x9b\x75\x91\xab\x8b\x5c\x1a\x63\xd3\x88\x2f\x0d\xbe\x98\xe6\xaa\x1e\xba\xeb\xe1\x5b\x3d\x38\xab\x37\x1d\x98\xfd\x67\x44\xd5\x47\xae\x3e\x71\xd6\x7f\x1b\x1c\x13\xd5\x00\xbd\x0d\x88\xad\x01\xcf\x1b\xc0\x7b\xc3\xa6\x00\x3d\x0d\xd1\xdb\x08\xdb\x8d\x26\x01\xe4\xd2\xf1\x3d\x1d\xce\x1b\x33\xbe\x31\x7d\x4d\x2a\x80\x5e\x80\x31\x4d\x89\xa7\x29\xf7\x4d\xc9\x53\xd3\x97\x00\xfe\x34\xab\x0e\x18\xd3\x8c\xfb\x66\xe6\x3d\x72\xcd\xd1\xdd\x7c\x23\x80\x7b\x0f\x1c\x79\xa8\x03\xf6\x56\xca\x8b\xac\x17\x5f\xbd\xe4\xa3\x05\x7a\x5a\xc0\x5b\x0b\x6c\xb6\x24\xee\x96\xe8\x6c\x09\x37\x2d\xb1\xdd\x0a\x3b\xad\xa8\x91\x56\x70\xd7\x8a\xd8\x5b\x5d\x16\xd5\x9a\xb1\xad\xc9\x51\x6b\xf4\xb4\x26\xd7\x6d\x88\xa7\x0d\x75\xd5\x06\x9e\xda\x10\x43\x06\xcf\x33\xb0\x93\x81\xce\x0c\x72\x96\x01\x07\x6d\xe1\xa6\x2d\x3a\xda\x62\xa3\xed\x45\xa1\x0c\x01\xb6\xda\x21\xdb\x8e\x7c\xb5\x43\xb6\x1d\x7c\xb4\x43\x5f\x7b\x6c\xb6\x87\xeb\xf6\xe8\x6b\x0f\x67\xed\xd1\xd9\x01\xf9\x0e\xd8\xe9\x80\xcf\x1d\xc8\x5f\x07\xf2\xd1\x11\xae\x3a\xc2\x6b\x47\xf4\x76\x24\xde\x4e\xe8\xea\x44\x1e\x3b\xc1\x55\x27\xf4\x74\x86\xb7\xce\xf0\xc1\x7e\x50\x75\x86\x8b\x2e\xc8\x76\x41\x67\x17\xee\xbb\x20\xdf\x15\x1b\x5d\xe1\xbd\x2b\xb6\xbb\x62\xbb\x2b\x63\xba\xc1\x45\x37\x62\xe9\x86\x8e\x6e\xf8\xdd\x1d\x1d\xdd\xb9\xee\x4e\x1c\xdd\x19\xc3\xde\x51\xf5\x40\x47\x0f\xe2\xef\x01\x17\x3d\xe1\xb7\x27\x75\xd7\x13\x9f\x7a\x12\x5b\x2f\x7c\xea\xc5\xf3\x4c\x7c\xcd\x24\x4e\xf6\x93\xaa\x37\xfa\xb2\xe0\x39\x8b\xfb\x6c\x7c\xcc\xc6\x5e\xf6\x5e\x80\x4f\xf7\xa0\xff\x1e\xb8\xba\x07\xfb\xf7\x30\x0f\xfa\xe0\x7f\x1f\xe4\xfa\x32\xbe\x2f\x7a\xfb\xd2\xdf\x17\xbd\xec\x1f\x55\x3f\x62\xef\x87\xef\xfd\xa8\xed\x7e\xc8\xf6\xa3\xaf\x3f\xb9\xe9\x4f\x4d\xf4\x27\x0e\xf6\x93\xaa\x3f\x5c\xf4\xc7\x97\xfe\xe4\xa6\x3f\x1c\xb1\xb7\x54\xfd\xb1\x33\x00\x1f\x06\x50\x93\x03\xc8\x61\x0e\x36\x73\xe0\x35\x07\x5e\x07\x86\x03\xee\x07\x92\x83\x81\xf8\x34\x90\x3a\x19\x04\xff\x83\xd0\x39\x08\x3d\x83\xb8\xbf\x17\x9e\xee\x25\xde\xc1\xc8\x0e\x46\xcf\x60\x64\x07\x63\x6f\x30\xbe\x0d\x61\x7e\xb0\xff\x54\x43\x90\x1f\x82\x7f\x43\x89\x77\x28\x31\x0e\xa5\xd6\x86\x2e\x06\xf0\xc6\xfe\x53\xdd\xc7\xfd\x7d\x8c\xbd\x0f\x9d\xf7\x31\x2e\x97\xfb\x5c\xee\x73\xd1\x75\x3f\x31\xdc\x4f\xcd\x0d\xc3\x8f\x61\xf8\x3a\x9c\xf1\xc3\xc9\xd5\x70\x78\x1a\x0e\x6f\xc3\xe1\x63\x04\xeb\xc0\x08\x6c\xb0\xef\x54\x0f\xc0\x0d\xfb\x4b\x35\x8a\x39\x34\x1a\xdb\xa3\x79\x3e\x06\x5e\xc6\x32\x66\x2c\x5c\xe5\x91\xf3\x3c\xf8\x19\x87\xed\xf1\xd8\x79\x10\x9f\x1e\x44\x27\x7b\x42\xc5\x3e\x50\x4d\x40\xcf\x04\xe2\x7a\x18\x5f\x1e\x21\x7f\x13\xc9\xe9\x44\xc6\x4d\x42\xe7\x64\x6c\x4e\xc6\xdf\xc9\xf8\x31\x05\x3b\x53\x90\x9d\x02\x6f\x8f\x32\xa7\xa6\x62\x63\x1a\x7a\xa6\x61\x73\x1a\x5c\x3f\x86\xef\xff\xc2\xf7\xe9\xe8\x98\x8e\xbd\xc7\x99\x33\x4f\x10\xc3\x13\x70\xfe\x24\x79\x7c\x92\x1c\xcc\x40\xdf\x0c\xea\xe4\x29\x7c\x99\xc9\x1a\xfa\x34\x71\xcc\xa2\x46\x66\x2d\x14\x35\x9b\x98\x67\xf3\xec\x19\xc6\xce\x81\xfb\xb9\x8c\x9f\x87\xce\x67\xd1\xf1\x2c\x3a\x9e\x63\xec\x7c\x38\x9a\x4f\x1e\x9f\xc7\xfe\x0b\xf0\xfb\x02\x6b\xcb\x0b\xf8\xf3\x02\xf9\x78\x11\x7d\x2f\xe2\xeb\x8b\xe4\xf1\x45\xe4\x5f\x44\xd7\x4b\xd4\xcc\xcb\xe8\x7f\x19\x9d\xaf\x50\x87\xaf\x30\x6e\x01\x76\x16\x70\xbd\x80\xd8\x17\xc2\xd9\x42\xf2\xb2\x08\xff\x16\xc1\xd7\x22\xe4\x17\x99\xf7\xf8\xf7\x2a\x3a\x5f\x23\xde\xd7\x88\x7d\x31\xb1\x2f\xe6\x7a\x31\xb6\x5e\x47\xdf\xeb\x70\xf4\x3a\xfc\xbc\x4e\x4c\x1c\xfb\xd5\x1b\xe4\xe5\x0d\xfc\x7a\x93\x76\x09\x7e\x2f\x81\xcf\x7f\xc3\xcd\xbf\xe1\xf1\x2d\x74\xbe\x05\x3f\x6f\xe1\xff\x5b\xc4\xf9\x16\xcf\x96\x52\x53\x4b\xc9\xc3\x52\x64\x96\x32\xe6\x6d\xb8\x7f\x1b\x7f\xde\xc1\xce\x3b\xdc\x2f\x23\x4f\xcb\xe0\x60\x39\xf1\x2f\x27\x4f\x2b\xb0\xfb\x2e\x3c\xaf\x84\xaf\x95\xf4\xaf\x44\xef\x7b\xf0\x9f\x4f\x1c\xab\xe0\x64\x35\x1c\xad\xa6\x16\xd6\xc0\xff\x5a\xf4\xae\x45\xef\x5a\xec\xae\xc3\xcf\x75\xe8\x5d\x4f\x6c\xeb\x89\x63\x03\xbe\x6f\x80\xb7\x0d\xf0\xb6\x01\x9d\x1b\x88\x71\x03\xb6\x37\xc2\x15\xfb\x33\xb5\x09\xdd\x9b\x19\xf7\x3e\x32\xec\xb7\xd4\x07\xbc\xbf\x3e\x80\xd3\x0f\xe1\xec\x23\x74\x7e\x44\x6d\x6d\x45\x7e\x2b\x73\x6e\x1b\x31\x6c\xa7\x8f\x3d\x93\xda\x81\xbe\x1d\xe8\xdb\x81\xbe\x1d\xe8\xd8\x81\x7f\x3b\x59\x2f\x77\x71\xbf\x0b\xf9\x5d\xc8\xef\xc6\xf6\x6e\xe6\xc7\x1e\x5a\xf3\x3f\x5f\xc7\x3e\x48\xb1\xf7\x51\x1f\xc3\xeb\x27\xf8\xfe\x29\xf3\xe9\x53\x62\xda\x4f\xec\x9f\xf1\xfc\x33\x78\x38\x80\xee\x83\xf8\x7e\x08\x7c\x4e\x9c\x5f\xc0\xf1\x11\x74\x1c\x61\x2d\x3a\xca\xdc\xfe\x92\xe7\xc7\xe0\xf5\x38\xbe\x1c\x87\xf7\xe3\xf8\x7a\x1c\x7e\xbf\xc2\xcf\xaf\xf1\xe1\x1b\xf4\x9d\x80\xfb\x6f\x91\x3f\x45\x2c\xa7\xa8\xcd\x53\xc4\xf5\x1d\x3e\x7c\xc7\xd8\x02\xf8\x2c\x60\xee\x16\x60\xab\x80\x71\xa7\xa9\xa1\xd3\x70\x7a\x06\xdf\xcf\x91\x8b\x73\xd4\x4d\x21\x36\xcf\xa3\xfb\x7b\xf8\xff\x1e\x3d\x3f\x70\x7f\x81\x71\x17\xf0\xfd\x02\xcf\x2f\x32\xbf\x2e\xc1\xf3\x25\x6c\xff\x48\x3d\xfc\x44\x5c\x97\xc1\xcf\xc4\xfd\x0b\xbc\xfd\x42\xfe\x7e\x25\x07\x57\x90\xff\x8d\xfc\x5c\x25\x4e\xf6\x2d\xea\x77\xe2\xfe\x1d\x3f\xff\x40\xf7\x9f\xf8\xff\x27\x76\xaf\x11\xe3\x75\xae\x6f\x98\x20\x5f\x45\xf8\xe5\xa3\xdf\x47\x7e\x8c\x33\xa2\xb1\x67\xd1\x64\xa3\x68\xaa\x35\x38\x28\x9a\x96\x03\xae\x88\xa6\x4f\x15\xcd\xd6\x09\x70\x6d\x5f\x28\x9a\x83\x6b\xa7\x0d\xcc\x00\x2f\x89\x16\x34\x41\xb4\x60\x64\x43\x7a\x89\x56\x2a\x0b\xe4\x02\xfa\x4b\xed\x15\xad\xf4\x2c\xd1\x42\xd1\x1b\x7a\x5e\xb4\x32\x93\x44\x0b\xab\x0c\xb6\x88\x16\x8e\x6c\xf8\x29\xd1\x22\xe8\x8b\xac\x00\xb0\x5f\x76\x2e\x58\x0c\x0e\x8b\x16\x85\xfe\xa8\xa6\x60\x34\xc0\x7e\x14\xcf\xa2\xb6\x82\xcb\xa2\x45\x0b\x08\x07\xf8\x19\x8d\xed\xe8\x15\x00\x5d\xe5\xa2\x00\xb6\xca\xe1\x67\x79\xc6\x97\xaf\x07\x06\x03\x7c\x29\xff\xa9\xf5\x9f\x2c\xd4\x2a\xd0\x57\x01\x5b\x15\xdf\x06\xdf\x88\x56\x09\x3d\x95\xd0\x53\x09\x3d\x95\xe8\xab\x74\x4c\xb4\x98\xd2\xc0\x0b\xc6\x01\xfa\x62\x90\xab\x8c\x5c\x65\xee\xd9\x1b\x69\xb1\x41\x00\xdf\x62\x6f\x88\x56\x25\x5f\x34\x17\x31\xbb\xb1\xe7\x46\x36\x0e\xfb\x71\x70\x17\x87\x3f\xf1\xf8\x9b\xc0\xf3\xaa\xf8\x9e\x38\x42\xb4\xa4\x54\x70\x51\xb4\x6a\x6b\x45\xab\x8e\xbd\x1a\x35\x01\xba\x6b\xd0\x57\x03\x5d\x77\xcd\x17\x2d\x99\x67\xc9\x3b\x01\x76\x6a\xc2\x4d\x2d\x37\x60\x5c\x2d\xfc\xa9\xd5\x0d\xc0\x73\x2d\xf4\xd7\x26\xae\xda\x4b\x44\x4b\x21\xe6\x14\x72\x92\x82\x7c\x0a\x3a\x52\xc9\x49\x2a\xe3\x53\xe1\xa0\x0e\x79\x62\x3f\xa5\xd5\xc1\x7e\x1d\x62\xae\x0b\x4f\x69\x70\x9d\x46\x1c\x69\xd8\xad\x47\x1c\xf5\x1a\x01\xf2\x55\x8f\xbc\xd7\x83\xdb\xfa\xf8\x54\x1f\xbe\xd8\x3f\x69\xf5\x91\x69\x80\x7c\x03\xec\x36\xe0\x9a\xbd\x93\xd6\x90\xfc\x34\x22\x27\x8d\xc8\x67\x3a\x31\xa4\xa3\xb3\x31\x7a\x1a\x63\xa3\x31\x3a\x1a\x63\xa7\x09\x39\x66\xef\xa4\x35\x41\xa6\x29\xfa\xd8\x37\x69\x4d\xb1\xd9\x94\xb1\x4d\xa9\x89\x66\xe4\xa1\x19\x76\x9b\xe1\x6b\x33\x6a\xa1\x19\x76\x9b\x23\xd3\x1c\x5f\x3d\xf0\xe8\x41\xbf\x87\x3e\x2f\xb9\xf2\x32\xc6\x4b\xee\x5a\xc0\x01\xfb\x26\xad\x25\xba\x5b\xc2\x71\x4b\x62\x6e\x45\x9e\x5a\xe1\x43\x2b\x6c\xb6\x46\x57\x6b\xb8\x6b\x83\xbf\x6d\xe0\x3c\x83\x7c\x65\xa0\xaf\x2d\x32\x6d\xcd\x16\x7d\xed\xc8\x41\x3b\xb8\x69\x0f\x77\xed\xe1\xbc\x03\xb6\x3a\xa0\xaf\x03\x76\x3a\xf4\x05\xc4\xdd\xe1\x0f\xd1\x3a\xa2\xa7\x13\xf9\x63\x2f\xa3\x75\xc6\xbf\x2e\x55\x01\xb9\xec\x4a\xfc\x5d\xe1\xb4\x2b\xbc\x77\x83\xf7\x6e\xf4\x77\xc3\xbf\x6e\xd8\xeb\x8e\xdd\xee\xd5\x01\x71\x75\x87\x87\x1e\xc8\xf6\x20\x07\xbd\xe0\xa6\x17\xdc\x65\xe2\x73\x26\x72\xbd\xe1\xa3\x37\xcf\x7a\x53\x67\x77\x73\x7d\x37\xd7\x77\xa3\x3b\x0b\xdf\xb2\x89\x31\x9b\x3c\x67\xc3\x45\x36\x79\xce\x26\x9f\xec\x55\xb4\x3e\xd4\x57\x1f\xec\xf4\x61\x7c\x1f\x64\xfb\x90\xff\xbe\xc4\xdd\x97\x98\xfb\x62\xa3\x1f\x5c\xb0\x37\xd1\x06\x10\xcf\x00\xb8\x1b\x80\xee\x1c\xee\x73\x68\x07\xa2\x7f\x20\xb2\x03\xe1\x68\x10\x7a\x07\x11\xe3\xbd\xf8\x79\x2f\xed\x60\xe4\x07\xa3\x83\xfd\x84\x36\x04\x8e\x87\xd2\x0e\x25\xef\xf7\x51\x73\xf7\x61\x2f\x77\xba\x68\xf7\x53\x1b\xec\x15\xb4\xe1\xe8\x1b\x8e\x3f\x23\xe0\x6f\x24\x75\xc9\xbe\x40\x7b\x80\x31\xa3\xf0\x7b\x34\xfe\x8d\x66\xdc\x18\xfa\xc6\xc0\xdf\x58\xae\xf3\xe0\x35\x0f\x9e\xc6\x61\x63\x1c\x7c\x8f\x27\xb6\xf1\x70\xf9\x20\x36\x1e\xc4\xaf\x87\x88\x65\x02\xdc\x4c\x40\xe6\x61\xc6\x3f\x4c\x4c\x8f\xa0\x77\x22\x76\x26\xe2\xeb\x44\xf4\x4c\x22\x77\x93\xb0\x3d\x89\xfc\x4c\x82\xbf\x49\xe4\x68\x32\x63\x26\xa3\x7b\x32\xfa\xa6\x90\x8b\x47\xf1\x73\x2a\xb9\x7d\x0c\xd9\x7f\xa1\xf7\x71\xf8\x7f\x82\xd8\x9e\x44\xff\x0c\x74\x3f\x45\x2e\x66\x52\x73\x4f\x73\x3d\x0b\xbf\x66\x33\x7e\x36\x73\x65\x0e\x72\x73\x18\x3b\x17\xfd\xf3\xd0\x3f\x0f\x1d\xcf\xd2\xff\x1c\x79\x9f\x8f\xfd\xe7\xc9\xfd\x8b\xd4\xe9\x8b\xf0\xff\x12\x79\x7a\x19\xbf\x5e\x21\xe7\x0b\xb0\xbd\x00\x99\x85\xe8\x5c\x84\xce\x57\xe9\x7f\x95\xb1\xaf\x51\x9b\x8b\xc9\xcd\xeb\xf4\xbf\x41\x6d\xbd\x89\xcc\x12\xf4\xf1\x8e\xd6\xde\x82\xa7\xa5\xf0\xf4\x36\x31\xbc\x43\x5d\xbe\x83\xfc\x32\x9e\x2d\xc7\xcf\x15\xe4\x62\x05\xb1\xbe\x8b\xdc\xbb\xcc\x97\x95\xe4\x6f\x25\x39\x7d\x8f\x9a\xc9\xe7\x7a\x15\xfc\xad\xc2\xc6\x2a\xb8\x59\x45\xff\x6a\x62\x58\x43\xac\x6b\xc8\xcd\x1a\xf4\xae\x25\x1f\xeb\x58\x37\xd6\x93\xdb\x0d\xd4\xe0\x06\xe4\x36\x12\xe3\x46\xfa\x37\xe1\xdf\x66\xfa\x36\xe3\xd3\xfb\xd4\xc8\x16\xf8\xdb\x02\xcf\x1f\x50\x5b\x1f\xc0\xcb\x87\x3c\xfb\x90\x38\x3f\x22\x3f\x1f\xe1\xc3\x56\x62\xd8\x8a\xdd\x6d\xc4\xbb\x8d\xb8\xb7\x63\x67\x3b\x3c\x6d\xa7\x06\xb6\x63\x63\x3b\x3a\x77\xa0\x7b\x07\xbc\xef\xc0\x0f\xde\xc3\xda\x4e\x64\x77\x92\xbf\x9d\xf8\xb3\x93\x31\x3b\xf1\x69\x27\xba\x76\x51\x0b\xbb\xf0\x69\x17\xfe\xec\xa2\x7f\x17\x9c\xec\x86\x3b\xde\xd1\xda\x6e\xec\xef\xc6\xd6\x6e\x7c\xd8\x0d\xd7\x7b\xe0\x64\x0f\x75\xba\x07\x3b\x7b\xb0\xb3\x07\x7f\x79\x87\x6b\x7b\x91\xdd\x0b\x07\x7b\xf1\x7d\xaf\xd9\x47\xfc\xfb\xc8\xd7\x3e\xf8\xd8\x87\x8e\x7d\xac\x39\xfb\xe0\x7c\x1f\x7c\x7e\x4c\xff\xc7\xd8\xfb\x18\x3f\x3e\x26\xf7\x1f\x13\xc7\x27\xe8\xfd\x04\xce\x3f\x41\xf6\x13\xe6\xc0\x27\xf0\xf1\x09\xf1\x7f\x42\x1d\x7f\x0a\xef\x9f\xd2\xff\x29\xba\x3f\xc5\xe7\x4f\xe9\xdb\x4f\xdf\x7e\xea\x73\x3f\xeb\xc5\x7e\x78\xd9\x4f\x7c\x9f\xc1\xff\x67\xd8\xfb\x8c\x38\x3e\x23\xe6\xcf\xc8\xdb\x01\x7c\x3b\x40\xdc\x07\xe0\xf3\x00\x71\x1c\xa0\xae\x0f\x10\xdf\x41\xf8\x3c\xc8\xbb\xe4\x20\x6b\xdd\x41\x6c\x1d\xc4\xd6\x41\xf4\x1e\x42\xef\x21\xf4\x1e\x42\xef\x21\xf4\x1e\xa2\x36\x3e\x87\x8b\xcf\xe9\xfb\x9c\x18\x3e\x87\xd7\x2f\xd0\xf9\x05\xf1\x7e\x41\xbc\x5f\x50\x97\x5f\x60\xe7\x30\xb6\x0f\xd3\x77\x98\xfc\x1c\x86\x97\xc3\xc4\x7a\x18\x3b\x47\xd0\x77\x04\xdf\x8f\x60\xfb\x08\x1c\x1e\xa1\x6e\x8e\x62\xfb\x28\xb6\x8f\x32\xfe\x28\xb6\x8f\x12\xff\x97\xc4\xff\x25\x75\xf7\x25\xf7\x5f\x72\x7f\x8c\x7c\x1e\x83\xe7\x63\xf0\x7c\x0c\x7d\xc7\xd0\x77\x0c\x7d\xc7\x19\x7b\x9c\xb1\xc7\x19\x7b\x1c\x3e\x8e\xc3\xf5\x71\xb8\xfe\x0a\x4e\xbf\x22\xd7\x5f\xe1\xf7\x57\xc4\xf8\x15\x7d\x5f\x33\xef\xbe\xc6\xf6\xd7\xf8\xfd\x35\x7d\x5f\x63\xfb\x1b\x62\xf9\x06\xee\xbf\x41\xee\x1b\xb8\xff\x86\x9c\x9e\x40\xe7\x09\xb8\x3f\x01\xef\x27\xb0\x7f\x02\x2e\xbe\x25\xc6\x6f\x19\xff\x2d\xf1\x7c\x4b\xed\x7f\x8b\x9d\x6f\xa9\x95\x93\xc4\x73\x92\x1a\x3a\x49\xee\x4e\x32\xfe\x24\xbe\x9e\xa2\xce\x4e\x11\xfb\x29\x7c\x3d\x85\x4f\xa7\x18\xff\x1d\xe3\xbf\x63\xfc\x77\xf8\xc1\xde\x4a\x2b\x40\x7f\x01\x79\x29\x80\xd3\x02\x38\x3d\xcd\xfc\x3c\x4d\xdf\x69\xfa\x4e\xa3\xe7\x34\x7e\x9c\x41\xee\x0c\xbe\x9d\xa1\xef\x0c\x7a\xce\xc0\xeb\x59\x74\x9f\x25\xa7\x67\xc9\xd3\x59\xc6\x9e\x65\xec\x39\xfc\x3d\x47\xac\xe7\xf0\xf7\x1c\xbe\x9d\x23\x27\xe7\xa8\xab\x42\x38\x28\x64\x7c\x21\xb1\x15\xa2\xb3\x10\x9d\xe7\x91\x3d\x8f\xec\x79\xfa\xce\x53\xdb\xe7\xe1\xe0\x7b\xec\x7c\x8f\xdc\xf7\xd8\xf9\x1e\x3b\xdf\x53\x53\xdf\x93\xfb\x1f\x88\xed\x07\xf2\xfc\x03\xb2\x3f\x60\xeb\x07\x62\xbb\x40\x1e\x2e\x60\xff\x02\xf6\x2f\x50\x53\x17\xe8\xbb\x48\xae\x2e\x92\x83\x8b\xd8\xbf\x88\xdc\x45\x74\x5e\x62\x0e\x5d\x62\xec\x25\xd6\xe8\x4b\x70\x7d\x09\x7f\x7e\xc4\x9f\x1f\xe9\xfb\x11\xae\x7e\xc4\xf6\x8f\xf8\xfe\x13\xfa\x7e\x62\x9e\xfe\x04\xaf\x3f\x91\xd7\x9f\xf0\xfd\x27\x38\xba\xcc\xf8\xcb\xf0\x7a\x99\xf1\x97\x19\x7f\x99\xf1\x3f\x33\xfe\x67\xfc\xfc\x19\x3f\x7f\xc6\xf6\xcf\xd8\xfe\x85\xf1\xbf\x30\x9e\xfd\xa4\xf6\x0b\x7e\xfe\x42\x9c\xbf\xa0\xf7\x57\x7c\xfa\x15\x3f\x7f\xa5\x2e\x7e\x25\x87\xbf\x32\x1f\xae\x20\x7b\x85\xbe\x2b\xf8\x7e\x85\xf1\x57\x18\xff\x1b\x72\xbf\xc1\xfb\x6f\x8c\xfd\x8d\x7a\xfc\x0d\x3b\x57\x89\xfb\x2a\x75\x72\x95\x3a\xb9\x4a\x9d\x5d\xc5\x9f\xdf\xe9\xfb\x9d\x39\xf3\x3b\x7d\xbf\xe3\xe3\xef\xf0\xf3\x07\x39\xfe\x83\x1a\xfd\x03\xfd\x7f\xa0\xeb\x4f\xf4\xff\x49\x8d\xfe\x89\xcd\x3f\xe9\xfb\x13\x9b\xd7\xe8\xbb\x86\xcd\x6b\xd8\xbc\x86\xcd\x6b\xf4\x5d\xc7\xe6\x75\x6c\x5e\xc7\xe6\x75\x6c\x5e\xc7\xe6\x0d\xf4\xdf\x80\x9b\x1b\x70\x73\x03\x6e\x6e\xc0\x61\x11\xb9\x2a\x22\x57\x45\xc8\x15\xd1\x57\x44\x9f\x8f\x5c\xf9\x90\xf3\x31\x7f\x7c\xf8\xe1\xc3\x0f\x03\x3f\x0c\xfc\x30\xc8\x9d\xf1\x69\xe0\x5f\x49\xd4\x03\xb9\x60\x21\x30\xfb\x6e\x88\xae\xe8\x53\x23\xc0\x12\xf0\x8d\xe8\x5a\x69\xd0\x14\x8c\x06\xf4\x69\xc7\x44\xd7\xe9\xd3\xbd\x60\x1c\x78\x1b\x9c\x12\xdd\x56\x01\x74\x03\x53\x41\x3e\x38\x23\xba\x9d\x3e\x7b\x27\x40\x9f\x7d\x2d\x38\x2f\xba\x83\xb1\x8e\x54\x90\x05\xe8\x77\x30\xde\x71\x10\xfc\x21\xba\xd3\x0d\x7a\x81\xe9\x00\x79\x27\x3a\x82\xa2\x40\x3b\x30\x01\x20\x1b\x84\xfd\xe0\x20\x80\x4f\xc1\xf8\x19\x8c\xef\xc1\xf8\x1e\x42\x5f\x48\x6b\xc0\xd8\x90\x9d\xa2\x97\xb2\x01\xee\x4b\x71\x5f\x8a\xfb\xd2\xc4\x5b\x9a\x31\xa5\x27\x81\x2d\x80\x58\x43\xb9\x0f\xe5\x3e\x94\xfb\xd0\x2b\xa2\x97\xa9\x09\xe0\xa3\x0c\x71\x96\x21\x26\xf6\xf2\x7a\x18\x7e\x86\xcd\x07\xf8\x18\x8e\xef\xe1\xc4\x13\x3e\x0b\xec\x15\x3d\x02\x9b\x11\xf8\x16\x31\x03\x60\x23\x12\x1b\x91\xf0\x12\x49\x5c\x91\x5b\x45\x2f\xcb\x7d\x59\xee\xcb\x72\x5f\x76\x05\xc0\xf7\x28\xc6\x44\x35\x02\xd8\x89\x7a\x09\xa0\x27\x8a\xd8\xa3\xab\x03\x6c\x45\x63\x2b\x9a\xb1\xd1\xf4\x95\xa3\xaf\xdc\x60\x80\x5c\x39\xe4\xca\xa3\x8f\x3d\xbf\x5e\xbe\x2f\x80\x0b\xf6\xfb\x7a\x05\xec\x57\x40\xbe\x22\xb9\xa8\x08\xef\x15\x91\xab\x44\x7f\x25\x38\xae\x84\x8d\x4a\x8b\xc1\x61\xd1\xd9\xf3\xeb\xec\xf9\xf5\x18\x38\x8b\xc1\x8f\xca\x8c\xab\x4c\xcc\xb1\x55\x01\x9c\xc7\xce\x05\xf0\x18\x8b\xdd\x2a\xd8\xa8\x82\xdd\x2a\xf8\x52\xe5\x53\xeb\x6b\x76\xdd\x45\xfe\x5d\x70\xe2\xc6\x17\x37\x36\xdc\xc8\xc5\x11\x47\x1c\x79\x89\xc3\x97\x38\x74\xc6\x13\x5b\x3c\x7a\xe3\xe9\x8b\xa7\x2f\x9e\xfa\x49\x08\x07\xe4\x21\x81\x7c\x56\xc5\x56\xd5\x1c\x40\xce\xaa\xa2\x23\x11\xbd\x89\xf8\xc9\xd9\x41\x4f\xc4\xcf\x44\x38\x4e\xc4\xa7\x24\xea\x86\xb3\x84\x9e\x44\x7f\xd2\x96\xff\x17\xa0\xce\xaa\x11\x53\xb5\x8d\xa2\x57\x47\x57\x75\x72\x5c\x1d\x7f\xef\xa2\x3e\xef\xa2\x1e\x38\x87\xe8\x77\xc1\x59\x4d\xf2\x5c\x0b\x1f\x38\x73\xe8\xb5\x90\xad\x0d\xaf\xb5\xb1\xcf\x79\x43\x4f\xc1\xdf\x54\x78\xa8\x43\x0d\xd4\xc5\xb7\x34\xea\x30\x8d\xdc\xa7\x31\x3e\x0d\xdf\xeb\x91\x9b\x7a\xe4\xbd\x1e\x7c\x34\x24\xce\x46\xf0\xdb\x08\x9f\x1b\x61\xb7\x11\x79\x48\x27\xee\x74\xec\xa5\x93\x7b\xce\x10\x7a\x63\xae\x1b\x63\xb3\x09\x1c\x34\xc1\x4e\x13\x74\x36\xa5\x46\x9b\xc2\x33\xe7\x05\xbd\x19\x3a\x9b\xf3\x8c\xf3\x81\xee\x61\x8c\x07\x1f\x3d\x70\xe8\x21\x1e\x0f\xbc\x78\x98\x0b\x5e\xf4\xb4\x40\xae\x25\xfa\x5b\xa1\xa3\x35\x3a\xda\x80\x0c\xf4\xb6\x27\x4f\xed\x91\xe9\x88\xcf\x1d\x69\x3b\xe1\x53\x67\xd0\x05\x7f\xbb\x52\xd7\xdd\x18\xd7\x1d\xd9\x1e\xf4\xf5\x04\xbd\xc8\x57\x26\x6d\x6f\xe2\xec\xcd\xb3\xbb\xc9\x6d\x16\x7d\xd9\x97\x45\xbf\x07\x0e\xd8\x87\xeb\xec\xbf\xf5\x7e\xc4\xd4\x9f\xba\xec\xcf\x7d\x7f\x64\x06\xe0\xeb\x00\xf2\x32\x00\x7b\x39\xe8\xcd\x61\x2e\xe4\xc0\x57\x0e\xe3\x06\x12\xe3\x40\x38\x1d\x44\x0c\x83\xa8\xbd\x41\xe8\xb9\x97\x38\x06\xc3\xef\x60\xe4\x87\x90\x8b\x21\xf8\x30\x84\x78\x86\xa0\x6b\x28\x9c\x0e\x45\xee\x3e\x6a\xeb\x3e\x62\xcd\x85\x33\xf6\xe4\xfa\x30\xea\x67\x04\xbc\x8f\xa0\x26\x47\x30\x4f\x47\xf2\x7c\x24\xe3\x1f\xa0\xbe\x1e\xc0\x36\xfb\x72\x7d\x14\x7e\x8c\xc2\xb7\x51\xd4\xfd\x28\x62\x18\x85\xad\xd1\xc4\x3e\x9a\xf1\xa3\xd1\x3f\x86\xf1\x63\xd0\x3d\x06\xd9\xb1\xf0\x3a\x96\xeb\xb1\x5c\xe7\x91\xb7\x3c\x72\x96\x47\x3d\x8c\xc3\xdf\x71\xc4\x35\x9e\x75\x67\x3c\x36\xc7\x53\x37\x0f\x52\xbf\x0f\xe2\xe3\x43\xf8\xf2\x10\x75\xf3\x10\x5c\x4e\xc0\xe6\x04\xe6\xd0\xc3\xd4\xfb\xc3\xc8\x3f\x82\xdd\x47\x88\x6b\x22\x36\x26\x12\xff\x44\x62\x9f\x84\xec\x64\xe2\x99\x4c\xfc\x53\x88\x77\x0a\xbe\x4f\x41\x76\x0a\xcf\x1e\x45\xff\xa3\xd8\xfa\x17\xbe\xcd\xa4\x7f\x1e\x35\x32\x8f\x1c\xcf\x83\xf7\x79\xf8\xf1\x2c\xf3\xe3\x59\x62\x7c\x16\xbb\xcf\xe2\xfb\x73\xc4\xf6\x1c\xdc\x3e\xc7\xfd\x7c\x7c\x7f\x9e\x18\x9f\x47\xf6\x05\xfa\x5e\x20\x86\x17\x59\xb7\x5e\x42\xfe\x65\xfc\x7a\x85\xb8\x16\xe0\xd7\x42\xb8\x5d\x08\x0f\x8b\xb0\xb1\x08\x9b\xaf\x52\xab\xaf\x32\xe6\x35\xfc\x5c\x8c\xfd\xc5\xe4\xfa\x75\xc6\xbc\x81\xcf\x6f\x60\xe3\x4d\x72\xb6\x04\xdb\xff\x66\xcc\x5b\xac\x0b\x6f\x5d\x14\x7d\x29\x63\xdf\xe6\xf9\xdb\xf8\xf8\x0e\x5c\xbf\x43\x4e\x96\x71\xbf\x9c\xb8\x96\xc3\xef\x0a\x62\x5b\x41\xfb\x2e\xfe\xbe\xcb\xd8\x95\x70\xb5\x92\xb8\x57\xa2\x63\x25\x3c\xbd\x07\x67\xef\x51\xcf\xef\x31\x97\xf2\xa9\x81\x7c\xea\x26\x9f\x9a\xcd\x87\xd7\x55\xc4\xb1\x0a\x7f\x57\x21\xbb\x8a\x9c\xae\x26\x57\xab\xf1\x67\x35\xcf\x57\xa3\x93\x3d\xbf\xbe\x86\x9a\x5e\x83\xbe\x35\x70\xba\x06\xff\xd6\xf0\x6c\x0d\xf5\xcf\x39\x40\x5f\x83\xff\x6b\xf0\x71\x0d\x63\xd7\x22\xbb\x96\xf8\xd6\x62\x6b\x2d\xf2\x6b\x91\x5d\x8b\xdc\x5a\x72\xb4\x16\x99\x75\xf8\xb1\x8e\x3c\xaf\x23\xae\x75\xf8\xb0\x0e\x3b\xeb\xa8\xe5\x75\xf0\xb9\x0e\xdf\xd6\x11\xff\x3a\x7c\x5a\x0f\xcf\xeb\xe1\x6d\x3d\xf9\x5c\x4f\x2c\xeb\xc9\xdb\x7a\xea\x60\x3d\xf1\xaf\x27\xf6\xf5\xe4\x6f\x3d\x73\x62\x3d\x7c\x6e\x80\x8f\x0d\xf0\xb8\x01\xae\x37\x90\xcb\x0d\xf0\xbe\x01\x7b\x1b\x89\x73\x23\xb1\x6c\x24\x9f\x1b\xf1\xf3\x7d\x6c\xbf\x4f\x1c\xef\x33\x47\xdf\xc7\xd7\x2d\xe8\xdd\xc2\xb3\x2d\xf8\xf7\x01\xb2\x1f\xe0\x37\xe7\x13\xfd\x03\xe2\xf9\x10\xbb\x1f\x92\x9f\x0f\xb1\xf5\x21\xcf\x3f\xc4\xaf\x0f\xe1\xf1\x43\xb8\xfd\x88\x18\x3f\x82\x7b\xce\x2e\xfa\x47\xe4\xff\x23\xfc\xff\x88\x38\x3f\xe2\x39\x67\x19\x7d\x2b\xcf\xb6\x32\x7e\x2b\xb9\xd8\x4a\x8c\x5b\xe1\x76\x2b\x5c\x70\xc6\xd1\xb7\x12\xe7\x56\x78\xde\x4a\xfe\x39\xef\xe8\x5b\xf1\x7f\x1b\xb6\xb7\x11\x2b\x67\x1f\x7d\x1b\xbc\x6c\xa3\x06\xb7\x11\xc3\x36\xc6\x6c\x23\xde\x6d\xe4\x76\x1b\xdc\x6c\x23\x86\x6d\xcc\xcd\x6d\xe4\x64\x3b\x31\x6f\xc7\xce\x76\xec\x6c\xc7\xce\x76\xec\x6c\xc7\xce\x76\xe2\xd9\x4e\x7c\x3b\xe0\x6f\x07\x7a\x76\xf0\xee\xdb\x49\x8d\xec\x84\x17\xce\x47\xfa\x2e\x78\xda\x85\xcf\xbb\xb0\xbf\x1b\x9b\xbb\x19\xb3\x1b\x99\x3d\xc8\xec\xe1\x7a\x0f\xbc\xee\x85\xa7\xbd\xc4\xc6\xb9\x47\xdf\x87\x8d\x7d\xc8\xef\x83\x83\x8f\x89\xfb\x63\xf8\xf9\x18\xf9\x4f\xc8\xe1\x27\xf8\xf7\x09\x32\x9f\xa2\xe7\x53\xc6\x7e\xca\xf5\x7e\x6a\x89\x33\x8c\xbe\x9f\xeb\xcf\xd0\xf3\x19\x7c\x7f\x86\xce\x03\xd8\x3d\x80\xfc\x01\xf2\x72\x10\x9d\x07\x89\xef\x20\x7a\x0e\x71\x7d\x88\xb1\x87\xb8\xfe\x9c\xf8\x3f\xa7\xce\x3f\x47\xe6\x0b\xf4\x7c\x81\xdd\x2f\xf0\x99\x73\x88\x7e\x18\x7e\x0f\x13\xf7\x11\x62\x3d\x42\x5e\x8e\x50\x4b\x47\xc9\xd7\x51\xea\xf0\x4b\xfc\xfa\x92\xf8\xbf\x84\xdb\x2f\xe9\x3f\x46\xac\xc7\xe0\xf8\x38\x31\x1d\x47\xf7\x71\xf3\x9a\x7c\x7f\x85\xcc\x57\xf8\xf2\x35\xbe\x7f\x8d\x8f\x5f\x63\xe7\x1b\xfc\xfa\x06\xbf\xbe\xa1\x96\x4e\xd0\x7f\x82\xfe\x13\xd4\xdf\xb7\xe8\xf8\x96\xdc\x7f\x4b\x7e\x4e\x92\x93\x93\xac\x4b\x27\xd1\x71\x8a\xf8\x4f\xa1\xe3\x3b\x6c\x7e\x07\xbf\xdf\x61\xb3\x80\xfc\x15\x10\x4f\x01\xbe\x9e\xc6\xef\xd3\xd8\x3c\x0d\x5f\x67\xb0\xcf\xde\x5f\x3f\x43\xce\xce\x52\x9b\x67\xc9\xff\x59\x72\x7e\x8e\x9c\x9d\xe3\xfa\x1c\xf1\xb0\xbf\xd7\x0b\xc9\x6f\x21\xd7\xe7\xb9\x3e\x4f\x3c\xe7\xa9\x21\xf6\xf3\xfa\xf7\xe4\xf1\x07\x74\xfc\x40\xdd\xff\x00\x3f\xec\xdd\xf5\x0b\xf4\x5f\xa0\xff\x22\xd7\x17\xb1\x79\x11\x5f\x2e\x51\x0b\xec\xd5\xf5\x4b\xf8\xfb\x23\xfd\x3f\x32\xa7\x7e\xc4\x97\x9f\xe0\xf6\x27\xfc\xfd\x89\xda\xb9\x4c\xff\x65\xfa\x2f\x93\x97\x9f\xc9\xd7\xcf\xe4\xf7\x67\x7c\x64\xff\xad\xff\xc2\xf5\x2f\x5c\xff\xca\xf5\xaf\xe4\xeb\x57\xf8\x62\xaf\xad\x5f\xa1\x9f\x7d\xb6\x7e\x05\x4e\x7f\xc3\xe7\xdf\xe8\xbf\xca\x9c\xb9\x4a\xbd\x5f\x25\xa6\xdf\xe9\xfb\x1d\x5e\x7e\xa7\xee\xff\xe0\xfa\x0f\x62\xfd\x03\xfd\x7f\xe2\xf3\x9f\xd8\xfd\x93\x58\xfe\x24\x96\x6b\xe4\xec\x1a\x75\x7c\x8d\xd8\xaf\xc3\xf1\x75\xf2\x7a\x1d\xbf\x6f\x60\xe3\x06\x39\xb9\x41\xfc\x37\xe0\xb9\x88\xb5\xb3\x08\xdd\x45\xe4\xc5\x47\x5e\x7c\xf0\xe8\xc3\x77\x03\x4e\x0d\x62\x35\xd0\x67\x5c\x16\x9b\x34\x02\x53\xc1\x5e\xb1\xa9\x70\xe0\x05\x37\xc4\xa6\x2d\x14\x9b\x3e\x1a\x1c\x13\x9b\xad\x2a\x98\x2f\x36\xbb\x1b\x4c\x17\x9b\x43\xc0\x2c\x70\x58\x6c\x4e\xc6\x06\x31\x2e\x68\x30\x58\x2b\xb6\xe0\x9a\x60\x8b\xd8\x42\x2a\x83\x49\xe0\x8a\xd8\x4a\xcd\x05\xa7\xc4\x56\x3a\x15\x6c\x14\x5b\x68\x37\x80\x6c\x99\x0a\xe0\x6d\xb1\x85\xb5\x2b\x81\x5c\x80\xce\xb0\x97\x40\x3e\xc0\xaf\x30\xc6\x86\xfd\x21\xb6\xf0\x20\x80\xfe\x08\x74\x47\xf0\x2c\xb2\x2f\x40\x7f\xd9\xf9\xe6\xff\xe7\x8d\x68\xd2\x95\x83\xe5\x93\xf6\x69\xec\xf0\x9d\xd2\xd5\x5b\x5b\x94\x72\xd8\x34\xdd\xa6\x07\x05\x2b\xbb\xd7\x66\x5f\xd4\xc7\x16\xa9\xe9\x23\x46\x66\x5d\x0e\x56\xa7\x82\xd5\xc1\x60\xb5\x35\x58\xe5\x07\xab\xa9\xc1\xca\x1d\xac\xfa\xf9\x7f\x92\xc5\xe3\x49\x96\x4a\x15\xc2\x3f\x8b\x88\x54\xe9\xe9\x11\x69\x11\x69\xfc\xa9\x93\xaa\x12\xca\xc6\xa9\xb2\x71\xba\x5a\x7a\x6e\xb1\x4a\x2a\xda\x5b\x4f\xb9\xeb\xa9\x65\xfa\x97\xd7\x1e\x55\x65\x7c\xbf\x98\x7f\xc3\x51\x93\xaf\xf5\xc7\xf4\x53\x01\xfb\x0d\xbd\x31\x36\xbb\xdd\xe9\x70\xb0\x8b\x57\x4a\xd3\x74\x3d\xd8\x2e\x0e\x4d\xc7\xd8\x68\xd3\x98\x78\xd2\xf6\xd7\x8d\x50\x69\x11\xfe\xff\x45\xa6\x97\xb4\x03\xf4\x9c\xaf\xdb\xa9\xb2\x45\x47\xf9\x1d\xa1\x3f\xa6\x0c\x9f\x52\x86\x69\xa3\x05\xe4\x8f\xb6\xe7\x49\x8c\xb8\x24\xc7\x9b\x5e\x3a\xd6\x55\xc9\x16\xe7\x0e\xb2\x95\x0e\x2d\xbd\x32\x3b\x56\x85\x56\x96\xf0\x88\xf0\x95\xd9\x15\xa3\x23\xc2\x42\xdf\x0b\xd5\x0e\x84\x1a\xa1\x5a\x58\x44\xd7\x88\xf7\x22\xf4\x03\x11\x2a\x34\x22\x34\xc2\x5e\xbe\xec\xaa\x10\xbb\xa4\xa4\x79\xd2\x22\xd3\xd3\x53\x52\xfa\x8d\xe9\x37\x06\xe3\xc9\x11\x62\x7a\x10\x68\x23\x55\xf9\x74\x9c\xd1\xd3\xa2\x13\x74\xd3\x9b\x84\xb2\x09\xf5\xd3\x2c\xa4\xe9\x71\x20\x2d\x3a\x8e\x56\x5f\xde\xe6\xcb\xab\x3d\x16\x76\xf3\xed\xef\xf6\x72\xd7\x05\x5b\x32\x0e\xfc\xd8\xeb\xe5\x1e\x2a\xad\xd7\xc2\x5e\x4b\x8a\x46\xb5\x53\xf5\x33\xf4\xfe\xbe\xb5\xcf\xfb\xfe\xa5\x26\x9b\x78\x5e\x75\x9a\xaf\xa6\xf9\x1e\x35\x31\xdf\xb7\x56\x75\x62\x5d\x35\x7e\x33\x72\x6d\x8f\xdb\x2f\x4b\x9c\x54\x97\x14\x79\xda\xdb\x43\x4f\x4a\x74\x55\x29\xef\x28\x67\x2b\xe7\x28\x1d\x5a\xb3\x56\x94\x23\x3a\x1a\x22\xe3\x83\xe3\x45\x62\x2a\x55\xaa\x53\x23\x3c\x3c\x24\x38\x38\xb5\x4a\xad\xa8\x5a\xe3\xb3\xa3\xa3\x43\x62\x6a\xba\x42\x13\x1d\x7a\xf9\xb0\xa8\x94\x28\x4f\x54\xd7\xa8\x51\x51\x8f\x46\x39\x82\xf5\xa8\xa4\xd2\x7a\xe9\x71\xd9\x76\xbb\x83\xe3\x83\x27\x2d\x2d\xc5\x0c\xab\x42\xca\x80\xfe\xfd\xd2\x22\xcb\xa7\xfb\x6f\x2d\xf6\x03\x09\xb8\x99\x03\x9e\xd6\x8d\x88\xb4\x82\x8f\xb2\xd9\x9d\x09\x0d\xe3\x93\xaa\x25\x96\x4b\x2b\x5b\x5b\xd5\xaf\xd7\x5c\xa5\x35\x2c\xef\xac\x5b\xae\xbc\xbd\xb6\x4a\xd0\xab\x28\x7b\xbd\xa4\x6a\x7a\xdd\x06\x2a\xaa\x5c\xf9\xb2\xf1\x0e\x5b\x23\xdf\x39\xdf\xb9\xb8\xd1\xee\xfc\x82\xd2\xca\x51\x66\x6d\xfb\xb5\xdb\x27\xff\xb1\xa0\xc2\x03\x31\x6f\x7c\x12\xea\xbb\x5e\xa6\x7b\xd3\x56\x87\x76\xf9\x7e\xc9\x1a\xd0\x3e\x6f\xb6\x6f\x6c\x8b\xec\x56\xf7\x3e\xa2\xbe\x3a\x72\xb6\xd4\xbb\xef\xbd\xbf\xf0\xae\x55\x6a\x7a\xad\x0f\x9f\x98\xb8\x6e\xe8\x14\xdb\x63\xaf\x3e\x9d\xde\xb9\xbb\xef\xb5\xba\xab\x76\x75\xee\x5e\xce\xf7\xc2\x20\xed\xdf\x75\x5a\xc4\xaa\x8e\xc3\xcc\x1a\xb3\xcb\x68\xe3\x67\xc7\x19\xfb\x6c\x09\x93\xca\x52\x53\xd2\xa5\x99\xda\xe2\x35\x9a\x35\x71\x97\xae\x53\xa3\x86\x3b\x46\xd7\xa3\x4a\x37\x72\xbb\x4b\x7b\x9a\x07\x97\x5b\x9f\x2d\xc1\x1b\xfa\xc4\xd6\x5a\x9f\x9d\x14\xbb\xa1\x4f\x52\x1a\x6d\xc5\x26\x15\x24\x7c\x7d\x76\x53\x87\x38\xc7\x7a\xd4\x60\x8f\xea\xed\x51\x19\x1e\x55\xcf\xa3\x92\x3c\xea\x9c\x47\xed\xf4\xa8\xd5\x1e\xb5\xc4\xa3\x5e\xf0\x28\x87\x47\xed\xf6\xa8\xf5\x96\x8c\x5f\xa0\x9c\x47\x05\x7b\x54\xd0\xc3\x1e\x75\xbf\x47\xf5\xf1\xa8\xce\x1e\xe5\xf1\xa8\x64\x8f\x8a\xb5\xa4\xbf\xf7\xa8\xe3\x1e\xf5\x89\x47\x7d\xe0\x51\xef\x78\xd4\x02\x8f\x9a\xed\x51\x93\x3d\x2a\xdb\xa3\xda\x7b\x54\x13\x8f\xaa\xe8\x51\xa5\x18\x5b\xe4\x51\x97\x3c\xea\xa4\x47\xed\xf3\xa8\x4d\x1e\xf5\x96\x47\x3d\xe5\x51\x13\x3d\x6a\xa4\x47\xf5\xf3\xa8\xae\x1e\x55\xd5\x32\xf5\xa7\x47\x5d\xf0\xa8\x13\x1e\xb5\xdf\xa3\x3e\xb2\x34\xce\xf7\xa8\x27\x4a\xd8\x6e\xe6\x51\x35\xfc\x4a\xbd\x28\xbf\x5a\xc2\xfa\xcb\x1e\xf5\x98\x47\x8d\xf3\xa8\xa1\x96\x69\xbc\x77\x7b\x54\xb8\x47\x89\x47\xa5\xff\xe2\x51\xea\x94\x47\x69\x07\x2d\xad\x8b\x3d\x6a\xec\xd8\xb1\x03\xf8\x5f\xff\x7e\x25\x7f\xc6\xdc\xfe\x33\xb6\xe4\xcf\xdf\x4b\xf6\xbf\xed\xde\x2f\x69\x2d\x25\x15\xf8\x65\xfe\x94\x5c\x4e\x02\x53\xde\x2c\xb2\xba\xe5\xa2\xa3\x9c\x65\xb4\x84\xf8\xa4\xfa\xf5\x1a\x46\xda\xe3\xcb\xa8\xe8\xa8\xb4\xba\x0d\x1a\x36\xa8\x5f\xef\x3f\x3e\x4b\x50\x69\x5a\xfc\x0b\xaf\x55\x8a\x7d\x64\x69\xee\x33\x2f\x57\xe8\xa5\xda\x74\xb9\xa7\x5e\xef\xae\x03\x2b\x55\xd6\x6b\xff\x6d\xf7\xf5\x63\xbb\x6c\xcd\xf7\xd8\x67\xbf\xf6\x7c\x8f\x9c\xa7\xd6\xf6\x7f\xfb\xf9\xec\x4c\xf5\xc2\x8b\x13\xfe\xec\xf0\xcc\xb4\x7f\x8d\xec\xfc\xb4\x6f\xd2\x3f\x3c\x28\x4a\xb4\x56\xb4\x3a\xc6\x45\x7b\x4b\xfb\x53\x52\x4d\xea\x4a\x73\x99\xe3\x6d\x91\x1c\x17\x59\xa1\x42\xb4\xd4\x0a\xd3\xea\xd7\x4f\x4f\x4b\xb3\xdb\x25\x3d\xbd\x54\xa9\xa8\xe8\xe8\xca\xa9\x94\xa6\xd7\x23\x5e\x15\xa3\xd7\xd7\x22\x93\x6d\xd5\x83\x12\xab\x77\xcd\x76\x55\xea\x96\xed\x4a\x8c\x4b\x8c\x8a\x0a\xaa\x15\xd6\x34\xb1\x5c\xd3\x8d\xc6\x29\x6f\x70\x19\xad\x73\x50\xd3\x1e\xd9\x41\x36\x81\xaa\xe4\x0a\x1e\x48\x89\x4c\x4f\x89\x4c\x0f\xdf\x69\x32\x26\xe5\xd3\x15\x53\xd6\xa4\xea\xf6\x69\xea\x9f\xab\xc5\x4d\x9d\xd4\xb2\xe1\x89\xe6\x04\x6d\x90\x66\x52\x56\x46\x39\xab\xa8\xf2\x0d\x1a\x96\xe7\xa2\x5c\x5a\xdd\x86\x4e\x47\x42\x7c\x35\x8b\x46\x3b\xe4\x25\x55\x33\x69\x2c\xa7\xa2\xca\x37\xd7\xea\xd7\x4b\x4a\x88\x77\xd4\x51\xcb\xc2\xa2\xce\xee\x79\x6d\x55\x9f\xe5\x9f\x25\x77\xaa\xff\xf8\x90\xf7\x6b\xbd\xd0\xb3\xe3\x48\x4f\x6a\xb5\x96\xed\x57\xfe\xab\x6d\xee\xcc\xde\xfb\x8e\xaa\x2d\x9e\x49\xb5\x26\x75\x9a\x34\x30\x57\xe9\x51\xcf\x0c\x4e\x6b\xd5\x38\xf3\x3e\x35\x48\xd5\x9f\x9f\x3a\xa5\xde\x8a\x83\x4f\x3e\xd2\x67\xf6\xf8\x5e\x0f\x3d\xd3\xf6\x99\x93\x3d\x73\x4f\x67\x7a\xc3\x3f\x29\x37\xbe\x61\xad\x8a\xdb\xf4\x5a\xf1\x4b\xbe\x6a\x34\xbd\x67\xe6\xfd\xfa\x7d\xdd\xbd\x0d\x3c\x5d\xd2\xd2\x1a\x3c\x60\xce\x63\x25\xbb\xf5\xc7\x34\x97\xc9\xac\x5a\xee\x35\x78\x43\xe8\x9a\x66\xb3\x8b\xa6\x37\xb0\xab\x24\xbb\xba\x6a\x57\xe7\xec\x6a\xb7\x5d\xad\xb7\xab\xb7\xec\x6a\xbe\x5d\x3d\x61\x57\x0f\xda\xd5\x50\xbb\xea\x6d\x09\x94\x2b\x96\x39\x6a\x57\x2f\xd8\x55\x46\x71\xa7\xc3\xae\xc2\x90\x1b\x6c\x57\xbd\xec\xaa\xb5\x5d\xd5\xb3\xab\xaa\x76\x15\x65\x57\x36\xbb\xfa\xc5\x4e\xe9\xdb\xd5\x41\xbb\xda\x6a\x57\xf9\x76\xb5\xc4\x52\x3c\xd5\xae\x46\xdb\x55\x8e\x5d\x75\xb3\x2b\xaf\x5d\xa5\x16\x0f\x10\xbb\xba\xff\xb2\xdd\x1c\x70\xd8\xae\x76\x5a\x03\x16\xdf\x3e\xe0\xaf\x16\xae\xd8\xd5\x99\x12\x06\x90\x9f\x6b\x57\xd3\xed\x6a\xdc\x3f\x78\xe4\xd7\x7f\xd0\x5b\xcf\xb2\xb0\xb6\xd8\xa5\xbf\xca\xe2\x4c\xba\x16\x90\xb6\xb4\xa3\xda\x9a\x62\x03\x6e\x9f\x8d\x77\x4e\xdc\xdb\x67\xee\x5f\x26\x6f\xbf\x7e\x03\xfe\x32\x81\xfb\xdd\x3e\x5c\x3c\xfb\xcd\x99\x5b\xf2\xed\xfc\xfa\xd7\xed\x55\xb8\xf9\x4e\x36\xf3\xd8\xc1\x77\xb7\x3e\xcc\xfe\xa9\x84\x88\xdb\x5b\x86\x17\x95\xe6\x74\x96\x0a\x91\xd2\x36\xf3\xdf\x93\x78\x3c\xbc\x62\xea\xde\x7a\xb5\x4b\x44\x78\xd9\x38\x2d\x22\x5c\x12\xf5\x61\x45\x57\x9e\xf3\x5d\x9a\xaf\x82\xc4\xb0\x7f\xea\x2b\x5d\xe4\xf5\x8d\xf1\x7d\xa6\x9a\xaa\xe7\xd5\x70\xad\xff\xd7\xa2\x8c\x4e\xbe\xbb\xb5\x07\xd0\x5b\x4a\xfe\xf0\xae\xb4\x3b\x1c\x5a\x50\x50\x68\x29\x29\x6d\xe7\x2d\x18\x13\xaa\x4a\x85\xaa\xeb\xa1\xea\x42\xa8\x7a\x3f\x54\x2d\x0f\x55\x0b\x42\xd5\x9c\x50\xd5\x27\x54\x75\x0c\x55\xc9\xa1\xea\x13\xab\x7f\x78\xa8\x6a\x62\xdd\x22\x1c\x3e\x38\x54\x45\x85\x2a\x9b\xf5\x6c\x6d\xa8\x5a\x62\x3d\xae\x6a\x3d\x1b\x76\x25\x54\x9d\x09\x55\xf3\x43\xd5\x74\x4b\x41\x3d\xeb\xc1\x05\x4b\x88\xce\xa7\x43\xd5\x60\xab\x33\xf9\xef\x54\x34\xb1\x84\xa3\x2c\x45\x8d\x51\xf4\x51\xa8\xd2\x06\x94\xa0\xf9\xce\x44\xf4\xbf\xd9\xdd\xff\x2f\x02\x77\xf2\xa5\x4b\x44\x3d\xad\x5a\x5c\x24\x84\x39\xd7\x6a\xa1\xdd\xda\xa8\xe0\xd7\x7d\x57\x8a\x20\x46\x69\x87\x96\xa9\x61\x73\x7c\x5b\x7d\xb3\x7d\x4f\x15\x3d\x7b\x82\x3c\x64\x69\x4f\xea\x23\x99\x4f\x65\x24\x7c\x5d\x68\x58\xb8\x3d\x54\x0f\x64\x0e\xde\x79\x69\x97\x77\x56\x73\x56\x6b\x58\xad\x61\x79\x3d\x4d\x6b\x7e\xa1\xf5\xb5\xcd\x1b\x9f\x7d\x7e\xf3\x87\xd7\x5a\xff\x14\xf9\xa5\x6d\x54\xee\xae\x66\x47\x1e\xbe\x71\x63\xe2\x17\xcd\x76\xe5\x9a\xff\xd8\xc8\xcc\xeb\x64\x79\xdd\x36\xd5\xb6\x0a\xfe\xbb\x7b\x53\x4b\x29\x9b\x16\xcc\x6e\x52\xd3\x4a\x87\xda\xb4\x32\x7d\x9c\xf6\x32\xa9\xce\xa9\x4e\x4d\x9c\xdd\x9c\x73\x9d\x8b\x9d\xa7\x9c\xf6\x60\xdd\x69\x67\x7b\x6c\x7b\x37\x3b\xd8\xbe\x9a\x1d\x87\xb5\xdf\x08\xdf\x4d\x7d\x8e\xf1\xaf\xfd\x37\x17\x7e\x1c\x8a\x48\x88\x88\xab\x1f\xc7\x4d\x5c\xb4\xf6\x63\x81\x6f\x8c\x9a\x53\xa0\x9e\xd5\xd2\x7d\xb9\xea\xa5\x53\xea\x25\x5f\xee\x29\xcb\x07\xe3\xa2\x6f\x87\x9a\xa9\xea\x50\x5b\xf5\xd9\x4d\x06\xd9\x83\x9c\xd8\xc0\x0d\xbb\xbd\x74\x29\xbb\x63\x41\x1f\xb1\x67\x65\x67\x4d\x2d\xad\xd8\xb4\xa6\xec\xbc\xdd\x08\x2b\x23\xab\x62\x42\x73\xd5\x90\x8a\x75\x96\x51\xff\xde\xd4\xe5\xbe\x32\xd3\x9a\xa8\xb8\x94\xf2\xbd\x7d\x3b\xba\xbc\xd5\x5e\xd5\xf9\x69\xc2\x06\xe2\x6c\xa4\x5e\xd6\x46\x69\xb3\x59\xe1\xa3\xbd\xc1\xc2\x1a\xa4\x64\x53\xb6\x92\x14\xff\xfb\x0a\x1d\x0d\xe3\x9c\x8d\x52\xb4\xa0\x14\xf5\xf2\x95\x2b\xc8\xd7\xc6\x31\xd3\x27\x5d\x2a\x78\x4b\x13\xb0\xa8\x85\x7d\x24\x12\x3f\xd8\x38\x27\xfb\xf9\x4e\x63\xbf\x58\x1b\x53\x4d\x54\x1d\xf3\x3f\xa9\xa4\x8c\xb5\xc6\x97\xda\x25\xbb\xf9\xc9\x7b\x25\x6f\x29\xf6\xc2\x76\x9d\x03\x86\x48\xb9\x40\xc2\xfd\xa4\x38\x55\x9a\xea\xa4\x75\xfc\xb1\x68\x53\x0d\xfb\x6f\xd7\x4a\x99\x7b\xdd\x4c\xe3\xa2\x6d\x80\xfd\x05\x09\x95\x4a\x52\xdd\x1b\x55\x31\x38\x52\x0b\xd6\x62\x2a\x3b\xca\xe4\x65\x3b\x2a\x4a\x54\x5e\x36\xfb\x6c\xeb\x0d\x7b\xeb\xe5\x0a\xb9\xee\x88\x28\xa7\x16\x67\xbe\x33\x2b\xa9\x06\x6c\xcf\x22\xeb\xd7\x4b\xe0\xd5\xa9\x45\x47\x69\x87\xd5\xd3\x49\x73\x7d\xf5\xf7\x6e\xcb\x7e\xf5\x7c\xab\xf1\xb3\xfb\xbc\xd4\x7b\x78\xc7\xd6\xf6\x17\x7c\xb5\xf3\x36\x16\xf5\xbc\xf0\xd3\xd3\xea\x15\x55\x69\xde\xf5\xb4\x2f\xd5\xb7\x3d\xbf\xef\x7f\xc8\x77\x5f\xcf\xa3\x56\x2d\xc4\xb1\xe7\xb6\x53\x5b\x66\x1e\x2a\x39\x75\x3d\x48\xd3\x4a\x95\xd6\x35\x36\xf7\x5c\x29\x51\x38\x52\x61\xea\x34\x3f\x03\x6c\x2b\xd3\x2a\x98\x3b\xeb\x12\xab\x46\x5a\xc3\xb8\xb2\xf6\x86\x89\xec\x98\x9d\x71\xc9\xaa\xdf\x1a\xdf\xbf\x52\xd4\x2c\x55\xe6\x9c\x6a\x55\xb3\x50\x7f\xf9\xe8\x2f\x67\xaf\x0f\x2d\x34\x79\x22\xed\xb6\xfe\xc4\x5b\x45\x9a\x78\x63\x63\x83\xa3\xa3\x5d\xee\x32\x61\x61\x95\x45\x5c\xc1\xd1\x95\x23\x23\x4b\xe5\x65\x47\x3a\xa5\xb2\x69\xed\x66\xd8\xbc\x74\x6f\x6e\x63\xad\x89\x53\x27\x35\xa1\x61\x73\xad\xa1\xf9\x6e\xe3\xd5\xe6\x4c\x6c\x50\xb5\xf8\x9d\xc8\x9f\x38\xa7\x3b\xb1\xce\xd4\x17\xd7\xcd\x1f\xd1\xe4\x8d\xac\x11\x31\xbe\xab\xf5\x95\xec\xfd\xfc\x44\xaf\x77\x3e\x98\xbe\xa8\xa6\xf6\x4c\xcd\x1d\x99\xcf\x4c\x9b\x92\x3b\x62\x74\xf3\x39\x59\x39\x4d\xd6\x2c\x7b\x6f\x45\xce\xca\x37\x1f\xbd\x67\x46\xcb\x42\xff\x9c\x08\x27\x1f\x7d\xf1\xaf\x1a\xa7\xab\xea\x41\xc1\xc1\xb1\x95\x23\x92\xa2\x93\x12\x2a\x27\x44\x47\xeb\x65\x2a\x97\xa9\x5e\xa3\x5a\x52\x5e\x76\xb5\x6a\xee\x52\x15\xdd\x79\xd9\x15\x2b\x96\x72\xe4\x65\x97\x72\x96\x70\xb5\x42\x4a\x71\xa2\x02\xee\xde\x5a\x1a\xeb\x36\xb0\xde\xc5\xce\xc4\xc8\x38\xd3\x5d\x47\x98\xaa\xa2\x4c\xaf\x13\xcc\xed\x77\x15\x8a\x84\xe7\xc9\xaa\xa1\x56\xfe\xf9\xe7\x3a\x77\xdb\x9c\xe6\xfb\x6d\xa8\x5a\xf4\xc9\x99\xed\x4b\xd5\x93\xb3\x1f\xbb\xf8\x72\x41\x51\xb8\xaa\x54\x2a\x77\x54\xee\xf8\x6f\x86\xd7\xd4\x9b\x8d\x1b\xd6\xae\xe7\xc6\x7a\x6a\xf0\xfa\x37\x16\x7e\x18\x66\x8b\x5e\x34\x79\xd2\x27\xa3\x36\xaf\x4a\xba\x27\x73\xf4\xa0\xcd\xa7\x45\x33\xbe\x85\xe7\x6e\x56\x3e\x23\xa4\xb7\x37\x39\x4c\xd7\x1c\xa5\x4a\x05\x89\x53\x39\xcb\x46\x52\x9e\x65\xcb\xd8\x6d\xb6\x48\xd1\xc3\xf4\x71\xd9\x41\xf6\xb0\x30\x55\x8a\x4c\x6b\x2a\x90\x62\x8e\x4d\x64\x37\xc5\x7f\x50\x2a\x71\x84\xb0\xc2\xe1\xec\x90\xe6\xdf\xd7\x71\x3a\x8a\x6b\xa8\xe2\xf4\x34\xa7\x72\x38\x55\x5c\xd9\x06\xfa\xb0\x06\xbe\x2b\x0d\x8a\xa6\xd6\xd0\xf6\xab\xb1\xab\xb7\xdc\xe5\xbb\x56\xbb\xad\x2f\x4b\x3d\x3e\x34\x52\x55\xf1\x15\xa8\x2a\x07\xf4\xf9\x37\x46\x7d\xae\xbf\xd4\xa5\x6f\xd1\x19\xad\xf4\x3d\x26\xdf\x51\xf0\xfd\x34\x7e\xba\xa5\x8d\x37\xc1\x65\x73\xbb\xa3\xca\x96\x8d\x8b\xaf\x54\xba\xb4\x52\xf1\x41\xb1\x79\xd9\x41\x41\xe5\x25\xbc\x7c\x5e\x76\x78\x45\xd1\xa9\x0a\xc7\x1d\x54\xab\xdb\x8e\x96\x26\xcb\xd4\x9f\xde\x5c\xb7\x0a\xc2\x61\x2b\x49\xad\x49\x7d\x9c\x6a\xaa\x77\x4d\x2e\x5a\x79\x77\x64\x9d\xe6\x5d\x52\x97\x7e\x32\xdb\xf7\xc7\xbb\x7b\x7e\xaa\xac\x62\x22\x07\xf4\x9f\x3c\xe7\xde\x7b\x26\x76\xf5\xfd\x68\x9f\x56\xe8\x5b\x1d\xee\xae\x14\x5e\xf0\xe1\xeb\xbf\x4d\x5f\xb5\xa2\x56\xbf\x8e\x2f\x3f\x7a\xff\xb8\x3e\xfe\xf3\xef\x00\xfc\x9d\x42\x7d\x54\xa2\x42\x32\xbd\xb5\xe3\xca\x97\x2f\x15\x12\x52\x23\x22\x86\x63\x49\xf5\x1a\x51\x55\xc7\x51\x0d\xde\x28\x15\x16\xe5\x8a\xd2\xca\xe9\x51\x51\xe2\x74\x32\x93\x9d\x4e\xa9\x82\xf3\x15\x6f\x73\xde\x7c\xad\x47\xa6\x07\x96\xb4\x9b\x5b\xbf\x3a\xa9\xf6\x78\xad\x7e\x78\xa4\x59\xd2\xd6\x19\x8c\x02\xe7\x4c\x66\x86\xa3\x39\x38\x85\x15\x87\x62\x4e\xf6\xcf\xcf\x2c\x55\xc9\x1b\xd7\x1e\x88\xf4\x5d\x2d\xd3\xa1\x65\xde\xb2\x6a\xf5\xdf\xbc\x6f\xc9\x07\xb3\xfe\xf4\x6d\x1d\xd4\x67\xf8\xa3\x03\x7a\xb6\x1a\x8b\x2b\x21\x3f\xab\x50\xb5\xe6\xa7\xa5\x8b\x6a\xb4\xcf\x38\x77\xbe\x5d\xf6\xde\x95\x2f\x1a\xf2\xac\xda\x76\xff\xa4\x37\x67\x0c\xcc\x6d\x3d\x89\x1c\xcc\xa1\x56\x76\x90\x83\x50\x49\xf1\x96\x73\x38\x9d\xa1\x2a\xb4\x4c\x18\x09\x08\x73\x54\xd0\x42\x25\x34\x40\xbb\xb9\xd8\x7b\xfc\x84\x07\xca\x9a\x95\x33\x2e\x4c\x89\xe6\x8c\x6b\x50\x49\x6b\x18\xb7\xc5\xe6\xac\xf9\x86\xaf\xe8\x5c\x3d\xdf\xd1\x84\xa7\xde\x2f\x9c\x56\x14\x69\x9f\x76\x72\xbb\xef\x33\x5f\x97\x1b\xeb\x59\xf8\x2a\xa8\x52\xcf\x58\xff\xcc\x52\x62\xe0\x70\xb4\xfd\x79\xf8\xa8\x2a\xa9\xd2\xcb\x7b\x57\x7c\xf9\xf2\x65\x1d\x21\xd5\xc3\xc3\xeb\xd6\xa9\x1d\x12\x12\xab\xeb\x75\xa3\x1c\x89\x95\x2a\x25\x8e\xcf\xae\x54\x29\x59\x42\x93\xc7\x67\x87\x56\x14\xd7\xf8\x92\x6b\x61\x60\xa6\xdd\xb9\x36\x50\x98\x81\xc9\x76\x6b\x86\xd9\xac\x85\xb2\x41\xc3\xfa\xe6\xf6\xb9\x6a\x59\x93\x40\x58\x65\x7f\xec\xb4\x7e\xfb\x19\xd5\x76\xec\x39\xb7\x7c\x9e\x1a\xf5\x90\xef\x4b\x5f\xd1\xb7\x57\x3e\x58\xd6\x77\x80\x8a\x7c\xaf\xff\xc8\x15\x03\x46\xdc\x63\x1f\x37\x75\x78\xce\x88\xe9\xc3\xec\xcf\x6f\x58\x30\x6b\x0b\xfa\xde\x18\x7d\xf0\xca\xbe\x35\xcf\xed\x8c\xb7\xd5\x78\x7d\xe4\xaa\xbd\x45\x6b\x1e\xba\xff\xed\x51\x43\xee\xee\xb7\xf7\x99\x87\x07\xe4\xce\x7d\x64\xc0\x10\x7f\xad\xa4\x12\xe7\x30\x6a\xa5\xa2\x24\x4a\x67\x6f\x75\xb7\xc3\x51\x2e\x3a\x3a\xa9\x9a\x54\xaa\x14\x1a\x5a\x4d\x4f\x18\x97\x5d\x2e\x4c\x57\x2e\x5d\xd7\x23\x43\x22\x2b\xb0\xf0\x55\x0c\xa1\xe0\x43\x9c\x77\x56\x49\xfa\x9d\x65\x4e\x78\xd6\xaa\x61\x9d\xd6\xeb\x46\x46\x47\x85\x28\x47\x82\xff\x0c\x5f\xb7\xac\xb5\xdd\xf7\x87\xa5\xd7\x69\x31\x3f\xf7\xf5\xad\xcf\x5c\x7f\x69\xef\x8f\x03\x57\x5e\x9c\xbb\xfe\xdb\x18\x15\x19\xfb\xdc\xf7\x93\x06\x77\x1e\x3b\x3d\xa7\xe7\xd8\xc7\xb4\xd9\x9d\xdb\x1f\xcd\x7f\xfe\xcf\xa7\x7d\xc6\xb1\x15\xbe\x47\x7d\xdf\xcf\x5e\xf1\x5a\xea\x22\xbd\xda\xdd\x63\xdf\x7e\x26\xf3\xfe\xc5\x66\x0c\xd9\xfc\x6a\x69\x0b\xb1\x3e\xef\x49\xf5\x56\xe2\x95\xe6\xb0\xd9\x82\x82\x6d\xf6\x85\x7d\x6c\x91\x4a\x16\xf6\x51\x61\xe6\x0b\x3a\xd8\x7c\x41\xdf\x7a\x4f\x05\xdc\x8c\x61\x71\x30\x3f\x50\xba\xd0\x50\xb9\x1b\xfa\xba\x98\xbf\xb5\xcb\xaa\x92\xef\x1c\x6b\x59\x45\x5f\xa1\xa9\xbf\xbc\x6f\x47\x40\x7f\x19\x69\xe6\x75\x95\x2e\x55\x0a\xdd\xf6\x60\xec\x84\x04\x07\x87\x85\x07\x87\x2c\xe8\x63\x0f\xbe\x69\xc7\x6f\x23\x65\xf7\x1d\x1b\x81\x5b\xc6\x6e\xed\x06\xfc\x36\x77\x6e\x34\xf7\x04\x5c\xde\x55\x3e\xd3\x6f\xfa\xfa\x17\xe6\xce\xa0\xe2\x97\x13\xd6\x5b\xeb\xfd\x24\x99\x6c\x7b\xd4\xb6\x9f\x0a\x4f\xf7\xc6\x6a\x0e\x1b\x17\x41\x4e\x25\x36\x9b\x66\xf7\x38\x94\x43\x1f\xa0\x29\xb7\xa6\xc2\xd8\x8e\x49\x0a\x5b\xb9\xb4\x94\x7e\xd4\x58\xb3\x14\xeb\xe3\xa3\xe2\xd7\x71\xd9\x08\x15\x1d\xac\xa2\x27\xd9\xf4\x1b\x1f\xe9\x2d\x34\x9b\x6a\xa9\x9e\x3c\xe3\x7b\xdf\xb7\xe5\xb4\xbf\x0e\x26\xaa\x04\xdb\x14\x5b\x0d\x8b\xc3\x1e\xde\x86\x4e\x24\x34\x15\x1c\x64\xb3\xbf\x9b\x7d\xd2\xa6\xc2\x6c\x2e\x9b\xc7\x36\xc7\x66\x0b\xd6\x6d\x6c\x00\xda\xd9\x94\xbc\x9b\x9d\xaa\x46\x2b\xcd\xad\xbc\x2a\x87\x8b\xc5\x6a\xab\x72\xb0\x5f\x61\x9b\x45\xf0\xc9\xd6\x7e\xab\xa4\xf9\xfa\x71\xd1\x0a\x4c\xb4\xe9\xd7\x8b\x6c\xba\xde\xe1\xe4\xc9\xa2\xe3\x27\x4e\xc8\x1d\xf1\x35\xf4\x56\xb6\x89\xe6\x10\x87\x33\xc8\x61\xd7\x34\x7d\x80\x4d\xb9\x4d\xeb\xca\x66\xfe\x47\x38\x04\xf5\x75\xad\x08\xef\x8c\xae\x61\xfd\x60\x55\x5f\x45\x4c\xd2\xbd\x37\xb6\xda\xf4\xc9\xa7\x55\x6b\xd5\xe6\x8c\xef\x61\xdf\x87\x56\x6c\x1b\x59\x3b\x36\x51\xe3\x95\x59\xc1\x7b\x79\x6b\x55\x8a\x29\x55\xba\xb4\x2b\x36\x36\x3a\x26\x5a\x8f\xd1\xe3\xe2\x23\x9c\x95\x74\x29\x5d\xc5\x1b\x5b\x65\x51\x9f\xd8\x48\xa9\x30\x20\x5b\x6c\xe4\xd1\x1d\xaf\xf8\x63\xc6\xe3\xaf\x19\xff\x87\x91\xe5\xd3\x8b\xcd\x46\x16\x27\x37\x30\x93\xcd\x57\x3b\xcb\x8c\xf9\xd2\xd7\x8b\x5f\xa2\x66\xbe\xb5\xef\x8f\x5e\xeb\xf8\xff\x50\xf6\x1f\x80\x51\x55\xe9\xff\x38\x7c\x9e\x5b\xe7\x4e\xef\x35\x99\x92\x49\x66\x52\x49\xc8\xa4\x10\x5a\x46\xe9\x35\x09\xd5\x11\x43\x00\x15\x05\x54\x8a\x10\xa4\x28\xa0\x54\x51\x51\x50\xc4\x42\x11\x3b\x28\xb0\x2c\xba\x41\x45\xb0\xae\x75\xc1\x55\x57\x57\x5d\x71\x15\x0b\x6b\x63\x77\xd5\x5d\x85\xdc\xbc\xe7\x9c\x5b\x66\x02\xec\xf7\xf7\xfe\x97\x05\x27\x93\x53\x9e\x7b\xce\x73\x9e\xf3\x79\xea\x5d\xbb\x75\x74\x43\x81\x20\xff\x6c\xed\x3f\xb5\x7d\xd0\xa4\x3a\xef\x94\xcb\xbf\xa8\x91\x7f\x59\x60\xa8\x81\x58\x0d\xbf\xf9\xb9\x47\x2f\xbe\x6d\xd1\xc4\x54\x5d\xff\xd2\x51\xd7\xb6\x0e\x2b\xbb\xb0\x5f\xff\x64\xe3\xd8\x17\x8a\xe1\x86\xdf\x66\x2a\x56\x4d\x06\x6d\x96\x3f\x12\x17\x62\xec\x96\x46\x4d\xe8\xaf\xe9\x75\x65\xd5\x68\xa8\x3d\x90\x97\x77\x81\xdf\x27\xd9\xa5\x86\x78\x1c\x35\xa0\xe6\x96\xc8\x08\xcb\x88\x0f\x32\x9c\xc5\x3d\xf0\x83\x8c\xdf\x6d\xc7\x32\xde\x12\xb1\x30\x26\xd6\xe2\xb6\xb8\x6b\xfb\xf5\x4b\x7e\x90\xe9\x87\x6a\x2b\x3f\xc8\xa0\x5a\x7b\xed\x9c\xda\xe5\xb5\x5c\x6d\x65\x0b\x44\x5a\xe0\xc7\x16\x38\xde\x02\x47\x5b\x20\xdd\x02\x55\x2d\x10\x6d\x01\x7b\x0b\xa0\x16\x90\xf6\xb5\xc0\x8e\x16\xb8\xbd\x05\x96\xb5\xc0\xec\x16\x68\x6b\x81\xa6\x16\x68\x6c\x01\xa5\x9b\xad\x05\x06\xe7\x6a\x18\xfa\x67\xac\x43\x54\xb6\x66\x91\x91\xbf\x92\x5e\x24\xf6\x97\x89\x7c\xa6\xd7\xb5\xbe\x84\xd4\x6e\xa0\x1c\x8f\x86\x6a\x62\xeb\x63\x04\xc5\xcc\x12\x57\xa5\x87\xb3\x2e\x55\xed\x4b\xd5\xa7\x58\x45\x5e\xf4\xc7\xe2\x91\x29\x8c\x17\x70\x18\x46\x3a\xb9\x54\xb4\xc8\x47\x2e\xd0\x42\x7a\x1b\xc5\xaa\x39\x27\xaf\xdc\x3b\x4a\x5b\x46\x5c\xb8\xec\xb3\x1b\x2f\xb9\x54\x10\xaa\x5f\xb9\x62\xeb\x93\x2b\xbe\xbc\xed\xa5\x41\x42\xf2\xfe\x05\x45\x95\x91\xe6\x8d\xe3\xef\x91\x3f\x3b\x7c\x4a\xde\xf8\xce\x76\x88\xbe\x08\x09\x48\xf6\x7f\x4c\x3e\xfc\xf8\x77\xf2\x3d\xaf\x77\xc2\xf3\xe0\xfe\x37\x5c\xf6\x6c\xe7\xa2\x85\x93\x27\xdf\x35\x76\xea\x65\x17\x5e\x3f\xad\x96\xf9\xf7\xd3\xf2\x7b\x8f\x4f\x6a\x29\x0a\xcf\x58\xfd\xe6\xd3\x0f\x42\xf8\xc1\x3d\x5b\x64\xe1\x89\x81\xd5\xa5\xeb\x4f\xde\xb2\x17\x2c\x1b\xff\x2c\xcf\xff\xe5\x25\xf9\xaf\x77\xdf\xb7\xb8\x6d\xcc\x61\x98\x71\x12\x42\xf0\xc6\x99\xa7\xe4\xa7\x3f\x6d\xbb\xee\xfa\x2f\x17\xcd\x5b\x39\x6e\xfb\x9b\x18\xf3\x60\x24\xcb\xa7\xf0\x3d\x26\x62\x59\x32\x33\xdd\xcf\xc4\xb0\x02\x6f\xc6\xea\x27\x12\x0d\xa2\x9d\xe5\x38\x1b\x30\x26\xa6\x2d\x83\x65\x8c\x81\x67\x59\x0e\x39\xd3\x76\x98\x63\x07\xfc\x6f\xd4\x4e\x8a\xac\x9c\xb2\xc3\x31\x3b\x1c\xb6\x43\x93\x1d\x34\xbd\x0d\x6b\x6c\xd5\x95\x8d\x29\x0c\x86\x74\x2c\xe4\xd4\xd6\xb7\xba\xda\x41\x70\x10\xc6\xbc\x6c\x0c\xc3\x1f\x0c\x82\xf0\xa7\x04\x67\xab\xef\xfc\xfa\x25\xf9\x23\xd6\x05\x97\xfc\x20\x37\x78\x46\x61\x44\x3e\xc0\x09\x57\xca\x5b\xf8\x15\xbf\x2d\xe3\x1e\x4b\xdf\x29\xcf\x83\x97\xd7\x60\x69\x50\x88\xe9\x5d\x42\xf5\x39\x1f\x3e\x3d\x8b\xd2\x43\x6c\x51\x9f\xdf\x6f\xf5\x21\x64\xcd\x33\xba\x38\xce\x28\x5a\xf1\xdd\x25\x46\x6d\xb6\x68\x5b\xc6\x66\xf3\x23\x2b\x3e\x3f\x56\x27\xf2\xe1\x53\x44\x6c\xfc\x69\x7a\x8a\x4e\x15\xc0\xb1\x02\x38\x52\x00\x3b\x0a\x60\x4e\x01\x54\x15\xa8\x66\xfe\xb9\xf3\xca\xce\xbd\x2d\xa9\xd1\x3b\x2b\x35\x55\x03\x1d\xde\x5d\x7c\x5b\x8a\xf4\xb2\x2c\x01\xfc\x23\xc5\x18\xf8\xa9\xd4\x0f\x50\xc7\x0c\x3d\x0d\xcc\xc3\xdb\xd7\xde\x23\xff\x51\x7e\xb5\xb3\x11\xde\x80\xc4\xde\x4d\xf3\x56\xcb\xef\x3e\x07\x43\xdf\xd9\xb9\xf6\x5e\xf9\x69\x7e\xc5\xc3\x0f\xac\xdb\x1b\xf3\x3d\xbc\xf0\xdd\x4f\xd8\x61\x97\xcc\x68\x1e\x7a\xa6\xf6\xf2\x05\x17\x4f\xc1\xa2\xe5\xb2\xae\xef\xf8\xe3\xf4\x1e\x1c\x91\x2e\xc3\x7a\x3e\x86\x78\xc8\x6c\x0e\x05\xa7\x84\x00\x85\xd2\xa1\x29\xa1\x39\xa1\xe5\x21\xde\xc7\xba\x79\xbb\xc1\x8e\x1f\xce\xce\x19\xd8\xb6\x8c\xc1\x95\xab\x01\x10\x1b\xd9\x5c\x2a\x17\xaa\xb5\x3b\x10\xf3\x61\xd4\xe5\xc3\x6a\x10\x66\xd1\x1a\x02\x98\x38\x05\x30\x21\xb8\x63\xf7\x76\x30\x6e\xf9\xe2\xcf\x72\xc3\x61\xf9\xdb\x0d\x7f\x86\x45\xa7\xbe\x82\x64\x4a\xfe\x21\xff\xa1\xf6\x7f\xc9\xdf\x33\xfd\x9e\x3c\x04\xcc\x02\xf9\x96\xdb\xc1\xb4\xff\x0c\xdc\xfa\xde\x2b\x2f\x0d\x99\xb5\x54\xde\x47\xe5\x19\xd9\x93\x5b\xf1\x9e\x48\xc8\x85\xfa\xa7\xe3\x2e\x49\x32\x1a\x6c\xac\x81\x75\x7b\x24\x57\x5b\x46\x62\x0d\x46\x4c\x99\x93\x2c\xbe\x07\xa2\x1e\x38\xec\x81\x6e\x0b\xdd\xcd\x9d\x12\x45\x0e\x37\xc3\xe1\xe5\x73\xa5\xa8\x8a\x96\x28\x03\xe6\x53\x18\x05\xd3\x5e\x95\xd7\x9e\xec\x7c\x1e\x9c\x17\x7c\xb5\xe3\x3f\xab\xde\x7d\x75\x1f\xbf\x42\x7e\x43\xfe\xe4\x3b\x79\xf3\x3b\xfc\x8a\xd3\x97\xae\x03\x66\xf7\xa1\x57\xf1\xba\x11\x5a\xd6\x61\x5a\x4c\xe8\x9a\x74\x7f\xc1\x68\x44\x0c\x63\xe1\x0d\x9c\x24\x21\x8e\xd4\x10\xb1\x98\x79\x43\x5b\x86\x8f\xf9\x86\xdd\xcb\xc3\x3a\x1e\xfa\xf2\xc0\xda\x78\x30\xf3\x3c\xd1\xa0\xb9\xb6\x0c\xb0\x48\xc2\xac\x42\xa8\x2d\x3b\x1b\x54\xb4\x11\x3f\x50\x2e\xf8\x74\xea\x82\x17\x2b\x73\x14\x45\x2b\x7f\x0b\xc1\xc1\x8d\x2b\x3f\xf3\xee\x20\xe6\x54\x79\xa7\x7d\x28\x3b\xa1\x82\x5f\x71\x42\xde\x76\x42\xbe\x95\x94\xba\xa0\x34\xda\xe8\x7a\x5d\x9c\x4e\x31\x06\x83\x09\x48\x1d\x4d\xac\xc4\x0b\x82\xd1\x44\x88\xb0\x01\x98\x58\x48\x5b\x7b\x0e\x05\xe0\x31\x10\x6e\xcb\x88\x2c\x4f\x48\x8a\x9a\xa0\xd9\xa4\xdc\x01\x3a\x8b\x62\xc2\x72\xae\x76\xa7\xae\xef\x2a\xb4\x60\xaa\x98\xaa\xf1\xcc\xfd\xe5\x9d\x97\x5d\x2e\x7f\x04\x0e\xf6\xa3\x72\x6e\xab\x3c\xf2\x44\xe7\x69\x4c\x12\xe5\xb3\xef\xf9\xdf\x30\x9f\x45\x30\x32\x2f\x0f\x06\x9c\x4e\xd6\x9f\x9f\x8f\x05\xb9\xc9\xc8\x1a\xa3\xb1\xbc\xc0\xd4\x4c\x3e\x32\x89\x79\x79\x04\x94\x63\x32\x38\xe4\xc1\xab\xe3\x3a\x67\x75\x9c\x0d\x2a\x2c\x57\x95\x0a\xdd\xd6\xc0\xe3\x0d\xcd\x65\x34\x81\x51\x70\x56\x23\xc4\xea\x63\xac\xc0\x31\x27\xe4\xf7\xe4\x27\xde\x81\x65\xbf\x9d\x80\x54\xad\xfc\x55\xfe\x23\xcb\xb6\x9f\x5a\x7e\x78\xcf\x55\x6f\x0d\xed\x21\xef\x4a\x32\xd3\x67\xdc\x2f\xbf\xe6\x82\x7e\x90\xff\x1b\xac\x7c\xe7\x4f\x07\x47\xcf\x5d\xba\x59\xfe\xee\xc0\xfe\x37\x6b\xca\x4f\x1c\xeb\x7c\x6d\xd6\x44\x75\x3d\xff\x41\xf7\xfc\xea\x74\x5f\x30\x48\x26\x84\x30\x0b\x32\x22\x2b\x08\x3c\x8f\x65\x98\xd9\x68\xb4\x00\x23\x32\x53\x32\x06\x31\xe6\x19\xd6\x5b\x7c\x46\x64\x44\x51\xc2\xcb\xad\x88\x34\xc2\x99\x16\x68\xb6\x40\x2b\xe1\x4a\x22\xba\x2a\x1d\x58\x7a\xb5\x96\xe9\xf2\xcb\xd9\x7d\x75\x55\x65\x0e\xab\x72\x64\x81\x89\x4a\x07\xec\x73\xed\x9d\xb7\xb5\x93\x15\x86\xe4\xd5\xcc\xbc\xab\x21\x4f\xfe\x81\xb9\xa4\xf3\x21\x7e\x45\xe7\x51\xa6\xe7\x6f\xcb\xd4\x7d\x67\x2e\xa1\x56\xf3\x1d\xe9\x39\x88\xc3\xac\x47\xe7\x1e\xa7\x19\x34\x11\x0f\xdd\x8c\x99\xba\xa9\x74\x0e\x0f\x6d\x3c\x44\xe8\xf7\xca\x97\x53\x78\x68\xe4\x21\xca\x83\x9d\x76\xb3\xe8\x4d\x15\x2b\xac\x62\xb0\x55\x7e\xd7\x77\x9f\x6a\x16\xcd\xda\x38\xcf\x63\xd3\x6c\x23\x56\x38\xc2\x56\xaa\xad\x06\x62\x50\x48\x9e\x85\xe8\x76\x84\x7a\x42\x7f\x00\x63\xf3\xcd\x98\x7e\x07\x46\xe6\x25\x36\xa3\x11\x5f\x0a\x56\x2b\x06\x4f\x2e\x27\x72\xdd\xee\x62\xcc\xac\x0d\x59\x8d\x82\xc9\x6a\xc2\x12\x97\x45\xc2\x79\x18\x05\x2f\xa0\x6a\xb8\x77\x28\xf6\x1d\x55\x7b\x53\x70\x38\xc6\xa1\x2e\xc2\x15\x56\x80\xcf\x9e\xff\x22\x01\xa6\x1e\x0f\xd4\x0d\xaf\x72\x6e\x90\xbf\x2e\x67\x1a\x5f\xa8\x38\xe5\x3e\x72\xb4\xf7\xe7\x55\x17\xb5\x32\x9f\x7f\x7d\x26\xf1\xf5\x7b\x48\x5d\x53\x61\x00\xdd\xfb\xf6\x74\x31\x32\x99\x8c\xc0\x18\x24\xc9\x92\xb3\xf9\x16\xbc\xb7\xc8\x12\xb5\x2c\xb7\xb0\xcd\x96\x63\x96\xcf\x2c\xac\xd8\xd1\x75\x2a\x1d\x74\x05\x86\xae\xc4\xaa\x3d\x30\x2c\xc7\x4b\xdd\x98\x21\xcb\x04\x95\xc4\xe5\xd7\x5a\x46\xe4\xd5\xd9\x3c\xa0\x69\x4d\x31\x10\x29\x13\x40\x4c\x02\xf6\x0b\x79\xeb\xbb\x97\xcb\x9f\x90\x85\xbb\x91\xf9\x2f\xcc\xed\xf4\xc0\x3b\xcc\xf2\x25\xe4\xb0\x75\xae\x60\x96\x75\x6e\x39\xf3\xb5\x42\x33\x37\x0b\xd3\xcc\xa3\x9e\x58\x3b\x00\x20\x75\x74\x45\x01\xff\x87\x55\x25\x4f\x54\x84\x66\x31\x0b\xf5\xb2\xe7\x8a\x6e\x8c\x22\x60\x20\xf9\x25\xf3\x53\x05\x91\x7d\x9a\x4c\x11\xfe\x84\xc7\xf4\xc3\xfe\x74\x17\xf2\xfb\x0d\xa2\xcb\xe5\xb3\x79\x59\xd6\xe7\x0b\x3a\x4c\x76\xbb\xd5\x66\x0b\x04\x31\xf2\x02\x17\x6f\xf3\x79\x1d\x76\xd6\x66\x35\xd0\xb9\xee\x09\xc2\xfc\x20\xcc\x08\xc2\x84\x20\x0c\x0e\x42\x49\x10\x7e\x09\xc2\x57\x41\xf8\x4b\x10\x5e\x0f\xc2\xc1\x20\xec\x0e\xc2\x7d\x41\x68\x0f\xc2\xf4\x20\x0c\x0b\x42\x1f\xfa\xfd\xb3\x41\xc0\x1d\xd7\xd1\x2f\x33\xda\xf7\xb8\xaf\x10\x04\xc3\x65\xda\x58\x35\x41\x48\x04\xc1\x1b\x84\x9f\x82\x70\x82\x8e\x78\x20\x08\x8f\x04\x61\x25\x9d\x72\x3a\x6d\x36\x30\x08\x75\x41\x08\x04\x81\xc3\x44\xfc\x44\x67\x7e\x35\x08\x8f\x07\x61\x23\x6d\xd7\x4e\x1b\x15\x04\xc1\x4d\xc7\x3e\x49\x47\xc1\x0d\xf6\x07\xe1\xa1\x20\x6c\xd6\x08\xd7\x67\xfa\x95\x8c\x90\xee\x01\x2f\x6b\x73\x61\x12\x17\x05\x61\x4c\x10\x20\x1d\x04\xa6\x2a\x08\x91\x20\xd8\x82\xd0\x70\x2a\x08\xc7\x82\x70\x24\x08\x7b\x83\xa0\x19\xa0\xdb\xa8\x84\x3f\xdb\xd8\xff\xff\x70\xf1\x4d\x3e\xaf\x93\x41\x69\x4f\x18\xa9\xba\xba\x31\x45\xdd\xc7\xba\x8c\xee\xe6\xdb\xaf\xa6\x3c\xe4\xaa\xab\x17\x05\x11\xe2\x2c\x93\x14\x28\x3b\x85\xa0\x3f\xc6\x14\xc0\x3d\xfd\x44\xb0\x6a\x50\x53\x5c\xbe\xec\xcf\x93\x23\x52\x9e\xed\x09\xf9\x37\x70\xc2\xfa\x8b\x02\x85\xfd\xe1\x77\xb0\x4e\xfe\x81\x9d\x7f\xe3\x91\xbb\xf7\x5c\x70\xe6\x18\x9b\x82\xf8\x94\x9f\x46\x9c\xc1\x77\xdf\x99\xef\xe4\xef\x9a\x6f\x64\x27\xe0\x63\x9b\x95\x8d\x56\x34\x36\x5d\x61\x40\x56\xab\xd9\x62\xb1\x8b\x20\x08\x58\x63\xb4\xd9\x81\x35\x61\x95\xca\x62\x16\x05\x96\xb7\xaa\x92\xd0\x0e\xcb\xed\xd0\x6c\x57\xef\xe8\xff\x45\xbf\x62\x39\x8a\x81\x42\x2e\xd4\xd7\xd5\x13\x21\x38\x5f\xbe\xd9\x67\xdb\x43\x89\x9c\x0c\x8b\xcc\x26\xe7\x1e\x10\xe4\x1f\xb8\x59\x3b\x47\x9d\x59\x89\x59\x75\xfd\x98\xb1\x93\xd8\x05\x98\x2e\x86\xe0\x1b\xc1\x87\xef\x1d\x2b\xd6\x82\x6a\xd2\xf9\x41\xd6\x65\x62\x4d\xe1\x7c\xd1\x8b\x2f\x19\x17\xb2\x11\x9d\x67\x47\x18\xa6\x84\x21\x1d\x06\xbc\x9e\xe7\xb3\xe7\x2a\x48\x41\x45\x32\x3e\xfd\x66\x21\xa0\x81\xdd\x01\x45\x30\xe6\x5d\x79\xf5\xbf\x5f\x90\xbf\xb8\xeb\x5d\x68\xff\x72\xe7\x89\xa5\x07\x1e\x78\xe0\xc4\xf5\x7b\xf9\xcd\xf2\xeb\xf2\x4f\xff\x91\x67\xfc\xf5\x76\xb0\x1c\xf8\x16\xee\xfe\xe0\xe4\x66\xf9\xcf\x0f\x75\x1c\xdc\x0c\xc5\x8f\xef\x7b\x51\xc3\x33\x19\x6a\x07\x74\xa1\x91\xe9\x12\x93\xe8\x32\xb8\x8c\x46\x2c\x56\xdc\x1e\x1b\xcb\x7a\x4c\x62\x5b\x06\xc3\x61\xa3\x11\x83\x1b\x23\xab\x01\x9b\x4a\x8c\x6a\x5a\x73\xef\x65\xdd\xec\x93\xca\xf1\xea\x62\xcc\x88\x4a\xf0\xd5\x8c\x35\x7c\x0d\x30\x8e\xf9\x05\x1c\xf2\xdb\x72\x97\xbc\x66\x1a\xb9\x3e\x76\x42\xec\xbe\xfb\x96\x5f\x27\xff\xc6\xaf\xf8\xec\xd5\xbf\xcb\xbf\xc8\x76\x2c\x3b\xc6\xcc\x5f\x39\x7d\x16\xc5\x5a\x97\xc9\x73\xe8\xba\xe5\xa3\x32\x34\x3c\x5d\x5a\x62\xf4\x78\x3d\x92\x8d\x63\x0b\x82\x6c\xb0\xa2\xdc\x53\x84\x49\xf2\xb8\x9c\x96\xa9\x19\x27\x0a\xd3\x45\xac\x80\x29\x15\x90\xae\xd0\x17\xb1\x92\x2c\x64\x4a\x5b\x49\xb2\xaf\xa9\x6a\x75\x35\x45\x2b\x2b\x12\xc3\x1f\xf5\x8c\x26\x92\x3d\xd8\xff\xb5\xb0\xee\xd0\xb5\x8f\xfd\xf5\x46\xd7\xa4\x4c\xf3\xe0\x8a\xa1\x53\x5f\x79\xdf\xd7\xfe\xd4\x92\xfe\xe7\x59\xe5\x99\x53\xd6\x1c\x7f\xfc\x6a\xcf\xb4\x8b\xac\x2f\x05\x9e\x7b\xd3\x75\xf9\xdd\x2f\x5f\x7b\xee\x82\x2b\xeb\x7d\x50\xc5\xf4\x57\xa4\xeb\xc0\x62\x61\x30\xa3\x3a\x8d\xc6\x80\x8f\xf1\xb2\x5e\x2a\xc6\xfd\x01\x0b\xbe\x1d\x7d\x58\x15\xf1\xf9\x10\xcf\x63\x36\xc9\xde\xdd\x01\x88\x06\x60\xae\x7a\x77\xeb\xcb\x8f\x72\x8d\xed\x9a\xd4\xa6\x82\x9b\x1e\x39\x45\x01\xa9\x26\xf8\x5d\x10\x25\xd0\x76\x83\xfd\xd7\x57\xf2\x23\x57\xc8\x7f\x05\x27\xb3\x7e\xfb\x17\xed\x7f\x7d\x06\x9c\x72\xd5\x1d\x77\x2d\xbb\x56\xbe\xb3\x85\xf1\x76\xe2\xa3\x34\xed\xe9\x25\x0f\x7f\x95\xd7\x79\x90\x39\xb3\xe0\xaa\xd6\x69\xf2\x14\xfd\x6e\xe4\x2f\xc0\xfb\x52\x8c\x86\xa5\x4b\x7c\x5e\x29\x91\x6f\xc7\x37\xa3\x3d\xe1\xe5\x4a\x4b\x50\xe9\xf2\x52\x26\xc6\xe6\xfb\x38\x89\x43\x2e\x57\x70\x6a\xc6\x85\x05\x3e\xb9\x1e\xb3\x57\xa3\xe6\xd1\xce\x6a\x1a\x04\x3b\x15\x52\x4b\x6c\x14\x93\x96\xec\x81\xd9\x9c\xa8\x94\x2a\x8c\xf2\xb8\xc3\xe0\x0b\xb3\x58\xf9\x60\x2e\x92\x7f\x96\xbf\xc9\x83\x98\xe7\x8e\x5b\x20\x73\xdd\xfe\x8e\xdf\xb5\x42\x6f\x60\x7f\x80\x68\x4c\xfe\xcc\xbb\xa9\x7d\xe9\x6d\x35\x97\xdd\xb9\x7d\xcb\xa4\x2a\xf9\x80\xfb\xd0\xcb\x3d\x67\x4f\xff\x63\x73\x6b\x45\xcf\x99\xf7\xcc\xfe\xdd\x87\x4f\x3e\x32\xe0\xe2\x59\xad\x2d\x95\x17\xf6\x2c\x2e\x1f\x35\x65\x69\xcb\x87\x5f\xd0\x67\xb9\x03\xef\xc7\xb5\x54\x27\x2c\x4d\xfb\x18\xc9\x80\xa4\x66\x89\x09\xe1\xeb\x89\x67\xc9\xb2\x83\x7a\x47\x52\xf3\xa6\x7a\x9d\x6b\x96\xed\x98\xc8\x2e\xfb\x4a\xfe\xeb\x57\x72\x43\x39\xf7\x34\x46\x9a\xa7\x2f\xe5\xb6\x9e\x20\x38\x73\x21\x5e\x9f\x7f\xe2\x31\xbd\x68\x74\xba\xd8\x61\xb7\x3b\x6d\x36\x9f\x5f\xc0\x5b\x88\xe5\x90\x5f\xb0\x49\xac\x13\xd9\x25\x0c\x74\x25\x97\xdd\xc1\x73\x44\x53\x6b\xf6\x53\xfb\x18\x16\x3e\xaa\x3a\xe3\x54\xed\x96\xdd\xcd\x7a\x45\xd5\x44\xf4\xb0\x0c\x8a\x45\x0b\x89\xc5\x12\x7f\x26\xaa\x39\xb3\xef\xe1\xdd\x05\x8f\x41\x72\x77\xbd\xfc\xb4\xfc\xb1\xfc\x5f\xf9\xb8\xcd\x70\x27\x24\xef\x71\x6e\x7c\x77\xcb\x7e\xf6\xb2\x33\x77\xc8\x5f\xcb\xff\xfe\xf6\xc3\xf2\x25\x45\xac\x70\xe6\x2f\x13\xc7\x5f\x31\x57\xd9\x47\xf2\xd6\xa6\x2f\xe9\xd9\x1f\x98\x4e\x00\x12\x04\x46\x32\x1a\x59\x86\x31\x9b\x8c\x58\x35\x46\xe0\x6c\x32\x43\xd4\x0c\x76\x33\x1c\x36\x43\x9b\x19\x1a\xcd\xa0\x48\x7e\x42\x69\x63\x4a\x61\xb8\x6a\x85\xcb\x30\x75\xe4\xac\xbb\xbc\x3e\x22\xcc\x99\xbf\xcb\x4f\x7e\x01\x3d\xe7\xd9\x85\xca\x06\xf8\x12\x43\xbe\x15\x67\x16\x6e\x5a\x38\x73\x31\xbb\x97\xcc\xbb\x19\x21\x43\x84\xae\xcf\x84\x74\x0f\x27\xd6\x45\x1c\x76\x8e\x93\x3c\x5e\xaf\x45\x34\x18\x8c\x92\xe4\xf7\x71\x16\x27\x6b\xf0\xd8\x25\x16\x6b\xe7\xce\x36\x3f\x34\xf9\xa1\xd1\x0f\x95\x7e\xaa\xba\x2a\x88\xa5\xbb\x98\xd6\xa8\x48\x69\x94\x54\x02\x46\x56\x04\xae\x7a\x3d\x8d\x40\x7c\x0f\x4e\x88\xf1\x0f\xc8\x3b\x43\x1c\xf4\x6d\x94\x77\xc9\x5b\x33\xe0\x2f\x14\x1b\x46\xc2\xa5\xd0\xb7\x34\x74\x05\x8c\xc5\x17\x52\xf9\x27\xe3\x76\x6c\x3b\xf3\x39\x26\xf6\x9d\xc7\xf6\xdf\x7e\x90\x4d\x9f\x5e\x38\x0c\x23\x1e\xf2\x22\xb6\xae\x9d\x78\xad\x9e\xa3\xd8\x6b\x70\x3a\x49\x1c\x25\x22\xcf\x10\xfb\x1f\xc7\x59\x90\xe5\x88\x85\xd9\x67\x81\x4a\x4b\x9b\x65\xbb\x85\x05\x84\x57\xd1\x2c\x38\x31\xf4\x6d\x54\xec\xe1\xa9\xea\x56\x12\x5e\xe6\x48\x29\x56\x01\x45\x3e\xba\x62\x2e\x02\xa3\x08\x98\x82\x4f\xa0\xf6\x33\xd8\x08\x0d\x9d\x8f\xc1\x6c\xf9\xed\x4e\xb9\x41\x7e\x95\xb9\x05\x2b\x7d\x25\xf0\x41\xe7\xa4\xce\x42\xc6\xdd\xf9\x1d\xa3\xf8\x43\xd1\x13\x98\x0e\xf2\xbe\x27\x03\xd6\x3e\x63\x06\x9e\x41\xc0\x00\x2b\x88\xa2\x11\x9f\x40\xc9\xc8\x2a\x0c\x7b\xcc\x08\x73\x8c\x30\xc5\x48\x96\x4b\xc3\xb9\x3a\x96\x77\x68\x6b\xa4\xcc\x0f\xcc\x7b\xf2\x47\x73\xe4\xdb\x30\x04\x66\xe1\x23\x18\xd0\x39\x8e\xb9\x90\x6d\xec\x7c\x90\x69\x3d\xf3\x02\x7e\xee\x63\x78\xbe\x38\xd5\xdf\x06\xa4\x0b\x38\x09\x08\xd6\x34\x19\x30\x90\x33\x62\x35\x4d\x39\x23\x8c\x01\x00\x2b\x9a\x98\x5d\xb0\xba\x86\x54\xa1\xa4\x62\x60\xdd\x37\xa4\x68\x11\x25\x50\x4f\x74\x21\x11\x62\x5c\xef\xd3\x9b\x8b\xd9\xed\x9d\x33\x2a\xd8\x5f\x8a\xcf\x4c\x66\xad\xef\xb0\xaf\x7f\xfd\xf6\x99\x14\x59\xeb\x37\xe4\x89\xec\xc5\xfc\x5b\xf8\x4c\x56\xa7\x83\x1c\x89\x1c\x94\x04\x1e\xf3\x0c\x70\x3f\x67\xb0\x5e\xcb\xff\x9c\x41\xa1\x5c\xb0\x9d\x13\xc3\xd6\xb3\x8a\x25\xba\x29\xfe\x5b\x07\xf3\x98\x70\x91\xfc\x9d\xfc\x01\xb8\x8b\xe4\x89\xe2\x82\xe7\x7f\x33\x1c\x56\xd6\x70\x76\xd7\x07\x8c\x9b\x7f\x1b\x6f\x50\x5e\xda\xcc\x00\x62\x01\xc3\x62\xd6\x0b\x48\x5d\x2a\xf5\xd6\xe5\xd9\x14\x5e\xa2\xfd\x3f\xfc\xa1\x84\xff\xe5\x37\x23\xa6\x6b\x8c\x3c\x91\xf9\x9c\xd0\x05\x8f\xa6\xbb\x78\xbc\x10\x12\x56\xad\x30\x5d\x0c\x46\xd6\x3f\x67\xc4\x10\xcb\x09\x98\x42\x01\x61\xda\x66\x48\x10\x90\xc0\x24\xc1\x69\x09\x4e\x4a\x70\x50\x82\xc7\x25\xb8\x47\x82\x75\x12\x64\x24\x18\x26\x41\x83\xf6\x4d\xbb\x04\xd3\x25\x98\x20\x81\x57\x02\x41\x02\x69\x89\x04\xb3\x68\xa3\x11\x12\xf4\x91\xa0\x4c\x82\x10\x1d\xa8\x53\x02\xf8\x51\x82\xe3\x12\x1c\x95\xe0\x59\x09\x76\x4b\xb0\x5d\x82\x0d\x12\x28\x1d\x26\x49\xd0\x24\x41\xa3\x04\x95\x12\x44\x68\x87\x19\xdf\x4a\xf0\xb1\x04\x6f\xd2\xd6\x7b\xb5\xd6\xcb\x24\x98\x4d\x5b\x8f\xd0\x5a\x87\x34\x3a\xbf\xd5\x46\x3f\x2c\xc1\xfa\x9c\x71\xcf\x22\xe4\x63\xda\x26\x5d\xae\xd0\x70\x1f\x6d\xab\x8c\xda\x26\x01\x83\xe7\xb6\xe1\xa7\xeb\x92\x08\xb1\xca\x58\x78\x6e\x0d\x51\xb6\xfd\x8f\x20\x95\xff\xcf\x11\x2a\xb9\x3d\xcb\x34\xe7\x93\x6e\x81\x53\xbd\x65\x98\x19\xea\x63\x84\xdf\x60\x4f\x11\x78\xa0\x44\xfe\x47\x11\x13\x96\x6f\x95\x27\x1e\xe6\xff\xfb\xfc\x7f\xd7\x53\x5e\x18\xcf\x30\xdc\xa3\x98\xbf\x05\x94\x4a\x87\x90\xc0\x73\x58\x47\x62\xf1\xb9\x36\x88\x2c\x02\x8e\xdd\x67\x80\xe5\x06\x98\x62\x00\x2a\x77\x52\x2f\x57\xeb\x06\x32\xca\x22\x12\x13\xc7\x27\x88\x7d\x51\x7e\x46\x7e\xee\x0b\x58\x03\x17\xc2\x3a\x86\x61\x4e\x75\xda\xd9\x65\x67\x56\xd0\xf8\x85\xb5\x5d\x02\x17\xeb\x1a\xa7\xc4\x16\x30\x3c\xe2\x00\x3d\xab\xc4\x16\x80\xe2\xf2\xaf\x8d\x79\xae\xe3\xee\xf9\x6d\x34\x2d\xa2\x8a\x25\x15\xb7\x9d\xf9\x81\xff\x14\xeb\x4b\xb8\x3d\x70\x9c\x88\x98\x5b\x26\xa1\x6c\x7b\x09\xea\x63\x2e\x91\x19\x27\xbf\x6d\x00\xe6\x25\x81\xdb\x0e\xee\x32\xf9\xb3\x08\xc5\x4b\x46\xac\xb3\xd6\x73\xa3\x51\x05\xea\x85\xae\x4f\x0f\xe2\x7b\xf5\x2a\x8d\xc5\x9c\x61\x9f\xdf\x5f\x6d\x0e\x9b\x7b\x37\x1c\xe9\xfd\x59\x6f\xc6\xd6\x1b\x4c\x6c\x2f\x41\xea\x61\xef\x31\x26\x13\x8b\xda\x7c\xf8\x47\xbb\xcf\xee\x93\x42\x21\x77\x4b\x26\x64\x97\x6a\x9b\x32\x28\x39\x26\x83\x90\xe4\x55\x3c\x2a\xa9\xca\xb2\xb3\xed\xc9\x0d\x0d\x59\xab\x9b\x1a\x9a\xa6\x23\x65\x55\xcb\xcd\xb1\x23\x17\x16\xd5\xd7\xa9\xae\x78\xd5\x55\x29\x92\x7b\x2b\xcc\x10\xf8\x65\x05\x36\xae\x1a\x8d\xeb\xea\xd9\xa5\x97\x5d\xc5\x0b\xe3\x1e\x6a\xbf\xe5\x51\xd4\x05\xe1\xc3\x9e\x65\x93\x2f\x71\xc8\xbf\x16\xfc\xf8\xea\xd1\x17\xfc\x43\x0c\xee\x60\x50\x0c\x47\xad\xa5\x13\x3e\xdf\xb9\x60\x4d\xd3\x80\xb1\x6b\x43\xc6\x71\x83\x8a\x42\x37\x4e\x7d\xf4\xa6\x83\x87\xb0\x30\x2a\x5c\x3e\x6c\x50\xe4\xf6\xcd\x1b\xef\x2a\xba\x4e\xde\x5e\x11\xf2\x07\xcd\xac\x78\x9f\x5d\x60\x80\xb9\x64\xdc\xe0\xa6\x15\x33\xf1\x1a\xc5\xf1\x1a\x3d\x86\xcf\x70\x10\x95\xa0\x05\xe9\xc1\x1e\x7f\xd8\xc4\x59\xdd\x6e\x97\x0b\x2b\x8d\xb6\x4a\x5b\xa3\x8d\x4d\xe2\xcb\x3f\xca\x56\xb1\xac\x95\xb7\xb1\xa5\x65\xf8\x77\x60\xf3\x58\xc3\xf1\x90\x21\xde\x94\xf1\xf8\x4d\x2c\x32\x78\x51\x08\x2f\x92\x1d\x2f\xcf\xb1\x32\x88\x96\x61\xbc\xa9\xca\x22\x7c\x27\xa9\x98\xac\x91\xe8\xd4\x44\x96\x10\xcc\x90\x6a\x55\x81\x99\x4f\x09\x77\xcc\x57\x6d\xed\xc9\xb8\x0d\x62\xd4\x12\xc0\x0a\xf1\x54\x7f\xc0\xf8\x53\x14\x72\x00\xe8\xc4\xed\xfb\x97\xfe\x7d\xcf\xf5\xf7\x47\x99\x3c\xb7\xfc\x4f\x3e\xdf\xf6\x0b\x04\xc6\xe5\x71\x5c\xaf\xdf\xc3\x0d\x77\x17\x38\x66\xb6\x5d\x3e\x6f\xe4\x10\x6e\xf4\xa1\x87\xad\xcf\xc9\x2b\xfe\x70\xe5\xe4\xd9\x03\x6c\xab\x87\x73\xdf\xcb\xe3\x6f\x1f\x37\xe3\xa5\x7d\xbf\x6b\xed\x3b\x6b\xd1\xf5\x50\x36\x75\xc6\x55\x8a\xdc\x6b\xc4\xcf\x3e\x1e\xf3\x47\x00\xf5\x4d\x47\xf1\xcd\xe5\xb0\xfb\x25\xbb\x14\x0a\x5a\x5c\x4d\x19\x87\xc5\x8e\x05\x1a\x6a\xca\x08\xde\x7d\x21\x98\x13\xa2\xe1\xd9\xca\xb1\x4a\x9d\x65\xb7\x24\x28\x84\x57\xa2\x4b\x54\x37\x34\x71\x29\x12\xc2\x19\xff\xd8\xab\xa2\x60\x9b\x25\x5f\xfd\xc9\xf7\xdb\x40\x7c\xf9\xd0\xe7\x56\xf9\x84\xe9\xfe\x59\x8b\x7a\xfa\x9e\x9c\x71\x45\xb5\xfc\xc0\xdf\x5f\x7b\x09\x26\xec\x38\xbc\xcb\x77\x78\xd3\xb3\xd7\xd6\xfe\x03\xef\x47\xef\xae\x6f\x79\x01\xef\x87\x1f\x25\xd0\x55\xe9\xfe\x28\x6c\x65\x1d\x18\x09\x38\x1c\x4e\x8b\x33\xdf\xc9\xd8\x39\x67\x71\x91\x20\x24\x8b\xbd\x1e\x07\x84\x03\x31\x63\x0c\x2f\xbc\x95\x35\xda\xd9\x40\x53\x86\x25\x0c\x1a\x2d\x86\xe5\xc5\x30\xa7\x18\x9a\x8b\x29\x3a\xd1\x76\x42\x65\x51\x7f\xf6\xf6\xa3\x3b\x41\x2f\x41\xb2\x0d\x45\x59\x27\x47\xd4\x97\x52\x37\x41\x8c\xd5\xd4\x27\xab\xb5\xa0\x48\x12\x2e\xf3\xfd\x90\x87\x17\xdd\x7b\x60\xf9\xd7\x0f\x02\xea\xcd\x33\x66\xf3\x38\xf0\xfc\xe0\x96\xe4\xaf\x6d\x3f\xb4\xcc\x1f\x53\x35\x79\xf2\xf4\x15\x03\x77\xb4\x5e\xf4\xd6\xee\xc3\x70\xcd\xe1\x57\xdd\xcd\xfd\x61\xe7\xe9\xd0\x9c\x85\x8d\x53\xcd\x83\x36\x7c\xd8\x72\xdd\xd5\x37\xcb\xbf\xcc\xfd\x1b\x39\x9b\x64\xed\x7b\xe3\xb5\xf7\xa1\x08\xc6\xfd\xfd\x22\x0c\x63\xc5\x60\xc7\x63\xf5\x44\x03\xb1\x08\x1a\x93\x89\xc4\xec\x8e\xa1\xb6\x48\x24\xc2\x58\xf8\x48\xc4\xe4\x74\xe6\x8d\xc9\x38\xed\xe3\xc4\xcb\x48\x84\x95\x5d\x8c\x8a\xac\xc4\x89\x26\x13\xdf\x92\x31\x79\x95\x8d\x21\x47\x2f\xd7\x62\x5b\x46\x44\x84\x6e\xb4\xa3\x6a\xa3\xc2\x4b\x24\x08\x34\xae\xef\x16\x3e\x7c\xc9\x7a\xfa\x78\x22\x4c\x17\x5b\x27\x6d\xba\xf0\xe7\x11\x9f\x1e\x78\xff\xd4\xed\x20\xed\x79\xe7\x0b\xff\x77\xec\xa5\xcd\x53\x6e\xca\x83\x4f\x12\xa9\x99\x73\x1f\x1f\xbe\x7d\xe9\xd7\x47\x8f\x42\xfd\x23\x1f\xbc\x7c\xe9\xfc\x67\x7b\xcd\x9a\xb6\x6a\x39\x89\xf7\x43\x88\x1d\x8f\xf7\xcc\x8b\xc6\xa7\x2b\x3c\x6e\x37\x72\x81\x8b\x13\x04\x56\x14\xf1\x55\xed\x33\xfb\x91\x1f\x1c\x78\x8b\x5a\x32\x46\x7c\xb7\x0a\x6c\x53\xc6\x2d\xd8\x18\xf0\x28\xd2\xa4\x52\x8d\x0b\x6b\x2c\xa3\x70\x5a\x81\x6d\x94\xec\x6a\x45\x90\x28\xf0\x3a\x5e\x9f\xaa\x27\xc2\xc2\x27\x52\x15\xc0\x06\x29\x91\xb1\xef\x91\xbf\xd9\xb3\xad\x68\x9b\x37\x7c\xe8\x89\x61\x63\x0a\x4d\x69\xcf\x80\xbe\x16\xfb\xfb\x45\xec\xd2\x33\x2b\xd9\xa5\xcf\xcf\xbd\x6f\xb5\xe3\x29\xc6\x90\xbe\x60\x3c\x2d\xe7\xcc\x74\xfd\x2a\x4f\xe4\x8e\x70\xa3\xb0\xce\x55\x8d\xd6\xa6\x2f\xc4\x08\xa9\xc2\x65\x2e\x0a\xb1\x61\x49\x2a\x28\x08\x47\x4a\x23\xe0\x8a\xa4\x6a\x50\x4d\xb4\xa6\xaa\x66\x47\xcd\xb1\x1a\xde\xca\x16\xa0\x48\xd8\x56\x54\x59\xec\x2b\x6e\xca\x48\x82\xd9\x1c\xc2\xa2\xd1\x5e\xd9\x9c\xb1\x23\xa1\x25\xc3\xd1\x70\x5d\xc9\x3c\x94\x43\x21\xe5\x61\xaa\xcb\x34\x2d\x93\x90\xee\xd4\x58\x2e\xa5\x9b\xfe\x1a\xb2\x27\x5f\xb3\xfa\xab\x06\xc0\xba\xfa\x3a\x2c\x20\x19\xdd\xd1\xe6\xa5\x4c\x18\xb3\x61\x34\xc7\x51\x27\xbd\x95\x21\x91\xce\x18\x4d\xef\xfd\xe3\x5f\x02\x10\x0a\x3d\x70\xcd\xe2\x02\xb7\x89\x69\x6c\x5b\x38\xea\xbe\x83\xcb\x8e\xef\x6e\xdf\x15\x62\x84\x22\x1e\x24\x57\xf8\xe1\x4a\xf9\x5f\x0f\x5c\x39\x79\xe4\xa5\x83\x2a\x9e\xcc\x6c\x6c\x92\x27\xde\x7c\x47\x78\x59\xfb\x9d\x53\x46\x67\x46\x97\xbe\xf6\xd0\xeb\x30\x77\xef\x9c\x29\xf9\x5b\x0c\x63\x37\x9e\x79\xea\xe4\x1b\xdc\xc4\x2b\x17\xa6\x37\x9c\x1c\xf6\xc7\xd5\xc4\x3e\x17\x47\x88\xbb\x15\xef\x65\x00\x5d\x9c\xee\x61\xb5\x58\x1c\x12\x43\x5e\x62\x15\x08\xf8\xfc\x92\x3f\x14\x44\x01\x60\xfc\x82\xdf\x62\xf3\xfa\x5c\x3e\xab\xc5\x23\xb8\x9a\x33\x02\x11\x7c\xd1\x10\x68\x47\x2d\x95\x75\x0e\x34\xa6\xba\x05\x37\xe9\xcf\xcc\x8a\x29\x55\xf2\x13\x1b\x8a\x4b\xbd\x0d\xb0\x52\xca\x64\x9a\x92\xec\x88\xa7\x16\x6c\xb9\xd7\x2a\x2e\x93\x4f\xb6\x07\xb7\x5c\xfe\x84\xb7\x5d\xfe\x0a\xc2\xfc\x5b\xf2\xac\xa7\xaf\xbc\x6c\xe3\xcd\x81\xab\xc3\x9d\xd7\x32\x63\x97\x96\xac\x78\x68\x61\xe7\x4e\x4c\x2a\xbd\xeb\xe2\xd4\xbe\xfc\x16\xf5\x99\x4f\x4e\xf7\x12\x78\x9e\x84\xd3\x89\x58\x8f\x20\x2f\x6a\xb2\x71\x1e\xf2\x2a\xc0\xb1\x19\x00\x4c\xeb\x29\x9a\xe8\xb2\x43\x82\xdb\x69\x96\x0b\xa2\x90\x64\x39\x05\x3f\x3a\x94\xd0\x41\x84\x2a\xb7\x73\x43\x15\x09\x60\x25\x69\x2f\xc1\x12\x08\x94\x74\x9e\xfa\x33\x04\xde\xe5\x3a\x8f\x1e\x3d\xcd\x62\x10\xfb\x2a\xe6\xb3\x42\x8c\x0b\x15\x5a\xec\x68\x6c\xba\x0a\x99\x4c\x4e\x87\x95\x33\x19\x2c\x66\x1b\x67\x68\xce\x70\x21\x85\x16\x86\x12\x73\xcc\x09\x3b\x9c\x10\x75\xc2\x5e\x27\x2c\x77\x42\xa5\x53\xa5\xa1\x0c\xe9\x07\x03\x51\x0e\xd2\x34\x7a\x95\x80\x82\x64\xbd\x4f\x51\xff\xb0\x62\x13\x2a\x86\x40\x71\xe7\xe6\xb6\x21\x85\xbd\x07\x34\x3a\x8f\x43\xe0\xbb\xfc\xbd\x84\xa4\x5f\x2f\x76\x3d\xc7\x0d\x6a\xe5\xda\x4f\x0f\xbe\xfd\x1e\x2a\xf3\xc9\xfe\xbe\x46\x63\x68\xe7\xa7\x07\x24\x8d\xe0\x07\xc0\xf4\x49\x3e\x63\xd2\xc8\xd0\x9f\xce\xb6\x21\x5b\xcc\xcb\x89\x2a\xd3\x64\x61\x8a\x41\xb1\x18\x4b\x36\xfc\x2b\x0c\x91\x91\x7a\x82\xa9\xbd\x98\x5c\x75\xad\xd0\xda\x7a\xae\xa9\x58\xb9\xee\x08\xdd\xa8\xb5\x35\xc6\x66\x2d\xc6\xcc\x87\xcf\xdd\x32\x5e\xfe\x06\xa2\x10\x78\x14\xde\x81\x0b\xe5\x24\x56\x41\xfe\x39\x42\xc6\x50\xff\xcc\x1e\x38\x22\x5f\xdc\xa9\xde\x53\xd9\xbd\x1d\x97\xae\xa5\x36\x63\xc4\x13\x8f\x16\x99\x5f\xf7\x16\x28\xc6\x7f\x44\x5d\x08\x1b\xa8\x93\xc0\xc6\x83\x09\xff\x3c\x00\xff\x12\x23\xc8\xc9\xad\xb9\x7b\xdb\x98\x1b\x8a\x88\x21\x5b\x9c\x50\x21\x1f\xe7\xdf\xfa\xad\x46\x9f\x53\x78\x0d\xcb\x8a\x72\xf4\x44\xfa\x8a\x7c\x96\xa5\x46\xc3\xa4\x2d\x99\x48\x14\x17\x15\x79\x2d\xd4\xa8\xdc\xa3\xc2\x97\x5f\xc4\x26\x82\x42\x31\x6b\xe1\x38\x64\x0c\x1a\x9b\x33\xd1\xa0\xdd\xe5\xb4\x59\x13\x49\x1b\xcf\x11\xfa\x50\x0f\x38\xd5\x03\x96\xf7\x80\x29\x3d\x40\xf9\x7c\xb4\x07\xcc\xee\x01\xcd\x3d\xa0\xa9\x07\x44\x7b\x80\x0d\xff\xbf\x8a\xfe\xae\x71\x72\xd6\x3b\x41\xa1\xac\x62\x01\xc0\x6b\x9b\x52\x58\x81\x6a\xb8\x67\x69\xb9\xa9\xb3\xa2\x1f\x0a\xba\x1f\x28\x57\x5d\x7d\x0c\x9f\x31\xe5\xb4\xf9\x74\xb4\x85\xbf\xef\x07\x09\xbe\x74\xd2\xea\xe0\x42\xf9\xe4\x12\xc7\x0d\x17\xad\x0b\xe1\x53\xf6\x08\xc6\x36\x76\x8f\xc8\x8e\xba\x6b\xfa\xd2\xdb\xad\xcd\x0f\x5f\x7d\xf3\x26\xcf\x72\xf9\xe4\x62\x27\xcb\x2e\xbd\xf7\xa6\xce\x07\x98\x25\x93\x2a\x16\xdd\xbd\xae\xf3\x21\x76\x6c\xdb\x5a\xd3\xaa\x92\xf9\x17\x2d\x9c\x7b\xfd\xac\x8d\x37\xa7\x2f\xc3\x27\xf2\xda\x8b\x7b\xf2\x8b\x74\x1e\xbb\x15\xaf\x5d\x1e\xf1\xab\x39\x0d\x56\xc9\x8a\x39\xcc\x88\xf2\xf2\x58\xbf\xd1\x9f\x1f\xc6\x9b\xe4\xe1\x9b\x33\x1e\xbb\xc9\x62\xb4\x5a\x2d\x36\xfc\x2b\xb2\x52\xd1\x30\x95\x20\x8a\xf7\x01\x8b\x0e\xcd\xff\x9c\x0b\x26\x1d\xaa\xef\xe9\xfc\xcf\x47\xa5\x09\xf3\xb9\x2e\x34\x1e\xb1\x7b\xc1\xec\xe2\x75\x79\xa2\x0b\x0d\x76\x6c\xd3\x16\x69\x73\x50\x97\x26\xea\x7d\xfc\x00\xa6\xd9\x42\xd1\x50\xdc\x2d\x5a\xb1\x20\x09\x86\x4c\xf6\xa6\x8c\xc9\xce\x79\x9b\x32\x1c\x01\x17\xc7\x42\x80\x05\xdd\xa9\x10\x34\x13\x40\xa4\xc3\xbc\x6e\xb6\x59\x6a\x98\xd5\x6e\x57\x9e\xc6\xd9\x7a\xec\x44\x70\x73\x0f\x3c\x28\xbf\xff\xdc\x47\xf2\x76\x48\x3c\xf7\xed\x2f\xf2\x47\xc7\xe6\xad\x19\x79\x6c\xce\x4d\x23\x98\xdd\x47\xe5\xe7\xf7\x7c\xfb\xd6\xeb\x50\xb7\xfb\xe3\x4f\xfe\x73\xdd\xcf\x73\xe5\xce\xb9\x5f\x61\x39\xf2\x2e\xbe\xaf\x1e\xc0\x18\xc1\x8a\x8a\xd1\xbc\x74\xda\xec\xf1\xc4\x4a\x23\x98\x17\x8b\xa3\xc5\x05\x05\xd1\x58\x49\x41\xac\xa8\xd0\x16\x8d\xc6\x42\x91\xfc\xe2\x80\x93\x35\xa0\x80\xa1\x29\x13\xf0\x3a\x31\x6a\x73\x52\x30\x5a\x0a\xd1\x52\x58\x5e\x0a\x73\x4a\xa1\xb9\x54\x91\x2b\x67\x79\xa4\x08\x32\x25\x0c\xe6\x24\xaa\x79\x75\xb5\x7a\x33\x29\x66\x42\xe8\x8e\x3e\x8b\xf4\xb0\x42\x8a\x54\xe9\xea\x37\x02\x59\x7d\xe6\x43\x05\x7d\x4e\x6f\x1f\x38\x4a\x7e\x61\xe8\xc3\xed\x3a\x4c\x15\x03\xcd\xf2\x37\xff\xc6\x5c\xe5\xb2\x19\xd8\xf5\x0a\x02\x5d\x0e\x79\x57\xcf\x9c\x25\x5c\x96\x39\xf4\xf0\x1b\x14\xa5\xf6\xbf\x41\x9e\xca\xfd\xe3\x9a\xf5\xd6\x65\x79\x8a\x2c\xef\x83\x9f\xfb\x30\xc5\x46\x45\x68\x49\x7a\x58\xdc\x2e\xd9\xc1\x9e\x4c\x18\x43\x88\xc5\x0a\xb6\x20\x30\x6c\x29\x4b\x3c\x46\x60\xe5\xd9\x64\xc8\x1f\x71\x47\x30\x08\x34\x1a\x58\x8b\xdb\x6e\xf1\x37\x65\x2c\x5e\x41\x0c\x31\x24\xfc\xeb\x58\x12\xa2\x49\x58\x9e\x84\x39\x49\x68\x4c\xea\x0b\x80\xcf\x53\x2e\x38\xc7\x4f\x4e\x1d\xdc\xd9\x9b\x99\x0a\x2d\xbc\x00\x98\xb9\xac\x04\x7c\x74\x8b\x80\xf1\xfa\x40\xc9\x37\x52\x1d\xba\xec\x8d\x01\x2f\x58\x0d\xe5\x3f\xcb\x5f\x8f\x2f\xe4\x46\x3c\x3e\x7f\xcb\x1f\x96\x7f\xf3\xc0\x8d\xb7\x95\xc8\xeb\x96\x6d\x8e\xda\xf7\x5c\xb3\x72\x48\x0b\xbb\x66\x49\xaf\xd0\x7b\xa7\xcd\xb0\xef\xfe\x69\x13\x5e\x7e\xf2\x65\xb8\xe6\xc8\xa4\xab\x3a\x8b\x7e\xb7\xff\xa2\x0b\xbe\x5a\x21\x9f\x5a\x72\xe5\x35\xea\xb9\x61\x17\xe3\xe7\x76\xa1\x11\xe9\x12\xde\x22\x98\x4c\x46\xa3\x20\x8a\x6e\x97\xc7\xe2\xe0\x05\xc6\xc1\x34\x67\x1c\x76\x93\xd1\x26\x90\xe3\xb2\xd7\x03\x6d\xaa\xe5\x9d\xda\x74\x54\xeb\xaf\xa3\x81\xa2\xbe\x5c\xc3\x7b\x22\x7b\x54\x30\x6c\xa2\x20\x8a\x1d\x39\xa8\x62\xc9\x7d\xf1\xcb\xe5\xaf\x1f\xf0\x3b\xc1\xec\x35\x70\xc3\x6e\xbb\xa4\xb2\x17\x3b\xde\xb6\xe7\x40\xa7\xcc\xf6\xbf\x6e\xe5\x13\x3d\x57\xcf\xb2\x62\x9a\x7c\xf8\x5c\x54\x70\x23\xf0\x4e\x5c\x9f\x1e\x1d\x71\xb9\x44\xc1\x82\x50\x30\x20\x04\x12\x49\x4b\x84\xf5\x7a\xf3\x5b\x32\x96\x60\x7e\xb0\x22\x88\xf1\x68\xd0\x6b\x67\x8d\x2d\x19\x5e\xf4\x88\x45\x22\x16\xf4\xde\xe6\x24\xa4\x93\x50\x45\x77\xc1\x9e\x04\xbc\x1d\xfb\x92\xa0\x7c\x19\x4d\x2a\x21\x33\x6a\x52\x58\x8a\x86\x28\xa5\x14\x7f\x3e\x09\xd2\xec\x7e\xee\x69\xe6\x21\x61\xbb\x7a\x2d\x38\x37\xa9\xe5\x36\x29\x80\x50\x31\x09\x03\xfb\x8d\xdc\xf5\xcb\xeb\xdf\x94\x9c\xf6\xcc\xb9\xe6\xea\xb9\x63\x6f\xfd\xe3\x83\xa7\x4f\xfe\xe9\x0d\xff\x69\xc7\xb4\xf1\x6f\x17\x0f\xbf\xf5\xe9\xcd\x30\x7a\xcf\x81\xdb\xee\x2a\x1c\x71\xe1\xe0\x0b\x6b\xea\xc3\x15\xdb\x6f\xd8\xb1\xeb\xd6\x4d\xf9\x83\xfa\x5f\x17\x2b\xc7\x07\x6a\x8b\x22\xfb\x27\x74\x9d\x62\x4e\xf1\xbd\xb0\x24\x98\x92\xae\x36\xdb\x4c\x3e\xa7\xd3\x84\xd1\xac\x24\xb1\x6c\xd0\x12\x32\x19\xa5\xb4\xdd\x63\xb3\xf1\x48\x90\x84\xa6\x8c\x59\xb2\x21\x0f\xe6\x3f\x22\x1e\x8e\x87\x60\x79\x48\x71\x85\x68\x9e\x06\xd4\x40\xb6\x21\xe8\xb7\xd3\xcc\x56\xa7\x7a\x27\xa6\xb4\x98\x68\x45\x31\xa6\xe8\x36\x25\xa6\xc4\xb8\x1a\x5a\x55\x2f\x0a\x70\xdd\xd2\xb5\xf6\xe9\x77\x16\xed\x5c\xb7\xaf\xea\x8d\xf8\xdb\x57\x9a\x2a\x8b\xa3\x23\xa3\x2d\xf6\x05\x57\x0d\x99\xc0\x58\x9f\x97\xe5\xe7\x3b\x4f\xf6\x8a\xf5\xa8\xb0\x3c\xed\xa7\x76\x8b\xae\xef\xf1\x99\xe9\x8d\x65\xee\xf4\x74\x6f\x07\x91\xb9\x16\x8b\x2e\x73\xc3\xf9\x21\x93\x93\xf5\x18\x80\x97\xf2\x6c\x54\xf6\x7a\xad\xf4\x72\x0a\xc3\xb1\x30\xec\x08\xc3\x9c\x30\x60\xf1\x7b\x2a\x0c\xfa\xc5\xa3\xa1\x8e\x06\xa7\xef\xfc\x42\x18\x08\xa9\x29\x05\x81\x10\x3d\xa9\x4e\x3f\x24\xf8\x2b\x06\x11\x21\xbc\xdb\xd7\x0e\x41\x2c\x84\xe5\x9f\xb0\x10\x1e\xf9\xd4\x7c\x2a\x84\xb9\xde\x9d\x4f\x2e\x29\x5d\xb1\x73\x11\x33\xf9\xcc\x93\x54\x0c\xcf\x9a\x8a\xc5\xf0\xec\x3c\xe6\x56\xf2\x1c\xf8\x20\x70\xc7\xf0\x73\x98\xd0\xc8\x74\x39\x20\x51\x64\x8c\x26\x13\xcb\x30\x16\xb3\x89\xb1\x89\x08\x3c\xc8\x02\x73\x2c\x30\x85\xc6\x2c\xe0\xcf\xc7\x2c\xb0\xcf\x02\xb7\x5b\x20\x1b\x7f\xf5\x3f\x6d\xd1\x61\xf0\xd4\xd5\x43\x8c\xb9\x46\xde\xb7\x0f\x62\x43\x38\x67\xbf\x7e\xd0\x17\x7a\x60\x8a\x1e\x0c\x7f\xe8\xdb\xb0\x84\x51\xfd\x19\x97\xe2\xbb\xff\x11\xfa\x76\xa0\x69\xe9\x3a\x40\x0e\x9b\x95\x15\xf1\x61\x64\x1d\xac\xc1\xe5\x76\x4b\x06\x83\xd7\xc3\x3a\x4c\x2c\x3e\x98\x36\xab\x64\xb0\xe1\xbd\x42\x9e\xb4\x17\x76\x78\x61\x99\x17\x1a\xbd\x10\xf5\x2a\xbc\xad\x7b\x10\x73\x8c\xd3\xd5\xaa\xdf\x49\x77\x23\x62\xca\x92\x24\x1a\x1e\xd3\xa7\x58\xa6\x7d\x98\x44\xee\x0f\xf2\x07\x65\x7c\x6d\xa9\xfc\x67\xf9\x83\x41\xc0\x58\x43\x35\x90\x80\x8a\x52\xbe\x16\x03\x15\x23\x73\xe7\x57\xb7\x5d\xdc\x79\x0d\x26\x7b\xe8\x4d\x03\x97\x30\x4b\x3b\x57\x1e\x5e\xc9\xfc\x01\x41\xd7\x23\x78\xed\x3a\xe8\xda\x8d\x4e\xf7\x30\x8a\x26\x01\x38\x1e\x83\x3b\x82\xe7\x48\x10\x40\xb3\x65\x8a\x85\xab\xb2\xa4\x2d\x4c\xd4\x52\x65\xb9\xdd\xc2\x62\x80\xc7\xb0\xac\x99\xc7\x0c\xac\x9b\xa6\x31\x58\x9b\x3b\x4f\xdb\x68\xaa\xc3\xd0\x88\x35\x6a\x1a\xa6\x06\x62\xe6\xbd\x67\xe4\x83\xf2\xbb\x70\x46\x3e\x09\x85\x4f\x42\x31\xd4\xc8\xf9\x98\xb8\x65\xf2\x0a\xa6\x9a\x31\xc8\x0f\xc3\xa4\xce\x7f\x77\xbe\x4b\x6d\x5d\xbb\xb1\x1c\x7f\x0d\xd3\xe3\xc3\xf2\xac\xd8\x2d\xd9\x6c\x46\xa7\xcb\x85\x65\x5a\x80\xf1\xbb\x9c\x58\x8e\xb9\x6d\x12\xc2\xcc\x88\x42\xe9\x00\x7c\x16\x00\xac\x5b\x34\x07\x08\x07\xce\x53\x9c\x75\x64\x1f\x53\x29\xf5\xd4\x64\xb7\xd2\x85\x91\xaf\x12\x45\x43\xac\xf9\x4e\xb1\x1e\x93\x05\x56\xe6\xa2\xa9\x23\x13\xc5\x95\xa3\x17\xf6\xc9\x7b\x0f\xe2\x43\x84\x08\xe3\x58\x0f\x2c\x94\x77\xce\x9b\xb5\x66\x93\x3c\xd1\xf9\xb2\x74\xc9\x95\x55\x5c\x81\x6c\x8b\xc8\x1f\x49\x45\x50\x04\x3f\x9f\xbe\xf5\xd1\xb5\x17\x50\x3a\x7f\xc1\x72\xf7\x5f\x98\x4e\x09\x5d\x9a\xee\x8b\xaf\xd1\x08\x53\xc9\x34\x32\x2c\x62\x80\xe1\x79\x13\x51\xb6\xab\x44\xd6\x26\x82\x45\x10\x11\x32\x0a\x0c\xc7\x61\x49\xcc\xd9\x00\xff\x24\x62\xf2\x3d\x73\x4c\x30\x45\x09\x4e\x6a\x3d\x9f\xbd\x9b\xda\xc4\xc8\xc2\xb6\xd2\xc5\x8c\x6b\x26\x6f\xd1\x98\x60\x2e\x97\x87\x16\xb3\x90\xec\xdc\xc6\xd8\x8a\xff\xc8\x3c\xf6\xe6\xeb\x9d\x97\xbc\x4d\x79\xd0\x25\x4f\x64\xf7\x60\xcc\x5b\x82\x66\xa4\xeb\x7c\x56\xab\xd3\x59\x16\x32\x1a\x8b\x0b\x59\xb6\xb4\xcc\xe7\x77\x1b\x1d\xee\x9f\x33\x05\x31\x7c\xbe\x4d\xbc\x90\x34\x9a\x8c\x3f\x67\x2c\x56\x87\xc9\x84\x1c\x08\x25\xbb\xdb\xc3\x69\xee\x68\x83\xe6\x46\x72\xe8\x9f\x55\x18\x99\x13\x11\x0d\x8a\x30\xc2\xe2\x35\x49\x7c\xda\xfd\xa1\x0f\x88\xf4\xee\xb0\x82\x12\x19\x4f\xcd\x74\x5e\xfc\x2d\xac\x5c\xb8\xce\xd4\x4f\x3c\x92\xf8\xba\x6c\x40\xfe\xa3\xf7\xbe\x58\x34\x72\xcc\x04\x6f\x5f\xd7\x2d\x53\x61\x78\x86\xbf\x40\xba\xb0\x57\x73\x91\x3c\x71\xd1\xf4\xf2\x06\xa8\x89\xc7\xee\xc5\x4a\xf7\x71\x18\xb3\xf1\xce\xe7\x5b\xe7\xc8\x6f\x4c\x5e\xe5\xe6\x5c\x97\x8f\xc8\xf7\xc9\xfb\x4b\x0b\x6a\x6b\x0e\xe3\x67\x3d\x2c\x4f\x84\x57\x08\xbe\x07\x26\xdd\xa1\x80\x7b\x84\x42\x4a\xde\xe3\x08\x1e\xfa\x74\x4f\xa5\x9c\x95\x93\x09\xf9\x2c\x0f\xbb\x73\xd2\x23\x4d\x3c\x18\x06\xd2\xff\x28\x79\x93\x93\x68\x7f\xdc\x73\xd6\x4f\x5a\xc3\xe5\xdd\x33\x2f\x71\xd3\xd3\x34\xb4\x28\x37\xd7\x52\x9f\x4d\xf9\x72\x49\x4e\x7b\x3d\x4d\xb3\xcf\xb7\x3c\x7c\xac\x25\x81\x32\x24\xc6\xa8\xed\x2c\x4b\xf5\x39\xb6\xec\xc9\xea\xd7\xdd\xb2\xfc\xf4\xac\x68\x4d\xb9\x73\x39\x62\x8e\xc3\x20\x10\x0f\x05\x35\x49\x63\xfe\xbc\x1c\xf3\x02\xe2\xdf\x46\x65\xe8\xea\x74\x43\xbe\xc9\x54\x9a\x60\xd9\xf2\x8a\x80\xdd\xee\x76\x97\xc7\x0b\xf3\x4b\xcb\x4a\x7f\xce\x04\x82\x9e\xfc\x7c\x93\xcd\x6e\x76\x9b\xcc\x3f\x67\x04\xbe\xcc\x64\x72\x97\x21\xb7\xe7\xe7\x8c\x9b\xf0\xc2\xb1\x0a\x3d\xe0\x3e\x97\x1f\x1c\xb9\xfc\x90\x9b\x34\x90\x0d\xa5\x56\xf6\xdc\x47\x52\xa5\x30\x1f\x94\x41\x3d\x95\xf9\xfd\xa1\x11\xc8\x0d\x4c\xb9\x25\x81\xbf\x85\x0d\x94\x23\x5a\x2f\x4d\xb4\xaf\xf6\x0e\x88\x3c\xbe\x39\x87\x27\x46\x5c\xa4\xf2\x04\xff\xf6\xa2\xe9\x3d\xea\xe5\xb7\x62\xf1\x51\x4d\xcc\x11\x66\xee\x5c\x79\xef\x96\x0d\x98\x2b\xa0\xae\x6d\x95\x9b\x75\x5d\x31\x3c\xdf\x07\xa3\x2a\xa2\x84\x2b\xc8\x19\x68\xc7\x27\x6d\x25\x3b\x14\x4b\xa7\xcb\xd2\xbd\x9d\x06\x9f\xd7\xe9\x7a\x32\xe3\x74\xda\xb1\x44\x7b\x32\x63\x30\x20\xde\x8e\x9e\xcc\xd8\x4d\x26\xfe\xc9\x8c\xe9\x94\x0f\xaa\x7c\x90\xf6\x41\xd4\x87\x41\x0b\x38\xf1\xdf\x1b\x4e\xd1\x8f\x17\x4e\x6e\x9d\xab\xa8\x7f\x73\xe7\x22\x62\x9b\x21\xb1\xcf\xd9\x08\x57\xbf\x9e\xd6\x47\x2c\x31\x14\x2b\xd5\x52\x5c\x41\xae\x61\x0f\x86\x7f\x8b\x46\xdc\x31\x62\xcd\x84\x21\x0b\x2f\x98\xbb\xad\xf9\x9e\xe1\xab\x47\xaf\x9e\x97\x5e\xc0\x70\xa5\xc1\xca\xb2\x8a\xf7\xc7\x95\x07\x2b\x2f\xf9\xb8\xbc\x10\x93\x4b\xdf\xac\x4f\xff\x67\x17\x68\x8d\x3d\x06\xb9\xe5\x83\xcc\x48\x2c\x57\x88\x4d\x62\x7a\xba\x1f\x2b\x10\xf7\x10\xe6\x1e\x60\x38\x86\xa4\x44\xa0\x34\xa0\xad\x93\xc0\x46\xfc\xf8\x12\x54\x51\x63\x84\x9d\xda\x23\xce\xaa\xc6\xb1\x43\x2b\xc5\xa1\x9b\x26\x68\x00\x7c\x65\x4e\xec\xb6\x7a\x2b\x2b\x19\x14\x29\xf6\x3f\xb5\x10\xad\xed\xec\xfc\xf4\xab\x6d\x6c\x39\x09\x5b\x3f\x7d\x2b\xfb\xfe\x99\x32\xbc\xa6\x23\xbb\xfe\xce\x4d\xe3\x57\xa0\x18\xbc\x97\xee\x8a\x5a\x0c\x92\xcb\x8d\x95\xfc\x80\xdf\xef\x96\x2c\x5c\x41\x9c\x63\xdd\x2c\x63\x0e\xe4\x05\x18\x0c\x76\x02\x6c\x00\x85\x44\xac\x4d\x18\x45\x67\xa8\x29\xe3\x71\x8a\xf8\x8f\xe4\x12\xa4\xc0\xba\x38\x2c\x8a\xc3\x8c\x38\x4c\x8a\x43\x43\x1c\x4a\xe2\x10\x88\x83\x14\x87\x93\x71\xf8\x4b\x1c\xee\x89\x83\xd2\xa0\x41\xfb\x5e\xc0\xd7\xd6\xf5\x71\x98\x45\x3b\x8c\xa0\xbf\x28\xa3\xbf\x33\xc5\xe1\x34\xed\xf6\xd7\x38\xbc\x1e\x87\x83\x71\xd8\x1d\x87\xfb\xe2\xb0\x3e\x67\x82\x61\x71\xe8\x43\xe7\x08\xc5\xc1\x82\xbf\x24\x3d\x7e\x8c\xc3\xc7\x71\x38\x1a\x87\xc3\x71\xd8\x1b\x87\xed\x71\xd8\x10\x87\x25\x39\x33\x34\xd2\x19\x42\xf1\x6e\x8d\x9f\xcd\x19\x1e\x37\x4e\x0f\xc1\xcd\xdb\xe2\xd0\x94\xd3\x1c\x13\xd4\x45\x7b\x1c\xa7\x3d\x76\xd3\xb6\x4a\x33\x06\x37\x8a\xc4\xc1\x86\xc9\x57\x9a\xe8\xd3\xcf\xcb\x46\x51\x9d\xd7\x9d\x75\x8e\x43\xeb\xec\x14\xed\xdc\x9a\x09\x67\x77\xc1\xb2\x81\xd6\x24\x71\xa4\x94\x90\xfd\x9c\x28\x7e\xd5\xf9\x94\x2b\xc2\x89\x2d\x9e\x88\xeb\x78\x3d\x3d\x9e\x75\xa8\x11\x52\x24\xf5\x3f\x6b\x93\x2f\xa2\x36\xf9\x9a\xaf\xf7\x45\x77\x46\x1f\x7e\xca\xd9\x0b\xcc\x9f\x44\x76\x46\x6f\xdb\x65\xd2\x4c\xf3\x30\x74\xc6\x15\xd5\x8f\xef\x32\x3d\xba\x27\xf8\xe1\xde\x19\xc3\x7f\x02\xde\x74\xef\x03\xbe\x67\x36\x68\x46\x7a\x2a\x93\xf0\x2d\xc5\x6d\xe6\x37\x63\xbd\x60\x53\x7a\x74\x9e\x2b\x54\x84\x90\xdb\xe5\x4a\x86\xc2\xc1\x60\x24\x62\x96\x2c\x16\x83\x81\xe3\x12\xc1\x50\xa5\x1b\x58\x9b\x1b\x24\xde\xed\xb3\xfb\x16\x64\x42\xe6\x48\x2c\x1c\x36\xf0\x92\x59\x6a\xcf\x58\xec\x36\x33\x58\x59\xb3\x99\xb3\x8b\x7c\x8c\x8b\xcd\xcf\x70\x7e\x2d\x6b\x96\x18\xbe\xb0\xa4\xc2\x4f\xa9\x5a\x51\x15\xc1\xa4\x1a\xba\xdb\x5a\x9d\x9a\xbc\x52\x62\x11\xb3\x21\x2e\x4a\x40\x06\x86\xa2\xb1\x7a\x22\xa4\x30\xb2\x76\x29\xc6\x0f\xc5\x70\x2c\x92\xd0\x60\x11\x03\x56\xbc\x50\x5c\x73\xe9\x89\xdd\x9d\x75\xc9\xc9\xf3\x3c\x81\x67\xa3\xfb\x53\xc9\x4f\x5e\xd9\xf7\x8e\xe3\x67\xdb\xd8\x21\xa3\xc7\xb9\x6b\x21\x1c\x93\x3f\x0f\x95\x3e\x0f\x5b\xda\x16\xfa\x61\xd6\xef\x3b\xde\x4e\xac\x9a\xb1\x64\x17\x70\x47\x0f\x6d\xbf\xb5\x6a\xdc\xb0\x4b\x66\xc8\x3f\xed\xba\xe1\xa5\x61\x17\x4f\x47\xb4\xbe\xfc\x2e\x6e\x28\xf7\x04\x0a\x91\x37\xfa\xa7\x5d\x79\xa8\xc0\x8a\xac\xc5\x25\x9e\xc8\xae\x8c\x47\x14\x8b\x76\x65\xc4\xac\xec\xc9\x66\xe2\xd4\x90\xf4\x6b\x92\x55\x51\xef\x13\x89\xac\xf5\x89\x49\x52\x98\x41\x4c\xd6\x27\xea\xb3\xb9\x7b\xc2\x5d\x7d\x57\x6d\xbd\xe9\xf2\x85\x8b\xa6\xad\xd9\xb6\xb6\x6f\xef\xd5\xdb\x56\x5d\xb6\x68\xf1\xb4\x35\x5b\xd7\xf4\xfe\x7c\xf1\xc4\xf1\x4b\x16\x4f\x98\xb0\x84\x79\xe2\xba\xcb\x57\xdd\xbf\xaa\x4f\x9f\x35\xdb\xd6\x5c\x7a\x5d\xfb\xa5\xab\x76\xac\xe9\xd3\xb0\x6e\xdb\xba\x4b\x17\x4f\x58\xb2\x74\xfc\x84\x25\x8b\x89\x3c\x4d\x22\x62\x79\x21\x71\x16\x37\xa4\x2f\x44\x5e\xd6\xeb\x77\x38\x2d\x46\xc9\x66\xb5\x4a\x9c\x68\x00\x96\xe5\x0d\x06\x93\xe4\x94\x7c\x7e\xd1\x68\x31\x2e\xcc\x70\x16\xd6\xea\xb0\x2e\xcc\xb8\x31\x04\x76\x44\x1c\x0c\xa9\x94\x23\x79\x3d\x2e\x27\x2b\x69\x61\x30\xa9\x94\x5a\x30\x47\xad\x92\xe3\xc8\xcd\x29\xd1\x62\x8e\xb4\x98\x51\xb5\x4a\x85\x92\x74\xa9\xfc\xa9\x57\xff\xb0\x04\x5c\xb2\xf9\xe0\xce\x93\xf7\x44\x61\x0c\xfe\xb7\x87\x7c\xaa\x87\xbc\x2f\x0f\x5a\xa2\xf2\xde\x3c\x70\x7f\x06\x79\xf7\xc2\x6a\x48\x30\xbf\xdf\xb8\x73\xd3\x77\xdf\x6d\xda\xb9\x91\xf9\x53\xe7\x13\xcc\x38\xb2\xf6\x47\x30\x7e\x78\x55\xb5\xfd\xfe\x2b\xfd\x98\x80\x1f\x04\x21\xc9\xc0\x23\x1e\x01\x17\x02\x34\x4e\x82\x81\xd4\xa3\xfd\x9e\x04\x07\x24\x78\x48\x82\x3b\x25\xa8\x91\xa0\x50\x82\x9f\x24\x38\x41\xab\x0f\x5d\x26\x81\xd2\xcc\x2d\x01\x27\x81\x65\x20\xf5\x6d\x2b\xad\x15\x9f\x37\xfe\x76\xd6\x4f\xd4\xc7\xbd\x52\x6b\x6b\xa2\xbd\xf1\xa8\x2f\x9f\x33\x30\x47\xc7\x56\xbe\x5f\x49\x1b\x17\x6a\x63\xf7\xc1\x12\x9d\xc1\x22\x3d\xb7\xc2\xca\x59\x82\xe2\x2c\xa8\xa0\xff\x3e\x47\x1a\x64\xed\x97\x04\x31\x00\xfe\x7b\x04\xa3\x86\xdf\x40\x60\x3e\x63\xbe\xeb\x74\x9f\x5e\xc8\x7c\xdf\xe9\x52\xfc\x1e\x7f\xe9\x0a\x71\x4b\xf9\x4d\xa8\x12\xf5\x45\x53\xd3\x3d\x4b\x2b\x7a\xf7\xb6\x39\x53\x05\x1e\xac\xc4\xb2\x6c\xff\x54\xb1\x54\x51\x51\x5c\x1c\x0a\xf5\xab\x77\x26\xaa\x4a\x2d\x9c\x25\x2f\xc1\xf9\x91\x3f\xd2\x9e\xf1\x23\xb1\x5d\x4b\xa2\xac\x54\x22\xb5\xd4\x5d\xcd\x7a\xd5\xb5\x3f\xd9\xcd\xed\xa6\x93\x67\x13\x45\x62\x39\xea\x7b\x0f\x48\x16\xd6\xd6\x28\xf5\x49\x5c\xc4\xdb\x8b\x5b\x92\x74\xa2\x04\xf3\xa7\xb7\x3e\x16\x7f\x32\xcf\x19\x7b\xa2\xe6\x92\xab\xe1\xf2\xf9\xab\x1a\x07\xc9\xdf\xca\x67\x3e\x39\xe1\xfa\xc9\x3a\x7f\xe6\xda\xdb\x52\xad\xf7\xcb\x87\xc1\x36\x64\xf8\x2f\x57\x5e\xb1\xb8\xe7\xc4\xf6\xd9\x0b\xaf\xe6\x37\xdd\xb2\x3a\x30\xb0\xdf\xaa\x44\xaf\x92\xe0\x98\xf7\xe7\x6c\x2c\x8d\xcf\x1f\xf1\xf4\xa1\xf5\x77\x15\x8d\x1d\xda\x3c\xbc\xaa\x7f\x69\xe1\x90\xaf\xdf\x19\x90\x5c\x3c\xfa\xe1\x9d\x9d\x8b\x84\xd1\x83\x4b\xfb\x94\xe5\x49\xc3\xfa\x0f\x6a\x52\x6c\x4d\x6b\xb8\xbd\x6c\x5f\xfe\x66\xca\x3b\xa5\x69\x37\x4d\x56\x44\x0c\x23\xf1\x80\xe0\xd6\x49\x1c\x6a\xc2\x57\x2f\xaa\xac\xce\x86\x12\xa8\xb6\x31\xac\xae\xc7\xf0\x5f\xa6\x57\xd9\x5f\xcb\x3a\xdb\x4b\xff\x52\xc6\xed\xfd\x18\xff\x8f\xe6\xab\xf6\xef\x3a\xc5\x9f\xc0\xb2\xd1\x86\x22\xa8\x01\x5d\x9f\x1e\x6e\xaf\x8a\x97\xd4\xc7\xeb\x91\xdf\x80\x0c\x7d\x7a\xd7\x95\xa6\x2a\xa2\xa9\xd7\x33\x89\x8a\xd7\x33\xb6\x68\x24\xca\xa0\x84\x3d\x81\xef\xdb\x68\x22\x9a\xe0\xcc\x66\xf7\x6b\x19\x33\xc7\xe5\xbd\x96\xe1\x5c\xcb\xfa\xc0\xec\x3e\xd0\xd6\x07\x9a\xfa\x40\x63\x1f\xa8\xec\xa3\xc2\x80\xdc\x44\x17\xf5\x2a\x28\xeb\x66\x37\x51\xcf\x5c\xb5\x66\x8e\xd4\x33\x5e\x9c\x62\x6e\xca\x56\x75\xa1\x93\x62\xfe\xac\x1d\x45\xb5\xf7\x11\x17\x21\x7f\xe2\x05\x79\xef\x0b\xaf\xc8\x4f\x3e\xfb\x22\x34\xbf\xf0\x22\xb4\x1c\x99\xf3\x90\x7c\xe2\xc1\xad\xf2\x37\xbb\x1f\x84\xc0\x43\x0f\x41\xde\x83\x9d\xbb\x5e\x78\xf7\xad\xc3\x37\xee\xad\xba\x3f\x38\x75\xd0\xd5\xb3\xdb\x67\x5e\x38\x3d\x6f\x47\xef\x3d\xcc\x4b\xa4\xe7\xeb\x30\xea\xd0\x0b\xd0\xfc\xe2\x4b\xf2\xfe\x17\x49\x87\xfb\xe5\x2f\x1f\x7f\x50\x3e\x41\x3a\xca\x9d\x9f\xbe\xf1\xe6\x7b\x73\x16\x94\xf4\x1b\x78\xcb\xea\x35\x77\x0e\x1f\x54\x79\xfd\x1c\xbc\x17\x57\x32\xbf\x63\xa3\x78\x2f\x8a\x51\x0a\xe3\xa5\xfa\x02\xce\x56\xc2\xb1\x26\xa7\x33\x11\x0e\xd7\x56\x98\x4c\x35\xb5\xbe\xa8\xc9\x35\xd4\x67\x75\x87\xdc\x5f\x66\xac\xa5\x5f\x66\x6c\xd6\x88\x15\x2f\x9c\xd5\x6a\x08\x7d\x9a\x28\xac\x32\x54\x9d\xc8\x20\x43\x07\xf8\x54\xd7\x89\x7e\x85\x28\x8b\x93\x93\xbd\xa2\x3a\xe0\x14\x95\x27\x6b\xb8\x68\x64\x54\xc3\x72\x52\xb3\x27\x63\x25\x9f\x5a\x63\x58\x51\x8f\x49\x60\x1e\xbd\x70\x08\xcb\xf6\x9a\x39\x32\x33\xfb\x91\x67\x97\xf0\xd2\x98\xbe\x7d\xcd\xbb\xdd\x77\xde\xbc\xe6\x7a\xae\x0f\x5f\xe3\xf0\x1b\xe3\x2f\x4e\x1b\x75\x51\x2a\x51\x73\x91\x93\x39\x58\xd3\xa3\x64\x62\xdf\xab\x26\x2e\x58\xca\x32\xc1\xc2\xc0\x98\x1e\x15\xae\x8b\xae\x68\x9d\x66\x89\xc8\x9f\x55\x96\x09\xd3\xcd\x30\x92\x61\x1a\xea\x52\x95\x63\x86\x28\x77\xc8\x7a\x6e\x0c\xbb\x0b\x19\xb0\x16\x37\x32\x9d\x90\x1c\x0e\x0b\xd6\x99\xcd\x16\x0b\xb1\x83\x08\x9c\x00\xc0\x72\x46\xce\xe9\x92\x30\x8f\x7d\x3f\xc9\xbc\x83\x3d\xc2\x62\x2d\xb5\xb2\xf5\x2c\x99\xab\x54\x03\xca\x82\xf9\x9e\x55\x45\x6c\x3d\x46\x01\xe0\x12\x63\xda\x07\xe6\xcf\x47\xac\x30\xe0\x47\x41\xfe\xc3\x73\x7c\xe7\xe8\xec\xe7\xf5\x30\x63\x08\xcc\x2e\x91\x37\xca\xdb\x93\x39\x1f\x15\xbb\xc8\x08\x74\x2b\x37\x1a\x63\x42\x1e\xe5\xa5\x2d\x88\x67\x78\x62\x6e\x7f\x32\x83\xd8\xfd\xa8\x51\xbf\xd7\xf0\x6c\xb4\x90\x07\x7b\xcd\x99\xbf\x71\xec\xad\xf0\xc4\x67\x9d\xf3\x31\x36\x56\x6b\x6a\x60\x6c\x6c\xc7\x63\x71\xdd\xce\x48\x05\xaa\x43\x6b\xd2\x23\xed\x28\x56\x5e\x9e\xaa\x48\xc5\xe3\x85\x3d\x4a\x4a\xa2\x15\x85\x15\xf4\xc0\xf4\xaa\xaf\x28\x2c\x2f\x48\x15\xbc\x9e\x29\xaa\x7e\x3d\x53\x98\x2a\x2a\x4a\x15\xb2\x67\x9d\x93\x5e\x30\xbb\x17\xb4\xf5\x82\xa6\x5e\xd0\xd8\x0b\x2a\x7b\x9d\x73\x4e\x7c\xe4\x9c\x54\x96\x29\x57\x54\xee\x21\xc9\x5d\xa8\xac\xf9\xfe\x7f\x9f\x17\x9e\x8d\x93\x4a\x25\x8a\xb3\xc1\xc5\x12\xdd\xc7\x83\xb9\xe2\xff\x8f\xc3\x22\x0f\xda\xbf\x60\x3f\x0c\xbf\x67\xcb\x94\xd1\xef\x7f\x3c\x62\xd0\xaa\xdb\x2f\x1c\xf0\xff\x3c\x28\xff\x81\x06\xf9\x8f\x6c\xe5\x8a\xb9\x93\xdb\x03\xf2\x3e\xa6\x4f\x43\xdf\x5f\x86\x28\xf8\xeb\x47\xfe\x09\x6e\xa9\x60\x54\x6b\x94\x60\xa5\x82\x81\x8d\x19\x26\x1b\x17\x04\x78\x0f\xb8\xa5\xa7\xaf\xe5\x6e\xe5\x9f\x98\x8c\x79\xeb\x10\x1b\x62\xfb\xf3\x77\x20\x33\xf2\xa3\x8a\xb4\xcf\x82\x90\x4b\x10\x82\x01\xd6\xfb\x44\x86\x35\x1a\xed\x4f\x60\x8c\xbf\x3c\x08\xca\x8a\xd9\x5f\xce\x4d\xca\x06\xb7\xa0\xe7\x8e\x7b\xc5\xdc\x74\xf1\xfe\xcf\xae\x5e\xf9\xdc\xf8\x4d\x17\xad\x79\x66\x5b\xeb\xe0\x21\x6d\xd3\x06\x0e\x98\xc2\x4d\xb8\xf1\xe0\xd3\xab\x26\x6c\x1c\x7b\xf0\xc6\xc1\x53\xa6\x0e\x1a\x74\xe9\x34\x3c\xf7\x44\xbc\xe1\x17\x73\xbf\x20\x13\xde\xed\x57\xd3\x37\xda\x4c\x66\x2e\x5b\x3d\xc6\x61\x37\x5b\x9e\xcc\x98\x9d\x6a\x0d\x19\x52\x3e\x66\x8e\x78\x4c\xe4\x72\x8b\xc7\x1c\x75\xc0\x5e\x07\x6c\x70\xc0\x6c\x07\x34\xe5\x7c\xa8\x74\x80\xcd\x01\xa6\xff\xe3\x77\x3f\xe6\x7c\x6e\xc0\x3f\x28\x23\x69\x37\xac\x7e\xe3\x4e\xce\x5e\xb2\xa8\x32\xa7\x4e\x4d\x59\xf7\x0c\xf5\x1c\x9c\x9d\x53\xae\x86\xe4\x52\x33\xaf\x7d\x26\xcf\x86\x3b\x3e\x83\x8d\x24\xa5\x9a\x79\x49\xde\x0d\xe3\x8f\xc3\x38\xf9\x89\xe3\x9d\xfd\x8e\x1f\xc7\x67\x67\x08\xd3\xc1\xfc\x85\xdf\x88\xf2\x50\x55\xda\x1f\x12\x5d\x2e\x7c\xac\x83\x08\x85\xf3\xed\xc6\x13\x19\xfb\xa7\x28\xf8\x65\x06\xfd\xed\xec\x8c\xf8\x6a\xc5\xe0\x85\x81\x6c\x3d\xbd\x1d\xe3\x05\xba\x64\xb2\x72\x18\x3e\x0d\xf1\x17\x2f\xbf\xe6\x92\x51\xe5\xf1\x8b\x82\x3b\x23\x37\x2f\xb9\x76\x65\xf5\xa8\x29\x97\x8c\xf6\x42\x6b\x80\xe9\xb8\xae\xf1\xca\xfe\xd5\xe3\x53\xf9\xc9\xa9\x05\x97\x4e\xba\x7c\x42\xdf\xcc\xa0\xba\x9e\x3d\xc3\x1b\xc8\x39\x9e\xc2\xec\xa3\xb4\x14\xa2\xb5\xe9\x66\x5f\x90\x65\x11\x26\x26\x1a\x89\x14\x25\x50\x30\x68\x70\xb9\x12\x66\x23\x87\xa2\xf6\x28\xbe\x05\xa3\xf9\x3e\xac\x1e\xb2\x27\x32\x26\x0e\x4c\x5c\x88\x2b\xe3\x76\x73\xdf\x72\xa7\x39\x81\x64\xa1\x57\x72\xac\x84\x7f\x9b\x6f\xcf\x2f\x38\x91\xc9\x3f\xae\x3e\xc9\x59\x89\x83\x73\xe7\xa9\x7e\x09\x35\xf7\xa9\x5b\x65\x16\x0a\x1b\x28\x68\xa8\x51\x2c\x0b\x44\xfc\x66\xa5\xaf\x62\x75\x22\x88\x98\x5a\xfc\xe0\xd4\xec\x81\xfe\xbe\xfd\x47\x8e\xbd\x38\xf0\x60\xf0\x96\x95\xed\x2b\x2f\x1f\x03\xe9\xd1\xbb\xee\xf8\x25\xf4\x94\x63\x52\x8f\x0b\xd8\x4d\xe3\x6f\xa8\xae\x18\x3b\xd9\x3f\x6d\x72\xe6\xe2\x21\xd3\x45\xc6\x3c\xaa\xf1\xf2\xa5\xaf\x04\x2e\xad\xc5\xcf\xdc\xc5\x6d\x67\x1d\x34\x8e\xce\x97\x36\x62\xf5\x5c\x14\xf4\x40\x3a\xdd\xab\xee\x8a\x89\xb8\xa1\xf0\x1f\xf0\x18\xe4\xb5\xdc\xf6\x08\x44\xcb\xe4\xef\xf0\x59\x7b\x47\x9e\xc8\x5d\x8b\xf5\xf8\x22\x74\x63\x7a\xb8\x10\x0c\xe6\xe7\xc7\x43\x79\x79\x89\xa4\xcb\xec\xb4\x39\x1d\x0e\x9b\xdd\x9e\x08\xba\xf2\x59\x9f\x59\x90\xf2\x42\x4e\x87\xcd\x66\x0f\xc5\x7c\x92\xaf\x39\xa3\x84\xcc\xa5\xa9\xf3\xe3\x14\xf5\x7f\x2c\x4f\xc2\x94\x24\x34\x25\xa1\x32\xa9\xab\xf4\xd4\xd3\x4f\x4e\x1d\xad\xa3\xa2\xd9\xdc\xb3\xeb\xd4\xa0\x9b\x64\xd4\x50\xba\x7e\xa0\x5e\x59\xc9\xb8\xe2\x4d\x17\x44\xdd\x12\xef\x51\xef\xab\x59\x17\x8d\x62\xb8\xd2\x99\x2d\x7d\x46\xd9\x04\xfb\x30\xf9\x1b\xc0\xea\x76\xbb\x89\xb9\xbe\xe5\xba\xe0\x1c\x08\x6c\x92\xaa\x7d\x3e\xfb\x4c\xf7\x05\xa3\x3c\x9e\x89\x53\x7b\x96\x5c\x2b\xaf\xe4\xbf\xe8\x7c\xb0\x4f\xdf\x87\x77\xdc\xcd\x5c\xd8\x69\xaa\x70\x0f\x12\x5f\x08\x10\x5e\x99\x29\xff\x97\x1b\x83\x75\x06\x1b\x5a\x9d\x1e\x4b\x92\x34\xf1\x89\xb5\x81\x11\xec\x0e\x91\xb8\x82\x38\x0b\xf7\x46\xc6\xc2\x0a\x10\x75\xc0\xed\x0e\x40\x0e\xc8\xdb\x47\x3f\x4d\x71\x40\xda\x41\xbe\xc5\x5f\x29\xdf\xcc\xd1\x7e\x54\x3e\xe3\x0f\x0d\x9f\x39\x60\xde\xe4\xdc\x73\x48\x4f\x22\x39\x82\x4a\xec\xa6\x13\xb3\x90\xae\x2e\x69\xc8\xcb\x11\xa7\x7f\x14\xdc\x12\xf3\xb0\x47\xef\x7f\xe9\xbe\xc7\x5f\x7c\x65\x0f\xb3\x80\xfb\xd7\x6f\x02\xff\xdb\x6f\x02\xfb\xfc\xc1\x5d\x8f\x1f\xde\x40\xef\xac\x43\x8c\x8b\xf1\xb3\x03\xb1\x9c\xf4\xa5\x4d\x88\xe7\x68\x6d\x26\xaa\x64\x56\xaa\xa5\x99\x88\xc9\xe4\x50\x1f\x88\xf6\x61\x5c\xb4\x38\x13\xa0\x8b\xe4\x89\x0c\xa9\x55\xe6\x26\x67\xd5\x6c\xb1\x59\x39\xc6\xe0\x64\x9c\x1e\xaf\xd9\xc6\xe3\x7b\x6f\x63\x06\x35\x7b\x09\x2a\x24\xa8\xd8\x99\xc5\x5c\x24\x8a\x4c\x33\x4e\x93\xca\x3c\x62\x7d\x8a\x22\x5f\xe1\xc5\xea\x5e\xf9\xa5\xc5\x2d\xc3\xaf\x09\xe4\x4d\xbb\xb5\x6a\xf0\xc4\xc7\xe4\x89\xc2\x02\x31\x5e\xda\xc8\xec\x1e\x0b\x17\x5c\x38\x75\x2e\x9e\x73\x1a\xf3\x14\x73\x07\xbf\x0a\x19\xd1\x05\xe9\x98\x64\x30\x00\xc3\xb1\xac\xc8\x88\x26\xb3\x28\x08\xec\x97\x19\xe1\x13\x03\x29\xab\x44\xa4\x44\x56\x45\xd6\x62\x5c\xf5\x25\x52\x15\x02\xac\xf3\x8a\x58\xef\x67\x53\xe2\x34\x5f\xc7\xa4\x17\xfd\x6f\xec\x9d\xbf\xcb\xc7\x3c\xb5\x08\xde\xbb\x6a\xf1\x82\xce\xc7\x17\x61\x99\x3c\x1d\x63\x2d\x82\x7b\x4d\xa4\x66\x66\xda\xed\x16\x84\x70\xbe\x19\xcb\x23\xc9\xf6\x65\x46\xfa\x94\xf5\x7d\x99\x61\x29\x90\xca\x46\x54\x6b\xeb\xaf\x5e\x07\x75\xda\x6d\x60\x55\x52\x64\xfa\xb3\x6c\xdf\x93\xcf\xdc\xf6\xf0\x89\x83\xf7\xec\x78\xb3\xb1\x5f\xcd\xc0\x9e\xc1\xc6\xbe\xd5\x35\x25\x21\x0f\xd7\xfe\xe6\x6f\x5b\x57\xbf\xf2\xcf\x4d\x1b\x86\x35\x25\x46\x5f\x5f\xd3\x34\xc6\x5f\xdd\x78\x09\xa6\x21\x81\xf1\x4e\x95\x8a\x77\x26\xa7\x6b\x24\xbb\xdd\xd6\x1d\xec\xd8\x8c\x9c\xd1\xe9\x32\xb3\x88\xfd\x7e\x92\xb4\x03\x1d\x21\xba\x9e\x0b\x96\xbb\x60\x8e\x0b\x9a\x5d\x50\xe9\x52\xce\x10\x29\x45\xd1\x6d\x1d\x72\x41\x90\x4a\xb5\x4b\x84\x78\x3d\xb0\x24\x58\x56\xf9\x00\x8f\x1c\xb1\xca\x87\x7e\x14\x60\xd8\x73\x3c\xb3\x3f\xfb\x99\xdd\x25\xdf\x3d\x44\xbe\xa3\x04\xae\x81\xa9\xc9\x9c\x8f\x18\xc3\x4c\x43\x48\xb0\xf1\xab\xec\x09\xb4\x04\x21\x7b\x52\xec\x64\xee\x44\xc8\x21\x1a\x78\xb6\xa6\x73\x04\xaa\x4b\x9b\x11\xd3\x86\x41\xce\x32\x86\x65\x19\x57\x07\x3b\xe2\x69\x97\x1f\x49\x45\x60\xee\x80\x7f\xa6\x25\xb3\x15\x7f\x66\x19\x87\x1f\x35\xd6\xd6\x42\x99\xa3\x16\xff\xbf\xb6\xd5\x51\xab\x8e\x3b\xf0\xdc\x71\xd1\x7c\xf6\x9a\xce\x61\xa8\x27\xe6\x5b\x6d\x5c\xc6\xd6\xc1\xde\xf4\xb4\xad\x40\x1b\xf6\x0f\x74\x54\xc6\x46\x06\x55\xc7\xc4\x43\x12\x5b\xe4\x35\x94\xd6\x8d\x78\xcc\x05\xd6\x73\x69\xcd\x4f\xdb\x21\xb1\x21\x71\x38\xc1\xa0\x48\x24\x02\x2c\x53\xa6\x90\xd5\xaa\xf4\xc7\xeb\x1c\x94\x1f\xc2\xe2\xbe\x37\xad\xd3\x31\x36\x5d\xda\xbd\x4e\x47\x41\x4c\x74\x20\x73\x24\x1d\x8e\x44\x23\x5b\x27\xe5\x47\x6d\xb4\x50\x87\x52\xa7\x83\x14\x5e\x53\x9d\x9f\x28\x45\xcb\x74\x34\x9c\xb7\x4c\x87\x02\x29\x48\x5d\xae\x98\x95\x11\xad\xac\xe2\xf7\xe4\x19\x13\xf1\x33\xfd\x83\x96\xe9\x18\x5b\x17\xe3\xc1\x94\x5b\xa6\x03\x8c\x0b\x0c\x35\xf2\xf1\x1a\xf9\x21\xa5\x4c\x47\x7d\x6d\xbf\xe2\x6e\x65\x3a\xe4\x1b\xf9\xcd\xf2\xbf\xc0\x4a\xec\xb1\x4a\x7d\x07\xd1\xee\x4c\x90\x2c\x2b\xfc\xec\x9d\xf8\xd0\x22\xe4\x7f\x9a\xb1\xd9\xf8\x04\x63\xef\xe8\xda\x77\xc0\xee\xe2\x85\x22\xbc\x6a\x88\xfc\x3d\x5f\x1f\x19\x48\xa1\x2f\x7f\xda\xc6\x90\x3e\xb6\x29\x36\x78\xcd\xe6\x24\x7d\xc8\x3a\x95\xe5\xf6\x29\xd3\xfb\x74\xc1\xf5\xb8\x8f\x37\x6d\x61\xec\x76\xdc\xc9\x83\x3c\xb6\xec\x2c\x6a\xfb\x01\x62\x44\x6b\xcf\x6c\x83\x67\x61\x12\x6d\x4f\x09\xf3\xbb\xfd\x85\xe7\xb4\x4f\x09\xef\x6b\xed\xd1\x4c\xf8\x10\xc8\x1e\x4a\x2c\xed\x40\x98\x0d\x6a\x0f\xb8\x1c\x9c\x48\x3a\xd1\x5e\xb5\x59\xba\x90\x3e\xcf\xfd\x70\x08\xdd\x89\x6a\xd2\xb8\x47\x93\x67\xb6\x67\x99\x67\x83\xe7\xb0\x87\xb7\x7b\x8e\x78\x30\x67\x79\x4a\x3c\x30\xd8\x03\xac\xc7\xe5\x61\x6c\x0a\xc1\xf8\x68\x91\x91\x5a\x5b\xf1\x3f\xc4\x8e\xb0\x1d\x21\x43\x8a\xde\x05\x6e\xb4\x23\x3d\xd1\xc5\xb0\xbc\x03\xf3\x81\x64\x31\x18\xdc\x60\xb7\x5b\x90\xd1\x8a\xac\x9c\x20\x78\x31\x28\xf0\x00\x16\xbc\x6d\x19\xb7\xcb\xc5\xf1\x92\xb9\x2d\x23\x91\xb2\x03\x34\xdf\xa1\xaf\x04\xac\x4d\x02\x33\x2f\x61\xdc\xea\xb0\x1b\x68\x51\x02\x16\x59\x48\xc6\x9e\x6a\x56\x4a\x29\x52\x87\x16\x5d\xee\x5e\x7e\x80\x80\x8a\x54\x6e\x5c\xbf\x66\xf8\xd3\x12\x69\xce\x4e\x50\xd7\xeb\x12\x40\x9c\x38\x59\x07\x0d\x96\xfb\xff\x4b\x7e\x8d\x7d\x85\x3b\x5a\xd1\x39\x60\x10\xb3\xac\xac\x73\xc5\x30\xe6\xab\xf2\x33\x9f\xf7\x5b\x2b\xff\x1b\x2e\x51\xca\x6e\x7c\x21\x6f\xfd\x9b\xbc\xea\x0b\xee\xb1\x77\xe4\xd9\xf8\x2c\xb5\xc8\x13\xf9\xb7\xf8\xcd\x78\x1d\x13\xdf\x93\xf5\x5f\x4c\xf9\xc8\xfb\x14\x40\x5e\x55\x1e\x74\x74\xad\x3d\x90\x57\x6e\x76\x29\x2c\x41\xce\x33\xad\xc3\x40\x79\xa8\x58\xe1\x3b\xd4\xa5\xf0\x03\x98\xcd\x7c\x02\x2c\x75\x16\x3b\x62\xb2\xfb\x7b\x4e\x7b\x19\x9e\x52\xc6\x27\xad\xf1\x31\x67\x0f\x98\x6d\x5a\x87\x6c\xfb\x32\xbd\x7d\x17\x4c\x52\xc7\xb7\x58\x70\x0f\xe7\x56\xa7\xf9\xdc\xf1\x29\xff\x14\xab\xfc\xb3\x1b\xf3\x4f\x10\xf3\x34\x25\x88\x01\xfb\xd3\x76\xab\xd2\x43\x61\x1e\xa5\x0f\x33\x9f\xd2\x54\x8e\xfb\x08\x86\xce\x55\xca\x0c\x1c\x87\x67\xe0\xc7\xf2\x86\xec\x0c\xd4\xf7\x81\xdb\xb3\xd3\x73\xda\xcb\x3d\xe9\x13\x90\xd6\x5c\x07\x78\x0f\x90\xc4\x05\xf5\x09\xf4\xf6\xa3\xe9\x33\x28\xed\xbb\x5e\x52\xc6\xe7\x79\xdc\xc3\x78\x1f\x06\xa0\xe7\x8e\x3f\x92\x3e\x43\xb9\xf2\x0c\xc8\xae\x3d\x03\x21\x89\x01\xc3\xef\x0c\x42\xee\x33\x90\x5a\x51\x6a\x6d\x0e\x0b\x0a\x91\x68\x56\x9b\xcf\xea\x08\x39\x9d\x21\x62\x9d\x36\x1a\x7c\xac\x81\xcd\xcb\x77\x48\x66\xa9\x2d\x63\x35\x9b\x0d\x16\x4b\xa8\x0d\x23\x19\x83\x53\xad\xd7\xd1\xbd\xc6\x43\xaa\xfb\xfd\x42\xb8\x8d\xf2\x1e\xc5\xae\x5a\xdd\x0e\x12\xc6\x11\xa2\x2c\x77\xde\xfa\x1d\xd7\x2e\x2f\x5d\x31\x7f\x3f\x5c\x5e\x2e\x6f\x1d\x72\x4e\x21\x0f\x66\xcc\xc7\xcc\xb8\xce\x27\x3e\x96\x37\xaa\xe5\x3c\xd4\x7d\xfb\x07\x95\x13\x3d\x55\x39\xf1\x89\x22\x27\x80\x1c\x7b\xf0\x3f\x8b\xe5\x84\x25\x67\x9f\x69\x5e\x31\xdd\x83\x6a\x55\xde\x2d\x53\xe5\x50\x7e\x3e\x5e\xa2\x70\x53\x38\x66\x62\xff\x8f\xf6\x32\x33\x90\xf2\x1d\x43\x5a\xe7\x77\x40\xd9\x81\xfc\xa8\xd6\x21\xdb\xbe\x4c\x6f\xdf\x05\xf7\xaa\xe3\x87\xc3\xb8\x47\x7c\x41\x3c\xff\x3c\xe3\x47\xb4\xf6\xcc\x36\x06\xa9\x72\x8e\xd2\x93\x78\x2c\x51\x7d\x6e\x7b\xba\xc7\xd5\xca\x1e\x33\x8c\xb2\xc7\x2c\xed\xc0\x32\xb1\x47\x62\x11\xa5\x87\xba\xc7\x80\x6e\x40\x8f\x71\x37\x70\xbb\x30\x8e\xe9\x9d\x2e\x30\x08\x0c\xe2\xcc\x16\x3b\x68\x95\xb0\x6e\x87\x23\x20\x22\xfc\x23\x29\x89\x75\x0a\x78\x7c\x58\x8f\x1c\xb0\xd8\x87\xc2\x7e\x14\x68\x2c\x23\x05\x62\x68\x4d\x77\x97\x04\xf5\x12\xf8\x24\x10\x25\xb8\x01\x2e\x93\x77\x6c\xc3\xbd\xa7\x6c\x93\x77\xd0\x7f\xe4\xfb\x61\x30\x4c\x87\x29\xf7\xcb\x3b\xc9\xcf\xdb\xe4\x9d\x3b\x60\x9a\x7c\xaf\x52\x9b\x2e\xde\xf5\xa6\xb0\x98\x7f\x06\x79\x50\x18\x25\x49\xec\x4d\x5e\x41\xa1\x37\x3f\x26\x44\x82\x41\xa7\xd5\x66\x73\x46\x44\x2c\x0c\x45\xa7\x58\x5c\x92\x1f\x8b\x04\xf3\x0a\x84\x42\xaf\xa9\x10\x73\x9c\x8d\xe1\x45\xa7\xdd\x22\x20\x93\x0b\x79\xdb\x32\x1c\xa9\x83\xd0\xf8\x6a\xb5\x1a\x97\xf6\x72\xb5\x6a\x6d\xcd\x22\x3b\xcd\x4e\xa1\xa4\x8c\xf8\x30\xb6\x24\xb1\x78\x1c\xf1\x16\xc4\xeb\x13\xd9\x6c\x65\x1f\x24\x5c\x35\x49\xa0\x51\x7b\xec\x8e\xef\xb7\xdf\xf4\xe6\xf1\xa5\x24\x19\xfc\xd3\x3b\xaf\x3d\xfa\xf6\x2d\x6a\xa2\x72\x92\x79\x76\xe2\x5b\xf9\x9d\xcd\x4d\x4b\x1f\x38\x71\x3d\xbf\xf9\xca\x5b\x7e\xbc\xf3\x04\x49\x0b\x9f\xb4\xf4\x93\x6d\xff\xd5\xd3\x94\x17\xb5\x30\xdf\x0d\x96\x6f\xbb\x6c\x44\x67\xb8\x66\x33\x14\xd3\x73\x48\x73\x59\x29\xcf\xf4\x52\x79\xec\x42\x55\xf6\xf8\x7c\x84\x27\xf3\xfc\x21\x33\x9f\xb3\xa7\x67\xb7\x97\x19\xb2\x6e\xee\xb4\x99\xb8\xa4\xc0\xf7\x4f\x5f\x50\x6b\x5e\x9b\x33\x7e\x99\xde\xbe\x4b\xe3\x61\xf0\xfb\x71\x87\xfc\x4b\xf3\x7d\xe7\x8e\x4f\x79\xa6\x97\x2a\xdb\xde\xd1\xe4\x02\x21\x88\x81\xd0\x0d\xa1\x80\xd2\x43\x97\x6d\x34\x67\x92\xd2\xd4\x57\x95\xb7\x7f\x50\x69\x92\xf0\x14\xd2\x6d\x92\x99\x15\x75\x9a\xd4\x1c\xed\x1e\x58\x8e\x98\xf1\x2e\x0f\x48\x17\x99\x2d\x1e\xac\x12\x23\x96\xc1\xec\xec\x30\x80\xc1\xeb\xb3\xe0\x0b\x8e\xf3\x60\xf1\x81\xd5\x21\x86\xd5\xea\x68\x34\x12\x3b\xfd\x59\x45\xce\xe9\xf6\x91\x92\x49\x62\x4a\xcd\x87\xaf\xd7\x8b\x26\x8d\x20\x99\xd7\x90\x2c\xff\x45\x4b\x8a\x5f\x5d\x9e\xcd\x87\xff\x3b\x4d\x88\xff\x42\xcd\x85\x07\x9a\xb7\xf4\x20\xff\x16\xaa\xc2\xe8\xac\xcc\x1c\x8f\x7b\xf3\xab\xaa\x50\x25\x60\xf0\x5c\x52\x92\x9f\xef\x40\x8e\x9e\xd5\xee\x60\x4b\xc6\xed\xad\x44\xe5\x5c\x79\x73\x06\x38\xd0\xe2\xb5\x1b\x1b\xb2\x21\x2a\xe7\xb0\x97\x62\xc2\x4b\xb9\xd4\x1a\xa9\x8a\xd9\xd3\xe7\x55\xb5\xf0\xee\xd1\x77\x9a\x51\x42\x10\xd9\xf8\x6b\xd5\xe0\xf9\xf6\xa9\x77\x36\x4c\xe8\x5d\x37\xf4\x86\xbf\x3d\xfd\x66\xfb\xc0\xd1\x53\xaa\x9b\xc7\xf6\xba\x30\xdd\x67\xd0\xe8\xd1\x03\x87\x0d\x9e\xbf\x2a\xf8\x0a\xc7\x7e\xff\xc9\xbd\xab\x1f\x9e\x95\x4e\x17\x15\x5f\x50\x3b\x79\xe7\xa3\xaf\x36\x3c\x53\xe8\x19\x37\x34\xd5\xd4\xb3\xc7\x15\x03\x07\x5e\xdd\xbb\xcf\xb4\xde\xb5\x7d\x97\xaf\x3c\xc3\x52\x5e\xa0\xf9\x6b\xfc\xa7\x78\x9f\x06\x92\x3b\x02\x0d\xb8\x52\x91\x36\x98\xc6\x04\xd3\xbb\xa9\x77\x3f\x73\x69\xb7\x3b\xa2\x7b\x7b\x11\xb5\x43\x44\x91\x67\xa4\x7d\x43\x07\x08\x07\x1a\xfa\x6a\x5d\x6a\xf5\xf6\xbf\x6a\xed\x99\xb5\xe8\x6b\x55\x9e\xf5\xee\x8d\x7b\x34\xae\x6a\x6c\xc8\xce\xa0\xb6\x1f\xc7\xbf\xac\xb7\xdf\x86\xde\x42\x39\x14\x5d\x78\xc7\x85\xa3\xcf\x69\x5f\xcf\xdf\xac\xd3\x33\x13\x7d\x88\xdb\x53\x79\x46\x3a\xb0\x4c\xbf\x7b\xfa\xf5\x51\x7a\xe8\xbc\x49\xfb\x08\x77\xe9\x73\xdc\x8f\x3e\x47\x25\x4a\x9f\xbe\x7d\x49\x9f\xc6\x9d\x1a\x55\xaa\x0c\x64\x51\x29\x96\x9b\x1f\x70\xa3\x51\x19\xaa\x43\xfd\xd1\xa3\xe9\x4b\xc3\x91\x48\x95\xbb\x3f\x42\xe5\xe5\x3e\x4b\xa0\x30\xd0\xcb\xdd\xab\x44\x34\x18\x4a\xdc\x25\x8d\xe9\x44\x9f\x31\x19\x6f\xf9\x98\x4c\x7f\x84\xff\x92\x1c\xa3\x92\xfe\x0d\xfd\x19\x5b\x18\x4c\x6c\xff\xb0\xd7\x1b\xee\xcf\x3a\x0a\x0a\x42\x2d\x99\x44\x81\xfd\xec\x3c\x23\x87\x23\xd5\x94\x71\x78\x8f\xa5\xa1\x2d\xad\xa7\x83\xa9\x0e\x59\x35\xd8\x51\x31\xb3\x2a\xfe\x88\xb2\x6e\xec\xa5\x96\x97\xcb\xd1\x52\x73\xb3\x91\xa2\x4a\x2d\xfa\x5a\x7b\x2c\x95\x9b\x19\xe8\x53\x8a\xd7\x8b\x45\x59\xc7\x44\x91\x9a\xab\xc4\xb1\x7a\xae\x92\xfc\xc1\xd4\xd4\xf5\x9b\x16\xde\xf2\x28\x93\x9f\x9b\x20\xd8\x7a\xcb\x1b\xef\x7c\xe1\x3f\x53\xfc\xc0\xdc\xe5\x83\x2e\x18\xbb\x36\xc4\x32\x67\xa7\x32\x7d\xdc\xdc\x56\xfe\xe8\x4d\x70\x83\x96\x27\x38\x77\x2e\x49\x6b\xf2\x5f\x32\x76\xe8\xa8\x15\x33\xcf\x28\xd9\x4d\x84\xaf\x1a\xe5\x89\x24\x4f\x0e\xef\xc9\x60\xba\x8f\x8b\xb1\x26\x8a\x90\x73\x3f\xc6\x7f\x44\x87\xc8\x2b\x97\x38\xba\xeb\x64\xff\x68\x5e\x17\xe5\xc1\xa1\x0a\xcf\x2e\x54\x38\x24\x1a\xc5\x1c\x12\xbb\x30\x56\x68\xf5\x74\xe3\xd9\xee\xed\x09\xcf\x5a\x14\x59\xc4\x90\x0e\xd1\x0f\xa3\x71\xad\x43\x6e\xfb\x5f\xb5\xf6\x39\x3c\x1b\x8b\xe1\x0e\x89\x19\x89\x68\x76\x06\xbd\xfd\xcd\xfa\xf8\x33\xd1\x17\x1a\x0f\x12\x92\x58\xa6\x70\x6d\x61\x81\xd2\x43\xe7\x41\x92\x6f\x51\x49\x69\xfa\x37\xed\x33\xa0\xeb\x02\xa4\xa1\x3f\x07\x46\x7f\x55\xb9\xe8\x4f\x69\xcf\xba\xf5\xf6\x02\x6a\x67\x15\x69\x4a\x1a\x73\xff\xca\x41\x7e\xb8\x6d\x08\xb7\x05\x4a\x3f\x6d\xcb\xac\x3d\xaa\xe1\x3e\xdc\xd8\xb8\xe0\x1c\xdc\x47\xc6\x16\x28\xfd\xca\xd8\x33\xdf\x40\x1a\xea\x73\x10\xd4\xb7\xe9\x2c\xd4\x87\x68\x0e\xe1\x77\xdc\x9d\xfc\xc7\x78\xae\x62\x74\x55\x3a\x1d\x71\xf8\x12\x09\xc1\x64\x0a\x32\x0e\xae\xa4\x34\x10\x32\x20\x91\x17\x82\x41\xc1\xed\xce\x6b\xca\xd8\xdc\x60\x63\xdd\x6e\x2b\x63\x2d\x68\xca\x58\xbd\x82\x8d\x89\x30\x58\xb0\xcf\x29\x85\x53\xa5\x70\x44\x8f\x9b\x47\x8d\xad\xaf\xe6\xe6\xd6\x29\x9f\x7c\x0d\xb9\x11\x18\x24\xd4\x3a\x19\xf3\xfa\x8a\x6c\xe0\x75\x7a\xec\x88\x64\x44\xe2\x7f\xab\xbd\xbe\x44\x92\xaf\x77\x15\x64\xab\x26\x26\x98\xbb\x96\x4e\x83\xa2\xa1\x83\x20\x19\xbd\xa3\x6d\x82\xbc\x4b\x7e\xe7\xe3\xdf\xa0\x3f\x38\xfa\xad\x2e\x8a\xb6\xca\xdf\xc6\x36\xde\xfc\xd8\x35\xad\x13\xef\x68\x99\xc9\x07\x16\xf5\x4e\xf4\xba\x7a\x5f\xdd\x12\xb9\xeb\x01\x0c\x3d\xda\xbf\xfe\x23\x30\x50\x5f\x14\xbc\x65\xe9\xec\xdf\xcb\xa9\x0f\xf7\x4d\x5f\x74\xed\xeb\xed\xe3\xa7\x68\x6b\xc5\xed\xa5\xf2\xa9\x45\xc5\x8b\x49\x75\xdf\xf0\x8d\x90\x80\xc4\x53\x89\x6a\xa3\xff\x2c\xde\x78\x80\xee\xdb\x18\x65\x9f\x49\x65\x5f\xca\x4b\xc1\x20\x5e\xdc\x50\x22\x14\x16\xd1\xff\xd1\xbe\x1d\xae\x52\xe4\x2b\x69\x1d\xec\x00\xee\x40\x30\x5f\xeb\x90\x6d\xff\xab\xd6\x9e\x59\x0b\x79\xea\xf8\xa1\x10\x61\xee\x59\xd1\xe0\x79\xc6\x7f\x59\x6f\xbf\x0d\xcc\xb9\xf4\xc4\x6f\x8c\x57\x9e\xa7\xfd\xcd\x3a\x3d\x33\xa1\x40\xe3\x6d\xd2\x81\x65\xc2\x9b\xc2\x79\x4a\x0f\x5d\x56\x0e\xa2\x71\x1a\xbb\xa8\xbf\xd7\x84\xea\xd2\x79\x1c\x6b\x32\x89\xc8\x60\xb0\x98\x25\xc3\x93\x19\x49\xe2\x89\xcb\x01\x01\xfe\x4b\x6a\xd6\xbf\x5a\xa6\xbc\x24\xa7\x2c\x1b\x2d\x49\xf6\xb9\x36\x45\xad\xfe\xf4\xbf\x7f\xfa\xa1\x73\x1d\xc7\x76\xae\xfe\x81\x7d\xe1\xe4\x49\xf9\xba\xcf\x3e\x93\xe7\x9e\x3c\x49\xb1\x61\x69\xd7\x47\xdc\x1b\xdc\x25\x2a\x36\xbc\x32\xdd\xe8\x2f\x08\xc4\xb8\x88\xd7\xcb\x46\xac\xac\xb5\xb8\x24\x10\xf3\x17\x70\x85\x21\x67\x61\x53\x46\x32\x83\x1b\x1f\x14\xa7\x57\x0c\x91\x70\x2b\xbb\xbd\x04\x8e\x95\x40\xba\x04\x4e\x95\xc0\x67\x25\x30\xa7\x04\x9a\x4b\xd4\x1a\x93\xf3\x08\x55\x18\x26\xbe\xac\xe6\x2f\xe4\xa2\x44\x0a\x2f\x7c\xf5\x6a\xf6\x49\x37\x90\xe8\x22\xc8\x90\x24\xa3\x14\x29\xe8\xb0\x3f\x94\xde\x74\x0d\x49\x45\xd9\x3e\xaf\xef\xa1\xd5\xad\x24\x35\xe5\xe6\x99\xbd\xaf\x37\xc0\x1f\xab\x2f\x9a\xb7\x66\x24\xe3\xe1\xe4\x81\x3d\x87\xcf\xb9\x69\x44\x62\xcb\xbc\xc3\x24\x35\xa5\x6e\xd0\xfd\x33\x9e\x20\x99\x2a\x3d\x07\xc0\xfb\xd5\x65\x8c\xad\xfc\xba\x9f\xdb\xa3\x79\x9d\x67\x0a\xe6\x7e\xa5\xc4\xbf\xd1\x18\x74\xca\x1f\x17\xa9\xfc\xb4\x2e\x97\xff\xc2\x42\x38\xe6\x37\xe6\xec\xdf\xd9\xed\xdb\xa9\x5e\x4d\x24\x07\x69\x9e\xff\x71\x7e\x54\x6b\x5e\x9b\x33\xfe\xaf\x5a\x7b\xcc\x4f\x45\xea\xf8\xe1\x30\xee\x10\xbf\x38\x9e\x7f\x9e\xf1\x6f\xd6\xc7\x9f\x09\xf9\x48\x95\x1e\x84\x20\x06\x62\xf3\x63\x11\xa5\x87\x26\xfb\x94\x98\x65\x4a\xd3\x25\x2a\x4d\x76\x95\x26\x3f\x9e\xc2\xff\xa9\x3f\xc4\xb8\x72\xb0\x61\xd7\x9f\x49\x8e\x0e\xc6\x61\x56\x84\x7b\xa4\xab\xcd\x5e\x6f\x71\x32\xcc\xda\xd9\xc2\x58\x61\x3c\x1e\x2b\x28\x48\xc6\x51\x41\x28\x6c\x0f\xba\x58\x03\x0a\x1a\x9a\x32\x41\xaf\x0b\x35\x65\x5c\x24\x3d\xc7\xae\xe4\x28\xcf\x3b\x27\x25\x27\x1b\x8b\xfd\x7f\x64\xe3\xa4\xba\xa7\xe3\xd8\x40\xf1\x04\x74\xcb\xc5\x79\x56\xc8\x4d\xc6\xb1\x3a\x5b\xe4\x6f\x60\x2e\x04\xc6\x3a\xff\x67\x2e\xce\xc5\xd3\xe4\xa9\xe2\x02\x79\xfc\x25\xc4\x7e\x74\x08\x3f\xdb\x47\xfc\x1a\xb2\x16\x4e\xe5\xee\xf8\xb1\xab\x53\x59\x3f\xbf\x9f\xac\x5f\xde\xaa\xbc\xa0\xb2\x1c\xfa\xfa\x29\xb6\xaa\xc7\x75\x9b\xd3\x7a\x38\x0a\xa3\xb3\xb6\x2d\x7b\xd8\xee\xcc\xb5\x6d\xa9\x18\x69\x92\x8e\x77\xd6\xa3\x8f\x72\x31\x55\xef\x2d\xbd\xfb\xe6\x62\x2a\xd5\xa6\xa5\xdb\xce\x24\x0e\x5e\x55\xdb\xd3\xf1\x9d\xd5\xce\xe0\x39\xe3\x37\xf1\x9f\xeb\xe3\xdf\x8b\xbe\xcb\x1d\xbf\xef\x9b\x7d\x07\x75\x1f\x5f\x9e\x46\x6a\xc2\xea\xf4\x6f\x65\x3d\x58\x4e\x38\xf7\x33\x8c\xb3\x03\x3a\x0e\x38\xc3\x8a\x91\x8d\xde\xf5\x46\xbc\x3e\xf5\x14\x17\x28\x63\x6f\x85\x5f\x48\xf8\x67\x5a\x62\x98\xbe\x9d\x7d\x87\xaa\xe3\x2a\xbc\x4b\x6b\x9a\x52\x9d\x23\xa1\xea\x41\xb5\x8a\x8d\x27\x88\x55\x0e\x2c\x3b\x7b\x61\xd9\x69\x76\x75\x97\x9d\x57\x53\x3e\x1c\xac\xf2\xe1\x25\x6a\x7b\x07\x6d\x1f\xc4\xed\x25\x7b\x37\xdd\x1c\x8f\x5f\xa6\x8f\xdf\x05\xfb\xd4\xb3\x11\x0a\xe1\x19\xa2\x8f\x46\x83\xda\xf0\xba\xec\x1c\x4f\xcf\xd2\x60\x15\x47\x7c\xa5\xb7\xc7\x33\x44\x27\x45\x83\xda\xf0\x0e\x7d\x7c\xe1\x5d\x6d\x7c\xe6\x3e\x78\x1e\x6b\xd6\xe4\x5c\xd0\x07\x58\x13\xcc\x33\xbb\xce\xc6\x29\xe3\xf9\xb7\xf4\xf1\xef\x43\xa7\xd4\x73\x44\x1f\xe0\x8e\x60\x9e\x4e\x7d\xce\xfa\xe8\xf4\x4b\x08\xde\x51\xe9\x09\x92\x09\xf2\x0e\xe6\x15\x9c\x43\xff\xd4\x1c\xfa\xd7\x69\x38\x08\x88\xe8\x87\xbc\x07\xf3\x0a\xba\xd1\x4f\xeb\xb4\xd2\xf1\x93\xea\xf8\xd3\x55\x3e\x70\xbb\x31\xdf\x78\xef\xf6\xe6\x19\x72\x6d\x11\xbd\xbb\xbe\x15\x6e\xe0\xdf\xb2\x27\xd0\x10\xba\x9e\xa7\xb9\x7f\xa1\x11\xa8\x00\xf3\x7e\x39\x62\x8a\x2b\x49\x85\x81\xe5\xc5\xa7\x8a\xd9\x0e\x76\xe0\x81\xe2\x0a\xc1\x49\xac\xa5\xb8\x73\x23\xe9\xab\xda\x9d\x9c\x02\xda\xa8\xe2\x91\x6f\xf9\xd9\x58\x46\xc4\x50\x0f\x74\x47\x7a\x02\x4a\xd8\x9c\x1e\xde\x1b\x89\xf8\x43\xe1\xb0\xd7\xe7\xab\x10\x84\xaa\xca\x88\x27\xe4\xf4\x38\x67\x66\xfc\x36\x4f\xc4\xc3\x48\xac\x27\x1d\xcc\x1f\xea\xf1\x18\xbd\x90\x28\x28\x31\x96\x34\x65\x90\x8d\x45\x46\xbb\x31\x6a\x64\x4d\xac\xd1\xc6\x16\xa8\xe5\x0e\x4e\x55\xc1\x9c\x2a\x68\xae\x52\xd3\xc0\x88\x20\xa1\x31\x93\x9a\x8e\xe7\x6c\xa0\x55\x52\xd5\x54\x62\x3d\x07\x45\xb5\x97\x9e\x55\xf8\x40\x49\x3a\xa7\xe5\x49\xeb\x63\x4a\x3a\x92\x5a\x01\x01\xce\xae\x80\x70\xc3\x97\xdb\x96\xed\xc8\x17\x18\x8b\x35\x20\x1f\x8f\x41\x41\x1e\x78\x42\x2b\x63\x37\xfd\x5e\xa9\x85\x30\xf3\xe6\x51\x93\x27\x4f\x5d\x4e\x4a\x21\xbc\xfc\xf0\xd3\x30\xf5\x99\xa9\xad\xde\x49\x83\x16\xef\x5a\xbf\x7e\xd7\x99\x66\x5a\x0e\xe1\xfa\x33\xb3\xae\xbd\x62\x45\x17\x9a\xf5\x67\xa4\xd9\xf7\xf8\x75\x54\x6e\x14\xab\x72\xe3\x51\x45\x6e\xa8\x36\xd3\xbd\x16\x5b\x37\xcc\xa9\xe0\xda\x49\x3a\x0e\x5e\x8f\xfe\x82\x72\x91\xf6\x75\xb1\x78\x37\x1c\xac\xd8\x4c\x23\xda\xf8\x58\x6e\x6c\xce\xb5\xc9\xda\x0e\xdb\x7c\xe7\x8c\x3f\x80\xca\x8d\xa1\xaa\xdc\xf8\x2c\x77\xfc\xf8\x83\xf1\xf2\x73\xc7\x17\x3e\xd2\xe9\xbf\x0f\xee\x04\x2b\xe5\x77\x6a\xc4\x7d\xcc\x6c\xed\x6e\xff\x54\xe8\x7f\x4b\x1f\xff\x3e\xf4\xb7\x5c\xdc\xbf\x3e\x5a\xd0\x1d\xf7\x17\xca\x13\x49\x6d\x5f\x7d\xfc\xad\xcc\x20\x45\xd6\x00\xd8\x36\xdb\x42\xea\xe0\xea\xd8\xf2\x55\xa4\xb6\x84\x3e\xf6\x56\x68\xc2\x18\x04\xe3\x34\x26\x6e\x8f\x43\x47\xd7\xfd\x07\xe2\x95\x56\xc3\xd9\xf6\x6a\xdd\x9e\x8c\xcf\xc6\x4d\xb9\x6b\x63\x7d\xda\xea\x3e\x67\x6d\xc6\xe4\xe8\x20\xeb\xa8\x5e\xab\xaf\x4d\xc1\xce\x82\xe2\x6e\x6b\x43\xeb\xec\xd2\xf1\x4b\x55\xd9\xf4\x88\x3a\x7e\x2c\x86\xc7\x4f\x6c\x48\x44\xd9\x9c\x7b\x5b\xa9\xd3\x40\xc7\x1f\xae\xde\xf3\xbc\x3a\x7e\x4d\x0d\xd1\xe4\xaf\x68\x48\xb1\x91\x73\xc6\x8f\x68\xe3\xe3\xbd\xd5\xec\xed\xd1\x28\x1e\x3f\x7e\x2c\x5e\x76\x9e\xf1\x3f\xd7\xc7\xbf\x17\xfd\xac\x8e\x8f\xef\xdc\x04\x53\xb7\xa5\xae\xf1\xdc\xf1\xe9\xde\x96\xaa\x7b\xfb\x85\xba\xb7\x64\xf8\xe8\xf6\x68\x01\x9b\x8b\x53\xd4\xf1\xdf\xd2\xc7\xbf\x0f\x8c\xea\xde\x92\xe1\x53\x5b\x52\xb5\xda\xf0\xaa\xec\x93\x1b\x48\x1d\x62\x7d\x7d\x7e\x65\x04\xea\xa7\x82\xa2\x22\x77\x12\x62\x1d\x5d\x87\x0f\xc4\x12\xca\x14\x65\xc8\x91\x33\x87\x30\x4c\x9b\xc3\x70\x86\xf6\x21\xcf\xd0\xab\x17\x59\xa3\x9b\x1a\x6a\xba\x3d\x83\x62\x4b\x26\x7b\x50\xa6\xee\xc1\xa6\x6e\x3e\x83\x87\x9c\x66\xce\xd8\x5d\xa7\xe3\xf6\x88\x8b\x71\xfb\x11\x6a\xfb\x38\x6a\x52\xef\x07\x06\x3f\xf4\x17\xd1\xa0\x5f\xd2\x35\x35\x6a\x23\x13\x1a\xf9\x15\xc8\x85\xa5\xdf\xf2\xf4\x40\xa7\xcb\x6d\x45\xc8\xe5\xb2\xfa\x68\xf1\x48\x52\xc4\xd0\x62\xb5\x06\x48\x15\xc3\x29\x19\xb7\xcf\xeb\x71\xf2\x06\x7e\x6a\xc6\x66\x36\x19\x66\x1b\x96\x19\x18\x9f\xc1\x67\xb0\x5a\x8c\x12\xeb\xe2\x14\xfb\x19\xc9\x04\xcb\x96\xe0\xd4\x42\x8c\x95\xb0\x3e\x2d\xca\x18\x52\x7a\xb9\x90\x6a\xa7\x1e\x23\xa0\xf9\x7e\x68\x52\x25\x0d\x31\x26\x92\xcc\x44\x8a\x26\x68\x85\x8a\xdf\x58\x12\x5b\x92\x80\x64\x82\x99\x87\x6f\x8a\x04\xfe\xe1\xcd\x85\x89\xce\xdb\x12\xa4\x66\x31\xe7\xd9\xf5\x22\xfe\xdf\xae\xd3\xdf\xb2\xcd\xaf\xbc\xa2\xd7\x02\xe0\x56\x51\xf9\xbd\x2e\xdd\xe4\x8c\x47\xf3\x63\x79\x41\x81\x03\x0e\x2b\x98\xb1\x58\x28\xcf\x63\xb1\xe4\xc5\x0b\xb8\xfc\x68\xfe\xcc\x0c\xd0\x80\x4e\x89\x8d\x12\xf1\x1d\x8d\x1a\x51\x0c\x5c\x41\x9f\x5d\x30\x86\x9c\x8e\x3c\x8f\xd1\xd7\x9c\x89\x1a\xab\x8c\x69\x23\x16\xe1\xc4\x5d\x1a\xa7\x29\xef\x4a\xee\xab\x12\xf9\xd1\xd0\x40\xb2\x2e\xb3\x32\xfb\x6c\xeb\xa1\x5e\x13\x85\x44\x4f\x0b\xff\xa3\x8c\x06\x7d\x74\x26\x13\x82\x86\x98\xfc\x6a\x3c\xac\x25\xc0\x2f\x94\x4f\x5e\x43\x73\xe3\xaf\x91\xbf\xfa\x7c\x5d\x6c\x5d\x88\x7f\x6b\xfd\xae\x3f\xac\xd1\xd2\xe0\xef\x63\xca\x94\xfc\xf8\x37\xb8\xbb\x77\xad\x57\x7d\x2e\xeb\xc4\xb0\xe6\xa3\x91\x98\xbf\xe4\xf8\x80\x2c\x8f\x5a\x02\xdd\x75\xf5\xae\x7f\xe2\xf6\xb5\x54\x7f\x53\x74\xfb\x6d\x4f\xe6\x58\x0d\x2c\x8b\xcf\x6e\x4f\xc7\x0f\x50\x99\x5f\xae\xca\x70\x56\x95\xf9\x8a\x97\xe9\x01\x5e\x3c\xdb\xce\xc0\x7c\x4a\x65\xbe\x32\xfe\xfa\xd7\x72\xad\x12\xb7\xe5\xb6\xd6\xc7\xbf\x94\xca\x05\x85\x7e\x0e\xe5\xd0\x2f\x1e\x11\x6d\xe7\xb1\x35\x14\x53\xb9\xa0\x8c\x7f\xef\x2b\x39\xe3\x8b\x4f\x88\xf6\xb3\x9e\xf7\x24\xad\xf3\xb1\x42\xa7\x7f\x6b\xd7\x32\xd5\x2e\x24\x76\x74\x5d\x71\x40\x74\x69\x52\x19\xb7\xfd\x58\xa9\x09\x82\xdb\x8e\x54\xdb\xce\xa5\x6d\x19\xc6\xd4\xd1\x95\x39\x60\xf2\x71\x7a\x5b\xea\x7b\xbb\x8b\xca\x9b\x72\xf5\x6e\x90\x54\x79\x43\xdd\x69\x07\x38\x21\xe7\x2e\x51\xeb\x63\x58\x69\x9e\xd1\xc0\x74\xa9\x52\x1f\x83\xe3\xc1\x46\xed\xbd\xa7\x68\x76\xdb\x0e\x5a\x13\x3b\x4a\xeb\x63\xec\xa5\x49\x70\x95\x3c\xfc\xcf\x7a\x18\xe4\xdd\xb6\xb4\xa8\x09\x29\x67\x42\xe8\xe9\xfa\x4e\x98\xce\xaf\xb0\x6b\xbe\xb7\x0a\x38\x86\xe7\xcd\x4b\xbb\x41\x9c\x2d\x76\x89\x0c\x8a\x20\x68\x43\xb3\xd1\x5e\xf4\x23\xe2\x5a\xe7\x2a\x21\x04\x64\x3d\xb1\x8c\xba\x8b\x62\x28\xfa\xcc\x68\x14\xd3\x80\xfb\x15\xa7\xc3\x95\xc1\xa6\x20\x73\x2c\x08\x2c\xe3\xb2\xb9\xda\x5c\x4c\xa3\x6b\x99\x6b\xaf\xeb\x47\x17\x87\x5c\xa7\x5c\x0c\x29\x8e\x58\x5b\x3b\xb7\x95\x8e\x41\x6a\x8b\x32\x54\x6e\x55\xa8\x72\x68\xa1\x22\x1b\x5d\x2e\xe2\x6e\x20\xc0\xd9\xef\x64\xad\xd9\x7d\x51\xeb\xaf\xfc\x9b\xff\x15\x99\x69\x45\xc9\x9e\x12\x56\xee\x7d\x16\xbf\xdb\xe7\xf0\xa4\x6d\x4e\x87\x11\x89\x9c\x64\xb0\x21\x8e\x64\x9e\x92\x22\x01\x7e\xd8\xe1\x87\xa8\x1f\xf6\xfa\x61\xb9\x56\x54\x72\xae\x5e\x29\x81\x56\x5e\x69\x4c\x05\xdf\x6e\xc8\x8d\x82\x61\xbb\x95\x5f\x11\xe3\xc9\xb8\x18\xaf\x87\x54\x5d\xb7\x0a\x2c\xcc\x56\x7e\xf3\x23\xdc\x7f\x1f\xe7\x21\xfd\xa5\x3c\x31\xa7\x12\x8b\x70\x59\xde\x91\x23\x79\xd0\x9f\xde\xeb\x0d\xa4\x86\x37\x7e\xbe\x1e\x8a\xec\x87\x95\xca\xf3\x39\x1c\x58\xf6\x5b\x3a\xba\x1a\x0e\x58\x9c\x9c\x94\x2b\xfb\xf1\xba\x36\x90\x1a\x2e\xb8\xcf\x68\xa5\x0f\xea\xd4\xfa\xf8\x68\x9f\x39\x67\xf5\xd1\xea\xbe\xd0\xdc\xe0\x0b\xd2\x31\x23\x66\x11\x13\x29\x40\x6a\xe2\xcc\x4a\xb5\x17\xce\x60\xe3\x6d\x6a\x49\x97\x26\x8b\x22\x7a\x2b\x69\xaa\x41\xce\x2b\x2c\x74\xd7\x3a\x29\xe2\xe2\xea\x56\xc4\x05\xb3\xcb\x45\x70\x2c\xa7\x86\x0b\xd7\x5b\x4e\xeb\x35\x5c\x14\x9e\xe6\x66\x51\xfd\xa7\x52\xd1\x7f\xd0\x93\xaa\x3e\x20\xe0\x7d\x14\x6e\x16\x24\xc4\xe5\xde\x89\xe4\x2c\x5e\x21\xb6\xe1\xf6\x4d\x8a\x3f\xb9\xba\x89\xfa\x93\x19\xea\x4f\xf6\x9d\xeb\x4f\xc6\x6b\x32\x8b\xae\x63\xa5\xba\x8e\xfd\x95\x35\x31\x99\xf0\x3a\xe2\xf3\x78\xfc\x80\x68\x56\xa6\xd0\xef\xd0\x53\x72\x83\x7a\x26\x95\x39\x7e\xdd\x41\x7b\x48\x12\x5e\x45\xbe\xa3\x6b\xd8\x01\xde\xa8\x4c\x42\x7a\xa8\xcf\x30\x8f\x9e\x03\x65\x8e\xd3\xcc\x57\x6a\x1c\x80\x58\x29\x42\x07\xdc\xae\x4e\xa1\xe1\x2a\xf2\x0c\xef\x51\xfe\x6f\x52\xdb\x0f\xc5\xb7\x69\x49\xda\x89\xd0\x06\x04\x95\x36\x00\x0c\xb5\xf8\x4a\xbe\x91\x67\x3a\xe0\x37\x75\x36\x45\x8b\x80\x56\x35\x8e\x47\xad\x97\xae\x3d\x17\xc6\x12\xab\x3b\x6f\xa3\x32\x46\xe8\x80\x92\x03\x82\x01\x65\x6d\xcf\x64\xbe\x5d\xd9\xf9\x70\xdb\x30\x6e\x1b\xfa\x03\x9d\x0e\xc8\xba\xbd\x9e\x95\x1d\x34\xd8\x47\x89\x25\xfe\x5e\xad\xc9\x6e\x41\xcd\xe9\x52\xd1\x68\x32\x08\x82\xc9\xc4\x01\xcf\x33\x08\x99\xad\x36\x30\xb2\x9c\x24\x0a\x8c\x01\xff\x41\x3c\xe6\x9c\xee\xef\x88\xa0\xe9\x28\x39\x55\x02\x94\x84\x2c\x95\x55\x68\x20\x1a\x66\x95\x22\x91\x27\xa5\xdb\x5b\xef\x2c\xbf\x73\x2d\x24\xaf\x86\xe6\x32\x79\xdf\x28\xe6\xa7\x0a\xf8\x3c\xfd\xf7\x0b\x98\x43\x9d\x47\xef\x3a\x7e\x97\x7c\xed\x09\xe5\xbe\xc5\x48\x86\x59\x4e\x6b\x14\x4d\x4c\x57\x19\x4c\x22\xa2\xa5\x55\x25\x51\xb4\xe0\x0b\x02\xcc\x16\x86\x33\xf1\x46\x83\xc0\x4a\xf8\x0f\x08\x40\x2b\x89\x9d\xb2\xc0\x5e\x52\xa7\x08\x94\x92\x6f\xdd\xa8\xd2\x4b\x17\x38\xb5\x84\xf6\x12\x50\xe9\xaa\xc7\x9b\xd0\x47\xfe\xe6\xaa\x75\x25\x37\xdf\x0c\x81\xab\x6e\x2f\xdd\xc0\xf4\x1c\xf4\xc1\x20\xe6\xe5\xce\x0f\x87\xbf\x3f\x52\xc7\x4d\x76\xcd\x07\xaf\xc6\x03\xe1\x3d\x27\x1e\x78\x5b\x07\xf0\x07\x6c\x4e\xcd\x09\xaf\xe1\xa6\x5b\xa9\xde\xde\xa2\xea\xed\xb3\x94\xf6\xd4\xa4\xd5\x01\xa1\x03\xf9\x51\xcd\x08\x5b\xab\xf0\x2d\xa9\x51\xae\x8f\xff\x2b\xac\x55\xf8\xd6\xed\xc6\x7c\x6b\xef\xe8\x9a\x71\xc0\xee\x51\x26\xe8\x76\xfe\x6f\xe5\x46\x69\x73\xe0\x3e\x66\xa5\x4f\x41\x01\xe6\xdc\x30\x01\xf8\xe1\xb8\x32\x89\xde\x27\x8b\xff\x7a\xaa\x18\xff\x65\xf5\x36\xa4\xb1\x04\x8e\x3f\x3a\x7c\xdd\x62\x09\x94\xe7\xf8\x55\xb7\x25\xaf\x03\x47\xae\x2d\x2f\x72\x38\x52\xd4\xcd\x96\x6c\xc0\xe3\x8f\xc7\x67\x23\x89\xdb\xbf\x46\x7a\x88\x27\xba\x30\x72\x44\xc9\xb4\x1d\x90\x71\x87\x11\xaa\x8a\xa7\x14\x33\x50\xc0\x62\xfa\x3a\xf7\xeb\xf4\x69\xac\x5e\x4b\xeb\xf8\x63\x59\xbf\x8f\xbf\x0b\x25\xd0\xa5\xe9\x3a\xc6\xec\x36\x47\x43\x2e\xbf\xdb\xef\xf3\xb9\xbd\x9e\xa8\xa7\x38\xe9\x0d\x79\x5c\x28\x1c\xb6\xb5\x65\xc2\x9c\xdf\xc7\x7a\x9c\xfa\x7b\x16\x76\x14\xc3\x94\x62\x48\x17\x43\x56\x6e\x37\xaa\xa5\x93\xb3\x01\x9a\x39\x65\xa9\x94\xb7\x73\xa8\xfe\x4c\x25\x87\x99\x98\x46\xb1\x58\x0b\x01\x41\x55\x75\x85\x29\xf2\xca\x4c\xd6\xca\xb0\x23\xe5\x9f\xae\xfd\x4f\x61\x53\x6a\x5c\xa6\xb8\x57\x60\xc1\x75\x53\x9e\x59\x61\xdf\x23\x7f\xf4\x6e\x03\x14\x48\x31\xae\x0d\xd0\x66\xd8\xe0\x1e\xd0\x63\xf1\x9b\xee\x7f\x2c\xe8\xdf\xb0\xe6\x4f\x10\x5d\xd8\x7b\xc2\x94\x31\x1b\x5b\xce\xac\xe2\x06\x42\xbf\x01\x1d\xab\x6e\x96\xef\x1c\x3c\x4b\x7e\xe4\xd4\xf1\x4b\xa9\x1c\xc6\x77\x22\xa9\x8d\x94\x44\xd3\xd2\x35\x4c\x91\xcd\xeb\xb1\xdb\x1d\x62\x51\x91\x31\x16\x73\x94\x14\xdb\x1c\x06\x91\x33\x17\x15\x22\x67\x30\xec\xf0\x84\xcd\xf8\x8a\xa2\xd7\x94\xd7\x63\x0b\xd3\x2a\x6b\x25\xa0\x15\xb0\xd1\x8a\xcc\x29\x2c\xed\xec\x56\xa4\x43\x8f\x4c\xd1\x6e\xa9\xee\xf5\x92\xac\x4c\x2e\x6e\xb4\x02\xb3\x4e\xbd\xb6\x6e\xea\x56\x39\x89\x17\x0d\x9c\x06\x1d\xef\x0e\xec\xa5\x37\xd8\x90\x49\xcc\x86\x9c\x22\x4a\x7c\x79\x43\x1f\xb7\x8a\x1f\xcf\xfc\xfb\xe6\xed\x48\xb3\xe5\x08\x3e\x8a\xeb\xaa\x55\x5d\xfe\xb8\x6a\x03\x54\xe2\x50\x96\x87\xa3\xdd\xe2\x3e\x14\x3b\xfe\x24\xdd\xee\xbf\x9e\x54\x56\xc8\xf1\x43\x2c\x08\xe5\x77\xb3\xfb\x9f\x15\x57\x82\xf5\xbd\x6f\x72\xe3\x5c\xa2\xbb\xa2\xc5\xe7\x19\xff\x73\x7d\xfc\x7b\x21\x9a\x3b\x7e\xfe\xbe\xfc\xc4\x79\xc6\x77\xe8\xe3\xb3\x58\x6e\x23\x14\xfc\x03\xcb\xd0\x28\x14\x7c\x8a\x0d\x07\xf2\x13\x7a\x20\x4a\xad\x3a\x07\xef\xcf\xfa\x46\x98\xed\xd0\x40\xe3\x06\xad\x2c\x43\x5d\x11\xc1\xf7\x83\x71\xdd\x15\xa1\xfa\xa9\xae\xe8\xfa\xc5\x90\xe2\x6f\xa1\x75\x8e\x6e\x4f\x8f\x75\x7a\x1d\x6e\xbb\xdd\xe3\x09\x05\xbd\x41\xab\x35\xce\xf3\xc9\x84\xc3\xdd\x96\x71\x90\xc8\x39\x07\xac\x73\x40\x5f\x07\xb0\x36\x07\xde\x18\x87\x03\x59\x2c\x76\x12\xae\x14\x0a\x1b\xc3\x6d\x19\x23\x17\xf4\x33\xfe\xb6\x0c\xe3\xa2\xaf\xa8\x21\xc2\xb9\x89\xd6\xdd\x69\xcd\xbe\x65\x4f\x2b\x88\xfb\xbf\x5e\xea\x53\xad\xa5\xc3\xa8\x0a\x46\x4c\x88\x47\xc9\xeb\x6b\x48\x20\x40\x24\x27\x8e\xae\xa8\xba\xde\x45\x32\xc5\x68\xd8\x2f\x7b\x57\xe3\x9d\xf2\xe7\xf2\x4b\x0b\xbe\x84\xbe\x1d\x4d\x7d\x1a\xd9\xa7\xca\x3b\x2f\x1f\xc4\x4c\x2e\xeb\xdc\x39\x8c\x79\xb9\xe2\xf4\xe6\xe9\x43\x0e\x44\xa6\x79\x96\xbd\x74\xcb\xf0\x27\x8c\xd0\x13\xbc\xbb\xa0\xcf\xf7\xd7\xf3\x02\x0d\xb0\x5b\xf7\xf5\xa7\x6e\x76\xbb\x51\x1a\xbb\xeb\xe7\x65\x0f\xfd\x0e\xa3\xd7\xde\x5d\xdf\x89\x6d\xdc\x68\x6a\x27\xab\x43\x6b\xd3\xa3\x8a\x5d\x41\x4b\x41\x1d\xc3\x14\x14\x54\xb9\xaa\x22\xa2\xc1\x10\x71\x45\xea\x7b\xa1\x5e\xe0\x67\xeb\xd0\x98\x4c\x1d\xad\x91\x59\x17\xa9\x63\x2c\x7c\x5d\x9d\xdd\x97\x97\x1a\x93\xc9\xf3\xf9\x0a\x9b\x32\x3e\x3b\x5f\x66\x2f\x6b\xc9\x70\xa2\x5b\x2c\x14\x59\xd1\x64\xb2\x7b\x51\x23\xa9\xc1\xa1\x04\xda\xe7\x56\x01\xa0\x69\x1e\xdd\x5f\xa9\xee\xd0\xea\xf4\x34\x9c\x53\x36\x33\x99\x5b\x3b\x53\xf7\x4f\xd7\x64\x5f\x74\x06\xba\x87\x7a\xbd\xee\xa1\xfe\xcf\xc2\x81\x1f\xdf\xac\x14\xfe\xba\x7e\xcf\xe0\x2d\x5f\x13\xbf\x74\x25\x29\xff\x75\xe5\x8c\x79\x37\x0e\x67\xbe\x3d\xdb\x31\xbd\x65\xc4\x28\xa5\x1c\xd8\x80\xe1\xb7\x11\x97\xf4\x33\xa4\x28\xd8\xd2\x35\x0b\xfe\x71\x8b\xe2\x94\x56\xe5\xf9\x41\x7a\x2f\xd5\xaa\xf7\xd2\xdb\x8a\x2f\xce\x4f\x22\x48\x49\xcc\xa0\x3f\xa4\x29\xf4\x1a\x36\xf8\x23\xe5\xcf\xf1\xca\xbd\x84\x9e\x56\xf1\x97\x1b\x8b\x73\xf7\x8f\x6e\x9f\xe8\x3a\x0b\x4f\x91\xf7\x12\xe8\xe3\xff\x0a\x77\x29\xb1\xb3\xf9\xf9\xee\x24\x13\xe8\xe8\xda\x70\x20\x10\xe6\xba\xdb\x24\x7e\x90\x1b\x48\xfd\x2a\x75\x0e\x8c\xa7\xb6\xd1\x5b\x29\x10\xc0\xb7\x92\xa7\x43\xee\x38\xe0\x09\x2a\x93\x64\xf1\x14\x7e\x86\x32\x6d\x0e\x09\x69\x71\x8c\x0c\x89\xf5\x61\x82\xed\xc1\xe8\xd9\x36\x09\xf6\x38\xbd\x93\xe8\xf8\xcc\xba\xcb\x95\x1b\xc9\x4d\x1e\xc1\xbb\xd5\x9b\x27\xba\xba\xe9\x73\xf4\xbd\x04\x74\x8d\xea\xd4\x35\x3a\xa0\xdc\xc5\x25\xf8\xc6\x2b\xe9\x80\xf2\x03\x25\xe5\xac\x37\xbb\x46\xa4\xd6\x55\x4f\xba\x46\x13\xd4\xbb\x3b\xaa\xb4\x4f\x10\xef\x29\x89\x1f\x49\x94\x08\x81\x6c\x7b\x65\xfc\x32\x7d\xfc\x2e\x28\x53\xef\xc8\xd2\x52\x3c\x43\xe5\xe6\xca\x12\x6d\x78\x87\x36\x7e\x05\xa5\x7f\x82\x6a\x73\x57\x7d\x17\x90\x4c\xe2\x19\xca\x2f\x2d\x4f\x68\xc3\xd3\xf6\x01\x79\x22\x79\xaf\x82\x36\x3e\x5a\x8c\x75\x3a\x45\xbf\x2c\x23\x71\x07\x65\x7d\xd8\x84\x8e\xfd\x7c\xf8\x5e\xa9\xe0\x46\xe8\xb4\x2f\xa6\xb6\x67\xd2\xb6\x98\xb4\x2d\xee\x25\x20\xbd\xed\x59\x74\xe3\x75\x9f\xac\xd2\x51\x42\x56\xa6\xec\xd9\xb2\x9e\xe7\xd0\x3d\x28\x87\xee\x75\xe8\x4d\xb5\x7d\x82\xac\x4c\xf1\xde\xe2\x1e\xdd\xe8\xbe\x03\xd3\x7d\x2d\xe5\x9d\x7a\x84\xec\x84\x96\x6d\x74\x3f\x7a\x63\xbd\xec\x14\xdf\x0b\x7f\x3f\x91\x56\xc9\x58\xfc\xb9\x72\x5f\xd0\x77\x2e\x50\x7a\xea\x55\x7a\x46\xa8\xe3\x1b\x0c\x24\x1a\x74\xac\xd1\xce\xe5\xfa\x74\x26\x74\x9d\xe2\xe6\x52\x9c\x3b\x51\xc5\xd5\x5f\x62\x5c\x4d\x9e\x35\xd4\xc1\xd4\x1c\x08\x45\x45\x8b\x6a\x0d\xcd\xbe\xcf\xc1\x46\x6b\xaa\x09\x60\x34\x0a\x66\xd6\x6e\xb5\x3a\x38\xd1\x28\x4e\xcd\xe0\x9f\x2d\x82\x13\x99\x2c\x26\x22\x4d\xb1\xdc\x54\xb2\x54\x72\xea\x7f\x3a\x73\x5e\xe5\xa7\xbe\xa1\x82\x14\xbf\x22\xc6\x71\x6a\x67\x51\x5f\xfc\x30\xe4\x44\xd1\x89\xc5\xf2\x5f\x17\x7f\x51\xf4\xc5\x10\xed\x05\x10\xf2\xa6\xe7\x3b\x6f\x63\xe6\x3d\x0f\x57\x9f\xa0\xef\x29\x0a\xaa\x75\xc5\x62\x68\x72\xba\xda\x6e\xb1\xb0\x6e\x49\x0a\xb2\x11\x36\x5e\x60\xb3\x5a\xd2\x2e\xa3\xc5\x88\x25\x97\x20\xa4\xad\xcc\x28\x52\x59\x0c\xff\x16\xd9\x2d\x36\x94\xaf\x56\x17\xcb\x2a\xa4\x98\x22\xbc\x14\x5a\x84\xfd\xdb\xd5\xdd\xee\x7e\xad\xdc\x36\xad\x7d\x50\xaf\x57\x16\xa3\x7f\xbb\x57\x17\x73\xdf\x50\xb8\xac\x42\xaf\x30\x56\x71\xb0\xe8\xa0\x37\xb7\xca\xd8\xac\xe7\xbf\x24\x65\xc6\xbe\x7c\x7e\xbe\x56\x67\x4c\x8f\xcf\x0b\x6b\xf1\x76\x12\x03\x5b\x72\xe3\xff\xa2\x0b\xa2\xe5\xdd\xe2\xf3\x14\x1f\xec\xcb\xba\xcf\x76\x1b\x04\xbb\xc5\x24\xb4\x27\xaa\xbb\xf9\x6c\x95\x78\xbe\x87\xb4\xf1\x31\x16\x78\x1b\x86\xe5\xc4\x17\x2e\xf4\x07\xcf\x33\xfe\x24\x7d\xfc\xf5\xe0\xee\xe6\x73\xbe\x32\x1c\x3d\x77\x7c\x8a\x1d\x7a\xa9\xd8\xa1\x23\x97\xfe\xe0\xca\x60\xc1\x79\xc6\xff\x5c\x1f\xff\x5e\x30\xe5\x8e\x1f\x5d\x11\x2d\x39\xcf\xf8\xcf\xe8\xf4\xdf\x0f\x87\x31\xf6\xa1\x3e\x53\xe2\xc8\x62\x20\xff\x2a\x2d\x82\x51\x8f\xb7\xa1\x73\x08\x57\xe9\x73\xdc\x8f\x7e\xd5\xfc\xd4\xd4\xa0\x0e\xf1\x66\xcd\xb3\xad\xf7\x51\xe6\x71\xe8\xcf\x41\xa2\x11\x29\xde\x60\x80\x86\x3d\xfa\xde\xf4\x45\xf5\x69\x6a\x75\xff\x39\xdf\x37\xeb\x6f\xc7\x18\xa5\x55\xeb\x43\xdd\xe1\xf9\xc7\xf3\x13\xfa\x34\x6a\x9f\x85\xf8\x2c\xff\x93\x9e\xe5\x5e\xaa\x2f\xe1\x6e\x55\xae\x04\x3b\xba\xd6\x1f\x08\x26\xd4\xd5\xa2\xcf\x41\xeb\x36\xf6\xd6\xc7\xdf\x0a\x1f\x69\x3e\x8a\xe8\xc2\x68\xb9\xba\x4e\xca\xb8\xf4\x9d\x1f\xf4\xcc\xf7\x56\x64\x27\x93\x56\x74\x18\x25\xcc\xb3\xa3\x4b\x3e\x90\xef\x93\xbc\xdd\xe4\x39\xad\xcb\x46\xe5\xd0\xc5\xaa\x5f\xe0\x15\x75\x2f\xbc\x5e\xbc\x17\x21\x14\xf2\x18\xdc\x39\x7b\xa1\xc4\x79\x96\xe9\x71\x9e\x5d\x90\x52\xe6\x30\x1a\xa9\xf2\x86\xe7\xb0\x49\x5a\xa8\xa7\x7a\x87\x29\xfe\xff\x5f\x35\xff\x3f\x96\xd1\xef\xa9\x73\x04\x02\x84\x9f\x32\x61\x3f\x93\xeb\x87\xdc\x80\xe7\x78\x97\xc6\x9f\xf6\xfd\x42\x89\x31\xb8\x42\x8b\x3f\x95\x24\xb2\x11\x16\x9f\xc5\xc4\x8a\xdd\x7c\xe4\xf4\x1d\x1a\xf4\x5e\xea\xa7\xde\x4b\x37\x2a\xf7\x0c\x21\xcb\xd8\x01\x15\x07\x8c\x16\x10\xf4\x7b\x86\xd4\x27\xe3\x8c\x74\xdf\x5a\xd5\xbb\xfb\x57\xb5\xbd\x83\xb6\x77\xe2\xf6\x88\xcf\xb6\xa7\xe3\x53\x5f\x6d\x3f\xd5\x0e\x30\x44\xf5\xd5\x2a\x13\x18\xcd\xfa\xe8\xf4\x99\x69\xfd\x33\x6a\x07\x69\x55\xed\x8d\x87\x54\x6c\x40\x27\x38\x68\x34\xa3\xdc\x18\x5d\x95\xfe\x32\x6d\x7c\x2c\xaf\x89\xad\x25\x9a\xf6\x2a\x0b\x6b\x8e\x98\x2b\xcd\x8d\xe6\x26\x33\xf7\x27\xb3\x13\xb4\x54\x19\x87\x3e\x17\x17\xa7\xeb\xdb\xaa\xde\x25\x8f\xab\xeb\x6b\x24\x93\x99\x8f\x98\x9d\x48\x3f\x7f\x6a\x4d\xcc\x1e\x34\xbe\xa2\x32\xed\x37\x62\x1c\x67\x93\x04\x33\x32\x19\x3d\xa4\x00\x37\x22\x05\x94\x2b\xed\x7a\x69\xab\xca\x6e\x55\x92\xab\xb3\x25\x5f\x5c\xfd\x81\xd9\xa4\x97\x08\xff\x42\xfe\xe6\x64\xf8\x10\xff\x96\x52\x1d\xfc\xf4\x5c\x6e\xf7\x7d\xab\x91\xfa\x2e\x00\x12\xcb\x51\x80\xaa\xd0\xe5\xe9\xda\x1e\x46\x47\x31\x0b\x31\x3e\xea\x8d\x86\x43\x91\x88\xcf\x6f\xf4\x57\xf7\xf4\x3a\x9c\x62\xbc\x29\x03\x79\xf9\x79\x63\x32\xb1\x7c\x27\x27\xe6\x8b\xf9\xd6\x08\xf8\x3d\xd6\x32\x12\x40\xa6\x2a\x9f\xd4\xfc\xd0\xd0\xa0\xd5\xec\x41\x29\x20\x99\x8c\x9a\x7d\xa4\x5a\x2f\x3f\x10\x67\xe2\x67\x05\x72\x58\x59\x31\x56\x57\xaf\x3a\x2f\x52\xac\x96\x5e\x47\xeb\xff\x47\xfe\xdb\x87\xe3\x1a\x3b\xae\xde\xbe\x7f\xd9\x97\x3b\x48\x48\x87\x60\xb3\x99\x40\xfe\xa7\xa1\xe4\xe0\xad\xb1\xdb\x42\x10\x08\xfd\xfb\xd2\xc9\x33\x47\x95\xcf\x6c\x5b\x75\xf7\x18\xee\x6e\xf9\xcf\x93\xdb\x0e\x3d\xfc\x37\xf9\xc9\xc7\xae\x9c\x1c\xec\x53\x53\xc4\x05\x5e\x65\x3b\x76\xad\x5f\x2f\x17\xf4\x59\xf6\xe6\xa8\x59\x8b\x80\x39\x3e\x7b\x3a\xc6\xdd\x19\x7c\xae\x86\xe3\x3b\x32\x88\x57\xbb\x1c\x5d\x94\xee\x51\x58\x1c\x2a\xb6\x47\xbc\xa1\x20\x87\x2f\x28\x97\xd7\xce\xf7\xa8\x70\x15\xc6\x0b\xe3\x6d\x99\x42\x0c\xa7\x83\xe6\x60\xa8\x2d\x13\x74\x96\x83\x19\xda\x32\x66\x16\xe5\xea\x15\x24\x00\xf4\x3c\x6f\x8e\xa5\xda\x28\x8d\xe2\xf4\x89\x4a\xe2\x66\xb7\x57\xc8\x16\x69\x41\xd0\xd9\x68\xe8\x8f\xdd\x43\x47\x9a\xff\xce\x1f\x7a\x95\x99\xdb\xfd\x55\xb2\x2d\xda\x1b\x64\x4b\xb5\x77\xca\x72\xbb\x47\x0e\x29\xea\xeb\x48\xf4\xfc\xe3\xa1\xec\x3b\x65\x3f\x26\x2f\x93\xfd\x88\xbc\x57\x56\xb7\x7f\x5c\xcc\xaf\xb0\x0b\xec\x8b\x08\xe5\xbc\xf7\x21\x0f\x95\xa1\x31\xe9\xf2\x12\xd6\x54\x10\x60\x7d\x76\x9f\xdb\x6d\x73\x38\x3c\x2c\x5b\x51\x6e\x77\xfb\x9a\x33\x6e\x30\x05\x45\xe4\xf0\x88\x45\x4d\x19\xd1\x4b\xaf\x62\xbb\xf6\x0e\x6a\xe2\x4e\x6f\x68\x68\x2c\xa3\x5b\xab\x45\x01\x6a\x1b\x7b\xd6\x8e\xf6\x07\x17\x56\x9f\xe8\x66\x8b\xda\x96\x9e\xfd\x4e\x07\x75\x33\x85\xc4\x69\xd6\x52\x28\x0b\x83\xc9\x56\x9b\x5a\x16\x8c\xa9\xca\xbe\xd7\x41\x09\xd2\xa1\x7b\xe9\x78\x9a\xe7\xdf\x97\xef\x9d\xdc\xf6\xd2\xe0\x0d\x7f\x69\xca\x79\xb1\x03\xa3\x3d\x2b\xb2\x20\x2f\x89\x70\xe3\x05\xab\x15\x39\x8d\xc8\xc8\xb2\x7e\x9f\xe0\x6d\xcb\x08\x02\xe2\x58\x64\x25\x9a\xa2\x5e\x12\xae\x2c\x67\xbf\xa8\x0f\x20\x59\x5f\x94\x62\xe9\x2e\x71\x31\x7d\x7b\x0a\x5f\x6c\x17\xe0\xbe\x11\x57\x43\xfb\x37\x60\x91\x9f\x93\x3f\x95\x6f\x82\x35\x77\xdc\xb7\x74\x9d\xbc\x8d\xfd\xf6\xcd\xc2\x47\x3b\x8f\x1e\xfd\xfd\xdf\xfe\xf9\xd5\x35\x97\x67\x26\xe5\xac\x71\x0f\x34\x18\x0d\x4f\x27\x07\xe6\x95\xd4\xd8\x59\x63\x85\xb1\x47\x0f\x84\xc4\x3c\x76\xe8\x90\x8a\x12\x67\x91\xaf\xa8\x6f\x53\xa6\xc8\xeb\xab\x24\x5a\x9b\x04\xb4\x14\x65\xee\x7b\x7c\xb5\xc5\xcd\xae\x6d\xaa\x3f\x5b\x4f\xc9\xb3\xf2\x3d\xf1\xe7\x54\x75\x98\xc9\x07\xcc\x4b\x56\x56\x5b\x6e\x28\x20\x29\x85\xa0\xbc\x52\x84\xbc\x04\x9c\x86\x2f\xb0\x46\x8b\xcd\xb0\x6b\x0e\x0f\x6b\x87\x06\x8b\x02\x76\x89\xe5\xf2\x86\x65\x66\xf6\x6d\xb9\x61\x7c\x85\xd1\x94\x77\xd1\xf5\x0f\x5c\xa6\xef\x02\x3c\x59\xdb\xd6\xdc\xe8\x36\x48\xf9\xb5\xc3\x2b\x52\x2d\x17\xa4\x3c\x26\xd3\x10\xa9\xac\xef\xd0\x24\x3b\xf3\x85\xf8\xf6\x1b\x9f\xbd\x61\x64\xb1\xb9\x74\x70\xcf\xbc\xea\x4b\x6e\x6a\xb1\x56\xcd\xe9\x7d\xdb\x9b\x37\xf6\x53\x37\x86\x5d\x1f\x6b\x5e\x77\x45\xf9\xc8\x58\xaf\xf1\xbd\xf3\x23\xa3\x56\x4d\x4f\x65\x12\x64\x63\x00\x15\xe1\x3b\xfb\x61\x7e\x33\x0a\x91\x77\xab\x07\x8c\x0c\xeb\x74\x38\x58\x23\x9b\x9f\xe7\x64\xac\x82\x15\x6b\xee\x56\x97\x80\xf0\xf6\x70\xb9\xf5\x5d\x72\xf6\x85\xa4\x1a\xb1\x49\xa2\x90\x73\x5e\x8f\x9d\xd6\xa9\xa0\xef\x48\x53\x39\xc9\x2a\xff\x77\xfb\x0f\x37\xc0\xc5\xff\x38\x0c\xfe\x4d\x7f\x92\x6f\xea\xfc\x5a\x7e\xb7\x10\x9c\xae\xa7\x56\x6d\xf9\xfb\x75\x87\xb9\x3d\xf2\x4f\x53\xdf\x3d\xb2\x5e\x7e\x44\xee\x94\xaf\x38\x7e\xf4\xe0\x90\x19\x37\x3c\x08\xc9\xe7\x1f\xf8\x1d\xb5\xb9\x5e\x86\x75\xef\x84\xb0\x1b\x25\xd0\xa8\x74\xb1\x2b\x16\x8b\xf2\x82\x10\x25\x55\x43\x03\xc9\x40\xb1\x2f\x6f\x6a\xc6\xe7\x70\xc5\x78\x56\x72\x38\x0a\xdb\x32\x0e\x4e\x62\xc9\xeb\xca\xba\xd5\xd7\x20\x0a\x35\xe4\xbc\x26\x96\xd4\x0f\xd5\xdf\xba\x2c\xe4\x14\xd5\xf0\xa9\x2f\x72\x50\x32\x07\xba\xbf\x82\xf9\x4a\x79\xdf\xdf\x8f\xfc\xff\x38\x7b\x0f\xf8\x28\xaa\xae\x7f\x7c\xee\xdc\x99\x9d\xed\x33\x3b\xdb\x7b\xcf\x6e\x7a\xc8\x12\x42\x68\x59\x7a\x27\x05\x30\x2c\x2d\xf4\x22\x4d\x7a\xaf\xd2\xa5\x8a\x80\x0a\x28\x28\xa0\x82\xa0\x8f\xa2\x82\xbd\x20\x16\x2c\x28\xf6\x5e\x78\x01\x15\x15\xdb\x63\x21\x99\xfc\xef\x9d\x99\x6d\x21\xcf\xf3\xfe\xde\xff\x47\x41\xc5\xcd\xce\x39\x77\xee\x3d\xed\x9e\xf3\xfd\x0a\x57\x44\x0e\xe6\xaf\xb6\xb3\xae\x17\x76\xf6\xed\x13\x2d\xf7\xb4\xee\xc5\x75\x12\x7e\x72\x1f\x9a\x9b\xa6\x63\x7e\xf2\xc9\x6d\x40\xfb\x2f\x4c\xc7\x3c\xa2\x7a\xeb\x0e\xc3\x1b\xda\x0e\x35\xc2\x0b\x49\x5e\x66\x91\xdb\x84\xde\x44\x97\xa0\xb3\x50\x15\x8f\x6a\x75\xba\x90\x8d\x20\x42\x0c\x1f\xe2\xdd\x61\x77\x8e\xd3\x57\x9d\x70\x3a\x6d\xac\xc5\x42\xe2\xd8\x9a\xd3\xb2\xac\xaa\x2a\xc1\x5a\x32\x19\x4e\x88\x8a\x98\x4c\x64\x98\xd4\x28\x19\xfb\x27\x91\xd4\x62\xd9\xbc\x27\xd6\xb4\x56\x2c\x80\x15\x12\x96\xda\x23\x22\xd8\xda\x64\x61\x8a\x44\x80\xb2\x7e\x82\xeb\xd4\xe6\x7e\xbd\x22\xa2\x46\xc5\xe4\x5b\x12\xa2\x5a\x06\x15\x4a\xd9\xa6\x5b\x0c\xaf\x21\x55\xae\x12\x2d\xf4\x11\x61\x3b\x5d\x81\xce\xb5\x99\xf0\x12\x1d\xe3\x3e\x27\xb4\x28\x75\x3c\xaf\x84\xd0\xef\xe3\x38\xa5\xd9\xec\xad\x4f\x98\xd5\xe8\x17\x54\x5a\xf0\x10\x9b\xfc\x76\xe4\x32\x47\xb3\x7d\x94\x1a\x59\xcb\xb0\xc9\x69\xda\x69\xb8\x31\x35\xb6\xf6\xc5\x65\x83\x6c\x88\x27\x9e\x11\x87\xd6\xb6\xa5\x87\xd6\x32\x0c\x6f\x8a\x86\x1a\xc9\xe9\x47\x72\x6f\x17\x39\x0d\x2d\x48\x4e\xaf\x45\x81\x32\x2c\x86\x50\x59\x55\x36\x8a\xad\x4f\x50\x94\x46\xa9\x64\x90\x80\x50\x63\xaa\x4f\x68\xf8\x66\xa4\xe3\xc9\x05\x2f\x95\x00\xd2\xd0\x6e\x17\xb9\xf5\x80\x3f\x50\x04\x00\x16\x16\xff\xf7\x76\x40\x1d\x03\x77\x74\x69\xec\x54\x00\xbf\x13\x7e\x6e\x1c\xb5\xe1\xf5\xa9\xe4\xa8\xdd\x7b\x7e\x00\xbd\xab\xc0\xac\x6d\x1f\xcc\x04\x83\xbf\xfd\x67\xf9\xf0\xfb\xc1\x94\xf9\x37\x1d\x03\xb7\x11\x19\xbc\x32\x4e\x22\x97\xa8\x8b\x17\x39\xfd\x7a\x68\xb0\xd9\xac\x56\x43\x54\xc1\x2b\x4c\x79\xa6\x7c\x42\x07\xd5\x36\x67\x6d\xc2\x66\x36\xf2\xd5\x09\x23\x50\x87\xaa\x12\x6a\x0e\xba\x70\x9f\x55\xda\xe2\x67\x9c\xcb\x94\xa0\xa5\xc9\xc6\xdb\xeb\x3a\xa9\x44\x64\x33\x09\x1c\xf9\x3f\xb0\xc8\x2c\x39\xe0\xa6\xa1\xa1\x58\x50\x14\x41\xad\xc8\x23\xa3\x52\xfc\x54\x3d\xa7\xb6\x55\x36\x91\xcc\xf8\xd1\xbe\xf1\xdf\xbf\x8f\x89\x64\xbc\x63\x3d\xd9\x4c\x32\xf8\xbe\xf3\x9a\x30\x84\x7a\x54\xc4\x0d\xf7\xa3\x2c\x37\x62\x23\x94\x90\xf2\x7a\x15\x3a\x1d\x45\x20\x93\xa8\xd6\x19\xa0\xc1\x59\x95\x30\x70\x14\xa3\x60\xaa\x13\x0a\x27\x34\xd5\x24\xa0\x39\xbb\x30\x98\x61\x6a\xb0\x5e\xe2\xea\x03\x8e\xd0\x01\xdc\x40\x01\x8a\xe4\xa3\x6b\x01\xc9\x56\x30\xb1\xdc\x45\x3d\x2a\x7c\x29\x34\x82\xbc\x60\xc3\xf8\x28\x69\x17\xde\x1f\xd0\x23\xef\x10\x28\x7a\xe9\xd3\x9f\x1b\x57\x4f\xb8\x7d\xe8\x4d\xe3\x27\x6e\xed\x3b\x91\x3c\x2c\x34\x08\xfb\xda\x34\x9e\x38\x0b\x14\x3d\xa6\xad\x1f\xf2\x0c\x28\xbc\xff\xab\xc6\xda\x05\x3f\x6c\x99\x3c\x7b\xe9\x17\x9b\xe6\xcc\x92\xee\x7c\x50\xd6\x46\x2f\x14\xf9\xf4\xda\xc7\xbd\xb4\x4a\x45\x2a\xd4\x90\xd0\x12\x3a\x46\x51\x9f\x60\x18\x52\xa3\x41\x1b\x5b\x03\x49\x64\x76\xc8\x96\x76\x8c\x55\x92\x58\x85\x5b\xd7\x8c\xd2\x2f\x7a\xa1\xf0\xf3\xb5\x07\x0b\x60\x61\xf7\x46\xae\x80\xbc\xda\xab\xe1\x48\x21\xa6\x73\xbe\x00\xc6\x5c\x00\xf8\xa6\x89\x24\xa6\x20\x1b\xf1\x14\xb2\xc7\x4a\x14\xf1\x75\x8f\x87\xa0\xd3\xc9\x06\x54\x0a\xab\x55\xc5\xc2\x50\xd0\x4e\xd5\x27\x02\x5a\xbb\xdd\xa8\x35\x22\x9b\x6c\x34\x6a\x3d\x28\xd6\xa1\x9a\x11\x7f\xe7\x67\x45\x39\x12\x15\x92\x1f\x27\xd9\x00\xdf\x20\xc8\x24\xad\x39\x68\xf1\xd0\x4e\x90\xaf\x18\xc8\xa7\x6f\xff\xb4\xa4\xb1\x1d\xb3\x4f\xf8\xa4\x0e\x84\x2f\x00\x3d\xe8\xf6\x21\x3a\x67\xf7\xfc\xba\xba\x04\xfe\x44\x1e\x5e\x31\x68\x4e\xa2\xed\x5b\x1f\xbc\x50\xd0\x6a\xfb\x03\x70\xd4\xd3\x0f\x0a\x2f\x08\x3f\xfd\x2e\xcc\xfb\x74\x3b\xa0\xef\xbe\x7d\x77\xf9\xca\xfb\xc3\xfd\x13\x78\xbd\xba\x20\xd9\xed\xf4\x4e\x22\x0f\xf3\x51\x47\xa2\x36\xb5\x9f\xa2\xd4\x8c\x2b\x4a\xe7\x23\xa7\x52\xe0\x44\xc2\x46\x08\x5e\xef\x74\x12\x7a\xd1\xb1\x50\x44\x28\x9b\x73\x33\xc5\x5b\x2e\x5e\xef\xa6\x2d\x03\x1d\x90\x46\xbb\xc4\xdf\x33\xa8\xcb\x25\xdc\xdf\x0c\x80\x30\x05\x45\xc6\xb6\x5f\x58\xf2\xea\xd3\x93\x17\x6c\x06\xc4\xbe\x4f\x80\x32\x2a\x5c\x75\xde\x3c\x6d\xee\x86\x55\xab\xdb\x17\xb4\x7f\xe5\xe8\xfa\xb9\x8b\x1e\xed\xfc\xe7\x38\xe1\x8c\x69\xe4\xa1\x49\xfb\x5e\x75\x78\x6f\x19\xbb\xfc\x95\xa9\xaf\xbe\xd0\x61\xf9\xb4\xa9\x13\xfb\xd7\x7f\x3b\x7e\xd6\xc0\x51\x4b\x57\xac\x7e\xea\x1e\xf1\x0e\x12\xa0\x3c\x93\x15\xfb\x87\x2a\xe3\x3e\x40\xd3\x1c\x47\xaa\x79\xde\xac\x36\x89\xc4\xf4\x40\x69\x30\xa0\xb7\x60\x80\x4a\x1d\x32\x1c\xce\xeb\x37\xc0\x75\xe4\xef\x62\xad\x56\x84\xe2\x28\xcf\xa0\x81\x9f\x17\x7a\xea\x54\x9f\x1b\xf2\x3a\xbb\xe2\xdd\x59\x60\x4f\xf1\xc1\x1f\x7a\xec\x2e\xd3\x67\xba\xfe\x55\xf4\x51\xb1\x4e\xf3\x09\xca\x01\x2b\x44\x3e\xa3\x21\xf1\x42\xcc\x66\x04\x14\x90\xa4\x18\xc6\x8c\x76\x01\xa9\xb5\xda\x8c\x26\x4e\xcd\xcd\x4b\x30\x0a\x35\x61\x52\x60\x46\xa3\xb9\x09\x05\x4b\xca\x14\x40\x12\x22\x87\x58\x38\xca\x64\xb0\x48\x96\xd6\x65\xb6\x47\x4c\xb4\xd8\x12\xa5\xd1\xef\x82\x20\x5c\x06\x64\x8b\xa4\x46\xff\x7c\x4a\x87\x9b\x91\x1a\x89\x1c\xf6\x4c\x67\xe4\xb7\xf3\x89\xe1\xf1\x12\x0f\x0c\x47\xa3\x16\x95\x95\xb5\x5a\x2c\x18\x23\x98\x65\x0b\x75\xfc\xe8\x84\x8e\x89\xe4\x20\x07\xae\x62\x22\x11\x82\x61\x1c\x22\x95\xbd\xbf\x85\xed\x50\x21\x97\xc5\x53\x95\x2e\x3e\xbd\x2d\x7c\x32\x95\x7d\x0b\xce\xbb\x65\x5a\xfb\xb7\xc1\xca\x7f\x2e\xec\x36\x64\x79\x70\xcc\x70\xbf\xff\xea\xf2\x67\x1f\x4a\x33\xdc\xef\x10\xce\x88\x0c\xf7\x7f\x83\x55\xef\x4d\x48\x24\x1d\xf9\x8b\x03\x66\x2e\xd9\x2d\xfc\x78\xe2\x5f\x6f\x48\x54\xf7\x13\x87\xe1\xf3\xfa\x28\xda\x23\xff\x12\x39\xd8\xdd\x44\xd7\x78\xd0\x60\x23\x69\x3c\x87\x69\x56\x3a\xf5\x80\x20\xf4\xc8\xea\x79\x28\xaf\x8d\xd4\x10\x1a\xa4\xb4\x06\x93\xb6\x12\x95\xa5\x99\xe6\x3a\xb9\xcd\xe5\xce\x57\x91\x72\x33\x09\x31\x24\x01\xd7\x4b\xd3\x8d\x62\x9d\xec\x51\xd0\xfa\x10\xf8\x1d\xb4\x6a\x6c\xd7\xc9\x77\xfa\xa1\xc5\xbb\x6e\xdc\x5e\xd1\xba\xc4\xa5\x8d\xde\x10\xa0\x57\x36\xdc\x05\xc7\x5c\xdb\xfc\xd0\x2d\xad\x6f\xff\xd7\xfa\xe9\x83\xcf\x1c\x16\x6c\xbd\x62\x95\xc3\x83\xb1\xa9\xfd\x7c\x45\x72\xcf\x18\x8a\xa7\x46\xa0\x3d\x14\x25\xba\xc5\xc3\xfe\x00\x6d\x75\x12\x9c\x46\xa3\xd5\x12\xd6\x00\x95\x97\x9b\xe3\xa9\x4e\xe4\xa0\xb8\xc3\xcf\x9a\x90\x45\x36\x71\x3a\xa0\x4d\xc5\xbd\x12\xf5\x49\x66\xf2\x84\x37\x75\x6b\xec\x3e\x64\x92\x24\x7f\x9a\x3e\x49\xae\xe8\x61\x0c\x1b\x1c\x62\xe5\xc0\x02\x8b\xc3\x22\x22\xef\x63\xce\x24\x60\xab\x8a\x48\xc0\xfb\xa1\x50\xdf\xbe\xcf\xb4\x5a\x02\x6c\x8b\x4a\x84\x6b\xdf\x9e\xf9\x18\x44\x3b\x6d\x58\x7e\xa3\x6f\xe5\x3d\x0b\x31\x85\x92\x30\xe5\x71\x0c\xc2\x5f\xf5\xf0\xd1\x40\x5d\x15\x00\xe4\xa2\xc6\x2d\xff\xbe\x78\x30\x99\x37\xe1\x1e\x27\x83\x02\xf7\xfe\x10\xd1\xb8\x97\xa5\xb7\xd2\x64\x92\x57\x87\xa0\x7d\xf4\x36\x7a\x3f\x7d\x8e\xfe\x8a\xbe\x4a\x33\x2b\x68\xcc\x9c\x8d\xc1\x96\xc5\x35\x50\xa3\x9f\x5d\x2b\xda\xf4\xa2\xb8\x05\xd3\x0a\x41\x2d\xd4\x31\x1a\xdc\x40\x40\x11\x84\x8a\x84\x2a\x5e\xbc\xa9\xcf\x28\xb0\x56\x88\xa0\x85\x46\xdc\x82\x24\x57\x58\xcb\xb6\x4e\x03\xd1\xe9\x7b\xf2\xf7\xe0\xea\xea\x56\x58\x45\x96\x36\xbe\xf5\x39\x2e\xab\x4a\xeb\x2c\x71\xe0\xef\x42\x31\x51\x97\xb8\x9f\x30\x03\xb5\x09\x1a\x51\x54\x0d\x29\x33\x65\xe1\x8d\x46\x2b\x30\x50\x3c\xb2\x1a\xa3\x13\x4a\x8a\xa0\xd0\xe3\x62\xc9\x9e\x85\xac\xbe\x16\x39\xb3\x10\xf9\xec\x8d\x99\x1b\x3c\x93\xd9\xfe\x33\xd7\x33\xf7\xdf\x20\xee\xe5\xae\x86\x2e\x59\x0c\xf7\xd4\xc4\x5d\x77\x48\x1b\xf7\x75\x99\xe8\x9e\xc8\xe4\x5a\x32\x13\x9d\xe2\x5e\x13\x90\xe4\xa2\xd4\x66\x98\x92\x8c\x55\xea\xaa\x13\x4a\x40\x50\xe6\xeb\x24\x4b\xe6\x3c\xe9\x86\x9b\xe6\x72\xc9\xad\x37\xff\xe3\x7e\xec\xa0\x24\x56\x0f\xc3\xe8\x2c\x1e\x25\x6a\xdf\x9d\x3b\x25\xb1\xb4\x72\x2b\x0e\xc0\xc8\xd4\xe4\x3a\xb1\xb7\xa2\x20\x6e\xd6\x10\x84\x16\xc5\xf9\x3a\x94\x8a\x90\xd5\x09\x06\x42\x5a\xca\xbf\x32\xde\x88\x8c\x9f\x13\x93\x4a\xdd\xe2\x4b\x09\x2e\xbc\x23\x77\xf7\x0a\x60\x5f\x71\x34\xf7\xc8\x42\x72\xc6\x1b\xe4\xf6\xc6\x19\x6f\x34\x6e\x97\x7a\x49\x8e\x22\x9d\x49\xf4\xfd\x2c\xe6\xfe\x51\x93\x2a\x95\x12\x92\x04\x09\xf4\x28\xf6\x50\x2a\x0d\xe8\x00\x70\x80\x22\x68\x42\xcf\x60\x12\x29\xb5\x96\x45\x46\x9f\x54\x69\xcd\x24\xc0\xb7\xda\x52\xd3\x86\x8c\x68\x2d\xc1\x79\x64\xaf\x05\xda\x1a\xe1\x88\x1f\xa3\xe5\x8a\xed\x47\x20\x42\x3f\x02\x62\x79\x20\x8f\x3f\x9d\x7b\xf6\x3b\xe1\x93\x59\xc2\x64\xe1\x23\x72\x92\x4a\x38\x47\xad\x5b\xf8\xc6\xa8\x01\xc7\xaa\xaf\x75\x25\xdf\x6b\x2c\xa0\xd4\xbd\x16\x60\x0c\x36\x74\x26\x67\xa2\xfd\x58\x40\x0c\x8c\xe7\xaa\xf4\x6a\x9d\x4e\xab\x55\xe7\x5b\x60\xd8\x03\x3d\x9a\x42\x4d\x11\x6b\xd5\x15\xa8\xd1\x41\x8a\x3a\xa3\xa3\x13\xbc\x93\xd7\xe9\x91\xed\xe4\x53\x5c\x1e\x62\x66\x10\xe3\x33\x42\x3f\x4c\xc1\x54\x6a\xc8\x24\xc4\xb0\x48\x38\x5c\xc8\x12\x8a\x08\x5d\x45\x20\x92\xe4\x74\x4b\x92\x33\x8b\x1f\xa0\x3e\x7a\xcc\x51\xd9\x76\xcc\xdd\xde\x23\x20\x22\xfc\x2c\xbc\x6b\xa2\x3a\xdc\x31\xb3\x77\x7d\x27\x2b\xd3\x63\xca\xca\xaa\x5d\x77\x6a\x5f\x06\x91\xc7\xac\xed\x3a\x4c\xba\xcd\xf1\x08\xb2\x36\xc3\xd6\x44\xcb\xda\x3f\xb5\x17\x4e\xf9\x67\xc5\xfd\x63\x86\x15\x54\xd7\x0c\xaa\xca\xdb\xb9\xa3\xa2\x12\xfe\xd1\x30\x6c\x6e\x51\x65\xfb\x83\xeb\xe0\x6e\xb4\xf6\x04\xb2\x8f\x98\xef\xde\x8a\xb2\x7e\xa7\x12\xd0\x5a\x2d\x8a\x6f\xd1\xfb\xb5\x1b\x6c\xac\x69\x54\x82\x75\x92\x2a\x25\x4f\x4b\x56\x11\x17\x2e\x52\x08\xca\x29\x15\xfc\x40\x92\x1e\x88\x7d\x01\x69\x0f\xda\x06\x53\xda\x1b\x6c\x22\xa3\xbd\xb0\x17\x13\xdd\x3f\x1b\x39\xf2\x40\x9f\x1b\x0a\x3b\xb9\xe3\x3d\x58\xcc\x6e\xbf\x6e\x21\x26\xb7\x17\xd9\xee\xcb\x5f\xde\x6d\xba\x88\xbc\x29\x91\xd9\xef\xe0\x22\xe2\x71\x1f\xb4\xa5\x98\x49\x6c\x6a\x8f\x1b\x45\x2a\x66\xb5\x44\x05\xa5\x63\xd5\x66\x14\x9b\x57\x56\xca\x1c\xf2\x86\xeb\x88\xe3\x30\x86\xd3\x7f\xa2\x7d\xd2\x03\x48\x6e\x3e\xeb\x90\xed\x5e\x92\xf6\x49\x34\x7c\x4a\xd5\x47\x42\x1d\x6c\x58\x92\x2b\x9a\x3a\x99\xf8\x09\x1b\x3b\x53\xd7\x8a\x6b\x8f\x67\xf4\x2b\xd0\xbb\x78\x05\x75\x87\x98\x67\xe1\x5c\x78\x03\xb2\x29\x98\x83\x32\x1e\xf7\x87\x34\x66\x37\x32\x27\x11\xd6\x60\x88\x6a\xcc\xc8\xb3\xb0\x04\x07\x95\xf6\x7a\x6c\x52\x7c\x19\x6e\x34\xc9\x32\x99\x61\x58\xc4\x80\x4a\xce\x7b\x7d\x14\xca\x10\xcb\x83\x46\x3f\x86\xd2\x57\x90\x14\xcc\x22\x97\x27\x3f\x94\xd9\xfa\x7f\x23\x9a\x40\xef\x70\x6d\x1f\xdd\xf2\x18\xf0\xe6\xb9\xf6\x6e\xa3\xdf\x17\x36\x96\xa5\xc8\xe5\x4d\x49\xe6\xfe\x5f\x3e\x73\x0d\xed\x04\xa8\xf7\xb6\x9c\xc8\xff\x43\x98\xfb\x1e\xf5\x02\x46\x6c\x38\x75\x32\xc9\xe4\x2f\x73\x4c\x2a\x78\xb4\xf6\x56\x64\x89\x50\x1e\x66\x23\x3c\x06\xc2\x10\xa2\x19\x26\x6c\x76\x54\x61\xfe\x2d\x00\x68\xbd\x42\xef\x93\x06\x5f\x93\xf4\xfd\x15\x86\x58\x12\xf2\x2b\x1d\x53\x31\x19\xa2\x13\xff\x89\xde\x0a\xf4\xec\xa3\x9f\x12\x03\x9a\x3c\xdf\x03\xdb\x4b\x84\x07\x7f\xc3\x37\xde\x91\xa7\xbe\xfb\x4b\xf8\xe4\xdc\x9c\xf5\xbd\x25\xaa\xab\x7c\x7e\x70\x15\x92\xfa\xc0\x29\xe7\x15\xe1\xd2\xf7\x6f\xca\x9c\x57\x4b\x7f\xb9\x49\xe2\xbc\x22\x26\x0a\x75\xcc\x1c\xb4\xf6\x46\xc2\x83\x22\x41\xbf\x95\x74\xab\x48\x95\x17\xf0\xbc\x8f\x23\x47\x27\x38\x85\x81\xd2\xd9\x31\xd0\x82\x02\xe5\x8e\x0a\xa3\xb8\x65\xd2\x8b\xdf\x4c\x6a\x15\x08\xe2\x5d\x8c\x42\x17\x8e\x0f\xe1\x39\xdc\x70\x4c\x05\x4a\xcb\x8d\x52\x16\xc6\x51\xbf\x82\xb6\x4d\x1f\xf5\xfc\x65\x9a\xf0\xbd\xf0\xf6\xeb\x60\x21\xd1\x34\xfe\xcd\x6e\xa4\xb6\xb7\x70\x7b\xc3\xfb\x9d\xda\x3e\xdd\xae\xe3\x9e\x9f\x96\x0b\x75\x8a\x1e\xd7\x0e\x04\x8b\x41\x09\xe0\x01\x05\x36\x7f\x58\x14\x1e\xf0\xd7\x19\x72\x81\x1e\xbe\xc2\x1e\x12\x3e\x7e\x4c\xd8\x87\x64\xee\x8f\xce\xdd\x9f\x28\xff\xe2\xc5\xb8\x24\x60\xe1\x5c\x90\x83\x1e\x56\xab\xf5\xea\x9d\x1a\xae\x3a\xa1\xe1\xd4\x28\xee\xb2\x55\x25\x18\x8e\x30\xe2\x82\x43\x66\xdc\x25\x15\x12\xb3\xe4\xa6\xd3\x0d\x06\xe1\x18\x08\x1a\x83\x50\x11\x91\xc4\xc6\x59\x17\x09\xdf\xba\xbc\x07\xb8\x9e\x9d\xf4\x4c\x0c\x6c\xeb\x2f\x7c\xd8\xd8\xf8\xe2\x1d\x07\x8e\x54\xe4\xdc\xe2\xec\x36\xf2\xb6\x81\xa6\x1f\xcf\x9e\x01\x15\x47\x63\xe1\x21\xff\xa8\x68\x4b\xc3\x99\x9e\xcf\x33\xe4\x39\xf5\xca\x8b\x1b\xaf\x12\xa9\x1a\x82\x42\xc4\x00\xf7\x12\x3d\xe3\x21\xbd\xd1\xaa\x44\x8e\xd9\xe8\x73\x42\xe8\x37\x18\x54\x16\x2b\xca\xcc\xad\x56\x8b\x8a\xb7\x78\xeb\x13\x16\xe4\xa9\x2d\xb8\xbe\x9b\x2e\x12\x8a\xa5\x84\xac\x96\x50\x5c\xec\x94\xa0\x2c\xe0\xf5\xe5\x04\xa9\x9a\xd0\x94\x44\xb4\x38\x3e\x46\xf8\xe4\x92\x4d\xae\x27\xbc\xfd\xcf\x9d\x7b\x57\x2c\xf8\x92\x5e\x29\x42\x5b\x08\x5c\x46\x35\xa1\xb1\x56\x02\xba\x90\x39\xd0\x90\x3f\xf1\x10\x85\x44\x4d\x3c\x3f\x5f\xa1\x40\x91\xaa\x27\xa4\x83\x6e\xb7\xc1\xc0\xf3\x45\x16\x67\x75\xc2\x02\x78\xa7\x4e\xaf\xf7\xa8\xa1\x3a\x82\x92\x76\x0b\xf4\xa2\xa4\x9d\xcb\x2a\xa2\x61\x22\xc7\x94\xbd\xcb\xe8\xa2\x6f\x56\x7b\xc7\x43\x94\x29\x37\xcb\x02\x6b\x56\xa9\x16\xfc\xd8\xfb\xfe\x59\xa9\x6a\x2d\xd4\x8c\x41\x91\x7a\xcc\xfd\xc4\xe1\xaa\x71\xd1\xee\xbe\x79\xae\xfc\x9f\xa5\x5a\xed\xc4\x79\x5d\xfb\xc3\xed\x13\x6f\x48\x56\x6b\xdd\x9d\x05\xa8\xe8\xb1\xe7\x36\xd3\x1b\xec\xe6\xcf\x15\x52\xb1\x76\x15\x70\x4c\xbb\x71\x8a\x58\xab\x15\x9e\xa0\x3b\xd1\xab\x08\x8e\xb0\x13\x83\x50\xb6\xa1\x25\x38\xc6\x66\x47\xd6\x01\xd9\x6d\x16\x68\x71\xc0\xc0\x69\xa1\xd3\xc1\x92\x76\x12\x05\xee\xb6\xfa\x84\x9d\xb1\x33\x14\x0d\xc5\x68\xe6\x8c\x74\xd1\x90\x2f\x4f\x0a\x58\x53\x64\x10\xb1\xd4\x55\x35\x3e\x04\x22\x0e\x56\xa9\x18\xe8\x32\xe8\x04\x48\xb5\x5c\x08\x5f\x16\x5e\x6b\xe8\x29\x7c\x0c\x58\xe0\xf6\x03\xeb\xdd\xdf\xce\xfb\xf8\x49\x30\xaa\xf1\x9b\xed\x3b\x97\xcf\x16\x7e\xae\x11\x9e\x20\x1f\x16\xee\xa0\x57\x3d\x3c\xe6\xf1\xc5\x87\x2e\xba\x1a\xbd\x70\xd7\xdc\xa9\xc3\xc7\x0a\xa3\x44\xbb\xde\x0e\xe5\x9f\x55\xe8\x9c\xe6\xa1\xb8\x2b\x10\xce\xc9\x51\x9a\xd0\x1b\xf0\x7a\x51\x1e\x5f\x90\xaf\xd4\x85\xbd\x54\xd4\x10\x0d\xd4\x27\xa2\x46\x83\x7a\x74\xc2\x40\x65\x56\x0a\xb3\x50\x47\x62\x72\x99\x27\x5c\x9e\x0c\x70\xc3\x6d\x42\x62\xd9\x59\x0f\x93\xa8\x70\x52\x99\x2d\xd4\xee\x53\x40\xed\x7c\x6e\x79\x97\x9f\x96\xdd\x11\x15\xbe\xaf\x02\x01\x00\x50\xfa\x5c\x54\x3d\x6b\xf7\x81\xc4\xc1\x65\xfd\x36\xae\xdd\xf9\x54\x0c\xf8\x0f\x34\x7e\x26\x08\xdf\x81\xc4\xd3\x5f\x94\xfb\xa2\xe5\x55\x1d\xb7\x0d\x1f\x16\x79\xf1\xee\xc7\xef\x1e\xb2\x62\x64\xd7\x58\xc8\x1c\x69\x53\xdd\x71\x78\xff\x71\x33\x4b\x85\x15\x2f\x26\x71\x54\xda\x50\x55\x44\x04\x5b\x7a\x7f\x20\xa0\x34\xeb\x59\xd6\x85\xa2\xa0\xdc\xa8\x52\xef\x77\x51\x61\x3e\xec\xa9\x49\x84\x2d\xbc\xa6\x26\xc1\x73\x2d\xa8\x91\xa9\x05\x9e\x9d\x4b\x61\xa2\xa4\x90\x5a\x91\x91\x05\x52\xb5\x50\x22\xde\x0d\x0e\xff\xd7\x5b\x4b\x47\x27\x86\x0d\x1d\x3f\xc5\xfe\x7b\xd9\xdf\x6f\x9e\x7e\x6f\xec\xd3\xc2\x6f\x73\xa7\xbe\x3a\x75\x55\xee\xd5\xca\x3f\xbf\x79\xe7\x0a\xd0\x4f\xdf\x3e\x22\xd7\x66\xac\x68\xd5\xa9\x28\xde\xd5\x71\xeb\xad\x3b\x76\x8c\xdd\x30\xb4\x9d\xbd\x7b\xeb\x99\xf1\xfe\xe1\x7d\x6b\xf6\x88\x7e\xab\xe9\x1d\x14\x6b\x7d\x82\xeb\x83\x70\xb0\x78\xb6\x6f\x17\xea\xc8\xd7\xc5\x3b\x8d\x28\x51\x12\xb7\x07\x15\xc8\x71\x11\x84\x99\x53\xa0\x8c\xc3\x88\x02\x4d\xa3\xd3\xe7\x70\xe4\x40\x80\x29\xb2\x44\x88\xcd\xcc\x92\xa0\xb1\x75\x9b\x34\x15\x37\x16\x96\x51\x04\x7d\x38\x6c\xc1\x47\x23\x93\x8c\xe0\xf6\x6d\xab\x6f\xd9\xa1\xfb\x96\x1e\xc5\xd7\xf0\xb9\x3d\x67\x0b\x57\x34\x97\x23\x6d\xfa\x8d\x5f\x5d\x9a\x97\x57\x8a\x7f\x51\x3f\xcc\x98\xb5\x65\x69\xa7\xce\xd7\x16\x59\x9d\xc3\x94\xd4\x79\xc3\xc5\x68\x7b\xea\xa0\x66\xf4\x58\xe9\x7f\x97\x4a\xb1\x31\x25\x0c\x16\x7b\x21\x82\xd8\x0a\x29\xdc\xbc\xc5\xc2\x6a\xdc\x1a\x63\xd0\x18\x0e\xfa\x51\x2c\xea\x77\x99\x75\x7a\x1d\xe6\x31\xd4\xb3\x0a\x67\x4d\x42\x21\xdb\xcc\x33\x29\xb2\x60\x64\x86\x62\x19\x4c\xe3\xad\x4a\xac\x52\x0e\x2a\xb1\xd2\x5c\x47\xa8\x26\x85\x33\xf9\xdd\x73\x5a\xf7\xe7\x74\x43\x27\x5c\xc7\xac\xd6\xce\xf5\xc4\xde\xaa\x41\x6f\xb1\x1d\x6a\xba\xeb\xa7\x8d\x6e\x46\xb1\x26\x9c\xd9\xba\xdf\x24\xc9\xdd\x5d\xee\x27\xe1\x88\x56\x71\x2b\xa3\xc5\xfc\x59\x1c\x72\x2f\x6a\x35\x0b\x79\x80\x82\xd9\xfa\x04\x0b\x33\x5a\x47\x32\x42\x45\x1c\x5e\x89\x16\x32\x7d\x07\x46\xf7\x14\xfa\x5c\x14\x3e\xbe\xf8\xc4\x6d\xa2\x41\x84\x47\xa9\x7d\xd7\xc6\x52\xfb\xd6\x94\x76\x30\x04\x3b\xbf\xf2\x8c\xcc\x45\x07\xab\xc4\x3b\xc9\x4e\x71\x9f\xc5\xe1\x50\xa1\x8c\x8b\x0d\xb2\x21\x1d\x5f\x95\xd0\x01\x1b\xa3\x64\x90\x27\x57\xb2\x84\x27\xed\x57\x92\x4b\x94\x7a\x76\xda\xa9\x94\x67\xf0\x28\x8b\x16\xae\x45\xca\xb9\xdb\x8c\x69\xab\xa6\x6e\x81\x7b\x6e\x2c\x32\x66\x2f\xb2\x9b\x3b\x65\x32\xd0\x61\x59\xe5\xbe\x1f\x74\x78\x8a\xe3\x36\xc0\xf1\x9c\x12\x9a\x2c\x26\x2b\xc1\x1b\xf9\xfa\x84\x11\x6a\x14\xf5\x28\x2b\x4f\x97\x1d\x53\x29\x79\x3a\x76\xc6\x9b\x4e\x0e\x96\xc5\xae\x9a\x9f\x99\xc2\x52\x57\x8f\xfc\xfa\x3e\x5b\x36\xe9\x7f\x4a\xb6\xd5\x5c\xab\x08\xba\x4a\x0a\x75\x9f\x99\x96\xae\xe9\x56\x49\xbd\x20\xf5\xd6\xcc\x47\x31\xdb\x72\xf4\x6c\x1f\x51\x11\x77\x72\x14\xed\xb1\xd2\x56\xbf\x5a\xab\x0d\x70\x0a\x85\xda\xa4\xa1\x1c\xd0\x44\x60\x38\xc2\x24\x45\xb1\xf4\x52\xb2\x43\xb5\xb0\x34\xd0\x91\x0e\x75\x50\xea\xe2\xf7\x85\xd2\xb1\x3b\xf9\xf0\xa1\xa3\x81\xfb\x41\x64\xf8\x92\xcd\x7a\x31\x3c\x0b\x5e\x3e\xd7\xba\x5c\x78\x5c\xf8\x54\xf8\x4b\xf8\xd2\x7a\x1b\x88\xdc\xc1\xdf\x7a\xfe\xf6\x47\xe0\x38\x21\xca\x4d\x1d\x82\xe2\x9c\x87\xcf\x9a\x85\x3f\x84\x4b\xc2\x6f\x3f\x7c\x94\x98\x0d\x15\x0d\x1f\xd4\x0d\x9e\x38\x53\xe6\xeb\x53\x74\xa3\xda\xa1\x93\xda\x3b\x1e\xb2\xa8\xd4\x30\xa4\x0e\xe5\xa2\x08\x33\xcf\xa2\xd1\xb0\x51\x8f\xc7\xc1\xa9\xa2\xac\x1f\xc5\xc6\x7e\x8b\xc3\x5d\x93\x70\x98\xd3\x41\x26\x16\xbe\xb8\x25\xf9\x33\x29\xf9\x92\x4a\xe0\x7b\xb0\x96\xd9\xf9\x1e\xb4\xcc\x03\x8e\xa1\xeb\x36\xb2\xcb\x71\xc8\xe6\x98\xff\xf0\xd6\x40\x0e\x2b\x52\xf5\x25\xf9\x52\x65\xaa\xbe\x83\xf3\xc9\x91\x42\x99\x7a\xec\x50\xa4\xcf\xaa\x83\x83\x95\xc7\x4f\xcf\x4c\x93\xa7\x62\xd6\x3e\xac\xcf\x98\xa6\xef\x15\xb7\xd0\x2b\x50\xc4\xdc\x2d\x1e\xd6\x3a\x18\x1f\x15\xe4\x38\xca\x1a\xa4\xd4\x41\xe8\x8a\xb8\xa2\x3e\xc6\x03\xd5\xb8\x88\xeb\xd4\x40\xc2\x98\x8e\x9a\xf1\x66\xb5\x66\x36\x57\x49\xa5\x19\x14\x35\x23\x59\x89\xb0\x22\x28\xd6\x94\xc8\x34\x74\x4a\x04\x5f\xa4\x06\x22\x16\x1e\x03\x5b\x90\xa7\x1e\x12\x7e\xdc\x09\x18\xe0\x9a\xd5\x49\xf8\xb5\x80\x5c\xd2\xe1\xb5\x0f\x8e\xde\xbb\xe9\x93\x05\x73\x56\x76\x20\x57\x17\x08\xbf\xb7\x5f\x7a\xc7\x91\xd7\x85\x2d\x96\x9b\x7f\xdc\xf9\x3d\xa8\x5d\xa2\xb9\x20\x9c\x1d\x2a\xfc\x78\xec\xe8\x89\xc5\x9f\xae\xdf\xfe\x52\x4f\x50\x76\x41\x33\x40\xb8\x7a\xcf\x3b\xc2\x0b\xc7\x24\x3d\x16\x21\xbf\x76\x92\xbe\x0d\xed\xa3\xc2\xb8\xcd\xe0\x52\xd2\xb4\xc5\x05\x03\x7e\x3b\x0a\x37\xed\x94\x02\x12\xda\xb4\xe8\x19\x06\x34\x75\xbc\x64\x04\xe6\x4e\x80\x97\xe0\xba\xcb\x25\xa3\xaa\x06\x14\x39\xf6\x07\x81\x7b\x10\x44\xee\xd3\xbd\xb7\xe0\xd8\xea\xb1\x5d\xfa\x14\x76\xcb\x1b\xb9\x65\xc3\xe6\xed\x9f\x0a\x1f\x98\xde\x7a\xae\x67\x35\x9c\xd9\x70\x38\x5e\xfe\xf9\xec\x3f\xc1\x86\xea\x7e\x55\x68\x7b\xef\xdd\xbd\x5d\x50\x0a\xa7\x0e\x89\x72\x3d\x88\xe2\xb6\xe9\xc8\xdf\xf2\x44\xdb\xb8\x8b\x00\x3c\x49\xd3\x14\x05\x01\xd4\x18\x35\x26\x95\x7e\x54\x42\x45\xf1\x34\x80\x10\x48\x15\x95\x8a\x8c\xd3\x6f\x48\x5a\x80\x5c\x20\x12\xf8\x65\x94\x11\x00\xf9\x9e\xf0\xc9\x4d\xc2\x16\x10\x02\x10\xf4\xe9\xb5\x6b\xe8\xc1\xb9\xdb\x2b\xba\xe6\x74\xf0\x0b\x13\xc8\x2e\xb0\xb2\xf1\x5e\xf0\xe8\xa8\xfa\x95\xa7\x3a\xe5\xe6\x37\x36\x48\x7c\x7e\x0a\xcc\xf3\x1e\x41\x67\xcc\x1d\x52\x19\x35\x6a\xa3\xda\x4d\xba\x73\xc9\xa8\xc3\x57\x9d\x70\x00\x23\xa1\x66\x25\x42\x3f\x22\x5d\xc9\xca\x2c\xce\xa6\xd9\xfb\xd0\xf6\xc4\x84\x8c\xb4\xb5\xdc\x08\x3a\x91\x22\xfd\x84\x24\x51\x92\xc8\xaf\x6c\x70\xdf\x9e\x98\xc8\x0f\x30\xc8\xc4\x51\xc0\xb0\x00\x8c\x6f\x33\x76\x79\x4d\xf7\x8d\xa5\x6b\x4a\xcb\x0a\x3a\x7a\x1b\x13\x49\x5e\xbf\xe8\xc0\x85\x98\xd7\x4f\xd3\xba\x6b\x9f\xae\xad\x35\x61\xa2\x89\x3c\x38\x79\x52\xdb\x48\xf0\x74\xa8\x75\x9b\x6b\x55\x49\x8e\x3f\xb1\x67\x45\xac\x1d\x56\xc7\x0b\x94\x5a\x46\x0d\x38\x68\x50\xd2\x1a\xbd\xde\x88\x96\x92\x67\xb5\x18\xc3\x0d\x28\x55\x4a\x94\x64\xa8\x54\xb4\x0e\xed\x39\x1a\x05\x5c\x34\xdf\xbc\x0f\x30\x13\x7c\x54\xc2\x7c\x06\x62\x78\x25\xb2\xfa\xc9\xcc\x7e\xd4\xfd\x42\x6b\x61\x29\xd4\x17\x5e\xdb\x15\x05\xb7\x0b\xaf\xe4\x80\x73\xa0\x4f\xe3\xe4\x42\xf8\xef\xa8\xb0\x0f\xb4\x21\x97\x08\x53\x2e\xbd\x03\x8e\xbe\x0c\x12\x97\xde\x14\x36\x8b\xf2\x7d\x8e\x7c\x39\x40\xf6\xc0\x80\xa2\xc0\x22\xc8\x90\xb4\x5e\xc3\x69\x95\x84\x02\xc5\xe6\x2c\x41\xf0\x6a\xb4\x0a\xd5\x09\x3d\x84\x1a\x1d\x05\xf4\x14\x45\x11\x4a\x16\xb0\x04\x8b\xe9\x07\xb3\xe9\x92\xb2\xa6\x63\x53\x32\x06\x71\x37\xa0\x38\xd6\x8f\x6d\x3e\xa6\xde\x09\xe6\xfc\xf4\x74\x0e\x18\xf8\x8d\xe0\x8b\xc2\xdc\xc8\x85\xd7\x72\x84\xbb\x2f\x93\xe5\xd1\x57\xfe\x7a\xf9\x87\xb3\xaf\xfd\xf8\xf2\xaf\x6f\x4a\xf5\x9c\x43\xc2\x60\xb1\x2e\xef\xc6\x7e\x5a\xeb\xb0\x72\x46\xce\x01\x21\x6f\x36\x7b\x29\x08\x3d\x16\xa3\x09\x9d\x65\x2b\xc5\x71\x84\x09\x12\x4a\x74\x36\x5c\xa9\x8e\x82\x8a\xeb\xc4\x90\xbd\xa0\x78\x6b\x4d\xca\xc7\x19\x53\xc7\x89\x8b\x86\xa3\x53\x92\x02\x8f\xbd\x2b\x34\xb4\x03\x74\xb4\xcf\xc4\xfe\x63\x0f\x8d\xba\xef\x89\x15\x05\xe0\xfb\xc6\x21\x85\x94\x23\xda\xf8\xe9\xeb\xef\x3f\x24\xbc\x26\x0c\xfe\xd7\x23\xd3\xc7\x0e\x2d\x98\xf5\xdc\xd8\x03\x77\x5e\x02\xf7\xa1\x15\x2c\xb4\x5e\x3e\xfd\xae\x70\xea\x61\x2c\xef\x3f\x48\xde\xb8\xd8\xcb\xd2\x2f\x1e\xb5\xda\x18\x9d\x56\xa9\xd4\xd9\x20\x4a\x0d\x5c\x3c\x84\x4e\xa5\x16\x83\xd1\x32\xec\xe8\x84\x95\x61\x08\x15\x14\xfb\xe5\x33\x64\xce\xcf\xc2\x96\xcd\xb8\x30\x0d\x10\x38\x25\x2b\xc7\x53\xc4\xfe\xf4\x3d\x88\x78\x0d\xc2\xfc\x26\x5c\xbc\x1b\x84\x9f\x14\xd6\x46\x29\x47\x61\xe3\x60\xd0\xb3\x60\xc5\xa5\xc6\x75\xab\x3e\xbe\xf9\xf2\x54\xe1\x63\x61\x30\xb0\x5e\xfd\x17\x70\x1d\xd5\x81\xf3\x6f\x5e\x12\x12\x97\xbe\x3a\x77\xcb\x6d\xbf\xcf\x7c\x56\xb2\x37\x4d\x1f\xa0\xfc\x66\x0a\x7a\xef\x4e\x2c\x2f\xa4\xf4\x26\x23\xcb\x9a\x28\x68\xd0\x18\xdc\x76\x8d\xc6\xc5\x1a\x39\x23\x7a\xef\x96\xda\x04\xd4\xeb\x19\x8e\xc5\x6c\x6c\x8c\xf3\x7f\x97\x97\xc6\x41\x33\xae\x08\xe3\x70\x88\x08\x67\x89\x0d\x5e\x9a\xbe\xd6\x0c\xf4\x85\xc2\xd7\x1f\xdd\xfa\xc9\x1c\xa0\x06\xa4\xf0\x79\x0e\x5c\x1b\x6d\x3c\x0b\x34\xe1\x09\x9f\x3f\x3f\xe3\xfb\x09\x63\x75\x8f\x9d\x99\xfc\xfc\xd2\xaf\x80\xc6\x07\x66\xbc\x74\x56\xb8\xf7\x99\xfd\x87\x67\xad\xc3\xf2\xee\x17\x06\x50\x41\x24\x6f\x21\xd1\x37\x9e\xc3\x7a\x0a\x09\xa7\xc9\x6a\x22\x3c\x14\x6d\xb1\xdb\x8b\x23\x34\x5d\xe4\xb0\xda\xac\xd5\x09\x67\xa1\xc9\x44\xda\x58\x32\xaf\x4a\x24\xa5\xf8\x6f\x3b\x42\x14\x57\xba\x46\xef\x04\xc5\x2c\xa0\x08\x64\xed\x0a\xec\xc3\xe4\x34\xac\x1c\x2e\xdd\x28\x0c\x3f\xfd\x43\x28\x3e\x62\xde\xc1\x9d\xa3\x5a\xb7\x99\xb5\x6e\x82\x0b\x8c\x6b\xbc\x18\x85\x6b\x7d\xc2\xb4\x07\x8f\x94\x8e\xba\xeb\xd9\x03\x75\xad\xc6\x0c\x1b\xb3\xc9\x35\x59\x78\x62\xf7\xca\x4e\x23\x7b\xb5\x89\x46\x82\x91\x58\x38\x14\x35\x6c\x03\x86\xb3\xf7\x0a\x1f\x53\xf3\xa6\xf5\x9c\x5a\xdb\xb9\x20\x1c\x2a\x09\xb4\x29\x1f\x3e\x04\xeb\xf5\x15\x3a\x7f\x5b\x91\x7d\xf5\x11\xf5\xf1\x56\x7a\x8d\x81\x31\x78\x81\x9b\xb2\x58\xb5\x56\xda\x4d\xf9\x18\x5f\x80\x62\xd0\x0a\x22\x2b\x31\x3a\xe1\xb5\x38\x74\x3a\xc6\xe1\x40\x3b\xdf\x41\x31\x14\xda\x4e\x7c\xb3\x8b\x94\xd8\xf5\x6f\x25\x7d\xf5\x03\x44\xfa\x31\x06\xd3\x93\xe1\xf3\x88\x4f\x81\x9c\xf6\x48\xf1\x77\x8c\x9a\x2e\x2c\x9f\xf3\x7e\x7f\x72\x4b\x41\x43\x24\x5c\x7e\x64\xa3\x70\x39\x0c\x1a\x26\x8c\xbc\x67\xc8\x54\xa7\xf0\xef\x32\x40\xbc\xfa\xee\xe7\x1b\x9e\x24\x3b\x56\xdf\x3a\xe7\xd2\x4b\xf5\x8f\x4d\x78\x6e\xc0\xb6\xfe\x5b\x87\x8c\x6a\xff\xe8\x91\x87\x8f\x1e\xbb\x15\xfb\x0a\x5a\xec\xbb\xc1\x67\xa0\x7f\x3c\x8a\x02\x7a\x3b\x65\x73\xd8\x50\xd2\x08\x74\xc0\xa5\xd7\x51\x36\x7c\x1f\x48\xa9\x09\xb5\xa1\x3e\xa1\x36\x42\x07\xe1\x40\x67\x20\xbb\x8b\xcb\x86\x76\x16\x8a\xb0\x9b\x6d\x2a\xec\x79\x19\x24\xa3\x08\x6d\x26\x77\x9e\x88\x47\xd8\x18\x3c\x0f\xdf\x2f\x68\xfc\xad\xf5\xcf\xbf\x08\xaf\x08\x57\x4f\xff\xe4\x04\x56\xd5\xd4\xe1\x0b\x36\xef\x78\xe1\xe0\xe8\x13\xf4\xca\x0b\x3f\x9d\x79\x56\xf8\x5b\x78\xf5\xa1\x03\x1d\x07\x0d\xbd\x7d\xe5\xfa\xc9\xe0\x55\x2c\x27\x6c\xba\x02\xff\x12\xf7\x7e\x9f\x78\xd4\xcc\x40\x07\x65\x67\xf5\x7a\xa7\xdd\xc1\x00\x85\xdb\x45\xd9\x6b\x12\x2c\x45\xe1\xdb\x9c\xaa\x84\xc6\x02\x9d\x04\x4a\xf5\x09\xf6\x3a\x39\x9b\x5d\xc1\x26\x85\x34\x49\x0c\x09\x59\x52\x1e\x84\x83\xa2\x42\x8f\x92\x0b\x9f\x2f\xfc\xfa\xee\x27\xbf\xe4\x81\x5a\x5d\x37\x72\xd8\xf4\x9b\x36\xbe\x3d\xe8\x20\xd5\xee\xec\xc9\xdd\xf7\xce\x7a\x62\xd2\xfe\xed\xc5\xb5\x03\xc6\xd4\x0e\xee\x0d\xc4\x38\xad\x18\xad\xa5\x05\xe5\x29\x51\x7c\x43\xec\x35\x62\x1a\xe0\x1c\x87\xdd\x0e\x72\x18\x23\x9d\x97\xeb\xb0\x90\x98\x01\xdb\x62\x51\x01\x12\x54\x25\x90\x31\x40\xf2\xa5\x72\x94\xac\x36\xb8\xa4\x78\xa9\xcc\x44\x21\x71\x56\xa3\x9d\x9d\x66\xb6\x16\xa1\x35\xf1\x75\xf1\xbb\x1b\xc2\xbb\x37\x3c\xdc\xea\xeb\xf0\xd7\x7c\xb0\xeb\xea\xed\xcb\x7b\x08\xdf\xfe\xf6\xc1\x37\x5e\xc1\x34\x79\xc6\x2f\x37\x8c\x3c\xb3\xa5\xb7\x0a\x2e\xc1\x09\x4a\xad\xd1\x1b\x75\xfb\x02\xbd\x67\xd5\x1d\x7a\xeb\x96\xdd\xe1\xfe\xf1\xf5\x85\xed\x4d\x79\xbd\xa6\x0e\x08\x17\x4a\xbd\x01\x97\x90\x7d\x79\x91\xaa\x41\xeb\x66\xc3\x37\xab\x9c\x5a\xed\x60\x75\x16\x33\xa4\x00\xd0\xa3\x4c\xd7\xae\xb3\x58\x20\xc1\x3a\x19\x5e\xac\x4e\xb1\x44\x65\xea\x16\x22\x96\x55\x2e\x91\xf2\x97\x54\xc9\x95\x23\x68\x74\x1c\xa4\x6a\x6c\x88\x00\x1a\xa0\xa2\x38\xaa\xdb\x53\xb3\xee\x3e\x2e\x74\x14\xf2\xf2\x84\xcb\xf0\x89\x87\x67\xdc\xe5\x9a\x05\x82\x20\x4a\xb5\xeb\x34\x61\xd8\xa8\x47\xee\x17\x9e\x12\xc2\xf7\x7e\x4e\xad\x79\xe4\xf8\xe6\xc6\xa7\x57\x01\x09\xc7\xf4\x20\xfa\xed\x0e\x91\xbb\xcd\x12\x57\x49\x83\xeb\x04\x6e\x4b\x4b\xf1\xa1\x62\x19\x0e\xfe\x41\xbf\xf1\x4f\x6b\x31\xc7\x3d\x4e\x10\xb0\xbf\xcc\xf5\xe6\x8b\xeb\x21\x41\x31\x04\xa3\xc4\x74\x5d\x14\xfe\xb1\xd2\xca\x58\x06\xbf\x5e\xf2\x02\xed\xf8\xd5\xe7\xae\xe2\x6f\x10\xbf\x05\xe0\x09\x2d\x6a\x18\xfa\x0e\x23\x51\x1b\xcf\x53\xd3\x4a\x4a\xab\x35\x00\x1d\x72\xb3\x3a\x1a\xa2\x03\x68\x24\x8c\xa3\x13\x14\xa1\x61\x39\xe4\x26\x94\x1c\x4a\xf5\x38\x52\xc7\x93\x44\x36\x11\x63\x8a\xe9\x4e\x7e\xbd\xa9\x2a\x80\x44\x0a\xe3\x17\x7f\x49\x24\x31\xfe\x5a\xb0\xf1\x0f\xb0\x51\x98\x87\x7f\xfd\x21\xfd\x83\x6a\x0f\xb6\x0b\x33\xde\x11\xfe\xfd\x8e\x30\x13\x6c\x7d\x07\xa8\x9b\x9a\xf0\xd4\x2e\xb9\x4e\xec\xf7\xa1\x92\x77\x6f\xea\xcf\x98\x7c\x4e\xc4\x2c\xe2\x22\x44\x47\xfa\x94\xd4\x6f\xcb\x60\x5c\x3f\x6b\x5c\x07\xbd\x4e\xaf\xc7\xee\x08\x43\x8c\xbf\x8c\x1b\x66\x81\x34\x02\x2f\xfd\xac\xea\x3b\xfa\xef\xd4\xcf\x8e\xa0\x1f\x97\xfa\x6d\x15\x33\x92\x3f\xcb\x7b\x3d\x36\x3b\xfe\x59\x43\xb3\x9f\x6d\xd7\xf4\x83\xca\x20\xfe\x6c\x4f\xe9\x67\xa9\x6f\xa5\x9f\xa5\x77\xcb\x3f\x5b\xaa\x2b\x6d\x95\x5f\x10\x86\xad\x5a\x35\xff\xd9\x50\xd3\x15\xd5\xa4\xe4\x8c\x34\xc7\x10\x85\xd4\xbb\x49\xfc\x1a\xa6\x52\x9c\xd9\x90\xfe\xbc\x3f\xfe\xce\x2c\x8c\x80\x2a\xe9\xcf\x31\x46\x80\xf4\x3d\xea\x84\xf8\x3d\xad\xa4\xef\xa1\x5f\x4a\x7e\x8f\x32\x28\x7e\x5e\xfa\xf3\xfe\xf4\x2b\xc9\xef\x91\xbf\xbf\x26\xf3\xfb\x45\xbc\xb0\xee\x69\x6c\x7e\x15\x81\x4d\x0f\x9e\x63\x12\xa1\xf9\x0d\x27\x41\xff\x13\x06\x2b\x95\xd5\x03\x2e\x62\x86\xf5\xcb\xc0\x85\xdd\x40\xbc\x4b\x64\xe0\xc2\xb6\x3f\xd9\xbe\x73\x16\xce\x2b\xc6\x99\x58\x9a\xc6\x32\x57\x11\x44\x06\x96\xb9\xe2\x75\x85\xb6\x05\x9c\x89\xca\x0c\x0c\xcc\x0d\x2f\x67\x60\x60\x2a\x1e\xbd\xee\xf3\xcd\x70\xb7\x91\x0e\xbf\x11\x19\xb8\xdb\x78\x16\xb7\x85\x79\xc7\x34\xee\xe2\x86\x14\x8e\xa2\x88\xbb\xe8\xba\xc7\x15\xc8\x9a\x77\x6c\x86\xb9\x8c\xbe\x3f\xd9\x93\x2d\x36\xe3\xdb\x97\xdb\xbd\x2d\xcc\x44\xa4\x71\xf8\x36\x60\xc4\x89\x34\x0e\x9f\x77\xb9\x37\xdc\xc2\x4c\x44\xfa\xfb\x63\x10\xed\x63\xc2\x15\xe7\x20\x09\x5c\x78\xa2\x12\x03\xc9\x25\xa7\x15\xc4\xd1\x83\x0c\xbc\x3f\xc5\x3a\xe9\x39\x68\x1f\x8a\xf8\x7d\xe2\x8c\x47\x07\x50\x40\xe4\xc4\x4d\x30\x12\x21\x30\x8c\x9f\xd9\xef\x53\xbb\xc2\x12\xaa\x9f\xd8\x64\x0f\x92\xed\xf6\xad\x4a\x5a\x78\x7e\x6b\xf8\x68\xea\xf9\x01\xf1\xf9\x81\xe5\x01\xeb\x7f\x7a\xfe\x6f\xcd\x9f\xaf\x14\xc0\x92\xa6\x6f\x09\x27\xee\xf1\xf7\xe7\xf9\xbd\x2d\x3d\xba\x25\x2c\x6b\x55\x19\x7c\xbe\xb9\xde\x9b\xfe\xa3\xde\x8c\xbe\xf9\x73\xd1\x7b\x69\xff\xff\xeb\xb9\x6d\x20\xc6\xba\xf2\xc4\x0d\xe8\x89\xa1\x90\xf8\x60\xdf\x18\x5f\x20\xfd\x60\xfc\xfb\x7f\xd1\xb7\x91\x38\xfc\xff\xf4\x5c\x11\xd3\x8a\x1a\xc0\x2b\x30\x7b\xce\xf5\xbc\x18\xe8\xbd\x7f\x86\x3e\xe8\x8d\xab\x29\x48\x9a\xe8\x1c\xfc\xfb\x49\x30\xe4\x84\xc9\x26\x13\x57\x24\x97\x20\x85\xe5\xac\xd8\x2e\x9d\x41\x2c\x0b\xf1\xa1\x8c\x11\x73\x0d\xb4\xc1\xb2\x40\xb2\x63\x69\xc7\x0e\xb6\xbc\xb0\x04\xa6\xdc\x4c\x96\xeb\x9e\x5d\x4e\x4e\x42\xff\x43\xe4\xcc\xc0\x27\x1f\x92\x96\x93\x60\xe8\x09\x8b\xa9\x19\x67\x86\xfc\xdc\x43\xc9\xe7\x92\x7b\x88\x2f\x9a\x3e\x16\xf7\x9c\x19\xf4\x21\x0a\xe3\x6e\xb2\x5b\x85\xf8\xd4\xe2\x4a\x50\x59\x09\xd0\xef\xac\xf8\x77\x65\x4a\x0a\x83\x08\xd3\x89\x64\x11\x39\x38\x44\xce\x0c\xc5\x51\xf4\x7d\xeb\x25\xf9\x61\x13\xa8\xc6\x73\x9a\x16\x8c\x3a\x77\x12\xfc\x7e\xc2\x62\xa3\xd2\xb3\x1e\x12\x96\xb3\x38\xcf\x74\xbf\xf4\x79\x52\x23\xcd\x62\xc0\xb8\x21\x07\xc6\x27\xc7\xbb\x98\x72\x33\xb1\x5f\xc6\x35\xfd\xa8\x68\x8b\xe2\xd6\x08\x31\x2f\x5e\x69\xb3\x2a\x54\xe2\x08\x46\x38\x4c\x92\xb4\x97\xe3\x22\x90\xb6\xd2\x4c\x94\xc9\x55\x45\x22\xb8\xe9\x7b\x74\xc2\x46\x99\x08\x62\x05\x41\x6a\x30\xe0\x3c\xa5\x33\x99\x9c\xf5\x09\x13\xa5\x0b\xd4\x27\x74\xc6\xeb\x69\x25\x0d\xf8\x4e\x8d\x10\x63\x97\xcc\xfe\x19\x3e\x45\x9f\x87\x83\x02\xb1\xcb\x51\x9c\x2e\xa3\x82\xc9\x36\xa1\x64\xdb\x58\xba\x35\x08\x0e\x00\x35\x9c\xd8\xf3\xd3\x66\xbd\x7b\xad\x7b\x87\x70\xe6\x95\x54\x9b\x10\x68\xdd\x3a\xdd\x1b\x34\xe5\x95\x01\x8c\xf0\x20\xb8\x70\xc3\x39\xe1\x93\x5d\x77\x4f\x1c\x96\xec\x0e\x7a\xeb\x54\xaa\x29\xa8\x20\x1a\xc1\xb1\x4d\x23\xc6\xc0\xa2\xfa\x13\xb9\x44\x19\x31\x37\xde\x89\xe3\xf3\x7c\x54\x48\x17\x0d\x03\xa0\xd3\x85\x42\xe1\x12\x87\x92\x61\x1c\xb9\x61\xaa\x5c\xaf\x6f\x13\x62\xad\xa5\xd5\x09\xa3\xcf\x6d\xb5\xb2\x6e\x77\x61\x55\xc2\xcd\xa1\x00\x48\x49\x45\x59\x33\xa5\xae\x49\x50\xce\xd4\x70\x1d\xd2\x2f\xbb\x25\xaa\x32\x4b\x77\xb9\x13\x41\x2e\x53\x05\xc5\xae\x9b\x48\x58\x4c\x4e\xd0\x3a\xe0\x3a\x9b\x84\x64\x4d\xa4\x7a\x40\x59\x00\x63\x40\xe6\xcd\x13\x2f\x4a\x77\xbf\xd6\x56\x68\xf8\xf6\x5f\xef\x44\x80\x2d\xba\xb1\x6e\xaa\xbf\xb1\xb7\x91\x7c\x49\x5d\x48\xb6\x1b\xbd\x70\xc0\x9e\x53\x40\xff\xfd\xbc\x07\x5c\x24\x13\xa2\x81\x8a\xc9\xbb\xef\x45\xe1\xe0\xa4\x91\x6b\x6e\x39\x36\x6d\x71\xe7\x11\x0f\xee\x9f\x3e\xb7\x74\x58\xcf\xbe\x23\xbc\x7f\x0d\xae\xc9\x7f\xf5\x20\x28\x02\xd3\x66\x8c\xf6\xef\x50\x79\xcf\x34\x1c\x25\x8f\x4f\x9a\xff\xd5\xf9\x57\x46\x9d\x96\x7d\x46\x16\xe6\x1a\xb2\x1d\x3f\x10\x19\x98\x6b\x81\x33\x81\xe8\x7f\xc5\x5c\xdb\x00\x64\xb4\x24\x09\x73\xad\xec\x78\x59\xfb\xe6\x78\x62\x8a\xae\xe2\xf7\x17\xc9\xdf\x9f\x9c\xa3\x13\xf1\xc4\xf4\x5b\xf4\x26\x4a\xd5\x0c\x4f\xe2\x53\xf1\xf3\x03\x9a\xcd\x9c\xea\x74\xc8\x67\xe8\x7f\x6d\xf6\xf9\x71\x42\x9d\x78\x27\x2f\xfa\x3c\x0e\xcf\x92\x09\x29\x2c\xee\x03\x22\xf6\x45\xad\xfc\xe7\x01\x19\x43\x0d\x7d\x5e\xf1\xa4\xfc\xf9\x88\xf4\x79\xf1\xdc\x7e\x05\xea\xc5\x98\xa5\x64\x7a\x49\x31\xd4\xa0\x83\x5b\xdc\x3c\x56\x12\xbf\x33\x89\x3f\x20\xfe\x6c\x20\x03\x87\x00\xff\x6c\xe1\xd8\xc2\x02\x82\x09\xc3\x82\x82\x66\xf1\x8e\x54\x1f\xc1\x7a\x81\x85\xb2\x5e\x6d\x64\xbd\xbc\x5e\x3c\x0f\x79\xd1\x97\x03\x33\xb0\xf0\x9a\xf6\xa0\x67\x95\xe2\x75\xc6\xd4\xc5\x62\x6c\xf1\x90\xfc\x79\x97\x0b\x23\x84\xbc\xed\x0e\xda\x32\x70\x38\x30\x96\x91\x14\x2b\x80\xbf\x53\xb1\x82\xed\x71\xb4\x75\x0d\x22\xfc\x48\xe9\x09\xd6\x4c\xaa\xb2\xdf\x8b\xfa\x33\x31\x6e\x8a\x88\x71\x90\x18\x33\xca\xf1\xe0\xa9\x8c\x3f\x1f\x21\xc7\x4d\x28\xd6\x53\xbe\x9f\xc4\xb9\xc4\x7f\x2e\xc7\x65\xd2\xfe\xe1\x52\x98\x74\x02\xf8\x5d\x96\x33\x1c\xc6\x7a\x7d\xef\x0b\xb6\xb0\x7f\xbe\x48\xee\x1f\x62\x5e\x6a\xff\x88\x78\x74\xb1\x87\x62\x6d\xd2\xfb\x47\xc2\xfa\x50\x76\x46\x39\xaa\x8b\xe8\x12\x0f\x2a\x18\x1b\xa1\xb7\x1a\x8d\x26\x93\x9e\x81\x1e\xb7\x95\x1f\x95\xb0\x5a\x4d\x76\x33\x34\xf1\x1a\x72\x74\x42\x63\x54\x24\x13\x13\x09\x1c\x2d\x73\x56\x45\xe2\x24\x8b\x25\xb1\x98\xe4\x1a\xb7\xc8\xfd\x23\x82\x14\x29\xe8\x9c\xbb\xc6\x4e\x73\x2c\x06\xb6\x45\xad\xfe\xfc\xea\x93\xaf\x35\x41\x11\x02\x0e\x18\x40\x64\x1a\x39\x6b\x1a\x70\x9d\xd2\x80\x11\x77\xcd\xdf\x88\x9b\xde\xfe\xfe\xf6\xc1\x23\xae\x81\x47\x1b\x0f\xd2\x2b\x1b\xdf\x26\x5b\x35\x54\xb6\x17\x73\xa8\xf7\x85\x21\x74\x07\x64\x63\xf5\x84\x1d\x77\x27\xb3\x2a\x95\x93\x80\x66\x8b\x8e\x22\x49\xbd\x9e\x20\x1c\x0a\x1e\x0f\x6d\xe0\x4c\x0a\x05\x42\x4e\x91\xf8\x41\xb4\x21\xcd\xf3\x27\x88\x52\xff\xe4\x85\x33\xca\x9f\x80\xcc\x9d\xd0\x86\xe0\xf3\xc1\x38\xc0\xf9\xeb\x9f\x5f\x76\xf4\x8d\x5f\x05\x4e\x78\xbd\x10\x3a\x46\x8f\x5f\x79\xd2\xfa\xc0\xdb\xa0\xef\x21\x61\x08\x93\x7b\x78\xc2\xe0\x8b\xcf\xfd\x26\x74\x12\xe6\xce\xba\x44\x2f\x1d\x3b\xef\xc0\xd2\x86\x63\x83\x40\x3e\x18\x45\xb4\x80\x51\xd3\x88\x3c\x4c\x72\x32\x1e\xbd\x2b\xae\x8e\x33\xb6\x80\xed\x92\xc6\xa8\xe9\x8a\x11\x5b\xc4\xcf\x07\x02\x78\xc6\x71\xbe\xc7\x9f\x89\xed\x22\xfa\xd2\x05\xca\x8e\x92\x2f\x45\xe7\x63\x2f\x78\x96\xd8\x21\x62\xd8\x76\x05\x85\x44\x69\xdc\x4f\x45\xd8\x88\x37\x42\x42\x32\x04\xa9\x08\x11\x29\x30\xb3\xc8\x2b\x9b\xab\xcc\xcf\xa5\xa9\xa4\x90\x7b\xcd\x17\xe1\x5e\x64\xce\x33\xec\x67\x1f\x62\x1e\x49\xf9\xd9\xbd\xc4\x17\xf2\x3e\x5b\x44\xdc\x43\xb4\x8a\xfb\xa8\x1a\xb6\xc6\x5b\x73\x77\x0d\x94\x88\x0f\x50\x0a\x5b\x73\x43\x65\x45\x38\x8b\x00\x41\x16\x51\xe6\x3c\x93\x7c\xad\xb8\x0e\xeb\xa5\xef\x82\x17\xc4\x39\x49\xd2\x8c\x59\xb8\x4e\x92\xbe\x13\xe6\x16\x7c\xed\x17\x49\x5f\x4b\xcc\x23\x45\xdc\xcb\xc7\x60\x25\x72\xb5\x95\x27\x81\xfa\x44\x65\xda\xdb\xe2\x75\xc3\x5c\x2f\xe2\xf7\xdf\x29\x7d\x3f\xe9\x90\x7d\x73\x14\x45\x14\xd1\xab\xd1\x7c\x36\x0b\xc3\x4a\xc4\xff\x16\xbf\xff\x49\xf9\x4c\x4c\x4d\x7e\x1e\x3d\x20\xfa\x4f\x34\x9f\xd0\x64\xce\x55\x4a\x31\x4b\x41\x32\x66\x21\xdf\x21\xbb\x49\xb3\xc3\x18\xcf\x5c\x8c\x59\x8e\x59\x8c\x54\xd6\x2c\x69\x73\xce\x0b\xf2\x1d\xd1\xae\x8a\x3f\xd3\xad\x1b\x06\x1e\x89\xe7\xc7\x3b\x66\x73\x4c\xc8\xcf\x09\xa4\x9e\x73\x1e\x46\x50\x6c\x83\xd6\xc9\x89\xd6\xc9\x79\x12\x78\x4e\x38\xf9\x64\x4a\x94\x7e\xc6\x47\xa9\x67\x9c\x27\x5d\x92\x1e\x64\x77\x74\xb4\xbb\xcf\xef\x9e\x66\xd5\x48\x63\xb9\x8a\x7a\x44\x65\x3d\x5c\xc9\x19\x68\x89\x93\xc5\x18\x33\x72\xcd\xf8\xa6\x9a\xf1\x20\x20\x3d\xfa\x24\xe3\xb5\xfc\x7c\xac\x47\xe4\x64\xd3\xb5\x13\x91\x50\x26\x55\x41\xfa\x59\x81\xd4\xb3\xce\x93\x3f\xa1\x9f\x14\xf1\xba\xf1\xb8\xf8\x0e\x1b\xdb\x12\xee\xea\x47\xa9\xe7\x9c\x27\x79\x59\x17\x64\xda\xc9\x82\x9a\x82\x6c\xbe\x85\xa6\x67\x51\xae\xe6\x17\x75\x91\xb0\xf8\xde\x21\x56\x25\x75\x11\x01\xa7\x81\xa6\x58\xa3\xcc\xd6\xa5\x69\x13\x32\x1a\x3f\xa7\xf9\x10\xc8\x77\xaa\x89\xe4\x4f\xe0\x31\x6b\x4d\x38\xfb\x27\xd2\xfc\x56\x4c\x97\xd4\x73\xce\x83\x69\xe0\x46\x51\x0f\x0e\x1f\xe1\x07\xb8\x66\x78\x67\x18\xf3\xef\x2f\x51\x8f\xdf\xe4\xcf\xdb\xe5\x99\x5d\x0e\x1d\x61\x6e\x49\xf3\xcf\x4b\x39\x64\x41\x0a\x93\x47\xda\x5b\xe2\xfa\x46\xf1\xee\x25\x43\x27\x9b\x7e\x3f\x11\xf2\x67\xd1\x2b\x35\x5d\x87\xf9\x8f\xde\x4b\x2a\x8e\x0e\x87\xf1\x7b\xf1\x9f\x6c\xba\x78\xc2\xef\xc9\x82\xd9\x4f\x3d\xcf\x9f\x7a\xde\x79\x98\x07\x7a\x8b\xeb\x9c\x8b\x56\x2d\x77\x52\x6e\x9a\x59\x8a\x48\x3f\xe7\xa3\xd4\x73\xce\x93\x37\xc8\xef\x25\x07\xd3\x5a\x8c\xc9\x49\x33\x0b\x10\x69\xfc\x93\x82\x24\x76\x48\x7a\x8f\x41\x32\x18\xc4\xfa\x78\x9d\x5e\x17\x95\x3d\x33\x8f\xf3\xee\x27\xd2\x18\x28\x48\x17\x5b\x72\xce\xde\xeb\xc5\x6f\xc6\x59\xee\xb4\x31\x59\x78\xe6\xf2\x73\x02\xa9\xe7\xa4\xf6\x17\x89\x12\x29\x32\xb4\x38\x94\x46\x59\x49\xe5\xf6\x07\x45\x3d\x06\xcb\xef\xe5\x65\xf9\xbd\xf8\x30\x5c\xc0\x2c\x5f\x33\x9c\x15\x29\x57\x2b\x48\xcd\xd7\xa7\xde\x0b\x4a\x4a\x03\x78\x7f\x79\xf0\x98\xba\xc7\x99\x09\x19\xd0\x02\xd6\x3e\xd2\xe5\x36\xe9\xbd\x90\x20\x1a\xc5\xba\xa0\xf7\xf9\x17\x7a\x9f\x99\xb0\x01\xe9\xe7\x05\x52\xcf\x3b\x0f\xb5\xf2\x79\x09\x62\xa8\xdc\x41\xc1\x66\x7c\x4c\xd2\x73\x3e\x4a\x3d\xe7\x3c\x99\xc4\xe8\xcf\x45\xfa\xe4\x56\xe5\x36\xc3\xe8\xb7\x0b\x15\x99\x98\x25\xca\xbf\xc5\xfd\xc2\xfe\x0b\xe4\x9d\x6c\xba\xf7\x44\x5e\xb1\x0c\x2c\x22\x7e\xd6\x2a\x54\x64\x62\x96\x28\xff\x26\xfe\x91\x3e\x1b\xc1\x34\x5d\x91\x02\x19\x54\x44\xc2\x08\x41\xdf\x3b\x5b\x8c\x5f\xca\xe5\xcf\xfe\x29\x7d\x56\x75\x52\xf8\xfc\x84\x4a\x2f\xdb\x75\xf1\xb3\x37\x08\x15\xb8\xb7\x44\xc6\x07\x51\x28\xff\xee\x21\x7e\xd2\x89\x01\x0b\x52\xe0\x20\x04\x68\x7a\x58\x18\x4c\x3d\x82\xfc\x7a\x01\xd1\x39\x1e\x20\x7c\x06\x9e\xe2\x49\x8f\x8f\x0e\xab\x1d\x8e\xa2\x70\x21\x6d\xf0\x90\x90\xa2\xac\x39\x61\x97\x55\x87\x2f\xb9\xd2\xf0\x1b\xd6\x8a\xcc\xe2\xa8\xdc\xa0\x1f\x51\xd0\xe5\x6d\x42\xa9\xf1\x28\x26\x8c\x47\x53\x71\x1f\x13\x10\x49\x18\xb4\x80\x2e\xef\x44\x43\xad\xed\xde\xc6\x2b\x05\x0d\xa0\xfd\xb6\xbe\xb3\xc6\x8f\x19\xdf\xc7\x29\xfc\x19\x18\xbb\xe2\xf8\xf6\xab\x80\xcd\x19\x90\xa8\x5e\xdf\x44\x08\xc3\x85\xfb\x8a\x06\x9d\x7a\xec\xd0\xd2\x3e\x60\xcf\xc0\x82\x21\xb7\x7e\xd7\x7b\xf6\xc8\x85\xb5\xb5\x23\xfd\xbd\xbb\xb6\x1a\xb1\xe6\x86\x82\x67\x0f\xf7\x9f\x7f\x63\xff\x89\xdb\x0f\x0b\x7f\xbe\x79\xa8\xf7\x6f\xa6\xa2\xce\x37\xcc\xdf\x87\xf5\xb9\x55\xa8\xa1\x78\x6a\x00\x11\xc6\xbd\x4c\x4e\x5e\xc1\x78\x19\x37\xcb\xd3\x56\x42\xa7\x8b\x58\x73\x7c\x0a\xd6\x0d\xbd\x5e\xb5\xcd\xaa\x86\x35\x09\xb5\xd4\xcb\x54\xfc\x1f\xd5\x91\x7a\x98\x92\x97\x12\xe2\x3d\x0c\xa0\xe8\xf2\x02\xa4\x1f\xd6\xb4\x13\x45\x0a\xc3\x6a\x07\xaf\x0d\x7e\xd2\x1a\x28\x4e\xbe\xfb\xfe\x8b\x39\x05\xab\x7f\x17\x16\x08\x57\xf3\xc0\x24\x30\xc6\xfe\x98\x50\x9b\x7b\xcf\xcb\x6f\x8e\x29\x83\x9a\x2e\xbd\x87\x55\xb7\xd9\xbe\xf7\xee\x3b\x9f\xdf\x12\x5a\x54\xb9\xe3\x7f\x0e\x4c\x33\x7e\xec\xf9\xea\xc9\x8e\x85\xdd\x7a\x7d\xe0\x88\xf6\xe8\x3a\xba\x19\x3e\x5d\x7e\x8b\xf9\xc4\x53\x28\x3f\x68\x8e\x4f\xfc\xb7\xf8\xf9\xbe\xf2\xe7\x97\x48\xd8\x0e\x22\x7c\xbd\xeb\x24\x28\x3a\xe1\x0a\x64\x20\x14\xe3\x5c\x39\x4f\xa8\xa3\xf1\x1d\xba\x85\x28\x8b\x3b\x29\x13\x6e\x44\x56\xab\x35\x26\x8d\xcd\x6a\x60\xf0\x50\xab\x5e\xa3\x85\x1a\x1e\x88\x6d\xc8\xf2\x14\x46\x45\x16\x10\x94\x5f\x46\x8a\x13\x87\x30\x92\xa1\x1c\x43\x8d\x14\x3e\xbf\xe8\x99\x3c\xfd\xe8\xfe\x73\xc2\xe7\x80\x07\x9c\x63\xc4\x27\x37\xbd\xf2\x96\x13\x45\xc4\x7b\x36\x0c\x9a\x3b\x65\xd5\xb5\xf3\xf4\xca\x55\xbd\xaa\x9e\x7e\x66\xd0\x3a\x02\xf3\x82\xb4\x43\xb9\x4a\x77\xf1\x1e\xbd\x8c\x88\x13\xa3\xe2\xb1\x0a\x7b\xa4\x50\x0f\x0d\x61\x03\xdf\xc9\x64\xf2\x86\x5b\x2b\x14\xfe\x30\x6f\xa7\xbb\x74\x0e\x9a\x2c\x6d\x5c\xce\x0e\x16\x03\xc0\xe3\x89\xea\x12\x71\x24\x31\x9a\x31\x92\x28\xe5\xea\x95\xc5\x31\xb1\x79\x3e\xfb\xb2\x21\xd9\x5c\x73\xdd\x58\x22\x8a\x8a\x19\xa9\x2f\x41\x6c\x7b\x44\x6f\xb9\x3c\x52\xd6\x3a\x7b\x44\x51\xee\x12\x0c\xa0\x37\xdf\x7c\x5a\x71\x28\x30\xff\xc2\xad\xda\xba\xe9\xde\x8b\x2f\x4d\x79\xa1\xdf\xc6\x5b\x5a\x1d\x22\xf5\xe9\xa1\x45\x58\xd5\xa7\xae\x5b\xe9\x86\x7a\xc5\xf4\xcc\xf1\xc5\x89\xe0\x99\x6b\xda\x49\xd5\x9b\x16\x1c\x7e\xae\x47\x8f\xb5\xbb\x2b\xb6\x7a\xbd\x23\x7b\x65\x4e\x32\x0a\x33\x3a\xb7\x29\x2c\xab\x8f\xf5\x24\x48\xa2\x35\xf2\x05\xdf\xd3\x3b\xd1\x9e\x68\x45\x0c\x89\xb7\xa2\x35\x51\x03\xe1\x29\xb6\xd9\x3c\xce\x00\xa3\x33\x68\x94\xb1\x52\x9d\x13\xe6\xc3\xfc\xd1\x09\x7f\x60\x74\x02\xa2\x38\xdf\xac\x34\x87\x47\x27\xcc\x46\x25\x23\x0e\x7a\x64\xd7\x31\xf2\xaf\x1b\xa4\x96\x72\x06\x4b\xcc\x87\xf6\x72\x39\xda\xda\x1c\x2d\x11\x35\xe3\x21\x65\x94\x3d\x54\x02\xb4\x5a\x21\x14\x21\x29\x8c\xa5\x6d\xd2\xd3\x8e\xe0\xea\xcc\xc9\x80\xd9\x1c\x78\xee\x65\xe1\x3d\x30\x6e\xd6\x4e\xe1\xdb\xe7\xaf\x08\x4d\x0f\x1f\x06\x8f\x03\xed\xbf\x83\x53\x12\x37\x6c\xd9\x37\x73\x61\xfd\xda\x5e\x0b\xe0\x97\xbd\xab\xbf\xdb\xa9\x39\xa3\x3a\x76\xbb\xd0\x54\x4f\x59\x77\xcd\xda\xfa\xc1\xec\xd3\x4f\x6c\x3f\x13\xa4\x86\x1c\x3b\x72\xea\x95\x21\x0d\xab\x37\x2f\xba\x71\x64\xf7\xb9\x7d\xc6\x4d\xc4\x77\x1a\x6d\x30\xc6\x2d\xfd\x0e\xda\x0f\x31\xa2\x57\x3c\x62\x75\xe7\x87\x0c\xea\x56\x10\xaa\x15\x7a\xbb\x3f\xe4\x56\x96\xb5\xf6\x29\x4c\x85\xa6\xc2\xaa\x84\xc9\x44\x38\x74\x04\x11\xcd\x68\xf6\x4a\xb6\xe5\x36\xd7\x8f\x96\x55\x91\xc6\xf9\xac\x32\x3c\x59\x1b\x59\xe3\x14\xb7\x3a\x15\x91\x48\xd7\xc5\xff\x4f\xe6\xff\x22\x34\x3c\x71\x18\xd4\x8c\x79\xf9\x89\xfe\x35\x63\xa6\x4e\x59\xb5\xaf\x6e\xdd\xb4\x05\xbb\xf6\x82\xb1\x37\xed\x11\xbe\xbc\x75\xfd\xc1\x5f\xc6\xad\xed\xb9\xc8\x74\xfa\xc4\xde\x4f\x73\xa8\xe8\x9e\xe1\x7b\x3e\x6a\x77\xbb\x7f\xfd\x90\xf1\x33\x76\x2e\x5c\xda\xe7\xf6\x8a\xe3\x53\x56\x3f\xd5\x9e\x72\x1f\x9a\xb1\xf5\xf3\x05\x67\xee\x58\xfe\x7e\xcf\xc5\x03\x66\xdf\x28\xdd\x73\x9f\x13\x2e\x8a\xfd\x17\x46\xa2\x63\xdc\xa3\x57\xa9\x00\x4f\x40\x68\xa6\x79\xde\x64\xa4\x79\xba\x3e\xa1\xe5\x79\x0a\x90\xa0\x3e\x41\xa6\x6e\x22\x4f\x67\xdf\x16\xa7\xcb\x4d\x0c\xf0\x4b\xd8\x85\x11\x2c\xba\xbf\x1c\xee\x96\x7a\x2b\x1a\x46\x92\x81\x35\x6b\xf3\xbd\xbf\x95\x4f\x6a\x38\x19\xa5\xee\xbc\xf4\x66\x43\x6c\xee\x8d\x1d\x1e\x6c\x97\x53\xdf\x65\xe0\x3b\x92\x1c\x9f\x0b\x17\xc4\x3e\x0b\x33\x96\x83\x43\x72\x98\x90\x1c\x56\xda\x64\xb2\x98\x69\x13\x5d\x9d\xd0\x9a\xcc\x58\x8e\xea\x04\xc9\xfe\x1f\xe4\x90\xac\xbe\xbf\x9c\xdc\x26\xb5\x53\x34\xce\x03\xb3\x97\x6f\x2c\x71\x5e\x32\x85\xda\xb6\x6a\x9c\x93\x03\x67\x9c\x7d\xad\x71\xf8\x4d\xe3\x7b\xdd\x55\x14\x0a\xf7\x8f\x16\x95\xbc\x92\x8a\xf7\x45\x9c\xe7\x90\x8c\xd3\xf2\x36\xd0\xe3\xbb\x09\x9e\xc7\x5c\xc3\x98\xd4\x97\x35\xb4\x70\x37\x51\x2e\x62\xb5\x74\x93\xb1\x5a\x3e\x93\xf3\x6c\x9c\x25\x91\x15\x87\x2b\xda\x67\xdf\x4d\x48\xbc\x01\x5c\x84\x58\x04\x50\x64\xc9\x2b\x88\x68\xaa\xe6\xd1\x8e\x1a\x80\xff\x9c\xd8\x2f\xfe\x79\xaf\x16\xef\x1a\x62\xf0\x37\xa9\x66\x4d\x41\x32\x20\xd6\x6c\x03\x8f\x07\x92\xd8\x87\x19\x35\x6b\x31\x7e\x53\x6c\x4a\xd6\x50\x24\x2e\x26\xb1\x86\xd2\x03\xb4\x22\xba\xc7\x8b\x25\x36\x26\x82\x09\x53\xc5\x21\xb0\x35\x04\x1e\x0a\x81\xe5\x21\xc0\x86\x40\x28\xee\xf0\xf6\x0a\xc5\x4d\x56\xf4\x9b\x8a\xeb\x15\x92\xc8\x9b\xc4\x80\xc5\x90\x9f\x8f\x49\x88\x67\xce\x92\x2b\xbb\x2d\xc8\xd7\x16\x62\x1c\x53\x11\x67\x31\x17\x87\x7d\xb9\x2b\x72\x3d\x19\xc8\x8c\x19\xb2\x9d\x4a\xd5\x77\x44\x5e\x29\x51\xb6\x18\xca\x96\x02\x71\x33\x8c\x79\x63\x65\xc1\xe2\xb0\x48\x31\x85\x44\x4c\x49\x20\x73\x6a\xa7\x30\x2d\x3f\x49\xc5\xb3\x7b\xc0\xa7\xe8\x5d\x49\x9c\x07\x98\x2d\x75\xbd\xdb\xdb\xc2\x1d\xcc\x1b\xa9\x78\x76\x0f\x50\x11\x49\x8c\x4a\xcc\x96\xb5\xda\xe1\x6a\x01\x73\x32\xad\x57\x39\x39\x2f\x99\xc7\xe1\x4b\x1e\x14\x9f\x3f\x14\x0a\x64\x06\xe7\x29\xbd\xb6\xa6\xf4\xda\x03\x14\x4d\xaf\x89\x7a\xe5\x83\xd6\x84\x19\xc5\xa8\x53\x1d\xee\x6c\x75\xc4\x35\x14\x71\x91\x14\xfb\x92\xb8\x48\xe8\xf3\xcb\x41\x97\x34\x3e\x10\xab\xce\xe4\xbf\x4c\x61\x22\x0d\x4b\x61\x22\xdd\x22\xf2\x3d\xe0\xcf\x63\x48\x24\xfb\x52\x7b\x33\x4e\xa4\x7a\xa1\x0e\xee\x14\xe7\xde\x7c\x44\xdb\xb8\xd3\x4e\x9b\xcc\x1e\x82\xd0\x18\x0c\x66\x1a\x06\x74\x3a\xbf\x09\x10\x2c\x69\x51\x3a\x5d\x24\x21\x3b\xae\x74\x89\x35\x65\xbf\xc2\xcd\x3c\x14\x6e\xaf\x03\x7e\x98\x76\x4b\xa0\x7a\xe5\xce\x0c\x1f\x44\xb3\x80\x02\xf6\xa1\x49\xe7\x33\xa3\x26\xed\x6b\xec\xe1\xfe\x7d\xe9\x76\x7f\x57\x25\x3d\x8c\x88\xff\x82\x7b\xd9\xa8\xfe\x44\x11\x51\x41\x54\xc5\x73\x2d\xf9\xe5\x58\x42\xbf\xcb\xe5\x76\xeb\x0c\xf9\x54\xbb\x52\x9a\x6e\x1f\x72\x47\xa3\xb6\xea\x44\x94\xf3\xb1\x6e\x33\x41\x16\x2b\x9d\x65\x49\x89\x53\x73\x4a\x59\xe3\xd3\xff\x45\xf4\xff\x38\xbb\xa4\x60\x8c\x69\x9d\x28\x76\xe5\xae\x2c\x9d\x12\x2d\x0e\x35\xe9\x99\x3e\xff\x49\x4f\xf0\xc2\xf5\xa3\x4e\xf6\x19\xae\x86\x2d\x29\xe5\xc9\xa6\x17\x71\xdf\x05\xdd\x96\x70\x23\x5b\x50\x15\x8f\xfa\x59\xb5\x22\x27\xc7\x0c\x9d\xc0\xc9\xb0\x54\x9e\xd5\x9a\x1b\x32\xab\x2d\x5a\x2d\x69\xb1\x78\xf8\x16\x3b\x1b\x62\x95\x52\x07\x6a\xfa\x56\x20\x7d\xfd\x9d\xee\xbc\x6e\xe9\x05\xa6\x55\xfd\x3e\xd5\x80\xdd\x7b\xd5\xb6\x94\xce\xbe\xa7\xd1\x7b\x7c\x26\xa9\x9c\xd4\xe3\x20\xac\x4f\xe9\x98\x73\x0f\xd6\x51\xd8\x90\x54\x06\x88\x58\xef\x18\xfb\x5e\x4b\xf8\xe3\xac\x52\xa5\xd2\x93\xa4\x2e\x09\xee\x4e\xa4\x66\x6b\x5a\x00\x6d\xcf\x86\x6a\xcf\x82\x67\xc7\x31\x5a\x97\xa6\x1f\xc4\xf9\xdd\x08\xca\x63\xba\x11\x33\xe3\xc8\xbd\x86\x73\x72\x3a\xf0\x46\x63\x87\xae\x8a\xd6\x2e\x45\x07\x17\xec\xd1\xdd\x68\x54\xe3\x18\x32\x18\x0a\xa9\xd1\xcf\xa8\x0d\x20\x5a\xa9\xae\xac\x4a\xd8\xd4\x5c\xa4\xa4\x1c\x96\x57\x25\x70\xf1\x17\x77\xdb\x8b\x97\x28\xa9\xce\x6c\x03\x6e\x0c\xaf\x28\x8e\xc9\xbf\x5a\x95\x34\x1b\xf7\xc5\x7f\xb5\x14\xb4\x95\x4b\x7b\xc6\x0d\x92\xf3\x2a\xb8\xeb\x30\x7b\x44\x25\x0b\x65\xe2\x8f\xeb\xe2\xb6\x69\x50\x82\x8f\x92\x66\x58\xa8\x1c\xe1\x1a\x4b\xee\x49\x43\x0c\x35\x38\x5a\xc4\x9e\x40\xc1\x5b\xe3\x69\x80\xb1\xa4\xf4\x4f\x8b\x23\x2d\x8f\xec\x27\x7f\xc8\x44\x1d\x6a\xf4\x37\xc3\xa4\x80\x44\x27\xa1\x8e\x19\x8c\x72\x91\x10\x51\x42\x54\x12\x33\xe2\x6d\x01\x69\x34\x91\x26\xb5\xbb\x4d\x6e\x47\x75\xb1\x5b\x9d\xeb\x86\x9d\xe3\x04\xe1\xa7\xa0\x81\xe7\xfd\x16\xab\xd5\xe1\x37\x39\x5b\xc1\x7c\x7f\x7e\x55\x02\x30\x7e\xae\x22\xec\x08\x57\x25\xf4\x0e\x0c\xdb\x9a\x1c\xbd\x94\x57\x11\x2f\x9f\xb4\x76\xf8\xf7\xcc\xb5\x4b\x77\xda\x63\xec\xac\xec\xd9\x1e\x74\xf0\x52\x3d\xd0\xd2\xa2\x02\x71\xcd\xe4\x70\x37\x1b\x94\x69\x4d\x0e\xa0\x79\x98\x31\xee\x43\xcd\x11\x2e\x0d\x0e\x51\xbd\xef\x9f\x7f\xfb\x13\x2b\x2e\x1f\x58\xb5\x25\x57\xd8\x30\x6d\x53\xbf\xe3\xd3\x57\xf7\xa4\xc2\x19\x73\x3f\xeb\x1e\x7d\x20\x3d\xf9\xd3\x78\x08\x3c\xbc\xb7\x3e\x71\xfa\xd8\x69\x30\xfd\xf9\x61\x53\x1b\xc3\xab\x00\x35\xef\xe2\x4a\xe1\xea\xe2\x0f\xc8\x2f\xb3\x06\x81\xa8\xa6\x0f\x9a\x8e\xd3\xfb\xd1\x7e\xd3\x11\x26\xc2\x4a\x38\x88\x35\xf1\x5e\x2a\x8e\xb5\x53\x94\x9a\xb4\x98\xb5\x94\x06\xea\x1d\x36\x48\xf1\x28\x0d\xa0\xd4\x1a\x8a\xd7\xe8\x28\x17\xad\x70\xaa\x54\x8c\xd9\xcc\x58\xad\x0a\x35\x43\x3a\xf4\x8e\xfa\x84\x45\xaf\x67\x28\x05\xc1\x33\x7c\x7d\x82\x81\x0a\xdb\xe8\x84\x82\x4f\x77\x8e\x73\x67\x92\x5d\xac\x36\xf1\x5f\x0d\xd2\xdf\x68\x9d\x0c\xe9\x35\xb4\x56\x24\x7f\xe1\xc1\x63\x0c\x53\x80\x92\x1d\x6b\x79\x0c\x18\x91\xbb\xcc\x29\x53\x30\x56\x26\x06\xca\x83\x14\x5b\x2e\x3c\x20\x9c\x39\xd0\x4e\xf8\x37\x34\x82\xe1\xf6\x03\x07\x84\xcf\x1f\x6f\x84\xbd\x80\xc6\x6d\xee\xbf\x67\xed\x3d\x8d\x37\xef\x2f\x04\x93\x84\x1e\xb5\xf4\xca\xdd\xdf\x08\x13\xaf\xbd\x49\xf6\x00\x0b\x5e\x0d\xc4\x6f\x7b\xe7\x19\xa1\xd3\x05\x79\xce\xf2\x38\xfd\xa5\x38\xdb\x95\x43\xec\x8e\x57\xbb\x78\x03\x52\xd4\x4d\xf8\x03\x2a\x4a\xed\x51\x6b\xdc\x1e\xaf\xc7\xaa\x81\x10\xea\x23\xfa\xa8\xc5\xe2\x50\x33\x71\x95\xca\xc1\x68\x0d\x28\x5a\xd4\x32\x6c\x20\xc0\xf8\xfd\x0e\x86\x77\x8d\x4e\xf0\xbc\x83\xf1\x10\xa3\x13\x1e\x07\x13\xc2\xe8\x06\x0e\x53\x7d\xc2\x91\x1e\xcb\x4c\x41\xfd\x26\xe7\xd7\xa4\xfd\x23\xff\x97\x83\x7b\x2b\x35\xa8\x61\xb0\x56\x64\xad\x02\xb2\xe5\x38\x7e\x4e\x91\x29\x5a\xe9\x1c\x4c\x9e\x28\x03\x1a\x45\x98\xa0\xcc\xaa\x48\x80\xbc\x09\xa3\x30\x66\xd1\x81\xf9\xbd\x0e\xcc\x5b\x5b\x2c\xfc\x64\x2a\x6e\xbc\xaf\xd7\x98\x24\xa4\xd1\x83\x2b\x06\x1d\xf8\xa1\x23\x59\xdb\x61\xc0\xaf\xc2\x8f\x93\x6a\x7e\xd9\x8a\x71\x8b\x4a\x26\x1c\x1e\xf3\x78\xcf\xde\x65\x0d\x8f\x86\x45\x3c\xa3\x8a\xf9\xe4\xd6\x1d\xc3\x60\x37\xa7\x08\x61\x84\xec\x74\x2d\x8a\xdd\x94\x68\x7d\xdc\xc8\x0a\xcd\x8e\x77\xf2\xe9\x74\x36\x0a\x9a\x55\x6a\x93\xd9\x9c\xab\x8e\x42\x68\xb4\x58\x14\x46\xbb\xdf\xef\xac\x4d\xf8\x7c\x0a\xa3\x4b\x59\x93\x30\x01\xb5\xd3\x10\xc4\x60\x2f\x46\x7f\x4d\xc2\xc8\x2a\x5c\xd5\x09\x05\x51\x25\xcd\xcf\x64\x82\xd8\xa4\xd1\x33\x70\x13\x93\xb4\x28\xd9\x9d\x99\xd2\x3c\x04\xee\xcc\x8c\x80\x20\x48\x82\x1c\xa1\x3d\x20\xaf\x42\x44\x52\x5d\xc1\x28\x48\x5b\x12\xe5\x68\xc5\x78\xe1\xdc\x01\x30\x66\x2e\xc6\x3a\x4a\xd4\x00\xf3\x01\xe1\x85\xa5\xac\x70\x01\xaa\x84\xf9\x79\x93\x48\x30\xdd\x1b\xc6\xa0\x48\xc7\x44\xc0\xa3\x3c\xa1\x33\xc9\xcc\x10\x51\x8f\x6c\x60\x97\x50\x38\xea\x84\x35\xc7\xd7\xf8\x5c\xce\xf7\x61\x0d\x69\xd7\xed\x78\x6a\xb6\x98\xb3\xe7\x4b\x9c\x0b\xe8\x5c\x74\x88\x7b\x29\x82\xd1\x68\xd0\xca\x28\xb5\x14\xab\xc7\x43\xeb\xa3\xf1\xd0\x7a\x8a\x93\x20\xd5\x16\x9b\xdd\x9a\x95\x39\xbf\x2e\x61\x58\xe7\x2f\x5b\x16\x59\x3e\x05\x44\xa6\x80\xe9\x51\xe1\xd6\x5a\xf2\xf7\x02\x72\xf3\x59\x32\xb7\xf1\xc3\xb3\x42\xdd\x05\x69\x4e\xb2\x0b\xda\x9b\xb3\xd1\xda\x73\x28\x63\x19\x1e\x2f\x32\x00\x23\x49\x31\xd0\xa8\x54\x92\x90\x56\x68\x75\x0a\x15\xd4\x51\xac\x89\x35\x1b\x0c\x6a\x8a\x82\x5a\xb5\x02\xf2\x84\x51\xa5\x56\xd5\x27\xf4\x6a\x28\xdb\x2c\x9c\x3b\xa4\xce\x59\xe6\x1d\xb2\x9c\x46\xc8\x48\x20\xd0\x5f\xce\x04\x01\x9e\x78\x11\x1d\x27\x8d\xce\xd6\x52\xe1\xd0\x06\xe1\x63\xcf\xb1\x03\x60\xc3\x66\xa1\xa2\x00\xbe\x5c\x7e\xa0\xbc\xba\x40\xb0\x2c\x1f\x41\xed\x13\xc2\x8d\x9d\xf6\xfc\x48\x3a\xc8\xf7\x2f\xf4\xed\x7b\xe1\xf8\x71\x69\x6e\x01\x48\xf8\xbf\x28\x7a\xec\x1b\xcf\x0b\x05\xad\x25\xb9\x6e\xc0\x71\x6e\x65\x49\x90\x6e\x1d\xcb\x0d\x19\xac\x80\x26\x7c\xbe\x48\x4d\xc2\xc7\x69\x50\x9a\xa3\x71\x12\xa6\x9a\xf4\x24\x6a\xe6\x50\x5b\x56\x12\x19\xc1\x8d\xda\xe2\x2c\x58\xa0\x08\x10\xcd\x09\xc0\xc5\xbe\x7d\x7c\xcf\x2f\xb5\x32\x62\x2c\x3f\xf0\x4b\xaf\x85\xdd\x3b\xfa\x0d\xfd\x2d\x91\x44\xe7\xea\x35\x0b\x85\x3f\x3c\x2f\xb6\xba\x7f\xf2\xb4\x99\x55\xdb\xcf\x1c\xbc\xf6\xdd\x9b\xaf\x39\xae\x19\xc6\x0c\x7e\x33\xb7\x6a\xdd\xe3\xbb\x84\x26\x93\x7a\x45\x5b\x3b\x43\xbf\x66\xe8\x31\x1f\xcc\xac\xd8\x5d\x3b\xa2\x47\x97\x58\xb9\xb7\x70\xef\xca\xfd\x47\x36\xee\x72\x77\xef\xb4\xc0\x5f\xe8\xf7\xe6\xde\xbe\xe4\xf8\x09\x29\x77\xab\x13\x73\x37\x1b\xae\x6f\xb1\x90\x20\x69\xda\xc1\x10\x84\x9d\xd7\x55\x27\x78\xa7\x02\x52\xb0\x3a\x41\xb1\x80\x21\x98\xcc\xb6\xf8\x8c\x69\xa8\x64\x02\xd7\xaa\x24\x98\xea\x2f\xb6\x62\x95\xa4\xb9\x23\xa4\x54\x30\x98\x43\x6e\x4e\xe6\x70\xbd\xb7\x0e\x1a\x34\xbf\x22\xda\x21\x3f\xd1\x79\xd8\x3d\x37\x24\x6e\xe9\xf3\x0a\x79\x3f\xce\xe3\x14\xe3\x27\x4e\x1e\xa6\xfd\xd4\x30\x69\xda\x4d\xe3\xf0\xda\xcf\x42\x7b\x54\xa0\x77\x21\xbb\xdd\x2d\x1e\xc0\xc7\x13\x72\x6a\x33\x07\xed\x36\x95\x4a\x67\xb1\x98\x75\xe2\xbc\x0b\xa1\x33\xf3\x3a\x05\x1e\x5d\xce\xc4\xdc\x93\xcd\x51\x56\x08\x90\x0c\x92\xa4\xf2\x9b\x8f\xc0\xcd\x96\xc8\x7b\x59\xc8\xc2\xf3\xef\xde\xbd\x71\xfa\xbe\xf2\x3f\xaa\x81\xff\x27\x40\x83\xa8\x70\x56\xf8\x3d\x2e\x7c\x3c\xb5\x9c\x0c\xbc\x78\x6a\xc5\xce\x59\xcb\xfa\xbd\xfe\xac\xf0\xf7\x8f\xc2\x35\xe1\x05\x5e\x38\x41\x16\xeb\xa4\xbd\xd1\x09\x39\xe4\x03\xc8\x17\x9b\x88\x48\xdc\x48\xb1\x6a\x82\x85\x16\xb3\x4a\xa5\x25\xcc\x5a\xa6\x36\xa1\xe5\x52\x02\xc9\x42\xe0\xe3\x92\x0c\xd4\x22\xbc\x5f\x6a\xa6\x65\xe0\x6b\x43\x8e\xbd\x98\xe8\xbf\x37\x7a\x79\x20\x58\x70\xfa\xbd\x91\xc7\xe6\x75\x04\xcf\xdf\xbe\x71\xc8\xe8\x6d\x26\x50\xfc\xec\x91\x45\x8f\xce\x30\x08\xaf\x60\xdf\x8f\xf9\x44\xe8\xc5\xe8\xcc\xf2\x84\x17\x45\x98\x23\xe3\xad\x42\x0a\xa7\x16\xd9\x4c\x2b\x8f\xb6\xa4\x49\xa5\x55\xd0\x79\xb9\x16\x9e\x37\x12\x2a\xaf\xcf\xe7\x45\x6b\xe3\x23\x7c\x1c\xc9\x59\xeb\x13\x1c\x4f\x46\xe5\x12\x00\x71\x1d\xa0\xa4\x84\x05\x00\x32\xc2\x4d\x31\xe0\x44\xc7\x3a\x0b\x4b\xd2\x18\x0c\xe3\x16\xe0\xeb\x10\x25\x8d\xf3\x8e\x91\xbd\xb2\xa0\x24\x2b\xe7\x81\x17\x81\x21\x22\x5c\x35\x5d\x07\x29\x49\x32\x70\x51\x1a\x4b\x12\x74\x7b\xe9\xa5\xc9\x19\x78\x92\xc8\x3e\x28\x45\xcc\x80\x95\x62\x8e\xd3\x37\x1e\xa2\x3c\x1e\x33\xe0\x79\xc6\xef\x50\x28\x34\x2a\x86\x09\x38\x35\x66\xb3\x92\x22\x50\xa2\xc3\x5a\xea\x13\xac\x51\x81\x95\x4a\x35\x96\xc8\x0a\x80\x58\x8a\x95\x42\xfa\x17\x19\xfa\xc4\x2f\x21\x6d\x30\xc9\xf1\xb3\x20\x10\x5b\x68\x44\xb0\x97\xe2\xcd\x13\x40\x64\x1c\xb9\x6c\x22\x88\x4c\xda\x12\xd9\xe2\x4a\x8d\x9f\x79\x36\x93\xf7\x1f\x3a\x1a\x70\x34\xae\xd2\xf3\xb7\xc2\xe9\xa4\xb1\xf1\x47\xfc\xeb\xec\x76\x69\xfc\xac\xf7\x51\xa1\xe4\xf6\x47\xd6\xf6\xc3\x03\x68\x28\xa7\xbb\x97\x00\xd4\x67\xf4\x2a\x5e\x01\x07\x88\xf1\x5a\xa8\xe9\x56\x7a\x03\xfd\x95\xc8\xdf\xe6\x20\xd6\xc6\x6b\x18\x25\x20\x4d\x36\x1b\x45\x21\xc1\x0d\x76\x33\xa7\xb3\x28\xb4\xbc\x5e\xa5\xe4\xd4\x4e\xb5\x4b\x6b\xa5\xf1\xdb\x72\x98\x50\xc8\xa1\x33\x99\x30\x43\x81\x09\x6c\x30\x81\x0e\x26\x00\x59\x13\xd0\xd2\x36\x93\xcd\x44\xa8\x98\x38\x8d\x63\x16\xe4\xb0\x49\x6c\x9d\xdf\x14\x1d\x8f\xe3\x2d\x09\xe7\x23\xc9\x3f\x60\xc8\x1a\xab\xe1\x33\xcd\x8f\x9f\x09\x22\xdd\xfd\x72\x3e\x21\xd9\x6e\x80\x17\xc8\x18\x04\x89\xbe\x87\xfb\x6e\x05\x06\x18\xef\x7c\xb8\xf3\xf4\x82\x2f\x7e\x05\x03\x0a\x84\xae\x02\xf9\x71\x61\x63\xdf\x86\x5f\x85\xba\x07\x5e\xde\x3c\x7d\x3a\xbd\xb2\xbe\xfe\x82\x70\xd7\x05\x61\xf3\x05\xd8\x1e\x8c\x69\xb8\x03\xf8\xd1\x51\x6d\xea\x2b\x0c\xa6\x09\xd1\xaf\x86\x88\x5c\xa2\x98\x38\x14\x1f\x9b\xeb\x0c\xe5\xe5\x71\x9c\x5e\x53\x00\x0a\x3d\x44\xd4\x1b\xb1\xd8\x15\x4e\x56\x67\xb5\xd9\x5a\x69\x75\xba\x12\x2b\xf0\x46\xfc\x21\x93\xbf\x36\x01\x0a\x60\x91\x9d\xb0\x58\x4c\x04\x51\x14\x2a\xaa\x4d\x44\x35\xfa\x10\xa6\x21\xe8\x1b\x1a\x16\x22\x43\x21\x95\x89\xd3\xb9\x06\xd1\xe3\x68\x92\xa0\x39\xda\x47\x43\x15\x45\xab\x54\xb0\x26\xa1\x92\xc1\x05\x31\x37\xbe\x88\x0f\x5b\x3c\x22\xbf\x42\x1e\x14\xe0\xc5\x56\x23\x43\x92\xb4\xb3\x42\xc6\x03\x68\x36\x23\x01\x60\x9a\x84\xa0\x99\x43\xc6\x14\x04\xe5\xa2\xc5\x08\xb7\x8e\xa0\xe8\xcc\x64\x2d\x0f\x2a\xc8\xda\xc7\x8a\xfa\xed\xe8\xf2\x47\xaf\x2f\x1f\xbf\x79\x8c\xf0\xe6\x01\x30\x71\xf6\x36\xa0\x3e\x36\x7d\x20\xb0\x1d\x10\x9e\x5a\x6e\x13\xf4\xf7\x05\x8b\x46\xad\xb5\x83\x47\xd4\x23\xc7\x0b\xb9\xa0\xa6\x2f\x03\x3e\x13\xfe\xc8\x7d\xa0\xcf\xbe\x65\x85\x42\x07\x92\x9b\xfd\xfa\x5b\xa0\xed\x61\x0f\xd8\x2b\x04\xa6\x9c\x1b\x3b\xe7\xa9\x3f\xb8\x0d\x4b\xda\x16\x07\x36\x08\x57\xac\xca\x05\x39\xc8\xae\xd8\x9b\xae\x50\xc7\xd1\x19\xb0\x11\x7d\xe2\x61\xd6\x06\x21\x6d\xb7\x92\xa4\x8a\x41\x66\x59\x65\xb3\x29\x70\xe3\x34\xa1\xa3\x74\x3c\xee\x2d\xa3\x60\x7d\x82\x6a\x7e\xae\x0d\xc9\xce\xb2\x58\x12\x3b\x55\x2c\xb2\x27\xfb\xc9\x30\x76\x03\x0c\x8b\xd3\x62\x95\x20\x48\x6a\x88\xa6\x76\xc2\xa5\x02\xb2\x72\xd2\x8a\xc8\xca\x56\x85\x57\x3f\x12\x96\x75\x07\x9a\xa2\x03\x65\x7d\x8b\x8d\x85\x02\x9c\x0e\x0a\x2e\xa1\xed\xde\x70\xe9\x3d\xb0\xb5\xdd\x37\x25\x75\x23\x7f\x48\x72\x81\x0d\x47\xef\xda\x84\xa4\xac\x8e\xe7\xd3\x24\x0a\x56\x19\x0a\xd2\x3a\x33\x4a\x39\x4c\x3a\x9d\xdd\x62\x1e\x98\xb0\x00\xc6\x44\x98\xaa\x31\x2a\x91\x86\xd4\xb0\xd8\x3d\x92\x29\x3c\x0c\x5b\x71\xec\x3a\x17\x22\xda\xa0\x0c\x9c\x22\x09\x2b\x45\xcc\x2d\x83\x38\xf7\x08\x2e\x1f\x08\xec\x03\x57\x46\x56\xcd\x74\x3f\xb4\x49\x4e\x34\xc7\x2d\x03\xde\x28\xb0\x47\xc9\x5b\xc1\xfd\xc2\x90\xb3\x8d\xa7\xb6\xdd\x21\xe6\x9c\x24\x84\x6d\xde\x7e\x5b\x8c\x87\x85\x3a\x45\x11\xf2\x23\x1e\x22\x8f\xe8\x17\xcf\x55\xf8\x03\xd0\x60\xb0\xc0\xa8\x46\x03\x9d\x46\xaa\x20\x5f\x61\x50\xb2\x3c\x64\x51\x88\xcb\x52\x4a\x64\x37\x95\x46\xc2\x3e\x2a\x95\xe7\x66\x82\xd2\xa6\x2f\x02\xa4\x35\x95\xf0\xe0\x15\xc1\x34\x8a\x57\x2c\xc9\x6a\x81\x56\x39\x8d\x89\x61\xb2\x50\xdf\xae\x99\x67\x30\xee\x3d\x21\x5c\x11\x9e\xc6\x68\x24\x57\xee\x79\x3e\x2e\x5c\x66\xf2\x8b\x5d\xbd\x0b\xc3\xb3\x1a\x3f\x7d\x7b\xed\xa6\xf9\xcf\x60\x34\x12\xa1\x6e\xca\xdc\xf8\xe0\x71\xdd\x40\x67\xc0\x61\x3c\x92\x1b\x07\xff\x53\x1f\x76\x14\x17\xe9\x2e\x2a\xb5\xe4\xd2\x04\xd4\xcc\x95\x00\x49\x90\x5e\xed\x45\x5c\x70\x7c\x2f\xd5\x0a\xe9\x95\x67\xcd\x23\x20\x34\x41\x4a\x65\x2a\xf1\x78\x4c\x3a\x8a\x8a\x95\x06\x0a\x50\xd6\x4c\x38\x03\x9c\x33\xa7\x2a\xe1\xb4\x18\x34\xd5\x09\x83\x13\xb2\x59\xe0\x1e\xd9\x93\x1e\x92\x5e\xb8\xbd\x4e\x21\x4f\xac\x63\x4d\x82\x32\xf0\xfd\x7f\xcc\xf3\xe0\x2a\xe4\x1a\x80\x9e\x2d\xda\xa3\x4c\x88\x1a\x45\xe6\x2f\x33\xe6\xb4\x98\xd7\xc1\x75\x45\x73\x0c\xf9\xbf\x37\x7c\x18\xf5\x4c\xc2\x4a\xad\x5d\xd5\x6f\xd0\xc1\x96\xb3\x39\xb4\xcf\xbe\x42\x3e\xef\x55\xd1\xe7\x39\x89\x9a\x78\x54\xab\xd1\xa9\xd5\x8c\x93\x65\x01\xa7\xe1\x78\x0b\xc3\xb8\x79\x97\x5e\xcd\x13\xe8\x2c\x38\xd1\xab\xd6\x22\x47\xe7\x48\x3b\xba\x58\x32\x66\x4d\xdd\xc3\xa5\xb8\x58\x32\x9c\x9c\x84\xdf\x80\xdb\x9a\xf0\x18\x79\x38\x09\xe3\xa0\x7d\x6a\x19\x79\x8b\x04\xde\xc0\x0b\x4f\x5e\x14\x0e\x4f\x14\x3e\x9e\xf4\x14\xdc\x2d\xc2\x38\xdc\x56\x43\x36\x90\x6b\x64\x04\x87\x53\xa4\xa5\xf1\x7b\xd2\xfa\x3f\x29\x18\x07\x14\x53\x61\xec\xef\x45\xe8\xdd\xd8\x89\x81\xf1\x7c\x9d\x9a\x53\x71\xb4\x11\x05\xba\x4a\x83\x52\xa3\x32\xa8\xec\x0e\xbb\xd3\x4a\x56\x27\xac\x1c\xa3\xd1\xa2\x97\x42\x19\x39\xad\x16\xe5\xa5\x2a\xb3\x04\xdc\x25\x8f\x3a\x65\x0f\x9b\xa3\x57\x13\x4b\x02\x0a\xa1\x6d\x95\xa6\x4a\xe0\x31\x38\xa2\x94\x97\x5b\x61\xbf\xee\x85\x5f\xf7\xdb\x1d\xb9\xb3\xa7\x70\xa9\xe7\x9c\xc8\x9c\x8e\x6e\x08\xb4\x66\x15\xd5\x7b\xcb\xf0\xe2\xb6\x70\x30\x2b\xbc\x77\x56\xd8\x01\xa6\x9d\x05\x1d\x1e\x70\x1f\xe8\xb0\x76\x8a\x1e\xed\xa3\x1a\xb4\xc6\x7f\x88\x33\x9c\x26\xa2\x5d\xdc\x67\x20\x8c\x26\x46\xa1\xd1\xaa\x54\x66\x00\x2c\x26\x88\xa2\xef\xd1\x09\x8c\x74\xac\x56\x70\x5a\x88\xf3\x5e\x71\x61\x2b\x62\xe9\xa5\x95\x76\x0d\x12\x08\x63\x95\x40\x24\x52\xc4\x6f\xc5\x63\x9b\x46\x3f\xbd\x64\x61\xe4\x6f\x61\xc6\x4d\xc2\x27\x37\x7d\xfc\x7b\xce\x9c\x4a\x10\xea\x40\x96\xce\x00\x5d\x1b\xbe\x7d\x43\x38\x4d\xfd\x7e\x56\xb0\x37\x3e\x4b\x76\x01\x97\xce\x6e\xde\xbc\xb9\xf1\x5e\x4c\x48\x4b\x4a\x75\x51\x71\x7e\xc9\x43\x0c\x8a\x17\x7b\x28\x83\xd5\x62\xb4\x98\x79\x83\xcd\xed\xb2\x43\x02\x68\xd5\x0e\xa7\xd3\xa7\xf6\xba\xa1\xd1\x64\xac\x46\x1b\xdc\x63\x32\x29\x1d\x16\x09\xf4\x2b\xdd\x70\x9a\x25\x61\xda\xe6\xc7\x64\x49\x71\x3f\x69\x6a\x66\x16\x89\x8c\xa3\x03\x23\x4a\xcb\x8d\x94\x7d\x75\xe4\x1d\x61\xe7\x94\x75\x3b\x46\xa4\x46\x66\x67\xbc\x94\x33\xb7\x23\x08\xe6\x83\xce\xfb\x40\x41\xe3\x5b\x4f\xfa\xa1\xfa\x6c\xe3\xfa\xfb\xd6\x77\x96\x06\x65\xc9\xc8\x59\x50\x22\x9c\x43\xbf\x68\xe1\x69\x31\x8e\xe9\x8c\x6c\xf8\x74\xf4\xfe\xf3\x89\x36\xc4\x88\x78\x69\x89\xd6\x6a\xe3\x0a\x78\x08\x83\xbc\x27\xea\x09\xda\xb4\x74\xdb\x72\xae\xa0\x36\x61\x75\xd2\x04\xc7\x39\x09\x27\xca\x1a\x9c\x16\x55\xac\x2a\xa1\xe2\x88\x9c\xda\x2c\x34\xec\x2c\x58\xc9\xd4\x51\x4d\xd5\x64\x8c\xd2\x74\x9b\x5c\x95\xa1\xe8\x14\x84\xae\x7c\x58\x93\x34\x5c\x4c\x79\x27\x60\x4c\xa1\x4d\x30\x0d\xe3\xa6\xd2\x8a\x41\x07\xe7\x6d\xba\x4f\x68\x10\x2e\x3d\x67\x5e\x3e\x72\xb8\x01\x30\x81\x9f\xcf\xbc\xfd\x82\xad\xa7\x32\x1a\xf1\xf8\xf4\x79\x37\x7c\x73\xcf\xbc\xb5\x55\x5d\x07\xae\x77\x52\xdd\x06\x75\x0f\x3b\x57\x8d\xbe\xef\xe6\xa7\x9f\xa4\xa8\x91\xe1\x15\xbd\xbb\x7b\xb7\xed\xba\x75\x67\x78\x01\x18\x5d\xe8\xf4\x04\x99\x3d\x9c\xa2\xb1\x69\xc4\xe0\x1e\x55\x2b\x6f\x24\x64\x5c\x58\xea\x59\x71\xff\x47\x88\x5e\xf1\xb0\xdd\xab\x87\x1c\x8a\xd9\xcd\x9c\x21\x47\x61\x50\xe4\x46\xf1\xbd\xab\xc5\xcc\xb1\xea\x80\x78\xf7\xea\xc8\x86\x83\x4d\x1a\xdb\x2c\x8a\xd6\xeb\x6e\x5c\xdb\x60\x2c\x83\xff\x15\x06\x56\x1f\x02\xaa\xd2\x39\xff\x05\x03\xb6\xd3\x9c\xdf\x1a\xf7\x5f\x0f\x01\x4b\x12\x39\x48\x87\x23\x48\x07\xcc\x23\x85\x74\x08\x29\xac\x6e\x1d\x64\xcd\x66\x93\x89\xe5\x14\x5c\x24\x47\x47\x40\x35\xfa\x57\xb3\xda\x27\xa2\xe3\xd8\x32\xd0\x71\x9a\xe9\x90\x71\x6b\x9c\x01\x8d\xe3\x8b\x04\x91\xf4\xe5\x62\xe1\x9a\xc9\xc2\xc4\x01\x7f\x26\x35\x68\x22\xda\x21\x0d\x84\x3f\xb1\x06\xc0\xce\xfe\x54\x33\xa7\xb6\x44\xba\x0f\xbe\x43\xd4\x40\xb8\xf5\xb9\x33\x48\x01\x72\xd4\x4d\xf3\x3b\x8d\x49\xca\x0f\xd4\xa2\xfc\x49\x9c\xf0\x10\x11\x23\xaa\xe2\xf9\xad\xa0\x3f\x4f\x0b\x0d\x3e\x9f\xd9\x6c\xe0\x79\x07\x84\x65\xad\x6d\x6e\x74\x7c\x80\xd6\xaf\x24\x78\xb3\xb2\xb0\x2a\xa1\xb4\x10\xe1\x96\xa0\xd8\x53\x08\xb6\x99\x40\xec\xe9\x7a\xa9\x8c\xad\x9f\x09\xd4\xfc\xff\x00\xc8\xae\xcc\x7d\xda\x7d\xf2\x90\x88\x87\xd1\xae\x27\x57\x72\x3d\x2a\xbb\x5c\x15\x4d\x42\xec\x3f\x7b\xe7\x4e\xd3\x1b\x6c\xd7\x3e\x9f\x5f\x8f\xcd\x0e\x08\x27\xe6\x18\x12\xf7\x5b\x79\xdc\x65\x53\x41\xca\xc0\x71\x94\x0a\x3a\x1d\x06\xa8\x53\xe8\x8c\x55\x09\x14\x67\xe3\x7a\x0d\xf7\x9f\x31\xc0\x71\x98\x27\x65\x65\x64\x46\xf3\x39\x3a\x2f\xe4\x90\x81\x53\x7d\xc2\x2f\x53\xc0\x8e\xcf\x7e\xbc\x4b\xf8\xfb\xf4\x33\xdf\xe8\x81\x4b\xc2\xa1\x86\x9b\x27\x4f\x2c\x05\xf5\x5f\xbf\xfa\x92\x70\x64\xff\x73\x47\xac\x12\xf0\x34\xb2\x61\x8f\x35\xbd\x48\xdd\x80\xe4\xc1\x31\x47\x6d\x3c\x4f\xa3\x26\x5d\x61\xe8\xa5\xbc\x56\x03\x45\x59\xd5\xb0\x80\x20\xf2\x03\x1a\x93\xd2\x60\x32\x98\x1c\x4a\x47\xb4\x26\xe1\xb0\x28\xf5\x55\x78\x2c\xae\x59\x28\x87\x31\x83\xb3\x51\x1c\xb0\xb0\x52\xdd\x1f\xa3\x9f\x19\xa5\x81\x80\x64\xd7\x04\x2e\x9f\x29\x92\x2d\xb0\x62\x55\xa1\xef\xe8\xae\xa6\x1d\x40\x77\x0c\xec\x2e\x14\x2e\xd0\x43\xab\xe7\xee\x32\x0f\x7f\x6c\xe2\xe6\x43\xc2\x57\xdf\xbf\xbc\x78\x54\x21\xf9\x61\xd7\x7e\x9d\x77\x96\x3a\xa6\xb5\x1f\x37\x33\x31\xad\xb2\xbe\xee\x29\x50\x74\x44\xd8\x6d\xad\x1f\xf5\xd3\xb9\x2e\x9d\xd6\x4d\x3f\xf8\xfa\x94\x31\x31\x30\x31\xa7\xac\x5b\x59\x51\x59\x77\xe9\x6c\x0b\x75\x22\xe6\x33\xe6\x73\xe8\x1f\xcf\x0b\x44\xf5\x28\x9e\x32\x7b\x8b\x15\x0a\xaf\x1d\xf2\xad\xf8\x52\x97\xb5\x3a\xe1\x72\xca\xcd\x15\xf9\xe2\x01\x0f\x5e\xdf\x5c\x51\x99\x81\x88\x1a\x2b\x6d\x19\xe9\x19\x19\x64\x39\x08\x49\x42\x89\x66\x9f\xf4\xdf\x7b\x3e\xd8\xac\x14\x2f\x7c\xc1\x8c\x77\xf5\xc8\x1f\xd9\x71\xcb\x26\x4d\xee\x1f\xff\xa9\xee\xfe\x8f\x22\xe8\x1a\xa1\xfb\xc8\xb4\x74\x8d\xb7\xf6\x83\x6c\xe4\x67\x09\xd3\xfa\x1b\x91\x97\xba\x98\x48\xc4\x4b\xfc\x11\x3d\x64\x3d\xac\xc3\xe3\x2e\x52\x28\xdc\x0e\x68\x2a\x31\xb5\xc2\x9a\x79\x50\xda\xe2\x31\xf3\x48\x57\x1e\xa8\xf3\x44\x2d\x03\xff\x15\xd5\x3a\x3b\xc8\x6a\xa6\x6b\x16\x0c\xe5\xff\x6a\xd4\x5a\xbb\x9f\x38\x28\x9e\x9c\xd6\xfd\xb9\x07\xff\x8b\x6d\x03\x66\x11\x20\xab\x43\x4d\xc3\xc2\x96\x40\xae\x25\x1b\x81\xcf\x8d\x19\x65\x6d\x7d\xe3\x51\xb5\xd3\xc9\xdb\x34\x14\x84\x1a\x1e\x7a\x3d\x1a\x5b\x2d\x1e\xd8\x04\x2c\xd4\x68\x08\x3d\x9e\x96\xd7\x73\x04\x53\xd3\x0c\x69\x0d\x67\x9c\xd7\x8d\x0b\xd3\xa9\x19\xe1\x72\x3f\x4f\xc4\x4a\x25\x18\x02\x18\x80\x7e\xec\x80\xc0\xd9\x07\xfe\xc7\x01\x74\xe6\x44\xed\x8d\x8b\xdd\x8d\x55\x76\xe0\xf9\x6d\xd5\x3b\xb3\xef\x16\x7e\x0c\xbc\x95\x0b\x1e\x60\xc6\x99\xee\x5a\x6f\xed\xd0\x7d\xdf\x3d\xa0\x00\xb4\x9f\xf0\xcc\xb2\xb7\x84\x93\x47\xe1\xbf\x84\x7f\x72\x73\x06\x8f\x91\xf0\xf7\xf0\x1d\x3b\xb2\xcb\x5e\x8c\xd2\xec\x25\x49\x3d\xa3\xb4\x9b\xcd\x4a\x3d\xf4\xfb\xac\x48\x66\x46\xc3\x5a\x91\xd0\x56\x2b\xaf\xe1\x5d\xb5\x09\xde\xa2\xa1\x6b\x12\x1a\xae\xb9\xd0\xd7\xe3\x4c\x83\x64\x75\x26\x69\xa4\x29\xc9\x85\x5a\x19\x79\x4c\xde\x98\xe2\x9e\x7b\xff\xea\x36\xe1\xcf\xe3\xef\x7c\x6b\xbb\x22\xb1\xcc\x91\x23\x23\xa5\x12\xcb\xdc\xa5\xb7\xdf\x16\x5e\x3b\x8c\xf9\xe5\x9e\x92\x68\xe5\xf0\x3a\xb7\x6d\xba\x42\x5f\x11\x39\xf8\x22\xc4\x84\x78\x79\xc8\x66\x63\x49\x8f\x37\x6c\x36\x7b\x49\x48\xa9\xa3\xea\x5c\x46\x5b\x95\x08\x85\xd9\xb0\x95\x85\xa4\xcd\x0a\x3d\x8c\x07\xa2\xdf\x20\x0a\x6d\x03\x58\x03\xc2\x55\x93\xb6\xcb\x12\x31\x40\xb1\x44\xc4\x2a\x05\x03\xf9\xcd\x0b\xa1\x18\x8c\xde\x58\x9e\x44\x53\xc0\xf6\x8c\x94\x00\x06\xcb\xc3\xad\xb1\xc5\xc0\x83\xf1\xc6\x52\x23\xcd\x98\xc8\xd5\x60\x5e\xe9\x2b\x85\x95\xad\xcb\x03\x13\x66\xcf\x99\xa5\x6b\x2b\x7c\xf4\xcb\xf3\x1f\x1a\xc9\x17\x83\xfd\xe2\xbb\x2a\x85\x6b\xfd\x88\x26\xd3\x5f\x6e\xa1\x2b\x45\x0d\x10\xee\xcb\xd9\xd0\xaf\xbd\xfd\xf1\xd0\xf4\x05\xc2\xb7\xc2\xc7\x17\xde\x1a\x3a\x6c\xfc\xa0\x1b\x4a\x56\x5a\xef\xd8\xdc\x50\x05\xea\x3a\x77\x7f\x07\xdf\x83\x3b\x9a\xae\xc0\x4b\x54\x7f\x5e\x01\x27\x8a\x7d\x02\x1a\xf4\xdf\x3f\xe0\xf9\x35\x78\x59\x8c\x8d\x7f\x42\x6b\x31\x13\xad\x45\x2b\x62\x56\xbc\x32\xca\x39\x55\xc5\x66\x8b\x45\x5b\x50\xec\x74\x29\x82\x30\x18\x43\xbb\xaf\x34\x5f\xab\xd3\x69\x6b\x13\x3e\xe4\x8d\x28\x42\xe7\x34\x47\xa1\xcf\xa5\xf3\xb9\x5c\x3e\x1d\x24\x6c\x36\x63\x6d\xc2\xc6\x89\x44\x35\x96\xe6\x2b\x22\x73\xb9\xe7\xa7\x6f\x91\x33\x67\xed\xe5\x8d\x59\x9e\x44\xdd\x2a\xcf\x2a\xc7\x59\xb3\x96\x4b\x0f\x18\xb3\x54\x7a\xbd\xf7\xc9\x2f\xdc\x0d\xc1\x43\xc3\x86\xaf\x5f\xea\x3a\xb6\x6d\x70\x4f\xa9\x54\xb7\xf9\x74\xe4\x79\x79\xd1\xa6\xce\x32\xe4\xdc\x56\x35\x7d\x91\x20\x98\xf6\xef\x2c\x38\x58\xd3\xab\xa6\xdb\xbf\xaa\x6a\x2a\xda\xe1\x0a\x5e\xa2\x9f\x77\x95\xb8\x64\x23\x27\x55\xd6\x2a\x28\x7e\x79\xfd\x9e\x47\xe4\xf8\x70\x90\x88\x2d\x1f\x25\x7a\xc4\xc3\x06\x9b\xda\x4d\x85\xc3\x3a\x87\xdb\x86\xc7\xdf\x75\x7a\xbd\x0e\x1d\x36\xbd\xdf\xe4\x47\xc7\xcd\x6f\x31\x11\x35\x09\x13\xd7\x0c\x9e\x3b\x9b\x0c\x06\x3b\xb0\x74\x33\x52\x52\xb5\x88\x78\xf0\x68\xa9\xcd\x50\x42\xad\xe0\x43\xe4\xc9\xd1\x77\x8e\x9c\x39\x6e\xc4\xb8\xb1\x93\x82\x6b\x67\xf4\xf3\xde\xf8\xf0\x58\xe1\xe2\xd8\x79\xcb\xaf\xdc\xb1\xf1\xfc\xcc\x03\xa0\x10\xee\x59\xf2\xe3\xe2\x9b\x6f\x4d\xd4\x74\xef\xfc\xf8\xc0\x1b\x5a\x55\x3c\xda\x7d\x41\xcf\xaf\xca\xd4\xb3\x6f\x98\xf6\xe0\x88\x9b\xce\xae\x7a\x01\x54\x1c\x15\xdf\xe3\x28\xa1\x8e\xbc\x09\xc5\xe9\x16\x94\x35\xb8\xa1\x42\x41\x98\x48\x93\xcd\xac\xd3\x59\xa1\xc5\x6c\x41\xbe\xd6\x6c\x56\x73\x35\x09\xb5\x13\x24\x13\xce\x4c\xf4\xdb\x24\x7a\x4e\xb9\x31\x55\x94\x08\xc8\x75\x70\x8c\xa9\x72\xe4\x38\xb0\x1d\xbf\x2b\x7c\x97\xd3\xf7\xcc\x91\x14\x5c\xb7\xf9\xfd\xf0\xb3\x70\x49\xc3\xea\x67\xd7\xef\x5b\x2d\xa1\x75\x4f\x7d\x16\xf9\xda\xbf\x91\x3f\x3a\x8b\xec\x75\x2e\x51\x4e\x4c\x8b\x97\xda\xf3\x9c\x6a\x75\x24\xe2\xcc\x29\xe5\x73\x78\x1f\xf4\x55\xa0\x0d\xd5\xd6\x13\xac\x4e\x78\x80\x5a\xa3\xb1\xb3\x16\x0b\x8a\x74\x2c\x1c\xdb\xba\x3a\xc1\x8a\x74\x47\xd4\xc9\xa6\xaf\x1e\x53\x69\x7b\x51\x38\xe5\x2f\xcd\x6f\x66\xb9\x33\x2b\x14\x7c\x46\x40\x5a\x21\x15\x00\x22\x52\x21\x25\x39\x9f\xd6\xb2\x39\xa7\x8c\x62\xb7\x1b\x29\x0d\xaa\x81\x87\x5e\xf9\xc0\x0e\x9c\xce\x03\xc3\x66\x76\x75\xc8\xd3\x69\x4b\xbe\x39\x8a\xa7\xd3\x06\xf8\x4e\x6c\x49\xf2\x58\x7c\x5c\x28\xfc\xb2\x7f\xd2\xc8\x7e\x63\xbb\x17\x1e\x4b\xdc\x5a\x25\xd4\x6d\xdc\xee\x59\x5e\xfd\xf0\x49\x71\x44\xed\x15\x30\xe3\xd1\x19\xa3\x41\x97\x55\x12\xaf\xc5\xb5\x3b\x2e\xbd\x41\xd5\x4d\x9a\x1f\xdf\xfa\x5d\xef\x57\xd6\x5e\x92\x66\xa8\xfe\x96\xe6\xf8\x78\x05\x9e\x1d\x92\xb8\x3b\xa8\xb5\x68\xcf\x39\xf1\x6c\x10\xab\x27\xa0\x45\xa9\x04\x50\x4f\xb9\x5d\xb8\x15\x81\xd5\x92\xa4\x42\xab\xe5\xab\x12\x5a\x4e\x61\xaf\x4a\x41\xc3\xb5\x08\xca\x8f\x59\x87\x30\x80\x94\xdf\x67\xc8\x88\x42\xe4\xfd\x57\x0e\xcb\x5e\x8f\x82\x0f\x87\xbf\x29\xfc\x2c\xb0\xf7\x82\xfc\xe7\xc0\xcd\xe5\xc2\xb7\xe4\xd4\x21\x23\xb6\xd4\x2e\xbc\x71\xe2\x14\x30\xfe\x1d\x21\xe7\x26\xf0\xe9\xe3\x20\xef\x3e\xe1\xe1\x48\xcd\x0d\x53\x3f\xb9\x65\xd1\xf2\xa8\x68\x27\x27\x20\x99\xdf\x11\xf1\x7a\xdc\x78\x26\xc8\x0c\xf5\x3a\xa7\x4a\xa5\xd3\x5a\x59\x02\x32\x1e\xce\x60\xf0\x5a\x59\x05\xa7\x63\x15\x7c\x4d\x42\x91\xce\xf5\x2a\x9a\xe3\xed\x67\xc1\x8f\x43\x11\x90\x5c\x6c\xd2\x13\x43\x52\xf2\x91\x8a\xd0\xd9\xe3\x5b\xee\x19\xbd\xfa\x33\x90\xbb\x09\xac\x03\x39\x0d\x1f\xb4\x6e\x53\xd0\xb5\xd8\x55\x04\xd8\xc3\x87\x4a\x36\x3f\xbc\x76\x61\xcd\xb3\x77\xc2\xf6\x8d\x77\x90\x13\xff\xf9\xa8\x67\x75\x62\x59\x5d\xf5\x80\x60\x5e\x81\x74\x87\x55\x8b\xec\x17\x44\xeb\xa8\x25\x70\x07\x56\x0e\x2c\x52\x73\x76\xce\x48\x7b\xf2\x8b\x98\x50\x69\x28\x16\xb1\x38\x2d\xd5\x89\xb0\xcd\x63\xa3\xa1\x2e\xe0\xe4\x74\x04\x8e\x3e\x93\xa2\x62\x11\xaf\xe3\x3d\x0c\x4b\xb2\x61\x58\x46\xab\x54\x6a\x89\x88\x56\xa9\x0d\xe6\x88\x2d\xcf\x8c\xab\xa5\x93\x4c\x7a\x0b\x5b\x15\x19\x0b\xc2\xf6\x42\xc5\x9a\xbd\xbb\xaa\x63\xce\x1b\x6a\xc6\xf8\xb7\x6f\x7d\xbe\x22\x32\xba\xfd\xea\x11\x3b\x46\x4f\xeb\x52\x1b\xec\x10\x9a\xdb\xd6\x33\x78\xef\x83\xdd\xda\xf4\x1e\x63\x6d\xdd\xb6\xad\x33\x1a\x79\x7e\xf9\xf4\x65\x0f\x0e\x3b\x3a\xa4\xe7\x99\xe9\x8f\xcc\x5b\x3f\xb0\xff\xe4\x33\x5d\x82\x65\x47\x6f\x5b\xd7\x7e\xe8\xcd\x95\x68\x7f\x0c\x11\x86\x50\x2f\xa2\xb5\xb7\xa3\xf3\xec\xb2\x90\x04\x61\xb5\xda\x0c\x2a\x9b\xca\xe9\x20\x21\x54\x58\xd1\xa2\xa3\x6c\x1b\x6d\x8b\x24\x38\xac\x8c\x70\x0c\xb2\x48\xec\x81\x31\x13\x12\xcd\x9f\x86\x4e\x03\xe4\xba\x41\x91\x14\x06\x1a\xb0\xa6\xb0\xd2\x84\xcf\x85\x21\xe0\xe8\xe3\x29\xe0\xb3\x14\x38\xda\x3f\x1e\xe9\x9e\x45\x9a\xab\xc2\xf1\x58\xe7\x78\x80\x65\x4c\x84\xd9\xef\xb7\x5a\x91\xcf\x70\x31\x30\x18\x70\x78\x31\x46\x16\x41\x69\x2d\x66\xca\x50\x9d\xa0\xb8\xd4\xa6\xc8\xce\x5b\xe4\xfe\xc2\x0c\x6c\x63\x7f\x46\xf3\x50\x6a\x8d\x19\xf0\xad\xd4\x0c\xc4\x28\xd7\x08\xdf\xcd\x4b\xf6\x09\xfd\xe1\x38\x7b\x54\x3c\x98\x5b\x5c\x70\x25\x6e\xfe\x31\x56\xb6\x69\xac\x23\x07\xca\x5d\x41\xd4\x73\x37\x6f\x44\x07\x71\x33\x91\xc2\x66\x46\xf2\x16\xe0\x6a\x23\xe1\xa4\x4d\x0a\xa3\x51\xa9\x54\x30\x4c\x58\xe7\xa4\x8a\x0a\x03\xd1\xea\x44\xc0\x69\x62\x6c\x36\x12\x65\x5f\x9c\x88\x64\x8b\x7c\x0d\x51\x99\x85\x5e\xdb\x82\xe8\xd7\xc9\x2a\xe5\x59\x69\xc2\xe9\xa0\xec\xdb\x50\x4a\x09\x67\x35\x17\xbc\x57\x2d\x17\x4b\xb6\x39\x6d\x09\x3c\x7d\xb8\x78\xa6\x3b\xb7\xa4\x7c\x99\x63\x9d\x83\xfc\x2b\x53\x87\xee\xbd\xae\xca\xcd\x4d\x8d\x39\xff\x3a\xaa\x51\x9c\xd7\x2e\x25\xef\x5b\x82\xeb\x32\xbf\x8a\x98\xf5\x18\xe3\x9c\x25\x3a\xc4\x51\x70\xa2\x05\x2a\x95\x9e\xd3\x1b\x30\xf6\x7c\x8d\x84\x3d\xcf\xaa\xcc\x3a\xed\xc0\x84\x0e\xa4\x08\xdb\xb2\x51\xe8\x63\xa5\xcd\x70\xe8\x71\x59\xd7\x72\xcb\x20\x60\x1f\x74\x77\xf8\xee\xa1\xc2\xe5\xa1\xb7\x80\x68\x2e\xb0\xe7\x92\x9b\xc1\x31\x61\xe0\x33\x42\x09\x38\x07\x0b\x71\x1d\x17\x10\x5d\x9b\xae\x90\x0c\xda\x9f\x2c\xe1\x8d\xb3\x50\xa7\x63\x38\xc6\xa0\xa6\xab\x51\xee\x2d\x01\xac\xa4\x3b\x92\x70\x27\x76\x46\xd6\x50\x7e\x19\xd8\x77\xd3\xa3\x3c\xa1\x82\x11\x1d\x57\x2f\x62\xa9\x76\x8d\x96\xfc\x1a\xc5\xd7\xba\x9b\xe6\x56\xf4\x47\x7e\xec\x22\x41\xc0\xe9\xe8\x7b\x35\x44\x45\xdc\xa5\xd0\x68\x54\x0c\x84\x3a\xa4\x9a\x56\xa1\x56\xa9\xab\x13\x2a\x33\xdd\xac\x73\xb5\x59\xe3\x6a\xd2\x1c\x22\x85\x62\x28\x9f\x8f\x81\x11\x6f\xe5\x92\x8f\xe7\xbe\xbd\xf2\xed\xdc\xc6\xbe\xd1\xb7\xe0\x8d\xe7\xce\x35\x4e\x38\x77\x4e\xf4\x99\xef\xa2\x35\x7c\x44\xc4\x48\xe9\x11\xf7\xf3\x1a\xa3\xda\xa8\x06\x4a\x95\x8a\x20\x68\x3d\xcb\x9a\x29\x9a\x36\x69\x68\x9e\xd7\x03\xa5\x52\x95\xc2\x8c\xc7\xa8\xa2\xd9\xcf\xc3\xa8\x47\xb2\x0b\x8a\x19\x51\xa0\x12\x44\x0e\x48\x02\x27\x8c\xe1\x1b\xc5\xf0\x96\x82\x7c\xf5\x0a\xdb\xe2\x19\xb3\x80\x7d\x43\x24\x5f\xb3\xdc\x3e\x7b\xe6\x7c\xf2\x53\xb2\xa8\xcd\xb6\x85\x0c\xd9\xb3\xb1\x92\x2c\xa8\xd8\x35\x8f\x6e\xbc\x5b\xea\x87\xf8\x13\xfd\x76\x5a\xbc\x93\xb7\xe1\x6a\x25\x65\xe0\xb5\x94\x0e\xea\x58\x40\x92\x90\x83\x7a\xa5\xde\xa1\xb4\xf3\x46\x0d\x8a\xba\x00\x65\xa0\x6a\x13\xac\xc1\xa0\xd1\xa0\x15\x82\x72\xb5\x32\xd6\x1c\xc1\x4d\xc6\xc7\xab\x90\xf9\x20\x80\xf8\xa2\x45\x8b\xd0\x1e\xf7\x5b\xc5\xfc\xe5\xf8\x6a\xdb\x12\x23\x37\xdf\x52\x2f\x5c\xaa\xe7\x6f\x9c\x77\xff\xa6\xe0\x08\x60\xdf\x7f\x8b\x30\xdc\xc7\xcf\x2f\xca\x05\x97\x04\x3b\xb8\xbc\x68\xe2\x9a\xfd\xe0\x8b\x86\x37\x0e\x8e\xf0\x46\x45\xfc\x25\x14\x6f\x24\x44\x39\x83\x71\x4e\x05\x75\x90\x31\x30\xbc\x02\x10\x9a\xe6\x4d\x69\xd2\x1b\x09\x48\xad\x8d\x80\x91\x8b\xd8\x80\x5b\xb5\x41\x0b\x8a\x81\x5d\x78\x9b\x9a\x56\xdc\x21\xd7\xbd\x50\xa8\x9b\xbe\xb8\xb4\xb3\xc2\xfe\xf7\x57\xe1\x21\xda\xf3\x0a\x0d\x7a\x06\x87\xce\xee\x2f\x62\xef\x4c\x5d\xbc\xd0\xa2\x52\x38\x0c\x1c\xf4\x20\x3b\xc4\x39\x54\x94\xd7\x45\x51\x3e\x85\xc3\x01\x0d\x3a\x42\x2c\x29\x38\x69\x37\x74\x57\x27\x20\x0b\x92\xfc\x6a\x19\x00\x45\xf8\x82\x23\xdb\x2b\xc9\x2d\x13\x40\xbc\x6e\x4b\x36\xc6\xcb\x75\x06\x8c\xce\x85\x2f\xcf\x21\x07\x7c\xc0\x5e\x45\xfe\x99\x23\x6c\xda\xb4\x7d\x97\xf0\xfb\xa1\x97\x7e\x69\x47\x34\x55\x3e\xbd\x64\x6f\xe7\xb5\xab\xc3\xa0\x46\xa8\x3b\x4a\xbf\x21\x4c\x7f\x49\x58\x1b\x7d\xf7\x9e\xdb\x7e\x59\x33\x7b\x51\xd5\xe2\x23\x1b\xc6\xcc\x2d\x7b\x06\x0c\x6b\xd8\x4e\x24\x31\x30\xff\x41\xfb\xb9\x80\x18\x10\x8f\xe8\x2c\x7a\xa3\x11\xed\x28\xd6\xad\x80\xf9\xc1\x20\x64\x61\x51\xa1\xd5\xed\xd3\x53\x39\xac\x45\x4d\xf8\x08\x64\x3c\x7d\x66\x23\x96\x3e\xd5\x4d\xd7\x7c\xe4\x21\x15\xee\xc8\x40\x9e\x69\x34\x4c\x45\x06\x04\x66\x24\x55\x6f\x44\x7f\xee\x06\x16\xf0\xdb\xb0\xb5\x8e\xf9\xc0\xba\xd8\xb0\x6c\xc8\x06\x27\xb2\xf3\x87\x4d\x46\xe1\xaa\x99\x81\xfd\x77\x4e\x58\xb2\x4d\x5f\x7d\x68\xda\xc6\x1d\xe6\x15\xc0\xba\x88\x87\xcf\xde\x79\x33\x59\xdf\xb8\x66\x58\xe1\xc2\xdd\x1b\xc8\xe1\x0d\xc7\xea\xd7\x6b\xd6\xe4\xce\x19\x32\x7f\xe6\xd2\x29\xb7\x6e\x8c\x8f\x43\x2e\x61\xf3\xd0\x56\xf4\x42\x51\x37\xa1\x4e\xd4\x2d\x8a\x6c\x6b\x8e\x8e\xd7\x1b\x0c\x1c\xa7\x67\xed\x0a\x18\xf1\x7a\x91\x6e\x79\xb9\x46\xbb\x4b\x4f\x05\x58\x35\xe1\x42\xaa\x59\x5c\x16\x83\x33\xa9\xda\xff\x45\x33\x80\x36\xec\xff\x9b\x56\x28\x0f\xba\x38\xef\x7f\xd5\xe9\x1f\x37\x39\xa6\x05\x85\x44\x5f\xa1\x78\x95\xea\x4f\xb4\xc1\xfc\x90\xad\x83\x6e\x8a\xa2\xd1\xdb\x62\x59\xba\x20\x48\xb5\x2d\x47\x2f\xcf\xa4\xcf\x2d\xae\x4e\xe4\x3a\xdd\x16\xd6\x41\xa8\x1d\xc8\x1e\xf9\x1c\x1c\xcf\xd2\xac\x48\x6d\x51\x99\xbc\xe9\xac\x90\xb0\x7b\x45\xfc\xd2\x66\x1b\x0e\xc8\xed\xb1\x2d\x36\xca\x5a\x93\xd3\x36\xd9\xee\xa3\x23\xc8\xa1\xf3\xb0\xa6\xc2\x77\xb2\xa6\xc2\x45\xf4\xfe\x00\x97\x7a\x7f\x83\xef\xbd\x11\xe9\xba\x35\xc3\x91\xdc\xc2\x43\xb8\xe4\xce\x9b\x1b\x0f\x90\x8b\x45\xad\x1b\x0f\xc2\x81\xa9\x37\xb9\x6a\x02\x56\x3c\xed\x51\x5e\x91\xf4\x17\x7e\x94\x79\x0c\x72\x30\x0e\x22\x0c\x28\x9d\x2a\xcc\x1e\xa6\x32\x05\x4c\x51\x96\x8d\x38\x09\xaf\x17\x19\x78\x2f\x67\x65\xb5\x7c\x75\x42\xeb\x24\x92\x6e\x32\xdd\x26\xcc\x37\xa3\x33\x48\x6b\x9a\xa5\xd1\x75\xc4\x06\xdf\x48\xbe\x7d\x4d\x86\x06\x27\x32\x9b\x81\x91\xff\x4f\xba\xf7\xc1\xb2\xd4\xf0\xbe\x54\xef\xaf\xe8\xfe\x65\x5f\xff\x0c\x92\x1f\xe3\xcd\x46\x08\xb3\x23\x44\xeb\x91\x07\x51\xab\x91\xb7\x0f\x99\x3d\x54\x5e\xae\xdf\x55\x9d\xf0\x3b\xf5\x0c\xcf\x23\x6f\xcf\x73\x6a\x96\x91\x2d\x45\xcb\x6e\x3e\xcb\xd1\x37\xef\x68\xce\x76\x6a\x19\x4e\xbe\x59\x17\xf3\x56\x6a\x6a\x51\xa7\xdc\xc4\x94\x55\xeb\xb5\x6b\x93\xde\x3d\xbb\x6f\xb9\xd1\x9b\x53\xa7\x3d\x6f\x98\xb6\x38\xd6\x99\xdc\xbf\x04\xe9\x51\x88\x62\xac\x3f\xd0\xb9\x52\x11\x45\x71\x33\x50\x28\xa1\x52\x05\x29\x15\xa5\x51\x33\x24\xa5\xc4\x3d\xe0\xe2\x76\x8b\x65\x96\xe5\xa5\x93\x93\x0b\x00\x0c\xa2\x03\x63\x8c\x51\x01\xa1\x41\xb8\x63\xdb\x3f\xe7\x91\x6d\xeb\xbf\xed\x1f\xf2\x4a\xa3\x09\x79\xda\x3c\xf2\x83\xd4\xac\x00\xce\x45\xa8\x3b\xc5\x18\x3a\xde\x74\x05\xed\xfb\x01\x22\x87\xc2\xe4\x78\x05\x67\x64\x4d\x26\xf4\x92\x71\x03\x84\xd3\x6c\xd0\x29\xc2\x21\x23\x61\xd5\x68\x75\x1c\xd0\x53\x1c\x67\xd5\x5a\x4d\xd5\x09\xab\x59\xcb\xa2\x4d\xc0\xaa\x3c\xf8\x9a\x84\xb4\x55\x25\xc8\x96\x8a\x6d\x72\x6d\x07\x23\x8e\x64\xf7\xb0\xa2\x63\xae\x48\x71\x2c\x58\xcb\xc5\x6e\x16\xe9\xaf\x48\xa9\x84\x2b\x8b\x93\x03\x98\xb3\xe6\xb6\xf7\xfe\xde\x0f\x0a\x5e\x79\x60\xb2\x8a\xfc\x24\x2a\x94\xe6\x83\xc3\x51\x61\x68\x09\x78\x2b\xda\x98\x73\xf1\xee\x47\xe6\x4d\xb8\xfd\xc8\xe4\xb2\xde\x7f\xbc\xfa\x3a\x28\x3b\xdc\xb5\xf8\xec\x97\x67\xff\x7a\xf3\x41\x60\xfd\x7a\xfa\x62\xe1\xda\xff\xcc\x5d\x25\xe5\x08\x15\x48\xbf\x71\xa2\x7e\x05\x28\x47\x08\x9a\x9d\x1a\x35\xcc\xcd\x55\x07\xc4\x00\x30\x18\x54\xab\x73\x6c\x06\x45\x8e\xa2\x2a\xe1\xcd\xb1\xd8\x50\x82\x60\xe3\x32\x40\xa6\xc5\xce\x85\x0a\x43\xac\x19\xb7\x20\x95\x02\x7d\x91\x13\x2d\x09\xb8\x57\xe4\x43\x4b\x02\xed\xcb\xfa\xc1\x39\xc2\x9f\xc2\xa5\x3e\x03\x06\xdf\xe4\x0c\x01\x32\x57\x59\xd5\xa5\xe7\x4d\x9d\x3f\xfa\x08\x4c\x04\xe3\xb7\x7e\x7f\xdb\x92\xdb\xa3\x54\xc7\x47\x57\x9c\x78\xf2\x35\xb0\x16\x6e\xbc\xf6\xd3\xf2\x79\xfb\x36\x3f\xf5\x61\x7b\xf7\x90\x91\x63\x5f\x9c\xf8\xf8\xde\xd3\xc2\x5f\xc2\xef\x77\x09\xdf\xee\x98\xba\x6a\xe9\xcc\xf7\xde\xf8\x14\x74\x7a\x40\xec\x65\xe9\x88\xf2\xec\xa7\x90\x6f\xe4\x51\x86\xe0\xc3\xbe\xc5\x62\x50\xdb\x19\xe0\xb3\xfb\x74\x6e\x37\xa5\xa3\x02\x7e\x25\xb0\x3b\x18\x47\x55\x42\xcd\x70\x46\x1f\xf0\x55\x25\x0c\x40\x4a\x17\x62\x29\x02\x48\xa9\x51\x5b\xda\x42\xc9\xa3\x8b\xb9\x89\x80\xb1\x08\x94\x71\x04\x6e\xd1\x91\x6a\x85\x41\x68\x14\xdf\x4a\xc4\x2f\xa2\x6b\x5a\xc1\x13\x55\x9f\xfd\x08\xc6\x80\xce\x7d\x80\xa1\xcf\xd7\xdf\x1d\x14\xde\x7c\xb3\x6a\xce\xa1\x93\x53\xc7\x08\x3f\x3f\xf8\xd0\xc4\xf1\x42\x1d\xd8\xa9\xfc\xf6\x05\xd0\x0b\x4c\x07\xcb\x84\x55\xda\x8f\x9e\xfb\x40\x78\xf1\xa8\x30\x85\x1c\x0c\x34\x57\xe6\x4d\x55\x36\xfd\x78\xd3\x32\x46\xba\x9b\x3d\xd2\x74\x05\xe2\x7e\x37\x23\x51\x1a\xb7\xd3\xba\xe4\x79\x35\x1b\x4d\x06\x74\x46\x0d\x16\x74\x82\xcd\x22\x32\x46\x1a\x68\x37\xed\x29\x22\x96\xb4\xef\x93\x6f\xc4\x23\xd1\xee\x85\x8b\xf7\x04\xc7\x03\xfb\x01\x1b\x2f\xfc\x6e\x65\xa4\xdb\xd6\xff\x61\x8f\x9f\x20\xc9\x86\x17\x17\xac\x3e\x56\x82\x2f\x5a\x53\xcf\x1e\x20\xc6\x7f\xe8\xd9\x3a\x5a\xa3\x68\xe9\xd9\xe0\xff\xfc\xec\x47\x80\xfd\xa7\xe6\xcf\x86\xb7\x5d\x2b\xc9\x7e\xb6\x50\x27\xea\x8d\x33\x6b\x8f\x96\x40\x2f\x8d\x65\x75\x66\xbd\xde\xab\xf0\xd8\xf0\x3d\xaa\x13\x50\x3a\x96\x52\xa1\x1c\xca\xd2\x1c\x68\x38\x96\xe1\x2a\x83\x19\x0c\x36\x62\xa0\x9d\x09\x30\x0e\x06\x52\xdd\x77\x8f\x29\x6e\x5b\x94\x5c\x92\x6f\xa8\xd2\x76\xd8\x18\x8d\x5c\xb5\x5a\xfb\xf9\xb2\xd9\xfa\x1f\xc4\x55\xb9\x36\x2b\x3f\x2f\x2a\x1b\x20\x29\x2e\x46\xb2\x2d\x12\xeb\x61\xb1\xb8\xdd\x68\x4e\xbd\x15\x93\x8e\x31\x88\x2b\x83\x2d\xa7\x93\xc8\x98\x0f\x49\x32\x04\xa5\xb9\x43\x25\x8b\x99\x79\x13\x8e\x44\x78\x5c\xb8\xf4\xab\xdd\x90\x75\x07\x7e\xfc\x44\xc3\x60\xea\xd2\xc2\x9b\xa5\xfb\x6f\x40\xa8\xe5\x67\x7b\x31\x97\x0e\x6d\x67\xac\x56\x8b\x85\x31\x68\x0d\x5e\x9f\xd7\x6f\x67\xdd\x6e\xf4\x78\x37\x67\x61\x59\xe4\x7b\x59\x27\xf1\x5f\xdc\x4f\x4a\x90\xd4\x9a\x88\x48\xff\xd7\x0b\x35\x37\xb9\x28\xc2\xf7\xda\xe3\xd7\x49\xd7\x78\x44\x5a\x9c\xcb\xb1\xce\xf0\x96\xa4\x98\x32\x67\x37\xbe\x53\xd6\xe1\xfc\x07\x6d\x1a\x9d\x5e\xc7\x6a\x48\xcc\x83\x22\x65\x8f\xe9\xfc\x27\xb5\x1e\xb8\x1a\x65\x85\x9d\x63\x03\x67\x2f\x73\xcd\x12\x2e\x2d\x68\xfd\xe7\xa5\xe9\x03\x61\x7f\xeb\x9a\x5b\x1b\x1f\x25\x27\x00\xe6\x6b\x3b\xc6\xc2\x47\x71\xf5\x09\xf4\xbd\x1c\xfa\x5e\xbd\x1a\x42\x3d\x6f\x40\x4b\xad\xad\x4e\x15\x9c\xe5\xf3\x2a\xd3\x2f\xa7\x82\x09\xa6\xbc\x0d\xe8\x75\xf2\x84\xe3\x03\xe1\xd2\x37\xdc\xa1\xf1\x1d\x0b\xab\xa8\x01\xa7\x1e\x1a\x3e\xa7\xa1\x33\xfc\xa6\x5b\xc5\x71\xeb\x65\xbb\x64\x0b\x7d\xc8\xb7\x2c\x43\xfb\x4e\x87\xbc\x77\xef\x78\x98\x97\x9a\x38\xf4\x28\x22\x27\x49\x0d\x03\xad\x28\x0e\xd5\x13\xb8\xdc\x49\x42\x68\xae\x45\xe1\xb4\x96\x34\x67\x34\xf5\x65\x37\x1d\x4b\xad\x1b\xa5\x22\x1f\xa1\x51\x9e\x13\x44\xbb\x30\x22\xc6\xd0\xf9\x00\x6c\x1d\x2c\x5c\x3c\x0f\x2e\xbd\xfe\xc9\xae\xed\x17\x85\xd7\x9f\xba\xeb\xdc\x8d\x73\x1e\x7d\x1e\x3c\x2a\xf4\xa7\xda\x6d\xdf\x74\xf3\x61\xb7\x90\x0b\x1e\x7d\xb0\xef\xd0\x75\x92\x5c\x34\x27\xca\x65\x41\xd9\x58\x90\x57\x10\x10\x92\x3a\x9d\x5e\xaf\x56\xa8\xad\x48\x36\x9b\x0e\xe3\x03\xeb\x74\x6a\xa0\x61\xd5\xfa\xda\x84\xda\x9c\xd5\x56\x92\x45\x74\x26\xbb\x6e\x55\x92\xf8\x2e\x17\x25\x3a\x9a\x14\x44\x2a\x39\x17\x8c\x07\x6d\x84\x31\xb5\x63\xae\x09\x57\x05\xfa\x3c\x70\x0c\x1e\xf9\xfc\xd2\x99\x55\x83\xce\x91\xeb\x90\x6c\xb9\xce\x8d\x37\x3c\xfa\x18\xd5\x4e\xe8\x2f\x44\xeb\x06\x97\xf7\x46\xe7\xe1\x8c\xdc\x77\x5c\x46\x8c\x8e\x97\xe5\xe5\xba\x89\xe2\x60\x50\x43\xe4\x52\xe5\x06\xda\x6a\x65\xd0\x99\x68\x53\x9c\x67\x75\x53\x39\x34\x0d\x73\x72\x0a\x6b\x12\x39\x9c\x1e\xa5\x41\x7a\x74\x78\xf5\x4e\xe8\xa8\x49\x5f\x43\x65\x96\xf0\xac\x15\x69\x6a\xaa\xcc\x5a\x99\x78\x6b\xc8\x82\xac\xe0\xa2\x2c\xf6\xbf\x34\x25\xc3\xcb\x42\xd3\xbf\xf7\x4e\x32\x4b\xb1\xc6\x50\x14\x6b\x74\x07\xff\x98\x6f\x9a\xde\x62\x4b\x32\x18\x70\xfc\x44\x6c\x76\x2a\xe6\x00\x43\xc9\x50\xdf\x2e\x2d\x37\x25\x8b\xb6\x0a\x79\x20\x74\x26\x45\x5e\x59\x5f\x9c\xe3\xdd\xd0\xc5\x9a\xd1\xe9\x03\x84\x22\x9d\xeb\x49\x6f\x00\x8f\x1f\xe5\x24\xfb\x38\x8c\x99\x98\xe7\x28\xfe\x1b\x5f\x38\xde\x90\xd7\xba\x67\x71\xc7\x88\xe1\x4b\xc7\x84\x87\xd7\x79\x26\xbb\xf2\x42\x55\xbd\x07\xf2\xdf\xe4\x9c\x16\xea\xf4\xcc\xfb\xe6\x9c\x9e\x43\xa8\x45\xeb\x76\xf4\x54\xa9\x3e\x34\x8f\x98\x70\x6d\xd9\xf3\x7b\xb3\x9f\x1f\x20\xba\xc6\x43\x3e\x03\xa1\x67\xf5\x06\x3f\x65\x67\xec\x21\x26\x68\x71\x61\x6e\x1c\x1f\xc7\x72\x35\x09\x02\xe3\x9c\x55\xa7\x71\xce\xb2\x5a\xda\xd2\xf5\x3d\x26\x1d\x8b\xe2\x5a\x71\x79\x2c\x5b\xd2\x18\x03\x86\xb3\x39\xa7\x5f\x95\xc4\x2d\xe9\x18\x31\x1e\x08\xdd\xf3\x44\x96\xc4\xc7\xcf\x85\xc0\x80\xe7\xf7\x8a\x32\xf7\x1d\xf7\x0c\x3c\x96\x12\xba\x61\xc3\x33\x52\x9d\x2c\x86\xce\x71\x5f\x14\x8b\x7a\x89\xfc\xb8\x55\x69\xb4\xa1\x0c\xd9\xe8\xa6\xfc\x3e\x0e\xed\x0c\x8e\x13\x61\x7e\xd3\x14\x9f\x20\x8d\x1b\x9e\xd5\x24\x92\xc1\x56\x22\xb3\x57\xac\x3b\xb8\x47\x77\x52\x5d\x5e\xde\xab\x28\xaf\xfb\xe0\x83\xfb\x74\x4f\x68\x4b\xca\xba\x74\xc8\xeb\x26\xd4\x2d\x5f\xd5\xbd\x9c\xfc\x3a\x3f\xb7\x5d\x99\xf9\x43\xe3\xb2\x9b\x7b\xb4\x69\xf4\x17\x96\x95\x15\x99\xdf\x37\x8b\x75\x85\xe1\x28\x5e\xe0\xc5\xfe\x83\x12\x3c\x65\xa0\x0a\x14\xf9\x4d\x01\x1d\xa7\x80\x4e\x58\x1a\x75\x3a\x5b\xe9\x6c\x61\x8f\x27\xdf\xe6\x14\x5f\x2a\x48\x32\x48\x60\xe8\x84\xac\x8b\x1b\xd1\xec\xa4\xdf\x29\x83\x76\x1f\xda\x87\x11\xb9\xde\x2e\xee\x4b\x63\x27\x89\xc3\x58\xf4\x49\x45\x80\x9a\x21\x2d\x5b\xf7\x1a\xd3\x29\xde\x6d\x0a\x0d\xd2\x9f\x31\x15\x99\xea\x27\xcd\xee\xb5\xef\xd9\x77\x4e\xf5\xde\x52\x7e\x26\xf2\x7a\x63\x61\xe7\xfe\xbd\xcb\x7a\x2f\xf2\xba\x96\xd0\x6f\xe0\x85\x1c\x3c\xb1\xa1\xf7\xc0\x9a\x70\xc9\x62\xf7\xee\x60\x3c\x18\x2f\x71\xdd\xb9\x66\xdf\xb1\xbc\x08\x6c\x78\x79\xef\x3f\xd1\xca\x76\x79\x1d\x3a\x57\x44\x3b\x8a\xbe\xea\x87\xa6\x26\x72\x0d\xdd\x13\x45\x41\x9d\xe3\x7e\x1e\xaa\xb4\x5a\x05\x6b\x65\x21\x43\x39\x75\x3a\x87\x4a\xe4\x57\xc1\xd4\xf0\x1a\x33\x61\xae\x4a\x10\x29\x98\xee\xec\xb2\x6f\xf2\xec\x49\xab\x8d\x6f\x40\x82\xe2\xbe\x48\xbd\x07\x30\x79\xc9\x7a\x6e\x6a\x6a\x9a\x6f\xba\x4c\x16\x42\xf7\xc4\x6c\x21\x8d\xbf\xe2\x09\x3e\xd2\x9a\xc5\x13\x12\x46\xef\x1f\x73\xbf\xd8\x31\x8f\x80\x96\xe7\x55\x10\x32\x56\xa8\x73\xe8\x9c\xac\xc8\x67\xa2\x55\x2b\x59\x51\x24\x67\x26\xe9\x4b\xa6\x44\xa9\xdd\x70\x1d\xcf\x0b\xda\x07\xb9\x48\x9e\xc7\x52\xf2\x3c\x21\xcb\x23\xd4\x61\x79\xe0\x7d\x58\x9e\x86\xea\x0c\x79\xc8\xa6\xcb\x4d\x3f\xd2\x2a\x64\x5f\x5d\x68\x07\x4c\x8b\x97\xb3\x3e\xcc\xea\xa2\xa5\x95\x1a\x0d\xa4\xfc\x20\x48\x04\x2d\x84\xcb\x65\xb7\x50\x96\x9c\xb0\x5f\x69\xb7\xd3\xc0\xc1\xa1\xbf\xb4\xe8\xac\x1b\xdd\xd5\x09\xa3\x45\xcb\xd6\x24\xb4\x99\x04\x1d\x32\x4c\xb0\x94\xb9\x67\xd0\x04\xc9\x4e\x98\x4f\x57\x9c\x92\xad\xde\xcd\x48\x3a\xc4\x15\x06\x32\x99\x30\x49\xd4\x82\xfb\xaa\x81\xa3\xfa\x4e\xdf\xdd\x59\x14\x1d\xde\x4d\xa1\xcd\xd5\xc0\x3b\xee\xa8\x5d\x48\xd8\x91\x55\x1e\x0f\xf6\x08\xe3\x9f\x39\xf6\xc2\x1c\x99\x9e\xa3\xec\xe0\x33\x60\x4f\xc3\xba\x7b\x97\xcd\xcf\x5d\x89\xd7\xbd\x63\xd3\x15\x9a\x45\x7a\xc6\xf0\xfc\x44\x7e\x4c\xe9\x60\x8b\xa1\xd7\x12\x66\x59\x25\xb4\x50\x65\xad\x81\xc3\xe9\xa8\x4e\x94\x3a\x59\x6d\x14\xbd\x03\x4b\x56\x9c\x9f\x35\x9f\x28\x96\x11\xb1\x79\x25\x53\x98\x09\x9d\x28\x09\xcb\x5f\x4e\x00\x33\xd0\x06\xa4\x6a\x1a\x75\x69\x56\x57\x4f\xc8\xb3\x5f\xb8\xfc\xc0\x65\xe1\xf7\x60\x59\xc7\xb2\xa0\xdb\x3d\x25\x7a\xbe\xdf\xe8\xa2\x8a\xf2\x56\xcb\x67\xdf\x72\x8f\xcb\xbd\x6a\xca\x17\x70\x46\xb9\xa9\x6b\x62\x5a\xc7\x6d\x17\x96\xbd\x79\xa2\xe7\xac\x61\xbd\x2a\x0a\x8c\xbc\xeb\x6c\xa2\x4f\xf1\x8d\x75\xb5\xcb\xda\xcf\x5e\xfa\xf4\xc1\x8a\xb9\x73\xa3\x37\x2e\x14\xf7\xd1\x44\x94\xab\xdd\x82\xec\x88\x07\xf3\xcd\x58\x20\xa7\x52\x39\x21\xf4\x79\xb5\x2c\x83\x72\x70\xc6\x42\xd8\xab\x9b\xb5\x08\xa5\x6d\x89\x7c\x69\xee\x33\xa4\x39\x3b\xda\xf0\xa9\xf6\x33\x78\xf3\x92\x4d\x0f\x0a\xe7\x9e\x14\x66\xf1\x8b\x81\x7d\xa1\x6e\x7f\xdd\xde\x11\x1d\xe2\xb9\xe5\xd1\xc8\x42\xaa\xff\x9e\x9d\xdf\x08\xab\xcf\x83\xb6\x1d\x86\x93\xcb\x1a\x6f\x8d\xc7\xee\xba\x1b\x28\xb6\xf5\xe8\xac\x39\xc7\xa8\xd1\x99\xdb\x87\x07\x20\xc4\x1a\x6d\x00\xcf\x6e\x93\x8c\x4e\xad\xc1\xb0\x22\x66\x06\xd7\x7e\x31\x3c\x75\xca\x1d\x4b\xbd\xce\x10\x39\x2d\xdc\xd5\x09\x9a\x40\xf5\xc3\xc2\x97\x3d\x29\xbe\x43\x27\xe1\xb4\xf0\x2e\xd5\xee\xda\x19\x72\x84\xe7\x23\xeb\xd6\xc5\x8d\xfb\xa5\xb8\x18\xfd\x83\xfe\x16\x7d\xb7\x09\x73\x9d\xaa\x94\x8c\x42\xc3\xea\x21\x20\x0c\x06\xa8\x51\x52\x16\xa3\xc9\x64\x56\x99\xcc\x1a\x03\x34\xb0\x66\x85\xf4\x34\x11\x88\x2e\xa3\xba\x97\xaa\x26\x89\xcf\xb6\x62\x6e\x64\x24\x41\x19\x0b\x00\x8a\x4c\xb0\x10\x5b\x41\x6e\x3e\x5d\x96\x07\x8a\x40\x6e\x77\x41\xd0\x3b\x5b\x0b\x9f\x08\xe7\xf3\xe8\x32\xe1\x73\xe1\xdf\x28\x49\x9e\x7a\x71\xcb\x50\xf2\x56\x24\xd8\xa9\x55\xdd\x16\x37\xae\x26\x97\x3c\xb7\xba\xb1\x37\x91\xe4\xfd\x7c\x95\xfe\x16\x45\x28\xe5\x71\x87\x46\x6d\x52\xb1\x6a\x96\x34\x92\x36\xcc\x74\xca\xa2\x68\x19\xd3\x82\x68\x70\xf9\x2e\x56\x9c\x7d\xe5\x9d\xba\x60\x05\xd2\x5d\x01\x3a\x09\x48\xa4\x1c\xb2\x1c\x93\x9c\x82\x4e\x80\x72\x8a\xcd\x8d\xff\x1f\x6b\xef\x01\x1f\x65\x91\x3e\x8e\xcf\xbc\x6d\x7b\x6f\xc9\x6e\xda\x66\xb3\x9b\xb2\x09\x49\x76\x93\x2c\x81\x40\x96\xde\x49\x40\x14\x56\x0c\x5d\x3a\x0a\x48\x27\x48\x53\x7a\x55\x40\xb0\x80\x0a\xea\x29\x8a\x48\xb7\x81\x05\x3b\x58\x0e\xef\x6c\xa8\x9c\x60\xc3\x7a\x9e\xa7\xa7\xb0\xb3\xff\x67\xe6\x7d\x77\xb3\x09\x7a\xdf\xfb\xfc\x3f\x3f\xf8\x90\xcd\xbe\xcc\xcc\xfb\xcc\xcc\x33\x4f\x9b\xa7\xd4\x5c\xd5\xd8\xed\x5d\xf2\x71\x2f\x29\x97\x33\xaf\x23\x71\xf2\x2e\xb7\x61\xde\x07\xe2\x79\xea\xd6\x18\xbb\xe9\xd2\x27\xf8\x9f\xb9\x38\xa0\x29\x00\x68\x75\xc2\x4d\x7f\xdd\x29\xd3\x99\xe9\x00\x13\xac\x23\x52\xa3\xa2\xa8\x8d\xe7\xd4\x48\x40\x1c\xaf\x11\x25\x49\x2b\x88\x9c\x89\x99\x68\xc2\xad\x2e\xe4\xa8\x51\x06\xb3\x3b\x38\x1e\x77\xbb\x86\xbc\x87\x8b\x0f\xe3\x11\x38\x10\x3f\x3b\x18\x1f\xe3\x96\x91\x21\xf8\xd1\xf8\x34\x12\x43\xc9\x58\xa4\x7c\x16\x8b\xd4\x2b\x5a\xe0\x94\x24\xec\x32\x80\x54\xe6\x06\xa1\x27\x33\x43\x74\x89\xd4\x08\xc0\xd8\x99\xa7\x6d\x36\x89\xf4\xea\x47\xf2\x69\x6a\x9d\x51\xa2\xb5\x9e\x42\x6b\x2a\xb7\x24\x95\xe0\xda\x77\x10\xaa\x6a\xcb\xeb\x0a\x63\x83\x6e\x59\xae\x35\xc5\x17\x28\x89\x25\xc8\x07\x81\x60\xa9\xfe\xb4\x65\xf9\x9c\xca\xd0\x80\x57\x18\x4d\xfb\x38\x51\x2d\x76\x04\xf8\x5c\xc8\x4b\xeb\xe6\x79\x2c\xa2\xda\x85\x24\xc4\xe9\x1c\x5e\xb5\x45\xed\xd3\xf2\xf9\x39\x46\x23\xaf\xd2\x48\x2a\x60\x6a\x2a\x93\x57\xd0\xf2\x5a\x0a\x34\x8b\x57\x7e\x59\xb1\xb0\xa6\x74\xfc\x70\xab\x18\xd1\xca\x0a\x91\xc2\x25\x03\x9c\xb2\xfa\xf8\x40\x79\x68\x09\x5d\xc2\x43\xaa\xec\xa4\x4b\x5a\x30\xd5\xcf\xf7\x5d\x58\x70\xe3\xea\xd3\x7f\x23\xff\xec\xd3\x13\x7f\x5e\xdb\xcb\x9f\x5b\x79\x7d\xef\x51\xbd\x32\x95\x98\xaa\x13\x3b\xd7\xdc\xb8\x7d\xc7\x98\x49\x78\x7b\xa8\x34\xcb\x3b\x70\x00\x5d\x63\x96\x2b\x13\xe6\xe0\xa6\xf1\x05\xbc\xd5\xa4\xd6\xa9\xad\x7c\x86\xd6\x60\xc8\xca\xcc\xc8\xf0\x98\x32\xd5\x6a\x27\x90\xa9\x86\x98\xd3\x63\x64\xde\xc9\xfa\x2b\x8a\x03\xfc\x41\xf9\x11\x51\xb6\x61\xb7\xae\x30\x21\x07\x1a\xe0\xd5\xf3\x36\x77\xb9\x75\xc1\x20\x3f\xbe\x23\xfe\x6a\x21\xbf\x22\x40\x06\x3e\x70\x64\x6d\xfc\x3e\xd2\x10\xc5\x66\xcf\x57\x0f\xae\x1f\x33\xa7\xea\x59\x3c\xfc\x8d\x17\xc9\xed\xee\x0b\x47\x36\x7f\xbb\x0c\x8f\x2e\x7e\x0d\xd6\xfa\x79\x05\xce\x3c\x54\x42\xad\xf1\xbc\xba\x98\x2f\xb0\xa2\x1c\x97\xdb\x85\x44\xc1\x90\x99\x95\x55\x5a\x60\x30\x04\xb3\x19\x79\xf5\x9a\x73\x5c\xbc\xd5\xec\x32\xbb\xb4\x1e\x53\xa1\xd6\x83\x58\x30\x3d\xb0\x0b\x59\x40\xff\xa3\x02\x19\xb2\x17\x16\x50\x55\x2a\x5c\x14\x4a\x49\x69\xc2\xd5\xba\x7a\x4a\x52\xae\x88\x04\xf8\xc3\x45\xb9\xc1\xfc\x4f\x0d\x59\xfb\x5e\x3c\xf0\xd6\xfb\x47\x9e\x7b\xe4\xf1\x63\xe9\x53\xfa\xcb\xc1\xf8\x43\xfd\x46\x34\x0d\xdc\xd6\x34\x7d\x74\x87\xb5\xde\x5e\x7d\x56\x05\xba\xce\xba\x7b\xd9\xd6\x7d\xcd\xdc\xfa\x75\xc9\xe9\x9d\x25\x1f\x76\xa8\x0c\x77\x1c\x72\x2b\x3d\x47\x43\xe0\x1c\xe5\xb3\x7a\xa8\xed\xa3\x59\x19\x48\x6f\x40\x86\x4c\x95\xcd\xe6\xe6\x5d\xb0\xe6\x3c\x6f\x46\x66\x40\x1d\xb3\x20\xdb\x3c\x53\x65\x19\x5a\x95\xb4\x0c\xdb\x92\x66\x20\xd9\xa3\x47\x71\x2d\x55\xf1\xef\xce\xef\x30\xe0\xea\x75\x03\xc6\x0c\xdf\xdb\x9d\x90\x7a\xac\x3f\x71\xf6\xab\xe6\x7f\xac\xe9\xcf\xdd\x68\x1d\x7f\x74\xee\xb0\xeb\x4f\x76\x7b\xfc\xa9\xf3\x7f\xbf\x87\x24\xee\xb7\x91\x39\x14\x96\x89\x00\xcb\xec\x16\x58\x2c\x02\x12\x32\xf5\x3a\x9d\xdb\x8e\x69\xee\x16\xbb\x1a\xa9\x8d\x8d\x34\x05\xd0\x7f\x81\xc5\x6b\x4b\xc6\xf4\xd2\x48\xd6\x96\x92\xf6\x3c\xae\xeb\xbf\x74\xd7\x56\x6c\x3f\xfa\xdc\x27\x26\x72\x41\xf3\xc0\xca\x6d\xc3\x87\x79\xeb\xcb\xe7\xe3\x35\xce\x0f\xef\x7e\x0a\xfb\xef\x7b\x72\x7f\xb7\x93\x2f\x1d\x9a\x30\x43\xd2\xc7\x37\x03\x7e\xfe\x0d\x68\xfd\x67\x0c\x96\x9a\xa8\x07\x20\xc9\x10\x32\xdc\x00\x4b\x26\xb6\x03\x2c\x18\xab\x33\x78\x06\x8c\x23\xad\x5c\x4b\x9b\xb2\xaa\x49\x13\x52\xcb\xed\x0a\x3b\x3c\x36\xde\xd8\x7f\xf3\xc6\xdb\xc9\xb7\x4f\x02\x24\x38\xab\x05\x12\x71\x1b\x99\xd3\xee\xdd\x1d\xc7\xc8\xf9\xbb\x5b\x60\xe1\x6e\x84\x75\xc9\x21\xd7\x08\xb3\x84\x06\x10\x99\x22\x00\x8b\x55\xef\xb2\xba\xb2\x04\x9e\xcf\xb6\x08\x76\x64\x37\x36\xc4\xec\x20\xbd\x36\xb4\xf2\xcc\x6a\x5d\x02\x5b\x16\x5e\x45\xc5\x0f\x44\xf1\xcc\x96\xab\xb2\x44\x6c\x56\xee\x95\x67\x3f\x33\x92\x0b\xba\xbb\xa7\x2f\xf1\x37\xb8\x0e\x24\xc3\x7d\xdf\x3b\x9f\xd9\x77\x9c\xd0\x40\xfd\x49\x77\x1c\x26\x93\xe6\x84\x2e\xb2\xc8\xde\xb3\xa7\x3b\xde\x8a\x97\x70\x66\x6a\x8b\x53\x6a\xeb\x82\xe2\x9c\x05\xe7\xa3\x2e\x9a\x9d\x9b\xed\x06\xcc\xb1\xe9\x78\x5d\xbe\x37\x3b\x27\x07\xa9\x54\xce\x91\x31\x95\x0d\x99\x46\xc6\x90\xd0\xca\x93\x23\xdc\xc6\x82\x8b\x99\x01\x91\xca\x1b\xac\xa0\xae\xab\x55\xfd\x5c\x7a\x5f\xc7\xdf\x8b\xfd\x78\xf0\x5f\xc9\xad\xff\x52\x6a\xe9\x7e\x9e\x2a\x9b\x4b\xae\xea\x88\xbd\x1d\x61\xf9\x5e\x23\x3f\xff\x42\x26\x7f\x94\xac\xa2\xfb\x75\x7a\xd5\xdc\xf8\x6a\x5c\x49\xde\x92\xf3\x17\xf8\x01\xcf\x1e\x57\x74\xee\x6c\xd4\x27\x1a\xb0\x09\x6e\x8d\xd1\xe5\x32\x18\x24\x8d\x20\xe4\xe6\x48\xc6\x6c\x63\x36\xb5\x05\xc0\x61\x70\x0d\x8a\x19\x1c\xc8\x39\x48\xae\x4e\xf2\xe7\xae\x4f\xf2\x8d\x6f\x2a\x9f\x1a\x50\x4c\x2c\x1f\x8a\x20\xe6\x69\xed\x8f\x20\xfe\x0f\x57\xf9\xfc\x4b\x17\x07\x8c\xfc\xf5\x54\x7c\x2e\xde\xf4\xe3\xf0\xeb\xaa\x9f\xfe\x71\xed\xa5\x4b\x27\x2f\x09\x1d\x56\x2d\x3d\xd2\xc7\xd3\x3c\x70\xd7\x3e\x6e\x69\x56\xe7\xaa\x69\xf1\xf6\x1b\xd6\x50\x9b\x45\x0e\xc8\x40\x3d\x98\x3d\x2a\x40\x75\x17\x8b\x8b\x2f\xd0\xe6\xe4\x14\x78\x61\xd1\x8b\x0a\x25\xb5\xda\x63\xf7\x18\xa8\xcb\xfe\x1f\x78\x66\x85\xdb\xba\x15\xd3\xd5\x54\xc9\x37\x9e\x8a\xc9\x36\xcd\xb7\x90\xea\x2b\xd5\x55\x05\xdc\x88\xab\x46\x8d\x1e\xee\x73\x7d\x73\x4d\xcf\x91\x5b\x86\x4e\xa8\x7b\xff\xab\xfd\xe4\xdc\x13\x2f\x9e\x7f\x68\xeb\x35\x63\xb0\x9e\xbf\xab\x61\x60\xb4\xe6\xc8\xa3\x9d\xa3\x33\xbe\x5c\xb1\xfc\xb6\x83\xff\xfe\xf2\x31\xf2\xc6\x9e\xbb\x57\x2c\xbe\xd3\x68\x9f\x76\xd5\xe6\x43\x28\xe9\xdf\x23\xde\x2b\x56\x00\xc4\x83\x81\x33\x21\x14\x30\x98\x55\x0e\x87\xd1\x1c\x10\xf2\x0a\xf3\x8a\x98\x07\x54\xa6\x11\x79\x32\x4d\x26\x5b\x66\x26\xdf\x18\xcb\x34\xdb\xb4\x0d\x20\x67\xb7\xf1\xf3\xa9\x0d\xd3\xc0\xfe\xb6\x31\x83\x38\xcd\xc1\xa7\xbe\x95\xf3\x4f\xc8\x95\x56\xf8\x90\x9f\xd4\xe2\xe7\xe3\x6e\xed\x05\x74\x43\xb3\xe3\x99\x4d\x5d\xa8\x2b\xc2\x42\x4b\x16\xf7\x5e\xd2\xed\x67\x75\x8b\x33\x50\xed\x8a\xad\xd4\x89\xe2\x7d\x25\x0f\xdd\x63\x42\x07\xab\xc4\x7f\xcf\x62\x5f\x7b\x2a\xfa\xb8\x19\xa4\xb4\x5c\x5a\xf7\x1d\xb8\x94\x41\xa3\xb1\xd8\x6c\xde\x6c\x10\x4e\xad\x96\xab\x62\x56\xac\x36\x19\xdc\x6e\xad\x24\xb1\x92\xd7\xa1\x10\xbd\x35\x0f\xd7\xa7\xc5\x97\x25\x65\x34\x5b\xda\x5d\x34\x73\x3d\xb3\x51\x5a\xcf\x1c\xcf\xd8\x6e\xdd\xba\xe6\xf0\x85\xf7\x26\xec\xc5\x99\x7b\xef\x2e\xbc\x5b\xd3\xee\xd3\x7f\xd3\xf8\xb2\x78\xc7\x1e\x03\x1d\xfa\x99\xb1\xc6\x5a\x32\xf4\xb6\xb9\x8f\x1f\xe7\xa7\x5d\xbe\xfd\x74\xf1\xa9\x43\xd2\x83\x6f\xbd\xf5\xbb\x7b\xc0\x98\x0e\xfd\x3b\x94\x46\x98\x0c\x73\x98\xdc\x20\x5c\xcb\x64\xd5\xaa\x68\x06\xd6\x6a\x55\x3c\x2f\x20\x9d\xa0\x33\xa8\x35\x7a\x15\xd6\xf0\x3a\x93\x44\x03\x7d\x5e\x4e\x3a\x2e\x85\x2c\x49\x0f\x1a\x59\x60\xb1\xc9\x17\x90\xb4\xa8\x1c\x7e\xe0\x99\x75\x57\xe3\x0c\x72\x8e\x7c\xf9\x10\x29\x27\xc7\xf1\x07\xe4\x3b\xd0\x48\x4c\xfd\xf0\x83\xbf\x57\xf1\x83\x49\x14\x3f\xc8\x6d\xa1\x7b\x5f\x0c\x8b\x54\x04\xef\x14\xa9\x0d\x4f\xc0\x22\x2d\x85\x6d\xc2\x42\x63\x0c\x3b\xda\xd8\xf0\xa8\x65\x8a\xf7\xf2\x28\x5e\x7c\x06\x26\x88\x8f\x0b\x1d\x2e\xdf\x2e\xdb\xe9\x3a\x2a\x7e\x74\xb2\xcf\x7a\xd0\xec\x43\x3c\x86\x83\x68\xc0\xfa\x62\x97\xde\x25\x05\xa5\x52\x0b\xb2\x7b\x3c\xfe\x86\x98\xc7\x6c\xcf\x05\xda\xe7\x34\x7a\x98\xb9\x38\xe9\xec\xd1\xc6\xdf\xb9\x4d\xf4\x06\x4e\xf7\x89\xc3\xff\x35\x6d\x08\xbf\xac\x21\xef\xc0\x86\xc1\x8a\x23\x1c\x39\xf3\xa7\x49\x42\xf8\x95\xb8\xbd\xe2\x02\xf7\xdb\x17\x7f\x9a\x15\x04\xf6\xe4\x69\x85\xd7\xe6\xa1\x1b\xa2\x75\x9e\x8c\x2c\x57\x96\x2b\x07\x61\x9c\xad\x37\x18\xb2\x33\xf9\x5c\x60\xbb\xf9\xb9\x5e\xca\x78\x3d\xb9\x79\xb9\x83\x62\x19\x79\x7a\x13\x8f\x4d\x79\xb9\x79\x9c\x11\xd0\x8b\xcf\x33\x67\x3b\x14\x6e\x9c\x0c\x9b\x63\x91\xb6\x4d\xb5\xc9\x30\xdb\x56\x31\x46\x69\xfe\x19\xf8\x8f\x39\xb4\x09\xb3\x8b\xa7\x08\x88\x7b\xd6\x8e\x7f\xc4\xaa\x8d\x78\xac\x9f\xec\x74\x93\xcf\xdd\xe4\xb4\x1f\x47\x71\xf9\x15\x8c\xbb\xef\x53\x2b\x56\x3c\x45\xf7\x5e\xa7\xf0\xee\x3c\x34\x25\xda\x31\xc3\xe3\x72\x65\x65\x21\x10\x5c\x80\x47\xe5\x0a\xd9\x99\x82\x17\x78\x67\x3e\xe5\xe3\x2d\x53\xb3\x27\xa7\x66\xcf\xb3\xe7\xa9\xb3\x1d\x0a\x73\xff\x2f\x53\x6b\x99\x58\xca\xd1\x2b\xf2\x27\xec\x3e\x35\xb1\x05\xc6\x3f\x62\xfb\x1d\x71\x3f\x3f\x39\xc2\x26\x76\x18\x26\xd6\xf7\x0a\x19\x80\xbc\xc3\x26\xc6\xb3\x1c\xea\xb9\xac\xee\x6e\x09\x2a\x83\x7d\xeb\xe8\x0a\x3a\xdd\xa5\xa5\x4e\x3e\xdf\xca\x3b\x1c\xa8\x58\xab\x45\x1e\xbe\x5d\x59\x46\x46\x79\x66\xd0\x15\x04\x29\xdb\xe4\xc0\x82\x45\x65\x34\xd2\x0c\x37\x66\x55\x76\x03\x28\xab\xee\x52\x54\xda\x2a\x6b\x41\xeb\x00\x04\xd4\xca\x45\x03\x3e\x42\xc9\xe9\xa5\x9b\x0d\xd2\x93\x05\x51\x5d\x42\xe5\x6f\x95\xd2\x91\xc7\xdc\x67\x1a\x49\xb8\x22\x2b\xd0\x00\x7e\x7c\x61\x7c\x18\x77\x75\xd1\xef\x2b\x5a\xd2\x38\x56\xdc\xcc\xed\xc8\x1d\x9b\xd3\x3a\x1c\x81\xdc\x00\xa2\xfa\xe9\x47\xd3\x9c\xf3\xb9\x17\xe3\xa3\x39\xd9\x3f\x07\x55\x92\xa1\xaa\x3d\xb0\x0e\x55\xa8\x2b\x5a\x15\xed\x13\xc8\x74\x96\x78\xf3\x6c\x65\x56\x6b\x45\x45\x55\x07\x1a\x7b\x51\xd9\x45\x92\x2a\xf3\x4a\x32\xc5\x6e\xa5\x76\x7b\xf7\x4a\x87\xb3\xa4\x84\x92\xc5\x6c\x5f\x43\x2c\xdb\xe3\x28\xb3\x95\x35\xc6\x6c\x26\x25\x1c\xa3\x13\x0b\x54\xa8\xfe\xc3\x70\x8c\xd6\xce\x2b\xf5\x6d\x96\x26\xdc\xaa\x38\xf9\x1f\x25\x52\xfa\x2f\x6e\x2d\x7f\x14\xd1\x70\xe1\xca\x15\xe3\x7e\x4e\xf9\xbd\xbc\xfa\x4d\x47\x8c\xba\x1d\x4d\xf9\xbd\x0c\x5f\xf8\x5f\xe2\x1c\xe4\x45\x4c\x39\xc5\xcc\x58\xd8\x98\x72\x8a\x89\xcf\xbb\x32\xf2\x41\x00\xdc\xaa\xd6\xd0\x9a\x9b\x25\xa8\x3d\xea\x88\x7a\xa0\x2d\xd1\xc6\x80\xcb\xdb\x43\xa8\x2f\xa8\xcf\xee\x68\xf7\x15\xd8\x6a\xad\xce\x0e\x1d\xac\x25\x15\x74\x7d\x0b\x23\x92\x54\x58\x60\xcf\x16\x7b\xf5\xec\xea\x76\x17\xf6\xe8\xe0\x2c\x74\x82\xca\x51\xe8\x70\xd4\xda\x6a\xd3\xd6\x36\x4c\xd7\xb6\x24\xc8\x07\x1b\x62\x3e\xaa\xf0\xbd\x9c\xb6\xa4\x2d\x2b\xac\x04\x25\x86\xd3\x25\x85\x16\xcc\xb3\xa4\x2c\x9f\x7f\xba\xc6\xde\x74\xd5\xb0\x10\x54\xc6\xb6\x2b\x8b\x79\x4d\x8b\xc6\xf8\x07\x69\x46\xfb\xf3\xa3\x0b\xe3\x63\xb0\x3a\x4d\x75\x7c\xa8\xca\x1e\x2f\x4d\x5f\x5c\xbe\x72\x19\xb7\x1d\x37\x2a\x0a\xe5\x15\x4b\x9d\xa6\x5a\x4e\xe9\x95\xd9\x66\x7d\x01\x79\xaf\xe1\x1e\x89\x8f\x48\xaa\x9c\x80\xc3\xd7\x20\x24\x2d\x10\xdb\x83\xd6\x5c\x8d\x46\x44\xc3\xe6\x72\x67\x99\xd3\x11\x40\x9e\x32\x53\x38\xac\x97\xb4\x52\x19\x72\x88\x91\x1a\x6b\x26\xad\x06\xee\x71\x06\x78\x5e\x57\xa1\xd5\x81\x74\x62\x32\xe8\xe4\xb0\x1a\x47\x2b\x9b\x25\x2c\x4f\x6b\xe7\x89\xb4\x4b\x7e\x6c\x2e\x6e\x65\xc5\xf4\xa6\x5f\x5d\x38\x5d\x39\x9c\xe8\x57\xae\x35\x68\x45\x38\xb9\x02\xb1\x54\x4d\x34\xf1\x4e\xcd\xab\xcc\x63\x65\x03\x27\xfe\x66\xd0\xc4\xe4\x05\x46\x9f\xc6\x97\xef\x69\xb8\x74\x80\x9b\x32\x7b\x52\xc3\xe6\x8d\x9b\xfb\xba\x13\xe8\x7a\x5d\x05\xbe\x96\x3c\x48\x2d\x9f\x98\x1c\x27\xc4\x22\x5f\x60\x14\x87\xcc\xc5\x83\x16\xff\x82\x3b\xd6\x87\x23\xb9\x79\x03\x66\x0c\x1e\x50\x17\x4f\xb4\xf7\xb6\xab\x96\xcf\xf1\x35\x2c\x67\x24\xc5\xb9\x30\xbd\xd5\x29\x6b\x97\xc9\xbb\x8b\xb4\x5a\xc0\xa8\x8c\x50\xc8\x61\xb2\x99\xf8\x42\xc1\x5b\xe5\xad\xce\x29\xa0\xbe\xea\xe5\x36\xbb\xad\x21\x96\xe1\xb4\x9b\xf4\x40\xdb\x40\x21\x4f\xbf\xfa\x48\x2f\xd9\xdd\x36\xc7\x9f\x25\x15\x9c\x9e\xbc\x6f\x48\xde\xe9\x28\xeb\x11\x69\x73\x4b\xc2\x87\x14\x63\x1d\x7e\x84\x5e\x40\x54\xf7\x2c\xef\x54\x68\x9f\x3e\x45\x2e\x5a\x4d\x57\x03\x25\xb4\x6d\x6f\x4f\x9a\xdb\xf7\x5b\x99\x40\x13\x75\xc9\x5b\x94\x09\xc9\x22\xd6\x84\x54\xb6\xba\x4e\xe1\xc6\x18\xb8\x23\xf1\x7f\xb6\xf7\x0e\x67\x6b\xd0\x08\x7a\xcb\x9d\x80\x07\x95\xa8\x13\x5a\x10\xed\xaa\x92\x2a\x32\xda\xf3\x21\x14\xb2\x19\x50\xa1\x14\x08\x06\x7d\xde\xec\x6c\x64\x93\x84\xfa\xce\xc5\xde\x7c\x6f\x43\xac\xda\x50\x91\xc1\x3b\x55\xf9\x66\xb3\x33\x50\x90\x6f\x76\x03\x29\x73\x3b\x9d\x1d\x69\x6d\x40\x01\xd0\x43\x30\xb7\x76\x00\x79\x59\xae\xe1\x4c\xa9\x55\x9a\x81\xb5\x25\xe4\x3b\x75\xa3\xf0\xa7\xb1\x73\xbe\xb6\x06\x70\x15\xd3\xd9\x02\x62\x5a\x48\x1d\xb7\xfa\x4f\x02\xea\x2e\xcc\xfb\x72\xef\xcd\x2b\xb4\x33\xe5\x2a\x83\xa7\xfd\xa7\xa7\x88\x43\x8a\xa7\x54\x18\xb9\xb7\x5b\x82\xec\xf0\xd3\x57\x44\xd8\x6d\xd8\x30\x77\x46\x69\x88\xeb\xcb\x4a\xa3\x7f\x56\x76\x4d\xc4\xdf\x6d\x50\x2a\xe0\x0e\xb3\xbc\xc6\xfb\x01\x6f\x3a\x50\x4f\x19\x54\xe4\x95\x1c\x39\xda\x1c\x49\x52\x65\x6b\xb5\x26\x9d\xce\xa0\x0a\x15\x89\x75\x1d\xcb\xab\x1b\x63\xe5\x1e\xaf\xce\xef\xe7\x1a\x63\x7e\xb3\x0d\x4e\x92\x0d\xcb\x97\x11\xd9\xc0\x0c\x75\xb2\xff\x4e\x1b\x26\x78\xe5\x19\x82\x65\x6a\xed\x6c\xec\x95\x63\xcc\x15\x27\x74\xb6\x5e\x20\xbb\xb4\x76\x4b\x6a\xb9\xdc\xaa\x89\xd8\x6a\xc4\xad\xdb\xc7\xdc\x4b\xbd\x92\xf6\x11\xb2\x8f\x7c\x45\xa3\x38\x9c\x39\xcf\x3e\x9a\x8a\xe2\x30\x73\x2a\x9b\xc8\x0f\x7a\x78\x1a\x75\x55\xda\x96\x73\xe4\xee\xb2\x99\xde\x42\x56\x40\x7e\x39\x75\x56\xba\x77\x61\xfc\x7e\x1a\xe4\xc1\x37\x1f\x9f\x71\xd7\x0a\x39\xcc\xe3\x6a\xcd\x36\xf7\x8c\xe1\x72\xc6\xc5\xdf\xee\xb9\x4d\xa7\x79\xcd\x54\x37\x88\xbb\xaf\x59\xf1\x0f\x07\x9c\xd2\xb0\xf8\x8f\xbe\xd1\x62\xa7\x43\x93\xef\x31\xf1\xc5\x20\x10\x9b\xf2\x1d\x42\xb0\xc4\xc9\x17\x79\x34\xa2\xdf\xea\x57\x35\xc4\xfc\x4e\x99\xc2\xa4\xfc\x35\xff\x38\x41\x53\xd2\x4d\x93\x26\x69\xfa\x6f\x49\x99\x40\x65\x2e\x54\xf9\xa8\xc3\xe6\xfb\x55\x27\xbf\x59\xf0\xc9\x1f\xe6\x62\xfa\xe5\x29\x72\x64\x76\xa6\x78\xea\xd2\xa3\x55\xa3\x6a\x97\xff\x49\x1a\xa6\xfe\xfd\x96\xcb\x77\x26\x09\x84\xc4\x19\x30\x17\x35\x48\x75\xd4\xc7\x1a\xf4\x06\x81\xb2\x16\x84\xf4\xa2\x86\xd7\xc8\xce\xa6\x5a\x89\x11\x83\x94\x50\xd3\xda\xf0\x49\x71\xbd\xb2\xc2\x87\x15\x59\x05\xc4\x13\x4c\x41\x1c\xc8\xaf\x2c\x8c\x17\x72\x2b\x8a\x2e\xff\xeb\x16\xee\x6f\xd4\x87\x94\xca\x1c\xfc\x8d\x94\x54\xcb\xf4\x29\x00\x72\xe4\x59\x96\x5f\xb4\x04\x5d\x1f\x0d\xbb\x9c\x45\xfe\x02\x4f\x6e\x4e\x7e\xbe\xa7\x88\xcf\x2b\x2e\x29\x71\x60\x64\x33\x9b\x44\x8d\x5a\xef\xcd\xcb\xd3\x69\xb5\x7a\xd1\x26\x04\xed\x0e\x47\x69\x9e\x26\x4f\xa3\xcd\x75\x68\x71\xaa\x94\x63\xba\x65\x3c\xcd\x3c\xde\xda\x5c\xce\x3c\x83\x03\xd5\x11\xd0\x1a\x7d\x7c\xd8\x56\x4f\xeb\x57\xb8\x1c\xb6\x70\xab\xa7\x11\xe5\x21\x7f\xdf\x2b\x45\x3c\x2e\x71\x9e\x78\xa5\xe4\x09\x5d\x81\xf9\xc9\xd7\x03\xdc\x99\x7d\x24\x98\xf6\x30\xfc\x14\x7b\xc6\x3b\xf1\xf2\x9c\x68\xcd\x84\x72\xb2\x98\x3b\x42\x34\xc3\x0b\xf0\x3c\xb2\x2a\x10\xc3\xbf\xfe\x5e\xd5\xea\x3f\x16\x27\x9f\xb3\xb9\xbb\x61\xee\x8f\xc2\xdc\xe9\x75\x42\xdf\xa8\x1f\x56\xdd\x28\x8a\x2a\x83\x96\xe3\x4c\x2a\x95\xc5\xc0\x6e\xd7\xb1\x68\x84\xbf\x92\xc6\xe0\x90\x40\x7b\x96\x30\x6a\x75\x2b\xd5\xda\x5b\x27\x69\x7c\xf7\xc1\x01\xf2\xb1\xb4\x02\xec\x53\x18\xf0\x7d\x15\x99\x5c\xf5\xfd\x48\x7e\x26\xf9\x94\xfd\xfa\xdd\x08\x7e\x26\xff\x39\xd6\x90\x5f\xf1\x97\x00\x21\xfb\x04\x9c\x06\x25\x53\x9c\x27\xf4\x40\x7e\x5a\x6b\x36\xc7\x9f\xeb\xcd\xcf\xcf\xcd\xcd\xb3\x6b\x33\x25\x93\xa4\xcd\x13\x0a\x03\xf9\x1e\x3f\xa8\x7c\xb9\x26\x96\xa4\xcb\xcc\x7b\x1a\x5b\x45\x9e\xd2\xeb\xc6\xfa\x36\x38\x2d\x7b\xef\x24\x6f\xc2\x5a\xee\x7b\xf3\x2c\x76\x39\x32\x49\x71\x7c\xad\xc7\xfc\x91\xde\x4f\xaf\x5a\xbd\xad\xb2\xb2\x6b\x8f\x1e\x93\x8a\x17\x4f\xc3\xe1\xcc\xec\xcc\x3b\x26\xdc\x9f\x3d\x1d\x67\x92\x8f\xc8\x97\x0d\x1e\xe7\xf3\x53\x27\x3e\x70\xe7\xa4\x3d\xbb\xfd\x91\x2a\xc7\x19\x0f\xf9\xbe\x7a\xfe\xfc\x99\xed\x1e\x7d\x6c\x2d\xd7\xf5\xf7\x6c\xbc\xf5\xe6\xa1\x48\x99\xc3\x19\x98\x43\x05\xba\x3a\xda\x2e\xa7\x22\xb7\x2c\x37\xcf\x57\xa6\x4c\xa1\x2c\x4f\x2c\xac\x2c\x0c\x95\xf8\x1b\x63\x25\x9e\x8a\xff\x6b\x26\x6d\xcd\x11\x96\xff\x69\x2e\x7c\xab\xd0\xe1\xff\x3e\xad\xb7\x34\x77\x75\x1f\x52\x3c\x63\xec\xc3\x7b\x8d\x25\x7f\x3e\xb7\x4b\xe7\xca\x7d\xdb\xe1\xd9\x96\xf5\xd5\x3d\xdf\x94\x6d\x2e\xf8\x22\x5f\x2f\x21\x94\x81\xc2\x51\x1d\xe7\x74\xba\x5c\x99\x66\x8d\xc6\x9d\x71\x0c\xfb\x0e\x72\x92\xc1\xf5\x34\x2e\x41\x56\x24\xe1\x22\xc5\x7d\x52\x11\xaa\x93\xb6\x41\xae\x85\x8c\x02\x7a\x24\x1d\x57\x7d\x36\xfc\x5c\x37\x23\x57\xb3\x70\xc0\x84\x49\xea\xeb\x8e\x37\x5a\x27\xf6\x98\x65\x6a\x7c\xee\x05\x09\x91\x7b\x3b\x0f\xe8\x36\x61\xb4\xb5\x2b\xb1\xe3\xdd\x03\x0b\x87\xcf\x1a\x42\xae\x16\x9c\x00\x47\x57\x80\xa3\x2b\xc0\x91\x87\x22\x51\x03\xb2\xdb\x1d\x1e\x87\xd7\xa8\x52\xe5\xe7\x64\x52\x48\x90\xa0\x73\x50\x48\xcc\x48\x68\x81\x24\xdc\xc6\x4e\xf9\xc7\x90\xa4\x05\xc6\xcc\xbc\x02\xa2\x07\xad\x6b\x66\xb5\x2f\x73\x17\x38\x47\xdb\x84\x31\x57\x00\xc6\x0f\x6b\x1a\xad\xdf\xa0\x19\x47\xe9\xda\x73\xe8\x04\xfe\x51\xa2\x16\x40\x33\x2a\x8f\xea\x8c\x3a\xa4\xe3\x24\xce\x2a\x59\xf4\xc7\x71\x21\x50\x3b\x01\x17\xd3\xf5\xc4\x3e\x06\x5d\x7d\x5a\x1c\x01\xd5\x34\xc3\x2a\x9c\xcc\x03\x14\x06\x6e\x83\x9d\x9e\x13\x1e\x72\x5d\xcf\x60\x46\x51\x79\x89\x6e\xfb\x89\x7b\x1d\x73\xc5\x1b\x6e\xbb\xed\xd2\x20\xc3\xad\x7c\x75\x27\xde\x7f\x79\xef\x84\xc9\xb0\x26\xbd\xf1\x45\x6e\xbd\xf0\x13\xb2\xa0\xd2\xa8\x4e\x27\x8a\x92\x64\xb1\x5a\x6c\x9c\xe9\x59\x58\x03\x1d\xd2\xc0\x7b\x25\x58\x93\xfa\x7a\xe5\x2a\x2f\xb5\x29\xac\x12\x01\xac\x01\x15\x00\xd8\xf4\xb9\x1b\x42\x59\x0f\x94\xf7\x38\x31\x4d\x72\x1d\xb1\x73\x95\x23\xbb\xf8\xbd\x42\x37\xed\x6f\x64\x1b\xd7\x27\x6b\xeb\x5d\xc3\x07\x6a\x64\x3e\x54\x88\x3f\xe6\xa6\x0a\x9f\xc3\xfb\x42\x51\x83\x45\xb2\x0a\x40\x23\xe1\xa5\x36\x9a\x72\x3c\x78\x40\x2f\x6a\x9f\x82\xd7\x89\xf0\x5a\xe6\xdd\x27\x2f\x3f\xb3\xfd\x50\x7a\x6d\x63\x6e\xca\x61\x50\x94\x7c\xb2\xde\x59\xd8\x33\xfd\xa5\xed\xc6\xc0\x4b\xb9\x75\xda\xdf\xf0\xe4\xf8\x51\x78\xe9\xb0\x41\x1a\x66\x6b\xfa\x01\x1d\xe7\xaa\xe0\x9d\x59\xa8\x36\x6a\x42\x3a\xbd\xde\xe4\x76\xdb\x25\x7b\x8e\x94\x6d\x75\x1d\xc3\xc5\x07\xb0\xa0\x7f\x1a\xde\xa8\x81\x05\x0e\xca\x77\x22\xf5\xa9\x20\x0d\xf9\x8e\x8c\x12\xa9\x94\x47\x1f\x85\xa0\xd5\x45\x59\x0d\x36\xf3\xe5\xd7\x77\x0f\x7a\x72\x43\x59\x7b\x2a\x7a\x9c\xd8\xc1\x7b\x8b\x8a\xf2\xb3\x7a\x46\x86\x5d\x2b\x72\x2b\x86\x0d\xd6\x3e\x00\x20\x4d\xb9\xfc\x7a\x6e\x56\xb6\x7a\xab\xbe\xff\x30\x7b\x3b\x99\x97\xf4\xc6\xdf\xf0\x7b\x00\x2e\x03\xbb\xb9\xb4\x21\x5e\xe2\x99\x47\x95\xd1\xa8\x75\xca\x2e\x55\x14\x2c\x23\xd2\xd2\x1d\x08\xcb\x2e\x55\x61\x5c\x1e\x52\xec\x60\x8a\x21\x2c\xac\x84\xf1\x79\x6d\xe1\x16\x67\x2a\xfc\xc9\xbf\xce\x90\x2f\xda\x77\x7b\xf8\x69\xf2\xd0\xa6\x13\xb5\xd1\x65\x57\x0f\xa8\xa9\x5d\xcf\x1f\xc4\x21\x72\xc8\x3a\xba\xf3\xa2\x25\xdc\xef\xe4\x4d\x72\xb0\x53\x5d\x61\x58\xde\x97\x0d\xf8\x1b\xe1\x1d\x80\xc5\x09\x94\xdd\x05\x3c\xcc\x62\x06\x1e\x66\x80\xcd\x31\x00\x03\xa3\x71\x64\x19\xa2\x99\x42\xe3\x00\x68\x0a\x0f\xd9\x0c\x06\xac\x39\xc6\xc0\xa2\xe6\xc3\x56\xf7\xbc\x6d\x58\x57\x27\xac\x30\x29\x47\x67\xc6\xbb\xe8\xea\x2d\x79\x3d\x5b\x70\x96\xbc\xf9\x7a\xf9\x7e\x8d\xa6\xe3\x53\xa7\xb3\x84\xaa\x23\x87\xf1\x37\xf8\x9d\xd0\xe0\x9c\xba\x89\xa4\x12\x60\x8b\xae\xcc\xda\x84\xef\x82\x8f\x95\xf8\x39\x25\x17\xe7\x71\xfe\x41\x06\x5f\x65\xd4\x62\xd3\x98\x74\x5a\x4e\x6b\xe2\x5d\x16\xab\x35\xc3\x64\xd1\x52\xc8\x44\x68\x56\xcc\xae\xb9\x5b\xdd\xab\xd2\xf0\xd9\x96\x1c\x36\x61\x1b\x2c\x16\x80\x80\x8d\xdc\x7d\x9d\xdb\xbb\x0b\xed\x05\xed\xdb\xb7\xdb\xfc\x72\xa5\x64\x99\xfc\xc4\x29\xd2\xad\x5f\x6c\xec\x71\xc3\x1a\xc9\xd3\xf9\x2a\xee\x22\xb9\xcf\xff\xac\xe6\x6b\x3c\xfa\xf2\xc7\xf3\x46\xb4\x63\x31\xda\x2f\xf3\xcb\xb8\x5c\x56\x23\x59\x9b\xfc\xce\xaf\x65\x75\x61\xb4\xac\xc6\x96\x96\xd5\xd8\x52\x1d\x9a\xae\x59\xa2\x61\xa5\x6a\xa0\xcd\xb3\x7c\x3d\x37\x88\xf6\x51\x9d\x6f\xf3\xfd\x02\xfb\x4e\xe0\xfb\xd5\xec\xfb\x17\xec\x6c\x8f\x15\xe6\x72\xbd\x81\x6d\xea\x51\x4e\x54\xcf\x6b\x44\xbd\x46\x6f\x34\x88\x12\x7c\x2f\x0f\xbf\x19\x4a\xab\x2f\xcd\x94\x57\x5f\xb5\xac\xe3\xe2\xb1\xd5\x95\xe3\x27\x35\x2f\x9c\x2c\x7c\x53\x56\xd0\x30\x67\x62\xd3\x88\x09\x6d\xc7\x52\xe9\x35\xbc\x9e\x37\x1a\x54\x92\x1e\xa1\xf2\x50\xeb\xb1\xe4\x6b\x3d\x87\x1c\x70\xd4\x7b\xf2\xc2\x45\x13\xc7\x57\x56\x0b\x73\x27\x8c\x18\x31\x61\x4e\x43\x41\x19\xac\xff\x1a\xa0\x9d\x79\xe2\x43\xb0\xfe\x65\x51\xab\x13\x0e\x11\xd2\xbb\x24\x58\x7c\x87\x8e\xe7\x35\x26\xc4\x70\xe1\x64\xa8\x36\x79\xed\x99\xa2\x98\x1e\x9c\xba\x5b\x4a\x65\x0c\x00\xe1\xf8\x42\x43\x71\x38\x36\xbb\x5b\xe7\x9b\xca\xf7\x97\x3c\xb1\x6a\xeb\xce\x63\xb7\x57\xe0\x8b\x78\x87\x61\xfb\xc2\xba\x1e\x2b\xda\xcd\x5c\xbe\xe3\xb6\xdd\x67\x9d\x71\x78\xef\x4e\x78\xef\x48\x78\xaf\x8b\xbe\xd7\xc5\xee\xdc\x32\x00\x2b\x33\xb1\x8e\x16\xec\xfb\xf3\xf7\xca\x96\xb7\x16\x81\x54\xb9\xa0\xe4\x71\x79\x78\xd8\xd4\x4f\x8f\x2f\xbb\x43\xf7\xbc\xd8\xa9\xba\x69\x5c\xa7\xba\x50\xc5\x60\x7c\x31\x6e\xda\x32\xf9\xc5\x1f\x9b\xe7\xb7\xeb\x55\xbf\x6a\x7e\x8f\x81\x06\x32\x01\xf6\xa6\x19\x2d\x12\x16\x0b\xa7\x61\xbf\x73\xd9\x5e\xb5\x7c\xf7\x32\x9c\x2c\x40\x6f\x0a\xb3\x84\x77\x90\x84\x32\xa2\x5a\xc4\x09\xbc\x4a\xcd\x49\x02\x86\x9d\x3a\x1d\x62\x72\x05\x75\x04\xd6\x60\x90\x32\x85\x59\xe7\xc9\x33\xe4\xe9\x0b\x78\x25\xee\xfa\x26\x1f\xbd\xfc\x9c\xc0\x43\xff\x55\xd0\xff\x7d\xd6\x3f\x2f\x6a\xe0\x39\x81\x53\x01\x25\x54\x8b\x7c\x72\x88\x34\x6f\x0d\xbf\x17\x87\x35\x38\xcc\x0f\x02\x4d\x7a\xfe\x05\xdc\x03\x77\x3f\xff\xa6\xc0\x5f\x7e\x8e\x8f\xc2\x38\xfd\x85\x5d\x7c\x48\xfc\x0d\x08\x18\xad\x4a\x0e\x72\xaf\x16\xe9\xf8\x51\x1a\xac\x91\xd8\x40\x4d\xf4\x3c\x58\x65\x0a\x8a\x55\xbe\x42\xea\x45\x05\x43\x85\xc4\x6d\x0f\x0a\xff\x79\x58\xc4\xd1\xcf\x85\xa7\xb3\x9e\x7b\x2e\x0b\x77\x86\xb1\x6e\x87\xb1\x16\x24\xc7\x12\x35\x9c\x86\xd3\xea\x44\xd5\x28\x01\x53\xa0\x4e\x37\x85\x58\x68\x43\x58\x1e\xcb\xc7\x47\xc2\x2e\xaa\x02\x72\x9d\x3e\x7f\x49\xda\xb6\x4f\xf8\xf1\x61\x49\xd8\x85\x3b\x65\x3f\xff\x7c\x36\xc5\xe5\xa5\xc2\xf5\x9c\x83\xd5\x4b\xb7\x1d\x81\xaf\xa2\xc0\xd3\x31\x92\xc5\xd5\xb1\xcf\x12\xe6\x1c\x5b\xb6\x08\xd7\xe3\x09\x32\x0d\x7a\x48\x38\xc8\x3b\xc5\xe1\xd0\xde\x11\xd5\x60\x81\x17\x31\xb7\x29\x06\x5d\x82\x0c\x7e\xd9\x4b\x81\xfb\x67\xfc\x88\x97\x1b\x28\x1c\xfc\x8b\x7c\xbe\x12\x00\xaf\x45\xfc\x04\xf6\x64\x0e\xfd\x0e\x4b\xbd\x8b\xfb\x9e\x7d\xef\xc6\xc6\x7c\x9a\x0c\xc5\x0d\x89\xe3\x2d\x30\x60\xbe\x0d\x0c\xb8\x61\xcb\x16\x68\x24\xc3\x90\xb8\x85\x3c\xc9\x69\x12\xa3\x59\x7b\x2c\xf2\x3c\x83\x59\x61\x7d\x95\x15\xd4\x6a\x3b\x9c\x1b\xe7\x8d\xdf\xbd\xeb\x2f\x32\xcc\x99\x64\x2a\xbe\x3b\xb1\x02\xa8\x4f\x46\x54\x27\x60\x15\xb0\x6f\x33\x90\x76\xfa\x92\x26\x76\xc2\xe0\x25\x85\x11\xaf\x4b\x85\xb9\xaf\xe1\xdf\x02\x91\x4c\xfd\x39\x90\xf0\xb0\x77\x6d\x86\xbe\x73\x92\x7d\x79\x15\x6a\xd5\x17\xde\x08\x7d\x79\x10\xd1\x54\xe2\x8d\xe2\x27\x20\x05\x91\xa3\x64\xaa\x07\x25\x02\x3f\x33\x1b\x01\xfc\x88\x09\x1d\x58\x2d\xfa\x5c\xc0\x1e\xa4\x82\x93\xa1\x51\x4b\x9c\x48\x2f\x02\xcb\xd3\x42\x50\xe8\x55\xaf\x8f\xb7\x01\x7b\xe0\x62\x77\xcd\xf1\x8f\x25\xaf\xdf\x35\x47\xe8\x40\xde\xc5\xa5\x97\x5e\xa6\x65\x39\x40\x9e\xe0\x8d\xca\x58\x96\xc3\x3c\xe8\x56\x02\x10\x88\xd4\x0a\x41\x5f\xd6\x4f\xee\xc2\xe6\xfc\x26\x1a\x8b\x0f\xe2\xef\xfe\x6f\x1a\x15\x49\xa7\x51\x6f\x2a\x24\xea\xbd\x14\x85\xa2\x63\x3d\x0e\x63\x6d\x49\x8e\xa5\x57\x69\x78\xd5\x9f\xd0\x28\x7f\x3a\x8d\xc2\x5b\x14\x1a\x35\x36\x45\xa2\x60\xac\x1b\xd0\x3e\xfc\x11\xa7\x85\x15\xc9\x8f\x1a\x25\x1e\x76\x0e\x23\xb5\x46\x94\x38\x8e\xed\x61\xf8\x94\x3c\x9c\x55\x39\x51\xd5\xe1\xea\xb0\x23\x8c\x3f\x22\xb7\xcf\x6f\x9e\xb7\xaf\xf9\xdc\x39\x3a\xc6\xcd\x30\xc6\x37\x6c\x8c\x9c\xa8\x81\xe3\x45\x80\x47\xa3\xc6\xa0\xe6\xc0\xae\x9c\x0a\xa5\xc2\x4d\x28\xea\x38\x7c\xd5\xbe\x6a\x2f\xfe\x66\x5e\xf3\x7c\x3c\x0d\x6f\x38\x77\x8e\xc6\x08\x2d\x83\xfe\x3f\x40\x7f\x1d\xca\x8a\xea\x41\x33\x52\xf1\x3a\x60\xeb\x7a\x83\x84\xca\x5b\xac\x08\xa9\xde\x32\x04\x3f\xc0\x08\x00\x02\x76\x4e\x9c\xd8\x3c\x6f\x9e\x8c\x87\x9f\xa1\xdf\xb9\x4d\xf8\x43\xb6\x27\xb0\xa7\x70\xfa\x60\x41\x14\x67\x5e\xc0\x27\x55\x4e\x09\x77\x4b\xf0\x77\x19\xe6\x7b\xe0\x0c\x8c\x15\x3f\x03\x49\xa1\x32\xea\x02\xf1\xc6\x0c\x78\x6b\x32\xeb\x4c\x02\xd6\xf0\x02\x8a\x22\xf5\x26\xd9\xc3\xd2\x9d\x61\x3e\x3d\x72\x44\x53\x48\xde\xdb\x16\xd2\x1f\x09\xcb\xb7\x12\x61\x90\x1a\xff\xbe\xee\x31\x6e\xf7\xf0\x3e\x03\x6f\xca\xd8\x13\x7c\x41\xd8\x75\xcf\x92\x40\xdf\xeb\x86\x36\xec\xd9\x45\xf1\xa4\xaf\x10\xe7\xd6\xb1\xf3\xec\x8c\x6a\x80\xde\x89\xc0\x9b\x29\x5c\xf2\x88\xb5\x72\xea\x7b\xdc\x97\x46\x26\x0b\x71\x1a\x8e\x0c\x78\x7a\x5e\x98\xce\x7d\x2a\x4d\x85\xf5\x70\xa1\xe2\xa8\xd3\x2a\x49\x19\x99\xb0\xb9\x99\x1a\xd3\xe6\x18\xaf\xd9\x32\x9c\x77\xc0\x27\x00\x17\x0c\xb6\x48\x5c\xd4\xdb\x3a\xe5\x6a\xe2\x54\x55\xb5\x5c\x9c\x70\x9f\xde\x3e\x65\xca\xed\x5b\x27\x4d\xda\xba\xb8\x4f\x4d\xb8\x6f\xdf\x70\x75\x5f\xf1\x86\x49\x5b\xe9\x83\xad\x93\xc2\x7d\x7b\x57\xb7\xef\xdd\x57\x3e\x97\x93\xe1\x48\x7f\x0e\x7c\xd9\x82\xb2\x61\x1f\x78\x13\x6f\x03\x92\x60\xb8\x5d\x71\x35\x2d\x6f\xf1\xd6\x97\xef\x97\xc3\xc9\xb4\x0c\x2a\x09\x87\xae\xbd\x61\x78\x6c\x4f\xa7\xab\x4b\x7d\x95\xd5\xb6\x06\x32\x74\xd4\x55\x7d\x6e\x0d\x05\x96\x44\x02\x01\xd7\xe2\x7c\x3a\x76\x77\x58\xef\x55\xe2\x49\x98\x51\xc7\x68\x0e\xe8\xf6\x6a\x8d\x26\x33\xc3\xa1\xd7\x8b\x9b\x62\x26\x7d\xae\x9e\x03\x46\x0b\xab\x6e\xd9\x14\xd3\xd0\x4d\x4b\xad\xbb\x62\x6c\xab\xa5\x02\x2d\x7b\x73\x3b\x8e\xea\x0f\x3e\xca\x15\xe5\x54\xd7\x00\x05\x37\xbd\x74\x50\xbf\xee\x39\x25\x91\xcc\x55\x85\x6b\x27\x94\x5d\xd5\xb7\x6b\x76\xb0\x7d\xc6\xca\xc2\xb5\xc2\xae\x40\x79\x20\xdc\x7b\xe7\x4a\xf8\x68\xdf\x6d\x27\xf5\xcd\xef\x00\x70\x7c\x2a\x7e\x02\xf4\x43\x87\x0a\xa2\x66\x49\xa3\x81\xd3\x6b\xd0\xab\x39\xc4\xad\x1b\x2e\xb1\x77\xb7\x7e\xa5\x2d\x42\x6d\x1d\x5e\xf6\xb3\x83\x16\x03\x39\xd4\x92\x75\x98\x4f\xfe\x26\xec\xca\xc5\x79\x41\xf2\xad\xfc\x53\x5e\x47\x84\x27\x72\xd3\xf8\x5a\x20\x4c\x70\x3e\x4d\x58\x83\xad\x66\xb3\xc5\x84\x45\x1d\x9c\xa8\x53\xa1\xb4\x50\x62\x8b\xdf\x25\x63\x11\xcb\x0c\x53\x8e\x55\xb8\x1b\x2e\xab\x2f\xe9\x55\x92\xbf\x6a\xfe\xc2\xb9\x12\x37\x93\xbb\xdc\x69\x75\xff\x8e\x2e\xfb\xa1\xf6\x63\x46\xfb\x9c\x74\xec\x19\x7c\x98\x77\x88\xdf\x01\xf4\x81\xa8\x05\x6b\x05\x95\x00\x47\x15\x21\xb5\x5e\x2d\x49\x06\x20\xad\xe5\x2d\x28\x21\xdb\xfa\x6d\x11\x50\x70\x22\x2e\x95\x4b\x55\xa8\x9a\xf1\xcd\xd7\x93\xbe\xfa\x6a\xd2\xd7\xf0\xf3\x1b\x7e\xd7\xbf\x7e\x98\xf2\xfd\x0f\x53\x7f\xfc\x7e\xda\x3f\x7f\x96\x65\xeb\xdb\x40\x5e\xbc\x1d\xe4\x45\x33\x72\xa3\x4e\xd1\x4c\x3b\x67\xd0\x67\xa8\xd5\x7a\x9d\xd3\x88\x38\x95\xc7\x64\x36\x67\x39\x8d\x46\xd1\xc4\x04\x7f\x0b\x28\x1c\xc5\x8a\x84\x6d\x09\x5f\x91\x25\xc3\x99\x96\x24\x23\x4c\x0b\x11\x30\xdf\x52\x8a\x91\x5c\x7e\xfd\xba\x59\x63\xa7\xf6\xbc\x66\xdb\xeb\x23\xb1\xf6\xd5\xf8\x07\x25\x39\x39\xa3\x72\xb9\x87\x9f\x1d\x78\xfd\xc2\x51\x43\xea\x56\x4f\xe0\x7a\x91\x81\xf8\xc0\xe5\xa6\x0e\x95\xd1\xa1\xcd\x7d\xb2\xf3\xe4\x35\xed\x05\xa2\xce\xeb\x4c\xcf\xcb\x3e\x8a\x39\x9e\x1d\xef\xa7\x40\xab\x43\x4c\xd3\x52\x54\x1e\x26\x3b\x85\xf9\x5e\x27\x4f\xbc\x84\x2f\x0a\xce\x4b\x17\x15\xff\x05\x7c\x96\x57\x09\xff\x44\xf9\xa8\x3a\x6a\x55\x81\x06\xa3\x47\x92\x15\xf1\xbe\xcc\x8c\x8c\x82\x4c\x8f\xe3\x18\x2e\x3a\xa0\xd2\xf2\xc7\x98\x22\x13\xae\x0f\x5f\x39\x1b\xb9\x28\x0a\x8b\x5b\x68\x6d\xb6\x0b\x28\xa6\x7f\xcc\xbd\x7f\x70\xf7\xea\x9d\x59\x7b\x8d\x7d\x07\xdc\x11\xbe\x7e\xe9\xec\xbf\xdc\xb7\x7a\xbd\x79\xaf\x6b\xc6\xda\xba\x19\x0b\x26\x72\x7f\xbf\xb9\x79\xdc\x24\x77\xb8\x72\x94\x2f\x90\x91\x7d\xe3\x75\xd3\xe7\x8f\x9e\xec\x68\xba\xda\x5b\xec\xce\x9e\x4c\xf9\xb1\x13\xe4\xb5\x55\xc2\x05\xb3\x8a\xaf\xc4\x6b\x90\xcc\xa3\xb7\xc2\xb3\x6b\xc4\x87\xcc\x12\xb7\xfc\x57\x3a\x87\x6d\xb0\x41\xd4\x4f\x81\xf2\x3d\x0d\x46\x02\x92\x54\x18\x08\x55\x79\xb8\xe5\x58\x7a\x7d\x16\x6f\xb5\x97\x5b\x70\x90\xbc\x85\x2f\x88\x5e\x96\x4b\x27\xd5\x8f\xd1\x77\x11\x03\x72\x02\xc7\xe3\x05\x41\x85\x55\x88\x46\xf5\xa6\x79\xed\x24\x47\x00\x11\x83\x8d\x51\x79\x90\x7f\x7b\x2f\x1e\x84\xfe\x64\x1c\xfe\x7f\x1f\x87\x5b\xb1\x97\xbb\xeb\xff\xc1\x38\xb8\xcb\x5e\xfe\x5c\xeb\x71\xd8\x7a\x50\xc1\x50\x52\x71\x58\x84\x21\xc2\x69\x0e\x09\x72\x5f\x92\x05\x5d\xf7\x8a\xb2\xfc\x39\x06\xfa\xf5\xe1\xa7\xcb\xfd\x80\x43\x80\xf4\xa1\xc8\x8e\x69\xfd\xe0\xed\x5e\xae\x0f\xc9\x9c\x8d\x67\xf2\xd3\xe3\x5c\x7a\x3f\x15\x95\x3b\xe1\xc8\xf1\x3c\xb0\x49\x2c\x49\x22\x95\x3c\x5a\x43\x8d\xbd\x16\x9f\x32\xc2\x86\xd9\x30\x04\x5e\x4c\x96\xf2\xd3\xc9\x52\xb6\xaf\x77\x90\x61\xfc\xa2\xc4\x6a\xab\x8a\xaa\xd9\xff\x19\xc1\xce\x9d\x4f\x78\x84\x5b\x29\x65\x31\xb9\x04\x28\x06\x60\xb6\x28\x80\x26\x89\x79\x49\x94\x29\x46\xfa\xd8\x30\x27\xba\xcb\x2b\xe3\x77\x73\xe3\xe8\x3f\xf1\xb6\x35\x84\xba\x16\xc1\x38\xcb\xf9\x7a\x7e\x91\xb8\x14\xe4\x50\x1a\x05\xe8\x14\xd4\x6a\x49\x63\xb6\xd9\x2c\x16\xa3\xc6\xe8\xb0\xab\x2c\x16\xab\xc6\x28\xb0\x11\x5b\xe7\x57\x49\x55\xe5\x06\xc2\x5a\x53\x0d\x6b\x2e\xa6\x7e\xe3\x17\x55\xd6\x1d\xbb\x75\x31\xce\x25\xc5\xa1\x8e\x47\x96\xc3\x2f\xc2\xf3\x73\x8e\x5c\xf3\x97\x6d\x58\x78\x6e\xd1\xc1\xc1\xf4\x53\xde\x8f\x08\xb9\x0b\x9f\x49\x3c\x03\xf2\x98\x1b\xe4\x1b\x35\xb0\x7e\x26\x97\x09\x1c\x93\xa6\xd9\x14\x80\x16\xf1\x61\x57\x24\xcc\x7f\xf5\xc4\xe2\x86\x86\xc5\x4f\x40\x0f\xef\xce\x9d\xe4\x53\xd6\x3f\x0b\xbe\x1d\x4b\xeb\x2f\x22\xce\xcc\xc1\x32\x53\x8a\x9c\xea\x2f\xda\x7c\xb4\x86\x07\x56\xc9\x03\x74\x27\x9f\xee\xdc\x89\xe5\x7d\x1d\x00\xbc\xeb\x86\xc4\xbf\x58\x7f\x2d\xcd\x81\xce\x21\x18\x04\x36\xf6\xcd\xb4\xd5\x73\xf9\x1d\x2a\x97\xc3\x3f\x40\x7e\xef\x71\x79\x14\x19\xfe\xa1\xd0\x7f\x5e\xb2\x3f\x0f\x22\xa1\x24\xaa\x55\x14\xa1\xd2\xfb\x1b\x70\x75\xa4\xb0\x5a\xc4\xf3\xe4\x17\xff\x27\x35\x00\xbb\x4b\xc7\xfb\x13\x7f\x67\x3c\x3b\x3f\x6a\xd2\xd3\x0a\x6d\x12\x70\xb8\x28\x8f\x79\x93\x86\x2e\x7a\x53\xfa\x3e\x8a\x7f\xc2\xac\xf1\xfe\x69\x83\x1b\xa7\x4f\x6f\x1c\x74\xc3\x98\x70\x49\x49\x65\x65\x49\x49\xf8\xeb\xc1\x37\x4c\x1d\x72\xd5\xd4\x69\x83\x4b\xaa\xaa\x4a\x82\x35\x35\x48\xc1\xe3\x17\xf1\xe7\xf8\xe3\x16\x19\xda\xc4\xe7\xf2\x6c\xb9\x52\x32\xb4\x5f\x96\xa1\xfb\xc9\x32\xf4\x8b\x8a\x08\xcd\x6c\x66\x2f\x72\x87\x58\x5f\xca\x03\x2d\xa2\x4a\x87\x75\x06\xac\x57\xcb\x43\x48\xc9\x25\xc7\x29\x83\x68\x84\x8d\x14\x66\x3f\xff\xf2\x95\x0a\xe3\x05\xe2\xc7\x69\xa3\xca\x23\x73\x89\xd5\x30\xee\xa7\xca\xb8\xf9\x51\xb3\x06\x49\xbc\x41\xfa\xe3\x61\xe9\xa8\xf5\x98\xca\xe9\x5e\x26\xad\xff\xae\x48\xeb\xf1\xdf\xc5\x8f\xd9\x2f\x2f\x32\xa9\x5d\x11\xdd\x41\xb6\x6b\x20\xeb\xb9\xae\x89\xad\x28\x13\x46\xb6\x38\x3d\x1a\xb7\x55\x43\x31\x2c\x8f\x2a\x3e\xa2\x01\xd6\xf7\xe4\xc7\x4d\x27\xc3\x8a\x06\xd0\x22\x26\x70\x2d\x62\x02\x87\x7b\x14\xf5\xed\xd6\xd9\x53\x50\x99\xb1\x30\xa7\xf3\x75\x3d\x8a\xfb\x75\xaf\x73\x97\x96\xdb\x16\x64\xd6\x8f\x24\xeb\x7d\xc5\xbe\xd2\x6e\x53\x47\x77\xcc\x2f\xc9\xef\x50\x35\x6e\x62\x1d\xdd\xd3\xc7\xf0\x0b\xdc\x36\x26\xbb\xa9\x28\x56\x20\x50\x54\x39\xa0\x9e\x1c\x9c\xa1\x53\xe9\x67\xd2\xe6\xe5\xd9\xbf\xfa\x08\xce\x8b\x90\x81\xf4\xa7\x70\x00\xbb\xc9\x17\x71\x33\xce\x24\x5f\x32\x1b\x45\xbd\xb0\x84\xbb\x9b\xd1\x2b\x90\x71\x05\x91\x13\x81\xee\x98\xa8\x0c\x01\x63\xa5\x30\x83\x9e\x6f\x07\x48\xb9\xb8\x1e\x37\x7d\x3d\x4b\x3c\x35\xe3\x23\xd6\xd7\x0b\x7d\x6f\x4e\xf6\xa5\x14\x93\xf6\x15\xb1\x28\x6b\x97\x2d\x7d\x99\x6c\xcd\xdd\x3c\xeb\x6b\xdc\x24\x2c\xf9\x68\x06\xc3\x93\x18\x99\x84\x8f\x24\x0e\x27\xfb\xc2\x54\x24\x0e\x5d\xd9\xd7\x05\x32\xb5\xc3\x1b\x9b\xf5\x35\xd9\xdd\x0f\x7a\xe2\xc4\xbf\xa1\xdf\x60\xd6\x0f\x64\x7a\x01\x64\x79\x8e\x83\x8e\x2d\x00\xb7\x84\x84\x32\x9d\x00\x0f\x26\xbb\xbf\x9e\x45\x26\x01\xc4\xb4\x4e\xef\x50\xee\xfe\xc4\xbb\x32\x35\x93\x54\xa0\xa0\x70\x9c\x5a\xc0\x12\x9f\xae\xa2\x2b\x94\x12\xde\x5a\x1d\xe6\xee\x8f\x1b\xef\xc7\x8f\xed\x86\x33\xb4\xe8\x93\x4f\xd8\x7e\x3f\x08\x63\x6c\x87\x31\x18\x9d\x06\x4d\x82\xa3\x56\x02\x4a\x6b\x93\xfd\x93\xbd\xb9\xed\xd0\x97\x6b\x64\x5d\xa1\xdf\x31\xf8\xe5\x07\x74\x17\xd0\x40\xe0\x2f\x00\x34\x12\x75\x6a\x00\x5a\x14\xb4\x6a\x44\x65\xa3\xb0\x25\xcd\x00\x2c\x7a\x5d\x3e\xbe\xda\x16\x56\x79\xf1\x0f\xa4\xe9\xc1\xd9\x2f\xbd\x34\xfb\x41\xbc\xfb\xa9\x1f\xb0\xc7\x88\x3d\x3f\xb0\x78\xbd\x33\x92\x06\xad\x55\xf9\x00\x0e\xe3\x91\xb4\x23\x06\x5a\xa6\x9f\x9e\x06\x13\xf9\x4c\x8d\xb9\x7d\x92\xa4\xf9\x21\x78\x29\x17\xde\x7f\x9d\xa4\xc1\xf6\x3f\x6c\x4f\x4f\x8f\xb8\x53\xda\x87\x39\x35\xf9\x4c\xd2\xe4\x5e\x0a\xfe\x00\xe3\x1f\x06\xe5\xff\x4e\x66\x3b\xd0\x1f\x14\x34\x12\x23\x97\xa1\x74\x9b\x03\xfc\xef\xae\x07\x85\x5f\xef\x15\x71\xf4\x42\x8b\xcd\xe1\x72\x54\xf2\x25\x3a\xab\x82\x70\x1e\x32\xa3\x06\x87\x68\x32\xe4\x1a\xca\x0d\xbc\x81\x9e\x8a\xf2\x93\xe1\x8f\x9b\x42\x27\xff\xec\x18\x90\x48\x51\xef\xae\x75\x9e\x82\xb0\xa7\x39\xb7\xdb\x98\xee\xc5\x7d\xbb\x76\x74\x97\x56\x3a\x16\xe4\x75\x1d\x25\xf9\xd8\x31\x18\x3f\x41\x3e\x06\x93\xc7\x76\x64\x7b\x31\x49\x2c\xc0\xdf\xb1\x73\xa0\x7e\x82\x6a\xda\x34\x36\x12\x94\xfa\x39\xdc\x58\x6f\xfc\x1e\xf1\xd4\x5f\xe8\x3a\x2d\x90\xa2\xbc\x4d\xda\xc0\xda\x30\xbd\x0b\x5e\x5f\xed\x75\x90\x05\xc2\x0e\x29\x3a\x70\x20\x1b\x87\x87\xb9\xbe\xc6\x74\x2e\xf3\x11\x1d\x45\x60\x35\x6d\x08\xd8\x24\x7b\x4e\xa6\xa9\x54\x75\x7f\xaa\x51\x51\x9c\xe6\x84\x7f\xe1\xee\xe2\x0b\xe9\xef\xa2\x8e\x96\x1c\x53\xa2\xfe\xc5\x72\xf3\x27\x3a\x09\x8f\xe3\x9f\xc4\x35\xec\xec\x1a\x0f\x51\x04\xa0\x0d\x15\x89\x9e\x65\x53\x52\x7d\x1f\xfc\x20\x18\x9f\x53\xf2\xf7\xa0\xf0\xf8\x47\xf0\x47\x8e\xcf\xec\x20\x9e\x49\xfc\x13\xd6\xd5\x8e\xb4\x07\x78\x8d\x85\x2a\xb0\x30\xdb\x64\xa0\x51\xd2\x14\xe7\xab\xc7\x35\xef\xf4\x8a\x86\xea\x34\x8e\x89\xa5\x73\x36\x4e\x9c\xa4\xdf\xe6\x0a\x4d\x94\xd6\xbb\x3d\xea\xf1\x82\xaa\x57\xb4\x73\x83\xba\x6e\x1e\x0f\x3c\x2c\xf1\x81\xb0\x18\x0f\x13\x09\xe3\x0b\xfa\x83\x26\x8d\x83\x67\x0c\xf8\xcf\xd5\x35\x3c\xec\x0a\x0e\x20\xd6\xb7\x65\x01\x5c\x42\x10\x76\x71\x0f\x2b\x7a\x8c\xf9\x08\xd0\x58\x9c\xa2\xb0\xd4\x02\xd2\xa2\xb3\x5c\xfe\x1f\x74\x96\x44\x22\xd1\x17\xc6\xab\x14\x7f\x33\xab\xb8\xd5\xe4\x28\x92\xd7\xb9\xaf\x70\x3d\xfa\x44\xd9\x77\x66\x86\xa2\xe5\x02\x2d\xe1\x4f\x5a\xec\x4f\x5c\xe2\x61\xf8\xb5\x56\xa1\x91\xfa\x83\x12\x2f\x62\x05\x83\x69\x4b\x6a\x2a\xaa\xdd\xb4\x09\xa3\x4d\x9b\x68\x0f\xb2\x83\xf6\xe2\x12\x75\xf0\xae\x5d\x7f\x06\xbb\x06\x14\x62\x1b\x1c\x48\xfa\x93\x13\xc8\x69\x10\x76\x5f\x52\xc7\xdf\x57\x7e\x01\x0c\xb2\x07\xc9\xb9\x5c\xf9\x27\x8c\x55\x0b\x4f\x12\xd2\x01\xc0\x29\x2b\xf2\x44\x8d\x26\x93\x65\xa3\x85\xb3\x50\x3d\x5e\x50\x2b\x63\xfe\x11\x82\x51\xad\x7b\xe6\xc6\x47\xb8\xdd\xb1\x7e\x83\xa7\xbb\xf6\x94\xbc\x40\x7e\x67\xd8\xb3\x6b\xfb\xc2\x40\x9f\xab\x1a\xfb\xdf\xb7\x1d\x77\x07\x44\xc2\x89\x4c\x18\xff\x53\xf1\x7d\x86\xb3\x6a\x13\x2c\x8a\x5e\x94\x99\xb9\x9c\x20\x5d\xe5\x93\xdd\x37\x40\x21\x7d\x30\x7d\x38\xf1\xfd\xd4\x40\xf2\xfa\x3e\xc8\xd7\xe3\x0e\xe2\x52\xb3\x4a\x75\x9e\x7c\x2d\xcb\xf8\x89\x87\xe0\x59\x47\xf6\xec\x02\xb9\xa8\x3c\x3b\x01\xcf\x9c\xec\xd9\x17\xe4\x79\xe5\xd9\xb7\xf0\x6c\x89\xdc\x2e\x51\x2e\xef\x4d\x82\x23\x53\xd1\x2d\xcc\x0e\x66\x3c\x92\x66\x02\x53\xe8\x8c\xca\x29\x73\xe9\xa4\xe1\x0c\x93\x7b\xff\xac\x3d\x66\xfc\x97\xdc\x0b\x0c\x18\xab\xc8\xb1\x94\xb9\x0c\xfa\x5c\x24\x43\x51\xcf\xc4\x49\xd8\x59\x69\x3f\xcc\x1a\xb8\x84\x45\x36\xc0\xf4\x6c\x3e\x77\xae\x8e\x99\x80\x18\x2c\x12\xb4\x1b\xa3\xb4\xc3\xb4\x9d\x0a\x98\x09\xb0\x31\xcb\xcd\xe7\xce\x35\xd7\x31\x53\x0f\x6b\x57\x29\x3c\xc5\xf9\xa4\xdb\x00\x06\x38\x5b\x8c\x03\x85\x98\x39\x91\xca\xb3\xbe\xdd\xf1\x27\xb8\x9f\x84\xa7\x70\xed\x2e\xd6\x76\x3a\x9f\x8d\x67\x83\x2c\xab\x05\xac\xc2\x20\x0f\x2a\xa7\xc6\xe6\x03\x68\x8d\x98\x9e\xc5\xfb\x17\x87\x71\x6e\x89\xef\xab\xb7\x3d\xcd\xeb\x85\x45\x58\x78\x77\xff\x1b\x8e\x75\xe6\xa9\xd0\x17\x93\x81\x89\x2f\x12\xef\x23\x3d\xf4\xd5\x03\xc3\x63\x26\x36\x16\xcf\xdd\x62\x0d\x73\x2b\xc6\x30\x32\xb0\xc5\x1a\x46\xe7\xfc\x11\xcc\xa5\x77\xe2\x20\x9b\x0b\x47\xe7\x62\x53\x6c\x5e\xbd\xc9\xed\x0b\x9a\xe7\x92\xa1\xb2\xcd\x8b\xfc\x1d\xda\x75\x53\xda\xc9\x6b\xa3\xd8\xb6\xba\xcd\x6d\x5e\x80\xa7\xbd\x46\x2d\x5b\xb4\xdd\x79\x68\x37\x04\xda\xe9\xa0\x9d\xc4\xc6\x4b\xb3\x62\x0d\x59\xc8\xfe\x90\xd7\x66\xce\x9c\x31\x9f\xc5\x48\xc6\x4f\x90\xbf\xe3\x8e\x89\x8d\x32\xad\xe5\x18\xad\xa5\xb8\x1a\x3f\xe1\xe3\x63\x3e\xf2\xf7\x27\x9f\x84\x36\x67\x61\xcc\x8e\x68\x1c\x32\xc0\x3a\x6a\x29\x5d\xa3\xeb\x18\x49\x0b\x05\x07\xb4\x2a\xce\x7b\x74\x5f\xe5\x1c\x47\x71\xa4\x7c\x99\xab\x60\xdc\x5b\x7f\xd9\xa6\x17\xcf\xe8\x17\x1d\x63\x30\xfd\x06\xfd\x2f\x42\x7f\x23\xf4\x17\x28\xc3\xa0\x2b\x1b\x49\xc5\xe9\xe7\x51\xad\xbd\x43\x81\x92\xeb\x87\x5c\x16\x8b\xc7\x1d\x63\x11\xf6\x3f\x65\x46\xde\xa0\x7b\xd3\x93\xbc\x80\x56\x25\x36\x03\x8c\xfa\x43\x70\x9e\x31\x80\xd9\x44\x79\x02\xc0\xf9\x14\x3d\x45\xe4\x05\x46\x83\x49\x29\x99\x89\xfe\x91\x18\xa0\xd0\x60\x24\x80\xd8\x83\xca\x65\x5d\x83\x57\x68\xb0\x2f\x49\x83\xc9\xcc\x24\x0d\xe6\xd8\x1e\x5c\xab\xc8\xd2\xfa\x83\x0e\x45\x7e\x06\x18\x5d\x7f\x42\x33\xaf\xfd\x5f\x84\x66\x4c\x3e\x20\xb5\x48\x93\x38\x00\xbc\x56\x7b\x00\x0b\x14\x2d\x4e\x01\x24\xbe\x1a\x1a\xbd\x0b\xab\xb7\x73\xf5\x74\xd3\xd4\xa2\x7f\x67\x18\x3b\x93\xda\x71\x3d\xdf\xba\xb9\xe7\x4c\xe8\xb3\x19\x60\x19\x98\x78\x19\xf8\x81\xfe\xa0\x4e\x32\x33\x86\x05\x90\xa8\x94\x52\xa9\xc9\x94\xbf\xcc\x4b\xe0\xda\xc6\x61\x0f\x1d\x68\x57\xe3\xca\xaf\x1c\xdc\x73\xbc\xdf\xd8\xb1\xba\xc3\x90\xae\x37\x4c\x91\xe6\xa8\x0a\x03\x9d\xb8\x69\x22\x83\xe1\x30\x8c\x57\xc1\x6c\x6c\xda\x03\x06\x58\x17\x99\xbf\x5c\x61\x50\x5b\xfe\x7f\xd8\xd3\x40\x1e\x1e\x9a\x38\xcf\x6c\xf4\xc0\x03\x79\x46\x9b\x79\xa0\xb6\xd9\x69\x76\x79\x92\x05\xbf\x1a\x99\x1c\xa6\x3f\x28\x62\x5e\x95\x94\x2d\x00\x4b\xe1\x70\x7a\xb1\x71\x37\xb9\xea\x7e\xee\x27\x32\xf4\x93\x4f\xf0\x22\x68\xdf\x8d\xec\x82\xfd\x5a\x4c\x23\x21\x0e\x5b\x0d\x06\x91\x57\x1d\x4b\x3c\x77\x44\x63\xe8\xad\x32\x69\x19\xf7\x3c\x19\x0c\xc9\x2c\x54\xae\x6a\xc4\x36\x23\x0c\x58\x23\xff\xf8\x07\x37\x76\xd8\xb5\x91\xc8\xf0\x6b\xc7\x4d\xbc\xee\xda\xb1\xd7\x5d\xbb\x74\xd2\xdc\x4e\x9d\x9a\xc7\xcd\x80\x3f\x32\x3c\xed\xc8\x54\x6c\x4b\xdc\x03\xeb\x9f\x19\x35\x4a\x08\x9b\x31\x07\x5a\xbf\x60\x16\xa8\x44\xdd\x14\x96\x59\x57\xea\x82\x24\xff\xc2\x29\xf1\xde\xc3\xc2\x57\xbb\x80\x8a\x61\x7b\xf6\xf6\xed\xf4\x7e\x24\xfe\x31\xd0\xb1\x17\xd8\x18\x8e\xa8\x56\xe2\x96\x08\x48\x63\xd6\x70\x1a\xda\xdf\xcd\xd8\x4e\x4a\x70\x7a\x41\xdc\xb5\x4f\xf8\x01\xe4\xa6\xf6\x17\xc8\xea\xec\x3b\xee\xc8\xc6\x76\x80\xa1\x8e\x4c\xc1\x28\xb1\x16\x70\xdf\x16\xd5\xa8\x65\x4a\xa8\x4b\x91\x74\x9e\x71\x09\x39\xbd\x38\xec\xc6\xba\xd5\x8f\xe3\xdd\xc2\xf0\x1e\xbd\xe7\xb8\xf7\xb4\x7b\x87\x4c\xb9\x6d\x66\x56\xb4\x77\xef\xe8\x9a\x6d\x6c\x3e\xf1\xcb\x64\x0a\x7a\x3e\x39\x96\x9e\x16\x90\xe2\xd2\x44\x1a\x15\x63\x0f\xb2\x23\x20\xb0\x87\x79\xab\xf7\x73\x2d\x63\xcd\x6e\x19\x0a\x13\x3b\x59\x84\x2b\x12\xf7\x03\xb6\x67\x46\xf5\x16\x0d\x5a\x62\x17\x91\xde\xac\xe7\xf4\x74\x56\x27\xdd\x1f\x9f\x64\xa1\x25\x7f\x64\xf9\xcc\x28\xed\x51\x17\xc9\x29\xae\xf1\x30\xc3\x67\xcf\xba\xea\xec\xca\x6a\xc7\xca\xc2\xb5\x64\x51\xa0\x3c\x50\xd9\x97\x19\x3e\xbb\xd6\xee\x5c\x29\xaf\xff\x30\xf2\x14\xfa\x2c\x31\x26\xc5\xcf\x99\x04\xac\xf2\x92\x9b\xb9\x71\x85\xf1\x7b\x76\x52\x39\x2e\x5e\x9f\x90\xf0\xfb\x89\x21\xd4\x86\x0e\xf4\xe7\x58\xe2\xc7\x83\x1a\x7d\x6f\x38\xb6\x41\xda\x18\xf0\x26\x5e\x2f\xec\xf8\x9d\xc9\x73\x1c\x69\xbc\x1c\x47\x2f\x26\x3a\x29\xbc\x1f\x24\x2c\x2e\x29\xdb\x40\x43\x26\xfd\x35\x72\x37\xc5\xd7\x73\x37\x91\x99\x6f\xbc\x41\xd6\xbe\xf6\x1a\xc0\x50\x84\xde\xc0\x53\xf1\x8f\x30\x57\x57\x54\x67\x17\x99\xed\x97\xce\xb9\x45\x6a\x8d\xfc\xe1\x4c\x87\x30\x13\x6f\x72\xa6\xd4\xc4\x2b\xcf\xf4\x8d\x2b\x26\x8a\xc9\x3d\x28\x81\x1b\xf0\x5f\xd9\x3c\x39\x79\x9e\xf4\x1a\x0c\x07\xe2\x73\x8b\xb9\xd5\x28\x71\x06\xe6\x79\x3f\x4a\x70\x95\x6d\xdb\x00\x1f\xaa\xbc\x34\x43\xd8\x48\x9b\xc0\x38\xda\xc4\x45\xfc\x0e\xff\x68\xfa\x19\xf3\x63\x17\x3c\xe7\x6b\x36\x5f\x3e\xb5\x8c\x2f\xd9\x7a\x99\xb5\xbb\x33\xf1\x1e\x3e\xc2\x64\x20\xcd\x01\x0e\x20\x28\xaf\x87\xb5\x02\xc9\x9d\xdc\xc9\xf5\x7b\x27\xfe\x54\xb1\xf8\xef\xdf\x75\xf4\xcc\x76\x24\x03\x51\x9e\xc2\x97\x40\x8e\x48\xf1\xa5\xf4\x1b\x9f\x97\x94\x1b\x1f\xf2\x42\xda\x95\x0f\xbc\xa3\x0c\xce\x72\xae\x72\x96\x53\xaa\x54\x8b\x06\x85\x73\x5b\x69\x50\x1c\x79\x07\xe8\x4c\x9f\xc4\x5b\xca\xde\xa8\xe4\x1e\x8c\x83\x7a\x2d\x5e\xbe\xda\xe7\xe8\x43\x56\xe1\x79\x63\x0e\x51\xb3\x07\xb9\x78\x88\xd6\x6b\x24\x7d\xc8\xfd\xe8\xeb\xc4\x32\x1a\x41\x47\x6d\x30\x20\xee\xe8\xf5\x16\x69\x89\xcd\x04\x5d\xdd\xa7\x42\x72\x05\x5f\x8a\x8b\xcc\x5b\xd1\x57\x95\xda\x25\x17\xb3\x86\x2e\xd0\x14\x7b\xaf\x1b\x7b\x6d\x7e\x89\x66\xba\xf1\xfa\xfe\xc3\x23\x91\x6b\x06\x4c\x34\x90\xf7\xf2\xdd\x33\x66\xb8\xf3\x1b\x87\x77\xea\x74\xad\x6c\x4b\x4c\xbc\x23\x2c\xc0\xb3\xa4\x1c\xa0\xef\x2a\xe0\x9d\x99\xe5\x54\xdd\x29\x54\x15\x2a\x86\x6a\x3c\xab\x69\xf6\xac\xa6\x79\xf3\x9a\x66\xcd\x6e\x9a\x23\xbc\xd7\x34\x7f\x7e\xd3\xec\xd9\x4d\x73\xe7\x36\xcd\xa6\x32\x69\x48\xb8\x01\xfd\x2e\xcd\x40\x19\x0c\xe3\x2c\xe6\xe4\xac\xaa\x3a\xe3\x88\x83\xd2\x4f\x96\xe4\x40\x55\x4d\x23\x63\xda\x71\xa1\x76\x03\x06\x04\x2a\x3c\x79\x9e\xd8\x8d\x81\x32\x77\xae\x5b\xfc\x38\xd4\x29\x4f\x8c\xa9\xdc\x79\xb6\xca\x48\x5d\x4e\x97\x7e\xea\xe1\x52\x46\xbe\xbd\xb2\x7d\x07\x8a\xcf\x33\xa4\x02\x5e\xab\xca\x51\xd6\x4c\x90\x70\x92\xda\x53\x5c\xf6\x53\x7c\x9e\x21\xec\xb8\x34\x01\x34\x9a\x82\x81\x03\x1f\xa5\x87\x00\x27\x6e\x07\x4d\xdf\xc9\x74\xf3\x36\xfa\x9e\x8d\xc9\x61\xcd\xb2\x99\x44\x38\xa0\xc8\x61\x89\x83\xd0\xfe\x8e\x3f\x6a\x2f\xdf\x5a\x0e\x50\xcc\x1f\xc2\x81\xa4\x18\x06\x7d\x6c\xc2\xa3\x9c\x24\x1e\xfa\xff\xa1\xeb\x61\x4d\x51\x9f\xee\x9d\xa8\xc9\xa3\x39\xa7\xf3\x88\xee\xc5\xfd\xba\xa5\x4c\x1e\xc2\xa3\xb2\xc9\x63\x4c\x87\x16\x93\x47\x2b\x39\xf5\x82\x2c\xa7\x22\x9e\xbc\x02\xf2\xfa\xad\xe2\x05\x80\x59\x03\x32\x07\x48\xd9\x2a\x9d\x4e\x2b\x99\xf8\x91\xfc\x8d\x3c\x2f\xc3\x9f\xac\x86\x48\x27\x81\xfd\x0a\x73\xd7\x48\x37\x63\xa4\x22\xdf\x62\x13\x70\xf9\xcb\xd3\x82\xa0\x69\xed\xf2\xe2\x02\x3f\x39\x67\x56\x98\x3d\x4e\x78\x00\x4f\xb3\x12\x4b\x69\xed\xb9\xa3\x70\xce\xcc\x6a\x0e\xd0\xae\x5c\x66\x05\xad\x03\xeb\xc3\xaa\x5a\xab\xcd\xe4\xcd\x2c\x8d\x74\xe8\x27\x66\xdf\x67\x4f\x20\x9b\x41\xba\x45\xd7\x31\x6a\x71\xad\x9c\xc4\xc6\xea\x20\x3c\xc2\x95\x4a\x85\x6c\xf7\x78\x55\x4a\x13\x49\xf2\x3b\xae\x54\xe6\x77\xc2\x23\x8c\xdf\x71\xf1\xb5\xcc\x66\x78\x33\xdb\x6f\xf3\x11\x71\x09\xe8\x0c\x32\x09\xa3\x6f\xa7\xc4\x8e\x11\xbc\xb5\xfc\xf9\xcb\xd9\xfc\xf9\x6f\x27\x4f\x7e\x76\x32\xab\x41\x04\x72\xc4\x50\x34\x92\xf1\x5e\x99\xb3\xa6\x4e\x23\xe5\xc0\x54\xef\xb9\x67\xcd\x9a\xcb\x6b\xd6\x50\x46\x2c\xab\x3c\x4c\x96\x9e\x84\x7a\x31\x7b\x8a\xf1\x30\xaf\xd8\x51\x4e\x53\xa9\xc9\xc6\xa4\xc6\x5e\xd4\x68\x43\x26\x51\xa3\x0d\x4e\x54\x09\x73\xb8\x22\x49\x83\xb2\xe9\x5a\x3b\x38\x93\x2e\x57\x57\xae\xe3\x75\x3a\xab\x94\x89\x58\xd6\xde\x26\x56\xcc\x4e\x4e\xbe\xc0\x36\x9c\x9e\x9b\xa4\x6a\x43\xeb\x1c\x17\x5e\x9d\xe7\xca\x2c\x70\xbb\x9a\xb3\xeb\x47\x76\x8f\xf4\x69\x1c\x32\x20\xc7\xe5\x0b\xb9\x17\x14\x2c\x6a\x0a\x0d\x6c\xba\x4a\xf4\x99\x6d\xbe\xda\x89\xd7\x77\x0c\x4e\xac\x1e\x6f\x0e\x76\xdb\x38\xbf\x74\x01\xb3\x2b\xf2\x80\xcf\xdf\xe0\x1f\x40\xff\xe5\xe1\xed\x5e\x14\x89\x9a\x9c\x7a\x21\x53\x63\x29\xb2\xd0\x14\xbd\x16\xca\x11\x9e\x3b\xe8\xc9\xe9\x4d\x3f\x0f\x9b\x6d\xbd\xb9\xdc\x1c\xba\x60\xc1\x60\x88\x3a\xab\xce\x48\x3a\x31\x51\x15\xdb\xf5\x87\x18\x29\xc2\xff\x6c\xcf\x5e\x9d\x2d\xe4\x75\xac\xa9\x70\xe6\x14\x5a\xc7\x65\x86\xfa\x46\xbc\x75\xd5\x15\x0e\x9f\xdf\x3c\xda\x11\xea\x4f\x2e\xc2\x7f\x4b\x9b\xef\xbc\xf3\xc7\x2c\x6f\x56\x41\xf5\xb0\x01\xe5\x59\x5e\x4f\xbb\x92\x21\x8d\x15\x47\xee\x64\x39\x1e\x41\x8f\xd8\xc5\x8d\x92\xce\xc2\x79\x08\xa3\xca\x68\x46\xa9\xbb\xbc\x30\xb7\x10\x4e\x43\x21\xfc\x75\x3b\x44\x03\x30\xe3\xde\x06\x9f\x1b\x0e\xc7\xd9\x60\xe8\x24\x73\xa3\x35\x9f\x04\xc0\xcc\x27\x5b\xdf\x21\xa6\xc3\xc5\xff\xf1\xf9\x19\xdb\xfa\xfc\xf4\x6d\x31\x19\x2e\x2b\x54\x8c\x89\x57\x9c\x2c\xf1\xdd\xb6\x27\x8b\xbc\x71\xe5\x59\x03\x9c\xd8\x44\xc6\xa0\x2d\x89\x53\x70\xaa\xa4\xfd\x2a\xa6\x43\xa8\x80\x30\x17\x46\x1c\xe1\xea\x2d\x1b\xbe\xda\xb0\xe1\xab\x8b\x87\x9a\x9b\x0f\x1d\x69\x6e\x86\xb6\x5f\x01\xce\x0d\x86\xb6\x12\x48\xd2\x22\x27\x6b\x6f\xb2\x24\x5d\xed\x8b\x80\xee\x71\x37\x6d\x48\x86\x7e\xb9\x61\x03\xb5\x37\x66\x5c\x7e\x1b\x16\x6a\x0f\xa3\x33\x1a\x96\x1f\x2d\x1b\xf9\x51\x19\xaa\x46\x9d\x50\x0f\xd4\x0f\x0d\x42\x31\x34\x1a\x4d\x42\x33\xd0\x7c\xb4\x14\xad\x46\x9b\xd1\x0e\x74\x0f\xba\x0f\x3d\x84\xf6\x44\xaf\x6e\x5e\xd2\xb8\x67\xdc\xba\x75\x13\x37\x5d\xb7\x65\xcb\xa8\xed\xd1\x5b\x6e\xe9\xbe\xaa\x74\x5e\xd1\xac\x59\xfa\xbb\xf3\xa6\x4e\x2d\x98\x6e\x1e\x32\xc4\x3e\x0c\xf7\xc9\x68\xdf\x3e\xab\xae\xa2\x6a\xc9\x9e\x4d\xdb\x57\xcd\xbb\x7b\xfa\xb0\x3e\x75\x55\x55\x75\x7d\x86\x4d\xbf\x7b\xde\xaa\xed\x9b\xf6\x2c\xd1\xf7\x1d\x78\xef\x83\x0f\xee\x1a\xb0\x9b\x57\xf5\xea\xa5\x16\xfa\x22\xa5\x86\xaa\xf2\x61\x75\xc1\xa6\xb4\xfc\x49\xfa\x37\x87\x5b\x1c\xbb\xff\xfc\x41\xd2\xd2\x29\x02\xbf\xa6\x16\x06\xbf\xdd\x97\x5f\x5d\x15\x0e\x15\x2a\x9f\x36\xe5\xd3\xa5\x7c\x62\xe5\x53\xd5\xe6\x3b\xf5\x27\x00\x29\x58\xb6\x5f\xfe\x1f\x6d\xdb\x7e\xf7\xb7\x79\x57\xf2\xdd\x7e\x6a\xf5\xf0\x52\xd8\x80\x2f\x87\xb9\x3d\xd3\xce\xe1\x01\xf1\x67\xc9\x01\x3c\x90\xeb\x36\x6d\x1a\xd9\x5c\xd5\xbe\x7d\xd5\xd6\xaa\xda\xda\xaa\xdf\x22\x35\xed\xab\x0b\xe8\x57\x02\x92\x7f\xa4\x66\x5f\xfb\xea\xea\xf6\xdc\x35\x91\x9a\x9a\xc8\xe5\x5b\xce\x4d\xc3\x03\x84\x95\xe4\xe0\xb9\x69\x97\x35\x35\xf0\x87\x5b\x43\x7f\x6e\xab\x6e\xdf\xbe\x3a\xfe\x70\x75\x7b\x50\x58\xe8\x77\xfc\x3a\xed\x48\x62\xb4\xcf\x6f\xb4\xfb\x36\xfa\x94\x6c\x9a\x36\x8d\x2f\xa0\x6f\x8c\x3f\x43\x0e\x4e\x3b\x27\x2c\x3f\x3b\x6d\xda\xb4\xcb\x37\xe1\x81\xb7\x43\xbb\x52\xf8\x47\xde\x81\x71\x3e\x87\x5f\xf0\x36\xf8\xe5\x5a\xf8\x25\x3e\x93\xbe\xfc\xd2\x59\xdc\xe7\xf7\xaa\x69\x67\xb9\xf7\x6a\xc2\x1d\xe2\x9d\xab\xab\x23\x77\x56\x55\xd5\x72\x79\x4a\xeb\x78\x22\x12\xa9\xfe\x02\x1a\x92\xbf\xb6\xaf\xaa\x2d\x81\xff\x86\x31\x2f\xdf\x34\x6d\x1a\xee\x73\x56\xb6\x17\x99\x84\x29\xb8\x42\xa2\x3e\x39\xea\x27\xd8\xd5\x0b\xec\x94\x28\xdf\x98\x54\xc8\x37\x26\x62\x56\xfa\x9d\x4b\x8e\x30\x17\xf3\xcc\xd7\x0e\x24\x94\xa4\xfb\x4a\x1b\xcf\x3a\xcc\x5f\xe9\x59\x47\x69\xc0\x5c\xe1\x6f\xf8\x3f\x40\x03\x78\x64\x03\xae\xa8\xd3\x58\x2c\xd8\x60\x62\x1e\x57\xb2\xfc\x4d\x6b\xc6\xcb\x2a\x29\x4f\x2f\x6a\x7d\x91\x94\x9d\x86\x2b\xc2\x19\x45\x91\xe5\x5b\xb1\xb0\x85\x8f\xf5\xe8\x39\xc1\x78\xbb\xe7\x39\xe1\x6f\x6f\xbd\xc5\xa9\x96\x4f\xaf\xc8\xad\xe9\xd2\xd0\x6b\xc9\x6e\x59\xe6\x7a\x9e\x0c\x46\xe3\x12\xbf\xa4\xc9\x29\xb6\x34\x39\x65\x5c\x9a\x98\x42\x1e\x6f\x25\xa6\x40\xdf\x97\x40\x3f\xfb\x82\xdd\x27\xa5\xd6\x42\x94\x6f\x9f\xc8\x4b\xad\xaf\x9f\xa8\xbd\x62\x28\xca\x57\xda\xb2\x2b\x27\xa0\x04\xf2\xba\xe5\xb7\xb9\x68\xe2\x40\x46\x1b\x8a\x45\xd6\x96\x72\x62\x9d\x4e\xa3\x35\x68\xe0\x2f\x16\x79\xd4\xae\xfc\x4d\x39\x62\x80\x1e\x11\x95\x3c\x40\x44\xbe\x31\xdb\x26\x8f\x73\xf1\x89\x9b\x1b\x07\x2e\x79\x42\x19\x6e\x4e\xea\xfa\x8c\xc6\x79\xc3\x5e\x18\x95\xbd\x48\xb9\x25\x51\x1b\x57\x9a\x6c\x5a\x7c\xa5\xc3\x24\xeb\xdb\x59\xd8\x8e\x7e\x12\xfb\xc3\x3a\xa9\x9f\xd0\xc8\xf6\x61\x5b\x9a\xa6\xfe\x53\x55\x20\x50\x45\xff\x09\x3f\xc9\x9f\x55\xb0\x3e\xe7\x60\xce\xc3\x13\x2f\x81\xee\x54\x1c\xb5\x1a\x24\x23\xd2\x63\x9d\x1e\xfe\x6a\x54\x22\xaf\xd1\x18\x65\xdf\xa3\x90\x35\x39\x21\x33\x65\xaf\x2a\xc5\x8d\x81\xed\x40\x61\x38\x32\xc3\x3b\x2f\x36\xac\x67\xef\xd8\xf0\x79\xde\x99\xea\x09\x27\x42\x23\xb3\xc7\x77\x98\x3f\xbf\xe3\xf5\xd9\x23\x43\xb7\x50\xb9\xa5\x0b\xbc\xe3\x8b\xc4\xdf\x01\x43\x72\x51\x10\x79\xa3\x46\x91\x37\xf9\xb2\x8b\x8b\x55\xbc\xcb\xe7\xb3\x18\x64\x5b\xc4\x69\xaa\xd1\x9a\x5f\x32\x9f\x56\xcc\x0b\x69\x09\x5b\xda\x9a\x19\xfc\x69\xbf\x7f\x31\x6d\xf0\x75\x91\xc8\x75\xd4\xec\xd0\x54\x53\xd3\x94\x66\x7a\x20\x1f\xa6\x19\x21\xba\x76\xa5\x66\x88\xae\x5d\x53\x86\x88\x60\xca\x20\x81\x13\x1f\x08\x4b\xf0\x5c\x69\x3c\xb3\x8e\x08\x2a\x7a\x31\x53\x7e\x8a\xa1\x2d\xe6\x7d\x11\xaf\x2d\xac\xc2\x73\x47\xce\xa8\x23\xbf\xc0\x0f\xf1\x61\xf2\xde\xb3\xb8\xf8\x59\x86\x5b\x43\xc9\x50\x61\x35\xe8\x02\x06\xd8\x2b\x2d\x27\x32\x33\x27\x95\x58\x68\xf5\xe9\xc2\x30\x65\x5e\x05\x11\x61\x35\xf9\x29\xfe\x08\x39\x4b\x6e\xab\x3b\x52\xb5\xe9\x8d\x07\x2e\xe2\xe8\x84\x52\xb2\xfc\xf8\x89\x61\xd7\x97\xdd\x34\x57\x96\x2b\xe7\x0b\x27\xc5\xbd\x52\x17\x36\x8e\x88\xb4\xa9\xbb\x87\xf4\x71\xc4\xbd\x57\x8e\x23\x75\x49\x1f\x08\x93\x17\x84\x23\xfc\x5f\xc4\x61\xe9\xf7\x03\x34\x0a\x9d\xfc\x43\x78\x25\xf7\x52\xad\x38\xec\x7e\x66\x2f\x7b\x86\x7f\x26\x31\xe2\x0a\xdd\xf3\xdf\xac\xcd\xfd\xf7\x53\x78\xb6\x0b\x27\x25\xb5\x24\x02\xb7\x02\xcc\x36\x21\x41\x07\x18\xa5\xb3\x2d\x51\xa3\x72\xf7\xa9\x16\xcc\xc6\xf9\xfe\x82\x94\xe6\x21\x0a\x8a\xd4\x23\x0c\x5f\x40\x3e\x27\x9f\x2f\x88\x4d\xca\x3b\xda\xee\xbb\xcd\x0b\xb0\x07\x7b\x16\x5c\x3b\x25\xe7\x68\xd9\xf7\xc2\x9b\xdd\xbb\xf7\x18\xb0\xe6\xb1\xee\xdd\x7b\xf5\x5b\xbd\x8f\xfa\xe7\xc0\x7b\x42\x30\x6f\x8a\xeb\xbc\x46\x95\x92\xf2\x03\x30\xae\xa0\xf2\xc1\xf4\x05\x97\xb8\x30\x42\x7e\xfc\xfe\x67\xf2\xd9\xa2\xa3\xd8\xc8\xf5\xc7\x45\x78\x56\x9d\x70\x72\xf6\xec\xa9\x37\xe3\x45\xcf\x3f\x23\xaf\xdf\x1b\x64\x8c\xd0\x87\xf1\x64\x69\x3f\x62\x76\x4f\x6f\x35\xb0\x70\x6f\x35\xff\xe3\x86\x0d\x97\xcd\xfb\x9b\x8f\x1c\x6a\x06\x99\x9a\x3c\x89\x3f\xc4\x9b\x84\x9f\xcc\x2a\x71\x2c\x99\x27\xdb\x74\xc9\x17\xf8\x2c\xbe\x4b\xf8\x19\x9e\x4d\x22\x6c\x3b\x80\xa6\xed\xc6\x17\x71\x80\xf9\xb8\xa8\x90\xf3\x38\xf3\xe8\x17\x70\x09\x4a\x85\x2f\xd4\xcb\x82\x15\xb6\x85\xf9\x7e\x59\x27\xb2\xc8\x8e\x8d\x27\x36\xd1\xf8\x84\xcb\xcd\xdc\xa5\xb8\x28\x8f\xfb\x14\xfe\x08\x1f\x62\xef\x9a\x49\xfa\x28\xef\xfa\x0a\xde\xf5\x95\xf0\x39\x3c\x9b\x47\x56\x28\xcf\xde\x83\x76\xbb\x84\x7f\xc1\xb3\x67\xc8\x78\xe5\xd9\xa7\xf8\x23\xce\x27\x21\x78\x36\x91\x2c\x57\x9e\x3d\x0d\x30\x3d\x4d\x9f\x71\x33\x49\xb3\xfc\x2c\xfe\x3d\xbe\xc8\xdd\xc4\xfa\x4e\x8f\x3f\xa4\xd8\xa8\xcb\xa1\xdd\x2c\xfa\x5e\x6e\x36\xbb\xf1\xa4\xcf\xee\xc1\x9f\xe0\xd1\xe2\x76\x68\x37\x37\x91\xaf\x3c\x73\xe0\x6f\x38\x13\x83\x65\x21\x99\x21\xdb\xb2\xc9\x3a\xe8\x4b\x84\x0b\xb0\xdb\x99\x87\xb0\x8a\x57\x8b\xd4\xc1\x08\x96\x21\xe5\xc2\x4f\x5d\x07\x74\xd8\x87\x99\xfb\x00\xb6\x1d\xbe\xf9\xd3\x53\x38\x76\xfc\x95\x39\xaf\xbd\x43\x8e\xbd\x0a\x9d\x8d\xe4\x27\xbc\x0e\xdf\xf0\xf3\xcf\x64\x83\xbc\xc0\x18\x97\x0a\x07\xb8\xb3\x8a\x7f\x88\x0e\x49\xbc\x2a\xfd\x7e\x5c\xb9\x25\x66\x1a\x17\x2e\x15\x1f\xa6\x2a\xd7\xb7\x49\x95\x0b\x27\xfe\x49\xa6\xe2\xe5\x49\x1f\x53\xa4\xe2\x25\xc4\x9b\xdb\xf4\x15\x4d\xd8\x5b\x8f\xf1\x72\x71\x2d\x21\xaa\x5f\x16\x78\x92\xba\x1a\x9a\x01\xf4\x79\x26\xd3\x67\xf2\xa3\x66\x13\x42\x3a\x51\x67\xb5\xb4\x52\x6c\xd2\x6f\x8e\xdb\x6a\x38\x38\xfb\xbf\xaa\x38\xad\xea\x51\x96\x47\x33\x32\x34\xff\x73\x2d\xca\xff\xa7\x75\x28\x95\xbc\xeb\x57\x0b\x03\xad\x01\xd4\x93\xfa\xf1\x73\x77\xa1\x4d\x97\xdf\x42\xc6\xa3\xf8\x39\x0f\xae\x87\xb3\x87\x2c\x4d\x4d\xd5\xd0\x4e\x81\xd7\x1a\xe0\xab\xe5\x76\x89\x7f\x5f\x3e\x88\x7c\x51\x17\xbe\xd1\x83\x1b\x58\xdb\x5c\x0f\x7e\xcb\x83\x17\xb7\xf4\x6b\xa2\x26\xc3\x6a\x86\x2f\xc8\x45\x5e\xe4\xba\x0a\x5a\xb3\x84\x72\xd8\xfc\x77\x80\xec\x9f\xc3\x74\x51\xdb\x11\xc4\x4b\x2a\x6e\x09\x30\x4c\xf7\x69\xc5\xe5\x41\xd6\x3f\x77\x80\xde\x89\x55\xe4\x9b\xa4\xb6\x49\xf5\x9a\x97\x85\x07\xb9\xd3\xd2\xd5\x8a\x3c\x1c\x8a\xba\x04\xac\x35\x80\xc8\xa0\x91\x24\xa3\x56\xd2\xa9\x24\xd5\xfa\x98\x04\x14\x98\x79\xf3\x30\x17\xc0\x36\xce\xf1\x34\x60\xb0\x45\xb5\x7d\x52\x5a\xf5\x9d\x8a\x24\xc8\x9d\xa5\xaf\x94\xe2\xfe\xa5\xaf\x96\x0a\x0f\x7a\xf1\x06\x3f\x99\x53\xfc\x09\xfc\x01\x3c\xff\x3b\x42\x62\x58\x5c\x66\x0e\xa0\x02\x98\xb7\xc4\xd7\x5e\xde\x89\x1c\x87\x38\x0b\xcf\x99\x8e\x91\x33\x87\x4c\x56\x41\xe5\x0f\x5a\xaa\x51\xbd\x32\xcf\xa3\x9c\x8d\xb3\xf2\xdd\xad\x12\x9a\xff\x3b\xfd\xbe\x03\x21\x95\x00\xfd\x0b\x51\x11\x5e\x28\x8f\x80\x76\xa2\x10\x10\x23\x1e\xeb\xcd\x7a\x7c\x2c\xae\x8d\x66\xe8\x4d\x88\xf3\xa3\x06\x84\x37\xa2\x1f\x50\x02\xe8\x06\x1a\x85\xb8\x7b\x11\x6e\x9a\xd1\x34\xa3\x3a\xd8\xc4\x86\x57\xc6\x1a\xc3\xc6\x0a\xe2\x79\xa9\xb1\xaa\x00\x3f\x6d\xb8\xd1\x86\xd9\x90\x48\x5f\xa1\xe7\x8e\x5d\xfe\x38\x6a\xd6\x9b\x04\x2d\x1d\x34\x81\xb8\x3c\xd4\x88\xb8\x19\x4d\xc9\xa1\x70\x53\x13\x52\x60\xe3\xbf\x63\xe3\x95\xe2\xcd\xa9\xf1\x3a\x00\xcd\xd6\x61\x50\x86\x41\x8b\x16\xf0\x31\xb2\x36\xea\x16\x54\x14\xbe\x5c\x84\xeb\xd1\x48\x74\x23\x7a\x1c\xa0\x14\x1b\x11\xde\xdf\x1a\x42\xdc\x04\x63\xd2\xbc\xf6\xbb\xc4\x6d\x30\x66\x08\xad\x92\xc7\xbc\x97\xce\x97\x83\x53\x9b\x6d\xce\xc6\xc7\x12\x03\xa2\x19\xd9\xd9\x3a\x9d\x1f\x23\xdd\x62\xdd\x5b\xba\x4f\x75\xbc\x59\x97\xa7\x3b\xa7\xfb\x51\x27\x34\xc1\x40\x69\xf3\x7d\x19\x21\xb5\x8e\xc1\x57\xc7\x79\xe4\xb1\xca\x76\xa2\x70\x54\x8b\x75\x3c\xd6\x20\x4d\x9e\x06\x66\x9a\x17\x75\x6a\xf4\xbc\xca\x8f\xf0\x8d\x78\x31\xde\x88\x4f\x00\xd8\x18\x9b\x31\x05\xcd\x92\x1c\x4c\xa6\x59\x40\xdc\xa5\x5e\x00\x5b\x80\x1f\x1e\x06\x1c\xe6\x6b\x13\xae\xc4\x4e\x34\xe6\x20\x2e\xe3\x61\x1f\x7a\x46\xfb\x07\xdb\xe5\xf0\x7e\x14\xcc\x0d\x96\x07\x39\xce\xc4\x3e\xeb\x83\x0d\xc1\x91\x41\x49\xfe\xb8\x31\xb8\x38\xb8\x31\xb8\x2b\xf8\x78\xf0\x44\xf0\xad\xe0\xa7\xc1\x1f\x82\x89\xa0\xc1\x14\x6c\xfb\x9f\xf4\xbf\x74\x4d\x33\x66\x8e\x9c\x01\x00\x28\x73\x01\xec\xe1\x83\xd2\xd5\x70\x7e\xa6\xb0\x99\x74\x18\x81\x50\x4e\x14\xd0\x08\x1b\x0c\x96\x00\x7c\xd8\x16\xdb\x32\x25\x2d\xc5\xa5\xea\x6a\x24\xff\x44\x29\xfc\xa3\x71\x37\x05\x6c\xcf\xe0\xa7\xb8\x90\x7d\xf7\x23\x39\x0e\x03\x8b\x21\x71\x29\x9c\x87\xc2\xa8\x9d\xe3\x79\x51\x10\x24\xa4\x12\xb9\x91\x31\x91\x17\xac\x53\xa7\x0d\x0b\x2a\x99\xbf\x5b\x42\x4e\x55\x5e\xde\x0b\x9d\x4a\xe3\x25\x9f\x93\x0f\xb0\x45\x5c\x7a\xe1\xd2\x38\x71\x09\xf3\x27\x42\xa2\xc0\xc6\x32\xa0\x68\x34\x1f\x23\x8d\x44\x03\x5c\x0c\x82\x60\xd4\x20\x91\x93\x78\x03\x6f\x18\x15\xe3\xad\x18\xf1\xf5\x26\x5c\x6e\xa2\x78\x54\x1f\xa2\xc1\xc5\xae\x64\x4e\xde\x64\x4e\x1f\xaa\x31\xd8\xe0\x84\xf9\xf9\x40\x35\xa8\xdf\xdc\x61\x1c\xfb\xa5\xf4\xf7\xaf\xca\xf8\x5f\x96\xf9\xa4\x6e\x8d\x64\xa5\xb8\x14\x5f\x1a\xf3\xd9\x67\x56\xee\xa9\xd3\x25\xc6\x65\x1b\xe2\xd3\x94\xb9\xad\x66\x73\x2b\x62\x73\x07\xdd\x57\xf4\xb1\xef\x9d\x52\x73\xbf\xc8\xbe\x07\x51\x7a\x8e\x33\x1e\x59\x51\x1e\xe0\x6d\x6e\x8e\xca\x65\x32\xf1\x58\x25\xe4\x7b\x11\x3f\x32\x86\x90\x5b\xd0\xb9\x47\xc6\x74\x36\xc1\x36\x32\x26\x08\x6d\x93\x84\xb5\xa4\x25\x05\x09\xe6\xbf\x66\x39\xe3\x4a\xb9\x7e\xa5\xf1\xc3\x98\x25\x3a\x3b\x43\x56\x5c\x99\xe8\x8c\xef\x78\x81\xaf\xa7\x59\xce\x7e\x25\x93\x3e\x68\x95\xe5\xec\xd8\x93\x72\x96\x33\x94\x9c\x03\x77\x1d\x9b\x43\x69\xf2\xbb\xd4\x8d\x7d\x6f\xc7\x64\x91\xdd\x08\x0b\x67\xc5\x65\x48\x4b\xf3\xff\x6b\xa9\x67\xa3\x40\x9d\x82\x75\x82\x56\xa3\x46\x56\x0d\x5f\xae\x07\xd9\x9e\x2d\x7c\x7d\xc8\xa2\x14\x57\x4f\xad\xb9\xdf\xcb\x07\x0a\x69\x52\x51\xec\x15\xce\x92\x0f\x66\x5b\xf8\xa2\x6b\x48\x88\xbc\xc8\xbb\x71\x10\xf3\xb3\x77\xcc\x18\x76\xe0\xf2\x5a\xd8\x60\xe5\xbd\x6f\xb2\xf7\x56\xb4\x59\xdb\x4a\x66\x3f\xfa\x0f\x7c\xbf\x1e\x9a\x52\x19\x46\x47\xd7\x96\xd7\xaa\x05\x01\x4b\xd8\x20\xe9\x75\x5a\x58\x53\x1d\xe8\x87\xaa\x91\x31\xea\x80\x0b\x2b\xcd\xb7\x59\xdb\x64\x7a\x6b\x65\x6d\x01\x13\xd8\xbf\x52\xa1\xb6\xf4\xd2\x2b\xfc\xee\xb2\x4b\xcb\xca\x84\xa1\xa5\x97\x8f\x96\x02\xf6\x5d\xee\x75\xe1\x02\x37\xf4\x82\x1c\x13\xa6\xec\x29\xc0\x11\x52\xf0\x1b\x89\xe7\x00\x0e\x15\xf0\x49\x37\x2f\x08\x6a\x2c\x49\x1a\x91\x1b\x15\x13\x90\x55\xe4\x01\xbf\x1b\x35\xd8\xa4\x81\x05\xa1\x78\x1e\x0a\xa6\x39\x25\xb1\xd4\x04\x34\xa5\xe8\x13\xe7\xe3\xdb\xcf\x93\x8f\xb0\x45\xd8\x4b\xbe\x17\xd6\x5f\xba\x49\x5c\xfa\xfb\xe2\xe4\x9c\x63\x6c\xce\x61\xd9\x9e\x0d\x12\xe5\x87\xf0\x2e\x3d\xea\x11\x2d\x50\xf1\x9c\x5a\xa7\x86\x03\x25\x1a\x91\xd6\xa0\xd6\x80\xdc\x20\xf0\x2a\x01\xa6\x2c\xf0\x58\x8b\x60\x09\x00\xeb\xd2\xeb\x7d\xc9\xd9\xd3\xe9\xbc\x93\x68\xe5\x8b\x50\x27\x08\x3a\x7d\x58\x84\xf2\x10\xe7\x25\x0f\x16\xf3\x5f\x96\xc6\x7b\xe1\xa0\x87\xe4\xf1\x86\xb2\x4b\xf8\x12\x3e\xf8\xfe\x05\xb2\x76\x05\xe9\x7a\x41\xc6\x0f\xa0\xc3\xe2\x4d\x0c\xa6\x08\xfb\xfe\x28\x7c\xff\x91\x7d\xaf\x63\x38\x3f\x2a\xf1\x6f\x69\x8e\xb8\x16\xa9\x81\x1c\x17\xa1\xd1\xd1\x9a\x1c\x8c\x1c\x82\x3d\x37\x57\x63\xb7\x69\xb4\x45\x79\x56\x9b\x64\x14\xdd\x05\x46\xb7\xb1\xa4\x18\x17\x69\x8b\x46\xc7\x72\xb4\x51\x0d\x9c\x0f\x6b\xde\xe8\x98\xc3\x6a\x63\x4b\x56\x82\xe9\x72\x9d\x0e\xc9\xd0\xbb\x4f\xa7\x7c\xe5\x6b\xd3\x72\x54\x25\x33\x25\x2b\x21\x6c\x38\xe2\xcb\xe7\x68\x01\x8e\x30\x4c\x89\xd5\xeb\x85\xdf\x7d\xb4\xc0\x1e\xd5\xa4\x3a\x62\xa1\x7c\x71\xcd\x23\x2f\x2e\x9c\x12\xff\x22\xd0\xff\x2d\x82\x47\xe1\x1e\x3d\x72\xb0\x31\xa7\xdb\xe6\xf7\x6e\x22\x77\x93\x97\x07\x05\xa2\xed\x1e\x7f\x7e\xce\x84\xae\x42\x56\x7c\xc6\xbb\x87\x16\xac\xbf\xf4\xc1\x2b\x18\xbd\x85\x0b\x70\xe7\x9d\x3b\x67\xbd\xbb\x8e\x7c\x46\x9e\x7f\x45\x28\x7c\xfd\x99\x05\x1b\xd9\xd9\x07\x45\x42\x7c\x86\xcd\x9b\xf9\x2e\xa1\x47\x00\x5f\xbf\x85\xbd\xc9\x45\xa3\xa2\xd5\x76\x8c\x2d\x1c\x97\xa9\xcf\xd4\x6b\x34\xee\x3c\xb7\x37\xc3\x9e\xa9\xd1\x22\xde\x02\x98\x68\xb7\x58\xb4\x9c\x55\x67\xb5\x65\xba\x45\x2d\x9d\xec\x28\x2f\x6e\xf4\x62\x93\x17\x50\x84\x4e\xda\x15\x4e\xa5\xda\x66\x61\x61\x49\x07\xb8\x50\x5a\x4c\x7e\xb2\x1a\x99\x12\x22\xee\x65\xd5\xe8\xe4\x88\x71\x50\x50\x7c\xfc\xab\x57\x91\xaf\xaf\xca\xfe\x2e\x6e\x1a\x8c\x5d\x43\xf4\x28\xe1\xd9\x82\x5d\x5b\x02\x3b\x1f\xca\xbe\x16\xbb\xae\x0d\x6c\x4f\xa0\xe7\xf1\x5e\x72\x35\xde\x7b\xe6\xb5\x9e\x03\xf1\x83\xa4\x7f\x55\xf4\x1d\xee\xb7\xb8\x6a\xdd\x9d\xf8\x0c\xa9\x7c\xf1\xc3\xc9\x14\xd7\x40\x98\x91\xec\x40\xbb\x4a\x68\x75\x57\x5f\x96\x51\x2d\x04\x2c\xbc\x3b\x10\xe0\xf5\x7c\x69\x4e\x4e\x10\x9e\x68\xd5\xb9\x39\xb9\x23\x63\x86\x1c\x2b\x72\xb6\xe4\x68\x94\x93\x03\x85\xc3\xe9\xf5\x21\xe5\x8d\xca\x43\x0e\xbb\x91\x53\xd5\x74\x84\x93\x66\xa3\x54\x8b\x1a\x42\x8d\xb0\x4d\x2e\x1e\x24\x1d\x97\xd3\x15\xa0\x84\xad\xa6\x80\x5f\x8f\x8b\xf1\x88\xc8\xa2\x37\xb6\x3c\x50\xf5\x8f\xd2\xf8\xea\xfa\xe3\x6f\x87\xae\x5b\x3e\xf8\xd6\xbf\xce\xfa\xa8\x4b\x7c\x63\xe9\xbf\x97\x16\x95\x6e\x3b\x32\xeb\x4d\xec\x11\xb7\x91\x33\xbf\x4c\x7f\x63\xef\xca\x32\xdd\x05\xdc\xb5\x0e\x5b\x9f\xbf\x6a\xd9\xb5\xe5\xb3\x3e\xdc\x46\x2e\xdd\x42\x8e\x5f\x10\x79\xbe\x11\xe7\xdd\xbf\x07\x25\xf6\x5d\x9b\xa2\x6d\x7c\x7f\xe9\x6f\x20\x4b\x96\xb2\x98\xd0\xc9\xc8\x8c\xfb\x21\x77\xd4\xc4\x61\x41\x10\x03\x1c\x56\x3f\xa1\x96\x40\x92\xa0\xdc\x8d\xb1\x38\xe8\x03\xbb\x2d\x9e\x61\x7d\xea\xce\xb3\x3e\x78\x42\xb2\x8f\x46\x43\xfb\x18\x5c\x06\x1d\xaf\x6a\xd5\xa7\x36\xf1\x8d\xd8\x49\xbc\x00\xbc\x74\x2c\x62\x7c\x1c\x83\xa4\x80\xec\x51\x3d\x57\x6a\x01\x52\x3d\xbe\xb4\xdc\xad\x66\x42\x59\x90\xf1\x50\xb9\xde\x30\x6b\x3f\x41\x69\xbf\x5a\x6e\x8f\x8b\x2c\x01\x5c\x74\xa1\x28\xa8\x75\xa5\xb7\xf7\xb3\xfa\x8c\xb4\xfd\x24\xb9\x3d\x47\x0b\xa4\x38\x0f\xe3\x3c\x68\x9e\x77\x0c\x9b\x0f\xe5\xf9\x4c\x48\xe9\x01\xed\xbb\x01\x4d\x7f\x94\xb5\x9f\x22\xb7\x47\x1b\x94\xf1\x81\xb5\x63\xc3\xf3\x06\xb3\xcc\xd8\x93\xe3\x8f\x07\x59\x7a\x1c\x93\x05\xe6\xb2\xf6\x1d\xf0\xad\x28\x29\x0d\x64\x64\x30\x69\x20\x67\x52\x4e\x81\xdd\xd0\x4a\x1a\xe0\xe4\x79\xb3\xbc\xdb\x41\x34\x28\xda\x4e\xb0\xe9\x74\xc5\xc5\x3e\xb7\xbb\xac\xd4\x26\xb8\x90\xcb\xdf\x10\x73\x39\x4d\x0e\x50\x4f\x72\x69\xc6\xd1\xb7\xcb\xf0\x92\x32\xdc\x58\x86\xeb\xcb\x30\x2a\xa3\xe8\x4f\xb9\x06\xcb\xc3\xd7\xa2\x52\xc8\xd1\x31\x72\x94\xb7\x9c\x42\x2a\xe2\x95\x38\x15\xcd\x60\xe2\x0d\x74\xc2\xa9\x04\x67\x9d\xb1\xcc\x10\x59\x79\x21\xe0\x87\xe3\xd6\xef\x73\x71\xe6\x01\x19\xd8\xdc\xfd\xc1\x12\x8d\xd1\x45\x2e\xba\x85\xa6\x67\x66\x3f\x74\xb8\xef\xba\xd7\x37\xc6\x66\x74\xb9\xed\xea\x7b\xaa\xb9\x61\xc2\x80\x95\x73\x83\x77\xf9\xc7\x92\x47\x16\x4f\xda\x7d\xf3\xbc\x45\xe3\x4c\x9b\x67\xfd\xf5\xa9\x65\xb8\xf0\xf5\xb1\x2f\x2c\x27\x3f\xce\xfe\xdb\xc9\x23\xd1\xb5\xdb\x99\xce\xfc\x2e\xac\xf9\x41\xd0\xf3\x32\xe0\x44\x8c\x8f\xd6\x64\xf9\xd5\xbc\x33\x5f\x57\xc4\xeb\xf8\x52\x87\xd3\x19\x74\x3a\x3c\x6a\x7f\x20\x00\x53\x0c\x04\x90\x27\x2b\x33\xd7\x08\x73\xb4\xba\x8c\x4e\x94\x09\x73\xc5\xae\x61\xb1\x61\x4b\x4a\x29\x55\x2b\x57\x92\x42\xc8\x33\xb4\x26\xb3\x81\x66\xb4\xce\x66\x20\x9f\x18\x56\xe9\x8b\x63\x39\x41\x11\x2b\x8f\xa4\x92\x80\x63\x58\xc5\x7c\x1d\x4e\x96\xb6\xf0\x45\x0a\xe0\x27\x9f\xf1\xe4\x67\x95\x83\x26\xd7\xce\x58\x4f\xbe\xf9\x76\xdc\x7d\x35\x92\x49\xea\x05\x9a\xbf\xeb\x3a\xfc\xd4\x2b\xd5\xb7\x57\xdd\x5c\x7b\xcb\xd6\x3b\x97\x14\xe1\xbc\x41\xe2\xa9\x43\x9b\xaf\x5a\x36\xa2\x83\xde\xf3\xd8\xfc\x8f\xc9\xe5\xf6\x81\x09\x01\x72\xa7\x78\x37\xfe\xe0\x0d\xf2\x63\xdc\x18\x28\xbb\x63\xc5\xf5\x73\x5e\xce\x7f\xaf\xe7\x30\x46\xd3\xa6\xc2\x9c\xdf\x62\xf5\x2a\x3b\x47\xf3\xf4\x06\xad\x49\xc4\x54\xf6\xe2\xcd\x6a\x8d\xc6\xa2\xdd\x25\x62\xd1\xa4\xf7\x68\xd4\x18\x99\xee\xb5\x60\x2a\x6a\x85\x42\xf5\xe5\xe1\xa6\xb6\xf1\xe6\xf4\x2e\x98\x86\x76\xd3\xac\xe2\x58\x52\x79\x6b\x22\x53\x71\xde\x40\x95\x3e\xaf\x3f\xee\x81\x2b\xe3\x8f\xad\x1c\x44\x3e\xe9\x77\xa3\xd0\x21\xfe\x7c\xed\x87\xa5\xe3\x76\x71\x0b\x2f\x5d\xfe\xf2\x3f\x67\xdf\x67\xb6\x0a\x14\x49\x7c\x27\x7c\x0e\xeb\x6e\x40\xf9\x34\x93\x88\xd7\x69\xc9\x91\x72\x73\xb3\x78\xde\xa9\xcb\x72\x66\x15\xf8\x72\xf3\xf3\xf2\x41\x15\xcd\x41\x79\x38\x13\x74\xd2\x4c\xe7\x8f\x05\xb8\xb1\x00\x27\x51\x09\xd6\xb3\x15\xef\xb0\xd0\xba\x5a\xb5\xa1\x54\xcd\xda\x80\x5c\xb4\x16\x17\xb6\xc3\x85\x2c\x56\x1f\x79\xf3\x0b\xaa\xcd\x7e\x6a\xd0\xe5\xca\x56\xdf\xd7\xb9\xef\x92\x45\x0d\x25\x33\xf1\xba\xfe\xae\x62\x3d\xc6\x53\x07\x92\x03\xe4\xeb\x0f\xc8\x25\xae\xc3\xaf\x05\x7c\xaf\xac\x27\xde\x7e\x6c\xe4\xee\x21\x15\xd7\x4e\x5d\x3d\xf4\xa6\x35\x42\x13\xcd\xe9\x4d\x5e\xdf\x78\x7a\x4a\x82\x9c\xf9\xe1\x45\xfc\xdc\x36\xdc\x7e\xd7\x71\x59\x9f\x56\x6a\x8a\xa3\x42\x34\x22\x5a\x61\xc8\xd3\xe6\xf9\x05\xc1\xe5\xf2\x6b\xb3\x81\x1f\x68\x8b\x8b\x0c\x79\x3c\xf2\xe6\x79\x07\xc7\x32\xdc\x79\x79\xc8\x6e\x77\x0f\x8e\xd9\xcd\x2a\x44\x33\x00\xee\x2f\xc6\x4d\x57\x56\x32\x46\xb5\xd6\xda\x96\x58\x41\xb9\x94\x10\x0b\x83\xa5\x95\x00\x5d\xc9\x02\xb6\xf5\xb8\x55\x0c\x91\x9c\xc9\x55\xce\x82\x8a\xdf\x8c\x6d\xed\xb1\x64\xfc\xb9\x3b\xf6\x7f\xf8\xc0\x4e\x3c\xec\xfa\x2f\xce\xdc\xfe\x7c\xed\x73\x5d\xd7\x5c\x35\x72\xfb\x6d\x19\xbb\x37\x0c\x68\x78\xa4\xa1\xd3\x1d\x23\x87\xec\x5b\xb3\x60\xab\x99\xcb\x9c\xd7\xb8\xee\xae\x49\x53\x87\xcc\xed\xde\xa9\x47\x9f\xc7\xbd\x7d\xbb\x76\xec\x07\x73\xaa\x24\x37\x08\x51\x56\x63\xa4\x32\xea\xb2\xe9\xf5\x48\x74\x7b\xdd\xbe\x6c\x84\x0a\xf2\x72\xbc\xf9\xde\x41\xb1\x7c\x6c\xa2\x08\xcf\xd2\xc5\xa5\xb0\x5b\x71\xc9\x56\x81\xa4\x94\xca\x44\x24\xd1\xf8\xf3\x64\x4a\x33\x44\x13\x7e\x79\x23\x42\x34\x9f\x9c\x21\x17\xd6\x07\x06\xcd\xbc\xbf\xf9\xba\xde\x3b\xc2\x39\xd7\xef\x9a\x3d\x3f\x8a\x87\xe2\x55\xb8\x77\x15\x79\xcd\x2f\x9e\x7a\x96\x5c\x22\x6f\x91\xf1\xc1\xf6\x25\xf9\xe5\x73\x87\x8d\x7c\xb2\xeb\xe8\xfa\x1e\x59\x25\x9d\x8b\x72\x06\xcc\x1a\x74\x0a\x9f\xc5\xed\x25\xe9\x59\xb9\xae\x04\xab\xd1\x97\x8b\xae\x89\x96\x39\xec\x76\x93\x1a\xf4\x08\xa3\xc9\x04\x02\x93\x37\xcf\x6d\xca\x36\x48\x5a\x63\xb6\xb6\x31\xc6\x0b\xd9\x66\xb3\xc9\x61\x37\x19\x4d\x0e\x51\xf0\xc0\x99\x0d\xca\xd9\x3c\x68\xb6\x91\xe4\x91\x65\xeb\x9c\xca\x4b\x93\x0a\x89\x6c\x53\xa1\xb0\xba\xaa\xd0\x4b\xf3\xf9\xca\x39\x49\x84\xf5\x46\xd5\x3b\xe4\xeb\x57\x59\xc5\xe0\x59\xe4\x8b\x07\x8c\x22\x36\x68\x54\x02\xab\xd6\xc0\x57\x66\x4e\xcb\xb9\xf4\x3a\x7f\xb9\xb9\x78\xe9\x9e\xb9\xb4\xd0\x5d\xf7\x4e\x75\x25\x81\x48\xad\x6f\xe2\xb8\xdb\x98\x4c\x35\x15\xe8\x71\x7f\x58\x67\x23\x72\x02\x6d\xed\x16\xf5\xb9\xad\xd9\x8e\x6c\xce\xa1\xe5\xb4\x79\xb9\x6e\x5b\x43\xcc\xed\x36\x21\x95\x69\x10\xad\x6d\xe0\x1a\x04\xe4\xa6\x21\xaf\x0d\xca\x04\xaf\x48\x99\x6c\xb1\x6b\xb1\x6c\x0f\x72\xe3\x1a\x5e\xa9\x28\x41\x4d\x37\x5e\x6a\xa8\xf9\x14\x4f\xbb\xfe\xbe\x73\xb7\x3f\xfa\xf4\xc4\x7b\xcf\x5e\x3b\x66\x69\x90\xdc\xea\xc1\xfd\x47\x2f\x0e\xe2\x05\xb9\xe2\x29\xd2\xfe\x11\xd2\x95\x9c\x5d\x77\xe9\xfc\xc3\xf8\x09\x9c\xbd\xf6\xf7\xf7\xbe\xfe\xcf\x6d\x63\xbf\x15\xa6\x9f\xfd\xf7\xfa\xa1\xdf\xd1\x3a\xb7\x70\x70\x0d\x40\x37\xf4\xa8\x7b\xb4\x04\x74\x3e\xa3\x41\xa7\xe6\x34\x26\xce\x01\x2b\xfa\xa3\x11\xbf\x6d\xc4\xf7\x1a\x71\x85\x11\xe7\x19\x31\x32\xe2\xc7\x8d\x78\x89\x11\x97\x1b\xb1\x62\x90\x99\x31\x23\x28\xa7\x61\x4a\x86\x39\xfb\xed\x2e\x2f\x45\x63\x26\xee\xe0\x51\x25\xe4\x5d\xad\x45\xf7\x00\x76\x3f\x24\x6d\xbe\xa6\xa3\xb9\x47\x61\xb4\x82\x1f\x78\xf9\xe1\x7c\xf9\x9c\xf9\x95\xdc\xfe\x3a\xd4\x2f\x5a\xa8\xc5\x34\x44\x5e\xc5\xa9\x78\x09\x44\x73\xd0\x52\x34\x1a\x83\x4a\x4b\xb9\xbd\x46\x40\x0e\xb5\x68\x02\x80\xca\x0d\x4c\xd8\x0c\xd7\x87\x2c\xc9\xfa\x42\x4a\x5d\x68\x65\xaf\x59\x32\x4d\x5e\x4e\x25\x46\x53\xda\x72\xff\x3c\xbe\xbf\x07\xf9\xf2\x0c\xce\x1c\x8f\x7f\xc3\xed\x48\x09\x76\xe0\xa3\x33\xc8\x53\x40\xc0\x7e\xe5\x34\x24\x14\xa7\xf9\x6c\x13\x7b\x60\xe3\xbe\x97\x30\xec\x58\x38\xea\xb6\x20\x8d\xe0\xc4\xc0\xa2\x33\x80\x72\xba\x6c\xc6\xc6\x98\x8d\x3a\x96\x99\x33\xb0\xa2\xa0\xb6\x2e\xc5\x44\x43\xc3\x38\xd0\x4b\xa9\x5c\x8e\xa9\x94\xc4\x0a\x69\x3b\x5d\xfc\xf7\xe4\x42\x07\xbd\xfd\xa6\x00\xf9\x95\xbc\xc9\x3d\x68\x2f\x6c\x1f\x2e\x0f\xba\xaf\x1d\x7f\xc7\xe6\x3c\xae\xd3\x66\x57\xd9\x5b\x75\xe4\x2a\xfe\xf2\xfc\x5b\x3a\x5a\x9e\xcb\xd9\x73\x46\xf1\x81\x21\xc3\x84\x27\x59\x0d\x93\x71\xd1\x1a\x0e\xf0\x03\x65\x65\xb9\x32\x32\x72\x34\x26\x1d\x4d\x8d\xab\xd3\xeb\xb3\x9d\x26\x9b\x9a\xcb\xe4\x45\x97\x01\xc8\xb9\xce\x23\xda\x1a\x63\xa2\x13\xd1\xcd\x7a\x3c\x07\x4f\xcf\x51\x74\x17\x99\x31\x53\xb2\x9e\xac\x56\x9e\x0a\x70\x48\xab\x1f\x06\xc4\xdd\x27\x97\xf2\x53\x51\xe5\x26\xad\xd4\x2a\xcc\x86\x3b\xaf\x31\xf2\xb3\x77\xd7\x36\x98\x24\x73\x1f\xf2\x15\xf6\xe1\xcc\x39\x86\x0d\x63\x76\xd0\xfc\x45\xbb\x4d\x4e\x6e\x7a\xef\x53\x15\x25\x37\x91\x5b\xc5\xcf\xe2\xbb\x7b\x55\x3c\xf0\xf0\x06\xae\xeb\xe5\x63\xbd\x76\x58\xe9\xbe\x82\xa4\x23\x8c\x64\xbc\xa8\x6f\xb4\x54\xd0\xe8\x0d\xc8\x64\x34\x22\x0d\x6f\x31\xeb\x91\xc1\x61\x94\x4c\xc8\x82\xa7\x5b\xf0\x28\x0b\x6e\xb4\x60\xf8\xfd\x6d\x0b\xde\x6f\xc1\x9b\x2c\x49\xac\x9a\xc9\x4e\x72\x38\xbd\x78\x2a\x60\x16\xcd\x39\xc9\x0e\x2a\x47\xb3\x8d\xe1\xaf\x37\x2e\x8b\x1a\x71\xbe\x25\x41\x5e\x21\xff\x3e\x88\x73\x7f\x78\xfc\x83\x77\xe7\x96\xf6\xaf\xee\xfc\x1c\x89\x12\xba\x8a\x94\xe6\x4d\xe7\x7f\x85\xb3\x58\x89\x7a\x47\xfd\x6e\xbb\x50\x54\x51\xa4\xb6\x17\x88\x06\xa0\xda\x21\x14\xf6\x6b\xd4\x6a\x4d\x43\x4c\xad\x76\x56\xe2\x8a\xca\x8a\x41\xb1\x4a\xec\x54\x28\xa0\x25\xc5\xeb\x93\x22\x7d\x4a\xbb\x67\x65\x51\x68\x55\x20\x56\xdc\xdd\x45\x3d\x8b\x52\xf4\x90\x92\xef\x82\x48\x35\xfb\xac\xc7\x46\x5a\x9f\x80\xff\xb5\xe0\x83\x63\x75\xd3\xa6\xfb\x9f\x7e\x63\xf2\xb0\x95\xb3\xae\x6f\x7f\xef\x8e\xdc\xb2\xa6\xe5\x0f\x6d\xbe\x05\xa3\x7d\x8b\xb7\xdd\xb7\x93\x33\x1f\xe8\xdc\x3f\x20\x9e\x7a\x32\x63\x46\x53\xa8\x8b\x5f\x7b\xc2\x39\x70\xd9\xe8\x3e\xfd\x0a\x7d\xd1\xa6\xae\xbb\x0f\x8f\x2a\xee\x5e\x1c\xee\x96\x57\x7c\xc7\xac\xc5\x7f\xbb\xcd\xcd\x69\xe6\x8c\x1c\xb3\xd4\xad\xc6\xe2\xb3\xa8\x55\x9d\x4b\x34\x98\x9d\xa7\x6e\x89\x6f\xc5\x97\x61\xe6\x01\xa0\x9d\xe5\x01\xbb\xdd\x27\x88\x2e\x9f\x41\xf4\x65\x09\xd6\x42\x6b\x91\x23\xd3\xae\xc1\x7e\x5e\x2b\x3a\xf2\x40\xce\xc9\x73\xda\x51\x80\xd7\x5a\xb4\x0d\x31\x8b\x49\xa6\x9e\xcc\xf6\xa2\x24\xc2\x72\xa5\xf4\x19\x85\x7a\x2a\x8c\x00\xe4\x39\x6f\x67\xae\x9e\x12\x1f\x1a\xfa\xe0\x95\x8b\xf6\x50\xef\x62\x55\xaa\x78\x2d\x37\x33\xc3\x3f\x73\x34\xf9\xc7\xf0\x81\x5d\x33\xdc\x8d\x2b\xdc\x85\x39\xd3\x2a\x85\x9b\xfc\x5f\xdf\x28\x0d\xcf\xae\x76\xe6\x15\xcc\x09\xdf\xb4\x48\x3f\x85\x6f\x6e\x7e\x9e\x6c\x39\xf3\xfa\x3b\xe7\x16\xdd\x92\x61\x78\xd9\x60\x3e\x1e\x3f\xed\xcd\x1c\xa1\xe5\x8f\x6a\x2d\x0b\x67\x75\xee\xc0\x15\x33\x59\xee\x1d\xe0\x07\x3b\x84\x06\x56\xa3\x1f\x64\x0a\xbb\xc9\x64\xf4\xf0\x7c\xae\xc1\x68\xcc\x31\x1a\x3c\x76\x87\x35\x43\x95\xd1\x10\x33\xe9\x11\xd0\x53\x2b\x15\x55\x61\x2e\xa6\x5c\x46\x26\x52\x32\x85\x9c\x11\x35\x9c\xd2\xe7\x15\x46\x20\x27\x47\x4e\x1e\x00\x9b\x15\xb9\x14\x61\x8d\x59\x69\x4e\xff\xed\xd7\x95\xbf\xdc\x35\x79\x55\xb9\x60\xbd\x8a\x7c\xf8\x62\x15\x76\x7f\xf8\x46\x5d\x28\x70\x53\xd7\xe6\xbb\xc7\x0a\x0d\xbf\x7d\xf2\x24\x79\xf7\xa1\x5e\x5d\x67\x93\xa1\xfc\xf7\x58\x87\x12\x2f\x90\xc7\xc9\x17\x35\x9d\xb1\xf4\xda\x2d\xeb\xe8\x5e\xf4\x07\x7e\xdb\x09\xe0\xf6\xa1\x8a\xa8\x4b\x9b\x9b\x61\xb5\xe6\x72\x05\x9c\xdf\x90\x85\xec\x48\xa4\x70\x4e\xf7\x2b\x74\xbf\xdc\xda\x2a\x85\x75\x4b\x11\x15\x19\xc1\xf8\x24\x82\xb5\xc3\x0c\xc3\x40\x7c\xe6\xbe\xfc\xf2\xc6\xfb\x1b\xa7\xf7\x58\x76\x43\xcf\x31\x9b\xdb\xcf\x1e\xd9\xe9\x81\x1d\x95\x79\xa5\x63\x56\x1e\xdb\x36\xf3\xe8\xf7\x42\xc3\x3d\x1b\xa6\x35\xde\x71\xa2\xdb\x90\x6b\x4a\x2d\x85\x9d\xaf\xed\xbe\xff\xde\xd1\x1d\x7a\x79\xf3\x4a\x8b\x7c\x15\x3b\x16\x2d\xc1\x81\x7f\x2c\x50\x6a\xa2\x8a\x9b\x00\x57\x64\x6b\x57\x5e\x86\xc1\x69\xca\xe1\x79\x93\x81\xd7\x78\x35\xf9\x6a\x40\x10\x10\xfd\x81\x5b\x21\x67\x45\x3e\x36\xe7\xa7\x64\xb4\xd6\xc9\xd1\x2a\x2b\x44\xba\xe5\x9d\x71\x01\xc5\x84\x42\x15\xbb\x46\x28\x64\x61\xdd\x0a\xfc\x9c\xfd\xa3\xdf\x46\xbf\x8c\x7d\xcf\x70\x7d\xfd\x2b\x9e\xc6\x23\xb7\x92\xf3\xf7\xef\xdc\xe9\xed\x35\x7e\xd7\xd4\xf0\x14\xfb\x67\xa7\xd7\x92\x27\x9b\x8e\x4b\xc2\x96\x3b\x8f\x92\x6f\xb6\x3f\xf7\xcf\x5f\xe7\xdf\xd8\x75\xf9\x91\xa1\xf3\x56\x30\x7c\xae\x05\x39\xec\x6e\x46\x0f\xfb\x45\x4b\x0c\x99\x99\xea\x6c\x75\x8e\xce\xa4\xf5\x38\xb3\x9c\xa6\x86\x98\xd3\xa9\xcd\x52\x65\x81\xd4\x45\xd1\x37\x9a\x83\xf3\x72\xb0\x39\x07\xa3\x1c\xa6\x9d\x04\x5b\x55\x11\x49\xd3\xcd\xe5\x3b\x0f\x19\x77\xbd\x57\xe2\x2e\x8e\x0c\xda\x9c\x55\x98\x3d\xbe\x8a\xbb\xd5\x4f\xbe\x9b\xd6\x06\x63\x5d\xc6\x97\xf5\x96\x3f\xc2\x53\x2c\xeb\x61\xac\x56\x4b\xf7\x68\x01\x72\xb9\xec\x6a\x03\x6f\x37\xd8\x33\x33\x9c\x16\x2c\xb9\x2c\x12\xad\xb7\xe9\xd2\x22\x0a\x6b\x7d\x26\x36\x65\xca\x94\x3a\x14\xaa\x4f\x93\x0f\x6b\xd3\xa4\x14\xb9\x16\x56\x9e\x45\x21\x79\x42\xf2\x6c\xe1\x59\xa6\xc1\xd7\xe0\x40\x29\xce\x09\x6c\x21\xff\x3a\xfa\xe6\xfb\x86\x39\xc0\xcc\x4e\xf4\xea\x37\x70\x04\xd7\x78\xff\xfa\xc5\x77\xff\x42\x56\xbc\x78\x78\x7f\xcf\x81\xdc\xd5\x4c\x26\x8f\x92\xa1\xe2\x58\x61\x30\xe8\x42\x79\xa8\x29\x1a\x56\xa9\xb3\x5c\x26\x97\x9a\xb7\xe5\xe6\xf2\x36\x3d\xaf\xcf\xf7\xba\x4c\xe6\xc1\x31\x93\x39\xdb\xa9\x71\x0e\x8a\x49\x1a\xa7\xda\x83\x32\x07\xcb\xe7\xa8\x31\x1f\xd7\xe7\xcb\x80\x32\x8e\xd2\x92\xd1\xb3\x3c\x4d\x46\x49\xaf\xc7\x64\x46\x22\xef\x93\x8b\xab\xfa\x55\xcc\xe8\xe9\xb2\x81\x0e\x04\x72\x56\x81\xa5\x4a\xe0\xf6\x3c\x4b\x76\x93\xd7\x1a\xbe\x1f\xf8\xf4\xe7\xb8\x00\xdb\x8c\x37\xef\x1a\x31\x7c\xe2\x00\x5c\x57\xd7\xc7\x35\x11\x4f\x10\x1a\xdf\x7d\x82\x3c\x44\x96\x08\x64\x12\xde\xaa\xfe\xf5\x55\x9c\x89\x63\x65\x07\xb3\xc9\x77\x2f\xcc\x59\x23\x71\x2e\x7c\xdb\xbe\xe9\x73\xe3\xdf\x14\xe0\x4b\x1f\x03\xaf\xec\x0f\x74\xe1\x4d\xa1\x11\x79\xd0\xf0\x68\xd8\x2a\x6a\x0d\xc0\x67\x74\xba\x4c\x0b\x30\xed\x6c\xb3\xc5\x92\x65\xb3\xba\x04\x78\x6a\x15\x2d\x1a\xbd\xd9\xc2\xeb\x40\xf7\x31\x21\x17\x2d\x26\xb5\x2b\x1b\x47\xb3\x53\x08\x1d\xae\x77\xc9\x73\x68\x29\x04\xa7\x70\x77\x59\xad\xcb\xc1\xb9\x98\xe5\x2a\x04\xb6\xc8\xac\xa1\x85\x8c\xc9\x47\x6a\x70\x65\xac\xa9\x6f\x71\x46\x17\xc7\x19\x1c\x26\x3c\x21\x5f\xed\xf1\x77\x21\xef\x92\x37\xb8\x71\xbd\x73\x4b\xcb\xfd\xc5\x41\xc3\x20\xa1\xb1\xe7\x03\xbb\x46\xcc\xcf\xc1\x1d\xe3\x03\x2f\xbf\xc5\xdd\xd8\x75\x1a\x89\xf2\x9d\xff\x35\x79\x62\xb1\xf9\x05\x0f\x8d\xd7\x25\x43\x25\xbd\x58\x07\x73\x98\x10\xad\x41\x3a\x8f\x3e\x13\x48\x9a\xdb\x2d\xea\x0d\x76\x9b\xc1\x26\x65\x49\xd9\x0e\x21\x53\x65\xb5\xe9\x8c\x28\xd3\x08\x47\xd2\xe8\xd4\x1b\x3c\x1e\xb7\x5d\x94\x78\x1b\x45\xa4\x51\xd9\x58\x36\x43\xbd\x1c\x62\x15\x2c\x91\x02\x7b\x2b\x7a\x92\x4c\xf5\x2c\x67\x31\xec\xcc\x31\xfe\xce\x51\x82\x57\x90\x2a\x9c\xe5\x82\x8f\x9e\xe3\xe7\xf5\xca\x98\x83\x6d\xf3\x7d\x1b\x7f\x7d\xb5\x81\xc4\x1b\x48\x37\xd7\xf5\xd8\x36\x5d\xff\xf6\x67\x18\xef\xc7\xed\xe7\xcf\xe3\x46\xc5\x37\x1d\x7a\x6d\x24\x47\xa6\xe0\xad\x56\x3c\xbf\xfb\x3c\x4e\x15\x7f\xb2\x67\xd1\xdb\x82\xb0\x56\x96\xe7\x22\x89\x6f\xa5\x89\x40\xf3\x4a\xd1\x90\x68\xd0\x5e\x52\x52\x5c\x9c\xab\xe1\xdd\x2a\x83\xcf\x6d\x70\xb7\x2b\x2b\x0a\x14\x17\x6b\xf9\x80\x2b\x00\x1c\xc7\xe5\xd4\xe4\xe6\xe4\x0e\x8a\xe5\x68\xcd\x8a\xe4\x9e\x96\xae\xda\xca\xf4\xa6\xd6\x26\x44\x16\xdb\x99\x34\xa1\x17\x46\x9c\xd6\x14\xe9\x96\xeb\x9b\x58\x0b\x22\x2e\x41\xa9\x1f\x47\xe3\xfe\x24\xfe\x58\xdf\x4e\x83\x6f\xec\x76\xb4\xe6\xc5\xf3\x2b\x7f\xb8\x77\xf1\xd6\x6c\x61\x1e\x21\x8f\x9d\xb8\x13\xe7\x9d\xd0\x91\x9f\x7a\xdb\xfa\xf5\xd8\x19\xad\xc4\x7c\x99\x09\x8f\x6f\x98\x30\x1b\xe3\x91\x7f\x8b\x1c\xcf\x4a\xa0\x27\xf6\x90\xa7\x1f\x5b\xb2\x86\xfc\xf2\xf1\xe9\x67\x71\xe5\x31\xdb\xb1\x10\x79\x2e\xd6\x65\xea\x34\x5c\xfc\xd9\xdb\x5d\x90\x6c\x9f\xe1\x45\x71\x4d\xf2\xee\x05\x4d\x7e\x0d\xc9\x16\x26\x7a\xf5\xc2\x61\xcb\x32\x8b\x49\xb9\x79\x61\xa6\x96\x16\x1b\x0d\xeb\x33\x57\xb1\x65\xfd\x84\x94\x5e\xd4\x44\xc3\xe1\xac\x1b\xb2\xdc\x8a\x85\x26\x69\x97\x62\xbc\x9d\xda\x81\x28\x6f\x67\x76\xa6\x7f\x2a\x76\x29\x37\xf4\x70\x9f\x75\x67\xab\xd0\x15\x76\x20\x66\x37\x9a\xab\xb4\x7f\x51\xb1\x1b\xc1\x1b\x70\xc6\x93\x19\x1e\xf9\x05\xc9\xf6\x6c\xaf\x58\xfb\x85\x8a\x5d\xea\x53\xa5\x7d\x19\xb4\x2f\xfb\xa6\xac\xc2\xdd\xd2\x1e\xf4\x9a\xbe\x30\xfe\x46\xf1\x6f\xc0\x85\x8b\x50\x35\x9a\x1a\xad\xcb\x70\x04\x78\x6f\xd8\x5b\x8a\xc2\x2a\xd0\x67\x6a\x4c\x11\x4f\x79\x63\x6c\x6e\xce\xca\x1c\x2e\xc7\x9a\x21\x78\x1c\x56\x3d\xf2\x60\x1d\xef\xb1\x7a\xac\x82\xc9\x97\xeb\xe3\xac\x92\x4f\x8f\x85\xe2\x96\x8a\xbf\x61\x56\x3a\x5b\x2e\x00\x20\x4b\xef\x96\x70\x53\x30\x1d\x75\x15\xb3\x31\x4b\xf2\xce\x59\x40\xfb\x29\x50\x72\x91\xb3\x5a\xf9\x72\x2a\x65\x39\x7f\x1b\xcb\x96\xcc\x2b\x09\xd2\x98\xce\x2c\xf4\xd9\x4c\xc8\x3d\x9f\x5f\x5c\x70\x01\xfb\xb7\xad\xda\xf3\xee\x93\x83\x77\x15\xd7\x74\x95\xea\x8f\x34\xbe\xf8\x1e\xf9\x28\x3a\x7c\x46\x74\x51\x81\x65\xc4\x03\x73\xd6\x8e\x9d\xd5\x65\x76\xf7\x1b\xf1\xd9\x0d\x17\x6e\x06\xed\xc0\xfe\x06\x1e\x85\xc5\x4d\xd3\x46\xae\xb8\x3d\x90\xd3\xf0\xfc\xe8\x9a\x7e\x4f\x70\x9a\x76\x05\xe1\xea\x02\xab\xfb\x72\xf6\x8a\x69\x63\xc6\x76\x99\x5a\x37\x6e\x0a\x93\x4d\x7e\x82\x35\xf9\x0c\xd6\x24\x8c\x3a\xa1\xeb\xa3\x91\x1a\x43\x66\xc7\x62\x7f\x15\x0e\x09\x15\x39\x39\x6a\x75\x71\x66\x85\x10\xb6\x85\xeb\x6d\x9d\x9d\xe6\xc6\x58\xa8\xca\x5f\xd5\x18\xc3\x7e\x27\xfc\x2d\x13\xcb\xda\x37\xc6\xca\xb0\xe8\x65\xd2\x7b\x7a\x66\x7c\x39\xb9\x6b\xaa\xc6\x83\x4c\x5c\x15\x12\xcb\xdc\x96\x25\x85\x15\x24\x33\xb0\x27\x8b\x68\x1a\x93\x37\x4c\x11\xaa\x96\x27\x0b\xed\x87\xbd\xf2\xe2\xd0\xf5\x78\x6a\x49\xe4\x75\x42\xee\xdc\xbb\xcb\xe9\x71\x66\x64\x3a\x7b\x64\x05\xc6\x4c\x1e\xd8\xe4\x74\x3b\x3b\xd6\x34\x6e\x5b\x92\xb5\xf1\x6c\xf3\x8c\x37\x97\xec\x7d\xca\xb5\x84\xac\x70\x6d\xec\x31\x74\x2d\xf7\xca\x79\xf2\xd8\x03\x0b\xa6\x14\xf5\x8c\x76\xf6\x5a\x73\x9d\x96\x97\x43\xd7\x0c\xf4\xf7\xa3\xce\xf3\x81\xa5\x58\xb3\x92\xbb\xe6\xbe\x1b\x9b\x9f\x9f\x74\xf8\x89\xa6\xf9\xb3\xfb\x3f\x3c\x76\xc8\xa0\x31\xec\x2e\x1e\x21\x69\x85\x78\x04\xe4\x8a\xf2\x68\x06\xc2\x02\xcf\x63\x8e\xd7\xdb\xf4\x76\x8d\x69\x54\x4c\x63\x15\x31\x3c\xb0\xca\x3a\x63\xab\xc2\x2f\xac\x56\x08\x2d\x44\xc2\x40\x57\x92\x80\x72\x27\xc9\x87\x33\xc8\x1a\x5c\xfd\x3b\x1e\x39\x60\x6b\xd3\xd0\x3b\x42\xb7\x75\x1d\x5c\x57\x49\xba\x72\x5d\xf9\xfa\xf8\xa3\xf8\xad\x71\xd7\x0c\xea\x7a\x68\x50\x7d\xfc\x79\x86\xd3\x0f\x23\xa4\x5e\x20\x9e\x32\x17\xf2\xcb\xf1\xcf\x08\x99\x55\x7c\x28\xb1\x48\xf6\x31\x91\xe1\xa2\xb6\x61\x7e\xb9\x7c\x06\xf1\xed\xb8\x1f\xca\x8e\x6a\x38\x0c\x14\x17\xce\xa0\xeb\x58\xe2\xf3\x43\x2e\x07\xaf\x4f\x3f\xbc\x3c\xea\x0e\xfc\xf3\x05\x56\x43\xdb\x8d\xf2\xd1\x88\x68\xc8\x6a\x77\xeb\x04\xad\x4d\xed\xc9\xc7\x02\xd2\x6a\x34\x36\x84\x8c\xb9\x42\x86\xd1\x28\x14\xf8\x34\x18\x79\xdc\x1e\xb5\xa7\x21\xa6\x53\x9b\xed\xf9\x38\xbf\x21\x66\x05\xa5\xa2\x4d\x45\xf2\xfa\x56\xbc\x5e\xa1\x70\x4a\xd5\x12\xb9\xcc\x45\x24\x55\x98\x5c\xc5\xdb\x60\xa7\xcd\x85\x5e\x19\xa9\x5d\xf8\x78\xc3\xc7\xdf\x3e\x82\xab\x5e\xa2\x85\xc9\x3f\xfb\xea\x2f\xe4\xb5\x97\x1a\x66\x4d\xda\x75\xf5\x9b\xe4\x87\xb1\x77\x35\x8d\xa1\xd9\x9a\xb6\x5a\xbe\x7b\xf5\x04\xae\x7c\x84\xa3\xa5\xc9\x1d\xe7\x5f\x39\x4e\xfe\xba\x5f\x45\x6b\x93\xab\x17\xbf\x36\x07\xeb\x4d\xd3\xde\x99\xbf\x7e\xab\x9a\xca\x06\x5d\x80\x06\x9c\x61\x32\x4b\x05\x1a\x14\x2d\xce\x12\x83\xfa\x12\x9f\xcb\x66\x2b\x11\x79\x5c\x89\x43\x19\x01\x33\xd0\x6a\xbd\xc1\x60\x2e\x29\x41\x1a\xb3\x33\x8f\x77\x31\x0e\xaa\x54\x68\x0b\xcb\xc5\x89\xad\xb5\x96\x2b\x4a\x7b\x2a\x86\x44\x95\xaf\x45\xc2\x4e\x5a\xb9\x22\x3e\xac\xd4\x25\xf2\x26\x2f\x45\xeb\x31\xd0\x6b\xf8\xf5\x49\xc9\x5d\xb4\xbc\x6e\xfb\xf7\xeb\x9a\xb7\xe6\x0a\xd1\x13\x2b\xef\x3b\x32\x7a\xf2\x42\xfe\xc4\x80\x59\x5d\xb2\x3d\x71\xe9\xea\xd9\x03\xba\x0e\x9d\x95\xe5\xc5\x9c\x57\xdf\x5f\xe8\xf0\xc6\x8d\xc7\xb7\x92\xf7\xb6\x2f\x58\xb7\x62\xc9\x3b\x4f\xad\xff\xcf\x4d\xf1\x2e\x0b\xde\xb9\xb9\xcf\xc6\x9c\xae\xe4\xa3\x15\x63\x6f\xb8\x7b\xfd\x43\x0f\x75\x09\x0f\x1b\x21\xeb\xd5\x1f\xc0\x1e\x3e\x2a\x74\x01\x3d\x70\x64\x34\x6c\x16\x45\x87\xc6\xe1\x0c\x66\x67\xb6\xd3\x14\xb4\xcb\x16\xb8\x4a\xa7\x33\x6c\xc3\x1c\x17\x0a\x7a\x1a\x63\x41\xa7\xb7\xa8\x31\xe6\xf5\xd8\x11\xe7\x30\x19\x54\x8d\x31\x83\x89\x73\x28\x1a\x35\xa0\x6c\x5a\x2d\xe0\x70\xfa\xf5\x56\x52\xb6\xd4\x60\xaf\x5c\x58\xa6\x25\x30\x5c\xe5\xc2\x5e\xd9\xda\x1d\x49\xe6\x2e\xa7\x3a\x86\x62\xed\x8b\xf0\x3f\xc7\x3b\x91\xbf\xec\x3b\x34\xb6\xb4\x4a\x97\x33\xa3\x7c\xe1\xd2\xab\x27\x0a\xdc\xd3\x78\xda\xda\xf3\x63\xbb\xb5\xef\xec\x3d\xba\xb7\x7c\x46\x76\xb1\xb5\x9f\x63\xad\xdb\x78\xd5\x75\xb1\x31\xdc\x89\x78\x97\x57\x71\xf3\xae\xd9\xc6\x7f\xa8\x8d\xcd\x73\x27\x9c\xbb\x83\xe3\x4e\x6d\x26\xfd\x1e\xbd\xc9\x48\x9e\xdd\xbb\x53\x07\xfb\xa9\x5e\xd4\xc7\x3a\x7f\xe4\x84\xaf\x36\x32\xf9\x6f\x1c\xc8\x18\xf4\x5e\xdb\x8c\x72\x68\xa5\x56\x95\x56\xab\xd6\x38\x0c\x1a\x03\x35\xcb\xe6\x69\x33\x46\xc6\x54\x5a\xab\xc6\x83\x2c\x2d\xb7\x42\xf5\xad\xcb\x4d\xcb\xb2\x9d\x7c\xa1\x4d\xa5\x86\xc0\x1f\x5c\x69\xcb\x45\xbb\x1e\x21\xaf\xbc\x7d\x15\xf9\xe0\xaa\x4f\x7f\x6f\x75\x9b\x2d\x17\xec\xfa\x90\xdc\x7a\x31\x87\x8c\xc6\xf7\x07\x70\xe8\xdb\x2b\xaa\x76\xc9\xf6\xe3\x7a\x90\xe9\x40\x9f\x05\x04\xf3\x00\xac\x39\x66\x24\x88\x22\x2f\x39\x35\x1a\x09\xf1\xd9\x59\x06\x50\xef\x0c\x66\x29\x63\x70\x0c\xf8\xbc\x28\x17\xfa\x6f\x55\x5e\x38\xe9\x08\x6e\x46\x14\xce\x54\xc1\x18\xb1\x4a\xbe\xba\xa2\xb0\x0a\xf7\x91\x7f\x7f\x79\x35\xf9\xe0\xea\x7b\x1e\xdd\x85\x0b\x9f\xfe\xfa\x3f\xe4\xc3\xb7\x67\xad\xea\xf3\xf6\x9c\x15\x7d\xb8\xbd\xe4\x5f\x64\x53\x88\x0c\xc7\x7b\x7c\xff\xd8\xf3\x1a\xae\xd9\xfb\xd1\xd9\x5f\x17\xfd\x73\x3a\x89\xdf\x8c\x12\xb2\x7c\x03\x8a\x9d\xf8\x1e\xac\xa5\x9b\x66\x4b\xcf\x44\xd8\x2e\x62\xd1\x63\xd0\xeb\xb3\x5c\x78\x64\xcc\xa0\x71\xb9\x90\x46\x63\x1e\x19\xd3\x08\xf4\x36\x37\xdd\x02\xdc\xda\x9b\x01\x60\xe3\x64\xd8\x04\x97\x98\x56\xe9\x2a\xc2\x73\x65\x95\x6b\xde\x9d\x75\x0c\xc7\x3e\xfb\x09\x87\xaa\xc8\x2f\xde\x43\x4b\xd7\xbc\x36\xf5\xc8\xc3\x7d\x87\x8c\x46\x09\xd3\xca\xf7\x9b\x4f\xe2\xda\xfd\xcf\x1f\x6f\x9c\xd2\x3c\xfe\xc9\x9b\xb6\x3f\x60\x27\x06\x24\xe7\x4e\x1c\x2a\xac\x16\x06\xa2\x12\x80\x2b\x4f\xc8\xcf\xd4\x15\xea\xf2\xf9\xa0\xcd\x6a\x2d\xb5\x65\x0a\x45\x82\xdf\xe4\x47\x8d\x31\xbf\xc7\xe4\x00\x45\x39\xcd\x0f\xcc\xd5\xa6\x6e\xa6\x18\x6a\xb1\xeb\xb6\x94\xda\x51\xec\x1d\x54\x0f\xa5\x35\x0b\x00\x79\xf1\xd1\xf1\x63\xa2\xbd\x7a\xbf\x72\xff\x35\x0f\x60\xe7\xa1\xa3\x5f\xe8\xc9\x05\xed\xbd\x57\xad\x1a\x50\x3d\x66\x71\x64\xea\x90\x2a\xf2\x76\xfc\xb5\xd3\xed\xba\xbf\xfd\x57\x67\xa8\xcc\x57\xed\xea\xb2\xf0\x60\xf3\x83\x38\xf3\xb6\x57\xef\x73\x9d\x68\xda\x7d\xdd\x80\x29\x03\xc2\x8e\xb2\xae\xa3\x7a\x1f\x38\x59\xf1\x55\x96\x3f\x75\x2f\x6f\x12\x97\x22\x1d\x0a\x45\xdd\x9c\x28\x62\x35\xaf\xd7\x6a\x0d\x58\x1a\x19\xc3\x18\x04\x7a\x04\x6b\xca\xab\xd3\xd6\xb4\x85\x71\xb0\x1b\x56\xde\x1b\x61\xd7\xf3\x2a\xae\xa2\x17\x77\xcf\x20\x72\xde\x4f\x96\xdc\x44\x3e\xc4\x16\xfe\xc3\x52\xe1\x1e\xb2\x8a\x8c\x7e\x3a\x7e\x42\x5c\x7a\x81\xd2\x82\xbf\x81\xc2\x7e\x81\xd9\x1c\x43\xd1\x4c\xac\xd5\x4a\x82\x64\x10\xf4\x1a\xae\x21\xa6\xd1\x00\xba\xa9\x81\x23\x9b\x68\x81\xed\xb6\xee\x07\xb2\x75\x33\xe2\x63\xef\xa1\x35\xad\xb8\x2a\xff\xc5\xd5\xe4\x07\x5c\xc0\x7d\x53\x48\x0a\x07\xe2\x7d\xfd\x87\x9d\x88\x47\xc5\xf3\x6f\x90\x1b\xc9\x02\x19\x5f\xaa\x80\xbe\x66\x8b\x5b\x50\x10\x74\x42\x9f\x60\x2e\xf4\xb8\xf2\x3c\x66\x8d\x08\xf2\x71\x59\x89\x2d\xe8\x84\xbf\x86\x82\x82\x9c\x91\xb1\x02\xc1\xa0\x02\x04\xb2\xb5\x91\x04\x92\x76\x81\x94\x82\xc5\x73\xc9\x02\xc9\x0a\x35\xb5\x45\x24\x24\x16\xda\x92\x15\x9f\x5a\x68\x0e\x96\xb2\xef\x9c\xd6\xbb\x5d\xc7\x60\xe7\x92\xfc\x6d\x81\x79\x8b\x9b\x7b\xdd\x16\x3f\x42\x5e\xf1\x1c\xe8\xdb\xbe\x5d\xc7\xd2\x4e\xf2\xc3\x2e\x31\x41\x2d\x5c\x22\x93\xc9\x77\xdf\xb5\x2f\x0b\x9b\xce\xaa\xf5\x93\x46\x4c\xc2\x5d\x8e\x76\x27\x07\x5e\xd0\xe1\x37\x8f\x9f\x8c\xb4\x53\x9e\x76\xfa\xf8\x03\xae\x54\x9e\x53\x2e\x42\x42\x3f\x91\xc6\xa7\x84\xa3\x6e\x15\x8f\xb0\x24\x52\x9e\xae\xe5\xd4\x6a\x9d\x8a\x6f\x8c\xa9\x54\x58\xc4\xb4\x0e\x18\xbd\x1a\x0f\xb6\xcd\x9a\xe6\xf5\xd1\x0c\x14\x61\xba\x55\x4b\x7e\xc6\xbd\xe3\xfd\xb4\xf8\xd5\x9f\xc9\x1e\xee\x05\x2d\x77\x5d\x25\xb0\xf4\x5b\x2a\xe9\x3b\x6e\x21\x31\xc9\x09\xe7\x2c\x17\x75\x89\x16\x64\x3b\x32\x32\x74\x42\x96\xd9\xa5\x13\xbd\x79\xee\xec\xd1\x31\xa7\xc3\xe3\xe6\x79\xb7\xc7\xe1\x14\x55\x26\x15\x1a\x15\x53\x09\x8a\x1d\x45\x89\x1f\x49\xa3\x08\x54\xdb\x17\x54\x85\xb4\x12\x96\x60\x75\x98\x39\x58\xad\x52\x6c\xad\xc7\xb8\x10\x07\x0a\xe1\x47\x3b\xcc\xfd\xba\x82\x7c\xbb\xb1\xef\x43\xb8\xe1\xd8\xa7\xb8\xf1\x70\x9c\xb8\xc9\xbe\x1e\xa0\xe6\x75\x7f\xa1\x18\xc7\x87\x74\xe4\x7e\xe0\x3c\x97\xbf\xeb\xc8\xfd\x27\xfa\xac\xf0\xf0\xf8\x99\x1f\x2d\xbc\x71\x3f\x39\xf1\x2e\xd9\x4b\x44\xf2\x85\xf1\x8d\x8c\xbb\x70\xee\x7b\x02\x39\x73\x04\x37\xdc\x30\x94\xec\x39\x82\x07\x36\x76\x03\xf8\x77\x93\x98\x70\x95\x78\x06\xd9\x51\x5e\xd4\xa4\x15\x39\xce\x6a\xa0\x34\x41\x74\x3a\x8c\x08\x95\x97\xb7\x02\xcf\x6a\x13\x0b\xfd\x81\x42\xfa\xa3\xa0\x30\x02\xad\x2c\x66\x9e\x1b\xfd\x86\x95\x8c\x6c\x8f\x5f\x35\x04\x49\x87\x5a\xbc\xad\x81\x90\xed\xaf\x61\x2b\xee\x78\xe7\x21\x12\xc3\xbb\xf0\xf6\xa7\x5f\x7d\xf3\x9a\xb1\xa7\x4e\x3c\x39\xfc\x91\xfa\x13\x73\xc8\x57\x64\x39\xb9\x44\x76\x91\xfe\x14\xbf\x1f\x20\x43\x55\xfb\xe0\x2c\xd1\x3c\xf8\xc1\x3c\x9f\x4f\xe7\xb0\xdb\x33\x2c\x16\x9d\xc8\xa3\x92\x60\x30\x84\x2a\x25\x9d\xce\x58\x92\x6b\xe7\x03\x1e\xa3\x67\x74\x4c\x63\xb4\x21\x20\x5e\xe8\xff\xe3\xec\x3d\x00\xa3\xa8\xb6\xff\xf1\xb9\x73\xa7\x6c\x2f\x33\xdb\x4b\xb2\x9b\xcd\xee\xa6\x92\xb2\x29\x24\x94\x2c\x10\x3a\x21\x85\xba\xb4\x50\x94\x2a\xbd\x4b\x17\xc1\x82\x52\x04\x01\x45\x11\x54\x10\x45\x8a\x62\x43\xb1\x2b\x16\x2c\x28\x96\x87\x5d\x41\xb0\x61\x7b\x56\xc8\x5e\xfe\xf7\xce\xcc\x96\x04\xf4\xfb\x7e\xff\xe7\x4b\xb2\x09\x9b\xcc\x39\xf7\x9e\x7b\xca\x3d\xe7\x7c\x4e\xeb\x91\xf2\x91\x14\x80\x5f\xfa\x68\x05\xb9\x49\xdf\x5f\x2a\x5d\x6e\x62\x5d\x90\xbc\x35\xf1\xc3\xc4\x40\xae\x56\x2f\x81\x81\x0e\x0c\x2f\x60\x76\x2d\x9d\x6f\xb5\xd7\x1e\x58\xf8\x46\xfd\xec\x27\xa6\x6d\xbe\x4f\xfb\x32\x08\x3d\x66\xe8\x3d\x60\xdc\x3a\xf7\xa1\xb4\x57\x39\xe8\xbb\x8c\x09\xdb\x31\xf9\x67\xc7\xcf\x58\xd8\x54\xbf\x67\x6c\x8f\x7b\xd6\xb5\x2f\x87\x7f\xb4\x0c\xeb\x15\x19\xd8\x7f\xc7\x1a\xb8\x35\xf5\xea\xfc\x94\xdb\x0e\xd4\xc9\xb6\xfd\x00\xb6\x6f\x7f\xe1\xf3\x5c\x44\x0d\x88\xe6\xf9\xb3\xb3\xf5\x76\x9b\xcd\x25\x8a\x7a\x1e\x02\xcc\x6f\x09\x28\x56\x61\xf7\xc5\x67\x33\x86\x3c\x26\x4f\x43\x4c\x6b\xb2\x01\x1a\xbb\xe1\x97\xb2\x5b\x75\x59\x6e\x49\x8b\xb0\x34\xaa\xef\x32\xfc\xa6\xe3\xfe\xcb\xb7\xe6\x34\x33\xf2\x42\x53\x0e\x33\xee\xaa\x49\x0e\xec\xc0\xec\x5e\xfe\x5e\xa0\xdb\xe1\x95\x2b\xd7\x18\xaf\x01\xf6\x79\x86\x45\x83\xd7\x38\x67\xcb\x2f\x6e\xf4\xcc\x04\xce\xe3\x99\xd3\xef\x47\x43\xde\x9c\x76\xcd\xdd\x93\xc6\x7e\x3a\x63\xea\x96\x0d\x5d\xfb\xd0\xdb\xe2\x3b\x7b\x54\xee\xb8\xff\x1a\xba\x51\x7a\xb1\x6f\x0d\x5d\x7b\xe1\xf8\x8e\xa7\x07\x63\x99\x5a\x8e\x75\xe4\x62\xf6\x16\xbc\x51\x1d\xa2\x19\x50\x74\x8a\x1a\x8f\x5e\xad\xd6\x68\xbc\x76\xac\x1d\xed\x8c\x09\xeb\x4a\xbd\xc9\xa4\xd6\x09\x6a\x28\x9f\xbd\xaa\x94\xab\x92\x02\x37\x4a\x0e\x98\x95\x86\x2f\x28\xfc\x28\xa8\xfb\xf4\xee\x25\xd7\xdf\xb4\xfa\x86\xcd\x2b\x41\x18\xfd\x88\x4e\x8e\x9f\xb2\x6b\xe8\x3b\x3f\xaf\xfa\xef\xce\x49\x83\x6a\x82\xcc\x63\x5b\xae\x9f\x37\xbf\x82\xde\x79\x7e\x19\x6d\x0c\x78\xbf\x7b\x73\xcb\x2f\xd7\x9a\xdf\xe5\x31\x5d\x1b\xb0\x3e\xb8\x80\x63\xa0\x2c\x2a\x1a\xf5\x51\x38\xd8\xe3\x03\xac\x16\x5b\x6c\x8e\xe7\xb3\x8d\x78\xa9\xb5\x46\x32\x80\xd0\x99\xd1\x10\x73\x92\x21\x16\x2f\xb5\x9e\xa2\x9a\xbc\x9a\x90\x33\x73\xc9\xb1\x10\x95\x29\x7f\x31\x7d\x90\x1f\x0d\x1e\x24\x59\xb9\x79\xc0\x85\xbe\x42\xdf\xd4\x87\xe5\x11\xea\x06\xbe\x9f\xeb\xe1\xb5\xe3\x1a\xe5\x01\x7e\xfd\xe8\xf7\x56\xdc\x3b\x9f\x1e\x75\xbe\x0c\xdc\xfa\x18\x99\xa0\xee\x9c\x9a\x01\x56\xac\xbc\x45\x9a\xdb\x87\xae\x25\x32\xf3\x39\xf6\x07\xdd\xf8\x8c\x38\xc8\x4c\x7d\x28\xaa\xb0\x09\xc7\x4b\x29\x6a\x5c\x76\xbb\xd3\xee\x18\x13\xb3\xbb\x95\xe5\xd4\x68\xa1\x46\x68\xbb\x9c\x89\xb4\xbf\x02\x17\x85\x3d\x23\x49\xf9\x4a\x29\x14\x59\x01\x9b\xa8\x5c\x50\x09\xc6\x80\x41\xa0\xef\xaa\x9b\x57\xaf\x5d\x89\x4e\xe2\xc3\x1b\x1e\x3f\x76\x4b\xec\xcb\xd3\xc8\x8f\x2a\xd1\x55\xe1\x4f\x40\x17\xd0\x67\xf3\x2d\x91\xf8\x08\x76\x45\xfc\xb7\x80\xeb\xef\x9f\x50\x23\xea\xf8\xa6\x5c\xf3\x7f\xe8\xe2\x0f\xac\x9a\x99\x4f\xe5\x52\x65\xd4\xb0\x68\xbb\x22\x8f\x87\xcd\xf3\xb3\x7e\xca\x4c\x55\x98\xcc\xe6\x72\x8b\x01\x07\x8f\x9e\x9c\x8c\xa0\x25\xc3\x92\x61\x0e\x06\x4b\xeb\x63\xb9\x41\x93\xd9\xaa\x76\x36\xc4\xd4\x4a\x38\x49\xc6\x81\x25\x02\x4a\x92\x44\x6f\x2d\x08\x8a\x70\x73\x52\xb9\x02\x71\xd0\xc3\xc4\x0d\x49\xef\xae\xe7\x92\x92\x61\xb3\x57\xca\x25\xe9\x12\x6a\x01\xab\xee\x39\x5c\xa5\x5b\xd3\x72\xdb\xc2\x71\x55\x1d\xdc\x4d\xc2\xc9\xcc\x07\x17\x75\x18\x52\x57\x1f\xb9\x6a\xb9\xe6\xb9\x5d\x1b\x0e\x2c\xfa\x64\xe5\x95\xbb\x27\xac\x89\x87\xbb\x75\xbd\x61\xa5\x63\x41\xc7\x11\x93\xe0\xc9\x86\x41\xae\xf1\xf9\xcf\xa2\xb7\x1e\xac\xf2\x3b\x46\x6d\xd9\x15\x2c\x0c\x1e\x7f\x6d\xf6\xf5\x33\xa7\xec\x1a\x56\xd8\x65\x0b\xda\x12\x8a\x5c\x1d\x6e\x5f\x4b\xf4\x7e\x08\xf3\xdd\x11\xeb\xfd\x62\xaa\x2e\x1a\x56\x59\x43\xf9\x7a\x03\x36\x37\x86\x7c\x2b\x53\x5a\x92\x59\x94\xab\xd2\x0b\xb9\xfa\x5c\x7d\x91\x50\x94\xd5\x1c\x2b\x12\x05\xed\x98\x98\xc0\xb4\x8d\x9e\x85\x36\x49\x5f\x29\x12\x21\x69\x19\x25\x60\xe6\x83\xa4\x99\x93\xc1\x01\x33\xe4\x95\x98\x99\x98\xcf\x70\xd0\x26\xcd\x92\xf3\x85\x16\x02\xea\xc2\x91\x15\xb5\x2b\xe6\xfc\xd5\x84\x7e\xe9\x7a\xf7\x8f\xfb\xcf\x01\xba\x64\xd0\xbc\x9b\x5e\x7e\xe6\xb6\xc6\xb5\xd7\xcd\xdd\x33\xd0\x09\xec\xa1\xbb\xd1\x0b\x6f\xc4\xbf\x04\x13\xe6\x3e\x76\x4d\x45\xb8\xa2\xae\x43\xf7\xc6\x13\xdd\xd6\xdc\x52\x7b\x78\x6f\xff\x79\xb1\x2e\x91\xe2\xc2\x6e\xb1\xce\x83\xfb\x76\x9e\xd5\xa7\xb0\xac\xef\xc0\xc1\x1b\xde\x9d\x97\xf4\x07\xd8\xde\x98\xbf\x5c\x7c\x86\x7d\x7a\x97\x68\xf1\x43\x68\x09\xb9\x98\xfc\xbc\x90\x5f\xd4\x93\xb2\x1b\x53\x03\x3e\xcb\x54\x36\x0e\xb2\x6c\xd4\xe5\x07\x06\x11\x89\x23\xb3\xfa\x61\x0d\x50\xcc\x3e\x47\x26\x3d\xfa\x09\x4b\x1c\xcf\x2a\xae\x64\x90\xe7\x18\xba\x17\xfa\x0b\xfd\x56\x3a\x74\xf1\xd6\x17\xee\x58\x35\xe7\xfa\xd9\xd3\xee\x2b\x46\xbf\xf5\x07\xf9\x80\xfe\x11\xc0\x27\xce\xa1\xb7\x36\x5d\xbf\xee\xf6\xaf\x41\x9f\x76\x63\xd0\x13\x96\x23\x8f\x0d\xba\x66\x6c\xef\xf6\x45\x01\x6f\x73\xff\x6e\xfd\x27\x4e\xe9\xfa\xdc\xdd\x8f\x3e\x70\xe7\x73\x35\x4d\xd9\x93\xea\x87\xf4\x99\x7f\x21\xbb\x3d\xf6\xcf\xbb\x62\x1d\xb4\x0d\xd3\x9f\x45\x05\xa9\xbe\xd1\xdc\x80\x29\x28\x08\x1e\x4b\x36\x65\x34\xf1\x7c\x88\x0f\x6b\x1d\x99\x38\x9e\x50\xb9\x29\x77\x36\x14\x98\x4c\x46\xc4\xff\x1e\xc4\x7b\x24\xa4\xc5\x8b\xf6\xb6\xd1\xa2\x8c\x31\xaf\x04\xfd\xca\xc4\x27\x52\xec\x0b\xc2\x32\x4a\x86\x8c\x75\x6f\x17\x21\x80\xea\xd0\xb0\x0d\xf3\xea\xd7\xb6\x9b\x9e\x39\x20\x5c\x59\x9f\x77\xdd\xa7\xb9\x2d\xa5\xb9\xe0\x74\x7b\x73\xe7\xca\xbc\x59\x39\x99\xdd\x6f\xef\xb9\x7c\x79\x30\x73\x3e\xfa\x9e\xb9\xb6\x7c\xf9\xc8\xea\xe2\x63\xfe\xc2\xa2\x8e\x2f\xc7\x07\x9e\x38\x41\x3f\xf8\x72\xa7\x76\xc5\x19\xc7\xca\xcb\x27\xce\x6d\x71\x81\x2d\x68\x92\x14\x6f\x78\x31\x3f\x1e\xec\x37\xfb\xa8\x00\x96\xb8\xfc\x80\x31\xcb\x6c\x76\x8b\x7e\xca\x60\xe4\xb9\x6c\x2e\xa8\xb1\x7b\x71\xb8\xcb\xbb\x28\x97\x68\xf0\xb3\x66\xc6\x6b\x12\xf0\x3b\x70\x4c\x6f\xb6\xfe\x6f\x1c\x5d\x9e\x21\x29\x3d\xac\x05\x7e\xfa\xae\xe6\xfa\xeb\xfa\xdf\x36\x66\x9a\xb7\x6b\x7e\xfb\xc1\xf9\x13\xce\x07\x5b\x6a\x83\x60\x5f\xb5\xbd\x6b\xfb\xfc\x71\x39\xbe\x35\xb7\x35\xce\x2b\xb2\xfc\x02\xae\x86\xbd\xc6\x0f\xea\x3b\xe9\x98\x37\xaf\xac\x78\x16\x8a\x3c\xf3\x0c\x78\x73\x56\xbb\x8a\x3c\xef\xb1\x49\xfd\x06\x62\x67\xe5\x0f\xcc\x47\x7f\x2c\x57\x8f\x60\x9f\xcc\x89\x3d\x69\xac\xd1\xbc\x4e\x2d\x1b\x08\x08\x5a\x21\x14\x54\xf9\x9a\xb1\x3f\xab\x52\x39\x8c\x0e\x30\x3a\xe6\xa0\x8c\xae\xe6\x98\x51\xbc\xb4\x42\x25\x09\xfb\x29\xd9\xbc\x2c\x46\x1e\x53\xc6\x48\x89\x07\xa2\xe0\x5c\xa0\x00\xf8\x23\xc9\x39\x7f\x56\x13\xbb\x1a\x7d\xfd\x25\xfa\xe6\x4e\xdf\xb0\x3f\x96\xc5\x81\xf5\x30\xba\xff\x4d\xf4\x12\x7a\x67\xc2\x5b\x80\x06\x23\x41\xaf\x1b\xe3\x8e\x67\x4f\xef\x7d\xe2\xf8\xc7\xcc\xa7\x9d\xaf\x9d\xdb\xb1\xeb\x4f\x5f\x1c\x40\x67\x77\x02\x3d\x08\xee\x05\xed\x01\x7d\x53\xa7\xf3\x17\x8f\x3e\xb0\x7e\xfe\xc1\xfb\xd0\x17\xf8\x5c\x74\xba\xf8\x03\xf3\x3c\x33\x00\xcb\x55\x4d\xd4\xe7\xa0\xbc\x82\xc0\x53\xbc\x2e\xa0\xcb\xf6\xb9\xeb\x63\x3e\x1f\x83\x3d\x16\x62\xba\x19\x1c\xbf\x30\xb6\x4b\x8b\x83\xd3\x55\x9a\x3c\x0f\x52\x8a\x5f\xb0\x9b\x8e\x19\x91\x9d\x91\xe4\xcc\x9e\x52\x1b\xd3\x69\x35\xfa\x6b\xc7\xa9\x9f\x5e\x07\xeb\xff\x0b\x2a\x73\xd0\xd9\xc7\xd1\xc5\xc5\x13\x67\x2e\x5e\x37\xae\x5f\x45\x9f\xf0\xb8\x61\x77\x3e\x05\x9e\xba\xf6\xf8\xa2\x4f\xdf\x3b\x06\xda\x1f\x7a\x7b\xd6\x87\x5b\x97\x2e\x5a\x38\xb6\xa6\x8f\xf5\x55\xeb\xad\xe4\x0c\x47\xb0\xbd\x2b\xc7\xb6\xc3\x47\x35\x44\xc3\x2e\x95\x53\xed\xb4\x6b\x1d\x0e\xb5\xc6\x28\x68\x04\x3f\x93\x91\x91\x45\x99\x55\x3a\x9b\xae\x39\xe6\xb2\x99\xf1\x7f\x1a\x47\xc2\x82\x54\x25\xae\xf6\x5a\x37\x91\x48\xe3\x5b\x95\x42\x0f\x39\x8f\x9c\x2f\xd7\x8c\x72\x56\x3b\x16\x7e\x5a\x1e\x1c\x2c\x8f\xca\xf9\x6d\x97\x4d\x5f\xd1\x2d\x6f\x0f\xfa\x72\x8f\x7f\x78\x3f\xf0\x28\x80\x83\xef\xbb\x2e\xab\x13\xc8\xec\x94\xbf\xea\xc6\x7c\x7a\x6a\x6e\x49\xb1\x2b\x3f\xd4\xb2\x1d\x8e\x1d\x3c\xc8\x2f\x86\xb7\x3e\x38\x08\x74\x46\x2f\xcc\x9c\xd4\x71\x83\xac\x7f\x9a\x28\x0a\x1e\xc1\x72\xa2\xa5\x7a\x47\xb3\x29\x35\x50\xa9\x38\x88\xfd\x75\x9a\x66\x34\x3a\x8d\x5e\x63\xe4\x01\x05\xa1\x96\x61\x19\x6c\x47\x38\x56\xbe\xf8\x88\x24\x27\x48\xca\x88\xca\x12\xd9\xe9\x44\xc3\x80\xc8\x56\xb2\x98\xc8\x20\x4f\x2f\x38\xf2\xe5\x7a\x74\xb6\x14\xd8\xaa\x41\xc9\x44\x90\x59\x0a\x87\xb4\xdc\x0f\x87\xd8\x90\x08\x76\xa0\xd1\x22\x22\xb6\xf7\x63\x2c\xab\xfb\x98\x2e\x54\x0e\xa6\x21\xec\x0a\x9a\x39\x0d\x17\xcc\x60\xe8\x1c\x9b\xdd\x9e\x67\xc1\xa4\xe4\x66\x61\x37\x2d\xcb\x66\xa5\x68\x9b\xd1\x80\xa3\x31\x43\x9b\xfb\x97\xd4\xdd\x4b\x2a\x70\x25\xb7\x2e\x2e\xf0\x8f\xd7\x2e\x7c\xd2\x97\x80\xbf\xc7\x3b\xa3\x3d\xb1\x83\x43\xc7\x15\x94\x69\x32\x66\x16\x2d\x5e\x3e\x70\x22\x4b\x3f\x09\xa6\xde\x7a\x52\xf9\xc9\xa2\x15\x43\xae\x24\x77\x2c\x23\x41\x06\x60\xc6\xcf\x26\xb7\x2c\x4b\xe7\x5d\xf1\x15\xb9\x65\xb9\x03\xf5\xbf\x77\xb6\x7c\xed\x32\xfe\xeb\x8d\x44\x7f\xe4\x93\x3a\x43\xac\x3f\x32\xb0\x46\xef\x1d\x0d\x65\x51\x26\x63\x98\x77\x38\x8c\x14\xcc\xcf\xe3\x1d\x8c\xc7\x93\x5d\x1f\xf3\x98\xb4\x22\x16\x5e\x2d\x63\x72\x33\x99\x8d\x31\x26\x35\x48\xfe\x92\x76\xac\xa4\x0c\xcb\xad\x58\x16\x72\x4d\x84\x0d\xb4\x9f\x24\x9c\x92\xb7\x19\xca\x75\x37\xb1\x5c\xcc\xa1\x5b\xd1\x7f\xf7\x4d\x7f\x3c\xbf\xf6\x9e\xc7\xe6\xac\xee\x80\x10\x1f\x1a\xd4\x74\xf0\xc4\x98\xc7\x41\x87\x77\x3e\xf8\x29\xbe\x6d\xdb\xbd\x27\x37\xdd\x37\x8d\xde\xf5\x3c\x3a\xf6\xc0\xe0\x5e\x2b\x17\x95\x96\x4f\x5b\x98\x6d\xe5\xe7\x9d\xff\xea\x77\xb0\xfd\xdd\xcf\xe2\x4d\x7f\x7d\xf7\x2d\xfa\xf3\x8b\xab\xe6\x51\x69\xbd\x5b\x1c\xe9\xdd\xba\x78\xf1\x62\x36\x1a\x42\x8f\x60\xdf\xc0\xdf\xd7\xb5\xae\xa5\x67\x6e\x93\x64\xa9\x06\xcb\xd2\xf7\xd8\xef\xb6\x52\x7d\xa2\x39\x1c\x84\x46\x23\xa3\x81\x16\x9b\xc5\xce\x15\xc0\x8e\x90\x86\x7a\x08\x0c\x0c\x84\x3a\x51\xa4\xc8\xd0\x52\x9d\xba\x21\xa6\xb3\xb6\x3a\xbb\xcd\xa3\x46\x36\x8f\x6c\xa3\x36\x49\x4d\x13\xef\x27\x25\xe0\x7c\xea\x18\xd3\x6f\x6c\xbc\xd7\x01\xae\xc8\x41\xbb\x27\xac\xfc\x33\x27\xfe\xd7\xe9\x3b\x80\xff\x39\x50\x94\x03\xaf\x9a\x37\xff\xd8\xb2\xc9\xc7\x3e\xfd\xe9\x10\xc8\xb8\xf3\x2d\x39\x1e\xf8\x06\xd3\xb5\x51\xa2\xab\x57\x34\x6c\x14\x04\x96\x32\xb1\xd0\xae\xb1\x99\x0a\xcc\x1d\xcd\x98\x2c\x33\x26\xcb\x6c\xd6\x00\x8d\xb6\x21\xa6\xb1\x02\x4c\x1c\x30\xfe\x03\x59\xf6\x64\x97\x57\x44\x69\x90\xf3\x57\x12\xdf\x08\xc7\x04\x58\x9d\xdc\x92\xf3\xfb\x9f\xe7\xb6\xa1\x1f\x1e\x42\x8f\x86\xff\x5c\x7b\x67\x06\xda\x99\x03\x86\x2f\x58\x0b\xa7\x1f\xfb\xfc\xfb\xbd\xe8\xb3\x7b\x8e\xcd\x9d\x73\xec\x9a\x69\xc9\x7e\x88\x76\x52\xfd\xf9\x0e\x69\x6d\xdf\x25\xf7\x5c\xd2\xda\x3e\x97\x58\x5b\xf6\x73\xa9\x4f\x21\x94\x88\xb1\xb9\x57\xa5\xde\x81\x8e\x51\x2f\x4b\x9a\xe0\xd5\x1c\xd4\x03\xac\x06\xd5\x6a\x1e\x30\x0c\x0f\x21\xa7\xc1\xb1\x37\x27\x24\xc6\x19\x91\xce\x76\xfc\xd1\xfa\x3e\xc7\x2f\x82\x80\x16\xc8\xd3\xbd\x01\xf3\xd0\x17\xa8\xe3\xbb\xbf\x7f\x89\xce\x03\x33\x58\xf1\x35\xb8\x1f\xdc\x80\x7e\x62\x56\xc4\x3f\xa4\x4b\x2e\xcc\xc7\x3e\xe8\x39\x5a\x3c\xbf\x4c\xb9\x2b\x7d\x5d\xba\x13\xae\x8e\x66\xd8\xcd\x66\x51\x07\x9d\xd8\x97\x77\x88\x56\xde\x6d\xa7\x55\x74\x7d\xcc\xa4\x32\x02\x5d\x6a\xd6\x77\xf2\x52\x3b\xf9\x6c\x12\xe6\x43\x8e\x4c\x2b\xc2\x8f\x16\xec\x9d\x69\x69\x1c\x5d\x85\x50\x09\xe9\xf7\x67\xe8\x32\x0d\x8f\xfd\x0e\xb2\xc1\x9c\x3c\xbf\x4e\xe8\x37\xe3\x28\x98\xf6\xee\x1f\xc3\x75\xfd\xb4\x70\xee\xbc\xfd\x8d\x2d\x43\xd8\x53\xe8\x01\xf4\xfd\xe9\xe2\xbd\xe7\xc0\x75\x17\x8e\x82\x77\x3a\x83\xda\x6c\xc9\x27\xee\xa1\xd4\x81\x38\xb1\xef\x31\x21\x5a\x01\x1c\xb4\x1d\xdb\x63\x2b\x63\xf3\x78\x68\xda\x66\x0f\xa8\xec\x2a\x11\x86\x9d\xce\x90\xc9\xa4\x63\xad\x4e\x52\xca\x2b\x50\x94\xce\xee\x66\x5d\xf5\x31\xd6\xa4\xf3\xd5\x93\xb1\xa6\xad\x26\xbd\x25\x2b\x7d\xd2\x64\x30\x91\x74\x91\x74\x1b\x1f\x11\x05\x2a\x92\x56\x26\xc2\x91\x21\x9d\xd8\x96\x07\x40\x5a\xa5\xc8\xc6\xbb\xae\x2f\x03\xae\xef\x93\xe5\x22\xda\xcc\xff\x86\x7f\xb5\xa2\x8f\xac\x3b\xe0\xbc\x64\xc5\xc8\x02\xfa\x69\x52\x25\x92\x28\x1b\x69\xbc\xe3\xa5\xa9\x53\x99\xd7\xda\xd4\x8c\x58\x49\x4d\x06\xf6\xaf\x9c\x54\xfb\xa8\x9b\x13\x29\x9d\x4e\x74\xbb\x58\x56\x65\xb1\x98\x54\x2a\x88\x5d\x2b\xc6\x64\x6f\x8e\x99\x5a\xdb\x6f\xb2\xed\xb2\xfd\x96\x72\xa4\x58\x32\x7d\x30\x2c\xf8\xc9\x7d\x87\xdc\x82\x14\x0e\x12\x4a\x29\x66\xdc\xde\xbb\xd0\x1f\x5b\x4f\xbd\x0b\x5e\x79\x16\x58\xd7\xbd\x8b\xae\xfb\xf9\x0c\x3a\x19\x01\x82\xf7\xde\x79\xbf\x02\x11\x76\xdf\xf7\x34\x42\x73\xc1\x9c\xf5\xe8\xf7\x87\x5b\xd0\xec\xf7\x5e\x7e\xb1\xe7\x94\xc5\xa0\x21\x4d\x3e\x4d\x21\x22\x9f\x26\x9e\x32\xd3\x63\xe9\x6a\xac\xff\x52\xf4\x7a\xf1\x69\x0b\x78\x5c\x32\xcd\x99\x19\x12\xcd\x2a\xb7\x5b\xe5\x72\xfd\x1f\x94\x57\xb5\xa2\xbf\x34\xf2\x6f\x1c\x04\xb1\x1c\xfd\x1f\x5c\xc4\x77\x76\x00\xfe\x0e\xff\xc4\x8b\x0d\x94\xa0\xb7\x13\xbd\x61\xbc\x49\x08\x91\xde\x30\x33\xaf\x8a\x4b\xad\xc5\xb6\xa8\x1e\x98\xcd\x6c\x08\xe8\x47\xe9\x4d\x72\x67\x01\xc9\x02\x25\xde\x2f\xf5\x15\xe4\x28\xb9\xa3\xbd\x89\xbe\x02\x9d\x8e\xe4\x8e\x4c\x8f\x99\x0c\xe9\xbd\x08\x24\x2e\xc6\xfa\xf2\x21\x7c\x86\xb3\xa8\x7e\xd1\x1c\x23\xe7\xf1\xda\xb9\x4c\xaf\x9f\x63\xb2\x03\x6e\xe0\x64\x9c\xa4\x85\x4c\xe7\xd3\x89\xcd\x31\x9d\xe8\x15\xa8\x0c\x5f\x46\x73\xcc\x07\xd3\x66\x6c\x2a\xee\x0d\x95\x56\x06\x27\xed\x2f\x09\x31\xc9\xe0\x41\x98\xcc\x24\x74\x96\x2d\x1f\xa9\x79\x24\xc8\x16\xcb\xba\xdc\x72\x66\x22\xd8\x98\xdb\x7f\xc1\xfe\xa5\xab\x0e\x77\xfa\x32\x67\x64\xfb\x3e\x43\xcb\x7f\x7a\xf4\xdd\x15\xe8\xe4\x19\x54\x55\xc0\x3c\x46\xee\x44\x0f\xb6\x2f\x42\x6f\x97\x7d\xff\xc6\xbc\x8a\x01\xcd\xf7\x74\x2c\x19\x75\xba\x64\x7d\xd7\xf8\x14\xe6\xce\xd3\xa7\x25\x7e\x01\x5b\xce\x9b\x4c\x21\xf8\x92\xb4\x3e\x08\xcc\x54\xd6\x87\xe3\xf0\xfa\x68\x28\x0d\xc7\x52\x89\xf5\xc1\xbc\x2a\xf2\x81\xa5\xa0\x5b\x34\xcb\xed\xf1\x88\x3a\xc1\x6a\x65\x18\x6d\x86\x36\x53\xb0\x36\xe3\x00\xc0\xa9\x52\x19\x89\x10\x50\x98\x6f\x4a\xbc\x9c\x07\x27\xe5\x37\xe5\x5a\x6f\x56\xe9\x9a\x4b\x5e\x8f\x4b\x36\x41\xaa\x86\x11\xed\x34\xfd\xca\xb3\xe8\xfb\x75\xef\x82\x85\x3f\x9f\x01\xe1\x08\xfa\x11\xef\xfb\xa3\x17\x22\x74\x46\x61\xfc\xdc\xde\xbb\x80\x06\x4b\x86\x65\x3d\xd0\x3e\xdc\x02\x6e\x96\x77\xfd\x85\x03\xa7\x3d\xfb\x9e\x06\xf4\x5c\x74\x93\xa4\x6b\x9d\x98\xd6\x2e\x92\xae\xad\xf8\xa7\x1e\xba\xff\xe7\xbe\x13\xfc\x37\x99\xcd\xd2\xdf\x90\x71\x48\x56\x5d\xfc\x59\x35\x0b\xef\xbd\x1b\xff\xb5\xd1\xd1\x52\xbc\x22\xbc\xda\xe9\x83\x4e\xac\xb7\x43\x66\xb3\xcb\xa9\xd2\x18\xd5\x0e\x8b\x93\xf7\x34\xc7\x78\xc1\x9d\xdd\x1c\x73\xbb\x8d\x4e\xa3\x65\x34\x76\xcd\x9d\xea\xd1\x31\x67\x9b\x06\x38\x2a\x55\xc5\x84\x57\x09\x94\xa6\x0f\xa7\x24\x25\x2a\xd8\x4d\x67\x72\x89\x9b\xa8\x01\xc9\xd9\x7a\x15\x82\x1b\xf8\xb1\xf2\x97\x5d\x5f\x3f\xb7\xe4\x1b\xa0\x47\x47\xd0\x67\xf1\xe2\x2f\xd1\xdd\x73\x66\x2e\x9e\x7d\xf3\xf8\xaa\xea\x62\x8f\xbb\xb4\x69\xf6\xc4\xbb\xe0\x8d\x53\x17\x80\xeb\x36\x6c\x5b\x7c\x03\xda\x0e\x1b\xde\x3e\xf4\xe9\x2f\xcc\xcd\xe8\x5e\xf4\x10\xfa\x76\x4b\xad\xf9\x4f\x7e\x0a\x70\x82\x08\x38\x19\x7f\x3b\xbe\x79\xda\x95\xb1\xe1\x72\xae\x26\x48\x51\x2a\x0e\xf3\x28\x60\x2e\x87\x44\x0b\x0d\x1a\x8d\xd6\xc8\x0b\xa2\xc8\xdb\xa1\x16\xf3\xe9\xf5\xb8\x55\x6a\x03\x66\x46\x30\x1a\x0c\xa2\x8e\xc7\x82\xae\xe1\xb5\x82\xde\x6c\x82\x3a\x28\x75\x4e\x11\xc7\x52\xe2\x2f\xe1\x61\xb6\x1e\x20\xda\x86\x35\x72\xb9\x82\x05\x3c\x8d\x23\x73\x82\xa3\x65\x73\x51\xe1\x3c\x72\xdb\x0f\xc2\x53\xc1\x89\xa9\xf8\xf3\x02\xd0\x5e\x62\xe6\x9c\xcc\x0c\x3d\x22\x7e\x2f\xb6\x70\x6f\xd3\x25\x49\x16\xa4\x7b\x2b\x6e\x18\xa6\xdf\x49\x7a\xa6\x28\x41\xcf\x09\xa2\x55\xb4\x73\x8c\xdb\x65\xa6\x8c\x10\x4b\x2b\x84\x36\x8d\x20\x42\xb5\xe0\xc4\x5e\x4d\x73\xcc\x96\x3c\x9c\xa4\x3f\xb5\xa8\x2d\xc9\x98\xd8\x44\xce\x3d\x51\x5c\x9e\x38\x91\x7e\xd8\x65\xd3\xbd\x4d\x2f\xbe\x61\x6a\x44\xa7\x1b\x0c\x1f\x6d\xd9\xbf\x32\x79\x10\x51\x7b\x38\xaa\x2c\xf3\xa9\xa7\x7a\x35\xa1\x66\xb0\xbd\xb1\xe4\xb1\xf2\x78\x73\xf2\x0c\x52\xec\x68\xa2\xa3\xe0\x31\xe5\x0c\x3e\x28\xf7\x0d\xd9\xf0\x09\xb4\x3d\x01\x8c\x8f\xd8\x9c\x56\x3e\xd5\x37\x44\xde\x7f\x5a\x7a\xff\x6b\x8a\x4e\xf3\x2a\x67\x56\x14\xf1\x6f\x18\xb1\x2f\x44\xf1\x69\x3a\xad\x12\x9f\x83\x73\x7c\x4f\xfc\xfe\xf7\xa4\xf7\x9f\x07\x9f\x82\x3e\xd2\xfb\xb1\xcf\x14\x02\xd6\x85\x56\x0f\x6d\x48\x3b\xe3\x01\x34\x91\xfd\x4a\xca\xd1\x74\x8d\x06\xb5\xa4\x83\x57\x4d\x53\x6a\xa8\xd7\x71\x2c\xcd\x8e\x8e\x01\xb5\x06\xd2\xf8\x09\x8c\x0a\x42\xd8\xa0\x07\x46\xbd\x54\x61\x65\x8f\x14\xe1\x8f\xb4\xe9\xd8\xca\x5a\x89\xca\x7e\xe2\xcf\x60\x7f\x3d\x0a\x91\xfb\xb1\xaf\xe8\x49\x5f\x01\x2f\xfa\x11\x85\xeb\xd1\x44\xb0\x95\x5d\x71\x61\x36\x73\xf3\xf9\x65\x68\xe2\xa5\xbd\xcb\x58\xfe\x08\xbf\xc3\x24\x1f\xc9\x8a\x63\xde\x80\x4e\x6f\x86\x7a\x9e\x87\x6a\x68\xb7\xe9\xb0\xce\xd1\xe9\xf4\x2a\x95\x16\xeb\x1c\xc8\xeb\xc9\x29\x2b\xb6\x5f\xa6\xca\x3e\x8d\x20\x45\xd2\x48\x6e\x27\x25\x63\xf0\xca\xe4\xa9\x01\x66\x26\x50\x10\x67\xba\xb4\x39\x27\xec\x8a\x53\xe8\x61\x59\xa6\xfe\xa1\x9f\xba\x5c\xea\x81\xf6\x47\x8d\x90\x61\xa8\xb4\x6e\x6a\xa5\x93\x5a\x49\x2c\x25\x3b\xa9\xcb\x0b\xe2\xe1\x56\x9d\xd4\x44\x9f\x4c\xc7\x6b\x7f\x0b\xfe\x3b\x06\xca\x42\x8d\x8b\x46\x2c\x6a\x23\xf6\x08\x81\x34\x29\x18\xd2\x7a\x03\x0d\x6d\xd8\x43\xb3\x0a\x46\xb3\x4e\x6f\xa4\x54\xac\x6a\x74\x8c\x15\x78\xda\x6c\xd2\x9b\x46\xc7\x0c\x7a\x58\x6f\x23\xbc\xcb\x7e\x5a\x91\x5c\x27\x96\xea\x57\x6c\x95\xc2\x56\x1c\xc7\x60\x04\xca\x23\x84\x23\xd8\x69\x93\x4a\xdf\x78\x9a\x67\x0e\x1e\x5e\x76\xbe\xbe\x65\x41\xfd\xdf\xcb\xb6\xc5\x9e\xee\xb3\x09\x5a\x11\x38\x84\xce\xd7\x6d\xbb\xfd\xb7\xf8\x1c\xb0\x15\x4d\xa4\x6f\x5a\x08\x16\x7d\x02\x9e\xbe\x30\x1b\xde\xf6\x1d\xca\x3b\x99\xec\xe3\x4b\xf5\x61\x63\xff\xf2\x01\x8a\xe2\x8f\x62\x5e\xfc\xd4\xf4\x68\x8d\x81\x32\xfb\xfd\x94\xc7\x6d\xb5\x69\xd4\x0c\xe5\x56\x43\xd6\x66\x0b\xb0\x59\x16\xad\x01\x72\x2a\xbb\xcb\xcb\xa9\x7d\x58\xa5\x8d\x89\x99\x0d\x06\x35\xc3\xba\x3d\x7e\x96\x12\x34\x46\x93\xd5\xc6\xaa\xe1\xfa\x00\x90\x04\xac\xc6\x5e\x9a\x6c\xc2\xb4\x27\x6a\xdf\x24\x27\xae\xb4\xb5\x36\xf1\x8b\x59\x61\xec\x08\x87\xc2\x90\x74\x38\x91\x3e\xcc\x52\xa9\xcb\x49\x2a\xdd\x27\xa9\x79\x48\x3f\x3e\xaf\x77\x2e\xca\x43\x2f\xd3\x43\xbd\x4d\x0f\x82\xac\x25\x1d\x07\x77\x9c\x03\x84\x39\xc5\xb3\xaf\xa7\x2e\x82\x0a\x74\xa4\x68\x65\x26\x28\x42\x6f\x7d\x61\x1b\x9e\x39\x8f\x1e\xe9\x8d\xaf\x86\xac\xef\x65\xb0\x05\x1d\xb9\x73\x1e\x3d\x24\x7e\xff\xf8\x7d\xa0\x16\x4d\xea\xb8\xd6\xd2\xf2\x1b\xbd\x5c\x67\x8f\xdf\xa3\x60\x73\xfc\xc5\xde\x8a\x3d\xa7\xa6\x68\x01\x03\xed\x0e\x4d\xb6\x90\x01\x1d\x06\x7f\x46\x36\x97\x13\xb6\x5b\x8d\x6e\x2c\xad\x7e\x23\xc3\x1b\x8c\x86\xe6\x98\xd1\xc8\xbb\x19\x8a\x4f\x59\x49\x49\xd5\x48\x05\xa2\x8a\x09\x68\x75\xb1\xc9\x26\x7c\x23\x79\x58\x69\x65\xc4\xa7\xdc\x71\x56\x28\x85\x52\xd2\x05\x2f\x43\xd7\x7d\x8e\x7e\xa8\x01\xfa\xdc\x3b\x17\xdc\xb8\x76\xc3\x96\x0e\x85\x1d\x40\xe3\xc4\xe6\xaf\xc7\x5d\xa4\xea\x40\xe8\xdc\x87\x2d\x0f\xef\xc5\x9e\xd2\x6b\x96\x27\x5f\x1f\xbe\x72\xc1\xf4\x49\x4d\xa3\x4f\x7d\xda\x3b\x76\xa6\xef\xf3\x87\x1e\xdf\xb6\xf5\x88\xcf\x7c\xef\xfc\x13\xa7\xa9\x64\x9e\xf6\x34\xde\x3b\x3d\x55\x14\xb5\xb3\x7a\x8a\x32\x90\x49\x0e\x46\x56\x47\x6b\x18\x9e\x03\x50\xaf\x26\x89\xef\xd2\x52\xac\xdb\xd3\xbb\x33\x22\xf2\x80\x73\x8e\x07\xf2\xc4\x67\xec\xfd\x9b\x01\x77\x97\x3d\x04\xab\x40\x3f\x7c\xde\xcf\xdf\x9d\x6d\x6d\x79\x83\x5d\xd1\xf2\xe6\xdc\xed\x4c\x8f\xf3\xcb\x60\xcd\xee\xa1\x17\x5e\x4c\xea\xb4\x9e\x49\x9d\x76\x9e\x56\x29\x3a\xca\x60\xc0\x3a\xca\xfc\xb0\xd9\x91\xd2\x69\x0a\x7d\xa3\x31\x7d\x56\x6a\x68\xb4\x88\xb6\x58\xac\x26\xbd\xd1\x60\x35\xe8\xa4\xf3\x61\x57\xe9\x4c\x50\xe4\x69\x71\x4c\x8c\xa5\x69\x2b\xe9\x1c\x12\x30\xd1\x14\xac\xb1\x83\xe3\x76\x19\x7e\x40\x22\x9d\x04\x52\x55\x97\xe6\xc7\x13\x09\xa1\x84\xd4\xc0\x84\xd4\xf8\x41\x39\x08\xcf\x69\xbf\x76\x36\xd0\x82\x32\xf4\x50\x56\x97\xaa\x76\x06\xd0\x19\xbd\xf2\xb3\x7d\xb8\x77\x1e\xfa\x18\x5b\x9e\xfb\x97\xaf\x05\xbd\xd1\x90\xbc\x5e\x95\x21\x75\x9c\xa2\x97\xeb\x6d\x58\x34\xf0\x59\xc0\x7e\x02\x7b\x37\xa6\xd7\x82\x35\x98\x8f\x02\x64\x16\x8f\xda\x2a\xd8\x2c\x82\xc9\xac\xa3\x79\xfc\x03\x80\xed\xa7\x19\xf2\xba\xd1\x31\x5e\x4c\x8b\xb6\xa4\xc3\xeb\xa8\x49\x65\xa6\x25\xd0\xd7\x4b\xcc\x3f\xf0\x33\x83\xd1\xa4\x4b\x8c\xfd\x13\x78\xc9\x4f\x5f\xce\xc0\x9f\x5f\xf6\xaf\xbd\xfc\xf9\xff\xd8\x53\x7f\x5a\xea\xa9\x6f\x17\xb5\x27\x7a\xea\x01\xad\x74\xd5\x73\x2c\x6c\x50\x4b\xda\xa7\xa6\x34\x39\x37\xbe\x4d\x4b\xfd\xa3\xa7\xe2\x9b\xe4\x96\xfa\x03\x69\x2d\xf5\x97\xf4\xd4\xb7\x8d\x93\xdb\xf6\xb7\xcb\xf5\xa7\xec\x39\x4c\x8b\x99\xdc\x2d\x19\xd5\x3a\xad\x46\x4f\x6b\x74\x50\xc0\x0e\x88\x9a\x35\x1a\x28\x83\x5e\xab\x81\x58\x44\xf0\xe9\xda\x21\x82\x7a\x11\x98\x44\x90\x6c\x64\x25\x1b\x2f\x24\xf4\x87\xa2\x3c\xa4\x23\x96\x98\x79\x4b\xfa\x89\x88\xb6\x00\xc1\x95\x53\xe6\xd5\xd7\x94\x0e\x6c\xec\x81\x6e\x00\xb9\x80\x02\xfb\x41\x79\x3c\x73\xd5\xbb\x96\x7e\x67\xf2\x72\x06\x5d\x05\xef\x8d\x0f\xa5\xf7\x5c\x78\xfa\xe8\x4d\xa4\x7e\xac\xff\xc5\xdf\xb9\xf6\x69\x3d\xf6\xe5\x56\x0a\x64\x30\x99\x16\xc1\x97\xa3\x61\xd4\x16\x51\x54\xb3\xae\x4c\x75\x36\x56\x70\x2e\xf8\x0f\x5d\xf6\xa3\xf3\xc8\x0a\x5e\xda\x61\xdf\x6a\xde\x7a\xb2\x84\xec\x7f\xee\xb1\xe7\x97\xf9\xa4\x1e\xfb\x96\x50\x85\xdc\x63\x5f\x44\x7a\xec\x0b\x95\x1e\xfb\x0e\xa1\xa8\x83\xf4\xd8\x17\xfc\xff\xec\xb1\xcf\xc6\x36\xeb\x90\xe4\x2f\x54\x44\x3d\x40\xc3\xd2\xbc\x8a\xd6\xa8\xb0\xbf\xa0\x96\x1d\x06\xec\x2c\x30\x3c\x71\x16\x64\x27\xe1\x32\xfe\x54\xc2\x47\x80\x11\xc8\xb8\xeb\x2f\x3c\x29\xfb\x08\x55\xd8\x47\xf8\xea\xc5\x65\x29\x0f\xe1\xc2\xec\xf8\x1c\xfc\xbc\x87\xf0\xf3\xdf\xc4\xcf\xb3\x51\xb5\xd1\x2c\x40\x66\xda\xf2\x56\xbb\xd5\xa1\x33\x6b\xd5\x8c\x46\x34\x33\xe6\xe6\x18\x76\xe0\x35\x94\xa0\xb5\x58\xa1\x06\xb6\x6a\xde\x37\xb7\xe9\xde\x97\xa4\xf3\x92\xe4\x36\xb1\x84\x70\xd3\x94\x4d\x4f\xc5\xde\xfe\xd0\xd4\x08\x3c\x0d\xfa\x79\x4b\xee\x79\xfa\x1a\x92\x2d\xa5\x03\x25\x59\x2f\x3e\x15\x6d\x02\x3b\xd1\xd8\xbe\x79\x63\xc7\x94\x93\x44\x69\x52\x67\xf2\x7f\x25\xfc\x26\x9e\x81\x14\x43\xe9\xd4\x1a\x8d\x5e\x62\x9e\x82\xa3\x63\x5a\x4a\xa0\x59\x4e\xad\x61\x01\x2c\xd6\x03\x53\xc2\x6f\x92\xce\x8b\xbd\x0d\xde\x50\x44\x59\x11\xe2\x39\x11\x25\xea\xfd\x0a\x3c\xf7\x15\x10\xe5\xcf\xe8\xc7\xc4\x82\x10\xb7\x49\xd9\x03\x9e\xdc\x23\x19\xa9\x9e\xd1\x5c\x96\x56\x73\x5a\x60\xa0\x39\x03\xd4\x99\x74\x66\xfc\x44\x3d\x23\xed\x04\x45\x0b\x98\x18\xad\x8e\x85\xd0\x64\x2e\x36\xd3\xf2\xe3\x8b\x92\x8f\x97\xf4\x5f\x69\xdb\x4d\x91\x37\x86\x2b\xae\xff\x7b\x97\x4c\xc8\x1e\x89\x10\xf2\xf9\xd4\x4b\xad\xb6\x47\xd9\x22\xec\xb3\xdd\x8a\x75\xcb\x2a\xc5\x67\xeb\x44\xba\x94\xf5\x3c\xd6\x6e\x6a\x98\xf2\xd9\xb4\xb2\xb7\xa6\x55\x35\xc7\xb4\x6d\x61\x40\x2e\xe7\xaf\x11\x07\x3b\xe5\xaf\x31\xeb\x13\xfe\xda\xd0\xaf\xb1\x83\x4d\xff\x88\x23\x81\x66\xc9\x5d\x3b\xaa\x84\x35\x77\x9e\x4e\x45\x31\x90\xec\x8d\x2a\x20\xe1\x92\x18\xa4\xbe\x8d\x80\xc1\x68\xd4\x8a\x3c\xaf\x75\x00\x9a\x76\x1a\xec\xcd\x31\x83\xc1\x08\xb4\x24\x18\xa0\xb4\x02\xad\xd3\x43\xd0\x26\x76\x69\xdd\x0d\x48\xe4\x86\x68\x89\xa4\x33\x99\x22\x8d\xfd\x8e\x88\x2f\xfa\xb1\x65\x60\x9a\x4b\x29\x85\x2a\x8a\x3f\x49\x94\x5e\xc2\xa7\x4c\xd1\x98\xf2\x73\x35\xd8\x23\xa8\x8e\x66\x18\xa1\x46\x8b\xe3\x2b\xde\x6a\xd1\x90\x90\x4a\xa3\x55\xf1\x5a\xb2\x62\x6a\x15\x2c\xb6\xca\x8a\xf6\xd2\x36\xd2\x56\x0e\xee\x3f\xb8\xb7\xe9\xb4\x5c\x4a\x07\xa0\xf2\xb0\x6e\xbd\x4b\x8a\xf1\x07\x45\x0b\xb5\x1a\xb7\xe0\x31\x89\x22\xd4\x78\xcc\x90\xc9\xcc\x70\x3b\x04\xad\xc1\x2c\x98\x49\xac\x6f\xa0\x78\xec\xc8\x60\x7b\xe5\x20\x25\x85\x33\x32\x2f\xf5\xbb\xa9\x36\x29\xda\x64\x85\xa1\x29\x75\xdb\xe3\x23\x3b\xab\x64\x9b\xf8\xb0\x00\xfb\x03\x37\xa8\x78\x0d\xdd\xf4\xdf\x2f\xd0\x67\xdd\x00\x53\xb6\x6b\x11\x98\xd5\x1c\x7f\xa7\x90\xce\x62\xf7\xdd\x7d\xc3\x9b\x85\xbf\xec\x67\x37\xa3\x0f\xd0\x9f\x28\x8e\x26\x7f\xf6\xf2\xdb\xcd\x6b\x97\x80\x55\xa7\x33\x7c\x1b\x77\x2c\x99\xdc\x13\x5c\x4f\xe6\xe9\x5d\xfc\x81\xff\x45\xba\xab\x0a\x53\x03\xa2\x05\xd6\x0c\xbd\xc5\x64\x32\x07\xa1\x59\x0f\x61\x6e\x8e\xc5\x38\x3a\x66\xb1\x98\x45\x01\x1f\x01\x41\x67\x53\x51\x2a\x3f\x8e\x1d\x44\xca\x95\x2a\x8b\x4c\xb6\x91\xd5\xc8\xf1\x5f\xba\xfe\x4d\x56\x48\x92\xec\x53\x3b\xba\x93\xe4\x15\xe0\xf3\xd1\x19\xb6\xae\x93\x64\xef\x25\x55\x3c\x53\xdf\x42\x5f\xec\x5f\xf7\xd1\xa6\x7e\x5f\x24\xc2\xd6\x0f\xb2\x57\x1d\xf9\x71\xd1\xfa\xd7\xa7\xed\x58\xb7\xee\xd8\xb4\xed\x98\x95\x63\xe8\xd7\x83\xe8\xf1\x9f\x96\x0d\xb9\xf3\xa3\x95\x99\x72\xf8\x7a\xed\x87\x5b\x07\x7c\xbb\x05\xbd\xbd\xe3\x89\xc3\x5b\x40\xce\x9e\x87\x9f\x93\xb1\x0e\xb0\x7c\xfc\x2d\xc5\x06\x76\xaa\x3e\x1a\xd6\xe9\x01\x30\x1a\x45\x02\x34\xa3\x76\x52\x0e\xa0\xd6\xeb\x75\x76\x5d\x73\x4c\xaa\x4d\x34\x92\x3a\x3a\x83\x56\x23\x7b\x69\xa5\xe9\xb7\x4c\xa9\xf6\x17\x72\xd8\x15\x9f\x22\x00\x48\x29\x60\x36\x91\x1a\x91\x18\x3f\xb9\x78\xc4\x5f\x00\x3e\xa9\x9d\xd9\x19\x94\xe2\x7f\xfd\x84\x54\x8a\x4c\xc4\xf6\xe2\x4a\xb8\x04\xcd\xdf\xb5\x61\xfe\x38\xb0\x89\x6e\x70\x4d\xdd\x30\xf8\xd3\x33\xe7\x97\xd1\xf6\xf8\xb7\xcc\x1d\x33\x66\x0d\x9a\x24\xc7\x02\x1a\xec\x0b\x57\x4a\x39\x86\x5a\x29\x86\x1b\x89\x65\xca\xcf\x7e\x86\x69\xcf\xa7\xfa\x46\x73\xfc\x3a\x9d\xc0\x86\xc3\x82\xb3\xc0\x59\xe8\x37\x66\x67\xab\xea\x63\xd9\xd9\x94\x2b\xea\xc4\x0a\xac\x3e\x66\xb4\x1d\x27\x08\x14\x3f\x17\xd2\x23\x67\xca\x3b\xe2\x7a\xd3\x5c\x95\xde\xa5\x99\x14\xf6\x60\xa9\x92\xec\x97\x6b\xa6\xb3\xc8\x75\x52\x67\x3a\x3b\xc8\x73\x3c\x76\xdb\x94\x38\xdd\x40\xd3\xb5\x03\x67\xf7\x0f\x8d\xbf\x62\xd6\x4d\xb5\xd3\x46\x9e\x42\x9d\x86\x5f\xfb\x34\xe8\x0e\x76\x17\xbe\x75\xf8\xcd\x5d\x13\x7b\x66\xd6\xfd\xe7\xee\xe3\xa7\xeb\xee\x38\xfb\x60\xd5\xbc\xfd\xbd\xe7\x2c\x1e\xfd\xc2\x94\x85\xeb\x9f\x03\x62\x7c\x01\x08\x1e\xdf\x34\xae\x6f\xe4\x7b\xab\xc7\xdb\xbe\x79\xeb\xea\x8d\xcb\x3f\x7e\x79\xc1\x5f\x07\x87\x50\x52\x9f\x44\x58\xea\xc9\xac\x95\xee\x45\x82\xa4\x87\x3d\xd3\xc1\x33\x3c\x15\x14\x45\x1d\xa5\x0b\x87\xa8\x30\x30\x41\xe8\x0e\x06\xdd\x4d\xb1\x60\x50\x63\x32\xf9\x1b\x63\x26\x93\xc6\xda\x18\xd3\xd8\x94\x2e\xcc\x36\x67\x05\xc8\xdd\x11\xa9\x9a\x13\x79\x4e\x94\x51\x42\x40\x60\xfc\xbe\xb0\x48\xb2\xff\x36\x65\x3c\x3c\x0e\x02\x94\x7e\x08\x23\x60\x76\x6e\x5c\x05\xa6\x2c\x45\xef\xa0\xb3\xe8\xb7\x3f\xe6\x14\x00\x11\x50\x1f\xfc\xd2\xf2\xe2\x92\x21\xeb\x6e\xfc\xfb\x99\x77\x56\xdc\xb0\x67\xee\x32\x9b\x1a\x76\x99\xbc\xd6\xce\x9b\xae\x1e\x7e\xdf\xa1\x5c\x7a\xca\xf7\x27\xaf\x6f\x89\x9b\xfa\x0d\x5a\xbd\xa7\xa1\xf7\xd2\xf9\xb3\x24\x1c\x29\x2a\x03\xf3\xc4\x32\xf5\x54\x1e\xb6\x23\xe1\x90\xc6\xee\xc0\xf1\xab\xd7\xcb\x38\x34\x4c\x41\xbe\xb1\x00\xe8\x60\x08\xda\x05\xc6\xc5\xbb\x2c\x8d\x31\x97\x4d\x42\x42\x68\x55\x66\x2a\xb3\xd0\xca\x8d\x4e\x66\xf6\xf1\x46\x00\xa9\x10\x43\x1a\x79\x2b\x37\xf3\x60\x67\xab\x33\x24\x98\x33\x74\xed\x84\x71\xde\x6f\xcb\x4e\xbd\xfe\xe6\xa9\x3e\xdb\xf6\x1f\x9e\x54\x78\x62\xfe\x42\xcf\xf7\x23\xd1\x98\x53\x3f\x0f\x3e\x74\x68\xec\x9c\x4e\xa2\x90\xdf\x0b\xae\xab\x6e\x2c\xde\xb6\xfc\xb6\x9b\x86\x2e\x18\x5c\x54\x5c\x10\x09\x2d\xec\x5e\xdf\x1e\x7d\xbb\xe3\xde\xe6\x6b\x47\xe6\x3b\xb2\x7c\xd9\x2e\xd1\xef\x34\x12\x79\xeb\x88\xf9\xd8\xc3\xbe\x41\x79\xa8\x42\xaa\x7b\x34\x94\x6f\xf5\x53\x94\xde\xca\xeb\x61\x51\x3b\x57\x10\x93\xee\xf2\x6a\x04\x6f\x7d\x4c\xb0\x69\x18\xbc\x1f\x60\x79\x11\x68\x28\x4a\xeb\x7c\xbc\x9c\x1d\xaa\x4c\x0e\xe4\x97\xce\xbf\xec\x34\x54\x54\x56\x28\xa9\x3a\x41\x16\x43\x5a\xaa\x6f\x87\x9b\xd9\xbd\x9b\x87\x0c\xaf\xf6\xad\xae\xc1\x8e\x64\x59\xfd\xce\x5f\xf6\x7e\x79\x11\xaa\x0a\x81\xfe\x95\x39\x87\xd0\xab\x93\xae\xeb\x3a\x7d\x4a\xc7\x91\x3d\x4a\x4c\xfa\xc9\x70\x49\xdd\xf6\x07\x7c\x7b\x05\x2f\x7a\x1e\xbd\x79\x1b\xda\xf8\xeb\xbc\x9f\xdf\x6b\x2c\x38\x1b\x1f\xd0\xf2\xe3\x3c\xc0\xf4\x9b\x31\x2b\xbb\xff\xc2\x41\xd1\xea\x69\xcb\x93\x7d\xc0\xd5\xd2\xb9\xea\x45\x29\xfd\xec\x5c\x35\x53\x8d\x63\xec\x0d\xd1\xc1\xe6\x4c\x93\xcf\x40\x19\xfd\x2e\x96\x31\xf9\x8c\x7e\x8f\xdb\x06\x19\xb5\xca\xe7\x57\xf9\xdd\xd0\xce\x30\x59\xf6\x00\xcd\x7a\x5d\x0e\x9e\x53\x65\xe2\x83\xd8\x14\x33\x17\x19\x96\x19\xd6\x19\xe0\x53\x86\x63\x06\xda\x60\x50\x41\xbf\xcf\xe3\x66\x19\xab\xda\x68\xb2\xd9\x59\x95\xd4\x6c\x19\x50\xfa\xce\xe4\xbb\xb0\x91\x23\x93\xd1\x77\x5a\xd3\x4a\x44\x71\x1a\xcc\x64\xb0\xa3\x39\xd9\x81\x06\xd2\x82\x70\xda\x2e\x46\xa0\xd4\x91\x06\x38\x9e\xf8\x59\x01\x18\xa0\xc7\x45\x33\xd1\xab\xe8\x3f\xe0\x31\x7f\xf8\x16\xa0\x1a\xec\x2a\x29\xcd\x19\xd1\x32\x22\xbf\xb4\x7b\xb7\xc3\xc0\x8b\x4e\x45\xa3\xef\xa1\xef\x6f\xf7\x77\x1d\xd2\x02\x9e\xd5\xa2\x0a\xba\x83\xff\x4a\xb0\x10\x5d\xac\x1f\x5e\x00\xc1\x47\x28\x44\x07\x9a\x46\x01\x16\x2d\x1e\x54\x18\x7f\x03\xbc\xae\x45\x5d\x88\xfc\x6a\x2f\xfe\x00\xbf\x67\xfa\xe3\xf3\x78\x45\xb4\xca\xe4\x56\x07\xac\x36\x06\x42\x9b\xce\x17\x70\x73\xe1\x50\x34\x3c\x3a\x4c\x43\xa3\x35\xd3\x8a\x3d\x24\xab\xa8\x77\x88\x4d\xb1\x4c\x3d\x76\xd3\xf4\xba\xa6\x98\x5e\x4f\x39\x4c\x14\xd7\x98\x2c\xc8\x69\x13\x90\x63\xc9\x06\xcd\x6d\x84\x9b\x55\x26\x2e\xc9\x98\x2f\x89\xe2\x83\xb0\x0c\xb3\x89\xa5\xdd\x2a\x9d\x5c\xf0\xdc\x93\x9f\x79\x5b\x02\xbb\x62\xa3\xae\x5f\xe2\xd9\xb7\x7e\x50\xcf\x3b\x72\xbe\x19\x00\x16\x3c\xf2\x51\xd3\xf5\x03\xa7\x2e\x42\xc8\xb2\xe3\xd6\x82\x7b\xeb\xfb\x34\xd6\x3e\x54\xdf\x58\x55\xbd\xde\x02\x8a\xd6\xce\xed\xbf\xa4\x8f\x9a\x31\x2f\x1d\xb3\xed\x61\x69\xdf\x07\x5d\x3c\xc7\x3c\xcb\x54\xe3\x7d\x1f\x9a\xfa\x9e\x8d\x9b\x42\xe4\x7b\xe9\x4e\x8f\xf4\x85\xe7\x46\x3d\x54\x3e\xf0\xe5\xcf\xc8\xdf\x91\x7f\x3c\x9f\xf9\x39\x1f\x00\xaf\x97\x80\x0f\x75\xf4\x85\x3d\x9a\x44\xf8\x0c\x46\xce\x9c\xa5\xf8\xab\xcc\x18\xa9\x2f\x78\x58\x34\x62\x32\x68\xa1\x8e\xc6\x71\xa9\x5e\x27\xe8\x44\x5e\x65\xd1\x1a\x54\x26\xda\xd4\x14\x2b\xa2\xb1\x87\x24\x60\xdb\xa9\xb3\xf2\x40\x05\xa5\xb6\xd6\xd1\x16\x50\x63\x91\xbb\x45\xed\xa5\x58\x32\xb0\x60\x28\xe9\x6d\x7c\xce\xcd\x09\xed\x2c\xcf\x9f\xf6\xb7\xd9\x76\xff\x9f\xc0\x35\x3c\x52\xd2\xb5\xd7\x5e\x20\xa0\x5f\x7b\x74\x7d\x17\x7d\xb3\xd6\xd5\x6b\x08\x3a\xc3\x54\xa3\x62\xe8\xea\x35\x19\x00\xb4\xb2\x39\x14\x7f\x35\xb1\xa7\x17\xf7\x63\x99\xff\x00\xd3\xe9\xa0\x7a\x45\x43\xb4\x0d\xd8\xed\x36\x97\x4e\xe7\xb4\x18\x6d\x0c\x0e\x3f\x6d\xb4\x84\x5f\xa4\x36\xd6\x93\x8a\x38\x02\x8f\x50\xe3\x02\x49\x68\x84\x54\x10\x5d\x52\x9c\x66\x3a\xb0\x91\xe3\x68\x25\xb1\x42\x42\x3e\x28\x54\xfa\x21\xfd\xed\x7e\xf4\x75\xa7\xd1\x03\xfa\x0f\xba\xb2\x4b\x68\xb4\x31\xdb\xef\xf3\x16\x97\xb4\xef\x33\xa6\x2b\xf4\x9d\x80\x8b\x9f\x40\xdf\x1d\x5b\xdd\xe0\x37\x30\x4f\xaa\x9d\x3d\x96\xbe\x06\x7c\x2f\x5f\x38\x2a\xfb\xfd\x01\x6c\x97\x5f\x94\xf2\xd0\x0d\xd1\x02\x86\x35\x99\xb4\xa2\x45\xaf\x81\x16\x8d\xd6\xa2\xb5\xdb\x38\x68\xd2\x69\x18\xd6\x4a\xb1\x5a\xab\x5e\xb4\x40\x1d\x59\xc0\x83\x76\xb0\xdc\x0e\x46\x26\x8f\x96\x59\xc1\xd5\x48\x8a\x96\x72\x99\xe2\x17\x2b\x2a\xb1\x87\x61\xa0\xc9\x2d\x9d\x68\xb3\x76\xc6\xf6\x19\xc2\xf3\xd7\x67\x84\x51\xe4\xfd\xb1\xb4\x5e\xb7\xee\x8f\x13\xe0\xaa\x4e\xa2\x73\x08\xc8\x07\xf3\x4e\xd0\x4f\xae\x5a\xda\xd2\x0d\x3e\x95\x35\xa5\x21\x9e\xc5\x54\xc7\xdf\x3e\x36\xa9\xeb\x11\x7a\x82\x44\xa8\x44\x27\xb3\x4f\xaa\x87\x1f\x11\x2d\xe3\x21\x64\x80\x5a\xad\x61\x34\x7a\x1d\xaf\x02\xd8\x00\xd3\x99\x40\x42\xc2\xa4\xc9\x70\x0a\x06\x6a\x8d\x1a\x1c\xbf\x49\x70\x13\x7a\xd0\xac\x5c\xf3\x4a\x90\x1c\xd2\x90\x6c\x72\x75\x32\x72\x66\xa4\x35\x8a\x4f\x24\x81\x83\x96\x08\x1c\x68\xd3\x40\xb0\x72\x20\x70\x9d\x40\x67\x86\xa1\x25\xc3\xd0\x99\x13\x78\x97\x07\x82\x07\x2f\x1c\x05\x6f\xa3\x12\x4c\xcb\xe5\xb0\x0d\x08\x9d\x58\xd6\x29\x9e\xd4\xed\xe3\x20\x9e\xa3\x38\x32\x23\x9a\x67\xea\x63\x14\x6f\xc4\x31\x25\xb0\x2a\x9d\xa4\x84\x92\x56\x14\xa4\x9e\xce\x3c\x8b\x9f\xb9\x1f\x4d\xd9\x2f\x3d\xf3\xc2\x51\xb8\xb8\xe5\x5a\xf9\x79\x17\x4f\x48\xbd\x27\x44\x87\x0e\xa0\x2e\x53\x0f\x41\x9e\xcf\xbd\x2a\xd1\xd3\x20\xbd\x7f\x2f\x7e\xff\xab\xd2\xd9\x1b\x21\xd9\xfd\x1a\x34\x84\x7b\x0f\xdb\x96\x30\x55\x46\x75\xa3\x96\x45\xfb\x75\xc9\xb6\x16\xf2\xd0\xe5\x62\x61\xb5\x17\xba\xdd\x0c\xc3\x46\x0c\x06\x36\x1b\x76\xaf\x3d\xd8\x1d\x50\xdd\x8b\xbb\x1f\xef\x0e\xb5\xd0\x5f\x5e\x1f\xf3\x9b\x5c\xa4\xbf\x42\xc5\x68\x05\xa1\x08\x9b\x1f\x93\x36\xa7\x3e\xa6\xb5\xb1\x6e\xaa\x13\x69\xc0\x4f\xb9\x05\x69\x26\x95\x7c\x43\xcc\xea\xcc\x94\xea\x91\xfb\x64\xe5\x04\x3c\x51\x41\x30\xad\x8c\x56\x90\x8a\xce\x22\x15\x95\x62\x65\x04\x2a\x40\x37\x24\xab\x2d\x7b\x4a\x01\xc9\x49\x25\x36\x99\x4b\xf9\xaa\xcc\x77\x73\x37\x66\xcc\x46\x17\x06\x66\x33\x3d\xef\x98\xbc\x76\xf7\xfc\x8f\x6e\xbb\x7a\x55\x98\xa1\xb9\xda\xe0\x85\xc1\x6e\xa6\xcb\xed\xd3\x36\xee\x9e\x7b\xbc\x65\x72\xef\x09\xbd\x73\xef\x18\x33\x27\x0a\x0f\x4d\xbb\xc6\x67\x19\xd7\x30\x7c\x62\xa7\x5a\xcb\xc4\x51\xf1\x5d\xe0\xe0\x1d\x63\x07\xbf\x7a\xff\x0b\x60\xfa\xf3\xc3\xa6\xea\x32\xc1\xa4\x87\x50\x97\xc5\xe3\x86\x1d\xd9\xfd\x3a\xba\xe6\x89\xe7\x7a\xde\xf2\x49\xcf\x33\xcb\xd0\x2f\x4b\x3f\xa0\x3f\x7f\xe0\xf1\x69\xf9\x33\xe6\x2c\x07\xde\xab\x26\x4f\x91\xe6\xcd\xe0\xbd\x7e\x42\x5a\xdb\xe1\xd2\xde\x0f\x42\x13\xa5\xbd\xcf\x20\xfd\x5b\x2a\x51\x6d\x32\xe8\x4d\x5a\xad\x06\xba\xd4\x1a\x17\x3e\x53\xbe\x4c\x83\x49\x5b\x1f\x13\xbd\x76\x15\x60\xd5\x19\x46\x3b\xdb\x80\x0f\xbf\x89\xc8\xc3\x68\x1f\x28\xf6\xa5\x81\xa2\x10\x0f\x8a\x40\x42\xc8\x1d\xec\xad\xf2\x4d\x4a\x35\x53\xaa\x9c\x9b\x5c\x82\x07\x48\xc3\x5a\xaa\x14\x99\xa6\xe6\xb9\xb6\x5e\xb9\xd7\x3e\x0f\xb8\xf6\x6f\x9e\xf3\x7b\xfd\x6e\x91\x85\xfd\x1e\x9d\x43\x4a\x90\x97\xe1\x93\xb5\x6f\x51\xde\x8a\xbb\x17\xd2\xa3\x5a\xae\x8d\x3f\x00\xb6\xaa\x37\xbb\xa6\x8c\xb9\xe5\x46\xe7\x74\x0f\x7d\xb3\xac\x13\x26\x63\xbe\x96\x63\x3e\x6c\x58\x27\xe4\x1b\x34\x1a\x28\x8a\x5a\x3b\x0e\x36\x39\xab\xcd\x60\x52\x73\x26\xae\x01\xfb\x82\x7a\x9b\x5e\x67\xa5\x34\x5a\x68\x93\x4c\xad\x63\xb4\x83\x56\x34\x02\xa1\xb1\x28\xd1\xe5\x6d\x6e\x7d\x5f\x01\xd2\x2b\xf0\xfd\x22\x97\x80\x33\x78\xaf\x27\xdf\xa5\x4b\xc9\xc8\x19\x63\x80\xf3\x04\x3a\xdb\xf8\xf4\xbd\x8b\xb7\xab\x7b\xe3\xe3\x76\x57\x61\x66\x69\x8d\x21\x13\xfc\x82\x0f\xdd\x5d\x83\x37\x2e\xae\xcc\x07\xcb\xe5\xb5\xbe\x78\x8e\x3b\x8f\x69\x2c\xa0\xa6\x44\x3b\x78\xa1\xde\x66\x10\x45\x1c\xd4\x71\x30\x1f\x1b\x67\x63\xa1\xb1\x5d\x0e\xe4\xb0\x71\x34\x98\x82\x5e\xc6\x17\xd2\x90\x3a\xb8\x98\xcf\x25\x5a\x5d\xb6\x70\x88\x35\x18\x21\x43\xa8\x5e\xde\x4e\x71\x10\xf0\x59\xac\x51\xaa\xde\x08\x18\x8d\xbd\x55\x63\x7a\x69\xaa\x2e\x3d\xd8\xb6\x96\x9e\xe3\xfd\xc9\xa5\x6f\x55\x77\xef\x05\x36\xf0\xdf\xe1\xab\x5d\xf3\x81\x7d\x91\x79\xe9\xd0\x1b\xdc\x78\x2f\x76\x5b\x44\xf4\xb3\x95\x87\x75\xb7\x8e\x5f\xbc\xde\x30\xe8\x9e\xc9\x37\x6e\xb4\x2e\x07\xf6\xab\x05\xf8\xcc\xed\x2b\xe9\xe6\xf8\xaa\xe1\x85\x0b\xb7\xdc\x40\x8f\x68\xd9\xd7\x7c\xbd\x76\x55\xee\x9c\xa1\xf3\x67\x5e\x33\xfe\x96\x1b\xa3\x57\xd0\x37\xc7\x6f\x1e\x56\xc2\x2e\x94\x65\x8c\xe7\x30\xdf\xed\xa8\x79\xd1\x5a\x5f\xbe\x3f\x27\x27\x10\xc8\x32\xa9\xa1\xd3\x86\x5d\xd2\xa0\xda\x96\x15\x64\x8a\x8b\x42\x39\x01\xd2\x85\xef\xf4\x31\x5e\x2d\xcc\x87\x9c\x4e\xf4\x52\xde\x86\x18\x97\x63\xa5\x6c\x7a\xbb\xc3\x9f\xc5\x4a\x8a\xbc\xa1\x78\x79\x71\x62\xd3\x94\x7b\x4f\x99\xfb\x36\x72\xd7\x4a\xf4\xd8\x4b\x19\xbd\xa4\xc3\x20\x4d\x24\xe1\x8f\x6d\x58\x5d\xd4\x66\x51\xf6\x3f\x39\xf7\xf7\x86\xb7\xa5\x55\x11\xdb\xf2\xdb\x7a\x55\x24\x69\x95\xd6\x05\xfb\xc8\x75\x38\x26\x2b\xc6\xeb\xa0\xc7\x52\xda\x27\x1a\xd6\x60\x9d\x25\x50\x3c\x4b\x41\x87\x9d\x85\x06\x93\xc6\xd6\x14\xd3\x68\x4c\x6a\x35\x87\x2d\xab\x11\x62\x57\x00\x5e\x2e\x6e\x91\xaa\x1c\x5b\x39\xca\x72\xa8\x42\x1a\xb5\x22\x52\xb0\xe2\x93\x32\x16\x6c\x31\xfa\x12\x9d\x43\x2d\x3f\xdc\x8f\x36\x87\xe9\x6b\x06\x3d\x7b\xee\x54\xdc\x12\x5d\x05\x98\x89\x73\x0f\x82\x01\x07\x1f\xcf\x85\x13\x9e\x41\x75\x5b\xd1\x93\xa6\x83\xbd\xfa\x48\x7a\x36\x44\xea\x2a\x30\x7d\xd8\xe7\xc0\xb6\x7f\x50\xb4\xd8\xa2\xc6\xc6\xd5\x00\x68\x83\x9a\x86\x2e\x27\xeb\x68\x8a\xb1\xac\xd1\x24\x18\x74\x94\x55\x27\x34\xc5\x74\x36\x9a\x31\x42\x20\xa1\x47\xb9\x00\xd6\xb4\x09\xfb\x4a\xe8\x95\x8d\x6a\x51\x3e\x76\x03\xd2\xb5\x81\x84\x1e\x25\x17\x5d\x12\xaa\xdd\x49\x72\x99\x97\x4f\xe0\x73\xd4\x52\x4c\xe8\x54\x08\x7f\x6b\xa2\x42\x2e\xb1\x27\xf8\x60\xd5\x6d\xbd\x03\x93\xcd\x04\x5b\xa6\x2b\x24\xe3\x35\xc5\x34\x33\xbd\x24\x1b\x6b\xa1\xba\x46\xb3\x80\x4e\xa7\x31\xb1\xac\xc6\x66\x05\x96\xa6\x18\x00\x38\x22\x57\xe9\x0c\x2a\x43\x53\x4c\x65\xd3\x52\x0a\x18\x4f\x69\x4d\x62\x15\x2f\xbd\xcb\xb9\x1c\x69\xb4\xe1\xf2\x44\x5d\x4a\x10\xa0\x4c\x98\x9e\x3c\xa6\x8e\xf2\x52\x33\xa3\x5d\xcc\x16\x0b\x74\xb9\xb5\x1a\x8d\x5b\x20\x57\x39\xc5\x99\xc0\xed\x02\x6a\x17\x70\xd9\x45\x4e\x6b\xd3\xd2\x6a\xad\x41\x10\x3a\x8a\x00\x16\x89\x40\x2f\x02\x03\x23\x8a\x3c\xc5\x1b\xea\x13\x00\x66\xa6\xb6\xd5\x73\x52\xf9\x9c\x50\x25\x45\xad\x23\x47\x82\xb6\x91\x5f\x1a\xd6\xbc\x3c\x53\x11\xcb\x44\x65\x99\x52\xc6\x4e\x4f\x3a\xf9\xcd\x16\x74\xfe\xe0\xf3\xbf\xba\x80\xc7\x78\x45\xbf\x49\x0b\x1d\xe8\xa5\x20\xa8\x60\xf7\x35\x4e\xb7\xa2\xd3\xf9\x40\xc7\xd4\x9d\x7c\xe5\x75\x74\xe8\x81\x23\xf7\xbb\x46\x8e\xbd\x7e\xc3\x33\x5d\xdf\x18\x30\xc8\xb5\xf5\x61\x69\x9d\x03\x58\x36\xee\x67\x1a\xb0\xcf\x95\x45\x35\x46\x0b\x3d\xbc\x51\xab\xd5\xd9\x28\x1d\x4f\xc1\xec\x80\xe8\xc0\x26\xc2\x64\xd4\xd4\xc7\x74\x46\x60\x20\xf5\x8a\x7a\xa3\xce\xca\x64\x92\x9a\xe2\x34\x13\x8b\xc5\x01\xf3\xd0\xba\xb1\xb4\x55\x5d\x66\x27\x40\x9a\x00\xc9\x61\xac\x48\xeb\x2e\x95\xfb\x08\xb8\xfb\xb7\xa3\x2f\x1f\x7f\xf7\x0f\xf0\x21\xf1\x6a\x80\x6b\xe0\xdb\xd5\xa0\xf2\x93\x53\x3f\xa2\x93\xcf\x4d\x5e\xda\xbd\x79\xcc\x94\x05\xdd\xe8\xfd\xc7\xd1\xd3\x07\xbe\x7f\xc3\x66\x23\xae\x0e\x1a\x78\xe2\xa7\x8f\xbf\xf8\xf3\xea\x9f\x67\x2f\x59\x3d\xe7\x2b\x69\xde\x03\xb6\x11\xb7\x28\xe7\x6f\x6c\xb4\x82\x82\x58\xdd\x1a\x0c\x02\xc7\x69\x68\x8d\x83\x72\xf8\x1c\xb4\x1e\x62\xdf\xdb\x4e\xe1\x83\xa8\x87\x64\xd2\x0d\x6d\x82\xf8\x17\x35\x1a\x2c\x3f\x1a\xa3\x8e\x4e\xb8\x41\x69\x3b\x12\x51\x3a\x7a\x49\x18\x9e\xb4\x19\xc9\x86\x65\xb9\x11\x39\x17\xfb\x48\x6e\x90\x48\x0e\xd0\x5d\xd0\xdd\xe8\x39\x70\x67\xdd\xa4\x38\xc8\x06\x67\xb1\xd7\x34\x68\xd4\x73\x4b\x67\xc4\xfa\x1c\x07\x87\x50\x1d\xf8\xd0\xb5\x75\xe4\x81\x5d\xd8\x74\x1c\x02\xff\xe9\xdf\x54\xdb\x2b\x11\x83\xb2\x9f\x09\x21\x12\x83\x9a\x39\xaa\xdb\x32\xa9\xfa\x80\x0e\x06\xcd\x21\xda\xdf\xc7\x9f\x6d\xb0\x26\x33\x75\xc9\x98\x95\x60\x62\x48\xef\x27\x75\x36\xbf\xc9\x98\x18\x90\xf6\xf9\x08\x6c\x69\xf6\x6d\xd9\x59\xf2\xef\x24\x6b\xaa\x02\xd8\xe7\x5a\x85\x7d\xac\x3c\x6a\x73\x74\xa8\x55\xb0\x99\x1d\x6e\xaf\x91\x31\x61\xd7\xdf\x66\x32\x6b\xb2\xcd\xb4\x33\x9b\x29\xc8\x77\x0b\x56\x7c\xee\x1d\x72\x40\x07\xad\x51\x97\xb7\x97\xd5\xea\xb7\xdb\x80\x91\xc7\x0e\xa3\x2e\x27\x4c\x65\xf8\x4d\x66\xab\x5f\xd7\x10\xa3\xfc\x26\xbf\xcf\x4f\xdc\x30\x23\xc5\xe0\x6f\xdd\x29\x41\x50\x84\x20\x22\xa7\x84\xb0\x08\xcb\xd7\x7e\x64\x35\x5b\xa5\x5f\x5a\x15\x0c\xe2\xe0\xb6\xd2\x4e\x54\x75\x0a\x5d\x30\x50\x49\xf2\x2f\xf8\x3f\x2e\xe9\x76\xe1\x9f\x63\x7d\x75\x63\x73\xcf\xec\xea\x6e\x35\xc2\xd5\x12\xd0\xe0\x34\x74\xe6\xab\x6b\xfd\xd7\xba\x81\xc3\x0d\xda\xfb\xd1\x2b\x81\x8c\x44\x6f\xd3\x5a\xef\x01\x34\x44\x3c\xc2\x74\x1f\x49\x4f\x90\x51\x07\x5f\x67\xb6\x3c\xb0\x66\xcd\x03\x8f\x5f\xa7\x74\x37\xc5\xdd\xeb\x6f\x93\xe5\x1f\x2b\xc8\x6f\x95\x19\xda\x65\x51\x37\x07\x19\x8a\x51\xeb\xd4\x7a\x4e\x75\x53\x8c\x63\xa3\x2c\x0e\x8a\x58\x23\xa3\x08\x08\xe6\xd2\xe5\x30\xbd\x95\xaa\xa0\xaf\x52\x8a\x10\xc4\x1a\x92\xf0\x07\xf0\xf9\x20\xaa\x27\x8e\xf2\x97\xdc\x9f\xc0\xaa\x42\xd7\x33\xd5\xcf\x10\x6f\xf9\xca\xc4\x84\x70\x20\xed\x61\x33\x8e\xab\xbd\xd4\xdc\x68\xad\xd9\x44\x43\xbb\xdb\xad\x56\x3b\xa0\x09\xeb\x91\x20\x8d\xcf\x0b\x60\xc9\x20\x60\x97\x2b\xc7\x0c\x5c\x66\xa0\x26\xff\xb7\x74\xb4\x63\x55\x62\x07\x7a\x3b\x56\x25\x76\x3b\xa7\xd7\x5b\xa4\xb6\x6e\x32\xa3\xc2\x76\x19\x55\x42\x14\xc9\x48\x49\xa1\xe0\x2f\x6d\x4e\x64\xb0\xb4\x92\x4d\xd5\xfb\x93\x7e\xe5\x64\xb9\x18\x6f\xb1\xd1\x8e\x3d\x5d\x80\xb1\x0c\x9d\x7f\xeb\x93\x73\xdb\x01\xff\xd2\x73\xdf\x1a\xd0\x69\x76\x78\xe3\x98\xab\xf3\x40\x45\x10\x1d\x83\xc3\xf7\x1d\x2f\xdd\xf7\xf0\x97\xaf\xbe\x08\x06\xef\x78\x71\xb7\x7d\xd8\x95\xf3\x37\x3e\x53\xb6\xe0\x2a\x65\xc6\x04\xe6\xad\x90\xe9\x8b\x7d\xd0\xc1\x09\xff\x5f\xa9\x87\xee\x97\xf8\x1e\x72\x92\xfc\xfe\x57\xc6\x81\x79\x9d\x4a\x54\x89\x11\x44\x17\xd5\xc6\xd6\x55\x62\x97\xd6\x54\xe3\xb3\x8e\x63\x58\x1e\x3b\x63\xd8\x87\xca\xa5\xc6\x47\x2b\x75\x3e\xe0\xf7\x6b\x82\xac\x4f\xc3\xc2\x7c\x9b\x2d\x2f\xc3\xe9\x33\x88\x5a\x9d\x4f\x57\x1f\x03\xb9\xc4\x50\x04\x28\x9f\x51\x74\x62\x35\x66\xf3\x07\x54\x01\x7c\xdc\x55\xb6\x56\xe8\x39\x8a\xc0\x16\xe5\xb7\x46\xa4\x6e\xa5\xc4\x52\xb6\xe3\xd2\x68\x37\x65\x96\x8d\x69\xc6\xe4\x7e\xf4\xe0\xe5\xe2\x5f\xfa\xbe\xb6\x36\x06\x4e\xb8\x34\x1c\x56\xac\x0e\x4d\x05\xb1\x6e\x7e\x05\xf3\x2a\x4a\xa8\xdb\x11\x37\x0b\x2c\x16\x8d\x59\x8f\x75\x1b\xe6\xd6\xef\xd3\x1b\xac\x5a\x9d\x99\x70\x9a\x89\x39\x15\xcc\x66\xca\x62\x57\xd9\x25\x16\xb1\xd2\x4e\x1a\x45\x92\xa0\x4f\x40\x04\x61\xad\xa6\xb4\x6f\xb6\x71\xe5\xdb\x70\x29\xc7\x7e\x6e\x90\x01\x13\x56\xfc\xe6\x34\xee\x06\xa3\xed\x8a\xae\x06\x63\x07\x4c\x34\x95\x56\x56\x5a\x5b\x73\x05\x9e\x94\x15\x35\x78\xb0\x65\x3a\xc3\x31\x34\x61\x47\xde\x7f\xa2\x8b\xb0\xe0\x7e\x9b\xc8\x55\x33\x63\x88\xfe\x83\xdf\x4b\xfa\x6c\x1e\xa8\x91\xeb\xb5\x44\x73\x08\x88\x4f\x00\xe6\x11\xd1\x26\xa8\x52\xf5\x5a\xf2\x5d\x0d\xd1\x97\x43\x65\x7d\xb9\x80\xa2\x1c\x8f\x81\xac\x2c\xfc\xf6\x8c\x27\x2e\xfe\xf1\x48\x86\xdf\xa1\x49\xd5\x6b\xc9\xf1\x26\x1b\xc7\xef\x1f\xa1\xdc\xed\x78\x94\xfa\x2e\x02\x21\x04\xdc\x1b\xdc\x59\xb4\x98\xd4\xb0\x74\x32\x66\x82\x58\xba\x46\x45\x4b\x74\x56\xbd\x80\xcd\x86\x99\xf7\xe0\xb5\xc5\x8b\xee\xc9\xf2\xd3\x51\x0a\x02\x01\xc2\x4c\xa3\x0d\x3a\x75\xac\x5a\xef\x33\x3a\xd5\x0d\x31\xa7\x4d\x48\x69\x08\x25\x62\xb2\x4b\x46\x51\x99\xa8\x92\x80\xbe\xa8\x4a\x7a\xae\x30\xe0\x06\xff\xe0\xbb\xcb\x61\xd3\x86\x9e\xbf\x37\xc5\x92\xa1\xd3\x6e\x93\x0d\xfd\x96\x16\x39\xb5\x47\x3b\xc0\x68\x66\x56\x2a\x7c\xda\x57\xdf\x36\x78\x02\xd4\xb2\x8b\x3f\x68\xdc\xec\x66\xaa\x1c\x5b\xf6\xbc\x22\x2e\x57\x17\xf2\x09\x42\xc8\x49\x71\x6c\x65\x45\xa9\xc7\xe6\x69\x8e\x95\xbb\x74\x06\x1c\x85\x84\x0d\xb4\x8d\xc9\x0f\x18\x02\xcd\x31\x8d\x41\x4c\x61\xaf\x48\x50\x25\x49\xb0\x92\x56\xd0\x92\xa0\x22\x92\x28\x36\xf6\x85\x39\x7f\xb2\xfe\x54\x01\xe2\xa5\x53\x91\x55\x22\x38\x26\x5a\x86\x1b\xf1\xc4\xf3\x8f\x01\xfe\x86\x0f\xd1\xd2\x38\xfa\xec\xd9\x9f\xd1\xcf\x8f\xa3\x73\xdb\x3e\x00\x4b\x7e\x1b\xbc\x29\xb6\x65\xf8\xe4\x2d\xdf\x2f\xdb\xbf\x67\xea\xb1\xba\xce\xc0\xd0\x79\xd6\x1b\x9b\xff\xd8\xb0\x63\x4f\xed\x84\x62\xb6\x67\xfd\x7a\x74\xfe\xc0\x0f\x68\xe2\x97\xd7\x5f\xbf\x19\xb8\x0f\xfc\x02\x56\x9f\xf0\xb7\x7b\xbf\xe3\x0e\xf4\xed\xfd\x8f\x1e\xed\x5c\x05\xba\xa0\x67\xe7\xef\x06\xed\x1e\x78\xe8\xc1\x80\x53\x8e\x1b\x71\x14\xcc\xf5\x90\xee\xba\xba\x45\xb3\xb0\xf9\x10\x05\x83\x46\xab\xd7\xe9\xb4\x82\x59\xc5\x73\x4e\x1b\x4d\xbb\x2c\x06\x83\x4a\xeb\x10\x74\x46\x5e\x6b\x95\xd1\x33\xe5\x28\xab\x35\xba\xb3\x9c\xa9\xc2\x27\x43\x43\x34\x3d\x27\x69\x7b\x52\x97\xef\x17\x29\x73\x59\x98\xeb\xa0\x9d\xfd\xc1\x61\xf4\x7b\xe1\xca\x8d\xe8\xf7\xf5\x20\xb7\x5b\xd3\xe6\xc2\x22\x10\xec\x06\xb2\x78\xa6\xba\xbc\xc7\x7e\xf4\x1c\xfa\xe0\x3e\x30\xf1\xe4\x3a\xa6\xba\xe5\xd1\x11\x80\x5a\x09\xae\x6a\x79\x14\x14\x83\x7b\x23\xb5\xb2\x9f\xdb\x8c\xe9\xcc\x55\x6a\x42\xaf\x8c\x96\x01\x33\x6d\x62\x78\x95\x9b\x11\x59\x1d\x14\xb0\x9b\x22\x8a\x26\xbb\x4e\x67\xf2\x7a\x78\x81\x12\xc6\xc4\x18\x8a\x32\xd1\x2a\x77\x73\x4c\xa5\xc2\xb6\xc3\x24\x36\xc7\x4c\x42\xeb\x4b\x56\x47\xd1\xa5\x77\x49\x12\x2c\x74\xc2\xe0\xca\x05\x96\xe4\xbf\x64\x42\x38\x99\xde\xbc\x16\x8c\x0c\x80\x70\x36\x78\x3d\x88\x2a\xb2\xc1\xbc\x64\xae\xf3\x35\x74\x0f\x38\x9b\x48\x75\x32\xc7\x1e\x7b\xec\x99\xa7\xa5\xdc\xb0\xbe\xe5\xa4\x94\xec\x94\xfd\xc8\x6b\xf0\x7a\x93\x09\x71\xb1\x68\x51\x0e\x0f\x7d\x14\x95\x95\x65\x70\x8b\x4e\xa7\xc5\x62\xb5\x1a\x78\x58\x58\x90\x69\x6e\x88\x65\x1a\xa1\xaf\x29\xe6\x76\x40\x68\xc5\xfe\x86\x55\x13\xc4\x0a\xcb\x96\x72\x24\x85\xaa\xd6\x7e\x64\xeb\xce\x61\xc0\x19\x41\x02\xce\x4a\xc6\x82\x61\xb4\x80\xdc\xed\x29\xae\x82\x98\xd6\xbb\xc6\x3c\x67\x1d\x98\x79\xf5\x4f\x5f\x5e\x38\x73\xf7\xe3\xb1\xf6\xf5\x68\x6a\xcf\xd1\xe8\xec\x4e\xa7\x19\xe8\xac\x6a\xa6\xe6\xcc\xb1\x5a\x71\xc8\xf0\xba\xe6\xb1\xb3\x99\xea\x51\x7f\x8d\xdc\xb2\xe9\x91\x23\xfd\x77\x2c\x18\x76\xea\x39\x0d\xda\x86\x7c\xb0\xf3\xc2\x95\x3b\x3b\xce\xbc\x2a\xbe\x73\x78\xfb\x31\xfd\xc7\xd5\x91\x20\x00\x50\xd9\x17\x7f\x50\x19\xf0\x79\x0a\x10\x4c\x23\xa7\xcb\x24\x8a\x8c\x0f\x06\xb0\x56\xf3\x99\x5d\x4c\x36\x0e\x07\x82\x5e\x7b\x73\xcc\x2b\x4a\xc9\x5c\x46\xcc\x82\x59\x78\x7b\x9c\x94\x96\xe0\x37\x41\x09\xdf\x44\x3e\x4f\x69\xa6\xa7\x0d\xda\x43\x24\x55\xb3\x10\x11\x28\xbf\x52\xcd\xed\x83\xa9\x62\x6e\x4e\x6a\x2e\x2c\x0f\x40\x52\xcb\x10\x9e\x79\xba\x16\x6c\x02\x61\xa5\xac\x7b\xd7\x5c\x74\xff\x54\x70\xb1\x10\xe9\x36\x6d\x21\x65\xdd\x13\xd1\xc1\x2f\xd1\xb7\xe8\xc4\x7f\xe7\xb2\x2b\xe2\x47\x80\x17\x74\x94\xca\xbb\xd1\xba\xd3\x9e\x27\x1e\x06\xf4\xdc\x27\x9f\xc4\x92\xe8\xf5\xc7\x77\x13\x3f\x11\xef\xdf\x14\xe9\xbe\x7f\x42\xb4\xda\xe5\xc6\x11\x0e\xe3\x87\xc1\x20\x45\xf9\x05\x37\x13\xc2\xbc\x85\x33\x70\x30\x90\x61\x93\xa2\x18\x93\x25\x3b\xdb\x0c\xd7\x40\xb0\x08\x82\x61\x10\xb8\xa0\x56\x0b\x5d\x38\x60\xa4\x48\xdb\x99\x84\x28\x41\x1c\x0f\xc2\xcd\xbf\x31\x99\x8c\x07\x5a\xfb\x20\x91\x94\x87\x82\xa3\x86\xc0\xbb\xc0\x39\xf8\x91\xae\xc0\xfb\x6d\xc2\x17\x19\xb7\x28\xac\xf8\x22\x43\x88\xb3\x12\x41\xe7\xdf\xfe\xe4\x1c\x38\x3c\x14\x1b\x9c\xde\x67\x4f\x4b\x4e\xc9\xe2\xb5\xc4\x29\x39\x5e\xba\xf7\x91\x2f\x5f\xcd\xd2\xa3\x8e\x72\x8c\xc0\x52\x52\x4d\x89\x40\xfa\x2e\x28\x2d\x64\x18\xd6\x44\xd3\x46\x56\xcb\x5a\x78\x95\x4a\xa4\x39\x23\xd7\x1c\xd3\xa9\x8d\x46\x95\x1a\x3b\x81\x04\x3a\x25\x12\x51\x24\x32\x55\x85\x95\x02\x3a\x90\x2a\x17\x60\x80\xdc\x2e\xc8\xfd\x42\xc4\x75\x85\x21\xf8\x49\xef\x09\x57\x9c\x1d\xb7\x10\x21\xf4\x11\x14\xc1\x88\x1f\x51\x95\xb5\x6e\x23\xa8\x2a\x15\xc0\xe7\xc8\x4f\x3e\x48\xd5\x02\xb3\x27\xba\x09\x7d\x0f\xfa\x5e\x27\xf9\x34\xf7\x62\x3b\xc8\x4a\xb1\xae\x81\xd0\xc6\x73\x1a\xad\x96\xd2\xab\xd5\x3a\x8a\xc3\xa7\x1d\x42\xa3\x1a\xe8\x40\x63\xcc\xc0\xe8\x74\x90\x31\x6a\x79\x68\xfd\x1f\x68\x93\xf3\xe9\xa2\x4c\x62\x04\x82\x43\xbd\x0f\xa2\xef\xe8\x31\xa0\xe1\x20\xfa\x29\x5c\x57\xfb\xe6\x98\x8f\x73\xc1\x70\xb4\x8b\x84\xe0\xe4\x2b\x6d\x03\x83\x94\xda\x09\x3e\x03\xaf\x13\xc1\xee\x1a\x1a\x2d\x54\xf1\x5a\x9d\x4e\xef\xd0\x68\xec\x7a\x23\x51\x46\x58\xfd\xe8\x79\xc6\xe3\x36\x68\x04\x28\x34\xc7\xec\x16\x16\x42\x16\x4b\xb7\x49\xa7\x4a\x64\xc8\x25\x21\xbf\x4c\x7d\x7a\x1a\x6d\x52\x4d\x4e\x92\x38\x69\xfd\xa0\xb2\x7e\x92\x58\xdf\x08\xe6\x83\x35\x64\xed\x3e\xe9\x3d\x71\xdc\xd9\xb1\x0b\xc8\x62\x02\x2d\xfa\x78\x24\xa3\xb7\xd6\xad\x07\xe5\x25\x02\x16\xe8\xce\xf4\x0b\xe7\x97\x25\x16\x95\x7c\xa4\x2d\x2a\x4d\x19\xb1\x5e\x15\x25\xdf\xc9\x46\xf0\x00\x8c\x06\x01\x13\x6f\x35\x9b\x2d\x14\x0d\x35\x04\x69\x01\x52\x06\xc6\x61\x37\x03\x56\xc3\x36\xc6\x2c\x36\x9d\x46\xc3\xeb\x8c\x2a\xa3\x68\x84\xbc\x55\xbe\x11\x97\x17\xf8\xdf\x39\x01\x81\xd4\x25\x7d\xda\x6a\xc3\xe7\xc9\x6a\xbf\x88\xfe\xac\x95\x80\xb4\xa7\x80\xfe\xa0\xbc\xed\xca\xcb\xab\x1f\xff\x84\xce\x4e\xdf\x01\x22\x0f\x3f\x62\xda\xa7\x4b\xb3\x56\xb2\xa8\x91\xd1\x62\xbf\xd9\x63\x15\x8c\x3e\x40\xa6\x15\x67\x99\x4c\xd0\x67\x35\xb3\xd9\x2a\xb5\x3a\x40\x31\x46\xa6\x39\x26\xf8\x4c\x46\xa3\xda\x64\x22\xca\x06\x3a\x69\xb5\x2c\xb8\xc9\x4e\xe5\x48\x4a\x42\xd2\x6d\x5a\xea\x92\x5f\x09\xba\x3a\x43\x6c\xd3\xa4\x04\xb9\x52\x8d\x1f\x0a\x84\xf1\xb6\xbc\x37\x03\x9d\x9a\x61\xb9\x63\x97\x3d\x8a\x4e\xf5\x74\x0c\xbd\xe6\xc9\xab\x11\x2b\x20\xdb\xe1\xe7\xb4\xe5\xe8\xab\x4e\xdc\xea\xf9\x73\x41\x36\xea\x43\x47\xe3\xcf\xd1\xd1\x05\x73\xd1\x3e\x70\xe5\xd2\x3b\xc6\x74\x60\xe8\xb1\xf1\xed\x86\x63\x0f\x75\xa9\x42\x5f\x83\x4e\x7e\xef\xa8\x09\xe7\xc0\x5c\xc9\xde\x61\x09\x62\x49\xac\xee\xa4\x3c\x78\x5f\x8a\xdc\x5a\xbb\x49\xa7\x76\x51\x00\x38\x69\x8f\x86\x25\x21\xbb\xcb\xa4\xe5\x32\xbc\x98\x11\xba\x31\xa6\x73\xa9\xd5\x9c\x46\xe3\x69\xc0\x61\xba\x05\x70\xd6\x74\xd6\xaa\xda\xd6\xc8\xa7\x33\x86\xad\x5a\x96\x91\xb4\xd2\x91\x7d\x91\x47\xd9\xfb\xc9\x88\xbe\x00\x71\x6e\xb3\xd1\xb9\x86\x1f\x0a\xb3\xd0\xb9\xf2\x5a\xb0\xfe\x04\xd3\x1b\x4d\xbf\x6a\x53\x1d\x9b\x8b\x7e\xcc\xe2\x5f\x9c\xf4\x05\x7a\x14\x6c\xfd\xf6\x00\x60\x41\x1d\xf8\x06\x39\xd4\x83\xd7\x0e\xb7\xe5\xbf\x76\x20\xe0\xdb\xfd\x10\x08\xc9\x36\x1b\xff\x4f\x75\x1f\xde\x9f\x00\x15\xa2\xa6\x45\xab\x7c\x4e\x9b\x98\x2d\xed\x4e\xc8\x82\xb7\xc5\x02\xb3\x9d\x6c\x38\x68\xb5\xe6\x08\x06\x83\xd1\x18\x66\x28\xbd\xa0\x6f\x8e\x65\xdb\x04\xc1\x68\xb1\x84\x9a\x63\x16\x68\x82\x5e\x35\x6d\x14\x14\x31\x6b\xd3\xd3\x01\x92\xe2\x25\xb4\xe5\xac\xd5\x86\x55\x54\x2a\x2d\x1e\x97\xd9\x36\x4e\x97\xbe\x6d\xae\x7e\xe8\xc5\xe9\xa4\x40\x1e\x84\xe7\xd1\xef\xfc\x5f\xfb\xb7\xa9\x6b\xfc\x65\x7c\xbc\xb6\xff\xc3\x16\x62\xfe\xc3\x58\x47\x6c\x93\x72\xe5\xd9\xd4\xe4\x68\xfb\x80\x98\xe9\xb0\x98\xb3\xf0\x1e\xfa\xe9\x6c\x81\xe5\x4c\x58\x63\xe8\x39\x81\xce\x72\x88\x7c\x28\xe8\xa7\xb5\x26\x6d\x43\x2c\xcb\x62\x32\xe9\x05\x21\xbb\x81\x74\xb7\x18\x3d\x1c\xd0\x5b\x2f\xcf\x7e\xeb\xb8\xe4\x32\x7b\x5a\x49\x66\xa4\xc8\x27\xee\xd2\xbd\x65\x0b\x13\x7b\x5b\xa2\xc9\x77\xa3\x9f\xfa\x49\xe7\xaf\x99\x9e\xf9\x0f\xdb\xfc\x6b\x69\x83\x88\x16\x62\xd3\xe1\xb8\xec\x66\x83\x8b\xaf\xa0\x21\x6c\x06\xf7\x3b\x35\x80\xda\x12\x1d\x98\xdb\xc3\xdf\xcf\xa8\xed\x16\xc1\x0f\x2b\x0e\x96\x55\xf4\xd6\xf6\xeb\xa1\xea\xe4\xec\x34\x88\x72\x3a\x07\x56\x47\xc7\xc4\xaa\xab\x8d\x65\x40\x0d\xcb\x2a\xa2\x2a\x02\x0e\xe7\xb7\xf5\xee\x4d\x86\xa6\x34\xc7\x22\xdd\x8a\x60\xa8\xc2\xa0\x0a\x85\x54\x06\x68\xab\xa8\x28\x68\x8e\x55\x30\x36\xd8\x1c\xb3\xb9\xd3\x8b\x3e\x1c\x64\x84\x37\xb9\xf3\x56\x0a\xbe\xaa\xa4\xfb\x86\x37\x71\x1c\x51\x5a\x94\x42\x23\x49\x3b\xc6\x64\x59\xec\xd2\x3d\x1a\x2d\x37\xd2\x48\xd7\x82\x06\x5a\x41\x22\x51\xf0\x2e\x52\x55\xee\x1c\x1f\xc4\xab\x07\x23\x62\x65\x0a\x32\x52\xae\x8a\x91\xcb\xde\x39\x86\x37\xd0\x2f\x96\x45\x4a\x16\x5e\x73\x6d\xa7\xab\x97\xa8\xd0\x19\xa6\x63\x60\xf4\xcc\x65\xdd\x6e\xda\x3b\xe3\xfd\xf7\x37\x2f\x5e\xb4\x71\x73\x55\x41\x15\x18\x38\x69\xcc\xf4\xbb\x2a\x2f\x52\x5d\x3e\x78\x72\xe6\xd1\xfa\xcd\x91\x41\xed\x4b\x06\xd9\xc7\xea\xdc\x7e\xff\xaa\x15\xb7\xed\x3e\x3c\x6f\x3d\xd6\xc3\x3f\x0d\xbd\x7e\xe0\xc2\xac\x22\x7f\xae\xff\xea\x99\xe1\x76\x59\x9d\xfd\x39\xfe\xed\x37\x4c\x59\x3b\x34\xc3\x6a\x1a\xd8\xaf\xdf\x88\x53\x9f\xf7\x8c\x4d\x5d\xd0\x67\xc7\xbe\x0c\x30\x12\x3d\xf4\x79\x9f\xd2\x9c\x50\xcc\xd5\xee\x51\xf7\xc3\xb3\x6e\x3b\x1c\x14\xb7\x4f\xbb\xe1\xd1\x81\x16\x95\xbb\x44\xda\x83\x37\x71\x1c\x37\x9d\xbd\x99\x6a\xa2\xae\x8d\xf6\x34\x15\xa8\x23\x3d\xba\xe5\x3a\x3d\x6e\x97\xd5\x66\x73\xe9\x3c\x45\xdd\x22\x05\xaa\x00\x15\x18\x58\x4d\x51\x03\xfa\x74\xa9\x56\xd7\x17\x15\xe9\x9d\xb9\x56\xa8\xeb\xd1\x45\xa7\xeb\xd2\x03\x7a\x3a\xd6\xbb\x43\x3e\x9f\xd1\x85\xb7\xc6\xe5\x89\x7a\xc4\xa6\x98\x47\xba\x81\x4d\xae\x6d\xa4\x46\x19\xa4\x6e\xb6\x57\x45\x12\xc9\x96\xd6\xcb\x9d\xb6\xe0\x7c\x59\x67\x5a\x81\x46\x49\x55\x2a\xfc\xe3\xb2\x4a\x95\x0b\xd8\x6d\x25\x17\x9e\xf2\x3e\xe1\x6d\x0a\x48\x97\x5d\x06\xa9\x49\x3d\x52\x30\x64\xed\xa6\x15\xc3\x23\x4b\x6e\x0c\xec\xde\xd4\xd8\xf5\xde\xd0\xb7\x59\x3b\x56\xcf\x3a\x3a\x68\x7d\xf9\xa0\xaa\x92\x26\xbc\xac\xae\xcc\xec\x45\xc3\xc7\xdf\xbd\x66\xda\xc2\x87\xde\x99\xb9\x6e\x4a\x73\x30\x36\x66\x62\xc5\x33\xdc\x77\xa0\x73\xb8\x5b\xdf\xa1\x1d\x7b\x2f\xe9\xb5\xa7\xcf\xd4\x86\x2a\xb7\x23\x54\x5d\x18\xad\x79\x68\xe8\xb0\xfc\x8a\xf5\xb6\xb9\x9b\x9c\xa0\x33\x7a\xf3\xc5\x5e\x65\xd2\xc2\xde\x93\x71\x75\xaf\x79\xb7\x0b\x8c\x38\x7f\xd8\x8a\xad\x7e\xd1\xd6\xb5\xbc\x87\x27\xcb\x73\x2c\x98\xa3\x67\xaa\xf0\x8b\x9a\x39\xc4\xbf\x3d\x83\xed\xce\xeb\x52\x7f\x57\x9f\x68\xb6\x91\x32\x00\x03\xc4\x27\x19\xd0\x6a\x15\xad\x72\x61\x1f\xde\x6d\xd4\x41\x1d\x19\x36\x07\x69\x8b\x5e\x45\x7a\x97\x6a\xa4\xa0\xa9\x28\xd2\xda\x0b\x69\x03\x76\xe0\x17\x31\x97\x24\xb5\x6a\x4b\x1b\xe4\x45\x53\x7e\xf8\x14\x99\xe3\xb5\xf6\x9e\x26\x73\x1e\xb0\xb7\xd7\xdf\xbc\x11\xd8\x37\xaa\x77\xee\xf1\x93\x29\x5e\xa5\x38\xee\xf8\x56\x9e\xe2\x35\xf8\xe9\xff\x80\xef\xe3\x6b\xae\x25\x23\xbc\x56\xed\x24\x23\xbc\xd0\xdf\x17\xa5\x18\xef\x08\x1a\xc2\xb1\x92\x2d\xe9\x15\xcd\x66\x58\x4a\xed\xd4\x38\x75\x76\x87\x43\xa3\x15\x05\x41\xcb\x42\xb7\xcb\xc1\x08\x46\xca\xae\xb3\xd7\xc7\xd4\x3a\x9b\x56\xc6\x3f\x54\xe0\xab\x52\xe1\x6c\x82\x56\x79\x62\x02\x90\xc2\x71\x86\x25\x70\x88\xb0\x1c\xeb\x18\x8b\x44\x76\xed\xda\x35\x99\x04\xe9\xb9\x04\x7d\x80\x7e\x22\x50\xcf\x57\x5e\xd7\x3f\x8b\x05\xa2\xa6\x57\xc5\x41\x00\x0e\xd2\x37\xdc\x45\xa0\x9e\xff\x3e\x25\x21\x3d\x83\x92\x51\x77\x1d\xa0\x67\xb4\xb4\xb4\xaf\x83\x37\xc8\x35\x6e\x89\x59\x89\x06\xca\x4b\x15\x60\xab\xa1\xb7\xe7\xe5\x41\x1c\x8e\x6b\xa1\xb6\x5d\x61\xe0\x89\x8b\x3f\x47\x4b\xf4\x74\x5d\xc0\x69\xc2\x9f\x9d\x42\x5e\xce\xc7\x39\xc0\x98\x93\x99\xd3\x9c\xb3\x2c\x67\x5d\xce\x5d\x39\x9c\x1a\x1a\x73\x8c\x39\x3c\xc5\x5b\xa5\x42\xd1\x8c\x4b\x8a\x2c\x25\x48\xe0\x91\x12\x6e\x51\x24\xbf\x6d\x25\x41\xeb\xd9\x8a\x30\x2b\x14\x96\xea\x45\xa5\x3a\x2b\xe0\x83\x52\x4b\x2c\x96\x4c\x7b\x3b\x20\xc3\x52\xbe\x8b\x56\x25\x46\x2c\x5e\xed\x1b\xeb\x07\x87\x76\x82\x59\x33\x46\xcd\x6a\x37\x69\xf6\x22\xe0\x43\x6b\xa7\xfa\xc6\x87\x7a\x4e\x1d\x3f\xa9\xdb\xc8\x2b\x99\x87\x65\xac\xca\x3f\xd0\xe4\x8f\x13\x63\x17\x5b\xd6\x98\x8c\x8f\x3f\x0a\x56\xe6\x67\x04\x33\xe8\x9b\xd0\x6a\x93\x15\xbf\x08\xed\x7b\x5c\xca\xf9\xcb\x35\x0a\x94\x1e\xdb\xff\x7c\x6a\x62\xb4\x53\xd0\xed\xa6\x32\x31\x5f\x85\x05\xa2\xcf\xea\x0d\xbb\x82\x5e\x60\x74\xdd\xe5\xa2\xa7\xbb\x96\xb9\x0e\xb8\x2e\xba\x98\x3c\x17\xfe\x41\xa6\x8b\xd6\x41\xaf\xcb\xeb\x62\xb4\x5a\x53\x3d\x01\x36\xf1\xb7\x01\x36\x49\xac\x00\x19\x3b\x8a\x99\x06\x45\x6d\x40\x4e\xe8\xb4\x4b\x4f\x56\xba\x69\x56\xd4\xa6\x9d\xcd\x0a\xcb\xdd\x0a\xd2\x72\x30\x3b\xef\x41\xef\x1f\xf9\x08\x25\xb1\x2e\x17\xaf\x0b\x94\x45\xca\xfa\x74\xed\x51\xdc\x2e\x82\xba\x16\xe5\x30\x6f\x0c\x9d\x52\xef\xac\xe8\x9a\x15\xed\xd1\x48\xef\x7d\x1b\x3d\xb3\xff\xbb\x37\x15\xe8\xcb\x5b\x37\x98\x1c\x19\x0e\x21\x6e\x3a\xdf\x69\xf9\x64\x93\xc3\xeb\x90\xef\x22\xee\xc3\xe7\x8a\xd4\xd1\x5a\x48\xbf\x07\xa0\x38\x48\x73\xb4\xc1\x6a\xb0\xe9\xb0\x91\xd0\x31\x1c\xa0\x13\xf0\xbe\xad\xc0\xb2\x24\x8b\x47\x4e\x8d\xbd\xa2\x12\xa4\x03\x7a\xbd\x8e\xde\xff\x0b\x94\xcd\x12\xd8\x4e\x9d\x41\x87\xa6\x17\xae\x7f\xe8\xc6\x9d\xbd\xfa\x94\xf5\xcd\x63\x57\xb4\xcc\xbf\x67\xc2\x2d\x0b\xe8\x19\xdb\xd7\x6f\xd8\xd3\xd4\xa1\x2f\x79\xf6\x74\xec\x6f\x4d\xc5\x71\x9d\x35\xed\xd9\x46\x9b\xd1\xae\x17\x1a\xc8\x15\x32\xa0\x8d\x0a\xf0\xe0\x3f\x3c\xbb\xb2\x0d\x9a\xd8\x74\x74\xf0\x20\xf0\xf5\x64\x44\x57\x75\xe8\xbe\xa1\x0f\x5c\x3b\xf5\xaa\x35\x85\xd9\x85\x9d\x42\xd8\x93\xbd\x27\xf3\x87\xea\xeb\x7a\x82\xae\x7b\xaf\xeb\x7e\xc2\x5b\xdd\x4d\xbe\x13\x96\x78\xe7\xf3\x85\x10\x13\x94\xe6\x16\xbf\x43\x17\x83\x3a\x19\x43\xd8\xe7\x23\xbd\xc1\x9e\x27\x2e\x36\x3d\xe2\x71\xca\x8d\x93\xca\xc5\x2f\xfe\x3d\x89\x6e\x72\xd7\xc7\x84\xe4\xdf\x93\x72\xed\xd2\xef\xf9\xfd\xe4\xb6\xd8\xfb\xc4\xc5\xe5\x8f\x78\x5d\xb4\xb1\x35\xf6\xf0\x18\x34\x44\xdd\x80\xd7\x5a\x4f\xb9\xa9\x42\xaa\x31\x9a\x9f\x1f\xcc\x09\x87\x04\xca\xc9\xf3\x19\x54\x28\x87\x6d\x97\x9b\x97\x57\x94\xe3\xc9\x0d\x19\x3d\xfe\x86\x98\xc7\xad\xc5\xe7\x49\xcb\x30\x38\x62\x67\xc4\x14\xd4\x41\x22\x8d\xd1\xa6\x97\x49\x42\x4a\x25\x82\xa4\x5c\x76\x09\xc9\x72\x45\xe9\xc2\x0b\x24\xfb\x5e\xa0\x84\x1f\x61\x00\xcc\x3b\x8f\xa2\xe7\x5f\x7b\xeb\xeb\xc7\x40\xd5\xb1\xb7\xbe\x89\x4f\x1f\xb7\xeb\xca\x09\xb1\xb1\xbb\xae\x98\x00\xb5\x63\xfa\x85\x72\xdb\x95\x0f\x68\xa8\x7d\x0c\x04\x06\x82\x95\xa0\x20\xbe\x7a\xf6\x47\x70\xcd\x45\x0a\x0d\xf8\x15\xb8\xfe\x6a\x01\x87\x4f\xa1\x73\x2d\x8d\x0f\x83\x2e\xfb\x6e\xdd\x75\x00\xbd\xb0\x77\xe3\x81\xf8\x4a\xe1\x25\x75\x38\x36\x87\xc9\x6a\x79\x0b\x96\x5e\xb8\xf9\xf8\x0e\x59\xb7\xd4\xa2\x21\xaa\x01\x78\x8f\xff\x77\x9e\xa5\x13\x64\x48\x3b\x41\xff\xce\xb3\x8c\xe5\xa0\x94\xc4\xfc\x5f\x3c\xc3\x43\x1b\xfe\xdc\xb6\xf5\x91\x75\x7f\xde\xb6\xfd\x61\x44\xd7\x4c\xed\x59\x55\xd2\x79\x52\xaf\x72\x7a\xf6\x65\x39\xa6\x9f\x39\x8a\xf6\x3f\x79\xe6\xf0\x73\xa0\xcf\xe1\xf7\xe2\xa5\x6b\x00\xb5\x72\xfc\xd4\xeb\x2e\x52\xd7\x8c\x9f\x15\xdf\x7b\x09\xbb\x34\xd5\xf5\xe2\x0d\xdc\x26\xf6\x6f\xac\xf3\x4b\xa8\x48\xd4\xed\xb7\x68\x4c\x0e\x58\xc8\x71\xd0\x64\x61\x22\xa5\x9a\xdc\xe6\x98\x86\x81\xc5\xcd\x31\x98\x6a\x99\x07\x6d\x0b\x0d\x43\x94\x04\x18\x2d\xdb\x6a\xe2\x40\xd2\x0c\xcf\x41\xfc\xba\x33\x20\x9c\x85\x15\xac\x74\x69\x14\x43\x05\xfd\x6e\xe5\x38\xf1\x33\x74\xe1\x08\x18\xfc\xb9\x67\x6a\xe7\xea\x2b\xc5\xad\x9f\xcc\x39\x8a\xee\xfc\x60\x60\x51\x65\xb3\x65\xe9\x33\x93\x16\x4d\x19\x38\xb1\x7d\xb3\x65\xf9\x33\x13\xaf\x9e\x36\x60\x7e\xc7\x12\x2f\xe8\xf5\xdd\x77\x60\xe9\x27\xea\xa2\xf6\x9d\x8a\x6c\xdb\xff\xda\xfa\x39\x5a\xf4\x83\x6a\x22\xd8\x5f\x9e\x27\xee\x01\xba\xad\x5b\x8f\x5a\x9b\xcb\xf3\x4d\x77\xa3\x1f\x77\x6c\x7d\xc1\x36\x1a\xf3\x94\x79\xf1\x0e\xd6\xc4\xdc\x2a\x61\x4a\x63\x9e\x72\x74\x8c\xda\x68\xf5\x50\x94\x55\xad\x63\x4a\x4b\xac\x99\xf5\x31\xab\x95\x71\x34\xc4\x18\xd3\xe5\x79\x12\x09\x37\x52\xb5\x92\xd4\xb1\xc4\xca\x15\x20\xed\x00\x90\xc7\xa1\x48\xff\x22\xf9\x2b\x72\xb1\x44\xe6\x46\xa0\x3b\x10\x99\x54\xd4\x20\x3e\xf3\x38\x7a\x13\xfd\xe2\x1b\x56\x56\xde\x68\xde\x7f\x84\x76\xf6\x9a\x11\xad\xa9\xec\x3d\xaa\xa4\xbf\xd8\x73\x76\xcf\xaa\x0a\xff\xc8\xf2\x8a\x46\x70\xe8\x10\xc8\x3f\xa0\xee\x97\x1b\xf0\x7d\x70\x3f\xfa\x0c\x6d\xcc\xca\x8b\x44\xf2\x32\xbf\xa1\x97\x98\x6e\x7c\x6b\xfc\xa8\x25\x96\x81\x25\x21\xed\x92\x2f\xe7\x0d\x9e\x6b\x2b\x28\x93\x71\xef\x67\x5d\xfc\x41\x13\xe4\x9f\xc2\xfa\xae\x37\xf6\x9b\x27\x44\x2b\xbb\xb9\xeb\x1a\x06\xf4\xe9\xd3\x5f\xa3\xad\xc8\xc9\xd1\xfa\x8b\xfa\x37\x58\x2d\x6e\xf5\xa0\x81\x3d\x4a\x0b\x4a\x9b\x63\xfe\x8e\x7d\x3a\xf6\xc9\xe6\x0d\x16\x00\xb4\xf5\xf6\x02\xa6\xa6\x2a\xbb\xaa\x39\x96\x99\x9d\x76\x11\x7d\xf4\x68\xa9\x39\xf2\x52\xa9\x84\x08\x55\x75\x99\x56\x2e\x39\x14\x97\x98\x26\x5a\x2a\x40\xae\x95\xf0\xce\xda\x95\x5b\x6a\x93\x74\x4b\x4d\x98\xff\x87\x6b\x6a\x29\xab\x2e\xa4\xb9\xc8\x81\xca\x08\xcf\xf1\xaa\x25\xb6\xa1\x5b\x47\x8d\xd8\xd8\xb0\x64\x9d\xe5\x61\x3f\xe0\x9f\xbd\xf3\xc9\xea\x29\x63\x06\xc4\xdf\x7d\x74\xf7\xe3\xc0\xb8\xf1\x53\xb4\xf4\x22\xfa\xf3\xbd\xcd\xdf\xae\x7d\x0a\x7d\xb3\xf5\x38\x58\xd9\x12\xdb\x32\xe8\xee\xe1\xd3\xb6\x9d\x59\xf4\xec\xee\x6b\x7e\xda\xbb\xf2\xc8\xd2\x9d\xbf\xaf\xde\x7f\x5b\xed\xc4\x62\x74\x9b\xb7\x40\x35\x39\xeb\x8c\xc7\x55\xc9\x75\x28\xed\xd0\xa1\x74\xf6\x84\x47\x8f\x5d\xe1\x6b\xe7\x66\xd0\xc8\xfa\x0d\xe8\xf7\xfb\x11\x42\x53\x8f\x6f\x1b\x51\x73\x1b\xb0\xec\xfd\x13\x5c\xfb\x61\xa0\xe0\xfd\x8e\x77\xa2\xaf\x1e\xdf\xf3\xfc\xa8\xab\x97\xc5\xf0\x4f\xf7\x1f\x3c\x1e\x70\x7e\x12\x18\x99\xfb\xe0\x4d\x0b\x1b\xe4\x73\xdf\x17\xfb\x14\x7f\x73\x2f\x50\x41\xaa\x9a\xaa\xc5\xd1\x74\xb1\xd3\xd7\xb9\x4b\x6d\x87\x0e\x35\xc5\x25\x06\x96\x2d\xd1\x50\x35\x5d\x3c\xd5\x3e\x75\x8f\xee\x85\x65\xd5\xe1\x70\x49\xb4\x83\x89\x12\x69\xaf\xc6\x64\x33\xd1\xd8\x86\x66\xd3\xb6\xf4\x9b\xfe\xaa\x9a\x97\xe4\x45\xbe\xcc\xd2\x06\x95\xe3\x9f\xdd\x01\xf0\x59\x4a\xd2\x22\x35\xa1\x31\x51\x9d\x70\xd9\x0d\x48\xae\x25\xec\xbf\x75\xd3\x67\x7f\xef\x04\xc5\x6f\x71\x85\x7b\x77\x7f\x50\xb3\x6a\x5c\x97\x65\x8d\xf7\xee\xbf\x6a\x44\xf8\xbd\xdf\xee\x41\x27\x5e\xb9\x0d\x72\xb6\xa1\xdb\x46\x90\xc5\x5e\x6b\x79\x38\x13\xb8\x9e\xba\xe3\xd1\xda\xab\x06\xf7\x6b\x39\x4e\x56\xce\x7f\xc6\x6d\xaf\x2e\xed\xf1\xeb\x1b\xaf\x81\xc8\x9e\x8f\x4e\x7f\xf7\x7b\x71\x75\x69\xd5\xdf\xe7\xe6\x5c\xf5\x9f\x8f\x5f\x7f\x1b\x3d\xbb\x8f\x1d\x1c\xa9\x26\x8b\x7a\xdf\xc9\x2b\xc2\x85\x36\x88\xae\x90\x16\x6a\xee\x40\xc9\x06\x49\x79\x10\xee\x51\x6c\x4b\xcc\xc4\x96\xa8\x5f\x66\x3b\x82\xc1\x52\x1e\x28\x1a\x65\x43\xa0\xcb\xcc\x2e\x15\x02\x97\xd6\xe7\x2f\xe5\x0e\xd8\x66\xfc\x7e\x41\x7e\x3f\x7d\x5c\xc9\x1b\x05\x02\xe6\x10\xc8\x06\xd9\x4e\x1d\x9d\x8e\xe5\x81\x63\xc4\xcf\xa5\x3e\x99\xea\xa8\x57\xc5\xaa\x29\x9d\x5a\xe7\xb2\x88\xa2\xdb\xa2\x36\x49\x18\x2e\x8c\x1a\x87\x7a\x6a\x41\xe5\xa6\x52\xf5\x88\x97\xcc\xeb\x96\x6e\x3e\xb9\x24\x5a\x78\x12\xca\x83\x02\x1b\xf6\xde\xd5\xd0\x2f\x67\x28\x3a\xd9\xf8\xde\xb7\x69\x28\x1e\xbb\xe6\xfe\x8a\xce\xd1\x9d\xf6\x3d\xed\x7a\x1f\xd5\x80\x5d\xb9\xa0\xf0\x6c\x12\xc2\x03\x1d\xc4\x74\x65\xe1\xb8\x29\x1b\xdb\x05\x89\x2e\x86\x66\xed\x2a\x56\xe5\x32\x19\x8d\x6e\x13\xab\xd3\x89\xf5\x31\x9d\x89\xa5\x1a\x63\xac\x95\xf9\x37\xba\x82\xa5\x95\xe9\xc8\xe0\xca\x5d\xad\x34\xa7\x48\x3b\xbf\xeb\x1a\x74\xb6\x61\xc7\xfe\xdb\x01\xf3\xfc\x93\x1f\x93\xeb\xd9\x5e\x0d\x63\x66\xd5\x8f\xda\xd7\x3e\x3e\x0b\xec\xf0\x7e\xf8\xc0\xb3\x20\xb6\xf3\xa9\xfd\xf6\xd8\xf8\xf9\xe8\xe4\xd0\x85\x33\x71\x2c\xd7\x42\x51\xcc\x49\x69\x36\x40\x61\xd4\x6e\x16\x78\x95\x4a\xad\x87\xa2\xc0\x69\x18\xca\x6a\xd0\x68\x2c\x66\x46\x02\xad\x56\xa2\xaf\x52\x73\x6a\x88\x58\x90\x67\xf9\x20\x0c\x88\xc1\x4a\xb6\x12\x7f\x88\x11\xc8\x9c\x1c\x81\xd6\x8e\x05\xb3\x46\xa2\xb5\x3b\xfe\x7e\x0a\xad\x1d\x0e\xe6\x8c\x45\x37\x8f\x00\xb3\x9f\x3e\xff\x1f\x78\xc3\x87\x63\x3e\x1c\xf3\x9f\x31\xe8\x0e\xb0\x13\x7f\x21\xdf\x80\x5d\x28\x43\x8a\x27\x7b\x31\xc3\x68\x0e\xd3\x60\xa5\xb8\x83\x2c\x55\x24\xf5\x86\x04\xfc\xf2\x8c\x0c\x32\x4d\xd2\x2f\x8f\x94\xa4\xb9\x9e\xa5\x68\x5f\x8f\x48\x79\x6d\xb7\x0a\x30\xa0\x47\xa4\xb4\x27\x3b\xa0\xbc\xbb\xae\xb2\x63\xb7\x8a\xca\x6e\xba\x8a\x4e\xdd\xc9\xdf\xca\x67\x5e\x05\xbf\xb1\xa7\xb0\xae\x13\x1e\xd3\xa8\xd5\xd0\x84\xdd\x94\x22\xd7\x1b\xa5\x38\x28\x92\x5a\x1d\x88\x4b\x49\xe2\xef\x44\xe4\x87\xed\xde\xb4\xf0\xe0\xb1\xd3\x3b\x37\x67\x8f\x2f\x1f\x3d\x7c\x78\xd1\xcb\x2a\xe6\x55\xfb\xd4\xdc\xd2\xdc\xc3\x99\xd9\x99\x47\x0a\x22\x04\xcb\x8a\x19\x00\x22\x98\x3e\x1d\xa5\x79\x18\x02\x9e\x2a\x7a\xa3\x14\x2b\x79\x02\xa3\x64\xb1\x07\xa4\x49\x81\x35\xbf\xe5\x5c\x05\xa3\xd7\x67\xda\x54\xec\x1b\x6f\x3b\xab\x87\x94\xf6\x29\x0e\x14\x48\xbe\x26\x8f\x7f\xb7\x42\xc2\x9a\xd6\x3c\x8c\x5d\x4b\xe5\x77\x03\x15\xd2\x29\x34\x80\xf5\x37\xcc\x30\x5e\x95\xf3\x9b\xc3\x50\xc3\x0c\xb8\xa2\xc7\xdb\x4b\x7b\xce\xa6\x00\xea\xc2\x4e\xa3\x1f\xe3\x7e\xc4\x3c\xe8\x0e\xf1\x06\x2d\xfe\xa5\xc8\x9b\xa5\xe9\x0a\xd5\x1a\x28\x53\xcc\x8b\x9d\x7e\xcc\x16\xdb\x3b\x65\xc6\xfa\xde\x4b\x16\x3c\xfc\xdd\xe1\x7e\xbb\xe6\xcc\xd9\x11\x63\xa7\x45\xaa\x3b\x96\xcc\x9e\xf0\xc0\x07\xed\x2a\x2a\x22\x0c\xb9\x1e\x6b\x29\x42\x0f\xc0\xaf\xd9\xc7\x31\x1d\x22\x8e\x78\xc2\xd8\x5a\x77\xa0\xba\x53\xf5\xd8\xe3\x2f\xef\x11\xc8\xe8\xdb\xb9\x9b\xaf\x57\xaf\x60\x5d\xa9\x51\x53\xa9\x2b\x2b\x33\x57\xe5\xb0\x54\xa1\xc5\x49\xe7\xe5\xf1\x45\x7d\xbb\xd5\x55\x56\x15\x3a\x8b\x8a\x9c\x85\x55\x95\x75\xdd\xfa\xaa\xdc\x5d\x3a\xda\xdc\x98\xa6\xa2\x48\x02\xad\x9a\x44\xea\x89\x78\x3c\x92\xbc\x25\x8a\xa4\xfd\x8c\x60\x22\x05\xb2\xac\x01\x13\x5e\x74\x31\xf9\x0a\xfc\xeb\x2b\x78\x99\x9f\x05\x53\xff\xca\xcd\x9a\x35\xe1\xe4\x49\xb3\xf4\xb9\xe5\x66\xe9\x0b\x5d\x28\x7d\x39\xbf\x4a\xfa\xf2\xb9\xfc\xb3\x0d\xd2\x97\xb8\x53\xfa\x02\x5f\xba\xf5\x56\xac\x82\x10\x27\x7d\xa1\x7f\x94\xbe\x9c\x3f\x23\x7d\x61\x42\xe9\xff\xd6\xf2\x85\xf4\xe5\x37\xe9\xb3\x74\xc5\xd8\x32\x05\xad\x80\x77\xb1\x67\x2f\x59\xc3\xb1\xd1\x32\x95\x3a\xda\xad\xb0\xa8\x28\xc7\xe9\xb1\x7a\x02\xc1\x60\x46\x7d\x5d\x65\x75\x69\xb5\xc6\xac\xee\xd6\x3d\xc7\xed\xc9\xa8\xaa\xab\xee\x63\x36\xf7\xa9\xae\xab\xca\xf0\xb8\x73\xba\x77\x53\xeb\x58\x23\x96\xf4\xa2\xb4\x05\x94\x17\xd1\x1c\x31\x1d\x4d\x7c\x4e\x7c\x48\x97\x4a\xe4\xea\x22\x50\x51\x1e\x28\x37\x93\x2c\x5b\x84\xb3\x46\xac\x92\x3c\x94\xdb\x22\xe5\x91\x20\x11\x06\x6b\x28\x60\x0d\x40\x22\x13\x7c\x28\xcc\x87\xa5\x11\xb3\x95\x38\x60\xb0\x43\x2c\x67\x7c\xb8\xa2\x32\x5c\x49\x20\x3d\x2b\xed\x1c\x6f\xe7\xbb\xbb\x3c\x57\x74\xed\x2b\x7d\x8a\x4f\xbe\xba\x76\x64\xee\xd0\xc6\x6d\xcc\x83\xca\x8b\x4e\x83\x8b\x8b\x34\x3d\x8d\x55\xe5\xd3\x5a\xba\xe3\x97\xea\x1e\xf8\xe5\x74\xdd\xe0\x92\x01\x25\x3d\xaf\xaa\x2e\x9f\x06\x4f\x0c\x2e\x1e\x58\xd2\x73\x5a\x55\xf9\xd4\x0e\xd2\x6f\x34\xdc\xc1\x7c\xa6\xbc\x88\x7b\xa4\xbf\x59\x26\x7d\x46\x7f\x0e\xc1\x6f\xec\x31\xb5\x3d\xfe\x1d\x5e\xfa\x9d\xa9\xe4\x6f\x76\x96\xff\x3c\xf9\x4b\xd7\x0f\x2e\x69\x47\x9e\x54\x31\x55\xca\x75\xa0\x89\xec\x69\xbe\x23\x65\xa6\x32\xa8\xba\x68\x50\xa7\x56\xeb\x55\x2a\x8f\x95\xa7\x01\x30\x53\x5a\x2a\x93\xe3\x79\x1f\x6b\x02\x5a\x95\x5e\xb0\xb9\x9d\x02\xa7\x24\xf1\x22\x9f\x95\xbe\x54\x85\x7d\x92\x04\x00\x76\x22\xf3\x22\x0f\xde\x4d\x26\x38\x08\x76\x03\x8c\x80\x80\x18\x10\x6b\x80\x1a\x24\xa0\xa7\xc8\xf0\x5a\x19\xcc\xc1\x9a\x43\xc0\x1c\x4e\x6d\x45\xdb\xce\xff\x3a\x5a\xc2\x73\xa0\x35\x6b\x0f\x57\x3c\x5f\x30\xa5\xe7\xe3\xc3\x67\x74\x7c\x9f\xa0\x3b\x4c\xd9\xc3\xf4\x20\xad\xc0\x60\xab\x8c\xf0\xc0\x7e\xbe\x7c\x65\x9f\x09\x83\xde\x28\xb9\x75\x8b\x7c\x17\x2b\xd5\x2c\xb0\x71\x69\x26\xf5\xc0\x68\x81\x4e\xad\x31\x98\xa0\xcb\x95\x65\xca\xd5\xb0\x85\x05\x81\x9c\x50\x66\x46\xd4\x62\x31\xa9\x33\x8c\x06\xbb\x5c\xe4\xad\x35\x5b\x4d\x62\x63\xcc\x94\xc0\xa2\x23\x9f\x4d\x47\xa5\x64\xbf\xcb\xf4\x59\xe9\x1b\xad\xda\x4c\xdb\x94\x77\x83\x4b\xca\xbb\x83\xe9\x7c\xc9\xb5\xde\x12\xd8\xf4\xc1\x55\xe8\xf0\xf9\x5f\x47\x89\x6c\xa2\x26\x6b\x19\x38\x9b\xce\x9c\x52\xfa\x4d\x50\xa7\x5b\x56\xc5\xef\x97\x4a\xbf\x95\xda\x2c\xfa\xe6\xf1\xe9\x4c\xa6\xfa\x79\x49\x8e\x7c\x64\xb4\xc4\xae\x73\xab\x78\x86\xc1\x7f\x1a\x8a\x22\x19\x44\x2f\x98\x48\x82\x9c\x64\xc5\x13\x49\x72\x15\xfe\x0f\x3b\x39\x52\x7a\x9c\x86\x89\xc9\x04\xe9\xa3\x82\x94\xaa\x0c\xbc\x67\xa9\xab\x76\xa2\x64\x49\xe3\x3f\xc1\xab\x4b\xe4\xc6\x03\xc9\xdc\xf8\xa6\x15\x3e\x10\xf6\xdd\x15\xd8\x9e\x9f\x96\x18\x7f\x7b\x05\x60\x93\x79\xf1\xcf\xee\xb9\xe7\xe0\x67\x52\x5e\xbc\x5d\xcb\x13\x4a\x5e\x5c\xaa\x63\x95\xec\x9d\x87\xd0\xee\xd0\x79\x08\xed\x24\x6d\x66\xb1\x00\x81\xa6\x45\xb3\xce\x9c\xe1\x55\x79\x9a\xc8\xad\x8e\xd8\xa4\xd0\x6e\xc4\x31\x7a\x53\xcc\x68\xa3\xc1\xff\x3b\xed\x69\x75\x3c\x01\x31\x51\x9d\x74\xff\x52\x37\x70\xb9\x6f\xf5\xdf\x3a\x21\x55\xc6\xf3\xc5\xd2\xf7\x94\x72\x24\xb6\xcb\x9a\x35\x0f\xc4\x7f\x96\xab\x5e\xaf\x69\x11\x94\xfa\x23\x05\x4b\x82\x32\x48\xd3\x3b\xfc\x46\x72\xaf\x2f\x98\x55\x16\x96\xe3\xdd\x36\x08\x3d\xa4\xcb\x5b\xab\xd5\x1b\x0c\xae\xe6\x98\x01\xea\xdb\x0e\x9b\x88\xa4\x8d\xb9\xc3\xab\x89\xb5\x00\x8e\xac\xc8\x9d\xbd\xe8\xc7\xba\xc1\xae\x34\x54\x37\xfd\x01\xcc\xb7\x0d\x3c\x3c\x67\xd8\x44\x74\xdd\x58\xd2\xdb\x7b\x37\xf0\xf7\x1a\xf8\xc4\x0c\xd7\xf2\x05\xe8\x3c\xbb\xe2\x8b\xa3\x5f\xac\x9e\xb0\x65\xbd\x1d\x99\xd8\x15\xf1\x26\x38\x69\xcb\x9a\x8a\x3e\xe3\xa7\xc8\x79\x32\xa5\xff\x04\xeb\xc6\x62\xaa\x7f\x34\xbf\x1d\x97\x9b\x93\x8f\x0f\x00\xc7\x97\xda\xbc\x01\x01\x9f\x02\xab\xd5\x66\x2b\x71\x1a\x6d\x6e\xc1\x6b\x80\x86\x10\xa9\x43\x87\x19\xf5\x31\x68\x6a\xdd\x9e\x5c\x93\x86\x63\x9f\x98\x90\x91\x68\xf7\x90\xa9\x96\xa7\xf1\x48\x75\x7e\x7e\x82\x93\x9a\xa5\xc0\x60\x13\x3e\xa4\x2b\x76\x70\xae\xf7\x9e\x59\x77\x3d\x3c\x79\xf8\xa8\xb5\x93\xeb\x9a\x97\xdc\xe1\xa3\xa1\x76\x2c\xfa\xe6\xbf\x16\x11\x88\x7a\xcd\x4f\x8d\x73\x9b\x8a\x27\x37\x97\x86\xe6\xdc\x7c\x65\x66\x7e\x1d\xdc\x30\x61\xf0\xd3\xbb\x9e\x40\x5b\x9b\xe7\xcc\x5d\xe9\x9e\x38\xca\xdb\x05\x41\xe6\xbb\x69\x6b\xb4\x53\x4b\xb8\x1e\xeb\x3e\xa8\x9f\xb2\xd0\xb0\x61\xee\xd2\xee\x9f\x35\x4c\x9e\x92\xc4\x44\x2a\xe0\x3d\x14\x4f\x05\xa2\x66\x96\xe3\x54\x80\xa6\xd5\x3c\xd3\x1c\x03\x3c\x24\x78\x96\x04\xb8\x3c\x05\x12\x02\xb0\x67\x44\x56\x19\x7e\xd5\x70\x7e\x71\x7c\xd9\xd7\x78\x4d\xf1\xda\x81\x6d\xf1\x15\x32\x38\x92\xdc\x17\xe4\x64\xdf\xc5\x7f\x2f\x1c\xb5\xb4\xfe\x7b\x46\x2e\x51\xc8\x74\xb9\xbf\x29\xd2\xef\xd7\xff\x3e\x07\xd5\xee\x43\x67\xdf\x61\xaa\xc1\xd6\xf8\x03\x72\x2f\x10\x45\xe6\x00\xcb\xb8\x4d\x7a\xaa\x43\xd4\xcb\x69\x34\x40\xab\xe5\x0d\x24\x75\xad\xa7\xf4\xcd\x31\x0e\x6f\x97\x56\xa0\xd9\xe6\x18\x0d\xa9\xd6\x60\x92\x49\x7c\x5c\x59\x86\x45\x69\x52\x88\x54\x65\x13\xe8\x7c\xdd\x0c\x86\x2a\x88\x87\x6b\xc1\xcc\x1c\x74\x33\x76\x21\xe7\xaf\x82\x35\x74\xd7\xd3\xe8\xee\x0f\xe2\x5b\xe9\x89\xb2\xbf\x83\x03\x21\x24\xd5\xfe\xd6\x44\x33\x39\x00\x34\x5a\x5e\xab\xd7\x43\x83\xfc\xe4\x46\xf9\xc9\x56\x9a\xad\x8f\xd1\xc6\xcb\x3d\xd9\xdc\xf6\xd9\xe4\x04\xe1\x67\xe7\xcd\x8c\x41\x4d\x18\x09\x65\x27\x03\x1f\x0d\x42\x67\x07\xce\xa0\xa7\x81\x37\x9e\x41\xbf\x1e\x46\x7d\xc1\xa3\x72\x5d\xad\xa4\x93\x7c\x04\x0b\xcd\xa1\x61\x32\x33\x7d\x3e\xb3\x06\x02\x3f\xc8\xe2\xb1\x22\x62\x7c\x3c\x4f\xf9\x04\x83\x05\x9f\x0c\x37\x05\xc9\xa5\x79\x2b\x20\x4d\x65\xc2\x4d\xda\x98\x0f\x69\x44\x0a\x91\x3a\x21\x51\xeb\x5d\x99\x5e\x39\x45\x20\x73\x98\x60\x41\x9c\xee\x7c\xe5\xbc\x9e\xdf\xb7\xec\x47\x2f\xbc\xbe\xf9\x64\xdd\x43\xa3\xf7\xcc\x7b\x7e\xcc\xb5\x5b\x3a\x4f\x6a\x5c\x8c\xfe\x43\x90\xb5\x9e\xcb\xb5\xa3\x5f\x7e\x8b\xa3\x6b\x8f\x75\xea\xf9\xf0\xf0\x6d\x80\x3f\xb4\xe5\x76\x6b\x56\x5c\xc2\xb6\x20\xf1\x40\x67\xa9\x27\xa8\x36\x9a\xed\x11\x39\xca\xe9\x74\xb9\x74\x1c\xf4\x65\x42\xac\x6d\x28\x32\x20\xc4\x9d\xd1\x10\x73\x1b\x5d\x56\x35\x0e\x10\xd5\xee\x44\x0b\x95\x92\x70\xcd\x6f\x63\x19\x12\xc8\xfd\xfe\x84\x0d\x50\x92\x21\x24\x39\xc7\xfb\xc1\xbe\x8e\xa3\x7b\xbf\xfb\x11\x3a\x80\x3e\x5b\xfa\x5e\x87\xe7\x32\x67\xf4\xdd\x75\x70\xee\xb4\xd8\xc4\x3a\x74\xe6\x5d\x68\x6b\x87\x18\xba\xb7\xd1\xf0\xf1\xeb\xe8\x0b\xf4\x58\xff\x1e\xd7\xf8\x4a\xde\x7b\x69\xce\x72\x17\x9a\xc5\x54\x7f\x27\x61\x5e\xa1\x89\x12\xe6\x55\x90\xba\x2a\x5a\x9d\xe9\x09\x92\xb1\x61\x1c\x65\xc8\x76\x79\x78\x16\x9f\xea\x30\xc3\xb2\x21\x17\xe7\xc7\x1b\x3d\x26\x96\x2d\x03\x5e\x71\x3e\x83\x41\x9d\xe1\xf3\xb9\x47\xc7\x7c\x82\xd5\xa8\x86\x14\x2b\x83\xbd\x2a\x26\x2e\x95\xce\x4f\x83\x94\x6e\x95\x67\xfd\x57\xc0\x2b\x51\xea\x24\xf9\xdf\x40\xaf\xba\xce\x75\x1d\x27\xd0\x5f\x63\xff\x1d\xf6\xaa\x69\xb1\x29\xfe\x0d\x31\xee\x0a\xf4\x15\xe9\x43\x46\x13\xa5\x3e\xe4\x20\x35\x3e\x5a\x91\xe9\xc9\x26\x13\x97\xd9\xa0\x21\x80\xf9\x66\x6c\x76\x7b\x18\x32\x4c\xc8\xc5\x06\xfc\x14\x6d\xa0\x9b\x62\x66\x16\xf3\xac\x22\x3c\xd7\xc7\x7c\x56\x9b\x51\x65\x0c\x32\xd6\xcb\xf3\x1c\xf9\x07\x8e\x2f\x6d\x2e\x86\x72\x93\xa9\xcc\xee\xbf\xf4\x17\x07\x82\xed\x3a\x7d\x2f\xf7\x17\xdf\xb4\x65\xce\xef\xf5\x7d\xfe\xa5\xc5\x58\x28\xe8\x0f\xfa\x91\x16\x63\x74\x23\xe9\x9c\x51\x5a\x52\x09\xd6\x17\x96\x49\x82\xf5\x55\x46\x8d\x8b\x96\x5b\xfd\xfa\x30\x2c\x70\xb9\x79\x8e\x73\x97\x98\x0b\xb2\xc3\x7e\x55\x45\x39\xd5\xce\x9d\x6d\x16\x08\x50\x06\x0f\x5d\x19\x82\x00\x33\x32\x1c\xcd\xb1\x0c\x26\x0f\x42\x8d\x72\xcf\x97\x9a\x5a\xeb\x90\x0a\xac\xe4\x97\x97\x2b\x72\xc5\x22\x8a\xdd\xd4\xff\x1b\xff\x8b\xe3\xb1\x60\x2b\x72\x0d\xa6\x0f\x18\x7c\xec\xef\xaa\x7f\xc2\x02\x7b\x1f\x11\x2c\xb0\x0b\x67\x01\x3a\x5c\x34\xc1\xe5\xb1\xf5\x47\xdf\x5f\x7d\xbd\xf6\xc8\x91\x36\xc0\x60\x8f\xdd\x21\x03\x83\x1d\xf9\xd2\x1a\xf2\xa0\x3d\x16\xe3\x5a\xad\x40\xfa\xac\xd1\x10\xa9\xcf\x3a\x42\x8d\x8e\x96\xf9\x0b\x5c\x94\x99\x0d\x85\xad\x16\x8b\x26\xec\x65\x4b\xa8\x02\x55\x79\x59\xb1\x37\x23\xc3\xdb\x14\xb3\x9a\x43\xb9\x19\x19\xe6\xdc\xdc\xec\xa6\x58\xae\xc9\x6c\x6f\x8c\x41\xb3\xcd\xc0\xbb\xa5\xdd\x6e\x85\x4d\x7f\x39\xdc\xb3\xc4\x14\xff\x14\x57\x11\x79\x29\xfe\x8f\xa6\x6b\xb8\xeb\x95\x87\x92\x8c\xe5\x0c\x18\xbc\xf3\x79\x77\x4b\x60\xd7\xf0\x11\x97\xf6\x5f\x4f\xbb\x1a\x54\x5d\xf7\xa0\x25\xe4\x55\x78\x5b\x7c\x9d\xee\xce\x1b\x0b\xee\x6d\xec\x75\x69\x37\xb6\x90\xc0\xf9\xc1\xfe\xf7\x68\x09\x7f\x68\x40\x34\x9f\xb2\x08\xb4\x91\x54\xe6\x60\x47\xc1\x60\x34\x3a\x04\x0d\xad\xa1\xc7\xc4\x34\x2c\xfe\xd0\x00\x83\x0a\xf2\x82\x0d\x00\x71\x74\x0c\xc8\x05\x8f\xd8\x65\x4d\x14\x6e\xb7\xb9\xb4\x50\x52\x79\xfe\x80\x02\x35\x96\x38\xc3\xb2\x4c\xc3\xbb\xaf\x50\x50\xc6\x48\x3d\x44\x0a\x83\xec\x9a\xc1\x27\x9f\x5c\x76\x5e\x06\x1a\x4b\xe1\x8f\xed\xac\x8c\xff\x26\x61\x25\x61\x5a\xa5\x1e\xef\x14\xad\x6a\x96\xe5\x2c\x9c\x4c\x2b\xad\x56\xe3\xd3\xa8\x66\xf0\x87\x1a\x18\x88\x15\x25\xb4\x26\x01\x9f\xff\x17\x5a\x39\xb9\x92\x28\xed\xf4\xd1\xef\xd6\xad\xf5\x76\x1f\x22\x55\x5a\x0f\x2f\x2c\x2c\x89\xbe\x25\x37\x7a\x2f\xc0\x9a\x45\x3a\x40\xa4\xd1\x9b\xb6\x14\x0d\x06\xe5\xa4\xd1\x1b\x1d\x21\x88\x41\x54\x1a\xa6\x9b\x8d\x1a\x1c\x6d\x47\x53\x16\x28\x42\x51\xc0\x8a\x43\xad\x13\x18\x3b\x76\xd7\x1c\x66\x0a\x5b\xa7\x31\x31\x1e\xaf\xaf\xcd\xc2\xe8\x34\x2c\xcf\x33\x7a\x16\x8a\x4c\x12\x1c\x5b\xe9\xf9\x4c\xa3\x57\x91\x25\x19\x30\x8b\x53\xd6\xb5\x92\x54\x96\x11\x7a\x09\x46\x4e\x80\x2e\xef\x54\x95\x58\xd7\x8a\x1e\xf5\xd3\x4a\x41\x27\x79\x65\x09\xb4\xdb\xe3\x9d\xa6\xd1\x73\x1d\xf2\xda\x76\x02\x9b\x2e\x52\x60\xb5\xb4\xbc\x14\x38\x8b\x8e\x26\xe9\x56\xd6\x78\x74\xb4\x44\xa7\xd6\x43\xbd\x28\x50\x16\x33\xa4\x69\x28\x40\x83\x1d\xd3\xcd\x51\x1c\x85\xd7\x58\xc5\x71\xa0\x09\x93\x0e\x75\x1a\x86\xe3\xa0\x9e\x31\x8a\xd0\xda\x86\x74\xa2\xf2\xda\x00\x9d\xc8\xa0\x4c\x72\x56\x9a\x97\xfb\x91\xec\x98\x03\x3e\xd1\x54\xcf\x07\xc0\x17\x7d\x95\xf5\x36\x85\x2c\xb5\xd3\x0a\x5e\xc3\x2b\x7e\xbe\x47\xd7\xd7\xd1\x37\x03\x5c\xd3\xc0\x4b\xac\xbc\xe6\x00\x80\x11\x9f\x83\x01\x4a\x77\x7d\xc5\x0d\xe9\x6b\xee\xa2\x26\x45\xdb\x0b\x66\xd1\x64\x23\x7e\x3e\x84\x76\xbb\x13\x7b\x57\x0e\x87\x8b\x35\x99\x59\x37\x76\xa0\x3d\xf8\x9f\x74\x2a\xdb\x18\x69\x48\x46\x22\x56\xa1\x05\x87\xa0\x23\xae\x91\xc4\x42\x55\x9a\xab\x4f\x55\xa5\xad\xbf\xec\xf1\x27\xdd\xea\xa4\xc7\x9f\x90\xef\x04\xba\x9e\x18\x58\xb7\x9a\x04\x2b\xb7\x07\x6e\x2b\x4d\x13\xf0\x34\x84\xbd\xb7\x57\x4b\xd1\x0a\x6a\x49\x8a\xb9\x82\xb1\xc7\xb4\x4b\xdb\x0b\xf6\x18\xe6\xe7\xaa\x68\x95\x28\x58\xcc\x32\x3f\x76\x3b\x70\x12\x6e\xcc\xac\xc0\xba\x49\x4d\x3c\xa4\xcd\x16\xbd\x4d\x85\xfd\x07\x95\x4a\x2f\x3a\xac\x84\x2b\x12\xc5\x50\xb4\xde\x48\x53\xf2\x1c\xa0\xb4\x72\x72\x99\x23\xe0\x90\xef\x1e\x94\x9a\xe4\x34\x34\xfb\x24\x4b\x89\x73\x20\x43\x1d\x88\x81\x6d\xeb\x48\x00\xb3\xdd\x77\xd7\xd4\xb4\x93\x40\x20\x0f\xa4\x13\xf2\xf5\xcd\x6c\x97\x1b\x6f\x7c\x20\x7e\x22\x75\x1c\x14\xdc\x03\x66\x8b\xcc\xcf\x2d\x14\xc5\x6d\x96\x70\x03\xeb\xa2\x39\x3a\xad\x5e\x43\x20\x1a\x2c\x82\x46\xcb\x58\x71\x98\x6f\xd3\x6b\x4c\x1c\x6d\x1a\x13\xa3\x69\x4a\x27\x08\x1c\xa4\x2c\x29\x97\x2d\x8d\xf0\x4b\xc1\x0d\x45\xff\xa5\xab\xef\x7f\x96\x3e\x31\xe7\xf2\xeb\xfe\x35\x1a\xd0\x4a\xb9\x24\x56\xfd\x4e\x42\xe3\x68\x2c\x43\x51\x2c\xff\x12\x8d\x7a\x9d\x41\x2b\xd3\xa8\xd5\x31\x56\x5e\xa5\xb2\x69\x0d\xbc\x04\x24\x81\x69\xd4\x0b\x56\xde\x48\x59\x94\xc1\xa2\xff\x03\x8d\x6d\x96\xd3\x7f\x33\x3d\x2e\xa5\x52\xba\xf4\x4c\x2e\xe4\x2e\xf4\x44\xba\x56\x19\x91\xab\x2c\x23\x6c\x50\xf4\xf5\x77\x12\x36\x5a\x53\x34\x0f\xaa\x68\x35\xc3\x00\x8d\x06\x1b\x6b\x86\xa5\xf4\x7a\x56\x6b\xd2\x9a\x8d\x40\x05\x47\x63\x51\x00\x1a\x0e\xb2\x02\xd0\x25\xd5\xb5\x42\x21\xd1\x85\xe9\x79\x66\xb9\xad\x8e\xe8\x14\x7f\x20\x05\x59\x4c\x9a\x76\x99\x65\x2f\xce\x8b\xaf\x4d\xa0\x3d\xd1\xb3\xa6\x02\xcf\xa9\xbb\xb1\x82\x4e\x02\x13\xcb\x08\x69\x94\x8c\xb3\x2b\xe1\x31\x18\x09\x76\x10\x65\x34\x1a\x68\x2d\xd0\x31\x58\x7d\x18\xd4\x9c\x06\x62\xc5\xc7\x19\xa0\xc9\xac\xd2\x00\xd2\x2b\x03\x34\x10\xbf\xc3\xaa\x61\xc9\x2c\x83\x4b\x48\x6b\x65\x33\xd3\xa6\x08\xfa\x13\x9d\xc4\xad\xd0\x18\xee\xc5\x04\xd5\x3f\xdf\x0a\x90\xa1\xe5\x49\xe2\xcf\x25\x40\x19\x80\x54\x2b\xb7\x46\x8a\x8b\x6a\xa2\x3e\xbd\x8a\x22\x70\x11\x14\xa3\x31\x68\x8c\x3c\x3d\x3a\x86\xf5\xae\x5a\xad\x23\x10\x53\x2c\xa4\x64\xed\x7b\xf9\x31\x2d\x29\xf0\x47\xd9\xb9\x86\xf0\x91\xb9\xf1\xdb\xe6\xc8\x45\x7d\x53\xe9\xf1\x53\xe9\xa3\x05\x68\xcc\xd7\xa9\xd5\x39\x7d\x61\x9c\xb4\x36\x41\x2c\xf7\x5a\x29\x3e\x2a\x8f\x7a\xd4\x2a\x0a\xe8\x58\x03\xc3\x18\xf5\x46\xa0\x21\x8b\x01\x55\x3a\x2b\xe4\x1a\x62\x50\x91\x23\x65\x25\x6a\x94\xe0\x44\x61\x9d\x4f\xc2\x50\x08\x84\x71\x7a\x5e\x3b\x74\xef\xae\x36\x48\x14\xdf\xb5\x1c\x4c\x70\x2d\xcd\xa5\x42\x43\x24\x3c\xef\x2c\x2c\xcb\xb9\x02\xf4\x39\x1c\x4e\x8f\xd7\xeb\xd4\x40\x26\x3b\x40\x0e\x97\x8f\xa2\xb0\x5f\x83\x5d\xf5\x0c\xa8\xe5\x9d\x5e\x41\x02\xb1\x73\x27\x89\xb8\x6c\xcc\x21\x7b\x70\x54\x7a\x7c\x44\x06\xfd\xfa\xe5\x7a\x48\xbf\x32\x4d\x8c\xbb\xe1\x6b\xc0\x1c\x40\xcf\x2b\xf1\x51\xcd\xba\x45\x8d\xe8\x94\x14\x20\x9d\xfa\x2a\x7e\xff\x57\x58\xa0\x04\xe6\xf6\x29\x57\xce\x83\xdb\xd1\x0f\x7f\xb7\xa0\xeb\x5e\x26\x81\x52\xe5\xea\x53\x7b\x41\x07\x12\x28\xc9\x68\x9a\xf1\x4f\x73\xed\xf2\xfa\xa1\x21\xdc\xb7\x52\x5f\x43\x43\x34\xcf\x6b\xd2\xe2\xed\xc3\x67\x91\xb1\x99\x18\xbf\xcf\x2e\xaa\x44\x57\x7d\x4c\x74\xeb\xa9\xfa\x18\x8e\x3a\x55\x4a\x8b\x37\xa3\xb2\xa6\x35\x93\x56\xa5\x81\x91\xb7\x66\x25\x8b\x4f\x16\x0f\x57\x5c\x26\x92\x62\x7e\x9f\x3c\x16\x07\x4b\xfb\xd0\x92\x7d\x24\x64\x7a\x7c\xcc\xac\xa5\x6d\xc3\x29\xb0\x07\x47\x4c\x32\x22\x07\x32\x7a\xdb\x04\x53\xd2\xdd\xd9\xf8\x8b\x3f\xb0\xcd\xec\x66\x4a\x4b\x55\x52\x03\xa3\xed\x60\x71\x24\x44\xa9\x73\x03\x56\x6b\x2e\xe5\x29\x2e\xe7\xaa\xda\x17\xe2\xa0\xdc\x40\x15\x16\x9a\x9d\xce\xcc\xe6\x98\x93\x31\x87\x9a\x63\x66\x51\x17\x21\x28\xfb\x69\xc5\x01\x0a\x2f\xad\x63\x40\xb9\x11\x48\x1a\xde\x2b\xf5\xf3\x8a\xca\xbc\xbf\xcb\x24\x59\xa5\x04\x52\x85\x72\xa7\x52\x5a\xc9\x73\x70\x47\xe3\xb4\x68\x61\x43\xb1\xe7\x93\x5b\xc6\xd6\x8d\xef\xb7\xe3\x97\xe5\x6f\x82\x3e\xaf\x57\x75\xcb\x9f\x14\xac\x9b\xf2\xe0\xe4\xdd\xeb\x7c\xa1\xab\x5f\x5f\xbe\x68\xdd\xb5\x93\xee\x19\xd6\x6e\x00\x60\x87\x83\xda\xeb\x26\x4c\x38\xd4\xdc\xb4\x1d\xbd\x58\xe6\xb3\xdc\x0e\x5c\x8f\x9f\x04\xeb\x3e\xd4\x9a\x3f\xd2\x6e\x47\xc7\xef\x7b\xe0\x95\x9e\xcf\xf7\xdd\x0d\xc2\x5b\xf6\x6d\x5e\x87\x1e\x58\x56\xf4\x5b\xb6\x7c\x3f\x4a\xea\x8d\x7a\x30\x75\x54\x0e\xf6\xb0\x31\xff\x05\xbe\x80\x2d\xb7\xd4\x69\xe1\x79\x67\xae\xde\x17\xe2\xca\xcb\xbc\x45\x58\xa3\xe6\x7a\xbd\xa4\xb0\x48\x9a\x98\x64\x6b\x24\x65\x11\x81\xfa\xd4\x3c\xb1\x7f\xe5\x9f\xcd\x0a\xa7\x8a\x23\x24\x86\xa5\xc1\xb9\x84\xdf\x64\xef\x2a\xb6\x10\x3c\x17\x4e\xcc\x1e\xb3\x5a\xe0\xd8\xe6\x5e\x23\x27\xbc\xfa\xf3\xad\x68\xe7\xa0\xfe\x33\x6c\xc5\x7d\x16\x76\xff\xd4\xee\x1f\xb2\x69\xcc\x84\x39\x43\xfb\xe4\xcf\x09\x86\x06\xfe\x58\xd9\x90\xe9\x6c\x17\xb5\x04\x02\x7f\x1d\x7b\x14\x54\x1f\x08\xbc\x28\xce\x7d\x7d\x16\xfa\xa8\xdd\x2d\x65\x0b\x4f\x4e\x5e\x34\x6b\xe6\x0f\x23\x45\xd3\x33\xc1\x6f\x2b\x4e\x4d\xcd\xcb\xdd\xb3\x7c\x91\x24\xab\x89\x3c\x64\x90\xea\x19\x0d\x62\xe7\x54\x4d\x39\x1c\x58\x05\x32\x21\x5f\x66\x66\x98\xf5\x59\x3d\x9e\x40\x73\xcc\x83\xa5\xd3\x0a\x9b\x63\x56\x51\xd0\xba\x65\x31\x4d\x46\x4f\x55\x6d\x67\x8f\x02\x65\x82\x00\x9b\x16\x36\x74\x02\xd9\x94\xf9\x92\x04\x25\xe9\x37\x79\x14\xdd\x94\x0c\x15\xee\x47\x7f\xa3\x8f\x2e\x97\xac\x24\x63\x05\x8e\xe4\x75\x53\xa2\x84\xdf\x8c\x46\x50\x01\xb8\xd6\x79\x4b\x32\xd3\x78\x10\x8e\x89\x42\xe4\x6e\x25\xc3\x0b\x19\x81\x0f\xda\x6c\x3a\x9e\xf1\xb2\x39\x61\x98\x21\xba\x5c\xbe\xfa\x98\xcb\xc4\x89\x22\x45\x1a\x3b\x4d\xea\x4b\xf9\x68\xdb\xf4\x5a\x51\xc9\xb6\x61\x22\x2d\xa3\x29\xb7\xa6\x61\xc1\x74\x0c\xb8\xca\x07\x8c\x23\xd0\x6b\x29\x36\x9e\x39\x4e\xfa\x60\x9f\xfe\xca\x80\x4e\x6b\xef\x98\xb2\xb0\xc4\xbe\x6f\xd2\x84\x52\x74\x3c\xa7\x36\xc1\x80\x49\xff\xf9\x93\xa4\x1b\xf6\xd9\x07\xec\xcf\x6e\x7c\x6a\x76\xf9\x77\xb2\xfe\xdb\x80\x6d\xe5\x6c\xa9\xdf\xa4\x73\xd4\xc7\xd3\x6a\x4a\xab\x02\x10\x50\x34\xc3\xea\x58\x3d\x0f\x19\xbc\x03\x0c\xd4\x02\xa0\x4a\x0f\x68\xda\xce\x04\x97\x43\x03\x05\x11\x9f\x44\x04\x75\x1f\x27\x51\xf0\x1f\x3f\xb0\xec\x3c\xc1\xbd\x6f\x19\x22\xc5\x27\xd8\x06\x72\x67\xb1\x9c\x17\x91\xaa\xfa\xbc\x70\xbb\x80\x97\x55\xe9\x6d\xa2\x48\x4a\xd0\x55\xf9\x81\x30\x5b\x52\xec\xb5\xb9\x72\xf3\xf3\x43\xf5\xb1\x7c\x2b\xa5\x71\x69\x08\x06\x89\x49\x30\xb2\x46\x49\x59\xa5\xf5\xc3\x9a\x8e\x0a\x69\x2b\x98\xea\x2b\x91\x21\xe8\x12\x50\xfd\x89\x1a\x74\x4b\xa2\x49\xdb\x9e\x04\xf3\x97\x0d\x65\x45\x79\x88\xcd\x23\x00\x1b\xe8\x5b\x05\x60\x03\x9d\xd9\x6d\x11\x81\xa9\x0d\xea\xc8\xf0\x75\x73\x7e\xaf\x7f\xe8\x6a\x01\xc2\xc5\xb7\xaf\x8c\xef\xa4\x17\x49\x18\x1b\xf1\x7b\xe1\x80\x36\xc8\x23\xa8\x84\x5c\x1d\xd0\xb3\x87\x55\x2c\x94\xd7\xf8\x7e\xec\x2f\x11\x2c\x52\x15\x55\x1c\xb5\xa9\x68\x96\xc5\xc1\x00\x8f\x7d\x6e\x35\xcf\x6b\x58\xc0\x29\x53\xf3\x23\x29\x98\x5a\xb3\xfc\x25\x92\x1c\x9c\xef\x07\xf4\x78\xf4\xd1\x74\x74\x1e\x54\x6f\x04\xb3\x41\x75\x7c\x1f\x5d\x03\xbb\xc6\x5f\xa1\xab\x5a\x76\xcb\xcf\x98\x86\x65\xf1\x38\xd6\xff\x3a\xf2\x0c\x1d\x8d\x0d\xb6\x06\xfb\x8c\x10\xea\xb5\xd8\x1d\x23\xbe\x04\x70\xff\xd3\x33\xf0\x03\x12\xe5\x7b\xf8\x39\x5a\x74\x62\xc0\x8b\xc0\xdf\x8b\x35\x77\xec\x0c\x3a\x80\x76\xf1\xb5\x68\x08\xb8\x9f\xa9\x8e\x3f\x14\xf8\x6e\xdd\x22\xba\x49\xc1\x96\x1a\xac\xf0\x64\xc0\xb2\x1f\xd0\x6b\xc8\xe8\x22\x16\x3b\x07\xb4\x81\x56\x41\xce\xc8\x99\x34\x06\x4a\xea\x2e\xc3\xba\x4d\x27\xb0\x72\xc8\x40\x46\x6d\xb6\x9e\xa7\x57\x2a\xd3\x10\x91\x9d\x3f\x89\x51\xc5\x88\x2f\xa6\x2e\xbe\xab\x30\x8b\xda\x03\x43\x0e\x5a\x3b\x09\x7d\x34\x09\xed\xa3\xcf\xd3\xd7\x11\xbe\xe3\x0b\x3f\x20\x2d\x29\x12\x2d\xb4\xc2\xbb\x40\xe6\x94\xaa\xb1\x53\x6c\xd0\x18\x00\xe4\xcd\x82\x60\xe1\x45\x83\xca\xac\x31\x42\x5e\xc5\x63\x27\x54\x95\x98\x2d\x9e\xf0\xf3\x5b\x0d\x86\x95\xd7\x9b\x74\x77\x55\x4a\x43\xa7\x95\x25\xa1\x47\x81\xb2\x1c\xf4\x7a\x2e\x3a\x91\x8b\x2e\x84\x80\x5a\x5e\x9c\x7e\xed\xc8\xe2\x7c\x70\xe2\xc4\x07\xf2\xd2\x3c\x32\x98\x6e\x22\xf7\x62\x77\xe3\xf3\x74\x44\xc1\xe5\x0d\xe1\x65\xa1\x28\xa3\x8e\x66\x79\xec\xd9\x31\x0c\x69\xce\x35\x19\x04\x9a\xd5\x41\x4a\xad\xd5\x72\xa3\x63\x5a\x01\x12\xef\xbd\x54\x11\x67\x7b\x55\x4d\xdb\xab\x2f\xb2\x30\x64\x59\x94\x6b\x2e\xfc\xea\x13\x50\xfe\x05\xb8\x05\x54\xc5\xf7\xfc\xf6\x34\x76\xeb\xfa\xc6\x51\x15\x3a\x4a\xdf\xc4\xae\x40\xb9\xe0\xc3\xf8\x70\xe4\x90\x2e\xea\x2c\xf1\x1f\xe8\x2f\x30\x3d\xbb\xb1\xcf\xf9\x84\xe4\x73\xf6\x8a\x86\x29\x3d\x76\x82\x59\x5a\xa5\xd5\x73\x8c\x5a\xa3\x31\x63\x9a\x4c\x2a\x56\x4b\x33\x40\xcd\x19\x19\xab\x11\xa4\x0d\x7f\x92\xef\x02\x12\xb8\x7f\xe9\x04\xf9\x09\x19\x6a\x90\x24\x0b\x6a\x2a\x9e\x44\x87\xd1\x09\xd0\x82\xbe\x05\xd9\xfb\x40\x0e\x8e\x26\xbc\xbb\x9e\xc4\xc1\xff\x32\xb4\x82\x2e\xa5\x55\xa4\x87\x28\xfe\x5f\xf4\x4a\xc2\x0f\x5e\x8d\x75\xc0\x7a\x69\x8d\x7a\x45\x43\xd8\xff\x35\x60\x9d\xc3\xea\x78\xb5\x9a\x35\xe8\x8d\x38\xfe\x54\x31\x7a\x06\xaf\x8d\x5e\x20\xb3\xc7\x28\xa3\x12\xe1\xc8\xd3\x73\x8e\xa6\x55\x55\x29\xc9\x74\x79\x91\xf8\xa4\x47\xfe\xff\x71\xf6\x1d\xf0\x51\x55\xd9\xc3\xef\xbe\xfb\xca\xf4\xde\x5b\x66\x32\x49\x26\x7d\x92\x0c\xc9\x90\x00\xc9\xd0\x91\x92\x84\xd0\x32\x84\x24\xa0\x74\x0c\x48\x13\x90\x2e\x22\x4d\x40\x50\x50\x51\x11\x10\x11\x95\x45\x29\x52\x15\xb0\xa0\x28\xb8\x8a\x65\x11\xb1\xac\x6b\x61\x75\x71\x15\xc4\xf2\x97\xcc\xcb\x77\xef\x7d\x6f\x4a\x00\x77\xf7\xf7\x6d\x56\x98\x0c\x33\xef\x9e\x76\xcf\x3d\xe7\x9e\x86\x08\xe6\xdb\x0b\x3f\xcd\x17\x76\x1d\x88\xb7\x94\xfe\xa3\xe6\xda\x91\x6f\x85\x27\xd8\xc5\x48\x0d\x89\x3d\x8b\xc1\xc3\xa2\x2f\x33\x06\xf1\xab\x9a\xd4\xe9\xdf\x1a\xe9\xa0\x32\xab\x4d\x6a\x8d\x11\x69\x1b\x13\x4c\x4b\xe3\x9c\x5e\x27\x30\xe9\x34\x5c\xba\xcf\x60\xb3\xc9\x6a\xa3\x36\x8b\xc5\x46\x99\xb4\x35\x51\x93\x59\xad\x85\x5e\x0a\x69\x77\xe2\xd7\xa4\xce\xf5\xa9\x4a\xb5\xcf\x43\xc9\x7c\x7c\xa9\xa4\x15\x79\x8c\x24\x4c\x29\xa6\x6f\x13\x9e\x86\xfd\x5c\x3c\x48\xe9\x5f\x49\xbf\x99\xf9\x7e\xad\xe3\xe1\x6e\xcb\x9a\x35\xb8\xcf\xcf\x83\x48\xe5\x6c\xb7\xc1\xf5\x57\x70\x64\x72\xf8\x17\x4c\xc5\x31\x61\xd2\xdc\xdc\xc5\xfd\xef\x1e\x10\xef\x44\x75\xf8\x8c\x38\x05\xf7\x5d\x84\xcb\x2e\x84\xcb\x29\xe2\xdb\xf7\x8f\x04\x4c\xb4\x19\x71\xd2\x66\x05\x5a\xe4\xe5\xd8\xa0\xc5\x69\x71\xb1\x86\xe6\x28\xad\x64\x59\x60\x56\x42\x07\x00\xd6\x54\x95\x1e\xba\xc9\x65\xbf\x74\x07\x81\x34\xfb\xcd\x1a\x66\x13\xe7\xa7\xfe\xad\x9b\x34\xcd\xfe\xea\x71\xe4\xff\xdc\xd8\x36\x5b\x72\x84\x00\x35\x11\xc9\x24\xee\x95\xe5\xa0\xfa\x45\x02\x72\x83\x42\xaf\x50\xea\xd4\x2a\x3d\x72\xda\xf5\x6a\x25\xe3\x72\x9a\x90\xa1\x6f\x70\x98\x4c\x7a\x85\x43\xab\xd5\xe3\xce\x01\x7a\xf3\xf5\x70\xb6\x77\x80\x12\xfd\xbd\x2c\xa9\xdd\x94\x6e\xda\x2a\x6b\xf7\x06\x44\xd3\xc3\x37\xe9\x96\x25\xd2\x33\xd9\x31\x2b\xd9\x77\xdc\x89\xe1\xe4\x8c\xd0\x02\x6c\x9c\x53\xe7\xa4\xec\x76\x9d\x5c\xee\x70\x39\xdc\x16\x23\x67\x6c\x8e\x42\x96\x02\x26\x15\xc7\xd9\x55\x52\xdc\x5d\xba\xdb\x49\x8d\xde\x60\xf7\xb1\x44\xf4\x54\x7c\x46\x74\x24\xf9\x8d\xa9\xf4\xc4\xd7\xd9\x65\x52\x0f\xf2\xc5\xa3\x4a\x5f\x2f\xfe\xeb\xdf\x44\x82\x0e\x19\x3e\xe0\xf5\x01\x53\xa6\x4a\x8d\xc8\x0b\x0c\xc2\xbf\x00\x48\x52\x75\x70\x93\x1a\x3c\x20\x4c\x55\x7b\x49\x4b\xf2\x64\x0f\x32\x17\xee\x41\x86\xa3\xa0\xd0\x6e\x37\x73\x06\xb9\x4e\xc9\xbb\x35\x6a\xb5\x47\xce\xb9\x2c\x88\xb4\x66\x9d\x85\x37\x59\x78\xde\x62\x82\x5a\x95\x4b\xab\x25\xa3\x20\xa5\xba\x12\x72\x23\x75\xfd\x5d\x5a\xa2\x07\x59\x1c\x4e\xdc\x85\x4c\x0b\xfc\x61\x3e\x49\xde\xd2\xd2\xd2\xf9\xa1\xa2\x71\x52\x2f\xb2\x86\xae\xd9\xf3\xfd\xdd\x93\x14\x2e\xe8\xc2\x01\xa5\xd0\x2a\x73\x8b\x4d\xc9\xb2\x8d\xa7\xf7\xc1\x78\x63\x32\x40\xe5\x20\x3a\xe7\x92\xd9\x0e\xc1\x88\x55\xcd\x01\xa3\xd1\xc4\x99\xac\x16\x46\x47\xfa\xba\xe3\x9e\xee\x26\x43\xfc\xfc\xb8\xbe\x5d\x92\x38\x32\x2b\x51\x53\x46\x66\x35\xd3\xa3\x26\x3e\xfc\x5a\x14\x2c\xd4\x45\x85\xaf\x87\xa8\x66\xcc\x5c\xf3\xf2\xdd\xe2\xd8\x95\xd8\x67\x21\xaf\x70\xb0\xc7\x60\xa1\x08\xbc\xd8\x39\xd4\x3c\xa8\x34\xd6\x8c\x96\x8d\xf7\xfc\x60\x56\x93\xfe\x1d\xfd\x88\x3d\xee\x6c\xbb\xc4\x3d\x41\xe6\xe1\xe6\x52\x43\x22\xf9\x19\x76\xf4\xc2\x8d\xdc\x3f\x9d\x52\xc9\x53\x76\x26\x3f\xcf\xcd\x1b\xf8\xe6\x68\x6e\xba\x41\x6d\x50\x43\xb3\x39\x80\x2c\x55\x06\x7a\xdb\x25\xf4\x8a\xd1\xf0\xf2\x1b\x9b\xca\x88\xb0\x73\x62\xa1\x83\x28\xa3\x56\xce\x6c\xb1\xe2\x52\x6a\x8b\x81\x14\x8a\x89\x9b\x4c\x1c\xcc\xcc\x73\x9e\xb1\xc2\x99\x2f\x0e\x0b\xbf\xac\xd7\xac\x7e\xa4\xdb\xdb\x85\x60\xfa\x00\xb0\x11\xf8\x76\x5d\x5b\x66\xd4\xb6\x52\xbb\x9e\xfa\x72\x43\x1e\x43\x3f\x78\xcf\x0b\x9f\x67\x03\xdb\xfa\x4d\xab\x80\xeb\xf5\x05\x77\x4d\x78\x2c\xad\xb1\x7f\x5f\x08\x5c\xa0\xd3\x6a\xe1\xda\xce\xd0\x86\x2e\xc7\x4f\x9e\x02\xdb\x2b\x1e\x7e\xf2\xd8\x41\x8a\x6e\xfb\x03\xf9\x1b\x31\x32\x1f\x37\x9b\x9a\x10\xe9\xe4\xf3\xf0\xb2\x6c\x9a\xb6\xe1\x28\x0d\xcc\xb5\xe8\xf5\x39\xd9\x54\x5d\x34\xdb\xa7\xd3\xf7\xc1\xe5\x1d\xb4\x9a\xcd\xb6\xd9\xb4\x75\x51\xde\x66\xb4\x19\x95\x4e\x67\x66\x5d\xd4\xa9\x53\xb2\x03\xa3\xca\xeb\x6b\x1b\xc8\x8d\x26\xee\xb0\x93\x12\x5b\x4f\xc1\x59\xd4\x1e\x56\x51\xa1\x84\x33\x44\xcc\x4d\x56\x29\xa8\xc1\x07\xc2\x62\x18\x91\xce\xe1\x1b\x1b\x1e\xe8\xf6\x4b\x9f\x2f\x0e\x7c\xf4\x13\x2d\xfc\x5a\xfd\x6c\xe1\x88\x30\xc8\x7c\xe7\xec\x57\xb6\x4b\x70\xc4\xb0\x91\xf7\xda\xc1\xa7\x59\xa1\x89\x53\x9f\xe9\xfb\xf8\x82\x8b\xef\xf6\x54\xbe\x38\x72\x4d\x51\x75\x71\x1f\xfe\xec\xb7\xe7\x5e\xbf\x6d\xc6\xd1\x8e\xb7\x4d\x5c\x31\x4f\xe4\xa3\x70\x99\xf0\xd1\x4f\xe5\xe1\x5e\x19\x99\x0e\x3f\x45\xb3\x79\x1e\x8f\x51\xa6\x57\xa9\x64\x2c\xe5\x60\x0b\xf2\x3d\x32\xa3\xac\x39\x9a\x87\xd4\x9c\x51\xc3\x5a\x2c\xd9\xcd\x51\x0b\xc3\xfa\x90\xe1\x4b\xb3\x38\xb7\xf7\x9d\xff\x81\x9d\x04\x39\x9a\x45\xfb\x3a\x8b\xd2\xff\x4f\x1c\x3d\x28\xec\x0d\x7d\x58\x72\x59\x68\xfd\xef\x2c\x15\x5a\xd3\x85\x36\x40\x39\x41\x15\x50\xfd\x17\xc6\x92\x7c\x83\xdf\x85\xcb\xcc\x35\xc4\x5b\x8c\xf3\xec\x48\xf7\x4c\x1f\x2f\x53\x6a\xf2\x68\xda\xa9\xd7\x6b\x64\x3e\xa6\xc0\x6e\x32\xe5\xe7\x21\xf6\xe6\x11\xf6\xe6\xa5\xe5\x21\xf6\xe6\x39\x9d\x06\xc4\x5e\x27\x3a\x27\x34\x1e\x4f\x76\x5d\xd4\xa3\x53\x6b\x22\x4a\x8d\x86\xad\x8b\x6a\x2c\xe2\x21\x87\xeb\xd0\xfe\x27\x46\x5f\xc7\x6a\xac\xee\x90\x1b\xf3\x1f\xb8\x1d\x10\xb9\x5d\xf5\xfc\xbd\xa1\x0f\x43\x3b\xf7\xfe\x47\x86\x2f\x5b\xa0\x43\xd4\x60\x5c\xff\x78\xfe\x4f\xd9\x7e\xe3\xec\x37\x71\x36\x11\x5f\x66\xc8\x82\x6f\x4a\xf3\x66\x8e\x81\x72\x92\x2b\x9b\x9e\xce\x66\x81\xcc\xfd\x99\xf9\xac\x25\xa5\x27\x0b\xe9\xb3\x8c\x7b\xb2\xc0\x8b\x52\x4f\x96\x97\xa4\xdc\x5a\xd2\xc6\x25\x73\x6e\x66\x3e\x63\x4d\x9d\x4f\x83\x7c\xda\x91\xa4\xd6\xf6\x96\x48\x96\x5b\x4b\xa7\xa7\xfb\xfd\x16\x95\x96\xc9\xe0\x65\xb2\x4c\xab\xd1\x4f\xfb\x46\x45\x55\x34\x4d\xf9\x0d\x46\x7b\x73\xd4\xe8\xe4\x13\x76\x9f\x74\xf3\x7c\x33\xa5\xeb\x83\x25\x95\xb4\x18\xd5\x25\xd3\xdc\x93\xd7\x49\xf1\x61\xc2\xc8\x29\x0d\xcc\xf2\x84\x7a\x34\x83\x3a\x64\x75\x1d\x0c\x8c\xcf\x3a\xf5\xea\x1e\xe1\xc4\xc9\xfb\x3e\xae\x7d\x61\xd4\xce\x96\x43\x93\x76\x3c\xf2\xd6\x1c\xe1\x13\xa4\xfa\x9e\x35\x77\x9c\x08\x9e\x10\x46\x95\x8c\x71\xe6\x5e\x3b\xfb\x89\xf0\xfc\xa1\xf2\x7e\xfb\x46\xcc\xbe\xb0\x69\xf3\x9e\xd8\xfa\x78\x9c\x6b\x18\x33\x92\xd4\xcb\xf6\x8c\x64\x72\xbc\x43\x0d\x70\xb6\x80\x51\xa9\xe6\x59\x7f\x3a\xf0\xd4\x45\x91\x1f\xe8\xe5\x7c\x5a\x93\xce\x6b\xd6\x59\x6b\xa2\x3a\x67\x3c\x53\xa1\x4a\xaa\xae\xbb\xee\xe2\x48\xea\x04\x8c\xc0\x67\xf4\xd7\x5d\x1a\x91\x49\xc8\xb4\x6e\x78\x59\x79\xaf\xf2\x67\xf1\xe5\xae\xd5\x97\x09\x86\x0b\x3b\x85\x0b\x77\x9f\x29\x15\x6f\x8d\xd6\xdd\xb9\x6d\x98\xf0\xed\xfb\xe4\x9e\x37\x73\xf0\x60\xdc\x26\xd8\x9b\x99\x5e\x23\x3c\x2f\x7c\x2f\x1c\x94\x6e\x8f\xe6\xaf\xc1\xa1\x0e\x3c\x6f\x07\xd9\x3e\xdb\xe2\x73\xff\xad\x26\xa3\xcd\x64\x93\x53\x06\x83\x43\x8e\x34\xd6\xc8\xa8\xcd\x80\xe7\xed\xe8\x21\x3a\xf5\xf0\xc0\x9d\xa4\x23\x8b\x77\x36\xb0\x05\x43\xfa\x50\xca\x28\x0e\xe0\x53\x00\x0d\x1d\x88\x57\x8c\x18\xe2\x19\x65\x78\xe4\xce\xc9\xc9\x63\x27\xdf\xd3\x99\x8c\xdc\xc9\xed\x3e\x60\xc2\x05\x78\x48\x4c\x8c\xbb\x93\x59\x1d\xdb\x2b\x7c\xbf\xef\xd6\x00\xd4\xff\xc6\xf7\xde\x0a\x5c\xf4\x7d\xa2\x9d\x49\x68\xdb\xb6\x1b\xd9\x3c\x62\x4f\xe3\xf2\x88\x87\xb3\x31\x80\x42\x76\x98\x0d\x22\x03\xc7\x6e\xe5\x6b\xa2\x56\xad\x4a\x57\x1b\x85\x2a\x0b\xc5\x12\x37\xf7\x8d\x44\x3f\x8a\x14\x79\xc8\x14\xb3\xf4\x7c\xe2\x30\xa0\xf8\xc5\xa2\xd1\xc7\x64\x93\x24\xb6\x99\xbb\x85\x6f\x96\xdc\x39\x61\x4e\x93\xd8\xcb\x29\xaf\x53\xa4\xe9\x09\xe8\x3d\x8e\x93\xd6\xe0\x3c\x61\xa6\xf0\xf1\xa6\xee\xb8\x7b\x53\xe9\x82\x18\xb8\x40\xf8\x9d\x83\x64\xf6\x47\x44\x33\x2b\xa6\x99\xd2\x68\xc4\x2d\x9b\xa0\xc6\x64\x33\xd9\xf5\x88\x4a\x48\x59\x18\xb5\x90\xa1\x34\x06\x8a\x43\x26\x78\x7b\x5e\xa7\xde\xfa\x8a\x4d\x4a\x13\x92\x19\x4e\xb9\x1f\xa7\x29\x7a\xb0\x78\xbd\xd9\xb4\xf5\x4e\xd7\x2d\xb1\x4d\x33\xd1\x41\x6c\x10\x6f\x82\x41\xe0\x5f\x9d\x85\xcd\xc2\x30\x7c\xad\x39\xfa\x95\xd5\x60\x76\xe2\xc2\xbc\x9f\xf0\x8e\x70\x0c\xc1\x07\x91\x3c\xee\x25\x71\xb6\x1e\x11\x3f\x25\x93\xc9\x39\x9a\x86\x5a\x28\x87\x36\xab\x0e\x07\xdd\x6a\xa2\x6a\x27\x07\x6a\xa2\x1c\x07\x65\x8c\x16\x8a\x76\x4c\x79\xf0\x4f\xef\x31\x93\xd3\x4d\x38\x9c\x76\x26\xca\x62\x18\x7a\xc9\xf5\xf0\xfb\xc0\x31\x08\x2c\x19\x04\x1c\x6f\x04\x85\xf3\xc2\x4f\xc2\x77\xb7\xbf\x96\x36\x2e\xf2\xe0\x23\x19\xe2\x6d\x31\x69\x62\xdc\xf6\xfb\xf7\x0f\x2e\xf6\x86\x76\x1c\x4c\xc6\x85\xc5\x38\xc3\xc0\x48\x8e\x06\x39\x7a\x62\x8f\x65\x25\x9e\x03\x03\x75\xd8\xc1\xd2\x50\xe2\xed\x39\x25\x27\x73\xe1\x94\x23\xa3\xd4\x4d\xc3\x0c\xa9\x71\x90\x78\x82\x47\x4a\x94\x01\xb1\x1d\xbe\x74\x43\x94\x61\x23\x96\xbb\xf6\x71\x06\x2c\x6d\xa9\x71\x86\x9e\x91\x0c\x7c\x13\x2c\xe7\x64\xac\x02\x90\x86\x5c\x1c\x72\x43\x75\x62\x80\x01\x37\x4a\x94\x69\xcc\xac\x42\x94\xb8\x1b\x66\x5f\xa4\xec\xe3\x38\x14\xed\xc3\x0a\xcf\x2f\x15\x0e\xfd\x71\x65\x7a\xfb\xb8\x02\x49\x92\x4c\xc6\x15\xf6\x20\x1a\xbd\x43\x7c\x92\xca\x88\x97\xa2\x0d\x4a\x25\x3a\x25\x9d\x36\xbb\xdd\x25\x33\x37\x47\x59\x8d\x4c\x46\xd9\x34\x64\x58\x0e\x8d\x49\xf3\x4e\xfc\x72\x5f\xf2\x45\x52\xbc\x4e\xdc\xb0\xe2\xe6\x93\x7b\x18\x43\xcd\x1f\x0b\xe7\x76\xbe\xd9\xf4\x1e\x3c\xba\x0e\x04\x6f\x3a\xc1\x27\xd5\x0f\xe9\x12\xf1\x2a\x94\xc8\xa7\xb3\x5a\xb5\x86\x54\x0f\x44\x8d\x3c\x10\xb5\xae\x26\xaa\xc5\x5d\x00\xda\xc1\xd6\xae\x01\x6a\xaa\xe7\x41\x1a\x6b\x84\x6f\xda\xa4\x77\x5b\xcd\xe5\x19\x77\xe5\xdf\xac\x4f\x2f\x02\x73\xe8\x97\xc9\x56\xbd\xa2\x6c\xe1\x59\x5d\x94\x87\x1a\x1c\xc9\xd3\xa8\x1d\x7a\x07\x64\xe5\xac\xc7\xc2\x00\xe0\xf6\x78\xbc\x36\x9c\x32\x98\x26\xd7\x3b\xf4\xac\xdb\x0a\x35\x16\x03\x64\x59\x0a\xcf\x06\x4c\xf8\x49\x55\xa1\x76\xe5\xe1\xa1\x64\x3b\xc3\x50\x52\x95\xa0\xdd\xaa\xa1\x81\x1f\x06\x01\x4f\x52\xb7\x7c\xd8\xc6\x00\x3e\xf6\x5f\x44\xb6\x9a\x76\x99\x4a\x20\xdf\xb7\x87\xd0\xfd\xfd\x26\x9b\x8e\x35\x1a\x77\x09\x7f\xa0\xdd\xbb\xaa\xde\xee\x18\x07\xd6\x83\x15\x64\x38\x20\x9c\x31\xf6\x5d\xa5\xfe\xc9\xb5\xad\x6b\x61\xe8\xb3\xed\x79\x7f\x19\xd3\xba\x82\x5d\xdc\x7a\x49\xb8\x54\xfe\x37\x68\x4f\xc4\xbd\x48\xbf\x74\x1b\xf6\xa3\xac\x44\xf7\x29\xe4\x26\x3d\xbe\xf2\x53\x9a\x58\xe4\x9d\xf2\x0e\xbb\x4c\x69\x52\x2a\xac\x3a\x2d\x52\x8b\x5a\x64\xf0\x23\x72\x23\x1c\xf4\x09\x2c\x6e\x22\x95\x12\x0a\xa4\x5f\x3a\xf1\xa8\xe2\xfd\xd2\x59\xf3\x3d\x58\x1d\xd6\x2e\xd7\x96\xe1\xa6\xe9\xbc\x73\x79\x6a\xcf\x74\xa2\x0f\xe9\x23\x43\x76\xe3\xbe\xe9\x63\x1f\x8d\xf5\x4a\xb6\x4d\x6f\xdf\x0b\xb0\x26\x39\x9b\x92\x4f\x33\x64\x61\x8b\x42\xcf\xcb\x19\x62\x07\xd8\x0e\xd0\x5a\x2d\x9b\x45\x1b\x0e\x81\xf0\x7e\x83\x83\xe1\xdb\xf5\xbf\xc4\xb3\x50\xca\xd9\x7f\xa0\xef\xf4\x20\x35\xa1\x9b\xa8\xbf\x89\xb6\x03\x8d\x70\xc9\xa2\x3b\xbf\xd8\xb9\xa7\x2a\x37\xc5\xd6\x20\x6b\x90\xb9\xb4\x19\xd2\x0c\xe2\xb3\xa0\x1f\xae\x21\x85\xb4\xc5\xc2\x66\x41\xda\x78\x08\x14\xee\x37\xea\xc5\x65\x92\xb5\xa7\x64\xe6\x0a\xe9\x53\xd8\x43\xea\xb3\x79\x36\xde\x67\x33\x12\xc1\x7d\x36\xbb\xac\xef\xd2\x49\x5c\x29\x3e\xcf\xb6\xed\x09\x8a\x92\x89\xb3\x36\x97\x13\x58\x73\x91\x9f\x73\x8e\xf4\x42\xdf\x99\x9c\xe9\x48\xf0\xcd\x96\xf0\xdd\x20\xd9\x3d\x78\x1c\x32\xd0\x1e\xd3\x5a\xdb\xcd\x4f\x16\x7b\x7d\xfe\x23\xde\xeb\x13\xe1\xfa\xb6\x84\x2b\x6e\xf5\x49\xfb\x57\xfb\xf3\x93\xdd\x41\xd1\xe7\x27\xb5\x5d\x62\x8f\xb2\x1b\x75\x1c\x18\x98\x3a\xdf\x42\xc7\xd1\x4e\xf2\x3b\xf9\x77\x4c\x0b\xfc\xef\x84\x16\xcf\x88\x33\x7a\x21\x9d\x9b\x8b\x69\x11\x98\x15\xc8\xb4\x6a\xdb\xcd\xe8\x4d\xf4\x1b\xc5\xcf\x20\x74\x78\x25\x4e\x87\x40\x80\xf4\x1b\x1d\x9b\x91\x6e\xd6\xb4\xa3\x03\xb1\x07\xf1\x3a\xa2\x3d\x48\x4d\xa4\xef\x8d\xcf\x02\xce\xc9\xc1\xf5\xbe\x59\xcf\x67\x65\x88\x16\x61\xe2\x3b\xa2\x4d\xb8\x32\x6e\x13\x22\xd8\x9e\xa2\xa8\xf8\x77\x70\xad\x6f\xd6\x43\x59\x19\xa2\x55\x98\x80\x8d\xcc\x88\x24\xeb\x9c\x92\xbe\xd3\x12\x5f\xa7\xb0\x10\xaf\x93\x77\x32\x2f\x07\x7a\xda\x7d\x87\xcc\xb4\x20\xeb\xfc\x53\xc2\x67\x47\x7c\x9d\x82\x02\xbc\x4e\xee\x7d\xb9\xd9\xd0\x99\xda\x3f\xb5\xed\x7b\x44\x37\x03\xb9\xab\xe8\x1d\xc9\x30\x71\x4e\x1b\x3a\xe3\xd4\x0e\xa4\x2c\x90\xe3\xef\x82\x1a\x1b\xb2\x86\xe4\xfa\xe6\xa8\xdc\x88\x68\xe4\x4c\xbd\x51\x4b\x74\xa9\x69\x7f\xd1\x47\x12\x3d\x49\x6b\x08\x64\xb7\x5d\x97\x8a\x86\x2c\x52\x17\xfc\x35\x4b\x58\x3d\xef\x01\x64\x8c\x7d\xf1\xd0\xf9\x35\x85\x40\x95\xbf\xe9\xae\xe5\xdb\x36\x2d\xee\x94\x0e\x86\xc4\x26\xb3\x8b\x4f\x0a\x47\xdc\xaf\xaf\xba\x26\x7c\x36\x74\xcb\x9a\x86\xa5\x77\xae\x98\x36\x71\xe1\x1e\x50\x4a\x6c\xf3\xb6\x47\xd1\xb9\x5e\x82\x7b\xc0\xd3\x83\x13\x32\xf7\x35\xf7\x78\x7c\x16\x24\xbd\x0a\x9c\x02\xdd\x28\x53\x44\x05\xb4\x58\xe4\xb6\x69\xf5\xf1\x51\x90\xa5\x29\xb3\x30\x1a\xa4\xfe\x8a\xf8\xf3\x3c\x7a\x30\xfe\xbc\x07\x77\x58\x6c\x40\xea\x51\x91\xfa\x79\xf1\xf9\x1f\xc5\x9f\x8f\x78\xf0\xf7\x38\x0f\xcc\x66\xcc\x03\xc3\xcb\x06\x1d\xc5\xb7\xe3\x81\xb8\xc6\xca\xf8\x1a\xe8\x3b\x9a\x38\x0f\x32\x32\x30\x0f\x7c\x63\x7c\x69\xe2\x32\x89\xef\x90\xde\x09\x64\x1f\x97\x48\xdf\xf9\x67\x5c\x76\x33\x32\xb0\xec\xfa\xee\xf3\xa5\x29\xe1\x0d\xb2\xbb\x95\xac\x53\x27\x7d\xc7\x12\x97\x5d\x5c\x3f\x0e\x69\xcf\x32\x8f\x8b\xa7\x52\x78\x9d\xda\xa3\xc1\x8c\xcd\xb2\x88\x57\x6f\xb7\x19\x0c\x4a\x3b\x84\x4a\xb7\xcb\x66\x68\x8e\xda\x6c\x88\x20\x16\xdc\x7a\x81\xd7\x36\x27\xe6\x4b\xde\x64\x78\xd8\x4d\x9a\x2e\x18\xbd\x46\xdc\xc3\x0d\x78\xa1\xef\x26\x5d\x16\x3a\x82\x19\x53\x5a\x4f\xed\x07\xd5\xc2\xc3\xd3\x60\x90\xde\x73\x63\x53\x85\x6b\x95\xe0\x5e\xf3\xe1\x43\xf0\xbc\xb0\xf1\x2f\x2f\x8b\xf5\x9f\xc9\x5e\x0a\x66\xca\x4d\xd5\x47\x8a\x0d\x16\x0b\xe5\x22\xbd\xa6\xd3\x3c\xc6\x35\x2e\x30\x1f\xf9\xb2\xae\x7e\x2e\xda\xee\x02\x50\xeb\x02\x6a\xce\xe5\x62\x94\x4a\xfb\x0d\xd5\xdf\x89\xe6\xb1\xcd\x8d\x62\xe3\xd8\xf6\x88\xb4\xeb\x9d\x00\xb0\x29\xea\x33\xeb\x80\xe8\x62\xfa\xda\xf7\x4b\x88\x6d\x18\x32\xbe\xc6\x21\x28\x68\xcb\xed\x63\xe6\xac\xcc\x02\xbf\xb7\xeb\x90\x10\xab\x28\x9f\x73\x9b\x41\x88\xd1\x54\xcb\x8c\x15\x2b\x92\xb3\x31\x31\x6f\x99\x47\x24\x3e\x7d\x25\xf2\x96\x81\x7e\x3f\x9b\xc5\x40\xef\x32\xaf\xe7\xcf\x78\xcb\x6c\x92\xbe\xc3\x88\xbc\x65\x20\x6e\x9d\xcc\xc0\xf4\x99\xe9\xde\x54\xde\x8a\xfa\x98\x7d\x82\xc8\xea\xe7\xd2\x77\xee\x8b\xcb\x6a\x66\x26\x96\xd5\xf4\x15\xe9\x5e\x45\xfb\x75\x48\xcf\x6f\xa2\x2f\x04\x49\x5f\x1c\x8e\xcb\x2a\x69\xd1\x0c\xd2\xe7\xdf\xf0\x1d\x32\x4f\x93\x7b\x22\x3e\x23\x1a\xed\xa1\xa7\x41\x0f\xb2\x87\xf0\x48\x69\xe3\x74\xa3\x39\x3e\x22\xba\x34\x39\x13\x83\xec\xb9\x11\xe2\xe7\xa9\xd3\xd2\x9e\xb3\xa3\x3d\x67\xbf\xc3\xee\x8c\xb7\x28\x15\xf7\x9c\xf8\xfc\x8f\xe2\xcf\x47\x78\x3c\x11\xc7\xc3\x6e\xc7\x78\x58\x26\x5b\x4c\x74\x7b\x9d\x2c\xae\xb1\x32\xbe\x06\xc2\xe3\xd3\x38\x1e\x69\x69\x18\x0f\xd7\x3d\x2e\x87\xb8\x4c\x7b\x3c\xf8\xdc\x04\x1e\x4f\x80\xef\x41\x7f\xf1\x3b\x6e\x37\xd9\xdb\x5f\x1b\x9c\x37\x59\xe7\x67\xd2\x9f\x75\x84\xf4\x1d\x53\x7c\x1d\x5c\x38\x4b\x03\xdb\x45\x9b\xef\xba\x75\xc8\x5d\x30\xc1\xe7\x63\x09\x9f\x43\x71\x7c\x3c\x1e\xbc\x8e\x73\xb8\xd3\xce\x9b\xdb\x7d\x87\xdc\xc7\x12\xbe\xfc\x2e\xe1\xf3\x59\x7c\x1d\x8f\x07\xaf\xe3\xbc\xc5\x69\x37\x2a\xdb\xf5\xc1\xc6\x3e\x05\xae\x4f\x90\x53\x1d\x22\x76\xec\xd7\xf0\x32\x5e\x41\x51\x4a\x4e\x26\xa7\x71\xfe\x0d\x49\x5b\x32\x24\x02\xfe\xed\xb3\x94\xc4\x2e\xcf\xe4\xee\x5b\x1c\x37\x7d\xe0\x91\x85\x7f\xd4\xbe\x41\x26\x4e\xe3\xf8\x2b\x78\x84\x5d\x44\xf2\xeb\xc7\xc3\x77\x91\x3d\x26\xa7\x4a\x22\x36\x8a\xe7\x00\x0f\xa0\x02\x2a\xf1\x68\x57\x5c\x7e\x00\xb8\x9a\x78\x10\xe8\x86\x25\x8a\x8b\x42\x7e\xa3\x14\xe5\x7d\x7b\xe7\xfb\xf4\x85\x4c\xa1\x6a\xf9\xc2\x19\x97\x99\x8a\x63\xb1\x6e\xb1\x67\x13\x77\x2f\x32\x3f\xa1\xd5\xa7\xd2\xd9\xfa\x49\x7c\xaf\xa4\xa5\xe1\xbd\xe2\x7a\xd8\xe5\x50\xb6\x9f\xb3\x4f\x7a\xff\x13\x5a\xb5\x4a\xf4\xfd\x29\xbe\x57\xb0\x21\xc1\x40\xf7\x58\xb7\x53\x43\xb7\x3b\xf3\x1e\x43\xfe\x6b\x84\x9c\x79\x23\x23\x21\x4e\x01\xec\x36\xa5\xc2\x6e\x57\xf2\x4e\x06\x1a\xa0\xdb\xe0\x52\x28\xec\xb4\x1c\x1d\x77\xa3\x48\x75\x85\x5d\xaa\xeb\xd0\x1a\x9b\xa3\x5a\xf3\xa8\xa8\x16\x7b\xb4\x29\xa5\x0e\xf1\x71\xa1\xb6\xe0\x75\xa3\xae\xae\x2b\xf8\xc0\xe5\xa9\x71\xef\xbb\x0a\x9b\xa0\x2d\x2b\xa6\xc1\x8f\x0b\x62\x35\x3d\x41\xa7\x80\x70\x72\xec\x94\xf4\xf4\x13\xdb\x0b\xa7\x78\xb2\xc3\xc1\x15\x0e\xfd\xf2\x39\x2b\x60\x47\xfa\x96\xaf\x85\x47\x4f\xc5\xae\xee\xd9\xf3\x9c\x92\xfb\xab\x6a\xfe\x70\x7a\x0a\xbe\x13\xd8\x20\x0c\x83\x07\x11\x1f\x9c\x78\xee\xa2\x59\x06\x79\xde\x61\xb1\x59\x64\x0c\xc5\xba\xb5\x5a\x17\x67\xb3\xdb\x6a\xa2\xd0\xce\xa3\x1f\x8b\xd3\x49\xd7\x44\x9d\x5a\x8b\x59\x65\xa8\x89\xaa\xda\x15\x3c\x24\x2b\xae\xae\x0f\xc9\x03\xa9\x4c\xe4\x06\x88\xc3\x21\x23\x3c\x98\x29\xac\x2a\x7b\x39\xf3\xe5\xaa\x21\xe9\x19\xdb\x1f\x2f\xbe\xd3\x9c\x11\x0e\xde\x6d\xb5\xcc\xae\x5b\x98\xb9\xb0\x01\x07\x9a\xbe\x3f\x2e\xbc\xbc\xe7\xf0\x93\x2a\xf6\x88\x6a\x7e\x0b\x78\xfa\x38\xf8\x50\x8c\x6f\x0e\x23\xf1\x4d\x07\xd5\x2d\xe2\x37\xc9\x00\xe2\x91\xc6\x4a\xb3\x32\xde\x0e\x19\xc6\x85\xfc\x3a\xa7\x95\xa6\xec\x06\x25\xb2\x35\x94\x4e\x98\x7a\xc9\x75\x93\x48\x22\x09\x6d\xca\x81\xd8\x27\x35\x31\x58\x2b\x20\x6f\x17\xe5\x04\x5d\x2a\xde\xd9\x15\x9e\xe3\xc8\x09\x07\x07\xf6\xb0\x08\xd7\x85\x3b\x63\x0f\xdd\x31\x68\xf3\x51\x25\xf7\x81\xaa\x22\x92\x1d\x94\xc2\x9e\x24\xee\x39\x8c\xc4\x3d\x9d\x54\x24\xe2\x57\x51\x26\xa3\xd1\xc0\x69\xcd\x48\xda\x2d\x56\xab\x5b\xa7\x77\x99\x6d\x5a\xa8\xb7\x18\xb5\x7a\x33\x94\xd7\x46\xa1\x33\xe1\x95\x5b\xc5\x99\x56\x08\xbe\x38\x94\x6c\x7b\xe8\x52\x82\x9f\x1e\xc0\x70\x27\xf7\x8b\xb0\x0d\xea\x69\xb9\x31\x0a\xfa\x4e\xe7\xec\x09\x0f\x3d\x83\xa1\xeb\x5c\x99\x1d\xbc\x2e\x1e\x3a\x6f\xc6\x9d\xe2\xdd\x90\x34\x5f\x97\xd2\x53\xd5\x91\x5c\x95\x12\xd2\x7a\x5a\x07\xd4\x0a\x5e\x29\x93\x6b\x59\x8e\x33\x22\x3f\xc9\xa0\xd0\x53\xfa\x51\x51\x5e\xad\x25\x11\x75\x6d\x3c\xa4\x8e\xdd\xd1\xd4\x50\xd3\xf5\xf4\x05\xf1\x98\x3a\xee\x5c\x89\xfe\xd8\x02\x9a\x84\xcf\x25\xd2\x0a\x14\x18\x18\x10\xf6\x80\xce\xc2\x3b\x22\x51\x0b\x84\x67\x61\x84\xee\x4a\x08\x7b\xfc\x74\x6c\x15\xa1\xe6\x4c\x11\x46\x69\x6e\xcf\x7f\x85\xb1\x36\x09\xa3\x99\xc5\xa5\x4c\xff\x1d\xc6\x44\xdc\xdf\x28\xc2\xd8\x0c\x34\xff\x88\x53\x70\x1e\x90\x05\x84\x5f\x2e\x0b\xe7\x45\xda\x3e\x2e\xfc\x42\x3f\x08\x76\x90\xa6\x94\xc3\x4f\x0b\x61\x4c\x51\xf0\x16\x99\xff\x87\x68\x38\x87\xe4\xb1\x98\x90\xe6\x74\x98\x90\x1b\x89\xac\x75\x33\x67\xc1\x9d\xc0\x20\x94\xb1\x32\x64\x17\xc9\x0c\x2c\xa4\xae\xcf\x5c\x94\x2e\xb0\x8c\x78\x18\x26\x26\x18\xb2\x76\x81\x34\x0d\xd3\xd8\x19\x94\x01\x3d\xb8\xb5\x05\x04\x84\x1f\x63\x47\xd7\x7c\x36\x8f\x6e\xd9\xf1\xc8\xec\x99\xc0\xd2\x1f\xac\x3c\xff\x03\x5d\xfc\xc7\xc2\xd1\x07\x41\xfd\xc4\x49\x0d\xb7\x81\x07\x44\xdd\x57\xd1\xf6\x2f\x96\x23\xfe\x63\x6f\x4a\x9a\x4b\xc8\xbf\x40\xfc\xf8\x1c\x9c\xf5\xa9\xd3\x33\x39\xd9\x1c\xcb\xda\xb2\xb3\xe5\xe9\x14\x32\xc9\x61\x5e\x2e\x4c\x43\x16\x1b\xd4\x41\x9d\x93\x75\x66\x36\x47\x9d\x06\xb3\x6a\x54\xd4\x6c\x14\x41\xbd\x2e\xb4\xd2\xce\x0f\x96\x92\xf2\x25\xc8\x53\x2f\x21\x48\x5f\x5a\x92\xe3\x96\x40\xa6\xa4\xac\x0a\x74\x06\x25\x40\x0b\xc6\x23\x74\x8e\x28\x6b\x07\x37\xcf\xb0\x0d\x01\xb6\xc1\x45\x02\x32\xed\x8e\x64\x0f\xfe\x78\xf2\x13\x5f\xcf\xa2\x27\xed\xdc\xb0\xf0\xf6\x47\x1f\xb2\x3a\xc1\xfa\xf7\xfe\x4d\x17\xb7\x56\x85\x73\xfa\x0d\x5d\xb0\x04\x1c\x16\x6a\x7e\xfb\xa6\xb6\xbe\x57\xf5\xd8\x83\x60\xe8\xc4\x19\x83\x47\x2d\x58\xf0\x10\xc6\xaf\x77\xdb\xbf\xf8\x3c\xf6\x0c\x95\x4e\x15\x51\xd1\x48\xa1\x27\x4d\x9f\x6d\x36\x99\x60\x76\xb6\x2d\x28\x97\xdb\xd2\x60\x49\xb1\x09\x1d\x76\x14\xd4\x71\x6a\x75\x1e\x99\x06\xe0\x27\xd3\x00\x1c\xb5\x37\xe6\xad\x95\x63\xe5\x5b\x75\x3d\x8e\xf1\x6e\x38\xed\xc7\x5d\x55\x82\xc4\xf4\x9c\x2a\x5c\xc4\xcc\x24\x06\x83\xe2\x3c\x3e\xe6\xa3\x87\x3f\x28\xea\x77\x6c\xed\xe3\xc7\x16\x5d\x7c\x72\xde\x56\x37\x0b\xf5\xc3\x81\xf9\x0d\xf9\xc1\x11\x53\x1d\x85\xc0\xd9\xa1\x40\x68\x6d\xed\x5b\x3b\xa3\xae\xb8\xa9\x69\xec\xe2\x1e\xa6\x86\x86\x5b\x87\xbc\xbb\xf3\x38\x98\x7c\x7c\xcc\x28\xef\x38\xf0\xf2\xb5\x2b\x45\x59\xcf\xcc\x5e\xf1\x83\xf0\xc7\xc5\x0f\x4f\xf4\x5c\xfb\xf1\xc0\xd9\x2d\x2b\x85\x5f\xa7\x7e\x86\x7b\x64\x21\x7e\xce\x63\x37\x50\xb9\xb8\x8f\x49\xba\x5f\x66\x72\x50\xae\x1c\xb5\x46\xc3\xe4\x50\x56\x93\x9f\xcf\xcf\xb3\x32\x2c\xcb\x34\x47\xd5\xe9\x7a\x36\x9d\x4d\x0f\xe8\x03\x69\xa3\xa2\x01\xa3\x5e\xd9\x1c\xd5\x5f\xdf\x08\x4d\xff\xa7\x15\x30\x7f\x5e\xf1\xa3\x25\xfd\x37\x9c\x04\x65\xbf\x57\x1f\x86\x23\x6f\x5a\xe8\x33\xef\x5e\x96\xad\x1e\x71\xbc\x18\x33\x38\x28\xb4\x7e\x2b\xf4\xe4\xc0\x27\x9d\x7b\xb4\x2b\xf2\x31\x4c\x19\x7a\x6b\x43\x55\x17\x00\x30\x73\xaf\xfe\x13\xf4\xa9\x41\xf8\x2d\x40\xe7\xf0\x18\xa6\x1a\xe1\x57\x1f\x09\xca\xe4\x36\x3f\xa5\x07\x3a\xb7\xc7\x63\xd2\xe9\xb3\xfd\x72\x84\x9f\xdb\x2b\x93\xa9\xbd\x5e\x67\x5d\xd4\xab\x0b\x98\xcc\x66\x53\x5d\xd4\xac\x55\x33\xb5\x51\x75\x3b\x2b\x3d\x59\xe6\x73\x23\x76\xbc\x24\x8e\x3e\x5e\xec\x9f\x1c\xfe\xf3\xb2\x9e\xd5\xec\x80\x91\x22\xcf\xf2\x8b\x84\xb6\x6f\xfe\x71\x81\x9d\xba\xfa\xfa\x8a\x9e\x05\x63\xc1\xa2\x9a\xf2\x72\xc4\xaf\x6f\x7e\xb9\xb8\x74\x6d\x73\x65\xc5\xf5\x85\x3c\xc6\x5a\x72\x0f\x35\x49\x18\xcf\x9c\x47\xbc\xf3\xe3\x29\xc1\x7e\xaf\xc2\x92\x46\x69\x75\x3a\x8e\xb2\x5b\xbc\x5c\x66\x86\x9d\xe3\x79\x0e\x79\x4b\x5a\x5e\x4b\x19\x8d\xea\xe6\xa8\x91\x41\x3b\x34\x2d\x71\x65\x4b\xf2\xde\x24\xce\xdd\xec\x7a\x99\x44\xa0\x7d\xfe\x3f\x2d\xd4\xc2\x66\x19\xfd\x51\x4f\xb9\xf0\x7f\x0d\x37\xf2\x6b\xd1\x12\xd6\xb1\x7f\xe1\x1f\x35\xe0\xf6\xa2\xdc\x07\xdb\x71\xc9\x7c\xcf\x68\x6b\xf8\x7e\x29\x90\x00\xa8\x6e\xc8\x76\x3b\x80\xf8\x93\x8e\xf4\x70\x8e\xd7\xcd\xe9\x5d\x3e\xa5\x4a\x45\xfb\xf4\x6e\x36\xc3\xaf\xd4\xa4\xf9\x7c\xae\x9a\xa8\xcf\xac\x91\xd7\x45\x35\x3a\x33\x0d\x21\x5d\x27\x26\x4d\x27\xb2\x53\xe2\xa9\x73\xd7\xdf\x8e\x77\xf0\xfd\xd9\x3c\x4b\x2d\x10\xd3\x29\xe8\x0a\xe1\xb7\x1b\xc7\x59\xf2\xda\x59\x33\x2e\xd7\x6c\x29\x05\xe5\x9b\x6f\x18\x67\x39\x7b\xb8\xd7\xdb\x87\xa4\x55\x28\xd0\x19\x72\x04\xed\x9d\x5f\x90\x2e\xcc\xc2\xf7\xd2\x2e\xb7\x81\x32\x67\x64\x50\x6e\x98\x2d\x97\xcb\x7c\xb6\x51\x51\x9f\xd1\xe5\xe2\xf5\x62\xa0\x86\x84\x69\xda\xfb\xad\x52\xa0\xa6\x7d\x7c\x4c\x0c\x85\xa4\x04\x6a\x52\x94\x60\xfc\xae\x98\x99\x25\xcc\x9f\x31\x75\xce\xcc\xb5\x63\x48\xd8\x26\xbb\x5b\xdf\x09\x5f\xc2\xed\x87\x65\x83\xeb\x87\x8d\x73\xa1\x0d\x32\xbc\xf0\xda\x0f\x67\xce\xea\x98\xd5\xc2\x76\x61\x8f\xf0\xfd\x43\x3d\xf5\xbf\xf1\xdd\x37\x02\x3b\xbd\xb9\xb5\x2a\xbd\xa0\x6e\xe4\x94\xf5\x68\x83\x14\x5f\x7a\xff\xa5\x83\x7d\x06\x93\xb3\xf0\x55\x84\x47\x4f\x74\x16\xe2\xbc\xcf\xf6\x78\x04\x5c\x2e\x0e\x61\x50\x13\xd5\x6b\x7d\xb6\xda\xa8\x8f\xe3\x14\xb5\xe2\xec\x13\x5c\x25\x93\xc4\xe5\x86\x9a\xda\xeb\x43\x3a\x30\xa1\xb3\x7d\x7c\x1c\x0f\xf8\xdc\xcd\xe2\x3b\xf3\x64\x43\xa3\xe2\x0e\x29\x0c\x0a\x17\xcf\x7d\xa6\xbb\x21\xd6\x13\xbb\x37\x2f\x7d\xd0\x28\xb4\x3d\xae\x5c\xf9\xec\xe5\xc3\x3d\x07\x53\xf1\x1e\xf1\xe9\x88\x17\x6e\xea\x96\x48\xa6\xcd\x64\x32\xdb\x29\x2d\x2f\x33\x6b\x65\x30\xcd\xc3\xf3\x66\x0b\x89\x9a\xd9\xcc\x0e\x0b\x34\x1b\x54\x70\x54\x22\xc9\x3a\x59\xc0\x91\x32\xee\x2c\x94\xcc\xc2\x6d\x47\xfa\x44\xeb\x5f\x8c\x10\x9b\x33\x3c\x95\xe0\xe7\x64\x8e\xd8\xda\x76\x01\x8d\xc3\x32\x30\x35\x95\xda\xfe\x7e\x6b\xe3\xb1\x0d\xc4\x08\x04\x73\x01\xa2\xbb\x8d\xe4\xb7\x20\x98\x79\xda\x02\x1c\x0e\xa7\x46\xeb\xb4\x68\xa1\xc7\xad\xd1\x38\x5d\xc0\x8e\xc3\x1a\x4e\xe8\xd2\x3a\xcd\x46\x44\x78\xa3\xe5\x3f\xc0\x1c\x77\x98\x44\xe0\x6e\xa4\x36\x09\x74\x38\xc4\x40\xc7\x5c\x59\x43\x2a\x8d\xff\x21\x13\xe6\x25\x23\x1e\xed\xc9\x5b\x55\x28\xd5\x16\x90\x3b\x83\x1f\xd8\x3f\xd8\x8d\xc8\x16\xc8\x4d\xdc\x75\xde\x8b\xef\x5a\xa5\xbc\xc5\x75\xc8\x77\xfd\x92\xf4\x31\xad\x8c\x78\xb5\x3a\x96\x92\x59\x81\x15\x1d\x95\xac\xd3\xa1\xd5\x9a\x68\x93\x72\x54\xd4\x64\x64\x01\x0d\xa4\x72\xf4\xd4\xfb\xba\xf6\x01\x08\x31\xf3\xf6\x26\xb2\x4f\xd7\xc7\xf3\x70\xd7\xca\x52\xc9\xff\xd7\xcf\x75\x38\x29\x37\xe6\x4f\x15\xf0\x13\xfb\xb0\x80\x93\x1e\xfb\xf2\x51\xcc\x00\xaa\x0b\x35\x36\x52\x5a\x5c\x92\x49\xe5\x96\xa7\x71\x1c\xaf\xb5\x99\xcd\x3a\x9d\x5e\xcf\x97\x53\x25\x6c\x55\x65\x71\x71\x7a\x59\x59\x41\x6d\xb4\xcc\x92\x9e\x66\xd3\xbb\x68\x95\x4b\x55\x1b\x75\xe9\x4c\x5a\x5e\x6f\x96\x0a\x44\x88\x3f\x55\x7e\x13\xa0\x0d\xe5\xed\x4f\x84\x2c\xff\xff\x92\xb1\xab\x05\x37\xe1\x53\x25\x60\x77\x8a\x03\xf2\xfe\x4b\xfe\x6e\x4e\xbb\x8d\xf2\xd1\xa7\x3a\x97\x06\xc2\x39\xff\x39\x95\xf7\x9d\x24\x6b\x5f\x3a\xd2\x73\xf0\xca\x11\x84\x8f\xdd\x10\xdf\xec\xec\x06\x03\x87\x67\xf0\xa2\xdf\x1d\x6d\x97\xe0\x45\x3c\x3f\x14\x8e\x23\xfa\x61\x29\xf2\x91\xb6\x91\xbe\xe8\xe5\x11\x37\xd0\xdb\xf5\x38\x12\xed\x93\xf3\x16\xd7\xc8\xa8\xc5\x79\x13\x05\x77\x43\x14\xfa\x66\x31\xe8\x14\x0d\x51\x16\xbe\x79\x28\x5a\xf8\x3a\xfb\x85\xa7\x33\x27\x65\x15\x74\xf5\x74\xea\xad\xbd\x49\x44\xfa\x8f\x7e\x6f\xed\x52\xca\xbf\x55\xf7\xaf\x15\x63\xd2\xc3\x48\x4c\xda\x43\x75\x8c\x78\xe4\x4e\x85\xc3\x01\x9d\xb8\xd7\x6b\x9a\x43\x51\x13\x45\x22\x68\xc6\x93\xd9\x29\xae\x36\x11\xfc\xbd\x3e\x28\x9d\x0c\xfb\x86\x6f\x8c\x4a\xe3\x41\x58\x77\x21\x60\x72\xba\x7a\x66\x7a\x0e\xdd\x4c\x75\x7d\x12\x38\x22\x0c\x53\xca\xdf\x57\x3f\x06\x5f\xb8\x4e\x67\x5d\xdb\xf1\xd7\xa3\xe2\x1e\x12\xee\xc0\x77\x9d\x68\x0f\x75\x20\xbf\x77\x42\x30\x1f\x27\xf1\x0a\xf1\xee\x78\x23\x45\xc9\xd2\x48\x3c\x43\x9c\x2d\x7b\x1b\xb2\xfa\x77\x90\xf9\xa2\xc3\x31\x2f\x84\x75\xc2\x42\xca\xdd\x76\x9a\xb2\x52\xbe\x08\x76\x01\xb5\xca\x2f\x00\xa0\x40\x04\xd4\x82\x91\x80\x01\x7a\x2a\x78\xa6\xb1\x11\x77\xc1\x0a\x91\xf6\x53\xa2\x05\x89\x73\xdb\x70\x57\xea\x10\x39\xba\x79\xd5\x58\x95\x37\x33\x14\x92\xcb\xc6\x28\x75\x43\x6e\xd1\x8d\xd3\x77\x2e\xe6\x84\x85\xbd\xb5\x5e\x77\x61\x59\xb0\x78\xd8\x08\x45\x53\x93\x22\x12\xf2\x20\x6b\x01\x02\x86\xad\xa6\x97\x71\x2f\x21\x3f\xc4\x8a\xec\x8c\xec\x88\xc5\x2c\x97\x6b\xb5\x10\x3c\x0f\x7f\x84\x6d\x10\xc2\x88\x5c\xdd\x07\x3a\x7d\x87\x40\x25\xda\x23\x67\xf2\x1a\xa7\x96\x88\xe1\xf3\x0e\x65\xf1\x79\x21\x59\xe1\x94\xd7\x7c\xca\x6b\xc0\x14\x7a\xd3\x0b\x0b\xd3\xbd\x85\xdf\xc4\x5f\x3c\x12\x7f\xc1\x4d\xf1\x16\x14\x88\xaf\xc5\xbf\x9f\xf7\x16\x92\x7f\xc3\xfb\x59\xc3\x56\x83\x15\x5c\x2b\x82\x49\xb9\x87\xe2\xc8\xd2\x67\xb0\x19\x66\x45\x3f\xfe\x70\x00\x37\x40\x5a\xb1\x6b\xc5\xae\xfb\x5e\x99\xb5\x6b\x15\xfa\x9b\x6b\x1d\x9a\xf8\x1f\xf6\x61\x80\x0e\x7d\xff\xbc\x84\x53\x7a\xc4\x28\xbf\x1e\x1d\xad\x39\x05\x9d\xf6\xb8\xb4\x83\xbf\x53\x1c\xda\xbc\x1b\xc0\x4e\x82\x8b\x68\x48\x23\x1a\x6e\x41\xeb\xe1\x39\x90\x4e\x2a\x3f\x62\x33\xda\xed\x94\x9a\xe7\xb5\x34\x78\x9e\xfe\x91\x6e\xa3\x21\x8d\xd7\xa5\x29\xb2\xec\x3b\x78\xd5\x84\x26\x31\x86\xa0\xf1\xcf\xd6\xa7\xfb\x4c\xee\xbd\xee\x06\x18\x10\x72\x93\x85\xf5\xc0\x77\x3d\x24\x40\x78\x4f\x58\xd8\xf6\x47\xdb\x6e\x84\xb7\x6a\x1f\xcb\x49\x0d\xd3\x8a\x8b\xc4\x49\xba\x62\xee\xe3\x11\x76\x54\xbd\x79\xe9\xfd\x7c\x9d\xcd\xd2\xa7\x66\xe2\x9d\x77\xf8\xb3\xf0\x39\xc5\xd6\x83\x11\xdc\x4e\x04\xbf\x72\x0f\x04\x22\x90\x98\xde\x88\xce\x23\x0e\xcd\x3a\xc4\x51\x3b\x77\xee\xc4\xfb\x6f\x1d\x5b\x0b\xfe\xcd\x2d\x41\xb6\x5c\x7a\x44\xad\x77\x53\x2a\x37\xfa\xb1\x58\x17\xb1\x22\x8f\x42\xb8\x3d\x5b\xb9\x58\x81\x8a\x84\x13\xbb\x71\x56\x9e\x4c\x93\xc1\x3d\x0b\xc5\x70\x0c\x4e\x62\x90\x6e\x4f\x0a\x41\x10\x61\x95\x93\x95\x1f\xed\x37\xa1\xca\x59\xea\xf7\x16\x15\xe4\x64\xe7\x0e\xef\x53\x56\x9b\xe1\x29\xe1\xca\x8b\x83\x45\xfa\x3e\xda\xbe\x85\xd5\x23\x16\x76\xe8\x50\x1c\x0c\x1a\xf0\x2f\x35\x0d\x9d\xbb\x97\x07\x31\x2c\x8b\xd9\x6a\xea\x59\x6e\x21\xc2\x55\x4b\x70\x25\x10\x10\x74\x8d\xc9\xee\x89\x7c\x88\x69\x8c\x9a\x97\xae\x95\xb1\xd5\x3a\x5f\xcf\xea\x96\xd9\x2d\x56\x7c\x0f\x37\x1d\xed\xb1\x73\x6d\x17\x29\x96\xd2\x1c\xc0\x1b\x8b\x06\x0c\xde\x56\x78\x43\x05\xc2\x21\x7e\xdd\xda\xb5\x1f\xad\xfd\x48\x58\xb8\x7f\xff\x7e\x92\x9f\x26\x3c\x86\x3e\x9f\xd6\xf6\x13\xc5\x53\x46\xca\x70\x90\xe7\x23\x10\x40\xbd\x92\x0a\x86\xce\x34\x96\x07\x8b\x8b\x70\x72\x60\x18\x57\xc2\xa4\xf0\x2e\xcd\x75\xfa\x31\xd3\xd8\x95\x06\x41\x88\xb3\xad\x6e\xf5\xb6\x89\x13\x46\xa8\x92\x72\x03\xa8\x6d\x48\x6e\x32\x11\x0e\x3c\xc2\x81\x81\x71\x1c\x70\x8b\x38\xdc\x1a\x98\x47\x07\xcb\x36\xe7\x99\xc7\xcc\x63\x97\x19\xd9\xea\x35\x4f\xb6\x8c\x6b\x44\xfa\x42\xfa\x8e\x8e\x63\x3e\x24\xb9\x73\xc3\x93\xcf\xa0\xac\x07\x55\x4a\x25\x7a\x90\x4c\x7c\x52\x09\x7a\x94\x78\x55\x20\x3d\xcd\x77\xdd\x53\x85\xbe\xe8\x85\x69\xc2\x32\x9d\xf4\x78\xf4\xc7\x84\x06\x8a\x11\xde\x62\x3b\xd1\x9f\xf1\x39\x44\x9a\xf3\xa8\x30\xe5\x3f\x10\x0c\xe6\x80\x9c\x52\x3f\x7a\xec\x01\x7b\x10\x61\x6f\x94\x4b\x3b\xa8\xb1\x84\xfc\xd1\x6e\x13\x05\x90\xe0\x64\x85\x13\xf3\x82\xd2\x39\xd6\x14\xef\xf6\x23\x36\x00\xe4\xa5\x72\x2d\xfc\x09\x50\xb0\x20\xda\xb0\x60\x5e\x63\xa7\x82\xfa\xba\x7a\xf7\x9c\x70\x20\xbb\xa2\x73\x56\x46\x85\xf0\x81\x1b\xfd\x5e\xd0\x69\xc4\xfc\x05\x0d\xd1\x05\x73\x2a\x32\x02\x9d\x2b\x72\xb2\x3a\x72\x75\xd1\x05\xf3\x87\x47\x17\xd8\xea\x07\xd7\x07\x3b\x67\x77\x2c\x0f\x04\xca\x3b\x66\x77\x0e\xa2\x5f\x6d\xf8\xfd\x05\xd1\xec\x8e\x1d\xb3\xd1\x7b\xe4\x2e\x03\xe3\xb1\x5f\xc2\xc3\xd8\x1e\xf0\xd7\xff\x1b\xcc\x80\xb9\x29\x5c\x37\x05\x00\xcb\xa3\x80\xb6\xe5\x2a\x6e\x13\xa5\xa7\x6c\x68\xaf\x33\x8c\x5c\x8b\x18\x2c\x13\x75\x57\xa3\xd4\xb5\x90\xd8\x00\x01\xde\x6f\x0c\xf1\xa2\x55\x00\x56\x29\x8c\x13\x86\xf9\x4d\xe6\xd1\x55\x63\x9c\x8a\xb4\xa2\x22\xa5\x82\xdb\x54\x52\x3f\x56\x31\x16\xf4\x5f\xa9\x2a\x08\x97\x90\xbb\x2c\xe1\x35\x24\x7f\xd5\xe8\x4c\x30\x53\xee\x88\x56\xcf\x9b\xd5\x34\x4d\x91\xf3\x40\x6c\x62\xd8\x88\x4f\x03\xcc\x67\xe8\x0f\xe3\x3d\x1e\x92\x66\x80\x96\xe1\x03\x81\xe3\xe7\x8f\x35\xdc\x6e\x18\xcd\xf3\xbe\x9c\xa2\xa0\x52\x31\x46\xe6\x59\x2f\x2c\x1c\xa1\x6b\x71\xd6\xa7\x67\x19\xd2\xdc\x45\xa5\xc5\xc5\x4f\x8b\xfd\xb4\x85\xcd\xc2\x76\x64\x4b\x7d\x86\xf6\x85\x6a\x1f\xa4\x13\xfa\xc3\x0a\x7d\xe1\x50\xd8\x5f\x29\x1c\x36\x5d\xc8\xf1\x0b\x6f\x4e\x7c\x17\x7d\xf6\x2c\x82\x29\x7c\xb3\x3d\x04\xc9\x1e\xd2\xdc\xbf\xee\xdc\xda\x73\x89\x3d\x04\x84\x43\xe8\xf3\x9d\x90\x6e\xe2\xd1\xb3\xb1\xac\xa3\x67\x63\x41\x8f\xef\x9d\x4e\xae\xb7\x36\x63\x91\xac\x5b\xb3\x15\xed\x12\xb4\xe7\xd0\x81\x45\x9d\x25\x9f\xd7\x52\x26\x49\xae\xb5\xe8\x5b\x09\xa1\xe6\xa5\x6f\xfa\xa4\xbf\x67\xa1\x1d\x87\x9f\x00\x0e\x90\xad\xb7\xdc\x20\x6e\x38\xf4\xc7\xf8\x46\xb4\xfe\x3b\xe8\x79\xf6\xb6\xdf\xf1\xfa\xfb\x23\x00\x4f\x90\x17\xa1\x65\xab\x40\x20\x53\x0b\x54\xc2\x79\xdd\xfa\x85\x20\x47\xbb\x41\xd8\x1b\xaa\xb5\xfc\x3d\xd4\x5f\xca\x05\xc9\x44\x7c\xad\xfe\xaf\x7a\xe6\x1c\xd2\x33\xa6\xa5\xf7\xc7\xf5\xcc\xac\xc9\x48\xcf\xd0\xc2\x37\x6c\x27\xea\x6c\x42\xfe\x8c\x41\x35\x50\xdb\xf9\xc4\xc6\x41\x4f\xf8\x0f\xfb\x62\x23\x96\xff\x60\x45\xc3\x82\x45\xd1\xfa\x45\x73\x2a\x32\xb3\x3a\x57\x64\x07\x90\xfc\x77\x2a\x12\x65\x7d\xf8\xfc\x79\x0d\xd9\x1d\x2b\xb2\x02\xe5\xe5\xd8\x8e\x88\xcb\x08\xd2\x0b\x9f\x88\x39\x2c\xe4\x0c\x3d\x80\xf8\xa3\x3f\x50\xc3\x34\x33\x34\x03\x24\x61\xc4\x0d\x28\x31\x8b\x40\x0f\xc2\x23\xb6\x3a\xce\xa3\xb6\xef\xd0\x77\xa6\x70\xcb\xd0\x77\x6c\x11\x25\x6c\xa6\xa6\x50\x0b\xd1\x99\xb0\x88\x96\x70\x6e\x14\xdd\x0f\x24\x0b\x60\x4a\xa5\x70\xc8\x7c\x21\x87\x5b\x46\xa4\x81\xe8\x63\xb4\xfe\xae\xff\x7c\xf6\xc8\x98\xe6\xa8\x69\xd9\xfd\xb2\x3a\x9d\xbb\x4f\xed\xc4\x59\x93\x1d\x45\x88\x2f\x63\xd9\x5a\xea\xb5\xff\xf5\x4c\x81\xff\xfd\x4c\x69\xfd\xff\x3e\x53\x68\xb4\x87\x67\x81\x17\x10\xbf\xb0\xdd\xa0\x3b\x00\x83\x5a\xa0\x95\x9b\x89\x9a\x27\xca\x22\xc9\x9c\xcc\xd4\x53\xba\xb4\x22\x03\x33\x27\xab\xa3\xf0\xd6\xfc\x11\x0d\x0b\xf0\x7f\x5c\x9d\xc8\x9a\x8e\x59\xe2\xef\xf3\xc5\x3c\x67\x0d\x3a\x9f\xcf\xb5\xfd\x9b\x3c\xdf\x1a\x51\x69\x29\x33\x88\x98\xb7\x98\x69\xb3\x1c\x92\x55\xb0\x31\xc2\xff\x89\x31\xf0\xe6\x0d\x76\xc0\x48\xe9\x28\x49\x31\x45\x28\x56\x18\x8e\xf8\x70\x40\x5a\xc3\x4f\x05\xa9\x4e\xb8\x17\x59\xc8\xe9\x2c\xa7\x7c\x20\xe2\xdb\xe2\xa3\x7d\x05\xc8\xc2\x0b\x68\xf1\x8a\xa4\x20\xe9\x4c\xdc\xa4\x63\xff\x07\x93\x2e\xf3\x4f\xde\x17\x86\xff\xb9\xa9\x07\xa6\xc7\x0d\xbd\xbc\xf8\x8b\x38\xe8\xe9\xd7\xa1\xf0\xf3\xf5\x28\x41\xa1\x05\xe1\xf3\x30\xc2\x47\xb4\xad\x90\xfe\x33\x52\xc8\x1e\xb6\x83\x88\x7d\x8b\x9d\xb6\xab\x79\x91\x70\x48\x03\x22\xda\xb1\xc8\xab\xfc\x33\xc8\x85\x16\x13\xe8\x63\xee\x75\x03\x15\xb7\xb5\xb4\x74\xbb\x91\x90\xc9\x75\x79\x32\x25\x34\x27\x62\xe1\x68\xfa\x3d\xb4\xaf\x16\x41\x68\xa5\xdc\x20\xe2\xde\xe2\xa6\xdd\x92\x11\x30\x15\xe9\x77\xbc\x3d\x88\x41\x17\xf6\x23\x28\xfc\x7f\x0e\xc7\x49\xcb\x64\x0c\xc9\x44\xeb\x8d\x1c\x15\x2e\x4d\x6b\x69\x99\xb6\xff\x26\x7c\x05\x6d\x56\x61\x7b\xdb\xfe\xb6\x6e\x88\xaf\xb2\x3d\x44\x5c\xd0\x6e\x48\x79\xec\x77\x71\xd2\x0a\x57\xe3\x5f\xa3\x85\xed\x48\x9f\xe7\x90\xef\x58\x29\xcd\x7e\x6c\xd8\x13\xae\xff\x27\xfb\x5d\xd8\x1e\x07\xe6\x62\x02\xaa\xab\xd7\x71\x8b\xd0\xe7\xa4\x30\x9f\xea\xd3\x76\x49\x92\x33\xc4\x17\x67\x42\xc0\x52\x16\x12\x65\xfa\x7f\x91\x2c\xe1\x64\x1c\x83\x84\x04\x6d\x8a\xbf\xb8\xf5\x4f\xc4\x05\x9f\x2b\x6f\xb5\xd9\xa9\xcc\xb6\x25\x48\x3e\x54\xfb\x21\x8f\x14\x3b\x15\xc4\x7a\x8a\xf5\xf1\x3e\xe1\x33\x44\x67\xe1\xf0\xfc\x89\xe4\x73\x88\x16\xf8\x73\x3c\xc5\xbd\x00\x70\x6f\x62\x28\x31\xea\x8b\x38\x3f\x84\xed\x33\x27\x4e\x9c\x89\x75\xe7\x4c\x76\x07\x30\x70\x3d\x88\xff\x01\x91\xc1\x50\x85\xf4\x10\x0e\x5b\x24\xa1\x9d\x89\xd6\x2f\x28\xc0\xc6\xf8\xaf\x29\x7e\xcb\xff\xdf\xf7\xa0\xb0\x89\xe8\xee\x9f\x12\x3e\x98\xd6\xac\xd5\x3a\x9d\x98\x98\x7f\xf7\xfd\xe4\x63\x7c\x87\xda\x4e\xbc\xe8\xf4\xf4\xf1\x89\x6a\x22\xaf\xb1\xc4\x40\xec\x89\x54\xb2\x5a\xff\xe4\xb5\xb0\x29\x4e\xd6\x55\x71\x12\x26\x5e\x34\x49\x20\xdc\x22\xfd\xdd\x2b\xc5\x36\x6d\xfb\x80\x9e\x4a\x4d\x85\x1a\x0c\x53\x04\x71\x53\x5e\x24\x1f\x29\xbf\x5f\xbe\x45\xfe\x9e\x9c\x93\x8b\x24\x4e\x15\xbf\x82\xf8\x33\xe9\x57\xb0\x5b\xe2\x2f\x28\xc0\xcf\x48\x43\x32\x7b\x88\xf0\x46\xb6\x07\xd2\xa2\xcc\xa2\x83\xe7\xcb\xbc\xc9\x79\xc2\xf6\x2f\xbe\x20\xe7\x94\xc0\xcc\x81\xb7\xb2\xfd\xc9\x67\x80\x28\xd7\x24\xfc\x17\xa0\x3b\xe5\xc4\x4e\xb2\xfd\x3f\x40\x9f\x31\xb1\xaf\x80\xa9\x5c\x1e\xfa\x8c\xee\x20\x28\x82\x40\x86\xc7\x3e\x06\x1b\x1b\xa5\x3a\xca\x1c\xcc\xe6\x43\x5c\x1e\xe6\x33\xe8\x22\x8c\x84\xbb\xf9\x73\x89\x35\x83\x78\xae\x78\x08\xbd\x0f\xce\x6d\x12\x72\x84\x91\xf2\x59\xbf\xae\x10\x79\xb5\x13\xf1\xaa\xd7\xff\xc4\xab\xdf\xdb\xf1\xf8\xff\xe7\x7b\x34\xce\xca\xa2\xbb\x31\x0a\x04\x17\x4f\xa5\xed\x01\xc8\x8e\xe8\xbe\x1f\x57\x8b\xb1\x47\x41\x77\x2a\x4a\x31\xa0\x42\xbc\xb4\x7f\x3d\xaf\xb8\x08\x47\x4b\x70\xb8\xe8\x52\x18\xa4\x75\x14\xaa\xc3\xc0\x17\xa6\x7f\x02\x0e\xe1\xdb\x98\x0e\xd8\x85\x8b\x84\x6e\x2b\x38\x3b\x08\xa0\xf3\x1d\xeb\x03\x28\x27\x74\x4b\x05\x62\x45\xc2\x63\x1d\x4f\x80\x40\x0c\x01\x6d\x0a\x61\x62\xdb\xce\x36\xd9\x9f\xe9\x90\x5f\x13\x3b\xfe\x48\xc2\xa7\xa4\x42\x48\x40\xa7\x33\xe7\x91\xf6\x4d\xdf\x43\xc1\xae\x0a\x10\x41\xd0\x52\xa0\x1c\x3f\x84\xbc\x56\x4a\x90\x57\x21\xc0\x91\xbd\x89\xdb\x34\xf0\x38\xef\xc0\x58\x49\xd3\x1f\x6c\x09\x3e\xd8\xab\xae\xd4\x31\x1c\xdc\x15\x8c\xcd\x59\x9f\x35\xeb\x25\xe6\xfc\x95\x92\x69\xcb\x84\xb2\x2b\xf4\x4f\xc7\xcf\x46\x49\x7c\xfe\x56\xb0\xa2\x6d\x33\x25\x47\xfb\x52\x86\xf7\x25\xeb\xd7\x02\x7f\x15\xb2\xe9\x7c\x60\xca\x8b\x2a\x66\x05\x13\xdc\xeb\x00\xef\x7c\xb7\xc5\x6c\xde\xb2\x0c\x7d\xfe\x02\x3a\xe4\x36\x23\x78\xec\x54\xda\x41\x15\xad\x45\x67\x80\xc6\x7c\x14\x81\xc0\x11\xa0\xaa\x90\x3b\x92\xac\x8a\x00\xf8\x4e\xc4\xc7\x6b\x68\x1e\xd7\xa4\xd0\x64\x1a\x1f\x08\x03\x1d\x28\x03\x39\x43\xc6\x7a\xab\x80\xb9\x8f\xbb\x61\xc9\x7a\x60\x40\xd6\xec\x03\xc1\x70\x79\xce\x12\xe1\xe2\xf6\xe1\xab\x16\x33\xe7\x63\xef\x76\xdf\x32\xfd\xc2\x0f\xa3\x1e\x59\x36\x45\x60\xe8\xfd\xf6\x6e\xf3\xa6\x0b\x1b\xc1\xe6\x4f\x9f\x09\x61\xb9\xbe\x44\x51\xcc\x16\x04\x83\x91\xca\x44\x9c\x3c\x4a\xc8\x00\x40\xf9\x3e\x99\x4a\xa9\x3a\x9a\x42\x14\xf1\xfe\x13\x31\x26\xec\x93\x0a\xf8\x71\xa9\xb6\x68\x37\x7e\x16\x04\x3b\x7e\xfa\xca\x32\x78\x69\xf0\xda\xdc\x20\x7d\x79\xa8\x76\xea\x62\x78\xf1\xca\xf3\x87\x1b\xa6\x09\xd5\x57\xae\x80\x23\xf5\xc5\x0d\xc3\xf0\x5a\xe7\x11\xfd\xcb\xd1\x5a\x0e\x2a\xf3\x80\xcc\x64\xd2\x38\x1c\xf6\x63\x64\x09\x07\x42\x97\xa7\x34\x78\xa1\x44\x4b\x14\xd2\xc7\x05\x77\x1b\xc4\xfd\x1b\xd1\x5a\x95\x74\x15\x28\xc4\x6d\xd2\xc1\xb9\x09\x33\xaa\xd2\x65\x2e\xe1\xaa\xa6\xa2\xa2\x38\xd4\x20\xfc\xd0\xbf\xeb\xb8\x7b\xa7\x0d\xe5\xec\xa5\x3d\x96\x05\x99\xf3\x59\x43\x37\x9f\x8c\x71\xe0\x98\x2e\xbd\x72\xc2\x37\xfb\x1f\xdf\xd2\x94\x6e\x7b\x61\x7e\xf1\x15\xc4\xff\xa5\x08\xd7\x56\xb4\x3e\x4f\xb9\x0f\x23\x24\x2b\xf6\xe1\x1e\x0b\x22\x92\x0c\x26\xb8\x88\x24\x29\xfc\xc7\x97\xba\x7e\x38\x55\xb8\xfc\x5a\x6c\x64\x90\xe9\x13\xdc\x84\x10\xba\x82\x65\xbf\x17\x7a\xc6\xef\xe8\x19\x10\x51\xcc\xb7\x9f\xa6\xe5\x7a\x70\x0c\xe0\x74\x1e\x51\x82\xe4\xe4\x39\x52\xae\xba\xf8\xa4\x4c\xdc\xc2\x36\x4e\x35\x44\x31\x30\x58\xb8\xf2\x00\xd0\x80\xd6\x3b\x16\x0b\x74\x90\xa6\x7f\xfc\xda\xba\x44\xb8\xb2\x54\x43\x5f\xe9\xde\x30\x0c\x51\x6d\xe8\xac\xd8\x08\x7a\x57\x1d\x82\xb7\x0f\x5a\xb0\x0f\x59\x4b\x73\x94\x88\x04\xc4\x14\xaa\x12\xab\x29\x40\x39\xd0\x5e\x11\xae\x30\xe7\xaf\x05\xf0\x1e\x9a\x8a\x68\x5b\xca\xfc\x41\xa9\x29\x7f\x44\x89\x7b\x1b\xa9\xd4\x08\x45\x5e\x7d\x04\x74\xa4\x78\xf2\x35\xac\x68\x93\xf5\xba\x01\x22\xda\x58\x86\x32\x8d\xb0\x34\x34\x76\x60\x4f\xc3\x4c\xe1\xca\x0c\xcb\x1d\xe3\x85\x63\x1d\x18\xbb\x70\xcd\x9f\x79\xeb\xf0\xd8\xb3\x74\xfd\xa4\x0d\x39\xd3\x01\x47\xf6\x29\x82\x87\xcd\x41\xf0\xe8\x29\xe7\x1e\xa0\xc0\x68\x27\x37\x4e\x1c\x6d\x82\xb3\xd4\xb6\xd7\x67\x14\xb1\x66\xd6\x62\xfc\x10\xba\xbf\xbe\x26\x5c\xb9\x4c\xbb\x7f\xfa\xca\x8a\x10\x0c\x37\x0c\x6b\xb5\x33\xe7\x31\xc2\xe8\xd9\xab\xdb\x2e\xb1\xfd\x99\x7f\x23\xfb\x24\xb0\xc7\x66\xec\xaa\x22\x8f\xb5\x21\xe0\x39\xf4\x68\x8a\x52\x49\x7b\xb5\x53\x3c\xfb\x86\xc4\xa5\x13\xc5\x08\xe4\x9a\x16\xdf\x5f\xf3\x61\x51\x07\xf0\x34\x45\x8f\xfd\xf6\x67\xfd\x5a\xa0\x59\xad\xf8\x62\xca\xa6\xdb\x7a\x2c\x1e\x32\x29\x38\xe1\x9e\x9d\x1b\xdd\x7d\x84\xa7\x4d\xfb\x0e\x0e\xaa\xa1\xbf\x8c\x65\x76\xef\xb8\x7d\xc8\x2e\xd0\x6b\xe0\x92\xf2\x5f\x3a\x6e\x7f\xf6\xb6\x47\x84\x8d\xc2\x5e\xd1\x57\x3a\x44\xf7\x92\x68\xaf\xdd\xdf\x8c\x75\xf4\x21\x8c\xe2\x3b\x8d\x49\xe2\x2f\x16\x2e\xa3\xcd\xd5\x82\x3e\xbb\x44\x58\xc8\xe4\x11\xbd\x62\xd9\xa3\xd5\xbc\x4c\x40\xd5\x62\x91\x06\x5d\x28\x02\x2a\x48\x30\x9f\x10\x26\x4c\xd7\x23\x12\xfc\x55\xf8\xf9\x2c\xda\x29\xc2\x88\xa0\x48\x84\x6b\x17\x98\x02\xbc\x53\xae\x88\xfe\x0b\x92\xb3\x00\x7a\xa6\x19\xe9\x2a\xb5\x4a\xd2\x55\x6a\xf4\x50\x40\xd1\xd2\x26\x4d\xea\xaa\x1c\x80\xe4\xab\x2c\x2c\x3d\x9d\x10\x9d\xe6\x18\x50\x2a\xec\x2f\x02\x5d\xfe\xf2\x66\xae\x77\xdd\x06\xe1\x58\x10\x0c\xff\xb5\x75\xd8\x73\xc2\xc5\x2b\x4f\x3e\xbf\x7a\xe8\x6d\x8d\x57\x4e\x1e\x5a\x22\xcc\xfa\xfa\x76\x11\xdf\xea\xb6\x93\xcc\x1c\x0e\xf7\xcf\xf6\x21\x1c\xba\xca\x41\x67\xb4\x4d\x18\xb2\x12\x8f\x56\x65\x41\x59\x7c\x70\xb9\xe8\x3e\x90\xaa\x14\xd2\x8f\x88\x35\x96\x65\x94\xc1\xa6\xa1\x43\x63\xff\x5e\x02\x4c\x83\x85\x73\xaf\xc4\xbe\x8d\xfd\x58\x7e\x11\xf4\x7a\x16\x36\xdd\x12\xa1\x37\x09\xf5\x1b\x9f\x13\x5e\x16\x8c\x4f\x82\xf4\x3e\x6f\x5e\x42\x7b\x08\xcb\x51\x1d\xc2\x4d\x86\x24\x29\x7d\x8f\x92\x91\xb0\xc3\x42\xa4\x40\x2b\xe1\xd7\x8a\x54\x4d\x2c\x09\x53\x99\x31\x21\x50\x5d\x90\x30\xbd\xf3\x20\x3d\x78\xa8\x66\xee\xb5\xfb\x2f\xd3\xbd\xd0\x1e\x82\xa5\x0d\xc3\x62\x4a\x70\xa4\x2e\x46\x4b\x42\x45\xe8\xf8\x19\x5a\xab\x9e\xf9\x82\xf2\x50\xa5\xfb\xec\x2e\xb3\xa3\x2b\x66\x8c\x19\x3d\x5d\x86\xf6\x2a\x5e\x49\x06\x70\xc4\x48\x27\xc9\x57\xc7\xe4\x65\x7b\x95\xb8\x53\xc4\x60\x2c\x4c\x28\xbb\x74\x0e\x4f\x93\x26\xb3\x8c\xac\x95\x00\xbe\xf4\xe1\x29\x56\xbd\x38\x76\x57\x11\x98\xd1\xc7\x5a\xd7\x38\xe3\xed\x45\xe7\x84\x2f\x2e\x79\x1a\x3c\x3b\x41\x5a\xb7\xda\xf3\xcc\x17\x87\x8f\x65\xf7\x1e\x16\x6b\xba\x02\xee\xb8\xa7\xeb\xb8\xa6\x2f\x85\x4f\x05\x3b\xcd\x75\x47\x8c\xd9\x7c\x78\x64\x8b\x08\x63\xab\xb0\x90\xee\xd5\x7e\x9f\x77\x91\xf6\x39\xfa\x09\x03\xad\xf0\x3a\xde\xe8\xff\xb7\x03\x7d\xf6\x4b\xb4\xcf\x0d\xe8\xb3\x06\x4c\x39\x45\x0a\xe5\xfe\x4c\x2e\x8c\xf1\x1e\xa6\x22\x22\xf4\xf8\xd8\x9c\x20\x98\x53\x6f\xae\x1e\x3c\x2b\xb8\xe6\xc4\x21\x85\xee\x0a\x78\x7b\x52\xaf\xae\xe5\x57\x16\xae\xf0\x8d\x9b\x44\xee\x9a\x96\xa0\xbd\x38\x9c\xec\x73\x1f\x15\xd8\x67\x00\x34\x90\xd6\xa1\xc9\x59\x69\x97\xd6\xec\x14\x0f\x11\x53\x64\xb2\x8e\x28\x77\x0a\x80\xb3\x99\x71\x5f\xa3\x4c\xa9\xff\xb5\x38\x30\xc9\x0f\xfa\xbf\x1c\xa4\xb7\xb7\xb6\x0e\x3b\x28\x7c\x7d\xf0\x17\xa1\xad\x68\x2c\xf0\xa4\x77\xed\xb8\x68\x7a\xcb\xa6\x31\x9d\x17\x2c\x47\xfa\xf5\xc0\xae\xc9\xc2\x84\x36\xea\xde\xcf\xdf\x6f\xfe\xe7\x7b\x1d\x42\xcf\xfd\x73\xd2\xed\x2d\xb5\xdb\x81\x71\xe4\x90\x6a\x91\x4e\x47\xda\xce\xb2\x56\x04\x97\x9a\x72\xbe\x48\x41\x15\x50\x29\x8f\x22\x31\xe5\xf0\x79\x45\x72\x9d\x92\xc3\x04\xcb\x0c\x46\x1f\x4d\x31\xac\x31\x03\xac\xd8\x01\x32\x97\x2c\xdd\xd5\x03\x58\x1b\x85\x57\x63\x97\x85\x01\x1d\x00\x03\x34\xf0\x74\xeb\xee\x26\xb0\x16\x8c\x11\x7c\xb1\x8b\x82\x01\x28\x58\x44\xc0\x59\x68\x1f\xff\x4e\xce\xc2\xec\x3d\x72\xd5\x21\x10\x39\x80\x5b\x75\xaa\xd5\xb2\x97\x93\xbb\x4f\xdc\xd2\x52\x12\x13\xe9\xdf\x22\x29\xbb\x10\x9f\x90\x4e\x83\x70\xe5\x2c\x56\x77\x42\xe7\xab\xc1\x98\xf0\x08\x6d\x46\xe2\x89\x1e\x5d\x80\x55\x9e\x70\xfa\x32\xb4\x49\x3a\x0f\x1d\xc0\x2c\x12\x56\xca\x46\x75\xd8\xa3\xd4\x90\xf5\x94\x4a\x4a\xab\x8d\xb3\x55\x4b\x54\x1f\x90\x44\xb3\xa2\x7d\x26\x79\x71\x51\x08\x51\x9c\x10\x37\x0f\x24\x57\x87\x34\xe3\x0b\x05\xc1\x6b\x77\x3e\x39\x31\xdc\x7a\xb1\xf4\xe7\x60\xac\xf5\x41\xf0\x63\x6b\x6b\x79\x85\xb0\x4d\xb8\x70\x65\xc0\x0e\xc0\x45\x9f\x14\xae\x22\x9b\xe5\xc0\xae\x69\xc2\xff\x09\xad\x7f\x88\xfb\x7f\x23\x02\xf0\x15\x02\x8b\xed\x45\x9b\x56\x0b\x8c\xb2\x23\x09\x74\x43\xa2\x8d\x2e\xe2\x5a\x88\xe8\x8b\x8e\x65\x33\x4f\x0c\x12\x88\x8e\x11\xf0\x82\x70\x65\xbf\xc6\x56\xba\x18\xe4\x35\x14\xdb\x20\x3d\x6a\x4a\x61\x2f\x60\xad\xed\xf5\xf3\x3f\x85\x85\x70\x73\x5d\xb0\x78\xe2\x72\x60\x7b\x75\xe5\xcc\x9a\xb4\x34\xef\xc6\x2d\xbf\x0b\xdf\xfc\xf4\x55\x01\xe1\xe7\x55\x84\xbf\x0c\xad\xa9\xa3\x72\x5e\xd4\x72\x1c\x50\x30\x48\xc9\xee\xd7\xd1\x00\xd0\x47\x53\x64\x59\x6a\xd4\x2b\x66\x23\x61\x91\x4e\x5a\x43\x80\x37\x32\xaa\x6b\xff\x0c\xd2\xfb\x63\xa7\xd1\x46\xb1\xf6\x1e\x9c\xd9\x03\x98\xba\x96\x3f\xf9\xc4\x57\x57\xe0\xc5\x98\xe0\x9d\xbb\xe8\xe2\x77\xaf\x1d\xea\x2c\xcc\xc4\x77\x16\x68\x9f\xb1\x3a\xb2\xcf\x4c\x54\x60\x3f\x84\x0c\x52\xac\x58\xd1\x31\x94\x29\x61\x04\xd0\x22\x83\x13\x27\x38\xc2\x16\x99\xb0\x44\xa3\x52\xbc\xb1\x8c\x22\xcc\x06\xdf\x7d\x21\x5c\xf9\x22\x87\x9e\xf4\xf9\x6b\x7f\x13\x96\x09\xe1\x2f\x81\x7d\xd4\x5d\xb1\x97\xe8\x3f\xae\x2d\x65\xe6\x82\x2f\x1e\xda\xf5\x8a\xb0\x54\xf8\x7c\x14\x48\x1b\x09\x06\x6f\xaf\xeb\x8d\xe9\xbb\x04\xe9\xf3\x02\x72\x46\xd8\x8f\x23\x49\xaa\xa0\x58\x49\xbb\xb2\xf1\xa3\x53\x52\x74\x29\x96\x02\xb4\x4f\xbb\x47\x18\x19\x04\x2f\xfc\xf0\xb9\xe5\x5e\xe1\xca\x32\x2d\xd6\x71\x57\x76\xbd\xd4\x30\x0d\x5b\x08\xdd\x08\xdf\x8e\xb4\xfd\xca\xed\x46\xcf\x75\x53\x45\x11\x0d\xaf\xb5\xa5\xd9\x68\x35\x63\xb3\x99\x35\x94\x05\x17\x59\x9b\xa5\x03\xda\x1c\x17\x1f\x32\x8b\xb3\xb9\xa9\x51\x4c\xe1\xd0\xe0\xd1\x7e\x21\x6f\x06\x89\x5b\x2b\x80\x0a\xf8\xf4\x3e\x3d\x32\xb5\xc2\xb0\x1e\x98\x6f\x0b\x8c\x7d\x70\xc5\xe3\x56\xaa\x0d\xe4\xee\xe9\xbc\x13\x58\x76\x0e\x7a\x51\xb8\x24\xdc\x22\x2c\x03\xf2\x01\xd5\xf5\xdd\x33\x98\xf3\xc2\xb3\xab\x9e\x6a\x76\xfb\xdf\x19\x76\xe2\x04\xed\x8c\x5d\xc2\x33\x37\x57\x56\x32\x5f\xc5\x9e\xd5\x68\xfa\xac\xbe\x97\xf0\xf8\x1c\xe2\x71\x2d\x81\x2f\x7b\x9f\xcc\x62\xb5\x88\x06\x9f\x15\x81\xa6\x41\xf2\x1d\xd9\x1b\x05\x48\xf0\xb1\xdd\x97\x54\x25\x92\x01\x81\xa4\x3a\x3e\x16\x07\x84\x8d\x92\x7a\xe1\x99\xfd\x88\x10\x68\x73\x9d\x1f\xe7\xbf\xf3\xe0\x13\x3d\x82\xfa\x9e\xf5\x61\x6b\xd3\x4b\x41\xfa\xd9\x1f\xbf\xb6\xd3\xbb\x7a\xf4\x44\xa7\xc0\xd5\xdd\x7f\x6d\xbe\x52\x3c\x7e\x3a\xf8\x0e\x99\x53\xfd\xee\x26\xb1\x49\x74\xe6\x30\x7b\x99\xf3\xba\x2c\x96\x45\xda\x9e\x67\x59\x7a\x22\x79\xff\x50\xe2\x7d\x79\xfb\xf7\x91\x46\x4e\x7d\x5f\x8e\xdf\xc7\x9a\x86\xe1\x60\x2d\x3a\x27\x71\x7c\x09\xd0\x87\xf0\xb1\x88\xe3\x4b\x78\x3e\xf9\xbf\x5f\x44\x9a\xc5\xc8\x70\xf4\x5c\xac\x28\x19\x8e\xd5\x90\xcf\xe1\x88\x08\x0b\x38\xf1\xb3\xd2\xd0\x1c\xb4\x95\x92\xdf\x18\xb1\x1f\xfd\x69\xc0\xdf\x8b\x2d\xc5\xdf\x6d\xdb\x82\x60\x1a\xcc\x54\xa0\x6f\x2a\xa8\xbc\x88\x85\x92\x29\x20\xab\x62\x95\x0a\x58\x1b\xc5\x93\xae\x59\x4e\x0b\xc4\x4a\xe5\x76\x7d\x63\x30\xe1\x02\x24\xdb\x54\x49\x33\x83\x85\xef\x0b\x84\xac\xe5\xc2\x65\x7a\x0e\x68\x58\x5e\xfd\xf3\x6f\xbf\x31\x15\xb1\x35\x60\xaf\x50\x8d\x9e\xff\x10\x45\x71\x43\x48\x8d\xaa\x91\x1a\x1f\xa9\x90\xab\xd5\x3a\xca\x80\xe8\xa2\x51\x30\x1c\xc3\x99\x21\xc3\x98\x64\x06\xd6\x50\x1b\x35\xd2\xb5\x51\x95\x3c\x28\x07\x16\xa4\x06\xe5\x40\xc3\x18\xe5\x46\x39\xc5\x6a\x19\x33\xa5\xae\x8d\x52\xf1\xd6\x98\xa4\x1b\x2d\x99\xab\xa9\x0f\xe5\xa5\x66\x9a\x26\xc7\x10\x27\x8a\x6a\xf9\xf8\x0f\x1e\x9b\x41\xaf\xea\x20\x3c\xf7\x9c\xf0\x31\xfd\x0a\x8c\x65\x0b\xb6\x7c\x70\x34\x5b\xe8\x19\xa4\xb9\xec\x58\x9f\xea\x41\x82\x00\xe4\x02\x02\xfb\xcc\x57\xa7\x7f\x7e\x07\x7c\x06\xd6\x09\x53\xa4\x79\x66\xbf\x33\xd5\x54\x1e\x55\x46\x55\x52\xd3\x22\x5d\x8a\x4c\x9e\xb4\xca\x0c\x7b\x99\x9a\xe6\x65\x1d\x73\x72\x64\xb4\x3d\xcd\xc4\x45\xaa\x9c\x9d\xb2\x3a\xd5\x45\xad\xe1\xbc\x70\x5d\x34\x3f\xc3\x93\xc5\xab\xb5\x79\x40\x0b\xf3\xf2\x94\xe9\x59\x96\x10\x8b\xdb\x67\xe8\x95\xba\xd4\xe1\x66\x18\x03\xd2\x16\x38\xd9\xfe\xbd\x5d\x36\x64\x3c\xca\x99\x9c\xe6\x1b\xf2\x5a\xc5\x99\xca\x3a\x9f\x5f\x1a\x80\x42\xe6\xea\x49\xd7\xe0\x61\x36\x11\x81\xe1\x59\x31\xef\x2e\x0c\xd3\xc4\x6e\x0b\xfd\x3e\xdf\x0f\x72\x46\x85\xe6\x3f\x30\xeb\xbe\xa7\x63\x5f\x1d\x37\x2f\x6c\x1a\xa1\x07\x7c\xfa\x8f\x6f\xbc\xdb\xb8\xea\xf4\xd9\xaf\x6c\xf0\xe3\xad\x53\x17\xf5\xec\x3a\x68\xb9\xb3\x55\x80\xb7\xd5\x8e\x5c\xe2\xa2\x9b\x02\x25\xb8\x05\xc3\x13\xf3\x2e\xd4\x36\xe7\x3f\xbd\x44\xb8\xbb\x29\x73\xd1\x2d\x3d\xd3\xee\xdf\x38\x75\x2a\x6e\xc0\x60\x1b\x31\xa8\xcf\x80\xc5\x13\x5b\x3b\x4e\xba\x75\x29\xa9\x63\x85\x6d\x31\x24\x47\xbf\x91\xf9\xf6\x0e\xca\x8f\xf3\xf4\xbd\x4a\x99\x55\xeb\x34\x99\x90\x47\x6e\xd4\xca\x60\x66\x86\x43\x0d\x80\x53\xd1\x99\x06\x30\x48\x03\x35\x8d\x38\x4c\xd3\x46\xc6\x68\x1a\x18\x35\x9a\x19\xff\xc0\x28\xa3\xbd\xbe\xfa\xa7\xb1\xb9\x51\x9a\xa2\x24\xb5\x59\x4a\xa6\xf3\x90\xdc\x76\x71\x97\x22\xdf\x99\x38\xe2\xbe\xcc\x50\x09\x3e\x9f\xc2\x62\xdb\x84\x3c\x30\x6f\x61\x60\xd1\x60\xba\xf8\x95\x93\xd5\x1b\x03\xcb\xb2\x7f\x3b\x13\x9b\x05\xca\xae\x5d\x7b\xfd\x9a\xff\xa7\x86\x11\xa5\x47\x7f\x02\x27\x4e\x83\xe7\x97\x2f\x1e\xde\xff\x74\xef\xfc\x27\x76\xef\x5f\xb3\xf2\x45\x57\x65\x87\x96\x78\xfe\xce\x10\x92\x7b\xd0\x8b\xd8\x28\x3e\xdc\x33\x86\xd4\x51\xe8\xa9\xec\x88\x49\x4f\xa9\x91\x00\x1b\x0d\x40\x57\x13\x05\x5a\x9c\x0a\x1d\x97\xce\x64\xc9\x15\x3a\x31\x45\xf0\x68\xc6\x1f\xc0\x9c\xc1\x7d\x10\x3e\x00\xcf\x5d\x8e\x6d\x14\xbe\x3a\xc1\x3d\xbf\x2b\xb6\x7e\x29\x53\xf1\xed\xa7\xc7\x84\xbf\x6f\x7a\xeb\x1f\x67\x7f\x8d\x0d\x43\xeb\xf0\xd2\x3a\x6a\xe4\xa5\xf7\x88\xf8\xf4\x16\xce\x6c\xb7\xab\x81\x92\x53\x3a\x1d\x36\xb5\xda\x4c\x51\xc8\xdb\xb2\xd7\x46\x95\x66\xda\x94\x9c\x1f\x91\x98\x57\xae\x8f\x17\x4a\x89\xf9\xb4\x25\x62\x35\x83\x04\x04\x52\x02\xac\x08\x07\x99\x27\x53\x38\x6d\x70\x1c\x18\x81\x1f\x36\x95\x56\x63\x88\x0a\x5e\x0d\xbc\x56\x44\xaf\x02\xcf\x8b\x70\x81\x13\xbf\x21\xc8\x2e\x9e\xfe\x0d\xeb\x7e\x4c\x03\x23\x83\xbd\xb0\xbe\x91\x6c\x56\x8e\x14\x95\x82\x83\xb4\x8a\x56\xcb\xf2\xd9\xce\x2c\x0d\xd5\x2c\x62\x28\x22\x0b\x00\x4c\x2d\xa6\x8a\xbc\x1d\x55\x12\xe5\x5c\xa1\x76\x59\x25\xa4\xd8\x22\xfe\xf3\x01\x4c\xcb\x8e\xfd\x94\x0f\xbe\xca\x16\xdc\x41\xba\x30\x5b\xda\x8d\xf1\x3a\x49\xcc\x0f\x5c\x27\x89\x74\xca\x47\xc2\x14\x5a\xc3\x74\x22\xfa\x2e\x2f\x62\x66\x39\x1e\xe9\x12\x39\x45\xd3\x32\x1a\x0e\x8a\xd2\x1c\xee\x77\x8e\x0e\x56\x5d\x62\x64\x48\x3c\xc1\x1f\xb9\xf6\xd8\x62\x03\xd6\x1c\xe1\x62\x0e\xad\x7b\x5f\xb8\xf8\xc1\xab\xef\xbe\xcb\xc4\xae\xbd\x81\x7b\x4b\x50\x06\xb4\xce\x0f\xe8\x95\x0e\xf7\x27\x52\xa8\x95\x6a\x68\x80\x7a\x86\x52\xa9\x94\x48\x35\x69\x29\x2e\xa5\x05\x67\xbb\x46\xde\x62\xde\x72\xa6\x98\x93\x85\x0e\x0f\x64\xa8\x80\x95\x87\x0f\xc8\x81\x83\x5e\xd0\xad\xbb\x7e\xc2\xaf\xd9\xb4\xee\xa1\xc0\x39\xd3\xe6\x67\x7c\x4f\xf5\x6d\xa4\x6d\x67\x62\xb2\x97\x36\x21\xbc\x32\x11\x4d\xdf\xc7\x39\x2c\xf0\x76\x72\xbe\x42\xb4\x91\xa2\x84\xff\x9d\x23\x69\x32\x95\x8a\x85\x58\x13\x42\x8d\x96\xf4\x6e\x93\x43\xf4\x03\x90\x3e\x4e\xf6\x6e\x13\xb5\x21\xe9\x5a\x9d\xd8\x20\xe4\x4c\xe3\xab\xf0\x3d\x58\x26\xcf\x42\x1f\x2c\x8e\x19\xaa\xd7\xe4\xad\x45\x4c\x89\x00\x4d\xbe\x70\xb9\x12\x7c\x01\xd6\xd5\xfc\xa3\x16\xbc\x21\x1c\x58\xfb\xed\x1a\xe1\xd5\x78\x5f\x24\x5c\xbb\x8d\x60\xf9\x81\xc0\x62\x42\xb0\x1d\x40\xb0\x68\x90\x8f\x6f\x50\x23\x4a\x2b\x59\x4e\xa7\x85\x4a\x35\xa3\xd1\xf2\xea\x78\x73\x73\x71\x61\x52\x19\xcf\x93\xfc\x3f\x7c\x4f\x84\x08\xfc\x43\x73\x66\x80\x1e\x06\xdc\x1f\x08\xad\x93\x94\xd9\xea\xd8\x01\xe1\x43\x9c\x45\xe7\x78\x76\x26\x64\xaf\xbd\x41\x67\x95\xdc\xe7\x6b\xbd\xc6\x54\xc4\x6b\xe7\x70\x4e\x15\x25\xe6\x58\xe1\x3a\xda\x62\x92\x3b\x67\x21\x7b\xaf\xb8\xed\x1a\xb3\x8f\xa9\x24\x51\x0c\x6f\x44\xe3\x80\x26\x25\xae\x7e\xb4\xc8\x90\x37\xa8\x25\xf7\x56\x29\x7b\x0e\x48\xde\xa8\x94\x40\x9e\x61\x24\x6d\x60\x7d\x44\x1f\xd0\xdf\x7c\x72\x75\xe4\x51\x21\xf6\xf0\x27\x57\x9a\x0e\x00\x7a\xe4\xda\x97\x9b\x40\xd5\xca\x57\x47\x31\x95\xef\xbc\xb2\x58\xf8\xed\xe4\xd8\xbf\x1e\x9b\x07\x8c\x27\x6f\x13\x3e\xe9\xb3\x21\x7a\xa2\xdf\xda\xe8\x6b\x84\x0e\xe8\xb4\x62\xa6\x31\xd9\x48\xab\xe5\x44\x8c\x46\x35\xc5\x71\x50\xaf\x66\x5c\x4e\xdc\xbe\x5e\xaf\xb3\xc9\xc5\x39\x70\xf8\xba\x23\xae\xc0\x71\x7c\xd2\x62\x85\x19\xfa\x0e\xe2\xb0\x4f\x13\xc7\x43\xac\x9a\x03\x58\x39\x9f\xc5\xdd\x3a\xb7\x7e\x79\x2a\xde\xa1\x73\xd3\xfe\xe9\xa5\xb3\xa7\xd1\x35\x83\x6e\xf7\x0a\x97\x27\x80\x0d\x9f\xfe\xb0\x59\xf8\x3f\xdc\xde\x13\xb8\x94\x8f\x4d\x59\x1c\xb4\x8e\x41\x52\x51\xd4\x76\x1a\xd9\x07\x93\xd0\x7e\xf2\x50\x01\x64\x7b\x39\x32\xcc\x06\xa7\x82\xe7\xe5\x2a\xbb\xcf\x96\x0e\x4c\x06\x45\x4e\x76\xba\xdd\x02\xd3\x34\xb8\x0e\xe3\xf5\x92\x44\xb7\x4c\x51\x57\xb2\xf8\x8c\xc0\x45\x9f\xe1\x40\xa9\x55\x82\x89\xb7\x66\x96\x84\x71\x9a\x9d\x07\xc0\x74\x1e\x10\x5b\x9b\xd9\xfb\xf0\xb4\xe3\x6f\x09\x6f\x3f\x57\xd6\xf3\xb1\x09\xbb\xde\x05\xdd\x76\x17\x77\x17\xf2\x4a\xf2\x62\x97\xf3\x17\xfc\x78\xa7\xd7\x45\x33\xe9\xd3\xbe\x29\x5d\x32\x19\x57\x56\x3e\x31\xad\xf3\xcb\xf7\x36\xe2\x4a\xcb\x95\x13\x2b\x66\xcb\xc0\x99\x92\xfa\x99\xf7\xdd\x42\x7b\x19\xa1\xb2\xb8\xef\xb4\x65\xfd\x48\x3d\x68\x56\xdb\x25\xbe\x1f\x3a\x3f\x7d\x54\x11\xd5\x91\x6a\x89\x74\xca\x36\xaa\x1d\xe9\xe9\x1d\xe9\x12\x59\x5a\x1a\x6d\x84\x15\xe5\xd6\x8c\x9a\xa8\xd5\xe5\x2b\xae\x8b\x3a\x5c\xbc\x5a\xa9\xf5\xa1\x63\xd3\xe7\x73\x29\x5d\xa5\x75\x51\x97\x45\x97\x57\x13\xd5\x29\x49\xf7\x29\xdd\x0d\xa9\xb5\x48\x9d\x90\xee\x6b\xf1\x11\x54\x71\x7c\xe3\x79\x75\x29\x47\x67\x49\x3c\xb1\x50\x6c\xac\x13\x3f\x31\x4d\x52\x7f\x1d\x7f\xba\x06\xc6\xcf\x4c\xfa\x8f\xc4\x99\xf9\xdb\xac\x1e\x17\x56\x7e\x22\x3c\x21\x7c\xf2\xd2\xfc\xdd\xbd\x1e\xbe\x88\x4f\xca\xb3\xef\x4d\x5b\xd6\x7f\xfc\x84\xc6\xdb\x6b\x72\xe9\x98\xf3\xfa\xc3\xf2\xe1\x7e\x03\xfe\x75\x06\x13\xb0\x7b\xdf\x35\xf8\x98\x3c\xf2\xdb\xec\x5f\xa6\xce\x5b\x56\xb9\xfc\xd3\x2e\x2a\xf1\xa8\xa4\xa9\x10\x92\xef\x8d\xa4\x0f\x61\x3e\xd5\x3f\x92\x65\xb6\xa8\x55\x0e\xce\x9d\x0b\xa1\xca\x02\x0b\x0b\x32\xdc\x0e\x9e\x0f\x18\x0c\x81\xba\xa8\xc1\x40\x99\x91\xd2\xf1\x0d\x4c\x28\x9d\x44\x76\xab\x3e\x94\xcc\x90\x4e\x2a\x37\x12\x0d\xaf\x22\x7d\x64\xc3\xbe\x78\x8a\xa8\x4f\x03\xa4\xc1\xff\x4c\x20\x6e\x20\xe0\xaa\xdf\xd6\x8f\xae\x1e\x58\x09\xfa\x0d\xe7\x81\x4c\x3e\xaa\x7e\xd4\xdd\x6e\x20\xd3\x3d\x32\x15\xd4\x8f\x59\x29\xb4\x3e\x7c\xcf\xc6\xe9\x23\x97\xae\x69\x31\xbd\xf9\xf4\x83\x7f\x73\x30\xbe\x07\xa3\x39\xbe\xec\xfc\xba\x86\xb9\xf7\xce\x3c\x9c\xcb\xb8\x1f\x9d\xb0\xf2\xc3\xe9\x47\x1f\xbf\x7b\xe8\xc4\x75\x4b\x87\xe3\xfa\x36\xaa\x37\xed\x21\x75\xbf\xf8\x74\x34\xc8\xe4\xb4\x56\x2b\x37\x1a\x28\xb9\x2a\xa2\x62\xf0\x50\x4f\x0c\x3d\x6e\x29\x55\x92\xba\x53\xcb\xc4\x26\xcd\xbc\x8f\x74\xce\xc2\x4e\xc8\x1d\xca\xf7\x46\xcd\x1e\x68\x10\x3e\xce\x00\x43\x00\xf5\xdd\xef\x0a\xda\xd3\xab\xe4\xb7\xba\x1d\xb3\x00\x00\x85\x17\xde\xec\x27\xfa\x20\x58\x5f\x3c\x44\xa7\xa1\xb5\xb2\x22\x7a\x3d\xa5\xe4\x28\xce\x68\xd0\xcb\x20\x54\xd7\x44\xa1\x45\x8a\x05\xb4\x5b\x89\xa6\xa4\x44\x5f\xce\xac\x23\xf6\x3d\xf3\x50\x40\x78\x4a\xf8\x44\x90\x81\x6c\xf9\x7b\xa3\x67\x0f\xd0\xd3\x69\x82\x20\xbc\xfb\xfd\x3b\xdd\x2a\x2a\x4b\x84\xd8\x90\x5d\xd3\x10\x9f\xbc\x48\xff\x2d\x40\x7c\x52\x20\x8b\xa6\x24\x62\x57\x22\x3f\x51\xcb\xf3\xb4\xd9\xa4\xa4\xea\x90\xe7\x0c\x69\x33\x34\xd6\x25\xda\x94\x4b\x1d\x55\x52\x1b\xd6\x49\x3e\x32\xe3\x0b\xc4\xeb\xe9\xc1\x8a\x1a\x3c\xcb\xe1\xe2\xa9\x4f\x85\x7f\x0b\xd7\x8e\xbf\x37\xf1\xae\x21\x4d\x27\xc0\x03\x42\x0b\x53\xf1\xe8\xea\x13\xc7\x77\xdf\xd6\x50\x59\x4d\x6a\x70\x9f\x44\x6b\xaf\xc7\xba\x98\x21\xf1\x6f\x32\xfb\xe0\x6e\x72\x2e\x98\xa9\x7e\x91\x1c\x74\xba\xd0\x6a\x85\x4a\x69\xe0\x79\xa5\x82\x66\xac\x16\xb5\xb6\x2e\xaa\x50\xa9\x5d\x6a\x5a\x07\xd5\x6a\x06\x28\xb5\x8c\xa9\x2e\xca\x98\x93\x62\x83\x9d\xb0\xbc\x1b\x0b\x34\xb0\x99\x2c\xe6\x6f\x23\x70\xad\x44\x34\x3a\x01\x68\x1c\x02\x1c\x1f\x08\xf6\xb7\x3f\xd9\xb8\xee\x5b\x50\x76\x74\xf3\x7b\x13\x67\xec\x3b\x41\x2f\x03\xfb\xae\xbd\xb1\xee\xbe\x25\x3b\xdc\xe0\x9c\x30\x60\x57\xbf\xe1\xcb\x08\x3f\x9a\xd1\x46\x6f\x25\xfe\x43\x4e\xc4\x84\x4e\x01\x0e\x1d\x5a\x32\x20\x67\xcd\x90\xa7\xf8\xd4\xbe\x99\x89\x83\x3f\xd9\xc4\xf3\x1e\x38\x3b\x53\x38\xbb\x5b\xf8\x76\xb7\x70\x96\xa9\x38\xd6\x7a\x0f\x9c\x47\xce\x80\xb1\x88\xc7\xa3\xc9\x59\x34\x8b\xac\x51\xd7\x76\x99\x79\x82\x69\x40\x3a\x38\x3b\x62\x64\x8d\x72\x87\x43\x63\x84\x2e\x27\x65\xb5\x68\xe5\x0a\x68\xb1\x10\xa5\x57\x52\xd5\x4e\x05\xb3\x16\x6c\x0d\xa2\x53\x59\x8f\x5e\xe9\x03\x66\x29\xd5\xa1\x10\x64\xd6\xd1\x83\xc8\xa0\xbf\xd8\x36\x38\x68\x5b\xcf\xc3\x78\xc8\x9f\xb1\xaa\x2c\x36\x0c\x3c\x96\x18\x16\xb8\xc3\x29\xc4\x18\x71\x50\x20\x2f\x5b\x4a\x74\x59\x7e\xdb\x55\x76\x2b\x81\xc1\x43\xa5\x53\xa1\x88\x1d\xc3\xe1\x73\xa7\x7b\x3c\x6e\x04\x0d\x9b\xe1\x4f\x73\x63\x60\x28\x02\x0d\x06\xe7\x86\xa6\xcf\x20\x15\x24\x6b\x3b\x90\x80\xd5\x1c\xd0\xa3\xff\xc0\x38\x3a\x32\x2f\x07\xc3\xf6\x22\xd4\xae\x5d\x21\xc2\xd6\x2d\x1c\x9b\x2c\x9c\xbc\x80\xfe\x07\x1e\x9b\x4e\x20\x9c\x0e\x1c\x9b\x9c\x0a\x41\x88\x83\x28\x5f\x0c\x9e\xc9\x3b\x9f\x47\xaf\xcc\xfd\x5b\x1e\xa6\xd7\x78\xe1\x43\xe6\x45\x76\x0e\xd2\x30\x65\x11\x07\xe5\x55\x38\x34\x4c\x56\x96\xd1\xe1\x65\x0a\x0b\xdc\xc8\x46\xd3\xe6\x59\x72\xfd\x16\x74\x56\x20\x9b\x31\x48\x1c\xbb\x50\x28\xb5\x91\x69\x71\x51\x66\x9c\x70\x29\xf0\x22\xc5\x29\x42\xcc\x4b\x70\x93\xf7\x3b\x81\x32\xf8\xf5\x7f\xce\xad\x8e\x4d\xa7\xa7\x0f\x2f\x66\xe7\x4c\xc3\xb9\xdb\xc0\x2a\xe5\x6e\x23\x22\x9b\x8c\xc2\x4f\xd7\xe5\x6e\x2f\x02\xd6\xbb\x0c\x10\xcb\xc0\x64\x24\xf3\xef\x91\xfc\xde\xe8\x8d\xf9\xbe\x68\x8f\xfc\x8a\x98\x72\x85\xfc\xde\x48\x64\x04\xd9\x6e\x8c\x8d\xe9\x4c\x2c\x67\xbf\xc2\x6a\x52\x33\x10\xea\xd4\x56\xc6\xa1\x35\x18\x9c\x46\x9d\x5e\x57\x1b\x35\x31\x6a\x35\xa5\xd7\x52\x7c\x52\xa5\xb6\xeb\x54\x9c\xda\x92\x8d\x4d\xe9\x61\x86\x5c\x8a\x4c\x1c\xa3\x61\x09\xe2\xe0\xc4\x9e\xaf\x1c\x7f\xe8\x6f\xad\x19\xd7\x78\x6c\x54\x1a\x30\x09\xe6\x6c\x58\x9a\x21\x1c\x9c\xb5\xf8\x77\xd3\x93\xeb\xf2\xfb\xd5\x0f\x1b\xfa\xc4\xe3\x9f\xfe\xf5\xc8\xcf\x96\x87\x67\x9c\x78\x45\xcc\x29\x6a\xfb\x01\x9e\x65\x6a\xa8\x2c\x04\x5b\xa6\xda\x91\x45\xb9\xe5\x06\xa3\x8f\xe3\x90\x7f\xeb\x60\xb3\x03\x6a\x43\x96\x8f\x41\x62\xac\x1b\x18\xb5\xe8\x60\xc6\xc0\xb8\x1e\x23\x27\x9d\xf5\x26\x75\x55\xf1\xaa\x8b\x2a\x50\x92\x7a\xca\x11\xf0\xb4\xf1\x32\xc0\x30\x5c\x5d\xf4\xcf\x33\x2f\x9e\xfd\xcb\x66\xd3\xbe\x0d\x75\xd5\xdb\x0a\xae\x16\xff\xe3\xf5\x99\x87\xc7\xbc\xf0\x98\xf1\x99\x27\x86\x56\x6f\x28\x03\xfa\xf5\xeb\xd7\x2d\x9a\xf7\xa8\x6a\x4c\xef\xe1\x85\x55\x4b\x1c\xeb\xd7\xf7\x5a\x34\x60\xfe\x26\xf5\x98\x81\xf5\x85\x1d\x96\xe0\xfb\x94\xe3\x88\xa6\x73\x49\x7f\xc1\x0e\x11\xa7\x4e\x2d\xd6\x4f\xb1\x6c\x86\x5d\x4d\xa9\xa1\x51\xe7\x96\xe3\x92\xda\x74\x98\x1c\xdb\x9d\xe8\x44\x44\xae\x08\x32\xc5\x92\x1d\x4c\x45\xa4\x75\xa5\xe4\x23\x52\x28\x65\x15\x07\x74\x22\x21\xa2\x0b\x87\xbe\x30\xe6\xc1\x3b\x26\xa4\x0d\x2d\x4c\x2f\xeb\x5a\x31\xa4\xfa\xdf\x1f\xbd\xf0\xce\xea\x43\x01\x43\xaf\x50\xfd\x18\xcb\xca\x87\x4e\xbf\x3b\xfd\x8e\xde\xe7\xdd\xb9\xb6\x1e\x91\x99\xcf\xf7\x7b\xfe\xdd\x27\x57\xdd\x71\xfa\x9e\x7e\xfe\xc2\xde\xe7\x7b\x4b\x79\x66\x48\x0e\xce\x31\xf8\x8a\xcb\x17\xd1\x22\xa3\x8c\xe2\x28\x9e\x31\xb3\x74\x4d\x94\x95\x74\x73\xbc\xfa\x53\xac\x93\xf6\x19\xe1\xb9\x4c\xa1\xd3\x6e\x52\xd6\x71\x4c\x1a\x17\x88\xe4\xe9\x71\xec\xc4\x92\x5e\x25\xd5\x89\x3e\xa1\xc7\x89\x0e\xfa\x89\xfc\x2e\x9d\x07\x06\x8e\xed\x48\xd6\x7d\x10\xc9\xa3\x93\xd4\x1d\x57\x46\x3c\x4e\x87\x43\xa1\xb4\x68\x95\x5a\x17\xda\x5e\x6e\xca\xae\xb2\xd7\x44\xe5\xc8\x6d\x70\x30\x06\xad\x92\xb4\x2b\x0b\xa5\x4e\xf9\x0b\x25\xa7\x8d\x90\xa9\x75\x62\x25\x27\x2b\x8d\xb5\x4e\x36\x8b\xf5\xc1\xd5\x0f\x6c\x48\xeb\x00\x8c\x95\x85\xc2\x05\xe1\x8b\x2a\x21\x56\xf5\xdd\x77\x9a\x30\x30\x76\x50\xb6\x4c\x9b\x8c\x4e\x01\x9e\x5e\xfd\x28\x90\x0b\xa7\xfe\xf5\x3e\x2d\xbc\x0c\xba\xd3\x3b\xf7\x54\xdc\x02\xec\xc2\xef\xa5\x45\x63\x1a\x21\x5d\x82\xf1\xda\x8d\x78\xf8\x37\x82\xc7\x25\x72\x96\xe4\x82\xef\xe1\xbb\xec\x69\x1c\x02\x45\xda\x54\xcd\xf0\x2a\x25\xa3\xd3\xd2\xc8\xca\xa2\x98\xa3\x20\x97\x92\x51\x2c\xc8\x8c\x57\xf3\x86\xe2\xe6\x7d\xc0\xc7\xfb\x41\xc8\x08\x70\x70\x02\x06\xa0\x3c\x4b\x78\xe0\x9e\x53\xb4\xf5\xd2\x36\xe1\xb4\x3a\x7b\x33\x50\x17\xf2\xe0\x7b\x41\x80\x5f\xb6\xa6\xc1\x3e\xe9\xf5\xc2\x19\x50\xd5\x09\xad\x95\x0f\xbe\xe7\x68\xb4\x96\x16\x79\x13\x03\x23\x2e\x3d\x2b\x57\x9b\xd4\x14\x66\x92\x42\xc3\xb2\xb8\x68\x57\x25\x97\xb3\xb4\xd1\xc8\x32\x87\x40\xee\x3e\x99\x5e\xcf\x1e\x45\x8b\xab\x11\x7d\x73\x45\xd3\x3e\x54\xa5\xc7\x50\xe0\xff\x40\xea\x15\x8f\x98\x31\x84\x81\x92\x9c\x47\xe8\xe3\x81\x9f\x87\x21\xfa\xe9\x22\xe1\xaf\xdb\x3f\xa2\xd7\xc1\x9e\x69\x82\x3f\x08\xf6\xb9\x85\x01\xc5\xe0\x77\x4f\xec\x1f\xb9\x23\x0e\x5e\x12\x81\xdc\xf2\xc7\x63\xc2\x2f\x5b\x60\x9f\x07\x84\x6f\xc4\xbe\x25\xa3\xc1\xf7\x88\x6f\xa7\x11\x45\xac\x88\xcf\x9d\x22\x66\xde\xe5\x52\x68\x6d\x36\x8d\x42\xe3\x33\x32\x4c\xba\x97\xd7\x6a\x6d\x1a\x4c\x1d\x2b\x02\x2d\x53\x8c\x96\x63\xa5\x09\xda\x97\xb8\xe0\x6b\xce\x94\x4a\x40\xbf\x2f\xd9\x03\x31\x61\x03\x78\xc0\xea\xbd\x3b\x67\x8f\x1e\x75\xdb\x47\x1f\x09\x3e\x10\x3e\x75\xe7\x98\xfa\x81\x67\x16\x7d\xb1\x7a\xca\x88\x09\x7f\x67\x4f\xcf\x69\x19\x3b\xdb\xac\xbf\x73\xe0\xc6\x4d\xf4\xc0\xae\x7d\x2b\x0b\x62\x83\x7a\x0f\x8a\x74\xc7\x30\x0e\x46\x30\x76\x45\x30\xe2\xb9\xad\x99\xd4\x00\xe4\x1f\x2a\x4d\x6e\x3b\xb0\xeb\xe5\x26\xb5\x4f\x6f\x54\x43\x2e\x8b\x0b\x28\x6d\x46\xa3\xcc\x4d\x51\xfa\x4c\x1a\x13\xd2\x4e\xe9\x31\x21\x25\x5e\x8a\x37\x29\x22\x19\x49\x97\x62\x42\x48\xd2\xae\xfa\x86\xab\x14\xa3\x9f\x15\x03\x0d\x25\x65\x09\x1c\xa6\x8f\xec\x87\x61\xef\xb1\x28\x6d\x64\x1e\x06\x7e\xe0\x28\xfa\xbd\x9a\x7e\xc2\xd5\x52\x04\xbc\x30\x4b\x44\x84\xe9\x04\xee\x9f\xd3\x32\xbe\xdb\xe6\xf2\xbe\x1b\x37\x81\x7d\x0b\x2b\xbb\x0a\x17\x7b\x83\x3b\x30\x2a\x48\x1e\x46\x20\x1c\xe4\x08\x07\x39\x65\xa0\x32\x23\x0a\x85\x4c\x03\xa1\xcc\x64\x34\xc8\x31\xb0\x0a\x4a\x26\x01\x7b\xa3\x43\xe7\xf7\x39\x13\x60\xd0\x65\x7f\xff\x79\x75\x6c\x93\x30\xeb\x48\xfe\xe3\x3b\xdf\x5c\xb3\x7c\x36\x7b\xfa\xfc\xbb\xcf\x0a\xb1\xfb\x90\xf4\x9d\x38\x7f\xe0\x9e\xfb\x44\xbd\x80\xd7\xe2\xd1\x5a\x4a\xaa\x38\xa2\xc7\xf7\x15\x9c\x82\x82\x2a\x9a\x56\xcb\x58\x96\x01\x78\x41\x79\x42\xcc\xda\x8b\x17\xc9\x23\x49\x48\xd5\x88\x23\xf4\x65\x4f\xec\x5c\x90\xa6\x3c\x02\x55\x4c\xf7\xf4\xa0\xfd\xf3\xe5\xd6\xff\xdb\x2a\x5c\xdb\x4a\xd6\x19\x2e\xc9\x4e\x7c\x1d\x9a\x43\x46\x80\x8a\x52\x73\xc8\x58\x54\x28\xf1\x3a\x90\xa2\x53\xb8\x90\x64\x80\x98\x14\x4a\x7e\x8c\xbe\x30\xc3\x1e\x89\x69\x3d\x74\x4e\x50\xa0\x3c\xc8\xeb\x8d\x1d\xf5\xb0\xa7\x5b\xd3\xd0\x42\x80\xdd\x8a\xd7\x59\x0c\x2e\x30\x03\xd8\x8f\x11\xf7\xc3\x11\x93\x0e\x5a\xec\xd0\x6a\x87\x72\xb7\xdc\xa3\x50\x70\x56\x9b\x4d\xcd\x1d\x05\x59\x48\x38\x28\x90\x97\x40\xa9\x3c\x78\x7d\x09\x4f\xa9\x0e\x1b\xdb\x38\x11\x34\x9e\x92\x49\x12\x46\x70\x05\x4f\x87\x77\xbe\x05\x15\x80\x7e\xf4\x6c\xc6\x09\xd3\xd4\xa1\x4f\xbd\x72\xf7\x9d\x8f\x4e\xf4\x7e\xe7\x04\x5b\x7b\xdf\xfa\x01\xb8\xf0\xe5\x9b\x40\x0d\xfa\xac\xbb\x3b\x5c\x53\x7f\xe9\xc4\xfc\xb5\x3d\xb6\x3c\x20\x4c\xe9\xd5\x0d\xc3\x35\x10\xe1\x5f\x45\xf0\x2f\x88\xe8\x00\xc5\xf1\x0c\xab\x52\x28\xd4\x78\x30\x81\x9c\xec\x66\xa4\x37\x6f\x44\x5f\xb4\x3d\xfd\x78\x8a\x2b\xfa\x8f\x7e\xad\x56\x18\x36\xf0\xd4\x91\xb7\xfa\x82\x67\xfa\xbe\x7a\x14\x7c\x0f\x9e\x15\x86\xc2\x2f\x85\x99\x60\x55\x6b\x1a\x5a\xa3\x01\xbd\xf3\x19\x5a\x03\x52\xde\x88\x1c\xe2\x07\xd2\x34\x0b\x8e\xe0\x87\xe3\x47\x57\xa5\x0c\x86\x45\x72\x02\x1b\x8e\x9c\x3a\x82\xb9\x44\xbe\xdb\x19\x5c\x80\xb7\xb0\x6f\x23\x1d\x94\x13\x51\x41\x5a\x41\xeb\x90\x62\xd6\x43\x91\x35\x6c\x92\x5e\xc9\xbd\x8c\x3b\x25\xc1\x70\xbb\xcb\x9c\xa9\xc2\xb5\xa2\x17\xbd\x2d\x1d\xaa\xf4\xa3\x8e\x7b\xc0\xb2\x25\xde\x27\xc1\x05\x60\xcf\x79\xa2\xf7\x70\x5a\xf6\x64\xec\x96\x1d\x52\x5f\xd5\xc9\x88\x16\x0f\x11\x5a\x14\x45\xf4\x0a\x0e\x28\x01\xcf\x30\x78\x8a\x37\xfa\x5b\x76\x03\x31\xca\x93\x6d\x3c\xb0\x28\xf0\x84\x1c\x20\x24\x07\xf4\x1f\x57\xd6\xf6\x7c\xe3\xf0\x5b\xf5\x34\x73\x4d\x60\x40\x17\x84\xfd\x6b\xc3\x84\x07\x11\x41\x2a\xc1\xab\x42\x75\xec\x2c\xe9\x67\x8f\x30\xac\x46\x6b\xb1\x94\x9f\xd0\x84\xe6\x18\x86\x07\xa2\xbc\x49\x72\x9d\x72\x3f\x85\xc9\xe2\xe3\xc7\x1c\x39\xf5\x28\x4d\xa7\x11\xda\x9c\xd8\x2a\xc2\xdc\x84\x60\xfe\x96\xc5\x39\xf2\xa1\x88\x12\x99\x47\xd0\x02\x4d\x26\x2b\xa5\x46\x0a\x79\x3f\x94\xcb\x8d\x1a\xfc\x48\x3d\xc5\x4b\x60\x63\x95\x9c\x30\x96\x30\x17\xcb\xc2\x5a\x00\xfc\x4a\x7c\x32\xe0\xce\x7c\xd6\x30\xf0\x41\x78\xd7\x4c\x63\x5a\xb0\x5a\xf8\xe7\xda\x2a\x97\x42\x3f\x6b\xef\x11\xa0\xee\xac\xaf\x04\x79\x40\x89\xf8\x42\x4f\x19\x37\x6f\xe2\x33\xb1\x57\xe8\xae\x40\x1f\x5d\x16\x5b\x03\xbf\x8c\x7d\xf4\xda\x4a\x7a\x34\xe2\x16\x86\x07\xeb\xb9\x6e\x08\x1e\x15\x55\x8a\xf8\xc5\x30\x80\x87\x6a\x85\x52\xa9\x51\x74\x95\x23\x40\x30\xf5\x00\x39\xa1\xf8\xc4\xee\x8d\xf3\x5f\xea\x66\x26\x12\x12\x9d\xaa\x58\xb0\x36\x08\xfa\x85\xfb\x8e\xfe\x1b\x20\x67\x74\xfe\x3e\x24\x58\xd0\x3d\x3d\x86\x24\xab\xf5\xd3\xae\x35\xf4\x83\x71\xd9\x62\xba\x4b\xfb\x57\xa9\x90\xd1\x0c\xc5\x72\x2a\x4e\x0d\xc8\x72\x58\x23\x29\xc8\x72\xcc\x75\xcb\x11\xec\x31\x55\x79\x52\x33\x1d\x06\x0d\x87\xf7\xde\x9e\x43\x17\x7f\x79\x64\xef\xe4\x40\xec\x7d\x4c\xe2\xd8\xf1\x57\x21\x6c\x4d\xa3\xfb\xee\x8b\x41\xd1\x8f\x5b\x8d\xf6\xf0\x64\x96\xc4\x94\xb1\xfe\x33\x28\xec\x0a\xe8\x82\x6e\x0d\x85\xf7\xae\x19\xd1\x38\x0f\xd3\xb8\x44\xe4\x5b\x49\x52\xff\xc5\xbb\x5d\x59\xd3\xa5\x0a\x05\x72\x6d\x41\x9f\x78\xeb\x9b\xfb\xdb\xa8\x1d\xa7\xbe\x5a\x4d\xb5\x6d\xbe\x63\x63\xfd\x5d\x93\x6f\xdf\x54\x3f\x9f\x3d\xff\xd9\xd1\xbf\x08\x5f\x3c\xfc\xf7\x57\x9f\x02\xee\x4d\xdb\xc7\x7d\x38\x6b\xc9\xdd\xe3\xde\x9d\xb7\xe4\x6e\x11\x86\x87\xc1\xa7\xf0\x0c\x7b\x00\xd9\x37\x85\xf8\x8e\x99\x55\x06\xf4\x94\xbb\xc0\x6a\x75\x3b\xbd\xbc\x5a\xaf\x94\x15\x05\x73\x35\x6a\xa7\x13\x9a\xbc\xd0\x0b\x65\x19\xa6\x43\x04\xa8\xd7\x49\x2e\x39\x99\xe1\x51\x72\xbd\x5b\x63\x22\x6e\x82\x98\x4c\xce\xc7\x9d\x1a\xd1\x3c\x25\xf9\xf9\x7c\x3a\x67\x4c\x5e\x3d\x80\x37\x6a\x7a\xed\x1d\x69\x5b\xb4\xec\x4c\x64\xe0\xa7\xaf\x3c\xb3\x6f\xd6\x34\x30\xef\xe0\x0e\x6b\xdf\xce\x9d\x46\x4d\xec\x3f\x68\xc4\x54\xe6\xbe\x92\xb2\xcd\x63\xf9\x65\xec\x9d\xe3\xf7\x54\xd1\xba\x91\x83\xd7\x3f\xbf\x74\xfe\xad\xcb\x6c\xb0\xcb\x8c\x19\x0b\x96\x77\x8a\x6d\x1d\x39\xa8\x77\xd7\x5b\x6b\x56\x62\x5c\xa2\x88\xcc\x5f\x23\xde\x61\x1f\x3d\x18\xd1\x2a\x65\x32\xb9\xdc\xa4\x85\xd0\xcc\x2b\x95\x0a\x39\x3e\xaf\x8d\x94\x42\xb4\x66\xe2\xba\x27\x64\x48\x3d\x59\xf0\xf8\x6f\x7f\xca\xd1\xb2\xe4\xe9\x23\xef\xef\x6e\xa3\xba\x9f\x3a\x32\xf9\xe4\x84\x09\x43\x06\xed\x65\x4f\x3f\x7e\xdf\x96\x23\xc2\x36\xb4\xf7\xdc\x03\x1b\x7b\x0f\x10\x69\xb8\x10\xc9\x4c\x5f\xb4\xae\x1a\xb9\x11\xa1\x88\x41\xad\xd7\xab\x2c\x0c\xb4\xca\xe5\x36\x15\x6d\xb1\x20\xeb\xf3\x46\xbd\x17\x57\x7c\xd2\xe5\x00\x6e\x1e\x2a\x99\x0a\x46\x10\xb7\x11\xa0\xf9\xb1\x4b\xbd\x90\xea\x3a\xba\xe5\xc0\xc3\x77\x1d\x15\x5e\x6f\x9e\x30\xac\xfa\xb7\x30\xda\xfd\xb3\x85\xe5\xf0\xcb\x87\x96\xce\xda\x6a\x10\xc6\xd0\x8e\xda\x9a\xae\xbd\x84\x4f\xf0\x5e\x79\x14\xe1\xff\x03\xb1\xe5\x72\x22\x4a\x0a\x42\x9a\x81\x32\x8e\x93\xd3\xd8\x98\xa2\x18\x86\x3d\x44\x70\xc7\x46\x54\xd2\xf7\x26\xdb\x14\x59\x4e\xf4\x23\x8f\xbd\xf5\x98\x70\xda\x03\x3b\x78\xd8\xdc\xd6\x13\x30\xb2\x55\x3c\xcf\x16\x20\x19\xed\x88\xf4\xa5\x85\x0a\x44\x94\x7a\x93\x49\xa5\x62\xad\xac\x8d\xd1\x89\x28\xc9\x45\x11\x0d\x25\x87\xcb\x90\x19\xb6\x78\xec\xa6\xe4\x94\x90\x7d\x87\xcf\x16\x1a\x4c\x99\x69\x9b\xf6\xd6\xcc\xac\x2f\xdf\x78\xf1\x35\x25\x3b\xe6\xd4\x78\xd5\x68\x7a\xc1\x84\x85\xf4\xe8\xd8\x86\x53\x2f\xed\xdc\xe8\x1e\x96\x46\x7b\x62\x27\x2b\xaa\x6e\xa9\xc1\xeb\x9e\x02\xdf\xb3\x17\x11\x2e\x06\xaa\x24\xa2\xd4\x42\x05\xcf\x18\xf0\x94\x47\x5e\xd4\x68\x2a\x90\xb9\x5f\xab\x50\x00\xee\x10\xa1\x29\xd1\x42\x55\x29\x87\x89\x1f\x06\xd0\xb6\x87\x21\xac\x7f\xf0\x1f\xc6\x10\x53\xf6\x6f\x23\xac\xbd\x74\xa5\xf3\x31\x3b\xd3\x17\xd0\xe7\x6c\x6c\xc3\x57\x6f\x20\xed\xd3\xf9\xdc\x47\xb1\x57\xd1\xe6\x7c\xf5\xea\xcb\xf4\xcc\x58\xff\x05\x57\xe9\x4a\xc2\xd3\xae\xe0\x13\x68\x63\xae\x50\x01\xaa\x84\xaa\x8d\x78\x98\x6c\x2d\xd4\x43\xbd\x1b\xfa\x2c\xd6\x7c\xa5\xd2\xea\x73\x33\x99\xa1\xcc\x0e\x39\xac\x46\x63\x31\x3a\x0e\x81\xec\x17\xfd\xc1\x20\x83\x0b\x95\x30\x41\x4a\x08\x40\xa1\x72\xa9\xbb\xa2\xa1\xfd\xcc\x3e\xf1\xe8\x0d\xfb\x93\x6e\x9b\x54\xfe\x1c\x88\xd7\x3b\xd3\xa6\x10\x19\x41\xe6\x8f\x57\x20\x85\xe9\x47\x7a\xde\xc2\x30\x65\x53\xeb\x1a\x67\x3c\xff\xca\xdd\x9a\xa1\x55\x55\xaa\x7d\xb6\x6d\xf7\xae\xb9\x5b\x57\xc4\x95\xe9\xed\x8a\xec\x53\x93\x07\x36\x94\x15\x74\x6c\x32\x80\x7f\x74\x2a\x2a\x8c\xf6\x99\xd9\x74\xf7\xbd\x90\xee\x65\x19\x5e\x1c\xb2\x8c\x9d\x38\x76\xa2\x79\xf8\xff\x85\x0a\xd9\x16\x2d\x98\x40\x57\x75\x0e\x95\x0d\xef\x87\x70\x9c\x86\x70\xbc\x05\xe1\x88\x67\x8f\x55\x47\xdc\x16\x2b\x93\x83\xb1\x84\x3e\xbd\x3b\xcb\xed\xb3\x32\x1d\x0a\x94\xca\x52\x2d\x9b\x93\x83\x50\x3c\x86\x10\x2b\x42\x0a\x30\x1b\xdf\x3e\x81\x80\xa8\xfa\x92\x28\xa6\xce\x5f\x25\xf7\x2d\x08\x0f\xa9\x8a\x9b\x38\xa1\x52\x88\x52\xea\xff\xdf\xa1\x8a\x26\x6e\x6a\xb8\xcc\x18\x8a\x4f\x1d\xe3\x2f\x63\x0c\x2b\xee\xa8\xb9\x09\x86\x2e\x47\x1c\xc5\xce\x01\x84\x22\xf3\x3d\x42\xb1\xb1\xc7\xcd\x50\x34\xdb\x11\x8e\xc2\x43\x08\xc7\x70\x09\xc1\xb1\x11\xe9\xb7\x29\xcc\xcf\xc8\x52\xcf\xa0\x7a\x46\x4c\x56\x97\x1a\x6a\xb5\x26\xb3\x1f\x79\x1b\xba\x4c\x5d\x16\xa5\xd2\x9a\x91\x6a\xcf\xa5\xb4\x08\xa7\x34\xa4\x1d\xb2\x29\x1b\x05\x25\xa9\xae\x8a\x77\xaf\x8a\x37\xbc\x16\x99\x97\xd2\x90\xc6\x1a\x2a\x0b\x87\x78\xc8\xf1\xfe\x0e\xe1\x40\xe2\xf6\x18\xb7\x6c\x0f\x95\x4e\xae\x9d\x38\xa7\xfe\xf1\xc9\x7f\xc9\x66\x94\xd6\xfd\xe9\x35\x2a\xd9\x71\xe5\xb6\x7e\x4d\xa5\x91\x48\xf7\x68\x90\x6e\xe8\x59\xb1\x6e\xd6\x72\x40\x2f\x5d\x55\xd2\xef\x39\x61\x50\xf7\x91\x1d\xcb\xe5\x23\x0e\x0c\x19\xd2\xbf\xf1\xe5\xba\xc7\xb0\x7d\xbf\x00\x7c\xca\xca\x99\xab\x54\x2e\x55\x4a\x75\xa1\x5a\x22\x79\xbc\x2c\x9c\x5d\x4a\x77\xb1\xb9\x3d\xc1\x6c\x19\x6d\xf3\xb0\xc6\x4a\x63\x95\x5a\xad\xe4\x79\xa5\xdf\xaf\xb4\x94\x95\xe5\xe5\xe6\x66\x2a\x4b\x58\x56\xa7\x44\xe2\x78\xc0\xed\x73\x54\x54\xf8\x32\x45\x79\x24\xa2\x27\xfe\x25\x2a\x1f\x62\x0c\x8a\xff\x4f\xd8\x9f\x29\x2a\xfc\x26\x77\xe5\xc9\x30\xb3\xf5\xbf\x84\x99\xe9\x49\x6c\xa4\x72\x74\xfe\xd3\xc5\x1b\x16\xbc\xdd\xad\x68\xd5\xb4\xc6\x19\xc2\xfd\x98\x9f\x11\xe5\x3e\xdb\xf6\xa5\x2b\xbb\x8d\x5c\xbe\x76\x93\x9e\x7e\xbc\x65\xc0\xb0\x0e\x81\x8e\x23\x8c\xb1\xab\x74\xf7\x70\xb7\xe1\x7a\xb8\x31\xcb\xde\xb7\x76\x56\x87\x96\x86\x47\x6b\xfa\xcf\x6c\x12\x7e\xae\x48\x1f\xde\xa1\xc8\x32\x6e\x42\x6d\xed\xa6\xe5\xbd\x07\xea\xbb\x56\x74\x2c\x8e\xf6\xdf\x1b\xe8\xdf\xf3\xd6\xa1\x88\xaf\x75\x88\xaf\x63\x38\x0a\xe9\xa5\x0c\xea\x96\x88\xc1\xe4\x54\x40\xb5\xc1\xa0\xc7\xa3\x96\x32\xd3\x19\x26\x4b\x7f\x08\xf8\xf7\x23\x43\xc1\xac\x39\x86\xb8\xeb\x41\x92\x9b\x47\xbc\xb5\x6c\x51\x72\x31\x43\x93\x76\x62\x72\x63\x96\x58\xdc\x00\x3b\x18\xe9\x01\x3f\x62\x2a\x56\x5e\xb4\x3f\x54\x76\xdd\x41\xbb\x68\xca\x9d\x43\x1f\xbe\xf3\xa9\x22\xa0\xd7\x1d\x62\x74\x2f\x1e\xef\x0f\xe1\xe0\xfe\xfd\x47\x95\xf4\xef\xd2\xb3\x3a\x54\xcc\xfc\xbc\x6c\xba\x62\xb9\xf0\xcb\xa2\x55\xd5\x41\xf5\x00\xf8\x92\x30\x79\xe9\xca\x51\x47\x6e\xa9\xa9\xab\x7f\xaf\x77\xbf\x7e\x14\xf1\x7b\x2e\xc0\x2d\x04\x76\x3f\x35\x34\xe2\xb4\x38\x55\x50\x6b\x32\x19\x8d\xba\x74\x8e\xcb\xd0\xea\x74\x99\x6a\x95\x4a\x41\x51\x26\x85\xb6\xab\x02\xf8\x11\xf0\x58\x2c\xad\x44\x2c\x2d\x94\x49\x3a\x45\xd0\x0f\x66\xa6\xbe\xfd\x41\x96\x40\xa4\x9d\x90\x62\x7d\x7c\x13\x19\x2d\x09\x4f\x1e\x30\x69\xce\xd0\xc7\xef\xd8\x9d\x0d\x0d\xe5\x2f\x6f\xd3\x31\xc7\x15\xdb\xfa\x8e\xc4\x22\x3a\x1c\x89\x68\x9f\x8e\xeb\xef\xbc\x1b\x70\xcb\xef\x9b\x06\x02\xad\xab\x87\x0e\x08\x55\xca\x46\xbc\x5c\x3d\xa4\x7f\xd3\xf1\x9a\xc7\x88\x8e\x9c\x82\x78\x90\x81\x64\x14\x7b\xc9\x83\x22\x39\x0e\x33\x2f\xf3\xd2\xb4\x46\x23\x33\xc3\x74\x1f\xe5\xed\xc6\xd7\xf1\xb4\xca\x0b\x5a\xbd\xc0\xe9\xcd\xf3\x76\xf2\x42\xde\xcb\x7b\x95\x6e\xc3\x51\x84\x0e\x4b\x29\xa5\x5d\x46\x62\x96\x8d\x8d\x53\x1b\xf5\xa1\xeb\x4d\x89\xf6\x53\x43\xe2\xf3\x0a\xf9\x40\x58\x12\x39\xd0\x91\xad\xaa\x1c\x93\xbf\xa3\x64\xe3\xbc\xf5\xdb\x6e\xdb\x3f\xf3\xbe\xc7\x75\x5b\x91\x34\x75\x8f\xea\x61\x85\x3d\x0b\x4b\xd3\x1d\xf5\x4f\xdd\xbf\xfe\xb3\x19\x1b\xef\xeb\x3a\xec\x1e\xb3\xa1\x7f\xcf\xdb\x86\x5c\x07\x77\xd7\x88\x13\xc3\xcc\xcb\x1c\x66\x33\xf2\x3f\xd3\x7d\xb6\x01\x7c\x23\x4f\xe3\x12\x79\x02\x69\x1e\x81\x34\x3b\x05\xd2\x1b\xa0\x4c\xdd\x2d\x24\xcf\x51\x9a\x03\xc2\xc7\x75\x77\xc3\x4d\xa1\x24\x32\x9f\x84\xf2\x81\xcf\xa6\x13\x28\x4d\x46\x22\xe1\x24\xb6\x01\x3e\xa5\x3f\x44\xba\x2b\x0b\x59\x15\x46\x97\x2e\x43\x2e\xd7\xa9\xd3\x20\x6b\x09\x58\xb2\x69\xce\x6e\x35\x62\x3a\x52\x14\x27\xd1\x31\x3e\xe3\x2d\xe1\xdf\x25\x09\x27\x85\x81\xca\x12\x23\x2f\xc5\x62\x42\x22\xd4\x60\xdc\x98\xdb\x87\xdd\xf2\xf0\x6d\xb3\x1f\x9c\x3e\x1e\x74\xea\xf5\xe8\xba\xa6\xa5\x79\x77\x17\x34\x85\xbb\x8d\xbf\x4d\x3f\x79\x64\x69\x29\x7d\xeb\x6d\x13\x7b\x95\xdf\x75\x6b\x74\x9c\x12\xe8\xea\xc3\xa3\xa6\xf4\xac\xeb\x34\xb8\xb0\xa0\xa8\xc3\x5c\x6b\x87\x60\x6e\x29\x86\xd3\x81\xe0\x7c\x09\xd1\x33\x03\x59\x5d\x3a\xad\x3c\x3d\x5d\xe9\x81\x66\xd6\x91\xe9\xc8\x32\x19\xac\x48\x19\xed\x65\x38\x8a\x28\x22\x7c\x29\x9f\x32\x04\x2e\xd9\x46\x02\x1f\x80\xc9\x2e\x44\x65\xed\xba\x10\x71\xa0\xfb\xc2\x8d\xa6\xe7\x6c\x77\x74\xea\xb6\xd7\x38\x63\x74\x45\xd1\x24\xe7\xe3\x61\x00\xe6\x3e\xd0\xb1\x29\x5c\x5d\xbb\x1b\x7c\x3a\x75\x42\xda\xf4\x70\xe9\x84\x79\x1d\xcb\x73\xb2\xc7\x68\xfe\x36\x76\x60\xc7\xfa\x52\x16\x6a\xa2\xdd\x6e\x5f\x28\xda\x67\xa5\xd4\x31\x38\x03\x9d\x73\xe9\x54\x90\x6a\x88\xb8\x15\x7e\x1b\x74\xcb\xe5\x5e\x2f\x03\x73\xf5\x6e\x3d\xf4\x14\x79\x8a\xed\x36\x9b\x1b\xbb\x15\xee\x63\xe8\x1c\x40\xc6\x37\xa2\x6c\x3e\xa5\x01\xb9\x22\xe8\x39\x22\xe8\x71\xbb\x31\xee\xb7\x96\x8b\x6a\xb3\x24\xbe\xe9\x32\xe3\xd8\x20\x2f\xfa\xba\xae\x65\x34\x3e\x26\x34\xc0\x18\xdf\x7b\x58\x95\x80\xe6\x65\xeb\x0c\x27\xf4\x53\xfa\xd7\x59\xcd\x20\x3c\xad\xcf\xc4\xf9\x43\x1f\x99\x5e\x3b\x53\x0f\xa0\x42\xcd\xef\xb7\xcc\xf5\x1e\x9e\x32\xa0\xa2\x4f\x4d\xc1\xcc\x2e\xb7\x95\x1d\x1b\x39\xde\x3c\x7c\xc8\xb8\xbb\x06\x57\xad\x9d\x76\x3f\x80\x77\xd5\xf4\x30\xe4\x86\xac\x93\x62\xb3\xb6\xaf\x85\xda\xda\xea\xe6\x37\x7b\xdc\xd7\xbc\x15\xe3\x6a\xa0\xde\x05\x1b\x98\x6f\x48\x2e\x44\x46\x44\x89\xbc\x40\x39\x45\xcb\x20\xcd\xf1\x47\x10\x66\x1c\xf1\x8f\x75\x6f\x94\x48\xbd\x0e\xf1\x65\x0f\xef\x0f\x63\x23\xf0\x07\xd7\x71\x17\x18\xb7\xf6\xf8\xfd\x60\xd4\xfa\xf5\xf0\x9e\x18\x4b\x5f\xc3\xbc\xed\x8f\x6c\xca\x99\x48\x57\x29\xa9\x6e\x11\x2b\x19\x0e\xac\x04\x0a\x46\xa9\x80\x2a\x19\x71\x64\xb1\x27\xfb\x32\x52\x52\x32\xf4\xf4\x84\x89\x4b\x34\x53\xe8\xc6\x41\xcf\x49\xaf\x16\x18\x69\xff\xc2\x91\xe5\xc7\x5f\x3f\x3e\x15\x74\xbe\x20\x1c\xc3\x4e\x7e\x53\xa9\x70\x8e\xb1\xc4\x9e\x01\x9d\x85\xbf\x09\x41\x1c\x47\x44\x76\xf5\x19\x24\xff\x39\xd4\xc0\x88\x2d\xe0\x40\x16\x2c\x1e\x17\xc9\x6a\xbd\xb9\xde\x3c\x87\x43\xab\x37\x19\x33\x58\x2d\x31\x6e\x15\x6e\x2c\x67\xfb\x14\x46\x23\xd2\xfb\x01\xd1\xc8\x4d\x3d\xf2\xda\xcd\x2a\x96\x24\x8f\xf4\x8e\x8f\x37\x9e\x41\x2e\x5b\xe8\xba\xae\x33\x1c\xfe\xe7\x2e\x20\x0b\xee\xad\x6c\xd0\x0f\x3c\x36\x58\x39\xa4\x6a\x84\xbe\xf6\xc4\x54\xe7\x61\x13\x2c\x1d\xd3\x73\xf0\xad\xf2\x4e\x53\x7b\x36\x8d\x56\x34\x1c\x1b\xa4\xa2\x99\xe6\x96\x11\xc2\x60\x70\xa2\xca\x37\x64\x72\xa3\x30\x94\xae\x7f\xf2\xee\x41\x5d\x06\xd7\x36\xf5\x1a\x3f\xca\xd1\x53\x48\x03\x47\xba\x79\x99\x21\x98\x9e\x95\x48\x16\x2b\x89\x2c\x56\x45\x34\x16\x9d\x4e\xaf\xa0\xf5\x6e\xbf\x3b\xc3\x6a\xd1\xe3\x83\x4a\x85\x36\x53\x36\xd2\xf2\x46\x10\xd8\x8b\x68\x9d\x2a\x7a\xfa\x76\x42\x87\xa5\x2d\x10\xb6\x62\x5b\x3b\x15\x07\x2d\x08\x25\xc6\x5c\x6a\x00\xf8\xa2\x22\x6c\x0f\x04\x73\x55\x51\xc3\xf8\x9e\x33\xb4\x08\x78\xc7\x01\x5a\x4b\x97\xcd\x1d\x30\x6e\x82\x66\x9c\xe1\xae\x63\xea\xa5\x30\x54\x05\xfe\x5a\x1d\x18\x3e\x63\x90\x30\x04\x41\x6d\xbc\x63\x40\xf7\x71\xa3\x4a\xab\x62\xe7\xc7\xdc\x4e\xf6\xce\x54\x74\x56\x4d\x42\xf0\x92\x9a\xba\x88\xdc\x80\x9c\x61\x1b\x65\xd7\xc8\xb1\xee\x31\x25\x2c\x25\x0c\x99\xe4\xa1\x9a\x68\x51\xf0\x49\x1d\x76\x52\xd8\xe1\xa4\x5f\x4e\xae\xdf\xfd\xe3\xeb\x5b\x77\xbc\xb9\xa6\xa6\xb1\x78\x4d\xed\xf0\x10\x3c\xfd\x85\xf0\xe3\x53\xeb\xce\x03\xd9\xa3\x8f\xee\xae\xff\x4b\xff\x03\x51\xb1\x7e\x9a\x1a\x8a\xd6\xf4\x20\xbe\xdb\x91\x0f\xae\x63\x74\x36\xa4\xf7\x9c\x0e\x08\x39\x74\xba\x53\x1c\x5e\xd8\x48\xa9\x13\x87\x07\x31\x62\xc4\x1b\x42\x43\xb9\xc8\xd7\x84\x02\x49\xf6\xcd\x41\x34\x02\x9f\x96\xf7\xb1\x1e\xea\x0d\x4c\x0f\x3e\x79\xdb\x8b\xf7\xdd\xfd\x88\xfc\x15\xf9\x84\xde\x83\xd2\x75\xcc\xc4\xbe\x7d\xfc\xbf\x3f\xbe\x76\xde\xcf\xf3\x57\xdc\xa9\xbb\x77\xf4\xb2\xe1\xae\xa7\x44\x38\xa6\xc2\xf1\x70\x1c\x82\x43\x4f\xf9\x22\x2a\x5a\x2b\x93\x8b\x71\x6c\x46\x75\x88\x1c\x08\x37\x09\x60\xe3\x0e\x32\x71\xfa\xd3\x0f\xc9\xd6\x0c\x1b\x65\xe5\xdf\xb6\x7d\xff\x97\xad\x3b\x78\x38\xbe\x30\xb0\xbb\xa5\x25\xe7\xe0\x87\x8f\xde\xd7\x39\x9b\x3c\x3f\x8a\xec\xef\x01\x70\x9c\xf8\xfc\x64\xec\x5a\x0d\x25\x27\xbb\xdd\xf3\xe3\xc7\x4a\x28\xde\xfc\x10\x0e\x70\x7e\xbf\xfb\xc1\xbf\xb0\x6f\x73\xab\xa3\x8d\x56\x19\x1c\xf7\xe2\xc7\x3b\xee\xf7\x77\xc8\xf7\x1f\x6c\x69\xc9\x27\xbc\xf3\x23\x59\xc3\xf0\xab\xa8\x4c\xaa\x2e\x62\xcf\x64\xec\xd0\x9d\x9e\xee\xf3\xb9\x3d\x4a\x8f\x31\xcb\x18\x50\x67\xda\x1d\x0e\xab\xcf\x83\xac\x8c\x1c\x52\x87\x90\x8d\x3e\xe8\x43\xfb\x87\xa7\xac\x71\x13\x38\x24\xed\xe5\x50\xe2\x16\x22\xc5\x8b\x49\xb1\x8a\x32\xe3\x29\x15\xc4\x76\x22\xb7\x3f\xc8\x34\x46\xfe\x2c\x5d\xd4\x6f\x54\xa8\x7f\x97\x3e\xb5\xf9\xc2\xcf\xc1\x3b\xea\xa6\xdc\x39\xf8\x91\x3b\x9f\x2e\xa4\x69\x79\xd7\x63\x4f\xe9\x15\x47\xe5\x3c\x33\x61\xe4\x91\xbe\x35\x75\x23\x5f\xef\xb7\x91\xed\xd1\x75\xd9\xf4\xfb\x85\xab\x8b\x57\x59\x4a\x91\x93\x3d\xeb\xf6\x1e\xdc\x10\x97\xc8\x8b\xb9\xe0\x73\xba\x8a\x7d\x18\x59\xe7\x9d\x22\x16\x95\x41\x6e\x80\x90\xb7\x40\xb5\x5d\xed\xb0\x58\x28\x85\x96\xe7\x55\xb2\xa3\x08\x72\x53\xe2\x06\x0f\x81\xf9\x86\x21\xe5\xca\x33\x71\xe7\xd9\x01\x5f\xe3\x85\xf0\x76\x8f\x0f\x65\x44\xae\x16\x88\x0c\x1c\xa9\xec\x39\xda\x3e\xb9\x71\xb6\x6f\x85\xf5\xbe\x5e\xb2\x4e\x8e\x22\x4b\x29\xf8\xbc\xa6\xb6\x63\x18\x4c\xbf\x77\xdf\xbe\x7b\x85\x7b\xb3\xac\xdd\x14\x8b\xf5\x08\x96\x5b\x91\xfd\x70\x2b\xd2\xb1\x76\x64\x3d\x98\xe4\x5a\x85\x86\xb1\x28\x90\xdd\x69\x51\x3a\x94\x4e\x9d\x4e\xa3\xb0\xe3\x43\x84\x43\x7b\x38\x8f\xd2\xe2\x43\x44\xa2\x64\xaa\x1e\x2a\x49\x56\x43\x89\x3b\x84\xf8\xcc\x48\x15\xfb\x13\x93\x4e\xc0\x3d\xb5\x9c\x2a\xb1\x6d\xf5\xd2\xae\x1d\xca\x7c\x23\x8c\xb0\xd7\xa8\x1a\x66\x0c\x02\xbb\x62\x3b\x9f\xbc\xbb\x7f\x8f\xf1\xa3\x3a\x54\x81\x77\xc4\xbb\x3b\xd8\x8f\xe5\x48\x6e\x92\x4e\x4e\x69\x58\xca\xe8\x34\xba\x10\x0c\x5a\x05\xb4\x88\x9e\xb2\x78\x71\x23\xb2\xb2\xa4\x7d\x60\xbc\x14\xbd\x32\xa7\x46\xa1\x9b\xc0\x86\x3a\x4f\xfd\xe4\x41\xc2\x68\xba\xfb\xb4\xbc\x05\x7d\xbb\xde\xd6\x64\x8e\x38\x84\xee\xd0\x3a\xc8\x38\xa9\xcf\x2c\xfd\xe0\x37\x66\x1a\x0f\xd0\x74\x78\x41\xdd\xc4\x16\x39\xd3\x20\xf2\x69\x1a\xf8\x94\xf9\x0d\xd1\x26\x17\xe9\x6c\xb7\xda\xa4\x31\x42\x99\x33\xc7\x67\x30\x6a\x7c\x4e\x23\xd4\xe6\x69\xf3\x9d\xce\x0c\xb3\xd9\xa3\x61\x32\x90\xa2\x7e\xd1\xa4\xa0\x6c\x46\x8f\xe4\xc4\x87\x88\x79\x60\xb8\x89\x5b\x12\xa7\x95\x48\x25\x2e\x41\x2f\xdc\xaf\x49\x24\x58\xbc\x4b\x68\x19\xfe\x77\x37\xb0\x80\xfb\xda\x2b\x6d\xbd\xe2\x66\x5a\x9b\xbe\xa3\x65\x04\xd8\x25\x44\x88\xd6\x06\xcf\xc6\x76\x8e\xa9\x4c\x51\xdb\xe0\x4b\xa1\x97\xa8\xb6\x11\x5e\xdb\xc1\xbf\xe0\x66\x84\x97\x02\xdf\x83\x40\x9a\xe6\x94\x72\x85\x42\x25\xa7\x8f\x12\x56\x83\x78\xa8\x22\xf5\xd6\x18\xdf\x3f\x58\xac\x55\xd8\x87\xa0\xbe\x99\xf5\x7a\x91\x8c\x0f\x58\x7e\x78\x07\xfc\x8b\xfe\x43\x18\x1a\x5e\x36\xa2\x04\x7c\x82\x9e\xeb\x01\x9f\xc1\xa1\xcc\x2f\x94\x0f\xeb\x3a\x56\xab\xa2\x6c\x66\x0f\xef\x4f\xb7\x51\x2a\x15\x34\x20\x3d\xb3\xdf\x29\x93\x79\x61\xc2\x8d\xab\x12\xdd\x15\x29\x0c\x97\xe8\x81\x98\x62\xe0\x91\x78\xaa\x45\x0a\xa7\x82\x37\x2a\x66\xf7\x1c\x3d\xa0\x77\x59\xb9\x3f\xdb\x12\xac\x28\xdd\xbe\x66\xce\xaa\x5b\xe7\x3a\x5c\xdd\x3b\xf5\xd4\x36\x8e\x5b\x41\x2f\xa8\x1d\x18\x7a\x24\xe4\xb3\x77\x18\x34\xb7\x74\xde\xfa\x99\x23\x07\xde\xdf\xd0\xa1\x02\xbd\x23\xda\x4d\x99\xd4\x4b\x70\x06\x1b\x43\x9b\x2a\x8b\xea\x18\x31\xdb\xf4\x7a\x43\x86\x47\x6e\x90\x73\x3e\x06\x06\x60\xb6\xd6\x4c\xa9\x90\x85\x9c\x43\x39\x29\x95\xa8\x2e\x74\xaf\x97\xbc\x9e\x32\xe3\x37\xe5\x62\x2d\x91\x24\xe0\x47\xe7\x94\x03\xb0\xe9\x3c\x8c\x0f\x96\xf0\x93\xda\x31\xba\x71\xfe\xa6\x96\xe1\x75\x0d\x2f\x6d\x9d\xdb\xc0\x28\x4a\x8f\x2f\x98\x0f\x0a\x96\xfb\x47\xfb\xeb\x33\xa3\x63\xc7\x45\x9d\xaf\x87\xd9\xd8\xc2\xb1\xe3\xd7\x1a\xac\x77\xd5\x3d\x7a\xa8\x5b\x1f\xe1\x3b\x7a\x2b\xbd\x6d\xdd\xf1\xd8\x25\xa7\x77\xc2\xc8\x5e\x43\x56\x59\x1f\x29\xae\xc4\x7c\x5a\x8b\x74\xde\x4a\xc4\x27\x2d\x55\x16\x31\x2b\xb4\x2c\xa0\x54\x6a\x8a\x55\x43\x1d\x32\x57\xf4\x2c\xab\x96\x51\xd8\x0e\x52\xe3\x73\xb5\xaa\x44\x12\xb4\xa4\x91\x22\x76\xfc\x46\xb0\x62\xf1\x02\xc8\x65\x2a\x0b\xaf\x7d\xbd\x14\xca\x6d\x25\x9f\xbd\x2b\xdc\xde\x54\x7a\xb2\xa4\x3f\xda\x7f\x13\xcd\x1b\xc2\x03\x26\x82\x13\xb1\xbc\x1d\xbb\x36\x6d\x12\x69\x35\x09\xf1\xf1\x11\x64\x27\xa9\x90\xbb\xd6\x33\xe2\x74\x70\xd0\xa9\xb0\x41\x83\xc6\x69\x73\x1a\xa0\x3b\xcd\xed\xe5\x1c\x0e\xb3\x0b\x69\x09\xd7\x51\x64\x2d\x51\xc8\xc2\x94\x4e\xce\x90\xde\xd0\x3e\xde\xa4\x4f\x4a\x3b\xde\x97\xa4\x92\x09\x04\xac\x89\x8b\x54\x5d\x66\x20\xec\xe3\xc1\x89\xc6\xc9\x79\x25\x63\x9b\xcb\x07\x02\xc5\xf8\xe7\x7b\x77\xfc\xe6\xa5\x07\xf6\x82\x25\x3b\xed\x74\x85\x91\x1e\xb7\xfe\xae\x5e\xd3\x2a\xb2\x07\xcd\x8e\x0e\x6b\x80\x46\xee\xc2\xa8\x75\xd5\x07\xde\x7f\x66\x05\xe8\x32\xfe\xd3\x3b\xee\x45\xb0\x8e\x47\x34\xba\x88\x64\xce\x86\xa4\xae\x36\x62\x75\x73\x2e\x5e\x6e\x91\xb9\xac\x56\x5e\x66\x54\x79\x91\x65\x07\xa1\x3f\x5d\xfb\x32\x3a\x0e\x64\x88\x4e\x76\xec\x35\xef\x77\x5b\x2c\x9c\x3c\x29\x86\x25\x55\x37\xf4\xeb\x2d\xd7\x27\x8b\xd6\x68\x69\xf4\x5f\x87\xb2\x30\x4f\x0e\x09\xab\xd1\x60\xc5\x36\x0a\xc9\xbc\xfc\xad\x65\xc9\xbf\x3f\x28\xdb\x56\x3a\x7f\xf3\xa9\x23\x8a\x21\xb7\x47\xba\xf4\x2e\xfd\x5b\x76\xb1\xbe\xd7\xec\x79\xcc\xd5\x07\x16\x5e\x15\x2e\xd3\xc2\x97\xc0\xcd\xed\x5a\xfb\xd6\xe5\xb4\x05\xe6\x57\x97\x0f\x1a\xc5\x82\x39\xc0\x35\xb7\x6f\x54\x58\xae\x7a\x75\xcf\x63\x62\x6d\xc7\x71\xb8\x01\xf9\x1c\xb8\x1f\xb9\x59\x6d\x60\x91\x4d\x6a\xc3\x3c\x76\xe9\x9d\x2c\x2b\x53\xab\xf5\xe4\x38\x50\x51\x7a\x90\xb3\xd7\x66\xa1\xc8\x89\x4d\x0c\xa9\xa4\x7e\xc1\x86\x60\x79\xb9\xe8\xf6\x7b\x68\x6b\x15\x8d\xac\x52\x3f\xd2\x29\xd0\x0f\x02\x38\x22\xc6\x87\xcb\x80\x37\x23\x5c\x10\xc8\x57\x15\xde\xff\x9e\xb0\xe3\x2f\xc7\xee\xb0\xe7\x9f\x79\x1f\x6c\x29\x76\xe7\x65\xb8\x5d\xb2\x30\x73\xd5\x50\x7a\xdb\x6e\xdb\xa0\xcf\x05\x47\xec\x04\x38\x18\x1c\x20\x9c\xa4\x6f\x79\x6e\x42\x1f\xe5\x72\x23\xc9\x21\x78\xaf\x6d\x36\x18\x04\xd7\xe8\x78\x18\xa0\x0a\x62\x6b\xc8\x7b\x5f\xb6\xcd\xa6\xb3\xe8\x45\x3a\x9e\x9e\xd9\xf6\x88\xf4\xde\xd5\xb6\x89\xf4\x55\x7a\xba\x8e\x67\x67\xb7\xad\x17\xdf\xa3\x0a\xdb\x66\xc3\x6c\x7a\x1a\x7a\x6f\x6e\xdb\xca\xd8\x6a\xf2\xb9\x03\x42\x7f\xc8\xc2\xd5\xe8\xbd\xf9\x6d\xeb\x62\xf7\x93\xcf\xa5\xa1\xf7\x1c\xe4\xbb\x0b\xda\xee\xc7\xdf\xa5\xe8\xb6\x1f\x85\x16\xc8\xd0\x73\x29\x17\xbe\xbd\x8c\x58\xb4\x9a\x4c\x8e\xb3\x78\x29\x0d\x95\x63\xb1\x64\x73\xd0\xed\x76\x68\xd3\x1d\x38\x51\x15\x4b\xde\xc9\xeb\x6c\x63\x6c\xc2\x91\x1e\x30\x26\x8f\x98\x43\xe2\x2f\xa4\x93\xae\x0c\x11\x4a\xd1\x81\x84\xcc\x17\xfb\x06\xcc\x73\x15\xde\x31\xb7\x66\x78\xce\xf3\xac\xb3\x63\xf9\x9e\x87\x17\x7c\xbc\x6a\xc3\x13\x42\xf3\xe8\x99\x0f\x8c\x9e\x5e\x0b\x86\xbf\xdd\xd6\xb9\x28\x3a\xc8\xef\xef\x37\xc8\xae\x61\x0f\x7c\xb6\x03\x38\xd7\x6c\x12\x8a\xb7\x3e\xbd\x79\xcf\xa3\x35\xfd\x48\x9e\x05\xc5\x08\x03\xe0\x12\xfa\x1e\x04\xff\xa2\xb6\xc7\x62\x6b\x09\x9e\x23\xd0\x7b\x0e\xfa\x6e\xf4\xde\xe2\xb6\xa5\x22\x4e\xd4\xb4\xb6\x4b\xbc\x86\xa9\x46\xbe\x40\x31\xb5\x24\x52\x9d\x1b\xf0\x79\x68\x8b\xd9\x6c\x37\x18\x68\x59\x80\x41\x16\x3d\x55\x17\x55\x2b\x7d\x19\xc5\x64\xb6\x65\x71\x5a\x31\xad\x66\x8b\x8b\x95\x19\x19\x85\x75\xd1\x0c\x5d\x1a\xee\x04\x51\x1b\xd5\x5a\x06\xf3\xa3\x79\x9a\xe2\x75\xbc\x97\x87\x72\x86\x57\x26\x46\x99\x8a\x33\x2d\x1b\xc5\xf2\xcb\x50\x4a\x52\x69\x9e\xa1\x3c\x39\xf7\x2b\x94\x4c\xd3\x48\xbd\x9b\x08\x70\xbe\x76\x05\xc1\xb8\xa4\x89\x4f\xde\x56\x88\x97\x15\x4c\x45\x62\xb4\xe9\x67\x4d\xf7\x08\x97\x4f\x7e\xa0\xbe\x0b\xd8\x5b\xb4\x8f\x8f\x98\xea\xba\x13\xd8\x55\xc5\x2d\xfd\x5e\x7a\xfb\xc6\x29\xa7\xf7\xdc\x73\x74\x77\xb8\x27\x3d\x21\x76\xb6\xa6\xcb\x2b\x2b\x1e\xa4\x9b\x8b\xd3\xfd\x1f\xbf\xd6\x6e\xd6\xa9\xbf\xed\x12\xb3\x93\x3d\x43\x85\xa8\x6e\xd4\xba\xc8\x80\x34\xb3\xd7\xa0\x2a\x2f\x2a\x4c\x67\x7d\x7a\x9f\xd7\xab\x33\x44\x18\x83\x23\x9b\x61\x7a\x74\x2f\x2e\x36\x04\x02\x5e\x87\xc3\xab\x54\xa9\x0c\x1e\x8f\x37\x2d\x8d\xf2\xe6\x17\xa6\x63\x12\xa5\x1b\xcc\x66\x8b\xd7\x9b\x3e\x30\xea\x05\x54\x87\x9a\x28\xa5\x93\x75\xae\x89\xca\xda\xb5\xea\xa6\x42\x38\x6f\x2f\x65\x5e\x82\x74\xfd\x94\xb8\x4b\x4c\xed\x0b\x4b\xb2\xd0\xcb\xdb\xdd\xa9\x65\x21\xc3\x10\xf2\x3e\x44\x9d\x40\x3a\xbe\x5d\xa3\x43\x56\xa4\xc9\x3a\xe1\x63\x3d\xa4\xa1\xc9\xa5\x22\xf2\x5e\xf8\x74\xa9\x78\xb3\x0c\xd7\x6e\xc2\x61\x4f\xec\x9d\xf7\xe5\xee\xf9\x8f\x79\x69\xdc\xc4\x11\x08\x97\x65\x39\x6f\x29\x32\x8a\x6d\xf3\x3c\x95\x4d\x3d\x8c\x5a\x60\x47\xc2\x9d\x1f\x34\xde\x65\xaf\x6a\xee\xa5\x63\x0b\x18\xa6\xea\x90\x72\xe0\xcc\xba\xa2\x89\xcd\x63\xa6\xf5\xef\xcd\x54\xbf\xfc\x94\xe6\x25\x61\xf1\xc1\xf1\x4d\x8e\x4e\x1d\x90\x05\xfc\x06\x23\x03\xf9\xdd\x6f\xbf\xb5\x82\x1e\x70\xb8\xa2\xc3\xe8\xf1\x9d\xc1\x77\x4d\xcd\xaf\xf5\x5a\xfb\xb7\x9a\x49\x73\xe6\x83\xbc\x51\x13\x6e\x17\xf5\x39\xee\xe7\xfe\x11\xa2\x69\x90\xea\x42\x6d\x8a\x0c\xf2\x64\xbb\xf3\x9c\x7a\x4d\x69\x90\xcd\x77\xb9\xdc\xee\xfc\xbc\xce\x68\x4b\xe5\x41\x7f\xa5\xbf\x2a\x3d\xdd\x65\xb1\xb8\x34\x6a\x35\x32\xba\xf3\x1d\x0e\x97\xd3\xa9\x70\xe1\x41\xaa\x69\x1e\x97\xbe\x36\x6a\x70\xb9\x3c\x03\xa3\x2e\xa0\xe8\x58\x13\x55\xe8\x60\x11\xce\x4a\xcd\x0f\xd6\x45\xf3\xcd\x29\x94\x95\xa8\x2b\xa5\x2e\x53\x09\xd2\xa6\x50\xb7\x7d\xba\x4b\x82\xb8\x99\xd7\x77\x47\x0f\xa7\x92\x36\x24\x52\x36\x0f\xa7\xe3\xfb\x90\x2e\x0e\xa4\xf6\x4a\xff\x7f\xac\xbd\x09\x80\x54\xc5\xd1\x00\xfc\xfa\x9d\x73\xdf\xf7\x3d\x3b\xd7\xee\xce\xce\x5e\xb3\xbb\xc3\xc2\xc2\x0e\x2c\xf7\xb5\xcb\x02\xc2\x08\x88\x82\x0a\x02\x1e\x88\xa2\x1c\x8a\x8a\x37\x9e\xa8\x78\x25\x2a\x78\xc5\x0b\x10\x47\x9d\x10\x23\x84\x18\x45\xc5\xa8\xf1\xd3\x44\x63\xd4\x18\x51\x63\x34\x98\x90\x2f\x31\x02\x6f\xfe\xee\x7e\xc7\xbc\x37\xb3\xa0\xdf\xff\xff\x2a\x2b\x4a\x1d\xdd\xd5\x55\xd5\x55\xd5\xdd\xf5\xc8\x6f\x26\x3c\xbc\xe6\x9e\xa2\xd4\x28\xdd\x96\x36\x4a\x52\x75\x59\xa0\xd5\xeb\x24\xa1\xda\x9f\x72\x68\xf9\x2f\xb4\xec\xdf\xe5\xbe\xe9\x0f\x2c\x98\x7b\xe0\x09\xa1\x6b\x7a\x74\xe9\xbb\xa4\x4a\x9c\x47\xcf\x39\xef\xa2\xf0\xe2\x90\x41\xd9\x3d\x1d\xf9\xeb\x27\x09\x82\x9a\x0d\xe5\x99\x21\x6e\xc9\x0f\x18\x00\x91\xa6\x1b\x8d\x41\x9f\xd7\x4c\x9b\x1a\x43\x21\xb8\x2d\xfa\xb9\x26\x3a\xe6\x88\xb5\x38\x9a\x59\x36\xe0\x70\x04\x3c\x1e\x53\xc0\x6b\x1e\x2c\x78\x2d\xf0\x97\xd7\x14\x00\x86\xc1\x02\x05\x40\xc0\xe4\x8c\xc6\xfb\x0b\xd1\xd4\x8c\x42\x14\x10\xfe\x80\xbf\xbf\x90\x0e\x98\xe5\x0b\x67\x69\xd5\x77\x55\x3d\x2d\x69\xb5\x38\x2b\xdf\xf7\x10\x37\x7d\x21\x8f\xa1\x24\x15\xc4\x1f\x27\x95\x05\x88\xd3\x04\x5c\x02\x17\x2e\x48\xc0\xdc\x9a\x23\x2d\xd3\x18\x5a\x92\x8c\xad\x8f\xff\x72\x6e\x45\x6a\xc3\xee\x4b\xdc\xe7\x0a\xfd\xf2\xc9\x49\x83\x71\x7d\xde\xd9\xd7\x63\xb4\xbc\x9b\xa0\xd6\xf3\x17\x61\xb9\xf0\x8f\x82\x97\x45\x49\x81\xe0\x8b\x2b\xef\xbd\xda\xfa\x2c\xa9\xc9\x8f\x9e\xfd\x22\x41\x95\x6f\x20\x08\xee\x06\x7a\x1a\xd1\x4e\x8c\x22\x26\x10\x5f\xe4\x2f\xee\xf3\xc5\xd2\x91\xa6\xee\xe6\x9e\x8c\xaf\xcd\xc0\x98\x69\x7b\x2f\x49\x51\x16\x8b\xd9\x4c\xd1\x6d\xed\x4d\x99\x9e\x08\xdd\x9e\x89\xd0\x29\x6d\x6a\x92\x76\xa2\xcf\x67\x4e\x26\xcd\x5a\x2d\x6d\x76\xd8\x0d\xcc\x60\xc1\x60\xa0\xcd\xbd\xe4\x60\xa1\xb7\x97\x36\x8f\x86\x4e\x71\xf4\x68\xda\x9c\x6b\x1d\x2c\xe4\x72\xb4\xb9\x1b\x5a\x7a\x77\x37\x6d\x8e\xa5\x07\x0b\xb1\x98\xb9\x3d\x43\x3b\xb3\xe3\x82\x6e\xcb\x38\xbb\xd9\x3e\xa3\x60\x96\xef\xe6\x0a\xa5\x93\x4a\xf3\xe4\x13\xff\x4b\xe5\x0d\x64\x19\xb7\xb5\x4a\x3b\x8a\x42\x61\x85\xd8\x46\xf8\x1d\x48\xa6\xa0\xb4\x4d\x00\x95\xd9\x73\xe8\x9b\x4d\x35\x7d\x7f\x59\xe8\x43\x51\x17\x3e\x98\xa7\x45\xed\x08\x1a\xa0\x45\x70\xb9\x73\xa8\x2c\xc3\xb8\xdc\xc2\x56\x44\xfe\x7b\xff\xe6\x85\xfc\xe7\x8b\x9a\xc7\x1a\xd6\xf9\x6e\x3a\xbf\xd9\xc5\x56\xb7\x00\xd6\xa4\x72\x9d\xc6\xb5\xa1\x4b\x57\x6a\xfb\xf8\xbf\x8e\x5f\x7d\xb0\x1f\x46\x8f\xd7\xcd\xbb\xda\xc7\xfd\x79\x9d\xcd\x46\x1d\xf5\x6d\x7c\xd7\x75\xe9\xe0\xa5\x60\x77\xd0\xc4\xfb\xc1\x7f\xc8\x91\xdd\xd7\xdf\xce\xfc\xf5\x8a\x8c\xe2\xd6\x6a\x70\xfc\x4b\xe4\xb0\xee\x07\x2e\xa7\xe0\x32\x2e\x35\x44\xf8\x15\xd4\xfa\x7b\x36\xc6\x03\xba\x53\xd0\x45\xd6\xaf\xcd\x91\xf3\x5b\xd7\x5c\x26\xf4\x26\xbb\x93\x20\x98\x09\x70\x2d\xd1\xb9\x4d\x29\x7f\x5a\xa4\x21\xd8\xd8\x0c\xda\x08\xce\xcc\xda\x5c\x69\x9a\x62\xec\x76\x9b\x8d\x61\x1b\x89\xb6\x20\x4b\x04\xa9\x84\x21\x91\x33\x74\xb9\x5d\x06\x03\x6b\x33\x6b\x06\x0b\x66\x0e\xfe\x82\xa0\x69\x7a\xb0\x90\x4e\xdb\xe2\x71\xd6\xd6\x0c\x06\x0b\xcd\xcd\xac\x2d\xd2\x30\x58\x80\xde\xdc\x46\xb0\x4e\x5f\x76\xa0\xe0\xb3\xd8\x5c\x33\x0a\x36\x73\xc5\x8b\x64\x95\x7a\x2f\xab\x7d\xb5\x21\x64\xab\x3e\x72\xa3\x5c\x1c\x39\x86\x43\x17\x0f\x53\x92\x29\xd8\x46\x80\x9c\xb2\x2b\x33\xee\x69\x8f\xed\x05\x40\x7b\x01\x21\xe0\xce\x89\x0b\xf1\xe9\xa4\x65\x07\x4e\x39\x99\xff\x7c\xb1\x31\x93\x31\xae\xcb\xbe\xc7\xc6\x2c\x2e\x60\xb0\x33\xd4\xd4\x67\x2f\xb8\xeb\x1e\x43\x92\x4b\xb7\x19\xd7\x87\xd6\x2f\xb2\x8e\x3e\xf6\xe2\x49\xfb\xd6\x99\x7c\x77\x2d\x7c\x14\x9c\xeb\xc8\xba\xf9\x2c\x38\x02\x86\x8d\x00\xbe\x9d\xfd\x77\x69\xb7\xf8\x96\x9f\xb6\xf9\x7a\xf7\xc2\x5f\x67\xf3\xb7\x5f\xcd\xef\x20\xcf\xf3\xe5\xec\x13\xd6\x37\x5c\x7e\x3b\x96\xaf\x86\x9f\x43\x6f\x85\x71\x40\x0b\xb4\x95\x87\xf2\x27\xd7\x87\xd2\xc1\xce\x16\xa3\xc5\xcf\x04\x9a\x9a\xd2\x69\x17\x1b\x08\x42\xcf\x1c\xcc\xc7\x62\xbd\x44\x0b\xfa\xee\x69\xda\xe9\xd4\xc5\x62\xba\x54\x2a\xa8\xab\x0f\x0f\x16\xea\xeb\x83\x3a\x9f\xdf\xe6\x87\xce\x04\xb9\x62\x4b\x1a\xba\xe2\xb4\x19\x3b\x67\x57\xd0\x32\x50\x08\xda\xe0\xaf\x50\x7f\x21\x88\x3f\x12\xa4\x72\xd0\xb2\xa2\xab\x7d\x8a\xb2\x3a\x22\xf6\xb8\x56\x6f\x7f\x8a\xc2\x08\xdc\x00\x59\xca\x25\x7a\xe5\x58\x8a\x8b\xe6\x62\xb2\xb3\xe9\x05\x48\xc4\x6e\xd5\xe6\x07\xbe\x99\xf4\xb3\xf3\xe5\xfd\x8f\xeb\x31\xc8\xae\xc7\x6b\xe6\xbf\x4c\x70\xc8\xf5\x44\x86\x17\xc6\xba\x9e\x76\xd8\x81\xdd\xa8\x3b\x24\x6c\x7c\x4b\x56\xf7\x4d\xa3\x6e\x5d\x72\xd2\x2f\x1f\x7e\x0d\xef\x7c\x3d\xfc\x01\x80\x9d\x10\x39\xb8\xa7\xa9\x6f\xd5\x82\x61\x24\x75\xfb\x39\x9b\xf4\x67\xb7\xb1\xc2\xbe\x77\x05\xf0\x9d\xbd\x6c\xb9\xd0\xe7\xe0\x5a\xe8\xa7\xd7\xe2\x38\x0b\x46\x12\x41\x7b\xc4\x16\x63\x2d\x94\x35\x1a\x8d\x58\x23\x36\xbd\xad\xc1\xd3\x90\xf6\x34\xc6\x63\x3a\x5d\xc4\xe3\x89\x04\x02\xb6\x48\xd0\x3e\x58\x08\x3a\xe0\x2f\x98\xe1\x40\x25\x35\x5b\x38\xe8\xb0\x39\x2e\x62\x73\xa6\x88\x81\x42\x8a\x84\xbf\x2c\x91\xd8\x40\x21\x22\x69\xaa\xfc\x3c\xa2\xe2\x36\xaa\xbc\xb4\xa4\xa2\xdd\xdd\xd5\x91\x84\xd0\xa3\xd9\x2d\xc9\x4f\xe9\xac\x6d\x50\x45\x45\x0d\x75\x53\x53\xc7\x65\xd6\xdd\x99\xe2\x7c\x92\xb4\x62\x79\xfe\x8b\x59\xac\x2c\xad\xe1\x7e\x1a\x18\x9c\x5a\x7a\xd2\x4d\xf3\x5b\x86\x51\xb3\xcd\x3b\x9e\x89\x50\x58\x3e\x14\x5f\x02\xcf\x00\x2c\x22\x0a\x34\x6f\x8b\x6c\xed\xb9\x7a\xb9\xa9\x22\x97\x73\xf0\xdd\xe7\xcb\xf2\xa3\x59\x0b\x63\x0d\xda\x6d\x4c\x28\x64\x85\x42\x89\x79\x3c\xf1\x58\x82\x20\xa2\x3a\x5d\xd4\xe3\x89\x42\xa9\x44\x2b\x52\x89\x42\xa9\x44\x25\xa9\x44\x6d\xce\x28\x94\x48\xd4\xa2\x78\x25\x72\x5c\x31\xc8\xbe\x54\x94\x43\x25\xc3\x3a\x81\x18\x72\xf8\xc0\x8f\x1a\x9d\x9d\xb9\xea\xd2\x80\xd3\x2f\x09\x20\xde\xcb\x7f\x31\xbb\xa2\x2e\x6c\xc7\x7f\xbe\x38\x67\x26\x35\xcd\x7d\xd5\xe6\xe5\xb5\x33\x0f\x00\xee\xcf\x28\xe9\x23\x38\x18\x57\xce\xa7\xa7\x40\x4f\xb6\x2a\xdf\x03\xf3\x21\xd6\x48\xd4\x07\xd8\x40\x1d\x41\xb7\xbb\xdb\xa1\xd5\xc7\x62\x61\x8e\xa3\xc2\x3e\xf7\x40\xa1\xcd\xe7\xb3\x0d\x16\x7c\x3e\x2a\xdc\xdc\x81\xfc\x15\x15\x0e\x27\x67\x14\xc2\x16\x4a\xa7\xbe\xbe\xae\xde\x37\x14\x13\xc6\x95\x4e\xf5\x61\x81\x43\xf8\xec\xb9\x54\x27\x48\x25\x53\x75\xe2\x6e\x91\x94\xce\xb2\xd0\xbe\x8c\xde\xac\xb9\x5d\x58\x1a\x2c\xe7\xa2\xbe\xe4\xcb\xff\x7e\xf5\xcb\x86\x23\xce\xf3\xce\x39\x7b\x65\xff\xad\x0f\xcd\x89\x65\x42\xd6\x2b\x0c\x03\xe3\x2d\x47\xfe\xfa\xc6\xab\xbe\x23\xd6\x45\xb3\xdf\x68\xe8\xbf\xe6\x9a\x69\x91\x1e\xe3\x46\xc7\x2a\x3b\x98\xbe\xbd\x78\xd3\x1d\xf1\x29\x63\xc6\x8f\xc9\xe6\xc2\x89\x5e\x67\x63\xe7\xd2\x73\xfd\xcd\xc3\x1f\x78\xfc\xfa\x2d\xc1\x71\xa3\x2e\x8e\x66\xa2\xe1\x70\x7b\x67\xf7\x5d\x33\x70\xcf\xaa\xe7\xcb\xdf\x92\xdf\x32\xc3\x88\x66\xe2\xaa\xfc\x58\x77\x2a\xe5\xa0\x28\x5b\xa4\x89\xf6\xe8\x3d\xad\xfa\x96\xa6\x26\xc2\x69\x0f\x87\xed\x70\x27\xb5\x5b\xa0\x2b\xb7\x58\xec\x7e\x3f\x61\x8f\x27\x02\x89\xc1\x42\x20\x60\xd7\xb3\x2c\x61\xf7\xd9\xec\xb6\xfe\x82\xdb\x6e\x26\x1a\x2b\x0f\x48\x2b\x41\x75\xd6\x5a\xa5\x15\xb2\x8c\x2c\x52\x3d\x53\x59\xd1\xc4\xcf\xbc\x7a\x81\xec\x47\x72\x95\xda\xa6\xac\x20\x62\xaa\xc2\xb1\xe0\xe2\xf5\xd7\x5a\x82\x40\xd2\x03\x4b\xd3\xed\x89\x6d\xd7\xed\x6c\x7d\x2d\xf6\x46\xde\x2d\xa9\x4a\xc4\xd9\x52\x1f\x99\x1a\x99\x61\xb9\x70\xc5\x84\x93\xb6\x08\xee\xe2\xcf\x2f\xf2\xfc\x8b\xfc\xb3\xa4\xa0\x2a\x2b\x22\xcd\x19\xe3\x73\x1e\xb9\xc7\x0d\x0d\xe8\xe1\x44\x1d\xb1\x22\x3f\x42\x63\x89\xfa\x68\xc2\x6c\xb3\xc5\x23\x04\x11\x13\x5f\x59\x98\x5c\x06\x97\x26\x4c\x06\x69\xda\x6b\x88\x07\x41\xda\x00\xcc\x86\xb0\x81\x34\x50\xa8\x43\x29\x7a\x7f\x11\xa9\x3c\x0d\x56\xbe\xe6\x17\xce\x3a\xda\xd1\xcf\xea\x2f\x48\xb5\xb5\xc6\x72\xc2\xb7\x03\xd0\x9c\xa1\x2a\xa2\x1b\x4c\x40\x74\xac\xb8\x37\x70\x94\x8b\x25\x41\xc3\xf0\x14\x9a\xaa\x67\xd4\xa9\x13\xc7\x5c\xf3\x05\x1f\xa9\xa7\x1a\x52\xfc\x6f\x47\x25\xd0\x54\x03\x17\x9f\xde\xbf\xf1\x7d\x32\x57\xff\x0a\xe8\xb4\x34\xf5\x2d\x5f\xd2\x95\xfc\xf6\xf5\x57\xf9\x7d\xd6\xe1\x1d\xb7\x5d\x98\xfa\xf4\x0d\xb4\xd7\xbc\x06\xf7\x9a\x5b\xe1\x5e\x1e\x83\x39\xe7\xd2\x7c\x8e\xa6\x9a\x6c\x94\x2d\x1b\x8a\x7b\x75\x41\x1d\xaa\xa2\x87\xda\xbd\x3e\xbd\xce\xdc\x3c\x50\xd0\xf9\x42\x94\x8b\xb6\x68\x0d\x13\xe1\xf4\xcd\x2e\xc2\x95\xea\x2f\xb8\xfc\x04\x3b\x03\xe6\x51\x2a\xe5\x87\xa9\x24\x1c\x3f\x9e\x8f\x30\xa3\xac\x32\x24\x12\xeb\x65\x6e\x06\x9f\x12\x42\x6f\x46\x2a\xb7\x0e\xf4\x3a\xae\x17\xd8\xbb\xe2\x14\x2e\xba\x93\xc2\x8b\x39\xf2\x8f\xaf\xbc\xe7\xe5\x0f\xfa\xb7\xce\x5b\xd9\xe7\x23\x7b\x17\x5e\x34\xed\xde\x9f\x6f\xf8\xf8\x89\xd5\x8f\xfb\x49\x36\xc1\xf0\xff\xb1\x87\x1e\x6e\x01\xa6\xad\x4b\x4f\x99\xba\x78\x5c\xe6\xa9\xc2\xe6\x7e\x7a\xda\xf5\xb7\x86\x36\x0c\x3c\xf3\x6c\x61\x7a\xe3\xfe\x87\x5e\xe5\x6f\xde\x71\xde\xa9\xc1\xbb\x34\xb3\x6e\xa5\xa6\xfc\xf5\xb5\x23\x8f\x2d\xbd\x28\x7f\xf3\x5f\x27\xbd\x72\xf5\x17\x42\x3d\x77\x18\x78\x9f\x5a\x4c\xef\x26\xf4\x44\x43\xde\x59\xb9\xcf\xcb\x91\xc8\x9f\xb1\x34\xa1\x65\x51\x21\xa1\x5d\xfe\x34\x7c\xcd\x5d\x5e\x7f\x0f\xff\x3f\x3d\xcf\xdf\x54\xca\x81\xa6\xdc\xcf\x6f\x06\xef\x83\x2c\xff\x06\xf9\x67\xfe\x20\xf0\x1f\x0b\x43\x19\x3f\x0e\x65\x3c\x13\xea\x8f\x17\xdf\x62\xaf\x0f\x5a\x0c\x24\x4b\x5a\x28\x37\xa3\xd1\xa4\x62\x6e\x77\x92\x80\x9b\x36\x74\xc1\x0e\xce\xe1\x9b\x51\x70\xf8\xb5\x2c\xc7\x0e\x14\x38\x73\xd5\x57\x31\xb2\xe9\xda\x0f\x8c\x01\x6c\x18\xf8\xa1\x0e\xea\x76\xeb\x12\x3f\x76\xda\xd9\x41\xa0\xeb\x87\x96\x98\x78\xfc\xfd\x4e\xcb\xf8\x7f\x1d\xdb\x9f\xa2\xae\x4e\xf2\xef\x36\x75\xfe\xf5\x3e\xfe\xb3\x67\xde\xe7\x8f\x82\xd4\xeb\xf7\xec\x3a\x32\xeb\xd6\xc1\x4b\xc8\x09\xa6\x96\xf6\x86\x5b\x5e\xff\xf5\x73\xfe\x48\x9d\x77\x05\xff\xfa\x63\xfc\x37\x77\x7e\xf3\xf2\x77\x20\x7b\xf4\x83\xf7\x9f\x05\xcc\xe9\x4f\xaf\x5c\x7f\xab\x60\x0b\xeb\xca\xaf\xb3\xff\x60\xbe\x27\x46\x10\x8f\xe7\x4f\x4e\xd5\xd7\xa7\x29\xda\xe3\x75\xfb\x02\xad\x74\x9b\xcb\xe5\x74\xb6\x75\xb7\xb3\xe6\x4e\x43\x27\x9b\x8e\xb1\x3a\x4b\xbb\x37\xc6\x8e\xa4\xe9\x9e\x6c\x56\x6f\xb7\xeb\x49\xb2\x5d\xef\x71\xba\x8d\x46\xbd\x33\x18\x08\xb4\xeb\x9d\xa0\x9e\x76\x66\x6c\x3a\xbd\xae\xbf\x60\x8e\xe8\x2d\xed\xdd\xcb\x0a\xed\x4e\x22\xd7\xaf\xfa\x7a\x56\x36\x2b\x26\xe5\xd2\x29\x0d\xfa\x61\x79\x59\xbc\x17\x32\x44\xda\x88\x8b\xfe\x6a\x37\xcb\xa0\x4e\xda\x39\xf5\xa9\x08\x5c\x40\x2e\x87\xea\x9f\x59\xf9\x4e\x83\xea\x23\x1d\x80\x13\x4f\x4d\xce\xbc\x69\xdc\xd9\x4f\x7c\x61\x39\x53\xf6\x23\xe3\xc1\x5d\x67\x00\x4f\xf8\x57\x4f\xf2\x4b\x74\x51\x21\xee\xe3\x34\x57\xf1\x7f\x45\x4f\xe9\x9e\x70\xaf\xe6\x3f\xbf\x91\x5f\x46\xcd\xc1\xfe\x65\xda\xf9\x87\xed\x13\x4e\x22\x4d\xd8\xb7\xdc\x09\x9e\x22\x0d\x3f\x79\x8d\x9f\x39\x7c\x33\x8a\xfe\xf0\x03\x3c\x72\x26\x8c\xfa\xb6\xad\x39\xb6\x8d\xfc\x88\x3f\x29\x71\x0a\x72\x39\x00\xdd\xd2\x27\x47\xe2\xbe\x03\x1d\x79\x2f\xcc\xe5\x35\x5a\xbd\x96\x31\x30\x46\x4e\x4f\xe8\x07\x0a\x34\x41\x68\x49\xd4\x6c\xb8\xb7\x57\xf9\xc0\x46\xda\x42\x85\xa7\x0d\xf8\xdb\x88\x51\x7b\xac\x75\xcd\x4c\xe0\x9d\xb9\x2e\xb5\xae\xc0\x7f\x51\x58\x43\x6e\x06\x3f\xe3\xe7\xbe\xce\x77\x83\x57\x90\xde\x6b\x44\x3e\x0e\xa2\x2b\xef\xa7\x75\x40\x67\xb1\x40\x57\xcf\x38\x19\x17\xe7\x20\x1c\x98\x93\x91\xc4\x9f\x87\x57\x73\x72\x57\x73\x42\x9d\x9b\xdd\x51\x54\x0b\x85\x5e\xba\x65\xe5\x4c\xe0\x9b\xb9\x31\x75\x65\x13\xdb\xc8\xff\x8f\xce\xaa\x4f\xaf\x14\xf8\xbe\x76\xb0\xae\xf5\xa4\x11\x96\x71\xa9\x7c\xeb\x87\xb8\x7f\xc6\x3b\xfc\x1c\x26\x08\xe3\x8d\x08\xae\x78\xad\xca\x8f\x88\xb7\xb4\xe8\x58\xd6\xad\x71\x6a\xb2\x91\x4c\xc2\x42\x3b\x82\x41\xaf\x2b\x10\x70\x38\x9d\xed\x01\xb3\xd3\x6f\xb1\x26\x74\x6e\x77\x86\xb3\x1a\x09\xca\xe3\x31\x52\xc6\x68\x7f\xc1\xe8\xa2\x1a\x51\x90\x5b\xe5\x81\x60\x80\x2a\xf6\x14\x11\xaf\x4a\x67\xf1\xa1\xb2\xa0\x15\x15\x51\x89\x81\x2b\x52\x08\xe1\x88\x25\x86\xb5\x00\x6a\x89\x98\xac\xd9\xd1\x7b\x62\xb4\xb7\xd8\x51\x4f\xfc\x9c\x1c\xae\xd2\x97\xa5\xd6\x8d\xf8\xe6\x97\x28\x64\xa5\xf4\x8b\xf8\x2f\x1f\xbd\x32\x75\xa5\x2f\x8c\x03\xd4\xf3\xce\xbc\xb0\x8e\x1f\x01\x96\x7d\x74\xde\x8d\x09\xf0\x2b\x52\x8c\x52\xcf\x7a\xfd\xd0\x9f\x96\x9e\x12\x1c\xcd\x53\xd4\x69\xaf\x5f\xf5\xc0\x66\x18\x99\x1e\x0b\x5c\xb6\x29\xa4\x5d\xbe\x86\xfc\xe8\x9a\xcb\xb3\x42\x6c\x4a\x12\x0c\x8c\x47\xf6\xc2\x35\x41\xef\xde\xfb\xf3\x29\xaf\xcd\xe6\x04\x76\x73\x20\x60\xd2\x6b\xec\x9a\x48\xd8\x07\xf4\x7a\x87\xc5\x68\x00\x26\xda\x60\x60\x6c\x26\x33\xe3\x1a\x28\x30\x2e\xf5\xab\x57\xa9\x7f\x48\xb7\xdc\x3f\x44\x9c\x6d\x4c\xfc\x28\x59\x47\x0e\xb7\x12\xc1\x9f\x07\xca\x02\x69\x8a\xf4\xdd\x67\x18\xda\xf8\xff\x1e\x7c\xf9\xcf\xfa\x65\xa9\x65\x03\xc0\x3b\x00\x6e\x43\x3f\xcf\x38\x76\xee\xd2\x73\x9d\xfc\xd9\xba\x79\xe0\xbd\xdc\x27\xef\xbc\xb4\x73\xc4\x88\xd7\xc1\xdd\xfc\x12\xf4\x8b\x6f\xd8\x78\x5d\x73\xfd\x49\xa7\xe2\xbc\xe5\x2f\xe5\xaf\x19\x1f\x7e\x17\x9b\x24\xce\xc8\x77\x50\x81\x80\x36\xe1\x70\x3b\x2d\xb4\xd9\xec\x0e\x27\xe8\x54\x32\x1a\xad\x8f\x45\x62\x4e\x97\x73\xa0\xa0\xa5\x2d\x96\x84\xdf\x68\x85\x13\xb1\x5a\x8d\x11\x97\xd9\x48\xf4\xcb\x9f\x59\x53\x4d\x04\xa9\x9d\xfc\x01\x99\x4a\x4b\x14\xe1\x7e\x00\x1a\x3b\x07\x3d\x1c\x5c\x37\xf4\xc9\x38\x38\xad\x2e\xdc\xab\x17\xed\x23\x30\x9c\x42\xcf\xa5\x5c\xee\x2c\x39\x6d\xd5\x4f\xdd\xc7\xfe\x4e\x5e\x4e\x71\xf3\xdd\x8f\xf2\x47\x1f\xe0\x03\x8b\x93\x57\x4e\x78\xf4\x9b\x7a\xf0\x69\x6a\xe1\xf9\x0e\x92\xcc\x8d\x4f\x81\x4f\xeb\xbf\x59\xed\x59\xff\xe4\x75\x6b\xea\x96\xad\x06\xe4\x2d\xaf\x2f\x01\xfb\x5e\xbf\xf7\xe4\x03\xaf\x74\x5c\x3c\x7d\xf2\x45\xdd\xaf\x1c\x58\x72\x13\xaa\x43\x42\x5f\x8e\xea\x90\x0d\xc4\x30\xe2\xb4\x7c\x47\x17\x65\xe3\xbc\x2d\x49\x2a\x16\x8c\xd5\xd5\x85\xc2\x61\x23\x47\xd1\xc3\xbb\x83\x75\xc0\xe3\x4d\x79\x53\x44\x18\x6a\x6e\x7f\xc1\xee\x74\xe9\x61\x94\xa0\xf7\xe3\x68\xc8\xa2\xf0\x6d\x72\x3c\x90\xed\x05\x2d\x95\xef\x9b\x2a\xee\x37\x09\x07\x0d\xb8\x72\x28\x7c\xe2\xb4\x52\x63\x44\x9f\x09\x24\x8f\x53\x4e\x9c\xd6\x97\x73\xcd\xbf\x6d\xcd\xd4\x99\x0d\xb9\xd6\x2b\xdc\xc6\xe6\x16\x45\x71\x91\x4d\x1e\x01\xde\xd3\x6c\xa0\xb6\x8a\xf8\x53\xfe\xd5\x25\xfc\x9f\xce\xbf\x76\xa4\xf5\x1d\xc3\x25\x13\x35\x62\x3d\xd1\xfa\x1c\xc3\xf0\x8e\xfe\xea\x12\x22\x49\x0c\x87\xf6\xcb\x42\x59\x24\x88\x2c\x71\x56\xbe\x3b\x91\x36\x51\xd6\x3a\x6b\xd4\x61\xaf\x6b\x67\x59\x7f\x9d\x83\xb6\x75\xd8\x3a\xed\x89\x3a\x18\x18\x9a\x8c\x04\xfc\x5b\x57\xe7\xf4\x86\x06\x0a\x5e\xbf\x15\xe8\x9a\x71\xad\x30\xd9\x5f\x09\x9d\x71\xdf\x49\x49\x20\x55\x5f\x7d\x15\xee\x20\x55\x9e\x58\x56\x7d\x2c\x31\xab\x94\x50\xec\x07\xaa\x80\xe8\x73\x89\xff\x79\x76\x84\x7b\xde\x2d\xeb\xb1\x7c\x36\xf8\xac\x2f\x1d\xa7\xf4\x87\x3e\x98\xf8\xfd\x97\xfc\x07\xe7\x5f\x33\x0a\x89\x64\x56\x75\xd5\x0f\x94\x1f\xe4\xe7\xe0\x9a\x5f\x9c\x98\x99\xcf\x98\xc9\x3a\x00\x1c\x16\x8b\x8d\x8c\xd1\x3e\xad\x2f\xa9\x4d\x78\x42\x33\x0a\x1e\x40\xe0\x70\xb8\xce\x6e\xb6\x00\x18\x30\x3b\x39\x03\xdc\xde\xfd\x4a\x35\x10\xf7\x79\x55\xdc\x2b\x5c\x26\x52\xcf\x6c\xe8\x72\xdd\xa6\xd5\x23\xe4\xc5\x86\x93\xb9\x6d\xfb\x90\x45\xba\x63\xc3\xe0\x3c\x84\xa5\x9d\x45\xad\x57\x95\xe7\xa0\xed\xfe\x17\xae\xe5\x17\x30\x0e\xcc\x12\xa3\x89\x1b\xf3\xe3\xa2\xad\xa1\x36\x5d\x87\x17\xdd\x21\x6b\x6b\x0b\x86\x7a\x6c\xb6\x86\x10\x45\xb5\xd4\xd5\xf5\xd1\x14\x35\x26\x95\x86\x29\xaf\x5f\xa7\x8f\xb6\x0e\x14\x7c\x5e\x7d\xd4\x1b\xf5\x9a\x83\x66\x17\xdc\xb9\x5d\x16\xf3\xa8\x81\x82\xd9\x89\xc2\x42\xba\x54\xfe\xe4\x59\x1c\x2e\xc2\xb9\xb6\xab\x0a\x0d\x78\x89\xbb\xad\xea\x89\x57\x02\x1b\x75\x46\x2c\xf5\x99\x41\x37\xce\xc8\xaa\x4a\x70\xd4\x8c\x5e\x67\x0a\x22\x72\x63\x10\xe8\xe2\x84\x1b\x68\xa4\x78\x03\x6d\x07\x8c\x1d\x81\xdf\xbf\xf5\x9c\xb5\x75\x61\x72\xf8\x69\x6b\xa6\xdf\xfb\xf3\xf5\x9f\x3e\xb1\xfa\xb1\x00\xc9\xc5\x19\xa0\xe5\x1a\x57\x82\x57\xa7\x7b\x0a\x37\xac\xf1\x4e\x19\x95\xed\x1a\x66\x0e\xff\x5e\xdf\xce\xff\xf3\xa1\x4a\x30\xc9\xcf\x41\xc1\xe4\xc5\x9b\xb7\xcf\x9e\x91\xde\xff\xd0\x2b\xe0\xdc\x67\xce\x3d\x2d\x7a\x9b\x36\xfc\xf2\xb1\x3d\xfc\xda\x55\xd7\xf6\x68\xdf\xa1\x3b\x26\xdd\xd3\xf3\xcd\xcb\xf4\x1c\x65\x60\x09\xb0\xaf\xd8\x0f\x75\xc3\x4b\x0c\xe4\x9b\x28\x0b\xf4\x83\x8c\x49\xcf\x71\x1a\x8d\xdb\x64\xa6\x7d\x06\xa3\xd1\xef\x24\x06\x0a\x4e\xbf\x49\xcf\x50\xb4\xc1\xac\x05\x1a\x27\x6d\xae\x34\x31\x80\xbb\xae\xbb\x5b\x14\x8e\x22\x9c\x11\x22\x1a\xa4\x0d\x14\x47\x89\xdf\xbe\xb5\xcb\x6a\x42\x5e\x09\x35\xe0\xa4\x17\x6e\x98\xcd\x7f\x09\x22\xc0\xfb\x28\x78\x1b\x8c\xe1\x53\xfb\xef\x90\x35\xe4\xed\x4b\x66\x81\x7f\x4c\xe1\x4f\x66\x0e\x1c\xdd\x0e\xf6\xf2\x27\xf3\x11\x49\x2d\x70\x7c\xb7\x99\x9f\x43\xce\x87\x63\xb6\x12\x9d\x79\x3f\xa5\xe1\x68\x0d\x8d\xbf\x81\x6b\xb6\x19\xe1\x58\x8d\x7e\x06\xd0\x9c\x62\x88\xd2\xd2\xc9\xa1\xbd\x1b\x0d\x0c\x28\x2c\xb2\x0e\x8e\xe7\x31\x34\x14\xfe\x06\xe5\x18\x98\x03\xd8\xae\x44\xc6\x58\x56\xec\x57\x50\xff\x86\x13\x8b\xf2\x9d\x1d\xa9\x61\xb1\x64\x27\xcc\xa6\x18\x97\xc9\x64\x36\x33\xcd\x9d\x30\xc1\xeb\x19\x11\x74\x75\xfa\x3a\x93\x83\x85\x4e\x67\x53\xdb\x40\xa1\xc9\x4f\xe8\x7c\xba\x81\x42\xc4\x67\xb1\x99\x19\xb3\xf0\x5d\x36\x49\xa3\xe4\x4f\x91\x56\xbd\x24\x17\xcd\xea\xc7\x7c\x91\x8d\xab\xb6\x3d\x5c\x91\x6d\xfc\x11\x5f\x63\x5b\x70\xbb\xca\x1e\x77\xae\xb5\x51\xa8\x96\x7a\xa2\x86\x01\x7c\xaa\x62\x9c\x42\xeb\x00\x51\x7f\x76\xe2\x3a\xeb\xf4\x7c\x9a\x8a\x72\x81\x08\xed\x34\x1a\x4d\xa6\x7a\x3a\x10\x65\x9a\xd2\x49\xb8\x20\x49\xbf\xd3\xe4\xf5\x6a\xa1\x4f\xb5\x58\xcd\x26\x27\x1d\x51\xaa\x4f\xe5\x6b\xa5\x55\xaf\xe9\x19\x61\x3e\x43\x4e\x1f\x07\xc2\x15\x75\xfa\x12\x4d\x40\x8e\x6c\x1f\x51\x16\x3b\x39\xcd\xa2\xdb\x65\x2f\x0a\x97\x54\x8e\x65\xa9\x99\x72\x89\x13\x06\xb9\xbc\x5e\xf2\x9f\xc8\xcf\xbc\x23\xd6\x36\x53\x44\x17\x71\x4a\xbe\xbd\x83\x75\xe9\x2c\x3a\x96\x1a\x16\x49\x65\x02\x54\x38\x1e\x8f\xc5\xc2\x91\x48\x2e\x66\x8e\xf8\x03\x84\x87\xf2\xb4\xf6\x17\x3c\x2e\x97\xc9\x3e\x50\x30\xf9\xa9\x7a\x45\xa0\x47\xa0\x8f\x66\x0a\x9f\x2c\x95\x22\x3c\xc9\x69\xc8\x9b\xa7\x54\x95\x1c\x6a\xff\x44\x61\xde\x09\xca\x91\xfd\xbd\xca\xfd\xc1\x94\xec\x92\x23\xbd\xc3\xc7\x29\x43\xde\xcf\xbf\xb6\x58\xde\x28\x26\x70\x42\xac\x47\x7f\x75\xbc\x1a\xe4\xbd\x70\xdf\x58\x8b\xfb\x04\xcd\xca\x37\x39\x38\xbf\x97\xf5\x7a\x3c\xac\x93\x73\x46\x4d\xd1\x98\x09\x7a\xaa\x81\x42\xd8\x12\xf0\x7b\xfc\x03\x05\x8f\xd9\xc9\x0e\x16\x9c\x4e\x83\x75\x40\xfe\x3c\xba\x74\x9c\x56\xd9\x35\xe4\x4a\x62\xb7\xe2\xab\x83\xd5\x1a\x5c\x55\x3f\xbc\x37\x36\x46\xad\xaa\xbb\xb6\x7a\xad\xaa\xb2\xe1\xf6\x22\xbf\x4b\xb1\x6d\x8c\x5a\xb3\xb1\x52\x2f\x24\xdc\x70\x2d\x33\xf4\x14\xb8\x67\x4c\xcb\xa7\xeb\x53\x7e\x33\x91\x89\x3a\x1d\x8e\xa8\x96\x48\x31\x9d\x1d\x99\x7a\xa7\xdf\xcc\x58\xe3\xf1\xf4\x8c\x42\xdc\x62\xf5\xcc\x28\x58\x5d\xd5\x3b\x5f\x4d\xb7\x07\xb1\x2a\x46\x71\xd5\x2b\x56\x29\x91\x55\x6e\x79\xcb\x95\xb1\x10\xa0\xbe\xec\xf6\x79\xe7\xdf\xbc\x56\x9c\x88\x6d\xf0\x3c\x45\x7d\xec\xe5\x87\x54\x65\xb1\x9d\x3f\x01\x93\x7b\xf9\xef\x2f\x82\xae\x1b\xcd\x6a\x8e\xbb\x52\x1a\xcb\xfc\xe4\x72\x65\x4d\xac\xfe\x5e\x34\x4f\x7e\x27\x5c\xab\x76\xe8\x13\xd3\xc4\x60\xbe\x31\xe5\xf3\xd6\xd7\xeb\x74\x11\x1f\x65\xa3\x6c\x19\xb2\x89\xf2\x42\xb5\xf4\x7a\x09\xb3\x19\x46\xb5\x66\x10\x8b\xb2\x34\x41\x0f\x14\x42\xc2\xa6\x87\x52\xd7\x4a\x0a\x8f\x3e\x84\x68\x55\x1d\x4d\xa0\xef\xd4\x88\x9f\x15\x04\x39\x3b\xae\x85\x08\xb7\xd7\x39\x4a\xf8\xd0\xa5\x7c\xd9\x1a\x86\xb4\x4f\x65\xce\xb0\x36\x76\x4c\x68\x19\x99\xb2\x7e\xec\x3b\x73\xe7\x35\xa1\xb3\x02\x8d\xf1\xfe\x49\x33\x6d\x3f\x05\x9f\x4c\x8d\xdc\xb3\x69\xec\xf8\xde\x48\xa4\xb1\xc9\x54\x77\x28\x92\x7c\x89\x9f\x63\xe2\xde\x75\x26\x27\xcc\xa5\xd7\x5e\x73\xdb\x04\xad\xf6\xf7\xce\x05\x67\x1e\xfd\x98\xbf\xfc\xc1\x7b\xcd\xef\xe8\x86\xf7\x3d\xfe\xe0\xde\x9f\xe0\xf7\xbb\x70\x0d\xdf\x82\x31\xbb\x87\xc8\xe7\xa3\xc0\x44\x38\xac\x16\x8b\xc6\x61\xa2\xbd\x6e\x8f\xc7\xe7\x30\xbb\x2d\x66\x33\x31\x08\x37\x74\x16\x66\x9e\xac\x5f\x75\x12\x53\xdd\x3f\x24\xa1\xd2\x36\x94\x5d\xb8\xdc\x5d\x39\x10\x25\xdf\x51\x2b\x19\xff\xee\x4e\x10\x9d\xc0\x58\x47\x8e\x04\x3d\xa0\xb9\x58\x51\x2f\x7a\xf8\xb1\x07\x63\x5f\xdd\xbc\x8e\x3c\x55\xb0\x11\xe9\x3b\xf7\x5e\x62\x4a\x3e\xad\xd3\xc2\x34\x82\x82\x5b\xa5\x5b\xa3\xd5\x70\x70\xef\x64\x39\xce\x27\xec\x9f\x7a\x13\xda\x3f\xb5\x66\x4e\xbd\x7d\x66\x2b\xdb\xa7\x32\xa6\x16\xb6\xce\xca\x87\xee\xd5\x5b\xe7\xc9\xb5\x1f\xba\x7f\x65\xa7\x6a\xf3\x54\x7f\xe8\xfe\x1a\x79\x13\x03\xe5\x3f\xc1\xf1\x02\x9c\xbb\x4d\xc8\x27\x34\x56\x03\x69\xa5\xb4\x7a\x93\xc9\x6d\xd1\x6a\x5d\x66\x83\x11\xea\xbe\xd1\xac\xb3\x68\x61\x2a\x00\xb3\x77\x46\xf1\xe9\x49\xd1\x90\xab\x3f\x21\x8f\x36\x2a\x49\x9a\x39\x5c\xe5\xc1\x2d\x65\xc1\xab\x92\x24\x8f\xad\x49\x92\x37\x0a\x35\xbf\x63\xab\xc9\x5c\x1e\xba\x2c\x7e\x0e\x16\xe5\x2b\xe4\xcf\x5e\x7f\xf5\xd8\x7c\xfe\x57\xd0\x21\xe1\xbc\x52\x07\xc7\xf6\x09\xf4\x37\x9d\x44\x9e\xb8\x28\x3f\xc6\xd0\x11\xe8\xb2\x52\xe6\x50\xa8\xb1\xc5\x1c\x8b\x0f\xf7\x78\xe2\xe6\xc6\x0e\x86\x19\xcd\x8c\xf1\xe7\x06\x0b\x36\x73\x0c\xe8\x29\x7f\xcc\x1f\x33\xa4\x52\x91\x19\x85\x94\xc5\x39\xb2\xbf\xe0\x74\x19\xda\x07\x0b\x06\xa7\x86\x1a\x28\x68\xfc\xd5\x47\xfb\xe2\xd7\xa3\x51\x93\xcf\xf4\x10\x0f\x02\xb1\xe4\xc5\x12\x6d\xac\x0e\x66\xa0\xb8\xed\x87\x74\x13\x34\x9e\x10\xcf\xd7\xb8\x84\xbc\xfb\x4a\x15\x5d\x50\x79\x21\x48\xdb\xbb\x9a\x5a\x7a\x1a\x0a\xa3\x8f\xba\xc6\x4e\x60\xd8\x59\x0f\x5f\x78\xc3\xa3\x44\x19\x84\xf6\x38\x37\x2c\x98\x6f\xe3\xff\x8b\xfa\x7b\xfe\xca\x33\x41\x53\x9f\x4a\x47\x32\xfc\xce\x6d\x17\x5e\xd3\xdf\x37\xf3\x5a\xff\xda\x8e\x98\xe1\x1d\xeb\x91\x11\xe7\x19\xa7\x76\x27\xfc\x1b\x4f\x7d\x74\xe3\xcf\x7f\xc9\x50\x0b\xe3\x97\x8d\x9f\x18\xbe\x65\xcb\xe6\x3b\x12\x17\xf3\xf7\x67\xfc\xa1\x18\x77\x84\x9c\x42\xce\x9f\x35\xbe\xff\x32\xa1\x4f\x37\xca\x6f\x46\x42\x99\xd5\xc3\xbd\xea\x8c\xfc\xb0\xfa\x66\x23\x65\x49\x58\xac\x71\x87\x2b\x6a\x4f\x74\xb2\x6c\x22\xea\xb0\x32\xfe\x9c\x7f\x58\xc2\x3e\x58\x48\x38\x43\x5e\x68\xf6\x7e\xc2\x48\xe9\x2c\x66\x5d\x1b\x4e\x6f\x1a\xd4\xe9\x0d\xf2\xd2\x35\x1f\x1a\xad\xc8\xa8\x26\xb7\x41\xc9\x2d\xf4\xe1\x9c\x2c\x37\xa1\x0e\x7e\xe2\xfc\xc6\x14\x07\xda\xf6\x4b\xee\xc8\xd2\x2d\x5d\x58\x56\x1b\x2f\x35\xea\x77\x1c\x27\xbf\x19\x75\xc1\xe1\x63\x67\xf3\xdf\x25\x33\x8d\x50\x40\x17\x6f\xe8\xca\xf7\xd4\xde\x6b\x10\xe4\xf0\x29\xf4\x7f\xad\xc4\x28\x62\x45\xbe\xa7\x29\x10\x6a\x68\xed\x32\x51\x19\x9f\xd9\xec\xcf\x8c\x64\xd9\x4c\x43\x20\xc6\x38\x7a\x1d\xf9\x8c\x7f\xb0\x90\x71\x26\xa3\x28\x2e\xb1\xb9\x07\x0a\x36\x80\xa4\xa1\xeb\xc6\xb2\x68\xeb\x57\x9f\x92\x74\x7b\x86\xfc\xee\xaa\xb2\xbc\x59\x25\x0e\xbb\x90\xf9\x48\x5b\xdb\xff\x4d\x2c\x1d\xc1\xe7\x1f\xea\x3f\xbd\x7e\x5c\xa4\x63\x9a\xe5\xd9\xdb\x54\xd2\x79\xea\x38\xd2\x01\xce\x7b\x6f\x77\x1c\x30\xf7\xcc\x38\x3a\xfe\x07\x65\xd4\x0b\xed\x6b\x19\xd4\x95\x24\xd1\x4c\x2c\xc9\x8f\xa8\x8f\x7b\x9c\x30\xd2\xd7\x39\xc9\x60\xd0\xa9\x89\x9b\x99\xd6\x96\x66\xe8\x47\x9b\xf1\xcd\xad\xe6\x70\x33\x69\x64\x9a\x9b\x7d\xd1\x68\x7a\xb0\x10\xb5\x70\x3e\x1f\x33\xa3\xe0\x73\xd9\x8c\x50\x64\x55\x3e\x41\xbe\xa2\xa5\x8a\xe2\xc4\x4d\x5e\xba\x9f\x55\x2d\x0a\x56\x7c\x3c\xaf\xbe\x9c\x05\xce\x14\x2e\x67\xf5\x29\xe6\x6e\x9e\x7b\xe6\xbb\xdf\xde\x02\x74\x4f\xbd\xfd\x97\xea\x6b\x59\xfc\xc3\x95\x29\x8f\x0d\x7c\xf1\xe6\x6f\xc1\xb0\x47\x50\x87\x3f\xe9\x52\x16\x20\x7c\x70\xce\x41\x18\x9f\x76\x11\xb3\xf3\x19\x1a\x75\x89\x6c\x8a\x74\x78\xbd\x11\x6b\x4b\x92\xd1\xe7\xf4\xc3\xa8\x14\x95\x72\xc4\x62\x0d\x83\x85\x98\xc5\xe5\x72\xc0\xf9\x3b\x9c\x26\x2d\x0a\xe5\x94\x19\xbf\xe4\x39\x54\x26\x21\x57\x77\xdc\x66\x30\xd4\xdc\x4e\xf8\xda\xeb\xb7\x85\x3b\xc6\x5d\xd6\xaa\x98\xa5\xe1\x94\xf3\x76\x7e\xf0\xf0\x7d\x60\xe6\xb2\xcf\xdf\xb9\xee\x37\xbd\x7b\xc7\x5c\x3f\x73\xe1\x5d\x9b\x3d\x0f\xde\x34\xad\xff\xf1\xfe\x91\x77\x1e\xae\x4c\xb4\xd7\xbd\xfd\xfa\xb5\x77\x58\x48\xe7\x9a\x99\x37\xdc\xbb\x68\xd5\xac\x8b\xc6\x8e\x1c\x37\x69\x47\x74\xf2\x98\x11\x53\x84\x3d\xe9\x05\x18\x0b\xfc\x0d\xae\x73\x07\x71\x56\x7e\x58\xb8\xd1\xd3\x9e\xd0\xfa\x9b\xdb\x1b\xd9\x2e\xb3\x9d\xa6\x6d\x66\x73\x67\xb3\x3f\x10\x80\x66\x60\x27\xe3\x81\x14\x19\x20\x03\x44\x2a\x55\x37\x08\x3d\xa8\x81\xc3\xd1\x9b\x73\x86\xaa\xba\x5d\x99\x3d\x5c\xd2\x6e\xb9\xc5\xaa\xba\x0a\xc4\xd4\xa5\xd4\x52\xc8\xd9\x73\xd2\xd7\x27\x8f\xf7\x5d\x7b\x1a\xec\xdd\x7c\xba\x4b\x21\x83\x31\x47\x63\x0f\xcf\x9b\x7f\xed\x25\xd5\x1f\xb9\x3f\x67\x2d\xcf\x3b\xda\xcf\x97\x44\xd0\x32\x01\x2c\x68\x7a\x68\xc6\xc4\x19\x63\xab\x3f\x78\x6f\xdb\xb0\xf0\xde\x5d\x58\xd7\xeb\xe1\xba\x1f\xc1\x7e\xb1\x95\x58\x9c\xef\x6a\x25\x49\x93\x2d\xd8\x98\x4c\x6a\x82\x26\x0b\xe3\x6e\x73\xb7\xd7\xc3\x25\x8f\xc4\xcc\x9c\xde\x5c\x0f\xcc\x54\x7d\x7d\x4c\x1f\xcb\x40\x25\x70\xf9\x60\x88\xe4\xf3\xcb\xcd\x2d\x95\x32\x50\x36\xb7\x04\x55\xe5\xfb\xaa\xd7\x87\x5c\x8d\xe9\x57\x9e\x23\x8a\xaf\x11\x8f\xca\x1d\x2d\xdf\xfd\x96\xdc\x72\xad\x42\x0c\x99\xc2\xaf\xd6\x61\x5d\xaf\xea\x63\xf9\xc5\x9b\xdd\xc7\xa6\x55\x84\xf0\xd7\x25\x27\x0b\xba\x2e\x74\x7b\xc6\x75\x3f\x72\x13\xf4\x81\x0e\x18\x29\x8d\xcf\x27\x19\xa7\x93\x75\xeb\x08\x8e\xa6\x09\x8d\x9b\x36\x7b\xcd\x3e\x97\x73\x66\xc1\x05\x04\x13\x66\xcc\xea\x24\xb9\xc6\xe3\x0b\xa9\x32\x72\x5a\xb8\x78\xa5\x98\x8e\x1d\xba\xfc\x57\x8c\xfa\x17\x7e\x07\xbc\x3b\x6f\x57\x78\xa9\x99\x0d\xc0\xdb\xb0\x0b\x3a\x1f\x7a\xf8\xd1\xb5\xb2\x37\x62\x9b\xdf\x7c\x53\xd0\xcb\x7d\x70\x4d\xda\xf1\x9a\x2c\xc8\xb7\x11\xbe\xfa\x84\xc1\xc8\xd9\x8c\x61\x1b\xd5\xe8\x4b\x24\x1a\x0c\x06\x33\x41\x98\x3d\x1e\x97\xd9\xac\xed\x2f\x98\x2d\x2e\xb2\xbf\xe0\x72\xd5\x85\x07\x0a\x75\x41\xf8\x0b\x5f\x04\x51\xaf\x86\xe2\x74\x5e\xbd\x16\xd2\x53\x23\xbc\x59\xdb\xa4\x56\xcb\xb5\x1a\x0a\x86\xe9\x7f\xb2\x7c\x4d\x9b\x7b\x17\x6e\xf3\xba\x1c\xdc\xf6\xe1\x37\xf7\xf0\x47\x7f\x75\xeb\x79\x1e\xc5\x6a\x4c\x03\x2b\xf6\xdc\xf6\x8b\x55\x9d\x5f\x9d\xb5\xa4\x1d\x2c\xfc\xf3\xfe\x3d\xfc\xa3\x5b\xfb\x36\x2a\x74\xf1\x56\x34\xb7\x29\xd0\xe6\xee\x82\xb2\x4f\xc1\x38\xb0\x9e\x45\xdf\x7d\x6c\x30\xd4\xc3\x99\xf8\xac\xa9\xfe\x82\xd5\xaa\xf5\xf9\x42\x50\xaf\x22\xf0\x17\xd0\xb2\x30\xb8\x42\x7d\xdc\xe5\x29\x55\xdd\x16\x92\xca\x15\x50\xfc\x82\xae\x88\x03\xee\x1a\x32\x06\x87\xd6\xd4\x91\x19\x61\x9f\x6e\xc3\xc3\xd5\xc4\x3b\xc7\xa3\xe0\xfb\x67\xaa\xe0\xfb\x89\xf8\xc3\xdb\x6e\x88\xc6\x35\x34\x1a\xb2\x69\xec\x1b\x28\xe6\xa6\xa6\x57\x62\xee\x67\x77\xdd\x63\x14\xf2\xa5\xd9\x70\x1f\x1d\x01\xe3\xc3\x46\xe2\xe4\x7c\x8b\x3e\x10\x80\x99\x7b\x52\xab\xa3\x92\xba\xa4\x3d\x6d\x6f\x8a\x44\x02\xda\x46\x73\x0c\xc6\x85\x31\x97\x3e\x1c\x08\xcf\x28\x04\x9c\x2e\x98\xf8\xba\x60\xda\xe7\x92\xa7\x23\x97\x37\xb2\xea\x27\x7f\x36\xf9\x48\xa3\x72\x3d\xb7\x7a\x8f\xcc\xa1\x2d\x52\x6e\xc9\x90\xb3\x93\x84\xdc\xfd\x71\xa7\x72\x47\x74\x3f\x0a\x53\x7c\xdc\x66\xd1\xc4\x6d\x80\x41\xf9\x53\xb8\x77\x24\x79\x8a\x42\xf1\x36\xd4\x5f\x0f\x33\x7c\xd4\xab\xd1\x7b\x76\x88\xbc\x51\xd0\xc1\x9f\x40\x1d\xcc\xe1\xf9\x2d\xc8\xb7\xb3\x0e\xa3\x2e\x6a\x75\x30\x29\x83\xd9\xdc\x44\x04\x02\xa9\x54\xda\x4d\xc1\xe5\xd2\xf9\x08\x37\xa1\xd3\x11\x6e\x2a\x6e\x8a\x87\x07\x0b\x71\xbf\xc5\x68\x82\x56\x63\x52\x9d\x77\xba\x91\x4f\x6c\xb1\xe1\x12\x21\x90\x83\x24\x31\x8e\x94\x73\x41\xf4\xb5\x2a\x1c\x16\x63\x8f\x87\xd2\x44\xb5\x16\x76\xd9\x3f\x37\x5c\xb6\xe8\xdc\x4b\xb6\x3c\x79\x66\x02\xac\x3c\xf6\x21\x3e\x01\x3d\x75\xeb\xab\xfc\x57\x5f\x9d\xf3\xf8\x44\x1b\x95\xcf\xb7\xf4\x44\x0b\xa3\xaf\xb8\x98\xee\xf8\xeb\xd2\xd3\x56\x2e\x5e\xbc\xb0\x04\xc0\xeb\xbf\xe6\xbf\xb1\x6c\xdf\xf8\xbb\x7f\x76\x8e\xec\x0f\x65\xda\x0d\x8f\x59\xd7\xad\x73\x64\x40\x9b\x70\x3e\x33\x09\x7c\x48\xcd\x13\x7b\x2d\x0c\xe4\x3d\xb8\xd7\x82\x13\x26\xbd\x31\xb3\xc5\xc2\x26\xd8\x24\xe1\x36\x18\x8d\x0e\xcb\x68\x1d\x68\xc4\x5d\x16\xd0\xa3\x76\x87\xd8\x77\x41\x7e\x6e\xa6\xbc\x4f\x65\xc5\x9d\x34\xc4\x43\x65\xd5\x03\x33\x96\x8b\xe5\xf0\x03\x33\x4e\xf5\x36\x1f\x5c\x85\xdb\x2e\xcc\xb9\xef\x9c\x1d\x49\x45\xdb\x85\xc9\xa7\x74\xe1\xb6\x0b\xf4\x05\xa8\xed\xc2\x35\x3c\x7f\x35\x6a\xbb\x00\x9e\xc2\x6d\x17\xe6\x95\x66\x49\x6d\x17\xd0\x9b\x3f\xf0\x47\xaa\x1b\xce\xc1\x47\xe4\xf2\x76\x1b\x45\xd3\x56\xaf\xce\xaa\x0b\xf8\x6d\x36\x13\x05\x35\xc6\x24\xbc\xb9\xe6\x86\x7e\x7e\x28\xbc\x2c\x55\xf4\xb9\x10\x8a\x66\x82\xc1\xa0\x66\x37\xcf\xa0\x27\x88\xa9\x27\xaf\xbd\xfd\xc1\xd3\x9e\xbb\xb1\xf2\x04\x91\x3c\x7d\xf2\xc4\xd8\x86\x35\x3f\xbd\xf9\x92\x7f\x5c\xaa\x7a\x83\x08\x7d\x2b\x78\x91\x9a\x48\xff\x93\x08\x40\xef\x35\x23\x1f\xd6\xc7\xac\x7e\xc2\x4a\x07\x5d\x2e\x5a\xd7\xa0\x6b\xd4\xeb\xbd\x11\xbb\xdd\x6b\xb5\x6a\x02\x5e\x7f\xcc\xa4\x41\x8f\xad\x63\x49\xaf\xf8\x4e\x03\xdd\xe3\x14\x2e\x8d\x28\xda\x7f\x89\xad\x06\xb3\x78\xac\x50\x84\xc2\x28\x23\x62\xd1\x9c\x53\x7c\xc9\x39\x21\x84\x46\x58\xa1\x62\x4d\x7d\xc6\xd3\x9f\xbf\x10\xb8\x82\xbf\x22\xbb\x7b\xa6\x2f\x35\xad\xb9\x66\xe1\xca\x97\x7f\x7a\xf5\xcc\x53\xc1\xdf\x33\x1d\x99\xa5\x61\xdb\xe4\xfa\xbe\xe9\x64\xfd\xb0\xd1\xf9\xd1\x1b\xdf\xbb\x88\xb7\xf4\x4c\x7e\xe4\xf6\x93\x17\x0c\xac\xbe\x61\xea\x59\xc7\x7c\xc9\xb6\x78\x24\xd9\x82\xe7\x73\x1a\xd4\x91\x39\xac\x1e\xca\x37\x09\x63\x41\x68\xac\xa4\x4b\xc3\xe8\x28\x8a\x74\xc5\xbd\xa4\x85\xd5\x85\x2c\x71\x9d\xce\x52\x9f\x72\xb9\x8c\x2c\xa9\x61\x18\xd2\x4b\xf8\xed\x76\xa3\x87\x20\xd1\xbb\x99\xa8\xfc\xf0\x33\x2b\xea\x09\x3e\xf0\xb6\xc9\x6b\xa0\xa8\xb7\x5a\x15\x17\xa6\x52\x59\x97\x3b\x67\x06\x48\x7d\xe4\xaf\x04\xbb\x93\x29\x2e\x67\x97\x3e\x45\x8b\xca\x5b\x47\x0a\xa3\xf6\xb7\x67\x5e\x75\x2d\x5a\xf7\xe5\x9b\xb7\x3f\xf1\xc7\xe7\xd3\x27\x7b\x9d\xf9\x17\x5c\x8b\x4f\x39\x7f\x72\xfe\xe4\x75\x13\x99\x2b\x0a\x09\x7f\x6a\xda\xfa\xe4\x43\x1f\xfc\x87\xff\xf2\xc1\x1b\x9e\xff\xc0\x6b\x3f\xf5\xe4\xe9\x97\xf2\xbf\xb8\x67\xed\x84\x39\x3b\x36\xf6\x8c\x2d\x97\xa5\xb7\xf0\x36\x96\x59\x21\xf5\x9d\x23\xcf\x66\x09\x98\xf7\x8e\xc8\x9b\xec\x80\x05\x24\x49\x3b\x28\x83\xcb\xe0\x46\x6d\x79\x76\xc1\xa4\x17\x35\xaa\x20\x68\xda\xce\x08\x2f\x97\xb3\xf8\xee\x6d\x6f\xd5\xbb\x45\x4a\x79\xbc\x91\x14\x4f\x37\xc0\x2d\xab\x5f\x5c\xbd\xdc\xbb\xdc\xec\xd8\x70\xd1\x88\x66\x4f\xa3\xbb\xb9\x41\xab\xbb\xc5\x4b\x2f\x3c\xb6\x89\xbc\xf0\xea\xfe\x15\xa7\x1a\x36\x70\xcd\x99\x9e\xab\x91\xff\xf9\x15\xf1\x5b\xf0\x15\xfd\x19\x1c\x07\x4c\x85\x85\x71\x38\x68\x03\xed\x36\xb8\xcc\x14\xdc\xaf\x8d\x0e\x87\x0e\xe0\x01\xbc\xd4\xdd\xd2\x8e\xb5\x43\x5d\x3b\x13\xba\x5b\xa1\x93\xf3\x4a\xe5\x05\x5d\x19\xd8\x3b\xf1\xc5\x89\x2b\xdc\x2b\xba\xec\xeb\x97\x77\x8c\x71\xfb\x02\x9d\x4d\x9a\xf6\x5b\xdd\xd4\x00\xb8\x9d\x5f\x71\x35\xff\xd6\x59\x8b\xf5\x97\xc1\x31\x80\x20\x7a\x77\xd4\x48\xbc\x48\x9d\x25\xbe\xc3\x9f\x9d\xf7\x7a\x62\x3a\x5d\xa3\xd5\x1a\xa4\x29\xaa\x35\x18\xfa\x7f\xf7\x06\x1f\x1b\x1d\x36\x3c\xdc\xb9\xf0\xff\xfa\x02\x7f\xd6\xff\xef\x2f\xf0\xd1\x9a\x5f\x05\xbe\xa2\xae\x82\x6b\xee\x21\x7a\xf2\x1e\xa3\xc5\x43\x58\xb4\x5a\x82\xa4\xbc\x2e\xb7\xdb\x47\x52\x94\x81\xb5\xd9\x5c\x86\xdd\xe8\x19\x18\x7e\x8e\x9f\x55\xcd\xa7\x52\x33\x02\xb6\xca\x86\xa4\x7a\xf6\x48\xd2\x7d\x26\xe1\x39\xa8\x66\xfe\x8b\x03\xe2\xd3\xee\x7d\xe0\x2b\x70\xea\xa8\xa9\x63\x97\x9c\x66\x1b\x03\xbe\xe6\x17\xcc\x8a\xce\xbb\x60\x16\x78\xe2\xc8\x57\x82\x1f\xc9\xc0\x3f\x7e\x0d\xbf\xe3\x37\x13\x83\xf9\x10\xcd\x51\x1a\x1d\xd0\x92\x0c\xa5\xd7\x68\xe1\x98\xb4\x16\x83\xc9\x64\xe5\xf4\x7a\x7c\x83\xe2\x97\x70\x01\xb4\xf8\x35\xba\x11\x8e\x52\x68\x84\x23\xb4\x8d\x51\x77\x2b\xad\x98\x98\x3d\x6b\x17\xb4\x03\xea\x29\x7a\x4a\x3f\xae\x30\x6c\x4f\xf7\x12\xef\x99\xbd\x2f\xf6\x16\xf6\x05\xf6\x04\xa8\x5f\x80\x46\xfe\xbd\xcb\xf8\x1d\x60\x06\x99\xdd\x2c\xf6\xc7\xeb\x81\x63\xba\x1e\xf7\x2a\x50\xf7\xf1\x4b\x0d\xdd\xc7\xaf\x07\x35\x27\xf8\x8a\x3c\x72\x8c\xf9\xff\x88\x8b\x64\xf1\x6b\x88\xab\x27\xc6\xe6\xfd\x48\x12\x40\x47\x6a\xb1\x24\xb4\x06\x28\x0b\xa3\x24\x86\xdd\xa2\x18\xaa\xa7\x7f\x82\xb9\x2b\xe7\xad\x98\x33\xee\x2b\x5a\x7e\x81\xd8\x43\xde\x05\xd7\xc0\x02\x23\xe5\x30\x31\x29\x6f\xf5\x6a\x8c\xe8\xfe\x8a\x3d\x48\x59\xed\x30\x24\x89\xe0\x37\x6b\x56\xc2\x86\x5a\xd7\xb0\xac\xd1\x87\x5a\x96\x39\xe1\x84\x1a\xa4\x17\xcd\xbd\x62\xd3\x1a\xd9\xcd\x61\x45\xc9\x61\x15\x19\x01\x84\x61\x98\x48\xb4\x00\x00\xdb\x00\xf6\x6e\x77\x2c\x58\xff\xd3\x5b\xc6\x5f\xb8\xe7\x82\x65\xfe\x65\xde\xfe\x0d\x6f\xfb\xf7\xf8\xf9\x50\x67\x9b\x41\x33\x7d\x64\x57\x6c\xcf\x92\x99\x97\x5e\x49\x2e\x3b\xb6\xe5\xd6\x75\x17\x8e\xa0\x77\x6c\xde\x7c\xe4\x0f\xf9\x11\x0d\x9d\x0d\xfe\xb4\xb0\x46\x75\xc4\x1e\x50\x82\x63\xc6\xfd\x12\xb5\x94\x91\xb2\xb0\x1c\x67\x35\xa2\xfe\x92\x31\x28\x40\x71\x6c\x52\x34\x2c\xbc\x7c\xcd\x09\x51\x6e\x96\x12\x1f\x57\xff\xa1\xb0\x40\xfb\xdb\x3d\xbf\x9b\x9c\xac\xf3\xf7\xec\x99\x36\x27\x9e\xa1\xa7\x1e\xd9\x6a\x18\xa5\xb9\xdd\x20\xc4\x46\x1f\x43\x1e\xbf\xc1\x72\xc9\xe5\x4d\xe8\x5c\x8d\xd1\xd0\xac\x89\xb5\x99\x50\xff\xd7\x18\xfe\x16\x60\xe3\x2e\x33\x61\xc0\x4e\x20\x5b\x11\x42\xa5\x17\x82\x1d\x97\xf0\xd1\xf4\x45\xef\x34\x7a\xae\xc5\xb0\xea\xa5\x3d\x4f\x2d\xac\x77\xae\x5a\x9f\x1e\x1d\x88\x80\x39\x73\x47\xd0\xae\xa3\x67\xbd\xb9\x72\x99\xe1\x76\x8d\x30\xb7\x89\x50\x23\x66\x40\x9f\x28\xf4\x4c\xa4\x69\x00\x18\x96\xc3\x2f\x7a\x69\xe9\x45\xaf\xf2\x05\x3e\xba\xce\x16\x25\xbb\x78\xdb\xcd\x7b\x2e\x00\x2d\x10\xf7\xfb\x63\x5b\x04\x3a\xc4\x8b\xf4\x1b\xd0\xaf\x65\x61\xec\xea\x35\x99\x1b\x7c\x3e\x46\xa3\xb1\xd9\xcd\x74\x47\x5b\x24\xd2\x29\x74\xaa\x18\xb2\x51\xc5\xae\xc6\xa6\xa4\x3c\x29\xab\xfc\x4b\xea\x58\x91\x55\x1d\x77\xff\x60\xc3\x0a\x8e\xaa\x74\x3c\xc8\x09\xad\x2b\x9e\x91\x5e\x41\xf7\x2c\xb0\xd7\xb6\xae\x30\x2d\xf2\x5c\xb9\xc2\x33\xd7\x12\x88\xd7\xcd\xb1\x2c\x94\x9b\x58\xec\xe9\x8d\x9e\xb4\xec\x34\xdc\xc4\x62\xa3\xf0\x1a\x7a\xc9\x69\xf5\x53\x8f\x1d\xdb\x78\xbe\x86\xbe\x43\x3b\x17\xfc\xbb\x37\x46\x9d\x84\xfb\x17\xc0\x79\x7f\x04\xed\xa8\x9e\x98\x96\xf7\xc7\x92\xc9\x30\x9c\xb6\xd7\x66\xf5\x86\x69\x73\x83\xb9\xd1\xeb\xad\xb3\xd9\xed\x01\x13\x5d\x87\xec\xc8\x0a\x1a\x9e\xd1\x11\xae\x80\x18\x9a\xb4\x4b\x3d\x90\xd5\x97\xd4\xa4\x9b\x1d\x55\xef\xbc\xa1\x61\xa9\x5e\x79\xe7\xa4\x57\xde\xab\x54\xaf\xbc\xf7\xed\x9d\x41\x65\xcf\x98\x00\xa7\x37\x7c\xe5\x78\x38\xbd\x39\x43\xbc\xf1\x3e\xf2\x3e\xd8\x3e\xd0\x3b\x73\x60\x01\x9c\x54\x6a\x2a\x78\x43\x7e\xe2\x0d\xf5\xf0\x3a\xb8\x3f\x2d\xc0\x3d\xdf\x46\xe7\xcd\x41\xbf\x39\x4e\x50\x54\xdc\x5c\x1f\x6f\x08\x05\x09\xd4\x9c\x83\x21\xa2\x70\x4f\x0a\xc2\x3d\x3e\xb5\xcb\x62\x53\xa8\xa3\xd4\x9c\x43\x2a\x40\x09\x9d\x30\xc5\x95\x52\x2e\xca\x28\xaa\x53\xd5\xa2\x83\x1c\x3e\x60\x5b\x32\xee\x02\xcb\xc9\xde\x2b\x97\xbb\x66\xbb\xe0\x42\xcc\xb5\xac\xa5\xb5\x1a\xe6\x39\x56\x27\x78\x78\xf3\x49\xd0\x59\x3d\x28\x34\xe8\x08\x6d\x3c\x9f\x63\xe0\x0a\x90\xb7\x7b\x3a\x5b\xea\x98\xdc\x54\xd4\xab\xa3\x75\x2c\xdf\x01\xd7\x22\x0f\xc7\xbe\x08\x8e\xbd\x81\x98\x98\x77\x12\x2e\x5f\x82\x33\x98\x5d\x09\x26\xd4\x18\x4a\x87\x42\x75\x9c\xc5\xcc\xe1\xb0\x9b\x24\xec\x70\x0a\x66\x42\x0f\x97\x24\x40\xd4\xe1\x19\x48\x13\xb0\x55\x37\x88\x95\x34\x0d\x46\xd6\x59\xc5\x19\x28\x27\xda\xb5\xbc\x18\x5d\xe4\x65\x68\x12\x50\xc1\xb4\xd6\xe7\xf4\x8c\x30\x70\xdd\xd2\x49\x75\xf5\x01\xe7\x02\xc7\xdc\x05\xda\x79\x56\x9a\x14\x3b\x8c\x34\x9e\xcf\xe9\xe6\x85\xd0\xc0\x23\x3d\xc7\x7e\x67\x18\xa5\xbd\x83\xd6\x20\x97\x00\x3e\x98\x4c\x88\xfd\x63\xa9\x5b\xa1\x4d\x6a\x89\x6c\xde\x08\x6d\x52\x07\x9d\xb2\x9e\x43\x2e\x01\x45\x05\x00\x77\x98\x21\x09\x06\x87\x4a\x52\x0b\xac\x8a\xab\x47\x9d\x47\xa1\x1f\x40\x1e\x9f\x7c\xfa\x5f\x8b\x1e\xbf\xf9\xd7\x9f\x2e\x7a\x1c\x5a\xaa\xf9\xd8\x3f\xc8\xef\x79\x00\xca\xb8\xbf\xf3\x39\x30\xc6\x5f\x8a\x7b\x9a\xd8\x84\x1e\x23\x1e\xab\x95\x35\xdb\xed\x2c\xe1\xb3\x78\x3c\x94\x13\x37\x37\x31\xc8\xcd\x4d\xc4\xc6\xd7\x52\x33\x02\x75\x8f\x13\x7c\x43\x0c\x46\xf6\x58\x56\x51\x6a\xa9\xd4\xe5\x84\x9f\x3f\x73\x9e\x97\x7f\x02\x2c\xbf\x69\xd6\x29\x1e\x30\x47\xd1\xeb\x84\x37\x9c\xba\xd8\xf8\x1c\x58\xf4\xf0\xe2\x53\xe0\x58\xd6\x10\x7b\xe8\x4e\xe8\xfb\xac\x30\x17\x0a\xa1\x3e\x37\xc0\x12\xb2\x79\xdc\x1c\x9c\xb7\x95\xd0\x68\x69\x42\x4b\x85\x9d\x46\x63\x44\x23\xc4\x0b\x0d\x45\xb7\xc7\xa3\xe3\x50\x63\x00\x5b\x28\x64\x01\x95\x17\xd9\x8a\xfb\x7c\xe2\x0a\x0a\x55\x73\xfc\x0c\xdb\x86\xb6\x28\x94\x08\x92\x31\x0a\x37\xdf\x4c\x09\x5b\x83\x1b\xac\xed\xda\xb2\xf5\xdb\x3f\xb6\xef\x6e\xbf\xf3\x81\xff\xbe\xd3\xd9\x7f\xee\xa5\x37\xec\x5e\xbd\x7a\x62\xdf\x1e\x10\x64\xef\xbf\xee\x0b\x40\x02\x23\x7f\x58\x73\xe7\xb5\x5f\xf2\xdf\xf1\x7f\x01\x0f\xbd\xf8\xf0\x3d\xfa\x67\x7e\x36\x63\x0e\x83\xd7\xca\x48\xec\xa1\x0c\xf4\x3f\x88\x0e\x62\x7c\x1e\x66\x39\x9c\x35\x40\xb4\xc4\xac\x31\x3d\x41\xc3\x0d\xa4\x8b\x71\x37\x66\x92\x28\x21\x71\xfb\x50\xff\x82\x5d\x7a\xad\x49\xb6\x18\xb1\x33\x4f\x8d\xe1\xe3\xc4\x43\xea\xc9\x21\x46\x3e\x9d\x59\x9c\xd3\xa2\x2f\xd2\xd4\x9c\x6f\xba\xdc\x21\x40\xfe\xe9\x99\x07\xcf\x9a\x68\x9d\x14\x4f\x06\xc6\x77\xcc\x5d\xc0\xb4\x83\xc7\x4d\x93\xa7\xdd\xe9\x6a\x9b\x71\xf9\x85\x8f\x3d\x70\xdd\x8d\x96\x27\x0c\x7d\xdd\x9b\x7a\x56\xae\x5d\x4a\xbe\x77\xe9\xfa\xf8\x22\xdd\x48\xed\x1d\x86\xa9\x73\x1c\x2d\x80\x02\xbe\x6c\xdb\xa9\x9e\x88\xdb\x16\x3c\x77\xc1\xb9\x6b\x4e\x5b\xe6\x68\x4b\xcf\x8e\x36\xf8\x82\xcb\x04\x7f\x70\x27\xf1\x22\xf9\x28\x53\x46\x7d\xc2\x9e\x33\x79\x49\x8f\xd9\x0a\x6d\xbe\x6e\x17\xc5\x54\xc2\x51\xc1\xec\xd1\x96\x27\x85\xc4\xca\x3a\xbc\x09\x30\x63\x1b\x03\xb1\xb6\xe6\x0e\xe3\x5d\xfe\x6b\xae\x9b\x1c\x0f\xf8\x3a\xda\xba\x8d\x77\xfb\xae\x7e\xd1\x74\xa7\xb9\xa7\x9f\xaa\xbf\xfe\x1c\xc3\x5d\xe6\xfc\xe4\xa3\xef\x5c\x73\x8e\xb0\x27\x8d\x25\x7e\x49\xe6\x99\xbb\x60\x7c\x30\x35\xef\xb3\x38\x8d\x1c\xe3\x75\x72\x61\x4e\xef\xa5\xad\x11\x6b\xd4\xeb\x65\x4c\x76\xbd\xde\x62\x40\x9b\x94\x1b\x9a\x41\x7a\x17\x41\x06\x15\x8e\x28\x5b\xd5\xf5\x44\x92\xac\x1d\x9f\x94\x55\x35\x3f\xe1\x64\x33\x4e\x9d\xd2\x14\x1c\xb0\x6b\xae\xd0\x8f\x3b\xc3\x27\xb6\x40\x99\xc0\x8d\x08\xa7\xeb\xed\xeb\x97\xb5\x8f\x04\x05\xfd\xe9\xad\xee\x2b\x47\x74\x88\x9d\x50\xae\x19\x35\x5a\xfb\xa7\x33\x56\x9a\x50\x5c\x19\x84\xf9\xdc\x3d\x70\x0f\x08\xc0\x9c\x7f\x5e\x3e\xea\x75\x81\x98\x3f\xe6\x32\xbb\xe8\x44\x84\xd2\xb0\xd0\x80\x93\x16\x4b\x40\x83\x06\x0e\x7c\x3e\x03\x15\x40\x56\x1c\x14\x5b\xa3\x18\x94\xad\x51\xc4\x9b\x99\xa2\x39\x67\x55\xe7\xf6\xe2\x07\x54\x84\xf0\x06\x38\x95\xa5\x1a\x74\x5b\xd3\x2f\x5d\xd3\x04\xd7\x0f\x03\xe1\xdc\xde\xdc\x59\xae\x15\x19\x93\xec\x89\x9c\x0b\xbd\x0b\x73\xbf\x1e\x7b\x81\x95\xff\xb3\x95\x3e\xc8\x7f\x04\xea\xf8\x8f\xae\xfa\xc7\x02\x56\x3f\x37\x8c\x9a\xa7\xa4\xce\xbf\x0a\xd4\x1d\xbb\xf1\x82\xb9\xfd\x75\xf3\xa4\xbe\xcd\x7f\xa2\x9e\x83\x73\x6a\x81\x39\x9b\x3b\x60\x8f\x9a\xd2\x54\x8a\x33\xd9\xdd\x14\xc7\xb4\xb4\xb6\xb4\x01\xb7\xbb\xd9\x83\x16\x20\x2e\xf7\xb0\x1b\x52\x99\x91\x82\xba\x2b\x0d\xe1\x84\x6f\x24\xcb\x5f\xc3\x25\xa5\xbc\x33\x25\x04\x6f\xd4\x3d\xd3\x9a\xf5\xb9\xb3\x7f\xb5\xf2\xfe\x67\xdb\x26\x34\x3a\x1c\x93\x02\x37\x67\xfb\x9a\x3a\x9b\xe6\x4c\x5f\x78\xb6\xdd\x71\xd2\xd4\x3b\xe9\x93\x92\x26\xcf\x86\xfe\x33\xb6\xcd\xbd\xf5\xd2\x31\x17\xf7\xb7\xd8\x8c\xf6\x9b\x47\x76\x66\x06\x67\xcf\xef\x9a\x31\xf7\x9a\x95\xe9\x81\xfe\xf0\xc4\xb9\x78\xfc\x17\xc2\x35\x39\x09\x8e\xdf\x81\x62\x36\x56\xab\x25\x49\xa7\xc5\x6a\x75\x59\x18\xa1\x25\x82\xd4\x21\x47\xdd\xff\x36\x22\x67\x19\xae\xac\xd4\xc1\x15\xdc\xc1\x7f\x42\xcf\xd9\xd3\xaf\x69\xef\x9e\x3c\xd9\xda\xbf\x67\x66\x60\x07\xf8\xf0\x63\x47\x23\xcc\x2f\x46\x35\x46\x73\xc3\x16\x2c\x00\xfb\xf8\xf4\x7d\x5b\x20\x4f\xd4\x53\xaf\x97\x3e\x0c\xf5\x00\xfa\x6d\xa3\xc5\xa2\xf5\x6a\x83\x4e\x8a\x0a\xb9\xe1\xce\x59\x0f\xbd\xac\x01\xb2\xb6\xc9\x75\x13\xa1\xa9\x71\xd6\x56\xdd\xd7\x3d\xa2\x4c\x75\x84\x6f\x6a\x8f\x02\xe4\x0d\x73\xe6\xaf\x7a\x6b\x03\xff\x4f\xe6\xe4\xbd\x33\xb5\x67\x17\x6e\x98\xed\x4f\xfa\x9d\x05\xfa\xf0\xca\x33\xef\xe7\xff\x7d\xe7\x87\xce\x36\xf0\x05\x3f\xb9\xa5\xee\xbc\xbf\x6f\x5d\xa8\xb9\x8d\xe1\xb0\x0c\x34\xe0\x6f\x30\x4f\x52\xf4\x6b\x31\x68\x75\x3a\x3d\xa5\x43\x21\x35\x2b\x77\x30\x55\xf5\x6b\xc9\xda\x63\x14\xaa\x92\x51\x31\xf0\x88\xd0\xaf\xc5\x3a\xe6\xf7\x6f\xd0\x07\x8f\xb1\xe0\xf1\xdc\x35\x8d\x9b\xf9\x59\xe8\x3b\x68\x70\x37\xf9\x0c\xef\x4f\x99\xbc\x49\x43\x92\x14\x07\xf9\x31\x3a\x46\x4f\xd1\xbf\xc0\x9d\x93\xe4\x6f\x15\xc8\x2d\x71\x85\x3e\x3b\xd2\x21\x35\xe7\xf0\x82\x17\xf8\xdd\x7e\x32\xe9\xe3\xc7\x83\xcb\xfd\xe0\xab\x1b\xc0\xc7\x37\xdf\xc8\xc7\x6e\xc1\x3e\xe7\xdf\xd0\xe7\xfc\x09\x8e\xdb\x85\xfa\x5a\x30\x4e\x82\xd2\xd8\x1c\x2c\xa0\x58\x1b\x6d\x70\x1a\x3c\x4e\x37\xc0\xf1\x29\x03\xb3\xe3\xc6\x5d\x06\x9d\x59\x61\xfa\x55\x0f\x3b\x85\x90\x15\xb3\x34\x03\x85\x43\xcd\x45\x73\xe0\x00\xff\xf3\x00\x99\xf4\x43\xfe\x57\xa4\xa8\xc9\xb1\xa4\x6f\x7c\xf3\xc9\x05\x2b\x3f\xc9\x47\x9f\x74\xf3\x4d\x7c\xec\x2d\xdf\x28\xed\xad\x86\x05\x33\x23\xf3\x6f\xc0\xb9\x63\x14\xcc\xa3\x5e\xc1\xb5\x83\x30\x31\x25\x1f\x04\xba\xb0\x83\xf6\xc2\xfc\x88\xe6\x48\x28\x6d\x3a\xe2\xb5\x58\xa2\x4e\x32\x60\x34\x92\x0c\x0b\xa3\xda\x62\x58\xab\x75\x90\x8a\xce\xbc\xe2\xab\x84\xaa\x36\xb1\xf8\x8b\x0d\xa2\x54\xe4\x97\xa5\x69\xc0\x01\xb9\xa3\x28\x88\xb4\xf1\x6f\xf9\xa0\xb4\xc4\xd1\x3e\xb2\xec\xbe\x59\x93\x4f\xb9\xf1\xe6\xd2\x22\x30\x39\xd5\xea\x75\x46\xc7\xb5\x81\x47\xc6\x8a\xe2\xbb\x6a\xe5\xc2\x81\xb3\x97\xdd\x0c\xc2\xb1\xb0\xc3\xdd\x95\x43\xb2\xfc\x1a\xc6\x44\x7a\x28\x4b\x94\x87\xdb\xb5\x94\x55\xc7\x99\xac\xb4\xc1\xed\x72\x79\x0d\x3e\x8e\xd3\xbb\x51\x4f\x5b\x1d\x0e\x85\x08\xb8\xae\x62\x28\x24\xbf\xb1\xca\xca\x4d\x0a\xa5\x7a\x6a\x42\xae\xa7\x42\x4d\x85\xfe\x1e\xf4\x0c\x2e\x3a\x75\xcd\x30\x1f\x70\xf0\x97\xfa\xc9\x33\x7c\xfc\xfb\xe7\xad\x7f\xfb\x51\xfe\x8f\x99\x9f\xdb\xc1\xf8\xd5\x8b\x4f\x2f\x5c\xf5\xbf\x37\x5f\xcf\x97\xed\x5b\x37\xdc\xff\xda\x7f\x83\x37\xe1\xd8\xe3\x26\xf0\x29\xd5\xca\xb2\xd0\x0c\x1d\xd0\x56\xda\xf2\x0e\x8f\xdd\x0e\x2d\x34\x68\xf1\xfb\x49\x32\xe4\xb4\x7a\x3c\x84\x91\x95\x9a\x6c\xb7\x48\x55\x18\x65\x77\x65\xab\xf0\x1e\x08\x55\x36\x28\xd1\xef\xe1\x0b\xf8\x70\x90\xe4\xb0\xef\x96\x95\x6e\x58\x7d\xe9\x39\xcf\x7b\xc7\xce\x09\x40\xce\x9f\xf6\xcd\xf5\x03\xe0\x64\x59\x7e\xcf\xfd\xfc\xba\x3d\x4f\x3f\xb0\x0d\xac\x7d\xfe\xe8\x82\x47\x9f\x3c\x3b\xff\x08\x15\x7d\xe8\xa1\x45\xbd\x8f\x12\x14\xff\x77\xfa\x11\x32\xc0\xce\x86\x5a\xa5\x85\x7b\xba\xe5\x59\xb8\x73\xe9\x75\x04\xd1\xd2\xde\xfe\x46\x3b\x2a\x12\x52\xb9\x2c\xc5\xf5\x82\x2c\xc7\xc0\x8d\x63\xfe\x59\xdc\xd7\x36\x76\x5e\x7a\x7f\xfa\xe8\x31\xf8\x83\x7e\x04\x5c\x9f\xe0\xcf\x8f\xbe\xfd\xd1\x47\xf0\x1f\x21\xcf\x4d\x41\x7a\xcc\xf1\xe9\x51\xd0\xb9\x70\x20\x91\x13\xe8\xb1\xec\xb5\x5f\x73\x65\x82\xdf\x0d\x89\x81\x18\xa6\x18\x05\x37\x25\xf8\xd5\x12\x45\x50\x0e\xf3\xd3\xcb\x7c\xf9\x51\x22\x4d\x98\x8a\x2e\x07\xe1\xf0\x12\x2d\xd9\x03\x96\x97\xf1\xfd\xa0\xce\x0e\x74\xaa\xdd\x4c\x0a\xff\xc6\xdd\x23\x85\x20\x95\x15\x9d\x2f\xf4\xb3\x6e\x72\xe1\x69\x91\x44\x04\xfe\x93\x48\x27\x9a\x9a\xdb\x35\xd9\xf1\xd9\xec\x74\xb3\x69\x4a\x38\x19\x5e\xca\x4f\x0f\xfb\xcd\x2e\x8b\x91\x65\x75\x26\xbb\xd5\xe8\xb4\x59\x34\x36\x67\x6b\x20\xe1\x4d\xa1\xeb\xb2\xb4\x37\x6a\xb6\x9b\x0d\x1a\x1b\xcc\x08\xcb\xbd\xf4\xbb\x64\x23\xcb\x41\xdb\xb4\x3d\x07\x9c\x4e\x8b\xc1\x82\x1e\x3f\x1d\xb0\x0a\x5f\xa8\x46\xd7\x6a\x95\x2d\xda\x46\x91\x23\x00\xc9\x76\x8d\x3a\xef\xdc\x95\xbd\x0b\xcf\xd0\x3d\xcb\x9c\xdc\xb0\xf0\xec\x35\x7d\x49\x26\x17\x8e\x87\x97\x9e\xd1\xd2\xe5\x73\x0c\xd6\xd5\xd7\x41\xba\x67\xd2\x4f\x80\x0f\x98\xf7\xa0\xbc\x74\xbb\x60\x6c\x8b\x68\xc2\xb9\x45\x73\x6e\x26\x7a\x0f\x18\xf1\xed\x24\xfe\x6f\xfc\x56\x66\xe6\xc6\xdb\xee\x82\xb0\x2e\x08\x7b\xbd\x08\x4b\xd1\x00\xc2\xa2\x4f\x00\x47\x13\x39\x77\x14\x5c\xcf\x6f\xe5\xff\x36\xe9\x5b\x30\x82\x7e\xe2\xae\xdb\x36\x0a\x31\x4c\x1a\xc2\xdf\x2f\xc2\x33\x80\x22\x5a\xd0\x47\x80\xa9\x28\xc3\xa5\xa2\xef\x82\x85\xc0\x39\xe9\x5b\xfe\x37\xcc\x7b\x08\x1c\x94\xaf\x84\xb0\xdf\x89\xb0\x80\x21\x89\x96\x03\x48\xfb\xa3\x5c\x2a\x11\x05\xdf\xf1\xbf\xf9\x76\x12\x70\x82\x85\x4c\x33\x1a\x08\xa6\x4d\xd2\x7b\xc8\x41\xe6\x10\x74\x7a\xde\xbc\x8e\x85\x18\x30\x5c\x24\x61\xee\xdc\x72\x40\xb8\xa5\x8e\xaf\x70\xb9\x73\x90\x17\x97\x28\xfe\xf9\x10\xe8\x9a\xfc\xf5\x67\xfc\x6b\xcc\xa1\x75\x17\xdd\x7d\xdb\xe5\x97\xde\x83\x69\x18\x20\x8d\xf9\x12\x0d\xc0\x42\xbd\x81\x7f\x73\x94\x8a\x06\x60\x52\x70\x0c\xee\x1c\x39\x9f\x7f\xed\xb3\xaf\x27\x83\xae\x43\x7f\x66\xe6\xdf\x73\xe9\xe5\xb7\xdd\x7d\xd1\x3a\x74\x07\xed\x13\x7e\x0e\xa1\x2f\xbf\x86\xa2\xf9\xbc\xce\xa0\x65\x19\x86\x24\x09\x13\xfa\x14\xe3\x01\x5c\x24\xb6\x20\x11\xd9\xd1\x61\x41\x56\x59\x40\xe5\x3f\xc9\xd3\x0b\x74\xc0\xd5\xd5\x68\xd7\x39\x5c\xf6\xf8\x28\x53\x80\x9f\x03\x26\xc6\x35\xe3\xeb\x33\xcc\x19\xcc\x98\xbe\xeb\xd0\xb7\x05\xe8\xe5\x20\x09\xd7\x9c\x45\x32\xa1\xd0\xda\xfc\x16\x5a\x44\xc2\xc9\xb9\x9d\x09\x06\x44\xef\xbb\x8f\xff\x98\x39\xe9\xe9\x0d\xfd\xfd\x1b\x9e\x46\xbe\x92\xef\x85\x63\x39\x52\x3e\x0c\xe1\x8d\x68\x34\x9c\x0e\xe8\x35\x1a\x4a\xc4\x84\xbe\xe5\x25\xcb\x4b\x50\xa8\x1c\xd3\x99\x4b\x75\x32\x6e\x2a\xeb\x86\xb6\xf5\x00\xff\xf1\x7d\xf7\x81\xe8\xce\xa7\x2f\x9b\x3e\x70\xe9\xd3\xdf\x09\xd4\x9e\x10\x88\xa3\x7e\x38\xef\xf1\x73\x98\x2c\x73\xb9\x2d\x89\x7a\x6f\x5b\x39\xf2\x0b\xf2\x3b\xc8\xcb\x9c\xd7\x52\xa4\xd3\xe4\x34\xd3\x5c\x22\x6d\xed\xec\x14\xfa\xe9\xe8\xf0\x39\xd3\x74\x08\x3b\x56\x84\x5d\x0d\xff\xc0\xba\x8b\x22\x7b\x4b\xe5\x6f\x8b\xbd\xdd\x86\x46\x01\x1a\xc2\x42\x6a\xcc\x3a\xf6\x03\x08\x9b\xc0\xb0\xf7\x82\xd5\xc0\x44\xb8\x60\xde\x15\x8f\x33\x49\x2a\x7a\x6b\x34\x66\xa2\x11\x34\x01\x7f\xa1\x6f\x20\xe1\x3e\x33\xef\x41\xf8\x71\xe8\xbb\xd4\x10\xfe\x00\xa1\x43\x74\xf8\x7d\xcc\x3a\x3c\x3e\x81\xce\x41\x72\x1d\x1a\xdf\xd3\x54\xb4\x54\xbe\xad\x28\x13\x11\xbe\xa3\xc4\xef\x43\x6f\x44\x04\x1a\x18\xb6\x17\xc3\x92\x8d\xa5\xf2\xaf\x8a\x8d\x4d\x66\x05\x6c\x9c\xdf\xad\xa2\x7b\x98\xbc\x57\xa0\x1b\x2f\x95\xcf\x2a\xc6\xeb\xd4\x74\x77\xab\xe8\x1e\x26\x33\x02\xdd\x4c\xa9\x7c\x46\x31\x93\x56\xd2\x3d\x9d\x1f\x64\x3e\xe6\x2c\x10\x36\x09\xe7\x91\x22\xd6\x82\xa5\xe5\x23\x56\x4e\xc3\x83\x7d\xa8\x33\x57\xde\x40\xfe\xa6\xa5\xdd\x60\x4f\x90\x2d\x2d\x4c\x12\xcd\x1d\xa4\xb1\xbc\xd0\x3d\x96\xd9\xcc\x47\x10\x6f\xbc\x80\x47\xec\x40\xbc\x08\x24\x35\x01\x6f\x7f\x4b\x56\x6b\x41\x78\x56\x25\x1e\x92\xf3\x8d\xec\x3b\x10\x2f\x25\xca\x79\x3d\xe0\x90\x9c\x49\xb7\x9b\x49\x92\x8e\x9b\x1c\x2e\x0d\xa5\x90\x33\xea\x3d\xc3\x62\x39\x4f\x10\xe4\x4c\x6c\x91\xe5\x7c\x23\x96\x47\x4a\x94\xdd\x58\x61\x8e\x8e\x52\x79\x66\x51\x26\x82\xe7\x38\x1c\xc2\xb2\x58\x1e\x13\x04\x58\x9c\xfb\x42\xd8\x54\xa9\x3c\xbe\x98\x6a\x60\x6d\x6a\x39\x2b\xe9\x1e\x26\xa7\x08\xb0\xee\x52\xd9\x52\x74\x3b\xd5\x74\x77\xab\xe8\x1e\x26\x57\xc9\xeb\x77\x5e\xb1\xb1\x5e\x4d\xb7\x5b\x49\x57\xf3\x5f\x30\x4b\x80\x75\x96\xca\xa7\x17\x9d\x3e\x35\xdd\x6e\x25\x5d\x08\x6b\x10\x60\xeb\x4b\xe5\x59\xc5\xfa\x8c\x9a\xee\x0a\xd5\x78\x0f\x91\x1f\x09\xb0\xbe\x52\x79\x76\xd1\xe7\x50\xd3\x5d\xa1\x1a\xef\x21\xf2\x7a\x59\x2f\x86\x17\x33\x29\x15\x5d\xb8\x4e\xd7\x71\x69\x08\x5b\x8f\x60\xb5\x2f\x93\xc8\xa6\x3d\x79\x13\x09\xec\x70\x9d\x80\xfd\x06\xbb\x93\x20\x05\xf3\x49\x23\x83\x13\xbf\x57\x3b\x9c\xfd\x18\xe2\x4c\x44\x3a\x41\x6e\x22\x20\x8e\x95\xd5\x1c\x5b\xfc\x26\xe1\x86\x2b\x1c\x5d\x08\xf5\xdf\x9d\x20\x23\x11\x49\x25\xac\x9d\x43\xf1\x7a\x85\x7c\x59\xe2\xe5\x44\xbc\x9c\x4f\x3b\x0d\x43\xf1\x9a\xa3\xe2\xf5\x1b\x2c\x2b\x1e\xd4\x95\x45\x6e\x4b\x20\x37\x67\x15\x37\x59\x66\xd7\x61\x99\xd5\x8b\x72\xf8\x3b\x96\x03\xb0\x95\xca\x4b\x8a\x36\x91\x97\x00\xdb\xcb\xaf\xa0\x87\x63\x1f\x32\x51\x84\x5d\x2d\xc8\x2c\x59\x2a\x5f\x57\x4c\x46\x20\x07\x05\xdd\x4b\x54\x74\xff\x49\xde\x2f\xd0\x85\x6b\xbc\xbc\xe8\x8c\xaa\xe9\x5e\xa2\xa2\xfb\x4f\xf4\x6d\x35\x44\xb7\xa1\x54\x2e\x16\x1b\x3a\xd5\x74\xe7\x40\xf9\x84\xb1\x95\x7d\x4e\x10\x02\x7d\x0b\xa7\xa5\xc1\x0d\x84\x64\x8b\xc3\x99\x4f\xf1\x9f\x3f\x80\xff\x7c\x22\xb6\x95\x7b\x88\x5f\xc9\x6b\x69\xc6\x36\xd7\x20\xda\xdc\x12\xc1\xe6\x80\xd1\xc8\x24\x81\xae\xa4\x33\xb0\x1a\x85\xcd\x4d\x46\xfd\x89\xb8\x2e\x08\x3f\x49\x80\x27\xf6\x83\x65\x18\xde\xe7\xb3\x26\x81\xfb\x2f\x6e\x2f\x69\x50\xc0\x9f\x5e\xfe\x86\xf9\x9e\x7d\x0c\xc2\x37\x62\xf8\x4d\xe0\xf7\x60\x3a\xe1\xc8\x1b\x40\x14\x92\x8f\x5e\x1d\x8d\x51\x3a\x01\x1c\xaf\x1d\x7a\x43\x44\xef\x65\xe6\x41\xf8\xc9\x02\x3c\xf1\x0f\x14\x75\x42\x9f\xd1\x61\x4d\x92\x1d\xab\x3a\xba\xa8\xb0\x02\x1e\x8f\xff\x2b\x3c\xfe\xb4\x38\xfe\x92\x38\x7e\xb3\x19\x32\x30\xfc\xc4\x60\xa2\x75\x4a\xdf\x8c\xbe\x15\xce\xfe\x1d\xc2\x4f\x11\xe1\x6f\x01\x75\x84\xe7\x39\x10\x0c\x92\x49\xe0\x43\x87\x8c\xbe\x80\x47\x2b\x61\x88\x32\xde\xc7\x7c\x85\xd7\x2e\x2d\xfa\x13\xc1\x36\x80\xa1\x54\x5e\x56\x94\x19\xc8\x7e\xfb\x46\x6c\x47\x53\x44\xd8\x3a\x01\x16\xda\xdc\xd3\x15\xd2\x8a\xb1\xbf\x2b\xd1\x25\x96\x81\x3f\x80\x29\x84\x2f\x6f\x86\x26\x84\x0d\xc9\xb2\xcb\x22\x12\xc7\x83\x91\xc6\x5f\x62\xff\x25\xd1\x87\x38\xeb\xa1\xfc\x83\x79\x2d\x09\xa2\x51\x12\xe2\x84\x4a\x80\x29\x86\x44\x3e\x02\x1a\x92\xeb\xff\x42\x3d\x91\xe7\x00\xe3\xb1\xb5\x3f\xc5\x63\x28\x7f\x09\xe5\x2d\x8f\x17\xfd\xff\x5b\x24\xbd\x5a\xae\x9a\xf3\xb7\xe4\xa7\xc2\x3c\xcc\xa5\xf2\x9a\xa2\xd9\xa3\x9e\xf3\x72\xd5\x9c\xbf\x25\xcf\x17\x60\x83\xa5\x72\xa9\x18\x4c\x2a\xe6\x5c\x76\xf2\x97\xc0\x38\x06\xd1\x6d\x12\x74\x1b\x00\x01\xd6\x58\x2a\x2f\x2e\x1a\xbd\x0a\x3b\xe0\x8f\x60\x58\x44\x77\xaa\x00\x4b\x7c\x21\xd8\x81\xb5\x54\x9e\x5c\xb4\x06\x69\x52\x25\x4b\x2a\x8d\xfd\x04\xa6\xab\xed\x00\x47\xe1\x1f\x04\xf2\x16\x8a\x04\x50\x11\xd0\xcf\x17\xcc\xb4\xe8\x29\xb0\xab\xe8\x94\xbe\x57\x48\x9d\x87\x7d\xc5\x61\x38\xff\x24\xb1\xec\x0f\xc8\x2b\xf1\x23\xde\x24\xfc\x68\x1d\x34\xc3\x34\x2c\x20\x13\x24\xa0\x69\xc1\x53\x60\x57\x51\xe1\xc9\xf6\xe1\xfd\xb1\x59\xf4\x2f\x9f\xc0\x3f\x40\xba\x67\xb5\x22\xdd\x7b\xdb\x60\xa6\xb5\x55\xba\xb7\x9f\x8b\x43\xf8\xe9\x22\x7c\x17\xcc\x6e\x04\x78\xa8\x7c\x86\x83\x55\xf0\x50\xef\xd8\x3e\x2c\xab\xe6\x1a\xbd\x1b\x85\xf4\x4e\xab\xd6\xbb\xfd\x58\x56\xd3\xc5\x7d\x8c\x97\x61\xcf\xab\x82\x85\xfb\x98\x8a\xee\x61\xf2\x63\x79\x6d\x27\x15\xcd\x46\x35\xdd\xdd\x2a\xba\x87\xc9\xb3\x64\xd8\x5b\xab\x60\xe1\x78\xe9\xe5\x98\x6e\x8b\x6a\xdf\x05\x6c\xa9\xfc\x59\x91\xd5\x10\x95\xd8\xa2\xfc\x15\xbf\x4f\x5c\xdb\x7e\x01\x96\x78\x48\x80\xa5\x4b\xe5\xa9\x45\x9a\x55\xfa\x43\x4c\x97\xbd\x4f\xa0\x8b\xfc\x39\x68\x01\x7d\x98\x3e\xfa\x08\x25\xf4\xe7\x80\x1b\xc9\x69\x01\x9d\x00\x2c\xcb\xa8\xfd\x79\xf9\x0b\x7e\x1f\xe5\x64\x3f\x17\xf8\x20\xdc\x72\x19\x6c\xc2\xfc\xb6\x8a\xb8\xcc\x7d\x30\x39\x27\x13\x70\x85\xc9\x9a\xbd\x60\xb7\x6a\x3e\x87\xc9\x2b\x85\x31\x6a\x4b\xe5\x0f\x8a\x5a\x4e\x39\x9f\x5e\x7e\xb7\x6a\x3e\x87\x45\x5d\x05\x5c\xa9\x3c\xae\xc8\x31\xea\xf9\xac\x50\xd1\x3d\x44\xde\x27\xaf\xd5\x23\x45\x03\xab\xa0\xcb\x7f\xcb\xaf\x50\xd1\x3d\x04\xec\x02\xac\xae\x54\x8e\x15\x75\x34\xa1\xb6\x01\xf6\xb7\x58\x1f\x5b\x05\xfd\xc2\xf2\x47\xfa\x15\x0a\x41\x7d\xf4\x7e\xeb\x0d\x98\xdd\x6a\x7d\x64\xf7\xe3\x38\x6d\x40\x88\xcf\xc8\xb9\x22\x7c\x7b\x3b\xf4\xe5\x99\xaf\x32\xad\xe6\x98\x52\x1f\x11\x7d\x1c\x07\xb7\x0a\xbe\x93\xcc\x08\x71\x30\x08\x04\x10\xfd\xfb\xbd\xfe\x21\xe8\x1f\x90\xe8\x43\xf8\x56\x91\x7e\x6b\x2b\xa2\xff\x70\xa6\x45\x4d\x1f\xea\xfb\x6f\xb1\x5c\x5a\x45\xfd\xf9\x9b\x30\x57\x6f\xa9\x5c\x28\xca\xc4\x25\x7d\x67\xf7\xd3\xd3\x64\xda\x07\xa9\x94\x00\x0b\xe3\x95\xbb\x8b\x32\x61\x85\x9f\x45\xe3\x6e\x13\x7d\xfe\x7b\xe2\xb8\x6d\x36\x38\x6e\xf3\x6e\xb3\x95\x31\x56\xef\x11\x78\xdc\x33\x44\xf8\x2e\x71\xdc\x28\x5e\x00\xc1\x57\x83\x61\x9d\x47\x3d\x6e\xd1\x57\xb6\x89\xe3\xbe\x48\xb6\x91\x39\x45\x99\x78\x65\x7f\xc0\xe3\x9e\x21\xc2\x6a\x65\x5f\x79\x57\x51\x26\x2c\xc7\x9b\x4a\xba\x87\xc5\xf8\x0d\xc5\x22\x17\x14\x6d\x16\x35\xdd\xdd\x2a\xba\x87\xc9\x89\x02\x6c\xa4\x54\xbe\xb1\x18\x09\xa9\xe9\xae\x50\xd1\x3d\x44\x91\x72\x2c\x32\xa5\xe8\x34\xab\xe9\xae\x50\xd1\x3d\x44\xde\x2e\xc0\xc6\x4a\xe5\x1b\x8a\xb1\xa0\x92\xee\xe9\xe5\xaf\x59\x37\xf6\xc1\xed\xd8\x07\xef\x27\xff\x2c\xc4\x6a\x14\x99\x44\x2e\x38\x79\x4e\x32\xab\xa7\x6a\x63\xb5\xad\x58\x67\x07\xb1\x7d\xde\x47\x7c\x2b\xfa\xc6\xa9\x82\x7d\x92\xb1\x33\x63\x2d\x04\x97\x20\x51\x7c\xa1\xb6\xcf\x6a\x7e\xaf\x52\x4f\x0b\x3e\x9f\xa6\xc8\x66\x26\x89\x7e\x9e\xda\x3c\x42\xe4\xa8\xf0\xf9\x98\x27\xfb\x91\x82\xe7\xe7\xe2\x5e\xda\x0c\x23\x6f\xcc\x73\xfe\x8f\xe5\xf9\x32\xd6\x51\x3c\x47\x94\x0b\x92\xf1\x85\xf1\xe4\x90\x73\xc4\x7b\xcc\xa0\x18\x8f\x7e\x8c\xe7\x78\x8c\xb8\x5a\x8c\x47\xfd\xd3\xfc\xc1\x1f\xc7\xef\x15\xf2\x7b\xb5\x4c\x2f\x4d\x06\x7f\x98\xdf\x77\xa2\x4c\x17\x48\xfc\xce\x3c\x1e\x3f\x64\x2b\x05\xbc\x1e\x59\x11\xe7\x12\x41\xf7\x49\xaf\x17\xe5\x60\x7f\x71\xb8\xb5\x8a\x1c\x4c\x78\x8b\x89\x7d\xc8\x4c\x31\xc7\x43\xdf\xf9\xf5\x3c\x47\x36\x37\xc3\x78\xad\xa1\x04\xd8\x62\x43\x53\xd4\xa9\x8e\xa7\x10\x0f\x6c\x8f\x59\xd1\xbe\x96\x0a\xf6\x28\xe6\x79\xb7\x3b\x5c\x43\xf0\x38\x20\xf1\x80\xf0\x75\xe2\x98\x9a\x9a\x10\x93\x77\x1a\xd2\x15\x0e\x22\xfd\x9f\x63\xfa\x9d\x22\xfc\x0d\x22\x7d\xbf\x1f\xd2\xf7\x5c\xeb\xf1\x55\xc7\x84\xd4\x5a\x4c\x7f\x36\xca\x49\xc8\x7b\x4f\x17\xac\xdd\xed\x86\xd6\xee\xb8\xcc\xe1\xe2\xec\x35\xf1\xe0\xcf\xb1\xfd\x74\x8a\x36\x7c\x8b\x10\x97\x78\x50\xdc\x2f\x13\x97\xec\x1d\xbd\xd1\x14\x69\xa3\x7d\x59\xc8\xed\x00\xcc\x45\xcf\x2e\xca\xa4\x2b\x74\xd9\xfb\x05\xba\x78\x9f\xbb\x0e\x8c\xc5\xf4\xaf\x86\x00\xbe\xa7\x49\xe8\x07\xbf\xcd\xeb\xbc\x7e\x46\x97\x20\x3d\x9e\xca\x56\x27\xf1\xc1\x71\xf3\x6c\x14\xc7\x90\x9b\xe6\x55\xb8\xa1\x5d\xce\xc9\x38\xdd\x3a\x7b\x02\x38\x1c\x55\xf9\x15\xf4\x31\xca\xb9\x1c\x26\x7f\x2f\xcc\xc5\x5f\x2a\x5f\x5d\xf4\x7b\x15\x73\x29\xff\x91\xdf\xad\x9a\xcb\x61\xb0\x51\x98\x0b\xcc\x7f\x07\x61\xfe\xab\x9c\x8b\xb7\xfc\x35\x33\x9a\xfd\x0c\xc2\x76\x89\x6b\x70\x16\xf0\x60\xa9\x36\x35\x41\x9f\xdb\xf0\x68\x43\x9a\x72\x29\xd6\xc0\x0d\x75\x36\x83\xd7\xe0\x24\x31\xaf\x78\x55\xf4\xb9\x0d\x0d\x70\x15\x92\x9b\x93\xf5\xac\x57\x01\xef\x85\xb2\x1a\xcd\x6c\x91\xe9\x1f\x94\x62\x4e\x98\x23\x3d\x59\x94\x89\xe3\xb1\xb8\xa1\xcf\xcd\xd0\x53\x64\xda\x07\xc1\x37\x02\x2c\xcc\xd3\x76\x15\x65\xc2\x95\x71\x63\x7b\xc3\x74\xb5\xaf\xe1\x3d\x11\xc7\xe4\xad\xad\x28\x26\x6f\x7c\xa3\x31\x23\x10\x97\x63\x72\x34\xf6\x8d\xd8\x06\x4e\xc2\xf5\x8e\xd5\xe0\x7c\x41\x8f\xbe\xc1\xd5\x0e\x30\x27\x99\xb6\x7b\x13\x20\x99\xac\x54\x3b\x86\xe4\xf5\x3a\xbe\x04\x8d\x79\xb5\xb5\x21\x5e\xed\x77\xb7\x37\x0f\xc1\x2b\xc3\x7e\x28\xf1\x82\x9b\xc7\x4e\xfe\x79\x2c\xaf\xf7\x01\xba\x17\x94\x00\xa9\xba\x54\x12\xb2\x23\xcf\x6d\x03\xe1\x36\x70\x7f\x1b\x68\xcb\x9b\x9d\x13\xfb\xe1\xbf\x2f\xd3\x1a\x26\xb6\xc9\xc3\xb0\xa6\x17\xa4\x17\xac\x5c\xa9\xb0\x7d\x2c\x53\x6c\x37\x5d\x58\xff\xee\x05\x05\x60\xc2\xb2\x5d\x21\xd4\x6d\x40\xbc\xa1\xc9\xe2\x4a\xc0\x25\x51\xd5\x7b\xb0\x7c\xa5\xb5\x43\x78\xc4\xeb\xa2\x9c\xff\x25\xe2\x8d\x4a\x36\x54\x4b\x00\xe2\xdd\x0a\xed\x74\x15\xe6\x97\x13\x75\x64\xb2\xb8\x2f\xeb\xf5\x50\x47\x34\x59\x8d\x8e\x66\x15\x6b\x7e\x12\xea\x29\xc7\x5e\x06\xe1\xe7\x88\x3a\x32\x9a\x28\x62\xf8\x60\x10\xea\x88\xef\x3a\x5f\x80\x53\xee\xe3\xb7\xc2\xf9\xac\xc2\xba\x9d\x13\xc7\xf3\xbd\xb0\xee\x9a\x12\xff\x71\x51\x26\x8e\xe7\x7e\x12\x8c\x47\xbf\x65\x86\xc9\xb4\x0f\x82\xbc\x9c\xb7\x5d\x59\x94\x09\x63\xd8\x9b\xa1\xcd\x28\xe9\x1e\x26\x73\x02\xac\xbe\xc4\xff\xae\xa8\xd7\x2a\xe8\x96\xdf\x86\x71\xa1\x92\xee\x61\xb0\x46\xde\xef\x57\x15\x83\x7e\x25\xdd\x09\x70\x5f\x56\xd2\x3d\x44\x2e\x13\x60\x4d\x25\xbe\x54\x34\x69\x94\x74\xef\x80\x71\xa1\x92\xee\x21\x50\x92\xf7\xfb\x33\x8a\x11\x9f\x92\xee\x45\xfc\xf9\xcc\x3f\x30\xdd\x61\x18\xf6\x73\x12\x7d\xd3\xdc\xba\x8b\x04\xd0\xc8\x7b\xa1\x91\x1b\x18\xb9\xd6\x39\x9b\x3f\x1f\x7f\xbf\x3d\x49\xcc\x15\x61\x17\x89\xb0\xd1\x52\x79\x61\x31\x1a\xf6\xe8\x64\xd8\x8b\xf8\x4b\x54\x74\xff\x89\x6b\x33\xc2\x18\x3a\x8a\x91\x26\x81\xac\x30\x86\xd9\xfc\x25\x2a\xba\xff\x24\xc7\xcb\x36\x78\x4a\x31\xd9\xee\xd1\x29\xc7\xbb\x58\x45\xf7\x10\x79\xb4\xfc\x1f\x51\x66\x9e\x62\xd0\xad\xa6\xbb\x58\x45\xf7\x10\x79\x99\x00\x1b\x43\xf5\xbb\x58\x50\x45\x17\xda\xdb\x3f\xb0\xbd\x0d\x13\xe3\x93\x77\xa5\x5a\x52\x04\x99\x5b\x64\x45\x24\x23\x89\x42\xda\x4b\x67\x97\xbf\xa1\xf7\xe0\xfd\x70\xae\x10\x2b\x40\x2f\x26\xec\x8b\xcb\x44\xcf\x9a\x6c\x4c\xb6\xeb\x02\x09\xac\x83\xea\xbd\xb4\x9a\xdf\x01\xaa\x4f\xce\x49\xeb\x70\x4e\x5a\xb7\xb4\xce\x27\x72\x54\xc4\x27\x98\x27\xbb\x4d\xe6\xb9\x09\x70\x62\x7c\x32\x0e\x72\x47\x3c\x43\xd6\x50\x64\x68\x9e\x4f\x40\x9b\x3a\xc8\x85\x20\x6e\x37\xe6\x49\x82\x53\x84\xfa\x09\x70\x40\x93\x72\xa4\x1c\x11\x52\x59\x6f\x21\xce\x81\xb1\xee\x5b\xcc\x4b\x10\xbe\x80\xe5\x77\x1f\xf1\x3b\x11\xde\x09\x4d\xca\xe9\x75\x46\x49\xbd\x12\xfe\x09\x68\x53\x07\xf1\xda\x74\x8b\x7e\x37\x2d\xeb\xfe\x6b\x45\xbd\x91\x54\xc8\xfb\x1c\xe8\x17\xde\xc2\x6b\x53\x10\x6d\xea\x97\x72\x9e\xc3\xc0\x9c\x54\xa4\x8c\x61\xb7\x10\x84\x26\x8c\xe5\x3c\x5c\x88\x8d\xc8\xd1\x38\x8e\x00\x28\x24\x00\x70\x63\xfd\xdf\xa2\xc7\xaf\x75\xa9\xf6\xe1\xc5\x30\xbf\x78\x04\xfb\xdd\x93\xb1\x7c\xfa\xc0\x34\x01\xc7\x89\xc6\xee\x2a\x95\xdf\x2a\xba\xbc\x1a\x87\x0a\xa7\x9a\x0f\x4f\x7e\x22\xce\x17\xf1\x71\x3f\xee\xf6\x49\x4c\x86\xe6\xb1\x1a\x26\x89\x0a\xf9\x3c\xe6\xf4\x48\x0c\x14\xf4\x71\x4d\x67\xb8\xb0\x66\xe4\x66\xa9\xa6\x83\x83\x1b\xe0\xf7\xfa\xbd\x5a\xb5\x4f\x17\x78\x5c\x2f\xf3\x58\x06\xf6\x4b\xfb\x00\x9a\x09\x09\xbc\x09\xaf\x5b\x60\x23\xe3\x08\x7c\x3e\x90\xf8\xc0\xdc\xea\x66\xd1\x77\xfa\x7c\x68\x22\x61\xb7\x57\xab\xdc\x5f\x05\x1e\x07\x24\x1e\xa8\x4e\x26\xee\xaf\x1e\x0f\x9a\x48\xc8\xe9\xae\x48\x0a\xd1\xe7\xf7\x69\xc2\x78\x9d\x87\x8b\xf9\xd5\xa0\xb4\xd7\x43\xdf\x29\x13\x17\x64\x04\x73\xb1\x47\xf0\x3a\x9f\x2c\xea\xc4\xcf\xe4\x7c\x42\x5f\x94\x09\x63\xbf\xb5\x0d\xea\xe7\x0b\x78\xdc\x23\xc4\x71\xac\x15\xc7\x2d\xd4\xeb\x9e\x33\x98\x74\x8a\xb3\x94\xf2\x23\xa8\xde\x85\xc7\x3d\x4f\xf4\xf9\x1f\x8a\xe3\x36\x9b\xe1\xb8\x0d\x77\x19\x4c\x94\xa2\x66\x22\xd2\x7f\x57\xa2\x0f\x65\x79\x75\x55\x4d\xad\x64\x11\x39\x48\xb2\x14\x79\x5c\x2f\xf1\x20\x96\x61\x1b\x10\x71\x90\xfc\x2d\x57\x5a\x44\x2e\xb2\xfc\x9f\x84\x7c\xbe\xc5\xf3\xe8\x51\xc7\xb0\xc0\x60\x80\xf3\xd0\x32\x5a\x3d\xc5\x29\xc6\xf5\x84\xd0\xc7\x07\xc2\xcf\x17\xe7\xf1\x3b\x71\x1e\x7e\x3f\x9c\x87\x67\xa3\xc7\x47\xda\x15\xf0\x6f\x41\xfa\x31\xec\x3b\x46\x62\x3d\x2d\x23\xbf\x83\xf5\xce\x02\xc9\x5b\x9e\xb7\xe8\x00\xab\xac\x9b\xfe\x1b\xc6\xb0\xff\x64\xfe\x0b\xe1\x17\x60\xfa\xd7\x12\x45\x09\x1e\x92\xb7\x6c\xb0\xe8\x08\x46\x09\xff\x16\xb4\xe3\x18\x5e\xdf\x91\xe2\x9a\x0d\x97\xeb\x0a\x3f\x2b\xea\x0c\x40\xb1\xd7\xfc\x1b\xc6\x96\xff\xc4\xeb\xbb\x40\xb4\xe3\xed\x32\xec\x56\x08\x4b\x54\xfc\x31\xa4\xbb\x5b\x45\xf7\x30\x39\x93\x90\xea\x7b\x17\x15\x8d\x7a\x35\xdd\xdd\x2a\xba\x87\xc1\x57\x32\xec\x6d\x10\x56\x41\x57\xc8\x6f\x15\x35\x46\x99\xae\x90\x37\xfb\x95\x75\x55\x18\x27\x50\x17\xb3\x6b\xa4\xbd\x11\xae\x67\x0f\x71\x48\x58\xcf\x68\x14\xad\x67\x68\x6d\x48\xdc\xd0\xd5\x36\x88\x63\x0b\x41\x87\x7f\x02\x1e\x22\x1c\x02\x0e\x32\x10\x68\xb7\x84\xdf\xa9\xb6\x41\x61\x4d\xd9\x15\xf2\x9a\xfe\x84\xd8\x23\xe9\x0d\x5a\x54\xc8\xe7\xcc\x90\x47\x58\x55\x99\x8f\x0e\xc6\x6f\x39\xb6\xc1\x26\x9d\x3b\x5e\x46\x7c\x43\xd4\xe3\xfa\xf6\x38\x88\x31\x6e\xdb\xb8\x31\xc2\xc1\xa3\xe4\x4f\x50\x6e\xd2\xcc\xb9\x6d\x49\x30\x5a\xd4\x9b\x5b\xa0\x3e\x0b\xb5\x0b\xb8\xb0\xe6\xdf\x99\xad\x7a\x52\xf6\x70\x00\x9d\x3d\x32\x77\x33\x5b\x88\x04\xd1\x97\x8f\xd9\xea\x0c\x44\xcc\xe2\xf5\xf9\x58\x0b\x51\xc7\xa4\x92\x31\x8b\xc5\x17\x0e\x3b\x16\x16\xc2\xb4\xcf\x46\x69\x17\x16\x28\x3b\xa1\x78\x41\xed\x69\xa9\xf9\x66\xa7\x83\x88\x56\x3e\x3d\x89\xdf\xca\x09\x2d\x57\xa9\xa8\x7d\x14\x88\x67\xdb\x69\x37\x08\x01\xe6\x14\xfe\xd7\xfc\x3f\xc6\xdf\x91\x1d\x1c\x71\xfa\xbd\x4f\x6c\xbe\x60\x74\x02\xc4\x56\xdd\xbe\x78\xfd\xe4\xba\xad\xfc\x07\x4f\x35\x3e\x00\x98\x17\x76\x81\xcc\x42\xfe\xc1\x0d\x0f\x82\x77\x3e\xe1\xff\x6b\xd6\xfd\xd1\xbd\x7e\xd5\xac\x33\xf7\x80\xd4\xfc\xbe\xab\x76\x1d\x7d\x99\x3a\xf5\xed\x6f\x2e\xbe\x7f\x13\xbf\xc7\xff\xa2\x70\x8e\xbb\x4f\x75\x8e\x7b\x90\x7c\x10\xca\xd5\xf0\x3c\x69\x66\xcc\x56\xe1\x14\x57\x3c\xc3\xdd\xa7\x3a\xc3\x3d\x48\x06\x84\xdc\xa5\xbb\x54\xfe\x4b\xb1\x7b\x84\x28\x49\xac\x6b\xef\x41\x7b\xca\x62\x7b\x12\x68\xbe\x4e\xff\x41\xc8\x53\x23\x68\xeb\x77\x94\xc0\x59\x45\x87\x9f\xe6\x54\x7b\x05\x5e\x2b\xe6\x88\x44\x5f\x6b\xa0\xbe\x12\xf3\xce\x09\x13\xe0\x62\x8d\x7c\x67\x64\x9f\xb4\x58\xd8\x66\x11\x8f\x43\x15\x1e\xda\xa3\xb8\xae\xea\x7b\x9e\x22\xfd\x68\xb7\xf7\x97\xc0\xdd\x45\xbf\x45\x3a\x86\x4e\x4b\xfa\xc0\x38\xd9\xa4\xc4\x43\x47\x93\x1d\x52\x7e\x0f\x15\x02\xfe\xf8\x7e\xdc\x70\xe9\x28\x5a\x8c\x49\xaa\xe7\xa2\x3d\x86\xf7\x30\xa8\x77\x14\x19\x0c\x22\x4e\xb6\x17\x6c\x6e\x99\x8d\x52\xef\x2a\x7c\x18\x32\x22\xe1\xa0\xc9\x50\x64\x4f\xbc\x67\xb4\xcc\x48\xd0\x6f\xc4\xe7\x0a\x05\x1f\x9e\x7c\x5b\x9c\x8f\x50\x7a\x28\x01\x18\xb9\x79\x6b\xe6\x43\x7f\xc4\x5e\x28\xf3\x61\xc9\x94\x34\x9f\x41\xc4\x66\xf0\x2f\x83\x7d\x3f\x34\x9f\x32\xf5\x02\xc4\x09\xa2\x73\x7b\x94\x07\x51\x64\xba\x04\x46\x16\xd3\x09\xe5\x94\xa4\xf5\x59\x8e\xf7\x72\x81\x17\x5c\x55\x89\xd7\x68\xc4\x6b\xf4\xc3\xa3\xe7\xd6\xf0\x42\xba\x25\xf1\xb2\xa4\xa0\x5f\xbd\x48\xa1\x63\xba\x22\xe9\x74\x0a\xb9\x8d\xa4\x5f\xd8\xa7\x8e\xc5\x71\xd8\xb5\xc4\xff\xe0\xb3\x33\xac\x67\xb5\xe3\xd6\x11\xd4\x2f\xa4\x71\x23\x2a\x14\xcc\xd7\x41\x5f\xd1\x1b\x1d\x6a\xdc\x7d\x5c\x44\x1e\xb7\x86\xfc\x4c\x5a\x8b\xde\x5e\x34\xf0\x31\x7b\xc6\x4c\x19\x62\x2d\x94\xbc\xc0\xff\x81\x57\xb7\x82\x97\x96\xfc\xa0\x8a\xd7\xb3\x3f\xc8\x8b\xac\xf0\x32\xe3\xb3\x14\x3b\xe2\x65\xf7\x0f\x3d\xaf\xb4\xcc\x4b\x57\x99\x57\x77\x37\xd6\xb1\x3d\x3d\xe3\x7e\x80\x17\x45\xed\x56\xf3\x8a\x95\xc0\x94\x62\xac\x79\x28\x5e\x57\x72\x4d\x32\x2f\x7d\x0d\xaf\x4f\x7a\x16\x54\xf3\x82\x6b\xdf\xc5\x85\xa5\xb5\xd7\xd2\xe0\x1d\xf5\xda\x23\x8e\x8a\xb5\xef\x65\x3e\x95\xd7\xfe\x1e\x14\x77\x54\xd6\x1e\xd7\x6a\x94\xe7\xb9\x07\xc9\xcd\x72\x6c\xfb\x20\x8c\x6d\xd5\xe7\xb9\xfb\x54\xe7\xb9\x07\x49\x9f\xe0\xa7\x60\x9e\xf4\x9b\x62\xa4\x4e\x75\x9e\xab\x3e\xef\x86\x7e\xea\x72\x31\x4e\x40\xa6\x0d\xac\x7b\xad\x1e\x82\x54\xc4\x69\xf8\x5c\x1d\xfb\xa8\x89\xa2\x8f\xfa\x52\xf4\x51\xb8\x00\x17\x7f\x36\xde\x68\xaa\xae\x8d\x5d\x87\xf3\x83\x7a\x31\x3f\xb8\x50\x8a\x67\x21\x79\xe7\x0e\xf9\x24\x3a\x5d\xa9\x25\x0e\xe0\xfc\x60\xa2\x98\x1f\xec\x17\xe0\xc9\x06\x54\x7a\x5b\x29\x9f\x46\x2b\xce\x63\xf7\x29\xce\xeb\x8f\x92\xbb\xb0\xcf\x80\xdb\x28\x8a\xbe\x3c\x25\xe0\x2b\x7a\x8c\x8a\x13\x7b\x81\x07\xe3\xc3\xbe\x69\xa2\xe8\x03\xbb\x25\x3b\x6e\x42\x4b\xd9\xf4\x97\xa6\xa8\xc0\xa5\x92\x97\x55\xdf\x0b\x38\x86\x73\x4f\xbc\xf7\xa2\x00\x98\x04\xe6\x01\xb3\x43\x66\x63\xed\x94\x65\xa5\xe0\xc3\x90\x0d\x92\xce\x20\x61\x41\x5d\xb3\xc6\xea\x65\x46\x02\x4e\x35\x1f\x1e\x9f\xd5\xe0\x9c\x31\x86\xd8\xc4\xde\x8f\xb9\x86\xba\x7f\xf0\x16\xf6\x81\x13\x45\x1f\xe8\x95\xe6\x83\x55\xb3\xfb\xe7\xdd\x8d\x3f\x34\x9f\x32\x75\x97\x34\x9f\xe6\x66\xc4\xa8\xfe\x95\xfa\xba\x21\xe6\x23\xf8\xbf\x89\xd5\xfe\xaf\x1e\xf1\xa9\xbf\xae\xbe\xb7\x86\x0f\xd2\x5b\x89\x0f\xf6\x7f\x62\x6e\x46\x5e\x85\x6d\x00\x1f\x5d\x4a\xba\x85\xf4\x16\xfb\xbf\x89\x55\xfe\x8f\x95\xc6\x4c\x1e\xae\x9c\xb9\x92\xaf\xe3\x73\x04\xa4\xab\xc8\x25\x01\xed\xef\xb5\x16\x95\xae\xc2\x58\x86\x7c\x0a\xeb\xea\x61\x41\x57\x49\x29\x06\xc6\xb1\x8c\xe6\xd7\x1a\x93\x12\xbe\x7c\x08\x9f\x11\x56\xce\x8a\x0f\x12\x8f\x11\xd2\x19\xe1\x80\xfa\x8c\xb0\xfc\x8d\x7c\x9e\x38\x55\x84\x7d\x54\xb0\x31\x4d\xa9\xdc\x8f\x6a\x3d\x0a\x7b\x3c\x1d\xe6\x2b\x6e\x5c\x3b\x6c\x17\xe7\xfe\xb6\x00\x0b\x63\xc9\x75\xc5\x60\x58\x4f\xa9\x6d\x77\x2b\x3e\xff\x18\x14\x61\xdd\x84\x74\x87\xe6\x26\x54\x17\x22\x8e\x7b\xfe\x01\x6d\xf7\x90\x6c\x8b\x70\x09\xeb\x5e\xa9\x6b\xd0\x53\x55\xb6\xbb\x15\xcb\x63\x50\x90\x07\xed\x17\xe1\xeb\xe1\xfa\x91\xa1\x62\x28\x2e\x92\x4f\x8b\x77\x29\xd4\x67\x01\x47\xf1\xdd\x14\xbc\xde\x0d\xc8\x55\x36\x1c\x6a\x08\x0d\x71\x16\xc0\x8c\xc6\x3a\x3f\x28\xda\xd6\xa9\x12\x4e\x12\xe9\x48\xf2\xbd\xa4\x5f\x60\x52\xc1\xa9\xe6\x73\xac\xe2\x5b\xd3\x69\xc4\x28\xc2\x45\x12\x32\xa3\x8a\x2e\x6e\x55\xf0\x61\xc8\x25\x12\x4e\x3d\x56\xc6\x60\x20\x58\x27\x33\x12\x70\xaa\xf9\xf0\x95\xf3\xa2\x0e\xc4\xa6\xe3\xd9\x8e\xd4\x50\xf3\xd1\x60\xdb\x1a\x14\x6d\x6b\x86\x84\x93\x45\x6c\xb2\x2f\x66\xe3\x3f\x34\x9f\x32\xf5\x5a\x65\x0f\x44\x8c\xba\x37\x77\x67\x87\x98\xcf\x93\xd2\xb9\x14\xb2\x2d\xca\x20\xf1\xa9\x43\x7c\xea\xb6\xd4\x75\xd7\xf0\x41\x7a\x25\xf1\xc1\xb6\x75\xb3\xa8\x33\x6f\x11\xe2\x59\xd6\x92\x58\x88\xd2\x27\x48\x74\x1e\xab\xae\xdb\x60\x3d\xc3\xb6\x26\x9c\xd9\x5c\x0b\x68\x45\x4c\x8b\x70\x23\x03\x11\x3f\x3a\xb3\x41\xa9\x45\xcd\x19\x11\x77\x1d\x1a\x2b\x58\x24\xd6\xa6\xbe\x23\xa4\xf3\x11\xa8\x77\xa9\x64\xaa\x91\xb6\xaa\xf5\x8e\xb5\xa1\x9a\x06\x58\x2c\x9e\xd9\x38\x85\x58\x18\x95\xda\xc9\x38\xaa\xb5\xc4\x53\x56\x75\x2c\x5c\xcd\xe3\x18\x38\x57\xc0\xc1\x2c\xea\x4b\xe5\x6b\x8a\xf5\xe9\x0a\x17\x69\xad\x54\x7c\xfa\x88\x67\x15\x7c\x12\xa5\xf2\xed\xc5\x44\xfd\x90\x7c\xd2\x12\x1f\x68\x43\xff\x16\xe7\x32\x6c\x18\x64\xd4\xe4\x6c\xca\x0e\x31\x97\x23\x12\x0f\x68\x43\x36\x81\x07\x3a\xc2\x46\xe3\x3a\x5c\xac\x6f\x1e\x92\x47\x48\xe2\x01\xf7\xc0\x17\x11\x8f\x67\x49\x54\xe0\x6f\x2d\x95\xdf\x2f\xb6\xf6\x48\x4c\x2a\x3c\x5e\x92\x78\x90\xf7\xe1\x7b\x8c\x10\x3e\x03\x59\x64\x4a\xe5\x03\xc5\x4c\xb7\xc4\xa2\x53\xd0\x03\xee\x3a\xe4\x5f\xc4\x39\x1c\x24\x85\xf3\x06\x32\x55\xe2\x3f\x2a\xa6\x1a\x44\xda\xd2\xba\xb3\x36\xe4\x5f\x44\xda\x72\x0e\x13\x2f\xf1\x7f\x2c\xc6\x93\x22\x5d\xb1\x2e\xba\x4f\x55\x17\x3d\x28\x9d\xc5\xba\x4b\xe5\x09\x45\xb7\x57\x5d\x17\xdd\xa7\xaa\x8b\x1e\x24\xfd\x72\xbe\x7c\x31\xf4\x71\x27\xa8\x8b\x42\x99\xef\x16\xfd\x72\x7d\x3d\xf4\xe3\x81\x7b\x03\x31\x91\xb4\x20\x73\x5c\x9f\xc4\x7e\x6b\xae\x28\x73\x8d\x08\x9f\x4e\x43\x3f\x1e\xbd\x26\x9a\xf2\x28\xcf\xd7\x20\x7d\x6e\x03\xd6\x9d\x95\xa2\x7e\xfe\x5d\x84\x4f\x26\xd1\x25\x30\x4f\x34\xee\x36\xa8\xe9\xb3\x63\xb1\xde\x9c\x2f\xea\xa7\x74\x2f\x01\x6d\xd3\xa0\xc1\xde\xd0\x14\xb7\x9e\x80\xfe\x31\xd0\x2d\xd4\x01\x31\xf9\x3a\x74\xa1\xa4\x2e\x51\xe1\x20\xd5\x58\x15\x3c\x58\xa2\xef\x52\x8c\x81\x19\x34\x96\xca\xdd\xc5\xc6\xcc\x10\x3c\xd2\x12\x0f\x28\xa3\x27\x04\x1e\xed\xed\x90\x47\xb2\x54\x7e\xb9\x98\xcc\x0c\xc9\xe3\x88\x34\x0f\x28\x27\x20\xe0\xe4\x72\xe8\xfa\x43\xa9\xfc\x62\x31\x93\x8d\xab\x6d\x46\xe0\x13\x92\xf8\x40\xdd\x7c\x00\xeb\x1a\x68\x64\xf0\xc0\x9e\x2b\x36\x76\x49\x6c\x2a\xb2\x7a\x49\xe2\x01\x75\xb3\x4e\x80\x47\x37\x38\xda\x4b\xe5\x17\x8a\xed\xa3\xe2\x0a\x5d\x86\x3a\xc4\x6d\x40\x3a\x24\xce\xe3\x20\x79\xb3\xa0\x17\xd1\x12\xbf\xae\x18\x8d\x89\xb4\x25\x1d\x62\xc7\x22\x1d\x12\x69\x1f\x24\xf5\x84\x78\xc6\xc6\x3f\x52\x6c\x48\xc7\x15\x7a\x8c\xeb\x61\xd8\x5f\xf6\x88\x6b\x50\x27\xcc\x55\xab\xc5\xd7\x08\xcb\x9f\x16\x75\x46\x4a\x65\x87\x62\x4d\xec\x23\xb1\x7e\x02\xd7\x60\xb8\xa2\x22\xe9\xd5\x78\x03\xa4\xfa\xdc\xf5\x49\xa8\xff\xdf\x62\xfd\xef\x11\xc7\x23\x9e\xbb\x68\x4b\xfc\x5b\x45\xb9\xe0\x56\xa1\x8d\xf5\x7f\xbe\x10\xb3\x50\x11\xc5\x38\xd3\x32\x8d\xd7\xe9\x65\xa2\x6e\xe1\xba\xa9\xa9\xcd\xe4\x1c\xa2\x6e\x77\x44\xaa\xf1\xc0\xf8\xfa\x2d\x59\x77\xe1\x28\x03\x0f\x04\xea\x94\x75\x3b\x91\xbe\x5d\xa6\x7f\x1f\xf8\x29\xe8\xc7\xf1\x35\xba\x6a\x62\xeb\xb4\x85\x24\xf2\x4a\x19\xbc\x24\xd7\x90\xee\xc3\xf5\x4d\x7c\x3f\x12\x99\xd2\xb5\xd1\x8c\x44\x5e\x90\x41\x77\xf9\x6f\xcc\x48\xb6\xd5\x96\xa4\xb0\xbf\xe0\x36\x03\x0f\x71\x3a\x8e\xc7\xdb\xa0\x33\x6a\x6b\x68\x6b\xf2\x69\x4e\x04\x7f\x80\x80\xfe\x09\xfb\xd3\x2c\xdc\x2f\xc9\x2e\x57\x97\x8c\x80\xc7\x5f\x0d\xbf\x15\xee\x43\xa7\xe3\x9c\xbf\x0d\x6d\x7b\x6d\xa5\xf2\xd1\x62\xdb\x08\x01\x45\x8a\xdf\xab\x71\xb6\x0b\x38\x68\x7f\xcd\xe2\x4d\xb9\xd3\xd2\x39\x52\x46\xb1\x0e\x89\xb3\x0d\x34\x41\x1c\xbc\xbf\x0a\x8c\x26\xb7\x0d\x57\x70\x19\x72\x2e\x3b\x30\x8e\x92\xcf\x29\x9d\x3d\x43\xf1\xe1\x1a\x65\x9c\x07\x89\xcf\x61\xe4\x8b\x71\xda\x30\xa3\xfc\xf4\xfc\xb4\x1f\xc0\xd9\x59\xc1\x99\x3a\x15\xf3\x99\xde\x39\x46\x8d\x23\xe4\xb1\x38\xfe\x8c\x0b\xeb\x52\x5e\x2e\xee\xdb\x8e\x57\x1c\x0e\x9a\x4e\xc0\xe4\x92\xa8\xba\x9b\x56\x8d\x73\xa0\x7c\xa1\x88\xe3\xfd\x9b\xd7\x3b\x24\x0e\x91\x27\x08\x76\x21\x73\xc0\x92\x22\xe2\x00\x45\xc5\x2c\xb7\xf5\x4d\x82\x08\xed\x42\x05\x80\xf2\xa6\xbc\x1e\xe3\x51\x32\xa2\x70\x5d\x11\xe2\x2d\xad\xc1\xdb\x2e\xe2\x79\x4a\xe5\x33\xf3\x7a\x8f\x07\xe3\xf9\xfd\x55\x78\x2b\x6b\xf0\xb6\x11\x02\x9e\xa3\x54\x3e\x37\xaf\xc7\x73\x1b\x82\xdf\x5d\x35\x78\x3b\x08\x99\xdf\x16\x99\x5f\x0d\xde\xdb\x08\x8f\x23\x15\x78\x0f\xc2\x44\xc5\x8f\x64\xef\xd8\x30\x24\x33\x41\x2e\xb5\x78\x3b\x25\xbc\xf6\x3b\xdb\xdb\x31\x1e\x84\xad\xc1\xf3\x95\xbf\xa6\xbe\xc0\x3a\xb5\x44\x58\x37\xe2\x01\xc1\x9e\x40\x06\xf9\xe8\xe5\x99\x7a\x9d\x5b\x69\x4f\xd5\xf0\x07\x30\x3c\xf2\x07\xe8\x31\x03\x68\x5f\xd9\x2e\x23\x60\x7b\xaa\x86\xdf\x4a\x6c\x11\xf4\x9c\x44\x0c\xe0\x8f\x89\x99\x9c\x80\x50\xd1\xf3\x6a\x9c\xed\x18\x07\xe7\x82\x88\x09\x09\xda\x16\xb4\x75\xcb\x48\x82\xdc\x20\x0e\xad\x53\xe0\x6c\x83\x79\xba\x8a\xcf\xd6\x4c\xd7\x10\x7c\x54\x38\x3b\x30\x8e\x92\x4f\xb1\x6d\x58\x15\x1f\xe8\x45\xd9\x19\x78\x5d\xeb\x51\x25\x00\x49\x8c\x47\xbb\x39\x3a\xe5\x5f\x6a\x80\x31\x72\x02\xc0\x9f\xea\x7b\x0e\x93\x6a\x70\x0e\xf0\xc7\x50\x04\xfe\x34\x3a\xa4\x5b\x90\xd7\xb9\x5c\x6a\x3c\xd1\xdf\x67\x08\x82\xfb\xb3\x80\x87\x6e\x61\x20\x5d\x7f\x81\x10\xee\xe5\x06\x5a\x02\x30\x4e\x4a\x90\x00\xa2\xd6\xac\xe9\xec\x1a\xbc\xed\x12\x5e\xa8\x35\x14\xc2\x78\x1e\x4f\x2d\xde\xe8\x1a\xbc\x6d\x6f\x89\x78\xbe\x2d\x3e\x1f\xc6\x93\x06\xa9\xc4\x5b\x5a\x83\xb7\x43\xc2\x0b\x6c\x11\xc7\x39\x14\x5e\x02\xdd\xbd\xc6\xf2\x3f\x4b\xed\xcb\x41\x02\xaa\x52\x62\x53\x22\x62\x26\x94\xba\x57\x0d\x7f\x00\xee\xb1\x82\xee\xa5\x52\x28\x6c\xb9\xb7\x51\x46\xc0\xba\x57\x0d\xbf\x55\xf2\xb1\x24\x62\x00\x7f\x5c\x9d\x68\x31\x57\xe5\x30\xd5\x38\xdb\x25\x1f\x4b\x62\x26\x24\x68\xb8\xa7\xa1\xcd\xac\xce\xe3\x10\xce\x16\x05\xce\x36\x30\x4b\xcd\xe7\x7f\x12\xcd\x43\xf1\x51\xe2\xec\xc0\x38\x4a\x3e\x5f\x36\xb4\x0e\xc1\xe7\x59\xec\x97\x05\x9c\x07\xa1\xbc\xea\x05\x9c\x04\x66\xd4\xf1\x69\xc7\xe8\x1f\xc0\xd9\x59\xc1\xc9\xe7\x31\x9f\x4f\x1b\xba\xaa\x71\xa0\xbe\xee\xc2\xeb\x99\x96\x75\xfc\xb0\xa8\xe3\x67\x1b\x0c\xd0\x97\x0c\xad\xe3\x6a\x1c\x41\xc7\xd1\x6a\x42\x58\x60\x38\x0b\x23\xca\x71\x18\xd4\x6d\xcd\x18\x01\xbe\x5a\xb7\xfd\x9d\x7e\x3f\x72\xfe\x43\xea\xcc\xec\x1a\x3c\x59\xb7\x83\x5d\xc1\xe0\x71\xf1\x6a\xf9\x6d\x93\xf0\x7c\x57\xf8\x7c\xc7\xc5\x9b\x55\x83\xb7\x43\xb6\xc1\x2b\x02\x81\xe3\xe2\xdd\x89\xf0\xb0\x3f\x96\xf0\x1e\xfc\x3b\xf2\xff\xd0\x13\x95\x80\x39\xaf\xcf\x64\x30\xaa\xda\x7c\x87\xc4\xdb\x29\xe2\xd5\x61\xbc\xba\x3a\x8c\xd7\xde\x5e\x85\xd7\x47\x10\xe4\x4c\xac\x4f\xcb\x31\xd6\xe6\x6f\x04\x4b\x42\x85\x25\xdb\xad\x36\x23\xab\xab\xc8\x1e\xc1\x8e\x50\xc0\x1e\xf8\x8b\x60\x45\xe8\x6e\x1c\x70\xdf\xe8\x96\x81\x45\x3f\x04\xf7\x5c\xf2\x25\x05\xfc\xd6\x37\x45\xed\xb6\x21\x05\xb2\x9d\x6c\x0b\xb0\x3a\x65\x3c\x84\xe8\xff\x46\x01\xbf\xfd\x4d\x51\xb3\x11\x03\x38\xe7\x73\x5c\x21\x56\xf1\xaa\x03\xf3\x80\x38\xd4\x18\x05\xce\x36\x42\xc5\xe3\x69\x9b\xbf\x86\x87\x0a\x7e\x07\xa1\xe6\xf1\x1b\x57\x70\x48\x1e\x2b\xb0\x2d\x08\x38\x0f\xbe\x29\x5a\x82\x0d\x33\x89\xbe\x16\x6d\xfe\x41\x9c\x9d\x12\x4e\x06\x6f\x2b\xae\xd7\x5c\xb1\x1a\x9c\x56\x88\x13\xc7\x3a\xd3\x24\xdb\x0f\x2f\xda\xcf\xc5\x34\x8d\x7c\x3d\xfc\xa9\xb6\x9f\x59\x35\x38\x07\xca\x1a\x11\xe7\x82\xe3\xe0\x40\x7f\x4d\x17\x05\x1c\xc9\x86\x24\xbf\x6b\x9f\x64\xb7\x63\xbf\x2b\x21\x29\x75\xf3\xac\x1a\xbc\xed\x12\x9e\x73\xb2\xd3\x79\x5c\xbc\x5a\x7e\xf2\xfe\x60\xdb\x62\xb3\x1d\x17\x6f\x69\x0d\x9e\xbc\x3f\x38\xb6\x38\x1c\xc7\xc5\xbb\x13\xe1\x61\x5b\x68\xaa\xb2\xa1\x04\xb6\x85\x44\x02\xa3\x9a\x4c\xb5\x36\x54\x85\x27\xd9\x90\x0f\xe3\x89\x5b\x59\x63\x63\x15\x9e\x50\xc3\x6b\x95\x6a\x5e\x70\x3f\xaa\x13\x73\x8b\x30\x5c\xeb\xf0\xa5\x61\x1f\x47\x54\x9f\x0d\x28\xe1\x0f\xe0\xfd\x0b\xe5\x16\xf8\x98\x3d\xbe\x36\xee\x53\xd5\x2f\xab\xe1\xb7\x12\xdf\x4a\x31\x7f\x18\x85\xd5\xe1\x6c\xb8\xa1\xba\xa6\x56\x8d\xb3\x1d\xe3\xe0\x58\x1c\x31\xa1\xc8\xd8\x84\x58\xba\xaa\xae\x58\x8d\xb3\x0d\x8f\x4b\xc1\xe7\xf2\x70\xfd\x0f\xf1\xd9\x81\x71\x94\x7c\xee\x88\x35\x56\xf1\x09\x94\xbf\x66\xd7\xc1\x75\x4d\x12\xed\xa7\x0b\x5a\xfe\x95\xa0\xb1\xe4\xb5\xc1\xa0\x5e\x9f\x20\x83\x41\x42\x79\xdf\x31\x5f\x05\x7f\x80\x17\xef\x47\x92\x57\x0e\x09\x3f\xba\xfc\xb5\xe6\x5c\xac\x37\xed\x6a\xfd\xa6\xc8\x26\x6d\x53\x13\xc4\xa0\x64\x14\x95\x7e\xd7\xe0\x6d\x97\xf0\x9a\x75\xcd\xcd\xc7\xc5\xcb\x94\xbf\xe6\x1e\x15\xf0\xc0\x2d\xf2\x1e\x81\x62\xf6\x74\x09\xe8\xf2\xfa\x74\x7a\x08\x54\x64\xbb\x35\x78\x3b\x44\xbc\x0c\xc6\xcb\x64\x86\xc6\x3b\x13\xca\xfc\x74\xec\xc3\x2e\x12\xf5\x8d\x16\xe3\x1f\x74\x9d\x33\xb8\x3c\xe8\x71\x18\x95\xfa\x56\x0d\x7f\x00\xeb\x02\xf2\xdc\x61\xb8\xae\xa0\x6e\x41\x9d\x8c\x60\x1d\x8a\xbe\xac\x6f\x24\x62\x00\x7f\x8c\x0a\xa6\x1c\x46\xb5\x1e\x54\xe3\xc8\xfa\x46\x62\x26\xd0\x4b\x0e\x46\x1b\x1c\xea\xbb\x23\x08\xe7\x1c\x05\xce\xb6\x4a\x9c\x25\xf0\x79\x20\x98\x1c\x8a\x8f\x12\x67\x47\x25\xce\x12\xf9\x14\xa3\xf5\x43\xf0\x59\x83\x7d\xf1\x45\x62\x2e\xfb\xa1\x14\xcb\x04\x31\xa3\xa6\x7b\x9a\xba\x7f\x00\x67\x67\x05\x67\xd8\x30\xcc\xe7\x9e\x68\x73\x15\x0e\xf4\xc5\x5c\x00\xaf\x67\x0f\xce\xa5\x24\x5f\xec\xf9\x39\xfa\xc0\x77\x5e\xa7\xd5\x52\x54\x02\x68\xb5\xb2\xb2\x8a\x71\xc9\x44\x01\x47\x11\x97\x08\x3e\xa7\xbc\x1d\xf9\x1c\x88\x43\xca\x48\xb2\x0e\x3c\x4f\x10\x5a\x8b\x80\x87\x2a\x34\x48\x77\xc2\x02\x1e\xcc\x67\xef\x40\xf9\xec\xd0\x78\x17\x23\x7e\xd8\xc7\x49\xfc\x76\xbe\x29\xfa\xd4\xf0\xd2\x70\x18\x23\xc5\x62\xb5\x3a\x9e\x83\x36\xb8\x14\xcb\x7d\x9d\xa0\x73\xa4\x46\xd4\x39\x5c\x30\xbb\xb2\x3d\xe3\x53\xe9\x5c\x35\xfc\x01\x0c\x8f\x74\xae\xa3\x03\x22\xe4\xae\xcf\xc9\x08\x58\xe7\xaa\xe1\xb7\x82\xaf\x24\x5d\x40\x05\x69\xd0\x3e\xad\xbd\xc7\x57\xa5\x0b\xd5\x38\xdb\x31\x0e\x5e\x23\xc4\x84\x04\x5d\x8b\xba\x46\xf9\xd4\x6b\x54\x8d\xb3\x8d\x1c\xae\xe6\xf3\x52\xfb\x88\x1f\xe2\xb3\x03\xe3\x28\xf9\xfc\xbe\x6b\xe4\x50\x7c\xb0\xfe\xac\x13\x63\xee\x7f\x49\xfa\x83\x2b\xec\x60\xf4\x2b\xa3\xa7\xff\x00\xce\xce\x0a\xce\xb4\x69\x98\xcf\x2b\x5d\x7d\x55\x38\x30\x4b\x62\x2f\x46\xbe\x91\x9a\xa7\xf0\xa5\xba\x22\x48\xa7\x09\xe9\x3c\x32\x5f\x05\x23\xf8\xcf\x1a\x18\xcd\x0a\xa4\x4f\xd4\x3c\xc9\x67\x42\xbd\x30\x3c\x4b\xca\x40\x9d\x52\x0c\x50\x05\x87\x7c\x64\x2d\x1c\xca\x41\x1f\x12\xe0\x14\x3e\xb1\x16\x6e\x56\x0d\xdc\x8e\x21\xe1\x56\x22\x38\xa4\xb7\x32\xdc\x83\xfb\x7f\x1c\xdc\x4e\x11\x6e\xdc\x38\x25\x1c\xae\x55\x31\x9f\xc9\xb5\xaa\xbd\xc4\x5e\xe1\xfc\x03\x55\xb7\xd0\xe1\xc4\x03\xc5\x4c\x6b\xa5\xc2\x37\x14\x0e\xd5\x0d\x6e\x14\xcf\x58\x30\x52\x53\xa6\xa9\x45\x55\x13\xc4\xf5\x08\x0c\xbf\x04\x8f\x64\xef\x5a\xa1\x02\x8a\x42\x40\xd0\xe0\x68\x68\xaa\x54\x3c\x2a\xf5\x0b\x19\x1e\xd1\x3f\x89\x50\x60\xd4\x3f\x5d\x9f\x56\xd5\x48\x70\xce\x89\xe1\x85\x1c\x6d\xaf\xf4\xbe\x07\xa7\x75\x20\x7a\x7a\x34\x5e\x9b\xd7\x56\xe0\x21\x7d\x5e\xa8\x35\x63\xf0\x48\x09\x10\xc5\x48\xac\x82\x21\xc5\xb1\xa4\x11\xe3\x08\x71\xec\xde\x17\x15\x27\xcf\xa6\x36\x93\xb5\x2a\xe6\xef\xc3\x67\xd5\x12\x3c\xe4\x41\xdc\xac\x3c\xab\x36\xee\x33\x5a\x58\x5d\xcd\x59\xee\x67\x72\xfc\xb0\x97\x38\x2a\xca\x14\xbb\x73\x7f\xca\x1f\xaa\x8d\x85\x2a\xf0\x70\x0e\x25\x25\xbc\xef\x41\x5f\x50\x05\x8f\xf7\x25\x3c\x9e\x8b\x44\xfa\xcf\x09\x73\xc6\x4f\x1f\xa0\xaf\xfc\xba\xe8\x0d\x54\x76\xbf\xca\x5e\x56\xc1\x81\x3c\x7e\x42\x10\x95\xf7\x12\x9e\xcd\x1e\xbf\xa3\xc6\x77\x61\xf8\x75\xe2\x3a\xbc\x47\x28\xde\x83\x36\x47\x9b\xdb\x6a\x7d\x5d\x05\x9e\xea\x26\x5f\x50\xc2\x67\xf6\x43\xcd\x53\xc2\x77\xa3\x6f\x21\x49\xf5\x5b\x4b\x8a\xbb\x4d\x78\xeb\x27\xd6\x3d\xdc\x79\x23\x35\xba\x61\x74\x8f\xc6\x97\xa0\x50\x6a\xae\xae\x7b\x56\xe3\xe2\x3a\x36\xc4\xc5\x34\x70\xcd\x14\x95\xb2\x21\x2e\x3e\xf8\x3b\x31\x2e\xae\x69\xcb\xb8\x28\x4e\x41\x65\xed\xbc\xbe\x6d\x04\xe2\x4d\xa2\xc7\xa9\xaa\xbd\xa6\x1a\x7f\xbb\x0a\x1f\xc7\x55\xa8\xc2\x8d\x91\x25\xee\xca\x3d\xa7\x1a\x1f\xc7\x07\x6a\x7c\x54\xee\x1e\x82\xf9\xd0\xf8\x3b\x6a\xf1\x51\xe5\xfb\xc4\xfc\xa5\x7a\x36\xc4\xc7\x35\xf0\x2a\xfe\x8e\xb6\xa6\x13\xf3\x57\xe0\xef\x94\xf1\x3f\x97\xf0\xfb\x23\xfd\xe3\x31\xfe\x94\x29\x35\xf8\x62\x5f\x9e\x03\xd2\xbd\x2b\xa1\x36\x8e\xf0\xc1\x43\x3f\x5c\x23\xaf\xc2\xc5\x35\x72\x15\xee\x09\x6a\xe5\xfc\x1c\x65\x0d\xda\x92\x44\x7b\x01\xc2\xc5\x77\xe0\xc4\x1a\xf6\xa8\xe3\xd7\xb0\x97\xd6\xe0\x6f\xaf\xc2\x57\xd5\xce\x6b\xf0\x57\xd6\xe0\x6f\x23\x6a\xf8\x9f\xa8\x86\x5e\x83\xbf\x83\xa8\xe1\x7f\xa2\x5a\x3a\xc2\xaf\xd4\xc4\x21\xfe\x83\xf5\x6a\xfc\x58\xa9\xfc\x66\x5e\x1f\x8b\xfd\x58\xfc\x9d\xf5\x35\xfc\xdf\x94\xf9\x37\x34\x54\xe1\xab\x6a\x89\x68\xdd\x51\x3e\x09\x7d\xef\x6d\xbf\x11\x5e\xce\x24\x46\x25\x22\x84\x23\x01\xe2\x71\xf5\x9b\xc4\x6a\xbc\x03\x55\x78\x8d\x63\x1b\x31\x5e\xe5\x39\xd9\xd0\x78\x5b\x15\x78\x7e\xa1\x4a\x98\x68\x81\x88\xa4\xcc\x51\xd4\xd2\x21\x70\xb7\x57\xe3\x36\x74\x37\xb4\x61\x5c\x89\xab\x1a\x77\x8b\x02\x17\xd7\x3f\x55\x7c\x2f\x49\x34\x9f\x80\xaf\x12\x77\x47\x35\x6e\xc3\xad\x0d\xad\x27\xe0\xfb\x84\x54\xdb\x44\x76\x0d\x4c\xd0\x2e\x95\x7c\x27\x60\x01\x1f\x8f\xaf\x12\x77\x67\x35\x6e\xdf\xcc\xbe\xe1\x18\x17\x5d\x13\x55\xe3\x06\xa0\x5e\x28\x6a\x9d\x68\x65\x51\xb4\x86\x35\x63\x91\x60\x95\xc0\x70\xba\x50\x28\x95\x0a\x7c\xd2\x1a\xe5\x6b\x70\x71\x14\x27\xe3\xa2\x7a\xcf\xa9\xc7\xa9\xb1\x66\xf8\x39\xca\x5a\x24\xb2\xe7\x17\x30\x26\xf5\x4f\xe2\x47\xd5\x4e\x6b\xf0\xb7\x57\xe3\xcb\x35\xd4\x40\x60\x88\xfc\xb8\x06\x7f\x9b\x02\xdf\x8b\x62\x6f\xa9\x94\xea\xf3\xc9\xe8\x82\xcc\x66\xd5\xe0\xee\xa8\xe6\x7d\xe2\x7a\x2a\xc2\xaf\xd4\x45\x91\x2d\xff\xbd\x82\x1f\x78\x9a\x04\xa5\xf2\xdf\xf2\x7a\x2c\x39\x15\x05\x31\x4e\xac\xc5\xdf\x39\x14\x7e\x32\x89\xf1\x93\xc9\x6a\xfc\x1c\x5c\x37\x39\x77\x40\x2b\x8e\xf2\x20\xbc\x6a\xe2\xfd\x24\xd0\xee\x6f\xcf\xe8\x42\x09\x80\x62\x48\xb5\x1f\xae\xc6\x3d\x50\x83\xdb\x15\xed\xc2\xb8\xe8\x18\xf7\xc4\xb8\x38\x9f\x92\x71\xb1\xdc\x50\x4a\x65\x84\x1b\xbf\xcc\x59\x95\xef\x55\xe1\x6f\xaf\xc5\x47\xd9\x15\xc6\x97\xb8\x9f\x08\x1f\xe7\x59\x55\xfc\x61\xaa\xf5\xa3\xf9\xef\xa8\xc5\x47\x59\xd7\x89\xf9\x4b\xb9\x14\xb6\xf1\x7f\x09\x7b\x6f\x05\x1f\x65\x60\x27\xe6\xaf\xc0\xdf\x59\x8b\x3f\x70\xf7\xc0\x04\x8c\x8f\x0e\xb7\xab\xf1\x91\xad\xcb\x39\x97\xca\xd2\x87\xd7\xe6\x5e\x55\xb0\x15\xcb\x1e\x12\x56\x99\x7f\x55\xf6\x66\xba\x99\x18\x2a\x1f\x5a\x5a\x03\xbf\xfd\x84\xf0\xd0\x56\x95\xf9\x98\xc2\x56\xcf\x1c\x12\x7e\x56\x0d\xfc\x8e\x13\xc2\xaf\x44\xf0\x95\xfc\x0c\xd9\xe3\xfe\xff\x1b\xfc\xce\x2a\xf8\xa1\xf2\xba\x4f\xa5\x1c\x8d\xbc\x47\x7a\x2f\x26\xf4\x3c\x68\x71\xb7\x0c\xab\xbd\xb7\x81\xde\xff\x8b\xf0\x9b\x88\x77\x09\xe5\x1d\xb5\xff\x16\x33\x72\x52\x27\xc7\xb4\x52\x0e\x08\xd7\x6a\x2f\xf1\x9a\xb0\x56\x38\xa6\xf3\xe1\xbe\x6f\x8f\xe7\x75\x99\x56\x14\x52\x23\x96\x92\x59\x4a\xb8\xe8\xce\x9a\x98\x73\x0a\x38\xe6\xa7\xc9\x5c\xa9\xec\x2f\xe6\xda\x44\x3e\x95\xd8\xb1\xc2\x07\xe6\x20\x1b\x15\x38\xa8\xf6\x19\x6b\x6a\x51\xf3\xe8\xac\xcc\xbf\x28\xf3\xb8\x03\xc7\xaa\xa8\x16\xdd\x09\x27\xd4\xe9\x93\x2e\x60\xc8\xf7\x5c\x30\x9f\xa2\x22\xb7\xf8\x5c\x81\x87\x72\x8b\x71\xbe\x71\x83\x28\x44\xed\xe9\xb1\x0e\x71\x0f\xa3\x5b\x7a\x17\x60\x45\xbd\xd3\xde\x13\x72\x68\xf4\x1e\x80\xb4\x95\xc0\x8c\xa2\xcd\xa7\x7e\x1b\x24\xdc\xdd\x60\x7f\x2a\xbf\x27\xda\x04\x7e\x01\xc6\x20\x79\x5b\x20\x8a\xa5\x04\x9c\x45\x8b\x8d\xae\xdc\x09\x14\xef\x7a\x7c\x26\xc2\xc3\xfc\xf3\x76\x82\x88\x3c\x47\x5a\x6c\x80\xb0\x81\x12\xff\x52\x5e\x67\xb3\x31\x4c\x82\xb4\xd9\xa4\x4d\x6f\xc1\x82\x21\xf0\xa8\x6e\x06\x7a\xeb\x67\x48\x84\x54\x1e\x3e\x04\x52\x67\x6d\x1f\x4c\x31\x56\x36\x3c\x4f\xfa\xcc\x3e\x87\xf4\x7e\x8a\x00\xa0\x9d\x6e\x22\xcf\x64\x0e\x10\x3a\x22\x90\x47\x1f\x75\x21\x18\x42\x6f\x40\x3f\x5b\x0e\xb4\x2b\x3f\xe8\xc1\x99\x00\x17\x1b\x05\x72\xb1\x1c\x79\xa6\xdf\x32\x2a\xbf\x69\xf8\x54\xe3\xb2\x04\x73\xe0\x86\x81\xf5\x13\xbb\x97\xf6\xee\x45\x7d\xa4\xcf\xe3\xe7\x80\xf3\xca\x97\x13\x66\x22\x94\x37\x98\x08\x42\xcf\xe8\xad\x16\x52\x73\x99\x91\x68\xf1\xbd\xa1\xa2\xa6\xf8\xb8\x1a\xea\x95\x0b\xfc\x36\xbb\x39\xea\x6d\xca\x8d\x98\x44\x07\xb6\x39\xca\x84\xdd\xc8\x5e\xa9\x1f\x36\x3c\xb9\xf9\x2c\xf5\x18\x3d\x79\xad\x46\x4b\x68\x0d\x7a\xf5\x08\x7f\xe4\xf8\x56\xd0\x4f\x52\x0b\x99\x22\xe1\x25\xe2\x79\x9b\xd6\xe5\x73\xf9\x9d\x8c\xd9\x18\x36\xb6\x18\x29\xa3\x4d\x4b\x10\x2d\x2f\x65\xff\xb4\xa0\xfd\x25\xa1\x1b\x35\xfa\x8a\x48\x33\x89\x5a\x2b\xc7\xd0\xa7\xfc\x42\x24\xea\xf4\x9d\x35\x91\xe4\xa2\xfa\xc9\x7d\xa3\xfc\xf1\x36\xcf\xba\xd0\xa8\xf9\xe3\x1a\xa6\x8c\xed\xf1\x35\xb5\xd8\xd7\x7a\x7b\x17\xd2\x4f\xc6\x1a\x62\x4d\x7d\x2b\x4e\x1b\x51\xd7\x58\x37\xbc\xe3\xf4\xa5\x3d\x50\xc4\x04\x45\x3c\x40\x7f\x4a\xed\xe2\xd0\xf7\x13\x82\x44\x94\x98\x98\x4f\x44\xb4\xa1\x90\xab\xce\x17\x08\xb8\x5c\x31\x7f\x38\xec\x43\xcc\x01\xb4\x38\x27\xb3\xc7\x08\x8c\x79\xad\x61\xa2\x31\xe4\x23\x5a\xb2\x1f\xa6\xe1\x70\x6c\xdd\x2d\x0b\x5e\x12\x5e\xe3\x29\xfa\x1b\x67\x8f\x37\x3e\x2a\x97\xe5\xa2\xf0\x17\xf9\xac\x3c\x4e\x38\xb4\xf1\xca\x71\x6e\x49\xff\x26\x7d\x6c\x75\xe3\xbe\x34\xab\xc3\x03\x86\x03\x95\x06\xcc\xff\xe1\x8f\xf0\xaf\xea\xfa\x0a\xf2\x0d\xf8\x2e\xb2\x10\x1b\xfa\xd0\x4d\xc1\xf2\xa1\xbc\x2e\x1a\x47\x21\xb8\xba\x81\xa2\x84\x8b\x7d\x03\xc2\x15\x70\x88\x5a\x9a\xd0\x0f\xec\x93\x69\xe2\x73\xf5\x48\x4c\x4d\x4f\x79\x47\x02\xdb\xb5\x50\x1b\xba\x03\x8d\x05\xd7\x6b\x51\x5b\x90\x86\x5b\xa4\xc3\x7b\xd5\x1d\x09\x09\x1e\x7a\x59\x48\x5f\xc6\x42\xd9\x62\x77\x77\xf7\x78\x14\xd6\x4a\x79\xae\x14\x97\x5e\x4d\x10\xec\xb3\xcc\x67\xe8\x0e\x87\x58\xf3\xde\x8b\x6f\x63\xc1\xf9\x5a\x4a\xe5\xee\xbc\xce\x62\x01\x20\x01\xd4\x49\x26\xc4\x7b\x8a\x20\x38\xaf\x88\x77\x8b\x60\xa1\x0e\xb1\x52\x7e\x76\x5e\x67\x36\xab\x91\x04\x1c\xc8\x8b\x73\x61\x9c\xf4\xf1\x78\x41\xab\x1e\x9a\xd7\x5a\x11\x6f\x28\x5e\x6a\x24\x01\x27\xae\xec\xfb\x27\xfb\x02\xe1\xce\xf0\x8d\x45\xb7\x55\xee\xef\x42\x90\xc4\x4a\x68\x6b\xff\x8b\x6d\xcd\x02\xad\xc4\xcc\x10\x5a\xad\xd5\x68\x32\xd9\x8c\x7a\xc9\xe6\xba\x5b\xba\x2b\xdf\x76\x52\x59\x1e\xa0\x72\x51\x3b\x07\x1e\x42\xf6\x77\x7d\x37\xb2\x3f\xb0\xff\x61\x0e\x00\x03\x5b\xb1\x43\xfe\x17\x20\x92\xe0\x3f\x8c\x8a\xbc\xa8\x31\x22\xaf\x64\xde\xa2\x61\xb4\xfa\xe3\x33\xab\xe5\x96\xb3\x47\x21\x71\x05\x37\xa2\xcc\x5e\x0a\x00\xc7\xff\x4d\xc9\x2e\x0a\xe2\x09\xfe\x13\x3c\xb7\xc7\xe8\xf9\xd4\x4f\x39\x12\xf2\x8b\x13\xc3\xf2\x21\x87\x96\xa0\xa2\x89\x68\x52\xfb\xa6\xee\x63\x1d\xa9\xd3\x05\x1d\xfa\x88\x3e\x62\x31\x7b\xc2\x1e\xd2\x83\xb8\x2f\x68\x47\x7d\x95\x5f\xca\x66\x5b\x16\x48\x9f\x2c\x50\x8d\x20\x31\xb4\x83\x58\xe3\x35\x74\xe7\x36\x0d\xef\xd5\x2c\x8b\x01\x77\xfd\xb4\x09\xa3\x91\x11\xae\xf7\xf5\x9c\x3c\xae\x61\xfa\x84\x5e\xc1\x08\x87\xcf\x63\x0e\x5c\x31\xe6\x9c\x51\xdd\xb3\x9b\x9e\x6b\xc7\x46\xb8\x64\xf1\xf0\x54\x6b\x6a\x78\xc7\xe2\xf9\x9d\xd2\x99\x7b\x3b\xde\xfb\x71\xad\x92\xbc\xe7\x4d\x42\xec\xc8\x89\x9e\x72\x3f\x6a\xf1\x0e\x51\xab\xfc\x2d\xde\xfb\x05\xf8\x4d\x25\x21\xaa\x36\xb9\x4c\x16\xad\x2e\x81\xf1\x94\xba\x8e\xe8\x9b\x38\x56\x80\x47\x3d\x0f\x7f\x27\xe8\xe0\xfb\x30\xe7\xc5\x11\x21\xf4\x33\x66\x88\x48\xca\x98\x95\xdc\x6f\x48\x5c\xaa\x9b\xf8\xf0\x47\xe0\x76\x40\xdc\x14\xb6\x4d\xa1\x06\x7b\xc7\x7e\xc1\x92\x5d\xa8\x5b\xc3\x55\xd2\x45\x02\xf9\x8e\x06\xb5\x99\xfd\x5e\xe4\x83\x7a\x74\xe9\x40\x97\x95\x45\xfc\x84\x8a\x53\x43\xb6\x21\x05\xf9\x50\x24\x2a\xfa\xaa\xf9\xa0\x5e\x90\x8b\xf1\x7e\x8e\x6f\x02\x6a\x69\xb1\x2a\x49\xd3\x4c\x12\x70\x7b\x39\x73\xe5\x95\x11\x21\xc1\x5b\x70\x7f\x41\xe1\x9d\xd1\xa6\xf2\xf7\xa0\x0f\x8f\x8c\x81\x08\xcc\x5d\xb8\x3f\xa0\xc2\xc7\x40\xfb\xa5\xae\xc5\x76\xd8\x54\x6d\xbf\x1a\x6c\xbf\x1a\x0d\x32\x7b\x8e\xab\xb5\x5f\xea\x6b\x11\xaf\xd6\x7e\x39\x4e\x8d\xd4\x89\xf5\xf6\x6e\x68\x93\xff\x86\x76\x62\x20\xe0\x1e\x9f\x87\x02\xa0\xe1\x3e\x6d\xa2\x2c\x76\x8b\xc3\x4c\x12\x46\x0e\x6e\x5c\x07\xda\xdb\xd5\xdf\x23\xe2\x62\xa8\xa9\x7b\x0c\x7f\x4b\x43\xb4\xcb\x87\x13\xcb\x98\xfc\xa6\x0c\x1b\xa9\x58\xe5\x5e\x9f\x7b\xea\xe2\x93\x67\x78\x87\x3d\xa4\xb4\xcb\xbb\x44\xbb\x14\xf9\x21\x6e\x46\xcc\xcd\x68\xe4\x20\x43\xc8\xef\x43\xbc\x2d\xc9\x1c\xab\xf9\x89\x96\x29\xf1\x53\xd8\xa5\x92\xa1\x68\x99\x15\xbb\xf4\xc2\x69\x8f\xc9\xc7\xc2\xbe\x60\x4c\x1b\xf3\x51\xae\x94\xab\x3e\xf0\x66\xf2\xe3\x24\x99\x4c\xda\xa0\x1f\x82\x9b\x04\xde\xae\x49\x63\x04\x1b\x27\x74\x0e\xd9\x16\xab\xd2\x3a\xa5\xaf\x7f\x0d\x65\x96\x66\x10\xe3\xe0\x00\xd1\x57\x71\x7a\x01\xf9\xf8\x71\xed\x72\x75\x7c\x19\xdd\xbb\xc9\x6b\xd5\xf8\x18\xbe\xda\x30\xdb\x9f\x8b\x74\x9f\xd6\x3e\xbe\x2d\x9c\xbc\xa2\x52\x5b\xff\x54\xaa\xad\xc3\xf8\x5c\xaa\x7d\xe3\xdb\xeb\xfe\x39\xfe\x78\xed\x59\x34\xb6\xd1\x8b\xc4\xf8\xfc\x05\x71\x1f\xf3\xa2\xfa\x7d\xa7\xd7\x3f\xc4\x59\x37\xb6\xb3\x8b\x70\x4f\xa9\x65\xc4\xef\xc5\xba\xff\x97\x92\xa5\x05\x6c\x01\x9f\xd1\x9d\x10\x1a\x14\x54\xe7\x6d\x55\xf8\x70\xbf\xfd\x0a\xd4\xe1\x5e\x08\xbf\x97\x6a\xb6\x75\x33\xeb\x22\x46\x07\xb4\xa0\x50\xa8\xb6\x66\xfb\x36\xdc\x47\xef\xc6\x79\xeb\x2a\xb1\x46\x9f\x17\xef\x82\xc4\x60\xfc\x1d\xfb\x7d\x2c\x64\xa2\x94\xf7\xd8\xab\xe1\x0f\x80\x2e\xf1\x2e\x08\xbe\x9a\x57\xff\x4e\xbd\x8c\xa0\x90\x47\x51\x3e\xcf\xb8\x43\x7d\xef\x7d\xbe\x74\x28\xad\x94\xc7\xd9\xec\x27\x35\xf2\xb8\x03\x98\xa0\x0d\x0a\xf2\x98\x09\xe5\xe1\x38\x8e\x3c\x84\x7b\xf9\x61\xe9\x5e\x3e\x8c\xf1\x17\x8b\xeb\x85\x1f\x28\x18\x9c\x06\x87\xf2\xde\xbf\xd8\xdf\xe3\x7e\xf9\x1e\xff\x26\xb0\x01\x8c\xc5\xe3\xd3\xa1\xf7\x0c\x66\x9d\x41\x75\x8f\x9f\xb8\x17\xee\xcd\x97\x61\xdb\xee\x11\xcf\xeb\xf6\x5e\x8f\x3d\x82\xb1\x54\x5e\x95\xd7\x19\x8d\xe8\xc8\x5c\x79\xc3\x15\xe2\xdc\x0d\x71\x3e\x13\x71\xfe\x25\xf8\x03\xe9\x94\xfd\xd2\xbc\xce\x60\x50\xa3\xc8\x77\xd1\xd8\x28\xae\x23\x65\xe5\x7b\x86\xff\x12\xb0\xc8\x72\x7f\x5e\xe7\x70\xe8\xa0\xf3\x75\x38\x2a\x58\x14\x61\xa4\xef\xa7\xde\x67\x3e\x13\xbf\x33\xd1\x9a\xf7\x1a\x74\x3a\x40\x53\x26\x56\xa3\x31\x73\x7a\xbd\x8e\x35\x53\x0b\xa9\x73\x29\x8a\x82\x61\xf0\x1b\x0b\xb2\x95\x2f\x38\x8a\xf6\x8d\x5d\x08\x8a\xd5\x51\x6c\x09\xfe\x2a\x38\x90\x8d\xe9\xf7\xd3\x47\x17\x36\xbe\x97\xa6\xef\x17\xbc\x87\x05\x45\x8f\x38\xe6\x1d\x8a\x1f\x41\xfd\x78\x7e\xd8\x85\x24\xc4\x58\x16\xcc\x10\x1d\x08\xf0\x57\x38\x0a\xee\x43\xe0\x08\x80\x95\xbe\x9f\x4c\x60\x7e\xae\x3c\x5c\x58\x0e\xd2\x07\x02\x6d\x9c\x23\x48\x33\x00\xcf\x09\x23\x97\x06\x5c\xa9\x8f\x48\x67\x58\x38\xd6\x7d\x4f\xac\x59\x48\xb5\x29\x74\xec\x65\xf4\x25\xf0\xd9\xe5\x10\xb5\x29\xba\x5f\x3e\x2f\xbb\x4d\x7c\xbb\x05\x86\x95\xca\xbf\x2c\x0e\x6b\xf7\x29\x7a\x70\x55\xf1\xa1\xba\xd1\xbb\x68\x19\x07\x45\xc0\x2f\x66\x5a\xd5\x6c\x3a\xe5\x33\x7b\x6c\x27\xeb\x44\x7d\x3f\x20\xda\x49\x17\xb4\x93\xae\x45\xd2\x41\xba\x7c\x5f\x01\xf3\x29\xca\xf3\xc1\xf4\x65\x3c\x14\x01\x8f\x5f\x34\x7e\x26\x2a\xf7\x8c\x1c\x59\x3d\x9f\x5b\xca\x5f\x73\x7d\x58\x1f\xdb\xe5\x7d\x6d\x83\x88\x15\x75\x44\xa3\xe8\x8a\x52\x24\xa2\xae\xe7\x76\xe0\x3b\x4d\x9f\x89\x77\x9a\xa0\x06\xdf\x2b\x64\xf5\xff\x88\x44\xd4\xe0\x22\x8f\xfb\xa1\xce\xe7\x11\x0f\x6a\x9e\x78\x4f\x7f\xef\x4d\xb8\x36\xd4\xdc\x5c\x75\xce\xff\x99\x78\xce\x0f\x69\x3e\xaa\x82\xc0\xfe\xe6\x13\x38\x4f\x07\xb3\x05\xc1\xa0\xf7\x3d\x30\xae\x7d\x0f\xe7\xb4\x7e\xa8\x0b\x0f\x48\xba\x40\x11\x43\xe8\x82\xb0\x41\xf9\x45\xad\x92\x74\x09\xe1\x4e\x85\x7b\xed\x5c\xb8\xf7\x19\x51\x3e\x0c\x77\x5a\x1d\xa1\x33\x9b\xf0\x9e\x57\x95\x0f\x0b\xfb\x1d\xfe\xc8\x5a\x8e\x9c\x8b\xb7\x3a\xbf\x8d\xae\x13\xb7\xb8\xae\x89\x6d\xce\xf4\xd3\xd0\x88\xdf\xe3\x0f\x11\x8d\x30\x78\xa0\x08\xeb\xb3\xe8\x7b\xc6\x24\x1c\x47\x8b\xf8\x21\x34\xbb\x35\x66\x6d\x9c\xc5\x70\xff\xfd\x92\xf5\xa0\xef\x7b\x44\x20\xec\x27\xcc\xd5\x84\x09\xda\x8b\xd3\xa0\x83\x12\xa0\x01\x80\xdc\x49\x8d\x86\x03\x7a\x86\xd1\xc2\x51\x20\x43\x69\xa9\x7c\xf7\x5b\xf8\x12\x18\x24\x15\xb3\x72\xa9\x5c\x2a\xe7\xce\xb9\x39\x37\x97\x6a\x9c\xb5\x21\xf7\xd8\x63\xe2\x3f\x1b\xf8\x43\x4c\xe1\xb2\xdc\xcf\x1e\x1d\xf6\xf8\xe3\xc3\x1e\xfd\x59\xee\x32\xc4\xeb\xf7\xfc\x21\xf0\x0c\xe4\xa5\x23\x3a\xf2\x6e\x0d\x34\x43\x2d\x09\x87\xc6\x30\x2c\xab\xa7\x39\x00\xff\xd6\xb1\x3a\x02\x7d\x39\x5d\xf8\xb2\x48\xe5\xdb\xe9\xd2\xfc\x53\xb9\x18\x1c\x7e\x34\x95\x03\xcf\x7c\x9c\xbb\xf2\xbb\x41\x30\xf9\xca\x1c\xfd\xd8\x1f\x73\x97\x7c\x7f\x36\xf3\xe9\x25\xc3\xd0\xb7\x46\xa6\xc2\xf9\xd4\x63\x1e\x70\x3e\x1a\x9a\x66\xb5\x14\xc5\xb2\x50\xc8\x7a\x86\xd2\x52\x5a\xc8\x44\xe2\x20\xce\x45\xf1\x0d\x36\x48\x1c\xce\x03\xce\x26\x5a\x3f\xf8\xdd\x95\xb9\x8f\x21\x0f\x30\x19\x4e\xe4\xb6\x4b\x72\x7f\xfc\xd3\x30\xd4\x8f\x14\x10\x33\xc1\x5e\xfa\x1b\xb8\x8b\x52\xc4\x84\x7c\x07\x01\x65\xcb\x00\x62\x77\x01\x10\x4c\x84\xc9\x33\xa7\x32\xb7\x30\x3b\x19\x16\xfd\xc7\x79\xf8\xb7\x0c\x81\x7f\x43\x75\x0f\x30\x9f\x30\x64\x2b\xb3\x97\x21\x57\x9e\x7f\xca\x82\x95\xe7\x13\x2d\x69\x29\xe5\xb7\xe7\xa2\xdc\xcc\x14\xbd\x2a\x05\xf6\xbe\xfe\x3a\xe6\xd1\x04\x79\x8c\xc1\x3c\x4e\xcb\x8f\x86\x3c\x04\x16\x11\x06\xdc\x02\x7f\xc7\x80\xc0\x4e\xfc\xbb\x53\x19\x90\x67\xd0\xff\x85\xff\x4b\xf8\x3f\xe7\x49\xff\x29\xfc\x1e\xfe\xa6\xfb\x13\x06\x40\x7e\x0b\x16\xac\x44\x7f\x9d\x8f\xff\x82\xff\xb9\x12\xb1\x17\xd4\x12\x71\x6f\x8a\x50\xff\x8e\x60\xee\xa0\xfc\x0d\xd8\xab\xb1\x23\xde\x60\x44\xfe\x33\x92\x21\x68\xcc\x7b\x1e\x03\xa6\x30\x60\x04\x03\xd2\xcc\xff\xc3\xdb\x7f\x00\x46\x59\x65\x8f\xc3\xf0\x3d\x4f\x9d\xde\x27\x33\x93\x3e\x99\xf4\x4e\x26\x85\xd0\x32\x08\x84\x40\x80\x00\x86\xc0\x00\x21\x10\x91\xaa\x20\xd2\x41\x04\x04\x15\x44\x85\x08\x08\x2a\x28\x2a\x60\x41\x90\x55\x08\x01\x0b\x28\xc5\x8a\xa8\xa8\x88\x82\xb8\x6b\x5b\xd7\x55\x5c\x77\x57\xdd\x24\xf3\xe4\x3b\xf7\x4e\xc9\x04\x70\xdf\xdf\xef\xfb\xff\xdf\x77\x92\xa7\xdf\x7b\xee\xb9\xe7\x9e\x7b\xca\xad\x10\x27\x22\x2d\xa1\x4d\x84\x1f\x44\xf8\x5c\x84\x77\x44\x78\x49\x84\x3d\x22\x3c\x22\xc2\x3a\x11\x96\x8a\x30\x53\xbc\x46\xf8\x84\xa3\x22\x3c\x2f\xc2\x63\x22\xac\x17\x61\xb9\x08\xb3\x45\x68\x10\xa1\x46\x84\x0a\x11\x0a\x44\x48\x12\xc1\x28\x42\x87\x08\xdc\x65\x11\x2e\x89\x70\x46\x84\xff\x61\x84\xff\x55\xf8\xf2\xab\x23\x44\x88\xd2\xf5\x37\xa7\xeb\xaf\x21\x44\xbc\xff\x1a\x3a\x54\xa8\x74\x57\x1d\xa4\xaa\x35\x5d\x45\x22\x65\xda\x49\x57\x94\x6a\xea\x20\x5d\x5f\x42\xb6\x29\xc8\xe9\x56\x78\xed\x38\x28\x8f\xf6\xa1\x52\x1b\x8a\x3a\x57\xa2\x6d\x97\x28\x7b\xd6\x28\x44\x70\x77\xd4\xa2\x9c\xbc\x8e\x10\xa5\x15\x8d\x72\xbc\x12\x93\x4f\x0d\x20\x90\xc8\xb2\x04\xac\x8d\x8d\xbc\xc2\x57\x70\x23\xc4\x95\xe8\xbd\x1c\xf4\x75\xa8\x88\x5a\x40\x5e\xd4\x69\x81\x9a\xb4\x8f\x8e\x53\x8b\xfc\x18\xff\x98\x07\x75\x70\x97\x0e\xea\x74\x50\x89\xae\x90\x0e\xbe\xd5\xc1\x27\x3a\x78\x48\x07\x6b\x75\xb0\x40\x07\x53\xd0\x42\xd4\x81\xa4\x83\x5f\xc3\x9f\x4e\xe9\xa0\xb9\x6b\x14\xfc\xaa\xc6\xa0\x93\x75\x30\x52\x07\xd7\xe9\xa0\x58\x07\xa9\x3a\xb0\xe9\x40\x60\xd1\xbe\xd6\xc1\x47\x3a\x78\x5d\x07\xb0\x5f\x07\x3b\x74\xb0\x41\x07\xab\x75\x70\x0b\xed\x68\x83\xe1\x3a\xe8\xaf\x83\x42\x1d\x24\x87\x23\x4c\xff\x59\x07\x5f\xb2\x18\x27\x74\x70\x80\x45\xd8\xa4\x83\x15\x2c\x02\xa6\x50\xcb\x22\x14\xb3\xd0\x44\x07\xff\x0a\x83\xc7\xc0\x3b\x59\x48\x04\x3d\x2f\x1c\xb2\x98\xc1\x35\x31\xb8\xff\xd2\xf9\xca\x3b\xc3\xee\x0f\x03\x8e\x04\xf7\x31\x34\xb8\x60\x78\x84\x5c\x8e\x78\xbc\xaf\x83\x63\x2c\x60\xb8\xb4\x1b\xfe\x98\x37\x6e\xed\xfa\xeb\xc2\x1b\x0d\xd1\xc1\x27\x5c\x0d\x81\xc5\xc8\x21\x15\xa7\xd8\x3a\x58\xe1\x4d\x4c\x83\x52\x01\xdd\x7d\x2f\xba\xfd\x5e\xfe\x95\x74\xe7\x98\x81\x87\x86\x4c\x31\x2e\xf7\xf2\x15\xc7\x97\x1e\x1a\x3a\xe4\xa9\xc1\x4a\x5b\x54\x19\xab\x49\xae\xcf\xce\x4b\xc8\x03\x20\x81\x16\x4d\x2c\x51\x78\x74\x1c\x2b\xe2\x1c\xb6\xcc\x96\xe9\x54\x08\x72\xa8\x8d\xd1\x53\x5a\xe6\x41\x65\x64\x00\x98\xdb\xfc\x64\xe2\x72\x2f\x24\xa5\x3b\x46\xf1\x15\x4f\x3f\x08\xc2\xf1\xf9\x74\x78\x0f\xf2\xeb\x4f\xca\x71\x58\x85\x6c\xa5\x21\xdd\x7c\x4e\x41\x25\xaa\x64\x59\x12\x45\xad\x8e\x49\x52\xe9\xd1\x71\x44\x64\xe0\x0b\x4e\xe4\x84\xf7\x7a\x0e\xef\xba\x4d\x05\x29\x6d\xaa\x60\x29\x3c\x75\xb8\x66\xaa\x7e\xa5\x17\x92\xd3\x1d\x75\xca\xf1\x9a\xa7\x2b\x41\x78\x7d\xd1\x21\xc4\x5d\x41\xdc\x47\x21\xee\x68\x66\xfa\x2c\x3a\x54\x7d\x06\xad\x4e\x02\x1d\x3c\xe2\xd7\x45\x23\x6e\x29\x8f\xb4\x8c\xf2\x11\x6f\x0f\x7d\xa9\x51\xde\xe5\x52\x75\x73\xb1\x25\x5d\x5c\xa9\xb4\x27\xa5\x2c\xbd\xa3\x71\x61\xd5\x84\xe3\xe8\xd7\x21\x4d\xf8\x0e\xca\xf7\xc4\x4e\x6a\x7c\x19\x56\xad\xcd\x68\x32\x69\x6d\x26\xad\x23\x46\xa5\x16\xd4\xa8\x6d\x1c\x5a\x9b\xda\x24\xea\xba\x54\x85\x48\x11\x84\x36\x04\x0c\x69\xb9\xf2\xd0\xb6\x6e\xa1\x7c\x41\x67\x99\xb8\x3b\x6f\xb9\xe9\xe9\x8e\xd1\x43\x9a\x59\xf9\x04\xbc\x5d\xca\x6a\xfe\xe1\x11\xac\xac\x3a\x0b\x8d\xf9\xd6\x61\x1c\xd5\xc4\x4a\x06\xfb\x52\x69\xc9\x81\x08\x92\x64\xd7\x9b\x0c\x26\x8d\x41\xab\xb5\xdb\xb4\x06\x01\xc5\xd5\x35\x0a\x92\xa1\x87\xa5\xc9\xf0\xb3\x44\x6d\xf4\x1e\x5d\xae\x62\xe4\x8e\x77\xb7\xec\x4c\x62\x25\xec\xf4\x2b\xda\x48\x69\xd7\xf2\x15\x3b\x1f\x06\xe1\xd8\xed\xcd\xc3\x68\xa9\x1f\x5b\x7c\x10\xf1\xea\xf8\x55\x39\xce\x97\xb1\x32\xb7\x93\x5a\x5f\x96\xd1\x6a\xb2\x5a\x2c\x66\x13\x2b\x7d\x2c\x77\x2c\x7f\xd9\x24\xc7\x38\xb4\x3a\x5d\x8c\x59\xa2\x4c\xa0\x23\xa6\x10\x1b\x78\x4f\x14\xe5\x98\x89\x37\xb2\xef\xb7\x39\xa2\x5a\xa3\x19\x03\x3a\x19\x43\xec\xbc\xe5\xc6\xb6\x8c\x98\xa2\x0d\xb1\xa1\x22\x37\x0f\x9b\xa2\x0b\x3e\x20\xc7\x8c\x78\xf6\x3a\xca\x31\xcd\x23\x86\x3d\x3b\x00\x6f\x16\x1e\xa1\x72\xb1\x9d\xaf\x10\x8a\xc5\x95\xa6\x74\xf9\x5b\x85\xda\x60\xdf\xc2\x25\x26\xf3\x3e\xee\x58\x20\xd4\xa3\x1d\xa5\x25\x95\x3e\x8f\x9a\x80\x46\xa5\x92\x78\x59\x06\x81\xe3\xf4\x3a\x49\x4d\x78\x41\xd4\x22\x49\x87\xfb\x35\xa2\xc8\xc9\x58\x10\x05\x6c\xe3\x78\x8a\x38\x75\x01\x42\x54\x0d\xee\x5a\x1e\xdc\x24\x9a\xf7\x58\xc5\x32\xd1\xea\xe6\xd3\x64\xee\xc7\x1f\x1e\x39\xaa\x3c\x9f\x09\x95\x79\xa4\xe3\x46\xb8\x3e\x93\x3f\xd6\xd6\x2c\x0c\x8e\x7b\x37\x01\x16\x29\x6b\x12\xde\xc5\xf4\x8b\x3a\xe6\xa2\x6f\xf9\x2e\x52\xef\x6e\x5f\x35\x58\x2c\x26\x83\x56\x43\x77\x3b\x33\x1a\x4d\x3a\x59\x16\xcd\x36\x3b\xe1\x45\xc1\x24\x88\x26\x31\xc6\xa1\xb1\xdb\x88\x4d\x6b\x36\x08\x16\x9d\xd5\x62\x1d\xee\xd7\x5b\x24\x34\x88\x04\x4e\x05\x1c\x0c\xf7\xcb\x9c\x05\xff\x30\x2c\x09\x16\x7e\xd8\x28\x0a\xe3\xda\x89\x74\x79\x79\xd8\x44\xec\xdc\x5a\xb2\xb3\x59\x82\x62\xef\x45\xec\xd3\xb4\x80\xa7\x50\x76\x38\xb7\xf2\x54\x26\x0c\x2b\x39\x37\x0a\x66\x67\x2a\xdb\xea\x52\x60\x56\xa6\xf2\x68\xe9\xb9\x3a\x65\x57\x26\xd4\xd4\xf1\x1f\xd1\x4c\x4d\x56\xb6\x25\xbc\x1b\xa7\xbc\xad\x9c\xc6\x27\x65\x1b\x4c\xc6\x27\xf0\x32\x3a\x8f\x85\x65\xdc\x4e\xfe\x2d\xa2\x85\x5a\xdf\xbf\x89\xa4\xd7\xa9\xf9\xc5\x3c\x87\xd6\x55\xba\x1e\xbe\xd5\xc3\x27\x7a\x68\xd6\xc3\x6e\x3d\xcc\xd3\xc3\x14\x3d\xd4\xe9\xa1\x92\xbd\x7f\x50\x0f\x31\x7a\x90\xf4\x60\xea\xaf\x87\x52\x3d\xa4\xe8\xc1\xa2\x07\x41\x0f\xff\xd2\xc3\xd7\x2c\xda\x29\x3d\xbc\xc0\x62\x6e\xd2\xc3\x6a\x3d\x2c\x08\xc7\xc7\xf0\xc5\x7a\x48\x0d\xc7\xbf\xe9\x23\x3d\x9c\xd0\xc3\x01\x16\x14\xa1\xde\xa5\x87\xc9\x7a\xa8\x65\xe9\x20\xdc\xf4\x70\xb8\x5f\xf4\x00\x5f\xea\xe1\xfd\x70\xe8\x9d\x7a\x58\xa1\x87\x5b\x58\xe8\xe1\x7a\xf0\x85\xa1\xda\xf4\x40\xf4\xf0\xb3\x9e\x06\xfe\x28\x9c\xf8\x3c\x16\x2c\xf8\x15\x71\xec\x89\x50\x8e\xe9\x81\xdb\xaf\x87\x1d\x7a\x54\x0b\x0d\x5d\x24\xfd\x7f\x33\x16\xfe\xc0\x5a\x98\xd0\x45\x0f\xa0\xa3\x30\x21\xe2\x29\xd8\x42\x5b\x2b\x7b\x8b\x62\xb8\x9d\xfb\x16\x2f\x7c\x6e\xcf\xa2\x25\x7b\xb9\x9d\x8b\xf7\xed\x5d\xb2\x64\xcf\x9e\x60\xff\xce\x9d\x68\xa9\xff\x07\xba\xe1\x9d\x8c\xfc\x5e\xea\x8b\x45\x66\xd7\x4a\x02\xda\xfa\x5a\x82\x05\x82\xd6\x1f\x3c\x32\x4e\x15\x62\x9f\x82\x22\x56\x3b\xbd\x21\x4e\x89\x58\xbc\x5e\xe4\x6c\x77\xe8\xb8\xb3\x27\xb8\x7b\xc2\xcd\xec\x3c\x9d\x9d\xbb\x29\x67\xc2\x47\x50\x27\x30\xfb\x5d\xf8\x00\x7d\x1c\xa7\x0f\x53\x40\xd7\x42\xe2\x10\x01\xda\x22\x06\x61\x1b\x9a\xda\xe7\xf6\xec\xeb\xe1\x82\x70\x07\x35\xca\x6b\xa8\x4d\x3e\x14\x6d\xf2\x2c\x16\xcf\x7e\x88\x27\x68\x93\xa3\xbc\x8b\xc4\xa2\x5c\x5a\xe2\xc6\x68\xca\x50\xb8\x70\xbd\x70\x47\x4d\x6b\xa2\xb8\x31\x98\x9e\x05\xe3\xfd\x24\xae\xc2\x1c\x26\xfb\xf4\x84\xe3\x44\x9e\x57\x01\x0a\x21\x3e\x68\xc3\x77\x5a\xf0\x41\xdb\x9d\x26\xfd\xd3\x89\xda\x13\x70\x81\xff\xa0\x2d\x51\xf8\x0b\xbc\x10\x05\x43\x4b\xfd\x01\xac\xf7\x18\x17\x21\xf1\x3c\x6d\x63\xd5\x68\x24\x5e\x4d\xb7\x88\x8c\x76\x6e\xba\xfa\x03\x2c\x3b\xee\x30\x5c\x65\x3e\xac\x0b\xc3\xae\x51\x7e\x20\x5d\xe0\xe7\xfb\x6c\x28\xc3\x55\x82\x96\x76\x69\xea\x64\xad\x96\x10\x41\xcd\x0b\x57\x80\x8f\x40\xe7\x11\x2a\xcb\x37\xfe\xfd\x04\xeb\x10\xf4\x05\x4c\x43\x48\x02\x7b\x8d\x32\x8c\x26\x11\xf4\x5b\x43\x3f\x93\x24\x53\x3f\x53\x26\x55\x1d\xff\x91\x0f\x8b\xeb\xd0\x5f\x8b\x23\xd9\xa4\x8c\x54\x92\xeb\xc9\x68\xae\x97\x6f\xd1\x28\xab\x36\x96\x2f\xc8\x18\x5d\x9a\x54\xdd\x6f\x64\xcf\x9e\xfd\x92\x32\x78\xad\x34\xc6\xff\x90\x1f\xd6\xf9\xe1\x56\x3f\x4c\xf6\x43\x9d\x1f\xca\xfd\x90\xe3\x87\x04\x3f\x6a\x71\x3f\x5c\xf6\x77\xf8\xb9\x13\x34\xc0\x23\x7e\x6e\x1e\xfd\x52\xed\xe7\x4c\x7e\x10\xfc\xf0\xa5\x1f\x3e\xf2\x03\x5a\xa8\x3b\x59\xfc\xe5\x7e\xf0\xf9\x87\xfb\x39\x2e\xd9\x5f\xe8\xe7\x8c\x7e\x50\xf1\xa3\xa5\x51\xce\xa1\xdd\x52\xbb\xd1\x85\xd5\xfc\x03\x73\xe2\x73\xd8\x4d\xf7\xf8\xd4\xf8\x16\x88\x3b\x38\xce\x97\xea\x52\xd9\xf1\xd5\x0b\x7e\xa2\xc2\x17\x2f\x8c\x23\x46\x7c\xf2\xe9\xfd\x44\xbe\xcf\x0f\xcb\xfc\x30\xcb\x0f\xfe\x16\x8e\xf8\x92\x96\x2c\xab\xaa\x62\x88\x65\x33\xc4\x10\xaf\x76\x3f\xfc\xe8\x87\x8b\x7e\x78\x2f\x14\xe6\xf5\x5b\xe6\x56\x6d\xf5\xc3\x5a\x3f\x2c\xf6\xc3\x0c\x74\x47\xfc\x30\xc4\x0f\xbd\xfd\x90\x8f\x98\xf8\x61\x1a\x22\x34\x9d\x65\xe6\x7b\x3f\x5c\xf2\xc3\xdb\x0c\xf3\xe7\xfc\xb0\xdd\x0f\xf7\x33\xe4\x67\xfb\xa1\xc1\x0f\x63\xfc\x30\x2c\x9c\x52\x5c\x54\x4a\x5f\xf8\xe1\x8c\x1f\x5e\xf1\xc3\x3e\x3f\x20\xbd\xee\xf1\xc3\x52\x3f\xdc\xe4\x87\x7a\x16\xbe\x8f\x1f\x72\xfd\x10\xef\x07\xbd\x1f\x7e\xf7\x03\x26\xf1\x99\x1f\xde\xf1\xc3\xcb\x68\xbe\xef\xf5\xc3\x63\x7e\xb8\x0b\xd1\xf4\x43\xb5\x1f\x8a\xfc\x90\xea\x07\xa4\x20\x87\xc9\xc0\xcf\x7e\xf8\x9a\x61\xf2\x3c\xbe\x68\xa0\x92\xa0\x61\x42\x57\xcb\xf0\x4a\x2f\xe3\x4a\x5b\x92\xca\x8e\xce\x28\x39\x91\x18\x39\xd4\xd9\xa8\xc8\xc9\xa1\x4b\xa8\x32\x4d\x10\x3e\x9c\x15\x15\x40\x13\x69\xe8\x2a\x97\x6e\x6d\x08\xc3\xeb\x54\x12\x21\x46\x0c\x6f\xee\x2c\x87\xf7\xeb\xb6\x88\x29\x06\x60\xfb\x3b\xd3\xfd\xb0\xff\xdb\xb7\xb4\xff\x16\xcf\x03\x5e\x38\xb7\x70\x85\x3d\xf9\x4f\x2b\xe7\x2c\xb5\xf6\x07\xa1\xf7\xa0\xec\x01\xbe\xa1\xb6\x18\x4e\x75\xcd\xb7\x43\xaf\xf5\xb6\x95\x9c\x14\xfa\xbc\x21\xae\xbb\x7d\xf1\x80\x41\x0f\xef\xbf\x73\xd1\xc0\x4a\x18\xb0\xb8\xe1\xd8\x80\x39\x33\xa6\x8e\xee\x33\x3b\xd0\x7c\xed\xf7\x8b\xff\x20\xf8\x9f\xc4\x95\x4c\xae\x90\xe3\xfc\x12\xae\x04\x1f\x78\x62\x69\x26\xe8\xc1\x13\x8e\x27\x15\xa7\xb1\x7a\x52\x1b\x25\x0e\xdc\xfc\x71\x1f\x14\x3d\x8a\x81\xe4\xc0\x7f\x68\x1d\xc4\xf0\x42\x22\xb3\x37\x7e\x65\xad\x53\xbf\xc2\xf7\xb4\x2e\x1e\xb8\x45\xbd\x42\xcd\xd5\x07\xeb\x69\x02\x7f\x87\x30\x0f\xc3\x64\x10\x4d\xc7\x68\xd6\x52\xac\xa1\x23\x61\x4c\x32\xd1\x70\xa3\x48\x30\xdd\x41\x64\x1d\xb7\x96\x7f\x96\xa8\x48\x9e\xcf\x81\x92\x01\x4d\x6a\x41\x02\x01\x34\x6a\x9e\xfc\x38\x6e\x07\x7f\x8c\x47\x44\x0a\xea\x73\x22\x0a\x3d\xa4\xc5\xd3\xd0\x2a\xf3\xca\x60\x95\x41\x7d\xcc\x00\xfd\x2e\x4b\xca\xa1\x97\xc5\x75\x30\x7d\x20\xcc\xce\x52\x1e\x50\x1e\xcb\x40\xd8\x6e\x84\x3d\xe9\x1a\xb0\xd5\x1a\xc2\x23\x6c\x72\x8c\xd0\x56\xa0\xab\x61\x53\xa8\xac\x17\x15\x1e\x3f\x66\x50\x5e\xb9\x2c\xc1\xa0\x97\x45\xfe\x59\x65\xcb\x40\xa5\x29\x0b\x66\xc1\xa4\x8c\x60\xfe\x6a\xd8\x5c\x52\xa4\x01\x61\xeb\x83\x21\xd9\xe8\xfe\x9d\xe9\xbe\xb8\x0a\x33\xf0\x9c\xee\xa8\xee\xb2\x8e\x03\x22\xd4\x08\xeb\x85\xa3\xc2\x19\xe1\xb2\xd0\x21\x48\xf5\xe6\x92\x12\x76\xa0\x9c\xbc\x2c\xee\xe3\x5e\x92\x6a\x91\xe6\x76\x1f\x5a\xe1\x88\x19\xb7\x81\xf9\xbf\x21\xef\x17\x50\x18\x72\x2f\x05\x8a\xb9\x77\xc5\x7d\xbb\x51\x67\xd0\x79\xb9\x7e\x56\x46\xd6\x43\x3c\x06\xe7\x2f\x80\x85\x54\x54\x84\x42\xe7\x00\x78\xbf\x63\xbc\xb1\x12\xf1\xc1\xb0\xdc\x66\xb4\xbb\x82\xba\xd0\x88\x76\x7f\xba\xc6\xc0\x49\x2a\x1d\x41\x4d\xc3\x71\x82\xd9\x44\x88\x1a\x54\x2a\xb5\x5e\xaf\xd6\xa1\x6e\x14\x05\xf4\x98\xd5\x46\x81\x02\xac\x30\xd3\x4e\xa5\xc8\x3f\x7d\x08\xb7\xb8\x31\xd3\x8a\x29\x64\x54\x8f\x78\x68\x43\x57\x1e\xfa\x94\x41\x72\x59\xe0\x57\x7a\x5e\x4d\x4f\xca\x03\xf4\x2c\xbc\x00\xb1\xca\xb7\x6d\xc3\xc0\xa5\x7c\xc7\xbb\xe9\xbd\x72\x0b\xbd\xef\xa2\xcb\x8c\xa4\x87\x2f\x56\x30\x1a\xf5\xa2\x46\xa5\xd1\x81\x4e\xaf\x37\x69\x8d\x46\x15\x52\x57\x2f\xf3\x4c\x5b\x84\xda\xda\xa2\x14\x46\xa7\xce\xf0\x9a\x3d\x25\x6e\xbb\xc7\xec\xb5\x07\xf5\xc6\x09\x54\x4a\x27\x4e\x84\xf5\x06\xaa\xa4\x90\xe6\xe0\x22\xe9\xf1\x41\xcd\x07\xb2\xac\x46\x56\x10\x04\x8d\x46\xa7\xa2\xd3\x9a\x45\x0d\xdb\xf2\xf6\xda\x9a\x8f\xea\x26\xde\x1c\x54\x4e\xdb\xa1\x87\x72\x6a\x04\x55\x4e\x34\x0d\x65\x3b\xbc\x10\x52\x4f\xd0\x61\xc2\x34\x7e\xc6\x34\xa8\x5e\x17\x78\xea\x21\xa0\xf3\x10\x6a\x69\xa4\x1b\x73\xa3\x02\xe5\xdd\x7c\x76\xed\x29\xf8\xf2\x94\x72\x59\x4c\x87\x59\xca\x03\x24\x12\xef\x1e\x22\x51\xbd\x4e\x99\x94\x43\x6b\x5c\x10\x44\xac\x89\x57\xe9\x75\x8a\x43\x1c\x20\x8c\x9f\x7f\x0e\x69\xde\xc3\xca\x40\xcc\x9f\x19\x61\x5c\x16\xef\xa2\xfb\xfe\x92\x22\x5f\x8c\x9a\xe7\x41\x16\x45\xda\x9a\xaa\x95\xd5\x1a\xfc\x13\x40\x15\xd2\xbd\x57\xb7\x26\x32\xd4\x68\x43\x5f\x59\x86\xec\xc8\xae\x3d\x79\xf9\xf2\xc9\xda\xdb\x6f\xbf\x1d\x71\x14\x0f\x5e\xbc\x78\xf0\xe0\x9c\x39\xb7\x44\x97\x99\x9e\xea\x76\x41\xaf\xd7\xaa\x34\x1a\xad\xd6\x80\x6c\x24\x61\x79\x69\x3b\x75\x7b\x57\x0a\x86\xcb\x29\xba\x94\x9c\x91\x42\x52\xb6\x85\xcb\x88\x54\x72\xcd\xdc\xe7\xac\xad\xd2\x44\xea\x7c\x39\xbc\x4e\xe2\xf5\x9c\x9e\x53\x61\x26\x64\xd9\xa2\x15\x05\xc1\x6c\x41\xc7\x45\xa7\xe2\xb1\x5a\x7f\xe3\xd7\x8a\x2a\x15\x27\x4b\x17\x80\xbb\xc8\xb6\x42\x67\x29\x33\xaf\x8b\x55\xe7\xa0\xfb\x12\x62\xdc\xa2\xc8\xc8\x01\x0f\xdd\xc4\xdd\xcb\x7b\xe5\x34\xaf\x55\x96\x64\x6e\x4c\xdc\xa1\x38\x65\x57\x3c\xac\xfb\xbc\x76\x6a\xbc\x52\xfc\x76\x1f\x73\x5a\x32\x7f\xdd\xbd\xf7\x6e\x82\xfd\x4a\xf5\xfa\xf5\x90\x13\x53\x9c\x82\xf2\x64\x14\xf7\x1c\xf7\x29\xd6\xae\x78\x32\xcb\x97\xcc\x13\x12\x27\xc4\x9b\x8c\x31\x6a\x63\xbc\x9a\x87\x04\x48\xd4\xc6\x43\xbc\x4a\x6b\xad\x22\x26\x70\x89\x26\xba\x3d\x50\x1c\x3e\x99\xe2\xad\x2e\xc9\xf5\x8d\x5f\x92\xac\x44\x67\xfd\xc6\xaf\xbb\x44\xf8\x6f\xfc\xe4\x42\x70\xb1\xef\xd0\x5a\xdf\x41\x3f\x3b\x07\xd5\x54\x4e\x7d\x54\x1f\x6a\xb0\x59\x19\x4b\xc6\x2d\xbb\xe5\xe0\x1e\xe1\xd4\x0c\xce\x28\x4b\x04\x6f\x68\xc7\x79\xd9\xf3\x3d\x5c\x76\x28\xbb\x53\xcb\xfd\x37\xcc\xdf\xf3\xf0\x82\xfb\x8d\xaf\xc9\xf9\x05\xa5\x7d\x4a\x32\x7b\xa5\xbf\x20\xae\xbc\x67\x4d\xfe\xdc\xa9\x2b\xb6\x4c\xf3\x3b\xb2\x73\xfa\xf7\xe9\x5e\x54\x40\x65\xee\xd3\x5c\x33\x2f\xb1\xf6\x80\x1c\x2c\x43\xea\xc6\xa2\x01\x29\xeb\xc8\x45\x95\x28\x89\x88\x29\xc5\x8d\x29\xce\xc8\xf8\x92\x90\x2b\x6d\x29\xa3\xbb\xc9\x1b\x00\xd6\xbd\x13\xfb\xc4\xcb\xca\x2d\x71\x5c\x3f\xc7\x8b\x0f\x70\xcd\x6b\x80\x3b\x74\xcf\x8a\x17\x7f\xc7\x9a\x55\x8f\x34\xba\x28\xae\xa7\x63\xbb\x48\x21\x19\xe9\xcb\x96\xac\xa6\x7c\x4d\x42\x8a\x23\xd3\x64\x72\x68\x78\xbe\x1b\x5f\x64\x93\xd2\x62\x63\xd3\xbe\xf1\xc7\xc6\xe6\x10\x7d\xce\x37\x7e\xfd\x25\x92\x84\x14\xf9\xe2\x1a\x14\x89\xa2\x05\x6d\x04\x62\x82\x87\x51\x41\xb6\x07\xb7\xb4\x67\x3e\x41\x59\x09\x6b\xfe\xb7\x52\x92\x78\x52\x24\xbb\x2d\x46\x66\xe7\x20\x8d\xe0\xd2\xc2\xbb\x47\x0f\x29\xee\xfb\xdc\x96\x3b\xee\x9b\x30\x3a\xa3\xfb\xa3\x37\xe7\x16\x8f\xcc\x2a\xcb\x95\x7b\xf5\x2a\xf4\x16\x0d\x28\x12\xd7\x4f\x18\x39\x60\x82\x96\x33\xd6\xf4\x99\x79\xdb\xf4\xfa\x81\x93\xcd\x9c\xa5\xa6\xfb\x84\x69\xca\x67\xc5\x79\x83\x72\x0b\x33\x32\x96\xf5\x2a\xf2\x14\x76\x2f\x4b\xcf\xa5\xb4\x1b\xcf\xc9\xbc\x46\xd8\x4e\x1c\x48\x3b\x2b\x6f\x33\xa0\x04\xb1\x69\x5c\x4e\xbd\xc5\x22\x7e\xed\xd7\x58\xd8\xe0\x35\xda\x2a\x71\x22\x22\x32\x83\x1a\x25\x88\x9a\x8c\xde\x66\x99\x37\xb8\xa5\x37\xda\x09\x3c\x74\x0c\xd6\x8c\xea\x3d\xc1\xdc\xff\x85\x1b\x9c\xbb\x0d\xbc\xf7\xe6\xaa\xfd\xea\x1a\x4e\x86\xa5\xf9\xe9\xd5\x13\xc7\x29\x8f\x43\xc7\xba\xd9\xfd\xcb\x9e\xcf\xce\x52\x6e\xea\xe8\xe8\xb8\xd0\x31\x83\x7b\x91\xbb\xc3\x24\x8b\x37\x74\x3c\x12\xd8\xc0\x74\x90\xa1\x63\x3a\x77\x9c\x5b\x89\xef\xa6\x77\x3c\x16\xb8\x8f\xb5\x89\x76\x60\xb8\xff\xb0\x77\xb7\x76\xdc\x1f\x58\xcf\xde\x3d\xdb\xb1\x88\x8f\xe7\x6e\x35\xc9\x7c\x37\x48\x0c\xdc\xcf\xe2\xf2\x1d\x33\xb9\x16\x6e\x15\x86\x9b\xd1\xb1\x89\x86\xc3\xfc\xf9\xb0\x16\x3f\x2a\x7e\x4c\x52\x88\xdf\xd7\x4d\xa7\x8d\x4f\x4e\x76\xa0\x36\xd1\xba\x13\x44\x97\xc7\x95\x12\xe7\x4c\x02\x88\x77\xe8\x54\xb3\x9d\x30\xdb\x01\x4e\x87\xd3\x61\xda\xa0\xda\xa1\xe2\x6a\x54\xa0\x4a\x26\xa8\x3c\x8a\x0a\xea\xeb\xbd\x54\xbc\xd4\xd7\x87\x5b\x39\xbc\x50\x10\x2a\xc5\x10\x35\xdc\x56\x5a\x6c\x96\x54\xca\xd0\x22\xe3\x62\x6a\x25\xc5\x78\x19\x9b\x07\xff\x60\xfa\xf0\xc3\xc7\xb6\x83\xee\x99\xbd\xaf\x2b\x6d\x95\x43\x46\xae\x1d\x33\x64\xec\x10\x6e\x7e\xaa\x32\x2b\x13\xa6\xa7\x2a\x5b\x72\x60\x6f\x1a\x6c\x3d\x7b\x66\x3f\xf4\xde\xb7\xef\x11\xbd\x71\xc0\xc8\xd5\xbf\x2c\x5c\x32\x13\xee\x3e\xf2\xde\x91\x2f\x8e\x20\x1f\x4e\xee\x58\x2e\x5e\x12\xdb\x08\xed\xf3\xca\x25\x0b\x7d\x95\x24\xdd\x6d\x12\xcc\xc9\x66\x8b\x98\x95\xad\x15\x74\x82\x4e\x9f\xe8\x72\x5a\x05\x4b\x52\x52\x32\x97\xea\x31\x08\x7a\xd4\x34\x19\xb2\x2c\x24\xeb\xe3\x2d\x92\x3d\xcf\x9e\x9f\xed\x8c\x89\xcb\x72\x49\xe9\x9e\xc4\xf4\x06\x7f\xa2\x55\xeb\x69\xf0\x6b\x85\x4e\x1e\x75\x44\x33\x67\xe8\x7a\xc5\xb9\x5b\xa1\x98\x9e\x81\xc2\x26\xdd\x8c\x99\xa5\x7d\xb6\x31\x8e\x32\x7a\xc2\xb7\x50\x5a\xe6\xe0\x44\xd9\x03\x78\x1b\xe3\x00\x9b\x03\x24\x8e\x2b\xea\xdf\xa7\xff\x73\x53\x5e\x7f\x05\xc6\xfd\x25\xef\xb9\xfc\xc1\xbd\x7a\x3c\x37\xa6\xa9\x9b\xf2\x93\x2e\x56\x79\xf8\x8d\xf9\x5f\xbd\xab\x0c\x28\x78\x8e\xcb\xef\x39\x58\x99\x55\x3c\x58\x51\x9c\x50\xf5\x74\x8b\xac\x71\x6d\xff\x71\x3b\x14\xfe\x04\xb7\xff\xd9\x30\x75\xa6\xda\x72\xd7\x3b\x37\xbe\x32\x30\x37\xa7\xfd\x68\xce\xe9\xf9\xca\x26\x79\x96\x68\x8c\xe7\xdb\xc7\xa5\xea\xe0\xc6\x71\x95\x5c\x6b\x89\x72\x92\x96\xf1\xe4\x8e\xbf\x23\x6d\x1e\x24\x39\xa4\xd6\x97\x97\x26\x8a\x49\x09\x46\x63\x52\x8e\x4a\xc8\x75\xc4\xc4\xe4\x65\x71\x0d\xfe\x94\x34\x99\xd7\x3a\xac\x59\x59\x5a\xab\x35\xb6\xc1\x6f\x15\x92\x44\xad\x38\xd1\xaf\xb5\x86\x05\x43\xa8\x92\x5a\xca\x31\x97\x39\x9d\xfd\xc5\x21\x66\xc7\x02\xe5\x65\xcc\xa0\x24\x78\x52\x52\xb9\x60\x49\x0b\x0e\x31\x1f\xad\x62\x62\xb6\x39\xac\xa5\x65\x6e\x29\xb4\xad\xbd\xf0\x63\x71\xce\xbf\xfa\x69\x5e\x9a\xff\xd5\x34\x65\xff\x9f\x8f\x29\x7f\x5f\xff\x21\x2c\xfe\xf9\x5b\xc8\xf0\x2a\x3f\x25\xec\x9a\xff\x8b\xf2\xe3\xee\xbe\x2e\x33\xe8\xec\x6a\x61\xd0\xfd\xe3\xe3\x0b\xb9\x19\x5a\xe5\xf1\xd2\xbc\x37\xe7\x1f\x39\xb2\x01\x74\x7f\x6a\x87\xfb\x3e\x3a\x79\x7c\xe0\xcc\xdb\x94\xfd\xca\xa5\x5f\x47\xc2\xd8\xc5\xab\x1e\xef\x75\xd7\x4c\x55\xd0\x57\x46\xef\x50\xf8\x07\xca\x39\x33\x69\xf4\x15\x73\x26\x93\xd5\xa0\x35\x6a\x54\xa2\x80\x1a\x59\x4d\x8c\x46\xb5\x46\x63\xb1\xaa\xb4\x06\xed\x42\xbf\x68\x00\x61\x92\xdf\x00\x06\xd0\x18\x8d\x64\x92\xdf\xc8\x6b\x2c\x37\xdd\x4c\x1b\x99\x82\x59\xc5\xbc\x16\x84\xfd\x89\x4e\xa5\x12\x6e\x6b\x0a\xe6\x9a\x0f\xf1\x2e\xef\xb6\x7a\xca\x28\x2f\x73\x39\x43\xb9\x65\x99\x81\x55\x69\xd0\x23\x41\x39\xe5\x55\xbe\x2e\x5a\x99\xb0\xf2\x75\xfe\xa5\x4c\xe1\x4f\xca\xbc\xf7\x5f\xdd\xac\x28\xc0\x6d\xe6\xff\xf6\x3e\xc3\xf5\x34\xe2\xfa\x20\x96\x49\x2e\x69\xf6\x4d\x49\x4d\x4b\x33\xc4\x39\x1c\x31\x46\x83\x21\x9f\xf0\x82\x2c\xa8\x72\x73\xb3\xb2\xf2\x12\x62\x5d\x31\x82\x3d\xd1\xae\xca\xcd\x26\xd9\xc9\x59\xc9\xf3\xfc\x89\x59\x09\x09\xc8\xec\x0b\xfd\xb1\xbc\x3d\xc6\x12\x23\xbb\x30\xec\x42\xbf\x4a\xf6\xf1\xc3\x79\xae\x40\x7e\x5e\xe6\x78\x99\x97\xb5\x59\xce\x02\x23\xf0\x46\x23\xa8\x45\xa3\x45\x6b\x99\xef\xd7\xca\xa1\xf6\x53\xcc\x0f\x2a\x9d\x86\x7a\x67\x85\x25\x58\x69\xcd\xe5\x9d\xda\x33\x94\xdd\xf2\xd0\x05\x90\x08\x05\x5d\x19\xde\x6b\x29\xef\xb4\x1e\xca\xbc\x65\xf4\xa0\xe5\x1a\xe3\x90\x69\x69\x4b\x46\x08\x57\x68\x49\x76\xa3\x17\xe4\x40\xcf\xc8\x5d\x56\x5a\xf6\xc5\x4b\xf1\x87\x6d\x87\x12\x0e\xda\xd3\x2e\x9e\xda\xff\x81\xf9\xdf\xc6\xeb\x07\x0e\xab\xb5\xb9\x20\x21\x41\xf9\x4b\x0c\x24\x26\x28\x7f\x96\x32\x8f\xc1\xd6\x86\x85\xce\x3f\x67\x7f\xbd\x27\x50\x9a\xf1\x5a\x2a\xb4\x6f\xbe\x65\xf3\xbc\x33\xaf\x3c\x76\x5f\x61\xed\xa0\xf1\xd3\x6f\xc3\xa7\xc4\xe3\x83\xc6\x4e\xc9\x78\xb1\xe5\x74\xcd\x49\x26\xbb\x3c\x1d\xbd\xa4\x37\xc5\x2c\xd2\x8d\x4c\xf0\x15\x15\x64\x26\xab\xdd\x2a\xb7\x20\x7a\xa4\x14\x59\x56\xc5\x5a\x2c\x56\xab\x4a\x4c\xc9\x14\xbd\x45\xc4\x90\x68\xb8\xde\xef\x49\x8e\x95\x04\x4b\x9a\x3b\xd1\x14\x63\xcc\x55\x89\x16\x3b\x1a\x10\xa7\xbc\x15\x15\xa7\xbc\x8c\xa9\x49\x97\xfd\x37\x58\x31\x17\x05\x2f\x74\x64\x13\x4a\x72\x77\x19\xef\x81\xb2\xb0\x5c\x77\x53\xae\xb6\x85\xd9\xda\xea\xe5\x83\xea\x9a\x7d\xe8\x0d\xe9\x62\xf6\xb8\xbb\x62\x17\x2a\xdf\x1b\xb6\xec\x82\x4d\x76\xf3\xed\x63\xd6\xc6\x2d\x50\xbe\xdd\x6d\xb3\x82\xc9\x2e\xf3\x43\x37\x4f\x79\x64\xf0\xfe\x5d\xcf\x4f\xbd\xe7\x9e\x8d\xf6\x15\xca\xf7\x4b\x2c\x3c\x7f\xdb\xc3\xab\x02\x8f\x0f\x56\x7e\xe1\x3e\x98\x35\x2e\x6f\xf1\x96\xb5\x81\x9d\xfc\xf5\x0d\x6b\xb4\x77\x66\xcd\x1b\x33\x01\xcd\xcf\x37\xc7\x3f\x70\x8f\x6f\x72\x60\x2e\x37\x77\x6c\x37\x91\x6e\x63\x86\x16\x27\xed\xa9\x36\x20\xbf\xc7\x91\x24\x42\x97\x5b\xc8\x22\xf7\xf8\x06\xa7\xa6\xc7\x27\x09\x22\x6f\x32\xc9\x16\x77\x4a\x66\x96\xc8\x99\xcd\x12\xe2\x6b\xb3\x71\x76\x64\x31\x4c\x3c\x5b\xaf\x56\xe7\xd8\x2d\xe9\x56\xa3\xc3\x91\x1c\xaf\x73\x7a\x92\xb4\x71\x71\x19\x68\x28\x3a\x49\x66\x26\x71\xf2\x5c\xaa\xd9\x22\xf1\x59\xd4\x1f\x44\xea\x50\xe2\x14\x50\xe3\x31\xd8\xe3\xed\x8d\xdc\x54\x44\x8b\x01\x6f\x97\x46\x57\x26\x0a\xad\x58\x25\xe8\x1f\x5a\x5d\x1e\x19\x0f\xb4\x82\x43\x55\xa5\xcc\x23\x7a\xcb\xdc\xa2\x37\x03\xc9\x89\x2e\x72\xc6\xe2\xd9\xc3\x60\xc2\x2a\xb8\xbd\x06\xa4\x61\xb7\xe6\xcc\x89\x9b\x9f\x33\x6f\x94\xb2\xed\x5e\x65\xcb\x28\xa5\x75\xd4\xec\x9c\x59\x71\xb7\xf0\xbd\x4f\xc4\x29\xff\x52\xaa\x5b\x73\x5f\xe4\x46\xd9\xc6\x29\xb6\x21\xa5\xfc\x3f\x60\x03\xba\x16\x78\x7c\xb6\xf6\x33\x65\x08\x1c\xa0\xc7\x67\x6b\xe9\x2f\x70\xea\x1c\xd7\xfb\x19\xac\x26\x3d\x3b\xfe\xae\x5a\x8a\xf4\x49\x23\x43\x48\x2d\xe7\xf4\x75\x54\xf4\x29\x1a\xdc\xbf\x7b\xf7\xec\xac\x54\xb7\xdb\x29\x18\x12\x47\x38\x5d\xae\x11\x86\xac\xc1\x62\xdd\x28\x4e\x02\x93\xd6\xec\x49\x71\xfb\x86\x3a\xe6\xfb\x8d\x43\x93\x86\x56\x0c\xad\x19\x7a\x66\x68\xc7\x50\xc9\xc0\xf7\xec\xbb\xc8\x0f\x16\xb7\x65\x91\xbf\x67\x6a\xaa\x7b\x28\xfe\x49\xb1\xe9\xf9\x8b\xfc\xe9\x2e\xad\xb4\xc8\xaf\x75\xb9\x9c\xb1\xb5\xf3\xfd\xb1\x12\x8a\x90\xbb\xea\x60\x61\x1d\x4c\xad\x83\xd1\x75\x50\x59\x07\xc5\x75\x90\x56\x07\x8e\x3a\x68\xae\x83\xdd\x75\xb0\xa5\x0e\xee\xae\x83\x29\xec\xeb\xc0\x3a\x28\xad\x83\x74\xf6\x55\xae\x83\x5f\xeb\xe0\xbb\x3a\x38\x54\x07\x4f\x85\x83\x05\xe1\x38\xd9\x57\xcd\x8c\x3a\xf0\xd7\x41\x55\x1d\x94\xd7\x41\x56\x1d\xc4\xe2\xab\x3a\x68\xab\x83\xef\xeb\xe0\xcd\x3a\x68\xa9\x83\x67\x58\x9c\xc9\x75\x30\x8a\x25\x5c\x56\x07\xaa\x3a\x98\xf1\x7b\x1d\x9c\xab\x83\x37\xea\x60\x6b\x1d\x2c\xf0\xcd\x66\x10\x23\x01\x32\x18\x74\xa9\x0e\x7e\xab\x83\x8f\xeb\xe0\x14\xc3\x12\x93\x7f\xb0\x0e\xee\x62\x28\x62\x00\x3b\x0b\x10\x44\xee\x14\xc3\x6f\x37\x0b\x10\xc4\xaf\x2c\x2a\x03\x3d\x30\xad\xb3\x75\x70\xbc\x0e\xc8\x0b\x75\x00\x3b\xea\x68\x83\x4f\x03\x6b\x76\x99\xf0\x07\x3d\x87\x7f\xd4\x42\xfc\xc7\x9d\x85\x51\x91\x72\xc2\xdb\xe7\x84\x8d\x48\x2a\xb4\xcd\x5e\xd3\x09\x26\xb8\x09\xb5\xad\x49\xac\xd3\x44\x27\x40\x94\x07\x7d\x83\xce\xdd\x75\xcc\xd1\x1e\x25\x78\x78\x89\x36\xda\x84\x26\x46\x14\x97\x21\x93\x1a\x20\x07\xb0\xba\xbb\x59\x9d\xf6\x52\x13\xce\x1a\xb6\xc3\xfb\xa0\x86\xcb\x87\x8c\x50\xe3\xb4\x43\x4e\x67\x26\x68\x12\x30\x03\x35\x68\xa7\xe7\x80\xf8\xc8\xc6\x4a\xb9\x7f\x5a\x5e\x52\xe5\xe0\x19\xd3\xd4\x83\x26\x58\x07\x9f\xdf\xbc\x66\xe6\x3f\xc0\x02\x3d\x3e\xf9\x7b\x8f\x01\x77\x2f\x2b\xd8\xf8\xdb\xb3\xcf\x19\xdf\x55\x0f\xaf\x49\xef\x5b\x18\x1f\x5f\xbe\xfc\xeb\x63\x07\x37\x3f\xa7\x3a\xa3\x59\x7a\x7d\xaf\x85\x43\x16\x2d\xfd\xa0\xb5\xc2\xbf\xed\xf1\x5f\x2a\xb9\xbb\x94\xcd\x99\x31\x03\x0c\x8f\x3a\xa7\x8d\xce\xcc\x83\x3b\x46\x4f\x1c\x13\xf8\x5c\x5c\x79\xf2\xc8\xf2\xba\x5f\x7e\x69\x3f\xba\x70\xb9\xa7\x57\xa9\x64\x4d\x89\x8f\x49\x74\x26\x97\x36\x2f\xb9\x6d\xf1\xb2\x98\xc9\xc9\x29\x45\xb1\xe6\xd8\x79\x75\xf7\x6d\xe2\x7e\xbf\x77\xd5\xe9\xe0\x38\xdb\x8e\xbf\xab\x77\xb1\xb6\x8b\x12\xd6\x22\x53\x27\x2e\xa2\xed\x37\x1d\xe7\xe9\x5e\x66\x58\x47\xa8\x04\xa1\xf3\x42\xf3\x51\x9a\x16\x93\x8d\xbe\xa1\x22\xe4\xab\x55\xc5\x71\xb1\xdd\x74\x7a\x34\x13\xf4\xb1\x2a\x10\x8d\x89\x49\x49\xa5\x56\xa3\xb1\xa4\x30\x4f\x2b\x1b\xa7\x19\xc1\x98\x99\x9a\x2c\x98\x72\x32\x3c\xbc\xd5\x5a\x14\xef\x24\x36\xa3\x0d\x54\x26\x9b\xd7\x6b\x33\xf1\xfa\xe2\x58\x3e\x31\x86\xcf\xef\xd6\x4d\xad\x47\x3b\x91\x92\x9b\x39\x6c\x4c\x9c\x4c\xa8\x67\x72\xa4\x53\x9a\x78\xbd\xc1\x37\x11\x17\xb2\x53\xb0\x84\xdd\x60\x08\x0a\x12\x77\x50\x90\xf0\x28\x48\x32\xf0\xe0\xdd\xd6\xd0\x1f\x04\x05\x8b\x87\x09\x16\x8f\x23\xcd\x23\xe3\x1b\x79\xc6\x9a\x9c\x63\x7d\x7e\xce\x51\xce\x9f\x52\x9e\x30\x2a\x9f\x1e\x51\xb6\xc7\xb7\xe6\xbc\xa6\xda\x93\x73\xab\x0b\x9c\x66\x18\xbd\x07\x7a\x19\x60\xe8\x4e\xf0\xfc\x67\xff\xf3\x3d\x2e\xf3\x35\xfb\xba\xff\xa0\xd4\x9d\x10\xef\x84\x77\x87\x8b\x01\x32\x14\xb8\xa4\xee\x02\xff\x8f\xcf\xd6\x7c\xa6\x54\xc3\x41\x7a\xe0\x6d\x58\xf2\xc0\x86\x80\x61\x0d\xfd\x29\x8f\x9e\x3b\x77\x8e\xb7\x1e\x41\x7f\x76\x18\xca\xe4\xef\x85\xf3\x68\x83\x24\x93\x9e\xcd\xb2\x55\xb6\x5a\xcc\x71\x7d\x8d\x50\x8e\x5e\x62\x0f\x7c\x6b\x80\xeb\x88\x9f\x98\xf1\xd9\x42\xec\xec\x1e\x59\x22\x64\x65\x52\x6e\x36\x33\xbd\x1c\x6e\x90\xe4\x3d\x16\xe6\xf6\x61\x76\xe3\x38\xcc\x6b\x51\x1f\x28\x43\x5d\xc3\x11\x0f\xbf\xf4\xfd\x03\xce\xb2\x6f\x7a\x69\x1a\x56\x2a\xef\xbc\xf5\xcd\x3f\x76\x6e\xfb\xee\x56\xe8\x3d\x7f\xfe\xa0\x84\x95\xdf\xdd\xd9\x53\xf9\xa5\x55\x38\xbf\xed\xd9\xf1\x4b\x95\x6f\xa1\x8f\x3f\x61\xc2\xf0\xb6\x76\xe1\x7c\x5b\x06\xef\x0e\x1c\xe8\xbd\x71\x2b\xb7\x2d\x30\x52\xf9\x44\xe9\xa0\x7d\x28\x23\xc8\x2b\x42\xb5\xf8\x2e\x49\x44\x4b\xa4\x90\xdc\xe8\xeb\x4e\x52\xf5\x46\x8b\x68\x8d\x8f\x8f\x8b\xb3\x3a\x6d\x39\x52\xa1\x64\xca\xb7\x89\x31\xdd\x62\x8a\x92\xf8\x0c\xa7\xc9\x64\x37\xeb\x12\xe3\x79\x0d\x4f\x67\xcb\xf0\x1a\xb3\x19\x7d\x3c\x6b\x5e\xa1\x15\x48\x45\x41\xa8\x70\x73\xc2\xb6\x7f\x91\x39\x7a\x80\x70\xd8\x84\xc2\xbc\x85\xda\x4b\x99\xea\xf4\x96\x32\x2b\xc2\xcb\x74\x84\x24\x7b\x8a\xcb\x32\x58\x15\x0b\x79\x09\x22\x1a\x13\xdc\x9a\xd2\x79\x23\x6f\x5a\xee\x7f\xfc\x96\x17\x73\x04\x4d\xdc\xdb\x31\xa7\xad\x27\x6c\xf5\x8e\xf1\xb7\x1b\xe4\x93\x9a\xa7\xca\x46\x94\xbb\xaf\xbb\xae\xdf\xd8\x22\xe5\x77\x9e\x77\xb5\x07\xb8\xac\x01\x3d\xd7\xcd\xbd\xe3\xd7\xd5\x77\x0d\x5d\xbb\xb0\xb1\x71\x61\x60\xda\x90\xd1\xde\x3e\xaa\xc2\x49\x1b\xbc\x23\x06\x8d\x39\x54\xbd\xe9\x97\x3b\xd0\x76\x88\xef\xf8\x49\x78\x05\xed\xaf\x4c\xb2\xc8\xd7\x57\x50\x6b\x2d\x69\x69\x2a\x89\xd7\x6a\x93\x13\x13\xe2\x5c\x4e\x67\x76\x96\xd6\x15\xeb\x42\xd3\x2a\x56\x4a\x4c\x4a\x5c\xe8\xe7\x93\x8c\x49\x05\x49\x15\x49\xcf\x27\x09\x5a\x3e\x36\x29\x36\xc9\xee\xf1\x90\xb9\x7e\x8f\x6c\x37\xce\xf5\xdb\x5d\xa4\xab\x14\x6a\xa0\xfc\x1d\xb4\xab\xa2\x2c\xc8\x30\xaf\x47\x7a\x56\xd1\x8e\xc0\xdc\xb1\x93\xcc\x66\x66\x51\x73\x29\x85\x33\x23\x3d\x18\x51\xd0\x8e\x4e\xb6\xa2\x19\xcd\x7b\x66\xde\x9e\x0a\x99\x09\xca\x59\x83\x08\xa5\x09\xca\xfb\xfc\x98\x21\x77\x97\xff\xd3\x7b\x61\xe7\x5f\xbe\xbc\x2f\x69\xb9\x5a\x73\x7b\xf2\x5d\x83\x21\xe3\x6f\xe0\xb7\x29\x1d\xda\x7e\xc2\x91\x4d\x1b\x37\x97\x94\x6e\x1e\xb0\x6c\xfe\x8a\xcc\xad\x0f\x81\x0e\x84\xcd\xfd\x33\x36\x83\xa8\x28\x1f\x15\xf4\xed\x13\x6c\x87\xe5\x90\x4f\xfb\x61\xbd\xb7\xa1\xcf\x9e\xa5\xd7\x19\x68\xc3\x8a\x4e\xcd\x9b\x25\x59\x8e\x11\xcc\x66\x1b\x58\x2c\x76\xa3\xd6\x46\x6c\x0d\x7e\x34\x0d\x08\x87\x0e\xaf\x14\x34\x09\x3a\xdb\x5c\x3a\x47\xc2\x45\x6a\x6c\xa8\xfd\x82\x76\xaa\x79\xc1\x4d\xad\x41\x3c\x7b\xa8\x55\xe4\x29\xd8\x3a\x0b\x32\xe6\x0e\xe6\x1e\x83\x39\x81\x5a\xce\x98\xa7\x0c\x86\x29\xca\x11\x65\x6f\xff\xc7\x6e\x54\x2e\x2c\xd8\xca\x0f\xe5\x8a\x03\xef\xd2\xe3\x87\xc0\xa3\x5c\x63\x7d\xa0\x8d\x6b\x44\x3c\x07\xa2\xa1\x33\x15\xf1\x74\x90\x4a\x5f\x86\x5e\xa3\x96\x04\xd1\x60\x30\x59\x6d\x0e\xc1\x28\x12\x62\x34\x03\x62\x29\x4b\xbc\x93\x77\x21\xd7\x02\x07\x0d\x7e\x8a\x65\x67\x73\x46\xd8\x6e\x75\x94\x17\x85\x98\x8f\x36\x69\xb8\xe5\x34\x59\xa4\x07\x5a\x75\x62\x59\x1a\x3d\xb8\x21\x4a\x79\xae\xd0\x9c\xab\x74\xcf\x83\x09\xf9\xca\x13\xc9\xec\xdc\x4b\x39\x9f\xae\x1c\xc9\x87\xca\x64\x7a\x1e\x20\x6c\xff\xfa\xeb\xef\x97\xff\xb0\x7c\x17\x1e\xca\x1b\xa7\x16\xfc\xb0\x60\x17\x1e\x88\x62\xc7\x51\x65\x86\x6a\x96\x94\x8b\x35\xbc\x94\xf4\x23\x23\x49\x3d\x59\xec\xeb\xd7\x93\x0c\xb6\xf7\x55\xa9\xd4\xd7\xa7\xe5\xc6\xf5\xcf\x2e\x54\x0f\xb5\x94\xd8\x89\xbe\xc1\x9f\x9c\x3c\xa1\xb7\xb1\x2e\xae\xbf\xd8\x3f\x9d\xf7\x24\xe4\x1a\x3d\x1e\x63\x2e\x6f\x49\x28\xe3\xf9\xf1\xd7\xab\x13\x2c\x95\x2e\x4b\xf6\xd0\xa1\x96\xe2\xe2\x42\x0b\xa5\x38\x1d\x6c\xcf\x84\xe7\xa9\x48\x1d\xa2\x16\x19\xcb\x59\x51\xf4\xf0\xdd\x88\x42\xa3\x0d\x25\x19\x06\x90\xdd\xa5\x65\x56\x66\x9e\x33\xe5\x84\x52\x23\x25\xa3\xb3\x5b\xd5\x11\x8b\x4e\xa9\x20\x97\x95\xa6\x96\xf5\xe1\xca\xbc\x12\xa0\x70\xa1\xc6\x2d\xf3\xcd\xd3\x90\x1d\x89\x85\xd6\x42\x2c\x75\x03\x30\x5f\x2e\xd8\xc4\xa2\x9a\x75\x66\xef\x4d\xde\xda\x51\xdd\x94\xaf\x7b\x97\x7d\x58\xf5\xc9\xe3\xb7\x6d\x68\xcf\x7f\xf3\x64\xab\x72\xcf\x2b\x2d\x7b\xb6\x6e\x1b\xea\x5f\xd8\x98\x51\x67\x7d\x61\xc7\xbd\x83\x95\x8f\x1e\xd4\x36\x42\xc9\x82\xf9\xc3\xc6\x56\x4e\x9d\x02\x6f\x78\xfd\x15\xd5\xe5\xe3\xcb\x33\xdb\xd2\x17\x2f\x7d\x10\x0c\xcf\x8c\xaf\x1b\xf0\xe4\x82\x19\x6b\x94\x0e\x57\x75\x72\xd9\x75\xc5\x9e\xb9\xb0\xea\xc0\x99\x41\xef\x7d\xe0\x1b\xba\x0a\x7e\x7c\x7a\xf3\x02\x7e\xb5\xf6\xc2\xc5\xb7\x15\xaf\xf2\xfd\x1d\x77\x8c\x1a\x70\xfd\x4d\x56\x3d\xec\x82\xaa\xb7\xae\x4b\xe9\x5e\x92\x51\xa6\x1a\x99\x97\x6e\x1f\xd1\x3a\xab\xf1\x95\x7e\x13\xc7\x3c\x39\xac\x57\xef\xb9\xf5\x10\x03\xa7\xde\xbd\x7f\x5b\x5f\xe5\x17\x25\xf0\xb7\x1f\x93\x2c\xf6\xbe\x65\xa9\x19\xb4\x1d\xf8\x31\x65\xb4\xf0\x02\xd6\xf5\x64\x92\x4d\x86\xf8\x32\xad\xea\xac\x24\x7d\x92\x9a\x4f\xe5\xf9\x5c\xa7\x2b\x27\xce\xee\xe0\x5d\xee\xd8\x58\xe2\xb2\xc4\x58\xb5\xa6\x49\x7e\x6d\x1c\xc9\x98\xe4\x27\x42\x94\x54\x46\x96\xa7\xae\x2f\x92\x9a\x12\xdc\x1b\x19\x5a\x40\x85\x34\x27\x5b\x63\xec\x26\x77\x4a\x78\xa7\xbe\x0c\x3e\x03\xb9\xde\x51\xc6\xa5\x97\x98\x80\x92\x14\x25\x99\xdd\xc6\x6f\x59\xbd\x65\xd7\x47\x49\x7a\x65\xf9\xea\x31\x39\x35\xd5\x83\xaa\xb4\xef\xcd\x99\xac\x5c\x86\xc6\x55\x4f\x27\xaa\x40\x7d\x7d\x63\x56\xfa\x7c\xf1\xc1\xfb\x97\xcc\x53\xbe\xfa\xbb\xf2\xd4\x43\x3d\x95\xb9\x96\x8b\xe9\x0d\xf3\xdd\x5f\x2a\x3f\xbf\xb6\x1b\x7e\x78\xe5\x0c\x24\x6f\x4a\x87\xa3\x81\xe9\x2b\x0e\xf5\xcd\xcc\xfb\xb8\x11\xdd\x47\xb6\x6f\xd1\x79\x66\xff\xa7\x10\xba\x76\xe7\x13\xbe\x09\x59\x69\xf1\xf1\x3a\x5e\x72\xda\x24\x9b\x45\x23\x08\xf9\x56\x2c\x66\x21\x2e\xce\x92\x99\x94\x9c\x9e\x61\x92\x72\x73\xcd\x66\x4b\x5e\x86\x29\x5d\x67\x73\xda\xc0\x96\xac\xb6\x27\x49\x4e\xa7\x13\x9c\x99\xbc\x6b\x83\x09\x36\xd8\xa1\xc0\x0e\x5f\xba\x60\xb9\x6b\xbd\x8b\x23\x2e\x93\x8b\x33\xd9\x5d\x2e\xbb\x89\xb7\xe4\xc6\xf1\x16\xda\x57\x10\x92\xf1\x41\xab\x8c\xd6\xf7\x39\x41\x0d\x1d\xba\x06\x29\xc4\xb8\x31\xe2\x31\x46\xa4\x3f\xa3\x98\xe0\x40\x41\x4f\x8d\x2a\xd9\x23\x09\x9e\x88\x4b\x80\x1e\x34\x14\x67\x60\xcd\x2c\x15\x8b\xe8\x20\x40\x37\x55\x7a\x23\xdf\x07\x48\xdf\xe0\x98\x2e\x35\x38\xa6\xf7\x56\xbe\x7b\x59\xb9\xbb\x5e\xf9\x6c\xeb\x2a\xc7\x2a\xd3\x2a\xc7\xea\x1e\xdc\x7f\x20\x70\xd1\xc4\xe5\x4b\xca\xc9\x67\x86\x07\x7e\x35\x0d\x87\x2f\x2a\xd6\x29\xad\xe2\xca\x47\xef\x5f\x0c\x39\x19\x8b\x9b\x9e\x54\x52\x79\xd3\xe2\xeb\x17\x43\xae\x32\x58\x27\x5e\x9f\xf8\xd7\x11\x23\xe0\xc1\x81\xc1\xf1\x47\x93\x3b\x8a\xc4\x56\xc9\x88\x7a\x2f\x8d\x2c\xf0\xf5\xd7\xa9\xad\x9e\x14\x5b\x22\xa7\x02\x8d\x96\x40\x92\xe8\x88\x15\xc1\xa9\x35\xc6\x4a\x19\xe9\x26\x13\xa7\x73\x39\x27\xf9\x5d\x2e\x4e\xa7\xd3\x4c\xf2\x5b\x3d\x6a\xcf\x44\xbf\x4e\x2d\x70\x29\xb4\x9d\x88\x43\x09\xc9\xc1\x24\x3f\x67\xa1\xbd\x91\x21\x86\x09\x75\x46\x76\xb6\x6c\x3a\x0b\xba\xd8\x9f\xc1\xc6\x22\x4f\x19\x5a\x63\xa1\xa6\xa2\x44\xa0\x0d\x26\x19\x7c\x69\x05\x78\xca\xdc\xbc\x24\xc8\x60\x8b\x71\x58\x25\x8e\x3b\xff\x54\xfa\xcf\x4a\xfb\xab\xd0\xf8\x83\xf3\x29\xd7\x21\xa5\x50\xf9\x36\x6e\xe5\xf8\x57\xdf\x5a\x9b\xff\x4a\x06\x9c\x9e\xde\xa4\x7c\xf8\xb2\xf2\xc0\xca\xf9\x2f\xbf\xf3\xdd\x7b\x27\x53\xa1\xec\xdf\x97\x61\xe1\x67\xfa\xa5\xcb\xed\xa7\x76\x0f\x6b\x5c\x60\x6c\xcf\xd5\xd6\x7e\xfd\x7e\xe0\xcd\xc9\xe3\x39\xee\x86\xa6\xa3\x49\xfc\x29\xb7\x72\x0c\xf5\x3e\x6d\x2b\x91\xac\x4c\xae\xc6\x61\xbd\x58\xe1\x1b\xa4\xd7\x59\xec\x31\x46\x70\xc6\xc5\xab\x78\x33\x9f\x94\x10\xeb\x32\x08\xb2\x4a\xab\xd2\x71\x5c\x92\xd5\x91\x44\xbb\x8c\xcc\x62\x8a\xc9\x6c\x76\x1b\xb5\x56\xab\x53\x65\x8b\x93\x1d\x8e\x78\xac\x24\xc8\x47\x09\x84\x24\xd8\x78\x4e\x6f\xb6\x24\x85\x75\x44\x90\x4b\x42\xe5\x1e\xbe\x80\xf7\xda\x8d\x67\xb4\xc5\x1b\xdc\xb4\x39\x90\x32\x87\xb5\xd3\x53\x74\x8b\xee\x0c\x77\x99\x97\x2b\x91\xaa\xe1\x4e\x70\xc1\xf8\x51\xb0\x38\x4b\x39\x1b\xff\x4b\xd6\xae\x52\xe5\x42\x69\xe0\xbd\x3d\xca\x67\x7f\x7a\x2e\xeb\x3f\xf5\xca\x9b\xd0\x0a\x7b\x9c\xca\xc9\xd9\x7b\x53\x9d\xfc\x3d\xf0\x9b\xa2\x3e\xfb\xd4\x59\xe5\x38\xf4\xa6\xc7\xd9\xa7\x9e\x7a\xea\x2c\x90\xc4\x81\xc1\x76\xa2\x40\xc7\xdf\xc5\x75\xac\x3d\x6c\xa9\xaf\x1f\x67\x48\x48\x94\x55\xce\x94\x9c\x14\x55\xa2\x21\x46\x32\xa5\x9a\xf2\x52\x73\x9d\xa9\xa9\xf6\x34\x4b\x4e\x8e\x11\x33\x66\x4a\xe0\xd4\x62\x42\x72\x9a\x6c\x42\x8b\x47\x26\xda\x34\xe4\x98\x64\x6d\x72\x1c\x8a\x71\xab\x56\x98\xd4\xa5\x91\x30\xe8\x83\xd0\x16\x14\x4b\x39\x33\x02\x22\x9e\x06\x78\xbb\x8c\x4e\x62\x59\x0e\x36\x25\xa4\xa1\x84\x4e\x8e\x49\xa0\xe6\xad\x24\x52\x5b\x80\x3a\x19\x65\x22\xe7\x4e\x36\x97\x20\x0d\x50\x36\xbb\x17\xf2\xdb\xbe\x9b\x7c\x77\xae\xf2\xfd\xf0\xb6\xef\x40\x0a\x8c\xc9\xda\x7f\xb7\xf2\xc6\x03\xdc\xf9\xac\xf6\x41\xdc\x9d\x1b\xfe\x36\x15\xe2\x5e\x54\x52\x15\xa1\x36\x73\x75\xe6\xf2\xc7\xf6\x07\x9e\x17\xf4\xa6\xa7\x8b\x7a\x94\x34\x2d\x3c\xf0\x62\xca\xd9\x39\xd7\x25\x9d\x9d\xd1\xb8\xb2\x9b\x72\x16\xd6\xc7\x9e\xed\x56\x59\x92\x1e\xe6\xff\x4b\xc8\xff\xb1\xc4\x4d\xea\x7d\xa5\x2a\xb5\x2b\x36\x8e\xe7\x63\x49\xa2\xd3\x92\x24\x9b\x35\x6a\xbb\x4e\x9f\xa2\xf7\x38\xad\xe6\x24\x39\x69\xa2\xdf\x66\x20\x1a\x8d\x6a\x92\x5f\x23\x0b\x89\x16\x62\x69\xf0\x93\x58\x94\x90\xb4\x79\x30\xa8\x69\xbd\xa1\x0e\x8d\x2b\xd5\x2e\xcd\xa7\x98\xce\x5d\xc5\xe4\xb4\xad\xd0\x88\x7e\x57\x88\xc5\x07\x7e\xa3\xd0\x46\x50\xe4\xef\x57\x7f\xc9\x51\x7e\x8a\x5f\x31\xf6\xd5\x4b\x77\x7e\xd5\xa8\x1c\xfb\x30\xf5\xa9\x0d\xb7\xce\x79\xf9\xe4\x67\x5a\x37\x74\xfb\x85\xb5\x7a\x22\x6b\x9f\x7c\x7a\xe0\xc4\xb9\xc6\xf6\xfc\xb8\xaf\xe6\xff\xe9\x65\xe9\x25\x5e\x7b\xef\xc1\x04\xfe\x94\x47\x39\xdc\xd1\xa1\x5c\xe4\xdf\x84\x5f\xa4\xd7\xd1\xc3\xd1\x2b\x77\xd2\x7d\x5b\x51\x4e\xae\xea\xf8\x87\xf4\x67\xb1\x09\xf3\x9a\x4d\x7a\x90\x3e\x98\xdf\xee\x45\x19\x1c\x6f\x31\xbb\xd4\xe5\x89\x68\xf3\xf4\xea\x93\x91\x28\xfb\x2a\x38\x8b\x64\x90\x48\xb3\xdf\x20\x1d\x1a\x17\x97\xdb\xec\x4f\x8d\x3b\x34\x2e\xb5\x18\xaf\xae\x5e\x4e\x83\xad\xd9\xdf\x47\x32\xc8\xa4\x22\xe4\x74\xd2\x5f\xb0\xcb\xa2\xab\x5f\x49\x45\x5c\xd0\x8e\xa3\x06\x2e\x47\x1b\x85\xa8\x87\x68\xe0\xec\xb6\xd0\x58\x01\xae\x73\xac\x00\x27\x4b\x5d\x47\x0b\xbc\xb9\x30\xaf\x25\xf5\xd0\xfa\x4d\x4f\xf6\xb9\xf5\xc9\xb9\x6b\x1e\x3c\x2a\xcc\x28\x19\xd1\x3d\x5d\xa8\x7b\xf0\xb1\xd8\x84\x25\x4f\x4d\xbb\xff\x21\x67\x2d\x0c\x48\xec\xe1\xcd\x31\xc5\xd4\xd5\x4c\x8a\x8d\x6f\xfb\x82\x76\x00\x73\x2f\x3c\x98\xbe\xe6\xbe\xe7\xb7\x4f\xfa\x76\xc7\x88\x0d\xab\x75\xf7\xf4\x58\x70\xb8\xff\xb6\x63\x8f\x6d\x1e\x39\x71\xed\x81\x09\x4f\x6f\xf6\x8f\x82\x07\xb7\xd8\xca\xa7\xd6\xce\x18\x74\xff\xca\x55\x37\x0f\x5d\x17\x48\xa3\xa3\x00\x38\xea\x13\x0a\xd9\xe2\x66\xa6\x17\x6f\xf1\xf5\x54\x39\x3d\x49\xce\x24\x73\x62\x9c\x18\x9f\xc9\xf3\xf1\x39\x2a\xbd\x1c\x6b\x8f\xf3\xa4\xba\x93\x48\x62\x6a\xa2\x3b\x41\x8e\x23\xf1\xf1\x09\xf3\xfd\xf1\xf1\x76\x62\xd7\xcf\xa3\x66\xaf\x7b\x81\x9f\xc8\x91\xa1\x99\x57\xf4\xe5\x04\xfb\x8e\x3b\xff\xe9\x1a\x2b\x5e\x4b\x17\xdd\x69\x00\x23\x84\x7a\x6e\xe8\x5c\x41\x46\x99\x0a\x90\x2b\xc0\x8a\xe4\x91\x79\xe6\x07\x70\xdf\x6e\xd9\xbb\xf4\xb7\x0b\x29\xea\xf2\xc2\x81\x93\xbd\x0f\xf4\x5b\xbd\xfb\xc6\x7b\x1e\xd6\x58\xee\x4d\xbb\xbf\xba\x12\x6e\x9a\x91\x78\x5d\xfd\x9a\x01\x85\xe2\xe6\x7b\x97\xce\xf9\xfc\xf9\x11\xfb\x33\x0b\x7a\xf5\x1a\xbf\x78\xcf\xfe\x11\x5b\xef\x2d\xea\xde\x58\x78\xbc\x10\xee\x82\x5b\x9e\xd9\xa4\xec\xf7\x2c\xd9\xde\xa7\xa8\x07\xe3\x87\x6c\x42\xd4\x32\xeb\x57\x37\x93\x04\xd4\x9b\xcb\x7d\x55\x89\x9c\xc5\xa2\x43\xbb\xd7\x68\x4a\x23\x4e\xad\x88\xcc\xae\x56\x3b\x4d\x7c\x7e\x9e\x4e\x54\x6b\xec\x99\x0b\xfd\x71\xee\x85\xfe\xa4\x38\x30\xda\x93\xec\x05\x76\x5e\xcd\xdb\xe3\xec\x71\x44\x43\x60\x21\x1a\x0a\x2a\xb3\xa0\xb6\x18\xb5\x26\xf4\x8a\x48\x85\xc3\x8b\xff\xd1\x9e\x40\x7d\x57\x46\x89\x76\x6a\xa9\xae\xa4\xfd\x23\xd4\x22\x45\x4a\xd0\x06\x07\xb4\xc9\xac\x5e\x75\xf4\xf0\x37\xb9\xb3\xc3\x04\x1d\x23\xf1\xaf\x6e\x6e\xa9\xbb\xed\xf1\xc0\x5f\xf4\xf1\x4f\xfc\x03\xcc\x90\xca\xa5\xbb\x6c\x8f\xfd\xa2\xfc\xc4\x7f\xf2\xfd\x91\xfb\x77\x7d\x7d\xf8\xa1\x1d\x1f\xf7\x2e\x1b\x30\x2c\xb5\x47\xb9\xb7\x7b\x6e\xfc\xee\xdd\x42\xef\x31\xbb\xdb\x5f\x13\x57\xb6\x1d\x79\x7e\x32\xef\x6d\x5d\xce\xbd\xf9\x4e\xeb\xf6\xbb\x4e\xfe\x63\xe3\x03\x95\xd5\x43\xee\xf5\x0d\x1a\x91\x3c\xe0\x66\xc2\xe8\x92\xdc\xf1\xb3\x78\x0a\xe5\xa2\x91\x24\x21\x8d\x8a\xb0\x9e\x14\xe4\x24\x17\xa4\xa5\xa5\x27\xa7\x13\xa7\xca\x44\x88\xaa\xd8\x9b\x9e\x2e\x64\x14\xa4\xbe\xed\x2f\x28\x10\x32\x74\xb6\x37\xfd\x3a\x21\x23\xff\x2d\x7f\x86\x49\x88\x7f\xd3\x2f\x58\x3b\x4d\xa6\xab\x94\x5f\x79\xb4\x35\x10\xb4\x52\xb9\xe8\xfe\x02\x8b\x5c\xcc\xa5\x7a\x52\x04\xac\x28\x16\xc1\x5b\x94\x6a\xe1\x6d\x52\x0e\xd8\x3d\x66\x37\x25\x41\x0e\xa0\xad\x5b\x2a\x9e\x7a\x4d\x79\xfe\xb5\x93\xca\xde\x97\x5e\x87\xe1\xaf\xbd\x0e\x23\x8e\xdd\xb2\x53\xf9\xfa\xc9\xed\xca\x5f\xf7\x3c\x03\xb1\xdb\x77\x42\xfc\x93\x97\x1e\x5f\xf3\xf6\xb3\x70\xf3\x86\x1d\xfb\xb6\xee\x3f\x38\x64\x20\x77\x9c\xc6\x78\x0b\x86\xbe\xf2\x1a\x0c\x7f\xfd\xb8\xf2\xc2\xeb\x4f\x82\x6b\xe7\x36\xe5\x9b\x67\x9e\x51\xbe\xa2\x11\xc0\xb3\x64\x53\x1b\xaf\xb9\x73\xe9\x0a\xe5\xf7\x6a\xac\x13\x87\x79\x3a\x47\x8a\xea\xc5\x24\xd2\xe0\xeb\x96\xe4\x72\xc5\xc7\x4a\x5a\x3a\x8d\x09\x20\x56\xad\xd3\x69\x63\xb5\xc9\x6e\xa7\xdd\x18\x9f\x10\xff\xb6\xdf\xaa\x93\x20\x36\x56\xcd\x25\xf0\x13\xdd\x30\xdc\x0d\x85\x6e\x40\xab\x88\x9a\xec\xde\x02\xea\xed\x31\x27\xc9\x1b\x95\x79\x73\xb8\xa5\x3d\xd4\xf0\x64\xf6\xa2\x81\x86\xdc\xee\x35\x7b\xcc\xc5\x65\x94\x03\xf8\x8c\x18\x7b\x1a\xed\x31\x2f\x71\xdb\x85\x86\xdd\xbf\xaf\x8b\xc9\x71\x64\x6d\xf8\xe7\x2e\x55\x62\xfe\xc3\xab\x36\x0f\x95\x15\x38\xf0\x4f\xee\x09\x9e\x70\x2b\x95\xb3\xdd\x66\xf7\xbe\x01\xf2\x02\xcb\xa1\xd6\xb4\xad\xfa\x66\xa5\x05\xaa\x5a\xd6\x27\x3c\xa1\x68\xe0\xd7\x75\xeb\xa8\x8f\x57\x8f\xf6\xe1\xa7\x58\x9e\x1e\x32\xdc\x97\x99\xe8\x92\xb4\x2e\x2d\x6f\x77\xbb\xe3\x8c\x3c\xaf\x8e\x53\xa7\xa6\xe9\x9c\x4e\x55\x5c\x2c\x2a\x32\x6d\x6c\x50\xa8\x0b\x2b\xd2\xa0\x9e\x74\x5a\x30\xde\xe0\xae\xd4\xe5\x9d\x76\x4b\xa4\xf7\x23\x99\x98\xd1\xf2\x2d\xf5\xd2\x91\x81\x21\x23\x97\x56\x64\x07\x1d\xd0\x57\xe4\x40\x91\x6f\x22\x7c\x1c\xf4\x84\x29\xa7\xdf\x9b\xd5\x1b\x74\x81\x75\x8f\x6e\x79\xe3\xe0\x81\x37\xb7\x6f\x0b\xac\x06\x83\x6f\xd6\x07\x67\x60\xaa\xf8\xa0\xf2\xaa\xf2\xd7\x8f\x95\xb3\x93\xb4\x5f\x43\xc9\xb0\x2f\x9f\x7c\xfb\x8b\x8b\xef\xec\xbe\x34\x44\x79\xe7\x6b\xed\x44\xc8\x3b\x87\xfa\xde\xc7\x6c\xb5\xc6\x8e\x2f\x84\xbb\x84\x2a\x56\x26\x3d\x7c\x89\x4e\x9d\xcd\x9e\xa4\x17\x04\xbb\x8e\x77\x27\xeb\x93\x92\xcc\xf1\x2a\x93\xd9\x6e\x03\x09\x2d\x11\x12\x43\x2a\x8a\xea\xeb\x4f\x57\x9c\x46\x93\xfd\x74\x67\x95\x63\x8a\x28\x85\x69\x22\x5a\xa7\x2c\x88\x35\xeb\x53\xa7\xa2\xda\x6a\xa6\xde\x8d\x6c\xe6\xe6\x3f\xfa\xf3\x9d\x77\xfd\xf6\xe0\xd6\x7f\xde\xd5\x7e\xb2\xe8\xc9\x51\xab\x0f\x0f\xab\x6a\xbc\xb0\xd9\xfb\xc4\xe8\x17\xe7\xa7\x34\x81\xbc\x7d\x37\xe9\xd8\x70\xbf\xa2\xec\x52\xb6\x95\x56\xde\x74\x7b\xf6\x23\x4b\xb8\x7b\xc0\x5e\xd2\x77\x3e\x5b\x2e\x97\x08\x1d\xbf\x77\x7c\x22\x7f\xc1\xc6\xe0\x68\x89\x81\x94\x90\x79\xbe\x9e\x1a\x64\x19\x41\x16\xb4\x40\x47\x35\x79\xe2\x8d\x5a\x74\xc2\xec\xc6\x2c\xb9\x4c\x56\xa9\x4a\x0d\x06\x4b\x4c\x8c\x85\xe7\x2d\x42\x36\x3a\x89\xa8\x7e\xf4\x7a\x75\x5e\x7a\xba\x45\xa7\x06\x97\xc5\x1a\xf1\xb5\xcd\x78\x98\x4e\x04\xc7\x58\x44\x06\xe9\x5c\xe1\xf4\x99\x23\xab\x93\xa8\xc1\xa3\x06\x34\xa4\x51\x9d\x58\x01\x9d\xf0\x2b\x46\x10\x64\xe4\x73\xe1\x86\x4b\x9a\x6b\x5a\x64\x89\x9c\xd4\xde\xb6\xa3\x49\x98\xd8\x3e\x2d\x5b\xd9\xbb\xea\x73\xce\xfa\xdb\x1e\xe5\xf0\x6b\x97\x45\xe7\x99\x33\xcd\xaf\x9a\xde\x32\x34\x8c\x5c\x30\xb6\xb2\xe6\x89\x19\xa5\xa7\x5a\x1e\x7b\xdc\xfe\x86\xa6\x5f\xd5\x73\x55\x43\xd7\xcf\xef\x2d\xbe\xdc\x1a\x2b\x7e\xdb\xbe\xe9\xcb\x2f\xf9\xdb\xda\x57\x73\x9f\x28\x3b\x02\x95\xf7\x3f\xb0\x66\x7e\x52\x55\xcf\x6e\xdd\x53\x8b\x9d\x85\x15\xa3\xca\xef\xdc\x30\xf5\x8e\xd8\x01\xb9\xe3\x53\x8a\x1d\xb9\xfd\xc6\x07\xed\xaf\x1f\xd1\x00\x6d\x17\x7a\x10\x35\x2d\x4d\x01\xb3\xae\x16\xb5\x00\x1a\x49\x1c\xee\xc7\x0a\x65\xe0\x25\x09\x54\x46\xe0\x86\xfb\xc1\x1e\x64\x46\xcc\x3b\x6d\xce\x0d\x4e\x83\x08\x71\x60\x16\xd0\xc1\x09\x65\xb4\x87\x21\xab\xfd\x44\x06\xe7\xc9\x51\xc4\x4c\x68\x1b\x03\xb1\xef\x5c\x7a\x07\x4e\xd2\x36\xcf\xc6\x8e\xdf\xa5\x41\xe2\x9d\xa6\x74\x12\x9c\x8f\x19\xe0\xb6\xb2\xb6\xcf\xf9\xfc\xdc\x40\x15\x7e\xaf\x62\xdf\x1f\xc0\xef\xf3\xe0\x5a\xdf\xef\xc0\xef\x63\x31\x3e\xfd\xf2\x32\xdb\x55\x52\xc5\x2f\x0b\x0c\x31\x4b\x64\x69\x32\x21\x83\x7c\x5e\x82\x42\xbb\x06\x38\x13\x14\x02\xb7\x03\xf6\xc3\x31\x78\x1f\x04\x9e\x03\x9b\xd1\x96\x64\xe3\xf6\xdb\x8e\xd9\xde\xb7\xf1\x42\x59\x43\xd9\xec\xb2\xe5\xe8\xdc\x73\x60\x76\x92\x8a\x92\x92\x12\xa8\x37\x97\xd4\xd3\x51\x61\x25\xf5\x73\xea\x83\x73\x39\x1f\x64\x69\x3d\xc0\xd2\x7a\xba\x4b\x5a\xf3\x4b\x09\xe9\xe9\x4b\x8f\xa4\x05\x57\x25\x50\x6b\xac\x4d\xaa\xe5\xae\x05\x9e\x41\x67\xed\xbf\x1b\x19\xfc\x95\x57\xc3\x57\x49\x7d\x08\xe9\xed\xcb\xfc\x2f\xf0\xfb\x1b\xfb\x27\xf5\xaf\xe9\x7f\xcd\x0c\x84\xf1\x7f\x01\xe1\xa7\x86\xe0\x4f\x08\xc1\x1f\xc8\xe0\xcb\xa3\x29\xfc\x6c\x02\x05\x08\xbf\x01\xd6\xc3\x63\x20\x86\x93\xa8\xb1\x3d\x66\x13\x84\x1e\xc6\x1e\x49\x3d\x96\xf7\xb8\xd4\x43\xb8\x22\x05\x46\xa1\x20\xfc\x38\xb4\x55\xba\x09\xc3\x2c\x12\x17\xc3\xe6\x9a\x3e\x41\x26\x4b\x13\xb8\xfe\x44\x4f\x12\x7c\x7a\x2d\x51\xf1\x7a\x9e\x88\x82\xc1\xa8\xd7\x91\x48\xbd\x67\x82\x2a\xc6\xe1\x49\xcf\x28\x41\xf3\x42\x92\xdd\x76\x6e\x65\x79\x9f\xaa\xe5\xeb\xd7\x2f\xaf\xea\x53\xce\x5f\x84\xac\x7e\x77\x6c\x1e\x94\x3a\x68\xf3\x1d\xfd\xea\x28\x4c\x53\xc7\x71\xee\x67\x61\x39\xc2\xcc\xf4\x59\x44\x49\xa7\xd3\xab\xf5\x1c\x6f\x30\x12\xad\x9a\xd3\xaf\x10\xe9\x6a\x4a\xef\x16\x45\x14\x79\xb0\x0d\x4f\x92\x29\xec\x18\x87\x3d\x3d\xc3\xec\x81\x8f\x3b\x01\xf2\x3b\x3a\x93\x6a\xf7\x5c\x8d\x33\xd1\x72\x6a\x9d\x5a\x8b\x76\xb0\x41\xa7\xbf\x02\xe7\xf4\x0c\x0a\x51\x92\x3d\xa5\x65\xee\x12\x71\x79\x34\x20\x58\xfe\x5f\x70\x96\x44\xbd\x5e\xa7\xd6\x71\xbc\xd1\xa0\x25\x9c\x7a\x85\x84\xc4\xb8\x18\x7b\x25\xce\x69\xa5\x65\x14\x36\x52\x05\xc5\xb5\x97\xcb\xe9\x04\xf8\x44\x34\x75\x48\x17\x9c\x1d\xc4\x7c\xd0\x2c\xb9\x9c\x28\xda\x18\xae\x2c\xf3\xd1\xb4\x8d\xc2\x39\x9a\xca\x9c\xd2\x79\x1f\x45\xef\xc8\x4d\x74\x1e\x1c\x74\x5c\xa0\x51\xa5\xd2\x6a\x89\x9d\x4e\x50\x77\xba\x1c\x3a\x83\x7d\x85\xc5\x47\x0b\x80\xd1\x9f\x66\x25\x36\x92\xa3\xae\x66\x77\x74\x49\x44\xe5\x30\xaa\x4c\x22\x37\xd1\x65\x13\xe0\x3a\xef\x09\x87\xb8\x54\x31\x5c\x78\xf4\x8b\xfb\xf8\xe2\xad\x3a\x1d\x18\x8d\x82\x4b\xa6\x83\xf3\x12\xe2\xe3\x4c\x16\x57\x0c\x4f\x62\x04\xa3\x5e\x52\xb3\x75\x72\xca\x2f\x7e\x71\xda\xd4\x89\x4f\x67\xdf\x12\xea\x1b\xd4\x8d\xd6\x3f\xc2\xca\x04\x5f\x2a\xc9\x27\xaf\x46\x6d\xda\x70\x61\xcc\x1f\x20\xc7\x74\x61\x45\xc7\x77\xfc\x4b\xe2\xcb\x68\xb7\x66\x93\x01\x3e\x4f\x9a\x53\x95\x68\xb1\x10\x15\xc9\xc9\xd5\xb9\x47\xfa\x8d\x3a\x5d\x66\x9c\xd3\x19\x17\x67\xaf\xf1\xc7\x11\x31\xb3\xc6\x2f\xc6\x84\x4d\x73\x74\xcd\xd8\xd8\x4e\x6f\x4e\x94\x41\x52\xc4\xec\xb0\x90\xbb\xc2\x54\xa3\xc3\x5b\x16\xd4\xe6\x72\x19\x3e\x5a\x80\x6a\x89\x90\xf5\x69\xe1\x5f\xaa\x59\xff\xf6\x8a\x27\xff\xb4\xf0\xe8\xe2\x21\x4b\x92\x04\x98\x31\xbb\x64\x61\x5a\xde\xa4\xb9\x2f\xbf\xaf\xb4\x1b\xeb\xca\x7c\x37\xf5\x1b\xd8\x67\xc2\x03\xfc\xba\x37\x95\xad\xbf\xde\xfe\xee\xb1\x27\x20\x67\x4b\xdd\x90\xec\xc2\xbd\xaf\x66\xc6\x9f\x2e\x57\x2e\x05\xfe\x56\x5d\x3f\xff\xd3\xe9\x93\x6e\x82\x18\x96\x97\x1c\x54\x9a\x87\xd1\xd6\x12\x29\x53\xd1\xf1\x8b\x1c\x4a\x7e\x8d\x00\x82\x0e\xa9\x8b\x0a\x53\x8d\x26\x89\x25\xac\x01\x42\x48\x33\x2d\x87\x58\x7b\x4b\xd0\x56\xb6\x53\xa3\xd9\x4d\x72\xe0\x3e\xb8\x05\x9a\x02\x87\xd4\x55\x67\xb8\xfe\xca\xa5\x73\xc2\xb3\x6d\x75\xe7\x84\x96\x14\x25\x50\xc3\xbf\x1e\x6c\xef\xfe\x52\x19\x2d\x7e\x81\x69\xc9\x24\xc5\x67\xa2\x63\x83\x05\x59\xa5\x16\xb9\x89\x7e\x11\x1f\x48\x41\x51\x45\x4e\xf4\x2c\x73\xb3\x9b\xfd\x09\x27\x02\xfd\x94\xf3\x82\xa2\x8c\x96\x4a\xff\xf3\xb6\x9c\xfd\x3b\x9b\xe7\x4e\x76\x22\xac\x46\x84\xa5\x25\xc3\x7c\x19\x32\x1a\x53\x9c\x4a\x05\x92\xa4\x01\x8d\x4e\xcf\xcb\x82\x20\x37\xf8\x55\x1c\x1b\x0c\xaa\x16\x00\xb5\x1c\xcd\x07\x09\x9a\xc2\xa8\xc6\x9c\x15\xd4\x51\x0e\x4d\x75\x0c\x0f\x43\x2e\x2a\x62\x4d\x02\x25\x6a\x40\xbb\xcf\xad\x06\xb7\x7d\x27\x37\x3e\xd0\x22\xcc\x09\x70\x9c\x29\x70\x81\xaf\x56\x46\xef\xe0\x73\xb9\x53\x5b\xbf\x0a\xac\x0a\xc4\x7e\x1d\xcc\xd3\x32\xae\x5c\x58\xc1\xbb\x90\x57\x63\x7c\x1a\x0e\xc5\x1f\x1b\x8c\xff\x02\xa9\x88\x4c\x6c\x46\x60\xcb\x50\xa8\x96\x7f\xf9\x25\xca\xd0\xf0\x78\x62\x93\x24\x07\x58\xfc\xdb\x39\x2b\x9c\xe7\xfb\xb3\xf9\xb8\x5a\x8c\x4e\x60\xdb\xb8\xd0\x64\x19\x06\x21\x38\x10\xfc\xf6\x9e\x90\xdc\x13\x43\xd2\x29\x30\x40\x6e\xeb\xf8\x4e\xf8\x5a\xaa\x45\x8e\x4b\xf7\x99\x80\x48\x12\x8f\x96\x0c\xaf\x51\xf3\x98\x6d\x3a\xc5\x3e\x68\x75\x05\x67\x8f\x31\x7b\x44\xf4\x00\xda\xb2\x56\xf0\x72\x7f\x7b\x5a\xf9\xa5\x05\xca\x3e\x87\x6d\x47\x5c\xdc\x2f\xbb\x03\x77\x8a\xc3\x83\xf3\x78\x46\x90\x4f\xc5\x05\xfc\x09\x62\x43\xfb\x2e\x87\xac\xf2\x8d\x4a\x4f\x76\x68\x12\xd0\xbb\xca\xcd\xb3\x7b\xf4\x9e\x17\xfd\x16\x93\x3e\x36\x4b\xce\x7a\x11\x0b\xab\x40\xae\x90\x6b\x64\x9e\x9e\x96\xcb\x67\xe4\x4b\xb2\x28\x93\x3c\xf8\x39\x0f\xbe\xcc\x83\xf7\xf3\xe0\x58\x1e\xec\xcf\x83\x1d\x79\xb0\x21\x0f\x56\xe4\xc1\x2d\x79\x30\x31\x0f\x7c\x79\x50\x98\x07\x5d\xfa\xa0\x49\x41\xfd\x9c\xa0\x7d\xee\x0c\x0f\x20\x0d\xf3\x57\xb0\x4e\x48\x5d\xdb\xca\xe9\x29\x2d\x45\x0e\x5b\x51\x51\xed\xe1\xa5\xe2\x82\x23\x6b\x3f\x59\xb2\xea\xed\xa6\x03\x87\xef\x9d\xba\xab\xef\xf2\x93\x5b\x0f\x29\xbb\x16\x4d\xc8\xbd\xa1\x72\x80\xbf\x4e\x49\x2c\x19\xdb\x6b\x60\xc3\xd8\xa1\x3d\x27\x72\x03\x1f\xf9\xe8\xf2\x37\xa7\x77\x3f\xf6\xfe\xec\x15\xdf\xbe\x93\x78\x72\xc2\x94\x59\x75\x63\x6e\x7e\x69\xce\xa8\xd9\xa3\x6b\x67\x37\x50\x39\x48\xf7\x6d\x9c\x28\xbc\xc1\xc6\x12\x73\xa2\xc8\x4b\x32\x1d\x0d\x7c\xba\x73\xb1\x3d\x2f\x9d\x88\x03\x5b\x27\x08\x33\xda\xba\x0b\x6f\xb4\x6d\x99\x10\x94\xd1\xae\x0e\x45\xd8\x2b\xa8\x88\x95\xce\x23\xb5\x12\xad\x86\x68\x6c\x76\x2d\x31\x8a\x85\x76\x48\xb6\x63\xc6\x11\x48\x94\x21\x8f\x65\x62\x66\x7d\x6f\x89\x60\xa7\x7e\x07\x33\xdd\xcd\xe0\x9a\xf7\xc1\x1d\xab\xce\x2e\x9c\x7a\x62\xc7\x13\xc7\x38\x8e\x3c\x78\xf9\xce\xd5\xbf\x6c\x52\x08\xc7\xbd\xfa\xf5\x5f\x5e\x57\xa8\xdd\xb6\x5c\x19\xcd\xbd\x2a\x9e\x41\x39\x9d\xe9\xb3\x19\xed\x76\x34\xdd\x9c\x2e\x9d\x19\xad\x36\x44\x7c\xb8\x1f\x25\x66\xd8\xf5\x83\xb0\x8b\x43\x7b\xcd\x4b\x90\x4a\x25\x66\x4a\x47\x94\x82\x2c\x2d\x9b\x14\x9b\x33\xde\x76\x5d\xc9\x23\x1f\xbd\x3a\xa6\x5f\xd1\x80\xa1\xc3\xcf\x2a\xa3\x0d\xf2\x79\xd7\x49\x61\xd2\x81\xb7\xac\x9f\xbb\x6e\x9c\xd0\xb6\xbd\xf9\x0d\x26\x23\xfa\x83\x45\x18\x29\x94\x11\x3b\xd6\xf2\x59\xbe\xdf\x13\xd5\x99\x56\xb5\x35\x37\x2f\x33\x6b\xaf\x3f\x33\x33\x3d\x39\x21\x71\xaf\x3f\x26\x7d\xaf\x3f\x21\x81\xc4\x4c\x8c\x79\x3f\x06\x3d\xf3\x98\x64\x5f\x72\xec\x5e\x7f\xb2\xd6\x62\xdd\xeb\xb7\x58\x4c\x5a\x95\x7a\xaf\x9f\x98\xf6\xfa\x55\x2a\x42\x26\x92\xf7\x09\x86\x21\x5a\x9f\x56\xdc\xeb\xd7\xae\xce\x83\xc9\x79\x50\x9b\x07\xfd\xf3\xa0\x38\x0f\x6c\x79\xf0\xaf\x3c\xf8\x28\x0f\x84\x3c\x94\x78\xec\x82\xcf\x5f\xb3\x57\x27\xf2\xe0\x40\x1e\x6c\x62\x3c\x85\x71\x86\xb3\x38\xc8\x56\xa9\x2c\x1a\x86\x9c\x7d\x45\xd0\x9d\x0c\x70\x34\xd4\x60\x6a\xc1\xa4\x22\xd1\xae\x8e\xb5\x29\x2a\x24\x06\x43\xf6\xae\xe0\x1a\xae\x3d\x84\xe2\x8f\xe6\xd7\x05\xc7\x4e\x44\x66\xe4\xb3\x71\x10\x08\xa2\xa8\x20\x27\xec\x97\xd3\x21\xab\xd7\x7a\x1f\x2d\x05\xb1\xec\x98\x22\x28\x61\x55\x80\x76\x50\xda\x0d\xc0\xa7\x44\xbf\x64\x6d\x95\xf4\xed\xc0\xea\xa6\xea\xd5\xfe\x7e\x0b\x2a\x67\x3d\x3e\xfc\xa1\xc1\xf7\x0c\xbe\xeb\xd6\x8a\x45\xb5\x8b\xf7\xad\x1c\x3f\x70\x61\xdf\x39\x8f\x5e\xbf\x63\xc8\x94\xca\xf8\xbb\x6e\xf5\xcd\xe7\xfe\x95\x15\x5b\x90\xd1\xed\xe3\xda\xdc\xd8\xfc\xf1\x9f\xe7\x79\x94\xc4\xca\xbc\x9c\xbc\x8f\x6b\xf3\x63\x93\xf5\xe3\x3f\xcf\x4d\xa5\x72\xa9\x27\x49\x13\xa6\x88\x39\xc4\x0a\x63\x7d\x3f\x62\x2d\xd0\x08\x5a\x4e\x4b\xcc\x26\xbd\xa0\x03\xe0\x74\x9c\x55\xb0\x1a\x0c\x2a\x74\x00\x6d\x5a\xa2\x5b\xa1\xe3\x74\xbc\x4e\xe3\x33\xc9\x1a\x79\xaf\x5f\x6f\xd2\x0c\x47\x51\xa8\x49\xd6\xf8\xf0\x66\x85\x66\x87\x46\xd2\xf2\x1a\xb3\xc4\x4b\x28\x19\x39\xf2\x03\x0f\x71\x7c\x0e\x5f\xcd\x3f\xc2\x0b\xbc\xcf\xe6\xaa\xe2\x97\xda\x61\xa6\x1d\xc6\xd9\xa1\xda\x0e\x6d\x76\xf8\xdc\x0e\x2f\xd9\xe1\x11\x3b\xac\xb3\xc3\x72\x3b\x70\xb3\xed\xd0\x60\x87\x1a\x3b\x54\xb0\xae\x91\xa3\xec\x9c\x84\x7a\xc7\x0e\xaa\x0e\x3b\x5c\xb2\xc3\x0e\x3b\xac\x88\x7a\x3b\xe3\x8c\x1d\x9e\xb7\xc3\x7a\x3b\xcc\x66\xf1\x0a\xd9\xfd\x2d\x76\x18\xce\x1e\x0b\x58\xa0\xcb\x2c\xe6\x99\xa8\x37\xe5\xef\xdb\x61\xbf\x1d\x22\x05\x39\xa7\xeb\x62\x15\xec\xd7\x39\x5b\xb2\xa1\xf3\x33\x96\x2e\x4a\xb2\xd3\x45\x41\x51\x86\x65\x39\x87\x49\xb3\x70\xc1\x06\xab\x62\x51\x78\x44\x9b\x39\xaa\x1f\x54\xf6\x94\x51\xc1\x8c\xfe\xba\xd5\xcb\x7b\xed\x6e\xde\x6d\x87\x1f\x56\x7e\xbc\xf2\x73\x18\xb8\x5b\xb1\x72\x63\xef\x3c\xbb\xaa\x5d\xd9\xb2\x9b\x2e\xe0\xa5\x28\x17\x61\xf0\x25\xe0\x14\xe5\x92\xd2\x7c\x91\xc9\xec\xc9\xe4\x5f\xc2\x40\x61\x78\x68\xbe\x49\x85\xcf\xad\x95\x39\x95\x80\x15\x16\x0d\x50\xd5\x3e\x3f\xba\x74\x20\x88\xfb\xfc\xa8\x92\xf6\xf9\x8d\x90\x04\x1c\xd0\x99\x37\x24\xd2\x22\x94\xd3\x39\x0f\xd3\x1b\x54\x54\x10\x3a\x26\xf3\x5f\xb5\x27\x04\x0f\xfe\xe5\x4d\x9b\x02\xdd\x37\x6d\x82\xc9\x9b\x36\x21\x68\x74\x24\x04\xbf\x68\x61\xf3\x1d\x4a\x7c\xb1\x1a\x34\x17\x74\x32\x6a\x6f\xad\x4e\x56\xed\xf5\xa3\xe2\xe5\xa4\x42\xce\xc7\xa1\xf0\x2a\xa8\x2f\xb0\x94\xf7\x2e\x08\x25\x13\x6e\x86\xa7\x53\x29\xc0\xae\x06\x96\xcc\x68\x81\x6b\x3f\xc6\xfb\xda\x14\x44\x7a\x21\xf4\x85\xb1\x5f\x29\x7f\x55\xbe\xff\x4a\xf9\xea\xd2\x25\x72\x45\x5a\x3d\x7d\x09\xe1\xa4\x34\xa1\xb4\x24\x91\xe3\xf8\x42\xc1\x27\x70\x74\x5f\xf1\x82\xa2\x82\x7a\x2f\xa6\x47\x1b\x4c\x72\xa2\x27\x98\x86\x54\x3a\x98\x59\x8a\x7c\x45\xfb\x6b\x02\x87\x29\x72\x90\xf0\x15\x38\xc0\xf9\x95\xb2\x5b\x39\x1a\x58\x4b\x53\xa4\x69\x6e\xc7\x34\xcb\x04\x3a\x9b\x47\x4d\x52\x7d\x26\x4e\x25\xd2\xc9\x3b\x2a\x81\xd7\x6a\xe8\x3d\x95\xe2\xa7\xa3\x9a\x9b\xd1\x08\x32\xab\xc1\x9c\xe6\xc6\xf3\x76\x38\x0d\xa7\xdb\x9b\xb9\x56\x65\x95\xb2\x8a\x5b\xca\x49\x81\xd6\xc0\x9d\x23\x39\x09\x9e\x55\xea\x98\xae\x9f\x4c\x0e\x08\x03\xb9\x5f\x50\xb7\x24\xf8\x74\x08\x8b\x93\x64\x02\xc2\x3e\x36\xfd\x88\x44\x1a\xe8\xba\x15\x96\xb1\xb9\x9e\xb4\x0c\xf6\x1d\xe0\xfa\x3c\x80\x36\x03\x70\x29\x81\x87\xf9\x0f\xa5\x67\x51\x06\xc7\xfa\x34\x04\x54\xe0\x88\x31\x6b\x45\x8c\x59\x70\x3a\x4a\x39\x79\x98\x88\x0f\x4e\x59\xc8\x60\x92\x43\x96\xec\xdc\xc1\x8d\x4f\xdf\x5e\x51\xed\x4d\x4b\xd4\x9b\xd2\xdd\xa6\x54\xb5\x14\x78\x58\xae\x3b\xf1\x6b\x45\x61\x66\xb1\x46\x95\x9d\x91\xe1\x99\x1e\xd4\x61\x62\xe0\x61\xee\x20\xa6\x61\xa3\x69\x70\x36\x95\xcd\x4e\xd3\x20\x57\xa4\xe1\x35\x77\x36\x8c\x3a\x98\x48\x2a\x2d\xe1\x52\x36\x3e\xb9\xba\xe7\xb0\xa2\x54\x77\xac\x26\x29\xc9\x94\xe0\x90\x9e\xfd\xfd\xe9\xe3\xff\xee\x5d\x90\x51\x62\x12\xb2\xd2\xbc\xcb\x59\x9b\xc3\xaf\x5c\x9a\x78\x90\x6b\x46\x7e\x75\x1e\xe4\xd9\xd2\x23\x2d\xc0\xbd\xe0\x87\x76\x6a\x2d\x85\x16\x1f\xc1\x32\xd2\x88\x47\xb9\xb4\xa6\xa6\x20\x4e\x9f\x06\x36\x72\xd3\xe5\x2a\x36\xff\x8a\xe3\x51\x62\x28\xa4\xb5\x73\xfe\x15\x9e\x3d\xf0\x69\x53\x93\x5c\xf5\x6b\x35\x0b\xcf\xdd\x17\xd8\xc8\xd2\x10\xd1\xc6\xd4\x70\x32\x7a\x30\x92\xa8\x10\x9e\x25\x44\xda\x83\xca\x31\x32\x4b\x18\x28\x9d\x3d\xdc\x7d\x7c\x66\x60\x7a\x13\xd7\xdc\xd4\x36\x2b\x88\x67\x60\x23\x9f\xc8\x60\x24\xd3\x35\x52\x28\x07\x28\x9c\xc8\x40\x70\x9d\x20\xc2\xf8\xa2\xfa\xd6\xf0\x99\x4d\x88\x72\xeb\x45\xe1\x01\x86\x03\xcd\x27\xe2\x2c\x92\xa4\x43\x02\xda\x0f\xa2\xc4\x62\x1f\xa0\xb1\x5b\xd9\xf0\xe6\x08\x02\xcc\x9a\xe0\xee\x6b\xe2\xb6\xb4\x7f\x2a\x57\xb5\xcd\x6a\x0a\xd1\x89\x4f\x64\xf1\x31\x7d\x64\x72\x22\xf1\xad\xff\x25\x7d\xaf\x59\xc3\x6d\xa1\xe9\x0b\x0f\xb4\x5e\x8c\xd0\x00\xe3\xcb\x24\xcb\xa7\x13\xe8\x0c\x69\x42\x54\xb2\x72\x05\x12\x9d\x84\xe8\xc4\x84\x12\x03\x71\x41\x6a\x30\x64\xa2\xe9\xc1\xe0\xa5\xf9\xb0\x06\x22\x42\x2a\x49\x41\x94\xe4\x2e\x28\x85\x70\x8a\x20\xe5\x61\x68\x05\xf1\xfa\xb5\x9a\x52\x26\x04\x8b\x95\x8f\x8c\xf6\x8b\x9e\x57\x0b\xe8\xd4\x21\x30\x3a\x11\x3b\x8a\x17\x42\x3d\x58\x21\xd4\x28\x4f\x30\x2a\x8b\x47\x69\x31\x21\x6b\xb4\xcd\x42\x70\x21\x7e\x62\x78\x21\x2c\x99\x51\x4a\xc5\xb7\xd2\xec\xfe\x37\x58\x66\x9a\x53\x46\xb1\x2d\x0c\x37\x4a\xf4\x10\x5e\x08\x4b\x4b\xbc\x3e\x8b\xac\xa7\x53\x9c\xd0\x05\xd6\x69\x30\x9f\x2a\xd4\x7c\x08\x10\x2d\x5f\x9a\xd5\xf0\xfc\xd6\x50\x6e\xbb\x82\x75\x87\x72\xcd\x48\x18\x86\xce\xb0\x65\xeb\x5a\xc0\x1c\xf1\x20\x3f\x83\xc9\xeb\x7c\x9f\x86\x97\x65\x35\x7a\xb4\x2a\x51\x60\xe5\x22\x06\xc2\x78\xb7\x85\x6d\xb8\xce\xe2\xe1\x43\x82\x19\x69\xd0\xda\x17\xeb\xc7\xf9\xa6\x26\x65\x6b\xb0\x8e\x70\x70\x1e\xcb\xe7\x43\x56\x47\x64\x12\x8f\x92\x45\xc0\x9a\xa5\x92\x79\xa4\x2a\x16\x74\x51\x05\x1b\x10\xd0\x59\x5d\xe8\x81\xd1\x61\x5a\xb0\xda\xa8\x0f\x62\xd5\x09\xf1\x0c\xe2\xa6\x26\x65\x3e\x03\x4a\x5a\xad\x4c\xbd\x7f\x8d\x5a\x11\x64\x86\x9d\x10\x08\x57\xa2\xb6\xce\x0e\x86\x2e\x93\xcd\x68\x65\xb2\x47\x55\x28\x46\x03\x7e\x46\xd3\xb9\xa6\xf6\x94\x60\x5d\x3e\x1f\x2a\x7b\xf4\xda\x7d\x06\xd0\x4a\x6a\xb5\x06\x2b\x07\xaa\x10\xb5\x84\xa0\x0f\xfa\xd5\xed\x82\x4a\xa1\x4d\xae\x9d\x4b\x78\x84\x61\xdb\x43\x33\xd4\xcd\xe2\x41\x25\x01\x41\xb2\xca\x4a\xa9\x2b\x7a\x22\x34\x60\xf8\x53\x3f\xb6\x27\xe6\x40\xa5\xd2\xab\x51\x5f\x60\x1e\x74\x92\x1a\xa1\x1f\xf2\x4b\x01\x6d\xa7\x24\x08\x65\xc2\x1b\x45\xe4\x68\x91\x10\x3a\x9f\xe7\x2f\xb4\x1f\x44\x4a\x71\xf3\x30\x51\xcc\x4a\xeb\x11\x61\x36\xcb\x4d\xa8\x4e\x30\x7a\x95\xf8\x30\x25\x9e\xd7\x50\xcd\xa4\x52\x24\x9e\x91\x4b\x6a\xe3\xd4\xc1\xda\x11\xb8\x06\xb9\x82\x05\x5a\x12\x9c\x77\xaf\xa1\x84\x42\x01\x02\x73\x30\x5f\xad\x59\xfc\x17\x91\x3a\xf7\x21\xa3\x55\xbe\xcf\x14\xa2\x14\xd1\x20\x7d\xa4\xab\xab\x8a\x37\xcc\xdf\x9d\x12\xc9\xc3\xa4\xd2\x05\x4a\xa9\xa0\x5c\x0a\x32\x21\x17\x84\xdb\x49\x27\x41\xad\xd6\x69\x55\x2a\x1d\xe1\xd1\x7e\x0b\xd2\x49\x13\xe0\x64\x85\xf1\xe4\x0b\x7e\xf1\x8f\xe9\x44\x57\x24\x28\x01\x7a\x72\xf3\x1f\x36\xb5\x1f\xe4\xe6\x35\x29\x09\xdc\x3c\x7e\x46\x6b\x96\x58\xc9\xf2\xd1\xc4\x64\x11\xe5\x79\xe4\x4d\x4a\x27\x1d\x3a\x2b\x5a\xe4\x2d\xcc\x0d\x2b\x13\x24\x53\x20\x2c\x94\xda\x22\x42\x29\xa7\x6b\xc9\xb3\x6a\x65\x0f\x4b\x49\xca\x56\x54\x52\xb6\xa7\x60\xd6\x18\x4f\x85\x64\x00\x5d\x7b\x48\x87\x36\x2a\xc2\x56\x21\x4f\xa9\x28\xd8\x66\x3f\xa7\x6a\x27\x52\x2b\x6b\xc5\xbf\x16\x58\x7a\xcf\xf7\x6d\x82\xaf\xda\x53\x9b\xce\x31\x89\x27\x7a\x98\xcc\x43\x7e\x0a\xe1\x1d\xa2\x93\x46\x10\xf4\x2a\xad\x56\x87\xa5\xa0\x53\x69\x19\xca\xaa\x36\x86\xfb\x41\x2c\x62\x29\x58\xd1\xae\xc4\x3e\xca\x5f\x0c\x9e\xcf\x37\xf1\xd5\xed\xa9\x58\xf3\xe0\xab\xc0\xbd\x72\x55\xeb\x91\x26\xf1\x1c\xe6\x84\x95\x37\xcc\x61\x32\x36\xc4\x4f\x1c\xc7\xf8\x49\x6e\xfd\xdf\xf2\x93\x37\xc8\x4f\x28\x83\x18\x3f\xf1\x5f\xb4\x66\x85\x75\x2f\x93\x11\x8c\x9f\x88\x2c\x6b\x90\x65\x41\xa3\x12\x5a\x31\x29\xe8\x94\xe3\x57\xf3\x13\x04\xa1\x52\x4a\x7d\x88\xb8\x7f\x15\x64\xa9\x10\x43\x31\x99\xc6\xe0\x86\xe8\x44\x69\x44\x79\x49\x0d\x10\xe1\xa7\x36\x41\x6a\x0d\xa7\x11\xf8\xe3\x7a\x47\x93\x71\x7b\x83\xfc\xd4\x9e\xca\x57\x37\x29\x72\x53\xe0\x5e\xf8\x0a\xf3\x21\x56\xb6\x85\xec\x81\x88\x6e\xd3\x92\x5e\x3e\x23\xf2\x93\x5e\xe2\xe8\x64\x58\x9d\x56\xf9\x6f\x2c\xd5\x49\xac\xab\xd8\x2a\xa2\xf2\x42\x6a\x8f\x71\x16\xad\xe3\x21\x99\xc2\xf4\x8b\x16\x4b\xc5\x26\xe8\x69\x42\xc8\xbf\xb2\xac\x93\xb5\x0a\x51\x5d\xa9\x94\xbd\x15\x57\x4e\xef\x0d\x6b\x55\x2a\x74\x19\xa3\xa1\x1c\xa1\x72\x3b\xa4\x5d\x99\xec\xe5\x23\xe9\xf0\x74\x8a\x14\x19\xe8\x33\x1b\x24\xc9\xac\x53\xa9\x8c\x6a\xb5\x89\x36\xcd\xea\x8c\x2c\x43\xba\x36\x26\x8b\x7d\x6a\x14\xc6\x1a\xae\x55\x0d\x4c\x56\x7a\xaf\x60\xbb\xce\xb4\x69\xcf\x66\x50\x25\x05\xad\x8c\x19\x4d\x4d\xe7\x98\x24\x63\xec\x17\xd8\xa8\x3e\x88\x0c\xd8\x9e\xa2\x3e\xc8\x58\x30\x4a\xcf\x6b\x49\x0f\x9f\x49\x4d\x09\xab\x43\x26\x44\x1d\x18\xcd\x86\xda\xab\xd8\x30\x8a\x0f\xbb\x30\xa2\x27\xc2\x8a\x61\x5e\xfc\xb5\x1a\xa5\x5b\x48\x06\x85\xe8\xda\xcd\x67\xa1\x54\x15\x91\xac\x44\xa7\x95\x14\xd5\x55\x76\x85\x37\xcc\x8f\x5d\x74\xad\x87\x26\xea\xd1\x20\x3f\x32\x4d\x16\xb1\x32\x44\x0f\xb5\x04\xf9\x48\x1a\x41\x9a\x56\xfa\xcc\xb2\x9e\xee\x58\xa8\x51\x6b\xb5\x26\xb4\x23\x4d\x46\x1d\x63\x4e\x63\x80\xd7\x2a\x61\xf5\xd3\x46\x04\x26\x2b\xae\xe4\xd0\xe8\xe2\xa4\x45\x49\xdd\xb5\xa0\xe0\xeb\xcb\xd4\x30\xe5\xd2\x26\x26\xfd\x82\x0a\x15\x99\x35\x24\xff\xb8\xa0\x5d\x81\xf2\x96\xe6\xb5\x8f\xcf\xa0\xe5\x79\x3d\xda\x3c\x3a\x15\xd2\x55\xad\x0a\x96\xa6\xba\x2d\xda\x00\x0a\x84\x6b\xe1\x55\x55\x24\x6c\x07\x85\xec\x00\xe4\xd6\xc0\x74\xf1\x28\x92\x16\x0b\x91\xff\x82\x52\x21\xca\xbe\xd2\x92\x62\x9f\x95\x67\x32\x8b\xda\x58\x3a\x49\xa3\xa8\xae\xb2\xb2\xba\xd6\xf5\xe8\x34\x3c\x41\x7b\x2b\xa8\x6b\x43\x16\x57\xc8\x8e\xe1\x23\x79\x12\xd9\x2a\x07\x83\x7c\x16\xbd\x4a\x65\x46\x6d\x6b\x32\x20\x61\xd1\x0a\x33\x19\x0d\x4c\xfa\x1a\xdb\xd4\x68\xb0\xb3\x5b\x49\x08\x68\x43\xfc\x1a\x9e\xcd\xd8\x75\x59\xcd\x10\xc7\x22\x51\xbd\xc1\x1a\x63\x77\x97\x20\xc7\x52\xa2\x06\x99\x96\x9b\xd7\xda\x17\xcb\xf4\x0b\x9a\x5b\xf1\x1c\xe6\x35\x64\x4f\x85\xf8\x08\x69\x2b\x6b\xb5\x7a\x82\xba\x0c\x31\xe8\xa4\x6d\x20\xda\x20\x6c\xfb\x6f\xb4\x65\xb5\x84\xd1\x96\x19\x70\x21\x33\x8b\xff\x02\x6b\x07\x33\xb5\x3a\xed\x4d\x46\x5b\x2d\xb3\x2f\xa8\xcd\xa9\x93\xf9\x56\xf5\x55\x56\xe7\x35\x69\x1b\x7a\xc0\x34\x98\x20\x85\xaf\x22\xa2\x94\x99\xfe\x94\xb6\x51\x7a\x87\xd1\x56\x30\x1a\xcd\x6a\x9d\xce\xa4\xa2\x8c\x2b\x8a\x26\xbd\x8e\x11\x54\x1f\x10\xd5\x4c\xc0\xa2\x92\xd3\xb4\x75\x2a\xb9\x3f\xa4\x6d\x44\x0f\x95\xb8\x69\x26\x99\x34\x0a\xdc\x1b\xe2\x5e\x25\x41\x3c\xca\x44\x9f\x30\x1b\x99\x17\x05\x6f\x13\x89\xb2\x89\xad\xa4\xd6\xe7\xd2\x1a\x8d\x76\xbd\xda\x64\x92\x38\xab\xd5\x86\x62\xc1\x66\x41\xb1\xa0\x13\x98\xa1\x70\xc8\xaf\x16\xdb\x4c\x41\xee\x7a\xd1\xaf\xa7\x3c\xec\x8d\x0c\x4a\x0b\x5b\xcb\x61\x11\x11\x5d\x91\x43\x92\x22\x22\x8a\x23\x12\x23\x22\x90\x43\x92\x23\x24\x95\xa9\x71\x14\x8d\xd7\x20\x9f\x4b\xb0\x5b\xd4\x6a\xa3\x4e\x67\x43\xe2\x58\x51\x1f\xd8\x88\x09\x4b\x43\x6f\xd0\x33\xbc\x2c\x9c\xa1\x9d\xca\x6a\x4a\x1c\x6f\xd7\x62\x89\xae\xdc\x9d\x92\x3a\xb8\xd4\x52\x49\xa7\x69\xc0\xaa\x80\x92\x40\xcb\x2b\x24\xb5\x83\x05\xc6\xca\x2d\x38\xe6\x20\x8c\x0f\x2d\x33\x33\x71\x90\x46\x5f\xac\x60\x30\xb8\xe8\xf6\x39\x3a\x9d\xd3\xae\x56\x3b\x6d\x5a\xad\x43\xa5\x72\x8a\xf6\x18\x3b\xe5\x4b\xad\x9f\x8b\x69\x23\x96\x56\x63\xb8\x08\x75\x9a\x80\x59\x8e\xae\x1e\xa1\x9b\xae\x4b\xc3\x76\x95\x44\x88\x2e\x1f\x5d\x61\xbc\x21\x89\x44\x8b\xf5\x5c\x54\xc5\x09\x15\x31\x2b\xde\xd6\x23\xc1\x0a\xc4\x64\x14\x6b\x93\x20\xdc\xcd\xe2\x1e\x26\x27\x2d\xcd\x74\x39\x14\xae\x15\x48\x41\xc4\xbd\x76\x9b\xdd\xe2\x9e\xd6\x51\xe2\x1e\xee\x66\xe1\xf3\x60\x78\xcc\x2b\x3e\x75\x86\xa7\xb5\xba\xe0\xaa\xf0\x81\x8d\xc2\x67\x9d\xe1\x43\xfe\x7b\x08\xbe\x12\xe5\xbf\x47\x45\x50\x1f\x0c\x85\xe7\x3e\xb9\x66\x78\xb6\x1e\x02\x86\xe7\x3e\x09\x64\xe3\x11\x0c\xcf\x7d\x1c\x05\x1f\x04\x22\x5e\x1d\x1e\x61\x47\xc2\x67\x93\xa9\x81\x7f\x8b\x7b\xa4\x27\x23\x6b\xb4\x58\xd9\xe8\xdb\xf0\xcc\xab\x02\xe2\x25\x65\xa4\x27\xa9\x20\xfd\xc8\x40\x52\x4d\x6a\xe8\xaa\x56\x64\x1c\x69\x20\x37\x90\xa9\x64\x26\x99\x4d\xe6\x92\x85\x64\x29\x59\x4e\x56\x91\xbb\xc9\x3a\xb2\x9e\x6c\x24\x5b\xc8\x23\xe4\x31\xf2\x24\x79\x8a\xeb\xee\xbb\xf9\xf1\xed\x0f\x6d\x6e\xda\xb5\x6b\xe7\xcd\xa3\x06\xe4\xe9\x17\x2f\xbe\xa9\xb6\x7f\xae\x6e\xd1\x8d\x43\x4b\x12\xc4\xb5\x6b\x27\x0f\x29\x8e\x17\xd6\xcc\xf1\xf7\xcd\x32\x2f\x5b\x76\xcb\x18\x5f\xa6\xe9\xb6\x49\x23\xca\x5d\xea\xfb\xee\x9b\x38\xbc\xbb\x53\x75\xef\xfc\xfa\xde\x69\xf6\x95\x2b\xe7\x8d\xef\x95\x6a\x5b\xb1\xe2\xde\xdb\xd6\x2c\x12\x57\xef\xd8\xb6\x75\xd3\x86\x9d\x3b\xa7\x0f\xea\xe6\x86\x3b\xef\x9c\x56\x55\x98\x4c\x56\xaf\x7e\xe6\xe9\xa7\xd6\xaf\xbb\x7b\xf5\xdd\x2d\xc0\x37\xfb\x9f\x9c\x7a\xc3\xcc\x69\x33\xf1\xd6\xa7\xf1\xef\x98\x3c\x71\x5a\xc3\xb8\xd1\xb5\xa3\x83\x8f\xe3\xc7\xd4\x3e\x76\x7d\x4d\x75\x55\x75\xf0\x71\xdb\xf0\x21\x55\xfd\x2a\x06\xf6\x1f\x18\x7c\xf4\xf5\xea\xff\x48\xcf\x32\x6f\xa1\x37\xf8\xb8\xb5\x7b\x71\x61\x4e\x46\x41\x6e\x41\xf0\x31\x33\x35\x77\x4b\x52\x9c\x27\xd9\x13\x7c\xdc\x14\xef\x4c\x76\x58\x8d\xd4\x12\xa1\x8f\x36\x93\x6e\x23\x7a\x88\xd4\x9b\xa2\x8f\x1b\x50\xb5\xac\x5a\xbe\x74\xd1\x52\xfa\x58\xe1\x5f\x71\xdb\xa2\x98\x5a\x88\xab\x02\x57\x7f\x88\x2b\x84\xb8\x5c\xb0\x25\xc3\xb4\xda\xaa\xfe\x85\xb9\xc9\x3a\xb2\x68\x11\xd1\x25\xe7\x16\xf6\xaf\xaa\x9d\xa6\xb9\x69\xe7\xbd\x6b\xe2\x56\xf7\x5c\xcd\x19\x57\x83\x9a\x5b\xbd\x70\xee\xec\x9b\x66\x23\x8c\x17\xfd\xf3\x6e\xb9\x89\x84\x67\xb8\xb0\x26\x55\xba\x4c\x7a\x70\x40\x73\xe8\x17\x19\xfd\x1e\x9c\x05\xd3\x39\xd2\xeb\xff\xd2\x9b\xce\x71\x63\x51\xd3\x86\x82\xa3\x05\x83\xa8\x74\x79\xfd\xff\xdf\x43\xf0\x4a\xe7\xea\xd8\x3d\x69\xa1\x43\x8c\xba\x97\xff\x07\xef\x1d\xff\x07\xe1\xe1\xbf\xdc\x9b\xaf\x71\x4c\x9d\x36\x0d\x1e\xc5\x63\xc7\xd4\xa9\x81\x26\xbc\x3e\x16\x3c\xce\x4c\x9d\xaa\x4c\x9c\x36\x4d\x69\x9c\x36\x4d\xd0\xe3\x75\x52\xf0\x38\xd3\x19\xfa\xcc\x35\xdf\xfe\x01\x8c\x33\x9d\x6f\xdb\x5f\xef\xbc\x6f\xfb\x67\x67\x4c\x7a\xed\xfc\x89\x29\x8d\xf4\x37\x69\x62\xe7\xef\x86\xab\xef\x27\xd1\x5f\xe3\x04\xfa\x6b\x64\xf7\xc1\xd7\xf2\x8f\x2c\x32\x78\xd8\x93\x72\xa9\x51\xb9\x34\x51\xb9\x88\xff\x93\x94\x2f\x26\xc9\x3f\x4d\xa4\xab\x3a\xfd\xbf\x27\x33\xc8\x1e\xf2\x3c\x79\x91\x1c\x22\x2f\x91\xa3\xe4\x38\x79\x83\xbc\x43\xce\x90\xb3\xe4\x1c\xf9\x9c\x5c\x22\x5f\x91\xef\xc8\x0f\xe4\x32\xf9\x27\xf9\x8d\xb4\x91\x0e\xe0\x41\x06\x2d\x18\xc1\x0a\x0e\x88\x83\x24\xf0\x40\x06\xe4\x40\x01\x78\xa1\x0c\x7a\x42\x05\xf4\x83\x81\x50\x0d\x35\x7c\xed\x8b\x5c\x51\xe3\xee\x16\xd0\x34\x8b\x9f\x7c\xc2\x7b\x6f\x78\xaa\x05\xb4\x3e\xbb\x78\x2e\x71\xd8\xfd\xfb\x7e\x15\xbf\xf8\x22\xa9\x66\xfd\xf3\xbf\x89\x97\xa4\xd2\x29\x4f\xb4\x80\xa1\x59\xfc\xf0\x43\xb9\x6c\xea\x93\x2d\x60\xc4\x40\x67\x53\x46\xde\xfe\x42\xab\xf8\x97\xbf\x78\xae\x5f\xfe\x62\x9b\xf8\x95\xa6\xc7\x8c\x47\x5b\xc0\xd2\x2c\xbe\xf7\x9e\xb6\xe7\xcc\xc7\x5a\xc0\x8a\x81\xce\xa4\xd7\xdd\xd1\xac\x88\xdf\x7e\x9b\x31\x7a\xd5\xa1\x0e\xf1\x3b\x43\x9f\x59\x0f\xb7\x40\x4c\xb3\xf8\xf6\xdb\xc6\x8a\xd9\x8f\xb4\x80\xe3\xa0\xf8\x4e\xf6\xd8\xbb\x8e\x50\xe5\x26\xfe\xed\x6f\x39\xe3\xee\x7e\x09\xab\xf5\x41\xf1\x07\xcb\x75\xb7\x3e\xd8\x02\xb1\xcd\xe2\xa9\x53\xd6\x7e\x73\xb7\xd0\x25\xfa\xc4\x37\xf2\x27\xdc\xf3\x6a\x0b\x48\xcd\xe2\x4f\x3f\x15\x34\xac\x3b\xda\x02\xf2\x41\xf1\x72\x4c\xe5\x82\x07\x5a\x20\xb1\x59\x7c\xfd\x75\xc7\xc0\x85\x1b\xfb\x5a\x21\x09\x15\xec\x71\x48\x87\x7c\x28\x85\x3e\x30\x18\xb5\x43\x25\xfe\x65\x20\x01\xca\x30\xf3\xd5\xf8\x3c\x10\x06\xfa\xf4\xc7\x2f\xbf\xf1\xc3\x3b\xdf\x9d\xf9\xea\xec\xa5\x73\xba\xcf\x5b\xe0\x3a\x9f\x29\x76\xf0\x92\x67\x7f\x11\x3f\xfb\x2c\xae\x7a\xe9\x9e\x7f\x8a\x9f\x7f\xde\xd7\x02\xc3\x91\x78\x39\x48\xb8\x9e\x50\x83\xf1\xfa\xe1\x5f\x0a\x64\x43\x11\xf4\x80\x61\xf8\x7c\x1d\xfe\x8d\x38\x70\xfc\x8d\x77\xce\x9c\x6d\x81\x7e\x87\xa4\x73\xe7\x8e\x9d\x78\xf3\xdd\xf7\x5b\xc0\xd7\x2c\x7d\xf4\xfc\x8b\x87\x5e\x42\x1c\x2b\x0e\x49\x7b\xf6\x3c\xb7\xff\x40\xcb\xcb\x2d\xd0\xab\x59\x7a\x7a\xe3\x96\x47\x1e\x43\x1a\xf6\x3c\x24\x3d\xf5\xd4\x86\x4d\x5b\xb7\xed\x68\x81\xee\xcd\xd2\xce\xe5\xab\xee\x5e\xb7\xbe\x05\xca\x0e\x49\x4b\x97\xde\xb6\x62\xf5\x9a\x7b\x5b\xa0\xb8\x59\x5a\x34\x75\xe6\xec\xb9\x0b\x5b\xc0\x7b\x48\xba\xe1\x86\xc9\xd3\x6e\xba\x65\x5e\x0b\x14\x36\x4b\x13\x6b\xae\x1f\x3d\xae\xa1\x05\x0a\x0e\x49\xd5\xd5\x43\x86\xd7\x8e\x19\xdf\x02\xb9\xcd\x52\x55\x59\xcf\x8a\x7e\x28\xb5\x73\x0e\x49\x5e\x6f\x71\xf7\x5e\xbe\xfe\x2d\x90\xd9\x2c\x15\x26\x79\x32\x72\x50\x5c\x67\x1c\x92\xe2\xe2\xe2\x93\x53\x33\x73\x5b\x20\xb5\x59\x72\xca\x5a\xa3\xd5\xd1\x02\x9e\x43\xe8\xe2\x0b\x2a\x9d\xc9\xd6\x02\xc9\x07\x24\xf2\x5b\x5b\xc7\x11\xc6\x42\xd5\x07\xa5\x7f\xfe\xf3\x5f\xbf\xb7\x1f\x01\x02\x02\x54\xf9\x1c\xd2\xcf\x1f\x3d\xbd\x73\xd1\xc4\xaa\x42\x27\xf9\xf9\x67\xe2\x2c\xac\x9a\xb8\x68\xe7\xd3\x1f\x69\x5a\x40\x75\xe0\xc2\x97\x5f\xff\xf5\xef\x2d\xd0\xff\x90\xf4\xe9\xa7\x97\xbe\xfa\xee\x87\xcb\x7d\x6d\x30\x90\x48\xe4\xf3\x28\x36\xac\x21\x12\xb2\xa5\x16\x74\x60\x02\x1b\x38\x21\x1e\x86\xe0\x1b\x15\x29\x70\xa0\x8c\x73\x78\x43\x97\x2e\xc2\xdb\x1c\x7c\xf7\x7f\x7a\x81\xc8\x5d\xe4\x86\x0a\xe6\xff\x3b\xc0\xbb\x5c\x82\x32\xba\xec\x1a\x87\xf8\xff\xc1\xfb\xb4\x2b\xde\x85\xe5\x7b\xc6\x35\x0e\xf9\x0f\xe0\x38\xfe\x97\xe1\xe1\x7f\xf9\xde\x1a\x82\xe5\xf8\x7f\xb8\x9a\x43\x61\xa7\x32\x41\x8f\xff\xef\xb3\x7f\xbc\x69\xbb\x17\x15\x45\xf0\x3f\xf8\x76\xea\xd4\xf6\xb1\xff\x07\xa1\xe0\xd1\xe8\x30\xaf\x4f\x9d\xca\xef\xea\x1a\x08\xff\xa7\x5e\x05\x6c\xea\xff\x20\x4c\xdb\x3f\xff\x27\x38\x04\xa3\x4e\xfd\xa3\x33\xbd\x86\x34\x57\xe3\x55\xfa\x6b\xe2\x1f\xe8\xb2\x3f\x7c\x3f\xa9\xf3\x17\xd4\x71\x13\xa2\x34\xdd\xa4\x28\x7d\xd7\x45\xeb\x35\x46\xeb\xbe\x89\x61\x0d\x38\x29\x04\x1c\x0f\x04\x46\x1f\x31\x38\x06\x22\x74\x57\x32\xb4\xb7\x3f\x46\x5d\x38\x88\x0c\x25\x23\xc8\x28\xe2\x27\xf5\x64\x12\xb9\x91\x4c\x27\x37\x93\x39\x64\x3e\x59\x4c\x96\x91\x95\xe4\x4e\xb2\x96\xdc\x47\x9a\xc8\x66\xf2\x10\xd9\x4e\x1e\x27\xbb\xc8\x33\x64\x2f\xf9\x13\x39\x48\x0e\x93\x57\xc8\x6b\xe4\x24\x79\x8b\x9c\x26\x1f\x90\x8f\xc9\x79\x72\x91\xfc\x99\x7c\x43\xbe\x27\x3f\x92\x7f\x90\x7f\x93\xff\x90\x00\x00\x88\xa0\x06\x3d\x98\xc1\x0e\x2e\x48\x00\x37\xa4\x41\x16\xe4\x41\x37\x28\x81\x72\xe8\x0d\x7d\x61\x00\x0c\x82\xa1\x30\x82\xef\xef\xbb\x89\x54\x4e\xbb\xed\x99\xbf\xc6\x8a\x6f\xbd\xc5\xe4\x9e\xc8\xd7\xcc\xde\xfc\xfc\xbf\xc4\x33\x67\x86\xdc\x74\xef\x73\xff\x11\xdf\x9d\xbc\x7c\xd7\xd7\x89\xe2\xc9\x93\xd3\x97\xed\xfe\x3e\x4e\x3c\x75\xfd\xdc\xf5\x2f\xfe\x2c\x9e\x3d\x3b\xfc\x96\x07\xf6\xff\x5b\x7c\x7f\xe2\xaa\xc7\xbf\x4c\x11\x5f\x7b\xed\xc6\x15\x4f\x7c\x93\x24\xbe\x3e\x7a\xe1\x96\x43\x7f\x17\xcf\x9d\xab\x9d\xb7\xe1\xc0\x3f\xc4\x8f\xc6\xdf\xbd\xfd\x42\xba\xf8\xca\x2b\x93\x56\x3f\xfa\x67\x8f\xf8\x6a\xdb\xab\x28\xe5\xe2\x50\x6f\x0c\x47\x1d\xd1\x13\x7a\x36\x8f\x59\xb4\xb5\xe5\x47\xf1\xd3\xa3\xa0\x42\xc1\x97\x05\x55\xe8\x5f\x88\x88\x61\xf9\xa1\xfa\x35\x0f\x5f\xcc\x10\x8f\x74\xf4\x4d\x40\x39\xe9\x46\x0d\x35\x04\x3f\x54\x40\x05\x69\x47\x29\x19\x0f\xb9\x30\x02\x9f\x7b\xa1\xf4\x75\x60\xd6\xfa\x93\x7c\x7c\x2a\xc1\x3f\xda\x2d\x9e\x0e\x83\xd0\xa8\x10\xa1\xf4\x10\x93\xf4\x62\x55\x55\x5f\x0d\x0a\x6a\x13\x24\x42\x21\x0c\xc5\x0f\x3e\xfc\x2b\x85\x5e\xbe\xf8\x23\x9f\xbe\xfa\xd1\xeb\xef\x9f\x7a\x97\xd7\x41\x65\xf5\xcc\x75\x7b\x7e\x17\xdf\x79\x47\x54\xeb\xcd\x76\x11\xa0\xaf\x1a\x46\x22\x15\x9d\xa8\xd6\x06\xa0\x85\x22\xa2\x6a\x2b\x3a\x54\x54\xda\xa3\xcf\x75\x62\x65\x65\x0b\x5c\xff\xc2\x7b\x1f\x7e\x72\x18\xb5\x5d\x9f\x43\x03\xa5\xb7\xdf\x7e\xe5\xb5\x93\x6f\x1d\xa6\xc4\x3d\x28\x71\x2f\xa3\xaa\x3b\x0c\xc5\xd0\xfd\xa0\x24\x8a\xa8\xeb\x0e\x53\x13\xe3\x60\x7f\x69\xcf\xbe\x17\x9a\x0f\xa3\x8e\xcc\x3f\xd4\x4f\x7a\xf6\xd9\xed\x8f\xef\x7a\xe6\x30\x2d\x96\x83\x92\xb4\x6d\xc7\xce\xa7\x0f\x43\x2a\x64\x1e\x94\xd4\xea\xf5\x9b\xb7\x1c\x46\x1a\xb9\x0f\xfa\xa4\x75\xf7\x6f\x7a\xf0\x30\xc4\x42\xf2\xa1\x0a\xe9\x9e\x7b\x6e\x43\x4d\x78\x18\xc9\xe4\x38\x28\x69\x96\xde\x7e\xc7\x5d\x87\x51\x7f\xc4\x1c\x94\xf4\x7a\x54\x84\x87\xa9\x59\x73\xb0\x97\x34\x73\xd6\xad\x0b\x0e\x83\x06\x0c\x87\x7a\x4a\x33\x66\x8c\x9f\x38\x79\xda\x61\xa4\x91\xea\xa0\x64\x18\xd7\x70\xc3\xd4\xc3\x54\x7b\xf9\x9c\x92\xd9\x8c\x6a\xb2\xad\xa3\xbb\x54\x3d\x6c\x64\x5d\xab\x52\x26\x0d\x1e\x4c\xd5\xd4\x61\xe8\x0f\x55\x07\x25\xcb\xe7\xa8\xa7\x0e\x53\x5b\xe8\xa0\x64\xb7\xff\xfd\xe7\x7f\x1d\x86\x21\x30\xdc\x97\x5e\x2c\xfd\x1e\x9b\x98\x92\x9e\x9d\x2f\xc5\x70\x7b\xa4\x75\x9a\x99\x86\x6a\xcb\xef\x31\x31\xbf\x5b\xaa\x0d\x33\x35\xeb\xa4\x3d\x9c\xd6\x79\xe6\xec\xb9\xc3\xd4\x90\x3a\x54\x25\xbd\xf3\x0e\xfc\x70\xf9\x9f\x87\xa9\x39\xe5\xd3\x79\xa5\xdf\x7e\x63\xfa\xb5\x50\x72\x46\xb4\xda\x55\x3a\xad\xe0\xff\x9e\xce\xf9\xff\x4e\xaf\x85\x9c\x70\x6f\x89\xe7\x1a\x87\xd7\xfe\x47\x87\xc7\xee\x35\x5f\xe3\x80\x2b\x02\x3a\xf0\x5d\x46\xd4\x21\x5f\xf1\x5d\xc4\x77\x65\xd1\xcf\x78\xb8\xf1\x90\x4b\x3c\xf6\x34\xbc\x5a\xf1\xea\x89\x3a\xae\x8c\xff\xff\xf8\xfd\x8a\xf4\xe1\xca\xe7\x2b\xf0\x0c\xc7\x97\x43\x78\x51\x7c\x1c\x08\xd7\x71\x05\x7c\xeb\x95\xcf\xa1\xf8\xe1\xab\xf8\x71\x6b\xce\x8c\xce\xdf\x4c\xfa\x47\x7f\xe1\x6b\xf8\xd7\xba\xb9\xf3\xd5\x27\xf8\x3f\x63\xc6\xc7\xf8\x1f\x7a\x17\xf8\xdb\x8c\xd0\xc7\xf6\x67\x67\x42\xc5\xcc\x8f\x67\xc2\x9e\x99\x9d\x60\xa2\x60\x75\x7d\x8e\x00\xe2\x62\xd8\xc3\xc7\xec\x9f\xfb\x81\x86\x88\x24\x30\x93\xc2\x56\xea\xf0\xcb\xc7\xe1\xd8\x91\x2b\x0d\x33\x93\x45\x0a\x6c\x84\x94\x49\xf4\xdf\x33\x11\xdc\x8d\xec\xbf\x8b\x06\x7a\x2d\xe2\x2c\xe1\xff\x04\x3c\x4b\x33\xc2\x9f\x8e\x5d\xa9\xd4\x8e\x85\x6f\x8e\x47\xeb\x9a\xab\x74\x56\xe7\xab\x48\x28\xe9\x74\x58\x4f\x85\xb5\x25\xa6\x1a\x4a\x62\x52\x04\x74\x10\xec\x6b\x11\x60\x41\x40\x9d\x00\x58\xe4\xe0\x98\xdd\xa5\x64\xbe\x30\x56\xa8\x0d\xee\x4b\x45\x44\x81\xa7\xc3\x68\xc2\xc3\x75\xdd\x66\xf7\x52\xfe\x52\xbb\x5b\xa8\x6d\x77\x13\x8e\xd0\x15\x56\xcf\x08\x6f\x31\xdf\x2f\xd1\xa7\x13\x88\x8c\xc2\x58\xa5\x16\x88\xc8\x93\x82\xd3\x17\x4f\x47\x8d\xd5\xa3\x51\xad\x66\xb7\x59\x12\xde\x6a\x2b\x1b\x22\x74\xa3\x17\x61\x59\xdb\x19\xa1\x1b\xa6\x79\x33\x2c\xe7\xa6\xf3\x4b\x43\x69\x0a\x22\x70\x51\x63\xf8\x69\xab\xd6\x74\x45\x80\x76\x58\x0e\xed\xc1\x71\x48\x9d\xe1\x59\xba\x32\xd0\xc6\x7b\x95\x5a\x06\x09\x23\x7a\xbb\xee\x28\x1d\x5a\x25\x37\x08\x62\x88\xb2\x8d\x42\x51\x86\x43\xa3\xf2\x68\x30\xbf\xf8\x53\x11\x6e\xda\x35\xf3\x4b\xc7\x58\xab\xc8\xef\xf8\x39\xb0\x95\xf6\xa7\x62\x14\x69\x88\xb0\x0f\x31\xb0\x1e\xe2\x80\xd0\xa5\x80\x43\xa1\xe9\x80\x35\xb7\x1a\x43\x70\x63\xb8\x3a\x61\x5f\xdb\x48\xd6\xa7\xdf\xd4\xf1\x8d\x34\x56\x78\x0e\xc3\xb3\x7c\xf1\xc1\x3d\xbe\x82\xb0\xd5\x1c\x34\x31\x22\x3c\x17\x78\x34\xf0\x48\x70\x0c\xc0\xa3\x18\x7e\x88\xb0\x31\x02\x9f\x22\xd3\x09\x5f\xcd\x49\x43\x02\xcf\x06\x9e\x16\x36\xb6\x8d\x44\x24\xae\x80\x4f\xb8\xce\xd0\x8c\x6e\x66\x90\xc6\x52\xf0\x6d\xe5\xdc\x8d\xa1\xb1\xec\xf1\xe2\x6e\xb6\xef\x5e\x4f\x9f\x5b\x2d\x8a\x5a\x99\xe3\x34\x5a\x95\x04\xbc\x00\xfb\xb5\xb0\x43\x0b\x1b\xb4\x50\xa3\x85\x0a\x2d\x14\x68\x43\xa3\x91\xd9\xee\x1b\x51\x53\x19\x30\x97\x1e\x35\x78\xd5\x02\x57\x37\x4d\xe9\x0d\xc7\xa7\xc1\x29\x45\x56\x2e\xd1\x95\x54\xb8\x0f\xb8\x8f\x03\x79\xf0\x67\x25\x49\xb1\xc0\x4f\xac\x9c\x9e\x22\x4f\x08\xf9\x42\x16\x9b\xaf\x89\xe5\x64\x22\x4e\x15\x51\x25\xbb\x6d\xba\x78\x01\x0b\xf8\x42\x17\xfe\x08\x0f\xf8\xb5\xd1\xb1\xfe\xf9\x50\x66\x63\x4b\x59\x01\x5d\xca\x8a\x8e\xef\x7f\x6a\xd1\x07\x8b\x97\x7c\xb8\x78\xf1\x07\x4b\x97\xbc\xbf\xa8\xae\xf1\xa9\x1b\x1a\x9f\x99\xdc\xb8\xa7\x71\xd2\x33\x8d\xdc\x64\xfa\xfe\x2c\x7e\x5a\xb4\xe8\xfd\x25\x8d\xcf\x4c\x9a\xf8\x6c\x23\x7e\x69\x7c\x86\x2d\xc9\x4f\x1a\x49\x9d\xd0\x20\x8c\x44\x4e\x31\xb2\xf9\x79\x19\xa8\xf1\xcb\x48\x05\x19\x48\x6a\xc8\x68\xd2\x40\xa6\x92\xd9\x64\x21\x59\x8e\xe4\xb4\x79\x52\x4a\x8a\xbd\x45\x19\xa1\xab\x35\x74\x75\x84\xae\xe1\xef\xf2\x15\xcf\x57\x5e\xaf\xfc\x7e\xe5\x73\xda\x15\xf0\xc3\xe9\xf1\x9f\x16\x77\xef\x5e\xbc\x89\x9e\x7e\x2b\x2b\x29\x2b\x49\xa5\x77\x4a\x59\x29\xfe\xf6\x96\x95\x94\x94\x71\x23\xe9\x39\x10\x4b\x5f\x70\xab\x22\x61\x03\xfb\x8a\xbb\x97\x96\xb2\xc0\xf0\x26\xfd\xa6\x8c\xa7\xe7\xdf\x68\xe0\x4d\xf4\x8e\x7f\x10\x4f\xb9\xf8\xa4\x9c\x2d\x2b\x2b\xf9\x0a\x1f\x60\x23\xde\x8c\xa5\xc0\x16\xe2\x09\x0e\x97\x7a\xcb\x03\xfd\xf1\xee\xa1\xe2\xe2\xee\x5c\x7c\x28\x90\xc2\xe3\xcd\xd7\x34\xda\xc7\xdd\x8b\xbb\x67\xe3\x4d\xb0\xbe\xbc\x40\xd6\x0a\x1e\xbe\x95\xe8\x49\xac\x4f\xaf\x11\x0c\x46\xd9\x88\x14\xad\x21\x74\x1f\xbd\xfa\x48\xa5\x65\x25\x49\x3c\x29\x84\x2e\xa2\xc4\xcd\x98\x75\xfe\x56\x45\x39\xd4\xac\x28\xb3\xcf\xf1\xad\xf3\x3e\x9b\x71\x48\x51\x80\x6f\xbe\xe9\xe3\x85\xc1\xfa\x9c\x85\xbc\xf9\x9c\x40\xd7\xc1\xb6\x52\x3e\xd1\x71\x02\x70\x18\xdf\x84\x7e\xf2\x95\x72\xc4\x8b\x75\x12\xae\xe0\x8d\x2c\x61\x55\xbb\xb0\xe0\x9d\x85\x0b\x4e\x2f\x58\xf0\x2e\x9e\xe7\x0b\xab\xda\x96\x71\x7d\x17\xbc\xbb\x00\xef\xf1\xe5\x42\x3a\xe3\x31\x3a\x0d\x0f\xc9\xf5\x59\x75\xf1\xf1\x9c\x60\xb3\x61\x4a\x69\xa9\x26\x27\xf2\x25\xad\x3d\x17\x2f\xbe\x67\xba\xf8\x5e\x97\x29\xa5\xa1\x34\xaf\xe0\xcf\x8c\x6b\xe0\x30\xa2\xf1\xd9\x49\x93\x90\xf9\xd8\x79\xe8\xd5\x08\x45\xbe\xe1\x39\x1a\x39\x46\x83\xb9\x70\x27\x77\x03\x3f\x1f\xe9\xea\xa2\x34\xb0\x19\x08\x91\xe5\xd8\x38\x07\x6f\xd6\xb0\x9d\x7b\x28\x4e\x6c\x22\x46\x68\xf0\x3f\x5b\x61\x98\x0e\x32\x94\xc3\x53\x5b\xbd\x45\xa5\xdc\x0d\x5b\x26\xf5\xbf\xa5\xff\xc6\x1b\xa7\x0e\x1c\x3c\x64\x4a\x65\xe5\x94\xc6\xc1\x43\x1b\xb8\x65\x33\xef\xeb\x7b\xeb\x80\xa9\x4d\x83\x07\x4e\xad\x9c\x32\xa5\x72\xe0\x8d\xd3\xd1\xe6\xfd\x13\xca\x8e\xc5\x28\x3b\xb4\xc4\xc9\x56\x46\xee\x41\x6e\xf1\x55\xe8\x7a\xb8\x92\x4a\x73\xd2\x92\xd2\x88\x55\x22\x52\xaf\x9e\x99\xf1\x29\xf9\x29\x25\xdd\xa6\x75\x03\x7f\x37\x18\xd8\x0d\x5c\xdd\xa0\x9b\xb7\xbb\x31\xa5\x21\x65\x76\x0a\xaf\xea\xee\x53\x1b\xaa\x52\xba\xa7\x74\xe7\x8d\x46\x35\xa8\x63\xa8\xd0\xbf\x50\x7f\x9a\x2d\x10\x96\x33\xa1\xde\x74\xda\x1b\x6c\x85\x36\x7b\x4d\x11\x99\x6c\x09\x8f\xa9\x65\xf9\x20\x72\x0a\xc9\x28\x26\xee\x64\x22\x17\x93\x0c\x3a\x1e\xd3\x46\x1c\x45\x24\x7a\x76\xb9\x18\x75\x0f\x6c\x0d\x2a\x36\xf3\x61\xb1\xb2\xb5\x3d\xa0\x3c\x0c\xd0\x88\x05\xc8\x41\xe3\x58\xe5\xbd\x4f\x3f\xdb\xf2\x10\x14\x7d\x7a\x1e\x0a\x03\xe3\xf2\x93\x93\xf3\xf2\x92\x93\xf3\xe1\x6c\x6e\x72\x72\x41\x41\x72\x72\x6e\xe0\x6f\x43\x36\x36\x0d\xe9\xd3\x78\xf8\x70\x23\x57\xa5\xa0\x1e\x80\x29\x81\x56\x98\xa1\x6c\xfe\xcf\x79\xb4\xff\x1f\x7e\xe8\xfc\xa7\xca\x7b\x80\xa6\x7d\x5d\x72\x7e\x38\x32\xbb\x2a\x47\xd7\xae\xf5\x1c\x39\x42\xfb\xb2\xe0\x03\xa4\xd9\x43\x8c\x66\x0e\xe4\xa1\x3c\x32\xd9\x57\x9e\xaa\xb3\x64\x26\x3a\x2d\x4e\x24\x17\xc9\x2f\x70\xdb\x8d\x71\xc6\xac\xbc\x69\x79\xe0\xcf\x83\xea\x3c\xe8\x9d\x07\x79\x39\xe9\x46\x63\x92\xb1\xc1\x38\xdb\x28\xa8\x6a\xd2\x1b\xd2\x39\x63\xba\x31\x5d\x8d\xb4\x7a\x97\x2d\x70\x8a\x74\x7a\xaf\x93\x4e\xef\x85\xe8\x64\xe9\x1c\x7a\x1c\x4d\x25\x31\xaa\xac\xd3\xa2\xee\x19\x61\x32\x18\x61\x1e\xba\x82\x30\x01\x72\x0d\x5a\xec\xa3\x64\xe8\x33\xa4\x69\xe3\x90\xae\xb4\x58\x12\x95\x71\x7a\x55\x2e\x1c\x39\xe2\x59\xbb\x96\x8e\xf7\xa8\xec\x98\x2b\x19\x84\x9e\x6c\x3f\x93\x5a\x5f\xb7\x12\x93\x56\xd6\x70\xd9\xd9\x31\xae\xfc\xf4\x94\x04\x8f\xc7\xa5\xe1\xcb\xbb\x77\x5b\xe1\x7a\xdf\xf5\xa5\x8b\x5f\xee\x82\x42\x17\x14\xb8\xc0\x95\x63\xcc\xae\xc8\xae\xc9\xe6\x55\xd9\xa4\x60\x42\x3d\x72\x07\xfe\x22\xb3\x9e\x23\x1d\x8d\xac\x9d\x1f\xbc\xf6\x44\xa0\xdb\x54\xc6\xd0\xd6\x10\x89\xee\x56\x69\xe0\x64\x34\x25\xd3\x33\xe4\x8c\xb2\xf4\x0c\x4f\x89\xb7\x94\x6e\x64\x59\x5a\xe6\x08\x65\x9b\xae\x4a\x91\xce\xaf\xbd\xee\xba\x1b\x7a\x1d\xc9\x6b\xa9\x93\xce\x9d\x33\x57\xb7\x74\x6b\x4e\x1d\xdc\xa7\xe4\xba\xc5\x93\x5f\xce\x69\x1e\x66\x3a\x77\x4e\x37\xfc\x40\xe6\x2b\xb3\xe6\x24\xad\x7b\xed\xf8\xda\x75\x13\x6f\x38\x21\xf4\x3c\x2f\x65\xe4\x35\xe7\xb5\xcc\x99\xd7\x67\xd9\x44\x0c\x14\x9b\x6d\x52\x9d\x3f\x6f\x1e\x74\x20\xaf\x65\xf2\xb2\x3e\x2b\x1a\x10\xc2\x50\x7d\xef\x53\x6b\xd6\x9c\x98\x34\xe9\x9e\x35\xa7\x68\xde\x3f\x23\xc3\x85\x74\x61\x25\xd6\x94\x0c\x52\xe7\x2b\x4a\x35\x69\x2d\x06\x83\x9d\x24\x38\x04\x81\x68\xf9\xac\x4c\x8b\xdd\x48\x9c\x26\xe7\x70\x27\xef\x24\xc9\xf0\x73\x32\x24\x63\xed\x5d\x41\x38\x15\x71\xf9\xd2\x32\xab\x5c\x32\x56\x8c\x9c\x0b\x13\xea\x8b\x4e\xcf\xb9\xb5\xa0\x3e\x68\xa0\x74\x2e\xb5\x10\x2c\xe5\xd0\xb4\x67\x47\x70\x31\xf1\x60\x77\x2b\x1d\x4b\x11\x9e\xdb\x46\x33\x9b\x0f\xdc\x85\x21\x33\xfb\xef\xbb\x75\xc1\xf5\x75\x1b\x66\x00\xe9\x20\x83\xe9\x9a\xbd\x9e\xee\xe3\xcb\x97\x8e\x1c\xdd\xb3\x77\x79\x3d\x77\x9d\x76\xc8\x92\xea\xdb\x77\xd5\x5d\xbf\xe4\xe6\x27\xf4\xbb\x2b\x95\x56\x90\x2a\xb9\xa6\x92\x86\xf2\xba\xc5\x7d\x7a\xd7\xf6\x68\x28\xa6\xf9\x19\x41\x5a\x85\xe7\x31\x3f\xb9\xa4\x3b\xe9\xe3\x73\x17\xe6\x0a\x49\x7c\x46\xa9\xcd\x9d\xe1\x2e\xef\x91\x9b\x94\xed\x25\xa9\x2b\x52\xb9\xd4\x3c\x34\x07\xb4\xc6\x6c\x08\x96\xdd\xbb\xf5\xa1\xba\x1d\x1e\x3e\x4e\x47\xea\xb3\xa9\xa0\x74\xb1\x90\x52\x2f\x9b\x7e\x81\x19\xb0\xcb\x6c\xb1\x49\x9b\x11\xa8\x94\x94\x63\xec\x51\x03\xa2\xa3\x57\x41\xe7\x3b\x36\xe6\xa8\x24\x49\xe5\xee\xdf\x73\x4c\x56\xaa\xde\x24\x99\x74\x82\x60\xb0\xa6\xa5\xea\x7f\xac\x7d\x7e\xde\xbc\xbd\xcf\x2c\x19\x78\xfd\xc3\xfe\xdb\x6e\x1f\xed\x5f\x72\x9b\x40\x72\x72\x44\x3d\x1a\x96\x82\x59\xaf\x33\xc4\xf5\x6a\x1c\xe6\x4d\x56\x4b\x52\xdf\xb1\x45\x3f\x8d\xb8\x79\xd9\xbe\x27\x97\x2c\x7a\x36\x27\x79\x89\xbf\x61\xc1\xb2\x31\xa3\x6f\x63\xf3\x33\xd0\x88\x14\xce\x10\x37\x29\xf4\xc5\x5a\xe2\xb5\x0e\xa3\x24\x39\xe2\xf9\x14\x8f\xda\xe5\x53\x69\xab\x5c\xe6\x1a\x54\xfc\x6c\xab\x0d\x14\x54\xde\x2e\x23\xd6\x01\x79\x10\xff\xd9\x18\xf1\x44\x2e\x09\xdc\x65\x28\xe4\x7b\x43\x78\x61\x77\x54\x66\xc9\xae\x89\x5b\xee\xab\xe4\xee\x18\xbd\xfd\x06\xbe\xe6\xc9\xd5\xaa\xf6\xbf\x4a\xb7\x3d\x37\x7a\xec\xb3\xfe\x3b\xfc\x37\xac\x5b\x2d\x9c\x99\xf8\xcc\xba\xdb\x57\x0f\x9c\xb8\xe2\xe8\x63\xbb\x27\xa8\xd3\xd2\x26\x3d\xd7\x64\x38\xba\x62\xbc\x7f\xcd\xc8\x85\x47\xa8\xfe\xec\x45\xd0\xc8\x14\xde\x20\xc5\xa4\xbb\x2f\x81\x33\x16\x67\xa2\xf8\x30\x0a\x25\xa5\xa9\x39\x05\xaa\x64\x9b\xa0\x4d\xd2\x82\x45\x6b\xa1\x4d\x29\xe1\x3d\x50\xeb\x29\xa5\xbd\x51\xd3\x6f\xb3\xa0\xac\x0f\x5f\x92\x11\x54\x44\x14\xab\x22\x47\x7a\x78\xb9\x4f\xbb\x4d\x2e\x2d\x0b\xf3\x11\x53\x54\x89\xbc\x43\xa8\x6c\x6f\x56\xdd\xbd\xb0\xa1\x84\x2b\x7f\xc1\x3f\x74\x65\xe5\x03\xf5\x7d\x26\xa7\x9b\xb5\x4f\xcc\x99\xb7\x63\x40\xad\x29\x26\x63\x7a\xff\x41\xdb\xe6\x75\x5f\xd0\xd0\x5b\xec\x76\xf3\xf2\x5b\x3d\x71\xa5\x8b\x36\x0f\x29\x58\xb4\x60\xc8\xed\x43\xe7\x3e\x0a\xde\xbe\x99\x69\xe9\x8b\x1f\xdc\x31\xb3\xae\x31\x93\x57\x0d\x1b\x32\x6f\xde\xae\x6e\x23\xa7\xdf\xfe\xd0\xa2\x12\x3b\xcd\xcf\x94\x8e\xef\xd1\x5f\x58\x8c\x75\xc3\xe9\xd3\x10\xbd\x55\x2f\xf3\xae\x58\x4d\xc4\x6c\x65\xb3\xb9\xf2\xa1\x00\x42\xfa\x2a\xc6\xc1\xd6\x7b\xa3\x4c\x6e\x00\xae\x31\x66\xdc\xfe\xb1\xd5\xa5\xeb\x6e\x1c\xbd\x3e\x3d\xe5\xfe\x31\x93\xd6\x8f\x99\x7d\xef\x4a\x47\x5d\xf3\xdf\x97\x4e\x5e\x79\xdd\xcc\xb5\xb7\x2e\x5a\x38\x7f\x4d\x63\xdd\xab\x6b\x5f\xfc\x98\xd9\x1e\xd7\x75\x7c\xc7\x7f\x88\xb4\xd3\x91\x38\x9f\x56\x23\xa1\xc9\xa1\x37\x54\x6b\x40\x43\x5c\x05\xf5\xe1\xce\x48\x3a\xeb\x97\x38\x24\x22\xa7\x73\xe9\x19\xa5\x84\x93\xab\x40\xbd\xa4\xbf\xf2\xde\xf5\x69\x87\x37\x8d\x9a\x87\xb6\xee\x1b\xcb\x94\x2d\x6b\x2b\x95\xe9\x9b\x06\x82\x78\x74\xca\x5a\xf0\x07\xed\x9a\x13\x24\x81\xef\x89\x75\xc2\x45\xf7\x69\xd4\x88\x9c\xc1\xe0\xb2\xb9\x44\x3e\x2e\x56\xaf\x52\x15\xe0\x77\x87\x19\x2b\xf1\xbb\xf5\xe5\x05\xe5\x5d\xf9\xc5\x6b\xa7\xa4\x96\x3d\x6c\xed\x82\xe8\xd1\xff\xf0\xfd\x90\x87\x6e\x9e\x50\x50\x7e\xab\x6f\xe3\xcc\xf2\x1e\xcb\x86\xe5\xe6\x0b\x2b\x27\xbf\xb6\xf1\xd9\x07\x17\xaf\x58\xb4\xe8\x51\xad\x22\x2d\xdd\x52\x9a\x3f\x74\x9e\x95\xcd\xe9\xfd\x58\xb8\x2c\xdc\x4d\xe2\x49\x32\x69\xf0\x95\x24\xea\x74\x24\xc1\x68\x8c\xb5\xc7\xca\x44\x48\x71\x1b\x12\xea\x12\xa0\x5f\x02\x24\xe8\x13\x4b\x13\x21\x2d\x91\x9a\x3f\x7c\x22\xa8\x12\xe3\x93\xe3\xc6\xc4\x41\x5c\x52\xbc\xd3\xa2\x11\xd8\xe4\x8b\x02\xb6\x4c\xa9\xd9\x3b\x21\xd4\xfd\xcb\xb4\x4a\xf4\xfa\x3f\x54\x9d\x84\x26\xd3\x52\x1c\xcd\x62\x04\x63\x07\x3e\xa5\x41\x5a\x89\x28\x5c\x2e\x5d\x3a\xa8\xbc\x7c\xc9\xb0\xc2\xec\xc0\x67\x6b\xe7\x96\xf7\xb8\xad\x26\x2f\x8f\x3b\x12\xd8\xc0\xa5\x07\x3e\x83\xff\x1f\x71\xef\x01\x18\x55\xb1\xfd\x01\xcf\x99\x7b\xef\x6e\x76\xd3\x76\x37\x8d\x54\x36\x1d\x08\x49\x20\x21\x09\x41\x20\x0b\x84\x5e\x42\x87\x00\x01\x42\x0a\x09\x25\x81\x24\x94\x88\xb4\x27\xea\x0a\xfa\xb0\xa1\x28\x2a\x45\xac\xcf\x06\x2a\x22\xea\xff\x09\x16\x50\xe1\xa1\x34\x41\x44\xa4\x29\x0a\x8a\x14\x51\x21\x7b\xf3\x9d\x39\x77\x77\xb3\x09\x89\xfd\xfb\x3e\x63\x0e\x93\xb9\x73\x7f\x73\xda\xcc\x9c\x99\x7b\xef\x4c\xee\x90\xd9\x23\x33\x53\x87\x55\x5a\xe0\x9d\x55\xea\xdc\x39\x6b\x32\x92\x07\xcd\x97\x02\xf8\x8f\x9b\xd5\xa9\xab\xe6\xac\x66\xbc\x7e\x6f\x7d\x18\x9d\xaf\x27\x9e\x01\x9a\xb6\x44\xb4\x8a\x92\x94\x00\x3a\x32\x84\xa6\x48\xb1\x01\x8a\x14\x2b\xce\x0b\xa7\xdf\x74\x29\x1e\x7f\xc5\xb6\x22\xf8\x8b\x57\xe2\xf9\xe3\x93\x33\xd5\x27\xfb\x4c\xee\x7e\x32\xe6\xd4\xc4\xd3\xb1\xa7\xbb\x4d\xce\x80\x71\x7d\x27\xe7\x9c\x89\x3d\x33\x11\x7f\xc3\xd4\x27\x27\xc1\x78\x08\x79\x08\xc7\xb7\x9c\xfc\xcd\xf9\x70\xb6\x60\x73\x01\x64\xab\x3f\xdc\x0f\x33\xd5\x6d\x53\x36\x4f\x51\x23\x90\xf0\xca\xfb\xd5\x56\x0f\x39\xe7\x76\x72\xad\xb2\x94\x05\xb1\x19\xb6\xae\x06\x25\xc8\x6c\x16\x3b\x86\x41\x60\x80\xc9\xcb\x5f\x92\x30\xce\xf4\xf7\x57\x7c\xa5\x90\x60\x6f\xb3\xd9\xcb\xa2\x0f\x0a\x92\x69\xc6\x60\x65\x92\x49\xb2\x30\x0b\xf3\xe7\xfe\x3e\x93\xf2\xfd\x2d\x62\xcb\xb0\x26\x7b\x67\xba\x5f\x38\x69\xd8\xc0\x83\xbe\x5c\x4a\x77\xef\x2e\xd9\x70\x74\x80\x73\x03\xb9\x8a\x3b\x07\x41\xe2\x20\x98\x1e\xaf\xae\x8a\x83\xe9\x09\xea\xaa\x76\xfc\x4a\xfb\xeb\x67\x46\xdb\x13\xec\x71\x77\x4a\xd7\xe0\x0e\xb5\x76\xfb\x9b\xdb\x8f\x9c\x86\xb7\xb7\xbf\xc9\xa0\xfe\x3a\x76\xd4\x37\xa3\x1e\x03\x68\x47\x40\x7f\x1f\x5f\x5f\x3f\xac\xcc\xdb\x4b\x2f\x1b\x02\x0d\x0a\x97\xa4\x20\x71\x24\x8d\x49\x1f\x10\x20\x23\xcf\x26\xc6\x7d\x83\x70\xca\x98\x93\xe3\x3c\x4a\xc5\xcd\xa0\xb6\x03\xa6\xf3\x91\xbc\x6b\xe7\x4b\xd7\x8e\xd7\x1a\x67\xe5\x0b\xc6\x43\xe8\xf8\x85\xf1\xf4\x33\x46\x3d\x3b\xfa\xe6\xf8\x9b\xe3\x17\x20\x4b\xfb\xd4\x14\x64\x49\xed\x45\x2c\x21\x4f\xd8\x0a\xe5\x15\xb4\x9f\x5f\x9e\x2d\x29\xc4\x64\x36\x82\x2c\x2b\xfe\xcc\x62\xe6\xfa\xc8\x08\x45\xa7\xf3\xb3\x18\x85\x02\x39\x46\x37\x2c\xd8\xcf\x4f\x36\xe1\xcc\x72\x52\xbe\xec\xfe\x44\x1a\xdd\x53\xa8\x4f\xf0\x95\xea\xa1\x3a\xd7\x66\xf5\x01\xe2\xb3\xbd\xd8\xee\xfc\x26\x71\x7e\x8f\x6b\xc7\x25\x38\xdf\x9f\x9f\x6d\x7f\xfd\xe2\x5d\x96\x4e\x29\xde\xf6\x56\xb6\xa9\x43\x22\x8a\x20\x71\x41\x44\xc7\x6c\xf3\x1d\x21\xb9\x33\x87\xf2\x71\xea\xf2\xd3\xfc\x60\x76\xcf\xf9\xb3\xba\x71\xee\xb8\x35\xb3\xf7\xbc\xaa\xae\x62\xef\x28\xec\x67\xc5\xd9\x44\xe2\x0c\xb6\x11\xb6\xf6\xfe\x96\x00\x23\xf8\xea\x7c\xc2\xc3\x39\xf7\xf3\xf6\x31\xf9\x44\x84\xe8\x74\x91\x01\xc6\x49\xf9\x38\x94\x8b\xa7\xd6\xd8\x0e\x7d\x2c\x3c\xdc\xb9\x3d\x27\x6b\xe5\xa1\x48\xe7\x81\x02\xd9\xd9\x9e\x7b\xc4\x0a\x45\xa6\xc9\x18\xaf\xb6\x05\xa1\xc7\x78\xa1\xd3\x68\xed\x0c\x94\xe8\xbc\xf5\xbd\x79\xe4\x55\x30\xab\x7b\xd4\x7a\xf5\x8e\x29\xea\xe7\x1b\xd7\xc2\x0f\x17\x12\x7f\x6c\x05\xd1\x8f\x3c\xba\x64\xbe\x7a\x4d\x8e\x80\x92\xaf\x3e\x38\xa1\x5e\x55\x4d\xd2\xb0\x8f\x3f\x5e\x54\xb3\xac\x74\x3a\xf2\xec\xaf\x8e\x51\xde\x20\xfd\xc6\xa1\x86\xdb\xb5\x0e\x61\xe1\x10\x16\x27\xce\xa6\x34\xe0\x4c\x40\x49\x88\x0f\xe3\x71\x7c\x52\x7e\x5c\x1c\xb3\x58\x62\x91\x73\xc9\x57\x3f\x39\xdf\x37\x5c\x7c\x83\xde\x78\x4f\xa3\xc6\x7b\xc5\x6b\xf3\x76\x29\xda\xb5\x8b\xb4\xe8\x00\xcc\x9d\xb2\x20\x9a\xe6\x33\x3a\xbd\x01\x9c\x7c\x4b\xd2\xa5\xaf\xd5\xa7\xa6\xeb\xc7\x46\xf4\x4f\x8e\x9f\xdf\xa6\xce\x0c\xc1\x7c\xc5\xda\x53\x73\x8f\x6c\x03\x8b\xda\xe1\xde\x55\x8b\xab\xd5\x07\x86\xf1\x60\xc7\xa1\x58\x6b\x89\xef\xd7\x5e\x3e\x60\xe8\x35\x56\xb9\x7d\xca\x96\x05\x4f\x7e\x1d\xe1\x78\x83\xd7\xcd\x99\x31\xa1\x48\x9d\xac\xed\xd5\x64\x54\xc7\xc8\x59\xe8\xbf\x29\x38\xd2\x75\x61\x36\x76\x87\x2d\x4f\x49\xcd\x91\x6e\x92\x6e\x4a\x8a\x8e\x88\x94\x12\x8c\xde\x19\xfe\xfe\xde\x3e\x59\x86\xce\x1d\x2d\x1d\x02\xba\x87\x77\x8b\x4a\x88\x8c\x36\xf7\xec\x11\x01\x59\x9d\x3b\x76\xe8\xde\x61\x78\xbe\x45\xe7\x23\x19\x82\xa3\xc2\xba\x77\x37\x84\x85\x05\x0c\xcb\x0f\x33\x79\x87\x1b\x3a\xe6\xe5\x1b\x82\x59\xdb\xe1\xf9\x2c\xc8\xe3\x25\x5b\xf7\xf1\x0f\xda\xf9\x0f\xd4\x52\x73\x9a\xa8\xc0\x75\x02\x06\x6d\x6e\x16\xeb\x07\xe2\xe8\x13\x1a\x94\xe2\x03\x9c\x9b\xdc\x89\x5d\xf2\x85\x46\xf4\x92\x33\xbe\x14\x67\xb3\xc6\x4a\xdd\x21\x4b\x09\x0c\x09\xf0\xc3\xd9\x41\xa2\x3e\x2b\x53\xba\xa5\x78\x86\xa2\xeb\xbf\x6c\xe8\xf3\xeb\x5f\x28\x5f\x70\x05\x0c\x15\xa3\x26\x04\xa8\xbf\xc6\x5c\xf8\xc0\xb6\x7e\xfd\xf3\x93\xc7\xb5\xea\xeb\xd5\x26\x31\xca\xea\xd7\x6e\xf4\xc9\xc9\x77\x0c\x9e\x19\xa2\xce\x8f\xaf\xee\x37\x14\xf6\xe9\x06\x75\x0b\x32\x8e\xec\x1d\x1f\x3e\x7b\x92\xaf\x5a\x02\x8f\x05\x3f\x56\xb9\xe5\x4d\x03\xe8\x7b\xf7\x6f\x7d\xcf\x83\x1c\x96\xa8\xa5\xd6\x65\x53\xe3\xe7\xab\x6b\x93\xc3\xa3\x62\xf5\x6b\x4c\x3a\x0e\xea\xdb\xa6\x05\x13\x46\xf7\x4e\x04\x8b\x65\x24\xdc\x17\x16\xf2\x1a\x4c\x12\x73\x45\xf5\x30\xea\x76\x22\xea\x36\x02\xfb\xd8\x21\xb6\x36\xfe\x41\x41\x3e\x3a\xa3\x2e\x4c\x92\xcd\x16\x4b\xb4\x24\xcb\x56\x33\xb4\x36\x7a\x1b\xf3\xf2\xd1\xa5\x7c\xbd\xfd\xe5\x70\xd6\x2a\x2f\x9f\x39\x37\x5a\x10\xe7\x09\x78\x6c\x84\x47\x3f\xae\x0d\x91\x85\x7a\x12\x21\x16\xb4\x3d\xc6\x69\xd3\x63\x48\x07\x97\x36\x74\x52\x56\x2c\x54\xdc\xd2\x5b\xfd\xdf\x13\x70\x9f\xa9\xf4\x81\xf8\x0d\x77\xbe\xdc\xe1\x21\xd0\x6f\x74\x74\x0e\x48\x6d\x63\x1d\x64\x1d\xa6\x94\xda\x4c\x37\xa9\xed\xf9\xd4\x80\xbe\xa3\xb9\xdf\xff\x61\x70\x7a\xdf\xf5\xed\x93\xa3\x53\x92\x7d\xb7\xb4\xe2\xdf\x3c\x29\xfa\xe4\x38\xb5\x4c\xf9\x0e\x7d\x5c\xbc\xbf\x99\x20\x2b\x7e\xfe\xfe\x3e\xe0\xcd\x7c\x7d\x41\xef\xa5\x28\x26\xb3\x3f\x78\x49\x93\xf3\xbd\xbc\x00\x87\x77\xc5\x02\x3e\x93\xf3\xc1\xd9\x7d\xd0\x5e\x43\xae\x83\x92\x3d\xa3\x67\x1a\x56\xd0\xbd\x41\x3b\x23\x33\x5d\x8a\x95\xe7\x6e\x9b\xeb\xf8\xf7\x5c\xf5\x73\x30\x43\xe2\x4c\x5e\x35\x13\x22\x4e\x3d\xbc\xf8\x1a\x9f\xe0\xd8\xa8\x2c\x75\xec\xe5\x1d\xaf\x57\x3b\x6a\xc4\xf9\x0c\x6a\x99\xfc\x12\xea\x31\x92\xf5\xb1\xc5\x9b\xfd\x4c\xbe\x96\x48\x16\x1e\x11\xc1\x99\xc5\x4f\x69\x1d\x15\x09\x11\x41\x5c\x67\xb2\x58\x7c\xf3\xf2\x2d\x41\xba\x90\xa1\xf9\x3a\x93\xdb\xe7\xc4\xa9\xc7\x39\x9e\x2e\xa6\x0d\xae\x92\x76\xde\x02\xed\x1c\x27\x38\x09\x88\x75\x1f\xb4\x13\x0d\x3c\x3f\x2f\x51\x1a\xf4\x5a\xcd\xea\x47\xf4\x5e\x93\xef\xad\xf9\x29\xef\x95\xb9\x61\xab\x4b\xfe\x13\x32\x57\xfd\x1a\xa2\x94\xdd\xea\xf4\x2d\xd3\x0b\xef\x5b\x1e\x90\x93\xa9\x06\x39\x9e\x83\xd5\x7c\xc4\x2d\x6d\x97\x6e\xa8\x75\x6c\x50\x76\x6b\x7a\xa3\xfd\x90\xfd\xd9\x60\xb4\x38\x46\x3e\x3e\xc0\xbd\xbd\xb0\xff\x55\xbc\xc1\x57\x36\x19\x8c\x46\xb3\xb7\x17\x97\xc0\x20\xf4\xe6\x0f\x1e\x9a\x33\x7d\xa0\xed\x8a\xda\xcc\x96\x4c\xa4\x3b\xd0\x93\xee\x20\xda\x00\x42\x77\x39\x13\xd4\xc7\xf6\x97\xa8\x5f\x08\xdd\xfd\x8b\xff\x02\xb3\x1d\x41\xd0\x73\x2f\x6a\x6f\xc9\x02\xc7\x75\x54\xdf\x52\xbe\xd8\xb1\xda\x71\x14\x15\xa8\x9d\x71\x81\x3a\xdc\x85\x1c\xfa\xa3\x27\xb6\x95\xe9\xcc\x5e\xd0\xf9\x1a\x90\x1f\x1d\xe3\xb2\x09\xed\x6b\x66\x18\x13\xea\xfc\xfc\xbd\xc1\x18\x24\xeb\x74\x90\x97\xaf\x0b\x72\x33\x96\xd3\x22\x63\x22\x3c\x40\xfd\x49\x2e\xee\xf8\x85\xf7\x56\xa3\xce\xf2\xdf\xba\x6b\x94\x7a\x16\xac\x10\xfa\x34\x7c\x0a\x3d\xf9\x03\x6a\x3b\xa1\x2c\xb8\x38\x50\x1d\xa7\xec\xae\x7b\x11\xde\xd1\xbe\xa5\xfb\x04\xfd\x2c\x96\xf6\xc0\xe8\x66\x8b\x62\x06\x83\x0c\x92\x4e\xe7\xeb\x85\x8a\xd1\xe3\xdc\x60\x52\xbe\x22\x71\x2f\xf0\x9a\x94\xef\x2d\xb4\xf4\x81\xeb\xdd\x60\x8f\x4f\xab\x9c\x47\x6b\x60\xb0\x4d\x3b\x32\x23\x0f\xb1\x52\xcf\xba\x7f\xb7\x91\xd6\x3a\xca\x93\xa5\xab\x6d\xea\x26\x4a\xa6\x5b\xae\x7d\x2a\x7d\xf8\xcd\x9e\xba\x74\xc7\x52\x51\xe7\x31\xd4\x05\xc8\x5d\xb4\x3a\xb9\xb7\x37\x9a\xc2\xcb\xcb\xd7\x28\x3e\xf9\xd0\xe9\x75\x43\xf3\xf5\xfe\xb2\x51\x32\x0e\xcd\x07\x29\xe8\x37\xeb\x04\xf4\x67\x77\xad\xa6\x9f\xf2\x1c\xd5\x09\xfc\x6e\xd5\xda\x46\x6a\x9b\xe8\x98\xcb\xb3\xd4\x32\x58\xbd\x93\x3f\xf3\xf1\x87\x8e\x09\xae\xbd\x62\xcf\xeb\x52\x68\x5f\xbc\x70\xd6\xc5\x16\x09\x01\x01\x7e\xa1\x3a\x3f\x5d\x64\x04\xf8\x30\x5f\xc9\x18\x34\x29\xdf\x28\x4b\xa6\x49\xf9\x52\x40\xc3\x50\xa1\x8d\x70\x8d\x0e\x85\x8a\x4e\xd4\xc5\x5a\x99\x99\xb6\xbb\x0b\xc9\x4a\x87\xf8\xb4\xac\x00\xb1\xc6\xc0\xb1\xfd\xcb\xa1\xde\x2f\x3c\xa9\x9e\x57\xdf\xda\x0f\x73\x2f\x9f\xdf\xf0\x8e\x4d\xfd\xc1\xf1\xe1\xde\xdb\xef\x9a\xf7\xf6\x86\xd3\xb7\xbc\xda\x7d\x38\xf4\x00\xd3\x39\x78\xe8\xb3\x69\xa3\xae\x2d\x3e\x90\x2f\x79\xcf\x79\x50\xdd\xb7\xf1\x8d\xad\x9a\x8f\x54\xe0\x58\x3c\x4b\x1e\xc2\x02\xc5\xbe\x0c\x12\xd7\x61\xac\xe2\x8b\x41\xd7\xd0\x7c\x6f\x93\x0e\xb8\xbf\xd8\x45\x0b\x99\xc9\x69\xd8\x3f\x4b\xa8\x1d\x1b\x33\x6d\x3d\x47\x13\x47\xda\xce\x42\xcf\x2b\xd4\x97\x5f\x86\xe8\xbe\x8a\x39\xcc\x76\xf0\xe6\xd3\x4b\xe7\xde\x19\x94\x10\xd9\xa6\x4b\x94\xdc\xc5\xf1\x44\xec\x77\x5d\xef\x86\xad\x8e\x91\xff\xb5\x98\xdb\x76\xc6\x3a\x37\x31\x66\xd0\xa1\x4e\x6c\x2c\xc3\x16\x61\x31\x9b\xc3\xf4\x6d\xe5\xac\x1e\x59\x3d\x3b\xdd\x34\x39\xbf\x93\xdc\x36\x2c\x4c\x6f\x8a\x31\x4b\x60\xb2\x38\xb7\x31\xc3\x5a\x9d\x0c\x84\xb8\x18\xe8\x84\x73\x72\x3f\x45\x4f\xfd\x4a\x94\x1c\xd8\xb1\xbb\x82\x46\x09\xc0\xd9\x61\x70\x88\x98\x09\x66\x05\x74\x97\xdc\xfb\x94\xf9\x71\xbd\xf2\x96\xba\x01\xa3\x0b\x00\xdf\x80\xd0\xd0\x56\x46\x75\xa3\xfa\x58\x3e\xb4\x8a\x03\x09\xf0\x3f\x73\xa8\x35\xc6\xea\x0b\x43\xa0\xab\x95\x8b\xff\x82\x43\x02\x53\x43\x0e\xb6\x1e\x38\xa1\xb2\x67\xd7\x9b\x6f\x5a\x1e\xd4\x36\x2c\x30\x2e\xda\x6a\x92\xda\x7b\xf7\x1d\x37\x29\x4e\x8a\xee\x64\xb3\x75\x0b\xa9\xfb\x54\x59\x5a\xf7\xa9\x75\xd0\xa0\x7e\x9d\x63\xa4\x76\xb6\xa1\x23\x86\x44\x49\xbe\x75\x4b\xdb\x4d\x68\x93\x9a\xdc\xb9\x6b\xfa\x82\x6c\x9e\x30\x64\x66\x6e\x54\x7c\xbb\xf7\x2c\x66\x63\x78\x72\xac\xd0\x75\x11\x63\xfa\x12\xd4\x75\x27\x96\x69\x8b\x34\xf9\xfb\x07\xe9\x62\xe4\xe4\x8c\xe4\xcc\xa4\x8e\x43\xf3\x93\x4c\x31\x41\xfa\x20\xbf\x70\x7f\x7f\x7f\xf0\x0b\xa2\xe3\x53\x9a\x15\x3c\x85\x77\xea\xe8\x27\x69\x82\x07\x06\x47\x02\x49\xeb\x14\x3d\xc8\x29\x3a\x34\x98\x45\x7e\x5d\xfd\x2c\x49\x08\x1e\x10\x11\xed\xa7\xee\x53\x3f\xeb\x0d\xdc\x17\x7c\xfd\xbc\x23\x7c\x21\x01\x92\xdb\xe1\x15\xf0\xf3\xf3\x09\xf3\x5e\xd7\x69\xdd\xec\xf9\xf3\xc8\x68\x39\xa1\xfc\x81\xa8\xbc\xbe\x1d\xa5\x8e\x7d\x86\xb4\x76\x54\xa0\x05\x97\x45\xf4\x8c\xcc\x8d\x89\x89\xec\x19\xc1\x6f\x71\x2c\x0b\xeb\x19\x19\x13\x17\x87\x7f\x85\xc1\xfd\xb7\xcd\x17\x56\x4d\xec\x42\xbe\x8e\x71\x9d\xfc\x09\xca\x17\x80\xbd\xf6\x20\x5b\x42\x88\x2f\xb0\x40\x53\x84\x39\x42\x2f\xeb\xcd\xbe\x72\x94\x25\x20\xa0\xb5\xc5\x5f\xe1\x81\x26\x33\x98\x8c\xc8\x54\x98\xd1\x44\xfe\x25\x46\x0f\x4b\xb6\xb6\xc3\xa1\xe7\xd1\x30\xa8\x80\x74\xe7\xac\x5a\x12\xeb\x4c\xae\x69\xb4\x4e\x1f\x00\xd1\x0d\xdb\x63\x0b\xd7\x1b\xf7\xaf\xa8\xdb\x7d\xd6\xad\x99\x32\xa7\x66\x49\x07\xd8\x02\x29\x75\x07\xba\xb5\x6f\x15\xd8\x07\x7e\x4c\x7e\xbc\xdd\xb8\x9c\x95\x6b\x2a\x47\xe6\x3f\x90\xab\xce\x95\xa6\xa9\x6f\xc4\x77\x8f\x09\x8f\x2c\x8d\x14\xfd\x36\xf2\x3b\xca\xb9\xaf\x8f\x45\xaf\xe8\x24\xd9\xcb\xa0\x83\xc9\xf9\x3a\x4c\x49\x92\x85\x3c\x9f\xbe\xc9\xd7\xf6\x7e\xd7\x86\x31\x39\xc1\xf1\xc8\x1c\xf5\x88\x36\x7c\x95\xba\xc6\x2d\xad\xbf\x65\x4c\xca\xc1\x3e\x86\xf0\x38\xf6\xb5\x88\x07\x72\x5e\x3e\x80\x4e\xef\xaf\x0b\x6a\x82\x27\x69\xe7\x3f\x71\xd3\x48\xb8\x35\x5e\x5d\x38\x4e\xfd\x7a\xbf\xdc\x45\x1d\xf9\x5f\xb5\xa3\xdc\x45\xeb\x3b\xa2\xeb\xcf\x2b\x93\x51\x9f\x06\x44\xee\x66\x8b\x96\x7c\x59\x64\x98\xc5\x12\x19\xec\x2b\xc7\xc7\x05\xe3\x98\x17\x6c\x12\x3b\x0c\xe7\xe5\x9b\x82\x8d\xba\xbc\x7c\xa3\xc9\x63\xb7\xa6\x9c\xa4\x46\x53\xe1\xf8\x4c\x8b\x73\x63\xa6\x00\x54\xa0\x89\x45\x5b\xa9\x2b\xd1\xd3\x02\x56\x48\x40\x77\x99\x9f\x7f\xea\xdd\xae\x59\x59\xdd\xcc\x4f\xae\xfd\xaf\x5a\xa1\xde\xe1\xd8\x7d\x1f\xe8\x9f\x68\x3b\xfd\x81\xd2\x89\x95\x21\xed\xbb\x4f\x98\xfd\xbc\x02\xd6\xb3\xd3\x66\xf6\x1b\x0b\x13\xbf\x78\x5d\x7d\x4a\x5d\x01\x17\x9e\x83\x98\xa7\x0e\xea\x4e\x3e\xf9\xd0\x06\x85\x67\xcf\x9e\xd2\x2f\x3d\x0c\x79\x56\xd8\x60\xfe\xb6\xf4\x05\x3d\xff\x8b\xb1\xf9\x31\x9d\xcc\x0d\xb2\x97\x58\x82\xe5\x32\x77\x2d\x9b\x68\x9d\x2a\x3d\xb6\xcc\x8a\xd7\x03\xfe\x16\xa6\xf2\xe4\x54\xc7\xbc\x14\xa4\xbc\xfd\x95\xb7\xae\x38\x4a\x90\x88\xef\x90\x5e\x90\xde\x84\x8e\xce\xb3\x49\xfd\x5e\xc5\x89\x8c\x78\x08\xb8\x07\xa7\x2b\xda\x87\x62\x52\x6c\x46\x3a\x74\x5c\xbe\xfc\xd8\xd3\x4f\x4b\x6f\x72\xb3\xfa\xec\xa3\x78\xcf\x71\xe9\x2a\x1c\x56\xf6\x38\xef\x11\xc7\x6c\xcb\xae\x7b\x02\xb0\xbc\x94\x08\x21\xb7\x3f\xfd\x74\x42\x21\xcc\x2f\x54\x3a\x3c\xaa\xb6\x9b\x02\x73\x8a\x44\x5d\x8f\xcb\xe3\xe1\x25\x67\x5d\x3e\xaf\xa0\xcf\x89\xb3\xad\x77\xa7\x69\x77\x85\x04\x45\x67\x5c\x7b\xfa\xe9\xd7\x1c\x17\xf0\x9e\xef\x97\x2d\xc3\x31\x65\x16\x96\x5f\xaa\x6c\x13\xa7\x29\x6d\x56\xc4\x26\x15\xe9\xbb\xb5\x0f\x02\x91\xa7\xa5\x8e\x0b\xb0\xe2\x76\x79\xfc\xb2\xa3\xda\xf3\x43\xb3\xe4\x90\x8e\xeb\x73\x69\x77\x06\x7f\x9c\x22\x2a\xe2\x2e\x6f\x50\x14\x2f\xc9\xcb\x75\x6a\xa7\x73\x79\xd9\xf9\x6c\x94\xbe\x53\x4d\x07\xe9\xb8\xfa\xdd\x7a\xf5\x5b\x18\x1e\x07\x63\x95\x63\xaa\x15\xbe\x8a\x80\x81\xea\xab\x37\x60\x62\x88\x26\x21\xe7\x46\x11\x78\xe8\xb9\xbe\x19\x4c\x83\x88\x1e\xe9\xb3\x15\xc4\x7c\x26\x4e\x7d\x11\x42\xd6\x43\xb0\xd2\x5f\x7d\x15\x06\x46\x88\x2d\xc5\x84\xcf\x5d\x93\x9e\xe2\x17\xf4\xbb\x9d\xcf\x6f\xc5\xe9\xa2\x92\x97\x64\x40\x3e\xb1\x49\x78\x9c\x2e\x4a\x1e\x8c\x43\xa1\x98\x0e\xf2\x11\x5f\x4f\x80\x04\xd5\x3b\x03\xac\x19\xca\x50\x7e\xcb\xf5\xcf\xc1\x4f\xbd\xe4\xc4\xfa\xd6\x89\x15\x67\x33\x31\x1c\xe6\x41\x42\xf6\x0c\x62\xaf\x2e\x19\x3c\xe0\x9c\xfd\x1b\xf6\x63\xe9\x01\xa2\x4d\x58\xd5\xcf\x1f\xfd\x7a\x66\x86\xfa\x55\x06\x42\xdc\x02\xcf\xa9\x97\xc0\x4f\x6b\x13\xeb\xe1\x29\x7e\x8f\xf2\x17\x30\x61\xa7\x1b\x13\x1a\x61\x42\x7d\x02\xda\x71\x0b\xda\xd1\xc0\x02\x5f\x57\x14\x83\xa4\xd7\x03\x6d\xd0\x26\x7c\x34\x55\x9c\xe6\x1a\xe4\x7c\x55\xe3\x73\x7e\xcf\xa9\xdb\xd7\xdf\xae\x6c\x5b\xb6\x73\xa7\x66\x57\x55\x2c\x51\x7d\x8b\xb1\xbf\xb8\x57\x96\xb9\x38\x9a\xcf\x40\x87\xd0\xee\xa1\x7b\xc1\xf9\x4a\x47\x50\xb4\x9a\x8f\x77\x9e\x72\xcc\x82\x49\x47\x77\xee\x5c\x46\xf5\x76\x55\x67\xc0\x95\xfa\xfb\xb1\x6d\xc4\xd9\x2c\x8c\x0b\xc3\xc9\xe2\x8d\x29\x0e\x9c\xe9\x00\x9d\xaf\x20\x7d\x4f\x41\x9a\x73\xe4\x15\xfa\x4e\x14\x3b\x73\xc2\x95\x93\x85\xf7\x9f\x84\x8c\x1d\xea\x8c\x55\xab\x20\x11\x75\xf2\x6f\xf0\xe3\x03\xb1\xd3\x10\x3a\x09\xb5\x79\xcb\x4c\xc7\x65\x83\x97\x82\x2d\x8e\x9e\x64\x38\x3b\x1c\xb1\x1f\x97\x30\xd7\x4f\x99\x60\xcd\x54\x6b\x05\x95\xac\xe2\x94\x5d\xc7\x0f\x74\xca\x2e\x67\x1d\x21\x56\xea\x22\xb7\x25\x9c\x30\x9b\xb7\x8e\xa1\xed\x51\x1a\xae\xc8\xd4\x0e\x5c\x76\x0f\x10\xc1\x0f\xfe\x3e\xda\x9e\x57\xb5\x77\xc4\x26\xf1\xaa\x24\x69\xc0\xf1\xe3\x8e\x23\xc7\xb4\x7d\xff\xd8\x74\xd8\xc7\xdb\xd0\x1e\xc9\xe1\x36\x6f\xf4\x53\x59\xf8\xbb\x24\xb9\x3f\xd0\xb1\xb8\x23\x29\x18\xf6\xf5\x43\x38\x0e\xed\x93\x5e\x12\xf7\xbd\x2c\xe5\x70\xad\xad\x47\xda\xbc\xb1\xff\x04\xf4\x39\x71\x2e\x87\x76\xb8\xb4\xd9\xf9\x88\xcd\x79\xe7\x3d\x5f\x4d\x80\x78\xbc\xe1\x6e\x6d\x8f\xca\x01\x18\xc7\xe8\x94\xdd\xa6\x04\xd6\x9f\xce\x57\x1e\xc4\x9f\xc3\x0b\x31\xb6\xe0\x54\x2b\xcc\xb2\x2e\xb1\x72\xc6\x5f\x12\x0f\x5d\xc2\x5f\x0a\x87\x25\xe1\x50\xe0\x3c\x5b\xb9\xa0\xa0\x99\x7b\xf3\xe8\xde\x14\x5b\xf4\xca\x08\x48\x8d\xf8\x2f\x4e\x3a\x22\x60\x68\xc4\xac\x88\x25\x11\x5f\x45\xc8\x84\x03\x21\x2f\x85\xc0\x92\x10\x82\x11\xff\xcf\x2e\x98\x8d\x38\x5b\x21\x81\xf7\x93\x8f\x58\x12\x14\x83\xd8\x0b\x54\xbe\xc2\x7e\x51\x5f\x43\x3b\xdf\xab\x3c\xc5\xfb\xe9\x4e\x31\x13\x0b\xd8\xe2\xe5\x8f\x82\xfa\x4a\x5b\x21\x07\xc7\x78\xb4\x6e\xc3\x89\x36\x38\xa3\xd3\x36\xb3\xe6\xfd\xc2\x3f\xdb\x78\xe7\x6a\xfd\x6e\xa9\x5b\x46\xf7\x02\x5f\xdd\xa9\x87\x9e\xaa\x9d\x17\xdf\x26\x36\x3b\x67\x6c\x2f\x92\x75\x2b\x7b\x50\xde\x2c\x1f\x31\x69\xf5\x24\x2a\x06\x3e\x8d\xea\xbb\xc0\x0f\xc2\xc2\xfa\xfa\xfa\x6d\xf5\x9f\x2a\x21\xc8\x87\x4e\xb1\xd0\x79\x9e\xe8\xaa\xca\xe3\xf4\xb7\xa6\xab\xdb\x70\xdc\xab\xa3\xbf\x25\xfa\xbb\x0f\xfe\xfd\x0b\xfd\x2d\x53\xf9\x6f\xf1\xef\x44\xfa\xdb\x9b\xae\x0f\xa9\x7f\x5f\xae\xd5\x2d\xc5\xbf\x7d\xe8\xef\x7e\x88\x37\x9c\xae\xfb\xd2\xdf\xb7\x62\xf9\x64\xfa\xbb\x15\xdd\xff\x19\x5e\x1f\x4a\x7f\x87\x91\x3f\x8c\x83\x0f\xe5\x85\xf2\x3c\xf4\xaa\x56\xaf\xe0\xd4\x99\x6f\x85\x1e\x9b\xf3\x41\xde\x0a\x59\x2c\x87\x4e\xdc\xd2\xde\x05\x11\x3f\xf2\xc2\xeb\xc7\xe0\x0e\x1c\x5c\x57\xc0\x87\x68\xad\xe7\xd5\x91\x88\xbf\xad\xfe\xaa\xee\x45\x5d\x2e\xea\x35\x94\xe4\xbc\xa8\xac\xa6\x7a\x6f\xc8\x67\xf7\x37\x93\x9f\xa8\x95\x17\xf6\x90\x43\xeb\x37\x35\x73\x9d\xf2\xe9\xfe\x7b\x35\x7d\xd5\x87\x92\xbe\x12\x84\xbe\x48\xaf\x9b\xb5\x7c\x75\x63\xa3\xfc\x1f\x5d\xf9\x4e\xfd\x52\xbe\x19\xeb\xe1\x5e\x8e\xd7\x99\xf1\x55\xf0\x8f\x82\x28\x66\x2e\xc8\xc0\x32\xe7\x51\x47\xeb\xa8\x0c\x68\xbc\xc0\x7e\xba\xf7\x08\xc6\x0c\xd9\x94\xcf\x9d\xf9\x8c\x0d\xf2\xb0\x51\x82\xb0\x11\xe5\x3f\xda\xc8\x56\x09\xc2\x56\x22\x9f\x3f\x4f\x38\xd8\xf4\x9c\xbe\x87\x4c\x98\x74\xf2\x15\x23\xd9\xba\xfe\x47\xc4\xcf\x90\xaf\x61\xbe\x4e\xcb\x8f\xd4\x7c\xe0\x6e\x8c\x2d\x06\xc9\x3f\x60\xbe\x97\x13\x47\xe3\xe7\x18\xef\xd3\xc4\x87\x8d\xec\x79\x61\x63\x75\xb1\x9c\x44\xf9\x46\x27\x3f\xab\x1b\xf9\x4a\x82\xf0\x15\xca\xff\xb4\xfe\x4d\x0f\x9f\x49\x10\x3e\x43\xf9\x9f\x31\x93\xc6\xa7\x32\x56\x3e\x8e\xf9\x7e\x5a\xbe\x94\x48\xf9\x27\x90\x4f\x0b\xe1\x98\x9c\xf5\x7e\xa8\xf9\x16\xf2\x39\x8e\xf2\xcd\x4e\x3e\x3f\xa5\xfc\x79\xc8\x8f\xa6\x87\x00\x67\xfe\x62\xb6\x12\xf3\xd3\x11\x9f\x53\x7e\xa0\x33\x7f\x0e\x5b\x87\xf8\x18\x4c\x28\x5e\x94\x1f\xec\xe4\x67\xb4\xfa\x33\xe6\xd7\xa9\x8b\x15\x13\xe5\x87\x38\xcb\x3f\xc7\xb2\x3d\x7c\x3a\x41\xf8\x74\x83\xbc\x9a\xef\x50\x7e\xa8\xd3\xa7\x42\x84\x4f\xb9\x7d\x3e\x41\xf8\x3c\xc9\xe5\xe5\x6a\x2b\xd8\xf6\x73\x9d\x76\x41\x1f\x03\xad\x8d\x90\x3f\xe8\x92\xdc\xfe\xf0\x33\x4f\x6d\xd0\x27\xe5\x6b\xfa\xfc\x19\x4e\x11\x0e\xc9\x45\xf9\x81\xce\xf2\x33\xa9\x6d\x6d\xc1\xfc\xa5\xba\x95\x38\x79\xb4\xbe\xea\xaf\xd3\xc9\x96\x6d\xd0\x85\x19\x21\x7b\x33\x70\x6c\x60\xd9\xd8\x75\xd2\x4c\xc2\xd5\xe1\x4a\xe9\x18\x37\xe7\x80\x38\x98\x59\x6f\x09\x89\x86\xc9\xcf\xd5\x82\xdf\xe8\x01\xd0\x76\xf0\xe4\xb8\x9e\x10\xd8\xaf\xdd\xfa\x2d\x6b\xe7\xaa\x7b\xe5\x68\x0c\xaa\x07\x38\xf6\x74\x5d\x77\xcb\xd1\x1f\x57\x1e\xb6\xab\x9f\x1f\xc0\x7e\x2c\x5a\x5e\xc7\x57\xe9\xda\x8b\x7d\xad\x36\xd3\xcb\x58\x7b\xb0\xfb\x92\x62\x59\xb4\x5e\x27\x27\x6e\x85\xde\x3c\xd5\x7a\x5e\x3d\x26\xaf\x83\xbb\x9e\xe6\xe5\x58\x7e\x08\x96\xef\xe7\x2c\xaf\x63\xe2\xb1\xba\x28\x6f\x0d\x88\x4d\x81\xc4\xfb\x78\xf2\x0b\x5b\x27\x5c\x3b\xaf\x6b\xaf\xd6\xd4\x96\x4b\x34\x1e\xb6\xc3\xf2\x8b\x95\xb3\xcc\x57\x9c\x71\x8f\x5d\x8b\xe4\x6f\x04\xa3\x78\x40\x5b\x90\xa6\x09\xa0\xcd\x69\x62\xb5\x53\x43\x79\x7e\xc9\x7b\x85\x63\x2b\x63\xdf\xcc\xfe\x6e\xe3\xc8\x1d\xf3\xe5\xaf\x5b\xa7\xf4\x1b\xf8\xf8\x73\x31\xad\x09\x2b\x53\xde\xc0\x57\x28\xdf\xb9\xb1\xfc\xf5\xa0\x97\xc4\xeb\x1a\x7b\x0a\x08\x4b\xd2\xb6\xf0\x4e\xa7\xce\x37\x71\x63\xc9\xbb\x85\x63\x67\xc5\xbe\xd9\xe5\xfc\x86\x91\xdb\x16\x2b\x1b\x05\xd4\xda\x67\xa3\xad\xda\x7b\x4a\xf4\x1e\x9a\xb2\x9d\xde\xcf\x12\xef\x80\x44\x62\x3c\x2e\xd6\x4e\x3b\xb3\x5c\xb4\xef\x20\x36\x9c\xe5\xb3\xc9\xac\x8c\x5d\xb3\xfd\x4b\x9f\x99\x19\xa5\xcb\xc8\x88\xf2\x86\xe8\xe8\xa8\x92\x9c\xd4\xc1\xd9\x85\x63\x26\x4e\x4c\x4c\x1a\x91\x1c\x37\xce\x2f\x44\x6a\xdd\x3a\xc4\x32\x6e\x44\x62\xe1\xe0\x1c\xc3\x10\x23\x8b\x8a\x9a\xd6\xbb\xe3\xb0\x61\x43\xc2\x07\x0c\x18\x12\xd6\xbf\x7f\x9f\xb4\x21\x43\xca\xbd\xfb\x0c\x8b\xc9\x9b\x3a\xb5\x6b\xd7\xc4\x20\x93\x69\x62\x62\x41\xf2\x98\xd1\x45\x45\x3d\x7b\xb6\x69\x05\x69\x43\x13\x61\x52\x2b\xc8\x4b\x1c\xd3\x2a\x2d\xad\xd5\x98\xc4\x3c\x25\x7d\x60\x96\x75\xd8\xb0\x01\x99\xad\x87\xf8\xf4\x0d\xd7\x4b\x1d\x3a\x44\x78\xc9\xe9\x2c\xd5\xf5\xa5\xde\x07\x69\xee\xa4\xeb\x85\x5f\xed\x55\x86\x86\x8f\x72\x9d\x29\x3a\xfa\x30\xad\xd1\x89\x5c\xee\x72\x0d\xab\x3f\xe9\xe6\x26\x3f\x9e\x2b\x42\x18\x1f\x65\x44\x2b\xe2\x23\x6d\x8c\xca\xc5\xfb\x54\x74\xa4\x51\x06\xa6\x45\x1e\x46\xc4\x18\x13\x07\x46\xe3\x35\x71\x96\x75\x30\xc4\x8a\xcd\xf9\xe9\x92\xe7\x3b\x24\xb1\x5a\x71\x45\x1c\xfd\x9e\x0e\x9d\x92\x20\x08\x67\xb2\xda\x3f\x60\x8a\x8d\x31\x9b\xd2\xd3\xbc\x58\xf1\x71\xe8\xe5\xd8\xae\xbe\x0d\xbd\x78\x4e\x71\xb1\x7a\x75\xff\xe8\x4e\xfd\x43\xdb\x4c\xaa\xa9\xbb\x4b\xe4\xc9\x8b\xd4\xb7\x8f\x17\x3b\x56\xaa\x3f\xfc\x78\xee\xd7\xfc\x79\xd7\x5f\x3d\x5e\xac\x65\xe2\x4d\xab\x36\x3e\xfc\xf0\xfa\xf5\x0f\x3f\xbc\xd1\xe1\x57\x5c\x2c\x45\x51\x1e\x02\x15\x1f\x97\xb6\x3d\x91\x5f\xf2\x50\xd4\x7f\x2a\x6f\x79\xdc\xb1\xf3\xc3\x0f\x3e\xf8\x50\x5e\x74\xbc\xb8\xb8\xb8\x6e\x11\xf4\x52\x4f\x5c\x4c\xce\x0b\x5b\x0e\xa7\x21\xbc\xf8\x5a\x0e\xd6\xed\xf3\x29\x7f\x6f\xdb\xf8\xcc\x14\xfe\x00\xf2\x81\x39\x7c\xc1\x0b\xef\xbc\xf3\xc2\x4b\xef\xbc\xa3\x6e\x82\x5e\x75\x8b\x8a\xb1\xba\xe3\x52\x68\xd1\x8e\xbd\x33\xbf\x60\xf5\xe0\xab\x5e\x56\x7f\x12\xed\x74\xa8\x9a\x0d\x4b\xea\x37\xa3\x07\x45\xdb\xfc\x74\x0a\x28\x18\xfc\xcb\x8a\x7c\xf7\x78\xec\x4f\x4d\xff\x73\xad\x9d\x6a\x0b\x2c\x01\xb1\x74\x84\x1b\xb6\xd1\x23\x77\xce\xf2\x9f\xd1\xe6\xa7\x56\x7e\xdd\xd5\xec\xe2\x3e\x7b\x17\xf5\xa9\x12\x58\x51\xf2\x3a\x29\x47\x71\x30\x1f\xd6\xda\xe6\x2b\x19\x7d\x8d\x7e\x32\x76\xd6\xfa\xfb\x69\xa7\x58\x44\x3a\xf0\x81\x16\x2e\x69\xdb\x30\xd2\xf6\xed\x62\xaf\x7a\x58\xf3\xef\x37\x32\xb7\xb7\x9f\xde\xf7\xf5\xf1\xb3\xba\x1e\x94\xd7\x2d\xb9\x75\xc0\xd4\x51\xbb\x3b\xae\xa2\xe7\x71\x63\xa5\x2b\x70\x17\xc6\x6c\x06\x8c\x99\xfc\x25\x9c\xb1\x1a\x75\x1a\x83\xf9\x8a\xe4\x5c\x11\x74\xc6\x60\xd9\x9e\x0c\x9e\xb8\xb3\xca\x8c\x0c\x46\xf8\x77\x95\xae\x94\xe4\xef\xbd\xaf\xcf\x6c\x71\x2e\xb8\xfc\x16\xd4\xe8\xfa\x3b\xb1\x74\x60\x04\x6f\x26\xd9\x24\xdd\xdd\xe3\x25\xc2\x12\x1b\x0c\xba\xa3\xda\x80\x74\x9d\x78\xe0\x95\xd5\x1d\x4e\xdc\xaf\x61\x99\x7b\xe9\xfa\x0b\xac\x31\x73\x30\x04\x4c\x56\xae\xe1\x7c\xc4\x44\xfb\x9a\x82\x4e\x51\xf4\x7c\x09\x13\x9b\x69\xbb\x25\x8c\xcf\x4a\x0f\xd1\xf3\x02\xf5\x13\xc3\x0f\x1f\xeb\x95\x6b\xe7\x92\x7e\x6e\x2d\xe6\x46\x41\xca\x35\x29\xc3\x79\x1f\x93\x74\xd2\x0d\xf7\x65\xc5\x47\xeb\x15\x08\xd2\x63\xf8\xe5\x6d\x50\x17\x29\xd7\x5a\xff\x9c\x74\x4e\x8b\x5f\x9f\xc2\x7b\x57\xe8\x93\x90\xff\x08\x8c\x82\x65\x1c\xf0\xbc\x25\xc3\x12\x9d\x98\xe0\x85\xed\xc9\x6e\x88\xc7\xf5\xb1\x89\xb1\xc8\x39\xa4\x4b\x2b\x94\x55\x2f\xca\x3f\x3e\xab\x40\xd6\x19\x5d\x48\xe4\x43\x0f\x45\x42\x20\xe2\x3c\x84\x38\x0b\x5d\x38\x5c\x67\xf4\xf2\xf2\x56\xf4\xf2\x12\x10\x7c\xa4\x79\xe0\xc4\x4a\x28\x83\x58\xd1\xe7\xfd\xce\xec\x56\x1e\xdc\x22\x9f\x7d\x56\xa7\x5c\x83\xc0\xc8\xd5\xab\x23\x45\xdf\xbf\x05\x71\xa6\xeb\x0e\x5a\xf4\x6c\x1a\x4b\x85\x81\xc4\x63\xa5\xf2\xab\xf4\x8a\x3e\x8a\x85\x88\xdd\x8f\xc5\x81\x23\x81\x41\x41\xa1\x41\x3e\x3e\xca\x3d\xf9\x3e\x66\x66\xbe\x27\xdf\x20\xb6\x16\xd4\xb6\xea\x74\x2d\x63\x3a\x87\x81\x98\x14\xee\xee\x46\xa3\xb8\xb3\x17\xe4\x6b\xda\x0f\x1b\x98\x1b\xd5\x2e\x2b\xd4\x9e\xb8\x62\x6a\xf2\x88\x01\x3d\x23\x93\x3a\xb7\xba\x23\x71\x85\xf2\x6b\x42\x6a\x42\x7a\xbf\xc7\xef\xc0\x7f\x3a\xf7\x7a\xfc\x0e\x9c\x27\x74\x41\x7e\xb6\xeb\xcd\xb4\x6f\x00\xce\x11\x25\xec\xdb\x7d\x0c\x06\x5f\x2f\x9d\x53\xc7\xe9\x69\xce\xf9\x17\x5a\x57\x8c\x35\xd8\x2d\xe0\x74\x41\xe9\x62\x3c\x85\x6e\xaf\xae\x03\xdf\xef\xe9\x5f\x54\xf9\x2f\x49\xe7\xc5\x2f\xca\xf3\x98\xf2\xa3\x54\xa4\x6f\x8d\xfd\x6b\x47\x5b\x2b\x59\x92\xfc\x8c\xde\xde\xfe\xde\xfe\x52\x6b\x89\x1b\xd0\x6b\x6c\x4c\x7f\x8f\xe6\xde\xee\xdd\x29\x3d\x25\x4a\xc8\x48\x77\x1d\x04\x03\x70\xe8\xdf\xff\x79\x72\x7c\xde\x90\x69\xe1\x1b\xdb\xed\x50\x7e\xdc\x70\xf7\xc0\xfc\x41\x63\x1f\x7e\x10\xc7\xd6\x93\xf2\x5a\x9c\xdf\x7f\x69\xd2\xb3\x5e\xea\x76\xa6\xc5\x47\x7f\x34\xef\x1d\xcc\xdb\x47\x79\x73\xff\x6c\x9e\xda\x45\xd9\x5f\x7f\x51\x9f\x64\xd1\xf1\x8f\x69\xce\xd8\x59\x7e\xa6\xfe\xa8\x72\x9d\x99\x71\x5c\xe4\x7a\x3f\xe7\xb8\xd8\x29\x36\x86\xb6\xcd\x0e\x0e\x0a\xf4\x87\xd8\xac\xb4\xcc\xbd\x8b\x7b\x64\x1b\xbb\xe7\x2d\xb3\xff\xcf\xb0\x24\x68\xe0\x60\x65\x62\xaa\x71\x86\xcf\x80\x9e\x0b\x5b\xa5\x55\x24\xdc\x88\x8b\x7f\xef\x91\xd7\x72\xb3\xf2\x9e\x49\xcf\x1f\x57\xef\x74\xd6\x7d\x43\x9e\xd8\xed\x42\x7e\x51\x6a\xa7\xbc\x87\xba\x0e\xb0\x19\x8c\xfe\x4a\x6b\x85\x8b\x28\x30\x35\x6d\x37\xcd\x47\x50\x9b\x59\xa4\x4e\xd2\xe6\xff\x16\x3f\xc4\xef\x1f\x98\x7b\x6f\xdb\x07\xe2\x9f\x92\x5f\xfc\x57\x55\x4c\xcf\xbe\x77\xde\xb7\x8c\xb0\x8f\xa1\xac\xef\x2a\xbf\x22\xb6\x5d\xbd\x57\xc3\x56\xef\x56\xef\xa9\xdf\x5b\x3f\x09\x47\x7b\xaf\x4d\x4c\xbc\xf2\x2d\x9a\x5a\xb4\x5e\xbd\xbb\x2d\x84\xb6\x55\xef\xd9\xbb\xf7\x4f\xe8\xf2\x0f\xda\xe6\x06\x3d\xfc\x25\xbd\xfc\xf3\x79\xf5\x93\xd5\x7b\xd8\x86\xfa\x49\x16\xbd\xc1\xc2\xf6\xff\xbf\x93\xf7\xff\x57\xbd\xff\x5f\xc8\xf1\xd7\xf3\xb4\xb5\x58\xee\x47\x6b\x22\x01\xaf\xd3\xf6\xe6\xfe\xe2\xa9\x74\x8e\xf3\x25\x68\xf1\xa6\x45\xec\x3e\x08\xdd\x2f\x77\xb9\xfe\x01\x96\x97\xd4\xed\xca\x36\xb0\x61\x5f\xad\x7d\x2b\x1f\x6a\xf3\xf1\x36\x60\xdc\xd8\x4f\x2c\x2b\x89\xdd\x4a\x45\xac\xb3\x3b\x29\x4d\x3b\xba\x5e\x11\xe7\x07\x47\xeb\xa3\xff\xb7\x2e\x72\x9d\x3a\x17\xc9\x7a\x5e\x14\xe6\x78\x4c\xd9\xb6\x7a\xf5\xea\x23\xcb\x19\xe1\x7d\x8a\x78\xa9\x88\xa7\xc5\x8c\x21\x36\xa3\x97\x8f\x8f\x94\x87\x8c\x79\xeb\xc5\x62\x4a\x81\x73\x63\x43\xbd\x12\x9b\x03\x2e\x4c\x48\x95\xd4\xba\x55\x7c\xe3\x93\x2e\x5c\x7d\x92\xe9\x61\xbf\x35\xea\x4a\xc4\x6d\xca\xa3\x89\x25\xdb\xc2\x4c\x36\x9f\xa1\x3e\x93\x7d\x24\x1f\x1f\x9d\x5f\x9e\x01\x0c\x36\x53\x40\x13\x8e\xb1\x9f\xcc\x4e\x2d\xc8\x6e\xe0\x3b\x3e\x1d\x3b\x97\x44\x1c\x6f\xdc\xcc\x43\xe2\x1a\x7e\x6e\xc7\x16\xbe\xe6\x4e\x4d\x00\xe3\xca\xbb\x7d\x7a\x91\x0c\xe7\xb0\xbe\x20\x4f\x19\x8c\x3a\x1d\xc9\xe0\x6b\xf0\x90\x21\x20\x04\xc7\xc1\x2c\x31\x86\x8b\x17\x2d\x22\xcb\xf9\xaa\x8f\x24\xab\xc0\x5d\x4e\x12\xac\xf1\x7b\xd8\x74\x44\x08\xc0\x59\x67\x65\x1b\x7f\xcd\xc5\xff\x16\x7d\x1e\x46\x41\xda\xaa\x29\x75\x3b\x82\x39\x71\x96\xd5\x8a\xb5\x91\x6b\xd5\xe7\x5c\x1a\xd5\xf4\xc9\xd5\xc7\x95\xd7\x60\x34\xdd\x1b\xc1\x22\x6d\x7e\xa1\x5e\x26\x93\xf4\x1d\x5c\x13\x2f\xa3\xfb\x88\xe5\x29\x01\x22\x5e\x62\x11\x4b\x09\xfa\x68\xc5\xb9\xd1\x74\xac\x38\x45\xcd\x35\xc6\x71\xf5\x32\x2f\x0a\x77\x3c\x06\x77\xa5\x0f\x1b\x1e\x97\xdc\xc9\x34\x3e\x22\x73\x58\xb7\xb8\x5e\xdd\x3a\x87\x75\x48\xf3\x9b\x60\x4d\x1b\xac\x4f\x5a\x7e\x3e\x21\x3e\xb6\xcd\xa8\xbe\x09\x21\x91\x21\x09\xf1\x13\x7a\xd2\x9e\xd2\xeb\x50\x19\xaf\x53\x6c\x94\x68\xb3\xe8\x01\xc4\x2b\x14\xde\x5e\x62\x99\x50\x56\x24\xb0\x38\x9f\x60\xe4\x78\xbc\x0a\x8f\x81\x2e\x05\xb7\xe6\x74\xe9\x75\xbb\xba\x51\xdd\x03\x25\xd0\xce\x2e\x3d\x06\x13\xec\xea\x21\x68\xd7\x1c\x26\x93\xbd\x8d\x7f\x02\xf3\x1e\xf5\x04\x61\xf2\x83\x3c\xce\xae\xf6\x86\x37\xff\x01\xcc\xdb\xd5\x73\x50\x09\x56\x3b\xac\x95\xc6\xd9\x1d\xe3\xf8\x53\x1e\x98\x5e\x2c\xd6\x66\xd2\xe1\x1f\x46\x83\x5e\x1c\xb2\x23\x3e\x80\x69\x8a\x48\x4f\xac\x1b\xe0\x16\xab\x97\x08\x4e\xfe\xd5\x5e\x97\x2b\xbd\xa5\xb5\xcb\xc1\x6e\xbc\x78\x9b\x59\x70\x68\x34\x70\xbd\x24\x10\x9d\x2c\x8a\xe5\xdb\x9c\x74\x0f\x44\xb3\x01\xb2\xc4\xe3\x6f\x44\xdc\xaa\x96\x4e\xc0\xf9\x6b\x3f\xbb\xbc\x53\xdd\x0d\xb7\x15\xaa\x07\xa0\x13\x62\x0e\x6f\xde\x3e\x4d\x41\x1b\xcb\x1d\x2d\x1e\x9b\x69\x8c\x3e\xa0\xae\x9c\x02\x7d\xa1\x93\x5d\x7a\x1a\x2a\x0b\xd5\xad\x30\xbc\x31\xaf\x7a\x81\x2b\x36\xca\xc2\x41\xcd\xa0\x93\xb8\xa2\x80\xdc\x22\x2e\xc2\x12\xaa\x23\x6a\x12\xbf\xd5\xce\x07\xf0\xdd\x13\x1d\x6b\x78\x95\x27\x5e\x13\xfb\x70\x34\x50\x8b\x7c\x66\xa0\xf4\x10\x60\x76\x89\x3f\x02\x5e\xf9\xc2\x7e\x9e\x3f\x09\xb7\x4d\x57\xcb\xd4\x54\xa9\x5c\xe0\xf6\x71\xeb\x34\xce\x65\x23\xb1\x18\xae\xd7\xbb\x6c\x44\x67\x77\x78\xa8\xd4\x03\xf3\x69\x75\xd6\x38\x78\xf1\x84\x5d\x5a\x0f\x37\x97\xaa\xd3\x1c\x8f\x4a\xd7\x98\x13\x93\xcf\xf2\x94\x9d\x49\x06\xaf\x3f\x24\x3b\x9f\x65\x57\x27\x8e\x43\x23\xa1\xbb\x2f\x29\x56\x0f\x43\x1b\x81\x97\xf1\x77\xec\xfe\xaa\x3a\x7c\x3a\x1a\x08\xed\x5e\xeb\x38\xc4\x4f\x0f\x71\x1c\xe7\xd1\x1e\x98\x06\x8c\x19\x43\x1a\xf4\x29\xe9\x50\xa3\x4a\x23\x64\xd7\xb3\xc5\x46\xdc\x12\xbe\xb9\xa1\x82\x42\x48\x41\x35\xa8\x9b\xf8\xe9\x81\x8e\x57\x20\x19\xac\x82\xef\x3c\x77\x1d\x09\x36\xb3\xab\x0e\x3a\x65\xca\xa3\x49\xa5\xb7\xe8\x5a\xcf\xa8\xf3\x6b\xa0\x18\xbc\xec\x7c\x0d\x7f\xbc\x9f\x63\x03\x9f\x88\x98\xc9\xcd\x61\x0a\x2f\xf8\x0d\x4c\x61\xb2\x10\x0d\xf3\x71\x75\xf2\x5c\x78\xe0\x17\x3b\xce\x5c\x8a\xf8\x47\x7d\x1c\x7d\x70\x26\x40\x36\xeb\xe7\xc4\xd5\x31\xab\xcd\x4f\x1c\xbc\xed\xa5\x97\x65\x10\x2b\xef\x2e\x50\xcf\x86\xea\xf2\xd3\xd0\x79\x68\x31\xa5\x5b\xee\xf5\x87\xe5\xa9\x9a\xdf\x27\xbb\x6d\x8f\xfc\xb9\x6c\x2f\x2c\xaf\x93\x5b\xe4\xcf\x6d\xfa\xde\xd5\x68\x27\x3e\x9a\x9f\xea\x47\x56\x62\xda\x73\xd6\xbf\xd3\xe6\xbb\xdd\xa2\xd9\x3e\xb4\xee\x98\x9c\x9f\x56\x77\x4c\x8a\x45\xcc\x78\xb7\x0e\x3b\xd8\x82\x5d\x6d\xde\x6d\x79\x4f\x45\xba\x4e\xce\xbb\xc1\xf4\x19\x84\xbf\x43\xed\xb4\x08\xc6\x8a\xc6\xbf\xd6\x71\x9b\xdc\x26\xa3\xee\x2c\x2f\xdd\xac\xe9\xe1\x86\x3a\x34\xdb\xff\x99\x3a\x34\x8b\xbd\xa2\xf6\x5a\x00\xd5\x10\x81\x7a\x51\x37\xc9\xfd\xd2\xea\x16\x82\x85\xcf\xa6\x3a\x12\xff\x9e\x7f\xad\x52\x8b\x6a\xe1\x56\xf0\xb1\xc3\x30\x49\x4d\xab\x1b\x2b\x3d\x23\x3e\x7b\x74\xeb\x3b\xc2\xe6\x23\x16\xde\x0c\x46\xec\x0a\x74\xa0\xbd\x4f\xd1\xa4\x1f\x08\x71\xf5\x2d\xfd\x16\xc3\x0b\x07\xec\xd0\x57\x96\xb2\xea\x02\x0f\xc9\x3b\xdc\x3a\x68\xec\x0b\xa2\x0f\xfc\x6d\x5f\xc8\x70\xfb\x42\xb7\x05\x68\xb7\xcb\xf2\x04\xcd\x68\x84\x17\xe9\xe6\x2d\xc6\xe6\x2f\xac\x66\x30\xea\xb8\xa4\x47\x61\xa5\x86\xd7\x3d\x5a\x70\x84\xcc\x85\x30\x58\xf4\x2b\x9f\xd5\xb5\x55\x86\x75\xa8\x6b\x2b\x7d\xa6\x61\x86\xb8\x75\xd8\xce\x16\xe0\xf2\x05\x1d\x47\x5c\xaf\x46\xb8\xa9\xa9\x2d\x7a\xc1\x56\xb5\xc3\x22\xc8\x87\x1e\x76\x69\x4e\xdd\x0a\x25\x2f\xb5\x2e\x44\x9a\xb1\x44\x60\x67\xfe\x1d\x6c\x97\x6a\xf3\x16\xc3\x10\x68\x6f\xe7\x2b\x1d\xb3\x95\x11\xc9\xd7\x4f\xf1\x99\xb0\xa9\x39\x6c\x61\xfb\x3f\x86\x0d\xf1\x6e\xec\x45\x50\x03\x7a\x3b\x74\x56\x77\x09\xec\x05\xd7\xa4\xbb\x04\xdf\x1d\xdc\x63\x57\x94\xcd\x4f\x61\xe2\x93\x55\xd1\x7f\x4b\xb2\x30\xda\x9e\x9c\x74\xf7\x17\x00\x6d\x01\xd1\xd2\x05\x9a\x9a\xa4\x0e\x59\x0a\xf7\x9f\xb3\x2b\x23\x52\xae\xeb\xe5\x5f\x49\xb7\x6d\x9d\xf6\xff\xe3\x7d\x8a\x30\x7c\x8f\xa5\xd0\x5d\xc0\x34\xd8\x28\xcf\xcd\x4f\x8c\x38\xfb\x87\xe9\x14\x49\x7c\x34\x02\x92\xae\x11\x52\x48\xb6\xdb\xc7\x13\x21\x5a\x48\xb8\x5b\x7d\xad\x10\x25\xbc\x22\xff\xaa\x6e\x2d\x84\x4a\x81\x35\xc8\xa3\x5d\x52\xbf\x2f\x9e\x7c\x8b\x1e\x54\xc6\x1f\xf0\x72\x43\x3a\x75\xe7\xf9\x7d\x06\x69\x2f\xd1\x65\x99\xd7\xd5\xed\xe3\x61\x8d\x70\xa9\xfb\x20\x43\x3d\x5a\x0a\xb5\x18\x56\x74\x62\x8d\xeb\x48\xd1\xda\xbe\x47\x1d\x37\x54\xd1\x72\x0d\xab\xd5\xcf\x47\x51\x0d\xbc\x2d\x5f\xaa\x5e\x2d\x83\x5a\xc7\x76\x9e\xd3\x08\xbf\xbd\x2d\x88\x6c\x2f\x29\x92\xd1\xbb\x59\xf8\x46\xe8\x19\xa0\xb8\xd1\x97\xa9\xe7\x47\x10\xfa\xb7\xd2\x0b\x02\xbb\x6e\xbf\x94\x8c\xd8\x13\xdd\x6d\xac\x8d\x2d\x40\xc7\x64\x4e\x11\x81\x00\xd5\x73\xa5\x39\x64\xb2\x5d\x03\xec\xdd\xea\xe5\x61\x08\x9b\x69\x97\xef\xfc\x06\x75\x52\xd7\x4d\x7a\xd7\xa5\x93\x06\x5f\x10\x2d\x41\x8f\x83\x2d\x70\xa5\x59\x5f\x30\xa3\x01\xc9\x17\x76\x4c\x84\x47\xed\xf2\x0e\xf5\x58\x39\xd4\x6a\xbe\xb0\xee\xc6\x3e\x40\xc6\x1e\x05\xc7\x84\x1b\x7a\x14\x42\xd2\x8b\x98\x52\x70\x56\xaf\xce\x82\x91\x70\x93\x5d\x7e\xef\x84\x9d\xce\x01\xf3\x8c\x79\x53\x9c\x7a\xa4\xb1\x54\x56\xf4\xf8\x83\x9a\x74\x8e\x2f\x9a\x1f\x34\x1d\xb3\x1a\x62\xd5\x35\x18\x96\x8b\xf1\x9f\x97\xc3\xcd\xc8\x32\x1f\xd9\x18\xdb\xa3\xed\x37\x8f\xdc\x12\xee\xe3\xea\x7e\x58\x0c\x26\x3b\x64\xf0\x17\xed\x8e\x4b\x52\x5c\x63\xf9\xb1\x4f\xd5\xfa\x67\x49\xd6\xe1\x0f\xe8\x9b\x43\x75\x85\xd5\xce\x88\xed\x05\xf5\x3d\x78\xfc\xa2\x5d\x3a\x65\x77\xe4\x88\xd6\x05\x6c\xa8\xa7\xbd\x45\xdb\x92\x25\x44\xd4\x29\xba\x46\x3a\xf5\xf0\xd3\x26\x3d\xeb\x1b\x6a\xd9\x64\x88\x82\x42\xbb\x3c\xdf\x71\x10\xd6\x4f\x51\x8f\xf2\xd1\x8d\xdb\x40\xa6\x2d\x8c\xe4\xd7\x89\x36\xa0\x8d\x80\x5e\x84\xdf\x48\x0d\xee\x51\x30\xa4\x85\x7e\xb0\x64\x32\xdc\x24\x5a\xdb\xcb\xea\x1b\xf0\xe8\x64\xf5\x7d\x1c\xd7\x4d\x1e\xf1\xab\x41\x9c\x43\xd8\x30\x06\x36\xc5\x6f\x79\x14\x2c\x55\x37\x4d\x81\x76\x50\x80\x51\x16\xcc\x9d\xa0\x6e\x11\xa7\x48\x7a\xf0\xaf\xa7\x33\x19\xdd\x71\x8c\xac\xc8\xa0\x6b\x19\xd7\x1d\x18\x45\x4e\xe4\xb7\xd9\x21\x91\x9f\x2e\x72\x2c\x90\x56\x7b\xe0\x91\xdf\x3a\xe3\xec\x1b\xac\xd6\x6c\x94\x8d\xa2\x8f\x87\x97\x0f\xdb\x79\x35\x3c\x52\xa4\x8e\x50\x8b\xe4\xf1\x1e\xed\xc9\xcd\x9f\x36\xb6\xfe\x11\xfe\x44\xc3\x2a\x2e\x80\x1c\x3b\x2f\x86\x47\x4b\xd4\xed\x7c\x7c\xa3\x71\x9f\xfc\x40\x58\xcb\x68\xf8\x53\x7e\xd0\x77\x0e\xa2\x8f\xb4\xcb\x91\x75\x67\xa4\xc2\x3e\x8e\x87\xa5\x1c\xa1\xc7\xec\xa6\x7e\x20\x3c\xcc\x15\x6d\xfd\x19\x3f\x70\x8d\xb5\xc3\xe7\x42\x67\x9a\x20\x38\x66\x4b\x7d\xfb\x3a\xd6\xf3\x95\xb4\x87\x6a\x8e\xbb\x9e\x4e\xb6\xd0\xa6\xf5\xdc\x50\xcd\xef\x78\xdb\x0e\x75\xc8\x3c\x28\x10\x31\x57\xb5\xba\x51\x1a\xdb\xcd\x31\x0a\x3a\xf3\x7e\xac\x71\x3d\xed\x6c\x81\x5a\xdf\xab\xd5\xd3\x9c\xc7\x85\x34\xeb\x71\x4f\xa8\x33\xe7\xe1\xe4\xd6\x68\x87\xd1\x52\x68\x37\x47\x9a\xf4\x84\x07\xae\x97\xe8\x1f\x35\xff\x90\x85\x77\x38\x23\xaf\x1b\xe7\x60\x21\xae\xd9\xc7\x84\x79\xf0\xc8\x71\xec\x24\xa4\x2e\xdd\xea\xbe\xfc\xd8\x15\x7b\xe5\x34\x17\x87\xdf\xe0\x1e\x2d\x78\xc7\x98\x79\x90\x66\x87\x64\xa9\x67\x37\xc7\x73\x52\x12\xf3\x8c\x65\x44\xbf\x63\x71\xf5\x13\x3a\x71\x5a\x9c\xde\x15\x6e\x20\x8f\xee\x03\x3f\x6f\x88\xbf\xf2\x16\x42\x27\x57\xfc\x65\xe8\x50\x37\xdb\x35\xb6\x67\x34\x1d\x2b\x35\xbb\x71\xbd\x4e\x8f\xd8\x5e\x8d\xb1\x7f\xcb\x2f\x86\x2c\x84\xae\xae\x18\xcc\xd0\xb1\x6e\xfc\x0d\x31\x98\x13\x5f\xeb\x87\xfe\x38\x7e\x73\x71\x98\x77\x72\x5d\xd2\x0d\x71\x58\x13\x7c\x0d\x5e\xa7\xe1\x6b\x15\x34\x83\xdf\x7c\x2c\x66\x4c\xbe\xfe\x9e\x33\x16\xcb\xf4\x8c\x7d\x5c\xb1\x18\x8e\x9c\x3a\x2d\x1a\x73\x79\xc6\x0d\xf1\x58\x07\x01\xb8\xe6\x2b\xbb\xc0\x1a\xe6\x8c\xc7\x32\x9a\x89\xc7\x10\xaa\x61\x22\x95\xdd\x5c\x3c\x36\x78\x31\x4e\x70\x10\xa6\xee\x66\xe9\x13\xd6\xa4\x6f\xfc\x93\xf1\xd8\x09\xf5\x3f\x95\x30\x4f\xc4\x63\x8e\x77\x07\xf2\x9b\x9b\x8d\xc7\xb4\x58\xe6\xcf\xc7\x63\xfb\xd4\x6d\x95\xae\x78\x2c\x4a\xf5\x41\xf8\x66\xe2\xb1\xbf\x59\xc7\x26\xf5\x68\xa5\x2b\x22\x1b\xa1\xda\xb0\x0e\x8a\xc8\x9a\x8d\xf9\x3c\xea\xf8\x9d\x98\x2f\xc3\xa3\x86\x35\xea\xc5\x4a\x67\x54\x36\x47\x9d\x88\x15\x50\x58\xd6\x68\xfc\xa0\x71\x5f\xcc\x83\x5b\x8a\xca\x1a\x7a\x09\x37\xec\xe3\xea\x0f\x95\xf0\x82\x88\xca\x86\xab\xd3\x04\xaa\x16\x96\x21\x6e\x59\xe3\xb8\x8c\xc9\x5e\xfa\x3f\x10\x97\x5d\xa8\x84\x25\x76\x79\x91\xda\x75\xb0\xb0\xa2\x27\x7f\x7f\x3c\xbe\x13\xc3\xe4\xf4\x21\xfc\x94\x5d\xde\xeb\xf8\xa4\xcc\x85\xd3\xa7\xf9\xd8\x56\x12\x83\xa5\xee\xc6\xc8\xa9\x51\x0f\x9b\xe8\xea\x61\xff\x4f\x7d\x73\x0a\x4c\x83\xc5\x18\xe8\xa8\xab\x27\xc0\x03\xce\x78\x6f\x90\xc7\x18\x11\xe6\x69\x23\x44\xd7\xeb\x74\x62\xc9\xcb\x55\x01\xbd\xf3\xd0\xdc\x18\x71\x63\xfc\xcf\x97\xba\xe3\x7f\xde\xfb\xf7\xea\xd1\xcb\x3a\xac\xeb\xcf\xd4\xe3\x9e\x05\x40\xa8\x7b\x16\x20\xe5\xb1\xc6\x3e\x81\x63\x11\xfa\x04\x17\x7d\x32\x57\x74\x58\x9b\xd2\x28\xb0\x68\xe8\x79\xa8\x65\x4b\x6e\xf0\xf2\x33\x53\xa1\x1a\x66\xd9\xb1\xc3\x38\x3d\x01\x76\xd4\x6d\x94\xe3\x1a\xc5\x16\x18\xbb\xd2\xd8\x21\xd3\x1a\x8e\x8e\xfa\x9d\x46\xeb\x62\x8d\xc7\x8f\x44\xec\x8d\x85\x7b\x6c\x2f\xc0\xb0\x5d\xfa\x50\xdd\x5e\x02\x8f\x5e\xfd\x6b\x71\xbb\xe4\x8a\xdb\xbf\x51\xc7\xc2\x68\xc8\xb6\xcb\xe3\xd4\x1e\x76\x11\x9c\xb5\x10\xb7\xcb\x0a\xf6\xb9\x5e\x8a\xc7\x20\xdc\xec\xca\x8a\xde\x1d\x5f\x5f\x52\x8b\xa0\x14\xda\xda\xa5\x87\x55\x3b\x74\x81\x38\xf6\x4f\xce\x09\x1e\x53\x0f\x40\x11\x0e\x17\x10\x07\xf3\xec\xea\xfb\xd2\xc3\x7f\x23\x76\x07\xd7\x72\xe0\x87\x70\x27\xe8\x30\x4e\xb5\xab\xb2\x3c\x0e\xf1\x46\xff\xd5\xd8\x5d\xd1\x46\xe5\x77\xd4\xa9\x93\xc0\x00\xb3\xed\x72\x9c\xc3\x0c\x2b\x26\xaa\x52\x21\xe9\x60\xcc\x3f\x1d\xb3\xcd\x9a\x08\x16\x28\xb3\x4b\x4b\x1c\x6f\xc3\xad\x13\xd5\x5f\xf8\xcd\x17\x45\x3d\xf9\xff\xf4\x1c\xa1\x6a\x3c\x06\x19\x7d\xed\x7c\x06\x76\xfd\xff\x2a\x55\x0f\x42\x1a\x1f\xd7\x48\x9e\xbf\x38\x47\x58\xad\xde\x33\x05\x06\x42\x12\x46\x6c\x30\x63\x82\xfa\x0e\x46\x6c\xcc\x43\xff\xce\xf1\x94\x6b\x7d\x9e\xd2\x78\x64\xbe\x61\xcd\x34\x71\x12\xbf\xd9\xce\xdf\x99\xe8\x78\x5c\x7e\x5f\xf3\xb9\x09\x7f\x2f\x96\xaf\x29\x80\x54\x3b\x0a\xbe\xa2\x44\xdd\x27\xad\x40\xbc\xce\xcd\xc5\x6a\x18\x8e\x88\x0e\xc8\x15\x8f\x34\x1d\xa3\x1b\x62\xb5\x8f\xd4\x9c\x4a\x48\xc2\x09\x91\xf4\x6e\x5d\x37\x7e\x64\xa0\x1a\x2a\xe7\x6a\x7c\x66\xdd\x30\x8e\x3a\x63\x35\xd1\xee\x9a\x04\x3b\x96\xdf\x8e\xd6\x86\x56\xe2\x9c\x6b\x92\x5d\x4a\xae\xdb\x2f\xaa\xf0\x91\xca\xbe\x6d\xa1\x0e\x77\x3c\xf5\x87\xeb\x30\x37\xd4\x91\x03\x03\xec\x3c\x07\x07\xe9\x23\x03\x1d\xdf\xf2\x81\x9c\xce\x85\x62\x9d\xeb\x1d\x7f\x27\x66\x73\xd5\xf0\x86\xa8\x61\x1c\x4e\xfc\x21\x5f\xdd\xc8\xbf\x18\xe8\xd8\x06\x3d\xa4\x29\x1e\xfa\x77\xc6\x6c\x0c\x38\xc6\x47\x7f\x28\x66\x1b\x56\x09\x77\x5f\xb7\x0b\x6e\x8b\x9d\x31\x5b\xe7\x1b\x63\xb6\xdf\xf1\x31\x3e\xeb\x4e\x81\xd3\x83\x60\x4e\xc9\xce\x71\xb5\xef\x9f\x8c\xd9\x62\x9d\x31\xdb\x0f\xea\xe2\x5a\x1c\x7e\x0e\xca\xbf\xd6\x15\xa4\x49\x1a\x4f\xbd\xff\xa9\x78\xea\xb4\xfa\xc2\x02\x78\x0c\x06\xdb\xa5\xf9\x60\xa9\xdb\x8d\xf8\xea\x26\xc8\x6b\xbe\x8e\xbf\xba\x4e\xf7\x3f\xf5\xdd\x05\xb0\x41\x8c\xd3\x45\x70\xd1\xc1\x3b\x4a\xd7\x1c\xdf\xf0\x50\x8f\x3a\x96\xfd\x35\x39\x3c\xa3\xb6\xd7\xd4\x2f\xb4\x3a\x1e\x93\xe6\x38\x72\xd3\xa4\xba\xba\x75\x52\x01\x6b\x24\x47\xa3\xf5\x34\x44\xd6\xfd\xd6\x7a\x9a\x07\xf4\xf3\xea\x19\x0d\x5a\x72\x38\xf2\x51\x41\xda\xaa\x28\xe1\xfe\x85\xf5\xb4\xc3\x88\x75\xa7\x1c\xe1\xe8\xa2\x99\x12\x71\x96\x7a\xce\x3b\x51\x03\x0a\xcd\x3b\x3d\x87\xe5\x46\xab\x69\x82\x31\xc1\xd7\x71\xf5\x99\x79\x30\x05\x06\xd9\xe5\x1d\x1f\x3b\x26\x75\xe3\x6f\x40\x46\x63\x3c\xf7\xba\x97\xc2\x5a\x8e\xde\x3c\x7a\xb3\x58\x77\xf4\xf6\xad\xba\x69\x2e\x54\x41\x57\x0c\xde\x1c\xd5\xdd\xf8\x61\x11\xbc\x79\xae\x23\xfc\x03\xb1\xdb\x3e\xf5\xc5\xb9\xf0\xa2\xf0\x89\x7c\xb8\xcb\x31\xbb\xaf\xd4\x57\x1d\xc9\xfb\xb3\xc6\xf5\x74\xb0\xb5\x6a\x14\x7f\xb6\x50\x4b\x4b\x3e\xf1\xb2\xfa\x89\x56\xc7\x6b\xfc\x07\xc7\xab\x58\x85\xc3\x2a\xdd\xa2\xe9\xa8\x8b\x87\x4f\x58\x74\x14\x0b\x71\x6c\x8f\x4d\xa3\x36\x4b\x76\x5a\xf3\xd1\xfc\x33\xea\xe1\x39\x18\xcd\xa3\x4f\xdc\xef\x78\xaf\x8f\xd4\xaf\x6e\x95\x38\x03\x9f\x78\x6f\x1c\xb7\xc9\xda\xf3\x96\x3f\x1c\xb7\xed\x9a\x07\x2f\xd9\xa5\x37\x1c\x6b\xbb\x49\x83\xd7\x6a\xbc\xde\xdb\xd8\x3f\x14\x11\xb7\xb5\xec\x1f\x92\xcb\x3f\x0e\xab\xab\xc6\xe3\x60\xd9\xcf\x2e\x8f\x57\x8b\xd4\xd5\x45\x30\x8a\x57\x37\xc2\xa3\xb1\x4e\xd2\xeb\x75\x5c\xe7\x65\x60\xc8\x20\xc8\x7a\x8b\x2c\xb9\xe6\xa1\x9e\x1c\x1a\x88\x3f\x73\xac\x94\xea\x78\x7b\x3c\x7f\xdc\x6e\x97\xbe\x70\xdc\x5c\xc4\x4f\x9d\xb9\xb6\xb8\x31\x8f\xee\x39\x83\xe2\x8c\x23\xfe\xcc\x9c\xe1\x2b\xf5\xd8\x78\xe8\x07\xa3\x31\xbe\x52\xdf\x2c\x82\x69\xce\x75\xc0\x7b\xff\xb6\xdf\x79\x84\xdb\x6f\xd5\x6b\x4a\x81\x9e\xd0\x51\x3d\x55\x04\xf3\xd5\xdd\xd2\xb2\xa6\x7a\x6e\x6f\x0b\x6e\x14\xcb\x2b\x34\xcd\x6b\xd6\xeb\xb4\xcf\xfc\x1b\x66\x79\x5f\x4e\x24\x78\x3e\xe8\xd7\x52\x98\xef\xd8\x2f\x2f\x64\x8d\xd6\xde\xff\x82\x5f\x98\x1b\xe2\x79\xfe\x00\xc5\xf3\x3c\xa9\x49\x3c\x1f\x47\xe3\x09\xce\x47\x65\x8e\xe3\x67\x83\x07\x23\x60\xf3\x11\xfd\x51\x75\x10\x0c\x87\x6e\x76\xe9\x33\x07\xce\xd0\x9e\xf8\x8d\xb8\xfb\x0f\xc6\xf4\x92\x3b\x48\xbe\xa0\x4e\x86\x21\x62\x15\x28\x4e\x4d\xb3\xf3\x0a\xea\x94\x9a\xc1\x56\x68\x2d\xfe\x0f\x61\x7b\x04\xe0\x87\xd4\x35\xd0\x1a\x27\x4b\xfc\x7e\xf5\x5d\x3b\xdc\xc1\x23\x6e\x98\xd7\xe0\xa8\xa1\x37\x18\x81\x63\xec\xe6\x65\x11\xef\x3e\x37\x99\xd7\x38\xc1\xb0\xb3\xfb\xaf\xf3\x15\x1c\x8c\x28\xed\xea\x39\x79\x2b\xba\xb2\xe7\x7c\xce\x23\x9e\x17\x4a\x95\xf4\x4d\xe3\x9e\x66\xe3\x79\x5a\x29\x66\x80\x0d\x64\x5f\x5d\x0a\xd4\x96\x9e\x93\xef\x6e\x61\xfd\xe3\x4f\xc6\x6d\x8a\x3b\x6e\xc3\x0a\x7c\xe0\x16\xbb\x34\xaa\xee\x3f\x58\xc1\xcf\xd2\xe1\xed\xff\x04\xbe\xc7\x2a\xff\x78\x88\x84\xe9\x14\xb3\x21\xbe\x7a\x8d\x2f\x76\xc6\x6c\xff\x6c\x1d\x39\xd0\x1f\x23\x66\x9c\x25\x60\x1d\x47\x21\x43\xba\xaf\xc9\x73\x46\xab\x78\xee\xc9\x78\x73\x2b\x6d\xd9\x0d\x51\x1b\xf5\x1c\x6a\x47\x75\xea\x44\x98\x07\xde\x76\x98\x5b\xae\x3e\x2b\xff\xea\x7e\x66\xe9\x19\xb7\xfd\x81\xb9\x81\x68\x68\x88\x74\x13\xe1\x7c\xe5\x5a\xc7\x6d\x78\x16\x1b\x61\xf3\x11\xe3\xb3\x81\xe2\x12\xf9\x86\xe7\xf1\xee\x88\xed\x9c\x3a\x73\x29\x6c\x16\x11\xdb\x75\x7d\x8a\x32\xa2\xd1\x1a\xa5\xab\x7f\x74\xc6\x52\x7a\xd9\x13\xcc\xe5\xab\x1e\x7a\x8b\x6f\x18\x74\x7e\x55\xef\x5a\x04\x9b\xc4\xa0\x73\xd7\xb5\xeb\x0b\x92\x95\x11\xea\x2e\xe8\xcc\x58\xb3\xcf\xb9\x99\xd2\x32\x7a\x76\xb3\x23\xf2\x17\xea\x73\x8b\x09\x9d\x0f\x80\xef\xaf\x7f\x84\xf0\x8e\x83\xd8\xd3\x34\xf3\x7c\xfe\x8f\x61\x7b\x8e\xc4\xef\xaa\x4f\x2c\x82\x4f\x10\xfb\x3b\xc9\x54\x67\x48\x55\xf2\xea\x8e\x4a\xf1\x8d\xdf\x27\x68\x58\x53\xe3\x37\xbc\x51\xd0\xd2\x9a\xda\x56\xf5\x95\x85\xf0\x91\x73\x4d\xbb\x83\x32\xac\xe1\x79\x75\xdb\x1b\xd7\xd4\x38\x97\x14\x8f\xb5\xe6\x66\x9f\x75\x2e\x85\xff\x12\x96\x30\x1a\xe1\x34\x7a\x17\x43\x8b\xcd\xc4\xc0\xdb\x8c\xed\xdd\x71\xd9\x01\x75\xc4\x62\xd8\x2a\xc6\xdd\x1d\x87\xea\x02\xb3\x70\x74\xea\xcb\x5a\x78\x57\x44\xa1\x77\x45\x50\x8f\x4e\xc0\x1b\xed\xd3\x10\x93\x5d\x51\x4b\x6a\xe1\x35\x18\x81\x31\x59\x5d\x64\x9a\x9c\xad\xc5\x64\x0d\xef\xb8\xa4\x79\xc6\x4a\xb4\xce\x85\x3f\x9e\xd0\xd9\xbf\x13\x91\x9d\x56\xef\x5e\x00\x6f\xe3\x4c\x80\xcf\xc6\x99\xc0\xc2\x34\xb9\x9f\xba\x89\x8f\x6e\xf6\x3d\x1a\xb2\xff\x6f\xd5\xd0\xbc\x17\x7c\xa6\x3e\xb6\x08\x3e\x83\x74\xfb\x07\x7c\x5a\xdd\x27\x19\xb2\xcd\xb1\x14\x27\xcb\x4d\xde\x31\xa2\x75\x34\x2d\x46\xe7\xf4\xd4\xc8\xf3\xe9\x46\x76\x93\x91\xb7\x91\x2f\xbc\x71\x0b\xbc\x2b\x7c\x21\xb6\xee\x58\x9a\x9c\x5f\x77\x4c\x0e\x6d\xe1\x1d\x18\xe7\xd8\x2b\xbc\xd7\x05\xdc\x62\x3c\xb6\x75\x01\xbc\x8b\x73\xa3\x3a\x7b\x9a\xfc\xce\x4a\xd6\xe4\x3d\x2d\xf2\x09\x11\xf7\xf3\x06\x77\x6d\x6e\x8d\xf5\x9e\x79\xfc\x1b\xbb\x3c\xf5\xfa\xc3\xb9\x4a\x37\xf7\x3b\x5a\x37\xfa\x82\xd6\xa6\xdc\xea\xbc\x61\xdd\xcc\x2d\xec\x2f\xea\x8c\xb9\xb0\x0e\xa6\xd8\xa5\x57\x7e\x75\xf4\xe9\xc3\x3f\x82\x22\xfa\x18\xbe\x99\xf7\xdd\xb4\xd8\xff\x37\x7d\xcc\x23\x02\xfb\x45\x7d\xb4\x06\xec\x30\x16\x23\x30\x47\x49\x3f\x7e\x94\xde\x77\xcb\xf8\xe7\x7c\x6c\x9f\xba\x76\x3a\x46\xe4\x83\xec\x60\x85\x64\xc7\x2b\x03\xf9\x69\x75\x93\xb4\xbe\xd1\xfb\x85\x09\x14\x8f\x6b\xf6\xd7\x35\x7d\xb6\xd5\xb2\xed\x35\x58\x1e\xed\x38\x3e\x84\x9f\x76\x1c\x92\x6b\x5b\x78\x17\xee\x8f\xd9\x5e\x1b\x0a\xb6\x56\xc3\x9b\x04\xd9\x8f\x9f\x12\x8f\xd4\x1b\xbd\xab\xf9\x7b\xfd\x81\x3b\x0e\x3f\xa1\x0e\x1f\x07\xf7\x40\xbe\x1d\xa7\xbd\x8f\xaa\xd3\x4a\xe1\x66\x94\xb8\xf1\xfb\xa4\x1e\xb6\xfa\x1d\x1f\x20\x54\x8a\x04\xbe\x50\x07\x8f\x80\x47\x84\xbf\x97\xab\xa9\x6a\xd9\x74\xb8\x8d\x3f\x79\x9e\x35\x7e\xef\xd5\xf5\xdc\x5c\x5b\x3b\x46\x99\x25\x49\x6c\x53\x94\x96\xda\x92\xd4\xc2\x59\x17\x4e\xe2\x27\xed\xbc\xca\xb1\x66\x22\xdf\xcd\x07\x30\xcf\xf7\x73\x5d\x6b\x77\xee\x7e\x4b\x96\xdd\x78\xbf\xe1\x55\xbb\xd5\x37\xa6\xc0\x6c\x98\x81\x91\x96\xfa\x6a\x21\x54\x3b\xd7\xee\x06\x37\x37\x2f\xd7\x1e\x67\x4a\x92\x8e\x80\x1b\x90\x9b\xb5\xfa\x8e\x09\xa4\x01\x0c\x23\x0e\x14\xc2\x6d\xea\x6e\x79\x67\xe3\x77\x5f\x9b\x91\x9f\xc6\xfe\x16\xe5\x27\xab\x8f\x83\x0d\x76\x68\xa3\x1e\x2e\x86\x25\xd2\x63\xac\xf1\x3b\xd4\x66\xd7\x73\x79\x2e\xeb\x25\x45\xb6\x68\x53\xb0\x9c\xc6\xe1\x20\xb8\xc2\x6c\x9c\xd1\xdc\x0b\x7e\xb0\xd4\x2e\xbd\x55\x97\x6b\x77\xc5\x25\x0d\xb1\x70\xdb\x86\xf7\xc6\x34\xbb\x37\x42\x6c\x2e\x0c\xce\x70\xc3\x9a\xc4\xb3\x95\x84\xba\xcf\xed\x72\xdb\x4f\x9a\xe2\x26\x39\xe3\x77\x57\x7c\xd6\x1c\x72\x48\xb3\x01\xf6\x49\x75\x25\x44\x40\xb5\x9d\xe7\x3a\xde\xb2\xf3\xcb\x5c\xd7\x1c\xbf\x32\x6b\x11\xb5\xe5\xb0\x3d\x1d\x26\xd8\xa1\x9d\x7a\xc8\x0e\x13\x50\xab\xe2\x5b\xa3\x37\x64\x3b\x1f\xa8\x4c\x62\xde\x62\xef\x0d\x2f\x2f\xb6\xc4\x48\x87\x4c\xa4\x87\xed\x49\xa3\x48\x5d\xfb\x3e\x8f\x7e\xf9\xc0\x71\x89\xa9\x87\x52\xdb\xe0\x6f\xe2\x38\x65\xd2\x67\x95\xf8\xdf\x67\x62\xcf\x97\x6a\xe5\x43\xb8\xe8\xfc\xc6\x21\xc0\x66\x90\xb4\xed\x87\xbd\xf4\xae\xcf\x12\xb4\xaf\x1b\xc4\x86\x5f\xff\x2b\x97\x56\x7d\x28\x81\xc3\xf1\x58\x38\x2f\xd2\xbe\x6b\x50\x1f\x5f\x2e\x30\x16\x29\x1f\x72\xe5\x06\x0c\x9d\xc1\xfd\x69\x03\x7d\xe5\xa1\x44\xeb\xa3\xb1\x9b\x57\xaf\xaf\x92\x36\xaa\xcb\xe9\x4b\x04\xed\xfb\x8e\xc3\xcb\x11\x63\x99\xf2\x1a\xb7\x20\x46\x28\x6b\xcd\x5a\xdb\x4c\xca\x24\xdf\x4a\xdf\xc5\xbe\x92\xaf\xaf\x25\x32\xcc\x42\x1f\x67\xa5\xed\xa6\x6f\x39\xd2\x3d\xbf\xe0\xf3\xfc\xba\x21\xc0\x1f\xb0\x16\x48\x8f\xee\x9e\x9d\x15\xd6\x3e\xcd\x34\x36\x32\x73\x58\xd7\xd8\x9c\xec\x4e\xa1\xa9\x1d\xfc\xf2\xa3\x32\x86\x6e\x90\x2e\xae\x92\xee\x51\x5e\x0b\x09\x0f\x89\x4d\x18\x9e\x9b\x80\xff\x26\xc4\x8e\xec\x15\x0f\x73\x4d\xb7\xf9\xdd\xc1\x24\xf5\x29\xe5\x35\xe8\xe4\xfc\x3e\x23\x1a\x6d\x15\xe4\x1b\x64\xf3\x35\xf5\x0b\x0a\x0a\x0b\xf3\x02\x9c\x6a\xe6\x61\x97\x67\xf2\xd2\xa4\xa2\xfd\x54\x91\x9f\xa4\x74\xed\xd3\x0d\xf1\x6d\x49\x40\xb3\x7c\x81\xef\xba\xa8\x75\xea\x1c\x24\x0f\x35\xcf\x5a\x44\xe6\x50\xdd\xfd\xab\x57\xaf\x56\x97\x7b\x70\x16\x1d\x3b\xb4\x67\x3c\xea\xe5\x8a\x8e\xf1\xa1\xc4\x93\x81\xf9\xbd\x6a\x00\x69\x09\x9a\x26\xec\x8b\xb4\xf7\xb4\x4f\x5a\xa2\xf5\x58\x79\xc0\x03\xe2\x73\x93\xb5\x92\xba\xf1\x41\xa9\x0e\xa1\x4c\xea\x19\x3f\x10\xfb\x1c\xe0\xfd\x77\x28\xc7\xe0\x3c\xdd\xef\x83\xad\x2f\x50\x36\xda\xfc\x03\xfb\x19\x8d\x3e\x3e\xe0\x2f\x55\x4a\x7b\xb1\x41\xa3\x40\xf4\x29\x4b\x83\x2c\x21\xae\x6f\x64\xc0\x7b\x6d\xe4\xda\xb6\xce\xcf\x63\x96\x23\xf2\x6b\xce\x8f\x63\xa4\xfa\x38\xe5\x30\xfc\xdb\xf3\x7b\x21\xa1\x20\x7f\x04\xe4\x92\x97\xb7\x5b\x45\x0d\xba\x11\x9b\xcd\xc2\x6c\xd7\x37\x37\xdf\xf2\xbc\x40\xc7\x26\x92\xfa\xd8\x5c\x6a\x7b\x62\xaa\x92\x4d\xfb\xd3\x75\xb2\x85\xc9\xa0\x37\xe2\x1c\x54\x52\x7c\x14\x5f\xbd\x37\xf3\x1e\x9a\x2f\x56\x8d\x0d\x41\xdc\xdf\xf9\xb2\xb4\xeb\x93\x4e\x8b\xab\x11\xba\xf6\x8e\x15\xfb\x9d\xb6\xaf\x1d\x01\xa1\x23\x16\x24\x2e\xc8\x57\xbf\xc9\xaf\xe5\xf7\xc1\x33\xea\xd8\x8f\xd5\x6c\xd8\x29\xbe\x25\xcd\xae\x3f\xa7\x74\xd3\xb7\xb3\x24\x48\x45\x62\xef\x0b\xfd\x7a\x98\x08\x13\xcd\x7a\xbe\x82\x5d\xaa\xbf\x84\x36\x0f\x95\xbb\x07\x75\xb7\x79\x85\xc5\x4b\x7c\x6d\x26\x2c\xce\x84\x9c\x4c\xc8\x94\xbb\x75\x33\x27\xb0\x24\x73\x86\xb9\xa0\xa0\x20\x23\x03\x30\xd5\x1c\xd6\x86\x7f\x10\xeb\x45\x18\xd0\x04\xcb\x16\x64\xeb\xd9\x14\x2b\x27\xe7\x8f\x60\xbd\xf4\xb7\xb1\x96\x79\xe8\x2b\x00\xb6\x9a\xf5\x06\x13\xdb\x57\x7f\x8a\xb0\x7a\x18\x7a\xf4\x23\x2c\x0d\x28\xf5\xf7\x64\x5c\xe6\xa1\xaf\x7f\x0e\xeb\x45\x90\x9b\x60\xf5\x32\xf4\x1a\xd0\x14\xeb\x8f\xc9\xf8\xd2\xdf\xc0\x12\x7b\xa0\xb5\x17\xba\x67\x97\x11\x2b\x81\xaf\xf8\xbf\xef\xcd\x7a\xfd\x7a\x96\x05\x13\x05\x12\x28\xcb\x14\x3d\xe3\x42\xf3\x16\x58\x6c\x81\x1c\xec\xfe\x41\x96\x6f\x40\x62\x2e\xac\x5a\x37\x16\xea\x4b\xa0\x98\x75\x02\x53\x60\x49\xc1\xcb\x82\x5b\x21\x16\x78\x60\x49\x41\x41\x2d\x63\x85\x7a\x60\xbd\xc8\x62\x1b\x61\xb5\x5a\xd6\x2a\xac\x29\x56\x48\x48\xcb\x58\x25\x1e\x58\x2f\xfd\x4d\x2c\x83\xd0\xbd\x13\x6b\x3d\x0b\x44\xdd\xeb\x0c\xa6\x03\xa4\x79\x29\xf4\x85\x50\x2b\x62\x71\x58\xec\x07\x39\x7e\x90\xea\x07\x7e\xbf\x29\xe3\xa3\x1e\x58\x1b\xd8\xb8\xbf\x85\xc5\xdc\x58\x09\x02\x03\xed\xf8\x22\x33\xc2\x56\xb2\xa3\xd7\x0b\x5e\xfe\x02\x4b\x5a\x1c\x05\x39\x51\x90\x1a\x05\x51\xbf\x69\xc7\xfb\x3c\xf8\x7a\x89\x0d\x6d\xc4\x57\xf8\x0b\xe1\x31\x4d\xf9\x6a\x49\x5f\xa5\xf5\xe7\xe5\x62\x6a\xdb\xf3\x9c\xed\xb1\xbd\xb3\x6d\x6f\xd7\xda\xb6\xd4\xae\x4b\xbb\xf6\xbe\x81\x42\xfb\x31\xb0\x38\x06\x72\x62\x20\x46\x6a\xdb\xb6\x39\x5f\x15\x58\x15\x1e\x58\x1b\xfe\x26\x96\x27\x5f\x2f\x62\xd8\xd6\x18\xab\x7d\x97\xf6\x29\x4d\xb1\x92\x92\x5a\xc2\x9a\xef\x81\xf5\x12\x64\xfe\x2d\xac\x62\x6a\xdb\x2e\x7d\xf9\x39\xdb\xf6\x1e\xad\x6d\x4b\xc9\xe3\x92\x3b\x21\x16\x77\x02\xa5\xfe\xb6\x8c\xf3\x3d\xb0\x36\x20\x5f\x7f\x07\xcb\x93\xaf\x86\xfe\xcb\x85\x95\x3a\x2e\x35\xb3\x29\x56\xcb\x32\xfe\xcb\x03\xeb\x25\xb0\xfd\x65\x2c\xf1\xdd\xb0\xaa\x7f\xd9\xe5\xf7\x6c\xda\x8e\x23\xa6\x44\xbe\xa2\xfe\x1b\xf6\xa3\x59\xef\xe5\xa8\x9f\x89\xd1\x6c\x0f\x5b\x3b\x0e\x5e\x2b\xbc\x30\x34\x89\x97\xa5\xd6\x7e\xb0\xd7\x0f\xfe\xeb\x07\x2f\xf9\x35\x38\xb0\x3f\xfa\x30\x77\x37\x08\xaa\x43\xfc\x37\x5b\xab\xc8\xa3\x5d\xdc\xd1\x62\x5d\x2a\xce\x9b\xd6\xb1\x70\x9b\xbf\xbb\x2e\x0f\x40\x0d\xc5\xdd\xaf\x35\xc1\x30\x98\xea\x2f\xb0\x7d\xc4\x6f\xde\x1f\xc4\xb8\x81\x0f\x37\xc6\x1f\xe3\x43\xb3\xe7\xcb\x2e\x1b\x78\x39\xd8\x12\xb6\x4e\x48\x83\xb3\x08\x94\x86\x4d\x63\xc7\xeb\x8f\x08\x14\x59\x4a\x18\x9f\x10\x87\xc6\x90\xa5\x98\x98\x46\x28\xee\xf6\xfd\xa4\x07\x8e\x0a\xb3\xfe\x32\x4e\x63\x7e\x66\x08\x1c\x83\x09\x7c\x84\x54\x9e\x38\x1d\xc6\x77\x48\x21\x9c\xf6\xed\x7f\x97\x1f\xed\xbe\x06\x1c\x8d\x3f\x4d\x3b\x11\xe3\x23\xc2\xc8\xc9\x5a\xb5\xba\x11\x47\xe8\x38\x43\x9f\x84\x3a\x1e\xc4\x98\x59\x87\x5a\x0d\x67\xc1\x36\x5f\xee\xeb\x6b\x4e\xe0\x5e\x67\xbc\xbc\x65\x1e\x2f\x5c\x50\xeb\xe8\x80\xdd\xa4\x8e\x51\xb6\x29\x0f\x62\x1c\x3e\xd0\xd6\xc6\x1c\x6c\x09\x0a\x0a\x0c\xb4\x04\x78\x47\x04\xf0\x08\x29\x36\x26\x38\x38\x20\x50\x0a\xb0\x84\xfa\x4d\xca\x0f\x95\x99\x34\x29\x9f\x29\xf8\x1b\xce\x72\x92\xdc\xfb\xae\x37\xbc\x0b\xe0\x3c\x03\x81\xb6\x1a\xd1\xb6\xe5\xc9\xcc\x0a\xc8\x74\xee\x07\x2a\x36\x35\xd5\x3b\xf7\xc5\xd6\x4b\x7e\x20\x65\xce\x9c\xda\x76\x70\x87\xe2\x92\x56\xeb\xfc\xe6\xdf\xfa\xc8\x17\x21\x9b\xd4\x63\x38\x44\x9b\xa2\x47\xfd\x78\xf7\xa7\x47\x2d\x4f\xb5\x39\xae\x8e\x09\xd8\xe7\x3d\x7b\x91\xd4\xb1\x5f\xf6\xec\xe9\xeb\x17\xd6\xe1\x4c\xf9\xa9\xf1\x93\x3f\xdb\x35\x62\x62\xdd\x33\x7b\x3e\xa2\xb5\x38\xe4\x5d\xec\x23\x1e\x24\xf6\xee\xf6\x37\x78\x99\x7c\x7c\xcd\xbe\x06\x13\x97\x2d\xc1\x96\x10\x83\xc1\xcf\x64\xf2\x35\xfb\x49\xbe\x16\x26\x15\xe6\x33\xb9\xb0\x81\x71\xed\x59\x64\x76\xaa\x33\xb4\xd5\xe6\x18\xe9\x1a\xdb\x21\x69\x62\xa3\x5b\x8d\x61\x08\x88\xc6\x6e\x4c\x2a\x9d\xd4\x37\xae\x7f\x87\xac\xd8\x20\x35\x2d\xc4\xff\x45\xf5\x1a\xf2\x39\x11\x56\x6e\x07\x9d\x7a\x20\xf2\x25\x64\xf3\x2d\xd9\xda\x6f\xae\x3c\x7d\xc3\xe0\xba\x65\xca\xd2\xba\x30\xe9\xeb\x5f\xeb\xef\x79\x18\xf9\xab\xac\xbf\xac\xd8\x51\xb7\x89\x6c\x84\xad\x9d\x5b\xb7\x3c\xc1\x3b\x22\x21\x20\x42\x6a\xdb\x26\x38\x38\x30\x20\x20\x30\x31\x31\x36\x50\xd2\x34\x1c\x8b\xda\x8d\x0d\x60\x1e\xbb\x33\x13\x97\x1e\x1a\xf6\xd4\xb1\xf3\x20\x9d\x1c\x70\xea\xd8\x1f\xa2\x03\xdc\x3a\xd6\x71\x3f\x90\x13\xad\x71\x19\x59\xf0\x00\x7f\xe8\xce\x75\xaf\xa4\xb4\xf1\x59\x71\xfb\x03\x3b\x42\xdb\xaa\xc7\x96\x0b\x35\xef\xbb\xfb\xd0\x77\x41\xc3\x16\xbc\xa5\x5e\xc9\x55\x2f\xa9\x27\x39\x9c\xb1\x7a\x4f\xaf\xdd\x72\x7a\x67\xd7\x8c\xc5\x77\x3c\xb2\xec\x00\x7f\x1f\xb5\xfd\xed\xfe\xee\xb7\xab\xb7\x5d\xb8\x2b\xd3\x70\xf6\x48\x47\x31\xcf\x51\xf7\xb2\xa9\x90\x26\x55\x30\x3f\x16\xc6\x02\x36\x05\xb1\x37\xa1\x03\xf3\x67\x7a\x48\x13\xcb\x40\x62\x1e\x9b\x16\x14\xe8\xc7\x69\xab\xa5\xee\x5c\xa2\xd3\xd1\x62\xe9\xfc\xa2\xbe\xe7\xb2\xca\xec\xc3\xe7\xd6\x64\x4e\xbe\x2d\xa1\xcb\x90\xcc\x41\x3d\x73\x3b\x4a\x15\x8e\xbc\x03\x8f\x0c\x5e\x74\xeb\xd0\xcf\xef\xef\xef\x58\x5a\x71\x32\xbb\xb2\xbc\x2e\xa5\x84\xe6\xdc\x87\x59\x15\xb4\xc5\x38\xd1\xc8\xc2\x5f\x91\x65\x49\xb7\x15\x52\x5f\xf1\xc2\x29\xfd\x56\xe8\xc8\x72\xd0\x60\x39\xe9\x62\xdb\xcb\x78\x9c\x0c\xea\x73\x20\x1d\xa7\x24\xea\xe1\x88\x5d\x85\x47\xad\xdf\xfe\xe7\xb6\xad\x91\x55\x2b\xe0\xbd\x59\x0f\x2d\x70\x3c\xb2\x82\xb0\x9e\x47\xac\x51\xc8\x73\x38\x0b\xda\xec\x63\xf0\x17\x2c\x87\x62\xbe\x00\xca\x11\x5f\xf2\xc7\x67\x65\x66\x75\xe7\xda\x1e\xed\x89\x99\xce\xad\xdb\xc5\xce\x65\xd1\x7a\xf5\xf9\x56\x43\x76\x8f\xb7\xc5\x0c\x6f\xd7\x2d\xf0\x3f\x3d\x7e\xbc\xed\x96\x0e\x63\x6b\xd2\x8a\xa2\xa1\x22\xb2\x6a\xf6\xfc\x25\x37\x75\xee\x1c\xd5\xa3\x4d\x76\xcc\xae\xb2\x31\x19\x63\x87\xf5\xb7\xf6\x6a\xb3\x42\xd4\xf7\x26\xea\xa8\x37\xd6\x17\xc7\x5a\x6f\x89\x8d\x8b\x0b\xd6\xc9\xc6\xad\xd0\x61\x73\x58\x64\xf0\x56\xd2\x93\xeb\x29\x44\xc7\x0e\x52\x9a\xa8\x55\x9f\xe8\x3e\x10\x87\x4e\x63\x88\x75\xed\xa6\x84\x86\x4d\x82\x2c\xf3\xda\xbc\xa2\xa8\x17\x62\x1f\x9d\x73\xf3\xed\xf9\x83\xba\x75\x7e\xee\xce\x3b\x1e\x32\x6c\xd1\x77\xeb\xd4\x35\x7b\x4e\xbf\x08\x9e\x31\xad\x4f\x61\xeb\x19\x93\x8a\xf3\xfb\x15\x07\x9a\x07\xd8\xca\x6f\x9f\x51\x1c\x9c\x91\x98\xdd\x6e\xcc\x72\xb2\xd7\x8b\x28\xfb\x08\xd2\xa3\x2f\x4b\xb0\x79\xfb\xfa\x72\x26\xcb\x5e\x3e\x3e\x3a\xfe\x26\x2a\xc0\x9b\xe9\x20\xd5\xb5\xd8\xaa\x4d\xb4\xd1\x84\xfa\xd8\xac\xe8\x2c\x52\xaa\x04\xe9\x1f\x45\xbe\xd8\x5a\xbd\x27\x02\x1e\xff\x7a\xea\x8c\xc8\x6d\xaa\xfa\x5f\xd0\xaf\x5a\xb5\x00\x4e\xa8\xf1\x4b\xe1\x25\x75\x9f\x90\xf7\x05\x94\x57\xd4\x11\x8e\x35\x18\x75\x3a\x9f\xf0\x56\xb2\xec\x23\xa1\xa9\x52\x37\xfb\x5b\x7c\x5c\x32\x8b\x55\x85\x74\xd7\x4e\xa7\xa8\x5a\xe7\x1e\xcb\x62\x07\x2f\xa7\xac\xe8\xc4\xfa\xd8\xa7\xe0\xd7\x48\xf5\xf9\x36\x5d\xfa\x4e\x59\xf0\xc6\x9a\x8b\x09\x5b\x0c\xa9\x99\xb9\x03\x3b\xb7\xeb\x99\xfc\x92\x54\x74\xd7\x5d\xd1\xb5\xe5\xb7\x3f\xb6\x33\x3c\x39\x69\x60\xb7\xce\x1d\x3b\xa0\x7c\xbb\xb0\xee\x6c\xd4\x75\x30\x8b\x61\x31\x36\x83\x9f\x9f\xce\x6a\x32\x19\x7d\x74\xc2\xc8\x61\xc8\x5c\x9a\x66\x64\xb1\x36\x27\x6a\x4e\x14\x8e\x69\xa1\x2d\xbb\x45\x6d\x2e\x63\x27\xba\x8e\xa4\x42\x17\x48\x5f\x72\xdb\xa1\x67\x67\xde\xec\xfd\x9c\x7f\x8f\x05\xc9\xb9\x93\x8b\x66\x8f\x78\xe0\xc5\xb4\x0e\x99\x7d\x32\x13\x3a\x0f\x98\x7a\xef\xd2\xcf\x21\xbc\x28\x3f\x64\xe0\xfb\xdd\x2a\x26\x0d\x5d\x91\x77\x25\xbd\xcb\xa0\xde\x69\xc9\xf4\xbd\x87\xfa\x0e\xea\xda\x86\x7a\xf0\x61\xe6\xb7\xb0\x49\x74\xc4\x04\x13\xea\x4d\xcb\xa1\xdd\x22\xfc\xb8\x58\xb1\xc8\x8a\x56\x8f\xf3\xc2\xf0\x67\x96\x8d\x08\xfe\x6f\xf0\x98\x15\x0f\xab\x13\xa5\xa2\x7f\xbd\xba\xe9\xd9\xc2\xb2\x4d\x9b\x1f\x11\x6b\x09\x92\xfa\x06\xca\xd4\x4f\x9a\x89\x32\x45\xb3\x64\x16\x87\x3a\x35\x9b\xbd\x63\x42\x42\xbc\x23\xa8\xb9\xb5\x61\xde\xce\xe6\x66\xd6\xc4\x12\xf3\x72\xcd\x7d\x1a\x8e\xda\xca\xa2\x73\x2d\x02\xd2\xb4\xa3\x07\xb0\xa7\xf0\x3c\x78\x6b\xc0\xfc\xdb\x87\xf6\x2f\x7b\xf9\xe1\x65\xf7\x4e\x1e\xdf\x36\xf5\x89\xa9\x9d\xb2\xc6\x26\x77\x4f\xd6\xe5\xf4\x4c\xef\xdc\xb9\x4f\xa6\x34\xb3\x74\x64\xcf\x29\x81\xc9\xb3\xab\x96\x55\x4c\x19\x30\x35\xb4\xd5\xc8\xf4\xc9\x33\xd5\x3d\x37\x75\x18\x92\x9a\xd1\x26\x79\x41\x9f\xec\xb6\x19\x7d\xba\x24\x77\xa0\x75\x0f\x94\x79\x2a\xf4\x40\xfd\x8b\xd3\xf0\xe2\x6c\x06\xce\x8d\x72\x74\xb4\x25\x9c\x1c\x3e\x98\x59\xdc\x0e\x6f\x71\x5b\x20\x2d\xab\x61\x27\x36\x67\x5f\x81\x83\x05\x78\x1c\x65\x97\x5e\x9d\xd6\xa3\x68\x72\xf5\xd6\xe5\xf3\xee\xce\x2e\x5d\x3e\xba\x74\xb9\x65\x93\x19\x7c\x3b\xb6\xcb\x1e\x90\x81\x7e\x71\x61\x47\x76\xcd\xe4\x45\x1b\xef\xaa\x19\xb7\xf7\x81\x01\x13\x0b\xc3\x87\xc3\x23\x89\x59\x83\x07\x24\xa5\x0c\x11\xeb\x30\x15\xca\x16\xc9\x44\x6b\x64\xfe\xcc\xb2\x05\xfd\x41\x06\x1f\x5a\x4a\x4a\xd3\xf6\x72\x4e\xd7\x2b\xb1\x59\x21\xee\x1d\xb5\x78\xd6\x11\x49\xad\x9b\xcc\x87\xcb\xe5\x6f\xf0\xfa\x32\x19\x82\x3e\xd6\x27\xf9\xbc\x6c\x7c\x29\xf0\xd9\x67\x03\x9d\x7b\x01\xab\x07\x95\x2d\xb4\xb6\xa3\x61\xfa\xe8\x74\x5c\xf1\x33\x36\x60\x4a\x7a\x5a\xc4\xc1\x9e\x48\x43\x35\xf0\xc9\xef\x48\x47\xde\xff\xf8\x3f\x72\xd9\x5b\xbc\xae\x5c\xd6\xd5\x1a\x5f\xf6\x19\xa1\x5e\x12\x90\xb4\x56\x54\xa5\x6c\xe1\x9b\x10\xcf\x8c\x1e\x1a\x69\xf3\x0d\x0a\xf5\xc7\x1f\x9e\xa7\x07\x7d\x48\xa0\xb6\xa4\xa3\x3d\x9f\x40\x76\xa9\x77\x70\xb5\x14\xc4\x4e\x13\x2b\x46\x0a\x71\x9e\x9b\x91\xde\x5e\x9f\xd3\xb3\x67\xef\x11\x37\x29\xdd\xfc\x47\xf6\x42\x09\x54\x4d\x02\xdd\xc7\x11\x26\x5b\x60\x52\x42\xc7\x9e\x21\x43\x0e\xb8\x05\xe1\xea\x7f\x50\x8e\xc9\xb4\xf6\x17\x23\x56\x88\xc3\xa2\xa2\x2c\x06\xc6\x82\x14\x5f\x9b\x21\xa0\x9f\x6f\x44\x8c\xa8\x3b\x29\x8d\xb6\x37\x49\x27\xa7\x6a\x76\x9d\x8d\x96\xff\xd2\x51\x85\x0f\xc4\xf6\xed\x6d\x0b\x17\xfb\x9b\x84\x65\x0f\xbf\x29\xb1\x57\xb7\xac\xb0\x0e\x1d\xfc\x26\x44\xa6\xf6\x3d\xb5\x71\x8d\x74\x7e\xc7\xab\x7c\x8d\xae\x26\x38\x3c\x24\xa9\x4d\xde\x80\xb6\x21\xe1\xc1\xb1\xf1\xa3\x72\x62\x17\xf4\xf2\xb9\x7b\xa5\x51\xd3\xeb\x01\xe4\xa7\x37\xe9\x35\x40\xec\x27\x6c\x36\x1a\xd1\x5c\x79\x00\x62\x4b\x62\xe7\x52\x19\x2d\x39\x89\x6d\xaa\x42\x62\x12\xba\x41\xba\x73\x33\x45\x5d\xdf\x93\xd2\xaf\x4b\x79\xd6\x92\x7b\xa7\x4b\x93\x47\x8e\xa8\x8e\x9a\x5e\x88\x56\xbb\xcf\x78\x62\xe9\x0c\x9f\xdc\xac\xce\xbd\x7e\x6d\x19\x9f\x8b\xdd\x60\x1a\xe3\x93\xf9\xa4\x46\xf8\x45\x7c\xe9\x76\xe9\x44\x94\x07\xbe\xee\x21\xe3\x7d\x3e\xea\x0a\x8f\x0a\x1a\xf0\x7d\x59\xa4\xb0\xa3\x77\xb8\x17\x76\xad\xa6\xbc\x20\x08\x72\xed\x72\x65\xa6\x37\x5b\xd0\x45\x1a\xa1\x4b\x2e\xab\xa2\x51\xb1\x7f\x4f\x0b\xf7\xa8\x67\x4b\x27\x61\xd5\x1e\x77\x8c\xcd\x8b\x35\x8e\x50\xb6\xb8\xea\x83\x20\x61\xd2\xc1\x59\xb6\x2c\xac\xf7\x43\xac\xb7\x08\xeb\xf5\x46\x3b\xa6\xbd\x66\x90\xc3\x03\x7d\x7c\xb6\xd6\xbf\x63\xb3\x18\x7c\xfb\xc9\x3e\xb2\x8f\x3e\xca\x1c\x22\x4c\x1a\xa2\x27\x36\xd0\xa4\x66\x3a\x8f\xd3\x79\x42\x89\xc6\x0c\xed\xbb\xa5\x4b\x24\x13\x6b\x7b\xb4\x85\x38\x77\x36\xe3\xe1\xa5\x35\xa3\x7c\x96\xdb\x93\x46\x0d\x6a\x13\xdb\x33\xa7\x4b\xf8\xd0\xc8\xf1\x91\xd3\xc7\xa4\x8f\xc8\x8b\xe9\xd0\xde\x67\x42\x78\xc7\xc1\xca\x96\x92\x51\xde\xc3\x86\xbd\x7f\xdc\x1c\x64\xc9\x1e\x91\x1b\x11\x11\x1e\xd9\x3b\x3d\x8a\x74\x72\x5e\x5e\xcb\x4f\xe8\x12\x5a\x6e\x7f\x64\xcc\x86\xf6\xe7\x75\x44\xfa\xb1\x86\x8f\xd6\xad\x7d\x52\xfe\x65\x9d\x0e\x6c\xa7\x75\x09\xd8\xfc\xde\x88\x78\xe7\x9d\x08\xe8\x8e\x78\xd5\xf2\x5a\xf8\xcc\x8d\xf7\xbb\x6d\x6f\x3a\xaf\x79\x5e\x3a\xf2\xd5\xe9\xf7\x74\xeb\x5e\x90\x2e\xae\xd5\x29\x35\xd8\xf6\x92\xd5\x1d\x02\x8f\xda\x9e\x84\xfc\xbd\xae\x9b\xc3\x2c\x2c\x82\xc5\xdb\x82\x42\xc2\xc3\x83\x98\xbf\xc9\xdf\xea\x2f\xf9\x73\x7f\x7d\x6b\x3d\xd7\x87\x06\x21\xfc\x17\x05\x69\xef\x15\x68\x63\x74\xa3\x36\x48\xce\x9f\x29\x35\xf0\xdf\x3e\x37\x27\xcb\x38\x20\x7f\xe4\xd8\x91\xc3\xf4\xe3\x2d\x71\x7d\x72\x15\x92\x44\x41\x49\x94\x5f\x13\x03\x86\xb6\xea\x9c\xdc\xb9\xaf\x31\x61\xa2\xa4\xa8\x57\x9c\x42\x91\x9e\x46\xa1\x5c\xeb\xf4\x26\xb1\x4f\x23\x4b\x12\x6f\x71\x85\x07\x18\x71\x90\x36\xca\x51\xfe\xfe\xc1\xad\x83\x53\x83\xa5\x60\x2f\xd9\xc9\x48\xc3\x31\x54\x28\xb0\x5b\xd4\xe6\xf7\xd7\x9b\x71\xfa\x23\x65\xdd\x2b\xf2\xa5\xb5\x0a\xef\xd7\xa6\x7f\xcf\x6e\xe1\x6d\x3b\x06\x2d\x8e\x5b\x3c\xa1\xed\x80\x1e\x5d\xc2\xe2\x3b\x86\x2f\x8e\x5b\xa8\xec\x51\x7f\x88\x78\xe0\x81\x08\x18\x18\xdb\x36\x36\xad\xdb\xbd\xb5\xf8\x4f\x52\xee\xfd\xf3\x88\xaf\x87\x91\xaf\x49\x7a\x2b\xea\x3b\x90\xa1\x13\xf9\x99\x8d\xba\x25\x38\x26\x89\x16\x93\x9d\x1a\x66\xda\x93\x26\x78\x48\x0c\x88\x0e\xd1\x4b\xee\xfd\xdb\xa8\xe2\xf1\xca\x1d\xc0\xbd\x7e\x99\xba\xf2\x39\xfe\x44\xfe\xc0\xe1\xb3\x42\x36\xb6\xdb\xa1\xd3\x85\xb3\xfa\x84\x2b\xea\xc3\xab\x17\x24\xf4\x1f\x31\x74\xd0\xfa\xd5\x37\xd4\x11\x6a\xc3\xce\xc0\x4f\xc2\x7a\x96\x50\x25\x61\x7b\xc4\x39\x87\x14\x24\x24\x66\xdd\x58\x4b\x97\xab\x5e\xc0\x6f\x53\xec\x8d\x6b\xb9\x92\x50\x1f\xde\xa8\x12\x57\x1d\x49\x18\xa7\xc6\xb2\x68\x9b\xc5\xea\x65\xf1\x6f\xd5\xba\xd5\xca\x56\x52\x2b\x2f\x6f\x7f\x19\x64\x46\xdb\xbd\xa6\x53\x1b\xa5\x26\xe1\x59\x8b\x44\xa1\x48\x96\x2b\x2a\xd3\x8c\x9e\xe2\x59\x67\x44\x5f\x5b\x5a\x57\x43\x50\x59\xfb\xb9\x2b\xcb\xca\x7d\x1e\x0c\x49\x2b\x93\xd7\xba\xeb\x87\x1f\xc2\xc2\xbd\x4a\x65\x7d\x5f\x5b\xf7\x3c\xaf\xae\xf3\x25\xc5\xc9\xcf\x3a\x7d\x7b\xe4\x07\xa7\x6c\xb6\x10\x6b\xab\x97\xfd\xc1\xdf\x9f\xc5\x06\xfa\x87\xb7\x0e\xe7\xe1\xc4\x13\xf5\x1a\xc8\x95\x66\xf3\xd4\x82\xf7\xd2\x6f\xe0\x2c\xa0\x59\xa3\x37\x62\x2d\xb5\x05\xb3\x7b\x32\x78\x6b\x63\xcb\xe3\xbc\xb1\x43\xa3\x7d\x94\x13\xe4\x8b\x6f\x6a\xbb\x11\x1f\x44\x1b\xb1\x1b\xae\xeb\xc4\x75\x6d\xdf\xe4\x26\xfb\x35\xff\xc8\x4d\xd2\x80\x66\xf2\xcf\xf2\x44\x29\x49\xec\x31\xa9\x2e\x16\xfb\x08\x5b\x12\xbc\x2e\x53\xfe\xb7\x7c\x0a\xe1\x6c\x51\x17\x36\xca\xff\x81\x6f\x70\xe6\x6f\x6c\x94\xff\x3d\x7f\xa6\xb9\xbd\xc2\x7f\x7f\x6f\x6c\xa6\x53\x8d\xea\x62\x18\x54\xff\x83\xf3\xec\xde\x54\x76\x13\xcb\x61\x59\xb6\x88\xf0\xe8\x68\x9c\x11\xb2\x6c\xb0\x65\xaf\xcb\xe6\xd9\x89\x41\xfe\xfe\x89\x06\x49\x4a\xec\xde\x3d\x39\x51\x3c\xe6\x4b\xa5\xa3\xea\xf0\xd7\xb4\xbb\x60\x76\x5a\x5a\x6a\x9a\xe8\x15\x94\x4e\xee\xf8\x35\x21\xcb\x23\xad\xf7\x48\xc7\xb7\x90\xaf\x0f\x48\x97\x54\x63\x8a\x35\x26\x25\x25\xc6\x9a\x72\xc6\x95\x78\xd8\x95\xe0\xf9\xc9\x5a\x2a\x39\xc9\x95\xd8\x9b\x5d\x91\x3d\x59\x9c\xca\xab\x95\xa0\x7f\x5f\x72\xfe\x7b\xb9\xc9\xdf\x61\xd0\x17\x43\x48\x26\x3b\x1c\x28\x6f\x32\xca\x2b\xd1\xa9\x40\xad\xc5\x93\x36\x06\xa0\x6f\xdd\x1a\x87\x43\xb0\x85\xae\x0b\xe5\xa1\xfa\xa8\x28\x5f\x3d\x09\xe9\x14\x4e\x1b\x13\x95\xac\x68\xfd\x6f\x71\xef\x70\x04\x42\xbf\x20\x18\xe8\xe2\x27\xc9\x95\x10\x7c\x6e\x98\x39\xb3\x67\xf3\x2c\x79\xf0\xa4\xc7\x31\xb9\x35\x5a\x21\xc3\x16\xa1\xe3\xfc\x13\x8c\x7d\x96\x48\x92\x77\x6c\x6c\x08\x8b\x04\x5b\xe4\xba\x48\x1e\xe9\x1d\x13\x63\xf6\x6e\xc2\x5a\xd8\xee\x02\x6d\xa2\x9e\x85\x53\x14\x7d\xec\x6f\xf2\xa8\x8e\x0a\xae\x10\x5c\x4e\x0b\x81\xdd\xcd\xf2\xa9\x9e\xaf\x9a\x39\xb3\xea\xd5\x16\x58\x15\x67\xf1\xd5\x9f\x97\xbf\xd7\xe1\x3c\x97\xa5\x60\x20\x9f\x99\xc2\x13\xfd\x24\xbd\x4e\xb4\x3a\x9c\xda\xb2\x90\x28\xae\xf7\x93\x62\xb1\x41\x66\x75\x97\xb2\x24\xa6\xe8\xe3\xa4\x04\x3f\x7d\x74\x86\xb5\xdf\x82\xa2\xde\x16\x3f\xa5\xcd\xd0\x6e\x7d\xa6\x0f\x4e\x1f\x05\xdd\x2c\x31\x71\xdc\x12\x52\xf1\xf4\x91\xa5\x8b\x5f\x9f\x61\x0d\x6d\x35\x73\xcd\xff\x4d\xbd\x0a\x56\x5e\xd2\x46\xfd\x06\xbe\xe9\x3d\xa7\x74\x6c\x9b\x56\x83\xca\x6f\x1f\xd1\x73\xd6\xb0\x94\xd4\xe1\xd5\x52\x85\xfa\xef\xa8\xec\x25\xf7\x8d\x9c\xf1\xc6\xed\x83\x7a\x2f\xdd\x36\xa7\xe2\xf9\x65\x93\xa2\xa1\x0b\x0c\x9b\xf5\x7f\x03\x91\xaf\x51\xf5\xdf\xeb\xbd\x94\xf1\x68\x57\x0c\xc2\xc5\x23\x63\x10\x2b\x2d\xce\xb3\xfd\xb4\x94\x3e\x1a\xa7\x00\xb1\xda\xa6\xd3\xae\x7d\xff\x45\x7e\x24\x04\xeb\x4e\x5d\xeb\x13\xad\xfc\xdf\xb5\x73\xe3\x6f\x0f\x9b\x07\x21\x0b\xcc\x8b\xc6\xde\x19\x3e\x17\xc2\x9e\x0a\x0c\x50\x7f\x0c\xd2\x4b\x83\x57\x95\xde\x72\x8f\xdf\xa8\x27\xa6\x2d\xbf\x3f\x68\x09\x84\xdc\x6c\x91\xe4\x57\x9e\xb9\x5e\xf4\xc8\xad\x7c\x92\xe3\xb6\xf1\xc9\xb5\x0f\xdd\xc9\x27\xd4\xbd\x30\xc9\xee\x7d\x5b\xdb\x9a\xb1\xf3\x66\xff\xab\xf4\xbe\xe5\xb6\x62\x7e\xb7\xe3\xee\x71\x1d\x95\x5a\xd2\x1b\xf2\x27\x1f\x26\xfe\xac\x4e\xfe\x5a\x60\x4d\xcc\x53\x02\xe4\x57\xea\xca\xa3\xa5\x35\x8e\x36\xce\x93\xd0\x90\x13\x53\xb0\x7a\x25\x40\xd1\xce\x49\xf3\xd3\x2f\xc6\xfa\xd5\xe3\x8e\x17\x16\xb4\x5b\xba\xa1\x96\x4f\xac\x7b\x21\x6f\xb5\xe1\xc1\x30\x71\x4e\x5a\x68\x65\x04\x9d\xcb\x40\x2b\x59\x2c\xa0\x0f\xc3\x9e\x1b\xbb\x03\x83\xbe\x33\xd6\x1d\x57\xff\x2a\xd2\xae\xd8\x33\x48\xd2\x4d\x22\x2d\xe5\x12\xed\x4b\x74\x08\xd1\x31\x74\xb5\x00\x69\x20\x0b\xac\x2f\xc3\x19\xbb\x84\xf9\x71\x2c\x8b\xd2\xd9\x44\xbb\xd4\xaf\x44\xda\x55\xa4\xf5\xa7\x31\xdd\x16\xfd\x22\x12\xa9\x99\x68\x1c\xe6\xa4\xe2\x5d\x47\x91\x8a\xbb\x52\xf1\x2e\x91\xd3\x85\xa8\xb8\x2b\x15\xef\x2a\x63\xe9\x84\x9c\xce\xfc\xd5\x5f\x90\x9a\x89\xc6\x61\x7e\x06\xde\x75\x14\x69\x17\xa2\x82\xdb\x2c\xc4\x2f\x43\x6a\x42\x84\x2c\xac\x45\xa4\x23\x89\x46\x11\x8d\x23\x9a\x46\x25\x85\x44\x59\xac\x0f\xd1\x7e\x44\x07\x51\xfe\x70\x4a\x8f\xa2\xf4\x68\x4a\x8f\xa5\xf4\x38\x4a\x4f\x40\x9a\x8d\xb5\xe4\x22\x35\x51\xda\x4c\xe9\x48\x4a\x47\x11\x15\xb5\x64\x13\x7e\x36\x21\x67\x23\xb2\xa0\xc3\x89\x0a\xe4\x6c\xc2\xcc\x46\xb4\xa3\xac\x0b\xf1\xdc\x85\xd0\xba\x10\xcf\x5d\x08\xad\x0b\xa1\x75\x21\x2d\x75\x41\x34\x51\xb2\x1f\x51\xd1\x0f\x77\x41\x34\x91\x1e\x45\x74\x2c\x51\x81\xd6\x95\xf4\xd9\x95\x38\xec\x8a\x98\x65\x48\xcd\x94\x8e\x44\x9c\xae\x88\x29\x68\x1c\xe5\x0b\x0e\xbb\x12\x87\x5d\x89\xc3\xae\xc4\x61\x57\x36\x82\xe8\x48\xa2\x63\x89\xe6\x23\xed\xcf\xfa\x23\x72\x7f\xfd\x69\x16\xcf\x46\x21\xfe\x4a\xa4\x66\x41\x31\x67\x10\xcb\xa7\x9c\x7c\xca\x19\x87\xe9\x57\x91\x9a\x91\x4e\xa0\xf4\x04\x91\x96\x6e\x12\x76\x94\x6e\x92\x06\xd6\xaf\x40\x3a\x9c\xe8\xe8\xfa\x5c\xa4\x63\xea\x65\xa4\x63\x29\xa7\x80\xd2\x25\xf5\xef\x23\xad\x24\x5a\x8b\xd4\x86\x65\x5e\x44\x5a\x80\xb4\x87\xd4\x0b\x8c\x48\x73\xeb\x07\x20\xed\x5b\x5f\x8b\x74\x48\xfd\x4a\xa4\x13\x11\xbf\x87\x34\x99\x68\x21\xd1\x22\xa2\xa5\x44\xcb\x89\x4e\x27\x3a\x83\x68\x05\xd1\xd9\x44\xe7\x10\x9d\x4f\xf4\x16\x76\x2b\xd2\x45\x98\xce\x25\x9e\x73\x89\xe7\x5c\xe2\x39\x97\x78\xce\x25\x9e\x73\x89\xe7\x5c\xe2\x39\x97\x78\xce\x25\x9e\x73\x89\xe7\x5c\xe1\xf3\x52\x1f\xd4\x40\x6b\xa4\x66\x41\x89\xf3\x3e\xc8\xf9\x10\xa4\x7d\x89\x0e\x21\x3a\xbd\xfe\x28\x52\x51\x6f\x5f\xaa\xb1\x2f\xd6\x78\x10\xe9\x70\xa2\xa2\xc6\xbe\x54\x63\x5f\xaa\x6b\x20\x22\xec\x44\x2a\x74\x32\x90\x74\x32\x18\xcb\xcf\x44\x3a\x9c\xe8\x58\xa2\x13\xeb\x8f\x20\x2d\x22\x5a\x4a\xb4\x8c\xe8\x34\xa2\xb3\x88\xce\x26\x3a\x87\xe8\x7c\xa2\x0b\x88\x2e\x22\xba\x04\xe9\x10\xe2\x67\x08\xf1\x33\x84\xf8\x19\x42\xfc\x0c\x21\x7e\x86\x10\x3f\xc3\x89\x9f\xe1\xc4\xcf\x70\xe2\x67\x24\xb6\xd6\x6b\x48\xcd\x82\xe2\xd5\x32\xa4\x7d\x89\x0e\x41\x3a\x4a\x9a\x5b\xbf\x57\x1a\x2d\x3c\x1f\x29\xb6\x56\xa4\x66\x4a\x47\x12\x8d\x12\x14\x75\x15\x8a\x34\x97\xd2\x7d\xeb\x37\x22\x1d\x88\x5a\x1a\x8d\x08\x22\x3d\x9c\xd2\x63\x89\x8e\x27\x2a\xac\x3f\x5a\x9a\x44\xb4\x88\x68\x49\xfd\x87\x48\x4b\x29\x3d\x95\x68\x39\x95\x9c\x4e\xb4\x82\x68\x25\xe5\xcf\x26\x3a\x87\xe8\x3c\xca\x9f\x4f\xe9\x5a\xa2\x37\x13\x8e\xb0\xce\x68\x69\x21\x5d\x5d\x44\xf9\x8b\x31\x3d\x06\xa5\xe8\x83\x14\xdb\x1a\x52\x33\xa5\xb1\xad\x21\x8d\x12\x94\x2c\x3e\x86\x7c\x75\x0c\xf9\xea\x18\xf2\xd5\x31\xc4\xed\x18\xf2\xd5\x31\xe4\xab\x63\x88\xe7\x31\xc8\xf3\x41\xa4\xa5\x94\x2e\x27\x3a\x9d\xe8\x0c\xa2\x15\x44\x67\x13\x9d\x43\x74\x3e\x51\xc1\xdb\x18\xe2\x6a\x2c\xd9\x62\x2c\xda\xe2\x5e\xa4\x05\x48\xf3\xd1\xa6\xdb\x90\x2e\x41\x3a\x0e\xeb\xfd\x0c\x69\x11\xd1\x52\x2c\x39\x0e\xfd\xe1\x18\xd2\xd9\x94\x33\x87\xe8\x7c\xa2\x0b\x88\x2e\x22\xba\x04\xe9\x78\xb2\xef\x78\xb2\x6f\x01\xc9\x55\x40\x72\x15\x90\x5c\x05\x24\x57\x01\xc9\x55\x40\x72\x15\x90\x5c\x05\x24\x57\x01\x49\x54\x40\x12\x15\x90\x44\x05\x24\x51\x01\x49\x54\x40\x12\x15\x90\x44\x05\x24\x51\x01\x49\x54\x40\x12\x95\xa2\x4e\x8e\x22\xad\x42\x3e\x4b\xd1\x22\x3b\xa5\x32\xac\x25\x16\xe9\xe4\xfa\xcd\x48\x8b\x28\x5d\x42\xf9\xa5\xf5\x5b\x90\x96\x53\xfe\x34\xd4\x64\x19\xd6\x25\xd2\x33\x88\x56\x52\x99\xd9\x54\xbe\x8a\xd2\x73\x28\x3d\x97\xd2\xf3\x29\xbd\x80\xe8\x22\xa2\x4b\x90\xce\xc0\xba\x36\x23\x2d\x22\x5a\x4a\xb4\x8c\xe8\x34\xa2\xb3\x88\xce\x26\x5a\x43\x74\x0e\xd1\xf9\x44\x17\x10\x5d\x44\x74\x09\xd2\x99\x88\x76\x0a\xe9\x14\x6c\x59\x33\x11\x53\xa4\x4b\x89\x96\x11\x9d\x45\x74\x36\xd1\x1a\xa2\x73\x88\xce\xa3\xf2\xf3\x29\xbd\x80\xe8\x42\xca\x59\x44\xe9\xc5\x94\x5e\x82\xe9\x59\x88\x7f\x10\x69\x11\xd1\x52\xa2\x65\x44\x67\x11\x9d\x4d\xb4\x86\xe8\x1c\xa2\xf3\x89\x2e\x42\x3a\x9b\xf4\x3c\x9b\xf4\x3c\x1b\x75\x22\xa8\xd0\x76\x95\x34\x9f\x45\x22\x5d\x40\x74\x09\xd2\x6a\x2a\x53\x4d\x57\xe7\xd2\xd5\xb9\x74\x75\x2e\x5d\x9d\x4f\x38\xf3\xa5\x99\x78\x75\x3e\x95\x9c\x4f\x25\x6b\x49\xf6\x5a\x92\xba\x96\xa4\xae\x25\xa9\x6b\x49\xde\x5a\x92\xb7\x96\xe4\xad\x25\x49\x6b\x49\xd2\x5a\x92\xb1\x96\xa4\x5b\x40\xc8\x0b\x08\x73\x01\x61\x2e\xa2\x9c\x45\x94\xb3\x88\x72\x96\x50\xce\x12\xca\x59\x42\x39\xaf\x62\x0b\x4d\x47\x6a\x46\xba\x0d\xfb\xe4\x74\xe9\x4d\xa2\xdb\xa5\xf7\xd9\x20\xa4\xbb\xd0\x2e\xdb\xa5\xdd\x2c\x14\xe9\xde\xfa\x47\x90\x7e\x52\xbf\x07\xe9\x3e\x4a\xef\xaf\xef\x88\xf4\x40\xfd\x62\xa4\x07\x89\x1e\xa6\xfc\x2f\x89\x9e\xa0\xbb\x4e\x52\xf9\xaf\x89\x5e\x20\x7a\x89\xe8\x15\xa2\x3f\x09\x8a\x35\x96\x4a\x3b\xa4\xed\x58\xd7\x0e\xac\x37\x14\xe9\xce\xfa\x33\x48\x77\x11\xdd\x4d\x39\x7b\x29\xbd\x8f\xe8\x7e\x2a\x79\x00\xef\xdd\x81\xf5\x7e\x8c\xf4\x10\xe5\x1f\x26\x7a\x14\x6b\xdf\x81\x3c\x88\xab\x5f\x11\x3d\x4f\x08\x57\xc4\x55\x9c\xa1\x87\x4a\xef\x52\x5d\xef\x62\x2d\x7b\x90\xee\x22\xba\x97\xe8\x3e\xa2\xfb\x51\x96\x77\x49\xae\x77\x11\x5f\x94\x3c\x44\xf4\x28\xe5\x7c\x45\x65\x04\xda\xbb\xd2\x55\xa2\xbf\xe0\xd5\xf7\x50\x93\x8b\x91\x9a\x05\x45\xfc\xd5\x48\xdf\xc7\x92\xef\x91\x14\xef\x49\xbb\x89\xee\x25\xfa\x15\xd1\x13\x44\x4f\x51\xc9\x33\x94\xfe\x1a\x39\x7f\x4f\xfa\x56\xa0\x49\xe7\x89\x7e\x4f\x08\x3f\x10\xbd\x40\x57\x2f\x52\xfa\x0a\xd1\x3a\xa2\x0e\xa2\xf5\x82\xca\x0c\xe9\xfb\xc8\xf3\x19\xa4\x87\x59\x3a\xd2\xb3\x28\xef\xfb\xd2\x15\x4c\x7f\x40\x9c\x7c\x40\xfa\xfc\x40\xba\x84\x74\x27\xe5\xec\x24\xae\x76\x92\x6e\x77\xe2\x5d\x83\x90\x1e\xa5\xab\x27\x88\x7e\x4d\xf9\x17\x88\x0a\xa9\x77\x91\xde\x76\x91\xc6\x76\x91\xc6\x76\x91\x45\x76\xa1\xc6\x04\x3d\x48\x39\xa2\xf6\x5d\xa4\xab\x5d\x24\xdd\x2e\xb2\xc2\xc7\x54\xd7\xc7\x54\xd7\xc7\xd2\x7e\xca\x11\x1a\xfe\x18\xcb\x97\x22\xfd\x9a\xd2\x67\xf1\xae\x8f\xb1\x46\x91\xbe\x44\xf4\x0a\x95\x57\x31\x7f\x37\x49\xb7\x9b\x78\xdb\x8d\x72\x85\x4a\x7b\x88\xe7\x3d\x94\xb3\xc7\x99\xf3\x0b\x96\xd9\x4b\x56\xde\x8b\x56\x10\xe9\x9d\x94\xde\x4d\x69\x61\xd9\xbd\x68\xd3\x3d\x48\x05\x9f\x7b\x89\xcf\xbd\xd2\xf7\x78\xef\x5e\xf2\x90\x4f\xd1\x9a\x0c\xa9\x99\x68\x24\xde\xf5\x29\x8e\x59\x82\x2e\xc4\x92\x9f\x22\xf2\x62\xa4\xef\x23\xe6\xa7\x84\xfc\x29\xb5\x94\x4f\x11\x5f\x5c\xdd\x4f\xe9\x03\x44\x0f\x11\xfd\x8a\xf2\x85\x1e\x3e\x25\x7d\x7e\x4a\xfa\xdc\x87\x38\x7b\x90\xee\x22\x2a\xee\xda\x47\x77\xed\x23\x7f\xde\x87\xbc\x85\x22\x15\xfe\xbc\x8f\xfc\x79\x1f\xca\x98\x8e\xf4\x1b\xca\x3f\x4b\x54\x48\xba\x1f\xb9\xdd\x8c\xd4\x2c\x28\x49\xbd\x5f\xda\x89\x25\xf7\x4b\x7b\xb0\xcc\x7e\xd2\xf9\x7e\xd2\xdb\x7e\xe9\x4b\xca\x39\x45\x65\xbe\x26\xfa\x2d\xd1\x73\x88\xbf\x1f\xbd\x4e\xd0\xef\x89\x5e\xa0\xfc\x1f\xe9\xae\x8b\x94\x73\x89\x72\xae\x50\xfa\x2a\xd1\x6b\x44\xeb\xa8\x8c\x83\x68\xbd\xa0\xe8\x87\x67\xa4\x03\xc8\x55\x29\x52\x33\xd1\x48\x2c\x79\x00\x75\x88\x14\x39\xc4\x1c\xd2\xde\x01\xf2\xc0\x03\x64\x97\x03\xc4\xe7\x01\xf2\x87\x03\x28\xaf\x48\x7f\x45\xf4\x24\xdd\x75\x0a\xf5\x70\x40\x3a\x4d\x57\xcf\x50\xce\xd7\x94\xf3\x0d\x95\x39\x4b\xf9\xdf\x12\xfd\x8e\xae\x9e\x23\x7a\x9e\x72\xbe\xa7\xf4\x0f\x44\x2f\xa0\xed\x0e\xa0\x5c\x22\x7d\x91\xe8\x25\xc2\xb9\x4a\xe9\x9f\x89\xfe\x4a\xf4\x1a\x51\xd1\xb2\x0e\x50\xcb\x3a\x48\xba\x3d\x48\xed\xfa\x20\xd9\xfa\x20\x69\xf8\x20\xf5\x18\x07\xc9\xaf\x0e\x92\x47\x1d\x44\xce\x45\xc9\xf3\xc8\xdb\x21\x69\x17\x96\x39\x44\xd2\x1d\x22\xcf\x3f\x44\x6d\xe4\x10\xc9\x78\x88\xf4\x7c\x88\x3c\xfc\x33\xb2\xef\xe7\x4e\x2a\xda\xec\x51\xf2\x9c\xa3\xd4\x27\x1f\x23\x6f\x39\x46\xad\xef\x18\xf9\xcc\x31\x69\x0f\xde\x75\x0c\x91\x37\x23\xdd\x47\x74\x3f\x95\x3c\x44\x57\x0f\x53\xce\x97\x44\x05\x3f\xc7\x10\x67\x90\xf4\x25\xb5\x88\x2f\x09\xe7\x4b\xc2\xf9\x92\x64\xf9\x92\xee\xfa\x92\x4a\x1e\x27\x49\x8f\x53\x99\xe3\x88\xb9\x1a\xa9\xf0\xc9\xe3\xe4\x93\x27\xa8\x2d\x9f\x20\x9e\x4f\x50\xef\x77\x02\xdb\xe6\x19\xe9\x24\xd9\xe2\x24\xda\x42\xd0\xf3\x44\xbf\x27\x2a\x7c\xe6\x24\x69\xf8\x24\x95\x3f\x29\x5d\x47\xcc\x93\x74\xd7\x29\xea\x09\x4f\x91\x95\x4f\x91\x65\x4f\xd1\x78\x71\x8a\xd0\x4e\x11\xda\x29\xb2\xe0\x29\x1a\x41\x4e\xd1\x08\x72\x4a\xba\x4c\xf9\x57\x10\xed\x14\x8d\x23\xa7\x10\xf9\x11\xa4\xd7\xd1\x0a\xa7\xc8\x03\x4f\xa3\x07\x0a\x6a\x16\x94\x6a\x39\x8d\xf8\x9b\x91\x0a\xfc\xd3\xd4\xcf\x9c\x26\xe4\xd3\x84\x7c\x9a\x90\x4f\xd3\xbd\x67\xa8\xde\xaf\xa9\x57\xf9\x5a\x3a\x49\xf4\x0c\xd1\x6f\x28\xff\x3c\xa5\x2f\x10\xbd\x44\xf4\x0a\xe5\xff\x44\xe9\xab\x94\xfe\x05\xd1\xbe\x21\x84\x6f\x08\xe1\x1b\xea\x9d\xbe\xa1\x36\xfb\x8d\x74\x1d\xd3\x67\x51\x6a\xac\x89\x7a\x86\xb3\xd4\x33\x9c\xa5\x7a\xcf\x92\xde\xce\x52\x2f\x71\x16\xb9\x12\x54\x48\x7a\x16\x25\x15\x69\x21\xe9\x59\x94\xf4\x11\xe9\x1c\xe1\x9f\x23\xfc\x73\xc8\x55\x3a\xd2\x2b\x94\x16\xb5\x9c\x93\x54\x4c\x9f\xa7\x5a\xce\x13\xfe\x79\xc2\x3c\x4f\x98\xe7\x89\xe7\xf3\x84\x79\x9e\xb8\xfd\x9e\x6a\xbf\x40\x98\x17\x48\xd2\x0b\x64\xbb\x0b\x64\xbb\x0b\x54\xef\x05\xb2\xda\x45\xba\x7a\x91\xca\x5f\x24\x5b\x5f\x24\x9e\x2f\x62\xf9\x8f\x91\x8a\xf2\x17\xa9\xfc\x45\x2a\x7f\x89\xca\x5f\xa2\xf2\x97\xa8\xde\x4b\x54\xef\x25\xd2\xd5\x25\xf2\x8a\x4b\x28\xd1\x1e\xe9\x32\x59\xed\x32\x59\xed\x32\x69\xe6\x32\x71\x7e\x99\x10\x2e\x93\xd5\x2e\x53\x8d\x97\xa9\xc6\xcb\x24\xd1\x65\x92\xe8\x32\x71\x7b\x99\x46\x8a\x2b\xd4\x2b\x5e\xa1\x5e\xf1\x0a\xe9\xe7\x0a\xf5\x9c\x57\xa8\xe7\xbc\x22\x5d\x15\x94\x7a\xfb\x9f\xe8\xae\x9f\x88\x87\xab\xe4\x27\x57\x49\x63\x57\xc9\x4f\xae\x12\xcf\x57\xc9\x43\xae\x92\x87\x5c\x25\x7f\xbb\x4a\x1a\xbb\x4a\xd2\xfd\x4c\x77\xfd\x4c\x3d\xea\xcf\x54\xfe\x67\x6a\xd7\x3f\x53\x9f\xf9\x33\xc9\x7b\x8d\xd0\xae\x11\x8e\x03\xbd\x57\xd0\x5f\xb0\xb5\xaa\x54\x97\x4a\x32\xaa\x24\xa3\x4a\x08\x2a\x79\xa6\x4a\xd2\xa9\x24\x9d\x4a\x1a\x53\x49\xb7\xf5\x74\x57\x3d\xe9\xa7\x9e\xee\xad\xc7\x7b\x45\xfe\x79\x4a\x7f\x4f\xf4\x02\xd1\x4b\x44\x2f\x13\xfd\x89\xa8\x86\xf0\x0b\xb6\x94\x7a\xa1\x2b\xd9\x5f\xe8\x0a\xa9\x99\x28\x8e\x77\x48\x71\xbc\x93\x7b\x60\xfe\x1e\xa4\xe6\xfa\x3d\xfa\x53\xfa\x53\xf5\xaf\xea\x4f\x8b\x39\x2f\xd2\xd1\xf5\xd8\x2b\xb1\x31\x2c\x5e\x7f\x1a\x7b\x95\x57\xf5\xdf\x4a\xaf\xd4\x87\x22\x7d\xab\x9e\x21\xdd\x4f\xe9\xc3\xf5\x8b\x91\x1e\xad\x4f\xa7\xb5\xb4\x28\xa8\x10\xeb\x69\xf4\xdf\x68\xf6\xa2\x33\x0d\xcc\x1f\xe2\x9d\x69\xce\xbc\x61\xb0\x33\x2d\xb1\x30\x58\xe9\x4c\xcb\x2c\x1c\x4e\x3a\xd3\x0a\xf3\xe3\x11\xce\xb4\x8e\x85\xf2\x49\xce\xb4\x9e\xdd\x2c\x55\x3a\xd3\x5e\x2c\x50\x0e\x74\xa6\x0d\xcc\x4f\xee\xeb\x4c\x1b\xa1\x5c\xdf\xce\x99\xf6\x66\x11\x5e\xff\x73\xa6\x7d\x58\x8a\xa1\xbf\x33\xed\xcb\x32\x0c\xa7\x9d\x69\x3f\x16\x66\x1c\x8a\x9c\x80\x38\xa0\x8c\x3d\x4f\x5c\x89\x34\xa0\x2c\x8a\x33\xcd\x59\x30\x64\x38\xd3\x12\xeb\x04\xf9\xce\xb4\xcc\x32\xe1\x39\x67\x5a\x61\x11\xa0\x3a\xd3\x3a\x96\xc6\x93\x9c\x69\x3d\xbb\xc2\x6b\x9d\x69\x2f\xd6\x46\xfa\xce\x99\x36\xb0\x08\x3a\xc7\x56\xa4\x8d\x7c\x9f\x3c\xda\x99\xf6\x66\x9d\xbd\x1e\x70\xa6\x7d\xd8\x04\xaf\x73\xce\xb4\x2f\x9b\x66\x98\xef\x4c\xfb\xb1\x4e\xc6\x30\x96\xcb\xca\xd9\x54\xfc\xad\xc1\xdf\x9b\x59\x09\x2b\x66\x56\xfc\x2d\xc4\xbf\x0b\x31\x55\xc4\x2a\xd9\x2c\x56\xcb\xaa\xa8\x54\x19\xe6\x5a\x59\x1b\xcc\x6d\x8b\xff\xa6\xb1\x0e\xac\x23\xfe\x5a\x59\x5f\x2c\x55\x89\xd7\x67\xe0\xfd\x56\xd6\x0b\xd3\x55\x78\x97\xa0\x85\x84\x5b\xc9\x2a\x58\x0a\x33\xd2\x95\xdf\x46\x4b\xc3\xd4\x70\x27\x17\xfd\xe8\xee\xf6\x98\xea\x8f\xf7\x17\x89\x35\xf0\xdc\xf2\xa9\xe5\x35\xe5\x37\x97\x14\x5b\x8b\x0b\x6b\x0a\xad\x45\x95\xb3\x6a\xab\xca\xa7\x96\xd5\x58\xdb\x14\xb5\xb5\xa6\x75\xe8\xd8\xc1\xda\xb7\xb2\x72\xea\x8c\x12\x6b\xaf\xca\xaa\x59\x95\x55\x85\x35\xe5\x95\x15\x29\xc6\x5e\x4d\x8b\xa5\x59\x87\x23\x44\xbf\xc2\x9a\xf6\xd6\xfe\x15\x45\x88\x3b\x08\x19\x9a\x82\xd5\x7a\x32\x6c\x65\x23\xf0\xaf\x0a\x56\x8d\x97\xcb\xa7\x94\x68\x60\xd6\x11\x85\x15\x98\xd1\x13\x4b\xcc\x20\x26\xfb\x93\xa2\x66\xe0\x3d\x45\x98\x5d\x39\xa3\xd8\xda\xbf\xa6\x70\x46\x39\xfe\xd1\x03\xef\x2c\x42\xcc\x0a\x2c\x27\x90\xad\x2c\x19\x7f\x7f\xa7\xa6\x1e\xd5\x45\x25\x15\xc5\x25\x55\xd6\x64\xeb\x0d\x95\xfe\xf6\xad\xd6\x96\x98\x6a\x82\x63\x6d\xc4\xe4\x68\xc2\xab\x76\xa3\xa5\xa1\x96\x3b\xe0\x4f\x0a\xda\x82\x8d\x2e\xa9\xaa\x16\xb7\xa5\xa5\x74\xe8\x90\xd2\xb1\x79\x06\x5c\xd5\x27\xbb\xab\x6f\xa1\x72\x51\x77\xb2\xa8\xdb\x55\x75\xf3\xe2\x94\x93\x28\xc2\xf5\x6a\xe8\x8a\xd0\xdd\x4c\xfc\xb7\x8a\x4d\xc7\xbc\x4a\x56\xfa\x9b\x0e\x62\xc5\x72\x25\xe4\xce\xd5\x78\xa5\x84\xfe\x2a\x26\x54\x81\x3d\x0a\x4b\x8c\xa0\x52\x43\xe9\x4e\x61\x9b\x1a\xaa\xad\x82\x4a\x8d\x6c\xa6\xc6\x3c\xac\xb1\x94\x64\x29\xf1\x28\x59\x44\xd8\x42\x4e\x0d\xb9\x12\xd3\x65\x4e\x2b\x4f\x63\x73\xc8\xc1\xab\xb1\xa4\xb8\xcf\x25\x5b\xb5\x70\x60\x0f\x63\x94\x57\x5b\x0b\xad\x35\x55\x85\xc5\x25\x33\x0b\xab\xa6\x5b\x2b\x4b\x1b\x3b\xa5\xb5\xaa\x64\x6a\x79\x75\x4d\x49\x15\x66\x96\x57\x58\x47\xa5\x8c\x48\xb1\x0e\x2d\xac\x29\xa9\xa8\xb1\x16\x56\x14\x5b\x47\xba\x6f\xcc\x2b\x2d\x2d\x2f\x2a\xa1\xcc\xa2\x92\xaa\x9a\x42\x2c\x5c\x59\x53\x86\x2e\x34\x6d\x4e\x55\x79\x75\x71\x79\x91\xa8\xad\x3a\xa5\x39\x87\x6c\xbe\xa5\x36\x38\xa1\x47\x2b\x62\xa8\x39\xa1\xb1\xb9\xa4\x87\xc1\x54\x5c\xfc\x5d\xad\xdd\x32\xa2\xa6\x64\x6e\x89\x75\x70\x61\x4d\x4d\x49\xb5\x28\xdc\x13\x0b\x54\x3b\x95\xaf\x19\xb6\x07\x29\x65\x26\xfe\x25\x0c\x36\x0f\xd5\x25\x94\x53\x46\xe9\x42\x32\x7a\x31\xc1\x89\x9e\xa1\xc2\x79\xe7\x14\xec\x2b\xac\xbf\x59\xb1\xd5\x79\x6f\xa1\xd3\x79\x2a\xf0\xa7\x12\xcb\x6a\xd2\x88\x7b\xda\x3b\x9d\xa2\x94\x68\x35\xd5\x5b\x81\x75\x58\x31\xed\x6a\x39\xd5\xa4\x8f\x72\x72\x2e\x4f\x2e\xac\x64\xd6\x42\x72\x12\xcd\x31\x67\xe2\xd5\x1a\x2a\x5b\x44\x4e\x3e\x83\x38\x14\xbd\xe4\x4c\xd4\xa3\x56\xeb\x14\x67\x3f\x38\x8f\x7a\xd5\x32\xb7\xec\x58\x3e\x3a\x86\xdc\xaf\x41\x17\x9a\x4b\x97\x3a\x5b\xa1\x95\x72\x67\x61\xba\x92\x78\x77\x69\x2f\x99\x2c\x27\xf8\x2f\x21\xae\x44\xaa\x90\x7a\xe9\x29\x78\xc7\x0c\xaa\x47\xe3\xa3\x8c\x1c\xb7\x90\xdc\xae\xc4\xe9\x86\x35\xc4\x6d\xb5\x87\xfb\x6a\xce\x6a\x25\x8e\x05\x7a\x6f\x72\x59\xd1\x37\x97\x38\x35\x39\x06\xfb\xf4\x41\xcd\x22\x6a\xda\xf2\x6c\x36\xd5\xd4\xf0\xe7\x92\xde\x1a\xb0\x2b\x88\xdb\x62\xca\xab\x74\x6b\x56\x94\x9a\xe1\xac\x49\x93\x78\x06\x8d\x1d\xd3\xdd\x56\x29\x25\x6f\xd4\xb4\x57\x4c\x68\xc9\x2d\xe8\xb7\x94\x74\x53\xe3\xac\xb5\x92\x38\x2a\xc6\x1f\xcd\xce\x9a\x47\x55\xe2\xbd\x73\xc8\x6a\x5a\x53\xd7\x7c\xbd\xe6\x06\xcd\x15\x92\x7e\x2b\x9d\xf7\xcd\xc2\x2b\xa2\x2e\x8d\x97\x99\x5a\xd3\xed\x59\x58\x8d\x4d\x11\x1b\x6e\x8f\xaa\xf2\x99\x95\xed\xad\xf3\xca\xca\x8b\xca\xac\xf3\x0a\xab\xad\xc5\x25\xd5\xe5\x53\x2b\xf0\xe2\x94\x5a\x6b\xe3\x86\x60\xc5\xab\x85\xd8\xd4\x2b\x2a\x2a\xe7\x62\x33\x9a\x5b\xd2\x1e\x9b\x75\x69\x55\x49\x75\x59\x79\xc5\x54\x6b\xb5\xe8\x8e\xab\x4b\xaa\xca\x4b\x9d\x10\xd6\x9a\xb2\xc2\x1a\xd1\x31\xcc\x2c\xa9\xa9\x2a\x2f\x2a\x9c\x31\xa3\x16\xc7\xb8\x99\xb3\xf0\xd6\x29\x38\xa8\xcd\x2b\xaf\x29\x13\xb5\x17\xce\x78\x2e\x45\xe3\x02\x7b\x8d\x52\xec\xa4\xad\xe5\x33\x67\x55\x55\xce\x25\xf6\x92\xab\x8b\xaa\x4a\x4a\x2a\xb0\x9e\xc2\xe2\xc2\x29\xe5\x33\xca\x6b\x10\xa3\xac\xb0\xaa\xb0\x08\xfb\x12\xec\x50\xca\x8b\xaa\xa9\xaf\xc0\x2e\xc2\x3a\xab\xb0\x22\xb9\xf7\x9c\xaa\xca\x59\x25\xc8\xe4\x98\xbe\x83\x1a\x0a\x22\x5b\x5a\x3f\x53\x5d\x39\x63\x6e\x49\x35\x95\xae\x28\x29\x29\xae\x16\xfd\x54\x31\x8a\x38\x03\x6f\xc2\x8a\x67\x54\x56\x4e\x17\xa2\x94\x56\x56\x21\x7b\xc5\x35\x65\xc9\x1e\xfc\x96\x56\x56\xd4\xe0\xad\x95\xd6\xc2\xe2\x62\x94\x19\x15\x55\x59\x34\x67\xa6\xe8\xc1\xb0\x57\xa9\x71\x31\x57\x58\x54\x55\x89\xd7\x66\xcd\x28\xac\x41\x94\x99\xa2\xa7\x2a\xa3\x36\x3e\x8b\x75\x61\xa9\xf8\x33\x8f\x7e\x52\xa8\xa5\x7b\xf6\x5f\x45\xce\xde\x2b\xc5\xe9\x1f\xa9\x78\x63\x4d\xcd\xac\x2e\xa9\xa9\xf3\xe6\xcd\x4b\x29\x74\x76\x62\x45\xd8\x87\xa5\x20\x53\xa9\x7f\x1d\x56\xb8\xc8\x2c\x72\x66\xcf\x0e\xaa\x8a\xdc\x42\x60\xce\x44\x77\xf9\xcd\xaa\x6b\x6a\x67\x95\x38\x9d\xa4\xaa\x3a\xa5\xac\x66\xe6\x0c\x6d\xf8\xd3\xaa\x75\xf5\x93\x73\x3c\x7a\x66\x57\x2b\x1a\x81\x43\xdb\x20\x1a\x86\x66\x39\xdb\x7e\x1f\xa7\xd7\x5b\x9b\x20\x88\x7e\xae\xe9\x68\xde\x51\x1b\xc7\x07\xe1\xf8\x50\x21\x9c\x77\x0e\xf5\xea\xc2\x96\x23\xfa\x0f\xb2\xe6\xcd\x42\x37\xe9\x83\x36\xb2\x3a\x0b\xb4\xb7\xba\x46\xfc\x8e\x62\xb8\x6f\xac\x2e\xad\x07\x2a\xc7\xbf\x6b\x48\xf0\x6a\x6a\x3f\x29\xa4\xac\xa9\x78\x3d\x0f\x39\x1b\xe4\x56\x03\x3a\x61\xf9\xac\x9a\xea\x94\xea\xf2\x19\x29\x95\x55\x53\x53\xf3\xfa\x0c\x72\xc6\xed\x4c\x9c\x50\x5e\x9f\xc8\x3e\x63\xcd\xfc\x67\x8c\xa4\x38\x9f\x63\x84\x2a\x63\x2c\xac\xc3\xb8\xd7\x0b\x63\x5c\x23\xc6\xb3\x3e\x18\xbb\xfa\x31\x7f\x66\x62\x66\x66\x61\x01\x2c\x90\x05\xb1\x60\x16\xc2\x5a\xb1\x50\x16\xc6\xc2\xc5\x69\x79\x2c\x8a\xb5\x46\xa9\xa3\xc5\xdb\xa5\x2c\x8e\xc5\xb3\x04\x96\x88\xf1\x65\x5b\xd6\x8e\x25\xa1\x7e\x92\x91\xdb\x54\x67\x94\x99\xce\x3a\xb1\x0c\x96\xc9\xb2\x58\x67\x96\x8d\x12\xde\xc4\xba\xb2\x6e\xac\x3b\xcb\x61\x36\xec\x9d\x7b\xe2\xc8\x98\x8b\xbd\x62\x1f\xec\x05\xfb\xa1\x05\x06\xb0\x81\x28\xdb\x60\x36\x04\xa5\x1c\xca\x86\x61\x00\x32\x02\x83\x85\x51\xa8\xef\x31\x6c\x2c\xcb\x67\xe3\xd8\x78\x36\x81\x15\xb0\x89\x6c\x12\x9b\xcc\x0a\x81\xb3\x27\xd8\x32\x76\x1b\x7b\x9b\x3d\xc8\xce\xb2\xdb\xd9\xbf\xd9\x0a\xf6\x18\x7b\x96\x6d\x04\x89\x2d\x07\x99\xdd\xca\xee\x67\x97\xd8\x65\x76\x37\xce\x0d\xec\xa0\x63\x5f\xb2\x8b\xec\x71\xf6\x1c\xfb\x89\x5d\x61\x57\xd9\x06\xf6\x02\xfb\x90\xed\xc4\x79\xcf\x14\xd4\xf9\x3d\xe8\x13\x1f\xa3\x5d\x77\xb1\x8f\xd8\x5e\xb6\x9b\xed\x61\xff\x63\xdf\x62\xcf\xb4\x9f\x7d\xc2\x3e\x65\x2f\xa1\xee\x7f\x64\xf7\xb2\x43\xec\x00\x3b\x88\x16\x3b\xc7\xbe\x67\x77\x62\x08\x52\x8e\x3d\xaa\x70\xcb\x0a\xb6\x0e\x2d\x34\x9b\xc6\x94\x6a\xf4\xb0\x1a\xec\x81\xe7\xb1\xef\xd8\x7c\x8c\xf5\x6b\xd9\x02\xb6\x90\xdd\xc2\xb6\xb2\xf5\x6c\x31\x5b\xc4\x96\xb0\xa5\xec\x3c\xfb\x81\x6d\x03\x3d\x78\x81\x41\x9c\x66\x0c\x3e\xcc\xc1\x54\xf0\x05\x3f\xf0\x07\x13\xab\x07\x06\x66\xb0\x40\x00\x00\x04\x42\x10\x04\x43\x08\xb4\x82\x50\x08\x83\x70\x88\x80\x48\x88\x82\xd6\xec\x17\xf6\x2b\x58\x21\x1a\x62\x20\x16\xe2\x20\x1e\x12\x20\x11\xda\x40\x5b\x68\x07\x49\xd0\x1e\x92\x21\x05\x52\xd9\x35\xf6\x19\x74\x80\x8e\x90\x06\xe9\xd0\x09\x32\x20\x13\xb2\xa0\x33\x64\x43\x17\xb8\x09\xba\x42\x37\xe8\xce\x4e\xb2\x53\x90\x03\x36\xe8\x01\x3d\xa1\x17\xe4\x42\x6f\xe8\x23\xce\xc6\x82\xfe\x30\x00\x06\xc2\x20\x9c\xfb\xbd\xcc\x36\xc1\x10\xc8\x83\xa1\x30\x0c\x86\xc3\x08\x18\x09\xa3\x60\x34\x8c\x61\xd7\x59\x1d\x3b\xcd\xce\xc0\x58\xc8\x87\x71\x30\x1e\x26\x40\x01\x4c\x84\x49\x30\x19\x0a\x61\x0a\x14\x41\x31\x94\x40\x29\x4c\x85\x32\x28\x87\x69\x30\x1d\x66\xc0\x4c\xf6\x26\x54\x40\x25\xcc\x82\xd9\xec\x6b\xf6\x0d\x54\x41\x35\xd4\xc0\x1c\x98\x0b\xf3\x60\x3e\xd4\xc2\xcd\xb0\x00\x6e\x81\x85\xb0\x08\x16\xc3\x12\x58\x0a\xff\x82\x5b\x61\x19\x7b\x0a\x6e\x83\xdb\xe1\x0e\xb0\xc3\x9d\xb0\x1c\x56\xc0\x5d\x70\x37\xfc\x1b\x56\xc2\x3d\x70\x2f\xdc\x07\xf7\xc3\x03\xb0\x0a\x1e\x84\x87\x60\x35\x3c\x0c\x8f\xc0\x1a\x78\x14\x1e\x83\xc7\x61\x2d\xac\x83\xf5\xb0\x01\x9e\x80\x8d\xf0\x24\x3c\x05\x4f\xc3\x33\xf0\x2c\x3c\x07\xff\x81\xe7\xe1\x05\x78\x11\x5e\x82\x97\x61\x13\x6c\x86\x57\xe0\x55\x78\x0d\xb6\xc0\xeb\xb0\x15\xde\x80\x6d\xf0\x26\xbc\x05\x6f\xc3\xff\xc1\x7f\xe1\x1d\xd8\x0e\x3b\xe0\x5d\x78\x0f\xde\x87\x0f\x60\x27\xec\x82\x0f\xe1\x23\xf8\x18\x76\xc3\x1e\xf8\x1f\xec\x85\x4f\xe0\x53\xd8\x07\xfb\xe1\x00\x1c\x84\x43\xf0\x19\x1c\x86\x23\xf0\x39\x1c\x85\x2f\xe0\x18\x7c\x09\xc7\xe1\x2b\x38\x01\x27\xe1\x14\x9c\x86\x33\xf0\x35\x7c\x03\x67\xe1\x5b\xf8\x0e\xce\xc1\x79\xf8\x1e\x7e\x80\x0b\xf0\x23\x5c\x84\x4b\x70\x19\xae\xc0\x4f\x70\x15\x7e\x86\x5f\xe0\x57\xb8\x06\xd7\xa1\x0e\x1c\xa0\x42\x3d\x67\x1c\x38\xe7\x12\x97\xb9\xc2\x75\x5c\xcf\xbd\xb8\x81\x1b\xb9\x37\xf7\xe1\xbe\xdc\x8f\xfb\x73\x13\x37\x73\x0b\x0f\xe0\x81\x3c\x88\x07\xf3\x10\xde\x8a\x87\xf2\x30\x1e\xce\x23\x78\x24\x8f\xe2\xad\xb9\x95\x47\xf3\x18\x1e\xcb\xe3\x78\x3c\x4f\xe0\x89\xbc\x0d\x6f\xcb\xdb\xf1\x24\xde\x9e\x27\xf3\x14\x9e\xca\x3b\xf0\x8e\x3c\x8d\xa7\xf3\x4e\x3c\x83\x67\xf2\x2c\xde\x99\x67\xf3\x2e\xfc\x26\xde\x95\x77\xe3\xdd\x79\x0e\xb7\xf1\x1e\xbc\x27\xef\xc5\x73\x79\x6f\xde\x87\xf7\xe5\xfd\x78\x7f\x3e\x80\x0f\xe4\x83\xf8\x60\x3e\x84\xe7\xf1\xa1\x7c\x18\x1f\xce\x47\xf0\x91\x7c\x14\x1f\xcd\xc7\xf0\xb1\x3c\x9f\x8f\xe3\xe3\xf9\x04\x5e\xc0\x27\xf2\x49\x7c\x32\x2f\xe4\x53\x78\x11\x2f\xe6\x25\xbc\x94\x4f\xe5\x65\xbc\x9c\x4f\xe3\xd3\xf9\x0c\x3e\x93\x57\xf0\x4a\x3e\x8b\xcf\xe6\x55\xbc\x9a\xd7\xf0\x39\x7c\x2e\x9f\xc7\xe7\xf3\x5a\x7e\x33\x5f\xc0\x6f\xe1\x0b\xf9\x22\xbe\x98\x2f\xe1\x4b\xf9\xbf\xf8\xad\x7c\x19\xbf\x8d\xdf\xce\xef\xe0\x76\x7e\x27\x5f\xce\x57\xf0\xbb\xf8\xdd\xfc\xdf\x7c\x25\xbf\x87\xdf\xcb\xef\xe3\xf7\xf3\x07\xf8\x2a\xfe\x20\x7f\x88\xaf\xe6\x0f\xf3\x47\xf8\x1a\xfe\x28\x7f\x8c\x3f\xce\xd7\xf2\x75\x7c\x3d\xdf\xc0\x9f\xe0\x1b\xf9\x93\xfc\x29\xfe\x34\x7f\x86\x3f\xcb\x9f\xe3\xff\xe1\xcf\xf3\x17\xf8\x8b\xfc\x25\xfe\x32\xdf\xc4\x37\xf3\x57\xf8\xab\xfc\x35\xbe\x85\xbf\xce\x0e\xb3\x13\x7c\x2b\xfb\x9c\xbf\xc1\xb7\xf1\x37\xf9\x5b\xfc\x6d\xfe\x7f\xfc\xbf\xfc\x1d\xbe\x9d\xef\xe0\xef\xf2\xf7\xf8\xfb\xfc\x03\x76\x94\x7d\xc1\x8e\xb1\xaf\xd8\x11\x76\x9c\xef\xe4\xbb\xf8\x87\xfc\x23\xfe\x31\xdf\xcd\xf7\xf0\xff\xf1\xbd\xfc\x13\xfe\x29\xdf\xc7\xf7\xf3\x03\xfc\x20\x3f\xc4\x3f\xe3\x87\xf9\x11\xfe\x39\x3f\xca\xbf\xe0\xc7\xf8\x97\xfc\x38\xff\x8a\x9f\xe0\x27\xf9\x29\x7e\x9a\x9f\xe1\x5f\xf3\x6f\xf8\x59\xfe\x2d\xff\x7f\xd8\x7b\x13\x38\x29\x8a\xf3\x7f\xb8\x67\xea\xe8\xaa\xd9\xe5\x14\x15\x10\x8f\xa8\x31\x5e\x31\x6c\x77\xcd\x65\x88\x71\x8f\x6e\x15\x11\x0c\x82\xa2\xf1\x1a\xd8\x81\x5d\xd8\x03\xf6\xe0\xf0\x40\x62\x8c\x1a\xe3\x1d\x63\x0c\x31\xc6\x18\xa3\x88\xc6\x98\x95\x18\x63\x8c\xf1\x06\x15\xf0\xc4\x0b\x54\xe4\x50\x54\x54\x44\xbc\x50\xd9\xb7\xba\xfa\xbb\x33\xbd\xc3\x82\x98\xfc\xf3\x7b\xf3\x7b\xdf\xbf\x7e\xea\xa9\x63\xaa\x9e\xef\x53\x4f\xd5\xf4\xf7\xa9\xee\x5e\xe6\xed\xf8\x3b\xf1\xf5\xf1\x77\xe3\xef\xc5\xdf\x8f\x6f\x88\x7f\x10\xdf\x18\xff\x30\xbe\x29\xfe\x51\xfc\xe3\xf8\x27\xf1\x4f\xe3\x9f\xc5\x37\xc7\x3f\x8f\x7f\x11\xff\x32\xbe\x25\xde\x49\x2c\x12\x23\x71\x42\x08\x25\xc1\x3f\x1c\x63\x13\x41\x24\x49\x90\x32\x52\x4e\x7a\x91\xde\xa4\x0f\xe9\x4b\xfa\x91\xfe\x64\x27\x32\x80\xec\x4c\x76\x21\xbb\x92\x81\x64\x10\x19\x4c\x76\x23\x43\xc8\xee\x64\x0f\xb2\x27\xd9\x8b\x7c\x83\xec\x4d\xf6\x21\xfb\x92\x6f\x92\xfd\xc8\xb7\xc8\xfe\xe4\x00\x72\x20\x39\x88\x1c\x4c\xbe\x4d\x0e\x21\xdf\x21\x43\x49\x05\x71\x88\x4b\x14\x49\x92\x14\x49\x93\x0c\xc9\x92\x43\xc9\x77\xc9\x30\xf2\x3d\x72\x18\xf9\x3e\x39\x9c\x54\x92\x2a\x52\x4d\x6a\x88\x17\xbc\x0f\x42\x8e\x24\x47\x91\xe1\xe4\x68\x32\x82\x1c\x43\x46\x92\x51\xe4\x58\xf2\x03\x32\x9a\x1c\x47\xc6\x90\xb1\xe4\x78\x72\x02\x19\x47\x4e\x24\x27\x91\x1f\x92\x93\x83\xe7\xec\xe4\x34\x72\x3a\xc9\x91\xf1\x64\x02\xa9\x25\x79\x32\x91\x4c\x0a\x9e\x7c\x93\xc9\x64\x0a\x69\x20\x8d\xd6\x3c\xd2\x44\x9a\x83\x27\xbe\xa4\x85\xb4\x92\x36\xd2\x4e\xa6\x93\x19\xc1\x93\x58\x72\x06\x39\x93\x9c\x45\xce\x26\xb3\xc9\x39\x64\x8e\xf5\x5b\xf2\x23\x72\x2e\xf9\x31\x39\x8f\xfc\x84\x9c\x4f\x2e\x20\x17\x92\x9f\x92\x8b\xc8\xcf\xc8\xc5\xe4\x12\x72\x29\xb9\x8c\x5c\x4e\xae\x20\x57\x5a\xbf\x24\x3f\x27\x57\x91\x5f\x58\xbf\x26\x57\x93\x5f\x92\x6b\xc8\xaf\xc8\x5c\xf2\x6b\x72\x2d\xf9\x0d\xb9\x8e\xfc\x96\x5c\x4f\x7e\x47\x6e\x20\xbf\x27\x37\x92\x3f\x90\x9b\xc8\xcd\x64\x1e\xb9\x85\xcc\x27\xb7\x92\xdb\xc8\x1f\xc9\xed\xe4\x4f\xe4\x0e\xf2\x67\xd2\x41\xee\x24\x0b\xc8\x5f\xc8\x5d\xe4\xaf\xe4\x6e\xf2\x37\x72\x0f\xf9\x3b\xb9\x97\xfc\x83\xdc\x47\xfe\x49\xee\x27\x0f\x90\x07\xc9\x43\xc1\xd3\x44\xf2\x68\xf0\xc4\x8e\x3c\x46\x1e\x27\x4f\x90\xc5\x64\x09\x59\x4a\x9e\x24\x4f\x91\xa7\x83\x67\x47\xc1\x73\x13\xf2\x3c\x79\x81\xbc\x48\x5e\x22\x2f\x93\xe5\x64\x45\x70\xe7\x9f\xbc\x46\x56\x92\xd7\xc9\x2a\xb2\x3a\xb8\xf3\x1d\xdc\xbb\x26\xeb\xc8\x5b\xe4\xed\xe0\x4e\x31\x79\x97\xbc\x47\xde\x27\x1b\xc8\x07\x64\x63\x70\xdf\x94\x7c\x44\x3e\x26\x9f\x90\x4f\xc9\x67\x64\x33\xf9\x9c\x7c\x41\xbe\x24\x5b\x48\x27\xb5\x68\x8c\xc6\x29\xa1\x94\x32\xca\xa9\x4d\x05\x95\x34\x41\xcb\x68\x39\xed\x45\x7b\xd3\x3e\xb4\x2f\xed\x47\xfb\xd3\x9d\xe8\x00\xba\x33\xdd\x85\xee\x4a\x07\xd2\x41\x74\x30\xdd\x8d\x0e\xa1\xbb\xd3\x3d\xe8\x9e\x74\x2f\xfa\x0d\xba\x37\xdd\x87\xee\x4b\xbf\x49\xf7\xa3\xdf\xa2\xfb\xd3\x03\xe8\x81\xf4\x20\x7a\x30\xfd\x36\x3d\x84\x7e\x87\x0e\xa5\x15\xd4\xa1\x2e\x55\x34\x49\x53\x34\x4d\x33\x34\x4b\x0f\xa5\xdf\xa5\xc3\xe8\xf7\xe8\x61\xf4\xfb\xf4\x70\x5a\x49\xab\x68\x35\xad\xa1\x1e\xf5\xe9\x11\xf4\x48\x7a\x14\x1d\x4e\x8f\xa6\x23\xe8\x31\x74\x24\x1d\x45\x8f\xa5\x3f\xa0\xa3\xe9\x71\x74\x0c\x1d\x4b\x8f\xa7\x27\xd0\x71\xf4\x44\x7a\x12\xfd\x21\x3d\x99\x9e\x42\x4f\xa5\xa7\xd1\xd3\x69\x8e\x8e\xa7\x13\x68\x2d\xcd\xd3\x89\x74\x12\xad\xa3\xf5\x74\x32\x9d\x42\x1b\x68\x23\x6d\xa2\xcd\x74\x2a\x9d\x46\x5b\x68\x2b\x6d\xa3\xed\x74\x3a\x9d\x41\x67\xd2\x59\xf4\x0c\x7a\x26\x3d\x8b\x9e\x4d\x67\xd3\x73\xe8\x1c\xfa\x23\x7a\x2e\xfd\x31\x3d\x8f\xfe\x84\x9e\x4f\x2f\xa0\x17\xd2\x9f\xd2\x8b\xe8\xcf\xe8\xc5\xf4\x12\x7a\x29\xbd\x8c\x5e\x4e\xaf\xa0\x57\xd2\x9f\xd3\xab\xe8\x2f\xe8\xd5\xf4\x97\xf4\x1a\xfa\x2b\x3a\x97\xfe\x9a\x5e\x4b\x7f\x43\xaf\xa3\xbf\xa5\xd7\xd3\xdf\xd1\x1b\xe8\xef\xe9\x8d\xf4\x0f\xf4\x26\x7a\x33\x9d\x47\x6f\xa1\xf3\xe9\xad\xf4\x36\xfa\x47\x7a\x3b\xfd\x13\xbd\x83\xfe\x99\x76\xd0\x3b\xe9\x02\xfa\x17\x7a\x17\xfd\x2b\xbd\x9b\xfe\x8d\xde\x43\xff\x4e\xef\xa5\xff\xa0\xf7\xd1\x7f\xd2\xfb\xe9\x03\xf4\x41\xfa\x10\x7d\x98\x3e\x42\x1f\xa5\x0b\xe9\x22\xfa\x18\x7d\x9c\x3e\x41\x17\xd3\x25\x74\x29\x7d\x92\x3e\x45\x9f\xa6\xcf\xd0\x67\xe9\x73\x74\x19\x7d\x9e\xbe\x40\x5f\xa4\x2f\xd1\x97\xe9\x72\xba\x82\xbe\x42\x5f\xa5\xaf\xd1\x95\xf4\x75\xba\x8a\xae\xa6\x6b\xe8\x5a\xfa\x06\x7d\x93\xae\xa3\x6f\xd1\xb7\xe9\x3b\x74\x3d\x7d\x97\xbe\x47\xdf\xa7\x1b\xe8\x07\x74\x23\xfd\x90\x6e\xa2\x1f\xd1\x8f\xe9\x27\xf4\x53\xfa\x19\xdd\x4c\x3f\xa7\x5f\xd0\x2f\xe9\x16\xda\xc9\xac\xe0\x67\x8e\x19\x61\x94\x31\xc6\x99\xcd\x04\x93\x2c\xc1\xca\x82\x7f\xdb\x85\xf5\x66\x7d\x58\x5f\xd6\x8f\xf5\x67\x3b\xb1\x01\x6c\x67\xb6\x0b\xdb\x95\x0d\x64\x83\xd8\x60\xb6\x1b\x1b\xc2\x76\x67\x7b\xb0\x3d\xd9\x5e\xec\x1b\x6c\x6f\xb6\x0f\xdb\x97\x7d\x93\xed\xc7\xbe\xc5\xf6\x67\x07\xb0\x03\xd9\x41\xec\x60\xf6\x6d\x76\x08\xfb\x0e\x1b\xca\x2a\x98\xc3\x5c\xa6\x58\x92\xa5\x58\x9a\x65\x58\x96\x1d\xca\xbe\xcb\x86\xb1\xef\xb1\xc3\xd8\xf7\xd9\xe1\xac\x92\x55\xb1\x6a\x56\xc3\x3c\xe6\xb3\x23\xd8\x91\xec\x28\x36\x9c\x1d\xcd\x46\xb0\x63\xd8\x48\x36\x8a\x1d\xcb\x7e\xc0\x46\xb3\xe3\xd8\x18\x36\x96\x1d\xcf\x4e\x60\xe3\xd8\x89\xec\x24\xf6\x43\x76\x32\x3b\x85\x9d\xca\x4e\x63\xa7\xb3\x1c\x1b\xcf\x26\xb0\x5a\x96\x67\x13\xd9\x24\x56\xc7\xea\xd9\x64\x36\x85\x35\xb0\x46\xd6\xc4\x9a\xd9\x54\x36\x8d\xb5\xb0\x56\xd6\xc6\xda\xd9\x74\x36\x83\xcd\x64\xb3\xd8\x19\xec\x4c\x76\x16\x3b\x9b\xcd\x66\xe7\xb0\x39\xec\x47\xec\x5c\xf6\x63\x76\x1e\xfb\x09\x3b\x9f\x5d\xc0\x2e\x64\x3f\x65\x17\xb1\x9f\xb1\x8b\xd9\x25\xec\x52\x76\x19\xbb\x9c\x5d\xc1\xae\x64\x3f\x67\x57\xb1\x5f\xb0\xab\xd9\x2f\xd9\x35\xec\x57\x6c\x2e\xfb\x35\xbb\x96\xfd\x86\x5d\xc7\x7e\xcb\xae\x67\xbf\x63\x37\xb0\xdf\xb3\x1b\xd9\x1f\xd8\x4d\xec\x66\x36\x8f\xdd\xc2\xe6\xb3\x5b\xd9\x6d\xec\x8f\xec\x76\xf6\x27\x76\x07\xfb\x33\xeb\x60\x77\xb2\x05\xec\x2f\xec\x2e\xf6\x57\x76\x37\xfb\x1b\xbb\x87\xfd\x9d\xdd\xcb\xfe\xc1\xee\x63\xff\x64\xf7\xb3\x07\xd8\x83\xec\x21\xf6\x30\x7b\x84\x3d\xca\x16\xb2\x45\xec\x31\xf6\x38\x7b\x82\x2d\x66\x4b\xd8\x52\xf6\x24\x7b\x8a\x3d\xcd\x9e\x61\xcf\xb2\xe7\xd8\x32\xf6\x3c\x7b\x81\xbd\xc8\x5e\x62\x2f\xb3\xe5\x6c\x05\x7b\x85\xbd\xca\x5e\x63\x2b\xd9\xeb\x6c\x15\x5b\xcd\xd6\xb0\xb5\xec\x0d\xf6\x26\x5b\xc7\xde\x62\x6f\xb3\x77\xd8\x7a\xf6\x2e\x7b\x8f\xbd\xcf\x36\xb0\x0f\xd8\x46\xf6\x21\xdb\xc4\x3e\x62\x1f\xb3\x4f\xd8\xa7\xec\x33\xb6\x99\x7d\xce\xbe\x60\x5f\xb2\x2d\xac\x93\x5b\x3c\xc6\xe3\x3c\xf8\x87\x8c\x19\xe7\xdc\xe6\x82\x4b\x9e\xe0\x65\xbc\x9c\xf7\xe2\xbd\x79\x1f\xde\x97\xf7\xe3\xfd\xf9\x4e\x7c\x00\xdf\x99\xef\xc2\x77\xe5\x03\xf9\x20\x3e\x98\xef\xc6\x87\xf0\xdd\xf9\x1e\x7c\x4f\xbe\x17\xff\x06\xdf\x9b\xef\xc3\xf7\xe5\xdf\xe4\xfb\xf1\x6f\xf1\xfd\xf9\x01\xfc\x40\x7e\x10\x3f\x98\x7f\x9b\x1f\xc2\xbf\xc3\x87\xf2\x0a\xee\x70\x97\x2b\x9e\xe4\x29\x9e\xe6\x19\x9e\xe5\x87\xf2\xef\xf2\x61\xfc\x7b\xfc\x30\xfe\x7d\x7e\x38\xaf\xe4\x55\xbc\x9a\xd7\x70\x8f\xfb\xfc\x08\x7e\x24\x3f\x8a\x0f\xe7\x47\xf3\x11\xfc\x18\x3e\x92\x8f\xe2\xc7\xf2\x1f\xf0\xd1\xfc\x38\x3e\x86\x8f\xe5\xc7\xf3\x13\xf8\x38\x7e\x22\x3f\x89\xff\x90\x9f\xcc\x4f\xe1\xa7\xf2\xd3\xf8\xe9\x3c\xc7\xc7\xf3\x09\xbc\x96\xe7\xf9\x44\x3e\x89\xd7\xf1\x7a\x3e\x99\x4f\xe1\x0d\xbc\x91\x37\xf1\x66\x3e\x95\x4f\xe3\x2d\xbc\x95\xb7\xf1\x76\x3e\x9d\xcf\xe0\x33\xf9\x2c\x7e\x06\x3f\x93\x9f\xc5\xcf\xe6\xb3\xf9\x39\x7c\x0e\xff\x11\x3f\x97\xff\x98\x9f\xc7\x7f\xc2\xcf\xe7\x17\xf0\x0b\xf9\x4f\xf9\x45\xfc\x67\xfc\x62\x7e\x09\xbf\x94\x5f\xc6\x2f\xe7\x57\xf0\x2b\xf9\xcf\xf9\x55\xfc\x17\xfc\x6a\xfe\x4b\x7e\x0d\xff\x15\x9f\xcb\x7f\xcd\xaf\xe5\xbf\xe1\xd7\xf1\xdf\xf2\xeb\xf9\xef\xf8\x0d\xfc\xf7\xfc\x46\xfe\x07\x7e\x13\xbf\x99\xcf\xe3\xb7\xf0\xf9\xfc\x56\x7e\x1b\xff\x23\xbf\x9d\xff\x89\xdf\xc1\xff\xcc\x3b\xf8\x9d\x7c\x01\xff\x0b\xbf\x8b\xff\x95\xdf\xcd\xff\xc6\xef\xe1\x7f\xe7\xf7\xf2\x7f\xf0\xfb\xf8\x3f\xf9\xfd\xfc\x01\xfe\x20\x7f\x88\x3f\xcc\x1f\xe1\x8f\xf2\x85\x7c\x11\x7f\x8c\x3f\xce\x9f\xe0\x8b\xf9\x12\xbe\x94\x3f\xc9\x9f\xe2\x4f\xf3\x67\xf8\xb3\xfc\x39\xbe\x8c\x3f\xcf\x5f\xe0\x2f\xf2\x97\xf8\xcb\x7c\x39\x5f\xc1\x5f\xe1\xaf\xf2\xd7\xf8\x4a\xfe\x3a\x5f\xc5\x57\xf3\x35\x7c\x2d\x7f\x83\xbf\xc9\xd7\xf1\xb7\xf8\xdb\xfc\x1d\xbe\x9e\xbf\xcb\xdf\xe3\xef\xf3\x0d\xfc\x03\xbe\x91\x7f\xc8\x37\xf1\x8f\xf8\xc7\xfc\x13\xfe\x29\xff\x8c\x6f\xe6\x9f\xf3\x2f\xf8\x97\x7c\x0b\xef\xb4\x2d\x3b\x66\xc7\x6d\x62\x53\x9b\xd9\xdc\xb6\x6d\x61\x4b\x3b\x61\x97\xd9\xe5\x76\x2f\xbb\xb7\xdd\xc7\xee\x6b\xf7\xb3\xfb\xdb\x3b\xd9\x03\xec\x9d\xed\x5d\xec\x5d\xed\x81\xf6\x20\x7b\xb0\xbd\x9b\x3d\xc4\xde\xdd\xde\xc3\xde\xd3\xde\xcb\xfe\x86\xbd\xb7\xbd\x8f\xbd\xaf\xfd\x4d\x7b\x3f\xfb\x5b\xf6\xfe\xf6\x01\xf6\x81\xf6\x41\xf6\xc1\xf6\xb7\xed\x43\xec\xef\xd8\x43\xed\x0a\xdb\xb1\x5d\x5b\xd9\x49\x3b\x65\xa7\xed\x8c\x9d\xb5\x0f\xb5\xbf\x6b\x0f\xb3\xbf\x67\x1f\x66\x7f\xdf\x3e\xdc\xae\xb4\xab\xec\x6a\xbb\xc6\xf6\x6c\xdf\x3e\xc2\x3e\xd2\x3e\xca\x1e\x6e\x1f\x6d\x8f\xb0\x8f\xb1\x47\xda\xa3\xec\x63\xed\x1f\xd8\xa3\xed\xe3\xec\x31\xf6\x58\xfb\x78\xfb\x04\x7b\x9c\x7d\xa2\x7d\x92\xfd\x43\xfb\x64\xfb\x14\xfb\x54\xfb\x34\xfb\x74\x3b\x67\x8f\xb7\x27\xd8\xb5\x76\xde\x9e\x68\x4f\xb2\xeb\xec\x7a\x7b\xb2\x3d\xc5\x6e\xb0\x1b\xed\x26\xbb\xd9\x9e\x6a\x4f\xb3\x5b\xec\x56\xbb\xcd\x6e\xb7\xa7\xdb\x33\xec\x99\xf6\x2c\xfb\x0c\xfb\x4c\xfb\x2c\xfb\x6c\x7b\xb6\x7d\x8e\x3d\xc7\xfe\x91\x7d\xae\xfd\x63\xfb\x3c\xfb\x27\xf6\xf9\xf6\x05\xf6\x85\xf6\x4f\xed\x8b\xec\x9f\xd9\x17\xdb\x97\xd8\x97\xda\x97\xd9\x97\xdb\x57\xd8\x57\xda\x3f\xb7\xaf\xb2\x7f\x61\x5f\x6d\xff\xd2\xbe\xc6\xfe\x95\x3d\xd7\xfe\xb5\x7d\xad\xfd\x1b\xfb\x3a\xfb\xb7\xf6\xf5\xf6\xef\xec\x1b\xec\xdf\xdb\x37\xda\x7f\xb0\x6f\xb2\x6f\xb6\xe7\xd9\xb7\xd8\xf3\xed\x5b\xed\xdb\xec\x3f\xda\xb7\xdb\x7f\xb2\xef\xb0\xff\x6c\x77\xd8\x77\xda\x0b\xec\xbf\xd8\x77\xd9\x7f\xb5\xef\xb6\xff\x66\xdf\x63\xff\xdd\xbe\xd7\xfe\x87\x7d\x9f\xfd\x4f\xfb\x7e\xfb\x01\xfb\x41\xfb\x21\xfb\x61\xfb\x11\xfb\x51\x7b\xa1\xbd\xc8\x7e\xcc\x7e\xdc\x7e\xc2\x5e\x6c\x2f\xb1\x97\xda\x4f\xda\x4f\xd9\x4f\xdb\xcf\xd8\xcf\xda\xcf\xd9\xcb\xec\xe7\xed\x17\xec\x17\xed\x97\xec\x97\xed\xe5\xf6\x0a\xfb\x15\xfb\x55\xfb\x35\x7b\xa5\xfd\xba\xbd\xca\x5e\x6d\xaf\xb1\xd7\xda\x6f\xd8\x6f\xda\xeb\xec\xb7\xec\xb7\xed\x77\xec\xf5\xf6\xbb\xf6\x7b\xf6\xfb\xf6\x06\xfb\x03\x7b\xa3\xfd\xa1\xbd\xc9\xfe\xc8\xfe\xd8\xfe\xc4\xfe\xd4\xfe\xcc\xde\x6c\x7f\x6e\x7f\x61\x7f\x69\x6f\xb1\x3b\x85\x65\x75\x58\x77\x8a\x98\x88\x0b\x62\xdd\x65\xfd\xd5\x7a\x58\x50\x6b\x81\xf5\x17\xeb\x11\xc1\xac\x73\xad\x07\xad\x0b\xac\x5b\x05\x17\xb6\x10\x42\x8a\x84\x28\xb3\x1e\x15\xe5\xa2\x97\xe8\x6d\xdd\x67\xfd\x53\xf4\x11\x7d\xad\x7b\x45\x3f\xd1\x5f\xec\x24\x06\x88\x9d\xc5\x2e\x62\x57\x31\x50\x0c\x12\x83\xc5\x6e\x62\x88\xd8\x5d\xec\x21\xf6\x14\x7b\x89\x6f\x88\xbd\xc5\x3e\x62\x5f\xeb\x13\xf1\x4d\xb1\x9f\xf8\x96\xd8\x5f\x1c\x20\x0e\x14\x07\x89\x83\xc5\xb7\xc5\x21\xe2\x3b\x62\xa8\xa8\x10\x8e\x70\x85\x12\x49\x91\x12\x69\x91\x11\x59\x71\xa8\xf8\xae\x75\xb1\x18\x26\xbe\x27\x0e\x13\xdf\x17\x87\x8b\x4a\x51\x25\xaa\x45\x8d\xf0\x84\x2f\x8e\x10\x47\x8a\xa3\xc4\x70\x71\xb4\x18\x21\x8e\xb1\xae\x11\x23\xad\xb9\xd6\xaf\xac\xf7\xc5\x28\xeb\x21\xeb\x0f\xd6\x95\xe2\x58\xf1\x03\xeb\x5a\xeb\x66\xeb\x32\x31\xda\xba\xca\xfa\x85\x38\x4e\x8c\x11\x63\xc5\xf1\xe2\x04\x31\x4e\x9c\x28\x4e\x12\x3f\x14\x27\x8b\x53\xc4\xa9\xe2\x34\x71\xba\xc8\x89\xf1\x62\x82\xa8\x15\x79\x31\x51\x4c\x12\x75\xa2\x5e\x4c\x16\x53\x44\x83\x68\x14\x4d\xa2\x59\x4c\x15\xd3\x44\x8b\x68\x15\x6d\xa2\x5d\x4c\x17\x33\xc4\x4c\x31\x4b\x9c\x21\xce\x14\x67\x89\xb3\xc5\x6c\x71\x8e\x98\x23\x7e\x24\xce\x15\x3f\x16\xe7\x89\x9f\x88\xf3\xc5\x05\xe2\x42\xf1\x53\x71\x91\xf8\x99\xb8\x58\x5c\x22\x2e\x15\x97\x59\x7f\x13\x97\x8b\x2b\xc4\x95\xe2\xe7\xe2\x2a\xf1\x0b\x71\xb5\xf8\xa5\xb8\x46\xfc\x4a\xcc\x15\xbf\x16\xd7\x8a\xdf\x88\xeb\xc4\x6f\xc5\xf5\xe2\x77\xe2\x06\xf1\x7b\x71\xa3\xf8\x83\xb8\x49\xdc\x2c\xe6\x89\x5b\xc4\x7c\x71\xab\xb8\x4d\xfc\x51\xdc\x2e\xfe\x24\xee\x10\x7f\x16\x1d\xe2\x4e\xb1\x40\xfc\x45\xdc\x25\xfe\x2a\xee\x16\x7f\x13\xf7\x88\xbf\x8b\x7b\xc5\x3f\xc4\x7d\xe2\x9f\xe2\x7e\xf1\x80\x78\x50\x3c\x24\x1e\x16\x8f\x88\x47\xc5\x42\xb1\x48\x3c\x26\x1e\x17\x4f\x88\xc5\x62\x89\x58\x2a\x9e\x14\x4f\x89\xa7\xc5\x33\xe2\x59\xf1\x9c\x58\x26\x9e\x17\x2f\x88\x17\xc5\x4b\xe2\x65\xb1\x5c\xac\x10\xaf\x88\x57\xc5\x6b\x62\xa5\x78\x5d\xac\x12\xab\xc5\x1a\xb1\x56\xbc\x21\xde\x14\xeb\xc4\x5b\xe2\x6d\xf1\x8e\x58\x2f\xde\x15\xef\x89\xf7\xc5\x06\xf1\x81\xd8\x28\x3e\x14\x9b\xc4\x47\xe2\x63\xf1\x89\xf8\x54\x7c\x26\x36\x8b\xcf\xc5\x17\xe2\x4b\xb1\x45\x74\x4a\x4b\xc6\x64\x5c\x12\x49\x25\x93\x5c\xda\x52\x48\x29\x13\xb2\x4c\x96\xcb\x5e\xb2\xb7\xec\x23\xfb\xca\x7e\xb2\xbf\xdc\x49\x0e\x90\x3b\xcb\x5d\xe4\xae\x72\xa0\x1c\x24\x07\xcb\xdd\xe4\x10\xb9\xbb\xdc\x43\xee\x29\xf7\x92\xdf\x90\x7b\xcb\x7d\xe4\xbe\xf2\x9b\x72\x3f\xf9\x2d\xb9\xbf\x3c\x40\x1e\x28\x0f\x92\x07\xcb\x6f\xcb\x43\xe4\x77\xe4\x50\x59\x21\x1d\xe9\x4a\x25\x93\x32\x25\xd3\x32\x23\xb3\xf2\x50\xf9\x5d\x39\x4c\x7e\x4f\x1e\x26\xbf\x2f\x0f\x97\x95\xb2\x4a\x56\xcb\x1a\xe9\x49\x5f\x1e\x21\x8f\x94\x47\xc9\xe1\xf2\x68\x39\x42\x1e\x23\x47\xca\x51\xf2\x58\xf9\x03\x39\x5a\x1e\x27\xc7\xc8\xb1\xf2\x78\x79\x82\x1c\x27\x4f\x94\x27\xc9\x1f\xca\x93\xe5\x29\xf2\x54\x79\x9a\x3c\x5d\xe6\xe4\x78\x39\x41\xd6\xca\xbc\x9c\x28\x27\xc9\x3a\x59\x2f\x27\xcb\x29\xb2\x41\x36\xca\x26\xd9\x2c\xa7\xca\x69\xb2\x45\xb6\xca\x36\xd9\x2e\xa7\xcb\x19\x72\xa6\x9c\x25\xcf\x90\x67\xca\xb3\xe4\xd9\x72\xb6\x3c\x47\xce\x91\x3f\x92\xe7\xca\x1f\xcb\xf3\xe4\x4f\xe4\xf9\xf2\x02\x79\xa1\xfc\xa9\xbc\x48\xfe\x4c\x5e\x2c\x2f\x91\x97\xca\xcb\xe4\xe5\xf2\x0a\x79\xa5\xfc\xb9\xbc\x4a\xfe\x42\x5e\x2d\x7f\x29\xaf\x91\xbf\x92\x73\xe5\xaf\xe5\xb5\xf2\x37\xf2\x3a\xf9\x5b\x79\xbd\xfc\x9d\xbc\x41\xfe\x5e\xde\x28\xff\x20\x6f\x92\x37\xcb\x79\xf2\x16\x39\x5f\xde\x2a\x6f\x93\x7f\x94\xb7\xcb\x3f\xc9\x3b\xe4\x9f\x65\x87\xbc\x53\x2e\x90\x7f\x91\x77\xc9\xbf\xca\xbb\xe5\xdf\xe4\x3d\xf2\xef\xf2\x5e\xf9\x0f\x79\x9f\xfc\xa7\xbc\x5f\x3e\x20\x1f\x94\x0f\xc9\x87\xe5\x23\xf2\x51\xb9\x50\x2e\x92\x8f\xc9\xc7\xe5\x13\x72\xb1\x5c\x22\x97\xca\x27\xe5\x53\xf2\x69\xf9\x8c\x7c\x56\x3e\x27\x97\xc9\xe7\xe5\x0b\xf2\x45\xf9\x92\x7c\x59\x2e\x97\x2b\xe4\x2b\xf2\x55\xf9\x9a\x5c\x29\x5f\x97\xab\xe4\x6a\xb9\x46\xae\x95\x6f\xc8\x37\xe5\x3a\xf9\x96\x7c\x5b\xbe\x23\xd7\xcb\x77\xe5\x7b\xf2\x7d\xb9\x41\x7e\x20\x37\xca\x0f\xe5\x26\xf9\x91\xfc\x58\x7e\x22\x3f\x95\x9f\xc9\xcd\xf2\x73\xf9\x85\xfc\x52\x6e\x91\x9d\x09\x2b\x11\x4b\xc4\x13\x24\x41\x13\x2c\xc1\x13\x76\x42\x24\x64\x22\x91\x28\x4b\x94\x27\x7a\x25\x7a\x27\xfa\x24\xfa\x26\xfa\x25\xfa\x27\x76\x4a\x0c\x48\xec\x9c\xd8\x25\xb1\x6b\x62\x60\x62\x50\x62\x70\x62\xb7\xc4\x90\xc4\xee\x89\x3d\x12\x7b\x26\xf6\xb2\xdb\x9b\xea\x87\x0e\xad\x1c\x8a\xbc\x46\x36\x4f\xcf\xb7\xb4\x4e\x68\x6e\xc9\x93\xc6\xf6\x0a\xde\x58\x5f\x5b\xdb\xdc\x66\x57\x36\x06\xf7\x9b\x9b\xec\x5c\x98\xf3\xca\xf1\x2d\xf9\xe9\x79\x9e\x33\x99\x5d\xd9\x3c\xa9\xb9\x29\x3f\xc5\xce\x85\x79\x59\xf5\x84\xfa\x96\x09\xed\x8d\x13\x1b\xf2\x33\xcb\x26\x14\xcb\x89\x6a\xad\x2a\x37\x61\x42\xbe\xa9\x2d\x31\xa1\x50\xe4\x35\x13\x72\x81\xca\xda\x30\xab\xd1\xfa\x73\x6d\xb6\x07\xc0\x3c\x00\xbd\x10\x30\x6f\xb2\x84\x57\x54\x94\x2f\x14\x6d\x0f\x66\xe4\xc3\x9c\x7b\xa1\xc6\xbc\xc9\xca\x8e\x88\x18\x35\x29\x62\xd4\x11\x45\x5d\x93\x0a\xc5\xf2\x23\x26\x34\x37\x36\xe6\x50\x99\x14\xa9\x94\x1d\x19\xd1\x53\x57\x2c\xd3\x23\xc7\xe7\x5a\x68\x9d\x16\xfc\xa8\xb6\xfa\x86\xda\x3c\xaf\x37\x99\x7d\x14\x66\x52\x8f\x99\x1c\x15\xce\xa4\x3e\x74\xdd\x51\xb0\xb9\x3e\xcc\xe3\x47\x0d\x8f\xd7\x4f\x2e\x1b\x1e\xc1\x98\x5c\x2c\x97\x1f\x1d\xb5\x6a\x4a\xb7\xca\xa4\xe0\xf1\x45\x43\xae\xa9\xb6\x7e\x02\x1f\x91\x9b\xd0\xde\x96\xe7\x0d\x26\x2b\x1f\x11\xed\xd7\x10\xa9\xf0\x11\xa1\x83\x1a\x4c\x46\x47\xe8\xd9\xd3\x06\x2d\xf8\xc8\x70\x7c\x53\x38\x7e\x64\x74\x7c\x53\x74\xfc\xc8\x70\x7c\x53\xe8\xe0\xa6\xdc\xd4\xe6\xd6\xb6\x96\xe6\xa9\x75\x79\xe2\x35\x4d\x22\xf9\xa6\x49\xf6\x28\x4c\xbe\x19\x93\x1f\x15\x4e\xbe\xd9\x64\xbd\x46\xd5\xb5\x37\x4d\xca\xb5\xb4\x37\x36\xe4\xda\xdb\x7a\x35\x47\x6b\x7c\x74\x68\x43\x4b\x68\xc3\xe8\xa8\x0d\x2d\x51\x1b\x46\x87\x36\xb4\x84\xd9\x71\xe1\xa8\x56\x93\x95\x1d\x17\x71\x63\x6b\xc4\x8d\x63\xa2\xda\xda\xa2\xda\xc6\x84\x6a\xda\x42\x8f\x8c\x09\x96\xb4\x2d\x58\xd2\xb1\xe1\x92\xb6\x87\x4b\x3a\x16\xb3\x6a\xc7\xac\xc6\x86\xb3\x6a\x37\x19\x1b\xdb\x52\xdf\x34\x89\xb5\x07\xb2\xd7\xd8\x6e\x33\x6c\x8f\xd6\xec\xb1\x58\xfa\x76\x7c\x6b\x4e\x88\x58\x3b\x23\x52\x3e\x31\x52\x9e\x55\x2c\xf3\x93\xc2\xb9\x9e\x61\xb2\xc4\x49\xc5\x6d\x7c\x46\xa1\xc8\x1a\x9a\x9b\x26\xb5\x9a\xaf\x76\x45\x66\x28\xf2\x0a\xe4\x0e\x72\x17\xb9\x42\x9e\x44\x9e\x42\x9e\x46\x9e\x41\x9e\x45\x5e\x89\xbc\x0a\x79\x35\xf2\x1a\xe4\x1e\x72\x3f\xcc\xb3\xc0\xcf\x02\x3f\x0b\xdc\x2c\x70\xb3\xc0\xcd\x02\x37\x0b\xdc\x2c\x70\xb3\xc0\xcd\x02\x37\x0b\xdc\x2c\x70\xb3\xc0\xcd\x02\x37\xeb\xb3\x51\x75\xcd\x2d\xfa\x08\x1a\xc8\xb0\xad\x12\x73\xae\x04\x76\x25\xb0\x2b\x81\x5d\x09\xec\x4a\x60\x57\x02\xbb\x12\xd8\x95\xc0\xae\x04\x76\x25\xb0\x2b\x81\x5d\xe9\xb1\xb1\x06\xb3\xbd\x88\x59\x85\xf9\x56\x01\xbb\x0a\xd8\x55\xc0\xae\x02\x76\x15\xb0\xab\x80\x5d\x05\xec\x2a\x60\x57\x01\xbb\x0a\xd8\x55\xc0\xae\x02\x76\x15\xe6\x5d\x05\x7f\x57\xc3\xdf\xd5\xc0\xaf\x06\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x06\xf8\x35\xc0\xaf\x01\x7e\x0d\xf0\x6b\x80\x5f\x03\xfc\x1a\xe0\xd7\x00\xbf\x06\xf8\x35\xc0\xaf\x01\x7e\x0d\xf0\x6b\x80\x5f\x03\xfc\x1a\xe0\xd7\x00\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\xef\x01\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\xbe\x9f\x4d\x54\x06\xd7\x92\xf0\x6b\x9e\x2b\x14\xed\x4a\x2f\xcc\x73\xf9\xf0\x6a\x37\xaa\xb5\x21\xd7\x5a\x17\x96\x9b\x8b\x65\xa3\xc5\x19\x3a\x14\x79\x05\x72\x07\xb9\x8b\x5c\x21\x4f\x22\x4f\x21\x4f\x23\xcf\x20\xcf\x22\xaf\x44\x5e\x85\xbc\x1a\x79\x0d\x72\x0f\x79\xe8\x0d\xa7\x02\xf8\x15\xc0\xaf\x00\x7e\x05\xf0\x2b\x80\x5f\x01\xfc\x0a\xe0\x57\xa4\xcb\x8f\x8b\x5e\xad\x5b\x23\x15\xf4\x80\x25\x15\xb0\xa4\x02\x96\x54\xc0\x92\x0a\x58\x52\x01\x4b\x1c\x58\xe2\xc0\x12\x07\x96\x38\xb0\xc4\x81\x25\x0e\x2c\x71\x60\x89\x03\x4f\x38\xf0\x84\x03\x4f\x38\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x9b\x92\x93\x0f\xd1\x57\xf4\x86\x7c\x6b\x2b\x5a\x60\x81\x0b\x0b\x5c\x58\xe0\xc2\x02\x17\x16\xb8\xb0\xc0\x85\x05\x2e\x2c\x50\xb0\x40\xc1\x02\x05\x0b\x14\x2c\x50\xb0\x40\xc1\x02\x05\x0f\x28\x78\x40\x01\x5f\x01\x5f\x01\x5f\x01\x5f\x01\x5f\x01\x5f\x01\x5f\x01\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x1f\x91\x80\x83\x48\xc0\x41\x24\xe0\x20\x12\x70\x10\x09\x38\x88\x04\x1c\x44\x02\x0e\x22\x01\x07\x91\x80\x83\x48\xc0\x41\x24\xe0\x20\x12\x70\x10\x09\x38\x88\x04\x1c\x44\x02\x0e\x22\x01\x07\x91\x80\x83\x48\xc0\xc9\x02\x1f\x11\x81\x83\x88\xc0\x41\x44\xe0\x20\x22\x70\x10\x11\x38\x88\x08\x1c\x44\x04\x0e\x22\x02\x07\x11\x81\x83\x88\xc0\x41\x44\xe0\x20\x22\x70\xb2\xc0\xc7\x61\xc7\xa9\x04\x3e\xa2\x02\x07\x51\x81\x83\xa8\xc0\x41\x54\xe0\x20\x2a\x70\x10\x15\x38\x88\x0a\x1c\x44\x05\x0e\xa2\x02\x07\x51\x81\x83\xa8\xc0\x41\x54\xe0\x54\x02\xbf\x12\xf8\x55\xc0\x47\x64\xe0\x20\x32\x70\x10\x19\x38\x88\x0c\x1c\x44\x06\x0e\x22\x03\x07\x91\x81\x83\xc8\xc0\x41\x64\xe0\x20\x32\x70\x10\x19\x38\x88\x0c\x1c\x44\x06\x0e\x22\x03\x07\x91\x81\x83\xc8\xc0\x41\x64\xe0\x20\x32\x70\x10\x19\x38\x88\x0c\x1c\x44\x06\x0e\x22\x01\x07\x11\x80\x83\x08\xc0\x41\x04\xe0\x20\x02\x70\x10\x01\x38\x88\x00\x1c\x44\x00\x0e\x22\x00\x07\x11\x80\x83\x08\xc0\x41\x04\xe0\x20\x02\x70\x10\x01\x38\x88\x00\x1c\x30\xba\x03\x46\x77\xc0\xe8\x0e\x18\xdd\x01\xa3\x3b\x60\x74\x07\x8c\xee\x80\xd1\x1d\x30\xba\x03\x46\x77\xc0\xe8\x0e\x18\xdd\x01\xa3\x3b\x60\x74\x07\x8c\xee\x80\xd1\x1d\x30\xba\x03\x46\x77\xc0\xe8\x0e\x18\xdd\x01\xa3\x3b\x60\x74\x07\x8c\xee\x80\xd1\x1d\x30\xba\x03\x46\x77\xc0\xe8\x8e\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\xfb\x72\x52\x4b\x6e\x7a\x5e\x53\xdf\x78\x69\x38\x3d\x28\x99\xcf\xdc\xa1\x8e\x34\x67\x92\x48\x8b\x42\x9e\x44\x9e\x42\x9e\x46\x9e\xe9\x55\xd7\xdc\x3c\x25\x37\xbe\x79\x7a\x74\x54\x25\xf2\x2a\xe4\xd5\xc8\x6b\x90\x7b\xc8\x43\x5f\xb8\xe0\x73\x17\x7c\xee\x82\xcf\x5d\xf0\xb9\x0b\x3e\x77\xc1\xe7\x2e\xf8\xdc\xad\x80\x15\x15\x19\xe4\x59\xe4\xc0\x07\x8b\xbb\x60\x71\x17\x2c\xee\x82\xc5\x5d\xb0\xb8\x0b\x16\x77\xc1\xe2\xae\xe3\x94\x6b\x8e\x1c\x9f\x6f\x68\x9e\x51\x9c\x14\xa8\xdc\x05\x95\xbb\xa0\x72\x17\x54\xee\x82\xca\x5d\x50\xb9\x0b\x2a\x77\x41\xe5\x2e\xa8\xdc\x05\x95\xbb\xa0\x72\x17\x54\xee\x82\xca\x5d\x50\xb9\x0b\x2a\x77\x41\xe5\x2e\xa8\xdc\x05\x95\xbb\x2e\xf0\x5d\xe0\x83\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xa8\x5d\x10\xb5\x0b\x22\x76\x41\xc4\x2e\x88\xd8\x05\x11\xbb\x69\x8f\xb5\x35\x37\x35\xb7\xf6\xaa\xad\xcf\xb7\xe4\x5b\xeb\x5b\x4d\x2d\x51\xd9\x30\xb5\x2e\x67\x8a\x32\xd7\xd4\xdc\x96\x6f\xc8\xd7\xe7\xca\xbd\xa9\xad\xf5\xfa\xf4\x6e\x9a\x85\xd7\x86\xcf\x8f\x6a\x46\xa9\x7c\x54\x63\x7d\x70\xef\x21\xac\x8c\x8d\x74\x4e\x8c\x6a\xcc\x4f\x0a\x3b\xf5\xab\xd7\xdd\xbb\x61\x31\x83\x45\xab\xf2\x6d\x39\x76\x44\x4e\x47\xd2\x36\x70\xe8\x49\xba\x89\x68\x1c\x36\xa6\x4e\x97\x68\x00\xc4\x8e\xce\x4d\x9d\x9a\xe3\x23\x72\x8d\xe3\x6b\x73\xf1\x63\xda\xe3\x23\xdb\xe3\xe3\xea\x6d\x20\xc7\x8f\xad\x27\xa3\xeb\x9a\xd9\x71\xf5\x93\x1a\x73\x64\x4c\xae\xdd\x86\x15\xe4\xd8\xba\x7a\x52\xad\xd3\xb1\xad\xf5\xe5\x47\x45\x2c\xe8\x83\x0e\x5d\xf5\x44\xae\x30\xf1\xf2\x7c\x74\xba\xf9\xae\xe9\xd6\x77\x4d\x77\x40\x7b\xf7\xa1\xe1\x64\xcc\x78\x3a\x3e\x98\xcc\xa4\x60\x32\xac\x36\xdf\xd0\x96\xb3\xa1\x8b\x9e\x11\x4c\x29\xf8\xb0\xcd\x4c\x29\x50\xc6\xa6\x98\x29\x35\x84\x53\x6a\x6a\x8f\xcf\xac\xb7\x9b\xc3\xf9\x90\x96\xba\x66\xde\x1a\x4c\xa6\x82\x99\x8c\xb4\xe9\x39\x01\x97\x4c\xd5\xf3\x99\xa0\x93\xae\xb2\xe6\xc0\xc1\xe5\x51\xdf\xf6\x29\x31\xaf\xbc\x39\xba\x3a\xed\xd1\xd5\x69\x2e\xac\x4e\xb8\x27\x40\x92\x2e\x48\xd2\x05\x49\xba\x20\x49\x17\x24\xe9\x82\x24\x5d\x90\xa4\x0b\x92\x74\x71\x4c\x76\x71\x4c\x76\x71\x4c\x76\x71\x4c\x76\x71\x4c\x76\x71\x4c\x76\x41\xaa\x2e\x48\xd5\x05\xa9\xba\x20\x55\x17\xa4\xea\x82\x54\x5d\x90\xaa\x0b\x52\x75\x41\xaa\x2e\x48\xd5\x05\xa9\xba\x20\x55\x17\xa4\xea\x82\x54\x5d\x90\xaa\x0b\x52\x75\x41\xaa\x2e\x48\xd5\x05\xa9\xba\x20\x55\x17\xa4\xea\x82\x54\x5d\x90\xaa\x0b\x52\x75\x41\xaa\x2e\x48\xd5\x05\xa9\xba\x20\x55\x17\xa4\xea\x82\x54\x5d\x90\xaa\x0b\x52\x75\x41\xaa\xae\x1f\xe2\x2b\x1c\x8c\x15\x0e\xc6\x0a\x07\x63\x85\x83\xb1\x02\x9d\x2a\xd0\xa9\x02\x9d\x2a\xd0\xa9\xc2\xc1\x58\xe1\x60\xac\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x40\xa4\x0a\x44\xaa\x70\x1c\x56\x38\x0e\x2b\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x70\xa8\x02\x87\x2a\x1c\x86\x15\x0e\xc3\x0a\x87\x61\x85\xc3\xb0\x02\xc7\x2a\x70\xac\xc2\x61\x58\xe1\x30\xac\x70\x18\x56\x38\x0c\x2b\x70\xb0\x02\x07\x2b\x70\xb0\x02\x07\x2b\x1c\x86\x15\x0e\xc3\x0a\x87\x61\x85\xc3\xb0\xc2\x61\x58\xe1\x30\xac\x70\x18\x56\x38\x0c\x2b\x1c\x86\x15\x0e\xc3\x0a\x87\x61\x85\xc3\xb0\xc2\x61\x58\xe1\x30\xac\x70\x18\x56\x38\x0c\x2b\x1c\x86\x15\x0e\xc3\x0a\x87\x61\x85\xc3\xb0\xc2\x61\x58\xe1\x30\xac\x70\x18\x56\x38\x0c\x2b\x1c\x86\x15\x0e\xc3\x0a\x87\x61\x85\xc3\xb0\xc2\x61\x58\xe1\x30\xac\x70\x18\x56\x38\x0c\x2b\x1c\x86\x15\x0e\xc3\x0a\x87\x61\x85\xc3\xb0\xc2\x61\x58\xe1\x30\xac\x70\x18\x56\x38\x0c\x2b\x1c\x86\x15\x0e\xc3\x0a\x87\x61\x85\xc3\xb0\xc2\x61\x58\xe1\x30\xac\x70\x18\x56\x38\x0c\x2b\x1c\x86\x15\x0e\xc3\x0a\x87\x61\x85\xc3\xb0\xc2\x61\x58\xe1\x30\xac\x70\x18\x56\x38\x0c\x2b\x1c\x86\x15\x0e\xc3\x0a\x87\x61\x85\xc3\xb0\xc2\x61\x58\xe1\x30\xac\x70\x18\x56\x38\x0c\x2b\x1c\x86\x15\x0e\xc3\x0a\x87\x61\x85\xc3\xb0\xc2\x61\x58\xe1\x30\xac\x70\x18\x56\x38\x0c\x2b\xdc\x26\x57\xb8\x4d\xae\x70\x38\x56\xb8\x4d\xae\x70\x48\x56\x38\x24\x2b\x1c\x92\x15\x0e\xc9\x0a\x87\x64\x85\x43\xb2\x02\xff\x2b\xf0\xbf\x02\xff\x2b\xf0\xbf\x02\xff\x2b\xf0\xbf\x02\xff\x2b\xf0\xbf\xaa\xc9\xc8\xdc\xc4\xfa\xfa\x8a\xa1\x99\xae\x2b\x13\x22\x00\x85\x08\x40\x21\x02\x50\x88\x00\x14\x22\x00\x85\x08\x40\x21\x02\x50\x88\x00\x14\x22\x00\x85\x08\x40\x21\x02\x50\x88\x00\x14\x22\x00\x85\x08\x40\x21\x02\x50\x88\x00\x14\x22\x00\x85\x08\x40\x21\x02\x50\x88\x00\x14\x22\x00\x85\x08\x40\x21\x02\x50\x88\x00\x14\x22\x00\x85\x08\x40\x21\x02\x50\x88\x00\x14\x22\x00\x85\x08\x40\x21\x02\x50\x88\x00\x14\x22\x00\x85\x08\x40\x21\x02\x50\x88\x00\x14\x22\x00\x85\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x89\x08\x20\x09\x46\x4f\x82\xd1\x93\x60\xf4\x24\x18\x3d\x89\x2b\x47\x12\x57\x8e\x24\xae\x1c\x49\x5c\x39\x92\xb8\x72\x24\x71\xe5\x48\xe2\xca\x91\xc4\x95\x23\x89\x2b\x47\x12\x57\x8e\x24\xae\x1c\x49\x5c\x39\x92\xd9\x2e\x1c\xd8\x8d\x2b\x47\x12\x57\x8e\x24\xae\x1c\x49\x5c\x39\x92\xb8\x72\x24\x71\xe5\x48\xe2\xca\x91\xc4\x95\x23\x89\x2b\x47\x12\x57\x8e\x24\xae\x1c\x49\x5c\x39\x92\xb8\x72\x24\x71\xe5\x48\xe2\xca\x91\xc4\x95\x23\x59\xe9\xb3\xd6\xba\xfc\xf4\x5c\x42\x9f\x1d\x72\x13\x5b\xf3\x93\x9a\x1b\xc2\xe2\x54\x2d\xea\xca\x4c\x71\x5a\xae\x31\xd7\xd6\xca\xea\xea\x5b\xea\xa7\xb1\xb6\x56\x1d\x95\x33\xd3\x91\x99\x3e\xbc\xeb\xe3\x66\x7d\x10\x08\x95\x56\x55\xf2\x69\xed\xe3\xdb\xdb\x5a\x79\x6d\x6e\x52\xbe\xb5\x8e\x35\xe6\xdb\xf2\x93\x58\x63\x6e\x5a\x6e\x22\x6d\xc9\x4d\xcc\xeb\x91\xad\xf9\x69\x76\xf0\x27\x88\xc1\x23\xf2\x56\x93\x89\xd6\x66\x8d\xda\xda\x3e\x4d\xb6\x4f\x9d\x9a\x6f\x39\x2d\x68\x6a\x68\x9e\x91\x6f\x09\xde\x99\x30\x7a\xab\x53\x65\x21\xd8\x34\x0d\xdc\x44\x73\x0d\xf9\x89\x44\x1f\x58\xd8\xa4\xfa\xc6\x7c\x03\xab\xd5\xf5\xb6\x78\x5d\x9e\x4c\xcf\x4d\x67\x67\xe4\x66\xd5\x37\x11\x7d\x54\x21\x6d\x3a\xcd\x6a\xae\x15\x13\xeb\x9b\x72\x0d\x53\x72\x13\x89\x4e\x4c\x9b\x9a\x47\x53\x63\xbe\x91\xe8\x14\x56\x9a\xda\x9b\x88\x4e\xbc\x55\x7f\x3e\xa5\x8e\x06\x4a\x6c\xf3\xc1\xd4\x7c\x7c\x6a\x3e\x61\x8a\x6d\xad\xfa\xa8\xc2\x8c\x24\xd3\x9a\xf5\x84\xf4\x0c\x69\x30\x15\x7d\xc6\x99\xce\x35\xf8\xf4\x30\xd3\xa0\x5c\xa7\x20\x9b\x14\x9c\x64\xea\xa4\xce\x5a\xeb\xb4\x4e\xe3\xa6\x8a\x9a\xf0\xbb\xa2\xf3\x0a\xe4\x0e\x72\x17\xb9\x42\x9e\x44\x9e\x42\x9e\x46\x9e\x41\x9e\x45\x5e\x89\xbc\x0a\x79\x35\xf2\x1a\xe4\x1e\x72\x3f\xcc\x2b\x80\x5f\x01\xfc\x0a\xe0\x57\x00\xbf\x02\xf8\x15\xc0\xaf\x00\x7e\x05\xf0\x2b\x80\x5f\x01\xfc\x0a\xe0\x57\x00\xbf\x02\xf8\x15\xc0\xaf\x00\x7e\x05\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x0e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x15\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\x33\xc0\xcf\x00\x3f\x03\xfc\x0c\xf0\x33\xc0\xcf\x00\x3f\x03\xfc\x0c\xf0\x33\xc0\xcf\x00\x3f\x03\xfc\x0c\xf0\x33\xc0\xcf\x00\x3f\x03\xfc\x0c\xf0\xb3\xc0\xcf\x02\x3f\x0b\xfc\x2c\xf0\xb3\xc0\xcf\x02\x3f\x0b\xfc\x2c\xf0\xb3\xc0\xcf\x02\x3f\x0b\xfc\x2c\xf0\xb3\xc0\xcf\x02\x3f\x0b\xfc\x2c\xf0\x2b\x81\x5f\x09\xfc\x4a\xe0\x57\x02\xbf\x12\xf8\x95\xc0\xaf\x04\x7e\x25\xf0\x2b\x81\x5f\x09\xfc\x4a\xe0\x57\x02\xbf\x12\xf8\x95\xc0\xaf\x04\x7e\x25\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\x7e\x15\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\x7e\x15\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\xfb\xc0\x09\x63\xb2\x0a\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\x69\x9f\x9f\x60\x9e\x75\xf2\x19\x61\x76\x42\xf8\x92\xe3\x0c\x93\xc9\x13\xba\x6e\xb0\xcb\x19\x5d\xa5\x70\x1c\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x97\xf5\x64\x65\xd7\xf3\x4a\x99\xeb\x2a\x25\x2a\x0b\x4f\x66\x13\xb9\x42\xb1\x6f\x65\xf1\xa5\x4f\xe3\x86\xbe\xb9\xd2\x86\x48\x0f\xe3\xb6\x68\x0f\xd3\x30\x20\xd2\xa3\xa0\x78\x40\xae\x87\xc6\xa8\x2e\xf3\x64\x39\xaa\xcb\x34\xec\x14\xe9\xd1\x65\xf9\x4e\xb9\xad\xdb\xca\xc2\x97\xc4\xc3\x17\xd2\x72\x91\x72\xd8\x6e\xec\x42\xbb\x29\xf7\x09\xdb\x0b\x96\xf4\xc9\x75\xaf\x63\x9c\xb1\x01\xe3\x4c\xb9\x77\xd8\xde\x05\xdb\x3b\xd7\xad\x2a\xbd\x42\xa9\xd0\x96\xf0\x8a\x7e\x2e\xea\xe7\x5e\xf8\x92\x6f\xa8\xb5\xaf\x57\xea\xe4\x7c\x69\x83\x57\xea\xf5\x7c\xa9\xd7\xbd\x9e\xbc\x9e\xef\xc9\xeb\x5e\xa9\xd7\xf3\xa5\x5e\xf7\x7a\xf0\x7a\x7e\xeb\xb6\xc4\x51\xc5\xb9\xd5\x17\x8a\xf2\xa8\x82\x17\xea\x0b\xa5\x51\x85\x52\x73\x61\xf4\xa8\xe2\xe8\xe6\xa2\x75\xa3\x4a\xa7\xde\x5c\xda\x30\xaa\xd4\x17\xcd\xa5\xbe\x18\xd5\x93\x2f\x9a\x7b\xf2\xc5\xa8\x52\x5f\x34\x97\xfa\x62\x54\x0f\xbe\x68\xee\xc1\x17\xe6\x05\xe0\xf0\xc5\xc9\xe6\x62\xd1\xb4\x1a\xa3\xc2\x56\x53\xec\x6d\x5a\x0b\x46\xf4\x6e\xee\x56\x0d\xc7\x18\xf0\x70\x8c\x29\xf6\x32\xad\x5d\x68\xbd\x9a\xa3\x35\x39\xb6\x50\x6a\x2f\xd8\x33\xb6\xa8\xb0\xbd\x58\x1c\x5b\x34\xad\xbd\x58\x1c\x5b\xb4\xb2\xbd\x68\xe5\xd8\xee\x56\xb6\x77\xb7\x72\x6c\xd1\xca\xf6\xa2\x95\x63\xbb\x59\xd9\x1e\xad\xf1\x13\xc3\xcb\xec\x2c\x93\xc9\x13\x0b\x36\xcf\x2a\xd8\x7c\x62\x51\xfd\xac\xe2\x77\xe5\xc4\xf0\xbb\x32\x2b\x7c\x21\x3e\xb8\xa6\xf9\x88\xd9\x7c\xc4\x6c\x3e\x62\x36\x1f\x31\x9b\x8f\x98\xcd\x47\xcc\xe6\x23\x66\xf3\x11\xb3\xf9\x88\xd9\x7c\xc4\x6c\x3e\x62\x36\x1f\x31\x9b\x8f\x98\xcd\x47\xcc\xe6\x23\x66\xf3\x11\xb3\xf9\x88\xd9\x7c\xc4\x6c\x3e\x62\x36\x1f\x31\x9b\x8f\x98\xcd\x47\xcc\xe6\x23\x46\xf3\x11\xa3\xf9\x88\xd1\x7c\xc4\x68\x3e\x62\x34\x1f\x31\x9a\x8f\x98\xcc\x47\x4c\xe6\x23\x26\xf3\x11\x93\xf9\x88\xc9\x7c\xc4\x64\x3e\x62\x32\x1f\x31\x99\x8f\x98\xcc\x47\x4c\xe6\x23\x26\xf3\x11\x93\xf9\x88\xc9\x7c\xa7\x0b\x0f\xf3\x43\x4c\xe6\x23\x26\xf3\x11\x93\xf9\x88\xc9\x7c\xc4\x64\x3e\x62\x32\x1f\x31\x99\x8f\x98\xcc\x47\x4c\xe6\x23\x26\xf3\x11\x93\xf9\x88\xc9\x7c\xc4\x64\x3e\x62\x32\x1f\x31\x99\x8f\x98\xcc\x47\x4c\xe6\x23\x26\xf3\x11\x93\xf9\x88\xc9\x7c\xc4\x64\x3e\x62\x32\x1f\x31\x99\x8f\x18\xcc\x47\x0c\xe6\x23\x06\xf3\x11\x83\xf9\x88\xc1\x7c\xc4\x60\x3e\x62\x2e\x1f\x31\x97\x8f\x98\xcb\x47\xcc\xe5\x23\xe6\xf2\x11\x73\xf9\x88\xb9\x7c\xc4\x5c\x3e\x62\x2d\x1f\x31\x96\x9f\xec\xd2\x0b\xfb\x11\x53\xf9\x88\xa9\x7c\xc4\x54\x3e\x62\x2a\x1f\x31\x95\x8f\x98\xca\x47\x4c\xe5\x23\xa6\xf2\x11\x53\xf9\x88\xa9\x7c\xc4\x54\x3e\x62\x2a\x1f\x31\x95\x8f\x98\xca\x47\x4c\xe5\x23\xa6\xf2\x11\x53\xf9\x88\xa9\x7c\xc4\x54\x3e\x62\x2a\x1f\x31\x95\x8f\x98\xca\x47\x4c\xe5\x23\xa6\xf2\x11\x53\xf9\x88\xa9\x7c\xc4\x54\x3e\x62\x2a\x1f\x31\x95\x8f\x98\xca\xc7\x59\xdd\xc7\x59\xdd\xc7\x59\xdd\xc7\x59\xdd\xc7\x59\xdd\xc7\x59\xdd\x47\x0c\xe5\x23\x86\xf2\x11\x43\xf9\x88\xa1\x7c\xc4\x50\x3e\x62\x28\x1f\x31\x94\x9f\xe9\xc2\xc3\x7c\x11\x43\xf9\x88\xa1\x7c\xc4\x50\x3e\x62\x28\x1f\x31\x94\x8f\x18\xca\x47\x0c\xe5\x23\x86\xf2\x11\x43\xf9\x88\xa1\x7c\xc4\x50\x3e\x62\x28\x1f\x31\x94\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\xb3\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\x33\xba\x8f\xb3\xb9\x8f\xb3\xb9\x8f\xb3\xb9\x8f\xb3\xb9\x8f\xb3\xb9\x5f\x0d\xdc\x6a\xe0\x56\x03\xb7\x1a\xb8\xd5\xc0\xad\x01\x6e\x0d\x70\x6b\x80\x5b\x03\xdc\x1a\xe0\xd5\x00\xaf\x06\x78\x35\xc0\xab\x01\x5e\x0d\xf0\x6a\x80\x53\x03\x9c\x1a\xe0\x78\xc0\xf1\x80\xe3\x01\xc7\x03\x8e\x87\xf9\x79\x58\x57\x0f\xb8\x1e\x70\x3d\xe0\x7a\xc0\xf5\x80\xeb\x01\xd7\xc3\x3c\x3d\xe0\x7b\xc0\xf7\x80\xef\x03\xcf\x07\x9e\x0f\x3c\x1f\x38\x3e\x70\x7c\xe0\xf8\xc0\xf1\x81\xe3\x03\xc7\x07\x8e\x0f\x9c\xf0\x1e\x88\x33\x34\xe4\x51\x9d\x57\x20\x77\x90\xbb\xc8\x15\xf2\x24\xf2\x14\xf2\x34\xf2\x0c\xf2\x2c\xf2\x4a\xe4\x55\xc8\xab\x91\xd7\x20\xef\xc2\xf5\xc3\xbc\x02\x78\x15\xd0\x5f\x91\xea\x65\xfe\x05\x3c\xf3\x47\xa1\xb5\xe3\x1b\x7a\x4d\x6b\x6f\x0e\xfe\x81\xd5\xe0\xef\x44\xf3\xb5\xe8\x83\xb1\x0e\xb0\x1c\x60\x39\xc0\x72\x80\xe5\x00\xcb\xf1\x79\x63\x7d\x93\xf9\x53\xbd\xfc\x84\xe6\x26\x68\x71\x95\xcc\xcf\x9c\xd0\x90\x6b\xd4\x28\xb2\x25\x57\x1b\xfc\x5b\x8e\xf9\x99\xe1\x67\x49\x8c\x4c\x01\x21\x05\x84\x14\x10\x52\x40\x48\x75\xf5\xf3\xcb\x27\x36\xb7\xb7\xb4\xb6\x4f\xcd\xb7\xd4\x37\xb7\x94\x4f\xac\x9f\x9e\xef\xaa\xf4\x6a\xd5\xc6\x37\x15\x6a\xf9\xe0\x1f\x39\xee\xaa\xc9\x42\x7b\xa8\x27\x8b\xd5\xc8\x62\x35\xb2\xf0\x4e\x16\xab\x91\xc5\x6a\x54\xa2\x5f\x25\xfa\x55\x3a\xb4\xa1\xbe\x25\x87\x0a\x5c\x59\x99\xe2\x53\xf3\xad\xf9\xb6\xae\x66\xac\x54\x65\x96\xb7\xd6\xe5\xa7\xe5\x1b\x68\x6d\x73\xd3\x24\x1a\xfc\xdb\x92\xf8\x00\x93\xaa\xc4\xa4\x2a\xe1\xe6\x2a\x80\x55\x01\xac\x0a\x46\x55\xc1\xa8\x2a\x18\x55\x05\xdc\xf0\x11\xab\x53\x81\x2d\x53\x11\x86\x44\x3a\x4f\x21\x4f\x93\x51\x75\x8d\x32\xdf\xda\x56\xdf\x98\x6b\xc3\xa2\x56\x84\xc4\xac\x73\x4f\x34\x37\xe5\xdb\xea\xea\x5b\x6a\x65\xdb\x8c\x66\x53\x68\x95\xba\xc9\x38\xae\xae\xbc\xad\xae\x25\x8f\x72\x6b\x59\xe0\x67\x94\xcb\x8d\x9b\x51\x09\x55\x65\x94\xcc\xb5\xb4\x34\xcf\x68\xc8\x4f\x6c\xb3\x4d\xa9\x7d\x6a\xc2\xe4\xe6\x5f\x9a\x0e\x3f\xac\x6d\x9e\xd1\x14\x96\xc6\x6b\x30\x89\x6e\xb5\x4d\xe5\x85\xd2\xf8\x56\x13\x73\x3a\xf8\x33\x25\xc7\xa9\x48\x26\x9a\x5b\xda\xea\x82\xbf\xa4\xcc\x35\x94\xd7\x37\xb5\x05\x7b\xd3\xfc\x13\xbe\x65\xf9\x69\xed\xf5\xd3\xf5\x3e\x6a\x9a\x90\x67\x75\xcd\xed\xad\xf9\x5e\x7a\xeb\x36\x34\x4f\x0a\x36\x57\x53\x73\x5b\x22\xe8\xac\xa3\xdf\x86\xb6\xa9\x85\xe2\x78\xf3\xf0\xce\xc1\x93\x61\x07\x4f\x84\x1d\x3c\xc9\x75\xf0\xc4\x56\xe7\x0a\x79\x06\x39\x3e\x77\xd0\x8e\xdd\x9f\x74\x51\x77\x51\x4f\x62\x7c\x18\xe9\xe8\x1c\xfa\xc3\x48\x47\xe7\xe8\x1f\x46\x3a\x3a\x4f\x21\x4f\x23\x07\x5e\x18\xf1\xe8\xbc\x12\x79\x15\xf2\x2e\x9c\x1a\xe4\x1e\xf2\x70\xfb\x24\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x1f\xdf\xc9\x24\xbe\x93\xc9\xe0\x3b\x39\x75\x7c\x43\xf3\x84\x29\xb6\x5e\xab\x20\x67\x61\xad\x61\x62\x98\xb7\xb4\xa1\xde\xd6\x5a\x97\xab\xcd\x33\x23\xed\xda\x29\x26\x97\x13\xeb\x1b\x1a\xf4\x85\xa6\x39\xfc\xe6\xe3\xf9\xb2\x83\xe7\xc3\x3a\xaf\x4a\x84\x3d\x5a\xf4\x0a\xdb\x6d\x2d\xf5\xb9\x49\xed\x53\xc3\xbc\x05\xf5\xda\xa6\x30\x6f\x98\xc8\x83\x53\x61\x43\xb8\x5b\x92\xd5\xf0\x4b\xb5\x2f\xeb\x9b\xa6\x8f\x6f\xd7\x4a\xda\x82\x52\xd8\x27\xd1\x3c\x35\xdf\x84\xc6\xd6\xc6\x7a\xbd\x45\x73\x13\xf2\x7a\x2f\x4d\x2f\x54\x48\x6b\x7b\x13\x9f\x98\x6f\xd4\xbb\x89\x06\x82\xb5\x4e\xd5\xf6\xd2\x09\x0d\xed\xe3\x59\x5d\x3e\xa7\xd1\x6b\xeb\x73\x8d\xfa\x72\x56\xd6\xd8\xde\x8a\xfd\x95\xef\x1d\x29\xeb\xeb\x9a\xb1\x20\x15\xc6\x84\x4e\x35\x56\xa2\x1a\x2b\x51\x8d\x95\xa8\xc6\x4a\x54\x63\x25\xaa\xb1\x12\xd5\x58\x89\x6a\xac\x44\x35\x56\xa2\x1a\x2b\x51\x8d\x95\xa8\xc6\x4a\x54\xe3\xea\x58\x8d\xab\x63\x75\x1a\x38\x69\xe0\xa4\x81\x93\x06\x4e\x1a\x38\x69\xe0\x84\xb1\xa7\x83\xfb\xda\x95\xe9\x42\x9e\x41\x9e\x45\x5e\x89\xbc\x0a\x79\x35\xf2\x1a\xe4\x1e\x72\x3f\xcc\xc3\xb3\x94\xce\x2b\xc2\x3c\x03\x7d\x19\xe8\xcb\x40\x5f\x06\xfa\xc2\x58\x53\x87\x54\x15\xc8\x9d\x30\x0f\xf5\xeb\xdc\x2b\x0f\x9f\x5b\x9f\x66\x1e\xf0\xf7\xd1\x5f\xe7\xbc\x3e\x48\x07\xff\x76\x70\xf0\x40\x5c\x04\xcf\xdd\x67\xd4\xeb\xbd\x65\x9e\xb8\x07\x25\x5e\x97\x0f\x32\x7b\x4a\x2e\xfc\xc0\x3c\x5e\x0f\x4a\xe5\x5d\x8f\xd8\x83\x8a\x08\x1e\x82\x9b\x7e\x6d\xb9\xe9\xe6\x53\xad\xf9\xb4\xa9\x0d\xed\xad\xc1\x3f\x4b\x5b\x16\x3c\x42\xc7\x1b\x01\x09\x53\x36\xc5\x7e\xa6\xc9\xbc\x46\x80\x0f\xfb\x46\x5a\x4c\x83\x0c\x0c\x32\xa6\x26\x82\x52\xf8\x8a\x80\x69\x6c\xcc\x4d\xad\x9f\x26\xc7\xe7\xdb\xc2\xee\x65\xe6\x45\x01\x94\x8d\xf1\x61\x59\xd4\xe5\xc3\x82\x9c\x9e\x9b\x8e\x8f\xcd\x0b\x04\x68\x6d\xeb\xea\x28\xb5\x53\xc2\x52\xef\xae\xd7\x09\xf0\x41\xa1\x54\x66\xe6\x8e\x56\x3d\x71\x94\x9a\xda\xa1\xac\x3c\x7c\xb5\x20\xac\xf4\xc2\xbb\x05\x30\xa3\xab\x50\x66\x5e\x2e\xc0\xc8\x69\xcd\xd0\x9c\x08\xdc\x87\x62\xd1\x05\xb2\xad\xcb\x64\xa1\x8d\x0f\x5f\xc2\xd0\x13\x0e\xde\xb2\x08\x96\x23\xc8\x35\x4d\x06\x99\xf1\x88\xb1\xce\x2c\x33\x1e\x8b\xf8\x78\x2c\xe2\xe3\xb1\x88\x8f\xc7\x22\xbe\x0e\xa9\xca\x22\x7f\x1f\x2a\xcd\x8d\xc0\x43\x26\xcc\x6a\xe9\x6b\xfe\x9e\x3f\xf2\x51\xbf\x48\xb9\x25\x78\xc9\x3c\x2f\xcc\x1d\x90\x43\xda\x27\x08\x73\xfb\x45\x17\x7a\x15\x6f\x28\x05\xcd\x46\x85\x2e\x94\x75\xdd\x79\x0e\x1a\xcd\xed\x0f\x5d\xe8\x13\xfd\xcb\xfe\xe0\x83\x10\xba\x7d\x42\x22\x54\xab\x77\x4d\x45\xb1\xe8\x14\x8b\x6e\x22\x84\x33\x1d\x0a\x45\xa7\x58\x74\x7b\x17\x6e\xba\x98\x4e\xdd\xab\x4e\xf7\xaa\x9b\x08\x0d\x32\xda\x0a\x45\x27\x11\x5a\x13\xb4\xf6\x89\x4c\x2a\xa8\xf7\xea\xba\xcf\x53\x62\x81\x2a\x16\x93\x45\x6b\x55\xb1\x98\xec\x8e\xac\xba\x57\x93\x45\xf4\x88\x4d\xaa\x58\x8c\x74\x48\x15\x8b\xe9\x62\x31\xd3\xcd\x32\xa7\x5b\xcd\xed\x56\x53\xdd\x6a\xc9\x6e\xb5\x88\xee\x6c\xb7\x0f\xd2\xdd\x6a\xdd\xc1\xb2\xbd\xbb\x39\x65\x68\xf7\x6a\x45\xf7\xaa\xd3\xbd\xea\x76\xaf\xaa\xee\xd5\x64\x59\x71\x7d\x86\x46\xca\x15\x91\xb2\x13\x29\x9b\x89\x06\x7f\xf8\x5b\x1f\x2e\x9e\xde\xe4\xc1\x1f\x70\x05\x7f\xe4\x75\xc8\x84\xdc\xd4\x48\xbd\xa2\xa4\x5e\x5d\x52\x1f\x1a\xa9\xa7\x4b\xc6\xbb\xdd\xea\x8e\x97\x44\x4a\x95\xd4\xd3\x25\xf5\x4c\x49\x3d\x1b\xa9\xa7\x82\xbc\xa4\x9e\x2a\xa9\xa7\x4b\xea\x99\x92\x7a\xb6\x2c\x52\x8f\x7c\x96\x2e\xd1\x9d\xee\xe1\xf3\x74\x49\x3d\x53\x52\x8f\xea\x8e\xf6\xcd\x94\xe8\xce\x94\xe8\xce\xf4\xd0\x3f\x53\x52\x8f\xea\x8e\x7e\x96\x2d\xd1\x9d\x2d\xd1\x9d\x2d\xd1\x9d\xed\x61\x7c\x54\x77\x97\xbf\x53\x5d\x6b\x50\x52\x4f\x95\xd4\xd3\x25\xf5\x4c\x49\xbd\x4b\x77\xaa\x44\x57\x4f\xf5\x74\x49\x3d\x53\x52\x8f\xda\x96\x2e\x19\x9f\x2e\xb1\x2d\x5d\xa2\x2f\x5d\xa2\x2f\x5d\x62\x5b\xb4\x6f\xa6\x44\x77\xa6\x44\x77\xa6\x87\xfe\x99\x92\x7a\x54\x77\xf4\xb3\x6c\x89\xee\x6c\x89\xee\x6c\x89\xee\x6c\x0f\xe3\xa3\xba\xbb\x7c\x92\x2e\x59\xaf\x74\xc9\x7a\xa5\x4b\xd6\x2b\x5d\xb2\x5e\xe9\x92\xf5\x4a\x97\xe8\x4a\xf5\x50\x4f\x95\xd4\xd3\x25\xf5\x4c\x49\x3d\xaa\x3b\x3a\xb6\x14\xab\xa7\xcf\x33\x25\xf5\xe8\xbc\x33\x25\xe3\x33\x25\xe3\x33\x25\xb6\x65\x4a\xf4\x65\x4a\x6c\x8b\x7e\x96\x2d\xd1\x9d\x2d\xd1\x9d\x2d\xd1\x9d\xed\x61\x7c\x54\x77\x97\xdd\x99\x92\xf5\xca\x94\xac\x57\xa6\x64\xbd\x32\x25\xeb\x95\x29\x59\xaf\x4c\x89\xae\x54\x0f\xf5\x54\x49\x3d\x5d\x52\xcf\x94\xd4\xa3\xba\xa3\x63\xd3\x25\xba\xd3\x3d\x7c\x9e\x2e\xa9\x67\x4a\xea\x51\xdd\xd1\xbe\xa5\xf3\x28\xc5\xee\xa9\x7f\xd4\xa7\xd9\x92\xf1\xd9\x92\xf1\xd9\x92\xf1\xd9\x12\xdb\xb2\x25\xb6\x75\xe9\xce\x96\xac\x57\xb6\x64\xbd\xb2\x25\xeb\x95\x2d\x59\xaf\x6c\xc9\x7a\x65\x4b\x74\xa5\x7a\xa8\xa7\x4a\xea\xe9\x92\x7a\xa6\xa4\x1e\xd5\x1d\x1d\x9b\x2e\xd1\x9d\xee\xe1\xf3\x74\x49\x3d\x53\x52\x8f\xea\x8e\xf6\xcd\x94\xe8\xce\x94\xe8\xce\xf4\xd0\x3f\x53\x52\x8f\xea\x8e\x7e\x56\xea\xa3\xd2\x79\x95\xda\x12\x8e\xd7\xa1\xb9\x3e\xc9\xd7\x4f\x38\xad\xb9\x2d\xf8\x51\x26\xc4\x23\xaa\x24\x5e\x51\x25\xf1\x8d\xdb\x43\x3d\x13\xa9\x57\x04\x31\x4e\xa4\x5e\x5d\x52\x57\x5d\xfd\xcb\xc7\xe7\x5a\xea\xbb\xfe\x6d\x95\x9d\xcc\x87\x55\x15\x61\x87\x8a\x40\xe9\xd0\x1e\xda\x2a\x4a\xda\x54\x0f\xfd\x54\x49\xbf\x54\x0f\xfa\x52\x3d\xe8\x4b\xf5\xa0\x2f\x55\xa2\x2f\xdb\x83\x7d\xd9\x1e\xec\xcb\xf6\x60\x5f\xb6\x07\xfb\xb2\x3d\xd8\x97\xed\xc1\xbe\x6c\x0f\xf6\x65\xb7\xb6\xaf\x3a\xb9\xb5\x7d\xdd\xda\x4a\xfb\xa9\x1e\xfa\x95\xea\x4b\xf5\xa0\x2f\xd5\x83\xbe\x54\x0f\xfa\x7a\xf2\x5f\xa6\x6b\x93\xf5\xd0\x56\xda\x2f\xd5\x43\xbf\x54\x09\x6e\x89\xbe\x6e\x6d\xa5\xfd\x52\x3d\xf4\x33\xfa\x82\x7f\xbf\xa0\x2d\x5f\x5b\x6f\xce\x5d\xc2\x6b\x9a\x64\x42\xfe\xae\x82\xd3\x55\x70\xc5\x19\xf9\x96\xe6\xa0\x64\x37\x37\x99\x53\x82\xdd\x36\xc3\xd4\xa5\xb9\x0f\x1b\x94\x44\x70\xe7\x3b\x2c\xd4\x87\xe7\x31\xbb\xb5\xde\x9c\xf7\xa4\xb9\x25\x6b\x4a\xe6\xbe\xac\xe9\xd4\x54\x1f\x2a\xea\x53\xf2\x52\x47\x9f\x92\x57\x38\x7a\x77\x7f\x59\xa3\x4f\xc9\x5b\x19\x89\xe2\x2b\x3e\x89\xe2\x5b\x3d\xb2\xf0\x12\x4f\xa2\xf8\xca\x4e\xff\x12\xa4\x43\x1a\x26\xf4\x2f\x01\xd3\x4d\xfd\xba\xe3\x75\xef\x14\x1e\x92\x1a\x26\xf4\x2a\xa2\x16\x6a\x5d\x0a\xca\x0b\xd8\x85\x8f\x0a\xc3\xda\xc3\x47\x3a\x87\xb4\xd6\x35\xb7\xb4\x95\x99\x3f\xc8\x0e\xcb\x7d\xcd\xfd\x06\x73\x57\x02\x77\x2e\x8a\x0d\x85\x5b\x28\xe1\x0d\x9b\x5e\x5d\x55\xf3\xf7\x28\x3b\x15\x6e\x56\x14\xff\x30\xa5\x77\xa1\xad\xa4\x6a\xfe\x26\xa5\x6f\xe4\x36\x95\x69\x35\x37\x83\x70\x43\x25\xd8\x22\x49\x7d\x09\x48\x56\xd5\xa0\xec\x44\xca\x6e\x50\xa6\xc7\x9d\x56\xe5\x69\x31\x26\x10\xc7\x7a\xe1\xaf\x7a\x0a\x2b\x6e\x25\xac\x58\x67\x67\xf0\x7b\x95\xe6\x37\x36\x2d\x6b\xa6\x35\xc7\xfc\x8a\x50\x3f\xcb\xa2\x8b\xac\x18\x7d\x8c\x7e\x64\x11\xfa\x31\xfd\x58\x97\x3f\xa1\x9f\xe8\xf2\xa7\xf4\x53\x5d\xfe\x8c\x7e\xa9\xcb\x5b\xe8\x16\x5d\xee\xa4\x5a\x03\xb3\xc4\xa3\x56\x4c\x2c\x14\x0b\x2d\x22\x16\x89\x8d\xba\xfc\xa1\xf8\xd0\x8a\x8b\x4d\x89\x7e\x56\x2c\xd1\x3f\x31\xc0\x8a\x07\xff\xb2\xa8\x2e\xef\x9a\x18\x64\x91\xc4\xe0\x44\xf0\xdb\xa1\x34\xfc\xcd\x22\x83\xdf\x95\x12\xd6\x78\xeb\x6a\x8b\xea\x4b\x7e\x83\x35\x78\x52\x4b\x7e\x8a\xe5\xd4\xe5\xc7\xb7\x58\x87\x35\xe4\xda\x9a\x82\xdf\x40\xb2\xe2\xc7\x1c\x5d\xb3\x97\xd5\xf7\xb8\xd1\x55\x5a\x5a\x96\x9e\x41\xcc\xfc\xa2\x91\x85\xb2\x55\x28\xc7\xcd\xaf\x1d\x75\xfb\x64\xc2\x84\xc6\xa9\xd6\x60\x23\xf7\xaa\x6d\xa8\x9f\x64\xed\xdf\xd0\x3c\x21\xf8\xa5\x25\xab\x60\x4f\xf0\xfb\x48\x41\xad\xcb\x22\xae\x7d\xb3\x8b\xb5\x87\xb5\x9f\xee\x95\x42\xeb\x50\xdd\x37\xe8\xe1\x23\x3f\x5e\xf7\xd2\x79\x7c\xa0\xd1\x11\x8b\x8f\x0e\xdb\xed\xfb\xb4\xb6\xbe\x16\x4b\x0c\xb6\xde\xb5\x86\x27\x86\x24\x76\xd3\xad\x8c\xac\x32\xbf\x02\xb1\x81\x7c\xa8\x6b\xfd\x75\x12\x01\x76\xe0\x2f\x56\x1e\x8c\x62\x5a\x43\xec\x5a\x6b\x90\x95\xb1\xaa\xf4\x8c\x8f\xb7\x4e\xb7\x26\x5b\x6d\xd6\x6c\xeb\x42\x6b\xae\x75\xa3\x75\xbb\x75\xbf\xf5\xb2\xb5\x46\x77\x4c\xc4\x06\xc4\xf6\x88\xed\x1f\x73\x62\xc3\x62\x7e\xec\xd8\xd8\x95\x81\x9e\xc4\xae\x56\x5c\xaf\x5b\x50\x1a\x58\x28\x0d\x2a\x94\x76\xd1\xa5\x4d\x06\xef\xe5\x42\x69\x79\xa1\xb4\xa2\x50\x7a\xc5\x94\xe2\x7a\x5e\xe5\xe2\x7d\x5d\xfe\x40\xbc\x5a\xf8\xec\xb5\x42\x69\x65\xa4\xd7\xeb\x41\x59\xef\x83\x38\x5d\x6f\xf6\x57\x6f\x6b\x80\x5e\xfd\x38\x5d\x97\xe8\xab\xe5\x06\xb1\xaa\x30\x6a\xb5\x29\x05\x7d\xfa\x5a\xbb\x24\x7a\xeb\xbd\xb4\x89\x7e\x90\xe8\x63\x50\xd6\x14\x7a\xad\x2d\x94\xde\x28\x94\xde\x2c\x94\xd6\x15\x4a\x6f\x15\x4a\x6f\x17\x4a\xef\x14\x4a\xeb\x4d\xc9\xd6\x48\x03\xcd\xef\xa1\x0e\xd5\x6b\x38\x4c\x3c\xaf\x31\x37\x6b\x6b\x9f\x37\xd8\x9b\xc5\x32\x9d\x7f\xa6\xeb\xcb\x4c\xfd\x33\xf1\xae\x99\xcb\x73\x5a\x6e\x16\xcf\x6a\xf9\x99\xd1\xf5\x1e\x66\x6b\xd3\xb7\xe8\x3b\xc1\x4f\xe0\x32\xae\xf7\xbe\xd0\xab\x96\x60\xbd\x59\x6f\xcb\xfc\x0a\x83\xd5\x37\xf8\x15\x06\xab\x3f\xdb\x85\x0d\xb6\x06\x98\xbd\x14\xd7\xf9\xde\x5a\xc3\xc1\x66\xf7\xb0\x60\x0f\x98\xdf\x73\x28\x63\x03\xd8\xee\xc1\xee\x35\xbf\xff\xf0\x49\xb0\xf3\x74\xfb\xee\x96\x25\x2e\x11\x97\x58\x7b\x88\xc7\xc5\xd3\xd6\x9e\x7a\x3f\x4c\xd6\x63\xfa\xc6\xf6\x8e\x2b\xe2\xd3\x71\xd6\x10\xeb\x50\xbd\x2f\x86\x5b\xa3\xad\x93\xf4\x77\x65\xb2\xd5\x62\x9d\x61\x9d\x6b\x5d\x64\x5d\xa9\x77\xc7\x0d\xd6\x7c\xab\xc3\xba\xc7\x7a\xd0\x7a\xdc\x7a\x46\xef\x92\x55\xd6\xdb\xd6\x46\x6b\xb3\xde\x2b\x3c\x56\x2e\x8f\xb3\x48\xfc\xd6\xf8\xad\x72\xb4\xc9\xe7\xcb\x1f\x98\xfc\x16\x79\xac\xc9\xe7\xc9\x51\x26\xbf\x59\x1e\xa3\xf3\xf9\xba\xdf\x08\x93\xcf\x97\x47\x9b\xfc\x16\x39\xdc\xe4\xf3\xe4\x51\x26\xbf\x59\x1e\xa1\xf3\x5b\x74\x3f\xdf\xe4\xf3\xa5\x67\xf2\x5b\x64\x8d\xc9\xe7\xc9\x6a\x93\xdf\x2c\x2b\x75\x3e\x4f\xf7\x3b\xdc\xe4\xf3\xe5\xf7\x4d\x7e\x8b\x3c\xcc\xe4\xf3\xe4\xf7\x4c\x7e\xb3\x1c\xa6\xf3\x9b\x75\xbf\xef\x9a\x7c\xbe\x3c\xd4\xe4\xb7\xc8\xac\xc9\xe7\xc9\x91\x56\x5c\xb7\x8e\xd1\xf2\x56\x59\xa5\xe5\x3c\x79\xa4\x96\xb7\xfc\x1b\x1e\x69\x86\x47\x9a\xe0\x91\x46\x78\xa4\x01\x1e\x99\x02\x8f\xd4\xc3\x23\x75\xf0\xc8\x24\x78\x64\x22\x3c\x92\x87\x47\x26\xc0\x23\xe3\xe1\x91\x1c\x3c\x72\x3a\x3c\x72\x1a\x3c\x72\x2a\x3c\x72\x0a\x3c\x72\x32\x3c\xf2\x43\x78\xe2\x44\x78\x62\x1c\x3c\x71\x02\x3c\x71\x3c\x3c\x31\xd6\xe4\x37\xcb\xa9\xc6\x17\xb5\x81\x17\xe4\x49\x5a\xde\x2c\x27\x07\x3e\xfa\x37\x3c\xf2\x33\x78\xe4\x22\x78\xe4\xa7\xf0\xc8\x85\xf0\xc8\x05\xf0\xc8\x4f\xe0\x91\xf3\xe0\x91\x1f\xc3\x23\xe7\xc2\x23\x3f\x82\x47\xe6\xc0\x23\xe7\xc0\x23\xb3\xe1\x89\xb3\xe1\x89\x33\xe1\x89\x33\xe0\x89\x59\xf0\xc4\x4c\xec\x8d\x19\xf0\x48\x3b\x3c\xd2\x06\x8f\xb4\xc2\x23\x2d\xf0\xc8\x34\x78\xe4\x7c\xb3\x47\x2e\x36\x7e\x99\x6e\x3c\x72\x56\xb0\x53\xfe\x0d\x8f\xdc\x0c\x8f\xdc\x04\x8f\xfc\x01\x1e\xb9\x11\x1e\xf9\x3d\x3c\x72\x03\x3c\xf2\x3b\x78\xe2\x7a\x78\xe2\xb7\xf0\xc4\x6f\xe0\x89\x6b\xe1\x89\x5f\x63\x6f\xcc\x85\x47\x7e\x05\x8f\xfc\x12\x1e\xb9\x1a\x1e\xf9\x05\x3c\x72\x15\x3c\xf2\x73\x78\xe4\x0a\x78\xe4\x72\x78\xe4\x32\x78\xe4\x52\x78\xe4\x12\x78\xe4\x3a\xb3\x3b\xe6\x19\x8f\x5c\x69\x3c\x72\xcd\xbf\xe9\x91\x87\xe1\x89\x87\xe0\x89\x07\xe1\x89\x07\xe0\x89\x7f\xc2\x13\xf7\x61\x6f\xfc\x03\x1e\xb9\x17\x1e\xf9\x3b\x3c\xf2\x37\x78\xe4\x6e\x78\xe4\xaf\xf0\xc8\x5d\xf0\xc8\x5f\xe0\x91\x3b\xe1\x91\x0e\x78\xe4\xcf\xf0\xc8\x1d\xf0\xc8\x9f\xe0\x91\x3f\xc2\x23\xb7\xc1\x23\xb7\xc2\x23\xf3\xe1\x91\x5b\xe0\x91\x7b\x8c\x47\xee\x37\x3b\xe5\x76\xe3\x91\x05\xc6\x23\x3a\x5e\x08\xc6\x1b\x86\x1f\x1e\x5c\x73\xf5\x55\xfb\x60\xcd\x17\x87\x83\xe1\x5e\x34\x3c\xf6\x82\x96\xef\x1b\x3e\xd8\xa0\x4b\x9f\x98\xd2\x07\x85\xd2\xc6\x42\x69\x11\xfa\x45\xaf\xf5\xc5\x18\xe7\xa6\xed\xc4\x38\x7d\x7b\x8c\x71\xac\x1d\x8c\x71\xc8\x14\x1d\x2c\x5a\x03\x8c\x1c\x1c\x9c\x97\x35\xef\x05\xb8\xfd\x80\x6e\x69\x8d\x5f\xf5\x2b\x90\x83\xf5\xac\x0f\xd3\xd1\xcd\x48\x1d\x7d\x9c\x6a\x4d\xb4\x9a\xac\xb3\xf4\xce\xb8\x46\x5b\x7d\xbb\x75\x97\x75\x9f\xf5\x9c\xf5\xaa\xb5\x45\xef\x85\xde\xb1\x5d\x74\x04\xb2\x5f\xec\x90\x58\x2a\x76\x98\xd6\x29\x75\xe4\xd2\x37\x8c\x7d\xc4\x40\x13\xd7\xc4\x12\x77\xeb\xba\xad\xf3\x35\x61\x7b\x59\x02\xf9\xcb\x61\xde\x6f\x6e\x18\xff\xec\xfa\xe8\xc0\x81\x03\x27\x0f\xbc\x37\xac\x0d\xb2\x06\xcd\x1c\xb4\x79\xf0\x59\x61\x6d\xf0\x1b\xbb\x65\x76\xbb\x68\xb7\x15\x61\x6d\xc8\x5e\x43\x6e\xd8\x7d\xf0\xee\xd7\x86\xe3\xf7\xe0\x61\xbe\xd7\x7d\x61\xbe\xcf\x64\xd3\x4b\xec\xb7\xcb\x7e\xe7\xed\xf7\xea\xb7\x32\xdf\xba\xf2\x5b\xeb\xf7\xf7\xf7\xbf\xde\xb4\xc6\xf7\x5f\x71\x40\xc2\x94\x7a\x1d\x70\xc8\x01\xa7\x1e\x70\xe9\x01\xf7\x1d\xf0\xde\x81\x7b\x1c\x38\xf2\xc0\xd9\x07\xde\x7e\xe0\xab\x07\xf5\x3e\xe8\xb0\x83\x9a\xf4\x3c\x74\x8f\x83\x66\x9b\xc8\x2e\x96\xdd\x1c\xea\x3d\x34\x1e\xe6\xc3\x6e\x0f\xf3\xc3\x9b\xc2\xbc\x7a\x7e\xd8\xef\x88\xc9\x66\x2d\x62\x47\xb4\xa0\x7e\x9e\xfe\xb2\xcc\xd7\x1e\xb6\xac\x0a\xf3\x5b\xc6\x0d\xd6\xd2\xd8\xec\xf8\x21\xf1\x94\xb5\xd4\x6a\x88\xaf\x24\x6f\x5b\x0d\x74\x44\x7c\xa5\x8e\xae\x97\xc6\x0f\xb1\x1a\xb8\xfe\x2f\xe8\x13\x7c\x66\xe4\x21\xe1\xff\x18\xdb\x60\x7a\x2d\x8d\xaf\x0c\x3e\x0d\x5b\xc3\xb1\x41\x9b\xae\xf5\x65\xe5\x9d\x2f\x74\xbe\xc0\xfa\x1b\xb9\xab\x91\x83\x02\x29\x1e\x33\x72\xa9\x91\xcf\x1a\xf9\x9c\x91\xcb\x8c\x7c\xde\xc8\x35\x46\xbe\x63\xe4\xbb\x81\x4c\xf4\x36\xb2\x8f\x91\x3b\x07\xd2\xda\x9d\xc5\x3a\x1f\xea\x7c\x88\xc5\x3b\xe7\x76\xce\x65\xd4\x94\xb9\x75\x80\x75\x00\xb3\x4d\x39\x61\x64\x99\x91\xbd\x8c\xec\x6d\x64\x3f\x23\x77\x32\x72\x80\x91\x83\x03\x29\x16\x1b\xb9\xc4\xc8\x27\x8d\x7c\xda\xc8\x57\x8c\x5c\x69\xe4\x6a\x23\xdf\x34\x72\x9d\x91\x6f\x19\xf9\x9e\x91\x1b\x8c\xfc\xc0\xc8\x8d\x81\x4c\xf4\x35\xd2\x20\x1a\x7b\x03\x2f\xc4\x3b\xd7\x77\xae\x67\xc4\x58\x4a\x4d\x8b\x6d\x64\xc2\xc8\x32\x23\x7b\x19\x69\xe6\xac\xed\x0d\xe4\x4e\x46\x0e\x30\x72\xb0\xf1\xcb\x62\x23\x97\x18\xf9\xa4\x91\x4f\x1b\xf9\x8a\x91\x2b\x8d\x5c\x6d\xe4\x9b\x46\xae\x33\xf2\x2d\x23\xdf\x33\x72\x83\x91\x1f\x18\xb9\xd1\x78\xb6\xaf\x91\x06\x51\xc7\x79\x71\x93\x0f\x29\xd8\x1d\xc8\xff\x66\x8b\x0f\xde\x21\x4b\xcb\x8d\xff\xb7\xb6\xb7\xbf\x69\x8f\x5a\xbd\xab\x69\x19\x64\xe4\x60\xec\x5d\x5d\xee\x36\x8f\xa5\xa6\x25\x3a\x9b\x67\x4d\xcb\x73\x46\x2e\x33\xf2\x79\x23\xb7\x9e\xe5\x1a\xd3\xbe\xf5\x5c\xdf\x31\xed\xef\x1a\xb9\xad\x79\xf7\x0e\x3e\xd5\xdf\x87\x40\x46\x7c\xa0\xbf\x1b\xba\xc5\x7c\xfb\x02\xab\xc3\x39\x45\xe6\x81\x19\x84\x56\x6f\xcb\xd2\xd0\xae\x88\x15\xdd\xd0\x42\x84\x60\x57\x04\x5a\xa9\x91\x5d\xdf\xbb\xa0\x9c\x30\xb2\x0c\x5e\x0e\xa4\x19\xad\xbd\x1c\xfa\x37\x90\x03\xe0\xd3\xd0\x9b\x81\x5c\x02\x3f\x06\xf2\x69\xf8\x2b\x90\x2b\x8d\x5c\x0d\x4f\x05\x72\x9d\x91\x6f\xc1\x3b\x81\xdc\x60\xe4\x07\x46\x6e\x84\x47\x02\x69\x10\xad\x6f\x6f\x73\x57\x08\xd8\xfb\xff\xaf\xbd\xb1\x1b\xfc\xf1\xdf\xfc\x4d\x8e\x59\x15\x85\x5f\x18\xe4\x91\xdf\x16\xec\x6d\x7e\x57\x70\x27\xb6\x33\x7e\x4f\x70\x08\xdb\xdd\xfc\x6e\x51\xf0\xab\x45\xc1\x6f\x16\x95\xfe\x62\xd1\x0a\xb1\x52\xac\x12\x6b\xc4\x3a\xfc\x32\xd1\x86\xc2\xaf\xcb\x98\xbb\x3f\xf1\xab\xe3\x4d\x5a\x5e\xab\x23\x8d\x11\x3a\xca\xbc\x5e\xc7\x13\xb7\xe9\x38\xf3\x6e\x1d\x51\x3c\xac\x23\xcd\xa7\xac\xe7\xad\x15\x3a\xd6\x5c\x67\xbd\x67\x6d\xea\x8a\x36\x63\xfd\x63\x03\x75\x8c\xb1\x6f\xec\xc0\xd8\x50\x1d\x65\x0c\x8b\x55\xc5\x8e\x8c\x8d\x8c\x8d\x89\x9d\x14\x3b\x3d\x36\x31\xd6\x10\x6b\x89\xcd\x8c\xcd\x8e\x9d\x17\xbb\x28\x76\x79\xec\xea\xd8\xb5\xb1\x1b\x62\xf3\x62\xb7\xc7\x16\xc4\xee\x89\xdd\x1f\x7b\x34\xb6\x38\xf6\x4c\xec\xc5\xd8\xab\xb1\x35\xb1\xb7\x63\x1b\x62\x1f\xc7\xbe\x88\xc7\xe3\x22\xde\x3b\x3e\x20\x3e\x38\xbe\x57\x7c\xbf\xf8\xc1\x71\x27\x9e\x89\x1f\x16\xaf\x89\x0f\x8f\x1f\x1b\x3f\x3e\x7e\xb2\xf6\xc5\x30\x76\x75\x89\xb4\x8a\xe5\xd8\xc1\xa5\x2d\x3d\xf4\x34\xb2\x73\x76\xcf\x1a\xb6\xd9\xb2\x95\x86\x1e\x5a\xa2\xed\xc7\x46\x64\x2d\xfb\xdd\x76\xf4\x6f\xcb\x9e\xa8\xb5\x77\x6c\x55\xde\xda\xb6\xed\xdb\xbf\xad\x96\x28\xfa\xd6\xf3\xda\xae\xcd\x5f\x21\x4d\xcf\x2d\xcf\x15\x65\xe4\x53\x1d\xb3\x77\xbb\x9b\xb2\x48\x47\xe4\x7b\x9a\x7b\x2a\x7b\xe9\x7d\xbb\xd1\xda\x5f\xef\xcd\x7e\xd6\x91\x41\xac\x46\x3f\xb0\xc2\x3b\x7d\xe1\xc8\xe0\x8e\xe8\x40\x2b\xb8\x37\x17\x46\xcc\xfd\xd1\x47\x47\x80\x5a\xa3\x8e\xb5\xf5\x77\x64\xb0\x8e\xeb\xf5\xb7\xc1\x1a\x6c\x34\x06\x77\x33\x87\x58\x7a\x87\xeb\x13\x43\x70\x0f\x4f\x47\x86\xf1\x71\xc6\x92\x98\xc6\x0e\x46\x7f\xd6\x0d\x21\x66\x3d\x6a\x5d\xa7\xe5\x62\xdd\xbb\xbf\xb5\x9f\x3e\x65\x38\x56\x46\x47\xdc\x35\xfa\xdc\x71\xac\x8e\xb9\x4f\xd6\x27\x84\x3a\xf3\x4b\xf4\x67\x58\x73\xac\xf3\xad\x8b\xb5\xbe\x47\xe3\xe3\xb4\x7c\x39\xde\xa0\x7d\xb9\x34\x7e\xaf\x2e\xbf\x47\x02\xeb\x67\xc6\x87\x74\xb5\x74\x2e\x25\xa3\xbb\x64\x7c\x9c\xe9\x3f\x34\xa6\x67\x12\xbb\xdc\x94\x3b\x02\xa9\xcb\x57\x69\x79\x77\xfc\x29\x2d\xe7\x06\x2d\xa4\x3c\x90\x74\x70\x51\x5a\xfd\x99\xcd\x7a\xb1\x3e\xac\xbf\xfe\xe6\x9b\xdf\x10\xd5\x3e\x2c\xfe\x5e\x19\xbe\xf9\x66\x5e\x9b\x0a\xf3\xda\x23\xb0\x80\x7e\x4c\x97\x5a\x71\x36\x24\xf8\x86\xc7\x9c\x58\x26\x76\x58\xac\x26\x36\x3c\x76\x6c\xec\xf8\xd8\xc9\xb1\xf1\xb1\xba\x58\x53\xac\x2d\x76\x46\x6c\x4e\xec\xfc\xd8\xc5\xb1\x2b\x63\xd7\xc4\xae\x8b\xdd\x18\x9b\x1f\xbb\x23\x76\x57\xec\xde\xd8\x83\xb1\x45\xb1\xa5\xb1\xe7\x62\x2f\xc7\x56\xc6\xde\x88\xad\x8f\x6d\x8c\x7d\x1a\xdb\x12\xa7\xf1\x44\xbc\x6f\x7c\x97\xf8\x90\xf8\xde\xf1\xfd\x75\x44\xac\xe2\x87\xc6\x0f\x8f\xfb\xf1\x11\xf1\xd1\x7a\x8e\xa7\xc6\x6b\xe3\x93\xe3\x53\xe3\xd3\xe3\x67\xc5\xcf\x8d\x5f\x18\xbf\x34\x7e\x55\x7c\x6e\xfc\xfa\xf8\x4d\xf1\xdb\xf4\x7c\xef\x8e\xdf\x17\x7f\x38\xfe\x78\xfc\xa9\xf8\xf3\xf1\x15\xf1\x55\xf1\x75\xf1\xf7\xe2\x9b\xe2\x9b\x89\x45\x38\x29\x27\xfd\xc9\x40\xb2\x07\xd9\x97\x1c\x48\x86\x92\x14\x19\x46\xaa\xc8\x91\x64\x24\x19\x43\x4e\x22\xa7\x93\x89\xa4\x81\xb4\x90\x99\x64\x36\x39\x8f\x5c\x44\x2e\x27\x57\x93\x6b\xc9\x0d\x64\x1e\xb9\x9d\x2c\x20\xf7\x90\xfb\xc9\xa3\x64\x31\x79\x86\xbc\x48\x5e\x25\x6b\xc8\xdb\x64\x03\xf9\x98\x7c\x41\xe3\x54\xd0\xde\x74\x00\x1d\x4c\xf7\xa2\xfb\xd1\x83\xa9\x43\x33\xf4\x30\x5a\x43\x87\xd3\x63\xe9\xf1\xf4\x64\x3a\x9e\xd6\xd1\x26\xda\x46\xcf\xa0\x73\xe8\xf9\xf4\x62\x7a\x25\xbd\x86\x5e\x47\x6f\xa4\xf3\xe9\x1d\xf4\x2e\xaa\xbd\x47\x4e\x66\x7e\x20\xf9\x8d\x7a\xb5\xa6\x07\xe5\xf8\xf4\xa0\x1c\xdb\x12\x94\x63\x5b\x4c\xfb\x3c\xd3\x3e\xcf\x94\xd7\x98\xf2\x1a\xd3\xe7\x41\xd3\xe7\x41\xd3\x2e\x4c\xbb\x08\xca\xa4\xdc\xe8\x2c\x2f\x2d\x77\xeb\x3f\xd4\xf4\x1f\x5a\x5a\xde\xd6\x58\xf2\x9c\x29\x3f\x57\xaa\x27\xb6\xd8\x94\x17\x9b\x3e\xca\xf4\x51\x46\xe7\xa7\x46\xe7\xa7\xa5\x36\x77\x2b\x47\xe7\xf5\x94\x29\x3f\xb5\x55\x39\x6a\xdb\xfd\x46\xff\xfd\xa6\xbc\x97\x29\xef\xb5\x15\xd6\xb6\xca\xe3\x4c\x79\x5c\x69\x7b\x37\xff\x6f\xc3\xcf\x3b\xe2\x9f\x6e\x7d\x22\xb6\x75\xb3\x79\x47\xca\x11\x7b\xb6\x55\xfe\x4f\xec\x93\xaf\xbd\x37\xa2\xfb\x61\x5b\x7b\x60\x5b\xeb\xfe\x6f\xac\x75\x6c\x65\x51\x76\xad\xb2\x91\x57\x15\x25\x39\x30\x22\x77\x60\xbd\x22\xe5\x1d\x67\x90\x7e\x85\xdf\x82\x0e\x7e\x09\xfa\x39\xf3\x0b\xd0\x2f\xd1\x95\xe6\xf7\x9e\xdf\xa4\x9f\xd0\x2f\xc4\x42\x73\xff\xc5\xd7\x29\x78\x86\x35\x5a\xa7\x71\x3a\x9d\xaa\x53\xad\x4e\x93\x75\x9a\xaa\xd3\x74\x9d\xce\xd2\xe9\x5c\x9d\x2e\xd4\xe9\x52\x9d\xae\xd2\x69\xae\xc6\xb8\x5e\xe7\x37\x05\xd7\xef\xc0\x3e\xeb\x62\xe3\xe5\xc3\x8d\xbc\xdd\xb4\x5c\x5f\x94\x61\xbb\x8e\x0c\x02\xb9\x60\x2b\xb9\xa8\xa8\x41\xb7\x34\x99\x51\x01\x27\x2d\xe2\xbd\x4d\xcb\xd5\x85\xeb\xf8\x21\xff\xf7\x3a\xfe\xaf\x5c\xc7\x35\x47\x5b\x05\x39\x34\x90\xb1\x4d\x46\xde\x58\x94\xf1\x97\x23\x72\x5c\x51\x5a\x8b\x8c\xbc\xde\xc8\x0d\x45\x19\xed\xd3\x43\x7f\x23\x35\xd7\x17\x65\x5d\x44\x9e\x55\x94\xf1\xe9\x11\x19\xd1\xb3\xe5\xb6\x22\x6e\xec\xe0\xa2\xec\x36\x97\x39\x45\x89\x19\x6d\x25\xc9\xc9\xa6\x9c\x2a\x6d\x8f\x7f\x5a\xf4\x06\x29\x8f\xb4\xdf\x1b\x91\x57\x15\xe5\xb6\xf4\x77\xd3\x59\x13\x91\x43\x22\xed\x51\x9b\xb7\xe1\xe7\x1d\xf1\x4f\x37\x3b\x23\xb6\x75\xb3\x79\x07\x64\xb8\x3a\xe1\xdc\xa3\xe5\xa8\x9d\xdd\x66\xb7\xe3\xfb\x64\xd1\xf6\xf6\xc9\xd7\xde\x1b\x51\xff\x6c\x63\x0f\xec\xd0\xba\x7c\x5a\xd4\xb3\x23\x6b\xdd\xcd\xce\xa8\xb6\xa8\x9d\xd1\xf6\xd0\xe6\xc5\x5b\x95\x07\xf6\x28\x77\xfc\x3a\x3e\x98\x3e\x46\x97\xd2\x67\xbb\xfd\x72\xff\xaa\x1e\x7e\xab\xff\x43\xfa\x11\xfd\x92\x76\x86\xbf\x94\x6a\x0d\xb6\x76\xe4\x0a\x6e\xe1\x0a\x6e\x59\xc1\x37\xad\x43\xa7\xbb\x75\xba\x4f\xa7\x87\x75\x7a\x5c\xa7\xa7\x74\x7a\x5e\xa7\x15\x3a\xad\xd2\xd6\xac\xd3\xf9\x7b\x3a\x05\x73\xde\x1c\x38\x48\xc7\xf6\x17\x5a\x03\x8c\x0c\xca\xa7\xa3\x5c\x94\x77\x44\x3e\xbd\x16\xb2\xf8\xe9\xb5\x91\x3e\x77\x6c\xd5\xbf\x4b\x96\xb6\x5c\x89\xb1\x41\xb9\x4d\x9f\x53\x34\x43\x98\xf2\x2a\xd3\x5e\x94\xc4\x9c\x81\x62\x41\xdd\xf4\xb2\xac\x9d\xb4\x8c\xd3\x4f\x34\xf7\x6d\xe3\xc9\xb6\xd5\x7b\x7b\xbc\xa9\x35\xc6\xb5\xc6\x61\x46\xa7\x55\xa2\xf1\xab\xc6\xf6\x8c\xf8\x15\x36\x9a\x9d\x61\x99\x3d\x11\x33\x7b\xe2\x1b\xff\x69\x1b\x7b\x40\x0c\x6c\x1c\x0e\x1b\x4f\x37\x1a\x83\xd2\xa0\xaf\xb1\x33\xbb\xf6\xe5\xb6\xbc\x9e\xe8\x49\xd7\xff\x00\x6e\x9f\xaf\x18\xf7\x7f\xd4\x82\x1e\xd7\xf2\xff\x7d\x0b\xb6\xe5\xfb\xb8\xa5\xba\xed\xa2\x9d\xbf\x72\xf7\x6c\xff\xbb\x15\xcc\x44\x61\x26\xc3\x77\x50\xe3\xb6\xd6\x2d\xc4\xf9\x37\x6d\xdc\xc6\x4e\xff\x17\x6c\xec\xd1\xaf\x45\x1b\x87\x5b\x0d\x11\x1b\x77\xf9\x17\xd7\xef\xab\xf7\xca\xb6\xfc\x1e\x58\x30\xfe\xff\x88\x05\x3d\xef\x95\xed\xe1\xfe\x8f\xcd\xbc\xc7\xd5\xfc\x1f\x98\x79\x4f\x6b\x8f\xbb\xca\xd7\xff\x77\xdf\x55\x8e\x1d\x6c\xce\x5b\x1b\x22\xf2\xe2\x62\x39\x46\x4b\x5b\x7a\x68\x37\xe7\xb6\xce\xf5\xa5\x1a\xd0\x67\x43\xe4\x6c\xb7\x68\x1b\x58\x17\x6f\xa3\x65\x51\x51\xcf\xb6\xe4\xd6\x36\x6f\xcb\x9e\x6e\xe7\xcb\xfd\xb7\x2a\x6f\xd8\xae\xdc\xae\x4f\xb6\xe9\x8d\x8b\x77\x60\xee\xdb\x98\xb5\x55\xbb\x95\xf7\x4c\xb9\x73\x44\x51\x46\x46\xed\x78\x2c\x49\xe8\xd3\xf4\x75\xfa\x86\x79\x03\xb0\xb7\x61\x12\x4b\x47\x8a\xc1\xfd\x5f\xbf\xbb\xc4\xfe\xbd\xee\xbf\x7b\xff\xd2\x3b\xc2\x7b\x3c\xe1\xdd\x11\x53\x3e\x2f\x90\x34\x63\x56\xa6\x2e\xbc\x93\x64\x5a\x4e\x2f\xca\xb0\x9d\x4c\x35\xf2\xc8\xc8\xa8\x0b\x8b\x12\x63\x87\x46\xc6\xf6\x35\x72\xdf\xa2\x0c\xef\x00\x51\x1e\x69\x31\xf7\xc0\x98\xb9\xa3\x41\xdb\x8a\xb6\x75\x93\xeb\x8a\x65\xd8\x1f\xb1\x79\x6b\x7b\x42\x9d\xa1\x36\x7e\x78\x51\x7f\xb4\x1c\xea\x89\xca\x1d\xf7\xc9\xf6\xbd\xd1\xcd\x03\x91\xb9\x6f\x7f\xd6\xe1\xfd\x36\xcc\xf7\xc8\x48\xcf\xf3\x22\x72\x6a\x41\xee\xf8\xfe\x8d\xd3\x65\xf4\x45\xf3\x7e\x76\xc2\x0a\xdf\x19\x1a\x56\xfc\xbe\xfc\x2f\xd9\xb3\xfb\x9a\x13\xe8\x91\xe6\xa4\x39\xc7\xc8\xa7\x4c\xcb\xfd\x86\xa1\x16\x14\x4f\xcd\xe4\x8b\xa2\x0c\xdb\x69\xa6\x78\x92\x0d\xcf\xb0\x61\x4b\x28\x71\x0e\x35\xa7\x4e\xb2\xce\x48\x73\xdf\x23\x78\xdd\xa7\x4b\x7f\x7c\x8d\x29\xef\x15\x39\x59\x1b\x6d\xf4\x0e\x23\xfb\x16\x3f\xed\x26\x23\xda\x42\xfb\xa3\x36\x6f\x6d\x0f\x74\xf6\x8d\x68\xde\x5a\xee\x5b\x2a\x77\xdc\x27\xdb\xf4\xc6\xbe\xa5\x1e\x88\xce\x7d\xfb\xb3\x0e\x75\xc2\x86\x4f\x23\xa3\xca\x7b\xf4\xf6\xd7\xd9\xb3\xcf\xd0\xb5\xdd\xf6\xac\x65\xed\x6f\x85\xef\xdc\x85\x27\xb5\xc3\x22\xf1\xc9\xae\x85\x11\x5f\x1d\xf3\xc4\xac\x5d\xcc\xd3\x71\xc6\x38\x93\xac\x9c\xf5\x65\x03\xc5\x13\xe6\x59\xd8\x72\xb1\x42\xbc\x2a\x5e\x13\xaf\x8b\x35\xe2\x0d\xb1\x5e\xbc\x1f\x3c\xf3\xd6\x68\xc4\xda\xc3\xda\xd7\x3a\x30\x18\xd9\x03\x5e\x8c\xae\x37\x72\xdd\x7f\x40\xf3\x47\xff\x61\xcd\xeb\xff\x63\x9a\xdf\xfd\x8f\x69\x7e\xff\x3f\xa6\x79\xc3\xbf\xa0\x39\xd8\x89\x7b\x6f\x63\x27\x86\x7a\xbf\xbe\xc6\xbd\xf5\x4e\x8f\x6b\x4b\x87\x40\xe7\x40\xa3\x6b\x85\x91\xaf\x58\x5d\x4f\xb9\x63\xac\xff\x0e\xf6\xde\x14\xe9\x1d\x7a\xa1\xcb\xda\xe0\xdb\xc0\x4d\x84\x1e\x46\xe7\x1f\x75\xdb\x1b\x3b\xda\x7f\x39\x56\xfc\xeb\xe9\xdf\xf1\xfe\xa1\xfe\xf7\x76\xb8\xff\x33\x5f\xb3\xff\x52\xec\xab\x1d\xed\xbf\x0e\xbb\x65\x47\xfb\xaf\xff\x9a\xfd\x97\x7e\xcd\xfe\xcf\x7c\xcd\xfe\xcb\xbf\x66\xff\x15\x5f\xb3\x7f\xe1\xdb\xd4\xeb\x0e\xf3\x3e\x73\x9d\xf5\xb2\xf5\x45\x2c\x1e\x1b\xa2\xe3\x85\x9a\xd8\xf1\xb1\xda\xd8\xfc\xd8\xca\xf8\x2e\xf1\x31\xf1\x53\xe3\x0d\xf1\xe9\xfa\xff\x39\xf1\xf9\xf1\x05\xf1\x2d\xe4\x60\x32\x92\xd4\x91\xe9\x46\x2e\x20\x8f\x93\xa7\xe8\xf1\xf4\x6e\xfa\x28\x7d\x2a\xf8\x9c\x6e\x66\x82\x8d\x66\x17\xb2\xc7\xd9\x26\xce\xf9\x00\x9d\xf6\xe0\x43\xe9\xe6\xe0\x7f\x7e\x2a\xaf\xd3\xff\x37\xf1\x7b\x6d\x6e\x1f\x6e\x5f\x67\xdf\x61\xdf\x67\xaf\x11\xbd\xc5\x30\x31\x5c\x9c\x2c\xce\x17\x8b\xc5\x16\x59\x2b\x37\x6a\x06\x48\x25\x86\x25\xfc\xc4\xb1\x89\x73\x13\xd7\x26\x3a\x12\x0f\x27\xde\x2e\xdb\xbf\x6c\x74\xd9\xb8\xb2\xf3\xcb\xae\x2d\x7b\xbc\x6c\x4d\xd9\xe8\xf2\x78\xf9\x90\xf2\xc3\xca\x4f\x2e\xbf\xb4\xfc\xb6\xf2\xbb\xca\x57\x94\x7f\xdc\xcb\xea\x95\xe8\x35\xb4\xd7\xc4\x5e\x33\x7b\x9d\xdb\xeb\xc2\x5e\xc1\x7b\xce\xfb\x76\x2e\xb0\x86\x75\x2e\x27\xdf\xed\x5c\x40\x6a\x74\x3a\x42\xa7\x91\x3a\x9d\xa0\xdb\x4e\xe9\x0c\x3c\x3c\xa0\xb3\xce\xe2\x16\xd1\xfd\xd2\xba\x94\xd5\xe9\xd0\xce\xcb\xf4\x98\x3a\x7b\x8d\xce\x89\xd5\xa7\x73\x77\xab\x9f\x4e\xfb\xea\x5a\xd0\x6f\x39\xfa\x5d\x16\xe9\x57\xa7\xfd\x17\x68\xe8\xb3\xe5\x53\xab\x9f\x4e\xfb\xea\x16\xa2\xfb\x2d\xd7\x7d\x96\x07\xf8\x56\x3f\xad\xa7\xce\xea\xab\x47\xf4\xd3\xf9\xee\x3a\xed\xa1\x53\xd0\xcf\xd1\x9f\x6a\xcb\x2c\x5f\xa7\x23\x75\x1a\xa1\xeb\xa3\x75\x3e\x56\xe7\xc7\xeb\x7c\x9c\xce\x4f\xd2\xf9\xc9\x3a\xf5\xd2\x5a\x6a\xb4\x96\x05\x5a\x4b\x8d\xd6\xb2\x40\x6b\x59\x60\xb4\xd4\x14\x46\x2f\x28\x8c\x0e\x46\x9e\xac\x53\x2f\x60\x2f\x00\x76\xd7\xa8\xcb\xf4\xa8\xe5\x7a\xd4\x72\x3d\xea\x3d\x3d\x6a\x79\xb7\x51\x7d\xcc\x5c\x43\xbc\x3a\xe0\x5d\xa6\x47\x5e\xd6\x23\xde\x71\x3a\x8d\x31\xd6\x2e\xb0\x4e\xd4\x29\x6e\x1d\xd5\xb9\xdc\x5e\x63\x7d\xd3\x78\x30\x98\xf5\x65\xba\x36\x42\xb7\xa3\x66\x4a\x81\x45\x0b\x82\x48\x41\xaf\xc8\xd1\x9d\x3f\x23\xa3\x75\x3a\xbe\xb3\x46\xaf\x0e\x25\xe3\x74\xf9\x14\x9d\xe7\x3b\x1f\x21\xcd\x3a\xcd\xea\x7c\xc4\x8a\xeb\x4f\x6e\xd7\xad\xb7\x5b\xfd\x49\x75\x2c\xa1\x57\x74\xb8\x5e\xd1\x59\x7a\x45\x2f\x23\xa7\x6a\x1d\xa7\xeb\x94\xd3\x69\x82\x4e\x13\x75\xaa\xd7\x69\x8a\x4e\x0d\x3a\x35\xe9\x34\x4d\xa7\x76\x9d\x66\xea\x74\x96\xf5\x63\x32\x5b\xa3\x97\xed\x28\xba\xd9\x0f\x42\x5b\xbd\xa7\xb6\x7a\x4f\xe0\x8f\xd4\xf8\x23\x35\xfe\x48\x8d\xb3\x3c\xd0\x19\xee\x25\xad\x6f\x99\xd6\xb7\xac\xa0\x4f\xeb\xb2\x88\xee\xbf\xb0\x30\x83\x3e\xba\x4f\xa3\xee\xd3\xa8\xb1\x1a\xb5\xf5\x2f\x69\xab\x5f\xd2\x56\xbf\x44\xea\x74\x9a\xac\xd3\x54\x9d\xa6\xe9\xd4\xae\xd3\x4c\x9d\xce\xd4\x69\xb6\x4e\x73\x3a\x5f\xb2\x98\xde\x6b\x9b\xf5\x5e\xdb\xac\x75\xd6\x69\x1b\xea\xb4\x0d\x75\x3a\x92\x9b\xde\xf9\xa4\xf5\x8d\x9e\xf6\x9a\xb6\x77\x10\xfa\xde\xa8\x91\x97\xeb\xfe\x37\x6a\xf4\xe5\x1a\x7d\x39\xf9\xa1\x4e\x81\xff\x4e\x83\xef\xf2\x9d\x8f\x19\xff\x4d\x32\x3e\x5c\x6e\xe6\xd6\xa4\x53\x73\xc4\x87\x33\x74\x3d\xf0\xe3\x2c\x9d\xce\xd0\xfd\x03\x7f\x9e\xad\xdb\xb4\x4f\xc9\x39\x7a\xe7\x0c\xd4\x56\xf8\xd8\x3b\x7e\xd7\xde\xf9\xca\x55\xcb\x6b\x9f\xed\xe8\xca\x75\xf9\xf3\x0a\xed\xcf\x2b\xf4\xde\x38\xb3\xf3\x1e\xed\x9b\x7b\xac\x84\xd6\xfa\x82\xd6\xf6\x82\xd6\xb4\x50\x7b\xf2\x15\x3d\xfa\x05\x3d\xfa\x05\x3d\xfa\x05\xdd\xeb\x05\x3d\xfa\x05\xdd\xf3\x05\xad\x21\xaf\x2d\x6e\xd1\x3d\x66\x75\x2e\xd4\x7b\xea\xd4\xce\x7d\xb4\x35\x1d\x7a\xec\x3e\xfa\x93\x85\x7a\xfc\x5d\xda\x92\x0e\xad\x63\x99\xb6\xa6\x43\x5b\xd3\xa1\x7d\xb0\x50\xeb\xdb\x47\x8f\x5a\xa8\x75\xee\xa3\x3d\xbe\x50\xeb\xdd\x47\xeb\xdd\x47\xeb\xdd\x47\xeb\xdd\xc7\xea\xa5\x35\x05\x5a\x3a\xb4\x86\x0e\xbd\x9e\x81\x86\x0e\xbd\x9e\x1d\x7a\x64\x07\x69\xd3\xa9\x5d\xa7\x99\x3a\x9d\xa9\xd3\x6c\x9d\xe6\x74\x76\x58\x7d\xf5\xa8\xd5\x64\xbc\xd9\x09\xab\xf5\xc8\xd5\x7a\xe4\x6a\x3d\x6a\xb5\x1e\xb5\x5a\x8f\x5a\xad\x47\xad\xd6\x7e\x0f\x76\xc3\x6a\x3d\x72\xb5\xf6\x77\xb0\x23\x56\x6b\x7f\x07\xbb\x62\xb5\x99\xf9\x32\x3d\x3a\xf0\xe1\x32\x3d\x7a\x99\x1e\xbd\x4c\x8f\x5e\xa6\x47\x2f\xd3\xa3\x97\xe9\x91\xcb\xf4\x88\x65\x16\x2d\xcc\x7c\x3a\x66\x4f\xc8\x4c\x6b\x77\x72\xa6\x4e\x73\xac\xdd\xb5\x37\xbb\xbc\x12\xf6\x6c\xd4\xb3\xec\x6a\x29\x33\x76\x46\x6d\x8c\xda\xd7\x65\x5b\x60\x57\x60\x53\xf0\x3d\x77\xf5\x1e\x70\xad\x98\xfe\x06\xb9\xd6\x4e\xe4\x11\x6b\x04\x59\xa4\xe7\xbc\xd8\x1a\x44\x9e\xec\x9c\x4b\x9e\xea\x5c\x42\x9e\xd1\xf9\xb3\x9d\x15\xe4\xb9\xce\x73\xc8\x32\x9d\x5e\xd4\xf5\x57\x75\x7a\x5d\xf7\x59\xa5\x3f\x7f\x43\xa7\xf7\x75\xda\xa8\xd3\x26\x9d\x3e\xea\x5c\xa2\xb5\x4d\xd4\x6b\xf6\x80\xd6\xf4\x88\xee\xb5\xb0\x73\xad\xd6\xba\x16\x5a\xd7\x6a\x8d\x6b\xb5\xc6\x0e\xad\x71\x89\xd6\xf8\x04\x79\x5e\xd7\x5f\xd4\x69\xb9\xd1\xbc\x84\xac\xd4\x69\xbd\xee\xbb\xa9\x73\x2d\x0d\x18\xb2\xb7\xd1\xb4\x50\xb7\x2e\xd2\xe9\x49\x63\xd3\x12\xad\xe1\x1c\xd8\xd4\xa1\x35\x74\xe8\xd1\xe7\x98\x91\x7a\x14\xf9\x58\xa7\x4f\xf5\xba\xed\xaa\x67\x78\x8e\x9e\xe1\x39\x5a\xc3\x35\xe4\x11\xa3\x41\xdb\xa1\x53\x60\xc7\x4a\x9d\x5e\xd7\x69\xb5\xfe\x6c\xad\xce\xdf\xd0\xf8\x6f\x69\x4d\xeb\x75\x7a\x57\xf7\x7d\xcf\xcc\x6c\x2e\xf9\x00\x33\xfb\x42\xa7\x2f\x75\xea\xec\x5c\x42\xad\xce\x25\xda\xff\xcb\x02\xcb\x2d\x57\x9f\xf9\xb4\xb5\x96\xab\x57\xaa\x6b\x9e\x1b\xb5\xdd\xd2\xd4\xba\x66\xfc\xa2\xf6\xed\x72\xfd\x49\xe0\xb7\x37\x74\xfd\x7d\x9d\xb4\xad\x7a\x67\x2c\xec\x36\xab\xc0\x2f\x1d\x5a\xf3\x12\xa3\x39\x98\x51\x60\x9b\xf6\x87\x5e\xdd\x82\xf7\xb4\x8e\x60\xde\x2f\x5a\x13\xb5\xae\x0e\xb2\xce\x58\xda\xa1\xd7\xa0\xc3\xcc\x7f\x8b\xb6\x8e\x18\xeb\x5e\x37\x96\x0d\xd2\xb6\x06\xf8\xa8\x69\xdf\x04\xb8\x66\x7d\x74\x9f\x85\xc1\x8a\xeb\x3c\xf0\xe6\xf3\x11\xdc\x77\xad\x41\xc6\xff\x01\x43\x5a\xda\x8b\x96\xbe\x56\xac\xd5\xd7\x8a\xb5\xd6\xd9\xfa\xd3\x07\x74\xef\x47\xcc\xba\x74\x84\x7b\x26\x62\x7d\xb0\x1e\x5d\x96\x63\xae\x56\xb9\x1e\x11\xae\x60\xb1\x57\xe0\x95\x41\x85\x75\x7f\x5d\xe3\xbe\xa9\xeb\xeb\x60\xe1\x20\x8d\xdb\xa1\x71\x3b\xc2\xf5\xd7\x9f\x2e\xc1\x0e\x0a\x66\xf6\xaa\x2e\xaf\xd6\xed\xc1\xfc\x83\x55\x7b\x27\xd8\x35\x81\xd5\xf0\xc5\x06\xdd\xe7\x03\xb3\x2f\x3b\xcc\xea\x7d\xac\xd3\x66\xb3\x8a\x6b\xf5\x2a\xae\xd5\xab\xa8\x77\x97\x46\xd9\x47\xa3\x4c\xd4\x28\x13\xf5\xec\x96\xe8\xd9\x05\x33\x9b\x68\x66\x16\xdd\x2b\x81\xb7\x5f\xc5\x9e\x09\x76\xfd\x6a\x6d\xf3\x1a\xdd\xb6\xd6\x7c\x03\xe6\x92\x37\x75\xfb\x3a\x58\xf2\xb6\x6e\x0b\xad\x89\xee\xa3\x73\xb4\x45\x4b\x60\xd1\x5c\x63\xcd\x27\x3a\x7d\x06\xab\xba\xf6\x94\xc4\xaa\x2c\x31\xfe\x0c\xe6\xdb\xb5\xcf\xc3\x55\x09\x76\xe7\x5a\xcb\x26\x8b\x22\xdf\xa5\x60\xaf\xbc\x6a\xbc\x6c\x56\x5f\x73\x8d\xf6\xa4\xbe\x4e\x04\xfe\xdc\x64\x4a\x2b\xcd\x77\xd2\xc5\x1a\x74\x7d\x93\x96\x98\xb9\x75\x68\x1d\x1d\x1a\xc5\x0d\xd7\xde\xcc\x33\x58\xbd\x0e\x3d\x62\x84\xc5\xb1\x43\xc2\x11\x81\x4d\xcf\x9b\x6f\x68\x87\xc5\x0a\xdf\xca\x67\xf5\xf7\x07\x6b\xa9\xf7\x19\xbe\xb9\xc1\xf7\x4f\xef\xc3\xb5\x7a\x46\xa1\x6f\xd6\x06\x96\x6b\x7f\xac\x2d\xac\x46\xd0\xe3\x73\x3d\x36\xe8\xd5\xc7\x7c\x13\x57\x99\x3d\x13\x5e\x53\xba\x46\xbd\x1b\xb9\xbe\x7c\x68\x46\x77\x04\xd7\x18\x3d\x7a\xae\x1e\x7d\x8e\x59\xc3\x84\x5e\xc3\xb5\x7a\x0d\xc3\xef\xf3\x5a\xb3\x2b\x96\x98\x6f\x45\x64\xb4\xe9\x19\x0b\x74\xea\x6f\x92\xb9\x7a\xe9\xa4\x77\x99\x41\x0a\xac\x7e\x3f\xfc\xde\x1a\xeb\x3f\xd2\x79\x78\x15\x59\xa2\x67\xda\xd5\x1b\xdf\x1d\xf2\xb9\xf9\x36\xae\x32\x58\xe1\x0e\x5f\x87\xb9\x05\xdf\xea\x8d\x05\x2b\xd7\xc2\xca\xb9\xda\x8f\x5d\x3a\xd6\x9b\x55\x09\xf5\x6c\xd1\x7a\x6c\xa3\xe7\x8d\x6e\x63\xd7\x62\xec\x12\x8c\x7b\xb3\x9b\xd7\xe6\x1a\x8f\x89\x1e\xfc\xfa\x44\xb7\x1e\x76\xa1\x47\x97\x46\x5c\x17\xb5\x45\x4b\xac\xf2\x82\xcf\xba\xe6\x10\xf6\x5e\x52\xd0\x57\xb4\x67\x89\xb9\xa2\xd8\x85\xef\x63\x30\x8f\xae\x6f\xea\xc7\xb8\x4a\xc4\x4d\xbf\xe0\xaa\x2b\xb1\x96\x6b\xb1\x0a\x6b\x0b\xeb\x17\xae\xdb\x12\x63\x1d\x37\xbd\xc2\xab\xd7\xda\xe8\xd5\x4b\x6b\x02\xa7\xe8\xd2\x87\x66\x84\xab\x75\xae\xea\x66\x65\xd7\xbe\x08\x2d\x0c\xe7\xb6\x44\xb3\xfb\xaa\x6e\xf3\xd9\x7a\x2e\x1f\x16\x7b\x6b\xbd\xe7\x98\x79\xd1\xae\x79\x15\xae\x6f\x01\x33\x2e\xd1\x2d\x4b\x34\x33\xae\xd6\xf1\x4c\x78\x86\x38\x5e\xc7\x4e\x27\x58\xdf\xd4\xdf\x8b\x05\x7a\x4f\xdc\xd9\x39\x88\xdc\xdb\x69\xe9\xdd\x3f\x48\x7f\x6b\xce\xd1\x57\x31\xcd\xa3\x56\x70\xba\x18\xa0\xcf\x78\x07\x58\xdf\xd1\xdf\xbc\xa4\x95\xb6\xb2\xd6\xa1\xd6\x30\xeb\x28\x6b\xac\x75\xa2\x75\x92\x75\x32\xf9\x2e\x39\x9c\x54\x92\x1a\xe2\x93\x23\xc8\xd1\xe4\x18\x7d\x52\x1b\x4d\xc6\x90\xb1\xe4\x78\x72\x02\x19\x47\x4e\x24\x27\x91\x1f\x92\x53\xc8\x44\x7d\x7e\x6b\x20\x8d\x64\x2a\x99\x46\x5a\x48\xab\x3e\xd1\xcd\x24\xb3\xc8\x99\x64\x36\x99\x63\xde\xd6\xfb\x3b\x79\x80\x3c\x48\x1e\x22\x0f\x93\x47\xc8\xa3\x64\x21\x59\x44\x9e\x20\x8b\x89\xe6\x11\xf2\x34\x79\x86\x3c\x4b\x9e\x23\xcb\xc8\xf3\xe4\x05\xf2\x32\x59\x4e\x5e\x21\xaf\x92\xd7\xc8\xeb\x64\x15\x59\x6d\xfe\xb5\x8d\x37\xc8\x9b\x64\x1d\x79\x87\xac\x27\xef\x92\xf7\xc9\x07\x64\x23\xf9\x90\x6c\x22\x1f\x91\x8f\xc9\x27\x64\x33\xf9\x92\x6c\x21\x9d\xb4\x0f\xad\xb4\x57\xdb\x6b\xec\xb7\xf4\x9c\x12\x3a\xa6\x1d\x14\xfc\x0b\x29\xe1\x7d\x93\xff\x25\xf7\xbb\xd7\x9b\x77\x37\xfb\x06\x32\xbe\x26\x90\xc4\xfc\x55\x04\xbd\xd6\xb4\x0c\x35\xb2\xc6\xb4\xbc\x58\x94\x61\x3b\xf9\xa2\xd8\x9f\xac\x0b\x24\x33\x7f\xa9\x10\xea\xc4\xd8\x79\xc5\x16\xda\x66\xe4\x85\x11\x69\x70\xe9\xe9\xc5\x96\x50\x1b\xdb\x50\xc4\x02\x4a\x44\x86\xa3\x50\x5e\x5f\x6a\xf3\xd6\xf6\xe0\x53\xa3\xcd\x1e\x52\xd4\x1f\x2d\xc3\xc2\xa8\xdc\x61\x9f\x6c\xdf\x1b\xdd\x3c\x10\x9d\xfb\x76\x67\x8d\x51\x99\xc8\x4c\x2f\x2c\x6a\x86\x2c\xfa\xe4\xeb\xdc\xef\x0e\xdf\xae\x28\xde\xef\xae\xc5\x5f\x03\x5d\x5d\xd8\xb3\x8b\xff\xbb\xf7\x2c\xde\x03\x0c\xdf\x87\x14\x11\x69\xde\x12\xc4\x7b\xa4\x75\xc5\x96\xe8\x1b\x95\x78\x47\x31\x7c\xf7\x2f\xfa\xb6\xe4\xbd\x45\x3d\x78\xb3\xd1\x3c\xe3\x88\xcf\x33\x2d\x97\x47\x9e\x4d\x5c\x15\x29\x47\xde\xd7\xc5\xf3\x8b\x35\xc5\xfe\x51\x89\x37\x24\x2f\x8f\x68\x88\xda\xbc\xb5\x3d\x43\xad\x92\xe7\x41\x3d\xc8\xe7\x8a\xf2\xeb\xfa\x64\x9b\xde\xb8\xb7\xd4\x03\xdd\xe6\xbe\xfd\x59\xa7\x8a\xed\xa1\x4e\xcc\x3a\xf2\x6e\x6a\xe4\x1d\xd1\x1d\xdf\xb3\xff\xca\x1b\x21\x83\x34\xc2\x44\x9d\x02\x5b\x5b\xac\xe0\x5f\xaa\xb2\xac\xd9\x3a\x9d\xa7\xd3\x45\x3a\x05\xb3\xba\x5a\xa7\xe0\x2d\xc5\x1b\x74\x0a\xd6\xf9\x76\x9d\x82\xe7\x4c\xf7\xe8\x74\xbf\x4e\x8f\xea\x14\xcc\xe3\x19\x9d\x5e\xd4\xe9\x55\x9d\x82\x99\xbe\xad\x53\xf0\xbc\xeb\x63\x2b\xb6\xe5\xbc\xe0\x5d\xa4\x2d\xb7\x19\x19\x2d\x6f\x2d\x47\x6f\xd5\xf2\x5c\x64\xd4\x79\x3b\xa0\xa1\x3b\x8a\xd5\xf5\x8e\xe5\xd6\x7d\xf0\x3d\xbe\xeb\xbf\xfc\x7b\xfc\xb2\x79\x2e\x6c\xfe\xb2\x26\x76\x63\xf1\x79\x76\xfc\x2a\xd3\x92\x8a\xb4\xcf\x2b\x4a\xb4\x2f\x8e\x3c\xc9\x3e\xb0\xf8\x69\xf8\xf7\x23\xe8\x73\x56\x64\xac\xd1\x19\x9f\x13\x91\x21\x56\x4d\xc4\x86\x95\xc5\x27\xe2\xf1\x7b\x8b\xed\xdb\x94\x2f\x6f\x65\xf3\x56\xf6\x84\x3a\x43\x6d\x78\x7e\xbf\x95\x84\x9e\xa8\xdc\x61\x9f\x6c\xcb\x1b\xf0\x43\xd4\x03\xd1\xb9\x6f\x77\xd6\xe1\xdf\x7c\x84\x6f\x1e\x84\xef\x20\x85\x7f\x41\x02\xcd\x07\x96\x20\xee\xf8\xf7\x78\xfb\xef\xe9\x05\x6f\xbc\x1c\xaa\xd3\xe1\xd6\xd7\xfd\xab\x97\xae\x99\x84\xb6\x6e\x2a\xce\x13\x7f\xed\x72\x63\xc4\xe2\x31\xc5\x3e\xe8\xbf\xb5\xac\x0b\xfe\xc2\xe5\x7f\x2d\x17\x46\x38\x2f\x76\x77\xcf\x5c\x18\xb6\xe3\xea\xbc\x0d\x2e\x34\xfe\xee\x81\x0b\xf1\x06\x40\x38\x76\x60\xb1\x6c\x5d\x5c\xe4\xa1\x28\x2b\x6c\xeb\xaf\x50\xba\xb1\xe9\xbd\xdb\xe5\xc2\xab\xbe\x9a\x0b\x31\x6a\xf1\x36\xb8\x70\xbb\x3e\xd9\xa6\x37\xb6\xe2\xc2\xe8\xdc\xb7\x3f\x6b\xe8\xdc\x2e\x17\x46\xf4\xfc\x7f\x82\x0b\x75\x3e\xc0\x2a\xfe\x65\xc6\x80\x48\x4b\x51\xae\x28\x7a\xbf\x5b\x9f\xeb\x03\x19\x3b\xdc\xc8\x83\x8b\x52\xfb\xb7\xd8\x67\x2b\xa9\xf7\x5f\x50\x9e\x19\xf1\xf5\xe5\xa6\x3d\x22\x83\x7f\x99\x47\xeb\x2d\x3e\x2d\x0f\xda\x82\xff\xcb\xcd\x73\xeb\x15\x9d\xfb\xe2\xd9\x63\xdc\x7c\xc2\xbf\x5c\xd3\xf5\xff\x96\xa9\x5b\x3d\x75\xb4\xcc\xd3\x48\x6b\xf1\xf7\x6e\x78\x32\xc8\x17\x8d\xbc\xe0\x70\x53\xbf\x62\xc3\xe4\xff\x27\x00\x00\xff\xff\x0e\xa8\xda\x55\x1c\x56\x05\x00") + +func liberationsansBolditalicTtfBytes() ([]byte, error) { + return bindataRead( + _liberationsansBolditalicTtf, + "LiberationSans-BoldItalic.ttf", + ) +} + +func liberationsansBolditalicTtf() (*asset, error) { + bytes, err := liberationsansBolditalicTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationSans-BoldItalic.ttf", size: 349724, mode: os.FileMode(420), modTime: time.Unix(1459927770, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationsansItalicTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xbd\x77\x60\x54\xd5\xf6\xf7\xbd\x4e\x99\x99\x10\xd2\x48\x42\x12\x08\xc9\x4c\x12\x12\xc0\xd0\x43\x6f\x19\x5a\x04\x69\xa1\x04\x12\x7a\xe8\xd2\x21\x41\x8a\x08\x01\x51\x10\x41\x40\x8a\x20\x20\xa0\xa2\x88\xa8\x43\x11\x02\xa2\x82\xa0\x88\x82\xa0\x02\xa2\xa0\x20\x08\x01\x01\x41\xc5\x46\x99\xf3\x7e\xce\x99\x09\x22\x57\xaf\xbf\xdf\xf3\x3e\xff\x3d\xb9\xf7\x9b\x7d\xce\x3e\x6b\xaf\xf2\x5d\x6b\xef\xb3\xf7\x0c\x88\x28\x22\x12\xc1\x2f\x5d\xaa\x67\x64\x74\x69\x97\x1b\x1f\xf9\x8e\xd8\x86\xdf\xa2\xb7\xdc\xfd\x2d\x5a\x66\x4c\x91\xfc\x1a\x62\x2b\x53\x91\xfb\x59\xf7\x67\x76\xe8\xfc\x7a\x8b\xb0\xc7\xc4\x96\xb8\x48\xe4\x81\x41\xf7\x77\xce\x6a\x16\x3b\xe2\xc9\x1e\x3c\xf7\x88\x04\x9c\xe9\xd0\xb9\x5a\x4d\x79\xe9\xe3\xaf\x44\x94\x42\xe4\xfb\xf6\x1f\x91\x3b\x3a\x7c\x69\x8f\xbd\x22\xf7\xcd\x11\xb1\x57\xed\xff\x50\xbe\x6b\xcc\xf6\xfe\x4e\x91\x46\xd7\x45\xd4\x59\x83\x46\x0f\x1e\x31\x25\x77\x6b\x29\x91\xea\x3b\x45\x1c\x5b\x06\xe7\xe6\x8d\x96\x18\x29\x81\xbe\x18\xc6\x87\x0d\x1e\x3e\x71\x50\xda\xe7\xd3\xbf\x11\x19\x7c\x5d\xf4\x4a\xe5\x87\x0c\xcc\x1d\x60\x5c\x79\xac\x09\xfa\x1b\xf1\xbc\xce\x10\x3a\x82\x2b\x07\x1f\xe2\x3e\x9f\xfb\xf2\x43\x46\xe4\x4f\x38\x96\xbd\x69\x3d\xba\x19\x5f\x31\x7f\xd8\xc0\xb1\x23\xf3\x17\x0f\xdc\x24\xfa\x02\xee\x23\x2b\x0e\x1f\xd5\x3f\x37\x2a\xa0\xc9\x2e\x91\xf4\xc9\x3c\x9f\x30\x22\x77\xc2\xe8\x90\xbe\xb6\x85\x8c\x5f\xca\x78\xd7\xc8\xdc\x11\x03\x8f\xdf\xf7\xd3\x06\xd1\xd7\xba\x45\x4a\xbe\x31\x7a\x54\x5e\x7e\xcb\x97\x3b\x1d\x14\xdd\x73\x4d\x64\x48\x85\xd1\x63\x07\x8e\xee\x7b\xf0\x94\x2a\x52\x6f\x34\x84\x3d\x6a\x71\xc7\xdd\xfb\xef\xaf\xca\xea\x13\xda\xe8\x17\xd5\x19\x20\xe6\xcf\x81\x85\x71\xad\x8a\xdb\x1b\x9e\xdb\x0b\x03\xcf\x06\xc4\x21\x67\x3e\x54\x2c\x01\x7e\x3b\x9a\x78\xdb\x4b\xf3\xc0\xf5\x37\x3c\x37\xba\x06\x9e\x95\x01\x52\x5a\xee\xfa\x09\x8c\x33\x65\x02\xe3\x94\x4e\xd2\x45\x06\x8a\x9d\xd1\x61\x52\x4d\x7a\x8a\x68\x13\xb4\xf5\xe4\x4a\x11\x4d\x5f\xa5\xcc\x17\x9b\x88\xed\x59\x5b\x9a\xc4\x2b\xb1\x56\xdb\x5d\xfb\x54\x06\xa9\xe1\x01\x36\xb5\xa4\x5d\x57\x55\xb5\x84\xaa\x9f\x96\x40\x23\x53\x26\x18\xa8\x4d\x30\x75\xd7\x68\xda\xb9\x39\xe3\x5d\xc6\x2d\xdb\xe7\xde\x6e\x4a\x9a\xa3\x89\xb2\xa9\xaf\x28\xef\x9e\xfa\x8d\x98\x1a\xd8\xa6\x99\x4c\x48\x88\xdd\xef\x89\x5a\xff\x0e\xda\xa9\x5f\xc8\x5b\x7a\x9e\x54\xd0\xf3\x8c\xeb\x8e\x38\x79\xda\xd6\x55\x12\x94\x99\xf2\x91\xba\x5e\xfa\xaa\xeb\x8d\xfa\x5a\x9c\x4c\xd0\x37\xc8\x74\x64\x93\xe9\x7b\x90\x36\x53\xad\x6f\xcc\x61\x4c\x0e\xa8\x6d\x8e\xa3\xad\x0e\x82\x41\x55\x90\x07\x8e\x80\x3a\x20\x03\xf9\x8e\x20\x05\x1d\x8f\x9a\x7a\xac\x36\x4f\x56\x05\x38\xe5\x3d\x5b\x57\x63\x39\xf6\xd2\x6d\xfb\x64\x0c\x48\x37\xaf\xf5\xb3\x92\x6e\xaf\x2f\x03\xcd\x7b\x73\xac\x2e\xc6\x4d\xab\x3f\x8f\xfe\xf5\x96\xac\xf9\x7c\x94\xd9\x57\x2c\xc7\x75\x03\xc6\x15\x72\xbd\x8c\xeb\x8d\x8e\xb9\xb2\x11\xdd\x5f\x72\x7d\x54\x3f\x6b\x1c\xc7\xdf\x2f\xd1\xf5\x34\x6d\x37\x6d\xb7\x54\xc4\x67\x62\xc3\x17\x9f\xbf\x71\xba\x48\x73\xda\x96\x26\x90\x33\x5b\x1d\x24\x2a\xfb\xe0\x62\x9f\x11\xcb\x73\xeb\x1a\xfb\x89\x66\x3f\x40\xde\x38\x68\xc9\x9b\x7d\x24\x8c\x71\xbd\xb8\xef\xca\xf5\x68\xfc\x18\x84\xdf\xaf\x83\x39\xe0\xba\xba\x41\x4a\xab\x91\x72\x54\xdd\x60\xe4\x12\xff\x24\x8b\xfb\xf5\xe2\x46\xfe\x39\x3f\x7f\x73\x41\x15\x53\x86\xfb\x6f\x78\xf6\x84\xed\x1c\xf1\xff\x6a\x71\xdc\x96\x31\x03\x4c\xee\xcd\x3e\x7d\x98\x71\x55\x4b\x93\xbd\xfa\x00\x69\x4a\x5f\x3c\xa8\x0d\xde\xd0\x57\x18\x86\xde\x56\xe6\xab\xeb\x2d\xdd\xf7\x83\xc6\xea\x65\x19\xc8\x78\x9b\x7d\x83\xf4\x05\xd5\xc0\x2c\x78\x6a\x0a\x37\xaf\xfd\x0d\x96\x07\x88\xf1\x86\x95\x8b\xae\xbe\x5c\x14\xc3\x9f\xc3\x3b\x40\x26\xb1\x38\x0f\xf7\x02\x5f\x37\xd8\xeb\x1b\x1f\x5a\xb9\xb8\x1b\xe4\xc2\x9f\x5f\x93\xbf\x5a\x7f\x07\xea\xcf\x75\x77\x2e\xee\xca\x49\x8e\x1f\x0d\xcc\xd6\xc7\xbf\xa5\xa7\xf5\x7f\x60\x80\x74\xc2\x46\x65\x2b\x17\x77\xc3\xcc\x85\x99\x33\x5a\x33\x56\x33\xf7\xff\xd1\x12\xbb\x69\xff\xbf\xb4\xe9\x4c\xce\x96\x66\xfc\xa6\x5f\xfe\xba\xfc\xd7\xd6\xac\x53\xb3\xa6\xfe\xa9\x35\xf5\x9a\xf1\xd0\x36\x31\x5b\x93\x63\xea\xee\x27\x5f\x5b\x7c\x6f\xb6\xc6\x2e\xfa\x1f\xf5\xe7\x21\xc7\xf6\x8d\x74\xd4\xe6\x4a\x82\x39\x47\xcc\x3a\xb5\xec\x89\x55\x8f\xa6\x7f\xe9\x66\xcd\xfa\x5a\x63\xa7\xd9\xaa\x6e\xdf\x3d\xf5\x63\xb6\x2a\xcf\x55\xbf\xed\x94\x7b\x5b\xfd\x92\xa4\xd9\xf6\xfb\xfc\xb2\xf2\x0a\xe7\xf7\xb6\x2c\x7e\x03\x99\x6b\x2d\xad\xb9\xba\xde\x57\x13\xac\x19\x1f\xdf\xb9\x37\xe7\x25\x73\xe3\x9f\x5a\x73\xce\x12\x47\x88\xd5\x1e\x65\xfe\xf8\xee\xcb\x98\xf5\x62\xe6\xec\x7f\xda\x5a\xf3\x9d\x39\x67\xcd\x77\x2b\xbf\xbe\x79\x6f\xce\xbd\x7b\xda\x8b\x7e\x4e\xe2\x6c\xc7\xa5\xb3\xad\xb6\xc5\x77\x1c\x6d\x63\xab\xdd\x27\xa9\x77\xe5\x3a\xd1\x9e\x21\x99\x3c\xbb\xdf\xaa\xc3\xb1\x52\x85\x3a\x39\x43\xec\x93\xf4\x8b\x92\x89\xbe\x48\x3d\x4f\x29\x67\xe6\x50\xfb\x43\x6a\x38\x4a\xf8\xd6\x08\xfc\xaf\x5e\x9c\x07\xee\xa3\xb5\x6b\xc6\x8b\xf6\xf7\xa5\x9d\x6d\x9f\x29\xef\xe3\xd2\x3e\x05\xfe\x8e\xc1\xe3\x4f\xac\x63\xdd\xb0\x85\x2f\x66\x6d\xfa\xe7\x5b\x67\xc6\x56\xd6\x0f\x18\x37\xe0\xd0\x83\xbe\x50\x78\x99\x6e\xad\x2f\xf0\x63\xcf\x61\x2e\x85\x4b\x57\x7b\x94\x4c\xc4\xc7\xc5\xb6\xb7\x7d\x31\xfb\xe3\x3b\x42\x5b\x08\x2e\x73\xfd\x2e\x78\xcd\x5a\x5f\x4a\x1b\x37\xb5\x69\xc6\xaf\xe8\x8d\x32\xed\xb0\xce\xec\xd5\xda\xcb\x3e\xe6\xea\xe3\xe6\x3b\x20\x90\x75\xb5\x04\x39\x0b\x20\xce\x00\x73\x9d\x6d\x40\x8d\x3c\x25\x09\x66\x9f\xe3\x29\xeb\x3e\xb1\x78\x8e\x14\xd7\x62\x71\x0d\xfc\x4f\x73\x04\x9a\xde\x3b\xdf\xcc\xf5\xc6\x9c\xf3\xe8\x9a\x80\x5f\xef\xdf\x99\x0f\x7e\xfe\xee\xad\x37\x2b\x36\x31\x96\x9a\xb5\x7e\xb7\xcf\xc5\xe3\x02\x32\x18\xf7\xa3\x71\xe1\xce\x7c\xfa\x0f\x3b\xc6\x87\xe6\xda\xf0\x9f\xf3\xff\xaf\xf3\x95\x18\x1b\x82\xf8\xe2\x79\x76\xaf\x1f\x7f\xad\x77\xab\xfd\x6b\xcc\x7f\xad\xef\x86\x7a\x4f\x63\x87\x36\xc5\x78\xe6\x8e\x5f\xdd\xc5\x6d\xb3\x53\x53\xd4\x00\xe8\x5b\x9c\xbb\x7b\xfd\xf9\xa7\x79\x77\xc7\x0f\x7f\xbd\xab\xdd\xbd\x86\x2d\x80\xf5\xe1\x43\xa3\xaf\xc9\x8d\xa3\x94\xd4\x73\x04\x49\x3d\xeb\xfd\xba\x4f\x6a\x22\x33\x11\xf9\x6a\xd8\xd9\x88\x5f\x76\xee\x8f\xea\x6b\xe5\x25\x6d\xb5\x64\x23\x73\x03\x19\x37\xed\xf3\xe8\x33\xdf\xe7\x13\x8a\xd7\x13\x7b\x20\x73\x21\xcf\x9a\xdf\x25\x88\xd3\xce\xf3\x25\xbe\x75\x54\x32\xfc\x6b\xb3\xcb\xff\xfe\x8c\xa1\xff\xeb\xbb\xd6\x6c\xb7\x95\xef\xe7\xa5\x99\x36\x43\x12\xb5\x42\xe3\x67\xfd\x0a\xf5\x17\x6e\x72\x6b\x74\xf2\xbf\x5f\x75\x7d\xb0\x34\xd3\x55\x19\xa9\x5f\xb5\xf2\xd7\xd5\xbf\xa6\x9b\xf3\x26\x04\x34\x52\xbf\x34\x8e\xf9\xdf\xc1\x87\xc1\x2d\x7d\xba\x94\xe6\x1d\xdc\xd5\x0f\x64\x79\x37\x9b\x63\x5e\x81\x6f\x93\x17\x97\x34\xb3\x37\xb4\xe6\x72\x33\xd6\xa1\x2d\x77\xe1\x30\xfe\xab\x20\x06\xe4\xe9\x19\x8c\x31\x21\xc6\x76\xb5\xb3\xf7\x86\x3a\xc6\xc8\x54\x3b\xf2\xec\x43\xa3\x2d\xfe\x7d\x6b\xad\x49\x79\x12\xa8\x4f\x83\xbb\x41\x32\x04\xb9\x17\x99\xbf\x6b\xcc\x56\x8f\x97\xc9\xd6\x3c\xcb\x05\xd4\x22\x78\x86\xf8\xb7\x82\xa7\x40\x39\xee\xaf\x59\xf9\x89\x81\x9b\x70\x09\xb3\x62\x1c\x4c\x6e\xb2\x99\xff\x62\x6c\xd6\x16\xfb\xde\x1d\x16\x5f\x22\xed\x1c\xc3\xa4\xa5\xa3\x09\xd8\x07\xcf\xbd\xa5\x97\xe6\x91\xc1\xb6\x57\xa5\x9d\x5d\x65\x2d\x4a\x64\xad\x7a\x57\x12\xb4\x33\x52\x57\xaf\x67\xdc\xb6\x65\xc9\x78\x13\xea\x78\x09\x06\x41\x72\xc3\x78\x4a\xd9\x2d\x55\x40\x39\x10\xab\xae\x94\x54\x3d\x52\x9e\x52\xf7\x1b\xd7\xad\x3d\x1c\x7b\x3b\xf8\x3b\x0d\xbe\x50\xf6\x29\xe4\x50\x19\x0d\x0a\xd4\x2f\xe5\x00\x78\xd1\xbf\x27\x33\x31\xd0\x04\xdc\xb4\x03\xb3\x90\x59\x4a\xfb\x14\x6d\x6b\x90\xc0\x75\x1f\x38\x5c\x4d\x1b\x07\x2a\xc2\x4f\x0b\xb5\xbe\x12\xcd\xf5\x2b\x7e\x8c\xfa\x13\xc6\x25\x73\x6f\xc5\xb8\xae\xb4\xfb\xfd\x7b\x11\x73\x8f\x62\xca\xf7\x03\xe9\xea\x25\x59\x21\xef\xe0\xef\x32\x29\xaf\x6e\x34\x6e\xe1\xcb\xeb\x5a\x98\xac\xbe\x17\x7e\x79\x60\x4c\xa5\x5d\x0b\x36\x80\x58\x50\x0e\x64\xfa\x11\xef\xb3\x67\x7c\x01\xd6\x83\x46\xf8\xb7\x0c\xfb\xc4\xa3\x0c\xe6\x59\x10\x08\xd0\xaa\x1a\x6f\x83\xb7\x78\xbe\x5f\xe4\xf6\xef\x22\xde\x49\xe0\x4d\x91\x5b\x95\x69\xcf\xd0\xb7\x5a\xc4\xa0\xdf\x58\xc2\xfd\x71\xee\xdf\xe6\xba\x1e\xd7\x53\xc1\x16\xae\x5f\x06\xec\xdc\xbc\x9c\xa3\xbc\x5f\x83\x93\xdc\x4f\x00\x79\x60\x99\xbf\xed\x01\x3a\x80\x74\xd0\x1b\x99\x99\xe6\x99\x87\xeb\x17\x40\x5b\xd0\x0e\xb4\xa1\x9f\xb3\x91\xf7\x30\xd7\xe8\xba\x15\xce\xf5\x33\x3e\x5b\x46\x33\xae\x39\x47\x19\xf1\x60\x98\x6f\xbc\x77\x25\x98\x07\x06\x81\xe7\xc0\x3b\x60\x3a\xf8\x16\x1f\x57\xd1\xb2\xe3\xf3\x3e\x0a\x38\xbf\xdd\x5e\x43\x8b\x49\x6f\x47\xc6\xcf\xf3\x8d\x37\x5a\xd0\x3e\x4f\x9b\x0c\xfa\x73\xfd\x10\xe0\x6c\x64\xdc\xf0\x8d\x33\x38\xf7\x18\xcb\x41\xa1\x4f\xfe\xf6\x5b\x5c\x27\x81\xda\xdc\x13\x97\x77\x16\x18\x05\xae\xfa\x62\xbb\x1d\x85\x81\x86\xa0\x25\xf7\xcf\xd2\xff\x3e\xb8\xe9\x47\x1d\x5f\xbf\xfc\xc2\xb3\xa6\xdc\xbf\xeb\x8f\xab\xb5\x8f\x2b\x2f\x1c\xdd\xe6\x9c\x66\x74\xbe\x0b\x8c\x31\xda\x33\x26\x8e\xd6\xd4\xd9\x0b\x74\x07\xdd\x00\xe7\x42\xaf\xc9\xf1\x5a\x9e\xa7\xf8\x79\x8e\x20\x9f\x7f\x80\x71\x20\xdb\xb7\xf6\xb0\x8e\xd2\x9a\xe7\x0c\xfa\x2e\x92\xe3\x5b\xe6\xda\xc7\xfd\x5a\x7b\x07\x69\xcb\xfb\xb7\xb5\x56\x4e\x5a\xdb\xbb\x1b\xbf\xd9\x2f\xcb\x07\xf6\x34\xc3\x60\x4e\x54\x2d\x3e\x7f\xe8\xf3\x79\xef\xf6\x36\x8e\xfb\xf6\xa7\xb4\xbe\xbd\xed\x40\x6b\xaf\x6b\xbd\x93\x8d\xe7\x8b\xcf\x1e\xb6\xea\xc6\x4f\xd6\xf9\xe3\x80\xff\xbc\xc2\x7b\xda\x3a\x7b\xb0\x16\xdb\x37\xc9\x14\xf3\xdc\x61\x5f\x2b\x87\x79\x3f\x3b\xfd\xe3\x8f\xa2\x3f\xc3\x5c\x07\xf5\x31\xd6\xda\x96\x6e\xad\x29\xf4\xe9\x4f\x1b\x9f\xe0\xf7\x28\xf6\x16\xcd\xad\x75\xf2\x4d\xd6\x2e\x64\xf4\x6e\x32\xd0\x92\xe3\x1d\xc8\xfe\xe1\x05\xbd\x1f\xeb\xb5\x48\x7f\x6d\x21\xeb\x80\xb9\xee\xf7\x94\x1e\xfa\x62\xe3\x13\xed\x3b\xe2\xfe\x9c\xb9\xe8\x95\x36\xa6\x4e\x5b\x3d\xf6\x2a\xbd\x8d\x61\xb6\xcf\xe4\x21\xd6\xc1\xe6\x77\x6c\x99\xef\x4e\x5a\xb3\x4f\x0f\x64\xed\x19\x24\x49\xb6\x1d\x72\xd4\x11\x22\x05\x66\x6b\xae\x97\xd6\xba\x39\xdd\x78\xc9\xff\x6e\x69\x46\xac\x1f\x60\x33\xcc\x3c\x8f\x69\x76\xe3\x90\x6e\xc8\x00\xbd\x91\xb8\xed\xc1\x9c\x9b\x56\xca\x45\xfb\xfb\xc6\x27\xf6\xf5\xc6\x51\x5b\x7f\x79\x19\xf9\x17\x6d\xfd\xd9\x73\x94\x31\x56\x12\x6f\x3b\x13\x1c\x51\x07\xe8\xef\x4b\x1b\xdb\x6f\x92\xaf\x8f\xe4\x3d\xd0\x49\xca\xaa\xdf\x48\xbc\x69\x43\x7f\x5e\xca\x9a\x39\xb3\xde\x31\xd8\xd3\x66\xf2\x7c\xa6\x71\xd6\xf7\xde\x63\x1f\xc4\x1e\x0c\xbe\x9b\xd8\x26\x63\x77\xb1\x31\xae\x78\x5f\x66\xb5\xfe\x33\x89\xfd\x1d\x29\xd4\xbb\x73\xfd\x0a\x67\xc0\xae\xd6\xb9\xa0\x63\xf1\x79\x31\x60\xa6\xb1\xd0\x71\x12\x99\xdd\xc8\x6c\x43\x66\x3b\x88\x63\xfd\xfc\xc8\xca\xe5\x72\x73\xdf\x67\xd9\x32\xc7\x3f\x6f\x98\xef\xd1\x74\x07\x67\x20\xf6\x75\x11\x96\x2c\xb0\xc6\x4d\x36\x16\xfe\xe5\xcc\xe9\xcf\xb9\xb5\x47\x34\x73\x8e\x4e\x7b\x4f\x99\x64\x9d\x35\x3f\xa5\xbf\xbf\x7c\xe2\xe8\x85\xae\x7e\xc8\x8f\x91\x42\x47\x34\x76\x4c\x5b\x73\x25\x32\xa0\x2a\xcf\xf3\x8d\xb5\xe6\xfb\x5d\x2f\x90\x07\xf5\x2a\x52\x41\xfb\x89\x7d\xde\x70\xdf\x79\xc7\x36\xcd\xd8\x6a\xbd\x27\xfd\xe7\x15\xcd\x3c\x63\x3c\x6a\x3c\x67\x9b\x4c\x3b\xd8\x7f\xe6\xb4\x5a\xf3\x0c\xc3\xbb\xce\x3a\x77\x1a\x73\xec\x6f\x58\xef\x92\xd7\xf5\x85\x9c\x8b\xca\xcb\x13\xf6\x17\x79\x37\x1e\x42\xc7\xef\xe4\xf0\x2c\xfb\xf8\xda\x92\xa2\x5d\x95\x12\xbc\xf4\x79\xe7\x19\x87\xef\x7a\x47\x27\x6a\x76\xde\x2d\xbf\x59\x73\xc7\xe6\x7b\xcf\x4a\xaa\xb5\x7f\x68\x65\x3c\x67\x5f\xe5\x7b\x17\x6b\xbe\xb3\x8e\xff\xfc\x24\x5d\x03\x87\x52\x1f\xef\x51\x2f\x91\x32\x98\x9a\x49\x74\xd4\x27\xae\xa7\xd8\xd3\x64\x1b\x2b\x91\x59\xe9\xb0\x73\x3f\x96\xbd\xdb\x1a\x89\xb4\x3d\x2c\xc1\x01\x35\xe0\xe2\x4b\x49\xd2\x2f\x1a\x57\x88\x6f\x05\x73\xe3\x1a\xf5\x79\xa7\xce\xd0\xb3\x51\x2f\x94\xd1\xc5\x6d\xc0\x37\x32\xca\x91\x43\xff\x2a\x9e\x1f\x90\x66\x81\xcd\x64\xac\x43\x95\x41\xc5\x76\x8b\xf7\xe7\x8c\x6d\xc0\x5a\x50\xc5\xb7\xbe\x48\x08\x70\xb2\x56\x0c\x67\x3d\x65\x9d\xbb\x35\xc8\xca\xa1\xb9\x17\x33\xf7\xf8\x70\x50\x5c\x5b\xda\x35\xde\x3f\xdb\x88\xa9\x3b\xbc\xd8\x25\xd8\x56\x91\xfe\x5a\xc4\x61\x9e\x81\xa7\x19\xeb\xa8\x81\x86\x56\x1e\xc8\xbf\x15\xfb\x3d\xad\xed\x47\x79\x55\x9f\x2d\xe3\xac\xbd\x1c\xf9\x70\x24\x10\xef\x72\x49\x0c\xd8\x4c\x9c\xdb\xac\xbd\xe0\x28\xfc\xfb\xd3\x4f\x73\xcf\xee\xfb\xdc\x60\xa7\xf9\xd9\x80\x95\x47\xde\xfd\x66\xcd\x98\x79\x73\x54\xa5\x8e\x2a\xb1\x0f\xa3\x76\xcc\xfc\xdd\xd5\xfa\xce\x5e\x07\xa5\x9c\x2d\xd2\xf8\xa5\xb8\x35\x6b\xdc\xef\xeb\x56\x9b\xce\x3e\xab\x22\xe7\x16\xea\xd4\xaa\x15\x9f\x4f\x65\x8a\x7d\x2b\xd6\x65\xd5\xf0\x64\xdf\xf9\xe4\x9f\xf6\xe0\x77\xed\x39\x27\x99\x7b\xb7\xe2\xb6\xd8\x96\x39\x37\x2c\x5e\x68\xcd\x7d\xcf\x1d\x7e\xfd\x2d\xf2\x43\xfe\x76\x8f\x4a\xed\x9b\xf5\x67\xce\x15\xeb\x6c\x76\x6f\xeb\xf7\xd1\x9c\x8b\xe4\x23\xc9\x9a\x33\x66\xdd\x76\x37\x5e\x61\xdd\xe9\x51\xcc\xd3\x9f\xad\xb4\x37\xfd\x74\xac\x94\xf6\xf6\x57\x69\xa7\xca\x5e\x7b\x39\xc6\x5f\xe4\x4c\x53\x28\x4f\x38\x8e\x33\x67\xf7\x1a\xcf\x05\x94\x25\x1f\x6b\xad\x33\xc4\x40\x73\x0f\x66\x3b\x29\x85\x01\xdf\x93\x07\xce\x6e\xe6\x5a\x6b\x71\xf6\x2a\x75\xee\x3b\x3b\xb4\x2c\x3e\x43\x52\x43\x0b\x44\x14\xdd\x57\x53\x0a\xef\x6e\x45\xf5\xbd\xab\xc5\xac\x35\x9e\x19\xd3\x7c\xef\x7a\xef\x0a\xfa\x9e\xf7\xc1\x7c\x5f\x79\xd9\x57\x08\x30\x78\x01\x7b\xf7\xf8\xdf\xd5\x9f\x02\xf3\xbd\x6a\x07\x07\x79\x4e\x6d\x7a\xcf\xf9\x9e\x8b\xf9\x8e\xbd\xe8\xd3\x67\xbe\xdb\xcd\x71\x06\x36\xbd\xa6\xae\x11\x3e\x18\xd1\xb4\x2f\xfa\xdf\xb1\xfb\xfd\x36\xc6\xf9\xe0\xe5\xdd\x6b\x7c\x0e\x9c\xec\x95\xcc\x97\x7e\xa4\x3e\x4d\x69\x5c\xfc\x9c\x3a\xe9\x44\xfb\x04\xcf\x03\xb5\x00\x49\xa3\x5d\x67\xb3\x1b\x27\xf4\xfd\xc6\x65\xad\x1f\x5c\x8e\x92\x79\x9c\x23\x33\x38\x0b\xb6\x52\x97\xb0\xb6\xb6\x90\x56\xb6\xfa\x32\x8f\xfb\x42\xf6\xc6\x73\xf5\x34\xe3\xa2\xde\x58\x3a\xd9\x46\xd0\x3f\xd5\x38\xab\x46\x1a\xb7\xb4\x38\xe3\x5b\x5b\xba\x4c\xd5\xd7\x19\x3b\xf5\x5b\x32\x53\xff\x56\xd2\xf4\x00\x59\xc0\xf9\xe6\x07\xbd\x90\xfd\x39\xe3\x6c\x5f\xc8\x16\xdb\x4c\xe3\x0b\xf6\xbe\xad\x40\xa1\x09\x2d\x52\xa9\xaf\x7f\xae\xd4\xd7\x0c\xc3\x63\xdb\x69\xbc\x42\xbd\x35\xd6\x15\xe3\x17\x6b\x7e\x8c\x61\x6d\x18\x63\xdc\xd0\xde\x97\x24\xb3\xbe\x58\x7f\x3e\xd3\x32\x8d\x1f\xad\x77\xdf\x62\xce\x72\xe6\xfa\xe7\x41\x26\xcf\xf7\x8e\xa7\x2d\x4f\x5b\x9e\x79\x95\x65\x7e\xf6\xa0\xad\x13\x27\x7d\x0f\x98\x6b\x89\xde\xca\x5a\xe3\x0e\xe1\x47\x45\x3d\x8e\xfd\xad\xf5\xee\x33\x4e\xdb\x16\x1b\x5e\xda\xcd\x77\x7d\x36\x77\x1d\x5b\xb7\xa8\x97\xf2\xfa\x09\xe3\xb0\x59\x77\xd6\xde\x7e\x30\xe3\xd0\xc1\xfa\xf4\x82\x39\x9f\xb4\x1f\xa4\x34\xe7\xeb\xd2\xda\x1a\xe9\x0b\x7a\x68\x87\xa5\x8b\xb6\xd2\x42\x13\xed\x92\x3c\xa8\x1d\x92\x2e\x4a\x6b\xe9\xa2\x6e\x90\x06\xda\x32\xfa\x55\xe9\x02\xaf\x5d\xb4\xfd\xd4\xd8\xc7\xe0\x0f\x19\xa8\x85\x4a\x8e\x36\x8d\xbe\x97\x41\x65\x79\x41\x9b\xcb\x7b\xda\x25\xbb\x79\x17\xd6\x07\x59\xea\x11\xfc\x7e\x9b\xf7\xd7\x14\xc3\xcb\xf3\xc7\xb5\x32\x32\xd6\x84\x9a\x29\x49\x20\x41\x4b\x64\x9d\x33\x44\x53\x1f\x97\xca\x9a\x21\xa1\xea\x38\xd1\xb5\x8a\xec\xb3\xbf\x40\x7f\x45\xc9\xb7\xae\xaf\x1a\x37\x94\xf9\x52\x80\xae\x1e\xda\x4e\xce\x93\xb5\xa5\x8d\x7a\x52\x96\x69\xb3\xa4\xae\x56\x5d\x02\xd4\x6b\xec\xaf\x83\x64\x24\x7e\x8c\xd0\x82\x8c\x13\x62\x18\xc7\x95\x99\xc6\x71\xf5\x08\x79\x3d\x89\x8d\xea\xc6\x46\x64\x2a\x69\x25\x8c\xcf\xb5\x69\xac\xd3\x41\xc6\x30\x47\x3b\xeb\x3d\x14\xe1\x3b\x0f\x1b\xab\x79\xd7\x9b\x9f\x25\x70\xbe\xf5\xfe\xc4\xfe\x6a\xb4\x09\x38\xfb\x8e\x67\x2b\xac\xf3\x50\x9e\xf1\x91\x56\x52\x3a\xe8\xf9\xc6\x69\x7b\x8c\xf1\x1a\x6b\x4d\xb8\x09\xeb\x7d\x35\x88\x7d\xc4\x34\xe3\x27\xeb\xac\xe8\xd3\xd7\xdb\x36\x9d\xf3\x9f\xf5\x19\x89\xd1\xe8\xcf\xcf\x55\x8d\x83\xe8\xb5\xce\xce\x5a\x8c\xf7\x86\xb5\x5e\xfa\x3e\x47\x3d\xa2\xfb\x3e\xab\xbd\xf3\x99\xa0\xff\x5c\xf9\x82\x2d\x52\x9a\x5a\x9f\xe9\x88\xb1\x53\xed\x6c\xd4\xb1\xde\x55\xe6\x79\xbb\x84\x0c\x52\xbf\x92\xa9\xa0\xb9\x56\x09\x8e\x32\xa5\xb5\xb2\x56\x16\x29\x6b\x8d\xdf\xe0\xb4\xbd\x7a\x4c\x96\xc3\x6b\x2a\x68\xea\x47\xaa\xf2\xad\x84\xd3\x26\xc0\xcf\x5a\x75\x84\x0c\x82\xef\x32\xa0\x89\x3a\xce\xe8\x09\xef\xa5\xd4\xcf\xa4\x11\x7c\x4f\x03\xd3\xd5\x5d\x12\x0d\x87\x4b\xe0\xbd\x3f\xcf\x42\xb5\xba\x32\x94\xb6\x11\x68\x09\xa7\x36\x75\x95\xa4\x82\x52\xf0\x5a\x5f\xdd\xc9\xf9\xa3\x92\xb0\x1e\x18\xec\x9d\xbd\xdf\xfb\xcf\x0d\xec\x8f\x8d\x9a\xfe\xfd\x2e\x67\x02\x23\x8b\x67\x97\xc0\x59\xae\xeb\x82\x1f\xb9\x7e\xf5\x9e\xcf\x04\xe2\xfe\xa3\xbd\xeb\xb3\x49\xff\x59\xfd\xbf\xb7\xff\xc3\xcf\x2c\xcd\x7d\x9f\xf9\x59\xf8\xdf\x7c\x46\x79\x4f\x6b\xec\x23\x6f\x2f\x16\xdf\x93\x5b\xf6\x12\xde\x3d\x77\x3e\xa3\xf4\x7f\x96\x73\x6f\xab\xfb\x3e\x97\x3c\xe9\x6f\xbf\xf5\xb7\xd1\xbe\xd6\xfb\x8d\xf9\xce\x32\xeb\xe2\xde\xf6\x9f\xfd\xf8\xef\x9f\x55\xde\xf5\x99\x49\x7a\xf1\x67\x6d\xfe\xbd\xe6\xdd\x9f\x5d\x9e\xf3\xb7\xe7\xfd\x6d\xf7\x7f\xfb\x0c\xf3\x9e\xcf\x7a\x8a\x3f\xc3\x8c\xa2\x7d\x06\x2e\xd6\xd0\x0e\xa0\x7d\xf0\x9e\xcf\x88\x4a\xf9\xdb\xa6\x7f\xf3\xd9\xd1\x46\x6b\x9d\xf2\xb7\xc5\xef\xa5\x7f\x6b\xff\xe6\x3d\x79\xf7\xe7\x82\xf7\x7e\x0e\x7a\xdd\x97\x2b\xe9\xe5\x5f\x0f\xcd\xbd\x5d\x55\x6b\x7f\xd0\x4f\x6a\xff\xe3\xe7\xe3\xff\xd7\xda\xff\x5d\x2d\xfe\xcd\xe7\x73\xc5\x9f\x8b\x47\x51\x33\x67\xff\x2d\xe7\xff\xd8\x16\x7f\x0e\xfb\x2f\xed\xbd\x39\xba\xf3\x19\xec\xbf\xb4\x7f\xf9\x3c\xfa\x6f\x5a\xeb\x0c\xf8\x5f\xe0\x3b\x9f\x1a\xcb\xed\xd3\x65\x1a\xd8\x70\x57\x3b\xd3\x84\xb5\x06\xfe\x0d\xec\xf1\x32\x11\xcc\x74\xbc\xce\x5e\xfa\x75\x79\xb6\xb8\xb5\xce\x96\xff\x05\xf6\x79\x8c\x9b\x27\x33\x03\x9c\x32\x0a\x3c\x7b\x57\x3b\xce\x84\x79\x9e\xfc\x6f\xd0\x14\x99\x08\x66\xea\x0b\xe0\x6d\x01\xf6\xfe\x6c\xc7\x59\xf0\x7d\x6f\xf3\x1f\xb0\xaf\xc4\xee\x4a\xec\x56\xc1\x5e\x15\xfc\xdd\x8f\xbf\xfb\x19\x67\xbe\xbf\xff\x0b\x4c\x0e\xcc\xb8\x02\xc2\xad\x18\x67\x9a\xe7\xdb\xff\x8a\x49\xd8\x99\x84\x9d\x40\xec\x04\x32\xe6\x25\xec\xbc\x64\xb5\xd3\x4c\x14\xf3\x5e\xcc\x63\x31\x2f\xc5\xf1\xdd\xf1\xb9\xd8\xbe\x5f\xef\xff\xdf\x3c\x62\xa3\xe4\x7f\xc3\xbf\xe5\xe5\xff\x56\xdc\xff\xcd\xf7\xbb\xa1\xae\x57\x7a\xb1\x66\x9e\xa3\xcd\xf6\x7f\x06\xf7\xfc\x3d\x3e\x27\x5a\x7e\x4f\x97\x2d\xe0\x65\xfb\xcf\xb4\x3f\xcb\xcb\xfe\xb5\x76\x9a\x1f\x33\xe1\x34\xed\xaf\x35\x64\x5c\x57\xf6\xfd\xf9\x7d\xa3\x36\x50\xb6\x80\x97\xfd\x9f\xfb\x99\x98\xf9\x1f\x75\xb0\xd8\xf8\xc4\x82\xff\xde\xff\x3d\xe3\x51\xec\xce\xb7\x9f\x97\xa1\xe6\x3c\x60\x5c\x17\x1f\x94\x07\xff\x8e\x1f\x07\x76\xa8\xbf\xd6\x8e\x66\xf2\x01\x3c\xb5\xb6\x3e\xbb\x59\xaf\xe4\x80\x61\xe6\x41\xc0\xfc\x92\xbf\xb8\x55\x5f\xb5\xfe\x78\x80\x28\xbc\xad\xa9\x05\xeb\x7b\x74\x85\x9d\xb8\xbc\x5a\xfc\x3d\xbf\x71\x0c\xb8\xc0\x17\xbc\xbf\xdb\xf2\x8e\xf9\xd9\x04\xe7\x2c\x0b\xd6\xf7\x2e\xc3\xcc\xcf\xe9\x65\x1f\x30\xbf\xcf\xbb\x41\x7b\x1b\xff\x16\x99\xdf\xfb\xf2\xce\xd9\x4e\xbb\x1d\xdd\xc7\x41\x0b\xf5\xa0\xe4\x62\x77\x87\x5f\x9f\xf9\xf9\x61\x78\x31\x4c\xbb\x3c\x4b\x53\x0a\x64\xab\x7a\xd4\x42\x7f\xc6\x9a\x9f\xbb\x86\x99\x9f\x2d\xa3\xeb\xb8\xd2\xf5\xf6\xe7\xf8\xf8\xd6\x5d\xe3\xc2\xfc\x28\x65\xde\x23\x5b\x01\xb4\x07\x2f\x80\x36\xea\x25\xe9\xa9\x7e\x63\xec\x61\x0f\x6a\x63\x9f\x13\xca\x5e\xf0\x3d\xae\x1d\xf8\xd2\xdd\xff\x19\xcc\x18\xe2\xf9\xd4\xfc\x5e\xc9\xff\x3e\x0e\x0a\xd8\x25\xed\x4b\x04\x4a\x3a\xef\xa2\x20\xfb\xc7\x9c\xcf\x62\xad\xef\x0d\x22\xac\xef\x13\xce\x4a\x01\x71\x5f\xd1\x53\x8d\x15\x77\xbe\xb3\xf7\x7d\xd7\x30\xd5\xd4\x45\x4c\xcb\x1d\xa5\xe5\x51\x75\x09\xfc\x90\x23\xdb\x39\x69\x42\x4c\x3b\xed\xc9\x32\x52\x3f\x28\xd9\x8e\x27\xa5\xa4\x76\xc9\xf8\xd1\xbe\x41\x1a\x83\x8a\xfe\xb6\x09\xe8\x0f\x26\x9b\x67\x82\x00\x51\x9e\xd7\x39\xab\xdd\xdb\x9a\xd0\xae\x4b\x3d\xfd\x9c\xc4\xd8\x97\xc8\x4d\xdb\x16\xf9\xc8\xfc\xbc\xdb\xcf\xc9\x5a\x7d\x80\xa4\xd1\xf7\xa0\xe3\xa8\xb2\xd4\xb6\x4b\x89\x52\x6b\x18\xcf\xd1\xd7\xd6\xfc\x6e\xdd\xfc\xce\x9d\x36\xdd\xba\x3e\x2a\x2b\xad\xfb\xa3\x6a\xa2\x7e\x54\xb1\xd9\x5e\x35\x7e\xb5\x89\x72\xdc\xf6\xaa\x3a\xd7\xba\xfe\x8f\xf6\x5e\x28\x5f\xfa\x9e\x99\xad\x89\xbb\x9f\xfd\x6f\xfb\xff\x27\x60\x43\xf2\x17\xa8\x47\x69\x07\x5b\xd7\x47\xa9\xdb\xa3\xf2\x30\xb0\xb3\x07\x1e\x61\xc2\xac\x6b\xc7\x25\xe5\x39\xb0\xa0\xb8\x85\xb7\x64\x64\x5e\xd6\x77\x4b\x3f\xda\x4d\xa0\x92\x09\xe4\xf3\x02\x52\x95\x8d\x01\xc3\x94\x4f\x1d\x59\x4a\x86\x5d\x94\xaf\x40\x47\xdd\x2d\x0d\x6d\x6e\x69\xa4\xef\x62\x3f\x51\x9a\x33\x8d\x70\x2e\xb7\x72\x20\x35\xa9\x85\x60\x6a\xbc\xcc\x9d\xef\x38\xf7\x99\xdf\x1b\x19\xcf\xab\xf5\xbd\x6f\xff\xf9\x5d\x9d\x7f\x5f\x68\xed\x4f\x24\xcc\xfa\xee\xe9\xb0\x8c\x0e\x68\x2b\x9b\xec\x3b\xcc\x3d\x0a\xef\x8f\xc3\xbc\x63\x1e\x95\x24\xf3\x73\x4e\x6a\xfb\x57\xea\x77\x13\xd8\x0c\x1e\xa0\x8e\x7e\x40\x66\x99\x09\x72\xfb\x05\x30\xff\xcc\xc7\xcb\xf4\xdf\x36\x3f\x3f\x37\xf7\x76\xdc\x8f\xd6\x0a\xc4\xa5\xcc\x94\x97\xcc\xef\x47\x90\x6d\x69\x82\x33\xaf\xb9\x37\x5f\x6d\x9d\x57\x39\xdb\x5a\xe7\x64\xff\xf9\xf8\xee\x73\xb0\x75\xbe\x35\xcf\xb6\x53\x25\xdb\x3a\xe7\xde\x0d\xc6\x14\xe3\x3f\xcf\xd8\xc6\xe7\xd4\xf7\x0f\xbe\xf3\x35\x67\xd1\xbb\xcf\xd7\x9c\xad\xef\x9c\xab\x8b\xcf\xd4\x7f\x73\x9e\x36\xcf\xe9\xa6\x5e\x6b\x1c\x32\x36\xbb\xb9\x26\xdc\xae\x44\xea\x46\xd2\x9a\x7f\x36\x6b\xbe\xb5\x3e\xad\x17\x73\x4d\xae\x07\xdf\xbf\x2b\xfb\x94\x38\xb5\x3b\x6b\x74\x77\x25\x48\x5d\x2a\x7b\xc0\x8f\xea\x4c\xf9\x4d\x5d\x2d\xaf\x69\xd5\x64\x8c\xda\x4a\xcc\xef\x11\x4e\x33\x9e\xb3\xc8\xed\x6d\xe6\x7a\x25\x72\xcb\xfc\x7e\xa4\x31\xd7\x65\x69\x3b\x71\x6f\x7e\xfe\x5f\x5d\xe4\xe6\x37\xfe\xef\x09\xcc\xef\x3d\x14\x73\xde\xfa\xec\x7a\x3f\x42\xe6\xa5\x3f\xe5\x6f\x32\xfe\xc6\x2f\xc0\x43\x3f\x2b\xe4\x4d\xaa\xee\xe6\x30\xdf\xf7\x1c\x37\xe1\xf9\x86\x97\xf6\x0c\xad\xb9\xce\xd5\xa6\xbf\x80\x71\xcf\x80\xaf\xb9\x0e\x02\x73\xc1\x44\x64\x36\xd2\xd6\xa1\x65\xcd\xbb\x15\x08\x22\xb8\x46\xee\xe6\x52\xf3\x5c\x81\x0f\x33\xfc\x20\x06\xe3\x11\xf0\xb1\x98\xfb\xda\x6e\xb2\xfa\x1e\xb4\x03\x9d\xfc\xad\x89\x0c\x2d\x8c\xbc\x76\x63\x6d\xf2\xa1\x03\xa8\x02\x5a\xd1\x6f\xb6\xe5\x41\xb2\x1f\x15\x40\x35\xfa\xcd\xeb\x38\x10\x0d\xea\xf8\x51\x9d\xfe\x4a\xfe\xf1\x6d\xef\x42\x6f\xfa\xdb\xfe\x8d\x1f\x99\xfe\xe7\x19\xc5\xb2\x7e\xb9\x6a\xa0\x3e\x48\x2f\x06\xfd\xe9\x7e\x1b\xb5\xef\xb2\x57\x87\xfe\xda\xf7\xd8\x2a\xd6\x33\xe4\x5e\xdd\x77\xe9\xbf\xd7\x8f\xae\xa0\x1b\xc8\xf1\xb7\x5d\x91\xeb\x49\x5b\x0f\xd4\xf5\xc3\xbc\xae\x47\xbf\xd9\xde\x0f\x5a\xde\x0d\xfa\xcd\x76\x9a\x1f\xf5\xfd\x68\x40\xbf\xd9\x2e\xb8\x17\xff\xe0\xc7\xbd\x71\x74\x40\xce\xe4\xb2\xfa\x5d\x31\x9b\x7c\xc7\xf9\x79\xae\xe6\xcf\x47\x71\x6e\xca\xfb\xf3\xd2\xca\x9f\xbf\x0e\xc5\x39\xf5\xe7\x31\xe3\xae\x9c\x5b\xf9\xf7\xe7\xfd\x2f\x7e\x50\xb7\x27\xa8\x9b\xa1\x80\x79\x64\xb8\x41\x63\xff\xf7\x78\x66\xdf\x40\xeb\x33\x8c\x7f\xd9\xdf\xfd\xdb\xbe\xf8\xdf\xf6\xb1\xff\x26\x6f\x9d\xcb\xf6\xcb\x03\xd6\xf7\x4f\xfb\x65\xa6\x6f\xce\x19\x19\xfe\xef\xfd\x56\x80\xc7\xc0\xdb\xbe\xcf\x09\x8d\x50\xff\x77\x82\xe6\x67\x86\x0b\x41\x88\xbf\x65\x1e\x7a\x8f\xdc\x85\xfd\xbe\xef\x36\x6f\xff\x46\x3b\xc5\xaf\xab\xd0\x8f\x4d\x66\xcb\xfc\x3c\x01\x36\xeb\x8d\xd9\xc3\x98\x30\xd7\x2d\x73\x4d\x62\xed\x29\x86\xb5\x86\xb1\xe6\x21\x1f\x09\xcc\x75\x41\xd1\xf3\xd9\xfb\xbd\xe8\xfb\x1e\x83\x25\x49\xf3\xa3\x9c\xef\x4f\x4a\xea\xe5\xb9\x53\xac\x7b\x5d\x37\x97\x2c\xaf\x14\x88\x5d\xa6\xc8\x14\x6d\x94\x36\x4e\x9b\xa2\xcd\xd6\xe6\x68\x6b\xb4\x4f\x6c\x11\xb6\x38\xdb\x3e\xdb\xf7\xb6\xeb\x71\x1f\xc5\x2f\x8f\x7f\x2e\xfe\x0f\x67\x69\x67\x9c\xb3\xa5\xb3\x9d\xb3\x9b\x33\xc7\xd9\xc3\xd9\xcb\xf9\x88\x73\x8b\x73\xaf\xf3\x73\xe7\x09\xe7\x55\xe7\x75\xa7\xd7\x15\xea\x4a\x74\xa5\xb8\xaa\xbb\x6a\xb9\x1a\xb8\x1a\xb9\x9a\xb8\x5a\xb8\x7a\xbb\x46\xb9\xc6\xb9\x26\xb8\xa6\xba\x16\xb9\xde\x74\x5d\x4b\xb0\x25\x44\x24\x44\x27\x24\x26\xa4\x24\x54\x4d\x68\x9f\xd0\x25\xa1\x77\xc2\x8c\x84\xc5\x09\xeb\x12\xd5\x44\x7b\x62\x68\x62\x78\x62\xe9\xc4\xb2\x89\xce\xc4\x4a\x89\xa9\x89\xad\x12\x73\x13\x07\x26\xa9\x49\x61\x49\x09\xc9\x92\xac\x26\x07\x25\x87\x25\x47\x26\xc7\x24\x97\x4b\x2e\x9f\x5c\x39\xb9\x56\x72\xa3\xe4\xe1\xc9\x05\xc9\x33\x92\x67\x25\xcf\x49\x5e\x98\xbc\x26\x79\x43\xf2\xa6\xe4\x1d\xc9\x3b\x93\xf7\x26\x1f\x48\x3e\x94\xfc\x65\xf2\xf9\x94\x46\x29\xee\x94\x66\x29\x7d\x53\xfa\xa7\x0c\x4a\x19\x96\x32\xaa\xf2\x88\xca\xe3\xab\x46\xbf\x9c\xf0\xf2\x9c\x9b\xea\xcd\x3a\x37\x1b\xdd\x6c\x72\xb3\xe9\xcd\x16\x37\x3b\x78\x93\x8c\x5b\x86\x61\xfd\x09\xcd\xd5\x5a\xbe\x36\x49\x9b\x41\xfc\x4f\x69\x2f\x68\x87\x6d\x65\x6d\x0b\x6c\x87\x6d\xd7\xe2\x24\xce\x4b\xfc\xab\x9d\xe2\x8c\x71\xba\x9c\xad\x9c\x99\xfe\xf8\xfb\x38\x0b\x9c\x5b\x9d\x1f\x38\x8f\x39\xbf\x76\xfe\xe4\xfc\xd5\x25\xae\x70\xe2\xbf\xcf\x55\xd3\x55\xff\x4e\xfc\x43\x5d\xf9\xae\xf1\xc4\x3f\xdf\xb5\xda\x1f\x7f\x94\x3f\xfe\x76\x09\x9d\x13\x7a\x10\xff\xfc\x3b\xf1\x97\x22\xfe\x32\x89\xf1\xfe\xf8\xfb\x26\x0e\xb0\xe2\x77\xfd\x43\xfc\x99\x77\xe2\x9f\x9f\xbc\x3a\x79\xfd\x9d\xf8\x3f\x22\xfe\xe3\xc4\xdf\xe0\x4e\xfc\x03\x53\x86\x12\x7f\xdf\xca\x63\x88\x3f\xfa\xe5\x59\x37\x95\x9b\x71\x37\xeb\x11\xbf\xfb\x66\xf3\x9b\x19\x5e\x97\x19\xbf\x71\xd6\x78\xcf\x78\xc7\xd8\x61\xbc\x69\x6c\x31\x36\x1b\x9b\x8c\x8d\xc6\xab\x46\x3d\xa3\xba\x91\x7a\xc1\x55\x74\xa5\xe8\x52\xd1\xf7\x45\xdf\x15\x9d\x29\x3a\x5d\xf4\x4d\xd1\xc9\xa2\x13\x45\x5f\x15\x7d\x59\x74\xbc\xe8\x58\xd1\xd1\xa2\x23\x45\x9f\x15\x7d\x5a\x74\xa8\xe8\x93\xa2\x83\x45\x1f\x17\x7d\x58\xf4\x7e\xd1\xde\xa2\x5d\x45\xef\x16\xbd\x53\xb4\xbd\x68\x75\xd1\xe2\xa2\x05\x45\xf3\x8b\x66\x17\x4d\x2a\x1a\x55\x54\xbb\x28\xa1\x28\xb2\x28\xbc\x28\xa0\xc8\x76\xde\x7b\xfe\xf4\xf9\x93\xe7\x8f\x9d\xdf\x78\xfe\xa5\xf3\x8b\xce\x37\x3c\x5f\xef\x7c\xf5\xf3\xd5\xce\x57\x39\x7f\xdf\xf9\x0a\xe7\xe3\xcf\xc7\x9d\x57\xce\x7d\x7f\xee\xc2\xb9\xb6\xe7\xd2\xcf\x55\x3f\xdb\xe9\x6c\xc7\xb3\xad\xce\xb6\x3c\xdb\xec\x6c\xfa\xd9\x46\x67\x6b\x9f\xad\x7a\xb6\xc2\x59\xd7\xd9\xe0\x33\x37\xce\xfc\x76\xe6\xfa\x99\x1f\xcf\xfc\x70\xe6\xcc\x99\xaf\xce\x1c\x3d\xf3\xc9\x99\x83\x67\x3e\x38\xb3\xfb\xcc\xbb\x67\xb6\x9d\x79\xf5\x4c\xf6\x99\xac\x33\x5d\xce\xd4\x3d\x53\xfb\x4c\xad\x33\x35\xce\x54\x3d\xd9\xe4\x64\xc3\xaf\x56\xe4\xae\xcc\xad\x1b\xbc\x27\xf8\x95\xe0\x75\xc1\x2f\x07\xbf\x14\xbc\x36\xf8\xc5\xc0\x23\x01\xb7\xfc\x7f\x82\xf8\xff\xdd\x1f\xbb\x1a\x68\x36\x8a\xfc\x07\x13\x8a\x75\xd8\x32\x7f\xd4\x7f\xd1\xe1\x1b\xa9\x71\x50\xb3\xb1\x9a\x38\x38\x18\x95\x90\x40\x29\x29\x41\x12\x2c\x21\x12\x2a\x61\x52\x4a\xc2\x25\x42\x22\xa5\xb4\x44\x49\xb4\xc4\x48\x19\x29\x2b\xb1\xac\x42\x71\x12\x2f\x4e\x66\x5f\x82\x24\x4a\x92\x94\x97\x64\x49\x91\x0a\x52\x51\x2a\xc9\x7d\x92\x2a\x95\xa5\x8a\x54\x95\x6a\x52\x5d\x6a\x48\x4d\x49\x93\x5a\xec\x59\xea\x48\x5d\xa9\x27\xf5\xa5\x81\x34\x94\x46\xd2\x58\x9a\x48\xba\xb8\xa5\xa9\x34\x93\xe6\xd2\x42\x5a\x4a\x86\xdc\x2f\xad\xa4\xb5\x3c\x20\x6d\xa4\xad\xb4\x93\xf6\xd2\x41\x32\xa5\xa3\x74\x92\xce\xd2\x45\xb2\x58\x15\xbb\x49\x36\x7b\x98\xee\xd2\x43\x7a\x4a\x2f\xe9\x2d\x7d\xa4\xaf\xe4\xe2\xff\xe3\xac\xee\x4f\xc8\x93\xb2\x50\x96\xb2\x27\x7d\x41\x9e\x97\x17\xe5\x25\x59\xcb\x3e\xf6\x15\x4e\x98\x9c\x81\xe5\x35\x79\x43\x5e\x17\x8f\x6c\x94\xcd\xf2\xa6\x6c\x91\xad\x52\x28\xdb\x64\x27\x27\xbc\xb7\xe5\x1d\xc7\x25\x19\x2b\x03\x64\x20\x67\x9a\x2b\x32\x41\xd6\xc8\x68\x19\x16\x70\x9f\x3c\x24\x43\x03\x1e\x90\x59\xf2\x6c\x40\x4b\x76\xef\x6d\x03\xda\xc9\x60\x19\x1f\xd0\x38\xc0\x1d\x90\xae\x8d\x0d\x68\x25\xc3\x65\xb2\xd6\x43\xd6\xb1\xa3\x9c\x26\xfd\x65\x64\x40\x0b\xa5\x4b\x40\xeb\x80\x26\x32\x42\x1e\x71\xfc\x20\xfd\xd8\x25\x3e\x26\xcf\x28\x91\x4a\x69\xc7\x37\x8e\x53\x8e\x22\xc7\x05\xc7\x59\xc7\x77\xb2\x3d\xe0\x49\xd9\xad\x34\x70\xdc\x0e\x88\x75\xfc\xe1\xb8\x11\xb0\x37\xe0\x7d\xc7\x65\x99\xe8\x38\xe7\xb8\xe8\xf8\x45\x66\xc8\x1c\x79\x54\xe6\xca\x6c\x99\x27\xf3\x65\x81\x3c\x25\x8b\x65\x09\x11\x2e\x92\x15\xb2\x52\x96\xcb\xcf\xea\x2c\xf5\x39\xf6\xa0\xcf\xaa\xcb\xd5\x15\x32\x49\x5d\xa5\xae\x54\x9f\x10\x71\xdf\xdf\xa3\x7b\x4e\x76\x56\x97\xce\x9d\x3a\x66\x76\x68\xdf\xae\x6d\x9b\x07\x5a\xb7\xba\x3f\xa3\x65\x8b\xe6\xcd\x9a\xba\xd3\x9b\x34\x6e\xd4\xb0\x41\xfd\x7a\x75\xeb\xd4\xae\x51\xbd\x5a\xd5\x2a\x95\x2b\x56\x48\x49\x2e\x9f\x94\x98\xe0\x8c\x89\x2c\x15\x16\x1a\x12\x5c\x32\xb0\x44\x80\xc3\x6e\xd3\x35\x55\x91\xca\x2e\x8f\xd2\xb7\xa5\x47\x4b\x76\x95\xca\xc8\x4d\x6a\x99\x94\xdb\xaa\x4a\x65\x57\xcb\x98\x21\x2d\xaa\x54\x6e\x99\x94\xd1\xd7\xe3\xca\x75\x79\x68\xf4\x94\xa4\x56\xad\xac\xae\xa4\x5c\x8f\xab\xaf\xcb\x93\x42\x93\x7b\x57\x77\x5f\x8f\x1b\xc9\x41\xf7\x48\xba\x7d\x92\xee\x3b\x92\x4a\x98\xab\x91\x34\x32\x4d\x24\xb9\x3c\x07\x5b\x24\xb9\x0a\x95\xee\x1d\xb3\xb9\x9e\xdb\x22\x29\xc7\xe5\xb9\x62\x5d\xb7\xb3\xae\xf5\x14\xeb\x26\x98\x9b\x84\x04\x46\x58\x5e\x99\xde\xba\x5a\x7a\x32\x1e\x1a\x32\xbb\x65\x5f\x7c\x54\x36\x96\x0c\x6c\x9e\xd4\x7c\x60\x60\x95\xca\xb2\x31\xb0\x24\x97\x25\xb9\xf2\x54\x4c\x1a\xbd\x51\xa9\xd8\x44\xb1\x2e\xd4\x8a\x2d\x1b\x6c\x54\x25\x20\xd8\x34\x4b\xa4\x2d\x73\x07\x78\x32\x3b\x66\xb7\x6c\x11\x9b\x90\x90\x53\xa5\x72\x6b\x4f\x48\x52\x0b\xeb\x91\x34\xb7\x54\x7a\xec\xcd\x3d\x0e\x4b\xa5\xeb\x41\xd3\x75\x79\xd2\xb5\xb1\xf2\xae\xd9\x73\x0a\xc3\xa4\x5f\xdf\xd4\xa0\x01\x49\x03\x72\x7b\x66\x7b\xb4\x5c\xc6\xce\xd6\x5a\xce\x9e\x3d\xd3\x53\x2a\xd5\x53\x29\xa9\x85\xa7\xd2\xa4\xef\x62\x88\x7c\xa0\xa7\x72\x52\x8b\x96\x9e\x54\x53\x6b\x9b\x4e\x77\xec\xb4\xf9\xd3\xa4\xe2\xb1\x25\xf3\xc2\x98\xfd\x8b\x10\x4e\xd2\x95\xcb\x7f\xed\xc9\xf5\xf7\xd8\x93\xc3\x7e\x11\xf3\xd2\xa3\x36\xf7\x28\x9d\xb2\x13\xcc\x9f\xd8\x0c\xb8\x9e\x3d\x3b\x23\xc9\x95\x31\xbb\xef\xec\xdc\x42\xa3\xa0\x5f\x92\x2b\x2c\x69\xf6\xc6\xa0\xa0\xd9\xa3\x5b\x42\xb7\x64\x66\xa3\xa2\xd0\xd8\xf1\x64\xac\x27\x63\x4e\x8e\x27\xac\xef\x10\xa5\x41\x8e\x3f\xf4\x8c\x4e\x6d\x3c\x11\x1d\x7b\x64\x7b\xd4\xe4\x0c\xd7\x90\x5c\x7a\xf8\x7f\x7a\x52\x42\xbd\xd8\x84\x52\x77\x64\x32\xff\xe9\xb1\x40\x0b\xe4\xc0\x70\x42\x82\x49\xc3\x93\x85\x6e\xe9\xc7\x8d\xa7\xa0\x63\xb6\xef\xde\x25\xfd\x62\x37\x89\xbb\x5a\x6a\x8e\x47\xed\x6b\x3e\xd9\x55\xfc\xa4\x74\x96\xf9\xa4\xa0\xf8\xc9\x9d\xe1\x7d\x93\xc8\x6d\x9b\xce\xd9\xb3\x3d\x7a\x72\xeb\x01\x49\x2d\x61\xfc\xc9\x5c\x4f\x41\x3f\xaa\x6b\xa8\x99\x98\xa4\x30\x4f\xc8\xaf\xb1\x09\x49\xb3\xc3\x4b\xb9\xea\x57\xcb\xb1\x64\x5d\x78\xd5\x7a\xc0\x83\x2e\x8f\x2d\x05\x92\x18\x75\xf7\x00\xea\xc6\x1c\x32\x3b\xcc\xba\x09\xf9\xd5\xd7\x5c\x89\xc5\x40\x4a\xa9\x70\x57\xfd\x24\xd4\x98\x7a\x5a\x26\xb5\xec\xeb\xff\xff\x43\x43\x62\x50\xe0\x82\xe8\x56\xa9\xbe\x42\xe8\x92\xed\x71\xb7\xe0\xc2\x9d\xeb\xcf\x58\xcb\x8d\xd5\xab\x31\x22\xb7\x2f\x09\x7b\xb0\x85\x95\x4c\x4f\xb5\xa4\xd1\x9e\xc8\xa4\x66\x77\xb2\x6b\xba\xd5\xf2\xc1\xce\xd9\xd6\x10\xff\x30\x4f\x64\x73\x8f\xf4\xed\xef\x1f\xe5\xa9\xd6\xd2\x9a\x57\xae\x96\xb3\xfb\xb6\xf0\xb9\x60\xea\x4a\xea\x98\xbd\x5d\xd2\x8c\xd3\x1b\x6b\xb9\x62\x37\x9b\x4b\x67\x4e\x0b\x53\x38\xaa\x39\x55\x96\xd2\x72\x76\xf6\x80\x41\x1e\x67\xdf\xd8\x01\xcc\xbb\x41\xae\xec\xd8\x04\x8f\x3b\x87\x0c\xe7\x24\x65\x0f\xcc\x31\xcb\x0e\x86\x2a\x9d\x8e\xb5\x8a\x23\xc7\xaa\x95\x2e\xd9\x6d\x3a\x27\xb5\xe9\xd8\x3d\xbb\x9e\xdf\x11\xdf\x03\x53\x9d\x9e\xdc\xf2\x1e\x35\x49\xd9\xb1\x3e\x35\x14\xa0\x27\x20\x39\xc0\x95\xad\xc6\x6a\x39\x08\x86\xd1\xe1\xca\xe0\x22\xa9\x59\x23\x7e\x7b\x1c\xc9\x01\x20\x0c\xc2\xad\x5e\xb3\x70\x9b\x35\x72\x65\x2b\xb1\x52\x2c\x8d\x1b\x9e\x4a\xae\x96\x03\x5b\xf8\xe5\xcc\xfb\xbf\x28\xb5\x99\xe5\xd4\xbc\x55\xb1\x36\xbb\x79\x8b\x9e\xe6\xad\x62\x13\x72\x12\x7c\x3f\x55\x2a\xab\x3c\x76\xf9\x0d\x33\x22\xc0\x24\xb5\x55\xf1\x23\x96\x29\x1e\x04\x50\x9f\xcd\x5b\x59\x5d\x26\x97\x31\x66\xd1\xbb\xb2\x93\x06\x26\xe5\x24\x0d\x71\x79\xdc\x99\xd9\x66\x6c\x26\x3d\x16\xcb\x7e\x32\x2c\xce\xfd\xb9\xea\xf2\x97\xbb\xbb\xc8\x82\x26\x49\xe0\x71\xf1\x8d\x49\xa6\x27\x23\x35\xf6\x6e\x72\x3d\xf7\x5b\xf7\x77\x6e\x5b\xdd\xf3\xb8\x75\xf1\x63\xd7\xec\x80\xa4\x36\x9d\x67\x9b\xca\x93\xfc\x0a\x05\xcf\x5b\x7b\xc4\x2c\x61\x77\xbd\x52\xb1\xd6\x5a\x60\x4e\xe8\x24\xd6\x5e\x57\x18\x53\xda\x9a\xd0\xb3\x37\xba\xdd\xe6\x64\x1e\xd2\xc0\x54\x92\xd4\x7a\xc0\xec\xa4\xce\xd9\x8d\x2c\x69\xd6\x93\x47\x62\x27\x99\xb6\xc2\xa5\x8d\xd2\xa6\x4b\xb3\x2a\x95\x59\xda\x9a\x6d\x4c\x52\x66\x75\xdc\xe8\x56\x66\x75\xee\x9e\xbd\x3d\x8c\x3d\xf2\xac\x2e\xd9\x9b\x54\x45\x6d\xde\xb7\x59\xce\xc6\xf2\x3c\xcb\xde\xee\xe2\xa5\x61\xf5\xaa\x66\xaf\xd9\x69\xde\xb8\xcc\x1b\x53\x53\x27\x6e\x02\x2c\xf9\xd8\xed\x6e\x91\x02\xeb\xa9\x6e\x75\x58\xf7\xfd\x0b\x15\xb1\xfa\x02\x8a\xfb\x14\xe9\x5f\xa8\xfa\xfa\xc2\x7c\x86\x52\x2c\x43\x6e\xf6\x20\xfd\x0b\x75\xdf\x13\x77\xb1\xb4\x4e\x5f\x80\xaf\xaf\xc0\xea\xb3\x7e\x36\x8a\x49\x99\x3b\xd0\xe6\x0e\x70\x97\x70\x07\xa9\xc1\x6a\xec\x46\xc5\xec\xda\x44\xcf\x0e\xf6\x2a\x25\x14\xd9\x1c\xa4\x04\x2b\xb1\x1b\x19\xd5\xc9\xea\x2e\x54\x0a\x36\x96\x70\xc7\xfa\x24\x0a\x90\x70\xfb\x3c\x9c\x95\xf5\xa7\xe9\xac\xee\xd9\x9b\xd9\xd1\x28\xb1\xd6\x6f\x0c\x35\x33\x7f\x28\x97\x98\x21\x24\x9b\xd7\x4a\x4b\xd7\x00\xb3\x50\x26\xe7\x0c\x99\xdd\x37\xc7\x9c\x6c\x12\x45\x6a\xf8\xbf\xe2\x51\x92\x9a\x90\xa6\xa4\x26\x38\x62\x0f\xf2\x04\x26\x0d\x6c\xe6\x29\x99\xd4\xcc\xec\x4f\x37\xfb\xd3\x7d\xfd\x76\xb3\xdf\x41\x89\x2a\x51\x0a\xc3\x0b\xc8\x7d\xa6\x47\x31\x2b\xa0\x47\x76\x02\x53\xd2\x55\x76\x7f\xec\xec\xb0\x2b\x66\xa6\x72\x58\x54\x66\x87\x9d\xab\xd2\xb4\x1e\xce\xa6\x8b\xa2\xd4\x97\x2c\xa5\x89\xbf\x6d\xa6\xb8\xd9\x6b\x39\x95\xa6\xb4\x1c\x5c\x94\x86\x92\xa6\x34\xa0\xbf\x1e\x2d\xcf\xa5\x40\x09\x85\xe9\x6b\xd6\xef\x0e\xfc\x7e\x03\xa8\x72\xd5\xba\xf7\x3d\x4b\xb7\x7e\x8b\xf5\xdb\xad\x38\xf8\xed\xb4\x7e\xaf\x52\x74\x77\x27\x65\xd7\x6d\xe5\x8d\xdb\x8a\xdc\x56\x02\x3b\xdc\x54\x5c\x37\x95\x5f\x32\x2b\x3a\x7f\xca\xa8\xe8\xbc\x96\x91\xea\xec\x73\x75\xea\x55\x35\xf4\x6a\x87\xab\x7d\xae\xce\xbb\xfa\xc6\x55\x5b\xc9\x73\xdf\xc5\x3b\xcf\x9e\xc9\x70\x86\x9e\x51\xdc\x67\x32\xa2\x9c\xdf\x9e\xce\x70\xbe\x7b\xfa\xd0\xe9\x53\xa7\x35\xf7\xe9\xb4\x3a\x19\xa7\x33\x62\x9c\xef\x28\xe5\xa4\x31\xb3\x3e\x4b\x29\x4b\x5b\xc6\x9d\x9d\xf5\xc3\x15\xc3\x79\x45\xbd\x90\x75\xb9\xd5\xa5\xac\xef\x6b\x4a\xd6\xc5\x0b\x17\xb2\x2e\x28\x92\x55\xd4\x4a\xb2\xce\x8b\xe1\xfc\xba\xf1\xa9\xac\x53\x8a\x96\xf5\x4d\x63\x2d\xeb\xa4\x66\x38\x43\x8f\x2a\xa1\x47\x8d\xa3\xaa\x71\x54\x59\x75\x44\xf9\xfc\xb3\x46\xce\x77\xdf\x53\x76\x67\xa6\x38\xfb\xbe\x33\xfa\x9d\x82\x77\x34\x77\x61\xdf\xc2\xd1\x85\x5a\xa1\xb1\xcb\x9d\x53\x18\x5e\x33\x23\x74\x5b\xfa\x36\x35\x74\x73\xfa\xe6\xab\x9b\xb5\x12\x7d\x3d\xa3\x3d\xea\x7c\xcf\x6a\x8f\xc7\xa3\x15\xbc\x36\xff\x35\x75\xf5\x6b\x9e\xd7\xd4\xa9\xaf\x2a\xab\xd7\x7b\xd6\xab\xd5\x5e\x19\xf5\x8a\x1a\xfa\x4a\x87\x57\x56\xbd\x72\xea\x15\xbd\xe4\xea\x55\xa9\x4e\xf7\xaa\x12\xa5\x32\x64\x4d\xd8\x1a\xb5\x81\x7b\x4d\xe6\x1a\xd5\xb3\x66\xd7\x9a\xc3\x6b\x2c\xed\xae\x35\xae\xf2\x19\xcf\x2d\x2f\xef\x5c\x09\x56\x80\xcc\xe5\xca\xd2\xee\xad\x9c\xcf\x2c\x29\xef\x3c\xbc\xe4\xf4\x12\x15\xa1\x2d\x4b\x82\x4b\x65\x84\x16\x2a\x81\xee\xae\x4a\xe8\xe2\xa9\x8b\xd5\x3e\x8b\x46\x2d\x3a\xb4\xe8\xd4\x22\x3d\x74\x91\x73\xd1\xd4\x45\xf3\x16\x19\x8b\x6c\x0b\x9f\x6e\xe4\x74\x3f\x1d\x1d\x97\xe1\x7e\xba\x44\x50\x46\xe8\x02\xa5\xcf\x82\x55\x0b\xde\x58\xf0\xee\x82\xab\x0b\x8c\x05\x76\xf7\x82\x72\xc9\x19\xab\xe7\x79\xe6\xa9\xbb\xe6\x1d\x9e\x77\x7a\x9e\xf6\xd4\xdc\x0c\x67\xf5\xb9\xee\xb9\x6a\xc1\x5c\x65\xd4\x3b\x4a\x10\xc9\x3a\x6d\xfe\x36\x76\x29\x41\xee\x67\x43\x4a\x65\xb8\x66\x57\x9f\xad\x3e\x36\x23\xc3\x39\x6d\x84\xe1\x2c\x80\xb2\x43\xe3\x4e\x8d\xbb\x3a\x4e\xbb\x3a\x4e\xc9\xcf\x4b\x77\xe6\xc1\xd5\xd8\x8c\xda\xce\x31\xc0\x3d\x3a\xa5\x72\x86\x6b\x74\xf5\xd1\xea\x28\xee\x46\x82\xb2\x4a\x4c\x56\x99\xb4\x98\x2c\x47\x9a\x96\x65\x67\xec\xcb\x23\x94\x4a\x23\x94\xe1\x5c\xe5\xf6\xa9\xe6\xec\xdb\xa7\x99\xb3\x0f\xe3\x7b\x77\xaf\xe9\xec\x99\x51\xc3\xd9\x83\x78\xbb\xd3\x46\xd4\x0c\xcf\xb2\x91\x24\xbd\xa6\x96\x35\x4a\x53\x42\xb5\x74\xad\x83\x36\x4a\x9b\xaa\xd9\x96\xe4\x28\x9e\x4e\xbb\x3a\x1d\xee\x64\x72\xb6\xb9\x53\x95\x5a\x19\x26\x77\xcb\x3b\xc1\xdd\xd5\x8e\x46\x47\xd5\xdd\xb1\x76\xbd\x0c\x77\xc7\xe4\x8a\x19\x87\x32\x15\x57\xfb\x4a\xd5\x32\x02\xda\x3b\x13\x33\x4a\xb4\x2b\xd3\x4e\x6d\xd5\x2e\xbb\xdd\xf1\x76\x17\xda\xfd\xde\xce\xb6\xb4\x9d\x12\xd3\xb6\x7c\x95\x8c\x98\xb6\x71\xae\x8c\xa5\x6d\xd7\xb5\x55\xdb\x64\xd4\x75\xb6\xce\xe0\xa0\x8e\xd3\xf7\x83\x37\x32\x94\x53\x19\x57\x33\xd4\x82\x0c\x25\xaa\x66\xe9\xac\x52\x4a\x68\x56\x58\xcd\xd0\x2c\x36\xa9\x59\x8a\x28\x4e\x67\x68\x7a\x68\x9f\xd0\xa9\xa1\x7a\x68\x68\xb5\xd0\x0e\xa1\xa3\x42\xe7\x85\x9e\x0a\x35\x42\x1d\xe9\xf4\x5d\x0d\xd5\x46\x89\xd2\x41\x94\x82\x28\xc5\xa6\x14\x2a\xf3\x37\x76\xe9\x9c\x9a\xda\xa6\xd0\x61\xb0\xe1\x71\x64\xf6\xf0\x28\xb3\x3c\xc9\x9d\xcd\xdf\xee\x8e\xdd\x3d\xf6\x59\x1e\xc9\xea\xde\x23\x7b\xa3\xa2\x3c\x95\xf3\xd8\xdc\xb9\xd2\x2c\xae\x8d\xa7\x66\xe7\x6c\x4f\xdf\xb8\x9c\x36\x9e\x01\x5c\xb8\xcd\x8b\x02\x2e\xc2\xe2\x36\x46\x49\xb3\x9c\xbc\xfc\xbc\xfc\x71\xa9\xe6\x8f\xe2\xbb\x90\xd4\xbc\xd4\x54\xeb\x32\x3f\xd5\xba\x54\xf2\x24\xcf\x7c\xa0\x58\x0f\xcd\x9f\xbc\xbc\x54\xdf\x7d\xbe\xaf\x23\x2f\xdf\xbc\xcb\xa3\x15\x2e\x7d\xff\x37\x7b\xf3\xf2\xcc\xde\x54\xb1\xc4\xf3\xc6\xf5\xe6\x36\x55\x7a\xe7\xe5\x2b\x79\xa8\xc4\x6e\x6f\x14\x99\xea\x53\x4d\x39\x29\xf6\xe3\xce\x8f\x65\x20\xb5\x77\x1e\x46\xcc\x41\x96\x6b\x79\x8c\x61\x88\xa9\x80\x9f\xfc\xe2\x21\x31\xbd\xc5\x76\xc0\xf6\x8d\x3c\x62\x9b\xc6\xe9\x6e\xa2\xf5\xfb\x2f\x3f\x7a\x03\xd6\xa2\xf1\x22\xc6\x65\xf3\xee\xcf\xdf\xde\x6e\xff\xa7\x47\xd6\xbf\xff\xf1\xfd\x5d\x61\x4e\x65\x6f\x73\x4a\x5b\x2d\xc7\x38\xa5\xad\xe4\x5c\xb5\x84\x53\xdd\x2c\x99\x42\xcf\x86\x62\x49\xdb\x01\xc5\x25\xef\xca\x1e\xeb\x7b\xc3\x9d\x9c\x87\xe6\x72\xba\xfb\x9b\x1f\xdb\x34\x25\x5c\xb6\xa3\x6d\xac\x6c\xe2\x0c\xb8\x48\x96\x49\xc1\x3f\xca\x0d\xe5\x9c\xf5\x3a\xd6\x7b\x70\xea\xcc\x97\x01\xca\x97\xca\x34\xfa\x0a\xb1\xba\x58\x66\x2b\x03\xe5\x57\x25\x40\x49\x54\xd2\xe4\x8a\x5c\xc4\xf2\x5a\x7c\x3a\x21\x87\x64\x3f\xd7\xf5\x39\xe9\xae\xbe\x5b\x9f\xf2\xad\xb2\x5f\x9e\xc6\xf7\x61\xfc\xde\xc6\xef\xe5\x66\xaf\xfa\x93\xcc\x56\x9f\x96\x91\xea\x31\x6d\x1a\x36\x9e\x60\x4c\x6f\xba\xbf\xb0\x86\xbc\xa8\xf4\xe0\x6e\xba\xe4\x5b\x77\xbd\x39\x85\x8e\xba\xc7\xc9\x59\x44\xb9\x56\x26\xfd\x19\x81\xf7\x9c\x6d\x9a\xf1\xb3\x04\xdf\xda\xcc\x59\xd1\x7c\xba\x44\x1e\x94\x31\xb6\x03\x12\x7a\x2b\xde\xf8\x49\x6a\xe9\xe7\x25\xd8\x7b\x44\xde\xd5\x9c\xc4\x2e\x9c\x77\xcd\x9f\x69\xc5\xa3\x1d\xad\xb4\xa1\xea\x56\x55\xbd\xbd\x90\x9b\x05\x9c\x69\x17\x48\xae\xf2\x25\x5e\xce\xd5\x9a\x12\x41\x67\xa5\xa5\xf2\x8c\x9c\x95\x89\xfa\xa7\xda\xa7\x8e\x0a\xde\xab\x9c\xc3\x67\x71\xf2\x1e\xc0\x19\xfa\x6d\xd9\xa2\xf5\x94\x10\x99\x80\x95\xa5\x9c\xbe\xff\x57\x3f\xf6\x69\xfa\x10\x89\xd4\xcd\xef\x1b\x2e\x1b\x9f\x7b\xa7\xe2\xfb\xd7\x64\x6f\x07\x6c\x1c\xfa\x87\x21\x5d\x00\xfc\x2a\x17\x44\xb4\x16\xd4\x63\x5b\x32\x36\x01\x50\x0f\xb6\x5b\x68\x6c\x05\x0e\x10\x91\x1b\xcc\x07\xe6\x35\xfd\x01\x95\x41\x21\xbb\x05\x17\x38\x2c\x12\x78\x44\xa4\xe4\x10\x91\xa0\x8a\xe0\x77\x91\xe0\xbe\x22\x21\x8c\x0d\x8d\x01\xf4\x87\x1e\x17\x09\x43\x47\x18\x7a\x4b\x45\x02\xee\x23\x66\x89\x44\x06\x81\x0f\x45\x4a\x93\x9b\xd2\xd4\x7d\x14\xb2\x51\xdf\x89\x44\x2f\x15\x89\x41\x57\xcc\x64\x91\x32\x3a\xe0\xbe\xcc\x49\x91\x58\xf4\xc6\x32\xb6\xdc\x70\x70\x4d\x24\xce\x23\x12\xdf\x53\xc4\x89\x6e\xe7\x22\xb6\x61\xe5\xc0\x68\x91\x44\xf4\x26\x2e\xb5\xfe\x28\xab\x24\xa1\x33\x69\x17\xb8\x2e\x52\x1e\x9f\xca\xaf\x03\xe8\x48\xc6\xf7\x94\xf2\x22\x15\xf0\xa7\x82\xc7\xfc\x3b\xfa\x22\x95\x1a\x01\x62\xbc\x8f\xe7\xa9\xdc\xa7\x62\xa3\x32\xfa\xaa\xe0\x4b\x15\xee\xab\x0d\x10\xa9\xce\x64\xaa\xbe\x42\xa4\x06\xbe\xd4\x44\xbe\x26\xba\xd3\x88\xa5\x16\xb1\xd6\xda\x22\x52\x1b\xd9\x3a\xc4\x59\x17\x2e\xeb\x12\x53\x7d\xfc\x6a\xc0\xf3\x06\xf0\xd5\x90\xfe\x46\xf8\xdb\x08\xff\x1b\x61\xa7\x31\xb1\x37\xa1\x75\x93\x87\xa6\xd5\x01\xb6\x9a\xed\x15\x69\xce\x96\xb2\x05\x32\x2d\xe1\x25\x83\x98\x32\xcc\x76\x86\xc8\xfd\xf0\xdc\x0a\x3e\x5a\x71\xdd\x1a\x7b\xad\xf1\xb3\x0d\x79\x69\x43\x7f\x3b\xf8\x69\xdf\xc2\x0f\xf4\x66\xa2\x23\x93\xdc\x76\xc4\xc7\x8e\x70\xd0\x11\x3f\x3a\x62\xab\x13\x7d\x9d\xc8\x59\x67\xb8\xe9\x8c\xcd\xce\xc4\xd1\x99\x67\x9d\x19\xdf\x85\xe7\x5d\xe0\x29\x0b\x5e\xb2\xf0\x29\x0b\x3b\x59\xf8\x9d\x45\x7d\x74\xc5\x5e\x57\x74\x77\xc5\x97\x6e\xb4\xdd\xcc\xf6\x45\x80\x6d\xf3\xaf\xbb\x64\xd7\x02\xd8\xc9\x46\x77\x0e\x3c\xe4\x90\xc7\xee\x70\xdb\x1d\xd9\xee\x70\xd7\x1d\xde\x7b\xd4\x13\xe9\x09\xef\x3d\x33\x01\xb3\xad\x27\xbc\xf7\x3c\x2d\xd2\x0b\xb9\x5e\xe4\xa6\x37\x32\xbd\x19\x6f\x16\x7e\x1f\x7c\xeb\x83\x6f\x7d\xf0\xad\x0f\x1c\xf7\x81\xcb\xbe\xf8\xd0\x17\xb9\x5c\x13\xe8\xcc\x45\x3e\x17\x0e\xfa\x91\x93\x7e\xe8\xee\x07\x67\xfd\xf0\xa7\x3f\x71\xf4\xa7\x4e\x07\x50\xa7\x03\xe0\x7b\x00\x1c\x0d\x40\xc7\xc0\x39\xc0\x6c\xc9\xeb\x20\xfc\x18\x84\x1f\x83\xf0\x63\x10\x7a\x06\x61\x77\x30\x76\x07\x63\x77\x30\x76\x07\x33\x66\x30\xb2\x83\xcd\xff\x1e\x03\xb2\x43\x90\x1d\x82\xec\x10\x72\x38\x64\xa7\xc8\x83\xf0\x35\x94\x3a\x1b\x0a\xbf\x43\xb1\x3b\x94\x9a\x18\x8a\xdd\xa1\xd8\x1d\x06\x7f\xc3\xc8\xff\x30\xea\x77\x18\xf2\xc3\x90\x1d\x8e\xec\x70\x64\x87\x23\x3b\x1c\xd9\xe1\xc8\x0e\x87\xeb\x11\xc8\x8e\x80\xeb\x11\x70\x3d\x92\x76\x14\xf5\x33\xca\x6c\xe1\x7d\x14\xbc\x8f\x46\xcf\x68\x62\x1d\x8d\x0e\xf3\x8f\x54\x8e\x21\xa6\x31\xc4\x34\x06\x8e\xc7\xa0\x63\x0c\x3c\x8f\x85\xbf\xb1\xdc\x8f\x45\x26\x0f\x99\x3c\xe2\xcc\xc3\xc7\x3c\x38\xcb\xe7\x59\x3e\x76\xf3\xb1\x9b\xcf\x9c\xc8\x27\xa6\x7c\xf4\x8e\x23\x7f\xe3\xb0\xff\x10\xf6\x1f\xc2\xde\x43\xf8\xfa\x10\xf9\x7c\x08\xfe\xc6\xa3\x63\x3c\xf9\x1c\x4f\x2c\x13\xd0\x33\x01\x3d\x13\xa9\xc3\x89\xf8\x32\x11\xb9\x89\xe4\x6d\x22\x76\x27\x51\x67\x0f\x93\xbf\xc9\xd4\xda\x64\xe6\xe0\x64\xf2\x3f\x19\xde\x26\x63\x63\x32\x63\x1e\x61\xcc\x23\x8c\x79\x84\x31\x8f\xc0\xc3\x23\xe8\x7e\x04\x9d\x53\x88\x61\x0a\x31\x4c\xc1\x87\x29\xf8\x3a\x05\x1b\x53\xf0\x69\x2a\xf5\x5f\x40\xfc\x05\xd9\xe6\xf9\x02\xc0\x41\x01\xfd\xd3\xc8\xfb\x34\x72\x3e\x0d\x1e\xa6\xa1\x67\x1a\x36\xa7\x13\xd7\x74\x6a\x6b\x3a\x71\x4d\x87\xcf\xe9\x70\x31\x1d\xdd\x8f\xa2\xfb\x51\xf2\xf7\x28\x7e\x3c\x8a\x1f\x8f\x92\xbf\x19\xe4\x6f\x06\xf9\x9b\x41\xfe\x66\xe0\xd7\x63\xf0\xf4\x38\xba\x67\x32\x7e\x16\x7a\x66\x31\x27\x9e\xc0\xf6\x6c\x72\x34\x9b\xb8\x9e\xa4\x1e\x9e\xe4\xf9\x1c\x7c\x9c\x83\xfd\xb9\x5c\x3f\x85\xed\xa7\x18\x3b\x0f\xfb\xf3\x89\x67\x01\x31\x3f\x8d\x5f\x0b\xa9\xbd\x85\x3c\x5f\x84\xbf\x8b\xe0\x77\x11\x9c\x2e\xc6\x9f\x25\xe8\x5e\x82\xde\x67\xb0\xbb\x14\x8e\x97\x12\xe3\x52\x7c\x5c\x8a\xed\x65\xf0\xfc\x2c\x3e\x2e\x87\x9f\xe5\x70\xb8\x82\x18\x56\x92\x83\xe7\xe0\xfd\x39\x9e\xaf\x62\xfc\x2a\xec\xac\x66\xbd\x59\x83\xcc\x1a\x38\x7a\x9e\x1c\x3e\x4f\x8e\x5f\x80\x9b\x17\xf1\xf9\x45\xe4\xd6\x12\xcf\x4b\xd8\x7f\x89\xfe\x97\x19\xff\x32\xb6\xd7\xe1\xfb\x2b\xe8\x5e\x1f\xe3\xfb\xc3\x3f\xaf\x52\xd7\x1b\xf0\xed\x35\xf2\xf9\x1a\xfc\xbc\xce\xf3\xd7\x99\x33\x6f\xa0\xf7\x0d\xc6\xbd\xc1\x7a\xf3\x06\x1c\x79\xb8\xf7\xc0\xb1\x87\xb1\x1e\x62\xf5\xc0\x9f\x07\x59\x0f\x1c\x7a\x90\xdf\x88\x9d\x8d\xcc\xb1\x8d\xf8\xb4\x91\xfb\x4d\xdc\x6f\xe2\x7e\x13\x39\xdf\x44\xdc\x9b\xb0\xb3\x19\x4e\x36\xa3\x63\x33\xfe\x6e\x46\xef\x16\x7c\xd8\x42\xfc\x5b\x98\xc3\x5b\x88\x79\x0b\x3e\xbf\xc9\xfc\x7a\x13\x1d\x6f\x62\xfb\x4d\xb8\xde\x4a\x2c\xdb\x40\x21\xf1\x15\xc2\x43\x21\xb1\x17\xc2\x53\x21\xbe\x6e\xa7\x7f\x3b\xf9\xdc\x4e\xcc\xdb\x99\x1f\xdb\x19\xb3\x9d\x31\x3b\xe8\xdf\x41\xff\x0e\x38\xde\x41\x8e\x76\x60\x6f\x07\xfc\xbe\x85\x2f\x3b\xf1\x61\x27\xb5\xb8\x93\x7c\xbe\x4d\x3e\xdf\x26\x07\x6f\xe3\xdb\x3b\x70\xf1\x0e\xb6\xdf\x21\xbe\x77\xf0\xe7\x1d\x78\x7f\x87\x77\xd5\xbb\xd4\xdb\xbb\xe8\x78\x97\x78\xdf\x25\xd6\x77\xe1\x62\x17\xf9\xda\x85\xcd\x5d\xf0\xb6\x8b\xdc\xee\x22\xef\xbb\xa9\xa1\xdd\xc4\xb2\x1b\xce\x77\xe3\xc7\x6e\xea\xe2\x3d\xe2\x7b\x8f\x78\xdf\xa3\x1e\xde\x63\x4e\xbc\x47\x5d\xee\xc1\xfe\x1e\x78\xd9\x83\x9d\x3d\x8c\xdf\x43\xff\x5e\x7c\x79\x1f\xfe\xdf\x27\xee\xf7\xb1\xfd\x01\xbe\xef\xc3\xe6\x87\x60\x3f\xe3\xf7\x13\xef\x47\xe4\xef\x23\x62\xfc\x08\xdd\x1f\x99\xf7\xc4\xf9\x31\x39\xf9\x18\x99\x8f\xf1\xed\x63\x38\x3f\x00\xe7\x07\xd0\x7d\x00\x9e\x0e\x90\x9b\x03\xf4\x1d\xa4\xef\x20\x63\x3e\xc1\xce\x21\xec\x1d\x82\xe3\x4f\xa9\xa3\xcf\xf0\xf7\x33\x74\x7c\xce\xfd\x11\x72\x71\x14\x4e\x8e\xe2\xdf\x31\xc6\x7c\x81\x9d\xe3\xf8\x7e\x1c\x5f\xbe\xc4\xf7\xaf\xe0\xf1\x2b\xec\x9f\x60\xcc\x49\x62\x3c\x09\xf7\x5f\xa3\xff\x1b\xe4\x4e\x31\x47\x4f\xd3\x7f\x1a\x1d\xdf\xc2\xc9\x19\x7c\x3a\xcb\xd8\xb3\xcc\xe5\xef\xf0\xeb\x1c\xcf\xcf\x63\xef\x3c\x1c\x15\xc1\xf3\x05\x7c\xb9\x88\xae\xef\xf1\xeb\x12\x9c\x5f\x82\x8f\x4b\xd8\xbc\x8c\xed\x2b\xf8\xf8\x03\xfe\x5f\xc5\xc6\x55\xf8\xb9\x86\xcc\x35\xe4\x7f\xa4\xd6\x7f\xc2\xbf\x9f\xa8\xdf\x9f\xd1\x7b\x9d\xe7\xd7\x91\xfd\x05\x5b\xbf\xc0\xd5\x2f\xe8\xfd\x95\x71\xbf\x61\xe7\x37\x78\xff\x1d\x5f\xfe\x80\xa3\x1b\xe4\xfd\x26\xb2\x37\xb9\xbf\xc9\xb8\x5b\xe8\xba\x4d\x7e\xbc\xd8\xf7\x1e\xf0\xfd\x1d\x53\xe3\x02\xc7\xbd\xbe\x9c\xfe\x75\x90\x0d\xb6\x88\xa2\xb6\x05\xa7\x45\xd1\x4e\x8a\xc2\x9e\x47\xd1\xaf\x8b\xc2\xbe\x47\xb1\x73\x6d\x3f\x2e\x8a\x03\xf9\x80\x46\xa2\x94\x08\x03\x2e\xc0\xb3\x40\x0e\x8c\x81\x2b\xc0\xef\xa2\x94\xa4\x0d\x42\x26\x98\xe7\xe6\x5f\xc7\x09\x59\x24\x4a\x68\x65\xb0\x4b\x94\xb0\x01\x60\xb2\x28\xa5\x32\x45\x09\x2f\x07\x90\x8f\x18\x22\x4a\x24\xd7\x91\x4b\x01\xfa\x4b\xef\x14\x25\x8a\x31\xd1\xc3\x45\x89\x01\x65\x0e\x88\x12\x8b\x9d\x72\xe5\x45\x89\x8b\x11\x25\x1e\x79\xe7\x0c\x51\x5c\xf8\xeb\x3a\x2c\x4a\x02\x3e\x27\xb6\x00\xb7\x44\x49\x22\x9e\x24\xda\xf2\x1b\x44\x49\x46\x3e\xb9\x1e\x58\x2d\x4a\x4a\x45\x50\x28\x4a\x05\x62\xa8\x80\xbe\x0a\xc4\x56\xe1\xb2\x28\xa9\x5d\x44\xa9\x16\x00\x7a\x02\x8f\x28\xd5\xe1\xa1\x3a\xba\x6b\x10\x4f\x0d\x7c\xaa\x81\xdf\x35\xf0\xa1\x06\xfa\x6a\xce\x11\x25\x0d\xf9\x34\x9e\xd7\xc2\xff\x5a\x66\x8b\xce\x5a\xd8\xac\x8d\x5f\xb5\xd1\x5d\xbb\x00\x7c\x08\x88\xab\x0e\x32\x75\xd6\x81\x6b\xa2\xd4\xad\x05\x18\x5f\x97\xd8\xea\x21\x5b\x1f\x7f\xeb\xc3\x71\x03\x64\x1a\x1e\x11\xa5\x31\x36\x1a\xc3\x4f\x13\x7c\x6e\x82\x4c\x13\x38\x4f\x7f\x11\xa0\x3f\x1d\x7d\x6e\x7c\x74\x13\xaf\x1b\x7d\x6e\x74\x37\x25\x2e\xf6\x43\x4a\x53\x9e\x37\x25\x9e\x66\xe8\x6c\x89\xed\x96\x8c\x6d\xc9\xf3\x0c\x9e\x67\x90\x97\x8c\xef\x00\xf7\xf7\xe3\xf7\xfd\xf0\x76\x3f\xdc\xdf\x3f\x1f\x30\xa6\x15\x3a\x5b\xb5\x02\xb3\x00\x3c\xb6\x26\xe6\xd6\xc8\xb4\x86\xfb\xd6\x7b\x01\xb9\x68\x0d\x47\x0f\x90\xc7\x07\xf0\xff\x01\xc6\x3d\x00\xd7\x0f\x10\x6f\x1b\xf2\xdf\x86\x7c\xb5\x81\xc7\xb6\xd8\x6e\xeb\x06\xd8\x6b\x8b\xfd\x76\x91\x00\x3e\xdb\xe1\x5f\x3b\x38\x6a\x87\xae\x76\xe8\x6a\x0f\xb7\xed\xab\x03\x6a\xa3\x3d\xba\xda\x23\xdb\x1e\xbb\x1d\x90\xef\x80\x1f\x1d\x18\xdf\x81\x78\x3a\xc0\x4b\x26\xf9\xce\xc4\x97\x4c\xfc\xcd\xc4\x66\x47\x7c\xeb\x48\x5f\x47\xfc\xe8\x88\x6c\xc7\x7c\x40\x4e\x3a\xe1\x5b\x27\x38\xeb\x44\x5d\x75\x82\x9b\x4e\x70\xdd\x99\x3c\x74\xe6\x79\x67\xfc\xeb\x0c\xb7\x9d\xf1\xb7\x0b\xe3\xbb\x60\xbb\x0b\x1c\x76\x81\xa7\x2e\xf8\xd4\x05\x5e\xb2\xe8\xcb\x42\x2e\x0b\x9e\xd8\xbf\x29\x5d\xf1\xb7\x2b\x75\xd0\x95\xb8\xba\xa2\xab\x1b\x3e\x77\x23\x96\x6e\xd4\x10\x7b\x39\x25\x9b\x58\xb3\xc9\x59\x36\x7e\x65\x93\xa3\x1c\xb8\xeb\x8e\x4f\xdd\x89\xb5\x3b\x32\xbd\xf0\xb9\x17\xfa\x7a\x11\x6f\x6f\x74\xf7\xc6\x8f\xde\xe4\xb1\x37\x63\xfb\x50\x83\x7d\x78\xde\x87\xf9\xc1\x7e\x4d\xe9\x0b\x07\x7d\xc9\x6d\x2e\x79\xc8\xc5\xe7\x5c\x74\xe4\x32\x36\x17\xbf\xfa\xc1\x2f\xfb\x35\xa5\x1f\xbe\xf6\x23\x1f\xfd\xf0\xa7\x1f\xfe\xf4\xc7\x9f\xfe\xf4\xf7\xa7\xbf\x3f\x3a\x58\x32\x95\x01\xc4\x34\x00\xbd\x03\xf0\x69\x00\x79\x1d\x48\xdf\x40\x7c\x62\x3f\xa7\x0c\xc4\xd6\x40\xf8\x1b\x68\xf6\xa3\x63\x10\x5c\x0f\x22\xc6\x41\xf4\x0d\x62\x9e\x0c\xa6\xbe\x07\x13\xdf\x60\x64\x07\x93\x8f\xc1\xe8\x1c\x42\xdd\xb3\x9f\x53\x86\x90\xa7\x21\xf8\x34\x84\x9c\x3c\x88\xbe\x07\xe1\xe7\x41\xea\xe8\x41\xb8\x1e\xca\xfd\x50\xee\x87\x72\x3f\x14\x5d\x43\xe1\x73\x28\x31\x0e\x63\xcc\x30\xc6\x0c\xa3\x96\x87\x91\xdb\xe1\x3c\x1f\x8e\xfc\x70\x78\x18\xc1\xb3\x11\x3c\x1b\x09\x0f\x23\xe1\x6e\x14\x79\x1b\x85\xef\xa3\xe0\x90\xfd\x9c\xc2\x7e\x4e\x19\x8d\x7f\xec\xe9\x94\x31\xe4\x75\x0c\x32\x63\x19\x97\x07\x17\xf9\xe4\x2f\x1f\xae\xc6\x31\x9e\x3d\x99\xf2\x10\x31\xb0\x0f\x53\xc6\xc3\xf9\x04\xfc\x9f\x00\xdf\x13\x79\x3e\x91\x76\x12\xcf\x1e\x86\xfb\x87\xc9\xe9\x64\xae\x1f\x41\xee\x11\x6a\x6b\x0a\x31\x4d\x81\xc3\xa9\x8c\x29\x80\xbf\x02\xf2\x5c\x80\xcc\x34\x6c\x4e\x23\x96\x69\xd8\x9a\x8e\x1c\x7b\x23\x65\x06\xf6\x67\x10\xe3\x0c\x78\x9d\x41\xdf\x63\xd8\x78\x9c\x58\x66\xa2\x6b\x26\x75\x36\x8b\xf9\x35\x0b\xfe\x9e\x20\x17\x4f\x50\xaf\xb3\xc9\xdb\x93\x3c\x7b\x92\xeb\x39\xc4\x33\x17\x5d\x4f\x11\xef\x3c\x72\x3b\x0f\x3b\xf3\x89\x73\x01\xf9\x79\x1a\x3d\x0b\x89\x9f\x57\x8b\xb2\x08\x5f\xd9\x0b\x29\x4b\x88\x77\x09\xbc\x3f\x83\x9d\xa5\xc4\xba\x0c\x7f\x96\x11\xe3\x32\xec\x2f\xc3\xaf\x65\xe4\xed\x59\xe2\x7e\x16\x9f\x9f\xc5\xb7\x67\xf1\x7f\x39\x32\xcb\x19\xbb\x02\xff\x56\x30\x6e\x05\xfd\x2b\xf0\x6b\x05\x3a\x57\xc2\xd5\x4a\xf4\x3d\x47\x1e\x9f\x83\xc3\x55\xf8\xb5\x0a\xf9\x55\xe8\x5a\x45\x0c\xab\xe1\x66\x35\xbe\xaf\x61\xfe\xac\x41\xf7\xf3\xe8\x78\x1e\xff\x5f\x40\xe6\x05\xec\xbe\x40\x1d\xbc\x40\xbd\xbc\xc0\xb3\x17\xa9\xbd\x17\xa9\xdf\xb5\xc4\xf0\x12\xfa\x5f\xc6\xa7\x97\xc9\xe7\x3a\xe2\x5a\x87\xcd\x75\xf8\xb2\x8e\x67\xeb\xc8\xf7\x3a\xf2\xbd\x8e\xf8\xd7\xc1\x31\x07\x7f\xe5\x15\xc6\xae\xc7\xe7\xf5\xc8\xbd\x8a\xfc\xab\xd8\xd8\x80\x8d\x0d\xe8\x79\x8d\xf5\xe2\x35\xe4\x5e\x87\x93\x37\xe0\xc9\x83\x4f\x1e\xc6\x7a\xe8\xdb\x48\x2d\x6c\xa2\x1e\x37\xc3\xcb\x16\xe4\xb7\xe0\xd3\x9b\xd4\xe9\x9b\xf8\xbc\x95\xd8\xb6\xc2\xd1\x56\x7c\xdb\xc6\xb8\x42\x9e\x15\xe2\x5f\x21\x35\xb8\x9d\x9c\x6d\x67\x8d\xd8\x8e\x2e\xf3\x1b\x81\xed\xe4\x7b\x07\xf6\x77\x60\xff\x2d\x74\xbd\x05\x37\x3b\xa9\xd3\xb7\xa9\x93\x77\x88\xe1\x5d\x74\xb1\xaf\x51\x76\x91\xc3\xdd\xe4\x73\x37\xb5\xf0\x1e\xf6\xd8\xb3\x28\xec\x51\x94\x3d\xc8\xef\x25\xae\xbd\xc4\xf5\x3e\xe3\x3e\xa0\xef\x03\x9e\xed\xc3\xc6\x3e\xf8\xfd\x10\x3d\x1f\x32\x57\xf7\x93\xcf\xfd\xe4\xf7\x23\xda\x8f\xf1\xed\x63\xb8\x3b\x40\xdd\x1d\xc4\xfe\x27\x8c\x39\x84\xce\x43\x70\x74\x18\xbf\x0e\x53\xe3\x9f\x62\xf3\x33\xe4\x3f\x67\x2d\x39\x42\x6e\x8e\x10\xcb\x31\x72\xf0\x05\xb1\x1f\x87\xa3\x2f\xe1\xf8\x2b\x64\x4f\x10\xdb\x09\xf8\x3d\xc9\xf8\x93\xd8\x3d\x09\x57\x5f\xa3\xf7\x1b\xda\x53\xd4\xd1\x69\x38\xf9\x16\xbf\xce\xc2\xed\x59\xec\x9c\x45\xc7\x59\x38\x62\xdf\xa1\x9c\x83\x9b\x73\x70\x72\x1e\x4e\xce\x13\xfb\x79\x6a\xf2\x3c\xfc\x5e\x40\xd7\x45\x9e\x7d\xcf\xd8\x4b\xd8\xbe\x84\x5f\x97\x89\xff\x0a\x72\x57\x88\xe9\x07\x64\x7f\x80\xcf\xab\xd4\xce\x55\xf2\x77\x8d\x7a\xf9\x11\xfd\x3f\x81\x9f\xc9\xe9\x75\x7c\xfe\x05\xdf\x7e\xc1\xe7\x5f\xe1\xf6\x37\x78\xfe\x8d\x1a\xfb\x9d\x5a\xfa\x03\x4e\x6f\x20\x73\x83\x71\x37\xe1\xe2\x26\xdc\xdd\x22\x96\x5b\xe4\x9b\x7d\x87\xe2\x85\x1b\xa3\x95\xa8\x92\x29\xaa\x52\x11\x5c\x17\x55\x1d\x22\xaa\xd6\x13\xec\x12\x55\xa7\x4f\x2f\x14\xd5\xd6\x05\x5c\x16\xd5\x5e\x20\xaa\x23\x08\x1c\x11\x35\x60\x82\xa8\x25\xca\x83\x93\xa2\x06\xce\x17\xb5\x64\x24\xe0\x3e\x88\xe7\x41\xc8\x06\x5f\x13\x35\x84\x36\xe4\x96\xa8\xec\x35\xd4\x50\x74\x86\xc5\x80\xe3\xa2\x96\x42\x0f\x7b\x0d\x35\x1c\x1b\x11\xd9\xe0\x3b\x51\x23\xf3\x45\x2d\x8d\x8e\xd2\xd8\x8b\x42\x77\x34\xba\xa2\x6b\x81\x01\x60\x11\xf8\x10\xa0\x2b\x06\xfd\x31\x8c\x8d\x69\x0b\x26\x83\x39\x60\x05\x38\x2c\x6a\x19\x1d\xd4\x03\xc3\xc1\x6a\x80\x9f\x65\x67\x81\xa5\x80\xf1\x65\x7f\x17\x35\x16\x5f\x62\xfb\x02\x74\xc6\xd2\x57\x0e\x5f\xe2\xaa\x03\xec\xc4\x21\x17\x77\x40\xd4\x78\x01\xf4\xc5\x23\x17\x8f\x5c\x3c\x72\xf1\xd8\x76\xd2\xe7\x44\xce\x89\x9c\x93\x7b\x17\xcf\x5d\x3c\x77\xf1\x3c\x61\x86\xa8\x89\x8d\x00\x31\x27\xd1\x57\x1e\x3b\xe5\x89\x8f\xfd\x8e\x9a\x0c\xc7\x29\xf8\x9d\xc2\xb3\x0a\xc8\x56\x64\x7c\x25\xf4\xdc\x07\xbf\xf7\xc1\x53\xaa\x47\xd4\xca\xf0\x50\x19\xff\xaa\x04\x00\x78\xaa\xb2\x4e\xd4\xaa\x70\x51\x15\xf9\xaa\x70\x56\x0d\x3f\xab\xc3\x49\x75\x38\xa9\xde\x02\x90\x93\xea\xe8\xa8\x4e\x8c\x35\xc8\x59\x0d\xe4\x6b\x32\xae\x26\x71\xd7\x44\x3e\x8d\x18\xd2\xe0\x26\x8d\xf1\x69\xe8\x65\x7f\xa4\xb2\x3f\x52\x6b\xe1\x1b\xfb\x23\xb5\x36\x36\xeb\xc0\x63\x1d\xb8\xae\x73\x5a\xd4\xba\xf8\x57\x17\xff\xeb\xc2\x1d\x7b\x22\xb5\x2e\xb5\x50\x8f\x78\xeb\xc1\x6d\xbd\x0d\x00\x99\xfa\xc8\xd7\xc7\x2e\xfb\x24\xb5\x81\x1b\xbc\x28\x6a\x43\xf2\xd6\x90\xb8\x1a\x91\x8b\x46\xe8\x6c\x8c\x9e\xc6\xd8\x68\x8c\x8e\xc6\xd8\x69\xe2\x02\xc4\xd6\x04\x99\x74\xf4\xa5\x33\x3e\x1d\x9b\xe9\xf8\xc9\x3e\x4a\x65\x1b\xad\xba\xe1\xc8\x4d\x7c\xee\x2d\x80\x31\x4d\xc9\x6d\x53\xf4\x35\x85\xe3\x66\xf8\xd3\x8c\xb1\xcd\xe1\xb3\x39\xbc\x35\xdf\x2b\x6a\x0b\x78\x68\x81\x7c\xcb\x30\x80\x1f\x2d\xb1\x97\x01\x6f\xec\xaf\xd4\x0c\x7c\xbb\x9f\xf6\x7e\x7c\x63\x3f\xa5\xb6\xc2\xff\x56\xc4\xcf\x3e\x4a\x6d\x8d\xbe\x07\x68\x1f\x80\x9f\x36\xf8\xd1\x06\x99\xb6\xe4\xa6\x2d\xb5\xd3\x16\xbb\xed\xf0\xa5\x1d\x1c\xb6\x43\x67\x3b\xec\xb7\x43\x57\x7b\x74\x77\x60\x5c\x26\x3e\x64\xd2\x76\xc4\x9f\x4e\xf0\xd0\x09\x5f\x3a\x93\xff\xce\xe4\xa8\x0b\xfe\x74\x21\x2f\x5d\x88\x3f\x8b\x36\x8b\x31\x59\xe8\xce\x22\x9e\xae\x70\xda\x95\x1c\x75\xe3\x3e\x9b\x7a\xc8\x61\xae\x74\xc7\x4e\x77\xf4\x74\x47\x7f\x0f\xec\xf4\x84\xb3\x9e\xe8\xea\x39\x5a\xd4\x5e\xc4\xd4\x0b\xf9\xde\x26\x98\x17\xbd\xc9\x43\x1f\xea\xba\x0f\xf9\xed\x8b\x6c\x2e\xfa\x73\x89\x2f\x97\xba\xce\x65\xee\xe5\xe2\x57\x3f\xf2\xdc\x9f\x58\xfb\x33\x7e\x00\x73\x68\x00\x76\x06\x22\x3b\x90\x67\x83\x88\x73\x10\xb9\x18\x4c\x3b\xd8\x6c\xd1\x37\x84\xb9\x38\x04\xee\x1f\x64\xcc\x83\x8c\x7d\x90\x1a\x64\xdf\xa0\xb2\x5f\x50\x87\xe1\xdf\x70\xec\x0d\xa7\x7f\x38\xfa\x47\x90\x8b\x11\xc8\x8e\x24\xb6\x51\xc4\x30\x9a\xda\x1b\x83\xfd\xb1\xe4\x75\x2c\xfa\xf2\xa8\x41\x8e\x54\x6a\x3e\x36\xc7\x61\xf3\x21\xea\xec\x21\x72\x3b\x1e\xdd\xe3\x19\x37\x81\xe7\xec\x05\xd4\x89\xd4\xc0\x44\xf8\x98\x84\x7f\x93\xe0\xec\x61\x78\x79\x98\x5c\x4e\x26\x9e\xc9\xf0\xfa\x08\xe3\xa6\xa0\x67\x0a\x7a\xa6\xe0\xc7\x54\x62\x29\xa0\x5e\x0a\x90\x2d\x60\x4e\x16\xc0\x55\x01\xbe\x4f\x43\xef\x34\xf2\x35\x9d\xf1\xd3\x19\xf7\x28\x7c\x3d\x0a\xff\x33\x98\x4b\x8f\x61\xe3\x71\x78\x99\x49\x9d\x3f\x41\xff\x6c\xfa\x9f\x24\xae\x39\xf8\x3c\x97\xbc\x3e\x05\xe6\xd1\x37\x9f\xf8\xe6\x13\xf3\x02\x9e\x3d\x8d\x9e\x85\xd8\x5a\x48\x3d\x2d\x24\xf6\x45\xf8\xbe\x98\x1a\x59\x82\xdf\xcf\x90\x93\xa5\xf8\xb5\x8c\x71\xcf\xa2\x7b\x39\xe3\x96\x13\x3b\xef\x76\x75\x25\x63\x9f\x43\xef\x73\xf8\xb0\x0a\x5d\xab\xe1\x62\x0d\x32\xcf\x93\xcb\xe7\xc9\xd5\x0b\xd4\xd3\x8b\xf0\xb7\x16\xbf\x5f\x22\xa6\x97\xe1\x62\x1d\x71\xbc\x82\xef\xeb\xb1\xf7\x2a\x35\xf6\x2a\xf9\xd9\xc0\xb3\xd7\xe0\xe5\x75\x72\xf2\x3a\x3c\xbd\x01\xcf\x1e\x6a\x6b\x23\xf6\x37\x92\xff\x4d\xb4\x9b\x98\x63\x9b\xa8\xe1\xcd\xf8\xb8\x19\x3e\x36\x63\x6f\x0b\xf6\xb7\x60\xfb\x4d\x6c\xbe\x09\x8f\x5b\xe1\x65\x2b\xfc\x6c\xe3\x79\x21\xfe\x6f\xc7\xe7\xed\xc8\xef\x20\xde\x1d\xe8\x79\x0b\x99\x9d\xcc\xa1\x9d\xd8\x7f\x1b\xff\xde\xa1\xfe\xde\xc1\xde\xbb\xc4\xf7\x2e\x79\xdd\xc5\xf8\x5d\xcc\x95\xdd\xe8\xdd\x8d\xfe\xf7\xa8\xe1\xf7\xf0\x6f\x0f\xf3\x63\x0f\x71\xec\x65\x8e\xee\x45\xef\x5e\x7c\xdb\x4b\x2c\x7b\xf1\xe7\x7d\xb8\x7b\x1f\x3e\xde\x27\xae\x0f\xc8\xdd\x07\x8c\xfd\x80\x1a\xf8\x00\xfd\x1f\xa0\xfb\x03\xfc\xdb\x87\xfd\x7d\xd4\xd0\x3e\x62\xd8\x87\xfe\x7d\x8c\xdd\x87\x9f\x1f\xd2\xff\x21\xba\x3f\x84\x8b\x0f\xd1\xf9\x21\x3c\x7c\x08\x67\xfb\xc9\xdb\x7e\x6c\xed\x87\xfb\xfd\xe4\x72\x3f\xbc\x7e\x04\xef\x1f\xd1\xf7\x11\xf1\x7c\x84\xee\x8f\x88\xe1\x23\xec\x7f\x4c\x0d\x7e\x8c\xee\x8f\xf1\xe1\x63\xfa\x3f\xc6\xe6\x01\xe2\x38\x80\xec\x01\x7c\x3d\x80\xde\x03\xe8\x3d\x80\xde\x83\xcc\x59\xde\xff\xea\x41\xfa\x0f\xa2\xe7\x20\xf2\x07\xd1\x73\x10\x3d\x9f\xa0\xe7\x13\x78\xfc\x84\x98\x3f\x81\xa7\x4f\xf0\xef\x10\xf2\x87\xc8\xef\x21\x78\x3a\x44\xff\x21\xfc\x38\x04\x8f\x87\xf1\xef\x30\x71\x1f\x26\x2f\x87\x99\x23\x87\xc9\xdd\x61\xf8\xf9\x94\xbc\x7f\x4a\xff\xa7\xc8\x7f\x4a\x9c\x9f\xa2\xe7\x53\xf8\xfb\x0c\x3d\x9f\xe1\xe3\x67\xc4\xff\x19\xfd\x9f\xd1\xff\x19\xfd\x9f\x33\x0f\x3e\x47\xfe\x73\xe2\xff\x1c\x4e\x8e\xc0\xdf\x11\xae\x8f\x90\x8b\x23\xf8\x74\x94\x5c\x1d\xc5\xcf\xa3\xd4\xc3\x51\x6a\xe8\x18\x76\x8f\x51\x33\xc7\x90\x39\x86\x9e\x63\xe8\x39\x86\x9e\x2f\xc8\xf3\x17\xf4\x7f\x41\x5c\x5f\x50\x97\x5f\x10\x2f\xfb\x16\xf5\x38\xfd\xc7\xe9\x3f\x8e\xdd\xe3\xc4\x7a\x1c\x1f\xbf\x44\xc7\x97\x70\xfe\x25\x7a\xbf\x44\xef\x97\xc8\x7d\x85\xdc\x57\xc8\x7d\xc5\xf8\xaf\x18\xff\x15\xf5\xf3\x15\xf6\x4e\x10\xcf\x09\x78\x3c\x41\x1e\x4e\x90\x87\x13\xc8\x9f\x80\xdf\x93\xf4\x9f\x84\xab\x93\xc8\x9e\xe4\xfe\x6b\xf8\xfe\x1a\xb9\xaf\x91\xfb\x1a\xb9\xaf\x19\xff\x35\x7c\x7f\x83\xde\x6f\xb0\xc5\xde\x48\xfd\x86\xb1\xdf\xa0\xf3\x14\xf6\x4f\x21\x7b\x0a\xd9\x53\x8c\x3f\x85\xaf\xa7\xe0\xfa\x34\x73\xf7\x34\x3a\x4f\x33\xfe\x34\xe3\x4f\x33\xfe\x5b\x64\xbf\x45\xf6\x5b\x64\xbf\xa5\xff\x5b\x74\x7c\x0b\xff\x67\xd0\x7b\x06\x3e\xcf\xa0\xf7\x0c\xef\xa5\xb3\xe4\xfe\x2c\x73\xf6\x2c\x1c\x9e\x85\xb7\xef\xd0\xf5\x1d\x73\x89\x3d\x97\xfa\x1d\x1c\x7d\x47\xdf\x39\xb8\x64\xff\xa5\x9e\x23\x5f\xe7\xb0\x79\x0e\xde\xce\xa3\x87\x7d\x98\x7a\x1e\x2e\xce\x93\xc3\xf3\xd8\x2c\x22\x57\x45\xd4\x48\x11\xeb\x47\x11\x7e\x14\x61\xef\x02\x7e\x5c\xc0\x8f\x0b\x8c\xbf\x80\xce\x0b\x8c\xbf\x00\x6f\x17\xa9\x99\x8b\xd4\xfb\x45\x7c\xbb\x48\x6d\x5c\xa4\xef\x7b\x6a\xfa\x7b\xe2\xf8\x1e\x3b\xdf\x23\xf7\x3d\x76\x2e\x61\xe7\x12\x3c\x5c\xc2\xd7\x4b\xac\x6b\x97\x98\x13\x97\x91\xbb\x8c\xed\xcb\xc4\x70\x99\xfe\xcb\x70\x73\x85\x7a\xb8\x82\xdc\x15\xfa\xae\x10\xeb\x15\x6c\xff\xc0\x58\xf6\x7f\xea\x0f\xc4\xc8\x1e\x50\xfd\x81\xf1\x57\x99\x0b\x57\x59\x33\xaf\x52\x7f\xec\x07\xd5\xab\xc4\x78\x15\x0e\xaf\xa1\xf3\x1a\xb2\xd7\xc8\xf7\x35\xea\xe3\x1a\xfd\xd7\xe8\xff\x91\xfe\x1f\xf1\xf3\x47\x62\xfa\x91\x38\x7f\x44\xef\x4f\xd8\xfa\x89\xda\xfe\x09\xd9\x9f\xd0\xfb\x13\xf3\xf7\x27\x64\x7f\x46\xf6\x67\x64\x7f\xc6\x87\x9f\xd1\xfd\x33\x3a\x7e\xa6\xff\x3a\xfd\xd7\xe9\xbf\x8e\x8e\xeb\xe8\xb8\x0e\x57\xbf\xc0\xd5\x2f\x70\xf5\x0b\x7d\xbf\xc0\xd5\x2f\xc4\xfa\x2b\xfe\xfe\x8a\xde\x5f\xf1\xf7\x57\x6a\xee\x57\x6a\xee\x37\xea\x85\x3d\xa9\xfa\x1b\xb6\x7e\xc3\xd6\x6f\xc4\xf0\x3b\x31\xfc\x4e\x0c\xbf\x53\x73\xbf\xe3\xeb\xef\xd8\xff\x1d\x5e\xfe\x60\xbd\x67\xcf\xaa\xfe\xc1\xbc\xfd\x83\xbe\x3f\xe8\xbb\x41\xee\x6e\xc0\x3d\x7b\x58\xf5\x06\x39\xbe\x41\xdf\x4d\xe4\x6e\x22\x77\x93\xbe\x9b\xf8\x78\x93\x1c\xdf\x42\xee\x16\x72\xb7\xe8\xbb\x85\xdc\x2d\xe4\x6e\x53\x0b\xb7\xf1\xfb\x36\x3e\xde\xc6\xef\xdb\xc4\xee\x25\x76\x2f\x3e\x7a\xf1\xc7\x8b\x3f\x5e\xfc\x31\xa8\x61\x83\xb9\x68\x30\xb7\x0c\xfa\x8c\xe3\xa2\x49\x10\x68\x04\x86\x83\xd5\xe0\x88\x68\x4a\x00\xa0\x4f\x19\x02\x16\x81\xbd\xe0\xba\x68\x6a\x79\xd0\x05\xcc\x00\x5b\xc0\x05\xd1\xb4\x72\x20\x13\xd0\xa7\x15\x82\xcb\xa2\xe9\xf4\xe9\xf4\xe9\xf4\xb1\xaf\xd6\x74\xe4\x6c\x31\xa0\x2d\x28\x00\x8c\xb5\xd1\x67\x47\xce\x8e\x1c\xfb\x6d\xcd\xee\x01\xdf\x89\xe6\x40\xce\xd1\x0a\x4c\x00\x1b\xc0\x69\xd1\x02\xc2\x80\x1b\xe0\x63\xc0\x0a\x70\x00\xdc\x12\xad\x44\x65\x90\x0d\x66\x01\xec\x94\x40\x67\x20\xe3\x03\x19\x1f\xc8\xf8\x40\xc6\x07\x32\xbe\x24\x76\x4a\xe2\x77\xc9\x39\x80\x58\x4a\x32\x36\xa8\x16\x20\xbe\x20\xf4\x05\xc1\x43\x30\x36\x82\xf1\x2f\x18\x9f\x83\x77\x01\x64\x42\x90\x09\xc1\x66\xc8\x3a\x80\x6f\xa1\x2e\xd0\x13\x2c\x05\xf0\x14\x06\x77\x61\x2d\x00\xfe\x87\xed\x04\xbf\x8b\x56\x8a\x31\xa5\x46\x03\x6c\x97\x62\x0c\xfb\x7f\x2d\x1c\x1f\xc3\xe1\x31\xfc\xb0\x68\x11\x8c\x89\xc0\xbf\x08\xec\x44\x30\x26\x02\x5e\x23\xab\x03\xec\x44\xbe\x08\x4e\x8a\x56\x9a\x18\x4a\xe3\x6f\x69\x64\x4a\xc3\x55\x69\xe2\x8a\xc2\xbf\x28\x6c\x45\xe5\x03\xfc\x89\xc2\xe7\x68\xf2\x14\x5d\x0f\x0c\x00\xc4\x16\xcd\xd8\x18\xec\x73\x5e\xd0\x62\x18\x53\x06\x5e\xca\x10\x4b\x19\x64\xcb\x32\xbe\x2c\x1c\x96\x85\x97\xb2\x8c\x2f\x4b\x5f\x2c\xe3\x63\x19\xcf\x39\x41\x8b\xe5\xbe\x1c\x36\xe3\xf0\x2f\x8e\x3e\xce\x09\x5a\x1c\xfe\xc5\x47\x02\xc6\xc5\x63\x37\x9e\xfa\x88\x27\x06\xa7\x00\x7c\x76\xa2\xc7\x45\x7c\x2e\xe2\x4c\x40\x2e\x01\xff\x12\x90\x49\x80\xbb\x44\x72\x93\x08\x57\x89\xf8\x95\x08\xe7\x89\xc4\x99\x44\xfd\x24\x61\x23\x89\xb8\x92\x88\xab\x3c\x63\xcb\xc3\x5d\x79\x72\x57\xfe\x9a\x68\xc9\xf8\x93\x8c\xad\x64\xf8\x4b\x46\x77\x32\x3e\xa5\xd0\x97\x82\x3f\x29\xe4\x2a\x65\x3e\xf8\x50\xb4\x0a\xe5\xfe\x0f\x80\x6f\x15\xd0\x59\x81\xfa\xac\x88\xef\x15\xb1\x53\x11\xdf\x2a\x62\xa3\x12\x7e\x55\x82\xb7\x4a\xdc\xdf\x07\x5f\x95\xe1\xbf\x32\xbe\x57\x26\x1f\x55\xc8\x79\x55\x62\xae\x4e\x9d\xd4\x40\xae\x06\xf1\xd5\xc4\xbf\x34\x13\xd4\x40\x2d\x1d\xe0\x5f\x2d\xee\x6b\x11\x47\x6d\xb8\xa9\x0d\xd7\x75\xa9\xd1\xba\xf0\x50\x0f\x5e\xea\x91\x0f\xce\x15\x5a\x7d\x6c\xd6\xa7\x16\xea\x93\x97\xfa\xd8\x69\x40\xbd\x71\xb6\xd0\x1a\x10\x7b\x43\xec\x34\xe4\x59\x43\xee\x1b\x72\xdf\x88\x58\x1b\x53\x27\x8d\xf1\xb9\x09\xb5\x93\x0e\x7f\x6e\xb8\x70\x13\x8b\x1b\xff\xdd\xc4\xe3\x46\xbe\x29\xb6\x9b\xc1\x4d\x73\xae\x5b\xf0\xac\x25\xf9\xcd\x20\x57\xf7\xe3\x67\x6b\x72\xf0\x00\xb9\x6d\x83\xad\xb6\xf8\xd7\x8e\x9c\xb6\xa7\x76\x3b\x10\x6b\x07\x62\xea\x48\x5f\x27\xe2\xec\x4c\x3e\xba\xe0\x63\x16\xd7\x5d\xe1\xa0\x1b\xb5\xd8\x8d\xbc\x74\x47\xb6\x07\x32\x3d\x79\xd6\x0b\xf4\x66\x7c\x1f\x6c\xf4\x21\x07\x7d\xf1\x31\x97\x5c\xe6\x22\x97\x4b\xad\xb3\x47\xd7\xfa\x51\x3b\xfd\x58\x37\xfa\x31\xbe\x1f\xf2\xfd\xb0\xd1\x1f\x5f\xfb\xa3\xbf\x3f\x35\x32\x00\x5f\x06\x30\x47\x06\xa2\x77\x10\xba\x06\xc1\xdf\x60\xe2\x1e\x4c\xcc\x83\xcd\x6b\x64\x86\xe0\xf3\x10\x62\x7f\x90\xeb\xa1\xd8\x1a\x06\x67\xc3\xa8\x95\x11\xc4\x38\x12\xfe\x47\x22\x3b\x8a\x31\xa3\xc8\xc7\x28\xf8\x1d\x8d\xfe\xd1\xf0\x33\x1a\x7e\xc6\x54\x04\xf0\x30\x86\x67\x63\xe0\x7b\x2c\xf2\x63\x19\x37\x96\xbc\xe4\xc1\x5d\x1e\xcf\xf2\xe0\x33\x9f\xfc\xe4\xd3\x9f\xcf\x9a\x33\x8e\xfc\x8c\x23\xc6\x71\xc8\x3f\x84\xad\x87\x18\x3b\x9e\x38\xc6\x13\xc3\x78\xea\x76\x02\x5c\x4d\x40\xff\x04\xe2\x9d\x08\x3f\x13\xe9\x9b\x84\x8f\x93\x18\xfb\x30\x75\xf2\x30\x71\x3e\x8c\x1f\x93\x91\x9f\x4c\xbc\x8f\xc0\xc9\x23\xc8\x4c\xc1\x97\x29\xc8\x4c\x25\x87\x53\xe1\xa6\x00\x1d\x05\xf4\xb3\xb7\xd7\xa6\xe1\xd7\x34\x7c\x99\x46\x1d\xcc\x40\xef\x1c\xc6\x2c\x64\xfc\x42\x78\x59\x88\x1f\x8b\xf0\x6f\x11\xb6\x16\xf1\x7c\x11\xbe\x2f\x62\x2e\x2f\x26\xe6\xc5\xac\x95\x8b\x99\x93\x4b\xf0\x73\x29\x5c\x2e\x45\xff\x32\x64\x97\xc1\xc9\xb3\xc4\xb1\x9c\x7a\x5a\xc1\xb3\x95\xc4\xf6\x1c\xed\x2a\xc6\xac\x42\x7e\x35\x39\x5d\x0d\xef\xec\xdb\xb5\x35\xd4\xfb\xf3\xc8\xbf\x80\xad\x17\xd1\xb1\x96\x58\xd7\xe2\xf7\x4b\xd8\x7a\x99\xe7\xeb\xa8\x95\x57\x88\x69\x3d\x75\xbd\x1e\xfd\xec\xdf\xb5\x57\xc9\xcd\x06\x74\x6f\xc0\xff\xd7\xd0\xfd\x1a\xfe\xbc\x4e\xce\xdf\x40\xde\x03\x07\x1e\x72\xe9\x41\x76\x23\x3c\x6e\xa4\xee\x37\xc1\xf5\x26\xea\x73\x13\x7a\x36\xc1\xf7\x26\xf8\xd9\x8c\xef\x9b\x91\xd9\x82\x9f\x5b\xa8\xd1\x2d\xc4\xb5\x05\x2e\xde\xa4\x7e\xdf\xa4\x3e\xde\x64\xdc\x56\x6c\x6e\xa5\x7e\xb6\xc2\xc7\x56\xf8\xd8\x4a\xff\x56\x6c\x6f\xa3\x7f\x1b\xe3\xb6\xc1\xdb\x36\xf2\xb1\x0d\xdd\xdb\x90\xd9\x86\xdd\x6d\xd4\xfa\x36\xe4\xb6\xc1\xef\x36\x78\xde\x86\xce\x42\x62\x2a\x44\xa6\x10\xfb\x85\xf4\x17\xe2\x6b\x21\x7a\x0a\x99\xfb\xdb\xa9\x97\xed\x8c\xdd\x8e\x0f\xdb\xa9\xb3\xed\xf8\xb7\x9d\x98\xb7\x13\xd3\x0e\xb8\xdc\x81\xfd\x1d\xe8\xdd\x01\x67\x3b\xf0\x77\x07\xb5\xbe\x83\x1c\xbd\x85\xed\xb7\x88\xfd\x2d\xc6\xbc\x85\xef\x6f\x21\xbf\x13\xf9\x9d\xe4\x79\x27\x1c\xed\x84\x8b\x9d\xc4\xbf\x13\x1f\xde\xc6\xd7\xb7\xc9\xfb\xdb\x70\xfa\x36\x71\xed\xe2\xf9\x2e\xf4\xed\xc2\xfe\x6e\xe2\xdd\xcd\x9c\xd9\x0d\xe7\xef\x91\x9f\xf7\xf0\xf1\x3d\x72\xb2\x87\xeb\x3d\xe4\x65\x2f\xdc\xed\xc5\xfe\x5e\xc6\xee\xc5\xef\xbd\xf8\xcd\x19\x44\x7b\x9f\xe7\xef\xa3\xf3\x7d\xec\xbf\xcf\xdc\xf8\x80\x38\x3e\x20\xb6\x0f\x78\xb6\x0f\x9f\x39\x77\x68\xfb\xc8\xe9\x3e\x62\xd9\x87\x6f\x1f\xe2\xdb\x87\xd8\xe2\xec\xa1\x7d\x88\x6f\x1f\x32\x87\x38\x73\x68\xfb\xe1\x75\x3f\x31\x7d\x44\x3c\x9c\x33\xb4\x8f\xd0\xc1\x59\x43\xfb\x88\x3a\xe1\xbc\xa1\x7d\x84\x6e\xce\x1a\xda\xc7\xd4\xc6\xc7\xe8\xfc\x18\x3f\x3e\x66\x4e\x7c\x0c\x17\x1f\x93\x7f\xce\x1e\xda\xc7\xc4\x71\x80\x75\xee\x00\x32\x07\x18\xc7\x99\x43\x3b\x08\x9f\x9c\x35\x34\xce\x18\xda\x27\xd8\xe2\x4c\xa1\x1d\x42\xf6\x30\xba\x0e\x93\xff\x4f\xa9\xe7\x4f\x91\xe5\x9c\xa0\x71\x46\xd0\x3e\xc3\x87\xcf\xe1\xee\x73\xc6\x7d\x8e\xdd\x23\xf8\x73\x84\xfe\x23\xf4\x73\x26\xd0\x8e\x62\x97\xf3\x80\x76\x0c\x99\x63\xc8\x1c\x83\xc7\x2f\x88\xf9\x0b\xfc\x65\xdf\xaf\x1d\x27\xe6\xe3\x70\x7a\x1c\x99\x2f\xb9\xfe\x92\xd8\xbf\x24\xf7\x5f\x71\xfd\x15\xf5\xf0\x15\x79\x38\x01\xef\x27\x58\x07\x4f\x60\xff\x24\x39\x3f\x49\x1c\x27\xf1\xfd\x6b\x6a\xf1\x6b\xb8\xfd\x86\x18\xbe\x81\x9b\x6f\xe0\xec\x14\x7e\x9f\x22\x7f\xec\xd5\xb5\xd3\xf0\x74\x9a\x5c\x9f\xc6\x2f\xf6\xe6\xda\xb7\xe8\xfe\x16\x4e\xcf\x70\x7d\x06\xfe\xcf\x60\xff\x2c\x3a\xce\xc2\xc9\x77\xd4\xe6\x77\xc4\xf8\x1d\xb9\x3b\x47\xee\xce\xc1\xef\x39\x7c\x3d\x4f\x3c\xe7\xb9\x66\xcf\xad\x15\x51\x0f\x45\xe4\x99\x7d\xb6\x76\x01\xff\xd8\x5f\x6b\x17\xb8\xbe\x08\x47\x17\xe1\xec\x22\xfe\x7d\x8f\x7f\xdf\xc3\xcf\x25\xc6\x5d\xc2\xff\x4b\xe8\xb8\x0c\x57\x97\xe1\xe4\x32\x3c\x5e\x61\xdc\x15\xfc\xbf\x82\xed\x1f\xf0\xe3\x07\x62\xff\x81\xeb\xab\x8c\xbb\x4a\x3d\x5e\xc3\xe7\x6b\xc4\x72\x0d\x7d\x3f\xe2\xd3\x8f\xd8\xfe\x11\xff\x7f\x82\xbf\x9f\xb0\xcd\xde\x57\xfb\x99\x18\x7f\x26\xe7\x3f\x13\xcb\x75\x6c\x5f\x27\xae\xeb\xf0\xf1\x0b\xfe\xff\x02\x1f\xbf\xc2\xc7\xaf\xe8\xf8\x15\x7d\xbf\x61\xfb\x37\x64\xd9\xc7\x6a\xbf\x73\xcd\x1e\x56\xfb\x9d\xdc\xfc\x81\x7f\x7f\xd0\xff\x07\x3e\xdd\x40\xdf\x0d\xec\xb0\x5f\xd5\x6e\x92\xb3\x9b\xc4\x75\x13\x7d\xb7\xf0\xf5\x16\x32\xb7\x90\xb9\xcd\x7c\xbd\x8d\x9d\xdb\xf8\xea\x25\x1f\x5e\xfc\xf6\x12\xbb\x41\xbf\x41\x2e\x8d\xcb\xa2\xb3\xff\xd4\x65\x11\xb8\x2e\xba\xd2\x05\x6c\x01\xb7\x44\x57\x7b\x82\x9d\xa2\x6b\xd9\xa2\xeb\xe5\xc1\x70\x70\x5a\x74\x1b\xfd\xb6\xbd\xa2\xdb\x23\xc1\x00\x80\xbc\x43\x07\x05\x80\x71\x01\x13\x00\xba\x4a\xb4\x00\xe8\x2d\xf1\x9d\xe8\x81\xb5\xc0\x06\xd1\x4b\xa2\xa7\xe4\x0a\xd1\x83\x18\x1b\xc4\xd8\x20\xc6\x06\x33\x36\x18\xbb\xc1\x87\x45\x0f\x69\x0b\x3e\x14\x3d\x94\xb1\xa1\xd7\x44\x0f\x5b\x2d\x7a\x29\xfc\x2b\x75\x52\xf4\xf0\x39\xa2\x47\x70\x1d\xc1\x75\xe4\x64\xe0\x11\xbd\xf4\x68\xd1\xa3\x82\xc0\x01\xd1\xa3\xb1\x11\x8d\x8f\xd1\x8c\x8b\x79\x51\xf4\x32\xd8\x28\xb3\x54\xf4\xb2\xf5\x00\xf2\xb1\x3c\x8f\x3d\x22\x7a\xb9\xea\x00\x5d\x71\x01\x80\xfb\x78\xfc\x88\xc7\x5f\x27\xfe\xbb\xf0\xcf\x85\xac\x0b\x5f\x12\x32\x01\xf1\x26\x32\x3e\x71\xbe\xe8\xec\x9f\x74\xf6\x4d\x7a\x12\xb2\xe5\xd1\x55\x9e\x71\xe5\x91\x2d\x8f\x8f\xe5\xd1\x53\x1e\x2e\x93\x89\x25\xb9\x1c\xa8\x0c\x88\x29\x85\x38\x52\x8e\x8b\x5e\x01\xdd\x15\xe9\xaf\x58\x68\xfe\x3b\x3a\xa2\x8a\xf9\x21\x60\xb2\x6d\x1a\x3b\x7e\x87\xdc\xe7\x8e\x54\x74\x3d\xa0\x84\x28\x4a\x98\xa6\xd8\xdc\xba\x6d\x65\x0f\x5d\xd5\x24\xbd\x5a\xaa\x94\x8d\x09\xfb\xa4\x4f\xef\x5e\xa5\xc2\x95\xfa\xa5\xd2\x6a\x54\x57\x92\x22\xd2\x94\xba\x69\x0e\xa5\xf5\xa2\x0d\x7b\xbd\x15\x2b\xbe\x57\x51\x99\xab\x5d\xbf\x31\x75\xff\x7e\x74\xbe\xa5\x7d\xa0\x25\xf9\x75\x26\xb8\x43\x74\x9b\x22\x36\x09\x28\x61\x93\x02\xbb\xa9\x2d\xad\xec\xc1\x9a\xa6\x1e\x14\xdd\x51\x05\xd4\xed\x4f\xb9\x0b\xbd\xc9\x73\xd3\x0b\xb5\x0f\x94\xb7\xbc\x2d\x95\xb7\xcc\xbf\xbf\x59\x41\x44\x9f\x69\x9b\x28\xb1\xe2\x94\x63\xee\xe9\x65\xa2\xc4\xa9\xc4\xeb\x0e\x47\xbc\x33\x4a\xb7\xc7\x44\x47\xdb\xec\xa5\xc3\xcb\x85\xc6\x85\x04\x94\x2c\x19\x12\x1a\xae\x07\x46\x46\x44\x94\x08\xb4\x07\x26\xb8\x02\x1c\x7a\xc9\x90\x92\x6f\xe4\xc4\xc7\x29\x21\xce\x72\x12\x1a\x1e\xfa\x46\x4e\x99\xa8\xd2\xe1\xce\x90\x3e\x21\x6a\x68\x88\xd9\x8c\x0a\xd1\x83\x42\xc3\x3b\x84\xab\x0d\x4e\x85\x5f\x0d\x57\xab\x85\xa7\x73\x33\x2f\xfc\x54\xb8\xcd\xbc\x78\x23\x5c\x0b\x77\x57\x4f\x6b\x15\x12\x1e\x12\x6e\x8b\x89\x8e\x8c\xb0\x07\x96\xb0\x73\x7e\x49\x4f\x4b\x4b\x33\x11\x5e\xbf\x7e\xb5\x6a\xa9\xbd\xc6\x8c\xed\xdd\xab\x77\xaf\x31\xa5\xe8\x49\x2d\x25\xfc\xbe\xeb\xca\x17\x24\x3d\xe1\xd1\x56\xb0\xbe\xff\xfd\xf5\x1e\x02\xb4\x84\xd2\x09\x5a\x52\x84\x89\xa4\xda\x69\x20\x21\x22\x4d\x33\x91\x46\x7f\x42\x84\xf6\x5c\x7b\x45\xf7\x9e\xcb\x1e\xd9\xd5\xbb\xb8\xcb\xc8\x2e\xfb\xbf\x6d\x7f\x4b\x09\xcf\x19\x99\xad\x0c\xcb\x1e\x99\xfd\xf9\x6d\x77\xa6\x32\xb4\xbd\x36\xce\x3b\x6f\xb8\x77\x88\xb2\xd4\xc4\x70\x65\xcc\x70\xdf\x95\x77\xc8\x70\xef\x3c\x65\x0c\xf3\xeb\xba\x91\xaf\x3f\x6d\xbb\x2c\x89\x52\x51\xaa\xc9\x36\xf7\x83\x95\xc2\x2b\x04\xa7\x84\xb8\x2a\x3b\xab\x94\x89\x8a\xaa\x52\x39\x24\xd8\x66\xd2\x69\xd7\x35\xcd\x66\x97\xa4\x24\x7b\xb8\x56\x22\xae\x5c\xb9\x1a\x25\xaa\x3b\xab\x44\x55\xc9\xcb\x49\x71\x85\x54\xce\xaf\x3c\xa3\xb2\x5a\x29\xbc\xb2\x4b\x92\xec\xf6\xa8\xd0\xb8\x51\x71\x6a\x09\x2d\x2e\xae\x4c\x54\x74\x74\x94\xbb\x44\x58\xab\xa8\x0a\xc1\xf6\xe0\xbc\x1c\x09\xcc\x0c\xec\x1b\xa8\x05\x06\xda\x6d\x36\xcd\x6e\x11\x56\xad\x54\x5a\xb5\x5e\x26\x29\x31\xd5\x52\xcd\x9b\xb4\x6a\x56\x2d\x45\xd7\xef\x65\x52\x60\x3e\x28\xa5\x58\x6c\xf8\x89\xf1\x73\xf3\x17\xda\x2c\xaa\x22\x75\x9b\x23\xa9\x6e\x55\xa5\x42\xdd\x78\x25\x3a\xa2\xaa\x5a\xbb\x56\x13\x25\x5d\x49\x73\x70\xe7\x48\xa9\xa0\xc5\x2b\x8e\x5a\x34\xe5\x95\xc8\xa8\xe8\x88\x10\x45\xaf\xee\xbd\xe2\x35\x9c\x63\x5d\xfb\x3f\x8f\x7d\xa1\xcc\x82\xc7\xfb\x2e\x5e\xd0\x76\xfa\xc5\x85\x65\xc6\xc6\xae\xd8\x5e\x76\x45\x95\xdd\x5d\xf7\xee\xd8\x3e\x70\x6a\x77\xa5\xc9\xed\xeb\xdd\xa7\x75\x5c\xb0\x5c\x79\x65\xfb\xe7\x01\x6b\x5e\x08\xd9\xb2\x2a\x39\xef\xa1\x40\xe5\x4a\xa5\x1e\xd3\x7a\x8f\x5e\x9b\xa3\x3c\xfa\x44\xc4\x92\x87\xab\xbc\x1c\xeb\xbd\xbf\x76\xe1\x82\xf6\x03\x2b\x7a\x6b\x94\xd2\xdc\xcd\xbb\x56\x54\x56\xd9\xc6\x52\xda\x4f\x1b\xd7\xed\xef\xdb\xe6\x52\xef\xe1\x54\x69\x55\x69\x28\xdd\xdc\xb5\x63\x42\x45\x89\x77\xd4\x4a\x55\xb5\x06\x49\x49\x5a\xaa\x43\x09\xb5\x37\x6a\xec\xaa\xb6\x35\xa7\xa2\xab\xb0\x47\xc5\x3a\xb4\x65\x82\xca\x6e\xcd\xd1\x83\x0a\x7b\xe8\x11\xb4\x0e\xd5\x2e\x70\x95\x9e\x6e\xfe\x91\xf9\x18\xf3\x37\xe5\x73\x6f\xfc\x09\x49\x4a\x5a\x72\xcd\xa8\xd2\x91\x21\x6a\x52\x62\x4a\xed\x5a\xe1\x75\xa2\x13\x43\xd4\xd2\x91\x69\x35\xeb\x84\xd7\xae\xa5\xfc\xf3\x93\x57\xd6\xea\xcf\xbf\x7c\xf3\xc8\x23\x8f\xd7\x19\xb9\x20\x67\xf2\xac\x5e\x9e\x69\xcd\xbb\xba\x53\xa7\x64\x8d\x6c\xa4\x55\xfa\x9b\x4e\xdb\xb4\xa0\xe7\x96\x0c\x2d\x7a\x39\x6b\xed\xd2\x85\x4a\xdc\xa2\xe1\x4d\x1e\x3b\xd6\xee\x9d\xc7\x95\x80\xbe\x5b\xbd\x5d\xfe\xe1\x01\xd1\x27\x18\x97\xf5\x0b\xb6\x27\x24\x59\xaa\x4b\x63\x19\xe3\x6e\x1a\x99\x9a\xe6\xaa\x18\x94\xa8\x06\x24\x57\xad\x5a\xaa\x46\x54\xbd\x72\xc9\x22\xe5\xa2\x4a\xe9\x4d\xd2\x5d\xa9\x89\x15\x55\x5b\x4a\x64\x5a\x99\xe4\xe4\x94\x32\x65\x1a\x76\xcc\xd9\x55\x46\x09\x2d\x93\x5e\x86\x8a\x2a\x13\x64\x4b\x09\x49\xe9\x98\x13\x18\x12\x45\xed\x58\x53\x29\xc6\xac\x97\x31\x30\x22\xf5\x63\xaa\x31\xf1\xcc\xc2\xf8\x0b\x3b\x74\x50\x1d\x2a\x75\x90\x56\xb3\xae\xc3\x9e\x94\x58\xc1\x6e\xd1\x50\xa7\xae\xf9\x2b\xcd\x24\xc6\x1e\xaa\x44\x45\x37\x51\xea\x2a\x35\xcd\xfa\x09\x51\x4a\x47\x46\x45\x44\x46\x37\xd1\x6a\xd7\x4a\x49\x4a\xb4\xeb\xa7\x9f\x5c\x5a\x71\x60\xd5\x46\xb5\x82\x1b\x35\x5d\x3c\x69\xd3\xb9\xb7\xbf\xda\xf1\x73\xb9\x2f\xb7\xce\x7e\xed\x85\xcf\x1e\x69\xfb\x54\xa3\xb1\xed\x6f\x0f\x79\x61\x76\xeb\xc7\x2b\xaf\x7b\xf4\x89\x5b\x11\x1d\x66\x0f\x6e\xd8\xa3\xf5\xe8\x49\xea\x06\xef\xfb\x6b\x52\x2a\x85\xcd\x8c\x9a\x34\x7d\xff\xfa\x95\x07\x7b\x8d\x1f\xf5\xda\xe1\xf9\x0f\xe5\x6f\xe8\x5c\xf3\xf4\x9e\x16\x3b\xd7\xdd\x9e\x33\xb0\xfb\x2f\x05\xcd\x16\x8c\x1c\x35\x43\x7b\xbe\xfd\x80\xb8\x5a\xee\x4e\x0d\x9a\x76\x9e\x69\xfe\xbd\xf3\x8f\x58\xe4\x76\x5b\x6b\x64\xb4\xdb\x5c\x70\x75\x56\x47\x73\x71\x2c\x7b\xf0\x2f\x4b\x6c\x37\xff\x72\x28\xe6\x98\xbe\xde\x6c\xad\x9b\xed\x80\x04\x0a\xd3\x4d\x75\x38\x4a\x06\xe9\xb1\x3c\x48\x4f\xbf\x33\x44\x4a\x85\x45\x24\xa9\xa5\xc2\x24\x59\xeb\x76\xfb\x9d\x43\xaf\x1f\x53\x2a\x2b\x71\xb6\x03\x5e\xed\x76\x5d\xef\xc3\xde\x2f\x94\x8a\xca\x12\x25\x5f\x1d\x74\xd2\xfc\xd3\xe5\x8a\x51\xdf\x9b\xad\x56\xff\xab\x3e\x61\xa1\xfd\x53\x9f\x86\x3e\x2d\x2d\x1c\x7d\xb6\x7d\x6a\x33\xd4\x79\x8f\x78\xcf\x7a\xb3\x95\xdb\xea\x7e\xe5\x31\xa5\x92\xf7\xb8\x77\xa8\x77\xce\xed\x67\x4f\xe2\xdb\x04\x75\x93\xd6\x85\x78\x42\xa4\xa9\x3b\x25\x30\x54\x55\xc3\xb4\x12\x12\xa4\x04\x95\xb0\x6b\x25\x4b\x3a\x3a\xd8\xfa\xd8\xa6\xda\xe6\xd9\x74\x9b\x3b\xaa\x4c\x2b\xb1\x29\xb6\x5d\xc1\x56\xb0\xbd\x52\x7b\xd5\xac\x5f\x2d\xba\xbe\x2f\x8b\xac\x01\xe1\x66\x1e\x93\xa3\x6d\xd1\x8e\x92\x4c\xf2\xe4\xba\x36\x2d\x4d\x75\x2a\x01\x55\xbc\xe7\xb7\x8f\x5f\xb2\x62\xfc\xdb\xde\x0b\x55\x94\x92\x41\xb3\xf4\xee\x83\x67\xb4\xbe\xd1\x4a\x51\x0d\x69\xf5\x7b\xeb\xc7\x87\x29\x95\xf0\x61\xba\x6c\xd1\x07\xea\xcf\x49\x49\x69\xee\x4e\x29\x61\xb7\x8b\xa6\x05\x07\xbd\xa2\x2a\x5a\xa8\xda\x47\x55\x83\xec\x2a\xfb\x05\xfd\xb5\x9c\x12\xc7\x1c\x4a\x5d\xc7\x4c\x87\xea\xb0\x6d\xa6\xc0\x7a\xf5\xf2\xd5\x18\x15\xd6\xc7\xff\x7e\xf3\xad\x35\xa5\x92\x4a\x25\xd4\x4e\xc0\xad\x84\xd2\xea\xdb\x0b\x09\x7b\xdd\x42\x65\x9d\xda\xd7\xdb\x45\xd9\xf0\xb4\xb2\xc1\xdb\xe5\x69\x33\x27\xc9\xde\x1b\x4a\x1b\x39\x21\x25\xa4\xbc\x3b\xdc\xae\xd9\x44\xb1\x29\x25\x03\x6d\xb2\xae\x87\x6e\x5b\xde\x43\x97\x6a\xd6\x3c\xf6\xbd\xeb\x50\x1a\x91\x54\xa7\x6e\x12\xef\xcd\x10\x65\xf5\xc3\x13\xca\x64\xdf\xb7\xc7\x15\xde\xcc\x7b\xe3\x89\x47\x4e\xac\xeb\xb3\xc4\xca\xf1\x83\xca\x61\x75\xb2\xca\x0e\x54\x9c\xee\x52\x9a\xd8\x74\x45\xde\xca\x59\xa5\x1c\x52\xd4\x6a\x8a\xa2\x48\x35\x6b\x16\xa0\x0f\x55\x75\x13\x1c\x0f\x3a\x95\xeb\x4e\xe5\xf0\xea\xd5\xd6\xd8\x4c\x7e\x35\xc1\x17\xb3\xa6\x02\x35\xf3\xbf\x2f\x2a\xca\xf2\x1e\x82\x0f\xc5\x09\x4d\xc3\x74\x66\xea\x9e\xd4\x13\x27\xcc\xfc\xcf\x31\x2e\xab\x17\xc9\x3f\x69\xde\xaa\xb1\xd7\x12\x89\x32\x93\xcf\x14\xaa\x51\xdd\xa1\xa4\x51\x29\xef\x3e\x77\xbb\x45\xa4\xed\x34\x3b\x3c\xf3\x5d\x9c\xc3\xfc\xee\x67\x5b\x42\x8e\xcb\x49\x45\x77\x64\xd9\xc0\xc0\xb8\x08\x4d\x8b\x77\x84\xe6\xe5\x38\xca\x48\x14\x2b\xbf\x43\xd2\xad\xc5\xcb\x5a\xcd\xc3\x7d\x35\xc9\xdc\x0b\x53\xf5\xa4\x44\xd6\xea\xb2\x4a\x1d\xcd\x5a\x8f\xcc\x19\xc7\xe2\x14\xa5\x9e\xdc\x76\x68\x85\xf7\xcc\x81\x37\x3f\xc9\x59\x75\xa9\xe3\x33\xef\x8e\x1d\x3f\xdc\xfc\x65\x5b\xf2\xeb\x49\x43\xbc\x09\x7f\x28\xea\xd9\x2d\x4a\xbe\x12\x36\xf7\xc6\xc5\x23\xca\xbb\x6f\x2d\x5f\x71\xc4\xdb\xf4\x2d\xf3\xcf\x9d\x98\xff\x0d\x28\xed\x03\xea\x2d\x50\x6a\xb9\xcb\x05\xa8\x6a\xc9\xa0\x00\x35\x50\xcd\xcf\x09\x8c\xb1\xad\xd2\x95\x4a\x7a\x7d\x5d\xd5\x75\x87\x46\x11\x98\xef\xea\x6a\x24\x39\xdd\x7a\xcd\xdc\x21\x22\x21\xc2\x56\x37\x99\xd7\xac\xa3\x76\xbc\x32\xf8\xb0\xf7\x99\x24\x65\xe2\x4b\xd7\x95\x6e\xf1\xcb\xf4\xaa\xa7\xb6\x9c\xbb\x19\xb3\xcc\x37\x47\xae\xb3\xff\xc8\x22\x66\x97\xb4\x75\x57\x8a\x97\xc0\xe8\xb0\x52\xa5\xa2\x9d\x5a\xa2\x48\x42\x68\x98\x12\x1a\xe6\x0c\x53\x43\xb4\xb0\xb0\xc8\x48\x5e\x7c\x91\x0e\x25\x5e\xe2\xf3\x73\xcc\x75\xdc\x7a\xd9\xf9\x7e\x5b\x6b\x97\x55\xdb\xc5\x0b\x56\x8d\xea\x49\x75\x9b\x38\x7c\x34\x38\x2a\x34\x51\xac\xf5\x29\x44\xa1\x2a\x1c\x09\x8e\xa0\x98\xba\xb3\x16\x2d\x9b\xf7\x48\xef\x3a\x8f\x0c\x1d\xf1\x7c\xf2\xfa\x3a\xbf\xbf\xb5\xf5\xec\xa0\x83\x9f\x2c\x7c\xb3\xaa\xfa\x45\xdc\xd4\x5e\x4f\x8f\xef\xd7\xa3\xfb\xa0\x89\x6d\xfb\x4d\x1c\x3f\x3e\x79\xfd\xe6\xbd\x2b\x86\xbe\xb7\x69\x7a\xaf\xa5\xad\x96\x59\x35\x50\x9d\x1c\xe5\xe2\x6f\xaa\x14\xb8\x33\x53\xa2\x4b\x04\xba\x9c\xce\xc0\xfb\x22\xa2\x6d\x95\xf1\xb2\x4a\x44\xea\x7d\xa9\xf7\xe5\xe7\xa4\xa6\xc6\x06\xc7\x26\x91\x2f\x57\x98\xcb\xed\xca\x74\xe9\xe6\x85\x8b\x8b\xd5\x2e\x8f\xeb\x9a\xcb\x11\xec\x72\xc5\x96\x09\x2d\xa1\x84\x96\x70\x96\x20\xbc\x12\x25\x82\x83\xed\x79\x39\xc1\x0e\xb9\x2b\xa0\xf4\xb4\x6a\x7f\x2e\xc9\x56\xe3\x4b\xfa\x9f\x31\x2a\x35\xeb\x14\x87\x58\xa7\x7c\xf1\x12\x1c\xaf\x98\x91\x26\x25\xfa\x5e\xe1\x69\x96\x48\xaa\x52\x57\xad\xb3\xed\xcd\x89\x03\xc7\xbf\x9a\xb8\xa9\x81\x52\xf2\xad\xb7\x8e\xef\x7e\x43\x79\xf4\xe9\x89\xe7\x96\x15\xec\x9d\x56\xe6\xc5\x78\xcf\xc3\x73\x57\x2d\x99\x36\x39\x5e\x8b\x7d\x7a\x4e\xaf\xe1\x93\x46\x85\xec\x78\xb3\x70\xf5\xb2\xdd\xd1\x7a\xd9\x95\x0f\x3f\xb2\x67\x58\xf6\x9a\x11\xd5\xf3\xe7\x2e\x9e\x32\xfa\xe1\x15\x56\x9d\x06\x93\xb3\x14\xab\x36\x82\x25\xd3\x5d\x21\x48\x0f\x2e\xc9\xea\x66\xb7\xab\x01\x8a\xa2\xea\x6a\x48\x28\xc5\x1e\xa4\x13\x50\x80\xad\xa4\x3d\x28\x48\x31\x1f\x29\xe6\x3e\x25\x9d\x9a\xe5\xf5\x52\xbc\x81\xbb\x33\x71\x7d\xaf\x98\xfa\xbe\x7a\x36\x77\x6a\x75\x15\x36\x67\x0e\x4d\x49\xd0\xda\x37\xd9\xd2\xe4\x76\x5e\xac\x96\xb6\xaf\x70\x67\xb9\xc3\xb7\x5f\x51\x3e\x57\xd2\xbd\xbb\x95\xf4\x39\xda\xd6\x5b\x6d\x9f\xd2\x32\x6e\x5b\xff\x00\xa4\x22\x55\xc9\xcb\x04\x7c\x2a\x27\xbd\xdd\x35\xa3\x98\x9d\x7a\xb9\xb0\xd0\xd0\x72\x12\xa8\x2b\x71\x4a\x7c\xb9\x72\x0e\x47\x99\x3c\x36\x01\x8e\x60\x09\x8e\x20\x31\x61\x61\xbe\xba\x0a\x2e\x23\x1a\x05\x65\xf7\xcd\x2b\x6b\xdb\xe4\xa7\x3c\xcd\x97\x8a\xbf\xd4\x95\xe5\x5f\x82\x23\x41\xf3\x97\x94\x24\xb8\xb4\x3b\x2c\x27\x25\x3a\x92\x94\x6e\x5a\x42\xdc\xed\x47\xc7\xd6\x9c\xdf\xb9\xf0\x8c\xf7\xb4\xd7\xeb\x9d\x9b\xfd\x82\xf3\xb9\x71\x2f\x6d\x99\x9d\xff\xc2\x78\x8f\x6d\xda\x32\x6f\xd3\xfb\xaa\x1f\xdd\xf2\xab\xf7\x82\xd2\x3a\x75\xec\xa8\xb7\x36\x4c\x9a\x3f\xd0\xe2\x34\x0f\xff\xf3\xa8\xab\xb2\xec\xc8\x3b\xb8\xef\x4b\x88\x8e\x2d\xa5\x45\x6b\x15\x4b\x06\x06\x56\x8a\x2c\x9f\x97\x53\x2a\xb4\xa4\xb3\x24\xef\xee\xc8\x92\x91\x25\xc5\xe1\x08\x61\x45\x70\x48\x3c\x81\x94\x29\x5e\x11\x70\x1a\xaf\xcd\x00\xd2\x8a\x97\x87\xe2\x95\xd6\x66\xae\x0d\xe1\x66\x89\x44\x3b\xaa\x52\x1b\x6a\xb1\xff\xaa\x9d\x8d\x5c\xb1\xf7\x21\x8a\x1a\xb5\xfb\xcc\xcb\x4a\xe2\xdb\x4b\x76\x27\xbd\x54\x66\x6c\xc7\x17\xcf\xd7\x6a\xb4\x6d\xcc\x86\x23\x8f\x5d\xf2\x4e\x9c\x35\xf6\xc9\xc2\xf1\xa3\x7b\xad\xec\x19\xa9\x04\x1d\xff\x51\xf9\xc2\x3b\x6f\x56\xf9\x8e\xd9\xde\x93\xde\x5f\xbb\xf7\xf9\x6c\xdd\x52\xaf\x31\x5f\xd9\xfe\xe8\xda\x6f\x37\xe4\xcd\xcc\x5a\x61\xe5\xe3\x08\x35\xb2\xc9\x7a\x5f\x71\xea\xe1\xfd\x6b\x0f\xb5\x05\x04\x84\x95\xb0\x3b\xec\xf9\x39\x0e\xbb\x62\x4e\xe1\x9a\xe9\x77\x36\xa6\xfe\xdc\x27\x24\xd5\x29\xab\x28\x09\x2c\xbc\x24\x47\xd9\xbc\xb3\xd2\xcb\x7f\x28\x65\x6f\xdd\x88\xd3\x76\x97\x3b\xb5\x7e\xd6\xd0\x0e\x07\x94\xd1\xca\x50\xa5\xd9\xb2\xa7\xbd\x37\x4e\x1e\x3e\x6a\xfe\xb5\x2d\xa9\x03\x6f\x83\x6d\x8b\xe1\x21\x59\x6a\x48\x17\x77\xe5\x38\xad\x5a\x60\x52\x74\xa5\xb0\xb0\xe8\x48\x7b\xa0\xad\x66\x9c\xa6\xa5\xd9\x23\x22\xca\xa6\x94\x4d\xc9\xcb\x29\x5b\x96\xf4\x57\xa6\x30\xcb\x88\xeb\xee\xd5\xf4\xae\x39\x96\xf6\xd7\x59\x56\xbc\xc2\x16\x4f\x2d\xdd\xbf\xeb\xa9\x5d\x55\xa9\x5d\xab\x7c\x44\xf1\x0c\x64\xa9\x8d\xb6\x7e\xfb\xc8\x54\x77\xbd\x7b\xe1\xb5\x85\xca\xc8\x71\xde\xef\xfe\x38\x7a\x71\xeb\x1b\x3d\x06\x28\xfa\xa6\xc7\x17\x3f\x3a\xf5\xb1\x25\x4f\xc4\xad\x78\x75\xd1\x8c\x45\xdb\x96\xd9\x16\x6f\x5b\x3e\x67\x6f\x94\x9e\xf0\xec\xc8\xc3\xd7\x3f\xda\xb4\xe4\x50\x05\x3d\xe5\x99\xc1\x1b\x3f\xbc\xbd\x64\xde\x63\xfd\x46\x3c\x3e\x75\xf0\xf8\x27\x5f\x5a\x32\x7a\xea\x86\x85\xa3\x1e\x31\xeb\x23\x83\x38\x5b\x53\x1f\xb1\x9c\x2f\x3a\xba\x2b\x97\x93\xe0\x44\x7b\x54\xe9\xd2\xf6\x60\xed\xbe\x4a\x6a\x32\xc1\xa8\x12\x15\x16\x45\x85\x44\xa9\x51\x6a\x44\x60\x04\xd5\x1e\x51\x26\xd0\x99\x97\x13\xe8\xf8\xcf\x0a\x31\x8f\x04\x7f\x6e\xef\xcc\x10\xed\xe6\x8a\x61\x6e\xf6\x7d\x75\xc1\x26\xd7\x5f\xd9\xe1\x11\xc5\x01\xa6\xd5\x6c\xa2\x68\xd3\x1f\x3f\xf8\xd0\x96\x7e\x33\xae\x2e\xda\x7b\xa2\xcd\x94\xd5\x3b\x72\xbd\x07\xda\x3c\x17\xf3\x50\x8f\xe7\x4e\x75\x9e\x3d\x62\x51\xe1\x94\xe1\xbd\xd7\x76\x55\x37\x7c\x3c\xb8\x70\xcc\xd2\xdb\xf3\xbd\x27\x96\x7b\xdf\xb8\xb1\xe6\x01\xa5\x74\x95\xac\x9e\x4a\x82\xda\x63\xe2\xd3\xc7\xdf\x9e\xf4\xf8\x20\xf3\x1f\xc3\x94\x8e\x14\x49\x91\xde\xc0\x3a\xc3\x56\x70\x47\xd0\x70\xa2\x2e\x11\xa0\xdb\x56\xf4\xe0\x45\xb9\xa2\x87\x12\x6a\xb9\x5d\x2d\xf5\xae\x93\x6c\x84\x79\x20\x06\x37\x2b\xed\xa9\xe4\x5d\xc8\x2f\x6d\xd8\xa1\x43\xb7\x16\x1f\x3a\x84\xbe\x14\xf6\x09\xd7\xd1\x57\x82\x35\xa9\x8e\x3b\x2e\x38\xd0\xdc\x2a\xd8\xd9\x08\x05\x6a\xa1\x21\x25\x03\x57\xf4\x28\x19\xfa\x97\x4d\x83\x8f\x11\xe5\xee\x3c\xff\xb9\x77\x30\x0d\xad\x31\xf7\x0f\x15\xf7\xc4\x87\x37\xab\x51\x71\x4f\x45\x73\x0f\x71\x68\x45\x9f\x25\x7a\x95\x43\x87\xac\xfa\x7e\xd4\xfc\x2f\x21\xeb\xeb\xcd\x95\xc3\x5d\x81\x79\x24\xba\x5d\x0f\x70\xa4\xdb\xa7\xda\xe7\xd9\x35\x7b\x75\x75\xb4\xca\x76\x53\x55\x24\x54\x4f\xd7\x47\xe9\xab\xf4\x43\x6c\x8d\xa4\x4c\xb5\x5e\x69\x69\x07\x7b\x1d\xec\xf5\xe7\xc9\x15\xb3\xb5\x95\xd2\x25\x94\xd2\x8f\x6a\x67\x6f\xbd\xa4\x75\x57\x1b\x1e\x54\x9e\x7f\xd6\xfb\xb4\x77\xc1\x32\x6b\x5d\x98\xae\x64\xeb\x03\xcd\x6f\xfb\xe0\xa9\x85\xbb\x92\xe6\x30\x3f\x83\x29\x11\x60\xee\xb3\x42\x6d\x4e\x9b\xb9\xf1\x3b\x64\x23\x48\x9b\xe2\x56\xe4\xb5\x9c\x4c\xe5\xb0\xa2\x86\xfa\x76\x32\xbd\xee\x7c\xaa\xf0\x17\x12\x6b\x27\x94\x56\xc0\x74\xec\xc5\x69\x67\xb5\xec\x45\x8b\xbc\xb2\x68\xd1\x7f\xc4\x64\xb7\xa9\xba\xf9\x6f\xe9\x3a\xec\xb6\xea\xfa\x68\xbd\x40\xd7\xf4\x74\x99\x2a\xf3\xf0\x24\x54\x4d\x57\x47\xa9\xab\xd4\x43\xaa\x4d\x35\x63\x32\x23\xba\x6b\x35\xc7\x48\xdd\xda\x25\x94\xda\x66\x4c\xdd\x89\xe9\xec\xb3\xcb\x94\x51\xca\xc8\x67\xbd\xbd\xcd\x7f\x6c\x03\x9d\xab\x58\x1b\x46\x50\xcb\x71\x92\x20\x5d\xdd\xd5\x23\xb5\x92\x41\x09\xf1\xb1\xf1\x41\x1a\xb3\x2b\x52\x42\x83\x94\x52\x5a\x90\xd3\x1d\xef\x5c\xd9\x23\x3e\xb4\xac\xb3\x6c\xb5\xb2\x7d\xca\xea\xc1\x5a\xd9\xb2\x22\xd1\x6b\x72\x44\xbf\xeb\x2d\x79\xd7\x07\x27\x77\x1f\x58\xfc\x73\x36\x44\x35\xdf\xf8\x49\x4d\xd4\xba\x4d\xd4\x3f\xdf\x94\x1a\xc9\x55\xdf\x7e\xff\x52\xe3\xdc\x89\x8d\xa6\xf6\x0b\x79\x23\x38\xe3\xc1\xc7\x87\xf6\xac\xfa\x74\xfe\x9c\xad\x29\x6b\xd3\x95\x52\x7b\x2b\xec\xa9\x60\x5b\xf2\xe1\xca\xdc\x27\x06\x3e\x90\xd4\x6a\x74\x8b\xcc\xf1\xbd\xdb\x36\xea\x3c\x20\xbd\xdf\x84\x39\x93\x2a\xee\x79\xeb\xc6\x50\xeb\x33\x98\xf7\xbc\xe7\x1c\xf3\xd8\xdb\x35\x91\x76\xb2\xc7\x1d\x57\xa9\x6e\x46\xa8\x23\x36\x36\x3d\x3a\x26\x41\xa4\x7a\x4c\x68\x5d\x5b\xfb\x0e\x61\x1d\x14\x55\x3a\x28\xfd\x3b\x98\x7f\x93\xbd\x5b\xcf\x56\x56\xfb\x40\xa6\xaf\x6d\xd4\xdc\xd7\x56\xab\x6b\xb5\xee\xc6\x89\xf7\xb5\x0a\xed\xe0\xec\x70\xa8\xc3\xa9\x0e\x7a\x84\x16\xd7\x3a\xa8\xf5\xb1\x9c\x00\x3d\x28\x26\x3a\x3a\x22\xa2\xd9\xb1\x9c\xd2\x11\xa1\x41\xce\x20\xb5\xa4\x56\x2d\x28\x22\x22\xa8\x9a\x96\xd6\xb0\x61\xf2\xb1\x9c\x86\x92\x56\xe5\x58\x4e\xda\x89\x3f\xa7\x78\xb4\x39\xc5\x8b\xe7\xb8\xc9\x92\x99\x10\xf3\x4a\x31\xeb\xc0\xfc\xf1\x6d\xc3\xfd\x9f\x03\xdc\x75\xf2\x57\xad\x13\x5d\xdd\x24\x73\xf7\x60\x1d\x70\xd3\x6a\x46\xb3\x9f\xd5\xec\xe6\x21\xb7\x09\x8b\x83\x5a\x3e\x29\x51\x67\x57\x19\xae\xa7\xb9\x92\xa3\xed\x24\xab\xbc\x5a\x3b\x2c\x5c\x12\x6a\xea\xe1\x36\xdf\x1b\xc4\xb7\x4c\xa8\x8e\x79\x79\x07\xa7\x0e\x1c\xaa\xd9\x9b\xed\x19\xb3\xf2\xb5\x69\x17\xe6\x9e\xe8\x64\xaf\xb0\x22\x3f\xb9\x63\xe6\xcc\xf6\xcf\x7a\xbf\x79\xef\xa7\xff\x8f\xb1\x2f\x01\x8c\xa2\x4a\x1a\x7e\x47\xf7\xf4\xcc\xf4\xdc\xf7\x64\x32\x93\x39\x72\xcc\xe4\x60\x42\x86\x24\x84\x2b\x8d\x02\x0e\x02\x12\x6e\x46\x84\x80\x22\x88\x17\x37\x0a\x88\x80\x80\x22\x87\x80\x80\x07\xb7\x78\x81\x82\x20\x06\x0f\x56\x05\x6f\x59\xf1\x44\xdd\x75\x3d\x50\x97\x65\x57\x57\x45\x5d\x70\x75\xc9\x74\xfe\xf7\x5e\xf7\x1c\x89\xd9\xfd\xbf\xa0\x99\xc9\x4c\x75\x75\x75\xbd\x7a\xf5\xaa\xea\x55\xd5\x93\xd7\x7c\xb8\x1d\xc6\x5e\x87\x0d\x30\x5c\xbf\x41\xde\xff\xc4\x8f\xf2\xfd\x2f\xff\x06\x8f\x40\xdb\x4f\x70\xc2\x73\xe9\xdd\xcb\x6f\xbc\x7a\xfb\xe5\xcd\x57\x35\xdd\x7d\x63\x2f\xf4\xaf\x23\xf2\xc9\x87\xc6\x8d\x1a\xb0\x70\xe1\x89\xc3\x0f\xc1\x82\x47\x9e\xde\x25\x6b\x1e\x4a\x4d\x58\xf5\xf3\xc6\xa7\xa0\x73\xf3\xc7\xf2\x0d\xff\x79\x49\xfe\x64\xc7\xee\x19\x63\xc6\xbd\x08\xaf\x3c\x03\x3d\xf0\x8f\xa0\xed\xb0\xfc\xf4\xd7\x53\x16\x2d\x3e\xbd\xe4\xe6\x95\x63\xb7\xbe\x46\x65\x8e\xf6\x48\x25\xbe\xf3\x52\x32\x8b\x8c\x40\x92\x82\xa2\x81\xd8\xef\x82\x60\x36\x61\x8e\x23\x0b\x9f\x88\x9a\x53\x06\x51\xd4\x6a\x78\x8c\x89\x55\x0b\x6c\xa0\xd1\x5d\x43\x0c\xdb\x86\x78\x5e\xf0\x84\xda\xdb\xd4\x4a\x21\xeb\x14\x0e\xe1\x08\x4c\xe8\xa0\x89\xac\x56\x98\x2b\x19\x94\x5e\xfa\xe3\x7b\xb8\xe9\x13\x58\x2c\x8f\x36\x56\xcb\x4f\x20\xf3\x14\xb8\x4d\x9e\xcc\x2f\xfd\xcf\x62\xee\xa7\x82\xd1\xe9\x83\x28\x46\xd7\xaa\x46\xe2\x32\x58\x08\x0d\x46\xe0\x20\xb2\xdf\x24\x55\x98\xac\x4e\xaf\xce\xca\x39\x8d\x46\x4e\xa3\xe3\x8a\x02\x1a\xbf\xc9\xe4\x6f\x4e\x99\xfc\xf6\x81\x26\x13\x59\xaa\x9c\xcd\x29\xa3\x0d\x38\x9a\x53\xf4\xe2\xfc\xa5\x4a\x59\xab\xf2\xd4\x17\x73\xeb\x42\xd4\x15\xe0\xd9\x32\x15\x23\x84\x05\xad\xdd\x62\x10\x87\x94\x35\x2a\x04\x9b\xa0\xfc\xfe\x4f\xf2\xfe\x55\xf7\xc9\x6f\xca\xff\x4c\xef\x87\x57\xc0\x41\xf0\x2a\xf9\x9c\x7c\xf8\x4f\x70\xc6\x07\xaf\xec\xdc\x2c\xdf\xcd\x2f\xdd\xbf\x59\xfe\x6b\x4f\xf7\x83\xf3\x3e\xfa\x1a\x97\x43\xf4\xfc\x85\x27\x37\xde\x75\xdd\x0c\xa6\xef\x66\xb6\x7d\xc7\x7f\x40\xe6\x6c\x21\x48\x4a\x95\x26\x97\x00\x84\x80\x5f\xb4\x35\xa7\x8a\xcc\x71\x33\x32\x9b\x45\x0e\x14\x5a\x0a\x83\x85\x4d\x85\xeb\x0b\x77\x15\x6a\x0c\xb8\xb0\x10\x63\x6f\x73\x0a\xdb\xf3\x66\x6b\x23\x0b\x52\x29\x6a\xa2\x86\x2e\x3a\x8a\x08\x31\xd3\x84\x53\x4c\x13\x2a\x5f\x44\x84\x8a\xc9\xfc\xb9\x55\x3e\xf6\xe1\x61\xf9\xfc\xea\x0f\xe0\xdc\x33\x9f\xc0\x8a\xea\x96\xe2\x77\xef\x7d\x56\xfe\xc7\x3d\x7f\x79\x69\x13\x04\x57\xc2\x61\xcf\xef\xdd\x00\x0d\x07\x7f\x81\x77\x7d\x72\xf8\xa1\xfa\x19\xcb\x9f\x94\x8f\x7e\xf0\xe6\xdf\x69\xce\x1d\xe3\xf3\x0a\xc2\x67\x1d\xb0\x53\x3f\xca\x8c\xf5\x5a\xac\x75\x3a\x74\xf6\xe6\x94\x0e\x6b\xf5\xcd\x29\xad\x2d\xcb\xce\x5c\x98\x34\x08\xac\x0e\xe2\x47\x85\x28\xcb\x8a\x6d\xcc\x6c\x46\xff\x80\xdd\xe1\xd5\xef\xc8\x8b\xce\xcb\x00\x5a\x6b\x61\xe1\x2b\xb0\x7c\x67\xeb\x5f\x7f\xe6\x97\xca\xcf\xc8\xa7\xbe\x93\x77\x1c\xe7\x97\x5e\xf0\x6c\x85\x91\x97\x3f\x3d\x47\x7b\xa3\x90\xfb\x4e\x23\xf7\x15\xc1\x25\x52\x14\xe9\x00\x30\x1a\x78\x6d\x73\xea\x08\x0f\xef\xe4\xe1\xcd\x3c\x34\xf3\x50\x8b\x79\x9e\x46\x23\x9a\x53\x10\x03\x1d\x19\x58\x5b\xbb\x81\x25\x4c\x22\x3f\xaa\x3b\x49\x58\x94\x60\xd6\xa6\xf2\x3f\x51\x4d\x9c\x37\xd0\xfa\xc8\x58\x1c\x08\xb4\x7e\xdd\x8c\x97\x05\xf8\xa5\xdb\xe4\x5e\x5b\x64\xe7\x36\xf5\xde\x17\xb3\x67\x4e\x4a\x31\x88\x78\x5e\xa3\xd1\xea\xb5\x22\xbd\x93\x19\x36\xc2\xa1\x10\x8b\x18\x4a\x56\x7f\x12\x42\x9e\x98\x8e\xcd\x29\xe2\xbb\xf1\x36\x6a\x93\x67\x64\x8a\xad\x13\x50\x15\x73\x2a\xe5\x90\xdd\x38\x42\x48\x80\x3f\x4d\xc1\x85\x45\xad\xa7\x6f\x3c\x4a\x54\xf3\xbf\x02\xdc\xdf\xd2\xe7\x76\xa4\x5f\x23\xb7\x57\x6c\xef\xab\x89\x6c\x7c\x45\x64\xa3\x88\xac\x50\xc5\xde\x42\x1b\xc6\xfa\x82\x42\x2e\x14\x2c\x24\x02\x50\x58\x48\xcd\xd5\xe6\x94\x28\x92\x05\x9e\xc8\xb3\xc7\xef\x27\xa3\xd2\x58\x43\xd4\x13\x33\xb8\x73\xc6\x97\x2a\xcc\xc4\x5c\x25\x23\xd1\x89\x4c\xd4\x35\x52\xcb\x10\x6b\x38\x74\x46\x7e\x57\x3e\xf8\x01\x5c\xfa\xeb\x17\xb0\xb0\xfe\xa5\x92\x97\x37\x1f\x93\x4f\x6d\xf9\xee\x4f\xab\x5a\xc7\x27\xe4\x71\x41\x34\x6a\xf2\x1a\xf9\x15\x07\x19\x39\xef\x6f\xf0\xce\x3f\xed\x79\xa8\x6e\xf6\xec\x7d\xf2\x2b\xef\x9d\xfc\xfb\xd0\x21\xf2\x2e\xd9\x7a\xf3\x8d\x40\xe5\xd7\x71\x36\x56\x63\x24\xb7\x00\x75\x58\xa7\xd7\x13\x5d\x60\x34\xe8\x75\x18\x22\x81\xe8\x03\xad\xf0\x6c\xdb\x57\x92\xcb\x3e\x70\xbe\x70\xa7\x80\xcc\x02\xd4\x12\x1f\x87\xea\x07\x31\xab\x1f\x1a\x88\x8b\x36\xbe\x42\x51\xb4\x8d\xaa\xef\x5b\x93\x55\x12\x76\xa6\x24\x68\xa0\x19\xe2\xf4\xe2\x34\x5c\x7c\x14\xda\x8e\xce\x41\x6d\x73\x8e\xc8\x3f\xa0\xb5\xe9\xd9\xfc\xd2\xf4\x3e\x34\xf2\x3f\x8b\x19\x0f\x89\x3d\x84\xc2\x2c\x5e\x55\x2f\xe9\x00\xcf\x1d\xe4\x8f\xf1\x88\xa7\x2b\x44\x69\x79\x92\xbe\x4a\x66\x4f\x24\xd9\xc8\x43\x0b\x0f\x11\xc4\x8c\x04\x42\x01\x24\xf7\xaf\x18\xcf\xa6\x7f\x02\x26\xe0\x30\x72\x07\xf9\x07\xaa\x77\xa8\x6f\x7d\x81\xd8\x8c\x54\xdf\x58\x41\x5f\x29\x6c\xc0\xa2\xc9\xce\x61\x6c\x33\x9b\x80\x5e\x14\x4c\x22\xd1\x33\xc4\xa8\x68\x4e\x49\x5c\x13\xf5\xe5\xd9\xa8\x90\xf9\x99\x11\x46\x2a\x07\x4a\xcc\xb8\xc6\xda\x40\x7d\x88\x52\xd5\xa1\xac\xb7\xd3\x61\x20\x9a\x6f\xd1\xce\xe3\x05\x7b\xdc\x33\x26\x4f\xbb\x2d\xb0\x5d\xfe\x3c\x00\xbf\x7a\xa9\xe2\xb4\xe3\xc8\x93\xa1\xb9\xb7\x6c\xd8\x85\xab\xb6\xb5\x96\x7e\xf9\xa9\x22\x1f\x94\xd7\x0f\x10\x3a\x0c\xc4\x3e\x2f\xaf\x27\x4e\xa2\x28\xd2\x8c\x28\x01\x11\x4b\x89\xe7\x31\xf1\x15\x8d\x84\xfb\x26\x04\x05\x91\xa3\x7b\x00\x84\xc7\x9c\x81\x3d\x60\x4d\x9c\x6d\x05\xb8\x1b\xda\x79\x34\x8a\xab\x68\x55\xe2\x1f\x60\x7c\x08\x0a\x8c\xd1\xf5\x54\x23\x63\x59\x8e\xbe\x78\x2d\x91\xd3\xa3\x2b\xd7\xa0\xfb\xcf\xa7\x6d\xa8\x0a\xed\x5e\x9a\x3e\x45\x98\x3d\x64\x29\xaa\x49\xaf\x6a\x3d\x9f\xa1\x09\x9f\x26\x34\xf1\x20\x24\x99\x69\x2c\x47\x23\x10\xb6\x02\x9c\x9b\x92\x19\x83\x86\x71\x56\x99\x7f\x47\xff\x85\xde\x24\xb3\xee\x82\x6f\x5b\x06\x87\xe6\x31\x82\xc3\x0d\x23\x52\x0c\xb8\xdd\x2e\x41\x63\x77\xda\x21\x16\xec\xd0\x60\xb7\x38\x9d\x2e\x8b\xde\x68\x34\x9b\x4c\x1e\xec\x72\x79\x67\x78\xe1\x48\xef\x64\x2f\xf2\xd2\x31\x9d\x7f\x4b\x92\xbe\x4a\x17\xcf\xb9\x29\xb9\xde\x0b\x1d\xde\x7e\xde\x91\xde\x39\xde\xe5\x5e\x1e\x78\xe1\xb4\x1f\xbd\xb0\xd8\xdb\xcd\x4b\xc1\xe7\x78\x5f\xf5\x9e\xf6\x0a\x1f\x92\x5f\xe8\xa0\x17\x22\xc9\xdb\xe4\x9d\xe8\x5d\xef\xdd\xe5\xe5\xd7\x7b\x0f\x7a\xdf\xf3\x62\x86\x67\x44\x72\x50\xb2\xd9\x3b\xdd\x4b\xcc\xb1\xa0\x57\xf2\xe2\x06\x82\xe2\x80\x17\x56\x13\xd8\x19\xde\x25\x5e\x6e\x97\xf7\x98\xf7\x4b\x2f\x6e\xf4\xae\xf3\x22\x8b\x17\x9e\xf5\xc2\x63\x5e\xb8\xd8\xbb\xd3\x8b\xaa\x09\x38\x22\x8e\x04\x51\x92\x7a\x8b\x19\xdb\x35\x64\xb6\xba\x89\xe6\x32\xd9\xd8\xbe\x02\x91\xe6\x38\xdb\x8e\xa1\x82\x10\xa7\xe2\x36\x7e\xfc\xcc\x99\x33\x67\xcd\x9a\x45\x25\x7f\xfc\xcc\x66\xfa\x9e\x2a\xad\x8a\x8a\x99\x33\xad\x6a\x50\x2a\x91\x19\x25\x66\x6a\x24\x32\xb1\x75\x7b\x5d\xbd\x46\x80\x11\x5c\x5a\x66\x82\x74\xc0\xec\x2e\x77\x3d\x0c\x41\xee\xfb\x96\x62\xff\xb8\xba\xf4\x67\xb7\x3c\xa7\x89\xe8\xca\x9f\x7a\x0c\x5a\xbf\x7b\x41\xeb\xb9\x06\xc5\x20\x90\xcf\xe2\x5d\xcf\xcd\x7e\x61\x5c\xeb\x60\xdc\xe2\xbf\xd0\xab\xad\x75\x3a\xbf\xb4\x35\x5e\xf6\xc8\x47\xf8\xb8\x3a\x6f\xa8\x6c\xbd\xc9\xd6\xd4\xee\x52\x01\x20\x02\x24\x72\x3c\x6f\x30\x19\xcc\x64\x39\x17\xa0\x06\x1b\xb5\x64\xe1\xe7\xd5\x87\xa9\x61\xb1\xaa\x44\x46\xcb\xd5\xa8\x13\x15\x6a\x98\x00\x41\x22\xda\x64\xaa\x7e\x9a\xfe\xde\xe5\x38\x4c\xa8\xf8\x10\xb9\x0a\xec\x87\xf7\xc9\x67\xb9\x23\x8f\x4f\x6c\x1d\x46\xc6\xbd\xef\x0b\xcd\xf8\x41\x7a\x63\x04\xa6\xb7\x7d\xa7\x01\x44\xe7\x19\xa9\x47\x26\x39\xbc\xd8\xa6\xc7\x7a\x7f\xa1\x40\x54\x9c\x60\x07\x44\xe1\x31\x3b\xb5\x93\x35\x46\x0f\xb9\x88\xa2\xe0\xdc\xd9\xd5\x8e\xae\x36\xf8\x31\xe8\x84\x7d\xf9\x8f\xe5\x35\xdf\xc9\xa7\xe5\xd7\x4f\xc2\x05\x7f\x7b\x53\xfe\x66\xd3\x47\x6f\xbd\x06\x9d\xf7\x7f\xc2\xdf\x23\xbf\x2e\xff\x9b\xac\xd6\xf3\x3f\x84\x3d\xa1\xeb\x2c\xdc\xf0\xc9\x96\x43\xf2\x8e\xc3\xef\x7f\xba\x1f\x5e\xfe\xd2\xbb\x5f\x30\xbb\x9a\xf2\x62\x20\x8b\xcb\xd8\x08\x37\x0a\x45\x93\x56\xab\x33\x61\x1d\xb6\x3b\x04\x32\xdb\x05\x41\xab\xd7\x93\x15\x5b\x8f\x75\xda\x76\x8a\x3f\x17\x86\x61\x56\x44\x0d\xc7\xec\x07\xc2\x11\x3b\x35\x21\x88\xe9\x80\x47\xfe\x1d\x9a\x88\xce\xfd\x55\x1e\x4b\x67\x56\x1d\x5c\x06\x6f\xdd\xb1\x45\x7e\x90\x5f\xfa\xde\xe1\xcf\x2e\xa4\x3f\x25\x73\xab\x27\xac\xbf\x89\xe6\xdb\x83\xab\xe5\x45\xfc\x2f\x84\x2f\x1e\x50\x4a\x34\x59\xa0\x18\xfb\x9d\x4e\x9b\x60\xc0\x7c\xb4\xcc\x16\x24\x44\xd8\xec\x66\xfd\xc4\x94\x19\x78\xb3\x1c\x8a\xb3\xc9\x96\xbf\x00\x50\x36\x69\x10\x97\xdb\x6c\x28\x2d\x2b\xed\x8c\x63\xbb\x18\xc7\x0e\xc9\xaf\xbd\x63\x9d\x7c\x55\x8f\xbe\xb6\xc1\xe3\xef\xdd\xed\x4e\xcb\xa7\x3b\xe5\xdd\x39\x79\xfd\x97\xbe\xf9\xd3\x8d\xb7\xbb\xf6\xbd\x6e\x85\x75\x50\xf8\xef\x3c\x5c\xc9\xe4\xc9\x05\x46\x48\x31\x97\x15\x03\x23\x34\x18\x0d\x1e\xa2\x94\xac\x3a\x4e\xe7\xf6\x18\x10\x72\x35\xa7\x10\x02\x3c\x4f\x06\x9b\x29\x2b\x63\x56\x59\x65\x79\x0a\x12\xf9\x6c\xcd\xb1\x57\x31\x1d\x43\x2c\xa4\x20\xe8\xd4\x10\x1e\xb1\x21\x7d\xff\x92\x2f\x99\x49\x98\x8b\x26\x7f\x2c\xff\xf9\x24\x34\xc8\x33\x0e\x3f\xbb\x79\x93\x3c\xea\x6a\x34\x30\xfd\x0c\xbf\xf4\xc4\x23\xcf\x7f\xe6\x4f\x3f\x82\xbe\xbc\xf7\xce\x19\x37\xd3\x83\x92\xa9\xec\xf7\x20\xeb\xae\x44\x78\x1d\x05\x57\x4a\x0d\x5e\x8f\xbe\x34\x60\xa3\x0a\xbe\xd4\xc3\x95\xc7\xa4\x00\x74\x04\xa0\x18\x80\x0d\x7a\x68\xd6\x43\x23\x17\xd0\x3b\x81\xb3\x70\x62\xca\xeb\x75\x72\x9d\xab\x7d\x75\x31\x6e\x50\x8c\x90\xf1\x1d\xbc\x63\x3e\x5c\x9c\x8d\x28\x76\x81\x65\x74\x6b\xb0\x38\xa4\x2e\xd1\x41\x27\xb9\x97\x3b\x40\xc6\x86\x43\xd7\xfc\x26\x7f\x1f\x7e\xd2\x77\xe4\xe9\x4f\xff\xd8\x63\xcd\xe3\x8f\xef\x1d\x43\x26\x96\xe6\x33\xa8\x0f\xef\x0f\x3d\xbe\x5e\x5e\x99\x98\xfb\xc4\x2b\x8f\x8f\x93\xff\xe8\x78\xf2\x70\xc9\xd2\x39\xcb\xee\xb8\x78\x58\xdf\xea\xf8\x55\x6b\xae\x7c\xfa\xdd\xfb\xee\x4e\x4c\x9b\xfc\x5d\xaf\xc1\x0d\xf1\xba\xc9\xeb\xa6\xbd\xf3\x85\xf2\x8c\xcf\x92\xf1\xb8\x82\xd9\xed\x74\xf7\x1c\x71\x88\xac\xc2\x3a\x4c\x37\x1a\x28\xef\x11\x54\x25\x99\x46\x13\x61\x87\x18\x62\x48\xc0\x97\x9f\x7b\xf1\x9c\x5c\x18\xe0\x6e\x27\x36\xcb\x05\x1f\xf7\xb7\x6d\xdb\x28\xce\xfb\x09\xdf\xde\x67\xfd\xa8\x6a\xa5\x02\x82\x4f\xc4\xd8\x65\xb5\xd9\xdc\x44\x91\x8b\xd8\x6a\x25\xf6\x3f\x9d\xbf\xf6\x4c\x4c\x10\x32\x6f\x2a\xab\xda\x18\x2b\x68\x0c\xc8\xce\x7c\x23\x57\x22\xe8\x23\xeb\x03\x02\xe8\xae\x6f\xe4\x73\x66\xed\x3d\x47\x77\x5b\x0f\x6c\x87\x4b\x86\xec\x79\xf1\xb1\x3a\xf9\xa0\xe3\xa7\x0f\x2a\x17\x96\x60\x4d\xeb\xe1\x31\xdd\x57\xde\x07\xef\xc1\x93\x5b\x37\xc8\x67\xe9\x91\x72\x10\x3c\x49\x9e\xed\x3c\xa1\x43\x4b\x34\x88\x0d\x02\xf2\x38\x3c\xd2\x09\x5a\xad\x5e\x40\xc4\x9f\x67\x4f\x96\x17\x1e\x63\x8e\x35\xdd\xa0\xb4\x13\xb5\x99\x40\x0f\xbf\x2e\x7f\xf0\xf2\xeb\x91\x15\xa8\xdf\x7b\x44\x27\x06\x7f\xfb\x0d\x7f\xa9\xe2\xd4\x76\x21\x38\xbd\xb0\x41\xfa\x92\x76\xde\x35\x5a\x2d\x1c\x04\x0e\x07\x59\x63\xb9\x02\x8f\xd7\xeb\x9b\xef\x83\xbe\x25\x37\x2f\x4e\x7e\xe3\x83\x9f\xfa\xe0\xdb\x3e\xf8\x07\x1f\xdc\xeb\x83\x5b\xc9\xc7\xd2\x8d\x33\x93\x3d\x7d\x83\x7c\x28\x46\xfe\xf0\x41\xa3\x0f\x4e\x83\xff\xf4\x5d\xf0\xa1\x53\x3e\xf8\x96\x0f\x1e\xf0\x1d\xf5\x21\x9f\x74\xc5\x95\xc9\xb8\x0f\x8a\x3e\x9f\x0f\x5d\xf0\xc1\xb3\xb9\xaf\x08\x8a\x75\x3e\xb8\x90\x22\x1a\x38\x38\xd9\x46\x5f\x2f\x1e\x90\xdc\x49\x3f\x5a\xed\x43\xd3\x19\x4e\xb3\x0f\x36\x88\xbe\x4f\x7d\xff\xf4\xe1\xd5\xbe\xc7\x7d\x7f\x60\x6f\x79\x9f\x54\x95\x48\x2e\xf6\x41\xd4\xe8\x1b\xea\x6b\xf6\xe1\x38\x7b\x99\xee\x5b\xe7\x7b\xd7\xd7\xe6\x13\x80\x0f\x7a\x3d\x1e\xe2\x29\x59\x2c\xc4\x3c\x73\x18\x89\x52\x87\x50\xd0\x2a\x5a\x9d\xc9\x27\x7b\x93\x59\xa2\xc8\xaa\x54\x31\x73\x96\x22\xc5\x15\xe3\xc9\xc2\xc4\x7e\x66\xcd\xaa\x20\xcb\xd6\x2c\xd5\xc4\x1e\xaf\x7c\x3b\x33\xbb\x0d\x9e\xc8\xfc\x47\x99\x8c\x51\x19\x5b\xaa\xe8\x1a\xd5\x07\x2a\x4b\x15\x7d\xe5\x6f\x3d\x75\x89\x09\x0d\xee\x29\x8f\x3f\x75\xd7\x6b\x43\x0d\xdc\xd0\xa9\x70\xe5\x33\x83\x4c\xd8\x52\xdd\x0b\xbe\x72\x1c\x2f\x86\xf6\xae\x6f\x2c\x6a\x5d\x4a\x06\x64\xe9\xd6\xa3\xcf\x9f\xc6\x0d\xad\x1b\xb7\x7c\x10\x99\xbd\x0a\x3f\x47\xed\xb1\x4f\xc8\x78\xdf\xc3\x6c\xce\x4b\xa5\xa8\x86\x07\xa2\xa8\x17\x20\xc7\x6b\xb0\x56\xa7\x33\xb6\x19\x21\xc2\xd8\xa0\xd3\x6a\xa1\x9e\x13\x38\x62\x05\x91\x3f\xc5\x9c\x15\xe4\x6e\x50\x57\xae\xc4\xf8\xbc\xad\x7b\x42\xac\x0e\x46\x74\xd4\xf2\xa1\xc6\xcf\xdf\xe5\xf7\xd3\xe7\x4e\xa2\xbb\xe4\x7d\x6f\x10\xdf\xf4\xd3\x93\xe9\x3d\x70\x06\x9a\x90\xde\x8d\xbe\x45\xf7\xa6\x3f\x41\x65\xe9\x2b\xd2\x11\x65\x5e\x7d\x44\x68\x79\x9f\xc9\x5e\x83\xe4\xe3\x30\xdd\x56\xc3\x58\x47\x56\x7f\xbd\xa0\x21\x04\xf1\x08\x41\xa2\x4b\x20\x00\xf1\x1a\x16\xb5\x57\x98\x9b\x1f\x1c\xa5\x7c\xb2\xb3\x1b\x43\xb4\xeb\xc5\xd9\xf2\x92\x57\x61\x0d\xaa\xfe\x38\x2d\xa1\x24\x6e\x48\x4f\x40\xbb\x5b\xdf\x20\xcf\xfc\x67\x72\x9f\x42\xe6\x97\xd4\x93\xfb\x10\x12\x35\x1a\x91\x58\x80\x7a\xe2\x7e\x10\x5b\x4b\x83\x91\x16\x12\x17\x89\x0a\x7b\x6e\x47\x47\xb5\x3b\x99\xdc\x77\xad\x8e\xc1\x7a\x16\x12\x86\x21\xae\xc7\x85\x1d\x3e\x2e\x90\xc6\x01\xfc\xad\xef\xc2\xd7\x78\xee\x3a\x6e\xf4\xb6\xd5\x17\x1e\x61\xbc\x95\xc7\xa0\xaf\xf9\x13\x44\x4f\x54\x4a\x2e\x0d\xe0\x10\xd2\xf1\x64\x2a\x40\xee\x7c\x0a\xd2\x69\x96\xa2\x1b\xaf\xb9\xbd\x33\x05\x7b\xd7\x6a\x4c\xbc\x1b\x32\xa5\x84\x32\x38\x0b\xde\xeb\xfd\x46\x3e\xfa\x8d\x57\x1e\x23\xcc\x5d\xfa\xdb\xda\xa5\x0a\x9f\xee\x6e\xfb\x0e\xfe\x99\xed\xe1\xd1\x3d\x5c\xba\x8f\x9c\xd9\xc6\x53\x77\xba\x78\x22\x24\x50\x7a\x62\xd3\xa1\xcc\x3e\x1e\x6c\x1b\x43\x68\x99\xc8\x68\x21\x96\x01\x0f\xc8\x23\xeb\x80\x56\x40\xe7\x53\x82\x4f\x83\xcf\xa7\x34\xa0\x3d\x25\x8c\x8e\xfa\x04\x8c\xd4\x87\xe0\x5e\xef\x3f\x60\xdf\x6f\xbc\xf0\x5e\x79\xad\x3c\x66\xa9\x66\xf6\xd2\x5f\x57\x2b\x74\x44\xd1\x03\xf8\x23\xc2\x47\x0d\x48\x48\x05\x3c\x47\x64\x85\xd8\x99\x80\x38\x79\x61\x08\x31\xb4\x43\x36\x5c\x98\x0e\x57\x9c\x6e\xb9\x76\x50\x1b\x3a\x44\xed\x1b\xdc\x55\x7e\x4b\x7e\x67\x37\x9c\xf1\x16\x9c\x85\x1e\x40\xf3\xd3\x77\xa0\x2f\xd3\x41\x65\x1f\x6e\x62\x9b\x06\xff\xa7\x6d\xb8\xb2\xb7\x89\x88\x34\x10\xa5\xf1\x1c\x61\x5d\xbc\x22\xb3\x6b\x2c\xd4\x86\x9c\xbb\xb8\x2d\xff\x19\x3c\x98\xd2\x73\x1b\xf7\x24\xfc\x37\x7f\x9a\xd9\xcf\x0e\x08\x34\x02\xc0\x9b\xc7\x99\x41\x1c\xd0\x20\xe1\x59\xf2\x31\xc8\xf8\xfa\xe4\xee\xb0\x3e\x61\x17\xe0\x36\xf9\x0c\xff\xee\x03\x98\x5c\xe8\xf2\xcb\x5f\x39\x94\x58\x20\xdd\xb7\xa9\xe2\x2e\x03\x31\x50\x0f\x26\x4a\xdd\xaa\x45\xb7\xa7\xdc\xcc\x05\xcb\x82\x1e\x91\xeb\xde\x60\xaa\x18\x96\xe2\xb4\x26\x93\x4f\xdb\xe4\x86\x66\xaa\x9e\xdd\x6e\x9f\xcf\xd1\x94\xf2\x59\xca\x4a\x12\xda\x44\x53\x0a\x68\x73\x49\x0c\xb9\x48\x03\xf5\x88\xe2\xb6\x86\x8c\x51\x91\xc8\xae\x61\x79\x01\xae\xe2\x92\xfa\xba\x0e\x5b\x84\x82\x12\xec\x22\x36\x07\x16\x4c\x58\x8d\x79\xd7\xe3\x9d\xe3\x47\xf1\x9a\x11\x87\x6e\x5d\x73\x00\xea\x60\xf8\x1f\xf6\x6b\x27\xdc\xb4\xc0\x77\xa8\xea\xd4\xf3\x8f\xbf\x61\xbf\x54\x1c\xe6\x0b\x99\x2e\x6a\x79\xe3\xa6\x95\x83\x2a\x26\x0d\x99\xb4\x6d\x8a\x45\x3f\x64\xb0\x74\xeb\xd5\x7b\x6e\x7b\xee\x45\x0e\x5f\xe9\x1f\x37\x66\xd4\x18\xff\xc6\x15\xbb\xee\x90\xc6\xcb\xb7\x57\x47\x07\x0a\x33\x2c\x28\xcc\xe1\x92\x86\x31\x7d\x06\x4d\x18\x71\xfb\x10\xc2\x03\x3f\xe1\x41\x37\x22\x2f\x05\x84\x0b\xd7\x49\xf6\x32\xec\x0e\xea\xb1\xc9\xe1\xb0\xdb\x4d\x66\xb3\x56\x6f\x4c\xe2\x67\xdb\x7e\x95\x62\xf4\x8d\xb9\xa2\xdc\x5c\x51\x54\x11\xaf\x20\xee\xbc\xc3\x0e\xcc\x26\xa7\xde\x16\x74\x93\x05\x5d\x88\x34\xa5\x04\x17\xf0\x11\x8e\x58\xda\x45\x03\xe9\x22\xc2\x56\x30\x22\x0d\x15\x15\xaa\x65\xee\xce\x6e\x1d\x2b\x61\xbf\xb2\x08\x0b\x94\x42\xb6\xa6\x09\x89\x3e\x50\x49\x6e\x71\x29\xd9\x2d\xa5\xe8\x1f\xdb\x0f\x2c\x3c\xb5\x7f\xe1\x96\x20\x16\xc2\x68\x3f\xef\x37\x9f\x6f\x19\xa1\x2d\xe0\x06\xee\xbe\xf8\xaa\xb5\x57\x76\x5f\x3c\xf3\x96\xf5\xc3\x27\x70\x97\xbd\xf0\xf0\x5b\xf2\xb2\x67\xaf\x99\x50\xb2\x0a\x9b\x6f\xbf\x94\xfb\x5e\x4e\x75\x99\xd0\x3c\x7a\xf5\xb0\x07\xcf\x4f\x5a\xb4\xfa\x5e\x38\x70\xe1\xc2\x5b\x98\x2c\x5f\xdc\xf6\x1d\xfe\x86\x8c\xb9\x07\x24\xa5\xa8\x5b\x4b\xf4\x9c\xc5\xac\x35\x7b\x0b\x0c\xf6\xa6\x54\x91\x05\x5a\x2c\x06\x0b\x40\x16\x34\x11\x61\x13\x46\x88\xe7\x41\x53\x8a\x77\xfd\x97\x38\x92\x3a\xb2\x25\x35\xf5\x6e\x14\xca\xc4\x2d\xd5\x7d\x2e\x0d\x72\x5a\xe0\x47\x6f\x8f\xdc\x36\x5f\x7e\xf6\xd8\x3b\x1b\xce\x3e\xb1\xf7\x35\xfd\x93\x9a\xeb\xc7\xdd\xba\x6d\xf4\x82\x33\x5d\xe5\x17\xfe\xf2\xda\x9b\x70\xec\x83\x8f\x6d\xf2\x4e\x9a\x76\x87\xfc\x97\x75\xf2\x79\x32\x16\xfd\xdb\xfe\xc9\xed\x25\x63\xe1\x26\xf6\xeb\x65\x52\xac\x18\x3b\xfc\x64\x2c\x6c\x26\xa3\xd1\x6a\xc3\xb6\xb2\xa8\xcd\xea\x34\x19\x01\xfd\x50\x00\x42\x90\xf0\xdc\x02\x3c\x84\xe7\xae\xdf\xf1\x3c\x8f\x3e\x95\xdd\x7c\x8e\xbc\x84\xc2\xe8\x48\x37\x2a\x8d\x65\x35\x99\xf0\x34\x65\x39\xdc\xa0\xf0\x7a\x6b\x90\x2f\x1c\xde\x72\xde\xaf\xdb\xe7\xe4\x07\xee\xbe\x48\xe1\xf3\x82\xbb\x46\x4f\x70\x12\x36\xc3\x45\x84\xcd\xbb\xe1\x83\x17\xec\x6b\x87\x27\x6e\xc8\xf2\x78\x83\xfc\xcc\x52\xc6\x63\xfa\x1c\xdf\x71\x65\x8c\xc7\x41\x90\x92\xba\x04\xbd\x00\x98\xbd\x2e\xb2\xd0\xb8\xcc\xae\x50\x58\xab\x05\x7c\x90\xb0\xd5\x18\xf4\x07\x91\x83\x0b\x06\x0d\x76\xbb\xbf\x29\x65\xb7\x18\xf8\xa6\x94\xc1\xd5\x31\x26\xa5\xbe\xeb\xb8\x5f\x4b\x43\x78\x02\x13\x92\x7a\x77\x26\x6a\xac\x6c\x44\x0b\x65\xf5\xca\xcc\x22\x9a\x01\xaf\xb8\x7d\xd2\x8e\xca\x55\x03\xbf\xda\x75\xfc\xd4\x5d\x10\x3d\xf0\xf6\x69\xcf\x4e\x6e\xe9\xfc\xdb\x9f\x29\x81\xff\x8e\x5c\xb6\xe2\xae\x89\x23\x1a\x97\xdd\x7c\xea\x8f\xc7\x61\xe3\x93\xef\x3c\x3f\x6d\xf2\xaa\xe4\x2d\xcb\x1f\xdf\xce\xe4\xa4\x3f\x79\x90\x6f\xc9\x58\xb8\x68\xc4\xd6\xa1\x81\x48\x83\x8c\x6e\xa3\x47\xb0\x8b\x1a\xd1\xd2\x94\x12\x89\x0b\xaf\xc1\xc3\x52\x0e\x8d\x19\x41\x27\xb3\x96\x32\x6b\x08\x35\x63\xb3\xf6\x60\xc6\x22\x8c\xd4\x27\xea\xfb\xa0\x44\x8d\x5b\x88\xc3\xb0\xc6\x4c\xb4\x3e\x3c\xf4\x5c\xcb\x73\xf7\x15\xdc\xe7\x76\x0f\xba\x65\xd2\xa5\x35\x05\x55\x5d\x1a\x2f\x76\xd8\x4f\x16\xe0\x67\x5a\x07\xe2\x67\x96\x2d\x98\x31\xbd\xc1\x70\xa7\x06\xf5\xbd\x6a\xd2\x32\xca\x53\x4e\x1e\xc3\x4d\xe2\x86\x80\x08\xa8\x21\xf3\xb4\x27\x46\xc5\x56\x7f\x20\x50\xa1\x0d\x85\xac\x08\x27\xba\x81\x6e\x07\xbb\x21\x2b\x0e\x86\xb4\x18\x04\xfc\x66\x5d\x85\x17\xbb\x4c\xae\x2e\x4d\x29\x97\x05\x63\x13\x30\x95\x35\xa5\x4c\x4e\x40\x18\x9c\x5b\x8a\x18\x5b\x73\x52\x43\x04\x05\xaa\x89\x7b\xed\x62\xf3\xc1\xb2\x7a\x25\x00\x16\xc9\x64\x9f\x31\x85\xe5\x26\x13\xb5\x3e\x61\x86\x34\x18\x93\x9d\xab\x6c\x23\x17\xae\x95\xf7\xd7\x3d\x18\x79\xe3\xae\x6d\xc1\x30\xea\xd3\x7c\xd3\x90\xfb\xff\x30\xe8\xb6\x23\x8b\xe7\x3f\xea\x41\x42\x31\xff\xb8\x3d\xf0\x40\xf5\xaf\xf2\xb6\x69\x53\xae\x3f\x38\x69\xc9\x8c\xcb\x6f\x1e\xde\x5d\x1e\xd3\x5a\xbe\x7d\xe3\x9e\x27\x52\x97\x95\x1f\x7f\x64\x05\xec\x76\x62\xd2\xac\xcb\x4b\x56\xeb\x86\xdf\xd5\xfa\xda\xcf\x1f\xe3\xc0\xfc\xc5\xdb\xa1\x6d\xd3\xa2\xd5\x97\xee\x90\x7f\x53\xd6\xa3\x30\x71\xab\x9d\x64\x6c\xbc\xa0\xbf\x14\x31\x6a\x80\xcd\xe5\x70\x39\x9d\x76\x87\xc6\xe1\x2b\x70\x39\x81\x4d\xd4\x7a\x39\xa2\xa1\xf4\x3a\x27\x36\x37\xa5\xb0\xaa\x93\x68\x5a\xa7\xbb\xa1\xfd\xe4\x50\x4d\xf6\xac\x0a\x8e\xd8\x89\x5a\xa6\xb2\xc3\x82\x3a\x44\x84\x16\x8f\x78\x74\xf6\xa6\xcd\xce\xc5\x87\x6f\xb5\x3d\x75\xeb\xb1\xe0\xbc\xa7\x60\xb0\x65\x90\xcd\x8f\x97\xce\x4e\xdd\xbd\x4a\x9a\x9c\x9e\x8d\x56\x8c\xed\xf3\xe8\xb1\x87\xd2\xbb\xf9\x13\xf2\xad\x93\x95\xfd\xf4\x10\x21\xf2\x3c\x5b\xb7\x05\x62\x6d\x89\xf4\x54\x23\xdd\x0c\xdd\x31\x1d\xd2\xd1\x78\x49\x28\xde\x3d\xd9\xa8\xe4\x5f\xac\xd3\xed\xd4\x1d\xd0\x9d\xd5\x69\xf4\x58\xc3\x9b\x05\xce\x09\xc1\x08\x6a\x32\x28\xf4\x2a\xba\x93\x98\x93\x6a\xb4\x89\xe5\xe4\x92\xb9\x0b\x8b\xc2\x2d\x61\xf9\xb2\x0f\x5a\x4e\xf2\xc1\x7d\xfb\xfe\xf3\x25\x31\x4d\x5e\x67\xfb\x0c\x3e\x79\x0c\xfc\x45\xc9\xf9\x21\x96\x95\x1f\x18\x0c\xc4\xe3\xb5\x93\x85\xcb\xcc\x19\x74\x26\xa3\x99\xd3\x35\xa5\x38\x5f\xfe\x3d\xd8\x7d\x6c\x0d\x36\x75\xe8\x73\xb7\x09\x2b\xa3\x4e\x55\x05\xdd\x67\x08\xb5\x84\xd2\x6f\x74\x1f\xe8\xee\x56\xd4\xb3\x97\xf5\xef\x2d\xdf\x17\xad\xa1\xb7\xfe\xad\xde\xb4\x52\x3b\xf2\x0a\xee\xe1\x0b\xd2\x8e\x15\xea\xb8\x8c\x26\xf7\x37\x80\x05\xd2\x90\xee\x28\x89\x50\x3d\xbc\x04\x8e\x81\xb8\xbb\x98\x14\xc7\x8a\xb8\x01\x0d\x44\xa8\x07\xbc\x14\x5e\x0e\x31\xa2\xf9\x3b\x34\x00\x07\x45\x42\xa7\xc8\x61\x16\x86\x6b\x34\x0d\x35\x35\x13\xc5\x4b\xa3\x71\x3a\xbd\x99\xd8\xa9\x2c\x1c\xe7\xcc\x18\xa2\xd4\x14\x85\xe3\xdb\xa5\x8f\x26\x32\x31\x4f\x40\x6c\x6a\x62\x80\xb7\x8b\xc8\xa1\xf7\xe5\x73\x7b\x92\x74\xd0\x9e\x3a\x01\xa7\x7d\x91\xfe\x01\x36\xc1\x5f\x6e\x91\x6f\xe7\x4f\xb4\x5e\xf7\x22\xec\x2f\xc7\xd3\xf7\x12\xba\x73\xe3\xd5\x4d\x0a\x63\x1a\xb3\x99\xc8\xc3\x25\xfc\x7b\x3c\x1a\xca\xc3\x22\x3e\xce\xef\xe4\x0f\xf0\x47\xf9\x36\x5e\x03\x09\x0c\x25\xa6\x11\x8e\x27\x46\xbd\xca\x30\x1a\xfc\x0c\x91\x5b\xc8\xa7\xf8\x13\xff\xe9\xa6\xf0\x41\x33\x88\xcc\xd5\x2a\x38\x51\xba\x60\xd3\x99\xf5\x66\x93\x49\x2f\x56\x7a\x31\xae\x02\xa5\x45\x45\x40\xc4\x5d\xe2\x77\xc7\x21\x5c\x12\x87\x23\xe3\x73\xe2\x28\x18\x87\x0e\xe5\xed\xf2\xf8\x43\xf1\x96\xf8\x87\xf1\x73\x71\xa1\x22\xde\x33\x8e\x40\xdc\x12\x47\x53\xcf\xc5\xe1\x97\x71\xf8\x61\x1c\x1e\x8c\xc3\x7e\x04\x6a\x13\x81\xe2\x2c\x71\xc8\xd1\x0f\xcf\xc5\xd1\x1f\xe2\x70\x4e\x1c\x8e\x8b\xc3\xea\x38\x2c\x8e\x13\xbb\x09\x92\x2b\xde\x8b\xc3\x57\xe3\xf0\x71\xf6\xd5\xc4\x38\xec\x16\x1f\x19\x47\x62\x1c\xd6\x93\xaf\x3e\x8d\xc3\x4d\x71\x78\x5d\x1c\x36\x51\xf8\x7e\xec\xf3\x91\xe4\xde\xf4\xce\xa7\x09\x42\x8d\x18\xaf\x88\xa3\x0b\x71\x78\x3a\x0e\xb7\xc6\xdf\x8a\x23\x05\x7b\xb7\x38\xb4\xc4\x83\x71\x44\xa8\x22\x3c\x2e\x8c\x35\xa5\x0a\x2d\x5e\x9b\xae\x12\x16\x87\x0c\x36\xb2\xfe\xbb\x34\x54\xdd\x98\xcc\xe1\x48\x44\x2f\x8a\x55\x99\x51\xa3\x03\xa7\xaa\x19\x2b\x55\x90\x90\x25\xe3\x29\x3f\x2c\x9a\x37\x4b\x89\xe8\x65\x3e\x51\x1d\xa6\xec\xc7\xf4\xcf\xe6\x99\xd6\x5c\xf6\x70\xfe\xa0\x87\xec\x19\x3b\x8a\xce\xdd\xfa\x84\x83\x59\x10\x54\x3f\xb5\x9f\xd3\x0a\x08\xda\x74\x8b\x77\xf0\xe8\x39\xfb\x7d\xf3\x9e\x7a\xc4\x61\x7f\xcc\x29\xe0\x81\x1b\xa7\xcc\xbf\xcb\x34\xe2\x81\x6b\xee\xd8\xe0\x5c\x7c\x88\x7d\xbb\xaf\x70\x1e\x5a\xb0\xa8\xeb\xa0\xa1\xaf\xef\x4a\x3f\x84\x47\x34\xaf\x14\x57\xc4\x66\x5d\x7e\xd3\xcc\xdb\xa6\xa8\x33\x9e\x7d\xf9\xca\xae\xf4\x03\x19\x5d\xe4\x22\x63\xed\x03\x97\x48\x25\xd8\x63\xd5\x9a\xf4\x64\xbd\xd6\xe9\x3d\x7a\x7f\xa1\x16\x16\x88\x56\xde\x09\x9c\x44\xef\x3a\x2d\x64\x02\xfa\xf4\x3a\x85\x2b\x35\x6a\x08\x8c\xa5\xba\x76\xd0\x46\xa1\x9c\x0e\x6a\xf7\x44\xf4\x59\xd0\xdb\xaa\x1e\x6a\x51\xe9\x57\xd5\x53\x56\x0b\xa9\xf4\x66\xb4\x93\x62\xe7\x12\x9b\x87\xab\x21\x34\xd2\xdc\xbe\x1a\xc9\x67\x06\x4e\x2d\xd0\x06\xfc\x20\x60\x09\xa0\x22\x6c\xb0\x92\x65\xd7\xc2\x7b\x54\x43\x07\xa8\x43\x94\xb7\x7e\x39\x90\xb2\xc2\xd6\x31\x03\x42\xb0\xa8\xd6\x02\xdd\x6d\xe5\x6a\x9a\x36\xff\x79\xd5\xab\xa7\xb9\x35\xbf\x3e\xf3\xc1\x17\x47\x7e\xbd\xe3\xc1\xcb\x97\x2c\x98\xba\x68\x42\x4f\xf4\xf8\x6d\xf2\xdf\x5f\x99\xf4\xdd\x5b\x27\x60\xaf\xdd\x9f\xbe\x01\x03\xab\xe5\x33\xcb\x37\x6d\xed\xbf\xf1\x34\xa3\xa9\xed\x6d\xb2\x9e\x75\x25\x36\x82\x17\x44\xc1\xc5\x52\x71\xa9\xcb\x55\x1e\x13\x8a\xcc\x58\xab\x8d\x61\xf2\x62\x07\xf6\x02\x66\x13\x88\x66\x41\xeb\x03\xe1\x9c\x99\x93\xc8\xb1\x8e\x2c\xb2\xee\x4c\x28\x9e\xee\x11\x44\x1c\x9a\xdf\xf1\x0c\x69\x70\x7b\x73\xb2\x9c\x5a\x37\xd6\x09\x4f\xfd\xe6\x36\x3c\x6a\xe4\x88\x19\x79\x13\xb5\x79\x4a\x73\xb6\xa4\xe3\x9a\x09\xe2\xf5\x72\x21\xaf\x99\x7e\xa3\x6f\xba\xbb\x79\xb4\x62\x59\xe2\x3f\x75\x30\x25\xa9\x9d\x43\x9e\xe1\x6a\xc2\x57\x0f\x28\x03\xcd\x92\xa5\x04\xdb\x6d\x36\x73\xc0\x61\x32\x99\xb1\x39\x1a\x8b\xd1\x60\x7b\x55\x22\x49\x5f\x25\x9f\xbb\x30\x69\xb7\xf9\xcc\x26\xb3\x33\xc0\xcc\xb7\x10\x33\xdf\xbc\x9d\x9a\x6f\x90\xee\xb1\x36\xe4\x27\xcb\xb7\x37\xe0\xe8\xca\xcb\xc4\xe3\x7f\x5a\x70\x62\x50\xb3\xdf\x5d\xfe\x43\xcb\xa8\x60\xce\x56\x6e\x67\xc3\xd5\x2d\x11\x2f\xfb\xe4\x42\x1d\x7c\xe6\xee\xdf\x19\x71\x4c\xae\xd1\x59\x32\x3e\x36\xd0\x5b\x2a\x32\xf0\xa2\x20\xea\xf5\xc4\x43\xb7\xd9\x6d\x0e\x5e\x6b\xc0\x16\x8d\x05\x35\xa5\x2c\x16\xbd\x59\xd0\x30\xf3\x27\x6f\x4c\x6c\x0d\x79\x13\x14\x66\x26\x27\xcd\xe4\x67\x83\xe2\x46\xef\x54\x76\x99\xb6\x37\x70\x63\xcb\x6e\xaf\xed\xb1\x08\x77\xd1\x92\x91\x5d\xba\xe2\xc7\x8c\x9f\x3d\x9a\x3e\x81\xfb\xac\x9a\xf5\xf9\x8a\xeb\x4d\xca\x3a\xcf\x13\x5b\xfd\x63\x6e\x10\xe1\xee\x65\x52\xb9\xa0\x09\x3a\x8c\xa0\xc0\xeb\x05\x0e\x0d\x17\x8d\x19\x83\xc4\x1d\xf3\x0f\x4b\x81\x82\x19\x05\x48\xc4\x05\x05\x6e\x0b\xd6\x0f\x4b\x09\x02\xa6\x3e\x59\xbc\x7d\x46\x5d\x43\x87\x78\x22\x74\x30\xc7\x23\x9b\x3e\xc7\x22\x8a\x75\x89\xa0\x6a\xba\xab\x11\x45\xbc\xfa\xd7\x6f\x9f\x78\x3b\xb6\x31\xb4\x7a\xee\xba\x4d\x53\x1e\x5e\xb2\xa4\xdf\x3f\x4e\xc2\x2b\x2b\x1f\x74\x2d\x98\x7a\xcb\x8a\xf2\xa1\xeb\x16\x2f\x4d\xc2\xde\xbb\x0f\xcc\xbd\xb5\xfb\xd8\xa6\x49\xe3\xfb\x8c\x48\x94\x37\x5d\x77\xc9\x86\xed\x6d\xde\xa1\x03\x86\x26\xcb\x7b\x54\x55\x45\x87\x2b\xfb\xd7\xe3\xdb\xbe\x43\x4b\xf8\x4a\x9a\x77\x26\x85\x0c\x3a\x9d\x0d\x63\x6f\x01\x28\xb0\x14\x20\x07\x36\x6b\x74\x9a\x61\x29\x03\x59\xfc\x74\x66\xe0\xc8\x13\xf3\xb8\x35\x9b\x3a\x61\xcd\x8b\xfe\x11\x29\xa8\x67\xd6\x24\xe1\xa6\x10\xc9\xfa\x8c\xd0\x3e\x6a\x92\xf9\xd6\x45\x05\x8b\xa7\xdd\x1c\x7f\xb3\xe0\xcd\x45\x86\xcb\xcb\x7b\xd8\xaf\x72\x4c\x19\x59\x3f\x08\xad\x5b\xf6\xf3\xcf\xcb\xd2\x0b\x7b\x45\xc6\x9a\x56\x78\x28\x3d\xa3\xdb\xbe\xe7\x2e\xe5\x7a\x10\x9d\xd5\x5b\x0a\x60\x8f\xd6\xaa\x33\xa9\x3a\xab\xd0\x6f\x55\xd5\x95\xcb\xe4\xd4\xe9\x80\x99\x06\x68\x1b\x33\x9b\x72\xbf\xb3\x9b\x94\xdb\xd7\x65\x1c\x8a\xba\xac\x7f\x5b\x6f\x87\x3b\x3b\xd7\x54\x5c\x8f\xf4\x42\xa6\xab\xd0\x84\xd6\xfd\x79\xba\x0a\xad\x55\xc6\x9c\x70\x8c\xbb\x92\xd0\x66\x00\xbd\xa4\x20\x4d\x62\x12\x90\x60\x14\x0d\x06\x53\xd0\x24\x99\x9a\x4c\x4b\x4c\x1c\xdb\x5c\xc1\xc8\x0c\x54\xbb\xdb\xd6\xc0\x22\x6f\xd6\x76\x69\x87\x21\x16\x3f\x2b\x82\xf5\x75\xc4\x0e\x80\x17\x3e\x7a\xfa\x0f\x57\xeb\xf4\x5c\x41\x55\x35\x5c\xf2\x2a\x21\x41\xea\x37\xa7\xb6\x76\xc2\x58\xf4\x32\xbb\xe7\x14\xb2\x5e\xd7\xd2\x13\x01\x60\x57\xa9\xce\x0e\xa0\xd5\x64\x24\xcf\x23\xea\xb4\x5a\x2d\x31\x9e\xb4\x56\xce\xe1\x14\x1c\xd0\x88\x1d\x2e\x8d\xcb\xe5\x1a\xe0\x9a\xe7\xba\xdd\x75\x8f\x4b\x73\xc6\x05\x9f\x73\x1d\x77\xa1\xc9\x2e\xe8\xa2\x73\xbc\x6c\xda\xf5\x49\x9d\x0b\x4e\x75\x49\x57\x5e\x9d\x9c\xe7\x82\x29\x17\xd4\x10\x68\x74\xce\x05\xeb\x5c\x53\xc8\x15\x1f\xbb\xb8\x62\x15\xb6\x6f\xff\x64\xf2\x7e\xd7\x5e\x72\x39\xbe\xdd\x05\xfb\x51\xc8\x52\x57\x9d\x0b\xd7\xef\x75\x7d\xe3\x42\xf7\xb8\x60\x83\x6b\xa0\x2b\xe5\x9a\xef\xe2\x5c\x2e\xf8\x9b\x0b\x7e\xec\x3a\xe3\x42\xd3\xc8\xdf\x77\xba\x70\x1d\x45\xca\xb0\x18\x9c\x9e\xe4\xdd\x2e\x48\xcf\x82\x50\x3e\x28\x12\x4d\x49\xb3\xab\xd1\x85\x04\xe2\xc0\x6b\xc9\xa0\x6a\xad\x22\x16\x05\x9d\xd6\x4c\xd3\x20\x05\xa7\x12\xb4\x6c\xcc\x44\x67\xe2\x4a\xd4\x92\xcc\x92\x66\xb2\x24\x57\x64\x16\x5e\x25\x4a\xa9\xfc\x51\x31\x81\xc5\x2b\x67\x5a\x13\xf9\x55\x3d\xea\x7f\x35\x8c\xd1\x65\xc4\x42\xa4\xec\xa6\xa1\x61\xbb\xcb\x59\x07\x13\x5c\xe5\xfb\x25\x9a\x40\xb5\x7c\xf0\xbd\x2b\x0e\x45\x85\x61\x70\xd4\x4b\x95\x9a\x10\x5c\x7e\x10\x1d\xf9\x6e\xd0\xcc\xb4\x8b\x0c\x40\xe8\xf5\x17\xd1\xdf\xd3\xde\xeb\x87\x0f\xc5\xa3\x59\x0c\xe8\x09\x32\xee\xbd\xc8\x18\x88\xe0\x2a\x29\xa4\x05\xa2\x86\xa7\x11\x49\x9e\x83\x82\x5e\xd4\xe8\xb0\xce\x68\x31\x06\x8d\x48\x32\x36\x19\xbf\x34\x62\x23\x7d\x56\x57\x55\xcf\x24\x19\x22\x5e\xcf\x41\x9a\x0c\xce\x9b\x59\xcc\xd2\x99\x8b\x59\xaa\xdb\x86\x15\x94\xf8\xfc\x3c\x5a\x4a\x35\x66\x81\x4b\x16\x42\x44\x2f\xbf\x2f\x2f\x7f\x03\x7e\x27\xff\xfa\xc2\x4b\x70\xc2\x3b\x72\x05\xf4\xc2\xe7\xe5\x7e\xa8\x12\x99\xe4\x71\xf0\xe1\xf4\xb9\xf4\x07\x34\x9f\x9e\xe8\xfa\xa9\x84\x3e\x37\x18\x20\x15\xdb\x1c\x3a\xb3\xa8\x37\xeb\xed\x1e\xbb\x97\xee\x7a\x12\x05\x44\x55\xbf\x8e\x7c\xe6\xd0\xb5\x73\xb3\xb2\xf2\xa9\xc4\xf1\x33\x5a\x9d\x90\x60\x0f\x67\x1c\x2b\xc2\x3a\xa2\x6f\x68\x88\x17\x9a\x90\x25\xd9\xab\xa8\x2a\xd8\xbc\x61\x80\xef\x93\x67\x66\x98\x0b\xa0\x3e\x08\x0f\xbf\x91\xbe\x6b\xfa\x1d\x1b\xe5\x31\xa6\xdb\xb5\x4b\x16\xc4\xb9\x2e\xe9\xc7\x9a\x0e\xfb\x5c\x12\x0e\x5e\x78\xfd\xa5\xad\x43\xb2\xb9\xec\xf8\x34\xcd\x41\x84\xf3\xa4\x20\xe2\x79\x2d\x61\x86\x00\x80\x7e\x8e\x08\x2f\x16\x47\x88\x57\x89\xb8\x9b\x08\x23\x22\x24\xde\x11\x14\x9f\x6d\x03\x92\x7e\xf6\xfc\xe4\xdd\x22\x5c\xc2\xfe\x94\x24\xd7\x0d\x33\x92\x41\xb1\x5a\x44\xe4\x7b\x20\xc2\x69\x3f\x8b\xf0\x4b\xf5\x2b\xcb\x55\x53\x92\x9b\x44\x78\x9b\x08\x09\xb2\x89\x99\x0f\xc7\x4d\x48\x3a\x44\x88\x44\x78\x4e\x84\x5f\xb3\x0f\x97\x48\x8e\x11\xa3\x93\xb7\x89\x77\x8b\x88\x00\x5e\x29\xc2\x7e\xe2\x48\x11\x29\xd0\x03\x07\x27\x15\xb8\x0f\x45\x78\x4c\x45\x51\xda\xb7\x5f\x52\x01\x1c\x29\xc2\x8b\x44\xe8\x10\x8b\xc5\x6e\x22\x26\x28\x1b\xbe\x16\x7f\x16\x11\x01\x7d\x59\x45\x5c\x12\xef\x96\x1c\x2d\xc2\x6e\x62\x3f\x11\x85\x45\x48\x28\xb4\x88\x08\x05\x45\x49\x9c\x28\xee\x12\x8f\x89\x5f\x8a\x3f\x92\x15\x8a\x2e\xb8\x4e\x6f\x52\x64\x0b\xae\xd9\x96\x6c\x64\x8f\xa2\xc3\x1a\xc4\x93\xc5\x8a\x37\x43\xb2\xee\x92\xa1\x71\xe6\xc7\x7b\xe9\xc0\xd0\x0d\xe4\xe6\x59\xcd\xb3\x94\x28\xbd\x6a\x8a\x56\x64\x26\x01\x71\xc0\x32\xf1\xfb\x0a\x75\xbf\x99\x7e\xd1\x4c\xbf\xca\x7a\x22\x34\xeb\x5f\x8d\x14\x0b\x06\x37\x3a\x93\xfe\xa3\x17\x5b\x3c\xe9\x02\x74\x83\xf7\x4e\x5c\xba\xfa\xce\xd6\xbf\xa8\xb1\x54\xa7\x3c\x06\xf7\x25\xbe\x46\x15\x98\x2c\xd5\x45\xb1\xd7\x52\x69\xf1\x63\x91\xef\xe2\x70\xc4\x43\x65\x95\xde\x02\xa7\xdf\x6f\xd0\x62\xb1\xca\x20\x9e\x4f\x59\xcc\x06\xc9\xd6\x27\x69\x30\x38\x2a\xab\x2a\xcf\xa7\xaa\x7c\x0e\xe7\xf9\x94\x03\xb4\x4f\xc7\x6a\x68\x50\x97\x38\x9a\x35\xd1\x60\x53\x63\x0f\xd9\xed\x4c\x45\x1b\xb3\x45\xae\x9e\xc6\xd8\xfa\xc0\x9e\x50\x60\x4b\xb2\x09\x0a\x4e\x9a\xaf\xa5\xbc\x73\xb8\xc8\xe7\xf0\xc6\xe9\xcb\xf4\xdd\x75\xe3\x47\x79\x6f\x5c\xe2\x1e\x50\x78\xef\x5d\x77\x78\x1b\x53\x93\x3c\xfd\xed\xcb\xc6\xf7\x1f\xa6\xe9\xcd\x0b\xb0\xff\x90\x6a\xaf\x3c\x66\xc5\xdc\x3e\xf5\xb0\xa8\x32\x34\x62\x20\xb7\x98\x9b\x3d\x17\x5e\xbb\xee\x9e\xa5\x13\xe6\xcb\xdb\x9a\xef\x70\x21\xeb\xe4\xcb\x7c\x41\xf9\x25\xcf\x30\xab\xa6\x7b\xff\xa5\x4a\xbc\x5f\xee\x01\x17\x32\xff\xca\xf1\x0c\x73\xaf\xe8\xd1\x9c\xf1\x6c\x14\xdb\x4e\x48\xfd\xe8\x11\xb9\x87\x70\xf7\xaf\x37\x32\x59\x9e\x24\x8f\x41\x6b\x33\x3c\xb2\x78\x35\x11\xd1\x1f\xf1\x72\x8e\xb8\xa3\x4b\x59\xa8\xd2\x4f\x59\x51\xe0\xf5\x3b\xfd\xa2\xc5\xec\x30\x88\x86\xf3\x29\xac\xad\x12\x29\xa3\x44\xd1\x59\x05\x18\x8f\xd4\xd9\x67\x6b\x88\x57\xd8\x32\x0c\xb2\x31\x06\xe5\xc5\x67\xb2\x3c\xca\x86\x5f\x5d\x6e\x9a\xb4\x49\xf8\x51\x41\x2c\x2c\xba\xae\x11\x8e\xb1\x6c\x6b\xe5\x1d\xab\x66\x80\xdd\xfe\x2f\x3c\xe2\x4f\x50\x1e\xc9\x5f\x55\x84\x55\x1e\xc9\xf7\x30\x1e\xc1\xc9\x2a\x8f\x0a\x8b\x60\x63\x3e\x8f\x16\xa0\x18\x77\x23\x2e\x23\xc2\x39\x45\xd2\xd9\xb4\x6e\x17\xb0\xec\x4f\x69\xe9\xb1\x4c\xa5\xbd\x92\x5a\x40\x45\x9b\x98\x90\xf4\x55\xaa\xd4\x39\x92\x40\xb2\x49\xb1\x5e\x49\x9b\x28\xf2\xfb\x53\x45\xe2\x50\x71\xa7\x88\xa7\x8b\x8b\xc9\xcb\x01\xf1\x5d\xf1\xac\xd8\x46\xa6\x83\xa4\x33\x26\x45\x40\xcb\x58\x09\x2f\x2c\xaf\x56\x14\x7c\x5e\x51\xf1\x6a\x45\x26\x30\x0e\xe9\xce\x36\x15\x84\x5a\x9a\x6c\xc9\xb6\xbb\x9d\x26\x88\xaf\xed\xbf\x61\xe0\xd2\xb1\x17\xcf\xe9\x3b\xfd\xbe\x29\x2b\x36\x8e\x29\xbe\x6d\x56\xaf\xd9\x28\x56\x59\x50\x15\x8b\xaf\x1b\xd9\x25\xe1\xb8\x62\x73\x79\x29\x60\xa7\x13\xb3\x1f\x8b\x86\x9d\xe4\x8c\x80\x24\x1f\x41\x1e\xae\x27\x8b\x79\x74\x93\x0a\x10\xe6\x35\x58\xa3\x25\x36\x0d\xb4\x60\xa0\x91\x04\xcd\xf6\x71\x82\x19\x20\x48\x9c\xc7\xf1\x8d\xed\x4a\x8e\x33\xa3\x90\x20\x6e\xbb\x40\x66\x51\xe1\xa6\x7d\xaf\xc2\x3f\x47\x5f\x8e\xa2\x27\x5a\x0d\xfc\xd2\xe3\xc7\x19\x7f\x76\xb4\x7d\xc5\xf5\xe3\x97\x82\x22\xb0\x4e\x8a\xf2\x5a\xbb\x45\x6b\x09\xb8\xdd\x2e\xa2\xf3\x5d\x01\xd1\x25\x86\x82\x96\x82\xd9\xc4\x5f\xe0\xb5\x5a\x30\x3b\xb5\xcb\x72\xd0\x72\xcc\x82\x2d\x94\x5b\xf1\x40\x38\x49\x80\xb5\x56\xcd\x74\x37\xb4\xb8\xa1\xdb\x6d\xd5\xd0\x08\xaf\x84\x96\xa0\xf5\x68\x17\xd2\x34\xa1\x89\xe4\xcd\x31\xf4\x1e\xd1\x12\x48\xe3\xa5\xd6\x23\xab\x80\x61\x81\x7c\x56\x06\xcc\xf6\x85\x12\x15\x9d\x94\x8c\x28\xe2\x53\xef\x46\x4a\xe5\x2a\x0b\x8e\x65\x4a\x56\x33\x51\x60\x54\xfd\xf6\xc8\x6d\x73\xe4\x93\xc1\x5b\xc2\x9b\x77\x0e\xbe\xed\xc8\x8a\xc2\x5b\xfc\xcb\x36\x6a\xd5\x60\x30\x74\x9d\xe9\x2a\x9f\x30\x3f\xba\xdf\xf5\xd1\x13\x2b\xa1\xf5\xf9\xa9\x9a\xfb\x76\xd8\x1f\x5a\x92\x0b\x0b\xab\x75\x4a\x5b\xf8\x7b\x40\x29\xb8\x4d\xea\x5f\xe8\xf0\x39\xec\x01\x9d\xcf\x50\x0a\x80\x41\x87\x39\xbb\x3d\x1a\xe6\x39\xae\xac\x48\x1b\x0e\xe8\x0c\xba\xb9\x29\x9f\xb1\xc0\x62\x30\x70\x16\x8b\x7b\x76\x0a\x38\x2c\x0e\x5a\xb9\xe1\xb0\x08\x7c\x98\x0b\xcf\x49\x99\x4b\x61\x69\x29\xe7\x01\x8d\x99\x9a\xdd\x76\x75\x27\xe4\x99\x98\xd1\xa9\x6a\x91\x5c\x00\x39\x3f\xec\x4a\x4c\xbc\x50\x3d\x7d\x4c\x62\x85\xda\x15\x5f\x5b\x79\x56\x81\xe6\xec\xb1\x3a\x27\x32\x75\xb8\x44\xc9\x9b\xf7\xa4\xfb\xf9\x27\xcd\xf5\x14\x1e\xf1\x1e\xa9\x8f\x7e\xf5\xfc\xa6\xa3\xee\x87\x1c\x33\x06\xce\x5a\xec\xe9\x0e\xef\xf3\xca\xd7\xf8\x1c\x8b\x52\xf0\xbd\xa9\x4b\x0b\x60\xdd\x7d\x3b\xb6\x74\xd9\x7e\xcb\xfa\xa5\xd0\xf3\xf6\xd1\x45\xd3\x6a\xa4\x7e\xb3\x17\xc9\x5f\x2e\xdd\x38\x7d\x5f\xf9\xa8\x89\x8a\xaf\xb5\x16\x7c\xc5\x05\xb8\xd9\x64\x5d\x2d\x83\x46\xa9\xb6\x10\x84\x4d\xc0\x14\x8d\x8d\x8c\x41\x29\x06\xbb\xc5\x60\x30\x06\xb9\x98\x23\x86\x7e\x8c\xc1\xd3\x31\xf8\x5e\x0c\x3e\x14\x6b\x89\xbd\x1a\xc3\x4b\x62\xeb\x63\x68\x4e\x0c\x4e\x8c\x41\xe6\x88\xe9\xc9\x3a\x07\x62\x96\x18\xba\x8e\xfd\x39\xf0\xea\x6b\x93\xeb\x63\x70\x79\x0c\xce\x88\xc1\x7e\x04\xdd\xe4\x18\x26\xa8\x1c\x31\x08\x62\xf0\xc3\xd8\xe9\xd8\xb9\x18\x3e\x18\x23\x52\x1b\x9b\x11\x43\x3d\xa5\x58\x53\x6c\x62\x6c\x57\x8c\x93\xc8\xcb\xc1\xd8\x7b\xb1\x2f\x63\x3f\xc6\x34\xef\x91\x5f\x88\x79\x7b\x03\x47\x31\x6f\xef\xa9\x7e\x97\x28\xaf\xbd\x25\xc5\xfb\x0b\xd6\x35\x24\x77\xc6\x0e\xc4\x8e\xc6\x70\x4c\x12\xad\x84\x00\xa8\xc7\xce\xa2\x83\x29\xa7\x20\x09\x25\x07\x53\x02\x50\x92\xc9\x4f\x30\xcf\xbb\x82\xe5\x4a\xb3\xe2\xf3\xe6\x6c\x24\x44\xb5\xc3\xb2\x21\x92\x9c\xfc\xd9\xbb\xd5\x97\xd5\xbb\xe9\x24\xae\x77\x0b\x54\x93\xb9\x05\x5a\x20\x5b\x26\x94\xd5\x97\xd6\xe7\x4a\x6c\x34\x0f\x5f\x36\xf9\x9a\xab\x66\xad\xb9\x73\xd6\xa4\x6b\x26\x36\x0d\x9f\x3c\xe5\xea\x59\x77\xae\xbb\x61\xda\x94\x29\x97\x6d\x79\x68\xee\xac\x47\x1e\x9e\x3d\xf7\x21\xb4\x6f\xd5\xac\xc9\x53\xaf\x1e\xde\x34\x69\xda\xc4\xb9\x77\x90\xf7\xd3\xae\xbe\xac\x69\xda\xb4\x29\xb3\xd6\xcc\x7a\x64\xf7\xbc\x39\x0f\x3f\x4a\xe6\x61\x15\x00\xbc\x9b\xcc\x43\x17\x58\x26\xf5\xb7\x3a\x00\x76\xda\x9d\x2e\xb3\x68\xb7\x61\x93\x49\xc7\x11\x2f\x42\xd0\xeb\xb5\x3a\xa4\xd1\xe8\x6c\x22\xe7\x76\xb9\x3c\x82\xde\xa8\x9f\x9b\xe2\x8c\xd8\x64\x35\xcd\x25\xab\x97\x75\xa2\x15\x1a\xad\x46\xab\xd6\xe5\xb4\xdb\x34\x3a\xad\x52\x9b\xa5\x96\xdc\x8f\x57\x13\xc6\x73\x75\xe3\xed\x8b\xc6\xf3\xfe\x29\x55\xc1\x54\xe2\x58\xa6\x28\xcd\xb9\xa0\xff\x98\x51\x87\xbe\x81\x7d\x3d\xf2\xd2\x00\x5c\xec\x95\x97\xf6\x3c\xd4\x53\x5e\xe6\x85\x8b\x82\xf2\x52\x0f\x94\xe4\xbf\xbe\xf4\x0b\x3c\xf7\x36\x7a\x6d\xd1\x96\xc5\xf2\xfb\x30\xbe\x78\xcb\x22\xf4\x7c\x7a\x3e\xba\x83\xc8\xd8\x47\x72\x03\x59\xa7\xde\x66\x3a\xcc\x29\x89\x1c\x6f\x4a\x01\x68\xe2\xe8\x99\x83\x8d\x6f\xc7\x2b\x2a\x94\xa5\x0a\xb3\xe5\xea\x91\x47\xd0\x2b\x58\xdf\xfa\xcb\x85\x79\x58\x64\x69\x7d\x00\xb5\x7d\xd1\x36\x92\xeb\x4d\xd6\xad\x72\x50\x0f\xf6\x48\xa5\x15\xae\x12\x9f\x95\xeb\x0a\x42\xc1\x20\xe0\x7c\x2e\xbe\x81\xb8\xd0\xdd\x1d\xa8\x4b\xd4\x5b\x6b\xe9\x02\x2d\x5d\x82\x5d\xa4\x2e\xb8\x0b\x95\x93\xb2\xca\x24\x7d\x95\x1a\x7c\x81\xa4\xb9\xb6\xb1\x16\x85\x70\xad\x14\xaf\x49\x76\xa9\xed\x52\x5b\x62\x0d\x08\x81\xc8\xb0\x54\x28\x14\x00\x82\x89\x38\xbc\xc4\xe4\x99\x21\x2e\x11\xb9\xa0\xb8\x9e\x58\x3d\x58\x14\x97\x08\xc4\xb0\x89\x8f\xa7\x6a\x2b\x3f\x95\x86\x15\xdc\xb0\xcc\x5a\x66\x01\x33\x26\x76\xa8\x2f\x52\x7c\x61\x9e\xe6\x03\xb5\xf7\x87\x8b\xb3\xd5\xd5\xc4\x27\x2e\xa5\x39\x36\x2e\xb2\x44\xf0\x0e\x1a\x56\x63\x29\x38\x64\xa5\xf8\x59\xfe\x61\xf9\xaf\xdf\x3f\xfe\x4e\x54\x71\x90\xaf\xdd\x25\xff\x61\xed\x1d\xb7\x7f\xfb\x09\xbc\xbc\xf2\xc1\xd8\x4b\xf2\xcf\xd7\x6d\x7d\x7a\x53\x3a\xbc\xf0\xde\xe5\xf7\x37\x5c\x7f\xe7\xdc\x35\xe8\x81\x2f\x7b\x8f\x58\x93\x75\x97\x1b\xc7\x74\x9d\xfc\xd5\x8d\xeb\x03\xa3\xd6\x50\x8f\x79\xf3\x83\xf5\xa3\x6b\x1a\x76\x36\xf7\x9f\xd6\x85\xbf\x7a\x6c\x62\x50\x8f\xa8\xe6\x7a\x65\xde\xdf\xc9\xbd\x82\x3e\xe1\x17\xb2\x31\x29\x96\x2c\x1a\x8e\xd3\x02\x84\x74\x90\xe7\xf8\xb5\x34\x8b\x2b\x2f\x49\x3e\x17\xbe\x0e\xd1\x32\x0b\x5d\x64\x7f\x24\x7d\x32\x72\x20\xc2\xbd\xf2\x2c\xf9\xa1\x69\xec\x6d\x3f\xf2\x7f\x23\x7a\xd4\x4c\x56\x91\xee\xe0\x01\xc9\xef\xd1\xc6\x23\xb5\x75\x75\xb1\xa8\x05\x80\x68\x44\xcb\x35\xf4\x30\xf7\x80\x43\x70\x0f\x69\xe8\xe4\x64\x2d\x1d\x90\x01\x06\x73\xb2\xb6\x36\x18\xac\x39\x9e\x2a\xad\x3c\x9e\x1a\x1a\x6b\x8e\x4d\x27\x73\x38\x56\x6a\x0e\x42\x73\xb0\x28\xd8\x16\xc4\x41\x89\x58\x9a\xa0\xd4\x52\x3a\xa3\x74\x49\xe9\xfa\x52\x5e\x87\x83\xa5\xc1\x52\x8e\x18\x6d\x6f\xa6\x0c\x1c\x57\xf8\x66\x8a\xb3\xff\xbe\x0a\x8a\x0d\x09\x51\xc1\x6a\xdf\x04\x58\x91\xdd\x7a\xb1\xb6\xab\x8b\xc8\xcf\x52\xb7\x09\xf9\x65\x10\x35\xc5\x36\x66\xdc\xd1\x89\x9f\x09\x5b\x64\xb6\xc3\xf8\xbf\xbd\x24\x1f\x78\xe9\x35\x79\xff\x1f\x5e\x86\x4d\x2f\xbd\x0c\x87\x1d\xbb\x62\xaf\xfc\xe9\xde\x3d\xf2\x67\x7b\xf6\xc2\xf0\xde\xc7\x60\xc9\x9e\xf4\xa6\xe7\xdf\x7b\xf3\x85\x73\x13\x67\x05\xe7\x0c\x5e\x7c\xc7\x5d\x8b\x2e\x9b\x1d\x9d\xdd\x67\x2f\x7a\x85\x5e\x78\x1c\x0e\x21\xae\x50\xd3\xcb\xaf\xc8\x87\x5e\xde\x03\x23\x7b\xf7\xca\x9f\x3d\xba\x97\x5d\x1b\x91\xd3\x5f\x9f\x78\xeb\xf3\xf7\x43\xfd\xfb\x3d\xb0\x63\xeb\xe3\x83\x86\x45\xe6\x5f\xa3\x8c\x53\x0a\xad\xc6\x5d\xf8\xfb\x58\x7f\x80\x39\xd2\xc5\x5c\x69\xb9\xc5\x52\xe0\x70\x96\x13\x9b\xac\x00\x47\xba\x46\x6a\x4c\xa5\xa7\x53\x26\x93\xd6\x6d\x76\xec\x74\x20\x17\x76\x48\x26\x6b\xd2\xe1\x70\xbb\x6d\xa7\x53\xee\x2f\x42\x55\xda\xaa\xbf\xa5\x38\xb0\x5e\x0b\xd7\x69\x61\x50\x3b\x51\x8b\xb4\xb4\x8a\x68\x7c\x22\x91\x5f\x6c\xab\x70\xa9\x41\xcd\x0b\xc8\x2b\x40\x50\xec\x99\xdc\xfe\x3a\xdb\x5e\x8f\x84\x85\xb2\xba\xd0\xef\xf6\xd6\xa1\xca\x27\x74\xf2\xa2\x4b\x38\xee\xa2\xdb\x86\x5e\x3d\x1f\x5e\xff\x94\x6d\xf1\x7d\xc1\xe5\x3d\x20\xb7\x78\xb5\xbe\x56\x53\xed\xf0\x98\x4b\x36\xad\x5e\x78\x43\x8f\x44\xea\x6e\x2b\xda\xd0\xb3\x6b\x74\x54\xff\x19\xcd\xbf\xf1\xdc\xe5\xee\x29\x77\x58\x3f\xbd\xee\x8a\xb2\x2a\xf9\xfb\x22\x57\xbd\xf6\x1a\x23\x9c\xce\xe1\x21\x83\xe2\xdd\x17\x8d\x62\x7c\x18\x0c\xd6\x72\xd7\xe1\x7d\x40\x0b\xac\x60\xb8\xd4\x05\x6a\x80\x56\xcb\x59\xad\x3a\xa3\xc1\x80\x75\x66\xbd\x5e\xa7\xc1\x36\xcc\x71\x76\x1d\x91\xc7\xb3\xe3\x0c\x66\x1c\x67\x67\x4f\x1e\xc5\xa7\xb0\x06\xd3\x59\x9c\x13\x67\x77\x26\xd1\x38\xfb\xd2\xb5\xba\x84\x18\xa0\x09\x41\x47\xd6\xd8\xcc\x1b\x5c\x23\x9f\x37\xc0\x2d\x3b\x34\xf2\x14\x68\xe0\xd3\xcb\xe4\x7f\x1b\xe0\x7d\xdb\x35\xf2\x34\xa8\xe3\xd7\xc2\x1b\x1a\xe1\xec\x12\x79\x8d\xbc\xc1\xcd\xde\x96\xd2\xb7\x2e\x6a\x4f\x4d\x06\x2d\xdc\x25\xe8\x67\xc0\x83\xee\x52\x04\x72\x88\xa3\xe1\xf1\xfd\xa9\x24\x20\x14\xc3\x33\xe0\x17\x80\x4e\x00\x78\x3f\xd8\x0b\xd0\x3a\x02\x8d\x95\x62\x7a\xba\xf6\x54\x64\x53\x93\x4b\x58\x09\x3d\x7e\xba\xf5\x09\xfc\xd7\x16\xb8\xef\xee\xf4\xcb\xc4\x2e\x54\x6b\xdc\x89\x5d\x48\xe6\x14\xcd\xb2\xcc\x9b\x73\x55\xa0\x0e\xdc\x2f\x5d\xee\xd1\x06\xab\x42\xc4\xa3\xb1\x24\x22\x91\xe2\x2e\x31\x02\x17\x2b\xd6\x72\xf5\xdd\xcd\xdd\xc9\xdc\xeb\x4e\xe7\x5e\x55\x30\x58\x5c\x19\x0a\x27\xc2\x6f\xa6\x4a\xc8\xd4\x33\x17\x17\x15\x4f\x2f\xc6\xa7\x12\x70\x62\x02\x82\x12\x4b\x09\x31\x69\x8a\x13\x25\x25\x89\x62\xfc\xdf\xe6\x59\xb6\x14\x69\xe6\x4c\x65\x92\x11\xee\x79\x68\x30\x20\x6f\x9e\x59\x73\x69\x2a\xff\x97\xd9\xc6\xe3\x08\xed\x1a\xa0\x64\x4f\xda\x31\x75\x06\xac\x44\x8e\xfe\x0f\x73\x4d\x1e\xfe\xc6\x03\x8b\x61\xe2\xae\x7b\xaf\x19\xf5\xf9\xce\xe6\x61\x8f\x3d\xdd\x34\xf2\xff\x3b\xd1\x7e\x83\x4d\xf2\x41\xdc\x78\xeb\xf4\x29\x0b\xed\xf2\x6e\xd4\xd4\x3f\x29\x9f\x1c\x45\x6c\xc1\xb3\xfc\x29\xee\x16\xcd\x48\xba\x0f\x45\x73\xf5\xc9\xc8\xc1\x03\x29\xa4\xa6\xca\xb0\x12\xe1\xda\x10\x77\xcb\x85\xd9\xdc\x5a\xfe\xd4\x5c\x22\x8f\xaf\xe2\x2b\x30\x22\xfc\x17\x81\x1b\x74\x95\xbc\x06\x60\xd3\x00\x8d\xd7\x83\x9d\x07\x52\x00\x43\x37\xc6\x3a\x9d\xf9\x40\x4a\xa7\x14\x6a\x5a\x5e\xed\x50\xb0\xa7\x04\x4a\x95\x2e\x1b\x42\xae\x18\xb3\x0e\xa3\xbd\xf3\xe6\xed\x7d\xf4\xe6\x9b\x1f\xbd\x61\xea\xa0\x41\x53\xa7\x0d\xbc\xf4\x1a\x6e\xfe\x4d\x8f\xec\x99\x3b\x77\xcf\x23\x37\x0d\xbe\xe6\xda\x4b\x2f\xbd\x76\x9a\xa2\x17\xfa\x12\x21\x28\xe6\x5e\x21\xf7\x37\x83\x51\x52\x8d\x68\xd2\x41\x0d\x22\x76\x02\x22\x0b\xab\xd5\x62\x30\xee\x4f\x19\x88\x57\x60\xcb\xf6\x6f\xb8\x8f\x2c\x66\x67\x79\xd8\xc4\x2f\xe1\x77\xf1\xef\x11\x2d\x4f\xd5\x40\x22\xd7\xc6\x21\xbf\x5c\x43\xa5\x31\xaf\x97\x03\x2d\x2e\x44\xb7\x64\xfa\x39\xd0\x1a\x43\xb4\x47\x9e\x0b\x57\x6f\x80\xab\xe4\x79\x1b\xd2\x63\x37\x6c\xa0\xb2\x1f\x40\x09\x74\x86\x5f\x4b\x24\x72\xac\x54\xeb\x07\x66\x4b\xc0\x02\x70\x50\xe7\x72\x85\x74\x76\x40\x8b\x8a\x1a\xcd\x07\xcc\x47\xcd\xef\x9a\x35\x66\x33\xfd\x13\x1b\xb1\xd9\x6c\xb7\x1b\x4e\xa7\xec\x5f\x00\xff\xdf\x52\xe0\x54\x46\xd0\xb2\x1d\x00\x6c\x0d\xed\xd3\xd3\xec\xf5\xed\x2a\xff\x3a\xb4\x01\x08\xd8\x02\x43\xae\xb8\x66\xd9\xb0\x8a\x7e\x7d\x07\x4c\x36\x2d\xf2\x3f\x70\xeb\x4d\xeb\x7a\x5f\xb7\x71\xd2\xd5\x05\xf0\x98\x03\x25\xa6\x56\x0f\x1d\xd0\x67\x48\xbf\x41\xf1\x44\xf2\xb2\x46\xf3\xac\x79\x37\x37\xf7\xbb\x71\xc2\xe8\xee\x43\xca\x66\x2a\x31\x84\x5a\x54\x86\xfe\x4c\xe8\x2f\x85\x03\xa4\x1f\x0b\x7d\x7a\x31\xec\x72\xd9\x4a\x45\x1f\x5f\x46\xac\xfe\xe8\xde\xe8\x73\xd1\xe3\x51\xbc\x3d\x0a\x57\x47\xe1\x80\xe8\xe8\xe8\xbc\x28\xd6\x45\xe1\x8c\xe3\xd1\x6f\xa2\xbf\x45\xf1\x1f\xa2\xf0\x91\x28\x9c\x1f\xbd\x33\x7a\x7f\x14\x0f\x8a\x8e\x8b\x5e\x17\xc5\xbd\xa3\x10\x46\x97\x8c\x9f\x98\x5c\x18\x85\x43\xa3\xcd\xd1\xe9\x51\xdc\x93\x5d\x1e\xa5\xc9\x94\x5c\xd4\x11\xed\x16\xc5\x7d\x2e\x44\xe1\x87\x51\xb8\x35\x0a\x97\x13\x6c\x51\xd8\x2f\x3a\x32\x3a\x39\x8a\x7d\xd1\x8a\x68\xcf\x28\x36\x47\x21\x5a\x12\x5d\x1f\x3d\x18\x3d\x16\xe5\xcc\xd1\xa2\xe8\xd0\x28\x3e\x1a\x3d\x1b\x45\x20\x3a\x31\x8a\x44\x6c\x23\xde\x0b\x59\x01\xa8\x1a\x68\x06\xd3\x01\xa7\x23\x6e\xa3\xd7\xe8\x2d\x3a\x9d\x02\x85\x50\xa9\xdf\x5a\x52\xc8\x15\x16\x7a\x3f\x2f\xd2\xc7\xf5\x8d\xfa\x03\xfa\xa3\xfa\x77\xf5\x1a\xb3\x9e\xfe\x49\x06\x40\xaf\x37\x1a\x85\xd3\x29\xe3\x17\x1d\xfa\x14\x64\xdb\x14\x64\xbc\x18\x16\xd0\x99\x39\xb3\x79\x56\x76\x0b\xb1\x82\x5a\xcc\x15\xcd\xf9\x1b\x8d\xed\x76\x90\xa9\xef\x99\xd7\xce\x40\xd9\x6a\x63\xa1\x11\x4d\x24\x98\xdf\xc9\x00\x0e\x6e\x98\x74\xcd\x45\x0d\xfd\x26\xd9\x17\x5d\xdc\x3a\x7d\xcd\x5f\x06\x5e\x7e\x68\x83\x7c\xa1\x78\xa9\x6e\xdc\xa5\xa3\x9b\xc7\x0e\xe9\xcd\x79\x47\x24\xab\x1b\x07\xf4\xf5\xfe\x79\xe6\xe5\x4f\x55\x22\x63\x73\xbf\xf9\x1b\xbe\xb5\x24\x2f\x4d\x0d\xae\xbb\x88\x8e\xdb\x01\xee\x49\xb4\x32\x93\xb7\x86\x80\xa0\xe1\xd1\xe6\x71\x66\x3e\xce\x37\xf2\x8b\xf9\xb3\x3c\xcf\xe7\xe5\xad\xd9\xeb\xed\x09\x01\x1e\xc0\xe9\x4f\x78\x79\x15\xf7\xa4\x03\x16\xf9\xe5\x6f\xc9\xfc\x6f\x93\xc7\x70\xfd\xb9\x1e\x20\x08\x77\x48\x1e\x2f\x61\x8a\x68\x30\x84\x41\x11\x8f\x31\x22\x66\x26\x82\xc4\x56\x0d\x85\x69\x7c\xcf\x32\x7f\x49\xf2\xeb\x30\x7c\x2f\x0c\x5f\x0e\xc3\x96\x30\x64\x1f\x7a\x67\xcc\x49\xd6\x84\x2f\x0a\x0f\x0f\xe3\xe2\x30\x44\x61\x5b\x18\x5d\xfb\x65\xf8\xc7\x30\x22\xdf\x4a\x4f\x4d\x9e\x9a\x0c\xd3\x68\x9b\x79\xe2\x55\x49\x0a\x83\xaa\xc9\x65\xec\xca\x25\x92\x6e\xec\xb8\xe4\xcb\xe1\x0f\x18\x24\x81\x18\x3e\x2a\x39\x2b\x0c\x47\x86\x27\x87\xd1\x45\x2a\x44\xcd\xa5\x43\x92\x67\xc2\xbf\x84\xd1\x87\x61\xf8\x7a\x18\x1e\x0a\xc3\xe5\xe1\x4d\xe1\x87\xc2\x78\x74\x78\x4a\x78\x5e\x18\xf7\x0b\xc3\xba\x30\xb4\x85\xc3\x61\xc4\x85\x61\x8f\x9f\xd5\xcb\xba\xd6\x76\x4f\xde\x13\x7e\x24\x8c\xe6\x84\x97\x87\xd1\x95\x61\x08\xab\xc3\x52\xb8\x29\x8c\xb9\xb0\x23\x5c\x1c\xc6\x3f\x86\xe1\x87\xe1\xd3\x61\x74\x8c\x3d\xc5\x2e\x76\xd5\x31\xa9\xb7\x3f\x92\x8c\x87\xa1\x25\x0c\x09\xae\xd3\xe1\x73\xec\x7b\xb4\x3e\xbc\x2b\x7c\x30\x8c\x17\x87\xe1\xc4\x30\x1c\x1a\x86\x20\x4c\xfc\x2c\xab\x50\x28\x34\xa5\x5c\x85\xae\x22\x2f\x14\x45\x62\xb6\xd1\xd8\x6c\x0d\xdd\x60\x69\x68\x68\xcc\xee\xb1\xd0\x9f\x66\xe6\x5b\x55\xa8\x1b\xd0\x4a\x3c\x30\xbb\x31\xad\x04\x03\x2b\x66\xd2\x40\x60\x45\x45\x26\x0e\x48\x0b\xe6\xf2\x3c\x92\xcc\x4e\x0d\xed\xaf\x03\x13\xf9\xdb\x23\xaa\xfd\x41\xb5\x69\x84\x19\xdb\x18\xc2\x92\xc3\xb7\x8b\xbb\x67\x3c\x5c\x38\xaf\x65\xbb\xae\xc1\x50\xe9\x4a\x26\x2e\xed\x83\x96\xb6\xf4\xb9\xdc\x3d\x41\x1e\xc3\xff\x35\x3d\x5c\x2a\x39\xf8\xe2\x83\xe8\xca\xd6\x4f\x62\xb1\xa4\x76\xa9\x63\xd2\x15\x2f\x94\x97\xc8\x85\x4c\x07\xac\x97\x7f\xe5\x6a\x89\x1f\x66\x06\x5d\x24\x37\xaf\x41\xd0\x0c\x35\x7a\xce\x62\xa5\xad\xee\x0e\xa4\x04\xc1\x88\x35\x10\xd0\x38\x78\xa6\x1e\x20\x1b\xed\xb2\x46\xd8\x3f\x45\xad\x87\x9c\xb8\x65\xc6\x27\x33\xf7\xbc\xfc\xda\x7e\x94\xe0\x7d\xbf\x7d\xae\x89\xfc\xf6\x39\x7e\xf1\xb9\xc7\xf6\x1e\x9d\xc2\xee\x73\x89\x3c\x06\x7e\x49\xde\xd9\xc1\x45\x52\xd4\x6e\x13\x6c\x18\x3b\x1d\xc0\xbc\x26\x05\x68\x57\x30\x00\xf4\x66\x5b\x91\x8d\xac\xc7\x36\x5e\xbf\x26\x15\xe4\xab\xf9\x63\x3c\x66\x72\x0c\xd8\x94\xa4\xc6\x5a\x46\x61\x77\xad\x66\xf5\xa1\x21\x35\xf0\xcd\x0c\xb4\xfa\x04\xec\x33\x6c\x98\xfc\x7e\x4d\x77\x67\x75\x74\xdc\xa0\x9b\x2a\x4d\x57\x5f\x37\x91\x4f\xf6\x7c\x49\x18\xa7\xa9\xac\x4a\xa2\x27\x28\x0d\xbd\x89\xbe\xbe\x95\xd6\x96\x40\x8f\xe4\x63\xfd\x60\x56\x1b\xe0\x62\x03\x6c\x32\x4c\x34\xa0\x6e\x86\x7e\x06\x64\x31\x04\x0d\xc8\xc0\xb6\x44\xe6\xde\x9c\x3c\x66\x80\x0f\x19\x5a\xd8\x07\x4b\x24\xc7\x8d\x33\x93\x23\x0d\xb0\xda\x20\x19\x10\x67\x70\x18\x8a\x0d\xf8\x1a\xfa\xc5\xd3\x57\x4e\x4d\x3a\x0c\x90\x5e\xf4\xd4\x15\x93\x92\xec\x62\xd3\xb0\xd1\xc9\x25\x06\x38\xd2\x30\xd9\x30\xc7\x80\xd9\x47\x7d\x93\x83\x92\x3f\x1a\xe0\x1c\xc3\x26\xc3\x43\x86\x57\x0d\x1f\x1a\x4e\x1b\x34\x13\x29\x48\x0e\x23\xea\xfe\xb8\x01\x72\x04\x31\x25\x65\x93\x81\xa7\x90\xe7\x0c\x98\x40\xa1\xf7\x94\x1b\x48\x25\xee\xc2\xa4\xd9\xd0\x6c\x98\x6e\xc0\x02\xa6\xcd\x6c\x4e\xa7\xf4\xa7\xf8\x46\x6e\x28\x47\xd6\x3d\x8b\xda\xce\xe6\xb3\xf6\xed\x6c\x94\x50\x40\xb6\xc8\x49\x11\x40\x22\x79\x15\xd9\x10\xb4\x1a\x07\x50\xdb\x13\xd8\x85\x46\xd6\xb9\xa4\xb7\xe3\xe4\xbc\xbf\x15\x7c\xbf\x70\xfd\x9f\x9c\x28\x71\x1d\x9a\xb4\x6a\xd9\x9d\x69\xff\x75\xac\x3e\x86\xd8\xe8\x75\xc4\x46\x37\x82\x02\x50\x2b\x05\x6c\x3c\xef\xf3\xe8\xf5\x85\x82\xe9\x74\x4a\xf8\x02\x38\x4e\xa7\xd6\x03\x48\xac\xbd\x20\x98\x48\x80\x99\xf9\xfd\xbb\x86\x3f\x2c\x9c\x6c\x53\x8c\x6a\x84\x59\xd5\xb5\x52\xa0\x5d\x0a\x37\x6e\xd8\x6e\xec\x07\x87\xd3\xdf\xa7\x9b\xaf\xef\xb3\x6b\xd2\x8d\x8d\x63\xd0\xea\xed\x77\xf5\xec\x0f\xaf\xa4\xbf\xe5\x1d\x68\x77\xf3\x3b\xa3\x5b\xae\xfa\x78\xc4\x84\x21\xcc\x36\xe0\x89\xad\x5c\xa2\xda\xca\x03\xa5\x72\xb3\xc9\xa4\xd3\x5b\x0c\x1a\x5a\xa5\x8a\x05\x01\x1a\xf4\x9c\xcd\xae\x27\x50\x67\xc7\x99\xa8\x96\x9c\x4e\xb4\xe4\x51\xfe\x14\xaf\xe1\xb3\x76\x72\x46\xac\x13\xd9\x5c\x20\x62\x96\x46\xea\x69\xd2\x2f\x14\x60\xe6\x0d\x5a\xb2\x43\x80\x5b\xc8\x84\xd9\x06\xf5\x86\xd6\x35\xbb\x94\x3f\x76\x40\xc1\xb0\xb6\x0c\x4e\x87\x73\x9c\xf2\xda\x46\x79\x63\xf6\x2d\xa0\xf1\xcd\x89\x00\x68\xaa\xf9\xa5\x96\x52\xb0\x30\x02\x2c\x65\x42\x1a\x93\xcf\xad\x82\x96\xc7\x13\xd2\xef\x00\xdd\x53\x18\x59\x3d\xa0\xb1\xb6\x96\xc2\xc6\x09\xec\x4c\x05\xf6\x67\x05\xd6\x48\x61\xc1\x1c\xbc\x9a\xc0\x0a\x87\x90\x99\x82\x02\x86\x77\x25\xc3\xbb\x96\xc0\xce\x1d\xf1\x7b\xbc\x2e\xc9\x80\x51\x95\x07\x36\x46\xe1\x59\xb2\xfa\x5a\xc7\xcf\xac\x65\x37\x21\x76\x94\xfc\x30\x67\xe6\x7a\xb2\xbe\x05\x93\xa5\x1e\x0e\x6c\x10\x8b\x82\x05\x3e\x5f\x50\x24\x8a\x32\xe2\x00\x80\x75\x2e\x08\x4a\xa1\xe0\xf6\x71\x21\x33\xdd\x5c\x0e\x16\x48\x05\x4d\x05\x7c\xb6\x79\xc1\x74\x00\x9b\x68\x28\x83\x36\x67\xc8\x66\xb3\x76\xde\xc3\x20\x3b\xd4\xd4\x88\x21\x2c\xa4\xcd\x0c\x50\xc6\xbd\xd4\x70\x76\x1a\xa6\xfd\xa9\x7d\x17\x83\x69\x57\xc4\xd5\x2e\x06\xf2\x4f\x2f\x97\xbd\x52\x26\x3f\xcc\xba\x18\x0c\x0a\xab\x5d\x0c\x7a\x8e\xb8\xf2\x22\xb5\x8b\x01\x7f\x0f\x8d\xe9\xb6\xb5\xb5\xed\x27\xb6\xe1\x7f\x34\x3f\xda\x4a\x41\xb1\x8d\xf2\x20\x0d\x6b\xa8\xa6\x91\x44\x64\xe2\x4b\xd1\xbf\xcd\x36\x4e\x28\x81\x15\xb5\xa0\x42\xe1\xdd\xef\xe0\x65\x48\x8b\x3c\x9d\x2d\x0c\xfc\x59\xb8\xb8\xc5\x64\xcd\x5d\x91\x85\x97\xb3\xf0\x6d\x70\x98\x02\x6f\x66\xf0\xc6\x16\x87\xa9\x23\x3c\xaf\x15\x34\x19\x78\x1d\x82\x13\xf2\xf1\xd7\xb5\xb8\xc3\x9d\xe0\x3f\x94\x85\x87\x90\x1e\x63\xec\x7d\x1a\xd3\x0b\x30\xb9\xa2\xa6\xc5\x66\x51\xae\xa0\x97\xb0\x6b\x58\x2f\x00\xcd\x05\x7a\x0d\x1d\x77\xb4\x0d\xee\x24\x32\x51\x25\x39\x31\x8a\x90\x35\x7c\xb3\x03\x8e\x70\xc0\x84\x03\x3a\x1c\x90\x77\xc0\x67\xa1\x27\x43\x24\xd3\x00\xb5\x8a\x38\x00\xd4\x76\x00\x00\xad\x9d\xe9\x7f\x07\xb8\x4f\x1a\x61\x47\xd8\x8a\xc9\x2f\xde\x6a\x05\x06\x9d\x51\xab\x85\x0e\x8b\xc5\x08\xf4\x26\x80\x39\x8d\xc6\x45\x3c\x4e\xa7\x55\x6b\xe1\x2d\x13\x53\x08\x3a\x60\x73\xca\xee\xd0\x19\x9a\x53\x47\x74\xf0\x4e\x1d\xbc\x99\x26\x23\x42\x2d\x76\xe8\x1c\xc4\xa3\xc0\xc0\xd8\x9c\xe2\x94\x1a\xdf\x1a\x65\x13\xa5\x21\x9e\x2d\x0e\x07\x89\xcc\xff\xd9\x4a\x09\x25\x61\x94\x40\xd5\x64\x62\x92\xe4\xc5\x72\xc7\xb1\x63\xac\x0c\x19\x46\xf2\xca\xc8\x61\x44\x80\x21\xdc\x3c\x2c\xfd\x95\xfc\xcd\x5b\xf8\x28\xf7\x70\x20\xed\x1f\x8b\x1e\x0d\xa4\x53\xcd\xd8\x50\x94\xae\xb8\x77\xa5\xfc\x22\xfc\x44\x69\x5f\xa0\x96\x97\x73\x3f\xfc\x59\xf6\x91\x79\x33\x93\xac\x88\x1f\xf0\xf7\x10\xbe\x95\xb2\xb9\xb5\x00\xde\x4e\x78\x6d\x7a\x8e\x98\x44\x37\xb7\x14\x07\x05\x13\xe5\x32\x81\x63\x75\xf0\x4c\x46\xa2\x40\x91\xa9\x4a\x45\xa6\x88\x73\x5c\x0a\x67\x18\x2d\x00\xe5\xcb\xd4\xef\xe0\x65\xf8\x56\x1e\xfc\x0f\x06\x73\xa7\xf0\x72\x16\xbe\x0d\x5e\xae\xc2\x1b\x09\xfc\x66\x9b\xa1\x53\xf8\x43\x19\x78\x22\x23\x14\xde\x2d\x11\x07\x88\xdc\x00\xc1\x87\x2d\x26\xe5\x0a\x45\x42\xd8\x35\xb4\x1e\x7b\x24\xa3\xa9\x52\x79\x86\xb6\x85\xea\x3d\x38\x72\x8f\xcb\x79\x6d\x87\x7b\x0c\xa3\x67\xc8\x67\xe1\x35\x5a\x79\x12\x95\x5a\x06\xfc\x2c\x2c\x6a\xe1\x84\x4e\xe0\x0b\xd8\x33\x28\xf0\x6d\x2f\x2a\xd8\x79\x72\xc1\x26\x3d\x97\x83\x56\x61\x45\x46\x3f\x83\xd5\xc1\x57\x55\xea\x39\x4a\xfd\x5e\xad\xa6\x1d\xf5\x88\xe6\x0d\xf1\xf7\xb3\x1a\x46\x1f\xb8\x5a\xea\xe9\xc6\x3a\x83\xd5\xc4\xf9\xb4\x3e\xa3\xd1\xa6\xc5\x5a\x7f\xa1\x55\x67\xd0\x35\xa7\x4c\x66\xc3\x50\xc3\x62\x03\x36\x1b\x1a\x0d\x07\x0c\xa7\x0c\x9c\x1d\x1b\x0c\x36\xa3\xd1\xd7\x9c\x32\x62\xad\xad\x5d\x9b\x04\xd5\xba\x9f\x99\xc8\xab\x6c\xcc\xaf\x24\xc8\x34\x4f\xa0\x69\x31\x3e\x45\xda\x94\x22\xcd\x48\x08\xb5\xd2\x26\x0a\xaf\xc9\xcb\xfe\x95\xfe\x74\xd1\x96\xc0\x96\x79\x03\xe1\x3d\x01\xf9\xda\x89\xb0\x5a\xe9\xa6\x20\xff\x47\x69\xa7\xf0\xad\xbc\xf5\x4d\x74\xc7\x16\x34\x31\xbd\x6b\x8b\x6c\x53\x9b\x2a\x64\xc7\xef\x4d\xa6\x13\xba\x02\x45\x27\xdc\xa5\x8e\x05\x99\xe3\xf0\x69\x77\x98\x37\xb4\xe3\x2d\xab\xcd\x65\x63\x51\xa3\xca\xdf\x10\x55\xa7\x15\x12\x86\x75\xf1\x07\xf5\xf8\x7f\xc2\xcb\xa8\x24\x0f\xfe\x6f\x85\x45\x9d\xc2\xcb\x59\xf8\x36\xb8\x59\x85\xf7\x13\xf8\x1b\xc2\x85\x9d\xc1\x33\xfa\x6b\x54\xfa\x5f\xca\xc3\x7f\xb8\xa4\xba\x53\xfc\x87\xb2\xf0\x10\x3e\xa0\xc8\x2b\xa6\x17\x60\xb4\x32\x18\x50\xae\xc8\xc8\x2b\x59\x52\xf6\x81\xaf\xb8\xde\xdc\x6c\xe2\xe3\x97\x48\x36\x8d\x96\xd3\x13\xeb\x01\xea\xc9\x9a\x66\x34\x00\x1a\x9b\xf6\xc6\x67\xb6\x6b\x90\x63\x27\xcb\xb2\x0e\xba\x75\x90\xa0\xdf\x07\xaf\x94\x77\x5d\x03\x27\xc0\x09\xd3\xe4\xdd\x70\xe2\x14\x79\xa7\xbc\x0d\x5e\x0a\xaf\x84\x13\xa7\xca\x3b\x61\xf3\x34\xf9\x21\x79\xd7\x34\x38\x49\xde\x0e\x70\xdb\x9b\x6d\x6f\x69\xb6\xf2\x47\x80\x13\x04\x40\x19\x18\x25\x55\xdb\xfd\x61\x2d\xa7\x73\x38\xc4\xc2\x10\xe0\x9c\x7a\x67\x4c\xa7\xd7\x47\xc3\x85\x21\x3f\xe7\x2a\xb6\xba\x88\x10\x89\xc0\xce\x69\x1c\x56\x4e\x53\xdc\x9c\xd2\x69\xec\xb4\x5a\x07\x28\xb9\xee\xb9\x74\x35\x55\x94\x6a\xd4\x1d\x05\x97\x93\x56\x49\x87\xcb\x84\x48\x89\x5a\x53\xe0\xae\x4f\xf0\x2c\x0e\xe4\x86\xa5\xf6\x6e\x65\x90\xd5\x00\xf3\xeb\xa6\xb2\x7a\xe9\xd6\xfb\x1f\x78\x01\x72\x53\x4f\xc2\x05\x3f\xfc\xba\xed\xd1\x63\xad\xad\xb4\xf8\xb7\x0b\x9e\x72\xc3\x77\x5d\x5a\xb7\x4c\x7b\x96\x16\x01\x73\x87\x37\xbc\xcf\xaa\xa7\x6f\xd9\x2e\x6f\x3e\x45\x4b\x7f\x17\x3f\xf8\x22\x2d\xfe\x5d\xd9\x8c\x87\x4f\x90\x47\xac\x98\xd0\x7a\x70\xdc\x7e\xaa\x17\x08\xff\x59\x7d\x28\x93\x87\xee\xaa\xfc\xa4\x54\x79\x73\x11\x79\xeb\xe5\x2e\xc0\xb6\x76\xe3\xd5\x11\x5e\x86\xad\x79\xf0\x2f\xba\xbc\x9d\xc2\xcb\x59\xf8\x36\xb8\x42\x85\x77\x13\xf8\xe6\x42\x57\xa7\xf0\x87\x32\xf0\x44\x1e\x96\x65\xf4\x97\x8b\x6a\x80\x1b\x0a\x3c\xca\x15\x79\xfa\x8b\xd5\xf7\x31\x9a\x7a\xa9\x34\x1d\x52\xef\xa1\x23\xf7\x18\xad\x23\x46\x70\xee\x1e\x6a\xdd\xb3\x8f\xf5\x68\x70\x80\xfe\x52\x99\xc1\xe8\xe0\x38\x0c\x31\x42\x00\x5a\xb4\x50\xeb\x74\x19\xc9\x5a\xc5\x39\x9a\x53\x66\x63\x91\x11\x19\x89\x87\x83\xd8\xfa\xd4\xc8\xb6\x8c\xf2\x9b\x70\x66\xf6\x85\x12\xb4\xae\x2e\xa4\x56\x93\xd7\xab\xa5\xe4\x32\xed\x81\xd1\x15\x5e\xf2\x3d\xd4\x2a\x05\xe5\x81\x5c\x31\x79\xeb\x89\xe7\x3e\xbb\x70\x2f\x2b\x24\x27\x5e\x63\xdb\x5f\xb9\x25\xfc\x09\x50\x0d\xc6\x4a\xd5\x11\x83\xc1\x13\xab\xae\x06\x7e\x6b\x4c\x10\xac\x00\x77\xad\xf1\x1b\xe2\x30\xc6\x73\x0e\x47\x41\x53\xca\xec\x81\x66\xec\xf1\x38\x5c\x5c\x65\x53\x8a\x23\x57\xb0\xec\xf0\x76\xd9\x87\xee\x0e\xcd\x72\x94\x9c\x71\xbb\xda\x36\x51\x89\x47\xbb\xb3\x5b\x30\xae\x4c\x46\x22\xa4\x5b\x30\xcc\xb2\x66\x5b\xab\xe1\x37\xe3\x90\xff\xec\xc9\x8f\xb6\x4e\xec\xd9\x67\xe8\x9a\x3f\xbf\x34\xfa\xc1\xea\xee\x73\x6e\xbb\x71\x9e\x74\xe9\xc0\x8b\x86\x0c\x1e\x3e\xe0\xe6\x29\x1b\x1e\x0a\xbe\xce\xe1\xef\x3f\xdb\x7d\xeb\xbd\xd3\xfa\xf6\x29\x8e\x8e\x1a\xb8\x6c\xcd\xce\x43\x41\xf7\xba\xba\xab\xc6\x75\x9f\xda\xb7\xf1\xba\x86\xc1\xb3\xaa\xaa\x53\x3d\xfa\x8f\xdd\xf9\x60\x2b\xa6\xe3\xd4\xad\xed\x3b\x2e\xc1\x9f\x26\xe3\xd4\x4f\x43\xd7\xd4\x8b\xe1\x28\x55\x37\x74\xb7\x96\xa2\x09\x0d\xbd\xc4\xb2\x76\xb2\xd0\x11\x7e\x1e\xbc\x21\x0f\xfe\xa3\xee\x3d\x3b\x85\x3f\x99\x81\x47\x2b\xa1\x4e\x85\x6f\x20\xf0\xd3\xfb\x74\xef\x04\x7e\x00\xff\x42\x16\x7e\x07\x74\xe4\xe1\xdf\x24\x0d\xea\x14\xff\xc2\x2c\x3d\xd7\x42\x7d\x46\x57\x91\x0b\x30\xba\xa3\x57\x0f\xe5\x8a\x3c\xd9\x64\xd7\x68\x66\x67\xef\xb1\x0d\x86\x33\xd7\xf4\xa4\xd7\xec\xcd\x50\x95\xd5\x6f\x18\x04\x89\x4e\xfc\x80\xbb\x8c\xd8\xf9\xbd\x40\x3f\x70\xb7\x94\xa8\x36\x17\x80\xb2\x7e\x9a\xde\xb5\xbd\x2b\xb5\x3a\x5d\x65\x28\x5c\xeb\x72\x85\x2b\xf1\x80\xfe\x7d\x03\x25\x81\xa6\x14\xad\x70\xea\x07\x9a\x52\xfd\xfa\x79\xbd\x5d\x87\xa5\xbc\x5e\x5b\xac\xec\xd9\xb6\x7f\x48\x3e\x9d\x29\x59\x56\xd2\x14\x82\xe6\x10\x14\x71\x28\x54\x62\xe1\xbb\xdb\xba\x13\x21\x32\xd8\x68\xd2\x6a\x22\x6f\x43\x9e\xb6\xd0\x4a\xb0\x9d\x0e\xb6\xef\xd1\xae\xb2\xbf\x5d\xe3\x68\x45\x69\xb5\x2f\x85\x2a\x53\x9a\x70\x66\xca\x0c\xb3\x11\x48\xb7\xda\x2c\x59\x28\xc9\x98\xf3\xc4\xb8\x2f\x51\xab\xa5\xf0\xe7\x1a\xbc\x70\xfe\x98\xb5\x95\xab\x2e\xf9\x70\xf3\xbd\x2f\x46\x26\xfd\x78\x57\xf3\xba\x21\xd0\x0c\xcb\x7f\xb0\xbf\x77\xcb\x62\xff\xa1\xf8\xdf\x5f\xf9\x62\xea\x2d\x9f\xbf\xf2\x67\xb3\xb6\x75\xf6\x3b\x1b\x1f\x18\x32\xfe\xb2\xab\x1f\x9f\x6d\x41\x32\x37\x6f\xfa\xc2\x3d\x61\xa5\xa0\x6a\xdc\xd8\xc6\xe5\x37\xad\x59\xb2\x7a\xe9\xe0\x3b\x47\x3d\xf7\x02\x8f\xaf\xf4\x1f\x1a\x39\xd6\xbf\x71\xc5\x8e\x1d\xef\x1d\xa9\x5e\x18\x2e\xe2\xb8\xba\xeb\x86\x0e\xb9\x22\x75\xff\xe8\x57\x93\xb7\x2c\x7f\x6c\x07\x1b\x93\x8b\xe5\x31\xb4\x26\x8f\x8c\xc9\x00\xc5\xb6\x03\x59\xdb\x6e\x79\x4b\xb0\x50\x6b\x56\x6d\x3b\x56\x57\xc6\xe4\x2f\x09\x14\x79\x2d\x57\xe5\x23\x44\xe4\xa3\x3a\x5c\x62\x76\xb5\x93\x8f\x8e\xf0\xf3\xe0\x94\x3c\xf8\xb7\x42\xc5\x9d\xc2\x9f\xcc\xc0\x13\x79\x45\x2a\x7c\x98\xc0\x5f\x5d\x16\xea\x14\x7e\x61\x16\xff\xb5\xe0\xa7\x8c\x2c\x85\xa8\x2c\x5d\x5f\x12\x51\xae\xc8\x93\x3f\xa2\xcd\xe1\xbf\x18\x4d\xff\xa2\xf6\x14\xb8\xb8\x55\xb5\xec\xac\xa5\xb0\x30\xdf\xb2\x53\x60\xd1\xa9\x3c\xd8\x79\x63\x72\xb0\x1f\xe7\x5b\x75\x04\xb6\x07\x81\x3d\xc9\x68\x67\xb0\x68\xe5\xf7\xaa\x4d\x47\x60\xaf\xed\x60\xd3\x51\xbc\x1f\x30\xba\x15\xbc\xd7\xfe\x96\xb1\xe9\xc8\x63\xc2\xbb\x7e\x67\xd3\x5d\xdc\xf6\x13\x17\x20\xfa\x30\x00\xba\x80\xeb\xa4\xa8\x1f\x03\x42\xa9\x46\x10\x23\x11\x5b\x85\x57\xb4\x89\xf1\x6a\x57\x51\x53\xca\xeb\x2a\x24\x72\xcf\x69\xfc\x6a\x33\x48\x3f\x0d\x7c\xd8\x89\xc8\xbb\xfc\x2e\xbf\x19\x99\x4b\x89\xa0\xbb\x34\x1a\xc2\x52\x22\xe2\xb9\xcd\xd0\xdc\x8e\x4c\x45\x7b\xdb\x8e\xe6\x8e\x97\x25\x5c\xee\x12\x33\x74\xd9\xd4\x5a\xd1\x4c\x0a\x7c\x17\x58\xc6\xd7\xdb\x73\x4d\xdf\xe8\x9e\x34\x9a\x39\xf1\xaa\x83\x43\x86\x42\xc1\xbe\x77\xee\xe4\xa5\x3f\xbe\xfc\xc6\x57\x4b\xbf\xdb\x3f\x74\x43\xc4\x9e\xea\x21\x9f\x75\x6e\xbf\xf9\xbe\xa6\x5b\xe7\x4e\xb8\x2d\xd5\xad\xef\x3c\xbe\xfa\xf2\x8b\xca\x1a\xa7\x5c\x7f\xf1\x6a\xf9\xdb\x87\x3e\x90\xef\x79\xfc\xeb\x63\xbb\xa0\x7d\x6d\xcf\x2e\x33\x5f\xbd\x68\xe6\xcd\xf2\x94\x19\xff\x9c\x7e\xdb\x9a\x7e\x6b\xbf\x1e\x5e\x7f\x65\x0f\xca\x2f\x5a\xe3\x71\x09\xd3\x4b\xc3\x80\xa2\x97\x9c\xea\x7a\x56\x48\xb8\xbb\xaf\x38\xae\xf7\xb4\x93\x8b\x81\x44\x2e\xba\xb3\x71\x1b\xae\xea\xd5\x6e\x19\x1b\x8d\xca\x69\x20\xa4\x05\xff\x13\x3e\x27\xa7\x14\xfe\x25\x7f\xb0\x53\xf8\x93\x19\x78\x22\xa7\xa2\x0a\x1f\x20\xf0\x93\x23\xfe\x4e\xe1\x5f\xc8\xc2\xef\x00\xff\xce\xc3\x7f\x6d\x49\x75\xa7\xf0\x0b\xb3\xf4\x5c\x0b\xd2\x19\xb9\xf6\x53\xb9\xbe\x21\x54\xa4\x5c\x91\xa7\x23\x87\x83\x53\x5c\x2d\x37\x97\xed\xd3\x8b\xa0\xab\x14\xd0\xea\x9e\x48\x01\x6d\x93\x16\x11\x7b\x9e\x93\xe8\xde\x0e\x04\x4f\xa4\x86\xc2\x9d\x10\x41\xda\x9b\xfb\x1d\xb2\x70\x67\x7b\x44\x92\xb1\xae\x4d\xb0\xdd\x1b\xf6\x7a\x76\x4f\xfa\x0f\xf8\xaf\xe9\x23\x7b\xf0\x8b\xcf\x3c\x23\xef\xbe\xfb\x6e\x79\xf1\x33\xcf\x28\xf7\xa9\x6c\xfb\x0b\xd7\xc2\x5d\xa1\xda\x80\x37\x4a\xfd\xec\x61\x2f\xb5\x01\x75\x7a\x87\xd3\x09\x3c\x21\x51\xaf\x89\x45\x1d\x2e\x87\xa7\xd8\x83\x34\x1e\xe8\x0f\x55\x85\x10\x26\xfa\xd6\xcc\x7b\x43\x9e\x30\x57\xec\xb3\x16\x37\xa9\x76\xa1\xd5\xa5\xb3\x68\x7c\x4d\x29\x8d\x5a\x20\xd8\x98\x35\x0b\xd5\x0a\x25\x4f\x63\x4e\xdb\x32\x81\xac\x57\x6b\x60\x88\x45\xc8\x32\x6d\x50\x88\xda\x89\x90\x1a\x86\x34\xd7\xab\x44\x31\x0e\xeb\x6c\xc7\x07\xd3\x7a\x98\xdd\xd3\x06\x3c\x7a\xf7\xa5\x05\x37\xca\x7d\xb7\x5c\xd3\xf4\x28\xd4\x9b\x51\x61\xe3\x35\x77\x3c\x78\x39\xba\xc5\x94\x3e\xdd\x38\x6d\xe5\xd6\xd4\x86\x1b\x1e\xa6\xe5\x31\x17\x0f\xdf\x3b\xf5\x81\x6b\x6f\x94\x03\x97\x4c\x80\xaf\x0f\xac\x43\xb3\x6b\x57\xcb\x67\xee\xb8\x28\x91\x5e\x5b\xbf\x02\x9a\x95\x31\x61\x39\xfb\x4c\x46\xc6\xaa\xba\xef\xa2\x3c\x19\x24\x7e\x85\x47\xdf\x6e\x0c\x3b\xc2\xcf\x83\x37\xe6\xc1\x3f\x57\x58\xd4\x29\xfc\xc9\x0c\x3c\x91\x29\xb7\x0a\x4f\x86\x1c\x4e\x0c\x17\x76\x0a\xbf\x30\x8b\xff\x5a\x68\xcd\xd8\x85\x85\x54\x8b\xcc\x0a\x06\x94\x2b\x72\xba\x4f\xc9\xa1\x66\x34\x5d\xa1\xd2\x94\x54\xef\xe1\x21\xf7\xf8\xd6\xe3\x43\xf6\x7c\xbb\x50\xa9\x11\x52\xeb\xa1\x87\x48\xb1\x62\x87\x23\x6a\xf4\x63\xac\xd5\xeb\x75\xb4\x55\x49\x19\xf6\x1b\xb1\x15\x58\x3d\x4d\x29\xab\x45\x4f\xdb\x1c\xf8\x40\xf0\xbf\x15\x0a\x65\x3d\xc6\x5c\xb5\x50\xb6\xca\xf3\x7f\xd7\x0a\xe9\xed\xc3\x9f\x82\xb3\xd5\x9a\xf3\x4e\x8a\x85\x46\x4f\x90\x53\xc2\x5c\xa5\xde\xfc\xbf\xd4\x0a\x65\x9f\x7d\x61\xf6\xd9\xaf\x05\x9f\x64\xf8\xe5\xa1\xfc\x5a\x5f\x58\xa0\x3c\x7d\x1e\xbf\x94\x58\xd1\x03\xd9\x58\xd1\x6a\xf8\x14\xbc\x2c\x17\x8f\x2a\x6a\x31\xb7\x8b\x77\x29\xfd\x0c\xf8\x11\xd4\xb6\x51\xe1\xc5\x3c\xfb\x69\x75\x43\x07\xfb\x4c\xc5\xff\x6d\x06\xbf\x8e\x83\x2f\xe4\xc7\xbb\x2e\x6d\xb1\x7a\x3a\xc1\x7f\x26\x8b\x7f\x0b\xf1\xed\x72\xf8\xf7\xf4\xbc\xa8\x23\x7e\x79\x14\xed\x7b\x99\xa5\x7f\x3b\xb6\x91\x2f\xc4\xa7\x11\x70\x10\xc3\x8e\x81\x32\x59\xea\x22\x37\xd3\x3e\x0c\x59\xbc\xdb\x51\x0c\xe8\x29\x5c\xb8\xb1\x31\x12\xc9\xc1\xb1\x3e\x90\xcc\xaf\x28\x55\x7d\xe5\x11\x8c\x5e\xe8\x67\x91\x8e\x58\x8b\x5f\x8d\x03\xa9\xf4\xd2\x5a\xff\xb3\x4c\xde\x06\xa8\xf2\x36\x55\x95\x37\x2f\x91\xb7\xef\xbc\xaa\x65\x01\xda\xe3\x97\xb3\xf8\xdb\xe0\x7e\x15\x3e\x40\x6e\xb0\x35\xe2\xcf\x61\x07\x19\xfc\xdf\xb0\x39\x33\x40\x99\x33\xe0\xb4\x0a\x5f\x40\xf0\x4f\x2d\xf2\x76\x8a\xff\x91\x0c\x7e\xb4\x15\x19\xc1\x5f\x94\x39\x46\xf0\xef\xf3\x17\x75\x8a\xff\x44\x16\xff\xd6\x8c\xde\x66\x73\x78\xb7\xd7\xf7\xbf\xe9\xd7\x01\xb8\x27\x33\x87\x09\xfe\x57\x8b\x4a\x3a\xc1\xff\x6b\x1e\xfd\x77\x82\x8f\xf3\xf8\xb3\xd9\x17\xea\x80\x9f\xf5\xb6\x64\xf8\xcb\x54\xfc\xb5\xea\xf8\x3b\x88\xc0\x6c\x20\xeb\x3f\xee\x60\x1f\xfd\x93\x7f\x83\x3f\x61\x29\x05\x97\x30\x7e\x5e\xc0\x2f\x81\x41\xc0\x26\xe9\x51\x25\x40\x3d\x2b\x2a\x4c\x0a\x39\x8d\xb5\xca\x1a\x4b\xe3\x46\x36\x0d\xb8\x1b\x28\x3d\x04\xfe\xc9\x5b\xc9\xdc\x37\x81\x2a\xb0\x51\x1a\x18\xf0\x79\xf9\x72\x3e\x5a\x54\x14\x0c\x86\xa2\x65\x06\x9b\xad\x2c\x84\xc3\x5d\xc2\xf1\xb2\xa8\xb3\xd8\x17\xf0\x0d\x4b\x85\xcc\x81\x78\xa0\x31\x30\x34\xc0\x39\x71\x20\xe0\x0a\x16\x81\x02\x97\x4b\x4b\xb5\x81\xc5\x15\x74\xcd\x70\x2d\x71\xad\x77\x69\x44\xcc\xaa\x64\x8c\x2e\x7f\xd2\x65\x29\x37\x9b\x01\x35\x49\xb2\xd5\x00\xcc\x5f\x63\x16\x38\x31\xbc\x95\x5e\xe6\x4a\x6f\x45\xd8\x21\x0b\x96\x2e\x05\x25\xed\xca\xee\xdc\x79\xd5\x79\x2c\x13\x51\xad\xce\x52\xbb\x2c\xc0\xd7\x72\xe5\x77\x35\xd9\x02\xbd\x06\xf9\x43\x2f\xac\xf4\xb7\xf8\x97\x7b\x97\x1f\xa3\xbd\x16\x88\x7e\x99\x97\x5f\x87\xb7\x3a\x53\xa9\x07\xe3\xcb\x36\x6e\x5c\xd6\x1a\x53\x1a\x2e\xe4\xc5\x15\x1f\xc8\xc4\x15\xc9\x5c\xff\x80\xe8\x86\x4c\xdc\x72\x9f\xb1\x63\xdc\x52\xb1\x55\x47\x64\x6d\xdb\xd5\x10\xe7\xd9\xc2\x0b\xc3\x1d\x6d\x61\x05\xff\xb7\xd9\xb8\x25\x07\x1f\xce\x8b\x8b\xee\x24\x6c\xfb\x3d\xfe\x0a\xa6\x1b\x92\xaa\x6e\xb0\xe4\xe1\xdf\x53\x5c\xd1\x29\xfe\x47\xb2\xf4\x6f\x85\xcf\xa8\x73\x81\xe2\x7f\xc8\x60\xea\x94\xfe\x13\x59\xfc\x5b\xa1\x46\xc5\x5f\x4c\xf0\x6f\x08\x45\x3a\xe2\x97\x47\xd1\x7e\xa8\x59\xfc\xdb\xd1\x55\x19\x9f\x62\x7c\x8b\xdd\xae\xd7\x67\x7c\x0a\x79\x1a\xed\x55\x91\xc5\xbb\x1d\x36\x00\x07\x85\x43\x6d\xbe\x96\x68\x54\xa7\x6b\x17\x57\xce\xc6\x7d\x89\xec\x4f\xca\xe3\xc7\x5b\x26\x47\xa7\xf4\xe6\x7c\x89\x3b\xe9\xce\x7c\x96\x1f\xbb\x22\xb1\x0e\xf4\xb2\x3e\xa6\x0c\x7f\xb9\xaa\x7b\x0e\xa8\xf8\x43\x54\xf7\x94\x06\x71\xfb\xf5\x97\xf5\x83\x60\xf8\x2f\x55\x75\xcf\x0f\x2a\xfe\x6e\x04\xff\xa8\x86\x04\x0a\x74\x82\xff\xdb\x0c\x7e\x1d\x87\x6c\x2a\xfe\x20\xc1\xff\x42\xa4\xbc\x53\xfc\x67\xb2\xf8\xb7\x80\xdf\x54\xfc\x09\x82\x7f\x73\x5d\xef\x4e\xf1\x3f\x92\xc1\x4f\x74\x9b\x59\x1d\x4f\x8a\x7f\x7f\x30\xdc\x29\xfe\x13\x59\xfc\x5b\xa1\x57\xc5\x5f\x47\xf0\x3f\x9a\xa8\xed\x88\x5f\x6e\xa0\x7d\x5e\xb3\xfc\xf9\x0d\x7e\x93\x19\xcf\x87\x5b\x42\xa5\x38\x33\x9e\x0c\xaf\x26\x68\x51\xf1\x6a\x5b\x61\x59\xde\x1a\x75\x5f\x43\xb7\x0e\x78\x59\x2f\x56\xc6\xf7\x0a\x95\xef\x99\xf8\x2e\x8d\xe7\xdf\x6f\x33\x70\xed\xe9\xa6\xbe\xc0\x54\x61\x08\x81\x1f\xa4\xc2\x8b\x60\x28\x83\xf7\xa1\x52\xd8\x16\x2c\x70\x68\xda\xc5\xb6\xfa\x00\xa0\xe9\xc6\x2f\x05\x76\x62\xc5\xcc\x97\x7a\xd9\xec\x0e\x13\x41\x6f\x37\xb9\x69\x9a\xb4\x0e\x73\x9c\xc7\x68\x32\x79\x69\xf9\x25\x44\x6e\xd4\x9c\x72\xb8\x5d\x4e\x1b\xaf\xe5\x9b\x53\x66\x83\xa8\x75\x93\x7f\x7a\x1d\x6d\xf3\x67\xcf\x75\xe3\xa2\x51\xaf\xfc\x23\xc9\x94\x84\x69\x4f\x3c\x97\x05\x4b\x7e\xd5\xe4\x12\x07\x33\xfd\x60\xd5\xb2\x51\x55\x39\x89\x90\x36\xa9\x6b\xbd\x35\x0d\x6f\x3d\xfa\xc6\x96\xc0\x96\xca\xa3\x95\xa8\xad\xf2\x48\xe5\xfd\x81\xfb\xdf\x28\x8c\xa5\x61\x8c\xb6\x89\xe5\xe0\x96\x33\xe4\x67\xcb\x85\x36\x5c\xf5\xe1\x87\x99\x7a\x77\x23\xd1\xcb\x21\x30\x55\xea\x51\x68\x04\xb6\x02\xda\xd8\xcd\xee\x30\x6a\x1c\x9a\x70\x84\xf6\xdb\x08\x38\x3d\xce\x61\x29\x9f\x87\x58\xeb\x16\x1c\xc4\xd8\xec\x81\x67\x3d\x6d\x1e\x84\x3d\xd8\xa3\xf3\x02\xbb\xc3\xa1\xd7\x65\x0a\x11\x95\xa4\xef\x99\xe3\x1b\xac\xea\xbe\x52\x36\x92\xc7\x9e\x80\xd1\xde\x69\x77\x8e\xcc\xb3\x08\x21\x13\x14\xe0\x4d\x4a\x71\xe9\x4d\x87\xe7\xb1\x9a\xd3\x1b\x9f\xfa\x76\x99\x77\x19\x51\xac\xb0\xca\x2b\x9f\xac\x28\xe4\x71\x4a\x2d\x88\xdf\x8a\xc6\x2b\x85\xf2\x7f\xe4\x9e\xa6\x2a\xf5\xb3\x1b\x1c\xea\x1e\xc7\xcd\x2c\x46\xae\xec\x71\xa0\x77\x72\xbb\x2d\xc7\x8c\x9e\x7c\xdf\xb9\xed\x67\x5a\x17\xcd\xbf\x40\xe4\xeb\x5f\xc7\xa9\x9f\xbd\x83\x98\x4c\x83\x5a\xa8\xe7\x5c\xc8\x1a\xe6\x96\x26\xe9\xab\x54\x11\x0a\x25\x0b\x25\xbf\x9f\xfc\xf2\x78\xc8\x2f\xb7\x9b\xfc\x72\x38\xc8\x2f\xbb\x9d\xfc\xb2\xd9\xc8\x2f\x51\x24\xbf\xf4\xfa\x64\x45\xf6\x27\x6f\xcf\x05\x31\xdd\x5e\xa9\xe8\x6a\xd0\x4d\xd5\xed\x94\xa2\x3d\x7c\xc7\xfd\x1c\x5a\xab\xbd\x9e\x1f\x91\xa5\x69\xf5\xcb\x19\x9a\x74\x2a\x4d\xba\x0c\x4d\x3a\x4a\x93\x8e\xd2\xa4\xa3\x34\xe9\x28\x4d\x3a\x4a\x93\x8e\xd2\xa4\xa3\x34\xe9\xfe\x2b\x4d\x7d\x99\xfe\x50\x78\xc4\x95\xe6\x78\xf4\x07\xc1\xd4\x2e\xbe\x40\xe9\xf9\x13\x7f\x26\x4b\xcf\x96\xe7\x33\xf4\xd8\x54\x7a\x6c\x19\x7a\x6c\x94\x1e\x1b\xa5\xc7\x46\xe9\xb1\x51\x7a\x6c\x94\x1e\x1b\xa5\xc7\x46\xe9\xb1\x75\x46\x4f\xdb\x31\x79\x14\xed\x59\x9c\xe5\xd1\xf6\xb6\xf9\xcc\xb6\x84\x40\x14\x31\xce\xda\x8c\x6d\xcb\xe4\x51\xb4\xb7\x07\x81\x1b\xac\xc2\xf5\x52\x6d\x50\xb3\x39\x0f\x8e\xed\xb9\x5d\xc6\xf4\x57\xa5\x6a\x6b\x85\x55\xfd\x45\x9f\x70\x2f\xa7\xc9\xe7\x39\x99\x07\x34\x8e\x73\x8a\x9d\x21\xd1\x4b\xaa\x60\x45\x6d\xb4\xbf\xba\xc4\xd3\xc4\xc5\xf5\xbc\x06\xb0\xb7\x13\xc9\x1f\xb4\x99\xf2\x7b\xfc\x8f\xbc\x0e\x41\xb3\xda\x3c\x24\x01\xc7\x67\xf2\x36\x12\xf6\x04\x4e\x7d\xd0\x72\x52\xe9\xe1\x42\xe9\x20\x7a\xf4\x07\x96\x4b\x40\xe8\xb0\x08\xa0\x0a\x7e\xc1\x3e\x0f\xc9\x63\xf0\xf3\xcc\x96\x1a\xcc\x3e\x1f\x02\x19\x3c\xeb\xb3\xbc\x91\xe9\xaf\x2a\x55\x1f\xd5\x2b\x36\xb1\x9d\xd9\xc4\x7d\x5b\x3c\x36\x9c\xb3\xfa\x58\x8f\x18\xb4\x9d\x3f\x09\x74\x44\x1f\xf5\x93\xc2\x0e\xbb\x1d\x78\x80\x57\xe3\x71\xea\x6d\x76\x33\xa7\xd5\x68\x37\x8d\x43\x1a\xc9\x61\x37\xeb\xc9\x54\xd6\xfb\x04\x2b\x68\x54\xbc\xa9\x82\x77\x6a\x94\xf8\x23\x75\xa1\xb2\x3d\xe9\xc9\xf4\x14\x22\x65\x11\x3e\x42\xcb\xac\xdb\x35\x8d\x41\xdb\xb9\x2b\x8e\x20\xf9\xdf\x73\x38\x18\x38\x91\x7e\xac\x5d\xf3\x18\xee\x35\xc7\xde\xbd\x0e\x68\xfa\x75\x79\x7e\x03\x19\x75\xdd\x6e\xa0\xfd\x9a\xc9\xf3\x74\x51\xf5\xfc\xb4\x8c\x9e\x1f\xdb\x62\xb2\x73\x19\x3d\x1f\x96\x1b\x68\xaf\x19\x02\x77\x99\x02\x07\xde\xcf\xc0\xcd\xc9\xc2\x65\x7a\xd2\xb0\x7a\xf2\x4b\xa5\x62\x28\x92\x91\x32\x68\x70\xb6\xed\x33\x71\x24\x79\x24\x40\x41\xa4\xf5\xc3\xed\x5b\xcd\x64\xea\x87\xf3\xbb\xd9\x65\xbb\x8e\xd0\x1e\x33\xf6\xf6\x3d\x66\x3e\x68\xb9\xba\x5d\x8b\x19\xae\x47\x3a\x9d\x69\x31\xa3\xac\x33\xf8\x34\xf3\x5d\xe2\x8a\xef\x02\x32\xbe\x85\x86\x0c\xd4\x46\x8d\x0e\x70\xed\xe6\x74\x88\xc0\x1b\x84\x46\x02\x3f\x54\xd9\xd3\x8d\x0d\x65\x7b\xba\x88\x8e\xaa\xf3\xf7\x7b\xba\x84\x6f\xb4\xa7\x74\x16\xff\x6f\x50\x9b\xe1\xc7\xc7\x2d\x82\x41\xc1\x4e\xe4\xe5\x79\xb9\x41\x9d\x0f\x43\x15\xb8\xb6\xc9\x19\xb8\xd7\x5b\xb4\x5a\xc5\x2d\x53\xe8\xe5\x7c\x79\xf8\x2e\x20\x1a\xf3\x72\x3c\x45\x58\x48\x08\xb8\x2d\x8b\x92\x25\xb6\xa8\xf4\xba\x98\x7c\x2a\x78\x2f\x10\xfb\x8f\xd9\xfa\x90\x98\x4a\x7d\xb4\x5a\x84\x72\xb6\xbe\xda\xff\x3a\x83\x9b\xac\xfd\x43\xd3\x77\xd1\xb9\x2b\x6b\xb4\x2a\xd6\x0c\x4e\x74\x3e\x87\x93\xcc\xc9\xe3\x0a\x5c\x39\xc7\xa9\xf8\xd8\x5c\x44\x04\xdf\xd7\x6c\xcf\x79\x08\xed\x54\x27\x70\x1c\xd6\xe9\xc8\xb3\x60\x8c\x4c\x66\xce\x28\xe8\x39\xde\x2c\x42\x0b\x16\x79\x91\xc7\x3a\x2d\xc6\xa0\x39\x85\x33\x9d\xb6\x33\xe9\x0d\xb6\xf6\xbd\x58\x98\x8d\x4f\x96\x17\x9a\x55\x45\x46\xba\x44\xe0\x61\x01\x7a\xb3\xa8\x75\xfe\xb4\x07\xfd\x0f\xaf\x3a\x3a\x17\xd6\x14\xc9\xef\x6c\xdb\x86\x0a\x46\xed\x18\x85\x8e\xa7\x1f\xde\xb4\x7d\x73\x86\x16\xf8\x1f\xb2\x3e\x8a\x60\xb0\xe4\x17\x68\x6d\x3a\xa0\x7d\x8e\x88\x23\x6e\x30\x16\x19\xe3\xc4\xdd\xa7\x1d\x36\x91\xd6\x82\x9e\x6d\xfb\x51\xd2\x6b\x91\x16\xd1\x6e\x9c\xaa\x62\xa0\xb4\x74\xef\x6e\x63\x4d\x8e\x6c\xf9\xa4\x24\x54\x3a\xea\xcd\x10\x07\xa7\xdd\x51\x74\xfb\xfd\x2d\xcb\x57\x15\xad\xba\x15\x05\xfa\xed\xe8\x87\x2d\xe9\xb1\xc9\x9d\x97\xa4\x17\x64\xf6\xab\x99\x9c\x75\x55\x7d\x64\xab\xa2\x0f\x4c\x4c\x1f\xf0\x2d\x26\x6b\x6e\xc7\x9a\xc0\x13\x35\xce\x15\x30\x1f\x79\x18\xa7\xf8\xc8\xcb\xf3\x7c\xcc\xb6\xc2\xa2\x0e\xb1\x4d\x3a\x3f\xdf\x64\x63\xd7\x55\x95\xb3\x99\x19\xf9\x19\xd2\x62\x76\x28\xb8\x29\x5e\x32\x3f\x0b\xb8\x21\x19\xbc\xf9\xf3\x73\x7d\x8b\x3f\xac\x60\xcd\xd2\x2b\x67\xf7\xd7\x01\x5c\x0d\x72\xfb\xeb\xaf\x59\x5c\x1d\xf6\xd7\x29\xbd\xe5\xcc\xee\x65\x78\x89\x5d\xad\xcd\xa3\xf7\x85\x40\x71\x07\x7a\x13\x04\xfe\x2e\xa6\x4f\x87\xdd\x4c\xe0\x85\xd3\x6d\xb3\x15\x39\x0e\x11\x39\x6e\xe3\x5b\x82\x41\xa3\x31\x2b\xc7\xb4\xa7\x37\xd1\xbf\x4b\xf8\xcd\xc4\xc3\xed\x2f\x15\xfb\x1c\x5e\x97\xd7\xe3\x71\xba\x4c\xa1\x10\x76\xe1\x68\xcc\x57\x54\x64\x69\x4e\x15\x71\x1e\xec\xb2\xd1\x46\xc6\x4a\x0b\x63\x16\x3c\x6c\xfc\x5d\x42\x1a\x53\x15\xd9\xde\xf5\xb4\xf8\x9a\x98\x2f\xa1\x30\xad\x30\x8e\xf8\x60\x42\x23\x24\xea\x8a\x13\x41\x2b\x6d\xeb\x63\x82\x78\xe4\xf4\xed\x95\x6b\xc3\xcd\x75\xc9\x09\x7d\x4b\x06\x9a\xe4\x1f\x6e\xfa\xfa\x7e\xc7\xfe\xa3\x1f\x36\x3c\x6b\xf0\x73\x93\xa0\x76\x3b\xdc\x6a\x1d\xd0\xed\xda\xfd\x8e\x31\xfd\xae\xaf\xee\x73\xc9\xb6\x23\x70\xc1\x80\xba\xaf\xa7\x3d\x79\x75\xeb\x0a\xae\x1f\xec\x3d\x6e\xd7\x8a\x55\xf2\xd6\x21\xe3\xe4\x7b\xe4\x5f\x8e\x37\x53\xbd\x47\xec\x60\xda\x97\xa8\x04\x0c\x94\x4a\xbd\x16\x97\xcd\xe5\x74\x5a\x6d\x62\x30\x88\x6d\xb8\xb4\xcc\x6b\xf3\xfb\x8d\x4d\x29\xbf\xc5\xe5\x34\x5b\x6d\x1d\x3b\x16\x34\xb6\x3f\xe2\x23\xaf\xc4\x26\xa3\xe0\xff\x7b\x87\x22\xa2\xf8\x93\x19\x5d\x7f\x77\x67\x1d\x40\xb6\x14\xad\x91\xc7\x30\xb5\x8f\x7e\xec\xac\x69\x51\xeb\xf7\x3b\x56\x64\xf3\x10\x1e\xc8\xe4\x21\xa0\xd5\xc8\xad\xd8\x40\x2c\x6f\x61\xad\xbf\x63\x5e\x04\xeb\x71\xc4\xfc\xdb\xe1\xaa\xcd\x74\x2e\x2f\xc6\x3d\x35\xd0\x31\x86\xae\xe0\xff\x36\x9b\xe7\xc0\x21\x03\xc8\xe5\x45\x3c\x58\x54\xda\x29\xfe\x33\x59\xfc\x39\xff\x96\xe2\x7f\x28\x58\xd6\x29\xfe\x9f\xb2\xf8\x31\xaa\x00\xf9\x79\x14\xdf\x16\x96\xb4\xcf\xa3\x50\xef\xb1\x5a\xd9\x07\x60\xf7\xd8\x09\x07\xb5\x8b\xbb\x3f\xef\x2f\xed\x10\x77\x47\xc4\xef\xfa\x45\x6b\xe7\xd7\x10\xfd\x11\x02\xd7\x4b\xbd\x3d\x76\xaf\xc9\x64\xb6\xd9\xb9\xa2\x22\x9e\x77\x58\xb0\x21\x6c\x88\x98\x6d\xcd\xa9\x23\x66\x78\xa7\x19\xde\x6c\x86\x66\x33\xd4\x62\xb3\x59\x04\x3e\xaf\x49\x34\x35\xa7\x74\x22\xf6\xb8\xec\xc0\xae\x9e\x3d\xa0\xf4\x32\xcd\x1c\x91\x97\x77\x2a\x48\x36\x06\x92\x6d\xc0\xab\x89\x64\xce\xca\x70\xe7\x32\xbc\x4a\x6a\xea\xed\xa5\xea\xb1\x19\x78\xd1\xe0\xd9\xf2\x19\xf9\xa5\x8f\xe0\x4d\xdf\xdd\xbc\x19\x4f\x0b\xa4\x7b\x8c\x45\xab\x02\xe9\x79\xcd\xe8\x6c\xe0\xc2\xf6\xa5\xc3\x3f\x1a\x79\xe7\x2b\xf2\x37\x9b\x3f\xd5\xc3\xee\xd0\xfc\x0b\x5c\xf1\xa1\xa8\x26\x7d\x6d\x10\xb9\x41\xe2\x3e\x79\xdf\xd1\xb7\xfe\x44\x63\xfe\xc4\x97\x16\xfa\x72\x97\x91\x27\xac\x02\xb5\x60\xba\xd4\x33\x6c\xf2\x82\x5a\xbe\x4b\x34\x6a\xef\x52\x44\xbc\xa8\x22\x7b\x51\x5d\x3d\xdd\x74\xad\xa5\x6d\x25\x6b\xfd\xb5\xc8\xc1\xd5\xd6\x5a\xdc\x35\xc5\xee\xe2\xa6\x54\xa1\xd7\x6d\xe1\xcb\x2d\xe5\x4d\x29\x93\xc1\x92\xbf\xcf\xaa\xe6\x13\xfd\xaf\x36\x93\xca\xe6\x6a\xae\xb0\x2e\x12\x2c\xd3\x84\xd4\x4e\x58\xc1\x6c\x8b\xb1\x12\xa5\x23\x96\x85\x86\x8d\x33\xdb\xa9\x5c\x91\xb8\xe2\xf6\x89\x5b\xab\x56\x5d\xfa\xe5\x76\xf9\xdc\xb4\x8d\xf2\x37\x6f\x9c\xe2\x56\xff\xfa\x34\xf4\x5e\x3d\xf8\x9d\xf9\x27\xbe\xf6\xb4\x0e\xfd\xf5\x8e\xdd\xa9\x5f\x57\x6e\x4d\x61\x0f\xb7\x68\x01\x6b\x49\x99\xe8\xb3\xe2\xae\x09\xa3\x1a\x57\xcc\x7b\xe9\xf9\x7f\xfc\xf1\x8f\xb0\xf7\x83\xc7\xc6\x4f\xa6\x7d\x29\x5b\x60\x60\xad\x7c\xe6\x36\xf9\xe3\x15\xd0\x7c\x93\xda\xa3\x52\xd5\x9d\x2b\x99\xae\xaf\x55\xf3\x2c\x5e\x56\x65\xd2\x4d\x64\xf8\x63\x77\x01\xa7\xeb\xe8\x27\xe0\x3e\x4c\xbe\x46\x29\xf1\x50\xf0\xb4\xaa\x3b\xed\x44\x77\x1e\xb7\xbb\x04\xdb\xef\x74\xfd\x4a\xa6\xeb\x6b\x55\x5d\xbf\x4a\xd1\xe1\xa8\xed\xf6\x16\x8f\x9f\x53\x63\x23\x6d\x6f\xc9\x0d\xb4\x57\x54\x06\x2f\xb1\x29\x66\x67\x74\xfd\x87\x2d\x6e\xb7\x20\xe4\xe9\xfa\x95\x4c\xd7\xd7\xaa\xba\xfe\xa2\x3c\x7a\xb7\x79\x8b\x3a\xa1\xf7\x5a\xa6\xeb\x47\xb1\x3d\xcd\x3b\x93\x39\x6a\x37\x39\x7d\x39\x6a\xe9\xfe\x27\xed\x47\x2f\x54\x11\xd8\x3a\xe5\xd9\x90\x15\x0e\x64\xd0\x31\xb2\x8e\x9c\x8d\x55\xe2\xf6\xeb\x02\xeb\x2d\xc5\x78\x31\x5a\x8d\x0d\x37\xa8\xbc\x88\x12\xec\x7f\x8f\x56\x68\xbc\xed\xe0\x15\xfc\x05\x19\xfc\x68\x25\x3c\x0c\x2f\x61\xf0\xe5\x04\xff\x86\x78\xac\x53\xfc\x27\x33\xf8\xd1\x4a\xf0\x8a\x8a\x3f\x46\xf0\x4f\xef\x12\xed\x88\x5f\x1e\x43\xfb\xe9\x67\xe9\x5f\x00\x7b\x65\x78\xb8\xb1\xa5\x5a\xa5\x9e\xe2\x25\x7e\xc0\xc7\xdc\xa0\x2c\xdd\x0b\xc0\xba\x0c\xdc\xe1\x96\xb8\x4a\x75\x86\x5e\xc6\xeb\x3a\x95\xd7\x3d\x33\xf7\x27\xf4\x3e\x5f\xd1\xb5\x13\x7a\xbf\xce\xa3\xf7\x4e\x70\x2c\x8f\x1f\x8f\x96\x57\x77\xa0\xf7\x59\x42\xef\x15\x4c\x36\xea\x99\x3f\xb2\x00\xb0\x9c\x5e\x60\x22\xfe\xc5\x12\xbe\x92\x7c\x3e\x86\x75\x87\x58\xf0\x86\x0a\x4f\x7b\xe9\x33\x7a\xea\x55\x7a\x32\xfb\x4b\x5a\x42\xcf\x20\xbd\x85\xd3\xb4\xc3\x3f\x9e\xd0\xf3\x18\xb3\xfd\xc6\xa8\xf6\xe4\x43\xaa\x3d\x19\x00\xf0\x12\xb2\x7a\x65\x57\xed\x5c\x9f\x7e\x33\xb8\x48\x0a\xf3\x1a\xa8\xd7\x6b\x0c\xd8\x62\x32\x59\x45\x62\x74\xd1\xd4\x21\x41\x4f\xd6\x6a\xf2\x31\x6f\xcc\x1c\x3c\x64\x53\x4f\xd7\xca\x75\xef\xcf\xd6\x47\xe0\x6c\x3d\xb9\xda\xc7\x7f\x2c\xf4\x06\xe4\xbf\x2f\x7a\x71\x91\xfc\x4d\x00\xba\xc7\x66\x7a\xfa\x13\x55\x45\xeb\xc6\xb7\xc0\x57\xb7\xa9\x67\x11\x79\xd5\x3e\x5f\x41\x7a\xd6\x8c\xdb\xe1\xd0\xfb\x2c\x16\xa0\xd7\x73\xa1\x30\x59\x7c\x1d\x05\x56\x87\x75\x58\x2a\x60\xb4\x18\x87\xa5\xc8\x17\x82\xdb\x61\x16\x10\x6b\x9c\x9c\x31\x44\x73\x24\x29\xe1\x9c\xbc\x2e\xc3\x2c\xb1\x3d\x57\x42\xd2\x4d\xe9\xbe\x90\xeb\x03\x46\xfe\x17\x34\xd0\xc9\xba\x7e\x5d\x3a\x6a\x92\xb9\x7c\x91\x77\x51\xcf\x6c\x3b\xb0\x9e\x6f\x7a\x8f\x47\x0d\x27\x69\xff\x2f\xda\x11\xec\xb3\x65\xb0\x9a\xf6\x04\x93\xdf\x5b\xf6\x41\xaf\x4c\x8e\x17\x8b\x7f\x74\x57\x73\x04\x37\x81\x5c\x0e\xd9\xaa\xa2\xf2\x0e\x39\x61\xca\xde\xdf\x0b\xd9\xbd\xc2\x1d\x6c\x93\x32\x63\x83\xcd\x2a\x8e\x77\xd8\x2b\x54\x72\xc8\xb6\x65\xf0\xa3\xd5\xf0\x57\x75\x6e\x52\xfc\x33\xdd\x1d\x73\xd4\x14\xfc\x23\xb2\xf8\x57\xb3\xbc\x9e\x0c\xfe\x6b\xfc\x1d\xf7\x2e\x15\xfc\xdf\x66\xe9\xe7\xe0\xdf\xf3\xe8\x5f\xe2\x0d\x76\x8a\xff\x4c\x16\xff\x16\x1a\x9a\xcd\xe2\xbf\xb5\xa8\xb4\x33\xfc\xc2\x4b\x59\xfa\xb7\xc1\xcf\x89\x2d\xe2\x92\x0c\x08\x7a\x31\x82\x57\x65\x92\xe6\x58\x72\x76\x06\x3f\xcb\x31\x52\xf0\x6f\x03\xbf\x00\x75\xaf\xaf\x88\xee\xf5\x4d\xca\xec\xa6\xe6\xad\xfd\xca\x33\xfc\x94\x7d\x06\x0c\xff\x0d\xf2\xf3\xec\x9e\x75\x15\xfd\x2e\xcf\x8e\xde\xe7\x81\xdc\x1e\x2f\xb1\x17\x26\x81\xfc\x3d\xd8\xe7\x0b\x4b\x7e\x7f\x1f\x79\x14\xed\xbd\x6f\xc9\x3c\xcb\x76\x96\x9b\xe7\x7c\x0e\xc4\x68\x73\x0c\x51\x4c\xc2\x17\xfc\x7e\xc5\x0b\xac\x60\xf7\x90\x47\xd1\x5e\x71\xd9\x7b\x6c\x87\xc7\xd4\x38\x4b\x38\xac\xee\xdf\x30\xbc\xec\xec\x07\x36\xbf\x7b\x28\x71\x08\x34\x5e\xf1\x3b\x7c\xd4\xef\x68\x4b\xb7\x04\x0b\x74\xde\x3c\x7d\xcd\x7a\xae\x31\x7d\x73\xb9\xaa\x4f\x1f\x55\xe0\x5d\x56\x0a\xff\xaf\x16\x9f\x53\xeb\xc8\x83\x57\x72\x0a\xe5\x6c\x4e\x61\x1b\x6c\x52\xc7\x4c\x4f\x6e\x60\x30\xeb\x70\xfb\x5a\x01\x65\xbf\xf5\x64\x66\xbf\x95\xe8\xdf\xbf\x80\xdc\xde\xd6\x82\x80\x27\x7f\xaf\x39\x8b\xff\x50\x06\xbf\x0e\x42\x29\xc3\x4b\x1d\xe5\xbf\xc1\x28\x62\xa1\xc3\xfe\x2c\x3b\x5f\x80\xad\xbf\xbd\xd5\xf5\x77\x97\xf2\x0c\x7a\xe6\x6b\xf9\x5b\xf4\x46\xa8\xc9\x8b\x1d\xb2\x1e\x5d\x6c\xbc\xc6\xab\x6b\x4e\x6d\xe6\x19\x08\x4d\x7f\xd5\x1b\x01\xdf\xee\x19\x14\xfc\x8f\x64\xf0\x13\x3f\xf9\x2a\x35\x26\x45\x6f\xf0\x98\xde\x00\xdb\xe9\x4c\x15\xff\x89\x0c\x7e\xe2\x2f\xbf\x9f\x87\xff\x61\xbd\xa1\x53\xfc\x72\x06\x3f\xd1\xc9\x62\x1e\x4f\xdf\x35\xd8\x3a\xe0\xff\x86\xe0\xff\x96\xf1\x74\xfc\x79\x65\x8d\x78\x33\x0f\xff\x1f\x0c\xb6\x7c\xfc\x4a\x5f\x5d\x74\x88\xed\xe1\xd5\x48\x05\x26\x00\xcc\x16\x0b\x3d\x56\x1b\xea\x31\x34\xd2\x13\x57\x69\xc6\xa4\x49\xcd\x98\x64\xe9\x40\x50\x6d\x9f\xaf\x44\xc6\x58\xca\x9a\xc0\x9a\x4a\x0b\x38\xf4\xad\x7f\xfd\xf2\x01\xd5\x9e\x8a\x58\x34\x11\xb4\x9c\xe1\x5a\xb6\xdd\x62\xb8\x53\xeb\xef\x31\xe4\x82\xd2\x73\x39\xd3\xc7\x3e\x08\xe2\x60\x82\xd4\x95\xaf\xaa\xb2\x16\x94\xea\x04\x8e\xc7\x3e\x5f\x21\x46\xa8\xd0\x5a\xd8\xb5\xda\xab\x37\x15\x3a\x9d\x31\xda\xde\x50\x08\x06\x39\xb2\x6e\x22\x53\x88\xd8\x85\x16\x9a\x94\x94\x49\x35\xa7\x0a\x57\xed\x1e\xd5\x90\x6f\x0e\x2a\x2b\x04\x2d\xcd\x54\x23\xcf\x42\x7e\xe6\x40\x44\xc9\x28\x88\x10\xe7\x28\xc2\xb7\xcb\x22\x78\x74\x31\x8d\x44\x77\xf5\xca\xef\x14\x1a\x9d\x99\x14\x02\xd6\xcf\x9e\x2f\xdd\xaf\x8d\x1d\x5d\x8c\x4a\x73\xbb\x83\x7c\xc3\xc6\x8d\xcb\x36\x34\x0e\xc9\xa4\x12\x5c\x33\xa1\xe0\x3e\xef\xeb\xf8\x4f\xff\x52\xf7\x05\xe1\x40\xd6\x9f\x13\x83\x11\x64\xec\xee\x26\x6b\x9e\x87\x70\x39\x0a\xc6\x4a\x5d\xc2\x25\xde\x12\xb3\xdf\xe1\xf5\x70\x5a\xad\xc7\xea\x30\xf3\xe5\x31\x6b\x38\x14\x0e\x35\xa7\xc2\x9a\xb0\xc6\x23\x7a\xbc\xcd\x29\x8f\x0d\x44\xc5\x68\x73\x4a\xc4\xb9\x16\x68\x99\x34\xac\x8e\xa7\x3a\xaa\xdd\x7e\x68\xc9\x37\x19\x04\x56\x2b\x98\x7f\xc4\x63\x7d\xe6\x6c\xc7\x7a\xe5\xac\x47\xf8\xb4\x65\xc2\x78\x6e\x93\xf6\xf0\x3e\x54\x98\x7f\xd4\xe3\x67\x99\x03\x1e\xfd\x99\x23\x1f\xb9\xef\xa7\x5c\x51\x63\xf5\xfb\x1f\x3b\x9c\x3b\xf1\xf1\x7e\x7a\xd6\xe3\x66\x88\x9e\xcf\xec\x99\x70\x3f\xa8\xf9\xc0\xbd\xa5\xa0\x45\xcb\x19\x8d\x06\x83\x16\x62\x97\x93\x66\x01\xd3\x30\x9d\xc1\xd8\x9c\x22\xf2\x86\x7f\x7f\x3c\x65\xfb\xa3\x58\x95\x6a\x80\xf6\x79\xc0\xb0\x09\xef\x08\xa4\x43\xa3\x60\xbf\xd3\xa0\x4d\xfe\x44\x4e\xa7\x1f\xfe\x0c\xce\x83\x33\xef\xdd\x28\x3f\x4a\xeb\x4e\x92\xaf\xb6\xbc\x7b\xe6\x5e\xe8\x98\x39\xbf\xc3\xf9\x08\x43\xa4\x72\x31\xe8\xc6\x0e\x63\x19\x76\x58\xad\x46\x93\xc9\x86\x71\x45\xb9\xd5\x31\x3c\x65\x05\xa2\x1b\x98\x9c\x9d\x1c\x84\xa0\xc8\x51\xf6\xbc\xdf\x7c\xbf\xe2\x77\x82\xa3\xec\x66\xfc\xaf\x13\x10\x98\xc4\x9c\x47\xff\x28\x4a\x9f\x08\x96\x58\xdb\xf7\x75\xcd\x9d\x81\x40\x45\x86\xfb\x7e\xe7\xee\xa3\x89\x5c\x63\x57\x45\x70\x10\x9d\xe9\xdc\x33\x2c\x56\xe6\x04\x75\x52\xa1\x95\x33\x02\x93\x49\xab\xd5\x73\xd8\xed\xa2\x67\x24\x12\x35\x6e\xc0\x5a\x53\xae\x00\x83\x25\xa1\xe6\x85\x02\xd8\x59\x9f\x0a\x43\xed\x65\xec\x94\x7d\x95\xab\x5b\x61\x43\x86\x9f\x07\x5f\xbb\x55\x03\x07\x77\x3f\x0f\xaf\x63\x5c\x3d\x84\xab\x28\x4b\xf1\xbf\x1e\x0e\xbd\x79\xc1\xc5\x18\xdb\x6e\xce\xfa\x40\x39\xb8\x44\x2a\x8d\x62\x31\xe4\x71\x71\x4e\xa7\x51\x61\x6d\xa5\xb5\xc2\x01\x44\x0f\xe5\x6b\x31\xe3\x6b\xe1\xef\xf9\x4a\x4c\x37\xd5\x72\xeb\xe4\x5c\x09\x85\xab\x8c\xc8\xff\x7d\xb0\x04\x63\xeb\xa3\xe3\x05\x58\x92\x18\xc1\xe6\xe8\x7f\x65\x2b\x6e\x6e\x09\x3d\x27\xa7\xe8\x04\x6d\xcf\x59\xaa\xef\x2a\xc8\x1a\xbe\x86\x9d\x53\xda\x5d\x2a\x74\x09\x85\x44\xe3\x99\x04\x93\x72\x56\x29\x71\xb9\xed\x99\x73\x49\xb3\xa7\x08\x2b\xbd\x7a\xf2\xcf\x92\x60\x69\xe1\x1c\x4d\x77\xa4\xbd\x28\x94\xc8\x91\x52\xcb\x12\xe6\x84\x03\xb7\x42\xe9\xc3\xc3\x50\x5c\xfd\x81\xbc\xfa\xcc\x27\xf2\x47\xca\xb1\xa4\xd0\x43\x8f\x25\x6d\x03\x57\x72\x5d\x9f\xdf\xbb\x41\x3e\x77\xf0\x17\x79\x96\x7a\x2c\x29\xec\xab\x1c\x4b\xaa\x9c\xa1\x2a\xd8\x34\x4d\x44\x57\x8c\x90\xca\xc3\x82\xd1\x67\xf7\x15\x44\x01\x28\x10\x0a\x62\x76\x7b\x39\x2d\x96\xb0\x5b\x45\x31\xd0\x9c\xf2\xf9\x8c\x22\x17\x8d\x62\x5c\x92\x7f\x82\x2a\xdd\xae\x63\x0d\x22\x6a\x2a\xf2\xce\x36\xc8\x6d\x02\xe4\x1d\xa7\x1a\xa4\xc7\x15\xa9\x9a\x5b\x63\x46\xff\xe3\x64\x55\xe8\xdb\xae\x2d\x7a\x60\x91\x54\xef\xaf\x8a\xf5\x1b\x6e\x2d\x6d\x29\x79\xe7\xbf\x9c\xb2\xba\xa9\x6c\xd3\x46\xe7\xbd\xb6\xd1\x57\xbc\x91\x7f\xda\xaa\x7a\x9e\x07\x6f\xe6\x75\x20\xc2\x9e\x4b\x67\xa6\xcf\x85\x39\xae\x40\x57\x50\x6c\xb7\x97\x58\x5d\xc3\xc9\x73\x19\x8d\x81\x26\xf2\x5c\x66\xa3\x05\x63\x8d\x06\x34\xa5\x34\xae\xff\xe3\x73\x95\x50\xb7\x3f\x77\xb6\x87\xdb\xd6\xfe\xb9\x94\x43\x3e\x26\xaf\xeb\x42\x4f\xf9\x78\xe9\xed\x0d\x67\x9f\x78\xf0\xca\x01\x5f\xf6\xad\xf1\x57\x17\x35\x0e\xb4\x17\x65\xce\xfb\xb8\xf1\xe6\xae\xf2\x0b\x9f\xbd\x42\x0f\xfc\x18\x0a\xf5\xce\x7b\x1d\xe3\x27\x3d\x98\x6d\xf0\xd6\x49\xee\x0b\xb1\x6c\x34\x1c\x99\xa3\x0e\x10\xa0\x7d\xfc\x8d\x56\xa7\xb6\x00\x63\xad\x15\x17\x05\x75\x01\x47\x80\x0a\x93\xd6\x81\xb5\xce\x0e\x93\xb4\x5d\x72\x78\xbb\xba\xa8\x9c\x0e\xcf\x9d\x2f\x8b\xa7\xe6\xce\x97\x3d\x67\x56\x75\xb7\x1b\x16\xbe\x06\xa3\xed\x8f\x99\xcd\xe9\xeb\xec\x71\xb3\x84\xc6\x4b\x08\xcd\xf5\x59\x1d\x5d\x64\xd4\x6a\x2d\x58\x87\x45\xa7\xe8\xd2\x10\xe5\x41\xb8\xac\xd7\xeb\xe8\x79\x7f\xd9\xc8\x52\xbe\x8a\xce\x70\xba\x86\x05\x92\xd8\x81\x38\x44\x9b\xd0\xee\x5d\x54\x9b\x10\x51\x09\xa1\xf2\xd3\x6d\xb0\x0c\x62\xb8\x71\x74\x5a\x1b\xc0\xcf\xc8\x3f\x34\xca\x9b\xe4\x75\xf7\x6e\x84\x63\xa9\x2a\x81\xcf\x6e\xfb\xcf\x62\x74\x8f\xfc\x1d\xd3\xd1\x99\x73\x53\x68\x2f\xf1\x26\xa9\xdc\x20\x16\x91\x75\xc2\xe8\xb0\xdb\x8d\xa5\xd8\x84\x2d\x31\x4b\xb9\x5b\x2f\x38\x9c\x66\xd3\xf0\x94\x19\x08\x61\xd6\x79\xbb\x20\xaf\xf3\x76\x4e\x9f\xe4\x28\xab\xc9\xa8\xe9\xf6\x27\xa7\xd0\xe3\x47\xcd\xf0\xff\x77\x76\x4a\x22\x7d\xa2\x08\xfd\xe3\x7c\x88\xcf\x3f\x3f\x85\xa6\x0b\xe6\x9d\x9f\xc2\xed\xbc\x60\x3f\x56\x94\x77\x80\xca\xbd\xf2\x33\x2c\x5b\x10\x81\x2a\x62\xbb\xd2\x7e\xed\x0e\x22\x19\x97\x4a\x65\x4e\xe0\xe0\x7c\xbc\x8f\xa8\x12\x1e\x70\xc5\x11\x91\xb3\xd9\xdc\x4d\x29\x9b\x45\xcf\x6b\x05\x2d\x79\x18\x1f\x47\xc4\x9b\x73\xe5\x7a\x92\x24\x3c\xed\x23\xb8\xb6\x86\x4c\x83\x1b\x8d\x00\x05\xf2\x08\x6e\xc8\x7a\x15\x76\xd2\xcd\x7d\xd9\xf9\xa7\x60\xd8\x9b\xf6\x17\xc2\x1b\xef\x93\xd7\x8d\x1a\xb0\x32\x7d\x24\xdb\xd6\xfd\x9a\xc5\x13\x7b\xa2\xc7\x0f\xca\xfb\x5a\x34\xf2\x0f\xcb\x37\x68\xe1\x98\xcb\x0e\x5d\x7f\x04\x5e\xb2\x37\xd7\xde\x3d\xb9\xf5\x57\x00\xdb\xbe\x26\xb2\x71\x15\x3b\x6b\x8c\x48\x06\x16\x04\x2d\xa7\x07\xc4\xb8\x35\xb0\x73\xf3\x78\xa0\xd3\x69\xe9\x61\xc8\x00\x76\x2e\x19\x6c\x04\x6a\x94\x96\xaa\xa1\x8c\x1b\x0e\x03\x21\x7c\xef\x35\xad\xef\x84\x70\xcd\xc4\xd6\xbb\x43\x5c\x95\xfc\xd1\x36\xf8\x4f\xea\x7b\xb3\xb3\x38\x11\x58\x40\xf4\xc0\xe7\x44\xf7\x6a\x89\x3d\x34\x50\x2a\xc1\x3a\x4e\xe7\xb1\xda\x6c\x5c\xc8\x13\x8a\x84\x43\xe4\xc6\xa1\x90\xb3\xb0\x10\x34\xa7\x0a\xed\x56\xab\xd3\x49\x64\xd4\x99\x53\xc3\x1d\x4e\xa3\xcc\x99\x3f\x25\x35\xa0\x3e\x44\xe3\x7f\x30\xd7\x1f\x84\x68\x38\x65\x62\xd1\xf0\x67\x3d\x3a\xfa\x35\xec\xd2\xbb\x35\xa6\x7b\x1f\x97\xa1\x77\x9f\xdd\xf2\xcd\xb8\x3d\x37\xc1\xfe\x1f\x42\x1d\xac\x78\x55\xbe\xfb\x9c\x7c\x56\xfe\xb0\xe4\x56\x68\x4d\x37\xd4\x1f\xff\x08\xed\xab\x34\xbd\xf8\xe7\x05\xcb\x7a\x3d\xf5\x98\xfc\x3e\x99\xf9\xf2\x0d\x5f\x10\x19\xd7\xdd\x7c\x0f\xd1\x63\x4d\x64\x2d\xfc\x8c\xed\x3b\x8c\x92\xaa\x2c\xe6\x48\xb1\x4b\x17\xa0\x87\xa2\x15\x14\x9b\x35\xb1\xa8\xc6\x5b\xe8\x65\xe7\x27\x02\x83\x81\x4c\x28\x8b\xc5\xc0\x45\x22\x00\x84\xd4\xa3\x02\xf3\x16\x13\xf5\x39\x40\xc7\x72\x6e\x26\xc6\x75\xac\x47\x65\x71\xae\x65\xa3\xd2\xf6\x35\xc2\xe6\x5c\xd0\xee\x36\x21\x14\xfa\xe4\xd7\x93\x4f\x5f\x3f\x17\x46\x7e\x7a\xf3\x74\xf1\x81\x92\x75\x0b\x36\x3f\xb5\xe3\xc1\xde\xfe\x4b\xe4\xbe\x5b\x6e\x87\xf0\xf1\x0d\xa3\x1e\x79\xdf\xf1\xea\xde\x87\x3e\xf0\x16\xde\x31\xe5\xe8\xff\xe3\xec\x3d\xe0\xa3\xaa\xd2\xfe\xf1\x7b\xee\xb9\x77\xfa\xcc\xbd\xd3\x7b\xcb\x24\x99\x49\x0f\x09\xa4\x51\x32\x10\x40\x3a\x49\x28\x61\x80\x90\x80\x74\x90\xde\x95\xde\x7b\x13\x14\x09\x55\xe9\x88\x08\x91\x26\xa2\xae\x8a\xab\x02\x16\x74\x6d\xbb\x96\x57\x5d\x77\x2d\x2b\xfb\xba\xab\xab\x24\x37\xff\x73\xce\xbd\xd3\x42\xf4\xdd\xff\xef\xb3\x4b\x20\xf1\x66\xee\x73\xda\xd3\xce\xf3\x7c\xbf\x5f\x1d\x3b\x53\xb8\x72\xf2\xee\xa5\xf7\xd7\x3f\x2c\xfc\x69\xe2\x7c\xc0\xd7\xac\xdc\xd0\x83\xf8\xfe\x2d\x26\x61\x18\xe1\x84\x36\x52\x3d\xc3\x01\xc0\xb2\x3c\x4f\xab\x0c\x06\xb3\x8a\x67\x4d\x84\x81\x1a\xe8\x15\x7a\xb4\x1a\x7a\xa8\x40\x9e\x9c\x4a\xe1\x94\x5a\xf3\x12\x3a\x5d\x0a\x41\xac\x5f\x2a\x9e\x97\xc1\x9d\x2d\xd2\x25\x44\x02\x37\xf4\x5a\xd7\xd1\xdd\xdd\x8a\x3d\x39\x19\x15\x55\x06\x90\x12\x63\x89\xee\xbe\x63\x97\x79\x2f\x32\x1a\xec\x87\x84\x33\x17\xb8\x84\x12\x26\xc0\x9e\x41\x9e\xcf\xe5\xf0\x60\x39\xab\x52\xf1\x3a\xb5\xda\x6c\xb1\xf2\xd6\x7c\x6b\xd8\x5a\x6f\x9d\x61\x5d\x66\x3d\x68\x3d\x6b\x7d\xcb\xfa\x99\xf5\x8e\x55\x4d\x25\xfc\xf8\x8e\x55\xde\xc3\x47\xbe\x5b\x86\x1e\x78\x01\x7f\x8f\x82\xc3\xd8\x37\xb2\x19\xe8\x1f\xb4\x15\x57\x35\xe4\x0c\xac\xee\x55\x67\x05\x61\x2b\xf0\x5a\x01\x65\x05\x66\xa8\xd4\x70\x9a\xb9\x11\x19\xcf\x52\x1c\xe6\x62\xe1\x8c\x2a\x23\x5d\x15\xe1\x8c\xc0\xa8\x56\x51\x79\x22\x9f\x94\xd4\xe3\x2a\xe1\x6f\x82\x28\x51\x20\xc6\x80\x94\xa0\x1e\x25\x58\x11\x52\x69\x8e\xf9\x83\x02\x20\x00\x08\xab\x10\xb6\xb5\x0c\x53\xd8\xb1\x53\xd8\xe8\xb8\x6d\x7f\x4f\x10\x1a\x01\xfd\xa8\xf3\x11\xb7\x77\xd7\xea\x81\x3d\x59\x1f\xd7\x67\xd4\xfa\x95\xbf\x3e\xc7\x56\xac\x7c\x74\xcf\x52\x13\x25\x71\x66\xcb\xbd\xc8\x17\xc8\xc2\x91\x92\x07\xa6\x85\x42\x16\xa5\x95\xb3\x5a\x2c\xe9\xc8\xe9\xe2\xb8\x9c\x60\x7a\x5d\x24\x18\xa4\xe4\x5a\xec\xb7\x68\xe5\x72\x47\x5d\xc4\x6a\x45\xb1\x54\x6c\xbf\x11\x36\x9d\x98\xdd\x4c\x50\xea\x89\x90\x65\x09\x6c\xda\xbf\xe3\x12\xdc\x4b\xac\x0d\x3c\x8f\xc8\x5c\x8f\x2f\x11\xbd\x82\x2a\x43\x6a\x9c\x64\x7b\x33\x00\x43\xda\x60\xd9\xde\xe0\xde\xfa\x28\x71\x0e\xae\xc4\xd8\xb6\xab\xfb\x44\xd9\xb6\xb1\x6e\x68\x27\xd4\x90\xfe\x42\x23\xb2\xa7\xdd\xc3\x01\xad\xca\x2e\x67\x94\x6a\xb5\x46\xa9\x70\x41\x2b\xcf\x43\x05\xf4\x6a\x34\x3e\xbb\x8a\x52\x2b\x20\x61\xbc\x77\xc6\xef\x86\xdb\x2c\xfe\x14\xb1\x11\x30\x02\x9b\x11\x14\x02\x1c\x11\x61\x6b\x80\x54\x44\x90\x74\xa4\x80\x9a\xf1\x0b\x73\x06\x4c\x13\xde\xba\xfe\x0d\x3d\xf5\x56\xb3\xa6\xd0\x71\xdf\xf2\x9e\x05\xa5\xfe\x8a\xca\xa0\x50\x33\x77\x42\xe1\x43\xeb\x1e\x61\x96\x35\x39\xe1\x57\x77\xe7\x1d\xdc\x56\x5c\xf3\x48\xdf\xdd\xa3\x86\xcc\x98\x55\x7f\xae\x5d\x30\x8b\xac\x4f\x4a\xcb\x77\xb2\xf7\x91\x3d\xcb\xa6\xba\x85\x03\x66\x8e\xe3\xfd\x50\xe1\xca\x70\x41\x9e\xc9\xc9\x35\xf3\x21\xce\xae\xae\x8c\xd8\x79\x3d\xc5\x9b\xa9\xd4\xb8\x19\x2b\x97\x8c\x58\x5b\x07\xbf\x38\x81\x26\x25\xa9\xe4\x5d\x84\x3d\x8e\x15\x6d\x30\x0b\x2e\x5c\x51\x75\xe4\x86\x8e\x5c\xfa\x82\x77\x3e\xe1\x3a\x32\x39\x60\xef\x53\x0b\x77\xec\xe6\x4a\xb5\xc3\x26\x2e\x5a\xe9\x5d\xf3\xcc\xa6\xd0\x57\xa6\xbd\xeb\x32\xf3\x41\x56\x65\xd1\x90\x41\x2f\xee\x6f\xde\x87\xa9\x8f\xa6\x8d\x98\x32\x7a\xc7\xda\xce\x7d\x85\x8f\xcb\x33\xab\x6b\x16\x36\xd0\x67\x9b\x0b\x6f\x36\xc6\xee\xf1\x49\xcd\x81\x0c\xdf\xe3\xa3\xf1\xe5\xa3\x45\xe9\x4f\xee\xc8\xb3\xc3\x66\x56\xa6\xa6\x64\x94\x56\xa3\xa2\x21\x5d\x1f\x91\x43\xc8\x52\x62\x6f\x67\x5e\x61\x12\x93\x2d\xce\x08\xe0\x9c\x27\x86\x38\x09\xc0\xea\x15\x4f\x38\x8f\xac\x68\x5c\x79\xd2\x79\x72\x25\x7d\x70\x33\x7d\xa0\x79\xf4\xe6\xe6\xfa\x18\xdf\xf7\x76\x34\x29\xfd\xc3\x21\x2d\xaf\x87\x06\x8e\x56\xaa\x95\x06\x83\x91\xd3\x19\x75\x56\xb5\x46\x63\xd3\x2a\x79\x3d\xa3\xe6\x8c\x06\x14\x06\xb3\x75\x11\x1a\xa3\xd4\x89\x77\xb8\x24\x88\x68\x5d\xef\x11\x8d\xd6\xc4\xdd\x2b\x17\x8b\x3e\x02\xa4\x02\xa4\x0b\xa0\x1f\xe8\xda\xd9\x8b\xf4\x4e\xa5\xa1\x4f\x94\xf2\xfb\x7f\x08\x09\xf8\xc7\x2e\x24\x85\xf9\x80\x61\xc0\x48\x61\xbd\xc4\xfd\x4d\xb8\xc0\x99\xc9\x3b\x76\x51\x31\xae\xa4\x8f\x44\x39\x55\x46\xbd\xd1\xa4\x37\x63\x12\x4e\x0a\x45\x07\x16\xc6\x62\x35\x99\x6c\x66\x3d\xa0\x19\xc6\xc8\x29\xb4\xd5\x48\x43\x02\x8a\x91\x78\xc6\xf0\x2a\x5b\x13\x29\xc6\xc4\xf6\x65\x89\xe3\x57\x12\xac\x30\x59\x5e\xa9\x48\xe5\x7b\xfb\xfe\x85\x3d\x8b\xdd\x79\xbe\xf2\x3e\x86\x59\xc9\xe5\x2a\xaf\xac\xda\x8e\x3c\xd3\xfa\xd1\xcd\x17\xa2\x55\x2b\x64\xad\xac\xa4\x5f\x4d\x5a\x2b\x5c\xc5\xc0\xca\x64\x5a\x25\x5a\xab\x4a\x69\xad\xcc\x09\x6b\x15\x07\x8a\x49\x5c\x2b\xe7\xf2\xd5\xee\x15\xab\x1b\xd7\x6c\x70\xaf\x5d\x4e\x3f\xb6\x86\x3e\xdd\x3c\x78\x4d\xf3\x78\x64\x23\x9e\xa0\x28\xb8\x12\x7d\xb6\x99\x1a\x11\xce\xd7\x1a\x50\xc8\x67\xc4\x3d\xbf\x26\x9d\x9e\x97\xe3\x95\xb2\xe8\x4d\xbc\x19\xe8\x28\x8e\xe7\xaa\x22\xbc\xd9\x4c\x55\x45\x64\x5a\xb3\x19\xc7\xfd\x1a\xb3\x94\xc5\x2f\x2d\x15\xc1\xad\x25\x9a\x8f\xd2\x04\x1c\xb6\xa8\x1f\x2c\x37\x12\xde\x6f\x5a\x8e\x56\x0d\xa3\xe2\x06\x0b\xad\xc5\xb0\xea\xe4\x9f\x1b\x6b\x4d\xac\x8c\x37\x0c\x13\xb6\xbc\x44\xaf\xf3\xbd\x69\x7d\x23\x70\xdc\x71\x92\xf9\xb9\xec\x6e\x05\xdd\x75\xda\x44\xb5\xdb\xbf\xb5\xf9\x45\xf8\xee\xf9\x8a\x79\x3d\x6e\x3e\x5c\x86\xe7\xa2\x3f\x3a\x97\x38\x2f\x11\xa2\xaa\xc3\x19\xde\x74\x5f\x5a\x5a\x6a\xaa\xcf\xcf\x29\xcc\xb4\x43\xe1\xc8\xf0\xfb\x33\xd3\x69\x75\x9a\xc1\x67\x51\x43\x16\x69\x4e\xd6\x48\xb9\xe3\xfa\x52\xd4\x99\x49\x3e\x66\x61\xab\x42\x81\x60\x8c\x3c\xa3\x30\xf1\x54\x8a\xff\x74\x92\x63\x1b\x28\x46\x67\x54\x7f\xb3\xf7\xc8\x83\xa3\x8e\x9e\x31\x9f\xbf\x7a\xde\x50\x33\x7a\xe1\x46\xcf\xd5\xe7\x2e\xf3\x83\x22\x3f\x97\x5f\x7e\xee\x2b\x13\x77\xdc\x58\x76\xcc\x74\x7c\x54\x9f\xe3\x87\xee\x9b\x06\x1f\x69\x9a\x50\x1b\x9e\x50\xfb\xd8\x23\xf0\xb5\xa6\xfb\x06\x94\xd4\x8d\x04\x15\xf0\xe2\xdd\xf1\x63\x56\xef\x18\x30\x2c\x66\xa7\x31\x87\xb9\x95\xea\x14\x76\x53\x7a\x33\x63\xb6\x30\x1c\xa7\xb4\x58\xec\x4a\x9b\x19\xf0\x50\xae\x41\xbe\x9a\xdc\x69\x90\x38\xff\xc5\x61\xc4\xeb\xbf\xe2\x15\x51\x04\x51\x3e\x6e\x9c\x13\x18\xcd\x53\x14\x37\x3d\x8f\x6d\x8a\xdb\xe7\x04\x6e\xf3\x2f\x42\x77\xdf\x7a\x6c\xb3\x64\xa4\xe3\x14\xe7\xa4\xbe\x8b\xd4\x2f\xf0\x32\x38\x29\x7e\x9f\xce\xee\x36\xc8\x98\x3d\x94\xc4\x81\x2e\x1f\x84\xfc\x3d\x9c\x97\xe9\x14\xf6\x04\x39\x1f\xb2\x60\x99\x72\xa5\x32\x4b\x0b\x4d\x0a\x53\xa0\x2e\x62\x32\xca\x91\x3a\x77\xc6\xd9\xd0\x0b\x13\xc8\xf9\x0a\x13\xe0\xbb\x19\x2b\x52\xe5\x68\xbb\x62\x6c\x3e\x92\x3c\x88\x93\xa4\xeb\x40\x12\x4b\xfa\x57\x20\x3f\x77\x62\x3d\x3f\x2c\xf0\x92\xc5\xbd\x6d\x17\x3b\xfb\x13\xe1\x8d\x67\xa2\x84\xe9\xbb\xbe\x3a\x18\x89\x91\x7e\x7f\xf4\x4a\xde\xd4\x5e\xc7\x26\xaf\x3f\x59\x5e\xe0\x3b\x27\x5c\xfd\xe7\xb2\x18\x71\xfa\x98\x17\x84\xcf\xd6\xc6\x58\xbf\x09\x37\x13\x8b\x79\xfd\xac\x54\x1a\xd5\x35\xec\xd3\x68\xb5\x9c\x07\xda\x54\x50\x95\xce\x71\x41\xa3\x8a\xd2\xea\x38\xb9\x83\x44\x2c\xfe\xe4\x88\xa5\xd0\x90\x44\x33\x98\xa0\xec\xc5\x60\xa5\x28\x3a\x24\x19\xad\x03\x20\xd1\xcb\x07\xdf\xbe\xfc\x25\xf2\xeb\x5f\xfd\x44\xb5\xce\x81\x87\xe2\x58\xb1\x54\x36\xf8\xe1\x77\x80\x22\xce\xde\x64\xfa\xe6\x26\x76\xec\x5f\xbd\xd0\x7b\xd9\xb1\xc9\x4b\x8e\x97\x2d\x42\x5e\xc5\x70\xfa\xf9\x24\x16\x27\xb4\x06\xc2\x30\xd9\xcf\x68\x0d\x0c\x94\x17\x7b\x79\x0e\x68\x54\x72\x90\xf3\x21\xa7\xca\xaf\x75\xaa\x90\xe6\x32\x63\x4a\x7a\xe4\x38\x78\xdd\xf8\x28\xf0\x62\xb1\x8c\x78\xf9\x2e\xc5\x29\xe5\xf1\xc5\x48\xf2\x18\x0a\xac\x69\x85\xf8\xb8\x62\xf6\x39\x91\x56\x90\x08\x5f\x4c\xbf\x22\xcd\xf7\x3f\x4e\x1f\x01\x6f\x67\x09\x7b\x1a\x41\xf8\x7f\x3e\x9b\x71\x15\x44\x46\xad\xc3\x2b\x70\xfb\x8d\x75\x13\x4d\xd1\xc9\xee\xdf\xf3\x3f\xaf\xc9\x1e\xa0\xef\x2e\x6f\x1f\x62\x3e\xcb\x27\x33\xff\xd6\x9f\x73\x45\x9f\xa0\x02\xf9\x04\xc5\x68\xde\xf5\x94\x1b\x33\x7a\xd8\xa0\x41\xc9\x21\xc1\x39\x08\x3d\x5e\x24\x3c\x6f\xe0\x4c\x72\x53\x25\x12\x9e\x77\x3b\x71\x42\x8f\xc7\x73\x7f\x8f\xf0\x49\x79\xb1\xd8\xe4\x8b\xb2\x07\xa0\xcc\x98\x1e\x9b\xf6\x62\x69\xd6\x8f\xac\x05\xa3\xb2\x84\x0f\x9f\x02\xec\x73\x4f\xce\x59\xd8\xa5\x82\x4c\x79\x97\x5c\x69\xc2\xfb\x75\xff\xd5\xc0\x96\x37\x6d\x2b\x83\xaf\x1b\xc5\xa9\x56\x23\x59\x71\xae\xf7\x0d\xc2\x19\xee\xc6\x0c\x42\x3a\x83\x45\xa1\x50\xda\x51\x74\x60\x40\xc2\xaa\xdc\x66\x34\xb7\x16\x39\xfa\xc3\x5b\x78\x25\x72\x37\xb1\xf5\x14\x91\xeb\xef\x69\x18\x4f\xa4\xd8\x4f\x4c\x0b\xc4\xd8\xf6\xff\x94\xc0\xb6\x1f\xcb\x0a\x0c\x6e\x4d\xba\x1f\x4f\x09\x48\xe4\xfb\xd1\x5e\xbd\x8f\xd0\x4e\xc8\xc5\x11\x0c\x97\x6d\xca\x76\xb9\xf2\x65\x6c\x1a\x0a\xc5\x15\x26\x14\x03\x2a\xf2\x90\xfd\xb2\xdb\x7d\xd8\x75\xd1\xe8\xab\x23\x3a\x0d\x40\x5e\x7f\x28\xc1\x7f\x89\x07\x00\x89\xb8\x1c\x86\x52\xc9\xb2\x91\x9e\x3d\x0e\x09\x0e\x12\x7c\x49\xf0\xfb\xbd\x7b\x34\x5f\x7b\x1e\x94\xc7\x8c\x5e\x6f\x63\x0e\xdd\xf7\xd0\xac\x84\x1e\x3e\x9c\xe1\x33\x4d\x1c\x65\x1c\x27\xb8\x65\xd3\x24\x0b\xf8\x65\x5d\x75\x72\x1f\x5f\x2c\xc5\x87\xb1\x2a\x84\x17\xd9\x12\x72\xd7\x6c\xa3\xaa\xc2\x99\x46\x35\x72\xea\x75\x1c\x74\x40\x9b\x9c\x91\xe1\xca\x52\x35\xe3\xb0\xeb\x68\x1b\x5d\x17\x91\x5b\xeb\x22\x36\xb9\x0d\xdf\x41\x50\x0c\x5a\x94\xeb\xc9\xab\x92\x40\xd0\x9f\x78\xf9\x0c\x63\xd0\x15\x89\x1c\xfd\xf0\xd6\x4f\xc2\xc2\x41\xcf\x03\xfd\xb3\x1e\x30\xff\x36\x00\x1f\xdc\x06\x9c\xf0\x00\xa1\xe9\x5f\x3b\x4e\x78\x91\xfe\x87\x50\xc5\x2e\x7f\xec\x8d\x63\x98\xa9\x1f\xc0\xd5\x51\xa6\x7e\x40\x0d\x42\xfa\xa5\x3d\x3a\xa3\xb9\xb8\xfe\x55\x26\x97\x5b\xd3\x3c\x5e\x2f\xa5\x4d\xd3\xe6\xe5\x53\x56\x55\x8a\xc7\x93\x92\x82\xdc\xfb\x14\xa3\x4c\xa6\x52\xc1\xfa\x88\x2a\x31\x28\xc6\x7f\xe9\xe3\xb7\x20\x71\x88\x35\x10\x8f\x85\x09\xac\x29\x44\x73\x00\xa2\x80\x02\x56\x19\xe3\xc7\x24\xf5\x5d\x60\x71\x17\x9a\x79\xb0\x61\xdb\xde\xd7\x4b\x1a\x23\xc0\xfe\xc3\x9f\x7f\xc9\x1f\x32\x77\xc3\xe5\x29\x37\x9e\x3a\xb7\x67\xd9\xa5\x65\x1d\xce\xd6\x09\x17\x5b\xa8\x1f\x85\x7f\x77\xa8\x5d\xbe\xf7\xda\xad\x03\x03\x99\xfb\x6a\xc7\xcc\x5f\xee\x7f\xe9\x89\x27\xf7\x0d\x7e\x30\x52\x9e\x9d\x6a\x0e\x6d\x9d\x39\x71\x7a\xb7\x95\x8b\xf3\xbe\x7a\xe9\xb9\xa7\x6a\x56\xd5\xf7\x28\x48\xcf\xa8\x18\x83\xc7\x95\xdd\xf2\x1d\x7c\x99\x19\x48\xa5\xe3\x71\x59\xac\xd6\x54\xdc\x4b\xa1\x77\x29\x5d\xa1\xa0\x3e\xd5\x2e\x43\xf6\xcb\x6e\xc4\x3d\xe9\xd1\x8c\x1f\xff\x5f\x8d\x8b\x0c\xca\x1f\x85\x6a\xa5\x45\xf8\x46\x2b\x29\xf9\xc1\xfe\x3e\xc9\xf7\xd0\x15\xd3\x17\x79\x77\x0f\x00\xa3\xce\xbd\xd8\xab\xe1\xe4\x53\xd3\x8a\xbe\x58\xb4\xce\xbb\x73\x80\xb0\xeb\xa5\x77\x06\x9d\xbc\xb8\x60\x65\xc9\x54\xf8\x87\x1e\x55\xf9\x3f\x6e\x59\x5e\x35\xab\xa6\xa0\xb0\xb8\x47\xe1\x9e\x3e\x83\x4b\x7e\xdc\xb9\x25\xb2\x6c\x54\xa1\xaf\x04\x99\xa1\x6e\x2d\x2d\x2d\xbf\xa2\x33\x0d\x71\xce\x0f\x0e\x21\xfb\xea\xac\x50\x43\x2f\x65\xdf\xa3\x5c\xc8\xbb\x28\x0f\x3b\x7d\x94\xd2\x9a\x2e\x93\x71\x56\x8a\xc9\xc8\x34\x20\x07\xd0\xe0\x0c\xd8\x3e\x73\xdc\x71\xd0\x0e\x14\x64\x5e\x50\x6a\x7b\x39\xdc\x10\x79\xbb\x37\xdf\xcd\xaa\x2d\xb8\x59\x9e\x7c\xeb\x61\x6c\x5f\xd4\x8a\x52\x5a\xf2\x2b\xf0\xdf\xc5\x51\x0c\x5f\x34\x94\xb3\x6b\xa7\x4c\x9d\xa9\x69\x61\xeb\x4a\xda\x7b\x7a\x74\x9d\x30\x57\xf9\x73\x4e\x97\x3e\x43\xde\x2a\xea\x9d\x9b\x59\xd2\x37\x9f\x69\x19\x3d\x77\xca\xf8\x50\xf9\xaf\x5f\xbb\x2c\xb5\xda\xfd\xda\x79\x93\x42\xf9\xcc\x3f\xdc\xc3\xde\xea\x57\x9c\x99\xdd\xa7\x28\x33\x0f\xaf\x03\x27\xd6\x7b\x20\x7f\xb6\x77\x38\x5d\xe9\xb3\x38\x1c\x46\x8e\xe6\x7c\xd0\x1a\xb0\xa6\xda\xf5\x06\x7d\x55\xc4\x62\x32\x70\x4a\x0f\x52\xa5\x16\x8a\xad\x46\xde\xb6\x53\xf2\xb6\xf1\x9f\xeb\xc9\x38\xff\x51\xf9\x63\xd4\x48\x81\xb6\xf9\xce\x20\xbd\xa2\x6b\x01\x3e\xd0\xe5\x7a\x15\xb8\x97\xf8\x2c\x3b\x43\xa8\x31\xef\x31\x8d\x1c\xd3\xb9\x35\xff\x99\xf0\x91\xf0\x2f\xd1\xaf\x5d\x11\xab\x19\x29\x0c\xdb\x64\x2a\x40\xab\x68\x5c\x31\xa2\x50\xd0\x5a\x0c\xa1\x89\x61\xa8\x68\x03\x15\xad\xea\xc4\x95\x61\xf7\x50\xfa\xa6\xc4\x2e\xc6\xe4\x70\xf8\xbf\xae\xfd\xeb\xf5\x4b\x44\x5b\xc2\x85\x1e\xe6\xab\xbb\x4e\xe6\xab\x2b\xa2\x8a\x24\xb9\x07\xc2\x01\x77\x03\xe9\xc7\x14\x1c\x81\xa2\x59\x52\xb2\x3e\x96\x0b\x70\xa9\x5a\x43\x35\x8a\xb1\x81\x5d\xae\x90\xa3\xa9\x52\x70\x28\x56\xf2\x48\x3a\x31\x6e\x6b\xc8\x5f\x09\x6e\x63\x12\x11\x5c\x92\x36\x6c\x83\x12\x6e\x89\xcb\xf1\xc8\x62\x51\xff\xf5\x32\x69\xef\x25\x87\x5b\xbf\x7c\x37\x52\x7b\xa3\xc7\x56\x24\x71\xc4\x49\xf5\x3d\x94\x89\xca\x0d\xdb\x58\xa3\xda\x48\x41\x33\x4d\x5b\x74\x18\xbb\xcb\x89\x29\x11\xea\x22\x20\xe1\x16\x11\xc4\xe0\xb8\x8c\xc5\x7e\xb9\x1f\x24\x6f\x3c\x70\x09\x97\xcc\x08\x2e\xe1\x67\x45\x55\x59\x7b\xef\x7d\x61\xb4\xeb\x80\x9a\xf9\xaa\xa1\xe1\xd7\x33\x21\x4f\x0d\xbf\x5f\x3f\xfd\xfe\xf4\x4e\xec\x70\xf4\xb1\x7b\x90\x5f\x97\x87\xde\xeb\xa1\x4a\xc2\x4e\x27\xaf\x57\x41\x3d\xf4\x9a\xad\x56\x1f\x72\x41\xcd\x16\x88\xfc\x41\x8c\x4f\x17\xcb\x42\xc4\xdc\xa0\x04\xc2\x79\x16\x6b\x9f\x98\xe7\xec\xc3\x9e\x73\xcc\x19\x82\x34\x45\x6f\xf9\x9b\xf0\xa3\x75\xf7\xf3\x87\xf5\x4f\xed\x03\xcb\xfa\x1f\xbf\x36\xe0\xa7\x10\x72\x83\xcc\xa9\x37\x2e\xf7\x29\x14\xce\x9a\xee\xdc\x8e\xcc\x86\xb2\xa6\x67\x6a\x4a\xd6\x3d\x0a\x76\xc3\xb1\xc2\x03\x79\xcf\x1d\x1b\xf7\xf4\x15\x8f\xb0\x54\xf8\x51\xf8\x5a\xe4\xcf\x63\x37\x30\x65\x48\xf7\x84\xc3\x29\x30\xa0\x56\x98\xcd\x2e\x7b\x80\x09\xf2\x7a\x7d\x48\x99\xce\xf9\xd8\xca\x08\x0a\x02\xcc\x6e\xc8\xdb\xcd\x28\x76\x21\x91\x8a\xb5\x54\x14\x38\x29\x3c\x49\xa6\xd0\x8b\x7b\xa1\x32\xfa\x37\xd9\xf4\x2a\xc7\x6e\x30\x61\x69\x03\x7f\x38\x9e\x53\xa4\x68\x9b\x58\x4f\x18\xef\x5c\x3c\xe2\xd8\xb8\x13\xaf\xa4\x7e\x2d\xdc\xe9\x97\x48\xb1\x07\xa8\x85\x2d\xdf\xca\x32\xd1\xfc\xa6\x53\xbd\xc2\xe9\x3e\x87\x56\xce\xf0\x56\x6b\x80\x67\x18\x55\x00\xba\x82\xae\x90\xcf\x83\x7e\xa6\x52\xab\xea\x22\x4e\xb5\x98\xbc\x8f\x4e\xb5\xd8\x6e\x96\x54\x2d\x15\xcd\x90\xa7\xa6\x77\xe0\xa9\x34\x59\x16\x6e\x29\x93\x25\x18\xe1\x20\xfa\x1e\x85\x04\x04\xbe\x83\xa1\xdf\x7a\x46\xb8\xb3\x03\xa4\x01\xcb\x91\x02\xc1\x43\xf7\xcf\xfa\xe7\x7f\x3e\xbe\xfe\xe8\xbf\xd6\x2e\xdf\x9a\x43\x07\x3c\x6f\x74\xb8\x78\xf8\xdc\x15\xe1\x69\xf3\x9a\xbb\x27\x00\x0f\x66\x0f\x53\x37\x7c\xd6\x5f\x78\xee\xeb\xeb\x9f\x6e\x02\xf0\xec\xe3\x5f\x0f\xfa\xac\x41\x3d\x5c\xb8\x7d\xf9\x96\xf0\xec\x39\xbc\x3f\x77\x21\xbb\xb6\x86\xdd\x44\xf9\xa9\xa2\xb0\xd3\x6a\x54\xab\x19\xa3\x9b\x71\xa7\x04\x6c\x0e\x07\xf2\x39\x1d\x8c\x1c\x52\xba\xb8\xf0\xe5\xad\x6d\x2e\x96\x5a\x24\x76\x8a\xc5\x5a\x0e\x20\x22\xd2\x8a\xba\x53\x05\x18\x7a\xfc\xfa\x77\xe7\xe8\x0f\x3e\x7f\x44\xfb\xd8\xce\x25\x6f\x3d\x3a\x7a\x79\x87\xf6\xd6\x70\xc5\xda\x75\x63\xaf\x0b\x37\x4d\x93\x5f\x5d\xdf\x6f\x08\x2c\x6b\x3a\xd2\xb5\xf3\xe6\x87\xf7\x82\x3c\xf0\xe8\xa8\x63\xaa\x7d\xea\xc7\x77\x8d\x13\x42\xc2\x8e\xe7\xc8\x99\x7f\x8f\xa2\x64\x6b\xd8\xcd\x48\x88\xa2\xb0\x83\xd3\x69\x55\xbc\x8e\x37\xd1\xb4\x59\xc5\x6b\x74\x10\x45\xb1\xb2\xba\x08\x0a\xf8\x71\xf6\x21\x4f\xc4\x9f\x48\x0e\x0e\xc5\xa4\x83\x48\xad\x83\x15\x0e\x8e\xe3\xbb\x00\x76\xdf\xb2\x49\xe3\x52\xba\x65\xa5\x97\xa5\x0a\x70\xe6\xb5\xd9\xc2\xb2\x97\x41\x01\xb8\xd2\x6f\x31\xbb\xb9\x7e\xb5\x33\xe8\xcf\x6e\x3e\xd5\x7c\x89\xee\x05\x4b\x9b\x47\xd1\xa6\xe1\x61\x4a\xe4\xae\x93\x05\xd9\x77\xd1\x99\xea\x1a\x4e\x51\xab\x5c\x98\x91\x98\xb6\x58\x7c\xb4\xd7\x64\xaf\x8e\x50\x56\x60\x85\x56\xab\x89\x52\x71\x89\x75\xe0\x51\x00\xab\x78\x16\xb6\x95\x6e\xc6\x8c\x7f\x16\x6b\x71\xdc\x1b\x93\x23\x27\x40\x59\xde\xc5\x9b\x9a\x3b\x74\x7b\x5f\xc7\x87\x17\x67\xa8\x1d\x6c\x27\xd0\x5c\xb1\x77\xf6\xe2\xba\x31\x25\x3d\xea\x07\x36\xd7\x6d\x7a\x97\xb0\xd8\x2d\x5c\x99\xc3\xe4\x36\x9f\xea\xda\x50\x31\x1b\x9e\x78\x70\x41\xed\xb2\x2e\xeb\xef\x0e\xfe\x19\xaf\xab\x58\x93\x82\xf6\xa7\x9e\xaa\x0c\x67\x2b\x34\x72\x15\x8a\x41\xf5\x0a\x1d\xcd\x22\x1d\xa4\xd3\x19\x38\xb5\x4e\x5d\x17\x51\xe9\x29\x7d\x7d\x44\x4e\x51\x8c\x0e\x19\x50\x06\x12\xc0\x4a\x49\x17\x25\x95\xd1\x49\x6e\x64\x21\xd9\xa7\x46\x7f\x94\xa1\xcd\x8f\xff\x14\x03\xff\x2c\x20\x80\x43\xcd\xd0\x03\xbf\x71\x0a\x95\x60\xad\x43\x30\x0b\x3c\x9c\xeb\xb9\xbb\xdf\x09\x5a\x84\xf1\x30\x17\x5c\x6c\xd8\x28\x94\xac\x6e\xfe\xb1\x61\x2b\xed\x10\xf3\xda\xef\xa2\x97\xca\xd0\xd9\xff\x1d\xf9\x2a\x89\x7c\x95\xa2\x7c\x66\x2c\x5f\x65\x84\xe1\xfe\x5f\xe4\xeb\x03\x96\x82\x8a\xe6\x63\x4e\x58\xe2\x14\xae\x80\x1c\x87\x30\x59\x38\x49\x1f\x73\x36\x3d\xe4\x04\xc3\x84\xbf\xd3\x93\x40\xcf\x8d\xeb\x85\x4b\xab\x85\x63\x1b\xd7\x83\x11\xa2\x7c\x97\x84\xa1\xac\x9e\xe8\xcf\x01\xe1\x0c\xbb\x42\xc1\xba\x01\xc3\x53\x10\xfa\xf4\x3c\xef\xf5\xb8\xeb\x23\xac\xc7\x43\x6b\xb5\xa6\xba\x88\x5e\xaf\x75\x32\x80\x06\x75\x11\x3a\x36\x79\xb1\x2b\x84\xc2\xac\x44\xd9\xc4\x5b\x7f\x2c\x1b\xce\x75\x12\x36\x60\xe9\x6e\x9a\x78\x44\xe8\xdc\x33\xca\xa6\x1f\xbc\xf0\x57\x5f\xf3\xd1\x4f\xbe\x1e\x71\xbe\xe9\xe1\x9b\xc2\x4f\x79\xc7\xb3\xcf\xae\x9e\x74\x7e\x65\x97\x4f\xdf\xab\x44\xd6\xb0\xe1\x90\x60\xb1\x0b\xb7\xb7\x08\x4d\x2f\x8c\xbd\x78\xae\xe3\xb6\xa5\x55\x87\x6e\xde\x7f\xf2\x3c\xd2\x49\x2d\xdf\x21\x99\xcd\x48\x66\x07\x55\x1d\xce\xb2\x9b\x95\x2a\x95\xc3\x64\xc6\x7a\xc9\xc5\xf0\xbc\xd3\x6c\xb7\xd8\xd1\x89\x36\x99\x40\x7d\xc4\x64\xd2\x5a\xa0\x52\xa9\xd5\xa2\x70\x47\xeb\x8c\xb9\x74\xd2\xf5\x67\xe2\x94\xc6\x5d\x6a\x1c\xcc\x8b\xd7\x1b\xf8\x92\x9a\xc2\x77\xd4\xc5\x80\x18\x29\x38\xa0\x54\xf8\x5c\x68\x3c\xb1\x15\xd8\x4e\x6f\x5a\x24\xfc\xf5\xf5\x4f\x84\x9f\x4e\x82\xb2\x1b\x42\x9d\x0f\xfe\xea\x6d\xba\x0d\x0e\xd2\x93\x51\x30\x74\x77\xef\x19\xc0\x0d\x7a\x76\x37\x00\x1f\xbf\x04\x3a\x5c\x31\x80\x6f\x0e\x35\x08\x06\x24\xf7\xf3\xc2\x10\x26\x95\xe9\x88\x4e\xcc\x90\x70\x36\xb0\xeb\x38\x8e\xb6\xd9\x19\xb3\xd3\xe9\xc6\x16\xc1\x46\xd3\x68\xe1\x69\x5a\xef\xb0\x03\x07\xa8\x8c\x20\x0d\xa0\xd3\xeb\xd1\xee\xd0\x3b\x93\x7c\x51\xe2\x5d\xb4\x2d\xba\x1f\x53\xf5\xc5\x08\x4b\xf0\x45\x34\xd6\x59\x14\x16\x9f\x51\x36\x97\x82\x9e\xae\x8c\x15\xef\xce\x5b\x37\x6d\xd5\xf1\xfc\xa3\xb3\x84\x71\x4b\xae\x4d\x00\xda\xef\x85\x3f\xa5\xc0\xd9\xf0\x8c\x30\x6f\xfd\xc4\x6b\x0b\x96\xed\x9d\xbb\x5a\x23\xac\x9e\xfc\xc2\x82\xf7\x41\x66\x1a\x78\xe0\x69\xbc\x47\x9e\x14\x86\x32\x1e\xb4\x87\xb3\xa9\x91\xe1\x7c\xe4\xaf\xb9\xb3\x29\xca\x6d\xb4\x30\x32\xb3\xcd\x96\x1b\x94\xc9\x72\xec\x16\xab\xa5\x12\x4f\x39\x72\xa1\x83\x9c\xc9\x44\x5b\xb9\xec\x6c\x9a\xce\x44\xc3\x49\x9a\x74\x4c\xa7\x77\xef\x4e\x8e\x25\x23\x24\x79\x25\x26\x04\xa4\xc8\x8a\xe3\x9b\x08\x9b\x39\x1d\x24\x06\xba\x18\x2e\xdb\x2e\x54\xcf\xbc\x32\xa9\x20\xd2\xf0\xe4\xa6\xb9\xe1\xfe\x27\xd7\x3a\xc1\xfe\xe6\xc3\x4e\x38\xd6\x2a\xe4\xed\x3d\xbc\xa2\xd3\x89\xd1\x45\xb3\xeb\x3a\x3d\xf8\x10\x30\x4c\x1a\x27\x3c\x5b\xb1\x64\x70\xb7\xf1\xfd\xc3\x41\x4f\x4e\xc7\xcc\xc2\xf6\xce\x8d\x20\x73\xd3\x7c\xe1\x0a\xf7\xe0\xf8\xdd\x95\x69\xd9\x56\xad\x2b\xbb\x7b\xfb\x6e\x7d\x5f\x93\x78\xd3\x86\xa0\xd8\x27\x95\x1a\x11\x6e\xa7\x52\x9b\x5c\xea\x54\x34\x6e\xa3\x05\x04\x18\xa7\x5e\x9f\xee\xf4\x78\xd2\xbc\x4e\x8f\x13\x45\xce\xa9\x54\x6a\x7d\xc4\x48\x51\x3a\x8f\x41\xa5\xd2\xe9\xe4\xf5\x11\x1d\x93\x38\xd0\x7b\x4e\x2c\x1a\x66\xf4\x60\x18\xfd\x31\x94\xbe\x28\xcf\x03\x72\x55\xfd\x3a\x88\x6b\xc4\x30\x0d\x84\xff\x08\xdd\x6b\x44\xe5\xe2\xc9\x0f\x1c\x4e\x3b\x59\xf4\x9f\x67\x2f\x7c\xb1\x75\xb3\x53\xf8\xdf\xca\x53\xfb\xd7\x66\xd3\xef\xbb\x9b\x46\xda\x8a\x36\x9d\x3e\x23\x8c\xa1\xff\xd1\xe7\x91\x61\x63\x16\xce\x9f\x9f\x76\xf2\xfc\xcb\x0d\xe7\x76\xaf\x2b\x9d\x32\x7d\x5e\xf7\x3d\x4b\x47\x3e\xb2\xf6\x01\xf1\x6c\xe3\x5e\xcf\x0a\x72\xb6\x51\xe4\x69\xe5\x2d\x7a\x8d\xd3\xa9\xe7\x21\x63\x32\xf9\x58\x86\xf1\x5a\x79\x7c\x4f\x43\x19\x2d\x06\xa3\xa1\x2e\x62\x84\x94\xa2\x1e\x5f\xb7\x1a\xa3\xf6\x25\x61\xb3\x25\xef\x34\xd1\xa1\xcc\x05\xd1\x46\x25\x72\xa4\x91\x6f\x89\x2f\xdc\xc4\xe0\x9a\x01\x07\x56\x5c\x1e\xc7\x3c\xa3\x5c\x36\x73\xe6\xe9\xfb\x1f\xdb\xfe\x76\xe4\xb4\x07\xf6\xf1\x08\x8e\x8e\xf9\x6f\x7d\xb9\x55\xb8\x6b\x8a\x1c\x99\x6e\x5e\x32\x77\xca\x1b\xb3\x16\x2e\x05\xaf\x37\x34\x08\x6f\xbf\x79\xf9\x90\xf0\x8f\xad\xa2\xdc\x3f\xa1\x58\xad\x81\xf0\x0d\x0f\x0a\x67\xe9\xe4\x5a\x05\x34\x18\x14\x72\x68\x53\xab\xdd\x76\x9b\xcd\xa5\x93\x57\x46\x74\x3a\xb3\xca\x6e\x37\x9b\x29\x5c\x9b\xa7\x55\xaa\x94\x48\x89\x72\x89\x3c\x9d\x24\x62\x6b\x53\xf2\x34\x89\x9d\x41\x14\x58\x2e\x42\xdc\x61\xbf\x09\x8d\x06\x4c\x5d\xb8\x73\xd5\x8a\x7d\xfd\x4e\x3b\xa1\xc6\x29\x74\x6b\x97\x7d\xe6\xfa\xff\x7e\x70\xe1\xea\x49\x7a\xc6\xcc\xe5\xb3\xc7\xd6\x82\x75\x9b\x36\x09\x87\xb7\x3d\xfb\xfe\xc9\x43\x9a\xfa\x59\xc4\x66\x5b\x90\xac\x2b\xd9\x2f\xa8\x0c\xea\xbe\x70\xaa\x9e\x0f\x52\x54\xaa\xdf\xaa\x52\xf9\x79\x98\x99\x95\x0e\xa8\x94\x40\x4a\x55\xc4\xaa\x0d\x06\x38\xad\xa9\x12\xab\xd0\x38\xdb\xb4\xa1\x54\x94\x36\x19\x94\x1c\xe7\x9f\x09\xb3\xa4\x87\xbe\x87\x65\x8b\xb0\x4e\x63\x9f\xcf\x58\x0c\x0b\xe5\xe0\x79\xb3\xea\xbe\xc8\xda\x45\xdd\x7e\xf8\xfa\xd5\x97\xb4\x87\x34\x0b\x17\x6c\xda\xd6\x75\xc0\x85\xc9\xc5\xd0\xb3\xd2\xb1\xaa\xe2\x0f\xd5\x97\x1d\xf0\xe2\x94\xbc\xd4\xc2\x52\x5b\x5a\x9f\x29\xfd\x4e\x5f\x5c\xb3\xc9\x13\x19\x30\x65\x74\xbb\xce\xf6\x92\x8a\xd1\x3d\xf4\xfe\x86\x95\x60\xc4\x00\xa1\x06\xe3\x73\x8a\xf9\x98\x52\xc2\xdf\xed\xa2\x2a\xc2\x01\xa3\x56\x0b\x3c\x32\x9b\x1d\x22\x87\x83\x02\xc0\xad\x32\xa3\x09\xe6\xed\x06\x14\x19\xd3\x76\x3b\xa0\x39\xe0\x24\x59\xa3\x3c\x43\x69\x1c\xf3\x5d\x3c\xcd\x12\xc0\x7c\x00\x14\x8a\xc5\x69\x78\x82\x79\x80\xdb\xee\xc5\x1e\xb0\x6c\x60\x58\x76\x1e\xa4\x1d\x65\x95\x4a\xa6\xfc\xd9\x19\x07\x4f\x0a\x9d\x26\x7c\x35\x9d\x7e\xfe\x8d\xad\x57\xd3\xc7\x53\x2d\xc0\xb8\x0d\x85\x12\x5f\x66\xd6\xe4\x8c\xae\x3f\x7d\x4c\xa8\x16\x7e\xe8\x52\x93\x06\xa7\xfc\xe9\xdd\x9b\xcd\x3f\x0e\x7f\x07\x58\xd0\x9c\xbf\x8c\x44\x5a\x40\xf8\x41\x2d\x61\x25\xe9\xa5\xa6\xc5\x3b\xa0\x28\x43\x28\x96\xe5\xe5\x46\xf6\xc6\xaf\xed\x49\xac\xfc\x2a\xfa\xf2\x14\x79\x5e\x4e\xf9\xc2\x3a\xe4\x42\xc9\x29\xb9\x42\xc9\x02\xe4\x4b\x89\x69\xea\xc4\x5b\x23\x29\xf7\xf5\xea\x91\xfd\x47\xf0\x27\x90\x4f\x01\x18\x61\x90\x19\x80\x3e\xc3\x88\x6c\x4e\xa6\x8a\x55\x30\x1a\x8d\x1e\x68\x39\x8a\xd2\xb2\x48\x2b\xc9\x49\x47\x14\x43\xa9\x91\xfb\x5e\x17\x51\xf0\x14\xfa\x1f\xad\x35\x90\x32\x51\x83\x88\xbf\x90\x40\x53\x17\x5b\xf0\x68\x1e\xc1\x28\xb2\xd1\xf8\xc9\x1f\x91\x9d\xc6\xbf\x06\x6c\x3a\x03\xb6\x08\xb3\xf0\x9f\x33\xc2\x1c\xb0\x49\x98\xc3\xc8\xc0\x75\xa1\x6c\x8f\x70\x63\x8f\x50\x0f\x0e\xee\x01\xed\x5b\x5a\xa8\xfe\x68\x6c\x69\xa4\x16\x88\x89\xf6\xf8\xa8\xbe\x90\x09\x3c\xc1\xdc\x41\xdb\xb1\x33\xfb\xaa\x58\xab\x2b\x7b\x07\xcd\x85\xe2\x3c\xf4\xb2\xe9\xa4\xe0\x56\x7c\x56\xf9\x1c\x7b\x3b\xf6\x6c\xad\xf8\x2c\xbd\x5e\xb6\x57\x7c\xd6\xa3\x8f\x3d\xdb\xa3\xe5\x5b\xc5\x24\xf2\xec\x7d\xf8\x59\x7a\x3d\x4b\x30\x7a\xa8\x5a\x66\x36\x79\x96\x0e\xc5\x9f\x2d\x6f\xf9\x4e\xb1\x92\xd4\x8c\xe7\x89\x3d\xe9\xf8\x19\xd2\x1f\x54\x23\x9b\x44\x7a\x34\xc4\x9f\xf7\x97\x7e\x8e\x7b\xd5\x9f\x8b\xf6\xed\x92\x5e\xf5\x57\xa3\x9f\xa3\x7c\x9f\x7c\x4e\x3b\xf1\x73\xd8\x57\xa3\x9f\x23\x17\x9f\x17\x7f\xde\x5f\xfa\x79\x4a\xec\xf3\xab\x12\x3f\x5f\xc2\xad\x12\x62\xb8\x55\x62\x1f\x51\x0c\xd7\xbd\x4b\x23\x6f\x69\x03\xb7\xea\x76\x0c\x5f\x6a\x7d\x0c\xd7\x11\xe3\x90\x9e\x28\x0b\xb7\xc2\x15\xc5\x58\x07\x03\xe2\xf8\xd8\x4a\xdc\xba\x13\xc5\xc7\x7e\x55\xa6\xb9\x07\xeb\xe0\x13\x32\x8f\x22\xd6\xc1\xfa\xab\x14\x15\xb9\x4c\x71\x22\xce\x01\x47\xf8\x5a\xfd\xfe\x5e\x1c\xc6\x39\xe0\x30\xce\x01\x87\x71\x0e\x38\x8c\x73\xc0\x61\x9c\x03\x0e\xe3\x1c\x70\x18\xe7\x80\xc3\x38\x07\xe0\x92\x30\x2e\xac\x94\xc9\x70\x7b\x33\x4b\x56\x00\x17\xe2\xc7\xc1\x0f\xda\xc2\x80\x46\xe3\x3f\x42\xc5\x31\xa0\x4f\x79\x52\xdb\xec\x5d\xbc\x1d\xeb\x2b\x5c\x4f\xfd\x4a\xc5\xf1\x02\x1f\xf6\xa6\xb5\xea\x5d\x6c\x85\x11\x8c\x3e\x7f\x26\x15\xc7\x08\x5e\x64\xf3\xb4\xd9\x4f\x11\xc7\x8e\x5b\x1f\xc5\x79\x25\xd8\x71\x5b\x3c\xa9\x6d\xf6\x53\x64\xc5\x3e\xbf\x90\xfe\x1c\xfd\x07\x67\x98\x83\x34\x46\xaa\x42\x5f\x67\x39\xfc\x52\xb7\x03\x29\xb7\x4f\x7c\x8f\x6c\x8a\xf8\x1e\xb4\xbf\x27\x03\xa3\xd4\x1f\xd2\x0f\xd8\xd0\xef\xf3\xf0\x40\x3a\x28\x4f\x07\x98\xe4\x94\x06\x3e\x32\x7d\x1d\x30\x8d\xc5\x6f\xbc\xb7\x3d\xfd\x71\xec\xbd\x01\xf2\xde\x39\x3e\xeb\x6f\xbc\x77\xb8\xac\x29\xe1\xbd\x0a\xa9\x7e\xff\x1d\xf4\x5e\x7f\xd8\x02\x3f\x4d\x6f\x49\xa7\xa7\xa7\x1f\x4c\xa7\x0f\xa4\xbf\x99\x4e\x27\xbe\x7d\xe6\xcc\x0e\x6d\xbd\xbb\x03\xfd\x41\xec\xdd\xe9\xe4\xdd\x0b\x02\xbf\xf5\xee\xb1\xb2\x6f\x13\xde\x6d\x93\xe6\xb8\x1b\xfa\x57\x5e\xd8\x0f\x5b\x42\x60\x7a\x08\xbc\x89\xb9\x96\x96\x86\x0e\x84\xe8\xbc\x50\x79\x88\xc6\x0c\x4c\x74\x28\x69\x12\x88\x24\x6d\xce\x43\x11\xfd\x6d\xab\x79\x98\xee\x4a\xf9\xcd\xf9\x4f\x9c\x07\x96\x12\xb1\x08\xf3\xff\xeb\x79\xe8\x8a\xf6\x62\x80\x19\x60\x90\x21\x4f\x32\x76\x96\xe5\x5d\x63\x67\xb9\x90\x3e\x43\x59\x28\x4f\x58\xc9\x40\xda\xcc\xa6\x33\x98\x46\xa1\xb0\xd1\x60\x97\x68\x14\x44\x71\xa2\x67\x9a\xec\x85\xee\x92\x2c\x56\x69\x2f\x54\x21\x59\xf2\xc3\x5e\xe6\x40\x37\x50\xde\x0d\x70\xdd\x40\x37\x1a\x76\xd2\xa7\x33\xa6\xae\x15\x9d\xca\xd2\x20\xcd\x76\x2a\xb3\x12\x0c\xa0\x0e\x64\x4b\x46\x37\x48\x4c\x96\xac\x98\x2c\xc5\x34\xee\x8d\xc1\x7c\x0e\x7a\x91\xcf\x61\x78\xa3\xd1\x9c\xcc\xe7\xd0\x5a\x0e\x7a\x2f\xf5\xef\x96\xb3\x44\x8e\x4e\x48\x8e\xec\xb0\x1b\x1e\xe8\x02\xca\xbb\x00\xae\x0b\xe8\x42\x50\x89\xc7\x76\x2e\x2f\x29\x4b\xa3\xd9\x12\x49\x0a\x22\x44\x5c\x06\xc2\xeb\x20\x7b\x1c\x7d\xde\x3a\x71\x3c\x8c\x13\x54\x62\xdd\x66\x21\xba\xed\x6f\x8d\x16\x1b\x93\xd0\x53\x22\x62\x13\x93\x5e\xa9\xe3\x52\x9f\xf4\x1c\xf1\xec\xc1\x9e\xe8\x65\x27\x7a\xf6\xb2\x64\x27\xf5\x64\x2c\x40\xcf\xe7\x23\x9f\x38\x48\x3d\x18\xee\x96\x9e\x62\xb0\x1b\xf4\x01\x5f\xaa\x37\x35\xe8\x85\x30\x68\x57\xa9\x82\x7a\x98\x11\x82\xfe\x14\x7f\x7d\x84\x3a\x80\x19\x94\xf8\x14\x5a\x09\x53\xd2\xc3\xe9\x69\x75\x91\xf4\x74\x39\x72\xd4\xea\x22\x06\x83\x8e\x91\xbb\xea\x22\xf2\x68\x6e\x28\x56\x79\x46\x58\x6c\x71\xf5\x52\xc1\xbd\x60\xc5\x62\x86\x4e\xec\x24\x27\xfd\x6a\x4c\xac\x83\x98\x11\xf3\x1c\x49\x45\x41\xf8\x7f\xec\x99\x15\xf6\x95\xc6\x4d\xc2\x4b\xcf\x47\xab\x83\x3e\x01\xee\xa2\xe4\x8a\x20\x46\xa8\xb5\x83\xc7\x1d\xa4\x2e\x08\x5c\x58\x31\x66\xc1\xb4\x68\x61\xd0\xf1\x27\x12\x0a\x82\xf4\x2b\x56\x1c\x44\x7e\xd1\x2b\x18\x1f\x8a\xe9\x8f\xfc\xbb\x62\x6a\x71\xb8\x42\xc6\x66\x5a\x3c\xed\x38\xa8\x0b\xe8\x82\xc1\x80\x9a\x42\x0e\x5e\xc0\xc2\x42\x4d\xa9\xa6\x04\xf7\x0e\x56\x45\x64\x30\xa8\x35\x86\x8d\x39\x95\x11\xde\xe3\x34\x1a\x61\x0a\xe7\x6c\x5f\x19\x71\xf2\x50\x81\x7e\x02\x7d\x90\x86\x22\xd9\x51\xb4\x0c\x17\x53\x8c\x13\x58\xd3\x02\x7d\xe9\xbd\xb9\xed\xc4\xe8\x8e\x25\xed\xc4\xe2\x75\x39\xae\x72\x8c\x66\xfb\x0c\x22\xa7\x72\x21\x26\x5e\x91\x23\xff\x0a\x79\x86\xe2\xcd\x8a\x54\x6b\x0a\xa7\x97\x7c\x77\x4d\x38\x5b\x74\x24\xf0\x87\xd9\x5b\x83\xcd\x6a\x03\x2d\x14\xd1\xfd\x4f\x4c\xd9\xfb\x42\xdf\xe5\x97\x17\xcd\x3f\xe2\xa2\xe5\xa9\xec\x29\xb9\xd5\x78\xac\x9b\xa1\xb9\x6a\xc6\xf8\x09\xa7\x6a\x97\xcd\x98\xb7\xb9\xba\xf6\xd4\xa1\xef\xd3\xd6\xd7\x8e\xaf\x05\xdc\xec\x51\xd7\x1e\x5b\x02\x3c\xd7\x6a\xa7\x8d\x4a\xdb\xa8\xf4\x44\x26\x35\x1d\xad\x45\x9f\x3b\x67\xfd\x3f\x57\x2e\xde\xb8\x56\xf8\xf8\x5e\x3c\x32\x64\x03\x1a\xa8\x38\x1e\xd9\xc5\x94\xd0\xff\x81\x47\xb6\x9e\xba\x45\xc5\xf1\xc8\x66\x74\xe8\xd8\x06\xee\xd6\x21\xf2\xf9\xb9\xc9\xbd\xc0\x04\xf7\x61\x1b\x67\x6e\x03\x77\x6b\xa8\xbc\x20\x8a\xf7\x82\x7b\x8f\x40\x9d\xf8\x3c\x9d\x0e\x46\xdf\xf3\xfc\x74\x61\x08\xa9\x17\x20\x36\x92\xc7\x7d\x6b\x7f\x93\xb0\xa6\x87\xe0\xda\x5a\xd1\x16\xe2\x9f\x63\xcc\xe6\xe8\xf3\x51\xde\x03\x74\x8e\xf7\x81\xbf\x48\xe7\xa9\x23\x7a\x0f\xf2\x9d\xf2\xe2\x7e\x56\x05\x8a\x9f\x63\x58\x03\xf8\x59\xea\xdf\x14\x20\x67\x3e\x5d\xf4\xb3\xf2\x63\xbe\x93\x98\x8f\xc1\xe3\x04\x0b\xc5\x71\x52\x9f\x53\x71\xdc\xb5\x2b\xfe\x20\x9f\x64\xab\x5b\x1e\x45\xf3\xc8\xe2\x79\xa4\x07\x53\xc9\x3d\x56\xd8\x96\xde\xf2\xa4\x6a\x41\xd2\xf3\x18\xcf\xe7\x63\xfc\x3c\xf8\x45\xec\x91\xbe\x4c\x3a\xd0\x38\xdc\x45\x07\xb2\x91\x27\x44\xab\x5a\xcf\xbb\xea\x0b\xe2\x83\x05\x89\x4f\xd5\x39\xea\x83\x21\xdf\xf1\x54\xc2\xcf\x6b\xa5\x9f\x63\x3f\xb1\x26\x8a\xe1\xc8\x4b\xfe\x61\x6c\x7f\xdc\x89\xe1\xb1\x09\xf4\x70\xb1\xf7\x2d\x8d\xf4\xbe\xe5\x36\xfa\x02\xf1\x1d\x12\xdb\x1f\x5f\x46\xf7\x07\xb2\x9d\x92\x9e\x22\xb8\x6c\x7f\x29\x2c\x4a\xdc\x1f\x22\x0e\x87\x22\x03\xc5\xba\x2e\xaa\x3b\xbe\xb7\xd4\xdb\xed\x0e\xab\xd1\x68\x32\x39\xe4\xd0\xe3\xb6\x1a\x70\xa4\x6b\xb2\x9b\xa1\xc9\xa0\xa6\xeb\x23\x6a\xa3\x8c\x93\x70\x8a\xca\x0b\x93\x1a\x56\x62\xd7\xde\xa6\x58\x8d\x9b\x94\x52\x27\x17\xad\xd0\x8f\xf3\xbf\xcc\x2f\xb7\x96\x6c\xf2\xac\x7e\x66\x63\xe8\xdb\x37\x2f\x5d\x57\x76\x68\x06\x4b\x31\x55\xc0\x1c\xba\x65\xce\x95\x57\xd4\x20\x78\x6e\xe9\x6e\x5c\xce\xf6\xc6\x85\x43\x3b\x73\xf3\x00\xdf\x3c\x9b\x5d\xde\x7c\x9a\x1e\xdc\xa4\x2c\x23\x77\xc2\x2d\x7f\x43\x63\xfb\x1e\xe9\x54\x2d\x65\xc7\xb1\x96\x4e\xa9\x74\x5a\xcc\x0c\x84\x80\xc4\x5a\x0e\x99\xbe\x2e\x22\x63\x2c\xda\xd1\x11\x86\xb6\x58\x00\x0d\xdb\x8e\xb5\xa2\x97\xdd\x62\xac\x25\x17\xd3\xd0\x0a\xc0\x92\xcb\x56\x7c\x75\x51\x44\x19\x8e\x3d\x0f\xc6\x5d\x4a\x39\xf9\x97\x2b\xaf\x09\xdf\x09\x36\xe1\x1b\x38\x70\xce\xbc\xfa\xd3\x8b\x4c\x27\x6f\x82\x15\x9f\x22\x2f\x3a\xf3\xe4\xf3\x7f\xbc\xf8\x57\xc1\x2e\xcc\xae\x65\xce\xcc\x58\x3c\xbe\x71\x42\xd3\xb6\x7e\xe0\x7e\xdc\x5b\xd9\x06\x36\x4c\x33\x70\x49\x7b\x0b\x83\x45\xb5\xe3\x0c\xad\xb0\x56\xf0\x99\xb3\x88\xd8\x30\xa2\x9d\x27\x38\xd0\x44\x07\xa0\xed\xe5\x76\xfb\x92\xb1\x56\x88\xfd\xfc\x41\xe1\x16\xed\x27\x3a\x17\x0d\x60\x1f\xb5\x8e\xec\x0d\x0d\xc8\xa1\xe6\x87\x7b\x31\x98\x21\x92\xae\x0f\xcd\x08\xd1\x61\x4c\x0b\x49\x85\xf2\x43\xf4\xd9\xd0\x9d\x10\x7d\x30\xf4\x42\x88\xde\x16\x3a\x18\x22\x24\x92\x74\x65\x68\x19\xfe\x82\x1e\xc9\x0f\x85\x43\xb4\x0f\x3f\xc7\x87\x7c\xc8\xa5\xc1\x34\x49\xcc\x25\xf0\x87\x0b\xe9\x19\xc8\x12\x63\xa3\x6c\x89\xd1\x38\x75\x20\x0d\xe1\xa2\xb3\x13\x63\x4a\x8f\x62\xcc\x22\x3b\xbd\x4a\x7e\x24\x66\xa7\x1b\x30\xb7\x00\xe9\xd9\x3c\x44\x3d\x43\xcd\x08\x57\x30\x67\xab\x5f\xa8\xa6\xb7\x55\x1f\xac\xa6\x67\x54\x2f\xab\xa6\x2b\xab\xeb\xab\xe9\xfc\xea\x70\x35\x4d\x55\x83\xb7\xaa\xef\x54\xd3\xf1\x07\x96\x55\x83\xca\xea\xa5\xd5\xb4\xaf\x3a\xbf\x9a\xe6\xab\x41\x35\x21\x0f\x40\x62\x4d\x09\x6b\x2b\x07\xa1\x68\x02\xd2\x87\x62\x3c\x02\x71\x2f\x23\x46\xde\x3e\x33\xd1\xd6\xdf\x89\xda\x7a\x85\x00\xbf\x14\xe3\x18\x33\xb1\xf5\xbf\x36\x9a\xdb\xb2\xf5\x5f\x46\x6d\x3d\x35\x8f\x96\x74\x2c\xec\x81\x6c\xfd\x9d\x1e\x49\xb6\x1e\x7d\x3e\xe1\x4b\x21\x9f\xff\x98\x74\x46\xfb\x92\xcf\x87\x21\xe4\xce\x5c\x02\xfa\xc6\x50\x96\xca\x9c\xf0\xf9\x04\x5b\x9b\x7c\xfe\x15\xe9\x8c\x4a\xbc\x1d\x10\x05\x83\xf0\x2f\xa1\x2c\xb3\xea\x9e\xf5\xfe\x9b\x5c\x1f\xf5\x97\xe8\xb7\xe9\x63\x60\x90\x88\x57\x62\xc7\x0e\xd3\xd3\x9c\x8d\x69\xd5\x33\x2b\xc5\x62\xaf\xc5\x62\xb1\xb7\x69\x0f\xe6\xa6\xc5\xbf\x53\x81\x31\x4e\x3a\x95\x76\x6b\xcd\xd9\xd0\x3a\xde\xa3\x6f\xc3\x7a\xd0\x1d\xcf\x93\x83\xcc\x93\xa7\xd1\xd1\x16\x0e\xf2\x95\xd8\x3b\x6e\xd3\x4f\x4b\xba\xa6\x3b\xd2\x35\x2b\xbb\xb7\xe6\xa9\x20\xd8\x9e\x72\x43\x0c\x2b\xf4\x6d\xfa\x9f\x60\xb0\xd8\xfb\x8b\x81\x29\xc0\x24\xad\xe5\x1e\x8e\x26\x11\xdf\xf3\x5a\x0c\xdf\xf3\x6d\x5a\x41\x49\x58\x2d\xd9\x78\x1c\x9e\x94\xac\x7b\xb0\xff\x5b\x61\x88\xa2\x71\xcc\x42\xe3\x20\xf8\xd7\xe8\xfc\xed\xb7\xb5\x8d\xd9\x7a\x25\xf6\x8e\xdb\xf4\x7e\x69\x1c\x39\x68\x1c\x13\x73\x5a\x63\xb6\x76\x44\xca\xe8\x63\xb2\x1e\x22\x86\xdd\xdb\xa0\x5c\x5c\x0f\x1a\xe0\xc8\x18\x54\xb1\xf7\x72\x4d\x79\xd0\xef\x5c\x23\xe3\xf8\x51\xfa\x9d\x94\x68\xdf\x33\x87\x7b\xc8\xab\xdb\xf8\x1d\x8c\x95\x27\xc4\xe2\x63\x24\x17\xf8\x48\x1a\x07\x8f\xc6\x71\x90\x6f\x8d\x4d\x86\xf9\x06\x9e\x27\xe3\xf8\x51\x7a\x7e\xaf\xa4\x47\x78\xa4\x47\x96\xde\xf3\xbc\xc8\x59\xa4\x8f\x61\xff\xbc\x0d\x4d\xd1\x7d\x15\xc4\xfb\x2a\xe4\x4e\x6f\x13\x3b\xa7\x80\x8c\xa3\xba\xf5\x7a\xe0\xcd\x4b\xdb\x3d\xc1\x64\xec\x9c\x7b\xe3\x68\xb4\x1e\x4f\x89\xe3\xa0\xd1\x01\xa1\xe7\x87\xda\xc6\x18\xba\x12\x7b\xc7\x6d\x5a\xc2\x49\xa0\x33\xd0\x54\x45\x32\x5a\x63\x0c\x11\xbc\x13\x32\x8e\x0e\x92\x4c\xa7\xa3\xe3\x48\xc1\xe3\x30\xd9\xfc\x22\xe2\x49\x82\x4c\x38\x9f\xf0\x33\x19\xc7\x10\x69\x3d\x46\x44\xd7\x03\x07\xeb\xc0\x63\x72\xcb\x5b\xe3\x00\x88\xb8\x2a\x2d\xb1\xf7\xdc\x86\xc3\x40\x0f\x22\x17\x8a\xe6\xe8\x39\x81\xb6\x70\x60\x32\xc9\x38\x86\x48\xe3\x90\xb0\x74\x31\x3c\x01\x58\xec\x6d\x8d\x03\x23\xc6\x8b\xfa\x18\xfe\xc1\xdb\xf4\x7f\xa2\xfb\xca\x8f\xf7\x15\x67\xf5\xb5\x89\x4d\xd0\x87\x8c\x63\x98\xf4\x3b\xd6\xe8\x38\x82\x78\x1c\x46\x77\xfa\x6f\x60\x20\xc4\xf2\x0e\x68\x1c\x0d\xd2\xbe\x42\xd3\x05\x26\xa4\xb4\x8d\x13\x71\x25\xf6\x8e\xdb\x74\x14\xa3\x18\x63\x96\x0c\x09\xb5\xc6\x89\x28\x13\x4a\x13\x31\x56\x14\xbf\x80\xf9\x94\x84\x9d\xb2\xa7\x31\x33\x2f\x01\x63\xa5\x34\x11\x63\x45\xf1\x0b\xf5\x5c\xf4\xb9\xa7\x1a\x33\x72\x63\x18\x2b\x97\xd0\xe7\xc5\x30\x50\xc8\x73\x77\xa4\xe7\x84\x57\x1a\x95\x3a\x51\x77\xe3\x73\x29\x94\xe2\x1a\x19\x09\xcb\x44\xa6\xf8\xe5\x0b\xe9\xd3\x06\x37\x3a\xbc\x50\x2b\x81\x28\x80\x96\x2b\xc8\x37\xbd\x8f\x7d\x84\xf2\x52\x55\xe1\x2c\x8d\x9d\x71\x1b\x8c\xc8\x3e\x38\xdd\x76\x99\x9f\xa2\x7c\x4e\x99\x42\xa9\x18\x1d\x51\x2a\x29\x8b\xc1\x60\xb1\x70\x75\x11\x0b\x43\x81\xd1\xb1\x0b\xdb\xc4\x2c\x79\x32\xa8\x09\xf6\x29\x60\x71\x2a\xd5\xa1\x7d\x50\xc6\x92\xbf\x93\x6f\x2b\x2c\x66\x9e\xea\xe9\x03\x9b\xc1\x89\x9c\x5b\x42\x81\x1f\x9c\x02\xf3\x96\xcd\x9c\x71\xbc\x6a\xed\xac\xef\x8f\x5d\xfe\xec\xed\x11\xcd\x3f\x08\x43\x8e\x4e\x04\x23\xbe\x9c\x56\xba\x61\xeb\x93\x4b\x00\x77\x61\xcc\xec\xa1\x93\x23\xdb\x16\xbe\x74\xe8\xcb\xfd\x33\x76\x0a\x1f\x0a\xfd\x89\xfc\x8f\x08\x43\x61\x84\x19\x40\x05\xb0\xfc\x66\x0b\xe3\xe7\x5c\x2e\xbf\x57\x66\x51\xca\xa8\x34\x2a\xd5\x2b\x13\xd3\xfa\x2a\xca\x6e\x36\xdb\x71\xea\xd9\xce\x53\xa0\xfa\xbf\x96\x3f\x1b\x60\xf9\x19\x79\x71\x17\xd8\x6a\x00\x32\x5c\xb6\x4b\x4d\x72\x83\x81\x20\x3b\xd8\x53\xf8\x78\x8b\xfb\x87\x3f\x2e\xe9\x5e\x53\x19\x59\x59\xd8\x50\xf6\xc1\xb1\x03\x67\x06\x8f\xbb\x4f\x18\x29\x0c\xdd\xdb\xef\x5f\x67\xea\xf3\x82\xf7\x7b\x1f\x2e\x1f\x3a\x76\x51\xdf\xca\x31\x23\xc7\x17\xac\xdf\xb4\x7f\xc3\xa4\x43\xfd\xc6\xae\xbb\x23\x5c\x88\x9e\xa5\x04\x3c\x60\x14\x97\x6c\xa2\xe2\x78\xc0\xd7\x75\xa6\x36\xe2\x92\x01\xf2\xce\x06\x09\x0f\x98\x5e\x0f\xb2\xc1\x64\x11\x0f\x18\x3d\xff\x95\x2b\x25\x09\x0f\x18\x50\x61\xa1\x86\xb5\xb1\xbb\xd0\xa0\x8b\xc3\x2e\x95\x5e\xc3\x71\x6a\xb5\x06\xda\x34\x36\x97\xdb\x2c\xc3\x4d\x69\x7a\xb1\x36\x00\xbb\x88\xc8\x47\x2c\xcf\x4a\x82\x20\xc0\xb1\xb3\x52\xea\x45\x4b\xc0\x91\x8b\x2e\x24\x80\x3d\x80\x42\x37\xf5\xa1\xba\x57\xb7\x18\x31\x76\xdc\x45\x8d\x9b\x19\xfe\xed\xda\xa7\xae\xe9\x85\x26\xf4\xde\x1e\x3d\x8b\x1e\x98\x3b\xf5\x7c\x7d\x14\x32\x6e\xfd\x9a\x73\xe7\xfb\x8f\xf8\xf5\x4d\x82\xb1\x85\x7c\x58\x8c\x5b\x98\x4a\x15\xa2\x39\x98\x19\xee\xa4\x2b\x2e\x36\x7b\xda\xb5\x83\x99\x9d\x3b\x3b\x79\xbf\xdf\x09\x61\xd8\x6c\xee\xca\xfb\x9c\xd0\x66\xb0\xa1\x10\xd8\x6d\x73\x6a\x29\x43\x59\x65\x24\x45\x85\x4c\x27\x25\x97\xe7\x90\x2a\xe5\xb4\x84\x2a\x65\x31\x27\x40\x22\x62\x52\xde\x19\x23\x63\x30\x24\x51\x18\xb5\xae\x5c\x2e\xc4\x7e\xba\xe4\xff\x92\x1b\x13\x5c\x94\x57\x0e\xee\xed\xb8\x94\x48\xbb\x39\x90\xdc\x7d\x59\xdd\xf8\x6f\x4f\x79\xf1\xac\x87\x0e\x6d\x9d\xb4\xdc\x54\x59\x37\x6e\xed\x8e\x0c\xd8\xe7\x68\x42\x17\x26\x3d\xaf\xb4\x5f\xfb\xec\x9e\xf7\xb1\x1d\x13\xfa\x31\x1f\xbf\x6b\x3c\x60\x5d\x3c\x75\xe5\xc3\x93\x22\x7d\xc7\x8d\x79\x6c\xfa\x7b\xe3\x22\x49\x8d\x99\xc2\xcc\xae\x9d\x73\xda\xb7\x2b\x2a\xee\x2a\xd6\x0f\x23\x5b\x70\x9d\xe4\x51\x0a\xa9\x71\xe1\x0e\xed\xf8\xa0\xdd\x9e\xea\x76\x5b\xb2\x54\xa9\x10\xaa\x64\x46\x0b\x2f\x6b\xdf\xc1\x24\xf7\xe5\xfa\x72\xeb\x23\x3e\x9f\x96\xd2\x86\xea\x23\x5a\xa3\xdd\x81\xbb\xf8\x82\x54\xb0\x5e\x2c\x4b\x17\xe9\x9d\x92\xe0\x0b\x48\x1f\x43\x22\x61\x98\x8d\xbf\x4e\x42\x18\xc2\x48\xce\x91\xbf\x18\x52\x91\x88\x26\x05\xb7\xce\x16\xca\x63\xc5\x97\xf8\x56\x09\x46\xb9\xcc\x31\x04\x5b\xfb\x17\xdf\x7e\xf6\x11\x30\x77\x85\xf0\x9c\xf0\xc3\xa7\xff\xba\xfe\x34\xf8\x0b\xe0\xee\xd8\x1f\x7d\x64\xf3\xaa\xb9\xfb\xab\x67\x2f\xf9\xe9\xca\x3b\xbb\x76\x9c\xff\xf0\x51\x76\xb7\xec\x89\x1d\x5b\x5f\x77\x33\xd6\xdd\x73\x3e\xfa\xe5\xb9\x27\x0e\x7e\xe8\x62\xca\x8f\xee\x39\xbe\x02\x4e\x1e\xde\xb7\xb2\x72\xdd\xe0\xaa\xf1\xec\xdd\x89\xa7\x1b\x1e\x98\x7d\x7e\xfb\xcc\xd9\x78\xfc\xf5\x68\xfc\x0d\xec\x3b\x68\xbf\xb4\xc3\xb7\xf6\x19\x16\x9f\x2c\x85\x49\x71\xe7\xf1\x8c\x52\xc9\x6b\x1c\x6e\x8b\xac\xa0\xd0\xa9\x41\xe7\x3e\xad\x0a\x99\x7f\xa3\x4f\x2e\xf3\x52\xc6\xac\xca\x88\x31\x0a\x77\x54\x28\x05\x6a\xf7\x0c\x57\x6a\xe3\xc7\x83\x09\x16\x5b\x62\x43\xa6\xa4\x22\x4c\x3c\x66\x3e\xcd\x4a\xee\xd4\xc8\xdd\xb8\x5f\x1c\x37\x7d\xb6\x76\x7d\xe5\xe4\xe1\xd7\x9f\xd8\x0e\x26\xcc\x12\x6e\x09\x77\xff\xf8\x59\xed\xd1\xc9\xe0\x19\x50\x1d\xfe\xcb\x82\x6e\x53\x8f\xd6\x02\x7a\xe6\xd1\xc8\x46\x38\xb9\xdf\xee\x61\x8b\x2a\x66\x4e\x7c\x65\xe3\x8d\x2c\xc6\xb5\x7f\xc6\x8f\xc2\x37\x2f\x9f\x5c\xf0\xd2\x2a\x3b\xd3\xbb\x11\x38\x57\xcd\x9c\x7c\xbd\x6e\xe2\xca\x89\x17\x26\xff\x75\xf4\x93\xd3\xa7\xad\x24\x7a\xed\x03\xe1\x27\x52\x93\x62\xa4\x3a\x86\xdd\x94\x4e\xc9\x2a\x01\x34\x40\xb3\xc1\x64\x64\x0d\x6c\x5d\x44\x6d\x30\xb4\xae\xa3\xb8\x1e\xbf\x2b\x46\x03\x42\x7f\x15\x44\x0b\x28\x44\xea\xe4\xa0\x84\x9d\xc1\xe8\xc5\xea\x93\xbb\xff\x43\x8f\x9a\xbd\xb2\x6c\x6b\xa8\x4b\xd7\xa6\x17\x71\xb1\xc4\xc6\xbb\x47\xa7\x4f\x9c\x38\x21\xa7\x6f\x87\x76\xd9\x5b\x49\xdd\x89\xf0\x13\xa9\x3b\x31\x61\x19\x68\x83\x5a\xae\x86\x2c\xc5\x5a\xa8\x58\x7d\x09\x90\x53\xf8\x1e\x15\xf7\xe3\x5c\x8f\x5f\x9b\xb6\x92\x21\x7a\x03\xef\x17\xd5\x66\x10\xcf\x5c\x20\xdb\x09\xdd\x62\x91\x49\xd3\xe7\xe0\x9d\xd9\x2b\x3d\xd6\xad\x9c\x7d\xe9\x7a\x98\xbe\x71\x7d\xd3\x47\xb3\x26\x76\x1a\x9a\x91\xe3\x2a\x4b\x1b\x93\xe8\x8b\x1f\x8d\xf9\xe2\x7b\xc1\x33\xd4\x47\xd8\x17\xd7\x13\x5f\xbc\x7d\xa3\x8e\x6f\xc3\x17\xbf\x11\xf3\xc5\xf7\xe2\x9c\x31\xf1\x4d\x3a\x62\x3c\xf6\x92\xb2\xd6\xbe\x38\xd2\x53\x31\xdc\x7e\x8c\x2b\x06\x66\x88\xbe\x30\xd2\x4f\x31\x9c\x7e\x82\x37\x76\x2b\xc1\x57\xcc\x8a\xdd\x85\x14\xc2\x54\x31\x97\xcd\x40\xec\xfd\xa0\xaf\xe7\x7d\x41\xc9\x5b\x4c\xcc\x65\x13\x5f\x8e\xe4\x6d\xab\xa5\xfc\xb1\x25\xf9\x2e\x81\x39\x10\x04\xe5\x41\xc0\x05\x41\x90\x86\xfe\x7b\xee\x12\x5a\xbf\xb7\x84\xde\x1d\xf5\x37\x7d\xd8\xb7\x7b\x3c\xa3\xa8\x4d\x1f\xb5\xab\x6c\x5f\x2c\x6f\x44\x70\xb3\xa4\x77\xf6\xa1\xd2\xc2\x76\x98\x57\x04\xea\x8a\xa6\x17\xd1\xe5\x45\x03\x8b\x68\xae\x08\xa0\xff\x17\x61\xec\x47\x29\x45\x5c\x2b\xe6\xd0\x45\xbf\xf5\xcb\x98\xdf\xba\x97\x56\x22\x99\xf1\x9c\x7a\xd1\x22\xec\x70\x79\xda\xf4\x5b\x6f\xc4\xfc\xd6\xbd\x31\x6c\x4c\x1f\x5a\x83\x45\x6e\x6f\x5b\xd8\x95\x09\x63\x2b\xc6\x7d\x5e\xe2\xd8\xbc\x78\x6c\x17\xfd\x81\xb6\xfd\xef\xf8\x7c\xa2\x75\x36\x48\x79\x70\x3c\x9f\xf6\x30\x07\x0f\x04\x40\x79\x00\x70\x01\x10\x48\x18\x51\x02\xb6\xd3\xa1\x28\xf6\x12\xfa\x9d\xf7\x24\xbc\x73\x8c\x43\x94\xaf\xd2\xb4\x89\xed\x34\x28\x86\xed\xb4\x91\xfa\x98\x8a\x63\x3b\x6d\xb5\xb7\xe2\x11\x12\x5a\x84\x1a\xba\x2b\xb2\x6d\x06\x14\xed\xf4\x0c\xa7\xd2\x2e\x97\x96\x02\xc0\x22\xd7\xca\x79\x1f\xef\x65\xec\x95\x11\xda\xa0\x85\x0c\xee\x52\x37\x56\x46\x38\x95\x93\xc2\xf7\xbc\x85\x92\x4a\xc6\xa4\x50\x49\x2d\x5b\x44\x3f\x15\x82\x56\x06\xaa\x98\x4d\x34\x47\x5d\x1b\x85\x6f\xcb\x4a\x13\x6d\x10\x60\xa2\x46\x87\xbd\xf1\xeb\x5c\x4b\x82\xa5\xf9\x3e\x6e\x58\x68\xd2\xf7\xf4\x3d\xd3\x9f\xca\x44\x3e\x6a\x4d\x38\xbf\x7d\xc8\xc1\xb2\x21\x8a\x37\x6a\x64\xc5\xb9\x29\x29\x25\x6e\x3a\x04\xd3\xbc\x69\x48\x91\x66\xa6\x39\xad\xe8\xc0\x5b\x79\x6f\x3b\xa4\x55\x39\xaf\x17\xb9\x12\xb8\x2b\x2e\x21\xb1\x24\x56\x6d\xc6\x18\x90\xe2\x75\x45\xbf\x8b\xe0\x9a\x34\xae\xb4\xc4\x41\x9d\xda\xb0\x75\x6d\x5b\x90\xae\xb3\xcb\xe2\xd6\x16\x5c\x8a\x0e\x53\x78\x63\xdf\x03\xf4\xd9\xb6\x20\x5e\x9b\x1b\x63\xc3\x5f\x92\x30\xf6\x16\x64\x53\xe8\xc3\x6c\x36\x65\xa7\xd2\xa9\xba\x70\x81\x36\x35\x95\xb1\xaa\x34\x0a\xb7\xdb\x60\xd0\x40\x2b\x83\x34\x42\xd0\x6e\xe6\x7c\x95\x11\x2d\x6d\x85\x1c\x67\x66\xcd\x0e\x5c\x2e\xa2\x61\x58\xa6\x2a\xa2\x94\xb3\x1c\x25\x15\x94\xc7\xcc\xa9\x95\x4c\x44\x2b\x97\x83\xcc\x41\xb0\x28\xb1\xac\x3c\x36\xe6\x84\x21\x93\xb2\x8d\x83\x6b\xb7\xcf\x8a\x15\x97\x8f\x0c\x17\xcc\x7a\xe8\xe0\x96\x8f\xd2\xd1\x30\x9f\x2f\xed\xd1\x3e\xbb\x4b\x85\xbc\xb4\x7e\xcf\x74\x7a\x20\x41\xd3\xf3\xa2\x51\xad\xda\xf9\x07\x69\x50\xb9\x7e\x5b\x59\x17\xb1\xfe\xc5\x29\xd4\x80\xe3\x48\x77\x6b\x29\x77\x58\xab\xe2\x68\x9d\x92\x54\x5a\xc6\x4b\xe1\xc9\xf2\x20\x1f\x37\x09\x40\x7d\xac\x08\xa3\xdb\xd1\x40\x20\xd3\x25\xcc\x5c\x09\x2a\x1d\x52\x25\x2d\xdf\xca\x3e\x44\x7b\x3a\x8d\x6a\x4f\x55\x50\xa3\xc3\x1d\x0a\xa0\xcf\xef\xcf\xd2\xe9\xf5\x59\x5d\x6d\xb6\x2c\x08\xbb\xf7\xf0\x9b\x53\x3c\x2a\x3d\x63\x76\xb9\x3a\x57\x46\x5c\x16\x73\x07\x34\x59\xbc\x96\x92\xe7\x12\x47\x2d\x3d\xb9\x9d\x2c\xe6\xb1\x59\x4b\x13\x69\xcf\x7e\xd3\x3f\x4b\xc6\xbe\x0a\x06\xe4\x81\x36\x20\x31\x92\x3a\x72\xc0\xaa\x44\x17\x6d\x50\x02\x16\xd6\x0f\x15\x30\xfb\x88\x27\x19\x29\x83\x91\xc7\x1b\x74\x12\xbd\x34\x11\x7b\x47\xec\xcf\x79\xe5\xe9\x83\xad\xd0\x33\x60\xff\xd6\x38\x59\x25\x42\x8d\xec\x5d\x66\x20\xb2\x56\x05\x54\x57\x2a\x12\x2e\xc8\x87\x19\x25\x1a\x6d\xb9\xd5\xaa\x2d\xf1\x41\xb6\xa2\x9b\xdf\x8d\xe6\xc8\xe4\xe5\x9c\x1d\xf1\xb5\x8e\xa9\xb0\x32\x62\xb2\x68\x9d\xf2\x6c\x82\x38\x94\x96\x8c\x38\x14\x87\x0a\xb1\xde\x43\x97\x9f\x30\x15\xe4\x50\xc5\xae\x73\x70\x43\x18\xd9\x67\x18\x80\x28\xb1\x3a\x1a\x24\x4d\x16\xbb\x0e\xcd\xc5\x27\xa7\xef\x54\xb0\xae\xa1\x8d\xc3\x2c\xea\xd6\xb3\xd3\x77\x7f\xf9\xaa\x63\xc3\x97\x3c\x80\x27\xe4\xae\x90\x30\x51\x03\x9f\x3b\x72\x43\x58\x71\xe1\xfa\x61\xa1\x27\xb8\x36\xd5\x47\x26\x07\xcd\x16\x9a\x9c\x31\x83\xd0\xb4\xbc\xbd\x6a\xc5\x1a\x71\x3a\x9a\xce\x27\x01\x8d\x30\x2d\x7b\x5b\x76\xb1\xcf\xb1\xdf\xa0\x7d\x69\x44\x5b\xc1\x4e\x0d\x0e\xe7\xa9\xf5\x14\x0f\x4c\xbc\x5e\x67\xb3\xca\x65\x4a\x85\x56\xeb\x54\x38\x18\xbb\xce\x8e\x22\x13\xab\x42\xcd\x53\x26\x46\xa9\xd3\x29\xf4\x1a\x25\x94\x29\x0c\xa4\x41\xe2\x56\xf9\x2d\xec\xc9\x91\xe4\x75\x42\x89\x5c\x5c\xd9\x18\x03\xd0\x0f\xd0\xee\x00\x85\x56\xa4\x35\x0b\x01\xda\xda\x46\x79\x21\xfa\x31\xe3\xb8\xf5\x52\x5f\x61\xa6\x30\xfa\xf4\x90\x2b\xb0\xf2\xc3\x42\x60\x3b\x73\xf7\x7f\xc7\x83\x48\x3e\xec\xb0\xfe\x66\x53\xd3\xd7\xbf\x54\xc0\x4f\x9b\xfc\xa0\xa1\xf9\x97\x29\xec\xf2\x9f\x40\x5d\xd3\x7d\xe0\x2c\xe0\x15\xa3\x85\xe3\x2d\x42\x01\x81\x6b\x45\xfa\xb2\x00\x8d\xe1\x07\x34\x06\xcc\x06\xf8\x40\xb8\xc4\x6b\xb4\xe8\x4d\x6c\x8a\x5a\xa3\xa1\x28\x17\x8d\xa2\x2f\x0b\x1b\xf2\x78\x32\x52\xd8\x54\x47\x6a\x5d\xc4\xed\x08\xbb\x1c\x10\x52\x0e\xc6\x2f\x53\x70\x0a\xdc\x23\xca\xe9\x51\x00\xc6\x61\x66\xe8\x3c\x7d\x21\x7f\x23\xda\xda\x57\x88\xbf\x75\xf0\xb7\xee\x0d\x45\x25\x1d\x82\x99\xa2\xad\xf2\x74\x91\x0d\xba\x98\x94\x96\x06\xe5\x01\x63\xba\x3e\x4a\x19\x2d\xb1\x02\x32\x34\xdb\x7d\x62\x7a\xa3\xad\x43\x33\x73\xff\x76\x0c\x6b\xb4\x15\x23\x20\xbd\xbe\x7e\xe3\xe9\x37\xb7\x61\x0c\xa4\x33\x2b\x67\x9d\xb9\x5b\x7e\x1f\xfd\xdd\xb0\xb9\x18\xfa\x88\x35\x0d\x59\x51\xdc\xab\xb8\xa9\x7b\xb7\x9d\xdb\x22\x57\x4f\x0c\x7d\x12\xc0\xfd\x00\x62\x08\xa4\xb2\x2d\x4d\xfd\xf6\x4f\x83\xc7\x43\x4f\x0b\xcf\x23\x5d\xb9\x10\xd9\x89\xc3\xe8\xfc\xbb\x91\xae\xac\x0d\x17\x7a\xcc\xc8\x44\x20\xbf\xc7\xcd\xd2\xb4\xd3\x6f\x34\xb3\x86\x90\x21\xe8\x42\x0a\x86\xf5\x19\x79\x99\xce\x6e\x0f\x54\x46\x20\xb4\xf3\x06\xa7\x5a\x8d\x16\x10\x39\x8a\x71\x08\x24\xe9\xfa\x96\x1c\xfc\xd6\xb7\x95\x49\xe3\x14\x4b\x50\x83\x20\x00\xa2\xfb\xda\x58\x18\x23\x3f\x84\x2b\x6a\x55\x4f\x33\x46\xa1\x7f\x4e\x99\x04\x88\x34\xbe\xbf\xf0\xd3\x5e\x50\x34\x75\xfb\x0f\x67\x06\xf5\xf9\x4f\x43\x53\xc4\x02\x9e\x4c\xcb\x5d\xd2\x30\x14\xfe\x7b\xc8\x36\x7b\xfb\xcc\xe6\x52\x13\x41\x46\xf2\x0a\xfd\x40\xf3\xd4\x37\x30\x3c\x92\x0d\xec\xbe\x7b\x79\x68\x19\x7d\x4d\xb7\x56\xf8\x88\xc4\xcb\x79\x22\x57\x00\xda\xa3\x5d\xc3\x29\x5a\x85\x1a\xca\xe5\x40\xc9\x02\x8d\x9a\xd5\x71\x72\x2d\xee\x05\x61\x28\x4a\x4d\xab\x15\xd8\x0f\xc7\x0e\x78\x79\xbc\x82\x39\xe9\x02\x1a\xdf\xab\xe0\x8e\x74\x09\xab\xda\x18\x18\xb0\x65\xce\xf3\x73\xc0\x56\xaf\x30\xb3\x9e\xfe\xa3\xa7\x69\xe1\x92\x2d\x30\x93\xae\x69\x3e\xd1\x20\xe8\x1a\xe8\x2d\xd8\x1e\x3d\x8d\xf6\xd6\x34\xb4\xb7\x70\xe3\x6a\x9f\x70\xd0\xa0\x37\x1a\xd5\x6a\x56\x06\x28\x99\x86\x51\xf2\xbc\x59\x69\x32\x42\x02\x30\xab\x67\x54\x72\x46\xc6\x51\x5a\xa8\x94\xa1\x33\x71\xa3\xbc\xf0\x16\xe1\x92\xa4\x0a\x13\x4f\x43\x6c\xe3\x60\xf0\x0e\x5c\xcf\x1f\x00\x22\x57\x18\x28\x0e\xb0\x8e\x6e\x9e\x43\xc2\x90\x4d\xd7\x06\x0a\xe3\x4f\xd3\x8b\xa7\x09\x2e\x0f\xdc\x3d\xf8\x4c\xf3\xd5\x57\x76\xb1\xcb\x1b\x9a\xbf\x69\x6e\x07\x76\x09\x14\xf4\xd0\x05\x0d\x93\x04\xf8\x1f\x31\x97\x20\x13\x86\xe2\x3c\x15\xd5\x01\x79\x0a\xd9\x6a\x87\x23\x48\xb1\xb9\xb9\xc6\x14\x2a\xa5\xb8\xc8\x91\x0b\xd3\xd2\xb2\xaa\x22\xa1\x50\x1a\xaf\x52\x69\xb5\x8a\xea\x88\xd6\x09\xad\x55\x11\x93\x89\x85\x04\x04\x3b\x2f\x9e\x73\x89\xde\xdf\xb7\xd1\x10\x47\x6c\xa2\x15\xf7\xaf\x5a\xd1\xbf\x72\x69\x3a\x56\xbe\x98\x0b\xc4\xfa\xc5\x42\x5f\x0c\x4b\xc6\x03\xac\x1e\x1a\x6e\xfc\xcf\x37\xc5\xe1\x0d\xc5\x7d\x3a\xf5\xae\x1c\xbf\x3a\xaf\x4f\x79\xc7\x7f\x97\xee\xce\x59\x34\x6f\xeb\xc3\xd9\x35\xeb\x96\x2d\xeb\xfe\xb7\xdb\x60\x4c\xf6\xe3\x96\x45\x13\x1e\x5a\x9d\x39\x70\xeb\xd2\xe5\xbd\x40\xe7\xc7\xcf\xa8\xae\xf6\x2d\x9d\x31\xc6\x9a\xd3\x13\x8c\x7f\xa0\x66\x78\xd7\xd1\xb5\x99\x9d\xdb\x65\x67\x56\x4e\xb9\x6f\xfb\xbe\x16\xfb\xc0\x9e\x03\x7b\x65\x96\xe5\xe4\x84\xaa\x67\x88\xf6\xf4\x3d\x61\x28\x89\x85\x9c\x18\xe9\x47\x65\x35\x59\xec\x76\x37\x65\x36\x9b\x5c\x0e\xab\xcd\x5a\x19\xb1\x71\x66\x14\x26\x21\x3d\x6e\x56\x2a\x35\x1a\x79\x75\x44\x93\x5c\x70\x1d\x8b\x8c\xa2\x25\xcb\x38\xab\x52\xec\xa1\xad\x1e\x50\x2c\x8e\x33\x3d\x0f\xe4\x82\x2c\x20\x05\x4b\xaf\x77\xe8\x5b\x96\x3b\x34\x52\xdc\xa1\xd7\xe0\xd9\x0b\x7b\x4c\x29\x5b\xe4\x0e\xf7\x6d\x70\xc4\x63\xa6\x0d\xb4\xa3\xb0\xfb\xaa\x75\x4c\xf7\x99\x53\xbb\x8e\x7c\x31\xc7\x2b\x45\x4e\xe2\x1a\x1d\x45\xf1\xd2\xe3\xec\x6e\xca\x4a\x75\x09\x7b\xb5\x3a\x2b\xa5\xa3\x6c\x72\xa3\xd1\x0e\x2d\xf5\x11\x80\x54\x11\xaf\xd5\xf2\xbc\xaa\x3e\xc2\x93\xd2\xc5\x84\x24\x98\x54\x81\x1f\x6b\x39\xf3\x1b\x13\x8a\x00\xe4\x41\x03\x41\x63\xa4\x58\x08\x86\x4d\xcc\xef\xb7\xe8\x95\x29\x7b\xd6\xad\x79\x31\xf7\xe4\x0a\x70\xe2\xcb\x7f\x08\x2f\x09\x77\xfa\xd0\x36\xdd\xbc\xf7\x37\xad\xdf\xb7\x70\x96\x1b\x8c\xf8\xf4\x5d\xe1\x9f\x42\xa3\x46\x58\x45\x64\x1a\x86\x71\x17\x98\x01\x68\x92\xda\x87\x9d\x2c\xcf\x53\x6a\x68\xb6\x00\x63\x55\x04\x00\x4a\x4b\x76\x0b\x72\xb1\x78\x82\xec\x90\x98\x94\x13\xcf\x12\x96\x24\x2a\x87\x24\x06\x72\x1f\x21\x60\x07\x4f\x3f\x36\x6c\xd2\xb0\x17\xba\x3e\x39\x09\x54\x9d\x7c\xf5\xe6\x0b\x9d\xc1\xd9\xea\x3d\xa3\x47\x8f\x7d\x59\x07\x2a\xce\xef\xb9\xf0\x7d\x9a\x70\x9d\x82\xa4\xef\x91\x27\xfd\x1d\x1e\xe4\xbb\x4c\x0c\x17\x5b\x80\xde\x6b\x36\x43\x95\xc3\xa1\xd5\xa6\x28\x14\x46\x48\xa1\x48\x32\x68\x46\x01\x75\x7d\xc4\x40\xab\xbc\x1e\xaf\x07\x45\xd6\x5e\xda\xab\x67\x30\x4a\x9d\xde\xc0\xa4\x49\xed\x1e\xd4\x3d\xf0\x95\x89\x67\x3e\x59\x59\x13\x38\x8a\x24\x00\x4b\xdc\x62\x21\x6f\x05\x62\xb9\x7c\xad\x63\xed\x33\x40\x48\xc4\xaf\x04\x0e\x50\xeb\x10\x1e\x4f\xbd\x07\xc6\x12\x0c\x59\x0d\x8f\xc5\x11\x2c\xc1\x47\xab\xaf\xc6\x41\x2c\x69\x2a\x8c\xb9\x18\x49\xcf\xb6\x17\x9d\xce\x1c\xb7\xd9\x00\x1d\x0e\x20\x57\x2a\x15\x6a\x96\x55\x28\xec\xc0\x64\x60\x7d\x7e\x87\xda\x8c\x41\x17\x15\x48\x87\x71\x34\x87\x86\xc7\x19\xe5\x58\x89\x15\xc6\xc1\x48\x25\x28\x7e\xd0\x3a\x65\x16\xd3\x67\x22\xca\x86\x9c\xa6\x48\xd7\x2d\xb2\xb3\x3e\xdc\x82\x87\x9d\xd7\xda\x39\x73\x9f\x9f\x0d\xb5\x73\xae\xcd\x99\xeb\x9e\x67\x6b\x2f\x9c\x11\xbe\xff\x9b\xf0\xa3\x73\x0e\x3d\x0a\x2c\xeb\x6f\x69\xfa\x51\xaf\x7f\x0a\x66\xd0\xc3\x9a\x8f\xe3\x3f\x7b\x96\x08\x77\x84\x6f\xee\xdc\x1e\xb4\xa5\xf9\x67\xb0\x7b\xf6\x70\xdc\xfe\x86\x62\xad\xc3\x14\x60\xbe\x62\x57\x18\x64\x70\x00\x85\xfd\xa9\x0e\x2d\x5e\x76\x16\x52\x72\x98\xcf\xcc\x49\x8d\x0a\x17\x9a\xf4\xd0\x66\xa3\x19\x95\x52\x67\xb0\x68\x1d\x8c\xc2\xa5\x50\xb8\x35\x56\xd6\x5a\x17\xe1\x9d\x26\x67\x5d\x44\x6b\x42\x3e\x83\x3c\xcc\x42\xbd\x8d\xb1\x11\xb4\x15\x0c\xc0\x7d\x4b\x3c\x88\x8e\x5b\x85\xad\xab\xeb\xa3\xaa\x12\x0f\xd0\x8f\xbd\x4a\x20\x11\x96\x49\x7d\x31\x00\x7d\x81\xb8\xbf\x7e\xe2\xae\xfd\xbb\x36\x02\x3d\x4c\x19\x7d\x60\xf4\x30\xcf\x61\xe1\x5d\x50\xe6\x11\x16\x0b\x57\xe8\x37\x3d\xcd\x36\xd0\x03\xe4\x34\xff\xf5\x3d\x0b\xe8\xd9\xfc\xf9\xe7\xec\xf2\xed\xdb\x25\x66\x01\xe4\x8a\xbc\x7c\xf7\x22\xc0\xf5\x6e\x4c\xcb\x02\x64\x43\x5f\x23\xbc\xd6\x69\x54\x16\x95\x4f\xad\x0b\xf7\x4d\xd7\x6b\x38\xb4\x37\xd2\x42\x79\x3e\xb9\xc3\x61\xcd\xb6\xbb\x5c\xf9\xb9\x56\x5f\x88\xd3\x2b\x74\x05\xba\x76\x36\x8a\xca\x4c\xcb\xac\x8c\xe4\xa5\x85\x00\xa7\x61\x54\x32\xab\xc3\x97\xcb\xa4\x99\x65\x69\xb2\x34\x95\xd9\x9c\x82\x3d\x6c\x9d\x53\x05\x2b\x23\x2a\x4b\xac\xf3\x4c\xda\xa2\x64\x64\x12\xd1\x35\xa9\x13\xbf\xc7\xd6\xc6\x4d\x2e\x8c\xb3\xb9\x47\xcd\x2d\xf6\x2a\x90\xf7\x44\xf8\x06\x8c\x62\xb7\xa7\xc9\x6a\x0c\xc8\x40\xfb\xa0\xbc\x90\xae\xfd\xb2\xb4\x72\x54\x43\xbb\x0d\x03\x3f\xdb\x3b\x7d\x88\xf0\xcd\x5e\xd0\x6d\xee\x16\x40\x1f\x1a\x57\x09\xe8\x06\xe1\x83\x35\x36\x41\x75\x3d\xaf\x68\xcd\xc5\x34\xbf\xff\xe4\x1f\x94\xf4\xe2\xac\x5d\x57\xc1\xcf\xc2\x6e\xc7\xf0\x48\xf9\xba\xd9\x01\xa1\x17\x68\x99\xfe\xd6\x6b\xa0\xfc\x69\x07\x78\x54\xc8\x9a\xf8\xc6\xa4\xb1\x1b\x40\x99\xee\xd4\xbe\xbb\xb5\xe5\x40\x5b\x02\x54\xe3\xca\xbf\x8b\xf6\x1f\xa4\xa2\x3d\x6d\xa7\x06\x86\x33\xa0\x0d\xb9\x1a\xc0\x66\x67\x78\xa5\x5c\xee\xe4\x1d\x4a\x3b\x85\xbc\x44\x19\x45\x69\x19\xa9\xbb\xc8\x18\x6b\xcc\xa2\x92\x3b\x8b\x62\x6d\x14\x09\x9d\x2e\x04\x59\x0f\xef\x63\x91\xc1\x5e\xb4\x32\xe5\x68\xb1\x3f\x04\xec\x50\xe1\x2f\x1e\xf0\xf9\xbc\x0d\xee\x0d\xb9\x39\x5f\xbe\x78\xe0\x35\xc7\x71\xeb\x8c\xb1\x93\x56\x78\x32\x85\xbb\x30\x03\x5c\x6d\x68\x3e\xfe\xe8\x37\x5f\xbe\x7f\xe5\x69\xff\xdc\x87\x76\xee\xff\x50\xac\xc9\xc0\x31\xd7\x4f\x04\x5b\xc6\x8e\x31\x01\xd1\xf6\xe4\x79\x14\x46\x2a\x21\x6d\xb1\xd9\x9c\xb4\xc3\x6a\x19\x14\xb1\x52\x06\x95\x5a\x85\x22\x7e\xb5\x9a\xd2\xb6\x0a\xc9\xa2\xdb\x32\xb9\x16\x3e\x7a\x19\x11\x0b\xd4\xe2\x28\x37\x3a\x80\xeb\xb5\x62\x41\xdb\xec\x19\x8e\x19\xc3\x1b\x47\xa0\xaf\x0b\xbc\x9b\x80\xde\xdf\xe8\x8f\xb2\x9e\x0c\x5c\x0d\xde\x16\xf2\x56\x37\xef\xde\xbf\x5a\xf6\xda\xe9\xd3\x48\x57\xcc\x14\x6a\x30\xb7\x21\xda\x87\x99\x78\x66\x43\x26\x4a\x9d\x22\x73\xb9\xd4\x26\x98\x95\xed\x84\x29\xa9\x36\xe4\xba\x3a\x6c\x8c\xdf\xcb\x7b\xeb\x22\x3a\xde\x88\xb4\x08\x9a\x59\xa5\xf3\xde\x1e\xe1\x84\xfe\x83\x68\xdc\x26\xf6\x0e\xe1\x4e\x5c\xdc\x6c\x20\x23\x30\x9d\x7c\xd4\x47\x95\x81\x04\xbe\x0e\xe6\xe9\xdc\x6c\x53\x57\xce\xdb\xa5\xff\x7b\xb2\xac\x3d\x37\x2e\x0b\x3f\xaf\x7f\x0f\xac\x17\xfe\xb0\xe3\x90\x57\x78\x5f\x2e\xd8\x7f\x58\x7f\xa1\xfe\xef\x57\x85\x3f\x1f\xfa\xf4\xc9\x76\x19\x4a\xf6\xb0\xee\x75\x53\xc9\x47\x23\x36\x03\xf6\x49\xa4\xac\xb7\x7d\xd8\xbf\xe4\x57\x4d\x08\xf8\x26\xc0\x27\xc7\x36\x0a\x57\x6e\xbe\xfe\x35\xf1\xcf\x71\xde\x6e\x1c\xe1\xa1\x69\x8f\xd7\xa1\xc0\x9c\x45\x51\x3a\xb5\x9b\xf5\xfb\x5d\x6a\x33\xd3\xa1\x88\x73\x19\x7c\xbc\x3d\x17\x5f\x06\x19\x50\x48\x6a\xb0\xc8\x14\x0a\x58\x1d\x51\xc4\x06\x97\x88\xce\x18\x1b\x59\xe2\xe0\xa2\x5d\xc6\xc9\x21\x97\x54\x40\x87\x2c\x93\x2c\x39\xce\x82\x93\x73\xb3\xd3\x0b\x7c\x85\x7d\x47\x4d\xf7\xa5\xc7\xe1\x98\x51\x54\xaa\xf6\xc9\x9e\xb4\x66\x9e\x97\x0b\x23\xe2\xd1\x15\x1a\xa9\xe6\xb0\xe6\xfe\x51\x9d\xf6\x9f\x89\x06\x56\x13\x47\x15\x2d\x53\x0f\xf8\xb0\x69\x6a\x08\xe8\x93\x91\x1b\xf1\x78\x95\xf8\x2e\x96\xd8\x37\x07\xd5\x2b\x9c\xe6\x90\xa1\x00\x40\x8f\x21\x6d\x79\x05\xcb\x38\x5d\x3c\x2d\x93\xcb\xd0\x6a\xca\xe5\x8c\x52\x69\xc7\x30\x88\x7a\xa2\x0f\x93\xbc\xd6\x24\xb7\x95\xe8\x41\x28\xd1\x37\x1a\xef\x01\x86\x60\x9c\x3f\x0a\xf7\xcd\x7c\x7e\xd6\x71\xf7\xf1\x15\xf4\x58\x11\x19\x42\x23\xcc\x20\xc8\x10\x43\xc6\xd1\xbd\x9b\x2f\xd2\xbd\x77\xd3\x87\x45\x64\x88\xa3\xf4\x67\x51\x64\x08\xe2\x3f\x62\x2e\x43\xe4\x07\xd8\xa8\x01\xd8\xbb\x45\x33\xaf\x51\xb1\x28\x3e\xb0\xdb\x6c\x0e\x9b\xc5\x42\x57\x47\x2c\xbc\x02\x39\xb8\x95\x11\xd6\x80\xfc\x14\x15\xcf\xa9\x62\x09\xa6\xc2\xe4\x1c\xb3\x04\x51\x27\xe9\x6d\x12\x11\x90\xc4\x0a\x91\xda\x20\x46\xbf\x68\xcb\xd1\xb7\xb2\x73\x47\xee\xcd\x7c\xc6\x7d\xa1\xae\xb1\xee\x41\xf7\xa2\x1e\xda\x93\x01\xa6\xdb\xb2\xc1\xc1\x12\x78\x52\xfb\xe4\x8e\x1d\x82\x03\xfc\x75\x07\x18\x35\xf6\x2f\xab\xa7\xea\xc4\xf9\xdc\x8d\x73\x83\x64\x3e\x4d\x54\x38\x1c\x00\x94\x51\x6e\x92\xa9\x35\x4a\xa5\x59\xaf\xb7\x18\xe4\x26\xa8\x54\x29\xeb\x23\x3a\x8a\x91\xab\x54\x32\xbd\x06\x62\xff\x9b\xd4\x80\x95\x96\x46\x6d\x67\xd4\xac\xc4\x3d\x6f\x88\x84\x0a\x16\x5a\xb1\xeb\x6d\xf4\xb3\x9a\x47\x5d\xff\x11\x96\xcf\xbc\x36\xfb\xed\x7f\xb8\xb6\x4c\x79\x79\x22\xdd\xf1\xf9\x3f\x35\xfd\xfa\xb3\xb0\x82\xd9\xbb\x43\x28\xc7\xcd\xb4\xe0\xc5\x1d\x7f\xfd\xeb\x5f\x9b\x47\x81\x4c\xa2\x5b\x48\xfe\x91\xf8\x9f\x7e\xaa\x6f\x38\x68\x33\x00\xca\x6b\x30\xb3\x2a\xa7\x33\xa0\x72\xe9\x99\x14\x1f\x34\xe2\xce\x39\x1b\x65\x32\x29\x1c\x16\x4e\xa1\xad\x4c\x40\x38\x24\x06\x2f\x2a\x59\x14\xe4\x50\x6a\xb1\xc4\xe2\xe9\xe8\x40\xbc\xc5\x16\xc9\x09\xd1\xa2\xa3\x30\xab\x0b\x92\xd4\x00\x0f\x4d\x77\x1f\x15\x8e\x4f\x5f\xbb\x73\x64\xaf\x4e\xde\x1c\x5f\xcd\xf6\x01\xce\x79\x8f\xbb\x27\xf6\xb8\x18\x06\x4b\xaf\xbc\xda\x3c\x5c\x13\x7c\x5c\xf8\xb6\x8c\xfe\x6a\x47\xf3\x93\x2f\xee\xed\xaf\x5b\xa3\x98\xb5\x2e\x8f\xbe\x6f\x07\x18\x22\x9c\x02\x43\x9a\x36\x38\xfb\x80\x4c\xe1\x16\x99\xd7\x9e\x48\x97\xf7\x40\x6b\x8f\xeb\x60\x87\x85\xf3\xf2\xd5\x56\x1b\xc3\x71\x99\xbe\xa0\xcf\xa6\x66\x4a\x4b\xb8\xcc\x2a\x14\x58\x71\x9c\x93\xb2\x5a\x9d\x4e\x53\x65\xc4\x69\x51\x14\x56\xe2\x4e\x18\x7c\x9f\x93\x90\x12\x89\x3b\x88\xb8\xff\x29\xc9\xf5\x42\x0e\x0a\x72\xb8\x62\x79\x22\x86\x95\x27\x32\xe9\xc4\x60\xe9\x48\xcf\xb5\x31\x7a\xab\xab\x03\xf2\x77\x6b\x87\xb0\xb2\x41\xe7\x96\x6c\x7a\x4a\xf8\x59\xf8\xe4\x6f\xc6\xc9\xa3\xe6\x2f\x72\x9e\xcb\xf9\xf4\xea\xa9\x57\x8d\x7d\xd4\x55\x4e\xbf\xae\x5b\xe3\xab\xf3\xd7\xf5\xcd\x1a\xdd\xbf\xbe\x61\x02\xcf\x74\xef\xdf\x2f\xbc\x64\xdc\xf1\x15\x97\xaf\x31\x70\x8c\x7b\x44\xcd\x90\x1a\xf7\xce\xd5\x07\xd7\x86\x6b\xc1\xa2\xfc\x50\x6f\xf9\x0c\xbe\xf9\x13\x06\xa6\x95\xd6\x74\xe9\x3b\xaa\x7a\x5d\x3f\x09\x2f\x76\x04\xd2\x49\x16\xa4\x95\x7a\x86\x53\xd5\x2e\x23\xd4\x6b\xf5\x3c\xaf\xd1\x06\xa0\x16\x06\xd3\x4d\x2a\x8d\xde\xac\xe1\xe4\x5e\x92\x28\xb3\xb6\x4a\x94\x25\xc2\xc2\x4b\x8b\xd7\x2a\x3d\x56\xf8\x7f\x43\xc4\xfa\xcf\x1f\xfb\x1d\x74\xd8\xf3\x4d\x47\xda\x84\x86\x45\xb2\xfb\xd0\xba\xb5\x43\xeb\x86\x39\xf1\xbb\x87\x53\x19\xb7\x16\xaa\xd8\x54\x13\x26\x32\x94\x99\x64\xa1\xa0\xc8\x86\xcf\x68\x65\x4a\x4e\x66\x4e\xa4\xc3\x8f\xc1\x90\x97\x26\xc3\x90\x13\x58\x1d\x79\xeb\x34\x70\xdb\x70\x3a\xee\x73\xc7\x2c\xea\xe3\x28\xd6\x4d\x26\xc2\x97\x40\x74\xce\xc1\xda\x87\x46\xab\x67\xa6\xb5\xa6\xc1\x8f\x61\x8f\x8b\x78\xdf\x1f\xa1\x53\x93\x8f\xec\x5c\xa6\x35\x37\x17\xaa\x83\x1e\xe8\xd2\xb9\x30\x9a\x3a\xd4\x15\xb4\xc3\xfd\xe8\x26\xa0\xf6\x60\xcc\xef\x4c\x92\x81\x4b\x69\x1b\x4b\x3d\x81\xa7\x4f\x4f\x40\xf9\xef\xc5\xfd\x4e\xc0\xc0\xfb\x2f\xd0\xbf\x5f\x4c\x00\x09\x72\x5b\x7e\x17\x02\xfc\xaf\x04\x27\xa8\x76\xec\x23\x55\xf7\x80\x80\x03\xca\xd6\xf2\x1d\xbc\x46\x74\x6a\x49\xd8\x45\x43\xc8\x73\x56\x05\xa7\xb0\x3b\x34\x48\x21\xa0\x1d\x66\xa1\x69\x96\x45\xb1\x29\xcb\xb7\x81\x01\x1e\x43\xa1\x89\xc6\x55\x74\x42\xc3\xa0\xa1\x03\x4f\x67\xdf\x1c\xdc\xb0\x10\xf4\x7a\xe1\xd6\xf6\x1f\xce\x9c\x78\x45\x85\xf1\xa5\x97\xee\x1d\x0a\x5f\xf8\x6b\x3b\x50\xf1\xd1\x2b\x7f\x14\x8e\x3f\x7e\xf2\x61\x0c\x2c\x0d\xd2\xb7\x12\x2a\x07\xa4\xab\xfe\xd2\xf2\x04\xfc\x3b\x92\x27\x8d\xca\xc3\xf7\x09\x72\xda\x95\xc3\x64\xb0\x46\x43\x46\x8a\x43\xa9\x4c\x31\x40\xb4\x01\xbc\x59\x95\x11\x57\x8e\x9c\x66\xbc\x5e\x4a\xa7\xb3\x54\x46\x8c\x46\x1d\xc9\x0f\x33\x78\xef\xdc\x4a\xf2\xde\xc4\xcb\x90\x78\x32\x4c\xda\x42\xe2\x0d\x48\xb4\x78\xdd\x03\xa4\x94\x00\x9a\xef\x28\x49\x96\x04\x90\x89\x0e\xbb\x07\x80\x3b\xa7\xe7\x4e\xb0\xce\xe9\x52\x57\x3c\x60\xdb\xeb\x1b\xa6\x1d\xa9\x65\x9e\x96\x4f\x1a\xb9\x6c\xef\x50\xe5\x8c\xe7\xc6\xcc\x5d\x53\x7f\x79\xe9\xfc\x0d\x33\x76\x37\xba\xc6\x9a\x86\x3e\x94\x32\xb2\xff\x84\x11\x8f\x4d\x07\xfa\x57\xea\x2b\x77\x8c\xb4\xd7\x4f\x5e\x2b\x7c\x30\xaf\x20\xf3\xfe\x11\x33\xee\x1f\xb5\xad\x6a\xcd\xa8\x7e\xc3\x2e\xa7\x04\x25\x3f\xe3\x04\xe1\x25\xc6\x7b\x2b\x0b\xef\x2b\xb7\xce\xcd\xe5\x42\xc8\x99\x61\x3b\xad\x4e\x57\x60\x33\x56\x47\x70\xcd\x82\x57\x45\xc9\xc9\xe6\xe2\xc9\xe6\xb2\x24\x45\x92\xe5\x92\xbb\xd7\x0a\xe0\x22\x29\xf7\xdd\x0a\xdc\xc4\xf8\xbb\x50\xd0\xd5\x8d\xc2\xab\x71\x7c\x9d\x62\xba\xff\xe1\x70\x9b\x70\xd0\x8f\xff\x72\x29\x8e\xb2\x03\x0c\x63\x06\xb5\x3e\xfa\x12\x27\xfe\x74\xe9\xfc\x54\x85\xb3\x72\xa1\x0a\x9f\x1e\xad\xcb\xa9\x45\x2e\x2d\x84\xed\x0c\x86\x02\xaf\x4a\xee\x32\xf3\xe6\xea\x08\x0f\xda\x18\x63\x2b\xa0\xeb\xf8\x18\x5b\x67\xf8\xcb\x41\x22\x82\xe4\xff\x0d\x78\xed\x73\xed\x8e\x41\xcc\x34\xfe\x1e\xec\xf5\x9e\x95\xbb\xd0\xd9\x19\x39\xae\x69\xd4\x6f\x60\x5f\x87\x71\x8c\x81\xf6\xab\x11\x59\xd7\x8a\x70\x8a\x4e\xab\x75\x52\x26\xa3\x8c\x92\xb9\xdc\x4e\x74\x6e\x74\x4e\x1c\x5e\xa9\x78\x1c\x60\x41\xa4\xea\x20\x7f\x6f\x22\x20\xaa\x1c\x44\x13\x54\x2c\x1e\x25\x39\x46\x71\x97\xec\x2a\x2d\xe6\x50\xfa\x33\x63\xc0\x17\x2f\xde\xd4\xd5\x0a\xc6\x43\xaf\xfb\xf7\xe4\xbe\xb5\xfd\xa5\x74\x3b\x9c\x3f\x7d\xed\xd9\x5c\xf0\xb3\x8d\x2e\x7f\xff\xd5\x41\xfd\x9b\xff\xbc\x68\x4d\xee\xb1\x97\x5f\xd8\xd0\x71\xe9\x96\xfd\x27\x91\x7c\x52\xff\x12\x3a\xdf\x3e\x64\xfb\xd3\x7d\x28\xbc\xe0\xec\x36\x85\x52\x69\xe3\x6c\x29\x7e\x9b\x1d\x99\x7d\x9b\x51\x63\x74\xe3\x4a\x07\xe4\x4f\x69\x50\x50\xa1\xe1\x7f\x0b\x68\x3a\x56\xf3\x80\xef\xe4\x5a\x15\x35\x61\x02\x00\xbc\xbd\xac\x72\xd1\x66\xc2\x89\xca\xd5\x6b\x46\xef\xcf\xde\xd0\xfb\xf3\x83\xaf\x7d\xba\x45\x10\x0e\xdd\xfc\xd2\x76\x80\x59\xbe\x10\x45\x75\x74\x45\x71\xd9\xea\x2d\xf5\x83\xca\x57\x2e\xf8\xf4\xf5\xd7\x84\x17\x9f\xc6\xa4\x71\x1b\x24\xa2\x38\x9a\xea\xd6\xf2\x1d\xfb\x26\x92\x39\x95\xca\xa6\xa6\x84\x4b\xd1\x8c\x66\x66\xea\xb2\xb2\x52\x58\x99\x2c\x25\xc5\xa9\x83\xe6\x1c\x73\xae\xc1\x5a\x1d\xc9\x72\x66\x52\x68\xd3\xa4\xea\xb4\x94\x81\x42\x6a\xca\x00\xbd\x2a\x6f\xb0\x32\xe2\xb5\xa8\x68\xdc\x2e\x4c\x25\x5e\x12\xe5\x25\x90\x90\x67\x25\x67\xc8\x0d\xd1\xa8\x4e\x1a\x10\x8d\xf7\x54\xb1\x15\xab\x31\x31\xbd\x86\x54\x34\x2d\x9d\x1e\x2b\xef\x47\x83\x63\x65\x70\xa6\xe9\x27\x3c\xba\xe2\x87\x4e\xcd\x7a\xea\x63\xe3\x13\x34\xc8\x29\x2c\xee\x97\x3e\x61\xe2\xe4\x07\x00\xab\x7e\xa4\x69\xcf\x6b\x9f\xdb\xf6\x02\xaa\xe1\x65\x7d\xf3\x6e\x39\xfd\xee\x8f\x68\xb0\xa3\xc6\x17\x5f\x7e\xc2\xb9\xbc\x57\x79\x60\x43\xc9\x96\x05\x2f\x08\x7f\xde\xfb\xce\xa5\x01\x4b\x6f\x0a\x77\x7f\xf9\x60\x5a\x0e\xa9\xcd\x22\x7d\xe7\xfd\x0d\x32\x38\x81\xe4\x0d\x7f\x44\xdf\x2f\x43\xf3\x90\x4e\x0d\x0d\xe7\x98\x2d\xca\x54\xde\xe5\x4a\xf5\x69\x2c\x6c\x88\x81\x30\xe8\xd3\x12\x57\x57\xab\x15\xeb\xd3\x8c\xa4\x3e\x4d\x86\xb4\x20\x51\x83\x05\x79\xad\x6b\xd4\x70\xc2\x09\x24\xc7\x85\x6c\x74\x8b\xe1\xb5\x2c\x8e\xde\x23\x06\x63\x2a\x50\x6e\x26\x35\x3c\x60\xe9\x89\x3f\x3a\x8f\x87\x5e\x9b\xf9\xe0\x8e\xfd\xae\x67\x8f\x8f\xad\xbe\x98\x7d\x24\xfd\xe5\x27\x0f\xbc\x38\x60\xc3\x90\x89\x0f\xfd\xdd\xb4\x68\x55\xf6\x13\x93\xea\x6b\x6b\xd7\x8c\xa9\xef\xd1\x73\x9b\x69\xf9\xf2\x2d\x73\x07\xcc\xeb\xa3\x64\x34\x1b\xeb\x1f\x3b\x2f\xf6\xd3\x33\x02\x1a\x47\x21\x35\x23\xdc\x09\x8d\xa3\x9d\x8b\xcf\x74\x67\xb6\xcb\xd5\x58\x64\x30\x35\xb5\x03\x1a\x4c\xfb\x1c\x71\x30\xfe\xf4\xea\x48\xa6\xdb\x6f\xd7\xfa\xb5\xfe\xff\x66\x58\xb8\xb3\x19\xd7\x6b\xc5\x47\xa7\x4f\x86\xe6\xfa\xbd\x11\xb6\x5a\xe2\xf8\x70\x57\xb4\x39\xdc\x55\x8d\xee\x45\xd2\x2a\xd7\x8e\x19\x35\x53\x01\x53\x77\x0d\x6d\x73\xf4\xe3\x86\x99\xc4\x45\x9e\x38\xb9\xdb\x20\xb9\x34\x0b\xa2\x3e\xfc\x1e\x7e\x83\xe6\xc1\x42\x85\xa8\xc1\xe1\x6c\xb7\x8a\xa3\x38\x87\xcc\x4b\xa5\xa5\x79\x1d\x30\x33\xc3\xad\x96\xa2\x7b\xa0\x86\x6a\x75\x8a\x35\x05\x56\x46\x52\x2c\x56\x03\xbe\x34\x4f\xaa\x50\x8b\xd2\x3f\xb6\xaa\x43\x42\xca\x23\x0a\x94\x96\x85\x42\x49\x69\xb0\x3a\x1a\xc4\x6a\x0e\xc5\x3d\x6c\x48\x15\x96\x3d\x38\x7d\xd1\x84\x51\xd5\xce\x7e\xf3\x36\x44\xaa\x27\x6c\x1e\x53\x08\x76\x1c\xbe\xb4\x67\xed\xfb\xdf\xdc\x78\xf5\xd3\x2d\x40\x0e\xf6\x6d\x6b\x98\x32\x7a\xc0\xb0\xcd\x93\x46\x75\x1f\xd0\x7f\xdf\x67\xf4\xc0\xcd\x73\xa7\xed\x71\xe5\x5f\x6d\x68\xfc\xe6\xe6\x8b\xa0\xe2\xa8\x98\xd7\xae\x16\x86\x82\xbb\x28\xae\xb0\x50\x65\x61\x37\xc6\xad\x33\xd1\x26\x1b\x0a\x1d\xad\xd0\x62\xb6\x54\x45\x64\x66\xb3\x1a\x29\x3e\xb5\x13\x44\x9b\x5d\x12\x51\x77\xa3\x00\x3d\xc5\x52\x3e\x30\x31\x8e\x08\x14\x6f\xb9\xdc\x78\xf9\x51\xc7\xa3\x2e\x6b\xdf\xa5\xa3\xba\x95\xda\x33\x0a\xba\x74\x37\xd9\x6e\x3b\x56\xc2\x8b\x4d\xbd\x57\x6e\x9f\x31\xa3\x94\x5f\xa3\xac\x18\xb3\x80\x60\x07\xe0\x5e\x1d\x76\x1a\xb2\x33\x99\x54\x29\xce\xd0\x66\xe9\x9d\x05\x4a\xa8\x08\x2a\x42\x21\x77\x50\x1f\xa4\xfd\xfe\x8e\x90\xa6\xcb\xbc\xa9\xd5\x11\x2f\x50\xd9\x75\x16\x4b\x87\x4a\x14\x29\x42\x88\xbc\x07\x14\xc8\xeb\x92\xe8\x64\xa5\x29\x8e\xd9\xd7\x78\xb7\x4b\x92\x0b\x87\xe9\x2a\x62\xd2\x62\xd1\xe3\x8d\x70\x1d\x90\x35\x32\xc4\x8d\x91\x0e\x80\x98\x13\x47\x80\x41\xc1\x66\xe1\xc9\xa2\xc7\x03\xaf\x6e\x69\xf0\xa5\xd0\xa5\xa3\xe7\x57\xee\xbd\xdc\x77\xc5\x95\xa5\x73\x8f\xba\x58\x8f\xaf\xe3\x1d\x64\x96\xf2\xbd\xc8\x2c\x7d\x90\xff\x1f\xa1\x61\xd2\xf8\xa9\x67\x47\x2f\x9b\x31\x7c\x41\x75\x89\x50\xd3\x94\xb9\x6f\xe7\xf1\x33\x83\xab\xb2\xdf\x78\x62\x35\x68\x7f\x63\xf4\xd4\x51\xcc\x91\xdd\xc0\x46\xec\xd3\xdd\xfd\xff\xfb\x27\xe8\x59\xb8\x74\x1f\x30\x3c\xbc\x78\x63\x9f\x7d\xc2\x2f\xd1\x1e\x26\xac\x4f\x70\x0f\x13\xf2\xf5\x90\x5e\x65\xb4\x68\xff\xb9\x31\x56\x84\xdb\xc2\xf3\x1c\xe7\x02\x16\x39\x90\x7b\x3d\x14\x32\x00\x14\xc5\x68\x34\x06\xe2\xf6\xf1\xb8\xc8\x24\x4a\xd1\x90\x88\xd3\x9f\x18\x47\x60\x2b\xe0\x87\xe2\x9e\x12\x75\xa6\x3c\x8e\x1f\x5a\x0e\xfc\x74\x77\x70\xad\xfa\xcc\xbf\x3e\xfc\xf1\xbe\x47\xdf\x5f\xf1\xc4\x7b\x8e\xe3\xa5\xcf\xce\x3a\x3e\x62\xc7\xda\x1d\xe3\xb3\x84\x7f\xd2\x6e\x61\xf0\xea\x7f\xdc\x5c\x2a\xbc\x3c\xfe\xf0\xc3\xce\x97\x37\x0a\xcd\x7b\x37\x3c\xda\xf1\x0b\xb2\x9e\xd3\x90\xdc\x93\x09\x66\x91\x1b\xb3\x1a\x53\x56\x28\x63\x18\x9a\x61\x69\xe0\xe4\xcc\x4a\x25\x07\xa0\x87\x65\xbd\x56\xa8\x01\x58\x5c\x8d\x93\x01\x1c\x95\x84\x96\x7b\x0f\x00\x7a\x1a\x8c\x21\x9f\x47\xbd\x20\x11\xfe\x9c\x38\x06\x55\x5f\x5c\x3e\x03\x6e\xbc\xd6\x7c\xd1\x95\xbe\x7a\xd1\x98\x79\xb3\xa6\x65\x14\xa4\x75\x4e\xb7\xa4\xee\x83\xfb\x9a\xd5\xf4\xbf\x9b\x6a\xab\x36\x75\x5d\xbf\x67\x5e\xed\xfc\xed\xc2\x85\x3e\x5d\x7b\x4d\x1e\xd2\xb5\x8b\x23\x90\x2d\xfa\x38\xe3\x5a\xfe\xc6\xf2\x4c\x57\x4a\x4d\xb5\xa7\x06\x85\x73\x95\x3e\xe8\x70\x58\xf3\x65\x01\x5f\xa6\xbc\x03\xc7\x15\xe5\x07\xac\x32\xc6\x9d\x9d\x91\x91\x9d\x1d\xac\x8e\x64\x73\x6e\xe4\x13\xb8\x2d\x1a\xe4\xda\xa1\x59\xe6\xa2\x58\x1c\x89\x3a\x2d\xa9\xe2\x34\x8a\x16\x12\x24\xa1\x28\x88\xf1\x20\xc8\x61\x7c\x28\x28\xec\xc6\x3f\x43\x0e\x2d\x5a\x02\x2f\xc0\xae\x10\xdd\x21\x98\xef\xd0\x65\xf4\x4e\xa3\xd5\x03\x16\xa5\xcf\xf1\x76\x4a\x0d\x74\x4c\x79\xa9\xc8\xb1\x61\x0e\x1a\xdd\xe0\x7e\x3a\x7f\xb0\xf7\xf8\xb1\x9b\x1f\x19\x3d\xc6\x9d\x97\x57\xd1\x65\xc5\xc2\xce\x99\x45\xc3\x33\x8a\x46\x76\x0b\x64\xc0\x3f\x8e\x1d\x56\x13\xee\xd0\xbe\x48\x78\x63\xd5\x84\xac\xd9\x3b\x67\x8e\x98\xb3\x61\x3c\xf0\x17\xb5\x5f\x7e\xff\xd5\xba\xb9\xaf\x8e\x99\x39\xa9\x4e\xcc\xc5\x0c\x45\x6b\xd4\x07\xad\x91\x9d\x9c\x7d\x8b\x96\x53\x40\x95\x46\xa3\x54\xaa\x2c\x2a\x87\x93\x37\x2a\xed\x9c\x91\xc5\x3e\x05\xbe\xcb\x8a\xe2\xff\x26\x00\x9a\x49\x67\x28\x8e\x26\x07\x12\x6b\x10\x12\x01\xe4\x84\x8f\x1b\x87\xa8\xbd\xcc\xbd\xa8\x71\xbf\xba\xc1\xd3\x25\x0b\x63\x50\x71\x12\x46\xb9\x99\x60\x16\x22\x4f\xcc\xa9\xd5\xca\x28\x83\xcf\xe8\x33\x9b\x8d\x26\x99\x29\x35\x60\x73\x23\x7f\x1a\xa4\x40\x95\xc9\x0c\xb9\xb8\x27\x56\x68\x68\x15\xa1\x95\x46\x23\xb4\x58\x85\x51\x20\xa1\xfa\x28\x29\x4a\x03\x4b\x25\xb1\x9e\x91\xa4\x4d\x00\x2c\xef\x6d\xf4\x38\xe1\x72\xa9\x80\x68\x36\xbd\x5a\x2a\x2c\x92\x70\xcb\x6b\xc7\x1e\xaa\x23\xf3\x88\xeb\xa7\xb0\xcc\xd9\xc8\x22\x64\xa5\xc9\x74\x14\xe5\x32\xb3\x46\xb9\x51\xa1\x90\xc9\x5d\xf2\x1c\x6f\x6e\x0a\x72\x68\x52\x9c\x66\xb9\xdd\x4e\x63\x53\xa8\xe6\xab\x23\x6a\x64\xa9\xa8\xf2\x04\x75\x45\x36\xcf\x3d\x43\x20\x07\xb4\x4d\xb9\x13\xe9\xaf\x03\x71\x92\x6c\x38\xb2\xcd\x41\x88\x63\xdc\xe3\xd9\x3c\x2f\x9a\x2c\xde\x69\x80\xce\xd6\xa3\x91\xd8\xb0\xff\xb1\x77\x7d\x94\x2c\x9b\x9c\x0f\x9d\x88\xa5\x8f\xce\x07\x47\x75\x0c\x7b\xe4\xe8\xd0\x2a\x95\x3a\x5e\xa7\xd7\x6a\x06\x45\xb4\x94\x5c\x4d\xa9\x71\xe0\x46\xd1\x4a\x33\xcd\x89\xc9\xba\xc4\x3c\x36\x21\x95\x2f\x28\x90\xee\x8e\xa4\x0c\x1d\x4e\x5c\x87\x66\x0e\x6f\x1c\x31\xdb\x31\x7b\xd4\xf9\x51\x33\x81\x3e\xa5\x31\x85\x9e\x44\xd2\xd4\x82\x0b\x7c\x09\x3b\x9d\x3e\x8d\xe7\xb6\x53\xcb\x0f\x60\x3f\xd1\x23\xde\xb0\x8e\x52\xb3\x6a\xa3\x41\xc7\x91\x6c\xad\xa4\xd9\xa4\x65\x47\x46\x28\x31\x31\x4b\xca\x85\xfe\x95\x93\x93\x92\xeb\xcb\x6f\x37\x71\xa1\x66\x4f\xe3\x1e\xc5\x17\xb9\x41\xf5\x41\xd5\xf8\xa9\x59\x65\xd0\xd4\xf4\x6d\x48\xb4\x7f\x7f\x42\x62\xff\x8a\x3e\x5f\x4d\x95\x86\x5d\x40\x0e\x91\x0f\xaa\x84\x4a\x2d\xd4\xa8\xe4\x0a\x79\x65\x44\xc1\x51\x0c\x64\xd0\x4e\x33\x53\xe5\xf7\x56\xb8\xea\xc5\x0a\xd7\xb4\x42\xb9\x9f\x30\xa3\xfa\xe5\x01\x30\xe7\x4d\x67\xf3\x19\xe7\xad\x86\x5b\x4e\xba\xda\xf9\xe6\xa6\x4d\x9b\x60\x60\xe3\x46\x2a\x91\x93\x80\x17\x39\x09\xe8\x96\xb7\xd0\x17\x15\x9a\x57\x8c\xeb\x5b\x19\x0e\xa9\x4d\x26\x0a\x59\x1a\x33\xa7\x40\x67\x40\xa5\x72\xf0\x0c\x63\xd7\x01\x13\xa8\x8a\xa8\x4d\x0a\x64\x8b\x4d\x0a\x93\x42\x29\x81\xdf\x63\x4c\xdf\xd6\xf0\x50\xd1\x6c\xa8\xa8\x74\x0a\x8d\x18\x07\xab\xa8\x23\x10\xe7\x5c\x0d\x30\xed\x4a\x31\xda\x3b\xfe\xb9\x23\xa6\xec\x5a\xac\xad\x6e\xdc\x79\xdc\x7e\x7c\xee\xba\x92\x10\xcc\x64\x3b\xf6\xa7\x23\x8a\x69\xc3\x66\x6f\x04\xc7\x9a\x75\xcb\x9b\x8f\xc1\xf6\xf9\x99\x1f\xdc\x87\xe7\xa7\x49\xa8\x01\x77\x88\x8c\x59\x61\x93\x4c\x43\x51\x7a\x5a\xa3\xe1\x75\x40\xcf\x51\x4a\xa6\x5a\xbc\x10\xc0\xab\x50\x98\x20\x07\xee\x17\x90\x27\x61\x71\x82\x3b\xc2\xf5\x78\x44\x0a\x8a\xd9\x1b\xbf\x5c\x2a\x88\x46\x9e\xb2\x2e\x68\x9d\xcd\xe8\x0c\x3d\x46\xee\xc5\x46\x87\x0b\x1c\x32\x8f\xcb\x65\x51\x42\x8f\x87\x42\xf6\x8d\x52\x52\x8c\x97\xf1\xf1\xbc\x96\xd2\x22\x5b\xa1\x75\xb2\x6e\x88\x4c\x9d\xd3\x51\x19\x91\x39\x9d\x28\x52\x14\xe7\x84\x30\x02\x24\x55\xe2\xb5\x82\x2a\xc7\xdc\x4f\xc4\xc5\x2a\xc4\x4d\xb8\x12\xae\x1c\x13\xf0\xc1\x62\x4b\x0c\x81\xaa\x18\x59\x43\x3f\xf0\x35\x0e\xa0\x7f\x4c\x11\x7a\xec\x3e\xb3\x47\xf8\xe9\x84\xb0\xdc\x7f\xd6\xf3\xe1\xf4\xcb\x93\xf6\xad\xac\x76\x81\x1b\xcd\x7f\xbc\xc8\xde\x10\xa6\x9d\x13\x1e\x36\xbf\x73\xe0\x90\xf0\xef\x9d\x20\xd7\x7c\x61\xfe\xed\x49\x8b\x36\x6c\x03\x2b\x9a\x06\x89\x58\x9d\x32\xa4\xe5\xa8\x5c\xb4\xaa\x19\x41\xaf\x9d\xce\x31\xa8\x90\x3d\xe6\x38\xb5\x46\x93\xe3\x85\x79\xf9\x46\x3b\x9f\xab\x4e\xe1\x5c\x99\xb8\x46\xce\x82\xb6\x99\xc5\xc2\xc7\xb4\x01\x29\x54\x4f\xba\x79\x48\x44\x67\x84\xf2\x44\x98\x7e\x9c\x74\x12\x15\x6e\x22\x90\x7f\xfc\x11\x46\xfb\x90\x5e\xd1\x6f\xe8\xcc\x93\xfe\x79\xe7\x71\xf9\xa4\xca\x00\x7b\xef\x1c\xbf\x70\x8b\x6e\xd0\xa1\x89\x6b\xb7\x9b\x97\x9e\x23\xff\x79\xd6\x49\xdf\x3c\xa4\x94\xd7\xd4\xe5\xfa\xfb\x0e\x7c\xfe\x18\x3d\xb2\xe9\xc9\xba\x75\x75\xc3\x67\x0d\x9f\x3f\x73\xc5\x78\x51\x35\x47\xff\xe3\x13\x74\xdc\x76\x90\x31\x66\x53\x03\xc2\x21\x93\xc6\x2d\x73\xa4\x53\xa1\xcc\xcc\x60\x30\x14\x72\x68\x60\x4e\x6e\xa6\x93\x92\x29\x83\x4e\x8e\x53\x5a\x31\x0c\x2f\xc4\xb5\x40\x89\x48\xf2\x85\x84\x49\x2f\xe6\xfc\xc6\x47\x98\xf6\x3b\xc3\x49\xfa\x37\xb2\x36\xc5\xac\xff\x37\x86\x73\x2e\x3e\x6e\x64\x7c\xaa\xb3\x2f\xff\xc6\x60\x12\x06\x8d\x6c\xd1\xf1\x2b\x51\x7d\x2e\xeb\xcb\xf4\xa7\x8a\x71\x45\x68\x28\xbf\x28\xdf\x5b\x64\x07\x4a\x4e\xcd\xe9\x74\x2a\xb5\x1a\x78\x61\x49\x4e\x4a\x29\xbe\x92\x4d\x73\xba\x0a\xd1\x12\xf2\x16\x19\x76\x46\xed\x06\xb5\x8e\xa3\xd4\x12\x4b\x44\x69\x52\xba\xba\x30\x71\x31\xe3\xbe\x97\x3f\x81\x23\x25\x29\x1b\x6a\x6d\x5b\xbb\x47\x1f\xa6\x1f\x7e\xc8\x9e\xb0\xac\x66\xb9\xb4\xac\x95\x87\x27\xaf\xdd\x6e\xd9\xed\xd9\x3c\x37\xaa\xe6\xb7\xdb\xc5\x09\xa1\x17\xcd\x2f\xc6\xe3\x6c\x7e\x42\x2a\x8b\xc5\x13\xb2\x74\xd2\x8e\x0d\x85\x73\x9a\xfe\xb9\x6f\xad\xa8\xef\xbf\xda\x90\x8a\xa7\xa5\xf9\x50\xac\x86\x14\xf3\x21\x50\x69\x84\xdd\x2a\xc5\xa9\xb0\x99\x6c\x56\xab\xd2\x94\x62\x0a\xea\x74\x26\x65\xba\x17\x79\x07\x5e\xde\x49\x59\x39\x8d\x1e\xfb\x70\x54\x74\x0f\x13\x73\x2c\xb2\x29\x19\x92\x0c\x9a\x34\x62\xc9\xa9\x4e\x18\x58\xab\x7a\x60\xfa\xa6\x68\x8c\xb7\x25\x8c\xe4\xd9\xc4\xf2\xdf\xa5\x51\x63\xec\x6a\x10\x65\x87\xd7\x12\x8b\x7d\x67\xc7\xec\x72\x0e\x92\x3f\x84\x7c\xe5\x34\x2e\xd5\x6d\x72\x58\x1c\x76\xbb\xd9\x62\x49\x65\x60\x46\x50\x93\xe9\x47\x52\xfb\x79\xb7\xc5\xce\x59\xcc\x72\xba\x3a\x22\x77\xc6\xd2\xd6\xf7\x2e\x9a\x98\xaf\x4a\x4a\xc2\xfd\x76\x3d\xb3\x0c\x8e\x1b\x19\xd5\x76\xbb\xda\x2a\x5f\x7e\x84\x3d\x13\x55\x7f\xf4\xcf\x6d\xd5\x2b\x37\xfd\xec\x22\x63\x28\x43\xb6\x60\x2a\x3a\x67\x1c\x95\x1d\x36\x29\x28\x56\xcb\xca\xb4\x3a\x99\x4e\xcf\xab\x59\x0e\xd9\x41\x1d\xde\x6d\x85\xe5\x85\xc9\xe0\xee\x58\x01\xa3\xd0\x18\x9d\x97\x00\x40\x7e\x27\xae\xfb\xba\x00\x7a\x7b\x75\xa6\x15\x27\xdf\x79\x54\x38\x9b\xa9\x36\xac\x3b\xf1\x0e\x3a\xf1\x95\x5d\x32\x97\xd2\x7b\xee\x5e\xa7\xaf\x8d\x4c\x5b\xda\x1c\x66\xca\x12\xea\xea\x71\xcc\xc1\x3c\x46\x49\xb9\x1c\x59\x8d\xc4\x17\x31\x3a\xdc\xc1\x62\x34\x42\x99\x57\xa3\x91\xd9\x18\x8a\x35\xa5\x9b\x82\x56\xba\x2a\x22\x57\x1a\x8c\x68\x6f\x18\x8d\x38\x97\xcb\xf1\x98\xbd\x80\x57\xa6\xe0\xa3\x2f\x43\x21\xb0\xcc\x9c\x9c\x0d\x8c\xb5\x69\x19\x4a\x13\xf3\x38\xa2\x8a\x13\x8b\xe5\x8a\x65\xf1\x52\x56\x82\x0a\x18\x6c\x1f\x8f\x4c\x8a\x0c\xec\x47\x76\xa1\x73\x4f\x20\x38\x9a\x87\xe9\xa6\x3c\x49\x68\x0e\x6e\xd6\xd9\xe8\x1d\x0e\xc1\x5e\x7e\x72\xe9\x74\x42\x71\xb0\x6a\x5f\x0d\x3d\x73\x85\xb0\x7b\x75\xcf\xe1\x22\xd5\xc1\xb6\xc5\xeb\x85\x17\x4a\x36\xef\x14\x69\x0e\x76\x82\x2c\xd1\xff\xef\xdc\xf2\x1d\xfb\x15\xb9\xdf\xc8\xa2\xba\x87\x53\xac\x01\x0a\x2a\x78\x85\x8b\x0f\xb9\x42\x39\xd9\x01\xab\x35\xcd\xc6\x1a\xd3\x8c\x95\x11\x5f\x9a\xc5\xa6\xa9\x8c\xd8\xf8\x04\x74\x62\x02\x6e\x98\xec\x15\x4b\xf0\x7b\x52\xc5\x5a\x0c\x61\x06\x45\x99\xc6\x02\x26\x96\x61\x8f\xc6\xf1\x70\x99\x41\x7f\x6e\xd9\x13\xd3\xdf\xdc\x76\x55\xf8\xdb\xe1\x11\x43\xa7\x6f\x4d\x33\xec\x7d\x16\x78\x1a\x66\xbd\xb7\x75\xc9\x1e\xfd\xd8\xbb\x8f\x3d\xfd\x1a\x98\x4f\xf7\xaf\x1f\x71\xdf\xc7\xff\x79\x71\xc1\xd5\x89\x3b\x84\x0f\xcf\xcf\x9a\xdf\xf8\x5a\x3d\x0d\x56\xfe\x74\xe4\x84\xf0\xf3\x8e\xc5\x8b\x7e\x7e\xe9\xcc\x5f\xc0\xb0\xab\x14\xa4\xba\x11\x4e\x04\x8c\x31\xe7\x40\x3e\xf4\xc0\x70\xc8\xa0\xb6\x28\x80\xc7\xe2\x31\x39\x4d\x3a\x27\xa3\x63\x52\x03\x1e\x2b\xe6\xf2\x03\x06\x8b\x92\xb2\x78\x15\x5e\x14\xdd\x2b\x78\xd2\xfb\x27\x39\x6d\xe5\x85\xf7\xb2\x05\x44\x99\xc0\x8c\x22\x89\x1f\xde\x5a\xc4\x7c\xe2\x2a\xac\xf6\x41\xd8\x05\x18\x58\x93\xc5\x6a\xc4\xa1\x71\xb0\x6a\xeb\xb1\xa5\x7f\x3f\xda\xf7\x89\xfe\xfb\x0f\x2d\xfe\xee\xcc\x40\x70\xfa\xc0\x13\x53\xd7\x56\x36\xaf\xea\xdf\xe7\x89\x31\x1b\x07\x20\x7f\xe2\x90\xe7\x93\xa7\xce\x82\x6e\xa7\x55\x60\xb9\x30\xdf\xf5\xf6\xa9\xd3\xc2\xd9\x0b\x6a\x61\x12\x33\xf8\x8b\x76\x4d\xe7\x75\x8f\x01\xfb\xce\x59\xbb\x1c\xb0\x27\xbf\x43\xf8\x99\xe8\xa1\xc6\x96\xef\xe8\xe5\x68\x73\x1a\xa9\xfc\xb0\x4d\xab\x30\x6a\xd4\x6a\xb9\x42\x81\x42\x02\x3d\x3a\xb4\x7a\x8b\x4e\xae\x31\xcb\x45\xbf\x33\x16\xea\x47\x15\x6c\x50\xe4\x07\x30\x92\xeb\x31\xd1\x54\x06\xb3\xb2\x73\x7b\x2d\x8c\x58\xa6\x35\x1e\xb6\x19\xc5\xab\xe0\xdc\x76\xdb\xb4\xe3\x9e\x9a\x4e\xb7\x6f\xfa\xc3\x86\x59\xd1\x7b\x60\xf1\xbd\x6f\x92\xb9\xfc\xed\xf7\x52\xff\xbf\xdf\x7b\xb5\xf1\x4e\xab\xf7\xc2\xeb\x77\xf3\x93\xde\x2b\xd4\x90\xf1\x7a\xa8\x6e\x61\x3f\x67\x53\x78\xac\x4a\x25\x7a\xb1\xcf\xe3\xb5\x2a\x7d\x76\x97\xdc\x85\x5e\xef\xb2\x88\x08\xfd\x72\x2e\x31\x8a\x88\xbb\x61\x31\x4d\x10\x97\xe4\xde\x2b\x84\xc4\xc9\xf8\x36\xee\x9f\x55\xd0\x15\x0f\xc5\xe7\xe4\x6e\x9f\x84\x4b\x82\x3e\x2b\x27\xe9\x88\x8c\x6f\x21\x19\x7f\x20\x39\x73\x3c\x37\x46\x85\xd1\x2c\xce\x8e\x38\x37\xbc\x56\xa1\xe6\x14\xce\xc4\xb9\x49\x48\x3b\x93\x8c\x16\x52\x4a\xe5\x20\xf1\x8e\x1e\x89\x91\x75\xaa\xf1\x5f\x76\x43\xc2\xf5\xfc\xb8\xa7\xde\x6f\xda\xc8\x7c\x1d\x9b\x1c\x40\xd1\xd2\x7b\x7d\x98\x81\xc7\x6e\xb3\x29\x8d\x0e\xa3\xcf\xef\x4b\x31\xcb\xfd\x1e\xf4\x66\x0f\xef\xe0\x6d\x1c\xaf\x46\xb1\xb9\x93\x4a\xb2\x45\xad\x50\xae\xa5\x66\xd6\x56\x73\x72\x8f\x44\x96\x35\xac\xa8\xc8\xc7\xce\x57\x5e\x6e\x25\xda\xf4\xe6\x4a\x71\x66\x66\x4f\x0d\xe5\xc3\xb3\x51\x21\x01\xf2\xe6\x29\xfa\xaf\x48\x46\x2d\x8a\x59\x38\x2d\x45\xc9\x74\x32\x8e\x51\x56\x47\x98\x68\x7d\x23\x28\xbc\x97\x70\x1c\x9d\x24\xdb\xea\xd0\xd7\x7f\xec\x99\xed\xcb\x2e\x58\xb4\xc9\xb7\x88\x3e\xf3\xd6\x5b\xea\x23\xea\xad\x47\x9a\x37\xa2\xcf\x9c\x8d\xc6\xdd\x0d\x7d\xa6\x9e\x72\x87\x75\x50\xa7\x53\x18\x0d\x6a\x19\x0a\x23\xc5\x93\x9b\x15\x8b\x82\x9c\x52\x52\x3f\x8a\x29\x2e\x87\xe7\x5e\x35\x0c\x19\xdd\x29\xdd\x97\x59\x72\xe0\x0c\x87\x21\x3a\x41\x5d\x51\xfd\x48\xd5\x11\xd5\x89\xc3\xe1\x01\x77\xff\x07\xf7\xff\x20\x1b\xe3\x20\xbd\x22\x66\x7c\xbf\x60\x94\x69\x94\x4a\x4a\xad\x56\x71\x18\x4a\x46\x25\x83\x56\x8b\x52\xcb\x69\x2b\x23\x1c\x07\x68\x5a\x57\x19\xa1\x39\x35\x30\x27\x14\x90\xb4\x86\xdd\x8a\xe6\xe2\x0b\x03\x46\xa9\x54\x13\xe0\x98\x0f\x92\xca\xc7\xc0\x9f\x1a\xdf\x01\x2f\x1d\x7e\xf1\xd2\x09\xa0\x7e\xfb\xdf\xb7\xef\xef\x05\x0c\x0b\xd7\xbf\xc6\x94\xed\x58\xb6\xfb\xa2\x5d\xe8\x02\x2e\x82\x5f\x85\x2d\x73\x27\xef\x94\xe4\xda\x2d\xc9\xd5\x35\xec\x03\x0c\x43\x9b\x30\x2b\xb7\x85\x86\xb8\x35\x87\xd4\xdb\x9a\xd4\xb4\x86\x53\x9b\x91\x12\x33\xc7\x72\x01\x79\x49\xc4\x60\x51\x7a\x30\xd2\x08\x20\xa6\x5c\xfc\x28\x12\x25\xb2\xf8\x21\x18\xf4\x3a\x38\xf0\x91\xd0\x73\xda\xfc\x9f\x3f\x12\x0a\xde\x69\xac\x59\xbc\xee\x15\xe1\x97\xfb\xe8\x95\xe0\xa2\x50\x62\x59\x37\xf1\xd4\x8b\x4c\x59\xd3\xc0\x79\x93\x76\x0a\x5b\xc8\xbe\xbf\x2c\xd4\x90\xfa\x67\x5c\xc1\x90\x9b\x9f\xea\xa2\x32\x33\x32\x28\x4d\x2a\x63\x28\xb5\x28\x14\x06\x43\x89\x2b\x1f\x06\x83\x39\x55\x11\xe4\x0a\xf3\x9c\xaa\x3a\xc2\x39\xa1\xbd\x0a\xf9\xf7\x49\x15\xd0\xf1\x84\x5c\x69\x1b\xe0\xb2\x62\x01\xb4\xbc\xd5\xd6\xfc\x6f\x6a\xa0\x2f\x4c\xf4\xca\xc7\x77\xcc\xf4\x15\x17\xcc\x7e\x50\x59\xb1\xd3\xbf\x71\xee\xef\x54\x40\x1f\x7e\xaa\xc7\x89\x80\xa3\x5a\x73\x58\xf3\xc0\xf8\xf4\x3c\x50\x5f\x32\xac\xf2\xf7\x6b\xa0\x85\x5f\xd1\xd8\x33\x90\x3e\xb4\x50\xbe\x30\xaf\xb3\xd1\x56\xcc\xa9\x83\x42\x42\x36\xb1\xa1\xbe\x75\x5b\x51\x1c\xaa\x1d\x79\x7c\xf3\x2a\xc3\xde\xd2\x82\xbe\x23\xed\x9f\xa7\x5d\xd8\xdd\xbf\xa7\xaf\x53\xc1\x23\xb9\x5f\xa4\x9e\x12\x6a\x2c\xfb\x6c\x53\x96\x30\xab\x9e\x3d\x67\x7b\xc2\xf3\xf7\xbb\x73\x2f\x9d\xc2\x73\x5d\x89\xde\x57\x49\x62\xc2\x1e\xe1\x00\xe7\xd2\x50\x2e\xca\x2c\x93\xf9\xdc\x66\xb3\x57\xe3\x71\x7b\xaa\x22\x9c\xdb\x6c\xb4\x21\x7f\xc3\x49\x4e\x17\x95\x10\x5e\x24\x07\xc6\xd2\x7e\x4c\x12\x26\x5a\xf7\x17\x2c\xf6\x02\x31\x5f\xbd\xf1\xc5\xb8\x50\xd7\x9e\x74\x9c\x76\xba\x1f\xdd\xd0\xa7\xc0\x91\x93\x5b\x5e\x61\xb2\x3e\xef\x58\x09\xff\x2c\x8a\xd7\xd4\x65\xe5\xf6\x86\x87\x34\xeb\x59\xd8\xf5\xfe\x05\x2b\xf1\x79\x47\x36\xed\x1f\x24\x27\x9b\x1e\x36\x99\x18\x35\xe3\x84\x5e\x8f\x0e\x89\xa4\xe3\x29\x7b\xe2\xdc\x44\xab\x99\x41\x4a\x62\x1d\x4a\x12\x29\x22\x26\xd1\xe8\xf3\x6f\x6e\x97\x66\x6e\xb7\x22\x5f\x7e\xcd\xa2\x55\xdc\x76\x2e\xa7\xb4\xa4\x9b\xb7\xa3\x50\xf3\x43\xe1\x40\xba\xa5\x67\xca\x72\xe7\x31\xc3\xba\x65\x9d\xfb\x36\xbb\xfb\xe6\x15\x97\xd8\x0e\x1a\x71\x2e\xa1\x1f\x9a\xab\x3f\xa3\xb9\x72\x51\x41\x6a\x50\x38\xc7\xae\x4b\xd7\xd2\x0e\xc6\xe5\xd3\xb9\x14\x46\x63\x86\x4f\xa1\x08\xa9\x51\xcc\xac\x75\xa4\xd3\x8c\x5a\xcd\xea\x31\x49\xb5\x9e\x62\x51\x54\x46\xb1\xad\x78\x50\xa5\xde\xc3\xe8\xcc\x45\xd3\x7c\xb1\x90\x8c\xf4\x60\x24\xaa\x2d\x8b\x15\x44\xf9\x5d\x8a\xd3\xc1\xbb\xed\x8a\x73\xb6\x4e\x9a\xb5\xfe\xf1\x75\xfd\x7b\xbc\x99\x72\x61\x0f\x99\xd0\xde\x63\x6d\x9f\xdd\x5f\x29\x18\x4a\x2a\x3b\x66\x95\x0e\xe6\xdb\x09\xb3\x46\x87\x47\x8f\x78\x68\xca\x43\xfb\xdc\x4c\xda\x33\x97\xd0\xac\x4e\x7b\xf0\xee\xda\xb1\xc7\x81\xac\x57\x49\x6e\xbb\xfb\xfb\xe7\x91\xb3\xf6\x79\x4b\x0b\x6d\x66\x77\x23\x7d\x5a\x1a\x76\x29\x91\xc3\xc9\x59\x38\xad\x43\x6b\x97\xe9\xb4\xba\xaa\x88\x52\x1b\x46\x67\xde\x54\x19\xe3\x5a\x73\xdc\x2a\x48\x2e\x0d\x8b\xf5\x48\x89\xab\x1d\x20\xb0\xc7\xd1\x59\x07\x75\x43\x46\x73\x5b\x63\x7d\x76\x5b\x44\x82\x12\x76\x37\x66\x28\x69\x76\xe0\xe6\x3a\xfa\xcf\x51\x6a\x12\xb4\xc6\x3a\x61\x18\xe1\x9c\xb1\x51\xc5\x61\xa7\xc6\x60\x50\x42\x68\xb1\xf3\xac\x83\x23\x24\x2a\x1a\x95\x82\x23\xa2\x48\x4b\x2d\x71\xcc\x14\xc6\x13\x7a\x98\xc5\xa0\x4d\x5e\x19\xb9\xec\x65\x24\xc8\xcd\x98\x20\x37\x44\x41\x84\x61\x58\x10\x26\x80\x05\xb9\xfb\x75\x54\x10\x9a\x52\xb5\x7c\xcf\x8c\x40\x3a\xd1\x8d\x7c\xf1\x31\xe1\x02\xce\x4f\x43\x46\x83\x4c\x2f\x64\x52\x70\x37\xb1\xdb\xed\x72\xa5\x5a\x18\x4b\x30\x3d\x45\xe1\xc0\x19\x12\x16\xf0\x4e\xa7\x06\xba\x39\xa3\x87\xa4\x72\xcd\xf1\x54\x6e\x5e\x69\xbc\xd2\x3b\x91\x82\xb8\x34\xa1\xc6\x08\xc4\x6a\xbd\x65\x49\xf4\x20\x04\x42\xda\x09\x30\x8c\x20\x1a\x06\x38\x30\x02\xfc\x3c\xa2\x71\xc4\x54\xc7\xd4\x76\x09\x51\x8e\xd2\x3a\xd5\x31\x65\xc4\x07\xcb\x9f\x4b\x11\x14\x4e\xa6\x4c\xc8\x13\x8b\x50\x63\x51\x8e\xe7\xbe\x79\xab\xc1\xdb\x4d\x5d\x5e\x3a\xb1\xb9\xe4\x18\x9a\xe3\x02\xdc\xdf\x8f\xc6\x56\x88\x6f\x0c\xbc\xed\x02\xd9\x06\x95\x0d\x42\xad\x2a\xbb\x1d\x1b\x6c\x1f\xec\x90\xa1\xd5\xe1\xaa\xb6\x6c\x2a\x1d\x85\xd9\xce\x78\x89\x01\x4e\x25\x24\x55\x72\x27\x5c\x8d\x76\x68\xdf\x85\xe9\xd0\x9e\x5c\xa5\x11\x43\x94\x80\x5a\x10\x4c\x27\xe9\x31\xb9\xa8\x42\x91\x8f\x4e\x81\x7f\xbd\xf9\x63\xb0\x63\xf7\x8e\xc1\xde\xd5\xce\x59\x7d\xc6\x95\x76\x2c\xeb\xb8\x7d\xd1\xc4\x93\x75\x3e\xdf\xca\x59\x0b\x9d\xd5\xed\x0b\xdc\x29\x6e\xe1\x4d\xd3\x9b\x4f\xf5\x5e\x30\xa6\xb2\x7b\xa9\xb3\x6c\x63\x5d\x9f\x8a\x85\x3d\xbb\x6f\xe8\x37\x7b\xed\xd4\xcb\x13\x3a\xdd\x7f\x7f\xc7\xd9\x2b\x37\x96\xa5\xfb\xbb\x57\x8e\x09\xff\x20\x7c\x81\x63\xa9\x89\x68\x4c\x16\xa6\xcc\x20\x83\xf3\xc9\x9e\xc6\xfc\x93\xbb\x49\xbe\x31\x05\x63\x9f\xca\x69\xad\x0a\x83\x71\xa8\x91\x27\xc9\x89\x30\xd2\xb1\xab\x35\x6c\xb2\x30\x8d\x64\x1e\xe0\x00\x08\xd0\xea\xf7\x2e\x5c\x19\xaf\x54\xb2\x8e\x5a\x61\xd9\xcb\x4c\x19\x8a\xda\x5e\xe8\x3e\xb7\x7d\xfb\x8b\xcd\x5d\xf0\xe7\xa2\x90\x9d\x9d\x41\x7a\xf5\xc3\x61\x9f\x5c\xa6\xd6\xea\x18\x40\xe9\x95\x0a\x85\x9a\xd1\x33\x16\xa3\xc9\x64\x56\x9a\xcc\x8c\xce\xac\x57\xcb\xc8\x8b\x0a\x0a\x30\x91\x4d\xe2\x65\x72\x61\xcc\xc9\x2f\x34\x7a\x09\xcf\x6c\x00\x06\xb1\xe5\x4e\xef\x80\x59\x2c\x4f\xbe\x95\x4e\xc3\x71\xa0\xec\xad\x91\x67\x33\xe5\xa5\xc2\xce\x17\x72\x64\x1d\x85\xdd\x67\x51\x14\xd9\xb3\xe3\xd3\x77\xe8\x0b\x48\x9e\x0f\x6e\xae\x6b\xfa\x82\xfe\x7a\x6a\xf5\xda\xa6\xff\x91\xc6\xca\xcc\x65\xbf\x40\xeb\x54\x1c\x76\x28\x39\xe4\x50\xa8\x8c\x34\x6d\x33\x18\x8d\x56\x0e\x39\x18\x46\xf1\xd2\x0e\x24\x13\xdf\x26\x69\x6c\x10\x63\x19\x42\xc2\x20\xcb\x87\x27\x02\x74\x01\xf0\x6e\xef\x76\x8e\xd4\xbc\x21\x7b\xfa\xd9\xdf\x3e\x37\x49\xe9\x01\x96\x39\xc2\x53\x2f\xd3\x13\xd7\x7d\xc1\x7e\xa1\x5e\x2b\x5b\xb8\x32\xeb\xee\x5b\xf4\xd0\xdc\xbf\xa9\xb2\x3f\x6d\xde\xc5\x74\xfe\xe1\xa2\x98\xb3\x7a\x08\xc9\x33\x0d\xcd\x91\x02\xc5\xd2\x16\x48\x2b\x90\xe2\xa0\xa1\x92\x95\xc9\x54\x0c\x72\x05\x59\x9a\x23\xee\x59\x61\xeb\xd6\x65\xbf\x51\xe4\xdc\x85\xa0\x62\x88\xf0\xe5\x1f\x6e\x81\x9d\x6f\x36\x7f\x32\x04\x5c\xa2\x57\x08\x06\xf0\x8f\xe6\x07\x85\xbe\x04\x2b\xa1\x86\xf4\x07\xd9\x71\xae\x41\x87\x22\x2c\x16\x72\x7a\x93\xc9\x69\xe1\x38\x87\xd9\x60\x34\x90\xa8\xd8\xc2\xa1\xe8\x98\x33\xc7\x8a\x8d\xa3\x57\x46\xe5\xf7\xd2\x19\xb4\x2a\x34\xc6\xe8\xa4\x51\xa6\x0e\x19\x2c\x4b\x0b\x75\x08\xf9\x7a\xe4\x8f\x9a\xa2\xb1\x34\x27\x42\x29\xd0\xc7\xda\x29\x2e\x65\xa6\xa9\x0f\x69\xa6\x8e\x0d\x75\x99\x2d\x75\x05\x09\x62\x9c\xdb\xf2\x6e\xcb\x00\x22\xa3\x85\xf2\x22\xef\x25\x5f\x6f\x72\xa8\x28\x1d\x63\x71\xbb\x65\x06\x99\x09\xfa\x91\xa8\x3e\x51\x54\x68\xc5\x9d\x7b\x4a\x23\xe7\x10\x45\xd6\xa8\x38\xb3\x92\xcc\xcd\xcb\x52\xaf\x22\x76\xb2\xe2\x5e\x96\x48\xc1\x2c\x8a\x9d\x16\x05\xc8\xc9\x02\x32\x79\xb0\x38\x2a\x76\x1a\x2e\xce\x2d\xc0\x1d\xa8\x13\x1e\x79\x61\xf4\xf8\x85\x47\xce\x36\x77\x2b\x5c\x3a\x40\xb8\x95\x28\x7d\x45\xfb\xb9\x35\x0d\x17\xb3\x36\x3e\xbf\x7e\xfa\xc8\x35\x2b\x46\x0e\xed\x3c\x57\x1a\xc1\xc5\xaa\xf1\x33\xfc\xe9\x78\x4f\x11\xac\x4a\x52\x07\x3b\x20\x9c\x61\x92\x39\x6d\x50\xc6\x68\x1d\x00\xb8\x75\x5a\xad\xcb\x8e\xab\x73\xec\x76\x15\x85\x8b\x75\x74\x3a\x95\x93\x26\x3c\x8a\x14\xf7\x5f\x70\x8d\x18\xe3\x19\x61\xa9\xde\x20\x9e\x12\xbe\x09\x4b\x52\x84\x1e\xbb\x9e\xda\x20\x08\xa7\xae\xdc\xe6\x4f\x7b\x3e\x9a\xf1\x64\x5d\xc3\x2a\x92\x0d\x5e\xc5\x94\xe1\x54\xf0\x7b\x07\x1e\x15\xfe\xb9\xeb\xd1\xdd\xe6\x0b\x73\xdf\x9d\xb0\x68\xf3\x36\xb0\x42\x9c\xf3\x47\x84\xa1\x44\x5e\x1f\x95\x49\x4d\x08\x97\x05\xac\x1a\x05\x13\xb2\x23\x27\x06\xc9\x6d\xf0\x02\x90\x1d\x32\x18\xb2\xcc\x69\x95\x11\x0f\x32\xcf\xd0\x63\x55\x04\x34\x8c\xd9\x63\xf6\xe8\x28\x9d\xbf\x2a\xa2\xd6\x39\x69\x1f\xa9\xa8\xe4\x12\x60\x3e\xa4\xb2\x23\xd2\xd6\xd1\x6a\x1c\x12\xa9\x8b\xc4\x77\x61\xb1\xca\x71\x9e\x81\x5c\x04\x20\x7b\x5d\x14\x1d\x8f\xb1\xa0\x58\x02\x6b\x11\x47\xb6\xe7\xd4\xa4\x82\x76\x6b\xaa\xf7\x7f\x3c\xff\xd4\xc8\x2b\x47\xff\x74\x35\x6f\xd7\x46\x71\x6c\x23\xce\x4f\xdb\x75\x72\xd0\xe8\x45\x64\x8c\x96\x0f\x4e\x3c\xb7\xa9\x53\xf7\xf1\xb3\x67\x75\x9b\xdd\x73\xe1\xa6\x03\x93\xc7\xae\xda\x8e\xc6\x79\x37\x7b\xf4\xae\x6e\x25\x25\xdd\xc5\x33\x76\x01\x9d\x31\x0a\xf9\x21\x36\xaa\x4b\xd8\xa7\xd5\xd9\x28\xb9\xd1\x48\xe9\xa0\xdd\x81\xf7\x54\xbc\xf9\x0c\x93\x5b\xb6\x6a\xf6\x2a\x4c\x26\x94\x2b\x34\x62\xfe\x94\xa2\xa4\xde\x33\x92\x6f\xf8\x75\x72\x66\x67\x10\xea\xa9\x99\x39\x7e\xd2\x1a\xdf\x89\x59\xa0\xf7\x1f\x6e\xce\xff\xf6\x68\x1f\xda\x63\x00\xfb\x7b\x74\x5c\xbb\x65\xf2\x70\xe4\xd0\x7d\xf0\xc6\x79\xe1\xe5\xa7\x54\xc2\x52\x2c\x13\xf2\xdc\x49\x4e\xc4\x41\x75\x0e\x7b\x1c\x94\x89\xa1\x18\x8d\x53\xe3\xb2\x5b\xad\xa0\x12\xb3\x57\x28\x95\x3c\xae\xc1\x91\xee\x56\x12\xae\xca\x13\x9c\x09\x51\x11\x90\xec\x87\x98\xa0\x8d\x55\x1b\xe2\x53\x0a\xc1\xa2\x7e\x8f\x1c\xea\xb7\xed\xc6\xf6\xc3\x97\xf8\x46\xae\x7e\xf0\x82\xbd\xb5\x93\xe6\x75\x6c\x3f\x19\x2c\xe7\x6e\x9c\x59\x08\x3c\xaf\x8f\x3e\x7c\x48\x37\xa1\x76\xa3\xf0\xc6\xd2\xf9\x8b\x0d\xcd\xff\x43\xe6\xca\x85\xeb\x36\xc9\x5c\x75\x0c\x7b\x8c\x0c\x65\x43\xb1\x8d\x8d\x81\x0e\xbb\x8d\x52\x72\x44\x22\x8b\xd5\x0c\x50\x6c\x03\x12\x37\x30\x95\xd4\x2b\x8f\x4d\x74\x8c\x20\x47\xaa\x93\x31\x74\xe0\x91\x8b\x63\xa4\x3f\x18\xb8\xfb\x40\xff\x2d\xb7\x76\x1e\x6a\xd4\x3f\xe3\x6e\x58\xb2\x7f\xe4\x27\x1d\xdb\x4f\x67\x6f\x08\x93\xb9\xd7\xce\x2e\x12\x3e\xfd\x63\xdd\xe3\x07\x74\x2f\xad\x06\x39\x0f\x52\x2d\x06\xba\x54\xcc\x3d\xdc\x11\x86\x92\xfa\x16\x2f\x55\x16\x76\x19\x4d\x0c\x44\x8a\x41\xeb\x70\xf8\x90\xce\xb6\xa2\x59\xb2\x3a\x31\xe2\x0b\xc3\xe0\xfa\xd8\xa4\x3a\x9e\x56\xfc\xb6\xf1\x4b\xee\x7b\xeb\xaf\x0d\x14\x3d\xfb\xd8\x4b\xda\x73\x9a\x71\x23\x1f\x3e\x9d\x31\xd0\x30\x7d\xca\xe4\x5d\xa9\x0d\x5d\xff\xf2\xf8\xd5\x9b\xc6\x7e\xc5\x80\x65\x06\x1c\x7b\xc4\x3e\xe1\xfe\xeb\x1f\x0a\x93\x23\xbd\x57\xac\x5a\xf8\x40\xbb\x63\x0d\x6f\xff\xa1\xaa\x0e\xac\x06\x2e\x60\x4a\xe0\xe5\x95\x70\x76\x29\x3d\x3d\x8f\x1e\x45\x41\x5c\xa7\x0c\xff\xce\x74\x27\xfc\x13\xe9\x54\x4d\x38\x37\xdd\x68\xd4\xd8\xe4\x5e\x8a\x92\x33\x1a\x26\x18\x62\xd2\x5d\xe9\x2e\x14\x35\xa4\x03\x35\x4c\x4f\x57\xf1\x7c\x0a\xce\x52\x1a\xcd\x98\x98\x42\x83\x9b\xa7\x92\x81\x1c\xda\x2a\xd1\x11\xc3\x33\x2e\x5a\x85\x10\x24\x8e\xb0\x05\xc4\x4b\x76\x7c\xe2\x86\xe5\x00\xfc\xfb\xd6\x95\x60\xfc\xa2\x96\xbf\x7f\x7e\x73\x4e\xf6\xdf\xdf\x3e\xfb\x7c\x53\xcb\x82\x39\x6b\x1b\x1e\x5a\xfd\xea\x27\xc0\x35\x72\xe4\xe2\x75\x2e\x05\xec\x35\x75\xab\x45\xce\x2f\xae\x3d\x7e\x2e\x83\x9e\xfc\xd5\x67\xab\x9a\x5e\x31\x8d\x9d\x5a\x39\x6a\xc5\x0b\x5d\xfb\x3d\xbc\x2d\x83\xe4\x26\xf9\x96\xef\xe1\x6d\x52\x6f\x94\x81\x34\x5e\xa6\x54\x6b\xa4\x72\x7b\x1d\x6c\x66\x96\x5b\xa9\x51\x6a\x90\x45\x51\xa2\x01\x29\x95\xd6\x14\x52\x6d\xc4\x93\x6a\x23\xcb\xff\x55\x6d\x14\x65\xd4\x34\xe3\x7b\x41\xd1\x09\x12\x99\x7a\x45\xf7\x4e\x74\xf4\x2d\x64\x63\x41\xc7\xc2\x59\x0f\x2c\xa9\x1f\x30\xdc\x39\x72\xd5\xa6\x89\x63\x26\x6f\x18\xd3\x41\x98\x72\xea\xf5\x86\x87\xcf\x7e\xfd\xc7\xab\x1f\x0c\xdc\xf5\x3e\xfd\xe4\xc6\xed\x93\x23\x15\x83\x36\xcf\x18\xdf\x6b\x70\xe5\xd1\x7f\x36\xef\x7a\x6c\xcd\xc2\x27\x6c\xc5\x7b\xb6\x9c\xf9\xf4\xc5\xe5\xc2\x17\x2f\xd7\x45\x6b\x57\xd8\x02\x56\x49\x85\xa8\xfa\x70\xbb\x50\xd0\xef\x97\x07\x81\xce\x69\x70\xda\xed\x40\x0e\x32\x0c\x86\x4c\x52\x44\xaa\x21\x04\xad\xb8\x8e\x05\x5f\xf2\x39\x75\x1a\x9e\x49\x4d\x28\x64\x49\xc0\xfd\x26\x1c\xdc\x89\x94\xe4\xa5\xfa\x36\x8b\x5a\xac\xb1\x52\x1e\x8e\x0e\xfc\x7f\xc4\xbd\x07\x7c\x53\x47\xf6\x30\x7a\x67\xe6\x16\xf5\xde\x6c\xb9\x48\x96\x2b\xb6\x71\x91\x6d\xd9\x34\x8b\x6e\x9a\xb1\x31\xb6\x11\xcd\x74\x30\xa1\xd8\x40\xe8\xc5\x74\x08\x10\x48\x42\x48\x08\x90\x50\x52\x08\x49\x96\x00\xa6\xa4\x93\x5e\x16\xd2\x36\x6d\x37\xa4\xec\xa6\x6c\x02\x69\x9b\xb6\x49\xb0\xae\xdf\x94\x2b\x59\x36\xec\x7f\xbf\xf7\x7e\xdf\xff\xf7\x48\xac\xa3\x7b\x35\x7d\xce\x9c\x39\xe7\xcc\x99\x73\xfe\xb3\x79\xcb\xc3\xf3\xcb\xfe\xd5\x3f\x9f\x58\xee\x0c\xb5\x24\x1e\x05\xff\xc1\xd2\x65\x0a\x48\x24\xa7\xe5\x93\xf7\xc5\x1a\xbc\x30\xbb\x85\x72\xca\xd7\x05\x82\x09\x12\x42\x3c\x50\xab\x35\xbc\x46\xaf\x03\xaa\xea\x50\x1e\xc0\xff\x34\xbc\xd6\x28\x6a\x58\x3c\x75\x4c\xee\x26\x74\x36\xc8\x8c\xb0\xda\x3e\xe2\x24\xd8\x0a\x8e\x86\xc0\x67\xa1\xd6\xb7\x5b\x1b\xe4\xc4\x86\xd6\xb7\x31\xef\x5c\x02\x5e\xbb\xfa\x12\xf8\x56\xb6\x52\x25\x3d\x6a\xb7\xc9\xf5\x70\x33\x3d\x97\x8d\xc7\xf2\xf1\xd0\x60\xba\x4d\xa5\x52\xab\x13\xf4\x89\x89\x1e\xcc\x33\x27\x27\xb8\x6b\x42\x09\x9c\xde\x2e\x92\x98\x2b\xa2\xc8\x61\xf1\xc4\xd4\x21\x9e\x5c\x7b\xd1\xcc\xec\xef\x08\x84\x99\x1e\x73\x6c\x2c\xc1\x34\xa2\x3d\x64\xe8\x41\xce\xec\xad\x4b\xb6\x3c\xff\xe0\xc0\xf3\xad\xcf\x6e\x75\x6f\x15\x83\x72\x38\xad\x38\xcd\x99\x3d\x71\x46\x36\xb8\x40\xaf\x9b\xad\xbe\x61\xe3\x5e\x74\xa9\x2d\x75\x9b\x57\xbe\xef\xe6\xec\xd1\xf3\xab\xfa\x65\x16\x89\x3d\xc9\x51\x3e\xa6\x2d\xa7\xb0\x8c\xfa\x4f\xdc\x7e\x1d\xd7\x2b\x98\xac\xa5\x91\xe7\x39\x1d\x19\x2b\x1d\x6f\x50\x6b\xf4\x10\x48\x5a\x5e\x83\x74\x46\x8d\x5d\xa4\xae\xe8\x94\xd0\xf8\x85\xe6\xb2\x4e\xa6\xdf\x6a\xc0\x4e\xff\x30\x57\xaa\x06\xa0\x14\xe8\x8e\x56\x9c\x92\x2f\x9d\x79\xfc\xa2\x7c\xc7\xc7\xd0\x22\x63\x96\x54\xd6\xac\x04\xcb\xff\x48\x44\x0f\x3f\x2d\x3f\x01\xde\x86\xb3\xd8\xfc\x40\x62\xe7\x26\x10\x3b\x02\x1e\x08\x24\xe0\xa1\x11\xf0\xa3\x42\xc0\xde\xc5\x8e\x20\x8b\x74\xdd\x0b\x3f\x0e\x0f\x78\xfb\xc4\x69\xa8\xe5\x7b\xb4\x8d\x63\xb6\xde\xd4\x3e\x8d\xc4\x1a\xae\x09\x66\xe7\x20\x6d\x5a\x02\x8a\xd7\xc7\xc7\xc5\xe9\x9d\xc8\x99\x67\x36\xe7\xc7\xbb\x8d\xb6\x51\x21\x23\x48\x24\xb6\xde\x99\xd4\x0e\xda\x73\xad\xad\x77\xd4\x37\x4c\x17\x53\xb4\xce\x96\xd0\x1d\xb6\x67\x76\x72\xcc\xf9\x3f\xd8\x41\x8b\x49\x9e\x5e\xdf\x47\xec\xcd\xe4\x37\x5a\x47\xf9\x3a\xee\x11\x74\x32\x83\x3e\x7a\x9b\x62\x66\x06\x7f\xff\x00\x3c\xd8\xd5\x89\x09\x9d\x9f\x8f\x94\xbd\xdb\xc3\x35\x06\xcb\x5c\x89\x89\x30\xc9\x60\x34\x26\xc5\x23\x8f\xca\x66\x4b\xf1\x78\x13\x30\x27\x52\x1d\x8a\xe3\x78\xcc\x65\x41\xde\xc8\x27\x63\x84\x47\x6a\x12\x4c\x90\x37\x27\xd9\x23\x81\xc6\xb8\x98\x18\x56\x65\x79\x84\xf2\x98\xbb\x46\xb2\x8a\x3d\xed\x41\xde\xeb\xef\xf3\x46\x7a\x57\xda\x17\xf0\x6a\x41\xcf\xa2\xeb\x6d\xf8\x76\x50\xe9\x92\x4f\x26\xb6\x26\xc9\x2f\x02\x1b\xd0\x5c\x67\xf3\x9f\xbb\x62\xef\x5e\x4a\x77\x46\x28\xfb\x7f\x0a\x37\x23\x58\x9a\x98\x92\x82\x77\x5a\x15\xe6\xfe\x93\x79\x9f\xd9\x64\x4a\xc5\x12\x34\xac\x0e\x25\xa1\x44\xb7\x1b\x8b\x23\x46\x77\xb2\xbb\xdc\x8d\xbb\x85\xdc\xc8\xcd\xe9\x95\x88\x4b\x9d\x38\x03\xc2\x7b\x51\x82\x1a\x0d\xc6\x03\xba\x74\x8a\x45\x12\xf8\x8f\xcc\x02\xe9\x19\x58\x9e\x24\x9f\x76\x81\xe1\xf6\xeb\xb1\x0d\x45\xa0\xb7\x4b\x7e\x3e\x69\xef\x8a\xb9\xd7\xe3\x1e\xe4\x5f\x57\xec\xa5\xf7\xa2\x07\xb6\x5f\x91\x9a\x29\x5f\x93\xc5\xe5\x70\xb3\x83\x3d\x9c\x1e\xad\xce\x28\x18\xec\x98\x17\xce\xb6\x67\x20\x64\xb7\xa2\xdc\x1c\x93\xa9\x7b\xb6\xc5\x8e\xf7\x04\xbb\xdd\x9c\x63\xca\xc1\x5b\x9e\x51\xcf\xb9\x08\x92\xfa\x28\x92\xba\xaf\x7b\x21\xa1\x93\x54\xd2\xd1\xb7\xeb\x5e\x4e\x40\x2c\x80\xe0\xf5\xec\xf5\x11\xe8\x7c\x31\xa1\x12\x39\xdc\x6d\xed\x70\xab\xbb\x2d\xb9\x8b\xbd\x3e\xfc\xfb\x6d\xf0\xf5\x4e\x5e\x77\xe6\x61\xc6\x7f\xdb\x35\x06\xfb\xa8\x2c\xac\x83\x3f\x47\xee\x79\x4a\xf5\xb8\xff\x7e\xae\x1f\x77\x6b\xb0\xd2\x67\x4f\x70\x5b\x32\x4c\xdd\x72\x73\xb5\x65\xf9\xa8\xbb\x01\x8f\x42\xf7\x20\x42\xdd\xdd\x76\xbe\x7f\x96\xc9\x34\xa0\xbb\x3d\x33\xa3\x2a\x64\xc9\xcc\x34\x26\x24\xc4\x71\x71\xc9\x55\xa1\x38\xb7\xb9\x9b\xb1\x1b\x51\x6c\xeb\xb9\x7c\x2d\x1e\x91\x5e\x74\x44\x8a\xfe\x87\x11\x61\x86\x25\x84\x7e\x46\x7c\x28\x75\xba\x98\x52\x18\xc3\x05\x5d\x67\x94\x3a\x4c\x4e\x62\xa2\x9e\x11\x9b\x93\xff\x7e\xdd\x01\x8f\x1d\x6c\x8b\x4a\x21\xf2\xb6\xcc\x87\xad\x4b\xe6\x75\x88\x21\xcf\x6c\xfb\x9f\xae\x40\x90\xd1\xec\x90\x52\x40\xaa\x3d\x54\x13\x11\x53\xc2\x85\xd7\xbf\xf6\x85\x97\xf5\xc0\xf6\x4a\x8a\x5f\x19\x5c\x09\x57\x86\xc7\x78\x53\x70\x58\x59\x5a\x86\x81\xd3\xf4\x16\x82\xe6\xa0\x18\xf0\xf9\x3c\xb9\x66\x64\x34\xa6\x14\xb9\x5c\x29\x62\x1a\x3f\xa0\x7f\x7a\x59\x5a\x19\x16\x63\x7a\x10\xf1\xd1\x98\x66\x4c\xe1\x2c\xc9\xf6\x84\x84\x7c\x62\x23\x61\xcf\x24\x7e\xb3\x7a\x97\x66\x18\x33\x98\x40\x89\x37\xc2\x97\x14\x69\xb2\xd3\x48\x47\x45\xcb\x08\xaf\x42\xe2\xde\xc5\x5a\x1c\x76\x95\x30\x8b\xba\x5e\xc2\x55\x06\x5b\xe8\x8a\x8a\xd6\x88\x0c\xca\xbf\xdb\x49\x06\x9d\x47\xc6\x6d\xf1\xb5\x68\x1a\x6e\xea\x8c\x9e\x17\xd1\x35\xf2\x29\x19\xb9\xae\x38\x6b\xef\x82\xae\x5a\xf8\x4b\xf8\x36\x26\xc0\x42\x6e\x02\xc7\x09\x45\x42\x0e\x97\xca\x95\x62\x2e\xa8\x30\x2f\xae\x30\x4e\x67\xb5\x5a\x32\xbc\x3a\xb5\xba\x48\x10\x24\xaf\x85\xef\x51\x96\x11\xc7\x19\x8d\x8e\xea\x90\xd5\x6a\x34\xf9\x3b\x14\x8c\xa5\x18\x2f\xed\xb1\x0a\x46\x57\xac\x17\x95\x4e\x01\x3f\x14\x63\x8b\x58\x95\xa3\xb7\xa4\x83\x12\x29\x67\x06\x84\x87\x25\x1c\x6b\xe4\x4c\x21\xc0\x94\x92\xa0\x66\xe9\xea\x48\x7c\x6b\xb0\x77\xc0\xa0\x7d\x0f\xda\x8f\x58\x67\x8d\x99\xb9\xc8\xd7\x7f\xed\xbc\x05\xe5\x3f\xfe\xc3\x04\xec\xe9\x15\x2b\x97\xdf\x50\x92\x9e\xf4\xe1\x2a\xdd\xd8\x86\x50\xf6\x40\x1a\xf1\xda\xbc\x7a\x6d\xdc\xc8\x41\x93\x46\xa6\x15\xa4\x77\x4b\xab\x9a\x37\xf4\xc0\x83\xdb\x1f\xca\x2c\xcd\xcd\xcd\x1e\xd2\xd0\xb7\x78\x62\x72\x78\x45\x5f\x5b\x35\x1e\x83\x99\x8a\x1f\x21\x12\xc3\xab\x21\xe8\x57\x67\x64\xb8\x7c\x4e\x9b\x2d\xcb\x04\x4d\x16\x1f\x9f\x94\x9f\x54\x90\xe0\x1d\x85\xd9\x97\x4c\x8b\xd5\x52\x1d\x72\xda\x83\x56\x63\x5e\xae\x36\xb7\x2a\xa4\xd6\x3a\x62\x0f\x1b\xfc\x51\x87\x0e\x5d\x43\x42\xfb\x3b\xac\x09\x52\x14\x59\x3e\x20\x76\x0e\xec\x1d\xe8\x74\x30\x61\x8d\xa8\x63\x01\xa2\x47\x14\x45\x43\x0a\xe3\xc6\x0f\xef\x08\xf3\xfd\xae\xd4\xe9\xc0\xe2\xd3\x77\x71\xb7\x73\x7a\xd0\x73\x8b\x82\x49\x2d\xce\x68\xcc\xef\xb4\x8e\x13\x0c\x61\x52\x78\x45\x20\x73\x8c\x91\xd9\x18\x8c\xc0\xbc\xef\x3e\x3c\xef\xa5\xdc\x00\x6e\x6b\x70\x48\x6e\x52\x52\xba\x23\x1d\xb3\x10\x79\xfd\xf8\x5e\x8e\x5e\x25\x0e\xad\x85\x78\xe5\x2d\x49\x43\x83\x06\xf6\x43\xe5\xa2\xbf\xbc\x2a\x94\x97\x10\xef\xf7\x73\x29\x29\x59\x55\xa1\xf4\xf4\x14\x93\x5d\x6f\xd0\x57\x87\x2c\x26\x83\x51\x24\x96\x6f\x0e\xae\xac\xf3\x2d\xab\x2e\x28\xc1\x9c\xe0\x5e\xe3\xeb\x34\xa2\x22\xb5\x44\xb8\x8e\x0e\x4b\xab\xae\x9a\xe9\xe8\x82\x8a\xb9\x58\x07\xd9\xca\xcb\x88\xf8\x7b\x95\x92\x00\xba\x63\xfa\x3d\xf9\x13\x6f\x1a\x3b\x6b\x4e\xa7\x98\xe8\xa1\x91\x73\x52\x3b\xae\x0c\xae\xde\x5f\x27\xac\x9a\xdb\x54\xde\xbc\xf6\x8b\xe7\x16\xdf\x15\xf0\xf7\xbd\x7d\x5d\xdc\x14\x5b\x69\x7e\x79\x56\x97\x70\xe9\x43\x6b\x9b\x89\x53\x26\x76\xa7\x50\xfe\xdb\xce\xee\x09\x53\xfa\xf8\x9a\xa7\xde\xf6\xd0\xa6\xc9\x43\xb3\xba\x8f\x98\xef\x4d\x63\x7a\x86\x6c\xcc\x8f\xdd\x8f\x71\x28\xc0\x2d\x0a\xf6\x86\x66\xad\xb6\xd0\x9b\x91\x6d\xca\xb4\x64\x9a\xcd\x96\x8c\xf8\x78\xbb\xc3\x61\x29\x44\xa5\xc5\xaa\xb2\x3c\x3d\x1e\x49\x53\x12\xde\xeb\x92\xb8\x6c\x47\x9c\xcd\x15\xe7\xaa\x0e\x65\xc4\x19\x2d\x8e\x4e\x77\x06\xfc\x1d\xe6\x1c\xd7\x33\xda\x8a\x2c\xaa\xb2\x88\x7c\x11\x6b\x93\xa5\x18\x01\x29\x37\xcf\x3b\x05\x47\xf7\xda\x3a\x5b\xea\xa2\x0f\x22\xe6\x4c\xb7\x2a\x66\x41\x8f\xfd\x85\x5d\x93\x70\xb2\xd3\xa6\x0a\x6b\xbf\xfe\x66\x2b\x58\x12\xb5\x14\xba\x2b\xea\x87\x0f\xfe\x10\x31\x14\x3a\xdb\x36\x04\x9d\x5d\xbf\x9c\x1c\x42\xa9\x2a\xc6\x4f\xee\x30\x1a\xfa\xf6\xee\x8d\x78\x6c\xbc\xed\xdf\xf0\xbf\xe1\xb1\xc9\x26\xde\x0f\x9c\x0e\x75\x5a\x82\x19\x91\x38\x6e\xe6\x34\x07\x9f\x9b\xa3\x4e\xc8\xb4\x21\x31\x53\xac\x0e\x75\xcb\x74\xd8\xe2\xaa\x49\x54\x13\x53\xc4\x86\x52\x89\x2b\xa9\x0c\x45\xd9\x35\x31\x4d\x88\xe9\xe4\x75\x0e\x22\xd3\x15\x25\xba\x42\x53\x3c\x19\x12\x31\xa2\xbc\xdc\xe7\x97\x96\x7d\xf7\x65\x56\x2f\xbe\x71\x4e\x8f\xf7\x9e\x04\x43\xb2\x76\xa7\x3f\xdb\xb8\x20\xb9\x67\x6d\xc9\x82\x85\x7d\xff\xf8\x97\x7c\xe5\x59\x97\x70\xe1\x6a\x75\xc5\x8c\xa9\xe3\xb2\x7b\x17\x64\x77\x1b\x3e\x6b\xc0\x9e\xc3\xed\x71\xb7\x57\x8f\xc8\x2a\xce\x48\xb6\x66\x56\x37\x8d\x38\x7c\xfc\xd6\xd5\x74\xfd\x78\xf1\x86\xf4\x22\xee\x93\x0a\x4b\x58\xc4\x5a\x5d\xa3\xc1\x52\xbd\x4e\xcb\xf3\x7a\x62\xaf\x8b\xf7\x1b\x23\xe0\x44\x0d\xa7\x51\x48\x24\x33\x64\xe9\x7c\x55\x25\xd2\x7e\xca\xad\xe0\xed\x80\x34\x71\x24\x4a\x76\x87\x1d\x70\x81\x3b\xbc\x68\x3f\xfc\x92\xd8\x75\x12\xa6\x03\x1d\x6f\xbb\x44\x7d\xba\x42\x8c\x5f\x80\x5f\x8d\xeb\xd5\x71\x71\xdc\xca\x60\x5f\x97\x36\x4e\xab\x37\x38\x01\xe7\x44\x1a\x87\xda\x8e\x65\x2e\x23\x82\x26\x64\xe6\x89\xa2\x44\xb2\x8a\x16\x11\xd3\x70\xa8\xe1\x75\xf1\x3a\xb7\x46\x02\xbc\xcb\x6e\xb4\x58\x54\x4e\x9b\xc1\x6c\xc7\x1c\xa7\x56\xe0\xa8\xf8\xa7\x78\x22\xc6\x9f\xaf\x17\x16\x16\x76\xa2\x5a\x4e\x36\xd4\x31\xc0\x8f\x53\xd0\x98\xc2\x5a\xe0\xa3\x57\x20\xdc\xc0\xdf\xe9\x01\x15\x6c\x4c\x93\x37\x96\x2c\x8d\x07\xc2\x8a\xac\x7f\xaf\x96\x13\x3a\x3d\x22\x35\x4c\x0b\x7f\x08\x9f\x0f\x5f\x80\x45\xe1\x8b\xd0\xff\x47\x71\xe7\x67\x0e\xb6\x87\xf1\xd8\xee\xc4\x7d\x24\x47\x10\x43\x83\x69\x78\x50\x0d\xb8\x17\x7a\x0d\x84\x46\x49\x32\xeb\x4d\x06\x2d\x16\x93\x04\x03\xfe\x4f\x54\x63\x91\x12\x8d\x22\x2e\x57\xa2\x4a\x7b\x16\x98\x32\xd6\xea\x24\x42\x7a\x99\x2c\xeb\x8d\x40\x3e\xff\x4f\x7d\xc2\x57\xfa\x1c\x6f\x40\x0b\xe4\x4f\xd9\xd7\x89\x68\x01\xfa\x02\x94\xcb\xcf\x82\x7f\xfe\x51\xc4\x20\xc6\xdf\x25\x72\x9d\x50\xc5\x0f\xe7\xd2\x48\xac\x7b\xb7\xe4\xd0\x71\x69\x3a\xc9\x22\xa4\xfb\x7c\x19\x69\x6e\xc0\xa7\x18\x2d\x36\x9b\x71\x54\xc8\x66\xe2\x93\x3a\x14\x03\x91\x48\xd7\xe5\x9d\xaf\x5e\xf8\x62\xaf\xfd\xa7\xb3\x2b\x16\x1e\xb3\xad\x43\x2f\x45\x44\x49\xf4\x05\x1a\x78\x62\xc5\xad\xdb\x4c\xc5\xf6\xc1\xc3\x42\x7d\xb5\xf5\x1b\x80\xdd\x14\x30\x86\x1a\xd6\x3c\x9e\xb4\xb2\x55\xfe\xf0\xf4\xae\xaa\xda\x1b\x57\x06\x87\x03\xd3\xe2\xec\xe1\x03\xd3\xef\xc9\x92\xbf\xe9\x5d\x2b\x7f\x51\x51\x32\xba\xff\xf1\x3d\x70\xcd\x1f\x09\x8c\x26\x2d\xc1\x34\x69\x17\x6e\x77\x31\x5e\x77\xd9\x89\x92\x4b\x97\xc5\xf9\xd3\xfd\xa4\xe9\x25\xb9\xb9\x81\xee\xf9\xf9\xd9\xa3\x42\xf9\xb8\x03\x69\x46\x8b\xdd\x8e\x3b\x60\x37\xf1\xde\xeb\x74\xe0\xda\x10\x5e\xd7\xed\x47\x87\xb1\x21\xd9\xcd\x23\x16\xc1\xb1\x46\x03\x25\x5d\xfb\x95\xda\xdc\x67\xe7\x4e\x73\xc0\x98\x56\x13\xa4\x3d\x7b\x4f\x7d\x67\xaf\x61\x70\x46\xd5\x8e\xdd\x62\x97\x1e\x9a\x5d\x2d\x9b\x06\xd7\xca\x7f\xaf\x4c\xef\x17\x4c\x26\x7d\xbc\x7a\xb2\x30\xf5\x80\xed\x1e\xe7\xae\x0d\xee\xde\xe4\x5c\x4b\x0f\x2e\xc3\x27\x45\xce\x24\xa1\x1c\xee\x0d\x8e\xf5\x5f\x87\xdf\x3d\x81\x17\x61\x0a\x9e\x37\x2f\xf1\xd4\xee\xb1\x79\x48\xfc\x24\x9f\x5e\x14\x53\x13\x5d\xe4\xda\xc6\x57\x46\x0e\x79\xd0\x41\x84\xd0\x37\x5c\xf9\x04\xa6\x09\x89\x35\xd5\x60\x44\xb6\x20\xdf\xfa\xdf\x2f\x6e\xfc\x5e\xda\x3c\x72\xfa\x74\x43\xdd\x8a\x5a\xdd\xb2\xfa\xf5\xb6\xea\x65\x87\xcc\xb3\xea\x0a\x52\x6d\x49\xae\xec\x02\xbd\xd3\xc4\x4f\xa9\x0a\xce\x9c\x9c\x39\x5c\x2e\x02\x2f\xf7\xcd\x5c\x7c\x53\xb3\x5c\x8b\x26\x8c\x9b\x65\x9c\x6d\xe8\x37\x68\x55\x29\xd5\xcd\xdf\xcc\x3d\x0d\xd6\x08\xed\x58\x92\x32\x73\x05\x41\xb7\x51\xc7\xe9\xa0\x08\xf1\x22\xd6\x5f\x51\xf3\xdf\x71\x46\x98\x0c\xf3\x60\x03\xe4\xe1\x65\xd6\xd6\xf2\x98\xc0\xf4\xe4\x96\xaf\x5f\x02\x9d\xbc\xa7\x7e\xe7\x5c\xee\x90\x57\xa5\x94\x98\x6c\xa9\x59\x99\xba\x03\xcb\x0f\xd9\x26\x08\x9b\x96\x2d\xbb\x5a\xaa\x9e\x24\xf4\xe8\x87\x06\xb5\x3d\x70\xc3\x14\x32\x76\xb9\x78\x9c\x6c\xfc\x8f\x78\xec\xba\x93\x28\x3c\x4c\x17\x0c\x2e\x41\xc4\x7f\x8e\x5b\x92\x11\xb4\x68\xcd\x1a\x51\x92\xac\x66\x0b\x34\x7e\xad\x13\x35\x5f\x89\x57\x98\x25\x55\x44\x80\x2e\x24\x5b\x90\x35\x6a\x13\x1d\x31\x30\x2b\x4c\x8d\x1b\xbc\xc0\x31\x6c\xf9\xbc\xc4\x45\x2e\x94\x55\xdf\x3b\x25\x09\x8e\x54\xef\x5d\x0a\x76\x84\xcf\x9e\xd8\x57\x3f\x4a\x4d\xea\x71\x73\x4f\x41\x88\xeb\x49\x20\xf6\xfc\x0e\x7d\x82\x1d\x57\x94\x94\x90\xe8\x14\x61\xfc\xd7\x5a\xd3\xb7\xb4\x26\x3a\x2d\x1d\x55\x75\xaa\xcb\x16\x7b\x26\xc5\xaa\x2d\x50\xaa\x3d\x88\xfa\x66\x79\x6c\x05\xdd\xfa\xd6\x8a\xdd\x61\x56\x6d\xef\x8c\x38\x58\x49\xaa\xbf\xb9\xed\x11\x5f\x5f\x75\x93\xba\x72\x64\x82\xef\xab\xba\x2a\x0d\xa5\xab\xd9\xe0\x32\xf2\xe3\x76\x10\xdb\x9e\x60\x30\x09\x60\x42\x0e\xf5\x3a\x9d\x5d\x6b\x96\xb4\x12\x35\xf0\xb1\x51\x27\x8b\xba\x2b\x76\xed\x57\x11\x9d\x99\xbf\x13\x35\xf7\x47\xd9\x18\xeb\xb5\xa6\x3d\xd9\x00\x5d\xdd\x0a\xe2\x6f\x97\xff\x32\xbc\xea\xc1\xdb\xe4\x17\x77\xae\xe8\x39\xae\x6e\xd3\xa9\x7c\x74\x1c\x14\xcb\xcf\x98\x26\x0d\x59\xba\x05\xfe\x11\x9e\x31\x66\xe0\x2c\xf9\x2a\x3d\x23\x00\x97\xf9\xb5\xb8\x3d\x56\x62\x73\x67\xb1\x72\xc0\x64\xd0\x23\x41\xd4\xa8\x24\x13\xd2\x48\xbc\xcd\x6a\xb5\x23\xfd\x15\x8b\x74\xc5\xa4\x01\x22\x69\x90\xdf\x1f\x39\x40\xed\x7c\x7e\xca\x28\x1f\x22\x56\xb7\x98\x40\x3b\xcb\x01\x6e\x90\x33\x80\xa9\x74\xf2\xcd\x6e\xd4\xfd\xca\xcd\x7d\x96\xb9\x05\x9b\xef\xab\xf5\x49\xbc\x1d\xa8\x97\x62\x4c\xb0\xaf\x5a\x1c\xfe\x1c\xb7\xe5\x8f\x6d\x85\xa3\xa1\x36\xfc\xcb\xa6\x42\xc5\xc6\xbe\xfd\x67\xee\x29\xd4\x17\xb7\xc9\xc6\x15\x06\x5d\x6a\x95\x59\xa7\xd2\x41\xa3\xc9\xe4\x80\x76\x9d\x84\xe5\x2e\xd5\x15\x1e\x72\xdf\x92\xb3\xdc\xe8\x99\x65\xcc\x4e\x17\xc0\xa8\xe9\x24\x77\xb8\xfd\x56\x62\x4d\x8e\x07\xc8\x00\x2b\x0b\x33\xed\x45\xfd\x66\xf4\xbe\x6d\xe5\x08\x87\x28\xc5\x81\xf4\xcd\x72\x5d\x75\x68\xca\x53\x9a\x06\x71\x52\x33\xfc\x49\x1e\xdb\x32\xcc\x5c\x00\xf3\xc2\xc2\xcd\x8d\x24\x86\xc8\x6b\xe8\x25\xf0\x2c\x8d\x0b\xac\xa1\x76\xc1\x4f\xa0\x97\x90\x8f\x3e\x0b\xf4\xf9\x53\x1e\x41\x28\x5c\x30\x8b\xd2\x67\x71\xc3\x50\xdd\x63\x9c\xb6\xbd\xe5\x54\x4b\x4b\x85\xf6\x1c\x86\x6b\xd6\x30\xb8\x7a\x35\x83\xab\x56\x31\xb8\x72\x25\x81\xe7\x4f\xad\x58\xc1\x9e\x97\x2f\x67\x70\xd9\x32\x02\x83\xa7\x96\x2e\x65\xcf\x4b\x96\x30\xb8\x78\x31\x83\x37\xde\xc8\xe0\xa2\x45\x2c\xdd\xc2\x85\xec\x79\xc1\x02\x06\x9b\x9b\x19\x6c\x6a\x62\x70\xfe\x7c\x56\xcf\xbc\x79\xec\x79\xee\x5c\x06\xe7\xcc\x61\xf0\x86\x1b\x58\x39\xb3\x67\xb3\xe7\xc6\x46\x06\x67\xcd\x62\x70\xe6\x4c\x06\x67\xcc\x60\xe5\x4c\x9f\xce\xe0\xb4\x69\xec\xfd\xd4\xa9\x0c\x4e\x99\xc2\xca\x99\x3c\x99\x3d\x4f\x9a\xc4\x60\x43\x03\x83\x13\x27\x32\x38\x61\x02\xcb\x3f\x7e\x3c\x83\xe3\xc6\xb1\xf7\x63\xc7\x32\x18\x0a\x31\x38\x66\x0c\xfb\xbd\xbe\x9e\x3d\xd7\xd5\x31\x58\x5b\xcb\xea\x19\x3d\x9a\x3d\xd7\xd4\x30\x38\x6a\x14\x83\xd5\xd5\x0c\x56\x55\x31\x38\x72\x24\x2b\xa7\xb2\x92\xc1\x11\x23\x18\x1c\x3e\x9c\xc1\x61\xc3\x58\xba\xa1\x43\x19\x1c\x32\x84\xc1\x8a\x0a\x06\x07\x0f\x66\x70\xd0\x20\x06\x07\x0e\x64\x70\xc0\x00\x06\xfb\xf7\x67\xb0\x5f\x3f\x56\x5e\xdf\xbe\x0c\x06\x83\xec\x7d\x79\x39\x83\x7d\xfa\x30\xd8\xbb\x37\xfb\xbd\x57\x2f\x06\x7b\xf6\x64\xb0\x47\x0f\x06\xcb\xca\x18\x2c\x2e\x66\xb0\xa8\x88\x41\xbf\x9f\xc1\xc2\x42\x06\x0b\x0a\x18\xcc\xcf\x67\x30\x3b\x9b\xc1\xcc\x4c\x06\x33\x32\x18\x4c\x4f\x67\x30\x2d\x8d\xc1\xd4\x54\x06\x7d\x3e\x0a\x83\xea\x94\x94\x0a\x2d\x89\x90\x4c\xdf\xba\xdd\x0c\xc6\xc7\x33\x18\x17\xc7\xa0\xc3\xc1\xa0\xdd\xce\xa0\xd9\xcc\xa0\xc9\x44\xe1\x49\x49\xaa\xc8\xfe\xdf\xfd\x87\xd7\xd9\xfb\x3c\x02\xbf\xd3\x75\xf6\xb9\x73\x18\x3a\x44\xd6\x59\x50\x59\x67\x41\x65\x9d\x05\x95\x75\x16\x54\xd6\x59\x50\x59\x67\x2d\xff\x3f\xad\xb3\xa0\xb2\xce\x82\xca\x3a\x6b\xf9\x0f\xeb\x2c\xa8\xac\x33\x4e\x59\x67\x41\x65\x9d\xb5\xfc\x1f\xae\xb3\xa0\xb2\xce\x82\xca\x3a\x0b\x2a\xeb\xac\x45\x59\x67\x2d\xca\x3a\x3b\xaf\xac\xb3\xa0\xb2\xce\x82\xca\x3a\x6b\x51\xd6\x59\x50\x59\x67\xc1\xff\xcb\xeb\xac\xe5\xff\xd2\x3a\x3b\x1f\x5d\x67\xff\x5f\xd7\x55\x69\x29\x83\x81\x00\x83\x25\x25\xd7\x5f\x6f\x6c\x7d\xb5\x44\xd7\x57\x5e\x1e\x83\xdd\xbb\x5f\x7f\x9d\xb1\x75\xd5\x72\x8a\x2c\x27\xf2\xec\xf5\x32\xe8\xf1\x30\x98\x9c\xcc\x60\x52\x12\x83\x6c\xc5\xb5\x9c\x4a\x48\xf8\x9f\x57\x9e\xd3\xf9\x3f\xad\xc0\x96\xc8\x0a\x3c\x65\x34\x32\x68\x30\x30\xa8\xd7\xb3\xf5\x6d\xd1\xe9\xf0\xfa\xd6\x6a\xf1\x87\x46\x83\x3f\xd4\xea\xff\xed\x95\x1a\xfd\x47\xcc\xa6\xd5\x78\xcd\xfe\x42\xe5\x46\x5f\xd0\x28\xf2\xbc\x5a\x8d\x59\x1d\x03\x84\x52\x0b\x09\xf4\x10\x7f\xa1\x4c\xb9\x9d\x68\x66\x86\x5e\x92\x0f\x73\xee\x4e\x1f\xe5\xaa\xc0\x2f\xe9\x21\xc9\x3f\x37\x47\x9f\x20\x5c\x78\x3e\x25\x63\xfa\x98\xba\xe9\xa5\x03\x6e\xc5\x65\x36\xf1\x4b\xe1\x28\xe1\x27\x5c\x90\x27\xa8\x47\x1a\x4e\xd2\x48\x06\x23\xe2\x5b\xb4\x1a\x2e\xcf\x1f\x7f\xa1\x30\x7a\xa0\xc8\xce\x76\x03\x2c\xbe\x40\xa0\xb0\x04\xfc\x96\x9d\x6a\xee\x5f\xbb\xac\xd1\x54\x30\x58\x18\x91\x9e\x5d\x5b\x57\x31\x63\x49\x6d\x05\x69\x67\x0b\x2e\x73\x6a\xa4\x4c\x0d\xd2\x8b\x48\x34\x18\x25\xb1\x45\xcf\x71\x79\x85\xf1\xaf\x77\x2a\x93\xd9\x91\x48\xec\xa8\x18\xc6\xf5\xaf\x5b\x3d\xdd\x5c\x38\x28\xc7\xc7\x2f\x45\xa3\x86\xcc\x5c\x5c\x3b\xb4\x2c\x2d\x8b\xf0\x52\x17\x30\x6f\x67\xc4\x7d\x77\x72\xdd\x83\x76\x27\xc7\xe9\x74\x2e\xc9\x62\x89\x73\x20\x64\xd4\x6a\xd5\xc6\x2f\xb9\xaf\x08\x93\xe9\xa7\x6a\x74\x85\xa1\x53\x4c\xb4\x23\xfe\x86\x3b\x79\x30\x31\x02\xc0\x0d\x8c\xcf\x1e\x3d\xaf\xef\xee\xad\x05\x0b\x53\xf6\xae\x68\xd9\x51\x7f\x70\x5e\x3e\xb8\x0c\xa6\xe8\x27\xbe\x38\xee\xf8\x4d\xf6\xa9\x0b\x76\xac\x99\xf7\xdd\x6a\x5e\xf1\x31\x78\x2f\xae\x3f\x15\xd7\x1f\x87\xf9\x26\x27\x67\xb5\xf2\x2e\xc0\x83\x78\x9d\xce\x0d\x1c\x0e\xa3\x5a\xaf\x57\x2b\x2d\xc0\x82\xab\xd2\x82\xe8\x2d\x51\xdc\x06\x7a\x6e\xd3\xe1\x0b\x41\xb1\x18\x0c\x20\x30\xb8\x60\x6a\xb3\x7f\xfa\xce\x19\xf3\xd7\xc1\xe5\xea\x95\xa3\x67\xf7\xad\xac\xc8\xf6\x0c\x02\x97\x7f\x93\x6e\x5e\x55\xf3\xd4\xa6\x7e\xcd\xb3\x35\x1b\x43\xaf\xd5\x84\x26\xea\xe5\xbb\x29\x7f\xb4\x9e\xbb\x8b\x9f\xc1\x1f\xc3\xfc\x52\x72\x97\x67\x2f\x6d\xe7\x74\xee\x5b\x7e\x10\x7f\x8e\x13\x39\x57\x50\xc3\x41\x1e\x49\x2a\x28\xf2\x00\x4f\xe6\xc5\x42\xaa\x79\x21\x72\x9f\x1a\xf8\x80\x9f\x1f\xf4\x80\x7c\x5a\x3e\xf7\x00\xb8\xeb\xe8\xb7\xc8\xd0\xf6\x23\xfa\xf3\x35\xf9\x45\x1e\xe2\xfc\x02\xea\x9a\x1f\xf8\xd5\xc0\x0f\x1f\x38\x2a\xcf\x78\x00\x54\x80\x61\x0f\x7c\x8b\xfe\x8c\xf3\xd3\x7b\x0a\x23\xf8\x13\xf0\x4b\xe1\x2f\x9c\x9a\x7b\x34\x38\x02\xcb\xf6\x2a\x24\x22\x0d\x04\x40\x9b\xaa\x05\x3f\x68\x01\xe4\xb4\xf9\x78\x05\x4d\xd2\x36\x69\x85\x79\x26\xfc\xad\x4a\x8b\x3c\xf8\x55\x15\x7e\xf5\xa9\x56\xe8\xf8\x75\x97\xf6\x07\xad\xd4\x87\xa4\x68\xd2\xb6\x68\x0f\x6a\x05\xba\x10\x97\x28\x8c\xde\xf4\x1b\xd8\x82\xf4\xd5\x85\x2a\x8e\x6b\x81\x87\xe6\x6f\xd1\xf2\x3b\xb5\x80\x14\x31\x49\x8b\xb4\x08\xa9\xa1\x7a\xf7\x38\x01\x72\xec\x5c\x1a\x90\x68\xde\xcd\xcd\x78\x29\x2d\x98\x38\xa1\x19\xff\x35\x4c\x68\x8e\x32\xb7\x7e\x65\xc1\x64\xf8\x04\x1f\xe6\xab\xe1\x97\xfc\xf8\xc7\xa1\xfc\xef\x45\x3c\x48\xba\xc0\xbf\x68\x7b\xf0\x41\x1b\x60\xf7\x68\xb8\x2d\xfc\x09\x94\x42\xfb\xb7\x3f\xd8\x04\x38\x81\x47\x02\x52\x69\x54\x5a\x8e\xd4\x6c\xa2\xcd\xdf\xa5\x3d\xaf\x7d\x13\x37\x5f\x85\x3b\xe8\xc1\x4d\x7f\x93\xf4\x8c\x35\xf0\x53\x2d\xff\xbd\x16\x90\x04\x30\x8f\x65\x80\xa5\x6f\x6a\xc1\x7c\x2d\x50\xc6\xe2\x13\x2d\x68\xd1\x82\x64\x2d\x38\xaf\x05\x0d\xac\x33\x50\x85\x24\x9e\xe3\x71\x57\xc8\xf2\x89\x76\x85\x44\x60\x5d\xb0\x60\xc1\x44\x1a\x4e\x87\x74\xa9\xc3\xc6\x91\x49\x0b\x01\x3f\x0d\xd7\x00\xd5\x17\x4e\xf3\x93\x5f\x86\x6d\x4d\x3c\x7f\x02\x18\x48\x5f\xc8\x1a\xbd\x93\x6f\x81\x43\x31\x3e\x23\xce\x76\x16\x01\x81\x07\x2d\x88\xd0\x90\x8b\x74\x6d\x52\x3d\x8b\x1f\xaa\x9b\xfb\x36\xf3\x2d\x60\x38\x95\x65\xf8\x77\xe0\xeb\x42\x0d\x4e\x7f\x3c\x38\x1d\xf0\x08\x09\xf9\xc2\x24\x01\x96\x0b\xf3\x05\x28\x04\x97\xae\xa8\xf0\x08\xc0\x28\x80\xd9\xc7\x85\x67\x84\x4f\x84\xef\x05\x7e\x92\xb0\x4b\x80\x46\x21\x59\x80\xf7\x08\xed\x02\xf4\x08\x41\xa1\x4a\x68\x12\x5a\x04\x01\x27\xfb\x84\xbc\x6a\x11\x1e\x25\x29\x40\xd9\x71\x9c\x03\x56\x91\xe2\x68\xfa\xef\x05\x70\x5e\x00\x02\x99\xdf\xc4\xb8\xc4\x8a\x37\x48\xda\x20\xcd\x7a\x10\xe7\x20\xd9\x25\x04\xe0\xf6\x10\x46\xca\x6c\x36\x14\xd9\xd1\xa1\x88\x0e\x4a\xb6\x32\x20\x2c\x5e\x15\x6c\x0d\xff\x2d\x1e\xa6\xf3\xef\x10\xdb\x2d\x30\x84\x3f\x0d\xc9\xbd\x70\x01\xf7\x9d\x43\xa2\x24\x74\xe9\x7b\xb1\xd5\x6f\x97\xc0\x90\x75\x6f\xfc\xc4\x9f\xb6\x01\x94\xf8\x07\xce\xe3\xc5\x79\x16\x28\x79\x20\x2f\x4a\x5c\x97\x3c\x19\xc5\x7e\xab\x1d\xda\x7e\x7a\x63\x1d\x7f\xfa\x8f\x44\x39\x6c\xc3\x63\xd6\x20\xcf\x06\xa6\xf6\x33\x78\xcc\xac\x67\x00\xe2\x05\x32\xc6\x79\xd1\x2c\x56\x3c\xc4\x6f\x36\x07\x9b\x71\xa2\xe1\x4c\x36\x3b\x28\x7f\x03\x3e\x6e\xbf\x81\xa6\x47\x02\x00\x3c\xfe\x96\x77\x91\xd1\x12\xd6\x0f\xf0\x62\xf8\xc3\x38\x98\x26\x7f\x43\x6d\xd0\x12\x71\xd6\x79\xed\x6b\x71\x9b\xac\x67\x78\x20\x89\x5c\xa7\xf2\x59\x93\x80\x09\x37\x49\x9e\xcd\x9a\x84\xf3\x64\xe2\x3c\xcb\x94\x3c\xa4\xef\x9d\xf3\x58\x69\xd7\x33\x71\xcf\xe5\xd9\xac\xe7\x44\xae\x1e\x80\x33\x7e\xc7\xf7\xc0\xad\x91\xb8\x64\xbc\x4b\x70\x04\x1f\xd5\x2a\x4c\x1d\xa8\xd9\x6f\x9e\x3f\x96\xa0\xe3\x45\x44\x50\x0f\x7c\xb7\x53\xdf\xf3\x2f\xf8\x8f\xef\xf1\xfe\xfb\x57\x5f\x7a\xff\x7d\x3c\x86\x4e\x34\x55\x29\x07\xe3\x1c\xc7\xf1\x02\xcb\x4f\x72\x47\xb2\x82\xef\x6e\xd6\xf7\x22\x59\x48\x5b\x1f\xe4\xc6\x83\xed\xe0\xfd\xff\xb6\x37\x31\x7f\x16\x91\xbd\x49\x0a\x60\xc1\xb4\x20\x3b\xd5\x34\xb0\x76\xd9\x6c\x93\x7f\x20\xe8\x9e\xde\xbd\x76\xec\x90\xa9\x0b\x61\xad\xd0\x97\xad\xe1\xce\xe5\x72\x92\xa4\xd1\x18\x8c\x5a\x4d\x0b\xe2\x3b\xca\x25\x7b\x28\x35\xcc\x72\xe0\xcd\x89\x5a\x2f\x49\x06\x3c\x23\x31\xe5\x0a\xd7\x94\x3b\x9f\x7b\x04\xbc\x07\x64\x3c\x4a\xa9\x78\x7f\x46\x08\xe0\x77\x2a\xb5\x88\xe5\xd9\x16\x8c\xab\x78\x7f\x36\x2b\x23\xc5\x76\xa6\x34\x6f\xb1\xbf\xd8\x6f\xf7\x83\xf7\xe4\xbd\x2b\x9a\x57\x3c\x32\xe7\x8b\x2f\xba\x96\xe3\x09\x1a\x20\x26\x30\x12\x52\xab\x80\x20\x48\x74\xae\x94\x62\x94\x2b\x14\x3e\xbb\xaf\xd8\x57\xec\x05\xef\xe1\x12\xc0\x4c\x70\xeb\x17\x5f\xcc\x51\xca\x38\x02\xde\x23\xea\x61\x72\xc7\x57\x83\x79\x04\x4c\x11\x45\xa4\xd3\x6b\x44\x20\x88\x82\xfa\x3c\x9d\xf5\x88\x8d\x53\xe4\x48\x22\x5a\x9e\xd2\x2e\x5c\x26\x29\xd6\xb3\x6a\xd5\x9c\x95\x2b\x19\x8e\x5e\x01\x56\x38\x0e\x1c\xa4\x38\xca\x01\x01\x53\x02\xb2\x37\x74\xe0\x68\xb1\x17\x8e\x0b\xef\x82\x4d\xc0\xba\x83\xb6\x63\x1d\xa6\x97\x6e\xe1\x4b\xcc\xb3\x64\x04\xad\x98\x6c\xe8\xd5\x78\xb0\xd5\x88\x43\xb7\x8f\xe3\xa4\x9d\x21\x4c\xd2\xb2\x3b\xdd\xac\x22\xc7\x20\xe9\x19\x7e\xea\x80\xcb\x8f\x47\xfc\xd8\xc6\x43\x70\x11\x9a\x59\x73\x2a\x78\xa3\xff\x19\xfe\xc4\x43\x37\xd5\x56\x1e\xd9\xcd\xee\x92\x83\x3a\xc1\x03\x73\x08\x0d\x03\xe6\x60\x22\xe4\x30\x31\x8e\x13\xca\x84\x21\x02\xfa\x5c\x00\xcf\x09\x6f\x0b\xb0\x55\x00\xb7\x0a\x87\x31\x81\xc2\xcc\x5d\x50\x3b\x77\x61\x05\x14\x2c\x02\xbc\x01\xd0\x67\xf5\xf4\xd9\x15\x2f\x08\xef\x28\xbf\x9a\xc7\x4f\xa9\x28\x12\x06\x10\x42\x05\x78\xc1\xa6\xbc\x1d\x51\x53\x57\x71\xaf\xd0\x2a\xc0\x5d\x02\x18\x20\x4c\x13\x16\x09\x1b\x04\x3e\x5f\x00\x36\x21\x15\x23\xaf\x00\x36\x08\xe4\xd7\x77\x84\xcf\x85\x9f\x05\xb1\x49\x00\xa9\xb8\x84\xd1\x38\x1d\x6f\x22\xa5\x80\xc0\xcf\x02\x78\x54\x38\x2f\x40\x9a\x9e\x52\x34\x57\x4e\x41\x05\xce\x08\x27\x09\xe4\x87\x37\x85\x1f\x04\x4c\x18\xdf\x64\x3f\x9e\x72\xb9\x2b\x68\x22\x83\xc1\x5c\xc1\xc8\x1c\x57\x83\xc9\x1c\x57\x4e\xe9\x5c\x36\xa6\x69\x0d\x0b\xb2\x23\x44\x5f\x09\xc1\x4d\x9e\xb3\x17\x64\x93\xdf\xe9\x4b\x05\xb9\x88\x5d\x15\xa8\x4b\x69\x4d\x11\x3c\xd4\x37\xf7\xab\xfc\x2e\xf8\x88\xb8\x90\xc4\xa8\xe6\x2a\x83\x85\x16\x51\x74\xe9\x38\x2e\x4e\x6d\xdc\x1e\xca\x57\x83\x49\xea\x47\xd5\x3f\xa8\x91\x51\x9d\x8c\x37\x4d\x62\xa8\x62\xdf\x1e\x32\x21\x0f\x0a\x22\xfc\xff\xa3\xe8\x07\x84\x30\xbe\x34\x2f\xa0\xe6\x71\x74\x1f\xcd\x8e\x9d\x30\xc5\xe1\x10\x39\xd7\x93\x22\xf6\x7f\xfe\xc2\x12\xf8\xc8\xcd\xd3\xa6\xdd\x7c\xf3\xb4\xa9\x3b\xe7\x0c\xef\xd1\x73\xf8\xf0\x9e\x3d\x86\x0b\xeb\xc8\x8b\xe9\xdb\x77\x4c\xeb\x31\x7c\x64\x20\x30\xaa\x8a\xe2\xc8\x60\xb9\x16\x10\xeb\x13\xa2\x31\x8d\xd7\x60\xa2\x24\x19\x11\xb2\x58\x8d\x62\xb2\x88\x5b\x23\x72\xfa\xed\x21\x0f\x4e\xc6\xe5\x4d\xc0\x0d\xa0\xd6\x3f\x91\x23\xa4\x88\x69\x19\x41\x95\xc8\x55\xa7\xdf\xc7\x8c\x5d\x30\x6e\xe3\x84\x69\x99\xe9\x25\xbd\x8c\xfd\xe5\xda\x89\x43\x6b\x76\xf8\xf2\x57\x95\xa7\xe4\x39\x1a\xdd\xb4\xbe\x62\x8c\x93\x85\xc2\x53\x9c\x03\xf4\x08\xce\x97\x54\x2a\xa7\xc5\x6a\x75\x2d\x72\x01\x87\x6b\x90\x6b\x86\x0b\xbd\xe4\x7a\xcf\xf5\xa5\x0b\xb5\xba\xc0\x1e\xd7\xfd\x2e\xb8\xc1\x05\x66\xb8\x16\xbb\x60\xaa\x6b\xb4\x0b\x8a\x2e\x87\x0b\x36\xfe\xec\x02\x24\x09\x7c\xc1\x05\xee\x77\x9d\x71\xc1\x5b\x5d\x60\x91\x6b\x83\x0b\x4e\x71\x81\x41\xae\x3a\x17\x2c\x22\x65\xa5\xbb\x20\x66\x12\x7f\x75\x81\xcf\x5d\xe0\x6d\x17\xc0\x69\xcf\xb8\x80\x8b\x60\xd5\xa0\xaa\x9a\x8a\x3a\x5c\x13\x1c\xe0\x02\xe9\xae\x12\x17\xb4\xb9\x80\x48\x93\xfe\x83\xa4\x7b\xc7\x05\x4f\xba\x30\x17\xed\xda\xe5\x3a\xe8\x42\xd3\x70\xcb\x60\x95\x0b\x14\xb9\x06\xb8\xa0\x07\x73\x9d\x2e\x9b\x0b\x96\xfd\x40\x8b\xc2\x12\x56\xa0\x82\xc0\xa0\x3e\xa3\xa0\xe2\xbc\xeb\x4d\x17\x84\x8f\x2a\xbf\x38\xdc\xec\x17\xa3\xce\x54\x61\x74\x25\xbb\xa0\x45\xd0\xb6\x98\x24\xc2\x43\x14\xc6\x5f\x2c\x2c\x04\x18\x9f\x9a\x1b\x9a\x29\x3b\x44\xff\x35\x44\x71\x2a\x9b\x7e\x2e\xe8\xf8\x37\x31\x1a\xf4\x3d\xe6\xea\x63\x4a\x77\x88\x59\x6a\x1f\x75\x94\x0a\xe9\x6a\x85\x30\xd0\x6d\xf8\xc0\x60\xf2\xb4\x6e\x63\xf3\x96\xd5\xe4\x0c\x1f\xd8\x27\x69\x7a\xe6\x78\x5f\x70\x2c\x7f\x22\x2d\x37\x6d\xc9\x9d\x8b\xc8\xe7\xdc\xe9\x3d\xc8\x9e\xe2\xc4\x73\x10\x14\x3e\xc7\xfb\x90\x16\x4c\x0a\x26\x88\x5a\x04\x31\x7f\x03\xb5\x48\xa7\x52\xab\xf5\x01\x3d\x48\xd7\x03\x41\x6f\xd7\xc3\x55\x7a\xaa\x21\x58\x59\xa1\x27\xbd\x89\x9b\xd3\x54\xf1\x9e\x1e\xbc\xac\x07\xf7\xeb\xcf\xe8\xe1\x66\xfd\x1d\x7a\x38\x43\xbf\x58\x0f\xf1\xaf\x5c\x30\x71\xd2\xd4\x0a\xab\x1e\xf0\x7a\xf0\x99\xfe\x27\x3d\xe4\xce\xeb\xdf\xd4\xc3\x93\x7a\xb0\x5b\x7f\x2f\x4b\x71\x0a\xaf\x67\x0c\x83\xc1\x9c\x11\xa3\x2a\x3e\xd7\x83\xb7\xf5\xe0\xbc\x1e\xe0\x14\xbb\xf4\x07\xf5\x70\x8a\x7e\x81\x7e\x9d\x1e\x0d\xd0\x8f\xd6\xc3\x7c\x3d\x80\x7a\x8b\x3e\x45\x8f\xfa\x90\x06\x04\x13\x8b\x7b\x93\x8a\x4f\xea\x9f\xd3\xc3\x0d\x7a\x52\x20\x5a\xac\x07\xd3\xf4\x60\x94\x1e\x00\x9a\xc2\x90\x91\x5d\xf1\x8e\xfe\x73\xfd\xcf\x7a\x84\xcb\xa4\xad\xed\x11\x97\x52\xc1\xe9\x4d\x7a\xa8\xbc\x3f\x48\x9a\x02\x9a\xf4\x2d\x7a\x08\x27\xe9\x81\x51\x9f\xa7\x2f\xd7\x63\xea\xae\x82\x02\xbc\x7d\x9c\xd6\x28\xe4\x09\xe5\xc2\x1a\xcc\x3d\x09\x02\x46\xf6\x0e\xb6\x95\x4d\x0d\x9e\x96\xec\x06\x36\x21\xd9\x91\x19\x99\x40\x66\xb1\x19\xcf\xe3\x02\x4a\x18\xf0\x27\xfd\xc9\xec\xef\xe4\xcf\xd1\x1a\xb0\x62\x6a\xe0\xa7\x9f\x4e\xd4\xf6\x86\x20\xef\x0e\xa3\x30\x01\xfc\x09\x1b\x48\x4e\x94\x2f\xb3\x4f\xbc\x36\xa6\x80\xe9\x70\x2a\x32\xe1\x8d\x39\x21\xa8\x03\x3a\x49\x67\x44\x26\xb3\x1e\x6f\xf7\x98\xca\x5f\x28\xeb\xd8\x77\xd8\x6a\xa3\x2e\x12\x7b\x03\x29\x00\x46\x75\xf3\x97\x56\xe5\x2c\x1b\x3b\x7b\xc1\x28\x1e\x99\x36\x0d\xe8\x97\xba\xb3\x68\xed\x5a\x8d\x75\x33\xb9\x8b\x83\x72\xe1\x67\xc2\x5b\x98\xf6\x74\x0f\x3a\x31\x3f\x2b\xf0\x1c\x96\x5e\x75\x1a\x8e\xd3\xab\x04\x2d\xe4\xd5\x12\x62\x02\x46\xe4\x96\x4c\xe4\xd2\x01\x90\x32\xa4\x8c\x40\x46\xc0\x19\x70\x4a\xf0\xb3\x31\x7f\xfc\x31\xe6\xea\x55\xfa\x89\x36\x46\xbe\xe1\x4f\xca\xa3\xec\xe7\x9e\x42\xa3\xe8\x59\x47\x02\x57\x14\x8c\x13\x9d\x6a\x3b\x16\x13\x51\x3c\x30\x1a\x85\x44\x21\xc9\x89\x80\x45\xf7\x2d\x0f\xae\x28\x6a\xff\xb2\xa8\x13\xa9\x68\xe8\x86\x6b\x5c\xc1\x39\x99\x2b\x38\x40\xad\x54\xf7\xad\x5e\x0c\xca\xb6\xca\x0b\x3c\xfa\x71\x35\xfd\xaa\x46\x0c\x4b\xf4\xc6\x95\xba\xe3\xe0\x18\xb8\x3d\x7c\x19\x3a\xc2\xf3\x67\x0c\x48\x9e\x34\x77\x54\xff\xda\xe9\x5f\x15\xe7\x06\x06\x55\x05\x5d\x71\x49\x94\xd6\xb8\xc1\x15\x10\x12\x01\xde\x2f\xe3\x83\x58\xfc\x81\x02\xe2\x78\x70\x99\xca\x8a\xd4\x0c\xd5\xcf\x2e\x58\xfb\x91\xfb\x85\xe5\x2f\x80\x2b\xbc\xe3\xea\x65\x9a\x2f\x15\x5c\x82\x4f\xf1\xff\xe2\xd2\xc8\xfd\x82\x64\xd1\x66\x4b\x8f\xc3\xe2\x73\x86\x3e\x19\x39\x9d\x09\x9f\x87\xe2\xe3\x9d\xdf\x20\xcd\xe7\x21\x49\x42\x5f\x47\xbc\xc5\x75\xba\xfe\x4b\x07\x31\x4a\x9c\x3b\x45\x3b\x52\x6e\x6e\x28\x07\xec\x0e\x67\x12\x84\x37\x1d\x3d\xb8\x7a\x53\xfc\x34\xdb\xb8\xba\xc9\xd3\x13\xcb\x26\x2d\x9d\xb6\xff\x96\xef\x3d\xf3\x13\xb6\xd7\x8c\x0f\x2e\x1a\x57\x53\x00\x5f\x6b\x5e\x35\xa6\x26\xb3\xac\xcf\xa0\x60\x62\x8e\xd7\x9b\x3e\x73\xd0\x8c\xf9\xad\xe6\xc6\x52\x7f\xb7\x40\x5a\x52\x59\x25\x89\x65\xd9\x86\xe5\x63\x1b\xff\xb9\x49\x42\x05\xdc\xd7\x1c\xf3\xf9\xf1\x27\xfc\xae\x3b\xf1\x4d\x05\xd7\x6b\x48\x9f\x0e\xe2\x89\x6a\x12\x08\xef\x99\x7c\x16\x70\x18\x09\x24\x1e\x9d\x03\xd6\xd6\x10\x66\x22\x2c\x9d\x6e\x9c\x7b\x7d\x66\xc2\x49\x34\x6d\x91\xcf\x81\x37\xf9\xdf\xb7\x30\xbe\x28\x92\x5f\xe2\xba\x05\x35\x98\x3f\xe6\x08\x17\x4a\x8b\x38\x1b\xe2\x79\x20\xb2\x52\x94\x18\x3f\xd1\x0b\x16\xb4\x28\xb3\x9f\x15\x56\xb1\x05\x7d\xb6\x85\x5c\x6a\xbc\x7e\x79\xe8\xff\x7d\x79\x70\xdf\x16\x38\xf1\xff\x62\x79\xa0\x6e\x0b\x3a\xd2\xb9\x3c\x81\x4b\x09\x6a\x10\x09\x74\x80\x07\x0c\x40\x5c\xde\xc9\x10\x29\xaa\x8b\x89\x31\x2b\x45\xce\xc7\x85\x6c\xe1\x7f\x27\x6b\x19\xe7\x1f\x82\x9a\x70\x7e\x57\x50\x8d\x65\x78\x2c\x22\x50\x76\xed\xa2\x3f\x26\x17\x6e\x85\x17\x0e\x91\xe3\xb6\x80\x06\xd4\x14\xa6\xe7\x79\x91\x7c\x84\xff\xd4\x63\xf6\x15\x6f\xfe\x2a\x35\x10\x45\x81\x88\x23\x65\x9d\xd9\x7d\xaf\xd9\xa7\x94\xb0\x63\xd1\x22\xb0\x10\x6c\x95\x97\xa0\x26\x79\x15\x8d\x6f\xba\x46\xae\x87\x71\xed\xcb\x4c\x12\xdc\x2a\xff\xfb\xf7\xfb\xe9\x3a\xbd\x8f\x7f\x1f\xd5\x88\x09\x54\x96\x48\x0a\xea\x09\x93\x83\x54\xe4\xc2\x5c\x0b\x80\x0a\xf7\x1d\x8d\x72\x40\x42\xa9\x90\xbf\x5e\xe1\x5d\x4e\xd8\x54\x1e\xbe\xc5\x81\x87\xe3\xfe\xc5\xf2\x13\x8b\x19\x7e\x3d\x8c\xf9\xc9\x38\xaa\xc3\xfe\xca\x37\x0c\xd5\x3c\xc6\xd9\x99\x0e\xdb\xae\xe8\xb0\xed\x8a\x0e\xdb\xae\xe8\xb0\xed\xca\x59\x91\x5d\x39\x2b\xa2\x70\xf9\x72\xf6\x7e\xe9\x52\x96\x6e\xc9\x12\xf6\xbc\x78\x31\x83\x37\xde\xc8\xde\x2f\x5a\xc4\x9e\x17\x2e\x64\x70\xc1\x02\x06\x9b\x9b\x59\x39\x4d\x4d\xec\x79\xfe\x7c\x06\xe7\xcd\x63\xf9\xe6\xce\x65\x70\xce\x1c\xf6\xfe\x86\x1b\x58\xfa\xd9\xb3\xd9\x73\x63\x23\xfb\x7d\xd6\x2c\xf6\x3c\x73\x26\x83\x33\x66\x30\x38\x7d\x3a\x4b\x3f\x6d\x1a\x83\x53\xa7\xb2\xf7\x53\xa6\xb0\x7c\x93\x27\x13\xc8\x11\xdd\x35\x85\x0d\x0d\xec\xfd\xc4\x89\x0c\x4e\x98\xc0\xe0\xf8\xf1\x2c\xdf\xb8\x71\xac\x9c\xb1\x63\x19\x0c\x85\x18\x1c\x33\x86\xc1\xfa\x7a\x96\xbe\xae\x8e\xa5\xaf\xad\x65\x70\xf4\x68\x06\x6b\x6a\x58\xba\x51\xa3\xd8\x73\x75\x35\x4b\x5f\x55\xc5\x9e\x47\x8e\x64\xb0\xb2\x92\xc1\x11\x23\x58\xfa\xe1\xc3\x19\x1c\x36\x8c\xbd\x1f\x3a\x94\xc1\x21\x43\x18\xac\xa8\x60\x70\xf0\x60\x96\x6e\xd0\x20\x06\x07\x0e\x64\x70\xc0\x00\x06\xfb\xf6\x65\xe9\xca\xcb\x59\xbd\x7d\xfa\xb0\xe7\xde\xbd\x19\xec\xd5\x8b\xc1\x9e\x3d\x59\xfa\x1e\x3d\x18\x2c\x2b\xa3\x30\xa8\x2e\x2d\xad\xb0\x07\x8b\x8a\xd8\x5b\xbf\x9f\xa5\x2e\x2c\x64\xcf\x05\x05\x0c\xe6\xe7\x33\x98\x97\xc7\x60\x4e\x0e\x83\xdd\xba\x31\x98\x99\xc9\x60\x46\x06\x83\xe9\xe9\x0c\xa6\xa4\x30\xe8\xf5\x32\xe8\xf1\x30\x98\x90\xc0\xa0\xdb\xcd\x5a\x1d\x1f\xcf\xea\x8d\x8b\x63\xef\x5d\x2e\x06\x9d\x4e\xf6\xde\x6c\x66\xcf\x26\x13\x83\x46\x23\x83\x06\x03\x85\x67\xb5\x5a\xdc\x89\xff\xfd\x83\x22\x46\x87\xdc\xf2\x3d\xe0\x99\x76\xa6\x13\x54\xf3\x92\x8a\x07\x2d\x58\x26\xe5\x4c\x1f\x13\x46\x92\x10\x03\xaa\x6f\xf2\x93\x40\x3c\x8e\x51\x0f\x2e\x98\x34\x69\x01\xce\x10\x77\xec\x18\xb5\x41\xc0\x5f\xcf\x47\xf2\x42\x95\x84\xf3\x42\xb1\x6b\x5e\x12\x71\xd2\x0f\xce\x93\x9c\x0f\x8e\x92\xef\x39\x76\x0c\xc4\x91\xbc\x55\x72\x1d\x68\x6c\xff\x03\xe7\x4d\x0a\xea\xa0\x88\xf0\x17\x49\x05\xf9\xf3\x98\x87\x8d\x7f\xbd\x2c\x86\x0a\x09\x76\xc9\x69\x4f\x2b\x06\x8d\xc7\x8e\xc9\xff\x14\x59\x31\x5d\xf3\xf3\x40\x80\x80\x34\x00\x9e\x17\xaf\xcd\x2f\x14\x07\x32\x70\x7e\xf9\x9f\xc7\x8e\x1d\x67\x5d\xc0\xb4\x2a\x49\xae\x07\x7f\x6a\x7f\x87\xca\x4c\x98\x12\x5a\x44\x1d\xe9\x46\x9c\x1d\xb5\x18\xd5\xd7\x68\xc7\x85\xff\x20\x05\x81\x3f\x2d\xad\xaa\x5a\xba\xa4\x7a\xd4\xe2\x49\x3d\x73\x73\x7b\xf5\xca\xcd\xed\x79\xb9\x7a\xde\xfc\xaa\xaa\x79\xf3\xaa\x72\x03\x81\xdc\xdc\xb2\x32\x42\xcb\xd6\x01\x13\xf8\x37\xec\x8f\x19\xf4\xfe\x1c\xd7\xd6\x40\x6d\x49\xde\x07\x46\xb8\x1f\xf6\x23\x3c\x32\xa9\x1f\x68\x24\x9e\xd7\x4b\x3a\x15\x6a\x11\xa9\x26\xfd\x62\x61\xd4\x78\x84\xde\x60\xf1\x5b\x25\x2f\xfd\x84\x7d\xe5\x1f\x84\x37\xee\x40\xf2\x18\xf9\x4b\xe1\x8d\x43\x08\x18\x81\x23\x51\xfe\xbb\x8d\x7d\x52\xda\x7c\x0c\x98\xe0\x5f\x48\x7d\xf0\x9e\xf6\xdb\x48\x7d\xf8\x5d\x2f\x79\x2e\x2c\xa3\xf4\xfa\xee\x76\xe9\xf7\x27\x29\x8d\xdd\x0b\x6e\x85\x79\x78\x0f\x97\xb8\x44\xae\x02\xdc\x4a\xe5\xee\xe9\xfc\x4a\x78\x95\xea\xc2\x12\x82\x5a\xb2\x3b\xe0\x79\x01\x02\x53\x4e\x14\x76\x38\xa2\x01\x5e\x3b\xde\xdb\xe0\x55\xf9\x9b\x75\x60\x8f\x50\xfd\x2e\xa8\xc2\x79\x67\xe2\xbc\x61\x9a\x37\x3e\xa8\xe1\x44\x04\xa1\x14\xd1\x8b\x15\x2a\xcc\x1f\xdb\x55\x8a\xbd\x60\x26\xd8\xb3\x4e\xfe\x46\xb8\x20\x3f\xfa\x2e\xb3\x05\xc2\xf3\x71\xb8\xfd\x01\x9c\xd7\x43\xee\xdb\xd0\xfd\x6c\x0d\xc0\x92\x12\x96\x11\x4d\x1f\xc7\x5f\x9c\x50\x18\xdd\xd7\x70\x09\x7e\xbb\x17\x1c\x96\x67\xaf\x03\x36\x9c\xad\xea\x5d\xa2\x8b\xc1\x5f\xee\x8e\xe4\x07\x3c\x47\xd4\x78\x6b\x04\xd2\x72\x82\x90\xf1\x17\x62\xf2\x5b\xbd\xc5\x78\x57\x53\x01\xdb\x3a\x79\xb6\xfc\xf6\xbb\xf2\xa3\x44\xf7\xf1\x14\xde\xcf\x8e\xe3\xfc\x44\xbf\x63\xc2\xd2\x0a\xde\x53\x55\xac\x01\x22\x52\x31\x94\x9e\x50\xc8\x2e\x17\x75\xb4\xa1\xd8\x0f\x8f\x87\x0d\x5b\xc0\xdf\xb7\x92\x66\xbc\xfa\x2a\x2e\xe7\x09\x79\x0c\x3c\x45\xdb\x81\x77\x40\x24\x41\x41\x84\xb4\x19\x20\xda\x0d\x5a\x46\x41\xbe\x84\xf3\xdb\xbd\x03\x77\xc2\xc6\xb0\x2a\xf4\xca\x66\xd2\x86\x57\x71\x5e\x0e\x73\xbb\x6a\x2e\x3f\xe8\x90\x20\xe4\x04\x2d\xaf\x51\x01\x20\x08\x1a\xa0\x5a\x83\x00\x3a\x2f\x91\x69\x98\xd0\x71\xf1\xbd\xc3\xd1\x9c\xd7\xe9\x43\xc5\x58\x06\xf0\x42\x4e\xae\x7b\xac\xe9\xbd\xf7\x9a\x1e\x03\xc7\x4e\xff\x04\xdc\x06\xe0\xfe\x89\x03\xe1\xdf\x44\x5d\xfb\x08\xc9\x87\xdb\xa5\x39\x89\x5a\xc8\x2a\xbb\x48\xd4\x88\x04\xa3\xe4\xef\xff\xcd\xff\x79\x13\x2f\xea\x14\xdd\xa6\xbc\x1c\x2f\x06\x70\x4d\x5a\x22\x61\x08\xf2\x72\xfe\xf4\xeb\x82\x7c\x49\xd4\x45\x54\x88\xed\xed\xf2\x69\xfe\x04\xa8\x14\xfe\x82\x71\x6b\x8b\x3c\x8b\xf1\x87\x6d\x39\x42\x5b\x7b\x96\xa4\x22\xf8\x76\xf5\xdf\x60\x18\xf5\x07\xf3\x0f\xfe\x1d\x90\x44\xf5\xcc\xaa\x13\x54\x2a\x50\x14\x9f\x62\xf8\x12\x16\xc1\x89\x02\x17\x84\x0f\x8a\x3e\x38\x59\xbc\x8f\xa6\x81\x64\x25\x90\x9a\xbd\x52\xf8\x60\x1c\x7f\x34\x4e\xf4\xad\x5b\x87\xc7\xe9\x37\xfe\x0c\x0c\x0a\x8f\x73\x06\x2e\xfd\x8c\x8e\x28\x5b\x98\x86\x25\x35\x93\x6a\x58\xce\xd8\x9c\x15\x42\x8b\x8a\xae\xa2\x0b\x58\x04\x2e\x64\x8a\x84\x80\x9f\x19\xbd\xf9\x0d\xe0\x72\xf3\x5a\x30\x0b\xd6\x0d\x1d\xd6\x14\xd7\x98\x79\x86\x3f\xb3\xa6\xd9\xd6\x7b\x70\x45\xaf\xe5\x37\xe1\xb2\xf7\xf0\xef\x72\x37\x60\xbe\x0c\x71\xea\x93\x1c\x09\x73\x88\xbb\x8e\x02\x7e\x69\xb6\xb7\xd5\xcb\xbf\x4b\x2e\xa6\x41\xf9\x03\xfe\x79\x90\x29\xac\xa0\x7c\x8e\xbe\x95\xe7\x04\x1a\x0e\xf1\x62\x21\xb3\xf1\x22\xa1\x00\x27\xa7\x1e\x49\x0d\xbf\x93\x7a\x6f\x2a\xff\xfc\x39\xfc\x0f\xf7\xeb\x29\xfe\x58\xfb\x18\x3c\xae\x16\xce\x74\xda\x88\x09\x5e\x8b\x9e\xae\xa8\x32\xe6\xaf\x37\xe2\xd5\x45\x24\xde\xbf\xfa\x40\xf9\xf8\x6d\x0d\x9a\xdc\xe9\x4b\x37\xcf\x9b\xa1\x6d\x8a\xf3\x94\x16\x0b\xb3\xcb\xc4\x19\xea\xe1\x7d\x07\xd4\xe8\x0a\x97\x22\xad\x87\xdd\x15\x2f\xe5\xbf\xe0\x5e\x11\xa7\x50\x1a\x66\x68\x35\xaa\x5b\xec\x88\x91\x2e\xe2\x15\xfe\xfa\x14\xeb\x95\x6b\x08\x96\x70\x6f\x57\x8a\x45\xca\x96\xd7\xe0\x39\x5d\xc7\x64\x78\xce\x78\x5a\xe4\x5a\x54\x44\x27\xee\x8f\x27\xbd\xa4\x4a\x74\xe0\xa7\x9f\xf2\x9a\xbf\xbe\x21\x9f\x09\x93\x8f\xae\xf2\xa6\xdc\x8a\xcb\x18\x41\xcf\x53\x70\x09\xa0\x45\xe2\xa3\x25\x58\xa3\x47\x18\xc5\x17\x4e\xf3\x33\x5f\x86\x6d\x8d\x31\x27\x18\x64\x2d\x3c\xc0\xb7\x70\x21\x7a\x86\xa1\x3d\x15\x39\xbf\x60\x7a\x75\x57\xf4\xe4\x82\x8c\x41\x19\x4e\xf7\x0a\x4d\x27\xe1\x5a\x04\xb2\x5c\xa3\xb5\x20\x9c\x9a\xe4\xa8\xc3\x39\xf6\x2b\xb9\xe4\x56\x92\x13\xca\x6d\xfc\x03\x60\xbf\xf0\xf4\x75\xfb\x87\xe8\xb2\xf0\xd3\x4f\x3d\x5d\x1b\xff\xa2\x9f\xfc\x03\x74\x85\x28\xfa\x76\x28\x7f\xc4\x9f\x02\xa9\xe2\x34\x8c\x87\x16\xce\x76\xd6\x68\x34\x6b\x79\x05\xef\x3e\x2a\x7c\xa9\x30\x8f\x78\x35\xc2\x02\x74\x07\xde\x59\x25\x5f\x20\x79\xf1\xcd\xb3\x60\x7d\x45\xff\x1b\x13\x1b\xbb\x3d\xd0\x2d\xa5\x35\x85\x3f\xb5\x61\xae\xb5\x7c\x60\x70\xc0\xda\xf5\xe0\x04\xf5\x61\x2c\x5f\xe2\xcf\x80\x54\x8a\xdf\x86\x56\x15\xd7\xa2\x13\xa2\xb3\x4a\xce\x18\x7d\xec\xa2\xb4\xaf\x0f\x28\x58\xd0\x02\x40\x23\xac\x1b\xd2\x7f\x71\xc2\xac\x8c\xd3\xc2\xe3\x14\x91\xfb\xf6\x5f\xb2\x83\xae\xc1\xf6\xa5\xe8\x1c\x77\x97\xb0\xd6\x24\x49\x9f\xc9\x27\xd8\xba\x6c\x5f\x88\xdf\xdd\x4e\xdf\x7d\x2e\x9f\x62\xb6\x84\xed\x7b\xd1\x41\x6e\x3b\xc6\x79\x1d\xc6\x66\xa9\x05\xe2\xb1\x2c\xc7\x4b\x07\x57\x17\x7b\xca\xbc\xbd\xdb\x18\xb1\x60\x79\x8a\xd9\x23\xac\xfd\xd0\x9b\xd2\x30\x6d\x44\xfd\x80\xea\xa3\xff\xb9\xcc\x71\x72\x23\xf7\x70\x7b\x0b\xa5\x21\xca\x39\x04\x2e\x90\x1e\x5b\x54\x92\x53\x8b\x46\x65\x14\x49\xda\x91\xf2\x6c\xee\x20\x3d\xb7\x88\x49\x8b\xe8\x71\xc5\x89\x4e\xc7\x15\x38\x6d\xb9\xdc\xc0\x1d\x6e\x3f\x8d\x67\xdb\xd0\x8a\x30\xc3\x21\x31\x5d\x37\x41\x0d\xa6\xdb\x3e\x3c\xff\xe7\x9f\xe7\xcb\x0d\x0b\x9b\x17\xd0\xf4\x13\x71\xfa\x67\x95\xf4\x02\x94\xa8\xb2\x9e\xa6\xc7\xf4\xd7\x6f\xf7\xd9\x7d\x34\xfd\xb0\x05\xcd\x0b\x99\xcf\xaa\xcd\xfc\x8b\x60\x99\xb8\x05\xb7\x45\x77\x0a\x31\xdd\x3e\x45\x79\x2a\xc9\x81\x65\x3b\xc3\x07\xe0\x8f\x38\x49\xd9\x4d\x78\xff\x34\x61\x89\xab\x90\xec\x9f\xd2\xe7\xed\x55\x1c\xa5\x71\xed\x47\xe4\x7a\x6e\x7d\xfb\xdb\xe4\xf0\xbe\x55\xcf\xb5\x48\x62\x74\xee\x62\x4f\xc3\x9d\x3d\xfa\x8f\x5e\x35\xd5\x54\x38\xa0\x9b\x0f\xef\x3b\xa1\x81\xd3\x17\xd7\x0e\x2e\x49\xcf\xe6\x59\x1f\x87\xe3\x32\x4e\xb5\x1f\xc5\x6d\x36\x9d\xc6\x22\x1a\xe6\xc8\xd8\xee\xab\xec\x5d\x44\x7f\x7f\x8a\x1e\x2b\xc8\xf5\x91\x73\x85\xf6\x11\x38\x4f\xab\x92\x07\x6f\x18\x88\x0e\xcc\x05\xca\xbd\x38\x95\x73\x84\x56\x7a\x8c\xf0\x02\x39\x45\x00\xed\xc3\x70\xfa\x93\xed\x4f\x12\xda\x11\x54\x93\x1d\x46\x14\xd1\x79\x35\x1d\x9c\x3c\xc5\xff\x50\xcc\x71\xc1\x49\x76\x5a\x20\xbf\xa3\x9c\x16\x00\xf9\x49\xf9\x3d\x30\xa8\x7d\x2a\xc6\x15\x3c\x67\x48\xe0\x4c\xaf\x17\x2a\xd4\x3c\x3b\x7c\x8b\x1b\xce\x97\xdf\xa3\x67\x04\xf2\x9b\xb8\x9e\x8f\xb8\x7d\x14\xb7\xd4\x5c\x0b\xef\x26\xc6\x0c\xc4\xdc\xb0\xc3\x9f\x6b\xc0\xfa\x51\x20\xe9\xc0\xcd\x43\xfb\x27\x17\xf5\x59\x96\x58\xb4\x4f\xfe\x7c\xef\x4e\xe7\x61\xe7\x6e\x60\x50\xfc\x49\x6f\xc3\xf9\x4d\x38\xbf\xc0\xb5\x68\x3a\xf2\x77\x36\x5d\xb6\x5e\x2e\x12\x67\x96\x17\x7b\x7a\x97\x2f\x59\x29\x96\xec\x93\xff\x9d\x90\x38\xc9\x72\xaf\x69\xd9\x2c\x6b\x4f\x60\xc7\xfb\x91\x45\x7e\xb5\xed\x4a\xfb\x8d\x16\x49\x6d\x09\x9b\x39\x46\xe3\xee\xc0\x6d\xfb\x67\xbb\x91\xd2\x0e\x43\xab\xc4\x89\x50\x4d\x76\xfa\x58\x42\xee\x61\x84\xfc\xbe\x54\xb9\x9e\x12\x72\x46\x77\x71\xbe\x57\x14\xde\xd1\xd0\x6a\x47\x46\x75\x1c\xc9\x47\x66\xd9\xf9\x7f\x4c\x77\xbb\x32\x8a\x78\x1d\xf5\x93\xcb\xb8\xaa\xf6\xbb\x4d\x92\xea\x77\xf9\x32\x5b\xaf\xf2\xcf\xb8\xae\x1d\xd4\x6b\xc1\x72\xf9\x11\x65\x0d\x27\xc9\xb5\x5c\x13\x79\x07\x0f\xc8\xef\x2b\xeb\xed\x06\x9c\xae\x08\xe3\x39\xe2\x4c\x67\xe7\x83\x35\x00\x2a\x8c\xd7\x04\x46\x06\x8d\x9b\x06\x6c\xc4\x23\x39\x91\xe1\x38\xfe\xb6\x8c\xf2\x3a\x96\xb3\x0a\x93\x25\x11\x34\xc5\xdc\x09\xc1\xf4\x62\xca\xdb\x81\x65\x5b\xe5\xe4\x2d\xf0\x47\xb9\xfe\xd5\x57\x01\xd5\xe5\xcb\x07\xe4\x5d\x60\x6a\xfb\x2a\x2e\x8e\x8b\x0b\x6a\x34\x98\x37\x34\xbb\x5a\x6c\x06\x92\x95\xa0\x78\x19\x45\x50\x33\xb3\x3b\xf7\xb3\xa8\x24\x51\x80\x47\xc5\x35\x62\xc0\xc4\xf1\x93\xbb\x77\x0f\xf4\x1d\xdf\x37\xd0\xbd\xfb\xe4\xf1\x13\x17\xc8\x57\xd2\x8b\xd7\xce\x19\xde\x7f\xe8\xc0\x81\x43\x07\x0c\x9b\xb3\x16\xf7\x77\xa7\x3c\x06\x64\xb5\x2f\xa7\x7a\x05\xe9\xf7\x07\x68\xbd\x33\xe4\x31\xb8\xdb\xcb\xf1\x3e\x62\x3a\x0d\x31\x47\xa7\xd2\x2a\x32\x46\xec\xb9\x3e\xd7\x1e\x73\xae\x2f\xcf\x89\x39\xd7\x97\xef\x96\x1b\x41\xa0\xfd\x6e\x8c\x83\xa6\xd3\x12\xd7\xa2\xe6\x0d\x34\x3f\x99\x2f\x14\x7b\x20\xd5\x23\xf6\x3c\x4a\x6e\x8c\x3d\x8f\x92\x9f\x96\x17\x02\xb1\x7d\x09\xa6\xc9\xa6\xd3\x5a\xc2\x5e\x98\xa2\x65\x38\x3b\x53\x65\x6b\x67\xaa\xbc\x35\x96\x28\x03\x79\x1d\xee\xdf\x9a\xf6\x69\x9c\x03\xef\x18\x78\x52\x5b\x2c\x82\xd6\x45\x4a\xa2\x7a\x7b\xc2\xa9\x5c\xab\x79\xdf\x70\x7d\xc5\xbb\x3c\xa6\xb3\xe2\x1d\xc8\x7f\x97\x9f\x04\x49\xed\x3d\xaf\xb3\x26\x85\xf0\xa5\x38\x98\x2a\x3f\xb9\x86\xb4\x21\x7c\x8f\xdc\x08\x27\xc9\x57\x18\x1f\x06\x19\x1f\x46\x78\xac\x7b\x08\x8f\x25\x37\x62\x1e\x0b\xca\xc7\x30\x8e\x8c\x69\xdf\x4f\xd7\x86\xe9\xac\x70\x1e\x05\xb5\xa6\x0a\x8c\x51\xd9\x64\x63\x10\x14\xed\x0d\xe8\x1b\xbe\xc5\x09\xe7\x97\xd3\xcf\xbf\x31\xe5\x0d\x9e\xc3\xf5\xdc\x8f\xa0\x05\xc8\x84\xf7\x93\x2b\xdb\xfa\xd2\x7e\xef\x06\x16\x30\x07\x1c\xba\x86\xf7\xab\x0e\xf7\x77\xc3\xa7\x80\x65\x27\x6e\xd7\x21\x90\x00\xa7\x80\xbd\x5d\xd3\xc0\x21\x57\xc7\xe0\x96\x81\x84\x55\xb8\x1c\xae\xfd\x73\xbc\x41\x7d\x16\x4d\x93\x47\xa4\xa3\x0c\x00\xb9\xb6\xa9\x53\xd1\x01\xb4\xae\x6d\xca\x64\x74\x37\x4e\x57\xdd\xfe\x11\x38\x2e\xfc\x33\x36\x9d\x00\xfc\xf8\x3d\x3c\x7f\x77\xb8\xbf\x4f\xd4\xfc\xfe\x2b\x5d\x37\x3b\xe5\x4a\xae\xa9\xfd\x55\x4a\xaf\x63\x8e\x89\xf1\xac\x16\x51\xcd\x2a\x3d\x75\x2e\x2c\x71\x64\xfb\x4c\xfd\xea\x96\xcf\x34\x15\x0e\xfc\x7b\x7a\x2e\xac\x85\x63\x2b\x26\x2f\x82\xb5\x03\xbb\xac\x27\x43\x2b\x4f\x39\x90\x3c\x85\x51\x52\xa4\x04\xb0\xac\x93\x94\x40\x68\xc8\x00\xbc\x5e\x9f\x6c\x7f\x23\x42\x7b\x22\xb9\xe8\x4e\xe1\x35\x7b\x51\xb1\xcf\xfe\xa4\xbc\x05\x2c\x6d\x78\x1c\x67\x5a\x2a\xff\xf3\xf1\xc7\x19\x1e\x1e\x96\x6f\x07\x13\xdb\xd7\x61\xca\x93\x88\xe5\x66\xb5\xda\xc8\xe9\x74\x66\xb1\xc5\x66\x64\xb9\x89\x06\x8f\x51\x6f\x4a\x7b\x7c\xf4\xea\x07\xc5\x26\xe6\x21\xdc\xd9\x66\x1e\x1a\xe8\x35\xbe\x57\x60\xa8\x79\x8a\x7e\x6c\x65\x53\x99\xa7\xb2\xa4\xb2\x41\x2f\xff\x6d\x28\x59\x83\x43\x2b\xc7\x8e\xf3\x67\x8e\xad\xc4\xe3\x92\xc6\x2f\xe0\xfe\x26\xa6\x61\x1a\xe7\x08\x6a\x54\x5a\x81\x68\xf2\x5b\xe8\xa4\xc4\x13\x5d\x3e\x61\x0e\x3a\xf4\xf7\x7f\xab\xdf\xb0\xbe\x6e\xfd\x86\xfa\x0d\x1b\xea\x36\xf0\x2f\xd7\x6e\xda\x58\xb3\x71\x63\xed\xc6\x0d\x35\x1b\x18\x6d\x9a\xca\xcf\xe1\x0e\x88\x5b\x71\x9b\x31\xef\x8b\x74\x5a\x72\xdc\x57\xc8\x78\x5f\x14\x28\x61\x9e\xd5\xfa\x80\x00\x75\xb6\xe6\x74\x24\x02\xfc\xe5\x80\x71\xbe\x3b\xa1\x60\xf2\x64\x63\x41\x1f\xb7\x1b\xea\xe7\xf0\x73\x46\x18\xea\x13\xcb\x4a\xd3\x73\xab\x0b\x54\xc3\x55\x39\x45\x09\x3d\x7b\xfa\x74\xfa\x01\x23\x08\x1d\x5f\x2c\xea\x50\xbd\x94\x4f\xc7\xd2\x72\x56\x54\x49\x80\xec\xf3\x94\xff\x9f\xa0\xc8\x0f\x69\xf8\x4f\x5e\x6c\xe3\x8f\xda\xae\xae\x22\x9f\xa2\x6e\xc6\x8c\xa7\x67\xcc\x60\x63\x7a\x27\xe6\xcd\xbf\x15\x9e\xeb\x2c\xef\x30\x26\xb0\x99\x31\x7e\xc7\xfe\x48\x92\xdb\x88\x8d\x45\xfb\x1f\xfc\x31\xb0\xf6\x9a\xb4\x54\x36\x12\xa9\x68\xf4\x77\xfe\x98\x0d\xf0\x89\x57\xc9\x3a\xc0\x2c\x6d\x8b\xf0\x14\x5b\x07\x0a\xed\x6e\xe2\x11\x77\x2b\xe3\x19\xb0\xe0\x49\x78\x06\xd4\xbe\x8f\x7f\x03\x4e\x15\x3e\xc3\x65\x12\xa3\x3f\xbc\x1f\x6b\x25\xcc\x2b\xb7\x68\x28\x4a\xe0\xf1\xce\x2b\xa3\x4b\x41\x42\xbe\x80\x15\x28\x1b\x13\x78\x17\xfe\x70\x23\x3c\x23\xdf\xe8\xbd\xdd\x0b\x56\x7a\xf7\x78\x85\xcf\x8c\xf2\x55\x1d\x50\xc9\xdf\x3c\xfc\xb0\xe2\x3f\xe3\x1c\xc6\xb1\xdb\x30\x5f\x65\xc4\x7b\xa7\xa1\x05\x12\x77\xe5\x7e\xca\xd7\x75\xba\x94\xe1\x97\xca\x53\x8d\xde\xb8\xee\x19\xc5\xa5\x6a\xe7\x7a\xbb\xfc\x75\xa2\xd8\xa4\xed\xe9\xf7\xe6\xce\xbb\x81\xf2\x43\x6f\x63\x7e\x28\x85\xf1\x5b\x52\x0b\x0f\xa2\xb8\xdd\x65\x9f\xe0\xdf\x56\xf6\x09\x18\x7e\x02\xa3\xec\x7b\xed\xab\xe9\x7c\x38\x4f\x19\x79\xc0\x63\xb1\xec\xb4\xde\x5c\xc1\x63\xe6\x12\x73\x25\xd9\xcd\x78\x31\xe2\x09\x21\x7f\xe1\x4f\x6d\xe8\x1f\xb6\xab\xbf\x93\xcf\x6f\x66\xcf\x7e\x6a\xf6\x6c\xb6\xc7\xfa\x08\xdf\x40\xf7\x33\xca\xb9\xc5\xae\xaa\x08\x5b\x5f\xbf\x69\xc0\xa6\x87\x37\xf6\xdf\x44\xf6\x35\xf9\x30\xdb\xdb\xda\x8b\x71\xbe\x3f\x53\xf9\x5b\x77\x0a\x73\x41\x94\x7f\xc3\x83\x27\x51\xad\xc3\x9f\xa9\xd2\x21\xa4\xe8\x1c\xe4\xbd\xfc\x8d\x60\x86\xf0\x3b\x17\x4f\x6c\x2e\xb5\x06\xb5\xc9\xe4\xe2\x1c\x10\x5a\xd4\x2d\xbc\x83\xcb\x7b\x21\xfe\xa3\x17\xa8\x7c\xad\x44\x81\x40\x6c\x29\x11\xff\x30\x18\xe5\x1d\x6c\xcb\x20\x8e\x57\x33\xaa\x33\x13\xa7\x5a\xc7\x69\xf3\xab\xcb\xfb\x8c\xec\x3d\xb9\x77\xb7\xb8\x69\xe6\xf1\xe6\x69\xb5\x3d\xab\x7b\x4f\x16\x5c\xd6\xe5\x33\x1a\x7b\xe7\xcf\x29\x99\x63\x5b\xbe\x7b\x69\xc1\xdc\x00\x87\xe4\x2d\xfc\x14\xb0\x51\x82\x9c\x8b\x4b\xe0\x3c\x5c\x56\xd0\x62\xb7\x08\x7a\x15\x97\x98\xa4\x8f\xc7\xf3\xaf\xe7\xe2\x92\xe2\x30\xc1\x62\x57\xe5\x98\x41\x09\x69\x45\x64\x73\x10\x3b\x76\x07\x22\x55\x40\x01\x63\x03\x91\x50\x77\x64\x0f\xeb\x5f\x9e\x1c\xe8\x65\x9d\x95\xbe\xb2\x3e\x67\x78\xff\xde\x49\x25\xbd\xcd\xb3\x3d\xe5\x21\xf9\xce\x94\x53\x29\xa3\xf0\x9f\x10\xf0\x64\x60\x6a\xb4\xb2\xc9\x9b\xe1\x0d\x14\x36\x84\x8a\xb0\x3c\x0b\x7e\x66\x32\xed\x7c\xfe\x59\x70\x50\x3c\x8d\xd7\x68\x3e\xb1\x03\xca\x4a\xcc\x4d\xf5\xb8\x5c\x82\xd9\xa6\xa3\x12\xcd\x45\xbc\x5a\x0b\xc9\x31\x1e\x65\xb5\xbb\xb6\x83\x34\x03\x5d\xb7\x71\x8b\x3a\x1a\xb5\xba\x2e\x67\x18\x6e\xd4\xe4\xd4\xd9\x49\x7d\xc7\xe9\x3a\xbf\x1f\xc0\x1a\x8b\x7f\xe0\x9f\xed\x68\x63\xe3\xb8\xf1\xc5\x40\x15\xdb\x66\xfc\x02\xcf\xdb\xf7\x78\xc6\xcd\xed\x8f\xe1\xd5\x62\x39\x23\x21\x5e\x2d\x02\x42\xb5\xf3\xfc\x74\x9a\x04\x09\x93\xce\x8c\x80\xdd\x5f\x0c\xcc\x7b\x7e\xdd\xb3\xe7\xd7\x5f\x4f\xb5\xb4\x9c\x3a\xbe\x78\x71\x44\xd6\xa8\xe7\x4e\x60\xde\x4d\xc4\x58\x85\xd9\x5e\x6a\x85\x45\x35\x28\x98\xe2\x06\x30\xa7\xdc\x73\xf1\x89\x13\x2b\xe5\xfa\xef\x76\xee\xfc\x0e\xa7\x77\x85\x1d\x78\x70\x2e\x53\x9d\x96\x9a\xde\x3d\x22\x7e\x34\x73\xb9\x62\xae\x37\x37\x10\xaf\xde\x6a\x2e\xc4\x4d\xe6\x1a\xb9\x66\x6e\x19\xb7\x96\xdb\xca\xdd\xc2\xed\xe5\x0e\x70\x87\xb8\x07\xb8\xdf\x5b\x0f\x56\xde\x7f\xe4\xfe\x73\xc0\x7e\x32\x54\x94\x8f\x41\x6b\xc8\x55\xda\xab\x14\x7f\x09\xaa\x43\x09\xbd\xc0\x10\xd3\xe8\x31\xa3\xf1\xd3\x99\x90\x6d\x8c\x67\x4e\xd3\x1c\xf6\x43\x6a\x93\x6e\x7f\xe6\xa2\xa5\x8b\xe8\x0f\x39\x4b\x83\x1b\xb6\x6c\x60\x3f\x0c\xd8\xa2\xdd\x37\x7e\xf7\x9d\xbb\xe9\x0f\x93\xee\x9c\xb6\x7d\xd7\x76\xfa\x75\xd6\xae\xaa\x7b\x5b\x56\x92\x34\xe9\xa1\xa2\x5e\x43\xc6\x34\xed\x5f\xba\x65\xdf\x9d\xbb\xee\x6d\x69\xb9\x77\xd7\x9d\xfb\xb6\x2c\xdd\xdf\x34\x66\x48\xaf\x22\xfd\xd0\x7b\x46\x1c\xb1\x48\x68\xf0\xd0\xc1\xb4\x25\x2a\x7e\x28\x11\x76\xfd\x8a\x3b\x05\x3f\x39\x91\xcd\x8b\xfd\x17\xe3\xab\x44\xf9\xfc\xef\x4f\xd4\xd6\x87\x9a\x19\x11\x61\x43\x20\xe2\x92\xcf\xec\x4f\xb3\x91\xa0\xee\xfe\xc2\x0c\x05\x5a\x15\xe8\x54\x20\x50\xa0\xd4\xe5\x99\x18\x2b\x61\xe2\x42\xc5\x1d\xf0\x5f\xd2\x76\x7d\x4e\xeb\x52\x57\xa4\xee\x34\xdc\x1e\x62\xc5\x24\x90\x6d\xd9\x0f\x2f\xcf\xfd\x14\x8c\x08\x3f\x25\x9f\x04\x95\xb0\xff\xdc\xb9\xf2\x2d\x45\xa5\xa5\x45\xb7\x17\x95\x95\x15\xfd\x1e\x28\x29\x2d\x4e\x25\x8f\x72\x51\x49\x20\x50\xf2\xa7\xd2\xe2\xe2\x52\x58\x17\x28\x29\x09\xb4\x6d\xf8\x74\x2e\x18\xc1\x6f\x96\x4f\x7d\x3a\xb7\x4d\x5d\x82\xff\xc1\x9b\xc8\xe7\x9e\xe2\xd2\xd2\xe2\xf0\x83\xc5\xa5\x25\x01\x1f\x79\x06\xaf\x91\x8c\x72\x88\xe4\xf9\x9d\x64\xdf\x43\xde\xca\xbb\xe6\xce\x45\xa9\xa4\xc6\xf0\x93\xf2\xa9\xb9\x9f\xf2\xeb\x2f\xcd\x9d\x3b\xb7\x6d\x21\xa8\xbc\x0d\xa7\xcb\xc1\x7f\xf2\x5b\xb8\x9c\x2f\xf0\x17\xb0\x07\x7f\x19\x8b\xbf\x84\x17\x90\xca\xaf\x5e\x02\x43\xfe\x28\x9a\x7b\x09\xbe\x5f\xe2\xef\x11\xee\x53\x5c\x1c\xb8\xab\xa8\xa8\x0c\x7a\x94\xd4\xe1\xf6\x40\xa0\xf8\x4b\x9c\x50\x7e\xbb\xb4\xa8\xac\x1b\xfe\x19\x97\xd9\xb6\x70\xee\x5c\x30\xe4\x12\xd5\xaf\xf6\xe4\x57\x81\xd1\xa2\x17\xe3\xbd\xee\x14\x2f\x9e\x87\x54\x4d\x4e\xce\xfa\x99\x76\x7c\x34\xd1\x8e\x0b\x4b\x15\xf5\x38\x4e\x3f\x90\x5f\xca\xc9\xd4\xce\x1b\x73\x27\x1d\xe6\xdd\x11\xa3\x1c\xbf\x9d\x49\x36\x72\xed\xb4\x69\xb5\xdd\x02\x81\x6e\xfc\xd2\x59\x75\xf5\x33\x6a\x03\x05\x05\xec\xae\xe4\x5d\xfc\xbb\xe0\xef\xe2\x26\x9c\xdf\x8c\x77\x34\x8d\x39\x68\x44\xc4\x1e\x51\x8b\x98\x92\x85\x69\x73\x0a\x1d\xf6\x0e\xbe\x99\xd0\xb0\x2f\x17\x6f\x6c\x84\xf5\x15\x43\x16\xc4\x35\x66\x3e\x9a\x87\x49\x96\xb8\x69\xcb\xca\xf2\x81\x83\x7b\xaf\xd8\x2a\x8f\xc4\x84\x0a\xc8\x2f\xca\x23\xb8\xe5\xb8\x06\x2c\x02\x9c\x56\x41\x80\xd4\x44\xfc\x60\xbc\x44\x2c\x47\xb2\x3c\x86\x23\x91\x0f\x77\xe2\x48\x80\x7c\x55\xae\xe3\x6c\xf4\xec\xc0\x70\x1a\xe6\xe3\xed\x09\x77\xee\xf5\x09\xb8\x04\x27\x3b\x6b\xb0\xc5\x1e\x35\x74\x49\xcf\xe7\x43\x00\xc5\x68\x7a\x3a\x7a\xb6\xd8\xa3\x05\x4c\x4b\x4b\x70\xfa\xab\x34\x3d\xa6\xe5\x41\xad\x5a\xa3\xd2\xeb\x63\xf2\xf9\xf3\x30\x19\xc5\x5b\x92\x32\xf4\xec\x84\xe4\x04\x29\x03\xbe\xc8\x2a\x55\xca\x92\xef\x63\xa7\x25\x5d\xe7\x43\x94\x5a\x30\xc4\xbb\x21\x9d\x0f\xe6\x5a\xa1\x98\x19\xef\x0f\x24\x73\x31\x7a\xfa\xf4\xd1\xfc\xc5\xd2\x82\x82\x40\xed\x8c\xfa\x7a\x1a\x57\x94\xfb\x85\x7f\x00\x9c\x12\xa6\xe3\x71\xc3\xfc\xb0\x9a\xf2\xd6\x56\xc5\x63\x1b\x61\x04\x7e\x29\xcd\xc8\x28\x2d\x4b\xcf\x28\x15\x44\x06\x4b\x31\xad\xec\x8b\xfb\xf1\x74\xfb\xf3\x58\xe6\xc1\x24\x48\x0b\x44\x1d\x40\xc2\x79\x03\xd9\xc1\x99\xa1\x08\x19\x68\x67\x64\xd0\x33\xfc\x9e\x8d\x71\x37\x4f\xe8\x3f\xac\xb2\xdf\xc4\xed\x71\x9b\xd4\x35\xaf\xf9\x87\xa5\x2d\xcf\x5a\xb3\x3a\x6b\x59\xda\xf0\xe2\x9b\x31\x9f\x23\x3f\x83\xe9\xf6\xc0\xf6\xa7\x38\x2b\x97\xcc\x65\x73\xde\xa0\xc1\x97\x98\xa8\xcf\x72\x3a\x8d\x82\x84\xce\x9b\xf5\x6c\x7f\x27\xfb\xad\x3f\xe6\xd8\x25\x23\x2a\x50\x3b\x49\x73\x85\x48\xb8\x4b\x8c\x35\x42\xec\x51\xcc\xc0\xc6\xca\x90\xdf\x1f\x1a\x39\xab\xb1\x72\x6c\x61\xe1\xd8\x91\xb3\xc2\xaf\xf4\xce\xc9\xe9\xd9\x33\x27\xa7\x37\xb8\x1c\xf9\xf6\x6b\xe5\xf4\x21\x43\xa6\x57\x56\x4e\xaf\xa8\x98\x5e\xe9\x2f\xc1\xaf\x7b\x97\xf8\x15\xc8\xf6\x87\x52\x7e\x26\xf7\x8a\x58\x44\xf5\x28\xbc\x24\xb1\x95\x72\x81\x32\x60\x24\x24\xbf\x17\x33\x7a\xaf\x34\x34\x07\xdb\x39\xfc\x21\xac\x95\xbf\x3c\x05\xe2\x4f\x91\x7c\x43\xe4\x7a\x61\x45\xfb\x6b\x9c\x86\xac\x17\xd8\xc2\x33\xf6\x13\xcf\x8f\xc0\x79\x3d\xc8\xef\xf0\x16\xa6\x06\x84\x15\xf2\xc5\xf0\x5b\xe1\x37\x0f\x6e\x5c\x0b\xfe\xfe\x0d\x98\xba\xa4\x44\xde\x01\x16\xfe\xb6\x98\xe8\xb4\x97\xf2\xcf\x08\xc7\xc4\x42\x9a\x1f\xf3\x7e\x12\x8c\x48\x03\x20\x26\xff\xb1\x2e\xf9\xc5\xc2\x48\x01\x94\x9f\x59\x28\x24\xc2\xa7\x84\xfd\x51\x99\xe7\xa2\x62\xb4\xf9\xd4\xd5\x33\xfc\x50\x21\x91\xd8\x15\x87\x57\xca\xef\x81\x97\xda\x6b\x3b\x64\xc4\x8f\x95\x54\xe0\x25\x92\x4a\x7e\x6f\x0d\x1b\x87\x1a\xfe\x79\x61\xa3\xd0\x8e\x77\x3c\xcb\x19\xbb\x64\x68\xb1\x6a\x14\x66\x94\x48\xa9\x80\x30\x3e\x69\xa9\xd1\xed\xde\xe1\xe4\x31\x13\x20\x6c\xcc\x6d\xdd\xb4\x57\xfe\x5a\xfe\xea\xe6\x89\x8b\x92\x36\xe6\x3e\xb7\x22\x74\xf1\x16\x60\x3c\x76\x57\x99\xd0\x7e\xf0\x8e\xba\xda\xd1\xe3\x77\x1f\xc9\xcc\xad\x7b\x34\x5a\xfe\x26\xb1\x04\xe3\x23\xee\xaf\xa6\x45\x02\xd1\xfe\xfa\xd2\x71\xc1\xbc\xe4\xb3\x78\x3d\xc2\xa6\x8d\x13\xe5\xd3\xdf\x7c\x23\x9f\x99\xb8\xf1\x32\xcc\x87\x79\xfc\xf3\xeb\x16\x2f\x5e\x07\x16\x2a\x6d\x94\xeb\xd1\x1b\x98\x0f\x10\x99\x2e\x50\x04\x8c\x6b\xa2\x3c\x00\xee\x51\x31\x7a\x63\x4f\x5b\x3c\xfa\x12\x33\x00\x73\x16\x13\xde\xbb\x04\x7c\x04\x39\xfe\x67\x93\x24\x4c\x95\xc3\x0a\x3f\x5e\x09\x2e\x41\x9e\xff\x09\xbf\x6b\x94\x2f\x31\xbd\x10\x97\x08\xbe\x06\xe3\x44\x8e\xf2\x9e\xf1\x41\x93\x70\x85\xff\xea\x9a\xcb\xdd\xe5\xca\x85\x6e\xab\x1f\xbd\xe6\x5c\xee\x94\xff\xba\x73\xf9\x4e\x61\xf3\xb2\x65\x6d\x53\xe0\xd5\xb0\xc0\xca\x1e\x48\xcb\xfe\x11\x97\xbd\x40\x7e\x4f\xa9\x6f\x02\x6e\x43\x32\xff\x05\x7e\xb7\xb4\x1d\x2a\xba\x9b\xb1\xe0\x12\x78\x8f\xff\x19\xf3\x83\x98\x5a\x58\x75\x26\x93\xee\x1b\x72\xf8\xf3\x35\x0d\x00\x40\xaf\x9d\x90\x65\xce\x0c\xb2\x88\xa4\x14\xf5\xb1\x42\x04\xa6\x39\xdb\xca\x66\x8f\xfa\x64\xfd\xf6\xb1\xf7\xad\x6a\xda\xac\x5e\x26\xf4\xef\x5f\xd7\xd8\x13\xf6\x3d\xec\xfb\x7c\xff\xd6\xb5\xbf\xac\x5a\x7c\x83\xb9\x7c\xe4\xc4\xd7\x6e\x78\x12\xd7\x5d\x0f\x3e\x84\xb3\xc8\x1d\x7c\x61\x96\xfc\x96\x52\x77\x1f\x70\x19\x7c\x8b\xfb\xea\x22\x72\x9e\xe3\x32\x87\x6c\x9a\xaf\x8c\xe4\xb2\x3d\x35\xa5\x2a\xff\x4f\x37\xeb\xfd\x48\xca\xee\x7a\x9f\xfe\x85\xe5\x7e\xcf\x75\x6e\xd1\xf3\x0e\xf9\x87\x9b\xa9\x5e\x80\xdc\x5e\x7e\x94\x8e\x47\x93\xdc\xa8\xd4\x7f\x1f\xae\x7f\x3b\xff\x23\xde\x25\x70\xfd\x5a\xc9\x0c\x8d\xdf\xa8\xaf\x48\x5f\x51\xdf\x22\xfe\x48\xf4\x0f\x5a\x65\x20\x12\x6a\x03\x2c\x4e\x8d\x1b\xb2\xc8\xa2\xdc\x5b\xef\x3e\xba\x67\x4a\x12\xbf\x46\x7d\xb0\x59\x5e\x08\x87\x9c\xd8\x37\x71\x98\x9a\x9c\x6d\xa6\xe3\x31\xbd\x57\xd8\x69\x12\x85\x25\xf7\x93\x71\xdf\x8b\xeb\x1e\x4b\xc7\x7d\x45\x3b\xa7\xd4\x6d\xc5\xef\xb2\xf9\xcf\x31\x0e\x5a\xce\x02\x49\x25\x5e\x41\xc4\x76\xab\xb0\xdc\x4f\x4f\x65\x10\xf0\x01\x44\x9d\x67\x58\x41\xb7\x9b\x65\x79\x33\xa8\x3c\xd5\xb2\xfe\xbb\xed\xf2\x73\xcf\xe0\x36\x97\xc9\x2f\x83\x2d\x60\x81\xfc\x01\xc8\x94\x77\xca\xd4\x57\x37\xf7\x3b\xff\x10\x2c\xa1\xbc\xa2\xf5\x0c\xc6\x1d\x51\x91\x0f\x63\xed\xef\xd1\xef\xf3\xde\xf8\x84\x7f\xc8\x06\xf4\x89\x72\x1b\xc9\x73\x23\xa6\x89\x27\xdb\x97\x2a\x79\x70\x47\x3b\xe5\x11\xec\xc8\x57\x6c\x05\x27\x71\xa6\x2d\x36\xf9\xa7\x44\xb2\x55\x01\x6e\x0c\xce\xe3\xa7\x72\x5d\x52\x50\x67\xe0\x38\x8d\x86\x37\x99\xa1\xd4\x62\x60\x16\xe4\x1d\xe7\xd6\x5d\x05\xbd\x4f\xfe\xa3\xa0\x47\xcf\x83\x5d\xc4\xbf\x2c\x5f\x69\x11\xa1\x23\x12\xd7\x89\xc4\xe5\xb7\xa4\x73\x83\xa8\xb6\x71\x1f\x37\xbb\xad\xb5\x23\x9d\x29\x03\xbf\x89\x6b\x6b\x35\x45\xd2\xa7\xcb\x7f\x80\x9f\xf9\x1e\x26\x91\x63\xf6\x71\x5f\xf3\xcf\xc1\x5e\xa2\x14\xbd\x8f\x00\x3b\x8f\x07\x35\x59\xfc\x5a\x5c\xfd\x86\x24\xb7\xf3\xcf\x79\x41\x6a\x9a\xfc\x29\x95\x87\xdb\xf8\x47\xe1\x36\xb1\xaf\xc2\x73\x17\x06\x1d\x3c\xd0\xe8\x81\xde\xa8\x16\x45\x03\x16\x8d\x21\x16\x8d\x89\x8f\x4a\x4c\x61\xf1\x7f\xf1\xa6\x8b\x1d\xd7\xc2\xca\x62\x6c\x22\x51\x9a\x22\x2a\xbf\x2d\x6d\x7f\x42\x6a\x93\x3f\xf1\xee\x49\x01\xfd\x52\xf6\xa4\xf0\x8f\x7a\x41\x53\x9a\xbc\x3b\x99\x0a\xca\x18\x37\xf6\x71\x1c\xff\x95\xb0\x0e\xf7\x33\x95\xe3\xcc\x12\x2a\x6b\x7f\xa0\x7d\x05\x67\x3b\x05\x4d\x08\x9e\x93\x7f\x6b\x35\x9b\x05\x21\x0d\x64\x17\x73\xe5\xc5\xb4\x5f\xf7\x81\xa7\xc1\x6d\xf0\x2e\x4c\x1f\x72\x83\x09\xf4\xb2\x03\x07\xf6\x85\xf2\xf0\x2f\x41\x77\x76\x05\x17\x74\xc4\xe1\x0f\x83\xad\x82\x1a\xc0\x67\x33\xc7\x9d\x11\x0f\x10\xf7\x65\x3f\x9f\x0d\x9e\xbe\x74\x89\x8c\xd7\x70\x8e\x13\xa7\x08\xeb\x4c\x19\x5c\x26\xf7\xbb\x52\xf3\x54\x5a\x33\x30\x20\x70\xae\xbd\xae\xd5\x68\x04\x40\xa9\x19\xa7\x1f\x82\xd3\xbf\x4c\xd3\x67\x73\xb2\x92\x7e\x52\x4c\xfa\x11\x38\x7d\xb4\xa5\x2c\x3d\x12\x68\xfa\x1c\xee\xb3\xce\xe9\x45\x56\xbe\x24\xc5\x94\xdf\xfe\xef\xf6\x6f\x44\xaf\xb0\xc7\x94\xce\x15\x7a\x59\x6a\x03\x1b\x87\x24\x3c\x0e\xed\x33\x5b\x13\x12\x34\x9a\xe8\x38\xe0\xf2\x5f\xe2\x38\x69\x26\x2d\xbf\x17\xd8\xa3\x94\xff\x11\x2b\x5f\x4b\xca\xff\x53\xab\x4e\x87\x50\x47\xf9\x78\xe1\x09\xdf\x92\xf2\xd1\xb8\x44\x96\xda\xc1\x52\x67\x91\xd4\xfd\x5a\x33\x32\x7c\xbe\xd8\xf2\xbb\x63\x62\xfc\x94\xd8\xd7\x92\x8e\x30\x82\x9a\x45\xd4\xa3\x90\xe3\xdc\xc4\x0b\x3e\xd0\x99\xd3\xf1\xe7\x06\x8b\x4b\x50\x93\x0c\xc5\xc5\x1c\xfd\x88\xce\x25\xf1\x39\x90\x4a\xcb\x28\xc7\x75\x9a\xe8\x73\x1a\x9d\xbb\x72\x0e\xf0\x7f\x15\xd6\x61\xdc\xf2\x06\x4d\x88\xe7\x31\x1a\x49\x02\x6c\x08\x09\x88\x47\x16\x16\xa3\xa6\xc3\xc8\x41\xf2\x22\x1f\x4e\x9e\x14\x0e\xfc\xfc\x0c\xb0\x08\xeb\xf6\x5f\x75\x0b\x6b\x99\x7e\xe2\x03\x5c\xcf\x9b\xd4\x7e\xcf\xc0\x95\x04\xe3\x01\xa7\x11\x91\x06\x99\x0c\x3c\x6f\x14\x05\x68\xe0\x0d\x0d\x21\xde\xa2\x01\xf4\x2c\xad\x90\x79\x87\xea\xec\x8c\x82\x06\x98\xc1\xf8\x99\x86\xba\x83\x62\x12\x57\x16\x7e\xff\x57\xa0\x4a\xb8\x9a\x9a\xc8\x27\x3e\x64\xb4\x19\xcb\x7a\xca\xa2\xb0\xf6\xaa\x6e\xc7\x0e\x23\x9a\x38\x7c\x8f\xdd\xb3\x78\x6a\xdb\xbd\x5c\xb4\x4f\x8d\xb4\x4f\x99\x74\x4f\xc1\x6d\x11\x12\xe8\x73\xef\xe8\xef\xaf\xd2\x67\x62\xe4\x83\xb8\xe9\xed\xdf\x08\xbf\x0a\x7b\xa8\xdf\x92\x64\xae\x26\x98\x8f\x80\x23\xd1\x61\x48\x94\x0c\x92\xc7\xcb\xa1\x86\x90\x91\x1b\xc9\x91\x48\xac\xdc\x71\xee\x13\x8e\xb7\x62\x94\x8e\xe3\xb5\x71\x0d\x21\xad\x95\xb7\x34\x10\xef\xcd\x5d\x7c\x03\x37\x67\x77\x09\x1f\x47\xdc\x39\x02\x0f\x67\xd6\x00\xde\x87\x41\x91\x25\xd5\x19\x09\x63\x96\x4a\x82\x60\xc3\x44\x38\x2c\x39\x7c\x1a\x1c\x06\x76\xd0\x57\x78\x4f\xde\xfe\x8d\xfc\xb9\xfc\xd2\x5f\xc0\xf2\x2f\x5e\x91\xbf\xde\xfd\xee\x9f\x5f\x04\xf6\xbd\x7f\x45\xf1\x07\x51\x82\xfc\x92\xfc\x6f\xf9\x67\x79\xd9\x3b\xa0\x27\x70\x7c\x0f\x6e\xf9\xeb\x5d\x27\xe5\xbb\x4f\xbf\xf5\xe1\x23\x60\xec\xb3\x6f\x7c\xcc\xfa\x5f\x8d\x27\x20\x85\xf6\x2f\x27\xda\xdf\x43\xf4\xb9\x3b\xa5\xeb\x87\xf1\x1c\x7f\x81\xe7\x58\x43\xee\x93\x6a\x88\x75\x24\xcf\xa9\x74\x2a\xad\x86\x57\x23\x49\xa5\x02\x9c\x85\x4c\x4a\x1e\x0d\x83\x07\x62\x6f\xd6\xa5\xf9\x50\x7a\x06\x89\x3e\x04\xfc\xfc\x17\xcf\x3f\x6f\x35\xf5\xeb\x1f\x7e\xec\x75\x54\xf5\x12\x40\x9f\x4e\xbe\x73\x4b\x73\x9b\x47\x58\xcb\xea\x13\x8f\xd1\xfa\xf2\xa3\xf5\xbf\x42\x9f\x0b\x28\xfd\xfa\x11\x3f\x37\x50\x1b\x02\x09\xef\x2d\x55\xc1\x02\xa4\x51\x11\x1b\x51\xa0\x17\x75\x5a\x0d\x1e\x6e\xed\x48\xed\x1a\x2d\x32\x6a\xcb\xb5\xc7\xb5\x9f\x68\xf1\x80\x6b\xb5\x3a\x4c\xfb\x1b\x42\xa2\x85\x4c\x07\x41\x9a\x6b\x06\x1c\x44\xbd\x69\xd2\xc1\xc6\x98\x43\xff\xd2\xf9\xb2\xa4\xab\x2f\xa3\xcd\xc9\x57\xd7\x25\xf3\x93\x92\xda\xce\x26\x09\x6b\xf7\x5f\x3d\xbb\x7f\x3f\xdc\x78\xd7\x5d\x31\xbe\xaf\x45\xe2\xfb\x9a\xe2\x3f\x27\xbc\x4e\xed\x58\xd3\x82\x16\x8c\xff\x2a\x20\x8a\x6a\x65\x01\xf0\x74\x60\xf2\xca\x63\x2f\x80\x78\x89\x2f\x26\xe0\x05\x28\xfc\x53\x18\xfc\x84\x57\x01\xbf\x4a\xfe\x8e\xff\xf4\x2a\x1e\x89\x3f\xd6\x28\x7d\x1f\x42\xfb\xee\xa7\x63\xff\x07\x7e\x46\xf4\x2c\x79\x70\x30\x55\x42\x50\xa5\x55\x21\x12\x24\xd7\xc0\x69\xf4\x48\xe2\x71\x1f\xd5\x2a\xcc\xdc\xf0\x08\x68\x38\x3c\x14\xa4\xc6\x88\x23\x23\xb3\x3f\xe2\x1d\xb5\xc3\xed\x1c\x6e\x81\x2f\xa0\x26\x1a\x5c\xdc\x65\x12\xcb\xc0\x0b\xb7\xc9\xa1\x44\xf4\xcf\xa4\xb6\xcb\xa0\xc5\x15\x3e\x85\xa6\x26\x3f\x04\x07\x82\xdf\xef\xdc\x2f\x07\x16\x86\x7f\xda\x4f\xe6\xe3\x1c\x6e\xc3\x78\xda\xa6\x00\x9d\x9f\x77\xf1\xf3\x5b\xf4\xb9\x17\x5d\x0f\xab\xdb\x7f\x11\xa7\x0a\xdb\x68\x5c\x83\x4c\xae\x39\xd8\xc3\xea\x70\x66\x26\x7b\x34\x92\xe4\xc9\x74\xf0\x76\xb5\x5a\xa5\xb2\xd9\xed\xa9\x6e\xb7\x21\x15\x19\x50\xb7\x2c\xab\x23\xd3\x31\x29\x44\x92\x48\x9e\x49\x21\x8d\x94\x89\xff\x53\xd9\x6d\x56\xb5\x0a\x45\x4c\xce\x99\x53\xab\xa8\x4a\x24\x66\x75\x98\x63\x7b\xa3\x38\x67\x4a\x49\x2d\x36\x71\x5e\xea\x3d\xaf\x90\xc7\x02\x18\x9f\x0d\x24\x5f\x39\x50\x9c\x82\x23\xc5\xc9\x36\x6c\xb9\x22\x7f\x0d\x06\x03\xf3\x21\xdf\x59\x6f\xc1\x65\xe0\xba\x5d\xfe\xfe\xd4\xc1\xee\x67\x73\xde\x59\xf9\xea\xfb\x8f\xde\x39\xf0\xb1\x95\xaf\xbe\xf7\xe8\x9e\x41\x1f\xc8\x1f\x70\xed\x20\xf3\xcc\x99\xb6\xbf\x3e\xd0\xb6\xf1\xb3\xcf\x6e\x7e\xfd\xf9\x83\xc7\x5f\x7f\xf6\xe0\x09\x4a\x1b\xfe\x8a\xfb\xbe\x87\xf6\xbd\x27\x9d\xff\x37\x31\xee\x3e\x87\xe7\xc7\xc3\x0d\x0d\xa6\x5a\x3d\x1e\x13\x5e\xeb\x9a\x38\xdc\xf5\x78\x6f\x7c\x4a\x32\x30\x81\x49\x21\xab\xc9\xa4\x8a\x8b\x53\x99\xcd\x2a\xe4\xa1\x18\x41\x59\x50\xe6\xc4\x34\xea\xe2\x9e\x05\xc7\x8d\xf8\xaf\xb5\x76\x04\x51\xa6\x4d\xc7\x5f\x9c\x91\x28\x72\xbc\xd7\x87\xe0\x8e\x1a\xff\x17\xbf\x69\xc7\x3e\x33\xd6\x74\xe0\x40\xe9\x91\xc7\x8e\xcc\xb8\xf1\xee\x86\x84\xb1\xcf\x4c\xc9\x97\xdf\x91\xe5\xc6\x1a\xf0\xd0\x85\xe7\x07\x17\x80\x37\xe4\xdc\x49\x9e\xa5\xab\xd1\x90\xb6\xb3\x70\xd8\xde\xdd\xe0\x2f\xb2\xf0\xcb\x97\x72\x2d\x69\x77\x32\xee\xc7\x9b\x98\x86\xa5\x73\xc3\x82\x59\x9e\x78\xbd\xc4\x9b\x9c\x4e\x9f\x89\xe7\xb5\xbe\x04\x3e\x23\x53\x1f\x1f\x9f\x94\x98\x90\xd8\x10\x4a\xb0\xe8\xd4\x0d\x21\x9d\x85\xb3\x36\x44\x03\xfd\x44\xfd\xf3\x99\x63\xc2\x8e\xb1\xa5\x44\x02\x2c\x9a\x38\x81\xc4\x75\xf1\x06\x94\x78\xfd\xd4\xfd\xa7\x93\xb0\x0e\x85\xce\x74\x48\x63\x2e\x2e\x3b\x0d\x4c\xb7\xca\x1f\xca\x97\xef\x2b\x94\x93\xc2\xa7\xb2\xff\xf5\xdb\x87\x2f\xdd\xf9\xf3\xe6\xb5\x3b\x73\xc3\x1f\x25\xfd\xb9\xf8\xec\xe1\x93\x8f\x83\x91\xc2\x9e\x4d\x57\x1f\x94\x7f\x90\x77\x8c\xd1\xee\xff\x74\x04\xe8\xff\xcf\x97\x3e\xd9\x2e\x87\x1f\x3d\xf2\xcf\x9a\x4f\xf7\x6b\xc7\x82\xdc\xc7\x5e\x07\x03\x4f\x2a\xf4\x0b\x59\xc4\x93\x98\xdf\xc8\x21\xfb\x9a\x1a\xfc\x99\xe3\x9c\x41\x3d\x04\xbc\x90\x0e\xc1\xa3\x2a\x91\x83\x74\x57\x23\x9b\x5a\x14\x7f\x69\xfa\x5e\x64\x97\x55\x03\x10\xe4\x94\x1c\x6a\x92\x43\xa7\xd7\x22\xa9\x23\x07\xc5\xf9\x41\xed\x57\xf8\xf3\xa2\x84\xf7\xce\xa9\x6c\x67\x06\xd3\xf0\x0f\xd6\xa0\x16\x76\x33\xa7\xc3\x85\xdd\x72\x5d\x2a\xba\xd5\x66\x2b\xe9\x53\x30\x4f\xb7\x9f\xa6\x9f\xa9\xa4\xb7\xb0\xf4\x20\xd3\x9c\x0e\x5e\xcc\xcc\xd6\x38\x3b\xa7\x27\xb1\x5e\x69\xfa\x46\x25\xfd\x1d\xf8\x07\x7b\x2b\x48\xc6\xc9\xcf\x01\x7d\x6b\x72\x8a\xc6\x1d\xc9\xc1\xe8\x04\x6c\xa2\xe9\xd9\x5e\x5e\x56\xc4\x4a\xc7\x3b\x39\x78\x57\x67\x64\xfb\xb8\x92\x96\xc6\xc0\xa1\xfb\xfe\x12\x5a\x76\x0f\x40\x0e\x05\xd8\xce\xef\xa2\x3b\xff\xbc\xa4\x54\x9b\x3e\x76\xe7\xa7\x72\x1b\xed\x33\x3f\x82\x4b\xe0\xb2\xb8\x7e\x41\x9f\x41\x8f\xd3\x22\xc9\xeb\x75\xe9\x5d\xdd\x30\xdd\xcf\xb6\xfb\xaa\x42\x66\xbb\xc3\x40\xa2\x3f\x92\xe8\x19\x34\x28\x01\x0d\xe0\x5a\xee\xcf\x8e\xd9\x9c\x23\x21\xac\x88\x6f\x58\x8c\xc4\x7e\x11\x4a\x26\xa7\x2f\xbd\x37\x88\xfa\x8d\xed\x03\x9c\x14\x4d\x68\x94\x4e\xbc\xbd\xd5\xac\x3b\x6a\x87\xba\xbe\xbe\x27\x4b\xef\x4b\x49\x38\x61\xe1\x43\xa7\x17\xdc\x73\xa2\x62\xe3\x33\x9b\x17\xdd\x52\xfd\xc4\xbc\x0b\x41\xb8\x88\x1f\xd1\xb2\x30\x6d\x7d\x69\x8d\xbc\x63\x81\xfc\xf8\x93\x63\x6f\x33\xdd\xb1\xe2\xf5\xa7\xd7\x81\x6e\xaf\x4e\xde\x70\x40\x7e\x71\xfd\xbf\x2f\x5f\x18\x76\xdf\xc3\x98\xaf\x78\x1d\x8f\xeb\x24\x1a\x33\x2d\x8b\x1b\x1b\xec\xee\x51\xc7\xfb\x44\x94\x61\xcb\x40\x6a\x94\x6d\xb5\xd9\xba\xd9\xac\x6e\x31\xd5\x97\x8a\x7b\x92\x9a\xaa\xe3\xe2\x13\x89\xd3\x7b\xa3\xce\xc1\x39\x89\x0f\xfc\xae\x71\x46\x95\x48\xf1\xfe\xeb\xf6\x8d\x9c\x6c\x92\xf3\x4d\x8e\xdc\x21\xf1\x61\x69\xc5\x87\x59\x1c\x8f\x16\x28\xb7\x49\xd2\x7d\x01\xea\x6f\x18\xfe\xf0\xe0\xcb\x87\x6e\x6a\xde\x21\x7f\xf1\xd3\x8c\xfb\x03\xa2\x51\x18\x7c\x0a\x38\x27\x80\xfd\x72\x5b\xdf\xbb\x4b\x1f\x1e\x72\xff\xd9\x7d\xeb\x13\xf6\xee\x9e\x23\x5c\x38\x75\xeb\xae\x0b\x89\xee\x47\x96\x5d\x92\xaf\x96\xa6\xcf\x4c\x91\xf7\x08\xfb\xc1\x5f\x77\xc8\x27\xdb\x2e\xa5\x05\x4e\x1c\x58\xb4\xfd\x66\xfb\x1d\x1b\xc7\xce\xa4\xf7\x57\xe5\x31\xfc\x64\x1a\xa3\xb6\x47\x30\xc9\xa0\xe6\xf1\xe6\x67\x34\xea\x78\x64\xc2\x93\x64\x76\xf3\xc0\xc8\x03\x35\x6f\xb0\x6b\x59\x88\xa3\xbc\xf2\xb2\xb2\x09\x13\x3a\xbb\x4e\xa6\xbe\x1f\x70\xe3\x4b\x02\x98\x89\xc2\x2d\x2f\x09\x20\x90\xb3\x40\x34\xe7\x0f\x06\x0b\x9f\x0b\x9f\x5c\x58\xf3\x4c\xef\xe6\x8b\x7c\x8f\xf0\x84\xb4\xbd\x79\x4d\x2b\xe0\x7d\x57\xaf\xbe\x21\xff\xf8\xf4\x2f\x7c\x1e\xc5\x13\x12\xaf\x76\x03\x8d\x4f\x9f\xcc\xd5\x07\xf3\x8d\x62\xb9\x08\xad\x3c\x32\x1b\xdc\xfa\x04\xb5\xcb\x95\xe0\x36\xf3\x49\x9e\x24\x6f\x82\x2e\x51\x57\x15\x72\x1b\x44\x31\xd3\x68\xa9\x10\xb9\x44\xce\xce\x11\x9f\xc4\x11\x9f\xf8\xd9\x1d\x1b\x56\x2c\x7d\xe7\xf0\x7e\x8d\x69\x3c\x1d\xc3\x0c\xe6\x4a\x38\xc3\x1a\x8d\x14\x53\x5c\xc4\xa5\x21\x12\xe0\xa6\xfd\xbe\xf3\xe5\x95\xbf\x7e\xb2\x15\xcc\xb9\x33\x3c\x2f\xb4\xa3\x9d\x3b\xf4\xda\x57\x20\x05\x64\x86\x9d\xf0\xa3\xf8\xe6\xaf\x9e\x6f\x3c\x37\x6d\xa4\xfc\xcb\x73\xeb\x6e\xe5\xdf\x57\xc9\x4f\x6e\xfb\xfa\xc6\xfb\xe5\xb6\x1d\xff\x78\xfa\x4b\x10\xac\x02\x35\x4b\x36\xd0\x18\x02\x64\xcd\x62\x7c\xcf\x20\xd1\x79\x92\xcc\x69\x1a\x8d\x59\xef\xe1\x05\x67\xa6\x33\x4b\xef\xf1\x7a\xbc\x55\x21\x8f\xc7\xc6\xd9\x88\xc3\x6e\x57\x8b\x0b\xea\x90\xcb\x65\x33\x49\x1c\x71\xb6\x2c\x39\x3a\x6e\x16\x45\x82\x3d\x28\xf8\xd2\xd9\x1f\x62\x4c\x24\x0e\x8c\xea\xca\xfd\xa2\x0e\xb7\xc0\x5e\x89\x39\xbc\x00\xb7\xcc\x3e\x34\x68\xcc\xc4\xd7\xb7\xde\xf7\xf4\x89\x5d\x60\xcc\xf4\x37\x9f\xde\xfc\x70\xd1\xe6\xac\xf9\xc3\xa6\x2e\x04\x15\xee\xa7\x8e\x8c\x98\xb9\xa8\x6a\x40\xe3\xc4\xda\xc3\x5b\x56\xdc\x6b\x80\x71\x4b\xab\xb6\xef\xab\x19\x33\xba\xbc\x74\xfc\x88\x83\x3b\x72\x26\x0d\x1d\x36\x96\xf4\xa7\xb7\x7c\x2b\xaf\xc6\xf3\xe2\x23\xd1\x1b\xf5\x76\xbb\xe0\x11\xdc\x29\xee\xd4\x64\x0f\xc7\xa5\x79\x40\x8a\x2f\xa5\x3a\xa4\x76\x09\x2e\x3b\x32\xfb\x30\x27\x9b\x57\x4e\x5b\x19\x0d\xd6\xe9\x8f\x60\x38\x43\x70\x23\x50\x81\xa8\xdb\x62\x03\x20\xfe\x41\xc8\x84\x90\x1e\x70\xa0\x9c\x90\x7b\x5e\x1d\x77\x58\x7e\x4e\xbe\x92\x55\xb3\x64\xd1\x34\x7f\x62\xce\xa0\x19\x79\x29\x13\xb6\xdd\xbb\x1d\xa4\x83\xb2\x07\xc1\x9f\xe4\x77\xe3\x85\x0b\x6b\xf6\xca\xef\xca\xd3\x0e\xe5\xf7\xcb\x4b\xf1\x94\x55\x06\x72\xaa\x86\x8d\xaa\x08\x0c\x4e\xc8\xe9\xe5\xeb\xb6\x73\xde\x59\xf0\x18\x70\xdf\x29\x8a\xeb\x95\xd8\xd1\x24\xf6\x35\x89\x3d\x98\xae\xd2\xd8\x2c\x16\xb3\x59\xad\xe1\x92\x90\xdb\x9d\xa4\x41\xc9\x1e\x97\x40\x02\x01\xdb\xb5\x89\x40\x25\x98\x8d\x6a\x8d\x9d\x45\xd0\x2d\x77\x96\x95\xc7\xc6\xb1\x51\x7c\xb2\x11\xf4\x8e\x75\x63\x48\x5a\xee\x77\xd8\x63\x02\x5e\x2f\x7f\x4b\xf1\x07\xbb\x4f\xa5\x13\xd1\xfd\x46\xc5\xfb\xeb\xdb\xb8\x19\xdd\x23\x6e\x5f\xed\x69\xd3\xcd\xda\xc5\xea\x5e\xab\x98\xb7\xd7\xab\xaf\x31\x59\x80\x1f\x88\xc7\xd8\x40\xb9\x9f\xf2\xa0\x27\xde\x62\x4f\x4c\x84\x76\x0d\xd4\x78\x3d\xf1\xd6\xea\x50\x7c\xbc\xc4\x49\xc6\xaa\x10\xc6\x10\x67\x75\x94\xa6\x74\x20\x48\x67\xbe\xdf\x63\xb6\x69\x00\x53\x30\xc4\x83\x12\x54\x68\xb1\x7a\x45\xbb\x09\xa4\x40\xe4\x25\xf8\x0f\x3f\x00\x73\xa7\x1f\xfa\xf4\xb6\x87\x9f\x98\x75\xf0\xd2\xe2\x5b\x9e\xee\x15\x7e\x2b\x1e\x3c\xb1\xeb\x5c\x1f\x98\xef\x9e\x28\x5c\x90\x4b\x8f\xc9\xfd\xe4\x4b\xdb\xaf\x7e\xf6\x20\x38\x01\x12\xb7\xfd\x71\x1f\xb0\x81\x84\x3d\x37\xca\x1f\xf2\x7f\xc3\x62\xc0\x3f\xee\x6e\xda\x79\x13\xe3\x59\xc1\x11\x1a\x2b\x23\x3f\xe8\x81\x08\xe9\xf4\x2d\xe4\xf2\xe7\x48\x3d\x48\xd6\xe7\xe9\xef\xd1\x1f\xd7\x3f\xa3\xff\x5e\xdf\xae\x97\x54\x46\x48\xbc\xd2\x02\x72\x99\x95\xa1\x41\x80\x99\x2f\x52\x46\xe4\xe7\xdc\x97\x12\xb4\xf7\xb5\xde\xaf\xde\x36\xb4\x6f\x66\x6d\x51\x4f\x54\xd9\xf6\x60\x6e\x24\x16\x47\x1d\x8d\x33\xd1\x2f\x88\x09\x20\x1e\x25\x3c\xa4\x24\xca\x04\xbd\xd0\x0e\x25\x20\x69\x91\xa0\x56\x0b\x46\xcc\x21\xdb\x29\x45\xc2\xdc\x10\x9d\xb1\x18\x81\x2e\x32\x24\x5e\xc0\xf4\x63\x01\xe2\x48\x05\xbe\x25\xff\x7c\xb4\xe2\xd4\xdb\xad\xd3\x2f\x80\xc6\x8f\xc3\xdf\x81\x2a\xf0\xeb\x4a\x79\x13\xa6\x4c\xe1\xa7\xc1\x40\x39\x2f\x7c\x07\xb5\x19\xc4\xfc\xc0\x7a\x3c\x27\x16\x6e\x54\x30\x57\x34\x73\x9c\x49\x6f\x34\xe8\x0d\x36\xb3\xc5\x62\xc5\xbf\x27\x9b\xca\x4d\x90\x33\x01\x35\x32\x71\x40\xcf\x6b\x0c\x16\x8b\xc1\xae\xe1\xab\x42\x9a\x08\xc1\xcf\x23\x0b\x96\x7a\xcb\xe8\xec\xef\x90\x22\x52\x06\x59\xaa\x8a\x7b\x1c\xa7\xd5\x87\x80\x0f\xe6\x98\xe3\x7b\x0c\x48\xcc\x74\x39\xc6\xf9\x66\xce\x4f\x7b\xbd\x75\xa5\x6c\x7f\x11\xbd\x3b\xf5\xee\x19\x9a\x75\x2a\xd3\x2d\x2f\x5d\xdd\x06\xe5\x30\x64\x3a\xb2\x77\xe5\x25\x7c\x5f\x1a\x5b\xb8\x36\x98\x8d\xe2\x48\xf4\x90\xa4\x78\xb7\xdb\xe8\xd1\x60\x04\x37\x19\x0c\x46\x63\xb2\x06\x25\x60\xd2\x1d\x1f\x6f\x32\x1a\x0d\x6e\xc9\x41\x51\x27\x1a\x36\x50\x69\x5c\x8c\x77\xc8\x98\x80\xf6\x64\xb8\x02\x91\x20\x81\x19\x18\xe0\x3d\x48\xf1\x49\xca\xbc\x93\x4a\xf0\x02\x6f\x11\xf8\x7e\x6b\xc7\x8c\xbe\xd1\xce\x43\xd5\xa8\xd3\x20\xe9\xcc\x2a\xdd\xcb\xf3\x0e\x27\x2e\x3d\x7d\x9f\xc3\x92\xb8\x25\x6e\xf1\xf8\xfe\x01\x57\x9e\x3c\x46\x78\x3e\xbc\xb2\x77\xc9\x6b\xa7\x8f\xc0\xc6\xb6\xe3\x37\xac\x26\xf3\x8a\x39\x1f\xf4\x13\x6e\xbb\x89\xeb\x15\xf4\x9a\xf0\x90\x62\x19\x0b\xef\x29\xc8\x6c\xf1\x58\x82\x96\x2a\x4b\x8b\x85\xe7\x8c\x7a\x83\x1d\x37\x5c\x12\x8d\x54\xdb\x4a\xb9\x79\x30\xa1\x53\x80\xf1\x34\xe2\x16\x9e\x2c\x3f\x8c\xea\x92\x0f\xf9\xc1\xa1\x93\x07\x87\x19\x4e\x58\x96\x7e\x7c\xe9\xe8\x99\x27\xef\xbf\xf0\xd3\xdf\x57\xf6\xec\xed\x1f\xb0\x49\xfe\x4c\x7e\xed\x32\x0d\xb7\x82\xeb\x0e\xc8\xb7\xa2\x4f\xf1\x9c\x16\xe0\x71\xcb\xe5\xd2\x5c\x26\x64\xf2\x22\x95\x2a\x29\x29\x2d\x07\x75\x2f\xec\xee\xcf\xcb\xcc\xc9\xcd\xa9\x0e\xe9\xdc\x29\x88\x47\x7c\x75\x48\xe5\x76\x21\x84\x6c\xb9\x9c\x8d\x10\xb6\x32\x1a\x55\x93\x06\x68\xee\x08\x46\x4c\x9b\x14\xbd\xd2\x4a\x58\x54\x91\x17\xff\x13\x89\x0b\x14\x53\x5a\x5d\x0e\x88\x45\xb9\x57\x32\x00\xc8\xed\x3a\x1e\x77\x54\x0e\x6f\xea\x4c\xee\x0e\xed\x04\x79\xbf\xad\xde\xf3\xe0\x51\x30\xf8\x99\xa1\xf1\x70\xb9\xeb\x87\x0f\xf8\xde\x63\xa7\x9b\xd7\xdb\x9b\x1f\x9a\x7b\x1d\xb2\x97\x75\xc7\x92\xa7\x81\x25\x55\xb0\xef\x9c\x38\x73\x97\x57\x85\x84\xf5\xab\xdc\x1b\x62\x63\xc0\x73\xa3\x68\xff\xc7\xb5\x7f\x23\xac\xc0\x83\x91\x42\xf6\x78\x9d\x07\xa3\x72\x9c\x07\x25\xf9\x92\x52\x3d\x7a\x47\xa2\xa3\x3a\x94\x68\x34\x5b\xec\x12\xa4\xc8\xa2\x60\x4a\x97\x9e\x92\x91\x8f\xe8\x2f\xc9\x0a\xf6\x8a\x64\xf8\x4b\x2c\xe5\x20\x85\x3a\x02\xf1\x7b\x89\xe7\x71\xf4\x4d\x85\xaf\x97\xb1\x66\x70\xab\x66\xbd\x3c\x2f\x37\x34\xd9\xff\x64\xe8\x8e\x0c\x63\xf5\x9e\x04\xb7\xfb\x86\x00\x9f\x16\x7f\x79\x83\xf4\xe7\x51\xc6\x4d\x8e\x67\xb3\xca\xe0\xd1\xcb\xf2\x93\xf2\xe5\x85\x2f\x81\x77\x2f\x54\x39\x0d\xdb\x74\xe6\xf5\xe1\x1a\x9f\xc2\x73\xd5\xf1\x95\x18\x4f\x92\xc8\xce\x63\x33\x26\x20\x23\x32\x78\x34\x7a\xbd\xc1\x90\x6c\xd0\xbb\x49\xec\x0b\x17\x6d\xa9\x19\x6f\xa5\xa6\x58\x8a\x58\x7e\x6d\xd4\x58\x50\x18\x8d\xd9\xee\x23\xa4\xc0\x22\x10\x2a\x4e\xb9\x2a\xaa\x0a\x39\xfa\xe2\xd7\x37\xcb\xfb\xa7\x1e\xe8\xc7\x5b\x6b\x5a\x9f\x9f\x06\x8e\x6c\xbe\x3f\xbd\x4f\xc1\xe1\xe1\xcd\x87\x27\x6c\xe6\x2b\x7f\x7a\xfd\x94\xfc\xdc\xa3\xfd\x87\xaf\x90\xeb\xd1\x77\x50\xbd\xf1\xb9\x97\xe4\xe7\xcb\x47\x6f\x03\xce\x35\x77\xde\x43\xc6\xb5\x3f\xc6\xab\x8f\x71\x5b\x53\xb9\x60\xd0\x67\xe4\x92\x9d\x58\x58\x75\x72\x28\x2d\xdd\x9a\x92\x9c\x62\x44\x82\x5b\xd0\x56\x85\xf2\xd5\x4d\xea\x16\x35\xc2\x24\xcb\x44\xb6\x79\xea\x5a\x41\x71\xe3\x1e\x13\xcf\xc9\x1a\x8d\x36\xa2\x08\x3d\xd7\xc1\xa4\xfe\x53\x0e\x7f\xd4\x32\x67\x4f\xe9\x96\xaa\xa6\xc6\x73\x0b\xb3\xc7\xce\x8d\x41\x9d\x23\x3b\xc0\xd0\x2d\x20\xe3\xd2\xb2\x7e\x43\xe6\xcc\x7e\x50\xfe\xe0\xce\xe2\x0a\x7f\x72\x57\x74\x39\x44\x7c\xcc\x60\x5c\x20\x71\x88\xcc\x78\x7c\xcb\x82\x89\x36\x83\x43\x97\x80\xa9\xb8\x01\xa9\x92\x55\x1e\xad\xc6\x29\xe1\x8d\x06\xb3\xe4\x96\xd8\x30\x1a\x9d\x51\xa1\x23\x3c\x46\x2a\x99\xf6\x0c\x89\x0c\x31\x9f\xe1\x31\x17\x65\x90\xd8\xe0\x84\x01\xb9\xfc\xf2\x27\x07\x40\xf7\x4b\x30\x33\xfe\x96\x5b\xc1\xf0\xcd\x72\xfb\x7d\x60\x51\x46\xcd\xb2\xc7\xd6\xf6\x5c\x6d\xfb\xc7\xc5\x97\x40\xc9\x91\xf5\x22\x7f\xf0\xd0\x73\xf2\xfb\x87\x36\xc2\xd2\x9b\x36\x0c\xdf\xfb\x97\x19\xdb\x0e\x50\x5c\x1d\x86\xf9\xa8\x99\x34\x16\x63\xb7\xa0\x5d\xef\x70\xa8\xe2\x55\x6e\x1b\xde\x02\x6d\x0e\x3c\xf3\x1c\x6d\x5b\x79\x6c\xc4\x00\xc5\x47\x42\x04\x0b\xbd\x31\xa6\xc8\x04\x51\x41\xa5\x82\x7e\x70\x40\xbc\xfc\xe6\x46\x29\x82\xa0\x1b\xd0\xd9\x28\xd6\x25\x50\x9c\x2c\xce\x85\x47\x71\xfd\x4a\xcc\x4f\xce\xc9\xf9\x82\x66\x64\x53\xe9\x6d\x7a\x57\x9c\x19\x33\x0c\x66\xdc\x00\x1a\xe5\x33\xf6\x52\x31\x60\xd5\x59\xcc\x8c\x26\x29\x5c\x25\xae\xf6\xe0\x32\xc3\xc5\xd3\xe7\x53\x9e\xf4\xee\x92\xc3\x7f\x7a\xe8\x39\xd3\x42\xbc\xcd\xdc\x36\xa4\xf4\x5d\x30\x15\xf4\xdd\xb6\x7b\xcd\xfe\x1f\xe5\xf5\x2f\x3c\xfe\xc8\x80\xd1\x70\x24\x9e\x93\xc1\x18\xe7\x7f\xe5\x47\xd1\xf8\xbf\xa3\x82\xdd\xd4\x1a\xcc\x08\xc4\x6b\x90\x23\x3d\x1d\x39\x0c\xc8\x90\x95\x19\xcf\x79\xe3\xb4\x71\x55\x21\x95\xd6\xa1\x51\xbb\x2d\x89\x44\x62\x32\x9b\x95\x38\x6e\x2c\x70\x00\x93\x34\x2c\x65\x31\x4c\x81\xb3\xd3\x22\x30\xd0\xbd\x10\x13\x22\x13\x87\xb9\x48\x2a\x56\x5b\xa9\xe8\x24\xa1\x3e\x10\x2f\x06\xf4\xd6\x4d\xfb\xaa\xef\xfe\xea\xf0\xc8\x63\x23\x1f\x7f\x1b\xd8\xbf\x4b\x58\x72\x60\xe4\x8d\x8b\x9b\xb2\x8f\xef\x1c\x32\x2e\xbe\x79\xfe\x9d\x33\xcb\xf8\xaa\x17\x4e\xed\x90\xff\x76\x71\x86\x20\x37\x82\x3b\x54\xdf\xbd\x0e\x4c\x60\x4e\xea\xc6\x84\xdd\x7f\xac\xbc\xe9\x1e\x09\x0e\xf8\xdb\x13\x1b\xd7\x6d\x0b\x3f\x86\xea\x1e\x05\xc6\x99\xef\x52\x3b\xe8\x31\xfc\x32\xbe\x0a\x23\xd2\xc0\x60\xaa\xc5\xea\xb0\xab\xed\x10\x71\x66\x1b\x6f\xb5\xba\x00\x84\x4e\x8b\x11\x8f\x30\xc7\x03\x9d\x4e\xaa\x0a\xe9\x4c\x0e\x72\xee\x48\xd7\xb2\xb3\x4c\x89\xcf\x42\x89\x6c\x74\x35\xa7\x91\x53\x20\xb6\x83\x62\xc6\x17\xaf\x10\x2b\xd9\xd7\x7d\x50\x25\x67\xbe\x08\x27\xcf\xcc\x2a\xc9\xb4\x79\x52\xaa\x7b\xf5\xaa\x28\xf1\xd5\x82\xe6\x67\x65\x15\x40\xad\xdf\x87\x1b\xb1\x3c\x5c\xbf\xad\x4a\xb7\x32\x31\x67\xc6\x52\xf9\xaf\xd0\x1d\x1e\xdc\xf6\x3e\xc5\xb5\xc5\x72\xbd\x70\x48\xe8\x85\xc7\x7d\x68\x30\x95\xd3\xe9\xe2\xf5\x7a\x9b\x60\xb3\x0a\xa2\x55\x4c\x4c\x4a\x70\x8b\x02\x7e\x30\x72\xf1\x86\xf8\xaa\x90\xd6\xe0\xd0\xeb\xdc\x5c\x64\x9c\x69\x2c\x33\x7f\xde\xb5\xca\x25\xba\x43\x51\x8f\xd2\x90\x0c\x77\xaa\x39\xaa\x88\x71\x5a\xfd\xf0\xab\x75\xbb\xeb\xe2\x56\x9f\x59\x95\xb2\xed\xbb\x27\xf1\x38\xcb\x35\xa6\xc5\xa7\x97\x9b\xb6\xde\xfc\xed\xb1\x25\xa0\xd7\xfa\x55\x70\x53\x78\xe5\x43\xcf\x8d\x07\xf2\x0d\xe0\x76\x1e\xd4\x05\xab\xe0\xb4\xf0\x8e\xaa\xee\xcd\x0d\x90\x7f\x91\xd2\x1b\xbc\x76\xff\xe0\x47\x72\xdd\xb9\xaa\x60\x66\x8e\x3d\x5b\x9d\xed\x41\xa9\x52\xaa\x5b\xd2\xbb\xf5\x79\xf9\xb6\xec\x6c\x97\x06\x65\xb8\x32\x30\x6e\xb8\x1c\x1e\xb5\x46\x5d\x15\x4a\xd6\x98\xa2\x91\xf1\x3a\x44\xd1\xae\x48\xa2\xf8\x5f\xa2\x34\x91\xd9\xd9\x2a\x24\x33\x1a\x9a\x25\xe0\xe4\x23\x4e\xd7\xc9\xd9\x95\x88\xc6\xd5\x0f\x9f\xb1\xb5\xfa\x6c\xe1\x9d\x0f\xae\xf9\xe8\xae\x25\x5b\x2c\x7c\x8f\x3f\xad\xdc\x7b\x7c\xf3\xf7\x87\xb4\xf2\x8f\x15\xd6\x71\xf5\x33\x77\x24\x15\xdc\x5f\xa0\x05\x75\xb3\x96\x6c\x06\xbe\xa6\x5f\xfa\x6c\x73\xff\xf4\xcc\xbd\xf2\xd9\x07\xd7\x6e\xdd\xba\xf6\x83\xa7\x9f\x01\xbd\x1e\x77\x6d\xeb\x21\xef\x9e\x3e\x6c\xf9\xaa\x3f\xed\x6f\x6b\x0b\x46\xf4\x12\x7b\x85\x15\x11\xbd\x04\x37\xfb\xbc\xa2\x59\xd1\x99\xd3\x21\x68\x31\x19\x94\x13\x86\x88\x2e\x86\xae\x55\x9a\x9e\xea\x26\xb8\xd9\xdc\x8f\x11\x5d\x8c\x8b\xe4\x98\x96\x10\xaf\x68\x26\x3a\x74\x31\x74\x6f\x24\xba\x0f\xb2\x37\x52\x5d\x49\x8b\xa2\x8b\x49\xc4\x59\x3e\x48\xf4\xa8\xb8\x4e\xba\x15\xa6\xff\x90\xa2\xfa\x8f\x32\x30\x57\xd1\xc5\xe0\x2a\xc0\x79\x97\x9b\xd5\x10\x4d\x4f\xe7\x88\xa6\x5f\xc1\xd2\xc3\x05\x4a\xfa\x3c\x9c\xfe\xcb\xbc\x42\x77\x4c\x7a\x1a\x07\xea\x1b\xf4\x31\x8d\x03\x95\xc9\xf9\xb9\xe9\xc1\x40\x8a\x4a\x95\xe3\x28\x84\x6e\xb7\xc1\x61\x28\x2e\x12\xd2\x30\x21\x8e\xcb\xc2\x6b\xbf\x30\x8b\xb8\x4c\x32\x66\x25\x67\x41\x35\x12\xb2\x84\x2c\x9d\xd5\x9a\x57\x15\xb2\x72\xba\x24\xcc\xba\x74\x0e\x79\x44\x63\x5c\x4d\x28\x8b\x04\xef\x8a\xcc\x76\xd4\xc5\xb5\x28\x45\x1d\x34\xfa\x30\xdd\xc6\xd2\x42\xc4\xf8\x04\x45\x22\x2c\x53\xef\x89\x20\x1a\x2a\xc4\x01\xe6\x54\x7a\xcb\x5a\x27\x3f\xf4\xd4\xe2\x8f\xf6\xca\xab\x1b\x8e\x7c\xb6\x73\xf3\xdd\x8f\x1c\x3a\xfa\x55\xd3\xa4\xd0\x4d\x43\x67\x4c\x1e\xbf\xbd\x12\xec\xac\xaa\x1b\xd8\x6f\xd0\xa6\x82\xb1\x7c\xb7\x03\xdf\x8f\x0c\x9d\xbb\xef\x96\x7f\xad\x00\xaf\x1c\xc5\xd2\x44\xd6\x9e\xe5\x37\xac\xbf\x25\xbc\x7c\xf6\x8d\x13\x1f\x9e\x7b\x43\xf3\xc4\x47\xe0\xc3\xfd\x7b\x67\x17\x0d\xab\x18\x4e\x75\x00\x3e\x3c\xc6\xc4\x4f\x5c\x77\xae\x07\x37\x37\x58\x96\x5b\x50\xd0\xdd\xa1\x0b\xa4\x81\x94\xbc\x94\x34\x1d\x9f\xed\x36\x49\xd9\x52\xaf\x9e\x66\xab\xd5\x50\x15\x22\x2f\xab\x42\xb9\x79\x92\xdb\x9a\x67\xcd\xe3\x33\x33\x8b\xaa\x43\x99\x5c\xe7\x60\x02\xca\x18\x94\x95\xc5\x44\x2f\x53\xc2\x64\x47\xf7\xb0\x48\x60\x06\xc8\x29\xa1\x06\x63\x03\xba\x1b\xd8\x71\x49\x89\x25\x90\x03\x22\xb1\x14\x25\xbf\xa4\x0c\x06\xd9\x9c\xf9\x35\x93\x07\xca\x47\xaf\x6c\xdc\x95\x92\x95\x92\xef\x9f\xc5\xcf\x0e\x55\xd5\xfa\xb2\x7d\xfd\x7b\xcf\x78\x6a\xbf\x4f\xfe\x45\xfe\xf1\xb5\x87\x1e\x7e\x52\x3b\x59\xd6\x2f\x98\xd4\x30\xbf\xf6\x6e\xf8\xbb\x7c\x48\x1e\xb5\x74\x46\xf1\xa4\xd1\x15\x49\x59\x05\x3b\x4a\x6a\x06\x16\x4e\xa8\x1f\x9d\xe9\x0f\xec\x07\x3d\x4e\x09\xa7\x1f\xbe\xf7\xd5\xcf\x2e\x0e\x18\x0d\x2a\x2a\x76\x1c\x5b\xdc\x34\x62\x42\x01\xa5\x4f\xef\x72\x9c\xb8\x5c\xd8\x81\x65\x91\xc2\x60\x9c\x41\xaf\xd1\xea\xb4\x7a\x64\x85\xd0\xa6\x36\xe2\x2f\x5a\x0b\x27\x74\xe8\x55\xcb\x23\xbe\x56\x3a\xa8\xbe\xe2\x6d\x1f\x90\x98\x84\x98\x4e\xf6\x01\xc2\x9d\xeb\x26\x4d\x19\xd0\x37\xaf\x34\x51\x86\xcd\x4f\x2f\x94\x5b\x5e\x00\x85\xe0\xec\xc0\x16\x61\xc7\x94\x8d\x03\xb2\x53\xc2\x0f\x85\xcf\xc1\x0a\x54\x16\x9e\x08\x2d\xb5\x83\x31\x2e\xe3\x95\x21\xbd\x2e\x5c\x34\x65\xa0\xf5\x60\x34\xd3\x14\xde\xf1\x12\x27\x9d\x04\x0e\xc4\x8e\x5f\x99\x3e\x54\x5c\x4e\xf4\xa1\x68\x7d\x8c\x3e\x34\xee\x0c\x04\xf1\x44\x1d\x7a\xae\xfd\x5c\xab\xd3\xae\xef\xac\x43\xed\x87\xf7\xbb\x02\xe1\x82\x45\x84\x3d\xe8\xfc\xf7\x6e\xff\x46\xac\xa7\x7b\x2e\x89\xcf\xd7\x2d\x01\x01\x21\x2b\x27\x47\xe7\x74\xa4\xa4\x58\xad\x3a\x01\xe5\xe7\xb9\x52\x4d\xa9\x55\x21\x3d\xa7\x36\x39\x32\x33\x93\x93\x91\x93\xea\xd8\x14\x56\x00\x77\xd7\x95\x47\x64\x85\x4e\x91\xa7\x14\x0d\x90\x9f\x85\x07\xf6\x39\xae\x21\x6a\x01\x1f\x60\x14\xcf\xab\x68\x0f\x23\x94\xfa\x71\xe1\x80\x7b\x61\xb7\x8d\x1f\xdf\xb2\x72\x9b\x9a\xef\x7d\x7c\xe5\xfe\x63\x4d\x53\x9a\xd0\xc4\xf1\x3b\xeb\xbb\xb5\x9d\x99\xb6\xe4\xf8\xf4\xbd\x49\x03\xef\xeb\xaf\xc7\x2d\xde\xb6\x74\xcf\xf3\x98\xa6\x6d\x5d\xb7\xad\xe5\xe9\x93\xb7\x82\x01\xab\xda\x5e\xb9\x09\x38\xf7\x1f\x98\xb8\x4a\x3e\x7b\xc7\x87\x0f\xdf\x0d\x26\xc9\x07\x07\xe7\x4f\x9f\x87\xf7\xc2\xfb\x71\x9f\xdf\xe1\xfb\x60\x19\x64\x42\xb0\x30\xcd\x64\xb2\x8a\x05\x6e\x77\xf7\xe4\x9c\x9c\xee\xa2\x96\x87\x0e\x87\x1f\x16\xe6\x24\x8e\x0a\xe5\x38\x7c\x99\xa3\x42\x69\x3e\xb7\x8d\x83\x76\x3c\xcb\x7a\xd5\xa8\x90\x9e\x49\xd2\x91\xa3\x99\xb2\x48\xc4\x7f\xd0\xe5\x30\x83\x4e\xbb\x1a\x78\x4b\xe2\x15\x2f\xac\x4a\x10\x50\xc9\x09\xbc\x06\x44\xd9\xa2\x8e\x8b\x5e\x98\x8e\xd3\x41\x40\xf3\xc3\x7d\xe5\x5f\x5b\x8e\x8e\xad\x4b\xec\xc9\xf7\x1f\x30\x75\xd6\xac\x91\x3c\x3c\x09\xf4\xa3\x6e\x6e\x0c\xd4\x67\x95\x04\x92\x76\xad\xe8\x57\x9e\x98\x5b\x58\x36\xc0\x64\xbd\x6d\xc9\x50\x14\xdf\xf6\xe5\x0e\xe0\x06\x09\x53\x96\x1b\xf6\x5a\x17\x2d\x5a\x21\x5f\x5c\x04\x91\xaa\xfe\xfd\x2b\x9f\xf4\x59\xae\x97\xbf\xda\xb7\xc3\x7c\xc0\x30\xa0\x7a\x5a\xdc\xf3\x37\x82\x59\xf3\xf1\xdc\xce\x97\xeb\xc9\x99\x17\xe6\x37\x3d\x84\xdf\x74\xf2\x44\xa4\x06\x3c\xf0\x26\xe9\x74\x29\xa6\xf8\x86\x10\x30\x59\x55\x96\x86\x90\x8a\xa7\x4a\x18\x45\x67\x0a\x62\x1c\x86\x32\xe7\xb2\x4c\xf9\xef\x2f\xe4\x2d\x84\xcd\x92\x90\x15\x93\xa7\x98\x43\x4d\xd0\x5e\xfd\x45\xdb\x5f\xc0\xf2\xef\xce\x02\xe3\xae\xa7\xe4\xfb\x2f\x8d\xfc\xec\xf6\x2f\x0e\x86\x94\xd3\x4c\xb9\x1e\x1c\x48\x06\x85\xbf\x91\x33\xcc\x9d\xf2\x6f\x0f\x7f\x25\x2f\xfb\xd2\x28\xcf\x12\xef\x9b\x72\x5e\xfe\x74\xf3\x5b\x1f\xfe\x09\x8c\x7b\x86\x1e\x68\x42\x86\x9b\xfc\x08\x2a\x7f\xf4\x0c\x26\x99\xf0\x7e\xe2\xe4\x8d\xb8\xc1\xc9\x66\xad\xd6\x63\x8c\xaf\x0e\x01\xa3\x43\x65\xc5\xbc\x98\xe9\xba\x0d\x8e\xba\xa2\x65\xf1\x86\x95\x29\xc0\x4c\x16\x30\x45\xa3\x08\xf6\x81\xa0\x5b\xf5\x6d\xf7\x6f\x09\x3f\xfe\xf6\xc7\xcb\x3f\x7b\xa0\x12\xdc\xf9\xdb\xe6\x23\x63\x5b\x96\xcf\x5a\x33\xa9\x27\x6e\xea\xc1\xe4\x4f\x1f\x79\x1c\x0c\x7e\xf0\xc3\x97\x1f\x94\x5b\xcf\xe1\x76\xf2\xa3\x41\xd2\x36\xf9\xcb\x0d\xbb\xf7\x55\xec\xfb\x0d\xd3\x85\x97\x38\x4e\x78\x1b\x8f\xa9\x8b\x44\xd3\xb1\xf2\x4e\x0e\x37\x2f\x4e\xab\x8d\x77\x80\x86\x90\xc3\xc1\xa9\x54\xc6\x86\x90\x4e\xa7\xa2\x47\x88\xb1\x21\x91\x63\x42\x57\x92\x73\xa2\xe8\x90\x76\x18\x30\x39\xfc\x01\x04\xa7\x04\x3e\xb8\xfa\x04\x18\xf2\xce\x25\x90\x99\xdf\x9a\xf6\xc6\xed\xb7\x5f\xd9\xf1\xf9\xc5\xde\xb5\x20\xd1\x06\xf8\xd7\xce\x81\xd2\x07\xce\x1c\x09\x2c\x58\xb7\xe2\xfb\x4d\xf7\x9e\x44\xf2\x10\xdc\x1e\x13\x96\x8f\xbe\xc6\x72\x50\x37\xae\x3c\x98\x9c\x11\xaf\x49\x41\x1a\x94\x6d\xb5\x58\x72\x50\xbc\x31\x23\x2d\x8d\xab\x0a\xa5\xb9\x49\x28\x72\x12\x12\x2d\xa2\xea\x64\xdc\x6a\x59\xd7\x63\xf8\x18\xdf\x49\x5d\xc3\x2f\x92\x08\x45\x4a\xe4\x5e\xcc\xa3\x80\xf1\x1b\xb7\xf8\x06\x8f\x3d\x7f\x78\xc4\xce\x0b\xb7\xdc\xfb\x98\xe9\xb8\x75\x72\xfd\xc2\x83\x13\xba\x0d\x9b\x1d\xdc\xb6\xfc\x5f\x5f\x9c\xdb\xe8\x9d\xbe\x41\xbe\x32\xae\x26\x15\x77\x34\xf3\x99\xbb\x16\x00\xc7\x0b\x93\xee\xb9\xcb\x75\x43\x68\xab\xfc\xe5\xc2\x01\x35\xfe\x64\x53\xca\xaa\xa9\x47\x4f\x94\x1d\xc9\x4e\x8c\x9e\xc5\xf6\x17\xd6\x72\x5a\xae\x24\x98\x00\x05\x01\xa8\x90\x4e\xa3\xd1\x03\xb1\x21\xc4\x07\x01\x50\xa9\xd5\x5c\x43\x48\x8d\x54\x8a\xff\x24\x32\xa0\xf1\x17\x3a\x82\x96\xd1\x10\xb0\xc4\x26\x91\x1c\xd0\x4a\xe0\x5f\x75\xf0\xa9\x8a\xd3\x59\xe1\xdf\x56\x3f\x03\xcc\xe8\xa7\x24\xfe\x0b\x79\xa0\x7c\xcb\x5b\xe1\x45\xc2\xda\xfd\x4c\x97\xf3\x86\x3c\x06\xd5\x53\x3d\x5a\x9f\xa0\x47\x44\x48\xad\xd5\xea\xd5\x3a\x28\x8d\xc2\x14\x1d\xa8\x11\x1f\x84\x50\xad\xd1\x80\xaa\x90\xc6\xa8\x76\xc7\xd6\x49\x35\xc4\xc0\xdf\xa1\x5c\xf5\xd2\x8a\x7d\xa4\x62\xd4\x4b\x1e\x5e\x0a\xd6\xf5\xbd\x3b\xf5\xf3\xd3\xc7\x41\x1a\x9c\x8a\x8e\xcb\x9f\xc8\x27\x1f\x6b\x6b\x10\xfe\x81\xfb\x38\xad\xfd\x5b\xfe\x3d\xe1\x22\xe7\xe3\x06\x04\xbd\x12\x87\x90\x3e\x39\xce\x62\xd7\xdb\xd3\x52\x4d\x29\x66\x8d\xcf\x97\xa0\x49\x70\x36\x84\x12\x38\x0d\xde\x57\x34\xd6\x4e\xca\x46\x3c\x45\xd1\x3d\x34\xaa\xf5\x67\x74\x33\x62\x0b\x57\x12\x00\x19\x84\x9e\xc6\x52\x1e\xc0\xbf\x57\x77\x74\x5c\x61\x36\xdf\x7f\xe8\x9c\xe6\x3e\x0d\x6d\xe7\xdc\xf5\x27\x2a\x33\x4a\x84\x81\x43\xa6\xce\x9e\xd6\x1b\x0d\xe4\x2b\xcf\x87\xff\x39\x73\xa5\xf1\xa0\x6d\xfd\xd2\xaa\x9f\xda\x64\xc9\xfe\x3c\x1c\xd3\x38\x19\x3f\x2f\x5a\x38\x59\xde\x79\x0f\xf8\x89\xcc\x0d\xde\x51\xf8\x00\x9e\x1b\x35\xd7\x2b\x98\x24\x21\x0e\x60\xce\x1c\x20\xa4\x81\x2a\x95\x56\x8d\x69\x81\x84\x46\x85\x24\x09\x08\x88\xc4\x83\x55\xfc\x3e\x45\xfc\x73\xc5\x08\xad\x5e\x1f\x09\xc4\xef\xc7\xf3\x03\x37\xbe\x04\xe6\x84\xed\x6a\x70\xf7\x0b\xf2\xfd\xf0\x4b\x35\xdc\x5e\x00\x5f\x08\x3f\x5c\x40\xfc\x68\xca\x21\xe1\x38\xe6\x45\x12\xb9\x69\x41\xbf\x5e\x50\xa9\x74\x12\x26\x77\x36\xb7\x2d\x39\x49\x10\x25\x71\x52\x48\x25\x91\x7d\x78\x52\x48\xaf\x93\xf0\x7f\x9c\x93\x06\xd7\x9e\x14\x72\xe2\x86\x36\x44\x23\x92\x45\x23\xa3\xff\x87\xc3\x68\x3a\x9c\x74\x0c\x33\x72\x80\x05\x0f\x1c\x28\xca\xc0\x1f\x04\xd5\x79\x3c\x7a\x8c\xce\x99\x38\xf0\x90\x1b\xa4\x83\xda\x67\x3d\xe1\x35\x59\xf0\x71\x4f\x78\x68\x26\x7c\x38\x78\x69\xf7\x76\xf9\x1f\xf3\x26\xdd\x0b\xfa\x3d\xf3\x1c\x48\x3d\x1c\xfe\x49\x0e\xed\xad\xfe\x10\x94\xbc\x2d\x7f\xb6\x01\x94\xee\x9d\x2a\x5f\xd8\x00\x0a\x96\xac\xdd\xb2\x78\xd1\x5d\xeb\x1e\x97\x8f\x7c\x24\xe7\x87\x4f\x31\x3d\xd8\xd7\x72\x1d\x2f\x09\xef\x70\x76\x6e\x78\x30\x53\x27\x71\x3c\xb4\x58\x78\x51\x6b\x10\x1c\x4e\x81\x97\xf8\x51\x21\x51\xd2\xa8\x75\x58\x6c\xd0\xd2\xbe\x19\x8c\x1c\xd5\x8c\x53\x23\xbc\x6b\xfa\xa1\xec\xb2\xa4\x0f\x44\xfc\x15\x32\xd2\xd2\xc9\x07\x4c\x0b\xf0\x58\xc4\x83\x12\xbc\xfd\x71\x5e\x5e\xda\x0d\x1c\x71\xe4\xc9\x13\xb2\xc1\xee\x03\xf2\xab\x67\x41\x1a\xe8\x37\xf6\xff\xe1\xec\x3d\x00\x9c\xa8\xb6\xff\xf1\xb9\x73\x67\x32\xe9\x33\x99\x49\x2f\x9b\xb6\x9b\xed\x85\xcd\x56\xda\x86\xbe\xf4\x2c\x3d\xb4\x5d\x60\xa5\xa9\x20\x1d\x01\x29\xd2\xa4\x0b\x08\x2a\xa2\x58\x40\x10\x15\x05\x16\x01\x41\x40\x44\x44\x04\x54\xb0\x3c\xec\xf5\xbd\x67\x7b\x16\xf4\x15\x20\xc3\xff\xde\x99\x49\x36\x59\xf0\xbd\xef\xff\x27\x92\x2c\xd9\xec\xe6\xdc\x73\xcf\x3d\xf7\xd4\xcf\xe9\x25\x0e\x02\xef\x82\x9a\x82\x9c\xe7\xd6\x1d\xb9\x77\xec\xe1\xfb\x0f\x00\xdd\xae\x81\x8f\xc7\x8f\x89\x9b\x9f\x17\x6f\x6b\xc2\x67\xe3\x82\x38\x44\xf5\x0f\xb4\xdf\x25\xc8\x1a\x28\xd0\xeb\x74\xd9\xac\xda\xe6\x74\x92\x85\xa4\x1a\xb6\xf2\xf9\xfd\xa5\xd9\x39\x0d\xb1\x6c\x57\x11\x49\xfb\xac\x3a\x48\xa3\xcb\x83\x16\x08\x0f\x62\xbe\xd0\x9c\x62\x96\x12\x10\x89\xe2\x89\x64\x40\x5f\x89\x5d\x34\x8f\xcd\x0b\xa7\x8c\x92\x52\xbe\x74\x49\xd3\x56\x82\xfe\x4a\x3f\xbe\x23\x91\xb5\x40\x99\xce\x77\x1f\xfe\xf8\xc8\xa7\xf7\x58\xf6\x1f\xdd\xcf\x0f\x1e\x75\xf7\xaa\x8c\xa3\xaf\x1c\xe6\xfa\xc7\xfe\x55\x73\xf8\x95\x1b\x44\xf6\xca\xbf\xbe\x78\x3d\xdb\x03\x2f\xee\x38\x18\x34\x50\x6d\x1e\x37\xef\x1a\xd9\x63\xd7\x13\xdd\x26\xc1\x07\xaf\x8f\x1b\x11\x19\x37\x62\xcb\x83\xf0\xcd\xeb\xdd\xfa\x54\xd5\x0f\x07\x9d\xe0\xc1\xab\x1f\x9f\xbe\x7c\xdb\xc6\x27\x0f\x74\xe8\xde\x27\x11\xd3\x1d\xa2\x5a\x80\xf4\x40\x19\xde\x13\xce\x6c\x2e\xd2\xbb\x7d\x3e\x55\x36\xb2\x6b\x55\x7a\xaa\xbc\xa2\x08\x99\xf8\x45\x2e\x42\xa5\xc9\x76\xb1\x6c\xd0\xa6\x41\x66\x0f\xd4\x34\x4f\x3b\x4f\x2c\x33\x75\xd4\x9b\xec\x85\xca\x61\xdc\x94\x85\x32\x29\x2b\x4d\xfd\xba\x79\xad\x74\x7e\xcf\x47\x1b\xef\x5e\x6b\xec\xff\xc4\xf8\xe5\xeb\x2d\x0b\xf6\xcd\x33\xa9\x7b\x0d\x9a\xba\xdb\x37\x53\xfe\x6a\xca\x6e\xff\xcc\xfd\xaf\xe4\x2c\xfb\xf4\xd9\xeb\xdd\x5d\xf0\xb9\x47\xf7\x86\xbc\x87\x27\x8d\x9c\x35\xe5\xde\xb1\x38\xa1\x41\xae\x89\x2f\xab\x2f\xf2\xf7\xec\x7b\x7c\x3b\x59\x9f\xf8\x72\x27\x39\xfc\x7a\xe9\xc5\x4f\x6f\x5b\xf5\xd0\xfe\x55\x48\xfe\x76\x22\x1d\x7b\x1b\xba\xb7\x32\x90\xfe\x09\x32\x36\x13\xc7\x65\xd8\xa0\xd7\x60\x34\xfa\x32\xdc\x6e\x88\x34\x0f\x65\x32\x6b\xcd\xe8\xee\x42\x8a\x97\xe3\x0d\x50\x3e\xcc\xe1\x5b\x0f\xb4\x95\x30\xed\x9b\x21\xde\xa5\xa9\xd2\xca\x72\xa5\xbe\x30\x18\xc9\xed\x59\x32\x7a\x65\xf7\x8d\x2b\x2f\x9c\x5d\x75\x4c\xfc\xc7\xb1\xf1\x93\x8f\x0f\xf9\xf8\x8f\x4e\x4b\x8e\xcd\x5a\x3a\x91\x7a\xd5\xed\xbd\xf3\xec\xd8\x7b\x96\x0d\x25\xcf\x5d\x9d\x4f\x5a\x0a\x43\x1f\x9e\x9c\xf8\xe5\x13\x7d\x6b\xa5\x73\xb2\x1d\xe9\x9b\xcd\xf4\x5f\x90\xc5\xd2\x26\xe2\xb5\x31\x80\x25\x18\xca\xef\xf5\x06\x00\xe5\xa4\xa2\x31\x27\x1e\xda\x6d\xe0\xfb\xc5\x58\x03\x90\x47\x0b\x2b\x63\xb9\xd3\xf2\x8f\xf8\x82\x4d\x72\x3f\x65\x5c\x65\xca\xe8\x32\xf2\xd5\xdb\xbb\xec\xb8\xf3\xc1\x2d\x86\x3e\x9e\x27\xd7\xb5\xef\xe1\x6d\x53\x35\xc3\xd3\xd3\xd0\xaf\x71\xc1\x51\xf7\xbc\x26\xf1\x0b\x32\x77\x58\x74\xcb\x9a\xa2\x9e\x60\xc3\xa6\x8d\x96\xed\xb6\x07\xc4\x79\x5d\x0a\xeb\xfa\xbd\xb8\x89\x9c\x7f\xb5\x4c\x96\x9d\x1f\xc5\x21\xb8\x56\x12\xd1\xd9\x3e\xe2\x67\x71\xa1\x08\x2f\x70\x94\x2f\xe0\xf3\xfb\xd0\x65\xe5\x73\x19\x75\x56\x5d\x7d\x4c\xb0\x5a\x39\x13\xe4\xf8\x16\xdc\x4c\xf5\x15\x04\x7f\x69\x7b\x4a\xf1\xf4\xa4\xb0\x7f\x65\x72\x7e\x3c\x15\xf4\x6b\x40\xd1\x4b\x2f\xae\xbb\x6b\x50\xd5\xfa\x4d\xb1\x73\x23\x96\x1e\x03\xfc\xb1\x49\x3d\x1f\x7a\xf8\xb3\x9f\x6a\xef\x3b\x25\x7e\x73\x45\xdc\x29\xfe\xe4\xef\x7e\xcf\xc1\x7f\x0d\x5e\xff\x78\x49\x5e\x3c\x4a\xdf\x1b\x7f\xcb\xd3\xfa\x87\xaf\x66\x89\xef\xfc\xbc\xa5\x2f\xae\xcf\x7b\x14\xf9\x77\x15\xd4\x66\xa2\x90\xa8\x26\x66\x45\x3a\xb4\xca\xd3\x64\xea\x02\x81\xcc\xca\x3c\xca\x06\x55\xaa\x36\xb6\xd6\x99\x9a\x6c\x55\x59\x76\x34\x56\x09\xe9\xb2\x32\x1b\xe1\x34\x47\x63\xac\xd3\xeb\x2c\x76\x42\x1d\x74\x46\x6c\x16\x16\xb9\x77\xac\x55\x45\x13\x44\x51\x32\xe8\xcb\x9d\x2e\x95\x4e\xba\xf3\x7c\x73\xce\xb4\x79\x6a\x66\xda\xb0\xea\x44\x01\x41\x45\xa5\x8d\x51\x31\x8a\x27\xd0\xdc\xdb\x6d\x4b\x84\x3e\x12\xe2\x83\xa3\x62\xca\x36\x15\x01\xb2\x75\xb7\xb9\xd1\x4e\xed\x26\x7a\x7a\x14\xe7\x2f\xfb\x6d\x4b\xe7\xfa\xae\x15\xae\x76\xc6\x07\xf9\x29\x03\xfb\xf4\xef\xd7\xa7\x71\xcb\x08\x7a\xc0\xf9\x29\xd3\x17\x4d\x79\x75\xce\x3d\x0f\x56\x94\x36\x6e\xef\xe3\x8d\x51\x7d\x72\xaa\x7a\x0f\x1b\x1e\xba\x2d\xdc\xeb\x81\x77\xc4\x37\x76\x66\x04\x33\x7a\x4e\x9c\x51\x5a\xba\x04\xe8\x1e\x2a\x74\xf7\x1b\x31\x7b\xec\xb0\xf5\xb5\xcb\x86\xd7\xe6\x87\xeb\xa3\xa1\x42\x59\x37\xe3\x19\xa3\x61\x74\x36\x4a\x89\x5a\x7c\x36\x6c\xb9\x9e\x40\x80\x30\xe4\x1a\xc2\x88\x1f\x59\x5a\x9f\x2f\x2b\x0b\xd9\xca\x59\x82\x4a\xa5\xd5\xc2\x86\x98\x96\x4a\x4e\xea\x6e\xbe\x6a\x12\xf7\x73\x72\xc9\xca\x58\x6e\x7c\x9d\x60\xa7\x16\xd2\x09\xbf\x16\x87\x79\xd0\x2b\x84\x3f\x20\xcd\x4b\x00\x95\x99\xed\x21\x35\xeb\xb1\xd5\x8f\x9f\xae\x7c\xb1\x2b\xc8\xf8\xcf\x67\xff\x2e\x1d\x32\xf7\x31\xf1\xd3\xa5\x9b\x6a\x8f\x6c\xff\xe2\x8a\xf5\xa0\x4b\xdc\x2a\x9e\xd9\xf1\xf3\xbc\xdb\xcf\xec\x07\x86\x39\xc3\x22\x01\xaa\xcb\xe0\x89\xe3\x66\x94\x6e\xdf\xfc\xfc\xb6\x41\xf3\x87\x45\x5a\xb5\x75\x45\x26\xf4\x1c\x3b\xfb\xf9\xed\xed\xba\x06\x7a\xf7\xf8\x49\xfc\xcf\xd0\x9d\x93\xa7\xec\x9d\x90\x5d\x9d\x99\x57\xd9\x23\x75\x7d\x05\xd8\xf6\xc8\x33\x1a\x5d\x96\xac\x2c\xca\x45\x15\x15\x1a\xb3\xec\x84\xd9\x6c\xb7\x9b\xa2\x31\x3b\x95\x4f\x10\xc8\xfd\x91\x22\xcf\xc9\x43\x9f\xb6\xb8\xe6\x00\x74\x33\xe5\xe5\x7f\xb2\x4e\x5f\x25\xa3\x22\x47\xa4\x52\xfd\x27\x2b\x04\x79\x5f\xf2\x3f\x9a\x53\x29\x2e\xbe\xe5\xea\x7a\x3e\x51\x23\xf9\x08\x8d\x48\x8f\xd5\xa1\xb5\xf8\x89\x4c\x62\x50\xa4\x30\x60\x33\xea\x38\x7d\x30\xc8\x19\x61\x16\x84\x21\xc6\xec\x44\x3a\x2c\x83\xd3\x65\x52\x46\xa7\xd5\xea\xa4\x28\xc2\x49\xb1\xfa\x80\x31\x50\x1f\x33\x2a\x25\x76\x72\x00\xd1\x24\xe7\xe3\x6e\xaa\x5b\x50\xc4\x55\xb6\x7c\x91\xab\x83\x6b\x0b\x61\x4a\xe6\xd0\x0b\x30\xf6\xba\x1f\x52\xbd\x86\xce\x2f\x9c\x9d\x15\x09\x05\xdb\x66\x1c\xd8\xe7\xbe\xbe\xcf\x0d\x8e\x77\xd0\xe5\x05\xfb\xce\xa9\x1f\xbc\x7d\xc8\x90\x31\xb6\x40\x63\xcd\xb2\xf8\x10\xf0\xe1\xbd\xf4\xe6\xe9\x63\x07\x44\xab\x82\xa5\xe2\xa5\x78\x70\xfd\x7a\xf2\x6b\xe0\x2f\xc9\x5f\x3f\xf6\xf6\xb1\x8d\xd3\x9e\x7f\x69\xea\xf0\x6b\x3a\xb2\x16\xad\xab\x27\xd2\x7b\xff\xa4\x3a\x48\xeb\x1a\x1c\x29\x0a\xa2\x75\x05\xf4\x99\x99\x01\xce\x48\xc9\x0b\x73\x98\xfb\xc5\x3c\x9c\x2e\x40\x19\x1d\x56\xab\x03\x2d\xcc\xc1\xb2\xfa\xa0\x31\x18\x8d\x19\x2d\xff\x8f\x0b\x13\xd2\x02\xba\x35\x00\x2d\x0c\x86\x29\x75\x9f\x39\xa1\xe9\xde\xb6\x99\xc1\x36\x81\x33\x43\x5d\xf1\x7f\xb9\x7e\xa9\x35\x04\xb2\xbb\x8f\x6d\x5c\xf3\x60\xdd\x88\xaa\xcc\xb2\x4e\xed\xef\x15\x1f\xdc\xfa\x11\xd5\xa1\x71\xc8\xe0\x08\x32\x3d\xc5\xd7\xc4\x75\xab\x56\x81\xc5\x20\xbf\xa2\x6c\xd1\x98\xa3\x91\x4d\xe7\x27\x4c\x99\x50\x1f\xef\x8f\x5b\x4b\x48\x62\x3a\x92\xbd\xad\xc8\x9e\xc0\xb3\xd6\x5b\x47\x32\x5c\x5a\x2b\x17\x08\x40\x2b\xcc\xcf\x13\x32\x1a\x62\x9c\xc0\x69\xf4\xd8\xb6\x27\xb2\x1a\xd2\x6d\x88\x94\x0c\x3b\x26\x9d\xf6\x11\x92\x57\x82\xd3\x1e\x7e\x74\xf1\xe0\x20\x9a\x8f\xb2\x98\x19\x92\x10\xca\x9a\xa7\x8d\xb4\x27\xc9\x17\xc5\x7f\x88\x1f\x0c\x5c\x73\x0a\x30\xef\x80\x55\x1e\x71\xfe\x8b\xef\x3e\x50\xd8\xf8\xf9\x32\x60\x05\x01\x7d\xb1\xb8\xe4\xdf\x67\x5e\x3f\xfe\xcb\x9c\xf7\x5f\x5e\x79\x76\x45\x0f\x33\x80\x3f\x4d\x07\xfd\xae\x3f\xdc\x63\x53\x9b\x45\x13\x6b\x23\x5f\x7d\xd0\xb6\xa3\xf8\xb3\xf8\x2d\xf9\xe4\x43\xdb\xe6\xc4\x57\x6e\xdb\xd7\x7d\xfd\xa7\xf8\xfc\x74\x44\x3a\xb4\xb7\x94\x6b\x42\x77\x92\x45\x13\x60\x21\x74\x07\x60\x28\xcb\xeb\x88\xc6\xbc\x5e\x42\xa3\xd1\xf6\x8b\x69\xb8\xf4\xbc\x4d\xb2\x4c\xc0\x96\xf0\xaf\x68\xf9\x7a\xcc\xf4\x33\x3e\x4a\x95\x54\x06\x78\x07\x58\xa0\xe8\x7c\x0a\xfc\xfe\xee\x97\x75\xab\xde\x06\x06\xd0\xdf\x23\x1e\x16\xff\xfd\x50\xff\x25\x8b\x9e\x3d\x5e\x39\x7e\x6c\x8f\x36\x25\xce\xd9\x8d\x47\x5e\x11\x3f\x35\x7f\x7a\x76\x41\x7c\xd7\x84\xa2\xcd\x65\xab\xc4\x3f\x26\x2f\x5d\xb9\x67\x73\xfb\x5e\x41\x9d\x7a\x99\xed\xe1\xf5\x9f\xff\x53\xd6\x67\x4e\x82\x80\x87\xd0\xdd\xe4\x46\xfa\x2c\xd3\xa0\xe7\x18\x8d\x4d\x6d\xb1\x5a\x91\x27\xc5\x41\x0f\x2e\xc4\x50\x69\x05\x6d\x3d\x32\x9b\x8d\x82\xa0\xb6\xc8\x7e\x15\xba\x9e\x90\x5d\xdc\xf2\xa2\x97\xba\xbe\x65\x5b\x59\x9e\x0d\x18\x14\x82\x01\x0b\xba\x4e\xd1\xbe\xb7\x01\x52\xdd\x26\x22\x1b\x2e\x5e\xe9\x5b\x52\xf1\xda\xf1\xd7\x0a\x4f\x90\x0f\xc1\xa3\x7b\x5a\xb7\x3a\xde\x2a\xb4\xe6\x3e\xf2\xdb\xd2\x8e\xad\x46\x5d\xb7\xc0\x1f\x0e\xfa\x04\xde\xb5\x6b\xdf\xd5\xab\x33\xc7\x8d\x47\xf4\x65\xdc\xf8\x15\xf6\x46\x77\xbc\x09\xe7\xee\x80\xce\xc0\xb2\x3a\x15\xd4\xd0\xbc\xc9\x24\xe8\xd9\xba\x98\x1e\x00\x46\xcb\x44\x63\x9c\x96\x25\xa9\xba\x18\x69\x4d\x9b\x5a\x9d\x7e\x7b\xa2\x93\x98\x55\x19\x16\x82\x4c\x50\xf0\x0b\x34\x13\x44\xfe\x58\xa9\xf8\xf9\xcb\x37\x08\xd5\x6d\x4f\x9c\x1e\x67\xaf\x02\x39\x51\x80\x0c\x9f\x2a\xf4\xbe\x3d\xd7\x3b\x35\xba\x61\xbb\x07\x80\x0f\x3c\xd6\xe8\x12\xbf\x94\xef\xf1\xa7\xd1\xde\xe2\xd8\x50\x16\xd1\x35\x92\xc5\x6a\x55\x8e\x80\x27\xa0\x82\xa4\xd9\x62\xc9\x06\x24\x19\xf2\xb9\xfa\xc5\x7c\x56\x81\x20\xcd\x6c\x6a\x38\x88\x90\x83\x41\xf9\x49\xfc\x39\x3e\xb9\xcd\x2d\x82\x40\x4a\x0c\x48\xa5\x05\x49\x7f\xad\x39\xf4\x33\xe7\xb9\xe1\x38\xf4\xd3\xb9\xe3\xb9\xa9\x5d\xa4\xc8\xcf\x9d\xfb\x46\xc5\x42\xad\xe8\xae\x3d\x4f\xcf\xe9\x86\xc3\x3d\xcb\x80\x1b\xf8\x1b\xef\x36\x3e\x2c\xfc\x30\x5f\x7c\x75\x34\x09\xd5\xd3\xc5\x77\xc5\xb7\xea\xf1\x2b\x9f\xcc\x05\x77\x8e\x97\x74\xa2\x13\xd7\xca\x21\xf9\xf4\x11\x45\x68\x15\x99\x39\x3c\xcf\x11\x0e\xbf\x5f\x4b\x68\x8b\x4b\x32\xac\xfd\x62\xb8\x52\x81\x33\x32\xc6\x7c\xac\x2b\x98\x4c\x69\x56\x7f\x6a\xee\x36\x15\xac\x57\xb1\x61\x2b\xcb\x2a\x2b\x78\x25\x50\x8d\x33\x6b\xd9\xca\xb0\x54\xa9\x51\xb5\x18\x59\x7f\x20\x59\x21\x8a\x2f\x70\x67\x41\xc1\x6d\xeb\xde\x5a\xf1\xce\x07\x6b\xc4\x6b\x67\xde\x1a\xab\xab\xdd\xf8\xc0\xb1\x55\x3b\x61\x9b\x6e\x73\xbf\xfa\x1c\xae\x98\x36\x7f\xd5\x33\x23\xe7\x4d\xbe\x6f\x6f\xbd\xef\xee\x4f\x7e\x04\xd4\x23\x7d\xce\x9c\xde\x2f\x3e\xf9\xc2\x13\xed\xab\xeb\xef\x6a\x15\x9b\xe3\x36\x93\x90\x7e\x15\xce\x5a\xb8\xf0\x7e\xf1\xbd\xa5\xf3\x96\x6f\x00\x59\x69\x7d\x37\x2a\xdc\x77\x73\xe3\xc6\x0d\x97\x38\x18\xfc\x13\xc7\x2e\x89\xde\xd2\xf7\x93\x35\xdd\xd4\xc3\x92\xdc\x77\x44\x72\xbf\x5d\x8a\x65\x76\x8b\x84\x58\xb3\x99\xa7\x6c\x1c\x05\xed\x5a\xad\x83\x45\x67\x93\x65\x81\x0e\xa2\x07\x8d\x46\x1f\x8d\x69\x58\x60\x8d\xc6\x80\xa5\x65\x81\x79\xda\x28\x74\x0c\x1d\xac\x94\x39\xe2\x6c\x2b\x52\x9b\x48\xf9\xe0\xa4\xa3\x9f\xbc\x28\x5e\x39\xfa\xc6\x80\x47\xbf\x58\x05\x54\xae\x5f\x1e\x3a\x9b\x01\x66\x39\xc5\x15\xfa\x9f\x80\xe1\x8d\x93\xf7\x01\xed\x91\xc6\xd5\xcf\x3d\xba\xa4\x75\xe5\x37\xb2\x8c\x7d\x8d\xe8\xea\x22\xd1\xd5\x39\x92\xc5\xb3\x9c\x8d\xd2\x9a\x29\xca\xa1\xb5\x9b\x38\x44\x96\x09\x91\x65\x32\xa1\xcd\xd2\x45\x63\x5a\x4b\x32\xb8\x7a\x33\x59\x61\x05\x31\x1c\x59\x8c\xb2\x7d\x18\xc4\xa5\xb9\x15\x95\xc8\x85\xc0\x35\x52\xfe\x03\xc0\xf0\xca\xe9\x01\x0f\x7f\xba\x41\xbc\xea\xfa\xe5\xd1\x93\x99\xe2\x0a\x27\x98\xa5\xf9\x49\xbc\x42\xb5\x7e\xf3\xc4\x52\xf1\xfb\x43\x23\x57\xef\xd9\xb9\xa4\xa0\xfa\x9b\x44\xad\xbe\x4b\xaa\x87\x7e\x5c\xe2\xed\xf9\x44\x5c\x98\x38\x21\xf1\x76\x0a\xd2\xdb\x17\xa5\x7a\xf9\x90\xc4\xdb\xf6\x04\xa1\x7a\x46\xaa\x67\x2f\x8b\x38\x68\x95\x9e\x20\x34\x2a\x68\x00\x3a\x9d\x51\x03\xa1\x4a\x4b\x01\x06\x12\x2a\xa9\x71\x44\x99\xd1\x9c\xee\x2f\xf8\x05\x9c\x3f\x94\x86\x2a\xf9\x01\xf5\xe3\xaf\xf1\xf3\xcb\xc4\x03\xbf\xee\x06\xa6\xbf\x83\x1e\x64\x16\x80\xe2\xcf\xd4\x5f\xe2\x0f\x90\x77\x5e\xcb\xa6\x17\xc5\xb7\x91\xa3\xae\x2e\x90\xe2\x34\x83\xe9\x81\x88\x6f\x16\x8c\xa9\x8e\x91\xf3\x79\x68\xd3\xe9\xf5\x56\x8b\x9a\x36\xb0\x7a\x17\xcf\x58\xa4\xd3\x18\xc6\x2d\x72\x29\x9f\x87\xe3\x41\x41\xa1\xa2\x12\x04\xa1\x54\x49\xe3\x57\x2a\x24\xe9\x81\x17\x9f\x5f\xcd\x65\x89\xda\x4d\x2b\xa9\xc0\xe7\x7b\x90\x43\xac\x19\xa0\x33\x54\x76\x03\xf5\x54\xeb\x6b\xa7\xc9\xf7\x06\xde\x7f\xbd\x1b\x3c\x98\x79\xf2\xda\x32\xfa\xeb\xf8\xcb\xdd\xbf\x89\x3c\xb8\x9c\xdc\x84\x6d\xe8\x19\x4a\x5d\x04\xb2\x06\xf1\x64\xf0\x20\x84\x06\x0b\x4f\x99\xb2\xdd\x2c\x2b\x98\x4c\x21\x56\x30\x0b\xd1\x98\xde\x6c\x36\xb9\xb4\x0c\xc1\x78\xa5\x0a\x09\xfb\x4d\x15\x12\x29\x65\xe3\xcd\xa5\xf0\x29\x65\x12\xd9\x41\x49\xbe\xf0\x54\x5a\xa4\xd1\x6e\x5d\x2d\xf1\xd6\x2c\x4a\xe7\x07\x35\x4e\xf1\x55\x5f\x93\xef\x6e\xe7\xdd\x2b\x94\xb2\x89\xf0\x93\x3d\x52\xcb\x26\xd6\x0d\xd8\xbe\x7c\xc7\x8e\xe5\xe4\x49\xa5\x70\xa2\x43\x3f\xb9\x70\x02\xed\x6b\x3e\xda\xd7\xd5\x78\x5f\x41\x6d\xda\x3e\x87\xf0\x3e\x73\x0c\x61\x22\x27\x91\x23\x52\xde\x17\xc2\xef\x93\x5e\x77\x48\xaf\x4b\x3d\x37\xaa\x5f\xd0\xfb\x73\x70\xce\x41\x1d\x07\x05\x4a\x8e\xcd\x44\x87\xc0\x5d\x06\x4e\xae\xd9\x4e\xe6\xe4\xe4\xf7\xef\x4b\xbc\x5f\x03\xc0\xd0\x44\x9e\x50\x8f\x93\x14\x3b\x38\x63\x6a\x95\xb7\x24\x6b\x87\xd0\xb9\x1e\x8a\x64\x2d\x44\x8c\x8e\x54\x02\x9f\xcf\xef\x50\xa9\x42\x46\x7f\x90\xce\xce\x09\x10\xc1\xcc\x60\x7d\xcc\xeb\x86\xee\xfa\x18\x38\x01\x01\x01\xd1\xf1\x81\x50\x9f\x09\x7d\x7e\x5e\xcf\xd7\xc7\x22\x2c\x40\x86\x91\x90\xa8\xf7\x40\xd2\x81\xa4\x11\xb7\x8e\x24\xf3\x51\xe9\xd5\x1f\x00\xca\xa6\x2b\x0b\xe4\xf8\xbc\xc4\x72\x6c\x0b\x49\xa6\x2d\x85\x33\xc9\xe8\x80\x31\x70\x68\x67\xe0\xdd\xfa\xda\x69\x6d\x56\xf6\xa1\x67\x5f\xbb\x73\x61\x59\xac\xb0\xef\x50\x5b\x36\xa9\x9e\x75\xf7\x10\xf1\xf7\xbe\x1b\x8e\x5d\x11\xdd\x19\xd4\x32\x1c\x6d\x7c\xbc\xcd\x63\x0f\x55\x17\x9d\x3a\xfb\xcc\x92\xd9\x95\xf9\x0d\xd3\xdf\xd4\xb6\x33\xa1\x4b\x84\x8f\xeb\xa9\x6f\xb7\x6e\x95\x79\x02\xa8\xcb\xaa\x5f\xb8\x10\xec\x2a\xf1\x50\x04\x33\x15\x1e\xaa\x10\x0f\xbf\x54\x69\xa8\x94\x3c\x28\x9e\x57\x86\xf6\x62\x1f\xb2\x79\xbd\xc4\xed\x91\x0e\x6e\x8f\xc7\xca\x53\x02\xa5\xf3\xe9\xfc\xbc\xa5\x3e\xc6\xf2\x35\xfc\x0b\x3c\x14\x20\xcf\xcb\xd1\x67\x56\xef\xd5\x93\x06\x28\x05\xa1\x1d\xf5\xb1\x12\x77\xc4\x1d\x75\x2f\x74\x9f\x70\xbf\xe3\x56\xb9\xdd\xd8\xc8\x2a\x55\x38\x93\x52\xf1\x9a\x54\x7d\x92\x17\x53\x2a\x9b\xf9\x99\xe9\x41\x6a\x4a\x12\x4f\xd9\x37\xb3\xa9\x28\x72\xe7\x3e\xf1\xea\xca\xb7\xc1\xe4\xaf\x3f\x04\xa1\xe2\xa6\xcc\xb3\x0f\x7c\x2c\xbe\x53\x41\xce\xf2\xc4\xd7\x91\x1f\x1c\xdd\xf4\x8f\xf1\xeb\xe6\x89\xa7\xcc\xeb\x81\x76\xdf\xbf\xc0\x9a\xcb\x07\xb6\x57\x4e\x59\x2c\x7e\xb3\xa5\xf6\xcc\xdf\x96\x6f\x8d\x1d\x7d\x06\xf3\xa1\x35\x5a\x57\x44\xd2\x31\x15\xb7\xec\x67\xc2\xfd\x01\xba\xd4\xfe\x80\x53\xa9\xfd\x01\xcf\xb4\xec\x0f\xb8\x71\x0d\xdd\xe5\x72\x8f\x5b\xa1\xd4\x9b\xb6\xf1\xc6\x2f\x6a\xb3\x64\x7b\x06\x88\x51\x48\x92\x38\xde\xe5\x72\x66\x20\xb7\x80\x83\xea\x4c\x75\xd0\xe9\xaa\x8f\xf1\xc8\x31\xf8\x85\x07\x2c\xbf\x80\x27\xad\x88\x85\x9c\x93\x37\x71\x1c\xa8\x8f\x71\x50\xa7\x51\x69\xea\x63\x2a\x21\xcd\x1f\x52\x84\x69\x44\x7e\x7e\x8b\x6a\x67\xc9\x14\x91\x4a\x40\xe5\x14\x0f\xef\xc2\xc1\x61\xdc\xd5\x42\xe5\x82\x4a\xbf\xcf\x84\xa4\xc9\x4f\x2d\x10\xc3\xb3\x97\x3d\xf5\xdc\xfc\xd6\xce\x0c\x21\xb3\xfb\xf4\x95\xb1\xa7\x61\xab\x69\xa0\x0b\xd2\xc8\xe2\x65\x31\x1e\x7f\xea\x33\x30\x13\x4c\x79\x70\xa3\xb8\x93\xfa\x52\xbc\x5f\x6c\x14\x77\xad\xd1\x3e\xc4\xac\x07\xfd\x81\x19\x88\xf1\xe7\x4e\x35\xbd\xfd\xd7\x07\x81\x79\xca\xdd\xe8\xce\x47\xe7\x8a\xc1\xbd\x55\x3c\x5a\xdd\xb8\x48\x25\x03\x21\xa5\x43\xd6\x1c\x61\x65\x59\x82\x82\x2e\xb7\x56\xa3\xa1\x9d\x80\x64\xc8\xfa\x98\x4e\xfd\x0b\x03\x58\x66\x01\x83\x56\xc8\x30\x84\x8a\x46\xef\x95\xfb\x42\xf8\x44\xc9\x59\x58\x59\x96\x02\x85\x82\x93\x7a\x37\x65\xf3\x12\x3d\x50\x61\xe8\x17\xc2\xca\xd2\xfc\x59\xca\xca\xa0\x76\x7e\xfc\x77\x1c\x70\x3f\x3e\x8d\xd4\x4f\x3b\x3e\x0d\x58\x94\x35\x89\x7b\x41\x57\x69\x49\x1f\x92\x6b\xe2\xd3\x90\x72\x7f\x8e\x1c\x90\xba\x12\xe9\xbc\xa3\xbb\x25\x84\xd6\x62\xc7\xf5\xdb\x6a\xf4\x8a\xa0\xd7\xab\x00\xa4\x1c\x4e\x96\xe3\xed\x16\x2d\x92\x72\x35\xa1\x8d\x68\xa3\x5a\xc8\x41\xad\x96\xa0\x18\x12\x52\xb0\x1e\x8f\x54\x90\xfb\x72\x94\x53\x2d\xcb\x71\x22\x3c\x97\x76\xca\xfd\xf2\x29\xf6\x43\x65\x8a\x7d\xb2\x87\x9b\x1c\x27\x9f\xdc\xfd\x19\xf1\x9f\x3b\x5f\xdb\x0c\x16\xe8\x26\x1c\x9b\xa8\xfd\x6b\xbf\xcf\x62\xf8\xb4\xa2\xb3\x2c\x9e\xad\xa8\x8c\x7f\x4d\x06\x0b\x4b\x9e\xce\x30\x37\xeb\x34\x2b\xd6\x81\x78\x9c\xa0\x74\x7e\x5f\x91\x7b\x3e\xcc\x34\xee\xf9\xd0\x36\x99\x6d\x42\x73\x57\x89\xb4\x57\xf4\x11\xd5\x2f\x04\x46\xbd\x45\x3e\x90\x46\xad\x26\xf1\xe0\x04\xbd\xd1\xa4\xa2\x05\xc6\xac\xe7\x75\x34\xa3\xe6\x19\xc8\x2d\x34\x60\x04\xdd\xcf\x9c\xe7\xa5\x94\xb2\x54\x86\x23\x2f\x41\x3a\x90\x61\x5c\x13\xca\x00\x1c\x6c\xab\xd4\x00\x64\xf6\xda\x98\x1a\x60\x7a\x6e\xbf\x2b\x00\xdf\xfd\x4c\xfc\x79\xf7\x81\xaa\xeb\x55\xe4\x03\xe2\xc7\xf4\xdb\xcf\x43\x7a\xd1\xf5\xc6\x55\xcb\xa9\x3d\x57\x17\xc0\x5d\xe2\xb5\xa1\xf4\xd5\xcb\x9e\xaf\xcc\xf8\x8c\xc4\xd1\x99\x7b\x83\x29\x43\xb4\xbf\x27\xd1\x7e\x15\x9c\x01\x3d\x24\xdd\x83\x89\x7f\xcc\xe6\x85\x6c\x9a\xee\xa9\x11\xc7\xd3\x67\xa5\xdc\x4c\x4d\xc4\x4b\x93\x3a\x42\xa5\xd1\x10\x24\xd4\x1b\xd4\x0c\x43\xa1\x9b\x9f\x26\x71\xc2\x42\x03\x48\x5e\x87\x1b\x91\xf1\x4d\xdc\x5c\xa4\x93\xae\x68\x05\xbf\x2c\x3b\xe8\x60\x80\x8b\x51\xd1\x83\x84\xe5\x37\x08\x7e\x7b\x19\xb9\x5c\x9e\xa8\x38\x1e\x3c\x44\x2f\xba\xe6\xa5\xbe\xbc\xba\x40\x02\x4f\x6e\xd9\xc3\x8a\xf8\x88\x6c\x10\xea\x1f\x92\x0d\x62\x46\x16\x5e\x2e\x65\x40\xbe\x8d\x9a\x54\xeb\xa1\xc5\xaa\x37\x20\x71\x40\xae\xff\x2f\xb8\x6b\x62\x01\x85\x24\x1d\x79\xc8\xfa\xb4\x2e\xc2\xe6\x93\x9b\x46\x15\x16\x8a\x96\xe7\x14\x44\xe1\x63\x19\x71\xff\x40\xd0\x39\x71\x32\x77\x7c\x92\x38\x99\xf4\xa2\xad\x62\x6d\x8a\xfc\xb6\xec\xad\x4d\xe8\x77\xfa\x5e\x4e\x85\xf5\x3b\xd2\x43\x9d\x10\x0f\xc7\x23\xba\x8d\xc8\x92\x19\x16\x29\xb6\x68\x4c\x06\x96\x80\x24\x67\x34\x92\x84\x41\x43\xdb\x54\x0c\x63\xe5\x4c\x06\x53\x7d\xcc\x68\x80\x16\x16\x10\x6a\x5a\x8d\x96\x43\xf3\xe8\x1b\x12\x2e\xa1\x54\x8f\x2b\xf7\xce\x26\x8b\x89\xd2\xa2\xeb\x4a\x8d\x56\x18\x5f\x56\xb8\xea\x5a\x52\x3f\x88\xe1\x48\x23\x31\xd4\xcc\x17\x26\x37\x45\xaf\xfd\x1e\xdd\x3f\xe9\xfe\x31\x7b\x46\x3e\x0d\x79\x71\xc0\x25\xb1\xe7\xec\xe1\xdb\xfa\x3e\x1e\x3f\x03\x1e\x12\xc7\x93\x55\x63\x40\x03\x72\x8b\x44\xc4\xfe\x0e\x48\xef\x7c\x27\x3e\xdd\x70\x53\x7f\x2d\xb2\xc7\x9e\x47\x3a\xe7\x65\xb4\x8e\x20\xb1\x22\xd2\x45\xab\xc9\x70\x79\xf8\x00\x72\x96\x28\x36\xe8\x71\xbb\x83\x1a\x48\xdb\xec\xf6\x2c\x8a\xa6\x33\xed\x36\x9b\x06\xa9\x51\x8d\x4b\x95\x01\x55\x90\xf5\x23\x83\xb6\x21\xc6\x17\xe3\x9b\x99\xd2\x6a\x60\x20\x18\xa4\xd0\x35\x46\x53\xbc\x5c\x6b\x6c\x52\xea\x8d\x95\x71\x40\xc9\x5c\xae\x5d\xfe\x56\x4b\x27\x4b\x4e\xe0\x28\x80\xdf\x78\x92\x1a\x32\x2d\x43\xd9\x30\x2c\x64\x90\x61\xa4\x99\x70\xbf\x1d\xee\x86\xc1\xed\xab\xe8\x4a\x87\x41\x38\x3a\x30\xc4\x17\x7f\xe7\x07\xf2\xd1\xe2\x11\xef\x9e\xdc\xd0\xb7\xd7\xc0\x9e\xb3\x8f\xcf\xae\xad\x9f\xf8\x10\x50\x5f\x10\x1f\x5e\xdb\x0f\xdc\x76\x49\xbc\x14\x98\x98\x3f\xff\x04\xb9\x91\x65\xe3\x7d\x21\x93\x7b\x10\x6c\x11\xdf\xde\x39\x31\x97\xbc\x3d\xbe\x29\x7b\xf4\x5e\xd0\x4a\x1c\xf5\x74\xf5\xf5\x38\x79\x40\x6f\x8e\xdf\x8e\xcf\x85\x80\xee\x9a\x13\xf4\x26\x22\x97\x98\x1b\xe9\x49\x41\x87\x53\x9b\x2d\xf8\xfd\xd9\x99\x46\x27\x54\xe5\xe5\x67\xb2\x46\xd6\xd8\x80\x5d\x8e\xc9\xec\x36\x96\x44\x3a\xd9\xc3\x3a\xbc\x0e\x52\x7a\x30\x40\x47\x84\xb7\xd5\x3a\x1c\xe8\x26\xaf\x8f\x79\x28\xa4\xc8\x63\x11\x2a\x4a\x91\x48\x64\x9b\x6f\x67\x39\xfc\x86\x67\x9e\xe1\x1a\xfe\x62\xa9\xd7\x98\xa8\x4e\xcb\x36\x48\x77\x74\x72\xec\x4d\x28\x1f\x54\x26\x21\x61\xe4\x88\x9c\x0c\xdb\x88\x1f\x29\x32\xf7\x6d\xf1\x9f\xed\x76\xb5\x79\x61\xf5\xde\xd3\x8f\xed\x18\xe3\xee\xf6\xfe\xab\xab\xa7\x6d\x38\xd9\xfe\xe9\x28\x70\x7d\xb0\xf0\xfc\xa4\xc3\x3b\x66\x6d\x10\xcf\x99\x77\xef\xeb\xba\x69\xfa\xe6\x35\x13\xee\x79\x60\xd1\xca\x91\x93\x67\x2d\x6c\xf7\xcc\x73\x43\xb6\x8c\xda\x78\xcc\x6e\xd9\x39\xf5\xc2\xaf\x4a\xae\xf6\x88\x74\x06\xa3\x91\x12\x3d\x32\xca\x0d\x3a\x24\xa5\xc6\x2e\xba\x81\x3a\x92\xd6\x59\x74\x59\x3a\xa8\x63\x54\x2a\x12\x40\x35\x72\xb4\x7a\xd0\x43\x69\x52\x4b\x3b\xe9\x3c\x1a\xd2\x92\xae\x1e\x31\x45\xe9\x38\x46\x52\x8d\x56\x96\x3a\xc6\x27\x55\xbf\x81\x9b\x34\x5b\x0b\x8d\x96\x90\xcf\x23\x92\x2e\x7b\x53\xd1\x65\xff\x54\x74\x99\x01\xe9\xb2\xbd\x9c\x9d\x60\xd2\x75\x19\xd6\xdb\x88\x76\x81\x18\x10\xc9\xd3\x19\x0d\xbc\x41\x4f\xf2\xbc\xa0\x17\xcc\x8c\x5a\x6d\xd1\x19\x49\x13\x69\x6a\x88\x15\x93\xc8\xf1\xe7\x05\xc1\xa0\xe7\x91\x8e\x53\x3a\xd7\x15\x92\xd1\x3e\xa4\xe6\x37\xd3\x3b\x1e\xc0\x2d\x64\x0f\x44\x6f\x92\xb4\x77\x91\xa4\xcd\x3b\x81\x6e\xc2\x34\xc1\xda\x81\x04\x6b\x2e\x3a\x63\xc8\x66\xa1\x17\x48\x34\x56\x47\xdc\x04\xe0\x38\x93\x5a\x6d\x36\x59\x78\x81\x47\xff\x40\x76\x89\x89\x83\x2a\x9d\x62\x96\x34\x07\x45\xc2\xcd\x59\xe9\xd2\x5b\x59\x22\x20\x48\x3d\x2d\xea\x5b\x9a\x1e\x75\xe2\xcf\x2f\xdf\xc2\xd0\x48\xf4\x33\xdf\xd4\xdb\x9d\xec\xa5\x6f\xd9\x4f\xad\x7c\xff\x02\xfe\x3e\xec\x9f\xfc\x77\xb2\x1f\xba\xa5\x3f\xd9\xb2\x37\x19\xad\x5b\xba\x97\xa4\x75\x77\x8d\x64\x6a\x39\x9b\xbb\x96\xd3\x1a\xf4\x3a\x83\xce\x6c\x64\x59\x8b\x01\xb9\xc7\xc0\x0a\x39\x2d\x61\xd4\x21\x3f\xb3\x39\xdf\x88\xf7\x00\x0f\xcb\x4b\xc7\x14\x20\xf2\x5b\x95\xd8\xf0\x44\x28\xa9\xa0\x4e\xea\x40\xc1\x89\xc5\xcf\x6b\x66\xe7\x0f\xec\x5f\x5b\xd9\xbf\x7e\xb5\x78\xcf\x3b\x20\x97\xb4\x7f\x78\xfd\xdf\x13\x57\xac\x37\xe7\x05\x57\xb4\xc9\x1b\xf7\x0a\x7c\xee\xfa\x2f\x90\xbb\xf6\xca\xfa\xc5\xed\xa5\xfa\xc0\x39\x37\xfe\x50\xe9\xe9\x55\x78\x32\x06\x3a\xe7\x53\x22\xad\x75\x6a\x9f\xdf\x9e\x6b\xb6\xd9\x72\xfd\x6a\x4a\x6b\x45\x36\x96\xc5\x6a\x75\x67\xb9\xd9\x2c\xc8\xc2\xfc\x3c\xb3\x2d\xd7\xd6\x10\xb3\xe7\xfa\xfc\x6a\x7f\x03\x32\xbb\x72\xd1\x1f\x8d\xd5\x22\x20\x95\xf7\xff\xdc\x1f\x8d\x0c\x70\x25\xd0\x46\xe1\x48\xcc\xad\x1b\xa4\x07\x7f\x24\xc6\x1f\x01\x8e\x7d\x8d\x99\x47\x83\x99\xdf\x00\xb8\x45\xfc\xdb\xfe\x89\x05\x47\x0b\xde\xef\xfd\xfa\x97\x4f\xad\xac\x3c\xdc\xee\xc3\x4f\x9e\x58\x5e\xfd\x97\x7f\x7f\xb0\x83\xb8\xb1\xea\xa5\x97\xae\x5c\xde\x71\x83\x58\xfd\xf5\xd7\x6b\xdf\x7b\x65\xeb\xfe\x0b\xaf\x3e\xda\x74\x8b\xfe\x68\x7c\xef\x6f\x4e\xdc\xfb\xe8\xa6\x27\x34\xd8\xf0\xc2\xc3\x35\x35\x1a\x64\x41\xea\xd4\x84\xd4\xc4\x8e\x2c\x49\x69\xa6\x51\xe2\x7a\xba\xc5\xbd\x9f\x85\x2f\x25\xc5\x6a\xa4\xfb\xe3\xab\x08\x9b\x89\xbf\x91\xe7\x7f\x7b\xf9\x37\xe9\x02\x92\xaf\xfd\x6b\x5e\xe9\x73\x2f\x48\x79\xca\x45\x84\x95\x68\x1f\xc9\x20\x04\xc1\x6c\xa0\x69\x9b\xd9\x6c\x27\x48\x16\x99\xb2\x3c\xcb\xaa\xad\x16\xde\x2c\x28\x3d\xe7\x89\x8b\x23\xad\x21\x5b\xb9\xd8\xa9\x64\xfa\xd5\x08\x12\x35\x66\xe8\x48\xfe\x5b\x14\xb7\xbe\xfe\x86\x76\xe2\xb1\x89\xa4\xfa\x9f\x83\xfe\x3e\x60\xe3\x31\xf1\xe7\x63\xe0\xba\xe4\xb3\x91\xc1\xf8\xa7\xc8\x5b\x7b\xd6\x2b\x90\xbf\x5f\x5d\x90\xd0\x19\xcc\x08\x89\x0f\x9d\x22\x3e\xcc\x07\x64\x56\x20\x56\x60\x36\xe0\x52\x08\xac\xe7\xf0\xab\xc8\xce\xd0\x49\xfa\x2d\x8d\x0d\xe1\x96\x80\x2c\xe1\x84\xf5\x8c\x48\xa9\xc1\x5c\x00\x3f\x21\x2e\xe0\x07\xf1\xe7\x04\x1b\xb0\x05\x94\xb4\xbd\x98\x1c\x1a\xe3\xdb\x44\x23\x39\x0c\xa5\x43\x4b\x36\x18\x8d\x84\x9a\xa2\x4c\x90\x33\x1a\x0c\xb4\xbc\x17\xac\x3e\xb1\x1b\x89\xcd\x50\x4c\x85\x54\x32\xc2\xe9\x17\x47\xea\xa6\xe0\xbf\xaa\x6f\xd1\xc6\x5c\x2d\x94\x48\xba\x84\x49\xba\xd8\x72\x77\xa4\x1d\x22\xa5\x73\xfb\x7b\x4b\x1b\x4c\xad\x07\x7f\x62\x83\x41\x3d\x0f\x09\x24\x26\xff\xc3\x06\xab\xbc\xd9\x06\x23\x17\x8b\xe5\x19\xe4\xca\x69\x20\x33\x61\x83\x9d\xfe\x18\x0c\x92\x6c\xb0\x37\x90\x69\x9e\xee\x43\x40\x29\x3e\x25\x4a\x58\x13\xb8\xa3\xaf\x5f\xa4\x90\x62\x59\xa4\xc0\xf5\x6a\x1b\xd2\xe6\x76\x3d\xf2\x8b\x29\x74\xd9\x9e\xa0\x40\x5f\x0a\x7c\x4e\x01\x8a\x42\x24\x23\x13\x9c\x47\x6c\x44\x7b\x98\x10\xa5\xe2\x52\xf9\xae\x9d\x92\xdf\xa2\xac\x0c\xf7\xb3\xe1\xd8\x95\x42\x24\xe6\x9c\x4c\x26\x5d\x84\x78\x26\xfe\x7c\xed\x85\x14\x5b\x11\xf0\xc7\xff\x68\x36\x17\xd1\x85\x55\x88\x69\x45\x8c\xb4\x2a\xe4\x2a\xb6\xec\x21\x44\xaf\x16\x49\x4d\xc7\x48\x26\xa1\xd3\xa9\x8d\x94\x9a\x12\xcc\x04\x8f\x38\x48\x00\x96\x58\x40\x20\x0e\x12\x84\x1a\x69\x0f\x35\xd2\xf8\x6a\x3e\xa9\xf1\x64\x1e\xa6\x84\x6c\x31\x0b\x6f\xa2\x0c\x6c\x05\xd5\x09\x92\x5e\x94\x48\xba\x5d\x22\x69\x5f\x0b\x72\x00\x61\x46\xba\xb7\x27\xbd\x99\xf0\x10\xb3\x22\x3d\xd0\xa6\x99\x38\xa7\x4d\xa3\xb1\x73\x30\xc3\xeb\xb0\xd7\xc7\x58\x47\x8d\xe3\x05\x07\x14\xa0\xc3\x61\x50\x19\xd0\x06\x13\x26\xce\xe4\x33\x45\x4d\x8f\x9b\x68\xbd\xc9\x64\x10\x58\xe8\x85\x37\x20\x34\x40\x88\xed\x1a\xe4\x14\xa8\xd0\x96\xab\x92\x69\x52\x6c\xc3\x20\xd6\xa6\xc7\x1a\x92\xf3\x78\xc3\x89\x26\x92\x6c\xde\xef\xc3\xd5\x2b\xe8\xdc\x2a\x46\x0d\x81\x43\x9b\x95\x65\x21\xa8\x7f\xf4\x93\xb6\xcf\xec\x06\x47\x00\x03\x5a\x9d\x10\x1f\xff\xfb\x27\xe2\x57\xe5\x7b\xf2\x4e\x3f\xfc\x05\x28\x0c\xc6\xd7\xba\xc8\x31\xd4\xdb\xd4\xd5\xa5\xb3\xdb\x82\x11\xe2\x09\xf1\x1f\xd7\xc5\x59\x97\x8e\xbd\xd4\x7a\xe9\x6a\xa0\xfb\x7e\x4b\xaf\x57\x2e\x4b\xfc\xae\xb9\xf1\x23\xf3\x23\x5a\xa3\x99\x08\x10\xdd\x23\xd9\x26\x83\xc1\xe8\xd0\xfa\x20\xd4\x1a\x61\x30\xd3\xa4\x47\x17\xab\xc9\xc8\xb1\xd0\x60\xe4\x19\x77\x7d\x8c\x11\x08\x4b\x3a\x6e\x82\xac\x67\xf2\x5b\xd8\x5f\x29\x58\x2f\x95\x8a\x6f\xcc\x13\x74\x1a\xe4\x0b\xbd\x0f\xa8\x41\x29\xfd\x96\xf8\xc8\x17\xe2\x15\xf1\x12\x14\x3f\x91\xdd\x64\xe0\xe9\x0a\x36\x01\xcb\x61\x31\xbe\xfa\xfc\xc1\x43\x00\xae\x79\x8b\xde\x2c\x81\xbe\xfc\x21\xde\xfd\x3e\x68\x0d\x6c\x51\xd9\x5d\x06\x5e\xd0\x63\xcb\x8b\xe2\xb6\x43\x1f\x7c\x80\x4b\x25\xdf\xf9\x54\xc6\xdd\xd9\x81\xce\xe1\x4c\x24\x3f\x06\x24\xed\xb1\x48\x81\x1e\x00\x83\x4e\x67\x34\xaa\x79\x64\x44\xaa\xd5\x76\x03\x41\xd8\x74\x40\x6f\x41\x0b\xb3\x5a\x2c\xe8\x15\x23\x92\x20\x88\x15\x57\x12\xf4\x45\xd9\x8d\x94\xc6\x61\x53\xb3\xfe\x54\x0a\xdc\x82\x52\xa7\x73\x26\x12\x2b\xa4\x2e\x90\xf8\xcb\xb9\x79\xff\x30\x32\x6f\xd9\x2a\x90\x0b\xca\xc9\xa1\xe2\xcf\xc7\xa7\x88\x33\xe2\xd7\x29\x5e\x6c\x3c\x7a\xf2\x91\x07\xc0\x32\xf2\xb6\x92\xd7\x17\xbd\xff\xee\xd5\x05\x64\xf7\xf8\x41\xea\xef\xf7\xac\x9e\xb7\x18\x63\x18\x21\x7b\xb9\x50\x8a\xe5\x77\x96\xf6\x63\x02\xfa\xf7\x51\xfa\x33\x74\x5a\xb3\x91\xfc\xfb\xf5\x7c\x88\x74\xf0\x0e\x6f\x8e\x37\x37\x84\xac\x65\x1c\xad\xb7\x79\xbd\xbe\x7e\x31\x2f\xb0\x31\xd1\x98\xad\x65\x5e\x8d\x08\xa7\x57\x54\x02\x9f\x52\xdd\x81\x8b\xc9\x43\xd9\x89\x00\x39\x3a\x09\x38\x69\x98\xc5\xa8\x28\x23\xc9\xf0\xe4\x26\xf1\xa3\xa8\x7e\xc9\xdd\x23\x97\x0d\x2b\x9d\xd3\xf3\xe5\x33\x3d\xef\x7f\x67\xa5\xd8\xd0\x7f\xee\x11\x50\x06\x36\x7b\xdf\x10\x77\x3c\xd8\x58\xeb\x5b\x0b\x17\x88\x4f\x95\x46\x37\x3f\xdc\x75\xed\xe5\x01\xf7\x2d\x5d\xf2\xe6\xb1\x19\xe2\xbf\x0f\x0d\x03\xf1\xb5\xa0\xf1\xab\xfb\x87\x56\x3e\xe1\x68\xdb\x71\xd2\x8b\x6b\x81\x46\xd2\x3b\xd9\x37\x7e\x84\xbf\x50\x9d\x11\x57\xdd\xc8\xb2\x89\x45\x8a\x43\x5e\xc1\x4b\xd8\x19\x41\xaf\xa7\x18\x82\xca\xc9\x86\x21\x77\xc8\x5d\x17\x63\x43\x40\x07\x43\x21\x2d\xc7\x05\xa2\x31\x8e\x13\x2c\x5a\x4b\x34\xa6\xd7\x36\x97\x13\xa5\x1d\x8e\x74\x43\x5f\x6a\x5f\xc5\x33\x71\x12\x35\x98\x32\x16\x1d\xb0\x26\xed\x7e\x9f\x6c\xf5\xb3\x00\xfe\xb2\x6e\x31\x18\x3b\xe7\xc6\x77\x5f\x9e\x9f\x5e\xf0\xdd\xbb\x2f\x1e\xbf\x7e\x63\xf6\xf4\xe5\x5b\xe7\x2d\x7d\xe3\x33\xe0\x1e\x3e\xfc\x9e\xfb\xdc\x6a\x58\x7b\xc7\x3a\x2b\xc3\xdd\x33\x62\xd7\xbe\x5c\x72\xe2\xb7\x5f\x2c\xb9\xfe\xba\xb9\xf1\x8e\xe8\xc8\x7b\x4f\x74\xe8\xf5\xc0\xfd\xb9\x48\x1f\x14\xa0\x35\x9d\xa2\xfa\xa2\xf5\x74\x8f\x64\x59\x6d\x99\x1a\x48\x99\xdc\x6e\xca\xa6\x41\xcb\xc9\x34\xa9\x70\xfe\xd9\x21\x44\x63\x0e\xab\x74\xd4\xa3\x31\x15\x77\xeb\x8a\x88\xb4\x93\x22\xf9\x24\x7e\xb9\xf1\x81\x31\x2a\x55\xdf\x36\x95\x5f\xae\xfa\xa8\x94\xf6\x8d\xec\x34\x79\x8e\x77\x73\x1f\x30\x72\xdf\xab\xb5\x5b\x77\x37\xdd\x5e\xf6\xf5\x9c\xfb\xbc\x1b\xfb\x88\x9b\x5e\xbb\x38\xe8\xc5\x3d\xb3\x17\x57\xdd\x01\x4f\x76\xa9\x2b\xb9\xb2\x76\x51\xdd\xd4\xc1\xa5\xe5\x15\x9d\xc3\x0f\xf7\x18\x50\x75\x65\xc3\xba\xa1\xf7\xd6\x17\xfb\xaa\xdb\x87\x6b\x3a\x26\x70\x0d\x0a\xe8\xf3\x84\x13\xc9\x56\x97\x48\x96\x57\x6b\xcd\x82\xd0\x64\x85\xb9\x39\x8c\xbf\x2e\xa6\x65\x19\xe0\xc6\x81\x30\x41\x30\xd6\xc5\x04\x82\x70\xdd\x94\xb7\x95\xa3\x48\x2d\x73\xb7\x52\x41\xb1\xad\x52\x82\x92\xc7\xa9\x3d\xa4\xac\x18\x92\xc8\xc6\x01\xfa\x44\x7d\x31\xf8\xf1\x8d\xaf\x16\xfd\xf5\xc1\xc6\xbd\xc5\x70\xcf\x13\x3d\xba\xe5\x0d\x1e\xf5\x07\x00\xbe\x6a\xf1\x3f\x1f\xce\xdb\xd6\xeb\xc6\xec\x07\xfb\xcf\x37\xff\x74\x66\x1b\xc8\xda\x5a\xd7\xa9\xfb\xa9\x4b\xee\xb9\x7e\xf1\xa2\xf8\xee\xfa\x23\xe2\x67\xe2\xf7\x4b\x97\x83\x8c\x7a\xa0\x9d\x2b\xc6\x67\xdd\xb7\x5e\x8e\x33\x75\x41\xeb\xc8\x96\xce\x8c\x54\x1b\x75\xe3\x25\x74\xe6\xdf\x92\x7a\x49\x57\x46\x6a\x4d\x04\x09\xa1\xd5\x6a\xf3\xf8\x8c\x50\xe3\x76\xbb\x34\x6a\x35\xed\x74\x51\x36\xca\x96\x89\x54\x78\xd0\x66\xb5\xaa\x39\x64\x2d\x39\x69\x0f\x49\x93\x46\x1f\x3a\x68\x75\x31\x53\xb1\x11\x18\xd1\xdb\xd5\xac\x3f\x10\x80\x2e\xb4\xa7\xd0\x82\xaf\x3e\xd3\x7f\x77\xc1\x4d\xcd\xea\xc1\x96\xda\xdf\x26\x43\xc7\x04\x12\xfe\xb7\x2d\xe1\x7f\x93\x92\x0b\x24\xe0\xf4\x0b\x72\x81\xc8\x51\x55\xf9\xe2\xc2\x33\xe0\x2f\xa1\xf0\x83\x2f\xdc\xd6\xaa\xbc\xac\x60\x78\xd3\x70\x4f\x49\x55\x2f\x60\x3c\x21\xfe\x36\xa5\xfc\x87\x97\x5f\xe6\xa2\x8e\xfa\x26\xf0\xad\x59\x64\xc8\xc1\xa1\xa9\xa0\xe7\xcf\x53\x07\x05\xc1\x47\x62\x88\x2d\x18\x08\x7a\x88\x47\x96\x67\xc6\x5f\x02\x57\x19\xa3\xe8\x92\xf3\x69\x57\x90\x7c\x2e\xa4\xfa\x20\xf9\x1c\x19\x29\xe5\xdc\x9a\x4c\x64\x85\xeb\x7d\x99\x6e\x3a\x87\x82\x30\xdb\x67\xd0\x1b\xf4\xd1\x98\xc1\xe0\x20\x58\x0b\x10\xa0\xc5\x22\x4b\x2b\x47\xa8\xa2\x18\xc3\xcb\x2a\x75\xee\x25\x3d\x6c\x69\xd4\x76\x75\x33\xe4\x43\x38\xbd\xd5\x52\xf6\xa1\x24\x18\x10\xc5\xb7\x56\x0a\x41\x24\x39\xb6\x48\x27\x12\x2c\x78\xe6\x8c\x6b\x57\xce\x9b\x53\xe6\x6e\x78\xcc\x7d\x64\x57\x63\xbf\x83\x05\x3b\x42\xa7\x9e\xdf\xf6\x6a\x9f\x95\x03\xc7\xcf\xfb\xce\x3c\x67\x49\xc1\xf6\xf1\xa3\x46\x8c\x58\x36\xba\xa1\x4b\xd7\xfb\xcd\x8b\x16\xad\x9d\xd1\x67\x66\x0f\x0d\xa5\x5f\xd5\xb0\x65\x3f\xda\xe7\x41\x37\x7e\xa2\x7a\x50\xad\xd1\x3e\x0f\x91\xf6\x5d\xfa\x37\xfd\x3d\x1f\xc2\xff\x96\xfc\x5a\x95\x92\x1f\x70\x9b\x42\x60\x92\x37\xdb\xae\x4d\xf3\x6b\x71\xdf\xbe\x06\xc9\x05\x4f\x0c\x8e\x14\x70\xc8\x43\x32\x90\x26\x13\x72\x6e\x79\xbd\xc0\x60\xef\x91\xe7\xf5\xc8\xb9\xe5\x48\xae\x4e\x76\x6e\x0d\x7a\x8b\xe4\xd9\xb2\x09\xcf\xb6\xd9\xad\x95\x36\x3c\xcd\xf2\x91\x53\x8e\xd2\xb6\x0a\xca\xb6\xaa\xd0\xae\xfe\xde\x34\x3c\xd4\xae\x5b\xec\xaa\xb2\x85\xaf\x54\x8f\x1c\xde\x44\xb5\x16\x43\xe6\xb2\x7a\x10\x56\xb6\xec\x37\x8b\x18\xc4\xfb\xf5\x18\x92\xe3\x98\x44\x5f\x55\xc4\x0d\x4c\x24\x67\xe2\xcc\x1a\x8d\x00\x10\x49\x48\x26\x39\x96\xd1\xe3\x94\x19\x2f\x61\x0a\xa4\x20\xb7\x80\x94\x66\x62\xbf\xe0\xd7\x82\xe6\x06\x0a\x5e\xf0\x43\xf2\xe2\x21\x71\xff\xf2\x85\xa3\x27\x0f\xee\x5c\xe0\xf3\x67\x86\x07\xcc\xde\x4f\x6e\xbf\x08\x0f\x8a\x13\xc5\x97\xb6\x77\xe3\xef\x65\x67\x81\x4a\xd2\x75\xed\x74\x92\x47\x52\x2e\xd1\x4e\x34\x46\x4c\x76\x35\x61\x32\x1a\x59\x82\x75\x3a\xcc\x6a\xa0\xd6\xe9\x0e\xdd\xf8\x22\x92\xa5\x33\xd5\x72\x3a\x40\xe9\x80\xce\x6e\x22\x38\xd6\xe2\xd3\x73\xb5\xc5\x16\xe0\xb2\x00\x8b\x56\xcb\x22\xbe\x19\x35\xac\x74\x5c\xc2\xf2\xa1\x40\x36\x18\xfe\x07\x7e\x46\xff\x48\xaf\x57\xc1\x19\xc8\xf6\x30\x91\x82\x14\xd2\x52\x90\xb4\xc1\xc8\xaa\x70\x16\x12\x66\xac\xdf\x73\xb1\x45\x12\xd2\xda\x36\xd2\xce\x8a\xf3\x90\x8e\x83\x71\x07\xd5\x3a\x25\x0f\x29\xef\x73\x8d\x54\xb7\xde\x1d\x63\x8a\x41\x0a\x68\x34\x5a\x0a\xb9\xc9\x1a\x2d\x83\x96\x51\x17\x23\x8b\x01\xfa\x4f\xab\xa2\x2d\xe8\x20\xe8\x9a\xf7\x37\x9c\x38\xd7\xf6\xd4\xb6\x49\x25\xfd\x85\xcd\x7f\x39\x6c\x08\x76\xc5\xc0\xd7\xb1\xa6\x8b\x4d\xf5\xa2\xa7\xbe\xe9\x22\xda\xce\x0a\x70\xf6\xda\x69\xf0\x93\x28\x50\xad\x6f\xd1\xdb\x8e\xe9\x89\x20\x7a\x18\xa2\x24\x62\x83\x04\xad\x22\x54\xc8\x2d\xa3\x18\xaa\x2e\x46\x30\x2c\x8d\xa3\x40\x96\x84\x65\x9d\xe6\xee\xca\xfc\xc1\x1f\x49\x45\x2e\x36\x1d\x12\xdd\x87\xf0\xa7\x5d\x3b\x0d\x0f\x5e\xef\x8e\x81\x03\x12\xf9\x68\x49\xf7\xf5\xbf\x55\x2d\x00\xfe\x6c\x55\x4f\x89\x96\xa8\xf4\xfe\xd5\xe8\xfd\xe3\xa4\x33\x34\x5c\xee\xed\x13\x07\xab\x26\xd1\xe7\x90\x8e\x28\x27\x3a\xe1\xde\xbe\x0e\x56\xb6\xb5\x07\xfa\x8d\x7e\x63\xb0\x40\xa7\x47\x7e\x4b\x20\x0c\x61\xc0\x0a\xbb\x74\x0e\xf8\x5d\x46\x03\x51\x51\xcc\x14\x47\x63\x41\x8f\x96\xa5\x08\x81\xe1\xda\x65\x13\xd9\xd1\x98\x13\xc7\xb4\x95\x10\x8b\x52\x54\x25\x99\x82\xc9\xbb\x01\xbd\x58\x9a\x4c\xe5\xa6\xdc\x12\x78\x0e\x39\x4c\xc0\x94\x28\xcd\x4f\x66\x15\x2e\x9f\x31\x82\x6c\xd9\x48\x49\x5c\x19\xcd\x55\x14\xb8\x97\x66\xda\xda\xc7\xa7\x9f\x7b\x62\xea\xfd\x1e\xda\xdd\xaf\x69\x12\xd9\x79\xe3\xc4\xb5\xdb\xa6\x9e\x7f\x7c\xea\x3a\x0f\x6d\x1a\xb9\x7f\x0a\xdd\x65\x73\x7e\x6c\xfe\x90\xf0\xf4\xc6\xc9\x0b\x7a\x0e\x80\x7b\x66\x3e\xd8\x6f\xc6\xa8\x49\x0b\x7b\x0c\xb0\x1c\x7d\xfa\x3c\x98\x7f\x60\xfc\xc8\x27\xc1\x53\xf1\xf3\x0d\x03\x5f\xd9\x71\x41\x5c\x76\x68\xfc\x48\xdd\x1d\xa2\x9b\xec\x3e\xba\xff\xaa\x7e\x3b\xc5\xfe\xf7\xac\xda\x24\x1e\x9a\x3f\x77\x1e\xec\xbd\x49\x7c\x6f\xc5\xbd\xcb\x1e\x04\x3d\xef\x9e\x3b\x4f\xe2\xdf\x1e\xb4\x97\x6d\x25\xfe\x0d\x93\xf6\x36\x26\x8e\xa7\x7a\xa3\xbd\xf0\x20\x9d\x52\x08\x9d\x46\x83\x5a\xd0\x70\x9c\x4e\x87\x4d\x48\x27\x72\x0c\x04\x8d\xcd\x46\x63\xc3\x4c\xaf\x63\x75\xc8\xbc\xb1\x18\x8c\x2e\xe4\x8e\x7a\x9a\x85\xae\x26\xc5\xae\x69\x36\xf7\x53\xf0\x01\x52\x00\x2e\xb0\x04\x06\xcb\x12\x08\x18\x52\x17\xf7\x93\xf3\x15\x60\x97\xc3\x1b\x27\x3c\x15\xdd\x64\x61\x14\x64\x97\x05\xe8\x50\xcc\x95\x90\x5d\xc8\x91\xd7\xbb\xc7\xbf\x05\x0f\xe9\x96\xe6\xca\xc0\x2e\xe4\x1a\xf9\xac\xaf\x40\x02\x10\x97\xea\x2d\xaa\x22\x2e\x68\x36\x6a\xb5\x3a\xb3\xce\xee\x30\x9a\x4c\x2a\xdc\xbb\xad\x37\x58\x74\x5a\xad\x2d\x55\xfd\xa5\x07\x63\x12\xc4\x25\xca\xb4\x83\xcd\xd5\xc4\x60\x5d\x27\x7d\xef\x3e\x55\xd3\x47\xdc\x86\x8e\x49\xac\xdf\xa6\x7e\xf7\xae\x36\x76\x46\x07\x65\x57\x45\x6e\x87\xb6\x3c\xba\x6a\xd1\x71\x39\x9f\x57\xb0\xf4\xee\xaa\x76\x78\x08\x08\xc0\xba\x5c\xaa\x31\x2f\x24\x46\x44\x4a\x42\x5e\x07\x28\xd0\xf0\x5a\x96\x35\x1a\xb5\x3a\x5d\x81\x17\x16\x15\x3b\x90\xe5\xe8\xce\x8d\xc6\xdc\x56\x2b\xa2\xce\x6a\x35\xb2\x96\x60\x20\x80\x08\x2c\x4c\x10\xa8\x70\x33\xd9\x5e\xd9\x92\x99\x37\x13\xac\x62\x9a\x99\x79\xcb\x82\x7b\xca\x30\xcf\xd1\x6b\xd0\xf4\xe7\x5d\x33\xf7\x3f\x6d\x16\x76\x23\xe6\x76\xdf\x38\xf6\xee\xb5\xc6\xe8\x93\x13\xe5\xf2\x73\xfc\xdd\xe7\xdc\x33\x11\xaf\x97\xcd\xaa\xec\xd9\xf7\xf4\xe3\xe4\xf0\xeb\xcf\xd7\xdf\x87\x58\x3d\x75\xe8\xac\x29\x0b\x26\x24\xca\xce\xf1\x37\x5f\x7b\x9c\xac\x97\xf8\x3e\x48\x1c\xaf\x5a\x81\xd6\x5a\x4c\x4c\x8b\xb4\xb5\x71\x5e\xad\xbb\xa8\x30\x1b\xe6\x10\x44\x7e\x7e\x4e\x6e\x6e\xa1\x9b\xa3\x4a\x5a\x15\x16\xb9\x72\x73\x72\x84\x0c\x8f\x47\x0b\x0d\x66\x81\x35\x38\xd0\x55\x6d\x95\x8a\x92\xac\x05\xf9\x44\x3e\xba\xa2\xa4\x7b\x40\x11\x9e\x84\xf7\x85\x63\xfe\x89\x44\xc1\xcd\xc2\x24\x5f\x11\x7f\xb6\xe4\xb4\x16\x03\xb9\x06\x1f\xef\x29\xcd\xa3\x65\xd7\x3e\x9c\x58\xf6\x66\x69\xd9\x3b\xf1\xaa\xa5\xe5\x4f\xdd\xef\x46\xcc\xe1\xb1\xf0\xa1\x55\x4f\x19\x96\xbe\xea\x2d\x78\xd1\xca\xf2\x9f\xc2\xbc\x69\xc4\x92\x88\x7b\xd8\x90\x8e\x5c\x88\x78\x60\x40\xd2\xd7\x3d\x12\x12\x08\xad\xd1\x48\x33\x34\x01\x1d\x76\xad\x0d\x19\x9f\x5a\xa8\x56\x31\x6a\xa6\x2e\x86\x8c\x30\x23\x07\xb9\x68\x8c\x86\xd6\x5b\xf4\x89\xb7\x88\x90\xc8\x66\x3f\x8e\x93\xa4\x19\xfe\xd4\xc2\x7f\xfd\xfa\xd5\xf9\x26\x71\x87\x93\x64\x63\x87\x2e\x7f\x1a\x2f\xc5\xd6\xfe\x3d\x4b\xde\x00\x7d\x9f\x7f\x29\x17\x3e\xb9\x58\xac\xd8\x20\xee\x44\xe6\xfd\x90\x41\x48\x27\x86\x90\x9f\xff\x32\xa2\x0d\x22\xc9\x72\x10\x3d\x22\xd9\x80\xb4\x50\x7a\x8e\xd3\x68\x28\x12\xba\x9c\x1c\xcf\xf0\xc8\x27\x71\xd4\xc5\xf4\x7a\xa0\x61\xac\x48\x42\x49\xc0\x42\xf9\x5a\x4e\x86\xda\xf2\xd3\x7a\x50\x12\xb7\x73\x18\x2a\x24\x86\x5b\x10\x58\x76\xb1\xe9\xa2\xf8\x3e\xa6\xf2\x42\x53\x1a\x85\x58\xdf\x4b\x54\x52\x59\x29\x44\x4a\xbe\x21\xa2\x13\xbe\x22\xdd\x73\x16\xa2\x22\xe2\x32\x11\x7a\x9a\xa0\x6d\x56\xb5\xa5\x2e\xa6\x56\x43\x46\xc5\xea\x8d\xd0\xd8\x82\x71\x2d\x26\xce\xdf\x9a\x1a\xf8\xca\x2d\x08\xb9\x15\x11\x80\xd0\x20\x1a\xf6\x49\x18\x7a\xf3\x22\x7d\xb5\x1a\x87\x93\x13\x04\xe4\x44\x38\x35\x94\x27\x43\x40\x86\x14\x2b\x20\x7f\x4e\x10\x18\x82\x31\x20\xf7\x41\xcb\x69\x1b\xb4\x77\x69\x17\x6a\x4f\x68\xdf\xd1\x7e\xa1\x55\x23\x2d\xc9\x58\x71\xb2\xe7\x6d\xc7\xe7\x0e\x4a\x0b\x1d\x11\x4e\xa8\x75\x38\x08\xa9\xba\x8b\xfb\x3f\x04\x46\x92\x1b\xaf\xdc\x1f\x3e\x28\xa7\x79\x94\x88\x88\x6c\x85\x92\xc1\x13\x6f\xaf\xfc\x6d\x87\xb8\xa3\x70\x87\x30\xbb\x7e\xf9\x76\x9f\x38\xd5\x01\x56\xa8\x66\xdc\xfe\x97\x8a\x9d\xc1\xbf\x51\xbd\x3f\x38\x7b\x41\x7c\xe9\x19\xd0\xd9\x7d\xe7\xa4\xa6\x57\x16\x0f\x59\xb6\xf4\x94\x6f\xdd\x16\xc4\xdf\x00\x92\x83\x53\x68\x6d\x66\xc2\x8f\x3c\xd6\x12\x0b\xe1\xe2\xd4\xac\x4e\xa7\xd7\xab\x09\x18\x0c\xf0\x88\x46\x9e\xd3\x68\x59\x6d\x5d\x8c\x53\x8a\xe6\xf4\x46\x03\xab\xd3\x5b\xe8\x0c\xc4\x75\x6b\x8b\xa2\x81\x66\xff\x35\x15\xbd\x0b\x6f\x01\x29\x9f\x43\xdc\x1f\x87\x77\x82\x47\xde\x1f\xc3\xa5\x54\x0d\xd2\xa7\x7a\xac\x3e\xb3\xf4\xf0\xfb\xf0\xcb\x7a\xac\x4d\x3f\x1a\x07\xb6\xbd\x76\xf1\x95\x4f\xe7\xac\xef\x3b\x65\xd2\xec\x55\x7d\xc9\x67\x17\x8b\xdf\xbd\x36\xfa\xa7\xb3\x3d\xb0\xfd\x81\x6c\x91\x4f\x2f\xbf\x09\x32\xd6\x8a\xdf\x2d\xd9\xb8\xf5\x3e\xc0\xc9\x71\x90\x77\xd0\xbd\xe5\x41\xb2\x62\x44\xe7\xad\x7f\x24\x97\x80\xc8\xe0\x32\xb2\xac\x4e\x60\x74\x8c\x03\x87\xfe\x20\x61\xb4\x21\x3f\xcf\x66\x03\x3a\x1d\x5b\x17\xd3\xb1\x7a\x1c\xf1\x4b\xd8\x25\x29\x01\x85\x9b\x51\xac\xe4\x9e\xde\x20\x28\x22\x71\x23\x3a\x32\x57\x5c\x40\x99\xb3\xe0\x27\x19\xf1\xa1\xb7\xc1\xbd\xad\x86\xb6\xfe\xee\x0a\xc0\xc4\x37\x7c\xf9\xe8\xb2\xdb\xea\x80\x0a\x9c\x45\x84\x7e\x68\xec\x3b\xad\xdb\xce\x1d\x48\xc0\xcf\x82\x5f\xc7\xdc\xd1\x63\x58\x8a\x3f\x47\x7f\x83\xec\xfa\x5a\x09\x33\xa1\x13\xc8\x53\xf0\x0f\x42\xa6\x10\x59\x12\xc8\x62\xad\x69\xb5\x53\xf2\xfb\xe7\x26\xdf\x3f\x91\xf8\x55\xae\x9d\x82\xa4\x1f\xc3\x3f\xde\x91\x15\x94\x7f\x22\xa5\x76\x0a\xe3\xaf\x19\x90\xdd\x93\x4f\x8c\x8f\xb4\xf1\x3a\x4c\x26\x2b\xaf\x0b\xf1\xa1\x82\x42\xb7\x60\x15\xea\x90\xcf\x1e\x44\xf2\xea\x45\x3f\x07\x7e\xb6\xde\xb0\x92\x44\x90\x0b\xfa\x82\x50\x03\xad\x41\x6b\x90\xb7\x11\x26\xde\x42\xa0\x6b\x3d\xd1\x4b\x87\x8b\xa7\xaa\x65\x44\x83\x29\xa6\xea\x16\x0d\xfd\x72\xf8\x4e\xf2\x00\x2b\x65\xcd\xda\x0c\xd5\x16\xac\xc4\xa8\xae\x7e\xc6\x8f\x9c\xa4\x66\xb4\x36\x23\x20\xbb\x55\x75\xb7\x95\x79\xdb\xb4\xe1\x57\x4a\xd7\xfb\xa4\xfd\xdf\x2f\x76\x2c\xf6\x34\x79\x40\xa1\x43\xbc\x94\xef\xa6\x95\x5b\x7e\x83\x17\x19\x74\xc6\xfb\xd4\x03\x86\x93\x67\x64\x18\xb7\xb3\xd4\x4b\x8b\x37\x6e\x5c\xfc\xc9\x9d\x66\xf9\xb2\x8f\x5b\x1e\x5b\x8a\x64\xd9\x8f\xee\xfa\x05\xca\x7c\xde\xc6\x88\xfe\xb8\x0e\xdc\xa5\x03\xef\xe8\x7e\xd1\x91\x3a\x3c\x09\x5f\x9f\x5f\x54\xfb\x82\x0e\x34\xe8\x16\x2a\x2f\x78\x9d\x9e\x5a\x09\xee\x1a\x6a\xf4\x1a\x03\xab\x06\x38\xba\x4a\x47\x68\xe4\x89\xd0\xac\xec\x0e\xa3\x95\x3b\xed\xdc\x67\xb8\xb7\x25\x59\xe4\x43\xe4\x4f\x99\x92\x3f\x65\xea\x54\x05\x0c\x5b\xa8\x01\x18\xb4\x1d\xf2\x0e\x71\xe3\xc1\xa6\x77\x0e\xc0\xf8\x65\x5a\x5c\x49\xb5\x5e\x8c\xed\xd7\x59\xca\xe0\x5f\x42\xc1\x0d\x81\x9f\x23\x5f\x35\x83\xb8\x37\xd2\xd1\xc4\x41\xca\xe6\x74\x6a\x34\x76\x8a\xa3\x7c\x5e\x9b\x13\xe9\x11\x24\x97\xd0\x66\x53\x19\x0c\xb8\xf1\xc6\xe4\x35\x15\x9b\xde\x36\x7d\x6e\xfa\xd9\xa4\xd2\x40\x53\x84\x15\x6a\x4d\x26\x03\x87\x83\x2c\x04\xe4\x20\x09\xf1\x7c\x67\xb3\xad\x16\x3f\xbf\x64\x34\xe1\x58\xab\x0c\x60\x98\xaf\x54\x74\xe5\xd7\xff\x37\x6d\x22\xa1\x18\x92\xfe\x66\x33\x55\xe9\x06\x90\xcb\x5a\xad\xe0\xdd\x86\x15\xa5\x5b\xa6\x89\x87\x8f\x5c\x58\xf1\x8f\xbd\x3b\x5f\xd3\xee\x55\xdd\x3e\x64\xd5\xb6\x6c\xb0\xd1\x29\x4e\x53\x8d\x9d\x73\xd7\xcc\x72\xf1\xd5\xbf\xbc\x71\x1c\x0c\xdd\xfd\xcc\x26\x47\xc3\xc4\x67\xf6\x2f\x2e\x2b\x5e\xb8\x54\x92\x55\x1a\xad\xf3\x03\xaa\x27\xb2\x1f\x07\x49\xff\x46\xfb\x02\x7e\xa7\xcf\x71\x21\xe2\xca\x19\xc2\xa4\x22\x1f\x39\x43\x10\x1f\x1d\x46\x6a\xf5\xc4\xfe\xaa\xaa\x5a\x0d\x5e\x47\x65\xa5\xfc\x5c\x51\x21\x3f\x97\x97\xcb\xcf\x65\x65\xf2\x73\x38\x2c\x3f\x97\x96\xca\xcf\xad\x5a\xc9\xcf\x25\x25\xf2\x73\x71\xb1\xfc\x1c\x0a\x49\xcf\x91\x5c\xbf\xbf\x56\x13\xf1\x78\xd0\x83\xdd\x8e\x1e\xcc\x66\xf4\x20\x08\xe8\x81\xe7\xd1\x83\x4e\x87\x1e\xb4\xda\x5a\x40\x10\xca\x4f\xe3\xe7\x48\x26\xfa\x71\x22\x12\x08\xa0\x07\x9f\x0f\x3d\xa0\x9f\x27\x22\x0e\x27\x7a\x10\xac\xb5\x04\x58\x43\x29\x55\x66\xa6\x7c\xf9\xbf\xf2\x72\x90\x7f\xf3\x7f\xd2\x9a\xd1\x23\xf9\x14\x3d\x17\xaf\xf9\xa2\x84\xa1\x72\x96\x20\x86\x1e\x26\x0c\x32\x8d\x06\xfc\x69\x55\x88\x46\x03\xfe\x0c\x03\xa6\xd1\x10\xb1\xd9\xd0\x03\x22\xd4\x80\x09\x35\x60\x42\x0d\x98\x50\x03\x26\x94\x04\x14\x46\x52\x59\x93\x56\xe7\x06\xd2\x3f\x33\xbd\x26\x1a\xe9\x43\xe4\x6b\xab\xde\x41\xfa\xd0\x49\x64\x12\xc3\x22\x25\x3e\xc2\xe6\x72\xd1\x8c\xc5\x82\x2c\x90\x90\xd1\x98\x65\xcb\xc4\xaa\x10\x5a\x54\x8c\x05\xd9\x20\x56\x0b\xab\x37\xa1\x2b\xdf\xea\xf2\x40\x4f\xfa\x85\xda\x12\x40\xf5\xa6\x6a\x37\xc5\x22\x69\xe9\x95\xa7\xdd\xb7\xaa\x77\x64\xf3\x24\x9a\xee\xa6\x43\xd5\xad\x6c\x95\x74\xbf\xbd\xa5\x4d\x80\xee\x2c\x55\x36\x5a\x97\x20\x75\x07\x97\x39\x68\x60\x36\xf3\x5a\x1c\xc6\x37\x6a\x69\xe8\xcd\xf0\xe8\xf4\x26\x7d\x5d\x8c\x07\x4a\x3d\x35\x61\x30\x22\x89\x56\x5b\xa3\x31\xad\xda\x8a\xae\x31\xa1\xd9\xdc\x6f\xb6\x18\xf0\xed\x75\x53\x49\x68\xd2\x03\x48\xe0\xb2\x64\xcb\x35\x35\xc8\x51\x86\xcd\x76\x0d\x8f\x97\x80\x57\x37\x4c\xec\x21\xdd\x5e\xe0\x40\x8c\x4a\x9a\x36\x88\xfa\x75\x68\x51\xe0\x2f\xca\xcd\x75\xf6\x7a\xcf\xe4\x5a\x64\xbf\x19\xeb\x68\x3f\x31\x29\x52\xe3\x36\xb8\x32\x08\x9e\x32\x3b\x9d\x0e\x87\xdd\x2e\x98\x0d\x2a\xb3\x2a\x10\x84\x6c\x34\x96\x61\xb1\x23\x8b\xc7\x65\x27\xf0\xd1\xf7\x41\xc8\xda\xc1\xcf\xf6\x1b\x76\x12\xda\xa1\x5d\xe3\x20\x04\xb3\x59\xab\x49\xdc\x63\x92\x9a\x1e\x31\xe5\x96\xb8\x33\x72\xa4\x4e\x0a\x22\xdf\x72\x86\x49\xaa\xae\x06\xb3\x64\xfd\x3b\xeb\xc0\xcc\x3f\xd1\xcf\x31\x45\xfd\x3e\x42\x8e\x68\xa9\x98\x15\xbf\x9c\xd2\xe0\x3b\x0e\xfe\x20\xdd\x59\x33\x41\x37\x25\x76\x25\x98\x42\xe0\xbc\x60\xe5\xd3\xf1\x96\xe5\x58\xd7\x37\x89\x58\x17\xba\x13\x3b\x2a\xef\x47\x57\x1c\x28\xf2\xf8\x52\x63\x5d\x09\x3f\x5f\x8a\x8d\x0d\x97\x63\x63\xc4\xe7\x29\x98\x40\x8f\xba\x82\xa4\x90\x12\x1b\x23\x91\x4f\x32\x1d\xc7\xd6\x90\xcd\xeb\x25\x46\x47\x4a\x19\xb7\xde\x62\xe4\x79\x13\xb2\x0c\xdc\x48\xb3\x1a\xdd\x46\x9f\xdf\x42\x39\x16\x00\x40\x00\x74\x15\x00\xc2\x11\x71\x68\x70\x68\x1b\x5d\x84\x46\x83\xc1\x4b\x25\xe1\x10\x53\x6e\x05\x1c\x30\x4c\x36\xfc\xf1\x89\x04\xbe\x1c\x02\xc0\x46\x42\x1a\x72\x63\xba\x5b\x4b\xea\xbb\x3d\x35\x38\x94\x70\x6d\x15\xdf\x4b\x71\x6c\x3b\x8b\x87\x40\x2d\x35\xbf\xd9\xbb\x95\x1d\xae\x74\xdf\x76\xf2\x8d\x1f\xb5\xad\xe8\xcd\x44\x6b\x62\x78\xa4\xa4\x2c\xb3\xc0\x44\x42\x48\xe8\x6c\x36\x22\x13\xb6\x69\x9b\x01\x80\x2f\x37\xb7\xb8\x3e\x56\x98\x4b\xf9\x2a\xeb\x63\x3e\xc1\xad\xaa\x8f\xb9\x05\xce\x6c\x36\xd6\xc7\xcc\x54\xb2\x94\x35\xa5\xcb\x8a\x50\x40\xa9\xd2\x1b\xb5\x31\x72\x39\x36\x38\xdb\x03\xbe\x39\xe8\x29\xa5\xe7\x54\x54\xd0\x97\xad\xf2\xcb\xc5\xc1\x52\xdb\x9f\xd4\x5d\x9b\x40\x04\xa9\xa8\xa4\x76\xf6\x3e\xde\xa7\xed\xb9\x05\x2b\x7f\xd9\x33\xec\xec\xe1\x7d\xeb\x87\x0f\x3f\xbd\x12\xe8\x41\xc1\xec\x8f\xc5\x73\x2f\x8b\x7b\xf7\xfe\x28\x1e\x79\x49\xfc\x7d\xed\xf4\x4b\x20\xfb\xe0\xa2\x97\xfa\x4c\x19\xdf\xb4\xf4\x93\xc7\x07\x7d\xf6\xc6\xe2\xef\x47\x82\x52\xb0\x42\x9c\xd2\x67\xc0\xb4\x77\x80\x75\xd9\x89\x77\x27\xac\xea\x50\x2d\xbe\x2f\x5e\x7f\x4e\x7c\xfa\xf7\x45\xfb\xf7\xaf\x05\xea\xe7\x1f\x03\xc3\x7e\xbd\xa7\xaa\xdb\xd2\xf1\x13\xde\x10\x7f\x5d\x70\xe6\xfb\xc1\xfd\xe5\xbe\x0f\xea\x22\xda\x63\x33\x46\x2d\x34\xf1\xbc\x59\x80\x80\x34\xb2\x1a\x96\x14\x28\x0b\xa3\xd7\x5b\x39\xc0\x6b\x48\x81\x65\x29\x82\x97\x03\x78\x72\xf3\x76\x6a\xb8\x37\x61\xb5\x66\x09\x30\x2c\x48\x1d\xa9\x61\xab\x85\x03\x41\x1d\xc0\x48\x97\xd1\x6f\xb3\x77\xb7\x7d\x72\x83\xe1\x69\x93\x58\xb5\x2d\xf8\xf9\x13\xcb\xf6\x9c\x05\xcf\x81\x53\xd7\xd7\x7c\x06\xee\xd8\x5b\xd6\xb9\x55\x57\x71\x4c\xfc\x23\xf0\x88\x78\x1b\xa2\x82\x24\xc6\x11\x04\xfd\xa0\x52\x9b\x3b\x20\x92\x0f\xac\x56\x35\x61\xe0\xf5\xb8\xbf\xc9\xa8\x57\xeb\xdd\x2e\xca\x59\x1f\x83\x52\x85\x18\xc1\x52\xe8\x8f\xde\x04\xf5\x82\x84\xd6\x9e\x68\x2d\x4a\xd4\x89\xe4\xa7\x02\x3f\x34\x87\x4e\x70\x21\x76\x22\xe3\x8b\xbd\xc2\xca\x64\xd6\x97\x3c\x05\x36\xb9\xc5\xdb\x0b\x53\x72\xbf\x6f\x89\x0b\xdc\xe0\xde\xbc\xe6\x04\x30\xb5\x7b\xe3\xf7\x38\x05\x4c\xd9\x36\x7e\x98\x9a\x93\xc6\x7e\xc1\xbf\x91\xad\xa2\x21\x42\x88\xee\x42\x33\x11\x72\x6b\x69\xbf\x5f\x1b\xb2\x70\x74\x76\x0e\x41\x66\x92\xd1\x58\x28\xd3\xea\x76\x38\xb4\xfd\x62\x0e\xce\xa3\xa9\x8b\x59\x04\x8f\x87\x13\x58\x4e\x01\x7f\xe0\xab\x93\x81\xf5\x9a\x70\x0b\x47\x11\x33\xb7\xd9\x13\x0b\xc8\x98\x78\x18\xd1\x4c\xb6\x0f\x6d\xcd\xfa\x16\xe6\x29\x8a\x74\xf8\xe4\x57\x56\xb8\x27\x35\x3d\xe9\xe0\x77\x07\x55\xb7\xbf\xbb\xdc\x79\x47\x60\x04\x52\xbb\xff\xfc\xed\xab\xf3\x4b\x25\x7d\x0a\xce\x8e\x3f\x30\x3e\x7e\x0e\xb6\x5f\x39\xf5\xd3\xa5\x77\x68\x68\xb1\x44\xd2\xbb\xb8\x76\xe2\xc6\x8f\x4c\x47\x74\x4e\xb2\x88\xdb\x22\x15\x0e\x8f\x87\x72\xeb\xf5\x3a\x2d\x15\x74\x52\x6a\x2a\xc4\xf3\xd9\xac\xb5\x1e\x63\xa2\x50\x0e\x77\x7d\xcc\xe1\xd0\xe9\xd0\x39\xd1\xe9\xd4\x18\x64\x24\x80\x54\x98\x4f\xa9\x30\x92\x93\x5a\x89\x06\x73\xbb\x02\x14\x9d\xd2\x24\x94\x52\x89\x17\x22\x25\x4f\x07\x60\x4f\x87\xf0\x27\x8a\xe6\x89\x44\xd1\xbc\x4f\xb0\xa9\x28\x6a\xf4\xce\x3f\x16\x92\x17\xe6\x1d\x07\xfc\xf1\xd9\xaf\xb7\x01\xab\x81\xf9\x4d\x60\x29\x68\x0a\x1e\x5e\xf6\xa6\xf8\x5d\x09\x39\xc4\x15\x7f\x8e\x3c\xf9\x1c\x10\x9e\x5d\x37\x5d\xbc\x6c\xde\x00\x0c\x7b\xba\xc4\xef\xa5\x17\xc5\x37\x83\x00\x18\xf1\xd2\x53\x95\xd3\x16\x89\x37\xbe\xc4\x45\xf4\x20\x88\x8b\xe8\x25\xec\x6b\x7a\x26\xda\xb3\x2c\xa4\xdd\xca\x33\x82\x41\x13\xc7\x6a\x28\xaf\xc6\x40\x85\xec\x36\x5b\x36\xc6\xbc\xc6\x60\xd7\x7e\x1d\xa7\xab\x8b\x65\xb0\x1c\xba\x1b\x39\xce\x60\x64\x0d\x96\x44\xee\xce\x9a\xb6\xcc\x94\xfa\xe9\xe2\x14\x04\x07\x45\x2b\x34\xdb\x8f\x09\x9f\x2e\x15\x27\x26\x61\x46\xc2\xa9\x23\x96\x15\x21\x33\xf2\xe4\xc1\xb3\xf0\xe5\x91\xe8\x6e\x1c\xf6\x52\xb9\x78\xe9\xa9\x13\xda\x17\x34\xe3\x06\x2e\x7b\x24\x0b\xdc\xeb\x14\x97\xa8\xc6\xcc\x99\x3a\x5d\x32\x27\x07\x8b\x19\xe8\x8e\xcc\xff\xe5\x3f\xbb\x36\x3b\xc6\x8c\xdb\xbd\x4f\xb1\x29\x71\xef\x3a\x3a\xd7\xdf\x4b\xb5\x37\x66\xa2\x6b\x24\xa0\xd5\xe9\x08\x93\x46\xc3\x11\x8c\x8a\x50\x59\x91\xde\xb3\x68\xa4\x92\x38\x8e\x83\x7a\x0a\xea\x18\x69\x6e\x4d\x22\x4f\x4f\xa4\x57\x84\x25\xcd\x96\x20\x1e\x6a\x22\x55\x85\x06\x81\x91\x84\x7e\x18\xca\x26\x87\x1d\x16\xcf\x9c\x87\xd1\xcb\x20\xf3\xc8\x84\xa3\xe3\x5e\x00\x7d\x61\xdb\xf2\x0f\xc0\xde\x8e\x46\x1d\x69\x8e\xff\x88\x2b\x38\xf0\x33\xf5\x2b\x33\x75\x94\xb8\x01\xc4\xba\x0e\x92\x69\x83\x1b\xa4\x18\x85\x11\x57\x2a\xe9\x91\xdf\x49\xab\x00\xa1\x22\x34\x9c\x86\x85\x8c\x91\x89\xc6\x8c\x46\x8d\x41\xcb\xd2\x40\xbe\xa4\xd3\xe8\x4a\x90\x25\x47\x4f\x24\x6a\x04\x49\x76\x74\x24\xdc\xf0\x64\x97\xe9\xdd\xb6\x77\xbb\xeb\x9d\x97\xc8\xbb\x77\x85\x7a\x7c\x05\xee\x12\xef\xc7\x7f\xa9\xd6\xf1\x63\x60\x83\x38\x49\x3e\xab\xb8\x3e\x6f\xbb\x54\x2f\xe7\xc6\xdd\x6e\x0e\xad\xd6\x2e\xd5\x64\x1b\xd0\x85\x80\x38\xe4\xc9\x30\x6a\x79\xc8\x37\xc4\xec\x10\x9a\x69\x08\x20\x87\x9c\x7b\x29\xf3\x5f\x5a\x83\x03\x9e\x2d\xac\x9e\x70\x73\x75\x52\x82\x3b\x02\xe6\x94\x1f\x26\x98\x54\x83\x24\x76\x2d\x98\x04\x0e\x26\xb8\x34\x0e\x31\xed\x02\xe8\x20\xbe\x3d\x1e\xde\x48\xf2\x0b\x49\x6a\x0e\xf9\x17\x99\x5f\xd2\x5f\x4b\xfc\x87\x34\xbe\x49\x79\x98\x1c\xc9\x8e\xb3\x12\x3d\x23\x39\x02\x61\xd6\x6a\xad\x12\xe5\x16\x99\x74\xb5\xcd\x2e\x91\x1e\x8d\x59\xd1\x0e\xd3\x80\xc5\x94\x5b\x64\xca\xc3\xb7\xa6\x5c\xa2\x5d\x90\x68\x17\x92\xbc\xc4\x08\xcf\x3a\x10\xb8\xd8\x74\x17\xf0\x83\xfe\xbb\xde\x7b\x2a\xc1\xd5\xbf\xfc\x58\x0b\x07\xf7\xf8\x0a\xb3\x93\xec\x88\x5c\x74\x85\xbd\x60\x8a\xb8\x0e\xfc\x5b\x61\x30\x89\x24\x8e\x50\xdd\x83\xf8\xeb\x42\x9e\x5b\xbf\x48\x7e\x06\xeb\x30\x70\x84\xdb\xe3\x72\x69\x21\x74\x73\x0e\xa7\x45\xe5\xf5\x19\x38\x07\xd7\x10\x73\x13\x0e\x87\xc5\xe9\xcc\xa8\x8f\x39\x21\xcb\x58\x64\x21\x4c\x14\x57\xa4\x2a\xc1\x70\xc2\x7a\xc6\x72\x88\x13\x87\x2c\x08\xca\xf8\xb2\x52\x84\x19\x03\x14\xf3\x44\x16\xc0\x75\x16\x54\xd7\x8f\x2e\x5b\x7c\x4d\xf9\x9a\xa3\xaf\xcd\x39\x36\xe7\x97\x78\x71\xb0\x29\xa7\x1c\x59\x6f\xac\xf8\x1a\x75\xfd\xba\x08\x9e\x88\xcf\x86\xb4\xe3\xf2\xa1\xde\x13\x76\x7c\xda\x2b\xb0\x69\xb5\x2a\xbe\x96\x9c\xca\xbc\xf5\x63\xd3\x79\xf4\x6b\x78\x1b\x39\x2f\x7e\x0f\xf8\x9b\xb4\x0e\x03\xae\x4d\x97\x30\x5d\xdd\xb8\x5f\xde\xa5\x16\x54\x1a\xab\xdb\x09\x00\x62\xae\xdd\xee\xd6\x08\x66\xa3\xca\x93\xa1\xd2\x08\x1a\x1c\x82\x16\x04\xa3\x19\xeb\x0c\x33\x72\x8c\x8d\x96\xff\xbd\x12\x69\x2d\xfe\x60\x85\xb2\x08\x5c\x81\x10\xac\x6c\x4f\x56\xa2\xad\xa0\x4c\x66\x64\x31\x53\x1b\x76\x79\xe7\x6d\x1a\xf0\xcc\x80\x17\x5f\xcc\x33\xee\x36\x66\xce\x38\xb1\xf9\x22\xfc\x8b\xd8\x08\xda\x7d\x20\xf6\x5d\xbd\xae\xf6\xae\x46\x4a\xac\x03\x2f\x6c\x7b\xab\x4b\xd7\xbd\xaf\x4f\x34\x92\xaa\xf8\xd5\x2c\xf1\xfd\xde\xd0\x2e\xce\x4f\xca\xb9\xba\x15\xda\x87\x00\xd2\x70\x63\x22\xe5\xac\x2f\xcb\xef\x47\x3b\x11\xcc\x0c\x04\xd0\x4e\x04\x39\x9f\x23\xc3\xe2\x55\xbb\xb3\xdd\x21\xce\xe0\xf4\x3a\x1b\x62\x41\xc2\xeb\x75\xfb\xfd\x59\xf5\x31\x3f\xf4\x40\x0b\xcb\xb8\x79\xf9\xca\x4f\x5f\x49\x38\xb5\xd1\x33\xd5\xec\xbf\xf5\xc6\xb4\x07\x89\xfa\x1e\x69\x7f\xe8\xab\x37\xef\x8f\x7b\xd6\x58\x71\xdd\x1c\xac\xd9\xe7\x91\x9f\xfd\xcf\x7d\xda\x70\xbe\x5b\x7c\x0d\x3a\x2e\x4b\x52\xf6\x2a\x88\x64\x6e\x0d\xda\x2b\x2f\x5a\xed\x88\x48\xd8\xcf\xd8\x69\xb5\x2b\xe0\x73\x3a\x49\x8f\x27\xa0\xb6\x3b\x4c\x56\x83\xcd\xac\x0d\x66\xaa\x69\xde\x86\xce\x47\xc0\x65\xb3\x99\x1d\x0e\x3f\x32\x57\x59\x0b\xeb\x35\x30\x66\xcb\xad\x57\x7a\xb3\xf8\xf9\xd3\x76\x0c\x6d\x98\xe2\xe1\xc8\xfb\xc6\xa0\x8d\xa3\xc7\xa5\xec\x9b\xbf\x55\xa7\x52\xf1\xa3\x01\x48\x95\x37\x92\x1d\x95\xfd\xf3\x1e\x6c\xb1\x81\xdb\x97\xd7\x67\x89\x75\xe8\x58\x5d\x4d\xec\xe2\x83\xf0\x05\xb4\x8d\xe0\xc6\x4f\xc8\x66\x3f\xad\xfa\x81\xa8\x23\x76\x46\x62\x95\x55\x66\x8b\xc5\x97\x43\x74\x6f\xdd\xae\x6f\xbb\xc2\x36\x54\x55\xa7\x56\xbd\x7a\x11\x55\xb0\x5f\x7f\xad\xcf\xd7\xaf\x6b\x9b\x4e\x6c\x07\x64\x88\x77\x68\x17\xe9\x5b\x58\x50\x58\xd0\x10\x2b\x2c\xf4\xa0\xb7\x56\x56\xb6\x6b\x57\x56\x1f\x6b\x47\x59\xec\x11\x3b\x8f\x6e\x67\x3b\xd0\x43\xbb\xc7\x63\xa8\x8f\x79\x5c\x74\xa6\x04\x43\x94\x30\x6b\xb9\x53\x38\xf4\x81\xad\xf5\x0b\x89\x7a\x94\x70\x38\x91\xe2\x47\xaf\x62\x13\x1e\x69\x93\x14\x0c\xbf\x70\x42\x10\xf8\x64\xf8\xd8\x48\x32\x18\xb7\x4f\xaa\x28\x0a\x97\x5a\x82\x12\xc8\x00\x19\x4c\xad\x56\x49\xaf\xb7\xe7\xb3\x90\xe1\x58\x99\x44\x9b\x51\x8a\x75\x98\x0c\x40\x4d\xec\xbc\xf4\xd3\xf3\x9d\xe7\x37\xb4\xee\xd1\xae\xf5\xd8\x51\xa3\x2b\xf6\x6d\xf6\x66\x64\xf4\x1b\x7f\x4f\xf7\x39\x9b\x1a\x8e\xbe\xf6\xfe\xde\x41\x3b\xb7\xa6\xd4\xe3\xaf\x00\x5d\x67\x3c\x34\x7a\x69\x6e\xff\xb2\xfe\xa1\x3e\x66\x8b\xc3\xb3\x78\xe5\xe3\x87\x77\xcc\xdc\x00\x76\x4f\xdc\x3a\xb1\x8b\x99\x31\x66\x54\x14\x15\xe6\xbb\xfc\xee\xbf\xe6\x07\xdc\x01\xf7\xfc\x89\xa3\xee\xe9\x26\x98\x23\xb3\x1a\x27\xdf\x9d\xa8\xd9\x07\x59\xb9\xa0\xaf\x78\xe4\x2f\x9d\xaa\x7a\xb7\xcf\x28\x38\xef\x7f\x7e\xc6\xc6\x63\x76\xeb\xd3\x52\xed\xc4\x56\x71\x30\xbc\x40\x3f\x41\xf4\x45\x7b\x31\xa4\xb2\xa2\xa2\x4b\xb5\x59\x10\x7a\x55\xe7\x51\xb5\xd9\x04\x51\x53\x54\x5b\xeb\xad\x0b\x97\x95\xa9\xd5\x5e\x6f\xb4\x63\x4d\xbb\xea\x48\xaf\xfc\xbc\xfc\xbc\x68\x2c\x3f\xdf\xdd\xa5\xb2\x3a\x52\x51\x1d\xc6\x43\x21\xa3\xb1\x6a\xce\x6c\x8b\xd8\xb8\x7e\x31\xc2\xc6\xd9\x48\x1d\xb4\xb9\xdd\x3a\xa4\x40\x5c\x54\x30\x05\x0c\xf4\xd6\x5b\xe1\xe4\xce\xa7\xed\x46\x62\x27\x12\x31\x57\x49\x50\x53\x60\xe7\x41\xa2\x60\x48\xd9\x0b\xeb\x2d\x37\x23\xa5\x3c\xa3\xa2\xf2\x16\x3b\x21\x17\x6b\xc0\xca\xdb\x4e\x9e\x5d\xd9\x2f\xaf\x75\x79\x55\xc3\xd0\xc1\xc5\xc3\x87\x3e\x6a\xcf\xf1\x74\x1d\x32\xa9\xf3\xe4\xfb\x7a\x6d\xdc\xb3\x66\x49\xfb\x35\x4f\x25\x0a\x38\xda\x7e\x38\x33\x6d\x1b\x16\x4d\x9c\xd9\x67\xe5\xc0\x3b\x66\x83\xe8\x1d\x6b\x87\x06\xed\xfe\xf2\x9c\xbc\x62\x6f\xa6\xf7\xae\x19\x59\x39\x9e\xa0\x67\xe1\xd8\x21\x53\xbb\x65\xd8\x2a\x07\x74\xee\x57\xa7\x94\x79\x9c\xcb\x03\x75\xc9\x4d\x78\xd3\xb1\x68\xa8\x5c\xf3\x31\x5b\xf6\xe3\x7e\x51\xe6\x4f\x65\x10\xed\x22\x5e\x15\xed\xc9\x70\xe9\x8d\xfa\x0c\x9a\xf2\x5a\xad\x3e\x17\xb2\x2a\x1a\x62\xac\x4e\x47\x7b\x78\x8b\x81\x96\xaa\x53\x6b\xd2\xaa\x9c\x53\x32\x43\x81\x22\x20\xf7\xbe\x48\xd3\xa6\xc2\xa9\xd3\xa6\x82\x02\x79\x6e\xe5\x8b\x23\x2c\x25\x47\x4b\xb8\xd6\x13\x62\xe6\xa7\x0e\x3f\xd5\x77\xe1\xd3\x63\x52\xe6\x4d\x1d\xee\x0f\x9e\x1d\xf1\xce\x47\xe0\x6d\xb1\x78\xc7\x8a\x2e\xb0\xf3\xf5\x83\xb5\x0f\x6f\x4a\x8c\x9b\x02\xcf\x22\x3a\x9f\xc6\x38\xcd\xd2\xfd\xd1\x26\x92\x21\xf0\x7a\x83\xd6\xe6\xb0\x19\x78\xca\x49\xd3\x2e\x3b\xc5\xb3\x84\xcd\x60\x8b\xc6\xb4\x06\xab\x5e\x9a\xe3\x91\xe8\xfd\x6a\x41\x65\x96\x4c\x95\x0c\xcc\x5c\x44\x4a\x04\x03\x09\x95\xf9\xe8\xd3\x41\x0c\xca\xbc\xfa\xd7\x43\x7d\x77\xf7\xbd\x6b\x5d\x77\x43\x4e\x53\x8e\x76\xf0\xb0\x97\x77\xcf\x22\x57\xec\xc3\xa0\xcc\xcf\x9d\x1c\x26\x81\x32\xab\x46\x1c\x3f\x43\x36\xc6\x57\x1f\x5a\xaf\x82\xaf\xc9\xf8\xbd\x4a\x0f\x02\xc1\x12\x7e\xa2\x15\xae\x7d\x71\x16\x17\x53\x59\x66\x3d\xa5\x0f\x97\x3a\xdd\x05\xc8\xb2\x2f\x2a\xc8\x8e\xf0\x5c\x36\x57\x1f\xcb\xca\xce\xd6\x10\x1a\x5b\x7d\x4c\x23\x10\x81\x94\xd2\xce\x94\x22\x48\x24\x8c\xe7\x4a\x53\x01\x6b\x13\x29\x18\x09\xf7\x52\x95\x98\xe8\x07\x91\x44\xc9\xe5\x9d\x95\x52\x5e\xbf\x08\x80\x00\xc5\x48\xe1\x54\xf4\x22\x1e\x83\x04\x77\x63\x24\xcc\x69\x9f\x89\x6f\x1d\x50\xc6\xfb\x35\x6e\xdc\x0c\xde\x7f\xeb\x07\x50\xd0\x76\x41\x63\xcd\xcc\x41\x15\x13\x80\xe1\x67\xf1\xdd\xd6\x0f\xac\x8d\xcc\x5e\x36\xba\xf7\x9c\x3b\xe0\x65\x7a\x33\x06\xc7\xdc\x27\x1e\xfd\x75\x61\x62\xe2\x5f\x3c\xab\xce\xed\x7a\xf7\xe3\x2b\x7f\x2f\x0d\xe4\x3a\x43\x64\x87\xeb\xff\xec\xe9\x6b\x5f\x54\x5e\xf7\xf6\x67\x68\xed\x38\xcf\x88\xb1\x32\x8d\xd2\xda\x63\x91\xc2\x80\x4b\x4d\x64\xe3\x0e\x50\x75\xb8\xd4\xe5\x29\xf6\x44\x63\xad\x8a\x73\x23\x26\x36\x97\x8d\xc6\xb2\x73\x73\x69\xbd\x3e\x13\x03\x7d\xd3\xd6\xe6\x14\xce\x7f\x5b\xbc\x74\x18\x53\xb3\x38\x72\xc4\x18\x04\x98\x44\x9d\x25\x5e\x3d\x5a\x7c\x16\xce\xe8\xc8\xcb\xc7\x01\x83\x4a\xaa\x55\x74\xd3\x5f\x56\x9e\xfa\x46\x42\xd8\x8c\x8f\xec\x56\x4b\x2f\x9c\x33\x64\xea\x90\x36\xfa\xbe\xed\x86\x8c\xcc\xea\x08\x4e\xfe\xfb\xfe\x9d\x05\xb5\xed\x8b\xba\x16\x87\x7a\xe5\xf5\xe9\x42\x3e\x7b\xaf\xf8\xb7\xd7\x46\x7d\x7f\x5e\x42\xdd\x14\xf7\xe7\xe6\x95\x3e\xf0\x48\xe9\xed\xeb\xbb\xe4\x55\x5b\xdd\xcb\x40\xc6\xb6\x27\x43\x36\xa7\x25\x33\x84\xcf\xcc\x5e\x74\x66\xbe\x90\x6a\x78\x8b\x22\x36\x42\x05\x49\x15\x69\xb0\x18\xac\x3a\xdc\x38\x67\xd4\x51\x24\x54\x01\x09\x81\x20\xe9\xa2\x25\xab\x87\xd0\xcd\x2d\x58\x6d\x35\x00\x83\x2d\x27\xbc\x15\x72\xfb\x69\xf1\xd2\x89\xd7\x1d\xba\x9c\xe1\xe0\xad\x69\xe7\x57\x4c\x1a\x91\xdd\x2d\xa7\x75\x9f\x00\xbd\xe8\xba\x6f\xd5\xa4\x3e\xcf\xc2\xfc\xb3\x0d\xf7\x65\xf9\xda\xb7\x95\xce\xeb\x5d\xc8\x8e\xea\x8c\xfc\x2c\x5e\xfa\x6c\x1a\x92\x34\xa9\x13\x74\x66\x0d\xdb\x2f\xa6\xd7\x6b\x38\x12\xd9\xf9\x96\x3f\xf9\x6c\x24\xec\xb6\xca\xd4\x4f\x06\xd7\xdf\x3f\x78\x68\x8c\x63\x26\x10\xc6\xbf\xba\x6a\x4c\x83\xbb\xa6\xa4\xa8\x53\x2e\xba\x38\x23\x3f\xfd\x40\x6a\xcf\x8d\xb8\xd7\x9e\x5d\xd6\x0b\xc7\xc6\xa4\xf5\x32\x26\x3e\x44\x65\xe1\x58\x17\xf9\x2e\xb9\x1d\xf4\x97\xf0\x7d\x7d\x32\xbe\x6f\x4e\x93\xd5\x4b\x1a\xd2\xf0\x7d\x25\x3a\xe9\x63\xe8\x67\x42\xf2\xcf\x80\x57\x15\x4c\xe0\x0c\x93\xf4\x33\xe1\x26\xb3\x87\xd4\xa5\x64\x8d\x20\xc6\x89\xd5\x74\x41\x7c\xb5\x49\xd5\x32\xfd\x23\x85\x05\xb8\xfe\xc0\xe5\x0a\x9b\x35\x1a\x32\x1c\xa0\x2a\x04\xa1\xd2\x5b\x5c\x1f\xf3\x0a\xf6\xec\xfa\x98\x9d\x62\x35\x66\x9e\xd7\xb2\x04\xdd\x10\x23\x25\x90\x42\x25\x1f\x98\x28\x52\x48\x8f\x15\x9b\x52\x52\x44\x35\x40\x3e\xf9\xed\x81\xd4\x90\x03\x4a\x95\x82\x6f\xd2\x24\xcf\x12\x4b\x46\x91\x70\xd4\x89\xfa\x47\x6d\x5b\x6f\xa1\x6f\xf0\xfa\x3e\xae\xcb\x07\xef\x62\x9d\x40\xeb\x03\x07\xde\x88\xaf\x9d\xbc\x7c\x63\xfc\xe8\xe7\x80\xd8\x25\xbe\x73\xfc\x9b\x6b\x23\xf7\xfe\xbe\x7c\xd2\xae\x19\x91\x27\xd6\xad\x7f\x6b\xf2\x63\xe2\x60\xe3\x32\xf5\xd4\xfb\x8a\xa9\xa2\xf8\xee\xe8\x01\x97\x35\x02\x7d\xd7\x4e\xbf\xfa\x48\x6f\xa6\x46\x3c\x25\xfe\xe7\x3f\xe2\x9d\x1f\x83\xb6\xc0\xb2\x0b\x74\xf9\x69\xc1\x96\xc6\x53\xe2\xe7\x0b\x3f\x7c\xff\x05\x30\xf4\xf8\xf9\x2f\x30\x1f\x3a\x8a\x83\x19\x3c\x37\x0d\xe3\x3c\x94\x12\x7d\x23\xf9\x05\x5e\xad\xdd\x1e\xc2\x5c\x08\x79\xa9\xb0\x20\x94\x05\x73\xa2\xb1\x20\xe7\x2e\xc6\xb6\x32\xe2\x82\x45\xe2\x42\xf4\xff\xc2\x85\x3f\xe5\x01\x34\x33\x29\x19\x99\xb4\xfc\x28\x9c\xf0\xa7\x0c\x68\x63\x1d\x2e\xae\x7e\xea\xf8\xb4\x4b\x5b\xf6\xbc\x7c\xfc\xc0\xd8\x59\xed\x87\x0f\x1d\x3b\xad\xc3\x9f\xad\x9e\x1a\x30\x7a\xa6\xe8\xf8\xee\xc2\x51\xd0\x75\x17\xce\xa1\x3e\x20\x7e\x3b\x67\xc3\xa3\x1b\xa5\xf4\x23\xc6\x09\xbe\xb1\x4d\x35\x96\xbe\x82\xd6\x5d\x4c\x44\x22\xfe\x4c\xde\xae\x52\x41\x96\xa7\x4a\x5a\x79\x5c\x3e\xab\xaf\x3e\x06\x09\x2b\x95\x1b\x2a\xd0\x16\x60\x74\x01\x8c\x4e\xaa\x58\x96\xf6\x9a\x96\xe1\x73\x19\x64\xca\x2a\x03\x05\x4b\xea\x51\x46\xba\xad\xac\x00\x78\x0a\x98\x5c\x9c\x41\x5a\x38\xba\x5c\xd2\x18\xed\x01\x4f\x39\x0a\x7b\x0b\xef\xfe\xfc\x8a\xb8\xeb\xab\xa2\xbb\xab\x7b\x73\x1f\xfe\x78\x1c\x8c\xfc\x22\x02\xae\xad\xbf\xb7\xdd\xf4\xea\xfe\xba\x67\x7e\x5b\x0c\xb8\xce\x93\xab\xfb\x18\x9f\xf9\x6d\x19\x7d\xa5\xaa\xa4\x44\xbc\xf8\xd1\x17\xe2\xdd\x7f\xb7\xf7\x2e\x45\xea\xa7\xe8\xbb\x8f\xc0\xc2\xef\xed\x43\xe3\xc3\xb7\xbf\x9d\x37\xaa\x7d\x2b\xf7\x6b\xe2\xe1\x27\xc4\x23\x03\xc9\x3b\xba\x56\xb8\x4e\x80\x4e\x12\xae\xf0\x8d\x75\xd4\x4a\xea\x79\xc2\x4e\x14\xa1\xdb\x36\x23\x53\xef\x20\xf4\x44\x71\x09\x5a\x1c\xe7\x43\x6e\xa6\xc0\x71\x39\xa1\x7c\x2a\x3f\x1a\xd3\xa8\xb0\xed\x72\x8b\xc5\x35\x97\x15\x90\x2a\x46\xd1\xfa\x12\x36\xbf\x1c\xff\xc8\x00\x4c\x99\xb2\x38\xb4\x77\xb6\xe4\xd2\x56\x4e\xbb\xfc\x58\xd5\xed\xe1\xbe\xba\xfb\x1f\x9b\xfb\xed\xa3\x8e\xc1\x15\xe5\xbd\x35\xab\xd7\xbe\x3c\xb7\x7c\x4c\x45\x1f\xdd\xc8\xe5\x7d\xd6\xb5\x19\x53\xd2\xc3\x38\xf4\x9e\xee\xe4\xb3\x5b\xc5\xd7\x8f\xbb\x27\xb6\xa9\xc8\xfe\xe4\xf1\x1d\xa0\xf2\x80\xad\xa4\xb4\x4b\x51\xee\xf9\x87\x8f\x75\xea\x5b\x5e\xe0\x7c\x48\x9c\x74\xa9\x43\xff\x56\x39\x9e\x6d\x80\x42\x72\x3a\xf5\xc6\x8f\x9a\x2f\x98\xf7\x88\x4a\xa2\x27\x31\x90\x58\x1d\xe9\xde\xbf\x57\x5d\x5d\xaf\x01\x03\x3a\xf6\xec\x18\xe4\x7b\xb6\x52\xa9\x08\xa7\x81\xa7\x07\x0d\xee\x59\x55\xd5\xb1\xff\xc0\xba\x8e\xe8\x4f\x17\xdb\xc0\x81\xed\xd9\x2e\xc8\xb2\xee\x62\xc8\x65\x6d\x95\x10\x22\x6b\x1a\xda\x6c\xc8\x6b\x75\xd9\xa8\x82\x10\x1b\xaa\x8f\xe9\x58\x21\xbd\x10\x45\x49\xff\x28\x05\xd1\xe1\x04\xa6\x6a\x22\xe2\xdd\xdc\xc1\xc1\x57\x27\xa7\x2c\x49\x61\x62\x3c\x21\x48\x0e\x13\xe3\x2b\xd3\x09\x32\x53\x26\xb5\x2b\xad\x11\x95\xa9\xd1\x65\xa4\x12\x25\x96\x4a\x83\xf4\xe5\x98\x32\xfa\x76\x16\x32\x17\x82\x15\x95\xc1\x4a\xd5\x8c\x81\x9b\xfa\x02\x0e\x04\x96\xfc\x43\x3c\x74\x56\xfc\x6c\xc3\xab\xe2\x97\xe2\x17\xe2\xd9\xd9\x9f\x83\xf2\x63\xfd\x97\x77\x19\xd7\xa9\x3e\x7c\xdf\x97\x4f\x0e\xff\xfa\xc2\x7d\x40\x3d\xa8\xf5\xb7\xcb\xef\xff\xcf\xa1\xdb\x2e\x9c\xe8\x35\xb9\x08\x1c\x1a\xb7\x7f\xe0\xe8\xc5\xdd\x66\x3c\x5a\xb4\x28\x02\xc8\xed\x1d\xef\x99\x3c\xe6\xe9\x21\xf1\x07\x9d\xe6\x8c\xca\x89\xe3\x0c\x7d\xdc\xf4\xe0\xa0\x5b\xfc\xf1\x3f\xcf\x8b\x5b\x6e\x10\x2b\xef\xbc\x13\xd8\x88\x1b\xcf\x83\x51\xc4\x8d\xe5\xee\xe0\x03\x01\xcb\x84\x37\xc5\x6f\x16\x9f\xfa\x72\x60\xd7\xae\x03\xa7\x5e\x04\xf6\x55\x27\xde\x0e\x9a\xc1\x91\x8a\xca\x76\x25\x77\xde\xb5\xfd\x40\x7e\x4d\x75\x2b\xb8\xa4\x6d\x69\xe7\xd1\xdd\xd6\x48\xf6\xc8\x58\x64\x8f\x5c\x55\x3d\x40\xe4\x11\x65\x44\x2d\x31\x21\x52\x5e\x93\x21\x94\x96\xe4\x87\x6b\x09\x18\x36\xda\x05\x9a\x61\xba\xf7\x28\x2d\xce\xcf\x6f\xd3\xb1\xb6\xbc\xbc\xa6\xb8\xa6\xd8\xde\xd1\x18\xe4\xec\x90\xa2\x1c\x76\x2e\x24\x09\xa3\x9e\x4b\x05\x18\x95\x63\xbe\xc5\x12\xdb\x65\xd7\xad\x58\xce\x3c\x20\xfb\x38\xac\x04\x3f\x14\xb0\xc1\xca\x44\xcb\x43\x20\x5b\x95\x98\xcd\x18\x66\x02\x89\x42\x7b\x85\xdb\x20\xc1\x52\xfa\x16\xfc\x56\xf9\xef\x9a\xe9\x79\xe5\xdc\xf0\x47\x3e\x5d\x7f\x72\xe6\x23\xc7\x4e\xbe\x36\xe0\x89\xaf\x97\x79\x46\xad\x6c\xa8\xfe\x61\xe8\xb1\xb6\xd9\xdb\x47\x34\xdc\x3f\xb6\x83\x38\xd9\x63\xcb\xcc\x97\x78\x47\x5e\x6f\x66\x6e\x3b\x40\xed\x90\x99\x4b\x9e\x9d\x3b\x6d\xf3\x9b\x87\x96\x88\xef\xbf\x71\x7b\xff\xfe\x27\x5f\x5e\x0a\x32\x2f\xde\xbe\xb9\xd7\x63\xf1\x98\xd8\xba\xb0\xa0\x4d\xbf\xc7\x01\x01\xfb\xad\x6d\x57\x15\x46\x5c\x5b\x28\xb3\xf2\xf1\xc3\x98\x95\x44\xa2\xaf\x54\xdb\x4a\xf5\x1d\xba\xbf\x4c\x12\x5e\xcc\xeb\x74\x5f\x30\x5e\xca\xef\x74\xa1\x43\xe0\xc9\xae\x6d\x32\xd3\xe7\x6f\x4a\xb1\x7f\x7a\x11\x7a\x3f\x2f\xbf\x9f\x74\x2b\xf9\x20\x3c\x80\xb3\xdc\x67\x11\xf4\x69\xb5\xd2\x53\xc4\x81\x12\x7e\xb7\x83\x28\x8f\xb8\x04\xca\x8e\xf1\xbb\x9d\x3a\x9d\x2b\x81\xdb\x0d\xac\xf5\x31\x20\x34\xc3\x8b\xb7\x84\xee\x06\x42\x88\x48\x47\x45\x91\x05\xba\x12\x92\x42\xf4\x6f\xe2\x1f\x17\xc1\x8c\xbf\x5e\x06\xf9\x25\x4d\x59\x17\x1e\x3c\x24\xfe\x7d\xf3\xa7\xaf\xb6\x6d\x7d\x17\xb2\xa5\xb7\xda\x41\xc5\xd5\x7f\x82\xb5\x18\x08\xe5\xae\x25\x7b\xc5\xe3\x17\xcf\x7e\xcb\xc5\x8f\xc9\x35\x02\x0a\x86\xb7\x64\x63\x23\x69\xb0\xd9\xd4\x24\xad\xa6\x9d\x2c\xeb\xd2\x0b\xb8\x5b\x04\x99\x6d\x04\x36\xdb\xa8\x5b\x91\xd5\x9c\xdc\xaf\x94\x87\xcc\xa4\xe5\xf6\xa5\x12\xd3\x9f\x4a\xcb\x27\x37\x45\xb7\x6c\x5f\xff\xf3\x9e\x67\x5e\xd7\xee\x55\xdd\x31\x6c\xfe\xd6\x41\xd3\x16\xf2\xf1\xd7\xc1\x23\xfc\x7b\xfb\xcf\x80\x21\x4f\xed\x7e\xc0\x31\x6a\xc2\x72\xf1\xa3\x75\xcb\xe4\xbe\xc7\xd6\x37\xbe\xa0\xee\xa2\x3f\x22\x04\x62\x66\xa4\xbd\xc6\x00\x05\x4a\x6d\xe2\x79\x8a\x60\xd4\x6a\xa3\x96\xd0\x22\x59\x33\x00\x23\x6b\xac\x8f\x71\x02\x2b\xc3\x2f\xb3\x2a\x0d\xad\xc5\x63\x9d\x29\x1a\xa9\x16\x3d\xa5\x63\xd1\x1f\xc6\xc4\x20\xa5\x22\x4b\x30\x77\xaa\xba\x3a\x5f\x99\x10\xc1\x9d\x92\xbf\x48\x56\x34\x26\x0d\xee\xb0\x52\x72\x0e\x98\x2c\x48\x33\xb8\x4f\x31\xab\x92\x96\xfe\x86\x21\x75\x57\x37\x71\xef\x62\x50\xd7\x55\x7c\xfe\xf2\x13\x3f\x89\x87\xba\x81\xee\x8b\xc5\xa6\xae\xa0\xef\xfb\xdb\xfe\x0e\xd7\x3f\x34\x52\xfc\xa1\xfe\xa1\x06\xb1\x1c\x5c\x19\xf1\xd0\x48\x60\x19\xf9\x70\x3d\x78\x4d\xb4\xc8\x3d\x03\x85\xd4\x5c\xf0\x03\xfd\x2d\x61\x21\x0c\x4d\x6a\x28\x18\xb1\x53\x75\xbe\x54\xce\x63\xfb\xa5\xb4\x43\x48\x2a\xf2\x91\x47\x4e\x80\x1f\xba\x97\x8b\x3b\x3a\x15\x95\x76\xec\x5e\x0e\x86\xe1\x67\x7a\x4a\x69\x5b\x73\x55\xdb\x48\x99\xfc\x24\xfd\xce\x2a\xea\x2d\x70\x81\x7e\x95\xb0\x12\xc2\x41\x4a\x4b\x18\x78\x09\x37\x37\x5c\xcc\x9d\x93\xda\xc1\x83\x95\x52\x86\xd5\x08\xe4\x40\x81\x82\xf1\x07\x4e\xc7\xa8\x68\xb0\x57\x7e\xc9\xd4\x6e\x63\xdd\x03\xcb\x46\x14\x4d\xef\xda\x6f\x28\xf5\x56\xc9\xd0\x2c\xbb\xab\x70\x5d\x80\x2f\x1a\xd6\x3f\x80\xf8\x6f\xa4\xba\x13\xff\x92\x66\x73\x1a\x9a\x54\x0b\xf1\x10\xba\x9a\x52\xe7\xb9\x56\x25\x02\x13\x64\xe4\x59\x7e\x35\xe0\x5f\x59\x31\x3a\x67\x7c\x88\xb3\xd2\xe7\x5e\x6e\x55\x1b\xed\xd5\x37\xaf\xef\x64\x69\x46\x30\xd5\x1d\x04\xd0\xcf\x6a\xf0\x5a\xe9\x85\xf8\x67\x9d\xe7\xb0\xec\x22\x5a\xe4\xe3\x0f\x02\x1e\x53\x59\xfe\xcc\x31\xa6\x58\x16\x7d\x6e\x43\xdd\x94\xe2\x09\x0d\x2f\x4b\x7c\x12\xef\xa0\xdb\x90\x5f\x22\x1d\x26\x10\xdc\x01\x95\x61\xa1\x40\x68\x89\x62\xe4\x4d\x49\xac\x6a\xd6\x19\x89\x6b\x2f\x4c\x9e\x19\x79\x68\xdc\x9c\x7b\xdb\x4f\x58\x5a\xb2\xbc\xe6\xbd\x47\x7b\x6c\x9a\x72\xc7\xf3\xc3\xe9\xf6\xe5\x55\x1d\x0a\x26\x4e\xdb\xbb\xab\xb8\x4d\x15\x1e\xb7\x4d\xa8\xaf\x67\x89\xbb\xe1\xc7\xf4\x41\x44\x13\xce\xe0\x67\x23\x9f\xa5\x0d\xd1\x85\xe8\x8b\x3c\x97\xfc\xae\xc1\x8c\x9e\xbe\xda\xde\x59\xbd\x4b\x59\x6d\xa5\xbe\xac\xda\x54\x9d\x43\x13\x85\x64\x5e\x31\x53\xdc\x1b\x89\x4d\x75\x6f\xe8\xea\xd0\xb6\x7d\x27\xb3\xc3\xea\x22\x8a\xcf\x9f\x2b\xc5\x7f\x91\x02\x2c\xc6\x39\x32\xee\x7c\xe9\x39\x1c\xcb\xb9\xe9\x0b\xac\x15\x83\x01\x4b\x90\x0b\x97\x5a\x84\xe4\x57\xe0\xbf\x7e\x05\x6f\xf1\x5a\x56\xf2\x2b\xf2\xfa\xd4\xa9\xe3\x2e\x5f\x36\x49\x8f\xd7\xd7\x48\x4f\x64\xa1\xf4\x74\x75\xa9\xf4\xf4\xb9\xfc\xda\x7a\xe9\x29\xee\x90\x9e\xe0\xa9\x4d\x9b\x90\x9e\x12\x55\xd2\x13\xf9\x0f\xe9\xe9\xea\x5f\xa5\x27\x2a\x94\xfa\xbd\xeb\x5f\x48\x4f\xbf\x4b\x8f\x12\xcf\xc6\x8a\x8b\xe0\x16\xfa\x6f\x37\xf1\xac\x77\x24\xab\x53\xa4\x4b\x97\xe2\xc2\x9c\xac\x50\x86\xcb\xec\xf1\x64\xf4\xee\xdb\xa3\xba\xb4\xb2\xb2\x47\x4e\x46\x8f\x1e\x19\x39\x50\x63\x12\x8c\x0c\xa5\x21\x8a\xcf\x55\xa3\xff\x79\x85\x57\xe8\x4b\x24\x99\xe8\xf9\x7c\x35\x77\x1e\x7f\x89\x5f\x69\x55\x62\xc3\x61\xaa\x60\x45\x79\xb0\xdc\x84\x81\xe4\xc3\x2a\x4b\xd8\x22\x55\xd1\x96\x5b\xc3\xe5\xe1\x2c\xbc\xd1\x96\x50\xd0\x12\x84\x68\xbf\x6d\x4c\x28\x9b\xc9\xc6\x33\x02\x90\x2d\x6b\xab\xb4\x41\x2c\x51\xd9\x15\x95\xd9\x95\x18\x16\xb5\xd2\xa6\x62\x6c\x4c\xc4\xe9\x6e\xec\xd8\x53\x7a\x88\x4f\x9c\xd3\x79\x44\xee\x90\xba\x47\xa8\xe7\x94\x2f\xda\x0d\x2a\x29\xd6\x76\x63\xab\xcb\x27\x5d\xef\x82\xbe\xd4\x74\x45\x5f\x4e\xd6\x0f\x6a\xd5\xbf\x55\xb7\x3b\x5a\x97\x4f\x82\x97\x06\x95\x0c\x68\xd5\x6d\x52\x75\xf9\x9d\x6d\xa4\x9f\x88\x6e\xa5\x3e\x53\xbe\x88\xbb\xa5\xdf\x59\x26\x3d\x8a\xff\x1a\x8c\xde\xd8\xf5\xce\x2a\xf4\x33\x8c\xf4\x33\x77\xe2\xdf\xd9\x5e\xfe\xf5\xf8\x37\xdd\x37\xa8\x55\x11\xfe\xa4\x8a\x3b\xe5\x38\xb2\x38\x16\x63\x45\x48\x93\xff\x07\x46\x3c\x3a\xb5\x81\x04\x00\x5d\x31\x16\x83\x87\xf2\x69\x54\x0c\xe3\xe7\x68\xd2\xc4\x6b\x0d\x11\x83\xe6\x10\xb0\x46\x74\x31\x03\xef\xb6\x2e\x74\xf0\x2a\x0c\xc9\x13\xfe\x0c\x1d\xbe\x52\xb9\x04\xe0\x5c\x62\xdc\x4b\x73\xd8\x30\x0d\xbe\x02\x62\x00\x0b\x8c\x3f\xa7\xc1\x07\x46\x29\xdb\xb4\x19\x53\x10\x2d\x7e\x39\x21\x5e\xda\xfb\xd1\xf2\x03\x01\xeb\xf5\x2a\x72\xfa\xca\x17\x4a\x37\xe6\x4d\x1f\x32\x72\x6d\xe6\xb8\x82\x0f\x13\x28\x17\xd7\x0a\xe2\x87\xc1\x16\xb8\x6b\xe7\x60\x0c\xde\x33\x6b\x5e\xbb\x31\x03\xc6\x0e\xcb\xbc\xf7\x01\xa5\xa6\xe1\x4d\xdc\x1f\x84\x64\x22\x1f\xe7\x50\xf4\x1a\xad\x51\xc7\x41\xc2\xe9\xf4\x73\xb9\x5a\xba\xb0\x40\x2e\xcc\x37\x70\x11\x4e\xdf\x2f\xc6\x59\x72\x02\x0b\xb3\x32\xe4\x01\x6a\x69\xcb\x48\x6f\xc2\x6d\x59\x91\x0f\x5a\x56\xe4\x67\xa5\xad\x06\x6c\x4b\x14\x31\x34\xed\x11\xbf\xda\xfb\xe6\xed\xcd\x75\x0c\xe0\x78\xda\x92\x52\xeb\xf5\xc7\x89\x39\xa0\x32\xa5\xa6\x61\x66\xca\xca\x9a\x7b\xa2\x71\xde\xbc\x4f\x24\xd7\x4a\x01\x08\x39\x03\x54\xff\xbf\x67\xcd\xe5\x0d\xc2\xca\x20\x8c\xf4\x66\x32\x63\x2e\x55\xbc\x24\xfb\xa4\xbf\x3d\xe8\x3e\x98\x9a\x2f\x3f\xb7\xdd\xbd\xfd\x7f\x64\xcb\x95\x1a\x65\xa4\x63\xf1\xc9\x1c\x1a\x29\x76\x10\x8c\xd9\xcc\x69\x0c\x2c\xab\x51\x41\x1a\xf9\xe0\xde\x0c\xce\x53\x17\x63\xa5\x52\x6f\xbd\x9a\x43\x7f\xa0\x96\x30\x5b\xa1\x35\xbd\xcc\xea\x66\xa2\xf9\x24\xe2\x53\x4a\x99\x95\x5c\xa2\x13\xc6\x53\x37\xd3\xeb\x99\x71\x2a\xfc\xf3\x19\xce\x19\x99\x4d\x99\x8b\x9d\x8b\x27\xde\x5c\xd7\x3c\x77\xf1\xe1\xc3\x8b\xe3\x5f\xa4\x14\x53\x91\x09\x6c\x0e\xc2\x88\xcd\x9c\x88\xdf\x06\x2d\x3c\xad\x56\xf3\x02\x4b\x19\x20\x34\x78\xdc\xac\x0e\xf9\x79\xac\xc1\x68\x74\xd5\xc7\x8c\xd0\x90\x32\x76\x23\x9d\x46\x25\x3a\x66\x31\xa3\x53\x8f\xac\x4e\x9c\x20\x11\xfc\xa5\x48\x19\xd8\xa4\x50\xac\x1f\x0e\xf8\x1b\x30\xae\xee\x3f\x67\xc4\xfc\x67\xc5\x21\x13\x8f\x03\x53\x05\x58\x3c\xbf\xff\x80\xbb\x07\x95\x3e\xb6\x45\x7c\x8a\x5e\xf4\xce\x81\x4b\xf3\xa6\x36\x2c\x28\x8f\x7f\x4c\x2f\x8a\xb7\x09\x4c\x1b\x35\xb3\xfb\xa4\x59\x72\xde\x27\xd1\xff\x83\xb8\x5b\x42\x74\x8a\x64\xe5\xeb\x73\x1d\xee\x22\xab\xd5\x9d\x93\xcb\x06\x55\xea\x52\x75\x2b\x21\x23\x1a\x13\x38\x8a\x25\x74\xac\xda\x45\x84\x9a\x7b\x38\x9b\x91\x59\x53\xb1\x8f\xe9\x64\x07\x0e\x52\x71\x48\xe1\x25\x7b\x73\x24\xda\x85\x80\x12\x60\x96\x88\x97\x00\x17\xf3\xe6\x3e\xe2\xc3\x2d\x37\xff\x71\xa9\x77\x6a\x19\xaa\xfb\x93\xb3\x1e\x7d\xe1\x8e\xa1\xbd\xa6\xf6\x1d\x64\x1a\xb3\x66\x74\xd5\x82\x29\xfd\xca\x07\x4f\xe9\xd3\xaa\xfd\x48\xb3\xdc\x64\x43\xab\x1e\xee\xac\x9b\x92\x55\x3f\xe8\x95\x1d\x2f\x8b\x9b\x47\x8e\x1b\x7a\x47\x2e\xfc\xb0\xee\xa9\x3f\x46\xdd\xb3\xca\x33\x7b\xd8\xed\x03\x80\x63\x02\x6e\xb5\x91\x31\x25\x00\xb5\x8f\x71\x13\x0c\x9e\x2d\x45\xab\x54\x6a\x40\x92\x1a\xdc\x37\x85\xac\x28\x06\xaa\x68\x9e\xac\x07\x00\x10\xc5\x23\xc2\x89\x99\x77\x4a\x2e\x3b\x51\x99\x83\xac\x22\x00\xf7\x44\x9b\x26\xc5\x9f\xbf\x82\xd8\x4a\x2f\x02\x8f\xc4\xcf\x80\x6b\x6e\xe9\xae\x97\xea\xcb\xe0\x6c\x24\x9b\x52\x5f\x16\x01\x80\x9a\xa2\x69\x0d\x4d\x11\x2a\x86\x44\xd2\x08\x49\x16\x28\x35\xfd\xa9\xe0\x31\xf2\x6f\x0f\xe3\x5e\x35\x74\x34\x3e\x68\xba\x08\x1e\xe8\xfd\xd4\x38\xf1\x1e\xaa\x35\xd8\x10\xff\x41\xfa\xbd\x21\x74\x3e\xbf\x43\x9f\x61\x40\x76\xaa\x47\xa5\xd5\x02\x9d\x8e\x31\x42\xc8\x6a\x0c\x84\xa1\x21\xa6\x42\xdb\xa6\xe3\x31\x1c\x18\xd9\x8c\xf6\x10\xbe\xb9\x55\x5b\x08\x0b\x12\xe6\x96\x54\x47\x1b\xec\xf4\xcc\x0c\x78\x5f\x46\xbc\x72\x30\xd8\xee\x11\x87\x2f\x3c\xbe\xf0\x19\x98\x45\x0e\xdb\x2a\x76\xd8\x18\x9f\x44\x6e\x90\xf9\x65\x40\xeb\xc9\x90\x7a\x2a\x6a\x22\x5e\xbd\x5a\x4d\x19\x09\x82\x85\x0c\x63\x54\x21\x7b\x33\x1a\xa3\x74\x48\x9b\x1b\xc8\x68\xcc\xc0\xaa\x2d\xcd\xb2\xda\xcc\xb8\xe6\xf2\x2c\x5c\xbc\x8b\x4f\x91\x54\xf4\x26\xc0\x0c\x87\xb8\xa2\xf5\x5b\x8e\x73\x63\x9a\xc6\xdc\xed\x98\xd3\x9f\x6a\xbd\x58\x7c\x7b\x49\x5c\x24\xc9\x25\xa0\x49\xc2\xdf\x18\x2c\xd5\x1f\x04\x90\x96\xcd\xb6\x31\x0e\x64\xe8\xba\x19\x18\xcc\xb4\xf0\x3e\xbe\x3e\xe6\xf6\xf9\x6c\x76\x3b\x3a\x22\x76\x88\x48\xb2\xf1\x14\x3a\x35\x94\x2b\xb9\xf2\x74\x32\x92\x9a\x16\xd1\xc0\x49\xa3\x2a\x15\x5d\xca\x37\x43\xff\x63\x8e\x48\x09\x0e\xea\xc8\xf3\xe2\xb1\x77\x0f\x7c\x92\xff\xbc\x6b\xe1\xec\x0d\xdf\xdc\xb7\x71\x45\xb7\x47\xa7\xad\xc2\xd3\x6c\x1e\xf6\xc6\xb3\x7b\x8e\x19\xde\x58\xf9\xde\x5f\xc1\xc7\xe2\xbf\xc4\xb1\x5f\xae\x7c\x20\x23\x3a\xf8\x10\x98\x70\x7e\xdb\xf3\x59\xe1\x78\x29\x46\x27\x5b\x58\x90\x61\xba\xae\xd4\x82\xc3\x83\x52\x0f\x57\x34\x92\xc7\xa8\x04\xb3\x15\x71\xd2\x61\x56\x51\x19\x5e\x9e\x73\x71\xd1\x98\xc3\xe5\x32\x5b\x2c\xf6\x68\xcc\xc2\x32\x0c\x65\xb6\x50\x98\x9b\xff\x73\x09\xf2\x44\xda\xe6\xa6\x04\xa5\x42\x0c\x77\xf4\x49\x00\x7b\xa5\x56\x78\x70\xf1\x6f\x4f\x8a\xcf\xe5\x3d\x6b\x9a\x30\x7a\xdb\xc9\x95\x73\xef\x1c\x1b\x6d\xba\x48\x8e\x72\x89\xfd\x7b\xcf\xb8\xbd\xe9\xc3\xbd\xcf\x89\x3f\x3c\x0c\x5c\x86\xfe\xbd\x00\x79\xee\xde\x35\x3e\x71\x0c\xd5\x7a\x95\x38\x3d\xf8\x21\xc6\x18\x13\xc7\x4b\x18\x63\xd9\xc4\x94\x48\x5b\x48\xf0\xd0\x46\xd9\xec\x6c\x56\x00\xfa\xb4\x3e\x0f\xc6\x3b\x71\x79\x28\x3b\x6d\xcf\x45\x22\x9d\x93\x15\x70\xa9\xa0\x8c\x2d\x86\xf4\xae\xd7\xef\x77\xd7\xc7\xfc\xbc\x8d\xd3\xc0\x6c\x5a\x81\xa2\x95\xa7\x15\x24\x04\x31\x1c\x0e\xff\xf7\x56\xe6\x3f\xc7\x12\x93\x3a\xd4\xfe\x4f\x78\x62\x1b\x7b\x03\xd7\xed\xc8\xdd\xf2\x8b\x97\x9c\x53\x0a\xfe\x3b\xa6\xd8\xb3\x65\xf1\x47\x31\xc8\x0a\x79\x40\x67\x91\x70\xc5\x6e\xec\x12\xc7\xd3\xb8\xf7\x25\x84\xd7\x4f\x12\x26\x88\xae\x0c\x9b\x31\xd3\x0f\xbd\x1a\xaf\x5b\xea\xf1\x76\xe3\x1e\xef\x1c\xe4\x26\x66\x67\xfa\x9d\x34\x29\x37\x76\x1b\x8d\xea\x0c\x9f\xcf\x55\x17\xf3\x59\xac\xac\x9a\x0d\x51\x96\xff\xa7\xf5\xff\x59\x2b\xb7\xb4\x7a\xa5\x9d\xbb\x7f\x75\x5e\x73\x3b\x77\x7e\x45\x45\xb1\xdc\xce\xdd\x1b\x18\xa4\x5e\xe0\x97\x06\x4f\x78\x2a\xea\xbb\xb9\xa5\x7b\xc2\xf0\x50\x5a\x4b\xb7\x58\x8d\x3b\xa6\x94\xb6\x6e\x40\xb4\x41\x67\xed\xef\xf4\x26\xa2\x8a\x98\x16\x69\xa7\x0d\x85\x7c\x18\x53\xcd\x58\x95\x5b\x51\x51\x55\xe2\x84\x74\xb5\xe0\xf3\xb5\x2e\x0a\x37\xc4\x4a\x8a\x5c\xc1\x04\xb8\x1a\xe1\x76\x38\xdc\x6e\x2b\x1e\x5e\x52\x95\x8b\xf1\x30\x63\x09\x04\x35\x25\x80\x97\x44\x23\x28\x4e\x4c\x29\xce\xbf\x19\x37\xef\x7f\xe0\xa8\xf1\xfe\x14\x18\x35\x69\x82\x45\x12\x59\xab\xbc\x2c\x9b\xac\x93\x60\xd5\x2a\x5e\x58\x7f\xe0\x64\x1a\xac\xda\x36\xf0\xe4\x82\x0b\x12\xaa\xda\xb9\x7d\xdc\x13\x1b\x26\xf6\x71\xf6\x1d\xd0\x7f\xa0\x0a\x03\xac\xad\x9b\xf3\xd0\xaa\x66\x80\x35\x30\x70\xf0\xd6\x06\x9c\x9f\xdd\x31\x6d\xd7\x67\x59\xed\x7a\xac\x7c\x28\x6b\x49\xf0\x8e\xc6\x2c\x8f\xd2\xeb\x8e\xce\x30\xee\x75\xaf\x24\xe6\x44\x22\x9a\xcc\x4c\xb7\xc5\x6a\x2d\xf2\xf9\xfd\xd9\xd9\x65\x65\x15\xfa\x22\x0a\x72\x6e\x77\x35\xac\x2a\x68\x15\x8d\x15\x15\xb8\x52\x7a\xdf\x93\x6d\xef\x15\xd9\x04\xa1\xaa\x6b\xee\x7c\xff\xef\xac\xb9\x89\x39\xff\x3f\xfa\xe0\x5b\x32\xe7\x7f\x34\xc6\xdf\x3d\x8d\x4f\x32\x86\x09\x48\x5d\xf2\x13\x1a\x6e\xd9\x25\x3f\x79\x6b\x56\xd7\x04\x63\x02\x7e\x2a\x81\x4f\x85\xb1\xdc\x6c\x44\xdf\x48\xb6\x8e\xe7\x48\xab\xd5\xc6\x19\x6c\x06\x3b\xa3\x56\x3b\x6c\x3c\xaf\xb3\x90\x96\x86\x18\x49\x12\xac\x49\x42\x77\xe1\x19\x09\xc8\x2d\x79\x1e\x14\x36\xb4\xe8\x75\xbf\x09\xc6\x2d\xe5\xd8\xa7\x41\xb9\x35\x1f\xf2\x77\xd1\x21\x4f\x83\x73\x4b\x9e\xe9\x1d\xe8\x4c\xcf\x95\xf5\xf0\x78\xa9\x3f\xdf\x9a\xa0\xd5\x62\xb1\x72\x06\xab\xc1\x86\x68\xb5\x5b\x2d\xbc\xce\x4c\x9a\xeb\x12\xb4\xa2\xc3\x6c\x61\x94\x69\xc7\xff\x93\x56\x59\x45\xd5\xa4\x1e\x52\xa5\x39\xbf\xb2\xae\xb1\xcf\x6b\x29\x07\x32\xd9\xa0\x9f\xd7\x30\xea\xe7\x94\xf3\xa7\xf4\xe8\x27\xb1\xf1\xec\xc4\xf0\x48\xb1\xd5\x6c\x82\x9c\x8d\x62\x48\x2d\x69\xb3\xd9\x39\xd6\xce\x3a\xb4\x3a\x9d\xd3\x6c\x32\x5a\x49\x6b\x43\x8c\xa1\x48\x81\xa4\x69\x52\x80\x9c\x9d\xd7\xca\x7c\x0d\x2b\x4e\xa6\xa2\x67\x6e\xc6\xc7\x53\x54\x0c\x22\x18\xbb\x17\x52\xf2\x43\x82\xc9\x43\x44\xab\x14\xee\xd6\x14\xf7\x99\xd6\xd6\x55\x03\x1a\x65\x06\xdf\x76\x49\xbc\x52\x3b\x2d\xda\x51\x61\x2f\x0b\x36\x88\xe7\x5c\x5d\xc0\x63\x98\xc5\xd7\xe3\xe4\x04\x71\x2d\x78\x94\xc5\x1c\x4e\xc5\x40\xb0\x62\xfa\xcd\x3c\x0b\x8d\x16\x86\x52\x93\x98\xd5\x46\xcc\x6a\xb5\x46\x63\xe7\x59\xbd\xc4\x69\x44\xbf\x09\xd3\x6f\x82\x46\xab\x45\x2d\xf3\xfa\xff\x48\xbf\x20\xd3\xcf\x28\x08\x17\x3a\x20\x53\x8f\x18\x5e\x91\xd3\x7e\x42\x3e\x08\x2a\x78\x08\x5b\x4b\x27\xd4\x64\x55\x2a\x90\x08\xa0\xfd\x27\xa0\x51\xc1\x44\x78\xfc\x06\x01\x3a\x33\xe9\x3c\x77\xe1\x9c\x9b\xda\x46\x33\x26\x33\x8f\x6c\x69\xe0\x74\x39\xd4\x6e\xa3\xd1\x63\x36\xd9\xd4\x36\xc4\x6e\x17\xe1\x6a\x88\x51\x84\x1a\xfd\x21\x05\x07\x2f\x81\xc4\xa6\xc3\xc9\xa5\x57\x34\x99\x14\x3b\x4b\x71\x19\x6e\x02\x25\x14\x82\x4b\x9e\xcc\x3b\x9e\x77\xd8\x7d\xb8\x34\x55\xa0\x31\x36\xa1\x24\xcc\x6f\x3d\x49\xed\xfe\xf0\xc3\x8d\xe2\x8d\xa4\x44\x63\x80\x42\x2c\xcd\x94\x2d\xc9\x6b\x69\x6e\xee\xe0\x48\x31\x03\xd4\x56\x13\x65\xe6\x69\xb3\x15\x38\x9c\x76\xb5\xcb\x68\x74\x9b\x4d\x56\xb5\x15\x37\x6b\x1a\x04\xbb\x85\x71\x12\x4e\xa4\x7e\x90\x75\x68\x60\x49\x22\x6d\x12\x52\xa2\x24\xb2\x45\x31\x96\x42\x3b\xb6\x26\x9a\xa5\x5b\x96\x6c\x21\xf8\xf4\x22\x77\x93\x07\x94\x38\xc4\xb7\xa7\x37\xcb\xb8\x02\x40\xf1\xc3\x42\xba\x7a\xe3\xc6\xc5\xf1\xdd\x09\x21\x57\x40\x28\xa8\x97\x24\x19\x79\x16\x29\xc2\x28\xe2\xb7\x05\x79\x14\x99\xc0\xac\x33\xea\x8d\x26\xb3\x60\x51\x59\xd5\x6a\x9b\x51\x27\x81\x3f\xa2\x43\x68\x10\x78\x06\x4a\xf0\x4f\x8a\x19\x7b\x0b\x32\xe5\xc1\x4d\xb7\xe0\xac\xff\x4d\x72\xe1\xec\x5b\x32\xf5\x8a\x58\x93\xa6\x24\x92\x2c\xfd\x56\xa2\x6d\x06\xe2\xe9\x39\xa9\x86\xbd\x73\x24\x13\x12\x06\xce\xc8\xf1\x04\xa0\x2d\x1a\xad\x16\xe9\x0a\x9e\xe2\xb1\x06\x27\x59\xb3\x45\xc3\x92\x20\x1a\x23\xd9\x5b\xd1\x96\x32\x9f\x0b\xb7\x0a\xb7\x64\x1e\xd8\x2a\x5e\x76\x81\x8f\x87\xdf\xc4\x37\xf8\xc2\xaa\x66\xc5\x90\x00\xee\x90\x75\xec\x9b\x12\xfe\x5c\xbf\x48\x3e\x89\x36\x1a\xc3\x00\x6a\xb4\x2a\x9a\x86\xc8\xfb\xa6\xf4\x9c\x56\x6b\xc2\x00\xd3\x0c\x43\x68\xd0\x4b\x3c\x32\xcb\x75\x49\x54\x69\xee\x74\x82\x38\x90\xda\xa7\x6d\x4a\xc4\x77\x53\xc1\xa4\xb1\xe6\x82\xf1\x05\x71\xb0\x00\x97\xcf\x4d\x27\x6f\x4c\x7f\xf9\x0a\x06\xad\x6d\x86\x8c\xbe\xe6\xc5\x2a\x55\xd1\xa5\x18\x03\x83\xc5\x15\xea\x04\xcb\x1a\x49\x1d\xd0\x23\xbf\xd5\x60\xd4\xa8\xb4\x10\x77\xf6\x19\x21\x67\x02\x48\x8d\x02\xa0\xa5\xd0\xf7\x2d\x6a\xad\x96\xae\xc3\x93\x15\xd2\xa9\x4a\xed\x8c\x4b\x99\x27\x92\xa4\x27\x0d\x12\x43\xc2\x20\xd8\x9e\x0a\x8b\x21\x43\x0f\xc8\xd0\x18\x09\x9c\xc0\x15\x12\x1e\x57\x79\xc4\x03\x90\xab\x45\xd1\x46\xad\x96\x95\xd9\x43\x69\xe4\x29\x37\x34\x34\x50\x72\x85\x42\xda\x5c\xd0\x74\x76\x60\xb1\x4f\x67\x06\x39\x27\x43\xac\xb9\xd2\xcc\x8c\xad\xd7\x5c\x49\x4c\x93\xc7\x24\xbf\xa8\x3c\x82\x6c\x43\x02\xe8\x69\x23\x45\xb1\x06\x16\x68\xf1\xf2\x21\xa3\xb7\x40\x55\x34\x06\xd9\x66\xe4\x38\xfc\x9c\xfc\x4c\xa0\x7c\x5a\x72\xa9\xa4\x25\x06\xbe\x74\x89\x97\x0e\x36\xd5\xc7\x7f\x48\x2e\x75\xd5\xf5\xba\x94\x75\x8a\x83\xd5\x77\xa3\x75\x66\x62\x3c\x03\x48\x59\x09\x0b\xa3\x52\x01\x8f\xd1\x08\x2c\x14\x95\x15\xb2\x5a\x29\x9e\x77\xd4\xc7\x78\x57\xd0\xa7\xf3\xa1\xb5\xeb\x74\xc8\x52\x47\x4c\xa0\x21\x21\x2f\x3d\xd5\xa7\x48\x96\xa0\xdc\x3c\x44\x4f\xe6\x87\xe2\x10\x59\x6e\xed\x32\xc1\xf8\x95\x38\x40\x0e\x30\x4f\xdd\x33\xb1\x71\xc4\xd8\xb2\xf7\xfe\xda\xd2\x6f\xea\xfa\xe8\x8c\x55\xd4\x17\xd7\x7c\x88\x6f\xdf\x14\x7a\x4c\xd7\xbf\xbb\x95\xcf\x94\xe8\x9b\x55\x75\x92\x6a\x2f\xeb\x22\x79\x4e\x3d\x20\x5c\x82\x4a\xe5\xca\x80\x3e\xbf\x5d\x0a\xda\x00\x08\x33\xbc\x5e\x77\x5d\xcc\xcb\x1a\x0c\x5a\x67\x86\x45\x8b\xfc\x27\xad\xab\x99\xb3\xb7\x72\x96\xa4\xc2\x79\xcc\xe7\xc4\x28\xda\x5b\xb8\x4c\x12\x08\xca\x78\xec\x16\xdd\xec\x33\x25\x90\x51\xe2\xdf\x05\x3f\x3c\x76\x93\xd3\xa4\xa0\xa5\xe0\xfc\xfd\x8f\xf4\x16\x69\xbe\x57\x15\x31\x2a\x52\x66\xd3\xb6\xca\xc8\xe1\xc2\x15\x44\x56\x56\xd8\x9d\xa1\xa5\xab\x5b\x07\x0a\xeb\x63\x81\x00\x63\x34\x0a\xf5\x31\xce\x48\xb9\x9d\x8c\x13\xed\x08\xb2\x18\x72\xf2\xc8\x3c\x74\x62\xc9\x44\xe2\x37\x6c\x4f\x49\x00\xa7\x8d\x30\x6a\xae\x90\xcd\x92\x12\xdd\xe8\x41\xc9\x83\xc9\xa3\xae\x95\xf0\x49\xa8\x79\xee\x2e\x23\x65\xc5\xa4\xef\xc8\x21\x15\x7a\xcb\xec\xbb\xeb\xe6\xb7\x5b\xf7\xf4\x1f\xe2\xf5\xfd\x20\xf3\xa5\xa5\xdd\x7a\xb6\xab\x9d\x77\x66\xe1\xae\x1d\x6d\xea\xa7\xcc\x39\xb7\x64\xd9\xc6\x17\x36\xb6\x6a\x3b\xb2\xef\x8d\x1e\xf3\x6a\x1b\x97\x6e\xef\x9c\xd3\xd6\xed\x6f\x07\x8c\xd7\xfe\x00\x27\xbf\x2f\x5f\x93\x73\x46\x5c\x7c\xec\xe0\x71\x61\xd3\x1f\x6f\x82\xd8\x0b\xaf\xbc\xf8\xae\x38\x7a\x3e\x5f\x0c\x1f\x7f\x4c\xfc\xe7\xda\x0f\xef\x9c\x01\xe6\xed\x1f\x37\x59\xc6\x5f\x80\xc7\xa8\x5e\x44\x3e\x51\x81\xeb\x85\x6d\x9a\xd2\x0c\x2e\x27\xa7\xac\x00\x31\xa3\xcc\x9d\xa1\xa1\x2b\xab\x02\x45\x51\xc4\x0c\x15\x62\x46\x14\x31\x83\x73\x3b\x55\xf8\x7a\x52\x59\xcb\x72\x72\xc9\xdc\x28\x62\x86\xf5\xff\xc2\x0c\x53\x0a\x37\x52\x32\xae\x7f\xce\x0d\x1b\x62\x46\x99\x3c\xa8\x0a\xb1\x03\x3e\xdd\xaf\x61\x58\x8f\x21\x63\x9f\x7e\xa6\xcf\xca\xc3\x53\xfa\x45\xba\x64\x16\x0e\x7d\x64\xc4\xe8\x21\x5e\x7b\xef\xc1\x0f\x8d\x1d\x3f\x79\xc6\xa4\xfc\x4e\x55\x63\x3b\x17\xd6\xe6\x15\x0e\x18\x1d\xac\xcc\xca\x3a\xff\xea\x5c\x90\x71\xe1\x76\xd7\x02\xf3\xe3\xe2\x77\x1b\x56\xdf\xa7\x9a\xb0\x77\x0d\x80\xcb\x37\x2c\xdb\x22\xfe\x6d\x34\xcc\x06\xd7\xe6\x4e\x3d\x35\x74\x45\xa7\x01\x12\x54\x94\x94\xe7\x1c\x2c\xe5\x39\x0b\x70\x84\x18\xf9\x53\x36\xc8\x11\x1c\x6f\xa3\x0a\x33\x32\x8a\x5c\x81\xfa\x98\xd7\xeb\xa2\x0a\x0a\x04\x21\xb7\x3e\x06\x05\x41\x6d\x68\x88\x69\xd5\x2e\x42\x9e\xa7\xa8\x40\x05\xa5\x75\xba\x28\xea\x11\xd9\xfa\x2d\x8c\xfc\xe0\x4d\x63\x22\x12\x19\x7e\xba\xcf\x98\xff\x3c\xc6\x36\xfb\x3e\xae\x03\xe2\x1f\xab\x5a\xe6\x47\x3f\x7a\xf5\x01\x40\x8c\x06\x75\x9b\x77\x3b\xba\xb4\x4e\x98\xf8\x9e\xf5\x40\xff\x62\x5a\xb2\xf4\xcc\xdf\x36\xde\x9f\x96\x2b\xcd\x21\x7a\x47\x72\xb3\x0d\x76\x95\x40\x09\x16\x3b\x95\xeb\xf3\x7a\xf3\xdc\xc1\x68\xcc\xe7\x73\x73\x2a\x0b\x84\x16\x0b\x72\x8b\x2d\x56\x1d\x3a\xa5\x06\x5d\x62\x61\x89\x12\xd4\xf4\xe6\x16\xb9\x35\x49\x6a\x6d\x69\xb9\xb8\x96\x9d\xd2\xa4\x85\x03\xef\x37\xae\x2b\xda\xda\xf0\x4d\xca\xc2\x5e\x3d\x9f\x96\x58\x9d\x33\x69\x76\x2b\x51\x0c\x77\x69\x9b\x5c\xce\x27\xaf\xa5\xa5\x58\xc5\x3f\xe4\x3d\x3a\x84\xee\xd7\xe1\x52\x7f\x4b\xfb\x88\x8f\x02\x2a\x92\x26\x18\x86\x56\xa9\x29\x3c\x84\x93\x50\x6b\xd4\xf8\xce\xa0\x90\x7a\xad\x8f\xa9\x92\x97\xea\x2d\x07\xbb\x25\x6e\x2c\x69\x50\xc9\xfb\xab\x27\xed\xed\xfb\xf0\xef\x89\x79\x24\xd7\x8e\xe0\xab\x53\x9a\x3d\x22\xdf\x9f\x18\x37\x89\x28\xc5\xc8\x0f\x0e\x02\x66\x05\xb2\xf3\x43\x21\x6f\x30\x98\x0d\x59\x5e\xa7\x0a\x97\x39\x78\x63\x56\x76\x76\xa0\x2e\x96\x6d\x71\xa3\x93\xe2\xe6\x24\x58\x1a\xce\xc8\x12\x3a\xb9\xc0\x2d\xd1\x3c\xa8\x78\x27\xa9\x70\x34\x4a\x1e\xc1\x2f\x54\x24\xa3\x5a\x69\xe1\x56\x5b\xb2\xff\x54\xa6\x57\x19\xb2\x82\xde\x47\x3e\x80\x31\x57\xa4\x31\xa7\xb7\x00\xa4\x19\x3b\x1d\x5d\xbf\x8b\xe7\x99\xe9\x5e\x83\xa6\x3d\xe3\x9b\x49\xce\xc1\xb8\x2b\xc7\x77\xc6\xb7\xc3\xfe\x2d\x30\x69\xe2\xff\xc4\xd7\x32\x39\xe7\xae\x42\x13\x1e\x87\x1a\x7f\x02\xaf\xf9\x28\xba\x27\x19\xc4\x67\x35\x9e\x5d\xa4\x46\x96\x3f\xe2\x29\x1e\x5e\xa0\x61\x18\x2d\x4d\xaa\x21\x50\x41\x08\xa4\x79\xdd\x98\xa9\x20\xa5\xa7\x53\xe9\x6f\x10\x40\x18\xfd\x0f\xc8\x82\x63\x53\xc5\x4f\x4e\x5e\x06\x9f\x5e\x8a\x6f\x24\xbb\xc1\xd6\xf1\xdb\xc9\x4d\xd7\x8f\xcb\xf5\x81\xe2\x60\x6a\x34\xd2\xc6\x7a\xa2\x20\x62\xd6\x93\xe8\xce\xd7\x6a\x75\xe8\x33\x30\x2a\xa7\x16\xb2\x40\xaa\x8e\xbd\xf9\x77\x23\xff\x01\xe2\xd2\xc4\x0a\x6c\x47\x82\x07\x9b\xfa\xbd\x7e\x64\xbc\x1d\x96\x46\xc0\x3d\xaf\xc7\xef\x13\x07\x83\x67\x90\xf2\x1f\xdd\x94\x37\x69\x32\xb9\x0d\x23\x99\x21\xf9\x57\xd6\xc2\xe1\xd9\x6e\xac\x5e\x03\x90\x31\xc6\x30\x6a\x88\x5c\x35\x0e\x9a\xd4\x6a\x5e\x8f\xce\x39\x92\x1b\x3c\x2e\xc9\xc8\x33\xb2\xab\x80\x2d\xee\x9b\x8a\x87\xe5\x5a\x6b\xd9\x90\x95\x2a\x14\xc3\x40\x31\x06\x1a\x40\x8f\x9f\x4e\x1e\x71\x74\x00\xdb\xde\x13\x75\x20\xe2\x11\xc7\xde\x75\x74\xaa\x38\x9a\xfc\x82\x7c\x22\x7e\x62\xdc\x58\xb2\x43\xbc\xfe\xa1\xf8\x21\xb2\x16\xc7\x27\x3e\x55\xd6\xcd\x13\x7d\x22\x21\xa3\x4e\xa7\x32\x01\xa0\x52\x41\x64\x26\x42\x92\xd4\xf3\x5a\xad\x99\x17\x38\x97\x86\x64\x8d\x3c\x1e\x90\xa7\x53\xc9\xbd\x3c\x09\x24\xad\x04\x6e\x79\x33\x49\x09\x55\x13\xf4\x37\x33\x46\xa1\x4b\x0d\xda\xbd\x7e\x64\xa2\x49\x5d\xd8\x05\xcc\x3f\x15\xbf\x0f\xb4\x77\x89\x27\xab\x9a\xaa\xc4\x93\x88\x49\x03\xe6\xf7\x1b\x33\x07\x33\x69\xa5\xf8\x25\xf0\xca\xb1\x93\xcb\x0a\x86\x35\x8b\x75\xa0\x8a\x66\xf5\x7a\x2d\x03\x28\x5a\x85\xa1\xe9\x71\xdf\x2c\x47\x69\x19\x2d\x80\x84\x9a\x86\xf0\x56\xc6\xab\xc4\xa8\x16\xc3\x07\x90\x38\x68\x40\x50\x23\x41\x8a\x6b\xa4\xf0\x00\xfc\x9b\xf8\x6e\xfc\xf7\x4b\xe4\x5a\xf1\xb9\x37\x90\x7e\xfc\xf8\x52\x7c\x17\xf0\xae\xc0\xd6\xeb\xc8\xf8\x93\xe4\xf7\xe4\x83\xf1\xcb\x64\x76\x7c\x78\xfc\x35\xc9\x82\xc5\x74\xed\x41\x36\x6c\x5b\xc9\x86\xfd\x5f\x74\xb1\xd0\x82\xe9\xaa\x8b\x11\x96\xff\x4d\x17\x94\xe8\xc2\x82\x2a\x85\x02\xc8\x93\xef\x8a\x4b\xde\x00\x3f\x8a\xff\x7e\xe5\x55\x30\xf2\x82\x98\xff\xe1\x18\x74\x8a\xc0\x51\xb1\x33\x59\x40\x1a\xc5\x61\x60\x47\xfc\x77\x71\xa0\x04\x5b\x24\xeb\x22\xd5\x15\x89\x57\xb5\x91\x10\xb2\xa7\x8d\x3a\x35\xa0\xf5\x8c\x46\x43\x1b\x0d\x2c\xcd\x99\xd4\x94\x81\xaa\x8f\xe9\x0c\x3c\x3a\x2b\x2c\xc1\x2a\xde\x91\xb4\x8b\x35\xa7\xd3\xe3\xc3\x49\x27\x4e\x0a\xf3\x2b\xe6\x34\xb2\xe7\x3e\x40\xea\x48\x74\xbf\x47\x9e\xb8\x82\xac\xfb\x49\x4d\x7d\xaf\x9d\xbb\x22\x7a\xe8\x45\x5b\xaf\x1d\xc1\xd8\xd2\xb2\x92\x92\xce\xd2\x10\xc4\x9f\xaf\x11\x7f\xfc\xc4\x90\x48\x71\x06\x74\x12\x1e\x1f\x67\xd4\x09\xac\x56\xaf\x17\x38\x8f\x93\x0e\x04\x89\x0c\x6f\x46\x34\x66\xb6\x79\x59\xa3\x02\x43\x86\xfb\x1b\x39\xe4\x1c\x11\x35\xcd\xca\x09\xc9\x7d\x0b\xca\x52\x34\xe6\x7f\x03\x1f\xc3\x7a\x94\x74\x8f\x56\x12\x9c\x2f\x3f\x90\x06\x40\xd6\x28\xfe\xe2\x22\xbf\x72\xc1\x3d\x22\xf3\x27\x30\x64\x60\xf5\x6a\x19\xcb\x1c\xc9\xdf\x6d\xd2\xfc\xa1\xee\x91\x2c\x8d\xc1\x40\xdb\x2d\xff\x1f\x67\xef\x01\x18\x55\x95\xfd\x8f\xbf\xfb\xee\x7b\xf3\xa6\xf7\xde\x32\x93\x49\x25\xa4\x90\x81\x84\x40\x48\x86\x1e\x29\x21\x09\x25\x19\x52\x08\xbd\xf7\x2e\x84\xde\x7b\x11\xa4\xcb\x82\x20\x22\xa2\x54\x03\x28\x88\x05\x45\x41\x2c\x5f\x65\x5d\x60\x71\x2d\x08\x82\x75\xd5\x75\x85\xbc\xfc\xef\xbd\xef\xbd\xc9\x24\xc0\xee\xfe\x7f\xeb\x42\x86\xc9\xcc\xbb\xe7\x9e\x7b\xea\xbd\xe7\x7e\x8e\xd3\x61\xb6\x5a\x9d\x2c\x74\xb9\x1b\x00\xcd\xed\x4e\x27\xca\x36\x9d\x46\x13\x81\x34\x6f\xbc\x63\xfb\x50\xf4\xf5\x48\x58\x73\x61\x0a\x8f\x80\x36\xff\x65\x15\xe2\xf3\xe6\x47\xa0\x9b\x47\xf2\xa9\xe5\xfc\x08\x82\x95\xe6\x42\xfe\x34\x91\x82\xd0\xae\x53\x1b\x8c\x7a\xbd\x4a\xa3\x31\xd8\xa1\xdb\x63\xb4\xc8\x2c\xb8\x2e\x52\x66\x50\xba\x74\xd2\xf6\x94\x24\x8a\xc1\x87\xa9\x8c\x82\x4f\x88\xc2\xdb\x12\xac\xfd\xa3\x40\xd4\x4e\x61\xcb\xbe\xf8\x51\x40\x6a\x62\x82\xd5\x00\xa6\xd6\x80\x0d\xef\x42\x31\x7a\x0a\x6b\xa4\x2d\x94\x4d\xe6\xd4\x3b\x5d\x76\xbb\x5e\x2e\x77\xb8\x1d\x1e\x9a\x62\x8d\xec\x80\xb0\xcd\x82\xf2\x65\x93\xc9\xc8\x40\x95\xcb\x68\x57\x09\x26\xb0\xd1\xfe\x8e\x64\x88\x33\xf1\xff\x85\x5c\x88\x38\x2b\x5c\x3d\x25\xb1\xd6\x86\x7e\x4a\x98\xf1\xb5\x13\x5b\xce\x0a\xbe\xf1\xa6\xc0\xda\x6f\xca\x67\x95\x6f\xde\x20\xe2\xc6\xa7\x28\xf9\x5f\x91\xe7\xde\xb5\x39\xc2\xdf\x7d\x32\xf0\x29\x9f\xa1\xf6\x8b\x10\xf2\x51\x78\x74\x78\x9f\xa7\xb9\x99\x35\xc8\x75\x4a\x19\xca\x58\xd5\xc8\x5c\xaa\xa1\x5d\x6d\xf7\xb8\x0d\x3a\x33\x6b\xc6\x50\x15\xac\x89\x95\xc9\x58\x13\x52\x3f\x97\x4e\x6b\x11\x5d\x52\x34\xe1\xd1\xe8\x8d\x52\x16\x27\x6b\x20\x16\xef\xa6\xe1\xfb\x6a\x51\x9c\x5e\x98\x3b\xa1\x4d\xc7\x31\x04\xaf\x6e\x68\x51\xf2\x84\x78\x7d\x03\xa7\xa7\x28\x40\x06\xff\xa9\x3c\x56\x80\xad\xcb\x34\x7f\x74\x3e\xc2\x6b\x94\xcf\x32\x9f\x11\x1c\x7e\xe4\x33\x35\x2c\x46\xe2\x67\xcd\x76\x9b\x51\x47\x63\xdd\xa7\x69\xb3\x05\x2a\xcc\x46\xc9\xb9\x3c\x8c\x9f\x17\x17\x01\x9a\xc8\x03\x12\xd2\x04\xb2\x4c\x87\x00\xdd\x44\x44\x81\xe1\x2c\x5c\x4c\xe4\xb3\xee\x06\x1d\x10\xe4\xb3\x4e\xcd\xce\x17\xb1\x24\x2c\x04\xdb\xa4\x3b\x39\xb7\x76\xd7\xdf\x93\x3d\x85\x62\xda\x00\x8a\xee\xfb\x84\x52\xec\x26\x1d\xe5\x92\x27\x27\xfb\xfd\x2e\x13\x6c\x9e\x4a\xe9\x9d\xc8\xf1\x25\x5a\x9d\x21\x0e\xe5\x37\x2a\xaf\x37\xae\x3a\xec\x65\x54\xd8\x6a\x99\xa2\xee\x3b\xa0\x30\x3e\xdd\xa9\xff\xe0\xa1\xdb\xe9\xc2\xf1\x60\xa4\xbb\x19\x81\xf4\x16\xb8\x18\x44\xfc\x6d\x8b\xe2\x03\x02\x4f\xce\x01\x7c\xa5\x3b\xbb\x65\x02\xf8\x89\xf9\xfc\xdc\xae\x7b\x55\xcb\xa7\xf3\xef\x7f\xc4\xdf\xe6\x3f\x80\xae\x69\x8b\x52\x9f\x4b\x1d\xe6\xe9\x0c\x9e\x07\xc9\x40\x05\x9a\x7b\xeb\xae\xff\x8d\xbf\xd4\x16\x5e\x65\x3e\xa5\x27\xf5\x7c\xe3\xda\x9c\x79\x65\xcf\x6d\x07\xcd\x81\xa9\xeb\x84\x21\x65\xbd\xba\x86\xfa\xa1\xd7\xfd\xf9\xff\xe3\x7f\x9c\x3e\x81\xde\xc0\xff\x71\xaf\xf0\x9d\x9b\xe4\xec\xfb\xb7\xfa\x7b\xcc\xbb\xa4\xdf\x6c\x73\xdc\x2f\x88\x36\x50\x6e\x45\x42\x42\x6c\x2c\x12\x13\x26\xcd\x69\xb7\x58\x52\x29\x83\xdb\x50\x14\x6e\x6e\x73\x87\xe4\x6e\xb9\x5b\x1d\x13\x83\x12\x97\x18\xbd\x9a\xc5\x58\x2e\x0f\xcd\xf5\x52\x54\xdf\xc1\xc6\x15\xe9\x92\x8a\xda\x24\xd5\x6c\x98\x70\x50\xec\xe8\xcc\x25\x66\x8b\x15\xba\x7f\x51\x2c\x5e\x52\xb5\xa3\xc5\x8a\x5e\x5f\x6c\xbf\x78\x93\x95\x4f\x98\x83\x27\x9b\x05\x7c\xe7\x2e\x7f\x6d\x7f\x86\x99\x3f\x73\xc9\x2b\xf1\xe0\x5f\x99\xf9\x8b\xd7\xf4\x0f\xe7\x2f\x9b\x7c\xf3\xbd\xc4\xdc\xea\x01\x64\x96\x57\x7f\xbf\x72\x66\xe4\x90\x15\x05\xb3\x17\xbd\xb0\x53\x58\x47\xfe\x7d\xb2\x8e\x09\x54\x1a\x35\x32\x94\xed\x72\x58\x11\x77\xbd\x1a\x95\x56\xde\xbc\x79\x5c\x9c\xd6\x6b\x34\x58\x65\xe9\x19\x94\xc9\x83\xd2\xd5\x66\x0e\x4f\x88\xf3\x70\x1e\x95\xdf\x9f\x58\x1d\xf6\x33\x5a\x8d\x2a\xd4\xb0\xa6\xf8\xfe\x58\xf0\xbf\xad\xab\x64\xf2\x1b\x16\x17\x8b\x25\xb9\xae\xff\xbf\xac\xef\x04\xfe\xda\xa9\x9c\x75\x39\xf7\xea\xfe\xa7\x05\x7e\x66\x3b\xc7\xff\x1d\x24\x38\x40\xe2\x9f\xff\x61\x95\xd1\x1a\xf3\xef\x91\x35\x4e\xa4\xd2\xa9\x51\xa1\x2c\x2a\x3d\xdd\x1c\xa3\x55\xeb\x14\xc9\xc9\xf1\xf1\xba\x18\xd8\xc2\x83\xac\x5a\x06\x65\x8e\x41\x56\x21\xdd\x19\x13\x92\xc7\xc8\x63\xd4\xb1\xb1\xcd\x51\xea\xaa\xd7\x69\xd5\x21\x35\x5b\x2c\x2e\xf5\x43\x2c\x78\xe4\x72\x47\x24\x3c\x6a\xc9\x23\x06\xef\x7f\x59\xf5\xae\xef\x2e\x6a\xbd\x26\x67\xcf\xcb\xff\x65\xe1\x67\x4d\x55\xf0\xd7\x41\x92\xed\xea\x89\xc7\x2d\xff\xc3\x7d\xfe\x84\xbe\x52\xa4\x8f\xcf\x3b\x02\xa6\x0b\xfd\xaa\xd8\xc7\x27\x8e\x4d\x00\xaf\x27\xa6\xb3\xf6\x46\x18\x30\x04\x07\x1b\x63\xc0\xc0\x6f\x45\x7c\xe4\x0d\x62\xcd\x6f\xc0\x90\x00\x96\x27\xa4\x31\xb6\x46\x35\xbf\x21\x94\x0b\xdb\xc8\x39\x7e\xd7\x50\xbc\xdf\x12\xeb\x96\x6b\xb5\x2a\x80\x48\x08\xc4\x59\xad\xb1\x46\xda\x57\x1d\x56\xd1\x34\x15\x6b\x34\xda\xf1\xce\x55\xc3\x49\x91\x68\xdb\xa2\xb7\xa8\x44\x59\x92\xce\x88\x94\x80\x9c\x0b\x8a\xdb\x53\xd2\xcd\x15\xdc\x28\x19\x14\x9f\x9b\xd9\xb9\x7c\xc4\x1e\x20\xff\xe0\xd7\x7f\x17\xdc\xfa\x61\x2f\x32\x13\xaf\xdc\x49\x3c\xd8\xe1\x1f\x1b\xae\xcd\xf8\xe8\x9d\xaf\x6a\xf0\xa1\xc6\xc6\x40\xd5\x19\xd0\x82\xbf\xc5\x7f\x91\x6d\xfe\xe9\xda\x75\xfe\xc4\xb1\x55\xcb\x92\x9e\xdb\x0c\xd4\x7b\x9e\x3b\x52\x37\x03\xd3\xee\x41\xf1\xb5\x82\xc4\x42\x3d\x42\x49\x9c\xcc\x68\x8a\xd1\x68\xdc\x14\x65\xb1\x9a\x64\x28\x0e\x8a\xb1\x5a\x0d\xc5\x61\xab\xd5\xe4\x32\xe3\x13\x7c\xd3\x43\x27\xf8\x11\xd0\x81\x46\x1b\x17\x0f\x9f\xdf\x93\xd6\xce\x51\x87\x49\x5e\x00\x8f\xce\xff\x79\x37\xbf\x2f\xe9\x05\xf3\xf0\x81\x3b\xdf\x3c\xf7\xd2\xe0\x4a\xe4\x41\x22\x5b\xc7\xc3\x72\xf7\x1f\x3b\x7d\x84\xbf\xb3\x1d\xb8\x34\x65\x5d\x01\xf8\x6c\xd5\x4e\xde\xd7\x70\xbc\x34\x33\xcd\xfb\xa9\x10\x83\x6f\xe4\x87\x91\x7e\x46\x36\xaa\x5b\xc8\x68\x35\x1a\x2d\x36\x9b\xdc\x44\x19\x0c\x0e\xb9\x1d\xbd\x34\xe2\x52\x3b\x7d\xd8\x66\x14\x5a\x2e\xe2\xce\x46\x72\x99\x49\xca\xd6\xa5\x38\x4e\x8c\x75\x83\xc6\x48\x09\xc5\xc3\xad\x16\x49\xbd\x9a\xd8\xe4\xe8\x85\xb9\xa4\xc9\x51\xd7\x09\xf3\x47\xec\x87\xc5\x42\xb5\xdd\xd3\xd1\x8d\x8e\x96\x81\x56\xa0\x2d\xe0\x85\x22\x3b\x81\xce\x5d\xfc\x45\x82\x51\x6d\xa3\x3a\x84\x62\x2d\x14\x0d\x20\xb4\x9a\x69\xb3\xca\xa1\xb2\x9b\x98\xe2\xb0\x49\xa7\xd0\xa2\xec\x85\x52\x58\x69\x4b\x49\x98\x16\xfb\x06\x5f\x08\x36\x5c\xf5\xc9\x89\x2a\x05\x04\x38\x17\x8f\x42\xc6\xca\xa3\x71\x8e\x05\xe8\xc5\xef\xd5\x34\xc2\xac\x4e\x68\xdb\xa1\xea\x08\xfd\xec\xb1\xc3\xfc\x97\xfc\x45\x90\x1d\x85\x5d\xdd\x66\xfe\x03\xda\x88\xcb\xe5\xc4\x3d\x57\xf6\x32\xf1\xc5\x5d\x42\x71\x94\xd5\xaa\x50\x72\x6a\x8d\x92\xb1\xe9\xf5\x76\x8a\x32\x2b\xcd\x70\x40\xd8\xec\xd2\xc8\x07\x84\x35\x1a\xa5\x4e\x05\x95\x42\x2a\x9b\x93\x1e\x75\xc7\xaf\x71\x5b\x63\x72\x53\x8f\xb0\x4d\xda\x81\xa7\x91\xf5\x83\xbf\xc4\x6c\x5f\xf2\x7f\xbf\x64\x15\x46\x6d\x3d\x9f\xfd\x2a\x9f\x7f\x86\xbf\xc9\x8f\xe8\x31\x22\x5c\x4c\xd5\x03\x23\x58\x13\xd9\x92\x1f\xc3\xd7\xf2\x47\x71\xab\x66\x4c\xa3\x03\xc9\x69\x47\x72\xfe\xd6\x31\x14\x50\x28\xf5\x98\x42\xd6\x8e\x88\xb5\x09\x24\x16\x11\x12\x8b\x31\x89\x7a\x95\x4e\x69\x79\x34\x89\x52\x03\x5f\x9b\x50\x67\x18\x01\xde\x42\x04\x62\x71\x7d\xcb\x30\xb2\x7c\xf6\xfa\xb8\x12\xde\x21\x40\x6e\x7d\x1b\x3e\x7e\x21\xf3\x87\xf7\xf8\x97\x9b\xcd\xef\xd3\xfd\xd0\x19\xb0\x3f\x02\xb7\xc5\xf2\xf5\xdf\x02\x17\xe1\xdd\x30\xf1\x0c\xa3\x20\xe4\x97\x63\x38\x4b\x95\x16\x25\xe9\x78\x7f\xbe\xe1\xf8\x82\x51\xb0\x50\xcb\x18\x29\x15\x12\xc7\xa3\x91\xb6\x98\x17\xa2\xce\x2f\xa2\x9b\x95\x34\x3a\xb9\x00\x0f\x9d\x5c\xfc\x4c\xe4\x2d\xea\xe8\x42\x94\x32\xbc\xf7\x72\x51\x3c\xbb\xc0\x79\x1f\x64\x54\xf8\x68\x82\xc6\x29\x16\xa0\x58\x86\x35\xe8\x9b\x1e\x5b\x94\xfc\xe7\x63\x0b\x29\x95\x91\x08\x69\x74\x64\x81\x85\xea\xc8\x7b\xb3\x1b\x9d\x59\x90\xf2\xcb\x86\xbd\xfc\x86\xfc\xa4\x63\x28\x56\xa5\xd3\x71\xb4\x93\x83\x2e\xab\xd5\x4d\x33\x06\xe4\x62\xcd\x06\x83\xd2\x69\x0f\xd9\xa9\x01\x61\xbb\xd1\xa2\x84\x11\x68\xc4\xcb\x8f\xb8\x8b\x8c\xbb\x0f\x9a\x1e\xd3\x72\x29\x00\x9b\xad\xec\xf8\x88\xb6\x4b\x9b\x7a\x1d\xdf\x0d\x2a\x1e\xd1\x79\x89\x34\x80\x8c\xce\x4d\x3a\x87\x62\x75\x38\x39\x51\x1b\xed\x46\xb7\x52\xa5\x6a\xc8\x4b\x34\x28\x2f\xd1\x60\x3c\x56\x0d\xe2\xd4\x65\x69\x33\x3e\xd8\x14\x00\xa6\x21\xe9\x8b\x80\x3a\x63\xd1\x7a\x34\xb0\x73\x4d\xd1\xde\x91\x63\x42\x8f\x04\x77\xe6\x47\xd0\x2e\xd0\x2d\x2a\x27\x41\xf2\x85\xfb\xa4\x51\x1e\x64\x9f\xfd\x5a\x9d\xdc\xe4\x71\x38\x90\x7d\x36\xa9\x74\x8c\xd7\x09\xed\xf6\x18\xa8\x52\xd9\xf4\xd0\x6d\x92\xeb\x8c\x94\xa3\x91\x7c\x05\x83\x17\x84\x3b\x3e\x4d\x6a\x89\x05\x19\xcb\x07\x1c\x3e\x57\x84\xe9\x80\x34\xb1\xc6\x3b\x34\x59\xd9\xa2\xa1\x63\xbe\x3f\x9e\x64\x37\xf4\x6e\x5e\x77\x7d\xf6\x29\xbf\x9c\x4d\xae\x3d\x08\x0c\xf7\x5e\xf3\x69\xda\x79\xe9\x64\x40\x09\x06\x0f\xee\x3e\x3b\x26\x6e\x5f\xcf\x07\x3d\xe0\xf1\xab\xf9\x09\xff\x7a\xd0\x9b\x9d\xff\x20\xfd\xb2\x67\x5e\x6b\x78\x31\xca\xee\x61\x99\x24\xb8\xf8\x0e\x6c\x5b\x58\x85\x82\xd2\xe9\x19\x20\x93\x59\xd5\x7a\xc6\x49\x53\x94\xcb\xa1\x56\x18\x74\x7a\x8b\x95\x51\x59\x64\xa0\x24\x2c\x8b\x58\xbe\x26\x4d\xb7\x1b\x82\xca\x48\xfd\xf3\xc3\xe0\xf7\x44\x26\x2f\x4e\x89\x34\xe1\x5e\xd5\x08\xfe\x5e\x10\x4f\xa9\x0f\x77\xc2\x1b\x75\x2d\xa2\xf1\xef\x45\x4c\xc9\xdf\x48\x3e\xd0\xab\xa1\x3f\xa8\x0c\x63\xc1\xc5\x91\xbb\x3f\x8c\xd8\x87\x95\xd6\xb2\x09\x74\x2d\xe8\x76\xdc\x60\x67\x22\x1d\x00\xa5\x1e\x34\xec\x2d\xf4\xf9\x4e\xe4\x6e\xec\x36\xc0\x89\xf8\xab\xad\x0d\x09\xf4\x81\xb6\x1d\x54\x89\x8d\xe2\x0c\xe1\xf9\x47\x23\xcf\x07\xa0\x9c\xdc\xa5\x85\xb4\x85\x4d\x80\x68\x84\xd6\xc7\x8d\x7a\x61\x84\xc8\xfd\x5b\x61\x8c\x59\xd2\x18\xd4\x28\xa0\x91\x30\x5b\xf3\x31\x66\xeb\xba\xdc\x36\xc2\x28\x12\x66\x2b\x1a\xe7\x25\x8a\x92\x9b\x48\x3c\xb4\x8c\xc4\x47\x3e\x94\xe7\x7c\x4c\xb0\xee\x0f\x44\xf5\xd0\xfe\x2e\xd2\x43\x9b\x01\xfb\xc4\x78\x47\x8d\xe2\xa3\x67\x74\xd6\x26\x3d\xb7\x31\x6e\x6c\x0a\x99\x67\x81\x38\x4f\xbd\x38\x4f\x3f\x9e\x67\x5c\x4a\x13\x9c\xd9\x27\xeb\xef\xb1\x37\xd8\xcd\x7a\x19\x28\x26\xff\x6e\x8f\xbe\x1f\x60\x0a\xf5\x32\xda\xd5\xf0\x7b\xd9\x37\xc6\x04\xfc\x7b\x3c\x27\x5a\x0f\x46\x09\x73\x4a\xc6\x8c\xd8\x94\x10\x17\x63\x6f\x3c\x27\xe1\x19\x98\x0f\xf8\x19\x04\xbb\xf6\x5d\x89\x0f\x49\x98\x0f\x5d\xe3\x03\x56\x5d\x13\x3e\x90\x38\x10\xf3\x5b\x88\x03\x15\x80\x2e\xa5\xc4\x8e\xcf\x29\xf8\xc2\xf3\x1b\x49\x09\x6c\x93\x71\xc4\x58\x70\x96\x14\x0b\x22\x7e\xef\x97\xbe\xd3\x0c\x5f\x78\xde\x9c\x18\x2f\x44\x83\x51\xb4\x91\xde\x9d\x64\x9c\x77\xc5\x75\xe5\xa4\xef\xb4\xc0\xe3\xbc\x9a\xd6\x1c\xfa\x9b\x8c\x43\x7a\x8e\x90\x71\x6e\x8b\xf3\xd9\x25\x7d\x27\x0d\x8f\xb3\x29\x25\x19\xba\x9b\x60\xf1\xa2\x71\xd8\x66\xc8\x36\xb8\x71\x35\x3b\x03\xad\x3a\x95\xc3\xa1\x33\x42\xc6\x63\x30\x9b\xbd\xb8\xa5\xe3\x80\xb0\x55\xaf\xd7\x55\x87\xf5\x7a\xca\x04\x1b\xd5\xaf\x09\xe1\x5b\xe4\x12\xe6\x43\x7d\x49\xc4\x72\x35\xb2\x81\x9e\x82\x6c\x3a\xde\xb1\x12\x10\x47\x18\xda\xf9\x36\xff\x73\xf0\x40\xcb\x97\xe6\x4e\x3f\x52\x79\xfc\xc5\x1c\x37\x78\xf0\xe0\x6b\x2f\x23\x8f\xa9\xfb\xfe\xf0\xeb\xab\xf8\xdf\xcd\x27\x9e\xeb\xb2\x7c\x5e\xdf\x67\xaa\xa6\x3c\xb9\x01\xac\xd9\xb1\x97\x1f\x67\x7c\x7d\xfb\x9a\xdb\x35\xc2\x3c\xb7\x20\x3f\xce\xe2\x3e\x00\x74\x9f\x88\xec\x9d\x91\xed\x95\x7a\x6c\xd2\x2b\xc1\xaf\xc8\xee\x61\xd9\x43\x4a\x06\xf6\x69\xf5\xd1\x3d\x36\x23\x78\x8e\xbd\x25\x3c\x47\xf4\x79\xa5\x28\xab\x1e\x14\x9b\x8f\xf0\xc4\x34\xc6\x73\x14\x9f\x7f\x54\x7a\x3e\x5a\x8b\xb5\x12\x5f\xcd\x78\x2d\x8e\x18\x74\x14\xd7\x64\xfd\x84\x31\x66\x45\x30\x23\x47\xe1\x8b\x1c\xc2\x77\x02\x78\x2d\x26\xf9\xbc\xc2\x28\x51\xdf\x19\x81\xd6\xe2\xdf\xb2\xa3\xfa\x04\x2a\xf3\xdf\xc2\x38\x7f\x11\x75\x39\x40\x74\xf9\xc1\x96\xe3\x3e\x1f\x84\x8d\x74\x99\xf4\xbb\x20\xe3\x94\x88\x6b\x5e\x27\xc9\x70\x1c\x96\xe1\xc9\xfe\x18\x39\xd5\x68\xcd\xa3\x31\x29\x6c\x54\x0c\x95\x1f\xf2\x99\x5c\x6e\xb3\x9b\xc1\xa0\x14\x7e\x9f\xcb\x3c\x20\xec\x72\x29\x28\x85\x9e\xe0\x50\xd8\x1f\xc2\xa1\x48\x89\x46\x5f\xc8\x79\x18\x7b\xc2\x94\x19\x97\x8d\xd1\xe4\x30\xe2\x04\xe9\x8c\xf6\x10\xd2\x84\xf1\x7b\x90\x91\xfb\x40\x09\x3f\x05\xbb\xbe\xe7\x3f\xcd\x85\xbf\xd0\x8f\x82\x96\xf8\xf3\xe7\xfb\x7f\x74\xfd\xe8\x1a\x33\xf5\xb7\xef\x5b\x5d\xf9\x3b\xa6\x5b\xec\xed\x41\x70\xb4\xbd\x38\x4f\xd2\x79\xbc\x7a\x2f\xa5\x97\x53\x72\x5f\x8c\x07\x3b\x58\x0f\x50\x41\x8f\x87\x55\xab\x9d\x04\x47\xc2\xfc\x10\x8e\x84\x08\x38\xdc\x88\xfe\xc6\xe8\x11\x50\x68\x1f\x9f\x07\x4c\x04\x34\xc2\xcf\x64\x46\x61\x45\x7c\x58\xb7\x8b\x99\xf7\xe4\xc8\x05\x03\xb3\xfe\xd8\x74\xb0\x19\x3d\xa0\x09\x32\xc4\xec\xc2\xa7\xb6\xf7\xd8\x0d\x0a\x81\xf7\xe0\x61\xa9\xff\x28\x96\x1b\x66\x2b\xd5\xb0\x9e\x68\x6d\x18\x98\xc8\x26\x30\x70\x59\x5c\xac\x9a\x69\x22\x03\x91\xf5\x64\xb6\x89\xeb\x59\x2f\x7d\x27\xc1\x80\xbe\x33\x35\xe0\x6f\xbc\x9e\xe8\x3b\xa4\x37\x1e\x91\xcf\xbf\x8b\xe3\xc8\x24\x59\x8b\xc7\xf2\x39\x35\xd6\xa7\x57\x34\xf9\x0e\xc1\x8e\x27\xb6\x82\x17\xc7\xd9\x2b\x7d\x27\x0e\xcb\xe7\x34\x7f\x8c\x02\x36\xb1\x2f\xa4\xff\x29\xd1\xb3\xff\x13\xf5\xe6\xb4\xa8\x67\xc8\xd7\x80\x25\x16\x5b\x74\x5f\xee\x08\x0e\x6a\x6f\x09\x07\x95\x5e\x49\x7d\x24\xea\x99\x03\xe9\xd9\x62\x87\x2b\x1a\x07\x35\xf2\xfc\xa3\xd2\xf3\xd1\x3c\xba\x49\x34\xb9\xf0\x3c\x96\xda\xad\xb0\xa9\x3d\x16\xc6\x98\x25\x8d\x81\xe6\xf1\xb9\xf4\x9d\x18\x3c\x8f\x75\x6e\xa7\x30\xca\x43\xf3\xf8\x39\x32\x0e\x04\x17\x23\xdf\xc1\xe3\xdc\x30\x7b\x1e\x39\xce\x42\x82\x01\x2b\xcc\xe5\x19\x7c\x6d\x3f\x4a\x9f\x7f\xb3\xfb\x9b\x8e\x23\xec\x05\x93\xf9\xfc\x55\x9c\x4f\x85\xf4\x1d\x2f\x1e\x67\xa0\xcb\xc1\x9a\x9b\x7c\x87\xec\xc3\x92\x75\xf9\x43\x9c\xcf\xad\x46\xf3\xe9\xe3\x76\x9a\x55\x4d\x6c\x78\x3e\x3f\x82\xf9\x2b\xb2\xe1\x0a\x7c\x57\x43\x06\xe5\x0c\x27\xe7\x90\x45\x53\x29\x68\x7c\x38\x2b\x93\xcb\x61\xa4\x35\x23\x39\x9c\x8d\x2a\x76\x12\xaf\x1b\x90\x0a\x52\xe6\xaf\xde\xba\xac\x4f\x56\x8c\x3f\x52\xb4\x05\xdf\xd7\xd8\x21\x1c\xca\xa2\xe7\xe2\x31\x02\x28\xce\xb5\xa2\x18\x4c\x41\xb5\x0c\x39\xd1\x18\x72\x0a\xf7\xb8\xe7\x54\x4a\x05\x5d\x1c\x56\xe8\xf0\x20\xc5\x61\xb9\xa5\x61\x10\x7c\x03\x1c\x6f\x5c\xe7\x34\x1e\xc5\x04\xad\x4e\x7e\xe3\x33\x64\x4b\xfd\x63\x0c\x46\x7e\x09\x6f\xa1\xa3\x07\xa3\xb9\x93\xfe\x98\x84\x5f\xd7\x45\xdf\x1a\x2b\xc9\xbe\x17\xeb\xcb\x5e\x14\xe9\xd1\x4d\xf8\x45\xfa\x45\x10\x7e\x3d\x10\xed\xec\x69\xe9\x3b\x7e\xac\x2f\xb3\xbc\x6e\x05\xdd\x98\x5f\xf5\xcf\xa3\xb5\xc4\x77\x44\x9c\xb8\x37\x97\x53\x27\xd3\x58\x29\x4a\xed\x30\xd8\x0c\x6a\xad\x86\x75\x99\x4c\x6e\x87\x0e\x7b\x3c\xe4\xf7\x34\x46\xa3\x65\x40\xd8\x08\x35\x4e\x94\xb8\x1a\x19\x05\x6e\x19\xe9\x8a\x4e\xfd\x9b\x5c\xe3\x88\xda\xba\x24\x07\xf6\x30\x92\x5e\xe7\x03\xe1\x3e\x87\x74\xad\x04\x9c\xcc\xf6\xee\x5c\xd3\xad\x63\x4c\xcb\xbc\x99\x1e\xeb\xd3\xf3\x9e\xf7\x34\xba\x64\x32\x68\x3b\xff\xf5\xd6\xb5\xb6\x3d\xb6\xa7\x26\xd3\x1b\x36\x0a\x97\x4d\x78\x05\xa2\xbd\x9c\x2f\x25\xf7\x4c\x9c\x54\xff\x50\x86\x4d\xcb\x59\xe4\x66\x46\x26\x73\x98\xad\x16\x16\x05\x31\x6e\x99\xcd\x6e\x2b\x0a\xa3\x98\xde\xe2\x74\xa2\x85\x71\xea\x2c\x5c\x49\xd8\x62\x51\x1b\x4a\xc2\x5a\xf5\xff\x44\x79\x30\xea\x0a\x4a\xf0\x61\xfa\x23\xf7\x51\x3a\x4f\x8e\x9e\xc0\xd4\xa8\xcb\x29\xfc\xd6\x06\xda\xc9\x2d\x15\xe1\x9c\xb3\x94\x9c\x73\x3a\xb1\xdd\x36\x9b\x74\x16\xbb\x1d\xe5\xb2\x2a\xd6\x68\x62\xac\x36\x9b\xdb\xe0\xb2\xd8\x75\xd0\x60\x35\x41\x83\x11\xca\x71\x29\x96\x44\x6c\xe4\xc0\x1b\xfd\x17\xe9\xad\x4e\x02\x8c\xe8\x2a\x88\x84\xc4\xa8\x13\x4f\x2b\xf3\xfa\x89\x6d\xbd\xda\x7a\xb3\xda\xe5\xf5\x89\xb5\xf0\xdf\x34\x3d\xf9\x2c\x4f\x9c\xb6\xf2\x80\x71\x97\xa5\x6f\x28\xa1\x28\x85\xce\x6a\x74\x02\xda\xb3\x90\x12\xcf\x3f\x4b\xc9\xf9\xa7\x03\xd3\x6b\x32\x6a\xcd\x36\x9b\x01\xd3\x6b\x30\x32\x16\xab\xd5\xa5\x77\x9a\x6d\x5a\xa8\xb7\x18\x51\xde\x01\xe5\x25\xff\xbf\xe9\x4d\x6c\x38\x08\x75\x02\xb8\xf8\xe0\x86\xe2\x36\x31\x59\xad\x73\x8b\x5a\x1d\x69\x7c\x1e\xba\x76\xfd\xd4\x35\xfb\xad\xdb\x2c\x3d\x3b\x17\x4d\x00\x33\x1a\x1d\x8b\x7e\xc5\xdf\xc4\x7c\x15\x7a\x22\x53\x06\xdc\x45\x50\x0f\x34\x4a\xad\x01\xf7\xd3\x97\xb3\x72\xa8\x56\x9b\xa0\x51\x0f\x58\x19\x8b\x84\x57\x29\x93\x41\xdc\x9c\x17\x1a\xc5\xba\xdc\x68\x8c\xc1\xa8\x0c\x19\x9f\x1c\xe3\x48\x4d\xe8\x47\x8d\x24\x15\x48\x67\xc7\x21\xfe\x25\x2f\xa8\xe6\x2f\x8b\x6c\xbc\x0b\xfa\x78\xf9\x17\x41\x37\x72\x82\xbc\x7e\x0b\x5d\x46\x18\x78\x60\x4b\xdd\x78\x81\x7f\x42\xaf\xa6\xff\x4c\x57\x91\x44\x17\x4a\x9c\x2d\xff\x85\x2e\x28\xd0\x05\x09\xcf\x10\x5d\xd2\xd9\xf1\x61\xfe\x03\x37\x48\xfb\x52\xe0\xd7\x58\xd0\xda\xcd\x5f\xf8\x0d\x1f\x20\x83\x5b\x1b\xc0\x1b\x98\x55\x7c\xde\x06\xde\x49\xf6\xf4\xd1\xd2\xb2\x65\x62\x3f\xdb\xb4\x10\x5a\x3f\xa8\x32\x29\x14\x66\x99\x1a\xa9\xb5\x8c\x42\xcc\x31\x44\x0e\xd7\xf3\x1b\x55\x85\xa2\xe1\x71\x9b\xeb\xb8\x64\x60\x0a\x02\x7c\x27\x93\xb4\xd7\xe8\xf8\x2d\xff\x0b\x68\x01\xe4\xe0\xc0\xa8\x73\xfc\x8f\x59\x7c\x0d\xbf\x60\xd7\x36\x50\xf9\xe1\x89\xeb\xf7\xe9\xf8\x3f\xe7\xd2\x6f\xf3\x17\xa7\xcf\x11\x72\x9d\xbb\xcc\xf3\x24\x27\xec\x2a\xd0\x51\x7f\x8f\xeb\x45\xe8\x20\xbd\x1f\xa1\xd1\xa5\x54\xc5\xda\x55\x46\x26\x29\x39\xc1\x53\x1d\x4e\x30\x59\x94\x03\xc2\x16\xbf\xc5\xaf\xb3\x41\x95\x4e\x27\x1b\x10\xd6\x49\x40\xbf\xc2\x65\x4c\x51\x81\xa3\xee\x6b\xc5\x8a\xbb\x06\xf9\x00\x8a\xa0\x73\x84\xd8\xa8\x13\x64\xdc\x69\x94\x5e\x55\x7b\x61\xe9\xf2\x43\xe7\xfd\xb1\xfa\x41\x93\x57\x0d\x7a\xf7\x1b\xd0\x12\x18\x40\x78\xca\xb9\x13\xa6\x8b\x73\xd6\xc6\x14\x9e\x28\x6a\xfe\xd3\x15\xfe\x37\x7a\xe3\xee\x8d\x23\x26\xbe\xfc\xc2\x11\x3e\x61\x50\x97\xf8\x0b\x87\x3f\xff\x95\xee\xf3\xa0\x7f\x65\xd6\xfb\xdb\x9f\x01\xeb\xf9\xa1\x5f\xde\x44\x73\x40\x73\x92\x05\xd9\x4b\x94\x8f\x4a\x47\x99\x43\xb3\x54\x14\x9d\xc4\xd8\xec\x76\x6d\x0c\x64\x32\x5a\xb8\x4d\x18\x7c\x48\x83\x82\x4b\x15\x67\xb3\x51\x1c\x97\x5c\x14\xe6\xf4\x94\xff\xa1\x26\x96\xc6\x1c\x63\x4e\x7e\x54\x5b\x96\xe0\xa3\x5a\x94\x09\x73\xc0\x28\xcc\x42\xe7\x24\x59\x62\x03\x28\x0b\x81\x8e\xd8\xb7\xff\x74\xcd\x8d\x17\x2b\x56\xc4\x31\xc6\xd2\xe3\xef\xea\x5f\x98\x38\xcf\x9d\x78\x22\xa9\xd9\xd7\x67\x9e\xdc\xe1\x9f\xfb\x4e\xbf\x59\xa5\x19\xc3\x4b\x67\xaf\xee\x5b\x65\x39\x73\xe4\x3c\x98\xf3\xca\xe0\xca\x1a\xf0\xc6\xfd\x3f\x8a\xb2\xde\xd9\xbd\xf3\xc2\xe5\x5b\xd7\x06\x8d\xbc\xb4\xb2\xf7\x0b\x80\xea\xb1\x60\xc9\x26\xfe\xcc\x7c\x7c\x03\x12\x50\x6f\xa1\x35\x92\xb1\x9b\xa8\xe6\x54\x9f\x50\x73\x9f\xbf\xb9\x21\xc1\xc9\xc9\xe5\x4e\x83\xc5\xcf\xa6\xa6\x25\x5b\x2d\x56\x0b\x72\x10\x9c\x95\x53\x07\x7c\xbe\x40\xc0\x33\x20\x1c\x60\xd4\xb0\x3a\xac\x8e\x1c\xe3\x49\x3d\x46\xd3\xd3\x1f\xea\x95\x4a\xee\xcc\x5a\x1b\xd6\x05\xcd\x17\x43\xb2\x3d\x74\xa7\xc7\x2a\x5e\xe9\x61\x52\x47\x56\x4d\x9a\xef\x46\xcb\x93\xf2\xd5\xf9\x63\xe7\x19\x66\xcd\x53\xa5\xee\xd0\x6b\x87\xe7\x8d\x59\x72\xac\xcd\xfe\x2d\x60\xdd\x6b\xdf\x1c\xdb\x37\x6b\x21\x28\x18\x3e\x44\x58\xa1\xaf\x6f\x1c\x7c\xa1\xa0\xd3\x90\xca\xa7\x16\x2f\xa9\x9c\x30\x75\x41\x3b\xd0\xf7\xe4\x96\xa7\xce\xd9\x2d\xcb\x46\x0a\x7b\x56\xc8\x67\x3e\xcb\x14\x52\xc9\xf8\xce\x9d\x3d\x51\xcf\xc4\xf8\x7c\x4c\x22\xa5\x64\x9b\xa5\x98\x01\xfa\x7d\x51\x18\xc4\x80\x18\x4d\x5c\x9c\xab\x28\x1c\x67\x55\x28\x34\x1a\x0e\x69\x6a\x74\x03\x55\xf1\x20\xa7\xe9\xcc\xd0\xbc\x1e\x73\xf3\x46\xd8\x2c\x8d\xac\x21\xee\x22\x57\xd0\xf4\xb6\xcd\xd8\x29\x34\xdd\xad\xb4\x7a\x9c\x1f\x2d\x5e\xda\xc5\xe3\x07\x0e\xad\x03\xbf\x35\xbd\x68\xa3\xaa\x19\x3d\x70\xe8\xc6\x83\x17\x2e\x7f\xff\x7f\x2f\xee\xab\x2e\x15\xe2\x9f\xb7\x50\xfc\xf3\x3a\x5a\xab\x04\x5c\x03\xee\xa6\xa8\x58\x5f\x40\x61\xb5\x06\x1c\x2c\x86\x04\x77\xc8\x90\xa1\xa9\x46\x0a\x6e\x8c\x8d\x8b\x8b\x19\x10\x8e\x33\xea\x74\x46\x23\x52\x79\x23\xd3\x30\xa1\xc8\x25\x96\xe8\xf9\x88\xaa\xd5\x32\x8d\x80\x63\x90\x8b\xd8\x8f\xb8\x6c\x25\x44\x35\x59\x70\x45\xdb\xd9\x0b\x06\xbb\xbb\x82\x83\xd1\x77\xab\xde\xaa\x5d\x3c\x8d\xcd\xd8\x3a\xee\x78\xaf\xa7\x0b\x14\xe0\xdd\x6e\xfd\x12\x9e\x02\xaa\x86\x2b\x55\xeb\xcf\xb8\xcc\x33\x27\x1b\xd3\xff\xc4\x81\x16\x98\x9a\x26\xee\x27\xce\x23\xe7\xaa\xbd\x43\x29\x94\xda\xee\x74\x9a\xbc\xac\x4c\xe6\xf7\xaa\x99\x84\x78\x5d\xac\x3f\xd6\x8f\x2b\x43\x15\x0e\x97\xcb\x5a\x1c\x76\x59\x58\x56\xa1\x80\x45\x61\x85\xfe\xbf\xcd\x45\x5c\x9e\x46\x4b\x23\x93\xee\x44\x91\x39\x64\x4b\x37\xa7\xe8\x77\x1a\x96\x65\xff\xd2\x01\x93\x65\xbe\xe9\xb8\xb4\x2d\x53\xbd\xe0\x05\xb4\x64\xb0\x9d\xb4\x20\x13\x9f\xd2\x42\xc5\xe8\xc1\x96\x16\x9b\x70\x08\xf7\x73\x9b\xb4\x3e\x05\x4b\x06\x91\xf3\x14\xa4\x3b\x53\x90\x7d\x8b\xa7\x0a\x90\xaf\x0f\x18\x28\x97\xdb\x4d\x05\xa0\x3c\x51\x9e\xe0\xc2\x78\x56\xb6\xea\xb0\xcf\xf4\xd8\xd3\x94\x26\x87\x01\x86\xc7\x9d\xa6\x44\xed\x93\x4a\x3b\xa4\xcc\x20\xbe\xa8\xe9\xd9\x8a\xe6\x84\x69\xdc\x90\x88\x71\x7b\xed\x4d\xeb\x23\x0e\x59\xb0\x71\x1b\x3a\x4c\xb2\x6e\x2f\x3d\x9b\x3d\x8e\x12\x7b\x82\xca\x7a\x20\x1f\x16\x4f\x75\x09\xc5\xdb\x28\x33\xae\xae\x46\x1e\x54\x95\xa8\x4a\x08\xa0\x04\x33\x60\xf5\x7a\x15\xa6\xa8\x93\x17\x85\x35\x52\xc3\x49\xe6\x90\xff\x50\x69\x6a\xcb\xac\x87\xcf\x5c\x22\x96\x5b\xd4\x0d\xa8\x57\x4c\x7c\xc4\x01\xcc\x02\x7d\xbf\x5e\x23\x66\xfb\x90\x6e\xa4\x5f\x3d\xf5\xfc\x21\xe0\x72\xb6\xa3\x3b\x37\x3e\x8b\xa9\x1b\x52\x94\xd2\xb7\x74\xf3\x73\x17\x2e\xdf\xf9\xeb\x36\x11\x5f\xfe\x24\xd9\xf7\x0d\x85\x02\xd0\x88\xb1\xc9\x8d\x4e\x97\x5d\xe6\x8d\x71\x59\x71\x92\x6f\x77\x28\x95\x3a\x8f\x03\xda\x8d\x3a\x59\xb5\xe0\x63\xa4\xeb\x1a\x86\x46\x1b\xf9\x4d\xb6\xa5\x45\x76\x67\x49\x70\xc3\x26\xb6\xa6\x09\x93\xe5\xa9\x75\x3d\xc5\xd3\x86\x63\x48\x12\x9a\xf2\x37\xa6\xeb\x6d\xe9\xe4\x81\x12\xf0\xe1\x65\xe9\x88\xcf\x6e\xaa\x6d\xc8\x27\x57\xa9\x1c\x26\x07\xc3\xd2\xac\xc7\x6b\xd3\xe2\xb2\x29\x96\x2a\x0e\xb3\x46\xd6\x48\xcb\xa1\x8e\x16\x0f\x65\x9a\x38\x41\xa9\x5d\xa7\x70\xe0\xd1\x98\xa3\x48\x71\xb3\xb2\x41\x2b\xe1\x34\xe6\xeb\xf0\xb1\x05\xfa\x3e\x85\x11\x46\xf2\x87\x95\x76\xe1\xb0\x01\x1f\x3e\xd4\x0d\x29\x49\x96\x18\x08\xd2\x3d\xa1\xa9\x42\x8e\x31\x14\xd9\xcb\x7f\xb0\x9b\x91\xff\x6e\x26\xe0\x39\xa1\x1c\x5d\x83\xf7\x3e\xe9\x38\xa1\x46\x16\xfd\xfe\x45\xc4\x67\x07\x95\x1d\xf2\xa0\x00\xcb\xa2\xb2\x5b\x8c\x56\xd6\xe9\xa2\xac\x36\xc4\x68\xc4\x64\x94\x19\x47\x71\xb8\xf1\x79\xe7\x63\xd9\x2b\x96\xca\x6e\x31\x8d\x8e\x66\xad\x7a\x97\x54\x34\xfb\xe0\xb7\xc1\xe9\xd1\x5c\x4d\xe8\x07\x9b\xed\xd8\x21\xf0\x53\x3e\x85\xe9\x89\xf2\xa9\x7e\xa1\x8c\x96\x2e\x2f\xa5\x6d\x83\x9b\xec\x9a\xb4\xde\x66\xa9\x09\x5c\x7e\x28\xdb\x5a\x14\xce\xd6\xb7\x40\x96\xa4\x85\xbe\x65\x6a\x32\xc7\x25\x24\xeb\x5c\x09\x16\x35\x6c\x28\xcd\x08\x0a\x9d\x12\x72\xf2\x1b\x73\x59\xca\x19\x9b\xf0\x37\x1f\x44\x17\xd3\xfe\xe7\xba\x5a\x1d\x90\xb1\x7f\x16\x95\x0c\x9d\x86\xcd\x7c\xc6\xc7\x27\xf8\xa3\xfa\x14\x7b\x8f\x7e\x93\x0e\xfa\x84\x9e\x86\x8f\xa9\xaf\x35\xa7\x6b\x81\xbf\x38\xbc\xf6\xf0\x85\xcb\x3f\x7f\x08\x9a\xe5\x75\xbb\x3e\x3f\x55\xa8\x9e\x7d\x6c\xa5\x6d\xe7\x01\xbf\x74\x20\xeb\x55\x84\xd6\xeb\x3a\xbb\xc9\x28\x03\x25\x42\x5f\xd6\xfa\x7b\x70\x07\xee\xcb\x0a\x87\x8b\xe7\xbf\xa5\xe4\xfc\xd7\x8d\x71\x6e\x69\x83\xc2\xe9\xf4\x1a\x3c\x2e\xb9\xd7\x81\xc2\x30\x07\xd4\x99\x07\x84\x0d\x68\xe9\x30\x68\x40\x03\x86\xa2\xe4\xe4\xa5\x22\x47\x63\x4e\x54\x93\xb1\x87\xad\x15\xa0\xa1\xb5\x3a\xc7\xd6\x32\xab\x5d\x1f\x13\x60\x1e\x71\x02\xcc\x5f\xcd\xe5\x4b\x4d\x5b\x34\x85\xd5\x6c\xde\x43\xf6\xe9\x4f\x86\xff\x98\x9c\xff\x96\x32\xf3\xc9\x5d\x79\x89\xce\x18\x83\xd7\x25\x8f\x71\x28\x8b\xc3\x0e\x9d\xce\x5c\x84\xe8\xb4\x36\xc1\x7a\xfc\x8f\x74\x3e\x6c\x8c\xb4\x80\x9e\xd2\xb3\xa5\xad\x59\x52\xdb\x5c\xe3\x65\x7e\x65\x53\x2b\x74\xe9\xae\x17\xf7\x3c\x5b\xa3\xe8\x55\xc1\xc4\x36\x36\x3e\xf7\x43\x3b\x96\x62\x5d\xe1\x6b\xd8\xdf\x89\xae\xb4\x14\xf6\xf9\x11\xcd\x43\x49\x0f\x5c\x61\xaf\xf6\x08\x45\xc9\xd3\xc8\x39\x02\xe9\xa1\x4b\x0d\x43\x39\x7f\x2b\xd2\xd3\xb5\x3f\x5e\x0b\x7e\x3d\x3f\x97\xf2\xd4\xbf\x4f\xd9\x28\x7f\xc8\x64\x94\xe9\x74\xaa\x9b\xb8\xef\x4d\x08\x14\x81\x6a\xc0\x00\x03\x95\x7e\xa9\xb2\x32\x13\x67\x09\x2d\x32\x4c\x81\x2c\xa9\xa7\x3c\x46\x3f\xc7\xf2\x88\xfd\x19\xa7\x1e\xa6\xf6\xc5\x07\x83\x0a\xf9\x50\x95\xbe\xef\x13\xfa\xe1\x86\xdc\x16\x32\x7e\x6e\x57\x9d\xcf\x93\x96\x95\xde\xa2\xb4\x42\x59\x55\xa5\x0c\x05\xbd\x18\x82\x02\x30\x6c\x21\xbd\x54\xf6\x2a\xa5\x42\x23\x06\xa8\xa4\x90\xd5\xa2\x50\xe8\x74\x10\xbc\x04\x7f\x84\xf5\x10\xc2\x90\x42\x53\x00\x5d\xfe\x5a\x90\x87\x6c\xfb\xa5\x94\xca\x89\x18\xbf\x89\x58\x72\xa9\x15\x48\x42\x76\xd4\x6b\x2e\xea\x35\x60\xd2\x7c\xb1\x69\x69\xb1\xbe\xb4\x6f\xa4\x17\x5b\xa5\x17\xb2\xf1\xbe\xd4\x54\xe1\xb5\xf0\xf3\x25\x5f\x1a\xf9\x1d\xb6\x27\x5a\xb6\x10\x2c\x97\x3d\x40\x34\xa9\x8e\x50\x32\x32\xf4\x25\x9c\x94\xdb\xd0\x7f\x81\xec\x44\x8c\x64\xb4\xfc\xd0\xf2\x43\xab\xce\x4f\x3f\xb4\x12\xfd\x94\x3d\xe8\x17\xf9\x1f\xce\x2f\x80\x1e\x7d\xff\x73\x71\x4e\xb1\x21\x93\xa2\xe9\x74\x74\x96\xa8\xe9\x34\x9e\x4b\x23\xfa\xdb\x4a\xd4\xa6\x3c\x44\x76\x03\xb9\x88\x87\x34\xe2\xe1\x6e\x34\x1e\xc6\x39\x70\x51\xcd\x43\x76\x93\xc3\x41\x69\x38\x4e\x47\x83\x97\xe8\x1f\xe9\x7a\x1a\xd2\x78\x5c\x9a\x22\xc3\x5e\xc6\xa3\x46\x3c\x22\xb2\x77\xa6\xc7\x8d\x4f\x17\x8c\xeb\xba\xfe\x21\x1a\xd0\xe4\xc6\xf1\x1b\x80\xbf\x29\x25\x80\xff\x90\x9f\x5b\xff\x27\xca\x3c\x55\x94\xfa\x18\x2b\x9b\x47\x51\xe9\xce\x4b\x68\x7e\x02\x1a\x30\x47\x22\x84\xd3\xec\xc0\x32\xcb\xe2\x75\x5c\x89\xdd\x5a\xd0\x6b\xd4\xb4\x09\x81\x04\xc4\xef\x54\xb6\x0c\x54\xc8\x0e\x20\xfa\x55\x47\x20\x10\x88\xc4\xfc\x46\x7c\xae\xa8\x9d\x5e\x2b\xa3\x0e\x1c\x38\x80\xed\xc4\x7a\xb6\x08\xfc\x20\x5b\x48\xc5\x22\xae\x6a\x0c\x1e\x4a\xed\x41\xff\x59\x6d\xf3\x58\x61\x8d\x82\x68\x34\xe1\xba\x2b\xa9\x2c\xc6\x29\x19\xbe\x92\x41\xd0\xda\x6c\xe2\xc5\x7d\x7c\x24\x22\xcc\x2e\x31\x0d\xa4\xa3\x59\x25\x27\x34\x0f\x77\x1f\x99\xef\x6a\x15\xf0\x65\xa4\x26\x27\x35\xeb\x5f\x90\x55\x14\xe7\xcd\x94\xe5\xb4\x48\xcf\x30\x14\xe8\xba\xa5\x15\x56\xcc\x6d\xd9\xb2\x45\x7a\xba\x11\xff\xa3\x57\x79\x6e\xc7\x9c\x74\x4c\xcb\x7c\xb6\x90\x3a\x28\x9b\x8b\xe6\xaa\x23\x73\x25\x14\x90\xe9\x9a\xc4\x38\x0e\x97\x48\x05\x99\xca\xb0\x65\xf1\x5a\x39\x5b\xa8\xf7\x77\x2e\x1c\x3b\x63\xac\xad\x15\xfa\xee\x64\xa4\x63\x57\xeb\xbf\xa5\x58\x4a\x7b\x12\x2b\x16\x0d\x18\xac\x56\x58\xa1\x12\xb3\x83\xdc\xfa\xb5\x6b\x3f\x5d\xfb\x29\x3f\xf7\xf8\x71\xbc\x75\x43\xd1\xfc\x0e\xf4\xf9\x98\xfa\x9f\x28\x8e\x32\x51\xc6\x57\x38\x2e\x04\x01\x34\xa8\xa8\xf4\xe0\xa5\xca\x9c\xf4\x16\x19\xb8\x32\x0f\x85\x8d\xd9\x6c\xd4\xda\xc5\xb8\xdf\xdf\x61\x1e\xb6\xc2\xc8\xf3\xd2\xb2\x95\xac\xde\x33\x6a\x64\x85\xba\x41\x6e\x00\xb5\x07\xc9\x4d\x3c\x9a\x03\x87\xe6\xc0\x40\x69\x0e\x18\xc6\xcd\x44\x80\x21\x65\xdc\x1e\xd7\xa5\x1d\x96\x61\x4b\x4d\x6c\xe1\x9a\xbd\x63\x87\x57\x22\x7b\x21\x7e\x47\x2f\x63\xfe\x8f\xd4\x21\xf6\x6f\x78\x06\x65\x7b\x45\xad\x52\xa1\x07\xc9\x85\x27\x61\x44\x38\xa2\xac\xd2\xd3\xfc\x4d\x9e\xca\x77\x43\x2f\xcc\x23\x97\xea\xc5\xc7\xa3\xbf\x46\x96\x53\x0c\x7f\x91\x6d\x4b\xdf\xe0\x92\x89\x34\xa7\x50\xd9\x54\xe0\x64\x7a\x7a\x32\x48\x6e\x15\x40\x8f\x3d\xe9\x48\x47\xb3\x37\x29\x44\x0d\xaa\xcc\x24\x7f\x35\x52\xa2\x44\x24\x38\x09\xd9\x66\x6b\x24\x99\x63\x45\xf0\x21\x01\xbe\x2f\xd3\xca\x91\x77\x05\x87\x0f\x52\xe7\x84\xcb\xe7\xcc\xae\x6c\x9b\x5a\x56\x52\xe6\x99\x99\x9d\x98\xd4\x26\x37\x21\xae\x0d\xff\x89\x07\xfd\x3b\xb5\x6d\x45\xcd\x9c\xf2\xf0\x9c\x99\x6d\xe2\x12\x73\xdb\x24\x27\xb4\x96\x95\x84\xe7\xd4\xf4\x0f\xcf\xb1\x97\xf5\x29\x4b\xcf\x4d\x6a\x9d\x93\x98\x98\xd3\x3a\x29\x37\x1d\xfd\xd3\x8e\xdf\x9f\x13\x4e\x6a\xdd\x3a\x09\xbd\x47\xf6\x19\xf0\x3c\x8e\x8b\xf3\x30\x35\x26\xfc\xad\xff\x46\x33\x60\x1e\x49\xd7\x23\x09\xc0\xf2\xc8\x23\xb5\x5c\x29\xdb\x46\x19\x28\x3b\xd2\x75\x86\x51\xe8\xd0\x02\xcb\x05\xdb\x45\xec\xb5\x00\xed\x87\x47\x42\x61\x1a\x27\xc4\x0f\x60\xa5\xd2\x34\xb2\x34\x60\xb6\x0c\xc9\x1f\xea\x52\xc6\x64\x64\xa8\x94\xb2\x6d\x99\x65\xc3\x94\xc3\x40\x8f\x15\xea\xd4\x6c\x82\xcb\x07\xf8\x37\x91\xfc\x15\x22\x9f\x60\xa1\x3c\x21\x9d\x81\xb3\x68\x68\x9a\x22\xfe\x00\x02\x0e\x0b\x2e\xf6\x06\x78\x9d\x61\x20\x9b\x14\x09\x6a\x41\x43\x00\x28\xe3\x6a\x86\x19\xc7\x18\x87\x70\x9c\x3f\x39\x23\x5d\xa5\x1c\x2a\xf7\x6e\xe0\xe7\x56\xe8\xc7\xba\xca\x62\x13\x8c\x31\x9e\x8c\x56\x2d\x5a\x3c\x67\x17\xc6\xd9\xc5\x3f\x4b\x05\xea\x6f\x20\xbd\x50\x1f\x83\x74\xc4\x7e\xd8\xa0\x3f\x3b\x98\x1d\xc8\xe3\x4f\x99\xaf\x25\x07\xf8\x77\x46\x5d\x41\x9f\xfd\x08\xd1\x94\xfd\x28\x1d\x82\x44\x87\xb4\xeb\xd6\x5f\x5d\x7b\x35\xa2\x43\x80\xaf\x45\x9f\x6f\x8b\x6c\x13\x87\x9e\x8d\x65\x1d\x3d\x1b\x0b\xba\xa4\x3b\x6d\xdd\x17\x77\x61\x91\x2c\x59\xf3\x17\xa4\x25\x48\xe7\x90\xc3\xa2\x3e\x22\x9f\xd7\x51\x66\x51\xae\x75\xb8\xd3\xbb\x24\xd4\x9c\xf8\x4d\xbf\xf8\x73\x3a\xd2\x38\xfc\x04\x70\x92\xa8\xde\x32\xa3\xa0\x70\xe8\xaf\x11\x95\x68\xfc\xcb\xe8\x79\x8e\xfa\x3f\xf0\xf8\xc7\x43\x00\x00\x56\xa4\x96\xcd\x07\x89\xf1\x3a\xa0\xe6\x3f\xd7\x6f\x98\x0b\x92\x75\x9b\xf8\xa3\xc1\x22\xeb\x17\xc1\x1e\x0e\x21\xb7\x8e\x47\xeb\x5a\xf8\x5f\xed\xcc\x55\x64\x67\xcc\x8b\xd7\x49\x76\x66\xfa\x38\x64\x67\x68\xfe\x1b\xb6\x2d\xf5\x51\x44\xfe\x4c\xe9\x1a\xa0\x71\x70\x11\xc5\x41\x4f\xf8\x0f\x7a\xb1\x19\xcb\x7f\x7a\x9b\xf2\x39\xf3\xc2\x65\xf3\x66\xb6\x89\x4f\xc8\x6d\x93\x94\x88\xe4\xbf\x6d\x86\x20\xeb\xfd\x6b\x66\x97\x27\xb5\x6e\x93\x90\x98\x93\x83\xe3\x08\x49\x46\x90\x5d\xf8\x9b\x70\x5e\x41\x7c\xe8\x49\xb4\x3e\x86\x93\xbd\x98\x01\x0c\xcd\x00\x51\x18\xf1\x85\x26\xbc\x44\xa0\x13\x59\x23\xb6\x50\x5a\xa3\xfa\x3b\xe8\x3b\xe3\x65\x4b\xd1\x77\xec\x21\x15\x1c\x40\x8d\xa7\xe6\x22\x9f\x30\x8f\x16\xe7\x5c\x29\x14\x32\x21\x59\x00\xe3\xf3\xf8\x5a\xcb\xb5\x64\xd9\x52\x22\x0d\xc4\x1e\xa3\xf1\x0f\xfd\x67\xdf\x23\xc7\xf5\x4a\x4b\xd7\xc9\x4b\xf4\x9e\x82\xa2\x51\xd3\xc7\x39\x33\xd0\xba\x0c\x63\x8b\xa8\x37\xff\x57\x9f\x02\xff\xbb\x4f\x79\xf0\xff\xec\x53\x68\xa4\xc3\xd3\xc1\xcb\x68\xbd\x70\xdc\xa0\x3f\x09\xd3\x75\x40\xa7\xb0\x10\x33\x9f\x29\x6e\x1d\x88\x8b\x13\x1f\xed\xa5\x5b\xb5\x89\xc3\x8b\x93\xd0\x9a\xbf\x58\x53\x51\x3e\x07\xff\x91\x95\x08\x4b\xd3\x3a\x41\xf8\x77\x0d\xf1\x23\xf5\x5a\xe4\x9f\xaf\xd6\xff\x40\x9e\x6f\x0b\xa9\x75\x94\x05\x84\x2c\xbb\x2d\xb4\x45\x01\xc9\x28\x38\x18\xe1\x1e\x13\x0c\xbc\xf3\x50\x1c\x50\x2d\xba\x92\xa8\x50\x84\x62\xf9\xfe\x68\x1d\x4e\x8a\x63\x04\xa8\x74\xaa\x2d\x95\x18\x32\x07\x5d\xae\x1c\xca\x0f\x42\xfe\xdd\x7e\xda\x9f\x8a\x22\xbc\x44\x1d\x1e\x91\x14\xa7\x5d\x92\x42\x3a\xf6\x7f\x08\xe9\xe2\x1f\xf3\x3e\xdf\xff\xf1\xa1\x1e\x98\x2c\x05\x7a\x29\xd2\x0b\x89\xf4\xd8\x26\x53\xf8\x67\xd3\x29\x41\x7e\x2c\x9a\xcf\x16\x34\x1f\x21\xb6\x42\xf6\xcf\x44\xa1\x78\xd8\x01\x42\x8e\xdd\x0e\xda\xa1\xe1\x04\xc6\x21\x0b\x88\x78\xc7\xa2\x7c\xf1\x71\x94\xf3\x63\xcd\xa0\xc0\xd2\xe5\x21\x2e\xee\x19\x3b\xb6\xc3\xc3\x8c\x6c\x18\x17\xfb\xfc\x18\x2a\x39\x64\x95\xd1\xf4\x87\x48\xaf\xe6\x41\x68\xa3\x3c\x20\xe4\xd9\xed\xa1\x3d\x62\x10\x30\x11\xd9\x77\xac\x1e\xc2\x06\x60\x00\x51\x11\x78\x3c\x1d\x6f\x5b\xc7\x61\x4a\x46\xd9\x1e\x5e\x51\xfe\xde\xa4\xb1\x63\x27\x1d\x7f\xc4\xba\x82\x7a\x1b\xff\x6c\xfd\xf1\xfa\x0e\x68\x5d\xe5\x47\x88\xb8\x20\x6d\x88\x7a\xec\x1d\x89\xb5\xfc\xaf\xd2\xd7\x68\xfe\x59\x64\xcf\x93\xc9\x77\x6c\x94\xf6\x38\x0e\xec\xc9\xaa\xff\xa7\xf8\x9d\x7f\x56\x22\xe6\xdb\x08\x55\xbf\x36\x59\x2d\xc2\x9f\xb7\xf9\x1a\xaa\xa0\xfe\x9e\x28\x67\x68\x5d\x5c\x11\x01\x8b\x1a\x48\x90\xe9\xff\x45\xb2\xf8\xb7\xa5\x19\x44\x24\x68\x9b\xf4\x62\xd0\x63\xc4\x05\xfb\x95\x8b\xf5\x0e\x2a\xbe\x7e\x21\x92\x0f\xf5\x71\x28\x13\x21\xf9\xd0\x90\x7e\xce\xcf\xdf\x40\x7c\xe6\x4f\xd5\x8c\x22\x9f\x43\xbc\xc0\x9f\xe3\x28\xd9\xcb\xe8\x33\x88\x7b\xe2\x42\xdd\x94\xd6\x83\x7f\x76\xea\xa8\x51\x53\x09\xce\x07\xbb\x1f\x18\x65\x9d\x48\xfe\x01\x51\xc0\x90\x8f\xec\x10\xb2\xd6\x51\xd4\x4e\x45\xe3\xa7\xa6\xe2\x60\xfc\xf7\xa8\xbc\xe5\xff\xed\x7b\x90\xdf\x46\x6c\xf7\x4f\x91\x1c\x4c\x67\xd1\xe9\x5c\x2e\xcc\xcc\x2f\xfc\x3f\xf9\x19\x7f\x6d\xfd\xeb\x27\x5c\xde\x02\xbf\x60\x26\x52\x2a\x33\x8d\x24\x9e\x88\x66\xab\xed\x31\xaf\xf9\x6d\x12\x5b\x57\x4a\x2c\x8c\xbc\xa8\x12\x49\x78\x42\xfc\xd9\x25\x2a\x36\xad\xff\x84\x9e\x48\x4d\x84\x5a\x4c\x53\x08\xad\xa6\x22\x43\x51\xad\x58\xa7\xd8\xad\xf8\x50\x21\x53\x08\x2c\x8e\x16\xbf\x54\xe9\x99\xf4\x79\x9c\x96\x04\x52\x53\xf1\x33\x62\x90\xcc\xd6\x92\xb5\x91\x1f\x81\xb4\x20\xb3\xc8\xf1\xfc\x23\x65\x5c\x0a\xff\xec\xcd\x9b\xc4\x4f\xf1\xcc\x4c\x38\x88\xed\x41\x3e\x03\x04\xb9\x26\xa7\x6e\x89\x74\xdb\xe4\xba\xb7\xd9\x1e\x9f\xa0\xcf\x98\xd9\xf3\x60\xa2\x2c\x85\xac\x31\x6e\x00\x0b\x05\x02\xf0\x59\x72\x32\x5e\xe2\x5a\x59\x0a\x5e\x63\xd0\x8e\xaf\x86\x87\xb9\xab\x91\xf1\xd2\x71\x6b\xf8\x20\x7a\x1f\x5c\xdd\xc6\x27\xf3\xd5\x8a\xe9\xbf\x2f\x17\xd6\xe9\x00\x5a\xa7\x2e\xff\xd3\x3a\xfd\xd1\x68\x7d\xff\x5f\xbe\x47\xe3\xca\x24\xf0\x2d\x93\x83\xe8\xe2\xa8\x18\x34\xcb\x5a\xd0\xf1\x78\x18\x30\x0c\x7b\x06\x74\xa4\xc2\x14\x03\xda\x08\x65\x03\x6f\xa5\xa0\xa7\x61\xcf\x8c\xfe\x3c\x48\x7e\x23\x99\x7f\x0a\xfd\x05\x47\x5d\xb9\xf2\x60\xf3\x95\x2b\x78\x6f\x5c\xe6\x00\x89\xc8\xa7\x63\x1b\x00\x15\x84\x57\xd1\x83\x2f\x8f\x64\xa9\x23\xc8\xe0\x68\x11\x40\xbd\x92\x1f\x55\x7f\xa0\x5e\xfe\x38\xbb\xf1\x7b\x44\xcb\x4f\x47\xf2\x48\x2a\x88\x84\xd2\xc1\xbc\x4f\xe9\xa9\xd8\x23\x2a\x79\x7b\x25\x08\x21\x2a\x55\x88\x4a\x9c\x5c\xe3\xd7\x14\xc8\x11\x8f\x79\x04\xd4\x56\xd2\x28\x14\x9f\x49\xe6\x41\x7a\xcb\x7c\xff\xd2\xee\xfd\xdb\x7a\x87\x83\x99\xfe\xba\x2b\x1b\x1c\x3d\x06\xad\x61\xde\x3f\xd8\x6e\xe5\xce\xba\x1f\x0e\xd2\x3f\x2d\x3d\x33\x9c\x60\x79\xd4\x1f\xe0\xe7\x82\xb1\xf5\xbb\x28\x05\xd2\x47\x0e\xeb\x23\x1b\xd0\x81\x40\x3e\x8a\xe5\xfc\xa0\xec\xb8\x9a\x1d\xc3\xa4\x1f\x35\x83\x23\x97\x77\x9b\xcd\xbb\x47\xa3\xcf\x5f\x43\xce\x2d\x11\xd1\x64\xa7\x62\x5e\x51\xd1\x5a\x3b\x6d\xd7\x98\xce\x20\x92\x58\x81\x18\x94\x86\x44\xfa\x3f\x04\x41\x16\xe6\xa2\x96\x16\x20\x7f\xc8\xfd\x36\x3a\x1b\xe8\x2f\x83\x1e\xc7\xbb\xb5\x3f\x17\x8a\xa9\x9e\x3f\x03\xa8\x3f\xe1\x67\xf5\xa8\xce\xdd\xf9\xe6\x9e\x50\xe5\x94\x52\xe6\xfd\xba\x8d\x6b\xa9\xfa\x9b\xd7\xc6\xbc\xb4\x69\x30\x1f\xa0\x2f\xfb\xe7\x6d\xe5\xc7\x82\xb5\x3b\x36\x57\xf9\x04\xfb\x7b\x8f\xa2\x98\xb6\x68\x7c\x13\x95\x78\x4c\xa1\x56\xa9\xa3\xb8\x02\xd0\xef\xf1\x6b\x10\xe1\x8a\x81\xc2\x4b\x93\xed\x17\xef\xd1\x73\xfe\x6c\xf1\xba\xfd\xb7\x7e\x30\xf3\x9b\xcb\xc6\xd1\x8b\x7d\xf7\x3f\xf2\xd1\xbf\x8c\x32\xcc\x59\xc5\xf8\x0f\xee\x7c\xb1\x78\x60\xdd\xb5\x83\x07\xe9\xc4\xbe\x1d\x2a\x2b\x84\xf1\x3e\x47\xbc\x7e\x07\x8d\xe7\xa4\xe2\x4e\x72\x26\x93\xc6\xe9\x74\x9c\x25\xa3\x38\xd1\x28\x32\x4a\x83\x65\x46\xbc\x52\x24\x40\xbc\xe2\x5e\x4d\x01\xa8\xa5\xc9\x5e\x10\xcc\x4e\x83\xb8\xe4\x70\xe6\xd2\x09\xad\x38\xd7\x2b\xda\xb2\xf2\x82\xb4\x8e\xaf\x75\x49\xef\x5e\x5e\xb3\x9a\x35\x35\xeb\xd2\xae\xc8\xcf\xbc\xdf\xeb\xb5\xb7\xeb\x64\xe0\x0f\x6b\xde\xb4\x27\x8f\x9f\x9c\xbb\xaa\x22\x2f\xee\xb5\xc5\x05\xf6\x83\x42\xdc\xbb\x16\xcd\xf7\x2c\x1a\x9f\xa3\x5c\xc7\x64\x90\x81\xaf\x91\xc1\x19\x34\x38\xc0\x43\x8b\x73\xf4\x0b\x78\x06\x01\x98\x5d\x7b\xb9\xae\xa3\x9f\xd1\xfa\xb6\xa1\xf9\x1c\x44\x32\xdf\x05\x7d\x7f\x3f\xfa\x3e\x44\x1c\x0b\x9c\xa0\x69\xa0\x56\xab\x84\x09\xa8\xd1\x33\x4c\xc2\x53\x22\x48\x33\x04\xd4\x34\x08\x04\x26\xf9\x25\xc6\xf1\xb5\xdb\x4f\x81\x93\x2b\x0d\x73\x57\xf1\x1e\x3f\xf8\xf4\x9b\xcb\xa6\x95\xd0\xf3\xe0\x2b\xfa\xa3\xc1\x2d\x2b\x2a\x11\xd7\xfa\x56\xd6\xb5\xc0\xb4\xe2\x4b\xee\x3f\x90\xb1\xb4\x67\x28\x88\xe5\x14\xaf\x44\x3e\xb9\x02\x14\x00\xad\x4e\xfd\x50\xcb\xbc\x7f\x5f\xea\x2d\x80\xf8\x7a\x93\xb9\x81\x7b\x32\x85\x94\xb4\x1a\x68\x34\x5a\x44\x8b\xf6\x34\x68\x4d\xc9\xc9\xc4\x82\x51\x95\x71\x5c\xa2\xd0\x0d\x2b\x0f\x64\xc7\x67\xd3\x37\x13\x87\xb4\xcf\x8e\x53\x2f\xac\x5d\x68\x1a\x3d\x9c\x3f\x1f\xc7\x38\xce\xc5\xfb\x82\x4f\xb4\xab\xeb\x4f\xef\x1a\xb5\xc8\x37\xf9\xac\x48\x0b\x73\x15\xd1\x62\xa0\x1c\x47\x94\x9c\x30\x63\x25\x22\xc7\x40\x29\xc4\x19\x47\xb0\x17\xc8\x7d\x79\x61\xa6\x70\x3e\x99\xe5\x99\xcb\xb5\xdf\x83\x9f\x90\x80\xac\x12\xe6\x78\xff\x26\xf3\x3e\x11\x8e\x16\xc2\x9a\xd4\xdf\x63\x19\xe6\x26\x8a\x47\x12\x8f\x38\x4c\xed\xd5\xe4\xe1\x0e\x44\xb9\x0c\x0d\x40\x21\x99\x10\x74\xb3\xad\x78\x8e\x91\x22\x1e\x25\x67\x47\x8e\x04\x8c\xe2\x19\x1e\x86\xb9\x47\x31\xb3\x9e\xa2\x3b\x7d\xfa\x85\x6b\x7e\xed\x52\xfd\xfc\xb5\x3f\xf1\x05\x45\x2d\x26\x64\x06\xfa\x2f\x1f\x3f\x3d\x87\xdf\x60\x3e\x79\xb8\x6c\x39\xbd\xad\xae\x63\x9f\x9e\xe3\x86\x83\x89\x60\xe0\xd0\x21\x01\xef\xcb\xed\xba\xed\x5a\xc4\xf7\xe5\xe3\x04\x5e\xd6\xd2\x5d\x44\xbe\x9b\x5e\xf1\x41\xa0\xc3\x96\xb9\x16\xb3\xfe\x72\x65\x65\x84\xf9\x35\xa7\x90\x72\xcd\x22\x9f\x5f\xcd\xcf\x85\x9f\xa3\xcf\xeb\x28\xeb\x11\x39\x27\x48\x94\x1c\x93\x0e\xda\x51\x84\xdc\xa6\x02\x40\x67\x5f\xc5\x6c\x99\x29\x68\x0d\x4a\x27\x99\x92\xbe\x1d\xc8\xd2\x17\x0f\xbc\xff\xb2\x90\xb3\x20\x5b\x75\x07\x3d\xd3\x8a\x6c\x95\x46\xd2\x4a\x0d\x16\x53\xd1\x56\x01\xd1\xba\xe2\xe7\x27\x03\xf4\xe4\x2c\xb2\x5b\x4f\x5e\x92\xed\x78\x94\x19\x25\xf3\xaf\xfb\x41\xa7\x57\x3f\x49\xb6\x98\xf9\xf7\xf9\x57\x51\x20\xf3\xc3\xd7\x46\x57\x0b\xfe\xec\xc1\x17\x4f\x0d\x18\xdd\xf3\xcf\x83\xef\x5f\xee\x3f\x68\x61\x3d\xf5\xab\x30\xef\x92\xfa\x4f\x98\x64\x19\xee\xeb\xea\x3f\xa2\xd7\xb5\x57\x80\x5c\xa4\x26\x0c\x19\x8d\x43\x23\xb3\x20\x4b\x6a\x01\x21\xa4\x0d\x04\xad\x97\x20\xcc\x50\x6c\x76\x56\x9c\x11\x8e\x1a\x3c\x9c\xd7\x4e\xad\xed\x03\xd2\xdf\x7c\xf9\x36\xdf\x81\xbf\x92\xfc\x2d\xe8\x73\x1c\xce\x2c\xec\x4f\x57\xf3\xdd\xb6\xee\x3d\xc7\x6f\xe6\x3f\x19\x76\xa5\xf8\x1e\x30\x62\xff\x81\x64\x8a\xa5\xd0\x1c\xe5\x48\x8a\x62\x8f\xd0\x0a\x71\x96\x34\x99\xa5\xf2\x11\xb3\x14\xc5\x0a\xdf\x3a\x21\x0c\x65\x06\xdd\xbf\xf5\x3d\xed\x40\x3c\x7c\x70\xf3\x10\x7d\x70\x14\x62\x2a\x12\xac\x17\x8a\x86\x80\x92\x07\xcb\xe9\xc4\xea\xec\x8a\x4a\xcc\xcb\xaf\xd0\x38\x4a\x24\x5f\x2e\x2a\xfb\xb8\xd5\xe1\xe0\x6c\xed\x75\x58\x57\xd1\xa3\x39\xb4\x4e\xc2\xf4\xb0\x13\xd0\x8a\x82\xd6\x3a\xd2\x43\x10\x03\xc6\x89\x8d\x85\xf0\xba\x89\xf6\x0e\x89\x1a\x06\xdf\xc3\xbd\xfe\x6c\x79\x00\x6e\x3e\x76\xde\x39\xab\x6e\xbf\x0f\xec\xee\xe7\xb9\xba\xf4\xc6\x92\xaf\xde\xf9\xa5\x22\xef\xc8\x3b\x65\x03\xaf\x32\x37\x8f\x9d\x9a\xb6\xa4\x6e\xf9\x41\x70\xf2\xe9\xd2\x6f\x7e\xe5\xdf\xaf\xfb\x9d\x76\x5c\x19\x04\xe6\x7f\x3a\x6b\x1c\xa2\xeb\x01\xf2\x15\x51\xfa\xdd\x2e\x4a\xbf\x01\x16\x31\xfe\x02\x52\xf0\x7f\x0b\x75\x56\xff\x40\x0c\x7b\x15\x7d\xd6\x88\x7d\x97\x32\x62\xa5\x1f\x2f\x0f\xa6\x08\x9c\x28\xd9\x3b\xa7\x8d\x75\x57\x90\xb8\x0d\xf3\xb4\x2f\x5c\xe6\x9f\x5f\x53\x93\x63\x3f\x48\x1b\xb7\xb5\xeb\xd1\xe1\x60\xe6\x84\xaa\xd2\x45\x64\x5f\x69\x2e\xd2\x43\x19\xd1\x71\x1f\x15\x7f\x44\x65\x3f\x23\x0e\xd2\xf6\x98\x11\xd0\xe0\x4c\x64\x71\xa4\x4e\xee\xa4\xcf\x04\x59\x12\xa5\x08\x0d\xe0\x04\xd9\x22\xfe\x90\x58\xc9\x01\x0a\x8f\xfb\xe8\x2d\x5f\x7f\xd8\xef\x25\xfe\xf7\x23\x37\x6f\x67\x8c\xfb\xb4\xeb\xd0\xc5\x2b\x17\x9e\x98\x9a\x3f\x67\x13\xb2\xa8\xcf\xbc\x34\x84\x1f\xc5\xff\x73\xc5\x27\xef\xf5\x05\x1a\xc0\xa5\x57\xf2\x63\x57\x2f\x5d\x3a\xe2\x1a\x18\x14\x3f\xaa\x94\xcc\xfb\xd5\x7a\x64\x2b\x10\x4d\x1a\xca\x75\x82\x82\x6a\x99\x5a\x75\x06\x89\xa5\x4c\x70\x4a\xc1\x7c\xd1\xa2\xc5\x93\xc6\xe9\xa6\x20\x4d\x31\x6c\xb6\x0f\xec\x3a\x74\x7a\xe3\xfe\xab\x85\xe7\x2b\xf9\x8f\x78\x33\x3f\x32\x1e\xd8\x3e\x85\xbf\x3f\xe8\x31\x02\xbc\x0a\xd6\xf1\x09\x75\xf7\xff\xb0\xbc\x89\xe5\x7d\x29\x52\xbc\xb5\xc4\xf7\x25\x1d\x51\xa8\x6a\x41\xe8\x64\x58\xa1\x40\x96\x53\xfe\x5a\x83\xb6\x09\x2a\x2c\x56\x48\x13\xcc\x14\xd1\xc6\x21\xef\x27\x59\xb9\xfd\xb5\x57\xf5\x73\x56\xf1\xd7\x3a\xfd\xea\xe7\x4b\x16\x83\x8f\x90\x3c\x62\x95\x2e\xcf\xad\xac\xe0\xf7\x1f\xa4\x0f\x63\x89\xa4\x84\xf8\x83\xd9\x4d\x7c\x5f\xcb\x23\x2c\x47\xc6\x63\x59\x93\xc2\x64\x16\x97\x13\x4b\xa4\x42\x54\x38\x45\x83\xd3\x8d\x8c\xdd\x78\x5c\xcc\x73\xbf\xa8\xf7\xf0\xe6\xf2\xf5\xfc\xdd\x8e\xff\x44\xe3\x2f\x01\xa7\x7f\xb9\xd1\xfd\x18\xff\xc3\x29\xbe\xc2\x0f\x0e\x9c\xfa\x3c\xcd\xa4\x87\xdd\x26\x0e\x23\x94\x9c\x3a\x3d\x80\x5f\xc6\xd7\xcf\x3b\xf8\xc1\xdf\xca\x7a\x13\x9d\x5f\x8f\x28\xad\x60\xf0\xb9\x8c\xfd\x84\x4d\xab\x05\x46\xf9\xe9\xc8\xb4\x25\xd4\x6f\x32\xe7\x34\x90\x18\xf4\xd2\x16\x8e\x9c\xc7\x40\x14\x7e\x80\xc2\xda\xe3\xea\x98\xbc\x11\x17\x2b\xb2\xdc\xcc\xda\xf5\x99\x5d\x5e\x2f\xca\xfb\xf1\x2e\x32\x85\x7b\x32\xf2\x5a\xcf\x7f\xe6\xeb\x2b\xeb\xe7\xe4\x77\x89\xdd\x7e\xf8\x0f\xfe\xce\x67\x7f\x23\x71\xf3\x0f\x68\xfe\x23\x88\x7c\x25\x9e\xd0\xcb\x64\x40\xc9\x20\xab\x7a\xcc\x40\x03\xfa\x4c\x94\x08\x4b\xe8\x8c\x78\x68\x2c\xc8\x48\x19\x84\x33\x20\xe4\xb3\x4c\x70\xd7\x83\x22\x1f\xfd\x45\x5d\xed\x47\xc0\x5e\x5a\x15\xd7\xe1\x6c\xbb\x94\x3e\x33\x07\xdd\x3d\xc8\xf8\xeb\xfe\x8c\x5d\x32\xf7\xe6\xb5\xd5\x1b\x06\xc4\xf1\x45\xc2\xbe\x04\xd2\x2f\x66\x3d\xd1\x2f\x0b\x95\x78\x1c\x42\x06\x19\x52\x05\x72\x23\x0c\xde\xa0\x10\xbd\x3e\x2d\x2c\xb0\x78\x77\x8b\x9c\x36\xbb\x80\x68\xd4\x38\x6c\xd4\xc8\x6a\x83\x6d\xb7\x6a\xbf\xf1\xd3\xb2\xcb\xaf\x5e\xe4\x37\xdc\x4d\x3e\x0a\xe8\xa5\xc3\x67\xd7\xfd\x0c\x3d\xf7\x07\x31\xbb\xc0\xe1\x2d\xcf\x1e\xe6\x37\xf0\x57\x2a\x3f\xe9\xf3\x15\x60\xe6\x55\x94\x60\x9f\x80\xec\xf7\xa3\x7d\x42\x1b\xc1\x27\xf8\x9b\xfa\x84\x85\x2b\xa3\x7c\x02\x72\x94\x11\x8f\x80\xbc\x24\xa0\x8e\xd7\xff\x2e\xc3\xba\xe9\xa6\xda\x1c\xb1\xcb\x6b\x41\x87\x90\x21\x7c\xc8\x0e\x34\xf6\x9d\x76\x5a\x81\xeb\x42\xb5\x94\xf5\x2c\x7a\xbe\x05\x49\x4e\x7b\x34\x96\x45\x32\x07\xa4\xfd\xec\x80\xaa\xca\x4a\x12\xd3\x42\x2d\xd4\x01\x83\x2f\x8e\x1c\x48\xd3\x5a\xc0\xb0\x28\x28\xc0\xed\x33\x60\xfc\xab\x55\x69\x1d\xc3\x35\x83\x47\x00\x03\x68\x7e\xa4\xe3\xfe\xb3\xcf\xf6\x79\xf6\x1e\xbf\x88\x3f\xfa\x5a\xbf\x49\x63\x51\x84\xca\xd7\xee\x5e\xdc\x3b\x68\x30\xf1\xfc\x80\xcf\xae\xd2\x9a\xba\x3f\xf9\xdf\xee\x2f\xcf\xa3\x99\x4f\xeb\x96\xeb\xad\xb3\xd6\xe1\xf5\xbd\x8a\xec\xac\x8b\xd0\x98\x74\x8c\x33\x5b\xcc\x42\x94\x60\x41\x54\x69\xb0\x6d\x3d\x8a\x54\xaa\x96\x04\x0b\x0d\xc1\x64\x24\x64\xd0\xd2\x62\xa7\x1a\x53\x40\xe2\x08\x7c\x7b\x25\x56\xab\x2b\x13\x03\xa3\x9f\xfd\x8b\xd2\xaf\x1f\x3e\xda\x3d\xf3\xbc\x9f\xde\xfa\xf5\x15\xd3\x4a\xfa\x23\xac\x5d\x75\xa7\x4f\x5e\x0a\x1f\x9c\xbc\x95\x1e\x7d\x70\xc7\xa1\x82\x31\x75\x62\x1f\x27\xe4\x57\xe0\x3d\xe6\x7d\x7d\x02\x8b\xa2\x68\x3d\xc7\xb2\x80\x27\xef\xd7\x46\xde\x57\x34\x7e\x9f\xee\xd2\xe8\x7d\x05\x7e\x1f\x5b\x18\x46\x06\xe3\x91\x3f\xc4\xe7\x47\x14\x5d\x8b\xdd\xdf\x65\xd2\xc6\x3d\x08\xde\x5c\x01\x98\xdb\x8c\x8c\x9e\x85\x53\x07\xf4\x39\xe6\x2b\xf2\x39\x72\xe2\x01\x64\xc2\x67\x85\x1e\x3f\xf8\xfa\x5c\xe4\x1b\x15\xcb\x01\xf3\x2d\xfe\x5a\xdd\x62\xfc\x55\x24\xa3\xc8\xdb\xc3\x1a\x06\x7b\x22\x25\x95\x1a\xb2\x53\x72\x25\x64\xd5\xac\x4a\x09\x8b\xc2\xe9\x4a\xa0\x54\xb2\x0a\x99\x0e\xb0\x91\x22\xca\xca\x28\xd4\xc6\x00\xf4\x8b\x6d\xdb\x6b\x0e\x04\xf9\x31\x2f\x1f\xa6\xab\x0f\x24\x77\xfb\x19\xb4\xe2\xdf\x67\xda\xd4\x2d\x04\x97\xf9\xa0\xa0\x07\xcf\xa3\x75\xb9\x4b\xee\x7e\x9a\xa8\x01\xa1\x2c\x2d\xd0\xd0\x06\x85\x51\xa5\x33\x1a\x80\x5e\xc6\x72\x9c\x85\x35\xcb\x4d\x32\x0c\x49\x07\x71\x3b\xd5\xa2\xb0\x4e\x89\x7b\xf5\x2b\xf5\x4a\x20\xd3\xb1\x16\xa0\x2d\x0a\x03\x4b\x43\x83\x83\x74\x72\xdb\x22\xa5\x01\xe2\xde\x18\x55\xe4\x87\x9d\xb4\x88\x27\x4f\xfe\x00\xbf\x29\xc0\x66\xd6\x75\x0f\xf1\xab\xbf\x38\x4f\x7f\x01\x07\xb9\x78\x7b\x1e\x38\xef\xe2\xf3\x3b\xd2\xe0\x41\x19\x08\x56\xf4\x03\x3d\xf8\xe3\x18\x84\xfd\xfc\x0a\x7e\x1f\xe8\x0e\x3e\x27\x77\x59\xda\xd5\xdf\x93\xfd\xc8\x14\x52\xe9\x54\x2e\xd5\x89\xda\x11\xea\xe7\x8f\x8d\x6d\x65\x4d\xec\x94\xe1\x74\xea\xa8\x4e\x72\x85\x22\xaf\x79\xf3\x4e\x56\xd8\xa5\x73\x86\xb3\x38\x9c\xde\x0e\xf7\x19\xcd\xd0\xa5\xab\x33\xd2\x33\xd2\x93\xd5\xc9\xed\x8b\xc2\xc9\x56\xca\xaf\xf7\xd3\x4a\xe8\xf7\xc7\xc7\x7b\x8b\xc2\xf1\x56\x63\xeb\xa2\xb0\x51\xaf\x93\x03\x25\x94\xcb\xd5\x04\xb0\x22\x52\x5e\x85\x66\x14\x55\xdf\x47\xfe\x25\x15\xc3\xe1\x52\x77\x23\x69\x1e\x15\x05\x34\x13\x34\x44\xdd\x08\xcf\x12\x01\x0b\x12\x1b\x0a\x22\xb0\xcf\x65\x58\x4e\x2c\xd3\xb4\x45\xf5\x46\xcb\xca\x66\xc5\xae\xc1\x38\xbb\x64\x45\x60\x08\x98\x29\x83\xb3\x66\x96\xae\x6e\xbe\xa2\xeb\xff\x6d\x7a\xfa\x6c\x60\xe0\x4f\x6b\x06\xac\xed\xc9\xff\xcc\x7f\xf6\x83\xe9\xc3\xd9\x73\x3d\x47\xd3\xbf\x7d\xf3\xef\xc3\x67\xdf\x78\xf3\xaf\x3a\x39\x5c\xfd\xc1\xc6\xbf\xf4\xac\x2c\x1c\xfa\xc2\x64\x7d\x1d\xcd\x4c\x1b\x3f\xeb\x40\x2c\xdd\x31\x50\xb8\x78\x4d\x79\x59\xfe\xa2\xe9\xab\xe6\xad\x9c\xdf\x63\x79\xdf\x53\xaf\xb1\x70\x90\xe7\x68\x9f\x32\xcf\xc6\xc5\xbb\x76\x7d\x78\x3a\x63\x56\x6c\x0c\xc3\x64\x8d\xee\xd5\xb3\x22\xbc\xb5\xdf\x5b\x05\xb3\x17\x1d\xdc\x45\x41\x82\xf7\x11\xc3\x74\x42\x71\xa6\x8f\x4a\xa1\x46\x84\x10\xad\x6a\x9f\x1e\x09\x85\x9b\x8e\x8b\x83\x14\xe5\xd6\x6b\xd4\x6c\xf3\x54\x1f\xab\xd5\x21\x31\x48\xa1\xf1\x2d\x66\xa8\xd3\x29\xcd\xe6\xc4\xa2\xb0\x59\x6f\x73\x28\x1d\x88\x8f\xca\x86\xae\x22\x0d\x17\x72\x1e\xd3\x02\x5c\xac\x34\xc1\xf0\xc0\xe2\x19\x15\x69\x31\x42\x78\xd7\xd0\x5e\x44\xaa\x37\x44\xd2\x0f\xbf\xae\xa9\x75\xae\x6f\x57\x7f\xe7\x1f\x97\xfb\x3c\xe9\x7c\x52\xd6\xfc\xce\x47\x2f\x9f\x7b\x50\x8f\x5b\x8d\xcc\x5f\x78\xf1\x8b\x55\x1b\x2b\x2a\x6a\x96\xb9\x55\xb0\x60\x73\xd1\x8a\xec\xf2\x03\x47\x93\x91\xae\x79\xbe\xf9\x62\xd1\x83\xb7\xcd\x43\xc6\x14\x77\x59\x31\x76\x50\xfb\x1e\x4f\xad\x6b\x1d\xb9\x87\x83\x31\xfc\x8c\x32\x9c\xc9\x09\x7d\xcf\x19\x5c\xa3\x84\x63\xd0\xa4\x90\x59\xc1\x6a\x51\x4c\x6a\x32\x02\xa4\x05\x40\x47\xa1\x29\x8b\xe8\x57\xf9\x29\x51\xad\x18\x83\xc4\x03\xeb\x29\x3f\xa9\xee\x84\x28\x01\x09\x7c\x0c\x46\xdc\xfc\x27\x7f\x88\x7f\x0f\x7c\xf8\xdc\x96\x03\x3b\xce\x7c\xf8\x07\xd3\xe6\xa3\x0b\xfc\x79\x7e\x07\xbd\x7b\xc5\xa2\x07\x37\x40\xac\xa0\x8b\x7f\x8a\xe3\xa9\x29\x07\xc6\x91\x31\x69\x8c\x1a\x85\xd1\x6a\x65\x68\xe4\xf9\x5d\x4e\x0b\x0d\x69\x24\xa4\x28\xe3\x50\x41\x08\x29\x96\x35\x14\x85\x59\xe4\x42\x1a\x91\x21\xb1\x37\xba\x5d\xb0\x94\xdd\x61\xda\xc8\x75\x84\x46\xf4\x91\xde\x2d\xc6\xc0\x80\x65\xae\xa5\xe1\x46\x74\xe6\xfd\xec\xfa\xb9\x23\xa2\x15\xdc\x5a\x01\xde\x6b\x20\x97\x7f\x03\xab\x62\x2c\x39\x6f\x41\xca\xf8\x2b\xa2\x57\x85\x2b\x9a\x71\xdf\x0d\x4e\x05\xa0\x1a\x42\x8d\x4c\x81\xec\x84\x0c\xd1\x89\x1c\x39\x4d\xe3\xe2\x14\x1d\x50\x36\x18\x8a\xe8\x7b\x59\xd1\x37\xb5\xb1\x7d\x90\x6c\x03\x6c\xfb\xe0\xf6\xc7\x74\xbd\xab\xee\x44\x1e\x1d\xe7\xaa\xbb\xde\x91\x1e\x22\xd9\x01\x12\xfb\x91\x7b\x8f\xc8\x06\x24\x50\x7d\x43\xcd\x2d\x56\x45\x5c\x9c\xde\xed\xf6\xa9\xad\x0c\x4c\x82\x89\x11\xb8\x79\xca\x11\x81\x9b\xa7\x64\x45\x0d\x58\xf3\xd4\x43\x40\xf3\x4d\x91\x9e\xff\x47\x68\xf9\xff\x8c\x24\x7f\xe7\x3f\x81\xc7\x6f\x3b\x86\xd7\xfc\x63\x7e\x1c\xd8\x8f\x78\x88\xfd\x43\x4a\xc8\xcc\xca\x38\xe4\x30\x14\x14\x4d\xcb\x39\x1d\xa4\x7b\x87\x21\xbe\xd9\x7c\x41\x82\xc7\x0d\x46\xda\xf7\xe2\xaa\x10\x5c\xfd\x76\x20\xf6\x78\x2c\x38\xfa\xf1\xf1\x4f\x6e\x1d\x3a\xc4\xfa\xee\x5f\xc0\x37\xe8\x31\x7f\x7e\x46\xfc\xc9\x40\xff\xd0\x53\xcd\x43\x56\xa5\x46\xa5\x81\x46\x68\x50\xab\x90\x3e\xea\x28\xae\x29\x27\x1a\x6a\xde\x71\xf2\x4c\x8e\x84\x89\xaf\x45\xa1\x1c\xd0\xad\x5e\xbf\xb9\x30\x74\xa8\xd9\xf4\x1f\x5d\x60\xcf\x53\xfe\xf7\xcd\x1b\x57\xc7\x0d\xe9\xff\x37\x7a\xf0\xca\x3a\xf6\x05\xe1\x1e\x30\xc6\x43\xea\x47\xea\x79\xfe\x24\x63\xdf\x46\x13\xbb\x2f\xf5\x45\xc1\xd6\x14\x02\x8d\x02\x40\xad\x4e\x8e\xc2\x11\xc8\x30\x4a\x85\x82\xe2\x74\x94\xa6\x24\x22\xb9\xe4\x0a\x40\xba\x88\x67\x2e\x98\x04\x49\x22\xb8\x7c\x5c\x2f\x92\x8d\x54\xdd\x4f\xff\xbd\xae\x53\xe1\xb2\x98\xe5\x43\x8e\x74\xbb\xea\xbb\xda\x9d\x56\x81\xa7\xfa\x3f\x53\x4e\xcb\xf8\xf9\xeb\x9e\x5d\xc3\xcf\xa6\x24\xec\x61\x7c\x6f\xdc\x82\xe7\xad\x52\x63\xb8\x41\xa3\x9a\xb1\xda\x2c\x72\x56\xa3\x33\xd2\x6a\x0b\x47\xaa\x09\x83\xe4\x96\x78\xe3\x42\xc2\x47\xdd\x0c\xff\xf8\xc5\xc7\x5c\x0a\xbf\x7f\xe1\x71\x17\xc2\x89\x5e\x30\x4b\xc9\xfc\xfd\x21\x03\xab\xe4\x70\x6e\xa2\xd5\x29\x19\x8d\x8e\x83\x6a\x0b\x25\x8c\x4e\x06\x27\x55\x80\x02\x9a\x3f\x1e\xdd\x04\xf6\x4e\x36\x37\xa7\xdf\xbd\xf2\xf1\xa1\x79\x6e\x7b\x5d\xc6\x7b\x18\x63\xf7\xe5\xaa\x57\xe0\x50\x34\xdc\x53\x8b\x8b\x1e\x3c\xcd\xb4\x91\xee\x0b\x92\xfa\x2a\xa1\xb6\xcd\x4e\xb0\x65\x71\x6d\xa2\x95\xd8\xad\x38\xaa\x05\xd3\x0b\xfe\x81\xc6\x77\x22\x2e\x28\x0d\x4a\x3b\x54\x42\x97\x9b\x33\xd7\x02\xdb\xb1\x30\x47\x69\xd1\xcf\x23\x28\x99\xc5\xab\x9f\x1e\x6d\xbb\x48\x2a\x4b\x0b\xe9\x9a\x31\xce\x26\x1e\xfd\x91\xcb\xbc\xf4\x94\x9b\x0f\x16\xf1\xfc\x1b\x5f\xd7\x2f\x03\xf0\x85\xcf\x3f\x39\xff\xfc\xc6\xf3\xe1\xd7\xe1\x1f\xd7\xde\xda\xcb\xdf\x9f\xf7\xd7\x37\x0f\x00\xb0\xf0\xb5\x53\xdb\xa7\x2c\x2e\xde\x3d\x78\xea\x22\x61\xcf\x20\x8e\x1a\x05\xff\x01\x6f\xa0\xdc\x3a\x14\x52\x3b\x64\x66\x03\x44\xb4\x78\xdc\x5a\x8a\xd0\xa1\x35\x5b\xd0\xcf\x13\x61\xb3\x99\xe3\x64\x84\x22\x8e\x4a\x17\xb4\x32\x9a\x2e\x24\x12\x99\xd2\x65\x07\xe1\x18\x34\x52\xc9\x2c\xf8\x4a\x3a\xee\xec\xcb\xbd\xcb\x9a\xcd\x7e\x7a\xe6\xb7\xb5\x17\xaf\x7f\x74\xc9\xda\x7b\x4c\xeb\xad\xd0\x7f\x70\x6b\xc1\x48\xed\x09\xdd\xb9\x2d\xbb\x7f\x9d\xf9\xe1\xeb\xaf\xd6\xc7\x9e\xd2\x74\xaf\xe9\x3c\x66\x12\xd2\xb4\xbe\xf5\x9f\x31\xf3\x98\x2a\x24\x23\x5e\x2a\x91\xea\x1e\x72\xca\xec\x7e\x03\x63\xe4\xb8\x78\x68\x74\x6b\xa1\x36\x39\x49\x11\xeb\x30\x33\x94\x4a\x65\x45\x74\x1d\x0f\xcb\x55\x54\x0c\x7a\x71\x34\x6c\x42\x3c\xc3\xba\x88\xfe\x42\x36\xc3\x16\xd5\x1f\x52\xc2\x3c\x13\x08\x6b\x38\xe1\x26\x7d\x9b\x4c\x99\xd9\x80\xd4\x27\x98\x62\x39\x20\x70\x73\xdf\xcd\x07\xed\xda\x0e\xf2\x1f\x5c\xfe\xf7\xaf\xeb\x0b\xba\x94\xfb\x9f\x5f\x36\x7e\x76\x98\x6f\xd9\xba\xed\xf9\xbb\x23\x7b\x80\xb7\x52\xd3\x09\x6b\x47\xbe\x5b\x30\x74\xdf\x4b\x7d\xfe\xfa\xe6\xd4\x4f\xba\x56\xed\x7b\xe9\x89\x07\xbf\x7b\xc0\x8d\xe6\x4b\x0b\xa7\x2c\xa6\x7b\x5a\xf8\xe6\xcd\xe7\x76\x46\xac\x86\xf8\x5e\x3d\xd7\x1e\xd9\x42\x3f\x95\x4a\xb5\xa2\x26\x87\xf2\x14\xe9\xe9\x69\x31\xb1\x0e\x2d\xdd\x2a\xc9\x64\x6a\x15\x03\xb3\xb2\xfd\x69\xc8\x06\xba\xb5\x6a\xbf\xdf\xad\x76\x67\xe2\x9b\x1a\xb6\x38\x02\x4f\xd8\x0c\xf7\xf1\xfc\x2f\x71\x4f\xe3\xbb\x1b\x29\xd1\x20\xd2\x91\x30\xa7\x55\x43\x98\xe3\xb3\x65\xf9\x25\x58\xe9\x44\xa9\x4c\x9b\xd5\x13\x0c\x22\xd2\x46\x3a\x12\xd8\x0c\x57\x2d\x5e\x52\xbd\x3d\x75\x45\xb7\x2f\x76\x02\xf5\xc8\x8d\xc0\xf6\xce\xcd\xe5\x0f\x6a\xf9\x6f\x87\xf6\xf8\x60\xe6\xa5\x2f\xed\xf0\xc8\x1f\x4b\xf7\x84\xff\x58\xb6\x3d\xfc\xe0\x36\x53\xf3\xe4\x92\x57\xe2\xe9\x8e\xc1\xbc\xc5\x6b\xaa\xfa\xe6\x2f\x9e\x76\xfe\xd5\xdb\xef\xd5\xf2\xaf\x3c\xff\x7a\xe5\x90\x0f\x5e\x1d\x39\xe4\x38\xff\xe5\x6a\xe0\x5c\x00\x9a\x2d\xe6\x7f\x9e\x2e\x61\x3a\x21\x5d\x88\x41\xba\x71\x9a\xe0\x67\xa7\x22\x2f\x15\x97\xa8\x75\x59\x91\x05\x32\xf9\x28\x8e\x33\x59\xb5\x4c\x5a\xba\x27\x50\x12\x66\x4c\x1e\x8f\x2a\xc6\xae\x53\x35\x2b\x0e\xab\xac\x0d\xd8\xd9\x39\x39\x8f\x40\x56\x06\x92\xf1\x17\xa7\x86\x13\x50\x02\x57\x45\x80\xaa\x32\x4d\x50\x08\xdf\x44\xd5\x81\xa7\x5d\xc7\x9e\x1c\x39\x63\xc4\x07\x4f\x1f\x38\x57\xba\x77\x2c\xa8\x1a\x23\xaf\x55\xed\x7c\x3d\xa3\xaa\x7f\x65\xdf\x39\x5d\xaa\x2a\x4b\x67\x77\x60\xda\x2c\x7d\xc5\xc6\xd8\x36\xcf\x18\x77\x6f\xda\x4b\x5b\xc7\x9f\x9e\x6e\x60\x9c\x4b\x86\xc6\x25\xb5\x48\x7e\x11\x70\x75\xab\xc2\xa3\x4a\x9f\x2b\xaf\x18\x5a\xf6\x22\xd1\xa9\x6e\xb4\x97\xf4\xd7\x37\x53\x09\x21\x03\x27\xa7\xf4\x72\xbd\xc5\x6a\x14\xfb\x4c\xe9\xc5\x33\x95\xcc\x68\x9d\x46\x2c\x17\xba\xeb\x4a\x18\x5a\x81\x2c\x38\xfd\x8f\xaa\x39\x15\x6d\xe4\x67\x18\x65\x4b\x60\xf9\xe2\xe3\xbf\xab\x5e\xd5\xd0\x2f\x00\x6f\xbb\x9a\xa3\xf9\x09\x49\x77\x7f\xbf\xf6\x4e\x6e\x71\x89\xa0\xc3\xb8\xee\x39\x81\xf6\x52\x46\x14\x01\x19\xd5\x1a\x16\x22\xab\x62\x36\xa9\x69\xbd\x5e\x8e\x24\xc7\xda\x64\x40\xa1\x0a\x4e\x60\x05\x99\x7e\x76\x10\x85\x51\xb1\x09\x1d\xe4\x67\x94\xf3\x9e\x1c\xbf\x62\x90\xf3\xd5\x14\xfe\x8b\x9f\xdf\xfa\x1a\xec\xed\xd8\xba\x4b\xeb\xa7\xb6\x87\x5f\x7b\x9a\xff\x91\xbf\xf9\x1d\x59\x2b\xec\x47\x1c\x68\xad\x84\xbb\x5a\x76\xbd\x4c\xa6\x06\xd0\x64\x56\xa3\xd0\x41\xad\x46\x81\x84\x8a\x04\x12\x96\xc6\x6d\xdf\x6c\x91\xfe\x60\x78\x72\x4c\xc0\x6f\x82\x7e\xec\xae\x03\xb8\x55\xd8\x07\x3b\x4f\xf3\xfc\x67\xfc\xad\xe1\x3d\x80\xf6\xc9\x35\x6f\x30\x6d\xb6\x2f\x39\x78\x89\xd6\xf2\x4f\x2e\x18\xb5\x4d\x88\xb9\xae\xa0\x31\xdd\x68\x4c\x7c\xbf\xbc\x63\xc8\x0f\x4d\x26\x9a\xd3\x6a\x74\x3a\x15\xa7\xb2\x3b\x20\x72\x92\x18\xc6\x8a\x56\x2a\xf5\xc5\x61\xa5\x4e\x43\x5b\xa2\x36\xf0\x1b\x81\x0b\x4a\x9a\x80\xaf\xd2\xa5\xd1\xa4\x65\x2b\xde\x2d\x10\xcb\x27\xfc\xc8\x49\x6d\xb9\x02\x16\xb4\xe8\xdf\xe6\xce\x3f\x01\xae\x4a\xaf\xfe\xc7\xce\x25\x43\x8b\x81\x0c\xbc\xc7\x67\x81\xab\xda\x5e\x93\xbb\x3e\xb7\xef\xfe\x05\xf0\x1e\xf8\x79\xf0\x98\x6e\xe5\x82\xec\x26\x89\xb4\x69\x90\xa5\x0a\x85\xfc\x4a\xa3\x91\x53\xab\x54\x1c\xe2\x84\x96\x83\x56\x9b\x46\x87\x68\xd2\x68\x18\xa0\xd2\x31\xe6\xe2\x30\x63\x69\x10\xdc\x60\x93\x3e\x02\x62\xd5\xa5\x5f\xb0\x49\x18\x56\x97\x10\xd6\x16\x40\x5d\xf8\xf8\xc7\x7c\xc5\x89\x8b\x7b\xb7\xd4\xbd\x73\xeb\xeb\xba\x25\xcb\xbe\xf9\x3b\x3d\x01\xbc\x77\xff\xc2\xa6\x05\x4b\x0f\x78\xc0\x55\x3e\xab\x66\xfc\xa8\xed\x82\x2c\x3c\x8b\xe8\xf1\x93\x7c\x34\x39\x64\x46\xb1\x1d\xcb\x41\x39\x00\x0a\xd6\x42\x73\x14\x57\x1c\xc6\x0d\x4b\x84\x38\x3f\x12\x4c\x89\x60\xab\x68\x71\x5e\x83\x43\x1c\xfc\x81\x53\xc7\x4f\xf1\x07\xf0\x0d\xe0\x27\xe0\x2b\x94\x84\x7f\xc0\x58\x71\xec\x00\xa7\x93\xd8\xe1\x0b\xaa\x8c\x99\x0f\xcf\x52\x76\xaa\x67\x48\x87\x3b\xfb\x32\x6a\xb3\xdc\x6c\x77\xda\x1d\x76\xe4\x36\xec\x21\x7d\x58\x67\x8f\xb1\xa7\xdb\xa1\x02\xda\x0d\x06\xb9\x42\x8e\xde\x3c\x86\xc4\x03\x1f\x0d\x8a\xde\xa3\x21\xb0\xcc\x89\xea\xdc\xe1\xcf\x8c\xec\xa9\x64\xe3\xed\x22\x0b\x49\x30\xfc\x90\x1e\x73\x60\xe7\xbe\xd5\x75\x5f\x05\xa0\xe1\x6c\x33\xbf\x2c\x35\xa7\xd7\xfa\x5b\xff\xa8\x9b\x08\x34\x73\x57\x8f\x9d\x73\x5c\x76\x10\xa0\xb0\x1b\x56\x9c\xba\xfa\x36\xe6\x01\xac\xe7\xa9\x32\x76\x2f\xa2\x0f\xc7\x6b\x3e\xaa\x7f\xc8\xab\xf7\x39\xd4\x6a\xb3\xdb\xe7\x86\xb1\x28\x33\x02\x10\x85\xaf\x0c\x45\x33\xe8\x3f\x83\xcf\x87\xa9\x3b\x11\xf6\x59\xf4\x06\x3d\x7a\x75\x24\x6c\x88\x78\xb8\x48\x06\x19\x01\xda\x31\x34\x21\x38\x48\x8a\xe6\x02\x8f\x23\xdc\x5b\xeb\xab\x1d\x83\xfe\x5c\x7b\xdc\x04\x36\xef\xa5\x53\xf7\xf1\x1b\x1e\x9a\x06\xa8\x3f\x56\x1f\x66\xce\x33\xbf\xa2\x9c\x6e\x56\xc8\xea\x4c\x4c\x74\xbb\x53\x14\x7e\x8b\x89\x65\x35\x16\x4b\xaa\xbf\xb9\x33\x85\x4a\x41\xd4\x9e\x44\x11\x82\x5f\xe9\x8f\x15\xb9\xee\x8f\xf1\xd3\x2a\xe8\x37\x29\x8c\x46\x85\x52\x81\xdf\x54\xa3\x00\x7b\xad\x12\x14\x29\xab\x95\xb4\x92\x4a\xaf\xac\x94\x16\xc0\x10\x14\x31\x17\x22\x5a\x02\x24\x5c\x28\x3c\xc5\x86\x15\x11\x70\xb6\xa5\x99\xe9\x00\x89\xac\xc5\x1f\xe4\x6d\xf1\x03\x85\xf4\x98\xc5\xf3\x72\x9e\x47\x93\x8c\x85\x86\x73\xcd\x62\x59\x34\x49\xf0\x74\xeb\x49\x83\xc1\xa6\xb2\x33\x87\xeb\x26\xf9\xe9\x31\x4b\xe6\xb5\xd9\xbf\xa1\xee\x2b\x7a\x76\x8b\xf1\x9d\x86\x4c\x3f\x26\x4e\xb8\xf7\xa1\x3e\xdb\x2a\x1c\xb0\xf7\xc9\x89\xc7\x7b\x1f\x6d\x31\xb1\xc3\xe0\x19\x58\xe6\x26\x20\x39\x1e\x44\xe2\xd5\xf0\xc3\xf5\xe8\xf5\xf5\xf5\xbf\xa2\x85\xfe\x9a\xfc\xbb\x92\xc8\xe4\x03\x12\x5f\xb5\x21\x3d\x9d\x92\x8c\x5a\x95\x46\x8e\x8c\xae\xca\xe2\x80\x34\x6d\x37\x90\xdc\xd7\xa8\x26\xa1\xb5\x9a\xd2\xe9\x70\x2d\x3e\x84\x0d\xd1\xf5\x43\x70\x29\xd1\x80\x6c\xac\x4f\x4a\x32\xfc\x81\x68\xb0\x14\x30\x85\x3f\x96\xb2\x3d\xee\xcd\x69\x8b\xf8\xef\x03\x4e\x30\xba\xee\x9e\x8b\xfe\xc9\xc9\x0f\x5a\xfd\xcc\x77\x66\x3e\x75\xdf\xd4\xa1\x47\x96\x83\xe4\x95\x4b\xf9\x57\xd5\x4f\xcd\x7c\xe1\x1c\x89\xb5\x48\x3e\xd4\x8b\x8a\xa7\xaa\x42\x19\x56\x9b\x2d\x4e\xa1\xf2\x31\x7a\xbd\xc7\xe3\x53\xc0\xc4\x04\x9f\x4a\x13\xf2\xfb\x9d\x32\xab\xd5\xe9\x44\xd9\x90\xd3\x2a\x66\x91\x32\x19\x55\x14\x96\x35\xf6\xf8\x91\xbc\xc8\x79\x39\x27\xe7\xe1\x06\x18\x00\x7b\x79\xe2\xe0\xf5\x2c\x17\xa9\x0e\x8b\x40\x75\x66\xe5\x03\x3c\x1d\xda\x31\x70\xb4\x73\x73\x01\xe8\xb4\xe7\x04\x7f\xc2\xda\xb6\x66\xd5\x88\xa1\x43\xa6\x06\x36\x24\xbd\x79\xf0\xe4\x3b\xaf\xed\xb6\x6c\xdd\x0d\xdf\xe8\x52\x94\xf1\xcf\x75\x35\xfc\x83\xc0\xf8\x3e\x45\x3d\x3a\x16\xf4\x6b\x3d\xad\x66\xc3\xb2\x99\xdb\xe4\xa3\xca\xfb\x2e\x15\x72\x98\x0f\x91\x6d\x18\x86\x7c\x5d\x12\xd5\x26\xe4\xd3\x28\x1c\xf1\x31\xe6\x78\x05\x03\x9b\xc1\x64\xbf\xbb\x28\xec\xb7\xa2\x77\x20\x65\x20\x99\x9d\x74\xc7\x14\x59\x9d\xfc\xc6\x49\xa5\x4d\x4c\xe4\xf2\x71\x77\xe0\x48\xf0\x88\xf4\xc8\x86\xb3\x1c\x1b\x8e\xd3\xd2\x71\x95\xea\xb9\x82\xa9\x99\x03\x72\xc3\x7d\xf3\xa7\x0f\x4f\xcc\x1c\xf8\xea\xea\x67\x4e\x39\x83\x4f\xdc\xe8\x98\x50\x38\x30\x5c\x3a\xe7\xb9\xbe\xa3\xd2\x9a\x75\xea\xb1\xc8\x9c\xd3\x75\x68\x69\xe7\xc5\xfb\xf2\x67\x16\x8c\x3e\x50\xbc\x72\x66\xeb\xb2\xe2\x9e\x37\x67\x77\xe9\x3b\x78\x5e\xd7\xf2\xde\xbd\xcb\xbb\x0a\x76\x12\xe7\xc5\x18\x37\x81\xa5\x62\x42\x3a\x14\x6d\x50\x32\x8a\x63\xe9\x62\x94\xad\x33\x82\xf3\x12\x51\x7e\x85\x4b\xf7\x18\x1e\xc1\xc1\x6f\x3c\x75\x9c\x40\x23\xe0\xce\x19\x58\x06\x91\xad\x85\x9b\x09\xde\x4d\x21\x79\x26\xf6\x05\x41\x62\x7b\x13\x43\x26\x1a\xe7\xff\x32\x4a\xa6\x90\x73\x4c\x71\x98\xd3\x01\x99\xe4\x97\xa2\xa1\x6e\xa5\x2e\x1e\xc1\x8f\x91\xd5\x4d\x27\xcf\xbf\x7f\x41\x6c\xce\x11\xc9\xdb\x1c\x78\x0c\xb6\x35\x19\x63\x2f\xca\x9d\xf6\x90\xfb\xef\xf9\xe4\x4e\x16\x43\x01\x9d\xdd\xae\x31\x6b\x00\xc3\x38\x5d\x76\xa0\x01\xc8\xe5\x6b\x34\x66\x2d\x4a\xde\x84\x2c\x2a\x27\xbd\x29\xae\xa9\x04\x13\x46\xea\x15\x85\x43\x58\x7c\x14\xe8\x73\xe1\x2e\xc4\x0c\x07\x69\x57\xee\xa7\x37\xd9\x0e\x2f\xe6\x2a\x81\x6f\xf6\x91\xd9\xa0\x6f\x87\xdc\x17\x3b\xc7\xf3\xef\xfe\x91\x0b\xb2\x14\x27\xf6\xba\xb2\x41\x31\x7f\xa9\x45\xea\xf7\xf4\xdc\xba\xf9\xa0\x07\x08\xf2\xbb\x5e\xfb\x12\xf2\xef\x49\x77\xf3\x08\x16\xa2\x89\x4a\x0f\xd9\x29\x00\x8c\x46\x8b\x42\x61\x36\x20\xce\x1a\x74\x1c\xca\xf7\x15\x9c\x55\xa0\x2b\x2a\xab\x95\xe8\x79\xe8\xd6\x0b\xfd\xf1\xa3\x20\x0f\x3f\x6e\x8a\x75\x88\xd1\xed\xb1\x2f\xb6\x80\xef\xe0\x69\xd2\xbb\x54\x43\x05\x50\xe4\xa5\x52\x32\x8c\x56\x87\x02\x03\x46\xce\xde\xa2\x98\xdb\x91\x9b\xec\x91\xbc\x8e\x6c\xc0\x9a\x80\x0c\xbd\x48\x80\x69\xad\xf8\xb2\xe7\x36\xd1\x05\x3b\xce\xf3\xd7\xfd\x5f\x83\x7e\xed\x34\xe0\x3b\xe0\xe7\x6f\xc2\x2f\x1f\x78\xe1\xd0\xf6\xfc\x18\xd0\xbe\xb3\x34\x0e\x7b\x0b\x8d\x83\xf7\x63\x0b\x43\xcd\x20\xa3\x36\x99\x34\x94\x5c\xaf\xd4\xea\x29\x23\x23\x33\xcb\x64\x16\xb9\xc1\xc0\xd2\x46\xa3\x3a\x5f\xd1\x4b\x81\x51\xfa\x6e\x31\xb7\x35\xd4\x6d\x5c\x0f\x92\x9f\x93\x5e\x49\xf2\x68\xd1\xa9\x18\x1b\x5f\x04\x6d\xbc\xfb\x8a\x2b\x45\xfc\xf4\xa6\xd6\xfc\x96\xb3\x1b\xe8\x75\xb0\xbd\xad\xae\x2e\x17\xfc\xcd\xca\x27\x74\xa0\xbd\x56\x1e\xf4\xe7\x2f\x80\x2c\x89\xc8\x29\xfc\x7b\x93\xf8\xc3\x53\xe0\x54\xde\x85\x3c\x5f\x35\xe2\xc5\x73\x88\x46\x2d\xc1\x12\xea\x10\xf2\xdb\x62\x62\x18\x46\xe1\x53\xbb\x5c\x14\x65\x54\x28\xfc\x6a\xaf\x37\xdf\xd6\xcb\x46\xdb\x6c\x8c\x95\xbd\x15\xd3\xc0\x9d\x4a\xbc\x33\x2a\x79\xbb\x86\xe5\x21\xcd\xee\x4d\x91\xcb\xcf\xf1\x52\x1b\x61\x13\x7e\x81\x7e\xc2\xc5\x37\xcf\xf3\xb3\xce\x83\xf2\xcd\x9b\x26\x8e\xac\xea\xcf\xef\x9b\x30\xab\x7f\xd9\xfb\xb9\x5b\x6a\x96\xbc\x77\xab\x13\x4c\x7a\xea\x20\xfc\x72\xdc\xb0\xc1\x0b\x5d\xa6\xf1\xc7\xaa\xfa\x74\x6e\xcb\x7f\xc0\xb7\x1c\x3b\x74\x15\xbf\x07\xd1\x5a\x8e\x68\xfd\x17\xe9\x87\xec\x42\xf9\x68\xa7\x90\x2f\xce\xe5\x32\x01\x83\x41\x16\x6f\xd3\x68\x62\x14\x32\x59\x82\x53\x65\x32\xc5\xc9\x11\xef\x5d\x86\xdb\x01\xfa\x56\x03\x24\x01\x21\x13\x88\x3b\xba\x62\x5b\x02\xa9\x51\xac\x70\xd3\x42\xdc\xa5\xf4\x9b\x02\x40\xa4\x14\x48\xa4\x4f\xaa\x2a\xc6\xe4\x0e\x3b\x69\xdb\xd8\x1a\x13\x1f\xae\x02\x5b\x6b\x96\x9c\xff\xb1\x13\x48\x9c\x3c\x03\x13\xcf\xa4\x82\x67\xc6\x0d\x5b\xd4\x75\x46\xeb\xbe\x4f\x1d\x04\xef\xf3\xcf\x8d\x1d\xba\x94\x7f\x0e\x7c\xd4\xbf\x37\x9a\xc0\x27\x44\x16\xfa\x20\xda\xef\x93\x7e\xf9\x66\xca\x17\xd2\xea\x00\xb0\x28\x65\x32\xab\x96\xbe\xa5\x03\x02\x4b\xa3\xfb\xef\x8a\x0c\xa4\x19\x69\xe3\x31\x8f\x06\xa7\xf9\x6d\xe7\x41\xee\x95\x6b\x4f\xf1\xff\x02\xfa\xdd\x9b\x0f\x6d\xba\x58\xb9\x7b\x6a\x2e\x7a\xec\x97\x6f\x9c\x7a\x85\xbf\xb3\x95\xae\x5e\xb4\xaa\x8e\xee\xbe\xf6\x55\xa2\xff\x78\xbc\x1f\x49\x6f\xff\xcc\x90\x13\x63\xee\xc9\x94\x14\x54\xd3\xb4\x46\x9e\xcf\xf6\x62\x71\x7f\x0a\x70\x4b\x21\x48\x5a\x10\xaf\x65\x23\x3b\xeb\x8a\x92\xac\x3e\xe7\xe9\xbf\xd9\xea\x8e\xe5\xd2\xf1\xd6\xba\x6b\x1d\xe8\x91\x56\x3c\xa2\x28\x43\x68\x9c\x3c\xf4\xcf\xdf\xc8\x38\x19\x21\x07\xee\x12\xc1\xa0\x61\x94\x4a\x0d\x23\x0e\x23\x57\xdc\x02\x0f\x0f\x23\xf0\x3e\xdb\x8f\xab\x6f\xf0\x1f\x98\x67\xa5\x47\x76\xa8\xbb\x66\xa5\xe3\x73\xeb\x8e\xd9\xe8\xbf\x9d\x07\xdf\x4d\x01\x25\x93\x40\xd6\x94\x07\x5e\x32\x9f\x91\xe0\x3a\x13\xcb\x5e\x43\x32\x9a\x19\xb2\xab\xd0\xba\xfb\x8c\xd0\x62\xf1\x9b\xcc\x66\xad\xfd\x0e\x97\xce\x20\xb3\x46\x7d\x8b\xfd\x74\x25\x19\x49\x02\x3c\xcc\x91\x8e\xf5\x85\xe6\x2a\x0d\x37\x0b\xf0\xa0\x32\x12\x43\xe7\xd1\xf4\xcb\x4f\x1f\x69\xb6\x20\x71\xc6\xa0\xd9\x67\x47\xae\x5d\x5e\xbe\x37\x2f\x96\xff\xd2\x06\x76\x77\x3a\x57\x4f\xbd\x79\xbd\xcf\xe6\xcf\xd8\x6b\x93\x66\xa7\x55\x17\xcc\xfd\x61\xc5\x8a\xa7\xb3\x83\x2f\x4d\xe7\x77\x3c\xf3\xe9\xa9\x49\xff\x3e\xd4\x5f\xe0\x33\x93\x44\xe6\x9f\x16\x72\x08\x3d\xb9\xf0\xf4\xe9\x7c\xae\x17\x47\x13\xd4\xcf\x68\x8b\x12\x61\x80\xa8\xc1\x12\xf0\xe8\x5f\xc3\xbc\x22\xbc\xfa\xfc\xea\x62\xf0\xaf\xe2\xb5\x68\xee\x38\x93\x80\x5f\xf2\x55\x60\x0f\x99\xbe\x30\x0e\xd8\x8b\xc6\x81\x94\x3b\xa4\x46\xf6\x92\x41\x7e\x83\xa5\x6f\x61\xd9\xc9\x8f\x92\x1c\x13\x7a\xe4\x97\x6b\xce\xaf\xc1\x8b\x44\xbe\xd7\x06\x5c\x87\x2a\xf4\x3d\x3d\xce\x31\x19\x08\xd5\x06\x95\x56\x8b\x92\xbf\x5b\x1c\x62\xd8\x1d\xcc\xb0\xcc\xfc\xa8\x60\x46\x68\x50\x2b\xb6\x60\x27\xdb\x86\x34\x68\x3d\x63\x2e\xb7\x98\x2e\xc8\xea\x38\xd0\x34\xf1\x15\x1b\xe8\xb4\x2c\x17\x5c\x9f\xbb\xc2\x54\xd1\x73\x50\x35\xdd\x75\x4a\x5d\x01\xff\xae\xc8\x07\x05\xe1\x43\x6a\xc8\xa6\x94\x01\x15\x40\x03\xa8\x15\x0a\x8d\x12\xc5\xd1\x8d\xec\xaa\x2d\x6a\x7f\x16\xe7\x58\x1c\x61\x03\xc6\x2b\xa1\xff\xca\xff\x6d\xd9\x13\x88\x0d\x55\xb4\xe3\x10\x6f\x01\xc8\x36\x81\x4f\x87\xf0\x6b\x11\x27\x9c\xe0\x16\xdf\xa1\xee\x7a\x84\x17\xf4\xe7\x68\x2c\x96\xf2\x86\x34\x10\x69\x97\x8c\x61\x38\x70\x0b\x0a\x72\x16\xb5\x03\x8a\x1d\x15\x96\xe0\xd5\x2f\x80\x2f\x89\xdc\x3e\xd8\x30\x45\xa4\xf5\x75\xf4\x7d\x2b\xce\x7d\x28\xa3\x06\xda\x90\x28\xd9\xcd\xb7\x94\x50\x7b\xcb\x88\x9c\x02\x26\x94\xec\xeb\xe5\x4b\xa0\x78\xa4\xb4\x27\x9b\x60\x65\x26\x24\x12\x82\x4d\x56\xdc\xcd\x04\xc2\xb9\xf3\xf5\x81\x9c\x58\x7e\xc9\x90\x19\x72\x95\x6b\xfe\xdc\xf3\x87\x67\xca\x65\x1d\x40\xcd\x2b\x68\x11\xe9\xa7\x8b\x6a\x16\xe4\xd5\x55\xd0\xcf\xa6\x0f\xda\x55\x37\x12\x7e\x59\x57\x92\xd6\x77\x3e\xfd\x32\x5a\x52\x40\x15\x21\x1a\xe2\x10\x0d\x6a\x94\x8b\x9b\x50\x5c\x81\xd8\xa0\x51\xe2\x3e\x2e\x80\xbd\xc5\x09\xbc\x22\x3b\x8b\x51\x80\xb5\x22\xab\x40\x1e\x4e\xff\xe8\xb7\xf8\xfd\xae\x79\x73\xcf\x6f\x01\x03\x34\xca\x45\xf3\xd1\x70\x30\x6b\x4f\xdd\x18\x34\xc5\xb7\xcb\xdb\xd2\xfb\x1a\x8d\xa1\xa1\xe2\x50\xbe\xaf\xa0\x59\x8a\xd5\x72\x9c\x4e\x2d\x43\xaa\xcf\x12\x66\x65\xe6\x07\x1b\x24\x92\xb8\xf5\xc8\x06\x66\xd1\xf9\x79\x73\x55\x31\xf4\xb6\x3d\xe7\xe7\xcd\x33\x5a\xea\xc6\x62\xf6\xd5\x4d\xcd\x9e\x09\xdb\x3e\xf0\xd2\x4f\x95\x75\x7f\x70\x91\xd8\xb5\xa1\x48\x2f\x73\x91\x5e\xea\x28\x0f\xb6\x6b\x36\x08\xbd\x7a\x95\x2a\xc6\x24\xff\xd6\x49\xc4\xab\xb1\x5d\x13\xf4\x4d\x8c\xda\x40\xd4\xe6\x4a\x96\x91\x66\xcf\xdf\x2c\x79\xea\xe3\x45\x67\x6f\xf4\xde\xf4\x01\x88\xdf\xb4\xa0\xe6\xf4\xf0\x0d\x8b\xe6\x9e\x1a\x0e\xae\x7f\xf6\xda\xf8\x3f\x5e\xe8\xff\xf1\xa9\xc9\x7f\xbc\xd4\x9f\x1e\xbb\xf4\xe9\xf9\xff\x7e\x72\xe5\xd6\x45\x00\xaf\x3c\x15\x06\x9f\xc3\x61\xec\xcb\x68\xf4\x14\x2a\x2b\xe4\x88\xd5\xbb\xac\x7a\x6b\xf3\x64\x46\xa9\x4c\x35\x73\x5e\xa4\x3c\x5a\x68\xbf\x15\xaf\xbd\x13\x71\x05\x58\x34\x1a\x6c\x83\x60\x1d\xb2\xf0\x9d\x23\x4e\xdc\x07\xf2\x19\x50\x60\x99\x2d\xa1\x95\x5b\x6d\x0d\xfb\x3f\x78\xb3\x8f\xee\xfd\xa4\x75\xbe\x61\x54\x59\xe7\xbc\x01\x27\x96\xf0\x37\x72\xa7\xf5\x1a\xa5\x98\xa3\xe8\xd1\xb2\xd7\xbc\xae\xa5\x7d\xcb\xa6\x77\xec\xcf\xbc\x3e\x77\x62\xf5\xf6\xd4\xf8\x09\x45\xd3\xbe\x1d\x0b\x14\x15\xa7\xe7\xbb\xda\x2f\x49\x4a\x6d\x9e\x50\x58\x34\x78\xd8\xcb\x43\xca\x7b\x95\x9e\xeb\x55\x3e\x24\xe2\x13\x3e\x24\x3a\x63\x46\x2b\xa4\x87\x7a\x8b\x5a\x2e\xb7\x02\xbd\x1e\xea\x98\x5b\xf0\xb6\x08\x5f\x1c\xd1\x4e\x82\xa2\x20\xee\x8d\x68\x81\x09\xbb\x28\x94\x6c\x65\xd1\xf9\xfc\xf7\xdd\x57\x9f\x07\x1b\x56\xee\x1a\xf2\xca\xca\x53\xf7\xbb\x03\xf0\x59\x80\x85\xa3\xf9\xb9\xf0\xcb\x25\xd3\x86\x1c\x08\x83\xca\x0d\xfc\xfc\xd7\xdc\x54\x64\xcc\xbb\x44\x26\xac\xb8\x73\xbb\xc6\x60\xc0\xe7\x2c\x36\x85\xc2\x8e\x9c\x83\xd5\xca\x58\x9a\x44\x40\x8d\x2c\x36\x09\x84\x24\xdf\x6e\x02\x62\x32\x0b\xe9\x7f\x1e\xe1\x7f\x2c\x42\x24\x3c\xbf\xea\x2f\x9b\x57\xbf\xc6\x7f\x31\x61\xc9\xd0\x72\xfe\xe7\x2e\x48\x7d\xb7\xf1\xc3\xe0\x97\xf3\xa7\xcc\xdb\xef\xe1\xfb\xd1\xca\xf1\x03\xbb\x77\xe7\xb7\x09\xf1\x29\xa2\xe3\x33\x12\x83\xc5\x85\x0c\x14\x84\x34\x03\xe5\x32\x99\x82\x62\x18\xf6\x16\x7d\x5b\xac\x63\x6c\xd8\x7a\x20\x01\x30\xee\x98\x32\xfd\xe0\xaa\x83\x7c\xad\x0d\xba\x6d\x6c\xd9\x83\x0d\x70\xdc\x94\x29\x82\x4d\x18\x81\xe4\x50\x89\x9e\x67\xa1\x62\x43\x3a\x4e\xa9\x84\xd0\x68\x35\xda\x0c\xb2\x5b\x9a\x28\x31\x8c\xc4\x28\x8d\xcb\x0a\xc5\x5b\xfb\xe0\xed\x03\x27\xd4\xd3\x57\xcf\x54\x8e\x19\x36\x6f\x9f\x13\xbd\x08\xfc\x13\x5c\xdf\xb2\x21\x90\x47\x0f\xad\xdb\x98\x96\xd4\xbf\x7a\xfd\x32\x7a\x48\xdd\xa6\x53\x97\xf0\x78\x48\xe1\xd8\x5a\x12\x8b\x24\x85\xcc\x06\xa8\x52\x30\x66\x93\xc9\xc2\x20\x03\xa2\xb8\x65\x50\x01\xb9\x64\x43\xf2\xa3\x2c\x7e\x00\x26\x0a\x36\x24\x68\xca\x07\x18\x6d\x17\xe9\xda\x4f\xcf\x36\x63\xe9\x96\xcd\xf8\xef\x9e\xed\xb2\x2e\x21\x2d\x08\xbc\x4b\xd3\x54\x60\xf4\xd3\xc8\x7a\xf4\x9c\x35\x6f\x5d\x45\xdd\xb3\x48\xa3\x8f\x4e\x98\x4a\x8f\xac\x7b\xfa\x4b\xd8\x5d\x58\xc3\x1c\x70\x03\x42\x94\xf3\x27\x51\x2d\xa9\x6e\xa1\x38\x8f\x5e\x1f\x4b\x5b\x6d\xa9\x4a\xa5\x8d\x86\x09\xad\x12\xb2\x50\x66\xd8\x8c\xd1\x68\x38\x93\xf3\x5e\x5c\x46\x06\x47\x51\x1c\x16\x7f\xb2\x3d\x21\x6c\x85\x12\x84\x88\x46\xa0\x61\x02\x57\x5a\x45\xfa\xd3\x64\xe5\x37\xda\x06\x16\x0a\x35\xc8\x9e\x68\x36\x27\x83\x5c\x44\x25\xb2\xe9\xdd\xb3\x21\x93\xf7\x64\xbf\x21\x33\x4e\x7c\xb0\x47\xdb\xad\x43\x71\xa9\x69\x76\xcc\xce\x05\xd3\x56\x69\x5a\x72\xad\xcd\x56\x65\xf3\xb9\x2b\xd7\x4d\x6d\x9f\xd3\x71\x4c\x37\x25\xf8\x7a\x4c\x6a\x79\xe7\xe9\xe5\xf3\x96\x41\xfa\x09\x43\x7e\x5e\xdb\x3c\xcb\x88\xca\x09\xd5\x09\x4f\xf0\xbf\xc7\x3b\x5a\xb2\xbd\x54\x60\x3e\x84\x65\x25\x2d\x3b\xb5\x1e\xd2\x92\xcc\xb3\x2f\x9a\x67\x0c\x9a\x67\x22\x15\xa4\xca\x42\xcd\x69\xbf\xdf\x9d\xa4\xd3\xc5\xbb\xdd\xca\x96\x16\xab\xb5\xb9\x52\xd9\x4a\xcd\x70\xc9\x21\xa5\xa6\x20\x39\xd9\xc1\x59\x2c\x46\xc7\x9d\x40\x7a\x3a\x9e\xef\xbd\x86\xf9\x06\x85\x73\x41\x63\x4e\xf4\xd6\x4c\x14\x96\xb0\x29\xd3\x22\x22\x1c\x58\xf4\x7e\xee\xa1\x6e\x15\x42\x1d\x20\x97\x9d\x65\xca\x16\x3b\x89\x21\x4b\x51\x2b\xcd\x99\xaf\x91\xe6\xec\xdd\xf5\xc8\x39\x33\xdf\x0b\x73\xe6\x7f\x93\xa6\x3c\xbc\x0a\x4f\x19\x28\x85\x29\x23\x25\x8d\x9a\x32\xee\x2d\x08\xae\x41\x37\xf3\x0b\xb2\x08\x7e\xdc\x15\xc5\xa1\xd5\xf9\xa0\x0e\xc6\xaa\xd4\xea\x80\x51\xa1\xd2\xdd\x56\xdd\x75\x73\xf7\x2c\xa2\x4c\x93\x32\x8d\xe8\xb3\x44\x49\xb6\x31\xfa\x92\x2d\x98\x1d\x84\x5c\xa0\x25\x5e\xd3\xc4\xcc\x08\xf1\x16\x33\x68\x36\x61\x46\xbf\x1d\x33\x9e\xcf\x80\xb6\x9a\x29\xae\x19\x3a\x26\x73\x62\x7a\xd5\xb4\xfc\xf2\x1e\xa5\x83\xdb\x82\x6b\x4b\x27\xaf\x06\xfa\x79\x2b\xe7\xd4\xed\xd9\x19\xdb\xab\x43\xde\xa0\x31\x1f\x55\x57\x54\x8d\xb8\x55\x7e\x98\xec\x99\xa1\x78\xe2\x06\xf3\x2d\x5a\x93\x66\x54\x36\x95\x4f\x4d\x0b\xb5\xf3\x78\x35\x81\xec\x7c\x24\xcf\x76\x24\xdb\x5c\xb6\x17\x26\x65\x18\x8d\xa1\x9c\xa4\xa4\xf6\xb9\xf1\xf7\x64\x28\xea\xcc\xc7\x0b\x94\x9f\x6f\xf1\x78\xfc\xcd\x35\xba\x80\xdf\x62\xd1\x39\xfd\xf7\x82\xba\x3b\x50\x29\x58\x65\x22\x93\xf8\x34\x82\x88\x65\x30\x3d\x85\xb4\xba\x6c\xf0\x1b\x51\x99\x8f\x14\xa3\x70\x0d\xe5\x16\x09\xd2\xf1\x0c\x91\xd8\x88\xc0\xda\xc8\x1d\x01\x19\x17\xcf\x69\xa5\x42\xc5\xec\x78\xb1\x7e\x83\xfe\x4c\x76\xb0\xdd\x10\xcf\xc0\xe0\xa6\x61\xa3\x16\xd9\xe7\x5d\x19\x3a\xfd\xf4\x27\xcf\x69\xd6\xf7\xe9\x6f\x9d\x1d\xbb\x67\xc9\xce\x2e\x65\x5b\x97\x6e\x81\x9a\xba\xc5\xeb\x46\x0e\xcf\xcd\x6f\xdd\x75\x5a\xb1\x8a\xb6\xc1\xb2\x82\xd2\x29\x76\x58\x58\xf4\x46\x87\xdc\xe6\x03\x4a\x06\x95\xbf\x26\x08\x72\x27\x6b\x4d\x4e\xc8\x32\xb2\x62\xfc\xf8\xf5\x8b\x4b\x73\x2c\x34\x1d\x5f\xd0\x2e\xab\x43\xde\xb8\xdc\x15\xc1\xca\xd2\x19\xe3\xc9\xbe\x34\x0f\xae\xd3\x9f\xcb\x28\x64\x71\x03\x78\x4d\xf5\x9a\x58\x08\xe3\x5d\x26\x14\x26\x6a\xe2\x74\xdf\x29\x4d\x9a\xdb\x5e\xee\x8e\x8d\xba\x27\xac\x69\x4e\x4e\x7e\xd4\x1e\x9b\x00\xf8\x20\x1e\xc1\xc4\x26\x06\x64\x5c\x80\x18\x2e\x2c\xb3\x8d\x5c\x13\xf8\x79\xc2\x8c\xd2\x6d\x33\x0f\x64\xd0\x36\x6e\x66\xec\xa1\x9a\x36\x6a\x35\xcc\x9c\x94\x5e\x31\x23\xbf\xbc\x67\xbf\xc1\x6d\x99\x7f\x2e\x9d\xbc\x91\xff\xd7\xfc\x95\x23\xcd\x3b\xe1\x4c\xfe\xb3\xfc\x38\xb4\xb6\xa3\x3f\x1c\xd4\xb0\xb6\x34\xb5\x04\xc9\xde\xd3\x88\x4e\x64\x43\x71\x56\xee\x87\x4e\xa3\x1e\x32\x01\x44\xa5\x49\xc1\xe9\x6f\xab\xbf\xf3\x70\xf7\xac\x4d\x45\x4f\x32\xd0\x0d\x62\x87\xb7\x0a\x1e\x29\x77\xe3\x24\xb9\x93\x75\x9d\xf3\xc2\xe3\x04\x2f\x09\x4c\x7c\xb0\xb4\xa9\xe8\xd1\xd4\x24\x14\xc7\x26\x31\xff\x44\x3c\xf4\xe2\xee\xc5\x9c\xdd\x6e\xf6\x02\x80\xd2\x3e\xb3\xd9\x47\x79\xd3\xbd\xf9\xde\x5e\x5e\xe8\xf1\x02\x99\x57\xe6\x55\xba\x0c\xf7\x24\xe1\x22\x75\x4c\x95\x95\x86\xe8\xbe\x78\x82\xde\x47\xcb\x90\xb4\x97\x24\x8b\x34\x25\xf9\x8d\x3b\x93\x3f\x36\x6e\x60\xd6\x33\xa3\x57\xed\x18\x7c\x7c\xe2\xda\x67\xa0\x76\x3c\xac\x2e\x1c\x30\xd7\x09\x7b\x16\xbd\x91\x17\x42\x32\xb0\x63\xdd\x9a\x2f\x6a\xd6\x2f\x2e\xc9\x1b\x28\x2d\x75\x14\x9d\x38\x9b\x46\xf1\x08\xe7\x70\x58\x2c\x3e\x6d\x0c\x00\x5a\xad\xdf\x6e\x93\xd9\x64\x2a\xb7\xf1\x0e\x54\xdd\x6b\x20\x2e\xd2\x66\x2d\xe2\x9d\xb2\x45\x31\x16\x03\x25\x42\x20\xa2\x54\x3c\x69\xa3\xf7\x71\x67\xda\x8f\x8b\xad\x4e\xea\x3d\xb5\x68\xd5\x8e\x21\xc7\x27\x44\xd3\xb6\xa0\xe8\x8d\xf6\xed\x9a\x77\xee\x94\xb4\x63\xdd\xea\x7f\x20\xe2\xfa\x67\x45\x88\x03\x54\x00\xc9\xe1\x3a\x64\x5b\x12\x71\x5f\x3f\xaf\x41\xe3\x63\xe2\x95\x06\x65\x12\x63\xb3\x25\x6b\xfc\x7e\x9f\x0f\xe9\xa9\xcf\xc7\xb9\xcc\x88\xb7\xf7\x20\x14\xbc\x46\x30\x9d\x58\x52\x6c\x42\xa5\x7c\xdf\x28\x1e\xe5\x4a\xb1\x53\x64\xbb\x30\xbb\x95\x78\xb3\x55\x6a\x65\x89\xfc\x05\x27\xc8\x28\x08\x74\x9b\xd0\x22\xaf\xd3\xda\xaa\xa9\x0b\x9f\x1c\x96\xd3\x6d\xe3\x82\xb2\x59\x49\x55\x9e\x9e\xad\x3a\x17\x7d\x63\x9a\x37\xae\x5d\x67\x3a\xb7\x75\x46\xb7\x4e\x6d\x26\x55\xf7\x9b\xa2\xa4\x75\x7d\xdb\x0c\x1d\x9d\xd5\x21\x37\x35\x31\x94\x3d\x71\xb0\xa7\x7d\x4e\xb0\x3d\xa1\xdf\x8f\xe8\x5f\x89\x78\x1b\x47\xf5\x08\x25\xc8\x63\x63\x21\xad\xf2\xba\xcc\x16\xda\x12\xaf\x73\xb9\x12\xbc\x2a\x95\x1a\x9b\x1a\xb5\xda\x6e\x36\x1b\xed\xf7\x58\x34\x05\x29\xc1\x41\x53\x78\xe4\x04\x04\x2c\x90\xd8\xff\x50\x1d\x22\x61\x6c\x81\xb4\xdb\xf1\x93\xdc\xcb\x0a\x7b\x8f\x1d\x64\x9a\x3b\xa9\x63\xeb\x1a\xef\x04\xcf\xea\xd1\x63\x17\x4c\x2d\xed\xdc\x6f\x17\xb8\x7e\x2c\x66\x4a\xf7\x8e\x5d\x73\x07\x74\xee\xd8\xa2\xc5\x50\xed\x90\x92\x61\xc5\xc5\xa3\xe5\x50\x3e\xb0\xf3\x98\xb9\x82\x5c\xb4\xa1\xce\xc2\xce\x88\xf7\x7e\x2a\x0d\x77\x06\x97\xdb\xed\x90\xa6\x63\xf5\x7a\x77\xba\x3b\xc3\x75\x57\x63\x33\xeb\xe2\xd2\xe3\xf2\xe3\x7a\xc5\x31\x71\x71\x29\x66\x44\x3c\xf5\x83\x10\x9f\xa3\xa4\x11\x59\xc6\x7c\x49\x7c\x83\x22\xd1\xf1\x22\xd1\xf9\x20\x10\x8d\x7e\x6c\x0b\xe2\x73\x3a\x19\x87\x6b\x1f\xcc\xc1\x06\xed\x03\x3d\xbe\x8f\x9f\xe4\x58\x31\x74\xb4\xd5\x0e\x72\x27\x74\x1f\x3b\xaf\x74\xfb\xf4\xe2\x69\x26\x1a\xba\xe0\x74\x95\x6d\x42\xec\xe1\x7f\xad\xeb\x31\xbb\x43\x59\xaf\x7e\x43\x72\xce\x1e\xf5\x8e\x1f\x35\x65\x56\x69\xbb\xf5\x93\x16\x01\x65\x4d\xf7\xce\xe6\x51\xac\x6f\x4e\xdd\xa9\x43\x9b\xe9\xe0\x4b\x13\x5e\x1f\x11\x1e\x38\xec\x4b\x61\x4e\x90\xba\x02\xba\x32\xdf\x90\xf3\x13\x14\x75\xc9\x68\x46\xac\x76\xb9\x4b\x43\x19\x0a\x80\x2e\x64\xe6\x37\xc8\x36\xd6\x38\xa1\xcc\x65\xa3\x6d\xa6\x0d\xa4\x3e\x35\xf3\x29\x50\x30\x73\x26\xdc\x59\xc7\xd2\xf7\x85\x18\xae\x39\x8a\x09\x5d\xc8\xfe\xa8\x71\x0e\xa9\x02\x28\x4f\x41\xd9\xb4\x46\xa1\x54\x22\x97\xcb\x28\xee\xb2\xdf\x89\x91\x69\x83\xd7\x93\x82\x43\x21\x87\xc4\x6d\x65\x4c\xb4\xea\xcc\xd4\xcc\x9a\x8b\x35\x35\x6b\x1f\x6c\xe7\xd7\x7c\x87\x62\xd0\x41\x65\xfc\xef\x8c\xb5\xee\xc9\x25\xdf\xf0\xb5\x7c\x4f\x34\x8e\x0e\xe5\x45\x5d\xd1\x5a\x24\x51\x79\xa1\x18\xaf\xdf\xef\xb4\xa0\x00\x54\xab\x83\x4e\x67\x33\x55\x72\x9c\xfd\x9e\xcc\x74\xcf\xa2\x53\x69\xee\x7a\x29\x95\x90\x87\x61\x20\x25\x69\x87\xc6\x10\x55\x58\x04\xa2\xc1\x92\x70\x27\x7c\xe2\x79\xf0\x5f\x48\x62\xa2\xa1\x94\xc0\xe9\x7e\xc6\xe6\x6d\x8b\xa7\x59\x4b\x90\xc7\x45\x6c\x6f\x39\xac\xeb\xb3\xa6\x36\x93\xbb\x9c\x52\x97\xcf\x96\x7e\x83\x28\x3d\xd7\x27\xb1\x65\xeb\xe5\x93\x51\xa8\x5c\xb6\x77\x61\x71\xfe\xde\x8a\xae\xef\xba\x0a\xf9\x64\xf1\xfd\x89\x7c\x1f\x81\x4f\x0c\x75\x96\xbe\x80\xe8\x8f\xc5\x75\x31\xb4\xc5\x0a\x55\x1e\x4f\x9c\x31\xa0\x71\xde\xb3\x1a\xcd\x77\x8d\xb7\x59\x22\x3b\x98\x4d\x12\xcd\x41\x1c\x7f\xc6\x47\x60\x83\xb2\xa4\x6e\x69\x11\xa2\x49\x7c\x87\xc4\x64\x51\x6a\xaa\xde\x15\xd3\x2c\x49\x33\x54\x53\x53\xba\xc4\xd6\x5b\x20\x37\x77\x6a\xe1\xf0\x11\xba\xd1\xe6\x41\x67\x95\xd5\xb2\xb6\x1d\x68\x63\x97\xc0\xb4\xc5\xd3\xf8\xbe\x98\xcc\x92\xbc\xe1\x03\x03\xc5\x75\x9f\x8d\x1d\x48\x64\x62\x3c\xb2\x7f\x69\x88\x36\x5c\xaf\x82\xb2\x73\x33\xc7\xb9\xb4\x94\x5b\xaf\xba\x67\x63\xee\x48\xdb\x5c\x99\x06\x61\xd9\xcc\xd1\xb6\x97\x6b\x19\x7d\xd2\x9e\x36\xe0\xe8\x92\x15\xbb\x06\x1e\x9d\xb3\x69\xeb\x82\x17\x07\x4c\xca\x2b\x2b\x1d\x3c\x2e\x17\x5e\x5a\xf0\xd3\x9c\xfd\x6b\x17\xdf\x9e\xb2\x6d\xd5\xc5\x21\xef\x94\x0f\x1b\x3f\xfa\x03\x8a\xe4\xb9\xd7\xe9\xeb\xc8\x2e\xd8\x51\x46\x63\xc5\xbd\x2d\x75\x3a\x87\x4d\x2e\x77\x9a\xd4\x7a\xbd\xfa\x0e\x4d\x53\xec\xbd\x06\x4b\x16\x09\x2b\xc4\x98\x97\x4b\xcc\x6a\x30\xb3\x0d\x88\xf7\xe0\xad\x35\xb9\x63\xfb\x7c\xb3\x64\x5d\xf9\x73\x0b\xa7\x2d\x97\xcf\x66\x3b\x77\x2e\x1b\xd3\x8e\x59\xbb\x27\xf6\xeb\xed\xcb\x17\xfd\x34\x77\xca\x18\x63\x7e\xaf\xaa\x4b\x23\x5f\x45\xe3\x4f\x81\x23\xc8\x9c\x0d\x54\x4c\x48\x83\x82\x20\x23\xa5\xd1\x98\xf4\x1c\xad\xc4\xc3\xbe\x95\x19\x9d\x00\x93\x49\x72\x01\x89\xe5\x81\x2c\xfa\xd0\x8b\x45\x43\x3a\x1a\x16\xba\x2e\x1e\xd8\xb4\x55\xbe\x50\x01\x2f\x5d\xec\xb0\x64\xe8\xd9\x4b\xdb\x56\x65\xb4\x6c\x89\x9e\x8d\xf9\x99\x00\x47\x50\x46\xfc\x6c\x96\xa2\x4c\x6a\x8d\xc6\xac\xa6\xe5\xfa\x3b\x4d\x9f\xdd\xf8\xa8\x9e\x4c\x67\x3c\xbb\x90\x2b\x2b\x2d\xaa\x46\xcf\xf7\x5c\x7c\x7e\xc5\x2e\x68\x68\x91\xd0\x2c\x7d\xd8\xf8\xf6\x4b\x86\x9f\xbb\xbc\x5f\xac\x53\x3c\x0b\x55\x84\x77\xf1\x18\x53\x55\xa5\xf5\x40\x2e\xce\x62\x49\xe4\x12\x1c\xc6\x7b\x50\xab\xbc\xcb\xfd\xe0\x13\x5c\x3e\x0e\x4c\x22\x28\x54\x36\x01\x86\x2a\x40\xc4\x1c\xe9\x5d\x04\x26\x0c\xc7\x29\xb0\x51\x5c\xf2\x17\xe4\xf0\xe5\x5d\x6a\x0e\x1b\xe4\x53\xe4\x0c\x0a\x49\x7a\xa3\x28\x60\xbb\xab\x72\x5a\x08\xf9\xfd\x41\xb9\xe0\xfa\x4a\xa6\x2d\xbf\x19\xae\x1c\x9c\xa3\x2a\xb6\x76\xc8\x43\x51\x00\xff\xcb\x02\xfa\xc4\xe8\x2b\x83\xcb\x07\x0c\xbf\x55\x71\x18\xdf\x59\x07\xd7\x01\xcf\xae\x15\xd6\x57\x6d\x34\x2a\xa0\x0d\x6a\x1c\x1a\xa7\x8e\xe3\xd4\x4a\xf9\x5d\x9b\x99\x10\x98\x99\xff\x01\xd9\x2f\x8f\x3a\x2c\x8e\x64\x7a\xb8\xf0\x34\x88\xf7\x78\x23\x39\x0c\x55\xdf\xb6\x93\xb2\xac\xd4\x18\x7e\xa2\x8f\x7f\x95\x71\x55\xa9\x22\xdf\x9b\xa4\xc9\x07\xd7\x0b\xda\xfa\x72\xc1\xe5\xca\x83\x07\x2b\xf9\x36\xcd\x1c\x79\xca\x2a\x83\xa0\x73\xe5\x28\x17\xf1\x20\x5b\xe7\x44\xb6\xc9\x8a\xcc\x85\x4d\xaf\xb1\x41\x97\x52\xe9\x36\x68\x14\xce\xbb\xac\xf9\x8e\x86\x24\xad\xf9\xa2\x8f\x31\x36\x42\x86\x13\x53\x4c\x2e\xba\x03\x68\x96\x09\xb4\x2f\x13\x95\x6c\xb2\x7b\x9a\x96\xa5\xdb\x4e\xed\x35\x7c\x04\x3b\x88\xf9\x86\xcf\x79\xc2\x3f\x75\xf1\x34\xf0\x42\xdd\x81\xbd\xf2\x2a\x77\x49\xbb\xe1\x03\x8d\xcd\x68\x86\xd0\x51\x8d\x42\xd1\xd3\xcc\x30\x94\x1f\x24\x85\x8c\x2a\x46\x2f\x37\xeb\xcd\x56\x0b\x65\x56\xcb\xe5\x31\x0a\x40\xae\x36\x1b\x48\xf5\x1d\x88\x64\x04\x51\xa7\xce\xd9\x3a\x20\x1e\x39\xcf\x00\x9f\x4d\x1e\x33\x7e\x30\x5f\x6d\xa7\xbb\xee\xb6\xcd\x1b\xbc\x73\x3b\x6f\xa4\x37\xf4\xab\xee\xd6\x77\x16\x33\x85\xa5\x43\xb3\x37\x2e\x26\xe3\x75\x07\x7f\x67\x9e\x66\x6e\x51\x29\xf8\x1c\xc9\x1f\x17\xe7\x21\x73\xd7\xd9\x3c\x4c\x73\x95\x2a\xd5\x60\xd3\xa5\x28\x7d\x77\x13\x9d\x77\x64\xe6\x3b\x3a\x91\x03\xf9\xc1\x60\x74\x6c\xd8\x70\x86\x15\x95\x6d\x93\xfe\x91\x82\xca\x45\xf8\x11\x95\x8e\xd3\x5f\x95\x1a\x5a\xe5\xf6\x9a\x8e\xed\xa5\x41\x89\x2c\x50\xab\x61\x9d\xfb\x0e\x56\xe6\x4c\x78\xa2\x6a\x98\x62\xc0\x6c\xfc\xcb\xe2\x69\x96\x12\xe6\x16\xdf\xbe\x57\x4a\x56\xf6\x8a\x49\xe0\x60\xdd\x81\x21\xf9\x0b\x7b\xb7\xeb\x53\x54\xfe\xc4\xf0\x81\xf6\x36\xe0\x07\xe1\x57\x2b\xc7\x83\x43\x78\x1e\x5b\x91\x6f\xe9\x8f\xd6\x4f\x81\x3d\x15\xa4\x65\xb4\x52\xae\x50\xa8\xe4\xf4\x5d\x59\xe3\xed\x77\xf1\x26\x0c\x14\x37\xf8\xc0\x8b\x9b\xe6\x2e\xec\xa2\x94\xf5\x06\xea\xe5\x28\x27\xbf\xcf\xeb\x9e\xa8\xda\x0f\x7e\x11\x64\x22\x1b\xc9\x44\x77\xa4\x3b\x09\x54\x4e\xc8\x6b\x09\x28\x20\x92\x4d\x37\x54\xbb\x61\x52\xa2\xcb\x65\x8f\xb9\xa3\xb0\x04\xa0\xee\x9e\xac\x61\xa3\xd5\x96\x23\xe4\xa3\xc2\x09\x1b\x51\x22\x53\xc3\x91\xa6\x88\xa2\x82\xef\xf4\xd9\xa2\x92\xd0\x74\xa0\xa5\xff\x1a\xec\x11\xfb\x44\x52\x7e\x6a\x6a\x9f\x9e\xad\x77\xaf\x9e\x38\x76\x41\x4d\x6c\x42\x6e\x4c\x27\x57\x6a\xcb\xb2\x60\xdb\xae\x3e\x77\x79\x76\x5b\x70\x23\x90\x59\xd2\x3e\xad\x74\x56\x79\xc5\xd4\x45\xe5\xc5\x0b\x16\xcc\x69\xd7\x39\xce\x53\x92\x19\xc8\xc8\xcd\xac\x6e\x66\xc6\xb6\x59\x8e\x74\x3d\x07\xf9\x57\x33\x8a\x00\x43\xa1\x58\x85\xd7\xeb\xb7\x1b\x99\xa4\x78\x08\x93\x8d\x3f\xc8\xfc\xfe\xfc\xd8\x5e\xb1\x74\x6c\xac\xda\xee\x72\xe9\xd4\x77\x2c\xd4\x77\x24\xd2\xc7\xcb\x27\x9c\xf6\xe4\x37\x72\xba\x11\x78\x5b\x52\xdb\x8d\x6f\x3f\x3b\x01\x1b\xcb\x41\x11\xd5\x24\x21\x20\x24\xcc\x74\xeb\x49\x6b\xa7\x56\xf4\x1c\x72\xe1\xf9\xf9\xd5\x8c\x2d\xb9\x66\xc1\x7c\xe0\x3b\x99\x3a\x2e\x75\x4a\x8b\x49\x0b\xc6\x54\x98\x87\x8c\x2b\x90\x51\xb3\x47\x0e\xdb\x60\x34\xcd\x28\xdd\xf1\x4a\x87\x35\x1f\xd3\x7f\xa1\xff\x32\xf8\x5e\xdd\x7b\x9e\xb8\x59\x13\x4a\x06\x0f\xd1\x0e\x1d\x92\xdb\x43\x38\xe3\x3c\x4c\xbd\x0d\x2b\x98\xaf\xf5\x1c\xbb\x94\x5a\x4c\x4f\x22\xfe\x66\x1c\xb2\x8f\x25\x24\x66\xf0\x51\x99\x21\x9b\x4e\xe6\x51\x3a\x3c\x0e\xbf\x0f\x9a\x4c\xb1\x32\xb7\xd5\xa3\xf1\x7e\x47\x59\x05\xcf\xf3\xd0\xd6\x9f\x10\xbf\x62\xf0\x71\x92\x23\x9a\x62\x13\x6d\x12\x12\x8b\x50\xee\xe7\xe7\xc0\xf6\x89\x0b\x5a\x27\x3d\x39\xfb\x89\xaa\x7f\x65\x67\x1c\xea\x1a\xfa\xf8\xf9\x15\x3b\xdf\x7c\xff\x90\x1e\xfc\x62\xa4\xdb\x3c\xbb\xbc\x7c\x61\xcb\x94\x41\xab\x86\x54\x0c\x83\x23\x65\xdf\x54\xec\x2b\x3d\xfa\xf7\x67\x96\xfc\xe5\x1f\x6d\x7e\xec\x53\x89\x69\x1b\x8b\xf8\xbd\x93\xf9\x9d\x72\x23\x09\xe9\x10\xf2\x59\xb5\x7e\x87\x43\x65\x94\xcb\x95\x2a\xad\x2a\x11\x71\x3d\xc9\x68\xb8\x87\xde\x92\xab\xee\x28\x7f\xf0\x08\xe9\x1f\x61\x77\x7e\xd3\xea\x82\xa8\x8a\x4e\xe1\x42\x2f\x8e\xb3\x8d\x48\x3e\x30\xd9\x36\x13\xce\x04\x91\x37\xc7\x15\x94\xf4\xa7\xe5\x63\x5b\x8f\xfa\xcb\x98\xac\xc9\x59\x73\xd7\x9e\x7e\xd6\x5c\x3c\x3a\xab\xa8\xa8\x87\x67\xfa\xa0\xf4\x90\xa9\xc7\xe0\xd9\x21\xe6\xd7\xc5\x0b\x07\x7d\xb2\xe6\x09\x88\x3b\x58\xcb\x0e\xac\x7f\x0d\x40\x67\x95\x79\xf8\xe1\xf2\x81\x13\x58\xb0\x75\xeb\xa2\xca\x7e\x23\xf8\xa1\xf4\xb8\x6f\x47\x3f\x4d\xee\xac\x9f\x43\xf2\xfd\x2b\xca\xb9\x5a\x84\x1c\x66\x68\x81\x4a\xc4\x55\x3b\x6d\xa3\xa0\x01\xd2\xc6\xbb\x4a\x4e\x7d\xcf\x4a\xff\x20\xf0\x36\x3f\x82\x9a\x2e\x6d\x56\x07\xf0\x21\x7d\x40\xf0\xaf\x5e\x10\x83\xa1\xb7\x4d\x01\xb0\x87\x3f\xb7\x04\xec\xea\xe2\x89\x73\xa9\x6d\xf6\x8c\x8c\xa4\x16\x01\x57\xce\xfd\x45\xfc\xf3\x2f\x3f\x49\x6f\xe0\x53\xe9\x2e\xbf\x0c\x6d\xa5\x28\x33\xbb\x43\x03\x3e\x04\xb3\x79\x73\xdd\x05\x7c\x7e\xfe\xd7\xfa\x19\xc0\x0a\xd7\xea\x39\x98\x58\x7f\xa6\x6e\x2d\x25\xbd\x77\x8e\x9e\x87\xde\x4b\xa3\x82\x75\x6b\xc8\x7b\x5f\xd5\x8f\xa6\xf7\xd1\x93\x91\x7c\xcc\xa8\x5f\x26\xbc\x47\xf9\xeb\x67\xd0\x5f\x92\xf7\x66\x09\xef\x21\x9f\x77\x84\x2f\xa4\x2f\xc3\xb5\x44\x0f\x9e\x08\xc5\x7a\x15\x8a\x78\x28\xf3\x43\x7f\xb2\xd1\x6e\x30\x18\x8d\x49\x48\x15\x62\x91\x0e\x68\xd5\xb1\xe8\x3f\xa3\xcb\x82\x61\x9b\xf2\x05\x14\x1f\x31\x25\x6f\x08\x6b\x1b\x6e\xc4\x34\x55\x08\xb4\x4e\x8f\x54\x08\xf0\xc9\xc4\xe5\x13\x2a\x4a\xca\x5f\xdf\x37\xbb\x9a\x51\xb6\x7c\x72\xce\x5c\x60\x7f\x39\x75\x74\xd2\xa4\xe0\xf8\x39\xc3\x2b\x4c\x83\x46\x77\x85\x6b\xe7\x0c\x1f\xb6\xce\x64\x9d\x55\xb2\xbd\xb6\x43\x01\x7f\x07\x69\xc4\xde\x61\x77\xeb\x2e\xba\x12\x66\x4d\x28\x1a\x2a\x69\x04\xa0\x92\xf9\xde\xf4\x55\xa4\x07\x5a\x2a\x25\x64\xd2\x40\x2d\x0a\x3d\xf4\x94\x56\xab\x54\xa9\x74\x50\x85\x03\x69\x4c\x76\xd4\x11\xad\xb0\x89\xec\x02\x56\x4b\x1e\x20\x1d\x18\x03\x59\xd9\xf0\xf9\x42\x9d\x32\x19\x38\x17\xf1\xe3\x7b\x65\x2f\x48\xee\xb9\x92\x9e\xc4\xc7\xcd\x4d\x72\xf6\xa1\x2d\x75\xcd\xd6\x9e\x5e\x70\x90\xfe\x27\xe1\xd9\x27\x7c\x35\xfd\x32\x3d\x8f\x72\xa1\xa8\xb9\x53\xc8\x6f\xb5\x58\xdc\x6e\x8e\xa3\x9a\xc5\x6a\xb5\x14\x95\xec\x30\xaa\x34\xf1\xf1\x21\xa5\xb6\xc0\x18\x6f\x8c\x67\xac\x5e\x06\x97\x70\x89\xe8\xd9\x39\x52\x59\x94\xa1\x21\x03\xc7\x40\x41\xc6\x86\xc0\x2b\xd1\x66\xf6\x92\xe8\x21\x80\x45\x26\x01\x44\xc7\x82\xa9\x3d\xdf\xda\xb5\x69\x2b\x8e\x07\x9f\xa0\xd3\x06\x8c\x59\xd3\x77\x22\x9d\x31\x7d\xe7\x36\xba\x3c\x12\x17\x0e\x39\x06\xe6\x1c\xdb\xb6\x0a\x05\x87\x53\x72\x3a\xf7\x8a\x6b\x5b\x62\xd3\x2c\xa0\xfb\x34\x44\x88\x58\x36\xbe\xe7\xbb\x43\x0f\xbd\x10\xc9\xc1\xbc\xfa\x79\x75\xab\xc9\x7b\xa3\xf9\x9e\xf4\x35\x7a\x01\x7a\x6f\x7e\xfd\x3a\x41\x36\xa8\x7e\xf5\xf7\x38\xc0\x14\x22\x7f\x17\xa4\x86\x87\xb2\x91\x18\x98\x83\x71\x7e\x5a\x91\x9a\x9a\x9c\x4c\x6b\xcd\x4c\xcb\x56\x09\x19\x45\xe1\x04\x7d\x90\x2a\x0a\x6b\x0d\xf2\xb8\xa0\x4d\x1e\x94\x07\x0d\xb1\x36\x9d\xc1\x5b\x14\x36\x58\x1b\xf5\xc7\x15\x2a\xf8\x72\x22\x77\x8b\x9a\x60\xb1\x46\xd2\x88\x46\xbb\x8e\x89\x16\xe1\x5c\xb2\xf1\xfe\x34\x97\xd5\xb8\x69\x2a\xbc\xae\x58\x28\xb5\xca\xfd\x6d\xec\x72\xfe\xd7\xb7\x4e\xea\x16\x9f\x58\xa8\xad\x1a\xbd\x61\xa5\x7b\xf1\x09\xfd\x8c\x83\x17\xaf\xdb\x9f\x61\xe6\xce\x5c\xf6\x4a\x00\xfc\xab\x75\x8e\xd8\x32\xf7\x39\xb0\x7f\xe5\xc6\xdc\xae\xf4\x8b\x75\x03\xbb\xb4\x2a\x2d\x59\xb8\x81\x3e\xdc\x6f\xd4\x87\xa7\x71\xef\xd4\x9a\x85\x2f\x6e\x17\xf2\x3a\xdc\xbb\xaa\x25\x7b\x89\xca\x20\x3b\x7c\x79\x28\x28\x4c\x6d\xd6\xcc\x90\x15\xe3\x8e\x6f\xd7\x0e\x42\xb7\x41\xcb\x84\xda\xbb\x63\x9c\xfe\x24\x3f\x9a\x71\x33\x93\x35\xc9\x19\xc2\x95\x48\x71\x4e\xa7\x87\x52\xa5\x52\x5a\x0b\x97\x53\x14\xe6\x90\xd5\x28\x0a\x53\xfa\x06\x56\xe0\x2c\x2a\x27\xfd\x2d\xd2\xde\xef\xc6\x5b\x46\x52\x90\x4b\x35\x2a\x4b\x0a\x36\xdc\x1b\x92\x76\xbc\x12\xc8\x96\x17\xe2\x00\x99\x35\x09\x9c\x6d\xd9\x02\xfe\x9c\x10\xe4\x26\x72\xd2\x5e\x18\x2d\x9e\x24\x61\xa7\x73\x7b\xe7\x4b\xb3\x6e\xbe\x38\x6b\x9b\x0f\xb2\x09\x2f\xca\x93\x2f\xd8\x8d\x89\xf1\x8a\x05\xe6\x27\x2b\x1d\x36\xcb\xf1\x58\x87\x3d\x10\xaf\x5b\x60\x9d\x50\x1d\x13\x63\xd3\x58\x98\x27\xf6\x74\x1c\xbc\x7a\x50\xeb\xb9\x13\x9f\x5c\xd3\xaf\x8a\x29\x7c\x6d\xdf\xfb\xfc\xc2\xda\x11\x55\xce\x2d\x8e\x0b\xf0\x81\x3c\x23\x7d\xfc\x54\xd9\xa8\x17\x14\xe9\x19\x93\x26\x29\xa6\xe7\xf7\x1c\xd0\x6f\x65\xf1\xde\xdf\x06\xd6\xac\x5c\x0f\x9e\xc0\x60\xf3\x04\x4b\x9f\x5d\x83\xf8\x95\x4e\xe5\x51\x33\x42\x19\xb9\xb0\x55\x82\xc6\x65\xb7\x6b\x9a\x37\x33\x41\x59\xbe\xdf\x1f\x4a\x55\x72\xcd\x2c\x1e\x9d\x47\x67\x8a\x43\x6e\xc0\xca\x39\x28\xae\x35\xe2\x0d\x87\x72\x04\x3b\xe4\x6a\xeb\x5f\x3f\xa6\x33\x16\xe0\x9f\x21\x95\x42\x53\x80\x94\x38\x23\x0a\x69\x3f\x05\xd7\xdf\x89\xf7\x2a\x9c\x97\x09\x9a\x58\x7e\xe3\xf8\x2a\xd8\x14\x75\x3f\x1f\x3c\x96\x5b\x50\xd6\xb0\x35\x47\x47\x61\xf0\xaf\x17\x18\xb6\xdd\xc7\xba\x03\x2e\x89\x59\x36\x37\x62\x96\xd3\x2c\x32\xcb\xe3\x3d\xe5\x51\x1c\xb2\xb0\x4f\xec\xe9\x20\xb0\x6b\xf6\xba\x92\x2a\x0b\xe2\x16\xa8\x41\xdc\xda\x73\x44\x81\x39\xc5\x8d\x3e\x24\xc7\x9c\x92\x3f\xe8\xb4\xba\x24\x38\x36\xc2\xac\xa7\xf9\x57\x66\x61\x64\x7e\x5c\xfb\xb3\x1b\x09\xd9\x77\x88\x5f\xa9\xd4\x84\x50\xae\x5b\xab\xd6\x01\xa7\xd7\xe5\xd4\x31\x96\x38\x8e\x6a\xde\x3c\xdd\x92\x16\x9b\x88\xa4\x29\x96\xa2\xdc\x1e\x77\x71\x58\xa7\x36\x28\xed\x86\xa2\xb0\x13\xe0\xab\x0f\x45\x61\x8b\x52\x66\xb7\x6b\x53\x3c\x52\xef\x72\x24\x52\x37\xde\x12\x44\x49\xfa\x9b\xdc\x2c\x4e\x91\x76\x51\x23\x1b\xc8\x24\x08\x8d\xe6\x45\x20\x5a\xaa\x22\xb7\xd3\x6c\x9c\x70\x1f\x2d\xc8\x81\xa3\x85\x4e\x8b\x38\x7b\xb7\xaf\xf8\x78\xa5\xdd\x24\x72\x46\x13\xd7\x61\x8b\x73\x8b\xcd\xb3\x79\x55\xb7\x4c\x67\x81\xa9\x43\x47\x83\xe9\x13\x27\x7c\x85\x1f\x27\x4c\x9e\xaf\x06\x5f\x08\x82\x03\x8a\x16\x3e\xb9\x75\xae\x7a\xb9\xbc\xa0\x62\xe0\x42\x0a\xe2\xfe\x73\xb2\x3f\x98\x9e\xc8\xba\x84\xa8\xee\xd4\xae\x50\x3f\xb3\x81\x61\x64\x5c\x26\x05\xf2\x3a\xba\x3a\xa7\xa5\x37\x6f\x99\x9d\xe4\xf7\xb7\x4c\xef\xdc\x11\xfc\x7f\xac\xbd\x09\x7c\x54\x45\xb6\x38\x7c\xeb\x2e\xbd\xef\xdd\xb7\x97\x74\xa7\xd7\x74\x77\x92\x4e\xd2\x49\x3a\x49\x27\x2c\x49\xb3\x87\x3d\x04\x08\x04\x08\x10\x64\x91\x45\x59\x04\x11\x10\x08\x28\x82\xe2\x2e\x3a\xcf\x9d\xc5\x7d\x01\x84\x1e\x07\x75\x44\x9e\x3a\x0a\x1a\x97\xe7\x38\xbc\xe7\x38\x2e\xe3\x30\x8e\x02\x23\x0e\xa3\xce\x8c\x43\x6e\xbe\xaa\xba\x4b\xdf\x5e\x80\xf7\xfb\xbf\x8f\x71\x20\xe2\x59\xaa\x4e\x9d\x73\xea\x9c\x73\xab\x4e\x29\x95\x9a\xf1\x9a\x71\xde\x01\x6d\x9d\x5e\x93\xb3\xb5\xad\xd3\x69\x02\xb5\x74\x45\xbc\x2e\x3e\xa9\xb3\xa4\x4e\x49\x8f\xa5\xdb\x3a\xf5\xcd\xc3\xea\xc6\xba\x6d\x51\x93\xa6\x6e\x6c\x34\x3a\xb6\x4e\x43\x2b\x4c\xc6\x2a\x42\xc1\x5f\x4c\xe1\x9f\x75\x8f\xf3\x37\x71\x9a\x9a\xf8\xe3\x5d\xf8\x77\xf8\x6f\xe2\x5d\x80\xac\xbb\x52\x92\x19\xf2\x56\x18\xb0\x96\x44\xd1\x1b\x96\x58\x44\x2d\xa0\x70\x3b\xe8\x24\xff\xf5\x14\xc1\x45\x4a\xa2\x14\x68\x06\x51\xe1\x42\x9f\x83\x0e\xdb\x19\xb1\x06\x42\xee\x9a\xc2\x7d\xba\x83\x9e\x77\xb8\x7b\x84\x69\x8b\x79\xcb\xec\x58\x5e\x8b\x68\x36\xc4\x0c\x2f\xda\x6a\xd9\x72\x25\x33\xe4\x50\xea\x2a\xee\x63\xd7\x78\xd2\x59\x69\x26\x71\x6f\x69\x93\x02\xf8\x2e\xdc\x78\x03\x28\x8f\x8e\xeb\x58\xf6\x78\x18\xec\x1f\xa8\xe3\xb4\xe0\xfb\xa2\xb6\x05\x6b\x6d\x9f\x65\x75\x8d\x4e\xcd\xff\x25\x08\xf6\x6c\xba\xdf\xce\x1d\x02\xad\xea\x7a\x05\xb7\x1a\xbc\xf3\xd5\x0a\x1d\xea\x35\x3d\x11\x34\xed\xd3\x0c\x7c\xa3\x66\xec\xc4\x03\x0f\xa0\x3d\xed\x7e\x82\xa0\x3f\x82\x6b\x51\x4e\x34\x10\x4b\x52\x03\x94\xa6\xb2\xb8\xb7\xb6\x36\x0e\x4c\x1a\x06\xee\x66\x8d\xfa\xa4\xbb\xae\xad\xd3\x6d\x2a\x05\x71\xd0\xd6\x19\x88\x2b\x34\x26\x4d\x5b\x67\xcc\xe4\x08\x5b\xf5\x71\x53\x38\x6c\x8a\xeb\x69\xb5\xd5\x48\xa8\xd9\xcc\xe3\xff\xd8\xd3\xcb\x04\x2d\x48\x38\xab\x8b\x7c\xc0\x5a\x45\x5d\x4c\xac\x48\xa0\x09\x51\xa0\xc0\xee\x40\x72\xc6\xc5\x1a\xf2\xbd\x21\x2d\x1b\xae\x5d\x99\x04\x73\xd2\xdd\xd3\x2c\x5b\xcc\x37\x2e\x17\x04\x38\xf9\xc9\x6b\x76\xdd\xcb\x86\x40\xa7\x73\xab\x75\xe7\x0a\x30\xa4\xef\xfd\x59\x0f\x3f\x38\xbc\x42\x7d\xf8\xfa\x5f\x83\xf1\x9a\xf2\x78\x85\x8e\x73\x82\xf3\xec\xb4\x2b\x7a\xcc\x9f\x60\x41\x5d\xd3\x89\x84\x74\x38\x7c\xfd\x9a\xdd\x0e\xee\x05\x72\x85\xad\xa5\x59\xf7\xc5\x58\xef\x93\x47\x90\xef\xe7\xce\x73\xd3\xe8\x1a\xb8\xff\xd5\x40\xfd\x5c\x9d\x6a\xb1\xb0\x49\xa5\xd2\xdf\x5c\x55\xa5\x2f\x89\xfa\xe1\xf6\xe3\x1e\xea\x1e\x42\x45\x89\x58\xac\x16\x49\x22\x64\x64\x2d\x0e\x93\xd7\xd1\xd6\xe9\x57\x7a\xd5\x26\x35\x92\x56\x4a\xe7\xf5\x12\x36\x37\x31\x40\x76\x90\x13\x9a\x68\x51\xb6\x8d\x3a\x85\x73\xff\xf9\x69\x22\xba\xac\x17\x82\xf2\x90\x7b\xf8\x50\x52\x6e\xa7\xd9\xf2\xc2\xe5\x06\xb9\xeb\x2f\x47\x4e\xcc\x5c\xe9\x11\x7d\x7c\xc0\xef\x38\x5c\xc2\x8a\x86\x6b\x77\xfc\xda\xad\x7a\x52\xa3\x84\x4e\x7f\x2d\x72\x79\x91\x8c\xe7\xb7\x5d\x39\x5b\x7b\xd5\xd7\x1a\x64\xc0\x9a\xeb\x8e\x28\x90\xf9\x32\xd4\xf1\xfb\x87\x6b\x57\x86\xe7\x74\xf0\x9b\x02\xf5\xdf\x59\xae\x1f\xfa\xb2\x15\x50\x68\xe7\x70\xbc\xb0\x24\x95\xb4\x59\xd8\x70\x09\x94\x97\xde\xcf\x52\xee\x58\xac\xd2\x5d\x51\x48\x3e\xe1\x32\xaf\xd7\x16\x83\xe1\x44\x7b\x67\x19\x14\xa1\x0d\xb9\xb1\x16\xde\x2a\xd1\xad\x9c\x5c\x51\xe5\xde\xbd\x46\x5e\x0c\xd7\x74\x8d\xe0\xe2\xbe\x0c\xf5\x51\xe0\xab\x91\xe4\xfb\x15\x55\xad\xeb\x3a\xed\xac\x24\x90\xa0\xaf\x25\x3d\xd6\x26\xfa\x78\xd6\x31\xd8\x65\x79\x26\x44\x0f\xed\x99\x12\x6d\xa4\x9e\xd1\x2f\x38\xb0\x7c\x19\x96\x81\x9a\x3b\x0a\x6e\xe0\xa5\x00\xea\x6f\x59\xf5\xd9\xb6\x65\x06\x61\xbe\x3f\xc0\xf9\x86\x89\xae\x54\x35\x4d\x32\xc5\xa6\x90\x89\xa1\xb4\x76\x7b\x54\x1b\x61\x48\x25\x61\x50\xb6\x75\x9a\x8a\x0d\x3e\xc2\x87\x9e\xb2\x4e\xc1\xf0\x90\xb6\xd9\x5c\xed\x9d\x76\x9b\x89\xe6\xcf\x73\xf2\x47\xc9\x2f\x3d\x4b\x5c\x5c\xca\x9e\x52\x96\x6b\x16\x27\x0e\x3a\xfc\xc1\xe6\x83\x63\xa5\xdd\xdd\xe9\xf4\x47\x4f\xbf\x35\x2c\xee\x0f\x0e\xda\xb4\xc3\x1f\xf4\xb8\xf8\x29\x83\x26\x0d\xf7\x2a\xd8\xc2\x7b\xe4\x27\xde\x39\xa9\x79\x5c\x73\xdb\x13\xfb\xf1\x2c\xd1\x1a\x9e\x82\xf1\x0e\xf4\xa7\x44\x92\x98\x95\xaa\x2c\x73\x2a\x8a\x1b\x12\x41\x3d\x51\x4c\x34\x36\xe9\x1b\x28\x5b\xb5\xd3\x5d\x56\xeb\x77\xd6\x3a\x6b\x29\xbf\x3f\x32\xa9\x33\x14\xf2\x9b\x28\xcd\xa4\x4e\xa5\x92\x42\xb7\xa1\xf1\xc1\xf0\x44\x5c\x7e\x8d\xbc\xc9\xdc\xd4\xc4\xdf\x7e\xe4\xef\xec\x8a\x7b\x0f\xdf\xe3\x33\x29\xe4\x03\x55\x74\x94\x9f\x5c\x12\x27\xfe\x7e\xe9\x9b\x89\xdd\x07\x10\x08\x76\x02\x76\x6a\xe7\x3f\x4f\xef\x7f\xaf\xec\x9e\xc0\xce\x35\x77\xec\x62\xe3\xe3\xbf\x1f\xda\x58\x3d\x54\xbd\x55\xbb\x68\x4a\xf1\x37\xbf\x05\xf3\x2a\xf6\xd9\xd7\x2f\xba\x7e\xdb\xc4\x2b\xc7\x0f\x5d\x98\x98\xe2\xd8\xca\x4c\x1a\x15\x00\x83\xf7\x1e\x58\xb3\xa9\x71\x7a\x5b\x77\x97\xb7\x2a\x16\x69\x33\x92\x03\xe2\xd3\x36\x59\x6a\x87\xde\xf5\x70\xbf\x6b\xe2\xc8\x89\xad\x4d\xa3\x83\x45\xf6\xe0\x84\x09\x4b\x6c\xf8\xac\x70\xff\x43\xfd\x67\xc9\x1e\xa6\x02\xc6\x2f\x9b\x53\x43\xed\x95\x95\x45\x45\xce\x32\x0b\x15\x51\xb8\x4d\x66\x93\x82\xa2\x75\x01\xa7\xb3\x46\x57\x5d\x64\xb1\x5a\x26\x75\x9a\xdc\xc6\xe2\x92\xe2\xb6\x4e\x45\x44\xa5\x2b\x31\xa6\x8c\x2a\xa8\xdb\x46\x23\xe1\x60\xad\x70\xdf\x21\x62\x82\xd1\x63\xcf\xf7\x16\xde\x9b\x73\xc3\x3d\xd9\x1d\x02\x4b\x4e\xdc\x27\x04\x31\x0d\x99\x65\x77\xc8\x2a\x77\x32\x65\xe7\x5f\x7e\x4e\x2a\x15\xc0\x3a\xb5\x5b\x51\x63\x31\x0a\xcb\x1f\x1d\xb4\xb1\x68\xf3\xe2\xeb\xe2\xc7\x8b\x8e\x8f\x2e\xb1\x0b\xea\x1e\x2a\xf1\x29\x67\x94\x0f\xb0\x5e\x61\x5b\x38\xc5\xd5\x04\x28\x06\x69\x01\x0d\x1a\x6e\x38\x7f\xfe\x06\xee\x16\x1d\x52\x02\xed\xbe\x84\x65\xba\x61\x9b\x13\xca\xe2\x63\xb8\x27\x28\xf0\x5b\xf8\xcb\x53\x83\x5d\x7e\x83\x95\xf4\x19\x55\x2a\xc2\x6c\x0e\x11\x41\x8b\xd1\x64\x84\x7b\xae\x55\xcb\x7a\x58\xb8\x29\x93\xb4\x4a\xe5\xd1\xa6\xb4\x70\x1f\x76\x3a\x8d\x5a\x60\x50\x68\xb5\x84\xc9\x08\xb0\xee\xe3\xdb\xb0\xc2\x8b\x4f\xf8\x16\x77\x9c\x7f\xd6\xba\x36\x6e\xce\x97\x04\xae\x04\x85\x92\xf2\xa8\x8d\xbf\x40\x20\x9b\x33\x08\x28\x2b\xdc\x60\x6d\x55\x20\x1a\x55\x6f\x35\x6d\xe8\x1a\x7e\x15\x18\xd0\xb7\xd7\x4d\x35\xba\xb9\x7b\x9a\xca\x02\xb5\xaa\xad\x86\x35\xdd\xad\x5b\xb9\x23\xe4\x73\xee\x9b\xc1\x75\xba\xea\xf8\x8a\xd5\x3e\x30\x68\xe7\xcd\xdc\xdd\xa6\xda\xaa\x55\xab\x4a\xb8\x23\x3b\xe1\x9e\xf7\x0e\x37\x95\x8e\x42\x5d\x0f\x11\xb5\xc4\xf8\x54\xb4\x84\x34\x9b\xeb\xbc\x31\xf4\x64\x82\x37\x61\x80\x61\x97\x4b\x6d\x30\xd8\x09\x7b\x55\x5b\x67\x71\xb1\xdd\x2d\x5c\x80\x30\x89\x17\x20\x04\x3d\x77\xe2\xdb\x74\xe2\x47\x6a\xf1\x89\x40\xbf\x14\x38\x09\x5f\x2e\xf9\x77\x39\xa3\x21\xb4\x99\xb5\x00\x2b\x4c\x3a\xa5\x78\x13\x37\x0e\x22\x1f\x01\x93\x1b\xf6\x85\xde\xbe\xfd\xc1\x40\x90\x6c\x9e\xb3\x76\xfc\xfd\xaf\x8c\xdd\xfa\xf2\xe6\x75\x4f\x3a\x49\x65\x09\xf3\xac\xd5\xbb\xa7\xfa\x9f\x60\xfe\xe2\x85\xcb\x0e\x76\xf7\xac\x98\x71\x5d\x7b\x23\x3d\xf6\x42\xf9\xc3\x77\x3f\xbd\xbf\x73\x42\xf9\x89\x27\xb6\x71\xbd\xbd\xdd\xab\x66\x84\x77\xaa\xdb\x6f\xa7\x06\x9e\x3f\x79\xe1\xab\x75\x9b\x1f\xe6\xbe\xdb\xb5\x71\xe7\x98\x47\xd0\x63\xbb\x80\x98\x08\x3e\xa5\x02\xf4\x53\xf8\x4c\xa2\xec\x6c\xa6\x92\x9c\xd4\xe9\x53\xb6\xa0\xe3\x99\x6a\x05\x8d\xb2\xe4\x78\x22\xab\xe3\x46\xd6\xd1\x4c\x6f\x0b\xf7\x54\xcb\xda\x9d\x6b\x9b\xc0\xf4\xa6\xeb\x76\x82\x4f\xc1\x30\xee\x55\xf2\x3d\xee\x7f\x40\x69\x5f\x02\xca\xf3\x4b\xb8\x5f\x56\x42\x7d\x09\xc2\x6c\x69\x72\xaa\xdc\x48\x50\xca\xaa\x2a\x8d\x9d\xb2\x7b\x6b\x55\xd1\xa8\xd7\x5b\x43\x84\xda\x3a\x8d\x6a\x82\x70\xab\xdd\xe5\xd0\xff\xbb\xb5\x2a\x35\xb4\x19\xb5\x74\xbf\x4a\xba\x8d\x19\xcb\x2a\x2a\x48\x89\x10\xfe\xa4\x8a\xcf\xab\x2a\x19\xa4\xf7\x5e\x1a\x15\x81\xf8\xef\x26\xa4\xc3\x4f\xc9\xef\xf5\x56\x3b\x4a\x9a\x52\xbf\xe9\x7b\xd9\x4d\x85\x8b\xb8\x77\x5c\xc1\xaa\xe1\x6d\xc3\xab\xc6\x3f\xf4\xdf\x9b\xde\xfe\x5b\xdb\x83\x9f\x5d\xc9\x1d\x1f\xac\xb9\x75\xcb\xc6\x17\x3a\xef\x26\x6d\xee\x86\x40\xe5\xc8\xca\x9b\x77\x6e\xff\xcc\x12\x70\x38\xeb\x87\x4c\x5c\xb0\xa9\xed\xca\x0f\x1e\x69\xfb\x7d\x7a\xc9\xc9\x87\xdb\x6f\xe2\xd2\xf5\xf1\xf5\xdb\xaf\x7a\x7b\xcd\x86\xdb\xf8\x98\xfd\xf9\xfe\xb7\x99\xe3\xcc\x19\x18\x29\x6d\x4b\x8d\xa9\xd6\x30\x86\xba\x3a\x4b\xdc\x69\x32\x55\x59\x4a\xa2\xd1\x22\xb7\xdd\xa2\x66\x14\x0a\xbf\xbf\x91\xa4\xe9\xa4\xdb\x69\x8b\x5b\xab\x19\x52\xe5\xaa\x62\x4b\xd8\xe2\x32\xa8\x4b\x26\x17\x4b\x58\x34\x5a\x0d\x7a\x44\x3d\xa5\x35\xd6\x13\x04\x0c\x20\xf0\xbd\xf5\x5e\x5e\x0c\x45\xef\x0b\xf1\xd2\x5b\x42\xff\x11\x87\xf8\xad\x16\xfe\x54\x5b\x9b\x09\x4b\xc5\xdb\x36\x38\x2c\x88\x66\xd5\xf6\x81\x35\x41\x2a\x51\xfb\x44\xe1\x7b\x56\x48\xf6\xa1\x0b\x99\x12\x72\x18\x54\x4b\xcd\xa0\x67\xf6\x92\xc6\x4d\x92\xa7\x58\x05\x46\xdf\x99\x9e\xa2\x05\xaf\x3c\xcb\xdd\x19\xab\x83\xb1\xd4\xe6\x5f\x6e\xb2\x1c\xde\x74\xcc\x7f\xed\xe1\x39\xdc\xe7\xb6\x26\xec\x3a\xfc\x23\x5e\x29\x49\x8e\x25\xef\x40\x4e\xa3\xef\x45\xb0\x9e\xfc\x33\x37\x29\x0e\xfa\xb8\x4e\x35\x0a\xa6\xfa\xae\x21\xb7\x4d\x6f\x7e\xf2\xd8\x63\x7d\x7b\xc1\x19\xee\x50\x10\xb9\x92\xfe\x7e\xc2\x02\x05\xf7\x1a\xba\x93\xa1\x7e\x8f\xc8\xfb\x77\x98\x0b\xbc\x07\x75\xe7\x7a\x7c\xd7\xb7\x1c\xe6\x03\x57\xa7\x06\x94\xfa\x55\x4c\x24\x02\x6c\x71\x73\x0d\x74\x6a\xc6\x78\x18\xf8\x03\x0a\x5f\xbd\xaf\xce\xe7\x76\xab\x1c\xba\x88\x2d\x80\xde\x60\xab\x32\x43\x1f\xe5\x70\x04\xd1\x9d\x5f\x5d\x0c\xdd\xf2\xa5\x8d\x42\x6f\x23\xf1\x55\x48\xb1\x23\x07\x0a\xb4\xf2\x23\x7c\xfe\xfc\x43\x22\x99\x1d\x48\x21\x11\x0a\x19\x37\xfe\xaa\x83\xce\xc1\x27\x03\x48\xbd\xd0\x35\xa1\x00\x8a\xe3\xab\x16\xc7\x65\xc1\x93\xb2\xdd\x35\xa1\xf1\xcc\x71\x1c\x6e\xcd\x3e\x7c\x70\x31\x49\x6d\xbb\xa7\xbc\xef\x77\xca\xcd\x40\x7b\xe7\x81\x72\x32\xa2\x9c\x4d\x2e\xfe\x41\x0a\x9f\x46\x0e\xde\xc6\xf5\xfd\x08\x43\xac\x65\x9c\x87\xba\x8d\xbb\xed\xe0\x1b\x89\xc6\x8d\x3b\xa9\xf6\x83\xcf\xb4\x94\xe0\xc4\x90\x24\x4c\x70\x1f\x9e\x00\x6d\xc9\x8e\x6f\xe3\x55\xfb\xec\x16\xca\xe3\x01\x5a\x86\x51\xab\x94\x2a\x37\x60\x2d\x8a\x40\xd0\xa3\xb5\xa3\x36\x19\x2a\x38\x65\xa0\xa5\x08\xc2\x48\x1a\x61\x78\x65\xb4\x2b\x49\xa3\xec\x3a\xe7\xc5\xbb\x92\xf0\x67\xfe\x79\xdb\x86\x13\x56\x4a\x67\x17\xd0\x74\xa1\x99\x21\x13\x2b\xbf\x72\xc6\x2f\x67\x82\xef\x66\xfc\x72\xc6\x82\xa2\x05\xce\xc8\x4f\x6f\xbc\xf8\xa6\xc2\x76\x25\xf8\xb0\xe7\x76\xb7\x99\xb3\xd8\x68\x72\x31\xf8\x2f\x2e\x8e\xfe\xbf\x6d\xc3\x6b\x47\xf7\xfd\xc2\x31\x70\x19\x77\xcf\xcd\xb7\x4e\x5f\x96\xd0\xff\x27\xca\x2b\xce\xc3\x79\x1c\xc0\x3e\x21\x46\x5c\x95\x6a\xa4\x94\x06\x0b\x6d\xa2\x4d\x6c\x44\xab\x75\xda\x59\x4d\x59\x19\x1d\x04\x3e\xd6\x57\x59\x11\x75\x06\x89\x20\xca\x68\x61\xaa\x0b\xf3\x6e\x74\x95\xdb\x62\x80\x5e\x0a\xee\x28\x46\xc6\x28\xb4\x5a\x49\x24\xf2\xd7\x35\x13\x58\x64\x7a\x82\xe0\xaf\x09\x30\x77\x40\x9e\x02\x7a\xdc\x40\x15\x40\x05\xec\x80\x17\x38\xd0\x3c\x15\x04\x7f\x9e\x2d\xb3\xaa\xba\xae\x49\xc7\xb9\x7f\xba\xc1\xbb\xee\xe9\x0f\xd4\x92\xe3\xc9\xf6\x56\x37\x78\xdd\xcd\xfd\xa3\x6d\x04\x33\xa7\x68\x1c\x19\xe6\x7a\x4f\xbd\xfd\xb5\x66\x0c\xf8\x71\xd7\x07\x45\x7d\xf7\xe8\xb6\x93\x8b\x7f\x79\xd7\xce\x9d\xa5\x4f\xae\x5d\xff\x78\x74\xe7\xce\x39\xf7\xb6\x6f\xb3\xfc\x81\xfb\xe9\xb7\xbf\x6a\x68\xe4\x7e\xf1\xce\xa3\xad\x81\x0d\xdb\xd0\x1a\x16\x43\x9d\x46\xb5\xa3\x30\x51\x07\xd7\x30\x1e\x0b\xea\x9c\x4e\xb7\x45\xa1\xa8\xa5\x28\x9f\x9b\xaa\x6f\xf0\x12\x70\xce\x6e\xb8\x94\x36\xc2\x06\x37\x19\x9b\x5d\x63\x6c\xef\xd4\x69\xdc\x44\x24\x53\x2c\xca\xbc\xc1\xd5\xc4\x57\x8d\xb2\x17\x31\x53\x1f\x32\x02\xd9\xfb\xa6\xf2\x62\x51\xe6\x80\x54\x4e\x51\x68\x69\x57\x65\xe6\xd5\x53\xb6\xa5\x49\xaa\x10\xfd\x98\x9e\x5c\xa8\x12\xf4\x12\x77\xef\xdc\x6f\xf9\xc7\x50\x97\xe9\xf9\x92\x10\xfd\x57\xae\x33\xbf\x0a\x84\xe6\x8e\xde\xca\x79\x1a\xce\x3d\x08\xb3\xa7\xe9\xa9\xea\x38\x65\xf4\x95\x7a\x3c\x06\x93\xc9\x57\x6c\xa7\x98\xda\x84\x5f\x53\xac\x2c\x86\xd3\x2d\x66\xf9\x88\xd8\xad\x27\x94\x31\xfc\xb2\x62\x48\x56\xef\xc1\x4f\x78\x65\x24\x90\x3d\xf7\xbc\xd7\x15\x41\xf6\x1b\xaf\x97\x29\xed\xb4\xa7\x39\xae\x53\xfe\xee\xeb\x84\x8b\x96\x73\xc0\xbe\x9f\x3f\x90\xde\x81\x2d\x54\xc8\x01\xfd\xb3\xb9\x69\xb8\x8e\x13\x24\xa6\xa5\xe2\x66\x60\x24\x0d\x56\x93\xc1\x48\xab\x5c\x44\x20\x50\xa2\x0a\x39\x3c\x30\x9c\x70\x10\x84\xd9\x62\x9e\xd4\xe9\x87\xfe\x0c\xb4\x77\x1a\x59\x85\xb6\xbd\x53\xa5\x90\x3f\x65\x9b\xc8\x2d\xd8\xc8\xb2\x80\x02\x4f\xd8\xe6\xd5\x68\x1e\x9c\x22\x9f\x51\xc7\x4b\xb8\x30\xf3\x1f\xb7\x64\x15\x66\x2e\x9c\x92\xe6\x42\xfd\xea\x86\xf5\x0f\x5d\x2f\x56\x64\xd0\xba\xd1\xdc\x34\x66\x09\xae\xc9\x0c\x85\x39\x6f\x73\x1d\x69\xae\x56\x0f\x2c\xf3\xba\x8a\xe2\xa1\x50\x91\xda\x4c\x0f\x1b\x1e\xac\x6e\xeb\xd4\x18\x5c\xc5\xc1\xa0\xa1\xd8\x68\x6f\x6e\xeb\xb4\x9b\xca\xa2\x15\xd1\xf6\xce\x0a\xaa\x82\x22\x0c\x86\x64\x5b\xa7\x01\xbf\xdc\x84\x1e\x6e\x92\x69\x6f\x3c\x2e\x6c\xf2\x7c\x16\x5c\xa0\xe5\x82\x10\x3a\x65\x0e\xf3\xf0\x5b\xbb\x85\x2f\xb2\xe0\xd3\x3c\x4a\xb8\x81\x05\xe4\x62\x40\xf6\x0d\x24\xb5\x46\xa9\x20\x09\x6e\xe3\x9e\xc7\xa1\xd4\x43\xfe\x20\xd9\xd4\xbd\xb6\xed\xc1\x97\x50\x28\xb5\xf6\x71\x0f\x0e\xa5\x94\x0e\xeb\x2a\xf0\x5c\x63\xd1\xed\x9b\x5a\x52\x9e\x44\xdd\x92\x22\x37\xf7\x83\xad\xfa\x9f\xdc\x43\xb2\xe0\x8a\x9b\x06\x83\xab\x7b\x9e\xda\x3f\x65\x52\xc5\xbb\x8f\x6d\x03\x75\xbd\xdd\x57\xcf\x86\xc1\x95\xb7\x73\x71\xdf\x4b\xdc\xfb\x77\xed\xb0\x3f\x60\xbf\xed\xbe\x85\xe7\x4f\x52\x5e\x18\x67\x01\x0b\x8a\xb3\x1e\xe6\xfe\x85\xfb\xb4\x40\xbd\xef\x80\x7a\x80\xde\xda\x8d\x3a\x8c\x30\x38\xa0\xcc\x66\x46\xab\xa2\x8b\xdc\x0e\x96\x25\xda\x3b\x59\xb7\x51\xcb\x50\x94\x1e\xc6\x41\x2a\x96\x32\xb5\x77\x52\x62\x9b\x31\xe1\x92\x27\x21\xf3\xd3\xbc\x79\x43\x51\xa0\xeb\x0e\x50\xbd\xd1\x57\x58\xab\xa4\x06\x64\x12\xae\xb1\x85\xfb\xe1\xa9\xd6\xc3\xc0\x9f\x3e\xdc\x0b\x16\x7f\xde\xf7\xdd\xbf\x57\x8b\x1a\xc0\xfd\x6b\xd7\x35\xe0\xa7\xeb\xb9\x9b\x98\xde\x0b\x4b\x8f\x82\x11\x5c\x9c\xab\x15\x56\x9e\x8f\x63\x06\x71\xd3\xc0\x8f\xf8\x3e\x4c\x7d\xaa\x88\x30\x98\xf4\xa8\x05\x84\x45\x69\x36\x12\x06\x38\x50\x03\xcb\x68\xda\x3b\x95\x8c\x5c\x3d\xb3\x0f\x14\x24\xb3\x15\x12\x24\xce\x4f\x93\x6b\xdf\x74\x38\xa8\xcc\xd3\xcf\x90\x8f\x20\x1f\xc5\x58\xa8\x5f\x03\x88\x45\xa9\xc6\x32\x97\x8b\xa0\xaa\x13\x09\x5f\x3c\x14\x0c\xfa\x7c\x94\xd1\xa2\x65\x06\x0e\x72\x59\xaa\x0d\xd5\xc1\xf6\xce\x6a\x36\x5a\xd1\xde\x59\x16\x75\x7b\x1a\xe0\x6e\x60\xb2\x2b\x90\xaa\x19\x8c\x84\x16\xd7\x98\x32\x5f\x15\xf2\xfc\x43\xc6\x3b\x9a\x33\xed\xf6\x2e\xfe\x8a\x9b\x32\xd7\xb0\x24\x78\x72\xd7\x25\x5e\x71\x63\xbb\xe7\xc9\x67\x3b\x0f\x81\xa2\x97\xdf\x2e\xfa\x86\x5b\x6a\x3e\x67\xc8\xbc\x26\xcd\x43\x3d\xd6\xb7\x87\x10\xe5\x42\xdb\xf1\x9d\xe0\xd6\x54\x19\x61\x00\x7a\x73\x24\xa2\x37\x28\x3d\x3e\xa7\xb2\xac\x3c\x64\x6d\xeb\x0c\x99\x7c\x06\xb7\x11\xf5\x3c\x2c\xbc\x34\xe8\x84\x53\x2c\xeb\xfd\xd2\x70\xfe\xb4\x0a\x48\x01\xcd\x7f\xf7\x0c\xf9\x4c\xba\x84\x90\x2f\xfd\x84\xbc\xaa\x26\x7b\xc4\x5b\x8c\xef\x84\xf9\xf1\x45\x34\xb8\xd7\xbf\x27\xd4\xcb\x22\x44\x3d\x31\x31\x55\x19\x76\xb9\x12\x76\xbb\xce\xe8\xab\x60\x54\x49\x55\x43\x31\x5c\x52\x5f\xb1\xdb\x48\xbb\xc2\x34\x61\xb5\xc2\xfc\xca\x6a\xd2\x1a\x55\x6e\x22\x9e\x71\xf8\x7c\x25\xcc\xd1\x24\x7a\x40\x8b\xf4\x2a\x30\x23\xc5\x62\x39\x25\xaf\xec\x7d\xcf\x5a\xa8\xfe\x35\xfb\xf0\xbf\x64\xa1\xda\xf5\x2b\x23\x99\xc9\x5a\xc3\x53\xb2\x8b\x5e\x30\x22\x63\x14\x52\xa0\xf6\x0e\xd7\x33\xeb\x6d\x7e\xda\x0b\x95\x39\x05\x2f\xd0\x3f\x00\xfa\x7c\x54\xef\xf2\x13\x13\x52\xa5\x4a\xb6\xc8\xa5\x52\xd9\x60\x42\xe2\xf7\x07\x0d\x01\xbf\xd7\x4b\xb6\x77\x7a\x4d\x45\xac\xf3\xa2\xef\x96\x5b\x04\x73\x07\x79\x9f\x4f\xf9\xa3\xf5\xb9\x7a\x99\x5f\xc8\x6a\x9b\x2c\x5f\xb8\xa9\x7b\x73\xab\x57\xdc\xa2\x8c\xab\x6f\x16\xeb\x56\x04\xc3\x4d\xa3\x4e\xc2\xbc\xb7\x1e\xbd\x07\x6c\x28\x2a\x8a\x12\xaa\xaa\x2a\x2b\x0c\xbf\x92\x0d\x55\x44\x91\x81\x36\x85\xc3\xb1\x49\x9d\xa5\xa5\x61\x93\xc9\x31\xa9\xd3\x66\x83\xa6\x97\xb5\x51\xc9\xeb\x3c\xf2\x66\x41\xe2\xe8\xf1\xf1\xb9\xec\x58\x44\x2a\xf4\x80\x28\xdf\x45\x24\x53\xe2\x41\x0f\xea\x92\xd4\x4e\xcd\xc8\xcc\x4c\x8a\x56\xde\x7c\xe0\x03\xa1\xce\x53\x31\x6d\x47\x4f\xcf\x70\x59\x7d\xa7\x7c\xe2\x1d\x9b\xb7\xb4\x82\xc1\xa1\x5a\xee\x17\xfc\xdc\x6e\x8a\xae\xde\x8c\x4b\x3c\xe5\x83\x6b\x2a\xca\xdb\x96\x8e\x12\x8b\x3b\xe5\x03\x2a\x2b\x4b\xdb\x57\xa0\x37\x23\x7e\x86\x73\x2e\xc3\xb1\xd8\xa4\x54\x2c\xe8\x0e\x18\x58\xd6\xe6\xa6\xc8\x28\x19\x71\xbb\xbc\x30\x02\xb1\xc1\xd8\xd3\x6b\xf3\xda\x08\x1d\xbf\x4e\x04\xc1\xb4\x67\xbd\x3d\x28\x6d\x62\x59\xaf\xcc\x27\xf8\xa7\x6c\xc4\xc3\x84\xd2\x76\x5c\x60\x97\xba\xb6\x2d\xe5\x6b\xaa\x1d\x3b\xcb\xf5\xc7\xf0\x8b\xf7\x8d\x1f\xe9\x1f\x54\xfb\x8b\xaa\xdd\xe0\xd5\xac\x8d\xe8\xab\x68\xc9\xb3\xdc\x34\xfb\xc3\xce\xa5\x9b\xe8\x1b\x5f\x39\xe4\x7c\xcc\xfb\xed\x85\xf7\xa5\x0d\xe7\xdd\x23\xcf\x62\x5f\xb1\x82\xeb\x40\x7d\x1e\x08\x27\x31\x2c\x15\x34\x19\x95\x84\x0d\xe8\xf5\x36\x23\xe5\x72\x38\x9d\x45\x0e\xa3\xd1\x66\x30\xa0\x2f\xb2\xb9\x4e\x82\x8f\x2c\x32\xe7\x56\x84\xd1\x67\xbb\x09\xf4\x28\xb9\xdd\x07\xd0\x9d\x1c\x72\xcc\x77\x0d\x9e\x5b\xc5\xc1\xb9\xb8\xa7\x5f\x7c\x65\x81\x5a\x43\x17\x75\x81\x9e\x37\x77\x72\xa7\xee\xde\x8e\x06\x75\x03\x3d\xa0\x2f\x35\x7c\x75\x7d\xfd\x8b\xe4\xeb\xf2\xb7\xe6\x9d\xc4\xe4\x54\x85\x5d\x65\x25\x4c\x4e\x03\x49\x9a\xac\x36\xda\x52\x64\x71\xd9\x09\x13\x65\x74\xd8\x8c\xe8\x82\xbb\x02\x06\x41\x6d\xf9\x41\x90\xf0\xdc\x6c\xce\xe5\x48\x31\x38\xb0\x66\x9b\x84\xf4\xf2\x3c\xb9\xe8\xb7\x2b\xeb\x3d\x0f\xde\x32\x3a\xe5\xad\x1d\x7c\xad\xc7\x19\xf8\x2f\xf9\xdb\xf3\x64\x15\xd7\xc5\x9d\xdd\x75\xab\xfd\x11\xc7\x9d\xd7\xa3\x07\xd5\xc5\xa7\xe7\xf9\x7d\xf0\x63\x38\x66\x54\xe7\xb2\x41\xdf\x1b\x51\x50\x94\x5a\xa7\xb3\x68\x95\x34\xf4\xc7\xac\xc5\x64\x82\xfe\xd6\xe4\xd6\x28\x55\x4a\x98\x69\x19\x19\x2d\xad\x6d\xe3\x5b\xd2\x08\x15\x0b\xf1\xf7\x6c\x95\x40\x9b\x76\x40\xe8\x7c\x21\x69\x02\xf8\x19\x1a\x69\x5f\x95\x9b\x2a\xee\x7b\x12\x15\xab\x2e\xfc\x91\x7c\xb2\x4e\xb6\x59\xdf\x4c\x45\x76\xde\x7c\xe1\xf7\xdc\x0f\xd2\x1e\x4d\x12\x55\x70\xad\x9f\x84\x3e\xa6\x9e\x18\x46\x6c\x48\x0d\xb5\x36\x04\x95\xca\x68\x34\xce\x06\x83\x64\xdc\xed\xf1\x0c\x32\xc6\x8d\x23\x86\x5b\x92\x93\x3a\xd5\x16\x8b\xce\xd7\xe6\x06\x46\x37\xcc\x05\xdd\x6e\x9f\xcf\xd9\xd6\xe9\x33\xe9\x5a\xd0\x27\x78\xa6\x6c\x52\x27\xc3\x12\x35\xed\x99\x98\x4c\xea\x7f\x25\xf4\xc7\xe8\x42\x37\x83\x9a\x62\x39\xc6\x2c\xd6\x60\xf0\x85\x28\x98\x18\x46\x32\xb7\xa2\x4a\xc2\xc9\x8b\xdc\x8a\x6a\x01\x4a\xf1\x64\x21\x50\x1a\x28\xf1\x18\x26\x5d\xf1\xa5\xa2\x68\x33\xa3\x98\x7c\x68\xd3\xad\x07\x80\x1a\x04\xbf\xb1\x2e\x99\xbd\x76\xbd\xfb\x50\xe5\x17\xbf\x7e\xf6\x6d\xeb\x18\xed\x24\xbb\x87\x8a\x2b\xba\x2b\xca\x7c\x09\xee\xe3\xb7\xd7\xee\x18\x1b\xeb\x1e\xdf\xfd\xd0\x42\x13\xd7\x71\xd2\xdc\xb0\xdd\x7c\x63\x6a\xd3\x82\xa7\xb6\xbe\x74\x94\xa6\xe6\x15\xcf\x9c\x36\x75\x5a\xf1\x3d\xdb\x76\x6f\x4f\x75\x71\x37\x55\x97\x8e\x56\x80\xef\x5c\xbe\xb9\xda\x87\x55\xd4\xeb\x34\x15\x6e\x9a\xd6\x3c\x76\xf6\xe4\x9b\xc6\xf3\x79\x48\x07\xfd\x18\xdc\x57\x4b\x60\x44\x3b\x2b\x55\xad\x29\xd7\xfb\x7c\x06\x83\xde\x6d\xa9\xa1\x2c\x54\x7d\x5d\x50\xe3\xd3\xf9\x0c\x50\x52\xac\xc3\xe5\xb2\xb5\x77\xba\xdc\x3a\xa3\xb2\x12\xe7\x21\xe1\x9c\x3c\x44\x56\xa2\x6a\xca\x1c\x29\x94\x04\x94\x95\x8b\xc0\x7c\x5a\x3a\x5d\x19\xc2\x92\xbb\x4c\x36\x12\x38\xfc\xab\x1b\x12\xfc\xdc\xcb\xbe\x54\xb8\x77\x5c\x2c\x15\x39\x7c\x61\x12\xd7\xc7\x4f\xf5\xa4\xb9\xfe\xf6\x42\xb9\x08\xce\xbd\x98\xe5\xcc\xef\x61\xc6\x3d\x00\x66\x23\x55\x8d\x54\x8d\xdb\x5d\x1a\xf6\x85\x29\x6a\xa0\xc5\x32\xc8\x1f\x0c\x16\xb7\x77\x06\xdd\x26\xb6\xbd\xd3\x62\x02\x65\x1a\x42\xa9\xac\xc3\x33\xae\xc8\x79\xd3\xbe\x49\xf6\xe6\x6a\x81\x3e\x92\xb2\x4f\xec\x99\x34\x44\x29\x9b\x37\x7f\xdc\xf4\x52\x39\x98\xdf\x73\xdf\xc6\x91\xc9\xe2\xb8\xbf\xa5\xd5\xf6\x0f\x66\x4e\x63\x9d\x77\xc4\x90\x45\x6b\xd4\xc9\x8b\x25\x62\xf7\xdf\x70\x2f\xfb\x0b\xdb\xac\x05\xff\xa6\x3c\xf6\x2e\xfd\x23\xfa\x6b\x17\x97\x56\x03\x4b\x61\x19\x74\xd0\x51\x1c\x8b\x54\x11\x53\x53\x95\xac\x4e\x57\x6a\x2a\xa9\x22\xc9\xe2\x62\x55\x09\x55\x1d\xaf\x82\x0e\xd2\xa9\xaa\x52\x55\x15\x05\x02\x30\xed\x0c\x98\x8a\x18\xd4\x3e\xc6\x6a\x68\xef\xb4\xca\x4d\x44\xf4\xfa\x4d\xb9\x67\x55\xe4\x27\x55\x72\x96\x5a\x21\xf4\x19\xcc\x3e\xa4\x02\x08\xf5\x36\x7c\x48\x65\x84\xb4\xcc\xa1\xe5\xbb\x4e\x7c\x71\x3b\x20\xf7\xbc\x77\xca\xf9\x28\xbd\x65\xdd\x4d\xbf\x0a\x4b\xc7\x53\xb8\x3d\xc2\x2a\x5b\x92\x87\x06\x7e\xf1\xce\x09\xd0\xf2\xc2\x07\xaf\xa0\xa3\x29\xb8\x05\x1c\x8a\x17\x3b\xa8\x83\x50\xaf\xd1\xd7\xda\x86\xb8\xc7\x1f\x8d\x44\xcc\x5a\x65\xa5\xdf\x5f\xe7\x52\xba\x1a\xa1\x48\xab\xe3\x30\x4f\x8b\xc7\xed\xa1\x50\x79\x5b\x67\x34\x1a\x32\xd9\xec\x14\x65\xb7\xc3\x79\xdb\xed\x06\x35\xdc\xe2\xdc\x59\xaf\xfb\x27\x32\xf5\x6c\xf1\xb5\xf5\xa6\xec\xce\xbf\xe8\xd4\x7c\xce\x6c\xe1\x34\xf9\xfd\x1d\x97\x65\xf3\x2e\xbc\x04\xc4\x0b\x2f\x77\x75\xdf\x3d\x71\xf1\x20\x61\xde\x4b\xd7\x68\x8b\xe7\xef\x7a\xfc\xe8\x0b\x77\x82\xc9\x4b\x3e\x3c\x7a\xfd\xa1\xa6\xed\x65\xcb\xc7\x5e\x71\x0d\x68\x75\xbf\xba\x6f\xfc\xa2\xd5\xa9\x71\xe3\xb8\x8f\xf9\xc9\x2f\x59\x56\x95\xb8\x3b\xb1\x77\xc7\x86\xc7\x60\x54\xb7\x6e\xf2\xad\x0f\x8e\x9f\x3d\xa5\xa5\x71\xd6\xf8\xdd\xb7\x55\xcc\x1d\x33\x76\x06\xf2\xdd\xfb\xa0\x1c\x7a\xb0\x7f\x5c\x96\x6a\x74\x26\x12\x71\xb7\x9a\x0a\xfb\x62\xb1\xa4\x31\xcc\x30\x46\x63\x03\x72\x92\x6e\x98\x3e\x78\x88\xd2\x92\x92\xd2\x52\xb8\xcb\x97\x9a\x34\x3a\x1d\x8c\xc8\x60\x28\xc6\xc2\x18\xd4\x4a\xe2\x9e\x46\xb2\xe6\xa9\x85\x5a\xa8\x8a\xe7\xb5\xc4\xdb\xbf\xa8\xe4\x9a\xa3\xe8\xff\xab\xae\xaa\x07\xe7\x04\x33\x62\x18\x71\x89\x06\xab\xa3\x9e\xcd\x88\x00\x74\x5d\xaa\xd9\x2a\x49\x0c\x81\xf6\xae\x17\xce\x69\x2d\x49\x25\xad\x95\x95\x15\xca\x84\x4e\xe7\x2a\xf3\xf9\x42\x84\xc7\xe3\x52\x52\x75\xf5\x25\x91\x48\xa0\xbd\x33\xe2\x06\x44\x85\x1a\xda\xb9\x5b\x6d\x51\x5b\x68\xbb\xdd\x88\x72\x2a\x1a\x6a\x0a\x6d\xcf\x49\xd6\xf9\xf2\x9a\x33\x2b\x21\xcd\xae\x9a\x82\x90\x82\x6f\xa9\x99\x0c\xe4\xed\x04\x89\x1c\x37\x00\x84\x0b\x5b\x34\xa3\xa8\xe7\xbe\xfd\x4f\xa8\xf0\x14\xa3\xbe\x6d\xd3\x9c\x5d\x55\xb7\x8c\xfb\xe4\xc1\x13\x5f\xd0\x2f\xde\xa0\x99\x37\x34\xe6\x4d\xb5\x5c\xb5\x4e\xdf\xd7\x0d\x8d\xe1\x86\x83\x61\xf0\xd2\x1f\xfe\x86\x7a\x20\x26\x07\x6c\xbb\x7d\xd6\xb4\x96\x1d\xd7\x7c\xf1\x4e\x5d\x55\xdf\xac\x5a\x77\xb7\xf1\x01\xe3\xaa\x2b\x4b\x87\x90\x3e\xbe\xa5\x33\x94\x41\x80\xeb\xc0\xb9\xac\x95\x70\x10\x63\x53\xa5\x6a\x85\x9e\x34\xab\x34\x1a\x86\x21\x15\x94\xd3\x66\xb7\xbb\x58\xdb\xe4\x4e\x96\x50\x1a\x51\x0f\x5f\x05\x6b\x21\x08\xa3\xb0\x1b\x4a\x45\x09\xe1\x78\x42\x4e\x73\x19\xde\x7b\x5b\xe5\x1e\x1d\x3d\x7c\x05\x16\x42\x37\x7d\xd3\x47\xe9\x23\x6b\x04\xb7\xbd\x22\x98\x0e\xa2\x9d\xaa\xfe\x76\x7a\x40\xc6\x49\x2b\xde\x79\xee\x39\xfe\x4d\x07\xa8\xa7\x47\xe1\x1a\x95\xa2\x5e\x5b\x51\x95\x5d\xe5\x29\x27\x29\xca\x62\xf1\x78\xca\xa4\x9d\x27\xd4\xd6\xe9\xf7\x1b\x75\x76\x92\x64\x18\x68\xa7\x8c\xd4\xbf\x0a\x9d\x94\x96\x3b\x62\xd9\xb7\x11\xfe\xda\x86\x25\x90\x39\x23\x96\xa7\x97\x38\xf4\xb6\xd4\x9b\xc8\x8a\xf7\xa6\x3c\xb4\x0e\xb4\x1e\x7b\xff\xae\x73\xfb\xbb\x36\xc4\x42\x6a\x49\x13\x27\xbd\xa0\x58\x36\x73\xf3\x83\x1d\xd4\xb1\xaf\x6b\xc0\xb0\xdf\xff\xe6\x38\xf7\xd4\xbe\xaa\xca\x83\x65\x5e\x49\x05\x1f\x76\x75\x2f\xde\x0e\x22\x77\x00\x2d\x1f\x33\x35\xc0\xf9\x94\xe1\x7a\xd7\xe0\x94\xaf\xc8\xaf\xd3\x95\xd8\xfd\xfe\x90\xbb\xb8\xd8\xd9\xde\x59\xec\xe6\x0b\x99\x04\x05\xb7\x18\x02\xd5\x37\x12\x59\xef\x77\xcb\x2f\x42\x45\x85\xf6\x1a\xb2\xc8\x19\x7d\xcd\x97\xcd\xa0\x61\x9f\xa5\x34\x34\xa6\xcb\xf5\x6c\x26\x6c\x7e\x3e\xb4\x77\x3b\x29\x0e\x5e\xe9\x55\x99\x96\x6e\xa6\x96\x0b\xe1\xf2\x2d\x87\x9f\x56\x14\xf3\xc3\xb6\x36\xf2\xb9\x75\x07\xdc\x0b\x16\xc3\xf8\xae\x1c\x7d\x95\x22\x28\x2a\x5a\x0c\x25\xae\x33\x99\xd4\x9a\xa8\x26\x56\x11\x28\x56\x97\x1b\x4b\xa0\xfb\x2f\xb1\x17\xeb\xda\x3a\x8b\x59\xd6\xe1\xb0\xb4\x77\x3a\xb2\x74\x43\x38\xbe\x28\x6b\x8c\x9a\xc8\x3a\xcb\x2f\xde\x6a\xc8\xdf\xf6\x33\xb7\x1c\x92\x56\xf0\xa8\x94\x5a\x9b\x3b\x65\xdb\xfd\x2c\x29\xcb\xde\x0c\xc3\xe9\x0d\x38\xbd\x26\x67\x5f\x78\x7e\x96\x7c\xaf\x97\x32\x6d\xf2\x36\x28\xff\x97\xe1\x9c\x26\xc2\x39\x95\x11\x2b\x52\x03\xa2\x66\x27\x65\xb7\xd9\xdd\x56\xbd\xde\xed\x8e\x91\xb6\x50\xc8\x4f\x92\xe5\x0e\x98\x8c\x42\x8d\xf2\x7a\x91\xc6\x2b\xbc\x4e\x0b\xaa\x3d\x7a\x2d\x5e\x0b\xc1\x1a\x4b\x09\x22\x2c\xd7\x7f\xe1\x78\x2a\x3a\xaa\xe3\xcc\xee\xeb\x96\x90\x9d\x54\x15\x8f\xe9\x4b\x6a\x85\x3f\xb5\xa1\xc7\xa9\xa4\x16\x6f\xb4\xfc\x93\xf4\x03\x5f\x5a\x12\xcf\x98\x6e\x5a\xd7\xfd\xd8\xcc\x5d\x8f\x8d\x73\x81\x17\xfa\xae\x70\x53\xd7\x14\x73\xa3\x1f\x3f\xc8\x7d\xfe\xaf\xff\xbe\xda\x48\x2e\xac\x0c\xf9\x60\x88\x7b\x32\x3a\x07\x18\x74\x9b\xd7\x4d\xd8\x39\x73\xc9\xc2\x1e\x30\xf5\xb6\xfb\xb8\xb4\xf6\x99\x3b\x7f\xfb\xe3\xea\xd1\x4e\xdd\x3c\x28\x00\xbc\xa7\x2f\x04\x9f\x52\x65\xf8\x3e\x69\x09\xea\x7c\xe3\xd1\x6b\x28\x8a\x61\xc2\x21\x9b\x2d\xe2\x34\x9f\xa5\xf4\xea\x33\xcc\x37\xbe\xdc\x0b\x3a\x96\xcc\x79\x37\x74\x10\x39\x64\x6d\xb8\xf4\x15\x9d\x13\x8f\xc5\x69\xeb\xba\x95\x46\x05\xb9\x4a\x45\x53\x35\xcb\x27\x5d\xb5\x7a\xf2\x7f\x14\xcd\x58\xdd\xdc\x39\x76\x6a\x77\x23\xf8\xf4\xd6\x8d\xe4\x9c\x49\x0d\x36\x4d\x3b\x8b\x2e\xe8\xdc\xcd\xfd\xb8\x85\x7c\x71\xe9\xef\x66\xcf\x9c\xb3\xf4\xf4\x94\x03\xbc\xbe\x6d\x06\x7f\x20\xff\x4d\xff\x00\x73\xa0\xf2\x94\xd5\xa1\x52\x51\x2e\xa3\x91\xbf\x80\x75\x16\x5d\xc0\xfa\x36\xfb\x02\x96\x74\x7b\x94\x6f\xda\x26\x5c\x01\xcb\xf4\xe8\x01\x77\xed\x6c\x5a\xd2\xfe\xc5\x0d\xb7\xce\x78\x7c\xe3\x8a\xed\xea\x75\xcc\xb0\x61\x1d\x8b\x07\x92\x43\xf6\x86\x4e\x3d\x74\xf3\x96\x1f\x37\x5e\xbb\xd4\xdc\x32\x71\xf6\x3b\x4b\x7f\x8d\x65\x34\x0c\x3c\x4d\x51\x50\x46\x41\xa2\x92\x18\x9f\x2a\x25\x19\xa7\x3a\xa6\x54\xaa\x19\xaa\x2a\xe2\xf7\x9b\x4d\xa6\x78\x69\x51\x4c\x49\xd2\xc5\xc5\x84\x4d\x3f\xd1\x0c\xcc\x66\xfd\xd9\x10\xbe\x93\xf1\x16\x8a\x00\xba\xf0\xed\x56\x47\xa6\x3f\x80\xec\xa8\x16\x14\x1f\xea\x90\x97\xcc\x1f\xa1\x58\x48\x53\x44\x6b\x85\x1a\x93\x17\x80\xe7\xd6\xb4\x0d\x37\x4f\xac\x6f\x88\xcc\x7c\xf2\xfa\x15\x37\xd3\xd7\x31\xa3\x5a\x3a\x60\x0c\x30\xa9\xa7\xa5\x6d\xc6\x7d\x9b\x27\xcd\x1e\x37\x68\x79\x83\x75\x04\xf8\xc3\xe0\xa9\xee\x21\xc3\x07\xb6\x5c\xbd\xf2\xfb\xeb\x37\x2c\xb0\x0c\x1b\x3b\xeb\x83\xe9\x25\x9e\xd1\x83\x27\x8e\xbc\x72\xdd\xec\xa1\x0d\xcd\xa3\x9b\x9c\x1e\xfe\x2e\xdd\x17\x94\x41\x41\x10\x5e\xa2\x82\x98\x99\xaa\x74\x95\x97\x2b\xc8\x62\x15\xdc\xd6\x8b\x29\x6d\xc8\xa2\xb5\x54\x55\xfa\xa0\x4f\x55\x16\x17\x33\x84\xc2\xeb\x32\xda\xbd\x76\x2f\x19\x31\x7e\xab\x54\x9c\x26\x4f\x8b\x97\x91\xa0\x8a\x5b\xf8\xd3\x7f\x42\xb5\x45\xe8\xc4\xcc\xcf\x51\x78\x0c\x3f\x12\x4d\xd8\x1d\x49\x23\x56\x66\x52\xbe\x20\x55\x20\xaa\x4c\x5a\xb3\x3a\xa0\x80\x33\xb5\x93\xaf\xab\x1c\x7c\x58\x7f\xcd\xf8\x91\x9d\x7b\x6f\xbc\xe9\x81\x69\x7b\xae\x4d\xcc\x2d\xd6\x0d\x2c\x7f\xc9\xb0\xb4\x6d\x71\xb2\x63\x62\xe7\xd2\xfa\x79\xcc\xdd\xb5\x83\x9c\xd5\xad\xe3\xe2\x5d\xbf\xb9\xee\x9e\x7e\x62\xdd\xee\xed\x2b\xdf\x98\x17\x29\x19\xb7\xb3\x66\xe2\x14\xee\x8b\x71\x4f\x4f\x98\x79\xc5\xdc\xa3\x13\x9a\xf1\xdb\x3f\xc4\x68\xa8\x3b\x69\xa8\x3b\x25\x30\x5b\xa9\x53\x05\x83\x5e\x2d\x4b\xd2\xe2\x9d\x5e\xa3\xce\xa7\x8b\xeb\x28\xad\x4e\x47\x38\x8d\x36\x9f\x8d\x34\x51\x36\x9b\xd3\x69\x39\xd5\xe9\x3c\xcb\xcc\xa5\x80\x78\xcb\xb7\xab\x36\x93\xd8\xa1\x30\x66\xb6\xd4\x9f\x4c\xea\x5e\xf2\xbf\xba\xe7\x3b\xed\x74\xc9\x35\x9e\x1d\xe3\xa6\x2c\xbb\xc2\xba\x65\xe5\xf0\xc6\xeb\xbd\x2b\x3d\xdb\x56\x5f\xbd\x75\xcd\x74\x7c\xcf\x37\xed\x5b\x3d\x7a\xc4\xa8\x41\xb3\x47\x0c\x47\xf7\x7c\x67\xcd\x58\xd4\x36\x69\x99\x8a\x52\xce\x13\xee\xf9\x02\x62\x17\x38\x4d\x76\xe3\x3b\x36\x75\x29\x17\x49\xa3\xa7\xe7\x58\x1d\x61\xb5\xda\x09\x9a\xb6\xc0\x9d\xd9\xa0\xd3\x9c\xe6\xfb\x9b\xf0\x8d\xc9\xcc\x62\xa7\xaa\x4c\x9f\x93\xcc\x37\x8e\xa8\xf0\x89\xe3\xb6\x4d\x1b\x36\x2d\x32\x5f\x69\x64\xaf\x9c\x95\x08\x5a\x9a\xeb\xca\xd5\xba\x3b\x2d\xf4\xf6\xbe\x2b\xc8\x87\xbb\xa6\x5d\x35\x5d\xd5\xad\x18\x98\x1c\xc5\xf7\xb7\xfc\x07\xf1\x21\x38\x4e\x9f\x22\x58\xc4\x9f\xb0\xda\x28\x1d\xba\x96\xeb\xd0\xd9\x15\x36\x1b\xc5\xb2\xc0\xa8\xd3\x7c\x07\xce\xe4\xf1\xe7\x47\xc0\xf7\x00\x42\x9f\xd2\xa5\x82\x03\xfa\x26\x91\xfc\xba\x63\x43\xc7\x22\xd3\xa2\x6a\xdb\xe2\x19\x8d\x6e\x73\xc0\x5a\x53\xa3\xad\xbc\xc3\x44\x72\xe0\x6b\xae\x68\x16\x77\x7e\xc9\x0c\x38\x82\xba\xe6\xbe\x59\xfd\xfd\xc4\x04\xe2\x28\xd5\x49\x9f\x37\x29\x98\xab\x6c\x48\x1e\x0f\x82\xd3\xd4\x18\x28\x0f\x27\x51\x85\x7a\xd7\xeb\x15\x4e\xbb\x82\x72\xd9\x6c\x45\x14\x61\x34\xaa\xed\xdf\x58\xd5\xa7\xf1\xe9\x49\xd4\x95\x24\xfb\xe2\x9c\xb4\x83\x24\x64\x9b\x4d\xc8\x9a\x24\xbb\x1a\x57\x4e\x5c\xb0\xc0\xd0\xb1\x61\xaa\x6e\x5d\xc7\x56\xfb\xa4\x75\x6f\xae\x4f\xf8\xa9\x1d\x6d\xa9\x45\xdd\xa5\xe3\x40\x2f\xd7\x34\xa4\xf4\xda\xed\xab\xc1\xb3\xff\x3e\x0d\x4c\xb7\x23\x3b\x8a\x81\xd3\x60\x33\x1c\x83\x96\x30\xa2\x2f\x14\x0a\x15\x0c\x92\x94\x04\x49\x03\x92\x32\xe9\x0c\x06\xb3\xce\xa8\xf7\xe9\xe3\xfa\x39\x7a\x5a\x7f\x5a\x43\x92\x4a\xe8\x61\xcf\xa0\xf6\x48\x2d\xbc\x80\x5a\xba\x64\x05\x24\x31\x46\x72\x03\xf4\xfc\x02\x2f\x2c\x74\x8b\x76\xc8\x80\x36\xf3\xa4\x61\xeb\x87\xb5\x5b\xda\x07\x24\x1c\xeb\x1d\x90\x65\x63\x17\x58\xc0\x3d\xd8\xc5\x1d\xa7\x1e\x5e\xb7\x0e\xc9\x62\x08\xfc\xcb\x31\x70\x6d\x70\x0f\x2f\x18\x09\xd1\x04\x00\x0c\xf5\x0d\x71\x26\xa7\x87\x17\x9c\xe6\x87\xeb\xef\x58\x4f\x9f\xea\x53\x10\xff\x17\x3c\x34\xef\x4e\x88\x87\x7a\xc0\x39\x00\x4d\x6a\xe0\xcc\xf5\x70\xe2\xa4\xae\xc0\x2c\x33\xf7\x44\xc4\x6b\x22\x99\x09\xca\x27\x27\x9f\x18\x1c\x91\x85\x38\x4a\x2e\x65\xfa\xa1\x64\x9d\x84\x87\x18\x99\x8a\x3a\x28\xb5\x56\x8b\x9a\xcf\x50\x74\xb1\xcb\xed\x86\x7e\xa9\xc8\x57\x14\x2f\x9a\x53\x44\x17\x9d\xd6\xdb\x6c\x1a\x85\x42\x75\xc6\xc4\x5f\x50\x2e\x20\x5e\x5e\xb8\x49\x1c\x03\x0d\x04\xc2\x37\x7a\xe4\x63\x93\x38\xbb\x42\x5f\xc3\x8e\x4d\x98\xbb\xed\x9a\xf8\xd6\x0d\x37\xce\xb6\x76\xd1\x15\x07\x23\x55\x96\xe2\xd4\x08\xd0\x61\xdf\xe0\x38\xda\x31\x61\xf6\x52\xf2\xa5\xbe\x51\xf3\x1c\x3f\xcc\x1f\x7e\x45\x63\xd5\x10\x7a\x3e\x92\x3c\xee\x1d\x40\xbc\x06\xd6\x40\xb1\x18\x51\x97\x2a\x52\xa7\x53\x98\x8c\x84\xd9\x78\x5a\x49\xab\xbf\x23\x84\x4e\x5f\xb5\xe6\x26\xf1\x3a\x79\x56\x30\x09\xd6\x9c\xa4\x86\x94\xfb\x6c\xa5\x89\x21\x53\x15\x1f\x2b\x88\x7f\xdf\x13\x1a\xaa\x5e\xae\x9e\x30\xd1\x1d\xa2\x17\x22\x9b\x7b\x1c\xd2\xde\x04\x69\x9b\xa0\x8e\xb3\x84\xc1\xa0\x34\xe9\x01\xb0\x28\xcd\x06\x82\x60\x8c\xa7\x35\x4a\xe6\x3b\xe1\x16\x79\x3c\x63\x6c\xc2\x8a\x29\xb3\x8a\xdd\x89\xf7\x07\x45\xd8\xa5\x73\x6b\xaa\xd8\x50\x79\xbb\xcd\x38\xe8\xcd\xf5\xe4\xb4\xe3\x57\x5d\x61\x5a\x65\xba\x72\x12\x6d\xc7\xf3\x58\x08\xfd\xcb\x54\xb8\xa6\x7c\xef\x33\x9a\x86\x9a\xa0\x50\x92\x67\x68\xfe\x16\xa3\xbc\x57\x38\x7e\xb5\x8f\x1c\xca\x95\xdc\xbe\x6e\x03\xb8\x02\xa2\xfd\xdc\xb7\x9c\x97\x85\x8b\x38\x4a\x8f\xa1\xcf\xc3\x3c\x7a\x78\x2a\xa4\xd1\x46\x9c\x4e\x74\xff\xdd\xac\xa5\x93\x71\xaf\xb7\xb1\x2c\x52\xf2\x5d\xad\xfb\xac\x82\x3d\xeb\x34\x6b\xf5\x67\xf8\x3b\xf0\xe2\x15\xf8\xac\x96\x64\xe2\x26\x99\x7d\x0b\xbe\xc0\xb7\xa6\x8c\x37\x49\xca\xee\xc4\xbf\x31\xc5\x9c\x18\x38\xe1\x1a\x7b\xdb\xfa\x95\xee\x6b\x0c\x0c\xd9\x30\x6f\xd8\xe4\xb9\x9a\x86\x15\x23\x67\x5d\x61\x5c\x68\x9b\xdb\x16\xab\x34\x39\xfd\x65\x51\xfd\x3c\x08\x36\x71\x95\xbd\x0d\x5d\x90\x1f\x53\x8d\x6e\x7b\xe2\x0b\xf2\xaa\x39\x9e\x29\x83\xa6\xb4\xcd\x18\xb3\xa8\xdb\x37\xad\xef\x7f\xae\x9e\x8b\xee\xa6\x0f\x21\xb5\xd3\x83\x10\x64\x85\x78\x57\xbe\x99\x78\x95\x5e\x0e\xe5\x55\x86\xee\xaf\x1a\x2d\x16\x6d\x11\xdc\x2e\xcb\xa2\x8c\x96\x2e\x0f\x87\x63\xd1\xbf\x12\x8c\xaa\xc4\x65\x38\xc3\xaa\xbe\xf5\x53\x62\x3b\x9a\x84\x45\xe8\xc1\x92\x7d\x7f\x55\x38\x7a\x98\x7f\x5b\x35\xeb\x47\x28\x02\x6a\x4b\xfd\xfc\xa1\x4f\xdb\xea\x57\x8c\x9a\x75\x05\xdd\xbd\x6e\x8a\x30\xfe\x75\xd2\x7c\x8f\xaf\x6f\xf4\x92\x4b\x27\x0f\xda\xd7\x09\x07\x6f\x8e\x92\x2a\x6e\x48\x97\xb7\x1e\x8e\x1a\x3c\x27\xfc\xb4\x0a\x3c\xf3\xef\x4f\x40\xec\x06\xec\xd3\x67\x41\x1b\x7b\x0d\xf7\x2b\x80\x11\xa0\xd7\x6d\x08\xc3\xe5\x0a\x87\xcb\x0d\x65\x4c\xf0\xac\xb7\xe8\x8c\xd9\xa0\xfb\x8e\xe0\xb7\x94\x96\xcc\x15\x6d\xa9\x88\x29\x7d\x03\x93\xaf\x42\x33\x55\x9f\xfd\x39\x0c\x7c\xd1\xa1\x5b\x3f\x75\xab\xa3\x9b\x9d\x3b\x51\x14\xfc\x66\x5a\xad\x62\x56\xc3\x95\x69\xba\x66\xdc\xfc\x85\x86\x69\x70\x01\xde\x1a\x16\xbd\x76\xc7\x35\x7d\x3f\x2d\x9f\xcd\x4b\xfb\x31\x67\x7d\x3c\xc8\xc0\xa5\x40\x6d\x00\x62\xa3\xb9\x3a\x24\x73\x33\x1c\xef\x87\xb8\xcf\x48\x32\xe5\x21\x34\x1a\x4f\x31\x65\xa4\x4b\x4a\xca\xec\xa5\xe6\xc0\x59\xf7\x99\x62\x7b\xd1\x19\xfb\x37\x0c\xa9\xe4\xcd\x02\x7d\x12\x92\x46\x9d\x10\xb6\xc1\x2c\x03\xcc\x7c\xc4\x6b\x26\xeb\xe5\x0d\x0b\xc8\xd6\x96\x48\xc8\x56\x53\x0e\xed\x72\x21\x1e\x7d\xdb\xfa\x15\x94\xd2\xbc\xda\x4a\x36\xad\x9c\x30\x7f\xa1\x71\x21\x58\x3e\x54\xb3\x02\x5a\x6a\x71\x80\x74\xe0\x91\xa3\x9e\x05\xa6\xd0\x72\x80\xdb\x16\x44\x26\xa0\x8e\x82\x80\x40\x4d\x34\xed\x50\x47\x8c\xa8\x0b\x9b\xde\x60\x30\x31\x0a\x85\x59\xcb\x18\xcf\xa8\x28\x43\x76\x23\x3e\x7e\x70\xe8\x6a\x30\x5a\x69\xa1\x17\x20\x68\xfe\xd2\xa1\xd2\xcc\xba\xe6\x8e\x45\xa7\x3c\x6a\x65\xf7\x35\x77\xd0\xa7\x38\x77\x95\x7b\x24\xf8\xa6\x4f\x01\xce\xb5\xb8\x1b\xfb\xce\x91\x3f\xa3\xde\x49\x5b\x70\x6f\x84\xbf\xe3\xde\x6b\x5e\xa2\x39\x15\x34\x78\xbd\x1e\x93\x49\xa9\x24\x7c\x84\xdf\x38\xc7\xb3\xd9\x73\x87\x87\xf2\xa0\x36\x2c\x1e\x0f\xed\xd2\x9e\xb5\xd2\x52\xdb\xba\x58\x97\xac\x81\x4d\x6d\x7e\xf7\x04\x2a\xa0\x14\x4a\xce\x58\x54\x81\x24\x55\xd5\xb5\x7f\xeb\xb6\x07\xbb\x0e\xae\xbf\xeb\xde\xdb\xb9\x79\x54\xc7\x94\x31\x5d\xc3\xdd\x4f\x2d\x5c\xed\x01\x0f\x03\xaa\x77\xd3\x0f\x9b\x1e\xbb\x7b\xeb\xe9\x35\x0f\x72\xe7\x92\x57\x5e\x3d\x70\xcb\xc9\x77\xd6\xaf\xb3\xa2\x31\x6e\x25\x5e\xa3\xe2\xd0\x97\x59\x89\x22\xe8\x33\x47\xa4\x4a\xd4\xc0\xe1\xd5\xd2\x1a\x2b\xe1\xa6\x69\x42\x43\x05\x6d\x06\x43\xc8\xfa\x5d\xb1\xc3\x01\x2c\xdf\xaa\x4f\xdb\xbd\x5e\xad\x0a\x77\x57\x80\x8e\x9c\xff\x5d\xee\xcc\xd1\xd9\xbd\x9a\xea\xb0\x95\xef\xd6\x8c\x84\xc6\x37\xd9\x83\xfa\x56\x17\xa5\x9a\x49\xc6\xe6\xb0\x1a\x48\xe0\x4d\xce\x5b\xd9\xb1\xf7\xea\xc4\xf2\xba\xa5\x57\x4f\xde\xbd\xae\x01\x84\x96\x2d\x1f\x33\xab\x9e\x6b\x5b\xb4\x7c\x58\x57\xc3\x6b\x20\xc2\x3e\xb8\x71\xc3\xa9\x75\x4a\x60\xe4\xce\xd8\xee\xb9\x6e\xed\x99\x1b\x55\xdc\x1f\x29\xfd\xee\x60\xdf\xf3\xea\xab\xdf\x5e\xf2\x44\x98\x9c\xa8\x5d\xf8\x12\xb6\x77\x07\xd4\xbd\x53\xf4\xf7\x44\x1d\x1c\x7b\xb0\x2a\x54\xea\x86\xdb\x7e\x88\x6a\x50\x9a\xcd\xf5\xee\x2a\x2a\x16\x29\x2b\x8b\x9c\xd5\xa9\x0d\xdf\xd9\x58\xd6\xc9\x60\x8b\x47\x4d\x03\xf0\x1a\xc7\xcd\x89\xac\xc6\x22\x09\xb1\x9d\x2d\x4c\x02\xe4\xe5\x85\x06\x6b\xde\x97\x3d\xa1\x10\xcc\x7f\xd8\x03\xe4\x0b\xcf\x3e\x7c\xfd\xa8\xa2\x91\xfe\x12\xd6\x5f\x3a\x61\x0a\x59\x3b\xdf\x36\xb3\xa3\x7b\x81\xbf\x79\xfa\x8c\x29\x55\x0f\xdd\x75\xce\xbf\xdc\x73\xeb\xe4\x59\x81\xe6\x29\xeb\x16\x91\x27\x56\x5d\x5f\x73\x8f\x71\x80\x6a\x95\x6a\x7c\xab\x86\x05\x6c\xb4\xb1\x79\x64\xca\x5b\x11\x2a\xf6\x25\xc7\xd6\x2e\x5c\x9e\x36\x2f\x6e\x4c\xf8\x62\x01\x77\x78\x09\x5f\x83\xb8\x8f\x78\x8d\x5c\x8e\x7b\x34\xc1\x58\x40\xef\x20\xed\x26\xbd\xf6\x34\x43\x8a\xdd\x62\x78\x3d\xad\xa9\x8e\x4a\x96\x6e\x91\xd5\x18\x54\xf5\x95\x6c\x45\x71\x7d\xb3\xe9\xfe\x78\x6f\x43\x95\x3d\x5a\xb2\xd0\xff\x80\x6b\xcd\x6b\xc6\xe5\xe6\xf1\xd3\xa8\x38\x00\xa6\xd5\xec\x63\x17\x7a\x6f\xbc\x16\xca\xf1\x0a\x28\x47\x1d\x73\x07\xd4\xcc\x96\x94\xd7\xab\x52\xb9\x5c\x5a\xab\xd9\x4c\x69\xb5\xac\x9f\x0d\xa0\xef\x6d\x16\xd3\x19\xb7\xea\xdb\x0c\x67\xd4\x7d\xc1\x9c\xc8\xb4\xa9\x91\x6d\xe6\xc2\x50\x78\xd9\x65\x8e\x6b\x0a\xbb\xec\x0b\xe5\x25\x36\xaf\xa3\xaa\xc2\xd0\x34\x4c\x35\x7d\xaa\xa5\x63\x54\xbb\x7f\x87\x65\xc7\x54\xd5\x60\x4f\xa9\xd7\x7d\xd4\xb8\xcc\xd0\xba\x78\xd4\x20\x47\x13\xf8\x64\xd6\xb3\xcf\xce\xe2\x9a\x86\x35\x6b\x3e\x78\x95\xff\x4e\x64\x04\x9f\x92\x1c\xb4\x5b\x0f\xbe\x8d\x10\x07\x4e\x68\x57\x1e\x4f\x89\xcb\x6e\xb4\xd3\x11\x32\x10\x50\xa9\x60\xf8\x4d\x47\x83\x70\xf0\x0c\x30\x15\xa1\xeb\xa9\x45\x45\x3a\xca\x73\xa6\xd8\xfa\xad\x4e\x6a\xd7\x10\x8f\x35\xe5\xf6\x07\x16\x0f\x7c\x64\x9c\xa8\x78\x5e\xd0\x48\x66\x55\x37\xe0\x64\xdc\x00\x59\x1d\x3a\x51\x07\x82\xcd\xa0\xa3\x79\x43\xf3\x68\xf3\x98\x80\x59\x83\x76\xb4\xc6\x95\x6d\xf3\x17\xda\x47\x9b\x47\x37\xdf\x33\x60\xd1\x70\x0d\xf7\x8c\x15\xba\x86\x23\xa0\x95\x3b\x32\xfb\xd0\xfc\x66\xf5\xcc\xe2\xb6\xd4\x95\xdd\xbe\x0d\xb3\x41\x6b\x5f\xe7\xb0\x0d\xc3\xae\x0c\x5d\x8b\x75\x78\x09\xf4\x13\x4b\xe0\xbc\xaa\x89\x81\x29\x4f\x99\xdf\xef\xf1\x54\x99\xb4\x2a\x15\xcb\x52\x54\x4d\x49\x55\x55\x6d\x24\x74\x46\xab\x3b\xe3\x14\x3b\x71\xc9\x73\x7e\xd9\x41\x31\xbe\xf5\x05\xca\xd9\xf0\x8b\x8b\x38\xc7\xc9\x1c\x16\x8e\xf2\x11\x16\xdf\xf5\xdd\x4b\xa2\xcc\xe7\xa1\xdb\x1f\x9b\x31\xc0\x57\xd3\x68\x99\x50\x37\x2c\x5a\xda\x36\xb7\x63\xe4\x35\x43\xed\xf6\x59\x63\xdb\x2d\x8d\xa1\xa0\xd5\x69\xfd\x10\xfc\xe1\xee\x0d\x1b\xaf\x1a\x59\x69\x2b\x9d\x37\xac\x2e\xde\x51\xd3\xbd\x60\xe2\xbc\x31\xdb\x46\x97\x8d\x6a\x8d\x4e\xe9\x9c\x57\xea\x76\xc6\x1b\x47\x56\x3e\x7d\x9c\xe0\x7d\xea\xe7\x30\x2a\x39\x05\xfd\x08\xf4\xa9\x0a\xb5\x9a\x24\x6d\x46\x93\x89\x35\x32\x67\x74\xb9\x7d\x41\xf1\x60\xfd\xf2\x0b\xaf\x42\x3f\xc6\x41\x30\xac\x9c\xb2\xb1\x4b\x3d\x7a\xf8\x33\x91\xae\x0d\xb3\x8a\x1f\x05\x9f\x7f\x30\x60\x2c\x38\xc4\x85\x2a\x4b\x13\x03\xdf\x00\x9f\x71\xd1\x07\xee\x81\xbc\x60\x46\x4d\xfe\x06\xf2\x72\xa0\xda\x03\xdc\x1b\x6d\x36\xbd\x53\x03\x43\x5d\xbd\x4b\xe3\x38\xc3\x98\xbf\xcd\xf4\x77\x30\xcb\xba\x6c\x09\x59\x05\x14\x45\xc2\x2e\xa5\xbd\x30\xda\x73\xb5\x6b\x76\xae\xdb\xe6\xe8\xb1\xcf\x3e\xb8\x7e\xf5\x8d\xda\x09\x70\xc9\xc6\xd6\x96\xdd\xf7\x8f\x3f\x5f\x39\x6f\xee\xa2\x67\xb9\x7f\xdf\xb5\x75\x43\x43\x3d\xd8\x8d\xce\x14\xc0\xa0\xea\x2d\xc8\x57\xe8\x29\x41\x2a\xb4\x2a\xb5\x5a\x43\xa9\xbf\x51\xa0\xd0\x3c\xb7\xaf\x6e\xc2\x8a\x37\x0c\x10\x02\x87\x84\x9e\x12\xdc\x0f\x37\xa3\x58\x1d\x7c\x3f\x7a\xf6\x13\x9c\x91\x10\x63\x76\xf2\x13\x4c\xb3\x3a\x65\x57\x91\x24\x05\x77\x07\x82\xd1\x30\x5a\x05\x8c\xfb\xcf\x00\xf8\x6f\xa8\x6f\x2b\xee\x11\x90\xbb\x23\x58\xc5\x6f\xaf\xca\x98\x09\xfc\x93\xeb\x31\x93\xac\x99\x53\x81\x27\xcc\xe0\xf4\x5c\xb2\x71\xde\xdc\xbe\xe3\xf3\x78\x1e\x68\x7f\x3e\x83\xe5\x35\x38\x55\x6c\x82\xd2\x62\x09\x8d\x5e\xe3\x34\xd2\x16\x8b\xcb\x6a\x32\x99\xcf\x18\xe0\xdf\x65\x36\xe8\x44\x86\x5b\x22\x21\x7f\xd6\x22\x6b\x97\x96\xbe\xfc\x2a\x15\xe4\xdc\xfa\x80\xd7\x5e\xe3\x1d\x38\xc1\xc1\xd9\x2c\xa4\x97\x5b\x64\x25\xab\x2d\x7d\x5f\x82\xf7\x03\x0a\x70\x65\xa3\x6a\xa5\xba\x75\x6c\xf1\xf5\x68\x4c\xdd\x7d\x27\x0e\x17\x0b\x3d\x2d\xaf\xa2\xa0\x75\xe0\xb3\xbf\xa3\x53\x25\x76\xa3\x45\x5f\x64\x50\x78\xbd\x06\xbd\x91\x0e\x98\x6d\xb6\x20\x6b\xb1\x58\x1d\x14\x65\xb4\x9e\x29\x32\xd9\xed\x3a\x0d\xea\x36\x92\x78\x13\x0d\xa9\x45\x68\x54\x9a\x93\x46\xe0\x11\x8a\xd9\x7d\x0c\xa0\xd6\x6e\xe2\xbb\x0c\x61\xb8\x45\xf2\x85\x00\x30\x76\xd1\x0d\x43\x46\x4c\x5e\xb9\xf6\xb9\x6a\x7f\x47\xfd\x87\xf2\xc1\xde\x52\x31\xb5\x72\x49\xc3\x28\x2f\x39\x6e\x7b\xf7\xc4\x21\xb3\x67\x0d\x6f\x8a\xb5\x77\x93\x49\x24\xc7\x2d\xa3\x1b\xc3\xe5\x0e\x37\x92\xa5\x8a\x78\x95\xd2\xc2\x71\x17\x11\xa9\x94\x4f\xaf\x2b\xa2\x1c\x0a\xab\xd5\xa1\xa3\xdc\x2e\x00\x3c\x0e\xca\xe9\x34\xc2\xa4\x57\xf3\x57\xb2\xa8\x08\xeb\x84\x99\xdf\x67\x70\xe6\x93\x7b\x28\xc1\x2a\x94\x13\x51\x0f\x5a\xbe\xb7\xbd\x54\x69\xfc\x3d\x59\xe3\xe0\x3e\x5a\x70\x5d\xf7\xf3\xab\x39\xce\xb1\x86\xdd\x35\x6e\xcd\x90\xc5\x33\xa1\xb2\x36\x71\x13\xe9\x53\x9b\xa0\x9d\xdc\xb7\xe2\xea\xd7\x16\xfd\xce\xd8\xd3\x7e\xef\xe8\x8e\xf9\x0b\x80\x09\xed\xe5\x8f\x40\x3f\x92\xc2\xbd\x31\x6c\x44\x31\x31\x28\x15\x34\xb9\xdd\x4e\xab\x15\x1a\xa3\x97\xf4\x99\x5b\x9c\x13\x9d\x9b\x9d\x77\x38\x5f\x73\x7e\xe0\x54\x38\x9d\x7a\x85\xd4\xf1\x43\xea\x53\x2d\x8b\x36\x6a\xcd\xa2\x89\x58\x1a\x28\xe1\x08\xb1\x74\x2e\x9c\x6c\xfd\xe7\x92\x23\xb7\x5e\xbb\xe9\xea\x5f\x55\xcc\xeb\x29\xe7\x6e\xb4\x80\xaa\x79\x9b\xca\xc1\x46\x6b\x8b\x82\xe0\x5e\x7b\x94\xdb\xf0\xda\x0b\xbb\xf7\x82\xf5\xbf\xba\x30\xe0\x68\xef\xca\xb1\xef\x53\x4b\x7f\x7d\x7c\xe5\xf8\x05\xdd\xe8\x0c\xbc\x9d\x7e\x1d\xfc\xac\x28\x83\xf9\x8c\x1a\xbd\xfd\x9c\x42\xb9\x23\xa1\x4a\xa9\xd5\x54\x0f\x41\xa0\x67\x2b\xe0\xff\xcd\x89\xf8\x7b\x50\x3c\x14\xcc\x47\x95\xe8\x3c\x10\x03\x37\x90\x3b\xef\x56\x1c\xf5\x2b\xa7\x97\xec\x2b\xe9\x4b\x85\x1e\x0f\x41\x2a\x43\xc3\xdc\xcb\x81\x03\x47\x8e\xec\x3f\x72\x84\xa0\xb8\xd3\xf4\xeb\x64\x34\x87\x2e\x83\xe8\x92\x3d\x4c\x36\x5d\x0a\xdd\xae\x07\xe1\x24\x4f\x37\xaa\x7c\xf8\xa8\x92\x3b\x07\x06\x43\xca\x17\xfe\x82\x29\x07\xc0\xc8\x30\x77\x54\xa0\x8c\xf6\xe0\xeb\xb8\x09\xc4\x15\xfd\xcf\x10\x15\x84\x2d\xa5\x2e\x53\xfa\xcc\x34\x71\xcc\xea\x24\xe2\x89\xa2\x5e\xb1\x56\xdc\x4c\x26\xeb\x50\x68\x80\x3e\x02\xe3\xf6\xa1\xa8\x25\x98\x81\x54\x62\x57\x8b\xfe\xb4\x3b\xbc\x4f\x84\x2b\x22\xa4\xb7\xc4\x5b\x5a\x53\x5a\x59\x56\x0f\x86\x0e\x9c\x5d\x52\x11\x01\x2e\x9f\xcb\x1f\x0d\x82\xaa\x08\x37\xa1\xc9\x6a\x37\x6a\x94\x6a\x95\xda\x60\x34\x3b\xad\x66\x8d\xd1\x56\x1d\xa8\x73\x07\x58\x83\x4a\xa1\xd2\x9a\x8d\x16\x56\x0f\xff\xab\x81\xc4\x63\x1a\x42\xff\x09\xfc\x8b\xf9\x1d\xb4\x1f\xcb\x8b\x80\x65\x75\x3d\x26\x05\x1e\x50\x6d\x1c\x7f\xb5\x0a\x0a\xe7\x4a\xe1\x0c\xf1\x0e\x40\x0e\x04\xe0\x8f\xc1\xc6\x45\x57\x2e\x4f\x75\x2d\x65\x36\x53\xb1\xa6\xba\x79\x0b\x57\x0e\x0b\x31\x33\xc2\x95\xe1\x05\x1d\x45\xc5\xfe\x92\x41\xa5\xd5\xa5\x7c\xcc\x51\x4b\x7f\x0c\xd2\xcc\xc7\x50\x96\xba\xc3\x4c\x0f\x45\x62\xc2\x90\x2a\x03\x8d\x29\x0c\xd2\xdc\xc7\xdc\x33\x2e\xd0\x04\x18\xe6\xca\x5d\x3d\x3d\x10\xbe\x0b\xc2\x1f\x15\xe0\x69\xaa\x07\x20\x79\xe3\x8c\x34\x9a\x74\x04\xc0\xe3\xdc\xd3\x7f\x9b\xfa\x11\x18\x40\x7f\xbc\x6b\x59\x0f\xa6\x3f\x16\xc2\x3f\x27\xc0\x93\x34\xbf\xee\xe8\x9d\xb8\x28\xa4\xef\x00\xd3\x7e\xcb\xbd\xed\x02\x1d\xe7\xe9\x8f\x7b\x7a\x76\x61\xf8\xa9\x10\xfe\xbf\x05\x78\xc0\xf4\xc0\xf1\xc0\x79\x22\xfa\x4c\x34\x1c\x00\x47\xb9\xb7\xb8\x0b\x31\x10\x03\xd3\x98\x29\x3d\xcb\x76\x11\x80\x3b\x43\x7f\x4c\x06\xa0\x6c\x94\x84\x2b\xa5\x21\x95\x4a\x06\xf4\x40\x6f\x0a\x50\x8b\x8a\x44\x91\x49\x10\x91\x32\xca\x84\x93\x8e\x30\x19\x68\x3f\xce\xfd\x9d\xfb\x5b\xfb\x47\x80\x66\x86\x5c\xb5\x7e\xfd\xae\xab\xd0\x9c\xb8\x3f\x41\x1a\x65\x98\x86\xe5\x45\x05\xa0\x7b\x60\xe0\x43\xc4\xdf\x4c\x14\x7d\x56\xfb\x26\x5c\xf1\x28\xe4\xec\x48\x3a\xfe\xf8\x11\x77\xa1\x14\xb4\x7e\xfe\xcf\x52\x34\xd8\xab\x76\xad\x5f\x7f\x15\x1a\x6f\x92\x9b\x46\x5c\xd7\xff\x0e\x61\x22\x6c\xbf\xa2\x4d\x2a\x0d\x74\xeb\x2a\xc4\xdc\x9c\x30\xf5\x42\x7d\xa1\xc4\x2e\x6c\xe2\xa1\xe6\x13\x49\xfd\x14\x2d\xe9\x1b\x5c\x5b\x62\x31\x79\x07\x0d\xd3\x7a\xb9\x69\xc0\x39\x65\x4c\x3c\x48\xcd\xa0\x47\x25\x1f\xc2\x32\xf8\x1b\xbd\x11\x34\x29\x02\x84\x02\xc9\x8c\x38\x46\x23\x19\xa0\x40\xc5\x08\x1c\xd0\xd1\x81\x26\xfb\xaf\x7f\x61\xff\x87\x51\x11\x58\x35\x77\xee\xaa\xa7\xf1\xfb\x5f\x24\xf7\x2c\xd7\x01\x0e\xf7\xff\x0c\x71\xf4\x48\x12\x5a\x55\x4a\xa7\x56\xd3\x64\x8f\x02\x23\x27\x70\x7b\x81\x9a\x6a\x23\x60\x5a\x40\x14\xbd\x9f\x98\x70\x24\x13\x3a\x23\xf7\x96\xfd\xd5\xff\xb0\x83\xff\x69\xbf\x66\x55\xcb\x96\x55\x07\xda\x9f\x46\x24\xb9\xc7\x81\xeb\x99\x67\xfa\xfb\xfb\x1f\xe4\xa6\xd1\xdf\x30\x5b\x2c\x11\xa2\x84\x20\xcc\x4a\xf2\x2f\xf8\x8d\x13\xfd\xaf\x28\x52\x67\x33\xd0\xca\x30\x88\xd5\xd7\xa3\xbb\x2f\x55\xf8\x9e\xd4\x04\x08\x37\x5c\x80\x43\xdf\x37\x4c\x2f\x50\xe4\x91\xfe\x4f\xd3\xcd\x8d\xda\x28\x0f\x8a\x60\x5b\xe0\x8e\x67\x52\x3c\x01\x61\xc3\x18\xf6\x41\x30\x9f\xf8\x3d\x61\x4d\x69\xa9\x00\x13\xa1\x36\x7a\xfd\x7a\x1a\x01\x13\xf0\x1f\x0c\x5f\xcc\xf7\xab\x80\xf0\x23\x04\xf8\xf1\xfd\x1f\x13\xaa\xc3\x64\xa5\x39\x82\x81\x10\x4d\xee\x04\x63\xc2\xe3\xc4\x34\xd5\x16\xf2\x35\x88\x6c\x78\x09\xba\xa0\x6d\x69\x91\x22\xa2\xc5\x9d\x90\xd3\x82\x70\x8b\x79\x38\xb2\x7f\x7f\xba\xbc\xc2\x48\x09\x70\x2d\xdc\x49\x39\x3d\xf2\x2b\x32\x21\xd2\xbb\x2d\xed\x0b\xc8\xe8\x9d\xcc\x1a\xdb\x57\xf8\xdd\x63\x4c\xef\x50\x3a\x56\x29\xd1\x5b\xc9\xb5\x33\x1f\x29\xbe\x87\x70\x11\x28\x96\x28\xb1\x1e\xdc\xd9\xff\x6f\xb3\x52\xc5\x91\xe8\x2d\x11\x38\x97\x06\x46\x9a\xcb\x30\x6e\x31\xad\x64\x4e\x41\xd8\x91\x3c\x2c\x71\x1b\x61\x31\x2b\x89\x6b\xc1\x66\x1e\xb6\x56\x36\x6f\x28\xcb\x6d\x58\x96\x51\x41\x36\x77\xf0\xb2\x24\x1d\x4c\x84\xbc\xda\x66\x57\x51\x59\xb2\x1c\xd1\x7f\x06\xdd\x61\x80\xf0\xa3\x78\x78\xe2\x3d\x5e\x96\xe5\xd9\xb2\xdc\x86\xe7\x1e\x15\x64\xf4\xb4\x38\xa7\xfa\xb4\x48\x11\xd1\xe2\xde\x92\xd3\x82\x70\xc1\xfe\x3e\x1e\xce\x95\x8e\x96\x51\x06\x99\x2c\x65\xf4\xa0\x2c\x93\x22\xbd\x8e\x34\xeb\x90\xd1\x3b\x99\x35\xb6\xaf\xc0\xcb\x22\xdc\xf0\x74\x69\xb9\x8c\x5e\x93\x9c\x9e\xea\x5f\xa0\x5e\x84\xab\x4d\xb3\x45\x32\x7a\x4d\x72\x7a\xaa\x7f\x11\x5f\x88\x70\xa3\xd2\xa5\x95\x32\x7a\xd3\xb3\xc6\x77\x8e\x9c\x24\xc2\x05\xd3\x45\x36\x19\xbd\xe9\x59\xe3\x3b\x07\xbe\x12\xe1\xbc\xe9\xca\x68\x86\x1e\x5c\x93\xc5\xca\x18\x84\x2b\xc5\x72\x79\x8b\x44\xef\x90\x3b\x52\x7a\x12\x58\xe1\xa2\x80\x43\x56\x96\x20\x79\x73\xc0\x26\xc1\xaf\xcb\x59\x3a\xaa\xf8\x07\xc4\x69\x45\x6b\x4e\xee\x24\x7e\x42\xb8\xc4\x30\x10\x00\x56\x22\x9c\x72\x51\xbe\x30\xf8\x3e\x0c\x3e\x0c\x7f\x19\x26\x77\x87\x0f\x86\xc9\xea\x30\x80\xde\x0c\xaf\x5a\xbc\x0b\xfe\x5a\x59\x4f\x14\xe0\xfd\x36\x79\x46\xe4\xcd\x62\xde\xac\xbe\x20\xef\xe1\x72\xde\x80\xc1\xbc\xaf\x05\xbf\x16\x79\x97\x83\xef\xcb\xc1\x87\xe5\x5f\x96\x93\xbb\xcb\x0f\x96\x93\xd5\xe5\xa0\xbc\x00\x6f\x28\xc7\xc5\x58\x8e\xa5\x82\x1c\x6f\xe1\xe5\x03\xfa\x27\xa4\x2d\x3a\x9e\xaf\x20\xc7\x28\xf6\x15\xad\x02\x1c\x10\xe5\xb8\x29\x1d\x0d\x18\xed\xb2\x75\x91\xd3\x3b\x4f\xd6\x88\xf4\x66\xa7\x6d\xbe\x8b\xd2\x3b\x0f\xde\x10\xe9\xdd\x9e\x2e\xab\x93\xd1\x9b\xc6\x2c\x56\x9c\xe6\xe9\x99\xa2\x6a\x1a\x1c\xc5\xf3\x5c\x0f\x52\xd8\xae\x80\x2e\x63\x83\xe8\xae\x4f\x94\xf9\x5a\x92\xc9\x03\xc4\xbf\x79\x58\xe2\x97\xbc\x0d\x06\xb2\x6d\x70\x18\xb6\xc1\x32\xc1\x06\x1f\xe0\x6d\x10\xe8\x99\x08\x78\x40\xa3\x53\xa8\xb2\x6d\x10\xf5\x47\x51\xd2\x10\x7e\xb4\x60\x83\xdd\xa0\x11\xc3\x17\x91\x11\x70\x8b\xc3\x45\xea\xb3\xe0\x17\xf4\x9f\x65\xfe\xa8\xd8\x07\xe1\xcb\x31\xfc\x4e\x32\x0a\xda\x30\x3c\xf4\x97\xe0\x50\x20\x44\x69\xb2\xe0\x69\x38\xf6\x6e\x66\x32\x84\x1f\xc3\xc3\x63\xbd\x47\x3e\xa1\xce\x1c\x21\x67\xd4\x35\x90\xde\x2c\x78\x34\xfe\x13\x78\xfc\x31\x61\xfc\xdf\x0a\xe3\x37\x42\xfa\x4f\xe8\x0c\x74\x36\x7d\xf4\x16\x15\x8b\xe1\xc7\x0a\xf0\x2d\x02\x7c\x31\x1c\xff\xa9\x22\x8f\x4d\x91\x4d\x9f\x7b\x9d\x39\x81\xd7\x31\x26\xf8\x89\x2f\xfb\xff\xc5\xaf\xe3\x98\xb4\x48\x1d\xd1\x85\xbe\x99\xc5\xf6\x35\x56\x80\xab\x17\xd7\x7b\x7b\x5a\xa4\x2a\x8d\xf7\x90\x44\x0f\x80\x07\xb2\xec\xeb\x97\x26\x81\xa6\x4c\xc7\xd1\x98\x47\x2a\xfe\x2c\xd2\x86\x39\xf8\x55\x60\x09\xe1\x7a\x91\x04\x01\x12\xa2\x1c\x01\x64\xda\x2b\x70\xe0\xb1\xe0\xde\xf7\x36\xd4\x17\x69\xdc\x30\xde\x5a\xdf\xc3\xf7\x9a\x7a\x0c\xca\x57\x1a\xa7\x09\xea\x44\x7f\x97\x30\xcf\xc5\xf2\x79\x92\xdf\x93\xcb\xc4\xf1\x4f\x4e\x1b\xed\xb2\x79\x2e\x96\xcf\x93\xfc\x1e\xfc\xa7\x08\x77\x67\xba\xb8\x44\x9c\x67\x3f\xc3\x4d\x27\x83\x98\x5e\x05\xaf\xd7\xc4\x0d\x22\x5c\x6b\x5a\xe7\x10\xf5\x9f\x7b\x83\x9b\x8e\xce\x09\x41\xb8\x71\x10\x4e\x41\x9e\x1f\x22\x68\x7f\x32\x6d\x72\xd3\x18\x0a\x8f\x0f\x7a\x35\xaa\x06\xfb\x06\x4c\x4f\x5d\x07\x5c\x90\x9e\x1b\xe5\xb6\xc0\x0c\x77\x5e\x12\x3c\x6f\x60\x04\xef\x80\x85\x20\xc8\xae\x13\xe2\x0d\x54\xea\x20\xde\xdf\xe1\x7c\x23\xc4\x92\x7e\xec\x1d\x88\xc3\xa0\x14\xc6\x19\x46\x8a\x30\x2c\x37\x90\x1f\x18\x80\x81\x04\x2a\x6c\x15\xd0\x29\xac\x94\xe9\xd6\x1e\xbc\xef\x55\x61\x1f\xcc\x81\xd7\x79\x5d\x04\x16\xa8\x5b\x27\xf4\xa6\x02\xba\xd5\x81\xe1\x27\xf0\xf0\xc4\x79\x11\x1e\xea\xd6\xf3\x79\xf0\x68\xaf\xda\x83\x65\x54\x25\xe8\xcc\x7b\xa2\x8c\xc6\xa6\x61\x6e\x29\xd7\xad\x0e\x2c\xa3\x09\x02\x5c\xa5\x08\x37\x47\x0e\x87\xf6\x2a\x19\x3d\xb8\x57\x0d\x17\xe1\xa6\xa6\x0d\x26\x19\xbd\x93\x72\x7a\x70\xaf\x3a\x2e\xc2\xdd\x26\x87\x83\xe3\xa3\x4e\x61\x7a\x71\x81\xef\x0e\x11\xee\x54\x5a\xa1\x22\x84\x38\xa2\xff\x0f\xdc\x09\x61\x0d\x27\xf2\x70\xc4\xa7\x22\x5c\x73\x9a\x56\x48\xbe\x0e\xd2\xa3\xaf\xc3\xbe\x20\x8e\x7d\x98\x85\xec\xe1\x6d\x1c\x3c\x03\x7d\x02\xf4\x4b\x5a\xc9\x87\xf5\xff\x91\x3b\x41\xfe\x51\xf1\x2a\x4f\x13\xc1\x12\x5f\x0a\xfe\xc0\x0a\x75\x1f\xc2\xaa\x48\xd9\x9e\x7f\x52\x3e\x4e\x38\x9f\xcf\x44\xfe\xef\xa5\x95\x6a\x69\x9c\x0e\xee\xa4\x6c\x9c\x0a\xf2\xab\x99\x02\xd4\xa4\x34\xa3\x24\x32\xba\x06\x7d\x77\x16\xbd\x73\x80\x13\xe9\x3d\x9a\xd6\x29\x44\x7a\xdc\xe7\x92\xee\xf2\xf4\xce\x5d\x27\x40\xb9\xd3\x1a\x5a\x4e\x8f\x20\x14\xcf\x60\xbd\xa8\xe6\xf5\x82\x5c\x29\xe8\x45\x31\xd4\xa3\x1f\x9c\x6e\x83\x3d\x57\x8f\x14\x63\x71\x0c\xd5\xc6\xef\x65\xe4\xfd\x02\x7c\xc2\x1c\x01\x5c\x55\x8d\xd6\x97\xeb\x03\x21\xfd\x27\x44\xfa\xe4\x83\x64\x9b\xe0\xd3\xdc\x90\xfe\x43\xce\xa2\x82\xf4\x7b\x45\xfa\x10\xde\x29\xd0\xaf\x81\xf4\xf7\x56\x55\xe7\xd2\xe7\x4e\x28\x9e\xc1\xf2\xa8\xe6\xd7\x97\xea\x16\xe5\x31\x23\x2d\x52\xe7\xf5\x14\xdd\x25\x13\xe9\x42\xb8\xe9\x22\xdc\x1d\x69\x91\xaa\x60\x57\xc7\xf1\x78\x6b\x72\x7c\xb6\x19\xf9\x6c\x83\x89\xd1\xe5\xd9\x95\x1d\x8f\x77\x92\x00\x4f\x0b\xe3\xf5\xc1\xf1\x3e\xed\xf1\x6a\x9c\x79\x76\x75\x1c\x8f\xb7\x46\xd0\xdb\x7f\x88\xe3\xe8\x4e\x8b\xd4\xf1\x78\x7b\xd1\x1d\x2f\x91\x2e\x84\x6b\x26\x28\xd1\x97\x89\x54\x05\xbb\x92\xd1\x83\x76\x35\x99\x90\x34\xc7\x68\x96\xd1\x3b\x29\xa7\x07\xf5\xf0\x15\x11\x6e\x77\xba\xd8\x27\xa3\x37\x3d\x8b\xde\x39\xf2\x25\x11\x6e\x4a\xda\x66\x90\xd1\x9b\x9e\x45\xef\x1c\xf8\xad\x08\xb7\x24\x1d\xf4\x48\xf4\x96\xf7\x9f\x55\x10\xd8\x37\xd6\xe2\x79\x1c\xa7\x1a\xf8\x3d\x85\x22\xc3\xc8\x35\xde\x11\xae\xd5\x50\x39\x7b\x0a\x7a\xdb\x7d\x1e\x8e\x9b\xda\x71\x8c\xf0\x08\xf2\x8f\x38\x6e\xfa\x3d\x8c\x9b\x12\xa9\x10\xb5\xb9\x01\x7c\xd1\xd0\xdf\x40\xfa\x1a\xc0\xee\x86\x83\xe8\xcf\x78\x03\xd9\x40\x16\x9b\x21\xc5\x25\xe1\x6a\x15\x21\x52\x84\x51\xd4\xca\x95\xab\x04\xba\xb9\x63\x39\x41\x25\x79\x3f\x4d\x53\x64\x25\x13\x81\xbf\xdf\x56\x39\x40\x18\x8d\xdc\x4f\xe3\xb7\xe6\x15\xbf\xce\x1b\xcf\x12\x18\x43\x0e\x21\xc6\xa6\xea\x69\x6a\x4e\xc3\x81\x06\xb2\xa5\x01\x2c\x47\x7f\xe2\xd1\x1c\x6b\x00\x73\x1a\x96\xa3\xbf\x9c\xd8\x40\x1a\x1b\x00\xfc\x07\x0f\x90\x96\x8f\xb0\x5e\x0c\xf4\xd0\x28\x57\xd5\x5f\x64\x9c\x6f\x51\x1e\x51\x66\x21\x24\xb3\x65\xa1\x70\x41\x99\xd5\xca\x64\xb6\x13\x3d\xf3\x84\xe3\xdc\x21\x50\x66\x35\xa9\x00\xe5\x0b\x80\xef\x03\xe0\xc3\xc0\x97\x01\x72\x77\xe0\x60\x80\xac\x0e\xc0\x2d\x1a\x4b\x6c\x91\xd7\x9f\x25\x31\x31\xee\xcc\x1d\xc7\xdb\x54\x22\x6b\xed\xee\x0b\x17\x17\x1c\x47\x73\xd6\x38\x2c\xc2\xda\xbd\xf8\xff\x3c\x0e\x64\x93\xa3\xb1\x8f\x4a\x08\x7b\xdd\x76\x21\xee\x72\xc2\xb0\xe4\x65\xab\x5d\x9d\x95\x8b\xf1\x77\x0b\xb1\x8f\x9a\x2c\xf0\x46\xcd\x38\xd8\x34\x59\x05\xc3\xb4\x23\xa0\x2c\x5d\x56\xa1\x92\xbc\x8e\x44\xff\x09\x91\x7e\x26\x6f\x26\xed\x90\x7e\xb7\x95\x2d\x48\xbf\x57\xa4\x0f\xe3\xcc\xef\x85\xf1\x54\x40\x06\x87\xca\x62\x2a\x7b\x5e\x1c\xb8\x03\xd3\xaf\x17\xe8\xff\x42\xa0\x5f\x04\xe9\xaf\x76\xb8\x68\x75\xae\x4f\x21\xcf\x61\xfa\x53\xb1\xef\x7e\x70\x3e\xef\x51\xec\xd0\xa3\x3c\x64\x65\x95\x16\xf9\xd8\xa1\x3f\xd9\x81\xed\xb5\x5e\xf0\x13\x3f\x8a\x31\xfa\xe6\xb4\x48\x19\x8e\xf9\xcf\x70\xcf\x3a\x87\x63\xf9\xa9\xc2\x3e\x78\x4a\xb0\x57\xee\x44\x5a\xa4\x29\xd2\xc3\xfb\x60\xbd\xb0\x0f\xfe\x28\xec\x83\x5f\xe2\x7d\x90\x72\x67\xf6\xc1\xaf\xe1\x1e\x5c\x8c\xe3\xe1\xa9\xc2\x3e\xf8\x67\x3c\xde\x9d\x13\x71\x24\xef\xc0\x31\x8b\xe0\xa3\x64\x63\x84\x3e\x6a\x86\x38\xc6\xeb\xa0\x8f\x96\xc6\x38\x83\x3b\x29\x1f\x23\xf9\x15\xf1\x88\xe8\x53\x1c\x30\x3f\x96\xc6\x38\x00\xc6\xed\x29\x2c\xcf\x86\x6c\x79\x82\x0a\xe8\xa3\x1f\x2c\x8b\x51\xd9\x3e\x97\xe9\x3f\x8b\xde\xcc\x82\xf0\x1d\xc2\x7a\xbd\x22\xf8\xe8\x18\x94\xe8\xed\xa5\xe5\x0a\x57\x16\xfc\x00\x28\x83\x14\x73\x9f\x48\x3f\x23\x53\xd0\xff\x44\x5a\xa4\x8e\xe8\xc2\xf9\x9f\xa4\xc7\x8a\x74\x21\xdc\x10\x11\xee\x3f\xd3\x22\x55\x71\xbc\x4a\x56\xa2\xf7\x0e\x05\x37\x63\x1c\x23\xd7\x32\x38\x46\x0e\xa5\xcb\xab\x79\xaa\x62\x8c\x8c\xc6\x4c\xab\x99\xbf\x48\xb4\xdf\x21\x77\x71\x1f\x61\x1c\xb8\x0f\x22\x1c\x43\xba\x2c\xce\x73\x90\x70\x78\x3e\x31\x89\xcf\xbb\xe4\x47\x62\xfc\x5e\x85\x18\xbd\x1b\xaf\x97\x73\x91\x64\xf3\x07\x05\x2d\xf1\x79\x17\x7c\xc2\x7d\xc2\xe3\x54\x22\x46\x7b\xab\xea\xe4\x5c\x32\xf2\x11\xe5\x2f\xd3\x91\x8c\x5e\x57\x43\x76\x0f\x56\xc6\x73\xd7\x01\xc9\x4b\x5c\x07\x8c\x37\x24\x7b\x3d\xb0\xfd\xdc\x5e\x51\x95\xb3\x1e\x47\xa0\xfd\xcc\xc2\xfc\x92\x02\x9f\x4d\xc2\x7a\xc3\xa0\x0c\xd4\xab\x34\x74\x76\x5e\xd4\x85\xfa\x72\x29\x86\x40\xf8\x69\xbc\xfd\xfc\xb4\x86\x88\xa6\x8a\x80\xcf\x03\x8c\x1e\xd0\xef\x01\x5f\x78\xce\x79\xc8\x47\x3d\xc0\x03\x5a\x5d\x6e\x8a\x4f\x0a\x91\xbf\x41\x3b\x05\xe2\x07\xe7\x37\x0b\xeb\x6b\x32\xbb\x96\x05\xb8\xf7\xd2\x22\x37\x08\x67\x87\x36\xd5\xc3\x54\x08\x7c\x20\x1c\x60\xc5\xf5\xb7\xa5\x45\xc2\x10\xee\x17\x50\xff\x65\xf4\xe0\xde\x2b\xc6\xa0\xdc\x47\x69\xb5\x56\xa4\xd7\xbf\x07\xea\xbf\x8c\x1e\xd4\xff\x3f\x8b\xf4\xae\x83\x79\x9a\x44\x6f\x3e\xdc\xa3\xe5\xf4\x32\x31\x20\xf7\x64\xda\xa0\x92\xe8\x2d\x86\x79\x8e\x9c\xde\x39\xb4\x27\xf0\xf4\x46\xa5\x7d\x2e\x89\xde\xfd\x30\x1f\xfb\x2f\x4c\xaf\x11\xc3\x7d\x4d\xde\x81\x6b\x8c\x50\xcd\xfa\x5d\xe9\x22\x27\x65\xc9\xd4\x18\x3b\xa0\xef\x1b\x43\x0f\x80\xb0\xd3\x79\x58\xf0\x85\x04\x3b\x21\xed\xf7\x3a\x35\x19\xd8\xfb\xe1\x38\xe5\x74\xcf\x93\x03\x45\xfe\xca\xb4\xb7\x8c\x12\xed\xd9\x0c\x63\x09\x39\xcd\xf3\xe0\x0e\x11\x2e\x95\x2e\x89\x3b\x35\xd2\x38\xb3\xe9\x9d\x83\x11\xb7\x00\xa7\x4e\x7b\xec\x12\xbd\x21\x39\xf4\xce\x01\x59\xcc\x1f\xf4\x64\xe8\x41\x7b\xf9\x2f\x6c\x2f\x8d\x42\x6c\xe2\x15\xed\xc5\x87\xec\x65\x9d\xaf\x42\x9c\xba\xa4\xfb\x1d\xfd\x7f\xa5\x97\xe3\xfd\x6d\x3a\x1f\x0b\x00\xbd\xb0\xc7\xfc\x05\xee\x6f\xd1\x94\x9b\x2c\x1c\x9b\x00\x8f\x58\xd5\xc9\xc4\x23\xb9\xfc\x7b\x29\xa3\x94\x37\xfa\x70\xde\xb8\xc5\x27\xcc\x2a\x2b\x1e\x41\x63\x18\xa3\x58\x23\x8d\x61\x27\xd0\x08\xf1\x48\x13\xf1\x33\x11\x4a\x39\x28\x72\x62\xc9\xa3\x25\x64\xbc\x04\xf8\x4a\x80\xb1\xa4\xa5\x84\x2c\x91\xf8\xaf\x5c\xb9\x52\xa4\xf3\x02\xb4\xab\x1f\x95\x0a\x48\xa7\x09\xf3\x27\xc1\x32\x59\x0e\x39\xdc\x52\x4c\x66\xd7\x57\xf0\x9b\xf1\x0c\xca\x7b\x3a\xb1\x5c\x1f\x21\x3e\x13\xe0\x59\xe8\x47\xa3\xac\x9f\xcc\x8e\x8d\x5f\x80\x76\xf4\x23\x5e\xaf\x26\xc1\x8e\xc4\x58\x92\xfb\x18\xea\x3d\x4f\x1d\xd1\x85\xb9\xd7\x3c\xbc\x5e\x9d\x82\x1d\xfd\x4d\x84\xfb\x09\xe6\x90\xa4\x18\x73\xc2\xf1\xaa\xaa\x70\x1c\x30\x00\xc7\x01\x7d\xa4\x19\xef\xeb\x00\x6e\xa3\x50\xfd\x5e\x4e\xbb\xbd\x6a\x97\x6c\x6f\xc4\x6f\xda\xe3\x38\x60\x86\x10\x0b\xfd\x85\x87\x47\xc3\x3d\xd2\x7f\x32\x6d\x77\xa9\x6c\x32\xf8\x5c\xfa\x1c\x8e\xcd\x71\xfd\x08\x32\xd8\x5c\x54\xac\xce\xf6\x4b\xb9\xf4\xaf\x85\x69\x5f\x46\x1e\xab\x59\x67\x86\x3a\x91\xa1\x7f\x48\xa4\xaf\x06\xe4\x72\x51\xdf\x50\x20\x00\xbc\x5e\x8f\x3a\xd7\xd7\xf2\x3c\x36\x48\x3c\x96\x80\xb7\xa4\xba\x23\xf2\xcf\x65\x2e\x07\xcf\x45\x86\xc3\xf3\x79\x42\xe4\x03\x73\xa8\xd7\xc4\x3a\x12\x9c\x87\xa9\xc8\x53\x70\x1e\xbd\x22\x0f\xe8\x5f\x0f\x09\xf3\x70\xc2\x79\x84\x59\x47\xee\x3c\xb8\x13\xaa\x2a\xbc\xae\x03\x84\x5c\xea\xf7\xe2\x7a\xfd\x4f\x5a\xa4\x8e\xe8\xc2\x9c\xab\x1e\xaf\xeb\x0c\x61\xfd\xbf\x17\xed\xd0\x94\x16\xa9\x42\x3f\xf5\x09\xd4\xc3\xfb\xf0\x78\x07\xe6\xec\xe7\xa8\x4e\xb6\x5b\x67\xa0\xb2\xe2\xa3\xfe\xfd\x50\x0f\x07\xe1\xf1\xce\x14\xf6\x8f\x97\x85\xf1\x1a\xe1\x78\x6f\xca\x83\xe7\xe9\x1f\x12\xe9\xab\x01\x18\x97\x55\xd7\x3a\x6c\x12\x30\x32\x32\x14\x78\x6c\x10\x79\x10\x4b\x88\xdf\x49\x38\x48\xee\x77\xe5\xe3\x20\x08\xe6\xbf\xf0\x3c\x06\x09\xf3\xd8\x23\xcc\x43\x07\xe7\x61\x54\x6b\x29\x65\xd6\xb8\x6e\x85\xbe\x74\x11\x9e\xc7\x2c\x61\x1e\xef\x08\xf3\x70\xc3\x79\xdc\xe5\x2c\x22\xad\x59\xf0\xff\x03\xe9\x7b\x14\x1c\x84\x1f\x8c\xf5\xb3\x1f\xd7\x99\x10\xbc\x09\xd2\xdf\x6f\xd2\x80\xac\x7d\xb0\xff\x07\x82\xa0\x4e\x31\xbf\x85\xf0\x5d\x98\xfe\x0e\xbc\x9f\x60\x78\x48\xff\x6e\x93\x86\x60\xb2\xe9\x43\x7b\xf5\xe0\x75\x1d\x2c\xac\xd7\x6e\x71\xbd\x76\xa5\x35\x3a\x20\xee\x2b\x3f\xa0\xda\x0b\x5e\xd7\x2e\x01\xae\x54\x84\x7b\x06\xc2\xf1\x54\x31\xbd\x93\x72\x7a\x70\xdf\xfb\x49\x84\xdb\x98\xd6\xea\x65\xf4\x4e\xca\xe9\x41\xb8\x5b\x32\x35\x0d\xad\x5e\xa4\x87\x73\x58\x79\x7d\xef\x2b\xf0\xac\x08\x77\x57\xda\x5d\x2c\xd5\x31\xd1\xfe\xff\x99\x62\x94\xb8\xef\xc1\xb5\xa3\x89\x5e\x7e\xed\xfc\x68\xbd\x47\x16\x0b\x7b\x73\xae\x9d\x29\xae\x91\x6c\xe0\x21\x70\x4c\x5c\x6f\x27\x5a\xef\x4a\x37\x9b\x6b\x67\xfc\xfa\x61\x1c\x7e\xfd\x1e\x22\x9e\x15\x71\xdc\x08\x67\x99\xd7\xc9\xaf\xa0\x8c\x4f\x15\x8c\xeb\x2a\x99\xbf\x5b\xc4\xef\x79\x3d\xc4\x0f\x42\xec\x33\x14\xa2\x3c\x39\xb4\x85\xff\xa0\x27\xd9\x5a\x00\xe6\x02\x87\x50\x4d\x1b\x0c\xc9\xa9\x69\xa3\xba\xdd\x11\xa3\x99\x90\xad\x39\x01\x88\x7a\xb8\xa7\xb4\x32\xf7\x11\x61\xa2\x3d\x15\xb3\x3b\xfc\x2a\x55\x28\x64\xf0\xf9\x74\xa4\x83\x8e\x44\xfd\x7a\xbd\x6e\x6e\xa7\xc1\xa3\xd7\x3b\x3c\x1e\xf3\x9c\x4e\x0f\xed\xb0\x10\xcc\x9c\x4e\x92\xb0\x0a\xbd\x2b\xe4\x6d\x15\x89\x44\x7e\x0f\x2d\xe9\x26\x08\x3a\x5e\xc1\xdf\xe9\xe1\xcf\x97\xa2\x73\xcb\xfc\xa5\x2e\xf2\x87\xc7\x56\x94\x5d\x7b\xfd\x93\xaf\xec\x7e\x6a\xb4\x1b\xac\x2b\xbb\x6b\x56\xcf\x33\x8b\x83\x7b\x5e\xdb\x53\x71\xff\x85\xd7\x9e\xf8\xe7\x14\x6e\xfd\x13\xbf\xe2\x3e\xb1\x85\x1e\x2e\x7b\xea\xfe\xab\x16\xde\x0a\xae\xa8\x6f\x99\xf9\xcb\x83\x17\xde\xa2\x06\xfd\x99\x5b\xbb\xf9\x76\xee\x61\xc3\x2b\xbb\xfe\xf4\x33\x81\xbf\x91\x9e\x90\x7f\x23\x85\x7a\xf6\x2b\x31\x6f\xf8\x13\xaa\x05\x2a\x85\xf5\xae\x82\x70\xb2\x6f\xa4\x10\xae\x4d\x84\xbb\x33\xdd\x38\x80\x97\x28\xa2\x07\x6d\xfa\x1b\xe5\x18\x91\x1e\xf9\x2e\xc3\x82\x66\x94\x17\x7a\x18\x94\x17\xce\x4e\x9b\x1d\xb4\x52\xb6\x1f\xe0\xb5\x52\xe8\xa4\xb5\x7a\x97\x5e\x2c\xac\xd5\x48\xb8\x56\x6f\x0d\x1c\x92\xbd\x56\x88\x3e\x93\xc6\xfb\x39\x3f\xde\x0b\xd4\x66\x1c\xe7\x53\x28\xcf\xa3\x20\x87\x3d\xe9\x22\xa3\xf8\x6d\x57\xfc\xbe\x0b\xd7\x4b\xa1\x88\x88\x3c\x34\x34\xf9\x67\x01\x67\xb8\x19\xe3\x28\xd3\xc3\x9b\xc4\x8f\xbc\x42\xfd\x9c\x9f\x47\x86\x4f\x1f\xe6\x83\xf3\x72\xcc\xe8\x77\x66\x9b\x9c\x4b\x46\xef\x64\x7c\x18\xf2\x73\x11\x67\x24\x62\x94\x18\x98\x92\x73\x91\xe6\x33\x49\xc6\x87\x93\xe6\x13\xe6\xe7\xb3\x22\x1d\x36\xe7\xcf\x87\xfe\x0c\xc7\x26\x3c\x1f\x05\x7e\x07\x03\xf3\x99\x88\xf8\xfc\x6b\xe2\x80\x42\x7c\xb2\xe6\xd3\x8f\xf9\xe0\x6f\xdc\x60\x78\xba\x2c\x24\xb2\x10\xe9\x8f\x53\x9c\x93\xe8\x2b\xc9\x3f\x89\xf4\x53\x88\xfe\xb3\xa9\x69\xf9\xf4\x91\x1e\x61\xbf\x59\x22\xe4\x1d\x8f\x0b\xfe\x13\x7d\x8f\x84\x39\xad\x23\xf3\x7d\x0a\xeb\x12\xf6\x99\xc3\x71\x6c\xb5\x83\xaf\x5f\x08\xb9\x1d\xcc\x6a\x07\x4b\xdf\xa7\x72\xc7\xad\x21\xd0\xd9\x1b\x2c\x1f\x1b\x2f\x9f\xb1\x69\x87\xaf\x80\x7c\x66\xe2\x18\x83\x1f\xbf\x8a\xfc\x46\x1c\x7f\x33\x1a\xff\x87\x43\x06\x5e\x4e\x3e\x1a\x20\xad\x83\xc0\x67\x4c\x61\x3e\xf5\x32\x3e\x6a\xf2\x54\x16\x9f\x57\x86\xb4\x5e\x96\x0f\x49\xad\x12\xf8\xf8\x78\x3e\x83\xd3\xc1\xf2\x02\x7c\x6a\x31\x0e\xcf\x47\x43\xfe\x45\xe4\x33\x06\x2b\xf0\xf8\x29\x97\xe5\x43\x51\x5b\x05\x3e\x06\x9e\x4f\x47\x3a\x18\x2f\xc0\x67\x8a\x6c\xdd\xb5\xe4\x1f\x45\x3e\x93\x10\x9f\x13\x53\xc6\x5f\x64\xdd\x4f\x4b\xeb\x4e\x83\x57\x65\x7e\x04\xae\xa5\x21\x77\xdd\xbf\x96\xd6\xfd\x01\x74\x14\x4c\xf2\x25\x10\xb6\x31\xfb\x3b\xbe\xec\xfb\x29\x84\xf9\xa3\xb8\x0f\x6d\x48\xeb\x0c\xb2\xef\xa7\x27\xe4\xdf\x4f\x33\xf5\x01\xb2\x7f\x5d\x3a\x10\xca\x7c\x3f\xc5\xdf\x96\xc7\x88\xf4\xa0\x5f\xd2\x43\xbf\x24\xc6\x9d\x6f\x18\x85\xaf\xda\xb2\xb3\x06\xe8\x9b\xb6\x4e\xa4\x0b\xfd\xd2\x5c\xc1\x2f\xc5\xa1\x5f\x4a\x97\x94\x1b\xf3\xeb\x4f\x8b\x95\x2a\x89\xfe\x23\xe0\x73\x30\x16\xd3\x87\xfa\x03\x5e\x15\xbf\xf8\x66\xd3\x67\x8e\x4a\xf4\x1f\x21\xfe\x06\x77\x16\x44\xbf\x0c\xd2\xbf\x5a\xfc\xf2\x9b\x45\xff\x1d\xd9\xb7\xf1\x0b\xd4\xbd\x42\x7d\xc3\xc9\xd7\x37\xc2\x69\x67\xd6\xd7\x71\x81\xc7\xb7\xd8\x1f\xb5\x0a\x7e\xef\xb8\xb8\x9e\x95\x68\x3d\xbf\xaa\x0c\xf2\x5c\x64\x3e\x2c\xf7\x1b\xbc\xe4\xf7\x04\x46\xc3\x8c\x96\x8b\x7c\xff\xcf\xf0\x61\xc8\x8f\x45\x3e\x71\xc4\xc7\x5f\x52\x76\x59\x3e\x5c\x86\x4f\x08\xf1\xf9\x2c\x64\x2c\xc8\xe7\x04\xf6\x7b\xad\x82\xdf\xfb\x42\xe4\xd3\x88\xf8\x7c\xd6\x18\xba\x2c\x9f\xfe\x0c\x9f\x4a\x7c\xa6\x20\x1a\x28\xc8\x67\x30\xb6\x83\x56\xc1\xff\x49\xf3\x29\x43\x7c\x76\x95\xa5\xf2\xf9\x20\x7d\xc5\xfe\xaf\x54\xf0\x7f\x7f\xc4\xfc\x08\xd0\xcd\xeb\xb6\x49\xfe\x7d\x1e\xea\x2c\xf6\x7f\xfc\xf7\xf9\x1d\xa8\xb6\x29\xf7\x7f\x91\x8c\x1d\x40\xef\x49\x7e\x84\xf5\x96\xff\x8e\xfa\x2e\xb5\x5e\xd0\x5b\x94\x3f\xbe\xab\xd4\xe7\xe8\x15\xaa\x6b\x4e\x55\xe8\x4c\x11\xe2\xef\x27\x30\x3c\xd9\x07\xff\xc3\xa8\x54\x99\x33\x15\x08\xb4\x3a\x53\xc5\xc5\xf0\x37\xa7\x13\xfe\x66\xb3\xc1\xdf\xac\x56\xf8\x9b\xc5\x02\x7f\xd3\x6a\xe1\x6f\x1a\x4d\x2b\x38\xc2\x7d\x9a\x52\x2b\x95\x24\xa4\x6b\xc1\xe3\x80\xe4\x63\xc2\x2f\x9e\x07\xaa\xc9\xc8\xbe\xed\xca\x6b\x32\xa3\x65\xdf\xfb\xfa\xff\x24\x7d\x17\x1c\x27\xd4\x43\xa5\x33\x27\x23\x50\x8d\x47\xb4\xe1\xe5\x30\x87\x21\x70\x2d\xb0\x56\xc8\x75\x3a\x45\xb8\x3b\xd0\x77\x18\xf1\x0c\xcb\x30\x28\xb7\x5a\xfc\x3d\xa4\x3d\xd7\xd6\x57\xa7\x8b\x7d\x7c\x5d\x5b\xaa\xa9\x8f\x11\xe9\x41\x5b\x1f\xc5\xcb\x8c\x2c\x87\x4b\xfe\x80\x4f\xa8\xec\x4b\x32\xe3\xeb\xfa\x3a\x91\x2e\xb4\xf5\x2e\xc1\xd6\x63\xd0\x16\x9f\xf7\x47\x78\xca\x12\x7c\x6e\xcd\xfe\x02\xf5\xb6\xa8\x1f\xa5\xc8\xb9\xfe\xbd\xb4\x60\xcd\x5e\x88\x41\xda\x65\x31\x48\x46\xa7\x7e\x2e\xf3\x66\xea\xf2\x17\xe1\xd3\x97\xc3\x27\xea\x0b\x5e\xe4\x1b\x45\x86\x0f\x93\xe1\x13\x43\x7c\x2a\xfd\xe1\xcb\xf2\xe1\x32\x7c\x12\x88\xcf\xeb\x09\x5f\x41\x3e\x1f\x60\x5b\x6c\x17\x6c\x51\xe2\x53\x87\xf8\x7c\x5e\xe7\xbb\x2c\x9f\xfe\x0c\x9f\xc1\xf8\x5b\x47\xb2\xa6\x20\x9f\x09\xd8\x16\xdb\x05\x5b\x94\xf8\x84\x11\x9f\xdd\xe1\x41\xf9\x7c\x90\x3e\x61\x5b\xac\xe5\x6d\x91\xea\x14\x62\x91\x7b\xf9\x58\x24\x2c\x3f\xaf\x06\x75\x0a\xdb\x62\x7b\x56\xbd\x74\x07\x6e\xac\x01\x61\x65\xb6\x08\xc7\xaf\x9c\x8c\xf6\x7b\x30\x4f\xa8\x5d\x84\xc5\x3d\x01\xea\xd5\xc0\xf2\x4a\x87\x3a\x57\xaf\x98\x6e\x54\xbb\x00\x57\x08\xf5\xab\x07\x65\x7a\x35\x3f\x52\x46\x19\x73\xf5\x2a\x8b\x7e\x1f\x40\xe7\xeb\x60\xec\x8c\xc8\x1f\x81\xf9\x5c\xac\x2a\xc3\xa1\x00\xfd\x61\xc0\xce\xc3\x23\xf2\x47\xfa\xb7\xa4\xa3\xe5\x19\x0e\x22\x7d\x64\x17\x3c\x7d\x68\x17\xdd\x82\x5d\x34\x42\x06\x9a\xca\x44\xa1\xf1\x23\xbb\xe0\xe9\x43\xbb\x98\x48\x64\xce\xe2\x28\xcb\xe2\x85\xc6\x8f\x6a\x5d\x3c\x7d\x35\x09\x6e\xe7\xc7\x93\xc0\xe3\xff\x24\x9d\x68\x2e\x30\xfe\xa3\x12\xfd\x47\x80\x0e\xee\x81\xe2\x37\xa4\xfe\xef\xd2\x55\x4d\xd9\xe3\xe7\x4e\x28\x27\x23\x3f\x21\xd0\xb7\x50\x57\x08\xf6\xcf\x7d\x9f\x2e\xaf\x70\xa8\x33\x7e\x82\xe9\x46\x7e\x82\xa7\x0b\xd7\xb4\x5b\x84\xeb\x4b\x47\x4a\x79\x9a\xb8\xd6\x79\x42\x5e\xeb\x94\xc7\x18\x45\x69\xbb\x53\xaa\x75\x76\x40\x1d\x91\xd5\x3a\x21\x9c\x4f\x84\x1b\x0c\xfd\x53\x4e\xad\x73\x8c\x54\x3b\x7d\x17\x7a\x68\xde\x57\x97\xc0\x9f\x36\xb8\x7c\x94\x25\x4b\x5e\x7c\x8d\x51\x27\xd5\x50\xdf\xa5\xc7\x0a\xb5\x83\x72\x73\x04\x6c\xf3\x85\x9d\xd9\xe7\x45\x20\x7d\x65\x1c\xeb\xc7\x4a\x5e\xff\xc0\x05\x01\x1e\xd1\x37\xfa\x82\x94\x23\x97\x3e\x73\x0b\xd6\x8f\x55\x82\xfe\xed\x15\xe0\x2b\x20\xfd\xf1\xd1\xf2\x90\xf9\x92\xf4\xfb\x40\x2d\x5e\x3f\x4c\xfe\x48\xff\xa2\xb4\x3f\x94\xe1\x50\x80\xfe\x30\xf4\xcd\x16\xc1\x57\xe0\xda\x5f\x2a\x5d\x1a\xcb\x70\x10\xe9\x63\xfd\x5b\x29\xc8\x27\x86\x73\x43\xb4\x13\x43\xf8\x8f\xd2\xc1\xd2\x7c\xfa\x58\xff\x56\x09\xf2\x19\xc0\xd3\xaf\xc7\xf4\x7f\x97\x2e\xaf\x2e\x40\x5f\x25\xd1\x7f\x04\xfc\x0c\x63\x30\x08\x1f\xc5\xf4\xdf\x49\x47\x6b\x0b\x8c\xff\xa8\x44\x5f\xd4\x3f\x10\xc7\xf4\x3f\x4c\xc7\x07\x64\xd3\x87\xfa\x17\x47\xfa\xc2\xd3\x97\xe9\x0b\xb7\x34\xed\x0b\xf0\xb4\x79\x7d\x61\x6e\x41\xfa\xc2\xd3\x85\x70\x5e\x11\xee\xa1\x74\xb4\x8c\xa7\x29\xd5\xb2\xbe\x17\x6b\x59\x50\xde\x41\x7e\x7e\x6a\x3c\xde\x6f\xd2\x1a\x3d\x25\xcb\x95\x85\x5a\xd6\x29\xb1\x16\x02\xe5\xfd\x2d\x91\xa9\x21\x56\xb8\x3c\xd9\xb5\x2c\xe2\x77\x92\x7e\x0f\x12\xc6\xf1\x9c\x38\x8e\xb7\xd3\x62\xa5\x4c\xa4\x8b\xf5\x7b\x16\x3a\x13\x06\xed\xaa\x26\x53\x6b\xc3\xfa\x3c\x48\x90\xff\x3f\x04\x7d\x86\xc9\x1c\xa8\xd2\x59\x0a\xd5\xda\xb0\x3e\xcf\x12\xe0\xed\xc2\xf8\xa0\x13\x05\x4f\xba\x03\xb9\xe3\xc3\xf4\x55\x12\xfd\x47\xc0\x7e\x21\x66\x46\xe7\x40\x0c\x66\x4f\xc1\x5a\xde\x51\x89\xfe\x23\xc4\xc7\x7c\xcc\x0c\xfc\xe8\x1b\xa3\x3f\x96\x43\x7f\x64\xff\x19\xfa\x98\xa2\xda\x12\xa1\xb0\x1f\x50\xde\x4d\x1c\x27\xe6\x4b\x31\x7c\x28\x5e\xee\x54\x5d\x12\xbe\x97\x78\x59\x80\x47\xdf\x03\xed\x89\xcb\xc1\xef\xc1\xf4\x51\x8e\x55\x8f\xd3\xb2\xfe\xf3\xe9\x7a\x01\x47\x8a\xc9\x73\x71\xf6\x63\x1c\xbc\x9f\x35\x20\x24\x65\x63\x16\x46\x41\x3e\x7b\x89\xaf\x45\x1c\xcc\xa8\xa6\x3e\x76\x59\x9c\x03\x19\x1c\xcc\x67\x64\xe3\x45\x70\xd0\x7a\x0b\x38\xfb\x32\x63\xc3\x71\xfc\xb8\xc1\xa3\x2f\x8b\x73\x30\x83\x53\x83\x71\x52\xe3\x72\x71\xf8\xdc\x14\xc7\x85\x28\x37\x55\x28\xef\x7e\x98\x20\x2c\x29\x0d\x09\xb3\xba\xe3\x56\x2b\xcd\x1f\xa0\x6f\xa9\x2f\x08\xdb\x2b\x83\x75\x38\xb2\x60\x89\x2d\x04\xa1\xb0\x31\xbd\xa6\x28\x51\x02\x2a\x30\x34\x6a\xe6\xec\xfc\x25\x05\xed\x0f\x2d\xc7\xcb\x69\x97\x8b\xc7\x40\x28\x3c\xce\x73\x79\x38\xfb\x21\x8e\x3d\xa5\x83\x09\x39\x44\xd2\x14\x15\xc9\x30\x0a\xf2\xd8\xfb\xff\xc0\xe3\xc0\x25\x79\x6c\x47\xf0\x8a\xaf\x65\xf0\xfb\x04\x1e\x0e\xcc\xe3\x58\x3a\x10\xc8\xe5\x91\x8f\x73\x50\xc0\x29\x12\x70\x4a\x4a\x72\x71\x82\xfd\x67\xa9\x87\xb0\x8e\x2c\x12\xec\x23\xcd\xeb\x3b\xfa\x2c\x0d\x0e\x57\x96\x6a\xb2\xf7\x93\x5c\xf8\x5e\x62\xb7\x00\x8f\x1c\xe6\xee\x9a\x4b\xc3\xc3\xd5\xb8\x6e\x3e\x9f\x79\x25\x50\xe5\x76\x64\x42\x80\x97\x6c\x23\x17\x7e\xbf\x08\x8f\xc2\x0d\x30\xb3\xa1\x10\xfc\x07\xb2\xf1\xec\xc5\xe3\xcf\x70\xd8\x97\x28\x93\x63\x10\x85\x70\x0e\x64\x70\x30\x97\x23\x0d\xf9\x38\xeb\xa0\x6c\x6b\xf0\xfa\x95\x42\xed\xc6\x92\xea\x47\xa7\x85\x6c\x87\x61\xc0\x05\x1d\xf5\x15\x69\x9d\x0e\x00\x41\x13\x85\xb5\xc8\x86\xef\x15\xe1\x9d\x08\x7e\x7a\x0e\xfc\x72\x82\x50\xfe\x27\x0f\x4f\x4e\xe7\x25\xf5\x1d\x5a\x3b\x12\x78\x08\xf4\xcd\xd7\x23\xc1\x67\xd6\xee\x81\x3c\x9c\xfd\x02\x4e\xf1\x45\x71\xf2\xf9\xec\xcd\xe2\xd3\x9d\xd6\xeb\x2f\xcf\xe7\x40\x16\x9f\x42\x38\xb8\x77\x3a\x96\xf1\x62\x5e\x5a\x70\xda\xbc\x9e\x94\x40\x3d\xf9\x7d\x89\x4f\xe3\xce\xd6\x93\x1c\xf8\x5e\x09\x1e\xed\x1b\x9f\x96\x5e\x0e\x7e\x0f\xcc\x9f\x85\x35\x2c\x47\x6b\xb8\xa5\x5c\xc0\x90\xaf\x7b\x0e\xce\xfe\x0c\x0e\x8a\x96\xc1\x7d\x95\x85\x71\x26\xc9\x70\xf6\x82\x86\x2c\x3e\xdf\x94\xfb\x2f\x8b\x73\x20\x83\x83\xf9\xf4\x55\x16\xc6\x79\x14\xfb\x50\x1e\x67\x1f\x9e\x3f\xaa\xed\x94\xf0\xe7\x50\xa8\x74\x6d\xb3\x1c\xab\x00\xce\x41\x09\x27\x22\xe2\xd4\x0f\xc9\xc1\x41\x7a\x7c\x17\x5e\xcb\x58\x41\x3d\x9e\x07\x75\x86\x61\xb2\xf5\x38\x1b\x3e\x5b\x8f\xa7\xe5\xc0\x43\xfd\x52\x05\x78\xf8\x82\x7a\xec\x96\xe0\xb3\xf4\x2b\x07\x27\x5b\x8f\xbd\x05\x70\xf2\xf9\x64\xeb\xf1\x5c\xa8\x93\x97\xe7\x93\xad\xc7\x85\x70\xd6\x20\x1c\xec\x53\x45\x9c\x7d\x02\x8e\x0e\xe3\xf4\xa6\x63\xb1\xcb\xe3\x1c\xcc\xc1\xa9\xaa\xca\xc5\x69\x21\x08\xb2\x04\xeb\xcc\x52\x7e\x3f\xfc\x0d\xaf\xfd\x66\xa8\xfd\x87\xcc\x3a\x46\x9e\x33\x21\x58\x46\x06\xdb\xfb\x02\x0f\x6b\x85\xb0\x8f\xb2\xf9\xb0\x8f\xc8\x60\xf7\xfc\x46\xd0\x44\x07\xb6\x12\x87\x00\x2d\xe9\x47\x2e\xfc\x7e\x11\x1e\x7f\x9d\xbb\xaf\xa8\x10\xfc\x0f\x32\xf8\xbd\x9f\xc8\xe9\xbf\xe8\xd0\x5f\x06\xfe\xc0\x27\x72\xfa\xef\x16\x15\x80\xa7\xc6\x61\x1d\xe7\xe1\xf7\x89\xe3\x31\x23\xf8\x4f\x7d\xb1\xcb\xc0\x1f\x14\xe1\xf1\xd7\xe4\x4f\x83\x55\x39\xf0\xeb\xf8\xb7\x7e\xe1\x5a\x55\xe4\xda\x83\x01\xe9\x77\x5b\x1a\xf5\x30\xca\xb2\x87\x1c\x78\xc9\x1e\x4c\x08\x7e\x44\x0e\x3c\xd4\x53\x7a\x3d\x0f\x9f\x63\x0f\x36\xac\x0b\x6a\x09\x3e\x4b\x4f\x73\x70\x44\x7b\x60\x2f\x8a\x93\xcf\x67\x6f\x16\x9f\xb1\x69\x86\xb9\x3c\x9f\x03\x59\x7c\x26\x14\xc0\x59\x83\x70\xb0\x6e\x57\xe4\xd8\x03\x8d\x71\x5e\x4e\x87\x42\x97\xc7\x39\x98\x83\x13\x89\xe4\xe2\xf0\x35\xac\x6a\xb1\xe6\x03\xe3\x92\xef\x85\x38\x3c\x08\x17\xf2\x9e\x60\x71\x4e\x3d\x2e\x17\xbe\x57\x82\x47\xfe\xf3\xde\xc8\xe5\xe0\xf7\x64\x62\xd6\x52\x14\xb3\x0e\x28\x2d\xce\xab\x29\xe5\xe2\xc8\xe2\x76\x5c\xbf\x6b\x8b\x5d\x1e\x67\x2f\x9c\xb3\x9c\xcf\x2f\x4a\xf3\x6b\x7e\xb9\x38\x07\x32\x38\x98\xcf\xf3\xb1\x7c\x9c\x75\xfd\x67\x15\xb3\xe0\x5a\x46\x88\xda\x59\x19\x2d\x46\x51\x72\x84\x20\x09\x8f\x47\xa3\x91\xe9\x70\x0e\x6c\xaf\x04\x5b\x9a\x07\x8b\xea\x39\x67\xb1\x8e\xd4\x82\xb3\x92\xfe\xe2\xb8\xb5\x02\x06\x95\x12\xb4\x18\xb7\x3e\x90\x07\xbf\x5f\x84\xaf\x2c\x04\x8f\xe8\xef\x10\xe0\x77\x48\x7a\x7b\x69\xfa\xd9\xf0\x07\x2e\x49\xff\x4a\x28\x4b\x7e\xcf\x5f\x2b\xe8\xd1\x39\x21\xae\x28\x46\xf9\x62\xb1\xd3\x96\x7d\x57\x2d\x17\xbe\x97\xf8\x5c\x80\x47\xf7\x0c\x36\x05\x2e\x07\xbf\x87\xf8\x83\xb8\xd7\x87\x90\xc7\x19\x13\x12\x30\x64\x6b\x95\x8b\xb3\x3f\x83\x83\x37\xfb\x39\x91\xc2\x38\xa3\x64\x38\x7b\x61\x84\x2f\xe7\xf3\x4a\xc8\x75\x59\x9c\x03\x19\x1c\xcc\xe7\xc3\x48\x61\x9c\x9b\xb1\xff\x5c\x2b\xc4\x21\xa4\x88\x53\x8c\x70\xde\x89\x25\x0b\xe2\xac\x95\xe1\x1c\xcc\xc4\x55\x3e\x1c\x88\x54\x0d\xc8\xc3\x41\x71\x45\x1f\x5e\xc7\x41\x38\x57\x91\xf9\x51\x16\xf9\xd1\x05\x69\xb5\x9a\xa2\x32\x7a\x88\xf6\xee\x32\x1e\x3e\xc7\x27\x16\x61\x1f\xb2\x20\x6d\x30\x50\x54\xfe\x7e\x7f\x9b\x80\xf3\xeb\x2c\xff\x26\xe2\x68\xb5\xb9\x38\xdb\x11\x1f\xec\xab\x44\x3e\x7c\x0e\x25\xfa\x44\xbb\x34\xae\x2c\x5f\xc5\xfc\x8c\xe5\xbc\x41\x88\x75\xbf\x14\x74\xa6\x0e\xed\xc8\x75\x71\xb7\x3e\xaf\xa6\x2a\x87\xef\x05\xbd\x02\x3c\x4c\xcb\xc1\x6d\x8d\x97\x83\xdf\x83\xe1\xb1\x7c\x07\x20\xf9\xce\x18\x20\x60\xe4\x7c\x6b\x90\xe3\xec\xcf\xe0\x0c\x44\x38\x2b\x06\x5f\x1e\x67\x2f\xf8\x21\x8b\xcf\xbe\x01\xd5\x97\xc5\x39\x90\xc1\xc1\x7c\x5e\x1a\x7c\x11\x1c\xac\x2f\x1b\x04\x1d\xfb\x32\x2b\xff\x3a\x3e\x74\xc2\x65\x71\x0e\x66\x70\x1a\x30\xce\x88\x49\x79\x38\x28\xd6\xbd\x09\xad\x3f\x35\x93\x78\x91\xc8\xf2\x8a\xa0\x86\x00\x44\x34\x1a\x0a\xc9\x6b\x07\xdb\xf3\xe0\x25\xcf\x08\x12\x05\xe0\x51\x0c\x1a\xe4\xe1\xc9\xf6\xac\xbd\x3d\x89\x75\xe5\xfd\xb4\x88\x91\xad\x93\xd9\x38\xa2\x1e\x37\x5e\x14\x07\xe5\x6c\x87\x79\x1c\xf0\x27\xb9\x8f\xe4\x19\x11\xa5\xa5\x32\x0c\x21\x5f\xcb\x86\x3f\x20\xc2\x37\x16\x82\xdf\x02\xe1\x0f\x22\x9d\x87\xf0\x5f\xf2\x7b\xfa\xcf\xfc\x98\xaa\xd1\x98\x38\x90\x1e\x30\x20\x77\x4c\xf9\x38\x07\x05\x9c\x84\x80\x33\x78\x70\x2e\x0e\x5f\x8f\x52\x0a\x75\x22\x85\xf2\xd8\x74\xfe\xcb\x06\xae\xf4\x1f\x4c\xc7\xaa\x0a\xd6\xd6\x44\x78\x25\xd5\x04\xa6\x12\x99\xef\xef\xf3\xcb\x2b\x73\xe0\xf9\xda\x81\x52\xaa\x1d\x1c\x8b\x13\x52\x25\xa3\xbc\xac\x42\x23\xaf\xfb\x66\xc3\x22\xda\x8d\x44\x06\xfa\x4c\x69\x2c\xb7\x8e\x81\x73\x47\xa5\x94\x6b\x1d\x23\xb6\x89\x75\x77\x08\x3f\xcc\x1f\x2a\x98\x9f\x4a\xf0\x90\x7e\x8f\x0c\xfe\x27\x5f\x30\x07\x1e\xc6\xad\xe0\x05\x0c\xbf\x94\xa7\xdf\xbf\x40\x80\x47\x19\xc0\x04\xbd\x89\x51\xe7\xc2\x93\x0b\x25\x78\x05\xd5\x54\x9e\x81\x7e\x57\x67\x64\x72\xbe\xb1\xc0\x78\x42\x29\xc5\x13\xc7\x88\x87\x04\x39\xa2\x58\x6a\x90\x37\x50\x30\x36\x92\xe0\xe1\xd8\xd7\xc9\xe0\xff\xab\xd8\x9f\x03\xcf\xef\x67\x4a\xc9\xff\x1f\x23\x6e\x12\xc6\x8e\xf6\xd8\x80\xcb\x53\x70\xcf\x94\xe0\x33\xeb\x8a\xe1\x9f\x72\xba\x6d\x85\xfc\x9f\x52\xb2\xfd\x63\x60\x94\x00\x8f\xfc\x2b\x55\x9d\x28\xe8\x2f\x25\x78\xaa\x89\x94\xc3\xbf\x12\xaf\xcd\x81\x1f\x09\xd7\x4a\xaa\x93\x9a\xa2\x7c\x8d\x18\xea\xcf\x3d\xe3\x89\xc2\x95\xe2\x02\x38\xb8\x4e\x2c\xc3\xc9\xab\x16\x17\xc0\xd9\x23\xe3\x73\x89\x8a\x71\xc1\x31\xee\x97\xe1\x5e\xb4\x72\x5c\x00\x0f\xd7\x8d\xe5\x78\x85\xaa\xc7\x05\xf0\x0e\xe4\xe2\x15\xaa\x20\x8b\x78\x62\x2d\x18\xe2\xed\xcb\x1d\x67\xa1\x2a\x72\x01\xbc\x83\xb9\x78\x85\x2a\xc9\x52\x7f\x17\xa1\x36\x6c\x8a\xa0\x3a\x32\xd4\x90\x7b\x80\x82\xb8\x44\x3d\x39\x07\xa7\xb7\x00\x4e\x5e\x5d\x99\x9b\x26\xaf\xdf\x42\xac\x3d\x58\x17\xef\x81\x61\xea\x65\x6b\xbf\x79\xb8\xfb\x65\xb8\x97\xa8\x33\xe7\xe1\xed\xfd\x3f\xf0\x3c\xf0\xbf\xe2\xb9\x1d\xe1\x65\x6a\xc8\x10\x6f\x5f\x0e\xcf\x4b\xd4\x9f\xf3\x70\x0f\xe6\xe0\x5e\xbc\x0e\xad\x95\xd7\xe6\x90\x0d\xa2\x5a\x16\xc2\xed\x8f\xc8\xfc\x66\x7e\xdd\x30\x17\xaf\x37\x0f\xaf\x70\xfd\x30\x17\x0f\xd7\x0f\x25\xbc\x4b\xd7\x11\x73\x71\xf7\xe7\xe3\x5e\xb4\x9e\xa8\x95\xd7\x06\x91\x3d\xa2\xda\x60\x01\xbe\x85\xea\x8a\xb9\xb8\x07\xf2\x71\x2f\x5a\x5f\xd4\xca\x6b\x85\xc8\x2e\xb3\xe4\x74\xe9\x3a\x63\x2e\xee\xc1\x3c\xdc\x4b\xd4\x1b\xa1\x4e\xc8\xea\x87\x68\x65\x51\x4c\x85\xed\xed\x9f\x97\xaa\x3b\xe6\xe1\xf5\xe6\xe2\x15\xae\x3f\x72\xd3\xe4\x35\x3e\x64\xa7\xdf\x61\x2c\x6a\x3d\x71\xd9\x3a\x64\x1e\xee\xfe\x1c\xdc\x4b\xd4\x23\xf3\x70\xf7\x16\xe4\x5b\xb0\x2e\x99\x87\x7b\xa0\x20\xdf\x82\xf5\x49\x84\x9b\xa9\x35\x22\x7b\xcd\xc1\xbd\x44\x9d\x32\x0f\xf7\xe0\x45\x70\xf3\xeb\x95\xc3\xb8\x69\x99\xb8\x1f\xdb\xeb\x97\xbc\x4e\xa0\xac\xfc\x52\xb9\x4f\x0e\x1e\xce\x7d\xb2\xf0\x2e\x92\x03\xe5\xe0\xed\xc9\xc2\xbb\x4c\x2e\x94\x83\xbb\x3f\x1f\xf7\xe2\x39\x51\x0e\x2e\xce\x89\x0a\xf0\x2d\x98\x1b\xe5\xe0\x1e\xc8\xc7\xbd\x78\x8e\x84\x70\xc5\x7c\x07\xdb\xeb\x97\xb9\xb8\x17\xcf\x95\x72\x70\x0f\xe6\xe3\x5e\x3c\x67\x82\x76\x27\xcb\x81\x20\xf6\x3d\xa4\xf2\x7f\x93\x3b\xe5\xe1\x49\xf6\x8a\xf0\x2f\x9e\x43\x41\x1d\x94\xe5\x43\x32\x7b\xdd\x4d\x5c\x36\x97\xca\xc3\xdd\x9f\x83\x7b\x89\x9c\x8a\x9b\x26\xcf\x91\x64\xf6\x9a\x20\x2e\x99\x5b\xe5\xe1\x1d\xc8\xc5\x2b\x9c\x63\x41\x3c\x59\xbe\x84\xec\xf4\xe7\x0c\xde\x65\x72\xad\x3c\xdc\x83\x39\xb8\x97\xc9\xb9\xd0\x79\x6b\x3e\x87\x22\x1f\x20\x3e\x12\x62\x79\xb4\xcd\x14\x57\xd6\x15\xca\xb9\xd0\x5d\x73\x01\x7e\x27\x21\xdc\xcd\xc3\x07\xca\x82\xb1\xdc\x9c\x8b\x8f\x13\x85\x1c\x0d\x8e\x0c\xe6\x74\x42\xd4\x76\x91\xcc\x4e\xc4\x41\x67\xb3\x84\x3c\x10\x41\xe3\x13\x9c\xc5\xe9\x3a\x11\x32\x9f\x76\x94\xcf\x13\x72\xe2\xf2\xac\x2c\x50\x1a\xff\xab\xd2\xf8\x1f\x91\xc6\x5f\x0b\xa1\xa3\xb5\x83\x0b\x8d\x5f\x84\xc7\x3d\x27\xfe\x91\xc5\x23\x0f\x4b\x3c\x8f\x20\x9e\x77\x37\x2b\xf9\xf3\xee\x68\xbe\x06\x7c\xbf\x65\x4c\xda\xec\x94\xdf\x6f\x11\xe0\xf7\x48\xf7\x61\x76\x82\xc3\x60\x02\x82\x37\x62\x78\x5f\xda\x68\x2e\x00\xaf\x14\xe1\x61\x2e\x38\x16\xef\x78\xa4\x89\x20\x8f\x70\x8f\xa7\x2d\x16\x69\xc7\x23\xf2\xe1\x61\x2e\x78\x54\x82\xee\x37\xa6\xcd\x66\xd9\xfe\x98\xdb\x0f\x51\x88\x7a\xb5\x2f\x92\x0e\xa7\x45\x18\x04\xfc\x05\x40\x17\x3d\x9a\x9c\xc3\xf4\x12\x1a\xc2\x97\xd2\xab\xd4\x6a\x82\x21\xb4\x3a\x35\x83\x92\xd8\x96\xa2\xde\x84\xfc\x21\x07\xa5\x01\x28\x43\xcd\x20\x19\x4a\x92\x73\xdc\xfa\x9a\xc4\xb5\x03\x12\x4c\x67\x84\xe9\xdd\x3e\x7c\xe3\xc0\xe6\x45\x1e\xd4\x2f\x09\x10\x7f\xe6\xa6\x81\x63\xfd\x5b\xf0\xfb\x16\x7a\x03\x41\x68\x34\xb4\xc9\x4c\x2a\x7b\x0c\x66\xc2\xf4\x79\x51\x6f\x93\x9c\x60\xd6\x53\x86\x09\x25\x58\x56\x62\x0c\xb8\xaa\xa2\xf5\x8d\x6a\xc7\x0d\x2c\xf7\x6d\xb1\x62\x85\x76\x60\x22\x50\x79\xf5\x52\x38\xce\xe9\xf4\x38\xb2\x9b\x79\x9d\x50\xa3\x1e\xaa\x4a\x95\x8a\xd0\x68\x55\x74\xce\x28\xd1\x18\x15\xe2\x10\xbb\x1d\xde\xd9\xd7\x0e\x18\xc0\x74\x06\x99\xd7\xaf\xbb\xeb\xaa\xe6\xe5\x9e\xe7\xd1\xf8\xda\xe8\x17\xa8\x49\xcc\xab\x84\x83\xf0\xa6\x74\x6a\xa7\xcd\xe6\xb2\x32\xba\x1e\xb3\x5a\xea\xa2\xc9\x37\x9c\x45\x6d\xab\xab\x48\xd4\xc2\x3e\x84\x5a\xf7\x7a\x49\x38\xd4\x84\x81\x24\x27\x97\x8f\x1b\x99\xf2\x25\x87\xda\x66\x96\xf5\x74\x54\x8c\x1f\xd1\xec\x5d\x18\x99\x15\x1c\x3a\x93\x7e\x21\x5c\x19\x6e\x6e\xba\x6d\x33\xfc\x63\xed\x92\x45\xe8\x5e\x36\x45\xec\xa5\xdf\xa0\x66\x2a\x8e\xc1\x9f\x94\x84\x97\x68\x4c\x15\x99\x15\x34\xed\x83\xf1\x01\xe9\xf1\xf8\x5d\x7a\xb7\xad\xc7\x44\xa8\x80\x0a\x30\x04\x4d\xc4\x13\x9f\xd5\x7e\xde\x55\x5b\xf4\x5e\x6d\x53\xd6\xa3\x87\x68\x52\x42\x4b\xd8\x42\x23\x02\xa4\x07\xb5\x9e\xfd\xba\xe4\xf1\x12\x10\x8b\x8c\x68\x19\xe0\x49\x0c\xb4\x4c\x8e\xae\x1e\x57\x3a\xa2\xa5\xc9\x3d\xb3\x64\x72\x74\x25\xfd\xe6\x91\x23\x00\xfe\xa3\x09\x96\x06\x1b\xeb\xb6\xae\x84\x7f\x2c\xbb\x61\x45\x26\xbe\x55\x4a\xf1\x1e\xae\x75\xe4\xc5\xe2\xf9\x35\x0f\x2d\xff\x5e\xba\x80\x27\xc0\xe7\xd3\xe3\x6b\x21\x79\xf4\xf2\x6b\x22\xa8\x86\x52\x87\x6d\x73\x31\x6f\xcb\x80\x14\xe0\xa3\x10\xfe\xfe\x68\x6d\x01\xfe\x12\x3c\xbe\x33\x4e\xe6\xf0\x29\x8c\x97\x26\x08\xc5\xbd\x0a\x25\x3a\xdf\x20\xd4\xa2\x45\x8b\x03\x46\x14\x63\xda\xd2\x26\x93\xfc\x9b\xde\x93\x39\xf0\xa2\xc5\xf1\xd0\x9b\xd2\x46\xa3\x04\x2d\xd1\xff\x11\xc3\xc7\x0a\xd2\x2f\x82\xf4\xe5\x31\xec\x93\x39\xf0\xd9\xf4\x37\x42\xfa\x59\xf6\x8f\xfb\x02\xca\xfa\xb6\x41\x9b\x46\xbd\x9c\xf0\xd9\xd4\x45\x69\xbb\xd8\x71\x8c\x24\xb6\x40\x9b\xfe\x04\xda\x34\x43\x98\x88\x44\xca\xac\x55\x18\xa1\xe3\x61\x18\x8b\x91\x34\x92\x5a\x86\x51\xa0\xcc\xcc\xe9\x69\x55\x68\x89\x78\x6f\xac\x36\x6e\x46\x8f\x73\x49\x5d\xd0\xb1\x15\x85\xa8\x64\x22\x20\xb3\xf7\x4f\xa8\x55\xdb\xa8\xaf\xb9\x0f\x1d\x96\xc6\xe4\xe6\xa6\x94\x6a\x5a\x84\x7e\x4e\x07\xbc\x86\x55\xdd\xd7\x35\x0e\x9a\x51\x8e\xda\x18\xf2\x7c\x29\xb7\xc0\x37\x99\xb2\x1a\x10\x63\xda\x0c\x8d\xd7\x62\xa4\x8c\x94\x16\x80\x4b\x71\x6e\x12\x1e\x8a\x4b\x28\xa9\x50\x92\x92\xf1\xae\xff\x9a\xfa\x71\x15\xe5\xc9\xb0\x66\x7a\x0d\xdc\x57\x3a\xe0\x97\x31\x27\x89\xed\xf4\x0c\x6a\xbb\xe2\x6b\xd4\x03\x9d\x18\x93\x8a\x59\x55\x04\xe5\x0b\xf9\x4a\xdc\x46\x8d\xd7\x3b\xd7\xbe\xc2\xde\x63\xff\xde\x4e\x13\x76\x60\xd7\xf4\x58\x2c\x1a\x8d\x52\x69\x52\xfb\xd5\xd5\x6a\x4a\x0d\x4d\xaf\x77\x65\x53\xbc\x36\x9e\x88\x17\x99\xde\xeb\x5a\x89\x47\x25\x3c\xba\x22\x3a\xbd\x06\x38\x8e\x70\xae\xf5\x35\x60\x87\x30\xcc\x61\xae\x2b\xbf\xb6\xdb\xd8\x19\x04\xfa\xf2\x09\xa3\x86\xfa\x92\x29\xdb\xcc\xe8\xc6\xe9\x15\x6d\xad\x43\xbc\x0d\x83\xac\xb3\x7c\xa9\x19\xd0\x01\x4d\x59\x5a\x73\xe5\xe4\xe7\x2b\x8a\x4b\x8a\xeb\x9a\x6e\x5a\xeb\x0b\xfb\xea\x1b\xbb\xe7\x26\xe1\x9a\xc2\x9d\x9d\xec\xc5\xfb\x36\xae\xef\x91\x0f\xbc\xc0\x6b\xb0\x0e\x7d\xb5\x32\xda\xf3\xbe\xf1\xdf\x8b\xf7\x6c\x1e\x76\xe7\xdb\x3c\xac\x1e\xc2\xde\xa8\x37\xe6\xc1\x3e\xaa\xd4\xf3\xb0\xa8\x17\xde\x5b\xbc\x3e\x5e\x07\xf7\x81\x64\x2a\x4c\x55\x3b\x96\x3b\x48\x9f\x23\xee\x20\x0f\x38\x3e\x70\x90\x8f\x3a\x80\xd1\x01\x1c\x24\xba\xc9\x4c\xc1\xb0\xc6\x64\x54\xf1\xdf\xcf\x71\xc8\x88\x7b\x79\x48\xbd\x83\xc8\xc3\x72\xba\xc7\x70\xe5\x8d\x58\xfb\x7f\xa3\x8b\xee\x56\x93\x7f\xc3\x36\xcd\xcf\xed\x91\xd7\xf8\xb9\xd9\xe0\xdc\xb6\xd8\x7c\x79\x73\xeb\x57\x1c\x93\xbe\xfd\xdf\xf7\x98\xd8\xe5\xa1\x20\x17\x8c\x83\x7a\x0a\x8e\xc7\x7b\x39\xb6\x34\x35\x5d\xcb\xd3\xa7\x99\x08\x78\x5b\x69\xc8\xdc\xac\xe1\x61\xc9\x7f\xe3\x9e\x3d\x15\x42\x6c\x54\x29\xf4\xb1\x64\x20\xf4\x1e\xa9\x7f\x9c\xcc\xaf\x50\x13\xb0\x1d\x57\xe4\xda\xbd\x12\x59\xb2\x2a\xad\x52\xe5\xf8\x95\x2c\x78\xc9\xee\x31\xf4\xfc\xb4\x52\x29\xf3\x2b\x50\xb7\x9f\x93\xec\xd9\x0c\xed\xd9\xa2\x55\xa8\x0d\x06\x05\x45\x31\x16\xc6\xaa\x22\x55\x64\x96\x41\xbf\x1f\xab\x15\x8d\x2a\xf3\x84\x99\x60\xcf\x21\xa5\xcd\x11\x42\xef\x2d\x64\x0c\x3a\x32\x8d\x6a\xdc\x1c\x56\xf8\x78\x73\x7e\xc3\x37\x70\xe1\x90\x09\xc5\x2d\xff\x41\x88\x7c\x05\x7b\x36\x13\x35\x29\xb3\x5a\x65\xa0\x15\x06\xca\x02\x80\x95\x52\x51\x2a\x60\x16\xd8\x9a\x79\x6b\xce\x62\x2b\xb3\x64\x19\x57\xc1\x94\x45\xa6\xa2\x21\x67\xd8\x66\xec\x58\x87\x6f\x5c\xc7\x15\x04\xa5\xb6\xab\x09\x2a\x18\x09\x46\x2d\x5e\x7d\x30\x38\xd7\xb5\xc2\xd5\xe3\xfa\xde\x45\x13\x2e\xe0\xd2\xf7\xb0\xac\x5e\x4f\xc2\x08\xc8\x4f\x54\xe3\x6d\xf6\xe2\xb6\x2c\x89\x02\xf5\x3c\x0f\xe1\x90\xe3\x62\x26\x1d\xec\x24\x55\xc1\x6b\xbd\x7a\xc7\xa5\x4c\xfa\x79\x9f\x6d\x4c\xf3\xe0\x21\xf5\x83\xaf\xcb\xb5\xea\x4c\xed\x1b\xdb\xf5\x5a\x21\x1e\xff\x8e\xc8\x9c\xdf\xde\xe8\x0e\x16\xaa\x95\x63\xdb\x5e\x2b\xe8\x9c\x70\x8f\x1d\xb8\x20\xfc\x15\xae\xdc\x5a\x39\x86\xc7\x76\xb8\x16\xf7\x5e\x5e\x82\xfa\x30\xe2\x9a\xfc\x6d\xa2\x25\x86\x96\x87\x48\x5f\x28\x1e\x22\x0f\x84\x3e\x08\x91\x8f\x86\x80\x31\x04\x42\x24\x6a\x5c\x82\x6c\xc4\x23\x50\xcc\xb6\xc4\x8b\xd0\xfe\x83\x50\xbf\xdf\xf5\x7f\xa5\xdd\xff\x3e\xdc\xbb\x3b\x70\xae\x7c\x4d\xf6\x79\x41\x7c\x7e\xe3\x54\x89\xcf\x90\xdd\x1b\x2c\x17\x3e\x73\xde\x03\xd5\xa2\x5e\x2d\xcd\x81\x17\xe4\xf8\xaa\x24\xc7\x47\xd0\xd8\xa5\x73\xe3\x6d\xfe\x58\xc1\x6f\x14\xc7\xa4\x6f\x1a\xf7\x11\xe8\x8c\x2f\xef\x4d\x0a\xce\x46\xc0\xfb\x1d\x3e\xcf\x7f\x5a\x3a\x6f\x4f\x83\xff\x10\xf8\xa0\x03\xfd\x56\x9d\x35\xfb\x3c\xbb\x00\xbf\x4f\x3a\xff\xbe\x13\xf4\x0a\x3e\x45\x03\xe1\xa3\x1a\x5d\x0e\xfc\x9d\xe8\xbb\x39\xf6\x11\x83\x24\x9f\x12\xe5\x7d\x8a\x8e\xaf\xa3\xe9\xf5\xf2\xef\xe6\x4b\x08\x42\xd9\x2d\xc0\xdf\xc9\xfb\x94\x2d\x19\x68\x74\x0a\x55\x82\x96\xbe\x81\x9a\x71\x2d\x2a\x91\x73\xbe\x89\xf4\xa1\x7c\x62\x7a\xda\x6a\x95\xce\x87\x40\xd3\x9a\x42\x7f\x48\x4d\x64\xfe\x04\x7f\x42\xef\x18\x94\xa7\xac\x7a\xad\x56\xc9\x50\x06\x40\x51\x46\x68\x81\xea\x1e\x0d\x81\x1a\xfd\x27\xd0\x8b\x06\xb2\x27\x25\x50\xcf\xff\x64\x82\xc1\x0e\x08\x7a\x83\x04\x15\x7b\xbe\xe4\x79\xee\x07\x72\xcd\x6d\xe4\xa1\xf3\xf0\x47\xfa\xc3\x97\x9f\xd7\x03\xa5\x8e\xfb\x2b\x6a\x39\x52\x80\x8f\x45\xcf\xa8\xb4\x5a\xcc\x06\xce\x80\xee\xd1\x22\x23\x7f\xf3\x4d\x19\x9b\x26\x18\x3b\xd4\xf2\x7c\xc2\xd8\xe5\x28\x25\x3e\x4f\x1c\x22\xff\xbe\x86\x6c\xe6\xf9\x74\xea\xb8\x7f\xe9\xf5\x2f\xc3\x70\x64\x31\xfd\x3a\x39\x4e\xa1\x84\x7e\xcd\xfa\x22\x0d\x53\x06\xe1\x89\x07\x9c\x45\xa0\x07\x59\xd0\xfb\x0e\xe0\xe7\xbb\x94\x1f\xe8\x95\xf4\xeb\xc0\x1f\xe6\xfe\x10\x90\xd5\x79\x94\x52\xbd\xe5\x18\x58\x24\xc4\x61\x3b\x2e\xfd\x9d\x0a\xe1\xd1\x13\x05\x3c\x01\x3e\x9f\x1e\xd5\x44\x4e\x2c\x40\x2f\xff\x3b\x16\xfe\xee\x85\x75\x7c\x83\x10\x2f\x0b\x7d\x93\x41\x12\xf5\xc9\x49\x0e\x2d\xc4\x5f\x84\xc7\xf1\xf2\x17\x39\x7c\x0a\xe3\xa5\xfb\xcf\x2a\x4b\xb0\x4e\xd5\x02\x79\x86\x8a\xbe\x9d\x40\x25\x21\xfc\xfe\x8c\x86\x20\xf8\xd1\xe8\xbc\x11\x84\x17\xce\x1b\x51\x4d\xfd\x73\x65\x1a\xb5\x29\x2d\x3b\x71\x84\xe1\xdf\x82\x3a\xcb\x20\xfa\xd4\x4c\xd4\x19\x1d\xd3\xef\xe2\x75\xbc\x9c\xc0\xf5\x9c\x58\x4c\xaa\x22\x21\xfa\x50\x67\xeb\x10\x7d\x6a\xe6\x7c\x39\x7d\x1e\x7a\x44\x3a\xb7\xe6\xe4\x83\xf3\xfe\x10\xdd\x21\xa3\x66\x0a\xf3\x1d\x27\xc6\xcb\x4f\xa6\x6b\x62\x1e\xfe\xc3\x0f\x00\x9d\xf4\xb3\xe4\x97\x30\xb7\x44\xfa\x40\x28\x28\xa5\xa8\x0f\x50\xbd\x90\x3e\xa0\x77\x39\x18\x08\x94\xfe\x80\xe1\xfe\x40\x3f\x6b\x03\x54\xf1\xcf\x38\x77\x5e\x0a\xf7\xe5\x29\x70\x7f\xd4\x11\x81\x94\x01\xa6\x76\xa4\x9a\x50\x1b\xf4\xca\x1e\x94\xbd\xb4\xd4\x16\xf5\x66\x5e\xac\xc6\x1b\x8f\x82\xb5\x09\x1b\x0f\x39\x25\xd2\x49\x97\x2f\x0f\x68\xe1\xee\xfa\xba\xcd\x39\x72\xe2\xc8\x49\xd5\xf5\xa8\x07\x23\xe8\x3f\xc9\x9d\x23\xca\x61\x84\x41\x11\xba\x97\x09\x12\xa0\x86\x4c\xf1\x96\x9a\x6a\xab\x39\x64\x2e\x9f\xc2\x28\xff\xf5\x8d\xc2\x89\xe1\xfc\x10\xee\x4b\xe6\x26\xc2\x40\x44\x52\x06\x03\x0c\xeb\x55\x0c\x49\x51\x6a\x25\xa5\xa7\x5e\x46\xf9\x03\xc4\xe4\xdf\x95\x12\x77\x3e\x6b\xc8\xac\x8c\x26\xa3\x49\x47\xd2\xa1\x74\x28\xa3\xe5\x53\x36\x27\x9f\x7e\x5a\xf8\x67\x33\x77\x8e\xe9\xec\x49\x3e\xf5\x64\xe3\x33\xcf\x34\x3e\xf9\x54\xb2\x07\xd7\x06\xfa\xff\x9b\x3b\x07\x0e\x43\x1e\x1a\xc2\xf6\x22\x0d\x83\x12\x0d\xa5\x38\x82\xe9\xf6\x0a\xc9\x76\x34\x19\x82\xe3\x0a\x44\x93\xe0\xf0\x17\xc9\x1b\xff\xd9\x0e\xc6\xdc\x98\xa4\x9f\xfe\x34\xb9\xf1\xe7\xab\x98\xaf\x36\x36\x42\x1a\xdc\x38\x38\xce\x52\x81\x06\xa9\xd1\x30\x4a\x0a\xf0\x34\xde\x6c\x12\x46\x15\x42\x0f\x45\x38\x94\x81\xd2\xf6\x7f\xde\x98\xfc\x02\xd2\x01\x63\xe0\x70\xee\xd9\x98\xfc\xf4\xb3\xc6\x8d\x78\x0f\xf8\x3b\x78\x83\xde\x4c\x8e\xb3\x28\x94\x9f\xe3\x71\x09\xff\x0e\x65\x54\x93\x0a\x92\x30\x7b\x06\xc4\xcb\x9d\x46\xe0\x03\x2d\x60\x22\xa0\xe3\xf0\x8f\xe5\xe0\x00\xf8\x02\x30\x20\x15\x89\xb5\x02\x22\x1e\xeb\x5a\x19\x13\x1e\x24\xa3\x92\x01\xa5\xbe\x88\x5e\xe5\x06\x6f\xdc\x7c\x33\x4f\x4b\xa5\xff\x3f\xd1\x52\x11\xff\xbf\xd3\x82\xba\x0b\x43\x7b\xf2\x00\xf4\xcf\x0a\x70\x03\x96\xc1\x5c\x4e\x47\xfd\xdc\xdf\x0e\x6d\x71\x28\xfc\x77\x85\x59\x81\xfe\x24\x06\xa6\x62\xc4\x1c\x48\x95\xfc\x00\xc0\xdf\x37\x03\x72\x22\x98\x03\x48\xf8\x33\xb3\x99\x21\x27\x32\x73\x18\xb2\x85\x01\x3e\x26\xce\x90\x46\x06\x30\x04\xdf\x1a\x95\xdf\x90\xf9\xfa\x0f\xf1\x36\x75\x04\x7c\xcb\x6c\x21\xd4\x40\x79\x98\xd0\x68\xb5\x47\xfa\x7b\x52\xc6\xeb\x7b\x5a\xbf\xd6\x82\x37\xb5\x1f\x6b\xc9\x43\x5a\x80\xfe\xee\xc5\xd5\x6b\x5b\xe7\xf1\x3f\xa6\xac\xcb\x57\xb5\xda\x61\xe4\xac\x05\x57\x9d\xd2\xfe\xa0\x25\x3f\x12\xfe\xde\xbc\x70\x71\xeb\xb5\xda\x9b\xb4\xe4\x14\xed\x7c\x2d\x39\x54\xf8\x5b\x4f\xd7\x5c\x48\xec\x27\x2d\x99\xd6\x22\x82\xd4\x13\x5a\x70\xa3\x76\x97\x96\x5c\x05\xf3\x41\x04\x70\x78\xe2\xe4\x56\xf8\xe7\xb1\xc3\x63\x27\xb4\x62\x04\x76\xe8\x98\xd6\x3a\xed\x70\x2d\x49\x68\x4d\x5a\xbf\x96\x1a\x4c\xa6\x30\xa9\x63\x87\x9b\x06\xf1\x90\xd5\xf5\xf8\xcf\x54\x49\xb0\xb4\x75\x39\xdc\xd8\xb5\xd5\xda\x94\x96\x22\xb4\x77\x6a\x77\x6b\xbf\xd4\x7e\xaf\x85\x4a\xa6\x56\x3d\x32\x93\x56\x3f\x3d\x93\xa6\x88\x96\x58\x0c\xcc\x99\x0d\x23\x90\x58\x2c\xb6\x0a\xfe\xd0\x05\xff\x9c\xb3\x12\xfd\x8a\xad\x5a\xb5\x0a\xfe\x1f\xfd\x15\xfc\x1f\xfc\x1d\x17\x7e\xac\x49\x98\x77\x26\x14\xca\x84\xf2\x6d\x8f\x65\x58\xe3\xba\x75\xae\xce\x08\x75\xe4\xee\xb9\x77\x8f\xd8\xbe\xf9\x0d\x2c\xb3\x63\x50\x66\x5f\x61\x99\xc5\x0e\xd3\x5a\x0d\x1c\x4b\x2a\x65\x80\x32\x43\xf3\x3b\xa5\xa5\x0a\x88\x6c\x5c\x46\x64\x5f\x69\xcf\x4b\xb2\xd8\xab\x05\x77\x6a\xc1\x56\x2d\x40\x12\x5b\xad\xa5\xa0\xcc\xea\xb4\x80\xd4\x5a\xb4\x41\x2d\x85\x65\x7b\x52\x0b\x0e\x69\x5f\xd7\x92\x8f\x69\xc1\x2a\xed\x56\xed\xdd\x5a\x8a\x27\xa8\x83\x52\xa3\xb5\x36\x2d\xf9\x83\xc0\xc1\x32\x6c\x6c\x6b\x89\x76\x0a\x2f\x35\x72\xf0\x8d\xbc\xc8\x52\xf6\xba\x41\xad\x2b\x78\xfa\x90\x29\x22\x49\xdd\x29\xfc\x27\x77\x71\xa0\xb5\x1a\x8d\xc9\xa6\x2d\xd1\x52\x37\x6a\xf9\xd1\xd3\x2b\xd0\x00\x30\xaa\xce\xd8\x6a\xd4\xfa\xb4\x71\x2d\xa5\xa6\x18\xfa\x91\x99\x0c\xf1\xf4\x4c\x46\x92\x67\x6c\x0e\x8a\xea\x62\xa8\xcf\x6e\x8c\x17\xe1\x4a\x41\xac\xab\xc4\x5f\xa2\x60\x79\xb9\x02\x9c\x46\xa3\x97\x66\xc1\xc0\x0d\x6b\x8b\xa6\x47\xde\xf0\x58\x86\x52\x47\x76\x5c\xff\x9b\xbb\xe6\xdc\x8b\xed\xfa\x67\xee\x02\xf0\x10\xbf\x81\x3b\xbf\x33\xa5\x83\x82\x45\x0c\x69\x06\x2e\x24\xb4\x94\x18\x72\xa6\xc8\x5f\x88\x44\xd6\x88\x34\x86\x70\x17\x10\x8d\xae\xfb\xf0\xda\xf4\xc1\xb5\x39\x0b\xd7\x46\x47\x38\x52\x6a\x1d\x0c\x21\x0c\xa4\x52\x07\x07\xfd\x5e\x93\x54\xd8\xcb\x78\xe2\x86\x24\x38\x1b\x99\xae\xac\xdd\x10\x50\x95\x30\x5b\x7e\x13\x0e\xcf\x9e\xd5\x36\xcd\x37\xe2\x28\xdc\xdb\x76\x51\x47\x28\x80\xd6\x98\xb0\x12\xf1\x94\x13\x7a\x54\x13\x43\x68\x58\x9b\x59\x85\x54\xcb\xaa\x46\xca\x65\x40\xda\x95\x90\x5e\xec\x47\xde\x1e\x0a\x06\xed\x18\xa2\x06\x05\xa4\x9f\xc0\x97\x70\xa4\x8d\xeb\xaf\x73\x4d\x8f\xf4\x9d\x97\xeb\x55\xd7\x7d\xc3\x6f\xde\xf8\x46\x46\xbd\x20\xef\x9b\xa9\x23\xe4\x4f\x3c\x6f\xb0\x20\x65\xef\xa2\xaf\xa2\xff\x4a\xf7\xd1\xf4\x18\x1a\xe8\x68\xa0\xa5\x0c\x34\x6b\x63\x91\xd2\xcd\xda\xd8\xd3\x3a\x9c\x05\x11\xb6\x81\x25\x69\x16\x9c\x67\xc1\xc7\xec\x29\x96\x7c\x9d\x05\xbb\xd8\xc7\xd8\x34\x4b\xdd\xc4\x82\xf9\xec\x6a\x96\x1c\xca\xb6\xb3\x64\x1d\x82\x04\x36\x16\x90\x2c\xb8\x12\x01\xfe\xc0\x52\x2f\xb2\x6f\xb1\xe4\x63\x2c\xb8\x9b\x05\x2b\xd8\x1e\x1e\x70\x1e\x4b\x41\x50\x16\xe9\x40\x68\xda\x8c\xd6\xaf\x58\x90\x66\xdf\x64\x3f\x66\xa9\x27\x10\x5d\xb0\x95\x05\x53\x58\x44\x95\x6a\x60\x47\xb2\x24\x8b\xb4\xef\x9a\x51\x63\x5a\xef\x83\xa4\x4e\xb2\x5f\xb3\xf4\x6a\x16\xcc\x63\x41\x1d\x3b\x9c\x9d\xc2\x52\x0a\xd6\xce\x46\x58\xaa\xf1\x13\x16\xbc\x85\x08\x01\xf4\x17\x0d\x6c\x07\x7b\x13\x7b\x1f\xfb\x04\xab\x1c\x09\x7f\x44\x3f\xbc\xc8\xfe\xc4\x2a\x6a\x59\x00\xfc\x2c\x40\xd3\x23\x77\xc3\x71\xa6\x58\x34\xa8\x3b\x59\xda\xc8\x02\x25\x9c\x36\xd2\x42\x2d\x81\xd4\xc2\xc8\xc8\x45\x8f\xf4\xb1\x6b\x0e\x54\xc7\x39\xbc\xf6\xcd\xc6\x7e\x2e\xb6\x72\xa5\x64\xe6\x99\xbf\xed\x12\xda\x43\xaf\x44\x5a\x89\xd6\xab\xab\x4b\xae\x9b\x8c\xf4\x13\x39\x61\x1d\x5a\xad\xd7\x3d\x96\x16\x6e\xc3\x06\xf4\x23\xaf\xb0\x70\xb5\xee\xea\xba\x7b\x34\xfa\x03\xeb\x2d\xd9\xff\x12\xf7\x33\x19\x21\xde\xc0\xeb\xd5\x93\x3a\x9b\xb7\x5e\x34\x6b\x30\xd8\x7a\x58\x80\x44\xbb\x8a\xa5\x4a\x58\x24\x1b\xca\x8e\x17\x42\x5c\xb3\x63\x68\x0d\xf6\xb2\x87\x58\x0a\x89\xf6\x46\x96\xaa\x65\xd1\x5a\x40\x60\x08\x65\x61\xc9\xac\x05\xdb\xcb\xaf\xd6\x9d\x2c\x25\xac\x97\x8d\x45\x44\xa1\xb0\xc1\x4f\x2c\xc8\x5d\xb0\x1e\xb4\x1e\xab\x58\x72\x0a\x0b\xf0\x8a\x05\x05\x09\xff\x80\x96\x04\xad\x18\x75\x33\x0b\xe0\xa2\xcd\x65\x81\xc0\x14\xfd\xe7\x12\xb8\x68\x27\x58\x70\x2d\x5e\x1b\x0a\x6a\x19\x5a\xc7\x06\xf4\xdf\x00\x1a\x08\x29\x2e\xfe\xb1\x54\x93\x3f\xdc\x0a\x69\x02\x82\x35\xb1\xe4\xf7\x2c\x40\xac\x4f\xb1\xd4\x9d\x70\xe4\x73\xf1\x02\x52\x3e\x36\xce\x92\x04\x0b\x54\x94\xb8\x7a\xc8\xac\x0d\xa8\xea\x9d\xb5\x84\x70\x0d\xe1\xd2\xcc\xe1\xbd\x8a\x6c\xc5\x56\x66\x7e\xe5\xae\x25\xfe\x4b\x5c\x2b\xbf\xc4\x52\x82\x4d\xc2\x52\x9a\x5b\xb8\xf5\xe2\x52\x0e\xf9\xff\x78\x7b\x0f\xf8\xa8\xaa\xb4\x61\xfc\x3c\xe7\xb6\xe9\xbd\x65\x26\x99\x64\x32\xe9\x15\x32\x49\x86\xc0\x40\x86\x22\x04\x12\x20\x14\x03\x43\x4b\x28\x4a\xef\x55\x3a\x02\x0a\x22\x60\xa4\x0a\x02\x2e\x56\x40\xc5\x05\x12\x02\x16\x14\x11\x57\x11\x50\x14\x51\x01\x71\x57\x5d\x75\x75\xc5\x5d\xcb\x6a\x92\xb9\xf9\x9f\x73\xef\x4c\x32\x41\x7c\xdf\xef\xfd\x7d\xef\xff\x9b\xe4\xf6\x73\x9e\x73\xce\x73\x9e\x7a\xaa\xd8\x48\xeb\x70\xe4\x96\x7e\x52\x8d\x6e\x97\x79\xef\x04\xe1\xbd\x1b\x92\xfc\x88\x23\x5a\xdc\x66\xb4\xd9\xb4\x2c\x42\x4a\xa5\xd6\xa9\x75\xe9\x31\xb6\x08\x2b\xe3\xa8\x38\xa1\x5b\x54\x45\x3c\x10\xda\x68\x2a\x1f\xb7\xc8\x16\x4f\x3b\x41\x73\x20\x7d\x38\x5f\xb0\x24\x59\x99\x02\xbf\x45\xef\x88\xc8\x49\x4a\xac\xbe\xbb\x62\x84\xa7\x5f\x43\xdb\x9d\xac\x97\x3f\x6a\x59\xc0\x0e\x27\xb6\xa5\x1a\x75\x0f\x7a\x01\x2b\x04\x25\x22\x8e\x0a\x66\x05\x8d\x4a\xa5\x25\xca\x8e\xf0\xc2\x6b\x21\x95\x92\xe7\x04\xee\xf4\x48\x81\x64\x3c\xbf\x94\xa2\xd1\xe7\x93\xcf\xed\x1b\x3d\x18\xaf\x99\xf3\x73\x66\x1f\x93\x2a\xe0\x6b\x3f\xce\x7d\x53\xdc\x9d\x04\x23\x72\xaf\xdc\x05\x13\x93\x98\xaf\x9b\x36\x11\x6b\xe8\x89\x04\x58\x24\xae\x4b\x78\x42\x4a\xbb\x57\xcb\x5c\x76\x04\x49\xdb\x8a\x66\x07\xbb\xf1\x4a\xb5\x8e\xd5\x73\x7a\xa3\x05\x31\xac\x81\x63\x59\x83\xc6\x00\x26\xd6\x26\x08\x76\x8b\x46\x6d\x36\x99\x5f\x0b\x19\x75\x5a\x93\xc1\x74\x7a\xa4\x41\xa9\x40\xc4\xfa\x78\x2d\x24\xe5\x14\x9f\x26\x82\x1b\xb5\xcb\x95\x23\xff\x0f\xf2\x48\xf7\xe7\x8d\x34\xb8\x46\x33\x9a\xaa\x06\x72\x8a\xe4\x1c\xf7\x11\xb7\x24\xc1\xb8\x92\xc3\x21\x98\x99\x24\x3e\x3a\x22\x15\xa6\x27\x89\x7b\x3b\x1f\x1e\x21\xd6\x26\xc1\x84\x10\xf3\x75\x6b\x01\x5c\x62\xbd\x78\x82\x3c\x89\xeb\x60\x11\x79\x82\x3e\xa4\x3c\x63\xa1\x16\x3f\xc8\xbc\x44\x70\x79\x29\xb8\x8f\x47\x1a\x6d\x5f\x2d\xfc\xa2\x85\xeb\x5a\x58\xaf\x85\xbb\xb5\x0b\xb4\xd8\xa5\xcd\xd6\x76\xd1\x32\x4a\x2d\x4c\xfa\xbb\x16\x36\x68\x77\x6b\xf1\x32\x2d\x8c\xd4\x4e\xd5\xe2\x81\x5a\x48\xd3\xc2\x6f\x5a\xb8\xaa\xfd\x56\x8b\x5f\xd6\x9e\xd7\xe2\x43\x5a\xd8\xa8\xdd\xa3\xc5\x60\xd0\x26\x69\x83\x5a\xe6\x33\x2d\x9c\xd2\x02\xd2\xd6\x68\x1f\xd2\x3e\xa6\x65\x3b\xbd\xa0\xfd\x4c\xfb\x83\x96\xd9\xac\x85\x0e\xe4\xdd\x2c\x2d\x33\x8b\xbc\x7e\x41\xcb\x10\x50\x49\x5a\xf8\x41\x0a\x1d\xf9\xa2\x27\xce\xef\x66\x06\x10\xd3\x81\xc1\x8c\x5e\x09\x4a\x62\xa3\x9d\x1f\x3d\x1a\xc6\x44\x68\x3b\x42\xea\xb3\x63\x35\x6b\x84\xf6\x67\x47\xb6\x84\xb5\x44\x76\x03\xf6\x15\xd8\xf0\x83\x4f\xcf\x99\xf9\xf8\xfe\x59\x73\x9f\xc2\x07\xe7\x3f\xf1\xc4\xfc\xb9\xfb\xf6\x51\x9f\x9a\xb8\xd6\xfc\x09\x74\x55\x6a\x20\x53\xa3\xbc\xa0\x4d\xad\x10\x88\xea\x42\xac\x82\xd1\x68\x95\x1c\x20\xd8\x1d\x52\x90\xba\xca\x2f\x28\x90\x6a\x26\xb2\x4c\xa1\x4c\x3c\x1e\x3f\x55\x63\xf2\xc1\xbd\x93\x7d\x3a\xbb\xf9\x78\xf6\xab\xd9\xcd\x75\xd9\xaf\x67\x5f\x95\x7e\x31\xbe\x02\xfb\x1e\x6d\xfb\xff\x33\x22\x2e\x88\x4e\x72\x5e\x88\x0b\x22\xfb\x2e\x1e\x6b\xd6\x10\xb8\xc6\xde\x4b\x1d\x83\x81\xd4\x2f\xe8\x4f\xfc\x82\x4c\x29\xbc\xf1\x25\x62\x28\x1b\x25\x87\x4a\x47\x77\x48\x25\x45\x2a\xf2\x90\x28\x62\x7f\xb8\x36\x84\xbd\x77\x60\xa3\x9b\xdb\x22\xa7\x61\x22\x71\xbe\xe7\x56\x93\x52\x98\x8f\xf2\x44\x3b\x53\x47\x87\x89\x38\x3a\xb2\x2b\x41\x53\xfa\xfe\xcc\xd0\x33\x70\x8d\x79\xaf\xc9\xcd\xfe\x8d\x2e\xbc\xda\x16\x4f\x8d\xec\x75\x4a\x9e\x51\xb5\x8b\xe9\x2b\xf5\xb5\xc5\xb5\x7a\xa2\xf1\xc5\xf9\xb0\x21\x0a\x63\xa0\xf8\x2d\x6a\x0f\xc7\x71\x84\x60\x92\x02\x51\x82\xf1\x08\x23\x99\x01\x14\x14\x31\xe3\x09\x00\x29\xf7\xe4\xef\x7b\xd8\x40\xa0\x5c\x23\xe0\xd8\x44\xb0\x0e\x14\x07\x50\x68\xd4\x2f\x8d\xfc\x0c\xbc\xf0\x21\xb9\x08\xc8\xd7\xf2\x93\x70\x8e\xdb\x48\x7c\x39\x27\xca\x44\x45\xa8\x17\xaa\x44\x43\xe1\xad\x60\xcb\xc0\x92\x21\x43\xfb\x76\x2f\x74\xc7\x31\x79\x69\x66\xf5\xa0\xc1\x83\xd5\x69\x8c\xbb\xfb\xd0\x12\x45\xd5\x9d\x6b\xaa\x60\x6a\x15\x54\x56\x41\xaf\x2a\xc8\xae\x02\x4b\x15\x34\x55\xc1\x17\x55\x70\xae\x0a\x8e\x55\xc1\xee\x2a\xd8\x2c\x05\xa8\xae\x82\x60\x15\x14\x56\x81\xa1\x0a\xd8\x2a\x98\x74\x4b\x20\x02\x65\x64\xd5\xd4\x2a\x1c\x0b\xe4\x83\xaa\x2f\xaa\xf0\x8b\x55\xf0\x44\x15\x6c\xa8\x82\x79\x34\x44\x04\x86\x4b\x82\xf1\x2d\x0d\x02\xad\x01\x56\x54\x41\x79\x15\x74\xa8\x82\x94\x2a\x40\x55\xe0\xff\xa9\x0a\xae\x56\xc1\x99\x2a\x38\x54\x05\x5b\xab\x60\x49\x15\x4c\x90\x42\x94\x4a\x21\xd4\x55\x20\x07\x78\x35\x26\x0b\x24\x9f\x43\xab\xa0\x4b\x15\x24\xc5\x14\x64\x77\xd5\xb9\x60\xf7\x2a\xbc\x26\x5a\x0c\x39\x8b\xa4\x18\x98\xa4\x22\x30\x43\xf8\x41\x8e\xf2\x0e\xde\x0e\xf5\xa1\x3b\xb2\x5c\x59\xf5\xa1\x62\x97\xd7\x75\x7c\x64\x37\x6f\x9c\xc2\x5a\x1f\x42\x8a\xe3\x23\x91\x9e\x5c\x05\x6a\xad\xd2\x75\x38\x5b\xf5\x0c\x3d\x1c\xa5\xa5\x54\xdd\x54\x8f\x1e\xfd\x87\xfa\xe5\x16\x7b\xe1\xb6\x01\x62\xed\x89\x48\x88\xd8\x9d\xfa\x63\x76\x7f\xa5\x5b\xbf\x46\x36\xbe\xec\x06\xf6\x64\x1d\xd0\x1d\x7f\xe9\xae\xaa\x7f\xfc\x25\xf5\x8f\xe3\x78\xc1\x07\xe1\x85\x4b\x0b\x27\x6e\x1c\x30\x6f\xe5\x9d\x07\xe7\x0d\xaa\xe9\x34\x7b\xc0\xb8\x42\xf8\xec\xf7\xef\x70\xf6\xef\xdf\xfd\xb6\xf3\x49\x76\xff\xd3\xdc\xc6\x7b\x17\x0e\x3b\xb9\xb6\xcf\x7d\x4b\x16\xfc\x6d\xd9\xb4\xd1\x6f\xf4\xdd\x34\xf1\xf5\x3e\xeb\xc2\x07\x6e\xf7\x76\xda\x6d\x83\xee\x27\x5a\x12\x50\x3d\xb3\x18\x4e\x92\x3b\x06\x59\x8e\x23\x96\x38\xbd\xaf\x02\xe1\x06\xa9\xf1\x84\x2a\x44\x17\xf8\x98\xfa\xe0\x99\xbd\xcc\x62\x2c\x84\x7f\x23\xb4\x4f\xc2\x33\x7a\x6e\x95\x21\x4d\xf8\x45\x6a\x0b\xfb\x45\x1a\x13\xce\xa0\xf1\xcc\x59\x66\x8f\x04\x87\xca\xa8\xdc\xa0\x85\x51\x12\x97\x54\xe0\x38\xb5\x46\xad\x55\x02\xb7\x52\x85\x79\xca\x66\x54\xf1\x16\xdc\xba\x29\xac\xd7\xec\x6b\x3d\xc2\x8b\x83\x0d\xe2\xd8\x7b\x4a\x1b\xe0\x0d\x72\xc7\x9c\x85\x17\xc5\x3b\xe4\x43\xd2\x6d\x55\x68\x23\xde\xc1\x3c\x8b\x14\x44\xbb\xbb\x79\x40\x0a\x86\x65\x15\xc0\x28\x55\x0c\xba\x39\x52\xcf\xe4\x33\x33\x99\x15\xcc\x29\xe6\x06\x43\x52\xcb\xa7\x9e\x4b\x8c\x28\x4c\x05\x3f\xf8\x04\x92\x2d\xa8\x16\xff\xa3\x81\x9d\x7b\x94\xe2\x64\x50\xe2\x8d\x30\xbd\x14\xe6\x66\x88\x0f\x8a\xb5\x16\x29\x0d\x03\x49\x63\x70\x34\x0d\x04\x3c\xc7\xd0\xbd\x3e\x49\x1a\x1c\x4d\x83\x78\xe3\xd4\x3d\x3f\xc5\xdd\xe0\x78\xee\x77\x69\x10\x8b\x45\x49\x5c\x06\x10\x9e\xdf\xab\x80\x5d\xe2\xaf\xcc\xa3\xa0\xd4\x6c\x4c\x27\xde\xfd\x3c\xab\xb8\xb1\x54\x6a\xd7\xea\x4f\x10\xf6\x4f\x8a\x43\xc4\x4a\xfb\x7a\xb1\xd2\x9e\x4e\xd0\xf2\x11\xf7\x0b\xbe\xc4\x0f\x25\x38\xb4\x06\x95\x88\x03\x16\xc3\x4b\x21\x62\x19\x44\xdb\x18\x80\x88\x26\x7c\x29\xcc\xe3\x46\xee\x97\x31\x08\xc2\xef\x13\x83\xe7\x5b\x09\xe7\xf1\x41\x0d\x66\x18\x8e\x88\x60\x16\xf3\xc8\x41\xe4\x62\x74\x0c\x02\xd5\x00\x84\xe0\xc4\x69\x8f\xb0\xcb\x77\x91\xb0\x44\x6b\xd0\xdd\x05\x60\x39\xb1\x0f\xe4\xba\xd2\xa3\xc1\xc1\x5c\xbd\x5a\x60\x34\x44\x87\x30\xc8\x68\xd0\x6a\x76\x87\x94\x8a\xdd\x21\xad\x52\x4b\x72\xc1\xb1\xbb\x43\x88\xab\xe4\xb0\x9a\xc0\xa7\x9a\x06\x99\x08\x53\x12\x96\xa4\x3e\x24\x5d\x1c\xb7\xc4\x91\x1f\x71\xef\x22\x5b\x9d\x53\x39\xea\x2b\xf2\x59\x99\x98\xe3\xc5\xd7\xe5\xdf\xd5\xab\xec\xbf\xae\x5e\x15\x47\x92\x23\x44\x54\x4f\x9b\x4c\xd6\xa3\xa4\x63\x0a\x84\xd4\x7a\x2a\x95\xb5\x60\x3c\x26\x30\xb2\x5c\xce\x97\x24\x73\x7e\x01\x91\xcd\x3e\xa3\xb7\xc8\x63\xf5\x1a\x7d\x56\x59\x3e\x9f\x21\x72\xfe\xcc\x99\xa8\x7c\x26\x52\x5e\x96\xd0\x92\x4d\x1f\x85\xcb\x50\x69\x7f\x02\xa9\xc0\x58\xc7\x70\x8c\x02\xb1\x0d\x04\xbe\xa4\x35\x4a\x65\x69\xcf\x18\x65\x71\xbf\x07\x3a\x8b\x67\x07\x51\x71\x4f\xa1\x89\x7b\xe0\x48\x44\xe0\x43\x8b\x81\xc0\xfa\x81\xc0\xe2\x90\xe6\x08\x13\x6d\xff\x92\x94\x0e\xe3\x61\xb2\x86\x9e\x85\xcf\xce\x8a\x37\xb9\x34\x98\x21\x3e\x2c\xd5\xa3\x1c\xfe\x01\xc4\x13\x3d\x47\xfc\x1c\x96\x16\x09\xb7\xe9\x39\x9a\x9c\x0b\x48\xbc\x1f\x7e\x88\x68\xa8\x13\x62\x1f\x9a\x67\x23\x89\x77\x93\xbb\x8f\xc4\x53\xa1\xb8\xa0\x52\xc5\x63\x0c\x0a\x36\x9a\x60\xb4\x77\x9f\x24\x4b\xdb\xdb\xfc\xe9\x82\x3d\x6b\xe8\x1b\x37\x6f\xbe\x31\x74\xf9\xf2\xe5\x24\x7d\xae\xee\xfa\xf5\xba\xba\xd9\xb3\x67\xb5\xd3\x75\x5a\xe4\x3c\xca\x23\xa5\x96\xe6\x41\xdd\x4e\xd9\xb5\x62\x34\x16\x9f\x8e\x56\x74\x8a\x8f\x46\xb0\x89\x51\x3a\xf6\xe1\x4b\x84\x76\x54\xa4\x96\x46\x04\x3b\xea\xf4\x6a\x06\xf3\x82\xa0\x00\xc0\x5a\x16\xb3\x4a\x83\xd2\x88\x18\x1d\xf3\x65\x48\xab\xe0\xf4\xba\x44\x1d\xd6\x05\x75\xa6\x32\xda\xaa\x29\xf0\xd7\x00\xdf\x90\xf6\x4d\x97\x76\xc8\x1f\x1d\x31\x1e\x65\x01\xd0\xb6\xd3\x7c\xa4\xaf\xde\x4b\x77\xff\xa6\xfb\xe3\x33\x02\xe3\x31\xe3\x52\xef\x6a\xaf\x38\x95\xf8\x2b\x7f\x9a\xb6\xcc\xb6\x7d\xda\xcf\xa0\x2d\xc5\x5f\x1e\x39\x32\x13\xe7\x86\x2f\xcf\xc6\xf6\xfb\xc5\xbf\x42\x0f\xca\xaf\x03\x70\x3a\xbe\x49\xf2\x97\x80\x46\x06\x0b\xec\x44\x12\xc4\x27\x18\x0d\x86\x04\xa4\x62\xc1\x0d\x89\x09\x82\xe0\xfc\x22\xc4\x0a\x82\x16\x69\x2d\x5f\x84\x08\x81\x1b\x93\x8c\x8c\x96\x31\x6a\xaf\x23\x92\x67\x74\x4d\x26\x67\x5f\x94\x9e\x1d\xf9\x6d\x59\x8c\xdd\x03\xdc\xec\x11\x3c\x42\x74\x1f\x70\x22\xd7\xd3\xfd\x6e\x90\xd7\x7e\xf6\x26\x0b\xde\x5f\xe0\x37\xab\x38\xa7\xa7\xbd\x2a\x30\x6b\xdd\x13\x3b\x67\xee\x70\xde\xaf\x1d\x16\x1c\x34\xa4\x7f\xb7\xaa\xde\x4b\xb9\x55\xb3\x7f\xb5\xa5\xaf\x99\xb9\xfd\xc9\x99\x77\x39\x4b\xcb\xc6\x8d\x1e\xd4\x2f\x40\xf3\xfd\x38\x2e\x64\x9c\x92\xaf\x92\x15\xb4\x10\xde\xe5\xb4\x24\x97\x3a\x05\x11\x2b\x5f\x86\x08\xe2\xd0\x0d\xba\x8b\x76\x34\x2f\xad\xfb\xbf\x7b\x8b\x4d\x66\xba\xfb\xb8\x8e\x81\xd2\xb5\xee\x97\xbf\x10\xb3\x6c\x78\xac\x65\xf0\xf6\x45\x77\xe2\xc2\x47\xa0\x07\xc0\xec\xbb\xc6\xd6\x1d\x3d\x41\x28\xbf\x1c\x67\xe0\xcf\x88\x5d\x12\x87\x52\x51\x47\x5a\x73\x99\x06\xaf\x3d\x5f\xa5\xe2\xcd\x76\x03\x57\x90\xc0\x30\x3e\xde\x6c\x76\xa6\x39\xd3\xbe\x08\x69\x9c\xf1\x4e\xac\x64\x9c\x4e\x82\xa4\x9c\x2f\x42\x04\x35\x49\x04\x55\x9f\xca\xa8\x89\xa0\x25\x8a\xa0\x5b\x37\x48\x8f\x28\x48\x5e\x2f\xad\x77\x1d\xb1\x66\xfd\x45\x79\x44\xd7\x15\x9b\x23\x08\xa2\xfb\xf1\xdb\x93\xe5\x5d\xf9\xa5\xfd\xd2\xaf\xce\x7d\x78\x4a\x15\x04\x2a\x9e\x7d\x64\xf5\xd6\xd9\x77\xfb\x03\x7f\x9a\xd9\x73\x40\xcf\x1e\xbd\xcb\xcb\x98\xaa\xaa\x3e\x15\x95\x63\x06\x70\x1b\xa7\x8d\x19\xba\x50\xc3\x18\x47\xf4\x59\xf6\xf0\xa2\x69\xa3\x97\x9b\xb1\x7d\x64\xd7\x29\x8b\xc4\x1d\xe5\xfd\x8a\xba\x94\xf7\x28\x29\xbd\xbb\xa6\x7f\x49\xf9\x88\xaa\xce\x7d\x28\x2e\x47\x61\x01\xbf\xc3\xee\x41\x0e\x50\x07\x13\x18\xab\x4e\xa9\x54\x59\x55\xce\xb8\x42\x67\x2f\xe7\x04\x27\x73\xd5\x09\xac\xd3\xe2\x2c\x74\x32\x53\x9c\xb4\x05\x72\xce\xfc\x32\xe9\x5a\x7d\x97\x74\x0d\x2a\x43\xa3\xca\x3e\x73\xfe\xe0\xc4\xd2\x93\x7d\x48\x55\xd9\x4a\xe7\x43\x4e\xcc\x3a\x61\x9e\x73\x8d\xf3\x98\xf3\x8c\xf3\x03\x27\x27\x7d\x4b\xaf\xa8\x2c\xab\x74\xd6\x38\x31\x85\x8c\x93\x64\xb8\xb8\xa4\x90\x04\xdb\x4a\x02\x7e\xe1\xe4\x86\x92\x04\x25\x38\x47\x53\x33\x64\xe8\x71\x49\xde\xb2\x26\x27\x7c\xe0\x04\xb5\xd3\xe5\x2c\x77\xee\x76\xb2\x0a\x3b\x38\x54\x4a\x44\xbf\x26\x29\xb5\x65\xc8\xa4\x33\x69\x34\x5c\xb9\x69\xa4\x69\x89\x69\x83\x89\xcd\x37\x95\x9a\xb0\xcb\x04\x7a\x13\x60\x13\xca\x97\x2c\x1d\x9f\xbc\xd1\x73\x76\x41\x41\x41\x49\x89\xe4\x60\x64\x67\xcf\x96\x8d\x98\x6c\xa9\x25\x8f\x58\x4a\x63\x22\x6e\x45\x6b\xc5\x98\x8b\xe9\xbe\xe1\x3c\x5d\x93\x3c\xb2\x39\x34\xad\x2a\x81\x81\x9f\xfb\xaa\xc7\x97\x4d\x36\xf5\x59\x39\xc1\xbe\xd0\x80\xfd\x13\x7a\x0e\x1a\xad\x2e\xc7\x02\x2c\xf0\xa5\xd6\x4c\x18\x23\x6e\x85\x96\x0d\x33\xfb\x16\x84\x46\xa5\x74\x13\x57\xd1\xf6\xeb\xd7\x5b\x26\xe2\x8d\x78\xb9\x41\xe0\xc6\xb7\x3c\x10\x7e\x40\xd2\x63\x5c\xcb\x64\xfc\x22\x5e\x49\xde\x4d\x6e\xd9\x12\xde\x28\xbd\xd3\xb7\x4c\xc5\x17\xf0\x2a\xf2\x6e\x4e\xcb\x63\xe1\xcd\x52\xdb\xf7\xe9\x96\x7b\xf0\x27\x78\xae\x41\x60\x3a\xa2\xc3\xf2\x3b\x24\xb4\x4c\xc2\x2f\xe3\x15\x24\xdc\x94\x96\x6d\xe1\x07\x25\xbd\x3b\x82\x28\xa7\x3a\xee\x03\xe4\x41\x53\x83\x5d\x85\x38\xb3\xcd\xa4\x32\x58\x3c\x2a\xbb\x2d\x4e\x48\xd6\x68\xbc\x6a\x5d\x4d\xc8\x64\x57\xd9\x6b\x42\x7a\x15\x91\x65\x6a\xbd\xea\xb0\x0a\xeb\x19\xb5\x4a\xad\x72\xdb\xdc\xb8\x26\x84\x90\x1b\xd9\xcc\x35\x21\x5b\x44\x43\xf9\xf2\x5b\x15\x14\xa1\xdd\x31\xa3\x8d\x11\x0b\x32\x96\xb3\x09\x8e\xd2\xe8\xae\xe6\x94\x3e\x29\x87\x33\x91\xc3\x9c\x62\x2c\x34\x49\xe8\xb2\x33\x43\xe3\x0f\x8d\x5f\x3b\xb2\x70\xce\x3d\x77\xe2\x6a\x97\x78\x67\x17\x58\xe3\x14\x97\x06\xe1\x8c\x2b\xbc\x6e\x84\x38\xbf\xe2\xa1\x2b\x6b\xff\xf4\x86\x9a\x7d\x76\x77\x8f\x8d\x37\x86\xcc\x9f\x0b\x50\xb7\x41\xbc\xfc\x80\x78\x62\x03\x5c\x64\x61\xda\x42\xe0\x4f\x54\xef\x58\x4e\x6d\xa4\xd9\x2d\x9b\xb9\x4b\xbc\x02\x79\x89\x97\x90\x8f\x56\x07\xef\x88\x37\x9b\x0d\x06\x53\x8a\xe0\x45\x71\x39\x0e\x6d\x6e\x6e\x7e\x7a\x0e\xc2\x69\x1c\x2b\xa8\x3a\x98\x4c\x56\x6b\x47\xc6\x9b\x14\xcc\xc9\x4a\x8b\x4b\x8a\xab\x0e\xb9\x5c\x1c\x46\x49\xe6\xdc\x74\x47\xbe\x3a\xbf\x3a\xa4\x35\xaa\x6d\x36\xb3\x41\xa7\x66\xa9\x36\x23\xb4\x61\x38\x53\x10\x71\xd2\xe5\x67\xf9\xc1\xe9\x30\xbc\x53\x20\xdb\x02\xa6\x98\xa5\xeb\x5b\x17\xb0\x4f\x4b\x27\x42\x37\x8d\x14\x35\x85\x8e\xe0\xb4\xd9\xfd\xf4\x24\xa4\xa5\x43\x8a\xd9\xce\xb3\xd9\x40\x3e\x33\x16\x3b\x10\x4d\x66\xb3\x43\x5a\x3a\x76\x94\xf7\xac\xd8\x34\xeb\xf0\x3b\x30\xfd\xef\xfe\x4d\x5d\x86\x06\x2b\x36\x4d\x5a\x9b\x7b\xcc\x51\x2c\xda\xc1\xf5\xf2\xe6\xe5\xe2\xab\x1f\xe8\x0d\x39\x9b\xea\xfa\xc0\xc5\x9f\xc5\x1b\x4f\x75\xae\xc4\x42\xf7\xc1\x8c\x3e\xe5\x4f\xff\xd8\x07\x9e\x7f\xc3\x03\xd7\xd9\x39\x8b\x35\x71\xfb\x3e\x1e\xb1\xd3\xdf\xaf\xb8\x19\x6b\xc1\x1a\x7a\xe9\x00\x8c\xc1\x4f\xef\x9d\xce\xbc\xed\x12\x57\x87\xa7\x67\x1a\xd8\x52\xb7\x52\x6e\x43\x99\xdd\xf2\x1d\x77\x89\xdb\x4e\x70\x35\x3c\x98\x67\x13\xdc\x09\x39\x39\x71\x28\x25\x4e\x60\x3b\xe8\x74\x1d\x93\xd3\xab\x43\x29\xc9\xc9\xee\xf8\x78\x46\xad\x36\x55\x87\xf4\x7a\x35\x1b\x97\xc3\xe4\x54\x87\xf2\xf3\x19\x33\x2a\x95\x31\xd0\x4a\x04\x8e\x7c\xba\x31\x79\x6c\xdd\xcb\x95\xcf\xb3\xde\xe4\x14\x5c\x44\x10\xe0\x2b\x60\xed\x02\x5d\xc2\x9f\x95\x89\x81\x22\x44\x62\x18\x69\x3b\x75\x1d\x26\xb2\xdf\xcf\x0d\xa0\x45\xac\x13\x7f\xde\x70\x09\xe6\xff\xfd\x63\xc8\xee\x70\x2c\xf5\xc2\x8e\x06\xf1\xeb\xed\xb5\x2b\xee\x8c\x33\x1d\xf4\xb2\x3d\x56\x0e\x4d\xef\xe4\xc9\xc9\x2b\x5b\x1c\xca\xd2\xaf\xff\xe7\x08\x18\xf4\xd2\x81\x5a\xd0\xbc\xf0\x0b\x6c\xfa\xb8\xee\x09\xff\xac\x35\x7f\x16\x4f\x5d\xda\xff\x91\x17\x8e\x3d\x30\xe7\xfa\xda\x69\xba\xed\xda\xbb\xfe\x7c\x65\x90\x62\xeb\x7d\x44\x67\xbf\x47\xe8\xff\x43\xa2\x0f\x8c\x68\x59\xb0\x0c\x58\x4e\xa1\x53\xf3\x2a\x84\xf4\x7a\x62\x09\x10\x25\xab\x52\x69\x0c\x06\xb3\xc6\xa4\x50\xeb\xd4\x35\x21\x4e\xa7\x63\x95\xc0\x56\x4b\x1d\x54\x58\x0f\x9b\xe1\x14\xdc\x80\x9b\xc0\xa9\x19\x00\xa5\x5e\x8f\xc8\x17\x46\xa5\x34\x51\xe5\xdb\x26\xc0\x67\xdf\xaa\xe2\x22\x86\x78\x54\x66\xc8\x8a\x98\x32\x00\xfd\x23\x52\xc3\xeb\xf7\x11\xb6\x80\x7f\x8d\xc2\x87\x13\xc3\x83\x32\xe1\xe1\x38\x71\x46\xf1\xb1\xe2\xc3\x71\x87\x4f\x33\x4b\xdc\xec\xdf\xc5\x94\x3d\x97\x57\x89\xdf\x80\x7d\x15\xf3\xcd\x6e\x52\x86\x9f\x48\x19\x76\x93\x3a\xcb\x41\xef\x04\x57\x78\x93\x13\xdd\x76\xbb\x2d\x55\x91\xac\xf6\x68\xdc\xfa\x1c\x52\x16\x8d\x5a\xc1\xb1\x36\x5b\x5e\x26\xc7\xb2\xb9\xa9\x0a\xb5\x62\x7e\x88\x7e\xd4\x6b\xe6\x87\xdc\xa4\x0a\xa1\x45\x0d\xd5\xea\x99\xea\xcd\xea\x7d\xea\x1b\x6a\x2e\x49\x0d\x89\xa4\x68\xfa\x7d\x7a\xac\xd7\x27\xea\xab\xf5\x33\xf5\xf4\xe1\xb0\x5e\x50\x32\xfa\xa0\xcd\x59\xa6\xd6\xab\xf5\xb9\x44\x89\xcd\x0d\xd9\xed\x66\x81\xcb\x64\x33\xe7\x85\x0c\x39\x49\x39\x38\x27\x87\x75\x50\x22\x18\xdd\x8e\x0a\x24\x5b\x95\xa2\x61\x0e\xdd\xdc\x4a\x96\x07\xc6\x36\x5c\xb4\xb2\x49\xcc\x1f\x1d\x9f\x40\x50\xa2\x03\xaf\xc7\x5f\x5c\x4a\x47\x29\xd0\x46\x49\xbf\x2c\x1a\x24\x7a\x21\x8a\x2f\x82\x2f\x3a\xd8\xd0\x53\xe0\x67\x7d\xe9\x6f\x3c\x12\xee\x9d\x70\x3a\x97\x3b\x19\x77\xd2\x45\x8e\xb8\x8c\xcf\x5e\xde\xfc\x6a\xfc\x93\xfa\x79\xfd\xe6\xac\x70\xb8\xe0\x91\x38\x71\x92\x0b\x76\x92\x33\x63\x5a\x19\x82\x8f\xce\xfa\xa0\x78\xc7\xbe\x5d\x23\xbf\x8b\x5b\xf5\xe0\xaa\x7b\xcf\xbd\xb6\x70\x66\x41\xe7\x7e\x73\x97\x3d\x40\x9e\x4c\xd3\x4f\x64\xd6\xc9\xfc\x90\xdc\xd2\x89\x2f\xe7\x82\xa8\x00\x8d\x0a\x12\xda\x8d\x63\x52\xe3\x5d\x19\x19\x1e\x0f\xa3\x37\x21\x35\xef\x2b\xcc\xcd\x76\x67\x57\x86\xe2\xdd\x86\x8e\x90\x17\x67\xe2\xd4\x4e\x5b\xd0\xc6\x57\x86\x6c\x06\x9d\xbe\x43\x2a\x52\x5b\x51\xe9\x59\x62\xf8\x12\xd1\x48\xa4\xc2\x05\x52\xce\x52\x5f\xcc\xa6\x16\x6d\xb6\xbb\x1d\x22\x3a\x9b\x6a\x8d\x62\xbf\xcf\xc2\x47\x14\x87\x9d\x70\x84\x3f\xa2\x40\xbc\xe6\x88\xe5\xa3\x26\x28\x81\x7f\x61\x63\x7a\x45\xd5\xac\x67\x93\x16\x1c\x7d\xca\x62\x3e\x68\x15\x98\xbe\x5b\xee\x5e\xb4\x59\x07\x7d\xf7\x1e\x30\x6a\xef\xaf\xb5\xae\x38\xb2\x34\xae\xa2\x2a\xd3\xf3\xd3\xbc\x23\xf9\xe2\xbb\x7f\xc1\x4d\x67\xf3\xcb\x07\xbe\xf6\x64\xf8\x09\x66\x48\xf5\x3a\xf5\xda\xcc\x39\x23\x16\xcd\x84\x4f\x7e\x82\x87\x1f\x08\x4e\x08\xcf\xc5\x8b\x17\xfa\xcb\x07\x6a\xc4\x7d\xe1\x43\x37\xc5\xbe\xa4\xec\xc4\xf2\x46\x88\x57\x11\xde\x70\xa1\x44\x22\x3f\xd3\x51\x16\x7a\x38\x38\xc0\x69\xc3\x71\x71\x8e\x24\xe4\x85\xac\xcc\x4c\x36\x3d\x4d\x9f\xa0\x56\xa8\x88\x44\x35\x29\xdc\x09\x69\x89\x1e\x16\x90\x43\x9d\xad\xd3\x68\x72\xd2\x6d\x26\xa2\x79\xab\x43\x49\xf1\x7a\x97\x97\x18\xa8\x0c\xae\x0e\x65\x12\x97\xc7\x45\xfe\xb8\x14\x8b\xc3\x94\xa1\x94\x3a\x24\x64\x3b\x95\x0e\x84\x6b\x6b\xe5\x6c\xd7\xde\xe9\xbb\x4d\x03\x41\xc4\x8a\xa5\x26\x22\x25\x0d\x33\x61\x18\x33\x35\x62\xbd\x02\x39\x18\x2f\x23\xb3\x51\x26\xf8\x3d\x9c\x27\xdd\x0b\xc5\x7e\x2f\x08\xbe\x86\xdc\x4d\xee\x4d\xfd\x3f\x38\x0c\x4d\x03\x9e\x1d\xf0\x90\xfb\xa1\x9c\xcd\xee\xcd\x23\xaf\x5d\x10\x8b\x47\x1c\x1c\xb9\xc9\xcd\x0c\x01\x3e\x57\x9c\x28\xf6\x83\x49\x77\x5d\xc1\xcf\x19\x9d\x4f\x88\x82\x7b\x01\x9e\xf5\xd5\x6e\xd8\x2c\xce\xa6\xc7\xee\xaf\x76\x8b\xd9\x70\x99\x1e\xbb\xbf\xfa\xea\xab\xf0\xd4\x4d\x6b\xf1\x97\xd4\x8d\x24\xfe\xdd\x80\x96\xef\x14\x2b\x09\xae\x04\x94\x84\xee\x40\x95\x68\x57\x70\x68\x6a\x4a\x4a\xd7\x0e\x59\x3d\x7b\xfa\x8b\x15\x6e\xb7\xce\xd1\x1b\x95\x57\x54\x20\x47\x71\x07\x6e\xf0\x20\xae\x5f\x75\x88\xe3\xca\xfb\xf7\x27\xb2\xa4\x3f\x53\x6e\xca\xea\xea\xf1\xf9\x3a\x57\x86\xfc\x7e\x9f\xcd\x93\x51\x19\x4a\x4d\xf5\xe8\xdd\xae\x41\x84\x3d\xad\x86\xca\x90\xd5\x96\xa4\x08\x2a\xd4\x83\x42\x0a\x3d\x92\x29\xe9\xbc\x6c\x23\xca\xfa\x36\x56\xeb\xb6\x6e\x9e\x12\xeb\x21\xb7\x3b\x11\xbe\xa2\x3b\xa7\x30\xbe\xa4\x54\x8a\x2a\xde\x1a\x33\xa3\xc0\x4f\x45\x8f\xdf\xc7\x45\xb9\x8c\xca\xe4\xa8\x7d\xd9\x6a\x7a\xe7\x41\x3a\x35\x36\x53\x2d\xac\x87\x60\x9a\xbc\x63\x99\x89\x7b\x77\x75\x9a\x36\x06\x96\xc3\xe9\x3d\xce\x3d\x15\xaa\xb2\x84\x52\x73\x69\xe5\xa0\x31\xaa\x81\x93\x9c\x33\x27\xcc\x80\x6f\x36\xee\xb5\x3c\xa6\x1e\x54\xbe\xbf\x72\xee\xd2\x39\x7f\x39\xf1\xf0\x7e\xcf\x23\xe6\xe1\xc3\x27\x4d\x48\xec\x33\xfd\x8b\x63\xe1\x87\xc5\x8b\xe2\x7f\xee\x9d\x52\x07\xc6\xcb\x5f\x81\x8e\xf9\x71\xe1\xf2\xf0\x07\xb3\x57\x8b\x0b\xf2\xb2\x07\xeb\x96\x5b\xc7\x55\x15\x16\xc2\xae\xd5\xff\xfe\x6a\x7e\x4d\x5c\x56\xe7\xaa\x9c\x02\x97\x7b\x4e\xe8\xde\x75\x23\xa7\x17\x76\xe9\x54\xdc\x39\x21\x23\x31\xa1\xf3\xfe\x05\x2b\xcf\x5c\x6b\x0a\x5f\xe5\x56\xbd\x2b\x8f\x87\x2a\x25\x75\xf1\x19\xa9\x0b\x2d\xb2\xa1\x52\x34\x2d\xd8\x59\xab\x34\x76\x4a\xc8\x49\xb1\xdb\x3b\x76\xcc\x31\x6a\x6c\x2c\x1f\xec\x9e\xd2\xc9\x99\x9f\x5f\x54\x13\x2a\x28\xc8\x37\x38\x3d\x35\x21\xb7\xdb\x69\xd6\x60\x1b\xa1\x51\x9b\x8d\xe5\x38\x2b\xa9\x1f\xe2\x45\xc6\x4a\xf2\x56\xa1\x16\x83\xef\xf6\x48\xa6\x7e\x3f\x10\xca\x03\x4f\x01\x4b\x90\x26\x28\x41\xb6\xc4\x3d\x0c\xfc\x0e\x85\x79\x98\x36\x3f\x27\x45\xa4\x99\xd5\xe2\x06\xbb\x1b\x33\x61\xf1\xaa\xb8\x63\xf6\x29\x30\x62\xcb\xfb\x00\x1f\xbd\x0f\xdd\xc4\x6e\x75\x0d\xdb\xb6\x8a\x4f\xde\x25\x28\x7e\xfd\xc7\xf3\xe7\x33\xb7\x78\x36\xcc\xdf\xbc\x35\x67\xd8\xba\x95\x2b\x7b\x7d\xfd\x3e\x8c\xcb\x79\xdc\xb6\x78\xe2\xd2\xb5\x59\x03\x37\xaf\x58\x55\x86\xfb\x86\x8f\x73\xab\xce\x3d\xfd\xd2\xb5\x84\xf0\x53\xf8\xb3\x1d\xeb\x67\x2d\x0a\xff\x2a\x8e\xde\x7f\x78\xfe\xf2\x4e\xc3\x2b\xc7\x8e\xce\xea\xda\x31\x27\xab\x72\x6a\x9f\xda\x3d\x2d\x71\x03\x7b\x0f\x2c\xcb\xea\x9c\x9b\x9b\x31\x78\x16\x6d\x4f\xd5\xd0\xfd\xba\x08\xce\x64\x4e\xcf\x46\x79\x44\xe2\x15\xa1\x3d\xc1\x2a\x9b\xd5\x61\x4a\xd1\x65\x74\x28\x4c\x8b\x2f\xf2\x66\x25\x65\xe6\xe6\xe5\xa9\xe8\xec\x8b\x64\x55\x66\x56\x51\x5a\x07\x9d\xd1\x64\x35\x1b\xf4\x89\x89\x7e\x7d\x71\xc7\x3c\xb5\xa0\x37\xe8\xab\x43\x19\x29\x49\xac\x21\x3b\xdd\xcb\x98\x2d\xe6\xea\x50\x61\xbc\x03\x59\x0c\xe4\x4f\xeb\x73\x3b\x6d\x4c\x7e\x8e\x52\x6b\x92\x0c\x28\x7a\xb4\x72\x7e\x84\xe1\x7d\xed\xee\xe1\x76\xda\xa1\xad\x8d\x50\xe6\x77\x8f\xcc\xef\x8c\xc7\xef\x4b\xa7\xc3\xd8\x24\x59\x40\x0f\xf0\x11\xf6\xf7\x45\x44\x80\x99\xfe\xdb\x88\x14\x10\xa6\x4e\x74\x6f\x9b\xf5\x71\xa2\xd8\xf8\xe5\x8d\x54\x71\xe5\xb5\x1b\x1d\xc4\x70\xe2\x65\x47\xad\x7b\x42\xc6\x1b\x5e\x78\xf9\xe5\xe3\x1e\x78\xe5\xa5\xb7\x9a\xaf\x7f\x3d\x5d\xdc\xd9\x7c\xfa\xab\x69\xe2\x23\xf0\x28\x64\x9b\x9e\x83\x45\x6b\xb6\x34\xbf\xb2\xba\x56\x87\xe7\x0e\x1d\xc5\xfc\x7b\xf7\xdf\x77\x8b\x59\xf0\x21\x3d\xc8\x6d\x54\x44\xc0\xe6\xe6\x1f\xfe\x4e\x7f\xe1\x41\x90\x27\x5e\x82\xbc\x37\x99\xa3\xef\x52\x7f\x7e\x00\x91\xa5\x7b\xd9\x73\xc4\xce\xf0\xa0\x2e\x27\x90\x0b\x4a\x8e\x0b\x66\xc1\x6c\x22\xe8\xeb\xae\x81\x20\x0a\x21\x13\x74\x26\x5f\x75\xd2\xbd\x11\x4a\x90\x81\x3c\x97\xb6\xf9\x82\x54\x8d\x96\x46\xdc\x3e\x3d\x78\x4d\x11\xca\xf2\xba\xb0\x8f\xf1\x14\x74\xa3\x23\xae\x18\x1d\xf6\x32\x5d\xce\x35\xc4\xe7\x9f\xe8\x62\x9c\x72\x8f\xf8\xc2\xf9\x86\x7f\x3e\xb6\xf1\xc4\x74\x18\x3a\x63\xf9\xa0\x84\xd5\x27\xd6\x66\xdc\xff\xc1\x73\xec\xb9\xed\xcf\x8c\xde\xf9\x6f\xc8\x9e\x56\x5c\x3d\xb0\xe9\x06\x7b\xae\xa9\x08\x7f\x1c\x7e\xaf\xf7\x13\xdb\xf0\xfe\xf0\xe0\x73\xdf\x4c\x96\x79\x68\x36\xfa\x86\xcd\xe6\xde\x21\xd6\x7d\x16\xa1\x85\x09\x41\x7f\x22\x6f\xd2\xeb\x52\xdd\x5c\xbc\x25\xde\xe5\x72\x98\x2d\x96\x1c\x3e\x8f\xcd\xb7\xd9\x3a\x38\x0c\x06\xab\x31\xdd\x13\x8f\xb4\x8c\x8a\x61\x82\x4a\x7d\x99\x91\x5c\x55\x46\xc6\x9c\x9d\x67\x46\xa8\x34\x9f\xca\xef\xfc\x7c\xca\x31\xf6\x12\xda\xf8\xe8\x33\xb6\x39\xfa\x6d\xea\x5f\xd6\xf7\x72\xd3\x2d\xd5\x7b\xb2\xca\xf7\x49\xf2\x9c\xa7\xd3\x09\x52\x23\x6d\xb9\x74\xbf\x27\x6a\x2c\xe1\xe3\x85\xb3\xaa\xe6\x2d\x0c\x1d\x58\x38\x60\x74\x02\x64\x2f\x32\x2d\xb2\x2c\xb7\x8c\x32\x8d\xba\x4f\xab\x9d\xcb\x6a\xc4\xbd\xf7\x8f\x9c\x1f\xdc\x37\x68\x4a\xd7\xcb\xf8\x82\x29\x5c\x80\xfd\xfd\xba\x3d\xb0\x72\xc5\x6f\x4b\xef\xe8\xf1\xf9\xa8\x89\x13\x47\x85\x2b\xbb\x8f\x0c\x74\x5b\xf1\xd4\xc4\xf7\x46\x1f\x9c\xfc\x81\x58\x38\x9a\xae\x94\xdc\xf2\x3d\xfb\x0e\xb1\xa3\xb2\xd1\x13\xc1\x09\x9c\x8a\x18\x36\x26\x33\x9b\x2c\x24\x2a\xe3\x35\x71\x71\xf1\x89\xc9\x66\x2e\x23\x27\x23\x57\x13\x17\x1f\x37\x3f\xa4\x8c\x17\x12\x93\x13\xe7\x87\xd8\xe4\xd2\xf8\x81\xf1\x17\xe3\x99\x99\xf1\x2b\xe2\xb1\x3e\x39\x31\x79\x73\xf2\xe1\x64\x56\x4f\x2e\x37\x92\x6f\x26\xb3\x6a\x26\x3e\x39\x3e\xd9\x96\x9a\x9a\x3d\x37\x94\x99\x99\x2a\xd8\xf4\x73\x49\x55\xd7\x98\xb0\xc9\x64\x8b\x93\x8d\xa5\xdf\x79\x4d\xb3\x89\x43\x79\x8b\x99\xd4\x8e\x07\x0a\x22\xbd\x58\x74\xe3\x2b\x82\x08\x9e\x9e\x24\xc9\xe2\xb7\x53\x14\x62\xca\x05\xd2\x3c\x10\x9f\x29\xc5\x5f\x20\xf9\x16\x4c\x87\xbb\xef\x9b\x9e\x06\xef\x76\x17\x07\x9b\x79\xb8\xd8\x5d\x9c\x86\xd7\x2e\x9d\xb2\x36\x6b\x67\xe0\xaf\xfb\xde\xfc\x1b\x7b\x28\x38\x8b\x35\x33\x0f\x77\x9f\x3d\x00\xd2\xcf\x3f\x71\x3e\xfe\x50\xf1\x11\x8e\x29\xdf\xb3\x6a\x45\x4d\xaf\x55\x0d\xaf\x4d\x1e\xdb\xe1\xe1\x1d\x60\xf8\x75\x55\xc1\x54\x61\x05\x40\x23\xec\xde\xe6\x7d\x89\x95\xed\xa3\x22\x62\x28\xfc\x89\xc8\x0d\x0b\xea\x17\x4c\x37\x9a\x18\x96\xb5\x18\xcc\x4a\x62\x71\x82\xd9\x24\x58\x05\xc1\x66\xd0\xab\x2d\xc8\x52\x2d\x75\x96\x61\xad\xc9\xc4\x63\xa9\x31\x8c\x36\x4d\xfd\xae\x53\xd3\x17\x6d\xf6\xf1\x51\x65\x0e\x3e\x6a\xe3\x81\x17\xbc\xd4\xf4\xf1\x0e\x5d\x37\xef\xd4\xfc\xc1\xf8\xd5\x9f\xc3\x9d\xf1\x7d\x89\xe1\x73\xf0\xfe\xdf\xc4\xe2\xdc\x7d\x53\x4e\x2d\x5f\xc7\xe4\xe2\xa1\xe1\x67\xe9\xf1\x18\x31\x64\x36\x4e\x0b\xdf\xc0\x1b\x49\xde\x56\xd2\x3d\x5b\x49\xde\xec\xc8\x1f\x4c\xd0\xab\x79\x0e\xa9\xcc\x3a\x2b\xe8\x54\x6a\x81\x77\x18\x8d\x71\x66\x9d\x41\x57\x1d\x32\x30\x54\xcc\x97\xde\x82\xe9\x88\xaa\x4c\x15\x38\xa9\x3b\x35\xd5\x4f\x0e\xa9\x09\xc8\xc3\x90\x77\xf8\x43\x98\xe2\x16\xb7\x0d\x7a\xa5\x9b\xb8\xcb\x0d\x13\x93\xe8\xf9\xee\x90\x18\xef\x66\xef\x73\x8b\xf1\xbd\x61\x6a\xa2\xb8\x1d\x97\x3e\xb7\xef\x90\x38\x06\x4a\x9f\xd9\x75\xe8\xa9\x03\xbb\x0e\xc2\x5f\x1e\x7d\x54\x7c\x94\xbc\xa3\xb6\x55\xcb\x3f\xc5\xc9\xc2\x11\x7e\x2e\x32\xa1\xce\xa8\x37\xba\x13\x55\xa3\x79\xc1\x40\x96\xbd\xaa\xbf\xb7\xa3\xcf\x97\xee\x1f\xd2\x05\xa1\xee\x43\x94\xe9\xde\x2a\x61\xec\xc8\x84\x84\x9a\xac\xf4\x3e\xbe\x6e\x06\x83\xb3\x43\x6e\xb6\x8f\xad\xb2\x9b\x87\x07\xbd\xfd\x07\x26\xad\x1c\xa3\x74\x9a\x06\x9a\x4d\xbd\x38\x86\x4a\xd4\xf3\xa5\xe7\x4b\xcf\x9e\x77\x5e\x33\x96\x94\x38\xcf\x93\x13\x91\xaf\xe7\x09\x9a\xcf\x1b\x22\xcd\xff\xb7\x1a\x52\xbe\x48\x4f\x68\x3a\x23\xcf\x00\x34\x4b\x9c\x07\xc9\x44\x3d\x45\x58\x91\x76\x90\xda\xfd\x4e\xf0\x13\x4a\x2b\x2a\x4e\xf5\x13\x0a\xe3\x05\x37\x98\xac\x16\xcc\x42\xb4\x8d\x89\x10\x1e\x10\x57\x0d\x0b\xf4\xce\x54\x54\x88\xa1\xf5\x83\x70\xe4\xf0\xa6\x69\x55\x9d\xd2\xdc\x47\x5d\x05\xca\xd9\x29\xbb\x97\xdf\xfb\x4c\x53\x61\xaf\xf1\x33\xba\xa5\xad\xea\x37\x7c\xf4\x84\x41\x69\x55\x09\x49\x5d\xee\x1b\xb9\xfc\xbb\x1e\x27\xa1\x20\x6d\xe0\x8a\x0e\x15\x03\x76\x7d\x79\xcf\xe3\xe2\x4f\xcc\x96\x3b\xcb\x2a\x46\x0d\xef\xd3\x77\x74\x53\x4b\x4e\x59\xd7\xc2\xde\x05\xeb\x36\x2c\x7c\x73\xc1\xe9\xf0\xc4\x60\xdf\xec\xae\x25\xb9\xb3\xa0\x78\xd3\xb3\xfd\x45\xf1\x4f\x5d\x4b\xf6\xa6\xc1\x99\x6d\x0f\xec\x12\x07\x25\x94\xfa\xef\x18\x30\x64\x50\xef\xe1\x0e\xd3\x61\x98\x01\xcf\xcf\x13\x0a\x52\xba\x8f\xc2\x99\xa1\xe1\xae\x8a\xb9\xec\x33\xe2\x8d\x86\x2b\xe2\xfa\xb3\xe0\x1e\x3b\x7b\xde\x98\xb1\xf3\x16\xb1\xdb\xfb\xbd\xf4\xee\x77\xe2\xb1\x7b\xee\x39\x0d\xd5\x2f\xff\x0a\x59\x4d\x4b\xb2\x32\x3b\x76\xcc\x95\xdb\xb2\x1f\x15\x87\xb1\x1b\x88\xfc\xf3\xa0\x5c\x74\x67\x30\x5f\x61\xb5\x1a\x33\x1d\xc8\xc6\x68\xb5\x36\x87\x91\x4d\x76\xbb\xf3\xcd\x79\xd9\xc8\xa2\x37\x5a\x79\xb3\xcb\x95\x5a\x13\x72\x21\xb3\xc9\x60\xe6\x89\x97\xa8\xe0\x5d\x74\x9c\x0d\xdd\xc9\x4e\x12\xdd\xf6\xe8\xe4\xc4\x58\xec\xd3\x76\x22\xb9\x51\x53\xda\xce\xae\x28\x9d\x01\x62\xd5\x83\x0b\xb0\x8c\x75\xab\x45\x07\x66\x8a\x61\xda\x89\x65\xf7\x17\x33\x19\x45\xca\xfd\x07\x46\x57\xa6\xf4\xeb\xf9\x18\x93\x2c\xbe\x37\xab\xe1\x69\xd8\x74\xf7\xcd\x82\x17\x1e\x99\xbf\xb2\xec\xfe\xac\xc2\xb4\xac\xfe\x5e\x53\xbf\x9d\xb8\x32\xfc\xf7\x51\x79\x87\x0e\x3a\x1f\x72\x9f\xe9\x03\xbb\xc4\x6a\x20\x7a\x0e\xbb\xc5\xcb\x70\x07\xcc\xac\x7d\xf1\xe3\xa5\x93\x07\x1e\xbb\x0c\xe7\x8a\x3a\x74\x5d\x3d\x79\xd1\x13\xf3\xbe\x93\x6c\x57\xba\x07\x10\xed\x8f\x72\x12\xed\x9f\x82\x32\xd1\xee\xe0\x48\xbb\xd9\x6c\x30\x1a\x9d\x29\x99\x2c\x9b\x95\x96\xec\x72\x29\x14\x2c\x9b\xed\xe6\xed\x8e\x54\xc6\xe1\x55\x9b\x2d\xc1\x44\x85\x25\x45\x5f\x13\x42\x0e\x83\x23\xc9\xc1\x28\x5f\xb5\xc0\x3e\xcb\x61\x0b\xee\x60\x01\xbd\x25\xd1\x92\x6f\x61\xd4\x28\xe5\xa1\x14\xac\x63\x1c\x96\x14\x62\xec\x33\x4e\xa3\x33\xb3\x3a\xe4\x64\x8c\x32\xaf\x51\xac\x10\x61\x27\xb7\x11\x91\xdf\x18\xc9\x67\xa4\x4d\x27\x94\x56\x7d\xbe\x56\x92\x95\x4d\xab\x68\x3b\x8a\xa4\xff\xec\x44\x25\x58\xa8\x5e\xe0\x59\x6f\xc4\x5d\x96\x74\x05\x71\xa1\x3c\x02\x57\x40\x78\xd4\xec\xa1\xaa\x31\x78\xfc\x3f\x79\x7b\x9d\x53\x15\x35\xce\xb9\xa5\xe2\xaf\x2f\x8b\xd3\xa6\x9c\xda\xb5\xc9\xb9\xc9\x4c\x8e\x0e\x8c\x4b\x11\x1e\x6c\x86\x1e\x97\xc7\x84\x67\x9b\x47\xe0\x89\x03\x5e\x16\x1b\xb8\x55\xab\x17\xac\x2d\xce\x59\xbb\x60\x55\xf8\x2a\x13\xbf\x76\xdc\xda\xdf\xc4\xa4\xd4\xae\xe3\xbe\x99\x30\x01\xde\x1d\x4f\x75\xf8\x5d\x2d\x39\xdc\x5f\x79\x2f\xd1\x89\xa9\x68\x4a\xb0\x53\x22\xe7\x06\x6c\x4e\x76\x98\x4c\x5e\x8d\xd2\xae\x77\x3a\x95\x44\xf6\x72\x7c\x5a\x7a\x9c\xa3\x3a\x14\x17\xe7\x56\x26\x9b\xdd\xc4\xfc\xc1\x10\x74\x9b\x4d\x5e\xa5\x97\x88\x1a\x83\x46\xa5\x24\xf8\x3e\xef\x8b\xb6\x94\x38\xcf\x47\xfc\xc1\x18\x93\x3d\x96\x43\xa5\x06\x23\xaf\x3f\x0d\x15\x45\x9a\x8b\x88\x9d\x48\xc5\x79\x37\x28\x05\x22\x8d\x18\x9e\x15\x80\x36\x9c\xb0\x08\xbf\xbd\x2c\x4d\x14\x7f\xf8\x0b\xcc\xfc\x57\xfc\x92\xf8\xba\x1f\x3b\xbe\xd6\xf3\xa7\x6b\xf7\x7e\x33\xcc\x27\x5e\x4a\x82\x4f\x27\x3c\x20\x9e\x7b\x55\xec\x7c\xf2\xf9\xeb\xe2\x4f\xe2\x9b\x1f\x9c\x4d\x00\x5f\xd3\xcf\x70\xef\xc7\x8a\x4d\xb5\xfa\x27\xb7\x16\xbf\xed\x68\xaa\xe5\x06\xf4\x15\x1f\x13\x8d\x0b\xa7\x63\x7c\xe7\x8b\x7f\xb3\xb3\x53\x8d\xe2\x3a\xc9\x16\x68\xd9\x4f\xe8\xe3\xa0\x24\x47\x5d\xc4\xbb\x99\x14\x2c\x31\x24\x9a\x9d\xc8\x62\xc1\x56\x1c\xe7\x4c\x74\x3b\x54\xbc\x5a\x50\x73\x46\x63\x32\xe7\xb1\x33\x82\x42\xa8\x0e\x39\x2c\x0a\x97\x59\xad\x51\x57\x87\xdc\x06\x8d\x82\xfc\x71\xf1\x3a\x06\x38\x53\x44\xf2\xcb\x26\x9f\x3c\x6e\x22\x7a\xbd\xd5\xd4\xa3\x7d\x68\x4c\xb4\x7a\x49\x51\x81\xb6\x89\x78\x68\xdd\xa7\x7a\xd2\x3d\x40\xfc\xe3\x34\xf6\xcb\xd3\x83\xc2\x0f\xfd\x78\xfe\xd7\xe7\x12\xfe\x71\xbf\xf8\x62\x02\xdc\x0b\x09\x67\xef\x82\x8d\x09\xe2\x0b\x1d\x7e\x4a\x38\x1e\xce\x81\xe6\x5c\xb1\x0e\xb5\x0c\x08\x7d\x98\x04\x8f\x8a\x13\xe0\xd1\x6d\x7f\xdd\x06\x9f\x88\x69\xe4\xb2\xed\xaf\x44\x1e\xef\xf8\x93\xa4\xc3\x56\xb4\x7c\xc7\x75\xe1\x3e\x44\x85\x68\x4b\x70\xa8\x27\x39\xd9\xc1\x58\x7c\xf6\x5c\x36\x43\xaf\x50\x2a\xb3\xe3\x33\xf4\x19\x45\xc5\xb9\x0e\x5a\xa9\x59\x71\x60\x32\x9b\xaa\x43\x3e\x73\x1c\xf9\x4b\xd5\xe8\x3d\x89\x9e\x6a\x0f\xa3\x64\x3c\x9e\xd4\xd4\xc4\x9a\x50\x2a\x20\x85\x41\x41\x9d\xb5\x4a\x05\xa7\x64\x14\x0a\x8d\x86\xaf\x09\x69\xcc\xf2\x88\x1e\xa9\x31\xa8\xed\xce\x18\xc1\x43\x8c\xa2\x6f\xeb\xcf\x93\x6c\xa5\x08\xc5\x7b\x24\x59\x9a\x64\xb6\x47\x84\x32\x25\xf6\x62\xa9\xfa\x23\xcd\x01\xe9\xd1\x26\x66\x82\x1c\x9d\x34\xfb\xd2\xc3\xbe\xd5\x7c\x2c\x63\xdd\x22\x50\x8e\xdf\x57\x26\x9e\x7f\xf3\xef\x9e\x1e\x09\xf3\x67\x7e\xb1\x22\xfc\x65\x02\xa3\xca\x5e\x34\xf5\xca\x9d\x87\xfb\xfc\xfd\xa5\x93\x1f\x78\x37\x24\x5c\x28\x98\x1d\x5a\x3f\xb2\x0c\xbf\x02\x5f\x94\x57\x8d\x9d\x01\x4c\xee\x89\x27\x8f\x3c\x36\x78\xe8\xb6\x65\xa5\xa9\xdb\xfa\xdc\x19\xba\xeb\x4b\xcf\xb1\x3d\x87\xb6\x85\x06\x6c\xcb\xe9\xe4\x48\x4d\x4a\x22\x7c\x30\x9b\xf0\xc1\x25\xc2\x07\x4e\x22\x1d\xc7\x06\x0b\x5c\x4a\x86\x77\xb8\xed\x89\x06\xad\x36\xd1\xcd\x2b\xb9\x64\x42\x1c\xc8\x62\x36\x7b\xed\x89\xda\xc4\xea\x90\xc5\x62\xd0\x07\xb5\xac\xdb\xc1\x10\x0c\x3a\x9d\x3c\x47\x5b\x0a\xdb\x71\x80\x7c\x7b\xfb\xd6\x20\xa9\xb9\x90\xd8\xbb\xb7\xb0\x00\x51\x51\x4c\x8a\x39\x95\x92\x3e\x8f\xb8\x01\x8b\xc5\xb7\xcf\xa5\x2e\x4b\xfb\x5c\x0c\x9f\x85\xd1\xd7\x09\xfd\xbf\xdc\x9c\x7b\x2c\xf9\xcf\xcb\xae\x81\xed\x78\xf3\xcc\xe7\x76\x5f\xfb\x8d\x48\xc0\x41\xc7\x9f\xe1\x5e\x3b\x1b\x0f\xc5\x3f\xff\x0b\xee\xbd\xae\xd9\x54\x6b\x78\x61\x9b\x7f\xe2\x72\x4d\x53\xad\x15\xb4\x0f\xfe\xf9\x46\x1c\x3b\xc5\x2e\xae\x6e\x69\x11\x77\x33\xef\xc1\x42\xfe\x31\x83\x80\xb4\xa2\x17\x12\x25\x19\xb9\xba\xe5\x27\xfe\x1c\xf7\x20\x29\xb3\x9b\x68\x84\xce\x78\x42\xb0\x25\xc1\xed\x8a\x2f\x49\xf6\x65\x19\x0d\x98\x71\x28\x95\x8c\x21\x2b\x39\xde\x2d\x04\xba\x24\xe6\xd5\x87\xd2\x13\x1b\x46\xa6\x17\x91\x6b\x5c\x02\xef\x72\x60\xcc\xf3\xa8\x3e\xa4\xe5\x1b\x46\x6a\x2d\xf5\x21\xc1\x08\x6a\xa3\x51\x2b\xe4\x04\xc0\x15\x00\x6d\x00\xfc\x62\x00\xbe\x0f\xc0\xa7\x01\x78\x3b\x00\x27\x03\x70\x28\x00\xbb\x02\xf0\x40\x00\x96\x04\x60\x5a\x00\x46\x05\xa0\x22\x00\x5d\x03\x90\x1b\x00\x67\x00\x14\x01\xf8\x35\x00\xdf\x04\xe0\x93\x00\x9c\x8b\x86\x7f\x34\x00\x0f\x06\x60\xa9\x14\xbe\x2c\x00\x25\x01\x70\x04\x40\x19\x80\xdf\xa4\x90\x1f\x07\xe0\x2d\x29\xe4\xf6\x00\xdc\x1f\x80\x89\x01\xc8\x08\x40\x9c\x14\x40\x98\x1c\x80\x11\xd1\x38\x59\xd2\x5b\x95\x14\xed\x2f\x01\x38\x1e\x80\x9d\x01\x58\x17\x80\x7b\x02\x40\x82\x85\x02\xd0\x4f\x0a\x26\x45\x0e\x36\xd0\x80\x53\x1a\x03\xf0\xcf\x00\x5c\x0f\xc0\x85\x00\xbc\x12\x80\x03\x01\x38\x2c\xe5\x7e\x5f\x00\xd6\x07\x60\x73\x00\x96\x07\x60\x46\x00\xc6\x04\x60\x40\x00\x4a\xa5\xb8\xf9\x52\xe6\x12\xa5\xe4\xf5\x52\x61\x5a\xa4\x5c\xde\x94\x8a\x74\x43\x02\xf5\x72\x00\x9e\x0f\xc0\xde\x00\x6c\x0a\xc0\x0a\x09\x42\x75\x00\x06\x4a\x10\x08\xda\xb2\x03\x10\x2f\x21\x4f\x1d\x80\xa6\x00\x7c\x17\x80\xab\x01\x78\x47\x8a\xf5\x5c\x34\xd6\x32\x29\xd6\xc8\x00\xf4\x0d\x40\x67\x29\x0a\x09\xaf\x21\xf7\xa8\xba\xdd\x28\x94\x5b\xc6\xaa\xdc\x76\x58\xcb\xed\x47\xb8\xb4\x45\x1c\xf3\x87\xb0\x6e\x17\x9d\x9a\xfd\x63\xe8\x90\x7a\x49\x14\x50\x2b\x21\x3b\xb6\xb9\x26\x76\x10\x8c\x3f\xca\xf4\xa6\xe2\xd6\xb6\x4f\x6a\x11\xd8\x88\x3b\xeb\x63\x62\xc6\xbb\x98\x8a\xed\x52\x8f\x8a\x6c\x82\xc1\x53\xbb\x8a\x56\xa5\xbf\xb0\x6c\xfd\xf6\x09\x2f\x6d\x5a\xb2\x03\x6f\xe0\x2a\xba\x8f\x99\xdd\xbb\xff\x40\x3a\x8c\x65\xc3\xb2\xfb\x8a\x67\xd4\x86\x96\xae\x1b\xfd\xc2\xaa\x9e\x55\xc1\xec\xe5\x77\xce\x08\xe0\xa5\x07\xe2\x96\xde\xf7\xec\xde\x07\xc1\xb6\x7d\xd3\x7c\x75\xff\xca\x39\x4d\x77\xdf\x7d\x77\x78\x0d\xb7\x2a\xfc\xd3\xde\xed\x53\xbe\x7a\xfa\xce\x27\x77\x6e\x81\x84\xad\xd3\xba\xad\xfd\xb0\xff\x2b\xf7\x81\xa2\xa6\x5e\xb6\x93\x7e\x6c\xf9\x0e\xdf\xe0\xb6\x11\x49\x90\x4d\x3c\x00\xe2\xdf\xa4\x26\x1a\x12\xdd\x71\x36\xce\x95\xc9\x30\xb9\xae\x1c\x77\x1a\x8a\xe7\xe3\x90\xcb\x65\x4e\xd6\xeb\x91\xc6\x1c\x97\x4c\x07\x18\x11\x4b\x95\x18\xa6\x44\x02\xe6\x13\x21\x78\xde\xd8\xba\x7c\x43\xdb\xf0\x4b\x5a\x34\xac\x87\x88\x7d\x49\x57\x6d\x88\xf4\x71\xf2\x02\xb1\x42\xcd\x74\x78\x0f\x2f\x30\xb4\xac\x69\xb8\xa0\x72\xf4\xd7\xaf\xe6\x6a\x3b\x24\x76\xae\x4a\xbb\xc3\xbf\x6e\x7c\xcd\x74\x85\xb7\xac\x4c\x3f\xa8\xdb\x1c\xcf\x43\xcb\x3b\x96\xc6\x8d\xdd\xfe\x64\x16\xb7\x6d\xc2\xb4\x77\xc5\x8d\x13\xbe\xec\xee\xef\x5a\x3c\x69\xfa\x33\x9b\xa7\xcd\x70\xf4\xfe\xb3\x27\xae\xaf\x3b\x01\x97\x3f\x71\x7f\x45\xcd\x4a\x51\x1f\x82\xe2\x97\x83\x77\xc8\xed\x79\x43\x11\x52\x8c\x94\xc6\x79\x18\x09\xc7\xe7\xa0\x59\xc1\xae\x89\x69\x59\x5e\x6f\x8a\x4d\xc8\xca\x8e\xd7\xe9\x70\xb6\x80\x52\xf8\xdc\xbc\xec\xac\xac\x54\xd6\x51\x1f\x52\x9b\xea\x43\x7a\x36\x91\xc5\x4a\x86\x55\xb3\x6a\x94\x96\x94\xca\x20\xa0\xfd\x63\x39\xe9\xde\xc4\x14\xb9\xc1\xc3\x17\x69\x3d\x92\x55\x20\xed\xdb\x95\x49\xc0\xd7\xbe\xf6\x25\xef\x8e\xfa\x1a\x8c\x24\xee\x4d\x1e\x49\xb8\x63\x26\x66\x40\x53\x9a\x12\x68\x53\x31\x71\x91\x08\x32\x7c\xc0\xf9\xe3\xf1\x92\xf8\xc6\xda\x3d\xda\x5e\x30\x98\x9e\xbf\xa8\x9e\xd6\xed\xb1\xb1\x33\x4a\x87\x35\xf7\x13\xad\x36\x4b\xdd\x63\x60\x7c\x1b\xbe\x77\x9a\xeb\xf6\x8b\x37\x1f\x7e\x18\xb2\xf7\x6c\xea\x72\x07\x8c\xa3\x67\x71\x2f\xde\x5f\x7d\xa1\xea\xd8\xf8\x0f\x87\x8c\xe9\xdf\xec\x63\x4f\x1e\xaa\x69\x1e\xc4\xad\x6a\xea\xfe\x72\x35\xf3\x78\xe3\x0a\x8a\x8b\x6e\x2d\x3f\x70\x5f\x10\xbf\x58\x85\xcc\xc8\x8b\x7c\x68\x48\x30\x2f\x27\x5e\x43\x34\x27\x6f\x48\x21\xd2\x1d\xe2\xd9\xc2\x22\x8d\xea\xad\x10\x56\xbf\x15\x02\x0d\xc6\x1a\x60\x1c\x49\x49\x19\x7f\x09\x25\xb1\x8e\x0e\x7f\x09\x39\xcc\x6d\x5d\xda\xb2\xd5\xf7\x3b\x72\xa7\x5d\xec\x46\xa9\x98\x7c\x36\xc4\x45\xbb\xf8\x81\x78\x19\x31\x3d\x45\x26\xa1\x10\xa7\xc8\x5d\x45\x26\xd6\x57\x90\x62\xc2\x9b\xee\x87\x11\x6b\x0e\xec\xdf\xf0\xfe\xdb\x95\xc3\x87\x0d\xc2\x0f\xbe\x26\x1e\x7e\xed\x0d\xf1\xb9\x17\x4f\x43\xe5\x6b\xa7\x61\xd0\xab\xa3\x9e\x11\xaf\x1e\x7c\x46\xbc\xf6\xcc\x01\x48\x3e\x70\x00\xd2\x9e\x21\x5a\x23\x7b\xcd\xec\xf9\xf7\xc3\x03\xe2\xb5\x8a\xb2\xde\xfd\xc4\x8f\x68\x94\xb7\xa0\xff\xcb\xaf\x41\xe5\xe9\xd7\xc5\x23\xa7\x0f\x80\xe7\xe0\x01\xf1\xda\xd3\xe4\x78\xe6\x19\x3a\x83\x8f\xe8\xbb\x97\xf0\x62\x21\x4e\xea\x23\x8a\x43\xeb\x83\x21\x3d\x42\x46\xb5\x42\xa1\x34\x5b\x8c\x4a\x0b\xe3\x74\xe9\x5d\x89\xae\x81\xae\x6a\x17\x5b\xad\x27\xd7\xcd\xae\x8b\xae\x1b\x2e\x2e\x7a\xcb\xb6\xde\xe4\x33\x26\x9b\xdd\xf6\x76\x48\x4b\x7c\x64\x25\x51\x90\x49\x96\x4a\xcb\x4a\x0b\x4b\x7b\xfa\x78\xbd\x5a\xa5\xb2\xcb\x23\x6f\xa8\x0a\x34\xbc\x33\xba\xa0\xa0\x20\xe2\x1f\x4b\x13\x71\xe6\x50\x7b\xe1\x16\x8c\x19\x09\x01\x30\xe9\x82\xd1\x6b\xf4\x99\xed\x84\x0a\x8c\x40\x47\x94\x14\x79\xac\xfc\x6e\xc5\xbf\xa7\x3d\xde\x1f\xaf\x7c\xe5\x86\xbe\xdf\x33\x0d\x4d\x19\xf7\xb5\xe0\x07\xf0\x62\x3c\xd5\x16\x3e\x04\x7b\x2e\xa4\x84\x4f\x30\x42\xf8\x7c\xd6\xab\xb0\xa7\xf9\x37\xbc\x33\x3c\x09\xef\x9c\x39\x93\xda\x41\x33\x24\x3f\x60\x3b\xa9\xe3\x9e\xc1\x14\x5e\xe3\x70\xb3\x56\xbd\xd5\xa3\xa7\xf6\x8d\x8b\x4d\x49\xd5\x38\x1c\x0a\x97\xd3\x55\x1d\x52\x3b\x4d\x88\x58\x41\xd4\x73\x68\x1d\x27\x28\xd1\x6d\xb4\x4e\xe5\x1e\xad\x24\x64\xb4\x60\xa1\xb8\x0b\x58\x3d\x45\x12\xa3\x4a\x5e\xa1\xc9\x4e\x1e\x7d\x05\xf6\x34\x5c\x64\x40\x8c\x05\xf2\x61\xe4\x95\xf7\x76\x15\xff\x14\x3e\x7a\xf4\xc5\xef\x3f\xfa\xe4\xfb\x93\xc7\xc2\x47\x7f\x2a\xde\xf5\xee\x47\x30\x92\xdb\x2e\xfe\x59\xfc\xe4\x2d\xf1\xd9\xb9\xea\x47\x3f\xab\x86\x84\x86\xaf\x45\xf1\xeb\xe3\xe2\xe7\x35\x9f\x3d\xaa\x9e\x0d\x77\xbe\x0d\x69\x30\x90\xd6\xcf\xf0\x96\x4f\xd9\xa5\x6c\x19\xb1\x4f\x13\x51\xb7\xa0\xc7\xa1\xb1\x58\x13\xb5\x2c\x6b\xd5\x30\x9e\x24\x6d\x7e\x22\x24\x26\xa2\x78\x85\xc1\x6a\x01\xde\x02\x16\x23\x6d\x14\x3e\xef\x1b\x3d\x5a\x12\x41\xa3\xcf\xc7\x1a\xdd\x74\x77\xf1\x34\x1c\x11\xb6\x26\xab\xc7\xd8\xda\xaa\x62\x36\x52\xc9\x2b\x18\xf1\xd4\xbd\x3f\xac\xbd\xef\x3f\xdb\x77\xfe\x78\x5f\xf3\x1b\x05\x8f\xdf\xb9\xe6\xc4\x80\xb2\x71\xd7\xb6\xf9\xf6\x0f\x3b\x3a\x3f\xb9\x16\x84\x3d\x4f\xa1\x96\x87\x36\x89\xe2\x93\xe2\xa3\xc5\xbd\xa7\x2d\xcf\xda\xbd\x18\x3f\x00\xd6\xa2\xee\xf3\xc5\x7f\xc8\x72\x45\xdd\xf2\xa6\x30\x9e\xfb\x46\x1a\x23\xa5\x43\xc5\x68\x4e\xb0\x2b\xe0\x1c\x63\x22\x62\x52\x1d\x85\x85\x4c\xa2\x5a\xa7\xc5\x0a\x85\xbf\x93\x96\x27\xf6\x82\x96\x55\xb2\x8a\x1c\x47\xb2\x3e\x39\xb3\x3e\x94\x96\x96\xac\x20\x7f\x0c\xd6\xeb\xad\xf5\x21\x93\x49\x6f\x66\x34\x84\x8e\x4a\x7d\x17\xe4\x46\x69\xc3\x19\x79\x69\x90\xd6\xb6\xe9\xdb\x78\x15\x52\x19\x95\xe0\x55\xd2\x16\x34\x22\x3d\xcc\x6a\x22\x41\x92\xda\xb5\x4b\x43\xc4\xeb\x6f\xd7\x30\x4d\x5b\xb3\xd3\x1a\x1f\xdc\xc9\xcd\x6b\x66\x33\xc4\x53\x9b\x1e\x82\x1f\x1e\xd8\xf1\xd3\x99\x5f\x99\x41\xe2\xc5\xdc\x4d\xba\xc9\x93\x66\xce\x4e\x28\x5f\x72\xdf\xd4\x13\xdb\xd6\x3f\x6f\x5b\x67\x9a\x30\x7c\xd8\x04\x47\xe7\xfb\xe6\x0f\xeb\xf8\x12\xf7\xcd\x6f\x9f\xf2\xc9\xcd\xf3\x51\x4b\x0b\x33\xa3\xf9\x61\xfc\x77\x71\x5d\xb3\xfb\xdf\xb6\x81\x7d\xfa\xdf\x91\x96\x4d\x44\xfa\xbc\xaa\x99\x2b\xa6\x8c\x77\x07\xbb\x06\xbb\x78\x32\x12\xd3\x93\x4b\xee\x0c\x2e\x7f\x18\x41\xcb\xbf\x88\xe3\x71\x9a\xed\x8c\x94\xa8\x20\xe8\x44\x40\xa5\x1d\xa3\x66\x54\x0a\xa1\x32\xa4\x50\x30\x88\x61\x2b\x43\x8c\x15\xe9\x51\x4c\x87\x07\xb4\xb5\x24\xfa\x18\x22\x3e\x69\x73\x0d\xa3\x3b\x76\x29\x0c\x2e\x5c\xde\x2d\x7c\xcd\x85\x53\xd8\xce\x4d\x67\x37\x40\xe9\x03\xf2\x5c\xdd\xae\xc4\xa6\x1b\x2b\x8d\x09\x94\xe7\x26\x87\xe9\x68\x3b\xa3\x80\xe6\x33\xeb\xc3\xe7\x91\x70\x04\x67\xc4\xc9\xcb\x49\x90\xb0\x19\x24\xec\x5a\x6e\x23\x09\x3b\x4f\x25\x87\xcd\x8a\x84\x7d\x4e\x0e\xdb\xb5\x2d\x6c\xd7\x96\x9f\xf9\x01\xb1\x70\xf1\x6f\x34\x2c\xc9\xf7\x0c\x12\x56\x7d\x8c\x65\x70\xbc\x8d\xae\x42\x16\x09\xdf\x4d\x0a\x4f\x61\xcf\x57\xfe\x41\xf8\x4e\xb1\xe1\xc7\x47\xe1\x2b\x78\xeb\x1f\x84\xcf\x8f\x0d\xbf\x94\x84\xef\x2c\x85\x17\xba\xc9\xe1\x0f\x44\xc2\x8f\x88\x86\x77\xc7\x86\x77\xb4\x7c\xc7\xbc\xc2\x0e\x30\xf1\xd8\x26\x0d\x31\xdf\x8f\x26\xf0\x63\x70\x2f\xa4\x45\x09\x41\xad\x1a\x29\x18\x2d\x83\x38\x56\xa7\xd7\x6a\x50\xfe\xf9\x56\xae\x27\x68\xa7\x8b\x44\xa4\x17\x15\xd3\xd9\x5b\x1e\x2b\x5e\x55\xd2\xad\x6c\xc5\xe6\xcd\x2b\xca\xba\x95\x30\xd7\x21\xb3\xe7\xbd\xdb\xfa\xa6\xf4\xdd\x76\x6f\xcf\x2a\x0a\xd3\xd0\xf2\x3a\xfe\x81\x5d\x41\x60\x66\x04\x4d\x1c\xaf\xd1\x68\x95\x5a\xcc\xe8\xf4\x6a\xa4\xc4\xda\x95\x1c\x9d\x4b\xfc\x4e\x41\x6b\x07\x8b\xdc\xde\xc9\x0b\x14\xb6\xcd\x6e\x4d\x4b\x37\x7a\xe1\x72\x1b\x40\xe6\xb1\xb6\xa4\x9a\xbd\xbf\xcf\x33\x52\x63\xa5\x46\xa9\x26\x8e\x84\x4e\xa3\xbd\x25\xcf\x69\xe9\x14\xa2\xd4\xc2\xec\x29\xe2\x56\xc4\x02\x82\x15\xff\x45\x9e\x79\x4e\xab\xd5\x28\x35\x98\xd1\xeb\x28\xf8\x95\x3c\x41\xc6\x75\xe7\xad\x79\x4e\x2d\xf6\x53\xd8\x04\x2b\x36\xbb\xd1\x87\xb3\xdb\x00\xee\x8f\xc5\x0e\x6a\x97\x67\x3b\x4a\x0f\x9a\x35\x76\xbd\x85\xe2\x9a\x23\x42\xd2\x6e\xe2\xe3\x1c\x44\x60\xc4\xe4\xfc\x36\x18\x8f\x29\x49\x2c\xee\xb1\xd8\x76\x1f\x53\x0b\xad\x37\x72\xda\xd1\xb2\xd9\x89\xec\x4f\xe2\x8d\x9c\xc9\x68\xd2\xd8\x95\x7a\x6c\xb1\xd8\x35\x7a\x36\xce\xa1\xb1\xeb\xac\x2b\x4d\x41\x5a\x3d\x52\xed\xd0\x82\x3a\xdb\x95\xb7\x6d\x44\xc3\x2d\x55\x15\x83\x82\x98\x4a\x6b\xbd\x89\xad\xbc\x30\x6e\xbb\x97\xec\x4b\x92\xaf\x32\x29\x5f\x0c\x72\xa1\xee\x24\x67\xc8\xa1\xb4\xa9\xac\x5a\x30\x9b\x0d\x56\x9b\xcb\xc1\xc7\x27\x18\x5c\xa6\x38\x1b\x83\x6c\x7a\x56\xcb\x2b\x51\x3e\xcd\xd1\xf5\x4f\xcf\x1b\x62\x72\xd6\xd6\xdc\xc9\x79\xac\x1e\xf3\x1f\xe5\xcd\x00\x9f\x89\x49\x6f\xfc\x3e\x83\x93\x2a\xd9\xe1\x7f\x90\x45\x8c\x3a\xb5\x7c\xc9\x9c\xe4\xde\x40\xf1\x28\x8b\x60\xce\x9b\xa2\x48\x20\xe6\x81\x5d\xc1\x64\xe7\x68\x92\x06\x85\xf4\x1a\x0d\xe7\xb4\xdb\x9d\x4e\x4b\x65\xc8\x89\xb8\xf4\xca\x10\x67\x8b\x1a\x43\xd4\xf0\xa3\x16\xb0\x2f\x46\x42\xd3\x06\x59\x15\xf0\x31\x16\xbf\xcf\x2f\x0f\x0b\xf0\x93\x27\x13\x23\xc9\x64\x2c\xdb\xc4\x26\xe6\x64\xd9\x96\x0f\xd7\xfc\xe9\xd9\x15\x17\x96\x0f\x5d\x9b\xc4\xb2\xf7\xae\x2a\xbc\xa7\x63\xca\xec\x59\xaf\x5f\x7c\xdf\x38\xfd\x8e\x41\xf7\x0d\x1b\x31\x78\xc0\xfd\xd5\xcc\xc1\xbd\xe2\xfd\xe2\x97\x5b\xce\x1d\x7b\x0a\xba\x3d\x31\x7e\xe8\xfc\x33\xef\xa5\xa7\x6c\xe9\x26\x7e\x1d\x6e\x1a\x3e\x77\x8d\xd8\xb4\x66\xee\x7d\x3b\xa4\xbd\x7c\x31\x72\x10\x05\xf5\x0e\xb1\x73\x38\x62\xe9\xf9\x83\x2e\x05\x62\x30\x71\xe7\x39\x1e\x31\x6a\x0d\xcf\x60\x46\xc9\x82\x02\x29\xaa\xe5\xd1\xc8\xad\xe3\x9e\xda\xc6\x32\x18\xa5\x41\xc8\x44\xa3\x58\x81\x01\x0f\x38\xe0\xfa\x4f\xf0\x79\xf8\x89\x71\xe2\xdb\x4c\xa1\x78\xb6\x96\xfd\xa1\xc9\xb4\x85\x6d\x14\xbf\x6d\x3e\xce\xf4\xa5\xf6\x46\x93\x58\xc2\xbd\x24\xf5\x99\xa7\x04\x8d\x0c\x8b\x04\x56\x50\x28\x39\x4c\xbb\x5e\x59\x69\x6a\x0d\x9d\x9f\x15\xb3\xf6\x9d\x34\x6a\xd8\x63\xe4\xd8\xe6\xfa\x53\xec\x6b\x62\x09\xff\xd4\x6f\x23\x84\xb2\x5f\x1b\x28\xac\xb7\x09\xac\x1a\x02\x4b\x8d\xfa\x07\xd3\x79\x15\x9d\xfc\xa5\x24\x30\x14\x2a\x46\xab\x61\x08\xe0\xea\x90\x42\x8f\xc1\xc6\x60\xac\x64\x19\x50\x22\x25\x29\x06\x8a\x34\x41\x98\x4a\xba\x52\x63\x3c\x76\x64\x46\x2b\x87\x99\x8b\x94\x40\x4c\x2a\x8f\x12\x3c\xd6\xb7\xf1\x92\xf0\x36\xb6\x47\xf3\x11\x5c\x16\x7e\x86\xd9\x2f\x96\x4c\x67\xba\x30\xc5\x53\x76\x36\x37\x36\x7f\xbf\x93\xe4\x61\x35\xae\x61\xef\xc6\xff\x26\xb4\x6a\x0b\xaa\xa8\x88\x04\xf4\x5c\x08\x8e\xa2\x48\x29\x28\x30\x8f\x75\x35\xf3\x39\xae\x79\xf8\x61\x22\x67\xa3\x63\xc9\x0d\xbc\x10\x96\xda\xa1\x9e\x84\x57\x60\x0b\xde\x45\xe2\xe7\x06\xe3\x31\xa9\x0c\x0e\xc1\xee\x91\xf9\xe4\x4b\xd0\x95\x5d\x86\x82\xb6\x38\x72\xd2\x59\xca\x68\xc6\xb3\xb3\xa5\x41\xf0\xf2\x82\x00\x7e\x9f\xf0\x64\xf6\xeb\xd9\xf0\xca\xb5\x6b\x14\x8e\xaf\xe5\xdf\xec\x38\x7e\x28\x52\xa0\x92\x60\x3c\x20\x9e\xe7\x04\x41\xc1\x91\x92\x2b\x14\x2a\x0e\x1f\x0e\x25\x72\xc0\x71\x20\xf0\x80\xf2\x7d\xf9\xd4\x08\xca\x6e\x9b\x1c\x10\x5d\x40\x8f\xf3\x02\x31\x25\xcd\xe0\xc3\x33\xa6\x88\x5f\xd6\x83\xee\xdf\xf0\xfc\x2a\x1d\xe3\x98\x1f\x1e\xc0\xdd\x4f\x72\x38\x19\x9d\xe3\x66\x32\x57\x90\x05\x25\x11\xef\xe8\xed\xe0\x2e\x37\x4a\x57\xab\x3d\x06\xce\x81\xf8\xbc\xdc\xc3\x79\xa0\xcf\x4b\xcc\xcb\xcf\xab\xce\x5b\x91\xb7\x39\x6f\x5f\x9e\xa0\xcf\x2b\xcd\x1b\x28\x3d\x1e\xce\x3b\x95\x77\x31\xef\x66\x9e\xb2\xf3\xcd\xbc\x96\x3c\x9c\x17\x1c\x3d\xb6\x2c\x2f\x58\x35\xa2\xec\xdd\x3c\x48\x24\xa1\x36\x93\x10\x6c\x75\xde\x4c\x12\x88\x91\x42\x90\xf7\x14\x08\xae\xa1\xdf\xc1\xfa\x59\x0a\xa4\xe8\x5c\x37\xb3\x20\x8b\x73\x78\x0c\x2c\x53\xaa\x38\xa5\xc0\xa5\x8a\x81\x0a\xac\x08\xea\x6d\x65\x74\x75\x40\x93\x5e\x77\x51\x77\x53\xc7\xe8\x82\xce\x94\x32\x1d\x5d\x33\xc0\x77\x8d\x0e\xd8\x2c\xb0\x97\x9c\x1f\x5d\x60\x20\x07\xc8\xae\xfa\x9c\x39\xd9\x74\x22\xf6\xec\x39\x31\x13\xff\x68\x9b\x3c\xd3\xd6\xff\x61\x36\x11\x36\x4c\x4d\xa6\xdd\x1e\xb2\x5b\xc2\x45\x0c\x23\xca\x83\xdc\xcc\x17\xee\x3f\xb7\xa6\xf4\xf9\x11\x1b\x9e\xff\xf3\xba\xb7\x56\x6e\x7e\xf5\xc1\x03\xe2\xd1\xde\x0b\x3b\xf9\x16\xf6\x1f\x32\x7d\xba\xe8\xf3\x2d\x1c\x30\x74\xf2\xa4\x61\xbd\x17\xe1\x01\x4f\x5d\x07\xe7\x8a\x6d\xef\xbf\x70\xe8\x23\xf1\x4b\xb0\x7e\x38\x64\xf9\xbd\x2b\x57\xd6\xce\x9e\xba\xa5\x71\xe5\xca\x2d\x33\x67\x6d\x5a\x4e\x64\xf0\x4e\x84\xf8\x1a\xf6\x4d\xc2\x7f\xd6\xe3\x98\xe3\x58\x5e\xc0\x9c\x2c\xf3\x23\xc3\x90\x7d\x74\xb6\x15\xec\x1c\xc3\x4e\x69\xea\xc4\xbe\xd9\xb4\x63\x8c\x2c\xbb\x6d\x2d\x22\x7b\x90\x55\x10\xef\xec\x6f\xc1\x67\xd5\x2a\x33\x61\x5f\xab\xa5\x8b\x15\xf2\xad\xe0\xb2\x82\xde\x0a\xdf\x5a\x9b\xac\x78\xab\x15\xa6\x5a\x97\x58\xf1\x40\x2b\xa8\xad\x2e\x6b\xb6\x95\x99\xfe\xa2\xf5\x9c\xf5\x5b\x2b\x43\xbe\x94\xd3\x49\xce\xd2\x7c\xd8\x63\x74\xa2\xea\x54\xfa\x28\xcf\x46\x66\xbf\xa5\xb3\x6d\x61\x83\x15\x56\x50\x70\xd9\xd6\x72\xeb\x48\xeb\x54\x2b\x47\xc0\x76\xb1\x06\x8b\x4b\xca\x6e\xd2\x9b\x72\x2b\x85\xbd\xc1\x7a\xc8\x7a\xd5\x2a\x90\x74\xb1\x9e\x26\x3f\xd0\x3a\xd3\xca\x58\x83\x89\xde\x32\x6b\xd0\x64\x2d\x7b\x88\x66\x46\x7e\xcb\x0a\x7a\x4e\x2d\xb1\xf8\x79\x18\x23\x8f\xaa\xad\xa6\x2b\x0b\x8c\x69\x6d\x43\x69\x6b\x6b\x91\x27\x09\x45\xa5\x00\x67\x94\x3a\x88\xdd\x60\x25\xc2\x40\xf6\x29\x8c\x60\x9b\xf7\xde\xbd\xab\xdf\x5f\x38\xf1\xcc\x63\xfb\x5f\xc5\x18\x6d\xbf\xb9\x76\xcd\xbf\xb7\x8a\x08\xe3\x57\xbe\xf8\xdb\x69\x91\x8e\xcd\xdf\x2b\x96\xe0\xad\xdc\xe7\xc4\xf8\xcf\x0c\x5a\x2c\x82\x40\x88\xc3\xc1\xd8\xd5\x86\xca\x90\x1a\x10\x57\x29\x09\x03\x49\x2c\xb7\x8e\xcf\x23\x7c\x95\x4c\xf4\x82\xaf\xa0\x88\xa1\x74\x40\xd4\x85\x94\x96\x85\x4f\x19\xe8\x0f\x94\x3c\x8b\x9f\x7f\x6a\x58\x4e\xc7\x1e\x43\x42\xcf\x8b\x25\xe6\x2d\x8e\x6f\xd8\xf7\x9e\xad\x37\x6d\x75\x2d\x9c\xd3\x94\xfb\xec\x71\x79\x5e\x6c\x05\x54\xb2\x41\xe6\x27\x64\xa5\x6b\x15\x06\x53\x95\x6e\x53\xa6\x3b\x33\x27\xd7\x92\x5b\x98\x3b\x34\x97\xf9\x21\x17\xbe\xc8\x85\x77\x73\xc1\x92\x0b\x4f\xe4\x1e\xcb\xfd\x20\xf7\xa7\x5c\x36\x97\x8e\x4e\xee\x3a\x78\x64\xd9\x43\xb9\x80\x51\x6e\x52\x6e\x30\xb7\x26\x77\x56\xee\xca\x5c\xbe\x54\xbe\x5f\x99\xfb\x58\xee\xab\xb9\xef\xe6\x0a\xd1\x8f\x2b\x73\x39\x7a\xfb\x59\x2e\x23\x30\xb6\xb4\xe7\x42\x6e\xba\xc2\x98\x37\x50\xe6\xb6\xd1\xe1\xd0\xf6\xf8\x32\xe9\x6a\xb0\x48\xd7\x60\xb2\x52\x53\x66\x0b\x66\x04\x33\x03\x65\x19\x1e\x8f\xeb\xb9\xd0\x4c\x0f\x20\x8f\xc1\x83\xd5\x8c\x47\x1d\x44\x86\xe7\x42\x0a\x1a\x3f\x3d\x50\xa6\x40\x91\xf8\x28\x12\x3f\x32\x70\x5a\x43\x64\x90\x89\xc6\x37\xa9\xd5\xdc\x73\x21\xbd\xfa\xa2\x1a\xab\x83\x24\x9c\x3a\xa8\x36\x97\xa9\xa9\x68\x1a\x2d\x79\x23\xd9\xce\xeb\x44\x4a\x9d\xc9\x96\x06\x2c\xbd\x23\x2d\x22\xd1\xee\x75\xd4\xaf\xad\x96\x86\x52\xcf\xa6\x3c\xd8\x2a\xe9\x93\xd3\xd2\x25\xad\x57\x44\x11\x4f\x19\xcf\x6f\xd5\x01\x73\xfb\xb7\x81\x3b\x6a\xfb\xae\x1d\x5a\x3a\xa7\xcf\x9c\x6d\x13\xd7\x4c\x9b\xd3\xe1\xde\x39\x81\xb9\x77\x4a\xef\x7a\xce\xeb\x3e\x73\xe7\xdd\x6b\xb7\x0c\x4b\x21\xef\xe6\xe3\x5f\xb2\x9d\xb9\xa9\xbe\x87\x86\xe6\x67\x24\x8d\xd9\x96\x95\x26\x8e\xc8\x71\xe6\x67\xe6\x6f\x1c\x9a\xe7\xb3\x8c\xda\x92\x9b\x2a\xf7\x67\x77\x47\x7e\x36\x85\x33\x10\x5e\x9a\x11\xec\x6e\xd2\x19\x04\x23\xcf\x82\x5a\xad\x01\xac\x60\x59\xac\xa1\xcb\x08\x18\x88\x96\x52\x3c\x17\xa2\xcb\x5c\xb1\x1c\xfb\x5c\xc8\xc8\xd3\xd5\x42\xaa\xb9\x99\xdc\x0d\x8e\xe3\xb4\x1a\xb5\xaa\x52\xf9\xae\x12\x47\x66\xa6\xd2\xe9\x17\xbe\x0b\xa3\x23\xd3\x44\xa3\xbd\x1d\x31\x66\x5c\xd4\x67\xa1\x5d\x1d\x44\xe2\x7a\x8a\xe8\x48\x36\xc2\xe7\xe4\x80\x57\x77\xd6\xee\xf8\x27\xf8\x5f\x11\xd5\xb8\xeb\xae\xcd\x3b\xc1\x2a\xee\x3f\x85\x13\x60\xb8\x78\x03\x3c\x5b\x61\xda\x56\x48\x11\xaf\x6d\x15\xb7\x6e\x95\xc7\x6c\x4c\x40\x3f\xb1\x7d\xd8\xca\xc8\x1c\xa3\x7e\xc1\x5c\x35\x23\x28\x10\x2b\xb0\x5a\x8d\x42\x49\xc7\xad\x4a\x93\xa8\x0e\x73\x17\x39\x0e\xd1\xa5\x4d\x92\x00\xe8\x40\xd6\x7c\xb8\x01\xac\x82\x28\x03\x52\x1f\xe7\x49\x86\xa5\x3e\xe3\xb6\x75\x78\x7c\xb2\xde\x82\xc8\x31\x81\xf9\xbc\x39\x41\x3e\x98\x97\xb6\x6e\x0d\x77\xda\xba\x15\x26\xd0\x1c\x60\xda\x8f\xc8\xa6\xb0\x17\xa5\xb9\x34\x7d\x82\x99\x2c\xb9\x11\x78\x46\x25\xa8\xd4\x1a\x81\x20\x4c\x18\xc8\x57\xf3\x9b\x79\x86\x0f\xe2\x4a\xbc\x12\x53\xfc\x55\xb2\x2b\x59\xcc\xa2\xb8\x7c\x82\xa5\xf3\xa3\xcf\x8f\x96\xdd\xd5\x48\xc2\xf2\xca\x22\x45\x60\x55\x82\x95\x23\x29\x77\x27\xa9\x3e\xc5\x8c\x68\x76\x11\x0d\xba\xf0\x3c\x6c\xd8\x25\x3e\x23\x3e\xf3\xc8\x77\xb5\xb5\x34\xed\xee\xed\xd3\xc6\x3c\x41\x88\xc0\xb7\xa5\xcd\x73\x41\x96\xa6\xc6\xb0\x03\x51\x35\xda\x4c\x70\x44\xf3\x40\x64\x45\x1c\x9d\x3c\x7c\x7e\xb4\x3c\xd1\x3a\x6a\x6c\xc8\x69\xfb\xa9\xee\x07\xa9\xd4\xdd\x49\xba\x4f\xc9\xa5\xfe\xee\x11\x18\x0e\xc3\x77\x89\xf3\xcf\x87\xd7\xcb\x69\xef\x21\x69\xfb\xd9\x55\xc4\xbb\x57\x12\xcf\xc0\x48\xfc\x77\x3a\x4b\x8d\x67\x11\xab\x52\x63\x05\xf1\x29\xf3\xcf\xb7\x22\xb4\x55\xb8\xf8\x8c\x4a\x30\xa6\x7a\xc8\x79\x0f\x9c\x87\xf3\xcd\xf5\xb8\x51\x5c\x2d\xae\xc6\x4b\x30\x1f\x6e\x0c\xaf\x1d\x8c\x79\x38\x28\x56\x49\x34\x39\x01\x1d\x63\xfb\x10\xbb\x82\xea\x05\x16\x00\xf3\x74\xa9\xa3\xfc\x77\x5a\xf5\x82\x5f\x9a\x84\x4b\x2b\xe6\xf9\x63\xb8\xdb\xc3\xe2\x50\x04\x38\x39\xbc\x8b\xb9\xc4\x1f\x24\xb2\xc7\x19\x54\x11\x1d\xa1\x20\xfe\x87\x9a\x23\x95\x9c\x7f\x3e\x46\xa1\x10\x09\x5a\x1c\x9d\x5c\x93\x2e\x71\x97\xc0\x5b\x71\xdd\x96\x67\x96\x97\x96\xfb\x52\xdd\x5a\x43\x9a\xc7\x90\xa2\xe4\xc3\xbb\x84\xaa\x33\xbf\x94\x76\xc8\x28\x54\x29\xb2\xd2\xd3\xbd\x93\x65\xbd\xc3\x85\x77\xe1\x3a\x92\x86\x85\xa6\x01\xc4\xdc\xb0\xda\x48\x1a\xe8\x96\x34\x7c\xc6\xb6\xd9\xd6\x76\x9b\x5d\x9a\x8c\x82\x93\xb7\x3c\xbe\xa6\xcb\x80\x82\x14\x8f\x53\x95\x98\x68\x48\xb0\xf3\x07\x7f\x7d\xe6\xf5\x9f\xbb\xe6\xa7\x17\x19\xd8\xcc\x54\xdf\x0a\x69\x3e\xd5\x2f\x38\x95\xab\xc3\xf5\xa4\xb0\x8e\x3a\x46\x5a\x1a\xa8\x01\xf0\x91\x10\x34\xa3\xd2\xd6\x25\x80\x48\xdd\xa8\xb8\x53\x38\x95\xd6\x04\xcd\xd3\x47\xe1\x2d\x78\xb2\x50\x26\xd9\x60\x4a\xcc\x30\x2c\xc7\x88\xa8\x91\x4e\xce\x8b\x18\x4b\x24\x9e\x17\x3e\xaa\xad\x15\xca\x7e\x29\x27\x78\xda\x18\xde\x22\xa5\xc1\x11\x1b\x54\xcd\xd0\x36\x4d\x10\x38\x11\x31\x52\x4a\xa8\x59\x36\xd6\xa3\xe6\x11\xed\x8c\x23\x98\xf6\xe2\x8d\x4c\x46\x78\x72\x2d\xae\xaf\x6d\x9a\x41\xf3\x19\xde\xc2\xb8\xa3\x30\x88\x9d\x05\x02\xf0\xac\x88\x39\x09\x06\xfe\x1d\x0c\x46\x9a\xec\xac\x62\x32\x6a\x49\xb6\x1b\xaf\xb3\x0f\x23\x9a\x0f\x5a\x56\x92\x6f\x0e\x25\x93\x7c\x53\xe5\xcf\x0a\x12\x84\x63\x14\x42\xa3\xd4\xce\xd1\x96\x0b\xc9\x10\xc0\x1b\x6b\xf1\x8e\xe6\x8f\x84\xb2\xa6\x19\xb5\x51\x7c\x31\x6e\x09\x06\xc9\x07\x81\x21\x10\x7b\x82\x69\xfc\x2f\xf3\xe1\x33\xaa\xf0\x0e\x9a\x0f\xf6\xe1\xc6\xeb\x28\x8a\x0f\x02\x43\x40\xd9\x41\x2d\xe6\x79\x41\x60\x14\x8c\x52\x10\x6f\xc9\x4b\x0c\xa0\xb6\x0c\x51\xc4\x90\x2c\x11\xcc\x48\x79\x6a\xc3\x4d\x04\x9e\x9e\xc0\x23\xa2\x47\x89\x14\xbc\x48\xf2\x25\xb4\xcb\x57\x3b\x78\x72\xd6\xbc\x52\xe6\xe4\xdc\xfd\x52\x2e\xe1\x89\xc2\x93\xea\x4b\x40\x39\x41\x3d\x2b\x10\x4e\x60\x24\x78\x2c\x6a\x47\x1d\xd4\xac\x8f\x55\xe5\x94\x4e\x24\xac\x73\xa7\x68\xc5\x11\x72\x69\x9a\xc1\x3e\x1c\xa5\x31\x29\x7f\x04\x1e\xa9\x3b\x1e\x78\x25\x28\x98\x46\x0e\xfe\x3b\x78\x46\x5a\x66\x09\x7b\x3b\xa4\x1c\xd2\x5a\x88\xe4\x8f\xc0\x53\x13\x0f\xca\xc2\x29\x14\x58\xad\x46\x74\x1a\x9c\x46\x45\x8a\xac\x20\xaa\x92\x00\x3d\x1a\xe2\x68\xa9\xa3\xf3\xaa\xdb\xe0\xfa\x62\x41\x7b\x22\xe5\x97\x10\x1a\x4d\x41\xca\x35\xed\x77\xf9\x05\x66\x73\x75\xcc\x14\x49\xd6\xe7\x11\x6f\x43\x10\x94\x88\x65\x15\x1c\x2b\x55\x13\x17\x8e\xe6\xbe\x29\xea\x6e\xb6\xcd\x4d\x65\x22\x92\x9c\xe0\xa2\xb1\x3b\xe1\x9d\x8f\x6b\x6b\xc5\x9d\x32\xff\x60\xf8\x98\xd4\xd7\x25\x89\x7f\x04\x94\x14\xd4\x61\x22\x44\x19\x5e\xa1\x14\x18\x82\xe1\x46\x3a\x37\xae\xdd\xf2\xe6\x94\x97\xe8\x41\x40\xc0\x24\x99\xa7\x94\x75\x6d\x7c\x45\xf2\xa7\x24\x78\xd0\x09\x0c\xe1\x2c\xac\xc2\xbc\x5a\x29\xb2\x82\x94\x43\x36\x1c\xe5\xb1\x68\x0e\x65\x92\x8a\xa1\x29\x82\x02\x6b\x0c\xbb\x49\x78\x60\xa6\xd4\x5e\xa9\x6d\x4e\x96\x79\xfd\xe3\x08\x2d\x10\x35\x4b\x72\xca\x11\x5f\x55\x49\xa4\xbf\x9a\x38\xad\x3c\x01\x5d\x17\x52\x36\xb3\x0a\x51\x1e\xc1\xdb\x6e\xfa\x23\x81\x6d\x8d\xac\x37\x60\xe4\xea\xc4\x04\x02\x52\x62\x65\x8a\x61\xce\xdb\x8a\x07\x29\xff\x1c\xa9\xc9\x92\xa0\x56\xc9\x33\x44\xb5\x60\x0d\x56\x68\x79\x25\x01\x7e\x3c\xc4\x87\xd5\x6d\x72\x22\x52\x06\x9f\x84\xe7\xd8\x74\xa4\xfc\x47\xce\x1f\x33\xd7\x9a\xeb\x08\x9e\xf0\x3c\x92\x24\x29\x48\xe3\x49\x76\x66\xb4\x2c\x32\x9f\x44\xf1\xa5\x64\x18\x9e\x57\x13\x1f\x4d\xa5\x10\x79\x46\xc2\x17\xdf\x84\x95\x32\xbf\x84\xff\x00\x5f\xa4\x5a\x8b\xe4\x75\x14\x54\x14\x55\x44\xbc\xc0\x6c\x52\xb2\xc6\x4c\xe6\xd3\x08\xfc\x4b\x12\xae\x3a\x04\x8d\x04\x53\x58\x89\x41\x0d\x2a\x82\x20\xfe\xf7\x9c\xd3\x1e\x59\x4c\x74\x71\x06\x22\xb3\xae\x51\x5c\xc9\x52\x2b\x42\x8a\x94\x16\x29\xec\x36\x5c\x31\x48\xa1\x46\x6a\x2d\xc7\xa9\x34\x2a\x19\x57\xaa\x30\x16\x44\x89\x34\x8f\x84\xb8\x3f\xc4\x15\x75\xee\x8b\x68\x3f\x50\x91\x87\xb9\x54\xdb\x5c\x87\xe7\xd5\x8a\x09\x78\x1e\x33\xa5\x31\x93\xeb\x2d\x95\x43\x96\xf1\x78\x23\xa5\x7d\x42\xa3\x4a\x54\x14\xd4\x10\x99\xa2\x54\x2a\x48\x41\xd4\x52\xc5\x10\x4c\x85\xa3\xb2\xaa\xa9\x55\x56\x65\xb7\xa7\x2c\x89\xbd\xac\x51\x11\x4a\x49\x8b\x8a\xd1\xe6\x64\x52\x38\x89\xae\x22\x32\x41\x49\x64\x82\x46\x49\x34\x38\xe6\x58\x15\xab\x56\x50\xb0\xf5\x21\xac\x68\x46\x7c\xa3\x34\x92\x25\xbb\x3d\x51\xc9\x5c\x4b\xee\x99\xee\xb5\xf0\x79\x73\x4a\xed\x15\x49\x0e\x72\x5e\x22\x09\x25\x9a\x8a\xe4\x3b\x82\x27\x22\x0d\x38\x35\xc7\x6a\x54\x2c\xb9\x95\x72\xac\x68\x92\xb2\x5e\x47\x2a\x99\x97\xb9\x2d\x36\xf3\xed\x92\x89\x9c\x3f\xae\x65\xca\x9b\x53\x08\xef\xc1\xe7\xe1\x07\x85\xb2\xc6\x93\xb5\xdc\x15\x52\x8e\x08\x4d\xc1\x6c\x49\xf6\x4a\x34\xc5\x13\xff\x5f\xa9\x26\x36\x8a\x4a\x68\xfc\x1f\xd3\x94\x4f\xa6\x29\x22\x8d\x24\x9a\x62\x3e\x6d\xcc\x8c\xe8\x9b\x4b\x12\x7c\x42\x53\x02\xd1\x35\x88\x2e\x58\xae\x52\xb0\x8d\x74\x16\x75\x9b\x74\xbf\x0d\x4d\x81\x0c\x95\xe2\xea\x12\xc9\xff\xe7\x32\x59\xb5\x12\x95\x24\xdf\x24\xd8\xad\x34\xa5\x56\x20\x85\x16\x94\xd0\x4a\x53\x4d\x2c\xdf\x18\x4d\x25\xfc\x87\xfc\x47\x93\xf1\xf8\x64\x9a\x6a\x4e\x61\xca\x6b\x45\xa1\x36\xfc\x20\x7c\x4e\xca\xc1\xf5\x6e\xa2\x52\xaf\x4d\xe7\xa9\x51\x27\xaa\xf3\x54\x6a\x85\x86\x55\x68\xd5\xe2\x7f\x45\x50\xb1\x98\x6a\x47\x52\xad\x4a\x30\xa2\x08\x25\xaa\xa2\x5c\x1e\x91\x29\x92\xae\x51\x23\x5f\xd0\x8c\x89\x7d\xaa\xe6\xd5\xac\x86\xd5\x0a\x6a\x11\x29\x6e\xd5\xd4\xbe\x76\x38\x8b\xd1\xb2\x54\xe4\x4a\x24\x46\xe4\x08\x95\xdc\x11\x6d\x2b\x49\x5e\x62\xf6\xb6\xa6\x43\xd7\x83\xd5\xa3\x3b\x82\x06\x8d\x5e\x2f\x10\x05\xc9\x02\x67\xe0\xb4\x46\x8d\x5e\x2a\x8d\xa6\x49\x12\xc5\x41\x25\x91\xc5\x2a\xdc\xa8\x04\x49\x54\xfa\x7e\x4f\x72\xd1\xfe\x59\x9f\x59\x56\x4a\xb2\xf1\x31\xa5\xb6\xf6\x8a\x24\xc9\x24\xd2\x0b\x6f\x51\xd6\x11\xe2\x6b\x4e\x56\xd6\x51\xf2\x6b\xd3\xfb\x6a\xd4\x39\x68\xe0\xb1\x52\xa5\xd2\x02\x47\x2a\x4f\x8c\xa5\x3e\xf5\xef\xa8\x2f\x06\xa9\xed\xc8\xcf\xdb\x4a\x80\x51\x0a\xfc\xa5\x9c\xc8\xb5\x88\xec\x89\xe0\xb4\x63\xd0\xa4\x56\x71\xbc\x8a\xd7\x22\xa4\x51\xf3\xa2\xe2\x77\x46\x86\xef\x36\xa2\x8d\x02\xa7\x18\x55\x11\x2a\x94\xb4\x58\xab\xbd\xc1\x79\x29\x42\x99\xd6\x34\x64\x7c\x76\xa3\x3b\xee\x69\xf4\x58\x6f\xd4\x0a\x5a\x83\x5e\x23\x51\xa3\x3e\xcc\xa8\xc5\xa8\xda\x69\x42\xac\x24\x1f\x6e\x4f\x92\xb2\xce\xa4\x6e\x9e\x2c\xea\xba\x4b\xea\x97\xd2\x64\xad\x24\xef\x64\x25\x4a\x48\x33\x22\xf1\xb0\x6c\x53\x10\xf9\x4a\xcb\x18\x08\xd2\x09\xeb\x18\x54\x58\x4b\x78\x41\xa9\x90\x6b\x50\xd9\x14\x6b\x01\x85\xa3\x3c\x17\x49\xdb\x77\xab\x15\x14\xd1\xfe\x84\x3e\xc3\x93\xb9\x53\x04\xa1\xa4\xe2\x98\x4f\x69\xd9\x51\xac\x8d\xa5\x46\xc5\x41\x8b\x40\x24\x2b\x4b\x2c\x63\x86\xd8\x30\xbc\x4a\x54\xfc\xce\xd0\x8a\xf2\x76\x7b\xb4\xb6\x2a\x58\x92\x8e\xac\x61\x23\x36\x97\xc4\xe1\x4c\x6b\x99\x38\x69\x35\x0c\x42\xa3\x4a\x9e\x68\x70\x4e\x60\x35\x82\x51\xcf\x1a\xf4\x3a\x49\xd6\xea\x9b\x94\x0c\xcb\x48\xb7\x3c\x1b\x56\x47\x48\x54\x2e\x5c\x4c\xd9\x4a\xda\xc6\x10\x14\x79\x7c\x32\x8f\x58\x3d\x45\x84\x46\x29\x42\x65\x32\xc5\xf3\x1a\xbb\x93\x7a\xfc\x94\x96\x95\xbb\x42\x4a\x1a\xb1\xa1\x22\xb4\x43\xf0\x2a\x5b\x7f\x84\x4e\x95\x6d\x78\x0d\xc7\x5a\x82\x4d\xff\x05\x5e\x25\xae\x90\xf0\x2a\x99\x6c\x11\xc3\x8a\xf9\x94\x70\x43\xc4\xb8\x6a\xb3\x35\x25\xbc\xca\x3a\x58\x05\x24\x3d\x8d\xc0\x34\x2a\x7f\x67\x70\xde\x1e\xaf\x91\x46\x03\x92\x8e\x24\x34\xe1\xf3\x56\xb1\x49\xed\x4f\xa6\xb5\x4c\xad\x78\xe5\x30\xb5\x3a\x19\x15\xa3\x33\xaa\xb4\x06\xad\x46\x42\xa6\x36\xcc\x29\x25\x39\x4a\xd4\x99\xaa\xa9\x4d\x9d\xfd\x01\x5e\x5b\x35\x4e\x91\x87\x16\x51\x92\x3d\xe1\x07\x23\x54\x2b\x26\x70\xa7\x24\x31\xc7\xce\x24\x44\x4b\xc4\x6b\x2d\x8a\xb1\x83\xcd\x68\x70\xd0\x61\x50\x6a\xb5\x66\xa2\x13\x74\xa0\x53\x59\x81\xb3\x98\x88\x14\xd0\xb0\x92\x41\x70\x3c\xa4\xe4\x9a\x0c\x32\x4d\x1d\x0d\x69\x29\xed\x46\xf2\x11\x63\x1e\xb7\xa2\x3a\xd2\x1e\xd1\x26\x17\x5a\x85\x6e\xab\x7c\x68\x15\xbd\x11\x39\x11\x91\xbf\xcc\xa7\x08\xb5\xcf\xd7\xc0\x60\xbc\x82\x23\x75\xa0\xd1\xe8\xcd\x98\xee\xf3\xc1\xe8\x18\xab\xce\x82\x0c\xa4\x2e\xb4\x3a\xad\x94\x37\x13\xd6\x35\x53\xd9\x2c\x2d\xa6\x71\xdb\x4a\x89\xe9\x8b\x8b\x1a\xed\xd2\xaa\x58\x45\x6d\x86\x80\x44\xfe\x62\x02\xad\xaf\x88\xa4\x96\x2b\x4c\xaa\x37\x84\xd8\xd6\x3c\xd1\x3a\x33\x22\x3b\x1a\x13\x74\x60\xbd\x9e\xd3\xd8\x15\x0a\x0b\x5d\xca\x47\xa5\x65\xe2\x54\x36\x07\x67\xb5\x59\x29\x59\xaa\x43\xd8\xd6\x84\x4c\x8d\xfa\x68\x15\x6a\x54\x61\xa3\x10\xcb\x1a\x91\x9b\x76\x15\xd9\xd6\xff\x2f\x67\x94\x89\x65\x16\x5f\x44\x12\xd1\x6a\xbd\x12\xc3\x34\x91\x2a\x96\xaa\xb7\xf1\xa4\xcc\x3c\x92\x6c\x92\xda\x25\x10\x9e\xce\x1d\x92\xe4\xa2\xa9\x5e\x5a\x3a\xa7\x11\x50\x7e\x69\xeb\xc2\x39\x46\x0f\x77\xa8\xf1\x4e\xee\x10\x9e\xce\x5e\x95\xc3\x93\x72\x92\x27\x29\x3c\xc3\x61\x16\x53\x7e\xce\xff\x5d\xf8\xf0\x16\xf6\x93\xb6\xf0\x12\x7c\xf3\xf1\x08\x7c\x31\xba\xcc\x4e\xfb\x08\xca\xba\x48\x78\xfc\x61\xd4\xf7\x47\xd0\x3e\x86\x34\xa3\x98\x44\xc1\x1f\x86\xb3\xc8\x21\x45\x21\xba\xff\x72\x4c\x1a\xc0\x22\x2e\x26\x46\x49\x34\x8d\xb6\x08\x59\x68\x62\xf8\x67\xee\x10\xff\x78\xeb\x3a\x3e\x66\x69\x54\x74\x74\xd6\x5c\x3e\xf2\x21\x3f\xea\x82\x4a\x51\x4f\xd4\x07\x95\xa3\x81\x68\x08\x1a\x86\x46\xa2\x6a\x34\x1e\x4d\x44\x53\xd1\x4c\x34\x17\x2d\x44\x4b\xd0\x0a\xb4\x1a\xdd\x8f\x36\xa0\xcd\x68\x0b\xda\x81\x76\xa3\x7d\xe8\x71\xf4\x34\x4c\xab\x7b\x7a\xf3\x86\xfb\xd7\xdc\xdf\x00\x4c\x7d\xe8\xf1\x89\xe3\xa7\x4e\x9a\x4a\x6e\x83\xaa\xd0\x63\x13\x6a\x26\x55\x8f\x1c\x36\x74\x98\xfc\x38\x6a\xf8\xd0\x7d\x43\x06\x96\x97\x95\xcb\x8f\x8f\x56\x56\x94\xf5\x2c\xed\xd3\xab\x8f\xfc\x18\x0c\xf4\xda\xdd\xc5\xef\xeb\xe0\x93\x1f\x77\x76\x2a\xec\x90\x9d\x9e\x9f\x93\x2f\x3f\x66\xa4\xe4\xec\x48\x74\x79\x93\xbc\xf2\xe3\xd6\x78\x47\x92\xdd\xac\xa7\x26\x01\x7d\xb4\x18\x34\x5b\xd4\x02\x43\xdd\x1a\xfa\xf8\x10\x91\xf6\xab\x57\x2c\x59\xb4\x84\x3e\x96\x86\x56\x2e\x5d\x64\x1b\x0a\xae\x32\x88\xeb\x05\xae\x0e\xe0\xca\x01\x4b\x12\x4c\x1a\x5a\xd6\xab\x43\x4e\x92\x06\x2d\x5a\x84\x34\x49\x39\x1d\x7a\x95\x0d\x9d\xa4\x9a\xf6\xc4\x83\xeb\x5c\x6b\xba\xac\xc1\xfa\x35\xa0\xc4\x6b\x16\xce\x9d\x39\x6d\x26\x81\x71\x34\x34\x6f\xd6\x34\x14\x9d\xf7\x23\x8d\x82\xa6\xcd\xa3\xf2\xfc\xb0\xc8\x4f\xee\x00\x88\x19\x1e\xde\x36\x27\xf8\x7f\xe5\x8d\x7c\xa6\x73\x8c\xac\xde\xd4\xc8\xc1\xc5\xdc\x0b\xff\x07\xef\xed\xff\x17\xe1\xe1\xbf\xb8\x37\xde\xe6\x98\x38\x69\x12\xec\x25\xc7\x63\x13\x27\x86\x6b\xc9\x75\x9f\x7c\x5c\x9c\x38\x51\xac\x99\x34\x49\x1c\x37\x69\x12\xab\x25\xd7\xb1\xf2\x71\xb1\x2d\xf4\xc5\xdb\xbe\xfd\x03\x18\x17\xdb\xde\x36\x9f\x6e\xbb\x6f\xfa\xb1\x2d\x26\xbd\xb6\xfd\xb8\xe4\x71\xf4\x37\xb6\xa6\xed\x37\xfe\xf7\xf7\x63\xe9\x6f\xdc\x18\xfa\x1b\x27\xdd\xcb\xaf\x85\x7f\x4a\x91\xc1\x2b\x3d\x89\x37\xc6\x89\x37\x6a\xc4\xeb\xe4\x7f\xac\xf8\xe9\x58\xe1\xfb\x1a\x3a\xfa\xf2\xff\x3f\x3e\x43\x87\xd0\x61\x74\x14\x1d\x47\x2f\xa2\x53\xe8\x75\xf4\x26\x3a\x87\x2e\xa2\xf7\xd1\x15\x74\x15\xdd\x40\x9f\xa3\xaf\xd0\xb7\xe8\x26\xfa\x11\xfd\x87\x78\xf5\x2d\xc0\x80\x40\xfc\x64\x3d\x98\xc1\x0e\x2e\x48\x04\x2f\xa4\x43\x36\xe4\x83\x0f\xfc\xd0\x05\x4a\xa1\x27\xf4\x81\x72\x18\xc8\x1c\x3c\x8a\x0b\xc6\x3d\xd5\x00\xaa\x7a\xee\xc3\x0f\x19\xdf\xf8\xa7\x1b\x40\x1d\xb4\x72\x57\xdc\x03\x36\x3d\xff\x0b\xf7\xe9\xa7\x89\x03\x37\x1f\xfe\x0f\x77\x83\x2f\xbe\x7b\x7f\x03\xe8\xea\xb9\x4b\x97\x04\xff\xc4\xc7\x1b\x40\x4f\x02\xbd\x9f\x3c\x78\xf9\x91\x46\xee\x6f\x7f\xf3\x0e\x59\x71\xb4\x89\xfb\x5c\xd5\x79\xca\xde\x06\x30\xd5\x73\x17\x2e\xa8\xbb\x4c\xdd\xd7\x00\x66\x12\xe8\x62\x5a\xd5\xbd\xf5\x22\xf7\xf7\xbf\xa7\x0f\x5b\x7d\xbc\x85\xfb\x4a\xd7\x6d\xc6\xae\x06\xb0\xd5\x73\x6f\xbf\xad\x2f\x9d\xb9\xbb\x01\xec\x75\xdc\xb9\xac\x11\xf7\x9d\xa4\x2a\x81\xfb\xc7\x3f\xb2\x47\xde\xff\x22\x61\xb9\x3a\xee\x5b\x53\x8f\x39\xdb\x1b\xc0\x59\xcf\x9d\x3d\x6b\xee\x39\x77\x47\x03\xb8\xea\xb8\x37\xf3\xc6\x3c\xf0\x4a\x03\xf0\xf5\xdc\xf7\xdf\xe7\x57\x6f\x38\xd5\x00\x42\x1d\x77\xd3\xd6\x7b\xc1\xc3\x0d\xe0\xae\xe7\x4e\x9f\xb6\xf7\x59\xb8\xa5\xbb\x19\x12\x89\x52\x7a\x1d\xd2\x20\x0f\x8a\xa1\x1b\xf4\x23\x52\xb8\x37\xf9\x4b\x27\x08\xf0\x93\xc2\x97\x93\xe7\x3e\xd0\x27\xa8\x7d\xfd\xe6\x9b\xdf\x9e\xfb\xea\xe2\xe7\xef\xdf\xb8\xa2\xb9\xda\x00\x3d\x82\x06\x67\xbf\xc5\x07\xff\xcd\x7d\xf2\x89\xab\x7c\xc9\xa1\x1f\xb9\xab\x57\xbb\x9b\xa0\x92\x20\x2f\x9b\x20\xae\x0b\x0c\x24\xf1\x7a\x92\xbf\x64\xc8\x82\x02\xe8\x0c\x03\xc8\x73\x0f\xf2\x37\xe8\xd8\xb5\xcf\xbe\xf8\xfa\xbb\x06\xe8\x75\x94\xff\xe8\xea\x47\x0d\x60\xad\x0b\xdd\xf8\xfc\xab\x6f\x6f\x36\x40\x9f\x7a\xfe\x2a\xab\xd0\x18\x2c\x0d\x90\x74\x94\x27\x64\x21\x7d\x14\xd4\x7a\xb3\xbd\x01\xbc\xf5\x3c\x13\x9f\x94\x92\x91\xd3\x00\x29\x47\x79\x87\xcb\x21\x7d\x4c\xf4\xa6\x67\x13\xa9\x97\x5e\xcf\xbb\x0a\x3b\x05\x82\xbd\x1a\x20\xe3\x28\xdf\xc1\xd7\x41\xfa\xe8\xef\x52\xda\x93\x08\xcc\xec\x7a\xde\x57\x51\x39\x74\xf8\xa8\x06\xc8\x39\xca\x97\x95\x97\x49\x1f\x07\x0e\x19\x36\xb2\xba\x01\xf2\xeb\xf9\xf2\x09\x93\xa6\xcd\x9a\xd7\x00\x1d\x8e\xf2\x84\xa6\xa5\x8f\x13\xa7\xce\x9c\xbb\xb0\x01\x7c\xf5\xfc\xf8\xa5\x2b\xd7\xac\x7b\xb0\x01\x0a\x8f\xf2\x8b\x96\x2c\x92\x3e\xae\x58\x7d\xff\x86\xcd\x0d\xe0\xaf\xe7\x97\x3c\xb4\x75\xe7\xa3\x8f\x35\x40\xa7\xa3\xfc\x13\x4f\x3f\x21\x7d\xdc\xb2\x63\xf7\x3e\x52\xe5\x5d\xea\xf9\xa7\x9f\x7d\xe1\x58\xc3\x4b\x0d\x10\x38\xca\x3f\x73\xe8\x19\xe9\xe3\xe1\xa3\xc7\x5f\x24\xd5\x50\x5a\xcf\x1f\x7a\xf5\xcc\x5f\xde\x79\xb7\x01\x82\x47\xf9\x0f\xae\x7c\x20\x7d\x7c\xfd\xcd\x73\x17\xdf\x6f\x80\x9e\x41\x3b\x7f\x85\x71\xf9\xca\xc7\x2f\x79\xfa\xd0\x95\x2b\x87\x9e\x5e\x32\xbe\xdc\xe7\x62\x94\x57\x7f\xec\x6e\x89\xa1\xd1\x81\x88\x27\x34\xab\x20\x87\x15\x85\x40\x03\x06\xb0\x80\x03\xe2\xa1\x82\xbc\x57\x1c\xfd\xf1\xa7\x5f\x9b\x4f\x02\xf5\x06\xcb\x8e\xf2\x3f\xfc\xf8\x03\x49\xe0\x68\xe8\x3f\x4d\x2d\x27\x25\x5a\x2f\x3f\xc2\xff\xc8\xa0\x52\x3b\x95\x93\x76\x9f\xc3\x70\xc6\x5e\x10\xb9\x3b\x1b\x23\xa5\x8d\x91\xef\xff\x6b\x57\xa0\xb7\xf4\x30\xb6\xde\xd0\x7e\xb1\xc8\xed\xff\xe6\x45\x96\xfc\xfe\xdb\x1c\xdc\xff\x83\xf7\xa9\xb7\xbc\x8b\x6a\x8d\xf4\xdb\x1c\xc2\x1f\xc0\xb1\xff\x0f\xc3\xc3\xff\xf0\xbd\x39\x02\xcb\xfe\xdf\x5c\x8d\x91\xb0\x13\x25\xf5\x41\xfe\xdf\x95\xfe\xc9\x4d\xd3\x83\x44\xfd\xc8\xff\xf2\xdb\x89\x13\x9b\x47\xfc\x5f\x84\x82\xbd\xb1\x61\x4e\x4f\x9c\xc8\x3c\xd9\x3e\x10\xf9\x9f\xf8\x3b\x60\x13\xff\x0f\xc2\x34\xfd\xf8\x7f\x92\x07\x39\xea\xc4\x3f\x3a\xd3\x6b\x44\x1f\x8e\xfb\x9d\x56\xac\xf9\x03\x0d\xf9\x87\xef\xc7\xb6\xfd\x64\xcd\x39\x26\x46\x7f\x8e\x8d\xd1\xa2\xed\x74\xe9\xb8\x58\x8d\x5a\x13\xd5\xab\x63\x23\xc0\xc9\x41\x80\xd1\x47\x12\x9c\x04\xa2\xbe\x50\x4f\xc9\xbe\xbe\x4c\x74\x6c\x5f\xd4\x1f\x0d\x42\x77\xa2\x10\x1a\x8d\xc6\xa2\xbb\xd0\x64\x34\x1d\xcd\x46\xf3\xd1\x3d\x68\x19\x5a\x85\xd6\xa2\xf5\x68\x23\xaa\x45\xdb\xd0\x23\x68\x0f\xfa\x13\x7a\x12\x1d\x40\xcf\xa1\x3f\xa3\x3a\x74\x02\xbd\x8c\x5e\x43\x6f\xa0\xb7\xd0\x79\xf4\x1e\xba\x8c\x3e\x46\xd7\xd1\x5f\xd1\x97\xe8\x1b\xf4\x4f\xf4\x2f\xf4\x33\xfa\x0d\x85\x01\x88\x19\xae\x04\x2d\x18\xc1\x0a\x71\x90\x00\x1e\x48\x85\x4c\xc8\x85\x8e\x50\x04\x25\xd0\x15\xba\xc3\x1d\xd0\x17\xfa\xc3\x20\xe6\x91\xe0\x94\x49\x4b\x0f\x7c\xed\xe4\xde\x7a\x4b\x12\xeb\x1c\x33\x70\xe6\xb6\xc3\x3f\x71\x17\x2f\x56\x4c\x7b\xf0\xd9\xdf\xb8\x77\x26\xac\x78\xf2\x0b\x37\xf7\xc6\x1b\x93\x97\x3d\xf5\x8d\x8b\x3b\x3b\x64\xee\xe6\xa3\x3f\x70\xef\xbf\x5f\x39\xeb\xe1\x17\x7e\xe6\xde\xad\x59\xfd\xa7\xcf\x92\xb9\xd7\x5e\xbb\x6b\xe5\xfe\x2f\x13\xb9\xd3\xc3\x16\xee\x38\xfe\x1d\x77\xe5\xca\xd0\x79\x0f\x1d\xfb\x17\xf7\xc1\xa8\xfb\xf7\x5c\x4b\xe3\x5e\x7e\x79\xec\x9a\xbd\x7f\xf5\x72\xaf\x34\xbd\x42\x84\xa3\x8b\x68\xa3\x4a\xa2\x79\xba\x10\x89\x3c\x7c\xd1\xce\x86\x7f\x72\x1f\x9d\x22\x52\xd3\x42\xf2\x57\x46\x2c\x7d\x8e\xe4\xaf\xe4\xf8\xe8\x75\xbb\xae\xa7\x73\x27\x5b\xba\x27\x10\x01\xeb\x21\x7a\xaf\x82\x7c\x28\x85\x52\xd4\x4c\x04\x6b\x3c\xe4\xc0\x20\xf2\x1c\x20\xc2\xd4\x4e\x0a\xd6\x0b\xe5\x91\xa7\x22\xf2\xa7\x24\xc5\x4d\x83\xbe\xc4\x54\xe1\xa0\xf8\xb8\xa4\x7e\xb8\xb2\xb2\xee\x2a\x22\x77\x0d\xe0\x86\x0e\xd0\x9f\x7c\x08\x92\xbf\x62\x08\x04\xe3\x4f\x7e\xf4\xca\x07\xa7\xdf\x3d\xfb\x0e\xa3\x81\xde\xe5\x53\x37\x1c\xfa\x95\x3b\x77\x8e\x53\x6a\x8d\x56\x0e\xa0\xbb\x12\x06\x13\x1c\x3a\x88\xb2\xbc\x83\xd8\x3d\x1c\x51\x98\x05\xc7\x0b\x8a\x3b\x77\xeb\xc1\xf5\xee\xdd\x00\x43\x8e\x5c\x7c\xff\xca\x09\x6a\x8a\x1c\x2b\xe3\xcf\xc1\x39\x22\xcd\x8f\x85\xa8\x16\x3d\x01\xbd\xa8\x80\x37\xf5\x33\x91\x57\x41\x73\x68\xc0\xe0\xaa\x46\xd1\xcf\xf7\x23\xba\xad\x89\xae\x69\x64\x2c\x97\x82\x8e\xac\x1e\x3f\xf1\x04\x95\xfc\x75\xbc\x71\x54\xcd\x84\x49\x27\x48\x51\x14\x47\x79\xdd\x14\x9d\xa4\x17\x66\xcc\x59\x70\x02\x54\xa0\xab\xeb\xc2\x4f\x21\x6a\xef\x04\xb5\x85\x8e\x05\xf8\xa9\xda\xa9\x52\xec\x25\xcb\xef\xbd\xef\x04\xd1\x3b\xb6\x3a\x5e\xbb\x94\xe8\xbe\x13\x04\x7b\xf6\xa3\xbc\xea\x01\x95\x14\x7b\xd3\xd6\xed\x27\xc0\x09\x49\x75\xa5\xfc\x03\x9b\xb7\xed\x38\x41\x50\xee\x39\x16\xe4\x37\x28\x37\x48\xb1\x1f\x7d\xec\x89\x67\x4e\x40\x0a\x64\xd4\xf1\xca\x3d\x7f\x7a\xf2\xc0\x09\x4a\x1b\x47\x79\xfe\x20\x2f\xc5\x7e\xfe\x48\xfd\x09\x62\x20\xe4\xd5\xf5\xe4\x0f\x12\xed\x78\x82\xda\x5d\xc7\x7a\xf1\x87\xb8\x43\x52\xec\x97\x88\x9a\x3c\x01\x85\xd0\xa9\x8e\xe7\x5e\x7e\xed\x8d\xb7\x4e\x50\x8a\x3a\xca\xe3\xb7\xb1\x14\xfb\xc2\xa5\x0f\x4f\x10\xd3\xa2\x5b\xd0\xdb\x87\x7f\xbb\x9f\x71\x8a\xf6\x01\xe5\x41\x62\x2b\x71\x07\x95\x0f\x68\xa7\x18\xfb\x29\xe1\x57\xc9\x62\xe8\xc0\x3b\xbe\xbd\xf9\xe3\x09\x6a\xc3\x1d\xf3\xf1\xff\xb1\xfd\x87\x62\xcb\x18\x72\xba\x93\xd3\xb2\xf2\x78\x9b\xcd\xf1\x6b\xf0\x2a\x31\x41\x4e\x50\x43\xef\x28\x6f\xfd\xd5\x2a\x01\xff\xee\x87\x9f\x4e\x40\x05\x54\x1e\x2d\xe4\x7f\x6d\xd3\x96\x74\xf6\x72\x49\x7e\x9b\x6a\xa3\xda\xf3\x7f\x5f\x67\xfe\xbf\x57\x98\xc4\x0b\xf6\x15\x79\x6f\x73\xf8\xac\x7f\x74\x78\xad\x3e\xe3\x6d\x0e\xb8\x25\xa0\x9d\xbc\x4b\x8f\x39\x84\x5b\xbe\x73\xe4\x9d\x3f\xf6\x99\x1c\x1e\x72\x08\x45\x5e\x6b\x2a\xb9\x9a\xc9\xd5\x1b\x73\xdc\x1a\xff\xbf\xfd\x7e\x4b\xfa\x70\xeb\xf3\x2d\xf9\x8c\xc6\x17\x22\xf9\xa2\xf9\xb1\x13\xb8\xf6\x5b\xe0\x9b\x6f\x7d\x8e\xc4\x8f\x5e\xb9\xcb\x8d\xd9\x53\xda\x7e\x53\xe9\x1f\xfd\x45\xaf\xd1\x5f\xe3\xb6\xb6\x57\x1f\x92\xff\x29\x53\x2e\x93\xff\xc8\xbb\xf0\x3f\xa6\x44\x3e\x36\x1f\x9c\x0a\xa5\x53\x2f\x4f\x85\x43\x53\xdb\xc0\xc4\xc0\x6a\xff\xdc\x0a\x08\xdb\xa4\x87\xcb\xd2\x3f\xfe\x96\x86\x68\x4d\x60\x2a\x85\x2d\x56\x91\x2f\x97\xa3\xb1\x5b\xaf\x34\xcc\x54\x29\x52\x78\x0b\x24\x8f\xa5\xff\xde\x1a\xf0\x8c\x93\xfe\xdb\x29\xb6\xd7\x5a\x3d\x3b\xf2\x3f\x86\x9c\xf9\x29\xd1\x4f\xaf\xde\xaa\x2b\x5f\x8d\xde\xbc\x1e\xab\xc2\x7e\xa7\x0a\xdb\x5e\xb5\x86\xe2\xcf\x47\xd5\x5f\x54\x09\x93\x54\x23\x49\x8c\x6d\x05\x2d\x83\x7d\xad\x15\x98\x0c\xa8\x0d\x80\x14\x59\x6a\x77\x5a\x82\xe6\xb3\x23\x58\xba\x26\xb4\xb1\x0e\x10\xc7\x32\x74\xd8\x4c\x74\x08\xaf\xc7\xe8\x59\xc2\xdc\x68\xf6\xb0\x43\x9b\x3d\x08\x23\x1e\x21\xf6\x22\xfb\x96\xbc\x5f\x75\x50\xc3\x22\x81\x88\x78\x85\x92\x63\xd8\x5b\x86\xfd\xc8\x51\xcd\x46\x8f\x91\x67\xdf\x6a\xf2\x57\xb0\x1d\xe9\x85\x5d\xd6\x74\x91\xed\x48\xd2\x9c\x0e\x2b\xf0\x64\x66\x49\x24\x4d\x96\x03\x1c\x1d\xf9\x19\x69\xb6\x9a\x2c\xb2\xd0\x0c\x2b\xa0\x59\x1e\x5b\xd8\x16\x5e\x4a\x57\x00\xda\x2e\xaf\x50\x0a\xc0\xd3\x88\xd7\x63\xd3\x85\xc8\x8a\xcb\x32\x88\x0a\xf1\x51\x0a\x45\xac\x84\x71\xe2\x5e\x79\xcc\x1b\xf9\x29\x10\x9e\x24\xb5\xcb\xd1\xf2\x22\xba\x9a\x48\x34\x71\x12\xd1\xa3\x40\xbf\x92\xef\xe1\x9d\x08\x80\x44\xe1\x2b\xd8\xe7\x49\x0e\xe8\x7a\xd9\x80\x19\x8a\x9d\x48\x70\x3a\xeb\xcb\xa3\x24\x61\xf0\x70\x5c\xc5\x3e\xdf\x34\x98\x84\xaf\x6d\xf9\x92\x1f\xc1\x3e\x4b\xc2\x9b\xea\x11\x10\xac\x60\x73\x1b\x6c\x25\x86\x5a\x09\x0b\xcf\x86\xf7\x86\x77\x4b\x7d\xfa\x7b\x49\xf8\x0a\x76\x0b\x09\x1f\x17\x54\x63\x40\x74\xed\x64\x84\x81\x46\xa2\x13\x46\xa5\x34\x94\x98\xaf\x08\x1f\x0c\x3f\xc3\x6e\x69\x1a\x4c\xb2\x22\xc5\x6b\x97\x0e\x26\x91\x20\x26\x1d\x62\x7d\xf0\x23\x68\x32\x4d\x25\xf8\x2e\x19\x7f\xa9\xa4\xde\xd4\xdc\x63\x88\x0e\x47\x29\x0c\x3a\x59\x86\xae\x6b\x2e\x60\xac\xe0\x19\x95\x92\xe3\xd4\xbc\x9e\x29\x65\x30\xa3\x90\xc6\xa8\x8e\x6e\xb7\x0e\x9d\xdc\x06\xed\xf1\x2a\xc1\xa7\x64\x71\x70\xb0\xe8\x87\xb7\x06\xc3\x39\x51\x27\xee\x85\x71\x50\x83\x2f\xe2\xf7\xc2\x1d\x71\x51\xf8\x5c\xf8\x34\xee\x46\xd3\x7a\x1a\xed\x67\xf3\xd8\x4c\xa4\x47\x89\xb4\xae\x0c\xc8\xa1\x40\x8a\x24\x8f\x45\x13\xcf\x92\xba\xba\xd6\x8e\x46\xa2\x83\x5b\x2d\x74\x04\x72\x1e\xf8\x2d\x74\x9c\x23\x9d\xf1\x29\xcf\xfc\x7d\x7a\xd1\x7b\xf7\x2c\xbe\x74\xcf\x3d\xef\x2d\x59\xfc\xee\xa2\xaa\x71\x4f\x8f\x1f\x77\x60\xc2\xb8\x43\xe3\xc6\x1e\x18\x87\x27\xd0\xf7\xef\x93\x4f\x8b\x16\xbd\xbb\x78\xdc\x81\xb1\x35\x07\xc7\x91\x2f\xe3\x0e\x48\xdb\x26\xa0\x71\xa8\x8a\xad\x66\x07\x13\x6a\xd1\x4b\xf3\xe4\xd2\x89\x2d\xe1\x47\xa5\xa8\x0f\x1a\x88\x86\xa1\x6a\x34\x11\xcd\x44\x0b\xd1\x0a\xf4\x6e\x70\x6a\xe5\xa4\x49\x43\xa7\x75\x5a\xb4\x28\xb0\x34\x63\xd6\xac\x9c\x79\x49\x35\x35\x29\x13\x14\x65\x65\x9a\x0a\x14\x0c\xb2\xbd\x0c\x1d\x3a\x58\x0a\x0b\x7b\x55\x4c\x98\xb7\x74\x9a\xe0\x18\x3e\x2a\xde\xe1\x18\xb5\x6a\x65\xbf\x39\x0b\x06\x2c\xe8\xb1\x78\x79\xef\xe5\x05\x53\x66\x14\xcf\x70\x8e\x18\xe3\x1e\x63\x1a\x5c\x65\xab\xc2\x9d\xbb\xf1\xdd\x54\x59\x79\xba\xbc\x05\xcb\x67\x8c\xa9\xea\x96\x97\xd7\xad\x6a\xcc\x8c\xe5\x0b\x84\xb4\x71\x77\x27\xa7\x49\x2c\xd2\xd6\xfc\x67\xa4\xeb\x7e\xfc\x37\xa7\x28\xae\x4c\xb1\x93\xda\xfe\xf0\x44\xc7\x73\x7b\x93\x8b\x0a\x7d\x05\xe9\x91\xab\x39\x72\xb5\x47\xae\xd1\xef\xc2\x2d\xcf\xb7\x5e\x6f\xfd\x7e\xeb\x73\xea\x2d\xf0\xa3\xe9\x31\x1f\x15\x76\xea\x54\xb8\x95\x9e\xfe\xe3\x2f\xf2\x17\xa5\xd0\x3b\xd1\x5f\x4c\x7e\xcf\xf9\x8b\x8a\xfc\x78\x30\x3d\x87\x9d\xf4\x05\x5e\xdd\x1a\x36\xfc\x7c\x61\xa7\xe2\x62\x29\x30\xfc\x85\x7e\x13\x47\xd1\xf3\x7f\x68\xe0\xad\xf4\x8e\xd9\x4e\x4e\x39\xe4\x49\x7c\xdf\xef\x2f\xfa\x9c\x3c\xc0\x16\x72\x33\x82\x02\x5b\x48\x4e\x70\xa2\xd8\x57\x12\xee\x45\xee\x1e\x29\x2c\xec\x84\xe3\x23\x81\x44\x86\xdc\x7c\x41\xa3\x5d\xee\x54\xd8\x29\x8b\xdc\xc8\x32\xe0\x08\x5a\xcf\x7a\x99\x46\xba\x66\x5e\x50\xa9\x62\x75\x7a\x41\x4f\x25\x83\x3c\x41\x52\xe2\x21\x89\x2a\x91\x37\x19\xd1\x15\xba\xf0\x94\x19\x1f\xcf\x11\xc5\xe3\xf5\xa2\x38\xf3\x0a\xd3\x38\xef\x93\x29\xc7\x45\x11\x98\xfa\x69\x97\x17\xca\xfc\x95\x49\xf8\xeb\x59\x96\xae\x05\x6f\xa6\x9c\xcc\x10\xc9\xc8\x5a\xac\x06\xa0\x0c\x25\x8b\x27\xca\xc9\x3e\x22\x5d\xe0\x16\x12\xcf\x64\x57\x37\xb3\x0b\xce\x2d\x5c\x70\x7e\xc1\x82\x77\xc8\x79\x3e\xbb\xba\x69\x19\xee\xbe\xe0\x9d\x05\xe4\x9e\xbc\x5c\xf8\x0e\x1d\xeb\x1a\x0b\xdf\x8b\x3c\x41\x03\x13\xaf\x61\x2d\x88\x4f\x49\x35\x38\x08\x73\xd1\xac\x5f\xbf\x7e\xc1\x70\xfd\x42\x6c\x4a\xb7\x30\x57\xfa\x6d\x52\x1e\x34\xee\xe0\xd8\xb1\x84\x73\xa4\x73\xff\xdf\x67\xa3\xf5\x1b\x39\xb7\xcb\x12\x29\xf3\x5c\x58\x8b\xc7\x33\xf3\x09\x0e\xe3\x28\x9f\xeb\x90\x45\x40\x82\xcb\x69\x67\x8c\xaa\x5b\xf9\x5c\x9a\x65\x10\x99\x6b\x69\xb7\x09\x31\x4b\x29\xe1\xf1\x3b\xc6\xf6\x9a\xd5\x6b\xcb\x5d\x13\xfb\xf4\xab\xb8\xbb\x77\xef\xbb\xc7\xf5\xeb\x5f\x8d\x97\x4d\xdd\xd8\x7d\xce\x1d\x13\x6b\xfb\xf5\x99\xd8\xfb\xee\xbb\x7b\xf7\xb9\x6b\x32\xf1\x04\xfe\x4c\x64\xde\x3d\x44\xe6\xa9\x91\x03\xa5\xa0\x0e\xa8\x33\x9a\x1b\xec\x91\x9d\x1a\x97\x98\xd8\xb9\x38\x95\xd5\x98\x35\xc8\xcc\x23\x3e\xd0\x25\x23\x3e\x39\x2f\xb9\xa8\xe3\xa4\x8e\x10\xea\x08\x7d\x3a\x42\x5c\x47\xe8\xe8\xeb\xa4\x4f\xae\x4e\x9e\x99\xcc\x28\x3a\x05\x95\xba\xb2\xe4\x4e\xc9\x9d\x18\x3d\x1d\xb2\x6c\x63\x68\x5e\xe9\x20\x60\xc2\x95\xd9\x63\x46\x1b\xe8\x5c\x59\xda\x20\xdf\x9e\xfd\x62\x27\x4c\x20\x21\x19\xa5\x17\x22\x4f\x12\x12\x0a\x51\x3a\x1d\x42\x6a\x41\xf6\x02\x14\xbb\xcb\x0e\x17\x73\x0f\xa4\x98\x7e\x3b\x1d\x71\xca\xdf\x23\xee\x6c\x0e\x8b\xbb\x80\xc8\x4d\x4c\xfe\xc6\x8d\x10\x2f\x7c\xf4\xc9\x8e\x47\xa0\xe0\xa3\x8f\xa1\x43\x78\x64\x5e\x52\x52\x6e\x6e\x52\x52\x1e\xbc\x9f\x93\x94\x94\x9f\x9f\x94\x94\x13\xfe\x47\xc5\x96\xda\x8a\x6e\xe3\x4e\x9c\x18\x87\xcb\x44\xa2\xca\xe0\xee\x70\x23\x4c\x11\xb7\xfd\xf6\x31\x71\x8c\x76\x3d\xf2\xf1\x47\xe2\x05\x20\x4e\x41\x55\x52\x5e\x34\xb2\x74\x15\x4f\xad\x5f\xef\x3d\x29\xed\x97\xcb\xc2\x7b\x04\x6f\x8f\x48\x78\xb3\x13\xda\xc9\x45\xa3\x83\x9d\x34\x26\xb7\x03\x39\x32\x52\x4c\x3c\x9f\x97\xef\xb1\xea\x5d\xfa\xcc\xdc\x49\xb9\x10\xca\x85\xf2\x5c\xe8\x9a\x0b\xb9\xd9\x69\xd1\xc5\x70\x59\xc5\xc0\xb4\xea\x34\xac\x4f\xd3\xa7\x29\xe9\x30\x5c\x8a\xa7\xd1\x04\x4f\x17\xda\xf0\x74\xa1\x20\x76\x86\x61\x0c\x7e\xb8\x98\x8a\x4e\x8d\x5d\x3f\x8b\xa2\x24\x5d\x42\xc9\x23\xb7\xa0\x24\x8c\x6e\x83\x85\xe7\x29\x02\xba\x55\xd4\x6e\xa9\x68\x8f\x85\xc5\x31\x45\xa6\x57\xf1\xda\xc9\x93\xde\xf5\xeb\x89\x02\xed\xdd\x32\x97\xd7\xb1\x5d\x88\x5f\xeb\x47\xcb\x83\x3d\x8b\x0c\x6a\x41\x85\xb3\xb2\x6c\x71\x79\x69\xc9\x09\x5e\x6f\x9c\x8a\x29\xe9\x94\x9d\x85\xb3\x34\x6a\xb5\x27\xb9\x63\x9c\x2d\x4e\x91\x9a\xa5\x77\x27\xc7\x65\x25\xc7\xc5\x25\x67\x31\x10\x6f\xbc\x61\xbf\x69\xc7\xf6\x74\x9e\xee\x99\xb9\x19\xa8\x4d\x44\x97\x47\x1f\x1d\xed\xbe\x91\x7a\x19\x29\x6d\x18\xce\x13\x92\x21\xb6\x0b\xb9\x89\x4e\xa6\xf2\xb5\x4a\x64\x79\x18\x8b\xd5\x0d\x74\x4b\x55\x1b\x6d\x49\xe2\xe9\xce\xaa\x3a\x2c\x10\x7b\x39\x2d\x5d\x48\xf7\xa7\xa5\x7b\x8b\x7c\xc5\x74\xd3\xd5\x62\x7f\x74\xf5\x7a\x3f\x9d\x77\xc3\xac\xef\xd1\x63\x7c\xe0\x64\x6e\x43\x15\x7f\xe5\x0a\xf1\x5e\x3b\xd6\xa7\xf4\xeb\x56\xd4\xe3\x9e\x09\x2f\x65\xd7\x0f\x30\x5c\xb9\xa2\xa9\x3c\x96\xf1\xf2\x8c\xd9\x89\x1b\x5e\x7b\x7d\xfd\x86\x9a\xf1\x67\xd8\x2e\x1f\xf3\xe9\xb9\xf5\xb9\x0d\xb3\xe7\x75\x5b\x56\x43\x02\x39\xb3\x0c\x8a\x8f\x3f\x36\xf6\x3d\x96\xdb\x30\x61\x59\xb7\x95\xd5\x04\x42\x7f\x6d\xd7\xb3\xeb\xd6\x9d\x19\x3b\xf6\x81\x75\x67\xe5\x71\x7f\x9f\xa0\x4a\x36\x8d\x5d\x45\x38\x2a\x9d\xae\xf8\x9b\x62\x50\x9b\x74\x3a\x2b\x4a\xb0\xb3\x2c\x52\x33\x99\x19\x26\xab\x43\xef\xd0\xdd\x44\x2d\x74\x2f\xdf\xc4\xa4\xfc\x24\xec\x48\x72\x24\x09\x41\x33\x98\xe3\x82\xa9\x19\x65\x71\x02\x61\x9f\xec\xfc\xd1\x12\xfb\x10\xe6\x99\xdd\xaa\xb6\x22\xfa\x2a\x3a\x15\x11\xe4\x15\x40\x09\xf7\xd3\xc9\xd5\x91\x4e\x6c\x3a\x2a\x44\x5e\xdf\x43\x2e\x74\x1e\xe0\x6b\x15\x53\x7b\x3d\x3f\x67\xc1\x90\xaa\x87\xa6\x00\x49\xb5\x1f\x11\xb3\xd8\xdb\x69\x54\xc9\x92\xc1\xc3\xba\x74\x2d\x19\x8d\x7b\xa8\x2b\x16\x97\x2f\x7f\xb2\x6a\xc8\xe2\xe9\xfb\xb5\x4f\xf5\x16\x1b\x81\xef\x8d\x6b\x8b\xaa\x4b\xaa\xee\xe9\xd6\x75\x68\xe7\xea\x42\xb9\x5c\x83\x50\x23\x7b\x98\x94\x2b\x07\x75\xa2\x73\xe4\x3b\xe4\xb0\x89\x4c\x7a\xb1\xc5\x93\xee\x29\xe9\x9c\x93\x98\xe5\x43\x29\x2b\x53\x70\x4a\x2e\xdd\xe8\x52\x9f\x05\x8a\x2c\x3a\x1b\xe0\x9d\xd1\x11\x41\x10\x1d\x93\x4f\xb7\x1c\x93\xa6\xcc\xd2\x65\x29\x8a\x7d\x76\x29\x97\xbe\x02\x2b\xe5\xf8\x44\xb0\xe8\xa5\xa5\xe3\x04\x9b\x35\x66\xc0\xb7\x10\xb3\x01\x01\xd3\xb2\x25\x5b\xc1\xf3\x0a\x4f\xaf\x2e\xc3\x33\x53\xb4\x06\xde\xa0\x61\x59\x9d\x39\x35\x45\xfb\xcf\xa1\x87\xe7\xcd\x7b\xee\xc0\xe2\x3e\x43\x76\x85\x96\x2e\x1f\x16\x5a\xbc\x94\x45\xd9\xd9\x9c\x56\xa1\x64\x59\xa3\x56\xa3\x73\x05\xc6\x0d\xf0\x25\x29\x79\xbe\xfb\x88\x82\xef\x07\x4d\x5f\xf6\xfc\xe3\x8b\x17\x1d\xcc\x4e\x5a\x1c\xaa\x5e\xb0\x6c\xf8\xb0\xa5\x44\x53\x75\xa1\xd3\xe5\xd8\x8b\xc8\x83\x3a\x04\xe3\x4c\xf1\x6a\xbb\x9e\xe7\xed\xf1\x4c\xb2\x57\xa9\x8f\x4b\x8c\xcb\x8f\x63\x14\x71\x71\x46\x3a\x34\xbd\x84\x14\xac\xfd\x6e\x5d\x40\xa7\xb8\x83\x5d\x1a\x03\xef\xc6\x89\xe0\xf1\x13\x9d\xd0\x15\xa2\x9b\x2a\x10\x65\x97\x14\x57\xb3\x63\x63\x6f\x7c\xef\xb0\x3d\xe3\x99\x81\x8f\xaf\x51\x34\x7f\xcd\x2f\x7d\x76\xd8\x88\x83\xa1\x7b\x43\xe3\x37\xac\x61\x2f\xd6\x1c\xd8\xb0\x7c\x4d\x9f\x9a\x95\xa7\xf6\x3d\x35\x46\x99\x9a\x3a\xf6\xd9\x5a\xdd\xa9\x95\xa3\x42\xeb\x06\x2f\x3c\x49\x75\x6b\x00\x11\xa3\x9a\x7d\x13\x15\xa2\x4e\xc1\x04\xac\x2f\xcc\xc8\x70\x3b\xf4\x6c\x51\x71\x4a\xb6\x22\xdf\x92\xc4\xaa\x13\xd5\x60\x52\x9b\x68\x83\x14\xc9\x9f\x4c\x38\x14\xd3\xbe\x18\x21\x92\x09\xfe\x6e\x4c\x51\xba\xac\xb7\x68\xae\x0a\xec\x52\x2d\xc8\xa3\xf7\x85\x62\x7f\x94\x92\x24\xbd\xe6\x66\xec\x6c\xef\xe6\x7a\xc5\xfd\x0b\xab\x8b\x70\xc9\x91\x50\xff\x55\xbd\x1f\x1e\xdd\x6d\x42\x9a\x51\xbd\x7f\xf6\xbc\xc7\xee\x18\x6a\xb0\xa5\x4f\xee\xd5\xf7\xd1\x79\x9d\x16\x54\x77\xe5\x3a\x4e\x5f\x31\xc7\xeb\x2a\x5e\xb4\xad\x22\x7f\xd1\x82\x8a\xe5\xfd\xe7\xee\x05\x5f\xf7\x8c\xd4\xb4\x7b\xb6\x3f\x36\xb5\x6a\x5c\x06\xa3\x18\x50\x31\x6f\xde\x93\x1d\x07\x4f\x5e\xfe\xc8\xa2\x22\x2b\x2d\xcf\xdd\x2d\xdf\x10\xff\xe8\x1e\xc2\x23\x8e\xa0\x0a\x69\xcd\x5a\x81\x89\x73\xaa\x90\xec\x24\xc9\xb3\x59\xb8\x3c\xc8\x87\xd6\xb5\x04\xa2\x3b\x78\xd0\x1d\x22\xc7\xd9\x46\xbe\x30\xa2\xbc\x78\xc3\x5d\xc3\x36\xa7\x25\x6f\x1a\x3e\x76\xf3\xf0\x99\x0f\xae\xb2\x57\xd5\x7f\xb7\x64\xc2\xaa\x1e\x53\xd7\xcf\x59\xb4\x70\xfe\xba\x71\x55\xaf\xac\x3f\x7a\x59\xb2\x4b\x7a\xb4\x7c\xc5\x5c\x22\xb8\xd3\xa0\xc4\xa0\x46\xc5\x13\x67\x40\xab\x63\x54\x2a\x5e\xaa\xca\x38\x69\xe5\x94\xc8\x60\x31\xb0\x21\x3b\x8f\x84\x34\x9c\x96\x5e\x8c\xb0\x50\x06\xca\xc5\xbd\xc4\x0b\x43\x52\x4f\x6c\xbd\x73\x1e\x71\x3c\xde\x5c\x26\xee\x58\xdf\x5b\x9c\xbc\xb5\x0f\x70\xa7\xee\x5e\x0f\x21\xd9\xee\x39\x83\x12\x98\x2e\x84\x2f\xe2\x50\x5e\xd0\xaa\xe2\xb0\x4e\x17\x67\x89\xe3\x18\x97\x53\x4b\x7c\x01\x05\xb2\x4b\x34\x43\x67\xc4\x94\x18\x6f\xa1\x1a\x9f\x95\x22\x5c\xf0\x52\xca\x4e\x8f\x9d\xe3\x00\xdf\x54\x3c\x32\x7d\x4c\x7e\xc9\x9c\xe0\x96\xa9\x25\x9d\x97\x0d\xc8\xc9\x63\x57\x4d\x78\x6d\xcb\xc1\xed\xf7\xac\x5c\xb4\x68\xaf\x5a\xe4\x97\xec\x28\xce\xeb\x3f\xcf\x1c\x99\xdf\x7c\x99\xbd\xc9\xde\x8f\xe2\x51\x12\x91\x37\x16\xb7\x46\x83\x12\xf4\x7a\xa7\xd5\x29\x20\x36\xd9\xa3\x4b\x48\xd0\xba\x1b\x5a\x3e\xa3\xf3\xaf\xe8\xc4\xae\xa0\x45\xa1\x2e\x73\xbb\xe3\x4d\x49\x2e\x57\x62\xbc\x2a\x89\x05\x96\x75\x98\x88\xc4\x21\x82\xf8\x7c\x7e\x64\xd2\x4c\x7e\x76\x76\xfb\xe5\x38\x22\x6a\xa8\x6d\x4e\xa3\xdd\xc8\xb5\x66\xd8\x4e\x9e\x52\x21\xb5\x88\x63\x6f\x16\x2f\xe9\x5b\x52\xb2\x78\x40\x87\xac\xf0\x27\xeb\xe7\x96\x74\x5e\x3a\x30\x37\x17\x9f\x0c\x3f\x84\xd3\xc2\x9f\x40\xaf\x01\xb3\x87\x16\xe7\x0f\x9a\x69\x82\x57\xb7\x89\x0b\xe6\xef\x2e\xca\xad\x58\xc4\x98\xf1\x0f\x47\xc4\x89\xdb\xe6\xef\x94\x6d\xbe\x82\x96\x4e\xcc\x05\xee\x1d\xa9\x9f\x76\x6d\xb0\xaf\x56\x99\x68\xa2\x4b\x9b\x08\x4e\x1b\xc6\xf1\x66\xc6\x41\xa7\xe4\x28\xd9\x24\x4f\x5c\x82\x5b\xc3\x6a\x1d\x0e\xbd\xc9\x6c\x63\xb5\x3a\xbb\x33\x3e\x51\xcd\xaa\x5c\x74\xf5\x7d\x56\x89\x94\x2a\x17\x72\xd9\x0d\x2e\x97\xc1\xce\x30\x44\x77\x52\x67\xf4\x4c\x69\x44\xc9\xf8\xe8\xd6\x0a\xd4\xf4\x20\x07\xb9\xb5\x97\xc8\x86\x48\xbb\xe5\xd4\x5b\x2f\x74\x7b\x1b\x3a\xc4\x9b\x1c\x42\x91\x5f\x3a\x7c\xc6\x54\x72\xf8\xad\x82\xd1\xcf\x91\x0f\xcc\x85\xbf\xd4\x88\xc7\x6a\xfe\x42\x7e\x35\x50\x41\xaf\xe2\x47\xff\x1f\x73\x6f\x02\x1f\x55\x91\xed\x8f\xdf\xaa\xba\x4b\x77\xa7\x93\x4e\x77\x67\xed\x6c\x9d\x3d\x90\x84\x84\x84\x10\xc2\x96\x46\x02\x84\xb0\x84\x1d\x02\x84\x00\x49\x20\x01\x21\x10\xc2\xa6\x42\x82\x8a\xb6\xa3\x0c\xa3\xe8\xa8\x83\x8a\xa3\x8e\xfa\x70\x41\x04\x15\x57\x54\x70\x44\x85\x01\x59\xdc\x50\x51\x40\xdc\x05\x04\x37\x48\xdf\xfe\x9f\x3a\xf7\x76\xa7\x13\x82\xa2\xe3\xfb\xbf\x1f\x7c\x72\x52\xa9\x5b\xf7\x7b\x4e\x9d\x3a\x55\x75\xea\xde\x5b\x75\xd4\xad\xe4\xc5\x0a\x98\x53\xfb\xdd\xab\xae\x27\xfd\x2b\x36\x54\x90\x1f\x38\x19\xa2\x7e\x72\x2f\x99\xaa\xbe\x05\x69\x35\xa8\xa2\x85\xfc\x70\xaf\x1a\x04\xf6\x13\x0c\x95\x3a\x2e\xad\x12\xc2\x85\xc5\xae\xcb\xc2\x2c\xd4\x16\x22\x04\x11\xd9\x64\x12\x43\x0d\x66\x91\x08\x76\x9b\x21\x22\x32\x24\x2c\x3c\x6c\x7a\x45\x10\xc6\xfa\x34\xb2\x70\xe6\x32\x51\x46\xa7\x57\x18\x2c\x2c\x81\x41\x06\x63\x36\xc9\x66\xa9\xaa\xb0\xd9\xf8\x79\xe8\x01\x81\x03\xf0\x5b\x05\x7e\x6e\x3c\xa4\xf3\xda\x1d\x1b\xaf\x6f\x68\x6f\x3b\xfe\xdc\x1f\x3d\x80\x87\xd1\x48\x2e\x7c\x3a\x6e\xad\x63\x6d\xf5\xf6\x6a\x8c\x9a\x11\x87\xb4\x98\xee\x8a\x6f\x5d\x3e\xed\x6f\x0e\x5a\x7f\xeb\x6a\xe2\x55\xc9\xea\x5b\x57\xab\xdb\xee\x22\xc7\x57\x63\x3f\x88\x06\x72\x0e\xda\xce\x2e\xcc\x72\xf5\xa2\x36\x9b\x12\x44\xac\xa2\x25\x34\x54\x0e\x33\xf3\xed\x4c\x72\x78\x88\xcd\x6e\x1b\x05\x95\xb0\x87\xda\x41\x66\xbb\x56\x89\x51\x7a\x25\x18\x93\x42\xc3\x25\x01\xa4\xe7\xdb\x89\x2f\x94\xdb\x7f\xb4\x5b\x11\x3f\x05\x53\x5b\xe9\xea\x82\xfb\xcf\x6c\x07\xb1\xef\x8d\x9b\xe7\x98\x37\x67\xeb\x9c\x06\x47\x43\x1c\xfc\xcc\xda\x52\x3b\xcf\x41\x6f\xbe\x75\x35\x4d\xf2\x7c\x0c\xe2\x7a\xce\x52\xf3\x6a\x81\x78\xf7\xe8\x3a\x8f\x11\x66\xbb\x62\xa3\x65\x21\x8a\x98\x83\x83\x4d\x0e\xbb\x89\x08\x52\x6c\x5c\x84\x65\x7a\x85\x24\x44\x90\x48\x86\x3b\x1e\x63\xc0\xbb\x8d\x70\xd9\x8c\x46\xd0\x38\xf8\xb7\x91\xcc\x68\x84\x89\x5c\x88\xae\xf2\x07\xd5\x02\x91\xf9\x51\x4c\x7c\x73\xa2\xe3\x23\x1e\xa9\x60\x67\xfb\xe3\x89\xf8\x66\x2d\x7b\x7a\x12\x9e\x91\x9a\x1f\x09\x22\xb7\x9d\x48\x95\x0e\xfa\xee\xef\x4e\x4e\x4f\x31\x5e\x1d\xba\x62\x7a\xda\x82\xed\x2b\xa3\x63\x13\x92\x2d\x57\x47\xcc\x9a\x9e\xe9\xa8\xa4\x6f\xc4\xd3\x67\xc5\xdc\x9c\x39\x57\x88\x74\xa0\x67\x89\x94\x93\xdb\xd8\x68\x52\x53\xef\xd2\xf7\xca\x49\x43\xa1\x0e\x3c\x7e\xe1\x38\x57\x96\xdd\x66\xe3\x67\x00\x19\x8c\xa1\xc1\x46\x16\x13\xc1\x58\xac\x5d\xa9\xaa\xb0\x06\x99\x83\x40\x6a\xf0\xe4\xed\x66\x63\x48\x88\xa3\xaa\x22\x84\x19\x7d\x07\x68\xe2\x69\xc1\x01\xe1\x55\xfc\x2b\x62\xdf\x41\x99\x62\x78\x98\xd8\x85\x68\x27\x28\xc6\x68\xe1\x12\x9c\x56\x3c\x34\x7a\xdc\xe7\x24\x44\xdd\xab\xfe\xac\x4e\x9a\xb3\xfd\x89\xb5\x8e\xbf\x96\x2e\x23\x53\x1c\xea\xbf\x32\xc8\x35\x64\xe5\x3d\xff\x50\xef\x97\x56\xed\x7b\x8a\x9f\xa8\xce\xfe\xb2\x9a\x34\xaa\x7f\x5d\xfd\x1f\x52\xb8\x74\xa5\xd6\xc7\x9d\xea\x44\xc9\x8d\x67\x85\x26\x0b\x15\xae\x6c\xc1\xe1\x88\x8f\x8f\x88\x8e\xb0\xa4\x26\x1b\x25\xc9\x62\xb1\xb2\x94\x68\x9a\x4c\xab\x2a\x92\x93\x05\x9b\x2d\x09\x8c\x9a\x99\xcc\x66\xa8\x8a\x39\x46\xf0\x9d\xb2\x1b\x15\x78\xa2\x3a\x88\x4b\xf2\xad\x81\xdf\x1b\xe2\xd1\x8f\x2c\xb1\xc3\xc9\xf4\x17\x9e\xa9\x2e\xc6\x9c\x51\x87\x5c\xa7\x4c\xc8\xef\x91\xd0\x7b\x60\x53\x83\x89\xa4\xd1\x1a\xed\xd0\x74\xb3\xba\x00\x0f\x4d\x1f\x5f\x4b\x87\x7a\xca\x12\x12\x2b\x43\xef\xb1\x2e\x9e\x95\x93\x27\x7d\xd7\xe1\x68\x74\x41\xf4\xde\xa7\x4e\x12\x7f\x00\xbb\xef\x26\xf4\x04\x1f\xc2\x25\xac\x71\x95\x17\x0a\x62\x08\xe9\x5e\xd4\xbf\x77\x5c\x46\x4e\x71\x62\x54\x54\xdf\x08\xbb\xbd\x6f\xbf\x62\x43\x46\x7a\xef\x22\x22\x06\x0d\x08\x0f\xbf\xac\x5b\x4c\x51\x42\xf7\xac\xee\xa3\x2a\x7a\xe7\xf6\xcf\x1d\x5d\xa1\x74\x21\xd9\x2c\xab\xbf\x3d\xc2\xd0\x4f\x0c\xee\x0f\xff\xad\x29\x59\xb0\x06\xb2\x9a\x46\x55\x58\x43\xf5\xed\x4d\xfa\xb1\x97\xda\xd0\xe5\x0f\xab\xa8\x6f\x2b\xea\xf4\x88\x73\xfe\xa1\x23\xce\xa1\x29\xa9\x76\xdc\xf7\x8a\xe7\x3c\x46\x92\x7c\x82\xd1\x20\x02\xf5\x53\x98\x0c\xd6\x98\xce\xa3\xec\xf1\xf5\x6c\xa1\x14\x16\x69\x17\xc1\x13\x2b\xec\x39\x8d\xc4\x96\x96\x12\x13\x89\xd9\x92\x5b\xb6\xf4\x8a\x98\x27\xb3\x8f\xbc\xb0\x60\x0c\x31\xad\x53\xdf\x1c\x6a\x2f\x0b\x1a\x1d\x93\x18\x72\x59\xff\xca\xf1\x92\x3c\xf6\xc9\x95\xdd\x55\x0f\x3d\x7b\x8b\xfa\x53\xf0\x8c\xbb\x66\x85\x7a\x8e\x64\x9f\x50\xbf\xa5\xb3\xd9\x9c\xc9\x76\x75\x12\x79\xb1\xcb\x5f\x46\x3e\xfb\x92\x48\xa2\x63\xc6\x4f\x8c\x5b\xb7\x3a\x99\xfc\x53\x75\x0c\x5f\xe4\xaa\x54\xaf\xcb\xcd\x18\xaa\x2c\x08\x1d\x31\xdc\xb5\xb2\x96\xa9\xf5\xec\x65\xa6\x4e\x1f\x7b\xdd\x88\x15\x43\x73\x48\x5d\x0c\x49\x4a\x79\x90\xcc\x44\xbb\x51\x5f\x04\x3d\x87\x82\x9e\xa3\x61\xa6\x1b\xeb\xca\xb2\x88\x51\x51\xb1\xcc\x60\x67\x4c\x30\x9b\xe3\x85\xb8\x68\x98\x70\x49\x94\x28\x85\x45\x44\x58\x47\x55\x44\x44\x04\x09\xb1\xe0\xce\x8d\xae\x30\x2a\x92\x45\x28\xfe\x4f\xbe\xff\xbb\x5b\x81\x9b\xb9\x7f\x2f\x56\xa4\x7f\x8b\xaa\x91\xe8\xc1\x0b\x14\x7e\x6e\x74\x9b\x6e\x40\x29\xf6\x64\xf5\x45\xf2\x2f\xe9\x9a\x15\x8e\xe6\xfa\x65\x39\xaf\x11\x61\x9d\xc7\x6a\x9e\xdc\xb5\xb7\xbd\xba\xac\xa6\xbb\xba\x9f\x5a\x77\xdd\xa8\x4e\xa2\xb7\x39\xe9\xc6\x6b\xbe\xff\x9e\xdc\x72\xbe\xb6\x6f\xd2\xa4\x90\xd5\x51\x83\xd5\x34\x31\x85\xf4\x81\xb1\xb1\x58\xad\x93\xde\x00\x9b\xb7\x08\x43\x5c\x69\xa2\x14\x62\xb1\x98\x49\x90\x10\x1c\x4c\x14\x83\x24\x85\x5a\x0d\xac\xaa\xc2\x60\x20\x41\x32\x83\x61\x9c\x10\x73\x55\x05\xd1\x46\x96\xd0\x7f\x63\xb3\x07\x1e\xc1\xe4\xb3\xef\x64\x3b\x8f\x13\x00\xc3\x36\x1f\x01\x59\xb2\x78\xf3\xad\xcd\x1e\xd2\xbc\x9d\xd8\xb6\x37\x51\x6f\xd3\x73\x67\x6e\x9c\xbf\x99\xae\xf1\x2c\x92\x56\xf1\x63\xad\xcf\x27\x78\x76\x61\x2c\x12\xb5\x4e\x0c\x07\x1d\xc6\x09\x25\xae\x14\x18\x10\xac\xb2\x1c\x6c\x32\x85\x38\xe2\xa2\xa4\xf8\x84\x68\x21\x2a\x3c\x8e\x99\x43\x42\x8c\xa3\x2b\x42\xc2\x99\x7d\x54\x05\x0b\xf5\x7f\x57\x1f\xfa\x6f\x5b\x11\x6e\x81\x6c\x7b\x68\x06\x23\x84\x3f\x32\x55\x3e\x1f\x24\xda\xc2\x56\x81\x5c\xb2\x42\x9a\xc7\x3e\xb4\xe8\xd6\xdb\xc2\x67\x2d\xa9\xbf\xbf\xfc\xfa\x95\xb6\x2d\x2b\x5f\x76\x2e\xd9\x42\x9c\x5b\x87\xd9\xe2\xd8\xaa\x45\x15\x18\x35\xe4\x47\xcf\x67\xe4\x0e\xba\x7a\x52\xff\x87\x5e\x7e\xc0\x73\x9f\xb4\x5b\x5d\x59\x53\xab\xf9\x55\x5c\x67\xfc\x5c\xf0\x50\x2e\x2b\x13\x83\x64\x02\x93\x89\x89\xeb\x0c\x3c\x7a\x5b\x90\x42\xa8\x28\xf0\xa7\xe4\x36\x8b\x20\x98\xfd\x63\xb1\xa6\xb1\xc8\xa2\x0b\xce\xac\x4a\x24\x9a\x5c\x85\x24\xdf\x48\xb8\xb8\x4c\x55\x33\x5e\x9a\xb3\x9d\x58\xb7\xbb\x6f\xa2\x77\xfe\xe0\xb1\x91\xe7\x40\x67\xe5\xf4\xbe\x55\x9e\x23\xa0\xb5\x11\xab\x68\x9e\xe7\x2f\x9e\xdb\x3c\xbb\xf8\xa9\x0a\xba\xee\x26\x80\xee\xac\xc2\x20\x57\x2a\x48\x13\x6a\x0d\x31\x9b\xad\x20\x8d\x64\x33\x99\xec\x20\x0f\x13\x8c\x16\x49\x10\xc3\x83\xcd\x82\x79\x74\x45\xa8\xc0\x23\xb7\xe8\x56\xc7\x9d\x8f\x76\xbd\xb4\xa3\x40\x85\x5c\x22\xfa\xb6\x7a\xf6\xe1\x52\xae\xa1\x2d\xbb\x49\xfd\xc7\x9e\xef\x88\x91\xcc\x00\xdd\x91\x1f\xaf\x52\xaf\x93\x76\xb7\xce\x7d\x89\x0c\x52\x73\xd4\x68\xc2\x75\x86\xdf\x22\xbf\x07\x3a\x8a\xc5\x33\x4b\x8a\x5d\x4e\x42\x69\x50\x90\x6c\x82\x99\xd4\x60\x08\x66\x66\xa3\xac\xc8\x55\x15\x0a\x13\x4d\xcc\x04\x06\xc5\x9d\xa0\x7f\xfb\x06\x4f\x5f\x14\xa1\x80\xe3\x12\xc1\x9e\x0a\xf9\x89\xb0\x0a\x49\x64\x5f\x6f\x2e\x6f\x2d\x8f\x11\xe3\x3d\x2c\x9e\x7d\x15\x73\xfe\x28\x5b\xac\xd6\x91\x3b\xd6\x8a\x13\xee\xba\xf1\xfc\x83\x18\x6b\x13\x74\x71\x99\xd8\x1b\xf9\x26\x30\x45\x11\x4c\x7c\xc3\x96\x99\x4a\x52\xb0\xcc\x44\x36\xaa\x42\xb4\x10\x45\x50\x46\x55\x98\x02\xb4\xd0\x3e\x26\x9e\x6e\xc7\xf9\x7e\xa6\xc9\xf6\x50\x07\xcb\xf3\xac\x8b\x61\xbd\x62\x5a\xff\x43\x9f\x9f\x7b\xff\xa8\x1b\x58\xda\x8d\x37\xb4\x7e\xe0\xf9\x88\xe8\xfe\x21\x8f\x2d\xf5\xa9\xf4\x77\xb0\x89\x58\x58\x83\x26\x38\x14\x22\x84\x85\x59\x14\x4b\x5c\x7c\xa8\x2d\x84\x91\x60\x16\x14\x14\x51\x55\x11\x24\x32\x6b\x55\x05\x0b\x38\x34\x10\xe3\x9a\x04\xec\xcd\xe6\xea\x2f\x94\xf1\x64\xc0\x50\x7e\x32\x60\x64\x61\x3e\x49\xcd\x2b\xe4\x83\x24\xc6\x91\x12\xed\x21\x77\xee\x7e\x56\xfd\xe9\x86\x43\xe4\x06\xf5\xd5\x5b\xfe\x99\xa0\x7e\xe3\xf1\x9c\xbc\xe1\xe9\xe9\x5f\xbe\xa0\x7e\xf8\xcf\x23\x43\xa6\xac\x21\xd2\x63\x84\x92\xbf\xbd\x3f\xa2\xd7\xb9\xe6\xd5\xb3\xd9\x63\x35\x5b\xd5\xe7\xf6\xbc\xf9\x39\xe8\x66\x01\xcc\xcb\x79\xe2\x48\x21\x52\xe8\xea\x0a\x67\x94\x2a\x51\xa1\xa1\xd1\xc1\x61\x63\x2a\xac\xd6\xe0\x50\x6a\x51\x48\xb8\x16\xca\x31\xa7\x6d\xef\x17\x9e\x54\x9c\x6f\x8f\x48\x20\xc5\xc4\x1e\x18\xa3\x48\x21\xad\x87\x9e\x79\xb9\xd6\x68\x12\xfb\xf4\xfb\x62\xf0\x2d\xb3\x47\x2f\x4d\x58\x11\x9f\x97\xda\xb5\x38\x59\xec\xed\x71\x95\x34\x15\x2c\x5e\x42\xf6\xdd\x74\xc5\xa8\x61\x35\x7d\xd3\xfb\x5e\xe6\x7b\x0e\x2b\x18\x07\x80\x8e\x52\x85\x3e\x2e\x67\x98\xdd\x1e\x19\x92\x20\xd2\x34\x9a\x1e\xcb\x12\x22\x43\x98\xcd\xce\x6c\x36\x93\x4d\x00\xd3\x80\x91\x53\x14\x8a\xf3\x72\xb4\x73\xc6\x79\x64\xa1\xc0\x03\xd0\xf2\xfc\x22\x24\xb3\xb4\x74\x18\x95\x50\xc2\xc8\xc2\x9e\x60\xaf\xfa\xef\xfe\xc4\x30\xed\xae\x21\xab\xe3\x7a\xa6\xe6\x0d\x49\xf2\x1c\x3a\x3e\xd8\x20\xe6\x8c\x51\xa7\x1e\x5f\xf3\x7a\xb9\x59\xec\x3d\x32\x82\xdc\xfb\x4c\x59\x90\x12\x3a\x35\x8b\xf4\xe9\xf7\xa0\xf4\xf7\x75\x73\xfb\x64\x14\x0d\x3a\x7f\x0d\x6b\x1e\xf1\xc9\xc2\x17\x5a\x57\x49\xab\x5a\x57\xad\xdf\xee\x7e\xba\x1b\x9b\xd7\xba\xee\xea\xaf\x92\x0f\x4f\xa5\x77\x5e\xbd\x1c\xeb\x30\x4b\x10\x94\x02\xd0\x61\x92\xd0\x03\xd6\xbb\xc1\x06\x96\x1c\x13\x93\x12\x95\x30\xa6\x22\x36\x36\x2a\xd4\x12\xca\x6c\xc1\x4c\x31\x58\x94\x70\xae\x4b\x4d\x74\xbf\x3e\xf1\x15\x52\x32\xf3\x4b\x1c\xc7\xc3\xc7\xf2\xd3\x0d\xfb\xd3\x00\xbd\x8a\xd9\x6f\x67\x88\x29\x2e\xf5\xf5\x7d\x95\x4f\x66\x48\x7d\xc9\xe5\xaf\x64\x1b\xc7\x7e\x9d\x31\xa1\x76\xfc\xf0\x79\x49\x5c\xc5\x59\xc5\x89\xd4\xf3\x3f\x15\xb7\x7b\xca\x40\xd3\x89\x45\x03\x86\xdf\xc0\x62\x3d\xd1\x2f\xfd\x9b\x4a\x93\xea\xba\x0d\x1d\x03\xfa\xee\x33\x50\xb3\xc9\xc5\x82\x20\xfe\x5d\x1c\x04\xf3\x52\x32\x8c\xee\xa9\x36\xc6\x1c\x86\x10\x70\x69\x0c\x92\x98\x22\x08\xa9\xcc\x16\x6b\x1b\x5d\x21\xc7\xc6\xd2\x68\x4b\x50\xe2\x98\x8a\xa0\xd0\x08\x1a\xee\xdb\xdb\xa3\x1d\xde\xd4\x3e\x6c\x80\x7e\xc0\x1e\xe3\x4f\xb2\xda\x4e\x72\x57\x22\xd1\x3a\x8c\x24\x2c\x52\x8f\xf3\x24\xfe\xdd\x73\xe7\xa1\x29\x0b\xa3\x17\x1b\xff\xb5\x62\xe4\xe4\xc2\x25\xd3\xba\x04\x19\x44\xc7\x34\xd2\xec\x79\xd8\x7c\x5d\x78\x5c\xd7\x9e\xfc\xa8\x3a\x9a\x9c\xb2\x22\xbd\x6f\x9e\xfb\xd1\x49\xc3\xfa\xaf\x98\x99\x71\xac\xcf\x8a\x82\x82\xa7\xe9\xab\xea\xf9\x8c\xfc\x41\x15\x61\xc9\xfd\xf9\x38\xcb\xe5\xc7\x33\x94\x92\x5c\x36\x45\x82\xfe\x6b\x30\xca\xa4\xaa\x42\xe6\x3d\x99\x8f\x1a\xc5\xfe\x09\x88\xbf\x09\xd4\x26\x1d\x71\xa9\x47\xd6\x27\x9b\x73\xbe\x69\x06\xb0\x92\xc1\xaf\x2e\x84\x71\x01\xb1\xa8\x40\x64\xc0\x22\x30\x09\xf3\xd3\xf7\x2c\x72\x78\x07\x2c\xa6\x05\x2b\x23\xff\x53\x41\x3e\x8f\x56\xa3\xa7\x6f\xdd\x2f\xf6\x56\x7b\x5e\xa3\xda\x01\x81\x0a\x43\xbc\x5f\x8b\x3f\x8a\x63\x40\xaf\x29\x82\xcb\x95\x64\x0f\xb2\x80\x52\x93\x19\x8b\x08\x62\xa9\x69\x21\x96\x51\x15\x21\xa1\xa0\xe4\x08\x58\x40\x44\x08\x8e\x51\x15\x42\x68\xc0\xb1\x58\xc5\x99\x1d\xd7\xae\x78\x1a\x2c\x0f\x1b\x97\x56\x10\x2a\x14\x46\x8a\x0c\x63\x5b\xfa\x4e\x81\xed\x4f\x6d\x05\x3d\xd8\xdb\x37\xdd\x39\xf9\x7f\x54\xef\xb6\x1f\x3d\x24\xf2\x9b\x58\xf5\x9b\x7e\xb6\xc5\x4b\x16\x64\x6e\x5a\x3b\x74\x8a\x63\x61\xc3\x1d\xb3\x8b\xc4\x51\xaf\x3f\xf1\x77\xf5\xcd\xd7\x2a\x8f\x1f\x23\x76\x52\x9f\xb2\xda\xa5\x6e\x9f\x3c\xec\x2f\x1b\x14\x5a\xf2\xc1\xf3\xab\xaf\xbe\xd1\xf3\x2c\x9b\xf0\x04\xb1\xcc\x3e\xa4\xed\x3f\x14\x6e\xa4\x5b\xd8\xf5\xfa\xfe\xea\x30\x41\x16\xf9\xc9\x51\x06\x51\x92\x14\x99\xb6\x08\x84\x30\xca\x3f\x64\xcf\xc9\x77\xc0\x32\x34\x2f\xa7\x6d\x53\x08\x5f\xd9\xa4\x2a\x04\x7e\xfa\x3a\xe9\xc4\x04\xcf\xcc\x04\x3a\x29\x81\xfc\x70\xdf\xa9\xfb\x3c\x0f\x02\xe1\xd8\x4f\xb2\xa7\xc9\x34\x3d\x16\x70\xe8\x53\x44\x10\xe4\x16\x91\x1f\x78\x57\x94\xf3\x1a\xb8\x7c\xe0\xc2\xf0\x45\xc6\xc8\xd8\x3b\x63\x73\xeb\xae\xac\x13\x17\xad\x5b\xf7\x22\x8d\xf0\x7c\xa5\xed\xb5\xdd\xc2\x7e\x22\xd7\xfb\xef\x15\xa1\x99\x5b\x08\xbf\x37\x8f\xdf\x6b\x24\xe9\x44\x2a\xc8\x0f\x27\xd7\xab\xeb\x26\x92\x79\xea\x35\xff\x90\x6a\xd4\x75\x13\xc8\xbc\x55\xeb\xd6\xc1\xbd\x65\x62\x15\xb9\x56\xbf\xd7\xbc\x45\x52\x28\xdc\xf9\xd1\xc7\x7b\xb8\x5d\x14\x26\xa6\x02\x5f\x32\xcf\xf3\x51\x24\x4d\x56\xb7\xc6\xfd\x23\x4e\xac\x5a\x3e\x63\x1d\x0f\x22\x4f\xd4\xef\xe0\x3e\x1b\xdc\x27\xc1\x5d\xac\x05\x7e\x41\xad\x77\xe3\xe6\xca\x7c\x6b\xa2\xfa\x1d\x79\x68\x85\xe7\x43\xf1\xbd\xb3\xea\x3a\xb0\xa1\x3b\x45\x85\xd5\x29\x4b\x04\x23\xd8\x50\x08\xc6\x47\x96\x04\x53\x10\x91\x78\x1c\xe0\x1c\xa8\xa1\xbe\x7d\xdc\x77\x9a\x82\xb6\xe7\x37\x9f\xb0\x3a\xf5\xe8\x3a\xf5\x28\x99\x62\x25\xd5\xb2\xc9\xe3\xa1\x2c\x92\x8c\x57\x37\x6a\x63\x62\x3b\x4c\x70\xb9\x18\xd4\xc0\x14\xc4\xcf\x63\x51\x2e\xc4\x84\xce\x47\xb4\xad\x41\x80\x79\xb7\x55\xfd\x17\x89\x5f\x47\xe2\xa5\x4a\x75\x23\x19\x1f\x49\x99\xc7\xa3\xf5\xfb\x77\xd9\x83\x74\x95\xb2\x07\x75\xd1\xc3\x15\x2e\x13\x91\x19\x18\x33\x62\x60\x3f\x23\x23\xf0\xa7\x28\x6d\x23\x71\x4f\x56\x88\x4c\xc8\xc9\x69\x5b\x93\xfb\x47\x29\x0c\x9c\xcd\x75\xb6\xb5\x7e\xea\x07\xea\x84\xb8\x77\xe3\xc4\xfd\xf4\xfc\xf9\xf7\xef\xb8\x03\xf1\xdf\x07\xfc\xab\x74\xfc\x5e\xae\x48\x81\x30\x99\x30\x03\x3f\xf9\x95\x86\x82\x25\x31\x7e\x4a\x84\x22\x23\x07\x85\x74\xc6\xc1\x17\xa4\xdb\xae\x24\x17\x92\x2d\x1f\xec\xae\x9f\x0f\x2c\x00\xf4\x3c\xc9\xba\x43\x9f\x4f\x1f\x22\xff\xa2\x65\x7a\x7b\x16\xb9\xa2\x3a\xe5\xe1\xf2\x31\x11\xf4\xd0\x61\xff\x29\xba\x18\x93\x55\x3a\x13\x40\xf5\x31\x21\xaa\x47\xac\x27\xef\x03\x0f\x23\xff\x36\x40\x92\x8c\x2d\x0a\xc3\xe6\xd7\x83\x88\xc3\x7d\xf0\x63\x4f\x24\xaf\x9c\xcc\x5e\x91\xfd\x78\xf6\x8a\x41\xf4\x76\xa9\xfc\xc4\x89\x13\xa4\x1a\xdb\x4e\x5d\x0b\xa4\x18\xfe\xe0\xf7\x83\x68\x7e\x73\xd5\x9f\x6a\xda\xc1\x5f\x47\x9f\x3d\xcd\x53\x3f\x68\x45\xd6\xa6\xac\xab\xb2\x4e\x92\x6a\xb8\x9f\xfb\x47\x9f\xa9\x13\x69\xa5\xb7\x49\x90\x85\x58\x57\x10\xb4\xba\x01\xea\x29\xb6\x48\xbc\xe3\x01\x82\x3e\xff\xf2\x45\x52\xbe\x3d\x39\x5d\x81\xe5\xc6\xa3\x1b\x37\x2e\x78\x46\x9d\x48\xe2\xd4\x63\x2f\xbd\xa4\xe9\x68\x81\xb0\x87\x7c\x2f\xa6\xe9\xe7\x19\x04\xcb\x02\x05\xb3\x31\x1a\x64\xf1\x65\xec\xc0\xbc\x22\xba\xf1\xe8\xd1\x90\xf1\xa7\x2e\x6b\x77\x26\x99\xd8\x75\x4f\x26\xf9\xc7\x9e\x3d\xf4\xa6\x3d\x7b\xb4\xb5\xaf\x70\x96\x8d\xd1\xcf\x5c\x88\x75\x99\x65\x01\x6c\x86\x82\xb2\x5f\x96\x44\x1d\x8a\x7f\x95\x85\x23\x00\xf8\x44\xf0\xb3\x22\x8e\x6e\x8b\x6b\xfd\x3a\x96\x6e\x8b\xa5\xef\xdc\x7a\xab\x1a\xcf\xcf\xc9\x21\xc2\x83\xb4\x82\xbc\x87\xfd\x29\xd2\x05\x03\x2c\x8f\xe1\x00\x03\x80\x1e\x01\x5e\x3b\xf5\x06\x43\xc7\xfe\x34\x7a\x44\xd6\xb3\x59\xb4\x82\xde\xf2\xe9\xa7\x78\xc6\x1d\x1b\x45\x76\x77\xb8\x8f\xb5\xbb\x8f\xe0\x7d\x24\x66\x74\x1c\xdc\x08\xa5\xd7\x7f\xfa\xa9\xd7\x2b\x0c\x82\x39\xa2\x9b\xb4\x3b\x34\x4d\x18\x8a\xb1\xcf\x87\xd3\x22\x3c\xe7\xb3\x63\x7e\xb9\x9e\x7f\x0f\x49\x23\xdf\x89\x6f\xd9\xd2\x24\x23\xcf\x17\xcf\x0a\x6f\xa9\x4f\x41\x7b\xdc\x2b\x3d\x48\x8b\xe4\x63\xe0\x43\x5b\xb7\x1a\x84\x96\x10\xb6\x8d\x14\xc3\x5c\x08\x6d\xd1\x16\xbc\x09\xd8\xeb\x47\x76\xd3\xa2\xd8\x57\xd6\xfd\x65\x83\x7c\x2f\x2d\x1d\x36\xac\x2e\x44\x3e\x76\xfb\x83\xd7\x2d\x71\x26\x86\xd9\x8b\xca\x66\x0c\x45\x3e\xdb\x48\x5f\xf6\x8d\xf8\x56\xa8\xc6\x27\x5d\xe2\x5b\x90\x05\xab\x22\x9e\xa4\x8b\x68\xb2\x10\xf2\x0c\x2d\x37\x10\x8b\x81\x18\x04\x6b\x65\x65\x81\xd7\xeb\x7d\xc1\x7b\x44\x7c\x0b\xe4\x92\x25\x1b\xc6\xb8\x3d\x0c\xbe\x5a\x3a\xfe\xad\x9d\x5b\x0a\xb6\x26\xbe\x84\x7f\x33\xfc\x7b\x30\xfc\xfd\x20\xfe\x2d\x62\xf9\x2f\x61\x7e\xfb\x12\xff\x0e\xc2\xeb\x63\xbc\x07\xc4\x2e\xf2\x2a\xf8\xdb\x8c\x7f\x97\xf2\xa0\x87\x78\x3d\x18\xff\x5e\x03\xe5\xdf\xc7\xbf\xa3\xf0\xfe\x77\xe1\x7a\x0c\xfe\xed\xc0\x71\x69\x12\xa5\x62\x99\x58\xc7\xad\x61\x0b\x0c\xa6\x74\x1b\x19\xf0\x54\xc5\xdf\x08\x0c\x1e\xdb\x48\xa1\x50\xbc\x13\x63\x9a\x68\xa3\x2b\x7f\x42\x27\xa6\xb6\xe6\xa7\x92\xeb\xc7\x3c\x37\x86\xdc\x44\xe9\x73\xe4\x51\x75\x9c\x26\xf7\x56\xef\x8f\x72\x92\x5c\x02\xfa\x8e\x46\x7d\x9f\x96\x42\xfd\xf9\xb2\x3f\x5f\x16\x4f\x97\x75\x56\x3e\x5d\x3c\xcb\x36\x7a\x37\x5b\xf5\xfb\x84\x08\x57\x08\x79\x39\x8e\x3c\x10\x47\x6a\xe2\x48\x8f\x38\x12\x67\xe5\xef\x25\x0b\x2e\xc0\xf3\xdd\xa7\xe1\x5e\xe4\x2e\x4d\xcf\xde\x68\xd4\x73\x1a\xd7\x73\x28\x6f\x9f\x35\x5a\xbe\xfa\x40\xbb\xfc\x53\xf4\x8e\x76\xed\x82\xf9\x20\xd7\x59\xb2\xdb\xf3\x0c\xb4\x27\xc9\x89\x26\x96\x68\x12\x0d\xed\xb9\x90\xb7\xe7\x37\xd0\x3e\x7d\xb0\x1c\xd1\xec\x8c\x1c\xc1\xfb\xdf\x87\xce\xf6\x3a\xe6\x53\xed\x7e\xe1\x5d\x61\xb8\x90\xee\x8a\x26\xe5\x31\xa4\x38\x86\xe4\xc4\x10\x4b\x0c\x89\x21\x35\x31\x24\x2c\x86\x88\x90\xb4\xa2\xac\x3e\x91\x03\x6d\x21\x8d\xdb\x02\xca\xc0\xcf\x14\x32\x6e\xe5\x27\x5d\x19\xac\x50\x2a\xc0\x3e\xd2\xb8\x7d\xf0\x32\x74\x15\x96\xa1\x3d\xf8\x39\xd1\x58\xc6\x7b\x00\x1a\x5a\xeb\x0b\x12\xb6\xc1\x59\x01\xf1\xbd\xdf\x81\x8c\x47\xc4\x8f\x20\x5f\xd6\xf2\x63\x74\xbe\xb0\xc6\x11\xc5\x23\x90\x6f\xd0\xea\x44\x9f\xc6\xf2\x2a\x1d\xdc\xd6\xa7\xb0\x4e\x99\xc2\xa3\x82\xf9\x69\x18\xa1\x2d\xd6\x52\x45\xb0\x66\x16\x68\x36\xa7\x36\xa3\xcd\xa5\x49\x26\x5d\x6e\x3e\x0e\x07\x3f\x43\x4a\x42\x89\x18\x0a\xcb\xd6\x4a\x4d\x2e\x9f\x2d\xa7\x71\x5b\xc6\x72\x8f\x7b\x9f\x17\x6c\xae\x20\x52\x12\x49\x7a\x44\x12\x31\x92\x44\x5a\xf5\x76\xf7\xd9\x79\x1a\xb7\x73\x2c\xfb\x04\xf8\x5b\x80\xd9\x56\x0e\x31\x8f\x41\xbb\x99\x50\xf6\x10\x5d\x1f\xad\x5a\xb9\x88\x58\x12\x14\x4b\x62\x7d\xe5\x60\x30\xa2\x2f\x20\xef\x50\xbd\x2e\x6f\xe8\xba\x8d\x20\x11\xba\x6e\x79\x4c\x15\x19\xcb\x58\x75\x3d\x3c\x88\xf5\xbb\x5e\x6d\x16\xd7\x62\xbe\x5d\xe7\x31\x59\xd8\xca\x6d\xe3\xcd\x48\x32\x0f\x64\xd1\xfb\xba\x90\x0f\x6d\x73\x2f\x96\x0b\xd3\xcb\x8d\x82\x72\x91\xae\x60\xf2\x66\x3c\x99\x17\x4f\xe2\x49\x31\x10\xab\xd6\xea\x05\xfe\x36\x11\xeb\xf0\x9e\x08\xbd\x9e\x66\xf5\x20\xda\xcd\x26\x1b\xd9\x60\x23\xc5\x36\x92\x83\xf1\xbd\x6d\xa4\x87\x8d\x88\xf0\xdb\xea\x37\x1b\x1f\x46\x2b\xc8\x77\x33\x62\x44\xea\x7c\xeb\x84\x1a\xd0\x01\xed\x11\xa1\x57\x4f\xab\x9f\x6f\x6c\x48\xe3\x63\xc3\xc5\xdb\x49\xeb\x73\x58\x2e\x5a\x2b\xc7\xfb\xdc\xc5\xfb\xa8\x7f\x8c\x49\xe3\x63\x0c\xf2\xff\x54\xc3\x0d\x8f\x23\x06\xad\x60\x81\x3e\x56\x51\x33\xf6\x65\x49\x1b\x33\x84\x73\x28\x3f\xf6\x29\x39\xd3\xdf\xa7\x7e\x22\x3f\xb6\x8d\x7d\x98\x1f\xa4\xe7\xdf\x83\xed\x81\x7a\xc6\xfc\x30\x2d\x9f\xa6\xe2\xd8\xf6\x1c\xc8\xd1\x5d\xe6\x67\xde\x27\x6f\xb5\x40\x0d\xac\xdb\x49\x6f\xc1\x48\x8a\xe0\x92\x08\x94\x92\x9e\xb0\x1c\xc8\xe7\x2b\x02\x9f\x0f\xc1\xf2\x49\x4f\x3e\xfb\x84\x50\x58\x74\x92\x49\xf7\x2c\x7a\x6e\xdc\x04\x52\xb6\x65\xd8\x65\x2f\x15\x3b\xab\xae\xba\x8a\x98\xbe\x14\x73\xe8\x18\xb5\xcc\xb3\x6e\x0d\x21\x47\x0e\x5f\xfe\xd8\x2d\x75\x2a\x9e\xd5\xec\xe9\x22\x6e\x17\x96\xc8\x79\x30\xbf\x9b\xb7\x08\x06\xfd\x78\x61\x3e\x09\x26\x89\x4a\x72\xcf\x94\xc4\x25\xe2\x37\xea\x86\xa5\xab\xef\x26\xf7\x93\x60\xe9\x99\x25\x57\xbf\xa4\xc7\xe6\x9d\x2f\x6e\x67\x53\x7c\xf7\xd1\x16\xd9\x77\x5f\x41\xbe\x53\x8c\x4c\x4e\x4b\x9c\x6f\x20\xd1\x64\xe5\xc8\xd5\xab\xd4\x04\xe9\x99\x2b\x5f\x7c\xfa\x67\xe0\xb5\x4d\xdc\x29\x3c\x21\xed\x13\xcc\x42\xc8\x56\x33\x33\xb5\x28\xe8\x8d\xf0\xbb\xb4\xa5\x65\x32\x3e\x63\x7d\xa2\xe6\xc5\x09\x8b\x17\x98\x6e\x91\x5e\xdc\xbe\xec\x53\xf1\x7c\x64\x97\xbc\x41\x7f\x5d\x59\xc0\x79\xfe\x4d\xdc\xc9\x6e\x80\xfb\x83\xe1\xfe\x60\xa5\x85\x05\xa1\x33\xc2\xdf\x67\x68\x67\xc5\xe7\xf3\x78\x1c\xe9\x7f\xab\xdd\x3e\x79\xe9\xe5\xe2\xad\xd2\xc8\xfb\xdc\x0b\xbe\x93\xd6\x47\x75\x2d\x74\xd5\xcc\xed\x57\xa8\x7d\x8b\x87\xdf\x5b\x4a\xaf\xe0\xb7\x87\xc1\xb8\xe3\x3b\x4e\x48\x84\x15\x3f\x8f\x50\x3e\x40\xff\x1e\x6f\x8e\xb0\x84\xc8\xae\x1b\x58\x98\x9c\xa8\x38\x43\xba\x58\x32\xa2\x72\x72\x32\xba\xc0\xf4\x29\x47\x24\x39\xb2\xb3\x93\x63\xb2\x16\xd6\xce\x9d\x3e\x62\xd4\xf8\xf1\x95\x95\x83\x47\x95\x4d\xba\xac\x47\x7e\xef\xe2\x20\x12\x11\x61\x12\x22\x23\x8b\xfb\xe6\x5f\x56\x36\x78\x7a\x6d\x96\x69\xa9\xcd\xb6\x6c\xc4\xf8\xa9\x53\xc7\x8f\x1f\x52\x39\x78\xf0\xcc\xc2\x1e\xb9\xb9\x4d\x33\xc7\x0d\x19\x52\xd7\xa7\x7f\xff\xf9\x75\x33\xe1\xff\xd2\x0c\x67\x58\xb7\x6e\x4b\x49\x8c\x39\x25\x28\x39\x22\x2b\x26\x25\x39\x2b\x2b\x39\x25\x46\x8c\x4d\x4f\xb0\x67\xda\x2c\x0a\x8b\x8e\x0e\x35\x88\xb1\x7c\xb1\x93\x8f\xe1\x09\x8a\xdb\x76\xec\xb6\x3d\xab\xc6\xb8\x05\x7a\x5c\xa7\x1c\xfc\x1b\x13\x98\xe2\xcb\xe4\x1c\x5b\x51\xbb\x28\x7f\xed\x1f\x75\xdb\x7c\xcf\xd5\xf2\xb5\x8f\x0c\x3a\x6c\xac\x4f\x2e\x48\x2e\x48\x94\xf8\xe1\x03\xc9\xd6\x7c\x7e\xa4\x0b\x5f\x79\x14\xf0\x8f\xb5\x61\xf5\x40\x02\xf2\x25\xf0\xfb\xc3\xf3\x53\xdb\x22\xad\x5a\x93\x0b\xf8\xf1\x73\xa9\x3c\xac\x84\x35\xdf\xc9\x5f\x20\xc4\x13\xc6\xe3\xdf\x5a\xa1\x95\xf5\xdf\x24\x34\xd1\xf7\x69\x52\xe0\x87\x58\x06\xa1\xe6\x08\x19\xe8\x79\x45\x7d\x91\x0c\xa4\xc5\x35\x35\xe7\xaf\xe6\x29\x71\xa5\xfa\xe2\x91\x9a\x5f\x06\x1e\xa9\xd1\xd2\x64\xe0\xb9\xfb\x6b\x6a\x58\x3c\x4f\xf1\xb2\x35\x47\x24\xa1\xb2\x2a\x7c\xae\xb9\x6b\x6e\x5e\xd6\xb4\x37\x6b\xd4\xb5\xeb\xd7\x3e\xf1\x57\x12\x3f\x62\x64\xf5\xac\xbb\x2b\x26\x38\x9d\x9b\x72\x6a\x6b\x7b\xf4\x7b\x45\x75\xa9\xef\xdf\x76\xcb\x2d\x7f\xbf\xf5\x96\x85\x15\x53\xa7\x4f\x9c\x3c\xb5\xb2\x42\x5c\x79\xa4\xa6\xa6\xa6\x75\x25\x19\x48\x0e\xd7\x9c\x2b\xae\x39\x22\x3a\x40\x00\x48\x90\xc3\x64\x60\xeb\xca\x1a\xe0\x78\xe4\x58\xd5\x52\xdb\xb0\x92\x81\x55\xe4\xe8\x64\xcf\xeb\x57\x5f\x75\xfa\xf2\xe5\x2c\x73\x67\xc9\x2c\x6b\xd0\x5c\x92\x7c\x59\x91\xaa\x1e\x1f\x54\xa6\x7e\x40\x06\xaa\x93\xf7\xbc\x7f\xe8\x8d\x37\x0e\x3d\x72\xe7\x3f\x36\x3e\xbe\xe1\x76\xee\xab\xa8\x45\x64\x96\xf7\x1e\x5c\x43\x85\xca\x12\x91\x4c\x41\xa2\xd8\x20\x34\x83\x5b\x0b\x33\x4d\xe8\xc7\xbb\x2b\x8b\x72\xfc\x67\xf6\xd9\x93\x7b\xf2\xb7\x73\x4a\x08\xd9\xb3\xb8\xd1\x3a\xc9\xb9\x23\xcc\x3a\x50\x2d\xaa\xad\x78\x68\xce\xc4\xc5\x80\xd5\x4b\x7c\x82\xf5\x92\xbe\x02\xdb\x4d\x73\x99\x59\x48\x50\x90\xc5\x64\x12\x85\x16\x41\xd9\x46\x82\x37\x6b\x27\xa9\x62\x0c\xfc\x1c\xbf\x5b\xea\x6f\x11\x1e\x4b\x81\xdc\x7f\xdd\x93\xf9\xeb\xba\x36\x4d\xaa\xfc\x6b\xea\xec\x8c\xf7\xc5\x27\x16\xaf\xec\x57\x3d\xae\xa6\x32\x65\xe5\x1d\x5a\xbf\xfe\x59\x8c\xa5\xb2\xb4\x0a\x64\x4d\x70\x05\xc3\x5a\x4c\x36\xc9\x41\x8c\x09\x2d\xfc\xf5\xa8\x63\x77\x91\x0e\x8b\xfb\xf3\xfd\x82\x92\x79\x7e\x49\xc5\x58\x5d\x52\xfe\x5d\x70\x9c\xf8\x3c\xcd\x94\x9d\x80\x05\x6b\x08\x58\x1f\x99\x08\xd4\x5b\x6a\x11\xf8\x58\xe1\x43\xe2\x40\xf9\x32\x7f\x0b\x59\xd8\x9f\x90\xa7\xfd\x40\xb2\xd3\x07\x44\xc8\x24\xe9\x1c\x7d\x5f\x3e\x05\x7d\x36\xcb\x15\x43\x64\x49\x52\x36\xd0\x4d\x74\x3b\x65\xb4\xe5\x65\x81\x24\x40\xcf\x2d\x86\x5e\xcb\x3f\xfa\xae\xac\x74\xec\xa9\xf4\xd7\x1c\x96\xd5\x91\x0a\x5d\xa1\x1e\x96\xf6\x3e\xc6\xa4\x73\xef\xc7\x1d\x0d\x43\xb9\xcc\x80\x77\xcc\x87\x27\x30\x99\x5d\x22\x5e\x61\x6a\xbe\x22\x11\x33\x23\xd2\x5e\x49\xbd\x57\x3a\x17\x76\x34\xee\x7d\xae\xb3\x1d\xd2\x39\x36\x55\x56\xf1\x2c\xa6\x58\x59\x04\xe7\x21\x88\x6d\x30\x6c\x32\x50\x18\x4f\x5f\x26\x78\xca\x67\x31\xa9\x22\x22\xc1\x23\x49\x01\xb1\x6d\xfd\x04\x2b\x9e\xf4\x64\x29\x19\x90\xd9\x54\xb1\xea\x65\xaa\x7a\x16\x8a\x24\x6a\xb7\x1c\x12\x76\xe3\x8d\x61\xa7\x00\xfb\x34\x60\xdf\xe8\xc3\xa6\xb2\xc9\x60\x08\x52\x36\xb0\x4d\x8c\xb2\xdf\xc6\x4e\x4e\x07\x05\xf0\x25\x1e\x5d\xb6\xfb\x79\xb1\x72\x0f\xfd\xb1\x49\x94\xce\x9d\x0c\xbf\xf1\xc6\x70\x5c\x53\xfd\x04\xd8\x43\xe4\x27\xf5\xf5\x99\x45\x94\x05\x46\x61\x51\x45\x5a\xf8\x01\xa5\x7c\x59\xe5\x43\xc3\x35\x37\xe0\x24\x72\xac\xa5\xc9\x8f\x25\x7b\x0e\x24\x6f\x4a\x96\xce\x6d\x83\x7f\x20\xe3\x63\x80\xb3\x51\x91\x61\x2c\xed\xe9\x4a\x30\x18\x8d\x3c\x42\x6d\x74\x98\x94\x10\x4c\x9e\x08\x7e\x39\x78\x5f\x30\xb3\x04\x27\x04\xe7\x04\xb3\x60\x1b\x7e\xd2\x9d\xb7\xa7\xb2\x72\xa1\x2f\x2a\xa6\x36\x85\x25\x75\xa3\xfe\x09\x20\x9e\xe6\xe7\xf1\xa1\x9c\x6e\xea\x3a\x7c\x50\x71\x42\xb7\xfe\xd1\x35\x39\xcb\xc7\x66\x0d\x2f\xe9\x1f\x3f\xa5\xcb\xac\x64\xd7\x64\xe9\x5c\x46\xf7\x8c\x3e\x83\xef\x68\x82\x5f\xab\xe6\xd5\xf6\xd6\x9e\x6f\x83\x0c\x57\xc9\xa7\xf1\x1c\x8f\x5c\x57\x1c\x83\xba\x98\x8d\xc6\x60\x83\xbf\x65\xe5\x76\xed\x9a\xe7\x08\xac\x9b\x9d\x87\x36\x93\xf2\x91\x2e\x64\x1f\x43\xeb\x3e\xe9\x61\x47\xf8\x2f\x68\xe4\x63\x71\x1f\xf0\x1f\xa8\xe7\xd5\xd2\x29\x16\x23\x7f\x05\xf3\x57\x86\x2b\x4c\x64\x2c\xd8\x68\x32\x85\x98\x78\x6b\x6c\x67\x8c\xc1\x74\x06\x95\xf3\xe1\xfa\x6b\x96\x96\x9e\x8f\xc7\xe5\xe6\x43\x3f\xd9\xb8\xfa\x9f\xb4\x89\xcd\x1e\xbb\xc5\xb5\xb8\xc7\x76\xe9\xd4\x5f\x1a\xfa\xf4\x6c\xbc\xa2\x05\xd7\xea\x9f\xc8\xeb\x84\x4a\xa5\x1f\x7f\xba\xf2\x24\xc5\x2e\xb2\x87\x8f\x05\xe9\xf9\x95\x57\x9f\x3f\x2a\xaf\xdb\xc8\xe7\xea\x01\xf2\x3a\x75\xa3\x92\x8e\x65\xf4\xb5\x3c\xb6\x72\xbe\xba\xf1\xea\xcf\xa1\xd0\xad\x50\xe6\x19\x39\xc8\xab\x28\xf1\xed\x71\x08\xcb\xb7\xab\x57\xec\xf8\xb0\x49\x0e\x22\x76\xf5\x5b\xce\x6f\xb8\xbc\xc6\x7b\x56\xe9\x8f\xe5\x84\x16\xaa\x95\x63\xf9\x52\xf2\x99\xcf\xd5\x0f\xae\x56\xfa\x6f\x16\x48\xeb\x1b\xf2\x1a\x75\x61\xc7\x32\x04\xca\x78\xfe\xe2\x2b\x84\x3e\x44\x3f\xe0\x99\xac\x24\x77\x2c\x47\x92\xd5\xbc\xd3\xea\x23\x37\x2b\xc9\xea\x17\x58\x47\x87\x5c\xe7\xdd\xa0\x14\xc2\x2c\x1c\xfa\x74\x90\x85\x32\xa5\xc5\xcc\x87\x02\xde\x02\xac\x47\x72\x12\x9e\xb3\x8f\x01\x96\x0b\xf3\xf3\x5a\x67\x16\x8c\xa5\x23\x1a\x77\x6e\x93\x2b\x83\x43\x6a\xe5\x7d\xa9\x96\x01\xa1\xe3\x46\x07\x25\x14\x03\xbf\x31\xd2\x17\xea\xb7\x4a\x99\x60\x13\x42\x9f\xb2\x98\xa9\xdc\x12\xac\x07\x45\xe0\xf1\xd5\x93\x11\x86\x7f\xf1\xc4\x81\xfa\x53\xb5\x64\x5d\x95\x29\xbb\x76\xd9\xf5\xf3\x67\x05\x2d\x88\x76\xf6\x2a\x90\x1f\x2e\x92\x67\x19\x87\x0f\x28\x19\x6b\xce\x5b\xc6\x82\x9c\x58\x87\x56\xb7\x5c\xa7\x06\x77\x2e\x1b\xe9\x28\x9b\xa7\x71\x66\xcf\x31\x9d\x0b\x87\xf5\xcc\x95\x87\x0a\xbf\x28\xb9\x42\xb8\x10\xed\x32\xd9\x4d\x26\x16\xdc\x12\x1e\x6e\x08\xc6\x67\x96\x8e\xd0\x3d\x79\x39\x79\xfa\x0b\x40\xed\x20\xe5\x7c\x8c\x4f\x8e\x31\x6e\xd4\xdc\xb0\x95\x13\xfb\x17\xba\x7a\x46\x17\xc7\x5c\x9d\xbd\x25\x69\x60\xdf\x84\xcc\x98\x11\x56\x79\x68\xc3\xe2\xb8\xe4\xb0\x89\xc7\x23\x92\xac\xf6\x2a\xce\xe3\xfc\xc7\xf2\x20\xf5\x21\x25\xeb\x0f\xf0\x38\xff\x71\xe7\x3c\x06\x75\xe4\xe1\x5d\x2f\xed\xa4\x3d\xe4\x97\xc0\xde\x43\x9f\x62\xe8\xaf\xa1\x81\xe7\xe5\xf0\xe3\xb9\x03\xec\x7a\x47\x3b\xb3\xde\xd9\x66\xd6\x80\xf1\xa1\x74\x9a\xc6\xc9\x5b\x60\xfc\x0a\xd9\x2a\x1a\x5b\x64\xfd\x01\x92\x3e\xf2\x29\xc9\xd0\xe7\x68\x9c\xb8\x60\x3d\x7d\xd8\x2d\x7e\xf6\x80\x2c\x85\x8d\x1d\x1b\xf6\x38\xdc\x47\xd4\x37\xbc\x1f\x78\x17\x83\x4d\x19\x36\x0b\x7c\x5b\x8d\xf6\x74\xd6\x9b\xba\x35\x55\x7d\xe3\xd1\x47\x51\xcf\xeb\xc5\x8d\xc2\x50\xe9\x55\xb4\x3b\xfe\x34\x46\xb7\x61\x92\xfc\xd0\x29\xf5\xd8\xcd\xd2\xab\x68\x76\xe8\x77\x3e\xe4\x9d\x24\x3d\xd7\xa1\x4f\xd8\xf3\xe1\xca\x0b\xc7\xd5\x1f\xc5\x87\xb0\x53\x10\xf5\x4d\xf1\x21\xc1\xd1\xb1\x5c\x10\xc9\xb7\x2f\x82\xae\xa3\x97\xe2\xb6\xf2\xa0\xb8\x51\x8d\xd7\xf9\x06\xf4\x43\x96\xaf\xc6\xdf\xfc\xf9\x69\x71\x23\x89\xc2\xf5\x8c\xcf\xde\x6d\xb2\x11\x9f\x79\xf8\xec\x16\xfe\x36\x63\x1b\xbe\x21\x0f\x55\x6f\x41\x3b\xb1\x3d\x6d\x37\xb1\x16\xad\xfd\xfe\xed\xf8\xe8\xdf\xf9\x17\x6d\xbc\x37\x2e\xc9\x40\xc8\xb9\x1f\xe4\xa1\x9e\x97\x7e\x1f\xf6\xb9\x1f\x2e\x11\xfb\x09\xc0\x5e\xfe\x3b\xb1\x9f\xb8\x34\xec\xd6\x45\xe2\x0e\x6f\x5f\x69\xe3\xef\xc1\x6e\x5d\xd4\x29\xb6\xb8\xa3\x03\xf6\xf9\x47\xc4\x1d\x6a\xd3\xef\xc3\x3e\xff\xc8\x25\x62\xcf\x05\xec\x1e\xbf\x13\x7b\xee\xa5\x60\xc3\xb2\xd8\xa6\xbe\xd1\xfa\xb5\x77\xb1\x4d\x31\xda\x3c\x56\xed\x19\xc8\xf9\x7b\x20\x6f\xa9\x96\xd7\x7a\xb7\x96\x77\x4e\x55\xdf\x38\xff\xae\x96\x77\xde\xa3\x97\x3b\x0a\xe5\x9e\xd7\xcb\x7d\xaa\x97\x7b\x16\xca\xdd\xa2\x97\xdb\x26\x68\x7e\x5f\x81\xb8\x99\xe5\x49\x2f\x0a\x11\x7c\xf7\x84\xc1\x1e\x69\x8f\xb2\x49\x41\x2d\xa1\xd8\xe5\x79\x9f\xcf\x6b\xf3\x27\xf9\x5c\xdd\x61\xaa\x2e\x84\xa9\xda\x95\x50\xd3\x75\x32\xce\xd4\x83\xfa\xc7\xd7\x66\x4c\x85\x99\x5a\xdc\x9c\x9a\x9d\xba\xf4\x8e\x26\x4e\xf9\x44\x0d\x75\x69\x51\xdf\xf0\x54\xe8\x75\x69\xd6\xe4\xf1\xdc\xae\xbe\xa1\x2e\xd0\xf2\xd4\xbf\xeb\x79\x1f\x41\xde\xd3\x7a\xde\x87\x5a\x5e\xab\x19\xea\xf2\x99\x7e\x6f\x90\x9e\xb7\x06\xf0\x66\xe9\x79\x37\xe9\x79\xcb\x21\x6f\x8c\x9e\xb7\x4c\xd7\xc3\x66\xb8\xf7\x2f\xba\x1e\x9e\xd0\xcb\xf5\x84\x72\x16\xbd\x5c\x81\x5e\x6e\x04\x94\x4b\xd3\xcb\x0d\xd7\x74\xd3\x6a\x92\xaf\x52\x5f\x57\x86\x80\x6e\x6c\x4f\x87\x05\xb1\x96\x08\x63\x48\x87\xb6\x8d\xb8\xd0\x28\x4d\x61\x57\x8d\x4f\xec\x96\x5c\x92\x17\xd5\x2f\xa6\x25\x7b\x53\x97\x92\xbc\xf8\x4c\xc7\x08\x8b\x7c\x55\x4d\x8d\x29\xd4\x69\x19\xbe\x2b\x2a\x3a\xc4\x3a\x16\xf1\xed\x30\x0e\x7c\xf8\xfb\xfa\x53\xab\xfd\xd2\xfa\xd3\xf9\xdb\x41\xf6\x71\xbf\x53\xf6\xf3\xb7\x5f\xb2\xec\xe7\xef\x00\xd9\x67\xfc\xce\x31\xec\x8e\x4b\x93\x5d\x80\xe5\x0c\x39\x22\xf6\xd6\xce\x20\xa3\xa2\x44\x2c\xfc\x9b\x88\x62\x7d\x53\x14\xff\x80\xb1\x62\xff\xd6\x03\xfc\x65\x2d\x6f\x27\xe6\xbd\x56\x7a\x92\x1a\x95\x4c\xfd\xdc\xa2\xfe\xae\x70\x89\x18\xe0\xbf\x33\x28\x37\x88\xba\x82\x46\x05\x7d\x12\x74\x2a\x48\x0c\xe2\x21\x15\x32\xba\x97\xf2\xdf\x2e\x63\x7c\x62\x69\x10\x2c\xc5\xf8\x96\xa5\xc6\x3c\x1e\x3e\x61\xa1\xb6\x90\x6e\xf3\x77\x53\x79\xfc\xe3\x82\x94\xfb\x53\x3c\x8f\x02\x21\x6f\x78\x3e\x8c\xa6\x29\xd2\x93\xdc\xf5\x3d\xd7\xec\xe3\xfb\x30\x8d\x02\xbe\xda\x33\x85\x49\xae\x14\xb3\xd9\xb0\x80\xb5\xf0\x2d\x8c\xcc\x20\x07\x07\xe7\xc8\x0d\x32\x95\x43\x05\xa7\x90\x2b\x3c\x21\x88\x9f\x08\xa7\x60\x46\xd3\xc5\xc0\xc8\x0e\x21\x20\xc6\x06\x81\xe4\x0a\x2e\x81\x47\x10\xe0\xae\x3c\x17\x25\xa7\x31\x3f\x07\x17\xf6\x95\xb0\x94\xe7\x1e\x95\x02\x2b\x85\x48\x5d\x2e\xd2\xf3\x28\x55\x3f\x58\x45\x5e\xf3\x89\xa6\x64\x9a\x1f\x31\xbd\x83\x2e\x39\xc8\x74\x35\xc8\xd4\x05\x64\x32\xf0\xd9\x9b\xc7\xe5\x31\x28\x8c\x2f\x17\x43\x73\xcc\x0d\x66\xba\xd6\x4c\xcc\x8a\x5f\x20\x8d\x2f\x17\x4b\xd2\xc4\xca\xd1\x02\x4f\x80\x54\x18\xee\x06\xbc\xf5\x9c\x85\x8d\xf9\x45\xdc\xb7\xc0\x21\x20\xdf\xa2\xad\x2d\xec\x3e\x59\xfe\xba\x9e\x9e\x7e\xf5\x09\xba\xfe\x9a\xf2\x36\x69\x4c\x8f\x3d\x62\x9e\xa1\x7e\x8c\x02\x31\xef\x0a\xe9\x61\xf2\x43\x3b\x1d\x19\x16\x60\x10\x00\x58\x25\x49\x26\xa3\x31\xc7\xd4\x60\xa2\xa6\x50\xc9\x29\xe5\x4a\x4f\x48\xe2\x27\xd2\x29\x89\x4a\xba\x8e\x24\xbf\x8e\x24\x92\x2b\xb9\xa4\x51\x12\x93\xda\xe9\xc8\xa6\x2b\x49\xf3\x2a\x0a\xf3\x7d\x6d\x47\x0a\xc9\xaa\xe3\xf4\xa8\xba\x8b\xb7\x5c\x08\x10\x79\xa5\xe9\x11\xb3\xba\x02\x65\xa2\xde\xb7\xa4\x17\xa8\x41\xb7\x97\xb2\xa7\xf6\xd1\x4f\x40\x1c\xce\x32\x2e\xb1\x94\xff\x76\xc5\x85\xda\x4b\x45\x2a\x52\xe6\x54\x72\x95\xe9\xca\x02\xa5\x45\x91\x5c\xca\x28\xe5\x13\xe5\x94\x22\x2a\x3c\x56\x07\x08\xa7\xe0\x3b\xca\xca\x85\xda\x9e\xad\xcc\x85\x5a\x48\x20\x1e\x35\x7b\x52\xca\x7d\x29\x3f\x68\xe6\xf2\xc2\xb6\x6d\xa7\x9a\xf1\x1d\xf2\x59\x69\x07\xbd\x0d\x79\xc6\x41\xab\x14\x44\x47\x18\x45\xab\x95\x8a\x66\xf3\x76\x11\x16\x71\xa1\xd4\x49\x79\x84\x86\xe9\xa0\x1a\xd9\x49\x73\x29\xd7\xd1\x29\x2a\x9d\xa2\x84\x2f\x64\xf0\x1a\xa5\xbc\xee\x95\xd0\x20\x7a\xdd\xf9\xb6\x05\xfd\x55\x07\xf3\x2f\xa4\xa8\x36\x3a\xe3\x43\x31\xba\xd0\xf3\x61\x14\x4d\x79\x3f\xb9\xb8\x6f\xaf\x98\xec\xfc\xd0\x29\xb1\xbd\xc6\xf5\x4f\x19\xd0\xa7\xa7\x23\x37\x2f\x78\x6a\x5c\xe1\x58\xf9\xd1\x66\xf5\x8e\xc8\xb8\xc8\xe4\x8c\xb1\x43\x32\xe0\x77\x5a\xea\xd8\xd2\x74\x6d\x5e\xb8\x17\x8c\xe9\x19\x7c\x1e\xd0\xdd\x15\xaa\x10\xc2\x0f\x31\x0e\x32\x30\x45\x21\x12\x3f\x43\xd2\xbe\xb5\x42\x62\xc4\xd6\xf6\xe9\x74\x71\xc0\x46\xbb\xc4\x64\x2b\x3e\x21\xb2\xe6\xb3\x67\xdc\xea\x03\xea\x1e\x52\x4b\xba\xba\xd9\xdd\x64\xaa\x5b\x7d\x87\x74\xed\x1c\x5f\x10\x83\x4c\x7f\x08\xff\x6f\xea\xa7\x88\x4f\x0f\xd1\x14\xb7\x3a\x88\x3c\xff\x27\xe3\x5f\xa7\x7e\x4d\x1a\x88\xd3\x4d\x36\xb0\xc9\x6e\xcf\x64\xfe\x4c\x3d\x00\xdf\x20\x64\xbb\x42\x78\xe0\x0b\x93\x51\x61\xb2\x4c\x44\x7e\x74\x2a\xa0\x8b\x9d\xa2\x73\xec\x00\xe8\x66\xf5\x7b\x84\x16\x7f\x71\xb7\x96\xb0\x17\x38\xee\x08\x3f\x6e\xaa\xcb\xca\xa5\x36\x19\xa9\xc2\x8f\x26\x27\xba\xbc\xfc\xc9\x9e\xff\x40\x78\x94\xd5\x48\x0a\xf9\xf7\x79\x80\xb7\x4d\x9d\x35\x15\xc6\xde\x52\xb7\xf8\xba\xba\x9b\xac\x9e\xa1\x1e\x24\x3d\x00\x73\x8c\x5f\x17\x39\x7c\xd7\xba\xaf\x2d\xf9\x99\xc0\xf6\x67\x2a\xda\x41\xe3\x19\xcb\xed\x34\x91\x08\x9d\x29\x51\x13\xf7\x56\x75\xed\x4c\x32\x84\xf4\x70\xb3\x87\x48\xc3\x0c\x75\x1b\x19\xa3\xd9\x8a\x4f\x66\x45\x48\x77\xd9\xf8\x99\xaa\xe0\xbc\x1b\x65\x46\x25\x89\x88\x01\x42\x77\xd0\x70\xa1\xa6\x04\x4f\x7c\x15\xbd\xc6\x4d\xcb\xe8\xee\x69\x9e\xf5\xb4\x31\x10\xcf\xc8\xf1\xda\xda\x8e\xf2\xc6\xbb\x18\x5e\x01\x68\x81\xd8\xad\x3e\x35\x8c\x25\x5b\x3e\x74\x7f\x43\xff\x45\x56\xcf\x55\xeb\xd4\x1c\x56\xcf\x71\x07\xfb\x75\x9b\xe2\x0a\xd5\xda\x8c\xb7\x98\xa2\xe8\x52\x6a\xbd\x2a\x40\xb5\x01\x98\x0f\xa9\x0b\x26\x93\xc7\x3f\x75\xb3\x7f\x92\x2b\x66\xa9\x73\x3c\x77\xb1\x73\x82\x8e\x49\x17\x04\xd6\x5d\x60\x46\xc3\x25\xd5\x9d\x2e\x70\xab\xd3\x26\x43\x63\x41\xc7\x68\xa9\x51\xdf\x23\x19\xe8\x8f\xfd\x37\xed\xbf\x55\x1d\x33\x17\x1a\x08\xda\x7f\xb9\xe7\x1d\x7a\x7c\xa4\xe7\x08\x4d\x0c\xc0\xe4\x7d\x21\xb2\x4d\x9f\x4c\x06\x8d\x4a\xed\x90\xb5\x87\xc2\x1d\xa4\x45\x7c\x6b\x1b\x83\x19\xa4\x1b\xa8\x41\xdd\x4c\x8f\x0f\xf3\x6c\x21\xd9\xc4\xc9\xe5\x2e\xf7\xf3\xc8\x76\x99\x7c\x3c\xd0\xc2\x5c\x46\x6e\x62\x06\x9d\x89\xef\xdb\xdc\xce\x2d\xec\x61\x75\x59\x13\xa9\x21\x06\x37\x5d\x4f\xef\x29\xf5\xdc\x47\xa7\x71\xec\x6c\x3f\x76\x9a\xcb\xea\xc3\xe6\xd6\x10\x08\x9a\x7f\x81\xd0\x24\x52\x03\xbd\x47\x9d\xbe\x84\xdc\xfa\xb3\x9b\x84\x90\x6a\xfa\xe6\x60\xcf\xe0\x5f\xd8\x16\x6c\xbb\x52\x1d\x57\xe6\x51\x17\x44\x68\x48\x83\x22\x8a\xa0\x8d\x36\xd0\xc0\x6e\xeb\xb3\xd7\xe8\xa5\xd0\x72\x52\xbf\x92\xf3\x77\x8a\xb3\x35\xfb\xcf\xf6\xdb\x00\xc8\xe7\xb3\x01\x6e\x01\xb2\x78\x51\xf9\xfc\x26\x30\x68\x11\xb4\x17\x9d\x40\x8f\x95\x62\x6b\x71\xbc\x94\xff\x6e\x0c\xe8\x77\x95\x66\x03\xd1\xad\x1f\x89\x15\x79\xad\x1f\xb1\x64\xc0\x4c\xf5\xeb\x30\xd7\x15\xe1\x1b\x03\xfc\x16\x10\xa8\x48\x5f\x4c\xba\x0b\x4c\xa0\x00\xf1\x5f\x55\x7b\xac\x24\x93\xf8\x20\xb0\xc1\xb3\x5a\xcc\x28\x68\xfd\x82\xce\x7a\x52\xd3\xc3\x05\x3c\x78\x3b\xfd\x3e\x1e\x5a\x8b\x6d\x51\x07\x5e\x49\x16\x91\x58\xd0\x8b\xba\x59\x2c\xcd\x6b\x5d\x41\x6c\x74\x21\xf2\x48\xff\x53\xec\xec\x36\xb5\x7a\x39\xb9\x86\x98\xdd\x64\x34\x53\xf3\x5a\x27\xb1\x87\x39\x76\x8e\x5f\xef\xf8\xa5\x09\x13\x8c\x26\x85\x1f\x52\x61\xc3\x63\x7e\x3b\x8c\x0b\x91\xbe\xb1\xa6\xb4\x99\x3c\x76\xd0\x4d\x86\x88\xac\xb0\x35\xec\x1d\xf1\x55\xbf\x2e\xda\xdb\x04\x1f\x13\x7f\xdd\x26\x0a\xfc\x36\xd1\xef\x4a\x68\xbf\x33\xe2\x54\xad\xf1\x10\x2f\xce\x2f\x5b\x92\xcb\xc2\x5b\xcf\x68\x92\x29\x53\xa0\xb6\x4c\x13\xaf\x6d\xcb\xe8\x05\x06\xd1\x73\x05\x19\xc1\xc7\x99\x77\x5b\xbb\x48\xa3\x73\x5b\xbb\xb0\x77\x35\xcc\x48\xbf\x2e\xbb\xba\xec\x3e\x9b\x00\x8f\x15\xfc\xd7\x76\xb8\x39\x39\x17\xb5\x86\x6d\x6a\xee\x4a\x52\x41\x06\xb8\xd9\xe2\xd6\x1b\xa5\xf2\x9c\xd6\x48\x76\x79\x0b\xc7\xee\xf9\xdf\x60\xfb\x54\x5b\xde\x4c\x46\x92\x2c\x37\x5d\xeb\x59\x28\x8d\xcd\x3e\x7f\x8c\xce\x23\x9b\x3b\xc3\x46\x1b\xb8\x24\x6c\x92\xea\xc7\x5e\x49\x9a\x88\xe2\x26\xbd\xd4\x5d\x1c\xfb\xca\x73\xec\x26\x2e\x77\xae\x7f\x2e\x8b\x77\x85\x48\x02\x3f\x0d\x85\x8f\xe7\x4c\xe4\x8d\xb6\xa7\x38\xdf\xbf\xdb\xb2\x0b\xe1\x9f\xc9\x72\x34\x35\x53\x1d\xb9\x8a\xac\xfb\xda\x2d\x8d\xed\x76\x5e\x11\x7f\x41\xdd\x76\xd1\xdb\xff\xd2\xc7\x16\xde\xf0\x03\x56\x91\xfe\x1c\xa6\xad\x8d\xca\xfd\xf2\x64\xb9\x42\xf8\x67\x8b\x12\xe3\x1b\x74\x89\x2c\x6b\x7e\x86\xdc\xce\xcf\xf0\x4b\x87\xe6\x9e\x4e\x12\x79\x5d\x77\xab\x4f\xcd\x80\xba\x9e\x15\x7f\x51\xb7\xcd\x20\x0d\x1a\xee\xf0\x80\xbe\x8a\x73\x02\xff\xc2\x8f\x8f\xaa\x22\xfc\x27\xdc\x39\xd0\x04\xd5\xf5\x18\xb8\x2f\x16\x35\x99\xee\x6b\xa5\x67\xd4\x57\xa6\x90\xf5\xdc\xbc\x6e\x21\x05\xea\xe1\x59\x64\x39\xb8\x1e\x3d\x3a\xf0\xe8\xa6\x8d\x07\x01\x3c\x2e\x60\x71\x71\x0e\x77\xa8\x1f\x8c\x47\x0e\xb4\x0b\x5d\xa5\xfe\x58\x47\x96\x7b\x5e\xa1\xc5\xed\xf0\xb3\x5c\xe1\x68\x07\x4c\x62\xa6\xa0\x4e\xe1\xdb\xa1\x17\x10\xc9\x8f\x7e\xad\xfa\xcd\x58\x44\xff\x92\x3d\xc6\xb1\x5b\x0f\xb0\x6c\xc0\x9e\xe6\xef\x6f\x19\x2e\xbb\x2c\x88\x14\xbd\x05\x0e\xaa\x50\xa9\x33\x64\x6c\xc7\x36\xd8\x35\xea\x99\xd1\x00\xdb\xd3\x2d\xde\xf0\x39\xe8\xa4\xb5\x1f\xdb\xe1\xd3\x49\x9b\x5d\xf0\x5e\xa1\xc0\x44\x4c\xa8\xd4\xa9\x5d\x58\xa1\x09\xd1\x2e\x5e\x9d\x46\xee\x72\x8b\xaf\xaa\x1f\xd5\x93\xe5\x42\x07\xff\x33\xe3\x19\x6d\x38\x40\xb7\x16\x06\x41\x18\x63\x60\xb6\xb8\x60\x10\x44\x3c\x85\xfb\x9e\x5c\x3e\xaf\xba\x80\x8c\x23\x7d\xdc\xe2\xce\x4f\xdd\x24\xa2\x9d\xbf\xdc\x43\xf3\x11\xb5\x39\x56\x03\x35\x55\x28\x92\x02\x8b\x6a\xdf\xec\xc3\x57\x3c\xda\xd6\xc8\xce\x5d\xe6\xf5\xe0\xe6\x73\x2f\x81\xd6\x93\x2b\x40\x78\x3a\xae\xe3\x9a\x22\x47\x1b\xbb\xf9\x98\xf0\x2b\x1c\x2e\x06\x7f\x8f\x7a\x80\x34\x93\x50\x37\x29\xa0\x8f\xbb\x3d\xdf\xb3\x94\x76\xfa\xe8\xfa\x8c\x36\x74\xa3\x23\x0e\xc0\xb2\x28\x8b\x44\xe9\x04\xd8\xe7\x8c\xeb\x1e\xde\x63\xea\x4e\x72\xcf\x69\x37\x3b\xe6\xf6\x14\xf3\xde\x47\x60\x6d\x1c\x60\x03\xbc\xef\x89\xcc\x08\xf3\x99\x24\xb7\xd3\x70\x80\xed\x76\x18\x79\x9f\x55\xeb\xa6\x93\x78\x32\xc3\x2d\x2e\xf3\x1c\x22\xff\x9c\xa9\x1e\xa6\x13\xda\xf7\x8b\x9e\x2e\x07\xea\x81\x87\xfb\xd5\x67\x4a\x03\xe2\x07\x2a\xc2\x1f\x25\xb6\x7d\xff\x08\x18\x27\x6b\xa7\x93\x3e\xbc\x07\x3e\xa1\x3e\x4b\xee\x9a\xae\xbe\x06\xf3\x7f\x68\x80\xbf\xeb\xd7\x77\xdb\x5c\x09\x6a\xe9\xc8\xe6\xe2\xb3\xe5\x2c\x75\xf3\x4c\xd2\x95\x54\x82\x57\x46\x96\x4c\x55\x9f\xa6\xd3\xda\x8f\x21\x0a\xc6\x13\xf7\xfb\x3d\xa2\x04\xc3\x53\x00\x70\x67\x9e\x0f\x77\xa4\xe2\xa6\xd1\xd5\x6e\x92\x4e\x8f\x57\x7b\xae\x64\x77\x04\xe0\xe1\x1c\xa7\xfb\xe7\x1d\x1b\xaf\x73\xef\x1c\x54\x30\x85\x3c\xf1\x9e\x9b\x2e\x22\xff\xa8\x56\xc7\xaa\xd5\xe2\x94\x80\xbe\xe6\x97\x4f\x9b\x83\x2f\x45\x3e\xde\xe9\x6a\x2a\x49\xb1\x9b\xd6\x90\xbb\x6a\xd5\x57\xe8\x94\x76\xfe\x01\xda\x03\x6f\x35\x93\xf1\x77\xd9\xc3\x90\xc5\x80\x3e\xce\x2d\xc6\xb5\x7e\xc6\x66\x0c\xf6\xdc\xc9\x8a\xb9\x1e\x8b\x3a\xda\x03\xb7\x34\x9f\x77\xf6\x7b\xec\xc1\x37\x27\x8f\x59\x42\x7a\xe1\xc2\xc2\xb3\x90\x0d\x19\xe2\xf9\x27\x5d\x8b\x67\xf5\x17\x07\xf4\xf1\xe8\x8e\x7c\x2e\x60\xf3\x1b\x56\xf7\xaa\x3a\x72\x29\xa9\xe4\x3e\xda\x22\xf5\x01\x36\xa9\x9f\x67\x3c\xe9\x45\x4b\x85\xf6\x7c\xba\xeb\x63\x09\xe3\x7c\x7e\xd5\xf2\x22\x3b\xb5\xbc\xfb\xd5\x79\x4b\x61\x85\x6c\x72\x93\x09\x2c\xba\x9f\x27\x8f\xdd\x1f\x88\x6f\xe0\x63\xa8\x66\x27\x22\xb7\x12\xdd\x53\xbb\x70\x0d\x17\xe9\x5b\xbd\x4c\x5d\x4a\xfe\x71\x04\xc6\x0d\xd6\xbb\x5f\xeb\xc7\x6f\xf9\x7c\xb5\xe2\xce\xfc\xf7\x0b\xcc\xe4\x22\x56\x32\x71\x29\xc9\x73\x93\x6c\x76\x59\x3f\xcf\x46\x96\x29\x04\xfa\x3e\x06\xc0\xb3\xf9\xc6\x0d\x19\x9c\x3f\xa6\xf8\xdc\x13\x7e\xb8\x41\x51\xe7\x56\x02\xae\xc9\x0a\xd2\xc3\xe7\xaf\x19\x73\x5b\x17\xfa\x7c\x81\x82\x8e\xf3\xa9\xd6\x7e\x54\x91\x15\xfe\xad\x7f\x7b\xec\x5f\xb3\x8f\x91\x2b\x48\x5f\x9f\xcf\x66\xec\xde\x3a\xe5\x02\x9f\x4d\xc7\xd7\xc6\xa5\x4b\xc7\xef\xcc\x6f\x0b\xca\x6e\xcd\xbc\xc0\x6f\xeb\x80\xaf\xc1\xcb\x1a\xbe\xc6\xa0\x13\xfc\xce\x7d\x37\x53\xf6\xf9\x9d\xba\xef\xd6\xd3\x3f\x1e\x75\x75\x59\x7c\xbe\x1b\xcc\xae\xd0\x8a\x7c\x92\x79\xd2\xb7\x47\x54\xb7\x90\x0b\xfc\xb8\x5c\x0e\xbc\xfe\x13\x37\xc7\x1c\xad\xfb\x71\x05\x9d\xf8\x71\x00\xd9\xb6\x10\x2b\xea\xcc\x8f\x1b\xd1\x0c\x0b\x24\x80\x69\xbd\x82\xed\xeb\x38\x56\xfe\x61\x3f\xee\x53\xf5\x91\x06\xb2\x94\xfb\x71\x9e\x1d\xc3\xe8\x15\x17\xf1\xe3\x34\x1f\xe8\xf7\xfb\x71\xfb\xd5\xe7\x1a\x7c\x7e\x5c\xbc\x6a\x06\x06\x9d\xf8\x71\xff\x25\x8f\xcd\xea\xe1\x06\x9f\x27\x37\x56\x75\x01\x0f\xf4\xe4\x3a\xf5\x15\x03\x78\xfc\x86\xaf\x58\x10\xc0\x61\xbd\x7a\xba\x41\xf7\xe6\x16\xab\xd3\x80\x01\xba\x73\xed\xe6\x16\xe8\xe3\x32\xae\xa9\x2f\xe6\xcd\xb5\x8d\x1c\x7e\xd8\x7b\xd4\xef\x1a\xc8\x63\xdc\x9b\x1b\xa3\xce\xe1\xa8\x9a\x3b\x07\xb8\x75\xed\xfd\x39\x41\xe4\xcf\xdb\x7f\xd3\x9f\x3b\xd9\x40\x5a\xdc\xe2\x4a\xb5\xef\x88\x8e\xed\x78\xe9\x7e\x21\x9f\x42\xe7\x8e\xa4\xc7\xdc\xe2\x5e\xcf\xbe\x3a\x1f\xce\xe0\x0b\xc7\x5e\x29\x60\xec\x85\xe9\x54\xfe\xf5\xb1\x37\xdd\x37\xf6\xbe\xa4\x3e\x3f\x93\xcc\x21\xcd\xe0\x11\xa9\x77\x4c\x25\xb7\x82\x9b\xd8\xae\x9d\x7a\xe8\x73\x95\xde\x4e\x4c\x16\x15\x59\xe6\x8f\xd2\x7c\xf0\xfa\xe9\x21\x97\xb2\x76\xa0\xab\xfc\x6b\x07\x3a\x48\xf8\x0d\x3e\x8a\x28\x03\xaf\xdf\xc3\xc7\xbf\x82\x20\xd1\xfe\x15\x04\x2b\x17\xda\xdb\x45\x57\x57\x18\xd8\x05\xe5\x63\x35\x95\x64\xe0\x26\xb5\x73\x3c\xda\x46\x24\xec\xe9\xcc\x0f\x5e\xff\xd9\x6c\xb2\x88\x2c\x70\xc3\x00\x72\x7c\x2a\x79\xb5\xf5\x01\x31\xa5\x9d\xef\x01\x6b\x54\x9c\x53\x44\x7c\x26\x24\x6b\xe3\x51\xe0\xf3\xb6\xf6\xf3\x4a\x3a\x8c\xd2\xdc\x44\x5e\xa9\x04\x97\x9f\xbd\xa1\xbe\x52\x4b\xee\xfa\xf1\xbf\xf1\xf9\x99\xcf\xe7\xff\x5c\x9d\x44\x26\x90\x22\xb7\x38\x59\x1d\xe0\xf6\xf9\x70\x6d\x3e\x79\x7e\x9b\x8f\xa8\xc1\x9a\x2b\x60\x64\x36\x48\x01\x73\x35\xca\xdb\xc1\x4f\x54\xfc\x7e\xf9\xf7\x6a\x35\x99\x45\xba\xb8\xd9\x9d\xaa\x9b\xf4\x26\x29\x1d\xf0\xff\x84\x75\xc5\xdd\xea\x41\x52\x0d\x13\x0b\x49\x21\x4b\xdd\xea\x6b\xec\xce\x8e\x7a\xf9\xdd\xbe\x3f\xf1\x3d\x77\x7c\x83\xdc\x40\x64\x70\x70\xdd\xaa\x28\x4e\x06\xcc\x09\x7f\xd4\xf7\x97\xb4\x59\xfc\x65\x75\x76\x15\x31\x92\x85\x6e\x31\xc5\x63\x25\x37\x4e\x53\xd9\x0c\x94\x75\xe2\x9f\xed\xeb\x2d\x98\x46\x6c\xa4\xce\xcd\x5a\x3c\x2f\x92\x6b\xa6\xa9\x3f\xd3\x2b\x4e\xeb\xef\x50\xff\xdc\x35\x46\xe3\x14\x70\x4a\x86\xb8\xe9\xe5\x30\x2d\x5c\x3d\x4b\x3d\x44\xf2\xe8\xe4\x76\xf5\xf9\xef\xd6\x18\x77\xa8\x7f\x9b\x49\x86\x91\x4c\xf0\xf4\xc8\xe5\x53\xd5\x97\xb9\xa7\x27\x04\xb4\x83\x3e\xff\x52\x6d\x5c\x94\xb4\xe7\x31\x1d\x7d\x3d\xff\xd2\x22\xbd\x8a\x5e\xe1\xa6\x2f\x4f\xf3\xdc\x23\xbe\xa6\xe1\x4c\xfd\xef\xd6\x02\x4d\x95\x24\xc7\x0d\x0a\xb8\xb1\x56\xdd\xcf\x6e\xe4\xdf\xe3\x76\xe6\xe3\x81\x1b\xc3\x07\x28\x9f\x1f\x93\x1f\xe8\x67\xb4\xf3\xf1\xde\x54\x8b\x1b\x48\x26\xac\xa8\xd8\x8e\xd6\x7e\xf4\xfd\x61\x6a\xb4\x58\xa2\xc9\x59\x78\xc1\x5c\xab\xfb\x78\xbc\x27\x76\x70\x92\x6c\xbf\xee\xe5\x8d\x6a\x80\x45\x5b\x95\x9b\x65\xb7\x1e\xe0\x2c\xcc\xac\xee\xcb\x8b\xf0\xf0\xfb\x61\x97\xcc\xc3\xda\xc6\xa3\x98\x94\xb9\x69\x31\x4c\xe4\xef\x0f\xf3\x7c\x49\x87\xd1\x2e\xc8\xa3\x97\xd7\xf3\xdf\xf8\x7a\x3e\x0e\xcf\x72\x0e\x93\x49\x37\x37\xa9\x50\x1f\xa0\x1f\x0e\xf3\x3c\x47\x06\xb0\x99\x01\xfa\xd7\x7d\x3d\x7e\x2a\xb2\xc1\xf8\xbb\x7c\xbd\xd1\x0d\x64\xcd\x79\x37\x97\xba\x46\xf7\xf5\x7a\x5d\xe8\xeb\xfd\x86\xad\xd1\x05\x37\x70\x9c\x01\x08\x73\x4c\xd4\xe7\xe0\x21\x7f\xd8\xd7\x4b\xd6\x7d\xbd\xef\xd4\xe6\xe5\x30\x61\x1d\x12\x7f\x69\xad\xcc\x63\xbf\x00\xe6\xa0\x3f\xcb\x07\x3b\xae\x3e\x76\x25\xb9\x9b\x8c\x70\xb3\x65\xc4\xd6\xba\x1b\xd0\xd5\xcd\x44\x9b\x0b\x2f\xe0\xf1\x47\x9f\x09\xfe\x47\xdd\x71\x25\xb9\x8f\xcf\xeb\xd5\xe4\xb4\x87\x76\x67\xe7\x3c\x9f\xd3\xe8\x00\x1e\xd7\xfe\xb1\x7a\x04\x7a\x7a\x4f\xa9\x1f\x6a\x3c\xee\x66\x8b\x3d\x25\x79\xac\xb5\xf5\x5e\x56\x29\xb4\xab\x47\xbb\x67\x77\x80\x2c\xff\xda\xb3\xbb\x00\xe8\x47\xd5\xcf\x34\x68\xe6\xf1\x54\x80\x82\xb4\xa7\xb1\x88\xfb\x07\x9e\xdd\xbd\x07\x58\x37\x88\xb1\x9e\xde\xbc\x21\x51\xbe\x55\x81\xeb\x57\xc2\x37\x80\x71\xeb\x08\x9c\xc0\xdb\x3d\xb3\xe3\x82\x71\xb9\x8e\xa8\x0f\x2f\x25\x33\xc9\x70\xb7\xf8\xea\x5b\x9e\xaa\x7e\xf4\x59\x52\xd0\x1e\xcf\x3f\x06\xf3\xed\xdf\xbf\xea\xf1\x05\x0c\x71\xc9\x7e\x8f\xef\x4b\x75\xf3\x12\xd2\x48\xfa\x82\xc3\xe7\x59\xd4\x8f\xbe\x87\xcf\x05\x8b\xfe\x4c\x7f\x6f\xbf\xfa\xf8\x12\xf2\x38\xb7\x8b\x0a\x72\x93\x67\xe1\x10\x36\x44\x1d\x47\x87\x0a\xed\x9f\x81\xe4\xba\xa2\xda\xf8\x5c\x9c\xcb\xc5\xec\xe2\x09\x75\x9f\xc6\xe3\x29\xfa\x9d\x67\x2b\xb0\xf0\x38\xd9\x55\x9a\x9e\x7a\x07\xd8\x85\x4d\x46\x07\x8a\x42\xdf\xec\xe8\xe9\xd9\x8a\xf2\x3a\x5f\x05\x3c\xac\xbe\xb7\x18\x56\x01\x60\x17\xeb\x3c\x3b\x07\xb3\xd2\xd6\xdb\x44\x45\x97\xbd\xbd\xaf\x27\x6a\xef\x7a\x2e\xd9\xd7\xdb\xb5\x94\x6c\x72\xb3\x67\x3d\x1b\xfa\xb1\x11\x1b\x34\x59\x6f\x6e\x6f\x23\x12\x77\x6a\x2e\x6e\x23\xcc\x67\x23\xef\xa9\xb7\x4d\x81\x19\xb4\xd4\x2d\x4e\x51\xab\xd5\x3b\xaa\xc9\x78\xba\xa8\x1d\x1e\xce\x7f\x4c\x51\x64\x2a\x1b\x8c\x02\xe3\xbb\xee\x15\x9b\xc8\x7c\x6b\xd9\x40\x09\x8d\x28\x9f\x35\x99\xe5\x78\x5e\x9c\x42\xef\x71\xbb\xd9\x87\x9e\x2b\xaa\xe9\xb1\xcf\xb4\xef\x9f\xda\x30\xfd\x6b\x0d\x09\xc7\xf8\x3f\xb0\xd6\xf8\x44\xfd\x68\x0a\x29\x25\x13\xc0\x01\x53\x9f\xaf\x26\x73\xb4\xf7\xbe\x37\xff\xd7\xb6\x17\xe0\xa6\xbf\xe0\xd5\x14\x43\x2e\x23\xdd\xd5\x63\xd5\x64\x99\xba\x9b\x5d\xdb\x51\xd7\x59\xae\x88\x76\x6b\x00\x09\x97\x88\x9d\x5a\x1e\xce\x01\x4a\xdb\x0a\xf1\xe3\x69\x08\x4f\x87\xff\x32\x8b\x2c\xf3\x1c\x10\x57\x08\xed\x9e\xf7\xff\x01\xdb\xb0\xb6\xad\x03\xe8\xad\xb8\x0e\xa0\x99\x17\xf8\xbb\xda\xeb\x61\x9f\x3b\x0d\x8e\x75\x80\x2d\x03\x6c\xe7\x2b\x81\xc3\xea\x70\x32\x86\xf4\x73\xb3\x77\x3d\xb0\xbc\xbb\xff\x4f\x59\x07\x30\xbf\x37\x7d\x52\x9d\x4e\x46\xf2\xc7\x4b\x29\x6a\x9e\x9b\xce\x27\x05\x9d\xe2\x4b\xfe\x67\xff\x97\x86\x1f\xe0\xad\xbf\xa3\xae\x27\x09\xb0\xe2\xa2\xeb\xd4\x1d\x6e\x72\x3d\x8d\xed\xb0\x36\x82\x89\x44\x81\x06\x24\xda\xda\x88\x82\x97\x67\xd0\x8e\x79\x6c\xbf\x36\xd2\x11\x61\x04\xdc\xae\x7f\x42\x04\xce\xa7\x5b\xfd\x5a\xd4\x3e\xf0\x0b\x5c\x1b\x06\xac\x01\xb8\x8a\x99\xd2\xd1\x47\xea\x74\x0d\x80\x4f\xa5\x05\x02\x1d\x67\x7f\x6b\x37\xb2\x7c\xd6\xd7\xe2\x9a\x8b\x3c\x4f\xf9\x9d\x3e\x9e\xe4\xf7\xf1\x80\x81\x99\x5c\xe5\x66\xe3\x5b\x1f\x01\x06\x3f\xb1\xf7\x5e\xf9\x33\xf0\x03\xde\x2c\x4c\x21\x71\x64\x2e\xfa\x77\x80\xaf\x9e\xa3\xcd\xba\x7f\xf7\xe7\xf2\x28\x26\x43\xc1\xbb\x86\x95\x05\xf0\x38\x4c\x0a\xd8\x2d\x1d\xde\x7d\x66\xb8\x82\xc1\xc7\xa3\xbf\xf6\x34\xaf\xa8\xcd\xc3\xc3\x41\x45\xed\xae\xce\x9e\x46\x96\x92\x20\x37\x59\x52\xaf\xfe\x8f\xf8\x8b\xff\x7d\x6a\xa0\x8f\x77\x09\xeb\x09\xde\x09\x01\xa9\x0f\xe2\x7c\xe2\x7b\x66\xdc\xf6\x9e\x38\x91\xf7\x41\x89\xbf\x24\x06\xa9\x9e\xe2\xce\x9d\x88\x50\xed\xba\x9e\xcf\xb1\xfb\x5a\x9d\xb7\x8a\x3c\xc9\x1d\xbb\xf3\x4a\x37\x69\xac\x20\xb4\x7f\xee\xaa\xbf\xc7\xf4\xf9\x5d\x8a\x88\x0e\x91\x86\x97\xef\xfb\x62\x20\x40\x8f\xa9\x6d\x93\xd3\x2f\xea\x4d\x2b\xc9\x66\x3e\x39\xdd\x74\xee\xfc\x95\xd9\xd2\x58\x75\x17\xe9\xd5\x11\xdf\xf7\xbe\x5c\xba\x38\x7a\x51\xa7\x33\xf7\x87\xea\xc6\x66\x44\xa7\x65\xe4\xdb\xf3\x6f\x02\xbc\xe7\x10\x8c\x46\x9d\x7c\x43\x70\x69\xd8\x81\x33\xf6\x0e\xf5\xfe\x95\x64\x1f\x60\x7f\xc5\x42\x5b\x8d\x39\x52\x79\xeb\x61\x96\xda\xfe\x9b\x87\xb6\x67\x76\xf4\x82\xaf\x1e\x2e\xf6\xcc\x6e\x9b\xba\x65\x05\x79\x53\x7f\x8e\x9e\x2b\x8d\x6e\x7b\xa7\xde\xe5\xc2\x67\x76\x94\x32\x29\xe0\xf9\x76\xa7\xef\x60\x57\x91\xed\x88\xe5\x6f\xb7\x76\xdf\x8b\x68\x7e\x1c\x9f\xa0\xc5\x0b\xbe\x17\x69\xf3\xe1\x0e\xaa\x63\x9b\x61\x5c\x82\xf9\xf9\xd5\x77\x5a\xc3\x0a\x61\x06\x1b\x22\x5c\xe4\xbb\x16\x29\xf0\xbb\x16\x50\xa7\x8e\x7b\xe1\x77\x2d\x6d\x1e\xdc\x59\xb5\x76\x39\x79\x8a\x8c\x05\x0f\xae\x35\x2e\x4f\x2c\xe2\x8f\xec\xda\x7d\x97\x93\x17\xe8\x5b\xe1\xb3\x34\xf8\x1f\x88\x5d\xf4\x1b\x1e\xdc\x71\x75\xcd\x95\xe4\x45\x58\x3d\xd0\x85\xb0\x7a\x58\x91\x27\x96\xaa\x9b\xe9\x84\x4e\xbf\xfd\x41\x3b\xf8\x35\x0e\x9d\x5b\xc3\xbb\xea\xdd\x2b\xc9\xbb\x24\xdf\xfd\x6f\x3a\xa7\x75\x5f\x81\xe8\xf2\xac\x82\x05\x77\x87\xef\xa2\xf0\x59\x9d\xe6\xd7\x53\x7c\x73\x15\xf8\x66\xa5\xa8\xc3\x2c\xdd\xce\x26\x9e\xbd\x8a\xec\xe0\x36\x91\xdc\xfa\x51\x9e\x58\xd1\xfa\x91\x18\x7d\x91\xef\x75\xf4\x79\x9a\x5b\xb1\x0f\xf8\xa2\xfe\xdb\xb6\x2b\xc9\x0e\x58\x4f\xb5\xba\xf3\xc4\x97\xd7\x0a\x1d\xbe\x2d\x43\xdb\xe0\x6b\x05\xda\x66\xb6\x9d\x3d\xcb\xfd\xdb\x52\xfa\xb9\x5b\x9c\x7d\xfe\xce\x12\xa9\x9f\xff\xbb\xb2\x0e\xdf\xbd\xf9\xfb\x96\x5f\x9d\x1d\x65\x52\xfc\x95\xfd\x59\xbd\x7c\x09\xb9\x97\xcc\x74\xb3\x2d\xbf\x78\x06\x0f\xa6\x6f\x92\x6a\x12\x22\x74\xfa\xad\x5e\xdb\x7a\xe1\xb7\x6c\x2d\xc0\x67\xfb\x59\xbd\xab\x89\xb8\xc9\x24\xf0\xd9\x3c\xb5\xa5\xf4\xb0\xe6\xb3\x15\xfc\x79\xb6\xb6\x5f\xdd\x30\x17\x3c\xf9\xe1\x6e\xe2\x24\xd9\x9e\x2d\xc3\xe8\x71\x75\x33\xfb\x67\xbb\x6f\x24\xd3\xd0\x8f\xd7\xec\x40\xee\xf8\x7e\xed\xe2\x36\xa0\xc1\xd2\x44\xcf\x91\x91\xf4\xb8\xe7\x1d\x71\xb9\x5f\xdf\x7f\xc4\x06\xb4\x29\x62\xdb\x22\xf2\x3c\x42\x96\xd2\x63\xfc\x35\x7f\xbb\xef\x4d\x7f\x6b\x7c\xf0\xfb\xef\x9f\xaa\x63\x26\x93\xbf\x91\x0a\x37\x2c\x99\xef\x52\xe7\xcc\x22\x57\x40\x8d\xdb\x7f\x13\xab\xdb\x02\x6f\xb3\xdf\xb0\x05\x44\x45\x4f\xe1\x43\x75\xc4\x58\xf2\x0f\x6e\xf7\xf5\x6a\x8e\x5a\x37\x97\xac\xa6\xff\xfa\x46\x68\xff\xed\xae\xef\x1d\xbe\xf6\x9c\x1a\xea\xcc\x18\x3f\x21\x34\x2f\xe7\x62\xb5\xe6\x46\xbb\xa2\x8a\x1e\x75\xd3\x46\xcf\xfa\x69\x74\x37\x2d\x13\xda\x7f\x6b\xdc\x61\x1c\x33\x69\xb6\x25\x8a\x7e\xd8\x5f\xb1\xae\xdd\xea\xb3\x33\xc9\x42\x72\x39\xb8\x64\xea\xd6\x19\x64\x91\xef\x79\xe0\x88\xce\xd6\xf6\xda\xab\x55\xc6\x64\x44\xd6\xa0\x2f\xda\xfa\xaf\x4e\x45\x4d\x80\xbb\x71\x70\x06\x59\xad\xee\x16\x5f\x6f\xff\x1d\x6f\x27\x7a\x40\xdf\xe0\xa2\x7a\xc0\xd6\x9f\x4c\xee\x73\x93\x0c\xf5\xbd\x1a\xd2\xc2\xee\x6e\xe7\x8f\x66\xe2\xb3\x02\xfc\x56\x80\x8a\x0a\x1e\x71\xc6\xbf\x0f\xb7\x69\xcf\x80\xd0\x7f\x09\x74\x1f\x89\xcf\x49\x87\x45\xd1\xcd\x24\x84\xac\x72\xb3\x17\x5a\x4b\xdc\x3e\xff\xe5\x5e\xa1\x93\xef\xda\x35\x3b\xe8\x14\xb9\xb3\x87\xe9\x05\x7e\xf8\x50\xfe\x7a\x27\xad\xf5\x03\xb7\xd8\x65\xdf\x85\xef\x03\x6c\xed\xfc\xba\x5f\xe3\x10\xd9\xa9\x9f\x7e\x54\x5d\x4b\x62\xc9\x22\x37\x2d\xf1\xbc\xe0\xa6\x67\xa8\xdc\x99\xfc\xa2\xf0\x9b\xe8\x17\x5f\x05\xe4\x93\xa9\x6e\xd2\x55\x7d\xc7\x4d\xa6\x32\xbe\x1b\x8e\xa8\x87\xc5\x97\xe8\xe5\x12\x3f\xdf\x35\xc2\x65\x14\x0d\x06\x13\x3f\x39\x90\x9f\x61\xb0\x27\x4f\x3b\xff\x4c\xdf\x7f\x8a\x3f\xf4\xf2\x96\x8c\x98\x43\x03\x33\x62\x0e\x0e\xcc\xe8\x21\xad\xda\x51\x0b\xff\xf0\xbd\x1e\xf5\xce\x91\xde\x23\x0f\xea\xfb\x56\xba\xbb\x12\xa9\x64\x38\x6e\x38\x6b\xa0\x06\x25\x57\x5a\x20\xb5\x48\xac\x59\xda\x20\x6d\x92\xb6\x4b\xe2\x28\x89\x58\xf8\xbe\x79\xdc\x9b\x91\x93\x5f\xa9\x6d\x96\xc3\xed\x28\x76\xbe\x85\x28\x86\xf2\xad\x28\x3f\xe2\x4e\x0c\x6d\x1b\xca\x63\xcd\x80\x3f\x1f\xf0\x77\xe9\xf8\x39\x2e\x27\x93\x8f\xcb\x67\xc1\xb9\x31\xe6\x0a\x0b\x04\x10\xb8\x59\xd8\x20\x6c\x12\xb6\x0b\xe2\x28\x81\xe8\x41\xa1\x74\x78\xbe\x6d\x1d\x37\x04\xf1\xb3\xc5\x4f\xe0\x5e\x20\xba\x9e\xa6\x44\x79\x3e\xc4\x8d\x40\xe9\xcd\x9a\xfc\x2e\x69\x07\xf9\x14\xf0\xa3\x85\x04\xa1\xc0\x95\x1c\x17\x61\x93\x82\x83\x9d\x8e\x5c\xc7\x74\xc7\x02\xc7\x29\x87\x74\xca\x41\x9a\x1d\x1b\x1c\x9b\x1c\xcc\xe5\x18\xe5\xa0\x0e\x3d\xe8\x1a\x30\xe1\x6f\xf7\xf1\x94\xfb\x4e\xf7\x94\x30\xe4\xdd\x7a\xd1\x2d\x25\x63\x8e\x52\xaf\xb0\x8a\x4a\x3b\x3a\x6e\x2b\x21\x75\xe6\x6b\x4c\x5c\x36\xe6\xed\x07\xb2\x7d\xac\xef\xbf\x49\x14\x2a\x5d\xc1\xf1\xe1\x54\x0e\x76\x18\x5c\xe1\xa3\xc2\x69\x38\xdf\x81\xd3\x2d\x2d\xab\x34\x5c\x0e\x97\x95\xd0\xed\x06\x2f\x68\x9d\x85\x2a\x4e\x85\xf2\xed\x38\x7c\x33\x8e\x78\x4a\x21\xcd\xca\x06\x65\x93\xc2\xf8\xb6\x1c\x7e\x22\xa1\x7f\x63\x8c\xf6\xa0\x61\xa1\xcd\x1f\xf4\x49\x3b\x2d\xaf\x90\x74\x5a\x1b\x72\xa7\x63\xa9\x63\x27\xfc\x10\xdb\x45\x6b\xa4\x64\x5e\x0f\xff\x3a\xdf\x27\x43\xbd\x53\xa4\xa3\x64\xb1\x12\xce\xdf\x3a\x09\x61\xcf\x10\x22\x52\xaa\x68\x27\x4b\xe6\xc1\xba\x27\xa7\x7b\x2e\x4b\x2e\xc4\x13\x8b\x15\x12\x7f\xbd\xe3\xfa\x7a\x91\x58\xf6\x4a\xea\x2a\xf9\xea\x1b\xd4\x77\xc3\x48\x42\x9c\xfa\x95\xcf\xde\x3e\x00\xc7\x96\xeb\x24\x58\xe8\xe3\x4a\x0d\xca\x85\x35\xac\xd4\x62\xe4\xab\x1e\xc9\x49\x89\x6f\x47\x90\xd8\x4c\xb7\x53\x3a\x8a\x12\x0b\x25\xbe\xfd\x40\x39\xb8\xc4\x72\xf0\xb8\x37\xfc\xe8\x00\x7e\x30\xb2\xef\x00\x88\xd3\xd7\x39\xae\x73\xbc\xf5\x82\x58\xb7\x87\xfe\x50\x2f\xca\xf7\xdd\xa0\x6e\xf2\x1d\x03\x01\xed\x50\x2b\x3d\x49\xbe\xf2\xef\x9b\x1b\xe0\x32\x53\xc9\x24\x99\x94\xb9\x46\x62\x64\x7c\x9b\x93\x2b\xb6\x4b\xf7\x52\xd0\x35\x2a\x7e\x54\xc7\x7d\x50\xc0\x7d\x61\xd5\xc2\x4c\x50\xba\xf6\xe6\x44\xd3\x75\x22\xd7\x35\xb7\xfb\xaf\x52\xee\x4f\x51\xbf\xe7\x1b\xb0\xce\xe0\x5e\x28\x25\x93\xef\xbe\x52\xaf\xd7\x9f\x1d\xd9\x80\x6c\xc7\xf3\x90\x79\x24\x40\xa2\x98\x8c\x26\xc2\x24\xb3\x14\xac\x04\x09\x41\xa3\x2a\x70\xb5\x17\x4e\x2d\xfa\xc7\xee\x1d\x4e\x7c\xe5\x5d\x40\x0b\x63\xc0\x0f\xd1\xce\x9a\x37\x79\xeb\xe4\x46\x47\xe3\xb4\xad\xd3\xe6\xd1\x7a\xf2\xb6\x9a\xb3\x5a\x8d\x25\xc7\x05\xed\x3c\x3a\xef\xd7\xe2\xcb\x4a\x57\x5b\x1a\xab\xe6\xe7\xaf\xd1\x1b\x85\xf7\xf8\x19\x4f\xca\x3f\x89\x44\xa6\x81\xff\x13\x27\xb2\xdc\xfe\x64\x5f\xff\x53\xfd\x69\x71\xff\xf2\xfe\xb4\x3f\xcd\xb4\xa6\x89\x8c\x0a\x99\xd9\x89\x41\xa9\x24\xb3\xa0\xa0\x40\xc8\x2c\x00\x45\x2f\x2c\x28\xf8\x35\xbc\xfb\x88\xf8\xa7\xe2\x3d\x2e\x7c\xee\xc7\x2b\x26\xfb\x8a\x4f\x15\xd3\xe2\xe2\x72\x20\x7f\x10\x6f\x93\xe0\xfd\x53\xf0\x76\x91\x2b\xbc\xef\x73\xfd\x09\x1f\x02\xde\x44\x97\x4b\x64\x7b\x87\x1e\x19\x4a\x37\x0c\xdd\x3e\x94\x36\x0c\x6d\x1e\x4a\xcb\x87\x56\x0d\xa5\x39\x43\x8b\x87\x52\xcb\xd0\x84\xa1\x74\xfb\xd0\x93\x43\x69\xf1\xd0\x72\x3d\x2f\x61\x28\x19\x4a\xbb\x6a\x2c\xb3\x7b\xb6\x67\x09\x4c\xf1\x5f\x41\x41\xe7\x6d\xe7\xe3\x7d\x9f\xf0\xf3\xff\x19\xef\xc7\x85\x77\xfc\xbc\xcb\x8e\x94\xd1\x0d\x65\xdb\xcb\x68\x43\x59\x73\x19\x2d\x2f\xab\x2a\xa3\x39\x65\xc5\x65\xd4\x52\x96\x50\x46\xb7\x97\x9d\x2c\xa3\xc5\x65\xe5\x7a\x5e\x42\x19\x29\xfb\x7d\xbc\x33\x2f\xe0\xbd\x49\xf8\x84\x54\xfd\x2f\xf3\xe6\xdf\xc2\x6d\xc1\x7a\xcf\x05\xde\x69\xf4\xc6\x57\xb0\xb7\x78\x3f\xd0\xac\x87\xd1\x5c\x27\xd9\xe7\x3c\xe5\xa4\xc5\xce\x72\x27\x75\x92\x60\x6b\x1a\x3f\x96\x37\xd8\x62\x30\x76\xb4\x1e\x1f\x1e\x0b\xbf\x00\xef\x3e\xef\xb9\x3f\x8e\xd7\x89\x7c\x8f\x07\xc8\x97\x48\xf6\x25\x9e\x4a\xa4\xc5\x89\xe5\x89\x34\xf1\x92\xe4\x23\x17\xe0\x6d\xf2\x9e\xf8\xe3\x78\xf4\xad\x00\xbc\x5d\xd5\xd8\x5b\xbc\xdf\x6b\x56\xc3\xe8\xde\xcc\x23\x99\x74\x43\xe6\xf6\x4c\xda\x90\xd9\x9c\x49\xcb\x33\xab\x32\x69\x4e\x66\x71\x26\xb5\x64\x26\x64\xd2\xed\x99\x27\x33\x69\x71\x66\xb9\x9e\x97\x90\x49\x32\x89\xd9\x9a\xc6\x28\x11\xcc\xe6\xf6\x2c\x03\x5a\x4e\xaf\x87\x74\x01\xdf\xfb\xbc\x5f\xfd\xef\xf3\xa5\x0f\x5f\xc0\xf7\x71\xef\x5e\x3f\xdf\xac\x23\x59\x74\x43\xd6\xf6\x2c\xda\x90\xd5\x9c\x45\xcb\xb3\xaa\xb2\x68\x4e\x56\x71\x16\xb5\x64\x25\x64\xd1\xed\x59\x27\xb3\x68\x71\x56\xb9\x9e\x97\x90\x45\xb2\x2e\x9d\xef\xe7\x17\xf0\xdd\xe4\xdd\xfd\xbf\xcc\xb7\xce\xfb\x8d\x18\x81\x7c\x97\xea\xe3\xeb\xbb\xda\x7c\x22\x7c\xe9\xb7\x98\x2c\xb2\x2f\xeb\x94\x0e\x9f\x45\xa2\x35\x8b\x89\x8e\x0a\x0b\xee\x64\x7c\xe5\x78\x49\x9d\xe0\xdd\x47\x94\x3f\x8c\xd7\x99\x7c\xfe\xf9\x04\xf0\xb2\xc9\xbe\xec\x53\xd9\xb4\x38\xbb\x3c\x9b\x66\xff\x41\xbc\x4d\xc2\x4f\x7f\x0a\x9e\x7f\x3e\x21\x16\xad\xe5\x28\xdb\x5b\x78\xa4\x90\x6e\x28\xdc\x5e\x48\x1b\x0a\x9b\x0b\x69\x79\x61\x55\x21\xcd\x29\x2c\x2e\xa4\x96\xc2\x84\x42\xba\xbd\xf0\x64\x21\x2d\x2e\x2c\xd7\xf3\x12\x0a\x49\x21\x89\xd2\x5a\x2e\x2a\x8a\x19\x7e\x6d\x6c\xe3\xbc\xb3\x3b\xe1\x7d\x1f\xb1\xfd\xff\xc2\xbb\xb3\x7a\x3f\x2e\x7c\xef\xe7\xdd\xeb\x48\x2f\xba\xa1\xd7\xf6\x5e\xb4\xa1\x57\x73\x2f\x5a\xde\xab\xaa\x17\xcd\xe9\x55\xdc\x8b\x5a\x7a\x25\xf4\xa2\xdb\x7b\x9d\xec\x45\x8b\x7b\x95\xeb\x79\x09\xbd\x48\xaf\xff\x96\xf7\x26\xe1\xdc\xff\x3a\x6f\xde\x4f\x9f\xc5\xb9\x0c\xfb\xa9\x30\xe7\xb9\xe7\xb9\x15\x79\xbf\x16\xb6\x5a\x65\x93\x39\x5a\x10\xae\x73\xd5\x8a\xac\x39\x62\x43\x04\x2d\x8f\x68\x88\xa0\x39\x11\xc5\x11\x34\x21\x82\x9c\x8c\xf0\x46\xd0\xbd\x11\x47\x22\x68\x73\xc4\xda\x08\x5a\xe5\xbf\x66\x89\x48\x88\xa0\x78\xf5\x48\x04\xd9\x14\xb1\x9d\x17\xd8\xc0\xb3\xe1\x5a\x04\x25\x55\xa1\xc4\xc9\xcf\x02\x85\xd9\x4e\x08\x0f\xb3\x86\xa4\x82\x90\x76\x5f\x97\xce\xe4\x62\x2e\x6c\x2c\xd0\x24\xd5\x45\x6d\x84\x7f\x05\x05\xbf\x21\xab\x62\x0a\x16\xfe\x21\xfc\x3f\x23\xad\x5f\xb7\xbb\x2e\x90\x77\x97\xe0\x16\x76\xea\xba\x5d\xe2\x1a\x2f\x56\x65\x34\x64\xd0\x84\x8c\x9c\x0c\x6a\xc9\x20\xde\x0c\xd2\x9c\xb1\x21\x83\x16\x67\x94\xe3\xdf\x19\x6c\x7b\x18\x69\x80\x85\x48\x18\x69\x09\x23\x39\x61\xc5\x61\xd4\x12\x46\xc2\x60\xc1\x11\x5a\x15\x4a\x41\xb4\x16\x5d\x3a\x7b\x94\xb3\x73\xe9\x74\xf1\x78\x93\xfb\x9a\xbf\xe0\x37\x64\xf3\xe9\xf2\xff\x48\xba\x80\x3e\x91\xe9\xeb\x13\xc2\x1c\xe1\x5d\x2f\xb6\x36\x51\xb0\xb5\xcd\xa4\xd0\xdf\xda\x49\x1b\x92\x68\x79\x52\x43\x12\xcd\x49\x2a\x4e\xa2\x09\x49\xe4\x64\x92\x37\x89\xee\x4d\x3a\x92\x44\x9b\x93\xd6\x26\xd1\x2a\xff\x35\x4b\x52\x42\x12\xc5\xab\x47\x92\xc8\xa6\xa4\xed\xbc\xc0\x06\x9e\x0d\xd7\x92\xa0\xb5\x63\x89\x93\x9f\xe9\xcb\x5b\x3b\xd1\x19\xe7\xe0\x12\xc7\xc6\xb0\xe0\x4b\xb0\xcd\x0b\xe5\x7d\xa7\x9d\xbc\xc1\xe4\x99\xff\xc7\xe5\xd5\xf4\xbb\x8b\x3c\x80\x16\x60\x26\xf9\x3e\x0b\xe8\xd1\xd0\x83\x26\xf4\xc8\xe9\x41\x2d\x3d\x88\xb7\x07\x69\xee\xb1\xa1\x07\x2d\xee\x51\x8e\x7f\xf7\x60\xdb\x9d\xa4\xc1\x49\x12\x9c\xa4\xc5\x49\x72\x9c\xc5\x4e\x6a\x71\x12\xbe\x20\x8e\xad\x8a\xa5\x20\x5c\x8b\x2e\x9f\x3d\x25\xab\x73\xf9\x2e\x62\x9f\xbf\x25\x5f\x30\xd9\xf6\x7f\x2a\x5f\x22\xf8\x73\x8c\xcb\xc7\xdf\xb4\x5a\x65\x83\xea\xec\x23\xc4\xba\x4c\x74\x43\xf0\xa6\x60\x1a\x2c\xa5\xd1\x6d\xc4\xbc\xd5\x10\x24\x52\x8e\x25\x64\x56\x16\xc0\x9a\xba\x4c\x9d\x28\x6d\x96\x6e\x13\xba\x08\x45\xae\x04\x47\x2c\x8b\x14\xbb\x86\x24\x27\x67\x3a\xad\x55\x15\x4e\x31\x3c\x36\x32\x9a\x45\xda\x04\xa5\xaa\x42\x14\x85\x18\x7f\x18\x1b\x58\xbc\x17\xfb\x63\xd9\x05\x1c\x1b\xda\x9f\x14\xda\xb5\xb8\x29\x21\x3c\xec\x52\x0c\x9e\xd6\xd9\x33\x45\x8f\x5e\x25\x53\x99\x25\x2e\xbe\xab\xe7\xb5\xce\xd9\xae\x89\x8d\xa3\x93\xaf\xb0\xdc\x79\xf3\xb2\xcf\xd6\xdb\x1f\xdb\x7e\xb0\xf7\xb6\xf0\x70\x71\x26\xc9\xbc\x6f\xf7\x6e\x7b\x73\x76\xcb\x4b\xea\xc4\xc1\x23\xe7\x66\x17\x55\xbc\xb6\x99\x2e\x1a\x3e\xe0\x8e\xfb\xeb\x9f\xac\x69\x5d\x2d\x96\x90\x7e\xb7\xd7\x5c\xbd\xe6\xd0\xab\x93\xaa\x3c\x4d\xc7\xd5\x5f\x96\xf3\x7d\x38\x20\xff\x2e\x89\xc7\x01\xee\xeb\x8a\x8f\xb0\x1a\x8d\xd4\x14\x22\x46\x87\x87\x3b\xac\xd6\x90\x30\x93\x85\x45\xd8\x8c\x21\x36\x41\x9a\x5e\x41\xf9\xc3\x2a\x2e\xbd\x76\x34\xae\x4d\x3f\x54\x14\x0f\xba\xe5\x55\x48\x2f\xe4\x87\xc9\x16\x13\x12\x42\x78\xf0\x15\xd2\x9f\x1f\xfa\x06\xe9\x95\xbd\x86\x46\xf6\x48\xe8\xd3\xc7\x1a\xee\x79\x2d\xd2\xf4\xd2\x46\x62\x3d\x40\xe3\x44\xc7\x4b\x8f\xaa\x87\x12\x6e\x52\x27\x86\xb8\x0d\xe3\xa6\xce\x15\x5f\xb8\xbb\xa4\x35\x55\x5a\x75\x7e\x69\xdc\xdd\x6c\xef\x2f\xbf\xdc\xb3\x9a\x3f\xaf\xb8\xde\xfb\x8d\xb4\x16\x74\x9b\x21\x0c\x70\x25\x8b\x2c\x38\x29\x29\x3a\x26\x82\x49\x5d\xba\x26\x84\x56\x55\x24\x88\x61\x31\x11\x51\x2c\x82\x45\x08\x51\x8c\x6b\x58\xb0\xfb\x5e\x4d\x6b\xdf\xd6\x16\x15\x07\x7e\xfb\x22\x39\x53\xac\xf9\x78\xde\xad\xbd\xd0\xa7\x62\x0b\x49\xb6\x15\x06\xa8\x58\xa6\x21\x94\xde\xa6\xb6\xaa\x3f\x6e\xdf\xf8\xf8\x7b\xdf\xf5\x8a\xb7\xdc\xb5\x76\xd9\xf1\xf5\xf6\xd4\xed\x57\x04\x6d\x0b\x89\x14\xa7\x91\xc4\x47\x5e\xdf\x1f\x39\x6c\xe1\x63\x5f\x85\xfd\x44\xe4\x67\x36\x9d\x21\xc9\x77\x0e\x77\xdd\x79\x7f\xdd\xd6\xea\xed\x74\xe9\xc8\xda\xab\x97\xac\xde\xf7\xfa\x80\xdb\xd4\xf5\xa7\xee\x1e\x2e\x50\xf5\x4d\x61\x0e\x19\xc8\xe6\x08\xc1\x82\x43\xb0\x6f\x0e\x51\x9e\x27\xb1\x42\x18\x54\xcc\x01\x86\x50\xcc\x1f\xa8\x68\x41\x73\x30\x9e\x40\x7f\xc2\x30\x42\x7b\xb2\x16\x16\x79\x58\xe3\x75\x55\x8f\x2c\x69\xbc\xbe\x72\xa3\x32\x62\x46\xdf\xc5\x23\xa7\xf7\xe9\xc7\xe6\x5c\xbb\xe8\xba\xd6\xeb\xff\xb2\xb4\x45\x5d\xe5\x59\x5c\xf5\x9f\x8a\xbf\xcd\xdc\x33\xa9\x74\x88\x40\xbc\x83\x85\x15\xc2\xeb\xb0\x6e\x95\x85\xb0\x2d\x94\x12\xf1\x39\xc2\xa3\x5c\xc6\xe0\x27\x77\x39\xdd\x73\xd3\xed\x4a\x31\xc9\x67\xa3\x9b\x3e\x8a\xf9\xbc\xf9\xe6\x15\xb4\x62\xd9\x4d\xcb\x3d\x0e\x81\xa8\xd7\x08\x4d\x24\x09\xe4\x8b\x11\x32\x5c\x66\xc5\x1e\x5a\x15\xdc\x00\x76\x1e\x6c\x0a\xdd\x46\x1c\x5b\x48\x74\xb4\xb0\x8d\x83\xe4\x59\x8b\x38\x4e\xa5\x95\x1f\x04\x95\x5a\x08\x36\xca\xe5\xd4\x02\xf5\xf5\xf4\xc7\xbb\x55\x12\x15\xf5\x1a\x6b\xfe\x86\x86\xba\xd1\xbd\x7b\xf5\x1e\x1d\xd6\x5c\x7a\xac\xe1\x2f\x95\x33\xef\x9c\x91\x40\xd6\x85\x35\x8d\x19\x7b\x7d\xdf\xc2\x89\x3d\xd3\x73\x7a\x15\x84\xed\x69\x18\x3f\x64\x49\xcf\xb1\x25\x99\x2b\xf8\xb3\xe3\xbb\x40\x47\x4e\x90\x21\x0d\xda\x38\xd2\x9a\x9a\x9a\x93\x56\x9c\x56\x9e\xc6\xd2\xd2\x82\xe2\xa3\x46\xc5\x4c\x8f\xa1\x31\x31\x51\xdb\x48\xac\x2b\xa8\xc1\xd0\x6c\x58\x6b\x60\x06\x83\x14\xb4\x8d\x6b\x90\x8b\x54\xcc\xc5\xca\xc7\x50\x9c\xfc\x09\x30\xcb\xeb\x20\x97\x85\xf0\x20\xf8\x3c\x3a\x9e\x7e\x4e\x32\x3f\x09\xb9\xb0\xfb\xce\xa2\x9e\x7d\x27\x58\x6f\x2a\x3b\xd9\xd8\x32\x7f\x32\x19\x34\xf2\x6e\xf7\xc9\xde\x37\x85\x96\x0e\x1b\x3a\x7c\x44\xd9\x65\x61\x34\x67\x49\x5a\xb7\x82\x5c\x65\x6f\xf5\xe8\x31\xd5\x66\x1a\x32\xee\xb2\xba\x15\xbb\x22\xf3\xfa\x0d\xe9\xd5\xbd\xf7\x5c\xfe\xdc\x50\x5d\x2d\xac\x20\xd1\xa0\x6f\x93\x10\x2a\x64\xba\xec\x82\x28\x1a\x9a\x2d\x6b\x2d\xd4\xe2\x32\x05\x97\x5a\x2c\x34\x48\xe1\x2d\x40\xb5\x16\xe0\x6f\x5c\x2a\xb5\x78\x49\x3c\xfa\x48\x62\x21\xe1\x0f\xd1\x98\x85\x80\xdd\xdd\x92\xd0\x94\xa0\xce\xb6\x92\x6f\x57\x4d\x5d\x18\x71\x57\xb7\x03\x76\xc7\x59\x12\xbb\x61\xc3\x38\x72\x46\xed\xba\x90\x6c\x28\xd8\x1b\xc1\xcd\x45\x7d\x51\xa8\x27\x2e\x36\x05\xda\x29\xcb\x15\xea\x88\x8a\x12\x65\xd9\x66\x1e\x65\x99\x0e\x1c\x2d\x66\x6e\x54\x0c\x4a\x45\xa3\x51\x71\x7d\x14\xe5\x68\xec\x30\x56\xaa\xae\x89\x40\x15\xf0\x13\xe5\x6e\x20\x6f\x24\xa8\x5b\xf3\xfb\xcc\x98\x7d\xc5\xc6\xbf\xfc\x50\xe4\x0e\x99\x3a\xb8\x64\x5c\xa9\x6b\x62\x71\x0d\x9b\xb2\xe2\xb1\xdc\x2b\xea\x5b\x6e\x7b\x2d\xb5\xb7\x6b\xf4\xf0\xbe\x83\x7b\x62\x9d\x5f\x13\xe6\x92\xae\xe0\x57\xf0\x08\xfc\xdd\x9f\x4c\xb2\xda\xf9\xb3\x4a\x8b\x31\xb8\xd4\x6e\x0f\x51\x82\x5c\xd6\xb0\xd2\xa0\x20\x30\x70\x87\x10\x0b\xb2\xc4\x6a\xb2\x64\x72\x59\x32\xf9\xf0\x90\xae\x99\x78\x40\x68\x2b\x5d\xae\x54\x5f\xcc\x6c\xc8\x2b\x5a\x72\x53\xf5\xe3\x8d\x13\x96\x86\xb7\x98\x7b\x67\x8c\x5c\x1a\x3b\xe4\xda\xe9\x57\x6d\x55\xd5\xd2\x5e\x43\xa7\xf4\x2d\x1a\x31\x73\xee\x4d\x4d\xcd\xe7\xae\x9f\x34\xce\x9e\xd5\xad\xd9\x3d\x73\xc1\xd4\x96\x8d\x5f\xf7\x29\x9d\x5d\x96\xdf\x6f\x22\x70\xf4\x5a\x84\xab\xc8\x1c\x36\x15\xda\x24\x6c\x8b\x41\x92\x64\xde\x02\x44\x6b\x01\xae\x8b\xf4\xe4\x9e\x36\x7e\x4e\x94\x22\x53\xd7\xc3\x71\x4f\xbf\xa9\x4e\x8e\xa0\x83\xec\x2f\x3f\x75\xd5\xed\xc4\xf9\x5c\xc3\xf4\x47\xd5\x0f\x04\xa6\x6e\x84\x3a\x66\x81\x2d\x46\x0b\xa9\x42\x77\xe8\x13\x16\xbb\x9c\x96\x96\xe3\x28\x76\x94\x3b\x98\xc3\x91\x15\xcc\x55\xed\xf4\xf7\x5f\xcd\xea\x8a\xf4\x6e\x2c\x2b\xe1\xba\xad\x61\x30\xed\x02\x8c\x09\x6d\xf7\x55\x8d\x47\x71\x0a\x08\x10\xde\xa3\xe9\xda\x19\x93\xfb\x0d\x7f\xe4\xf6\x6b\x6e\x6c\xa8\x2f\xec\xb7\x61\x56\xc9\xb0\xcb\x5c\xfd\x47\x5f\x66\x1a\x3f\x7a\xd0\xd0\x11\x93\x47\xb0\x39\x33\xc6\x94\xd5\x05\x31\x4b\x79\x71\x43\xcb\xe5\x95\xe5\xf3\xc3\x69\xd8\xe8\x9e\xd3\xea\xd5\x37\x5d\x7d\xb2\xba\x17\xf6\xeb\xd6\x73\xde\xc8\xe2\x6e\xfd\x46\x0e\xc8\x2b\x0c\x6c\x1b\x1e\xe5\xbf\xbb\xcb\x9c\x18\x6a\x73\x41\xc3\xd8\x6c\xc1\x0a\x3f\x78\xed\xa9\x50\xbd\x6d\x62\xc1\x80\x7c\xc2\x07\xb4\x4d\xdb\x28\xa4\x0d\xe1\x85\x7a\x1d\x02\x63\xf8\x67\x5c\xe1\x9e\xfa\xc8\xe2\x09\x2b\x22\x96\xc7\x4c\x9e\xd8\x14\x31\xa4\xa5\xf6\xca\x2d\x84\xf9\x5a\x86\xcd\x75\xb7\xac\xfd\xfc\xea\x71\x93\x1c\x33\x6e\x58\x39\xb3\xa9\xba\xf9\xde\xb6\x96\xe1\xf2\xad\x93\x9e\xa6\x05\xf8\xde\xc5\x22\xc4\xb8\xcc\xcd\x30\xb4\xbb\x18\x33\x86\xb4\x18\xb4\x53\xe5\xf3\x8a\x72\x1c\x7b\x2a\xfd\x87\xae\x69\x2f\x8a\x0a\xf9\x8b\xa6\xf7\x99\xda\x3a\x9d\x8e\x11\xeb\x9f\xa5\xde\x3a\x91\x84\xbf\xa5\x64\x9a\x9f\x30\x6d\x0a\xfb\x9f\xff\x09\xc3\xf7\xea\x54\x0d\x91\x9e\x26\x49\x01\xd8\x12\x91\x5c\x94\x5e\x88\xcd\xb4\xc3\xca\xfc\xd8\xfb\xe8\xf4\x97\xd9\xfb\xb4\x57\x1b\xb4\xbc\xdc\xf4\x84\x59\xdd\x10\x80\x0d\x72\x93\xfd\x80\x6d\x85\xf1\x3b\xd1\x15\x2a\x1b\x83\x99\xe0\x3a\x65\x20\x06\x43\x78\x74\x8b\x3d\xc2\x87\x5f\xa9\x1f\x5d\xab\x75\x34\x40\xcf\xe3\xc3\x38\x0c\x42\xd0\xdf\xd3\x25\xac\xc8\xb0\xcb\x06\x8d\xed\x23\xf5\xb3\x8c\x2b\xc8\xcf\x52\x8a\xa3\x81\xa9\xea\xab\x4f\x6e\x5a\x5e\xdf\xc8\x91\xd9\xb1\xa1\xae\xb0\x36\xe6\x54\x7d\x04\x78\x57\x03\xef\x28\xf0\x4a\x66\xb8\x06\x85\x89\x41\xe6\x18\x33\x9d\x62\x9e\x6b\xa6\x66\xab\x22\x08\xd1\x37\xc6\xad\x8f\x7b\x24\x8e\xc5\xb9\xe2\x12\x4b\xe3\x12\x33\x1d\x53\x1c\xf4\x46\xc7\xf3\x8e\xaf\x1d\xe7\x1d\x62\xb3\x83\x4c\x71\xcc\x75\xd0\x72\x07\x89\x71\x64\x3a\xfa\x38\x98\xc5\x41\xa8\x43\xc8\xa9\xaa\xd4\xfc\xc6\xfc\x3d\x99\x95\x3c\x9a\x57\xfe\x1e\x7e\x3a\x34\x7f\xef\x94\x9e\x76\xe1\x9b\x1a\x98\x1f\x61\xe2\x80\xf6\x58\x91\x3f\x7c\x44\x4a\x76\x8f\xd0\x29\x31\xbd\xc6\x17\xa7\xb8\xf0\x3d\x4d\xc8\xd4\xb8\x5e\x63\xf6\x3c\x70\x2f\xfb\xe6\xd5\xad\xf4\xef\x72\x7d\x5a\x6a\x72\xc6\xa8\xa1\x5d\xf0\x4d\xcd\xb8\x21\xe9\x0b\x06\x9a\xd7\xac\x35\x69\xed\x7f\x10\xea\x32\x08\xdb\xc8\xc6\x4f\xc7\x6b\x11\x08\x7f\xd1\x46\x85\x60\x79\x14\x9b\xce\x83\x2a\x87\x3a\x4d\xfb\x4c\x74\x9f\xe9\x13\xd3\x29\x13\x73\x99\x46\x99\xa6\x9b\x98\x89\x9f\x0e\x97\xdd\xbd\x94\xff\xde\x1a\x9e\x58\x6a\x92\x85\x9c\xdd\xfc\x14\xba\x46\x50\x79\xa3\xad\x08\x24\xe7\xaf\x24\xf8\x29\xc1\x91\x60\xaf\xf9\x7a\x58\x02\xb9\xdf\x51\x76\x72\x15\x2d\xbc\x7a\xed\x5c\x36\x7d\xdc\xd8\x45\xf1\x73\x67\x80\xcd\xdc\x62\xfa\x74\x75\x53\x49\x61\xaf\x81\xbf\x74\x26\x8f\x44\xf8\x7b\x45\x2a\x81\x3c\x74\x3a\x85\x7f\xa1\x4e\xe3\x3e\x23\xdd\x67\xfc\xc4\x78\xca\xc8\x5c\xc6\x51\xc6\xe9\x46\x66\xd4\xe5\x31\xea\xf2\x18\x41\x9e\x3d\x17\xc8\x83\x56\xc6\x02\xe5\xa9\xa6\xab\xde\x62\x9f\x86\x05\xc8\x23\xdf\x6e\xba\xc5\xac\xde\xe8\x13\xa8\x4d\x9e\x50\x21\x4e\xe8\xe6\xb2\xc6\x86\x1b\xcc\x8a\x62\x15\x5c\xd6\xa8\x52\xc1\x15\x4e\xf8\xdb\xb9\xa7\xc2\xa3\x4a\xc3\xa3\xac\x60\x72\x1f\x66\x56\xee\xce\xb4\xf2\x17\x86\xa1\x3b\x7d\x63\x0f\x4c\x6a\x7e\x9b\x0b\xe4\x1d\x76\xd9\xa0\x49\xe5\xc9\xa6\xb1\x3d\xb8\xd5\xd9\xae\x5d\x13\xa0\x92\xac\xb4\x82\x7e\x85\x9a\xd5\xf9\x25\xe1\xba\x79\x43\xb7\xbb\x20\x18\xe7\x0b\x5c\xf1\x71\xd6\xa8\x30\xb3\xd9\x28\x8a\x51\x4e\xe7\x27\x51\xa7\xa2\x68\x43\xd4\x86\xa8\x4d\x51\xcc\x15\x45\xa2\x14\xdf\xeb\x4b\x7e\x72\x22\xc6\x88\xd3\xc2\x54\xf9\x24\x00\x01\xd2\x7d\x07\x98\x06\x9a\x55\xf4\x9c\xc6\xf1\xf2\x88\x81\xd7\x67\x8d\x1f\x91\x95\x3c\xa0\x6f\x51\x4c\x79\xfc\x94\x88\xc2\xf1\xfd\x52\x06\xf4\x2d\x74\xe4\x76\x37\x4f\x8d\x29\x18\x2d\x3d\x5d\x3f\x2d\x23\x73\xec\xeb\x87\xed\x11\xf6\xbe\xc5\x7d\x9c\xf0\x2b\x21\x6e\x50\x61\x3c\xca\xd8\x2c\x6e\xa6\x89\x72\x1a\xf6\xf9\x48\x97\x51\xe0\x9f\x28\x86\xb4\x04\x19\xb0\x43\xf2\xf7\x72\x7b\x3a\x19\x4b\x4a\x2f\x18\x4b\xe4\xb4\xf6\x63\x89\xe7\x27\x71\x33\x09\x69\xc3\xe5\x1f\xfe\x50\xa5\x25\xd8\x14\x88\xab\x8d\x23\x91\x3c\x92\x18\x22\x7f\x8e\xe3\xc8\x6b\x6f\x3d\x22\xd6\xbd\x40\x5b\xeb\x45\xa9\x09\x46\x91\xb1\xea\xf7\x1c\x96\xcb\xba\x12\x30\xbf\x92\x17\xeb\x63\x88\xc5\x20\x05\x6f\x80\xe1\x0f\xda\x4c\x76\xb4\xc0\xec\xee\x43\xde\x5d\xa9\x1d\xa9\x9d\xe7\x3b\x4b\x9b\x5c\x30\x86\xf4\x7b\x6c\xc2\x28\x65\x8a\xad\x6f\xb7\x92\x7e\x45\xa6\xb2\x0c\x56\xff\x1c\xac\xa8\x18\xaf\xc7\xe2\x59\x05\x43\x4d\x69\xd3\x98\x23\xa6\x8b\x7d\x54\x94\x3a\xca\x5f\x25\xe0\x7f\x0d\xf0\xaf\x97\x4f\xf2\x78\x08\x42\xb2\x2b\x34\x24\x26\x3e\xc2\x96\x6b\x22\x26\x93\x24\x0b\x2d\x06\x51\x1f\xc3\xa0\x19\xf3\xf7\xa0\x04\xcc\x5f\x33\xd2\xe9\x98\x50\xfb\xd6\xa3\x62\x0d\xd4\x74\x9e\x48\x3c\x3d\xf8\xa8\xd0\xc9\xdb\x5b\xe9\x80\x56\x7f\x52\xc7\x07\x85\xc0\xd7\xb7\x54\xdd\x06\xf2\x2c\xc2\x78\x00\x56\x21\xec\x19\x2a\x49\x16\x63\x8b\x59\xd6\xc2\x8a\xe5\x69\x27\x4f\xf3\x93\xff\xd1\x88\xc2\x90\x27\xad\x66\x44\xe4\x41\x00\x7a\x5f\x7f\xdb\xe2\x67\xa7\x2f\x8b\x5f\x3c\x4f\x0b\x07\xa0\x3e\xf3\xaf\xbf\xdd\x39\x7c\x84\xfa\x96\xa0\xe3\x8e\xf6\xe3\x82\x43\xd4\x11\xd7\x8e\x11\x0a\x02\x71\xa9\xfa\xb5\xb4\xf7\x69\x76\x6f\x00\x2c\x0f\x5b\x10\x00\x0b\xb8\x4f\x02\xee\x30\x9c\x03\xe2\x84\x7c\x57\xbc\x64\x30\x84\x06\x97\x0b\x55\x42\x03\x38\x5d\xb2\x1c\x93\xcb\x5f\x9f\xe7\x86\x9f\x0a\xa7\xe1\x2d\x51\x36\x64\x07\x03\x42\x5e\x0e\xb4\x27\x0c\x0b\x38\xbb\x5e\xd0\xa2\x01\x22\x74\x3d\xb8\x60\xaa\xa1\x21\xa2\xac\x70\xcc\xd0\x32\x73\x55\x88\x5f\x12\x25\xb3\xa5\x78\x6a\x50\xc6\x7c\x96\x92\x92\x15\x55\x1d\xef\xb9\xae\x4d\x24\xbf\x0e\x4f\xa2\x2f\x06\x36\x65\x15\xc3\xcc\x06\x41\x48\xe2\xcb\xde\x96\x84\x68\x14\x02\x47\x77\xad\x45\x3b\x1f\xdb\x03\x15\xf1\xd7\x8b\x35\xe4\xcf\x7e\x81\xe4\xec\x0e\x4d\xa9\x5e\xeb\x13\x89\x08\x87\xe5\x9e\x64\x0f\x8e\xa7\xf1\x2e\x8b\x48\x78\xe0\xc8\x72\x61\x83\x40\x4f\x69\x1f\x51\x2c\x74\xec\xb1\x6a\xc7\xc8\x12\xde\x75\x14\x72\xd5\x3f\x95\xbd\xb1\xb2\xdc\x73\x5f\xea\xc1\x44\xbe\xce\xdb\x02\xf7\xff\xe8\xbb\x5f\x60\xb2\xc2\x2e\x72\x3f\x8f\x1d\x60\x21\x5b\xe4\xf9\x7b\x95\xd3\x72\xcf\xc4\x83\xa9\xfb\x30\xe6\xcf\x99\xc0\xb8\x4f\x3c\xde\x17\x8f\xfb\xc4\xe3\x84\x79\x79\x30\xf7\x0b\xe3\x3f\xb5\x2f\xaf\x97\xeb\x24\x26\xd5\x29\x9a\xca\xca\x04\xd3\x56\x22\xd8\x89\x5d\xb0\x62\xbc\xa6\x8e\x65\xbe\xa0\x05\x2c\x53\x88\x76\x85\x50\x22\x84\x12\xca\xc3\x22\x85\xe9\x61\x91\x0a\x84\x4a\xed\xf9\xfb\x73\x6a\x33\x8f\x31\x64\x4b\x33\x9c\x41\x7e\x5f\x6a\xf1\xc3\x20\x7f\x45\xbb\xfc\xef\xe8\x6a\x3d\xff\x81\x76\xf9\xdf\xd2\x1b\x3b\x8b\xe3\x76\x69\xf1\xc7\x04\x59\x0d\x53\x9b\x49\x1f\xef\x77\x30\xa6\x73\x0f\x31\x47\xe8\x23\x14\x0b\x85\xae\xd8\x98\xc4\x44\xf0\x8e\x85\x22\xe2\x2a\xba\xb7\x88\x16\xa5\x87\x5b\x2c\xe9\x46\xc6\xd2\xfb\xf7\xcf\x4e\xc7\xb3\xed\xad\x7a\x88\x9b\xd0\xdd\xdc\x4b\x80\xb1\x3e\x3f\xb7\xbb\xd4\xc3\xbf\xa2\x48\x2b\x0c\x48\x2b\x01\xe9\xd4\x8b\xe4\x2b\xf6\x7c\xa6\x86\x75\x73\x26\x75\xeb\x96\xe4\xec\xf6\x99\x2f\x71\xa7\x2f\x41\xfb\x67\x6b\xa9\xec\x4c\x9e\xe8\x9e\xe4\xec\xba\xa3\xef\xfc\xbe\xd3\x9d\xdd\x7c\x25\xf0\xf7\x26\xfd\xf7\x99\x0e\x7f\xa7\x90\x29\xea\xbf\x04\x41\x54\x09\xd4\xd7\x0a\xf5\x65\xdc\x27\x14\x12\x84\x2e\xae\xf0\x84\x04\xbb\x10\x4d\x5c\xd1\xf7\x46\xd3\x68\x85\x87\x3b\x8e\x8f\x0f\x56\xfc\x95\xd4\x2b\x08\xb5\x83\x15\xc2\xaf\x4a\x4f\xc2\x48\x69\x38\xc9\xf4\xc9\xe3\x4f\x70\x39\xef\x9b\x37\xef\xb2\xce\x45\x0a\x90\x49\x11\xec\x20\x51\x32\x8c\x25\x8e\xe4\xe4\x48\x21\x8e\xb8\xe2\xee\x8d\xa3\x71\x41\x2e\x22\xcb\x4a\x8b\x28\x06\x25\x25\x59\x83\x7c\x82\x39\x76\x17\x59\x79\xe0\x55\x5d\x3a\x52\x88\xdf\x7a\xfc\xba\x84\x15\x11\xf3\xb9\x8c\x73\x22\xc9\xa3\x9d\x4a\xa9\x7e\xd3\x38\x6f\x5e\xe3\xd6\xce\x05\xa5\x42\x90\xf7\x1b\x71\x89\x1c\x03\x52\xe6\x42\xd7\xec\xd9\x8d\xa6\x87\x30\x45\xe6\xc3\x46\x7f\xca\xec\x11\x91\xf1\x54\x09\x61\xc9\x30\xad\x17\xf6\x67\x85\xac\x30\x45\x52\xd2\x98\xd3\x66\xcb\x2e\x0a\x1f\x79\xfb\xca\xa9\xf6\x50\xa5\xa0\x7a\xc4\xe8\xab\x2a\xfa\xbc\xf2\xd5\xe0\xa0\xf4\xbc\xd0\xf0\xc8\xd9\xb7\xef\x58\xd4\xf8\xe0\xcc\x98\xe8\xc8\x86\xf5\x2f\xcd\x3e\x1c\x4d\xb6\x93\x98\xd8\x77\xc8\xbb\xe3\x6f\x5e\x34\x21\xc6\x31\xba\xf1\x96\x29\xc3\xaf\x99\x5e\xd8\xb3\xea\x1a\xf6\x6f\xf5\xc5\xe9\xd6\xde\xd7\x6d\x98\x31\xff\xe9\x6b\x4a\x4b\x9a\x9f\x59\xb4\xe0\x89\xeb\x67\x24\x92\xde\x4b\x5f\x18\x77\xed\x58\x2e\xdb\x04\xef\xb7\xf2\xad\x52\x05\xb4\x6b\x77\x90\x0d\x54\x21\x31\x7d\x7d\x52\x68\xe7\xa1\xdc\x93\x61\xe1\x95\xac\xad\x64\x7c\x51\x1a\x79\xbe\xaf\x08\x49\x88\x96\xa6\x46\x7b\x6e\xb9\x2a\x7a\xf8\x84\xa6\xc7\x62\x96\x6c\x79\x30\xcc\xbe\x31\x5c\x61\x43\xd7\xcd\x5a\xfe\xd7\x90\x51\xf7\xcd\xb9\xfe\xe6\xf0\xe6\x27\xf1\xea\xa3\xb1\x4b\xc4\x77\xaf\xbe\xfa\x6e\xcf\x75\x4b\x0b\x87\x95\xff\xfb\x5e\x3a\xb5\xf5\xb1\x2a\x77\xd0\xea\x2e\x8d\x93\x97\x2e\x6c\xae\xe7\x31\xe1\xe9\x1a\xed\xe2\x8e\x7b\x69\x95\x26\x9b\x58\x86\xb2\x25\x04\xc8\xd6\x89\x68\x5c\x28\x92\x1f\x4d\xcf\x45\x7b\x1a\xf5\x68\xf3\x5b\x75\x41\xb4\x40\xf4\xcd\x1a\xe7\x2b\x31\xd8\x3c\x9d\xa6\x33\xd6\x02\xd1\xf3\x80\x84\x7c\xc4\x14\xc2\x52\x04\xc2\x2a\x60\x18\x30\x1a\x22\x80\x67\x8a\x77\x2b\xd0\xbe\x30\x22\x30\xd6\x87\xa7\xd9\x00\x4c\x97\x60\x7a\x08\xd2\x91\x98\x33\x11\x69\x25\xd0\x30\x21\xcc\x5b\x07\x33\x08\x83\xab\x29\x42\x21\xa6\x8b\xbc\x6b\x81\xf6\x86\xab\x29\x80\xc6\x73\x2a\x30\x3d\x19\xe9\x54\xb0\xdf\x14\xe5\x38\x94\xef\x02\x77\x1d\x06\x6a\x51\x7f\x06\x6a\x45\x9a\x02\xe5\x73\x30\x3f\x07\xd1\x72\x10\x2d\x07\xd0\xb6\x02\xed\xeb\x2d\x01\x3a\x95\x5f\x05\x84\xb5\x42\x3e\xf2\xcd\x47\x84\x7c\x44\xc8\x47\x84\x02\xb8\xf7\x30\xd0\x22\xa4\xbd\x91\xf6\x85\x92\x85\x82\x05\x10\x0a\x85\x50\xa4\x56\xa4\x71\x50\xbe\x50\x88\x47\x9a\x82\x34\x0f\xca\x17\x0a\x25\x78\x75\x30\xd2\x52\xa4\xc3\x41\xf2\x42\x18\x3f\x79\x7a\x3c\x96\x9c\x80\xe9\x49\x98\x9e\x8c\x74\x2a\xd0\x22\xe0\xc2\x69\x28\x70\x2c\x02\x2e\x3c\x1d\x07\x98\x45\xc0\x85\xd3\x14\x90\xbc\x48\x28\xc1\xab\xa5\x48\x87\x63\xfe\x18\x4c\x8f\xc7\xf4\x24\xa4\xbc\xa6\xbd\x01\x6d\x2b\xd0\x50\x4c\x5b\x31\x9d\x82\xe9\x12\xa4\xa5\x48\xb9\x6c\x7d\x51\x6f\x7d\xb1\x8e\x7d\xa1\x7c\x1d\x50\x2b\xa6\xe3\xe0\xae\xbe\xc0\x9d\x53\xce\xbd\x2f\xdc\xcb\xaf\x96\x62\x7a\x38\xde\x35\x06\xd3\x63\x91\x8e\x43\x3a\x09\xcb\x57\x00\x1d\xaa\x1c\x17\x86\x0b\xe3\x01\x79\x2d\x50\x2e\xc9\x78\x94\x64\x3c\xe6\x57\x60\x7d\x2b\xb0\xa6\x93\xb1\xcc\x64\x48\xaf\x15\xa6\x62\xfe\x54\x9e\xcf\xfa\xf0\x96\x62\x7d\xd8\x30\xef\xdf\x81\x8e\x41\x3a\xc1\x5b\x04\x74\xa2\xfa\x33\xd0\x49\xde\x1b\x80\x56\x62\xba\xd6\x7b\x18\x68\x03\xd2\xe5\x40\x5d\x60\x6f\x37\x03\xad\x04\x3a\x80\x0d\x14\x0e\x01\x05\xf9\x81\x0e\x41\x3a\x12\xe9\x34\xef\x5a\xa0\xd3\xa1\xfc\x00\x36\x03\x69\x35\xe6\xcc\x42\x5a\x8f\x39\x73\x91\x5e\x8e\x74\x3e\xd2\x85\x78\x75\x31\xd2\x65\x48\xaf\x12\xe6\x00\x5d\x09\xe9\xcb\x90\xef\x65\xc8\xb7\x04\xe5\x2f\x41\xf9\x4b\x50\xfe\x12\x94\xbf\x04\xe5\x2f\x41\xf9\x4b\x50\xfe\x12\x94\xbf\x04\xe5\x2f\x41\xf9\x4b\xb8\xb5\xb3\xc1\x60\xa5\xe7\x80\x5a\x39\x85\x5a\xbc\x0d\xb4\xc4\xdb\x0f\xe8\x10\xa4\x23\x91\xce\xf5\xde\x0b\xf4\x2a\x61\x1a\x1b\x82\x1c\x87\x20\xc7\x21\xc8\x71\x08\x72\x1c\x82\x1c\x87\x20\xaf\x61\x80\xf0\x25\xd0\x21\x48\x47\x22\xe5\x32\x0f\x43\x99\x47\xc0\xbd\xf7\x00\x1d\x83\x74\x92\xf7\x1a\xa0\xd3\xbc\x9f\x03\xad\x46\x3a\x0b\x69\x1d\xd2\x39\x48\x17\x20\x5d\x88\x74\x31\xd2\x65\x48\xaf\x44\xba\x12\x69\x0b\xd0\x91\xdc\xd2\xd8\x48\x94\x6d\x24\xca\x36\x12\x65\x1b\x89\xb2\x8d\x44\xd9\xc6\xc0\x18\xf2\x25\xd0\x12\xa4\x43\x90\x8e\x44\xca\x25\x1c\x83\x12\x8e\x43\x9d\x8c\x43\x9d\x8c\xc3\x36\x1d\x87\x6d\x3a\x0e\xdb\x74\x3c\x5b\xe2\x7d\x89\x4d\x00\x2b\x1a\x0c\x34\x14\xa9\x15\x29\xf4\x59\xa0\xf1\x9c\xa2\x3d\x4c\xc0\x7b\x27\xe0\xbd\x13\x40\xaa\xc3\x40\x47\x62\x7a\x0c\xa6\x27\x21\x9d\x82\x74\x1a\x47\x60\x55\x48\x67\x62\x99\x6a\x4c\xd7\x7a\x1f\x06\x3a\xcb\xfb\x02\xd0\xd9\x98\x53\x8f\x57\xe7\x7a\x4f\x01\x9d\x8f\xe9\x06\x2c\xb3\x10\xaf\x2e\x46\xba\x14\xf3\x97\x61\x7a\x39\x5e\xbd\xc2\x3b\x01\x28\x6f\xc1\x09\x6c\x05\x5e\x5d\x89\x57\x9b\x21\x3d\x11\xeb\x32\x91\xf7\x4d\xa0\x56\x4c\x43\xdf\x04\x1a\xcf\x29\xd6\x65\x22\xd6\x65\x22\xd6\x65\x22\xd6\x62\x22\xda\xf6\x44\xb4\xed\x89\x68\xdb\x13\xd1\xb6\x27\xa2\xa5\x4d\x44\x0b\x9f\x88\x16\x3e\x11\x2d\x7c\x22\x5a\xf8\x44\xb4\xf0\x89\x68\xe1\x13\xd1\xc2\x27\xa2\x85\x4f\x44\x0b\x9f\x88\x16\x3e\x09\x78\x3d\x01\x94\xb7\xc8\x24\x6c\x91\x0a\x68\xeb\xc3\x40\x5b\x80\x4e\x06\xbe\x87\x80\x56\x23\x9d\x85\x74\x21\xd2\xc5\x48\x97\x21\xbd\x12\xe9\x4a\xa4\x2d\x40\xa7\x20\xda\x14\x44\xab\xc4\x1a\x55\x62\x8d\x2a\xb1\x46\x95\x58\xa3\x4a\xac\x51\x25\xd6\xa8\x12\xeb\x52\x89\xb5\xa8\xc4\x5a\x54\x62\x2d\x2a\xb1\x16\x95\x58\x8b\x4a\xac\x45\x25\xd6\xa2\x12\x6b\x51\x89\xb5\xa8\xc4\x5a\x54\xb1\x26\xef\x1b\x6c\x16\x6a\x63\x16\x6b\xf4\x1e\x00\xba\x04\xe9\x72\xef\x6b\x6c\x36\x5e\xad\x03\x8e\xff\x00\x5a\x05\xbd\xa0\x0e\xf8\xae\x01\x5a\x8d\x39\xb5\x50\xa6\x0e\xb8\x73\x3a\x1b\xaf\xd6\xe3\xd5\x39\x98\x33\x17\xd3\x0d\x98\x5e\xe8\x2d\x06\xda\xe8\xbd\x11\xe8\x62\xbc\x77\x09\xa6\x97\xe2\x5d\xcb\x30\xe7\x4a\xa4\x57\x09\x0b\x81\xae\xc4\x74\x33\x5e\x6d\x81\xf4\xe5\xd8\xfb\x2e\xc7\xde\x77\x39\xf6\xbe\xcb\xa1\xf7\xbd\x06\x74\x01\xd2\x85\x98\xd3\x84\xe9\xc5\x98\x5e\x86\xf4\x4a\xa4\x2b\x91\xf2\xde\x37\x0f\x70\x8e\x01\x9d\x09\xbd\x63\x1e\xa0\xf1\xf4\x2c\xa4\x75\x48\x17\x20\x5d\x88\xb4\x09\xe9\x62\xa4\x4b\xb1\xfc\x32\xef\xfb\x40\xaf\xc4\x9c\x15\x98\xb3\x12\xd3\xcd\x98\x6e\x81\xf4\x02\xc4\x5f\x80\xc8\x0b\x10\x79\x01\x22\x2f\x40\xe4\x05\x88\xbc\x00\x91\x17\x20\xf2\x02\xc0\xe4\x94\xe3\x2c\xc4\x56\x58\x08\x5a\xe2\xe9\x25\x48\x79\x2b\x34\x22\x66\x23\x62\x36\x22\x66\x23\x62\x36\x22\x5a\x23\xa2\x35\x22\x5a\x23\xa2\x35\xa2\x84\x8d\x28\xcf\x22\x6c\xd3\x45\xd8\xa6\x4b\x10\x67\x09\xe2\x2c\x41\x9c\x25\x88\xb3\x04\x71\x96\x20\xce\x12\xc4\x59\x82\x38\x4b\x10\x67\x09\xe2\x2c\x43\xd9\x96\x21\xda\x32\x44\x5b\x86\xb2\x2d\x07\xcc\x8f\x80\x56\x23\x9d\x85\xb4\x0e\xe9\x42\xa4\x4d\x48\x17\x23\x5d\x86\xf4\x4a\xa4\x2b\x91\xb6\x00\xbd\x12\x91\xaf\x44\xe4\x2b\x11\xf9\x4a\x44\x5e\x89\xf9\x2b\x31\x7f\x25\xe6\xaf\xc4\xfc\x16\xcc\x6f\xc1\xfc\x16\xcc\x6f\xc1\xfc\xad\x30\x3e\xe4\x03\xb5\x22\x9d\x07\xb6\xb7\x55\x58\x01\xf4\x39\x98\x41\xe2\xd8\xf3\x40\xcb\xd8\x2b\xec\x35\x21\x12\xe8\x2e\xef\x83\x40\xf7\xc2\xd5\x57\xd8\x3e\xef\xdb\x40\xf7\x63\xfa\x00\xdc\xfb\x0a\x3b\x88\x25\x0f\x79\x1f\x00\xfa\x1e\xa6\x3f\xc6\xf4\x51\x18\x81\x5f\x61\x27\x90\x9e\x44\xfa\x3d\xd2\xb3\x48\x7f\xe0\x14\xb8\x4c\x67\xaf\xb2\x57\x60\x24\x7c\x95\xbd\x06\xb2\xbd\xca\x5e\x47\xba\x0b\xe9\x6e\xcc\xdf\x8b\xe9\xfd\x48\x0f\x78\x97\x02\x3d\x08\xdc\x5f\x05\x8e\x6f\x03\x7d\x07\xcb\xbc\x87\x39\x87\xf1\xea\xc7\x80\xfc\x2a\xfb\x04\xf3\x3f\x03\xf9\x5f\x05\x8e\x70\xaf\x28\x40\x7a\x07\xf2\xda\x81\xbc\x76\x00\x2f\x9e\xde\x85\xe9\xdd\x48\xf7\x22\xdd\x8f\x94\xf3\xda\x81\xbc\x76\x00\x2f\x9e\xf3\x0e\x96\x7f\xcf\xfb\x1c\xd0\xc3\x50\xf7\x1d\xc0\x85\xe7\xf3\x1a\xed\x60\x3f\xe2\xd5\x9f\x81\xee\x44\xdd\xee\x44\xdd\xee\x84\x51\xf7\x00\xd0\x78\x28\xb3\x13\xf5\xbc\x13\xf5\xbc\x13\x24\x99\x0e\xf4\x35\xd0\xed\x4e\x90\x01\xae\x62\x7d\x77\x82\x0c\x9c\xee\x47\xca\xf1\x77\xb2\x4f\x31\x7d\x0c\xb4\xba\x93\x7d\x86\xf4\x04\xde\xf5\x25\xd2\x6f\x90\x7e\x8b\xf4\x3b\xa4\x27\x11\xff\x34\xa6\xcf\x22\x6d\x45\xea\xc1\x7b\xbd\x9c\x8a\x02\xd0\xd7\xa0\x2e\x5f\x02\xfd\x18\x34\xf3\x1a\xfb\x42\xc8\x06\x7a\x16\xd2\xff\x46\x79\x5e\xd7\x29\xd7\xc9\xeb\xa8\x93\xd7\xa1\x3c\xa7\x87\xa1\xcc\xeb\x58\xeb\x5d\x20\xff\x0b\x40\x5f\x47\xba\x1b\x29\x2f\xbf\x0b\xcb\xef\x02\x1d\x3e\x00\xf4\x20\xd2\x43\x98\xc3\xb5\xb7\x0b\xeb\xb5\x0b\x24\xff\x92\xbd\x05\xe5\x39\xdd\x8f\x94\xb7\xe9\x5b\xd8\x82\x6f\x21\xfe\x5b\x4c\x05\xba\x9b\x1d\x02\x8e\xbb\xd9\x51\xa0\x7b\x50\x86\x3d\xec\x53\x4c\x9f\x45\xfa\x33\xe6\xa8\x90\xde\x0b\x5a\x3d\x00\xf4\x35\xe0\xb2\x17\xa5\xda\x8b\x52\xed\x05\x19\x96\x02\x7d\x07\xd3\xef\x21\xfd\x04\x4b\x72\x19\xf6\x42\xdb\x1d\x60\x6f\x83\x87\xf0\x0a\x50\x2b\xd2\x38\xc8\x7f\x1b\x5b\xed\x6d\x68\xaf\x17\xd8\xdb\xd8\x5e\x6f\x03\x32\xa7\xaf\x83\x3e\xdf\x46\xcb\x79\x1b\xf0\x97\x02\xdd\xc3\x4b\x42\x7d\xd7\x00\xe5\xf5\x7d\x1b\xea\xc2\x73\xde\xc1\xf4\x27\x98\xfe\x0c\xe9\x09\xa4\xbc\x47\xbc\x0d\xad\xf0\x25\xdb\x8f\x36\xb9\x1f\x35\xb9\x1f\x75\xbe\x1f\x65\xde\x8f\x98\xfb\x51\x3f\xfb\x01\x99\xe7\x70\x6b\xdc\x0f\x98\x07\x80\xbe\x07\x32\xec\x47\x9b\xdf\x8f\xda\xd8\x8f\x1a\xdb\x8f\xda\x38\x00\x16\x58\x06\xd4\x8a\x94\xd7\xe5\x00\xd6\xe5\x00\xf2\x3a\x80\xf6\x0f\x2d\x09\x77\x1d\x40\x8e\x07\x90\x23\x68\x11\x73\xf6\xe2\xd5\x43\x98\xf3\x31\x5e\xfd\x04\xf3\x3f\xc5\xfc\x63\x98\x7f\x02\xe9\x97\x48\xbf\x46\xfa\x0d\xd2\x6f\x91\x9e\x44\x7a\x0a\xe9\x69\xa4\xdf\x23\x3d\x8b\xf4\x47\xa4\xe7\x90\xb6\x22\xf5\x20\xf5\x72\x0a\x3a\x79\x81\x1d\x04\xf9\xa7\x03\xb5\x22\xe5\x3d\xe8\x20\xc8\x0f\x14\xe5\x3f\x88\xba\x3a\xc8\x76\x81\x54\x07\xb1\xe7\x1e\x44\x6d\x1f\x44\x4b\x3e\x88\xd2\x1e\x04\x39\x79\xfe\x71\xa4\x9f\xe1\xd5\x13\x98\xfe\x1c\xd3\x5f\x20\xfd\x12\xe9\xd7\x48\xbf\x01\x9b\x39\x08\xf2\xf3\xf4\x77\x48\x4f\x62\xf9\x53\x98\x3e\x8d\xf4\x7b\xcc\xf9\x11\xd3\x3f\x21\xfd\x05\xe9\x39\xa4\x5e\x4e\xb1\x4d\x0f\x81\x9c\x6b\x80\xbe\x06\xad\x73\x08\x24\xe4\xe9\x3d\x98\x7f\x00\x6a\x74\x08\xc7\xcc\x43\x68\xd5\x87\xb0\x47\x1c\x42\x6b\x3c\x04\x32\x1c\x60\xef\x60\x8b\xbc\x03\xad\xf0\x1c\xd0\xfd\x48\x79\x5b\xbc\x83\xf2\xbc\x83\xa3\xd9\xbb\xd0\xe2\x25\x40\x4f\x40\x9f\x7d\x97\x9d\x04\xfa\x01\xe4\x70\x7a\x02\x30\x3f\xc0\x7e\x71\x18\xc7\xc0\xc3\x38\x9e\x7f\x04\xf2\x3c\x08\x94\xb7\xfb\x47\x60\xbd\x6b\x80\xee\x82\xab\x1f\xa1\xf6\x3e\x02\xd9\x38\xdd\x0b\xb6\xfa\x11\x70\xe4\xf4\x00\xde\xf5\x0e\x96\x7c\x0f\xc6\xb1\x8f\xc0\x12\x78\xf9\x4f\xf8\x55\xc0\x94\xd9\xc7\xd8\xcb\x3e\x06\xb4\xb7\x81\xee\x86\xfc\x8f\xd9\x5e\xe0\xfb\x31\xd4\x2b\x1b\xe8\x3b\x78\x95\xd7\xeb\x63\x18\x87\x79\xce\xe7\x78\xf5\x5b\x4e\x71\x34\x3e\x82\x52\x1d\x01\x9c\x35\x40\x79\x6f\x3d\x82\xba\x3a\x82\x36\x7f\x04\xc7\x84\x23\x38\x0e\x1f\xc1\x9e\x7b\x04\x24\x79\x80\x7d\x0a\x6d\x07\xb6\x88\x3d\xf7\x53\x6c\x9d\x4f\xd1\xae\x3e\x05\xcb\x5f\x0a\x94\x8f\x18\x47\x71\xe4\x3f\x8a\x6d\x7d\x14\xb5\x7a\x14\xf5\x76\x14\x6d\xef\x28\x8e\xd2\x47\xd9\x79\x4e\xb1\xbd\x8e\xa1\x6d\x1f\xc3\x39\xeb\x18\x58\x0b\x4f\x9f\x40\xfa\x39\xd2\x2f\x90\x72\x0b\x3f\x06\x16\xc2\xd3\x27\x91\x7e\x8f\xf4\x0c\xde\x75\x16\xaf\xfe\x80\x39\x3f\x43\x2d\x8e\x01\xfe\x03\xec\x18\xe0\x1f\x60\xc7\x01\xff\x4b\xa0\x9f\x21\x3d\x81\xf4\x0b\xa4\xdf\x20\xfd\x16\xe9\x49\xa4\x7c\x96\x3c\x8e\x77\x7d\x86\x3d\xfa\x04\xde\x7b\x02\xef\x3d\x81\x35\x3a\x81\xf7\x9e\x40\x79\x4e\xe0\xbd\x27\xf0\xae\x13\x28\xc9\x09\x94\xe4\x04\xce\xb0\x27\xa0\xbe\x0f\x02\xe5\xf2\x7c\xce\xce\x80\x4e\x3e\x47\xdb\xf8\x1c\x47\x89\xcf\xd9\x79\x48\x7f\x81\xf8\x5f\x60\xdd\xbf\x40\x2e\x5f\xa0\x84\x5f\x20\xaf\x2f\x50\x7b\x5f\x20\x97\x2f\x50\xc2\x2f\xb0\xd6\x5f\x20\x97\x2f\x90\xcb\x17\x88\xff\x05\xea\xf3\x6b\x1c\xa5\xbf\x46\x79\xbe\x46\x8e\x5f\x23\xaf\x6f\xb0\x2e\xdf\xa0\xe6\xbf\x45\xf9\xbf\xc5\x32\xdf\x62\xfe\xb7\x88\xf3\x2d\xb6\xdd\x49\xd4\xf9\x49\x2c\x73\x12\xb9\x9f\x44\x5e\x27\x71\x94\x3e\x09\x08\x0f\x00\xc5\x92\xa8\xa5\xd3\x28\xe7\x69\x2c\x7f\x1a\xcb\x9f\x46\x69\x4f\xe3\x5d\xa7\xb1\xc5\x4f\xe3\x5d\xa7\xf1\xae\xd3\xd8\xe2\xdf\xe3\x5d\xdf\x23\xf7\xef\x11\xf9\x7b\x94\xed\x7b\xa8\xc5\x01\x90\xdb\x02\xf9\x67\x60\xfc\x01\x8a\xfa\x39\x83\x9a\x39\x83\x77\x9d\x41\x5e\x67\x90\xd7\x19\xe4\x75\x06\x35\x73\x06\x47\x89\x33\x58\xaf\x33\x68\x6f\x67\x90\xe3\x19\xe4\x78\x16\x30\x97\x02\xb5\x72\x0a\x5a\xca\x06\xca\x7b\xc4\x59\xb4\x81\xb3\x38\x7f\xfd\x80\xda\xfb\x01\x7b\xf1\x0f\x88\xff\x03\xf4\x6e\x9e\x3e\x8b\x69\x5e\x8b\x1f\x51\x9e\x1f\xb1\x8d\x7e\x44\x49\x7e\x44\xee\x3f\x22\xdf\x1f\xd1\x02\x7f\xd4\x4b\x72\xee\x3f\xe1\xec\xf0\x13\xb6\xfb\x39\x4c\x9f\x83\x74\x36\xf3\x40\x99\x32\xa6\x62\x8d\x54\xe4\xa5\x82\x1e\xde\x66\x2a\x4a\xeb\xc5\x7c\x2f\xe6\x7b\x51\x87\x5e\x8e\x29\x5a\xa0\x16\x6b\x80\x5a\x81\x0e\xc0\xf4\x00\x3d\x3d\xcf\x7b\x00\xe8\x0a\xef\x01\xe5\x98\x72\xcc\xbb\x55\x39\x0e\x2b\xf7\xb5\x40\x27\x78\x61\x0c\xe2\xcf\x25\x94\x2f\xd9\x16\xaf\x0c\xf4\x05\x6f\x1c\xd0\x03\xea\x77\x40\xdf\x53\xdf\x05\x7a\xd8\x1b\x27\x08\x42\x3c\x99\xcf\x9f\x15\xe2\xbf\x09\xc2\xe3\x7a\x9a\x08\x16\x92\xaa\xa7\xa9\x20\x93\x81\x7a\x9a\x09\x0e\xd2\xa2\xa7\x45\x21\x82\xbc\xa1\xa7\x25\x21\x84\xa8\x7a\x5a\x16\xc2\x69\x91\x9e\x56\x84\x2b\xd8\x20\x3d\x6d\x10\xc2\xd8\x57\x7a\xda\x28\x84\x88\x71\x7a\xda\x44\xea\xf1\xb4\x2e\xfe\x2f\x48\x88\x35\x3c\xa0\xa7\xcd\x42\x37\x63\x82\x9e\x0e\x16\x0a\x8c\xcf\xe9\xe9\x10\xc1\x61\x4a\x03\x49\x88\x68\x84\xbf\x1e\x45\xa9\x78\x9a\x40\x5d\x24\x3d\x4d\x05\x33\x29\xd0\xd3\x4c\xe8\x41\xca\xf4\xb4\x28\x64\x91\xf5\x7a\x5a\x12\x62\xc9\x27\x7a\x5a\x16\xba\xd2\x60\x3d\xad\x08\x67\x69\xb9\x9e\x36\x08\x19\xec\x65\x3d\x6d\x14\x62\x99\x57\x4f\x9b\xe8\x7e\x31\x4b\x4f\x07\x09\xbd\x0c\x73\xf4\xb4\x59\x98\x6a\x78\x45\x4f\x07\x0b\x73\x8c\x23\xf5\x74\x88\xd0\xc3\x78\x4a\x28\x11\xea\x85\xd9\xf0\xd3\x04\x3f\x57\x08\xb5\x42\x8d\xe0\x84\x9f\x19\xf0\xf7\x0c\x48\x55\x0b\x0d\xc2\x02\x61\xb9\xd0\x88\xa5\xea\x20\xd7\x29\x64\x40\x6e\x17\xf8\x9d\x27\xe4\x0a\xdd\xe1\xc7\x29\x0c\x81\x52\x0d\x70\xfd\x72\xb8\xdf\x29\x0c\x84\x74\x23\xdc\xc5\xe9\x0c\xc4\x6d\x10\xe6\x0b\xdd\x04\x13\x5e\xf9\x75\xb4\x3c\x48\x8d\xd1\xa5\x28\xc5\xbb\xb3\x20\x35\x14\xee\xaf\x06\x04\xa1\xa4\x7e\x76\x7d\x53\xfd\x15\xb5\x35\xce\x9a\x19\x4d\x33\x9c\xd5\x0d\x0b\x96\x37\xd6\xcf\xae\x6b\x72\x66\x54\x77\x71\xe6\xe5\x76\xcf\x75\x0e\x69\x68\x98\x7d\x79\xad\x73\x60\x43\xe3\x82\x86\xc6\x19\x4d\xf5\x0d\xf3\xbb\x99\x06\x76\x2c\x96\xe7\x1c\x03\x10\xa5\x33\x9a\xb2\x9c\x43\xe7\x57\x03\xee\x70\x10\x68\x26\xb0\x0d\x14\xd8\x29\x8c\x85\xbf\xe6\x0b\x8b\xe0\x72\xfd\xcc\x5a\x0d\xcc\x39\x76\xc6\x7c\xc8\x18\x8a\xea\xb9\x1c\x4a\x56\xc3\x1f\x4d\x33\x2e\xaf\x87\xdf\x03\xa0\x68\x35\x80\xcc\x07\xe9\x39\x94\x53\xc8\x86\x9f\xdf\x80\x1e\xb0\xa8\xba\x76\x7e\x4d\x6d\xa3\x33\xdb\x79\x01\x97\x5f\xbf\xd5\xd9\x5e\x8a\x0e\x77\x3b\x7d\x52\x4d\x40\x80\x45\xfe\xdb\xf3\x40\x8f\xb9\xf0\xbf\x1b\x7f\x17\x31\xa1\xb6\x71\x11\xbf\x23\xaf\x5b\x6e\x6e\xb7\xee\x9d\x73\xf4\xf1\xcb\xbe\x18\x3f\xce\x2e\xdb\xc7\xae\x73\x99\xeb\x51\x5e\x6e\x50\x4d\x78\x85\x2b\x68\x1e\xfc\x6e\x14\xe6\x42\x5e\x83\x30\xeb\x57\x9b\xdd\x09\xe5\x6a\xd1\x48\x17\xc1\x95\x5a\xfc\xab\x06\x51\x39\xf6\x78\x28\x31\x16\x4b\x8d\xc2\x3b\x79\x03\x34\x21\xb7\xf9\x58\x6a\x5c\x27\x1c\xcb\x81\xe3\x2c\xac\x47\x6d\x40\xc9\x6a\xc4\xe6\x75\xd4\x90\x1b\x20\x5d\xa7\x37\xe5\x1c\x61\x31\x9a\xed\x22\x28\xc9\xef\xf3\xd5\x6d\x11\x37\xcb\x00\xdd\xd7\x2f\x72\xce\x70\x36\x35\xce\xa8\xa9\x9d\x37\xa3\x71\xae\xb3\x61\x56\x7b\x53\x73\x36\xd6\xce\xae\x5f\xd4\x54\xdb\x08\x99\xf5\xf3\x9d\xe3\xbb\x8d\xed\xe6\x1c\x35\xa3\xa9\x76\x7e\x93\x73\xc6\xfc\x1a\xe7\x38\xff\x8d\xe5\xb3\x66\xd5\x57\xd7\x62\x66\x75\x6d\x63\xd3\x0c\x28\xdc\xd0\x54\x07\x76\x32\x67\x71\x63\xfd\xa2\x9a\xfa\x6a\xce\x6d\x51\xb7\xce\xac\xae\xf3\xfe\xd7\x66\x69\x01\x7d\x43\x00\xcd\x71\x8d\x2d\x41\x3d\x8c\xc0\xe2\xfc\xef\x45\xda\x2d\x63\x9b\x6a\x97\xd4\x3a\x47\xcc\x68\x6a\xaa\x5d\xc4\x0b\x5f\x06\x05\x16\xe9\xca\xd7\x1a\x76\x00\x2a\x65\x1e\xfc\xc5\x1b\xec\xff\x63\xef\x4d\xe0\xa4\x28\xce\xff\xe1\x3a\xfa\x1c\x96\x53\x54\x44\x54\x34\xc4\x13\x91\xed\xee\x99\xdd\xf1\xde\xa3\x5b\x45\x14\xa2\xa0\x88\x17\xc3\xee\xc0\xae\xec\xee\x2c\x7b\x70\x78\x5f\x31\x1e\xe0\x15\x63\x0c\x31\x46\x0d\x51\x44\x63\x8c\xa2\x31\x4a\x8c\xb7\xa8\x78\x22\x5e\x88\xa2\xa0\x82\xa2\xa2\xa2\xe2\xc5\xbe\x4f\x57\x7f\x77\xa6\x77\x58\x0c\x26\xff\xfc\xde\xfc\xde\xf7\x0f\x9f\x3a\xbb\xea\xf9\x3e\xf5\x54\x75\x7d\x9f\xea\xe9\xd9\x99\x4e\xe6\x0a\x8d\x53\xa7\xf2\x19\x35\xe9\xb5\x4a\x5c\x78\xbf\x37\xa1\xe7\x44\xda\x01\x06\xff\x20\xf0\x60\xf4\xcd\x60\xf1\x34\xd1\xff\x1c\xb5\x8d\x46\x13\xf6\x19\x8a\x45\x31\x49\xc5\xad\x0a\xb7\x89\x30\x06\x53\xbe\xf3\xf6\x68\x55\xf6\xa8\x57\x8b\x2b\xae\xc5\x60\x35\xad\x19\xb5\x48\xa2\x85\xd9\x48\x57\xdb\x54\xdb\x1a\xb5\xc0\x1b\x94\x86\xe1\xde\xd7\x48\x76\x8c\x50\x27\x62\x77\x9b\xae\xf6\xca\xba\xfc\xd8\xa9\xfd\xce\xbb\xa8\xe5\x57\xb0\x45\xb4\xa4\x27\xe1\xce\x1b\xac\x6a\x9b\x29\x9f\x53\xba\x77\x5a\x6f\x6f\x35\x73\xa1\xfe\x59\xa5\x55\x98\xcb\xa8\xbd\x77\x22\xf5\x68\x50\x38\x91\x1e\x75\x6a\xe1\x66\xd4\xb2\xcb\x62\x19\xb6\x29\x6d\x5b\x63\xcb\x37\x5a\xac\x83\x95\xc6\xa1\x74\x5f\x2d\xd9\x70\xc7\xcd\xc2\x92\xc7\xd2\x4e\x3d\xb2\x5b\x89\x91\xb5\xe2\xb7\x4d\x38\x13\x0d\x4a\xdf\xd6\x98\xec\x26\xa5\x6d\xad\xaa\xcb\xe5\x2d\x1b\xb6\x6a\x00\x52\x34\xe2\x06\xc5\x08\x53\xf2\xb3\x32\x49\xad\xc6\xc8\x7a\xb5\x4a\xda\xde\x9b\xb1\xef\x24\x65\x9b\x36\xa0\xe6\x94\x46\xb5\xf4\x3f\x9a\xe7\x68\x45\xe5\xa8\x6f\xbb\x9a\xb5\xe8\x56\x8f\xd6\x7a\xdb\x26\x96\xcb\x28\xfb\xe6\xd0\xaf\x99\xae\x84\x58\x91\x2e\x8d\xd1\xad\x5b\x99\x69\xa5\x5b\x91\x6e\xdc\x8a\x96\xfa\xc6\xdc\xd0\xc1\xd3\xeb\xea\x6b\xea\x06\x4f\xcf\xb4\x0e\xae\xcd\xb6\xd6\x4f\x6e\xa2\x8b\x13\x67\x0e\xee\x7a\x23\x0c\xa6\xab\x19\xba\xd5\x9b\x9a\x72\xd3\xe8\x36\x9a\x96\x1d\x4a\xb7\xf5\xa4\x96\x6c\x6b\x5d\x7d\xd3\xe4\xc1\xad\xe1\xee\xdb\x9a\x6d\xa9\x9f\x04\x11\x83\xdb\xea\x32\x6d\xe1\xc6\xd0\x98\x6d\x6b\xa9\xaf\xc9\x34\x34\xcc\x24\xe6\x6a\x6c\xa6\xae\x13\x89\xaa\xa6\xd7\xb7\xd5\x85\xe8\x99\x86\xf9\xc3\x22\x2d\x68\xd7\x98\x44\x1b\xf3\xe0\xfa\xc6\xe6\x96\xdc\x34\xa5\xde\xde\xad\x35\x2d\xd9\x6c\x13\xe1\x64\x6a\x33\x13\xeb\x1b\xea\xdb\x48\x46\x5d\xa6\x25\x53\x43\x7b\x09\x6d\x28\xf5\x35\xad\x6a\xaf\xa0\x2d\x62\x70\x73\xa6\x69\x6f\xbf\xbd\x25\xd7\x9c\x25\x25\x8f\x3d\x64\x64\xa1\x21\xa9\x15\xed\x33\xad\xb9\x86\x69\xd9\x56\xd5\xba\x29\x9b\xad\x6d\x0d\xf7\xa9\x5a\x1a\x62\x03\x75\x22\xe0\x86\x5c\x6e\x4a\x38\x94\x49\xb9\x16\x52\xaf\xb6\xad\x6e\xef\x98\xbe\x93\x72\x4d\x6d\xd4\x35\x37\x38\x53\x5b\x4b\x63\x26\x43\xe5\x6a\xda\x1b\xc3\x1d\x8c\x76\x95\xb6\x4e\xe5\x32\x35\x2d\x39\xba\xd6\xdc\x90\x69\x23\x29\x8d\xe1\x4e\x55\xa7\xee\xf1\x66\xb6\x2f\xdb\x87\xfe\x4f\x57\xff\x87\xa9\x3b\x3d\xbe\x7f\xd5\x60\xf7\x1a\x86\xf5\xb1\x0f\x75\x6c\x6b\x6b\xde\x77\x9f\x7d\xa6\x4f\x9f\x3e\x2c\x83\x4d\xac\x86\xf6\xb0\x61\xa4\xd4\x3e\xff\xba\xd8\x70\x89\x34\xab\xc5\x1c\xdf\xa0\x5a\xd4\xb2\x08\x65\x36\xd2\x72\xf9\x41\xe8\xb6\x99\xcd\x59\x2c\x92\x96\xd6\x61\x75\x6d\x8d\x0d\x11\xfd\x45\xb0\x9d\xfb\x64\x7b\x6c\x67\xee\xbc\x8b\x8e\x26\x6a\x1b\xa9\x68\xa8\x19\xf7\x7e\x80\x55\x3f\xb8\x48\x42\xb8\xcf\x15\x33\x78\x69\xc4\xdd\x23\x89\x1f\x9a\xc2\xc5\xdb\xae\x76\xf5\x70\x2e\x8f\x3e\x6c\xe4\xe0\x51\xcd\xb4\x4c\x02\x9a\xa3\xc1\x68\x30\x74\x70\x27\xcb\x97\x86\x14\xdf\xd5\x5c\xd1\x0e\x54\x4f\xe5\x36\x35\xf0\x56\x75\xff\x0c\x53\xc6\x9a\x4c\xd7\x47\x91\x66\x23\xf3\x66\xa0\x45\x58\xdf\xdc\xd6\x3a\xac\xb5\xbe\x61\x58\xae\x65\xf2\x3e\xa3\x82\x91\xca\x17\x67\x1d\xeb\x29\xec\xc6\xae\x66\xdd\xfc\x4b\xec\xa0\x7c\x77\x41\x5e\xa7\x46\xfe\xad\x41\xbe\xac\x45\x7e\x6b\x82\x7c\xd4\x12\xf2\x47\x7b\xb1\xde\xac\x0f\xeb\xcb\xfa\xb1\xad\x58\x7f\xb6\x35\xdb\x86\x6d\xcb\x06\xb0\xed\xd8\x40\xb6\x3d\x1b\xc4\x76\x60\x3b\xb2\x9d\x68\xcc\x3b\x87\x6f\x01\xb2\x21\xec\xa7\x6c\x57\xb6\x1b\xf9\x8c\x7b\xb0\x3d\xd9\x5e\x64\x9d\xbd\x49\xd7\x7d\xe0\x39\xba\xcc\x63\x49\x96\x62\x65\xac\x9c\xa5\x69\x7c\xfb\xb1\xfd\xd9\x01\xec\x40\x76\x10\x3b\x98\xf6\xe6\x4a\xe2\xc5\x6a\xda\x13\x03\xda\x03\x0f\x25\xfb\x8f\x60\x87\xd3\xc8\x8e\x60\x47\xd2\x18\x47\xb3\x9f\x91\xfb\x71\x34\xb9\x0a\x63\xc9\xda\xc7\xb2\x71\xec\x38\x36\x9e\x1d\xcf\x4e\x60\x27\xb2\x93\xd8\xc9\x6c\x02\xcb\x70\xc1\xfe\xc0\xce\x67\x3f\x67\x7f\xa7\x51\xae\x66\x17\xb0\x4b\xd9\x25\xec\x77\xec\x16\x36\x97\x4b\x76\x31\xd7\xd8\x79\xec\x97\xec\x33\xf6\x39\x9b\x4d\xfe\xfe\x85\xdc\x60\x6f\xb2\x4f\xd9\x75\x6c\x3e\xfb\x82\xad\x67\x5f\xb2\x1b\xd9\x9f\xd8\x93\xec\x09\x3a\xcb\x4c\x24\x8b\x5f\x4e\x2b\xe2\x69\x9a\xd5\x45\xec\x29\xf6\x1c\x5b\xcc\x9e\x61\xcf\xb2\x35\xb4\x2f\x2d\x61\xcf\xb3\x17\xd8\x9f\xc9\xf2\xeb\xd8\x15\xec\x65\xf6\x12\x5b\x4a\xf3\xf5\x21\xfb\x88\x5d\x44\x0e\x48\x3d\xed\xa7\xe1\xa2\x6c\x62\xd7\xd3\xfc\x4c\x55\x8c\xd2\x4a\xeb\xab\x8d\xf6\xdf\xe9\xec\x03\x36\x83\xfc\xf7\x99\xec\x34\x76\x06\x3b\x9d\xdd\xcb\x6e\x60\x67\xb1\x33\xd9\xd9\xec\x1c\xb6\x96\x7d\xcc\xee\xe3\x26\xb7\xb8\xcd\x13\xbc\x07\x2f\x61\xdf\xb3\x8d\xbc\x27\x0f\xbf\x47\xd4\x87\x75\x70\xc6\xfb\xf2\x7e\x7c\x2b\xce\x79\x7f\xbe\x35\xdf\x86\x6f\xcb\x07\xf0\xed\xf8\x40\xbe\x3d\x1f\xc4\x77\xe0\x3b\xf2\x9d\xd8\x06\xf6\x35\x1f\xcc\x77\xe6\xbb\xf0\x9f\xf0\x21\xfc\xa7\x7c\x57\xbe\x1b\xdf\x9d\xef\xc1\xf7\xe4\x7b\xf1\xa1\x7c\x6f\x3e\x8c\xef\xc3\xbe\x61\xaf\xf0\xe1\xbc\x94\x3b\xdc\xe5\x1e\x4f\xf2\x14\x2f\xe3\xe5\x3c\xcd\xf7\xe5\xfb\xf1\xfd\xf9\x01\xfc\x40\xf6\x0e\x5b\xc9\x0f\xe2\x07\xf3\x0a\x5e\xc9\xab\x78\x35\xf7\x79\x10\xfe\xf6\x28\x3f\x8c\x8f\xe0\x87\xf3\x91\xfc\x08\x76\x07\xfb\x0b\x3f\x92\x8f\xe2\xa3\xf9\xcf\xf8\x51\xfc\x68\x3e\x86\x8f\xe5\xc7\xf0\x63\xd9\xb7\xec\x3b\xb6\x8a\xbd\xcb\xc7\xf1\xe3\xf8\x78\x7e\x3c\x3f\x81\x9f\xc8\x4f\xe2\x27\xf3\x09\x3c\xc3\x27\xf2\x1a\x5e\xcb\xb3\x7c\x12\x9f\xcc\xeb\x78\x3d\x3f\x85\x4f\xe1\x0d\xbc\x91\xdd\xcf\x9b\x78\x8e\x37\xf3\xa9\xec\x3d\xf6\x3e\x6f\xe1\xad\xbc\x8d\xb7\xf3\x69\x7c\x3a\x9f\xc1\x67\xf2\x53\xf9\x69\xfc\x74\x7e\x06\x3f\x93\x9f\xc5\xcf\xe6\xe7\xf0\x73\xf9\x79\xfc\x7c\x76\x13\xff\x39\xbf\x80\xff\x82\x5f\xc8\x2f\xe2\x17\xf3\x4b\xf8\x2c\x3e\x9b\x5f\xca\x2f\xe3\x97\xf3\x2b\xf8\x95\xfc\x97\xfc\x2a\xfe\x2b\x7e\x35\xff\x35\xbf\x86\xff\x86\xcf\xe1\xbf\xe5\xd7\xf2\xdf\xf1\xeb\xf8\xef\xf9\xf5\xfc\x06\x7e\x23\xff\x03\x9f\xcb\xff\xc8\x6f\xe2\x37\xf3\x79\xfc\x16\x3e\x9f\xdf\xca\x6f\xe3\x7f\xe2\xb7\xf3\x3f\xf3\x3b\xf8\x5f\xf8\x9d\xfc\x2e\xbe\x80\xdf\xcd\xef\xe1\x7f\xe5\xf7\xf2\xbf\xf1\xfb\xf8\xfd\x7c\x21\xff\x3b\x7f\x80\xff\x83\x3f\xc8\x1f\xe2\x0f\xf3\x47\xf8\xa3\xfc\x31\xfe\x38\x7f\x82\x2f\xe2\x4f\xf2\xa7\xf8\xd3\x7c\x31\x7f\x86\x3f\xcb\x9f\xe3\xcf\xf3\x17\xf8\x8b\x7c\x09\x7f\x89\x2f\xe5\x2f\xf3\x57\xf8\xab\xfc\x35\xfe\x3a\x5f\xc6\xdf\xe0\xcb\xf9\x9b\xfc\x2d\xbe\x82\xbf\xcd\xdf\xe1\x2b\xf9\x2a\xfe\x2e\x7f\x8f\xbf\xcf\x57\xf3\x35\xfc\x03\xfe\x21\x5f\xcb\x3f\xe2\x1f\xf3\x4f\xf8\x3a\xfe\x29\xff\x8c\x7f\xce\xd7\xf3\x2f\xf8\x97\xfc\x2b\xbe\x81\x7f\xcd\xbf\xe1\xdf\xf2\xef\xf8\xf7\x7c\x23\xef\x10\x4c\x70\x21\x84\x14\x9a\xd0\x85\x21\x4c\x61\x09\x5b\x24\x44\x0f\x51\x22\x7a\x8a\x5e\xa2\xb7\xe8\x23\xfa\x8a\x7e\x62\x2b\xd1\x5f\x6c\x2d\xb6\x11\xdb\x8a\x01\x62\x3b\x31\x50\x6c\x2f\x06\x89\x1d\xc4\x8e\x62\x27\x31\x58\xec\x2c\x76\x11\x3f\x11\x43\xc4\x4f\xc5\xae\x62\x37\xb1\xbb\xd8\x43\xec\x29\xf6\x12\x43\xc5\xde\x62\x98\xd8\x47\x0c\x17\xa5\xc2\x11\xae\xf0\x44\x52\xa4\x44\x99\x28\x17\x69\xb1\xaf\xd8\x4f\xec\x2f\x0e\x10\x07\x8a\x83\xc4\xc1\xa2\x42\x54\x8a\x2a\x51\x2d\x7c\x11\x88\x43\xc4\xa1\xe2\x30\x31\x42\x1c\x2e\x46\x8a\x23\xc4\x91\x62\x94\x18\x2d\x7e\x26\x8e\x12\x47\x8b\x31\x62\xac\x38\x46\x1c\x2b\xc6\x89\xe3\xc4\x78\x71\xbc\x38\x41\x9c\x28\x4e\x12\x27\x8b\x09\x22\x23\x26\x8a\x1a\x51\x2b\xb2\x62\x92\x98\x2c\xea\x44\xbd\x38\x45\x4c\x11\x0d\xa2\x51\x34\x89\x9c\x68\x16\x53\x45\x8b\x68\x15\x6d\xa2\x5d\x4c\x13\xd3\xc5\x0c\x31\x53\x9c\x2a\x4e\x13\xa7\x8b\x33\xc4\x99\xe2\x2c\x71\xb6\x38\x47\x9c\x2b\xce\x13\xe7\x8b\x9f\x8b\x0b\xc4\x2f\xc4\x85\xe2\x22\x71\xb1\xb8\x44\xcc\x12\xb3\xc5\xa5\xe2\x32\x71\xb9\xb8\x42\x5c\x29\x7e\x29\xae\x12\xbf\x12\x57\x8b\x5f\x8b\x6b\xc4\x6f\xc4\x1c\xf1\x5b\x71\xad\xf8\x9d\xb8\x4e\xfc\x5e\x5c\x2f\x6e\x10\x37\x8a\x3f\x88\xb9\xe2\x8f\xe2\x26\x71\xb3\x98\x27\x6e\x11\xf3\xc5\xad\xe2\x36\xf1\x27\x71\xbb\xf8\xb3\xb8\x43\xfc\x45\xdc\x29\xee\x12\x0b\xc4\xdd\xe2\x1e\xf1\x57\xf6\x2a\x7b\x5b\xdc\xcb\x5e\x17\x7f\x13\xf7\x89\xfb\xc5\x42\xf1\x77\xf1\x80\xf8\x87\x78\x50\x3c\x24\x1e\x16\x8f\x88\x47\xc5\x63\xe2\x71\xb6\x8c\xbd\xc1\x96\xb3\x15\xec\x35\xf6\x96\x78\x42\x2c\x12\x4f\x8a\xa7\xc4\xd3\x62\xb1\x78\x46\x3c\x2b\x9e\x13\xcf\x8b\x17\xc4\x8b\x62\x89\x78\x49\x2c\x15\x2f\x8b\x57\xc4\xab\xe2\x35\xf1\xba\x58\x26\xde\x10\xcb\xc5\x9b\xe2\x2d\xb1\x42\xbc\x2d\xde\x11\x2b\xc5\x2a\xf1\xae\x78\x4f\xbc\x2f\x56\x8b\x35\xe2\x03\xf1\xa1\x58\x2b\x3e\x12\x1f\x8b\x4f\xc4\x3a\xf1\xa9\xf8\x4c\x7c\x2e\xd6\x8b\x2f\xc4\x97\xe2\x2b\xb1\x41\x7c\x2d\xbe\x11\xdf\x8a\xef\xc4\xf7\x62\xa3\xe8\x90\x4c\xf2\xf0\xfb\x0d\x52\x93\xe1\x1f\xb5\x33\xa5\x25\x6d\x99\x90\x3d\x64\x89\xec\x29\x7b\xc9\xde\xb2\x8f\xec\x2b\xfb\xc9\xad\x64\x7f\xb9\xb5\xdc\x46\x6e\x2b\x07\xc8\xed\xe4\x40\xb9\xbd\x1c\x24\x77\x90\x3b\xca\x9d\xe4\x60\xb9\xb3\xdc\x45\xfe\x44\x0e\x91\x3f\x95\xbb\xca\xdd\xe4\xee\x72\x0f\xb9\xa7\xdc\x4b\x0e\x95\x7b\xcb\x61\x72\x1f\x39\x5c\x96\x4a\x47\xba\xd2\x93\x49\x99\x92\x65\xb2\x5c\xa6\xe5\xbe\x72\x3f\xb9\xbf\x3c\x40\x1e\x28\x0f\x92\x07\xcb\x0a\x59\x29\xab\x64\xb5\xf4\xc3\xb7\x55\xe4\xa1\xf2\x30\x39\x42\x1e\x2e\x47\xca\x23\xe4\x91\x72\x94\x1c\x2d\x7f\x26\x8f\x92\x47\xcb\x31\x72\xac\x3c\x46\x1e\x2b\xc7\xc9\xe3\xe4\x78\x79\xbc\x3c\x21\xfc\x9c\x5f\x9e\x2c\x27\xc8\x8c\x9c\x28\x6b\x64\xad\xcc\xca\x49\x72\x72\xf8\x09\xbb\x3c\x45\x4e\x91\x0d\xb2\x91\xcd\x93\x4d\x32\x17\x7e\xa6\x2c\x5b\x64\xab\x6c\x93\xed\x72\x9a\x9c\x1e\x7e\x2e\x2b\x4f\x95\xa7\xc9\xd3\xe5\x19\xf2\x4c\x79\x96\x3c\x9b\xfd\x5e\x9e\x23\xcf\x95\xe7\xc9\xf3\xe5\xcf\xe5\x05\xf2\x17\xf2\x42\x79\x91\xbc\x58\x5e\x22\x67\xc9\xd9\xf2\x52\x79\x99\xbc\x5c\x5e\x21\xaf\x64\xbf\x96\xbf\x94\x57\xc9\x5f\xb1\xdf\xca\xab\xe5\xaf\xe5\x35\xf2\x37\x72\x8e\xfc\xad\xbc\x56\xfe\x4e\x5e\x27\x7f\x2f\xaf\x97\x37\xc8\x1b\xe5\x1f\xe4\x5c\xf9\x47\x79\x93\xbc\x59\xce\x93\xb7\xc8\xf9\xf2\x56\x79\x9b\xfc\x93\xbc\x5d\xfe\x59\xde\x21\xff\x22\xef\x94\x77\xc9\x05\xf2\x6e\x79\x8f\xfc\xab\xbc\x57\xfe\x4d\xde\x27\xef\x97\x0b\xe5\xdf\xe5\x03\xf2\x1f\xf2\x41\xf9\x90\x7c\x58\x3e\x12\x7e\x3e\x28\x1f\x0f\x3f\x89\x93\x4f\xca\xa7\xe4\xd3\x72\xb1\x7c\x46\x3e\x2b\x9f\x93\xcf\xcb\x17\xc2\xcf\x84\xc2\xcf\x3d\xe4\xcb\xf2\x15\xf9\xaa\x7c\x4d\xbe\x2e\x97\xc9\x37\xc2\xe7\xf4\xf2\x2d\xb9\x42\xbe\x2d\xdf\x91\x2b\xc3\x27\xce\xe1\x33\x63\xb9\x5a\xae\x91\x1f\xc8\x0f\xe5\x5a\xf9\x91\xfc\x58\x7e\x22\xd7\xc9\x4f\xe5\x67\xe1\x33\x4a\xf9\x85\xfc\x52\x7e\x25\x37\xc8\xaf\xe5\x37\xf2\x5b\xf9\x9d\xfc\x5e\x6e\x94\x1d\x1a\xd3\xb8\x26\x34\xa9\x69\x9a\xae\x19\x9a\xa9\x59\x9a\xad\x25\xb4\x1e\x5a\x89\xd6\x53\xeb\xa5\xf5\xd6\xfa\x68\x7d\xb5\x7e\xda\x56\x5a\x7f\x6d\x6b\x6d\x1b\x6d\x5b\x6d\x80\xb6\x9d\x36\x50\xdb\x5e\x1b\xa4\xed\xa0\xed\xa8\xed\xa4\x0d\xd6\x76\xd6\x76\xd1\x7e\xa2\x0d\xd1\x7e\xaa\xed\xaa\xed\xa6\xed\xae\xed\xa1\xed\xa9\xed\xa5\x0d\xd5\xf6\xd6\x86\x69\xfb\x68\xc3\xb5\x52\xcd\xd1\x5c\xcd\xd3\x92\x5a\x4a\x2b\xd3\xca\xb5\xb4\xb6\xaf\xb6\x9f\xb6\xbf\x76\x80\x76\xa0\x76\x90\x76\xb0\x56\xa1\x55\x6a\x55\x5a\xb5\xe6\x6b\x81\x76\x88\x76\xa8\x76\x98\x36\x42\x3b\x5c\x1b\xa9\x1d\xa1\x1d\xa9\x8d\xd2\x46\x6b\x3f\xd3\x8e\xd2\x8e\xd6\xc6\x68\x63\xb5\x63\xb4\x63\xb5\x71\xda\x71\xda\x78\xed\x78\xed\x04\xed\x44\xed\x24\xed\x64\x6d\x82\x96\xd1\x26\x6a\x35\x5a\xad\x96\xd5\x26\x69\x93\xb5\x3a\xad\x5e\x3b\x45\x9b\xa2\x35\x68\x8d\x5a\x93\x96\xd3\x9a\xb5\xa9\x5a\x8b\xd6\xaa\xb5\x69\xed\xda\x34\x6d\xba\x36\x43\x9b\xa9\x9d\xaa\x9d\xa6\x9d\xae\x9d\xa1\x9d\xa9\x9d\xa5\x9d\xad\x9d\xa3\x9d\xab\x9d\xa7\x9d\xaf\xfd\x5c\xbb\x40\xfb\x85\x76\xa1\x76\x91\x76\xb1\x76\x89\x36\x4b\x9b\xad\x5d\xaa\x5d\xa6\x5d\xae\x5d\xa1\x5d\xa9\xfd\x52\xbb\x4a\xfb\x95\x76\xb5\xf6\x6b\xed\x1a\xed\x37\xda\x1c\xed\xb7\xda\xb5\xda\xef\xb4\xeb\xb4\xdf\x6b\xd7\x6b\x37\x68\x37\x6a\x7f\xd0\xe6\x6a\x7f\xd4\x6e\xd2\x6e\xd6\xe6\x69\xb7\x68\xf3\xb5\x5b\xb5\xdb\xb4\x3f\x69\xb7\x6b\x7f\xd6\xee\xd0\xfe\xa2\xdd\xa9\xdd\xa5\x2d\xd0\xee\xd6\xee\xd1\xfe\xaa\xdd\xab\xfd\x4d\xbb\x4f\xbb\x5f\x5b\xa8\xfd\x5d\x7b\x40\xfb\x87\xf6\xa0\xf6\x90\xf6\xb0\xf6\x88\xf6\xa8\xf6\x98\xf6\xb8\xf6\x84\xb6\x48\x7b\x52\x7b\x4a\x7b\x5a\x5b\xac\x3d\xa3\x3d\xab\x3d\xa7\x3d\xaf\xbd\xa0\xbd\xa8\x2d\xd1\x5e\xd2\x96\x6a\x2f\x6b\xaf\x68\xaf\x6a\xaf\x69\xaf\x6b\xcb\xb4\x37\xb4\xe5\xda\x9b\xda\x5b\xda\x0a\xed\x6d\xed\x1d\x6d\xa5\xb6\x4a\x7b\x57\x7b\x4f\x7b\x5f\x5b\xad\xad\xd1\x3e\xd0\x3e\xd4\xd6\x6a\x1f\x69\x1f\x6b\x9f\x68\xeb\xb4\x4f\xb5\xcf\xb4\xcf\xb5\xf5\xda\x17\xda\x97\xda\x57\xda\x06\xed\x6b\xed\x1b\xed\x5b\xed\x3b\xed\x7b\x6d\xa3\xd6\xa1\x33\x9d\xeb\x42\x97\xba\xa6\xeb\xba\xa1\x9b\xba\xa5\xdb\x7a\x42\xef\x11\xfe\xed\x35\xbd\x97\xde\x5b\xef\xa3\xf7\xd5\xfb\xe9\x5b\xe9\xfd\xf5\xad\xf5\x6d\xf4\x6d\xf5\x01\xfa\x76\xfa\x40\x7d\x7b\x7d\x90\xbe\x83\xbe\xa3\xbe\x93\x3e\x58\xdf\x59\xdf\x45\xff\x89\x3e\x44\xff\xa9\xbe\xab\xbe\x9b\xbe\xbb\xbe\x87\xbe\xa7\xbe\x97\x3e\x54\xdf\x5b\x1f\xa6\xef\xa3\x0f\xd7\x4b\x75\x47\x77\x75\x4f\x4f\xea\x29\xbd\x4c\x2f\xd7\xd3\xfa\xbe\xfa\x7e\xfa\xfe\xfa\x01\xfa\x81\xfa\x41\xfa\xc1\x7a\x85\x5e\xa9\x57\xe9\xd5\xba\xaf\x07\xfa\x21\xfa\xa1\xfa\x61\xfa\x08\xfd\x70\x7d\xa4\x7e\x84\x7e\xa4\x3e\x4a\x1f\xad\xff\x4c\x3f\x4a\x3f\x5a\x1f\xa3\x8f\xd5\x8f\xd1\x8f\xd5\xc7\xe9\xc7\xe9\xe3\xf5\xe3\xf5\x13\xf4\x13\xf5\x93\xf4\x93\xf5\x09\x7a\x46\x9f\xa8\xd7\xe8\xb5\x7a\x56\x9f\xa4\x4f\xd6\xeb\xf4\x7a\xfd\x14\x7d\x8a\xde\xa0\x37\xea\x4d\x7a\x4e\x6f\xd6\xa7\xea\x2d\x7a\xab\xde\xa6\xb7\xeb\xd3\xf4\xe9\xfa\x0c\x7d\xa6\x7e\xaa\x7e\x9a\x7e\xba\x7e\x86\x7e\xa6\x7e\x96\x7e\xb6\x7e\x8e\x7e\xae\x7e\x9e\x7e\xbe\xfe\x73\xfd\x02\xfd\x17\xfa\x85\xfa\x45\xfa\xc5\xfa\x25\xfa\x2c\x7d\xb6\x7e\xa9\x7e\x99\x7e\xb9\x7e\x85\x7e\xa5\xfe\x4b\xfd\x2a\xfd\x57\xfa\xd5\xfa\xaf\xf5\x6b\xf4\xdf\xe8\x73\xf4\xdf\xea\xd7\xea\xbf\xd3\xaf\xd3\x7f\xaf\x5f\xaf\xdf\xa0\xdf\xa8\xff\x41\x9f\xab\xff\x51\xbf\x49\xbf\x59\x9f\xa7\xdf\xa2\xcf\xd7\x6f\xd5\x6f\xd3\xff\xa4\xdf\xae\xff\x59\xbf\x43\xff\x8b\x7e\xa7\x7e\x97\xbe\x40\xbf\x5b\xbf\x47\xff\xab\x7e\xaf\xfe\x37\xfd\x3e\xfd\x7e\x7d\xa1\xfe\x77\xfd\x01\xfd\x1f\xfa\x83\xfa\x43\xfa\xc3\xfa\x23\xfa\xa3\xfa\x63\xfa\xe3\xfa\x13\xfa\x22\xfd\x49\xfd\x29\xfd\x69\x7d\xb1\xfe\x8c\xfe\xac\xfe\x9c\xfe\xbc\xfe\x82\xfe\xa2\xbe\x44\x7f\x49\x5f\xaa\xbf\xac\xbf\xa2\xbf\xaa\xbf\xa6\xbf\xae\x2f\xd3\xdf\xd0\x97\xeb\x6f\xea\x6f\xe9\x2b\xf4\xb7\xf5\x77\xf4\x95\xfa\x2a\xfd\x5d\xfd\x3d\xfd\x7d\x7d\xb5\xbe\x46\xff\x40\xff\x50\x5f\xab\x7f\xa4\x7f\xac\x7f\xa2\xaf\xd3\x3f\xd5\x3f\xd3\x3f\xd7\xd7\xeb\x5f\xe8\x5f\xea\x5f\xe9\x1b\xf4\xaf\xf5\x6f\xf4\x6f\xf5\xef\xf4\xef\xf5\x8d\x7a\x87\xc1\x0c\x1e\x7e\x7b\xdf\xd0\x0c\xdd\x30\x0c\xd3\xb0\x0c\xdb\x48\x18\x3d\x8c\x12\xa3\xa7\xd1\xcb\xe8\x6d\xf4\x31\xfa\x1a\xfd\x8c\xad\x8c\xfe\xc6\xd6\xc6\x36\xc6\xb6\xc6\x00\x63\x3b\x63\xa0\xb1\xbd\x31\xc8\xd8\xc1\xd8\xd1\xd8\xc9\x18\x6c\xec\x6c\xec\x62\xfc\xc4\x18\x62\xfc\xd4\xd8\xd5\xd8\xcd\xd8\xdd\xd8\xc3\xd8\xd3\xd8\xcb\x18\x6a\xec\x6d\x0c\x33\xf6\x31\x86\x1b\xa5\x86\x63\xb8\x86\x67\x24\x8d\x94\x51\x66\x94\x1b\x69\x63\x5f\x63\x3f\x63\x7f\xe3\x00\xe3\x40\xe3\x20\xe3\x60\xa3\xc2\xa8\x34\xaa\x8c\x6a\xc3\x37\x02\xe3\x10\xe3\x50\xe3\x30\x63\x84\x71\xb8\x31\xd2\x38\xc2\x38\xd2\x18\x65\x8c\x36\x7e\x66\x1c\x65\x1c\x6d\x8c\x31\xc6\x1a\xc7\x18\xc7\x1a\xe3\x8c\xe3\x8c\xf1\xc6\xf1\xc6\x09\xc6\x89\xc6\x49\xc6\xc9\xc6\x04\x23\x63\x4c\x34\x6a\x8c\x5a\x23\x6b\x4c\x32\x26\x1b\x75\x46\xbd\x71\x8a\x31\xc5\x68\x30\x1a\x8d\x26\x23\x67\x34\x1b\x53\x8d\x16\xa3\xd5\x68\x33\xda\x8d\x69\xc6\x74\x63\x86\x31\xd3\x38\xd5\x38\xcd\x38\xdd\x38\xc3\x38\xd3\x38\xcb\x38\xdb\x38\xc7\x38\xd7\x38\xcf\x38\xdf\xf8\xb9\x71\x81\xf1\x0b\xe3\x42\xe3\x22\xe3\x62\xe3\x12\x63\x96\x31\xdb\xb8\xd4\xb8\xcc\xb8\xdc\xb8\xc2\xb8\xd2\xf8\xa5\x71\x95\xf1\x2b\xe3\x6a\xe3\xd7\xc6\x35\xc6\x6f\x8c\x39\xc6\x6f\x8d\x6b\x8d\xdf\x19\xd7\x19\xbf\x37\xae\x37\x6e\x30\x6e\x34\xfe\x60\xcc\x35\xfe\x68\xdc\x64\xdc\x6c\xcc\x33\x6e\x31\xe6\x1b\xb7\x1a\xb7\x19\x7f\x32\x6e\x37\xfe\x6c\xdc\x61\xfc\xc5\xb8\xd3\xb8\xcb\x58\x60\xdc\x6d\xdc\x63\xfc\xd5\xb8\xd7\xf8\x9b\x71\x9f\x71\xbf\xb1\xd0\xf8\xbb\xf1\x80\xf1\x0f\xe3\x41\xe3\x21\xe3\x61\xe3\x11\xe3\x51\xe3\x31\xe3\x71\xe3\x09\x63\x91\xf1\xa4\xf1\x94\xf1\xb4\xb1\xd8\x78\xc6\x78\xd6\x78\xce\x78\xde\x78\xc1\x78\xd1\x58\x62\xbc\x64\x2c\x35\x5e\x36\x5e\x31\x5e\x35\x5e\x33\x5e\x37\x96\x19\x6f\x18\xcb\x8d\x37\x8d\xb7\x8c\x15\xc6\xdb\xc6\x3b\xc6\x4a\x63\x95\xf1\xae\xf1\x9e\xf1\xbe\xb1\xda\x58\x63\x7c\x60\x7c\x68\xac\x35\x3e\x32\x3e\x36\x3e\x31\xd6\x19\x9f\x1a\x9f\x19\x9f\x1b\xeb\x8d\x2f\x8c\x2f\x8d\xaf\x8c\x0d\xc6\xd7\xc6\x37\xc6\xb7\xc6\x77\xc6\xf7\xc6\x46\xa3\xc3\x64\x26\x37\x85\x29\x4d\xcd\xd4\x4d\xc3\x34\x4d\xcb\xb4\xcd\x84\xd9\xc3\x2c\x31\x7b\x9a\xbd\xcc\xde\x66\x1f\xb3\xaf\xd9\xcf\xdc\xca\xec\x6f\x6e\x6d\x6e\x63\x6e\x6b\x0e\x30\xb7\x33\x07\x9a\xdb\x9b\x83\xcc\x1d\xcc\x1d\xcd\x9d\xcc\xc1\xe6\xce\xe6\x2e\xe6\x4f\xcc\x21\xe6\x4f\xcd\x5d\xcd\xdd\xcc\xdd\xcd\x3d\xcc\x3d\xcd\xbd\xcc\xa1\xe6\xde\xe6\x30\x73\x1f\x73\xb8\x59\x6a\x3a\xa6\x6b\x7a\x66\xd2\x4c\x99\x65\x66\xb9\x99\x36\xf7\x35\xf7\x33\xf7\x37\x0f\x30\x0f\x34\x0f\x32\x0f\x36\x2b\xcc\x4a\xb3\xca\xac\x36\x7d\x33\x30\x0f\x31\x0f\x35\x0f\x33\x47\x98\x87\x9b\x23\xcd\x23\xcc\x23\xcd\x51\xe6\x68\xf3\x67\xe6\x51\xe6\xd1\xe6\x18\x73\xac\x79\x8c\x79\xac\x39\xce\x3c\xce\x1c\x6f\x1e\x6f\x9e\x60\x9e\x68\x9e\x64\x9e\x6c\x4e\x30\x33\xe6\x44\xb3\xc6\xac\x35\xb3\xe6\x24\x73\xb2\x59\x67\xd6\x9b\xa7\x98\x53\xcc\x06\xb3\xd1\x6c\x32\x73\x66\xb3\x39\xd5\x6c\x31\x5b\xcd\x36\xb3\xdd\x9c\x66\x4e\x37\x67\x98\x33\xcd\x53\xcd\xd3\xcc\xd3\xcd\x33\xcc\x33\xcd\xb3\xcc\xb3\xcd\x73\xcc\x73\xcd\xf3\xcc\xf3\xcd\x9f\x9b\x17\x98\xbf\x30\x2f\x34\x2f\x32\x2f\x36\x2f\x31\x67\x99\xb3\xcd\x4b\xcd\xcb\xcc\xcb\xcd\x2b\xcc\x2b\xcd\x5f\x9a\x57\x99\xbf\x32\xaf\x36\x7f\x6d\x5e\x63\xfe\xc6\x9c\x63\xfe\xd6\xbc\xd6\xfc\x9d\x79\x9d\xf9\x7b\xf3\x7a\xf3\x06\xf3\x46\xf3\x0f\xe6\x5c\xf3\x8f\xe6\x4d\xe6\xcd\xe6\x3c\xf3\x16\x73\xbe\x79\xab\x79\x9b\xf9\x27\xf3\x76\xf3\xcf\xe6\x1d\xe6\x5f\xcc\x3b\xcd\xbb\xcc\x05\xe6\xdd\xe6\x3d\xe6\x5f\xcd\x7b\xcd\xbf\x99\xf7\x99\xf7\x9b\x0b\xcd\xbf\x9b\x0f\x98\xff\x30\x1f\x34\x1f\x32\x1f\x36\x1f\x31\x1f\x35\x1f\x33\x1f\x37\x9f\x30\x17\x99\x4f\x9a\x4f\x99\x4f\x9b\x8b\xcd\x67\xcc\x67\xcd\xe7\xcc\xe7\xcd\x17\xcc\x17\xcd\x25\xe6\x4b\xe6\x52\xf3\x65\xf3\x15\xf3\x55\xf3\x35\xf3\x75\x73\x99\xf9\x86\xb9\xdc\x7c\xd3\x7c\xcb\x5c\x61\xbe\x6d\xbe\x63\xae\x34\x57\x99\xef\x9a\xef\x99\xef\x9b\xab\xcd\x35\xe6\x07\xe6\x87\xe6\x5a\xf3\x23\xf3\x63\xf3\x13\x73\x9d\xf9\xa9\xf9\x99\xf9\xb9\xb9\xde\xfc\xc2\xfc\xd2\xfc\xca\xdc\x60\x7e\x6d\x7e\x63\x7e\x6b\x7e\x67\x7e\x6f\x6e\x34\x3b\x2c\xc6\xee\x64\x77\x59\x3c\xfc\xab\xaa\xec\x1e\xf6\x57\xf6\xa8\xa5\xb1\x05\xec\x6e\xf6\x98\xa5\xb3\x73\xd9\xc3\xec\x17\xec\x56\xcb\xb0\x4c\xcb\xb2\x6c\x2b\x61\xf5\x60\x8f\x5b\x25\x56\x4f\xab\x17\x7b\x80\xfd\xc3\xea\x6d\xf5\x61\x0b\xad\xbe\x56\x3f\x6b\x2b\xab\xbf\xb5\xb5\xb5\x8d\xb5\xad\x35\xc0\xda\xce\x1a\x68\x6d\x6f\x0d\xb2\x76\xb0\x76\xb4\x76\xb2\x06\x5b\x3b\x5b\xbb\x58\x3f\xb1\x86\xb0\xaf\xac\x9f\x5a\xbb\x5a\xbb\x59\xbb\x5b\x7b\x58\x7b\x5a\x7b\x59\x43\xad\xbd\xad\x61\xd6\x3e\xd6\x70\xab\xd4\x72\x2c\xd7\xf2\xac\xa4\x95\xb2\xca\xac\x72\x2b\x6d\xed\x6b\xed\xc7\x66\x59\xfb\x5b\x07\x58\x07\x5a\x07\x59\x07\x5b\x15\x56\xa5\x55\x65\x55\x5b\xbe\x15\x58\x87\x58\x87\x5a\x87\x59\x23\xac\xc3\xad\x91\xd6\x11\xec\x1a\xeb\x48\x36\x87\xfd\x86\x7d\x62\x8d\x62\x8f\xb0\x3f\xb2\x2b\xad\xd1\xd6\xcf\xd8\xb5\xec\x66\x76\x99\x75\x14\xbb\x8a\xfd\xca\x3a\xda\x1a\x63\x8d\xb5\x8e\xb1\x8e\xb5\xc6\x59\xc7\x59\xe3\xad\xe3\xad\x13\xac\x13\xad\x93\xac\x93\xad\x09\x56\xc6\x9a\x68\xd5\x58\xb5\x56\xd6\x9a\x64\x4d\xb6\xea\xac\x7a\xeb\x14\x6b\x8a\xd5\x60\x35\x5a\x4d\x56\xce\x6a\xb6\xa6\x5a\x2d\x56\xab\xd5\x66\xb5\x5b\xd3\xac\xe9\xd6\x0c\x6b\xa6\x75\xaa\x75\x9a\x75\xba\x75\x86\x75\xa6\x75\x96\x75\xb6\x75\x8e\x75\xae\x75\x9e\x75\xbe\xf5\x73\xeb\x02\xeb\x17\xd6\x85\xd6\x45\xd6\xc5\xd6\x25\xd6\x2c\x6b\xb6\x75\xa9\x75\x19\xfb\x9b\x75\xb9\x75\x85\x75\xa5\xf5\x4b\xeb\x2a\xeb\x57\xd6\xd5\xd6\xaf\xad\x6b\xac\xdf\x58\x73\xac\xdf\x5a\xd7\x5a\xbf\xb3\xae\xb3\x7e\x6f\x5d\x6f\xdd\x60\xdd\x68\xfd\xc1\x9a\x6b\xfd\xd1\xba\xc9\xba\xd9\x9a\x67\xdd\x62\xcd\xb7\x6e\xb5\x6e\xb3\xfe\x64\xdd\x6e\xfd\xd9\xba\xc3\xfa\x8b\x75\xa7\x75\x97\xb5\xc0\xba\xdb\xba\xc7\xfa\xab\x75\xaf\xf5\x37\xeb\x3e\xeb\x7e\x6b\xa1\xf5\x77\xeb\x01\xeb\x1f\xd6\x83\xd6\x43\xd6\xc3\xd6\x23\xd6\xa3\xd6\x63\xd6\xe3\xd6\x13\xd6\x22\xeb\x49\xeb\x29\xeb\x69\x6b\xb1\xf5\x8c\xf5\xac\xf5\x9c\xf5\xbc\xf5\x82\xf5\xa2\xb5\xc4\x7a\xc9\x5a\x6a\xbd\x6c\xbd\x62\xbd\x6a\xbd\x66\xbd\x6e\x2d\xb3\xde\xb0\x96\x5b\x6f\x5a\x6f\x59\x2b\xac\xb7\xad\x77\xac\x95\xd6\x2a\xeb\x5d\xeb\x3d\xeb\x7d\x6b\xb5\xb5\xc6\xfa\xc0\xfa\xd0\x5a\x6b\x7d\x64\x7d\x6c\x7d\x62\xad\xb3\x3e\xb5\x3e\xb3\x3e\xb7\xd6\x5b\x5f\x58\x5f\x5a\x5f\x59\x1b\xac\xaf\xad\x6f\xac\x6f\xad\xef\xac\xef\xad\x8d\x56\x87\xcd\x6c\x6e\x0b\x5b\xda\x9a\xad\xdb\x86\x6d\xda\x96\x6d\xdb\x09\xbb\x87\x5d\x62\xf7\xb4\x7b\xd9\xbd\xed\x3e\x76\x5f\xbb\x9f\xbd\x95\xdd\xdf\xde\xda\xde\xc6\xde\xd6\x1e\x60\x6f\x67\x0f\xb4\xb7\xb7\x07\xd9\x3b\xd8\x3b\xda\x3b\xd9\x83\xed\x9d\xed\x5d\xec\x9f\xd8\x43\xec\x9f\xda\xbb\xda\xbb\xd9\xbb\xdb\x7b\xd8\x7b\xda\x7b\xd9\x43\xed\xbd\xed\x61\xf6\x3e\xf6\x70\xbb\xd4\x76\x6c\xd7\xf6\xec\xa4\x9d\xb2\xcb\xec\x72\x3b\x6d\xef\x6b\xef\x67\xef\x6f\x1f\x60\x1f\x68\x1f\x64\x1f\x6c\x57\xd8\x95\x76\x95\x5d\x6d\xfb\x76\x60\x1f\x62\x1f\x6a\x1f\x66\x8f\xb0\x0f\xb7\x47\xda\x47\xd8\x47\xda\xa3\xec\xd1\xf6\xcf\xec\xa3\xec\xa3\xed\x31\xf6\x58\xfb\x18\xfb\x58\x7b\x9c\x7d\x9c\x3d\xde\x3e\xde\x3e\xc1\x3e\xd1\x3e\xc9\x3e\xd9\x9e\x60\x67\xec\x89\x76\x8d\x5d\x6b\x67\xed\x49\xf6\x64\xbb\xce\xae\xb7\x4f\xb1\xa7\xd8\x0d\x76\xa3\xdd\x64\xe7\xec\x66\x7b\xaa\xdd\x62\xb7\xda\x6d\x76\xbb\x3d\xcd\x9e\x6e\xcf\xb0\x67\xda\xa7\xda\xa7\xd9\xa7\xdb\x67\xd8\x67\xda\x67\xd9\x67\xdb\xe7\xd8\xe7\xda\xe7\xd9\xe7\xdb\x3f\xb7\x2f\xb0\x7f\x61\x5f\x68\x5f\x64\x5f\x6c\x5f\x62\xcf\xb2\x67\xdb\x97\xda\x97\xd9\x97\xdb\x57\xd8\x57\xda\xbf\xb4\xaf\xb2\x7f\x65\x5f\x6d\xff\xda\xbe\xc6\xfe\x8d\x3d\xc7\xfe\xad\x7d\xad\xfd\x3b\xfb\x3a\xfb\xf7\xf6\xf5\xf6\x0d\xf6\x8d\xf6\x1f\xec\xb9\xf6\x1f\xed\x9b\xec\x9b\xed\x79\xf6\x2d\xf6\x7c\xfb\x56\xfb\x36\xfb\x4f\xf6\xed\xf6\x9f\xed\x3b\xec\xbf\xd8\x77\xda\x77\xd9\x0b\xec\xbb\xed\x7b\xec\xbf\xda\xf7\xda\x7f\xb3\xef\xb3\xef\xb7\x17\xda\x7f\xb7\x1f\xb0\xff\x61\x3f\x68\x3f\x64\x3f\x6c\x3f\x62\x3f\x6a\x3f\x66\x3f\x6e\x3f\x61\x2f\xb2\x9f\xb4\x9f\xb2\x9f\xb6\x17\xdb\xcf\xd8\xcf\xda\xcf\xd9\xcf\xdb\x2f\xd8\x2f\xda\x4b\xec\x97\xec\xa5\xf6\xcb\xf6\x2b\xf6\xab\xf6\x6b\xf6\xeb\xf6\x32\xfb\x0d\x7b\xb9\xfd\xa6\xfd\x96\xbd\xc2\x7e\xdb\x7e\xc7\x5e\x69\xaf\xb2\xdf\xb5\xdf\xb3\xdf\xb7\x57\xdb\x6b\xec\x0f\xec\x0f\xed\xb5\xf6\x47\xf6\xc7\xf6\x27\xf6\x3a\xfb\x53\xfb\x33\xfb\x73\x7b\xbd\xfd\x85\xfd\xa5\xfd\x95\xbd\xc1\xfe\xda\xfe\xc6\xfe\xd6\xfe\xce\xfe\xde\xde\x68\x77\x24\x58\x82\x27\x44\x42\x26\xb4\x84\x9e\x30\x12\x66\xc2\x4a\xd8\x89\x44\xa2\x47\xa2\x24\xd1\x33\xd1\x2b\xd1\x3b\xd1\x27\xd1\x37\xd1\x2f\xb1\x55\xa2\x7f\x62\xeb\xc4\x36\x89\x6d\x13\x03\x12\xdb\x25\x06\x26\xb6\x4f\x0c\x4a\xec\x90\xd8\x31\xb1\x53\x62\xb0\xd9\xde\x54\x3f\x7c\x78\xc5\x70\xa4\xd5\x76\x6e\x5a\xb6\xa5\xb5\x26\xd7\x92\x95\x8d\xed\xa5\x46\x63\x7d\x6d\x6d\xae\xcd\xac\x68\x0c\x9f\x36\x37\x99\x99\x28\x35\x2a\x26\xb6\x64\xa7\x65\x8d\x8c\x4a\xcc\x8a\xdc\xe4\x5c\x53\x76\x8a\x99\x89\xd2\x1e\x55\x35\xf5\x2d\x35\xed\x8d\x93\x1a\xb2\x33\x7a\xd4\x14\xf2\x89\x2a\x12\x95\xa9\xa9\xc9\x36\xb5\x25\x6a\xf2\x59\xa3\xba\x26\x13\x8a\xac\x8d\x92\x6a\x92\x9f\x69\x33\x7d\x00\x66\x01\xe8\x47\x80\x59\x95\x24\xfc\x82\xa0\x6c\x3e\x6b\xfa\x50\x23\x1b\xa5\x86\x1f\x49\xcc\xaa\xa4\xc7\x21\x31\xa5\x26\xc7\x94\x3a\xa4\x20\x6b\x72\x3e\x5b\x72\x48\x4d\xae\xb1\x31\x83\xc2\xe4\x58\xa1\xc7\xa1\x31\x39\x75\x85\xbc\x76\xe8\xc4\x4c\x8b\x56\x47\x91\x71\x58\x5b\x7d\x43\x6d\xd6\xa8\x57\x89\x79\x18\x46\x52\x8f\x91\x1c\x16\x8d\xa4\x3e\x32\xdd\x61\xd0\xb9\x3e\x4a\xc5\x61\x23\x44\xfd\x29\x3d\x46\xc4\x30\x4e\x29\xe4\x4b\x0e\x8f\x6b\x35\xa5\x4b\x61\x72\xf8\xe1\x45\x43\xa6\xa9\xb6\xbe\xc6\x18\x99\xa9\x69\x6f\xcb\x1a\x0d\x2a\x29\x19\x19\x6f\xd7\x10\x2b\x18\x23\x23\x03\x35\xa8\x44\x1b\x49\xa3\xd7\x1a\x28\x32\x8e\x8c\xfa\x37\x45\xfd\x8f\x8c\xf7\x6f\x8a\xf7\x3f\x32\xea\xdf\x14\x19\xb8\x29\xd3\x9c\x6b\x6d\x6b\xc9\x35\xd7\x65\xa5\xdf\x34\x59\x66\x9b\x26\x9b\xa3\x30\xf8\x1c\x06\x3f\x2a\x1a\x7c\x4e\x25\x3d\x47\xd5\xb5\x37\x4d\xce\xb4\xb4\x37\x36\x64\xda\xdb\x7a\xe6\xe2\x25\xe3\xa8\x48\x87\x96\x48\x87\xa3\xe2\x3a\xb4\xc4\x75\x38\x2a\xd2\xa1\x25\x4a\x8e\x8e\x7a\xb5\xaa\xa4\xc7\xd1\x31\x33\xb6\xc6\xcc\x38\x26\x2e\xad\x2d\x2e\x6d\x4c\x24\xa6\x2d\xb2\xc8\x98\x70\x4a\xdb\xc2\x29\x1d\x1b\x4d\x69\x7b\x34\xa5\x63\x31\xaa\x76\x8c\x6a\x6c\x34\xaa\x76\x95\xe8\x63\x5b\xea\x9b\x26\xeb\xed\x61\xdc\x73\x6c\x97\x11\xb6\xc7\x4b\xe6\x58\x4c\x7d\x3b\xee\x9a\x63\x63\xda\x4e\x8f\xe5\x8f\x8b\xe5\x67\x16\xf2\xc6\xf8\x68\xac\xa7\xaa\x24\x31\xbe\xb0\x8c\x4f\xcd\x67\xf5\x86\x5c\xd3\xe4\x56\x75\x6b\x97\x96\x0f\x47\x5a\x8a\xd4\x41\xea\x22\xf5\x90\x26\x91\xa6\x90\x96\x21\x2d\x47\x9a\x46\x5a\x81\xb4\x12\x69\x15\xd2\x6a\xa4\x3e\xd2\x20\x4a\xd3\xc0\x4f\x03\x3f\x0d\xdc\x34\x70\xd3\xc0\x4d\x03\x37\x0d\xdc\x34\x70\xd3\xc0\x4d\x03\x37\x0d\xdc\x34\x70\xd3\xc0\x4d\x03\x37\x1d\xe8\xa3\xea\x72\x2d\x74\x04\x0d\xe3\xa8\xae\x02\x63\xae\x00\x76\x05\xb0\x2b\x80\x5d\x01\xec\x0a\x60\x57\x00\xbb\x02\xd8\x15\xc0\xae\x00\x76\x05\xb0\x2b\x80\x5d\xe1\xeb\x63\x15\x66\x7b\x01\xb3\x12\xe3\xad\x04\x76\x25\xb0\x2b\x81\x5d\x09\xec\x4a\x60\x57\x02\xbb\x12\xd8\x95\xc0\xae\x04\x76\x25\xb0\x2b\x81\x5d\x09\xec\x4a\x8c\xbb\x12\xf6\xae\x82\xbd\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\x7e\x15\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\x7e\x00\xfc\x00\xf8\x01\xf0\x03\xe0\x07\xc0\x0f\x80\x1f\x00\x3f\x00\x7e\x00\xfc\x20\x9d\xa8\x08\xf7\x92\xe8\x36\xcf\xe4\xb3\x66\x85\x1f\xa5\x99\x6c\xb4\xdb\x8d\x6a\x6d\xc8\xb4\xd6\x45\xf9\x5c\x21\xaf\xa4\x38\xc3\x87\x23\x2d\x45\xea\x20\x75\x91\x7a\x48\x93\x48\x53\x48\xcb\x90\x96\x23\x4d\x23\xad\x40\x5a\x89\xb4\x0a\x69\x35\x52\x1f\x69\x64\x0d\xa7\x14\xf8\xa5\xc0\x2f\x05\x7e\x29\xf0\x4b\x81\x5f\x0a\xfc\x52\xe0\x97\x96\x95\x1c\x1d\xdf\xad\x5b\x63\x05\xb4\x80\x26\xa5\xd0\xa4\x14\x9a\x94\x42\x93\x52\x68\x52\x0a\x4d\x1c\x68\xe2\x40\x13\x07\x9a\x38\xd0\xc4\x81\x26\x0e\x34\x71\xa0\x89\x03\x4b\x38\xb0\x84\x03\x4b\x38\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x9b\xb2\x4f\x19\x46\x3b\x7a\x43\xb6\xb5\x15\x35\xd0\xc0\x85\x06\x2e\x34\x70\xa1\x81\x0b\x0d\x5c\x68\xe0\x42\x03\x17\x1a\x78\xd0\xc0\x83\x06\x1e\x34\xf0\xa0\x81\x07\x0d\x3c\x68\xe0\xc1\x02\x1e\x2c\xe0\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x5f\x06\xfc\x32\xe0\x97\x01\xbf\x0c\xf8\x65\xc0\x2f\x03\x7e\x19\xf0\xcb\x80\x5f\x06\xfc\x32\xe0\x97\x01\xbf\x0c\xf8\x65\xc0\x2f\x03\x7e\x19\xf0\xcb\x80\x0f\x4f\xc0\x81\x27\xe0\xc0\x13\x70\xe0\x09\x38\xf0\x04\x1c\x78\x02\x0e\x3c\x01\x07\x9e\x80\x03\x4f\xc0\x81\x27\xe0\xc0\x13\x70\xe0\x09\x38\xf0\x04\x1c\x78\x02\x0e\x3c\x01\x07\x9e\x80\x03\x4f\xc0\x81\x27\xe0\xa4\x81\x0f\x8f\xc0\x81\x47\xe0\xc0\x23\x70\xe0\x11\x38\xf0\x08\x1c\x78\x04\x0e\x3c\x02\x07\x1e\x81\x03\x8f\xc0\x81\x47\xe0\xc0\x23\x70\xe0\x11\x38\x69\xe0\xe3\xb0\xe3\x54\x00\x1f\x5e\x81\x03\xaf\xc0\x81\x57\xe0\xc0\x2b\x70\xe0\x15\x38\xf0\x0a\x1c\x78\x05\x0e\xbc\x02\x07\x5e\x81\x03\xaf\xc0\x81\x57\xe0\xc0\x2b\x70\x2a\x80\x5f\x01\xfc\x4a\xe0\xc3\x33\x70\xe0\x19\x38\xf0\x0c\x1c\x78\x06\x0e\x3c\x03\x07\x9e\x81\x03\xcf\xc0\x81\x67\xe0\xc0\x33\x70\xe0\x19\x38\xf0\x0c\x1c\x78\x06\x0e\x3c\x03\x07\x9e\x81\x03\xcf\xc0\x81\x67\xe0\xc0\x33\x70\xe0\x19\x38\xf0\x0c\x1c\x78\x06\x0e\x3c\x03\x07\x9e\x80\x03\x0f\xc0\x81\x07\xe0\xc0\x03\x70\xe0\x01\x38\xf0\x00\x1c\x78\x00\x0e\x3c\x00\x07\x1e\x80\x03\x0f\xc0\x81\x07\xe0\xc0\x03\x70\xe0\x01\x38\xf0\x00\x1c\x78\x00\x0e\x18\xdd\x01\xa3\x3b\x60\x74\x07\x8c\xee\x80\xd1\x1d\x30\xba\x03\x46\x77\xc0\xe8\x0e\x18\xdd\x01\xa3\x3b\x60\x74\x07\x8c\xee\x80\xd1\x1d\x30\xba\x03\x46\x77\xc0\xe8\x0e\x18\xdd\x01\xa3\x3b\x60\x74\x07\x8c\xee\x80\xd1\x1d\x30\xba\x03\x46\x77\xc0\xe8\x0e\x18\xdd\x01\xa3\x3b\x60\x74\x27\x00\x7e\x00\xfc\x00\xf8\x01\xf0\x03\xe0\x07\xc0\x0f\x02\x7b\x72\x4b\x66\x5a\x96\xa8\x6f\xa2\xad\x38\x3d\xcc\xa9\x6b\xee\x70\xc7\x56\x67\x92\x58\x8d\x87\x34\x89\x34\x85\xb4\x0c\x69\x79\xcf\xba\x5c\x6e\x4a\x66\x62\x6e\x5a\xbc\x57\x05\xd2\x4a\xa4\x55\x48\xab\x91\xfa\x48\x23\x5b\xb8\xe0\x73\x17\x7c\xee\x82\xcf\x5d\xf0\xb9\x0b\x3e\x77\xc1\xe7\x2e\xf8\xdc\x2d\x85\x16\xa5\xe5\x48\xd3\x48\x81\x0f\x16\x77\xc1\xe2\x2e\x58\xdc\x05\x8b\xbb\x60\x71\x17\x2c\xee\x82\xc5\x5d\xc7\x29\x21\x8e\x9c\x98\x6d\xc8\x4d\x2f\x0c\x0a\x54\xee\x82\xca\x5d\x50\xb9\x0b\x2a\x77\x41\xe5\x2e\xa8\xdc\x05\x95\xbb\xa0\x72\x17\x54\xee\x82\xca\x5d\x50\xb9\x0b\x2a\x77\x41\xe5\x2e\xa8\xdc\x05\x95\xbb\xa0\x72\x17\x54\xee\x82\xca\x5d\x17\xf8\x2e\xf0\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xe4\x2e\x88\xdc\x05\x91\xbb\x20\x72\x17\x44\xee\x82\xc8\x5d\x10\xb9\x0b\x22\x77\x41\xd4\x2e\x88\xda\x05\x11\xbb\x20\x62\x17\x44\xec\x82\x88\xdd\x32\x5f\x6f\xcb\x35\xe5\x5a\x7b\xd6\xd6\x67\x5b\xb2\xad\xf5\xad\xaa\x94\xa8\x68\x68\xae\xcb\xa8\xac\x9d\x69\xca\xb5\x65\x1b\xb2\xf5\x99\x12\xbf\xb9\xb5\x9e\x4e\xef\xaa\xda\xf2\xdb\x70\xfd\xb0\x1c\x72\x25\xa3\x1a\xeb\xc3\x67\x0f\x51\x61\x6c\xac\x71\x62\x54\x63\x76\x72\xd4\xa8\x6f\x3d\x35\xef\x82\xa5\x2b\x2c\xad\x32\xdb\x96\xd1\x0f\xc9\x90\x27\x6d\x02\x47\x1b\x4f\x55\x92\x70\xf4\x31\x75\x94\xd3\x42\x20\xfd\xf0\x4c\x73\x73\xc6\x18\x99\x69\x9c\x58\x9b\x11\x47\xb4\x8b\x23\xdb\xc5\xb8\x7a\x13\xc8\x62\x74\xbd\x3c\xaa\x2e\xa7\x1f\x5d\x3f\xb9\x31\x23\xc7\x64\xda\x4d\x68\x21\x47\xd7\xd5\xcb\x2a\x0a\xa3\x5b\xeb\x4b\x0e\x8b\x69\xd0\x1b\x0d\x3a\xcb\x89\x4c\x7e\xe0\x25\xd9\xf8\x70\xb3\x9d\xc3\xad\xef\x1c\x6e\xff\xf6\xae\x5d\xa3\xc1\xa8\xfe\xda\xc4\x70\x30\x93\xc3\xc1\xe8\xb5\xd9\x86\xb6\x8c\x09\x59\xda\xa9\xe1\x90\xc2\x8b\x6d\x6a\x48\xa1\x30\x7d\x8a\x1a\x52\x43\x34\xa4\xa6\x76\x31\xa3\xde\xcc\x45\xe3\x91\x2d\x75\x39\xa3\x35\x1c\x4c\xa9\xae\x12\xd9\x46\x63\x02\xae\x6c\xa6\xf1\xd4\x50\xa0\xa2\x9e\x0b\x0d\x5c\x12\xb7\x6d\xef\x22\xf5\x4a\x72\xf1\xd9\x69\x8f\xcf\x4e\x2e\x3f\x3b\xd1\x9a\x00\x49\xba\x20\x49\x17\x24\xe9\x82\x24\x5d\x90\xa4\x0b\x92\x74\x41\x92\x2e\x48\xd2\xc5\x31\xd9\xc5\x31\xd9\xc5\x31\xd9\xc5\x31\xd9\xc5\x31\xd9\xc5\x31\xd9\x05\xa9\xba\x20\x55\x17\xa4\xea\x82\x54\x5d\x90\xaa\x0b\x52\x75\x41\xaa\x2e\x48\xd5\x05\xa9\xba\x20\x55\x17\xa4\xea\x82\x54\x5d\x90\xaa\x0b\x52\x75\x41\xaa\x2e\x48\xd5\x05\xa9\xba\x20\x55\x17\xa4\xea\x82\x54\x5d\x90\xaa\x0b\x52\x75\x41\xaa\x2e\x48\xd5\x05\xa9\xba\x20\x55\x17\xa4\xea\x82\x54\x5d\x90\xaa\x0b\x52\x75\x41\xaa\x2e\x48\xd5\x05\xa9\xba\x41\x84\xef\xe1\x60\xec\xe1\x60\xec\xe1\x60\xec\xe1\x60\xec\x81\x4e\x3d\xd0\xa9\x07\x3a\xf5\x40\xa7\x1e\x0e\xc6\x1e\x0e\xc6\x1e\x88\xd4\x03\x91\x7a\x20\x52\x0f\x44\xea\x81\x48\x3d\x10\xa9\x07\x22\xf5\x40\xa4\x1e\x88\xd4\x03\x91\x7a\x20\x52\x0f\x44\xea\x81\x48\x3d\x10\xa9\x07\x22\xf5\x40\xa4\x1e\x88\xd4\x03\x91\x7a\x20\x52\x0f\x44\xea\x81\x48\x3d\x10\xa9\x07\x22\xf5\x40\xa4\x1e\x8e\xc3\x1e\x8e\xc3\x1e\x38\xd4\x03\x87\x7a\xe0\x50\x0f\x1c\xea\x81\x43\x3d\x70\xa8\x07\x0e\xf5\xc0\xa1\x1e\x38\xd4\x03\x87\x7a\xe0\x50\x0f\x1c\xea\x81\x43\x3d\x70\xa8\x07\x0e\xf5\xc0\xa1\x1e\x38\xd4\x03\x87\x7a\xe0\x50\x0f\x1c\xea\x81\x43\x3d\x70\xa8\x07\x0e\xf5\xc0\xa1\x1e\x38\xd4\x03\x87\x7a\xe0\x50\x0f\x1c\xea\x81\x43\x3d\x70\xa8\x07\x0e\xf5\xc0\xa1\x1e\x38\xd4\x03\x87\x7a\xe0\x50\x0f\x1c\xea\x81\x43\x3d\x70\xa8\x07\x0e\xf5\xc0\xa1\x1e\x38\xd4\x03\x87\x7a\xe0\x50\x0f\x1c\xea\x81\x43\x3d\x70\xa8\x07\x0e\xf5\xc0\xa1\x1e\x38\xd4\x03\x87\x7a\xe0\x50\x0f\x1c\xea\x81\x43\x3d\x70\xa8\x07\x0e\xf5\xc0\xa1\x1e\x38\xd4\x03\x87\x7a\xe0\x50\x0f\x1c\xea\x81\x43\x3d\x70\xa8\x07\x0e\xf5\xc0\xa1\x1e\x38\xd4\x03\x87\x7a\xe0\x50\x0f\x1c\xea\x81\x43\x3d\x70\xa8\x07\x0e\xf5\xc0\xa1\x1e\x38\xd4\x03\x87\x7a\xe0\x50\x0f\x1c\xea\xe1\x30\xec\xe1\x30\xec\xe1\x30\xec\xe1\x30\xec\x81\x63\x3d\x70\xac\x87\xc3\xb0\x87\xc3\xb0\x87\xc3\xb0\x87\xc3\xb0\x07\x0e\xf6\xc0\xc1\x1e\x38\xd8\x03\x07\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x38\x0c\x7b\x78\x4c\xee\xe1\x31\xb9\x87\xc3\xb1\x87\xc7\xe4\x1e\x0e\xc9\x1e\x0e\xc9\x1e\x0e\xc9\x1e\x0e\xc9\x1e\x0e\xc9\x1e\x0e\xc9\x1e\xf8\xdf\x03\xff\x7b\xe0\x7f\x0f\xfc\xef\x81\xff\x3d\xf0\xbf\x07\xfe\xf7\xc0\xff\x5e\x75\xb9\x9d\x99\x54\x5f\x5f\x3a\xbc\xbc\x73\x67\x82\x07\xe0\xc1\x03\xf0\xe0\x01\x78\xf0\x00\x3c\x78\x00\x1e\x3c\x00\x0f\x1e\x80\x07\x0f\xc0\x83\x07\xe0\xc1\x03\xf0\xe0\x01\x78\xf0\x00\x3c\x78\x00\x1e\x3c\x00\x0f\x1e\x80\x07\x0f\xc0\x83\x07\xe0\xc1\x03\xf0\xe0\x01\x78\xf0\x00\x3c\x78\x00\x1e\x3c\x00\x0f\x1e\x80\x07\x0f\xc0\x83\x07\xe0\xc1\x03\xf0\xe0\x01\x78\xf0\x00\x3c\x78\x00\x1e\x3c\x00\x0f\x1e\x80\x07\x0f\xc0\x83\x07\xe0\xc1\x03\xf0\xe0\x01\x78\xf0\x00\x3c\x78\x00\x1e\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x3c\x80\x24\x18\x3d\x09\x46\x4f\x82\xd1\x93\x60\xf4\x24\x76\x8e\x24\x76\x8e\x24\x76\x8e\x24\x76\x8e\x24\x76\x8e\x24\x76\x8e\x24\x76\x8e\x24\x76\x8e\x24\x76\x8e\x24\x76\x8e\x24\x76\x8e\x24\x76\x8e\x64\xba\x13\x07\x7a\x63\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x62\xe7\x48\x56\x04\x7a\x6b\x5d\x76\x5a\x26\x41\x67\x87\xcc\xa4\xd6\xec\xe4\x5c\x43\x94\x6d\xa6\xa8\xae\x87\xca\x4e\xcd\x34\x66\xda\x5a\xf5\xba\xfa\x96\xfa\xa9\x7a\x5b\x2b\x79\xe5\xba\x6a\xa8\xab\x36\x46\xe7\xe5\x1c\x1d\x04\x22\xa1\x95\x15\xc6\xd4\xf6\x89\xed\x6d\xad\x46\x6d\x66\x72\xb6\xb5\x4e\x6f\xcc\xb6\x65\x27\xeb\x8d\x99\xa9\x99\x49\x5a\x4b\x66\x52\x96\x7a\xb6\x66\xa7\x9a\xe1\x17\x10\xc3\x8f\xc8\x5b\x55\x62\xb5\xe6\x08\xb5\xb5\x7d\xaa\xdd\xde\xdc\x9c\x6d\x39\x39\xac\x6a\xc8\x4d\xcf\xb6\x84\xef\x4c\x28\xb9\x55\xa9\x1e\x11\xd8\x54\x02\x6e\xd2\x32\x0d\xd9\x49\x92\x0e\x2c\xfa\xe4\xfa\xc6\x6c\x83\x5e\x4b\xe5\x36\x51\x97\x95\xd3\x32\xd3\xf4\x53\x33\x33\xeb\x9b\x24\x1d\x55\x64\x1b\x85\x99\xb9\x5a\x6b\x52\x7d\x53\xa6\x61\x4a\x66\x92\xa4\xa0\x93\xaa\x59\x54\x35\x66\x1b\x25\x85\xa8\xd0\xd4\xde\x24\x29\x18\xad\x74\x7d\x4a\x9d\x16\x0a\x31\xd5\x85\xe6\xac\x68\xce\x26\x54\xb6\xad\x95\x8e\x2a\xba\x8a\xe5\xd4\x1c\x0d\x88\x46\xa8\x85\x43\xa1\x33\xce\x34\x83\xc0\xa7\x45\x09\x81\x1a\x14\xc2\x64\x72\x78\x92\xa9\xb3\x29\x69\xad\x23\x99\xca\x4c\xa5\xd5\xd1\xbd\x42\x69\x29\x52\x07\xa9\x8b\xd4\x43\x9a\x44\x9a\x42\x5a\x86\xb4\x1c\x69\x1a\x69\x05\xd2\x4a\xa4\x55\x48\xab\x91\xfa\x48\x83\x28\x2d\x05\x7e\x29\xf0\x4b\x81\x5f\x0a\xfc\x52\xe0\x97\x02\xbf\x14\xf8\xa5\xc0\x2f\x05\x7e\x29\xf0\x4b\x81\x5f\x0a\xfc\x52\xe0\x97\x02\xbf\x14\xf8\xa5\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\xf7\x80\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x2f\x03\x7e\x19\xf0\xcb\x80\x5f\x06\xfc\x32\xe0\x97\x01\xbf\x0c\xf8\x65\xc0\x2f\x03\x7e\x19\xf0\xcb\x80\x5f\x06\xfc\x32\xe0\x97\x01\xbf\x0c\xf8\x65\xc0\x2f\x07\x7e\x39\xf0\xcb\x81\x5f\x0e\xfc\x72\xe0\x97\x03\xbf\x1c\xf8\xe5\xc0\x2f\x07\x7e\x39\xf0\xcb\x81\x5f\x0e\xfc\x72\xe0\x97\x03\xbf\x1c\xf8\xe5\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\xaf\x00\x7e\x05\xf0\x2b\x80\x5f\x01\xfc\x0a\xe0\x57\x00\xbf\x02\xf8\x15\xc0\xaf\x00\x7e\x05\xf0\x2b\x80\x5f\x01\xfc\x0a\xe0\x57\x00\xbf\x02\xf8\x15\xc0\xaf\x04\x7e\x25\xf0\x2b\x81\x5f\x09\xfc\x4a\xe0\x57\x02\xbf\x12\xf8\x95\xc0\xaf\x04\x7e\x25\xf0\x2b\x81\x5f\x09\xfc\x4a\xe0\x57\x02\xbf\x12\xf8\x95\xc0\xaf\x02\x7e\x15\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\x7e\x15\xf0\xab\x80\x1f\x00\x27\xf2\xc9\x4a\x7d\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x97\x05\xc6\xb1\xea\xb3\x4e\x63\x7a\x94\x1c\x1b\xbd\xe4\x38\x5d\x25\xf6\xb1\x9d\x0f\xd8\xed\xe9\x9d\xb9\xa8\x1f\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x0f\x9e\xf1\xc1\x33\x3e\x78\xc6\x07\xcf\xf8\xe0\x19\x1f\x3c\xe3\x83\x67\x7c\xf0\x8c\x9f\xf6\xed\x8a\xce\xcf\x2b\xed\x4c\x67\x2e\x51\x91\xff\x64\x36\x91\xc9\x67\xfb\x54\x14\x5e\xfa\x54\x66\xe8\x93\x29\xae\x88\xb5\x50\x66\x8b\xb7\x50\x15\xfd\x63\x2d\xf2\x82\xfb\x67\xba\xa9\x8c\xcb\x52\x9f\x2c\xc7\x65\xa9\x8a\xad\x62\x2d\x3a\x35\xdf\x2a\xb3\x69\x5d\x8f\xe8\x25\xf1\xe8\x85\xb4\x4c\x2c\x1f\xd5\x2b\xbd\x50\xaf\xf2\xbd\xa3\xfa\xbc\x26\xbd\x33\x5d\xcb\xe8\xa7\x74\x40\x3f\x95\xef\x15\xd5\x77\xc2\xf6\xca\x74\x29\xda\x7e\x3e\x97\xaf\x4b\xf8\x05\x3b\x17\xe4\x1b\x7e\xf4\x92\x6f\x24\xb5\x8f\x5f\x6c\xe4\x6c\x71\x85\x5f\x6c\xf5\x6c\xb1\xd5\xfd\xee\xac\x9e\xed\xce\xea\x7e\xb1\xd5\xb3\xc5\x56\xf7\xbb\xb1\x7a\x76\xd3\xba\xc4\x61\x85\xb1\xd5\xe7\xb3\xf6\x61\x79\x2b\xd4\xe7\x73\xa3\xf2\xb9\x5c\xbe\xf7\xa8\x42\xef\x5c\x41\xbb\x51\xc5\x43\xcf\x15\x57\x8c\x2a\xb6\x45\xae\xd8\x16\xa3\xba\xb3\x45\xae\x3b\x5b\x8c\x2a\xb6\x45\xae\xd8\x16\xa3\xba\xb1\x45\xae\x1b\x5b\xa8\x17\x80\xa3\x17\x27\x73\x85\xac\xaa\x55\x4a\x45\xb5\x2a\xdb\x4b\xd5\xe6\x95\xe8\x95\xeb\x52\x8c\xfa\x28\xf0\xa8\x8f\xca\xf6\x54\xb5\x9d\x68\x3d\x73\xf1\x92\x3d\x36\x9f\x6b\xcf\xeb\x33\xb6\x20\xb0\xbd\x90\x1d\x5b\x50\xad\xbd\x90\x1d\x5b\xd0\xb2\xbd\xa0\xe5\xd8\xae\x5a\xb6\x77\xd5\x72\x6c\x41\xcb\xf6\x82\x96\x63\xbb\x68\xd9\x1e\x2f\x19\xc7\x45\xdb\xec\x4c\x95\xd8\xc7\xe5\x75\x9e\x99\xd7\xf9\xb8\x82\xf8\x99\x85\x7b\xe5\xb8\xe8\x5e\x99\x19\xbd\x10\x1f\xee\x69\x01\x7c\xb6\x00\x3e\x5b\x00\x9f\x2d\x80\xcf\x16\xc0\x67\x0b\xe0\xb3\x05\xf0\xd9\x02\xf8\x6c\x01\x7c\xb6\x00\x3e\x5b\x00\x9f\x2d\x80\xcf\x16\xc0\x67\x0b\xe0\xb3\x05\xf0\xd9\x02\xf8\x6c\x01\x7c\xb6\x00\x3e\x5b\x00\x9f\x2d\x80\xcf\x16\xc0\x67\x0b\xe0\xb3\x05\xf0\xd1\x02\xf8\x68\x01\x7c\xb4\x00\x3e\x5a\x00\x1f\x2d\x80\x8f\x16\xc0\x27\x0b\xe0\x93\x05\xf0\xc9\x02\xf8\x64\x01\x7c\xb2\x00\x3e\x59\x00\x9f\x2c\x80\x4f\x16\xc0\x27\x0b\xe0\x93\x05\xf0\xc9\x02\xf8\x64\x01\x7c\xb2\xc0\xe9\xc4\xc3\xf8\xe0\x93\x05\xf0\xc9\x02\xf8\x64\x01\x7c\xb2\x00\x3e\x59\x00\x9f\x2c\x80\x4f\x16\xc0\x27\x0b\xe0\x93\x05\xf0\xc9\x02\xf8\x64\x01\x7c\xb2\x00\x3e\x59\x00\x9f\x2c\x80\x4f\x16\xc0\x27\x0b\xe0\x93\x05\xf0\xc9\x02\xf8\x64\x01\x7c\xb2\x00\x3e\x59\x00\x9f\x2c\x80\x4f\x16\xc0\x07\x0b\xe0\x83\x05\xf0\xc1\x02\xf8\x60\x01\x7c\xb0\x00\x3e\x58\x00\x9f\x2b\x80\xcf\x15\xc0\xe7\x0a\xe0\x73\x05\xf0\xb9\x02\xf8\x5c\x01\x7c\xae\x00\x3e\x57\x00\x5f\x2b\x80\x8f\x15\x24\x3b\xe5\x42\x7f\xf8\x54\x01\x7c\xaa\x00\x3e\x55\x00\x9f\x2a\x80\x4f\x15\xc0\xa7\x0a\xe0\x53\x05\xf0\xa9\x02\xf8\x54\x01\x7c\xaa\x00\x3e\x55\x00\x9f\x2a\x80\x4f\x15\xc0\xa7\x0a\xe0\x53\x05\xf0\xa9\x02\xf8\x54\x01\x7c\xaa\x00\x3e\x55\x00\x9f\x2a\x80\x4f\x15\xc0\xa7\x0a\xe0\x53\x05\xf0\xa9\x02\xf8\x54\x01\x7c\xaa\x00\x3e\x55\x00\x9f\x2a\x80\x4f\x15\xc0\xa7\x0a\x70\x56\x0f\x70\x56\x0f\x70\x56\x0f\x70\x56\x0f\x70\x56\x0f\x70\x56\x0f\xe0\x43\x05\xf0\xa1\x02\xf8\x50\x01\x7c\xa8\x00\x3e\x54\x00\x1f\x2a\x80\x0f\x15\x94\x77\xe2\x61\xbc\xf0\xa1\x02\xf8\x50\x01\x7c\xa8\x00\x3e\x54\x00\x1f\x2a\x80\x0f\x15\xc0\x87\x0a\xe0\x43\x05\xf0\xa1\x02\xf8\x50\x01\x7c\xa8\x00\x3e\x54\x00\x1f\x2a\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x59\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\x19\x3d\xc0\xd9\x3c\xc0\xd9\x3c\xc0\xd9\x3c\xc0\xd9\x3c\xc0\xd9\x3c\xa8\x02\x6e\x15\x70\xab\x80\x5b\x05\xdc\x2a\xe0\x56\x03\xb7\x1a\xb8\xd5\xc0\xad\x06\x6e\x35\xf0\xaa\x81\x57\x0d\xbc\x6a\xe0\x55\x03\xaf\x1a\x78\xd5\xc0\xa9\x06\x4e\x35\x70\x7c\xe0\xf8\xc0\xf1\x81\xe3\x03\xc7\xc7\xf8\x7c\xcc\xab\x0f\x5c\x1f\xb8\x3e\x70\x7d\xe0\xfa\xc0\xf5\x81\xeb\x63\x9c\x3e\xf0\x7d\xe0\xfb\xc0\x0f\x80\x17\x00\x2f\x00\x5e\x00\x9c\x00\x38\x01\x70\x02\xe0\x04\xc0\x09\x80\x13\x00\x27\x00\x4e\xf4\x0c\xc4\x19\x1e\xf1\x28\xa5\xa5\x48\x1d\xa4\x2e\x52\x0f\x69\x12\x69\x0a\x69\x19\xd2\x72\xa4\x69\xa4\x15\x48\x2b\x91\x56\x21\xad\x46\xda\x89\x1b\x44\x69\x29\xf0\x4a\x21\xbf\x34\xd5\x53\xfd\xfd\x3b\xf5\xa5\xd0\xda\x89\x0d\x3d\xa7\xb6\xe7\xc2\x3f\xaf\x1a\x7e\x4f\x34\x5b\x8b\x36\xe8\xeb\x00\xcb\x01\x96\x03\x2c\x07\x58\x0e\xb0\x9c\xc0\x68\xac\x6f\x52\x5f\xd5\xcb\xd6\xe4\x9a\x20\xc5\xf5\xec\xec\x8c\x9a\x86\x4c\x23\xa1\xd8\x2d\x99\xda\xf0\x2f\x39\x66\x67\x44\xd7\x92\xe8\x99\x02\x42\x0a\x08\x29\x20\xa4\x80\x90\xea\x6c\x17\x94\x4c\xca\xb5\xb7\xb4\xb6\x37\x67\x5b\xea\x73\x2d\x25\x93\xea\xa7\x65\x3b\x0b\x3d\x5b\x49\xf9\xa6\x7c\x29\x1b\xfe\xe1\xe2\xce\x92\x9d\xaf\x8f\xe4\xa4\x31\x1b\x69\xcc\x46\x1a\xd6\x49\x63\x36\xd2\x98\x8d\x0a\xb4\xab\x40\xbb\x0a\x47\x6b\xa8\x6f\xc9\xa0\x00\x53\x56\xa4\x8c\xe6\x6c\x6b\xb6\xad\xb3\x1a\x33\x55\x91\x36\x5a\xeb\xb2\x53\xb3\x0d\x5a\x6d\xae\x69\xb2\x16\xfe\x65\x49\x5c\xc0\xa0\x2a\x30\xa8\x0a\x98\xb9\x12\x60\x95\x00\xab\x84\x52\x95\x50\xaa\x12\x4a\x55\x02\x37\xfa\x88\xd5\x29\xc5\x92\x29\x8d\x5c\x22\x4a\x53\x48\xcb\xe4\xa8\xba\x46\x3b\xdb\xda\x56\xdf\x98\x69\xc3\xa4\x96\x46\xc4\x4c\xa9\x6f\xe5\x9a\xb2\x6d\x75\xf5\x2d\xb5\x76\xdb\xf4\x9c\xca\xb4\xda\x54\xa5\x0c\x57\x57\xd2\x56\xd7\x92\x45\xbe\xb5\x47\x68\x67\xe4\x4b\x94\x99\x51\x88\x44\x95\x7b\x76\xa6\xa5\x25\x37\xbd\x21\x3b\xa9\xcd\x54\xb9\xf6\xe6\x84\x4a\xd5\x5f\x8f\x8e\x2e\xd6\xe6\xa6\x37\x45\xb9\x89\x04\x66\xa3\x59\x6d\x53\x49\x3e\x37\xb1\x55\xf9\x9c\x0e\xbe\xa6\xe4\x38\xa5\xc9\x44\xae\xa5\xad\x2e\xfc\x26\x65\xa6\xa1\xa4\xbe\xa9\x2d\x5c\x9b\xea\x0f\xf8\xf6\xc8\x4e\x6d\xaf\x9f\x46\xeb\xa8\xa9\x26\xab\xd7\xe5\xda\x5b\xb3\x3d\x69\xe9\x36\xe4\x26\x87\x8b\xab\x29\xd7\x96\x08\x1b\x93\xf7\xdb\xd0\xd6\x9c\xcf\x4e\x54\x1f\xde\x39\xf8\x64\xd8\xc1\x27\xc2\x0e\x3e\xc9\x75\xf0\x89\x2d\xa5\x1e\xd2\x72\xa4\xb8\xee\xa0\x1e\xab\x3f\xe9\xa2\xec\xa2\x9c\x44\xff\xc8\xd3\xa1\x14\xf2\x23\x4f\x87\x52\xb4\x8f\x3c\x1d\x4a\x53\x48\xcb\x90\x02\x2f\xf2\x78\x28\xad\x40\x5a\x89\xb4\x13\xa7\x1a\xa9\x8f\x34\x5a\x3e\xc9\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\xc7\x3d\x99\xc4\x3d\x99\x0c\xef\xc9\xe6\x89\x0d\xb9\x9a\x29\x26\xcd\x55\x98\xea\x51\xa9\x61\x52\x94\xb6\xb4\xa1\xdc\xd6\x5a\x97\xa9\xcd\xea\x2a\x36\x6b\xa7\xa8\xd4\x9e\x54\xdf\xd0\x40\x1b\x4d\x2e\xba\xf3\xf1\xf9\xb2\x83\xcf\x87\x29\xad\x4c\x44\x2d\x5a\x68\x86\xcd\xb6\x96\xfa\xcc\xe4\xf6\xe6\x28\x6d\x41\xb9\xb6\x29\x4a\x1b\x26\x19\xe1\xa9\xb0\x21\x5a\x2d\xc9\x2a\xd8\xa5\x2a\xb0\xeb\x9b\xa6\x4d\x6c\x27\x21\x6d\x61\x2e\x6a\x93\xc8\x35\x67\x9b\x50\xd9\xda\x58\x4f\x4b\x34\x53\x93\xa5\xb5\x34\x2d\x5f\x90\xad\xed\x4d\xc6\xa4\x6c\x23\xad\x26\x2d\x8c\xf4\xd6\x66\xd2\x57\xab\x69\x68\x9f\xa8\xd7\x65\x33\x84\x5e\x5b\x9f\x69\xa4\xed\xac\x47\x63\x7b\x2b\xd6\x57\xb6\x57\x2c\x4f\xfb\x9a\xd2\x20\x15\xf9\x84\x4e\x15\x66\xa2\x0a\x33\x51\x85\x99\xa8\xc2\x4c\x54\x61\x26\xaa\x30\x13\x55\x98\x89\x2a\xcc\x44\x15\x66\xa2\x0a\x33\x51\x85\x99\xa8\xc2\x4c\x54\x61\x77\xac\xc2\xee\x58\x55\x06\x9c\x32\xe0\x94\x01\xa7\x0c\x38\x65\xc0\x29\x03\x4e\xe4\x7b\x3a\x78\xae\x5d\x51\x96\x4f\xcb\x91\xa6\x91\x56\x20\xad\x44\x5a\x85\xb4\x1a\xa9\x8f\x34\x88\xd2\xe8\x2c\x45\x69\x69\x94\x96\x43\x5e\x39\xe4\x95\x43\x5e\x39\xe4\x45\xbe\x26\xb9\x54\xa5\x48\x9d\x28\x8d\xe4\x53\xea\x97\x44\x9f\x5b\x9f\xac\x3e\xe0\xef\x4d\xb7\x73\x96\x0e\xd2\xe1\x5f\x0e\x0e\x3f\x10\xb7\xc2\xcf\xdd\xa7\xd7\xd3\xda\x52\x9f\xb8\x87\x39\xa3\x2e\x1b\x26\xe6\x94\x4c\x74\x41\x7d\xbc\x1e\xe6\x4a\x3a\x3f\x62\x0f\x0b\x56\xf8\x21\xb8\x6a\xd7\x96\x99\xa6\xae\x92\xe4\x93\x9b\x1b\xda\x5b\xc3\x3f\x4a\xdb\x23\xfc\x08\x1d\x6f\x04\x24\x54\x5e\x65\xfb\xaa\x2a\xf5\x1a\x01\x2e\xf6\x89\xd5\xa8\x0a\x3b\x54\x48\xa9\x9a\x08\x73\xd1\x2b\x02\xaa\xb2\x31\xd3\x5c\x3f\xd5\x9e\x98\x6d\x8b\x9a\xf7\x50\x2f\x0a\x20\xaf\x94\x8f\xf2\x56\x5d\x36\xca\xd8\xd3\x32\xd3\x70\x59\xbd\x40\x80\xda\xb6\xce\x86\x36\x19\x25\xca\xf5\xea\x7c\x9d\x00\x17\xf2\xb9\x1e\x6a\xec\xa8\xa5\x81\x23\xd7\xd4\x0e\x61\x25\xd1\xab\x05\x51\xa1\x27\xde\x2d\x80\x1a\x9d\x99\x1e\xea\xe5\x02\xf4\x9c\x9a\x83\xe4\x44\x68\x3e\x64\x0b\x26\xb0\xdb\x3a\x55\xb6\x48\xf9\xe8\x25\x0c\x1a\x70\xf8\x96\x45\x38\x1d\x61\x4a\x34\x19\x26\xca\x22\x4a\x3b\x35\xcd\xf8\x58\x24\xc0\xc7\x22\x01\x3e\x16\x09\xf0\xb1\x48\x40\x2e\x55\x8f\xd8\xf7\x43\x6d\xf5\x20\x70\x58\xcd\xcc\x96\x3e\xea\xfb\xfc\xb1\x4b\x7d\x63\xf9\x96\xf0\x25\xf3\xac\xa5\x9e\x80\x0c\x6b\xaf\xb1\xd4\xe3\x17\xca\xf4\x2c\x3c\x50\x0a\xab\x95\x08\xca\xf4\xe8\x7c\xf2\x1c\x56\xaa\xc7\x1f\x94\xe9\x1d\xff\x66\x7f\x78\x21\x82\x6e\xaf\x49\x44\x62\x69\xd5\x94\x16\xb2\x4e\x21\xeb\x26\x22\x38\xd5\x20\x9f\x75\x0a\x59\xb7\x57\xfe\xa1\x8b\x6a\xd4\xb5\xe8\x74\x2d\xba\x89\x48\x21\x25\x2d\x9f\x75\x12\x91\x36\x61\x6d\xef\xd8\xa0\xc2\x72\xcf\xce\xe7\x3c\x45\x1a\x78\x85\x6c\xb2\xa0\xad\x57\xc8\x26\xbb\x22\x7b\x5d\x8b\xc9\x02\x7a\x4c\x27\xaf\x90\x8d\x35\x48\x15\xb2\x65\x85\x6c\x79\x17\xcd\x9c\x2e\x25\xb7\x4b\xc9\xeb\x52\x4a\x76\x29\xc5\x64\xa7\xbb\x5c\x28\xeb\x52\xea\x0a\x96\xee\xd5\xc5\x28\xc3\xbb\x16\x4b\xbb\x16\x9d\xae\x45\xb7\x6b\xd1\xeb\x5a\x4c\xf6\x28\xcc\xcf\xf0\x58\xbe\x34\x96\x77\x62\x79\x35\xd0\xf0\x8b\xbf\xf5\xd1\xe4\xd1\x22\x0f\xbf\xc0\x15\x7e\xc9\x6b\x58\x4d\xa6\x39\x56\x2e\x2d\x2a\x57\x15\x95\x87\xc7\xca\x65\x45\xfd\xdd\x2e\x65\xc7\x4f\x22\xa4\x8a\xca\x65\x45\xe5\xf2\xa2\x72\x3a\x56\x4e\x85\x69\x51\x39\x55\x54\x2e\x2b\x2a\x97\x17\x95\xd3\x3d\x62\xe5\xd8\xb5\xb2\x22\xd9\x65\xdd\x5c\x2f\x2b\x2a\x97\x17\x95\xe3\xb2\xe3\x6d\xcb\x8b\x64\x97\x17\xc9\x2e\xef\xa6\x7d\x79\x51\x39\x2e\x3b\x7e\x2d\x5d\x24\x3b\x5d\x24\x3b\x5d\x24\x3b\xdd\x4d\xff\xb8\xec\x4e\x7b\xa7\x3a\xe7\xa0\xa8\x9c\x2a\x2a\x97\x15\x95\xcb\x8b\xca\x9d\xb2\x53\x45\xb2\xba\x2b\x97\x15\x95\xcb\x8b\xca\x71\xdd\xca\x8a\xfa\x97\x15\xe9\x56\x56\x24\xaf\xac\x48\x5e\x59\x91\x6e\xf1\xb6\xe5\x45\xb2\xcb\x8b\x64\x97\x77\xd3\xbe\xbc\xa8\x1c\x97\x1d\xbf\x96\x2e\x92\x9d\x2e\x92\x9d\x2e\x92\x9d\xee\xa6\x7f\x5c\x76\xa7\x4d\xca\x8a\xe6\xab\xac\x68\xbe\xca\x8a\xe6\xab\xac\x68\xbe\xca\x8a\xe6\xab\xac\x48\x56\xaa\x9b\x72\xaa\xa8\x5c\x56\x54\x2e\x2f\x2a\xc7\x65\xc7\xfb\x16\x63\x75\x77\xbd\xbc\xa8\x1c\x1f\x77\x79\x51\xff\xf2\xa2\xfe\xe5\x45\xba\x95\x17\xc9\x2b\x2f\xd2\x2d\x7e\x2d\x5d\x24\x3b\x5d\x24\x3b\x5d\x24\x3b\xdd\x4d\xff\xb8\xec\x4e\xbd\xcb\x8b\xe6\xab\xbc\x68\xbe\xca\x8b\xe6\xab\xbc\x68\xbe\xca\x8b\xe6\xab\xbc\x48\x56\xaa\x9b\x72\xaa\xa8\x5c\x56\x54\x2e\x2f\x2a\xc7\x65\xc7\xfb\x96\x15\xc9\x2e\xeb\xe6\x7a\x59\x51\xb9\xbc\xa8\x1c\x97\x1d\x6f\x5b\x3c\x8e\x62\xec\xee\xda\xc7\x6d\x9a\x2e\xea\x9f\x2e\xea\x9f\x2e\xea\x9f\x2e\xd2\x2d\x5d\xa4\x5b\xa7\xec\x74\xd1\x7c\xa5\x8b\xe6\x2b\x5d\x34\x5f\xe9\xa2\xf9\x4a\x17\xcd\x57\xba\x48\x56\xaa\x9b\x72\xaa\xa8\x5c\x56\x54\x2e\x2f\x2a\xc7\x65\xc7\xfb\x96\x15\xc9\x2e\xeb\xe6\x7a\x59\x51\xb9\xbc\xa8\x1c\x97\x1d\x6f\x5b\x5e\x24\xbb\xbc\x48\x76\x79\x37\xed\xcb\x8b\xca\x71\xd9\xf1\x6b\xc5\x36\x2a\x1e\x57\xb1\x2e\x51\x7f\x72\xcd\xe9\x24\x5f\x5f\x73\x72\xae\x2d\xfc\x49\x26\xf8\x23\x5e\x91\xbf\xe2\x15\xf9\x37\x6e\x37\xe5\xf2\x58\xb9\x34\xf4\x71\x62\xe5\xaa\xa2\xb2\xd7\xd9\xbe\x64\x62\xa6\xa5\xbe\xf3\x6f\xab\x6c\xa5\x2e\x56\x96\x46\x0d\x4a\x43\xa1\xc3\xbb\xa9\x2b\x2d\xaa\xf3\xba\x69\xe7\x15\xb5\x4b\x75\x23\x2f\xd5\x8d\xbc\x54\x37\xf2\x52\x45\xf2\xd2\xdd\xe8\x97\xee\x46\xbf\x74\x37\xfa\xa5\xbb\xd1\x2f\xdd\x8d\x7e\xe9\x6e\xf4\x4b\x77\xa3\x5f\x7a\x53\xfd\xaa\x92\x9b\xea\xd7\xa5\xae\xb8\x9d\xd7\x4d\xbb\x62\x79\xa9\x6e\xe4\xa5\xba\x91\x97\xea\x46\x5e\x77\xf6\x2b\xef\x5c\x64\xdd\xd4\x15\xb7\x4b\x75\xd3\x2e\x55\x84\x5b\x24\xaf\x4b\x5d\x71\xbb\x54\x37\xed\x94\xbc\xf0\xef\x17\xb4\x65\x6b\xeb\xd5\xb9\xcb\xf2\x9b\x26\x2b\x97\xbf\x33\xe3\x74\x66\x5c\xeb\xd4\x6c\x4b\x2e\xcc\x99\xb9\x26\x75\x4a\x30\xdb\xa6\xab\xb2\xad\x9e\xc3\x86\x39\x2b\x7c\xf2\x1d\x65\xea\xa3\xf3\x98\xd9\x5a\xaf\xce\x7b\xb6\x7a\x24\xab\x72\xea\xb9\xac\x6a\xd4\x54\x1f\x09\xea\x5d\xf4\x52\x47\xef\xa2\x57\x38\x7a\x75\x7d\x59\xa3\x77\xd1\x5b\x19\x89\xc2\x2b\x3e\x89\xc2\x5b\x3d\x76\xfe\x25\x9e\x44\xe1\x95\x9d\x7e\x45\x48\xc3\x1a\x6a\xfa\x15\x81\x51\x55\xdf\xae\x78\x5d\x1b\x45\x87\xa4\x86\x9a\x9e\x05\xd4\x7c\xa9\x53\x40\x49\x1e\x3b\x7f\x29\xdf\xad\x3d\xfa\x48\x67\x58\x6b\x5d\xae\xa5\xad\x87\xfa\x42\x76\x94\xef\xa3\x9e\x37\xa8\xa7\x12\x78\x72\x51\xa8\xc8\x3f\x42\x89\x1e\xd8\xf4\xec\x2c\xaa\xef\xa3\x6c\x95\x7f\x58\x51\xf8\x62\x4a\xaf\x7c\x5d\x51\x51\x7d\x27\xa5\x4f\xec\x31\x95\xaa\x55\x0f\x83\xf0\x40\x25\x5c\x22\x49\xda\x02\x92\x95\xd5\xc8\x3b\xb1\xbc\x1b\xe6\xb5\xa3\x4f\xae\xf4\x29\x1a\x13\x46\xa3\xfd\xe8\x97\x3a\x2d\x26\x58\x5f\xc6\x3b\xd4\x6f\x56\xaa\xdf\xcd\x64\x6c\x06\x3b\x5b\xfd\x8a\x50\x5f\xc6\xb4\x45\x8c\x6b\x4f\x6a\x5f\x30\xa9\x7d\xa9\x7d\x49\xf9\xaf\xb4\xaf\x28\xbf\x41\xdb\x40\xf9\xaf\xb5\xef\x29\xbf\x51\xdb\x48\xf9\x0e\x8d\x24\xe8\xcc\x7a\x9c\x71\xeb\x09\xeb\x09\x26\xad\x45\xd6\x67\x94\xff\xdc\xfa\x9c\x09\x6b\x7d\x82\x30\x12\xfd\x12\xfd\x99\x08\xff\xb2\x28\xe5\xb7\x4d\x6c\xc7\x64\x62\x60\x62\x10\xa1\x6a\xd1\x6f\x16\x29\xfc\xce\x90\x60\x13\xd9\xd5\x4c\xa3\x2d\xbf\x81\x0d\x9c\xdc\x92\x9d\xc2\x9c\xba\xec\xc4\x16\x76\x60\x43\xa6\xad\x89\xa9\x5f\x39\x3a\xe2\xf0\xea\xc1\xac\xcf\xd1\x47\x55\x52\xcc\x18\x8d\x80\xab\x5f\x34\x62\xc8\xb3\x7c\x5e\xa8\x5f\x3b\xea\x72\xa5\xa6\xa6\xb1\x99\x0d\x54\xf1\xe0\xda\x86\xfa\xc9\x6c\xf7\x86\x5c\x4d\xf8\x3b\x4b\x2c\xaf\x4f\xf8\xfb\x48\x61\xa9\x53\x23\x83\x6c\xb3\x0d\xdb\x91\xed\x4a\xad\x52\xa8\x1d\x4e\x6d\xc3\x16\x01\xd2\x63\xa8\x15\xa5\x62\x80\x92\xc1\xc5\x51\x51\xbd\xf9\x00\x49\xeb\xc3\xf4\xc4\x40\xf6\x11\x1b\x91\x18\x94\xd8\x9e\x6a\x75\xf9\x8e\xfa\x15\x88\x75\xf2\x73\x2a\xf5\xa3\x60\x85\xd8\xa1\xbd\xf4\x92\xb0\x97\x4e\x12\xf8\xb5\x6c\x3b\x56\xce\x2a\x69\xc4\xc7\xb0\x09\xec\x14\xd6\xc6\xce\x64\x17\xb2\x39\x6c\x2e\xbb\x9d\x3d\xc8\x5e\x67\xab\xa8\x61\x82\xf7\xe7\x3b\xf2\xdd\xb9\xc3\xf7\xe7\x01\x1f\xcd\xaf\x0c\xe5\x24\xb6\x65\x82\xe6\x2d\xcc\x0d\xc8\xe7\xb6\xcb\xe7\xb6\xa1\xdc\x7a\x85\xf7\x7a\x3e\xb7\x2c\x9f\x7b\x23\x9f\x5b\xae\x72\x82\xc6\x55\x62\x7d\x42\xf9\x4f\xad\x37\xf3\xd7\xde\xca\xe7\x56\xc4\x5a\xbd\x1d\xe6\x69\x1d\x08\x6d\xad\x5a\x5f\xbd\x58\x7f\x9a\x7d\xa1\xad\x4e\xf4\xa1\x78\x9d\xf5\x4e\xbe\xd7\x4a\x95\x0b\xdb\xf4\x61\xdb\x24\x7a\xd1\x5a\x5a\xaf\x7d\x9a\xe8\xad\x50\x56\xe5\x5b\xbd\x9b\xcf\xbd\x97\xcf\xbd\x9f\xcf\xad\xce\xe7\xd6\xe4\x73\x1f\xe4\x73\x1f\xe6\x73\x6b\x55\xce\x24\xa4\x01\xea\x37\x4e\x87\xd3\x1c\xee\x6f\xbd\x4c\x98\xdf\x90\xb6\x2f\x2b\xec\x6f\xac\xa5\x94\x7e\x4d\xe5\xa5\xaa\xfc\xb5\xf5\x91\x1a\xcb\x4b\x14\x7f\x63\x2d\xa1\xf8\x6b\x25\xeb\x63\x8c\xd6\xd4\xd6\x68\x1f\x86\x3f\x6b\xab\x1b\xb4\xf6\x2d\x9a\xb5\x84\xde\x4b\xef\xc5\xd4\xaf\x30\xb0\x3e\xe1\xaf\x30\xb0\x7e\xfa\x36\xfa\x40\xd6\x5f\xad\x25\x41\xe9\x2e\x24\x61\xa8\x5a\x3d\x7a\xb8\x06\xd4\xef\x39\xf4\xd0\xfb\xeb\xe1\xef\xdc\x4a\xf5\xfb\x0f\x5f\x85\x2b\x8f\xea\x77\x60\xcc\x9a\x6d\xcd\x66\x3b\x5a\x4f\x59\x2f\xb0\x9d\x68\x3d\x9c\x42\x7d\xfa\xf0\x5d\x84\x27\x03\x6d\x1c\x1b\xc4\xf6\xa5\x75\x31\x82\x1d\xc5\xc6\xd3\xbd\x72\x0a\x6b\x61\xa7\xb2\x73\xd9\xc5\xec\x4a\x5a\x1d\x37\xb2\xf9\xec\x4e\x76\x1f\x7b\x98\x3d\xc5\x5e\xa4\x55\xf2\x0e\xfb\x80\x7d\xc6\xbe\xa1\xb5\x62\xf0\x12\xfb\x68\x26\xc5\xad\xe2\x56\xfb\x28\x95\xce\xb7\x7f\xa6\xd2\x5b\xec\xd1\x2a\x9d\x67\x8f\x52\xe9\xcd\xf6\x11\x94\xce\xa7\x76\x23\x55\x3a\xdf\x3e\x5c\xa5\xb7\xd8\x23\x54\x3a\xcf\x3e\x4c\xa5\x37\xdb\x87\x50\x7a\x0b\xb5\x0b\x54\x3a\xdf\xf6\x55\x7a\x8b\x5d\xad\xd2\x79\x76\x95\x4a\x6f\xb6\x2b\x28\x9d\x47\xed\x0e\x56\xe9\x7c\xfb\x20\x95\xde\x62\x1f\xa8\xd2\x79\xf6\x01\x2a\xbd\xd9\xde\x9f\xd2\x9b\xa9\xdd\x7e\x2a\x9d\x6f\xef\xab\xd2\x5b\xec\xb4\x4a\xe7\xd9\x47\x32\x41\xb5\x63\x28\xbe\xd5\xae\xa4\x78\x9e\x7d\x28\xc5\xb7\xfc\x1b\x16\xc9\xc1\x22\x4d\xb0\x48\x23\x2c\xd2\x00\x8b\x4c\x81\x45\xea\x61\x91\x3a\x58\x64\x32\x2c\x32\x09\x16\xc9\xc2\x22\x35\xb0\xc8\x44\x58\x24\x03\x8b\x4c\x80\x45\x4e\x86\x45\x4e\x82\x45\x4e\x84\x45\x4e\x80\x45\x8e\x87\x25\x8e\x83\x25\xc6\xc1\x12\xc7\xc2\x12\xc7\xc0\x12\x63\x55\x7a\xb3\xdd\xac\x6c\x51\x1b\x5a\xc1\x1e\x4f\xf1\xcd\xf6\x29\xa1\x8d\xfe\x0d\x8b\x5c\x02\x8b\x5c\x0c\x8b\x5c\x04\x8b\x5c\x08\x8b\xfc\x02\x16\xf9\x39\x2c\x72\x3e\x2c\x72\x1e\x2c\x72\x2e\x2c\x72\x0e\x2c\x72\x36\x2c\x72\x16\x2c\x72\x26\x2c\x71\x06\x2c\x71\x1a\x2c\x71\x2a\x2c\x31\x13\x96\x98\x81\xb5\x31\x1d\x16\x69\x87\x45\xda\x60\x91\x56\x58\xa4\x05\x16\x99\x0a\x8b\x5c\xa0\xd6\xc8\x2c\x65\x97\x69\xca\x22\xa7\x87\x2b\xe5\xdf\xb0\xc8\xcd\xb0\xc8\x4d\xb0\xc8\x1f\x61\x91\xb9\xb0\xc8\x1f\x60\x91\x1b\x61\x91\x1b\x60\x89\xeb\x61\x89\xdf\xc3\x12\xbf\x83\x25\xae\x85\x25\x7e\x8b\xb5\x31\x07\x16\xf9\x0d\x2c\xf2\x6b\x58\xe4\x6a\x58\xe4\x57\xb0\xc8\x55\xb0\xc8\x2f\x61\x91\x2b\x60\x91\xcb\x61\x91\xcb\x60\x91\x4b\x61\x91\xd9\xb0\xc8\x75\x6a\x75\xcc\x53\x16\xb9\x52\x59\xe4\x9a\x7f\xd3\x22\x8f\xc2\x12\x8f\xc0\x12\x0f\xc3\x12\x0f\xc1\x12\xff\x80\x25\x1e\xc0\xda\xf8\x3b\x2c\xb2\x10\x16\xb9\x1f\x16\xf9\x1b\x2c\x72\x2f\x2c\xf2\x57\x58\xe4\x1e\x58\xe4\x6e\x58\xe4\x2e\x58\xe4\x4e\x58\xe4\x2f\xb0\xc8\x1d\xb0\xc8\x9f\x61\x91\x3f\xc1\x22\xb7\xc1\x22\xb7\xc2\x22\xf3\x61\x91\x5b\x60\x91\xfb\x94\x45\x1e\x54\x2b\xe5\x76\x65\x91\x05\xca\x22\xe4\x2f\x84\xfd\x15\xc3\x8f\x08\xf7\x5c\xda\xb5\x87\x12\x5f\x1c\x0c\x86\x7b\x55\xf1\xd8\x2b\x14\x7f\xa2\xf8\x60\x1d\xe5\xbe\x52\xb9\x4f\xf3\xb9\xcf\xf2\xb9\x45\x68\x17\xdf\xeb\x0b\x3e\xce\x4d\x3f\xe0\xe3\xf4\xe9\xd6\xc7\x61\x5b\xe8\xe3\xc8\x29\xe4\x2c\xb2\xfe\x2a\x1e\x18\x9e\x97\x89\xf7\x42\xdc\xbe\xac\xf3\x77\xd4\xfb\xfc\xd3\x5f\x81\x1c\x48\xa3\x3e\x90\xbc\x9b\x23\xc9\xfb\x38\x89\x4d\x62\x4d\xec\x74\x5a\x19\xd7\x90\xd6\xb7\xb3\x7b\xd8\x03\xec\x25\xb6\x9e\x6d\xa4\xb5\xd0\x8b\x6f\x43\x1e\xc8\xae\x7c\x18\x4f\xf1\x03\x49\xa6\x4d\x9e\x4b\x9f\xc8\xf7\xb1\x06\x28\xbf\x86\x27\xee\xa5\xb2\x49\xe9\xaa\xa8\xbe\x47\x02\xe9\xeb\x51\xda\x77\x4e\xe4\xff\x6c\xfb\xf8\x80\x01\x03\x4e\x19\xb0\x30\x2a\x6d\xc7\xb6\x9b\xb1\xdd\x37\x03\x4f\x8f\x4a\x03\xdf\xdb\xbe\x7c\xfb\x8b\xb7\x7f\x23\x2a\x0d\x1a\x3c\xe8\xc6\x1d\x06\xee\x70\x6d\xd4\x7f\x47\x23\x4a\x07\x3f\x10\xa5\x3f\x39\x45\xb5\xb2\x76\xdd\x66\xd7\xf3\x77\x7d\x73\xb7\xf2\xdd\xae\xdc\x6d\xed\xee\xc1\xee\xd7\xab\xda\x9e\xbb\xbf\xb1\x47\xc9\x1e\xfb\xef\xd1\xb0\xc7\xb5\x7b\x2c\xde\xe3\xbb\x3d\x87\xee\x79\xc2\x9e\xb3\xf6\x5c\xb8\xe7\xda\xbd\x06\xa9\xeb\x62\xaf\xa1\x7b\xd1\x3e\x1a\xe6\xf7\x3a\x53\x79\x76\x7c\xdf\x97\x22\xb9\xfb\xbe\x11\xa5\x07\x5c\x18\xa5\x15\x87\x46\x69\xf5\xf9\x51\xbb\x43\xab\x91\x8e\x54\x73\xc2\x0f\xad\xa3\x9b\x65\x3e\x59\x98\xb1\x52\xf5\x4b\xc6\x0d\xec\x59\x7e\xa6\x18\x26\x52\xec\x59\xd6\x20\x56\xc8\x0f\x58\x83\x36\x52\xac\x20\xef\xfa\x59\x31\x8c\x35\x18\xf4\x2f\x6c\x13\x5e\x53\xf1\xb0\xe8\x3f\xfa\x36\xa8\x56\xcf\x8a\x15\xe1\xd5\xa8\x36\xea\x1b\xd6\x51\xa9\x8f\x5e\xd2\xf1\x4a\xc7\x2b\x7a\x3f\x15\x6f\xab\xe2\xed\xc2\xd8\x7a\x52\xc5\xcf\xaa\x78\x89\x8a\x5f\x52\xf1\x52\x15\xbf\xac\xe2\x55\x2a\xfe\x50\xc5\x1f\x85\x71\xa2\x97\x8a\x7b\xab\x78\xeb\x30\x66\x3b\xe8\xbc\xe3\x91\x8e\x47\x74\xd1\x31\xa7\x63\x8e\xae\xa9\xbc\xc1\xf6\x60\x7b\xe8\xa6\xca\x27\x54\xdc\x43\xc5\x3d\x55\xdc\x4b\xc5\x7d\x55\xbc\x95\x8a\xfb\xab\x78\x60\x18\x5b\x8b\x55\xfc\x8c\x8a\x9f\x53\xf1\x0b\x2a\x5e\xae\xe2\x15\x2a\x5e\xa9\xe2\xf7\x55\xbc\x5a\xc5\x6b\x54\xfc\xb1\x8a\xd7\xa9\xf8\x53\x15\x7f\x16\xc6\x89\x3e\x2a\x56\x88\x4a\xdf\xd0\x0a\xa2\x63\x6d\xc7\x5a\x5d\x2a\x4d\x35\x55\x63\xaa\x38\xa1\xe2\x1e\x2a\xee\xa9\x62\x35\x66\xd2\x37\x8c\xb7\x52\x71\x7f\x15\x0f\x54\x76\x59\xac\xe2\x67\x54\xfc\x9c\x8a\x5f\x50\xf1\x72\x15\xaf\x50\xf1\x4a\x15\xbf\xaf\xe2\xd5\x2a\x5e\xa3\xe2\x8f\x55\xbc\x4e\xc5\x9f\xaa\xf8\x33\x65\xd9\x3e\x2a\x56\x88\xe4\xe7\x09\x95\x0e\xca\xeb\x1d\xc6\xff\xcd\x1a\x0f\xdd\x22\x4d\x4b\x94\xfd\x37\xd5\xb7\x9f\xaa\x8f\x6b\xbd\xad\xaa\xd9\x4e\xc5\x03\xb1\x76\x29\xdf\x65\x1c\xcf\xaa\x9a\xf8\x68\x96\xa8\x9a\x97\x54\xbc\x54\xc5\x2f\xab\x78\xd3\x51\xae\x52\xf5\x9b\x8e\xf5\x43\x55\xff\x91\x8a\x37\x37\xee\x5e\xe1\x55\xba\x1f\xc2\x38\x66\x03\xba\x37\xa8\x46\xdd\x7d\xa1\xd6\xd1\x98\x62\xe3\xc0\x08\x22\xad\x37\xa7\x69\xa4\x57\x4c\x8b\x2e\x68\x11\x42\xb8\x2a\x42\xa9\x9a\x8a\x3b\xef\xbb\x30\x9f\x50\x71\x0f\x58\x39\x8c\x55\x6f\xb2\x72\x64\xdf\x30\xee\x0f\x9b\x46\xd6\x0c\xe3\x67\x60\xc7\x30\x7e\x01\xf6\x0a\xe3\x15\x2a\x5e\x09\x4b\x85\xf1\x6a\x15\xaf\x81\x75\xc2\x78\x9d\x8a\x3f\x55\xf1\x67\xb0\x48\x18\x2b\x44\xb6\xf7\x66\x57\x85\x05\x7d\xff\xff\xb5\x36\xb6\x87\x3d\xfe\x9b\xef\x64\xce\x4a\xf3\xbf\x30\x68\xc4\x7e\x5b\xb0\x97\xfa\x5d\xc1\xad\xf4\xad\xf1\x7b\x82\x83\xf4\x1d\xd4\xef\x16\x85\xbf\x5a\x14\xfe\x66\x51\xf1\x2f\x16\xbd\x61\xad\xb0\xde\xb1\x56\x59\xab\xf1\xcb\x44\xeb\xf2\xbf\x2e\xa3\x9e\xfe\x88\xab\x45\x13\xc5\xd7\x92\xa7\x31\x92\xbc\xcc\xeb\xc9\x9f\xb8\x8d\xfc\xcc\x7b\xc9\xa3\x78\x94\x3c\xcd\xe7\xd9\xcb\xec\x0d\xf2\x35\x57\xb3\x8f\xc9\xbf\x80\xb7\xc9\xfb\xf1\x01\xe4\x63\x0c\xe1\x7b\xf2\xe1\xe4\x65\xec\xcf\x2b\xf9\xa1\xfc\x48\x3e\x86\x8f\xe7\x13\xf8\x24\xde\xc0\x5b\xf8\x0c\x7e\x26\x3f\x9f\x5f\xcc\x2f\xe7\x57\xf3\x6b\xf9\x8d\x7c\x1e\xbf\x9d\x2f\xe0\xf7\xf1\x07\xf9\xe3\x7c\x31\x7f\x91\xbf\xca\xdf\xe4\xab\xf8\x07\x7c\x1d\xff\x92\x7f\x27\x84\xb0\x44\x2f\xd1\x5f\x0c\x14\x83\xc5\xae\x62\xa8\x70\x44\xb9\x38\x50\x54\x8b\x11\x62\xb4\x38\x46\x9c\x40\xb6\xd8\x5f\xbf\xba\x28\x66\x85\x3c\xd7\x8a\x6b\xba\x69\xa9\xe2\x8e\x33\xbb\x97\xb0\xd9\x9a\x4d\x24\x74\x53\x13\xaf\x1f\x1d\x8b\x6b\xf5\x1b\x7e\x40\xfe\xe6\xf4\x89\x6b\x7b\xc7\x26\xf9\x4d\x75\xfb\x61\xfd\x37\x57\x13\x47\xdf\x74\x5c\x3f\xa8\xf3\xe6\x34\x8c\xb7\xdc\xf8\x52\x21\x8e\x5d\x25\x9f\xbd\xcb\xd3\x94\x45\xe4\x91\xef\xa4\x9e\xa9\x0c\xa6\x75\xfb\x19\xdb\x9d\xd6\x66\x5f\x76\x68\xe8\xab\x69\x9f\xb2\xe8\x49\x1f\x67\xbb\x53\xcf\xf0\x89\xe8\x00\x16\x3e\x9b\x8b\x3c\xe6\x7e\x68\x43\x7e\x36\x49\x24\x5f\x9b\xee\x91\x81\xe4\xd7\xd3\xdd\xc0\x06\x2a\x89\xe1\xd3\xcc\x41\x8c\x56\x38\x9d\x18\xc2\x67\x78\xe4\x19\x8a\x71\x4a\x13\x4e\xd8\x61\xef\xaf\xf3\x08\x0b\x54\xfd\xe3\xec\x3a\x8a\x17\x53\xeb\x7e\x6c\x57\x3a\x65\x38\xac\x9c\x3c\xee\x6a\x3a\x77\x8c\x26\x9f\xfb\x04\x3a\x21\xd4\xa9\xdf\xa1\x3f\x95\x9d\xcd\x2e\x60\xb3\x48\xde\xf3\x62\xa1\x8a\xcf\x26\x4b\x3c\xab\xf2\x0b\xe5\x60\x92\x31\x43\x0c\xea\xac\xe9\x78\x36\xac\x89\x62\x31\x4e\x8c\xa3\xd8\xe2\xa4\x0b\x9f\xa3\xda\x5f\x1c\xc6\xfc\x5e\x71\x15\xc5\xb7\x8b\xe7\x55\x1c\xd6\x6f\x08\x63\x79\x8f\x68\xe8\x8c\x59\x3f\xdd\xd4\x7b\xea\xbd\xf5\x7e\x74\xe7\xab\xdf\x10\x25\x1b\x16\x7e\xaf\x0c\x77\xbe\x1a\xd7\xfa\xfc\xb8\x76\x0c\xa5\x68\x5f\x6a\xcf\x32\xa1\x0f\x0a\xef\x70\xee\xf0\x72\x7e\x20\xaf\xe6\x23\xf8\x68\x7e\x0c\x3f\x81\x4f\xe4\x75\xbc\x89\xb7\xf1\x53\xf9\xd9\xfc\x02\x3e\x8b\x5f\xc9\xaf\xe1\xd7\xf1\xb9\x7c\x3e\xbf\x83\xdf\xc3\x17\xf2\x87\xf9\x22\xfe\x2c\x7f\x89\xbf\xce\x57\xf0\xf7\xf8\x5a\xfe\x19\xdf\xc0\x37\x0a\x4d\x24\x44\x1f\xb1\x8d\x18\x24\x76\x11\xbb\x93\x47\xec\x89\x7d\xc5\xc1\x22\x10\x23\xc5\x51\x34\xc6\x93\x44\xad\x38\x45\x34\x8b\x69\xe2\x74\x71\xae\xb8\x50\x5c\x2a\xae\x12\x73\xc4\xf5\xe2\x26\x71\x9b\xb8\x53\xdc\x2b\x1e\x10\x8f\x8a\xa7\xc8\x6a\x2f\x8b\x37\xc4\x3b\x62\xb5\xf8\x58\xac\x17\xdf\x48\x26\x0d\x59\x22\xfb\xc9\x01\x72\x47\x39\x44\xee\x29\x87\xcb\x94\xdc\x5f\x56\xca\x43\xe5\x91\x72\x8c\x1c\x2f\x27\xc8\x49\xb2\x41\xb6\xc8\x19\xf2\x4c\x79\xbe\xbc\x58\x5e\x2e\xaf\x96\xd7\xca\x1b\xe5\x3c\x79\xbb\x5c\x20\xef\x93\x0f\xca\xc7\xe5\x62\xf9\xa2\x7c\x55\xbe\x29\x57\xc9\x0f\xe4\x3a\xf9\xa5\xfc\x4e\x13\x9a\xa5\xf5\xd2\xfa\x6b\x03\xb5\xc1\xda\xae\xda\x50\xcd\xd1\xca\xb5\x03\xb5\x6a\x6d\x84\x36\x5a\x3b\x46\x3b\x41\x9b\xa8\xd5\x69\x4d\x5a\x9b\x76\xaa\x76\xb6\x76\x81\x36\x4b\xbb\x52\xbb\x46\xbb\x4e\x9b\xab\xcd\xd7\xee\xd0\xee\xd1\xc2\x39\x28\xd1\x83\x30\x36\xe6\xaa\xf5\x13\x84\x71\x98\xe7\xf7\x86\x79\x7e\xaf\xaa\x5f\xa8\xea\x17\xaa\xfc\x2a\x95\x5f\xa5\xda\xcc\x55\x6d\xe6\xaa\xfc\x7a\x95\x5f\xaf\xda\x6c\x50\x6d\x36\x14\xe7\xe3\xed\xc5\x70\x55\x3f\x7c\x93\x7c\x4c\x7e\xbc\xaf\x3c\x5f\xe9\x79\xfe\x26\xb8\x2b\x54\x7e\xc5\x26\xb8\xcf\xab\xfc\xf3\x9b\xe8\x1f\xcf\x37\xa8\x7c\x83\xca\x5f\xa5\xf2\x57\x6d\xd2\x26\xa6\x9b\x6c\x56\x3a\x34\xab\xfc\x60\x95\x1f\xac\xda\x9c\xad\xda\x9c\xfd\x83\xf9\x98\x6d\xe3\xf5\x5d\xec\xbf\x19\x3b\x6f\x89\x7d\xba\xe8\x19\xd3\xad\x8b\xce\x5b\x92\x8f\xe9\xb3\xb9\xfc\x7f\x62\x9d\xfc\xd8\xb5\xd1\x65\x3d\x6c\x6e\x0d\x6c\x6e\xde\xff\x8d\xb9\xe6\x8b\x0b\x71\xa7\x64\x15\x4f\x8c\xc5\xab\xe2\x71\x6c\xbe\x36\x37\xa7\x85\xfc\x96\x33\x48\xdf\xfc\x6f\x41\x87\xbf\x04\xfd\x92\xfa\x05\xe8\xd7\xb4\x15\xea\xf7\x9e\xdf\xd7\xbe\xd2\xbe\xb3\x9e\x50\xcf\x5f\x02\x0a\xe1\x67\x58\x47\x51\x18\x47\xe1\x24\x0a\xb5\x14\x4e\xa1\xd0\x4c\x61\x1a\x85\xd3\x29\x9c\x4b\xe1\x42\x0a\x97\x52\xb8\x8a\xc2\x1c\xc2\xb8\x9e\xd2\x9b\xc2\xbd\x3c\xd4\x8f\xcd\x52\x56\x1e\xa3\xe2\xcb\x55\xcd\xf5\x85\x98\x0f\x55\xf9\xfd\x55\xbc\xa8\xf8\x2a\x31\x50\x5e\x02\xe5\x9b\xf2\x9c\xb4\xc8\xe8\xd5\x99\xc7\x3e\x3e\xec\xff\xee\xe3\xff\xca\x3e\x2e\x2c\xf5\x29\xa0\x8a\xf9\x8a\x58\x3c\xa6\x10\x8b\x79\xb1\x78\x78\x21\x66\x33\x62\xf1\xa2\x42\x1c\x6f\xd3\xa5\xfd\xac\x42\xcc\x87\xc6\xe2\x18\x16\x3f\xbd\x10\x6f\x4e\xce\xc6\xd5\x4a\xce\x78\x15\xaf\x2b\xc4\xa2\x3a\x16\xc7\xda\xf3\xc5\xdd\xc7\xf2\x50\x95\xd7\x8a\xeb\xc9\xaf\x28\xc4\x0b\x63\xf1\xb8\xee\x63\x7e\xf9\x3f\x8f\xbb\xe8\x13\xaf\x8f\xd9\x7f\x73\x76\xde\x22\xfb\x6c\x81\x9e\x5b\x12\xf3\x01\x2a\x5e\x5f\xc8\x77\xd1\xf0\x3f\xb6\x4e\xe2\x6d\x7e\xec\xda\xd8\xdc\x1a\xd8\xdc\xbc\xff\x3b\x73\xdd\x45\xcf\xcd\xd8\xa1\x0b\xca\xe9\x9b\x89\x87\x76\x1b\x6f\xf9\x3e\x3e\x50\x7b\x52\x7b\x56\x5b\xd2\xe5\x97\xfb\xdf\xe9\xe6\xb7\xfa\x3f\xd7\xbe\xd0\xbe\xd7\x3a\xa2\x5f\x4a\x65\x03\xd9\x96\xec\xe0\x0c\x3b\x38\xa3\x33\x6f\xf8\x6b\xce\x8c\xce\xbd\x8c\x4e\xbe\x8c\xce\xbe\x8c\x4e\xbf\x8c\xce\xbf\x8c\x4e\xc0\x8c\xce\xc0\x8c\x4e\xc1\x9c\x85\x77\xe4\xc7\x14\xc2\x75\xf3\x4d\x68\x20\xf2\xed\x2f\x64\xfd\x55\x1c\xe6\xdb\x90\x0f\xe3\x6b\xbb\xe4\x59\x3e\xbe\x30\x56\xbf\xb9\x78\x82\x6a\x39\x81\x15\xcb\xef\x8a\x12\xb5\x71\x48\x8d\xab\x55\xfe\x51\x55\x5f\x88\xa5\x3a\x03\xf1\xb0\xac\x5a\x31\xb6\x15\xc5\x42\xfb\x8a\xb8\x6f\x33\x9f\x6c\xb3\x5e\x3f\xc4\x9b\x24\x51\x90\xc4\xfd\x95\x4c\x56\x24\xf1\x9f\xf5\xed\x1e\xf1\x9f\xe8\xa8\x56\x06\x53\x6b\x82\xab\x35\xb1\xf3\x7f\x5a\xc7\x6e\x10\x43\x1d\x47\x40\xc7\x09\x4a\x62\x98\xdb\xee\x47\xac\xcc\xce\x75\xb9\x39\xab\x27\xba\x93\xf5\x3f\x80\xdb\xfb\x9f\xf4\xfb\x3f\xaa\x41\xb7\x73\xf9\xff\xbe\x06\x9b\xb3\xbd\x60\x5e\x97\x55\xb4\xf5\x3f\x5d\x3d\x3f\x7c\x6f\x85\x23\xf1\x30\x92\x11\x5b\x28\x71\x73\xf3\x16\xe1\xfc\x9b\x3a\x6e\x66\xa5\xff\x0b\x3a\x76\x6b\xd7\x82\x8e\x23\x58\x43\x4c\xc7\x6d\xfe\xc5\xf9\xfb\xe7\x6b\x65\x73\x76\x0f\x35\x98\xf8\x7f\x44\x83\xee\xd7\xca\x0f\xe1\xfe\x8f\x8d\xbc\xdb\xd9\xfc\x1f\x18\x79\x77\x73\x8f\xa7\xca\xd7\xff\x97\x3f\x55\x5e\xa7\xce\x5b\xf1\x78\x56\x2c\xbf\x68\x93\x9a\x4d\xeb\xa3\x3c\xdb\x44\xc2\xa2\x4d\xda\x2f\xda\x0c\xd6\xac\xcd\xd4\x2c\x2a\x8e\xb9\x56\x68\x19\xcf\x77\xa3\xf3\xe6\xf4\x99\x15\xbb\x3a\x6b\x93\x96\x9b\x8b\x67\x6d\x82\xbb\xb9\x9a\x45\x9b\xc8\xff\xe1\xb1\x6f\x6e\xd4\xb5\x9b\x8c\x48\xe5\x3b\x46\x16\xe2\x58\xaf\x2d\xf7\x25\xa5\xf6\x82\xf6\xb6\xf6\x9e\x7a\x03\xb0\x97\x62\x12\x46\x9e\x62\xa7\xc6\xb1\x18\xeb\xf7\xba\xff\xee\xf5\xab\x95\x47\xcf\x78\xa2\x27\x46\x85\xbc\x5c\xad\x6a\xea\x54\xbc\x38\x8c\xb5\x21\x85\x38\xaa\xef\x7c\x66\x13\x3d\xc5\xe9\xbe\x4d\x24\x33\xaa\x89\x64\x76\x89\xcf\x2f\x46\x94\x27\x84\xb1\xde\x5f\xf5\x52\xb3\xd4\xf9\x54\x2c\x16\xaf\x2e\xe4\xe3\xfa\xa3\x3e\xa6\x15\x70\x4f\x28\x48\xd3\x17\x14\xe4\xc7\xf3\x91\x9c\x78\xbc\xe5\x36\xe9\xc6\x1a\x31\xf4\xcd\x5a\xe0\x07\x47\x1d\x3d\xab\x43\x9b\xc1\xdd\x8f\x2e\x16\x6f\xf9\xfa\x15\xda\x52\xed\x55\xf5\x7e\x76\x82\x45\xef\x0c\x8d\x56\x6b\x76\xc6\xff\xa2\x35\x3b\x24\x64\xa2\xe8\x89\x04\xce\xb0\x1b\x54\xcd\x83\x8a\xa1\x16\x14\x4e\xb8\xf2\xbb\x42\x1c\xd5\x6b\x7d\x0a\xed\xa3\xd3\xab\x56\x5e\x88\xbb\x3c\xf1\x50\x4f\x4e\xe4\x09\xea\xea\x1d\x2a\x7f\xbe\xea\xb5\x4a\xe5\x07\xc7\x4e\xbb\x1b\x8a\xe5\x74\x39\x1d\x2f\x2c\x48\x03\xe2\x90\x62\x9d\x37\xd5\x67\x53\x99\xdd\xc4\x43\x8a\xe3\x2d\xb7\xc9\x66\xad\x31\xa4\xd8\x02\xf1\xb1\x6f\x76\xd4\x43\x0a\x32\xa1\xc3\x86\x98\xc5\x62\x76\x88\x10\x55\xfc\x63\xd6\xec\x8b\xda\xbb\x5d\xd6\xec\xee\xf4\x3f\x3c\x0b\x27\x70\x52\x3b\x30\xe6\x9f\x6c\x9b\xef\xf1\xcf\x7d\x1e\xce\xb6\x51\x9f\x8e\xeb\xba\xa1\xdb\x7a\x89\xde\x47\x1f\x60\x3d\xad\x3e\x0b\x5b\x66\xbd\x61\xbd\x69\xbd\x65\xbd\x6d\xad\xb2\xde\xb3\xd6\x5a\x9f\x84\x9f\x79\x13\x9a\x64\x3b\xb2\x21\x6c\xcf\xb0\x67\x37\x78\x5c\x5b\xab\xe2\xd5\xff\x01\xc9\x5f\xfc\x87\x25\xaf\xfd\x8f\x49\xfe\xe8\x3f\x26\xf9\x93\xff\x98\xe4\x75\xff\x82\xe4\x70\x25\xee\xb2\x99\x95\x18\xc9\xfd\xf1\x12\x23\x4d\x3b\x25\x86\x9f\x5f\x1b\xca\x8b\x8e\x3c\xe8\x2f\xba\xcc\xdf\x96\xb6\x5f\x86\x59\xf9\x71\xf2\xb7\xbc\x7d\x24\xff\xe3\x2d\x6e\xff\xe2\x8f\x6c\xff\x2c\xe6\x7e\x4b\xdb\xaf\xc6\x8c\x6e\x69\xfb\xb5\x3f\xb2\xfd\xb3\x3f\xb2\xfd\x8b\x3f\xb2\xfd\xb2\x1f\xd9\xfe\x8d\x1f\xd9\xfe\x8b\x58\xfb\x5d\x68\x67\x15\x74\x67\x0c\x42\x8f\xed\x62\x12\x97\xb3\xce\xb7\x2a\xb8\xde\x6f\x0b\x5b\xaf\x47\x6b\xde\xeb\x7c\xf5\x3e\xf3\x14\xb6\x42\x79\x0d\x0e\xaf\xe6\x13\x79\x1b\xbf\x80\x2f\x26\xc6\x1f\xac\x3e\x29\x9a\x26\xce\xa6\x70\xb1\x58\x20\x1e\x10\x0b\xa4\x25\x53\x72\x9c\x6c\x91\x17\xca\xc7\xe5\x0a\xf9\x8d\xd6\x47\xdb\x46\xbb\x9e\xee\x9f\x3e\xfa\x40\xb1\x40\x3f\x58\xbf\x40\x9f\x45\xe1\x3a\x7d\x83\xb1\xa7\xd1\x60\x5c\x6d\xcc\x33\x5e\x34\xe6\xe9\xb3\x8c\x37\xa8\x9e\xfe\x9b\x09\x73\x90\xb9\x8b\xb9\xbb\xd9\x64\xde\x6b\x6e\xb4\x9a\xad\x73\xad\x0b\xad\x1b\xe9\x5e\xfb\xc0\x5a\x6f\x27\x6c\xcf\xbe\xc0\x7e\x30\x51\x99\x78\x34\xf1\x71\x0f\xab\xc7\x36\x3d\x86\xf4\x18\xd6\xa3\xae\xc7\xd5\x3d\x16\xf6\x78\xb9\xc7\x86\x92\x7d\x4b\x26\x94\x4c\x2a\xb9\xa6\x64\x7e\xc9\x8a\x92\xcf\x4a\xbe\xeb\xd9\xaf\xa7\xd7\x73\x7c\xcf\xe6\x9e\xf3\x7b\x3e\xda\xf3\xcd\x5e\xac\x57\xa2\x57\xff\x5e\x03\x7b\x0d\xed\x75\x60\xaf\x43\x7b\x8d\xef\x35\xa1\x57\x13\xb3\xd9\x90\x8e\x05\x6c\xff\x8e\x65\x72\xbf\x8e\x05\xb2\x82\xd2\x6a\x4a\x0f\xa1\x70\x24\xe5\x8f\xa5\x70\x62\x47\x38\x8f\xfd\x3b\xea\xa8\xad\xa4\xb6\x65\x94\x4b\x77\x5c\xc6\xf6\xa5\xfa\xfd\x29\x7f\x1c\xa5\xe3\x29\x9c\xd0\xf1\xb1\xb9\x8a\xae\x6b\xd4\x6a\x19\xeb\xbd\x71\x03\xeb\x4b\x61\x08\xb5\x30\x55\x4d\xa1\x5f\x88\x57\x4d\xed\x97\x51\xfb\xcb\x54\xfb\x05\x5d\xda\x6b\xd4\x76\x19\xb5\x5d\x06\x8c\x05\xac\x2f\xeb\x4d\x3d\xfa\x50\xe8\x4b\x61\x07\x6a\xb3\x23\x85\xb0\xad\x43\x2d\xaa\xa9\x2e\xa0\x70\x28\x85\x91\x1d\x1f\xb3\xa3\x28\x1d\x4b\xd7\x8e\xa1\x74\x1c\xa5\xe3\x29\x9c\x40\xa1\x27\x49\xa9\x23\x29\x24\x8f\xd2\x1d\xa8\xe7\x8e\x14\x86\x90\x0e\x34\x66\xea\xbd\x80\x7a\x2f\xa3\xde\x0b\xa8\xf7\x32\xea\x19\x8e\x69\x19\x69\xdf\x9b\x6a\xfa\x50\xae\x2f\xa5\x43\x14\xde\x32\x6a\xbd\x4c\x61\xf5\x8e\x46\xab\xb4\xab\x83\x76\x0b\x48\xee\x02\xc8\xad\xa3\x96\x97\x41\xee\x65\xec\x68\x0a\x63\x28\x8c\xa3\xeb\xc7\x51\xe0\xe6\x2a\xf2\x58\x35\xea\x7f\x59\x27\x82\xaa\x11\x4a\xd3\x50\x4b\xa1\xae\xf5\xa5\x90\x08\xed\x24\x0f\xef\xb8\x5a\x1e\x45\xe1\x98\x8e\xb4\x3c\x76\xe3\x06\x39\xae\xe3\x22\x79\x22\xa5\x59\x9a\xa9\x1c\x85\x99\x24\x45\xd0\xbc\x5d\x41\xf3\x76\x05\xeb\x27\xab\xd8\x52\x9a\xd1\x3a\x9a\xd1\x3a\x9a\xd1\x3a\x79\x52\xc7\x65\x72\x02\xb5\xcb\x50\xa8\xa1\xfc\x24\x0a\xf5\x94\x9f\x42\xa1\x81\x42\x13\x85\xa9\x54\xd7\x4e\x61\x06\x85\xd3\xd9\x29\xf2\x4c\x42\xef\xb1\xa5\xe8\x6a\x0d\x58\x34\x9f\xdf\xd0\x7c\x7e\x43\xf8\x2f\x10\xfe\x01\x84\x7f\x00\xe1\x1f\x40\x38\xd7\x93\xcc\x93\x98\xd1\xad\x3c\x92\xc5\x74\x6a\xbf\x86\xda\xaf\xa1\xf6\x6b\xf2\x23\xe9\x4d\x6d\xaf\xa3\xb6\xd7\x11\xe6\x79\x34\x8a\xf7\x49\xfb\xf7\x49\xfb\xf7\x65\x1d\x85\x53\x28\x34\x53\x98\x4a\xa1\x9d\xc2\x0c\x0a\xa7\x51\x38\x93\xc2\xd9\x1d\xef\x2b\xb4\x65\xdd\xa2\x19\xb4\xee\xd7\x74\x8b\xa8\xe7\xc7\x10\xb3\x1f\xf9\x86\xd3\x3a\x1e\xa0\xfd\xa3\x77\x47\x40\x33\x16\xd0\xcc\x04\x9d\xeb\xb1\x8b\xad\x0f\x27\xbc\xd0\xde\x47\x51\x4a\x2b\x49\x1e\x4f\xe1\xa4\x8e\x40\x9e\x4c\x61\x22\xd5\xd7\x50\x9a\xed\x98\x47\x23\x58\x28\x27\x53\xbe\x9e\xea\xa6\x74\xac\x23\xfb\xd7\x91\x25\xe7\xd1\x48\x02\x1a\x49\x20\xa7\x53\x79\x06\xa5\x33\xa9\xee\xd4\x8e\x63\x42\xdb\xc9\x33\xa8\xee\x4c\xaa\x3b\x8b\x70\x07\x40\x93\x3a\x68\xa2\xd6\xde\x3f\x9d\xf5\x70\xbe\xb6\x74\xe6\x25\x49\xba\x23\x6f\x15\x41\x76\x5d\x46\x36\x5d\xc6\x6c\x92\xba\x94\xa4\x2d\x25\x49\x4b\xa9\xe7\x52\xea\xb9\x94\x7a\x2e\xa5\x16\x4b\xa9\xe7\x52\x6a\xb5\x94\xf5\xdd\xac\x2e\x3f\x66\xf5\x71\xd9\xd6\xf1\x24\xd3\x94\xde\x2d\x1d\x4b\x68\x0e\x96\x90\x45\x1e\x63\xdb\x90\xb4\x39\x64\xd3\xf3\x48\xe2\x6c\x92\x38\x87\x5a\x3c\x46\x52\x1f\x23\x9b\x9e\x47\x92\x67\xd3\xca\x78\x8c\xa4\xcf\x26\x9b\x3e\x46\x92\x0f\xa2\xde\x97\x90\xf4\x39\x24\xe1\x12\xb2\xed\x79\x84\x32\x87\xf4\x9d\x43\x48\x53\x09\x69\x0e\xd9\xf4\x3c\xd2\x7b\x0e\x2b\x29\x5a\x63\x8f\xd1\xfa\x7a\x4c\xad\xaf\x36\x4a\xbb\x5b\x63\x7d\xa8\xc7\x4a\x9a\xdb\x07\xa8\xd7\x4a\xea\xb5\x92\x7a\xad\xa4\x5e\x2b\xa9\xd7\x4a\xea\xb5\x92\x7a\xad\x24\xcc\x07\xa8\xe7\x6b\xd4\x73\x25\xcd\xe3\x03\xd4\x7b\x25\x61\x3e\x40\x12\x56\xb2\x84\x92\xf0\x43\xbd\x67\x50\xa0\x1e\x79\x4b\xac\xa4\x71\xac\x54\x96\xd8\xb4\x6f\x71\xbf\x10\x31\x44\x11\x9d\x16\x64\x3d\xa8\xcf\x72\xea\xb3\x9c\xfa\x2c\xa7\x3e\xcb\xa9\xcf\x72\xea\xb3\x9c\xfa\x2c\xa7\x3e\xcb\xa9\xcf\x72\xc2\x5b\x4e\xfd\x96\xab\x5d\xca\xa5\x55\xe6\xb2\xc6\x8e\xd9\xec\x0c\x0a\xb4\x7b\x75\xec\xa0\xe2\x11\x34\xcf\x8f\xb1\x6d\xe5\xa2\x8e\x9b\xe4\x73\x64\xed\xe7\x3b\x5e\x90\x2f\x52\xba\xa4\xc3\x95\x2f\x75\x8c\x90\x4b\x3b\xe6\xca\x57\x29\x7d\x93\xd2\x77\xe8\x1e\x7b\x8f\xc2\x27\x14\x3e\xa3\xb0\x9e\xc2\x17\x1d\x6b\x48\xca\x04\xda\xaf\x1e\xa2\xfb\xe1\x31\xd2\xef\x09\x0a\x8b\x28\x2c\xa6\xf2\x73\x94\xbe\x48\x61\x49\xc7\x74\x92\x36\x9b\xa4\xbd\x20\x5f\xa6\xfa\x57\x29\xbf\x8c\xea\xde\x24\x09\x2b\xa8\xfc\x2e\x69\xb0\xbe\x63\x89\x16\x7a\xb0\x7d\x63\x92\x16\x42\xd2\x92\x6e\x24\x2d\x81\xa4\xfb\x48\x92\x4b\x52\x96\x28\x7d\xbe\xa4\xba\x0d\x1d\x0b\xc9\x3f\xe8\x1c\xf3\x0e\x64\xaf\x1d\x3b\xd6\x74\x8e\x9d\xa4\x4f\x20\xe9\x37\x91\xe4\x35\xd0\x71\x21\x49\x5e\xa8\x24\xbc\x4d\xe9\x4a\x1a\xe9\xbb\x14\xde\xa3\x36\x6b\x28\xac\xa5\xf0\x11\x85\x8f\x29\x7c\x42\xfd\x3f\xa5\x74\x3d\x85\xef\x28\x7c\x4f\xed\x3a\x3a\xe6\x6a\xac\x63\x2e\xcd\xec\xab\x24\xf1\x4d\x1a\xc9\x6a\xb6\xb7\x5c\x1f\xfa\xe2\x21\x06\xed\x53\x21\x52\xa7\xfe\xaf\x52\x58\xa6\x46\xbb\x86\x66\xf1\x31\xc2\x0b\x47\xd9\xd5\x56\x73\x69\x84\x73\xd5\x08\xc3\xd1\x85\x7a\xad\x55\x72\x9e\x23\x39\x2f\x52\x08\xad\xf8\x26\xec\xbf\x91\xae\x08\xb9\x94\x24\xbe\x43\x88\xba\x92\xff\x76\x28\x9f\xc2\x06\xca\x6f\xa4\xda\x04\x8d\x79\x09\x61\xdd\x97\xc7\x7a\x89\xac\x18\x59\x6f\x61\xa7\x7c\xb2\xdc\x12\xf2\xda\x7a\x6f\x7c\x88\x76\xce\x87\xc8\x6a\x6b\x94\xd5\xce\xa0\x16\x91\xc5\x26\x50\xef\x9b\x30\x1f\xd3\xe5\x33\xd4\x63\x09\x59\x23\xd2\x74\x0d\x49\x9b\x4b\x92\xd6\x90\xe5\xf2\x6b\x84\xac\xb2\x86\xf5\xc2\x6c\x2e\xcc\xdb\xfb\x19\x65\x8d\xb0\xf7\x42\x35\x93\x2f\xab\x71\xde\xa4\xd6\xc3\xdb\x91\x65\x42\xcd\xd9\x60\x9a\x41\x5a\x9d\x14\xa0\x4b\x61\x5d\xa8\xf5\x0a\x69\x94\x0f\x2d\xb7\x94\xf2\x6a\x35\x51\xf9\x6d\x2a\xaf\xa4\xf2\x7b\x14\xd6\x50\xf8\x90\xc2\x5a\x0a\x1f\x51\xf8\x84\xc2\x3a\x0a\x9f\x52\xf8\x8c\xc2\x7a\x0a\xe1\x9a\xf9\x86\xc2\x77\x14\xbe\xa7\xd0\xd1\xb1\x90\x74\x5f\xa8\x34\x98\x40\x1a\x4c\xc0\x1a\x5a\x52\x18\x0b\xa1\x2c\x56\xa8\xd1\x8c\x87\xa8\x2b\xa9\xbc\x8a\x42\x64\x81\x25\xf2\x7d\x4a\x57\x53\x58\x43\xe1\x43\x0a\x6b\xc9\xfe\x1f\x51\xfa\xb1\xb2\xce\x12\xd2\x62\x0d\x69\x11\xde\x49\x4b\x48\x83\x35\xf2\x2b\x0a\x5f\x53\xf8\x86\x42\x07\xac\x17\xce\xdc\x6c\x42\x9c\x4e\x68\xb3\x61\xf3\x09\xd1\x7d\x49\x88\x85\xd5\xb1\x24\xbf\xca\xee\xa3\x15\x72\x9f\xb2\xc6\x27\xea\x8e\x58\x42\x2c\xf0\x36\xab\x96\xef\xd1\x9a\xfc\x84\xed\xad\x4a\x7b\x53\x49\xad\x10\x5a\x39\x74\xf7\xa9\xbd\x20\x9c\xa7\x9b\x70\xd7\xcd\x26\x59\x0b\xd5\xf8\x9e\x51\x77\xde\x5c\x92\x39\x97\x90\x77\xa0\xb9\x9a\x4d\xa8\x2e\x59\x3a\x5c\x37\x73\xa9\xa7\xa1\x56\x71\xb8\xb2\x5e\xa0\x1e\x73\xe5\x73\x24\x79\x29\x21\xbc\x0c\xdd\xde\xa5\xfc\xfb\x54\xf7\x11\xdb\x56\xdd\xdd\x36\x70\x66\x63\x2d\xce\xce\xaf\xea\x25\xf9\x35\x39\x97\x46\xb3\x1a\xab\x72\x9d\x5a\xe7\xe1\x3d\x3d\x5d\xad\x75\x4b\xed\x15\xef\x2b\x7b\xaa\xf1\x75\xde\xf1\xf2\x5b\x35\x6b\x6b\x68\x37\x0f\xe7\xff\x1d\xb5\x16\x97\x60\x26\x96\x40\x5e\xb8\x06\x96\x28\xcb\x84\x56\xff\x1c\xb2\xbf\xa0\xfc\x06\xd2\xe4\x5b\x75\x27\x2f\x21\x1d\xdf\x8e\xad\xe4\xd5\x0a\x6b\x8d\x9a\x3b\xec\x7c\xaa\x15\x57\xf7\x70\x49\xbe\xed\xfb\xf9\xb6\x0b\x55\xdb\x70\x87\x2c\x20\x84\xf7\xd7\x4d\x21\x0a\xed\x13\x9f\xc7\xee\xcf\x6f\xc9\x26\x3d\x95\x8c\x77\x62\x98\x9d\xe3\x2b\x60\x2e\xc9\xcb\x89\x34\x5d\x48\x72\xe8\x8e\x8f\x50\x22\x59\x34\x9b\xd1\xbd\xb3\x90\xf6\x81\xd5\x5d\xf7\x68\xd8\x2e\xb2\x44\xa7\xed\xc2\x95\x1f\x8e\x7c\x6e\x78\x15\x23\x2f\x8c\x22\x42\xef\xbc\x3f\x0a\xad\xd6\x90\xf4\xf7\x21\x39\xea\x1f\xda\x7e\x49\xf8\x8d\x4f\xba\xd6\x97\x6a\x37\xb5\x48\x61\x24\x9f\xe6\xf5\x5a\x92\x97\x67\x50\xcf\xe9\xd4\x73\x3a\x8d\x28\x5a\x2d\xa1\xbd\xc3\x9d\xcb\x50\x63\x7c\x4f\xd5\xd0\xbc\x45\x2c\x11\xea\x42\x63\x79\x3b\x36\x3f\x9d\x8c\xf4\x45\x61\x3c\x64\x8d\xb7\xf3\xab\x3c\xca\xed\x4d\x73\xb6\x81\xf6\x13\x2d\x6f\xdf\x2f\x3b\x5e\x50\x1a\xc4\x6b\xd4\x58\x95\xf7\x3e\x9b\x74\x9a\xad\xd8\x33\xca\x35\xd2\x28\xcf\x08\x67\xde\x5c\x49\xde\x9a\x24\xcf\xf4\x32\x3a\xa9\x44\x7e\xb3\x2e\xef\xea\x30\xe4\x42\xba\x47\x96\x6c\xfc\x58\xbe\xba\xf1\x15\xda\xcf\xc2\xbf\xc9\x30\x85\xda\xf5\xa7\x33\xf1\x1e\x6c\x1f\xe6\xb2\x24\x2b\x63\x69\xb6\x2f\xdb\x9f\x1d\xc6\xc6\xb2\xe3\xd8\x78\x76\x82\xdc\x4f\x1e\x2c\x2b\x64\xa5\xac\x96\x81\x3c\x44\x1e\x2e\x8f\x90\x47\xca\xa3\xe4\x18\x39\x56\x1e\x23\x8f\xa5\xf3\xe8\x71\x72\xbc\x3c\x5e\x9e\x28\x4f\x96\x93\xe4\x64\x59\x27\x1b\x64\xa3\x6c\x96\x53\xe9\x9c\xda\x2a\xa7\xc9\x19\x72\xa6\x3c\x4d\x9e\x29\xcf\x56\xef\x21\xde\x2f\x1f\x92\x0f\xcb\x47\xe4\xa3\xf2\x31\x3a\xc3\x3e\x21\x17\xc9\xa7\xe5\x62\xf9\x8c\x7c\x4e\x12\xab\xcb\x25\xf2\x25\xb9\x54\xbe\x2c\x5f\x91\xaf\xcb\x65\x72\xb9\x7c\x53\xbe\x25\xdf\x96\xef\xc8\x95\xea\xef\x88\xbc\x27\xdf\x97\xab\xe5\x87\x72\xad\xfc\x48\x7e\x22\x3f\x95\x9f\xc9\xcf\xe5\x7a\xf9\x85\xfc\x52\x7e\x25\xbf\x91\xdf\xcb\x8d\xb2\x43\xeb\xad\x55\x98\x2b\xcd\x55\xe6\x1a\x1a\x59\x82\xfc\xec\xed\x28\xc6\x09\xfd\x7f\xc9\x93\xfc\x09\xe1\x5b\xa9\xf2\xb6\x30\x16\x67\xab\xfc\x83\x2a\x5e\xad\xbe\x93\xb3\x5e\xd5\x0f\x52\x6f\xae\x96\x17\xe2\xa8\x5e\x36\x17\xc7\xda\x1d\x85\x18\x7d\x2f\x8e\xd5\x47\x12\x46\x16\x62\xf9\x52\x21\x8e\xae\xca\x13\xc2\x58\x1f\x5d\xe8\xb5\x29\x4a\xa4\x1b\x10\x27\x14\xeb\xbc\xa9\x3e\x91\xcc\x28\x6f\xcc\x2d\xc8\x8f\xe7\x23\x39\xf1\x78\x8b\x6c\x72\xed\x3f\xb7\x46\x17\x0b\x6c\x32\xf6\xcd\x8d\x5a\x5c\xa5\xea\xbf\x8b\xb5\x1c\xb9\x19\x6b\x34\xff\xa8\xef\xe4\x74\xbe\x37\x52\x78\x92\x1f\xfb\xde\x0f\xd6\xec\xe2\xff\xee\x35\x8b\xf7\x25\x57\xa8\x78\x4c\x21\xdf\xe5\xdd\xcc\x4d\xdf\xd9\x9c\x55\xf8\x84\x24\xfe\x86\xe6\xa6\xef\xba\x76\x79\x37\x33\xaa\x1f\x5a\xf8\x4c\x46\x0c\x8a\xe5\xe3\x6f\x62\xc6\xdf\x4b\xdd\xe4\x7d\xc9\x78\x7d\x5c\xff\x2e\xef\xcc\xc6\xf5\xd9\x82\x77\x63\xa5\x57\x88\x7f\xac\x4d\x60\x8d\x45\xdd\xa3\xc7\x2d\x10\x1f\xfb\x0f\x8f\xba\xcb\x7b\xa6\xf1\x77\x4b\x63\x6f\x92\xc6\xde\xa8\xdd\xf2\x35\xfb\xaf\xbc\xeb\xb2\x1d\x21\x4c\xa2\x10\xea\xda\xc2\x98\xd2\xed\x4c\x0a\xe1\xe7\x61\x17\x53\x08\x67\x3a\x7c\xdf\x32\x7c\x9b\xf3\x46\x0a\xe1\x7b\xc0\xb7\x53\x08\xd7\xc7\x7d\x14\x1e\xa4\xf0\x38\x85\x70\x04\x2f\x52\x78\x95\xc2\x9b\x14\xc2\xcf\x1e\x3f\xa0\x10\x5a\xe8\x4b\xc6\x37\xde\x16\xbe\x65\xb5\x45\xf1\xa1\x9b\xd4\x5c\xf3\x6f\xc5\x4c\xbd\x43\xca\xba\xbb\x8a\xfb\xf8\x9e\xff\xee\xfb\x38\x7a\x7f\x20\xfa\x9e\x4d\xf4\x0d\x1b\x7c\x4f\x65\x55\xe1\xf3\xf7\xe8\xb3\xfb\xce\xef\xbb\x14\xea\x3b\xbf\x4d\x52\x78\xf3\x21\xba\x8a\x77\x06\xa2\xbe\x2b\x62\x7d\x9f\x8f\xc9\x8f\xe2\xe8\x7b\x51\x57\xc5\x6a\x62\xd2\xa2\x4f\xf6\x3b\xbf\xc3\x14\x8b\xc7\x15\xf2\xd0\x3f\xa6\xf3\xa6\xfa\xa0\x26\xf6\x86\x46\x37\xf1\x26\xef\x57\x6c\xb9\x4d\x36\x67\x0d\xd8\x21\x6e\x81\xf8\xd8\x7f\x70\xd4\xfc\xe0\x18\x96\xfa\xc6\x4b\xf4\x4d\x98\xb8\xce\x31\xc4\x2d\xbf\x8f\x7f\xf8\x0d\xc4\xf0\x5d\x9e\x7d\x29\x1c\xcc\x7e\xec\xf7\x79\x30\x97\xd0\x75\x45\x61\x76\x31\x92\xc8\x8e\x56\xec\xaa\x1a\x39\x3f\x3d\xf6\x36\x49\x4a\xc5\x63\x30\xf2\xa6\xff\xbd\x5c\x18\xff\x46\x03\xde\x3a\xd8\x94\x0b\x17\xc5\x98\x6c\x33\x5c\x48\x3e\x79\xb7\x5c\x08\x26\x8b\x76\xf6\xd8\xb7\x51\xd8\xe8\xcd\x70\xe1\xa6\xdf\x2e\x89\x49\x80\xe4\x79\xff\x2e\x17\x76\x91\xff\xc3\x36\xd9\xe4\x3b\x1d\x3f\x6c\x8d\x2e\x16\x18\x57\xcc\x85\x9b\x1b\x35\x98\xf5\x07\xb9\x30\x42\x54\xf1\xff\x27\xb8\x90\xee\x87\xfe\x31\x3f\xab\x7f\xbe\x26\xca\x5f\xaf\xe2\xc8\x2e\x75\x9b\xb4\xd9\x5d\xc5\x2f\xc6\xda\x47\x71\x7f\x15\xd7\x6e\x12\x37\xa9\x78\x86\x8a\xd5\x4a\xc5\xb7\x80\xc6\x84\x35\xe4\xb3\xe4\xe3\xf0\x6f\x0e\xf1\x83\x59\xe1\x1d\x96\xb0\xce\xf8\x7e\x55\xe7\xff\x8d\xcd\xdd\x7c\x22\x1b\xb6\x09\xff\x97\xa8\x4f\x51\x17\x75\x94\xe3\x53\x55\xa6\xf4\x0e\x4d\x71\xc0\x8d\xcf\x85\xe9\xa2\x23\xcf\xb9\x5b\x95\xaf\x58\x97\xfe\x7f\x02\x00\x00\xff\xff\x3f\x16\x14\x69\x18\x6d\x05\x00") + +func liberationsansItalicTtfBytes() ([]byte, error) { + return bindataRead( + _liberationsansItalicTtf, + "LiberationSans-Italic.ttf", + ) +} + +func liberationsansItalicTtf() (*asset, error) { + bytes, err := liberationsansItalicTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationSans-Italic.ttf", size: 355608, mode: os.FileMode(420), modTime: time.Unix(1459927769, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationsansRegularTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xbd\x79\x80\x8d\x75\x1f\xff\xfd\xf9\x5e\xd7\x75\xb6\x31\x63\xf6\x85\xc1\x39\x33\x63\x6c\x83\xc1\x18\x7b\xe6\x64\x19\x84\x8c\x7d\xc6\x58\xc6\x16\x22\xdb\x50\x48\xa1\x84\x44\x28\xad\x14\x95\x64\xcd\x88\x18\xa2\xb4\x29\x21\x2a\xb4\x29\x22\x46\x51\x4a\xda\x2c\xe7\x3c\xaf\xeb\x3a\x67\x34\x54\xf7\x7d\xff\x9e\xdf\xf3\xdf\x33\x77\x6f\xdf\xeb\xfa\x2e\x9f\xe5\xfd\xf9\x7c\xb7\x73\x86\x5b\x94\x88\x44\xf3\x87\x21\xf5\xb2\xb3\x7b\x74\x1e\x18\xf1\x50\x77\xb1\xf5\x3e\x4a\x6d\xa5\x76\x6d\xda\x66\xdf\xe3\x9b\x50\x5f\x6c\x7a\x43\xde\xe7\xb4\xcb\xe9\xd2\x3d\xb2\x68\xfc\x73\x62\x0b\x9d\x27\xd2\xf1\xd6\x76\xdd\x7b\xb6\xea\xd2\xb5\x6e\x79\xda\x77\x88\x38\x0f\x76\xe9\x9e\xde\x40\x56\xee\x7d\x42\x44\x15\xd3\xbf\x60\xf0\x1d\x03\xc7\x46\x3d\x99\xff\x8e\x48\xad\x99\x22\xf6\xba\x83\xef\x9c\xe0\xb9\xe5\x8b\x8e\x97\x44\x9a\xaf\x13\xd1\xe6\xdc\x36\x76\xd8\x1d\xf7\x0e\xdc\x12\x29\x52\x6f\xb3\x88\x63\xf3\xb0\x81\x85\x63\x25\x41\x5c\xc8\xab\xca\xf8\x88\x61\xa3\x26\xdf\xd6\xe2\x89\xce\x4f\x8a\xdc\xb6\x42\x8c\xe8\xa9\xc3\x87\x0e\x1c\x22\xc3\x67\xfe\x86\xfc\x16\xb4\x37\x1a\x4e\x45\xd8\xe2\x30\xda\xd5\x04\xde\xab\x0e\xbf\x63\xc2\xa4\x2f\x6b\x15\x3f\x83\xec\x04\x91\x1a\xa3\x46\x0e\x1d\x3f\x5a\x1a\x55\x6e\x28\xc6\x14\x8f\x48\x6c\x9f\x51\x63\x06\x0f\x8c\xab\xf0\xcc\x58\x91\x96\xf8\x53\x63\xec\x1d\x03\x27\x8d\x0d\x9b\xab\x7f\xcb\x78\x64\x88\x67\xf4\xc0\x3b\x86\x9e\xbe\xf4\xc0\x77\x62\x2c\x98\x2a\x52\xee\xa1\xb1\x63\x0a\x27\xcc\xfe\x63\xed\x65\x31\x96\x38\x45\x86\x57\x18\x3b\x7e\xe8\xd8\xab\x2f\xb7\xeb\x20\xd2\x64\xb8\x88\xde\xda\xe2\x4e\x13\x39\xd2\xbb\x4e\xde\x80\xf0\x16\xbf\x6a\x6e\xba\xf1\xb3\xef\xd1\xca\xed\x4a\xcb\xcb\x2b\xaf\x3e\x1a\x72\xbb\xe3\x53\x5e\xcd\x46\x65\x75\xe0\x4f\x47\x4b\xdf\xad\xd2\x3a\x64\xf3\xe5\x95\x97\xa6\x84\xdc\x1e\xac\xbf\xf6\x13\x92\x68\xd6\x84\x24\xaa\x6e\xd2\x43\xfa\x8a\x1d\x2d\x11\x92\xce\x93\x68\x2b\x34\x83\x58\x29\xd1\x8d\xe7\xd5\x42\xb1\x89\xd8\x9e\xb6\x65\x20\x32\x31\x50\xea\x1f\xc9\x6d\x5a\x94\xd3\xa6\x95\xb3\x1b\x9a\xf9\x63\x1c\x97\x10\x7f\x8e\x4c\xf2\x23\x36\xc9\x94\x5d\xff\xe6\xee\xad\xc5\x2b\x1e\xff\x15\xdb\x27\xbe\xae\x2a\xc3\xd1\x52\xbd\x52\x20\xea\x8d\x63\xbf\x93\x04\xcd\x6c\x33\x4c\x26\xa4\xbc\x5d\x64\xbf\xd9\x5b\x6b\x7a\x0d\xdb\xb4\x4f\xa5\xb7\x51\x28\x2e\x10\xe7\xa8\x2c\x1d\x6c\xbd\xa4\xbd\x9a\x2d\xc3\xb5\x35\x32\x0d\x84\xea\x95\x25\xc9\x58\x27\x43\xe8\x5b\xcc\x7b\x3e\xe5\x6b\xe6\x58\xfa\xe7\x80\xa5\x60\x18\xb8\x15\xa4\x83\x6e\x60\x38\x18\x01\xf2\x40\x41\xb0\x7f\x31\x32\x86\x9a\x72\xac\xb2\x50\x7a\x38\xdd\xf2\x1c\xba\x0c\xb0\xca\xf6\x9e\x0c\x07\xab\xcc\x67\xe3\xa4\xac\xb2\x37\x95\x61\xe6\x3b\xe3\x76\x1a\x58\x6e\xd5\x17\x52\xbf\xc6\xea\x6b\xb6\x0f\x34\xeb\xac\x32\x30\xae\x1f\xe3\xea\xf2\xfc\x2c\xcf\x2e\xc7\x7c\x71\x51\xd6\x05\x75\xa8\xbf\x19\x39\x8f\x04\xfd\x8d\xd0\xdf\x94\x10\xa3\xd0\xff\x0d\xbe\xdc\x8e\x4c\xd3\xf7\x99\xe8\x30\xcb\x5e\xe6\x3b\x7d\x2a\x07\x9f\x1f\x56\xef\xc9\x83\xea\x3d\xff\x87\xb4\xcf\xe5\x79\x2e\xfa\xe7\x50\x3f\x27\xd8\x3e\xd3\x2c\x35\xb3\x4e\xa4\x29\xe3\xdc\xbc\x3f\xc0\xb3\xc3\xf6\x9e\xff\x2a\x65\x3c\xb0\x81\xee\xda\x3a\x49\xd6\x62\x64\xab\x59\xe2\x7f\x5f\xcb\x96\x35\x72\x81\xfe\xb3\x41\x33\x30\x0e\x9b\x7c\x66\x1f\x9e\x0b\x69\xab\x63\x3b\x25\x6e\xed\x37\xa9\xc8\x7b\x77\x8b\x7f\xb8\x37\xeb\x8c\x91\xfe\xf3\x7a\x86\x4c\x31\x86\xe0\xd7\x1a\xa9\x09\x12\x41\x7b\x63\xa9\xcc\x33\x3a\x49\x0e\xcf\xbf\x80\xbb\x40\x8e\x76\x4e\x12\xcd\xf1\xf6\x75\xd2\x24\x88\x0e\xf0\x71\x7f\x90\xf7\xbf\x81\x64\x4e\xb0\x62\xd1\x2b\x10\x8b\x52\x60\xaf\x0b\x3c\xac\x35\xf5\x7f\x4c\x89\x7f\x52\xbe\x34\x0e\x37\x02\x5b\x1f\xa6\x6c\x67\xc5\xa2\x2c\x88\x45\x30\xbe\x0f\x07\x79\xff\x1b\xc8\xbf\x56\xc1\x58\x5c\x07\x74\x86\x80\xd9\xe8\xff\x84\xd2\x19\xe4\x7f\x5e\xb0\xbc\x1e\xf0\x82\x8e\xda\x3c\x3f\x74\x1d\xcc\x58\x14\xca\x5c\xb3\x34\x7d\x35\xe5\xfe\xad\xc4\x77\x53\xff\x7f\x28\x57\x19\x67\xa5\x97\xe9\xbf\xa9\x2b\x98\x97\xbd\xff\x5b\x69\xe6\xb3\xd9\xff\xdf\x4a\x4b\x2e\xf9\x16\x94\x8b\xaf\xfe\xe2\x00\x24\x34\x00\x93\x77\x8b\xfb\xbe\xe4\xa1\xdb\x9c\x17\xe0\x2d\xdb\x37\xb2\x46\x9f\x2f\x0f\x9a\x73\x84\x3c\x7d\xca\xd2\x27\x96\x8f\x73\xcd\xf9\x42\xdf\xfc\x60\x79\xaf\x59\x6a\x3d\x03\xf5\xe4\xa1\x59\xc6\x50\x1f\x11\xd4\x3d\xef\xc6\xd2\x38\xec\xf7\xd9\xf6\xc8\x8b\xe6\xb3\x15\xd7\x80\xbd\xd7\x95\xe4\xcb\x40\xe6\x9a\x65\xbf\x39\x0f\x82\xe5\x8c\x60\xd9\xc4\x9a\x97\xcc\x8d\x7f\x2b\xcd\x39\x6b\xcd\x1b\x4a\x5d\x02\xa5\xf9\x6e\xe6\x8b\x39\x97\xfe\xd7\xd2\x9a\xef\xcc\x39\x6b\xbe\x07\xe2\x6b\xcd\x7b\x73\xee\xdd\x58\x9a\xf3\x98\x31\xe5\xec\x91\x12\x63\xf3\x5a\xbe\xce\xa4\x0c\x31\x79\x47\x5e\x7e\x99\x58\x97\xb7\x4f\xb1\xfa\x74\xb5\xd6\xb5\x09\x56\xbc\xf3\xec\x36\xe9\x6f\x1c\x96\x5c\xe3\xa4\x7f\x37\xf5\xbb\xac\x18\xfa\x24\xc4\x11\x6a\xad\x17\x73\xb1\xbf\x4a\x69\x1c\x78\x8f\xa1\x2c\xef\xf0\x98\x73\xc0\x7f\xd0\x5c\x3b\xac\x79\x72\x94\x75\x2b\x0b\x1e\x2f\x50\xf6\xa6\x74\xd1\x8f\xdc\x0c\xce\xb7\x41\x8c\xe9\x62\x5c\x90\x51\x7a\x39\x69\x1d\xe4\x27\xa6\x94\x27\xfb\x61\x64\xe5\xe3\xfb\x65\xcb\xc6\x67\xed\x75\x03\x3e\xd3\xd6\x92\x32\x9d\xd2\xf4\x3d\xdb\xe8\x0b\xc7\x7d\xad\x75\xb9\x8f\xb9\x16\xeb\x6b\xe1\xf8\x94\x54\x35\xf5\xb0\xce\x14\xe9\xb7\xca\x26\xe6\xea\x78\x73\x0f\x08\x61\x5d\x75\x11\x33\xe7\x10\x62\x3a\x2d\xb0\xce\xea\x4b\x65\xae\x59\xe7\x78\x98\xf7\x34\x62\x1b\x9c\x23\xe4\xe1\x11\x72\xed\xc1\xd2\x1c\xf8\x5f\x63\x14\x9c\x2f\xd7\xcd\x37\x73\xbd\x31\xe7\xfc\xdf\xe6\x43\x90\xbf\x1b\xf3\xcd\xf2\xad\xaf\xb4\x41\xff\x23\x65\x6d\x2e\x1d\xe7\xcc\x66\xdc\x85\xc0\x1e\x61\x72\xfd\x0f\x7a\xda\x99\x6b\xc3\x3f\xcc\xff\xeb\xe6\x2b\x3e\x8e\x00\xe6\xba\xe3\xa4\xbc\x74\xa3\x1d\x81\xfc\xf6\xbf\x11\xcc\xf3\x51\x41\x1f\x47\x5c\xf3\xf9\xc6\xfc\xee\x2b\x5e\xfd\x5e\x49\xba\x36\xcf\x57\xca\x0a\x1b\xf9\x64\x1c\xa1\xdf\x2c\x19\x10\xcc\xcd\xfa\x37\xda\xf3\x6f\xf3\xee\x9a\x1d\xc1\x7c\xd7\xf6\xfa\x57\xdb\xa6\xc8\x1c\xed\x27\xff\x56\x73\xbf\x72\x24\x48\x77\x13\xd6\xba\x1e\xc8\x67\x33\xbf\x2b\x9a\xf6\xf0\xdc\xce\xd4\x65\xbc\x28\x19\xfa\x72\xf2\xbb\x97\x65\x57\x4d\x5b\xae\xb5\x67\x9a\x7a\xdb\x04\xd7\x93\x0f\x6d\xa7\xaf\xf9\x6b\xee\x57\x31\xa5\xfa\xa8\x53\xc1\xf5\xf6\xde\xe0\xfe\x79\x13\xe8\x5c\x66\x1d\xb6\xd6\x6d\xdb\x77\xd2\x9b\xbc\x6b\x0f\x32\x6d\x61\x92\x69\x84\x4b\xc7\x32\xeb\x77\x2f\x63\x12\x73\x49\x13\x87\x71\x5e\xe2\x4c\x5e\x4a\xc1\xbc\x49\x00\xbd\xb4\xcf\xa5\x8d\xf6\x2c\xba\x47\x4b\x38\xef\xb3\x8c\x47\xe5\x7e\x72\xf3\xc1\x20\xd8\x87\xfd\xcf\x59\xfb\xf1\x28\x6b\x5c\x2f\x7b\x77\x90\x85\xee\xdb\xac\x7d\x39\xad\x0c\xe6\x04\xf1\x30\xf0\x18\x3d\xe9\x6f\x82\x18\xe1\x27\xf3\xc1\xff\x36\xe5\x7d\xda\x5e\xeb\x8c\xe0\x0e\xee\xe5\x15\x8d\x79\xd2\xc3\x28\x28\xdd\xd3\xc5\x4e\x19\x6e\xd4\x60\x4f\x35\xf9\xeb\x01\xc8\x45\x30\xca\x8a\xb5\xb0\xd6\x06\xca\x40\xdc\xbc\xc8\x0f\x67\xbf\x35\x7d\x1c\x29\xb3\xf4\xba\x70\xc6\x91\x4e\x6f\x8e\x1f\xa6\xef\xe6\x5c\x65\x9e\x3b\xb6\x4a\x2f\x87\x97\xdc\x2d\x07\xcf\x9b\xa4\xa6\x3e\x86\x58\xec\x12\xb7\xbd\x92\x54\xb6\xdd\xc2\x9a\x10\x2e\x73\xf5\x13\x52\xc1\x68\x22\x83\x6d\xd3\xa4\xba\x09\x3d\x52\x06\x9a\x50\xd9\xfe\xef\xd4\x59\x19\x06\x6a\x80\x38\xed\x7b\x19\xa2\x7f\xee\xbf\xa0\x2d\xf2\xff\x6a\x9d\xe1\x38\xdb\xc1\xdb\x34\x70\xa7\xb5\x36\xad\x91\xdf\xc0\x25\xed\x03\x69\x08\x32\x82\x67\xb2\x6b\xa0\x4d\x02\x50\x95\x28\x33\xc0\x7b\xe0\xb1\xe0\x7b\xeb\xe0\xb9\xe2\x14\xfc\x6c\xb4\x50\x2a\x6f\x8d\x3c\x57\x06\x95\x99\x1b\x5f\x51\x2e\x0d\xca\xe0\x4c\xe2\xff\x8e\x32\x8e\xf2\x34\xa5\xae\x2d\xf6\x5f\x50\xad\x38\xd3\x14\x4b\x6d\x6d\xb9\x18\xa6\x2d\x7a\x84\x2c\xbf\x11\xf4\x1d\x14\x84\x04\xe4\x5a\xe7\x9b\x19\x41\xbc\x1f\xc4\xfc\x00\x4c\xd9\xfe\x12\x4b\x97\x79\xe6\x5c\x63\xf9\x7b\x0d\xf0\x5f\x05\xc4\xf3\xdc\x4c\xe4\xea\x15\x11\xdf\x63\xe0\x55\x11\xff\x77\x94\x3f\x50\xb7\x96\x92\x3b\x92\x7f\x25\xa5\x59\x17\xcf\x73\x13\xca\x69\xc1\x7e\x7b\x40\x5e\xf0\xfd\x68\xb0\xef\x92\x1b\x90\x0f\xba\x80\x2c\xd0\x9f\x3e\xb3\x39\x6e\xb7\x0c\xc8\xf4\x77\x02\x9d\x41\x47\xea\x4d\x59\x91\x81\x7b\xc1\x15\x7f\x40\x9f\xa9\xcb\xff\x14\xb8\x25\xd8\x77\x67\x60\xbc\x8f\xbb\x8f\x6f\x5b\xc0\x86\x52\xbd\xbe\xa7\xcb\xd8\xbc\x27\xf8\xfe\x1c\xef\xeb\x29\x91\xe9\x3b\xcd\xf8\x17\x02\xe3\xfd\x6d\x28\x9f\xa7\x4c\x05\xdc\xe3\xae\x72\x4f\xf3\x6d\xa2\x53\x14\xe5\x0a\xea\x96\x52\x22\xc7\xbf\x3d\xa8\x2f\x8c\x67\xee\x3a\xfe\x4c\x9e\xb1\xc7\xb7\x2c\x88\xf3\x01\xdf\xae\xc6\x51\x4e\x08\xca\x3f\x1a\x94\x3b\x21\x00\xdf\x19\x4a\x64\xca\xaf\x94\x37\xf3\xfe\x46\xd0\xaf\xee\xff\x0e\xdf\x6b\x00\xdd\xfe\x77\x82\x7e\x7e\x01\xb8\xa7\xf8\xde\x07\xdc\xb1\x7c\x15\x68\x1b\x0c\x7a\xf3\x4c\x26\xf8\xb6\x10\xc3\x3f\xc1\x44\xf0\x13\x73\xa8\xa5\x75\x66\xa4\x0c\xde\x51\xf6\x9b\xb9\xc2\xbe\x6a\x98\x79\x60\xcf\xf6\xff\x6a\xdf\xec\xbf\xa0\x47\xf9\xcf\xd8\x1b\xf8\x5f\xb3\x7f\x26\x37\xdb\x6d\xfe\xd7\x98\xef\x45\xa5\xf7\x0f\x63\x38\x7b\x46\xae\xdc\x14\x3c\x9f\xde\x5c\x7a\xb6\x35\xcf\x59\xd6\x9e\x9c\x2b\x21\xa5\x77\x0f\x5b\x86\xf4\x29\x73\xef\x30\xf7\x9b\x51\xd6\xdd\x83\xb5\xd1\x3e\x48\x26\x9a\xf7\x0e\xfb\x06\x59\x64\xee\xcf\xd6\x59\xd9\x5c\x33\x97\x4b\x2f\x7d\x11\x7b\x72\xa1\xdc\x6e\xde\x29\xac\x35\x85\x3a\xe3\x69\x6b\x0d\x72\x98\x67\x0b\xb3\x5d\x9f\x6d\xad\x8b\xb7\x5f\xeb\x17\x38\xcb\x95\xe7\x6c\x6f\x96\xa2\x3f\x16\x58\x37\x6d\x0f\x70\x3e\x98\x2f\x33\xf5\x2f\x79\xff\x89\xb1\x35\xb9\xb3\x20\xd3\x56\x4f\x7a\x1a\x19\x12\x6b\xdb\x2c\xb3\x59\x07\x39\xeb\xf8\xf7\x5b\xba\xcc\xf5\x86\xd2\xac\x43\x67\x21\xcf\x2e\xce\x0d\x4d\x1d\x6b\xa4\x92\x59\x1a\x77\x4b\x0e\x6d\xdd\x8c\x03\xd2\xa6\xcc\x1e\x37\x1e\x9d\x7d\xcc\xfb\x18\x6b\xd6\x1c\xc3\xcf\xfa\xd5\x42\x1a\xd8\xc3\xd8\x43\x9e\x91\xc1\x9c\x69\x56\xc2\xc9\x4c\xdb\x50\xee\x74\xe6\x9e\x36\x44\x56\x98\xfb\x0c\xfe\x8e\x36\xc1\x15\xd5\x61\xbc\x2b\x71\xdc\x59\x06\x1a\xa3\xa5\x83\xbe\x45\x62\xf4\x76\x52\xc3\xd4\x61\x3c\x66\x9d\x71\x7a\x9b\x7b\x8c\xa9\x4f\x7f\x50\x72\x4c\x04\xf7\x9f\xb9\xe6\x9e\x65\xf1\x3d\x1d\x7e\xe6\xff\x75\x2e\xb3\x4a\x33\x1e\xbd\x89\xcf\x59\xec\xe8\xc9\xf3\x2e\xeb\xbe\xd2\x2f\x78\x26\x76\x98\x7b\x97\x73\xa2\x44\x39\x63\xe9\x73\x98\x3e\xab\xad\x3e\xab\x6c\xb1\xd2\xd8\x2a\xcd\x98\x7b\x83\xb1\x33\xc7\x8f\x94\x70\xf3\xd9\x31\x58\x2a\x71\xae\x6b\x6d\xf5\x01\xd6\x38\xaf\x44\x5d\x77\xe7\xdc\x25\x2b\x4b\xef\xab\x56\xcc\x91\x69\x8f\x95\x3b\xad\xbb\xe6\x59\xea\x7b\xca\x72\x07\x32\x1d\xd3\xe9\xdf\x53\xea\x3a\x62\x2d\x19\xa6\xbc\x11\xa6\x3d\x8c\x2b\xb0\xf6\xc6\xc7\x64\x92\xb9\x3f\x68\x67\xf1\x6f\xad\x75\xf6\xeb\x6d\xeb\x23\x0e\xf6\xc9\xfa\xec\x17\x0f\x9b\xd0\xa7\x13\xf3\xb5\x52\xce\xe2\x60\x64\x60\x7f\xb3\xf6\xac\xe0\x7d\x55\x5f\x23\x29\xe6\x5e\x6c\x7f\xcc\xda\x4b\xe2\x91\xf9\xb0\x91\x26\x53\xec\xf4\xa5\xee\x61\x9b\x70\xdf\xda\x65\xd5\x3d\x6c\x98\x76\x8a\xb5\xe7\x45\x96\xb9\x57\x85\x58\xfa\x63\xad\xb9\xd3\xd4\xcc\x37\xce\x3a\x7f\x58\xe7\x07\x2f\xe7\xe3\xe9\x96\xae\x10\xcb\x8e\x49\x56\x9e\xda\x4c\x3b\x42\x36\x93\x17\x3e\x09\x87\x8f\x58\xa3\x44\x62\x1d\x4f\x31\x47\x5e\xe5\xac\x95\xcb\xd9\x45\xc4\xee\xa8\x2b\x6f\xd8\x16\xca\x2c\xfb\x73\x32\xd9\x76\xb7\x4c\x71\xde\x21\x3b\xed\x3f\x91\x3f\x87\xa5\x00\xff\x3c\xf6\x01\x70\x7c\xdf\x5f\x79\x66\xbf\x83\x73\x47\xa8\x38\x4a\x4b\xe7\x93\xdc\x29\x6a\x4b\x4f\x78\x6f\x64\x9c\x96\x34\xd7\x6c\x19\x65\x3f\x28\xbd\x4b\xf5\x06\xcf\x33\x39\x86\x43\xca\x05\xd6\x35\xdf\x0e\xd6\x86\x65\x01\x5c\xfd\x84\xf5\x94\xf5\xe8\xca\x48\x2b\x86\xd8\x0d\xff\x06\x1c\xc4\x04\x73\x6b\xa6\xfe\x1d\xf9\x7c\x8b\xc9\x85\xdf\x8f\xff\x31\xb6\x7e\xf2\x12\x77\xc6\xf9\x66\xfc\xcd\x18\x98\x39\x60\xc5\x81\xf8\x5b\xbe\xff\x55\x1a\x94\x21\xb6\xf3\x52\xd3\xe8\x20\x35\xac\xb3\x1c\x7c\x38\x5c\xc4\x35\x5d\x1e\x76\x25\x10\xf3\xdf\x38\xdf\xdb\x59\x8f\xd2\x24\xa5\xf4\x1e\x61\xdd\x6d\xcc\x58\x15\x5a\x77\x01\x47\x69\x69\xe6\x8c\x19\x37\xc7\x30\xce\x7d\xb3\xa5\x9a\x99\x3b\x8c\x6b\x1b\x2c\xa7\x50\xae\x36\xe7\x95\xfd\x5b\x74\xf6\x60\xfd\x09\x96\x66\x9e\x97\xda\x6a\xce\x03\xd6\xae\xf9\x66\x9e\x5a\xb9\x12\xb4\xe9\x5a\x19\x94\x55\x3a\x97\xcc\x33\xc0\xbf\x9d\xc1\xaf\x9d\x39\xcd\xfb\x4d\x99\xf2\x6f\xbc\x1c\xe6\x9c\xc7\xb9\xe7\x1a\xbf\xc1\xf2\x5f\xcf\xa8\xe4\xbe\x99\x7f\xe6\x5c\xb1\xee\x66\x37\x96\x41\x1b\xcd\xb9\x68\xe6\xa3\x35\x67\x76\x5d\x8b\x8f\x94\xf2\x74\xad\xf4\x72\xf7\x42\xae\xe3\x0d\xc9\x77\xe8\x94\x2b\xa5\xc0\x3e\x4b\x7a\xda\x3a\x33\xb7\xa2\xa5\xa7\xe3\x6d\x89\x72\xb4\x93\x72\xe6\x5d\xc0\xe1\xb0\xec\x1a\x66\x9e\xc1\x6c\x7f\x32\x47\xbb\x13\x87\xc3\xd2\x0d\x3f\x3a\x94\x72\x56\x6a\x67\xe9\x1d\x32\xb0\x5f\x4a\x1a\xe5\x1d\x94\xfd\xcd\xcf\x3c\x79\xbe\x15\x0c\x27\xd7\x0e\x83\xe2\xc0\xbe\xed\xaf\xf9\xd7\x67\x7b\x66\xdd\xd5\xdf\x82\xf5\x7d\x03\x32\xfc\xed\x03\x67\x00\xff\xed\x81\x76\xff\xa0\x40\x9b\x2f\x26\xd8\xde\x3f\xd0\xc7\xfc\xb9\xba\x26\x20\xcf\x5f\x44\x3b\x39\xec\xbb\x10\x80\xf9\xee\xbf\x29\x88\xbe\x41\x14\x05\x11\x15\x2c\xf7\x70\x56\x7a\xc0\x6c\x33\x66\xa8\x8b\xa5\xed\xe4\xc9\xf6\xd2\x67\xdd\x29\x9c\x0f\x38\x83\xdb\xa5\x95\xb1\x07\xff\x07\x49\x96\x61\x9e\x33\xa3\xe4\x49\xee\x82\x2f\x6b\x8f\x4b\x86\xad\x8d\xbc\x6c\x6b\x2a\x2b\xcc\x77\x23\x5b\xaa\xb3\x8f\xe4\x18\x37\x49\xb6\xed\x0e\xea\xa7\x49\x63\xb3\x5e\xaf\x2c\xed\xb9\xb7\x66\x18\xab\x98\x03\x57\xd8\x57\xbe\x91\x05\x86\x93\xbb\x45\x5f\x50\x2c\x77\x9b\xe3\x6c\x9f\x22\x6b\x36\xf7\x81\x28\xe4\x04\xa1\xc7\xc8\xa7\xc6\x27\xf2\xa9\xfe\x07\x7b\xd3\x65\xa9\x60\x7d\xce\xe3\xe5\x4c\x6b\xce\x8f\x11\x32\x1b\x88\x7e\x56\x66\x9b\xf9\x65\xae\x43\xfa\x40\xa9\x67\xee\x7d\x7a\x23\x89\xb0\xd6\xbf\x49\xc1\xf5\xcf\xbc\x67\x7c\xcd\xfc\xfa\x9a\xfb\xd2\xd7\x92\x4e\xcc\x7a\xeb\xab\xa4\xf5\xb5\xfb\x44\x5a\x70\x8d\x03\xd6\x9c\x33\xf7\xbe\xdd\xe4\xea\xd7\xd2\x96\x32\xab\xcc\x67\x73\xdd\x4d\x5d\xfa\x48\xe4\x7c\x29\x35\xad\x75\xd0\x9c\x9b\x3d\x03\xeb\x25\xfb\xe7\xbd\x66\x6e\xe8\xcb\xfd\x57\x6c\x5d\x28\xbb\x4a\xa6\xde\xd5\x7f\x54\x7f\x52\x1a\xe8\xed\x19\xd7\x5e\x3c\xf8\x52\x4f\x1f\x2d\x75\x55\x2f\x19\xac\xcd\x44\xdf\x6d\x52\x5f\x3b\xc8\x5e\x1f\x2b\x0d\xf5\x71\xcc\xf9\x31\xe4\x6b\x82\xa4\xe9\xe1\xbc\xe7\x49\x1d\xee\xd3\x75\xf4\x3b\xa5\x16\xf5\xd5\x8d\xcb\xa2\xb4\x4b\xd2\x5c\xbb\xe4\x3f\xa7\x1b\xd2\xdc\xd8\x47\x9b\x4d\xfa\x80\xe6\xda\x9f\x41\xcc\x93\x26\xa0\x9e\xd9\xce\x59\xb9\xbf\xb6\x85\xf9\xf8\x98\xf4\x43\x5e\x3f\xab\xdf\x61\xee\x55\x94\x16\xec\xd2\x47\xbd\x85\x4d\xe1\x92\xaf\xb7\x92\x34\xb3\x9f\xf6\x88\xff\x17\xdd\xc3\x9a\x15\x2b\x05\xda\x23\xa2\xd1\xa7\xb9\xfe\x80\x34\xd3\xde\x10\x03\x79\x43\xcd\x7b\x03\xfd\x0b\xac\x7e\xb1\x9c\xb1\xcd\xd2\x25\x2d\x4a\xfb\x38\xda\x98\xe7\x06\xff\x23\x26\xaf\xec\x0b\x3b\xed\x6b\xfc\xef\xf1\xbe\x09\x3c\xce\x19\xfb\x59\x13\x86\xf8\xff\xa4\xed\x15\xeb\x3e\x54\x48\xfc\xca\xb1\xaf\x4f\x90\xce\xf6\x0e\x52\x8b\x38\x56\x34\x41\x7d\x15\xe2\x50\x85\xbb\x54\x88\x51\xfa\x99\x69\x53\xce\x67\x9b\xad\x78\x9a\x9f\x91\x84\x97\xf9\x5c\x75\xa6\x79\xd6\x37\xf7\x23\x3d\xc1\xff\x92\x15\x93\xc0\xe7\xa8\xf5\x83\x7b\xd6\xb5\xfb\xa5\x39\x87\xad\x7b\x65\x43\xc9\x0d\x9e\x95\x6e\x62\xef\x5a\x64\x7d\xd6\xc0\xfa\x04\x6f\xbd\xe1\xc8\xab\xed\xe1\x0e\x72\x45\x1a\xc0\x65\x75\xc5\x79\x00\xd4\x36\x39\xe5\xfe\x54\x00\x0f\x91\xe6\x3d\x24\x88\x48\xad\x96\xdf\x4f\xd9\x1b\xe8\x5a\x06\xeb\xcc\xa3\xdc\xe9\x80\x1e\xee\x7f\x13\xae\x06\xe8\xe5\x81\x4d\x9a\xe9\xc2\x7c\x28\x96\x74\xd5\xca\xbf\x01\xde\x93\x69\x8b\xd6\x2b\x4a\x13\x38\xce\xd7\x0e\xa1\x17\x2e\xb5\xaf\xa5\x05\xa8\x0b\x52\xb5\x8b\x94\xdf\x4b\x0b\xe6\xb4\x39\xbf\x67\x32\x27\x99\xaf\xbe\xd5\x60\x37\x38\x54\xa6\x1c\x14\x80\x7f\x4c\xe9\x79\xfa\x86\xcf\x04\x66\xfe\xad\x2c\xfb\xd9\xe4\x5f\x9f\x25\xfe\x7b\xf9\x3f\x7e\x66\x69\x9e\xfb\xcc\x38\xfd\xc3\x67\x94\x37\x96\x26\xe7\xa3\x4a\xdf\xc9\x87\x57\x89\xc3\x54\xf3\x2c\x11\x3c\xff\x5a\x9f\xe5\xdc\x58\x1a\x81\xcf\x25\x1f\x0c\x94\xd6\x67\x63\x66\xf9\x49\xb0\x7c\xda\xdc\xb3\xcc\xbc\xb8\xb1\xbc\xf6\xd9\xce\xbf\x94\xff\xc3\x67\x26\x37\xf2\x57\xf6\xb3\xcb\xd2\x72\x42\xb0\xec\xf1\xdf\x3e\xc3\xfc\xa7\xcf\x32\xff\xa1\x74\xfe\xcf\x9f\x69\xf6\x12\x57\xf0\x7c\x60\x95\xa5\xfb\xd2\x7f\x2b\xff\xb6\x4f\xf6\xba\xf6\xb9\xe0\x3f\x7e\x0e\x1a\x88\x95\x79\x66\xb0\xd6\x43\xf3\x33\x9d\xde\xd6\xf9\x60\x59\xe0\x8c\x6c\xfc\xd3\xe7\xe3\x81\xb2\xfe\x7f\x69\xff\x5f\xca\xff\x25\x07\xeb\xff\x5b\x3b\x76\x77\xc5\x56\xf3\x2c\xb4\xc3\xcc\xa1\xff\x12\xf3\xd4\x7f\x6d\x2f\xfd\x1c\xf6\xbf\x94\x37\xc6\xa8\xf4\x33\xd8\xff\x56\x5e\xf7\x79\xf4\x3f\x94\xd6\x1d\xf0\x3f\xa0\xf4\x7b\x19\xfb\x7d\x52\xeb\x06\x64\x99\xb0\xee\x8c\xff\x00\x7b\x15\xd6\xd4\x2a\xe2\x74\x8c\xe2\x6c\x57\x06\xa5\x77\xcb\x7f\x83\x7d\x01\xe3\x16\x88\xd3\xe9\x96\x04\x50\x2b\x58\x02\xff\x25\x13\x81\xef\xc3\xac\xef\xc4\x36\x05\x20\x7a\x00\xfe\x79\x26\x74\x25\xe1\xc0\x69\x2c\x42\xd7\x75\xf0\x5f\xb2\xf0\x4f\xdf\xd7\x98\x71\x78\x06\xbd\xcf\xa0\xb7\x0e\xba\x80\x63\x4f\x00\xd6\xfe\xfd\x1f\x00\x07\x4e\xc7\xcb\x8c\x89\xa2\xff\xcb\xfe\xf3\xe6\xfd\xf6\x3f\x62\x00\x7a\x06\x30\xe6\x3c\xfd\x4d\x3c\x54\x0a\xff\x77\x26\x4a\x79\x2f\xe5\xd1\xf8\xeb\x2e\x1e\x11\x5c\xab\x02\x36\x97\xea\x0f\xca\xfd\xbf\x8d\xe3\xff\x61\x5c\xca\xc0\xff\x95\x89\xff\xaf\xfc\xfe\x4f\xb6\x97\x45\xe0\x3b\x46\x15\x13\x28\xad\xcf\xf6\x22\xff\xd1\xee\xfb\x24\x19\xb4\xb2\xff\x42\xf9\x0b\x77\x8c\xc0\x9a\x5a\x2b\x00\xff\x79\x72\xe6\x71\x70\x00\xec\x01\xef\x83\xbb\xc0\xf3\xec\x1d\x1f\x98\xdf\x7b\xe9\x43\x39\xd3\x0c\x65\xbe\x97\x19\xf3\xb7\x3c\x98\xcf\x99\xc2\x44\xf0\x3d\xf8\x3d\x63\x1d\xfb\x69\xe9\xe8\x48\xe0\xee\xc3\x3c\x60\xdc\xf7\x01\xc8\xde\x7f\xe2\xc7\x31\x54\xfa\xda\x9f\x81\x8b\xea\x94\x03\x24\xdd\xfa\xec\x26\xf0\x3d\xea\x39\x23\xf8\x25\x7f\x69\xa9\xad\xb5\x7e\x3d\x40\x54\x4f\xeb\x3b\x70\xeb\x7b\x74\x65\x9e\xae\xd7\x96\xde\x05\xfc\x47\x80\x07\x98\x9f\x5d\x75\x32\xfb\x98\x70\x06\xc7\x5b\xdf\xbb\x8c\xf4\x7f\x13\xfc\x5c\xb6\x14\xf7\xa2\xab\x63\x19\xb4\x37\x0a\xad\x3d\x72\x8e\xb6\x5f\xba\x3a\x45\xc5\x05\xe5\x75\x0e\x9e\xfb\x2d\x98\x7a\x91\xd9\x58\x4d\x97\x9e\x9c\x75\x80\x7f\x05\x63\x73\x41\x1e\xf6\x6e\xc3\xe7\x5d\xaa\x97\xcf\xfa\x0e\xbe\xcc\xb8\x88\x20\x22\xcd\x77\xfa\x96\x07\x99\xc1\xcf\xc9\xeb\x70\x16\x1e\xca\xd9\xf4\x26\xce\xa0\x8d\xac\x73\xa6\xf9\xf9\x2c\xcf\xd8\x52\x3e\xf8\x19\x8c\xf9\xfd\xbe\xb9\x8e\x37\x0b\xee\xc7\x15\x9c\xbb\xe4\x59\x57\x0e\xf7\xad\xf9\x12\x6d\xdf\x2b\x9b\x8d\x44\x31\x3f\x97\x8f\x20\x0e\xd6\xfe\x87\x8d\x35\x39\x57\x9b\xeb\x5e\x05\xeb\xbb\xfd\x5e\x16\x27\xd6\x5d\x1e\x9f\x96\x70\xe7\x6b\xcb\x1d\x24\xda\xf9\x98\xec\x30\xbf\xe3\xa6\xff\x0e\x7b\xaa\x8c\x32\xf6\x4b\x2e\x79\xea\xe4\x6e\x50\x60\x5f\x27\x39\x20\x39\x58\xde\x04\xfa\x81\x45\xf8\xd9\x1c\x7e\x9e\x37\x44\x45\xdc\x58\x9a\xd0\x2f\x4a\x13\xe3\x14\x73\xef\x71\x39\xcb\x99\xf3\x69\xf3\x73\xee\x52\x4e\xb8\xf7\x67\x50\xd7\xdb\x71\x58\x3d\x69\xdb\xa5\xe2\xb4\xfa\x9c\x69\x87\xd0\xdf\xfc\x0e\x79\xad\x0c\xa1\xcc\xb2\x9e\x0f\xcb\x33\xd6\xef\x2e\x1c\xd6\x92\x8d\xc3\xca\x66\x5b\xeb\xff\xcd\x26\xea\x33\xdb\x5a\x6d\xbe\xf5\xfc\xb7\xf2\x46\xa8\xcf\x03\x6d\x66\x69\xa2\x6c\xdb\xff\x69\xfd\xff\x02\x36\x97\xeb\xa0\x1d\xa6\x1c\x66\x3d\x73\x83\xc5\x9f\xbb\x81\x5d\x3b\x22\x77\x98\x30\xf3\xd2\x71\x56\x3d\x0b\x16\x95\x96\xf0\xe6\xa4\xcf\x4b\xc6\x9b\x9c\xe9\x0f\xcb\x2b\xa0\xa6\x09\xfa\x17\x3a\xd3\xd4\x46\xe7\x48\xf5\x91\xa3\xa7\xca\xb6\x8b\xfa\x02\x74\xe5\x3e\xd7\x9c\x3b\x75\x0b\x63\x97\xdc\xc6\x1d\xc8\xfc\x1e\xff\x1d\xbb\x15\x03\x69\x40\xac\x2b\x90\xe3\x95\xb8\x3b\xfc\x42\xec\x2b\x06\xcf\x6a\x39\xcc\xf3\x29\xd7\xce\x91\xa5\xe7\xc2\xd2\xef\xc2\xd8\x7b\xb9\xb3\x39\x9c\x9d\xc4\x65\xdf\x6e\x9d\x51\xea\x18\xcf\xca\x2a\x7d\x18\x7d\xeb\x91\xeb\x6b\xe4\xe6\xe0\x67\xe5\x9b\xc8\xa1\x1f\x4d\xd0\xe7\x29\x13\xc4\xb6\xa8\x14\xd4\x2f\x37\x41\xff\x4a\x66\xcc\xf5\xe9\x9c\xf5\x67\x07\x40\xdf\xca\x26\xcc\xbb\xad\xf9\xb9\xb2\x75\x5f\xe5\x6e\x6b\xdd\x93\x83\xf7\xe3\xb2\xf7\x60\xeb\x7e\x6b\xde\x6d\xa7\x49\x1f\xeb\x9e\x5b\x16\x8c\x29\xc5\xdf\xef\xd8\xfe\xed\xda\xe3\xfe\xbd\x81\xfb\xb5\x7f\xfb\x75\xf7\x6b\xee\xd6\xd7\xee\xd5\xa5\x77\xea\x7f\xb8\x4f\x5b\xf7\x72\xe4\x5a\xe3\xe8\x83\x9e\x1c\x91\x2b\xe6\xf7\x06\x57\x29\xaf\x48\xe9\xfa\x64\xfd\xde\x8e\xff\x14\x7c\x4f\x05\xf7\x69\x7d\xe4\x76\xd0\x5e\x7b\x92\x36\x13\xb3\x99\xe3\xcb\xfd\xdf\xe9\xe9\xe2\xd1\xda\xfb\xcf\x30\xe4\xf6\x32\x68\xff\x17\xcc\xef\x3f\xae\xb2\x46\x5c\xc9\x0d\x7c\x47\x62\xe1\xab\xe0\x1a\x17\x5e\xa6\x6f\x70\xac\xd9\xdf\xfa\xce\xe4\xbb\x7f\x86\xf9\x3d\xc7\x95\x87\x44\x2e\x9f\xa5\x3c\x40\xb9\x32\x50\x7f\xf5\x8e\xc0\x9d\xc8\xf7\x01\xf5\x7f\xf2\x3e\x05\xdc\xc6\xf3\xb3\x94\x29\x94\xcd\x6e\x94\x85\x5f\x73\xe8\x7f\x24\x88\x03\xc1\xd2\xcc\x81\xb7\x8c\xde\xb2\xfc\x06\x74\x06\xdd\x82\xa5\x89\x6c\x3d\x82\xbd\xbd\xb7\x64\x06\xd1\x05\xd4\x01\xed\xa9\x37\xcb\xaa\x20\x35\x88\xea\x20\x9d\x7a\xf3\xb9\x32\x88\x07\x8d\x82\xa8\x47\x7d\xcd\xe0\xf8\x4e\x65\xd0\x9f\xfa\x4e\xff\x60\x47\x4e\xb0\x3d\xbb\xb4\x6f\xb0\x5f\x3a\x68\x0a\xb2\x4a\x41\x7d\x56\x50\x47\x66\x19\x7d\x8d\xa8\xcf\xbc\x41\x57\xa9\x9c\xe1\x37\xca\x2e\x23\xff\x46\x3b\x7a\x81\xde\x20\x2f\x58\xf6\xa2\x5f\x5f\xca\x26\xa0\x71\x10\xe6\x73\x13\xea\xcd\xb2\x1d\x68\x5b\x16\xd4\x9b\xe5\x8c\x20\x9a\x06\xd1\x8c\x7a\xb3\x5c\x74\x23\xfe\xc5\x8e\x1b\xfd\xe8\x42\x3f\x93\xcb\x7a\x65\x7c\x36\xf9\xae\x1c\xe4\x39\x3d\x18\x8f\xd2\xd8\x54\x0d\xc6\xa5\x7d\x30\x7e\x5d\x4a\x63\x1a\x8c\x63\x76\x99\x98\x5b\xf1\x0f\xc6\xfd\x3a\x3b\xc8\x99\xc6\xa5\xeb\x87\x99\x3f\x01\x58\xdf\xf3\x99\xdf\xb7\x1d\xb1\x3e\xc3\xf8\x2f\xe7\x3b\xce\x2c\x6f\x81\xc3\x60\x67\xb0\x7c\xab\x2c\xfe\xdb\x39\x36\x78\x06\x3a\xf0\x6f\xfd\x95\xb9\xef\xee\x09\x7e\xff\x44\x89\x5d\xfb\xb0\x91\x79\xe9\x63\x3e\xfa\x0e\x06\xed\x3e\x10\xfc\xbe\xec\xab\x60\xf9\x19\xd8\xca\x1c\x3a\x17\x28\xad\x3e\xef\x95\xc1\x5b\x37\xb4\xbf\x1a\xf8\x5e\xf0\x2f\x98\xe7\x25\x13\xc6\x4d\xfe\x91\x16\xcc\x75\xcb\x5c\x93\x58\x7b\x4a\x61\xad\x61\xac\x79\xf4\xaf\x06\xcc\xef\x14\xfb\x9a\xdf\x67\x99\x47\x9d\x20\x2a\x05\x7e\x13\xd2\xa8\xca\x9b\xb2\xde\x0d\xf3\x57\xcd\xc4\x27\xd3\xc5\x2e\xf7\xca\xbd\xfa\x18\x7d\xa2\x7e\xaf\x3e\x57\x9f\xa7\x3f\xa7\x7f\x68\x8b\xb6\x55\xb6\xbd\x67\xfb\xde\x76\xb1\xf2\x07\x55\x96\x54\x79\xb6\xca\x9f\xee\x58\x77\x65\x77\x5b\x77\x67\x77\x6f\x77\x9e\x3b\xdf\xdd\xcf\x7d\x8f\x7b\xb3\xfb\x1d\xf7\x27\xee\x2f\xdd\xe7\xdd\x17\xdd\x3e\x4f\xb8\x27\xd9\x53\xcd\x53\xcf\xd3\xd0\xd3\xcc\xd3\xc2\xd3\xd2\xd3\xc6\xd3\xdf\x33\xc6\x33\xd1\x33\xc9\x33\xcd\xb3\xd8\xf3\xaa\xe7\xa7\x24\x5b\x52\x74\x52\x7c\x52\x72\x52\xb5\xa4\xba\x49\xb7\x26\xf5\x48\xea\x9f\x34\x33\xe9\xb1\xa4\x55\xc9\x5a\xb2\x3d\x39\x3c\x39\x2a\x39\x36\xb9\x62\xb2\x3b\xb9\x66\x72\x5a\x72\xfb\xe4\x81\xc9\x43\x53\xb4\x94\x88\x94\xa4\x54\x49\xd5\x52\x43\x53\x23\x52\x63\x52\x13\x52\x2b\xa5\x56\x4d\xad\x9d\xda\x30\xb5\x45\xea\xa8\xd4\xe9\xa9\x33\x53\xe7\xa4\xce\x4b\x7d\x34\xf5\xb9\xd4\x75\xa9\xaf\xa4\x6e\x4f\xdd\x91\xfa\x4e\xea\xbe\xd4\x03\xa9\x9f\xa7\x9e\xae\xd6\xa2\x9a\xb7\x5a\xab\x6a\x05\xd5\x06\x57\xbb\xad\xda\xc8\x6a\x63\x6a\xdf\x51\xfb\xae\xba\xf1\x2f\x25\xbd\x34\xef\xb2\x76\xb9\xd1\xe5\x16\x97\x5b\x5e\xbe\xf9\x72\x9b\xcb\x5d\x7c\x29\xfe\x2b\x7e\xbf\xf5\x9b\x99\xcb\xf5\x09\xfa\x14\x7d\x26\xfe\x3f\xac\xbf\xa0\x1f\xb4\x55\xb4\x2d\xb2\x1d\xb4\xfd\x54\x59\x2a\xfb\xf0\x7f\xb9\x5b\xdc\x09\x6e\x8f\xbb\xbd\x3b\x27\xe8\xff\x00\xf7\x74\xf7\x16\xf7\x6e\xf7\x11\xf7\x57\xee\x0b\xee\xdf\x3c\xe2\x89\xc2\xff\x5a\x9e\x06\x9e\xa6\xd7\xfc\xbf\xdd\x33\xc1\x73\x17\xfe\x2f\xf4\x2c\x0f\xfa\x1f\x17\xf4\xbf\x73\x52\xf7\xa4\x7c\xfc\x5f\x78\xcd\xff\x48\xfc\xaf\x90\x5c\x25\xe8\x7f\x41\xf2\x10\xcb\x7f\xcf\xbf\xf8\x9f\x73\xcd\xff\x85\xa9\xcb\x53\xd7\x5c\xf3\xff\x03\xfc\xff\x0c\xff\x9b\x5d\xf3\x7f\x68\xb5\xdb\xf1\xbf\xa0\xf6\x38\xfc\x8f\x7f\x69\xce\x65\x75\xb9\xf2\xe5\x26\xf8\xef\xbd\xdc\xfa\x72\xb6\xcf\x63\xfa\xef\x3f\xe9\x7f\xcb\xff\xba\x7f\xbb\xff\x55\xff\x66\xff\x26\xff\x2b\xfe\x8d\xfe\xb5\xfe\x26\xfe\x7a\xfe\xb4\x33\x9e\x92\x1f\x4a\xce\x96\x7c\x5f\xf2\x6d\xc9\x89\x92\xe3\x25\x5f\x97\x1c\x2d\xf9\xb2\xe4\x8b\x92\xcf\x4b\x3e\x2b\x39\x52\x72\xb8\xe4\x50\xc9\xc7\x25\x1f\x95\x1c\x28\xf9\xb0\x64\x7f\xc9\xde\x92\xf7\x4b\xde\x2d\x79\xa7\x64\x57\xc9\x1b\x25\xaf\x97\x6c\x2b\x59\x5e\xf2\x58\xc9\xa2\x92\x85\x25\x73\x4b\xa6\x94\x8c\x29\xc9\x2c\x49\x2a\x89\x29\x89\x2a\x71\x96\xd8\x4e\xfb\x4e\x1f\x3f\x7d\xf4\xf4\x91\xd3\x1b\x4f\xaf\x3c\xbd\xf8\x74\xf3\xd3\x4d\x4e\xd7\x3b\x9d\x7e\xba\xce\xe9\x5a\xa7\xab\x9f\xae\x72\xba\xf2\x69\x75\xea\xfb\x53\x67\x4e\x75\x3a\x95\x75\xaa\xde\xc9\x6e\x27\xbb\x9e\x6c\x7f\xb2\xed\xc9\x56\x27\xb3\x4e\xb6\x38\x99\x79\xb2\xee\xc9\xea\x27\x3d\x27\xc3\x4e\x5c\x3a\xf1\xfb\x89\x8b\x27\x7e\x3e\xf1\xe3\x89\x13\x27\xbe\x38\x71\xf8\xc4\x87\x27\xf6\x9f\xd8\x7d\xe2\xcd\x13\x6f\x9c\xd8\x7a\x62\xed\x89\xdc\x13\x3d\x4f\xf4\x38\xd1\xf8\x44\xe6\x89\x86\x27\xea\x9f\xa8\x7b\xb4\xe5\xd1\xe6\x5f\x2c\x1d\xf8\xcc\xc0\xc6\x61\x6f\x87\xad\x0e\x5b\x15\xf6\x52\xd8\xca\xb0\x17\xc3\x56\x84\x1c\x72\x5e\xb9\xf1\x37\x84\xff\x7f\xf7\x63\xd7\x42\xcc\x42\xc9\xdf\x98\x50\xd6\x25\xcb\xfc\xd1\xfe\x8b\x8c\xc0\x48\x9d\x0b\x9a\x8d\xd5\xc4\xc1\x21\xc8\x25\x21\x52\x4e\x42\x25\x4c\xca\x4b\xb8\x44\x48\xa4\x44\x49\xb4\xc4\x48\xac\xc4\x49\xbc\x24\x48\x05\xa9\x28\x89\xac\x42\x95\xa5\x8a\xb8\x99\x7d\x49\x92\x2c\x29\x52\x55\x52\xa5\x9a\x54\x97\x1a\x52\x53\x6a\x49\x9a\xd4\x96\x3a\x52\x57\xd2\xa5\x9e\xd4\x97\x06\x92\x21\x0d\x25\x53\x1a\x49\x63\x69\x22\x4d\xa5\x99\x34\x97\x16\x72\x93\xb4\x94\x2c\xf1\x72\x0e\x6d\x25\xad\xa5\x8d\xb4\x95\x6c\x69\xc7\x89\xa8\x83\xdc\x22\x1d\xa5\x93\x74\x96\x5b\xa5\x0b\xa7\xb4\xae\xd2\x4d\xba\x4b\x0f\xe9\xc9\xaa\xd8\x5b\x72\x25\x4f\xfa\x48\xbe\xf4\x95\x7e\xd2\x5f\x06\x48\x81\x0c\xc4\xfe\x59\x32\x5b\x1e\x94\x87\xe4\x51\x79\x52\x9e\x95\x17\xe4\x79\x59\x21\x2b\xe5\x45\x79\x49\x56\x73\xb3\x5c\x23\xeb\x64\xbd\x6c\xe0\x94\x5a\x24\x1b\x65\x93\xbc\x2a\x9b\x65\x8b\x14\xcb\x56\xd9\xc1\xcd\x6e\xa7\xbc\xee\x38\x2b\xe3\x65\x88\x0c\x95\x11\x8e\x1f\x64\x92\x3c\x27\x63\x65\xa4\xb3\x96\xdc\x29\xb7\x3b\x6f\xe1\xac\xf4\xb4\xb3\x2d\xa7\xf6\x4e\xce\xce\x32\x4c\xee\x72\xde\xe4\xf4\x3a\xb3\xf4\xf1\xce\xf6\x32\x4a\xa6\xea\xf9\xec\x27\xdb\x65\x86\x0c\x96\xd1\xce\x36\xaa\x87\xb3\x83\xb3\xa5\xdc\x21\xf7\x38\x7e\x94\x41\x72\x9f\x3c\x20\x4f\xa8\x18\x15\xeb\xf8\xda\x71\xcc\x51\xe2\x38\xe3\x38\xe9\xf8\x56\xb6\x39\x1f\x92\x37\x55\x33\xc7\x55\x67\xa2\xe3\x4f\xc7\x25\xe7\x3b\xce\x77\x1d\xe7\x64\xb2\xe3\x94\xe3\x3b\xc7\xaf\x32\x53\xe6\xc9\xfd\x32\x5f\xe6\xca\x02\x59\x28\x8b\xe4\x61\x79\x4c\x1e\xc7\xc3\xc5\xb2\x54\x9e\x91\x25\xdc\xaa\xe7\x68\xcf\xca\x38\xed\x69\x6d\x89\xb6\x54\xa6\x68\xcb\xb4\x67\xb4\x07\x45\xbc\xed\xf2\xfb\xe4\xe5\xf6\xec\xd1\xbd\x5b\xd7\x9c\x2e\xb7\x76\xee\xd4\xf1\x96\x0e\xed\xdb\x65\xb7\x6d\xd3\xba\xd5\xcd\xde\xac\x96\x37\xb5\x68\xde\xac\x69\x93\xc6\x8d\x32\xeb\xd7\x4b\xaf\x5b\xa7\x76\x8d\xea\xd5\x52\xab\xa6\x24\x27\xb9\x13\x62\x22\x23\xc2\xcb\x87\x95\x0b\x71\x39\x1d\x76\x9b\xa1\x6b\x4a\x6a\x7b\x8a\x54\x41\xdb\x22\x3d\xd5\x13\x99\x3d\x30\xa5\x6d\xca\xc0\xf6\x75\x6a\x7b\xda\x26\x0c\x6f\x53\xa7\x76\xdb\x94\xec\x82\x22\xcf\x40\x4f\x11\x85\x51\x2d\xa5\x7d\x7b\xab\x2a\x65\x60\x91\xa7\xc0\x53\x54\x8d\x62\x60\x99\xea\x82\x22\x2f\x3d\x6f\xbb\xa1\xa7\x37\xd0\xd3\x7b\xad\xa7\x8a\xf0\xb4\x90\x16\xa6\x8a\x14\x4f\xd1\xfe\x36\x29\x9e\x62\xd5\xa7\x6b\x2e\xcf\xf3\xdb\xa4\xe4\x79\x8a\x7e\xb0\x9e\x3b\x5b\xcf\x46\x35\xeb\x25\x8c\x97\xa4\x24\x46\x58\x56\x99\xd6\x7a\xda\x16\x65\xdf\x39\x7c\x6e\xdb\x02\x6c\x54\x1b\xcb\x85\xb4\x4e\x69\x3d\x34\xa4\x4e\x6d\xd9\x18\x52\x8e\xc7\x72\x3c\x15\xd5\x48\x19\xbb\x51\xd5\x68\xa9\xac\x07\xad\x46\xdb\x66\x1b\x35\x71\x86\x99\x6a\xf1\xb4\xed\xc0\x21\x45\x39\x5d\x73\xdb\xb6\x49\x4c\x4a\xca\xab\x53\xbb\x43\x51\xf9\x94\x36\x56\x93\xb4\xb6\x44\x16\xd9\x5b\x17\x39\x2c\x91\x9e\x11\xa6\xe9\xf2\x90\x67\x63\xed\x5d\x73\xe7\x15\x47\xc8\xa0\x82\xb4\xd0\x21\x29\x43\x06\xf6\xcd\x2d\xd2\x07\x32\x76\xae\xde\x76\xee\xdc\xd9\x45\x91\x69\x45\x35\x53\xda\x14\xd5\x9c\xf2\x6d\x02\x9e\x0f\x2d\xaa\x9d\xd2\xa6\x6d\x51\x9a\x29\xb5\x63\xb7\x6b\x7a\x3a\xfe\xa5\x52\x15\xd9\x52\xd9\x30\xe6\xfe\x2a\xb8\x93\xf2\xc3\xb9\xeb\x6b\x06\x06\x6b\xec\xa9\x11\xbf\x8a\xf9\x58\xa4\xb5\x2e\x52\xdd\x72\x93\xcc\x9f\xc4\x6c\xb8\x9e\x3b\x37\x3b\xc5\x93\x3d\xb7\x60\xee\xc0\x62\xff\xf4\x41\x29\x9e\x88\x94\xb9\x1b\x43\x43\xe7\x8e\x6d\x0b\xdd\x92\x93\x8b\x88\x62\xff\xf6\x87\x12\x8b\xb2\xe7\xe5\x15\x45\x14\x0c\x57\xcd\xf2\x82\xae\x67\x77\xeb\x58\x14\xdd\x35\x3f\xb7\x48\x4b\xcd\xf6\x0c\x1f\x48\x0d\xff\x65\xa5\x24\x35\x49\x4c\x8a\xbc\xd6\x27\xe7\xdf\x9a\x05\x5a\x20\x07\x86\x93\x92\x4c\x1a\x1e\x2a\xf6\xca\x20\x5e\x8a\xa6\x77\xcd\x0d\xbc\x7b\x64\x50\xe2\x2b\xe2\x4d\x4f\xcb\x2b\xd2\x0a\xcc\x96\x5d\xa5\x2d\xb1\x3d\xcd\x96\xe9\xa5\x2d\xd7\x86\x17\xa4\x10\xdb\x8e\xdd\x73\xe7\x16\x19\xa9\x1d\x86\xa4\xb4\x85\xf1\x87\x06\x16\x4d\x1f\x44\x76\xdd\x6e\x06\x26\x25\xa2\xa8\xfc\x6f\x89\x49\x29\x73\xa3\x22\x3d\x4d\xd3\xf3\xac\xbe\x1e\xac\xea\x30\x64\x84\xa7\xc8\x56\x0d\x92\x18\x55\x76\x00\x79\x63\x0e\x99\x1b\x61\xbd\x94\xff\x2d\x50\xfc\x90\x88\x82\x6a\x91\x51\x9e\xa6\x29\x88\x31\xe5\xb4\x4d\x69\x5b\x10\xfc\xef\xce\xe1\x09\x08\xf0\x40\x74\xfb\xb4\x40\x22\xf4\xc8\x2d\xf2\xb6\xe1\xc1\x3b\x30\x18\xb1\xb6\x1b\xeb\xa5\x33\x62\x60\x01\x01\x1b\xd1\xc6\x0a\x66\x51\x7a\xca\xd8\xa2\x98\x94\x56\xd7\xa2\x6b\x9a\xd5\x76\x44\xf7\x5c\x6b\x48\x70\x58\x51\x4c\xeb\x22\x29\x18\x1c\x1c\x55\x94\xde\xd6\x9a\x57\x9e\xb6\x73\x0b\xda\x04\x4c\x30\x65\xa5\x74\xcd\xdd\x26\x19\xfe\xe3\x1b\x1b\x7a\x12\x37\x99\x4b\x67\x5e\x1b\xb3\x73\x5c\x6b\xb2\xac\x5a\xdb\xb9\xb9\x43\x6e\x2b\x72\x17\x24\x0e\x61\xde\xdd\xe6\xc9\x4d\x4c\x2a\xf2\xe6\x11\xe1\xbc\x94\xdc\xa1\x79\x66\xda\xc1\x50\xcd\xe3\x89\x56\x72\xe4\x59\xb9\xd2\x23\xb7\x63\xf7\x94\x8e\x5d\xfb\xe4\x36\x09\x1a\x12\x68\x30\xc5\x19\xa9\x6d\x6f\x10\x93\x92\x9b\x18\x10\x43\x02\x16\x39\x53\x9d\x9e\x5c\x2d\x51\xcf\xa3\x63\x04\x15\x9e\x6c\x1e\x52\x5a\xb5\xe0\xcf\x22\x47\xaa\x13\x44\x40\xb8\x55\x6b\x26\x6e\xab\x16\x9e\x5c\x95\x28\xa5\xbd\x31\xa3\xa8\xa6\xa7\xed\xd0\x36\xc1\x7e\xe6\xfb\x75\x42\x6d\x66\x3a\xb5\x6e\x5f\x2a\xcd\x6e\xbe\x22\xa7\x75\xfb\xc4\xa4\xbc\xa4\xc0\x4f\x9d\xda\x1a\xcd\x9e\xa0\x62\x46\x38\x4d\x52\xdb\x97\x36\xb1\x4c\xd1\xe0\x24\x3f\x5b\xb7\xb7\xaa\x4c\x2e\x13\xcc\xa4\xf7\xe4\xa6\x0c\x4d\xc9\x4b\x19\xee\x29\xf2\xe6\xe4\x9a\xbe\x99\xf4\x58\x2c\x07\xc9\xb0\x38\x0f\xc6\xaa\xc7\x75\x6f\x65\xc8\x82\x26\x49\xa2\xb9\xf4\xc5\x24\xb3\x28\x3b\x2d\xb1\x2c\xb9\x45\xed\xac\xf7\x6b\xaf\xed\x6f\x68\xee\x50\xda\xec\x99\xeb\x4c\xe9\xd8\x7d\xae\x29\x3c\x25\x28\x50\xb0\xbc\x43\x91\x98\x29\xec\x6d\x12\x99\x68\xad\x05\xe6\x84\x4e\x61\xed\xf5\x44\x30\xa5\xad\x09\x3d\x77\xa3\xd7\x6b\x4e\xe6\xe1\xcd\x4c\x21\x29\x1d\x86\xcc\x4d\xe9\x9e\xdb\xc2\xea\xcd\x7a\x72\x4f\xe2\x14\x53\x57\x94\x74\x54\x1d\x7b\xb4\xaa\x53\x9b\xa5\xad\xd5\xc6\x14\x35\xa7\xeb\x46\xaf\x9a\xd3\xbd\x4f\xee\xb6\x08\xce\xc8\x73\x7a\xe4\xbe\xa2\x29\xad\x75\x41\xab\xbc\x8d\x55\x69\xcb\xdd\xe6\x61\xd3\xb0\x6a\x35\xb3\xd6\xac\x34\x5f\x3c\xe6\x8b\x29\xa9\x1b\x2f\x4e\xab\x7f\xe2\x36\xaf\xc8\x74\xab\xd5\xb0\x2a\xac\xf7\xc1\xc5\x4a\xac\x3a\x67\x69\x9d\x92\xc1\xc5\x5a\xa0\x2e\x22\xa0\xa8\x9a\xa5\xc8\xcb\x19\x64\x70\xb1\x11\x68\xf1\x96\xf6\x36\xa8\x73\x06\xea\xa6\x5b\x75\xd6\xcf\x46\x31\x29\xf3\x86\xd8\xbc\x4e\xaf\xcb\x1b\xaa\x85\x69\x89\x1b\x95\x59\xf5\x0a\x35\xdb\x39\xab\xb8\x94\x6c\x0a\x55\x61\x2a\x71\x23\xa3\xba\x59\xd5\xc5\x6a\xfa\x46\x97\x37\x31\xd0\x63\x3a\x3d\xbc\x01\x0b\xe7\xf4\xfc\x4b\x75\xcf\x3e\xb9\x9b\x38\xd1\xa8\x44\xeb\x4f\x14\xb5\x32\x7f\x48\x97\x84\xe1\x04\x9b\x6d\xa5\xad\x67\x88\x99\x28\x53\xf3\x86\xcf\x2d\xc8\x33\x27\x9b\xc4\x11\x1a\xfe\x53\x45\x2a\xa5\x25\x61\x4a\x69\x89\x21\xf6\xd0\xa2\x90\x94\xa1\xad\x8a\xca\xa5\xb4\x32\xeb\xb3\xcc\xfa\xac\x40\xbd\xdd\xac\x77\x90\xa2\x2a\x4e\x31\x7c\x3a\xb1\xcf\x29\x52\x66\x06\xe4\xe7\x26\x31\x25\x3d\x15\xf7\x24\xce\x8d\xf8\xc1\x8c\x54\x1e\x8b\xca\xdc\x88\x53\x75\x6e\x4e\xc2\xd8\x2c\x51\xaa\xa9\xf4\x54\x2d\x83\x65\x2b\xe5\xe5\xac\xe5\x56\x37\x53\x72\x71\x51\xcd\x25\x43\x35\xa3\xbe\x09\x25\xed\xe2\x55\x0e\x98\x76\x5b\x7f\x2e\x53\x86\x77\x8d\xda\x75\x55\x6d\xb8\xaa\xe4\xaa\x0a\xe9\x72\x59\x79\x2e\xab\x5f\x73\x6a\xb8\x2f\x64\xd7\x70\xff\x9c\x5d\xcb\xfd\x53\x76\x9a\x7b\xc0\xf9\x69\xe7\xb5\xf0\xf3\x5d\xce\x0f\x38\xbf\xe0\xfc\x86\xf3\xb6\x72\xa7\xbe\xad\xe2\x3e\x79\x22\xdb\x1d\x7e\x42\x79\x4f\x64\xc7\xb9\xbf\x39\x9e\xed\x3e\x70\xfc\xd8\xf1\xf3\xc7\x75\xef\xf1\x8c\x46\xd9\xc7\xb3\x13\xdc\x3f\xfe\xe0\x77\xff\xa0\xce\xf4\x3c\xd7\xfe\x6c\xcf\xef\x1b\x48\xcf\xef\xce\x9c\xe9\x59\xd2\x5e\x7a\x9e\x16\xbf\xfb\xab\x9b\x8e\xf5\x3c\xa6\xf4\x9e\x5f\xdf\xa4\xf7\x3c\xaa\xfb\xdd\xe1\x87\xdd\x87\x35\xeb\x0f\xef\x07\x09\x89\xd9\x07\xde\x52\x3b\x77\xb5\x70\xbf\x99\x53\xcd\xbd\xe3\xf5\x1a\x6e\xff\x36\x95\x53\x3c\xb6\x78\x7a\xb1\x5e\xec\xdf\xe5\xf5\x17\x47\x35\xc8\x76\x6f\xcd\xda\xda\x65\xeb\x98\xad\xd3\xb6\x2e\xdb\xba\x61\xab\x23\x61\x8b\x1a\xfb\xca\xf2\x57\x8a\x5e\xd1\xc3\x5f\x51\x0b\x5f\x55\x45\xaf\xaa\xf0\x57\x95\x33\x7c\x53\xd6\xa6\xf3\x9b\xf4\xe9\x45\x0b\x8b\xb4\xa2\xa2\x5d\x45\x07\x8b\xf4\xf4\x0d\x59\x1b\xb4\xe5\xeb\x8b\xd6\x6b\xbb\xd6\x1f\x5c\xaf\xa5\xaf\xcb\x5a\xa7\x2d\x5b\xab\x76\xad\x39\xb8\x46\xeb\xb2\x7a\xc1\x6a\x2d\x7d\xf5\x98\xd5\x6f\xac\xf6\xaf\x36\x96\x2e\xa9\xea\xce\x59\xa2\xc6\x3c\xae\xde\x78\x5c\x3d\x9e\x5d\xd9\xfd\xd8\xe2\x78\x77\xf8\x62\xf7\xe2\x69\x8b\x17\x2c\xf6\x2f\xb6\xd5\x5b\xe4\x5d\xa4\x4d\x5f\xa4\xc6\x2e\x98\xbe\x40\x5b\xb8\x40\xed\x5a\x70\x70\x81\xd6\x65\xde\x80\x79\x63\xe6\xe9\xb3\xb2\xfd\xee\x65\x0f\xa8\x99\xf7\xd7\x77\x4f\x28\xcc\x72\x17\xe2\xc8\x98\xd1\x2d\xdc\xa3\xb3\x33\xdd\x15\x55\x42\xcf\x0a\x19\x09\x3d\x1d\x19\x7a\x4f\x3b\xae\x17\xd0\x36\x00\xf4\xcd\xae\xef\xce\xef\xd3\xde\xdd\x87\x32\xba\x41\x54\x4f\x1b\xf4\x18\x0d\xf4\x9e\xa3\x74\x15\xaa\xb7\xd0\x3b\xe9\xa3\xf4\xa9\xba\xed\x7c\x57\xbf\x77\x48\x57\xcd\xdb\x35\xb3\x49\xb6\xb7\x6b\x6a\x8d\xec\x03\x39\xaa\x43\x36\x37\x53\x24\xb7\x03\x1b\xb2\xd5\xb1\xec\xf3\xd9\xda\xf4\x6c\x15\xd7\x20\xb6\x67\xa4\x0a\xef\x19\xd1\x20\xbc\x27\xa7\xb2\x9e\x4a\x94\xdb\x1d\x9e\x15\x3e\x20\x7c\x5a\xb8\x11\x1e\x9e\x1e\xde\x25\x7c\x4c\xf8\x82\xf0\x63\xe1\xfe\x70\x47\x16\x75\xe7\xc3\xf5\x31\xa2\xba\x88\x9a\x1e\xa7\x6c\xaa\x58\x2d\xdc\xd8\xa3\x7b\x5a\x5a\xc7\x62\x87\x9f\x1d\xde\x91\x93\x5f\xa4\xe6\x14\xa5\x76\x37\xff\xf4\x76\xed\x53\x64\x9f\x53\x24\x3d\xfb\xe4\xe7\x6e\x54\xea\xe1\xbc\x07\xe6\xcf\x97\x56\x95\x3b\x16\x35\xe8\x9e\x5b\x54\x50\x39\xaf\x63\xd1\x10\x1e\xbc\xe6\xc3\x74\x1e\x22\x2a\x6f\x8c\x93\x56\x79\x85\x13\x0a\x27\x4c\x4c\x33\x7f\x54\xe0\x41\x26\xa4\xa5\x15\x16\x9a\x4f\xca\x7c\x4b\x0b\xb4\x59\x4f\x2a\xad\x90\x66\xba\x31\x88\x97\x09\x13\xa5\x30\xad\x70\x82\x2a\x2c\x9c\x20\x85\x13\xa8\x2f\x54\xfd\x79\x2e\x2c\x94\x42\xea\x0b\x15\x43\x40\x61\x5a\x50\xfe\x35\x49\x28\xe8\x8f\x20\xfe\x98\x10\x50\x51\x58\xc8\xb8\x42\xe4\x14\x06\xd5\x25\xf4\x17\xdb\x3e\xdb\x3e\xb9\xc7\x36\x83\xdb\xc9\x64\xeb\xcf\xeb\x7e\x8c\x66\xcc\xa5\xbb\x44\xfc\xe7\xcc\xb7\xbf\xfe\xf4\xf5\xfe\x7f\x7b\xe5\xfa\xe7\x9f\xc0\xdf\x71\xe5\x56\xb1\x93\x5b\xc6\xf2\xeb\x9a\xe6\xc8\xbd\xfc\xb9\xee\xba\xba\x37\xe4\xed\xe0\xf7\x5d\x4b\x38\xe9\xff\xfb\xcf\x36\x6e\x2e\x81\x9f\xc5\xf2\x94\xcc\xfe\xd7\x7e\xb7\x5b\x37\x86\x15\xe8\xff\xeb\xa7\x80\xda\xc9\xdc\x86\xd6\x71\xcf\x79\x89\x6b\x5e\xb2\xca\x40\xeb\xc8\x60\xeb\x97\xb2\xe7\x9f\x45\xa9\x6f\xd4\x1e\x79\x84\x3b\xcd\x48\xfe\xdc\xca\x9f\x4b\xb8\x42\xde\xad\x5d\x90\x47\xb4\x6e\x32\x5a\xfb\x54\x9f\xc1\xad\xe6\x41\x7c\x5c\xa6\x46\x70\x43\x11\x55\x20\x2b\x54\x3e\x37\xb1\xfb\x82\x02\xfa\x73\x8b\x1a\x73\x83\xd0\xb9\xdc\x64\x5e\x94\x29\x32\xfd\xaf\x2a\xdb\x0c\xff\x2f\x12\x76\x65\x13\x96\x3f\x88\x9c\xc7\x65\x84\x8c\x23\x92\xe1\x57\xaa\xf8\x2f\x48\x43\xe3\xb4\x84\xf9\x0e\xc9\x1b\xba\x1b\xdb\x5f\xe6\xbe\x66\xfe\xcc\x28\x1d\xeb\x68\xaf\xdf\xae\x6d\xd1\xb4\xab\x8f\xf2\xb2\x88\x3b\xd9\x22\x19\xa8\x3e\xc7\xce\xf9\xfa\xcd\xff\x81\xcd\xff\xeb\x1f\xfb\x0c\x63\xb8\xc4\x18\x7b\xcd\x1c\xf2\x7f\xe2\x9b\x86\xed\x5f\x12\xa1\xed\xb0\x71\x20\xd8\xa5\xd3\xf5\xd0\x72\xc1\x2a\xae\xd7\x07\xf1\x38\x07\x09\xed\xb1\x7e\x14\x58\x1e\xfc\x46\x73\x08\xb8\xc2\xae\x36\x16\xec\x00\x17\x45\x42\xaa\x82\x1e\xe0\x33\x91\x72\xf5\xc0\x3e\x91\x50\x64\x84\xd5\x06\x67\x44\xca\x93\x4b\xe1\xa1\xe0\x27\x91\x08\xc6\x44\x22\x28\x72\x38\xa0\x5f\x54\x43\xf0\xa4\x48\x34\x7a\x63\xde\x11\x89\x45\x57\x5c\x1b\x91\x78\xfa\xc4\xcf\x11\x49\x60\x5c\x02\xba\x2a\x78\xc1\xb7\x22\x15\xa9\x4b\xa4\x2e\x71\x12\x20\x7b\x2a\x23\xa7\x32\x72\xab\xcc\x13\x71\x73\x6c\x70\x63\x83\x67\xa6\x48\xd2\x52\x91\x64\x6c\x4b\xe1\x39\x85\xf6\x6a\xf8\x52\x1d\x3d\x35\x19\x57\x93\xf7\x5a\x2d\x00\x72\x6b\x61\x4f\x6d\x0f\xa0\xbd\x36\x63\xea\xf0\x5e\x17\x1d\xe9\xf8\x5d\x0f\x3d\xf5\x8e\x8b\xd4\x47\x4f\x03\x74\x67\x2c\x16\x69\x58\x43\x24\xb3\xaf\x48\x23\xc6\x34\x2a\x12\x69\x82\x9f\x4d\x79\x6f\xfa\x87\x48\xb3\xf7\x45\x9a\x33\xbe\x85\x27\xf0\xd7\xa3\x6e\xc2\xa6\x96\xd8\x9d\x85\x9f\x37\x83\xd6\x05\x22\x6d\xb1\xa1\x1d\x32\xda\x61\x43\x07\xf8\xbe\x25\x06\xc0\xf5\x2d\xe8\xe9\x44\x9f\xce\x0b\x45\x6e\x65\x5c\x17\xda\x72\xe8\xd7\x75\x95\xf9\xab\x3b\x80\xf7\x1e\x64\x63\x4f\xda\x7a\x31\xa6\x17\xf6\xf6\x42\x5e\x6f\x6c\xee\xcd\xb8\x5c\x38\xcb\xc5\xf7\x3c\x7c\xea\x43\x8c\xfa\x30\x2e\x1f\xbb\xf2\x77\x01\x64\xf7\x85\xd7\xbe\xb4\xf7\xa3\xec\x87\xee\xfe\xc4\xa9\xff\x54\x40\xfb\x00\x64\x0e\x30\x4b\xea\x0b\xb0\xbd\x00\xd9\x05\xf0\x56\x80\xdc\x81\xb4\x0d\xc4\xff\x81\xc4\x71\x50\x02\xc0\x8e\x41\xb4\x0d\xa2\x6e\x10\x72\x07\xc3\xf9\x60\x74\xa3\x52\x86\x20\x73\x08\x0f\x43\xe0\x69\x08\xb1\x1c\x02\x27\x43\xa9\x1b\x6a\xfe\xdd\x7f\xea\x6f\x33\x4b\x38\xba\x8d\xfa\x61\xd4\x0f\xc3\xfe\x61\xc8\x1d\x0e\x46\x54\x02\xc8\x1e\x81\x8f\x23\x90\x3d\x82\x35\xef\x76\xf2\x6a\x24\xb1\x18\x09\xcf\x23\xe1\x7f\x14\x7e\x8f\x42\xd7\x28\x62\x38\x0a\xff\x46\x1d\x12\xb9\x03\x6e\xee\x68\x22\x32\x9a\x5c\x1b\x8d\xbf\xa3\xe1\x6f\x34\xbe\x8c\xc6\x97\x31\xf8\x32\x86\xbc\x1c\x43\xbf\xb1\xe8\x1d\x4b\xde\x8e\xa3\xdf\x38\xf4\x8e\xc3\x96\x71\xd4\x8d\x87\xaf\xf1\xc8\x1a\x0f\x37\x85\xc4\xbb\x90\xbc\x28\xa4\xae\x10\x5e\x0b\x69\x2f\xc4\xd6\x09\xc4\x61\x02\xf9\x39\x01\x5b\x26\x14\x03\xec\x9d\x08\x17\x13\xc9\x91\x89\x70\x38\x91\xfc\x9e\x48\xdc\xef\xc4\xce\x3b\xb1\xf3\x2e\xec\xbc\x8b\xb6\xbb\xb0\xf3\x2e\x64\xdf\x85\xec\x49\xd8\x39\x09\x9f\x27\xc1\xc3\x24\x74\x4f\x42\xf6\x24\x64\x4f\x46\xf6\x64\x64\x4f\x46\xf6\x64\x64\x4f\x86\xd3\x29\x8c\x9f\x82\x9f\x53\x18\x7f\x37\x72\xa6\xc2\xcd\x54\xb8\x99\x0a\x37\x53\xd1\x31\x95\x3e\xf7\xc0\xfb\x3d\xe4\xd6\x3d\xc8\xbb\x07\x9f\xef\xc1\xe7\x7b\xd1\x7d\x2f\x3e\x4e\x43\xcf\x34\x7c\x9c\x8e\x8e\xe9\xcc\x81\x19\xf0\x30\x03\x9d\x33\x78\x9f\xc1\xfb\x7d\xbc\xdf\x87\xdc\xfb\x90\x7f\x1f\x76\xdf\xc7\xb8\xfb\x91\x77\x3f\x72\x66\x32\xef\x66\xc2\xe7\x4c\xe6\xd5\x4c\xe2\x38\x93\xf6\x99\x70\xf9\x00\xb1\x78\x00\x2e\x67\xe1\xc7\x2c\xfc\x9d\x75\x54\x64\x36\x7c\xcd\x86\xaf\xd9\xe4\xd4\x6c\xd6\x87\xd9\xf0\x3c\x07\x7f\x1f\x64\xcc\x83\xc4\x6f\x2e\x76\xcf\x45\xcf\x5c\xf8\x9c\xbb\x02\xd0\x6e\xfe\xb5\xec\x87\x98\xf3\x0f\x61\xf7\x43\xc8\x7f\x88\xbe\x0f\xa1\x7f\x1e\x3e\xcf\xc3\xe7\x79\xc8\x9a\x8f\x7d\xf3\xd1\x35\x1f\x7f\x1f\xc6\x9e\x87\x99\x1f\x2c\xdc\xb2\x00\xbf\x16\xe0\xd7\x02\xc6\x2d\x20\xbf\x16\xc0\xdf\x42\xe4\x2f\x24\x06\x0b\xe1\x65\x21\x72\x16\x61\xe7\x22\xf2\x77\x11\x39\xba\x08\x3e\x17\x61\xc7\x23\xd8\xf1\x08\x75\x8f\x20\xef\x11\xfa\x3d\x02\x7f\x8f\x22\xf7\x51\xfc\x7c\x74\x94\xb9\x55\x01\xfa\x3d\x86\x9e\xc7\x27\x88\x3c\x81\x7d\x4f\x60\xd7\x93\x3c\x3f\x05\x2f\x4f\xd1\xff\x69\xfc\x7b\x9a\xb1\x4b\xc8\xb1\x25\xf4\x5d\x0a\x07\xcf\x10\xb7\x67\xe0\xfd\x59\x78\x5c\x86\x1d\xcb\xb0\x69\x39\x76\x3f\xc7\xf8\xe7\x18\xf3\x3c\x7c\x3e\x4f\xfb\x0b\xe4\xca\x0b\xf4\x5f\x41\x0c\x57\xc0\xc3\x8b\xe8\x7d\x91\x1c\x5a\x09\xc7\x2b\xe1\x96\xcd\x4e\x5e\x62\xae\xad\xc2\x8f\xd5\xe4\xc3\x6a\xec\x58\x83\xcc\xb5\x70\xbb\x16\x39\xeb\xd0\xbd\x1e\xfb\xd7\xe3\xfb\xcb\xd8\xfd\x32\x32\x36\xc0\xd7\x06\x64\x16\x51\x16\x31\x5f\x36\xd2\xff\x15\xe4\xbe\x82\xbe\x4d\xe4\xc5\x26\xe4\x6f\xa6\xee\x55\xfa\xbf\x0a\x0f\x5b\xe0\x7b\x2b\xf1\xda\x8a\xbc\x62\xe4\x99\xf7\x8d\x6d\xe4\xe5\x76\x9c\x7f\x0d\x9d\xaf\xe1\xcb\x6b\xe4\xfc\x0e\x6c\xdf\x41\x1c\x76\x10\xb3\x1d\xe6\x3b\x39\xb3\x83\x31\x3b\xe0\x7a\x27\x5c\xec\xa4\xef\x4e\xc6\xee\xa4\xff\x4e\x72\x76\x27\x3c\xed\x84\x8f\xd7\xf1\xed\x75\xf8\x7d\x1d\x8e\x5e\x27\x0e\x6f\xe0\xf3\x1b\xd8\xfc\x06\xb6\xbd\x41\xfb\x2e\x6c\xdb\x85\xcc\x5d\xf4\xdf\x45\x0e\xbe\x89\x8c\x37\xc9\xa1\xb7\xb0\xff\x2d\x64\xbd\xc5\x3a\xf3\x16\x7e\xbf\x4d\x7e\xbc\x8d\x0d\xef\x90\x03\xef\xa2\xeb\x5d\xda\xde\xa5\xed\x5d\xfc\x7a\x97\x71\xbb\xf1\x61\x37\x31\xde\x4d\x1c\x76\x63\xfb\x6e\x38\xdf\x4d\xfd\x7b\xd4\xbd\x07\x5f\xef\xc1\xff\x7b\xc4\xf4\x3d\x6c\x7f\x0f\x4e\xdf\xc7\xa6\x3d\xc4\x7f\x0f\xb6\xec\x21\x27\x3e\xa0\x6e\x2f\x79\xb4\x17\x2e\xf7\x12\x9f\xbd\xc8\xdd\x4b\x0c\xf6\xa1\x6b\x1f\x75\xfb\xa8\xdb\x47\xdd\x3e\xfc\xdd\x4f\xbf\xfd\xd4\xed\xa7\x6e\x3f\x3c\x7c\x48\x9c\x3e\xa4\xee\x43\xea\x3e\x64\x3e\x7d\x88\xbd\xe6\x36\x7a\x80\xba\x03\xc4\xf2\x00\xbc\x1e\xa0\x8e\xff\xe4\x20\xfe\x1e\xc4\xdf\x83\xd4\x1d\x34\xeb\x90\xf7\x11\x3e\x7d\x44\x9e\x7c\x8c\x8f\x1f\xa3\xe3\x13\xe2\xf3\x09\x31\xfc\x04\x1e\x0e\x61\xf7\x61\x64\x1c\xc1\xaf\x4f\xe9\xf3\x29\x76\x7e\x06\xa7\x9f\x91\x13\x9f\xc1\xe9\x67\xe8\xff\x8c\x38\x7c\x0e\xaf\x9f\xa3\xff\x73\x7c\xff\x9c\xf8\x7d\x41\x7c\xbf\x40\xd7\x17\xf8\xfc\x05\xfd\xbe\xa0\xcf\x97\xc4\xe9\x4b\x9e\x8f\x82\xaf\xf0\xff\x2b\xf4\x7f\x4d\xfd\x31\xe2\x70\x1c\x39\xdf\x30\x0f\x4f\x10\x87\x93\xd8\x7d\x12\x3d\xdf\x82\x53\xe8\x3e\x05\x8f\xa7\xc9\xf9\x12\x6c\x38\x03\xcf\x67\x78\xfe\x0e\xb9\xdf\xe3\xff\x59\x62\x72\x16\x39\xe7\x78\xfe\x81\xf6\x1f\xd1\xfb\x23\x1c\x9f\x47\xc6\x79\xd6\x9c\x9f\x88\xf9\xcf\xb4\x5d\x20\x06\xbf\xd0\xf6\x0b\xfc\x5c\x84\xef\x5f\xf1\xe5\x37\xec\xf9\x8d\x1c\xfc\x9d\x58\xfe\x41\xfb\x9f\xc4\xe3\x12\x1c\x5c\xc6\x97\xcb\xd8\x75\x05\x7f\xae\xe2\xff\x55\x72\xd4\xc7\x58\x1f\x9c\xf8\x57\x71\x5b\xac\x0a\x76\x70\xcb\x9c\x00\xbe\x15\xa5\x35\x04\x4f\x8a\xd2\xeb\x81\xf7\x45\x19\x09\xe0\x90\x28\x1b\x75\x9c\x53\x94\xa3\x06\xd8\x27\xca\x39\x16\xd0\xdf\xb5\x50\x54\xc8\x70\x51\x9c\x49\x54\xb9\x8b\xa2\x42\x87\x00\xfa\x87\xe5\x82\x77\x44\x95\xef\x01\x56\x80\x3f\x44\x85\xd3\x37\x02\x7d\x91\x11\x60\x8e\xa8\xa8\xda\x80\xb6\xe8\x51\xe0\x27\x51\x31\xc8\x89\x45\x4e\x9c\x01\x26\x01\xe4\xc4\x17\x80\xe3\xa2\x12\x9a\x00\xec\xac\x30\x5d\x54\x45\xc6\x25\x56\x02\xd8\x5f\x09\x7b\x2b\x15\x8b\xaa\xdc\x49\x54\x15\x0e\x9e\x55\x8e\x72\x25\x42\xa6\x07\x7f\x3c\x57\x44\x25\x6d\xe6\x90\x4b\xff\x64\x74\xa4\x20\x3b\x85\xba\xaa\xd8\x95\x5a\x24\xaa\x1a\xf6\xd6\x68\x21\xaa\x26\xb2\x6b\x79\x44\xa5\xe1\x5f\x6d\xde\xeb\xc4\x00\xec\xab\x8b\xec\xba\xc8\x4e\xc7\x97\x7a\xd4\xd5\xc3\xf7\x7a\x8c\xad\x8f\xbc\xfa\xf0\xd1\xc0\x09\xe6\x89\xca\x80\xa3\x8c\xe5\xa2\x1a\x52\x72\x76\x51\x0d\x91\xd7\x10\x3b\x1b\xc2\x5f\x26\xbe\x66\xe2\x43\x26\x76\x34\x42\x76\x23\xc6\x37\xc2\xaf\x46\x70\xd7\x98\xbe\x8d\xb1\xab\x31\x3a\x9a\xe0\x73\x13\xf4\x35\x81\x83\x26\x4b\xc1\x41\x51\xe6\x2f\xc1\x35\x45\x57\x53\xc6\x37\x5d\x0c\x3e\x13\xd5\x0c\x9d\xcd\xb0\xa7\x19\xbe\x37\x3b\x27\xaa\x39\x3e\x35\xc7\xd6\xe6\xc8\x6f\x81\x8d\x2d\xda\x00\x38\xb8\x89\x3e\x59\xf4\x61\x09\x50\x5e\x62\xe0\xa5\xfd\xe6\x1c\x80\x5d\xad\xb0\xaf\x15\x7c\xb5\xea\x0b\x90\xdb\x8a\xfe\xad\x89\x4b\x6b\x6c\x69\x0d\x77\xad\x79\x6f\xc3\x7b\x1b\xfa\xb5\xa1\x7f\x1b\x78\x6a\x8b\x9e\xb6\xb4\xb7\x5d\x07\xd0\x9b\x8d\xfc\x6c\xe2\x99\x7d\x46\x54\x3b\xfc\x6a\xc7\xb8\x76\xd4\xb7\xc7\xa7\xf6\xe4\x40\x7b\xde\xdb\xe3\x63\x07\xec\xef\x80\x4f\x1d\xc8\x99\x0e\xe4\xc0\x2d\xc8\xbd\x05\x7f\x6e\x21\x7f\x6e\x81\xc3\x5b\x76\x89\xea\x88\xef\x1d\x19\xd7\x91\xfa\x8e\xbc\x77\x22\xb6\x9d\x78\xee\x44\x7b\x27\x62\xde\x89\xdc\xe8\x8c\x2d\x9d\xe1\xba\x33\xbc\xdc\x0a\x07\xb7\x7a\x01\x39\x72\x2b\x71\xbc\x95\xfc\xe8\x02\xcf\x5d\xf0\xb3\x0b\xfe\x74\x41\x46\x17\x74\xe5\x60\x57\x0e\x79\x90\x83\xcd\x39\xf8\xd0\x15\xb9\x5d\xf1\xb9\x2b\xfc\x76\x65\x5c\x57\x6c\xef\x06\x5f\xdd\xf0\xb1\x1b\x31\xe9\x4e\x7b\x77\x72\xa0\x3b\xef\xdd\x69\xeb\x81\xed\x3d\xb0\xb3\x47\xb1\xf5\x8b\x89\xaa\x27\xfe\xf7\x44\x7e\x4f\x6c\xea\xc5\x7b\x2f\x64\xf5\xa2\x6f\x2f\x7c\xed\x85\x5d\xbd\xd0\xd9\x1b\x79\xbd\xa7\x02\xc6\xe4\x92\x53\xb9\x8c\xc9\xa5\x2d\x0f\x9b\xf3\x88\x6f\x1e\x7e\xe5\x91\x03\x79\xe4\x61\x1f\x74\xf5\xc1\xa7\x3e\xd8\x9b\x0f\x07\xf9\xf8\x94\x8f\xbe\x7c\xf8\xe7\x2c\xa9\xfa\x61\x4f\x3f\x7c\xea\x47\x9f\x02\xc6\x17\xc0\x41\x01\x3e\x17\x20\x6f\x20\x6d\x03\x89\xe7\xc0\x99\x80\xbc\xe0\xdc\xa8\x38\x37\xaa\x41\xf8\x35\x98\xfa\xc1\xd4\x0f\x26\xff\x86\x84\x02\x62\x37\x04\x39\x43\xc8\x01\xce\x8b\x6a\x28\x5c\x0f\x85\x9b\xa1\xf4\x1b\x4a\x3f\xce\x8e\x6a\x28\x1c\xdd\x86\x8c\xdb\xf0\xf9\x36\xe2\x7a\x1b\x3e\x71\x86\x54\xc3\x18\x3f\x0c\x3f\x86\xc1\xe3\x30\xf2\x69\x18\xb6\x0d\x23\x1e\xc3\xe9\x3f\x9c\x72\x04\x3e\x8d\xc0\xe7\x11\xd8\xc5\x79\x52\xdd\xce\xfb\x48\xec\x18\x89\xcc\x91\xbc\x8f\xc2\xc7\x51\xe4\xe7\x68\x78\x1a\x8d\xdd\x63\x88\xd5\x18\xc6\xb1\x6c\xab\xb1\xf8\x3b\x16\x2e\xc6\xc2\xfd\x58\x72\x65\x2c\x31\x1a\x07\xb7\xe3\xc8\x95\x71\xe8\x19\xcf\xd8\xf1\xe4\xd9\x78\xf2\x67\xbc\xf9\x8e\xbc\x42\x6c\x2e\x84\xc3\x42\xde\x0b\xcd\x77\x78\x9c\x80\x9d\x13\xe1\x67\x22\xb2\xef\xc4\xae\x3b\x29\x27\xd1\x3e\x19\xdb\x27\xe3\xe7\x64\xb8\x9c\xcc\xfc\x9c\x4c\xdd\x14\x38\xb8\x1b\x3e\xa7\x92\x87\x53\xe1\xed\x1e\xf8\xba\x17\x0e\xa6\xf1\x3e\x0d\x1b\x38\xcf\xa9\x19\xd8\x35\x83\xb6\xfb\xb0\xf9\x7e\xca\x99\xe8\x99\x89\x9e\x07\xf0\x7f\x16\xba\x67\xe3\xe3\x6c\xfa\xcd\xe1\x79\x0e\xbe\x70\x16\x53\x73\x91\xf1\x10\xf1\x99\x47\x1b\xe7\x2b\x35\x0f\xfe\xe6\xe1\xd7\x7c\xe2\x3a\x9f\xba\x87\xe1\x7c\x01\x3c\x2e\xc0\x0e\xce\x55\x6a\x01\xf2\x16\x12\xf7\x45\xc8\x7c\x84\xb1\x8f\xc2\xfb\xa3\xc8\x59\x8c\x7f\x8f\x91\xcb\x8f\x91\x43\x8f\x91\x83\x8f\x53\xf7\x04\xe3\x9e\xc0\xa7\x27\xe1\xe1\x29\x74\x3c\x8d\x5f\x4f\x93\xc3\x4b\xf0\x6d\x09\xf6\x2d\x85\xaf\x67\xf0\x9b\x33\x92\x5a\x46\x9c\x97\xd3\x7f\x39\xbe\x3c\x47\x1c\x9f\x47\xef\xf3\xf4\x7d\x01\xb9\x2b\x88\xef\x0a\xde\x57\x20\x63\x05\xdc\xae\x60\xec\x8b\xcc\xd5\x17\x89\xed\x8b\xd8\xf0\x22\xb9\xbd\x12\x1e\x57\xc2\xcf\x4b\xc8\x79\x89\xb6\x97\xb0\xe3\x25\xea\x5f\xc2\xdf\x55\x8c\x5d\x85\x4d\xab\x91\xb3\x86\x7e\x6b\xcc\x92\xba\x35\xcc\x83\x35\xf8\xbc\x16\xb9\x6b\x69\x5f\x47\xff\x75\xf8\xb8\x8e\xb8\xac\xa7\x7d\x3d\x5c\xac\x87\xf7\x97\x91\xf7\x32\xba\x5e\x46\xd7\x06\xea\x37\xd0\xbf\x08\x3b\x36\x92\x3f\x1b\x69\xdf\x88\xcd\xaf\xc0\xf9\x26\x64\x6f\x42\xf6\x26\xfa\x6c\xa2\xcf\x26\xfc\xde\x84\x6f\x9b\xc8\xa3\x4d\xe4\xd5\x66\x62\xf5\x2a\x1c\xbc\xca\x1c\x78\x15\x1f\xb7\xe0\xef\x16\x74\x6c\xa5\xef\x56\x72\xac\x18\x9b\xb7\x21\x63\x1b\x71\xdb\x8e\xdd\xaf\xa1\xf3\x35\x74\xee\x80\x83\x9d\xc4\x62\x27\xef\xaf\x33\xfe\x75\xc6\xbf\x81\x9f\xbb\xc8\xd7\x5d\x8c\x7b\x93\x9c\x7c\x93\x7c\x78\x0b\x9b\xde\x22\x57\xde\xa6\xdf\xdb\x8c\x7b\x9b\x18\x73\x04\x52\xef\x10\x97\x77\x98\x9f\xef\x60\xe3\xbb\xd8\xca\x59\x49\xed\x26\x07\x76\xc3\xe3\x7b\x94\xef\x11\xd3\xf7\x19\xbf\x07\x99\x1f\x10\xf7\x0f\x78\xdf\xcb\xfb\x3e\xde\xf7\x61\xfb\x3e\x62\xb9\x9f\x38\xed\x47\xf6\x87\x8c\xf9\x10\xae\x3e\x84\x23\xce\x36\xea\x00\x39\x77\x10\xdb\x3e\xc2\xee\x8f\x68\xfb\x98\xf2\x63\xe2\xfb\x31\xbc\x7e\x4c\xbf\x4f\xb0\xe1\x10\x7a\x0f\xc3\xc9\x61\xe2\x7d\x04\x7e\x3f\x25\x7f\x3e\x43\xf6\x67\xe4\xd9\xe7\xf0\xc0\x19\x45\x7d\x81\xbc\x2f\xd1\x73\x94\x98\x73\x2e\x51\x5f\x63\xc3\x71\x78\x3f\x4e\xf9\x0d\x7d\x4e\xe0\xcf\x49\xe6\x14\x67\x12\xf5\x2d\xfd\xbf\xc5\x9f\x6f\xc9\xc1\x53\xb4\x9d\x86\x67\xce\x25\xea\x0c\xf5\xdf\x11\x8f\xef\x19\x73\x16\xdb\xce\xe2\xdb\x59\x7c\x3d\x47\x0c\x7e\x80\x83\x1f\x90\xf7\x03\x3a\x7e\xa0\xee\x47\xf2\xf6\x47\x64\x9e\x87\xe7\x9f\xe0\xfb\x67\xfc\xbb\x80\xcc\x5f\x88\xdf\x2f\xf4\xb9\xc8\x98\x5f\x19\xff\x2b\xf5\xbf\x62\xdb\x6f\xf8\xf3\x1b\xb9\xfc\x3b\xf3\xe0\x0f\xec\xf8\x93\xb6\x4b\xe0\x32\xf5\x57\xe0\xfb\x2a\x31\xb9\x8a\x6f\x3e\x62\xe8\xc7\x57\xff\x51\xd1\xb8\x3c\x68\xaa\x09\x38\x28\x9a\x96\x03\x0e\x89\xa6\xb7\x07\x3b\x44\x33\xa6\x8b\x66\x6b\x23\x9a\xbd\x93\x68\x0e\x4a\xa7\x57\x34\x97\x89\x15\xa2\x85\x38\x41\x01\xa0\x5f\x39\xc6\x97\x2b\x16\x2d\x94\xf1\xa1\x67\x44\x0b\x1b\x02\x8e\x8b\x56\x7e\x38\xf8\x49\xb4\xf0\x27\x45\x8b\x60\x5c\xc4\x3a\x40\xff\x48\xca\xa8\x49\xa2\x45\x23\x3f\x86\xbe\x31\x13\x00\x32\x63\xd0\x1d\xbb\x5c\xb4\x38\xc6\xc5\x0b\xc0\xb6\x84\x7a\x60\x9f\x68\x15\xb0\xa9\xc2\xfb\xa2\x55\xec\x01\x3e\x13\x2d\x71\xa9\x68\x95\x5a\x00\x6c\xab\x34\x15\x14\x81\x6f\x45\xab\x5c\x09\xd4\x06\xb4\x55\x1e\x0b\x90\x57\x99\xb6\xca\xbb\xc0\x1f\xa2\x55\x41\x5e\x15\xe4\x57\x61\x7c\x15\x7c\x76\x1b\x60\x33\x78\x07\x5c\x14\xcd\x53\x15\xf4\x05\xe8\xf6\xa0\x8f\x73\x8e\x96\xc4\xf8\x64\x7c\x4b\x9e\x09\xf0\x33\x19\x9f\x52\x6a\x80\x5c\x30\x07\xe0\x53\x0a\x75\x55\x19\x5b\x95\xba\xaa\xf3\x00\xfa\x52\x13\x00\x36\xa4\xae\x02\xf0\x51\x8d\xbe\xd5\x1b\x02\x9e\x6b\xd0\xa7\x26\xb6\xd4\xc4\xe7\x5a\xc8\xae\x05\x97\x69\xc8\x4c\x43\x5f\x6d\xf4\xd6\x59\x28\x5a\x5d\xea\xd3\xe1\x39\x1d\xf9\xf5\xb0\xb9\x3e\xb6\x72\x36\xd2\xea\x23\xaf\x3e\x76\x34\x80\xf7\x06\xb4\x65\xd0\xb7\x21\xe3\x33\xe1\x2c\x93\xf6\x4c\xda\x33\x69\xcf\x44\x4e\x26\x5c\x71\x36\xd2\x1a\xe1\x6b\xe3\x08\x00\xe7\x1c\xb7\x35\xce\x43\x5a\x13\xfc\x6c\x02\x67\x4d\xe1\xac\x29\xf1\x6d\x0a\x27\x4d\xe9\xd7\x14\xfb\x9a\xd1\xde\x0c\xbe\x9a\x13\x9f\xe6\xc8\x6a\x81\x2f\x9c\x7f\xb4\x16\xa3\x00\x9c\xb6\xc0\xdf\x9b\xf0\xf7\x26\x6c\xb8\x89\xd8\xdd\x04\x87\x37\x31\xae\x25\x3a\x5a\x52\xdf\x92\xfa\x96\x70\xd8\x12\x4e\xb3\xe0\xd6\xcb\xbb\x17\x39\xde\x73\xa2\xdd\x4c\x2c\x6f\x46\xcf\xcd\xc8\x6f\xe5\x01\x70\xd6\x0a\xff\x5a\xd1\xd6\x9a\xf7\xd6\xe4\x0a\xe7\x25\xad\x35\xe3\x5b\xc3\x63\x6b\xfa\xb6\x46\x36\x67\x26\xad\x0d\xf5\x6d\xd0\xdf\x16\x3d\x6d\xe9\xc7\x79\x49\xcb\xc6\xf7\x6c\xf4\xb4\xc3\xbe\x76\xe8\x68\x47\x0e\xb6\x47\x66\x7b\xb8\xe9\x40\xbe\x74\x20\x6e\x1d\xe0\xe1\x16\x72\xe5\x16\x38\xe9\x88\x9c\x8e\x8c\xeb\x84\xae\x4e\xc4\x81\xf3\x8f\xd6\x99\x9c\xbc\x15\xbb\x6f\x45\x5f\x17\xe4\x74\x21\x2e\x39\xc8\xcd\xc1\xaf\xae\xc4\xb0\x1b\xdc\x77\x83\xa7\x6e\xf0\xd2\x0d\x39\xdd\x90\xd9\x8d\xf9\xd3\x9d\x18\x75\x27\x66\x3d\xa9\xeb\x85\xbc\x5e\xc4\xb4\x17\x3c\xf6\xc6\x36\xce\x29\x5a\x2e\x31\xe7\x8c\xa2\xe5\x11\x83\x3c\xfa\xe4\x21\xbf\x0f\x63\xfa\x20\xbf\x0f\xdc\xf7\xc1\xee\x7c\x7c\xca\x87\xcf\xbe\xd8\xd0\x8f\x5c\xeb\x0f\x17\xfd\xe9\x37\x00\x7d\x03\xe0\xa0\x80\x7c\x2e\xe0\x7d\x20\xf2\x07\x22\x7f\x20\x7d\x06\xd1\x67\x30\xef\x83\x79\x1f\x8c\x2e\xce\x25\xda\x60\xf8\x1c\x82\xae\xa1\xe8\x1f\x8a\x6d\x43\xf1\xf1\x36\x78\xb8\x8d\xbe\xb7\x61\xe3\x30\x72\x63\x78\x0c\x40\xf7\x08\xec\xba\x1d\x7b\x6e\xc7\xc6\x91\xc8\x18\x49\xce\x8c\xe2\x7d\x14\xb2\x47\xc1\xf5\x1d\xf0\x76\x07\xf3\x6e\x74\x28\x40\xde\x18\xfc\x1f\x83\x9c\x31\xd8\x3c\x16\xfe\xc7\x21\x67\x1c\x63\xc7\x53\xcf\x19\x42\x1b\xcf\x98\x42\x38\x9e\xc0\x98\x89\xcc\xed\x3b\x89\xf9\x5d\xf0\x36\x09\x1f\x26\xf1\x3c\x99\x5c\x9b\x82\x1f\x77\x9b\x1f\x6e\x23\x63\x2a\x3a\xa7\xa2\xf3\x1e\xea\xef\xc1\xf7\x7b\xc9\xb3\x7b\x89\xdb\x34\x7c\x99\x86\x9d\xd3\x89\xc1\x74\x7c\x9e\x41\x6c\x66\xa0\xe7\x3e\x64\xde\x47\xec\xee\x87\xf7\x99\xd8\x36\x13\xae\x1e\xc0\xb7\x59\xd8\x37\x0b\x8e\x66\x21\x6b\x16\xf1\x9e\x85\xff\xb3\x90\x3f\x9b\xb8\xcd\x21\x67\xe7\xf0\xfe\x20\x31\x7e\x10\x9b\xe7\x32\x4f\x1e\xa2\x9c\xc7\xd8\xf9\x8c\x79\x18\x7e\x16\x80\x85\xc4\x60\x11\x3a\x1e\xc1\x8f\x47\xb1\x67\x31\xb1\x7a\x8c\x79\xf7\x18\x1c\x3e\x0e\x27\x4f\x90\x17\x4f\x62\xcf\x93\xe4\xf9\x93\xc8\x7d\x8a\xf1\x4f\xd3\x6f\x09\x76\x2c\xc5\xbe\x67\xd0\xf3\x0c\xb6\x3d\x8b\x9c\x65\xc8\x5f\x0e\x27\xcb\xe1\xfb\x39\xec\x79\x1e\xbb\x38\x1f\x68\x9c\x0b\xb4\x15\xc4\xe7\x45\x6c\x59\x49\x0e\xad\xc4\xb7\x97\x88\xc3\x2a\xfa\xac\xc6\xdf\x35\xe8\x5e\x0b\x07\xeb\xf0\x69\x3d\xed\xeb\xb1\xe7\x65\xf2\x62\x03\x79\xbe\x01\xd9\x45\xc4\x65\x23\x3a\x37\xc2\xf1\x2b\xd8\xc1\x9e\xad\x6d\x26\x3f\x37\xc3\xd9\xab\xf0\xfc\x2a\xf3\x7a\x0b\x7a\xb7\xb0\x16\x6e\xc1\xbe\x2d\xd8\xbe\x15\x2e\xb7\x62\x53\x31\xf3\xad\x98\xf1\xc5\xf0\xbc\x8d\x58\x6c\xa7\xcf\x6b\xc4\xef\x35\xfa\xed\x20\x3e\x3b\xa8\xdb\x09\xaf\xaf\xa3\xff\x75\xe2\xf8\x06\xb2\x76\xe1\xef\x9b\xf4\x79\x13\xd9\x6f\x52\xf7\x16\xf1\x7a\x0b\xce\xde\x66\x8d\x7a\x1b\x7e\xdf\x21\x7f\xde\xa5\xee\x5d\xc6\xbd\x8b\x1f\xec\xd5\xda\x6e\xb8\xd9\x0d\x9f\xef\xd1\x87\x3d\x5b\x7b\x8f\xbc\x79\x0f\x3b\xde\x27\x4f\xdf\xc7\x97\xf7\x79\x7f\x9f\xf6\x3d\xf0\xb5\x07\xf9\x7b\xf0\x61\x0f\x75\x7b\xf0\x6f\x0f\xb6\x7d\x80\x2d\x1f\x60\xeb\x07\xd4\x7f\x00\x6f\x1f\x30\xd6\xfc\x07\xae\xf6\x92\x37\x7b\xe1\x65\x2f\xba\xf6\x62\xf3\x5e\x38\xd8\x87\xaf\xfb\xd0\xbf\x0f\x4e\xf6\x61\xd7\x3e\xea\xf6\x93\x0b\xfb\xe1\x7a\x3f\xfe\xed\x87\xa3\xfd\xc4\x7e\x3f\x71\xf8\x10\x3e\x3f\x44\xff\x87\xe8\xfa\x90\xfc\xfc\x90\xba\x03\xc8\x3c\xc0\xd8\x03\xc4\xe3\x00\x5c\x1f\xc0\xa7\x83\xe8\x3f\xc8\xf8\x83\xc4\xe2\x20\x1c\x1c\x44\xd7\x41\x7c\xfb\x08\x1b\x3e\xc2\xa7\x8f\xf0\xe9\x23\xe4\x7e\x44\x1d\x67\x08\xed\x63\xe4\x7e\x4c\xdd\xc7\xc8\xf8\x18\x19\x1f\xc3\xd3\x27\xd8\xf0\x09\xb1\xfe\x04\x2e\x3f\x21\xdf\x3e\xa1\xfe\x13\x64\x1f\x22\x8e\x87\x88\xc7\x21\xf8\x3c\x44\x8e\x1c\xc2\xb6\x43\xe4\xc3\x61\xb8\x39\x4c\x1e\x1d\xc6\xb7\xc3\xc4\xe8\x30\x3e\x1f\x41\xf6\x11\x64\x1f\x41\xf6\x11\x64\x1f\x21\x57\x3e\x45\xee\xa7\x70\xf6\x29\xb1\xfa\x14\xfb\x3f\x23\x2f\x3f\xc3\xc6\xcf\x90\xf3\x39\x5c\x7c\x4e\xff\xcf\xb1\xfb\x73\x72\xe9\x73\x7c\xfc\x9c\x3e\x5f\x60\xf3\x17\xc8\xfe\x02\x19\x5f\x30\xee\x0b\x38\xfe\x12\x1f\xbf\x64\xec\x97\x70\xf4\x25\xbe\x7c\x49\xdf\xa3\xf8\x77\x94\xf1\x47\xe1\xe8\x28\xb6\x1d\x85\xcb\xaf\xb0\xf7\x2b\xec\xfd\x8a\xbd\xf9\x2b\x78\xfb\x8a\xf1\x5f\x31\xfe\x6b\x62\xf7\x35\x76\x7c\x4d\xdf\xaf\xd1\xf5\x35\xf5\x5f\x13\xd3\x63\xe4\xca\x31\xfa\x1f\xa3\xfe\x18\x32\x8e\x51\x77\x1c\xfd\xc7\xe1\xe0\x38\xf6\x1f\x67\xec\x37\xe8\xfe\x86\xf8\x7e\x83\xee\x6f\xf0\xf5\x1b\xf8\x3a\x81\x9e\x13\xc8\x3b\x41\xcc\x4f\x10\xf3\x13\xe8\x3e\x89\x3d\x27\x19\xcb\x59\x4a\x3b\x89\xed\x27\x19\x7f\x12\xae\xbe\xa5\xee\x5b\xea\xbe\x25\xf7\xbe\x65\xde\x7c\x4b\xee\x9f\x42\xef\x29\xe6\xeb\x29\x7c\x3f\x45\x1e\x9c\xc2\x9f\xd3\xf0\x71\x9a\x18\x70\xe6\xd2\x4e\x63\x7b\x09\x65\x09\x6d\x25\xc8\x29\xc1\x8e\x33\xcc\xe7\x33\xc8\x39\x83\xec\x33\xd8\x7f\x06\xae\xbe\x23\x97\xbe\x23\x66\xdf\xe1\xd3\x77\x70\xfa\x3d\x31\xf8\x1e\x7f\xbe\xc7\xff\xef\xc9\x83\xef\xb1\xf5\x2c\xbe\x9f\x85\xbb\xb3\xc4\xea\x2c\x71\x3d\x8b\xac\x73\xe8\x39\x47\x1c\xce\xd1\xe7\x1c\x79\xf1\x03\xe3\x7e\xa0\xee\x07\x74\xfe\x80\xac\x1f\xb0\xe7\x47\xfc\xf9\x91\xba\x1f\x89\xfd\x8f\x70\xfe\x23\x3e\x9e\xc7\xef\xf3\xf8\x7d\x1e\x1b\xce\x23\xeb\x27\xf4\xff\x04\x57\x3f\xe1\xd7\x4f\xe4\xcb\xcf\xb4\xff\x8c\x5f\x3f\xc3\xe7\xcf\xf0\xf9\x33\xb2\x2f\x20\xfb\x02\x36\x5d\x80\xab\x0b\xe8\xbb\x80\x4d\xbf\xe0\xff\x2f\xd8\xf4\x0b\xfe\xfd\x42\xee\x5c\x64\xdc\x45\xe4\x72\x36\xd4\x2e\xd2\xe7\x22\x7d\x7e\xa5\xcf\xaf\xd4\xfd\x8a\x2f\xbf\x22\xeb\x57\x6c\xe2\xbc\xa8\xfd\x06\x0f\xbf\xc1\xc3\x6f\xd8\xf0\x1b\xdc\xfc\xc6\x5a\xf1\x3b\x1c\xff\xce\xbc\xf8\x1d\x5b\x7e\x87\x9b\xdf\xa9\xfb\x83\x7e\x7f\x30\x2f\xfe\x20\x6e\x7f\x10\xb7\x3f\x90\xf9\x27\xb6\xfc\x49\xee\xfe\x49\xfd\x9f\xf8\xff\x27\xf5\x7f\x52\x7f\x09\xfd\x97\xd0\x75\x09\xfd\x97\xa8\xbb\x84\x2f\x97\xe1\xed\x32\xfd\x2e\x13\xb7\xcb\xc4\xf8\x32\xf3\xfd\x32\xf9\x71\x85\xbe\x57\xc8\xbb\x2b\xd8\x70\x05\xd9\x57\xb0\xed\x0a\xdc\x5f\x85\xaf\xab\xd4\x5f\xc5\xf7\xab\xd4\x5d\xc5\xf7\xab\xd8\xeb\x23\x7f\x7c\xf8\xef\x23\x4e\x3e\x64\xf9\xf0\xcf\x87\xcf\x7e\xe6\x86\x9f\x7a\x3f\x3a\xfd\xd4\xf9\x8f\x8b\x2e\x31\xa0\x3d\x18\x05\x16\x82\xcd\xe0\x33\x70\x45\x74\xe5\x01\x6d\xc0\x70\xf0\x24\x78\x1f\x50\xaf\x35\x04\x43\x00\x75\xda\x41\xd1\x75\x27\xa8\x0d\x72\xc0\x04\x40\x3d\xe7\x62\x5d\x47\xbe\x61\x80\x1a\x20\x17\xcc\x03\xbb\xc0\x1f\xa2\xdb\xe8\x6f\x2b\x00\x33\xc1\x2a\xb0\x0f\xfc\x24\xba\x1d\x7b\xec\x4d\x00\x3a\xed\x4b\x01\xf2\x1d\xc8\x77\xb4\x00\x63\x01\x7d\x1d\xc8\x75\x22\xd7\x89\x5c\x67\x27\x40\xbd\x73\x39\x38\x24\xba\x8b\xbe\x9c\xbd\x75\x17\x76\xb8\xe8\xeb\xa2\x6f\x48\x02\x60\x3c\xe7\x70\x3d\x04\x7d\x21\xd4\x87\xa0\x2f\x04\x7d\xe5\xd0\xc7\xb9\x5c\x2f\x87\xff\xe5\x90\x51\x0e\x7d\xa1\x02\xf0\x31\x14\x1f\x43\xf1\x25\x14\xbf\x43\xf1\x3b\x0c\x9b\xc3\xfa\x02\xfc\x08\xc3\x8f\x30\xc6\x97\xc7\x86\xf2\xf4\x2b\xcf\xd8\xf2\xe8\x0a\xaf\x04\xf0\x95\xb3\xbc\x1e\x0e\x8f\x11\xc8\x8a\xa0\x4f\x44\x0f\x30\x1d\xac\x03\xd4\x47\x62\x7f\x64\x3d\x80\x9f\x91\x8c\x8d\x3c\x2a\x7a\x14\x63\xa3\x18\x1b\xb5\x18\x60\x47\x74\x28\xc0\xb6\x68\xe4\x47\x13\x9b\x68\x38\x8d\x3e\x23\x7a\x0c\x36\xc7\xe0\x63\x0c\x36\x73\x1f\xd0\x63\x18\x1b\x8b\x8f\xb1\x8c\x8d\x65\x6c\x2c\x63\xe3\x22\x00\xf1\x88\x9b\x0a\xf0\x37\x0e\x6e\xb8\x2b\xe8\xf1\xf8\x10\x4f\xbf\x78\x78\x88\x2f\x02\xdf\x8a\x9e\xc0\xd8\x04\xfa\x26\xd0\x37\xa1\x18\xa0\xa3\x02\xb1\xaf\x40\x5d\x05\x6c\xae\x80\x8e\x0a\xef\x80\x73\xa2\x57\xc4\x9e\x8a\xd4\x55\x84\xbf\x44\x38\x4d\x44\x77\x25\xc6\x57\xc2\x97\x4a\xd8\x53\x89\x98\x55\x42\x57\x65\xe2\xc0\xfd\x42\xaf\x8c\x8c\xca\xc4\xa2\x32\xf5\x55\xf0\xa7\x0a\x3a\xdc\xc8\x70\xe3\xb7\x1b\x8e\x3c\xd8\xe4\xe1\xd9\x63\x3e\x33\x2e\x89\x71\x49\xb4\x27\xc1\x73\x12\x7a\x92\xd0\x99\xcc\x73\xf2\x45\xd1\xb9\x4b\xe8\x29\x3c\xa7\x60\x4b\x55\x64\x57\xe5\xb9\x2a\xbc\x70\x87\xd0\xab\x92\x53\xa9\xd4\xa5\x52\x97\xca\xb8\x54\x6c\x4e\x25\x6e\xd5\x18\xc3\x7d\x42\xaf\x06\x77\xd5\xb0\xb5\x3a\xbc\x57\xc7\xee\xea\xd8\x5a\x9d\x3e\xd5\xe9\x53\x1d\x1d\x35\xe0\xab\x06\x31\xaf\xc1\xf8\x1a\xc8\xac\x71\xfc\xff\x1c\x35\x91\x5d\x93\x58\xd5\x24\xc6\x35\xb1\xa7\x16\xbe\xd4\x22\xee\xb5\x88\x6f\x2d\x74\xd4\x22\x87\xd2\x98\x6b\x69\xc4\x28\x8d\xfe\xb5\xb1\xb7\xf6\x24\xd1\xeb\x30\xae\x0e\x75\x75\xe1\xbc\x2e\xbe\xd7\x25\x5e\xe9\xc8\x49\x67\x2e\xd6\xc3\xae\x7a\xd8\xcb\xbd\x46\xaf\x87\x9c\x7a\xc4\xa6\x3e\x5c\xd7\x27\xfe\x0d\xe1\xae\x21\xfd\x1b\x62\x73\x43\x78\x6d\x48\xdc\x33\x91\x91\x09\xe7\x99\xbc\x67\x62\x47\x23\xfa\x36\x22\xd6\xdc\x6b\xf4\xc6\xe8\x69\x8c\xac\xc6\xf8\xd7\x18\x2e\x9a\xc0\x41\x53\xe4\x70\x9f\xd1\x9b\xc1\x51\x73\xfc\x6f\x8e\x7d\xcd\x91\xd7\x9c\x39\xd5\x9c\x71\xcd\x89\x0b\x77\x19\xfd\x26\xc6\xb4\xe4\x39\x8b\x76\x2f\xb6\xdd\x8c\x5f\xad\xe8\xd3\x06\x3f\xda\xe0\x6b\x36\x63\xb3\x29\xb9\x53\xe8\x1d\xc8\xe3\x0e\xf0\x7d\x0b\xf3\x8d\xbb\x83\xde\xd9\xfc\xcb\xd1\xd8\xd9\x85\x58\xe4\xe0\x4f\x57\x6c\xea\x06\x37\xdc\x13\xf4\xee\xd4\x73\x2f\xd0\x7b\x10\xfb\x9e\xa0\x17\x76\xf4\x66\x4e\xf7\x46\x56\x1e\xfd\xf3\x98\x6b\x79\xe4\x64\x1e\x79\xda\x07\xdb\xfb\xc0\x53\x1f\xb8\xcc\xe7\x39\x9f\x3e\x7d\xb1\xa3\x2f\x79\xdc\x8f\xdc\xea\x87\x5d\xfd\xc8\x93\xfe\xf8\xce\x9d\x40\x1f\x80\xdc\x02\xfa\x0c\x64\x0d\x1b\x48\x8e\x0c\x64\xbe\x0e\xc2\x96\x41\x8c\x1d\x4c\xff\xc1\xc8\x19\x52\x15\xa0\xf3\x36\x7c\x1c\x86\xcd\xc3\xf1\x69\x38\xe3\x46\x20\x63\x04\xe5\xed\xf8\x70\x3b\xfc\x8c\x64\xdc\x48\x9e\x47\xa2\x7f\x24\x39\x33\x0a\x3f\x46\x31\x8f\x46\xd1\x36\x0a\xdb\xee\xc0\x8f\x3b\x90\x73\x07\xbc\x8e\xc6\x3f\xee\x02\xfa\x68\x6c\x19\x83\xee\x31\xc4\x61\x2c\xfd\xc7\xd2\x3e\x16\x9d\xe3\x88\xcf\x38\x64\x8c\x27\xfe\xe3\xf1\xaf\x90\xb8\x14\x12\xdf\x42\xe6\xd4\x04\xfa\x4f\x20\xee\x13\xf1\x7d\x22\x7e\xdf\x49\x79\x27\xbc\xdf\x45\x79\x17\x32\x27\x61\xf7\x24\xf2\x60\x32\x6b\xc0\x64\xe2\x33\x85\xb9\x37\x85\x7e\x77\xc3\xc3\x54\x7c\x9e\x0a\x77\x53\xb1\x7d\x2a\x3a\xa7\x62\xcb\x3d\xf4\x9f\x06\xd7\xf7\xe1\xff\x2c\x62\x3d\x0b\x3f\x67\x21\x7f\x16\x71\x9a\xcd\xfb\x6c\xde\x67\x23\x77\x36\xba\xe7\xe0\xe3\x1c\x6c\x9f\x83\xbe\x07\x91\x35\x97\xb6\xb9\x70\xf2\x10\x31\x7c\x88\x72\x1e\x3e\xce\xa7\xee\x61\x6c\x5d\x40\x3e\x2c\xa4\x5c\x44\x3e\x2c\xc2\xff\x47\x90\xf9\x28\x5c\x3e\x8a\x4d\x8b\xf1\x67\x31\xf9\xf6\x18\x79\xfc\x38\x31\x79\x02\xb9\x4f\xa0\xe3\x49\xf4\x3d\x09\xa7\x4f\xe3\xff\x12\xf8\x58\x82\x8c\xa5\xe4\xcd\x52\xb8\x78\x86\x9c\x7b\x06\x1b\x9e\x45\xc7\xb3\xe4\xc1\x32\xfc\x59\x4e\x9f\xe5\xd8\xfd\x1c\x1c\x3d\x87\x2f\xcf\xc3\xd7\xf3\xc8\x7d\x01\x7b\x5e\x80\xfb\x17\xb0\xf3\x05\xf3\x1d\x99\x2b\xf0\x7b\x05\x3a\x56\xe0\xd7\x8b\xc8\x7c\x11\x0e\x5e\xc4\xa6\x17\xe1\x7b\x25\xe3\x56\x12\xd7\x95\xf0\xb4\x92\x1c\x78\x09\x2e\x5f\x42\xde\x2a\xe6\xde\x2a\x6c\x58\x85\xbe\x55\xc4\x6a\x35\x76\xaf\x86\xd7\xd5\xf8\xb1\x1a\x19\xab\x89\xc5\x6a\xec\x58\x8d\x0f\xab\x59\xc3\x56\xe3\xdb\x6a\xd6\xee\x35\xf8\xb3\x06\xde\xd7\x50\xbf\x06\x1f\xd7\x60\xe3\x1a\xea\xd7\x52\xbf\x96\xb1\x6b\xb1\x65\x2d\xfa\xd6\x92\x2b\x6b\xd1\xb9\x16\x5d\xeb\x68\x5b\x87\x6f\xeb\xf0\x73\x1d\xeb\xd3\x3a\x72\x76\x1d\xbc\xad\x27\x36\xeb\xb1\x6f\x3d\xba\xd6\xd3\xb6\x1e\x7b\xb8\xd3\xe8\xeb\x19\xf3\x32\x3a\x5e\x26\x57\x5f\xc6\x06\xee\x38\xfa\xcb\xe8\x7f\x19\x1f\x37\xd0\x7f\x03\xba\x37\x98\xcf\xcc\xbf\x22\x74\xbe\x02\x47\xaf\x20\x6f\x13\x3a\x36\xf1\xbc\x09\xbf\x37\xe3\xc3\x66\x78\xd8\x8c\x6d\xaf\x12\xd7\x57\xf1\x77\x0b\x9c\x6e\xc1\xb6\x2d\x70\xcd\xdd\x47\xdf\x42\xbf\x2d\xf0\xb7\x95\x3c\xd9\x4a\xcc\xb7\x22\x7b\x2b\xfd\xb6\xb2\xc6\x16\xd3\xb7\x18\xae\x8b\x19\x5b\x4c\xec\x8a\x89\x5b\x31\x63\x8b\xb1\xbf\x18\x3b\x8b\xc9\x43\xee\x4b\x7a\x31\xfe\x17\x13\x87\x62\x6c\xe1\xee\xa4\x6f\xc3\xd7\x6d\x8c\xdd\xc6\xd8\x6d\x8c\xdd\x86\x6f\xdb\x88\xd7\x36\x7c\xd8\xc6\xd8\x6d\xf0\xb2\x8d\xb5\x77\x1b\x7e\x6e\xc3\x8e\x6d\xd8\xb1\x8d\x71\xdb\xe1\x7f\x3b\x3e\x6f\xc7\x86\xed\xe8\xdb\x8e\xdf\xdb\xf1\x73\x3b\xdc\x6f\xc7\xf7\xed\x8c\xdb\x8e\x5d\xaf\x61\xe7\x6b\xf0\xbe\x83\x3e\x3b\xc8\x9d\x9d\xc4\x6c\x27\xef\x3b\xf1\xe3\x75\x6c\x7c\x1d\xd9\xaf\x13\xcf\x37\xc8\xcd\x37\xb0\xf1\x0d\x64\xef\xe2\x79\x17\x7c\xed\xc2\xdf\x37\x19\xf7\x26\x7d\xde\x64\x6d\x78\x8b\xfe\x6f\x91\x47\x6f\x91\x37\x6f\xc3\xf5\xdb\xf4\x7f\x07\x3b\xde\xc1\xde\x77\xe8\xf3\x0e\x72\xde\x65\xec\xbb\x3c\xef\xc6\xaf\xdd\xc4\x68\xb7\xf9\x8c\x9c\xf7\xe0\x9a\xbb\x9b\xfe\x1e\x7a\xdf\xa7\xff\xfb\x70\xf1\x3e\x32\xb9\xb3\xe9\x7b\x90\xb3\x87\x67\xee\x69\xfa\x07\x3c\xef\x25\xce\x7b\x59\x3f\xf6\xd2\x67\x1f\x72\xf6\xa1\x77\x1f\x36\xef\x87\xa7\xfd\xf0\xcd\x1d\x4c\xff\x10\xbe\x3e\x84\xdf\x0f\xf1\xe9\x00\x39\x7a\x80\xf5\xe2\x00\x76\x1d\x24\x8e\x07\x89\xe3\x41\xea\x3f\x82\x9b\x8f\xe0\xfe\x23\x7c\xfa\x18\xd9\x1f\xf3\xfc\x31\xf1\xfd\x84\x3e\x9f\x60\xcb\x21\x6c\x3f\x84\x8d\x87\xd0\x73\x08\xbb\x0e\x63\xd7\x61\xe6\xc1\x11\xea\x8f\x50\x7f\x04\xfe\x3e\x45\xc6\xa7\xf0\xf9\x29\xdc\x7f\x06\x97\x9f\xc1\xef\x67\xc8\xf8\x1c\xff\x3f\x47\xc6\xe7\xe8\xfc\x82\xb8\x7d\x81\xce\x2f\x88\xe9\x97\xf8\xf3\x25\xb6\x72\xff\xd1\x8f\xa2\xf3\x28\x7c\x1d\x45\xff\x57\xc8\xfe\x8a\x75\xe1\x6b\xf8\xff\x9a\xb5\xe0\x6b\xe2\x79\x8c\x3c\x3a\xc6\xf3\x31\xfc\x39\x8e\x9e\xe3\xc4\xfb\x38\xcf\xdf\xf0\xfc\x0d\xfe\x7c\xc3\x5c\x3b\xc1\xf3\x09\x72\xf4\x04\x32\x4e\x12\xe3\x93\xf0\x73\x12\x9d\xdf\x52\xff\x2d\xf5\xdc\x57\xf4\x53\xe8\x3c\x85\x2d\xa7\xc8\xe9\xd3\xd8\x72\x1a\x7b\x4f\x53\x5f\xc2\xdc\x2a\xc1\x96\x12\xb8\x3d\x83\xbd\x67\xc8\x89\x33\xd4\x7f\x47\xfd\x77\xc4\xe5\x3b\xe2\xc5\x7d\x44\xff\x1e\x1b\xbf\xa7\xfe\x2c\xcf\x67\x79\x3e\xcb\x33\x77\x10\xfd\x1c\x7c\x9d\xe3\xf9\x07\xea\x7f\xc0\x9e\x1f\xc8\xbd\x1f\xd1\xfb\x23\x5c\x9c\x47\xee\x79\xe2\xfa\x13\x6d\x3f\xf1\xfc\x33\x31\xfb\x99\x98\xfd\x8c\x5f\x17\x88\xd3\x05\xfc\xba\x80\xbf\xbf\xf0\xfc\x0b\x79\xf9\x0b\xf5\xdc\x23\xf4\x8b\xd4\x5f\x64\x0e\xfc\x4a\xee\xfe\x4a\x8e\xff\xca\xf3\x6f\x70\xf2\x1b\xf5\xbf\xc1\xf7\xef\xc4\xf5\x77\xb8\xfc\x1d\x8e\xff\x40\xd7\x1f\x70\xf2\x07\x3c\xfc\x49\x8c\x2f\x11\x97\x4b\xd8\xc0\x79\x5f\xbf\x42\xec\xaf\xc2\xaf\x8f\xf9\xec\xc3\x6f\x3f\xfe\x70\x46\x37\x64\x9e\x18\xaa\x12\x38\x2a\x86\xd6\x09\x3c\x29\x86\xde\xc4\xfa\x57\x39\x0d\x63\xba\x18\xb6\x36\xe0\xa2\x18\xf6\x1e\x62\x38\x3c\xe0\x90\x18\x9c\x8d\x0d\x27\x6d\xce\x3f\xc4\x70\x31\x3e\x24\x06\x2c\x17\xa3\x1c\x7d\x42\x23\x40\x01\x58\x27\x46\x18\xfd\x39\xcb\x1a\xe5\x13\xc0\x58\x70\x46\x8c\x70\xc6\x85\x6f\x06\x3c\x47\x38\x01\x7d\x22\xd0\x17\x91\x03\x86\x03\xda\x23\xb0\x21\x62\x15\x38\x28\x46\x64\xb1\x18\x51\x5e\xf0\xad\xf9\xff\xfb\x22\x9a\xf9\xff\x45\x62\x6b\x60\x9b\xc1\x2d\xc2\x21\x6e\x6f\x98\x66\xb7\xe9\x76\x4e\xe6\x36\x1d\x67\x25\x6b\x7f\xfa\xfe\xc8\x28\xd5\xb4\x69\x64\x46\x64\x46\xfd\x7a\xd1\x49\x91\x49\xd1\x91\x49\x91\xfb\x8d\xa1\x97\x97\x74\xd2\xf7\xdb\x66\x5c\x9a\x66\xcb\xbc\x1c\x6f\x7c\x67\xfe\xd6\xa2\x26\x2c\x26\x6a\x5a\x40\x96\xfa\xd6\xeb\xd7\x1d\x0e\xcd\x30\x5c\x4e\x8f\x52\xe1\x4a\x95\xd7\x95\xcd\x6b\xd8\x96\xe6\x1b\x9a\xfe\x88\x4b\xcd\x74\xa9\xf1\x2e\x35\xc8\xa5\x7a\xb8\x54\x1b\x97\x6a\xe0\x52\xc9\x2e\x15\xe3\x52\x86\x4b\x5d\x70\xa9\x13\x2e\x75\xc8\xa5\xde\x71\xa9\x57\x5c\x6a\x85\x4b\x2d\x2e\xed\x3f\xa4\xb4\x7f\x43\x97\xaa\x5a\xda\x7f\xd8\x45\x97\xda\xe6\x52\xab\x5d\xea\x29\x97\x7a\xd0\xa5\x26\xbb\x54\x07\x97\xba\xc9\xa5\xea\xb8\x94\xdb\xa5\xc2\x5d\xca\xef\x52\xe7\x5d\xea\x4b\x97\xda\xeb\x52\xaf\xb9\xd4\x5a\x97\x7a\xc6\xa5\xe6\xbb\xd4\x3d\x2e\x35\xc6\xa5\x06\xb8\x54\x47\x97\x6a\xee\x52\x69\x2e\x95\xe8\x52\xe5\x5c\xea\xaa\x4b\xfd\xe0\x52\x5f\xb9\xd4\xfe\xd2\xfe\x4b\x5c\xea\x21\xab\xff\x48\x97\xca\x77\xa9\xce\x96\xfc\x9a\x2e\x55\xc1\xea\xdf\xf8\xb2\x4b\x9d\xbd\x7e\xc0\x53\x2e\x6f\x7e\xd0\x98\x11\xd6\x90\x80\x0a\x4c\xaa\xec\x52\x66\xe7\x80\x35\x6f\xb8\xd4\x06\x97\x5a\xe6\x52\x77\x5b\xa2\xaf\x19\x81\xd1\xda\x01\xab\x99\xb6\x05\x2e\x35\xcd\xa5\x0a\x5c\xca\x5b\xea\x90\xa3\x7f\xbf\xd2\x9f\x01\xe3\xca\xfc\x0c\x18\x7f\xfd\xcf\x5f\xdd\x82\x3f\xe3\x6e\xf8\xf9\xdf\xfa\x4a\x56\x7a\x9a\x54\x4c\x88\xf8\x70\x00\x9d\xcc\x84\x88\xcc\xb0\x12\x42\xa5\xe8\x19\x7a\x66\x46\xac\x1a\xb6\x38\xe1\x9d\xdd\x6f\xa9\xf9\xfa\xc5\x4b\xd3\xf6\xec\x31\x73\xa1\xb7\xbe\x5b\x9b\x1e\xcc\xab\x14\x6f\x84\xae\x39\xec\x9a\x9d\xbc\xf2\x88\x12\xbb\x46\x6a\x65\xec\xef\xd7\xa0\x4c\x6e\x99\xa2\x4c\x68\xb7\x3f\x1c\x53\xec\x9b\x3c\x3f\xb6\x58\xdf\xad\x5e\xf3\xb5\x55\xaf\x05\x72\xcb\xc5\x04\x1a\x61\x9b\x2c\x89\xe2\x96\x57\xbd\xc3\x0d\x25\x15\x8c\x04\x9b\xa3\x8a\x3b\xce\x88\xb7\x3b\x2b\x57\x8a\x35\x62\x5c\xe5\xca\x87\x47\x19\xd1\x21\xf1\x09\x76\x5b\x4c\xb4\x2b\x24\x24\x3a\xc1\x66\x54\x0c\x0d\xad\xec\xae\x68\x24\x79\xca\x39\x1d\x46\x68\x58\x95\xca\xe5\x55\x98\xbb\x52\xb8\x44\x44\x56\x88\x8b\x8d\x8a\x8c\x08\x53\x07\xc3\x54\x97\xc8\x05\x91\xcb\x22\xf5\xac\xc8\x2e\x91\x5a\x58\x64\x58\xa4\x2d\x21\x3e\x26\x5a\x0f\x71\xd9\x6d\x92\x9e\x91\x91\x91\x05\xa2\x9a\x36\x4d\x4f\xef\x37\xae\xdf\x38\x5c\xcf\xc8\x88\xd8\xdf\x80\x9f\xb2\x8f\x51\x2a\xbe\x69\x64\x54\xbc\xe5\x8d\xf5\xbf\xa8\xe0\x7b\x10\x78\xa8\x27\xc5\x26\xe9\x29\xd1\x26\x52\x32\x33\x40\x52\x74\x86\x6e\x22\x83\xfa\xa4\x68\x7d\xfa\xad\xca\xf0\x9d\xca\x1d\xdd\xcb\xf7\x58\x8f\xd1\x3d\xf6\x7c\x73\xeb\x15\x15\x95\x37\x3a\x57\x8d\xcc\x1d\x9d\xfb\xc9\x55\x6f\x8e\xba\xfd\x56\x7d\xa2\x6f\xc1\x28\xdf\x70\xf5\xa4\x89\x51\x6a\xdc\xa8\xc0\x93\x6f\xf8\x28\xdf\x02\x35\xce\xfc\x1b\xb8\x71\xfe\xf1\x46\x37\xdb\x39\xa9\x2a\xb5\x25\x43\x8e\x78\xe7\xe9\x5a\x9d\xd0\xa8\x8a\x15\x6b\xd6\x4c\x49\xa9\x1a\x5e\xbf\xbe\xc3\x51\x35\x2e\x36\xd5\xed\x8e\xad\x1a\xaa\xd9\x1a\x66\x56\x68\x10\xde\xa0\x30\xef\x40\x4d\xf5\x4c\x4d\x65\x9b\x53\x53\x4d\x72\x7c\xe6\xd0\xde\xab\xf8\x69\x45\x6d\x4b\x45\x35\xbb\xe2\x4b\x15\xb5\x4f\xeb\xab\x95\xf5\xd5\x5d\xf5\x55\x9d\xd0\xfa\x15\x1d\x35\xdd\xa9\x4e\xb9\x27\x6e\x7e\x9c\x56\x31\x4e\xc5\x45\x45\x78\xa3\xe3\xdb\x47\x78\xc3\xc3\x95\x4b\x0f\xf7\x96\x8b\x68\x1f\x5e\xcb\x2e\xf6\xc2\xbc\x94\xe4\xc5\xfa\x0a\x5d\x1b\xab\x4f\xd7\x35\x9b\x1e\xab\xf7\xd4\x87\xea\x86\x2e\x92\xde\x80\xbc\x6a\xb0\x3f\x2d\x52\x32\x12\xd2\xd3\xc8\xa6\x8a\xfb\xd3\x32\x32\xfa\xf5\x83\xa0\x6b\xf9\xdc\xaf\x9f\xd9\x1c\x20\x34\xe3\x9f\xfe\x57\xbf\x5e\x6a\x55\xbd\x71\x15\x15\x1f\x59\x57\xcf\x6c\xd8\xa8\x31\x09\xc8\x8b\xa3\xae\xaa\x1e\x59\x45\x8f\x8d\xb1\x3b\x62\x53\x54\x43\xf3\xad\xa5\x52\x31\x66\x37\x43\xb3\xfb\x7a\x65\xaf\xa9\xb0\xec\xe1\x8d\xb3\xbb\xa7\x7e\x73\x60\xea\x6b\xfb\x6a\xbd\x1c\x33\x65\xe2\xa6\x27\x72\xeb\x5e\xf8\x7a\xaa\x5a\xde\x70\xd0\xc3\xf3\x9f\xb8\xda\xb7\xc1\xe0\x31\xbe\x2b\x31\x51\xaa\x67\xea\x5d\x93\x5c\xea\xa7\xda\xd9\xf9\xc3\x3b\x2c\xd9\xe0\xba\xff\x7e\xd7\x13\xcb\x93\xfa\x8f\x28\xe7\x6b\x5d\x2b\x3b\x77\x52\xd7\x17\xdf\x2f\xf7\xbc\x96\x70\x73\x8f\xc6\xa9\xbe\xda\xae\x09\xda\xc5\xe6\xdd\x9a\x54\x52\x2f\x96\x37\xf3\xd4\x26\x1d\xfc\x17\xed\x87\x6c\xf3\xa5\x9c\x84\x93\xab\xd5\x89\x41\x6f\x6f\x66\x25\x49\xb6\x97\x0f\x0f\x0d\xab\x11\x5d\xb7\x42\x85\xe8\xb0\x70\x38\xca\x6c\x18\x57\x7f\x4b\x5e\x44\x5c\x71\x7e\x44\x1a\xa5\x51\x5e\x0f\x8b\x72\xb9\xb7\xe4\xe9\xae\xe2\x7c\x3d\x95\x32\x5a\xb2\xcc\xbf\xaf\x90\x90\x95\x65\x96\x7f\xa3\x83\x7c\x8a\xb1\xa7\x24\x57\x83\x80\x8c\x06\x71\x2a\x45\x65\xa4\x36\x88\x8b\x2d\xad\x52\x0d\xab\xa5\x24\xdb\x63\x63\xe2\x32\x1a\x5c\xf7\x6c\x3f\xf4\xfc\xb3\x4b\x97\x3d\xb5\x72\xc5\x93\x97\x9b\x2f\xd1\x9f\x7e\xe6\xf2\xb1\x65\x4f\x2f\x7b\xf6\xd9\x65\x4f\xdb\xfa\x75\xce\xcf\xef\xda\x25\x3f\xb7\xdb\xe5\x9f\x3a\xf5\xe9\x9f\x93\xd3\xb7\x77\x57\xf5\xca\xa7\x25\xdf\x7c\xf5\xed\xb1\x53\x57\xc7\xda\x66\x84\x1e\xff\xfa\xf3\xef\xcf\x7c\x79\xec\xd8\x95\xd4\x4d\xcf\x3d\xbb\x65\xed\x8b\x2f\x69\xbb\x8b\x9e\x5f\xb6\x69\xfd\x8b\xab\xc4\xcc\xbb\xf6\xfe\x73\xb6\x46\xb6\x07\x25\x45\xd2\xa5\xa9\x4c\xf4\x66\x37\x74\xd6\x0a\xab\x1a\x5d\x31\x31\x29\x31\xba\x72\x82\x56\x2f\xae\x76\x83\x90\x30\x67\x58\xb3\xe6\x71\x0d\xaa\xdb\x22\xaa\x77\xcd\xab\x1d\x12\xd1\x58\xab\x57\x39\xc1\xa8\x58\xd1\xb6\x30\x42\xed\x8a\x50\xe1\x11\x59\x11\x9a\x4b\x8f\xb0\x35\xee\x9a\x67\x8b\x13\x77\x4e\x9e\xc4\x41\x02\x14\x80\x74\x73\xe9\x19\x17\xd5\x34\xdd\x9c\x4e\x4d\x9b\x42\x88\xb0\x74\x94\x65\xa5\x7e\x3d\x5b\x72\xf5\xf2\xca\x24\x20\x22\xb5\xae\x0a\x10\x63\xa6\x43\x5c\x7c\xa3\xc6\xf1\x14\x19\x0d\x1a\xc7\xda\x4b\xd9\x88\x6f\xa9\xe9\xd5\xaa\x07\x69\x31\x56\x6f\x9c\xdc\x71\xd7\x88\x4f\xcf\xa9\xde\x49\xf5\xb6\xae\x7a\x62\xdb\xd6\x13\x63\xb6\x8c\x6b\xb6\x28\xeb\xb1\x82\xb1\xed\xea\x36\xf1\x0d\x1b\xd2\xab\x60\xc8\xcd\xf7\xdf\x9d\x75\xcb\xee\xc9\xe7\x96\xcc\x6a\xf7\x70\xe8\xb4\x9b\xb3\x0f\x14\xab\xb8\x27\x5a\xae\xc9\x7e\xfc\xc5\x27\x67\xde\x59\xdc\x67\xff\x81\x95\x17\xd3\xfe\x3c\x3a\x28\x62\x76\x9c\x31\xb9\x7d\xfe\xb0\xfc\xf1\xf7\x65\xde\xda\xe7\xca\xf3\xdf\x1f\x1b\xb2\x67\xf2\xfc\xc6\xe6\xdf\x91\x1f\xce\x92\xe6\xb1\xd6\xc4\x0a\xde\x72\xba\xa6\x19\xd6\x6a\x68\x2e\x86\xfb\x83\xab\x6a\x70\x1d\x0c\x09\x2e\x7f\xb4\x4e\xf3\xe5\x6a\xcf\xda\xf6\x49\x79\x49\xf6\x46\x38\xa4\x5c\x88\x6e\x84\xb0\x35\x87\x47\x84\x24\x32\x9f\xb2\xb2\xca\x50\xc0\x06\x1d\x11\xd5\x38\xc3\xae\x45\x46\x44\xc5\xa7\x54\xd3\x22\xa7\xbd\xba\xe3\xe5\xd7\x36\xac\xdf\xf9\xf2\xce\xcd\x5a\x8c\x4a\x52\xfb\xf6\x1e\xf4\xd5\xf6\x7d\xef\x3b\xeb\xab\xfb\xc9\x3e\xb5\x5f\xb9\x91\x1f\x8a\xfc\xb4\xbf\xe4\xeb\x46\xb9\x10\x4e\x1f\xa6\x7c\xd1\x13\x6f\x94\xaf\x22\x34\x47\x4a\x23\x56\x4d\xad\x7a\x46\x5c\x54\xa4\x96\x86\x82\x1d\x2f\x6f\x78\xcd\x54\x10\xe1\x3b\xe6\x6b\xb8\xf7\x63\xf5\x91\x8a\xe7\x7f\x1f\x7f\xb4\xcf\x97\xe1\xfb\xc6\x9c\x13\x4a\x92\xb4\x57\xb4\xab\xf8\x5d\x5e\xba\x7b\x1b\x70\xe8\xb4\xbb\x6c\x21\x36\xa3\x9c\xa1\x2a\x1a\xb5\x0c\xcd\xe1\x8c\x73\x2a\x9b\x33\xd5\xa9\x19\xce\x90\xf2\x61\x61\x5a\x48\x88\x16\x1e\x71\xcc\xa6\xc4\xf6\x93\x4d\xb3\x95\x87\x9e\x7d\x81\x5d\xc7\x8c\x3c\x86\x34\x65\xad\x88\xcc\x30\x11\x69\xad\xab\xa9\xf1\xb6\x78\x47\x39\x55\xbd\x71\x6a\x63\x1b\xe4\xbd\xaf\x9c\x75\x7c\xa7\xb7\xdd\xf5\xf8\xd2\xbb\x76\xfa\xce\xd4\x51\xe5\x42\xe7\x18\x7d\x86\xcd\xec\x70\xa9\xbd\xd2\xfc\xd2\xfe\x8f\x0e\xb3\x46\xaa\x9a\x96\x5d\x43\x64\xb3\xd1\xce\x78\x96\xb9\xda\xda\x5b\x8d\x0d\xc6\xae\xeb\x61\xa1\xab\x35\xa5\x87\x6b\x03\x34\x2d\xd4\xae\x71\x56\x33\xd6\xe7\xb9\x8e\x38\x54\x63\xc7\x6c\x87\xe6\xb0\x6d\x62\xdf\xea\xd7\x2f\xc3\x5c\xa0\x32\x48\xc8\x01\xd7\x6d\x86\x91\x29\x91\x49\x99\x49\x58\x95\x14\xab\x2d\x7b\xd4\x97\xab\x56\x3d\xaa\x56\x69\x05\xbe\x1e\x6a\xdd\x23\x6a\x9d\xaf\xc7\x23\xa6\xce\x62\xdf\x25\x35\x43\xbe\x64\x3f\x4b\xf6\x46\x1a\x36\x71\xda\x9c\x21\xe5\xc4\xb6\x2a\xdf\x29\x4b\x40\xba\x35\xd5\x4b\x37\xc5\x54\x33\x7d\x53\x1a\x65\xa6\x64\xaa\x19\xd5\x6a\xdc\xdd\x3f\xf7\xcb\x55\xb7\x3f\x7c\xf3\x9c\x7b\xbf\x0c\xf0\x9a\xaf\x0e\x6a\x5d\x34\x4e\xa2\x9c\xdc\x22\x09\x1d\x94\xbd\x96\xb7\x4c\x1d\x50\x5a\xba\x52\x4a\xd8\xae\x02\xc2\x48\x8c\xcc\xa4\xd8\x7c\x75\x51\x1d\x5c\xbe\x9c\x71\x6c\xa9\xea\x5e\x6c\xd0\x25\xde\x1b\x42\x16\x61\x86\x5a\x92\xcf\xea\x9c\x56\x9a\x85\x19\xac\xa9\xaf\xbd\xfd\x65\x50\x8f\xf8\xcf\x69\x4d\xcd\x4f\x7d\x25\x7a\xab\x66\xe3\x70\x2b\x12\x6d\xa6\x86\xb2\x8c\x8c\x55\x19\x4a\x2d\x79\xd6\x37\x22\xc6\x76\xfc\x92\xc7\xdc\xab\x73\xfc\xe7\x8c\x14\xdb\xe3\xf0\x1a\x2f\x35\xbc\x31\x51\xf6\x50\xb1\x4b\x42\x05\x57\x78\x61\x9e\xcb\xa1\xc7\x16\xe6\xe9\x15\x82\xf3\xba\xec\x01\x20\x42\x4b\x49\x36\x53\x37\xa9\x41\x94\x5e\xfa\x9c\xd1\x20\xca\x48\xf9\xf3\x97\x5f\x2e\xfe\xa0\xe4\xcf\x1f\xb6\xce\x7f\x7e\xe5\xa2\x47\x97\x2f\x5b\xac\xbd\xe9\x5b\xe6\x9b\xa7\xc6\xab\xc1\x6a\xa4\xba\xdd\xf7\x88\xef\x29\x55\x5f\x45\xf9\x2e\xf8\xf6\xfa\x0e\xf9\xbe\x57\xe6\xbf\x75\xb3\x14\xb7\xc2\xc9\xb9\x10\x49\xf3\xc6\x18\x4e\x4d\x2b\x17\x6a\x33\x0c\xdd\x6e\x77\x2a\x51\x13\xf2\x24\x01\x0b\xcc\x5d\x88\xbd\x3d\x3d\x23\x18\x45\xd3\xef\xa4\x48\x5b\x66\xaa\x19\xc2\xa5\x6a\x98\xef\x2d\xd5\x79\xa5\xea\xfd\x94\xd1\xe2\xe4\x9a\x53\x97\x13\x9e\x32\xb9\x18\x86\xdc\x50\x7c\xab\x22\x2d\xbd\x9e\x4a\x52\x3e\xdc\x19\x5b\x39\x36\x5c\x0c\xb7\xc7\x59\xa9\x7c\x54\x54\xb9\xc2\xbc\x28\x87\x92\x4a\x52\xa9\x54\x07\xeb\x54\x82\xa5\x2a\xaa\xe9\x75\x73\x29\x23\xb3\xa5\x2d\xd3\x5a\x8c\x1c\xd5\x5b\x2a\x6b\xa9\x2a\xaf\x1c\xfc\x97\x14\x3b\x2c\xe3\xd1\xe7\x97\x4d\xef\x32\x67\x72\xe1\x63\x61\xc5\x31\xbf\xbf\x75\xf8\x54\xc7\xc5\x1f\x15\xce\xa9\xa2\x1d\x9b\x36\x71\xd3\xa2\xa9\x53\xe7\xf4\x9a\x30\xfd\x9e\x71\x91\xab\xdf\xdf\xb3\xad\xdb\xf3\xcf\xaf\xe9\xff\x44\xf6\x53\x56\x9c\x6e\x85\xf7\x0a\xd8\x56\x43\x06\x7b\x9b\x3a\xec\x89\x95\x62\x93\x43\x45\x92\x53\x23\x2a\xd9\xed\x35\x6b\xa5\x46\x46\x44\x46\x4c\xc8\x8b\x4c\x88\xbe\xaf\x33\x7f\xa8\xce\xe1\x91\x2a\xc2\x16\x19\xa9\x27\xba\xdd\x09\x85\x79\x6e\x87\xee\x2a\xcc\x73\x98\xa1\xc9\x08\xc4\xc6\x34\xd9\x5a\x77\xad\xfd\x47\x6e\x5c\x6d\x03\xfb\x4f\xf5\xc6\x71\x49\x0d\x1a\xe1\x48\x9a\xca\xcc\xb0\x1e\xca\x7a\xc4\x5e\x5c\x45\x19\x15\xfe\x38\x7d\xc4\x9f\xb0\xbd\xaa\x0a\x9f\xb3\x64\xe3\x4b\xb7\x0d\x5a\xfc\xc2\x03\xf7\xdf\xf5\x68\xe8\xab\xb8\x76\xe8\xec\x13\x0b\x9f\x2d\x52\x0f\xbc\x7d\xe4\xcd\x9d\x91\x97\x66\xcd\x2c\x9c\xb1\x74\xc6\xf8\x71\xf7\x4f\x19\x53\x7e\xfd\x5b\xef\x16\xcd\x5e\x5d\xc5\x88\x7c\xc5\x3a\xff\xa5\xc3\x7b\x63\x2b\x9e\x51\xd2\xc8\x5b\x31\xd2\x16\xa5\x69\x2c\x1b\x2a\x9a\xcb\x52\xa4\x51\x98\xe7\x8c\x8c\x54\xe5\xec\x76\x05\xe7\x59\xd8\x9d\x9e\x11\x3c\x44\x34\x0d\x4c\xcf\xbf\x26\xa8\x99\xb4\xb1\x0a\x9e\xb9\x94\x24\xe9\xe3\xd6\x5c\x1d\xae\x3d\xb0\x73\xb7\x6f\xa1\xd6\x30\xcc\xf7\x44\xa3\x08\x75\x41\x65\xf9\xde\x54\x59\xf3\xf4\x2d\x57\x3a\x3d\xac\xdf\x65\xef\x1f\x7d\xf5\x9c\xf9\x37\x82\xe0\xb7\x1b\xfc\x56\xc6\x86\x4a\xd2\xdf\x9b\x19\x15\xcd\x21\x31\x46\xa2\x1d\xf6\x84\x68\x58\x8e\x8b\xb6\x1b\x95\xab\x54\x24\xc5\x2b\x56\xd4\x63\x62\xe2\x27\xe4\xc5\xd8\x4d\x42\x87\x39\x54\x9c\x43\x15\x3a\xee\x67\xf9\xb0\xb8\xe5\x88\x13\x4c\x7d\x12\x23\xfd\xba\x8d\xdd\x5a\xdd\xa2\xcc\x25\x2d\x46\x02\xd4\xfe\xc5\x28\xe7\x46\x4e\x89\xe6\x96\x66\x54\xf6\xfd\x7e\xf6\xdd\x0b\x9e\x2d\x4d\xcf\x2d\x5a\xf1\xe2\xbc\x0e\xf7\x66\x15\xa5\xeb\x49\x57\xef\x4f\x9c\xf8\xf2\xc1\xdf\xd5\xde\x63\x7e\x59\xf7\x42\xec\x47\x1b\x9e\x7a\x60\x45\xdd\xc6\xda\x6f\x4f\xf9\x6e\x36\x7f\x1f\x43\x86\x07\x73\x23\x4e\x92\x25\xc7\x9b\x56\x39\xd2\x1e\x5a\x2e\x5e\xa4\x9c\x5d\x4f\xa9\x1a\x59\x31\xa6\xe2\xc4\xbc\x98\x18\xdd\xe5\x2a\x5f\x98\x17\x1e\xba\x20\x54\x0b\xb1\x85\x32\x55\x3d\x7f\x4d\x55\x73\xb9\xbb\x66\xf3\x75\xc7\x33\x2b\x15\x02\xf3\x55\x32\x3c\xd1\x8e\x6a\xe6\xa3\x15\x7f\x47\x99\x93\x87\x51\xe1\xc2\xe1\x1f\xaf\x28\x3b\xf4\x76\x5f\x97\xb9\xe9\xe9\xd5\xf5\x5f\x29\x7c\xfb\xd4\xd6\xc7\x67\xdd\xbb\xe4\xb9\x7b\xef\x5b\xac\xf6\x1f\xf3\xf9\xd4\x20\xd5\x4d\x8d\x56\x73\x7c\xdf\xb8\xd7\xf9\xbe\xf1\xfd\x94\x3f\xe0\xe2\x91\xa7\x56\x3e\x3a\xe3\x85\x83\x1b\x2c\xfe\x47\x58\x73\x6f\x06\xeb\x4a\x2d\x6f\x8c\xd3\xb0\xd9\xc4\xe5\x92\xd0\x30\x71\x85\xb8\x26\xe4\x85\xd8\x0d\x33\xf6\x7f\x85\xdd\x64\xb3\x01\xb6\x85\x68\xb1\x29\x11\x51\x8a\xa5\xd9\x08\xfd\xec\x95\xbc\x1d\xa7\x54\xe8\xd5\x72\xfa\x0b\xc6\x79\xdf\x16\xdf\x5c\xdf\xe2\xb7\x55\x79\xad\xa7\x7a\xe0\x29\x56\xb7\x3c\x38\xaa\x08\x47\x15\x38\x3d\xa7\x4b\x4f\x6f\xdd\x34\xbb\x3b\xac\x62\x74\x2a\xcb\x5d\x9c\x2b\xcc\x6e\xaf\x57\x3f\xce\x95\x5c\x23\xb9\xc6\xc4\xbc\xf0\x64\x15\x6d\x4f\x4e\xd6\x23\x22\x2a\x4d\xcc\x8b\x70\xe8\x75\x26\x96\x5d\xd3\x24\x38\x6d\xfe\xe9\x8c\x72\xed\xd4\xd6\x38\xb3\xec\x19\x85\x69\xa2\x37\x4c\x2a\x25\x2b\x3a\x40\x5c\x04\x33\xcb\xa8\xf8\xc7\x99\x13\xfe\x67\xef\x2e\x7c\xe0\xe7\xbd\x07\x7f\x9e\x35\x61\xf6\xe3\x5f\xfb\x2e\x4d\x7b\xe0\xc1\x7b\xa6\x3d\x90\xb2\x74\xfe\x83\x4f\xab\x9a\x8f\x2e\x54\x0f\xbe\xfd\xc5\x91\x77\xe7\xee\x88\x31\x12\x37\x4f\x7e\xee\xfd\x77\x5e\x9a\xbc\x39\xde\x88\xdb\xa6\x85\x9d\x9f\x74\xd7\xe4\x69\x13\xaf\x5e\xb9\xff\x81\x05\xf7\xf8\xbe\x9a\x6f\xce\xa3\x02\x7c\x8c\xc2\xc7\x78\x7c\xec\xe1\xad\x5b\x25\x8a\xfc\x25\x7d\xed\x51\x7a\x6a\xb5\xd0\xa4\xf0\x24\xe2\x1f\xee\x0e\xd7\xca\xeb\xe1\xe1\x7a\x6c\x6c\x62\x61\x5e\xac\xb5\x2e\xc4\x3b\x54\x30\x7d\x6f\xf4\xf1\x5a\x2e\x5c\x3b\x23\x5c\xcb\xdd\xa8\x68\xf3\x38\xa6\x59\x5e\x46\x95\x49\x86\x96\xca\x88\xf2\xfd\xfe\xeb\x8b\xef\xa5\xad\x6b\x54\xbc\x64\x8d\x51\xe3\xad\x09\xaf\x7f\xfb\xc7\x57\x67\x2f\xbc\xb3\xf4\xfe\xfb\x1e\x7f\x7c\xfa\xad\xb3\x3a\x6b\x5f\xf9\x1e\xf3\x4d\x79\x68\x49\x62\x91\xf2\xa8\x72\x7d\xee\x50\xc6\xa7\x5f\x5d\xf5\xad\xd8\xb0\xe6\xc0\xc6\x27\x9e\xde\xd4\xee\x3e\x6b\x4d\xb0\xf6\x31\xa3\x99\x75\xc7\xac\xee\x8d\xd6\x1d\x0e\x43\x0c\x97\xd3\xfa\x90\x81\x1d\x20\x5f\x85\x5b\x21\x49\x2f\xbb\xcd\x44\xb3\xb3\xe9\xd6\xee\xf6\xf6\xdb\xfa\xc8\x03\x07\xae\x3c\x76\xe0\x80\x29\xcb\xda\x97\x91\xe5\x92\x30\xa9\xeb\xad\x10\x26\xe2\x0c\x71\xda\xf4\xf2\xe1\xe5\x42\x96\xe6\x97\x0b\x0f\xec\xd0\x4b\x03\x3b\x74\x70\xe7\x8a\xff\xdb\x2e\x1d\x69\xde\x85\x03\x3b\xf5\xdb\x07\x96\x5a\x5b\xf5\x01\x6d\x29\x0a\x94\x0c\x95\xa7\x8d\xf6\xc6\x1a\x36\xc2\x16\xde\xea\xba\x1d\x43\x1d\x4e\x5b\x96\x7d\x9a\x7d\x81\x5d\xb7\xeb\xf5\xb4\xb1\xda\x74\xcd\xfc\x97\x73\xc2\x8d\x2c\x63\x8c\xb1\xcc\x38\xc0\xd1\x43\x2a\xa4\xf7\xcb\x30\xef\xc9\x81\xab\x72\xbc\xb5\x91\xab\x58\x97\x8a\x1d\xaa\x9f\xbc\xb2\x52\xef\xa3\x35\xdf\xaf\x9e\x7f\x9a\xfd\x6f\xd1\x53\xa6\x0f\x43\x54\xae\xd1\x4e\x3f\x67\xf1\x91\xe5\xad\xe1\xd0\xcd\x7f\xe3\xcd\x65\x1e\x61\xc2\x6d\x6e\x5b\x17\xdb\x00\xdb\x01\x9b\x2d\x44\xb7\x29\xaf\x92\xf5\x79\x39\xea\xa0\xd2\xc2\x03\x07\x85\x7e\xd7\xae\xf7\x69\xd7\x14\x25\xc5\x2a\x30\x04\x4d\x95\xf5\x93\x7a\xee\xe2\xc5\x3e\x59\xbc\xd8\x9a\x87\xd7\xf9\xc2\x29\x49\xc7\x17\xbd\x9e\x31\xd6\x98\x6e\xe8\x86\xca\x92\x69\xb2\x00\x1b\xec\xb6\x70\x2d\x4b\x1b\xa3\x2d\xd3\x0e\x68\x36\xed\x1f\x7c\x69\x9c\xe9\x52\x99\xa6\x2f\x7d\xf0\xe5\xe4\xd3\x4f\xa9\x31\x6a\xf4\xd3\xbe\xfe\xfb\xad\xd8\xf6\x60\xae\x57\xb7\xf6\xd9\x64\xe9\xe6\xad\x9d\xe4\x49\xa8\xe0\x74\x45\x89\xb8\x3c\x15\x8c\x94\xaa\x51\x95\xc2\x5d\x59\x2e\xb2\xd4\xe5\x71\x7b\x96\xe6\xbb\x43\x13\x54\x98\x9e\x50\xa9\x52\xec\x80\xbc\x4a\x46\x60\x67\xc7\x17\x22\x2f\x09\x11\xbb\x79\x8a\xfc\xfb\x34\x2c\xcf\xfa\xcf\x2e\x90\xd2\xd2\x51\xba\x67\x35\xaa\x9a\xd1\xc0\x60\x17\x8b\x35\xaa\xd7\xee\xd6\x2f\xa7\x7d\xb6\xda\xa0\x55\x6f\x79\x6b\x4e\xe7\x16\xa9\x4b\xe6\xcd\x5b\x51\xbe\xb8\xa2\x32\x8e\x1c\x53\x72\x75\xc1\xdb\x86\xb3\xe3\x9d\x43\xda\x34\x6f\x58\xd8\xa6\xed\xf0\x9c\xac\xa6\x4d\xb3\x73\x9b\x8f\x9f\x39\x6f\x4a\xe8\xee\x43\x9f\x5c\xbe\x69\xcf\x1e\xec\x7f\xce\x77\xca\x31\x9a\x33\x53\x96\xdc\x2a\xf7\x7a\xb3\x13\x1d\x35\x9b\xb4\x0b\x77\x78\xbd\xf1\xf1\x09\x49\x22\xf5\x13\xc2\x9b\xd8\xba\xe4\x18\x95\x0f\xe7\x19\x46\x68\xe8\x2d\x47\xf2\xa2\x5b\x1f\xc9\x8b\x8f\x0e\x0f\x75\x87\x6a\xe5\xf4\xd0\xe8\xd0\xe8\x86\x2d\x5a\xa4\x1e\x31\x7f\xc5\xae\x9e\x8a\x32\xea\x35\x6c\x58\xe7\x48\x5e\x43\x49\x2f\xf5\x2c\x30\x05\x99\x83\xe6\x24\x8c\xcc\x48\x0b\xde\xa8\xff\xe1\xd6\x6c\xad\xce\xd6\x9a\xd3\x38\x25\x70\x3b\x6a\x18\xc5\x7c\x8c\xcf\x68\x9c\xa1\x33\x1d\xcd\xd9\x98\xd9\x50\xab\x9a\x92\x6c\x68\xb1\x31\x51\x46\x46\x83\xaa\x5c\x96\x8c\x94\xe4\xaa\x5a\x66\x44\x94\x24\x35\x60\xb5\x30\xf9\x29\xaf\x02\x4b\x53\xe3\x46\x8e\xd1\x85\xfb\xa7\x0d\x1e\xa5\xdb\x5b\xbd\x3d\xee\x99\xf5\x33\xce\xcc\xff\xb2\x9b\xbd\xfa\xd2\x09\xa9\x5d\x73\x66\xdf\xfa\xb4\xef\xeb\xb7\x2e\xf8\xe6\x1d\x7a\x46\xd5\xdc\xbd\x48\xd5\x5a\xde\x78\x91\x6f\xfd\xcb\x3f\xfb\x9e\x78\xe3\x4f\xb5\x5d\x45\xfd\xac\xfa\x6f\xbb\xfa\xfc\xcc\xd1\x43\x9f\xe9\x33\x60\xf0\x3d\x07\x6b\xc4\x6b\xbf\x6c\xf7\x7d\xb2\x22\x37\x37\xfb\xee\xbb\xf7\xbd\xba\x42\x55\x5c\xb9\x65\xb9\xcf\xbe\x22\xaf\xff\xdc\x0b\x8f\x6e\x52\xb1\x8f\x1d\xf1\xdd\x71\xe9\x4d\xdf\xe7\xcf\x76\xec\x3d\xb6\x77\xfe\x1b\x6a\xe0\x69\x95\xa0\x3e\x10\xff\xab\xbe\x2d\x27\x6e\xbb\x67\xda\x37\xf7\x4f\x9a\xf3\xf1\x33\x7d\xe1\xda\xfc\x67\xdc\xbb\xb1\x2f\x38\x24\x42\xf2\xbd\x8d\xc2\xb8\xd5\x68\xba\xdd\xe6\x34\x7f\xa5\xc1\xe9\xd0\xa3\x22\x43\xb5\x01\x79\xa1\xa1\xd6\x87\x9a\x51\x45\x51\x2a\x27\x4a\xfd\x14\xa5\x76\x45\xa9\x85\x51\xaa\x20\x4a\xd5\x8b\x52\xe9\x51\xaa\xf4\x33\x2f\xc9\x6a\x90\x95\xd1\xf4\x1a\x95\xe6\x87\x3c\xdc\x37\xa3\xcc\x53\x74\x92\x9e\xa4\x73\xd1\x76\x29\x87\xdd\xc1\x63\xb5\xea\xc6\x82\xe7\xae\xde\xfb\xfc\x6e\x2d\xeb\x73\xad\xd1\xd5\x7c\x57\x85\xfa\x9b\xb5\xf0\x57\x2b\x55\x52\x4b\x7d\x43\xcc\xcf\x46\x8d\x9f\x2b\x75\xbf\xcf\x57\x5f\x7d\xd4\xb6\xb7\x75\x47\xe6\xa6\x6c\x7c\x8f\x9d\x61\xec\xc2\x55\x64\xb8\xb7\x59\xb9\x68\x67\x74\x62\xa2\x51\xde\xc9\x4e\xec\x34\x74\xb7\xa7\x5c\x74\xc5\xe8\x8a\x03\xf2\xa2\xab\x46\x6b\x9d\xc3\xa3\x95\xde\x32\x5a\x19\x94\x11\xb6\xe8\x68\xb6\xbb\xa8\x01\x79\xb8\x90\x38\x20\xcf\x88\xba\x71\xaf\x19\xd0\x6f\xc0\xb8\x7f\x38\xa5\x05\x4f\x13\x46\x4a\x52\x64\x92\x27\x92\x65\xaa\x8a\x32\x2f\xc0\xbc\x99\x9b\x4c\x4d\x65\x96\xc6\xf7\xbe\x1f\x2f\x5e\x7d\x47\x13\xf5\xd3\xbc\xe9\xab\xb6\xf8\x7e\x5c\xba\xd8\xf7\x86\xba\xf9\xa9\x27\xba\xfa\x9e\xf7\x2d\x55\x85\x1b\x96\xab\xf9\x3b\x3e\xb2\xcd\xf0\xad\xb9\x67\x4d\xe5\x98\x6d\xea\xd2\xf8\x41\xbe\x56\x85\x57\xfd\x7f\xfa\x8c\xfb\x02\xf7\x03\xce\x16\xb6\xc9\xd6\xbe\xd9\xdf\xdb\x54\x8f\x88\x8f\x73\xba\x5c\x71\x11\x7a\xc5\xc4\xf0\x78\xa6\x65\x7c\x7c\x74\xb4\xe0\x93\x21\xce\x08\xa7\xd7\x99\xe3\x5c\xe8\x5c\xee\x3c\xe8\x3c\xee\x74\x86\xea\xe0\xff\x61\xed\x3d\xe0\xa3\xaa\xb2\x07\xe0\x7b\x5e\x9f\xf2\xa6\xb7\xcc\xa4\x4c\x92\x49\x62\x4c\x60\x42\x0a\xa1\x49\x9e\x2e\x6a\x00\x85\x80\x14\x47\x4a\x82\x8b\x34\x0b\x11\x10\x41\xc4\x24\x14\xa5\x88\xa0\x22\xac\x74\x15\x15\x2c\x88\x6c\x44\x6c\x10\x11\x0b\x8a\x92\x15\xcb\xba\xae\x82\xca\xba\xbb\x36\x58\x45\x57\x25\xf3\xf2\xdd\x7b\xdf\x7b\x53\x42\x74\xff\xdf\xf7\xfb\xd0\x24\x33\xef\x9d\x7b\x6e\x3b\xf7\xdc\xd3\xee\xb9\x56\x01\xcf\x8d\x3b\x1c\x82\x09\xba\x44\x4e\xba\x93\xfc\x94\xae\x7f\xe6\x21\x4d\xc8\x48\x50\x28\x21\x50\x62\xfa\x61\x03\x5f\xa9\x1d\x60\xff\x27\x9c\x77\xdf\xa6\xb1\xea\xab\xed\xef\xab\x87\x1f\x82\xeb\xe0\xa2\xcf\xa0\xe7\xa5\xcf\xf4\xfa\x88\xfb\x55\x3d\xa6\xfe\xaa\xc6\xd5\x57\xa1\x60\xd8\xde\xfd\x4f\xc3\xe0\xcf\x60\x04\xdc\xb6\xfb\xc9\x01\x0b\x16\x69\xf6\x45\x3c\x37\xfc\x35\x78\x6e\x4c\x58\xb5\x29\x55\xfc\x76\xde\x8c\x78\xe4\xf1\x0a\xb6\xfa\x98\xc0\xf2\x76\x3c\xf2\xae\xb0\x97\xb6\xb1\xab\xde\xe2\x61\xb4\xe1\x25\x01\x24\xda\x88\xba\xf8\x6b\x1e\x53\xdf\x38\x12\xff\x0f\xbc\x0b\x53\x60\x69\x1b\x91\x65\xd4\xff\x40\xbf\x8d\x5f\xdf\xc6\x1c\xfd\x9b\xfa\xdc\x2e\x3c\x98\xf7\xab\xcf\x80\x00\xee\xb3\x4f\x2f\x03\x3a\x86\x84\x36\x54\x2a\xdb\x8c\x52\xca\x79\x2c\xd7\x98\x59\x11\x4b\x3b\x32\x2f\xd5\xc7\x56\xf3\xf0\x3c\x0f\xf3\xf9\xe5\x3c\x63\xe7\x41\x62\xb1\xe0\x03\xc0\xd5\xc7\x80\x45\xa6\xfa\x18\x72\x85\xe5\x94\x86\xe9\x04\x31\x41\x53\xfe\x8c\x3d\x8a\x68\x34\xb9\xfa\xcf\x0e\xae\x47\xc7\x3d\x6c\x79\xc7\x3b\xec\x7a\xbe\x65\x93\x3a\x60\x83\xea\xdd\x94\x68\xc3\xdd\x74\x0c\x7a\x2b\x59\xc0\xf3\x82\xc4\x08\xac\xd9\x42\xab\x02\x5e\x14\xf1\x2c\x8a\x2c\x1e\x07\x0b\xa9\xee\x5c\x09\x96\x48\xd8\xa4\x06\x2c\x65\x7b\x61\x2a\xeb\xea\xf8\xee\x00\xfb\x6f\xee\x1f\xf1\x33\x5b\xe2\xaf\xe2\x8a\x34\x5a\x99\x8a\x69\x65\x1b\xe5\xeb\x57\x2b\xfd\x45\x41\x46\xee\x40\x40\xf0\x12\xfd\xc9\x87\x99\x37\xf2\x41\x80\xf5\xf9\x42\x6c\xc8\x51\x1f\x0b\xb9\x59\x73\x7d\xac\x4c\x54\x44\x66\x8d\x78\x02\xcb\xcf\x22\xcb\x35\x87\xa1\x21\x0c\xe1\x30\x59\xae\x58\x1a\x21\x2a\x6e\x57\x99\x2b\xcd\x1e\x62\xd0\x47\xbe\x46\x39\x98\x7f\x55\x11\x1d\x5d\x23\x9f\xa9\xd0\x08\x97\x7f\x05\x91\xe1\x7b\x07\x1c\xdb\x7c\x06\xcb\x9f\xae\xef\x57\x9c\x1a\xa2\x8e\x63\x46\x37\xaa\x2f\xec\xff\x44\x6d\xdb\xc9\xbc\x0e\x63\x61\xde\x96\x5d\xbd\xe7\xdd\xa0\x7e\xa4\x9e\x51\x7f\x54\xdf\x1a\x55\xab\x6e\x53\x83\xb3\x16\xee\x86\xa1\xfa\x98\xf1\x61\x3a\x6f\xb3\x14\xbf\xc8\xb2\x24\xa9\xaa\x85\xb3\x58\x65\x11\xf3\x9c\x3a\x11\x4e\x60\xc1\x69\x5f\xe7\x67\x4a\x4f\xf7\xe0\xf9\xe2\x72\x91\xb1\x8b\x20\x89\xa2\x89\xb2\x22\x3c\x6f\x6d\x32\xec\x96\x61\x9b\x0c\xcd\x32\x34\xca\xd0\x20\x43\x9d\x0c\x64\x3e\x0d\x1b\xbc\xce\x8e\xf0\x84\x96\x18\xea\x7c\x92\xb3\xe3\xd9\xc4\xa3\x8d\xe7\x16\xff\x70\x93\xe2\xc2\x81\x03\xcc\xaf\x07\x98\x55\xf1\xd9\x7c\x4b\xfc\x09\x66\xd4\xaf\x4d\xda\x98\xbf\x84\x7f\xdd\x4a\xed\x4e\x77\x2a\x93\xa8\xbe\x8f\x29\xc7\xa5\xf0\x50\xc6\x43\x98\xc7\xdc\x05\x10\x0f\x7d\x4f\xf3\xb0\x9b\x87\x6d\x3c\x34\xf2\xd0\xc0\x43\x1d\x16\x13\xe8\x0b\xfc\xbc\xcd\x78\xa5\x3d\x74\x18\xcf\x9f\xe2\x61\x4d\x3a\x3c\x46\xd7\xd5\x7d\x90\xee\x5f\xd0\x4c\x4a\x9a\x91\x01\xb7\xfa\xa5\x03\x84\x51\xe2\x36\x86\x3b\xbf\x61\xa7\xe1\x36\x3a\xd0\x25\xca\xf9\x2c\x63\xb2\xd9\x2c\x0c\xeb\x74\x59\x2d\x98\x3b\x60\x59\xa2\x3e\xa6\xb0\xc0\xb2\xc8\x1d\xa6\x2c\x1b\x73\x70\xc5\x05\x61\x8d\x6b\x93\x31\x8a\x4e\xe8\x2a\x95\xf1\x61\x62\x23\x26\x0a\x14\xb5\xca\x78\x04\x38\xac\x6e\xf8\xc3\x0b\xae\xdb\xea\xa7\xcd\xc3\x8b\xf1\xed\x4f\x3d\x30\x2b\x67\xce\xa2\xd5\x2b\xd8\x8b\x37\x75\xe4\xbf\xfd\xb5\x3e\x97\x35\x74\x2e\x2b\x95\x10\xb2\x48\x26\x32\x9f\x16\x93\x19\x6f\xd1\xb2\x59\x04\x06\xef\x26\x3c\x96\xa9\x30\xf3\xad\xc0\x3a\xa6\xbf\xab\x4c\x91\x0b\x22\x9d\x0d\xb2\x43\x70\x23\xe3\x6f\xef\xc3\xd3\xf1\xe8\x67\xf1\x1d\x0c\xfe\xef\xce\xf8\x49\x3c\x27\x03\x99\x83\xf1\x4d\x1d\x5f\x18\x6b\x2d\x8a\xeb\xe2\x51\x8e\x62\x23\x73\x22\x88\x78\x52\x58\xb2\x9c\xb5\xa5\xac\x4f\xb5\x36\x4c\x78\xd1\x1e\x60\xde\xe0\x5b\xce\x86\x36\x69\x65\x05\x06\x97\x0d\xc2\x48\xe5\x54\x00\x05\x1d\xb2\x2d\x68\xcb\x0c\xb1\xe6\x80\xd9\x8e\x65\x3f\x0f\x6b\x73\xad\xc9\x84\x25\x99\xd0\x98\x09\x93\x33\x61\x50\x26\x54\x66\x42\x38\x13\x3c\x99\x70\x26\x13\xda\x33\xe1\x50\x26\x6c\xa7\x00\x73\x32\xa1\x21\x13\x46\x51\x00\x47\x26\x70\x99\x30\xf5\x24\x7d\xdd\x9a\x09\x6b\xe9\xeb\x3a\x5a\x3e\x42\xdf\xe1\xc2\xef\xd1\x57\x4b\x52\xf0\x6a\x48\x35\x8c\x2b\x69\x11\x0d\x1d\x86\xaf\xc6\xb8\xde\x4a\xc1\xa5\x21\xb2\x18\x88\x5e\x30\x10\x0d\x35\x10\x9d\xcd\x84\x93\x06\xae\xe6\x4c\x60\x1a\x69\xfd\x4a\x26\xd4\xd0\xf6\xa3\xcc\x84\xe3\xab\xfe\x77\x48\xac\x9b\x17\x69\xce\xad\xa4\x57\xcb\x4f\x5c\x3b\xce\x14\x33\x01\x5d\x53\x95\xd5\x78\x2e\xf2\x21\x0a\x39\xc4\x62\x50\x01\xd9\xe0\x1f\x08\xd5\x50\xe1\xe4\xc7\x98\x7a\x15\xa9\x6b\x6f\x57\x57\xf7\xc9\x65\xb9\xc7\xce\xc2\xcd\x9e\x02\x41\xc2\xb3\xdd\xf8\x23\xfb\xc4\xa6\x35\x7f\xbe\xa6\x43\x61\xdb\x1e\xbb\x61\xe6\x4b\x1d\xa3\xf8\x96\x8e\x68\xff\x3b\xb2\xcf\x7b\xc8\xcb\xfe\x85\xd2\xb7\xc1\x27\x64\xac\x7d\x47\x91\xd9\x2c\x8b\x1c\xc7\xcb\xbc\xdd\x66\x01\x81\x95\x10\xe6\xaa\x76\x68\xb3\xc3\x6e\x3b\x6c\xb3\x43\xb3\x1d\x1a\xed\xd0\x60\x87\x3a\x3b\xe0\xe7\x29\xcc\x80\x3a\xa3\xba\x72\x01\xa3\xa1\x85\x55\x84\x0f\xf4\x8b\xdb\x78\xfe\xb1\x4f\x99\x5f\xad\x4f\x70\xbb\x27\x3d\xda\x71\x25\x26\x9b\xda\x43\x57\xb2\x9b\x70\x3b\x18\x34\x09\xf3\xdf\x0f\x31\xff\xb5\xa1\x20\x2a\x53\x82\x5e\xc9\x8e\x24\x14\xca\xb4\x60\xd9\xc2\xc2\x71\x01\x2c\x5b\xb8\x9b\xe9\x60\x4f\xf8\xad\xbd\x2e\xb1\xef\xba\x44\xa2\xea\x69\x7c\x15\xf1\x1f\xee\x54\x0f\x7d\xf8\x91\xfa\xea\x23\x30\x0b\x86\x7c\x08\x03\x1e\x7d\x45\xfd\xe5\xf4\xf7\xea\xcf\x60\xf9\xf6\x0c\xf0\xcc\xeb\x9f\xa8\xad\x7b\x76\xc3\xe5\x9f\x62\x15\x7f\xe1\xe3\xea\xf3\x9f\x82\x08\xa5\xea\x5f\x31\x47\xfd\xaf\x7a\x18\x7a\x18\x7b\x30\x95\x8f\xcc\xc8\x89\x35\x8b\xb0\x1d\xef\x40\x16\xac\x64\xb8\xdc\x76\xbc\x03\xd9\xed\x78\x07\xb2\xe9\x3b\x90\x1b\xf0\xff\x64\x3c\x52\x77\xa1\xbe\x49\x39\x81\x4a\x3c\x78\x1f\x2a\xe7\x44\x07\xd9\x93\xc3\x58\xc8\x39\x7b\x42\xbd\xfa\x00\x33\xe2\x5b\xe0\xda\xd4\x7d\xea\x52\x58\x0c\x0a\xfb\xd1\x1b\xdf\xc4\x3f\xe6\x5b\x3e\x3d\x02\xce\xf8\x7b\xb4\x0d\x93\xd4\x85\x74\x7c\x02\x58\x3f\xae\x51\x22\x39\xae\x0c\x2c\x9a\xe1\x05\xc5\x17\x14\x7a\x33\xeb\x63\x5e\xce\x96\x57\x1f\x63\x6d\x6e\x0b\x66\x49\x96\xe6\x42\x08\x17\x92\x91\x8a\x52\x13\x49\x57\x16\x84\x55\x61\x9e\xb0\xa0\x6a\x2f\xb5\x94\x15\xfe\xc6\xc0\xa9\xef\xa9\x3f\x16\x2f\x9d\x52\x3d\x60\xc2\xe8\xf5\xaf\x0c\x7c\x4d\xfd\x6c\xfd\x6f\x0c\xa1\xfa\x81\xda\x9c\x7f\x5b\xa3\x7c\xbb\xef\xf1\x37\xcc\xcf\xc0\x1f\xde\xff\xfd\xb1\xe4\xa7\xe9\xb2\xe6\x58\x25\x0a\x56\xab\xdb\xe4\xc6\xec\xcc\x86\x15\x5c\xd9\xc4\xb1\xfe\x80\x95\x71\xe3\x2d\x0a\xcb\x66\x86\x60\x89\x5c\xcd\x01\x68\x0c\x40\x38\xa0\xed\xae\xe5\x35\xdd\x1b\x7c\x74\x4b\x15\x21\x3c\x7d\x90\x89\x02\x0c\xac\x21\x58\x72\x77\x62\x8d\x74\xf0\x01\x66\xfd\x77\xc0\x3e\xfb\x00\xac\xf9\xf9\xd1\xcd\x6a\x7f\x78\x7b\xfd\xc3\xcc\xe0\xf8\xb3\x7c\xcb\xfb\xfb\x37\x7f\x90\x19\x7f\x80\xfd\x66\x41\x4b\xfc\xe7\x55\x84\x17\x4e\xe8\xfc\x86\xfb\x19\x8f\x79\x0f\x74\x97\x92\x63\x45\x59\x99\xf9\x3e\x81\xe7\x7d\x99\x98\x43\xf6\xb4\x3a\xdc\xbe\xda\xc1\xd6\x98\x75\xba\x95\xb5\x5b\x21\x7f\x5f\xe7\x69\xa5\x2f\x7e\x74\x49\xfe\x98\xfc\x29\xf9\xac\x9c\x0f\x56\xce\x9a\xcf\x66\x64\x84\xeb\x63\x33\xb3\x20\x96\x05\x43\xb3\x30\x23\xcd\x02\x13\x9f\x95\xc1\xb1\x58\x3e\x6a\x10\x60\xa4\x00\x83\x04\xbc\xce\xdc\x49\xfb\x9b\x66\xbe\x9f\xa0\x1b\x69\xea\xe9\xfe\x3a\xa1\xe4\x1c\x2d\x91\xcb\x4d\x6c\x23\x95\x3d\x99\x22\xe2\x70\x8c\xe4\x96\xfb\x34\x91\x02\xab\x4f\x98\x37\x64\xf3\xdc\xcf\xea\x51\xf5\xeb\x78\x7c\xe4\x73\xe1\xf6\x3f\x3f\x77\xb8\x66\xd6\x96\x86\x47\x9f\x9c\x8c\x55\x5b\x60\x4e\xab\x15\x2f\xe6\xec\xda\xb0\x73\xcf\xc5\x8b\x0e\x5e\xd8\x32\x77\xea\x65\x25\xc4\xd6\x09\x53\x0a\x9a\x6e\x6e\x5a\x70\xf1\x98\x3e\x85\xbe\x82\x21\xe3\x6e\x19\xfe\xcc\xa1\x7b\x9f\xce\x6d\xbc\xa6\x71\xe6\x85\xa3\xfb\x97\xd8\x73\x4a\xfa\x8d\x9a\x85\xc7\xa5\x27\x5e\x0f\xad\x44\xaf\x81\x32\xe5\x23\xbc\xfd\x30\x22\x89\x99\xe6\x78\x8e\x4c\x17\xb8\x16\x18\x41\x05\x11\x13\x9c\x35\x62\x1b\xb4\x40\x85\x26\x13\x30\xf5\x26\x18\x6e\x82\x32\x1a\x2f\x30\xf5\xb8\x09\x8e\x9a\x60\x37\x8d\x25\xd0\x5e\xe0\xa7\xa7\x4d\xa0\x3d\xd7\x42\x10\x1a\xe9\x2b\x2d\xc6\xe0\x14\x7d\xb5\xd5\x88\x8f\xa8\xa1\x0f\x91\x09\xaa\xf1\x8b\x76\x13\xac\x31\x41\x33\x7d\x57\x67\x82\x28\x7d\xd1\x4e\xb1\xac\xa1\x55\x6b\xcf\x31\xa2\xb0\x09\x1c\x34\xfa\xe2\x04\x0d\x65\xd8\x46\x01\xb4\x38\x86\x1a\xfa\x36\x3d\x94\x61\xc2\x39\x61\x09\xe7\x30\xf4\x1b\x53\x5f\xd4\x27\xdf\x25\x2d\x7f\xfe\xbe\x29\xce\x18\x2f\xd3\xbe\x5f\xcd\xe4\x6e\xe7\xfe\x71\x36\xc4\xfd\x63\x93\x2e\x83\x6e\xc1\x3c\xb0\x18\x8f\xab\x1b\x0d\x56\x4a\x65\x87\xc8\x39\x30\x05\xdb\xf0\xd6\x8e\xc5\x4d\x2c\x61\x78\xa1\xcd\x0b\xbb\xbd\xb0\xcd\x0b\xcd\x5e\x68\xf4\x42\x83\x17\xea\xbc\x40\xc4\xff\x24\x23\xa6\x34\x94\xc2\x1a\xf9\xbc\x08\x65\xbf\x54\x49\xa6\x1f\x04\x8e\xf9\xf8\x49\x55\xbd\xeb\xc0\xa1\xe7\xf6\x1f\xdb\x7f\xb7\xfa\x5f\xcf\x6d\xa7\x1f\x61\x5b\x3a\x56\xbf\xfc\xc6\xd1\xd7\xd9\xc9\x1d\x77\x3f\xfe\xf3\x62\xad\x3d\x26\xbc\x56\x2f\xc7\xed\x91\xd0\x40\xa5\x50\x94\xb0\x70\xc5\x32\x0c\x2f\xb1\x66\x53\xd8\x5c\x67\x66\xca\xcc\x0d\xe6\x35\xe6\x36\xf3\x69\x33\x1f\x35\x83\xc8\xb0\x3c\x68\x22\x08\x6e\xcf\x8d\x46\xcc\x81\xb6\x13\x60\xed\x14\xfc\x78\xab\x62\x6d\xaf\xc5\x5f\x3e\x0c\xb7\x8f\x1a\x05\x4b\x0e\xe3\xbd\x28\xfc\xcb\x2f\xec\x09\xa3\x2e\xf1\x76\x5c\x57\x06\x74\x28\x9d\x81\x0c\x89\xd8\x7f\x3c\xa2\x13\x24\x07\x38\x1d\x58\x5b\x16\xc1\xc2\x8a\xb2\xd9\x64\x92\x39\x4f\x06\x1f\x0a\xae\x0c\x41\xa8\xed\xd6\xa6\xda\xbe\x21\x38\x3f\x04\x19\x21\x30\x87\xe0\x97\x10\x7c\x15\x82\x8f\x42\xf0\x66\x08\xf6\x85\x60\x79\xe8\xfe\xd0\xce\x10\x3b\x2f\x04\xd3\x43\xd0\x2f\x34\x24\x74\x55\x88\x2d\x0e\x41\x30\x04\xd6\x10\x4c\x8b\x87\xe0\x9b\x10\x7c\x12\x82\x23\x21\x78\x29\x04\x8f\x87\x60\x53\x08\x30\xd6\x5b\x43\x70\x6d\x08\xc6\x87\x60\x68\x08\x06\x84\xa0\x24\x04\x99\x21\xb0\x84\xa0\x23\x04\x5f\x87\xe0\xef\x21\x78\x2b\x04\x2f\x1a\xf0\x68\x55\x08\x9a\x42\x70\x7d\x08\xea\x43\x70\x79\x08\xa2\xa1\x9a\x10\x93\x15\x02\x7b\x08\x30\xfe\x53\x14\xff\x51\x8a\xff\xa9\x10\x6c\x0e\xc1\x6a\x02\xbb\x30\xc4\x8c\xa3\xd0\xfd\x43\xd0\x03\x77\x23\x04\x72\x08\xfa\x9c\x0d\xc1\xb7\x21\xf8\x38\x04\x6f\x87\x94\x99\xf0\x42\x08\x9e\x0c\xc1\xc6\x10\xe0\x0a\x16\xd0\x0a\x86\x86\xc6\x85\x98\xbe\xb4\x41\x19\xb4\x41\xbf\xd0\x06\x7d\x42\x1b\xa4\x75\x60\x33\xed\xc0\x42\xda\x81\x09\xb4\x03\x17\x84\x80\x14\xc8\x09\xe1\x65\x17\x6a\x0a\x6d\x0d\x1d\x08\x1d\x0f\x75\x86\x04\x14\x02\x29\xe0\xe0\x4c\xac\x47\x96\x41\x22\xb3\x86\xe7\x89\x84\x93\xc0\x44\x1a\xb9\x53\xff\x5b\xc1\x38\xdd\x05\xe4\x24\x82\x7c\xba\x07\x4f\x87\x27\x00\x25\x09\xea\xc0\xfc\x8d\xd0\x08\xf1\x99\x56\x4c\xd0\x28\x85\x2d\x2c\xb2\x01\x31\x67\xb8\x7d\xfe\xde\x2e\x37\xf9\x53\x3d\x10\xa0\x82\xff\xe7\xc9\x33\x81\x9e\xc1\x48\xe7\x49\x75\xd2\xeb\xf1\x1e\x85\x81\x9a\x9f\x9e\xfd\xb1\x4f\xd8\x14\xca\x03\xe9\x75\xb6\x69\xd4\x47\x73\x36\x75\x4c\xc6\x24\xd5\xb2\x63\xcf\x0d\xc0\xb1\x53\x3b\xee\xfd\xf0\xbe\xfc\xd9\x77\xb3\x7b\x34\x5a\xc6\x3c\x8b\x2f\x21\x32\x34\x48\xca\xab\x92\x49\xe0\x19\x16\x59\x58\x9e\x33\x9b\x2c\x82\x6c\x0d\xc9\x43\x65\x66\xa5\xfc\x82\xfc\xb5\xcc\x72\xb2\x47\xae\x94\x07\xc9\xdc\x8c\x51\xf2\x64\x79\x89\xbc\x56\x6e\x95\x0f\xc9\x27\xe5\x33\xb2\xd4\x5f\x86\x88\x0c\x16\x19\xce\xc8\xf0\xb1\x0c\x87\x64\x78\x5c\x86\xb5\x32\x2c\x90\x61\xb2\x0c\x65\xf4\x2d\xa2\x6f\xdb\xe9\xdb\x6d\xf4\x6d\x23\x7d\xab\xc8\x50\x29\x83\x43\x06\x4e\x86\xbe\x27\x64\x78\x8f\x6a\x58\xdb\xa9\x86\xe5\xc1\xd5\xcd\x91\xd9\x88\x3c\x0a\xd7\xd7\x8a\xeb\xe2\x49\xd5\x6b\x71\x95\x1c\x2e\xc6\x20\xb9\x4c\x66\x6e\x16\x61\x1e\x5e\x14\x9c\x59\x24\xd2\x3e\x4b\xc4\x71\xac\x81\x91\xf8\x14\x20\x0c\xe7\xc6\xdf\x96\x27\xb5\x19\x99\x98\xb2\x28\x75\xf9\xcc\x04\xf9\x26\xa2\x14\x10\xbd\xe0\x4a\x35\xa6\xd6\x1d\x63\x02\xaa\xf3\x18\x2c\x83\x85\xc7\xd4\x6c\xc6\xc2\x4c\x8b\xff\x89\xf9\x3b\xf3\x70\xfc\x43\xa6\x38\x7e\x75\x3c\x8b\x8c\x23\xde\xc5\x29\x8f\x92\x60\xb7\xd2\x29\x00\x30\x0c\x31\x18\x73\x12\x1e\x48\x01\xb1\x12\x1b\x60\x6b\x59\xd6\xca\x82\xc4\xe1\x9d\x60\xae\x19\xae\x36\xc3\x28\x33\x5c\x62\x86\xde\x66\x88\x98\xc1\x67\xc6\x3d\x80\xef\xcd\x00\x27\xcc\xd0\x6e\x86\x43\x66\xd8\x6d\x86\x6d\x66\x58\x6b\x86\x46\x33\x4c\x36\x83\x62\x86\x4a\x0a\xea\x31\x03\x32\xc3\xf4\x33\x66\x38\x69\x80\xb6\x9a\x61\xbb\x19\xd6\x98\xa1\xd9\x0c\x73\xcc\xd0\x60\x86\x3a\x33\x0c\x32\x43\x98\x42\x63\xc4\x18\x18\xe3\x7d\xcf\xc0\xbb\x9d\xe2\x9d\x43\xf1\x8e\xa2\xa8\xcb\x28\x6a\x44\x21\x0f\x51\x54\x4b\x28\xc0\x28\x8a\x27\x62\xe0\xe9\xab\x61\xd9\x4e\x5f\x37\x1a\xe5\xb5\x76\x69\xd5\xe0\x36\xb5\x29\x15\xb4\x49\x1a\x12\xed\xbd\x56\xfc\x24\x2d\xfd\x02\x45\x80\x4b\x33\x0d\xb4\x62\xcc\x24\xed\x66\x38\x57\x4b\x48\x5d\x31\xdd\x6d\x3a\xff\x7b\x0d\xd6\xa7\xe8\x0e\xc4\xcb\x48\x4c\xaf\xc9\x4d\x80\x08\x45\xd4\xde\x86\xf7\x1e\x3a\xdd\xac\x69\x7f\xfc\xf3\x77\xe1\x49\x78\xfc\x5d\xa6\x36\xbe\x8f\xa9\x65\xfb\xc6\x27\x31\x5b\xe9\x3a\xb9\x10\xef\xed\x0f\x51\x5b\xcb\x10\xa5\x44\x62\x58\xd1\x24\x72\x0c\x67\xb6\x88\xac\xbe\xbf\x33\x12\x48\xf5\x31\x70\x35\x5b\xa0\xd1\x02\x0d\x16\xa8\xb3\x80\x62\x01\x5d\x89\xd6\x7c\xd7\x34\x0e\x21\x45\xe0\x2c\x86\x2a\xe2\xe7\xf2\x42\x2e\xf7\xd0\xd9\x2d\xec\x55\x1d\xa7\xd8\xaf\x3a\x1e\x61\x97\xaf\xe6\xc6\x6c\x5a\x49\xae\x7a\x02\x74\x8f\x3a\x96\x29\xe6\x8f\x20\x11\x15\x2a\x1e\x1e\x09\x58\xe7\x94\x30\x59\xfe\x18\x03\x4c\x70\x3f\xc6\x50\x28\x29\xf5\x6b\x3b\xa9\x1b\x2b\x9f\x58\xb9\xf0\xde\x03\xeb\xff\xfd\x6f\x75\xac\x78\x53\xcb\x2f\xab\x5a\xce\x8d\x0b\xc0\x9b\x52\x97\xb8\x00\x9e\xc4\x05\xac\x57\xa7\x6f\x81\x8d\x7a\x64\x00\x29\xe3\x50\xc7\xc2\xa3\x46\xfd\x8c\xc8\x01\x91\x69\x78\x5c\x3f\x8f\xdf\x76\x5b\x7f\x55\x85\x33\x1f\x2b\xf0\x8e\x7f\xff\x1b\x63\x1b\xdb\x22\xcc\x6e\xf9\x79\xa5\x86\xcb\xcc\x3c\xc0\x62\x81\x12\x09\x50\xad\xcc\xe4\x39\x1a\x58\xc8\x12\x75\x0a\x0f\x22\xc6\x9a\x21\x15\x4b\xd3\xa5\xc3\xd2\x47\x92\xe0\x13\x24\xb8\xed\x12\x69\x8c\xf4\x88\xc4\xde\x2e\xad\x93\x7e\x92\x58\x41\xf2\xe1\xef\x53\xa4\xbd\xd2\x6b\x92\x30\xac\x50\xea\x8d\x3f\x93\x57\x8f\x48\x1f\x48\x5f\x4a\xf8\xeb\x5c\xfa\xf5\x4b\x0c\x2b\x10\x58\x52\x5a\x7b\xff\x9a\x84\xff\xed\xeb\x6c\xfb\x73\xed\xd0\x5a\xf2\x57\xb9\xec\xa2\x8b\x6b\x39\xc9\x23\x0d\x92\x46\x49\xdb\xa5\x56\x49\xb8\x69\x8e\xb4\x84\x7e\x7a\x4f\x3a\x29\x09\xe4\x15\xf9\x72\x52\x3a\x43\xbe\x8c\xc2\x1f\xcf\x48\xdc\x85\xa3\xa4\xb5\xf8\x31\x4b\x9e\x32\x04\x64\x94\x34\x47\xe2\x6c\x18\x61\xf3\x9f\x47\x5f\x49\x10\x37\x2b\x3d\xfa\x0f\xac\x65\x24\x97\x34\x4b\xda\x23\x1d\x94\xde\x95\x84\xc6\x8b\xa4\x91\xd2\x22\xe9\x1e\xe9\x41\x89\x27\x2f\xae\xc6\xaf\xb8\xbe\x48\x6a\x90\x98\xc9\x80\x99\xfc\xc4\x09\xb3\x88\xbb\x7e\x22\x66\x53\xda\x4f\xea\xe7\x89\x98\x6e\xde\x4e\x77\xdc\x9a\x18\x22\x31\xb0\x6e\xf5\x2d\xf5\x9d\x07\xa1\xf1\x2d\x98\xc5\x3c\xc0\xcc\x8f\xdf\xc1\x9c\x88\x6b\xf3\xd5\xf9\x99\x3a\x9d\x5b\xa1\x7e\x8d\xe7\xd8\xab\x98\xb4\xe0\x8f\xe7\x31\xad\x60\x9d\x40\x9b\x65\x16\x93\x5b\x0e\xb7\x53\x9d\xbe\x68\x11\x9d\x93\x19\xdc\xd3\x8c\x8b\x3f\x89\x78\x54\xac\x04\x88\x20\x83\xa5\x56\x01\x31\xf7\x8d\xb3\xa3\x28\x22\xae\xa1\x53\xf8\x15\x8a\x4e\x48\x55\x2b\x4d\x50\x55\xe1\xf6\x42\xab\xba\xf7\xe8\x47\xdc\xd3\xe0\xcb\x52\x3f\xf3\xd0\x18\x52\xac\x17\xcc\xe6\x86\xa1\x7c\x54\x86\x35\x83\x31\xe1\xe2\x62\x51\xf4\xda\xec\x3d\x59\xd6\xee\x0d\x72\xe5\xbd\xb2\x02\x23\x62\x59\xbe\x30\x72\x8a\xc5\x23\x62\xa2\xe8\x44\x35\x36\xb0\xdb\x66\xda\x18\x0b\x6b\xb3\x39\x9d\x96\xba\x18\x56\xb1\x22\x24\x8c\xac\xad\x1c\xb6\x95\xc3\x9a\x72\x68\x2e\x87\xc6\x72\x68\x28\x87\xba\x72\x28\xa3\x0f\x53\x96\xb4\x11\xf6\x40\x2d\x89\x98\x89\x53\x2f\x80\x16\xbe\x91\xee\x57\x21\xe2\x1e\xf1\xe1\xd6\x80\xe1\x3b\x72\x61\xa5\xc0\x4b\x85\x3f\x5d\xd9\xcb\xb7\x41\x51\xf9\x40\xb8\x00\x44\x1b\xe3\xf5\xf8\x60\xcb\x43\xdb\x3f\xf9\xe9\x87\xc6\x79\xf3\x6f\xb0\xbc\xd8\x13\x96\x1c\x79\xe7\xfc\xfe\xc1\xdc\x41\x97\x4e\x1e\x27\x08\x17\x3f\x7b\xd5\x1f\x37\xc4\x5e\x6d\x5a\x7c\x49\xbd\xe7\x89\x75\x3b\x5a\x05\xae\xff\x92\x59\x23\xaf\x72\x42\xe4\x85\xa7\xd5\x9e\x75\x23\xc4\x46\xc7\xf4\xc6\x5b\xa7\xde\x71\xd5\xe6\x2b\x62\x1c\x53\x36\x79\xc4\x95\x0d\x9a\xcd\x7a\x09\x8d\x47\x38\x82\xfc\x78\x84\x26\x28\xd5\xd9\xbc\xcd\x26\x07\xb0\xc6\x17\x29\xe0\x9d\x8c\xd7\x1b\xaa\x8b\x79\x1d\x32\x32\x7b\x99\xdc\xba\x18\xe3\xdb\x5d\x00\x35\x05\xb0\xa6\x00\x1a\x0b\x20\xa7\x00\x3a\x0b\xe0\x44\x01\xb4\x15\x80\xc6\x02\x67\xcd\xd2\xfa\xaf\x6b\xd4\x7d\x53\xf4\x69\xaa\xc9\xe6\x92\x3e\x69\x7e\x4e\x22\xdc\x8a\x15\xc4\xc3\xef\x62\x53\x3d\xfc\x59\xea\xac\x05\x0f\x55\x30\x12\xb3\x4b\x68\xe5\xb8\xf2\x87\x6f\x79\xfb\xe5\x97\xe6\xdd\xf1\xa7\x95\xcb\xee\x5f\x36\x9f\xc9\x8b\xbf\x19\xfb\x63\x4e\x93\xb9\xf7\x4e\xee\x5b\x35\x76\xe1\x95\xd3\xae\x52\xbf\x51\x3f\xff\xe2\x50\xfb\xe7\xef\xbf\x75\x18\xd3\x0d\x9e\x6b\xf6\x4d\x3c\xd7\x19\x68\x8a\x72\x31\x92\x3d\x6e\x41\x14\xdd\x32\x1b\x0c\x39\xfc\x75\xb1\x1c\x4f\x93\x67\xb5\xe7\xb8\x87\xf3\x78\x1c\x8e\xb0\xd0\x28\x34\x0b\xed\xc2\x09\x01\xb3\x2f\x87\xd0\x40\xbf\xb6\xe1\x07\xa2\x89\x15\x04\xb3\x99\xad\x8b\x99\x7d\x39\xe9\xfe\x84\x1b\x89\xa9\x38\xdd\x36\x0c\x9a\x3b\xcb\x4f\x5d\xd4\x34\xd4\xc8\xd0\xea\xc0\xbd\x6c\x79\x43\x8b\x7d\xaf\xf7\xc4\x13\x5f\x9c\x3a\x7d\xe2\x91\x8f\x33\x9f\xb3\xcd\x9a\xbe\xba\x99\xc9\xfb\x6b\xfb\xb4\xeb\xac\x9b\x9e\x87\x1c\x70\x83\x13\x72\x9e\x58\x6f\xbb\x6a\xc6\x7e\x6d\x2e\xc6\xe0\xf6\x9f\xc2\x73\x41\xe2\x2b\xc6\x28\xbd\xb2\x90\xcd\x66\xf7\x0b\x76\x21\x92\xef\xf2\xda\x10\x16\x81\x24\x29\x5c\x17\x93\x1c\x6c\xb0\x2e\xc6\xfa\xd6\x44\xa0\x31\x02\x39\x11\xe8\x8c\xc0\x89\x08\xb4\x45\xf4\x59\x48\xb1\xe2\x63\xb2\xab\x49\x9f\x84\x02\xbd\xa9\x44\xff\xac\x28\x22\xb3\xe0\xcf\xef\x89\x39\xbe\x27\x19\x26\xc2\x56\xd1\x61\x87\xbb\x16\x6c\x2f\x67\x98\x56\xe1\x09\x56\x8c\xff\x6d\xde\x1d\xf7\xaf\x58\xb1\x7e\xd9\xfc\x5d\xd3\xae\x02\x0f\x04\x98\xde\x57\x5d\x3d\x1f\x5e\x3e\xeb\xde\xd9\xdb\x31\xe7\x7c\x68\xfc\xe2\xd0\x7b\xc7\x3f\x7c\xe3\xb0\xbe\xde\x02\x78\x0e\x5c\x78\x16\x6e\x56\x2e\x71\x3b\x05\x31\x03\x21\xab\x55\x74\xb2\xa1\xa0\x80\xc5\x8e\x0c\x54\x17\x93\x33\xb0\x56\x9c\x91\x61\xb2\xdb\x7d\x75\x31\xbb\xc3\x84\x87\xdb\xe4\x6b\x0f\x41\x5b\x08\xb6\x85\x60\x4d\x08\x9a\x43\xd0\x18\x82\x86\x10\xd4\x85\xa0\x2c\x04\x37\x76\x5d\x5f\x69\xe1\x11\x81\xe8\x39\x2a\xb7\x36\x2d\x4c\xae\x36\x2b\x61\xa7\xb7\x88\xce\x8a\x08\x9e\x0d\x6b\x6f\x5a\x95\xb1\x65\x92\xba\xe3\xf4\xd9\xb3\xff\x86\x4f\x9e\xb7\xaf\xb9\x63\xf1\xfd\x02\xfc\xf7\xf9\x37\x27\xd6\xf6\xe8\x44\x90\x0d\x41\xb0\x42\x76\xfc\xe5\xc0\x8a\xc7\x37\x3f\xa5\xc5\x44\x61\x61\x8a\x19\xc0\xbf\x89\xbc\x68\xb5\x32\x4d\x76\x83\x80\x25\x29\x2f\xe7\xe5\xfc\x3e\xb3\x1d\x13\x0a\x42\xac\x80\x7b\xe0\x16\xec\xe0\xcd\xf1\x47\xfd\xc3\xfd\xf5\xfe\x26\xff\x6a\xff\x56\xbf\x68\xf7\xd7\xe0\x8f\x4f\xf9\x0f\xf8\x8f\xfb\x4f\xf9\xc5\xfe\xf5\xf8\x13\xa3\xbd\x63\xed\x18\xf4\x29\xfa\x9c\xf7\x2b\x63\x26\xd7\xfa\x95\xa2\xd2\xda\xb0\xbf\xcc\xdf\xe0\x67\x15\x3f\xe6\x29\x25\x25\x1a\xdb\x25\x72\x82\xb1\x57\xe3\xc9\x2c\xa7\x96\x93\x0a\x2d\x30\x05\x8b\x09\xf9\x55\x15\x34\x3a\xc2\xef\x25\xb3\x97\x05\x15\x5e\x98\xde\xfa\xa7\x3f\x2d\xba\x7d\x68\x65\x8f\xfc\x8b\x07\x1e\x63\x9f\xed\x18\xcc\x3e\xbb\xf8\x96\xb5\x8b\xac\xcb\xa5\x4b\xc6\x4f\x5a\xac\xd1\x9a\x3a\x96\x3d\xc5\x0d\x45\x61\x2c\x6d\x6f\x55\x26\xe7\xfa\x4d\xa6\x1c\x8e\x3d\xcf\xe9\x64\x73\xd8\xb2\x68\xa6\xdd\x6f\xf6\xd8\x3c\x05\x75\x31\x8f\xc3\x56\x52\x17\xb3\xf9\x90\x88\x39\x01\x07\x02\x07\x16\x0e\x85\x94\x32\x08\x97\xc1\xd1\x32\xd8\x5d\x06\x6b\xe8\x67\x54\x06\x75\xc7\xcb\xa0\xad\x0c\x86\x97\xc1\xb6\x32\x68\x2e\x83\x68\x19\xd8\xcb\xe0\x74\x19\xb4\xd3\x0f\xd2\x44\x5d\x50\x4a\x88\x44\xd4\x51\x3a\x51\x8f\x65\x4a\xa1\xd9\xb4\xe9\xa4\x2e\xbb\xc2\x22\x62\x40\x09\x3b\xab\xf2\x53\x97\x5a\x45\x65\xef\xea\x0a\xc1\xeb\x74\xb0\x95\xba\x29\x85\x06\x86\x30\x91\xa7\xdf\xcd\x7e\xc6\xb5\x60\x32\xc8\x4c\xc5\x9e\x9b\x5f\x7f\xe1\xf0\xdb\xb3\x77\xf6\x64\x24\xee\x71\xe1\xcf\xb5\x8b\xaf\x58\x71\xdb\xdc\xd5\xa3\x97\xd4\xaa\x63\x57\x36\x07\x87\x8e\x80\xfe\xbb\xa6\x4d\x07\x09\x42\xc4\x00\x3a\x7d\x52\xf6\x5a\xb1\xf7\x63\x1d\xaf\xaa\x7d\xd8\xd7\x96\x1c\xb8\xe6\x8d\x13\x9f\x1e\x9c\xfc\x02\xa5\x81\xbb\xf0\x2c\x7f\x87\xd7\x66\x00\x35\x28\xfd\xbd\x4e\xa7\x4b\x12\x5d\x62\x46\xd0\x8d\x1f\xbb\x44\x2f\x2b\xe3\x15\xe9\x68\x0f\x42\x5b\x10\x76\x07\xe1\x34\xfd\xdd\x19\x84\x13\x41\x48\x3c\xdc\x16\x84\xc6\x20\x24\x04\xc6\x59\x06\xb7\xc4\xf2\x5e\x4d\xba\xe5\x51\x0b\x7c\xc3\x53\xab\x77\x8b\x7a\x04\x88\x79\xec\x82\x7e\x0f\x2d\xdc\xfd\xe8\x33\xe7\x37\x8c\x6e\xba\xbf\xb5\x55\x04\xb6\x65\xc6\x1f\x9f\x7a\x27\x1e\x65\x76\xcd\x9a\x59\xb9\xfb\xbe\xf8\x22\xfe\x88\x7a\xdb\x05\x8b\xcc\x78\x7e\x97\xe3\x46\x5f\x40\xe5\x2a\x11\xdd\xa0\xd4\xb2\xa2\xa8\x05\x72\xd8\x39\x2f\xa0\x2b\xf0\xee\xab\x59\x54\x8e\x9b\xa0\x8d\xda\x74\xb6\x52\x6b\x4c\xa3\x61\xa3\x39\x9d\xf2\x4a\x33\xb9\x0c\xa7\xaf\x26\x9c\x23\xe2\xea\x2c\x3f\x25\x88\x95\x86\xc7\xe0\x16\x2f\x6f\x6d\x6d\xe5\xc3\x4f\x3c\xf1\xeb\x09\xae\xdf\xd9\xd7\x10\xd3\xf9\x0e\x96\xdb\xb4\x36\x39\xd0\x7f\x95\x27\xcc\x24\x5b\x00\xde\x64\x5d\x76\xbb\x88\xf7\x59\x31\xa4\x35\xec\xa8\x0b\x0e\xb8\x60\xb5\x0b\x90\x0b\x66\x9e\x72\x41\x3b\xfd\x52\xe3\x82\x4e\x17\x3c\xe5\x82\xad\xf4\xeb\x4c\xc3\x7f\x53\x46\x5d\x38\xc7\x5d\xb0\xdb\x05\xdb\xa8\x37\x7e\x38\x05\x8e\xd2\xf2\x17\xe0\x32\xa7\xe8\xeb\xa3\x14\x02\xbf\x6e\x76\x41\xa3\x0b\x72\x5c\x60\xa7\x18\xb5\x57\x07\x28\x6a\xad\x30\x7e\x78\x82\xd6\xda\x96\x02\x9c\x2e\xe7\x77\x23\xdb\x77\xd5\xdf\x12\xa6\x6f\xdd\x0d\x63\xac\x58\x32\x38\x4e\x12\xbf\x55\x54\xe5\xa7\x46\x9e\xe5\xad\xf3\xe6\x5d\x5e\x3e\xf0\xe2\x3e\xda\x58\x5d\x75\xff\x0a\xd3\x4a\xa1\x76\x1a\xf7\xb0\x26\x9f\xae\xc0\x32\x3e\xc9\x96\x60\x41\xab\x94\xa9\x58\xca\x36\x9b\xcc\x1c\xb2\x10\x11\x9f\x93\xad\x39\x72\x8d\xcc\x90\x5f\xf5\x72\xa7\xcc\xd9\x65\xed\x63\x93\xcc\xf7\x95\x95\x2b\xc6\xd4\x36\xc8\xcd\xf2\x36\xb9\x4d\x6e\x97\xf9\xe3\x44\xd9\xd5\xbe\x73\x48\x76\x60\x25\x55\xd1\x5f\x9e\x90\x4f\xcb\x26\x91\x01\xd1\xcc\x49\x76\x2c\x9b\x79\x31\x9b\xc3\x3b\x78\x8d\xbf\x2f\x4c\x24\x64\x4a\x85\x3f\x8d\xe5\x94\x13\xdd\xa4\xef\xb9\x8e\x2a\xb6\x4c\xbd\x67\x49\x6b\x2b\x7c\x7c\x4c\x1d\x0c\xef\xc0\x77\xd7\xab\x4d\xfc\x91\x8e\x49\x8c\xac\x46\xe3\xeb\xb5\x3e\xc0\x40\x3a\xef\x73\x95\x11\x2c\xb9\x2f\x1f\x4b\xf9\xde\xd3\x3c\x9c\xe0\xe1\xb8\xe1\x19\xdc\xca\x43\x33\xf5\x03\xe6\xf0\x60\xa7\x9e\xc1\xe3\x29\x4e\xc3\x35\x3c\x0c\xe7\xa1\x93\x16\x69\xa7\xcf\x13\xc0\xbf\x35\x35\x5d\xbc\x84\x2b\x5a\xf9\x23\xbf\x56\xd2\x31\x5d\x86\x90\x90\x8f\xf7\xa8\x62\xb8\x4d\xe9\x0c\x14\x23\x94\x6b\xca\x0d\xbb\x24\x53\xd8\x54\x72\x7e\x26\xe6\x79\x99\x8e\x80\x13\x79\xbd\x1c\x91\x7d\xac\xf6\x5c\x13\xf2\x4e\x2e\x81\xa1\x25\x50\x43\x2e\x83\x80\x9c\x12\xb0\x97\xc0\xd7\x25\x70\xbc\x04\x5e\x28\x81\xc7\x4b\x60\x65\x09\x2c\x28\x81\x99\x25\xd0\x9f\xbe\xb5\x94\xc0\x0c\xfc\xfa\x2d\xfa\xfa\x29\xfa\xba\xa9\x04\xc6\x95\xc0\xf0\x12\x08\x95\xc0\xd9\x12\x38\x45\x0b\x27\x00\xd6\x96\x80\x56\x41\x09\x05\xe0\x4a\xe0\x4c\x09\x7c\x6c\xa0\xc6\x65\xaf\x2d\x81\x4a\xfa\x0a\x57\xdc\xf7\x2c\x7d\x87\x4b\x6e\xa3\x25\xe7\x50\xd4\x43\x8d\xa6\x59\x68\x05\x5a\xf5\xdb\x69\xbb\xb4\xb7\x21\x8a\xb4\xbd\x04\x98\x36\x5a\x72\x4d\x09\x34\x90\x16\x61\x75\xb0\xac\x04\xa2\x25\x80\x4a\x34\x0e\xad\x2b\xa9\xe7\xba\xbf\x52\x15\xd9\x6e\xb5\xdd\x73\xf4\x61\xcc\xdd\xcb\x6b\x12\x5c\xbd\x24\x25\x92\xd6\xd5\xd7\xf0\x93\x15\xea\x0c\xae\xb2\xa8\x22\x9b\xf1\x53\x89\xd0\xa7\xff\xa1\x8f\xb5\xf7\x2c\x1a\xd3\x38\xfb\xf6\x3f\x0b\x8f\x01\xc3\x32\x6c\xbf\x75\xd7\x2d\x58\x9d\xc9\xf6\xd9\x7a\xe3\xf6\xfb\xf6\x8c\x69\x9c\xbb\x98\xd9\xb5\x79\xde\xee\x6d\xf1\x55\xec\x15\x2f\x9d\xcf\x97\xf6\x1d\x3e\xfb\xaa\xab\xaf\xbd\xbe\x61\xcf\x5b\x84\x33\x6e\x9e\xf7\xd4\x03\xf1\x55\xc6\xbc\xb3\xdf\xe1\x79\x0f\xa2\x49\xca\x00\x97\xc9\x64\x46\x41\x73\x30\x94\xe9\xf2\x21\x1f\x5f\x17\xf3\x39\x64\xbb\x19\x79\xdb\x33\xa1\x2d\x13\x76\x67\xc2\x69\xfa\xbb\x33\x13\x4e\x50\x7f\xa7\xf6\x70\x1b\x75\x88\xa6\x33\x71\xa3\x8f\x69\x4c\x3c\x37\x85\x79\xa7\xf6\x0d\xf7\xa5\xef\xf9\xe3\x63\x8b\xd6\xb5\xea\x9d\x19\xf8\xd0\xfc\x3d\x0f\x33\xbb\xae\x9d\x5b\xb9\x67\x4b\xb2\x07\x8d\x13\x9e\x3e\x12\x8f\x6a\x32\x21\x97\x85\xdb\x6c\xc6\x52\x61\xad\x52\xea\xa4\xde\x2c\x7f\x40\xb2\x51\x41\xd0\x43\x04\xc1\x6d\x01\x58\x13\x00\xcd\xef\xd2\x10\x80\xba\x00\x94\x05\xe0\x78\x20\xc1\xab\x7f\x3b\x4e\x3e\xb7\xab\xf4\xfd\xeb\x77\xdf\x7e\x0f\xff\xf8\xf9\xab\x97\x96\x6e\xde\xb2\x6a\xe5\x7d\x0f\xae\x64\xb2\xd5\x93\xea\x57\x90\x0b\x4e\xa6\x4c\x3d\xa5\x7e\x76\xe2\xad\xa3\x7f\xff\xe0\xc3\x76\x5d\x77\x50\xc7\xe2\xb6\x5d\x4e\xe3\x40\xb1\xee\x10\x40\x39\x4e\x49\x32\x21\x53\x61\x81\x93\xf3\x32\x9a\xee\x60\xb5\x4b\x21\x26\x8f\xea\x0e\x85\x50\x53\x08\x6b\x0a\xa1\xb1\x10\x72\x0a\xa1\xb3\x10\x4e\x14\x42\x5b\xe1\xff\xd2\x1d\xf4\x06\xe7\xe6\x15\xe5\xfb\x12\x83\xe9\x4d\x51\x1d\x8c\xa8\x32\xa2\x3b\xfc\x3a\x86\xe7\x5a\x85\x5d\xc0\xf1\x5c\xd9\x96\x96\x37\x5e\x7b\xe9\x96\xa5\xd7\xce\xaf\x59\x76\xff\xed\x0b\x88\xf2\xf0\xa2\xf4\xa0\x1a\xe3\x85\x47\x7b\x73\xbd\xa6\xb8\x27\x4f\x50\xcf\xa8\x9f\x7c\x7e\xf0\xaa\x03\xf7\xbf\xff\xe6\xab\x09\x99\xe8\x34\x1e\x6b\x22\x7f\xdf\xae\x8c\xf2\x4b\x4e\xa7\x23\x8b\x75\xb0\x91\x7c\x47\xc8\xea\x90\xdc\x3c\xe2\xb1\xe4\xcd\x3b\x50\x98\xe8\x83\x4a\x04\xc2\x11\x38\x1a\x81\xdd\x11\x58\x43\x3f\xa3\x08\x96\x81\xa8\x24\x3e\x3c\x02\xdb\x22\xd0\x1c\x81\x68\x04\xec\x11\x38\x1d\x81\x76\xfa\xa1\x7b\x19\xe8\x77\xe4\x75\x3e\x21\xac\xeb\xb2\x4e\xbe\x93\x84\xe0\xb9\x53\xcf\x66\x9d\x7c\xa7\x0d\x0b\xeb\xdb\x7a\x63\x09\xe7\x49\xb1\x95\x63\x7a\x6f\x79\x77\xc5\xfa\xe5\xf3\xe6\xdf\x7e\xff\x0a\x0f\xf8\xc0\xc7\xf4\x1e\x7b\x4d\xf6\xbd\x7c\xff\x6f\xce\xf6\x86\x67\xb7\x5f\x3b\x8e\x19\x78\xec\xc8\x91\xe3\x5f\x1c\xfa\x9b\xbe\x26\x98\x65\xb8\xcf\x6e\x72\xc2\x52\x70\x63\x79\xc6\xea\xf1\xda\x05\xb3\x83\xb3\x6b\x1b\x41\x45\xaa\x87\xa2\x82\x0c\xbf\x4f\x1b\x7d\x4d\xde\xf4\x3a\xef\x12\x1e\x93\xb8\x92\xc6\x29\x91\x82\xc8\x80\xc6\xb9\xec\xc0\x59\x2b\xf6\x15\xac\x9c\x62\x7e\xd8\xfc\x72\x6b\xfc\x08\x5d\x77\x7d\xb1\x5e\xb3\x17\xcb\x9a\xe7\xa3\xc9\xca\x00\x51\xc8\xf3\x66\x86\x64\x84\x42\x5e\x81\x2b\x29\x95\xf3\xd8\x40\x20\x07\xf3\xdc\x80\x83\x35\x63\x21\x80\xf5\x39\x4a\x01\x95\xc2\xe9\x52\x38\x51\x0a\x6d\xa5\xd0\x50\x0a\xcd\xa5\x50\x53\x0a\xf8\x79\x62\xf0\xf4\xf3\x05\x15\xbf\x13\x1e\x5d\x64\xb8\xdc\x0a\xa3\xd0\x53\x8b\x1f\x4e\x77\xb9\xb1\xec\xde\x7f\xb6\xbf\xf9\x71\xee\x56\xff\x9a\xe6\xe5\x4d\x57\x5e\xdd\xb2\x71\xf1\x90\x63\x6f\xfe\xf9\x58\xe6\x83\xf6\xc5\x37\xdc\x32\xa7\x6c\xe2\xfa\xd5\xb7\x0d\x3e\x0f\x4a\xee\x7f\x64\xe9\xaa\x9c\xb1\x23\x46\x8d\x52\xea\x82\x79\xe7\x5d\x7e\x43\xdd\xda\x8d\xb7\xad\xf4\xd4\x5e\x3e\x64\x68\xcf\x01\xe7\x17\x44\x2e\x18\x32\x89\xf4\x31\xa7\xf3\x34\x83\x57\x2e\xf2\xa0\x8b\x95\x88\xec\xf1\x58\xec\x76\x13\xc7\xf9\xbc\x36\x5e\xc2\xbc\xc5\x62\x37\x81\x95\x35\x29\x92\x9d\x71\x91\xb5\xd0\xec\x33\xa2\xad\x82\x6f\x13\xbb\xba\x11\x71\xae\x49\x09\x34\x20\x18\xf7\xa1\x8a\xc8\xf6\xd5\x15\xde\x0a\x6f\xbe\x66\x16\x60\xce\x8f\x4d\xf8\xeb\xc2\x25\x55\xf3\xde\x78\xa3\xa2\x26\x32\x48\x0a\xfc\xc8\xbc\xbb\xf8\xfb\xef\x17\xc7\x47\x0f\xab\xb1\x69\xf2\xc2\x52\x3c\xd6\x5f\x73\xfd\x30\x8f\xab\x57\xfa\xbb\x24\xc9\x02\x19\x96\x8c\xcc\x90\x8b\xa7\x2c\xce\x27\x7b\x4d\xc8\xfe\xff\x91\xc5\xa1\x8a\x74\x31\xd5\xe9\xd1\x63\x63\x34\x2d\x92\x29\xd2\x63\x43\x9d\xd0\xef\x5c\x0e\xc7\xf5\x8b\x8f\xa4\x3c\x8e\x99\xdd\xf1\x64\x92\xc7\x31\x7f\xc1\x6d\x16\x31\x5f\xfe\x05\xb7\xd9\x0c\xe3\x95\x9f\x01\x09\x26\x33\xcb\x30\x82\x99\xb5\x58\x4d\x8c\x5d\x00\xef\x46\x2b\x2c\xb1\x42\x83\x15\x46\x59\x61\x90\x15\xc2\x56\xf0\x58\x81\xb3\xc2\x09\x2b\xbc\x67\x85\x43\x56\xd8\x66\x85\xb5\xe9\x30\x1a\xc0\x54\xed\xb5\xf6\x2e\xf5\xc5\xc7\xf4\xb9\x86\x77\x1c\x7d\x1e\x4a\x7f\xbe\x92\x3e\x1f\x4a\x9f\x5b\xac\x50\x8d\x5f\xbc\x95\xfe\xa2\xe6\xff\xd6\x90\x04\xcc\xb9\x00\x4c\x9d\x15\xa2\x56\x70\x58\x01\x59\x75\x17\x66\xfd\xef\x6c\xaf\xbf\x1d\x99\xd2\x7d\x60\x4a\x45\x4d\x97\x13\x16\xb9\x9a\xa3\xa6\x06\xdc\x15\xcc\x35\xef\xab\x37\xb7\x7d\x27\xf7\xc9\x2f\xfa\xe9\x00\x9e\x1a\xe5\xbc\x57\x6f\x9a\xcb\x1c\x44\xd0\x19\xc7\xe2\xd9\x11\x72\x5b\x15\xec\x52\x3a\x01\x39\x45\xc1\x6a\xb7\xb1\x6e\x93\x95\x75\xb2\x1e\x49\xf4\x60\xdd\x5a\x92\xc0\x22\x79\x59\x9b\x9b\x95\xec\x60\x75\xb2\xa2\x77\xae\x0f\xa6\xf8\x60\x94\x0f\x2e\xf1\x41\x6f\x1f\x44\x30\xd3\xf1\x01\xe7\x83\x33\x3e\xf8\xd2\x07\x87\x7c\xb0\xc7\x07\xdb\x7d\xb0\xce\x07\xb7\x1b\x90\x83\x28\xa4\xc7\x07\x82\x0f\xa6\xff\xe4\x83\xcf\x7d\xf0\x9e\x0f\x5e\xf3\xc1\x5e\x0a\xb7\xc4\x07\x73\x28\x68\x2a\x46\xc1\xc0\xb8\x97\xa2\x5b\x4b\xd1\x4d\xf7\xc1\x18\x03\x1d\x06\x38\xe9\x83\x0f\x68\x95\x18\xe6\x11\x1f\x2c\xf7\xc1\x2c\x1f\x40\x03\xad\x33\x42\x1b\xd5\xe7\x0c\xad\xea\x10\xc5\xd1\x4c\xeb\x19\xea\x83\x32\xfa\x1a\xb7\xe7\x2c\x7d\xb5\x8d\xa0\xc7\x5a\xee\x02\x1f\x4c\xa6\xd8\x2b\x7d\x10\xf2\xc1\x69\x5a\xc1\x5b\x3e\x68\xa5\xd5\x2f\xa1\x6f\x6b\x7c\xc0\x38\x7c\x80\x7c\x94\xbd\xd7\x77\xab\x11\x9c\xeb\x71\x9e\xf0\x9b\x0e\x83\x74\x7f\x41\x72\x42\xfd\x15\xf8\x7f\x2c\x70\x13\x8f\xc1\x04\xe2\x1e\xa2\x81\xc5\x89\x98\xa3\x7c\x36\xe9\x8c\xab\x76\x57\xb8\xc9\x2f\x6e\xdd\x5f\x5e\x8a\x98\x0a\x9f\x6b\x57\xff\xb2\xe7\x59\x31\xe2\xfc\xfc\xe5\x97\x7a\xe6\xbc\xbd\x9b\x89\xef\xec\xb1\x33\x5e\x86\x27\x3e\x37\xb0\x6b\x08\x3b\x2e\x9e\xb1\x7f\x25\x1b\xa4\xfc\x83\x24\x0d\xfb\x0a\xcf\xbf\x05\x46\x29\xdb\x48\xfc\x9a\x99\x03\x91\x78\xe0\x58\x5e\x34\x59\x78\xd9\xba\x44\x86\xb9\x32\x0c\x92\x89\xd7\x8b\xed\x4d\xdd\x68\x3e\xea\x28\xfb\x49\x86\x93\x32\x7c\x40\x9d\x69\x7b\xa9\xb7\x6c\xae\x7c\xbb\xbc\x4e\x66\x27\xcb\x20\xc8\x3e\xb9\x50\xbe\x44\x1e\x23\xf3\x53\x05\xfa\x97\xbc\x79\x4d\xfe\x40\xfe\x52\x96\xee\x97\x3f\x92\x19\x0c\x34\x86\xa0\x85\x54\x94\xe4\xf5\x4f\x32\x7b\x88\x20\x28\x94\x7b\xe3\x82\x5c\xf5\x14\xf9\x11\x79\x2f\x7d\xce\xcb\xc4\x70\xde\xfb\x82\x8b\x6a\xfb\xca\x90\x27\x03\x10\xc5\x86\x39\x43\x02\x22\xdb\xb1\x5a\xc3\xb6\x12\x7f\xdd\x1a\xac\xe4\xb0\x73\x68\x54\xe4\x28\xc3\xb1\x17\x96\x81\x16\xcd\x73\x05\x6a\xb7\x51\x9f\x9d\x43\xae\x93\x1b\x65\x02\x2d\x60\x3d\x08\x38\x91\x65\x24\xc1\x8e\x18\x6f\x22\x4c\x8f\x78\x5b\xeb\x27\x94\xa4\xcc\x59\xfd\xac\x59\x25\xb3\x26\xa6\x2e\xc7\x73\xe4\xe3\xa4\x0f\xaf\xa2\x1b\x3f\x1e\x9b\xab\x7e\xa2\x7e\x7c\x10\x5a\xd4\xbb\x5f\x07\x1b\x58\x0f\xab\x77\xc3\xed\xf0\xa2\x3a\x88\x29\x65\x6c\xea\x38\x78\x38\x7e\x26\xfe\x2e\x99\x13\x1e\xcb\x25\x1d\x78\x4e\x7c\x24\x23\x86\x5b\xb2\x3b\x5d\x66\x93\x89\xb5\xbb\xb8\x80\x5f\x72\xdb\xdd\x7e\xa7\xc9\x8e\x30\x77\x47\xa1\x7b\x02\xb0\x28\x00\x73\x02\x30\x39\x00\x23\x03\x70\x51\x00\x2a\x03\x10\x09\x80\x2b\x00\x4c\x00\xce\x04\xe0\x64\x00\xde\x0d\xc0\xc1\x00\xb4\x06\x60\x7b\x00\x52\xe1\xc7\xa4\xc0\xfb\x28\xfc\x54\xad\xc0\x07\x29\x05\xd6\xfd\x6e\x81\x54\x78\xd8\x1d\x00\x2c\x98\xae\x0d\xc0\x12\x43\x30\x1d\x15\x80\x41\x54\x36\x0d\x07\xc0\x13\x00\x2e\x00\xa7\x03\x70\x22\x00\xef\x05\xe0\x50\xe0\xff\x04\x5f\x7d\x22\xa0\x5c\xa5\xc3\x27\x80\x13\x90\x09\xb0\x04\xce\x54\x18\xa6\xce\xc0\x85\x02\xd0\x66\x88\xcc\xf8\x61\x34\x00\x0e\xfa\x30\x11\x45\x42\xa6\xae\x3b\x07\xf9\xef\x66\xc2\xa8\x3f\x77\x21\xff\x8f\x7c\x18\x5a\xf8\x87\x1e\x3c\x98\xc2\xa7\xdd\x79\x45\x55\x78\xb7\xaf\x01\xbc\x94\xb1\xde\x80\x97\x31\xd8\x98\x03\x43\xca\x0b\x7b\xee\xb8\xda\xa9\x5e\xd1\x76\x92\xb7\x5d\xc6\x5e\xf2\xed\x7e\xb5\xe1\x0f\x73\x56\xa9\x63\x2d\x77\x08\xff\x2d\xe1\xaa\xe2\x8f\xd9\x8a\x3e\x95\x5f\x65\x9e\x3e\xfb\xda\x93\x3b\xaf\xa0\x6b\x19\xff\x66\x37\x90\xf3\x48\x70\xb5\xd2\xc1\x08\x22\x00\x2b\x48\x9c\xc5\x2c\xb0\x1c\x5b\x17\xe3\xec\x20\x12\xab\x1e\xf2\xbe\x67\x81\x43\x16\x68\xb5\xc0\x76\x0b\xac\xb5\xc0\x12\x0b\xcc\xb1\xc0\x64\xcc\x01\xa8\xb7\xb0\xd2\x02\x61\x0b\x78\x2c\x80\x79\xc2\x19\x0b\x9c\xb0\x00\x86\x6f\xfb\x0d\xf8\x41\x14\x3e\x62\x01\xce\x02\x27\x0d\xb4\xdb\x28\x58\x73\x77\x60\x1e\x0a\x59\x7d\x86\x42\x6b\xed\xd8\x4e\x31\x4e\xa6\x40\x1c\xad\x32\xf1\x2a\xb5\x4a\x0d\x40\xab\x09\xb7\x89\x69\xa7\x8d\xda\x4d\x6b\x5b\x43\xfd\x9d\x75\xb4\xe1\xb8\xd5\xa9\x99\x4e\xfe\xa7\xea\xda\x75\x5e\xcf\x99\xd5\x54\xc7\x69\x6a\x74\xbc\xe1\x36\xf5\x5e\xc1\x4c\x88\xbf\xca\x3a\xe2\x0f\x32\xb3\x97\xb3\x85\x2b\x97\x77\xfc\x4d\xf7\x35\xe6\xa9\x63\x99\x65\xfc\x11\x94\x8f\x65\xb3\x7e\xbe\xec\x6c\x0b\xeb\xcc\x63\x45\x2e\x52\x90\x21\x89\x92\xf8\x63\xcc\x2e\x0d\x97\x98\xa8\x74\x40\x3a\x2a\xb1\x76\x29\x8a\xbf\x9d\xc2\xd3\xc5\x4a\x92\x1d\xd9\x5d\xf8\x35\x42\xb9\x69\xde\x4d\xdd\x08\x7e\xe3\xac\xd4\x43\x1b\xfa\x21\x07\x2c\x86\x55\x16\x16\x55\x0d\x04\xfc\xb7\x77\x7f\xf0\x52\x51\x5d\x3b\x24\x48\x7c\x4c\xf8\x09\x03\x4d\xcb\xa7\xdf\x70\xfd\x8c\xa5\x8b\xef\xa8\x19\x77\xf9\x8c\x2b\x63\xd3\x2f\x1f\x57\xa3\x8e\xdd\xb0\x12\xa6\xdf\x34\x9b\x6f\xe2\x66\xdf\x04\x33\x56\xfd\xa9\xe5\xda\xeb\xd4\x4d\x13\x97\x63\x75\x6e\xd9\x24\x75\xe3\x8c\xeb\x5b\x70\x3f\x9e\x55\x87\xc1\x04\x62\xcf\x81\x0b\x95\x7f\x91\x48\x70\x84\x96\xf0\x30\x87\x86\x70\x8f\xe2\x61\x10\x0f\x95\x3c\x44\xa8\xad\xe6\x3d\x1e\x0e\xf1\xd0\xca\xc3\x76\x1e\x34\x98\xc9\x34\xc0\xdb\xc3\x63\x1d\x0d\xa6\x9d\xe1\xe1\x24\x7d\xdd\x48\x5f\x24\x0a\x6b\x76\x1f\x5c\x66\xad\x51\xac\x3f\x0f\x25\x46\xd4\x38\x73\x3a\xc5\x0e\xd4\xc4\xc3\x4c\x23\x72\x3c\x35\x16\xbd\xcf\xd1\xf4\x58\xf4\x1c\x23\xe0\xfc\x44\x4a\x14\xba\x56\xe0\x14\xb5\x35\x61\xf8\x03\x46\x38\xba\x66\x5c\xc2\x00\x51\xc3\x1e\x25\x9e\x13\x19\x73\x63\x7a\x20\x59\x82\xc2\xce\xa5\x9b\x6e\xe4\x33\x14\xa5\x8a\x1e\x71\x8d\x57\x38\x9f\x7d\x44\x1d\x26\xde\xf6\xf3\x22\x83\x46\xee\x30\x68\xc4\xe2\xf3\x71\x59\xc1\xac\x7c\x07\xa6\x11\x31\x23\x98\x11\xc4\x44\x90\x31\x3c\x83\x89\x66\x1c\xc8\x38\x9a\xc1\xda\x33\xa2\xf8\xdb\xa9\x0c\x4c\x23\x19\x19\xce\xbc\xbc\xfc\x1f\x63\x79\x21\xa7\xe3\xc7\x98\x13\xfd\x1f\x68\xc4\x4d\x44\x77\xfd\x0c\xa9\x53\x3f\x7b\x4d\xfd\x8f\x7e\xaf\x8d\xd0\x88\x80\x9f\x4c\x1c\x37\x7c\x5a\x6c\xcc\xb5\xc3\xc7\x0d\x58\xb2\x78\xe9\x8c\x99\x8d\xd3\x97\x37\x2d\x51\xff\x7a\xfd\x0c\xb8\xe6\xea\x65\x1e\xc6\x73\xc7\x24\x98\x7c\xdd\xb5\x2d\x7f\x5a\xa5\xae\x9b\x33\x87\x6b\xe2\xe6\xdc\xa4\xae\x5f\xb1\xb1\x85\xf4\x63\x3c\x53\xcc\xd5\xb1\x45\x58\x97\x9e\xa9\x98\x24\xb7\x3f\x80\x9c\x4f\xc6\x88\xa7\xbb\xb5\x70\x40\xad\x84\x88\xeb\xdb\x9f\x59\x4b\xff\xda\x3c\xf4\xaf\x52\x6a\xb2\xd6\x22\xc5\xad\x14\x0f\xa8\x75\x5b\x2c\xfc\x93\xb1\x1c\xcb\x70\xcb\x56\x0b\x3b\xd3\xd2\x84\xff\x3c\x65\x39\x6a\x39\x65\xe9\xb4\x88\x16\xc5\x24\xd7\x5a\x50\xb4\x84\x9e\xdb\x70\x1c\x2a\x09\x7e\x52\x52\x52\x72\xa8\xc4\xc8\x53\x40\xbc\x05\xd4\xa1\x5a\x45\x55\x3e\x2d\x78\x16\x4b\x46\x97\x5d\x7c\xf7\xe0\x96\x2b\xff\x30\xe7\xc2\x99\x7f\xaa\x6c\x5a\x94\x33\xaf\xc7\xa2\x59\xfd\x6e\x62\x8a\x4b\x83\x3d\x8a\xa3\xab\x47\x05\x7b\x5a\x73\xc7\xdf\x77\x7e\x21\xea\xec\x44\xfa\x3f\x87\x80\x58\x6a\x17\xf8\x5e\x7d\x0e\xf6\x69\x67\x44\xe1\xa0\xd2\x49\x64\x21\x41\x90\x4c\x48\x50\x44\x61\xd3\x38\xd1\x2e\xb0\x60\x62\xd7\x98\x60\x11\xcd\x2f\xd5\x60\x82\x91\x26\xb8\xc8\xc8\x47\xe5\x32\x01\x63\xe4\xa3\x6a\x37\xc1\x41\x9a\x8f\xea\x41\x13\xdc\x63\xc0\x6b\xf9\xa8\xba\xc0\x4f\x4d\x4d\x60\xd5\x6a\x82\x47\x4c\xb0\x8e\x26\xb0\x9a\x4b\x13\x5e\x8d\x4c\x49\x60\xe5\x33\x81\x60\x82\x9f\x4c\xf0\x2e\xc5\x9e\xb4\xd8\x63\xe8\x39\x14\xbd\x42\x43\x38\xb5\x40\x4a\xbc\x19\x9c\x31\xc1\x49\x8a\x5a\x83\x5c\x9b\x02\xa9\x25\xc6\xd2\x20\x39\x13\xe6\xcb\x14\xb4\xd5\x08\xd6\xa4\x40\xca\x45\x04\x2c\x64\xb8\x09\x4e\x1a\xad\xec\x82\xa4\x32\xa5\xa2\xed\xc6\x73\xdc\x12\x46\x8b\xd7\x3c\x57\x0a\xfe\xcd\x5d\xb3\xcb\x26\xfb\xff\x66\x8f\x8d\x92\x63\x60\xf4\x58\x6a\x6a\x92\x8d\x0a\x77\xbe\xdb\x9b\x5f\x05\x66\x9a\x71\x8a\x79\xb2\xc3\xca\xb7\x1c\x3e\xac\xf1\xe8\x3b\x3a\x3f\x63\x7f\xe5\x5b\x50\x0e\x1a\xa7\x94\xf9\xf1\xfa\x73\x4b\x92\xc3\x64\x92\x59\x96\xcb\x92\x39\x39\x37\xec\x0e\xd6\xc5\xfc\x0e\xe4\x6e\x73\xb7\xbb\x59\xfc\x9f\xe2\x64\xcd\xc4\xbb\x52\x17\x13\x25\x14\xa5\x69\x89\x2a\x74\xb5\xbe\xbc\x3c\x25\xa4\xdc\x65\x1c\x6f\xa6\x4d\xd0\xbc\xc6\x22\x6e\x45\x21\xe3\xac\x74\x25\xf3\x0f\x69\x66\x1d\x66\x14\x71\x1e\xbb\xf7\xdf\x7b\xeb\xeb\x47\x8e\xbc\x7e\xeb\xea\xd6\x90\xe6\x3e\x5e\x06\xde\x69\xd7\x59\xd7\xec\xb5\xed\xd8\xe1\x82\x2c\x80\x38\xe4\x38\x37\x6e\xb4\x3f\xb2\x92\x38\x91\x3f\xfb\x6b\xbb\xd6\x87\x7e\x08\x71\x75\xfc\x3a\x54\x80\x56\x28\xa3\xf2\x2c\x9c\xc7\x9d\xe9\x46\xa1\x9c\x1c\xab\x24\x71\x05\x88\x43\x85\x45\xd9\x26\xab\x69\x44\x2c\x44\x8e\x8a\x3e\x45\x62\xa2\x6b\xac\x33\xad\x4d\xd6\xad\xf8\xcb\x51\xeb\x71\x0c\xc6\x5a\x95\x82\xf3\x6b\xad\x4a\x28\x5c\x6b\xb5\xe6\x39\x1c\xfe\xd9\x31\x8f\x43\xe4\xf3\xb8\xbc\x39\xb1\x02\x72\x46\x5e\x77\x48\x56\x18\xd1\xdd\x24\x0f\xd3\x8d\xa9\xf9\x12\xf4\xee\xea\xfe\x02\xd2\x65\x1b\xe4\xe7\x56\x91\x68\x86\xfc\xaa\x0a\x67\x9a\x39\x86\x9c\xf8\x22\xe1\xdf\xb9\xe5\xd5\x5c\x9d\x73\xf7\x9a\xf8\x25\xb1\x31\xcf\x3f\xff\xce\xa1\x7b\xdf\xc8\xdb\xe5\x9d\x79\xe9\xac\x46\x92\x9d\x6a\xfc\xe5\xf0\xc5\xae\x2c\xa8\x5e\xf7\xc0\x86\x9e\xdb\xe6\xaf\x69\x81\xc0\x2b\x87\xe7\x5f\xdf\x57\x19\x3a\x7b\xa1\x7a\xa2\xe5\xb6\x9b\x9f\x2f\xde\x4d\xd6\xea\x8d\xe8\x33\x8e\xe1\x66\xd3\xbc\x49\x17\x29\xb9\x99\x19\x2c\xca\x73\x5a\x6c\xc8\x76\x5e\xb1\xbd\x18\x2c\xac\x37\x67\x77\x2c\xe0\xf2\x8a\x8a\x58\xb0\x3b\x66\xe6\x44\x92\x9c\x8b\x52\xc8\x11\x3c\x5b\x40\x0f\x0b\x52\x23\x35\x95\xd9\x31\x93\xac\xac\x2e\xaa\xf6\x13\xef\x6a\xb5\x5f\xf4\x79\x3d\xa2\x5f\x2c\x22\xce\x1b\xb1\xa8\xba\xb0\x3a\xc5\x69\xbe\x7c\xd8\xe4\x69\x7f\x9c\x75\xe7\xf2\x59\x93\xa6\x35\xd4\x8d\x9c\x3c\xe5\x9a\x59\xcb\x57\x5f\x3f\x7d\xca\x94\x61\x1b\x1e\x99\x3d\xeb\x91\x47\x6f\xbc\x71\x07\xf3\xc4\x8a\x59\x93\xa7\x5e\x33\xb2\x6e\xd2\xf4\x86\x9b\xee\xc0\x9f\xa7\x5f\x33\xac\x6e\xfa\xf4\x29\xb3\xee\xbc\xe9\xa1\x07\xe7\xde\xb4\xfd\x21\x2d\x56\x46\xc5\x73\x37\x17\xd3\x9f\x0f\xdd\xae\x0c\x67\x04\xc9\x6e\xf1\xfa\x7c\x01\x8f\x89\x43\x92\xe4\x94\x4d\xa6\x80\xdf\xed\x72\xf9\x59\xbb\xc3\x3e\x22\x26\x5a\xac\x96\x11\x31\x2e\x4a\x27\x0e\x4f\x59\x71\x8f\x5a\x64\x75\x58\xc3\xd6\x6d\x56\xce\xea\x41\x76\xc7\x53\x0e\x46\x3a\xed\x00\x87\x43\xf2\xba\x58\x12\x3a\x4a\xd3\x5a\x4c\x98\x38\xa1\xa2\xe2\x1d\xac\xcb\x94\x93\xf9\xa2\x73\x06\x09\x0a\xad\xa0\x67\x55\xc9\x9c\xd1\xdc\x64\x78\xde\xc8\xe4\xe8\x47\xf2\xaa\x72\xab\xf1\x0f\x55\x5f\x98\x76\xb8\x50\x6d\x81\x26\xb5\x65\x8f\xba\x18\x16\x32\xf8\xb3\xa2\x8e\x7b\x1d\x66\xc3\xcd\xaf\x33\xaf\x2e\xdc\xd0\xa4\xfe\x05\xa2\x4d\x1b\x16\x32\x2f\xc6\xe7\x33\x77\x68\xf6\xe2\x84\xdc\x80\xf9\xe8\x68\xe5\xfb\x84\x4f\x12\xf1\x88\x04\x7e\x69\x0c\xa4\x21\x3d\x3d\xdf\x89\x14\x26\xb8\x3d\x85\xc9\x84\x8d\xcc\x7d\xd3\x12\x3c\xaa\x31\x9d\xfb\x68\xce\xcb\xed\x29\x0c\x4e\xcb\x8c\xa7\x31\x41\xe6\x34\xc5\xdd\x4e\xe1\x52\xe3\xcd\x53\x39\x65\x9f\xa3\x06\x93\x6c\xa4\x0d\x4b\xf8\x46\x4f\xd0\x87\xa9\x05\x4e\x19\x71\xf0\x07\x8c\x20\x76\xcd\x9d\xaa\xd0\xe0\xf6\x73\x32\xee\xfd\xff\x22\x43\xd4\x44\x69\x46\xb9\x54\xd7\x2b\x9e\x38\x96\x4a\x14\x8f\x3c\xc2\x1c\x64\xcd\x1d\x3f\x9d\xbd\x93\xb5\x74\xfc\xa8\x8d\xff\xec\xce\x51\x1c\xc2\xe3\x5f\x81\x14\xb4\x51\xa9\x8f\xf8\xfd\x1c\xcb\x56\x9a\x7a\xf5\x2a\xc9\xce\xca\xea\xe9\x71\xf6\x2b\x71\x96\x5c\x74\xe1\xfc\x08\x5c\x1b\x81\xf1\x11\xe8\x13\x81\xfb\x06\xc2\xed\x58\x84\x1c\x08\x19\xd5\x60\xae\x86\x5b\xaa\xa1\x7f\x35\x1e\xcc\xb5\x26\xe6\x12\xac\xbf\x3a\x4c\x61\x13\x61\xe7\x76\xc1\x54\x3d\x30\xc2\x05\x51\x30\x77\x44\x2c\x3b\x88\x04\x4c\x94\xb8\xc2\x9a\x72\x92\x38\x81\xb2\x08\x3f\x3d\x1d\x51\xaf\x35\x5e\xef\x45\x82\x51\xf4\xd5\xd9\x22\x21\xb8\x72\x8d\x3b\x62\xd6\x50\x98\x30\xd4\x32\x5e\x7a\xe8\xd8\x9b\x6e\xd6\xed\x09\x45\x34\xf9\x45\x35\xfd\x0d\x95\x24\x14\x99\xc2\x0f\x04\xe6\xb2\x27\xdf\x0f\x3d\x10\xfa\x6c\x61\xcb\x80\x99\x8b\xee\xdd\x34\xe6\xe6\xc9\x8d\xd7\xfc\xf3\xdd\xbf\x7c\x9c\xf7\x80\x67\xd9\xdd\xcb\xee\xbe\x68\xc1\xfa\x83\x8f\x2f\x98\xde\x30\xf3\x18\x7c\xb6\x72\xf7\xf5\x2d\xfd\x67\xb6\xdc\x8c\x45\xae\xa5\x4d\x9e\x75\xc3\x2f\x2d\xbb\xa4\x32\x27\xff\x8a\xb9\x23\xfe\xb8\x2e\x50\xd6\x32\x6e\xed\xce\xa5\x2b\x73\xae\x1a\x79\xe5\xc8\xbe\x97\xf7\x2b\xe8\xb1\xa9\x31\xb6\x36\x3b\x7c\xfb\x98\x95\x1b\x3b\xde\xaa\x9d\x56\x2c\xcc\x18\xd5\x6b\x70\xef\x5c\xe6\x1a\x32\xb6\x3d\xb8\x57\x98\xab\xf8\x05\xd4\xdf\x1e\x51\x1c\x22\xc9\x83\x4f\xa2\x22\x79\x8e\xbf\x3b\x86\x79\x6e\x5a\x32\x19\xda\x49\xcc\xf2\x73\x49\xae\x87\x67\x1f\x8a\x1f\x7b\x98\x7b\x65\x1f\xfe\x47\xb2\x30\x75\x9e\xe6\x5f\xc5\xbc\xdb\x8e\x77\xa0\x6a\xd4\xa4\xd4\x05\xc2\xa5\xbd\x0a\x4b\x0b\x25\x07\x92\x50\x9f\xbe\x05\xc5\xc5\xf9\x87\x63\xd1\xaa\xc3\xb1\xf2\xa8\xbd\xb8\xa9\x98\xb1\x17\xe7\xe0\x3f\xab\x8b\xb7\x16\x77\x16\x0b\x28\x0a\x28\xea\x88\x36\x46\x9b\xa3\x6b\xa2\xa7\xa3\x82\x89\x2d\x8e\x16\x47\x39\xab\xd5\xf3\x46\xcc\xca\x71\x99\x6f\xc4\x38\x77\x9a\xbb\x81\x1e\xfd\xa7\x09\x09\x4b\xd2\x78\xb7\xc6\x00\x52\x0e\x6b\x55\xba\x48\x62\x03\x97\x98\x7e\xca\xdf\x55\x40\xcd\xd2\x7e\x3d\x27\x00\x61\x93\x1a\x4b\xe7\x5f\x7d\x59\x7d\xea\xe5\x57\xd5\x27\x5f\x38\x08\x75\x2f\x1f\x84\x11\x6d\xe3\x77\xa8\x1f\x3f\xb6\x43\xfd\xfb\x8e\x9d\x90\xb7\x73\x27\x14\xee\xe8\x58\x7e\xd7\xc2\x2d\x43\x67\x0f\xdc\x79\xd3\x8b\xed\x6f\xbc\x74\xa6\x61\x56\x78\xce\x65\x4d\x77\x30\xaf\x90\x82\x87\xe1\xf2\x97\x5e\x86\xba\x83\xaf\xa8\x7b\x0e\xee\x84\xdc\xc7\x76\xaa\x7f\x7f\x14\xff\xec\xd8\x01\x91\xc7\x37\x3e\xbe\x29\x7f\xfe\xb4\xcf\x8f\xbc\xf5\xc9\x5f\x72\x2f\x1e\xf4\x00\x19\xfb\x20\xb3\x92\x89\xf3\x7f\xc2\x32\x73\x0f\xcc\x35\x47\xd8\xec\xf6\x52\x36\x57\x2c\x2a\xca\xf4\xb1\xbe\x9e\x51\xf1\xbc\x93\x31\x5b\xc0\xee\xad\xb5\x85\xcd\xb6\x5a\x1b\x66\x3a\xae\x8c\x08\x8a\x9c\x8c\x65\x67\x23\x14\x46\x75\x88\x35\x61\x31\xcf\xe5\xb2\x9c\x8c\xb9\x3e\x6d\x8b\xc2\x9a\x28\x34\x47\xa1\x31\x0a\x0d\x51\xa8\x8b\x82\x12\x35\x6c\xe1\x29\xb1\x60\x15\xfa\x79\xa6\xbe\x84\xbe\x4b\x52\x3c\x9b\x15\x29\x0a\x58\x6a\x6c\x9f\xee\xfb\x4b\x0d\xee\x13\x8a\xca\x7b\x93\xd0\x3e\x4c\xb5\xc0\x5d\x77\xdb\xe6\x8d\x7b\x2e\x19\xf1\x87\x11\xa6\xfb\x1c\x5b\x5b\xee\x5e\x9f\x99\xef\x0e\xf4\xca\x1b\x3c\x82\xe3\x06\xaf\xbd\xaa\x69\xc5\xdc\x51\xcc\xca\x39\x53\xe7\xdc\xca\x70\x03\x46\x0c\xe9\x7f\x99\x79\xc6\xbc\x85\x0b\xd5\x23\xfd\xca\xa5\x69\xf2\x65\x17\xde\x3b\x73\xee\xf0\x0b\x39\x01\xaf\x5c\x3c\x16\x57\xa0\x55\x5c\x98\x7d\x02\x13\x8b\x13\xf5\x55\xc2\xbc\x24\x80\xdd\x6c\x73\x9a\xc1\x29\x71\x6e\x97\x09\x53\xd8\xa9\x71\x56\x3b\x1b\x65\x67\xb2\x4d\x24\x9d\x62\x34\xe1\x7c\x48\x75\xa1\x14\x40\x15\x54\x90\x24\x21\xb9\xc6\x07\x76\xae\xba\x0b\x46\xee\xc0\xbf\x46\xc5\x17\xab\xbb\xa1\xee\x51\xf5\x69\x18\xb1\x0a\xae\xaf\x81\xd9\x39\xea\x9d\xea\xdd\x59\x29\x1f\x8d\xbc\x68\xcc\xf7\x98\xb5\x67\x2a\x32\xe2\x19\x5e\x10\x59\xe6\xc9\x18\x62\xff\x8c\x6a\x8e\x94\x24\x0e\xa6\x16\xd0\x83\xb5\xec\xde\x8e\x5d\xec\x17\xad\xf0\xc4\x3d\xf1\x83\x58\xfe\xd6\x73\x92\x61\xf9\xdb\x81\xd9\x08\x97\xb6\x26\x7a\xa0\xde\x68\xb1\x32\xc4\x81\x7a\x16\x17\x87\x7b\xe4\x96\x96\x56\xf4\xa8\xc8\xcf\x8f\x04\x24\x29\xd2\x03\x71\x7d\xaa\xc3\xe1\x48\x69\x5e\x45\xde\xe1\x58\x41\xf9\xe1\x98\x3d\x92\x13\x61\x8e\x17\x00\x2a\x70\x14\x30\x26\x36\x52\x51\x50\x50\x11\x61\x7f\x6b\x3d\xf8\xc9\x7a\xd0\x16\x84\xb6\x1a\x2a\xd2\x23\xcb\x5c\x86\x3f\x32\xed\x18\xe3\x6f\xac\x0c\x9e\xcd\xa7\xe7\xda\x68\x66\x1e\x37\x4b\xf4\x2b\xbc\xa2\x7a\xff\x1f\x16\x86\x3a\xf2\xf5\x07\x9a\xa0\xe2\xae\xf5\xd3\x46\x7f\xb2\xb5\x7e\xc4\x63\x7b\xeb\x46\xfd\xcf\x55\xf1\x0b\xd4\xa9\xbb\xd9\x9a\xdb\x66\x4e\x59\xe0\x56\x1f\x64\xea\x2e\xae\x55\x8f\x8d\xa6\xf2\xc4\x29\xfe\x09\xee\x56\xc1\xac\xc5\xde\x22\x12\x60\xcd\xdc\x99\x1a\x7b\x4b\x73\x1a\xdd\x7a\x76\x36\xb7\x8a\x7f\x62\x22\xa6\x9f\x5b\xd8\xf1\xcc\x3e\x3d\xef\x5a\x89\xe2\xb5\x22\x97\x80\x84\x8c\x00\xeb\x7d\x2a\xc6\x9a\x14\x93\xfd\xa9\x98\x89\x24\x47\xa1\x12\x53\xfa\xb1\xce\x64\x26\xc9\xd4\x9c\x4d\xcc\xbe\x9d\x73\xe7\xee\x7c\x74\xde\xbc\x47\xaf\x9f\x3a\x74\xe8\xd4\xe9\x83\x87\x4c\xe3\xe6\xdf\xfc\xc8\x8e\x9b\x6e\xda\xf1\xc8\xcd\x97\x4d\x9b\x31\x64\xc8\x8c\xe9\x64\x0d\x93\x58\xf6\x08\xf7\x0a\xcd\x79\x39\x46\x29\x97\xf1\xce\x0e\x02\x63\xb3\x58\x18\x8e\x75\x38\xad\xf2\x93\x31\x2b\x62\xc0\x95\xc8\xa7\xf7\x27\x11\xc4\x53\x44\x8d\x6f\xe6\xb7\xf1\xed\x98\xcb\x92\x0c\x34\x15\xc9\xb4\x7a\xa9\x49\x05\x12\x0e\xab\x64\x72\x3d\x92\x96\x86\xb9\xd5\x48\xb0\x47\xb2\xd3\x30\x3b\xd4\x9b\x60\xe5\xdd\xb0\x42\x9d\x7b\x77\xfc\xca\xbb\xef\xc6\x34\x5c\xcc\x54\x30\x8b\xf9\x55\x58\x96\xbc\x40\xc9\x96\x6d\xb6\x0c\x14\x14\x3d\xc8\x93\x99\x25\x66\xc8\x4e\xa7\xf9\x64\xcc\xf9\x29\x64\xa0\x8c\x7f\xc4\xd0\xf1\x54\xa3\x90\xab\x6f\x1a\x3f\xc0\xbb\x32\x5e\xfe\xd5\x03\xbb\xf0\x02\x8f\x96\xa7\xad\x84\xc9\x69\xb9\x76\xd2\x95\x97\x0e\x19\x74\xa5\xb4\x54\x7e\xa0\xa5\xe9\xbe\x17\x6f\x99\xec\x81\x17\x98\x8a\xa9\x17\x2f\x1e\x32\xa8\xb1\xdf\xc0\xa1\x83\x07\x49\xd7\x2e\x59\x70\xc3\xbd\x2b\xae\x1a\xdf\xe3\x46\x22\xdf\x87\x98\x22\x66\x11\x6e\x57\x01\x5a\xa2\x0c\x0f\x64\x64\x08\x7c\x9e\xec\xca\xc9\x41\xb2\x99\x66\x9c\x20\x81\xc3\xb2\x4d\x3e\x19\xdb\x61\xdb\x67\x7b\xc3\xc6\xd6\xd8\x86\xdb\x18\xd6\x66\x63\xa3\x81\x9a\xc0\xf0\x00\x2b\x07\xb2\x02\x8c\x85\x23\xa9\x6e\x4e\xc6\x32\x3f\x65\xa5\x93\xb1\x02\xa1\x4a\xb8\x98\x24\x11\xfa\x24\x99\x9e\x89\x26\x89\x99\x40\xd3\xb7\xe9\x47\x1c\x8d\xe9\x76\x25\x8e\x2a\x24\xa6\x3e\x4c\x93\x35\x55\x55\xfe\x76\x06\x37\x66\xd1\xc6\xbb\xd4\xcf\xc3\xcb\x5c\xdb\xb7\xbd\x74\x41\xdf\xba\xf1\x43\x2e\x1d\x34\x4a\xb8\x43\xde\xdc\xb4\x68\xed\x98\xab\xc6\xcd\x60\x43\x73\x9a\xbf\x90\x97\xad\x5d\x7e\x7d\xed\x85\x03\x2e\xbe\xe4\x42\xeb\xf5\xf3\x6e\xbe\x7a\xe8\x0d\x1e\xc6\x34\x9d\xea\x34\xb5\xdc\xd3\x70\x9a\xc6\x84\xe7\x2a\x1e\xbc\xc9\xfe\x76\x3c\x38\x89\xb1\x72\xe3\x7d\xb5\xf6\xa3\xa3\xea\x5e\xee\x69\x0f\xe4\x64\xa9\x5f\x51\x1c\x77\xaa\x63\xb9\xeb\xb1\x1e\x9f\x8d\xc6\x2a\xe5\x7e\xb3\xd9\x69\xc9\x66\x18\xb0\x40\x38\xc7\x2f\x04\x85\xba\x58\xd0\xe7\xb1\xd7\xc5\x3c\x3e\x33\xd8\x51\xe8\x44\x18\xda\xc3\xd0\x16\x86\xdd\x61\xd0\x32\x46\x18\xbb\x40\x4d\x45\x22\xca\x3b\xd5\x59\x6f\xc8\x5f\xc9\xd3\x7b\xa9\xcc\x9e\xfc\x76\xde\xf9\xcc\xb5\x37\x37\xdf\xd3\x1a\x39\x3f\x23\xeb\xc2\xb2\x71\xf5\x3c\x3b\xe3\xe5\x3f\x5c\x9f\xa3\x8e\xe5\xbf\x88\x8f\x5c\xb1\x72\xd7\x83\xcc\xec\x8e\xf6\xcb\x2e\x96\x5a\x3c\x13\x27\x1f\x2c\x2e\x54\x49\x0e\xc2\x3a\xf5\x67\xf6\x47\xac\x0f\xd8\x49\x0e\x42\x5e\xb0\x33\x78\x59\x98\xf1\x8a\x10\x45\x40\x9c\xcc\x0a\x78\x29\x57\xd4\xbc\x5d\x8e\xc5\xfa\x34\xfb\x1f\x89\x0b\xc5\xff\x69\x2b\x32\xd7\xcb\xce\x69\xfc\xe8\xc6\x1d\x07\x5f\x7d\x92\xa9\xe0\x43\xbf\x7c\x22\xe4\xff\xf2\x09\xbb\xff\xb9\xc7\x76\x1e\x98\x42\xec\x1d\x3f\xc0\x7e\xd8\xcb\x6c\x70\x0a\xd2\x1f\xfa\x20\x64\x79\x16\xd5\xa3\x99\x78\x54\xd9\x09\x55\x9a\x3e\x79\x33\x96\xdb\xbf\xc0\x9f\x5c\x68\xa8\x52\x62\xc2\x7a\x85\xc3\x26\xcb\x24\x1b\xb9\xc7\x6d\x51\x1c\xc4\x1c\xe3\x70\x30\x36\x46\xbc\x33\x16\x66\xea\x98\x06\xa6\x91\xd9\xcd\xb4\x31\x78\xa9\xd2\x8c\x0a\x51\x12\x03\x1f\x7c\x3b\x99\x50\xcd\x08\x7f\xf7\xe4\x6a\x86\xee\xaa\xca\xfc\x3c\xb1\xba\x82\xe4\x95\xf9\x42\xfd\xae\x6f\x6e\xaf\x82\x7b\x97\x96\xd8\x2e\xbc\xb6\x68\xe2\xc4\xf8\x33\xdc\xd5\xc2\x88\xcb\x99\xbd\x93\xd9\x11\x5a\x5b\xea\xf0\x9a\x5c\x48\xcf\x77\xd7\x28\x61\x93\x24\x89\x02\x87\x48\x62\x46\xc4\x3b\x78\x86\x1c\x12\xe3\x58\xe1\xef\x58\x4c\x87\x93\x29\xab\x92\xe4\x67\xd4\xf2\xc0\x50\x15\x27\x11\xa6\xe8\x14\xab\xaa\xf1\x67\x6f\xdd\xb1\x37\xdf\x5d\xf0\x21\x53\x71\x2d\x73\xdd\x8a\x79\xcb\xe3\x59\xd7\x6a\xf2\x72\x08\xcb\x15\xc7\xb0\x5c\x41\x62\x6f\x2e\x55\xce\x37\x62\x6f\x58\x0f\xc6\xcd\x86\xd9\x3a\x16\x4b\x0e\x2c\x49\x78\x77\x32\x66\xfa\xf4\x94\x11\x82\x13\xa5\x47\x9f\x53\xa5\x85\xee\xf9\x64\x38\x35\xf4\x86\x39\xb6\xfb\xa9\x1d\x4f\xef\x79\x1c\xc6\xdd\x37\x6e\xda\x75\xe3\xc7\x5d\x33\x73\x3c\xe7\x7a\xf1\xad\xc3\xfb\x5f\x3a\xac\xde\xb2\x61\xf1\x1d\xeb\xee\x5e\xb5\x82\xb6\xa9\xcb\xfe\xce\x4a\x56\x27\x07\x32\xa6\x65\x20\xfb\x3b\x59\xfe\xa7\xc6\xd9\xec\x7c\x94\x9f\xc9\x37\x69\x5c\xb1\xdb\xfd\x3d\x9f\xe4\xcd\xaa\x00\x2f\x18\x1f\x98\x77\x76\xc0\x48\x75\xf7\x23\x30\xb2\xe3\x93\xc7\xc8\xa7\x1d\x30\x7c\x55\x16\xcc\x84\x39\x39\xea\xaa\x1a\xf5\xde\xc4\x47\x4c\x2f\x98\x48\x84\x61\x7c\x8b\xa3\x10\x2d\xf8\x17\x72\x14\x89\x71\xe6\x17\x84\x9c\xa2\xc4\xb3\xfb\xe2\x47\x51\x48\x71\x80\xf5\x00\xf1\x6b\x37\x58\x1b\xad\x2c\xcb\x38\x03\xa8\xa6\xaa\x0a\x0f\x8a\x93\xd0\x93\x5e\xfe\xa6\x73\xcb\xa3\x39\xec\xf7\xb8\x7c\xb1\x92\xc1\xd8\xa3\xf6\x99\x98\xd4\x53\xd0\x44\x4b\x81\xb1\x13\x44\x64\x70\x9d\x55\xf8\xff\x5e\x65\x04\xd7\x60\xda\x96\x55\x04\x0b\x2b\x23\x8c\x4d\x6b\x85\x53\x40\x37\xf5\x44\x98\x57\xb8\x11\xa6\x66\x70\xa0\x06\xd4\x88\xd8\xe8\x00\x00\x46\x30\x9a\xa3\xe1\xc0\x63\xba\x58\xdd\xce\x8d\xa1\x7c\x21\x0f\xd5\x2b\x95\x98\xaa\xc2\xb9\xb9\x28\x10\xc8\x20\x41\xec\x91\x7c\x57\xa6\x94\xab\xe4\xe5\x6e\x1a\x97\x67\x67\x93\x39\xc2\xa2\x99\x35\x99\xcc\xcc\xcc\xa3\x99\x4c\x66\x38\x02\x13\xb4\x4c\xa9\x46\x62\x2d\xcd\xe4\xd4\xf7\x1c\xeb\x4f\xaf\xb2\xea\xca\x81\x50\x03\x78\x3f\xa8\xb0\x89\x7a\x36\x2c\x2d\x11\x11\x78\xf3\xab\x16\x97\x8e\x9c\x30\xe2\xd2\x73\x73\x86\xa9\x1d\x1f\x1c\xef\x44\xcc\x8d\xaf\x94\xff\x66\xca\x30\xee\x95\xc3\x87\xc9\x78\xd0\x3c\x56\xc2\x69\x57\x21\x8a\xd0\x39\x89\xc3\x30\x3c\xe8\x81\xbd\x8c\xd3\xc9\x17\x32\xae\x7d\x9d\x9f\xb5\xba\xbc\x9c\x58\x50\x82\x27\x83\xfc\x74\x57\x46\x05\x92\xb4\xd5\xa3\x58\x19\x52\xc6\x79\x99\xd3\x63\x14\x48\x85\x57\x13\xf0\x9d\x40\x0e\x93\xf8\x14\x99\x71\xb9\x70\x01\x3f\xf2\x3b\x93\x35\x18\xf0\xa2\x60\xc0\x9b\x18\x98\xa8\xc3\xd3\x46\x05\x99\x60\xe1\xb9\xf0\xc2\x9e\x04\x3c\xc0\x75\x18\x3e\xa8\xd8\x59\x5a\x80\x25\xc1\xf7\x6e\xad\x04\x2d\x92\x2c\x73\xd6\x28\xc3\x6c\x82\xe5\x68\x19\xe6\x99\x59\x2c\x53\x88\x69\xd0\xdf\xdb\x0f\x17\xfb\xe1\x0a\xff\x6c\x3f\x93\xe7\xbf\xda\xcf\xb0\x5a\x1b\xa9\x22\x8a\xb1\x60\x8a\xd0\xd6\x7c\x00\x21\x71\x07\xe5\xb7\x1e\x34\x53\xe9\xcf\xb8\x59\x27\xcb\x39\x4d\xb2\xec\xe1\x2d\x22\xb2\xd9\x10\xc7\x7a\x7d\x5a\xd2\x03\x9e\x33\x59\xeb\x63\x58\xff\x95\x30\x0f\xc0\xfc\x47\x22\x79\x96\x78\x96\x73\x21\x39\x99\x82\xa5\x26\xa1\x28\xa4\x26\xbf\xd4\x32\xbd\xf7\xed\x5b\xae\xeb\xbc\x4e\x2d\x37\x98\x93\xe4\x06\x4b\x26\x59\x82\x7c\x11\x72\xd9\xc3\xf1\xbf\xbf\xf6\x3a\xb3\x8b\x7b\x2e\x6e\x62\x5e\x88\x5f\xcc\x86\x3b\x72\xd7\x67\xaa\xef\xc3\xa7\x5a\x8a\x30\x3d\xf9\x12\xf7\x5d\x4d\x7c\x11\x1e\x87\x69\xea\x30\x92\x47\x0b\x8f\x43\x21\x5d\x53\xb7\x80\x8a\xfb\x65\x7d\x16\xb2\xfb\x65\x07\x1d\xa6\x02\x63\xce\x69\xae\x28\x3a\xe7\xe7\xe9\x74\x52\x43\xe9\x04\xac\x56\xbe\x90\xb8\xc7\x1f\x6b\x95\x1d\xc8\x9c\x46\x27\x5d\xcb\xa8\x70\x5c\xa3\x13\x20\x65\xac\xe7\x59\xed\x46\x81\x54\x78\x35\x01\xdf\x09\x37\x6b\x75\xc8\x32\x86\xc7\xb4\x78\xaa\xd5\x65\xed\xb6\x8e\x3d\x46\x19\x3c\xf7\xf3\x71\x99\x2c\x05\x13\x0d\x69\x19\x03\x8e\x7d\x9d\x5f\xb5\x3a\x6c\x5a\x31\x6d\xfa\x49\x39\x13\xde\x1c\x9e\xa6\x6d\x2b\xc5\xe5\x04\x29\xbe\x95\xd6\xc4\x71\xb8\x26\x7e\x5f\xe7\xcb\xad\xbc\x84\x98\x14\x1a\xbb\x0b\x4f\x76\xef\x14\x78\xf5\x12\xad\x27\x04\x9e\xbb\x98\x13\x0d\x60\x0c\xdb\xf9\x2e\x86\x9d\x46\xfb\xa1\xc1\x92\x07\x98\x7a\x81\xe7\x31\xb0\x19\x99\xb9\x24\x66\xda\x07\x11\xc3\x57\xd2\x3e\x50\x78\x13\xfc\x8d\x52\x2f\x43\x5b\xc3\x80\x04\x92\xa0\x95\xd0\x9b\x4f\xe8\xce\xa6\xe7\x0e\x93\xb1\xb4\x39\x4a\x29\xf1\xda\xfc\x36\xc1\xed\xf7\xcb\x60\x11\x2c\x59\x99\x3e\x99\xd0\x94\xdb\x8e\x20\x8c\x75\x55\x3f\x63\xf1\xd7\xc7\x2c\x2e\xc6\x55\x1f\x23\x99\xbf\xd3\x5d\x3d\x69\x59\x6b\x0d\xcd\x05\x6f\x77\x15\x24\xbf\x98\x53\xcb\x34\x96\x5f\xa0\xe5\x19\xf3\xd2\x64\x1b\x2e\xdb\x06\x2d\xcb\x98\x96\x71\x6c\x03\xb7\x5e\xcf\x36\xb6\x4e\x9d\x41\x33\x8e\xb1\xb9\x4c\x03\xc9\x36\x46\xf2\x8e\x31\x77\xd4\x92\xa4\x63\x6a\xdf\x0d\xaa\x8b\xe4\x1d\xd3\xe6\x8c\x0f\xd3\xf5\xdd\x4b\x5f\xdf\x0f\x68\xeb\x1b\x6c\x36\x3c\x42\x7e\xab\x3f\x9f\xb7\xa6\x8c\x3d\xcd\x1f\x43\xc7\xbe\x5c\xa7\xbd\xbd\x1a\x8f\x0a\x85\xf0\xf8\x64\xee\xeb\xfc\x6b\x6b\x66\x8e\x84\xd2\xc6\xb4\x6b\x19\x95\x29\xd0\x79\x14\x29\x13\x2a\x08\x65\x1b\x05\x52\xe1\xd5\x04\x7c\x27\xbc\xaf\xf3\x9c\xcc\x4c\x5c\x20\x97\xcb\x0d\x25\x6b\x30\xe0\x69\x1f\xca\xf5\x3e\xbc\x9c\xd2\xa6\xc8\xbe\xce\x1f\x5b\x23\x65\xdd\xb6\x69\x4f\xa2\x0c\xc0\x87\x1a\xad\xb2\xb4\x14\xcb\xe4\xec\xeb\xec\x6c\xcd\xc9\xd2\x8a\x19\x93\x4d\xce\x92\x7c\xc6\xe5\x70\xb3\xb1\xae\x93\xaf\x38\x38\xb3\x20\x31\x08\x99\x25\x56\xb6\x22\xac\xd4\xa0\x8c\xe8\x8d\xe9\x09\xc8\x4c\x50\x6d\x02\xbf\x09\x70\x05\x77\xc1\xd5\xea\xb6\x69\x30\x11\x26\x4e\x57\x1f\x84\x86\x29\xea\x56\x75\x13\x0c\x81\xab\xa1\x61\xaa\xba\x15\xea\xa7\xab\xdb\xd5\x6d\xd3\x61\x92\xba\x99\xe6\x0a\xbc\xb4\xf3\x2d\xfe\x0c\xff\x3c\xe6\x64\x99\x98\x2b\x5e\xac\xe4\x07\xc2\x59\x5e\xaf\x0b\x65\x49\x16\x64\x29\x2c\xc8\xf1\x07\xf3\x48\x26\x1a\xa7\x8d\xe3\x82\xf5\x31\x91\x73\x93\x44\x34\xe7\x84\x56\x26\x34\x19\xca\xa3\x34\xbd\xb7\x48\xcc\xaf\x2e\x74\x92\x44\x34\x7e\x2c\xb8\xf9\xd8\xca\x22\xc0\x5b\x19\x02\x8f\x1f\xb0\x4c\xa3\x27\xf2\xf9\x69\xc7\xbc\xfd\x6f\xec\x22\x79\x68\xfe\xfb\xe8\xfc\xb6\xc3\x4f\xbc\x72\x75\xbc\xff\x2d\xad\x67\x80\xef\xb0\x5f\xc3\xbc\x72\xeb\x9e\xef\xd5\x9f\xb5\x94\x3e\x8d\x77\xff\xa7\x0d\x86\x92\x44\x34\x37\xdc\xf3\xfd\x7e\xf5\xa5\x13\x6b\x3a\x1e\x1f\x07\x3d\xc0\xfd\x8f\xfb\xd8\xd1\x57\xaa\x7f\x25\x63\x4d\xf3\x6d\xd0\xf9\xef\xa3\xd3\xcc\x2a\x8d\x97\x78\x3c\x98\xc4\xbc\xfb\x3a\xff\xd5\xea\x0d\x70\xf6\xb4\xf9\xe9\x5a\x46\x85\x6f\x75\x7e\x45\xca\x78\x0a\x3c\x7e\xa3\x40\x2a\xbc\x9a\x80\xef\x84\x3f\xe9\x74\xec\xf5\xe2\x02\x41\x14\xf4\x24\x6b\x48\xc0\xef\x31\xe0\xf1\xfc\x6f\x31\x78\x15\x69\x15\x03\x81\x7d\x9d\x6a\x6b\xc0\xa7\x15\x4a\xf2\x2a\x7a\x2e\x9f\xb6\x6b\x80\xde\xae\x76\xbd\x5d\x26\x5c\x8d\xe9\x42\x93\x95\x93\x12\xed\x4a\xc9\x69\x44\xf2\xf0\xf4\x56\x32\xdd\x66\x41\x10\x6d\x98\xcb\xf8\x03\xbc\xbb\x3e\x66\x26\x99\x77\xb0\xe6\x27\x48\xac\x40\x4c\xfc\xd4\x26\x5c\x52\xd2\xe5\xf0\xa5\x87\xb8\x5f\xc8\x89\x0d\x2f\x49\x68\x94\x48\xb3\xf3\xd5\x9c\x8f\xd7\xa9\x57\x1f\x38\x00\xf7\x9c\x02\xa6\x6d\xfb\x76\x92\xd3\xe8\xfe\x47\x99\xe3\xcd\xaf\xcf\x54\x3f\xe4\x5b\x3a\x3e\x3d\x72\xfb\x7d\xf1\xb6\x8d\x9a\xec\x7d\x57\xe7\x37\xdc\x6a\xfe\x08\x5e\xe5\xd7\x2b\x17\xe6\xb8\x4a\x03\x45\x42\xd8\x6a\x45\xa8\xa8\x34\xcc\x95\x57\x44\x02\xe0\x0d\x80\x10\x80\x12\x2b\x04\xad\x40\x32\xed\x78\xf8\x80\x35\xc2\x46\x42\x75\xb1\x08\x0a\x7b\x59\x13\x89\x56\x6f\xac\x80\xe1\x15\x40\x13\x8f\x4c\x48\x6c\x91\x7a\xfe\x9c\x7a\xc3\x30\xec\x4f\xaa\x99\xe5\xba\xcc\x1c\x05\x23\x9e\x57\xb7\xfb\x1a\x0a\x35\x0d\x0a\xef\x6d\xa8\xd4\xd4\x04\xec\xe3\x56\xbf\xf8\xd8\xe3\x8d\x4c\xe5\xb6\x8b\xc7\x5f\x3d\x7a\xd2\xf8\x71\x7d\x7b\xf7\xab\xba\xfd\xfa\xb5\x2b\x5b\xbf\xfe\xd7\xfe\xcf\x6e\x1c\x9e\x57\x3d\xb2\x6c\x1f\x14\xad\x7b\xb8\xd7\xf6\xac\xf3\xc6\x0c\x57\xa6\xf4\xeb\xbd\x64\xcc\x05\x93\x7b\x94\x8d\x2a\xbf\x7c\xc2\xb6\x07\x3b\x58\x8e\xfd\xe2\xcb\x07\x96\xad\x9e\x5a\xdb\x2b\xab\xb0\x7f\xdf\xf0\xad\x9a\xdc\x4a\xcf\x12\xf3\x27\xf1\xbc\x0d\xa2\x7b\xeb\x1f\xd0\x8b\x1a\x8f\xe8\xd5\xcb\x59\xc8\x94\xef\xeb\xbc\xaf\xb5\xbc\x8a\x0d\xa6\xd1\x60\xd7\x32\x73\x61\x94\xce\xb7\x48\x99\x5e\x96\x5e\x95\x46\x81\x54\xf8\x63\x06\x3c\xb3\x0c\xfd\x4d\xab\x03\x4b\x0a\x85\x4c\x35\x71\xa0\x57\xf7\xea\xb6\x8e\x97\x12\x65\xb6\xa0\x1f\x53\xda\xd5\x6f\x5f\xe7\x89\xd6\x7e\x97\x74\x5b\x66\x41\xa2\x5d\x33\xd0\xd7\x06\xef\x22\xa5\x58\xa6\x6a\x5f\xe7\x9b\xad\x55\x15\x5a\xb1\x24\xed\xd2\x72\xc2\xec\x44\x5d\x9b\x40\x32\xca\x55\x56\x92\x72\xb8\x89\x6f\x24\x9a\x68\xf0\x3c\x16\x5d\xd4\xf9\x8d\x70\x90\x1b\x86\x8a\x50\x25\xea\x8f\x1e\x53\x26\x66\x65\x67\xf7\x70\x59\xf3\x2a\xfb\x03\xf8\x2a\x2b\xab\x5c\x55\x85\xa2\x24\x15\xba\x0a\x07\x5c\x50\x55\x54\x17\x93\xab\xc0\xc3\x55\x55\x59\xf3\xcc\x91\x48\x1f\x4c\x3e\x0e\xdf\x79\x23\x62\x3e\x9f\x3d\x5c\x93\x05\xf6\xac\x99\x59\x58\xd5\xcb\xca\x0a\x87\x83\x75\xb1\xb0\xc3\x5e\x56\x17\xb3\xfb\xcc\x5c\x5d\xec\x94\x08\xcd\x98\x85\x8a\x66\x1f\xcd\xeb\x98\x72\xb0\x30\xed\x40\x76\xc2\xfe\xdd\xb7\x8b\x7a\x96\x14\xd4\x5d\x7d\x13\xaa\xb4\x97\xd2\x1d\x39\x4d\x1a\x66\x0d\x43\x77\xda\xa1\x6d\x7f\x6f\x72\xc2\xb4\x40\x3b\xa4\x4d\x73\xe1\x16\x68\xa7\x4d\xd9\x37\x98\x75\x77\xea\xc7\x4d\xd5\x03\x53\x86\xbf\x7b\xcf\xa3\x3b\xbf\xfb\xfe\xf4\xcc\xf9\xb7\xdd\x28\xbf\xd8\x13\xee\xfa\xf5\x8f\x73\x4f\xc2\x27\x1d\x75\xaf\x2c\x5d\x75\xd1\xe4\x09\x53\xee\x1f\xcb\xfc\x64\x5f\x73\x47\xd3\xbd\x02\xfc\xd7\xf9\xcc\x7e\xed\x3c\x2a\xdc\x79\xd3\x13\xeb\x76\xed\xe6\xb8\xfe\x77\xcc\xac\x1b\xef\x84\xc8\xca\x95\xf1\x97\x03\x39\x1c\x5b\x75\xcd\x90\xb1\x93\x62\x1b\xc7\x1c\x7a\x7c\xf3\xe3\x9b\x75\xfa\x54\x87\x91\xf3\xcf\x78\x6e\x2e\xd1\x65\x3f\xab\x2e\xfb\x9d\x97\x1d\x94\xc5\x82\xd4\xb9\x0f\x50\x9a\xac\xd5\xe9\xf8\x13\x8d\x5e\x82\x41\x4c\x2f\xa1\x7d\x9d\x27\x5b\x43\xd9\x56\xe7\x39\xf4\x92\x5a\x66\x2e\x34\xea\x74\x4c\xca\x04\x47\x05\xb3\x8c\x02\xa9\xf0\xc7\x0c\x78\x4c\xc7\x3f\xea\xfb\x6f\x28\x84\x0b\x84\xa5\x70\x30\x59\x43\x02\x7e\x41\x02\xff\x0c\xf4\xb3\x21\xf3\x93\x56\xb1\x4c\x36\x97\x9d\xa9\x95\x48\xc8\xfc\x66\xcc\x94\xf6\xd0\x36\xfd\x40\xe4\x2c\xf4\x87\x6d\xba\xcc\xe7\xa4\x32\xdf\xc1\xae\x32\xdf\x1d\x98\x99\x46\x53\xe0\xe7\xd6\xe8\x32\x1f\x86\xe7\x6a\xd2\x65\xbe\x63\x18\x76\x3a\x6d\x3f\x85\x65\x96\x1d\x33\x64\x3e\x0c\x6c\x66\xce\x91\xf9\xf0\x2a\x60\xaa\x68\xfb\x35\xdc\x33\x3e\x4e\xc8\x7c\x4e\x22\xf3\x31\xdd\xc8\x7c\xe4\x6c\x4f\x11\xff\x15\xf5\x55\xcf\x56\x22\x99\x76\x87\x6c\x76\x79\x3d\x16\xc9\x14\xc8\x63\xd9\x8c\xf3\x8a\x5d\xb2\xd7\xcc\x59\xdc\x6e\xbb\x90\x53\x17\x93\xea\x04\x10\x48\x9c\x4c\x58\x34\xd7\x46\x2c\x95\x96\x41\x16\x96\xb1\xb8\x2c\x23\x2d\xac\x89\x15\xb0\x98\x58\x60\x47\xa8\x20\x79\xe1\x0d\xdd\x07\xb4\xa4\x64\x9a\xb7\x3e\xaa\xa5\x9b\xa4\x1e\x1e\x7f\xdf\x72\x7a\xb8\x44\x73\xda\x14\x16\xf1\x55\xd5\x85\x45\x15\x3e\x7f\x81\x1d\x7c\xae\x2c\x70\x30\xa9\x27\x4c\x98\xde\xff\xfa\xf9\xe7\x53\xcb\x27\x5e\xbf\x50\x3d\xf6\xb7\xeb\x97\xfe\xa5\xee\x2a\x28\x87\x63\x8f\xef\xfa\x65\xc0\xaa\x4d\x9b\xef\x5e\x73\xf7\x03\xf7\x79\x80\xf9\xe1\x8c\xda\xff\xa3\x59\x4b\x67\x4d\x1c\x7b\x69\xe4\xa2\x25\x8d\xe3\x37\xa9\x33\xfe\x25\xa8\x67\xd5\x1f\xe0\xc7\xb6\x27\x77\x1d\xd8\xbf\xe7\x29\x3a\x4e\x77\x62\x66\xf0\x3d\xe5\x55\x23\xb8\x24\xaf\x22\x23\x4b\xe8\x02\x22\x7c\xa4\x4c\xce\x48\x99\x33\x7a\xfe\x89\xce\xd9\x48\x9d\x56\x8f\x6b\xb4\xea\xf7\xe3\x71\x0d\x10\x5a\x0d\x84\x84\x74\xb9\xac\x6b\x99\xb9\x30\x55\xa7\x55\x52\xc6\x3f\xd8\x1f\x14\xd2\x64\x45\x0d\xfe\x98\x01\x8f\x69\xf5\xb4\x4e\xab\x81\x00\x2e\x90\x05\x59\x7e\x01\x9d\xd3\xa6\x97\x12\xf0\x5b\xd0\x7f\x75\x78\xda\xa8\xb0\x1c\x2e\xed\x06\x7e\x41\xa2\x3d\x33\xd0\xaf\x06\x6d\x93\x02\x58\x5a\xe4\x42\x19\x42\xaa\x90\xc8\xa2\x0b\xd1\x71\x2e\xc2\xdd\x44\xfd\x89\x16\x34\x44\x39\x9f\xb5\x58\x90\x24\x71\x02\x27\x58\x65\xc9\xb4\x2b\x86\xa4\x3a\x89\x91\x59\x89\x53\x88\x3d\x1c\xd0\xae\xd8\x70\xd8\x0a\x0c\x90\xfb\x65\xde\x99\x50\x92\x96\x8c\x3d\x69\x78\xd3\xfc\x8e\x40\x13\xb3\xe3\xbf\x9f\xee\x88\xbf\xc0\x7e\x11\x7f\x7e\x07\xbb\xff\xd9\x67\xd5\x07\xef\xb9\x47\x6d\x7a\xf6\x59\x2a\x3b\x96\x76\xfe\x8d\x6b\xe5\xc6\x63\x35\x36\x88\xf2\xd0\x42\x65\x98\x2f\x3b\xe4\x76\xa3\x10\x56\x77\x22\xf9\x59\xde\x40\xd8\x1a\xc6\x5c\xd7\xea\x60\x03\x75\x31\x81\xf5\x9d\xa6\x07\x9e\xd6\xd0\x4c\x04\xda\x11\xa8\xdd\xc6\x93\x66\x9a\xa7\xa0\x21\x02\x75\x11\x50\x8c\x73\x52\x5d\x03\x76\xba\x95\x3a\x0d\xbd\x98\x1e\x57\xa3\x22\x67\x95\x43\x97\x38\x45\x4d\xe2\xec\x5d\xa0\x49\x9c\x02\x77\xe5\xaf\xdf\xbd\x32\x77\xf2\xa3\xfb\xae\x80\x7f\x1c\x9e\x3d\xee\xd1\x27\x47\xbc\xe4\x57\xb3\x06\x2d\x7f\x70\x65\xfc\xcf\x01\xf8\xfc\x0f\x77\x6e\x59\xa5\x1d\x65\xbb\x7a\xce\x07\x2b\x4e\x32\x65\xe3\xa6\x1f\x5e\x7a\xba\x65\x7c\xfc\x9d\x2b\xdb\x3f\x59\x34\x9a\xe9\x35\xe2\x28\x9e\xa7\x95\x9d\xdf\xb0\xff\xa1\x74\x73\xa5\xa0\xd1\xda\x37\x9a\x8c\x49\x49\x13\xeb\x25\xdf\x60\xbd\x24\x43\x4e\xa3\xb5\xae\x65\xe6\xc2\x58\x5d\x96\x23\x65\x42\x55\xa1\x6c\xa3\x40\x2a\xfc\x31\x03\x1e\xd3\xda\x29\xad\x8e\xcc\x4c\x0c\x9f\xbb\xaf\xb3\xa3\x35\x37\xd4\x6d\x1d\x0b\x12\x75\xcc\x40\xdf\x1a\x72\x26\x65\xa6\x80\xf5\x8c\x1f\xb0\x9e\xa1\x15\x4b\xee\xd5\x34\x6e\x9c\xb6\x6d\xbc\xbe\x0e\x42\x7a\xdb\x30\xd5\x81\xbf\xb7\x3f\x68\x72\xa5\xca\x99\x2b\xc8\x79\x3e\x2c\xdf\x79\x50\x2e\x1a\xa8\xe4\x64\x72\x6e\xb7\xc7\x6b\xf1\x58\xf2\xf2\xdd\x21\xce\x2e\xc9\x32\xe6\x42\xb2\x4f\x0a\x90\xa3\x87\xc4\xbf\xdf\xf5\xd0\x7e\x8a\xbc\xe9\x4e\xe6\xf7\x70\x26\xce\xee\x41\xea\x71\xbd\x15\xad\x9c\x40\xcf\xe8\xe9\xa7\xf6\x98\x0f\x12\x67\xf5\xf8\x23\x24\xbb\x07\x3d\xa0\xf7\x99\x7e\x6a\x8f\x7d\xdd\x38\xa9\x97\xe8\xd7\x82\x44\xbf\x66\x90\x5b\x1c\xb4\xf1\xa0\x0b\x10\x42\x44\xee\x0e\x65\x68\xbd\x4b\x8e\x87\x66\x23\xda\x94\xb0\x11\xad\x84\x69\x30\x38\x69\x87\xc2\xfa\x74\xba\xdd\x4a\x93\x91\xae\x48\xc8\x3a\x2b\xd1\xbf\xd3\xe5\xbd\x37\x5b\xcb\xbb\xca\x62\x5a\x1d\x3f\x24\x6c\x57\x1c\xb5\x5f\x24\xea\xf0\xb0\x9e\xcc\x6e\xea\xf8\x32\x51\xc7\x06\xac\x01\x26\xeb\xa8\xdc\xd7\x79\xa4\xb5\xb2\x5f\xd7\x3a\xd4\x06\xfe\x8f\x7c\x4b\xa2\x1f\x9b\xd9\x67\x88\xdf\xec\x69\x26\xb8\xaf\xf3\x68\x6b\x30\x28\xea\x5b\xbd\x26\x13\x8c\x26\xf9\x6f\x12\xf8\x37\x33\xe4\xac\x23\x86\xed\x47\x36\xc8\x7e\xfd\x82\xc1\x24\x2c\xcd\xc1\x4e\xf5\x92\x42\x5d\xc7\xbe\x42\xa7\x97\x20\x51\x7f\x6e\x0b\x66\xe9\x06\xa4\xe4\x1e\xcf\xbe\x49\xe9\xeb\x92\x74\x3e\x0b\x78\xc7\x86\xe0\xac\x60\x96\x9c\x66\x37\xd4\xf0\xab\x09\xfc\x9d\x70\x24\xc1\xfb\x79\x92\x06\x35\x6c\x58\xa8\x12\x63\x83\xf1\x1f\x33\xf0\xe3\xb5\xd2\x9e\xba\x57\x84\xcd\x61\x43\xaa\xd1\xe0\x35\xfc\xff\x31\xf0\x33\x1b\x99\x3c\x28\x48\xb6\xbf\x28\x98\xd9\x5d\xfb\x8f\x24\xf0\x6f\x84\xd2\xd4\xf6\x3b\x83\x99\xbf\xdb\x7e\x13\x4a\xb4\x3f\x48\x2a\xc8\x2c\xcc\xcc\xfb\xdd\xf6\x2f\x47\x1f\x24\xe0\x09\x43\x71\x64\xe6\xa5\xb5\x9f\xe6\x8f\xa7\xf8\x8b\x74\xfc\x53\x34\x5a\xa0\xda\xa4\x6f\x5f\xe7\xe3\xad\xbe\x4c\xfe\xdc\xbd\xae\x93\x3f\xe2\x28\x44\x97\xd2\x31\x3d\xcb\x3e\x8f\x86\x22\xb7\x62\x61\x4a\x10\x53\x72\x45\x49\x89\x5d\xd3\x58\x6b\xf4\x39\xd6\xed\x4c\x2e\x01\xdd\x93\x90\x41\xae\xc7\x6b\x3e\x1b\x9d\x8f\x65\x90\x1e\x39\x0e\xa1\xc0\x89\x6c\x36\xaf\x5f\xf0\x97\x94\x06\xbd\x7e\x1a\x68\xe6\xb1\x3b\x72\x1c\x51\x07\xeb\x67\x1d\x0e\x17\x26\x35\x89\x95\xce\xab\xa3\xd1\xbc\x8a\xd3\x24\xd7\x4a\x0e\x36\x8f\xa8\x76\x35\xa5\xb0\xba\x14\x26\xe8\x27\x79\x4b\x0c\xce\xd0\x37\x61\x95\x4a\x70\x09\x1a\x5d\xe7\x22\x32\x48\x7a\x42\x1a\x92\x58\xbd\x4a\x3f\xf0\xf8\x3f\x12\xd3\xa8\xef\x41\x69\xeb\x92\x25\xbf\x9d\x9e\xe6\xf1\xc5\xf7\xde\xbb\xb8\xa3\xb8\x4b\x86\x9a\xa4\x8d\x71\x93\x61\x63\xc4\x7c\xe0\x16\xcc\x07\x52\x6c\x9f\xdf\xb6\xca\x5d\xed\x92\x9a\x7c\x7a\x45\x42\x9e\x5d\x99\x90\x67\x35\xa1\x99\x0d\xa5\xcb\xb3\x5a\x1d\x3f\x24\xec\x98\x1c\x2c\x4f\xb1\xaf\xda\xf7\x75\x7e\xdd\x6a\xf7\x77\x5b\xc7\x97\x89\x3a\x36\x80\x23\xb5\x8e\x2c\x26\x2b\xbf\x9b\x3a\xfe\x93\xe8\xc7\x46\x38\x8c\xe9\xdd\xf7\x8c\x66\x8e\x25\xdb\x95\xd5\x96\xb0\xc8\x26\xf0\x1f\x49\xe0\xdf\x08\x83\x52\x65\x78\x26\x98\x99\x2e\xc3\xef\xc0\xbc\x43\xa5\x7c\xe6\x3c\x9d\xcf\xd4\x51\xde\x41\xcc\x2d\x07\x5b\xbd\x5e\x8b\x25\x9d\xcf\x04\x28\x9f\xd1\x70\x6f\x86\x85\x1a\x9f\xc9\xdf\xa7\x7e\xdf\x9a\x9f\x9f\xca\x93\xba\xd8\x85\x31\x9d\xcf\x4c\x19\x1b\xdb\xbe\xce\x7f\xb6\xda\x3c\xdd\x8e\x4d\x52\x9f\x58\x8e\xbe\x4a\xd1\x59\x32\x09\xc3\xcf\xcc\xeb\xa2\xb3\xd0\x7b\x02\x68\x3d\xe7\xeb\xfc\xe6\x63\x7d\xfd\x85\xc3\xb8\xa2\x82\xbc\x82\x1c\xe4\x4f\x95\xd3\x48\x4e\x1c\x5a\xc7\x10\x9d\xdf\xfc\x55\x1f\xff\xb2\x32\x5c\x49\x15\xaa\x8a\x3a\x33\x53\xe0\x35\xfc\x3f\x18\xf8\xf1\x1c\xff\xa4\xe3\xcf\xc9\xc1\xf8\xf3\x8a\xf2\xce\xef\x06\xff\x97\x09\xfc\x1b\xd0\x2f\x3a\xfe\x68\x94\x6c\x28\xa8\xbc\x4f\x37\xf8\xff\x63\xe0\xc7\xfc\xac\x4a\xe7\x67\x04\x7d\x4e\x51\x4e\xae\x81\x5e\xe7\x05\x14\xff\x91\x04\xfe\x8d\x34\x8f\x33\x99\x5f\x82\x3e\x8a\xa2\xbd\x0c\xf4\xfa\xf8\xa8\xc3\xc8\x3d\x0a\x89\xf1\xf9\x85\x19\xa6\xe9\x8b\xf9\x3d\xf3\x8d\x91\x49\xe0\x15\xc2\x0e\x1d\xaf\xd4\x01\x7d\xb4\xb1\xaf\xae\x26\x78\x89\xcc\x12\xad\x48\xb6\x3c\x69\x13\xa6\x63\x5f\xa2\x8f\xfd\xfd\xfa\xd8\x68\xc6\x7f\xe4\xb2\x72\xe6\x74\x7b\x3c\xfb\x9d\x38\x10\xc3\x0f\xd5\xe0\xd1\xf7\x48\x21\x34\x11\x0c\x32\x85\xa0\x19\x52\x33\x5c\x42\xb2\x0e\xdd\x66\xfe\x1c\xcd\xc1\xeb\x47\x8b\x95\x7c\xbf\x85\x65\x25\x91\xf3\x60\xa5\xd7\x61\x77\xf3\x6e\x20\x27\xf9\xdc\x81\x0c\x94\x01\xcd\x19\x6b\x32\xb6\x65\xb0\x19\x84\x63\x9d\x67\x73\xd6\xda\x33\xc0\xc2\xfa\x99\xfa\x98\xcf\x25\x88\x42\x7d\xcc\x6e\x11\x15\x3f\x6c\xf3\xb7\xfb\x19\xbf\xe8\x17\x65\x13\xc9\x64\xad\x5d\x9b\x40\xaf\xec\xc5\xec\x8a\x06\x96\xd0\x08\xe1\x12\x6a\x46\xa0\x17\x48\x1a\x21\x5f\xfa\x11\x4c\x7a\x95\x02\xc9\xc7\xa4\x85\xf6\x11\x36\x46\x72\xdb\x71\x53\xe2\x70\x60\xc3\x86\x03\x4c\xe7\xf3\xf7\xdf\xff\x7c\x1c\xc8\xed\x0a\x1c\x6c\xf8\x12\xff\xdb\x70\xb6\x93\xed\xf1\xde\x7b\x9a\x7d\xcd\xac\xe7\x18\x0a\x63\x4e\x9c\x9f\x95\xe1\x74\xfa\xbc\x2e\x31\xe8\x62\x73\xa5\x3c\x25\xaf\x2e\xaf\x21\x8f\x55\xf2\x9a\xf3\x98\xd5\x79\x80\xf2\x00\xf3\x5c\xd2\x9b\x80\xdb\x5f\x9b\xe9\xf1\x7a\x46\xc4\x32\xbc\x5e\x7f\x4a\x36\x22\x62\x29\x32\x59\x6b\x59\x72\x7f\x95\x91\x66\x48\xbf\xd2\x0e\x4a\xe8\x45\xa8\xb3\x9c\xda\xc9\x46\xbd\xf5\xdd\xa5\x1d\xd2\xfb\xa2\x85\x67\xa7\xa7\x1f\x5a\xb2\xa4\x15\x4a\xd5\xf7\x44\x60\x63\x34\x09\xd1\x58\xe6\x76\x2d\x09\xd1\x63\xdc\x5e\xc2\x79\xd7\x5e\xb0\xc8\x8c\xf5\xe8\x7d\x78\xa2\x96\x52\xbb\xba\xe6\x0b\x61\x8e\x6a\x54\x40\x1d\x33\x32\x23\x67\xa4\xeb\xd1\x1a\x3c\xd5\xad\x34\xbd\x7b\x0b\x86\xcf\x54\x5c\x9a\x52\x2f\xd3\x13\x9e\x7a\xa1\x1b\x13\xb4\x83\x27\x9c\xe9\x45\xf9\x79\xa9\xc6\x9b\x3b\x3f\xd2\xe4\x3a\xdd\xfd\xc3\xf0\x5c\x9a\x1d\x80\xc2\x53\x5e\xae\xd5\xb1\xf2\x23\xa3\x4d\xce\xae\xd0\xb4\x4d\xc4\xff\x73\x1d\x5d\xe7\x5a\x1f\xb8\xaf\x52\xfa\x20\x32\xa2\xbd\x3b\x78\xba\xce\x35\xfc\x1b\x7e\x4c\xc1\x2f\xb2\xa2\xdc\xc5\x76\x30\x5e\x1d\x0d\xcf\x53\x3e\x4b\xf1\x33\x9b\xad\x74\x15\xe2\xde\xca\x2c\x5b\xa0\xb5\x39\x07\xc3\x2c\xa4\x6b\xfb\x32\x0d\x06\x8f\x8b\x53\xb1\xf8\xdd\xc0\x38\x91\xd3\xa9\xb1\xd7\x09\x1a\x7f\xa5\x77\x75\x50\xbe\xa1\x8d\xc7\x46\x54\xa4\xf3\x0d\xea\xdd\x42\x9c\x90\xb0\x74\x50\xba\x3b\x88\x7f\xcd\x25\xe7\x5b\xc0\xac\xec\xd7\xee\xf6\xb0\x23\x6f\x84\x9e\xcd\x4a\x1c\xe0\xd2\x8e\x61\x69\x07\xbb\xb4\xd3\x5b\x37\xa4\xbe\x56\x52\xde\xad\x49\x39\xeb\x95\x0a\x73\x6d\x7a\xf9\x3e\x1f\xf3\xf0\x56\xca\x11\xaf\xc9\xf4\x88\x57\x28\xa5\xcc\x02\x5a\x06\xa3\x66\x12\x27\xbb\xb4\x53\x5a\x89\x23\x5a\x0d\xc6\x8d\x21\xe7\x9e\xd2\x4a\x1e\xe2\x3c\x37\x86\xfa\x37\x22\xab\x6f\xec\x92\x33\xe8\x60\x2b\xcd\x5c\x45\xc6\xf4\x31\xcc\x8b\x07\xd3\x98\x85\xd2\x6f\x91\x43\x44\x3d\xe0\x33\xfa\x7c\x39\xe6\x8d\x2c\x95\xbf\x2e\xa3\x32\xf0\xe5\xf0\x1a\xd5\xed\x1d\x2c\x23\xcd\x94\xc0\x21\x95\x49\x0c\x20\x07\x82\x09\x55\x55\xd4\xd5\x8c\xcb\x90\x7b\x4a\xde\xa6\xbc\xb1\x87\xce\x1b\xab\x75\xde\x48\xfc\xe7\xe0\xdf\xef\x77\x32\x49\x0d\x90\xe9\xbc\x5f\x1d\xcb\x44\xf9\x63\x98\x6e\x7d\x10\x50\x0e\xe1\x35\xea\xb4\xb9\x6d\x66\x33\xeb\x16\xc5\x80\xdf\xed\x5d\x3b\xce\xee\x8e\xba\x6b\xdc\x4d\xee\x53\x6e\xde\xc4\xba\x25\x3b\xe2\xc8\x71\xe0\xa3\x01\x38\x10\x80\xd5\x01\xa8\xa1\x51\x29\x39\xf4\x94\xeb\xcc\x53\x01\x68\xa7\x8f\x3a\x03\xf0\x54\x00\xb6\x52\x88\x99\xf4\x28\xac\x62\x1c\x91\x3d\x6e\x9c\xc7\x5d\x13\x80\xe1\x46\x79\x5c\xf8\x02\x5c\xe6\x14\x7d\x7d\x94\x42\x24\xf2\xce\x60\xdc\x76\x8a\x51\x7b\x75\x80\xa2\xd6\x0a\x77\xd2\x03\xb9\xed\xf4\xd0\x6d\x02\xb8\xdb\x18\xf8\x59\xbf\x91\x4f\x6b\x62\x32\x00\x17\x33\xb2\x84\xc9\x56\x77\x6f\xea\xb9\x84\xdc\x89\x8c\x5a\xe4\x9e\x16\x6f\x7e\x51\xbe\x98\x5f\xe5\xae\xb8\x5c\xcb\xad\x35\x0f\x66\x4c\xff\x98\xf9\xd7\xb4\xaf\x8e\xa8\x63\xf5\xfc\x5a\x67\x95\xfb\x57\x08\x37\x78\x76\xee\xf4\x80\x4d\x97\x4b\xf0\x7e\x58\x43\xd7\x61\x4f\x6d\x3f\x84\x4f\x34\x79\xc7\xb1\xaf\xf3\xed\x56\x87\x95\x4b\x91\x77\x56\xa8\xc3\x48\x5e\x2e\x0c\x3b\x4c\x87\x1d\x96\x80\xfd\x3a\x15\xd6\xc8\xe1\x45\xce\xd4\xa3\x0b\x95\x02\x24\xd3\x1b\x7e\x4c\x26\x33\xc7\x5a\x2d\x72\x33\x4d\xc1\xc5\xd6\xc8\xa0\xa5\xe0\x92\x78\x3b\x47\x12\xaf\xe0\xad\xc7\xe9\xef\x4b\x82\x66\x2a\x5c\xbf\x75\x41\x4c\xd7\xbc\x5b\xd7\xa9\xb7\x71\xfd\xe2\x3f\x68\x79\xb7\x74\x39\x2b\x4a\xf5\xb9\xa8\xa6\xcf\xa1\x27\x09\x9d\x3d\x03\x02\xa6\x32\x61\x5f\xe7\xc4\x56\xc1\x84\xb8\xa4\x7c\x38\x0e\xf3\x2d\x96\xee\xc1\xc3\x35\x9f\xb8\x7b\x98\xc6\x35\xf0\x0e\xcc\x0d\x4d\xb3\x8f\x92\xb1\x22\x77\xcf\x24\x70\xff\x02\x4b\xb5\xfe\x9b\xf7\x75\xc6\x5b\xcd\x82\x8e\x97\x8e\xd5\x6d\xea\x30\xb8\x94\x8e\x95\x86\xf7\x97\x4e\x0a\x29\x91\x4d\x5d\x32\x98\xad\xd1\xde\x14\x9c\x67\x19\x2f\x46\x80\x75\x19\xb0\x61\xd6\xb4\x22\x81\xd4\xd0\x65\x56\x50\x1b\x2d\x59\x7b\xc3\x35\x78\x88\x60\xe9\xa1\x58\xf1\x0c\xb7\x43\xd4\xbe\xd5\x7e\xdc\xce\x36\xda\x9b\x49\x1c\x11\xc2\x95\x41\x38\x59\x19\x0d\x23\xba\xb1\x9b\x3a\xb1\xcc\xf4\x7e\x7c\x35\xe1\xbe\x42\xbd\x20\x19\x9d\xd0\xeb\xba\x27\x59\x17\x86\xbb\x08\xc3\xe1\x5e\x70\xfb\x60\x54\x6b\x82\xa3\xd2\xf9\xf6\xe8\xf7\xf2\xc8\xe8\x12\xa5\xc0\x8a\x18\xc6\x24\xf2\x2c\x6f\xb7\x09\x60\xb2\x72\x0e\x11\x44\x05\xc9\x60\x62\xb1\x20\x64\x66\x79\x86\x5c\x0b\x66\x58\x6c\xa3\xf4\x3a\xfb\x09\x09\x3b\xad\xb1\x35\xf3\xd4\x55\x2f\x56\x55\xe3\x99\x2f\x60\xa6\xa9\x9d\xcc\x1b\x1d\xf3\xd7\xae\x3d\x00\xc0\x66\xdd\xa7\x7a\x36\x31\xc1\xd1\x5b\x46\x33\x87\xe3\x0f\xaf\xa5\xf9\x91\xf1\xaf\xe7\x69\xce\xb8\xc1\x4a\x89\x24\x5a\x2c\x1c\x83\x37\x14\x19\xcb\x43\x22\xc7\x0c\x97\x00\x13\x19\x42\xde\x4e\x9a\xf9\xbc\xcd\xb8\x36\x2a\x47\x4e\x06\x38\xf6\x8d\x4e\x78\x5b\x6b\x43\xa2\x09\x15\x7a\xed\xd5\x5e\xd1\xb9\xe2\x96\x5b\x5a\x6f\xbd\x95\xc9\x1e\xb4\x65\x10\xeb\x88\x5f\x59\xbb\xf5\xd2\xf8\x2d\x49\x99\xef\xb4\x11\x07\x20\xa9\x78\x6b\xd2\xf4\x69\x12\x06\x60\x1b\x6c\x73\x1a\x61\x00\x55\x29\xb6\xe0\x93\x86\x2d\x18\xcd\x85\x25\xa9\xb6\xb3\x49\xa1\x6c\xc3\x14\x5c\x95\x58\x9f\x61\x3a\x57\xbd\x74\x9a\xeb\xd0\x68\xce\x45\x44\x50\x97\x4d\xc7\xae\xe1\x56\x87\xb1\xdf\x53\x7d\x84\xe2\xc6\xb0\xe3\x34\xd9\x36\x07\xe5\x84\x74\xb4\xe9\x72\x6a\x2f\x5d\x17\xb9\x57\xd3\x45\x68\xe8\x02\x5e\xcc\xbf\xb6\x3a\x7c\xc9\xe8\x85\x94\x76\x1f\x4b\xd8\xb0\x97\x63\x59\x35\x69\x27\xcc\x22\xba\x48\x56\x7e\xd2\x8a\x4d\x65\x02\x95\x9e\xc9\x23\xfb\xc7\x88\xab\x71\x19\xf1\x64\x27\xb9\x58\xcb\xdb\x0a\x11\x16\x22\xfb\x3a\x3f\x6c\x8d\x44\xcc\xe6\x04\x75\x03\x7a\x18\xef\x37\x95\xfc\x7d\x28\x82\x2e\x50\xc2\xe6\xdc\x0c\xb7\xdb\xe3\x21\xf7\x05\x16\x64\x64\xa1\x2c\x5b\x7d\x2c\x8b\xf3\xb1\x6e\x17\xb9\xd4\x8a\x23\x09\xb3\xcb\x53\x72\x67\xa5\x45\x0f\xf0\xfa\x3d\xaa\xf4\x20\xb8\x66\x7e\xc3\xfc\x83\x25\x49\x9c\xc8\x5d\x95\xae\x0c\xe2\x19\x66\x9f\xac\xdf\xde\xbf\xe9\xaa\x19\x83\x47\x17\x6e\x7e\xfa\xe6\xf6\xf9\x07\xb8\x7d\x22\x57\x0b\xf6\x87\x7e\xfa\xfb\xe5\x8f\x79\x86\x0c\x99\x7d\xc3\xf0\x07\x9f\x80\x8b\xde\x7f\x79\xda\x9e\x6b\x3a\x96\x72\x83\xe0\x82\x0d\x93\x5a\xee\x52\x55\xf5\x4b\xf5\xe1\x4f\xbf\xb8\x51\x8f\xad\x25\xe3\x8d\xf2\x51\x7f\x25\x47\xcc\xcd\x70\x38\x9c\x4e\x26\x97\x2d\x88\x64\x64\x39\xb2\xac\x75\xb1\x2c\x87\xc7\xee\xf0\x6a\xfb\x52\x5a\xa6\xaf\x2e\x97\xf3\xe9\x4c\xfc\xb7\x92\xa7\x79\x04\x16\x28\x47\x3f\x37\xc3\xd0\x3c\x9d\xb3\xb3\x19\xdd\xe4\x52\xeb\xd8\xb9\xfe\xce\x94\x98\x8d\x4d\x46\xcc\x06\xd6\xfd\x3f\xd0\x6d\x80\x5a\xf0\x09\xca\x4c\x8f\x0b\xd1\x6c\xf7\x57\x24\x6c\xfd\x2b\xd1\x99\x54\x5b\x7f\x00\x05\xd2\x7d\x03\x1a\xfe\x1f\x12\x31\x21\x1c\xfc\x33\xe1\xf7\xc2\xf8\xb3\x51\x76\x61\x37\xf8\xbf\x4c\xe0\x4f\xea\xfc\x14\x7f\x10\x05\xc3\xdd\xe0\xff\x4f\x02\x3f\x0b\x9f\x13\xda\x53\x6c\x2c\x43\x43\x4e\x42\x13\x42\x91\x44\xbc\x49\x55\xd2\x46\x94\x97\xf4\x87\x30\x5b\xc1\x64\x94\xa1\xee\x07\xff\x54\x7f\x58\x48\x2d\x43\xef\x78\xfa\x49\x7c\x84\xbf\x13\xf3\xb2\x30\x89\x89\xcc\xe6\x91\xd9\xe6\x72\x39\xac\x7e\xb7\xdb\xcf\xb3\xb9\x79\x36\x67\x7d\xcc\x66\x73\x5b\x3c\xee\xfa\x98\xc7\x65\xb1\xd6\xc7\x2c\xac\x14\xaa\x8f\x49\x1c\xe3\xad\x8f\x31\xee\xa6\x3c\x48\xc9\x80\x79\xee\x6d\xd5\x24\xf8\xcd\x59\xa1\x1d\x02\xc9\x15\xf2\xc3\x48\x8b\x26\x49\x06\xbf\x15\x94\x63\xe5\x32\x4f\xbb\x12\x9a\xfd\xe7\x1f\x56\xab\x2f\xa9\xab\xa1\x11\x2e\xb9\x76\x3a\x7b\x4f\xc7\x27\xcc\x3f\xe3\x19\xec\x65\x67\x67\x8e\xac\x2c\x1d\x6c\xff\xb1\x13\x6f\x9d\xb0\x08\x86\xc3\x65\x30\xdf\xa2\x07\xc4\xdd\xcd\x71\x63\x39\xf5\x73\xf5\x47\xf5\x8c\x4a\xcc\x6e\x88\x25\xe3\x20\x96\xd3\xfc\x7f\x05\x58\x32\x5e\xa8\x5c\x9c\xeb\xb0\x78\x43\x58\x46\x0e\x09\xa2\x58\x98\x91\x11\x72\xb0\x3d\x7a\x96\x92\xfc\xc4\xa5\xe0\xe1\x4a\x4b\x4d\x7e\x7f\x31\x39\xec\xeb\xb5\xb8\x65\x77\x76\x5d\xcc\xed\x90\xf3\x89\x05\x9c\xe4\x2b\x3e\x25\x40\xb3\x00\x82\x60\x3a\xc7\xd5\x9c\xc8\x76\xd8\xe5\x3a\x41\x7d\x0b\x77\x69\x7d\x4e\xe6\x28\x0e\x17\x09\x46\x9e\x62\x7f\xef\x5c\xe2\x49\x4e\xde\xdc\x0c\x9a\x23\x99\xeb\x99\x48\x5b\xac\x7e\x3b\xff\x56\xf5\xeb\xef\xce\xc6\xbf\x87\x8c\x9b\x6e\x03\x0e\x3e\xe9\xa8\x59\xb1\xf5\xc1\x7b\xe1\xfc\xed\x6b\x58\xb1\x4b\x36\xe3\x67\x9f\x25\x99\xfb\xc0\x0f\x19\x4f\x3f\x1d\x7f\x39\x50\xf4\x71\xfb\xfb\x1f\xa8\x57\xb4\x83\xa2\xa7\x36\xd6\xf9\xdf\x34\xca\xb3\xab\xf4\x58\x94\xcf\xa8\x8c\xc0\xf8\x49\x24\x27\x09\x7b\xf2\x07\x39\x39\xb9\xef\x93\x7c\x71\x8f\x50\x5a\x1a\xad\xd9\x7c\xd1\x5e\x23\xa6\x06\xf3\x3e\xcf\x10\x8f\x9f\xb5\x76\xe5\xd9\xd3\x28\xcf\xae\xd2\x6d\x0c\xbc\x66\x17\x0a\x91\x50\xd4\x90\x5f\xc7\x4d\x61\x5b\xd4\x61\x24\x17\x9d\x8e\x1b\xcb\x09\x0c\xe5\xee\x01\x22\xa9\x04\x3c\x3a\xde\x44\x9b\x55\x03\x67\xd2\x4e\xea\x27\x8d\xc6\x4a\xfe\xce\xd6\x8c\x1c\x2e\xdd\x87\xd2\x07\xb7\xfb\x1d\xca\xb3\x29\x6e\x66\x79\x1f\x3d\x7a\x08\xb7\xda\xb7\xaf\xf3\x6c\xab\x2f\x93\x4d\x8d\x51\xa3\xf7\x49\x89\x3d\x30\x7c\x6f\xdd\xb6\xfd\x15\xe6\x13\xa4\x9f\x3d\xf1\xbe\xd0\x73\x5c\xcf\x5e\x7c\x9a\x0f\x91\xe6\xb8\xa3\xe3\x32\x46\x87\xef\xab\x8f\x4b\x09\xae\xa1\x64\x42\x49\xcf\x74\x9f\x23\xc5\x4f\xfb\xd0\x5b\xd7\x01\x66\xe9\x3a\x40\x34\x8a\x2b\xa8\x74\x55\xf6\xe4\x53\xd7\xbd\x86\xff\x98\x81\x9f\x59\x86\x9e\xd0\xe1\x4b\x4b\x71\x05\xbd\x50\xaf\x92\x34\x3e\x31\x01\xcb\x67\x3f\x53\xdb\x4e\x6f\x3d\x16\xe0\x11\x6d\xff\x2b\x3f\xaf\xdc\xc0\x4c\xdb\x8d\xf7\xc9\xbd\xdc\xd0\x44\xbb\x6f\xa1\xf1\x26\x18\x2e\x6a\x8f\x1a\x18\xbb\x69\x2f\x1e\xf3\xd9\x7a\xfd\x3d\xc9\x80\x94\xb9\xcb\x7a\xff\x6e\x7b\x97\x6b\xb2\x27\x86\x2f\x21\x03\xd2\x03\xf5\xa8\x48\x6b\x6f\x4f\xdc\xde\x56\x4a\x27\xd5\x7a\x7b\x27\x6a\xed\xb0\x06\xad\x12\x9b\x6c\x47\x0e\xa6\x91\x0a\xbe\x14\xef\xa3\x63\xa9\x9f\xfd\x96\x3a\x84\xee\x57\x96\x93\x63\x90\xd1\xe2\xfa\xe2\x99\xc5\xfc\xe7\xf6\xe2\x9a\xe2\xe1\xf4\x73\x53\xf1\x81\x62\xd1\x78\x45\xce\x48\x1e\x28\x3e\x5a\x2c\x69\x0f\x6a\xe8\xfb\xa3\xc5\xc7\x8b\x4f\x15\x9b\xf6\x90\x67\x5a\x89\xd5\x5d\x81\x9e\xa2\x0f\x08\x98\x99\x3c\x24\xb8\x93\x70\xa7\x8a\x3b\x8b\x2d\x8b\x9a\x8b\x01\x32\x9c\x19\x5e\xce\x43\xb5\xf0\xe4\x75\x09\x1a\x5d\xd3\x3b\xb8\xe8\xd8\x55\xeb\x63\x97\xab\xc9\x0b\x58\x10\x2b\x24\x02\xf3\xd9\x56\xb3\x83\x13\xd2\xe8\x35\xa7\xf3\x34\xeb\xa4\xf2\xe6\x58\x5d\xb6\x3d\x82\x65\x5b\xd7\x1e\x5c\xd1\x3e\x58\xd6\x9a\xe1\xd5\x47\xaf\x2a\xe5\x8e\x2f\x3b\xf1\x13\x03\xcf\x9b\x31\x5b\xb2\xda\x18\x1e\x73\x4e\xab\x8c\x39\x33\xd6\x36\xc8\x35\x20\x26\x13\x2f\x93\x8b\xef\x9c\xe0\x70\x02\x72\x6a\x01\x58\x44\xe8\xac\x48\x9c\x03\x4f\x3b\x42\x92\x38\xf4\xad\xdf\x82\x05\x19\xea\x3f\xf7\xab\xff\x06\xbf\x76\x1b\x16\x66\xb3\xe4\x68\xf7\x06\x38\x64\xdc\x89\x65\xe4\x40\xcc\x44\x37\x29\x8a\x10\x72\xc9\xb2\xc5\x1f\x0a\x05\x7d\x00\x6e\xbb\xc5\x92\x95\x6d\xcf\x06\x0b\xca\x06\x27\x9b\xe1\x74\x39\xb1\x20\x20\xdb\xe4\xba\x58\xd0\x6e\x1b\x6e\xab\xb7\xb1\x0e\xd6\x66\x33\xf9\x3c\x8a\xcb\x6e\xe2\x48\x3a\x78\x3d\x3d\xe2\x3b\x15\xae\xa4\xff\x80\x1a\xaf\xe8\x15\x15\xc9\xc3\xea\x15\x29\x89\x1f\xbd\x89\x23\x37\x34\x75\x62\x4a\xfa\xc4\x0a\x2f\xd4\x91\x94\x89\x24\x7f\xe2\x42\x2d\x83\xe2\x1b\x0c\xf7\xf3\xb0\x1a\xdb\xd2\xc0\x8f\x90\xb3\x18\xca\x48\x1e\x45\xb5\x7d\x71\x22\x0e\x90\xda\xac\xfa\xe8\xb1\xa0\x6b\x75\xda\xa5\xc1\x86\x58\x00\x2b\x4e\x8b\x03\xa4\x39\x17\xa9\xcd\xea\x4a\x3d\x1e\xe0\xa7\xb4\x98\x06\x39\x52\x96\xf4\xe8\x26\xe2\x06\x37\x19\xf8\xb1\x0c\xb2\x55\xb7\x57\x69\xc1\x8c\xb8\x1f\xdd\xe0\xbf\x22\x81\x7f\x25\x8d\x4f\x48\xf1\x4b\xab\xad\x99\x5d\x7d\xc6\x5a\x1d\x3f\x24\xfa\xc0\xc1\xae\xd4\x3e\xf8\x91\x3f\xa7\x9b\x3a\xbe\x4c\xd4\xb1\x01\x4f\x55\xb2\x8e\x6c\xa2\xd4\x65\x47\xba\xab\x83\xea\x8b\x7d\xf4\x58\xb0\x03\xe8\x2d\x54\xa5\x14\x31\x80\xfc\x0d\xfe\x46\x7f\xb3\xff\xb4\x9f\xf7\xb3\x0c\x04\xa7\x06\xa1\x30\xd8\x3b\x78\x49\x90\xbd\x22\x38\x3b\xc8\xe8\x91\x94\x46\xf0\xfd\x04\xcd\x3f\x4b\xdb\x40\x63\xcb\xae\xd4\xf1\x79\x90\x1e\x45\x93\x9d\x4d\xfc\xba\xb9\x60\xf8\xc6\x13\x31\x40\x5a\x3f\xff\x93\xe8\x27\x0b\x9b\x35\xd9\x86\x01\x1a\x82\xe9\x19\xe1\xc9\x4a\xc4\x5f\xea\xf2\x10\xae\x87\xcb\xd6\x7c\xf6\xba\x3c\xc4\x1b\x65\xa8\x3b\x3d\x34\x39\x14\x49\x54\xa3\x97\xd9\xa2\x8e\x26\x77\x29\x39\x8c\xbe\x6e\x66\xc2\xb8\x4c\xe1\xd3\x78\x68\xd4\xa9\x4a\x46\x76\xb6\xc3\x51\x10\x2e\x86\x70\x71\x5d\x71\x43\x71\x63\x71\x73\xf1\xb6\xe2\xdd\xc5\x6d\xc5\x12\x39\x15\x42\xc7\x57\x1d\xcd\xf1\x5c\xbf\x44\x9d\x9b\x99\xb1\x9a\xee\x82\x85\xff\xcf\xb1\xf0\x9f\xea\x4b\xa1\xf7\xab\x51\x7e\xd1\x4f\xdb\x1b\x98\xf9\xc6\x5c\x10\x37\x29\x99\x8b\x70\xd0\x94\xae\x5f\xd0\xbc\x8d\x94\xdf\x5e\xa5\xed\x0f\x94\x66\x71\x19\x9f\x8f\xe8\x52\x84\xc7\x84\xbc\x92\x27\x6d\xfe\xb4\x38\x54\x35\x11\x87\xda\x49\x75\x24\x5c\xc6\x6c\xd6\x7c\x54\x67\x5b\xf1\x62\x94\xd2\xca\x68\xbe\xf7\x63\x86\xef\x1d\xef\x43\x7b\x75\xba\x22\xb1\x32\x64\x6d\xf8\x8d\xa0\x02\xda\x6f\xad\x8e\x3d\x46\x1d\x26\x80\x69\xc6\x9c\x62\x7e\x84\x07\x5b\x46\xb2\x45\xab\x23\x31\xa7\xf4\x5e\x23\x2a\x93\x5c\xa0\xcb\x24\xdb\xf4\xbd\x94\xb4\xcb\x3c\xc4\x2c\x43\xda\x5e\x4a\xf3\x9c\xd1\xf9\x9c\xa0\xef\xbd\x55\x06\x3c\x09\xd6\x9a\x60\x96\x91\x94\x0a\xaf\xe1\xff\x8f\x81\x1f\xeb\xf2\xb7\xea\xf6\x51\xb3\x16\xd0\x6f\xed\x0e\xff\x11\x03\x3f\xb3\x11\xc5\xb5\xbd\x89\x80\xea\xa8\x93\x78\x55\x03\x2f\xe6\xf3\x7d\xf4\xb1\xa1\x03\x6a\x75\x5a\x5d\x90\xba\xe7\x69\x78\x8f\x25\xf0\x2e\x47\x9b\x8c\xf1\x77\x52\x07\xde\x99\x56\xab\x0b\xa5\x8c\xbf\x66\x4b\x62\x9c\xfc\x9b\x48\x46\x7f\x54\x8a\x45\xfc\x04\xec\xb6\x53\x76\x68\xb7\xc3\x51\x72\xed\xeb\x6e\x3b\xb3\x9a\xdc\xfa\xda\x68\x67\xec\x76\x38\x61\x3f\x6d\x67\xf0\x73\x3b\xf1\x14\xf8\xf2\x0a\x6a\x6b\xe8\x8d\xb0\xf8\x8d\x99\xe5\xcd\x75\xe4\xbe\x24\x92\xe3\x97\x7a\x35\x30\xa1\x26\x0c\x71\x7a\xe8\x2d\x49\x2a\xe9\x4c\x5e\x2d\xe1\x85\x81\xad\xc6\xad\x12\x5c\xab\x7e\x9d\x04\xd1\x15\x2c\xfa\x1d\x32\x39\xa8\x04\x4d\x53\x7a\xf9\x44\xae\x10\x53\x82\x93\xcf\x62\x4b\x7b\x84\xbc\x66\x9f\xcd\xed\xc6\x72\xb4\xdb\x27\x62\xdd\x9b\xa6\x86\xb0\x31\x36\x2c\x48\x23\x1b\x9c\xb0\x9d\xc6\x9f\x71\xeb\xf6\x9a\xac\xb5\x36\x07\x43\x83\x4a\xe8\x1d\xd5\x88\x1e\xad\x37\x6e\xbd\x48\xbd\x16\xc2\xc8\xcc\x92\xf0\x4c\xa4\xc4\x99\x24\xef\x97\xd1\x82\x4d\xf4\x00\x36\x4b\x53\x2b\xf4\x52\x8f\xea\x17\xca\x24\xaf\x98\x69\x62\x47\x1b\x97\xcb\xf0\x7d\xef\xbd\x77\xf1\xdd\xfa\x9d\x32\xff\x4a\x5c\x34\xc3\x7e\x18\x9f\x62\x5c\x30\x43\x75\x08\xcc\x91\xf8\x4d\xe4\xee\x43\x94\x8b\xce\x47\xe3\x95\xa8\xc9\xe6\xf7\x14\x15\x65\x67\x73\x79\x1e\x4f\x10\x13\x80\x8d\x2d\x29\xf5\x17\x65\x15\x65\xd5\xc7\x8a\xac\x45\x56\xce\x59\x28\x38\x85\x86\x98\x93\xe5\xb2\x53\x2f\xdd\xa7\x87\x82\xc8\x81\xf3\x2e\x79\xb9\x12\x41\xa8\x89\x1b\x68\x49\x27\xfc\xa2\x76\x90\x53\xbf\x7f\x5f\xd4\xaf\xdd\x4f\x5c\x97\xca\x6f\xa2\xf7\xef\x67\x5d\x7e\x91\x6b\xa3\xf3\x89\x0d\xc6\x3d\xfc\x2f\x1b\xb7\xef\x8f\x30\xee\xe3\x27\xd7\xf0\x73\xdf\x0e\xba\xb4\x57\x1f\xe7\x90\x0b\x16\xad\xd1\xef\xe3\xbf\x8d\xdc\xc3\xcf\xfc\x42\x2f\xe5\xd7\xe3\xcd\x4f\xe1\x3e\x5a\x31\x75\x8c\x56\x1c\x26\x97\x8b\x13\x65\x19\x71\xc8\x87\xb9\x3a\xf8\x09\x31\x65\x66\xe7\xd7\xda\xfd\xe0\x63\x4d\x58\x0f\x34\x99\x38\xde\x38\xfb\x94\xda\x47\x4d\xdf\xd3\x5c\x66\x4e\x57\xdf\xf4\x4b\x51\xf3\x75\x45\x2f\x35\x1a\xfd\x94\xaa\x7e\x11\xdf\xc2\x3e\x1b\x97\x60\xfd\x37\xc0\x93\x78\xf4\x66\x58\xb6\x7d\x13\x6c\x7e\xe1\x73\x72\xd2\xa9\xf6\xdd\xb6\xf9\x2d\x2a\xe6\x39\xc9\x7b\x8b\x32\xb0\x2e\x57\xab\x14\x38\xf8\x70\xd8\x6a\x0f\x06\x71\x9b\x0b\x8b\xdc\xbc\x9f\xf1\x67\x11\xcd\x4d\x76\x5c\x11\xa3\xb7\x17\xe5\x93\xac\xcb\x46\xb8\x79\x42\x4d\x4b\xbb\x04\xf9\x9c\x2b\x8a\x48\xf3\xfe\xd7\x25\x45\xcc\xbf\xe2\x47\x7e\xf7\x9e\xa2\xad\xea\xcf\x5d\x2f\x2a\xa2\xfa\xb5\x59\x1f\x63\x1b\xf2\xa3\x4a\x25\x68\x47\x16\x8f\x47\xe4\x11\x9f\x11\xb0\x60\x8d\xda\x62\xe1\x4d\x2c\xef\x49\x33\x0d\xa6\xe6\xcf\x4f\x46\xf4\x17\x55\x15\x54\x74\x19\xc4\x9b\x3e\xbe\x2f\xbe\x65\x0b\x14\xf4\x81\xf5\xe4\xa2\xe2\x87\x1f\xd2\x07\xf1\xc1\x05\xfb\xa7\xb3\x3f\x3c\x9c\xfb\x46\x7c\xef\x87\x6d\xf3\xee\x20\x17\xe7\xe2\x76\xe8\xe3\x18\x44\x85\x48\x51\xc2\x2e\x2e\x37\x17\x65\x84\xe4\x0c\xb9\xe8\x3c\xbf\x57\x70\x99\xed\xf6\x08\x8d\xae\xc6\xea\xaf\x59\x5f\x9f\xdd\x05\x7d\xe9\x51\x5f\xa4\x31\xdd\xaf\xc7\xd4\xe5\x68\x06\xa8\x38\x67\x2d\x32\x1f\x18\xe3\xc7\x7d\x9f\xfb\x5c\xe2\x7a\xa7\x94\xa5\x58\x1f\xff\x34\x79\xd7\xd3\x38\xbc\xef\x4f\xe1\xd7\xe1\xd1\xeb\xa7\x64\x7a\x3d\x1e\x13\x6b\x37\xd9\x03\x19\x5e\xc9\x2b\xb9\x30\xd3\xac\x8f\xb9\xdc\x56\xa1\x3e\x66\xe5\xba\xe4\x3b\x49\x4b\x61\x5d\x50\x4e\xcc\x0e\xf9\x61\xb6\xa8\x77\xa4\x42\x33\x41\xd0\xab\x7a\x99\xe7\xfe\x0d\x8c\xfa\xc3\x97\xea\x27\xeb\x37\x5d\x09\xd5\xed\x70\x11\xcc\x50\xd7\xa9\x07\xd4\x01\xab\x9f\xe9\xf1\xd7\x65\x70\x3e\x98\xb0\xe6\xdd\x4f\xfd\x78\xd8\xde\xfd\xea\x3c\xf5\x49\x75\x97\xba\x18\x26\x0c\x98\xb7\x54\x93\x83\xa7\x75\x7e\x23\x0c\x16\xea\x30\x65\x0e\x57\xce\x93\x4c\xa6\xfc\x90\x37\x8f\x75\xe4\x39\x8a\x0a\x33\x30\x0f\xc8\x70\x7b\xf3\xdd\x52\xbe\x94\x6f\x75\xbb\x71\x3b\xdd\x1c\x6d\x67\xd7\xbc\x2c\x78\xbd\x38\x0e\x25\x23\xd3\x2b\x8c\xb4\x22\xf4\xc6\xe7\xb0\x5b\x3b\x33\x4a\xef\x82\x0e\xfb\xd3\xae\xff\x11\x7b\x02\x1b\xf8\x4a\xed\x00\xfb\x3f\xe1\xbc\xfb\x36\x8d\x55\x5f\x6d\x7f\x5f\x3d\xfc\x10\x5c\x87\x3b\xe1\x7e\x78\xf9\x2d\xbd\x2f\xea\x13\xbe\x74\xe0\x33\xbd\x3e\xe2\x7e\x55\x8f\xa9\xbf\xaa\x71\xf5\x55\x28\xc0\xfd\x78\x1a\x06\x7f\x06\x23\xe0\xb6\xa5\xfe\x15\x5b\xec\x9b\x5d\x97\x5e\xfe\xef\x01\x0b\x16\x69\xfd\x21\xb1\x17\x77\xf2\x2c\x8a\x90\xfe\x08\xa2\x98\x13\x70\x65\x23\x39\x5b\x2e\x2c\xf0\x06\x49\x8e\x7f\x57\x8e\x43\xc8\x11\x72\xcc\x0e\x47\x5e\x5d\xcc\xe1\xd0\x6e\xcf\xfa\xbf\xf5\xe7\x9c\x0b\xb4\xfc\xc9\xd4\xf2\xb4\x2f\xe7\xde\xa5\xb5\x6e\x86\x69\xf1\xdc\x68\x65\xa4\xe4\xa2\xea\xdf\xb8\x53\xab\x76\xfe\x12\xeb\x3a\xc7\xa5\x97\xbf\x4b\xb2\xa2\x75\x13\xf3\x84\x79\xb8\xe0\xc7\x6b\xcf\x8b\x77\xac\x01\x4a\xb6\x0f\x85\x78\x4c\xe7\x3c\x62\x73\xc3\xb2\xcc\xbb\x82\xa2\x4b\x6c\x88\xb9\x58\x3e\x94\x5c\x7f\x89\x53\x9c\x5d\xee\xff\x62\xce\x65\xd1\x88\xd5\xce\xd6\x95\xf7\x76\x09\x7e\xed\x44\x9d\xc1\x97\xb5\x53\x76\x6d\xfa\xe9\x3a\x72\xb2\x8e\x39\x4a\xce\xd4\xa5\x72\xe4\xfb\xd5\x67\xc8\xf9\xba\xb3\x4f\x93\xc3\x75\x0c\x1a\x81\xf9\xc4\x9f\x74\x5e\x5c\xa3\x84\x05\xc2\x87\x9d\x4e\x13\x32\xf9\xfc\x2c\x66\x14\x2c\x6b\x16\xcd\x0e\x72\x08\x88\x84\x31\x88\xe9\x87\x01\x4b\xba\x5c\xf2\xee\xae\x8c\x54\xe4\x6a\x0a\x5d\x5e\x84\x64\x2f\x23\x1f\x84\x11\xc0\x7f\x03\xeb\xe3\x12\x66\xbb\x5b\x3e\x57\xe3\x6d\x9b\xb6\xc3\x32\xb5\x79\xfb\x76\xd8\xbc\xff\x5d\xd8\xb7\xe9\xd7\xa6\xcf\x9f\xbb\x75\x19\xa8\x2d\x1a\xdf\x1a\x49\xf5\x04\x8d\xef\x0e\x55\x8a\x3c\xa6\x70\xd8\x66\xc1\x7c\xd7\x86\x8a\x0a\x03\x98\xe7\x06\x7c\x1e\xaf\xe8\x15\x59\xa7\xd7\x6a\xb9\x22\x66\x45\x6c\x3e\xb9\x19\x29\x69\x09\xa4\x51\xe9\x15\x35\x25\x5d\x59\xaf\x5b\xbf\xd2\xa9\xb0\x8a\x36\x50\x8b\xfe\x22\x09\xe5\xc3\xee\x94\x10\xb0\x91\x2f\xbf\x7d\xcb\xc3\xe5\x1c\xf7\xff\x90\xf6\x1d\xe0\x51\x54\x6b\xff\x73\xe6\xcc\x6c\xdf\x9d\xd9\x32\xdb\xfb\x26\x9b\x90\x40\xda\x26\x84\x84\x40\x96\x22\x45\x5a\x42\x5f\x01\x09\x02\x2a\x45\xe9\x08\x22\x5d\x84\xd0\x41\x10\x90\x8e\x20\x45\x41\x84\x28\x08\x02\x62\x05\x1b\x22\x16\xd4\xfb\x29\x5e\xeb\x55\x2f\x7a\x2d\xd7\x42\x76\xf2\x3f\xe7\xcc\x6c\x0b\x70\xef\xf7\x3d\xff\xc7\x47\xd1\x75\x76\xe7\x3d\xed\x6d\xe7\x7d\x7f\xbf\xf8\x9b\xf4\xb7\x8a\x43\x48\x6f\x44\x1e\x9b\x25\x4e\x3e\x35\x73\xc9\x86\xa5\x4b\x37\x2d\x9e\x41\x07\x81\x1d\x58\x6e\xbb\x7b\x70\x07\xa0\xda\x8e\xc9\xc9\xd4\xf3\x7c\x23\x63\x74\xd1\xe7\xaf\xbf\xfe\xc1\x95\x77\x5f\x91\x39\x1e\x08\x9f\x86\x09\xad\x7d\xfb\xa8\x9f\x43\x81\x30\xe5\x50\x1a\xcd\x7a\xa5\xde\x1f\x30\x51\x35\x31\x93\x8b\x73\x23\x8d\x87\xdc\x16\xac\xf1\xa8\xf4\xf4\x65\xb3\x56\x38\x73\x00\x53\x0b\x80\x32\x2c\x39\xd2\x76\x2c\x46\xcb\x49\x69\xb9\xf6\xe0\x14\xad\x1c\x75\xef\x47\x63\x6e\xfb\xe5\xe7\x6b\xdf\x88\x9d\xc1\xa8\xc6\x3f\xe8\xc7\x16\xec\xd8\xb9\xb4\x7e\xc3\xa4\xd9\xd5\xe2\xb7\xb1\x41\x4f\x0d\xfe\x7a\x1f\xb0\x01\x0d\x3a\x85\x5f\xc5\xff\xe5\x10\x3f\x78\x10\x7e\xf0\xb7\x17\x5e\xbe\xfc\xde\x3b\x03\x9e\xc3\xe7\x2e\x86\xd6\xfe\x29\xcc\x83\x8b\x74\x9c\x4f\x41\xd3\x5a\x4a\xcd\x6a\x19\xbd\x8e\x90\x7b\xb2\x94\x1a\x47\xf5\x6a\x48\x81\x54\xb7\x71\x66\x8e\x35\x22\xe1\xd2\x06\x12\x31\xbc\x31\x06\x37\x34\xbe\x0d\x4b\x1a\xd7\x32\xad\xb6\x80\xef\x71\xe4\x4e\xf8\xfc\x6f\x47\xba\x74\x2f\xd2\xa5\x0a\x34\x27\xb7\x44\x43\x4a\x08\x05\xbd\xc1\xc0\x78\x04\x4f\xc0\xef\x43\xef\xf2\xe9\x7d\x7a\x87\xd1\x41\xd5\x21\xdd\x65\xd4\x0c\x8f\x19\x9b\x2b\xd5\x0c\xd3\x24\x29\x56\x53\x79\xc0\x4a\x81\x70\x16\x69\x92\x69\x4d\x20\x72\x84\x24\x64\x4e\x39\x64\xbe\xb8\xa6\x6d\xcc\x31\x02\x86\x3e\xe5\x68\xa2\x5e\xdb\xfc\x7e\xc5\xb3\xbd\x41\xe4\xd3\x77\x40\xd1\xce\xdd\xe2\xdb\x6f\x5d\x14\xdf\xda\xc5\xce\x41\xa7\xe0\x77\xf1\x1f\xf4\x93\x1f\xff\x7b\xd1\xcc\x8a\x7d\xcf\x1d\x12\x9f\xfb\xf8\x13\xf1\xe8\xd1\x23\xa0\xd7\xdf\xb2\xdb\xa3\xf9\x19\x8c\xf4\xd2\x52\x76\x3d\xb2\x5c\x83\xa3\xad\x94\x0e\xce\xaa\x56\x7b\x19\x9e\xe3\x42\x59\x4c\x56\x4e\xae\xd2\xee\xb2\xbb\xea\x62\x21\x3b\xcf\xdb\x43\x90\xd2\xe9\xcc\xc4\x1c\x04\x30\x3f\x77\x73\xd0\x9f\x74\x78\x93\x04\x9a\x07\x59\x63\x36\x28\x35\x9b\x65\x19\x4b\xf1\x18\x92\x08\x8d\x81\x88\x20\x2f\x34\xd1\xc5\x74\xdd\xa6\x7f\x2e\xd8\xbd\x4d\xfc\x16\xc0\x77\x5f\x03\xea\x2e\x47\x4a\x0e\xce\x59\xb0\x19\xdc\xd1\xb5\xeb\xeb\x2f\x1c\xdd\x0c\x94\xf7\xed\x19\x20\xfe\xdb\x72\xd7\xa9\xfb\x56\x1e\xb5\x97\x03\xe6\xc0\x3b\xfb\x0e\xb6\x9b\x3f\x7d\xea\xe8\xa6\x75\xd3\x17\xcd\x5b\x09\xf8\x5e\x27\x76\x51\xa0\xe9\x55\xb4\x37\xd7\xa0\xf5\x36\xa1\xf5\xf6\xe2\x3c\x0e\xc7\x61\xd4\x7d\x33\x40\x6b\x00\x80\x8a\xe7\x91\xb9\xe0\xa1\x4a\x3f\x3c\xa6\xa2\x0a\x6f\xb0\xdc\x69\x79\x1b\xc2\x30\x45\x20\x59\x70\x1f\xf9\x5d\xd0\xd4\x78\x75\xd5\xc2\x76\x7d\x43\x91\xac\xbb\xe1\x3f\x98\xaf\xe2\xbf\x6e\x8b\x77\x5a\xb5\xd1\xb2\xc5\xb8\x95\xbd\xba\x05\xef\xb5\x17\xc4\xde\xf0\x25\xf6\x10\xd2\x32\x9d\xd0\x0e\x60\x35\x1a\xde\xa0\xd5\x0a\x56\x9b\x9a\x24\x69\x14\x06\x83\xc6\x6c\xa6\x6b\x63\x9c\x79\xae\xf9\x29\x33\x34\x6b\xa8\xc2\xc2\x61\xe9\x6e\x7a\xb3\x0b\x4b\x7c\x0c\x38\x10\x51\x86\x60\xc8\x1c\x2a\x8f\x94\x13\xad\x0e\x77\x47\xda\x56\x45\xcd\xce\x4b\x8e\xf7\xc5\x06\x71\xa3\x6b\x83\xc7\xb7\x7e\x51\x9f\x2e\xac\x9f\xbb\xf5\xf6\xfa\x85\x7f\x5d\x62\x5b\x2d\xdc\xb8\x69\xae\x85\xd8\x9c\xbb\x90\x0d\xbd\x5d\x31\x02\xf9\xd8\x83\xa3\x05\x21\x2f\x95\x97\xa7\x33\x2a\xec\x76\xce\x08\x5b\xe6\x07\xc2\xc3\x63\x01\x17\x87\x6f\xc1\x28\x17\x87\x5b\xf5\x5d\x2e\x38\x3c\xe6\x62\x2c\xea\xe1\x31\xcb\x0d\x2c\xa9\x84\x13\x9b\x8e\x07\x44\x84\xc4\x6b\x49\xec\x29\x32\x41\xb8\xf2\xd4\x78\x53\xa3\xca\xbc\x51\x75\x69\xeb\xaf\xa2\x08\x4c\x3f\x2f\xfd\xf1\x56\x71\x08\x3d\x60\xa2\x78\xf2\xf4\xff\x88\x2f\xec\x07\x13\x41\x2f\x10\xd8\x96\xb0\xab\x8c\x65\xc6\xbd\xe2\x47\xe2\xaf\xe2\x6f\xe2\x1b\xfd\xbb\x89\x3b\x44\xe7\xe4\xd9\x87\x41\x8f\x2b\x60\x10\x98\x31\xcb\x9b\xb0\xac\xd8\xef\x42\x6b\xfd\x2b\x59\x6b\x2f\xd2\xeb\x41\xb5\xca\xa1\xb7\x6a\x94\x0c\x34\xf3\x5a\x9d\x0e\x2d\x32\xe3\xf3\x6b\x94\x7a\x2b\x43\x69\x55\x90\x72\xa3\x3d\x2b\xad\x78\x44\xea\xe1\x91\xc6\x81\xbb\x78\x92\x60\x63\xed\x41\x39\x01\x66\x04\x04\x29\x0f\xca\x78\x78\xa4\x7d\x67\xfe\x94\x87\x5c\x79\x7d\xe2\x57\xcf\x63\x1a\xe1\xf3\xf1\xab\xb1\xea\x45\xde\xd2\x60\xb0\xb4\x20\x37\xb7\x40\x1c\xb4\xea\xfe\x56\x63\xc6\x6c\x64\x96\x36\xda\xe0\x3f\xae\x4d\xdf\xd5\xd0\x61\xe6\x6a\xa0\xa8\xd8\xd3\xb5\xeb\xee\xca\xb2\xb6\x95\x72\xdf\xa7\xe2\x41\xa4\xf3\x71\x0f\x71\x96\x89\xd3\x6a\x75\x0e\xe8\x0b\x06\xa1\x0e\x66\x87\xfd\x9c\x49\xa0\x04\xa5\x44\x13\xaa\x13\x28\x77\xaa\x01\x49\xbe\xe0\xbb\x9e\xcf\x8f\x95\xd0\xa9\xd3\xa9\xed\x22\xad\x93\xf8\x68\x09\xe6\xfb\x6f\x5f\x7b\x6f\xca\x3c\x99\xe7\x6e\xe4\xef\xc7\x1a\xee\x9d\x79\xff\xf8\x67\xde\xb7\x9c\x6f\x00\xb7\x6c\x7a\x20\x8d\xec\xee\xad\x13\x2f\x89\xcf\x6d\x99\x39\x73\x0b\x7d\x38\x1e\x69\x78\x2b\x83\x6f\xcc\x1a\x55\x4b\xf5\x4c\x18\xbc\xe6\xa6\x7c\x60\x5e\x64\x18\x02\xe4\xbe\xbc\x65\x54\xc0\xd7\xe5\x14\xa5\xd7\x69\x68\x48\xd7\x21\x8b\x0a\x59\xe9\xbb\x15\x85\x99\x2c\x2d\xf8\x57\x70\x8e\x11\xe3\xc7\x84\x8c\x2f\x3f\xfe\x78\xc3\xfe\xfd\xf4\x8e\x15\xf4\xf6\xf8\x88\x15\xf1\x3a\xf2\xbb\xf8\x9e\xa2\x9a\x5d\x83\xfc\x8d\x6e\xd1\x2c\xa0\x31\x43\x13\x3a\xd0\x90\x31\x9a\x4c\x94\x85\xb1\x08\x56\x1a\xf0\xbc\x99\x31\x4a\x27\x9a\xa1\x18\xc2\xc8\x2f\x1b\xc9\x14\x29\x74\x32\x28\xb4\x55\x24\xca\x3f\x92\x5b\x53\x20\x75\x20\x4c\xdf\xf8\x5b\xc7\xcf\x6c\x5c\xde\xb1\x63\x49\xc5\x1c\x7a\xef\xe7\xf1\x7d\x34\xfa\x6b\x79\xfc\x4b\x66\xcc\xaa\x4d\xdc\x1e\xd3\x3a\x71\x14\xfd\x62\x7c\x4b\xe3\x17\x49\x3e\xb9\x8f\x91\x4c\x03\xa2\xf9\xb4\x81\x85\x16\x60\x51\x2a\x55\x2a\xab\x40\x01\xc0\x40\x68\xe5\x38\xa4\x2a\x8d\xc8\x74\x03\x9a\xad\x8d\x59\x68\xa4\xb4\x55\x02\x3a\x63\xd5\x52\x2d\x64\x9a\xda\x21\x08\x62\x29\x60\x34\x49\x40\x2c\x4f\xa8\xb9\x90\xd0\x41\x2a\x54\x2e\xe1\x72\x15\x22\x66\xc7\x79\x4c\x25\x2e\x52\x21\x5c\x71\xcc\x11\x49\xca\x78\xbd\x54\x3b\x01\xf6\x64\xae\x85\x4e\x8f\xd7\xa2\x46\x5e\x0b\xe1\xbf\xae\xc5\x83\x13\x27\x36\xdc\x73\x4f\xb3\xb5\x30\xc8\xb5\x95\x66\xaa\x43\x34\xa0\xd6\x18\x79\x5e\xa1\x85\xc8\xa4\x6a\xa0\x45\x50\x68\x4c\x1c\xd0\x31\x66\x3d\xfa\x0b\x99\x7c\xa8\x21\xb4\x0f\xc4\x53\x41\x63\x32\x55\x5c\x07\x24\xa6\x04\x12\xf5\x3d\x1a\x29\x46\x82\xcd\x89\xd8\xca\xe9\xd7\xb7\x83\x97\x4e\x5f\x68\x61\xe7\xf2\xc5\x2f\x4e\x82\xb3\x9d\x8f\x17\x3c\xdf\xfd\xe9\xd6\x5b\x99\x6b\x95\xd7\xaa\xe9\x0e\x13\xef\x2c\x18\x17\x5f\x00\x5f\x3f\xd5\x69\xfa\x2d\x6f\x3d\x5c\x21\xf9\xd5\xdb\xd0\xb9\x9a\x8f\x74\x40\x80\xea\x12\xcd\xf2\xd9\xed\x2e\x33\xcd\xab\x15\x0a\xde\x05\x43\x41\xaf\x89\xf6\x31\x0e\xa3\x12\x32\x68\x73\x30\x66\xca\x9a\x66\xb6\xb0\x1e\xc0\xe6\xa9\xba\xb9\x60\x6c\x30\x47\x11\xf2\x3b\xd0\xba\xa4\x51\xf3\xa0\x23\x45\x3e\xb1\x85\x90\xc4\xcc\x13\xef\x0c\x9d\xf1\xa6\x38\xf2\xf9\xa2\x91\x83\xef\x9b\x70\x6a\xd4\x7d\xbf\x9f\xd2\x1c\x50\x96\x3c\x62\xd9\xbb\x17\xfc\x00\xf7\x37\xde\x35\xef\xd1\xae\x8f\x6e\x80\xe7\x1b\xbb\x3e\xb6\x0d\x74\x82\xc7\xae\xdd\xb9\x76\xc0\xda\xda\x01\x44\xde\xa6\x77\xc4\x41\xb8\xfe\x02\x9d\xef\xe2\xa8\x5d\xc5\x30\x4a\xa0\xd3\x59\x95\x56\xbb\x8d\x43\x91\x2a\x47\xab\x55\x26\xe4\x43\xe3\xd2\xa5\x8a\x8a\xeb\x7d\xcf\x08\x08\x63\x71\x42\x98\x67\x53\xe2\x3f\xc4\xd6\x69\xdf\xa7\xf4\x5f\xba\x27\xbf\x8e\x1b\x58\x76\xf1\x82\x6e\xc5\x2d\xdb\x4c\x61\xe7\x5f\xeb\xf6\xf2\x60\x88\x3c\x13\xe6\xf0\x88\xbd\xd7\x3e\x58\xbd\x41\xbb\xcb\xb0\x95\xcc\xd7\x12\x71\xa0\xcc\xdf\x16\x89\x3a\x28\xa7\x49\xad\xd6\x6b\x9c\x1a\xb7\xcb\x64\xd5\x24\x09\xdc\x04\xa4\x28\xab\x33\x09\xd9\x12\xab\xf6\x7f\x62\x64\x13\x07\x32\x83\x6f\x50\x47\x70\x6d\x51\xe2\x0e\x9e\x7d\xc4\xa4\x60\x36\xc9\x77\xe5\x3f\x28\x0e\x22\xff\x49\xce\x45\xf8\x55\x26\xa3\x20\x38\xed\x06\x4a\x45\xa1\x5d\x62\xaf\x8b\x19\x4c\x06\x13\x63\x86\x5a\x0f\x8a\xec\x19\x26\x34\x3c\x05\x3b\x98\xf0\x88\x93\x1e\x54\x0a\x41\x32\xe1\x2d\xe1\x7b\x71\x06\x85\x45\x65\x68\x87\xe3\x32\x5c\xab\x12\x85\xac\xb2\xdd\x92\x91\x16\x3e\x12\x5f\x79\x1c\xe3\x2c\xfc\x0a\x7a\x76\x1b\x7c\xcb\xe0\x97\xa6\xcc\x76\xbe\x24\xfe\xf9\xd3\xcf\xe2\x1f\x40\xfb\xcf\x5f\x01\x2b\xc1\x2c\x1c\x06\xbd\x3e\xc5\x20\x0b\x1f\xbe\xdc\x72\x6c\xf7\xbd\x63\x67\x1d\x6b\x37\xf6\x3e\xb4\x95\x5b\x8a\x97\x91\xb5\xfa\x5d\x3c\x0f\x5a\x49\xfd\x20\x2c\x44\x73\x8c\xef\xfd\xbb\x46\x43\x2e\x85\x56\x10\x28\x83\xde\x68\xb4\x20\xf7\x30\x10\xd4\x1a\xb4\x06\xc8\x71\x52\x0f\x18\xf4\xe2\xae\x8f\x66\x23\xc9\xc0\xbe\x93\x67\x3e\x49\x37\x67\xb5\xb5\x96\x87\xc1\x81\x1b\x10\xcf\xbd\xff\x95\xe7\xa1\xc1\x2f\xcd\x98\x78\xf2\x46\xf4\x73\xe7\xce\x75\x78\x74\xef\xd8\xf9\x2f\x14\x75\x4d\x91\xd0\xa1\xb9\x17\x07\x2b\x7a\xa2\xb9\x37\x23\x2d\x1e\x8d\xfa\x1d\x4a\xca\x8b\xce\xb6\x57\x09\x7d\x7e\xa3\xc9\x80\xce\xb4\x5e\x0b\xb5\x56\x3c\xef\x10\x59\x51\x98\xe1\x37\x45\xaa\x23\x99\xf1\x1c\x69\x46\x49\x60\x3a\xda\xb2\xd1\x6e\x35\x16\x12\x40\x0b\x32\xd9\xe5\xcc\xb3\xf7\x9c\xb9\xef\x7d\xf1\xdc\x9e\xc7\x41\xe5\x7b\x8f\xbd\x01\xb6\xe5\x37\xfc\xbd\x61\x54\xfd\x0f\xe2\x5f\x40\xfd\xcd\xd2\xd1\x03\x4a\xcb\x8e\x80\x9e\xff\xf3\x37\xd0\xf5\xc9\xae\xd1\x3f\xce\x2b\xee\xa1\xd9\x02\xf1\x3d\xf1\x4f\xf1\x0f\xf1\x5c\x41\x22\xf6\x78\x19\xcd\xad\x91\x72\x53\x1d\xa3\x41\x41\x0d\x9d\x94\xd1\xe8\x54\x43\x8f\x17\x70\x3c\x6d\x30\x28\xb4\x5a\x53\x4d\x4c\xcb\x2b\x70\x53\xa5\x15\x17\xca\x54\x67\x8a\x9b\x19\x7d\x22\xf1\xd2\xba\x67\x90\xb8\x40\x9e\xd0\x72\x18\x66\x84\x53\x15\x9b\x6a\xf1\xa4\xf6\x5d\x1f\x01\x9d\xf3\xe3\xf7\xe3\x19\x8d\xb6\x01\xa5\xe8\x10\x57\x37\xee\xcf\x69\x29\xcd\x6a\xbe\xaf\xc3\x5f\x26\x76\x32\x9e\x50\x2b\x2c\xb0\x24\xe2\x63\x76\x3d\x39\xe7\x1e\x2c\xa7\xc1\xec\x52\xa9\xd4\x36\x08\xd5\x66\xe8\xf5\xb9\x94\xc8\xd3\x32\xba\x8c\x6a\xab\x53\x6b\xd5\xd6\xc5\xac\x50\x8d\xcd\x63\x66\x46\x33\x93\x8f\xad\x84\x11\xa4\x54\x66\x46\xa4\x0c\x78\x1c\x25\xfb\xe1\xee\x7f\x02\x46\xbc\x76\x45\xbc\xe3\x8c\x55\x0e\x93\xe1\x2c\xf1\x38\x06\xa2\x00\x51\x76\xfe\xa7\xaf\x9f\xfb\x21\xfe\x49\x7a\x80\x3c\x10\x18\xe3\xef\x51\xa9\x7e\xc5\x8f\xd1\x6c\xb6\xc0\x95\x76\x1e\x2a\x4b\x40\x82\xaa\x8d\x14\xcc\xcf\x63\xac\xb4\xd3\xe9\xaf\x89\x39\x79\xbd\xb9\x5f\x4c\x0f\xd4\x2e\x3a\xe7\x66\x39\x40\xdb\x8d\x89\x06\x91\xfd\xf2\x01\xc9\x80\xfd\x27\xba\xc1\xb5\xab\x5a\xe7\x64\xb7\xa9\x9a\x7d\x53\xc6\x41\xc5\x90\x35\x1b\x54\xaa\xc7\x2d\xeb\xc4\x6f\x9b\x93\x0e\xd2\xd4\x3e\xf1\x2c\xdb\x89\xdc\xdd\xda\xa9\xee\xd1\x6c\x8a\xe3\x78\x03\x40\x67\x0e\x17\x89\x6a\x19\xa7\xc3\x40\x0b\x34\x0a\xec\x91\x82\xc5\x61\x35\x43\xe0\xa5\xb0\x86\x4b\xa0\x7c\xa4\x61\x10\x46\x24\x44\x29\x89\x0d\x3f\x89\xf5\x81\x55\x86\x1a\x24\xb3\x83\x77\x89\xb3\xc5\x85\x67\x4e\x82\x5d\x57\x01\x3c\xb6\x13\xec\x11\x7f\xd9\xbb\x55\x9c\x06\x1e\xde\xb0\x47\x3c\x4b\x5f\x15\x6b\xd9\xf9\x8f\xbe\x7f\x7a\xeb\x07\xee\xc6\x46\x66\xcd\xac\xf9\x38\x47\x08\xa8\x3b\x50\x9c\xd5\x88\xce\x58\x1e\xd5\x36\xea\xc9\x56\x0b\x5e\x4c\x0d\xd8\x32\x3f\x4b\xed\x35\xe5\xe6\xfa\x87\xc7\x72\xcd\x06\x93\x09\x6d\x05\x13\x93\x82\xc1\xc4\x53\x9b\xe6\xc1\x90\xec\x43\x7b\xba\xbc\x3d\x3a\x5c\x01\x19\x1a\xd2\x8f\x64\x33\xd0\x04\x36\x21\x80\xc2\x65\x8c\x83\x16\xf0\x67\xdd\xd1\x7e\xc6\xe9\x2d\xdb\x1f\xad\x11\x9f\xdc\x7c\xd4\xf7\x7c\x24\xfe\x3b\xa0\x81\xa1\xe4\xf6\xc7\x4e\x9c\xda\xd9\x03\x4c\x9f\x77\xe0\x4e\xef\x73\xa5\xe2\x7b\x4d\x94\xf8\xbd\xf8\x09\x98\x73\xdb\xb2\xbb\x7a\x78\xbc\xed\x63\xd1\xcf\xee\x9b\x1f\x38\xb3\xef\xe5\x67\x7a\x4d\x1b\xd0\x39\xb7\x45\xf7\xbb\x7a\xfd\xd2\x71\xc1\x9c\xec\xbf\xbf\x73\x01\xc9\xdf\xa7\xe9\x07\xf8\x12\xd3\x03\x69\x67\x24\xbf\xdb\x40\x05\x54\x16\xca\x12\xce\xf1\xab\xdc\xc6\x50\x08\xe9\xb0\x90\x15\xc3\x79\x12\xa6\xff\xff\x2c\x3f\x20\xf2\xa7\x43\x5b\x1a\x24\x6e\x7e\x0c\x82\x4c\x07\x82\xe1\x3e\xb5\x6b\x37\x6d\x1c\x5a\xfc\xc1\x84\x05\x96\x5d\xbe\x77\x8f\x1d\x7b\xab\xe7\xb2\x35\xbb\x46\x45\x7e\xfd\xa3\x72\x7b\x4f\x71\xd6\x8b\x9f\x83\xfc\x21\xb3\x6a\x43\xa1\xfc\x76\x05\xeb\x07\xd6\x59\x36\x3c\xbc\xe5\xe1\xbe\x93\x7a\x07\x73\x0a\x3b\x45\xf6\xbd\xe3\x13\x5f\xdd\x2b\xdd\xff\x8d\x47\x3e\xda\x4e\x9c\xaf\x82\x03\xc8\x3e\xef\x24\x0e\xa2\xff\x64\xdf\x47\x3b\x24\x0b\x57\xd7\xf9\x94\x26\x07\xf2\x49\x75\x30\x9c\xed\xb6\xd6\xc6\xdc\x6e\x0e\x72\x9a\x7e\x31\xce\x05\x83\xb5\x31\x08\x6e\x92\x09\x20\x23\x68\xdd\x0c\x85\xb8\x8c\x28\x90\x0c\x24\xfb\x4e\x13\x6e\x7f\xe8\xc1\xb6\x95\xad\x4b\x6f\xe9\x30\x6f\x05\xd7\xce\xd5\xff\xee\x5e\x55\x45\xc5\x55\x6d\x4b\x8a\xaa\x58\xeb\x6d\xa3\x37\xd6\xff\xf5\x4e\xe7\x1e\xfa\x6d\xfa\x4d\xab\x98\xb8\xd6\x74\xd7\x80\xe2\xaa\xaa\xe2\xa2\xaa\x2a\x72\xff\x8f\xe4\xc4\xf7\xff\x5e\x1c\x27\x68\x28\xc1\xe1\x30\x31\x06\x83\x8d\x82\x7e\x9f\x9d\x37\xf2\xb5\x31\xc1\x6c\xe4\xb4\x28\x42\xd0\x5a\x69\x65\xbf\x18\xed\x4a\x99\x8e\x57\x33\xea\x0f\x12\xee\x0c\x2f\xbb\x09\xad\xdb\x81\x1b\xb2\x21\xc6\x3b\x75\x6e\x53\x52\xd5\xda\x90\xc6\x89\xb8\x4a\xfc\xda\xb8\xc3\xd4\xb1\xeb\xa4\x0c\x6a\x44\xa9\x26\x17\xd7\x48\x18\xb1\xef\x00\x68\xb5\x52\xa7\xa3\x79\x68\x36\x69\x34\x34\x47\x31\x1c\x8a\xb0\x39\x48\xa7\x29\x32\xfb\xf5\x78\x9a\xe9\x59\x3e\x81\x7e\xe7\xf4\xfb\x44\x5d\x6d\xde\x00\xef\x65\xbe\xba\xe6\x62\xbe\xaa\x92\x54\xd4\x43\xcb\xb7\xc8\xb5\x10\xad\x90\x6e\xc2\x56\x29\x80\x66\x42\xc5\x78\x6d\x06\xc6\xe0\xf3\x4b\xbe\xb5\x5d\xa1\x54\xa0\xf9\x50\x72\xb4\x3b\xa5\x95\xd2\x59\xde\xd3\xe0\x63\x93\x54\x90\xcd\x68\xde\x33\x49\x21\x97\x3f\xd4\xb1\x75\x9b\x82\xea\x36\xe9\xd4\x90\xf7\x6e\x7c\xd4\xb0\xcf\xd2\xbd\xc7\xd8\x04\x43\x24\xa0\x50\xc0\x27\xcf\x43\x7e\xd4\xaa\x61\x79\x1a\xf9\xbb\x26\xb3\x5e\x35\x3c\xa6\x67\xd0\xff\x1e\x1e\x03\x30\x81\x5c\x99\x4c\x2b\xe0\xc4\x3e\x49\x2a\xa4\xed\x9b\x02\xe6\x21\xd1\x5d\x54\x5a\x55\xd2\xa5\xfd\xfc\x65\xcc\x57\x5b\xb6\xfc\x75\xa8\xb6\x27\xbf\xcd\xb8\x6e\x09\x3b\x39\xe1\xdb\xce\x43\xef\x21\x56\x59\xc9\x58\xcc\x36\x1b\xaf\x77\x31\x2e\x9f\x9f\x77\xd6\xc5\x78\x0b\x6f\xa1\x04\x14\x7d\x50\x9a\x94\x5f\x4b\x7c\xda\x74\x57\x48\x1e\x3f\x1b\xcc\x0a\x97\xa5\x03\xab\xa6\x7c\x21\x1c\x27\xd2\x9f\x1c\x14\xc5\x95\x67\x5e\x7e\xee\xf4\xa5\xd3\x33\xa7\x0c\x7e\x69\xff\xa1\x35\xe2\xef\x96\x39\x3f\x3d\x0e\xe7\x37\xae\x3a\x7b\xee\xc2\x6b\x70\x94\x78\x8f\x63\xea\xf0\xbd\x63\x77\x9d\x73\x8a\x73\x9f\xf8\x63\xa1\xcc\x93\xc9\xba\x99\x4a\xa4\x13\xfa\x46\xf3\x40\x16\x87\x34\x98\xd5\xa1\x52\x69\xad\x59\xd6\x70\x8e\xc7\xab\x15\x6a\x63\x5e\x2d\xc7\x69\xbd\xd0\xc1\xab\xb3\xb9\x00\xf2\x2f\x03\x56\x87\x20\x5b\xe4\x08\x8e\xbd\x49\xde\x88\x6a\x16\xa6\x45\x9a\x53\x63\xa6\x0b\x7b\x43\x96\xcc\x29\xb1\xc1\x2f\xad\xde\x7b\x13\xae\x4c\xf1\x8e\xd0\x84\xd1\x7b\xc7\x6e\x3f\x5b\x28\x3e\x9e\xc1\x9a\x29\xe5\xe5\xbf\x67\x1f\x43\x73\x1c\xa2\x7a\x44\xc3\x2e\x41\xa7\xf0\xda\x15\xf6\x00\xa7\x86\xb8\xee\xd6\xae\x73\x52\x4e\xe4\xf2\x38\xa1\x46\x3d\x3c\xa6\x81\x94\x29\x33\x82\xc8\xc4\xf7\x4a\x40\xbe\x63\x54\x10\x3f\x85\x19\x49\x30\xfd\x4f\x40\x50\x48\x98\x36\x48\x37\xd0\x39\xe8\x3f\xd1\x79\xb4\x9a\x04\x9e\xa2\xe3\xe2\x45\x71\xcf\x87\x17\x1f\x6d\xfd\x2b\xdd\xeb\xe8\xc9\xab\x97\x3f\xbe\x7a\xa2\x81\xee\xf5\x6b\xeb\x47\xdf\xb9\x2c\xee\x11\x40\x1f\x10\x3e\x0f\xfa\x4f\xd1\x6e\xb9\x32\x5c\xfc\xe2\xf8\xb7\xa2\xf8\xed\x31\xe0\xa9\xbb\xb2\x45\x3b\x49\x7c\xe2\x75\xf1\x63\xf1\xe9\x44\xfc\xc3\x86\x09\xbe\x72\xab\xa8\x4d\x89\x7c\x35\x3b\x63\x77\x7b\x04\x1e\xd9\x3a\x26\x73\x6b\xa4\x9f\x09\x39\x29\x27\x6f\x08\x13\x49\x24\x28\x73\x88\x66\xe3\x69\x86\x3e\xb3\xe7\xb7\xc5\x67\xce\x3e\x7d\xee\x62\xef\x21\x95\x25\xca\x4e\xbd\x77\xee\x5b\x2c\x5e\xb5\x2c\xbc\xd6\x00\x47\x36\x1e\x3c\xf7\x19\x58\x07\x1e\xdd\xbf\x5a\xb3\x55\x77\xe5\x23\xb1\x5e\x1c\xf6\x36\x96\x03\xd7\x28\xc4\x91\x1c\x16\x14\x73\x5a\x79\x4e\xa7\x87\x7a\x0e\x0a\x56\x23\xfa\xa7\xde\x44\x21\x7f\x87\x92\x13\x9e\xd5\x69\xb1\xa0\x4c\x53\x20\x15\x68\x62\xfd\x80\x23\xdf\xf6\x80\x05\x55\x8b\xda\xf6\x77\xde\x9e\x9d\x55\xec\x17\x27\x9f\x8e\xff\xfd\x03\xf0\x24\xe8\x5f\x3e\x83\x5d\xd1\x2a\xb2\xc4\xde\xca\x53\x14\x7f\x22\x7e\x9c\xee\x06\x2b\xe2\x23\x68\xc3\xc0\xae\x94\xcc\xef\xc7\x2e\x65\xdf\x23\xb7\x11\x7e\x4e\x65\x53\xdb\x02\x1a\xb5\x9a\xf6\x07\x04\x67\xbf\x98\x00\x38\x4a\xe6\xf7\x83\x72\xf1\xb4\xe4\x6b\x57\xe7\x37\x83\xc9\x68\xce\x1b\x07\xda\xd3\x18\x90\x1f\x4f\x0f\x30\x80\xeb\x08\xe4\x40\x9e\xbf\xd7\xc8\xda\x05\xe3\xfb\x76\xee\x36\x22\x22\x76\x1e\x76\xb2\x39\x95\x1c\x1c\x1c\x1b\x5b\x34\x6c\x5e\xfb\xfa\x6b\xfd\x7f\x3c\x81\xe5\x6c\x8f\x74\xe8\x6e\xa2\x3b\xba\x46\xb3\x8d\x5a\x8e\x56\xa8\x75\x3a\x05\xe4\x18\x93\x59\x63\xa4\x8c\x75\x31\x25\x45\x21\x1d\xa7\x1d\x8e\x02\x1e\x06\xa2\x28\x27\xf3\x3a\xa2\x39\x10\x2d\xd6\x2b\x81\x04\x69\x5a\x00\xff\x5d\x06\x02\xed\x69\x0d\xe8\xd7\xf8\x23\xfc\x4e\xdc\x09\x56\x89\x1a\x71\x3c\xac\xbf\xb6\x0d\xec\x10\x87\xc1\x02\x70\x6c\xcb\x32\xb1\xcd\xa2\xf8\x2f\x5b\x56\xd1\x4e\x2c\x4f\x21\x8a\xe9\x8f\xa1\x33\x6c\xc4\xf6\x46\x45\x2b\x90\x48\x1c\x54\xe8\x30\x0e\x2e\x12\xa7\x26\x21\x4e\x4d\xcc\x20\x48\x84\x77\x37\x15\xe7\x66\xd2\x14\x82\x65\x40\x17\x7f\x18\xb6\x11\x7f\x46\x8e\xf3\x70\xf1\x2b\xfa\x64\xe3\x2c\xe0\x16\xff\x4e\x8f\x01\x5d\x96\xd5\x8b\xc7\x17\x89\x7b\x97\xd5\x93\xb2\x19\xbc\x8f\x50\xd0\xb8\x15\xcd\x8f\x93\xba\x35\x1a\x06\x2c\x6b\x55\x2b\x28\x23\xcd\xf3\x94\x1a\xba\x5d\x0a\xa4\xf6\x8c\x0a\x05\xda\x5b\x66\xa4\x6b\x59\x74\xd8\xf1\xed\x4d\x9a\xae\xc5\x32\x55\x64\x14\x0b\x47\x64\x57\x0e\xcb\xc4\x48\xd0\x8d\xc1\xac\x9c\x72\x53\x00\x9f\xc7\xac\x7c\x00\x76\x81\x5f\x1b\x3f\x81\x7f\x89\x78\x7d\x3d\xab\xc4\xbf\x1e\x7b\x47\xfc\xbe\xdf\xae\xe9\xc0\xf1\xcc\xdb\x62\xfc\xb7\xae\xf4\xef\xe0\xea\x96\x9d\xa2\xd5\x24\xbe\x2f\xfe\x7c\x48\xfc\xf1\x91\xc7\x9f\xed\x26\xfe\xeb\xfb\xf7\x3f\xfc\x56\x92\xb7\x0b\x92\xf7\x59\x22\x2f\xf2\x9e\x1d\x82\xc0\xa0\x20\x4f\xa3\xd5\xda\x29\x23\xe3\x72\x0b\x0e\xab\x63\x78\xcc\x02\xea\x62\x1a\x8b\xc5\x60\x85\x06\x64\x22\x0c\x52\xf8\x64\xaa\x40\x82\x36\x5f\x4c\x72\x22\x42\x41\x06\x03\xb0\xc9\x17\x94\x58\x91\x50\xd9\x58\x8d\x04\x00\xec\xd0\xf5\x57\xb1\x71\xe4\x53\x93\x80\x63\xfa\xae\x7e\xe2\x77\x17\xc4\x26\x14\x71\x66\x03\x85\xa8\x84\x7f\x35\x7e\x02\x7e\xa5\xc7\x7e\x73\x79\xd9\xf9\xf1\x80\xeb\xf6\xec\xe3\xa0\x03\xb0\x5c\x03\x11\x0f\xf8\x6e\xe7\x16\xd1\x44\x64\x1d\x26\x0e\x60\xb2\x98\xb6\xc8\xd7\xef\x12\xcd\x02\x4e\xa7\xd2\xea\xa0\x0d\xc8\x5b\xa6\xad\x28\x7a\x72\x30\xb5\x31\x03\xf2\x36\x5c\x2e\x50\x13\x73\x71\x26\xb4\xe4\xa6\x8c\x48\xef\x06\xf3\x8a\xc2\x1f\x41\xa6\x18\x49\x5e\x41\x4a\xb9\x7e\x24\x30\xfc\x35\xde\x03\xcc\xed\xbb\xe5\x74\x6d\x7d\xed\xb2\x8d\xa6\x23\xb6\xa6\x0f\x57\x5c\x9e\x76\xf9\x94\xb8\x0a\x4e\x81\x87\xc4\xd9\xab\x8f\x6f\x1c\xfa\xc4\x1d\x33\x16\xe8\x4e\xbe\x30\xff\xcb\x65\x67\xe3\x0e\x70\xcf\x11\x69\x4e\x7b\xa3\x39\xf5\xa1\x3d\x99\x8b\xec\x4a\x3e\x32\x7a\xb9\x94\xc1\x65\x37\x85\x2c\x4a\xa5\xc9\x45\x31\x79\x2d\x6c\x16\xc1\x52\x13\xb3\xa3\xdd\x19\x32\xd8\xed\x50\xe0\x72\x21\x0c\xd7\x90\xc0\x94\x18\x7f\x3c\xb7\x19\x93\x9b\x6e\x57\x58\x9c\xa0\xc6\x42\x26\xf1\xe4\x65\xd2\x41\x9c\xf3\x95\x5d\x51\x6b\xc4\x5f\xce\xf8\x72\xc5\x5f\xde\x5d\xfa\xe1\x98\x01\xeb\xf7\x3f\x31\xf9\xa5\xb3\x60\x54\x7c\x25\xb2\x82\x53\x8f\x3c\xdb\x67\xe9\xe1\xfa\x11\xa5\xcb\x97\x00\x53\xc7\xd1\x9b\x0f\xf4\xac\x1f\xda\xe7\xde\xde\xf9\x79\xb5\x95\xb7\xb6\x5b\x06\xf2\x96\xdf\x27\x9e\xd6\x2f\xbb\xaf\xef\xf8\x6e\xf9\xc1\x82\x0e\x45\xdd\xfb\xca\x9c\x58\xb7\xa1\x73\xaf\x43\xfe\x7f\x16\xd5\x3b\x9a\xeb\xb6\x30\x46\xb4\x49\x5c\x3e\xca\x67\x44\x1e\xa8\x35\x8b\xca\xaa\x8b\x99\x29\xca\x6b\xf0\xba\x86\xc7\xbc\x26\x8d\xc1\xa0\xac\x8b\x19\x32\x43\x81\xeb\x4e\x9b\x5c\xc3\x13\xb8\x1e\x15\x1f\x05\x2d\x06\xa8\xc4\xc7\x0f\x85\x0b\x81\xdb\xe8\x9a\x5b\xbb\x2f\x99\x39\x65\xbd\xfe\xb8\xe5\xf7\x17\xdf\xff\x6a\xd6\x0a\xf1\x87\x0e\xcb\x66\x8f\x72\xd2\x9f\x35\x0e\xc9\x1e\xbf\x68\x85\x58\x43\x5f\xbd\x65\x79\x9f\xa9\xf3\x66\x4f\x32\xee\x3f\x77\xfe\xb9\xb5\xeb\x96\x54\x4e\x9c\x38\xb5\x7a\xd3\xdc\x41\x8f\x2c\x99\x2c\xc9\x1f\x43\xf1\x4b\x18\xed\x73\x17\xd5\x39\x9a\x65\xd5\x53\x76\xa3\x59\xa9\x50\xa0\x30\xd1\xe3\xb6\x99\x71\x03\x83\xdd\x88\x42\x2c\xb4\x1a\x16\x08\x35\x75\x31\x68\x4e\xd6\x5c\x5c\xbf\x12\x24\x33\x43\x65\xf0\x8b\xe7\x23\xed\x4f\xfc\xa3\x48\x09\xc3\x84\xc5\xdf\xbf\x3f\xf3\x47\xf0\x68\x68\xfd\xa4\x75\xbb\x0e\x3e\xf6\xd5\x93\xf0\x56\xd1\xd9\xfb\x1b\x00\xc1\x67\x3f\x88\x7f\xbe\xf8\x84\x30\x67\x5a\xc3\x93\x3b\x76\x80\xd7\xb7\x6c\x11\x2f\x36\x4a\xf2\x15\xa0\xf8\x64\x38\xda\x33\x0e\xac\x57\x55\x94\x41\x03\x05\xd6\x62\x81\x06\xe8\x72\xe2\xbb\x74\x41\xa3\x31\x2a\x8c\x76\x14\x9f\x58\xd5\xac\x02\x19\x02\x05\xd7\x6c\x72\x9b\x6d\x6f\x24\x62\x69\x20\x24\x09\x25\x48\x08\xfc\x49\x81\xe9\x03\xe2\x27\x7b\x9f\x84\x3a\xb1\x63\xeb\x37\x3e\xbd\xf8\xfc\xd3\x17\x83\x87\xf4\xf3\x87\x7e\x09\x06\x5c\x04\x4b\x96\x2f\x17\x8f\xed\x3a\x78\x7a\xe7\x01\xdd\xb0\x69\x58\xae\x2c\x24\xd7\x46\xf6\x0b\x14\x5d\x77\x8c\x06\xed\xda\x1c\x00\xb2\xfc\x46\x7f\x0b\x2d\x93\x9f\x17\x06\x54\x30\x84\xc2\x0d\xbb\x21\x27\xc4\x19\x04\x74\xde\x0c\xd6\x04\x86\x93\xa9\x22\x89\xf5\x61\x4b\x4b\xbf\x49\x64\x3e\x4c\x73\x1a\x1f\x3a\xa7\x40\xe6\x04\x2b\xc7\x55\xba\x43\x02\x7d\x7b\x2e\xbc\xb3\x5b\x89\xeb\xdc\x45\x99\x9b\x7d\xde\xd8\xac\x6e\xe3\xba\xec\x99\xb7\xf0\xc1\xa3\xcf\xc1\x63\xe3\xfa\x77\x6e\x65\x0a\xe6\x95\x74\xea\x5b\xbe\x71\x2f\x21\x66\xaf\x19\x5c\x5c\x9d\xe7\x33\xe7\x6f\xad\x9f\xbd\x10\x0c\xe9\x2d\x0e\x5a\x28\xe5\x06\x06\x32\x2e\xa6\x17\xc5\x23\xed\xd6\x26\xea\xb6\x69\x58\x16\xad\xb8\x82\x72\xb9\xb5\x06\x9b\x8d\xa9\x89\xd9\x04\x83\x19\x59\x06\x5e\xc9\xa5\x67\x59\x9a\xa3\x66\xd2\x0c\x8b\x03\x69\x99\xf2\xde\xaa\xe4\x03\x38\x81\xd8\x9e\x66\x5c\xeb\xc5\xd7\xc5\xab\x0d\xfb\x34\x4c\xcb\xbd\x13\x5f\xb9\x74\xba\x89\x5a\xb5\xfa\xdc\x37\x13\xe9\x89\xbb\xc5\x9f\x3e\x1c\x25\xbe\xcf\x7e\x39\xe6\x96\x11\x75\xbf\x7d\x0b\xfa\xbe\xf5\x5e\xfc\x97\x1e\x47\x3e\x42\xf3\x79\x18\x4d\xea\xa8\xff\x76\x2f\x71\x38\x71\x2f\x41\x53\x47\xd1\x3f\x36\x4b\x7c\x59\x94\x3f\x6a\x80\x14\xa3\xa4\x94\x2a\x35\xfa\x56\x02\x9d\x20\x83\x9a\x5f\xfa\xeb\xe8\x9e\x6d\x7b\xf0\x2f\x90\x5f\x01\x14\x3a\x02\x4c\x25\xc9\x7b\x23\x3f\x97\xa3\x54\x8c\x4e\x67\x04\x7a\x34\x1b\x7a\x0a\x5a\x04\xa5\x99\x32\xe3\x0e\x32\x2d\xc7\x73\xc3\x31\xaa\x13\xfa\x8b\xd6\x9b\x48\x9d\x8f\x94\xcd\x93\xce\x6d\xa6\xe9\x4e\x11\x5b\x48\x64\x1a\x81\xf4\x52\xf1\xc9\x60\xf9\x21\xb0\x52\x9c\x8c\xff\x3e\x24\x4e\x05\xcb\xc5\xa9\x8c\x02\xbc\x2a\x56\x6e\x12\xdf\xdc\x24\xd6\x81\x1d\x9b\x40\x29\x8a\x71\xf1\x05\xf7\x5c\x52\x93\xc1\x24\xfa\x50\x34\x63\x95\xe5\x3c\xc1\xbe\xe1\x73\xa8\x76\xec\x6b\x52\x4d\xa4\xe2\x17\x30\x8a\xd2\x34\x40\x0c\xa9\x91\xc2\x3d\x51\x8f\x60\x2f\x25\x9f\x1d\x96\x7c\xb6\x1b\x9a\x37\xf4\x2c\xae\x16\x4e\xf5\x57\x29\x45\xf2\x6c\x57\xe9\x59\x66\x94\xf4\x2c\xf3\x95\xf4\x6c\xab\x56\xc9\x67\xf7\xa1\x67\xbf\x21\x35\xbe\xc8\xb3\xc0\x3d\xde\xcc\x5c\xb9\x87\x65\x90\xc2\x4f\x6a\xf1\xa5\xcf\x7b\x31\x5f\xc8\x3d\xc0\x83\xa0\x29\xd1\x13\x8a\x3f\xc7\x18\xc3\xd2\xef\xa8\x0b\xc9\xef\x14\x4b\xbf\x83\xe5\x93\x7e\x47\xc9\x90\xe7\xa5\xcf\x7b\xc9\x9f\x2f\x41\xfe\xdf\x4e\xf2\x79\xad\xfc\xfb\xa3\x6e\x84\xb3\xae\xa6\xc0\x48\x2a\x0d\x67\xdd\x02\x2d\xce\x1b\x60\x49\xa5\xb0\x43\xeb\x13\x38\xa0\x04\x3b\xb4\xf4\x78\xd3\x27\x18\x4b\xca\x95\x51\x37\xfc\x01\xc1\x36\x48\x62\x5b\xab\x31\x44\x51\x12\xdb\x5a\xc9\x28\xf5\x00\x66\x3c\x5f\x8f\x9e\xf7\xe1\xf9\x54\x97\x48\x7d\x34\xe8\x83\xae\xcf\x4a\xb0\x88\xca\xe3\x4d\x3f\x47\x0b\xc8\x57\x7c\xa4\xfd\xb6\x89\x63\xfa\xa0\x3f\x68\x1f\x07\x28\x0e\xb7\xe2\x1e\xe6\x5e\xe0\xae\x70\x8a\xd5\xdc\x0e\xf2\xaf\x3f\x71\xec\xa4\xc9\x84\x9b\x54\x7a\x41\xd3\x75\xb8\xcd\x68\xcc\xe7\xa5\x31\x10\xd8\x66\xef\xf1\xa6\x3f\x1a\xbc\x59\xaa\x1b\xe1\xfd\xa5\xf0\xfb\xea\x93\x3d\x7a\x04\xbf\xcf\xc9\x36\xeb\xa1\x6b\x86\xf3\x8b\xde\xb1\x56\xaa\xbb\x25\x30\xbf\x36\xdc\xf3\x69\xf3\xb0\x7c\xc6\x3b\xa4\xfa\xf8\x4b\xc9\xfa\xed\x7a\x19\x87\x50\xc2\x6d\x43\x72\xfd\x8c\xe4\x72\xde\xa8\x3e\x3e\x3f\xf9\x9e\x08\x7d\x15\x7d\xc7\x1b\x35\x42\x1a\x48\x00\xd1\xc0\xa1\x75\xd8\xa4\x37\xc9\xe5\xcf\xc9\x5a\x7c\xc5\x38\xe9\x5d\x68\xcf\x8e\xc5\xeb\x28\x61\x0e\x01\x3b\x55\x1d\xcd\x86\xdb\xc3\x80\x0f\xfb\xc3\x45\xe1\x68\x98\xa9\x09\xd7\x85\x27\x86\xe7\x85\x77\x84\x0f\x87\x15\x61\x09\x12\x0e\x36\xc7\x84\x93\x7e\xbc\x70\xd8\xa4\x61\x72\x8d\x79\x73\xd9\x4a\xd3\x64\x0b\x04\x88\x6c\x3e\xad\xcf\x73\x13\xd9\x1a\x9b\xcb\x46\x4d\x07\xfb\x90\x6c\x2d\xd0\xf7\xb7\x87\x2f\x84\xe9\xff\x26\x47\xd9\x8d\x64\x28\x4b\x93\x21\x2b\x8b\xc8\xe0\xd4\x3a\xad\x37\x91\xe1\xfb\xeb\xe6\xa7\x9e\xfa\xc7\xff\xb7\x0c\xad\xaf\x9f\x07\x97\xd6\x15\xf8\x5f\xcf\x43\x27\x6a\xe2\xff\x4d\x06\x19\x83\xcb\x46\x6a\x92\x1c\xf8\x76\x92\x72\x38\x74\x66\xa5\x51\x67\x74\x39\x4d\xc8\x44\x99\x4c\x9c\x9a\xb3\xe2\x22\x4c\x85\x1a\x77\x1e\xaa\xf9\x66\xd6\xbf\x79\x61\x68\x0a\x99\xd6\x64\xe4\xe9\x90\xdf\x58\x66\x93\x7c\x5c\x78\x9b\xdc\x46\x08\x06\xff\x74\xed\xda\x3f\xc4\xd0\x09\xa9\x5f\x90\xee\x44\xfa\x05\x01\x25\xfe\x5d\xfc\x5a\xfc\x15\x45\x37\xd5\xf6\xa5\xb8\x45\x30\xa1\x83\xc8\xfc\x64\xc9\x7b\xf8\xb0\x34\x3f\x0c\x44\xa7\x8b\x0d\xa3\x3f\xac\xac\x55\x26\x88\x48\x9b\x1f\x09\x27\x78\x9c\xa4\x8b\xc8\xfc\xfc\x9c\xe8\x5d\x41\xf3\x13\x88\x5a\x99\xea\xaa\xed\x55\x34\x5f\x55\x54\x15\xad\x5a\x5d\xc5\x54\x49\xb8\xc3\xd2\xb4\x4c\x1a\x96\xc2\xeb\x4b\x7b\x77\x39\xfd\x34\x25\xe3\x66\xe2\x26\x16\x48\xdb\x14\x36\x7b\x33\x1e\x88\x66\xef\xa5\x37\x83\x82\xa6\xc3\xe4\xbd\x7f\x93\xde\x0b\xe7\x96\x83\xea\xf2\xed\xe5\x34\x5f\x5e\x54\x1e\x2d\x87\xe5\x04\xb7\x18\x7f\x1d\xbd\x76\x12\x79\x2f\xe1\x80\x20\xfd\x39\x4b\x24\x99\xe1\xa7\x04\x1f\x8c\xb6\x5a\x49\x53\x24\xe8\xd4\x60\x6b\x8e\x35\x4e\xf0\x8d\x49\x8f\xce\x3e\xe9\x3b\xf4\x60\x49\x07\xc1\x76\xed\xd0\xfa\xb7\x77\xb5\xaf\x36\xe5\x24\xbf\x21\xd5\xb7\xf8\x91\x4f\x1d\xa6\xc6\x46\x2b\x40\x76\xb6\x4d\xa5\xd0\xc0\xb0\xd7\x68\x0c\x6b\x60\x6e\x8e\x3a\x4c\x85\xeb\x62\xc8\x36\xa2\x28\xba\x0f\x05\x38\x06\x68\x91\xf5\xa7\x18\xbd\xc5\x82\x9c\x6c\xbb\xdd\xc2\xe8\x03\x28\x8a\x4c\x24\xce\x0a\xd3\xe9\xfc\x86\x35\xeb\xe6\x4a\x2f\xb7\x0c\x90\x32\x97\x88\x10\x12\x14\xe9\x97\x8b\xca\xcc\x4a\x18\xd8\x13\xec\xc6\x35\x2e\xf3\xe6\xa5\x57\xb9\x7c\x07\xb2\xfa\x3c\x9b\x51\x06\x33\x14\x3c\x3b\x6e\x87\xf8\xdb\x82\x58\xaa\xc6\x65\xdb\xa1\xd6\xe9\x05\x30\x46\x2a\x71\xef\x75\x37\xd3\x03\xf9\x91\xad\xa9\xbb\xa3\x6d\x8a\xad\x8c\x2e\x0f\xe6\xb9\x51\xa4\x90\x95\x05\xad\xb0\xbc\x0d\x43\xe5\x10\x2a\xd3\x2c\x9d\x39\x6a\x2e\xad\x89\x99\xa3\x6a\x43\x37\xb3\x99\xf2\x73\x8e\x82\x9a\x98\x83\x27\x34\xf5\xae\xf4\x8b\xc6\x42\x19\xe0\xb4\x24\x49\xb8\x95\x74\x4d\x4c\x15\x72\xa9\x6c\xc2\xc9\xc4\x9c\xa5\xe5\x65\x52\xda\xcd\xc8\x13\xe2\xd9\x08\x0a\xf3\x22\xc8\x91\x43\x33\x61\x00\xe6\xd2\x04\xed\x2e\x2e\x96\xc9\x7a\xfa\x5d\xef\x33\xa6\x59\xa3\xc6\xcc\xb0\x23\x27\x66\x07\x4d\x47\x8e\xdc\xf7\xea\xf3\x6f\xbc\x31\x65\x7f\x01\xad\x62\x9e\x50\xcc\x5d\xee\xbb\x5c\xdb\x6d\x41\xff\xa5\x73\xee\x5b\xb9\x60\xbb\x38\x68\xd9\x3c\x67\x8f\xda\xc1\x43\x17\x94\x5d\xbe\x7b\xcc\xbf\x80\x02\xa8\xfe\x1a\x33\xc2\xbb\x4e\xd9\xfa\x40\xe3\xf3\x0b\xb6\x6d\x87\xbf\x4c\x3f\x30\xa4\xe1\xb5\xd7\x9e\x7c\xf5\x7a\x3c\x32\x64\x77\x3e\xa4\xd2\xf0\xc8\x82\xde\x60\x2e\x65\xff\x0f\x78\x64\xf5\x09\xbc\x71\x02\x47\x56\x72\xbc\xe9\xab\x86\x74\xc4\xb0\x64\x3f\x6f\x35\x79\x47\x81\xfc\x8e\x28\x95\xe2\xdc\xe0\x8e\x37\x6d\x6c\xe0\x04\x56\x9b\xf1\x1d\x52\x13\xa2\x34\x25\xb0\x4c\xd4\x14\x75\x8e\xb2\xa4\x7f\xe7\xad\xeb\xbf\x33\x42\x1c\x40\xee\xc0\x89\x9d\xe6\x71\x3f\xd3\x78\x19\x2b\x6c\x00\xae\xaf\x94\x6c\x31\xfe\x1c\xf7\xb5\x26\x9e\x4f\xf4\xdd\xa3\x73\x49\x9e\x27\xbd\x6f\x17\xa5\xbe\x5a\x58\x84\x4e\x74\x11\x55\x54\x98\xc9\xe3\x40\x7e\x2f\xd1\x7f\x8f\xbf\x87\x7f\x8f\x9c\xe7\x5f\xa4\x1e\x1f\xd8\x12\x1d\xaf\x96\x54\xcb\xfc\xcc\xfe\x5a\x92\x8b\xc1\xf3\x80\xf1\x37\x93\x3d\x97\x78\xae\xb1\x23\x01\xbc\x4a\x6f\x56\x06\x56\x63\x67\xb4\x47\xb5\x78\xae\xe9\xfe\x69\xf8\x72\xf8\x79\x8f\x07\x19\x78\x9f\xde\x97\xad\x57\xa4\x9e\x6f\x5a\x2b\x0e\xa2\x73\xf1\xf3\xe0\x4f\xc9\x0f\x5a\x9b\x60\xbc\x40\x4f\xf3\x83\x78\xab\x42\xd7\x7c\x5d\x34\x63\x89\x4f\x98\x43\x7c\xbc\x76\x09\x9f\x90\xf8\xb2\xa9\xcf\x87\xc9\x9f\x4b\x7e\xab\x8c\xeb\x88\x3f\x97\x7d\x42\x69\x0f\xfd\x94\xc4\x6c\x13\xe9\xae\xb2\x9c\xd8\x62\x02\xff\x70\x7f\xe8\x06\x7b\xe8\xcb\xc4\x1e\x42\x76\x7a\x9c\xec\x1b\x61\xb5\x47\x17\x8d\x2a\x4a\x47\x6e\x03\xc4\x07\x7e\x81\xf4\xb7\x8c\x88\x3a\x15\x6a\x1b\xc5\x59\x4d\x26\xb3\x99\x53\xa3\x60\xd4\x8a\xc2\xe4\x1a\x2b\xb8\x62\xc5\x1d\xd3\x9f\x47\xdd\xe6\xee\x33\xad\xf5\x56\x9a\xb3\x02\x15\xb4\x5a\xcd\x76\x0b\x34\x9b\x74\xb0\x2e\x86\xac\x57\x22\xa8\xaa\x96\xdb\x37\x87\x49\x5d\x3d\xcd\xd2\x45\x69\xe5\x5e\x24\x25\x4e\x2e\x2d\xd1\x3f\x23\xac\x7f\xfa\xbc\x79\xd3\x9e\xf9\xfb\xf9\x37\xbf\x8d\x2b\xce\x9c\xa1\xff\x3a\x03\x96\x3e\xbc\x60\xfe\x3a\x5c\xe2\xf5\xf4\x3b\x6f\x1e\x01\xa1\xf8\x14\x76\x7e\xfc\x49\xbc\x58\xf8\x0e\x75\x10\xb3\x09\xe9\x52\x03\x8a\xf5\x2a\xa3\x1e\x9b\x1a\xc5\x7a\x1c\x89\xf5\xd4\x36\x9d\x8d\x19\x1e\xb3\x99\x74\x26\x5c\xfc\xa9\x84\x2c\xbe\x3b\xbd\x79\xb4\x47\x11\x70\x1d\x41\x8a\xf5\x12\x70\x19\xad\x29\x13\xb3\xe9\x73\x71\xe1\x7b\x67\x8e\x57\x9f\x9e\xf0\xd9\xd5\x97\x56\xaf\x19\xbe\x69\xe0\x2e\x10\x3a\x00\x1f\xfb\x48\x6c\x2b\x3e\xd6\x4d\xfc\x5d\x99\xb7\x7b\xf0\x88\x3f\xff\x7c\xfc\xe9\x3b\x0e\xdc\xd1\x38\xad\x12\xb4\x02\x0f\x51\xd4\x8d\x30\x51\xe2\x04\x1f\x18\x9d\x2d\xb3\x59\xc2\x17\x79\xba\x81\x37\x2b\x32\xfd\xc6\x25\xa4\x56\x89\xe0\xa2\xc8\x3e\xc5\xd3\xd2\x77\xfc\x7e\x09\x5f\xa4\xa1\xc1\xe3\xd7\xa7\x61\xc2\x62\xd3\x40\x6c\x65\x7b\xe4\x43\xb8\xa8\x5c\x74\xf6\xf7\x45\xc7\x62\x7c\x28\x9b\xd9\xae\x60\x59\x95\xca\x4d\x05\xf5\xfa\x16\x28\xa2\x51\xb3\x0c\xa3\x2e\x2a\x2c\x2a\x5a\x5d\x44\xf3\x45\xd1\xa2\x89\x45\x3b\x8a\xde\x29\x62\xb9\x22\x64\x61\x5a\xb4\xe0\x79\xdf\x8a\xd8\x44\x7e\x1e\x4f\xf3\x7c\x78\x6e\xfe\xf6\xfc\xa7\xf2\xcf\xe4\x33\xf9\x51\xb5\xae\x5b\x5d\x3e\xc8\x57\x28\xed\x3e\x1b\xb0\xd9\x54\x66\x0d\xac\x0e\x03\x0a\x79\x9d\x74\x18\xfd\x3c\x55\x18\x29\xc4\xf4\x8b\x11\x42\x2f\x1d\x79\xab\xa4\x10\xad\x37\xfe\x57\x29\xb9\x29\xb5\x97\x49\x1d\x40\x32\x98\x51\x89\xd1\x24\x5f\x2d\x01\x8c\x2c\x17\x82\x98\xf9\x88\xa4\xdf\xd0\xcc\x43\xa5\x01\x60\xac\x93\x9c\x24\x08\xb9\x0d\xed\x13\x58\x56\x1e\x11\x58\xb8\xad\x6d\x01\xed\x79\x69\x67\x7c\xce\xae\x57\xe9\xac\xe2\x76\x2b\x47\x8d\x5a\xf9\x2f\x35\x5f\xf6\x1c\xcd\x3d\xe3\xf2\x8c\xed\xdd\xa6\xa2\x77\xb7\xd6\xea\xca\x9e\xbf\x7f\x74\x41\x7c\x9d\x9d\x58\x3e\xc2\x7d\xad\x33\x98\x22\xae\x60\x9e\x73\x8f\x6c\x73\xdb\xdc\x79\xe2\x7e\x7b\xf1\x22\x71\x00\xd8\x55\x55\x03\xba\x97\x74\xed\x5a\x52\x78\x2b\xec\x01\x2a\xf9\x67\x6c\x87\x52\xbc\x08\xa4\xa7\x55\xf2\x1f\xb6\x00\x4b\xd3\x00\x72\x6e\x46\x82\xdb\xa8\x8e\xc8\xdf\xf6\xf5\xae\xee\xdd\xa7\x37\x3c\xd3\x1b\x50\xbd\x27\xf6\x9e\xd7\xfb\xa7\xde\x4c\x6f\x48\x77\xe9\xc2\x87\x99\xee\xce\xee\x3d\xa1\x33\x9b\x90\x20\xbc\x97\x22\x41\x90\xd7\x09\xb9\x7b\xc8\xc1\x48\xfa\x17\x3f\x25\xfc\x0b\x95\x08\xbf\x94\x30\x17\x50\xf8\x41\x0b\x18\xa8\x48\xb0\x33\x86\x14\xe6\x82\xe4\x5b\x7c\x99\xf0\x2d\xa8\xe9\xf4\x53\xb2\xee\xab\x42\xba\xaf\xaa\x7b\x55\xb5\x29\x9c\xae\xfb\x08\xef\x0b\xf9\xfd\x47\x65\x1d\xd1\x43\x7e\x3e\x1b\xe9\xd8\xec\xee\xd9\xb9\x2a\x53\xfa\xf3\x04\xeb\x9b\xfc\xfe\x09\x59\x47\x1c\x91\x9f\x0f\xa1\xdf\x0f\xdd\x1e\x0a\x2b\xf9\xf4\xe7\xa5\xbd\xd6\x3b\xe1\x97\xd1\x17\xe9\x3b\xc0\x58\x89\x03\x02\x2b\x57\x88\x21\x18\x8e\x37\x38\xac\xe9\xae\xd9\x0d\xb8\x30\xe8\x8b\xe0\x0a\x25\x73\x47\x54\xe1\x91\xd0\x15\xc7\x9b\x1e\x68\xa8\x68\x2d\x85\xa8\xcd\x70\x9b\x95\x59\xc9\xf7\x5d\xa2\x9f\x42\xef\xc3\xb8\x96\x38\x26\x74\x33\xee\x66\xfc\x64\xd2\x7b\x4e\x24\xdf\x73\x89\x6e\x2f\xcd\x2f\x7a\x09\x5d\x75\xbc\xe9\xa3\x86\xaa\xd2\x44\x18\x9c\xc4\x51\x25\xe3\xc9\x95\xc7\x33\x55\x1a\x0f\xc6\x93\x26\x4d\xc4\xc7\x9b\x76\x35\x58\x8c\x40\x7b\xfd\x78\xd2\x38\x11\xd0\x78\x7e\x4d\x8c\x27\x3b\x1b\x8f\x27\x78\xbc\xe9\x54\x43\xd0\xa7\x6b\x86\x43\x2d\xbd\x2f\x2b\xf9\xbe\x4b\xf4\x3b\xe8\x7d\xd6\x67\x80\x4d\x0a\x3f\xe3\x0d\x36\x0e\x68\x53\xf2\x49\xef\x39\x91\x7c\xcf\x25\xba\x52\x5a\x1f\x1a\xbd\x85\xce\xa6\xb3\x3d\xba\xf4\xf5\x6c\xc2\x84\xaa\xe3\xc9\x78\x24\xfc\xbf\x8b\xd4\x77\x89\xf1\x70\x1c\x1e\x8f\xee\x78\xd3\xdb\x0d\x3a\xb5\x14\xda\x27\xe5\x6a\x42\x9a\x89\xbe\x2d\xc9\x8f\x80\xbf\x77\x99\xa2\x12\xdf\x33\x4a\xdf\x3b\x75\xfd\xf7\x08\xf7\x41\x0d\x19\x8f\xf4\xbe\x4b\xa0\xa5\xb4\x3e\x80\xc3\xfe\x03\xc7\x29\x13\x49\x04\x49\xbe\xbf\xd0\xf3\x1d\xc9\x78\x7e\x91\x9f\xf7\xca\xfd\xba\xe8\x2d\x80\xa3\x9b\x3d\x2f\x73\x33\xf5\x4e\x62\xf6\x5c\xa4\x5f\x4d\xec\xb7\x70\x18\xef\xb7\x10\x86\x46\x0e\xf9\x33\x78\x96\x9a\xae\xe3\x01\x48\x5f\x9f\x60\xd0\x28\xf1\x33\x9d\x6c\xf0\xb9\x15\xcd\xbe\x27\xbd\x2f\x2b\xf9\xbe\x4b\xd0\x2f\xef\x37\xf4\x36\x3a\xcc\x84\x9b\x71\x4d\x49\xef\x39\x91\x7c\xcf\x25\x3a\x81\xab\x8b\xde\x42\x07\x35\xc1\x66\x7c\x03\x04\xbf\x84\x8c\xa7\x4c\x1e\xcf\xf8\xc4\x78\x82\x41\x99\x37\x6a\x34\x92\x8b\xcd\xc4\x73\x6f\x3a\x83\xe6\xed\xc5\x14\xf6\x0a\x1a\x4f\x34\xb1\x3e\x3e\x1f\x5e\x1f\xf7\xf1\xa6\xe7\x1a\xdc\x0e\xa8\xbf\x6e\xbf\xa1\xf7\x65\x25\xdf\x77\x89\xcc\x1f\x3a\x0f\xe8\x65\x78\x8f\x9e\x6e\x08\x3a\xd9\x34\x8c\x17\xe4\x99\xd1\x0d\x64\x3c\x03\xe4\xf5\x59\x2d\xaf\x8f\x0f\xbb\x42\x2a\x9f\x0d\x66\x60\xda\x4b\x31\x74\xef\x24\x0e\xc0\x45\xfa\x48\x62\xbf\xe1\xac\x1d\x91\xeb\x02\x92\x4b\x0e\xa2\x93\x72\x8d\x21\x39\x95\x54\x1f\xfe\x45\xf0\x5d\x62\x3c\xe1\x30\x1e\x0f\x5a\xd7\xa3\x68\x5d\x9d\xcd\xc6\x23\xbd\x2f\x2b\xf9\xbe\x4b\xf4\x2f\xf2\x7e\x23\xb8\xb8\x9c\xcf\xc6\x66\xe8\x2b\x29\x77\x73\x22\xf9\x9e\x4b\x74\x09\xd1\x07\x00\xbd\x04\x84\x71\xba\x27\xec\x75\xa6\x8d\xbf\x19\x76\x8a\xea\x4f\xa2\xa7\x30\x76\x8a\xa3\xa4\xcd\xcd\xb1\x53\xd0\x73\x76\x19\x3b\x85\x29\x2c\x4b\xc3\x4e\x69\x86\x6d\x82\x9e\x5b\x21\x63\x9b\x50\x3a\x13\xab\xcc\xc0\x36\xc9\x4b\x62\x9b\xa0\xe7\x28\xec\x44\xec\x8c\x2e\xe5\x02\x60\x30\xcd\x05\x7c\x81\xc2\x00\x9c\x2d\xfd\x59\x1d\xe8\x13\x98\x10\x98\x1b\x38\x13\xb8\x10\xf8\x2c\xf0\x63\xa0\x29\xa0\x93\xfe\xc7\x70\xf2\xf1\xaa\xc0\x76\xf9\x7f\x69\x13\xcf\xe3\x8f\x9f\x92\x9f\xd6\xf4\xf2\xa1\x7f\xa3\x27\x04\x00\x87\x1e\xa3\x55\x54\xa0\x28\x70\x38\x70\x25\xc0\x54\x45\x03\xf3\x02\xab\x03\xd0\x8f\x3e\x78\x07\x7f\x80\x42\x66\xf4\x09\x04\x8e\x5b\x1c\x3e\xa5\x04\x6f\x82\x81\x4d\x52\x10\x27\xc3\x31\xca\x09\xa0\xa2\xe2\x00\xf8\x27\xbb\x81\x0a\x52\x5d\xa2\x01\xb5\x5f\xcb\x79\x3c\x0a\x4a\x6b\xa5\x29\x3a\x2b\xe4\xd7\xaa\xd5\xb4\x43\xc0\xf5\x40\xc3\x63\x0e\x06\x42\x1a\x3b\x0c\xf2\xcd\x27\x66\xe4\x49\xaf\x75\x4f\x74\xde\x00\x1e\x94\x65\x51\x98\xee\x49\xc1\x96\xb5\xcc\xb8\x26\x22\x1d\x0e\x4a\x2f\x80\x7f\x36\xae\x42\x41\xe7\xed\x79\xd9\x87\xc5\xee\x60\x1a\xe8\xb0\xa2\x7e\xca\xd6\xf6\x9b\x06\xfc\xbc\x6f\xf1\x85\x49\x6d\x06\x44\x6b\xc0\xdd\xf1\xab\x62\xd3\xe3\x23\x40\xc9\x2b\xdd\x1f\xcc\x5d\xbc\xe6\xe0\xe4\x9f\xf6\x3e\x54\xdf\x7f\x7c\x9f\xd5\x0b\xef\x3c\x31\x35\xb6\x74\x68\xd5\x51\x2c\x7b\x40\x1c\x08\x0b\x98\xde\xc8\xba\x74\x8e\xfa\x83\x3a\x83\xc9\xef\x57\x53\x06\x07\xa4\x60\x38\x3b\x68\xd0\xe9\xa0\xc7\x6e\xf7\x78\x04\x0c\x62\x86\x19\xd3\x23\xff\x45\xf2\x6c\x0b\xc5\x96\xb5\x87\xd7\x8b\x4e\x4b\x37\x5c\x48\xf0\x02\x71\xa7\xb8\xf4\xe8\x99\x89\xd1\x16\x81\x06\xf1\x6f\x40\x00\xfa\xba\xd1\xa3\xef\x74\x1f\x72\x8d\x79\x64\xe6\x99\x93\x93\x4b\xa2\x07\x2e\x88\x1f\x0c\xd9\x5c\x34\x78\xf8\xf4\xae\x5d\xa7\x79\xee\xee\xb0\xae\xea\xe2\x9a\x7b\x46\x0f\x1c\x12\xb8\x63\x56\x9b\x7d\xcf\x6c\x9b\xdb\x62\x7b\xd3\x75\x18\xcb\x28\xc6\x59\x9f\x19\xeb\x35\x5e\x1f\xb7\x49\x38\xcb\x38\xd6\xeb\x21\x7f\xc7\x80\x62\xbd\x14\x86\xbd\xcb\x1d\x34\x2b\xd3\xe2\x81\xdd\xe2\x20\x16\xb2\xeb\xd1\x33\xc5\x51\x3b\x65\xd1\xab\xd5\x1a\x8b\xc6\x2a\xe8\x79\x0d\xcf\x0e\x8f\xf1\x8c\x16\x6a\x4c\xd7\x97\x5c\x67\x56\x5c\x4b\x4e\x35\x6e\x02\xb3\x0a\x46\xe6\x96\xea\x07\x67\x4e\xf8\xa6\xef\xa9\x93\xb7\x02\xf6\x91\x7f\x7c\x80\x7e\xbf\xff\xec\x75\x9d\xef\xe8\x7b\x0d\x1d\x91\x0d\x7d\x86\xfe\x20\xfe\xf5\x24\xc6\xea\x12\x07\xb2\x53\xd9\x37\xa9\x00\xd5\x8a\xaa\xa0\xee\x8a\x96\x17\x58\x4b\x79\x3e\xd7\xad\xf7\x07\x15\x0a\xaf\xdf\xca\xb4\xad\x74\xfb\x8d\xd0\xec\x74\x96\xa3\x75\x71\x72\x14\xa5\x85\x2a\x55\x3e\x2e\x4b\x36\x17\xd7\xc4\xcc\x66\x08\xb3\xe5\xea\x64\xe9\x82\x3d\xad\x6b\xb9\x30\x22\x75\x7e\xa5\x65\x0d\xd2\x0b\x80\x93\x68\xf4\xe8\x33\x5b\x6b\xb9\xcc\x0f\x13\x90\xe4\xb4\x2e\xcf\x00\xa4\x97\x33\x6d\xe4\x93\x4c\x70\xfa\x06\xba\x43\xd5\xbc\xe5\xdd\x66\xdd\xfa\x5c\x9f\xad\xf7\xce\x1c\x9f\x02\xa8\x87\xaf\x56\x54\x86\xdb\xfb\xbb\xb6\x2b\xad\x4e\xc7\xaa\x07\x67\xaf\x99\xb7\xdb\x16\xdf\xd7\x6f\x52\xfb\x53\xa7\xa7\xed\xaf\xfb\x38\x09\x58\xdf\x38\xa0\xa8\x83\xc7\x52\x73\x7b\x05\x8a\x73\x30\x06\xd3\x7d\x28\xce\xc9\x41\x76\xe9\xf6\x68\x09\x0a\x70\xcc\x0c\xf4\xda\x6c\x05\x7c\x16\x84\xb9\x1a\x5e\x13\x29\x55\x98\x03\xf9\x81\xfc\xba\x98\xd3\x55\x17\x0b\x38\x03\x4e\x3d\xa5\x2f\xae\xc3\x89\xa2\x9c\xba\x64\x15\x4b\xaa\x6d\xaf\x39\xc7\x9f\xb4\x87\x49\x1b\x87\x74\xc6\x04\xfc\x07\xce\x14\xe1\x7b\xf1\x32\xe9\x7a\x5c\x48\x54\xc0\xe2\x0d\x9e\xaa\xe2\xf6\xd3\x73\x3e\xf9\x63\xe5\x9c\x35\x3b\xc5\xef\xfe\x1d\x17\x7f\x3c\xf0\x60\xfd\xfc\xaf\xfe\x56\xbf\x70\xcf\xca\xb5\xdb\xd6\x2c\x05\x1d\x8e\xef\xdc\xf2\xec\x91\xbd\xa0\x2f\xfb\x08\xfb\xca\xae\x07\x9e\xb6\x31\xd6\xe3\x2b\xce\x7e\x7c\xf9\xec\xb2\xe7\x2d\x4c\xf6\xec\x11\x4b\x37\x30\x0b\x98\x7e\xfd\x63\xb7\xcf\x9d\x39\x7e\x2e\xdb\xb8\xe4\x81\xe5\x1b\x17\xcc\xc7\xfd\xe9\xc3\xd1\x98\x5b\xb2\xef\x12\xde\xb0\x9a\x68\x0b\x67\x50\xa1\x67\xbc\x50\xa3\x29\x36\x66\x7b\xbd\xf9\x36\xb4\x40\x65\x4e\x03\xf2\xa3\x72\x6b\x63\xc8\x44\x05\x95\x01\xca\x52\x80\x39\xbc\x53\x25\x65\x85\xff\x61\x94\xd2\x20\xca\x33\x07\x1b\x4e\x1b\xac\x8d\x0c\xd6\x96\xc8\x0e\x95\xa1\x0d\x4d\xdf\x32\x7b\x69\x6d\xf7\xee\xcb\x66\xcd\x9d\xb8\x60\xa3\xd8\xf4\xed\xd7\xe2\xc6\x05\x13\xe6\xcd\x5a\xd6\xbd\x7b\x6d\xfd\xec\x65\x8f\x6f\xde\xb0\xe1\xd1\xee\xcb\xe0\xd8\x25\xb3\x6b\xe7\x84\x26\x75\x3e\x34\x71\xee\x21\x3f\xe3\x3b\xbf\xea\xfd\x6f\xbe\x7d\x6f\xf5\x6b\xe8\x5f\x0f\xcd\x9b\x78\xa8\xf3\xa4\xd0\x9c\xda\x39\x8b\x17\xee\xad\xdf\xba\x73\xd7\x96\x41\xcb\x7a\x93\x7b\xe0\x0e\x4d\x80\xf4\x7b\x9a\xa9\xaa\xa8\x4f\x41\x01\x96\xd3\x68\x58\x9a\x62\x2c\x02\xa5\x30\xe3\x26\xf1\xa8\xd9\xd4\xac\x70\xa4\xda\xf9\x66\xb3\x54\x5f\x71\x51\xb9\x5c\xc5\x42\x94\x4d\x0e\xd9\xab\x81\x0e\xf0\x36\x5c\x54\xd3\xf8\x38\xfd\xc0\x83\xeb\x8d\x9b\x4d\x5d\x7b\x35\xbe\xb0\x8a\x19\xb8\x65\xd9\xb5\xc7\x17\xce\xe9\xd5\x2b\x88\x7b\xd7\x88\x0c\xc5\x4d\x5a\x78\x89\xa9\x44\x32\x54\x46\xbd\x9c\x06\xb0\x0a\xe4\x0c\xb0\x1a\x46\xb0\x60\x19\x6a\x50\x6c\x2f\xb0\xa4\x1b\x07\x26\x2f\xa1\x5f\xfe\x5f\x49\x50\x4c\xaf\xc7\x85\x34\xf1\xb1\xe0\xcc\xc3\x0f\x99\x37\x5b\xba\xf6\x8a\x2f\xaf\x87\xe1\x65\xf5\x8d\x1f\x4f\x9c\xd2\x75\x60\xb0\x38\xa7\xba\x2a\x79\xe7\xf5\xaf\xa4\xaf\xbf\x19\x9c\xc4\x9c\x06\x51\xbd\x44\x82\x61\x52\x98\x2c\x37\xb8\xf3\x7a\x33\xe9\xeb\x6f\x06\xb7\x4a\x39\x32\x92\xde\x28\xc1\x77\x5e\x25\xa5\x99\x77\x5e\x04\xbb\x56\x24\x39\x97\x5c\x92\x5b\xb9\x1f\xbc\x95\xe0\x4f\xc3\x1c\x06\x3c\xf1\xb3\xc9\xe7\x25\x69\xfe\x67\x7e\xf2\x4e\x2a\x02\xfd\xc9\x1c\x38\x76\xd8\xd0\x1f\x7e\xc6\x2f\x3b\x85\x69\x39\x70\xe2\x17\x92\x5c\x74\xdf\x66\x39\xf0\x9f\x91\xa7\x90\x1d\x75\x32\xd8\x36\x57\x23\x53\xcd\xf0\xc8\xde\x46\x91\xe1\x65\x02\x90\x10\xa4\x65\xe4\xc1\x9b\xbf\xbf\x0d\x74\x53\x32\x7e\x63\x0e\x76\x17\x73\xa8\x9c\xc8\x8d\x30\x1f\x3d\x8a\xad\xc9\xbc\xd9\xb6\xb4\x77\xdf\x4a\xf9\xa2\x02\x2c\x2c\x01\x5c\x49\x75\x49\x9f\x92\xe1\x25\x13\x4a\xd8\x12\x82\x37\x49\xd2\xe0\x38\x0b\x9e\x86\x95\x99\xc4\x9a\xa4\x37\xd3\xad\xe5\xb5\xf0\x7a\x71\xe0\xc5\xbb\xbd\x37\xc0\xb2\x7c\x33\xe9\x07\x6f\x06\xb7\x50\x69\xfc\x15\x76\x60\x77\x5e\x8f\x65\x99\x36\xae\x72\x32\x2e\x92\xdf\xc7\x2f\x80\x74\x80\x0a\x04\xd3\x9d\xfa\xeb\xe7\x14\xbd\xa3\x87\x9c\xdf\xff\x39\x91\xdf\xf7\x82\x6a\xef\x76\x2f\xcd\x7b\x8b\xbc\x51\x2f\xf4\x92\x97\x67\xe4\xf7\x25\x4c\xa2\x2d\x09\x4c\x22\x7a\x19\x18\x2d\xe3\x6f\x11\x9c\x1e\x2d\xa5\xd5\xa5\x50\x8f\x92\x98\x47\xfd\x92\x98\x47\xcb\xa8\xd7\xd3\x31\x8f\x1c\x9c\xc3\x99\xc2\x3c\xa2\xe8\xa6\xfd\xe2\x40\xfa\x3c\xb2\x5d\x46\xca\x83\x79\x94\xd0\x53\xbc\x0e\x79\x15\x0a\x85\xcf\xe0\x85\xc8\x8d\xd0\xf1\x10\x6a\x8c\x94\xc6\x55\x13\xd3\x6b\x5c\x54\xf5\xab\x89\x6a\x93\x8a\x7c\x23\xc0\xd9\xec\x48\x8a\xad\xcb\xd8\xcc\x00\x19\xd3\x8d\x0e\x68\xdf\xb9\x6d\xd2\xcc\xcc\xbd\x03\xec\x4e\x1a\x17\xf6\xcd\xbf\xa6\xd8\x13\xf6\xe4\xe8\x40\xf6\x8f\x3f\xeb\x53\x76\x64\x09\xb6\xad\xc8\xdf\xc9\x45\x3a\xf5\xce\x68\x85\x5e\xa5\x52\x17\x3a\x1c\x59\xb9\x2d\xbc\xde\xdc\xb0\x9a\x29\x6b\x9d\x95\xeb\x80\xae\x60\xb0\xa4\x26\xc6\x05\x7d\xc1\xed\x41\xa8\x87\x41\xa3\xa0\x12\x18\xdc\xe6\xa9\xe3\x5c\x2d\x6b\x62\x2e\x97\x0a\x77\xc9\x15\xa6\x08\x3c\x93\x0c\xd7\xb6\x66\x0d\x73\xd2\xa5\xd4\x4d\x7a\xaf\x9a\x0d\x8f\x4d\x37\xa9\x37\x68\xcb\xea\xdc\x76\xf6\xd2\xa4\x59\x05\x3b\x92\xe3\xa5\x0f\xdd\xa0\x59\x2b\x7e\xaf\x7d\xd1\xcc\x84\x49\x9d\x9b\x1c\x7f\xd3\xb1\xa6\xef\xe9\x0f\xd9\x96\xa4\x5f\x6b\x58\xb4\xd8\x69\xf0\xb3\x6a\xb5\xd5\x82\x37\xa8\xc2\xc0\xe4\x84\x2d\x1e\x2d\x46\x32\xd0\x6a\x15\x26\x53\x08\x0d\xd9\x64\x55\x28\x6b\x63\x4c\x54\xc1\x01\xaa\x36\x06\xb8\x04\x34\x5d\x8a\xb1\xac\x59\x7d\x53\xaa\x40\x22\x59\xb1\xfe\x9f\x96\xd1\x47\xaa\xd7\x3b\xb7\x9d\x5b\x9f\x39\xb4\x4a\x7f\xe7\xaa\xd2\x6a\x78\x8c\x40\xd3\x79\xec\x29\xf7\x80\xee\x1d\x8f\xe0\xe1\xf4\xbf\xad\x02\xf7\xe5\xbd\x2d\x0e\x02\xed\x90\xce\xd6\xa1\x73\x6d\xd0\x50\x94\x81\xd5\x6b\x39\xa8\x44\x3a\x5a\xbe\x33\x91\x77\x55\x71\x11\x2b\x75\xde\x49\x38\xe9\xa0\xdd\x8c\x19\x12\x3a\xfa\x43\x9b\x96\xca\xa0\xe8\x04\xe3\xa8\x5f\xd3\x0f\x8a\x57\x92\xbe\xd7\xc8\x68\xeb\x02\x47\xa9\x89\xf7\xf9\x72\xf5\x3a\xec\x7d\xf9\x1d\xb0\x6d\xa5\x5f\x70\x21\xc7\xcb\x65\xb5\x16\xe3\xc6\x3b\x03\x0a\xdb\x4c\x5a\x46\x05\x25\x0f\x2c\xe9\x7a\xa5\x9a\xec\xab\x93\x97\x37\x99\x5e\x57\xe4\xc6\x7e\x57\x26\x79\x98\x10\xca\xf0\xbb\xd8\xb4\xd6\x31\x58\x92\xe1\x77\x25\x61\x65\x7e\x1f\x45\xef\x4e\xb9\x5d\xcc\x1f\x09\x70\x99\x4c\xaf\x2b\x1d\x66\xe6\xa5\xa7\x0e\x25\xbd\xae\x2f\x33\x30\x9f\xfa\x89\x83\x14\xaf\x30\x3d\xd1\x7c\x14\x50\x95\xd4\xf0\x68\x59\x99\xa9\x85\x4b\xa9\x52\x15\xda\x35\xea\x20\x45\xa9\x4d\xb0\x6d\x95\x0f\x0d\xd9\xc7\xdb\x5d\x8c\x8e\xe1\x1c\x9c\x05\x1d\x1d\x0b\xcf\xb5\xc1\xb7\xb6\x6a\x17\xdd\xb2\x79\xe7\x11\x3e\xef\x36\xa9\x82\xf7\xba\xb9\x48\x6b\x41\x2a\x0f\xa5\xcf\x0b\x66\x14\xb9\xbe\x0f\x29\x3b\x6d\x32\x14\xaf\x24\xc8\xd4\x98\xd2\x0d\x0f\xbe\xfd\x02\x58\x39\x7b\x6b\x19\x73\x38\xbd\x33\xa9\x7e\xe3\xe2\xfb\xe3\x79\x4b\x37\xd4\xcf\x98\xb1\x78\xf3\x12\xda\x1f\x7f\x93\xf4\x28\x81\x1f\x46\xdf\x35\x00\x4d\x8c\x95\x6e\x3d\x78\xd4\x81\xc3\xe9\x7d\x4a\xe7\x5e\xf9\xf9\xd2\x9b\x6f\x7e\xf6\xf9\xcb\x1f\x91\x3c\x73\xd3\x7a\xb6\x2f\xfb\x1d\xe1\x22\x76\x50\x6e\xa4\x3f\xca\xa1\x8d\x57\x29\xcd\x76\x0e\x19\x2e\xce\xcc\xeb\x58\x46\xa3\xd5\x6b\x19\x05\xe3\xf1\x3a\x00\x8a\xf7\x1c\x06\x83\x7b\x78\xcc\xa6\x56\x1a\x0c\x0a\xa5\xd2\x5c\x17\xd3\x28\x21\x43\x61\xaa\xe2\xc8\xab\x48\xf5\x49\xc7\xc7\x54\x51\x91\xd9\x74\x60\x4a\xbb\x29\x28\x29\x2e\x0a\xc0\x00\x08\x95\x87\x40\xc4\x66\x8e\xa8\xe9\x88\xb9\x00\xe4\x28\x15\x4a\x9b\x32\x02\xcc\x21\x66\xd5\x4e\x71\x92\xf8\xe2\xae\x0e\xcf\xd3\xd5\x1f\xdd\xf9\x3f\xbb\xc4\x17\xc1\xaa\xc6\xfe\x93\xe2\xad\x5b\xb2\x6a\x47\xf1\x9f\x9b\xae\xc5\xc3\x9f\xd7\x80\x2d\xf1\x3f\xc7\xb1\xf3\x9b\x50\x48\xf8\x47\xa3\x97\x2e\x06\x5b\x97\x2f\xe6\xdd\xfd\x16\xbc\x77\x2d\xfe\x17\x98\x24\x61\x9b\xdc\x8d\xc6\x36\x13\x8d\xcd\x83\xf4\xc2\xfc\x68\x1f\x83\x5e\x2f\x58\xd5\x1a\xb7\x27\x00\xa1\x87\x32\x66\x69\x35\x56\x55\x4e\xd8\x45\x19\x43\x8c\x83\x12\x78\x21\x2a\xd4\x08\xab\x85\x1d\xc2\x3b\xc2\x15\x41\xa5\x83\x82\xe0\x76\x44\x1d\x66\x0c\xf0\xc3\x67\x69\x55\x8c\x82\x33\x00\x3d\x44\x83\x56\x78\x87\xc7\xd4\x0a\xe4\x7c\xbf\x9d\xe4\xa1\x25\x8b\x4f\x2e\x30\x23\xf2\x7f\x66\xf6\xc8\x93\x33\x11\x96\xae\x67\x09\xdf\xa1\x4d\x19\xc6\x84\x87\x32\xf0\x4f\x8e\x32\x44\x90\x80\x6c\x20\x0c\x06\xde\x77\x1f\xc6\xf6\xd9\x35\xbf\xf7\xae\xa9\xf7\xb7\x7b\xc6\x57\x1d\x7f\x73\xe2\xb2\x04\xf2\xcf\xc9\xd5\x43\x76\xd1\xdd\xbf\x13\x1b\x57\xd0\xad\x86\xcc\xba\x03\x14\x3c\x8f\x21\x7e\x8a\x17\xbd\x3a\x68\x5d\x55\xef\x76\x8d\xd5\xed\x09\xf4\x4f\xe7\xcd\xec\x68\x82\x05\xf4\xdb\x66\x78\x34\x2c\xe3\x53\x21\x9b\xf7\x03\xd2\x01\x78\x2e\x46\x47\x2b\x54\x6a\xbd\x4e\x27\x58\xbd\xb4\xdb\xe3\xa1\x29\x17\x1f\x50\x6a\xd0\xd4\xe0\xd9\xe0\xfd\x8c\x43\x1a\xba\xa9\x26\xe6\xb0\x72\x01\x8d\x92\x61\x51\x00\xca\x22\xcd\xa9\x62\xf9\xe4\xa8\xd3\x87\x9c\x39\xde\x84\xd3\x18\x96\x00\x80\xcc\x11\x98\x18\x6e\xa2\x2e\x37\x07\x86\x64\x6a\x71\xc5\x8f\x1b\x7f\xba\xd2\xbd\xea\xc8\xca\xf3\xf3\xfd\xcf\x69\x83\xe2\xe9\xf2\x5a\x19\x1a\x68\xea\xe0\x57\x56\x02\x75\x2b\x50\x14\x6c\xb9\x6a\x5e\x6c\x35\x28\xc3\x48\x40\x3c\x58\x29\xb6\x1b\xb8\xcf\xd0\xb9\x20\x5e\x10\x22\x18\x41\xd9\x62\x17\xf8\xc6\xe1\xd1\xf4\x01\xcd\x69\xe2\xef\x3a\x93\x58\xfd\xd5\x51\x1f\xa3\x52\xe9\x81\x42\xab\xd6\xaa\x0d\x9c\x92\x50\xee\x23\x77\x54\x4b\x6b\x55\x84\x6d\x1f\x52\xd5\xcd\xab\x59\x09\xb1\x66\x89\xd4\x73\x67\x8e\xa4\x17\xc3\x39\x57\x9e\x01\xab\xc4\x49\x18\xa7\x7f\x25\xcc\xa3\x07\xc5\xf7\x6f\x11\x0d\x5b\xe8\x95\x78\x6e\x0b\x9a\xd6\x33\x0d\x68\x9f\xf1\xc8\xcb\xee\x19\x6d\xa1\x33\xd2\xb4\x09\xd3\x42\xb0\x0a\x8d\x02\xea\x71\x57\x1c\x35\x3c\x66\x30\xab\x71\xe3\x86\x11\x28\x19\x06\xea\x34\x50\x01\xd1\x89\x79\xb9\xfa\x55\x34\x77\x99\x27\x85\x64\x1d\xa4\x53\xa2\x26\x7d\x08\x21\x80\x2b\xf1\xd0\xae\x89\x08\xf8\x74\x18\xc5\x33\xa7\xc5\x33\xbb\xc0\x17\xa2\x1b\xee\xe8\xb0\x2b\xda\x49\x74\x6f\xdf\xce\x7c\x15\xff\x25\x9e\x0b\x76\xc6\x7f\x85\x02\xdd\x76\xcb\x98\x31\x5b\xc4\x46\x80\x1b\x80\xba\x8a\x03\x71\x4e\x8b\x6a\x4b\xf5\x8d\xb6\x68\xa9\xd7\x7b\x29\x36\x12\xb1\x85\xa9\x70\xbb\x2a\x6f\x04\xb6\x68\x51\x54\x13\x6b\xd5\x82\xd7\x41\x9e\x57\xd7\xc4\x90\x1f\x83\x7c\x18\x3b\x94\x4b\x3f\x09\xc6\x06\x06\x7c\xb8\x8e\x3c\x3e\x79\xe1\x87\xcd\x8f\x2d\xad\xe2\xba\x10\x84\x73\xd2\x4a\x69\x0b\x41\x81\x44\x49\x6b\x4d\x22\xad\xe0\xa2\x51\x08\x9f\xfd\xe6\x9d\x40\x97\x97\x5c\xb7\xb8\x82\xad\x3d\x75\x6d\xee\x6a\xf3\xe8\x9c\x15\xdd\x3b\xf5\xe2\x16\x55\x2c\x9a\x56\x3f\x77\xf0\x1d\xf3\x37\x2f\xbc\xf5\xd2\xeb\x47\x2f\xb9\x77\x71\x0b\xef\xbd\x7f\x6a\xd1\xed\x1b\x56\xcd\xe9\x9e\x0b\xf2\x37\x3d\xae\x79\xd7\x63\x77\x07\x26\xb5\xcd\x7b\x74\x4f\xdf\xfe\x23\x6c\x83\x06\xb7\xeb\xdf\x3f\x5a\xe3\x0c\xe6\xf6\xba\xb7\x66\xdd\xe6\x39\xcb\x2c\xdd\x7a\xdd\xda\xa3\xa0\x2a\x2f\x3b\xab\xdd\xad\x23\x70\xfc\x83\xc6\xff\x27\xb2\xa5\x1e\xaa\x6d\xd4\xeb\xa4\x6c\x0e\xad\xc7\xe6\xf1\xfa\x5c\x4e\x5c\x58\xae\x31\x18\x54\x35\x31\x83\xcd\x46\xe1\xfa\x51\xa2\xd0\xf9\x97\xaf\x6f\xda\x42\x7b\xb9\xc4\x0b\x7c\x84\xb0\x3c\x51\x58\x8e\x91\x82\xf2\x81\x54\xae\x7d\xad\x7d\x6d\xc7\xce\x07\x3c\x25\xfe\xd2\x2a\x3c\x96\xe2\xde\xb7\x54\xee\xc8\xee\xdc\x7b\x8b\x14\x21\x2d\x13\x0a\x6b\xce\x87\xdc\x9d\x27\xb5\x2d\xf6\xb6\xe9\x7a\xb6\xa5\x7f\x19\xcc\x5a\x56\x8f\xf7\x6a\x04\xed\x55\xdc\xeb\x6c\xa5\xda\x44\x3d\xac\xc9\x8a\xfc\x54\x1d\x65\x82\x76\x1b\x14\xea\x70\x48\xa8\xe5\x38\x55\x5d\x8c\x23\xc5\xa1\xd5\x52\x61\x84\x3d\xa3\x1b\x17\x53\x54\x21\x25\x62\x94\x13\x52\x12\xe8\x99\x85\x56\x1a\xc1\xa9\xd2\x1e\xa0\xff\xc1\x86\x07\xf7\x3b\x9f\xc9\x02\xea\x4b\x80\x05\x96\xa6\xbf\xd1\x76\x03\x98\xf7\xea\x73\xd3\xa6\x7b\xf6\x3c\x2b\xfe\x26\x5e\xfb\x4e\xfc\x56\x25\x3e\x28\xd5\x2c\x5b\x90\x61\xac\x21\x7d\xe2\x28\x56\x55\x6b\x2c\x14\xc3\xf3\x94\x06\x0a\x56\x60\x46\x2e\x12\xa0\xf4\x6a\xb5\x5e\x8f\x5c\x10\x3d\x2f\x41\x4c\x26\x33\x66\xcd\xe5\x91\x8d\x7a\xb2\x00\x5c\x81\xa4\xb9\x63\xd5\x63\xf7\xcc\x3d\xe3\x7e\xce\xf9\xe1\x63\x6f\x7d\xf2\xd8\x06\x70\x78\xf5\xac\x45\xf3\x5f\x36\x3c\x72\xf0\xdd\x97\x56\xbd\x1e\x16\x5f\x45\x36\x39\x20\x73\xe2\x63\x1f\x3b\x4c\x8d\x89\x96\xa9\xec\x21\x2f\xcb\x9a\xb4\x21\x2b\xf2\xf7\x01\xa7\xe5\x72\x73\x54\x21\xc1\x41\xfa\x52\xac\x14\x25\x70\x21\x61\x78\x2c\x14\xe2\x68\xce\x39\x3c\xc6\x99\xe8\xe0\xf0\x18\x7d\x1d\x5c\x56\xda\xd9\xae\xc8\x6c\x43\x4b\x24\xf7\xd0\x29\x4f\xa0\x30\xca\x4d\xcd\xd9\xa5\x2d\x00\x01\xa2\x4c\x07\x64\x0c\x2c\x4e\x60\x30\x12\x60\xc6\xc5\x8c\x8a\x40\x31\x0e\x15\x77\x67\xc2\x31\x7e\x0c\xf7\xca\x18\x8c\x2b\x9e\xbf\x08\x06\x74\xfd\xf3\xe4\xa2\xe7\x93\x48\x8c\x58\x57\xb4\x40\x31\xd2\x36\xd2\x8b\xed\xa3\x7a\x45\xc3\x8c\xc7\x63\x05\x16\xd6\xe9\xd4\xa8\x74\x16\x9d\x3f\xe0\xd6\x5a\x31\x34\x84\x0a\xe9\x29\x9e\xe6\x6d\xc3\x63\xbc\x59\x81\x87\x15\x49\x6a\x2a\x89\xb8\x2c\x6d\x30\x09\x3f\x43\xd2\x57\x12\x66\x06\x9a\x76\x9c\xe5\x09\xb7\x43\xca\x03\x77\x5b\x06\x90\x3f\xd1\x62\xda\x19\x68\x38\x3d\x6d\xda\x1a\xf1\xf7\x06\xdc\x61\x37\x8d\x7e\xfa\xf4\xa5\xc6\x9f\x5f\x86\x2d\xe8\xc1\xf1\x7d\xf8\xef\x4d\x73\x9e\xf8\x63\xe1\x9c\x9f\x1e\x5f\x1d\xff\xfd\xc2\x6b\x53\xe6\x9d\x3d\x87\xf6\x85\x1a\xc5\x56\xbd\x90\xbc\x2a\xb4\x47\x7d\x90\x06\x14\x8b\x1c\x25\x96\x86\x1a\xf5\x04\x0d\x28\xd2\x80\x42\x0d\xa0\x34\x80\x85\x2a\x13\x86\x8a\xa8\x8e\x54\x00\x89\xf2\x3f\xbd\x07\x3b\x42\x70\x35\x40\x88\xee\xf6\x2a\x5d\x7d\x5e\xbc\xbf\x7f\x7f\xf1\x81\xf3\xec\xfc\xbf\xe6\xc2\x2b\x7f\xfe\xd9\xe8\x27\x3e\xd9\xbe\x26\x3f\x23\x22\x27\x02\x73\xbf\xb9\xa8\x75\xd1\x01\x3a\x15\x0f\x1c\x4e\xc1\xca\x2a\x28\x05\x6b\xb1\xdb\x69\x33\x9a\x3e\x9a\xe5\xa1\xc7\x6d\xe4\x91\x1e\x35\xa9\x90\x36\x65\xa3\x2a\xa8\x43\x6a\x5d\xa7\x23\x85\x54\xab\x2c\xe0\x84\x05\xcc\xb4\xd4\x5b\x68\xce\x02\x54\xd0\x62\x41\x71\x86\x0d\xa7\x57\x68\xfb\xf0\x18\x85\xfb\x41\xdf\x4e\xdb\x20\xf8\x1a\x1b\x97\x31\x24\xf2\x89\xce\x37\x13\xc0\x60\x29\xd3\x2d\xe1\xa0\x10\x25\x60\x2b\x0f\x19\x25\x35\x1c\x82\x68\x77\xe0\xbf\x95\x30\x80\x6b\xa6\xcd\x81\xaf\xc7\xed\x87\x3d\xbb\xac\xec\xd2\x6f\xeb\x47\xa0\x52\x7c\xe0\x7b\xfa\xbd\xc6\xbf\x8f\x33\x80\xb1\x1f\xc5\x4f\x95\x7d\x2f\x5e\xb9\x72\x85\x9d\xbf\x66\x8d\xcc\x64\x70\x85\x01\xe0\xe5\x6b\xc7\xc0\xf7\xd8\xff\xea\x2c\x0e\x66\xc2\xc8\x2e\xbb\xa8\x20\x85\x6b\x40\xea\xa3\xb7\x0a\x56\x6b\x8e\x1e\xf0\x6e\x4e\xd5\x42\xab\xd4\x50\xc8\x27\x0d\x85\x90\xe7\x4f\x41\xa8\xd6\xc3\x96\xf9\x2e\x57\x10\x99\xe2\x60\x30\x4f\x10\x38\x7b\x1e\x57\x13\xcb\xcb\x53\x38\x01\xf2\xd1\xb3\xed\x76\x13\x06\x6c\x6b\xe1\xc3\xf4\xe2\x5a\xb5\x02\x1b\xeb\x64\x0f\x2a\x15\x21\xd8\x27\xc9\x63\x61\x94\x62\xbd\x1b\x0f\x16\x2f\x9b\x0b\xa4\x19\x70\x23\x1a\x6f\x82\xe0\x00\x99\x6f\x60\x96\x00\xa1\x2c\x36\x73\x76\x38\x47\xd9\xf9\xf2\x2b\xd7\xfe\x71\xfb\xad\xcf\xac\x7c\xeb\x8c\x38\x78\x77\x69\x47\x99\xdb\xa0\xae\xe6\x0c\xe8\xb9\x2c\x52\x8d\x4b\x12\x7b\xcd\x07\x0f\xe8\xab\xee\x12\x07\x83\x2f\x16\x83\x3b\x80\x0e\x78\xad\x60\x9d\x58\xba\x44\xdc\x60\x17\x57\x5b\x08\xbb\x81\x4d\x1c\xc0\xb4\x00\xad\x4d\x4f\x6d\x5a\xfa\xfc\x28\xe0\x5f\xba\xa1\x56\xee\x6b\xc2\xfc\x5a\x18\x5b\xd3\x8e\x6d\x18\x0f\xed\x76\x4e\x03\xac\x56\x95\x42\xc3\x69\x50\xa4\x6e\xa7\xd0\xda\x2a\x28\x4a\xcf\xe0\x4e\x2c\x9e\xd7\x9b\xd3\x7b\xd5\x22\x85\x37\x41\xb5\x22\x28\x37\x25\xb8\x86\xce\x98\xa8\xa1\x43\xd6\x8c\xc0\x45\x92\x06\xe5\x00\xd8\x0d\x14\xe2\xbf\xc0\x5b\x8b\x17\x7f\x7a\x56\x7c\xb4\xd3\x49\xd3\x9c\xe1\x77\xcf\x10\xff\x82\x2d\xc0\xf3\x5b\xe2\xfb\x36\xfe\xf3\xad\xef\xc1\x64\xdf\xd4\x05\xab\x96\xfe\x0b\x6d\x4c\x12\xb3\x3d\x49\xb8\x96\xed\xc8\x07\xc8\xe1\x1d\x8c\x60\x32\x18\xec\x34\xc5\x30\x4e\xb5\xc3\x2a\xf4\x43\x4a\x0b\xf2\x46\xbe\x26\x86\xd9\xdd\xcc\x9c\x52\x5b\x13\x53\xba\x92\x8d\x29\xc9\x65\x92\x22\xbb\x48\x02\x96\x0e\x9f\x1e\xdc\x18\x9c\x0a\xf3\x08\x2e\x4e\x0e\x26\xfb\x6e\x37\x61\x82\x1c\xf0\x4d\x9c\xd8\xd0\xd0\x40\x8f\x59\x14\x7f\x44\x0e\xfc\xe8\x3e\x8b\xc0\xc5\xaf\x9f\x7c\x92\x92\x31\x35\x06\x29\x14\xc8\xce\xd8\xa9\x10\xd5\x39\x1a\x74\x69\xb5\x2c\x15\x40\x8a\x34\x3b\x4b\x67\x35\xd8\xa0\x05\xf9\xb3\x16\x14\xeb\x21\xb5\x63\x30\x38\xb0\xa7\x92\xb0\x84\x29\x1c\x90\x74\x60\x50\x1c\x76\x26\x3b\x87\xdb\x81\x14\xd9\x47\x79\x04\x60\x92\x0f\xa9\xf4\x90\x2d\x6b\x53\x1e\x29\xac\xec\xbd\x70\xd1\xb3\x07\xc4\xe7\xc4\xb5\x18\xcf\xe4\xa5\x1d\x8f\xf8\xe2\x9f\x7f\x37\x7d\xca\xd7\xff\x12\x7f\x07\xda\x29\xb5\x9d\x0c\xbb\x0c\x1b\xd6\x9c\x1b\x02\x1e\x02\x03\x30\x94\x49\xaf\x36\xd7\x98\xbb\xe0\xc1\x51\xe2\x87\xe2\x2f\xe2\xbf\xc4\xb7\xa8\x64\xbd\xe1\x21\x64\x9b\xfc\x54\x4b\xaa\x7b\x34\x1c\x30\x00\xbf\xdf\x29\xe4\xa8\x04\x55\x41\x2b\x8f\xbd\x26\xe6\x71\x01\x9a\x36\xb0\x46\x5e\x93\x85\x31\xfe\xd8\xbc\x9a\x18\x9b\x09\x63\x62\x4c\x47\x28\x94\x9b\x95\xb2\x33\xa3\x31\xb9\x82\x30\xbd\x27\x3a\x3d\x2c\x2d\x63\xe8\xd6\xdb\xe6\xe2\x10\x6c\xd6\x8e\xd6\xb4\x8a\x39\xa8\x6c\x53\x1e\x2e\x2a\xb9\xf5\x81\xf9\x38\xf6\x9a\x89\x22\xee\xe2\xf9\xe3\x86\x00\x2b\x8e\xb8\x06\x8d\xf6\x3e\xcc\xb6\xfd\xa1\x71\x7c\x6d\x27\xdd\x2e\xdd\xfa\x87\xe9\x27\x70\xc0\xf5\xc5\xcb\x1f\xa3\xb1\x50\xf8\xee\x96\xd8\x39\x27\xd5\x27\x9a\x83\x36\x83\x89\x07\x7a\x9b\x0d\x42\x95\x82\xd1\x33\x6e\x17\x4f\x13\x06\x4b\x9b\x52\xc9\xa8\xd5\x56\x02\x08\x28\x03\x49\xa5\xed\xe3\x66\x1b\x59\x46\x89\x08\x00\x99\xaf\xd2\x28\xe3\x44\x80\xa4\xfd\x62\x96\x8b\x6b\xc5\xee\x67\xf6\xed\xa3\x37\x48\x40\x11\xab\xff\xd8\xbb\x55\x6c\x0b\xde\xda\xb0\x87\xee\x1e\x3f\x46\x77\x7f\x84\xde\x45\x70\x22\xe2\x3b\xe1\x0f\x09\x9c\x08\xe4\x13\x60\xfe\x0e\x14\x17\xde\x12\x0d\x09\x1a\x87\xc3\xc6\xb3\x0c\x8d\xdc\x5c\x97\xd3\x60\xee\x17\x33\xf0\x76\x92\x39\x16\x50\x00\x08\x95\x9c\x8c\xe4\x64\xaa\x68\xde\xf6\x1e\x21\x15\x9c\x09\x50\xa7\xb2\xd2\x9c\x44\xfb\x0d\x69\x7d\x87\x78\x7f\xaf\xbc\xff\x7e\xc5\x01\x15\x93\x3f\xf1\xce\xac\xec\xac\xaa\xb7\xad\xcf\x1c\x03\x5f\xaf\x7d\x75\xf2\xd2\xe3\xd9\xcb\xee\xd4\xec\xd1\x88\x17\xd6\x8a\x4e\x69\x2f\x90\x5c\x1f\x99\x3f\x0b\xee\xfe\xa2\x91\x79\x30\x9b\x2c\x5a\xd6\x88\x5b\x57\x8d\x10\x39\x1c\x10\xf9\xd9\x75\x31\x03\x65\xd2\x68\x14\xc8\xb1\xc5\x81\x29\xa9\x5a\xab\x48\x99\xce\x64\x40\x5a\x22\x9d\x2f\xc9\xcd\x2e\x8b\xe4\x44\x6c\x48\xc1\x03\x73\x80\x59\xf3\xf0\x2f\xe2\xe5\xd3\xe2\x47\x3f\xaf\xdd\xf0\xee\xc3\x74\xc9\xc3\xef\xc6\x17\x9e\x14\x97\x30\x9b\xd7\x8a\xd5\xb8\xdd\x17\x9c\x5d\xfb\xf5\xd7\x5f\xc7\x47\x80\x1c\x2c\x13\xc9\x27\x22\x1f\x13\x33\xeb\x0f\x8e\x16\x00\x17\xd2\x51\xbc\xcd\xc8\x3a\x4d\x5a\xc1\x29\x64\x85\x1c\x9c\xcd\x8b\x1c\x4c\x9b\x05\x1a\x2d\x98\x27\xc1\xc5\x5b\x2c\x2a\x2b\xa7\xd2\xa3\x88\x2a\xa5\x02\x2a\x2a\xe4\xde\x1c\x7b\x42\x31\x4b\x9d\xdc\x69\x72\x42\x03\x1d\x4a\x34\x05\x43\x24\x2f\x44\x96\xc7\x1c\x01\xd5\x20\x60\xf3\xd2\x70\xe6\x84\xbd\x5f\x75\x9a\xba\x22\x26\x37\x06\x7f\xbf\xeb\xee\x25\x2f\x2c\x00\x0b\xa6\x9d\x16\xb9\x2e\x5d\xc4\x6f\xf2\x59\x43\x4f\xfa\xab\xb5\xf1\x83\x07\xf7\xf7\x23\x8d\xc1\x74\xef\xb5\x60\x80\xf8\x04\x18\xd0\xb8\xf4\x95\xd7\x27\x18\x72\x3e\xc5\x63\x01\x38\x1f\x4b\x78\x9f\x8a\xa8\x41\xd1\x82\x16\x7e\x95\xca\x62\xe0\xb8\x02\x08\x2d\x4e\x58\x5c\xe2\xb1\xd7\xc6\x3c\x7c\x0b\x65\x6d\x2c\xd0\xa2\x05\x65\x34\x18\x8c\x46\x2d\x6e\x64\xa3\xd0\xc9\xa3\xf8\x14\xb6\xaa\xe4\x1b\x56\xa4\xdb\xd3\x48\xaa\x30\x8f\xf8\x85\x9c\x9c\xf0\x90\x90\x36\xa4\xd3\xa6\x2c\x93\xca\x79\xdb\x03\x5b\xd0\x00\x3c\x12\x3e\x47\x98\xfe\xe0\xb1\xdd\x5f\x5d\xfd\x65\xe2\x8c\x59\xf7\x68\x9e\x2f\x10\x1f\x78\xf3\xed\xbc\xb6\xce\x40\xe7\xae\xa3\x86\x28\x14\xd1\xe7\x86\x8d\x7c\x34\xf6\xca\xdc\x85\x5d\x86\x33\xbd\x9f\x7c\xe4\xe0\xd3\x0c\xd3\xf6\xc1\xc9\xfd\x07\x1b\xc5\xbf\x9d\x7c\x1a\xbc\x5b\x53\xab\x9c\xc8\x8f\x99\x38\x63\xdc\xe2\xdb\xb6\xf6\x8b\x31\x74\xd1\xc8\xbe\x83\xeb\xe4\x1a\x7d\xf8\x23\x1a\xa7\x15\xad\x59\xfb\xa8\x4f\x4f\x79\x3c\xbc\x4d\xc1\x2b\xb2\x42\x66\xc1\xc0\x11\x4a\x6c\x3f\x49\x7d\x39\x33\x53\x5f\xf8\xbe\xb1\x19\x37\x7e\x33\xca\xeb\xc8\x7f\xa5\xba\x6e\xb8\x39\xc9\x75\x61\xe3\x9e\xe6\x04\xd7\x34\x35\x47\xee\x27\x90\x65\xb5\x29\xb0\xb4\x9c\x82\xcb\x0a\x99\x38\x4e\x20\x17\xa5\x58\x56\x2b\x91\x95\xbf\x99\xac\x92\x2f\x96\x0e\xe5\x6c\x13\xa4\xec\x2d\x10\xd2\xc1\x9b\x40\x9b\x04\x92\x73\x52\x56\x3a\x8c\x65\xad\xdf\xb8\x64\x26\x5c\x9e\x48\xaf\x61\x61\xe1\x10\x22\xac\xb8\x1a\x0b\xfb\xc1\xf9\xf3\x49\x1c\xef\x8f\x89\xae\xee\x12\xcd\x0e\x50\x0e\x36\x27\x47\xa7\x33\x53\xb0\xa0\x95\x93\xf5\xd2\x5e\xb4\x51\xbc\x3c\x2f\xa0\x60\x13\x68\x04\x3a\xef\x7f\x89\xe1\x93\x02\x9e\xce\xc0\x46\xfe\xcf\x60\xde\x8f\xac\xe9\xd8\xa7\xf2\x96\xea\x5b\xd8\x9b\x03\x7a\xc3\x4b\xab\x36\x19\x1f\x17\x7a\x76\x9b\xbb\xa9\x39\xa8\x37\xa0\xda\xa1\x3d\x72\x98\xe8\xbf\xd6\x51\x4c\x29\x65\xa6\xf4\x66\xbd\xd3\xc5\xdb\x6a\x62\x16\x0b\x6f\x55\x28\x34\x04\x1a\x39\xd1\xbf\x51\x28\x39\x1b\xe9\x17\xe6\x69\x45\x0e\xa4\x77\x23\x59\xc3\x4e\xff\x3a\x7f\xe5\x98\xc9\x86\xe7\x3c\x1f\xed\xbd\xf2\xd3\x8f\x5f\x3c\xf1\xb9\xf0\x2c\x37\xbf\x6e\xe9\x62\x3a\xf8\xf7\x53\x63\x6f\x33\x6c\x78\x52\xfc\x5c\xfc\x51\xfc\xa7\xf8\xf9\x89\x2d\xba\xf1\x77\x5f\x94\x74\x5f\xaf\xa6\xdd\xf0\x15\x24\x0f\xc6\xe5\x1f\x15\x6d\x63\x65\xd5\x3c\xc7\x65\xb9\xdd\x79\x76\x5a\xa9\x56\xb4\x6c\x65\xcf\x53\xd2\xc8\xdd\x70\xe6\xa0\xc9\xd5\x71\x4e\x9f\x93\x56\x43\x0c\xa1\xae\x33\xe3\x3b\x0a\x06\xc5\x14\x7e\x19\xcd\x51\x12\x37\xe5\x06\xe3\x16\xcf\xb4\x44\x7f\x62\x67\x63\xfc\x39\x9c\xdd\x0e\x97\x49\x68\xbe\x89\x18\xde\xd6\x3a\xe2\xc7\xc9\xef\x9c\x92\x64\xbf\xaf\x95\x2e\xde\x39\xb1\x34\xf4\x40\xb7\xec\x91\x3f\x5d\x79\xfc\x13\xb7\x04\xe5\x1c\x3c\xf3\x2a\xd0\x8e\x3e\x3a\xbb\xdf\xa4\x76\xd1\xaa\x7e\x8f\x45\x3b\x5b\xfa\xf4\xee\x3e\x74\x6a\xc9\xea\x6f\x71\x36\xe7\xc9\x0d\x18\xd0\xf9\xf3\x05\x77\xbe\xfc\xd5\xe0\x95\x5d\x1f\xca\xeb\xdc\xa2\xa2\xe4\xae\x7e\xdd\x52\x36\x9f\xf8\xc5\x39\x54\xd7\x68\x56\xd0\xcc\x30\x56\xb7\xce\xaa\xcb\xa5\x5a\x58\x28\x23\x6b\x50\x1b\xb2\x71\xb7\xa7\xda\x87\xb9\x65\x68\x47\x4d\x06\xfa\x4c\x12\xce\x1c\x44\x4c\xe9\x05\xc1\xc8\xac\x3b\x40\xe8\xba\xdc\x34\x36\xf9\xe9\xa7\x95\x39\x54\x72\xeb\xef\x4c\xc9\xde\xb4\x13\x8b\x8d\x7d\xe3\xe8\xc4\x89\x15\x47\xea\x40\x2e\x28\xcc\x48\x3d\xff\x79\x16\x59\x7b\xe8\x48\x1e\x5b\xb9\x0f\xe8\x43\x82\x19\x93\x87\x11\x0d\x2c\x8a\xec\x6c\x0a\x69\x1a\x7d\xbe\xa3\xa5\xcd\x8d\x0c\x02\x30\x29\x38\x0d\x97\x5b\x13\xe3\x78\x4d\x10\x63\x6c\x43\xa1\x19\x1e\x7b\x7e\xb3\x11\x64\xa7\x70\x94\xd3\x34\x0e\xfa\x53\x02\x66\xcc\x50\x39\xff\xc0\x27\x97\x49\xd7\x3b\xc0\xd5\xa1\x4b\x65\xdb\x99\xf1\xbc\xc4\x38\x3e\x23\xc7\x37\x6d\x18\x7b\x41\x2e\xb7\x4f\x58\x17\xbf\x3f\x35\x0c\x34\x0e\x52\xaf\x28\xf7\x33\xf5\x88\x66\x9b\x4d\x26\x85\x4e\xab\x75\xe0\x8a\x6c\xa7\x4e\x47\x71\x0e\xaa\x26\xe6\x70\xa8\xa1\x9a\xc3\x8b\x01\xad\xcd\xb4\x50\x2a\xe4\x68\x86\x2a\x6c\xc6\x92\x4b\x3d\x4d\xb2\xdb\x5d\x96\x23\x15\x98\x0c\x02\xff\xf3\x8f\x6b\xd7\x7e\x12\xf7\x8d\xd8\xe6\x58\x31\xed\xe1\xcd\xb4\xe2\xd1\x05\x8b\x57\x73\xe0\x77\x3b\x5d\x2d\xfe\x5d\xfc\x55\xfc\x5a\xfc\x3b\xa0\x5a\x75\xbb\xfd\xfc\xc9\xa5\x8f\x1e\xda\xfa\xc4\xf5\x72\x22\x8f\x05\xf7\x5d\xe1\x53\x9b\xea\xbc\x52\xa0\x09\x97\x7b\xaf\x92\x9d\x57\xff\x11\xf7\xf8\x3f\xf4\x5e\x0d\xf9\x3f\xf6\x5e\x49\xf2\xb1\x5f\x10\x3f\x36\x97\x1a\x1e\x2d\x41\xb2\x05\x7c\x54\x4e\x8e\xd6\x69\x76\xfa\x60\x8b\x3c\x1e\x05\x09\xf6\x5c\x0a\xed\x07\x85\x02\xfa\xb5\xb8\x77\x97\xf2\xa8\x3d\x48\x61\x7a\x6e\x2c\xae\x51\x2e\x87\xc0\xed\x41\xd7\xc1\x21\x48\x13\x89\x24\xf7\x9b\xcb\x6d\x52\xe6\x8a\x34\x6a\x63\x54\x95\xd4\x38\xca\x72\x60\x4f\xef\xda\x09\xf2\x48\xc0\xac\xc1\xeb\xdc\x5c\xa4\xa4\xb4\xa6\xed\x9c\x01\x23\x17\x59\x18\x3c\xb0\x63\xdc\xca\xe5\xcb\xb6\x41\xfa\xd2\xdc\x69\xd2\xc0\x76\x3b\xe7\x77\xee\x94\xfb\x70\xe9\xea\x39\xb9\x65\xf2\x08\x27\x1c\x7f\xe2\xb5\xe7\xfb\x60\x9d\xd9\xad\xe9\x9f\x70\x3a\x1a\x63\x36\x35\x39\xda\x41\x80\x5a\x23\xcb\x22\x0d\xa4\xd5\xfa\xfc\x94\x3f\x9c\x03\x2d\x36\x0b\xd2\x9e\x94\x8f\xf7\xd5\xf9\xa0\xfa\x29\x0b\xe0\x2c\x17\x2c\x9f\x59\xa0\x16\xfa\x2c\x28\x88\xf7\xc1\x90\x2a\xe4\xc1\x08\x5e\x2a\x03\xb6\xbe\xcd\x71\x9d\x91\xaa\x9a\x24\x5d\x4a\xde\x10\xdd\xd9\x5c\x8a\x75\x95\x9c\x6f\x94\x6d\x42\x5b\x90\x40\x76\x96\x73\x77\xe1\x6e\xf3\x66\xfe\xed\xfc\xe1\x5d\xaf\x0b\x47\x7d\x07\x87\x8d\x9d\x34\xf4\xb6\xba\x69\x13\xee\x1b\xf3\xbe\xe5\x69\xfe\xbd\x67\xcf\x5e\x02\x81\x09\x4b\x2d\x9d\x8e\x2c\xdb\xb1\x6f\x13\xff\xe6\x6d\x03\x7a\x0f\x5d\x51\x37\x68\xf0\xc8\xcf\x0c\x07\xf7\xed\xc1\xe3\x2b\x43\xe3\x1b\x49\xc6\x77\x7f\xb4\x4b\x88\x77\x09\x81\x80\x8e\x72\xba\x5c\x4a\x05\xa5\xc8\x09\x53\x39\x40\x03\x43\x46\x29\xce\x53\xf2\xca\x3a\x25\x1a\xa4\x11\x70\xc6\x0b\xc6\xcf\x8c\x68\x90\x4a\xa3\xd3\x69\x44\xde\xb2\xd7\x6b\xc7\x66\x10\xaa\xaf\xbb\x57\xcb\x1c\x24\xae\xb4\x37\x9a\xae\x1b\x27\x90\x7b\xee\xad\x09\xc0\x82\xb2\x48\xf3\xb4\x1b\xae\x4a\x1b\xf9\xde\x0b\xc7\x2e\xf1\x4f\x5b\xde\x1f\x3f\x75\xe2\xd4\xba\xdb\x86\x4d\x1c\x73\xfb\x41\xdf\x51\xe1\xf5\x5d\x4f\x9f\xfb\xdb\xcc\x79\x20\xb0\x6a\xcf\xbe\x83\x86\xcf\x6e\x1f\x36\xa8\x6e\xc5\xd0\xde\x7d\x87\xbd\xc9\x6f\xdc\xbf\xab\xfe\x48\x27\xcb\x52\x69\x9c\xac\x12\x8d\x33\x42\xcd\x89\x76\x2d\xe6\x5d\x21\xa1\xb0\x50\x1e\xa8\x82\xca\x83\x65\xa5\xc5\xd2\x28\xc3\x2d\xfb\xc5\x0a\x03\x01\xa7\x37\x73\x98\x61\xa7\x33\x6c\x54\x32\xff\x79\xa0\x64\xa4\x24\x0e\xcf\xbf\x8e\x35\x25\x22\x81\x18\xfd\x2f\xc6\x6a\x2b\x4f\x24\xa0\xc9\x83\x8a\xff\x38\xf2\xa5\x27\x82\xf5\x6e\xae\xb0\x24\xbb\x5d\x10\x6d\xf1\x21\xf3\x9c\x81\x86\x9b\xcc\xc4\xe8\xa1\x76\xb4\xcd\x6d\xc6\x87\x4b\x67\x4e\x5c\x50\x8e\xe6\x84\xa6\x7a\xa0\xb5\xbf\x80\xe6\x44\xa0\xc2\x54\xff\x68\x2b\xca\xab\xb3\xf2\x6e\xb7\x32\x60\x0d\xe4\xe4\x7a\x75\x5a\x1d\xf2\x84\x39\xdd\x05\xdd\x67\x3a\x34\x05\x3a\x5d\x96\x23\x8b\xa9\x89\x65\x59\x1d\x66\xd2\xf2\x56\x9d\x99\x78\x6a\xb6\x87\x71\x0c\x87\xc7\x9a\xc2\xa0\x48\x0e\x53\xa1\x24\xc6\x97\x2c\x29\x01\x5b\xa0\x81\xaa\xd3\x9c\xc9\xa9\x91\xed\x5c\x79\xea\xdf\x5f\x3c\xff\x2e\x5a\xd2\xf7\x5e\xb8\xf6\x1b\xdd\x72\xfb\xd9\x21\xc9\x91\x5c\x7c\x13\xb0\xc0\xb3\x7d\x39\x5e\xd5\x09\xab\xf6\x00\x3f\xde\xc3\x2a\x71\x20\x9d\x83\xe2\x15\x01\xe3\x13\x41\x8a\x52\x98\x05\x3d\xce\x9a\xd8\xac\x16\xa1\x36\x66\x11\x34\x48\x8f\x6b\x14\xb0\x36\xa6\xc0\x60\x45\xc4\x22\x15\x66\x66\xc6\xa4\x0b\x9e\x64\xae\x31\x0d\xd6\xad\xec\x93\x86\x8d\x1b\x13\xac\x42\x97\x16\xc2\x63\x8d\xdd\x17\xae\x93\xb9\x85\x66\x2d\x4c\xc5\xf3\xef\x23\xbb\x98\x43\x95\xa1\x79\x6c\x99\xeb\xd2\x6a\x29\x05\xcb\x16\x9a\x29\x73\xeb\x60\x39\xf1\x10\x81\x03\xcd\xad\xb5\x25\xbe\x8b\xe6\x4b\x90\x3b\x23\xd0\x68\x07\x29\xb0\x8d\x8f\x5c\xcf\xcc\x29\xdb\xc8\x54\x80\x91\x4d\x3c\x46\x6c\x52\x90\xa2\x0b\xa5\xc8\x28\x90\xb5\x34\x4a\xda\x41\x22\x40\x82\x69\x9d\x82\xed\x01\xfc\x87\xd8\x56\x6e\x16\x04\x7a\xdc\x26\xf8\xda\xc9\xf3\x6f\x4d\xd9\x57\x40\xaf\x5d\xe5\x0f\x97\x97\x54\x44\x3b\x1c\xed\xb6\xb0\xdf\xd2\x39\xd3\x57\x0d\x78\xb0\x9b\x4f\x6c\x43\x3a\x05\x41\xdb\x43\x77\x8f\x01\x2a\xe0\xc2\x38\xb8\x63\x46\x80\xe2\x35\x1b\xa0\xf6\x71\x53\xef\x2e\xf1\x99\x0f\x9e\x19\x7d\xee\xca\xa7\x2f\x8e\x3a\x49\x25\xfa\xb6\x98\x1e\x26\x05\xee\xdb\x42\x6b\x70\xbb\x1c\x7f\xb8\x49\x6c\xed\x56\xd1\x9c\xc1\xe0\x44\x5e\xab\xc7\x4b\x20\xb7\x39\x8a\x63\x65\xf0\x50\xd6\x9e\x96\xce\xb8\x91\xa5\x32\x55\x48\x69\x2c\x83\xd4\xf4\x99\xe1\xa9\x61\xad\x57\x16\xa2\xa3\xe0\xa9\x1e\x1f\xde\xff\x5b\x13\x75\xed\x2b\xd9\x37\xdb\xb4\x64\xe3\xf6\x85\x77\xfd\x49\x7b\xc4\xdb\x3b\xf7\x00\x5e\xe4\x01\x18\x40\x90\x38\x64\x6f\xbd\xfb\xe9\xdb\x9d\x3e\xc1\xeb\xa4\x44\x32\xff\x49\xf0\x98\x5c\x54\x07\x14\x6b\x03\xab\xc2\x02\x29\xc6\x60\x52\x61\x7e\x20\x03\x60\xdc\x1e\xa8\xa0\x2c\x8c\x16\x68\x91\x03\xa6\x75\x31\x78\xb7\x44\xaa\x9b\xd5\x8c\x24\x50\xcd\xb3\x25\x38\x73\x19\xbd\x04\x63\xde\xd8\x4a\x73\x12\x31\xc7\x6a\xf1\xbe\x17\x50\xc8\xd4\xfe\x8c\x38\x7e\xee\xec\x71\x63\x67\xdb\xb2\x7f\xef\xd9\x23\x27\x2b\x3b\xe7\x11\xb8\x3b\x1e\xa0\x3f\x6b\x1c\xf6\xe9\xb4\x7b\xe6\xcd\xbb\x27\xf7\xb6\xa1\x97\xfb\x2d\x59\x5a\x5b\x50\x1a\x91\xf6\x92\xb5\xe9\x5b\xe6\x7d\xa6\x03\xa5\xa3\xda\x50\x35\xd1\x56\xea\x00\x8a\xae\x5d\x76\xa6\x34\x2b\xd0\x52\x55\x51\x59\x6a\xcf\x62\x18\x6f\x61\x7e\x7e\x61\x21\x32\xab\x85\x9c\x17\x1d\x51\xaf\x55\x6f\x41\x21\xab\x51\xcf\x25\xea\x5d\xd2\x83\x56\x5b\x3a\x22\x58\x36\xda\x1f\x39\x06\x88\xf1\x20\x09\x38\x58\x0e\x39\x8e\xe8\x9c\x24\xc6\x80\xc2\x70\x3c\xd1\x1c\x90\x54\x91\x8f\xae\x46\x01\x16\x7d\x46\x23\xb4\xd0\x39\x2d\xfa\xae\xdd\x00\xdd\x73\x75\x9b\xc9\x81\xea\xea\x50\x2b\xdb\xc2\x48\x5f\x3c\xb2\x9a\xe2\x85\xb6\x56\xa1\xea\xf6\xc1\xc9\x6d\x56\xf7\x1c\x31\xad\x45\xb9\x55\x28\xcf\x9d\xf6\x81\x90\x17\xe9\x69\x2b\x2a\x2a\xb4\x0f\x83\xe7\xea\x86\x4e\x28\x19\x52\x56\x26\x5e\xbc\x7d\x4d\xed\xd8\x19\x33\xc6\x0e\x5c\x3e\x0c\x14\x95\x95\x0d\x29\x99\x30\xb4\x6e\xd0\xbd\x1b\xba\x74\xd9\x70\xcf\x60\x82\xe3\x2e\x4e\x80\x57\x99\xb6\x94\x8d\x6a\x15\x15\x2c\xbc\x59\xad\x30\x2b\x1c\x76\x0b\x05\x8d\x4a\x0e\xea\x53\x1a\x17\x7b\x09\xa9\x30\x50\x0e\x58\x25\x08\xbe\x24\xac\x5d\xc8\x88\xc6\x52\xdd\x76\xf7\xac\xc3\x7b\x9f\xc9\xab\x1b\x80\x71\xda\x19\xe6\xc4\x3d\x75\x4f\xbd\x4d\x5f\x8c\xf7\x9d\x3c\xa1\xf4\xf0\x7a\x7a\xce\x5f\xa5\x60\xc1\x5c\x69\xff\x92\xba\x63\x74\x86\x7d\x54\x79\xd4\xe3\x31\x1a\x4d\x2a\xa5\xd2\x6e\x82\x18\xe3\xac\x26\x26\x00\x0a\xaa\x4c\x02\x91\x81\x4f\xca\x50\x9d\x79\x55\x04\xe4\x8a\xa1\x50\x1a\x8e\x73\xc2\x93\xf5\x00\x8b\x12\xb4\xab\x7c\x6c\x76\x52\x1a\xe0\xbe\xa5\x7b\x59\xc7\x39\x6a\x38\x7f\xec\xc8\xa7\xde\x8e\x17\xd2\x87\x88\x4c\xf1\x05\xcc\x11\x90\xcb\xef\x31\xaf\xac\x5b\x5a\x2d\xcd\xc9\x20\x22\x57\x0e\xd5\x31\x9a\x65\xd6\xd0\x94\xdb\xed\xf1\x84\x0c\x1a\xa6\x45\xae\x1f\x45\x0c\x7e\x40\x2b\x3c\x82\xce\x88\x02\x22\x17\x41\xe5\xcd\xa0\x32\x69\xae\xe1\x80\x5c\xb6\x82\xa4\xc4\x45\x1c\x04\xe1\xfa\x06\xd2\x0a\xa0\x93\x1a\x12\x61\xc5\x6f\x22\x03\x2a\xdb\x4d\xcb\x10\x99\xb9\x75\x69\x35\x96\xb9\xf1\x90\x78\x99\xdf\x2b\xac\x83\x81\x66\x92\x93\x7d\x6c\x47\xc2\x3f\x45\x70\xd2\x39\x34\xa3\x6e\x4e\xa5\xd2\xa9\xd5\xbc\x51\xaf\xc3\x84\x57\x4a\x2d\x85\x36\x2e\x8a\xdf\x68\xb5\x40\x73\x69\x24\x9f\x72\x96\xcd\x98\x76\x03\x84\xd3\x69\xe8\x2f\x73\x59\x44\xb0\x4f\x6a\x98\x3c\xb9\x61\xd2\xa4\x06\x7a\x0c\xb8\x28\x16\x2e\x12\xdd\xe0\x4b\x58\x85\xb3\xc2\x00\xc5\x26\x3f\x82\xd7\x12\x35\x46\x94\x86\xd5\x18\xf4\x5a\x4e\x05\xfb\xc5\x54\xf2\xa6\x91\x37\x8c\xdc\xd5\x89\x53\xa2\x18\x88\x1c\x68\x2a\xca\x03\x2d\x4b\x5a\x89\x57\x1b\x40\x76\x6d\x17\xed\x0e\x0d\xc8\x85\x21\xf4\x7b\x9d\x91\x70\x8f\xa0\xdf\xd3\x62\xe9\x35\xf8\x9a\x08\x42\x16\x40\xbd\x4e\xab\x54\x29\x91\x2b\xc7\x51\x0c\x44\xe6\x10\x47\x38\xa9\x1b\x89\x4c\xb0\xe6\x88\x10\x20\x1c\x9f\x01\x21\x04\x5e\xbb\x10\x3f\xf4\xf6\xdb\x74\xdf\x0b\xcb\x97\x2f\x87\xa1\x65\xcb\xc8\x9e\xc3\x13\xb5\x95\x70\x5b\x75\x8e\x06\x0d\x4e\xa7\x96\xa2\x94\x16\x8b\x5b\x49\x22\x72\xb3\x99\xe7\x35\x4a\x25\x24\x21\xb9\x46\x97\x00\x96\x97\xcf\x75\xa4\x10\xc7\xe6\x20\x91\xf7\x8f\x48\x08\x3b\xc4\x08\x84\xd0\x0a\xdb\xd0\xe7\x24\x17\x15\x21\xc6\xcc\xf8\x07\x0a\xa2\x5d\x0b\xe8\x71\xfd\xcb\x1b\x78\xbf\xcf\xa9\x58\x70\x5b\x5d\xc8\x42\xbf\xa1\x2a\x2a\xbc\xfb\x01\x96\x9e\x19\xef\xa8\x28\x2c\x9a\x3c\x99\x8d\xcf\x20\x6b\xc7\x91\x3e\xab\x13\xc8\x5d\xb7\x63\xbc\x70\xab\xca\xa8\x83\x90\xa3\x29\x5a\x05\x1d\x28\xf0\xd0\xe1\x1b\x54\xc6\xc8\xd4\xc6\x38\x14\x8a\xe8\x8c\x50\x4f\x91\x40\x2f\x0d\x90\xa7\x19\x74\x9d\x84\xbd\x46\x30\x4a\xb1\x3b\xdb\x16\xe0\x19\x0a\x94\x11\x8d\x1e\xa1\x6f\xdb\xdf\xc0\x8e\x5a\x34\xff\x4e\x65\xc3\x7e\xf1\x31\x65\xa4\xed\xbd\x74\x2c\xbe\x97\x8e\x2d\x1c\x37\x72\x16\x58\x1f\xf7\x5f\xae\x8a\x8c\x91\xee\x4d\x1e\x12\x07\xd1\x46\x34\x5f\xf2\x1a\x6b\xf4\xac\x01\x27\xb6\x52\x59\xc7\x54\x1d\x19\x09\x10\x12\x6b\x5c\x09\x2a\xca\xcb\x0b\x6f\x69\x25\x7e\xd3\x30\xa5\xb6\x13\xb7\x8b\x03\xb9\x8a\x5e\xe8\xf7\x16\x22\xbb\xdd\x87\xf0\x02\x0e\x8a\x16\x78\x58\xd6\xa6\x56\xb8\x8d\x3c\xef\xa3\x28\xb7\x1a\x06\xfc\x48\xa5\x52\x7a\xe4\xec\xe8\x5d\xac\x17\x43\x89\x2b\x5c\xb5\x38\x92\xe1\x80\xb4\x16\x78\x31\x32\x70\x2e\x6e\x00\x88\x26\x95\x5c\xc8\xf0\x67\xa1\x14\xd5\x3d\x71\x88\x90\x89\x5b\xd8\x40\xff\x2a\xae\x3a\x75\x79\xee\x37\x6b\x9f\xff\x47\xce\xd3\xe5\x5f\x8c\x58\xd7\xe7\xd4\xd6\xbe\x60\x6e\xfc\x75\xf6\x4d\xf1\xde\x23\xe2\x3a\xbb\x78\xb6\xfe\xcb\xf9\x1b\x1f\x11\x9e\x1d\xbe\x77\xc4\xc6\xe3\xab\xc1\x82\xc6\x7e\x78\x2e\xea\x9b\x7e\x50\x64\xa1\xfd\xd9\x02\xaf\x50\xd0\x67\x07\xb9\x46\xa5\x52\xa7\xd1\xe4\xfa\x60\x5e\xbe\xdd\xe8\x6e\xa1\xf2\x73\x6e\xa4\x20\xdc\x56\x52\x15\x69\xd5\x27\x43\xf1\x04\x92\xe9\xf5\x21\x56\x1a\xbd\x45\x1a\x12\x68\x12\x10\x34\x89\x70\x0a\x9f\x1c\x38\x71\xca\x43\x47\xe5\xba\xc7\xca\x47\xc6\xcf\x5a\xe5\x86\x6d\xb6\x4f\xda\xbd\xfe\xc8\xc0\x89\xd3\x17\x62\x78\xd0\xad\x33\x0e\xef\xa0\xa7\x34\x1e\x94\x8a\x1d\xa7\xdc\x76\xc7\xb8\x7b\xea\x8e\xbc\x81\x55\xef\xd6\x19\x4f\xed\xa4\xa7\x90\xf5\xac\x17\x07\x29\xbc\x68\x0c\xf8\x16\x27\xa4\xd4\x6a\x35\x20\xe8\x76\x38\x82\x1a\x98\x9d\x65\xd2\x59\x43\x2a\x27\x67\xf5\x21\x8f\xc9\xca\x31\x38\xc2\xd5\xba\x6e\x32\x82\x54\x3b\x47\x52\x7e\x09\x78\xfc\xe6\xa2\x3f\x5d\xbe\xfe\xde\x9b\x09\xfd\x97\x87\x1e\x3c\x6e\xf0\xf5\x02\x63\x7c\xff\x41\x8a\x10\xf2\x71\x8a\xa9\xda\x68\x4b\x07\xcf\x1b\xfd\x4a\xa5\xaa\x38\x37\xb7\x95\xca\xc8\x94\x44\xf2\x0a\x6b\x62\x79\xae\x2c\xb4\x1d\xb3\x78\xbf\xc3\x63\xf4\xe8\x70\x43\x8e\x85\x53\x19\x09\x5d\x43\xca\xbf\xbb\xc1\x9d\x6c\x22\x32\x27\xd6\x23\x7c\x83\x42\x54\xdb\x75\x7a\x9b\x9d\x84\xc5\x3e\x72\xb3\x95\xc0\x9a\xbb\xe4\x96\x19\xf4\x21\x2c\x7e\x7c\x05\xfe\xf3\xf0\x8e\x54\xf9\x69\x62\x45\x88\x12\xdf\x6d\xc2\x5c\xac\xa0\x69\x27\xb6\x35\x68\x7c\x41\x5c\x5b\xcf\x73\x4a\x87\xc3\x4b\x07\xb9\x60\x56\xc8\xe5\xc7\x05\xb5\x4a\x2d\x2f\x68\x05\xec\xc2\xd1\x89\xf6\xf9\x34\x94\xcf\x44\x99\x94\x39\xb3\x7e\x36\x65\x0d\x93\x92\xaf\x4c\x2f\x98\x7d\x86\xd4\xd0\x62\x69\x0b\xbb\x4d\xcf\x28\x8e\x2d\x4c\xd4\xcc\xea\x90\x88\x8f\x19\xd7\x49\x3a\x00\xad\x01\xf3\x16\x91\xb1\x5d\xd4\xa7\xa6\x5c\x26\x93\x15\xb9\xd9\x21\x26\xcb\xe5\x33\xfb\x0c\xb8\xc6\xd1\xca\x99\x05\x25\x9d\xba\x8d\x4c\x74\xfe\xa4\x7b\xd5\xf8\xca\x2f\xa9\x20\x6e\x52\xfa\x0b\xaf\x4e\x6b\xdf\x32\xda\x56\xfc\xe6\xfa\x2a\xdf\x29\xeb\xf8\xdd\x06\x64\x28\x0a\x6f\x50\xd4\x2b\xfb\x12\xff\x44\xfb\x9a\xa7\x0a\xa2\x02\xe6\xa1\xa0\x0c\x06\x8e\x53\x1a\x4d\x50\xcb\xb1\x3c\xa7\xe2\xc8\x86\x88\x98\x9a\x11\x3c\xe2\xfa\x28\xab\x0d\x67\xf0\x42\x00\xe7\x35\xf0\x25\x4e\x15\xb8\x28\x64\x33\x07\xf6\x8a\x91\xdc\x80\x72\x3f\xda\xa4\xfd\xbc\xb7\xce\xa6\x37\x5e\x7b\x95\x3e\x59\xd9\xf5\x8e\x0e\xf1\xbb\x98\x4a\xa9\x06\x74\xa0\x7c\xcf\xa1\x41\xde\xad\x9d\xea\x11\x6d\x61\x35\x18\x28\x81\xe3\x50\x18\xef\x74\x08\x1c\x66\x0c\xbb\x20\x7c\x26\xa0\x48\x4e\x10\xa0\x4a\x65\x22\x77\x01\xda\x66\x77\x01\x89\x48\x2e\x43\xa8\x14\x3b\x82\x09\x60\xb0\x12\x2f\x30\x23\xa7\x31\x50\x00\x12\xac\x08\x7f\x7c\x27\x5a\xd7\x2f\xd7\xc4\x8f\x69\x96\xad\x5b\xbd\x52\x4b\x77\xd7\x3c\x94\xce\x8b\x20\xfe\x18\x2f\x3d\x74\xec\xf0\x33\x70\xf0\x93\x0d\x0d\x4f\xca\x79\x44\x85\x81\xc4\x9d\x01\x6a\x5c\xb4\xd2\x4c\x31\x02\x84\x56\x5e\xe1\xd6\xe9\x14\x0c\x44\xfe\x07\x26\x72\x12\x00\x16\x55\x61\x34\x62\xe7\x96\xe3\x95\x06\xb5\xc1\x91\xcc\x90\x0a\x0a\x74\xcc\x14\xc2\xf5\x19\xd2\xcc\x61\xa4\xe0\xe0\xa4\x7c\xa9\x54\xfc\x56\xa6\x90\xc7\x63\x23\xa8\x88\xca\xb4\x6c\x3b\x7b\x5e\xec\x0a\xc4\xf8\xa0\x29\xa7\xf0\xc0\x1a\xa6\xd3\x6b\x45\xc7\xe1\x24\xd9\xc3\xa4\x05\xe2\x23\x8b\x86\x4d\x92\x86\x35\x69\x58\xbd\xf8\x42\xbf\x14\xd5\x83\x9c\x0f\xfb\x96\xdc\x6b\xe4\x62\xad\xac\x74\xfa\x01\x10\xb8\x70\x58\x70\xc2\xbc\x16\x7e\xab\x35\x64\x0b\x99\x70\x2e\xc8\xc3\xe0\x14\x98\x4d\x8b\x19\x40\x9b\x0d\xc1\x5e\x98\x16\x68\x54\xa4\x48\xc3\x49\x67\x4f\xaa\xa8\xb6\x1d\x30\x93\xca\x28\xac\xe3\x48\x38\x58\xc6\x53\x70\xda\xc4\xc9\xf7\x8d\x59\x78\x75\xef\xe3\x57\x17\x8e\xb9\x6f\xf2\xc4\x01\xa0\x17\x78\xe0\xf5\xe3\xf3\x0f\x78\x5c\xfb\xe7\x1f\x7b\x03\xdc\x4f\xf7\xaa\x7b\xe9\xc4\xe1\x93\x1b\xbe\x9c\x30\xe1\xcb\x0d\x27\x0f\x9f\x78\xa9\x8e\x06\xe2\x51\xf1\xe3\x1f\xc4\xf8\xdc\x19\xf7\xcf\x06\xf4\x3f\x41\x36\xe8\x4d\x7a\xdb\x06\x11\xce\x4d\x8e\x30\x2c\xf4\x8d\xb6\xe2\x75\x16\x35\xc7\x39\x15\x94\x8d\x61\x28\x1d\xf4\x79\x0d\x68\x51\x0c\x56\xb5\x19\x27\xf1\x94\x94\xc2\x85\x1d\x4f\x80\x1c\x65\x90\x46\x0a\x91\x76\x05\xd2\x1c\x97\x0f\x18\xc3\x68\x01\xb2\xb1\x93\x82\x89\xe9\x8c\xe6\xd2\x70\x8e\xb1\x3d\xc8\xb6\x58\x6d\x48\x71\x83\xbf\x9f\xba\x00\x96\xef\x7e\xef\x25\x71\xcc\xc7\x77\x4f\x9e\x34\x26\x7e\x74\xf4\xd8\xf1\x23\xc5\x41\xe0\x51\x1b\x30\x03\x08\xfe\x2c\x01\x0b\xc5\x39\x16\xf1\x7b\x31\x2e\x52\xad\xc4\x3b\xe1\x6b\xaf\xbd\x6e\x69\x7c\xc6\x7a\xe1\xec\xf1\x77\xdc\xb0\xb3\xf3\x4d\xac\x27\xf2\x9b\x7e\xa0\xf3\xd1\xe1\xb0\x50\x79\x51\x0b\x6b\x36\xa3\x70\x50\xb0\x2a\x19\x0b\xa7\xe5\xfb\xc5\xb4\x56\x46\x48\x6a\xb0\x34\x8c\x42\x80\x0d\x5f\x21\x08\x25\xaf\x25\x91\xc5\xa0\xb3\x15\x07\x58\xc8\x04\xab\x87\xdc\x82\xef\x72\x27\x4e\x67\x2a\x1b\x5f\x9c\xf1\xe0\xa4\xf1\x77\xdf\x9e\xaf\xd9\xa3\x39\xdb\x40\x97\x26\xdf\xc7\xbe\x71\xdd\xfb\xa8\xff\xef\xf7\xb1\x6f\x5c\x2b\x4e\x7f\x1f\x7c\x85\xbc\x0f\xf9\x42\xff\x46\xe3\xb3\x63\xbc\x78\x9b\x56\x0b\x80\xd1\xa1\x70\xea\x38\x3b\xc7\x59\xfa\xe1\x7c\x30\xd3\x2f\xa6\xce\x80\x24\x4a\xa5\xde\x13\xa6\x92\xd4\x05\x38\x00\xa9\x60\x4d\xbe\x1d\x57\x39\xb4\xed\x2a\x86\xa7\xdf\x99\x18\xee\xb5\xde\xb5\x9d\x0c\x3b\xb4\x20\x17\x74\xb8\x6f\x58\x72\xc8\x92\x2e\x26\xf7\xe9\x66\x2a\x37\x6a\x51\xa0\x31\x53\x94\x0e\x67\x5b\xfa\xc5\x34\x3c\xf2\x93\xc8\x56\xa8\xc8\x84\xc6\x36\x1b\x9b\x5d\x97\x23\xbd\xbb\x32\xed\xaa\x7c\xe2\x74\xb4\xf7\xbe\x49\x5e\x94\x9f\x6d\x68\x0c\x51\x19\xef\xf2\x50\xad\xa3\x6e\xd6\x64\xa2\x3c\x1e\xbb\x16\xed\x44\xd6\x45\xbb\x84\x7e\xc8\x3a\xa9\x0d\x68\xc0\x29\xcb\xd4\x2c\x01\x27\xd9\xa5\x66\x2f\x96\xe6\x40\x89\x8c\x40\x33\x19\xda\x94\xb7\xce\x0f\xfa\x0a\xc4\xef\x61\xfb\x34\x51\xe2\xb1\xda\x4e\xfa\xdd\xac\x02\xe4\x4a\x3a\x9e\xc8\x63\xa0\x3c\x51\xa4\x69\x95\x14\xcf\xb1\x9a\x7e\x31\x36\x51\x4e\x98\x88\x36\x22\xc6\xd2\x8c\xb1\x0e\x3d\x3d\xaf\x2d\x7a\xc7\xec\x7b\xe8\x43\xf3\x4e\xe0\xdf\x5d\xb1\x37\xbe\x0c\xd7\x04\xa1\xf1\x39\x13\xbf\x87\xec\x85\x82\xe7\xc8\x12\xf2\xd2\x81\x4a\x45\x2f\xa9\x7b\x65\xe4\x55\x1a\xc1\x9d\xf7\xce\xa8\xca\xca\x6e\x3b\xef\xf4\x50\x34\x71\xe0\xa9\x5d\xe8\x17\xef\x3c\x31\xef\xda\x7e\xac\x8f\x90\x8c\x4c\x11\xda\x23\x7a\x24\x53\xf7\x68\xb6\x56\xa3\xd6\x29\x38\xe4\xdc\x03\x93\x42\xa3\x00\x10\x93\xe7\x71\x28\xa4\xe5\x38\x5c\x6e\x52\x13\xa3\x39\x2d\x10\xd2\x2a\x33\x9a\x45\x34\x52\xde\x96\x70\x6e\x07\xa4\x42\x48\x10\x02\x21\x07\x08\x94\xe0\xb4\x1e\xe8\xd8\x00\xde\x3e\x7e\x79\xfd\x52\x30\xf2\x63\xb1\xe1\x1c\x30\x7d\x32\x75\x1c\x53\xb9\x7b\xcd\xfc\x03\x0e\xb1\x1a\x1c\x03\x7f\x89\x2b\x4f\x0e\x1d\x22\xe9\xc9\x74\xb9\x3a\x46\x03\x80\xa1\x68\x88\x62\x7c\x4a\x10\xb4\x4a\xad\xcd\x4a\x59\x6a\xa4\xba\x66\x1d\x47\xdc\x0d\x21\x15\xf5\x47\xd2\x8d\x53\x32\x7b\x1c\x49\xb0\xca\x85\x02\xc6\x08\xe9\x99\x44\xff\x02\x3a\x9e\x03\x3d\x3f\x16\xb7\x2e\x5d\xff\xd1\x31\xb1\xa4\x01\x18\xc6\x4f\xf9\x44\xbc\x4a\x2f\x04\xc7\xc4\x6a\xc7\x13\xf3\xd6\xec\x46\xe7\xb8\xcf\x90\xa1\x27\xc5\x95\x64\x7f\x55\x20\xdf\x07\xd7\x15\x97\x91\x4c\x68\x5e\x5e\xa9\xcb\x60\x28\x15\x2c\x16\x45\x56\x56\x41\x29\x6c\x5d\x5e\xd2\xb2\x26\x56\xe2\x6a\xa1\x70\x41\x63\x4e\x0e\x06\x3a\xcf\xb1\x62\xc8\x5b\x01\x73\x72\x44\x92\x8d\x36\xb6\x8a\xeb\xea\x03\x64\xaf\xe8\xbf\x55\x10\x4b\x59\x47\xc2\xd4\x41\x76\xa4\x03\x5c\xb6\xad\x9e\x77\xf3\xda\xe1\x6f\xde\x39\x38\xe1\xfe\x8a\xbc\x60\x56\x3e\xb2\xb3\x9e\x41\xb5\xff\xa1\x6a\xb8\xfd\xa6\xc7\xdb\x6e\x5f\xa5\xdb\xc5\x2a\xd1\x11\x9e\x8b\xfc\xbc\xa5\x68\xaf\xf5\x46\xfa\xdd\x8e\xcf\xad\x55\xad\x76\x70\x4e\xda\xa1\x37\xe1\xc8\x9c\x62\xfb\xa5\x90\xcc\x48\x7c\x29\x59\x21\x19\xbb\x1d\x85\x2e\xe9\x84\xeb\x46\x8b\x82\xef\x53\x5e\x55\xd1\xba\x9d\x6b\xc3\xc3\xe3\x5a\x16\x77\xec\xd5\x63\xa3\x38\xc8\xbc\xc3\xde\x72\xc0\xdd\xcc\xaa\x83\xcf\x98\xf6\xba\xc6\xcc\xbb\x36\xad\xe1\x29\x72\x86\x9b\x5e\x42\xef\x5d\x8c\xde\xeb\xc7\x37\xe9\x46\x83\xc1\x07\x28\x10\xe0\x94\x41\x7b\xc0\x4f\xd5\xc4\xfc\x02\x81\x93\x77\x19\xd1\x56\x34\x0a\xe4\x30\x51\x69\xd6\x31\x29\x50\xd2\x8d\x2b\x2e\x2a\x8f\x64\x48\x93\x91\xbc\x6d\x8f\x51\x7b\xd9\xb3\x1b\xb7\xc5\x4a\xb0\x5c\x07\x0e\x6c\xdc\x2c\x8b\x7a\x76\x39\xfc\xf4\xc8\x61\x22\x5b\x63\xd7\xe5\x5d\x1a\x9e\x92\x04\xce\x26\x32\x2e\x40\x32\x56\xa2\x73\x48\xe6\x86\x87\xd0\x61\x75\xaa\x1d\x3a\x65\xbf\x98\x8e\xa7\x2c\x37\x9e\x1b\x90\x59\xed\x21\x48\x59\x28\xa4\x5c\x41\xc3\xa6\xd5\x3d\x7a\x74\x2c\x6e\x39\x68\xd7\xa3\xf6\x36\xa5\x15\x55\xe5\xe2\xa0\x27\x8f\x41\xfd\xc2\x3b\x5d\x7b\x4d\xfb\x0f\x35\x7e\x79\xe7\xa0\x96\xf6\x1d\x66\x72\x26\x28\x71\x20\xec\x41\xee\x87\xc3\x28\xba\xc8\x73\xab\x68\x14\x09\xe9\x55\xfa\x1c\x97\x39\x97\x0e\x3a\xf4\x8c\x96\xd2\x66\xa1\xc3\xa0\x65\x78\x7c\xaf\xc6\xa3\x23\xc4\x20\x4f\x88\x91\xe4\xe1\x5f\x4d\xbf\x9a\xb4\x61\x5d\x9f\xe1\xed\x82\x42\x7c\x57\x2c\xe3\x17\xd9\x92\x89\x1e\x34\x67\x56\x5b\xb6\xe4\x5f\xe0\xff\xa4\x8f\x75\xe9\x5f\x7b\xa6\xfb\xac\xee\xcb\xe6\x47\x3b\x83\x2c\x69\x45\xc7\xcf\x8c\x4f\xef\x50\xd8\xbe\x7b\xef\x8a\xca\xd6\xe2\xc0\xc1\xa3\x9f\x6f\x37\xa9\xff\xf4\x25\x76\x26\x1f\xdc\x21\xad\xef\xaa\xba\xfd\x4b\xdb\xb4\x1e\xde\xa7\xb8\x03\xe1\x15\x69\xa2\xf3\x48\x3f\x7e\x87\x68\x90\x55\xa9\x0c\x5a\x8b\x1e\x39\x72\x0a\x2b\xab\xaa\x8d\xb1\xac\xc1\xa0\xad\x8d\x19\x0c\xb4\x46\xa0\x91\x2b\x44\x53\x69\xec\xe1\x52\xcf\x00\x88\xa4\x2a\x36\xcd\x48\x58\xb2\xaa\xca\x10\xe6\xa8\x90\xe6\xd8\x47\xd8\x44\x12\x74\x2a\xec\x6c\xfb\x6f\x8d\xef\xe1\x06\x34\xc8\x12\x06\x91\x74\x9e\x17\x0b\xb6\x15\xb8\xe8\x9c\x51\x30\x7a\x0b\x63\x15\x0c\x84\xd5\x44\xab\x56\x72\xe4\xed\xf2\x5a\xbe\xda\x2c\x5d\x21\x5d\xac\xdf\x80\xce\x25\xe3\xcd\xe2\x04\xfb\x6f\xcc\x38\xfc\xe6\x6b\x67\xc9\x9b\x69\xca\x89\x7c\xf0\x5a\xa4\xd7\xdc\x68\x0d\x71\x65\xa7\xdf\xaf\xa6\x59\x56\x0d\x42\x21\x97\x4d\x6d\xcb\xcd\x09\xaa\x1c\x4e\xe4\xc3\xb2\x80\x77\x3a\x2d\xd0\xcd\x59\x3c\xb8\x13\x5c\x97\x24\xed\xc8\x2c\xea\xaa\x68\xae\x43\x40\xaa\x1a\x3a\x2d\x3c\x97\xb0\xa9\x13\x55\xd1\x5e\x00\x2a\xc1\xef\x0d\xe3\xc7\xa7\x87\x2b\xe3\xc6\x81\x75\x28\xc6\x52\xe7\x0d\xc5\xac\x86\x24\x75\x16\x4f\x05\x2c\xb3\x16\x81\x8b\x8d\xed\x4e\x6c\x13\x30\x9f\x1c\x99\xbf\xfe\x68\x1c\xad\xd1\x38\x0a\xa9\x5e\xd1\x16\x59\x2e\xa3\x2a\xd7\xa7\xf2\xb5\x12\x74\xb0\x15\x2c\x2e\x0a\x66\xd7\xc4\x82\x9c\x4b\xc8\x55\x31\x7a\x4a\x8f\x62\x5c\x3d\x47\xd9\x53\xa4\x9a\xe9\x5a\xf0\x3a\xe6\x8e\x20\x55\x56\x5a\x9e\x48\x7f\x48\x77\x40\xc9\xc6\xf5\x1c\x29\x33\x24\x5f\x6e\xe2\x94\x34\x45\xdf\xf2\xb9\xf8\x53\xff\x48\x20\x3f\xbf\xef\x03\xb1\x7b\x3a\x75\xde\xbb\x6a\xe5\xbe\x4e\x9d\xef\x1d\xfc\x40\xdf\xfc\x7c\x7f\x69\x7f\xf1\x67\x0b\xa0\xde\x5b\x3e\xbd\x5b\xd4\xed\xcb\x5b\x76\xd7\xa0\xe1\x53\xa7\x0e\xdb\x7e\xfa\xf4\xf6\x61\x53\xa7\x0e\x1f\x7c\xe7\xb2\x3c\x9f\xa7\x7d\xf7\xe9\xcb\x2f\x8a\x71\x99\x4f\x05\x7e\x45\xfc\xc1\x16\x51\xb3\x5a\x81\xb4\x0f\xa5\xa0\x04\x2b\xce\x2c\xeb\xd2\x32\xcb\x99\xe5\x2e\xa4\xc2\x45\xce\x1e\xf8\x8d\xa5\x34\xf2\x20\x4c\xf0\xab\xef\x3e\xfe\xf0\x95\x67\x26\xce\x05\xb0\x43\xf1\xf3\x65\x95\x74\x5b\xf1\x3b\xf1\xb5\x77\xbf\xa2\x37\xc4\x47\xae\x5d\x07\x5e\x58\x06\x6c\x23\xa6\x8b\x3f\xe0\x77\x2a\x51\x60\x86\xef\x1b\xd4\xd8\x27\x24\xb5\xe6\x2a\xb5\x9a\xa5\xa1\x56\xc3\x42\xa8\x96\x49\x2b\x8d\xcd\xab\x83\x22\x20\x04\x73\x38\x00\x43\x60\xf3\xfb\xa0\xfe\x85\xa6\xd2\x50\xce\xbf\xcf\x20\x2f\xec\x55\xfa\xdf\xc7\xa6\x4d\x8f\xb7\x97\xf6\xb8\x02\xa9\xea\xb3\xc4\xff\xc3\x3c\x39\x6a\x9b\xdd\xce\xa8\xa1\xd3\xa1\xb1\x0b\x06\x0b\x03\x8d\x82\x12\xff\x7a\x49\xb5\xad\x22\x8d\x94\x0d\xff\xb8\xd9\x6a\xab\x06\x66\xfc\x0e\xdc\xa2\x06\x31\x4f\x24\x79\x57\xd1\xc5\xa7\x9c\x4e\x73\xe8\xf0\x3b\x20\xe7\xc8\x53\x6a\x1f\x2c\x7c\xf1\xec\x99\x7c\xa8\x0c\x1f\x3d\x8c\x82\xce\x5e\x77\x2d\x1f\xf6\x28\xfd\x14\x12\xe1\xf5\xd0\x46\xdf\xbb\xf1\x02\xfa\xfd\x83\xc1\xf0\xd3\xf1\x88\x24\x0b\x72\x29\xe0\xcf\xec\x17\x98\x74\x0b\xcb\xc2\x1b\x8d\x6a\x03\xcd\xd8\xac\x06\x4a\x63\x14\x08\x33\x08\x48\x9a\xf0\x0c\x7e\x12\xa2\x84\x38\x90\x14\x06\xb4\xa7\x61\x47\xb9\xdc\x0f\x3c\xf6\xc2\xdf\x2c\xdd\x98\xce\x5f\x9d\x06\x8f\x44\x27\xaf\x62\xbf\x20\x35\x7e\xd7\xde\xa0\x07\xb6\xbe\x6c\x7a\x25\xde\x87\xa9\xdc\x7f\x60\xa0\xf4\x7e\x17\x52\x86\x7a\x34\x17\x2a\x2a\x1c\x35\xb1\x0a\x15\x05\x69\x9a\x52\x40\x8d\x9a\x61\x69\xa9\x8c\x33\x52\xd1\xac\xab\x43\xba\xbb\x31\x82\x06\xf1\xae\xd7\x41\x4b\x50\xf6\x9a\x38\x04\x1c\xa7\x17\x88\x26\x70\x35\x3e\x4b\xec\x21\xfd\x6e\x31\x72\xa9\x26\x93\x3d\xd3\x36\xea\xd7\x50\x06\x93\x59\xa7\xe3\x4c\x28\x5a\x65\xad\x3c\x8a\xa8\x79\x8e\x14\x22\x09\xe9\x19\xc8\x84\x6d\x30\xa5\x5e\x96\x2a\x2e\x36\x96\x05\x64\x3e\x84\x00\x7c\x36\xbf\xbc\x2c\xbb\x53\xe5\x4f\xf1\x96\x09\xdc\x01\xfa\xe4\x94\xda\x4e\xda\x9d\x3a\x90\x3b\x5f\xc6\x1d\xc0\x3a\xa5\xb8\xa9\x37\xd3\x02\xc9\x60\x45\x56\x33\x16\x2d\xd4\x18\x30\x95\xb9\xd5\xeb\x55\x18\x05\x2b\xc7\x99\x04\x05\x13\x0c\x08\x26\x33\x52\x67\xd0\x86\xfe\x86\x9c\x99\x73\xf2\x56\x5c\x13\xa2\xd3\x90\x3c\x03\xe9\xff\x89\xc8\x98\xa4\x37\xf2\xe8\x48\xae\x3a\xd1\xdc\x92\x0f\x14\xca\x9c\xf2\x84\x98\xd9\x28\xd0\x97\xdc\x16\xb0\x6f\xf4\xa9\x11\xd3\x97\x2c\xdf\x18\x2f\x0a\x2e\x2b\x17\x2f\x24\x85\x2e\x28\x1c\xd5\xe5\xc9\x5e\x5d\x5a\x2f\x3b\xb0\x6d\xd6\x5d\x33\x66\xde\xde\xbf\xdd\x34\x59\xfa\x63\xb5\x77\xb6\x2c\xcf\x69\x85\x73\xe9\x18\xbb\x12\x8d\xc1\x85\x11\x32\xa0\xdd\xee\x72\xd2\xb4\x45\xa1\x77\x29\xa0\xc7\xed\x80\xd0\x8e\xe5\xd6\xa0\xbd\x82\x62\x4a\x83\x06\xf9\xf3\x94\x8b\xdc\x18\xca\x89\xf5\x64\xc5\x7b\xa6\x96\x96\xfd\x92\xcc\xec\x6a\xda\x75\x33\x08\x4c\x85\x53\xc4\xf9\x2f\x7f\x36\xfd\xf2\xf2\xcb\xa2\xed\x88\xf9\xd1\x25\xf5\xbb\x8e\x3d\xd6\x17\xd4\xc7\x3b\x30\x95\x47\xc4\x8d\x8e\x6b\xaf\x2d\xfb\x72\xee\xe9\x93\xba\x45\xf7\xbd\xb6\x7b\x4b\xc3\x6a\xb0\x00\xcf\xf7\x78\x71\x20\xd3\x83\x69\x8b\x66\x3b\x8f\x1a\x1b\xad\xca\x55\x5a\xec\x0e\x93\x29\xa4\x03\x5e\xd6\xaf\xf4\x1b\xdc\x6e\xbb\xa0\x64\xf2\x5b\xda\x05\x2b\x72\x4d\x41\xc8\xab\x63\x90\xe4\x48\x25\xe2\xee\x42\x8d\x43\xe3\x80\x56\x8e\x82\x30\x50\x2b\xf5\x36\xcb\x94\x19\x15\x32\x96\x89\xd4\x1a\x97\x1c\x43\xda\x26\x01\x39\x69\xf6\x39\x39\x02\xbc\x06\x56\x13\xd2\x92\xc8\x4a\x97\x94\xcb\x69\x0a\xf8\xcd\x03\xeb\x3e\x9a\xdb\x30\xfc\xc0\xd6\x13\x1f\x98\x5f\xd8\xd4\x17\x2c\x8e\x77\x42\x23\x5d\x74\xea\xf3\x0e\xed\x3b\xc5\xb7\x3c\x33\xe2\xd0\xee\xee\xfd\x66\x88\x03\x97\x2c\xbe\xe5\xfe\x5b\xa7\x2d\x58\xdf\xf9\x96\xcd\xcf\xac\x06\x0b\x57\xa0\x21\xdb\xc5\xf8\xd9\xf9\x13\xdb\x74\x57\x8c\x59\x51\x59\xd6\xee\x56\xe2\xf7\xa2\xb3\x7b\x18\xf9\x1d\x36\xdc\x27\xa5\xd3\xdb\x28\x14\xc7\x51\x7a\x68\x77\x90\xb2\x27\x48\xf1\x3a\x9d\xd4\x4a\x47\xfd\x97\x3e\xa9\x54\xa5\x56\xa2\x3e\x90\x34\x6e\x8d\x2f\x68\xb7\x66\xf9\xe2\xb5\x72\x6d\xe0\x97\xff\xbe\x70\x96\xf6\x9a\x5e\xfb\xf0\x93\x13\x52\x55\xe0\xf7\xe2\x8f\xbf\x88\x9f\xf1\xe2\x1c\x2c\x0b\x0a\x0f\xe0\x39\x22\x4b\x65\xd4\xab\xd5\xd8\x28\x23\xc3\x50\x1a\xe8\xb0\x5b\x00\xae\x50\xa4\x94\x4a\x03\xf6\x80\x94\x92\x28\x69\xfb\x22\x53\x12\xdc\x97\x7a\xdd\xa5\xb1\x11\x7c\xff\xe2\xdb\x3f\x7e\x2e\xdf\x16\xaf\x9e\xbb\x6c\x6d\xbb\x02\xb0\xc0\x08\xfc\xbf\x20\x2d\x20\x90\x8b\xe2\x67\xae\xbc\x7f\xde\x14\xff\xbb\x74\xf6\x2b\x70\xad\x24\x91\x25\x12\x75\x1a\x19\x60\xd5\x58\x19\x24\x89\x8d\x92\x65\xb0\x02\x14\xa5\x24\x5a\xed\x9b\xb5\x9e\x60\x53\x8d\x69\xa8\xe8\x8c\x3d\x89\x7c\x17\x23\xed\x7f\xf1\xed\xdf\x12\x57\xd6\x0f\x3f\x84\x85\x60\xdf\x14\xc7\x1a\xc5\x2b\xbf\x88\x3f\x89\xdf\x11\x31\x4e\x7e\x7c\xe9\x65\x13\x5d\x81\xf9\xb3\x90\x4f\xf8\x3a\xf2\x45\x5d\x54\x45\xd4\x65\xc0\x95\x2a\x16\xc1\x25\xb8\x3d\x16\x8b\x1d\x13\xb4\xd8\xa1\xa6\x26\xa6\x54\xe2\x1b\x49\x22\x40\xe2\x6e\x28\x03\x6d\xdb\x9c\x31\x15\x46\x4b\xaa\x69\x95\x36\x0e\x4a\x56\x36\xae\x59\xb2\x6a\xb9\xdc\xa7\xfa\xc5\x8f\xb4\x37\x59\xcc\xf8\xc2\x67\xe2\xd8\x4b\xef\x93\xc6\x54\xe0\x03\x66\x0a\x26\xb8\x65\x09\x96\xa9\x17\xed\x19\x0f\xe7\x75\xb9\x28\x41\x45\xa9\xfc\x3e\xb7\xcb\xed\xd2\x32\x5a\x14\x48\x68\x19\xc6\xde\x2f\xc6\x34\xbf\xe5\x97\x45\x4b\x74\xaa\x64\x30\xc8\x9a\xd2\x69\x63\xb3\xcb\x22\x42\x26\x75\xec\x87\xa0\x6a\x6f\x06\x67\x6c\x7c\xdf\x4b\x99\xb4\xb1\x4f\x88\x27\x3e\xcd\xa4\x8b\x3d\xf0\xc9\x27\x24\x37\x8a\xf3\xb1\xdf\x20\xfd\x83\x39\x2c\x03\xd4\xc4\xa8\x45\xe1\x84\x4e\x9e\x37\x78\x21\xb4\x68\x0c\x9a\x60\xa8\x28\x84\xa1\xdc\x5e\x88\xe6\x7a\x43\xdd\xb8\x50\x61\xe8\xb3\x10\x54\x43\x85\xd3\xee\xb4\xd7\xc6\x38\x27\xd0\x42\xa7\xd3\xc0\x71\x0e\x1c\x2a\x1b\x78\x4c\xd7\x74\xc3\xea\x17\x5c\xdc\x94\x3f\xc9\x68\xca\x20\xc5\xae\x48\x94\x87\x4b\xf0\x3d\x38\x44\x35\x27\x74\x94\x23\xb1\x33\xe8\xd2\x73\xe7\x26\xdf\x33\x7f\xfe\x27\x67\xc5\x4e\x0d\x3f\x2c\x9d\x78\xdf\xaa\x2b\x97\xe7\xdd\x73\xe7\x4c\xa6\x72\xf9\xc2\x61\x0f\x08\x4a\xe3\x82\x71\x0f\xef\x41\xf1\x6a\x8f\x01\xc3\x46\xf7\x03\x2f\x8a\x2f\x74\xbb\xad\x6f\x4f\x29\x96\xee\xde\xf4\x4f\xf8\x96\x5c\xc3\xd3\x37\x9a\x47\x79\x15\x8a\x40\x40\x6b\xe5\xdc\x56\x77\x6e\xce\xff\x63\xed\x3f\x00\xa3\x2a\xb6\x07\x60\x7c\xe6\xce\x2d\xdb\xef\xdd\xbe\x9b\x4d\xb2\x1b\xd2\x20\x09\x24\x64\x53\x08\x2d\x8b\x22\x52\x14\x42\x0d\x0b\x84\x20\x4d\xaa\x54\xe9\x25\x74\x14\x29\x2a\xa0\x08\x28\x2a\x8a\x62\xa1\x85\x62\xa1\xa8\x3c\x15\x05\xc1\xde\x95\xf7\x04\x0b\xa0\x62\x7d\x4f\xc8\xde\xfd\x9f\x99\xbb\x9b\x6c\x02\xbe\xf7\xfb\xfe\xdf\x17\xc8\x6e\xf6\xee\xcc\x99\x76\xe6\xb4\x39\x73\x4e\xaa\xde\xa4\x07\xe9\x46\xd6\xc3\x10\x40\xcd\xcb\xd0\x0e\x27\xb4\x8b\xd0\xff\xcd\x81\x87\x5d\x70\xd0\xd6\xa8\xe8\x5a\xb7\xb3\x8e\xb8\x54\x13\x8c\x8a\x4a\x63\x14\xcb\x46\x94\x35\x8f\xc6\x5d\xcf\xa6\x4d\x9c\xb6\xb8\xe3\xe1\x3f\xae\xbe\xfc\xc9\x5f\x93\x26\xbe\xff\xd2\x37\x7f\x72\x79\xef\x9c\x8e\x39\x9e\x0d\xa9\x1e\xf6\xfa\x06\xf5\x9f\xea\xd9\xa7\xef\xff\xa2\x45\xb3\x29\x03\xd7\xec\x50\xbf\x41\x71\xff\x11\xfe\x71\x81\xa0\x6c\x7a\xe3\xc0\x47\xbd\x08\x15\xd1\x95\xe6\xb2\x28\xa4\x05\xac\x4a\x45\x38\xd5\x4b\xf3\xfc\xfb\x90\xd7\x02\xa8\x67\xf7\x7a\x09\x75\x42\xb2\x03\x61\xb2\x5f\x8b\x64\x89\xf9\xf4\x0b\xe3\xce\x57\x71\x17\xc2\xb8\x0f\x49\x71\xa2\x83\x89\xbb\xc1\x46\x93\x82\x49\xb3\x06\x7f\x92\x06\x3f\x93\x8d\xe3\xf4\x4b\x66\xe4\x17\x65\xe4\xde\x50\xca\x45\xe2\x5e\x25\x77\x25\x7a\x9b\x74\x9d\xbd\xd4\xb4\x51\xb9\xf9\xd6\xf7\xd8\x59\x25\xe0\xdc\x79\x76\x7e\x5c\x19\x4a\xc5\x7a\xbd\x81\x13\x45\xc1\x20\x98\xcc\x21\x73\x85\x79\x98\x99\x84\xcc\x35\x66\x0e\x99\xb1\x42\xcc\x14\xf3\xec\x76\x77\x57\x0c\x1a\x52\x3e\x86\x1f\x03\x31\xca\xa2\x21\x7e\x48\x90\x5f\x95\x8b\x73\xa9\x67\xd9\x54\xab\xad\x91\x5d\x9e\xa9\x03\xe9\x2c\x28\x31\x13\xfa\x6b\x55\x7d\x2d\x08\xf8\x25\xf8\xad\xab\xaf\xe3\x1f\x55\x3b\xb4\x4e\x10\x56\x2b\x49\x0b\x16\xeb\x25\x19\x78\x5a\x9f\x50\x6e\x8a\xe4\x74\x06\x4c\x20\x47\x10\x0b\x69\x96\x96\x9a\xd2\x37\x9c\x8a\xcc\x6e\x11\x84\x07\x83\x2c\x42\xd3\xa2\x88\x74\x32\xb2\x35\x04\x34\xd7\x02\x24\x37\xb9\x04\x13\xbf\xd2\x15\x4b\xee\x1f\x3b\xd2\xa5\xaa\x09\xf5\xa2\x66\xf9\x30\xe9\x4c\xd3\x53\x7b\x5c\xf9\xc8\xc1\xfb\xb6\x1e\xae\x5d\xb9\xb2\xd7\xfa\x25\x03\x86\x1c\xbc\xb5\x53\xef\xdf\x6b\xd5\xca\x55\xf3\x17\x2c\x22\x5f\xd4\x65\xac\xca\x1c\xbe\x25\xbc\x66\xfc\x78\x4f\xfb\xb2\x36\x9d\xc4\x76\xda\x1d\x2f\x0c\xfd\xbe\x83\xcc\x61\xf3\xd7\x31\x94\x6a\xc0\x46\x8e\xce\x1f\x88\xcf\xc8\x28\x18\xcd\x26\x89\xe3\xa0\xab\x7a\x3a\x4f\x20\x47\x97\xbf\x5e\x1e\x13\xb8\x9a\x64\xa4\x67\x3e\x94\xb8\x94\x4d\x13\x4e\xd7\xe3\x0f\xf0\x1d\x4b\x61\x9a\x32\xdf\xc7\x07\xd5\x42\x98\x2a\xdb\x44\xbc\xe8\x4a\x11\x79\x24\xf2\x1b\x7e\x97\x1b\x8b\x62\xeb\xc6\x45\xa0\x5d\x81\x9e\x31\xf3\xd0\x0f\x49\xe4\x64\xcc\x03\xad\x77\x36\xf1\x23\x68\x41\x87\x9c\xc6\x45\x22\x77\xed\xc1\xaf\xc3\xe6\x1c\x5c\xef\x0b\xf6\x19\xcb\xf9\xdb\x9c\xfa\x79\xa7\x18\xdc\x6e\x57\x3a\x71\x91\x16\x4a\x8e\xdb\xc7\x4e\x93\xb1\xce\x2b\x20\x21\x50\x41\x6d\x85\x59\x8d\x15\xa7\xf8\xf1\x60\x13\x2f\x69\xa1\xde\x37\xba\x51\xd2\x5f\x2d\xfe\x86\x3d\xf1\xaa\xc3\xb9\xf8\x85\xae\x78\xd2\xdf\x5a\x7a\xcd\xeb\xbd\xf8\x95\x2e\x47\xfc\x3e\x17\x0e\xc4\x52\xfe\xfe\xb5\x0f\x1f\xdc\x3e\x7e\x30\xd7\x31\x7e\xa3\x2b\x9e\xb7\x6e\x37\x3b\x17\xa7\xd1\x77\x90\xc5\x93\x9c\x8c\x53\x92\x24\x87\x23\xc5\x42\x02\x69\xc8\x4f\x43\x99\x81\x14\xd7\x3b\xcc\x03\xd6\xc8\xbc\x9f\x2f\xe7\x61\x2d\x3c\xbc\x87\xb7\xa6\x38\xcd\xb1\x5c\xb5\xa8\xde\x2d\x9f\xc9\x3f\x94\xc2\x34\x49\xdb\xd9\xe0\x97\x6f\xff\x1b\xf1\x81\x5d\x5b\x86\x9d\x9a\x8f\x3b\x5c\x23\x46\xe0\x1e\xea\xfe\x5a\xf5\x35\xd8\x7a\x86\x6b\xe5\x89\x3b\xe6\x6e\xda\xa4\xe1\x51\x2f\x18\xcb\x19\x36\x96\x11\xa1\x12\x8f\x60\x4c\xe5\x38\x89\xf8\x6d\x56\xea\xd6\x19\x48\xc3\x82\x28\xf4\x0e\xa7\x8a\x3e\x1d\x0c\xc4\xe7\xf7\x95\xfb\x28\xe1\xf7\x89\x3e\x62\x61\x49\xa3\x6c\x16\xcd\xb5\xa1\x71\x06\x83\xeb\x7a\x38\x68\x9e\x48\xac\xbb\xf0\xef\xfa\x32\x48\x1a\x39\xa3\xbe\x56\xab\xee\xc7\x3d\xae\x11\x03\x70\x87\x4d\x9b\x36\xcd\xbd\x83\x09\x24\x0a\x76\xc5\x24\x01\x10\x48\xd4\x3f\xe3\xe7\x7b\x52\x0d\x8c\x83\xc6\x04\x6a\x0e\x63\x29\x4e\x32\xb8\xb3\xb2\xec\xf6\x00\xb1\x65\xbb\x3c\x2e\x9b\x81\x6f\x91\xe3\xca\x76\x66\x57\x84\x9d\xa0\xa2\x80\x52\x2b\x99\xd2\xe9\x2d\x09\x29\x05\x64\x04\x17\x0d\x90\x00\xa8\xd6\xe0\xac\x92\x78\xa3\xe6\x9a\xdc\x49\x31\x41\xea\x1a\xc7\x7c\xcd\x99\x21\xad\x91\x5b\xbe\x1e\x74\x99\x1b\x9b\xf8\xe5\xd7\x92\xa9\x91\x01\xdc\xe9\xbf\xee\x8f\xfb\xe5\x73\x1f\x71\x3b\x22\xe1\xc6\xae\xf9\xf8\x15\xf5\x0e\xd0\x12\x56\x71\xa9\x31\xdf\xfc\xc8\x2a\x92\x11\xf7\xa7\x1c\x20\xe9\x60\xac\xad\x51\x07\x74\x77\xa8\x9b\xbd\x79\xf3\x36\xe9\xe9\xae\x16\xd6\x36\x96\x94\xe4\x64\x4b\x8e\x2c\xb7\xb2\x14\x8a\xa2\xc5\xea\xe2\xcb\x3b\xa6\x24\xb5\xb2\x67\x33\x6f\x99\x56\x4e\x5b\x8e\x92\x43\xd5\x32\x0b\x62\xf7\x9d\xda\xd1\x33\x4e\x96\x63\x9b\x90\xe2\x7a\x1d\x3f\x76\x0d\x34\x71\xf0\x31\x03\x54\xc3\x81\x41\x23\xc3\x4b\xcc\xc5\xe6\x3a\x41\x80\x62\xd2\x39\x3c\xae\xf7\xf7\x8f\x3b\x76\xfc\xcf\x2b\x53\xdc\x55\x75\xd9\x91\x7f\xce\xfd\x62\x95\xba\x6e\xe0\xf6\xf4\x7b\x26\x2d\x7f\xee\xd0\x63\x7d\xf0\xb2\xc8\xe1\xbf\xbf\x4b\x45\x67\x6c\xaf\xfa\x80\x37\x8a\x5e\x59\xf6\xed\x52\xac\x64\x0f\xae\x38\xb5\x85\x29\x2e\x91\xc2\x26\x97\xac\x78\xc0\x97\x9e\xd2\x57\x30\x87\x34\x76\x59\x31\x2a\x47\x4b\x42\x37\x67\x8b\xf6\x60\x50\x96\x5b\x22\x4b\x6a\x59\x59\x33\x47\xb1\xad\x43\x52\x92\xcd\x61\x11\x85\x50\x27\x7b\x51\x7a\x51\x45\x38\x90\xee\x4c\x6d\x0b\xac\xd6\xe9\x2e\xa9\x08\xbb\xad\xc5\xf4\xe0\x35\x36\x97\x05\xec\xbc\x38\xe7\x3a\x77\xc7\xea\x9d\x69\xe3\x09\x82\x9b\x46\x4e\x69\xc0\xa8\xeb\x4d\x60\xb0\x89\xe6\xd9\x64\xd6\x32\xad\xec\xb4\x59\xfb\xdc\x64\x0a\xc9\xb4\x48\xbf\xe7\x1a\xa9\xa5\x79\x89\x53\x07\x48\xf7\xd4\xad\x31\xed\xb4\xe9\x34\x02\xe2\x35\xe8\xab\x89\x33\xb7\xab\xee\x4b\x92\x1e\xb9\x3f\xa6\xba\xd2\xf8\x06\x08\x09\x23\x85\x3c\xd4\x0c\x66\xb1\x3a\x54\xe8\xb0\xdb\xb3\x50\x52\x2b\x73\x61\xa1\x41\x27\x8a\xad\x10\x29\x2d\x49\xca\x52\x78\x76\x85\x4a\x51\xcc\xad\x7b\x87\xcd\xb2\x51\xaf\x07\x4e\xae\x57\x78\x98\x40\xbe\xe1\x8c\x9a\xda\x68\x51\x62\xec\x91\x86\x54\xd2\x09\xe1\x47\xd2\xea\x0d\x8f\x69\xd7\x1e\x12\x08\x09\x47\x08\xa5\xcc\x2c\x29\x8c\xfc\xea\xd3\xc8\xbb\xcc\x2c\x89\x77\x75\x1f\xd2\xf4\x94\x40\xed\xb6\x76\xb6\x76\x82\xd0\xfc\x6c\xb0\x1c\xe7\xde\xff\xe0\x1f\xdc\xab\x4b\x7e\xfd\xd5\xda\xe4\x88\xe0\xcb\x2e\x3d\xe2\xc7\x07\xe1\x1b\x22\xa3\x7a\xde\xa0\xc5\x76\x00\xd9\xe1\x32\xe0\x50\x26\x6a\x89\x46\x86\x4a\x9b\xbb\x0d\x86\x74\x67\x6e\xae\x4d\xb1\xc8\xe9\x18\x59\xb0\x41\xb4\x90\x74\xd2\x2a\x25\x3f\xc9\x0f\x9b\x0c\xe5\x68\x39\xb4\x1d\x21\xab\x6c\x02\x6a\x63\x72\x31\xd3\x4f\x82\x61\x24\xe9\x64\xe2\xb5\x70\x77\x19\x8d\x57\x90\x30\x05\x54\x96\xa8\x37\xdd\x27\x5a\x60\x8b\x1b\x1f\x39\x10\xa0\xa4\x74\xf0\x78\x6f\xcc\xa0\x3f\x30\xcc\x26\xe0\xc3\xfa\x33\x88\x45\x59\x1d\x3e\x0c\xc6\x0f\x22\x72\x5d\x5a\xaa\xed\x82\x84\xf3\x08\xae\xc4\x4c\x52\x22\x23\x7a\x96\xb3\x71\xfa\x41\xa7\x59\x08\x6b\x5c\x80\xda\xa3\x79\xa1\x9b\x68\xb2\x78\xbd\x94\xa5\x78\x03\x7e\x7f\x71\xcb\x96\xed\x9a\x73\x6e\xaf\x24\x75\xe8\x98\x0c\x04\x35\x10\x48\x56\x9a\xbb\xdb\x71\x3c\x9f\x9b\xdb\xa6\x22\x9c\x9b\x8b\x0c\x56\xbd\x41\xdf\x3b\x6c\x31\x19\x14\x1e\x58\x06\xe8\x3c\xad\x13\x98\x7a\x82\x79\xb9\xde\x38\x1f\x33\x69\x34\xbe\x1b\xa0\x99\x8a\x9a\x65\x6b\x37\xb5\x9b\x98\x9e\xaf\xb9\xaf\x46\xb3\xd3\x37\xbd\xb0\x46\x2e\xee\x99\xb9\xe0\xd1\x39\x6b\x34\x13\x75\xfb\xee\x3d\xba\x0c\x48\xb8\xb9\x96\x35\xe9\xe5\x01\xd8\x38\x64\xcf\x4a\x76\x75\xed\xe6\xf5\x03\x6f\x70\x8c\x1c\xb9\x62\x1e\xf7\x26\x4b\x42\x3e\xbe\xb2\x73\xf1\xea\x0f\x13\xef\xb0\x4d\x9d\x74\xdb\xf7\x03\x96\xf5\xd2\x2e\xb1\x55\x8e\xea\x42\x79\x69\x8a\x5a\x29\xdc\x27\xbc\x05\x14\x65\x64\xa8\x4d\x61\x20\x90\x99\x9e\x86\x7c\xbe\x64\x9b\x5e\x6f\x49\xce\x4d\x13\x82\x45\x85\x20\x1a\x14\xca\x2d\x5a\x55\x84\x5b\xa0\x8c\xf4\xde\xa0\x6b\xc0\x0e\x17\x7c\x4e\xa3\x42\xdd\xa9\x05\x37\x93\x79\x12\xfd\x53\x13\x9d\x1f\x12\xe3\x4b\x69\xdb\xe1\x5a\xa7\xa7\x04\x67\xd5\xec\x74\xed\x6e\x78\xa3\xa4\xe3\xdc\x59\x1d\x69\xbf\x65\xd6\xde\x27\x34\xf7\xa7\x3b\x73\x86\x84\x6b\xd6\xd4\xe2\xf7\x12\x7c\xf8\xf9\xb6\xcf\x4f\x18\xb0\xe7\x64\xdc\xf1\x89\xa4\x8d\x9f\x51\xf4\xfc\x63\xd4\x87\x67\x64\x5d\x37\x72\x70\xc9\x9c\x98\x73\xff\x6d\x9a\xfc\x70\x37\xe8\x25\x57\x60\x0f\xb4\x42\x3d\x43\x2d\x5a\x12\x82\x52\xad\x1e\xb7\x3e\x3b\xdb\x6d\x45\x7c\x7e\x41\xaa\xde\x91\x93\x23\x56\x84\x73\x5c\x2d\x91\xc3\x41\x63\x0d\x39\x94\xb8\x7b\x60\x2c\xf2\x5e\xd3\x2b\xa0\x71\x62\x48\xdf\x5c\xfc\xff\x3a\x14\xa4\xe1\x5e\xb3\x9d\x77\xd7\xf6\x44\xd1\xb5\xeb\xb7\xfe\xdd\x61\xa0\x7a\xe5\xb3\xbb\xa3\x7d\x85\x93\x57\xfb\xf4\x1e\x58\xd9\xfb\xef\x0f\x02\xef\x7b\xee\xe6\xf6\x93\x34\x1e\x4b\x73\xea\x7c\x03\xe3\xd2\x01\x7d\x6f\x1f\xf2\x1b\x05\x91\x18\x0c\x40\xeb\x74\xc4\x6c\x12\xf4\xec\x7e\x8b\x8c\x91\x68\x40\x86\x44\xb9\xa1\x89\xac\x90\xe0\xe2\x08\xff\xad\xf8\xee\x5a\x52\x13\xb9\x81\xfb\xa6\x6e\x30\xb7\x9f\xfa\x2f\x52\xfe\x4e\x76\xd5\x7d\x45\x9a\xb1\x36\xbd\x08\x93\x13\xcc\x7f\xd3\x8b\xba\x84\xb2\x4d\x5e\x99\x13\x6c\x62\x92\x4f\x76\x3b\x88\xc5\xe3\xb1\x4b\x06\x8e\xe8\x31\x26\x2e\xbb\x5d\x54\x9c\x16\xa7\x09\xe9\xa9\x9d\xbb\x9c\xfe\xd0\xc3\xdf\x77\x62\x59\x39\xea\xbd\xda\xa9\x57\xa9\x11\xa7\x93\xa0\x0f\xd3\xff\xa4\xd1\x07\x61\xd9\xda\xf5\xcb\x8e\xce\x5b\xbe\x69\xee\xe6\x65\x73\x8e\x27\x7e\x20\x7a\x2e\x3d\xf2\x25\xf7\x5a\xe4\x4d\xae\x0d\xfd\xbd\x52\xdc\xf8\x33\xed\xeb\x08\x10\xba\x3e\x84\xbe\x52\x3b\x7a\xe7\x50\x33\xde\x64\x12\xcc\xa0\xc6\x21\x9d\x59\xa7\x58\x2d\xc6\xbe\x61\x2c\x58\xe0\x9f\xa8\x37\x3b\x45\xd2\x97\xc6\xeb\x88\x5b\xb8\x63\x4e\xb0\xd7\xc4\x96\xd2\x34\xb5\xfa\x5f\xf2\xe1\xf3\x91\x8b\xbb\xc8\x54\xed\x95\x9c\xc7\xe5\xea\x2b\xf8\xbb\x2b\x45\xda\x3b\xc3\xbd\x6c\x75\x00\x5f\xc7\xdf\x02\x7a\x5b\xbb\x50\x6a\x72\x20\xe0\x77\x4a\xb2\xe4\x07\xad\x0d\xf1\x29\xb2\x15\x14\x7b\xab\x12\xe0\x79\x6f\x45\xdc\xd0\x12\xe3\x30\xb6\xc6\xc6\xee\xcc\xb8\x13\x24\xdb\x3b\xb1\x4c\xe4\x89\x9e\xf2\xfc\xcd\xa4\xf8\xd1\xb9\xbb\x77\xa4\xf7\xea\x12\x6e\x9b\x53\xb1\x64\xc7\x6e\xcd\xdf\x7b\xff\xba\x8a\xfe\xbb\xde\xc1\xca\xf2\x29\xed\xb2\x1e\x69\x71\xe6\x23\xf5\xbc\xe6\x36\xbf\xf0\x4a\x32\x8a\xf5\xaf\x52\x1c\x04\xfd\x6b\x81\x3a\x85\xd2\x33\x72\x9d\x92\x3f\xb9\x45\x0b\x49\x26\x39\xb9\x59\x69\x15\xe1\x2c\x5f\x43\x37\x13\x3a\xd9\xd4\x35\xfd\xff\xd8\x4b\x47\xfc\xc2\x5f\x71\x93\xee\xce\xdd\xfb\x9c\xd6\xdd\x23\xed\xba\xa6\xdc\x56\xb1\xf3\x50\xa3\x5e\x1f\xff\x4a\xfd\x67\xac\xd7\x57\xf7\xfe\xe6\x78\xc4\xfd\xce\xb1\x58\xec\x58\x7c\x81\x7b\x4e\x44\x8a\x44\xf2\xf0\xdd\x48\x1b\x8f\xf6\xcc\x80\x52\x51\x28\x94\xae\x93\x92\x15\xc5\x6a\x75\x4b\x24\xe0\x77\x78\xcf\x87\x1d\x28\x35\x95\xe8\xac\xdf\x13\xd3\xb9\x30\x22\x01\xc2\x91\x4b\xa8\xbc\x2a\x7e\xaa\x11\x6c\x62\x85\xb4\x37\xb8\x3f\xd6\xbb\x73\x06\x1b\xee\x02\x7c\xd2\x62\x52\xbf\x19\xd3\xe6\x76\xe9\x33\x70\xf4\xdc\x57\x5a\x17\x34\xcb\x1f\x20\xf2\xc3\x6f\xed\x3c\xf7\x3e\x95\xc7\xe7\xa6\xf4\x99\x3f\x46\xed\x48\x7a\xbd\x6b\xbc\xd3\x32\xb2\xf3\x64\x9a\x7b\x82\x8b\xfe\x80\x8e\xa2\x7f\x89\x54\x13\xa0\x5e\x85\x2e\x64\xb1\x10\x9e\xb7\xe9\xad\xf2\x45\xc9\x78\x2e\x2c\x61\x74\x3e\x8c\x2f\xa0\x7a\x69\x2c\x1e\x77\x25\x16\xe4\xd3\x99\x18\x71\x25\x38\x66\x4e\x45\xdf\xb2\x94\x9c\x82\xcc\x39\xc2\x8a\xd9\xb3\xeb\x84\xf1\xc3\xc5\xe1\x7c\x51\x57\xd2\x85\xe6\x7d\xc3\x17\xf0\x6b\xfc\x6f\xc8\x86\x5a\x86\x5c\x82\xcd\x06\xd4\xcc\x68\x77\x08\x7a\xa4\xb7\x9c\x0f\xeb\x2f\x91\x8b\xe8\x7b\xd4\x24\x98\x7a\x83\x63\x8f\xbb\x91\x7b\xcd\x78\x7e\xba\x40\x52\xbb\x77\x71\x25\x27\x67\xf6\xec\x05\x73\xdb\x7d\x4a\x68\xf3\xf0\x9b\xa5\xe9\xd2\xdd\xf3\xd5\xa9\xd0\x56\x73\xfc\x05\x5e\xca\x9f\x87\xb6\x60\x44\x82\xd5\x8a\xb1\xd1\x61\x17\x44\x91\xb7\x5d\x64\xad\xfd\xc0\x7f\xdf\xe0\x35\x15\x6c\xea\x37\xa5\x9d\x7f\xc6\x1d\x97\x70\x0d\x6d\x2d\xf9\x16\xd6\x5a\xaf\x9e\xfc\xf9\xc8\x01\x68\x6d\x58\x37\xd6\x1a\xd6\x7c\x3c\x5c\xe8\x08\x8e\x40\x7b\x1e\x54\x12\x4a\x32\xba\xdd\x18\xdb\xbc\x12\xf5\x99\xba\xa8\xe7\xa1\x39\x39\x24\x3b\xce\x87\xe5\x1f\x90\x16\x07\xf0\xe4\x7f\x75\x9b\xea\xd0\xc8\x6d\x0a\xdf\x91\x95\x95\x9d\x1c\xcc\x7a\xce\xdb\xb3\xab\x2b\x39\x35\xe3\xd6\x5e\xfc\xf9\xba\xdd\x65\xf9\x86\x29\xba\x77\xff\x55\x71\x53\x7d\x27\x38\x34\x12\xe6\xe1\x0b\xe8\x83\x99\xc5\xfb\x68\xc6\x63\x82\x80\x73\x18\x39\x42\x14\xc9\x28\x39\x5d\xc8\x7e\x2e\xe6\xfc\x72\xd1\xe8\x38\x17\x36\x7e\x7f\x1d\xe7\x97\xc6\xf6\x8d\xa0\x3d\x48\xea\xbd\x5f\xec\x85\xc5\x45\xb9\xd8\xfa\xd5\xca\x7f\xad\xff\xa5\x6a\xf4\xfd\xf3\xd5\xd7\xe7\x1c\x7a\x60\xfd\x4b\x64\x37\x2e\x56\x8f\xdb\x66\x0d\x19\x3d\x8d\xbb\x1a\x19\xb5\x68\x99\x7a\x05\xe1\xe8\xaf\xf8\x22\x39\x0f\x7d\x71\xd1\xf9\x77\xba\x5c\xbc\xdb\x63\xd0\xeb\xdd\x36\x33\x4f\x74\x4e\x59\x7f\x11\xe9\xbe\x67\x36\x28\x66\x5c\x89\xdd\x35\x88\xd1\x32\x42\xfd\x0e\x41\xf8\xa3\xe7\x89\xa5\xd0\x05\x76\xa8\x48\x6c\x6b\xee\x34\x7a\x0d\xf2\xb2\xd5\xef\xcc\x9e\xe7\xd2\x59\x1e\x58\xb2\xc8\x6f\xb6\x2d\x9a\x85\x2f\xe2\x4b\xd9\x0b\x0a\xba\x45\xbe\xe7\xae\x44\xae\xf4\x29\x6b\xcf\xf5\x8f\xfc\xb1\xbc\xe3\xad\x9c\xa8\xf9\x85\xfc\x81\x8e\x70\x4f\x41\x3f\xac\xa8\x75\xc8\x6d\x06\xcc\x36\xda\xec\x7a\x9d\xce\x66\xbe\x68\x94\x10\x74\x83\x87\x1d\x17\xcf\xec\x5e\x56\x1e\xef\x89\xd6\x95\x52\x0d\xab\x4b\x31\xf4\x01\x3a\x02\xab\x32\xbd\x75\x7a\x59\x9b\xaa\x5c\xf5\x8b\x25\x9b\x6f\xcc\x7f\x74\xb1\x7a\xbe\xd3\xc2\x23\xba\x6a\x7e\xe0\x74\xee\x3f\xea\xa0\xb7\x57\xe1\x6f\x23\xc2\xb3\x35\x8c\x06\x8c\x21\xaf\xe3\x00\xcb\xf1\x6b\xd0\xe2\x6b\x93\xd7\xb9\x1a\xf6\x59\x60\xf8\xb2\x90\x27\xb8\x2b\xf0\x00\x3d\x0a\x84\xcc\x92\x00\x4f\xf5\x7a\x83\x51\x82\xbf\x50\xfe\x49\xed\x0a\x52\x3c\xaa\x91\xbd\x58\x8b\xb7\x13\x74\x2e\xcc\xcc\x9d\x4d\xc3\x35\xdd\x77\xdb\xfd\x37\xde\x35\xff\x35\x0a\x67\x06\xc0\x29\x8f\xc3\xe1\x05\xa4\x13\x74\x14\x0c\xaa\x11\x50\x7e\xd2\xc9\x84\xbb\x4c\xcc\xdb\x93\x85\x85\x48\x2f\xc6\xe5\x0c\x90\x70\x32\x0e\x08\x64\x11\x80\xd3\x97\xc1\x49\x0d\x99\x38\x9d\x8e\x87\x0d\x63\xe0\x38\xe8\x57\x42\x77\x98\xc5\xd9\x99\xce\x14\xd0\x0e\x18\xdf\x1a\xae\x9e\x9d\x97\x21\x9c\x7c\x6d\xfe\x5d\x5d\xee\x1f\x7a\x1f\x1b\xd7\x9f\x3c\x28\x0b\xc2\x6f\x80\x83\xd0\x1f\xd1\x4c\x0c\x66\x83\x45\x16\x91\x54\x63\x86\xfe\xbc\x53\x96\xe8\xa1\x68\xd7\x14\xb1\x62\x2d\x49\xf7\x9f\x39\xa5\xa5\x39\xfd\x46\x8d\xea\xc7\x9f\x6a\xd3\xba\x75\x69\xff\xd1\x95\x95\xb7\x03\xbc\x2b\x00\x6f\x5f\x1c\x9e\x81\x48\x40\xa4\x68\x7c\x4a\x11\x66\xb9\x29\x3c\xcd\x5a\x18\x74\x6a\x26\x11\xbc\xaf\xff\xc8\x91\xfd\x29\x50\x7e\xd6\x98\x01\x95\xa3\xfb\x97\xb6\x6e\xdd\x46\xa3\xc5\x45\xb0\x4f\xd6\xc2\x58\x5d\x34\x42\x88\x98\x10\x4b\xd0\x68\x94\x89\xf3\x1c\x3d\x9a\x92\x65\xfd\xb9\xb0\xfc\x2d\x23\x48\x09\x47\x84\xf5\x17\x31\xea\x8f\x62\xae\xb9\x4c\x2c\x4a\x20\x96\xa6\xe6\x8c\x0d\x57\x8e\xb9\xcb\xb9\xc0\xb1\x61\xf2\xc3\xdb\xef\x59\x0a\x84\x6f\xb8\xf9\xfe\x15\x6b\x96\x2d\x33\x8c\x99\x76\xec\xc0\x13\xc7\x8d\xff\xa1\x31\x0d\xa1\x1f\x6b\x58\x3f\x40\x4a\x52\x80\x87\x19\x41\x4c\xe2\x89\xdb\x63\xc7\xe7\xc2\x76\x3b\x92\x8c\xb0\x92\x66\xa0\xc0\xf1\x7e\x5c\xff\x7c\x0c\x17\xc7\x93\x87\xd5\x5f\xe4\x66\x87\x52\x37\x2e\xbd\x67\xfb\xc3\x53\xd6\x3b\x16\x38\xef\x1a\x53\x19\x1e\x9b\x93\x8a\x2f\xfc\xc7\x78\xfc\x89\xfd\xaf\x4c\x1b\x63\x58\xb6\x6c\xcd\x8a\xfb\xcd\xea\xc3\x0c\x37\x47\xa1\x87\xf8\xae\xfc\x4e\xc0\x4d\x7f\x93\xcf\x69\x6c\xbe\x46\xa1\x1f\xf9\x2e\xfc\x21\x90\x97\x92\x42\x46\xc4\xf1\x44\xd2\x71\x58\xe4\x31\xcd\x64\x62\x8b\x4b\x4b\x99\xe9\x7a\x9c\x8e\x83\x7c\x97\x1d\xea\x7e\xf5\xd0\x0e\xfc\xd0\x53\x3f\x12\x4b\xdd\xaf\xe4\x6d\x74\x2d\x0c\x91\xe7\x00\x06\x8f\x05\x02\x30\xf2\x83\x09\x30\xd8\xd9\x39\xb7\xe3\x29\x75\xf4\x0e\xdc\x15\xf7\xd8\xf1\x23\x79\x1b\x60\xc4\x7c\x6f\x10\xbf\x87\xdb\x28\xbc\x0f\x38\x9a\x16\x92\xf5\x3a\x42\xb0\x88\x45\xa3\x01\xeb\xd6\x0f\x06\x38\xb9\xf1\x98\xa4\x31\x7f\x6c\x20\xe2\x52\x7a\xb1\x3d\xc8\x6d\x1c\xfb\x39\xf7\xfd\x98\x0b\x27\xf9\x7f\x38\x9e\x7e\xda\x81\x2d\xd7\xc2\x42\x58\x00\xe1\x54\x47\x00\x16\xb9\x1e\xac\x74\x52\x0c\xfc\x07\xb4\x26\x7c\xe0\xe4\x85\x31\xdf\x73\x9f\x8f\xe5\xf7\x60\x0b\x85\x46\x61\xe1\x64\xbe\x06\xaf\x66\xb9\xca\x9d\x07\xe1\x23\x2f\x90\x1a\x80\x91\x74\xca\x1a\x4b\x6d\x0e\xe2\x59\x10\xaf\x9e\x32\x05\x8a\xdd\xc2\x62\x59\xf2\x1f\x70\x03\x85\xbe\x50\xde\x1b\x32\x61\x9a\x0a\x9d\x5b\x13\x96\x31\x86\x4a\x31\x0f\x79\x2d\x5d\x29\x37\x30\xf2\x39\x97\xc9\x7f\xb0\x10\xea\xbc\xc1\xef\xe7\x3c\xd0\x86\x80\xec\x07\x10\x11\x25\xc2\x36\xc0\xa9\x58\x69\x3b\x8c\xd3\x29\xbd\xb1\xf8\xf4\x6f\xfc\x7e\x07\x26\x29\x57\xd8\x18\x37\xf0\xfb\xf1\xb7\xb1\x3a\x98\x6f\x5a\x07\x67\x17\x07\xed\x4e\xbc\xf2\xb7\xd3\x8b\xf9\xfd\x57\x52\xd4\x88\x83\x8d\x45\x1d\x87\x57\x47\x0f\x34\x8c\x05\xd7\x90\xeb\x8d\x05\x8a\xb1\xb1\xdc\xa8\x5e\xe2\xc6\x44\xc7\x43\x79\xeb\x7e\x3a\x14\xf8\x23\xff\x54\xe2\x18\xc6\xd0\x31\xa8\x97\xe8\x18\x66\x42\xa5\x37\xa3\x8b\xea\xfb\x83\x1a\x40\x37\xf4\x67\x1c\xf4\x47\x1d\x17\xef\x0f\x3a\xaf\x8e\xe3\x4a\x62\x75\xe8\xb8\x1b\xd7\xd1\xc6\x7d\x1e\xc6\xad\x8e\x8b\x8f\x9b\xa3\x19\x03\xf1\x4a\x76\x42\x21\x21\x5f\xc8\x8c\x24\x9e\xf0\x3a\xbd\xc8\x3b\x31\x4d\xdc\x70\xaa\xfc\x54\x5c\xc0\x97\xd2\xb3\xad\xa5\x41\x37\x5e\x39\xca\x3c\x0a\xfe\xf3\x6d\x3f\xfe\xf8\xea\xeb\x1f\x7f\x4c\xdb\xdd\x43\x46\xc4\x60\xd8\x0e\x10\xba\x44\xac\x6a\xbc\xab\x50\x91\x55\xa2\x35\x34\xdc\xfc\x13\x0d\xc1\xbb\xf0\xc7\x1a\x9d\x22\x06\xd1\x6c\x30\xcb\x96\xeb\xd3\xbd\xd2\xeb\xd3\xbd\x3d\x0d\x64\x8f\xd2\x3d\x80\xb7\x2f\x0e\xef\xbf\xd3\xbd\xcc\xbf\xa1\x7b\x43\x1a\xc8\x1e\x46\x8f\xa2\xe7\x38\x1d\x56\xb5\x6c\xfa\x22\x41\x04\x13\x98\x12\x8e\x13\x18\xaa\x9e\x64\x6c\x8f\xd1\x14\x6a\x68\x2e\x66\xf1\xb6\x39\x9d\xba\x69\xee\x94\xb9\xcf\x4d\x38\x7f\x5e\x1b\x63\x23\x18\xb0\x83\x89\x00\x30\x60\xeb\x48\x6c\x4d\x4e\x16\x26\xc0\xc0\x34\x6e\x79\x3a\x2c\xbf\x0e\x20\xe0\xdb\xf1\x7d\xe7\xcf\x4f\x88\xc1\x78\x9c\xd3\x71\x54\x33\xcc\x0b\x39\x0c\xd4\x60\x8e\x00\x8c\xc9\x6c\x10\xa9\xbd\x5c\x7f\x8c\xad\x6e\xec\x7c\x22\xd1\x6b\x4e\x83\x17\xeb\x17\xc0\xa4\x60\x03\xf3\xe7\x4f\x98\x37\x4f\xeb\x5b\x0a\xb6\x73\xab\xf1\x36\x86\x87\xb0\x9d\x79\x8e\x52\xa7\x44\x3c\x5c\x1d\x59\xc7\x4d\xc6\xf6\xd5\x20\x13\x7c\x09\x7b\x7f\xa6\xf0\x2d\xf4\xa1\x75\xc8\xa7\x37\x13\x93\xae\x82\x0c\x23\x5c\x0d\xb9\x4c\x38\x99\x60\x3d\xa1\xf7\xfc\xd7\xc6\xe4\x02\xe5\x38\xcb\xe0\x58\xc8\x64\x35\x2d\xb5\x6e\x90\xd2\xd7\xa0\x05\xe3\x16\x4b\x0f\xd8\xee\x4c\x3e\xfc\x62\xca\x9d\xce\x7d\xfc\x9e\x9d\xab\x36\x6d\x5a\xb3\x03\xfa\xb2\x45\x08\xe0\x0a\x46\x0f\xdc\x21\x03\xc0\x12\x78\x84\xd7\x31\x70\xf1\x5d\x44\xc5\xe6\x2d\xb5\x42\xe0\x59\x76\x67\x25\xc8\xaf\xe3\xdc\xe2\x34\xe8\x8f\x1b\x75\x0f\xe5\x03\x2f\x12\x91\xe8\xf5\xe8\xe5\xd5\xe1\xcb\x7a\x2c\xeb\xfd\x7a\x0e\xb4\x66\x12\x22\xce\xd5\x61\x99\xe4\x93\x72\xd2\x8b\x2c\x24\x8f\x90\xa3\xe4\x67\x20\x5a\x94\x68\x30\x99\x52\xcb\x7f\x9c\xc0\x0f\x63\x17\xaf\x4b\xe2\x09\x3d\xe3\x69\x7e\xdd\x34\x71\xe4\x9a\x91\x23\xd6\x4e\xa0\x29\x23\x6f\x69\xd7\xf6\x16\x61\x31\x7d\x30\xea\x9e\xd5\x23\xdb\xf4\xec\xd9\xa6\xb4\x4f\x6f\x36\xa7\x15\x6a\x7f\xfc\x3c\xfc\x65\x47\x65\xa1\x74\xbd\xc5\x02\x52\x8a\xd3\xa1\x0b\x49\x86\xae\x3a\xce\xba\x3a\xac\x70\x38\xc0\x55\x70\xc3\xb8\xc9\xdc\x6e\xee\x18\x27\x72\xd0\x93\x29\x9a\xaf\x40\x42\x27\x62\x7d\x80\xf9\x22\x1a\x63\xc2\xcf\x97\xdf\x32\x76\x5c\x65\xe7\x65\xde\xa2\x5c\x5f\xeb\x96\x25\x1d\xd4\xc9\xbe\xd1\xfd\xbb\x2c\xcd\xb2\xb4\x6c\xd7\x25\x3b\xa7\xc0\xc3\xe4\xb6\x1f\x60\x8d\x0e\x08\x87\x91\x9b\xe3\x43\x51\xa7\x57\xef\x71\x38\xcc\x66\x61\x6d\x38\x60\xc6\xbb\xcd\xc7\xcc\x67\xcc\x44\x36\xfb\xcd\xf9\x66\x98\x17\x33\x0a\x21\xdb\xda\xb0\x0e\x6d\xf5\xe2\xd5\x5e\x3c\xdb\x8b\xc7\x7a\xf1\x60\x2f\xee\xe6\xc5\x65\x5e\x9c\xeb\xc5\x3e\x2f\xd6\x7b\xf1\x9f\x5e\xfc\xad\x17\x7f\xe4\xc5\x1b\xbd\x78\xb9\x17\x4f\xf7\xe2\xe1\x5e\xdc\xc7\x8b\x6f\xf0\xe2\x42\x2f\x6e\xe6\x05\x81\x1d\x73\x5e\x7c\xfb\xaf\x5e\xfc\x2f\x2f\xfe\xc0\x8b\x8f\x79\xf1\x6e\x2f\x7e\xcc\x8b\xef\xf3\xe2\x1a\x2f\x9e\x1a\xaf\xd0\xd9\x8b\x8b\xbc\x38\xc3\x8b\x5d\x5e\xcc\x7b\xf1\x65\x56\xfe\x0c\x2b\xbf\x37\x5e\x7e\x29\x6b\x60\xa4\x17\x0f\xf0\xe2\x2e\x5e\x5c\x12\x6f\x00\x79\xb1\x06\xff\x3d\x2f\x3e\xee\xc5\xb5\x5e\xbc\x3d\xde\xa1\x19\x5e\x3c\x9a\x95\x87\x0e\xe1\x02\x2f\x0e\x78\xb1\xc2\x2a\x94\x86\xa6\x43\x1b\x67\x59\x9f\x8e\xb3\x3e\x41\x9d\xf5\xac\x8d\xc9\x5e\x3c\xcc\x8b\x2b\x12\xfa\x84\x58\x87\xce\xc5\x0b\x6f\xf3\xe2\x75\x09\xbd\xe9\x17\x2f\xc9\xc7\x9b\x87\x02\xdc\x3a\x36\x3e\x80\x55\xee\xc5\xf9\x5e\xec\xf7\x62\xd9\x8b\x25\x1a\xf0\x95\xfe\x54\xd3\xc0\xaf\x89\x3f\x53\x1b\xff\x0c\x8d\x17\xaa\xff\x99\xd2\xe4\x67\xea\xf5\x6a\x5c\xa7\x34\xca\x2f\x64\x98\x7c\x8a\xed\xb8\x98\xb8\x83\x63\xb2\x5d\x2b\x8e\x5a\x22\xd3\x69\x22\xb1\x54\x2e\xb6\xff\x2e\xe5\xf4\xeb\x79\xb3\xbf\xb4\x44\x3f\xd8\x58\xd0\xbb\x3c\xaf\x5f\xcf\x9b\x52\x47\x5a\x87\x58\x47\xf2\x7b\x32\x5b\x66\x76\x2c\x1b\x3d\xb6\x03\xbc\xcf\x5c\x3f\x8b\xc6\x3e\xe0\xf7\x10\xaf\x70\x0e\xf8\x88\x11\x65\x84\x14\xd1\xc0\x83\x60\x6e\x36\xe9\x38\xc4\x6d\x18\x0c\xba\x42\x7e\x61\x3c\xe6\x69\x61\x4c\x3a\xa5\xac\x05\x07\xd9\xab\xeb\xd3\xd3\xea\x81\x08\x7d\xe1\xf7\x38\xb0\x3f\x45\xbd\xa0\xbd\x02\x9e\x7e\x8b\x47\x71\x49\xc4\x04\x74\x3a\x39\x64\xe4\x90\xc9\xa4\xb3\xc8\x26\x01\x1b\xa8\xd8\x5c\xaf\xc4\xb6\x2e\x20\x09\x71\x85\x88\x94\x74\x3e\xc5\x12\x8b\x1c\xf4\x5e\x4e\x4f\xee\x87\xf4\x95\x9d\xdb\x37\xbf\xbf\x08\x9b\xec\x6c\xdf\x11\xd2\x92\xdb\x21\xbc\xcb\x68\xa4\xcb\x60\xd4\x71\x40\x40\x44\x9a\x01\xdd\xa4\x33\x0a\x1c\xaf\x97\xa8\xd8\x14\x3c\x55\xe8\xae\xf7\xa9\x70\xb3\xb0\x16\x52\xb6\x94\x5d\x9a\x5d\xea\x2e\x75\x4b\xdc\x8e\x81\x57\xae\x0c\xbc\x7a\x95\xbd\x92\x65\xf1\xbf\xe0\x15\xf4\xfd\x5f\x41\x27\xda\xc6\x74\x22\x1f\x6a\x17\xf2\xbb\x65\x9b\x5e\x2f\x12\x27\x92\x45\xe0\xf7\x42\x0a\x07\x52\x80\x13\x89\x84\xe7\x93\x4c\x3c\xbe\x48\x3d\x80\x1a\xb4\xb4\x60\x7d\x7a\x02\x7a\xfc\x4d\x8d\x61\xb1\xeb\x11\xcc\x67\xc3\x4d\xf3\xbe\xb1\x6d\x1e\x51\xff\x58\xfc\xde\xa7\x8b\xd4\x9f\x72\xf2\xfa\x77\xeb\xde\xb7\xfb\x0a\x7b\x5a\xd0\xe7\x29\xe2\xfa\x71\xf7\x46\xae\x70\x62\x64\x52\xd7\x85\xcd\x6f\x19\x3c\xf8\x96\x7e\x2b\x3f\x76\x87\x6e\x1c\x51\x1a\xc8\xd4\xe8\x38\xe8\xb0\xe8\x2b\x66\x8b\x70\x85\xf4\x30\x13\xc0\x79\x2f\x30\xe9\xb7\x9e\x74\x42\xdb\x23\xe7\xe0\x0b\xbc\xeb\x2a\xcc\x3f\xca\xc3\x5f\x71\xab\xf8\xdf\x50\x36\x0a\x85\xd2\x24\x31\xe0\xf0\x25\x99\x10\x4a\x72\x88\x7c\xf3\x16\x01\x93\x9b\xb8\x53\xce\x85\x7d\xee\x4b\xc4\x00\x62\x34\xf9\x21\xf1\x3e\xc5\xb5\x77\x7c\x63\xd1\x73\xe8\x42\xd1\x2b\x71\xd9\x0d\x86\xd3\x18\xf1\xf4\xe3\x54\x8e\x5b\xb5\x79\x6d\xcd\x16\xef\x04\x65\x78\xe5\xbe\xb4\x0e\xb3\x6e\x1f\x1c\x5c\x77\xd7\x9c\xb5\xf6\x3b\x9c\x9b\xfa\xf6\x2a\xe9\x54\x31\xbb\xb2\x88\x3b\x3a\xe1\xce\x01\xe3\x5d\x1d\xca\x66\x64\xb4\xf4\x07\x92\x4b\x6e\x2d\x1b\x3b\x71\xe0\x08\xcb\xd8\x60\x49\xf3\x42\x9b\x2b\xad\xa4\x1f\xcb\xeb\x0a\xb2\xff\x56\xfe\xbc\x22\x91\xd6\x98\x66\xc0\xa2\xcf\x62\xfa\x80\x4d\xe4\x96\xb0\xb9\xd8\x06\xcc\x61\xb2\x40\x65\x1f\x90\x99\x01\x2d\x10\x88\x70\xa0\xa6\xb1\x20\x9d\xf5\xae\x02\xf4\xca\x0c\xb0\xb7\xc9\x2b\xd5\x43\xf8\x0c\xff\xd7\xca\x84\x7a\x12\xc5\x74\x01\xd3\x9a\x3a\x3d\x2c\x27\x16\xb5\xca\x54\xdf\x4f\x20\xd1\x1a\x04\x6b\x50\x83\xd1\x75\x25\xf9\x66\x25\x76\xa1\xff\xf7\x70\xb8\xcd\x2b\xb9\xa1\xff\x1f\xc0\xc1\x03\x56\x92\xc7\xaf\x99\x0f\x42\x1d\x95\x41\xb2\xe3\x30\x8b\xf8\x9a\xe0\x3a\xa1\xd5\x55\x0b\xa0\xea\x4a\xfe\x2f\x28\x36\x1c\xea\x75\x23\x93\xa1\x9e\x27\xa4\x07\xc5\x96\xd5\x83\x2d\x74\x2a\xd8\xd4\xe1\xa2\x9b\xea\x5d\x89\xab\xc9\xe4\x88\x1e\x25\xd4\x93\x98\x2e\xcb\x71\x84\xf6\x1b\x8b\xa2\x40\x65\xdc\xc6\x7d\xc6\xb1\xf4\xdd\x00\x61\xf5\xf4\xe9\x78\x1a\xbe\x4b\x9d\x49\x26\xab\xf3\xd9\xba\x22\x75\x20\xb7\x31\x3a\x47\xa1\x99\xd5\xd1\x5f\x3b\x98\x8c\x9a\xc2\x7f\xcc\xad\x16\x93\x99\x8c\x0a\xd0\x05\x96\x80\x80\x42\x27\x31\xcd\xbd\x91\x66\x4b\xe7\xa3\x5e\x88\xa1\xbf\xc2\x93\x33\xd4\x97\x66\x00\x9c\x0a\x98\x81\x9e\x4c\x6f\xb7\xa3\x82\x90\xd3\x2a\xdb\x24\x9b\x51\xc0\x3a\xa3\xce\xe9\xb0\xe9\x74\x76\x54\x23\x03\xbc\x20\x48\x67\x0d\x1d\xd6\x8c\x4e\x85\x89\x16\x81\xb4\x06\xdb\x80\x97\xd9\x06\xf0\x7f\x1a\x9b\x08\xea\x4d\x0e\xd0\xcd\x45\xea\x23\x5c\x66\x94\xea\x72\x30\x9f\x22\xa7\x93\x78\x5c\x43\xe7\x24\x08\x92\x5b\x5c\xe4\x4a\x27\x41\x1a\xe3\x78\x5e\x9f\xa7\xa7\x0e\x1b\x36\x55\x7d\x04\x7b\x77\xee\xbc\xa6\x2e\x8f\x40\x93\x84\xca\x22\x15\xfa\x0a\x1b\xea\x66\x4b\xe9\xa0\xb7\x65\xd2\x9a\x4f\xf7\x51\x1f\xd9\xb9\x13\x7b\x69\xdd\x37\xd5\x01\xf8\x9f\xd1\x2b\x50\x37\x35\x64\xe2\x11\x07\xf2\x88\x4e\xe2\xf8\x98\x48\x9c\x30\x5f\x82\x53\x72\x3b\x33\x8b\xf1\x3f\x77\xee\x54\xbf\x13\x35\x30\x4d\xeb\x03\x21\xc5\x1c\x06\x2d\x94\x63\xcd\x37\xa9\x2f\x14\x97\x66\x43\x7d\xf5\xbb\x9d\x3b\x77\x69\x43\x80\xb9\x5e\xad\x56\x72\x29\xd1\x0f\x98\x9c\x06\x6b\x16\x97\xd3\x9c\xa4\x46\xd6\x6b\x73\x9c\x08\xe3\xef\xa4\xaf\x94\x59\x15\x15\xb3\x66\xf6\xee\x33\x63\x58\xbb\x96\x2d\xdb\xb7\x6f\xd9\xb2\xdd\x85\xde\x77\x4c\xaa\xa8\xb8\xe3\x8e\x8a\x96\xa5\xa5\x2d\x5b\x96\xd1\xbc\x46\x68\x35\x96\x39\x33\x77\x03\xd3\x7b\x78\x2c\x89\x8d\x75\x37\x3d\x66\xba\xd2\x2e\xf5\xab\xd3\x7b\xb0\x8c\x5d\x29\xea\x3f\x1d\xec\xec\x05\xf8\x91\xcc\xbd\xc2\xea\x19\x69\x1f\x39\xa3\x8e\xe7\xcd\x3a\x13\xd1\xd7\xc0\xb0\xe9\x0a\x15\xd6\xdb\xb8\xe2\x60\xd2\xd8\x2b\x37\x82\x02\x53\x6f\x4e\x04\x59\x0f\x98\x8b\x7e\x07\x70\x5f\x6d\x80\x0b\xec\x48\xaf\x37\x23\x93\x8e\xd4\x30\xe6\xd9\x18\x2e\x49\xe0\x9d\xde\x3d\xa7\xd5\xaf\x22\xf4\x05\xcb\x4d\x78\xe7\x0f\xea\x04\xee\x40\x74\x16\xcc\x26\xf0\x4e\x2a\xe3\xd9\x04\x3d\xaa\x71\x98\xb5\x7e\x96\x95\xfd\xff\xc5\xfb\xd5\x09\xd7\xf0\xfe\x97\xf0\x7d\x78\x01\x93\xc7\x29\x05\x92\x11\xcf\x13\x49\xd2\xe9\xa9\xd1\x8d\xe3\x41\x6a\xcd\xd7\x0e\x56\x12\x82\xc3\x80\x78\x0e\x2a\xbf\xf3\xa5\xd7\x5e\x7b\x8d\x8f\x9c\x3e\x5d\xb7\xe1\xf4\x69\x66\x23\x9b\xc7\x05\x98\x3e\x9d\x14\x32\x50\x6a\x20\x4a\x58\x88\xeb\x3e\xf5\x97\x28\xd3\x9c\x40\xbf\xb8\x80\x7a\x69\x31\xde\x28\xf4\xfe\x10\x57\x68\x67\x7d\x89\x75\x09\x48\x1d\xa2\x14\x57\xad\x1b\xea\xda\xd3\x68\x48\x97\xbb\xf1\xc6\xc5\xea\x25\xe1\xa4\xba\xfb\xc3\xd8\x39\x21\xe0\x5d\x20\xba\x03\xea\xa6\x86\xcc\x31\xfa\xb5\x10\xe3\x58\xf5\xaa\xc4\xb6\xad\x41\x27\x6d\x7b\xdc\x62\xec\x50\x2b\x71\xc5\x87\xd7\xd6\x07\x42\x43\x55\xef\x85\x42\xbc\xeb\x55\x89\xed\xd3\x78\xd8\x77\x63\x07\x68\xe0\xea\x7b\x1f\xaa\xbb\xb5\xf6\x53\xd5\x4a\xa2\x40\x7d\x46\xbf\x79\x2c\x30\x4a\xa5\xf5\x40\xd4\xb6\x7d\x55\x61\x63\x5a\xc8\xc2\xd3\x10\x25\x62\x59\x89\xff\x79\x17\xed\xc8\x89\x13\x50\xc9\xad\x0e\x24\x72\xbc\x1f\x9c\x40\x04\x49\xe4\x58\x3f\x70\x93\x71\xb8\x83\xd4\x3b\xcb\xbd\x96\x1b\x1b\xd1\x85\xdf\x5c\x41\xfb\xd0\x16\x68\xe8\x14\xb4\x05\xe8\x5c\x9b\x90\x8d\x93\xa8\x4e\x6f\x30\x72\x21\xb3\xd2\x95\xe3\x90\x5e\xa2\x7e\x8e\x46\xf8\x20\x49\x8a\x3e\x00\xea\x12\xa8\x22\xc1\xfc\x5c\xe5\x54\x61\xbd\xad\x0c\x76\x64\x9a\x3b\x9d\x62\xa6\x94\xc6\x4d\x51\x07\xbc\x30\xf9\xa3\x8f\x26\xbf\x80\x77\xee\xff\x0d\xfb\x2c\xd8\xf7\x1b\xc2\x91\x3a\xd1\x14\xbd\x55\x4a\x87\xfe\x19\xf6\xc6\xf6\x5b\xdc\x2c\xa1\xfe\xfc\xdb\xe9\xc5\xa2\x29\x66\x96\x40\x58\xdd\x00\x65\xbf\xbd\xa6\x2c\x33\x47\xa8\x1b\x16\x9f\xfe\x4d\x34\xd5\xdb\x61\xd4\xfd\xfc\x1e\xdc\x83\xd9\x9a\x94\xfd\x84\xd7\xd7\x50\x4d\x89\x61\x78\xa2\x99\x0a\xf7\xb8\xd6\x4c\x15\x8d\xc6\xf5\x20\x45\xe4\x1e\x66\xb0\x7e\xe4\x3f\xc0\x36\x66\x3b\x32\xd6\x52\xb3\x11\x35\x56\x69\x0c\x02\xdb\xe2\xd6\x22\x28\x17\x79\x46\x4c\xe7\xfa\x89\x4f\xb0\x72\x08\xaf\x61\xda\x27\xed\x60\x9a\x33\xf2\x0c\xff\xb4\x98\xbe\x78\x31\x5b\x5b\xf5\x0b\xfe\x00\xce\x10\x5e\x04\xf9\xd5\x52\x6b\xe0\x6b\x24\xb6\x99\x4f\x02\x6f\xb0\x52\x45\x57\x0b\x16\x08\xdb\x6d\xd6\x56\x79\xac\x69\xc4\x2d\xdd\x41\x8c\xb1\x3d\xc4\x1f\x58\x3d\xb3\x5d\xb7\x9b\x3b\xcc\xb9\x5b\xb3\xb1\x3f\xc9\x7f\x88\x06\x01\x5f\x66\x6d\x71\xeb\x62\x6d\xd1\x0d\x34\xa8\x96\xff\x90\xe9\xb8\xea\x0f\xfc\x6b\xd8\x25\xcc\x65\x7b\xd0\x76\x50\x80\x0d\x70\x2f\x3d\x8b\xd0\xc4\x6e\x6d\xc7\x01\xca\x38\xa7\x3d\x1e\x79\xff\x09\xfe\xb5\x43\xf0\xa3\xf5\xcf\x2d\x9c\x88\xbe\x29\xe5\x22\x1b\x50\x1d\x13\x51\x26\xeb\xce\xe8\xce\xea\x2e\xeb\x78\x1d\xac\x78\x6d\x6e\x7e\x57\x9d\x0c\x92\x76\xee\x14\x46\x75\x34\x3b\x2c\xbd\xd8\x47\xad\xb0\xe9\xc5\x1d\xf1\xd7\xc1\x9c\xae\x5d\xfc\x83\xc6\xfd\xd8\x7b\xf0\xe4\x9b\x0a\xc4\x45\xfe\x66\x9e\x11\xa9\x1b\xda\xf5\x37\x16\xce\x22\xda\xd9\x57\x1b\x90\x83\xdf\x14\x87\x33\x9a\x6e\xa9\x95\xf5\x35\x4e\xa2\x91\x72\xe8\xd3\xdf\x50\xf0\x37\xaf\x21\xe0\xc2\xf6\x6b\x28\x38\x1d\xf3\x42\x58\xf7\xc5\x31\x9d\xc3\x52\x9b\x40\x2a\x63\x98\x12\xa3\x90\xea\xc2\xbf\x53\x2f\x1a\xe1\x8e\xa5\x56\x90\x78\x6d\xab\x50\xcc\xb1\xd7\x1b\x25\xc7\x5f\xc7\x26\x19\x3d\x01\x6c\xb1\x2d\xa3\x79\x14\x3f\xb1\x86\x9f\x76\x90\x51\xda\xc6\xed\x90\x5c\x34\x0c\x65\x76\xc4\xe8\xa2\xa5\x96\x4a\x1e\x58\x43\x4c\x98\x4b\x28\x49\x4b\x97\x4c\x99\xf2\xa5\x56\x41\xad\x85\x4a\x8d\xc7\x64\x3b\xa8\xab\x21\xb8\x7e\x58\x55\x85\x8d\x39\x0a\xce\x50\x0f\x9c\xfe\x14\x38\x0a\xbc\x42\xad\x44\x8e\xc2\x01\xde\xed\xc3\x19\xe2\x48\xc0\x3b\x2b\xb2\x1d\xb0\x28\x06\x12\xc3\xbd\x53\x85\x85\xf9\x4d\xb1\x8f\xc0\x62\x36\xc2\xc0\x94\x5a\x7e\x5f\x1c\x07\xf1\x9e\x98\x5f\x6f\x23\x5c\x96\x50\x8d\x91\x8f\xaf\xa4\x15\x64\xf8\x74\x2d\xc8\x6b\x7a\x47\x3c\x73\xb3\x6d\xac\x3c\xbc\xfb\x2d\x23\x4c\x63\xe5\x87\x85\x17\xef\x9a\xdb\xb1\x4b\xb7\x76\x33\x57\x6b\xb8\xbc\x99\x5c\x44\x23\x99\x3c\x05\x30\x24\x81\xed\xec\x93\x65\xf9\x14\x9d\xe3\xa7\x30\xa3\xb2\x9a\xcf\x1d\x3a\x90\x5c\x7c\x6a\xdc\x9a\x4e\x2b\x17\x7c\x7e\x6d\x3d\x9d\xae\xfe\xf8\x05\xe6\xbc\x5e\xb2\x1a\xc9\xea\x09\x27\xff\xb6\x1e\x50\xb2\xc4\x7a\xf1\x73\x96\xa1\x03\x87\xce\x6d\x9e\x25\x9c\xfc\x7c\xc1\xca\xd0\xbd\x63\x9e\xfa\x7f\xd7\xde\x60\x75\x2c\x7a\x36\x5a\x03\xeb\x67\x39\x80\x90\x02\xdc\x91\x0a\xb3\x55\x50\x8f\xd1\xb9\x9e\xd4\xfa\x3a\x36\x4e\xe6\xa0\x7c\x2f\x75\x1c\xda\xc6\xec\xaf\x4d\xca\x33\x1e\x2f\xed\x69\x64\x7a\x85\xf2\xe5\x6a\x35\x7a\x2c\xba\x1f\x30\x2a\x2d\x64\x07\x19\x5f\xc6\x7e\xcc\x49\xf8\x58\xb5\x34\x49\x5a\x28\x11\x09\x08\x73\xd2\xa9\xa1\x55\x20\x8c\x52\x74\xd4\x4c\x7a\x8f\x4d\xfa\xfd\xf7\x49\x6a\xf5\xb4\x29\x53\x35\x18\x43\x01\xc6\x2b\x71\x18\x02\xc7\xc9\x92\x5f\xe2\x24\xe9\x58\x35\x9e\x84\x17\x62\x2a\xb9\x37\xc0\x90\x98\x2b\x93\x33\x9d\xc1\xe8\x31\x75\xca\x34\xc0\x83\x15\xfc\x3f\xf0\x6c\x71\x25\xf4\xd9\xb4\x8f\xc4\xb8\x4b\xa1\xe6\x25\x01\x64\x72\xf6\xda\xc8\x56\xee\x57\x28\x52\x46\x63\xb7\x76\x04\x4d\x40\xba\xde\x3c\x26\x9c\x96\x49\x4d\x4e\xcb\x18\xcd\x53\x2b\x51\x75\xf4\x3d\xc0\x35\xdb\x41\xb3\x24\x03\x24\x4d\x8c\x64\x94\xc8\xde\xc8\x22\x5b\x1d\x37\xc8\xaa\x95\x89\x07\x51\x38\x7a\x0b\xc0\xd8\x17\x7d\x0a\xc6\xe9\xa4\x72\x34\xc7\x38\xaa\x10\xe3\xc9\x31\x76\x4c\x0d\x9e\xfb\x98\x1d\x56\xad\xd4\x0c\xb1\x38\x7a\x2b\xd4\xab\x8d\xd7\x03\x22\xba\x90\x6e\x42\x89\xd5\x63\x0c\xd8\x1d\x33\xbe\xd6\x32\xdb\xeb\x71\xcd\xf4\x0a\xf5\x7a\x40\xbd\xbd\xd1\x97\x61\xe7\xa6\x84\x2c\x58\x10\x0c\x22\xec\xf9\x49\xfa\x85\x1a\xbf\x4c\x3a\xc5\x52\xba\xb3\x75\x69\x30\xb6\xee\xd5\x6c\xad\xea\x07\x0d\xb6\x56\xf5\x84\xfa\x11\x2e\x8b\x8e\x60\xf4\x9e\xa0\xb5\x61\xd2\xc0\x83\xca\xa8\x72\xa2\x7e\xb4\x9a\xb5\x67\xa5\xed\xa1\xcd\xd0\x9e\x72\x40\xc7\x3a\x89\xb4\xc1\xd1\x78\xa8\x0d\x7e\x57\x7b\x63\xf1\xa4\x36\xab\xe7\x34\xbf\x29\x1c\x3f\xef\x01\xc9\xe1\xd1\x58\x7d\xb2\x50\x87\x75\x89\xf5\x1b\x62\x2c\xed\x9d\x75\x53\x61\xff\xa0\xfa\xdd\x66\xf5\xd7\xf5\xb6\xed\x0a\x6e\x8e\x93\x19\xef\xac\x8b\xaa\x27\x22\xfb\xa2\x77\x2a\x92\xde\x16\xb9\x8c\x34\x9a\xfc\x03\xc0\x74\x45\xe5\x18\x1f\x02\x25\x02\xdd\x1b\x16\x28\x3f\xbe\x0e\x1f\x52\x2b\xe3\x7c\x08\xf8\x04\x8c\xe5\xcd\x98\xec\x6f\x3b\xe8\x94\xe9\x68\x62\x52\xff\x14\xe8\x8f\xfb\xff\xcc\x2b\xae\x11\xf6\x71\x74\x93\x5a\x86\x86\x47\x1f\x06\x1c\x74\x86\x0c\x12\x10\x79\xa4\x57\x62\x6b\xc2\x50\xd1\x1d\xc7\xc4\xe0\xf0\xbc\xe6\x77\x0e\x1d\xf8\xda\xc9\xca\x3b\xf3\x47\x0e\xda\x41\xe7\xb8\xbb\xda\x19\x1d\x60\x36\x5a\xdb\x01\x93\xd5\x2a\x71\x35\x0a\x93\x47\x35\x79\xce\x11\x9f\x64\xea\x3b\x2c\x95\x06\xa5\x54\x7c\x40\xfd\xa9\x2c\xad\x75\xe6\xfd\x1d\xba\x26\xa7\x74\x1a\x9f\x3d\x74\xa8\xaa\xbe\xc8\x0f\x17\x07\x34\xcf\xe1\x0e\x8c\x24\x7d\x35\xbc\xec\x8f\x40\x59\x03\xca\x6c\xda\x27\x73\x35\x7a\x06\x10\xa0\x35\x98\x72\xb5\x50\x41\xa5\x3b\x63\x96\xdc\x50\xdf\x44\x3b\x6e\xc6\xfc\x1b\xa8\x15\x17\x47\x0f\xc3\x9c\xdd\x08\xfb\x98\x20\xe5\x20\xdd\xb9\x5c\x5c\x62\xd5\x38\xd1\x8d\xcb\x97\xc3\x62\x0c\xd5\x70\x6a\x05\xfc\x39\x9b\xc9\x98\x20\x1d\xb0\x8d\x00\x42\x9e\x26\x5a\xd2\x9d\x5b\xcc\xa4\x6a\x3c\xfb\x2e\xd5\xbf\x92\xfb\x55\xad\x3c\x71\x42\x93\xab\xd5\xad\xea\x3a\x3c\x22\x3a\x1f\x79\x01\xa7\xcd\x56\x83\xc1\x43\x40\x81\x90\x25\xac\x83\xda\x43\xab\x82\x94\xfe\xb3\xbd\xa4\x05\x6d\x2b\x0e\x6a\xfe\xbf\xf5\x6f\x30\x24\xcf\xad\x9d\x87\x0e\xb9\xad\x55\xab\xd2\x4e\x43\x3a\x95\xb6\x6a\x75\xdb\x90\xa1\x53\xd5\x8b\x59\xc5\x8b\x26\xdc\x72\x63\xf7\x9b\x6e\xea\xde\xb9\xc7\x84\x45\xd0\xce\x0b\xd0\xbf\x9b\xa2\x83\x61\x8d\x52\x42\xb2\x20\x7e\x4d\x7b\x28\xd1\xfb\x09\x9c\xc4\xb3\x96\x68\x4f\x19\x5b\xce\x8e\xb1\xe5\x51\x27\xcf\x8e\xf9\x0a\xd8\xb2\x5a\xf9\xb3\x73\xd5\x2a\x27\xe5\xe5\x00\xa3\x13\x83\xe1\x0b\x59\x88\xf8\x35\x87\xb9\x1a\x66\xdd\x97\xf4\x14\x44\x0c\x42\x5c\x24\x04\xed\xb9\x13\x88\x84\x5f\x8d\x39\x7b\x52\x9d\x40\x21\xfc\xcc\x78\x9c\x3a\x15\x67\x44\x67\xd0\xf8\x26\x21\x3d\x30\x39\x83\xcc\x63\x5d\xac\x07\xff\x43\x6c\x53\xa7\xd6\x8b\x6d\x4d\xe0\x18\x41\xf0\x03\x12\xa6\x43\x14\x8e\x26\xfe\x39\xff\x9e\x65\xde\xdd\xc0\x31\xb1\xfa\x10\x8c\xe9\x76\xa0\x05\x6e\xe4\x0f\x29\xa0\xbf\x7d\x4d\x29\xa1\x83\xda\xe6\x39\xc9\xdc\x30\x31\x8c\x28\x5e\x47\x8d\xdb\xfa\x77\x5a\x5c\x65\x13\x2d\x8e\xc9\xbe\xea\xcb\xd8\x16\x6d\x17\xa3\x3b\x6b\x12\xe9\x0e\x93\x7d\xd5\x97\x63\xb2\xaf\x3a\x96\xeb\xa7\x5e\x64\xe5\x38\xb2\x26\xcc\x35\x92\x7d\xd5\xb1\x9a\xec\xcb\x01\x1d\xab\x04\x3a\xb6\x25\x76\x4e\x28\x23\x51\x11\x02\x42\x81\x40\x12\x74\x23\x46\xce\x85\x98\xf9\x45\xa3\x6e\xf4\xf7\x33\x66\x7d\x61\xe3\x47\xbf\xe0\xdb\x71\x84\x52\x85\x03\x36\xc1\x61\x86\xdd\xa2\x49\x31\xb4\x62\xe9\xff\x93\x21\xff\xd2\x64\xc4\x58\x7d\x14\xdb\x70\x35\x50\x40\x82\x74\x7b\xd8\x79\x56\x6c\xb0\xd5\x91\x1b\xb8\x23\xd8\xb6\x96\x8e\xf5\x39\x9c\xcc\x0d\xc0\x9b\x9a\x96\xe1\x06\x5c\xad\xe4\x9f\xc6\xc9\xf3\x69\x1f\x51\xf4\x1c\xb0\xed\x6f\xa0\x8c\x69\x1f\x22\xac\x54\x3e\x8b\x08\x97\x8d\x39\x54\x37\x62\x04\xd9\x4a\x16\xd7\x0d\xbf\x8d\x3c\x0c\x65\xbf\x8d\x7e\x89\xfd\xc2\x77\x0c\x1e\x50\xe0\xfc\x7c\x5a\x2e\x1d\x63\xbf\x3a\xf0\x5e\xfc\xb4\xf0\xdd\x5f\x7f\x8a\x06\x4a\x23\x1e\x57\x7b\xa2\x21\xd1\x13\x80\x3f\xde\x90\x59\x44\xb2\x19\xef\x32\x1f\x35\x73\x66\xc6\x87\xde\xd1\xe6\x8d\x34\x3a\xe8\xac\x8a\x1f\x74\xaa\x8f\x27\x9c\x74\x36\xdd\xfb\x4d\xd4\xca\x06\x6d\x12\xcf\x6e\xa4\x4d\x52\x9a\xdc\x19\xe8\xcb\xcb\xd1\xd3\x31\x5a\x2e\xc9\x8c\x7d\x92\x7a\x9a\x0c\xda\x74\x1a\x29\x4e\x77\xbe\xac\xae\xc4\xb3\xaa\x5f\x84\x8a\xb3\xd4\xef\x5e\x7c\x51\x6b\xf3\x31\x75\x03\x1e\x1a\x5d\x0c\xeb\x96\x12\x32\x21\xa3\x51\xe6\xf4\x7a\xab\x08\x98\xcb\xaa\x6b\x77\x14\x99\x8c\xa2\xc5\x3d\x65\xaa\x45\x3a\xf3\x40\xd3\x62\x26\xd6\x59\xbb\x97\xb6\x1f\xd2\xbe\xb4\xbb\x75\xb8\x79\x50\xcf\xc9\x65\x81\x9e\x25\x3d\xab\xcd\xea\x67\xdd\x29\xcd\xe8\xde\x73\xd0\xe0\x60\xf3\x41\x3d\x61\x9e\x32\xf9\xa9\xe8\x33\x31\x13\xf8\x86\x2b\x64\x88\x99\xef\x6b\x48\x4c\xce\xa6\x87\xd0\xf6\x04\xab\xfd\x67\x95\x4b\x97\x0c\x58\xb2\xb4\x72\xe9\xd2\x01\x4b\xf9\x37\xfa\x2f\x5f\xd6\x77\xd9\xb2\xfe\xcb\x96\xf6\xd5\xf2\x4e\x46\x1f\xe0\x27\xa0\xb1\xe2\x5d\xc8\x03\xb8\xe6\xd0\x59\x95\x1a\x21\x26\xe1\xb2\xed\xe5\xb0\x60\xa9\x98\xba\x6c\x33\xb3\x75\xa9\x93\x12\xe9\x54\x6e\x6c\x7e\x45\xdf\xbc\xd6\x29\xe9\x29\xd5\xd3\x5a\x16\xc0\x9b\x60\x68\x5d\x9e\x61\xb8\x55\xcc\xca\x71\xb7\x2e\x6e\xdf\xac\x73\x4f\xf3\x2d\xba\x8c\x3c\x4f\x61\x71\x3b\xb6\x27\x22\xcf\x8a\x26\xae\xbf\x54\x10\xd3\x09\x24\x2c\xc6\x24\xe0\x32\x6d\x03\x65\xd2\x4d\xf4\x2c\xff\x34\xc5\x2e\xd1\x34\x7a\xf4\x91\xd1\xa3\xb5\xf9\xdc\xc7\xef\x8c\xfe\x2c\xbc\xca\xf4\xe1\xd8\x19\x3d\x20\x00\x08\xb1\xa4\xf8\xa1\xbb\x66\x1d\x17\x5e\x55\x7f\x37\x61\xbd\xcc\xf8\xba\x8d\xdf\x89\x7b\x36\x2d\x8b\x9d\x04\xd4\x60\xdc\xf3\xf8\xac\xbb\x84\x57\x65\xf5\xdf\x26\x6c\xa2\x70\xb7\x83\xe6\x50\x25\x1c\x46\x4e\xd8\xa1\x46\x45\x40\x36\x9b\x11\xd5\xe8\x28\xa5\x2a\xcc\x4f\xa2\xfa\xbd\xb5\x11\x6d\xb1\x35\xec\xb3\x7b\x72\x6e\xee\xd4\x29\x33\x3f\xa8\x1f\x95\xf2\x7c\x5e\xb7\xce\x9d\x32\x06\xcb\xa3\xe5\xb1\xfc\x4b\xfe\x4c\x7f\x51\x19\xe6\xe0\x6d\xe2\xca\x39\x6c\x5e\xb7\xf0\x04\x8d\xfa\xef\xb2\xf4\xa8\x6b\x44\x40\x44\xd4\x67\xf8\xd3\xb8\xaf\xf0\x0d\xf5\xdd\xa2\x3e\x77\x07\x99\xdf\x95\x81\xe1\x6e\x90\x49\x53\x14\x02\x1b\x55\x4c\xaa\xd8\x73\xf8\xce\x25\xea\xd3\x1b\xf1\xbc\x8d\xc2\x37\xb2\x7a\xd5\x84\x75\xea\xa5\x67\xe1\x07\xfa\x00\xe8\x89\x1e\x02\x39\xdb\x84\xdc\x21\x23\xf1\x53\x61\x47\x86\xef\x4d\x8c\x31\xc4\x44\x8c\x06\xff\xc0\x60\x47\xa7\xc7\x92\x96\x97\xb5\x66\x69\x5d\x9a\x5b\x9c\x6c\x7c\xf0\x3e\xb6\x8f\xf8\xf7\x40\xee\x6d\xc6\x56\x8e\x48\x09\xda\x5c\x53\xfe\xc9\xbf\x17\xe3\x9f\x9c\x6a\x86\x6d\x71\x39\xba\x80\xad\x37\x70\x36\x24\xf8\x79\xbc\x8e\xc7\x7c\x8d\xcc\x61\x1d\xa7\xb5\x1e\xa3\x82\x00\x83\xfe\xaa\x66\xf2\x4d\x5d\x0a\xf9\xe6\xd2\xb8\x71\x87\xc7\x8d\xa3\xfb\xf0\x66\xe8\xfb\x11\xc6\xe7\xa9\x44\x6a\x10\x62\xbc\x3e\x61\x13\xc7\xd5\xc9\xe0\xf2\xe5\xbf\x68\x5c\x5f\x7d\x8c\x72\x7e\x1c\x2d\x86\xba\x6f\x33\x9b\x90\x72\x40\x60\x32\xa2\x66\x0c\xa2\xa2\x3d\xb3\x86\xbd\xcd\xac\x61\x61\xcd\x18\x86\xd5\x4d\xfc\x9d\x78\xb4\xf0\x17\x4a\x82\x79\xd2\x2b\x9c\xcd\xa4\xaf\xf1\xf2\x2e\x6d\xc6\x0b\xd9\x46\x20\xda\x56\x05\x2c\xa0\x5b\x2a\x76\x54\xcf\x52\xcf\xf7\x6e\x9e\x32\xc2\xce\xa8\x6e\xc7\x5e\x1d\x6e\xeb\x90\xe3\x65\x74\xb7\x7f\xbb\xde\x1d\x6e\x13\x3c\xf6\x39\x40\x7a\x0b\x26\x94\x4c\x70\xcc\x59\x3f\xab\xf5\xc4\x52\x58\xdf\x47\xf8\xe1\x78\xb2\x44\xe3\x4d\xd3\xfb\xad\x2d\x42\x36\xa7\x4d\x30\xeb\x50\x4a\xaa\x39\x09\xd6\x1b\x28\x5f\xaa\xb7\xde\x78\xa8\x39\x0b\x69\xa9\x09\xae\xe1\x74\x8c\x17\x0b\x31\xa3\xe2\x13\xb9\xbd\x6f\xb9\xc9\x5f\x5a\xa8\x1f\x63\x2c\xe8\x53\x9e\xd7\xa7\x47\xe7\xd4\x92\x42\xdd\x38\xeb\x28\xf5\xd9\xda\xda\x5a\xa1\x34\x90\x0d\xa8\x12\xae\x2a\x49\xcb\x4e\x2b\x2d\x5c\x34\xfe\xc3\x67\x9f\xc5\xbf\x6b\x36\x94\x47\xf8\x57\xf0\x64\x71\x3f\xf4\xa7\x35\x70\x5b\x73\x6e\x6a\xab\xac\x34\xaf\xd7\x26\x38\xcd\x6c\x3f\x50\x9e\x53\x48\xcf\x05\xaf\xcb\x6d\x35\x45\xfa\xba\x4f\xff\xb6\x47\xfd\xff\xee\x0b\xfe\x95\x26\xbd\xc4\xba\x26\x0f\xe8\x5a\xfd\x0c\x0b\x6d\x8d\xbe\xa0\xe9\xd2\x84\x17\x79\x6d\xb6\x00\x95\x24\x20\xcb\xd9\xa5\xce\x60\x31\xb6\x6e\xfc\x73\xe3\xc6\x3f\xff\xdc\x57\x53\xb3\x6f\xd7\x8c\x19\x71\x9d\xb3\x12\xed\x01\x59\x5b\xa4\xb2\x09\xd5\xff\xa8\x4c\xc1\xc8\xc4\x14\xb6\xa9\x80\xa8\x97\x82\x8e\xd3\x6e\xc6\x9e\x3d\xf3\xd4\xca\x9f\xd6\xae\xfd\x89\xd6\xf3\x44\x5c\x30\x49\x17\x98\x8d\x55\xcf\xe2\xbf\xa5\xb0\xdb\x45\xc5\xa8\x03\xba\x09\xf5\x40\xbd\x51\x18\xdd\x86\xc6\xa2\x29\x68\x36\x5a\x84\xee\x42\xf7\xa2\x4d\x68\x2b\x7a\x14\xed\x40\xcf\x86\x06\x6d\xeb\xf9\xe4\x93\x8f\x4b\xe4\xe6\x9b\x0b\x8a\x3c\x6d\xda\x24\xb7\xc7\xdd\x94\x7e\xfd\x1c\x03\x03\x13\x26\x64\x4c\x36\x6d\x69\x3e\x7d\x7a\xde\xac\xd0\xd2\xa5\x9d\x57\x1a\x37\x0f\x59\xbf\x7e\xd8\x83\x23\xef\xb9\x67\xcc\xba\x8a\xed\xf3\x6a\x8a\xda\x77\x1b\x38\x79\xcb\xac\x95\x9b\x1f\x5c\xb7\xbd\xa6\x66\xfb\xba\x07\x37\xaf\x9c\xb5\x65\xf2\xc0\x6e\xed\x8b\xcc\x3a\xbe\xfb\x23\xb7\x3e\x4e\x0f\xa7\x82\xaf\x17\x02\xa9\xcf\x4f\xfc\x49\xbc\xc3\xf6\x7f\xf8\xbb\xb0\xe1\x1a\x28\x66\xaa\x1d\x15\x49\xa8\x2b\x56\xa6\x23\xbd\x59\x71\x51\xb0\x30\x3b\xf6\x6e\x8f\xbd\xbb\x63\xef\x38\xf6\x2e\x35\xf9\x4c\xfd\x69\x80\x1e\x30\x05\x13\xff\x8f\xb2\x4d\x3f\x67\x36\x69\x2b\xde\x76\x26\x75\x0d\x4b\xa3\x7d\xb3\x52\x2f\x9d\x0b\x13\xcf\xe2\x5b\x23\x87\xd5\xbd\xb8\x27\x77\xe3\xc4\x89\xea\xbd\x45\x6d\xda\x14\x6d\x28\x2a\x2b\x2b\xfa\xab\xb4\xa4\x4d\x71\x06\xfd\xa8\x02\xa3\x2a\x2d\x79\xbe\x4d\x71\x71\x1b\x6e\x40\x69\x49\x49\x69\xdd\xd2\xb3\x13\xf1\xad\xfc\x0a\x75\xdf\xd9\x89\x75\xfa\x12\xf8\xe1\xee\xa6\xaf\x1b\x8b\xdb\xb4\x29\x8e\x3c\x5d\xdc\xa6\xa4\x34\x9d\x7e\xc6\x6f\xd1\x8a\x6a\x98\xd6\xf9\x8b\x56\xdf\x48\x9f\xaa\xeb\x26\x4e\x24\x19\xb4\xc5\xc8\xcb\xea\xbe\x89\x67\xf9\x25\x5f\x4c\x9c\x38\xb1\x6e\x1a\xee\x79\x3f\x94\xcb\x83\x5f\xf5\x5d\x80\x73\x1e\xfe\xc0\x1b\xe1\x8f\x41\xf0\x47\x64\x2a\x6d\xfc\xea\x17\xb8\xdb\x95\xa2\x89\x5f\x70\x1f\x97\x04\xdb\x46\x3a\x16\x17\x97\x3e\x54\x54\x54\xc6\x05\x62\xa5\x23\xd1\xd2\xd2\xe2\x6f\xa1\xa0\xfa\x5e\x9b\xa2\xb2\x1c\xf8\x1a\x60\xd6\x4d\x9b\x38\x11\x77\xfb\x42\xc3\xd9\xe9\xfc\x7c\xb4\x5a\x4c\x03\x9c\x35\xed\xe3\xc5\x1a\x8e\x1d\x29\x51\xfa\xcf\x4e\x92\x56\xd3\x83\x24\x61\x56\xec\x24\x89\xc9\x4f\xfc\x2c\x34\x84\xf9\xb5\xc2\xde\x10\x6b\xcc\x4c\x6a\x7c\xa7\xb0\xa9\xed\x60\xc8\xf5\x9d\x58\xa9\xfd\xec\x43\x9c\x21\x2e\x67\xf6\x33\xa0\x84\xbc\x51\x86\x7f\x40\xf8\x51\x3e\x15\x07\x28\x82\x35\x35\x7b\x51\xd5\xb6\x91\x1c\x9f\x5a\x2b\x2e\x8f\x8b\xf2\x6a\x2f\x66\x44\x03\x79\x45\xbd\x01\x7d\x16\xfd\x23\x41\x5e\x21\xb8\x46\x2f\xfd\x6f\x79\x45\x7d\xe0\x1a\x79\x65\xba\x3a\x00\xad\x66\xe7\x6d\xca\x7e\x8e\x50\xdb\xa5\x36\x48\x80\xe2\xd6\x4e\xe8\x56\x27\x1e\xd0\x5d\x53\x87\x27\x5c\x8d\xc0\x4e\xad\x62\x75\x1a\xe6\x72\x57\xfd\x54\xc2\x5c\x7c\xaf\x0e\xc0\xcf\xb1\x3a\x54\x1a\x35\xe8\x75\x46\x53\xa3\xaa\xf9\xa7\x12\xaa\xc7\x4e\x17\x31\x85\xc2\xfd\x43\x6b\x3a\x06\x4d\x7d\x42\x3b\x69\xa4\xfd\xd8\x0e\xeb\x53\x15\x5b\x1f\x51\xaa\x41\x66\x0d\x56\x53\xa1\x76\xc8\xf5\xbc\x96\xa9\x8c\xf3\x07\xbf\x03\xef\x13\x46\xd1\x1b\xae\x7b\x08\xa8\x77\xa7\x58\xc6\x25\xcd\x43\x18\x14\xd1\x3f\xda\x64\x67\xb7\x29\xcb\xca\x6e\x23\x88\xda\x7b\x1b\x68\xb3\x13\x8c\xfd\x48\xf4\x35\x58\xc4\x16\x21\x3b\x87\xb1\xc1\x48\xf4\x22\x20\x94\xd1\x24\x1d\x05\x95\x84\xae\x2d\x55\xa5\x1a\x85\x29\xa4\xcb\xe0\x8e\x2f\x49\x76\x30\xb0\xcc\xbb\xa6\xea\xc6\x1e\x3d\x6f\x18\x7a\x8f\x77\xb9\xbe\xef\x5b\xc1\x1e\x99\x73\x5a\x2c\x5c\xd0\x62\x76\xe6\x2d\xc5\x34\x54\x89\x7a\x94\xe9\xb1\x87\x91\x9d\x65\xc6\x03\x2e\x22\x0b\xc0\x9c\xad\x29\xe6\x16\x84\xb8\x25\x7a\x26\x9e\x7f\x8a\xbd\x68\x84\x9a\x5d\xed\xa8\x37\x6d\xb8\xe9\x00\x84\x84\x2b\xb4\x42\x62\x80\x80\x9b\xc6\xf6\x0c\x07\x83\xe1\x5e\x63\xc6\xf6\x1c\x54\x58\x38\xa8\xd7\x98\xc8\x9b\x1d\xf2\xf2\xda\xb5\xcb\xcb\xeb\x80\x2f\xc4\xff\xfa\xb3\xe7\xa8\x6e\xdd\x46\xf5\xec\x39\xaa\x6b\xd7\x51\x3d\x83\x25\xf0\xb8\x43\x49\x30\xf6\x4e\xe7\xbd\x0d\x7f\x3b\x7a\x53\x2c\x02\x49\xc2\x5c\x8b\x89\x48\x13\x65\xbf\xf3\x25\x9d\x3c\x92\x5e\x9a\x66\x0f\x4a\x6f\x56\x4f\x09\x45\x11\xbc\x08\x8b\xd4\x6f\xf7\xe1\xa4\x7d\x50\xa7\xaf\x5a\x29\x2c\x8f\xbe\xc5\xac\xec\x46\x41\xa0\x62\xcb\x29\xed\x0c\x96\x4b\x0b\x90\x20\xbd\x09\x97\x51\x2a\x2c\xff\x21\x72\x26\x72\xfa\x87\x65\x43\x71\xf7\x4b\x97\x70\x8f\xa1\x25\xea\x6a\x3c\x6d\xf1\x8c\x19\x8b\xd9\x7a\xf7\xe5\x8f\x0a\xcb\xc5\x42\x06\x83\x07\x09\x93\x8b\xdb\x8e\xf1\x7f\x83\x21\x16\x36\x00\x01\x18\x42\x0a\xd9\x2a\x6c\x69\xaa\x8b\x91\xad\x57\x0f\xf0\xdd\x85\x94\x85\xac\x8c\xfa\x11\xd9\x1a\xed\xaf\xe9\x57\xa4\x49\x19\xf5\x23\xad\x0c\xff\x9a\xb0\x4c\x88\x02\x07\xb3\x1d\x90\xec\x4e\x4b\x8d\x81\xc4\x8f\x44\xa1\x34\x15\x66\x32\x33\x62\x9b\x9a\xaa\x22\xd0\xb5\x52\x61\x59\xcb\xda\xe5\x9b\xd4\x1f\xd4\xef\xd7\x0c\x9d\x9e\xba\xac\xe5\xab\x73\xc3\xa7\xee\xc5\xf2\xce\x87\xca\x84\xe8\xb6\x07\x06\xf4\xef\x37\x64\xfd\xe3\xcd\x5b\x0e\xd8\x8d\xe2\xf0\x97\x8b\x25\xda\x58\x0d\x35\x3a\x5c\x3f\xd6\xf4\x2c\x00\xcc\x83\x18\x9d\x16\x10\x96\x2f\x1b\xaa\xee\xbf\x74\x49\x3d\x30\x74\xd9\x05\xae\x80\xcb\xe7\x5f\xa3\xe3\xc4\xd3\xb4\xfd\x01\x73\x4e\x4e\x03\x6f\x17\xe9\xb9\x04\x87\x45\x9c\xc0\xdb\x69\x90\x02\x72\x7a\x63\x5d\x12\xf9\x16\x18\xfb\x84\x19\x28\x1a\x55\x5f\xc2\x5f\xe0\x15\xfc\x6f\x8a\x24\x8c\x50\x6b\x34\x7f\x17\xf5\x45\x78\xd6\x95\x3d\x1b\xab\x2e\xd4\xec\x73\xd1\xe3\xf8\x02\xea\xc0\xfc\x7f\x28\x06\x48\x04\x8b\x17\x51\x79\xcc\x00\x0f\xf2\x13\x30\xc1\xf6\xb3\x67\xcf\x66\x77\x8b\x46\x70\x57\x23\x02\x85\xf3\x02\xc0\xe9\xce\xe0\x4c\xa5\xc1\x9e\x18\xec\xcf\xe0\x59\x0b\xea\x5f\x23\xcc\x8a\xc1\xc6\xea\x29\x78\x96\xc5\xff\xce\x74\x3e\x59\x76\x9e\x0b\xdb\xe5\x4b\x82\x5e\xcf\x9d\x0b\xeb\x7f\xa8\x8f\x08\x46\x4f\xae\x94\xfa\x40\x46\x8d\x32\xa4\xed\x7b\xf1\x86\x01\xc6\x79\x96\x07\x66\x3e\xf8\xc4\xa3\x9b\xa7\xde\xef\x58\xe0\xba\x6b\xf8\x00\x32\x41\xfd\xb0\xdb\x2d\xba\x89\xcb\x4e\x1c\x3f\x72\x6a\xd6\x04\xc3\xdd\x2b\x59\xfb\x6f\x42\x5b\x6d\xe9\x1d\x30\x61\x8c\xba\x3a\xd6\xfe\xc7\xf8\x02\x4e\x87\xb1\xb9\x80\x4a\x19\x75\x8a\x9d\x84\xe8\x85\x2f\x7a\xd7\x8b\xb9\xbd\xbd\xc3\x64\x9b\x6b\x2f\x77\x05\xad\x0e\x69\x6f\xc2\xa5\xae\xb9\xd7\xdc\xe7\xe2\x5d\xea\x65\x7a\x97\x0b\xda\xf5\x42\x1b\x3f\xb0\xb9\x98\x1c\x79\x59\x6b\x37\x3a\x02\xe6\xf4\x28\xbb\x77\xe5\x08\xe9\x6d\xf5\x97\xad\xb4\xfb\xf5\xd0\xe4\xb5\xd7\xab\x36\xfd\xf7\xeb\x55\xd1\x68\xb4\x12\x7f\x8d\x5e\x12\xd6\x42\x3b\x33\xa3\xa5\xb1\x39\xdf\x09\x6d\x87\xd9\x9c\xcf\x55\x0f\xc6\xc6\x7c\x00\x9e\xf5\xe2\xcf\x53\xbb\x69\xc8\x88\x79\x83\xc4\x73\x3a\xe1\x22\xa2\xdb\x8b\x05\x56\x81\x9d\x6d\xc4\xe9\x98\xdd\xac\x24\xf8\x8d\xd7\xdf\x58\x8a\x85\xbf\x56\x1c\x3a\x70\xd7\x15\xac\x87\xaa\x6d\xd5\xd7\xf1\x5d\x78\xaa\xfa\x09\x6e\xae\xae\x55\x35\xf9\x10\xfd\xc5\x3f\xc3\x95\xc4\xfc\xda\x01\x4f\xc4\xeb\xf8\xc2\x93\xbf\xee\x38\xfd\x35\xff\x8c\x03\x9b\x53\xd4\x3a\x5a\xe7\x4e\xa0\x7b\x7b\xa3\xb3\x62\x75\x9a\xfa\xc2\x0b\x9a\x9a\xb6\x17\x2a\xad\x74\xa8\xbf\xa5\x60\x9e\xfa\xed\x5c\x86\x3a\x67\xa2\x8b\x14\x89\x48\xb8\x44\x1b\x0f\xea\x18\xbd\x44\xf6\xb0\x3c\xa7\xc3\x43\x9d\x1a\xe7\x39\x0d\x38\x26\x3b\x6a\x1c\x67\x1c\x67\x1d\x02\x72\x28\x8e\x61\xec\xe3\x31\x78\x20\xe9\x69\x0a\x54\x59\x9c\x24\x2e\x14\x4f\x8b\x3c\x8d\x83\xd3\x24\x1b\x6a\xf5\xd0\xaa\xf2\x20\xe8\x5a\x53\xfe\xcf\x39\x51\xff\xf8\x7f\x9a\x13\x95\xde\x41\x82\xbe\xbf\xc5\xf7\xb4\x65\xa1\x2e\x08\x59\x25\x6e\x33\xbe\xb9\x2e\x8a\x9a\x87\x52\x70\x91\xaf\x9f\x6f\xa4\x6f\xa9\x6f\xbb\xaf\xd6\xf7\x81\x4f\x42\x3e\xcc\xf9\xb0\x0f\xf9\x92\x91\x23\x33\xd7\x5a\x8c\xf2\xab\xab\xaa\x8a\x19\x8c\xd8\xf8\x6d\x59\xa4\x58\x83\x81\x4e\xff\x2f\x18\x0e\xd4\x04\xc6\x21\xf5\x0a\x5e\xc4\xb7\x55\x44\x94\xca\xe6\xf4\x14\xff\x2a\xfe\xa7\x28\xc1\xda\x58\xf7\x53\x1f\x7f\x0e\x35\xdc\x21\xd0\x56\xf3\xd4\x4d\xa7\x4f\xf0\xaf\xa6\xe1\x8c\x4c\xf5\x2c\xd3\xbd\x51\x0a\xbf\x9b\x5b\x25\x76\x8a\xc9\xfa\x6d\x43\x7e\xbd\xc8\x63\x83\xd9\x8c\x45\x62\x01\x41\x48\x94\xd6\xd1\x08\xb0\x86\x63\x22\x96\xc5\x72\x91\x03\x51\xa0\xaa\x2a\x08\x6c\xed\x9a\x54\x3a\x5a\x03\x99\x31\x0d\xfd\xca\x4d\x2f\xed\x57\x3f\xd9\x88\x6f\xd8\xc8\xef\x4e\xc3\x93\x33\xd5\xf5\x7e\xa6\xa0\xb3\x7e\xf3\x08\x09\x7d\x84\x25\x4a\x16\xca\xa0\x63\x27\x65\xd1\x09\xd1\x79\xa8\xe5\x1e\xce\x71\x28\x6a\x08\xf9\x1c\x0e\x41\xc8\xcc\xf7\xe0\x0a\xcf\x6e\x0f\x57\xe0\x19\xe6\x59\xe7\x39\xe6\xb9\xec\x11\x38\x3b\x30\xb1\x62\x5c\x35\xa5\x8a\x4e\x03\x8c\xf7\x25\x7c\x04\x2f\xe0\x1e\x82\x51\x44\x43\x32\x41\x02\xcf\x09\xf8\x03\xe1\x9c\xf0\xbb\x40\x04\xea\xc8\xe0\x9e\x39\xaf\x6b\x1f\x61\x38\x90\x55\x6a\x8e\x0c\x09\x84\x17\x1c\x02\x37\x19\xbe\xab\x09\xe9\x6f\x9f\xd4\xb5\xb3\xd0\x4f\xe0\x68\xc9\x7d\x23\x46\x77\xa5\x4f\xf7\x0d\xa9\xee\xca\x3e\x57\x0e\x66\x9f\x43\xce\xde\x03\xba\x66\x08\x45\x42\x67\x81\x9c\x13\xf0\x6e\xe1\x98\x70\x26\x06\x5b\xb9\xb1\x4b\xd7\x02\x01\x67\x08\x18\x09\x8a\xc0\xb5\x67\x0f\x4d\x6d\xda\x75\x7d\x49\xc0\x35\xc2\x3a\x0d\x6e\x28\xb7\x65\x41\x57\xa3\x80\xcf\x08\x67\x05\x6e\xbb\x50\x2b\x1c\x17\x08\xed\x0a\xbd\x0f\x06\x95\x2e\x0b\xf8\x11\x61\x97\x00\x1f\xb0\x9e\x41\x3d\x68\xb6\x76\xc5\x68\x33\x73\x46\x60\xf1\xa4\xaa\xaa\xa6\x54\x53\xc7\xdf\xdc\xa9\x53\x73\xe9\xa7\x5c\xea\xcf\x0b\x3f\xec\x53\x35\x7c\x9c\x12\xbb\x60\xc8\x9c\x6c\xf0\x91\x2f\xbe\xa0\x34\xe5\x0f\x98\xdf\x9f\x60\x7e\xb3\x51\x73\x74\x39\x36\xc3\xcd\xe9\x0c\x87\x0c\xd8\x42\xb0\xcc\xcb\x0e\x99\x3b\x14\x9d\x12\x52\x64\x19\xe3\x4c\x94\x8f\x30\x77\x14\xe1\x33\x08\x53\xa0\xc5\xb9\x55\x30\xbd\xe5\xc5\x6c\xad\xa2\xbf\x22\x24\x9a\x19\xac\x5c\xf4\x63\x0c\x56\x26\xc0\x2a\x09\x39\x2b\xec\x35\xf6\x6d\xf6\xdd\xf6\x63\x76\x81\x81\x45\xb2\xa2\x81\x95\x65\x19\x56\x10\xc0\x4e\x42\x47\xd1\x69\xc4\xd7\x83\xc4\x55\x0c\xe6\xf7\xc0\xa0\xfa\x33\x98\x79\xe8\xd3\x18\x4c\x1f\xc0\x0c\x85\x1c\x46\x63\xae\x91\x2b\x32\x2e\x35\x72\xd4\xa9\x51\xe2\x25\x87\x04\x20\x47\x87\x5c\x92\x14\xef\x69\x2f\x54\x0d\x80\x17\x22\xbe\xa6\x71\x7f\xe1\x03\xc0\x7e\x29\x7a\x49\x78\x5f\xd8\x08\xb8\x55\x58\xc7\x20\xab\x3f\x01\xe4\xcc\x90\x81\x4b\x21\x34\x6a\xe5\x31\x1f\xc0\x1b\x1a\x32\xf8\x7c\x3a\x5d\x26\x0d\xa3\x84\xab\x8a\xeb\x47\x0c\xb8\xd9\x09\xc6\xfb\x0c\xeb\x5b\x7b\x1a\x6c\x92\xf5\x6d\x7a\x74\x1e\xfe\x22\x14\xd5\x2b\x78\x53\x73\x05\x7b\x94\xae\xca\x40\xe5\x90\xf2\xa6\xf2\xbd\x22\xea\x94\x31\xca\x2c\x65\xa5\xc2\xbf\xe1\x51\xda\x28\xdc\x53\xf0\x94\xd3\x29\x1e\x28\xf0\xa6\xf2\x89\xf2\x1f\x45\x7c\x40\xa7\x60\xa3\x5b\x59\xa1\xec\x50\xc8\xcd\xca\xed\xca\xc7\x0a\x91\x14\xb7\xc2\x1d\xd8\xa1\x60\x49\x29\x55\xfe\x4d\x3f\x97\x2a\x95\xf0\xd5\x4c\xe5\x01\xe5\x3b\x45\x5a\x5c\x49\xbf\x71\xc3\x47\x5a\x49\x68\x9f\x0d\x5f\xad\x80\xaf\xfe\xad\x08\xf4\x71\x36\x94\xbe\x19\xca\xcf\x54\x0e\x2a\x6f\x00\xb8\xef\x14\xa3\xc4\x1e\x56\x42\x99\x1d\xb1\x47\xff\x56\x0c\x26\x51\x71\x29\x9c\xa8\x94\x28\x33\x94\x8d\xca\x93\xca\xb7\x8a\xb8\x64\x80\xf2\x3a\xbc\x13\x51\xc9\x52\x96\xc3\xa3\xd7\x15\x81\xfe\x39\x20\x56\xe2\x80\xf2\xa7\xa2\x0b\xd1\x6a\x25\xca\x68\x78\xb6\x3c\x56\xef\x4f\xc5\x90\xa5\x74\x51\x42\xab\x07\xc0\xe3\x03\x50\xeb\x23\x5a\x50\x84\x12\x9c\x22\x28\x99\xca\x4d\xca\x06\xe5\x09\x65\xbf\x22\x4e\xa1\x9f\x8a\x95\xfe\xca\x28\xe5\x4e\x78\xf6\x0f\xe5\xbc\xf2\x87\x62\xa0\x8f\x6e\x62\x0f\x97\x41\xb1\x7f\x28\x1f\xb2\xc7\x46\x01\xca\xec\x67\x1f\x85\x4e\xbc\x92\xa1\x74\x56\xfa\x29\xd3\x95\x5a\xe5\xb8\x72\x4e\xf9\x5d\xd1\xf3\xf0\x61\xbd\x42\x86\x13\x65\x9a\xc2\xcd\x42\xd8\x48\xb0\x09\x99\x14\x53\xc8\x34\xcc\x34\xd9\x54\x63\x12\x0f\x45\x9f\x0c\x19\x4d\x26\x9e\xa7\x0e\xcf\xbb\x11\xd7\x80\x07\xb0\x6f\x58\x36\xd3\x29\x53\xd9\x1f\x53\x63\xbf\x8d\xdf\x1a\x7d\x47\xf1\x06\xf6\xcc\x73\x14\x6f\xc8\x60\x43\x03\xde\x94\x84\xcc\xbb\x72\x31\xce\x22\x38\x43\xc9\x58\x97\x01\xa8\xd3\x31\xe4\xca\xc8\x48\x4b\xcb\x04\xb1\xbf\x1a\x3d\x82\x88\x1f\x5e\x76\xa1\xaf\x01\xc9\xa7\x34\x20\x22\xc0\x03\x09\x91\x4b\x15\x3b\x01\xbc\xf1\x80\x45\x22\x69\x7b\x3f\x42\xff\x09\x1d\x91\xbd\x7e\xef\xcf\xde\xa8\x97\xff\x20\xdf\x5b\xee\xed\x45\xff\xca\xa7\xd7\x04\xe8\xdf\x5f\x7b\xf9\xed\xb2\xf7\x34\xbc\xff\xec\xe5\x27\x79\x17\x7a\x39\x5a\x7a\x97\x97\x4c\x5c\xcb\x9e\x92\x7c\xf6\x15\x54\x91\xbd\xb8\x0d\xfd\x2e\xdf\x7b\x94\x3d\x10\x65\x6f\xb5\x56\x3a\xea\x25\x3a\xe4\x05\x99\xc2\xab\x78\xcf\x78\xcf\x7a\xf9\x80\xf7\xb2\x97\xa3\x9f\xb8\xe7\x43\xde\x0a\xed\x19\x82\x17\x6e\x9a\x56\x84\x04\xbc\x93\x69\x01\xdc\x61\x9d\x77\x9b\x77\xb7\x97\xec\xf6\x1e\xa3\x8f\x91\x97\x7e\x86\xc2\x12\xe1\xb0\xc1\x60\xcd\x82\x37\xe5\x50\xf4\x8b\x5a\xc5\x45\xf4\x94\x0f\x15\x17\x23\xf6\x8a\x1b\xa6\xf1\x9a\x79\x6d\x98\xdf\x18\xcd\xa7\xf7\x76\x33\x18\x0f\x78\x0a\x21\xfe\x02\xfb\xcc\x62\xba\xc3\x67\xcc\xe7\x0b\x8b\x81\x0f\xa5\x84\x2c\x84\x47\xbc\x24\x0a\x5c\x75\x58\x20\xc4\xd6\x38\xb7\x82\x93\x7a\x08\xf3\xf9\x91\x36\x47\x85\xc5\x5b\xae\xfa\x84\x45\x4c\xde\x45\x1d\x00\x7e\x12\xf3\x69\xb6\xa0\x8e\xa1\x34\x11\xf4\x06\x83\x45\x10\x0c\x1c\x51\x64\x45\xc1\x32\xec\x42\x22\x70\x16\xde\x52\x1d\xe6\x6d\x06\xaa\x0e\x15\x32\x99\x21\x88\x59\x84\x1b\x5b\xe3\xe8\xce\xce\xb4\xd2\x4c\x4c\xe3\x1d\x8b\x12\xe6\x6e\xfc\x14\xab\x57\xd3\x31\xef\x50\x9f\x4f\x0d\x72\x7a\x7f\xae\xfa\x9c\xb0\xe8\xaa\x69\xf5\x6a\x99\x0c\xed\xfe\xa8\x29\x30\x69\x5c\xdd\xf6\xfa\x31\xa9\x6c\x4c\xcd\x51\x8c\x96\xf0\x8f\xb3\xcf\x1d\xe2\xdf\x0b\xda\x5d\xe6\x5c\xc6\x7b\x1b\xc7\xe9\xec\x15\xca\x4d\x75\xca\x72\x2c\x4e\x27\x0a\x0c\x0b\x70\x46\xe2\x4b\xad\x0e\xcb\x3e\xe8\xbb\xcf\xc7\x1b\x8d\xb6\x6a\x16\xb5\x13\x86\x60\xbf\x26\x34\x64\x43\xda\xde\x78\x48\xcb\xbf\x0f\xdd\x89\xd3\x9c\x69\xff\x23\x74\x67\xdd\xbf\xb8\x1e\x91\xfd\xff\x2b\x7a\x27\x1e\xbd\x0d\xc6\x75\x18\x16\x70\x1e\x1b\x57\x5e\xfd\x38\xcb\xd9\xe7\x56\x6c\x6d\x0d\x08\x0b\x3d\x61\x6d\x75\xb0\x32\x19\x3a\x89\x08\xa0\xe5\xd0\xab\x73\x06\xfd\x0c\xb2\x9c\xd0\x0b\x70\x22\xb2\x4d\x32\xe0\x02\x03\xce\x37\x40\x71\x4c\xaf\xb3\xd0\x05\x0a\x56\x25\x06\xaa\x62\xf7\x5a\xb3\x69\x46\x8b\xa0\xd0\xf3\x84\x3a\xaf\x5f\x3f\x75\xce\x09\xae\xfc\x75\x4c\xce\xfe\xf5\x57\x1d\x4c\x6c\xac\x6d\x91\x63\x6d\x17\x34\x99\xf3\xd6\x6c\xce\x07\xc1\x9a\x7c\xca\x7c\xec\x24\x90\xa5\xdb\x85\x52\xa1\x17\x50\x41\x14\x4c\x66\xa3\xa1\x9a\x45\xae\x15\xa5\xea\xb0\x68\x43\xa4\x3a\x4c\xd1\xa4\x71\x4a\xf1\x58\xe8\x4d\x66\x9d\x86\x49\x04\x44\x29\xa6\xbf\xf3\xf9\xb2\xab\x6f\xf0\x43\xae\x2e\x22\xe7\xea\x0e\x0a\x8b\xb6\x5c\x3d\xb8\x65\x0b\xb7\xec\xa1\x87\x34\x79\x27\xb6\xce\xd0\x87\xc2\x18\xae\xb3\x3e\x41\x0f\xca\x43\x6e\x24\x11\x5e\xe2\xf5\x3a\xa4\xc7\x48\x5f\xa3\x5f\xa7\xdf\xa6\xe7\x8d\x44\xcf\xc4\x09\x8b\xb5\xab\xb6\x09\x78\xd0\x39\x28\xc2\x6a\x41\x26\x1b\x62\x42\xa7\xc5\x62\x95\xf0\xb7\x45\xc4\xa3\xfc\x2c\xfe\xec\x55\x80\x7b\x65\x61\xa3\xfd\x15\x64\x6d\x4e\x80\xcf\x8f\x0a\xf4\x5c\xe4\xa6\x50\xba\x44\x88\x41\xc7\x71\x22\x36\x62\xa3\xd9\x42\x80\xcd\x56\x87\xf5\x9c\x8e\x20\x9e\x60\x03\x82\x69\xa0\xcd\xc5\xa2\xae\xd5\xc7\x43\x66\xf7\x78\xa9\xbf\x3b\xf3\x03\x08\x16\xeb\xe9\x39\x16\xcc\x00\x20\xd3\x04\x2e\x29\xf2\x6f\xf2\x5d\xdd\x65\xfc\x96\xea\x22\x13\x1f\xe3\x6e\xc4\x57\x1f\xdd\xa2\xde\x38\x2f\x72\x79\x0b\xf4\x05\xb0\x80\xaf\x65\x7d\x29\x65\xf3\xd1\x12\xc6\xdf\x82\x7d\x6e\xcf\xd6\xe4\xce\xe8\x1f\x20\xaf\xac\xa2\x67\xdf\xb0\x73\x16\x84\xf2\x02\xe6\x64\x87\x28\x66\x58\x25\x0f\x42\x92\x99\xb4\xc8\xa9\xcd\x39\x97\xc3\x6d\xcb\xc1\x19\x39\x9d\x73\x46\xe6\xac\xcf\xe1\x95\x1c\xcc\xa1\x1c\x2c\x93\x1c\x3a\x51\xc9\x06\x73\xd7\xe4\x74\x7d\xfa\xb0\xb0\xa0\xf7\x65\x29\x59\xc3\xc2\x0e\x45\x0f\xff\x44\x1b\x11\x6d\x8d\xb3\x1e\x6a\xaf\x6c\x1e\xd9\x5d\xab\xfa\x9d\xdf\x10\xe0\xcb\x82\x73\x31\x75\xdc\x61\xb1\x9e\x51\x1a\x73\xdf\x09\x20\x49\x49\x03\x15\xb2\xb0\x24\x93\xc6\x59\xb5\x52\x9b\xcd\x4f\x0b\x7f\xda\xd6\xf7\x85\xbe\x8f\xfe\xb4\x00\xbb\x31\xee\xfa\xc2\xcd\x98\xc3\xee\x63\xea\xba\x82\x36\xcf\xbf\x58\x27\xbd\xf8\x7c\x9b\xa2\x03\x07\xb8\xb3\x9b\x7e\x5c\xfc\xcd\x37\x4b\x7e\x7c\xf0\x27\x2c\x1d\x38\xa0\xfe\xe7\x17\x3c\x29\xe2\x3a\xf6\xd2\x4b\xc7\xb8\x0b\xb5\x48\x9b\x1b\x21\x97\xcd\x45\x3b\xb6\x4e\xf7\x02\xfe\xa6\xc2\x3a\xa5\xa0\x79\xa1\x32\x87\x5b\x49\x49\x31\x23\x6a\xbc\x72\x13\x7f\x2a\xef\xef\xec\x5f\xea\x5f\xef\xe7\xb7\xfb\x6b\xfd\xc7\xfd\xe7\xfc\xbf\xfb\x85\x61\x7e\xdc\xd9\xdf\xcf\xcf\x05\xfc\x05\x7e\xce\xe1\xc7\xc8\x8f\xcd\x9c\x9f\x4e\x8a\x53\x6f\xea\x9a\xcc\x99\xb8\x61\x61\xe5\x67\x13\x36\x99\x9c\x16\x89\x20\x76\xe7\x25\x58\x96\x5f\xd5\x30\x0d\xda\xe5\xb1\x04\x0a\xa8\x21\x16\x1b\x3e\xd5\x99\x5d\x5a\xdc\xd0\x58\x88\x17\x3a\x39\x56\xee\x6a\xdf\x47\x7f\x5f\x7c\xf4\x8d\x67\xdb\xbc\xd0\x66\xf7\x6b\x47\x97\xfc\xf6\x68\x5f\xfc\xcc\x92\x1f\x1f\xc0\xa7\xd5\x96\xcf\xbe\x45\xba\xd5\x1d\x7c\x63\x17\x7e\x5f\x6d\xbd\xe1\xa7\xa5\x6a\x7f\x4d\xdf\xab\x84\x71\x3e\x0e\xb4\x2e\x1d\xf5\x0d\xe5\xa4\x7a\x45\xa3\xd7\xe8\x94\x9d\x49\x69\xb2\x81\xa4\x91\x8c\x4c\x39\x13\x44\xc8\x54\x8f\x49\x27\xfa\x92\x7c\xb0\x0d\x93\x6c\x08\x88\x1d\x70\x8d\x86\x98\x75\xf4\xa7\x51\x6e\xf2\x84\xd8\xe8\x98\x65\xda\x92\xca\x31\xd5\x3e\x4a\x6c\xc5\x31\x73\x9a\xcd\x4d\x95\x11\x3f\xa6\x91\x1e\x11\x17\xc1\xf9\x78\xf0\xc7\xef\xf6\x5e\xf8\x7b\x64\xdf\xbe\x97\x7e\xfa\xe4\xb3\x9f\x5e\xac\x8d\xec\xfb\x7d\x61\xef\x33\x9f\xe0\xc1\xc2\x46\x75\x8f\xfa\xd9\x09\xf5\xd9\x69\x82\xb8\xe5\x6c\x35\x4e\x39\xf4\xbd\xaa\x7e\x7f\x50\xfd\x66\xd8\xd9\x2d\xa2\x30\x05\xf7\x7f\x0b\x67\xe1\x5e\xda\x7e\x96\x80\xe1\x14\x89\x7b\x41\xff\xcb\xa3\xbc\x5d\x8f\x3f\x43\x28\x29\x24\x73\x98\xe7\x85\x2c\x0e\xeb\xb0\x4e\x44\x1c\xe3\x91\x8c\x45\x32\x1c\x67\x38\x2f\xee\x05\x1a\x68\x42\x0a\xde\x0f\xd2\xa4\x49\x31\x9b\x44\xb3\x89\xb7\xda\x0c\x16\xb3\xe5\xde\xb0\xde\x2c\x22\xa2\x23\x1e\xd2\x95\x10\x13\xc1\x3a\x7a\x43\x69\x86\x0d\x0f\xb7\xe1\x7e\x36\xdc\xc5\x86\x4b\x6c\x38\xc3\x86\x5d\x36\xcc\xdb\xf0\xaf\x36\x8c\xcf\xda\xf0\x19\x1b\x3e\x6e\xc3\xbb\x6d\x78\x9b\x0d\xaf\xb7\xe1\xc9\x36\x3c\xd2\x86\x43\x36\x5c\xc4\x8a\x3a\x6c\x18\xd9\xf0\xd8\xdf\x6d\xf8\x5c\xbc\x68\xad\x0d\x6f\xb7\xe1\x75\x36\x5c\x63\xc3\xd3\x6d\x78\x98\x0d\x57\xd8\x70\x67\x1b\x0e\xb0\xd2\x00\x18\x0a\x03\xdc\x0f\xe2\x70\xb7\x33\xb8\xd3\x19\xdc\x7e\x0c\x74\x01\x03\x8d\x58\xc9\xe3\x0c\xd4\x52\x56\xa0\x1f\x83\x93\x11\x87\x53\xa6\x41\xd9\xce\xbe\x9e\x1c\xaf\xaf\xf5\x8b\x35\x13\x6a\x43\x7b\x75\x8c\x75\x49\x03\xa2\x7d\xaf\x55\x3f\xc7\x6a\xbf\xc4\x00\x40\x6d\x6e\x18\x6b\x38\xdf\x86\x65\x1b\x6e\xb8\x26\x79\xbd\x9b\x91\x43\xff\xee\xfa\xe4\x7f\xbd\x3b\x59\x5d\x5f\x98\xee\x0f\x5b\xd9\x50\x1a\xf3\xee\x9d\xc2\x46\x4a\x2e\x0d\x53\x91\x6e\x67\x81\x15\xe2\x5a\x2e\xd1\x1f\xe1\x22\x67\x4f\xe1\xbd\x78\xf7\xa9\xc8\x5f\xd4\xd5\x8d\xeb\x1a\x39\xc4\x75\x25\x65\x91\xdb\xb8\x47\x66\x33\xaf\x37\x9a\x87\x3b\x7a\x89\x1f\x25\x4a\xa0\xeb\x8f\xd0\x34\x0a\x4c\xe3\x41\x38\x42\x26\x2e\xdb\x9a\xc5\x65\x27\x65\xe7\x88\x0a\x53\xed\x73\x35\xbd\xbe\x4b\xf4\x12\x19\xc7\xca\xdf\xae\x95\x47\x6f\x69\xe5\x31\x94\xc7\xd9\xdd\xb2\x73\x0c\x7c\x62\xf9\x71\xea\x40\xf2\x13\x2b\x3f\x36\x06\xbf\x2c\x56\x3e\x09\xca\x27\x8d\x4c\x4a\x31\x7b\x12\xcb\xdf\x05\x1b\x72\x2f\x2b\xaf\xc9\xa6\x65\xef\x52\xfc\xb5\x62\x90\xf2\x28\xf9\x57\x40\x57\x32\x98\xa9\x94\x57\xd5\x50\x87\xe6\xe6\x50\xc5\x4e\x50\x67\x26\x6b\xa3\x2d\xfa\x0a\xda\x48\x0b\x19\x41\x2e\x74\xb9\x98\x78\x98\x7c\x28\xfa\x4b\x6d\x72\x33\x11\x25\x8a\x87\xb1\x5c\x82\xfc\x28\xbe\x27\x48\x39\x59\xa8\x7f\xa8\x25\xc8\x63\x76\xbb\x09\xa5\xa5\x35\xf7\x89\x6e\x97\xe8\xca\x6e\x8e\x9a\x63\x03\x41\x69\x76\x13\xaf\xb8\x9c\x8a\xac\xcf\xa0\x39\xeb\x68\x3a\x57\x92\x10\x8f\x8a\xb2\xa2\x46\x42\x4e\xb0\x21\xa1\x65\x66\xa3\x7c\xeb\xd4\xbf\x98\x93\x5c\x36\x7a\x68\x93\xad\x45\xaa\x2c\x65\xc7\x37\xa4\x47\xf9\xae\xd9\xa7\x5e\xf9\xf4\xdd\x05\xfb\x5a\x72\xee\xc2\x97\x0b\xfb\xe9\x84\x76\xf9\x07\x3d\xe9\x42\xe4\xf8\xd4\xa5\xb3\x9e\x48\x4a\x79\x70\xe6\xca\xd9\x3f\xae\x9c\x4d\x03\x51\xe2\x64\x9c\xb4\x7c\xf6\xcc\xe9\xe3\xd4\x53\xc3\xb7\xa9\x27\x6f\xef\xb0\x36\x0d\xb7\xfe\xea\xc4\x77\xc7\xdf\xff\xe0\x84\x26\x73\xae\x51\x2b\xf9\x6e\xc2\x49\xe4\x44\x2d\x50\x38\xd4\xd2\xee\xb7\xfa\x0d\xc9\xc9\x28\xdd\x6a\x45\x2e\xbd\x1e\x66\x32\x37\xc7\x1e\xf0\x07\xfc\x34\x24\xa1\x85\x58\xb2\x2a\xc2\x16\xa4\xf7\x11\x6f\xc3\xb8\x12\x33\x02\x35\x4e\x34\xa9\x45\x34\xd5\xe4\x38\x7a\x76\x90\xae\xd9\x32\x4b\xe2\x59\xf9\x71\x7d\xc8\xfa\xe2\x78\x78\x41\x27\xdf\xed\xc7\x2f\x0e\xae\x10\xc5\xda\x73\xff\xfa\xc7\xbb\x5f\xaf\xdf\x59\xf7\x57\xe8\x89\xde\xab\x1f\x7c\xee\xf1\x85\x53\x66\xdf\x71\xff\x22\xbc\xe1\xf5\x6f\x86\x4e\x1d\xa8\x7e\x2c\x3c\x0b\xe5\x9e\x8c\x54\xa6\x9c\x54\x37\xe7\xb6\x7e\x68\xc5\xbd\x5b\xd6\xf8\x56\xcd\x19\x3e\x79\xf3\x0e\x8d\x56\x4b\x80\x4f\x34\x27\x8a\x0d\xdd\x1a\x4a\x31\x18\x6d\x26\x49\xa6\x11\xf3\x14\xc9\xc8\x3b\xec\x21\x07\x46\x8e\x02\xc7\x30\xc7\x3a\x07\xef\xa0\x7c\xc6\xec\x4c\xea\x6a\x92\x6c\x36\xd9\x67\x30\xb0\x84\x26\xf9\xe5\x94\x3e\xe3\xdc\x06\xa6\x52\x9f\x2b\xda\x9e\x4a\xdc\x25\x34\x04\x10\xac\x4f\x7a\x49\xa9\x74\xec\x0f\xc9\xe9\xb0\xf2\xae\xa2\x9f\x8f\xaa\x73\x9a\xb5\x35\x1f\xf5\x86\xf8\xb6\x91\x2a\x57\xf9\x8d\xe5\xae\xc1\xeb\xb8\x27\xae\x5e\x1d\xa4\xfe\x32\xfd\xd8\x6f\xda\x7c\xb3\xfc\x99\x2c\x36\x5d\x00\x24\xa7\x80\x64\x49\xa1\xd9\xe0\xbd\x28\x60\xf7\xda\xd3\x9a\xa5\x98\x53\xcd\x15\x61\x3e\xd9\x95\x8a\x5c\x06\x9a\x92\x36\x1e\x1a\x3b\x41\x80\xd1\xc2\x24\x69\x41\xd3\x69\x9a\xf5\x58\xaa\x46\xc0\x92\x54\xce\xe9\xa0\x02\x72\x71\x91\xad\x94\x0a\x36\x64\x58\x71\xdf\x7e\xfb\x8e\x6c\x5d\xb5\x6e\x83\x1a\x7d\x08\xb7\x9f\x3d\xb6\xad\xaa\x9e\xfd\x97\x1a\xb9\xf0\x9d\xfa\x0a\xf7\x25\xfe\xb8\x72\xd3\x92\xca\xd0\x4f\x5b\x9e\x3e\x5c\xcb\xa7\xeb\xd4\x97\xe7\x3d\xb2\xeb\xf6\x6f\xd4\xdf\xb1\xf8\xdd\xab\xd8\x5d\x81\xfb\xce\xd4\xce\xee\xb4\xbd\x0c\xb8\x9f\x45\xa3\x73\x66\x24\x5b\x03\x66\x2b\x31\xb8\x78\x03\x9f\xdd\x5c\x6e\xde\xab\x39\x67\x00\xdc\x4f\x23\x66\xc0\x92\x40\x45\x58\xf6\x83\xa4\xef\xf7\x4b\x0e\x07\xe0\x88\xdb\xa1\x48\x08\x50\x45\x72\x35\xba\x6d\xdb\x38\x96\x7d\x7c\x3b\xc4\x87\x95\x99\x68\x70\x2f\x8d\x07\xb4\x69\x88\x67\xe3\xd4\xd2\x53\xe2\x37\x2b\x77\xb4\x1b\x5b\xf1\xd9\xd2\xfd\xaf\x6c\x98\x36\x6e\xfe\xdb\x4f\x5c\x9d\x5f\x33\x64\xf3\xe0\x61\x5b\xde\xda\xf4\x60\xef\xf1\x53\xc3\x5d\x47\xde\x36\xfc\xc9\x0d\x77\xac\x37\x72\xa6\x95\x23\x16\x3f\xf2\xc2\xc0\x55\xfd\xbb\x0f\xee\xbf\x22\x7b\x40\x8f\xca\x58\xcc\xc5\x01\xea\x23\x64\x18\xac\x45\x06\x1a\x1c\x72\x26\x37\x6b\xa6\xe8\xfd\x28\x49\x9f\x94\x95\xd9\x8c\x21\x3c\xef\x40\x87\xa2\x97\x43\x7e\xbb\xab\xeb\x0a\xf4\x00\xe2\x3e\x4b\xc2\x4f\x27\xbd\x90\x74\x22\x89\xac\x4c\x7a\x30\x89\x73\x24\x21\x62\x0a\xc0\x42\xe6\xd3\x5d\x4d\x29\x70\xae\x35\x98\xb8\x4c\xf5\xc2\x58\x3c\xf1\x1a\x35\xde\x6a\x97\x89\xf9\x62\x05\x17\x4b\x34\xef\x86\x0e\x63\x67\x41\xd5\xb2\x92\x49\x83\xda\x66\xe4\x2f\x70\x07\x72\xfa\xd6\x4c\x1b\xdc\xab\xd4\xcf\x75\x58\xa8\xee\xe0\x16\xab\x5f\xa9\x57\xf0\xdc\x1b\xfb\x16\xa7\xcb\xcd\xca\x06\x76\xce\x9b\xd8\xab\x8d\xbf\x4f\x72\x46\x41\x46\xaa\x2f\xab\xb8\xc7\xa8\x1b\xf0\x72\xee\x36\x9e\x5f\xb2\x50\x7d\x41\x4d\x67\x63\x62\x74\x94\xd9\xa4\x6f\x0d\xb9\x90\xd7\x0a\x7b\xd8\x6b\xf0\x25\xd5\xf8\xf0\x5a\x1f\x46\x3e\xac\x10\x1f\x45\x78\x9b\xdd\xdd\xd5\xeb\xb3\x3a\xf5\x4e\xa1\x22\xec\x54\xcc\xb2\xde\x59\x1f\x6e\xcd\x53\xae\xc9\x54\x53\x1a\xa8\x14\xcb\x07\xd8\x28\x7d\x2d\x76\xc6\x83\x66\x92\x32\x2d\x71\x6d\xc6\x4e\xab\x53\xcb\x03\xa5\x0e\xe4\x07\xd4\x67\xac\x9d\x3b\x21\x7b\x6c\x0b\x9a\xff\xe9\xea\x0a\x2a\x43\x8c\x03\xfc\xd7\x0b\x6f\xc7\xf2\xc7\xf6\x0f\x29\x34\x77\xac\x05\x10\x5d\x44\xde\xa4\x61\x49\x38\x89\xc9\xc2\x34\x3f\x42\x12\x76\x11\x9a\x50\xb6\x3e\x8f\x2c\xba\x4e\x1e\x59\xa6\x32\xe6\x56\x35\x89\x58\x9f\x98\x49\xd6\x66\x4f\x4b\xc2\xf6\x66\x1c\x49\x33\x60\x5e\x7f\xf9\xdc\xd9\x8b\xf8\xdd\x9f\xbf\x56\x73\xd6\x2e\x15\x22\x5f\x0a\x8b\xd6\xad\x59\x2c\x72\xe9\xc2\x7c\xee\x4b\x75\x89\x7a\x0f\x9e\x8f\xa7\x73\x3f\xa9\x6b\xeb\xdc\x34\x46\xa9\x7a\x49\x3d\xc7\x7f\x0a\x7a\xe2\x79\x0c\xea\xab\x86\x33\x94\xef\xac\x66\xb9\x96\x5e\x0e\x2d\x01\xa1\x16\xb4\x10\x23\x0f\x0a\xef\xd7\x46\xbc\xce\x88\x7b\x19\x71\xb9\x11\x23\x23\x1e\xf7\xb3\x11\xc3\xa3\x47\x8c\x78\xb2\x11\x0f\x33\x62\xd9\x88\xa3\x46\x0c\x0f\xcf\x18\x71\x0d\x2b\x04\x0f\xfd\xec\x79\x29\x7c\x71\xda\x88\x77\x1b\xf1\x36\x06\x03\xbe\xcb\x67\xdf\x41\xd1\x63\xec\xf9\xa4\x78\xd1\xb3\x09\x65\xfc\xac\x9d\x78\x64\x86\xc6\xf2\xc1\xd0\xf8\x93\x44\x39\xa1\xfe\xde\x3c\x53\x7d\xe2\x82\xb1\xfb\x8d\xd4\x40\x6d\x6e\x66\x60\xc5\x4d\xa4\x67\xdd\xd3\x9d\xe6\xd0\x9c\x93\x34\x66\x27\x61\x31\xf1\x3b\x85\x32\x91\x19\x34\x2d\x5e\x07\x78\xc4\x13\x93\xd1\x5c\x63\x3e\x66\x3e\x6b\x26\xe5\x66\x7a\x61\xd6\xc0\xeb\x74\x82\xcc\xd3\xb8\x9d\xa0\xe8\x5a\x81\xb7\xd1\x40\xbb\xb6\xc4\x8b\xf4\x69\x58\x62\xc7\x56\x54\xe6\x20\x05\xea\x7d\x4b\x6b\x6b\xf1\xe7\xef\xab\xdd\xf0\x3b\xf8\xa7\x89\xea\x42\xa0\x94\xbf\x71\x66\x35\x3f\xf2\x00\xb4\x6b\x01\x04\xf9\x89\xc5\xc0\xea\x1c\xca\x96\x2d\x36\x33\x72\x02\x62\xe8\x2c\xbc\xc7\x8d\x3c\xd4\x88\xbe\xcd\xb3\xdb\x23\xe8\x89\x0d\x19\x5c\x16\xa7\x01\x30\xd7\x90\x10\x0e\x53\xe3\xab\x89\x36\x90\x56\x24\x1e\xe1\xd1\x1d\x8b\x24\x07\x7a\xf7\xe9\xce\xb9\xb9\x25\xd9\x29\x8e\xf4\x1b\x3b\x8e\x5f\xd9\x03\x3f\x73\xe4\x74\x0b\x8f\x9c\xab\x7e\xf3\x12\xf9\xc7\xcb\x23\xdb\x25\x1b\x16\x7b\xee\xfb\xc7\xd5\x55\x5c\xa7\xc9\xa3\x5b\x8d\x8f\xb0\xf3\x60\x74\xb7\x3a\x93\x17\x61\x3e\x52\xd0\x2d\x21\x07\xf1\x7a\x93\x6c\x16\x8b\x9c\x24\xfb\x53\x11\xd0\x09\x4e\x26\x4c\x55\xb1\x39\xdc\x5d\x89\x41\x49\x71\x7a\x15\xd9\x22\x39\x69\x34\x74\x2d\x4c\x62\x79\x90\xd2\x6f\xb6\xa5\x1a\xa3\x69\x1a\x50\x82\x78\xea\x73\x57\xec\x70\xaf\x21\x31\x3a\x19\xca\x49\x98\x6f\xbf\x6c\x54\x9f\x59\x01\x9e\x3f\x70\x60\xc1\xe2\x79\x6b\xf7\x8b\xa6\x55\xd9\x33\x86\x84\xda\xe6\xf6\x52\x57\x09\xaf\x45\xe6\x3d\xba\xe5\xc0\x63\xdc\xd8\xba\x5d\x47\x73\xd8\x1d\x09\x98\xbf\xbd\x34\xdf\x25\x4e\x0e\x7d\xa2\x87\x35\x94\x44\x41\x90\x10\x91\x2d\x9b\x65\xbc\x54\xc6\xc3\x64\xdc\x59\xee\x27\x73\x01\x19\x33\xf3\xf9\x59\x19\x1f\x97\x3f\x90\xb9\x6d\xf4\xdb\xf5\x32\x37\x4c\x7b\x4e\xcb\xf0\xb7\xc7\xff\xa2\xdf\xd0\x52\xba\xcf\x69\x69\xac\x41\x1a\x4c\x21\x61\x1f\x2d\x8f\xb5\xe7\x46\xd9\x27\xf7\x90\x07\xcb\xab\xe4\xcd\xb2\x58\x1a\xff\xeb\x6d\xf9\x73\x59\x2c\x97\xf1\x7f\x69\xb1\x51\x8f\x9a\x7e\xc9\x55\xc8\x38\x5f\xc6\xcc\x2a\x2f\x19\x05\x59\xe2\xb5\x6c\x15\x78\x68\x5c\x80\x4e\x14\x8d\x87\x26\x7e\x6e\xb4\x31\x1a\xe3\x05\x68\x59\xe9\x38\x88\x11\xcb\x11\x4b\xf6\x9e\xde\xb7\x53\x9d\x73\x18\x97\x62\x43\xeb\x3d\x45\xa4\xe7\xf3\x6a\xbb\xcf\xf9\xb6\x75\xc3\xf0\x60\x5c\xb1\xe2\x8e\xdb\x62\x7c\x62\x1c\xe0\x65\x11\xe8\xb3\xa9\xbe\xdc\x0c\xbb\x44\xf7\x04\xf2\x18\x15\x25\x03\x65\x14\x97\x10\xb7\xc7\xed\xa9\x08\xdb\x25\x8b\x8f\x32\x8c\x4c\x60\x18\x33\x81\xd8\x2a\xf0\x3e\x0b\xe1\x0c\xe4\x23\xd9\xc8\x0d\x5c\xd1\xed\xb6\x64\x2b\x46\x33\x4d\x30\x62\x89\xa5\x2d\x08\x7a\xf2\xb5\xbc\x17\x94\x85\xe4\x56\xe5\x32\x4e\x9f\x28\x47\xc5\x77\x53\x21\xf3\x19\x89\x71\xc3\xd2\x62\x89\x7a\x71\x32\xaf\x5e\xec\x8e\xbf\x37\xe5\x31\x03\x7e\xf9\x62\xe3\xf3\xeb\x16\xa9\xdd\xb9\x39\xa7\x5f\xbd\x75\xed\xdd\x3f\xfe\x41\x19\xcd\xd4\xa1\x1d\x18\xa3\x69\x39\x70\x31\x63\x34\x78\xf8\xbe\xdf\xd3\x38\xe3\x7d\x53\x6e\x5f\xed\xd3\xe9\x96\xcc\xf7\xd4\x8c\xbf\x69\x50\x91\x69\x89\xff\xf0\xfd\x7f\xcb\x76\x62\xfa\x40\x0a\xdf\x13\x74\xfe\x3e\x6c\x8f\xf4\x8a\x5e\x12\x68\x1e\x64\x3f\xea\x1e\x6a\xae\x37\x18\xac\x82\xc5\x4b\x52\x5c\x2e\x42\x53\x39\xc8\x69\xf9\x69\x9c\x9e\x78\x04\x8b\xd3\x42\x13\x07\x18\x9c\x28\xb9\x21\x78\x75\x83\x0d\x33\x41\xd6\xd2\x7c\x36\x68\xa0\xd6\x34\x27\x5d\xaf\x12\x5b\x07\xdc\x4c\xa4\x4e\xcd\xc1\x34\x2d\x5c\x75\xa9\x53\xe4\x47\x4f\x1b\xad\xde\x51\xd4\xea\xe5\xa2\xb6\x37\x6c\x4b\xf2\x8c\x2f\xe2\x33\x2f\xe4\x14\x0d\xb8\xd5\x31\x65\x39\xf7\x41\xd7\xf3\x6a\xee\xfe\x77\xf0\xe9\xb7\x2a\x5c\xf2\x2a\x93\x75\x49\xa4\xef\x2d\x37\xe9\x16\x39\x40\x06\x5b\x0a\x32\x6f\x3b\xbe\x17\xc8\x86\xa9\xa8\x4f\xc8\x62\x47\x5e\x83\xc1\x88\x8c\x01\xff\x99\x00\x0e\xd0\xbd\x9c\x0a\xfc\x67\x61\x00\xa3\x40\x20\x00\xdb\x5b\x94\x09\xcd\x73\x26\x2b\x06\x1f\x49\x6e\x2a\xf7\x32\xd3\x6b\x22\x03\x62\xf8\xd5\xb0\xa7\x8b\xa8\x38\x6f\xa3\xd7\x80\x02\x5e\x4d\xde\xe5\xdb\xfd\xf6\xea\x1d\xdb\x42\x3c\x5f\xfb\xeb\x87\x6b\xce\x2d\x78\xe5\x99\x75\xea\x5f\xa5\x4f\x0d\x5c\x78\x0f\xc7\xff\xa4\x7e\xd4\xb9\x47\xfb\x72\x9a\x1e\xff\x0f\xec\xbc\x57\xfd\xed\x89\x77\x7f\x54\x67\xaa\xaf\xdd\xd4\xf3\x83\xb8\xbc\xb2\x85\xe5\xa4\xbf\x3d\x64\x0d\x58\x0d\xbc\xc7\xe0\xc9\x48\xaf\xce\xc0\xbb\x33\x30\xc9\x60\xa7\x85\xd0\x71\xc9\xe1\xa1\x98\x27\x7b\xfc\x1e\x0e\xf1\x0a\xcf\x59\x45\x9e\xa2\xa5\x15\x1e\x3a\x78\x0f\x31\xa7\xa5\xa4\x80\x4c\x96\xa2\x98\x41\x72\xa1\x53\x4f\xcd\x63\x5a\xbc\x28\x6a\x4c\xa9\xaa\x1f\x0b\xbb\x6e\xcf\x44\x2d\x3f\x76\xd5\xa3\x56\x16\x0b\x85\x42\x7d\x46\xa9\x27\x04\xd7\xa5\xcf\xb2\x41\x8b\x5e\xbb\xe3\x43\x86\x53\x23\x1f\xdf\xfb\xe4\xad\xbd\x16\xed\x99\x34\x6a\x63\xa7\xe9\xd5\xe4\x95\x39\x7f\xce\x5e\xb4\xa4\x3c\xbd\xcb\x13\x31\x04\x2a\xb8\x21\xaf\x60\xca\x9e\x15\x93\xfe\x7a\x6e\x68\x49\xe7\x99\x23\xe3\xf2\xf0\xbb\x2c\x87\xbd\x0f\xe5\x87\xdc\x6e\xd1\x6a\x04\x51\x20\x39\xc5\xec\xd0\x3b\x40\x83\x92\x13\x35\x8d\xc6\xc2\x15\x9d\xe8\x98\x39\xb8\x05\xbd\x27\xe3\x4c\xc5\x92\x92\x4d\x45\x14\x60\xfc\x25\x7c\x81\x7a\xf5\xfc\xe5\x28\xc2\x79\xd8\xc5\x95\x3d\xb1\xbe\xf7\xcd\x87\xe7\x85\x0f\xbd\x87\x73\x1e\x78\x18\x5f\xfc\x45\xfd\x15\x7b\xb1\x84\xf5\x38\x73\x89\xc8\xcf\xfe\x6a\x0e\x8a\x9e\x39\x7b\x42\x1d\xf1\x8a\xc6\xe3\x53\x40\xde\xf5\xb0\x5c\x78\xb7\x84\x3c\x8a\x9e\x18\x8d\x4e\xa7\xdb\x53\xee\xc1\xc7\x3c\x78\xad\x07\x23\x0f\x68\x7a\x1e\x3a\xdd\x56\x8b\xb5\xab\x0d\x30\xda\xe6\x32\xb8\x24\x40\x11\xa9\x3e\x99\x5c\xfd\xd1\x27\x73\x05\xa6\xf8\x4c\x27\x33\x8e\xbf\x69\x31\xfc\x65\x81\x88\xb1\x57\xc3\x5d\xae\xb3\x7a\x86\x22\xef\x0d\xd3\x46\x93\x83\x8d\x50\x96\x62\x33\x8a\xe5\x96\x54\xa1\x5f\x4e\x74\x63\xc8\x26\x23\xbd\x88\x40\xf7\x3c\xeb\xc6\x3f\xbb\xf1\x30\x37\x76\xb3\x1e\x01\x17\x92\xdd\xd0\x3f\x5b\x93\x84\x93\x9a\x9c\x94\x68\x77\x6d\x94\x75\x92\xaa\x61\x5a\xda\x49\xf5\xc2\x77\x5f\x9f\xd8\x7f\xe7\xf2\xfb\xe7\x77\xc9\xd3\xd2\x4e\x7e\xae\x7e\xf4\xc1\x37\x5a\xda\xc9\xd3\xbf\xd4\xe0\x56\xfd\x59\xda\x49\x58\xbb\xfe\x34\x07\x0d\xdf\x07\x64\xcd\x66\x68\x40\xa8\x95\x59\x51\xf4\xc0\xaa\xec\x42\x12\x42\xc0\xa5\xd3\x81\x36\xe2\x14\x62\x02\x6a\x67\x32\xb9\xdd\x29\x34\x0b\x7d\xc0\x2e\xda\xa1\x53\xa2\x8b\xe6\x93\x2d\xaf\x8f\xd2\xcf\xd2\xb5\x34\xe1\xdf\xf5\x9d\xa4\xf2\x43\x16\x07\x1b\x89\x2a\x05\x34\x65\x27\xd3\x20\xd9\x96\x6a\xe6\xc5\x1d\x31\xff\x59\xe4\xdf\x3b\x7f\xfd\xe3\xeb\x7f\x38\xe7\xd5\xdc\xff\xc0\x43\x0f\xef\x38\x7a\xb8\xb2\x62\xdd\x63\x1b\xb8\x62\xf5\xb2\xfa\xb1\x45\x1d\x8b\x1f\x30\xc2\xce\x33\x7c\x87\x73\x02\x2b\x7d\x9f\x1d\xfa\xf0\x84\x8e\xeb\xfc\xca\x07\xea\x17\x7f\xbc\xf2\xbe\xfa\x5b\xe4\x05\xe9\x33\x3a\xb7\x4e\x10\x5a\x7d\x7c\x05\xcc\xed\xe4\x90\xd7\x6a\xb3\x39\xed\x0a\x22\xbc\xc3\x80\x39\x07\xe7\x76\x65\x00\xf9\x76\x63\xbd\x72\x28\x7a\x26\xd4\x1c\x16\xdd\xa5\x60\x41\xc1\x26\x1f\xc2\x66\x04\x5d\x44\x01\x93\xdc\x15\xd9\x89\xc2\x63\xab\x6c\x92\x68\x3e\x14\x27\xf6\xb1\x14\xd7\x48\x33\x3f\x53\x64\xa0\x5b\x0c\x0f\x8d\xef\x2f\x16\xa8\x89\x99\xa1\x33\xa9\xcf\x4b\x43\x34\x6a\x37\xb3\xcf\xa4\x73\xa9\xea\xbe\x97\xf1\xa1\x9d\xdd\x6e\xcc\xf2\xb9\x9b\x15\x77\x1a\x30\xbe\x62\x0d\xd6\xbd\xa4\xae\xc3\x1b\x8f\xfc\x1c\x19\x4b\xca\x70\xe5\xbd\xdd\x0d\x4b\x1c\x23\x9f\x54\x3f\xe5\x7c\x91\x9b\xeb\x3e\x66\xb8\xbb\x42\xad\x14\xf2\x84\xf6\xc8\x8d\x86\x85\xda\x02\x92\x18\x0c\x4e\x23\x11\x45\xa3\x4c\x3c\xde\x02\xef\x30\xef\x3a\x2f\xf1\xb3\x08\x65\xbb\x68\x7c\xb0\x02\x6f\xc8\x3b\xd9\xcb\x5b\x88\xcb\xc5\x2b\x20\xc5\x9a\x40\x6e\xd1\x9b\x5c\x86\x84\xd5\x09\x06\xf3\xb1\x86\xca\x4d\xed\xab\x99\x1d\x35\x19\x52\x14\x60\x85\x32\x62\x98\xe4\xb6\x06\x49\xab\x83\xf7\x1e\xf8\x45\xfd\x6d\xa7\xfa\xc7\xaf\xfb\xd7\x1d\xda\x39\x93\x5b\xfd\x3c\xb7\x3c\x32\xef\x97\x8f\x39\x75\x3c\xde\xc0\x7d\xf4\x2b\xb7\x34\x32\x67\xe7\xbd\x1c\xff\x0f\x6d\xbf\xf5\x05\xde\x71\x11\xe8\x71\x0e\x9a\x13\x4a\xf6\xeb\x9b\x89\xcd\x7c\x0e\x84\x9a\x8b\x16\x4b\x73\x1f\xc9\xcd\x43\x79\xb8\x20\x0f\x5f\xce\xc3\x79\xf1\xdc\x69\xbb\xf2\xbe\xce\xe3\x50\x5e\x20\x2f\x94\x47\xf4\xc4\xd9\xa2\x85\xc7\x40\x32\x3d\x99\x15\x61\xab\xc7\xe5\xd7\x1b\xf4\x15\xe1\x54\x03\xcb\x97\x1d\x73\xe3\x8a\xe7\x45\x88\x53\x6b\x9a\xe2\x4a\x1b\x8a\x16\xf0\x99\xf9\xd2\xc5\x5d\x19\xb3\x4b\x41\x8f\xd6\xfc\x6b\x62\x69\x69\xea\x51\x2f\x48\x33\x4e\x05\xc9\xb4\xa9\xa3\xa7\x4e\x59\x3a\xc7\xbd\xf8\xf0\xa8\xd3\x47\x16\x6c\x6d\xc6\x37\xdb\xba\xe0\xc8\xe9\x7f\xbd\xea\x9e\xb9\x62\xd2\xd4\xd1\x33\x9e\xc4\xaf\x6c\x7d\xee\xc5\xd3\x2f\xfc\x9c\xbc\xca\xf9\x68\xe4\x81\x28\x52\xbf\x5b\x74\xf7\xdd\x8b\x80\xe2\xa0\x0b\x38\x14\x58\x95\x74\xf1\xe8\x3b\x2f\x3d\xb7\xb5\x8e\xf9\x11\x9c\x82\x09\xb8\x22\xcc\x8d\xdb\xb1\xd0\xb8\x6d\x08\xa5\x84\xf4\xda\x79\x25\x87\x2d\x87\xa2\x9f\xd6\x5a\x4c\xb1\xe3\xca\xb8\x29\x36\x6e\xcb\x62\xf5\x98\x2d\x0b\x8d\x43\xbf\xa2\x58\x4d\x6a\xca\xe2\xa8\x22\xf5\x7b\x6d\x92\x27\x66\xc9\xd2\x6a\xc6\xf9\x36\xb5\x9b\x51\xbe\xcd\xec\x6c\x2d\x62\x76\x3c\x37\xd4\x72\x77\x71\x27\x69\x35\x1a\xdb\xcc\xa4\x7a\x9b\x59\x19\xaa\x8b\xd9\xe5\xa0\x15\xf8\x75\x79\x1b\x97\x67\x6b\xc9\xca\xcf\x8d\xc1\x8f\xc6\xca\xe7\x42\xf9\xdc\xd2\xdc\x56\x3e\x4b\x7d\x79\xd0\x07\xa7\x41\x7f\xd2\x59\x3e\xea\x6c\xd4\x1a\x0d\x0d\x15\x25\x73\x1c\x6a\xa5\x34\x77\xbb\x9b\xe9\x15\x7d\x61\x50\x84\x55\x2d\x48\x02\x9a\x11\x10\xb1\x5c\xe0\x2f\x00\x31\x42\x2c\x10\x0b\x4c\x76\x7b\x2e\x48\x5c\xc8\xe4\xef\x4d\x13\x80\x34\xce\xcc\x46\x17\xb9\x2c\x37\x21\x8a\x35\x3d\xec\xd2\x02\x10\x3a\xdd\xf1\xd0\xbc\xb0\xbe\x9a\xb1\x2d\x16\xb2\x8c\x24\xb8\xb2\xc6\x7c\xad\xe0\x01\x6e\x97\x25\xe4\x1c\x1e\xf1\xd1\x0f\x17\x3f\x7a\xf2\xcb\x09\x7f\x5e\x19\xfa\x60\x78\xcf\xda\xc7\x67\xaf\x5a\xb4\x68\xd5\xdd\x35\x8b\xef\xc1\xfb\x87\xf4\xec\xb9\xa8\xc5\xb4\xb5\xdb\xf8\x9c\x25\x1b\xa6\xf7\xa8\xfa\xfa\xe4\xa9\x7f\x6d\xc4\xed\x71\x06\x9e\x8b\x27\x75\x98\xde\x7b\xea\xb2\xc8\xeb\xf7\x3e\xb4\x79\xdd\x7d\x1b\x37\x71\x4f\x96\x74\xe8\xda\xb5\x17\xd0\x4d\x3d\x8c\x99\xc6\x84\xcc\x45\x41\x54\x15\x2a\xcc\xcb\xc9\x09\x60\xa7\xb1\x75\x86\x57\x52\xa4\x0c\x23\x16\x8a\x8b\x6c\x40\x34\x71\x20\x2f\x50\x11\xce\xc9\xf3\xda\xf2\x6c\x79\x42\x76\x76\x7e\xef\x70\x36\x12\x40\x00\x11\x9a\x8e\xb7\x4c\xb3\x3b\x34\xc9\x6d\xa1\x85\xca\x74\x70\x62\x7a\xc0\x5a\x54\x4a\x93\xd5\xc7\xc3\xdd\xd7\x67\x43\xb6\x15\x67\x65\x68\x5e\x8d\x36\x7b\x90\x11\x54\x78\xce\x57\xdc\xb6\xec\x87\x8d\xea\xbb\x1e\x4f\xdb\xd6\xc3\x3c\xe3\x7a\x55\x8d\xf1\x78\xfb\x74\xb9\xfd\xe1\xa1\x6f\xa8\xff\xbc\xfb\xe4\xce\xe3\x67\xf8\xdb\xa2\x4b\x67\xbc\xf3\x23\xf7\xd7\x57\xea\xbd\xc7\xb0\xa9\x75\x55\x55\x7a\xfb\xd6\xab\x4b\x46\x0c\x2c\xac\xaa\x2a\xbc\xa1\xdb\x56\xdc\x6e\x0f\xb9\xed\xd9\x19\x9b\x6a\xd5\x4f\xd4\xb3\xf8\x84\x7a\x62\xee\x12\x6d\x9f\x97\x21\x24\xea\x85\xd5\xc8\x81\x5a\x85\xdc\x8a\x6c\x32\x13\xb3\x4c\x9c\x2e\x83\x15\xde\xcc\x36\x24\x35\x1c\x96\x50\x8d\xa9\x51\x06\xdf\x78\xc2\x0a\x09\xd3\x14\x6b\x40\x1f\x3b\x62\xc1\xdc\x7e\x59\xbb\x7e\x49\x43\x33\x33\x5a\x07\xd4\xa9\x47\x22\xff\xfa\x08\x3f\x8b\xfb\x95\xce\x12\x56\xb7\x0c\xae\xf4\xb4\x4c\x29\x88\x3c\x53\x6f\xc7\xb6\x0c\xb8\x19\x70\x33\x19\x21\x69\x99\x70\x52\xc9\x26\x4b\xf0\x3c\x86\x9d\x85\x51\x6a\x35\x91\xf6\x62\x0f\x89\xf9\xce\xb0\x3e\xd2\x73\x11\xb2\x84\x96\xd0\x63\x3c\x3b\xbe\xaf\x92\x93\x05\x6d\x5f\x6d\x81\x7d\x25\x93\xc4\x1d\x49\x50\x05\xf0\xc2\x5c\x58\x53\x19\xa4\x86\x14\x90\x2a\x5b\x2a\x26\x87\x5e\x96\x61\x37\xb9\x79\x1e\x99\x88\x3f\xd5\xe2\xa0\x19\x1d\xf5\x76\x2a\xd5\x48\x48\xf4\x55\x84\x45\x19\x27\xb1\x84\x6f\x3e\xd4\x90\xa1\xa4\x49\x9a\x92\x06\x33\x12\xcb\x37\x9a\x09\xcf\x5c\x36\xab\x22\x58\xed\x40\xa9\xac\x1d\x71\x26\x25\xb9\xa0\xd8\x7e\x7b\xe2\x14\xde\xb8\xfd\x83\x53\x6a\xf5\x85\xc9\x73\xe6\x4c\x8e\xdc\x3f\x7e\xfa\x9d\xe3\xd4\x4a\xfc\xa4\x17\xdb\xff\xc0\x17\x8a\xf0\x3a\x75\x8a\x43\xfd\x8f\x1a\x51\xcd\xad\xd4\x41\xe4\x8d\xc3\xaf\x3b\xeb\xde\xf1\xbc\x7d\x70\xd7\x5b\x7e\x92\x9b\xc2\xee\x50\xa2\x3e\xb0\x77\x7f\x04\xf9\xc2\x8d\x5a\xa2\xc1\xa1\x7c\xe2\xf3\x71\x62\xae\xa9\xb9\xab\x59\x33\xb7\xdd\xde\x5c\x24\xf9\xc0\xe2\x91\x02\x1b\x52\x71\xb5\x68\x41\x3c\x7a\xd0\x79\xf4\x2e\xe2\x77\x23\x77\x43\x1e\xdd\x60\xbd\x69\xa6\x3c\x31\xd3\x55\x1c\x25\x83\xb1\x64\xba\xe9\xb0\xeb\x1a\xd3\xd8\x92\xd2\x74\xac\xd1\xdf\xb4\x38\xad\xd5\x38\x4a\x1f\x61\xf3\x84\x82\xb2\x04\x42\x5b\x12\x1c\x4b\xae\x4c\x9f\xde\xb1\xa0\x6e\x57\xeb\xf6\xd3\xa7\x03\xc1\x9d\xc1\xb7\x5d\x55\xf5\xfd\xa8\x44\x4a\x3b\xee\xab\xe1\x75\x6f\x1e\x3b\x31\xe3\x72\xb7\x1e\xbf\x4c\x7b\xeb\xe8\x73\x5b\xf1\x30\x75\xdb\xd6\xe7\x18\x1e\xd2\x3c\xc1\x8f\xf0\x1d\x61\x94\x3d\x43\xb9\x9c\xde\x82\xf9\x1c\xbb\x3b\x2b\x39\xd9\x9d\xc6\xeb\x85\x56\xf9\xd9\x20\x72\x66\xbb\x52\xd3\xfb\x86\x53\x7d\x36\xc4\xd9\x65\xa3\xd8\x37\x6c\x94\x39\x67\x7d\x92\x80\xb2\xa6\x8b\x14\x1b\x98\x1e\xa7\xd9\xac\x09\xfb\x8c\x93\xdc\x38\x4d\xe4\x9c\x34\x3e\x81\x55\x89\x87\xf1\xef\x80\xa9\x12\x67\x2b\x25\xd3\x23\x9f\xaa\xff\xfe\x69\x66\x4a\x9b\x66\x37\xf4\x98\x37\xa7\x24\x43\xe0\x02\xd8\x3c\x69\xf6\xcc\x9c\xc2\xcb\xa1\x1b\x73\x8b\x4b\xdb\x8c\xb8\xad\xb8\x19\xf1\xd7\xfd\x13\x57\xe0\xb1\xdf\x59\x36\xd9\x1f\xdc\x7f\xa7\xfa\x53\x37\x8e\xf8\x36\xaa\xf7\x1c\xfd\xce\xac\x7e\xaf\x7e\x62\x7a\xd4\xdc\xb9\xf7\x48\xcb\x86\x27\xef\xc1\xae\x1b\x60\x0d\x6f\x03\xfe\x4f\xfd\x31\x64\x40\xaa\xc2\x50\x92\x62\x04\x84\x04\x04\x34\x92\x94\x64\xc9\x5e\x1d\x96\x78\xec\xad\x0e\x5b\xb0\x1d\x81\xf0\x1f\x6c\x9a\x11\x87\x62\x59\x06\x15\xa8\xa9\xb3\x85\x53\x41\x82\x15\x27\x78\x5c\x70\x47\xd5\x73\xea\x91\xb8\xa7\x85\x7a\x44\xfd\x01\x6f\x4c\x74\xb7\x00\x6c\x7b\x28\x09\xd7\x00\xf5\x8b\xf9\x59\xa8\x6f\xa9\x0b\x53\xd5\x51\xfc\xe4\xc6\x0e\x17\x28\x9e\xbf\x10\xf4\x47\x7a\x4b\x03\x05\x43\x3e\x07\x6f\x46\x16\x3d\xb5\x59\x24\xf9\x44\x2b\x6c\x0d\x05\xbb\x81\xb2\x63\x17\xd2\x44\x91\xeb\x74\x34\x4b\xb3\xf0\x59\xa9\x84\xd8\x28\x39\xe1\x17\x2f\x9e\xc4\xe7\xff\x73\xe1\xe4\x2b\x67\x96\x6d\x7d\x78\xf5\xaa\x0d\x8f\xad\x82\x9e\x6d\xf6\x62\x1b\xc6\x5c\x81\xfa\xb3\xfa\x4f\xc0\x93\x4b\x1e\x75\x14\x79\xe3\xec\xdb\xa7\xbf\xf8\xe8\xe3\x33\x14\x27\xa6\x82\xcc\x5a\x01\xf3\xe6\xa5\x39\x81\xcd\x26\x2f\x72\x08\x02\x6c\x5b\x5f\x92\x1b\x57\x87\xdd\x66\xb7\x19\xe9\xf5\x4a\x75\x58\xcf\xbc\x18\x1a\x48\xef\x35\x39\x81\x29\x3d\xb5\x65\x04\x0b\x79\x8d\x60\x51\x54\xe6\x83\xa5\x56\xee\xa9\x9d\x6a\x74\xd5\x13\x38\xf3\xc8\xe7\x38\x7d\xe0\xee\xe0\xd7\xf7\xaf\x3e\x33\x09\x1b\x2f\x77\xc0\x29\xa6\x0d\x57\x1f\xda\x8a\xcd\x9b\x9e\x3e\x78\xe3\x82\xbb\x26\xbd\x32\xe3\xc4\xc7\x44\xed\xc6\xf0\x74\x10\x28\x82\xef\xc0\x1c\xe5\xa1\x76\xa1\x14\x0b\x0a\x64\x39\x9d\xba\x80\xae\x55\xcb\x6c\xe4\x4c\x37\xa6\xe7\x54\x84\xd3\x7d\x46\x1b\x28\xa6\x46\x05\xd5\x4f\x11\xa2\xac\xae\xe1\x10\x86\x2a\xd1\xb1\xf0\x95\x8d\x53\x3b\xa5\x12\xcd\x5e\x40\xb7\x60\xb1\xe6\x46\x7c\xb9\x79\xc5\xed\x4f\x1f\x1a\xf0\xe3\xb7\x3b\xbe\x4c\x79\xc1\x32\x63\xec\xbd\x4b\x3d\x79\x9d\x87\x2c\x2c\x9b\x58\x59\xfc\xfe\x27\x55\x8f\x17\xde\xb1\xa2\xf3\x8c\x19\x33\x5b\x94\x64\x3a\x52\x6b\x3e\x78\x00\x9b\xb1\x9b\x25\x71\x3a\xfc\x55\x8f\xf1\xb7\x04\x33\x53\xcc\xa9\xed\x47\xf4\x79\xe8\xb1\x14\xf7\x53\xb9\x29\xdd\xe3\x3e\x22\xfc\xbd\xc2\x22\x64\x84\x39\x4d\xc1\x92\xa4\x33\xf2\x44\x07\x0a\x01\x16\xab\xc3\x3c\xe6\x31\x4d\xb3\x09\x53\x4a\x74\xd7\x4c\x69\x42\x62\x61\x9a\x7e\x94\x26\x51\x4d\xa7\xd9\x7f\x6e\xe7\x5e\xde\x1f\xf9\xeb\x28\xf9\x81\x3f\xaf\xde\xa4\xde\xfb\x6e\x64\xba\xb0\x68\x0b\x6b\x6b\xa5\x3a\x90\xbb\xc8\x6c\x96\x65\xa1\x64\x01\xf1\x9c\x4e\xa7\xe7\xf5\x66\x13\x07\xd2\xb8\xc0\x09\x9c\xde\x60\xc0\x34\xf5\xa8\x1e\xe5\x5f\xdb\x54\x5c\xdb\x65\xae\x28\xc5\x34\xe1\x53\x1a\x77\x51\xbd\x05\x2f\x7e\xf8\xdc\x2e\x6e\x04\xd9\xa5\x7e\xad\xee\x7d\xa1\xae\x5a\x88\xe5\x6c\xc6\xd1\x1f\xf9\x3f\x85\x53\x20\xaf\x76\x0f\x65\x66\xb9\xbc\x16\x04\x52\xa8\x37\xc0\xe7\xe6\x59\x73\x5a\x38\x73\xe0\x9f\xd1\xdf\xac\x59\x4a\x75\xb8\x99\xce\x68\x84\xb1\x1a\xed\x71\xdf\x6e\xa6\x6e\x6b\xd9\x63\x83\x89\x41\xad\x99\x6c\xc2\x69\x81\x34\xb4\xec\x33\x40\x1f\x44\x09\x54\x6e\xea\x08\x50\xaf\x1b\x50\x51\x85\x5a\x05\x87\x67\x96\x97\xb7\xf3\xb7\xcb\x08\xf5\x5b\xbc\xc2\xef\x5c\x76\xf9\xdc\xba\x94\x40\xc8\xd1\x32\x3b\xd0\x16\x1e\x0d\x1a\x5f\x98\x6a\xe3\xbe\xe3\x7b\xae\x57\x3b\xac\x1f\x39\x51\xde\xe6\x78\x6c\xcf\x9d\xd8\x3e\x6a\xe8\x96\x0d\xa3\x8d\xf3\xf1\x85\xe7\xfa\xf7\x6a\x09\x0f\xbb\xdd\x5d\x33\x53\x7d\xab\x12\x7f\xaf\x8d\xa9\x10\xd6\xca\x00\x6b\xa5\x07\xaa\xe1\x91\x44\x51\xc7\x73\x18\x13\xe0\xc7\x06\xa3\x8e\xaf\x08\xeb\x74\x9c\x48\x09\x60\x7e\x2c\xe3\x40\xe3\x9c\x43\xa0\xae\xd8\xd3\x8a\x41\x32\x4e\xe3\x0d\xea\xa5\x57\xbf\x8f\xb8\xb0\xe3\xd5\xef\xb9\x0b\x5c\x5d\x84\xe7\xee\x69\xcd\x1d\x8f\x3c\x4b\xdb\x68\xa5\x86\x85\x03\xc0\x23\x53\xd1\x4d\xa1\x66\x56\x93\x24\x21\x8f\xc2\x1b\x91\x10\xf0\x1b\xf4\x3a\x93\x6c\xb1\x9a\xac\xc4\xe7\x76\xfb\x7c\x8e\x61\x61\x1f\x4f\xef\xb9\xd4\x27\x5a\x88\x1f\xa8\x24\x24\x85\xa2\xca\x21\x12\xb2\x81\x5e\x15\x67\xe3\x6c\x9c\x45\x5f\xe8\x4c\xf1\x30\x55\x74\x03\xda\x84\x03\xea\x6c\xb5\x57\x2b\x20\x9e\x23\x70\xe4\xc0\x0d\xdc\x7c\x4f\x9b\xc8\xb2\x1b\xb8\x29\x83\x7e\xbf\x6f\x95\xaa\x0e\x1a\xbe\x08\xe7\xbc\xf6\x15\x1e\xf3\x01\xa7\x53\x17\xaa\x6d\xc7\x3c\xd0\x11\xdf\x8f\x6f\xb0\x59\xd5\x6f\x96\xe2\x92\xbb\xef\x54\xdf\x5e\x8a\x0b\xe6\x2e\x58\x3e\x6b\xfa\x03\xcb\xea\x54\x16\x87\x71\x84\x3a\x80\x1f\x2b\x7c\x00\xf2\x4b\xeb\x90\x47\x36\x08\x08\xe9\x2d\x56\xde\xe9\x32\x9b\x64\x9d\x64\x90\x41\xe9\x46\x34\x1b\x7b\x79\x82\x73\x47\x2c\xf9\x1e\x28\x4b\x0e\x22\xc1\x52\x66\x0b\xd9\x99\x59\xf4\x85\xcb\x2c\xe5\x11\x3f\xb6\xd5\xab\xa5\x79\xea\x96\x2e\x78\x41\xcb\x9b\xd5\xa5\x37\xe3\xc9\xef\xa9\xdb\x9f\xc5\x5b\xf0\x91\x71\x5f\xa8\x6a\x09\xf6\x5d\x78\xe7\xbe\xe7\xd6\xbe\x34\x73\xca\x0b\xeb\xf6\x63\xdd\x33\xfd\x8f\x47\x82\xb4\x1f\x4f\xaa\x03\xc5\xf9\xb0\x56\xb9\xa8\x77\x28\x27\x23\x2d\x19\xe7\x48\x0e\x87\xc1\x90\x23\xa7\xf1\x79\x2d\x9d\x29\xfe\x5c\x1d\x70\x8d\xec\x61\x61\xbf\x5d\x56\x86\x85\x65\xd0\xf1\xf8\x61\x61\xaf\x3d\x31\xdf\x0c\xb3\x09\x04\x6d\x8d\xe2\xde\x06\x1b\x52\xcf\xc4\xfd\x64\xd2\xd3\x8a\xd3\x58\x96\xdd\x98\x99\x9a\xc5\xd8\xa9\x37\x53\x93\xdf\xab\xa6\x4d\x5f\x79\x78\xd8\xfb\xbb\xea\xec\xe4\xdb\x47\x37\xf1\x39\xeb\xe7\xcc\x7d\x34\x93\x0c\xfd\x51\x7d\xfc\xf0\xe0\xe9\x33\xd7\x08\x8b\xea\xcc\x9b\xe6\xed\x7d\x98\x1c\xba\xf2\xe5\xf1\xcf\x6f\xbf\xff\xf1\xda\xf0\xc0\xca\x01\x23\x5e\xc0\xf3\x79\x4f\x9d\xf9\x81\x05\xf4\x1b\x18\xcf\x52\x18\x4f\x0a\xec\xdd\x96\xa8\x57\xa8\x45\x56\x7a\x32\xce\x93\x9c\x4e\x83\x21\x2f\x5d\xe6\x5b\xe5\xa7\xb8\x02\x2d\x75\x19\xb2\xac\x00\xa1\x0b\x04\x5a\x54\x84\x03\x2e\x2f\x9f\x90\x58\x3a\x9e\x69\xf3\xff\x3c\x9a\xf2\xfa\xd1\xc4\x32\x41\x35\x8c\xe7\x99\x01\x93\xa7\x2d\xdf\x77\xdb\xfb\xcf\xd7\x75\x23\xc7\x1e\xda\xc8\xf3\x7c\x9b\x87\x27\xcf\x5d\x9b\x4c\xda\x3c\x32\x65\xfb\x86\xbd\x03\x26\xcf\x58\xc2\xb7\x8d\xf4\xd9\x3a\x6b\xf7\x36\x6e\x5a\x5d\xe1\xeb\xff\x9a\xb0\xea\x91\x9d\xab\x27\x0e\x1b\x3e\x7e\xe2\xb0\xbd\x6f\x73\xef\xd2\xaf\x76\x3d\xca\x4d\xa3\xb1\x8b\x61\x3f\x1d\x05\x7e\xe2\x43\xa5\xa1\x64\xa3\x2c\xfb\x2c\x82\xd3\xe2\x4c\x49\xf6\x70\xd5\x61\x0f\xaf\xb3\x55\xc3\x96\x32\xc9\x36\x13\xd1\x62\xde\xc6\x19\x9c\xe6\x9a\xa7\x29\x2b\x0d\x2c\x4d\xcb\x2c\x2c\xb2\xa3\x5d\x66\x22\xe0\x9e\xeb\xda\x7f\xe6\xcc\xe7\x1e\x1b\xfa\x43\xb7\x23\x47\xbe\x3c\xf0\xa7\x7a\xe9\xd3\x77\xfb\xcd\x0a\xf2\x6f\x16\x3d\xb5\x6d\x7b\x6d\x49\x06\x77\xf2\xca\x02\xce\xd9\x17\xf3\xdf\xff\x74\x25\x3b\x8b\xe2\xcc\x1a\x76\xb6\xf2\x09\xc8\xc0\x37\x85\xb2\x6c\x92\x17\xa1\xe4\x64\xb3\x44\x52\x52\x5d\x34\xe7\x70\x92\xec\xf2\xbb\x40\xb5\x72\xb9\x50\x12\x32\xc8\x7d\xc3\x06\x8c\x1a\xc4\x1d\x66\x9f\x2e\x6b\xca\xea\x62\xb3\x07\x3c\xd8\xad\xe5\x09\x6e\x48\xa2\x45\xca\x82\x4f\xcc\xdb\xbd\x03\x7b\x83\xfd\xdb\x76\xb8\x53\x4b\x9b\xc5\xb5\x18\x5c\xb1\xeb\x1d\xbc\x1f\x37\x57\x76\x38\xd7\xab\xf3\xb4\x6c\x59\x0b\xae\x14\x69\xf4\x67\xbb\x3a\x90\x8f\x0a\x8b\x91\x1f\xb5\x09\x25\xdb\x2c\x16\xbf\x2c\x79\x64\x4f\x20\xcd\x69\xa8\x0e\xdb\x9c\x4e\x59\x21\x7e\xe0\x15\x7e\x19\x58\xc5\xeb\xb1\x5e\x95\x25\x24\x89\xd6\xc4\xca\xc2\x8e\x24\x96\xa5\x90\x9d\xa6\x94\x96\x04\xa9\x4f\x95\x85\xa4\xa7\x6d\xc7\xad\x0e\x3d\xb3\x68\x50\xeb\x97\xf7\xf5\x3f\x5e\x79\xe4\x48\x97\x7b\xb7\x61\x0e\x67\x94\x8e\xdb\xf1\xeb\x9b\xea\x0e\xf5\xc7\x66\xb7\xae\x38\x73\xdf\xe7\x17\x0a\x72\x22\x15\xc2\xe2\xc8\xdb\x29\x6d\xd5\x57\xd4\x6f\x37\xff\xb2\xfb\xff\xc7\xd9\x9b\x00\x36\x55\x6c\xff\xe3\x33\x77\xee\x92\xfd\x2e\xc9\x4d\xd2\x36\x69\x93\xa6\xe9\x42\xa1\x5b\x68\xcb\xde\x00\xb2\x28\x5b\x2b\x0a\x46\x81\xd6\x0d\x51\x56\x91\x27\x8a\x0b\x20\xa0\x88\x28\xc8\xa2\xa0\xa8\xa8\x28\x8a\x28\xa8\x75\x03\xa5\xb8\xe1\x8a\xfb\xbe\x81\xdb\xd3\xa7\xb8\x3f\xf5\x3d\x68\xa6\xff\x99\xb9\x37\x69\xd2\x56\xbf\xef\xf7\x17\x4b\xdb\xd0\xf4\x9e\x73\x66\xe6\xcc\x59\x3f\xe7\xe2\x21\xd4\x56\xb1\x11\x1f\xf8\x6b\xfe\x06\xe2\xa1\xd6\x10\x7f\x2d\xd6\x5b\x97\xb8\x50\x35\x5f\x94\x2f\x58\x8b\xac\xb1\xbe\xba\x1e\xaa\x96\x38\x1e\x14\x56\x16\x36\x26\xfc\xe4\x3e\xae\xf4\x57\xfa\x81\xd3\x49\x3c\x35\xa7\x17\x94\x36\x26\x78\x40\xee\xe7\x9a\x2c\x8f\xad\x3c\x35\xa1\x31\x23\xa5\x5f\x43\x33\xfa\x35\xbe\x3a\x72\x01\x48\x5e\x36\xed\x95\x35\xe8\xeb\x11\x96\xfd\xf6\xc6\x88\x17\x57\x42\xce\x5f\x6d\xdf\x21\xd0\x57\x98\x42\x5d\x2a\x86\xff\xbd\x77\x5e\xdf\xc8\xa5\xa3\xa3\x67\xce\x7f\x69\xc5\xf0\xe6\xd1\xf5\x79\x83\x37\xcd\x3e\x69\xc2\xe4\x49\x13\xa0\xb5\xb0\xed\x00\xfe\xfd\x8c\x5d\xcb\xd9\x28\xc6\xdb\x37\x1e\xc7\x8f\x9f\x30\xfe\xf8\x29\x0b\x6a\xd6\x7e\xdb\x7a\x6c\x69\x7e\x24\x7f\xcc\xb9\x17\xd6\xd4\xc0\x5b\xae\x98\xfe\xdc\xd7\xa7\x5e\x3b\xd2\x18\xc1\xb8\x67\xb4\xb1\x1e\x73\x88\x2f\x60\x25\xfb\xb7\x06\x1c\x1f\x8f\x12\x0b\x50\xb3\xfb\x4b\xfb\xf4\xf1\x6b\x80\x8f\xf5\x2d\xb4\x57\xe9\xe5\xe5\x55\x55\xd1\xe6\x44\x95\x5b\x55\x75\xdd\xd5\x92\xd0\xf9\xf4\x1c\xe6\x0c\x9d\x9d\x0d\xaa\xed\xee\x3b\x04\xd5\xa7\x97\x88\x68\x69\x62\x66\x12\x46\x39\xc9\x1c\x07\x40\xac\xff\x92\x7a\xc2\x3a\x1f\x0e\x15\xcd\x29\x1f\x3f\x6b\xd9\x03\x13\xd6\xcc\x6a\xd8\xb9\xf5\xae\xd6\xe0\x93\x55\x64\xbd\xe0\x9f\xd0\x55\x7b\xe6\xfd\xf7\xb4\xdc\x3a\xbf\xe1\x85\xbd\xaf\xbd\x53\xbb\x73\x38\xb1\x42\x7f\xc0\xdf\xe3\xd7\xe1\x8a\x71\x17\x9c\x34\xb8\x4f\xa9\x56\x54\xd7\xd4\x30\xe7\xfc\xb3\xe7\x85\xef\xbf\xf1\xc0\xc3\xe3\x17\x9d\x36\x26\xea\x2d\xee\x37\x69\xc4\xa2\x25\xab\xae\x4e\xcc\xa8\x5b\xf4\x8f\xe7\xbf\x7f\x3f\xc5\x1f\xff\x02\xe1\xaf\x37\xad\x25\x55\x02\xba\xb7\x58\x20\x7e\x75\x80\xaf\xe8\xa3\x14\xe7\x70\xba\x9e\xc3\xa6\xd7\x83\xde\xbd\x39\x8e\xe8\x1c\xce\xfb\xf7\xdc\x11\xfd\x2e\x12\xa2\x6b\x53\x0c\x86\x0d\xfe\x62\xa1\x6c\xfe\xea\xf9\x67\x0e\xe3\xc3\xf8\x6b\xfc\x42\x9a\x3b\x7c\xff\x6d\xad\x81\x27\x2b\xa1\xf8\x5f\x62\x57\xd8\x52\xdc\x7d\xf4\xd4\x8a\x6f\xae\x2a\x6f\xf8\x78\x5f\x06\x57\x87\xce\x9d\x15\xde\x71\xd3\xb3\x8f\x76\x32\x75\xf1\xd2\x60\x29\xdd\x9f\x12\xd1\x35\xef\x11\x5e\x0a\x41\x14\x4c\x8a\x57\xd9\xa3\x05\x0a\x1f\x29\x2a\x72\x46\x5c\x7e\x97\x13\xf1\x25\xc5\x51\xbb\x52\xc0\x3b\xe9\xc5\xda\x4c\x2e\x56\xd9\x51\xe4\x2c\x6a\x4e\x18\x1e\x37\x4f\x5d\xee\x9a\x54\x74\xdd\x8c\xc6\xa6\xe6\x1e\x1a\x46\x0a\x1b\x8f\x42\x4d\xc7\x12\xb6\x6e\x88\x15\x0c\xb3\x80\xa5\x0c\x8d\x49\x47\x05\xb0\x7e\x08\x84\x61\x84\x76\x8e\xbd\x35\x3e\xbd\x70\xe4\xd0\xb2\x6a\xcf\xa5\x70\x60\xfb\x43\xb0\xee\x52\x77\x4d\xd9\xd0\x11\x91\xe9\xf1\x5b\xc7\x36\x2f\x28\x1d\x3e\x2c\xba\x00\x0f\x81\xef\xfd\x28\xdc\x70\xf6\xac\x39\xb1\xe9\xc5\x15\xf8\xbd\x64\xc1\xf5\xd7\x73\x9f\xc3\x5e\x15\xc5\xd3\x63\x73\x66\x9d\x3d\xf5\xfc\xfd\xfb\x67\x9f\x7e\xcc\xce\x8d\x66\x7e\x82\x97\xf0\x76\x3f\x3f\x94\x7c\x15\x21\xb7\x43\x1f\xa8\x70\xb2\x28\x3b\x41\x58\x53\x72\x2d\x45\x51\xa0\x39\xc3\xbc\x92\x13\x0c\x7a\x1b\x13\x41\x99\xa8\x24\x85\x18\x79\x8a\x8e\x6c\x8d\x09\x89\x0e\x69\x89\xfd\x0d\x63\x84\x29\x14\x73\xa7\xf8\x92\x90\x9b\xb0\xe5\xee\xca\x56\x1d\x77\xe6\xec\x4f\x0f\x8c\x5d\xdb\x6f\x46\x78\xd8\xa0\xb1\xd1\x8b\xef\x4d\x1e\xdb\xbe\x48\xef\x17\x19\x34\xb4\x70\x46\xbf\xb5\x63\xcf\xb8\xb8\xa8\x5f\xff\x13\xe0\x06\x9c\x44\xbb\x5b\xa6\xcc\x8d\x9d\x31\x0d\xbf\x89\x67\x5f\x73\x0d\x5c\x07\x63\xb5\xc5\x67\xc4\xe6\x4e\x69\xb9\x70\xf6\x7d\xf7\x7d\x69\xd4\xfe\x9c\xce\xe6\xbf\x2e\x25\x9a\x35\x0c\xc6\xc4\x4b\xd5\x40\x40\x74\xb0\xca\x87\xc2\x88\x3b\xa7\x25\xa1\x02\xb7\xe2\x26\x4a\xd8\xed\x46\x36\x9b\xb3\x39\x61\x43\xa8\xa0\x25\x81\xba\x95\xc9\xf7\x2f\xcf\xaa\xb2\x62\x76\x50\x98\x28\x3a\x45\x2b\x2a\x23\x6b\x43\x74\x83\x54\x47\xbe\x47\x19\x3e\x91\xb0\x18\xdf\x85\x5f\xc1\x7b\xf0\xe3\xd7\xc1\x4a\x98\x0b\xaf\xc1\x97\x3e\xbc\x7f\x91\xff\x0e\xa8\xc3\x06\x38\x61\xdf\x97\x3f\xfc\xf2\xc5\xbf\xbe\xfd\xe1\x6b\xae\x37\xfe\x11\xbf\x05\x47\x11\x17\xce\x03\x4f\xdd\xb6\x71\xe0\xe2\x59\x2b\xc9\xe9\xfa\xed\xcd\x17\x9f\x7b\xf7\x83\xcf\x3f\xa6\xe7\xe6\x78\x72\x6e\x7a\xb1\x1c\xd4\xe0\x78\x41\x50\x55\x45\x9f\x83\x30\x10\x29\x0a\xe5\xd2\x0a\x31\x64\xb5\x3a\x59\xdd\x9b\xa7\x7b\xa5\x46\x17\xb3\x9e\x8e\x1c\x25\x1e\x1c\x88\xd6\xc5\x74\xc1\xc5\xe9\x9d\xe1\x37\x19\xd6\xd2\x4b\x8e\xef\x85\xff\xfd\xdd\x8f\x49\x58\x0f\x87\xde\x7c\x19\xfe\xe8\xe9\xbb\x4f\xb8\x65\xeb\x96\x5b\xaf\xdc\x3e\x7a\x60\xe5\x05\x67\x7f\xfe\x3e\x5c\xf4\xf8\x7b\xb0\x08\x7a\xa1\x0d\x12\x53\xec\x06\xc9\xd2\xf8\xc0\xad\x2f\xbd\xb3\x7a\xc9\x85\x73\xed\x96\x2b\x7d\x4f\x50\x5a\x3d\xe4\xce\xbb\x83\xdc\x29\x79\x74\x02\x9e\x00\x72\xac\x56\xaf\xcd\xe5\x76\xdb\x00\x71\x86\x39\xd5\xe2\xd0\x1d\xcd\x89\x1c\x5d\x25\x7f\x6c\x3e\x64\xeb\x56\x64\x9d\x3d\xa4\x9b\x92\x4c\xce\x34\x1b\x7b\x47\x3c\x84\x42\xdd\xe3\x93\x8a\x6b\x15\xb3\xb4\x1a\xdd\xe1\x5e\xef\xba\xa9\xae\xad\x6e\xb3\x6b\xbd\x1b\xf6\xaf\x68\xab\x82\xfd\xd0\x45\xc3\x86\x16\xf4\x0b\x5e\xd1\xae\xa3\xef\xaf\x08\xf6\x2b\x18\x3a\x0c\x2a\x47\x8f\xd2\x79\x84\x1d\xbf\xa0\x02\x72\x17\xab\xa0\x2a\xee\x57\xec\x76\x4e\xb0\x09\x2a\x72\x6b\x0e\x08\x25\x1b\xf1\x57\x14\x9b\x4c\x15\x4e\x2a\x7e\x9d\x35\xfb\x26\xac\x46\x6b\x89\x31\x20\xd1\x8a\x79\x81\xe2\x76\xa0\x02\xe2\x9d\xfc\x70\xf6\x81\x13\xfc\xb0\x94\x58\xf9\xe4\x14\x3e\xd0\x3e\xfc\xac\x00\x1a\xbc\x01\x86\xe0\xad\x67\xe5\xe1\xcf\x8d\x98\x07\x59\xb7\xbb\xf8\x21\xa0\x08\x0c\x8a\x87\x5d\x90\x0f\xbb\x7d\x01\x1f\x6f\xe5\x84\x68\x71\x7e\xce\xc4\x44\xbe\xf7\x2f\x23\x1d\x59\x5e\xca\xdf\x45\x38\xd2\x8e\xcb\x5f\x06\x36\xcc\x17\xfe\x2e\xa8\xc1\x5e\x30\x63\x19\x67\xe0\xc9\x3c\xb9\xb4\x88\x4d\xd0\x9b\x4e\x74\x08\xe9\xce\x12\x60\xb1\x80\x8a\x3e\xb9\x6a\x63\x22\x37\xd7\x9b\xe7\xb4\x0b\x76\xe2\x06\xdb\x75\xa1\x28\x63\xe4\xaf\x51\xc3\xd4\xbf\x73\x70\x57\x7f\x36\xfb\xbf\xaf\xd6\xd9\x3a\x5b\x42\xf1\x6e\xf2\xa1\x2f\x42\x6f\xd8\x0a\x04\xfb\x76\x4e\xcf\xaf\x3b\xa3\x6e\xe1\xd3\x2b\x93\x3f\x25\x7f\xff\x6a\x91\xd8\xf2\x48\xeb\xcd\x57\x0f\x93\x6e\x13\x8b\x26\x6c\x58\xb9\xf7\x92\x11\x05\x28\xda\x70\xd9\xbc\x6d\xd7\xaf\xbd\xe9\x9e\x35\xf0\xf4\x5f\xa0\xe5\xce\x26\xfc\x2b\xfe\x16\x1f\xc1\x47\x6e\xbc\xf2\xb6\xd1\x45\x93\x12\x5e\xaf\x75\xf0\xac\x5b\x9e\x83\xeb\x36\x3c\x7e\xf2\xc1\x77\xde\x7a\xf3\xe5\x8c\x5e\x5b\x91\xf6\xda\x76\x74\x74\xbc\x86\x27\xc3\xc1\x74\xb6\x03\x18\x97\xdd\x5b\xc1\x6f\x66\x6b\xd5\x48\xf6\x6d\x7f\x62\x0f\xbb\xc1\xa8\x78\xd4\x0a\x9c\x8a\x22\xf3\x44\x0d\xea\x1e\x27\x35\x82\x9d\xd0\x8e\x9c\x4e\xe2\x4e\x53\x25\x27\x43\x8d\x45\x10\xbb\x76\xd2\xa4\x58\x37\x07\x98\x94\x41\x76\xd6\x68\xea\x91\xb0\x49\xfe\x56\xca\x20\xea\x8f\xff\xf5\xf5\x0f\xa0\xe3\x2b\x28\xe2\x5f\xaf\xb9\x11\x2e\xc4\x57\xc3\x08\xf1\xea\x65\xe2\x99\x03\x58\xb2\xfa\x81\x9b\x97\xe3\xfb\xba\xd0\x33\x22\x1e\x15\x11\x92\x6d\x84\x1a\x99\xdc\x69\x02\xb1\x1d\x65\x81\x76\x25\x09\x6e\xe2\xe4\x36\x26\xdc\xba\x9d\x50\x65\x97\x7b\xa2\xa7\xf3\xae\xac\x0f\x87\x28\x84\x1e\x39\xeb\xd4\x20\x07\x74\x45\xc2\x8d\xe4\xc9\x11\x42\xc1\xc2\x1b\x56\xe3\x5f\xa1\xf8\x25\x04\x47\xfe\x89\xff\xb5\x1a\x9e\xbc\x7c\xcb\xfd\xab\xf1\x87\x1d\x00\x27\xf1\xcf\x59\x3d\x21\x5b\x99\xec\x56\xd1\x38\x12\x93\xe5\x7e\x63\xd6\x22\x91\xe5\xc5\xac\x4f\xa5\x38\x15\x83\xa0\xbd\x34\xc0\x41\xe3\x02\x16\x41\xa0\x88\x75\x0e\x87\x55\x44\x4e\x97\x1d\x59\x79\x28\x21\x3a\x40\x0d\x88\x6c\x70\x04\x31\x2a\xe9\x6e\x69\xe8\x62\xb7\x84\x55\x22\x18\x6a\x51\x5a\x89\xef\x23\x4c\xc2\x23\xae\xc4\x83\x77\x1c\x83\x8f\xc2\xd6\xdf\xf9\x0f\x92\x1b\xb8\x59\xc7\x4a\x85\xa5\xc9\xfb\xb8\x93\x8f\x32\xcc\x41\x56\x53\xfb\x1b\x91\x97\x07\xd4\xc6\xf3\xe8\x33\x5d\xaa\xaa\x88\x8a\xee\xf5\x70\x76\xe4\x52\x75\x97\x2c\xc9\x62\x1e\xd4\xcd\x89\xc3\xbe\xfe\x5d\xf4\x79\x38\x02\x59\xed\x40\xd8\xed\xa5\x95\xa6\x34\xf6\xd1\x00\x91\x7b\x33\x7e\x52\x7c\x00\xfa\x3f\xe9\xab\x78\x2b\x3e\x81\xce\xfb\x91\x80\x1e\xdb\x32\xea\xd8\x32\xe1\xcb\xe4\xcc\x35\x6b\x6e\xbf\x8c\xdb\x78\xec\x00\xf7\xce\xfc\x0b\xd8\x5d\x63\x33\x6b\x1c\x68\xbd\x72\x53\xbc\x2c\xe4\xf1\xc8\x36\x97\x4b\x93\xf3\x08\xfb\x32\x2a\x29\x15\x7d\xc8\x97\x4f\x53\xb2\x8a\xdb\xed\x8c\xdb\x6c\xc8\x85\x8a\xd2\x3a\x9b\x7a\xf9\xb9\x14\xf8\x23\x2b\x86\x9b\x99\x96\x4d\x95\x38\x04\x69\x1b\x96\x81\x10\xfb\x77\xa5\x0e\x74\xd8\x70\xeb\xa2\x45\x7f\x55\xf0\x70\xd9\x55\x77\xdd\x75\x15\xf7\x4c\xb7\x9a\x07\xb2\x9e\xa7\x91\xf5\x9c\x4e\xd7\x13\x8e\xce\x5c\x5f\xa5\x98\xae\xaf\x22\x01\x95\x03\xdc\xd4\x8c\x9f\x2b\xa6\x3f\x47\x5f\x87\x77\xb3\xd7\x59\x3f\x9b\xf8\xb3\x56\x4c\xfb\xd9\x54\xc9\x92\x84\x93\x88\x7c\xfc\x8f\x42\x55\x15\x8a\x69\x7a\xed\xe9\x56\x97\x0a\xed\x46\x4a\x4a\xad\xed\xec\x81\x13\x1f\x52\xcc\xf7\x98\x39\x80\xe3\xe2\xbd\x14\x3d\xae\x73\x21\xbd\x51\x5f\xa2\xef\xd6\x0f\xeb\x02\xd0\xab\xf4\x16\x7d\xad\xbe\x5f\xff\x59\x17\x9f\x0f\xe9\xc4\x46\x75\x38\x68\x92\x40\x79\xbc\xe3\xbb\x56\xc5\x05\x6c\x9d\x49\x02\xc8\x7a\x0a\xd9\xfe\xa8\xe8\x38\x22\x4e\x20\x7b\xb2\x10\x9c\x18\xef\xed\xb1\x14\xc0\x40\xa0\x30\x18\x74\x5a\x50\x51\x84\x56\x94\x11\x1b\xcd\x4f\x1b\xe4\x20\xcf\x07\x43\x28\xa8\xd9\xd4\xe6\x44\x83\x0b\xba\x6c\xc4\x12\x88\x4d\x35\xd3\x23\x95\x66\xca\x07\x64\x46\x91\x0c\x97\x97\xd9\x2e\x41\xa8\x84\xd3\x08\x01\x83\x59\x42\x8b\xa7\x5e\x11\xad\x39\xe5\xde\xf8\xc7\xb1\x93\xbe\xf8\x10\x6f\x9d\xb6\x6e\xc4\xdc\x41\x89\xca\x93\x1a\x97\xae\x9d\x82\x7f\x1a\xbe\x0f\x07\xf8\x2b\xf9\xaf\xf1\xd6\x9c\xc2\xbd\x4f\xbe\x87\x2f\xee\x3f\xec\x92\xda\x92\xb3\xe7\x7e\xbc\x70\x51\xa1\x92\x74\xf0\x5f\x6f\xd9\x02\x4c\xf9\x40\xbe\x52\xfc\x59\x29\x46\x0c\x3b\xc0\x82\xe1\xf9\x66\x8e\x4f\x24\x32\x15\xc3\xa2\x95\xef\xcc\x09\x12\x7e\xcd\x35\x03\x41\xb0\x2c\x3e\x41\x70\x22\x51\xf4\xe4\xe5\xe6\x3a\x9c\x1e\x67\x7e\x01\xa0\xe5\xc2\x48\x6c\x4e\x34\xa3\x35\x6c\xe2\x1a\xf9\x4e\xf1\xc9\x79\xd0\x89\xf2\xf2\x7c\x3e\xe2\xf3\xf9\x78\xa3\x67\xb6\xd1\xb1\xd6\xb1\xd5\x71\xd8\xf1\xb3\xc3\xe2\x40\x0e\x87\xa2\x58\x9b\x13\x8a\x3b\x13\x35\x21\xfd\x15\x9d\x8b\x49\x01\x14\xb2\x5a\x6d\x8c\x74\x2f\x2d\xc3\xe0\x25\xb2\x69\xbd\x80\x01\x7b\x88\x19\xfd\x85\x34\x38\x8a\xfc\xef\xe2\x0e\x9d\xbb\x2e\x39\x5f\x83\xf6\xf7\xd6\x7f\x39\x6a\xcb\xe9\xf8\xcd\xb7\xde\xc5\x2f\xdd\x09\x67\xc1\x61\x9f\xc3\x8a\x51\x8f\x54\x7f\xc8\x1f\x4d\x7e\x7d\xd3\xd7\xf8\xe7\x0d\x6b\xc7\xed\x6f\x7d\x10\x1e\xff\x39\x6c\x82\x97\xef\xbe\x7f\xd0\x25\x57\x30\xf9\x4c\x25\x77\xed\x7f\x98\x0e\xaa\x63\xdf\x77\xed\x2d\xfc\x7f\xee\xbd\x21\xef\x09\x91\x3b\x64\x06\xfb\x1d\x46\xfc\x5c\xeb\xf8\xd9\x62\x27\x7b\x28\x8f\xdc\xe8\x63\xe3\x65\x01\xe0\x0f\x87\x79\xd1\xeb\xf2\x12\x83\xbe\x38\xea\x0f\x35\x27\xfc\x7e\xde\xeb\x25\x82\xf5\x22\xbb\x42\x63\x90\x7c\x98\xb6\x8d\x82\xcc\x51\xf8\x29\xbb\x2c\x7b\xf2\x11\x1f\xa1\x60\x99\x36\x28\x9a\x09\x8b\x21\xc4\x60\xa4\xf8\x99\x35\x3c\x3d\xdb\xf4\x8b\x3a\x8b\x1d\xe3\x2f\x93\x8f\xe1\x96\xea\x58\xf3\xda\x2b\x06\x04\xdc\xd1\xda\xe1\x03\x06\x0c\xe8\x85\x38\x78\xf9\x11\x28\xec\xdf\xb6\x0d\x6f\x86\x73\xb7\x6d\x81\xb7\xec\xfd\x82\xff\x1c\xaf\xc5\xf3\xf1\x1d\x1b\x6d\x9b\xa4\xa1\x37\xc2\x32\xf8\x30\x1c\x96\xdc\xf9\xd6\xfe\x8b\x97\x62\x6e\x25\xe3\x85\x9c\x37\xe9\x3e\xc2\x8b\x46\xb8\x69\x8c\xf7\xb2\x4b\x92\x45\xf6\xfb\x1d\xbc\x9b\x9c\x43\x0b\x0a\x04\x65\x5f\x73\x42\x96\x8d\x50\xaa\xdd\xe2\xa4\x01\x63\xd6\x40\x6a\x32\xc3\x86\x16\xa7\xe2\xab\x3d\xa8\x2a\xc6\x8f\x31\x92\x87\x7e\x64\xb0\x21\xdd\x47\xd9\x38\x94\x7c\xa6\xad\x8d\x1b\xd2\x06\x27\x99\xa4\x3f\x0d\x47\x19\xa4\x73\xd7\x26\x2f\x20\x9a\x7d\x27\x77\x52\x06\xc1\x90\xf6\xbb\x89\x95\x84\x5e\x0f\x38\x3b\x3e\x08\x10\xc5\x2a\x49\x4e\x8b\xc7\xe2\xd5\xb7\x7a\x77\x7b\xf7\x7b\xd1\x56\xef\x61\x2f\xf7\x93\x17\x02\x6f\x8b\x77\xad\x77\xab\x97\xa2\x7c\xf0\x2a\x4f\x98\x50\x55\x60\x77\xd9\x58\x93\x26\xb2\x98\xfd\x90\xa9\xe2\x04\xa3\x9b\x8d\x15\x5e\xcf\xcf\xe8\x0f\x63\xf7\x0f\x83\x1c\x35\x4f\x6f\x58\x25\x7e\x65\x0e\x14\xce\x5f\xb2\xe2\x8e\xa3\xf4\xc8\x3e\x9c\xfc\x09\xda\x6e\x82\x7b\xb9\x86\x45\xb3\x6b\x8c\x73\x8a\xb7\x0e\xc4\xeb\x93\xf7\x9b\xba\xec\x16\xaa\xff\xe8\xf0\x55\x76\x56\x77\x9a\x67\xd5\x43\xce\xaa\x27\xea\xf1\x01\x47\x66\xfe\x9e\xf6\x75\xfa\xd9\xcf\xbf\x64\xea\xcb\x93\x0c\x7d\xe9\x76\x93\x9f\x27\x7a\xed\xa1\x56\xc5\x0d\x2d\x59\xfa\xb2\x9e\x9c\xef\x02\x69\x00\x79\xcf\x3b\xec\x3d\x47\xe1\x34\x78\x02\xf0\xc6\x9d\xd0\x43\x1f\xe2\x95\xbc\x01\xbb\x9c\x7e\x07\xb9\x93\xf1\x0c\xc1\xcf\xf2\x02\xa3\xe2\xa5\x02\x67\x07\xa2\xd5\x0a\x38\xe4\x70\x2a\x4e\x18\x72\x2e\xa1\xf5\xc5\xc4\xca\xb1\x22\x89\xf6\x78\x72\x9c\xd0\x9c\xe0\x34\x60\x16\xab\xf9\x1b\xcc\x7a\x94\x8c\xc6\x0c\x23\x49\x60\x2e\xaf\xca\x5d\x89\x0b\xdb\xb8\x3f\xf7\xe0\x42\x3c\x03\x6e\x12\x96\x1e\x2b\xe0\x3f\x3f\xba\x18\xcf\xc8\xc4\xed\x30\x7b\xb8\x8d\xbd\x47\x7c\x67\x6a\x1f\xe8\xa0\x39\x2e\x5b\x35\x8d\x77\x4a\xe4\xa7\xbc\xbe\x54\x49\x55\x94\x16\xa3\xfb\xa0\x17\x59\x89\x1e\x06\xd6\x2a\xeb\x56\xe2\xa2\x11\x47\x87\x17\x04\x0b\xeb\x6b\xd5\x32\xce\x55\x76\x2f\x73\x79\xa6\xf6\x49\x6f\x45\x3d\xfb\x2c\xf1\xef\xb1\xb3\x84\x6e\x4d\x86\xbb\x1f\x1e\x61\xe9\x16\x3c\x3a\xbd\xf5\xba\xf6\x9c\xa7\x74\xb1\x70\x85\x22\x52\x5d\x4c\xf8\x91\x89\x6c\x47\x10\x7e\x5c\x84\x9f\xb1\xf1\x5e\xa2\xa4\x5b\x55\x27\x90\x11\xc7\xc9\x4e\xab\x24\x78\x7d\xb2\xaf\xd2\x47\x9c\x4c\x27\x61\xc6\x49\xf6\xa0\x2e\xe8\x84\x09\x4d\x62\x20\x3c\x29\x4f\x39\xbb\x16\xd3\x0c\x70\xc4\x58\x97\x2e\x9d\x03\xa1\xe5\x11\x2f\x83\xa9\x08\x89\xbf\x61\x57\x6b\x7b\x4d\xeb\xda\xf1\xb3\xa3\xc3\xb9\x77\xf6\xe0\xab\xab\xa3\xa7\x36\x6c\x4d\xbe\x08\x37\xe1\x19\x5c\xbf\xd3\x61\x33\xb1\x9c\x30\x59\x81\xa1\x44\x07\xfc\x88\xef\x3e\xbb\x7b\x8f\x39\xd9\x0f\x34\x2f\x3f\x8a\xd0\x1c\x01\x6b\xe3\x4d\xf9\x79\xaa\xcf\xef\x0f\x06\x44\x64\x55\x94\x88\x5a\x58\x18\xb1\x31\x59\x47\x02\x28\x5a\x54\x19\x85\x9c\x1c\x85\x56\x10\xad\x8a\xc6\xa3\x5b\xa3\x3c\xb9\x25\xc4\x7c\x24\x22\x39\x0c\x64\xd0\x92\xd0\x16\xcb\xbb\x64\xae\x52\x86\xb2\xcc\xfb\x14\x2b\x8a\x04\x79\x06\xba\xc8\xa2\xc3\x95\x53\xcf\x8f\x99\x09\x18\xca\x92\xd1\x7a\xd2\x6c\x32\x1a\xcb\x68\x59\x4a\x17\x8d\x18\x23\x3e\x09\x0b\xe4\xaf\x98\x9b\xf8\x0c\xe4\x9f\x89\x3a\x64\xcd\x3f\xb4\x87\xdb\x05\x89\x27\x88\x4e\x8c\xce\xcd\xc1\x27\x7f\x06\x93\x55\xcb\xf0\xd7\x2f\x1e\x9c\xdb\x72\xca\x98\xb6\x31\xa7\x9e\x31\xf3\xe0\x8b\xf8\xeb\x65\x55\x30\xf9\x19\x3e\x39\x67\x76\x49\x1b\xb7\x22\xd7\x91\x3c\x19\x49\x91\xa7\xe0\x4d\xf8\xf5\xed\x33\x4b\xb9\x99\xc9\x8d\x65\x73\xef\x80\xd5\x78\xfa\x53\x91\xf6\xff\x72\xf7\x39\x72\x93\x97\x50\x79\x0c\x27\xf7\xc7\x3c\x61\x23\x28\x01\x4b\xe3\xc3\x0a\x5d\x05\xfe\x9c\x1c\x1e\x69\x05\x05\xd6\x28\x8a\x96\x96\x15\xba\x9c\x2e\x27\xd1\x25\xae\x06\x17\x17\x42\x2e\x17\x08\xf8\xe9\xe8\x1b\xbf\x3f\x10\x20\x4b\x19\xe0\x01\x51\x93\x21\xbe\x8a\x9f\xc7\x2f\xe1\xf9\x37\x78\xc8\x93\x4d\xfc\xa8\x53\x1d\xcd\xf3\xc4\x80\x6f\xa8\xa9\x2c\x67\x83\x39\xd3\x09\x29\x23\xbc\xdb\x65\xce\x7e\xa7\x00\x84\xc2\xa2\x92\x7a\x2d\xcc\x5c\xf3\x72\x58\x9b\x2e\x91\x31\x92\x2c\xac\x2c\x94\x66\xa5\x78\x6e\xf6\xab\xf8\x3f\x93\xee\x5a\x08\xa5\xcd\xbb\xf7\xbf\x3c\x6a\xd4\x23\xf7\x5f\x7f\xd5\xe5\x3b\x63\x0f\x8d\x84\x96\x17\xdf\x69\x5f\xbb\x72\xd3\x0e\xfc\xbd\xe7\xf6\xbd\xe3\xf0\xcf\xd7\x2d\x59\x71\xe1\x86\x85\x97\xcc\xbc\xe4\x1f\x57\x0c\xbe\xff\x9e\x17\xee\x5d\x7c\x77\xc8\xb7\x6b\xf9\xb3\xdf\x80\x74\x5f\x39\xd5\x0d\x4e\x1a\x07\x76\x72\x1c\x24\xba\x81\x5c\x88\x2e\x59\x96\x2b\x65\x8e\x58\x18\x22\x24\x67\x4f\x60\xba\xb3\xa6\x92\x28\x03\xb2\x90\x5d\xea\xea\xe9\x27\x8f\x04\xe9\x7e\xed\x5b\x0f\xef\xd9\x69\xe1\x7e\xfc\x6c\x87\x98\xcc\x15\x96\xb6\x9f\x35\x7f\x2b\xff\xc0\xd1\xc5\xe8\x9e\x45\xcb\x8f\x9d\xda\xa9\xef\x98\xee\x7a\xc9\xd4\x5d\xeb\x4c\xdd\xe5\x72\x51\x85\x27\x2a\x5e\x20\x65\xea\x2e\xaa\x4f\x09\x7d\xc4\xdb\x89\x97\xd9\x5d\x16\x8e\xd3\x34\xb7\x64\xb1\x38\x1d\x6e\x87\x47\x97\x75\x62\xbf\xb8\x38\xbb\xca\xa9\x2d\x89\x4a\x0e\x72\x9c\xdb\xa1\x49\x06\x52\x03\xed\x58\x36\xb6\x5f\x37\xb3\x24\x35\x61\xbf\xfb\xe6\xba\xa7\xa7\x9d\x44\xae\xa4\x1e\x36\x0e\xa4\x36\x01\xbf\x99\xdd\x4b\xf5\xf1\xa0\xdb\x03\x55\x8b\xea\x41\x5e\x1d\x78\xa1\x8a\x3c\x9a\x0a\x9b\x13\x2a\x12\xed\xcd\x09\xd1\xdd\x69\x05\x64\x1e\x75\x1a\x5e\xe8\x7e\xef\x47\xd0\x21\x3c\xad\xcb\x3d\xcf\x75\xec\xe9\xe9\x5a\xa7\xfe\xcf\xdf\xe2\x17\x94\x77\xc7\x12\x20\xdf\xdf\x4d\xfe\x3d\x5f\x58\xaa\x8a\x68\x22\x06\x20\x10\xf7\xc9\x56\x18\xa2\xff\x37\x5a\x5b\xac\xf3\xac\x4b\x88\xc6\xdd\x6d\xdd\x6f\xb5\x4c\x3d\x7f\x6a\x17\x1d\x18\xeb\xee\xf3\x75\xed\xd5\x27\x72\x61\xf7\x13\x5b\xb3\xc1\xf1\x7c\xa7\xcd\x61\xb7\x23\x1b\xf1\x5e\xc9\x9e\xd2\x9d\x36\x3b\x70\x11\x4f\x90\x17\xe9\xb1\x01\xee\x34\xf4\x9b\x11\xe1\x85\x66\x00\xd4\x90\x8e\x40\x0d\x6a\x26\x98\x7a\xd6\x42\x0b\x5d\x1c\x1c\x3b\xe4\xaa\x8a\xa6\x69\xa3\x63\x23\x46\x4e\x4f\x3e\xfb\x11\x7c\x1a\x2e\x39\x98\x6c\x3b\xf9\xbc\xcb\x3c\xc5\xa1\xb5\x03\x4b\x9a\xf7\xa0\x3d\xed\x3f\x23\xe5\xd8\x53\x5b\x17\xf5\x63\xf5\x6e\x17\x76\xfc\x2e\xdc\x96\xc6\x09\x38\x2f\x3e\xc8\xc0\x09\x88\x74\xe2\x04\x28\xbd\x60\x4b\xaf\xfd\xbd\xde\xe8\x85\x1a\x7a\x41\xd0\x0b\xda\x50\xb0\xc8\x5a\xf4\xbf\xc3\x02\xa4\xea\x8e\xff\x7f\x63\x02\xdc\xb6\xf8\xc7\xad\xa5\x6d\xa5\x26\x26\x40\xb0\x2d\x60\x62\x02\x08\xce\x07\xf6\xb4\x4f\xde\xf3\x80\xd3\xfa\xff\x03\x13\x80\xde\xf9\xcf\xb3\x3b\x7f\x68\x3c\x2c\xf1\x16\xbb\x9d\x9c\x6d\x1e\x3a\x9c\xc0\xb9\xdf\x49\xdc\x62\x72\xa6\x91\xdd\xce\x50\x1c\x78\x8d\x4b\x5d\xf6\x95\xe6\x6d\x9f\x7d\xc0\xa3\xec\x26\x32\xee\x7b\xe1\xf9\xd6\x63\x37\xb6\x71\xbf\xef\x61\x97\x8e\x71\xdb\x1f\x2b\x30\x74\xc9\x56\xb2\x0f\x1e\x60\x76\x65\x63\xdc\xad\xc9\xb2\x62\x91\x14\xc9\xe3\x06\xb4\xfb\x93\x9c\x53\xd6\xf9\xe9\x75\xa9\xa3\x01\x72\xa0\xe6\x84\xab\x92\x22\x0c\x48\x2a\xf9\x41\x09\xd1\x41\xa7\xd4\xcb\xca\xc0\x18\xc8\x6e\x87\xcb\xca\x1d\xb2\xfc\x1c\xfa\xf9\xe6\x47\x47\x7d\xf6\xd1\xbe\x2b\xae\xdc\xf8\xfb\xbe\x7d\xb0\xbd\xd0\xff\xc8\xe3\xdc\x89\xc9\x67\x2e\x99\x55\xcd\xfd\xfb\xe8\x62\x33\x16\x71\x3f\x93\xc1\xc9\xf1\x6a\x0b\x61\x16\x11\x02\xed\xc8\xe9\xf8\xde\x09\x9f\x73\xc2\xbd\x4e\xb8\xdc\x09\xe7\x39\x21\x47\xb4\x0f\x33\x80\xac\x02\xa4\x46\x10\x83\xf1\xd0\xd2\x19\x08\x13\xef\xc5\xe8\x1f\xcf\xb4\x82\x62\x69\x1b\x28\xa6\xde\xd3\x06\xff\xb5\x87\xfc\x9f\x92\x08\xb5\x81\xcc\x75\x90\xa8\xed\x2a\x83\xc9\xf1\x2a\x87\x2c\x93\x55\xb0\x5b\x24\x9e\xb7\x40\xa4\x2a\x55\x6a\x5c\x6d\x51\x51\xa5\x0a\x89\xff\xec\x44\x4e\xb2\x26\x44\x18\x3d\x2c\x8b\x1a\x4b\x93\xd1\xdd\x50\xc8\x58\x1d\xfa\x21\x55\xb6\x1e\xed\xd3\x06\xdf\xde\x03\xdf\xca\x5e\x24\x73\xa1\x38\xb6\x57\xbe\x37\x6d\xb0\x11\xf1\x22\x1b\xd0\x34\x8b\x93\xb7\xf0\x5e\x1f\x6b\x9b\x01\xd4\xee\x02\x64\xc7\x18\x66\x33\x4d\x9d\x6a\xdd\x9b\x00\x3b\x57\x87\xe9\x31\x9a\x59\x62\xd6\x56\x6d\x18\xa6\x2c\x2d\xee\x71\x38\x8c\x18\x58\xd4\xdc\xfa\x0d\xd7\x72\xab\xb8\x0b\x88\xa9\xf5\x2e\x8c\x6d\xdb\x82\xfa\xbc\xb5\x8f\x78\x2a\x5f\x6f\x69\xcf\x4d\xb9\x25\xe4\xac\xd2\xf5\x9a\x4d\xe8\xb2\x11\xbd\xe0\x23\xbe\xba\x4a\x8c\x65\xbb\xa4\x28\x3e\x3b\xc5\x1f\x22\x4a\x35\x87\xee\x20\xbf\xdd\x35\x5a\x92\x9b\x13\x92\xc4\x0b\xba\x2e\x20\x8f\x87\xe7\x15\xd3\x24\x4c\xed\x61\x7a\xcb\x96\xa7\x5b\xc0\xba\xf8\x26\xd9\x3e\x09\x05\xaa\x30\x4d\xc2\xb6\x2e\xf6\xe0\xa6\x36\xc3\x24\x4c\x3b\x23\xf8\x73\x8a\x94\x92\x65\xc7\x12\xe1\x81\x61\xf1\xa8\x9d\x9c\x6b\x85\xb8\x82\x1e\xf7\x5c\xba\xdb\xe3\x9e\x46\x0f\x72\xa2\x14\x99\x28\x4d\xa0\x91\x49\x2d\x37\x01\x84\x32\x7b\x58\xba\x52\x16\xea\x89\x28\x18\x4f\x53\xf4\xdc\xc5\xcb\x30\x6f\x9c\xbb\x73\x4d\x7f\x3f\x00\x2e\x8e\x9f\xa0\x2a\x88\xcf\xf5\xf9\x6c\xbc\xa2\xf8\x6d\x28\x3f\x98\x4b\x9c\xb9\xe6\xdc\x35\xb9\x9c\x9c\x4b\xd6\x36\x37\xd7\x25\xb9\x3c\x64\x7d\x55\x85\xec\xbd\x46\x75\xad\xba\x55\x3d\xac\xfe\xac\x5a\x1c\xaa\xea\x72\xcb\x88\xec\x42\x44\x8e\x00\xa0\x95\x6b\x5d\x01\x12\x3b\x8d\xed\xf3\xb3\x9d\x58\xd5\x6c\xb6\x60\x19\x38\x0a\xaa\xc1\x47\x42\x88\x45\x42\x40\x3d\xd9\x0f\xc5\x45\xdc\x4b\x9b\x3e\xea\xf3\xc8\x28\x58\xf1\x39\x1c\x06\x67\xdd\x81\x5f\x79\x1f\x4f\x7a\x7c\xcb\x88\x7f\x5e\xff\x2e\xb4\xbb\x93\xf3\xb9\xeb\x74\xdc\xc1\x1f\xbd\xea\xc2\x41\xf7\xef\xc6\x57\xe0\x5d\x87\xf0\xa3\x0f\xc1\x05\xe3\x57\x6f\x86\xf2\x3f\x6f\xfa\x3a\x69\xc8\xbb\xe3\x88\xf4\x30\xe1\x91\x62\xe7\x9e\x1e\xef\xe7\xb4\x5a\x6d\x84\x15\x0f\xb0\x91\xdb\x3e\x1c\x02\x61\xb2\x3b\x54\xc2\xa9\xca\x3b\x89\x93\x40\x0e\xb3\x05\x38\xab\x9c\x5b\x9d\xc4\x73\x70\x92\x3b\x07\xd9\x34\x3e\xd8\x09\x81\x64\xe6\xd8\xa7\xb1\xe0\x4e\xf7\x46\x08\x13\x07\x29\x44\x7e\xb3\xe1\xc6\x6a\x34\xdf\x83\xcc\x2e\x57\x8d\x36\x43\x3c\xbc\x15\xbf\xf3\x22\xfe\x10\xdf\x25\xe3\x0f\xdb\xda\x60\xaf\x3c\x38\x19\xe6\xc3\x3a\x38\xe5\xd9\xdf\x3e\x39\xf4\xdb\x9f\x1f\x1e\xfa\x95\xc2\x20\x3d\xfc\x20\x9c\x0e\x07\x1a\x3e\x2d\x2c\x82\x23\xf0\x52\xbc\x3b\xab\x36\xaf\x9c\xf1\xd6\x62\x62\xfb\x38\x81\x17\x24\x88\x96\x80\x50\x73\xf1\xbc\x13\x68\x36\x9b\x15\x58\x7d\x7e\x68\xd7\x88\x15\x21\x6b\x0d\xda\x04\x6d\xae\x46\x34\x98\xa6\x01\x49\x22\xab\x28\x21\x9b\x8d\x59\x66\x95\x59\xb1\x5f\x10\xcb\xac\xb3\x32\x8a\xee\x89\xb6\x62\x65\x90\x45\x31\x56\xda\x05\xdd\x44\x8f\x92\x5d\x56\x28\xb6\xc0\xb5\xb7\x3f\x06\xb9\x9f\xb8\x1b\xdb\xf0\xf1\x78\x5d\xe0\xae\x1b\xe1\x41\x3c\xf0\x96\xed\x5c\x73\xe0\xbd\x5b\xf6\xbd\x7b\x74\x31\x77\x3c\x71\x96\x8e\x2c\xbe\x96\xb3\x2c\x35\x62\xeb\xfc\x05\x2c\xb6\x7e\x1c\xa3\xfd\x22\xf2\x7d\x83\xf0\x19\xd1\xb1\x85\x44\xc3\xb9\x03\x40\x0e\x89\x22\xb1\xcb\x8a\x22\xa0\x68\x77\x11\xa7\x1a\x7d\x52\xb4\xc1\xd8\x81\x1a\x13\x21\x87\x43\x0b\x80\xbc\xdd\x79\x3f\xe7\x91\xe3\x91\xa7\x59\x69\x2f\x8f\x11\x02\x25\x94\xc7\x58\x91\x41\x97\xce\xcd\x34\x14\xa7\x91\x2d\x40\x66\x46\x81\x76\x09\x0c\xe1\xa2\x3a\xef\x82\xd2\x10\x88\xae\x58\xbe\xf1\xb6\x8d\xd7\x6c\xbc\x7d\xf5\x6f\x9f\xbd\x75\xf4\xc7\x3f\xfe\x55\x71\xc6\xcd\xdf\xc3\xcb\xf1\xd4\x3f\xcf\xe2\xcb\x5f\x86\x7f\xbc\xdc\xf6\xcc\x0b\xcf\x3c\xbb\x97\x7b\x1f\x1f\xc3\x47\x89\xe4\x93\x64\x1f\x8e\xdf\x01\xe1\x9e\x4b\xc7\xd6\xde\x5e\x77\xc6\x7b\xef\x5e\xb6\x9a\xe8\x1f\x5a\xb3\xf1\x0d\x3f\x80\xe8\x6a\x3f\x08\x83\x8b\xe2\x1e\x31\x17\xe5\x2a\x8a\x2b\x1f\x21\x8f\xcd\x65\x2b\x8c\x54\x45\x60\x84\xb2\x53\x49\x5d\xd4\x48\x65\xe4\x50\x04\x59\x91\x98\xeb\xcf\xf5\x37\x25\xe6\xe6\x2e\x26\xa7\x0c\xa5\x4e\x99\x2c\xe7\x34\x26\x64\xd9\xa5\xd0\x22\xe4\xae\xce\xea\xf9\xe9\x56\xb6\xf2\xf3\xbb\x1a\xa6\x2c\xf7\xcb\x86\x28\x1a\x85\xf2\x61\xd5\x1d\x33\xbd\x81\x9c\x14\x7c\x03\xd7\xf7\xc5\x17\xe7\xcf\x5e\xba\xf4\xe3\xa7\xf1\xf0\xd6\x23\xab\xe6\x2d\x5c\x73\xf8\x83\x25\xb3\xa7\x5f\xcc\x0f\x58\xbd\x6c\xea\xa5\xba\xa4\x5e\x31\x73\xfd\x5d\xfc\x80\xf6\x31\x27\x4f\x3d\x7b\x22\x7c\x06\xef\x1f\x7d\xea\x89\x63\x0d\x5d\x41\x78\xe4\x76\x11\x1e\x4d\xcc\x34\xe2\xbd\x48\x02\xd7\x98\x10\x64\xa4\xf7\x80\x99\xc6\xed\xc2\xeb\x5b\xf9\x01\xcb\xda\x8f\x27\x6f\x61\xeb\xed\xc1\x33\xf8\x95\xec\xfd\x6e\x30\x32\x5e\x24\x68\x9a\x24\x89\x50\xe1\xe9\x29\xb3\x13\xaf\x58\xf7\xb0\x94\xb0\xac\xf1\x0e\xab\xa3\x31\x61\xd5\xed\x62\xa6\xa7\x9b\x59\x9e\x9c\x56\x1d\x61\xe2\xd8\x52\x44\x7d\xd3\xdb\x25\x36\x70\x0c\x0d\xc3\xaf\x45\x4f\x8d\xc3\x5f\xe0\xc8\x3b\xdb\xdf\xba\x73\xe1\x98\x39\x15\xdc\xf2\x75\xe8\x31\xfc\x33\x9e\x7d\x7d\xf2\x6b\xe6\xee\xe6\x5d\x06\x5f\x85\x73\xda\x8f\x4f\xe1\xab\xf2\x7e\xb6\x2f\x47\x1b\x78\x14\xe4\x4c\x4d\x24\x74\x46\xc0\x93\xf1\xe3\x89\xbf\xca\x9c\xda\xbc\x7c\xbf\xa6\x15\x16\xca\x11\xe6\xf1\x06\x22\x02\x2a\x8a\xbe\x1e\x3d\x14\xe5\xe6\x45\x61\x43\x74\x6e\x94\x0b\x45\x21\x71\x77\x7f\x8e\xc2\xdb\xa2\xb0\x31\xda\x12\xe5\x0a\xa2\x95\x51\x0e\x44\x89\x51\xc8\xfc\x5e\xda\xd7\x57\x66\x57\x47\x9b\x0e\x30\xd9\xbd\xb2\x5c\x20\x4f\x90\x9b\x65\xde\xf8\x82\xa8\x7c\xe6\x09\xcb\xc4\x13\xd6\x3b\x3d\xe1\x69\x9d\xae\x70\x79\xca\x17\x4e\x77\xcb\x66\x38\xc4\x7f\xed\x0f\xa3\x98\x2f\xe5\x0f\x73\xee\x18\xea\xf4\x58\xb8\x89\xb9\x43\xdd\xf8\xbb\x17\xe1\xe9\x91\xa9\x1f\x3c\xb9\x61\xd8\xe8\x81\x15\xad\xf9\x55\x7d\x87\x3d\xfb\xe4\x07\x53\x23\xf0\xf4\x17\xf1\x77\xee\xa1\xb9\xad\xf0\x53\x87\x05\xcb\x5c\x63\x70\x25\x1c\xf1\xd3\x79\x53\x8b\xe0\x47\xb8\x58\x89\x4d\x81\x03\xf1\xde\x95\xc1\xe4\x6e\xf8\x8b\xc5\x41\x01\x0d\x20\xa8\xee\x38\x82\xa6\xf1\xe3\x41\x11\x58\x15\x3f\xd1\x91\x9f\xa7\x7b\xbd\x3c\x92\xf3\xf2\xac\x85\xa8\x30\x5a\x0c\x8a\x89\x24\xf2\x1d\x76\x87\x9d\x6c\x6e\x47\x81\x83\xeb\xa0\x36\x1c\xb1\xa4\xf5\x46\xbd\x45\x9f\xa7\xf3\x1a\xd2\x75\x3f\x2d\xca\xf1\x2b\x40\x6c\x4c\xb4\x30\xaf\x18\xfd\xc4\xc3\x10\x71\x8c\x79\xda\x81\x5a\x53\x39\x35\xd3\x21\x36\xa3\xc7\x19\x47\x22\xe3\x40\x74\x3a\xc5\x86\x23\x40\x36\x7f\xb8\xb6\xd3\x23\x26\x6e\x72\xc6\x49\x81\x2f\x6f\x7f\xbe\xcf\x6d\xb5\x2f\xb5\x9c\x8f\x1f\xb9\x7d\xd3\x99\x53\x13\xe7\x3b\xee\xa8\x80\x63\xee\x79\xed\xfa\x73\x2e\xde\xfc\xbe\xe7\xb2\xa5\xbd\xb7\x4d\x3b\xed\xc5\xab\x4f\x3a\xe5\x84\x49\x27\x8c\xf4\x40\xee\xb6\xcb\xcf\x5e\x69\xe5\x9c\x6b\x66\x6f\xda\x69\xd6\x6b\x7d\x47\x7b\xb9\xc9\xae\x2e\xb7\x43\xe8\x40\xa2\x28\x38\x04\x97\xbc\x5b\xde\x2f\xbf\x21\xa3\xdd\xf2\xcf\x32\x37\x4f\x5e\x22\x6f\x65\xaf\x08\x36\xe4\x94\x45\xce\x91\x5a\x63\x98\x0e\x22\x76\x86\xc8\x90\xe1\x12\xd7\xd5\x93\x65\x82\x83\x6c\xf0\xb7\xe7\x77\x4a\x08\x8b\xfb\xf9\x01\xc9\xdd\xf8\x7b\x74\xf6\xb1\x03\xdc\x86\xa2\x75\x05\xed\x37\xb2\xb3\x45\xf6\x30\xa3\x41\xa0\xb1\xc0\x7f\x19\xbe\x31\xf8\x8e\xfc\x83\xe1\x1b\xab\xc4\x37\xe6\x14\xaf\x83\xcf\xf0\x8d\x57\x91\x9f\x5f\xc5\xf2\x84\x67\xc5\xfb\xbb\xec\x9c\x85\xfa\xc6\x6e\x8f\xce\xdc\x63\x07\x51\xc2\x95\x3a\x67\x43\xd4\x39\x26\xab\xc5\x35\x70\x13\x38\x44\x3f\x75\x70\x88\xb8\xd1\x0e\xb7\xdb\xa1\x93\x9b\xde\x40\x5f\x21\x26\x93\x11\xc2\x37\x3d\x9a\xce\xcd\xd8\xc5\x5f\xce\xde\x7c\xab\x7a\xd8\x6a\xfc\x80\x1e\xb7\x16\xa1\xd7\xce\x7a\x98\x29\xbd\xe3\xe2\x31\xe0\xe6\x54\x9b\xea\x26\x0a\x63\x9e\xbe\x44\x5f\xab\xa3\x79\xfa\x6e\x9d\x03\x7a\x88\xe5\x78\xe8\x6b\xa2\x13\xa9\x44\x35\xa9\xb2\xe4\x60\xdd\xfd\xa9\x2c\x39\xbb\xb0\x3b\x5b\xca\x18\xa2\x9d\x8d\x39\x08\x46\xbd\x3f\x0d\x97\xa9\x68\x06\xbe\x7a\x60\xfc\x84\xd9\x93\x6a\x7a\xe7\x94\xd7\x0f\xaf\x8f\xf4\xe6\x5e\x23\xea\x63\x2c\x7e\x7d\xcb\x09\xce\xa5\xd6\x39\xe4\xe7\x2d\x70\xc4\xb1\x03\xa6\x4e\x34\xf3\x87\x23\xe3\xc5\x34\x77\x48\x48\xa5\x69\x44\xd1\xae\x10\x77\x7e\x89\x11\x64\x6e\xf0\x12\xa3\x80\x73\x49\xb2\x6a\x87\x22\x5b\x76\xba\xee\x34\x1a\x32\x35\x0b\xb2\xe6\xff\x39\xa1\x98\xec\x4d\x36\x44\x97\x84\xa2\xb1\x1f\x3f\x65\xf5\xd5\xe7\xc4\xf3\x21\xb1\x76\x38\xb2\x1f\x6d\x82\xc3\x19\x77\x36\x3a\x5b\x9c\x28\xee\x5c\xe2\xe4\x80\x13\x2a\xc8\x49\x6f\xa4\xb0\xdb\x37\x1a\x5a\x1a\x13\xbb\xe1\x7e\xb2\xb3\xe1\x2e\xd8\x06\x91\x0c\x1b\x20\x67\x81\xd0\x26\xe8\x88\x2d\x33\x0d\x89\x50\xc9\x99\x90\x80\xdd\x36\x2c\x35\x40\x0d\x2d\x4c\xae\xc7\x6f\x5a\x5b\x71\x0e\x5d\xcc\x3a\xf8\xf2\xb1\x03\xf0\x07\xec\xe6\x07\xf4\xd0\x87\x4e\xe9\x7c\x81\xd0\x29\x81\xe1\xf1\x72\x41\xa4\x68\xf4\x16\x33\x7e\x80\xb6\x5a\x0f\x5b\xb9\x16\x06\x4f\xb8\xdb\xca\xcb\x56\xa2\x3b\x24\x9e\x26\xd1\x45\xc8\x60\x05\xca\xb3\xa2\xef\x26\x5a\x16\x7b\x3e\x7a\xa1\x15\x57\x92\x87\x1f\x3b\x80\x1e\x33\xef\x1e\xf2\xec\xe5\xac\x87\x61\x1c\x79\xf6\xc4\x2c\x4c\x6d\x96\xe7\x27\xb4\x90\x5d\x86\xae\x62\xb4\x0c\x8c\x17\x22\x91\x13\x25\x64\xb1\x2e\xb1\xc2\x06\x2b\x64\x93\xa9\x09\x05\x76\xc4\xeb\x48\x04\x62\x53\xba\x81\xc6\x08\xc9\xa4\xfd\x2a\x03\xa3\x91\x92\x11\x41\x67\xe1\x7b\x5a\xf1\x3d\xec\xfa\x43\x8f\x91\xe7\x09\x78\x32\x6a\xe7\x07\x90\xe7\x4d\x61\xfe\xca\x24\x3c\x59\x1c\x22\xbc\x0a\xa2\xa0\x06\xc4\xc1\x1d\xf1\x73\x62\x60\x40\xef\xde\xf9\x79\xb6\x62\x8f\xc7\x06\xd0\xb0\xa1\x82\xb3\x20\x87\x8f\xa0\x48\x5d\x63\x22\xa2\x04\x81\xb7\xaa\x31\xe1\x55\xd4\x32\xb2\xa7\xbd\xd6\x3c\x34\x84\xe6\x7f\xb7\x0d\x83\x1b\x86\xc1\xe5\xc3\xe0\x82\x61\xf0\xac\x61\xf0\xa4\x61\xb0\xef\x30\xf8\x71\xea\x45\xe3\x95\xf8\x30\xc8\x55\x0d\x83\xa1\x61\xb0\x60\x18\x04\xc3\x32\xd0\xcc\xa6\xa6\x11\xc8\x3a\x5b\x99\x52\xad\xf2\x19\xa5\x57\x69\xb3\x96\xd5\x62\x98\x8d\xf2\xf5\x66\x27\x90\x12\xa6\xf8\x57\x25\xd4\x73\x64\x10\x33\x9a\x89\x7e\x95\x31\x65\xc2\x05\x83\x46\x82\x59\x1c\xf2\x44\xeb\x17\x13\x44\x61\x87\x20\x54\x6c\x9c\xbb\xe7\x61\x38\x7b\xde\xc6\x3e\x82\xb0\x03\x09\x15\x6b\xe7\x3f\xf6\xe8\xd1\x77\x67\x5f\x78\xc5\x22\xb4\xf0\xca\x8b\x67\xf1\x73\x66\x5e\x34\xed\xbc\x7a\x6e\xd1\xd2\x85\x73\xb8\x42\xfc\x15\xfe\xe7\x93\x93\x27\xe2\x04\xdc\x3e\x7b\xf8\x8c\x53\xa1\x1b\xe6\x70\x75\xa7\x9e\x71\x23\xbc\x13\x4f\xd9\x32\x23\x81\x7f\xc2\x5f\x7c\x7e\xe0\xf9\xf7\xfc\x6f\xbf\xfa\xda\xa7\x1f\xbd\x3c\xe5\xa9\xcd\xbe\x97\xda\x0e\xb2\x35\xf6\x19\x7a\x99\xc8\xfc\x34\x33\xd7\x3f\x83\x9f\xce\xce\xc5\x80\x78\x90\x13\x04\x8b\x45\x82\x36\xc9\xe6\x74\x10\x9b\xdf\x85\x04\xc8\xba\x0e\x74\x0b\x32\xf5\x5a\x5a\x9f\xf5\xb0\xd5\x8d\xcd\x4e\xb6\xfa\xa7\xad\xeb\xef\x6c\x7f\x85\xd8\x4b\xc7\xd3\xdd\x46\xad\x0b\xba\xe3\x20\x58\x44\x9e\xbd\x85\x7c\xa9\x82\x7e\xf1\xa0\x40\xe3\xa2\x8a\x45\x71\x6b\x36\xe2\xa9\x33\x8b\xa9\x00\x71\x08\x59\x74\xd1\x38\x5c\xa9\xe0\x45\x36\x8a\x3c\x9b\x95\xca\x1e\x25\x99\xed\xe7\x15\x77\xcf\xb9\xbb\xb5\x75\xfc\xba\xcb\x97\xae\x21\xa7\x6b\xce\x1d\x95\x9c\x40\xce\xd7\xc1\xfc\x7e\x37\x5f\x0b\x6f\x4e\x9d\x29\xc1\x38\xfb\x93\xe3\x61\x04\x58\xf4\x86\x07\xc8\xe1\xbc\xcf\x09\xcf\x72\x2e\x77\x72\x55\x4e\xc8\x85\x58\xcc\xc2\x69\x1c\x7f\xd9\xea\x18\x6d\x15\x20\x0d\xa4\x10\x2b\x9b\x6a\xca\x54\x33\xb1\xd1\x17\xdf\xfc\x37\x91\x8b\xeb\x5a\xe1\x4d\xad\x70\x73\x6b\x8a\x7f\xf4\x18\xd5\x8a\xa6\xac\xc5\xe9\xcc\x1e\x3e\x33\x3e\x90\xd0\xe0\x72\x39\x8d\x18\x0a\x51\xcc\xca\xc7\x2a\x6c\x55\x61\x0b\xf1\x20\x39\x8e\x7a\x92\x5c\x03\x8d\x62\x28\x6a\x48\x45\x36\xe4\xa2\xc4\xd8\xb3\xa9\xc9\xec\x6d\x6e\xee\x21\x8e\x91\x49\x13\x95\x17\xa1\x6b\x63\x2b\xdc\x40\xd6\xa6\x93\x32\x63\x75\xa8\x1d\xda\x87\x90\xb1\x93\xd0\x46\x63\x18\xe7\xc6\x75\x87\xd5\xe9\x94\x54\xe2\xba\xfa\xbc\x34\x77\x04\x7c\x30\x80\x58\x36\xa9\x84\x7a\x1e\x7a\x53\x62\x97\xa3\xcd\xf1\xba\x03\x51\xa3\x65\x82\x03\x49\xc8\xe1\x90\x6c\xb4\x71\xd9\x26\x4b\xce\xa6\x84\xd4\x83\x89\xce\x24\xd7\xd5\x13\x31\x5a\x59\x59\x98\x23\x65\x8d\x97\x43\xe4\x3c\xf8\xd6\x07\x07\xf0\x39\xf8\x71\xd8\xfe\xf2\x15\x17\x2d\x58\xf1\x0a\x37\x6f\xfd\x6d\x37\x6d\x43\x8f\x2d\xc3\x75\x58\x9e\x72\xe6\xb4\xc9\x4c\x5f\xd0\x75\xad\x21\x34\xa7\xe2\x1b\x55\xc4\x64\x96\x90\xec\xf1\xf9\xc8\xc2\xf9\x73\x6c\x6e\x42\xa6\xad\xcd\xf6\xba\x8d\x98\xab\x05\xb6\x09\x44\x5b\x12\xff\x4e\xd2\x2d\xb2\x47\x92\xec\x26\x91\xc6\xb2\x1a\xfe\xeb\xf9\xdd\x72\xc9\x29\xf2\x62\x9d\xc4\xd1\xf8\x06\x57\x6c\x10\xd8\x6a\x50\x87\x06\xb5\x1a\x04\x52\xed\x6e\xd0\x87\x9d\x54\xd9\x52\x7c\x3a\x42\xe8\xfb\x26\x8d\xe7\xc5\x47\x53\x0a\x89\x51\x8b\x3c\xfa\x62\xbd\x43\xe7\xa8\x49\x31\x41\x9f\xab\xaf\xd1\x6f\xd3\x77\xe9\xaf\x93\x97\xac\x36\xa4\xc7\x23\x25\xa3\xff\x82\x78\x8b\x9c\xa6\x3c\x5d\xda\x7e\x7e\x79\x0f\xf1\xbd\x1e\x28\xe7\xfa\x31\xaa\x4f\x6e\xfd\x84\x52\xfd\x69\x57\x92\x41\x2a\xd6\x8c\xf6\x11\x7b\x35\x0f\x6c\x8e\x0f\xb3\x49\x92\x97\x22\x37\x03\x60\xf1\xa2\x60\xc0\x4a\x2e\x44\x3a\xe3\x95\x8e\x59\x5e\x63\x15\x64\xeb\xeb\xd6\x43\x56\x44\x63\x9f\x39\x6e\xda\xd3\x00\xa0\x02\x43\xb0\x05\xce\x83\x4b\xc8\xb5\xf9\x06\xb9\xb8\x20\xdd\x32\x85\x79\x85\xa3\x21\xcc\xf1\x52\x8b\x7e\xae\xbc\x58\x7e\x9d\x5a\x7b\x72\x3c\x18\x1a\x2d\xcb\x6e\x37\x39\xfa\xee\xf4\xec\x88\x72\x23\x36\x52\xde\x63\x70\x24\xbd\x2c\x6e\xa3\x2a\x84\xc6\x42\x8c\xd6\xa2\x8c\x99\x12\xf5\x8f\x2a\x2b\xce\x5a\x7a\x9d\x03\x9f\x09\x6f\xb1\x5c\xb5\xea\xad\xd0\x13\x81\x43\xf7\xfd\xf3\xf7\xdf\xbf\x7d\xf0\x2b\x38\xd0\x31\x6b\xc6\x83\xfb\x96\x3d\x75\xf7\x73\xae\x8d\xdb\xf1\x61\xe2\xfb\x1c\xc1\x5f\xb4\x9a\x38\x82\x1d\x47\x84\x1d\x84\x6f\x15\x04\x29\x0a\xb4\x06\xfc\x4e\xd1\x61\xb1\x58\xad\x22\x40\x05\xf9\xb2\x4e\xf1\x53\x28\x32\x82\xec\x20\x77\x9e\xc3\x61\xb5\xc9\x56\x1d\xe5\x65\xa0\xa9\x98\x79\xa8\x2e\x8d\x7e\x9d\xd7\x04\x57\x12\x61\xc1\x8f\x18\xb1\xb2\xb5\xac\xda\xd6\x1d\xdf\x1f\x7a\xe7\x4b\xeb\x67\xad\xad\x87\xc2\x70\xdb\x0f\xef\x3f\x75\xd1\xea\xeb\x16\x5f\xbe\x62\xdd\xa5\x5c\x3e\x51\xf3\xdf\x41\xe9\x28\x35\x15\x88\xd9\xf0\x19\xfe\x16\x7f\x4b\x5b\xfe\x3e\x7a\xfb\x4d\x46\xb3\x6a\xda\x0a\xf4\xcc\x4e\x8c\xf7\x02\x08\xe9\x82\x6e\xb7\xdb\x54\x41\x80\x9c\x8d\xf3\x79\x11\x31\xc1\x9a\x12\x32\x0b\x16\x7b\xa0\xc5\xe2\x6a\x4a\x58\x64\xbb\x69\x2c\xf4\x14\xe0\xe8\x74\x9b\xcd\xb6\x28\x58\x4c\xd1\x2a\xc8\xfd\x9d\x63\x16\x18\x0e\x84\x9c\x0f\x3f\xff\x0a\x3c\xe5\xbf\x1f\xbc\x0e\x77\xb7\x7e\x77\xc5\x45\x33\x2f\x4d\xc2\x97\x09\x79\xef\xc7\xa0\xb0\xf1\x06\xa2\x7a\x5f\x86\xbf\x4c\x21\x07\x1d\x74\xfa\x91\xc2\x57\x5a\x31\xf5\x23\x55\x62\xd5\x80\x03\x2c\x1f\xcf\x15\x14\xa8\xc5\x5c\xe0\xf1\x8e\x83\xad\x81\x02\x87\x96\x95\x8f\x37\xde\x73\x49\xfa\x3d\xe7\x81\xff\x00\x56\x61\x82\xb8\xdc\x5c\x0a\x73\x99\xcf\xe7\x07\x1c\x6a\x46\x85\x09\xa4\xf5\x62\x0c\x7b\xab\x0c\x5c\x12\x1f\x6a\x93\xca\xca\xa8\x62\xcd\xf3\x5a\xf9\x5e\xa1\xf2\x35\xe5\x30\x5e\xde\x58\xde\x52\x8e\xe2\xe5\x4b\xca\x39\x50\x5e\x55\x1e\x2f\x47\x0a\x72\x69\x65\x7a\x4e\xb0\x31\x91\x93\x67\xe3\x10\x47\x8e\x15\x42\x9a\xa0\x45\x89\x17\x4a\x53\x8e\x92\x63\xb4\x26\x0b\x80\x1a\xc9\xa6\xac\x52\x78\x1f\xec\xe4\x19\x46\x73\x0a\x2e\xcc\x2c\x2f\x25\x7a\x96\x8d\x1a\xa7\x45\x65\xc4\x91\x4a\x41\xcc\x31\xf4\xc8\x5a\x1f\x6d\x2e\x49\xa1\xd0\x5d\xb7\x7c\x79\x2b\xec\x8d\xdf\x91\x20\x1a\x70\xe7\x65\xbb\xb7\x5f\x74\xd1\xb8\x9a\x21\x23\xeb\x58\xaf\x09\xff\xe8\xb2\xf5\xeb\x97\x6d\x18\x7c\x85\xed\xbc\x33\x77\xbd\xd6\xfe\xe6\xe6\x55\xd6\x6b\xc4\xd1\x33\xb8\x5f\x58\xcf\x49\x72\x87\xe9\xdb\x70\x2f\x52\xb9\xa2\xaf\x98\x8c\x2e\x04\x1f\xa4\x6a\x98\x88\x6b\x23\x9e\xdc\xb5\x86\x89\xda\x76\x9f\x31\xfc\xcf\xdb\xe2\x53\x88\xf3\xee\xf3\xcb\x9a\x86\x90\xea\x47\x81\x3c\x39\x40\x2c\x49\x99\x76\x62\x9a\x27\x74\x8d\x2c\xc8\xe4\x98\x1e\x92\xc9\xe1\x96\x65\x20\x8a\xc4\x61\x28\xb0\x55\xda\x16\xdb\xd6\xd8\x0e\xd9\x04\x1b\x3d\xbb\x36\x9b\xa8\x00\x9f\xe2\x0b\xf9\x5a\x7c\xf3\x7c\x4b\x7c\xfb\x7d\x6f\xf8\x2c\x56\xe3\x92\x70\x90\x13\xef\x23\x96\x86\xc7\x04\x49\xca\x3a\xdb\x59\x47\xbb\x0b\x6a\x92\x91\xa5\x4a\x81\x88\x32\xc4\x44\x5a\xeb\x44\xf3\xb7\x14\xc2\x82\xeb\xfb\xed\xef\xff\xfe\xe6\xbe\xcf\x82\x4f\x84\xde\xba\xe6\x4a\x0b\xdc\x82\xcf\xd4\xa0\xed\xac\x15\xca\xa3\xfa\x57\x1e\x58\x40\xcc\x20\x19\x86\xb7\x6f\x74\x3d\xb7\xfd\xc9\x65\xf8\xfa\x73\x66\x3b\x6e\x7a\x84\xf5\xc4\x13\xde\x1f\xe5\xc7\x10\x9b\x67\x52\x1a\x7b\xd5\xa8\x5f\x1d\xcb\xea\x59\xc9\xee\xe2\xa2\x6c\xbf\xfd\x66\x60\x58\xbc\x62\x76\xcc\xf3\x3c\x45\xa2\xb0\x3c\xde\xf1\x5b\x6b\x37\x38\xe1\xae\x75\xb0\xe4\x3c\x12\x7f\x4c\x3c\x42\xce\x63\x2e\xb1\x9c\x2f\x8b\x7b\x0a\x50\x6e\x5e\x9e\x64\xf5\xfb\x55\x95\xec\xac\x68\x51\x28\x0a\xa3\x54\x3a\xb5\xe4\x0a\x7d\x3d\x0a\x59\x14\x24\x37\x42\xd4\x7c\x6e\x5b\xee\xeb\x34\xd2\x55\x90\x3b\x21\x97\xa8\xf9\xdc\x5c\xc9\xef\x27\x57\xa9\x5f\x76\xb9\x1b\x13\x2e\xaf\x94\x97\x71\xa1\x76\xbd\x54\x19\x20\xc8\xf9\x5d\xef\xfe\xce\x7b\xb5\xab\x23\xd7\x79\x1d\x08\xe3\xd8\x75\x30\x04\x9f\xdd\xc5\xaf\xfb\xf5\x57\x7a\x3f\xfc\x96\xba\x73\xbb\xfa\x78\x99\xf7\x05\xbb\xdf\xc4\xde\x0c\xa7\x34\x0f\x2c\x8a\xeb\x3e\x01\xba\xdd\xaa\x55\x71\x38\x9c\x34\xfb\x12\x0c\xb4\x04\x61\x90\x32\x5d\x4d\x43\x7c\x41\xe8\x45\x90\x70\x03\xa1\xa2\xd8\x1b\x13\xbb\x94\x36\xe5\x75\x05\xc9\x4a\x81\x32\x41\x21\x8c\x2b\x0a\x70\xea\x56\x72\xf1\x59\x75\x97\x61\x03\x66\x5e\x72\x9d\x28\x3b\xe5\xdd\x3d\x44\x72\x2b\xa7\x59\x36\x4b\xa5\xd2\x61\x3e\x74\xef\x57\x8c\xd3\xe9\x78\x7c\x6b\x2b\x7c\xe8\x11\xe3\xd2\xa6\x2a\x95\x32\x68\x78\x62\xd4\x2b\x6b\x1f\xc1\xd8\xa2\x58\xf9\x06\x8e\x5f\x08\xcc\x8d\x0f\x0a\xe4\xa8\xaa\x57\xd7\xa4\x5c\x0d\x85\x2d\x85\xf1\xc2\xc6\xc2\x96\x42\x14\x2f\x5c\x52\xc8\xad\x29\x84\xa0\xb0\x8a\xbc\x44\x54\x49\xc0\xa3\x7b\x9a\x12\x39\xba\x8e\x7c\x40\x23\x8b\xc5\x4c\x5a\x44\x18\x6f\x25\x6a\x84\x76\x72\x94\x9b\x96\x46\xba\xf4\x31\xe5\xab\x65\xe9\x0f\xd8\x39\x31\x2b\x8d\x56\x99\xa5\x51\xe0\x60\xa6\x2d\x1e\x31\x7a\xd2\x3a\x75\x48\x82\x6a\x8a\xe4\x64\xee\x4a\x53\x45\x74\xaa\x10\x5a\x63\x4c\xe3\x1a\x4c\x57\x7c\x6f\xe8\x0a\xd8\x90\xaa\xa1\x22\xba\xc2\xd3\xd4\xb5\x86\xca\x88\x9b\x7c\x95\x8a\x9b\x10\x9d\xbd\x23\x55\x43\xa5\xb2\x1a\xaa\x9d\xad\x8a\xdb\x29\x64\xe9\x6c\xe6\xcb\xd1\x58\x0b\xf5\xe5\x58\xac\xe5\x31\x33\xd6\xe2\xf3\x91\x37\xe5\xd8\x72\x0a\xac\x5a\x46\xac\x85\xd8\xc2\xa6\x3f\x3e\x36\x5e\xc1\x4b\xc4\xec\x01\xc0\x26\x21\xa7\x23\xdb\x1f\xaf\x62\xfe\x39\xaf\xd0\x54\xa2\x6c\x01\xcc\xfe\x05\x95\x99\x85\x54\x9d\x81\x8b\x6c\xa3\x97\x19\xbc\xdf\xb4\xe2\x1d\xa6\xb9\x7b\xec\x00\x2d\xa7\x62\xba\x70\x7e\xc7\x11\xdb\x48\xe1\x06\xd0\x17\x9c\x1a\xaf\xb0\xca\x08\x95\x00\xa0\xf7\x21\x12\xae\xab\xcd\x83\x30\x58\x54\xd4\xab\x39\x51\x5a\xc4\x07\xab\x9b\x13\x41\x77\x8e\xd8\x9c\xc8\x71\xbb\x34\xcd\xd1\x9c\xd0\xf8\x34\x3e\x56\xaa\x07\xd5\x3c\x8c\xfd\xd3\xbd\x8f\x6c\x4b\xd6\xb0\x1d\xa9\xb2\x94\x8d\x4a\x21\x08\x98\x8d\x92\xca\xe5\x94\x88\xe1\x54\xcd\xa6\xa1\xe4\xc8\xeb\x1a\xf3\x11\x05\xae\xed\x84\xcf\x57\xfc\x0c\x23\x38\xf9\xfd\x9e\xc5\x0b\xc6\xbd\xbe\x9e\x26\x78\xee\xc7\x6d\x1f\xe0\x7b\x5e\x7d\x0d\xef\x78\x1f\xb7\x3d\x40\xeb\x38\xd7\xbf\x3e\x6e\xc1\xe2\x3d\xdf\xe1\xf6\xe5\xbf\xde\x72\xd5\x17\x13\x60\x0d\xbc\x1a\x9f\x3f\x76\x12\x1c\x48\x51\x2d\x61\xef\x19\x97\x8e\x1a\x4a\x13\x3f\x1f\xe1\x87\x1e\x7e\xe8\xa1\x87\xe0\xf8\x8f\x69\x81\xe7\xd0\x51\x97\xce\xc0\x6f\xe3\xa3\xf7\xe0\xa3\x6b\x4e\x39\x91\xc8\x41\x26\x36\xff\x4b\x0c\x8f\xab\x5f\x3c\xe0\xe6\x64\x97\xcb\x61\xb7\xd9\x1c\x92\xc2\x09\x3e\x2f\x39\xc2\x12\x39\x87\x36\x59\xb4\x1a\x98\x85\x66\xdd\x51\x17\x0b\x99\xf5\x50\x44\xe8\xd8\xb3\x18\x74\xa3\x98\x9b\xf6\x7b\x97\xf0\x37\xd6\xac\x5d\xbd\x75\xee\x55\x3b\xf0\x1d\x8f\x41\xfb\xba\xab\x1f\x3b\x3c\x71\x4a\x15\x3f\xe0\xe2\xeb\xb6\xe3\xa9\xff\x82\x2b\xf1\x45\x64\x49\xe6\xc0\x07\xe0\x57\xed\x73\x6e\x82\x63\x6e\xdc\xb2\xc8\xd0\x25\x3a\xb1\xe7\xbf\x65\xf9\xee\x5c\x30\x2e\x5e\xe6\x76\x58\x78\xbf\x1f\x2a\x40\x11\x1d\x7c\x20\xcf\xe2\x6b\x4e\x48\x1a\xd0\x5a\x12\x3c\xb0\x90\x3f\x0a\xa7\xf8\x9b\x13\x8a\xc6\xa1\xcc\xee\xfb\x6c\x28\x99\x58\xba\xb5\xd2\x3c\x42\x9d\x79\x55\x33\xab\x1a\xd2\xe1\xea\x36\x78\x0d\xfe\x07\xbc\xd1\x4c\xad\xde\x8a\x17\x08\xee\x6d\xdb\xf0\x12\xb8\x12\xc6\xf9\x1d\xef\xbf\xbf\xfe\x3b\x96\x5c\xf5\x25\x97\xb0\x14\x21\xa3\x93\xbf\x5b\x78\x85\xd1\x39\x26\x5e\xea\x25\x74\xba\xdd\x9d\x74\xe6\x12\x2b\xcb\x42\xbe\x23\x8a\x4c\xd1\x39\x40\x69\xa6\x4d\x94\x54\xa1\x19\x9b\xa7\x6b\xe9\x6a\x27\x95\x74\xe7\xb2\xf2\xba\x94\x2e\x23\x1b\x88\xe9\x30\x1d\xf6\x69\x85\xbd\xf0\x7b\x50\x3d\xf8\xd6\x87\xcf\xe3\x01\xf8\x6d\xf8\xf9\x9f\x47\x17\xac\xf8\x0f\x3f\x00\x5e\x8f\xe7\x5e\x83\xbf\xbe\xe7\xb6\x5b\x76\xa3\x5d\xed\x6f\xbc\x36\x6d\x3a\xdd\xe3\x4f\x75\x1c\x91\xe2\x64\x8f\x87\xc1\xd2\xf8\x18\x14\x0e\x03\xa2\x94\x15\xb7\x9b\x2f\x20\x77\xbf\x3f\x27\xa7\x00\xa0\xc2\x08\xf0\x2b\xfe\xb8\xbf\xd1\xbf\xd6\xbf\xd5\xff\x86\xff\xb0\xdf\xe2\x40\xb4\x0a\xcb\xdb\x9c\x08\xb8\x25\xda\xc0\x65\x93\x78\x77\x08\x85\x88\x94\x2b\x11\x44\xe4\x7f\x06\x1e\x91\x72\xcc\xe9\x09\xec\x12\x78\x86\x5d\x22\xef\x9d\x87\x32\x46\x73\x7e\x6e\x13\x04\xc7\x28\x5f\x0e\xb9\x69\xf5\x72\x08\xa0\x88\xfa\x54\xdb\xcb\x3a\x3c\x1d\x96\xc3\xa7\xd6\x3c\x52\xf3\xc6\xfa\x77\xfe\xa3\x73\x8b\x92\x57\xba\x21\xf7\x0e\x2c\x5a\xb3\xe5\x4c\xfc\xd1\xeb\xf8\x4d\x7c\x9b\xfb\x25\x61\x69\xf2\x06\x58\x0d\xc7\xe3\x3b\x07\x5d\xbe\xb8\xfd\x9f\x37\x7d\x83\x7f\x85\x45\xe3\x9e\x7d\x10\x4e\x85\xb5\x14\xec\x14\x82\x95\xc4\x8e\xbf\x88\xd8\x39\x61\x70\x7d\xfc\x54\x5b\x0e\xe1\x9c\x71\x5d\xa0\x81\x9c\x1c\x72\x0e\x43\xfe\x79\xfe\x25\x8c\x59\x81\x72\xdf\xc2\xbe\xdd\x4f\x5e\x90\xac\x8c\x77\x62\xe7\x07\xbc\x92\x93\x82\x52\xcc\xb5\x2f\xb6\xbf\x6e\xe7\x6d\xb4\xac\x43\xa1\x62\x68\x4a\x89\x41\x66\xa1\xd3\x4c\x31\xa4\x2d\x7f\x53\x12\xe7\x67\xcc\xea\x88\xb1\x91\xc7\x69\x39\x18\x73\x2e\xbb\x99\x36\x86\x83\xb0\xb2\xf5\x31\xf9\xdf\xef\xf5\x6c\xe0\x3c\xf8\xf1\x6f\xae\x47\xc9\x4d\x55\xfe\xd3\xd1\x6c\x13\x07\x82\x3f\x70\x3e\x3d\x3f\x66\x6d\x28\xd1\xa9\x1e\x10\x8f\x87\x24\x91\x43\xaa\xcd\xa6\xd8\x91\x68\x47\x5e\xdd\x4a\xbc\xb3\xe6\x84\x83\x57\x14\xc4\x23\xe2\x27\x1b\x85\x85\xac\x65\x24\xbb\x0c\xdf\x3c\xd9\x11\x44\xcf\x34\xf9\x5b\x8d\xb8\x25\x17\x44\x61\x54\x5c\xc2\x9d\xf4\xc4\x9b\x07\xb8\x86\x0f\xb9\xba\x67\xdf\x78\x72\x57\xc2\xea\x88\xad\x85\x0f\x5e\x19\x08\x70\x9e\xe4\x11\x9a\xca\xa7\x9f\xf9\x5f\x02\x25\xeb\xf0\xb5\x30\x31\x62\x32\xa1\x89\x8e\xbf\x6c\x67\x7a\xde\x45\x69\x22\x2e\x21\x70\xf0\xbc\x4b\xb0\x0a\x00\x29\xc4\x13\x76\x11\x9f\xca\x69\x73\xb9\x88\x43\x25\x40\xab\xfe\xf7\x34\x85\x19\x35\x2a\xa3\xcc\x6d\x87\xa8\x7d\xc7\xea\x05\xdb\xe6\x5d\xbd\x0b\xde\x73\xcf\xb0\x4d\x1b\xe0\x3c\xbc\x96\x7e\xf0\x03\x92\xfb\xe0\x3a\x3c\x87\xe9\x94\x36\x00\xa4\x22\x56\x3b\x15\x00\x27\xc6\x7b\x59\x24\xe4\x76\x03\x99\x57\x72\xec\x76\xbf\x43\x72\x28\x80\x0f\xe6\xbb\x6c\x1a\x22\x6a\xc5\xef\x11\x10\x12\xc8\x0a\x2b\x0e\xa3\xb6\xb9\xa6\x86\xae\xb2\xd6\xdf\x18\x7d\xd1\x75\x77\x77\xde\x37\x29\x31\x51\xc2\xc8\x19\x86\x29\x69\xb5\xb5\xc1\x39\xb0\xcc\x14\x16\x11\xdc\x87\xf8\x75\x04\xd3\x32\x23\x7b\xb9\x94\xfb\xc0\x90\x19\xfb\xd0\x93\xdf\x67\xcb\xee\x4a\xb2\x9e\xab\x59\x7c\xdf\x4b\x7b\x60\xd2\xb4\x7b\xec\x76\xaf\x41\xbb\xcf\xcf\x68\x6f\x4c\x78\x75\xb2\x31\xc9\x15\x49\x49\xd7\x0d\xd2\x63\xff\x0b\xe9\xee\x4c\xd2\x23\x2a\xb4\xc3\x2b\x5b\x61\xf8\xcb\x7b\xe0\xdd\xa6\x68\xd7\x1e\xe1\x7e\xdc\xb4\x81\x8a\x94\x1b\x46\x7c\x3b\x53\xc4\xf0\x7c\xbc\x06\xfe\xc7\x10\x32\x07\x2e\x26\x36\x60\x19\x91\xb1\x9f\xd8\x80\x89\x78\x1f\x3f\x8f\xf2\xbc\x5e\x7b\x2e\xb9\xd0\x6d\x76\x9f\xaa\x6a\x9a\x1d\xd1\xe8\x81\xc3\xeb\x68\x49\xe4\x00\xaf\x57\xf3\xf9\xf2\x9a\x13\x3e\x64\xe7\x35\x63\x13\xa6\xfc\xab\x58\x97\x89\x86\x9d\x7f\xe8\x86\xe4\x55\x3d\xc2\xa0\x61\x09\xb9\x2e\x2e\x08\x23\xe4\x06\x8d\xc2\xb0\x15\x86\x79\x9d\xf3\xb4\x9e\x76\x60\xdb\xbe\xbb\x9e\x3f\xad\x15\xda\xa0\x0d\x8f\xe2\xdb\x93\xcb\xe0\xf0\xe4\x45\x48\xa8\x4c\xfe\x79\xb0\x75\xdb\x13\x53\x84\xe4\x75\xdc\x7c\x61\xca\x63\x77\xb7\x1e\x84\x56\xe8\xf3\x73\x97\x26\x2f\x83\xdf\x50\xfa\xc9\xf5\x23\x40\x66\xb7\x07\x41\x73\xbc\x4a\x87\x10\x04\xdc\x6e\x0b\x61\x42\x92\x2c\x1e\x97\x4b\x26\x96\x07\x2a\xc8\x17\xad\x41\x6b\x53\xc2\xeb\x0e\x92\x3f\xb2\xc7\x13\x68\x4c\x78\x64\x0b\x94\xf5\x4e\x16\x3a\x2f\xa0\x1e\x99\x30\xb6\x70\x8a\x05\x16\x05\x8e\x50\x34\x5c\x18\xa6\xd0\xf7\x30\xec\x16\xe0\x8e\x81\x2b\x97\xdd\x7b\xe9\xaa\x21\x3b\x1e\xfd\x10\xbf\x8c\x3e\xc0\x2f\x6e\xb8\x7f\x1c\xde\x84\x27\xbc\x37\x72\xed\xf5\xc7\xf1\xb8\x09\xee\x1a\xb1\x71\xcd\xc8\x91\xf8\x13\x0f\x27\x26\x8f\xba\x66\x1e\xd8\x85\xce\xc5\x97\x13\x1e\x9e\x22\xfb\xfc\x0f\xb2\x06\xf9\x44\xf3\xcd\x8c\xd7\xdb\x45\x5b\x48\x92\x88\xec\xc3\x3c\xaf\x05\x04\xbf\x3f\x07\xe5\x13\x1d\x91\xa3\xd9\xf8\x48\xa1\x5b\x09\xa2\x60\x4b\xa2\x80\x82\x00\x0b\x42\x98\x16\x81\x43\x94\xa3\xd9\xd3\x9b\x3e\x6b\x3d\x62\x5d\x61\xd9\xb2\x56\xc5\x38\x00\xe1\x9e\x16\xa7\x3e\xac\x92\xb5\x79\xaa\x8d\xfb\x8c\x2e\x07\x1e\x91\xb1\x46\xdb\xf1\x1a\xb4\x8d\x2e\x0f\x39\x04\xcb\xc9\x42\x2c\xef\x69\x91\x7a\x5d\x9a\xbc\x96\xc3\x74\x89\x08\x7f\x2b\xc9\x1e\xbb\x90\xac\x51\x18\x14\x81\xd9\xf1\x7e\xa2\xd3\xe9\x28\x94\x24\xb7\xdb\x13\xe1\x79\x4f\x81\x90\x9b\x9b\x47\x2f\x39\x90\xe7\x71\xf0\xc5\x51\x5d\x23\xea\xba\x31\x51\x64\x30\x18\xa1\xc1\x65\x28\xe7\x79\x9c\xa9\xa3\xf1\x3f\x33\xa8\x66\x70\x98\xcf\xb8\xea\xb6\x78\xe4\xbc\x87\xdd\x2b\x5b\xb9\x61\xe9\xf5\x4a\xaf\x61\xbf\x41\xf8\x43\xf4\x16\x59\x3c\x72\x7c\x8e\xa6\xd6\x6b\x64\xf6\x4a\xde\xb4\xad\x1c\x37\xa1\x5d\x64\x0d\x21\x68\xc1\x93\xf9\x79\xe2\xf7\xe0\x24\xb0\x2e\x3e\x2e\xe0\xf1\x96\x79\x05\x54\x2c\x2b\x4a\xdd\x98\xa1\x71\x6b\x31\xe8\xdd\xbb\x38\x3e\x86\x3f\x79\xd2\xf0\xc1\xcd\x09\x30\x1c\x3a\xd0\xf0\xe1\xa3\xcb\x04\x5e\xe0\x5b\x12\x35\x13\x26\x8c\x26\x8c\x0e\x1d\x3d\xba\x5f\x73\x62\x74\x81\xae\xe7\x46\xe2\x5e\x77\x44\x96\x23\x11\x72\xe6\x22\x08\xa4\xeb\xde\x62\xb9\xca\xc1\x9a\xca\x1a\x13\xc9\x87\x76\xca\xa9\x86\x0d\xab\xc6\xba\x75\x3a\x1a\x09\x63\xa6\x39\x58\xd1\x48\x76\xfd\xf4\x10\x58\x4f\xec\xbd\x7a\x36\x6a\x97\x5d\x67\x32\x64\x79\x63\x56\x4f\xed\x22\x9a\x9d\x75\xd5\x32\xa0\x5d\x3d\xd2\x37\x52\xe8\x62\x70\xad\x7d\xc9\xdb\x86\xf0\x68\x57\x66\x8d\x75\xfd\xd3\x37\x3e\xbe\xe5\xce\xd3\x82\xa3\xeb\x26\xf6\x19\xa6\x06\x5c\xba\xf3\x94\x5b\x5a\x69\xc9\x75\xd5\x89\x17\x5c\xb3\xf5\xc6\xd9\x03\xb7\x0d\x98\x79\xe6\xd4\x3e\xd3\x66\x6f\x3a\x21\x38\x69\xd6\xe5\xc3\x57\xde\x71\xd2\x96\xdb\xd7\xcf\x9a\xdc\x10\x81\xeb\x3b\x6b\xb1\xaf\xde\x9e\x0b\x27\xe2\xbd\x1f\x0c\xef\x37\x6e\x48\xbe\x1c\x7c\x31\xf0\xd4\x6a\xa3\x34\xfb\xb4\x2b\xa6\x0c\x2c\x72\xab\xa1\x58\xd9\xac\xbc\x70\xe0\x8a\xb3\xc6\x05\x0a\x03\x6b\x17\x4d\x9e\x33\x44\x76\x79\xa3\x43\x12\x46\xdc\x33\x44\xfc\x97\xe5\xc2\xbd\xc4\x93\x5f\x1b\x1f\x7b\xdc\x70\x4b\xb5\x2b\xe4\xcf\xed\x93\x6b\x47\xbd\x3c\xba\xde\x1f\x80\x5e\xd5\xc3\xf9\x09\xe3\x47\xc6\x89\xff\x31\x92\x88\x7e\xe4\xc8\x31\xb5\x7c\x1f\xbb\x8d\xb6\x8b\xf2\x63\xec\xf6\x92\xe1\x63\xc6\x0c\x6c\x4c\x8c\x89\xe4\xe4\xe4\x97\xc4\x73\x7d\x25\x1e\x4f\x49\x89\xda\x94\x28\x91\xff\x4e\xf4\xa6\xe0\xbb\x88\x3e\x2d\x74\xd3\x6c\xf0\x31\x99\x71\xd9\xb9\xfa\xba\xbf\x10\x3e\xcb\xdd\xbb\x60\xcf\xd2\x0f\x8d\x5e\xb1\x6a\xf9\xcc\xfe\x9d\xf9\xfc\xa2\x77\x9e\xcc\x16\xfc\x69\xf3\x56\xd2\xf4\xfe\x89\x3b\x1f\x9e\x37\xa1\xd7\xa6\x01\x53\x4e\x1c\xdf\xe7\xb4\xf3\x88\xd8\x47\x4c\x9e\x75\xdc\x25\xb7\xde\x36\xfe\xcc\x41\x1e\x77\x9f\xb1\x83\xd3\x69\xff\x97\x7b\xc3\x44\xa7\xcc\xdf\xc8\x5d\x33\xdd\x2c\x02\x68\x5e\xd1\x98\xeb\x2e\xa8\x28\x5a\x50\x50\x54\x70\xd9\x8c\x71\xc1\x48\xf0\x06\x26\xe7\xe1\x44\xd7\x12\x53\x81\xdc\xc6\x83\xe2\xf9\x1e\x9f\x12\x08\x38\x81\x45\x92\x80\x0f\xe5\x07\xf3\xa0\x13\xb6\x24\x14\xa7\x33\x6b\x4c\x56\xb6\x3e\x4d\xa9\x51\xb5\xb0\x82\x2b\x41\xa9\xa6\x86\x14\x46\x0e\xa0\x83\xb1\x5e\x3a\x73\xd3\xfc\x29\xb1\x55\x6d\xab\xaa\x1a\x67\x37\x3e\xd1\xef\xc1\x67\xda\xf0\x97\x47\x27\xc2\xfb\xea\x66\x3e\xb6\x8b\x4e\xc7\xba\xf3\xaa\x51\xe8\xb8\xf6\x27\x5f\xdd\x05\x5f\xc2\x03\xff\x8d\xbf\xc4\x27\x1b\x98\x7a\x82\x44\xf4\x8b\x9f\xd2\xa5\xa9\xe4\xea\xf2\xda\x79\x41\xb0\xab\x28\x27\xd7\xc7\xab\x32\xf0\x3a\xbc\x0c\x5b\xd6\x9e\x85\x2d\xdb\x95\xae\x2c\x4c\x59\x93\x42\xe8\x53\x63\x5c\xc7\xc3\xb7\x3d\x8a\xf1\x1f\x3b\x16\xae\x9b\x52\xba\xfc\x91\xeb\x22\x27\x4d\xde\xb1\x90\xbb\xe5\x21\x6e\x7e\x72\xed\xef\xdf\x18\xb8\xb2\x4d\x0f\x3f\xc7\x2d\x4f\x9e\xb8\xe3\x5c\x0e\x3d\x0b\xb2\x67\x13\x06\x41\x05\x68\x8c\x97\xf7\x26\xf7\x65\x38\x2f\x8f\x78\x3f\x55\x95\xbd\x3c\xcd\x89\xa2\x9c\xe6\x84\x5c\x44\xb6\x63\xaf\xa2\x5e\x45\xbc\xdd\x9e\xcf\x66\x13\xca\x5d\x66\x13\x9a\x90\xa2\xe5\xdd\x60\x17\xb2\x87\x13\xc2\x9a\xa2\x7a\xd1\xc0\x6c\x91\xbc\xc0\x5d\xc8\x4b\x86\xa9\x4a\x9d\xd8\xfa\x62\xd0\x7d\x56\x61\xf2\xb8\x8f\x20\xe7\x5f\x31\x79\xcc\xd2\x8b\xfe\x31\x64\xd3\x65\x3a\x94\x3e\xfa\x0c\x1f\xf3\x0c\xbe\xaa\x69\xc8\x65\x63\x27\x9c\x5f\x7f\xe1\x99\x2a\x3e\xda\x6d\x7a\x61\xfb\x17\x7f\x7c\xd3\xb7\xbc\xb6\xfc\xf8\x6f\x70\x3b\x7f\xc1\xd1\x1f\xf3\x4a\x0b\x8b\xa2\xe1\xfe\xbf\x40\xc9\xc8\x01\x1b\xf9\x70\x60\x03\x39\xa0\x14\x8c\x8f\xf7\x2a\x74\x8a\xe4\x32\x26\x76\x64\x59\xaf\x5c\x62\x9d\x17\xd1\x4a\x19\x56\x13\x56\x94\x5b\x84\x2c\x96\x82\xc6\x84\x45\x41\x4a\x17\xb8\x86\x9e\x58\xee\x32\x58\xa3\x50\x32\x92\x08\x8c\xe5\x68\x8d\x31\x9c\x48\xa2\x20\x65\x1c\x1f\x3c\xfa\xe3\x0f\xbf\x52\x0c\xbe\xe4\x45\x23\x06\x0b\xd7\x5e\x77\xe3\x35\xd6\xe3\xeb\xfa\x4e\x1e\x7f\x02\x2c\x6e\x18\x6c\xbf\x72\xcd\xd5\xab\xd5\x21\x0d\x35\x13\xc6\x4c\x30\x43\xf4\x61\xb2\xeb\x28\x32\xdf\xb7\x91\xd7\x9e\xdd\xfd\x44\x28\x5c\x16\x2e\x08\x3f\xfa\xc0\xe6\xad\xf9\xe1\xd2\x30\xd9\x5b\x56\x72\x77\x4d\x22\xeb\xe8\x01\xc5\x71\x0f\xe2\x38\xd1\x45\xcc\x71\xbb\x4a\x17\x4b\x84\x1c\x82\x46\x1d\x7c\x3a\x6f\xc0\xea\x1d\x62\xd0\xeb\x6b\x80\xb0\x73\x60\xbb\x84\x5c\x07\x92\x4f\xbf\x04\xaf\x2c\xed\x9d\x33\x10\xf6\x19\xfb\xdc\x98\x5b\xab\x4e\x1a\x77\x7a\xac\x9e\x18\x92\xed\xa1\x73\xd7\x8e\xbf\x0f\x95\xbf\x5c\x5f\xb6\x72\x44\x6c\x94\x59\xaf\xc5\xff\x42\xe4\xa8\x19\xcf\x74\x10\x5f\xc0\xed\x61\xc8\x48\x0a\x79\xa6\xcc\x9a\xb7\xbb\x3d\xd3\xed\xf5\xd5\xbb\xd3\xb3\x6a\x24\xee\xec\x77\xf1\xc2\xfd\x3f\x3a\xfb\x9d\x70\xdf\xb0\xfd\xd7\xcd\x6f\x1a\x7a\x52\x45\xbf\x3c\x72\x97\xc5\x4b\x9f\xff\x9e\xb3\xbd\x7a\xda\xf2\x86\xbe\x63\x69\xec\x87\xf1\x27\x8d\xd5\x8a\xe9\x1c\x58\x55\xe2\xde\xe4\x66\xc3\x19\x46\x04\x35\x14\xa2\x1d\xa1\xc1\xc7\x3b\x86\xb4\x06\x73\x39\x57\x36\x96\x2f\xa3\x91\xc6\x99\xf8\x62\xe3\x7d\xf0\xd5\x14\x56\x69\x7e\x3e\x8d\xbc\xe6\x3d\xde\xd1\xd4\x9a\xe7\xe7\x1c\xd9\x58\xa5\xa7\xe3\xc9\x96\xd5\x44\x9e\x76\xe0\x23\x7b\x64\x42\xbc\x97\x26\x16\x86\xc3\x0e\x50\x14\x8d\x86\xf2\x80\x28\x94\xf5\x8a\x84\x8a\xfc\x45\x61\xd9\x1f\x6c\x4c\xf8\xf3\xac\x32\xc5\x3d\x44\x7a\x73\x27\x16\x49\x2a\x7a\x93\x05\x83\x93\x3a\x16\x19\x90\x91\x99\x35\xaa\xd0\x88\xa2\x92\x45\x31\x7a\x27\x20\xbf\x0e\x1f\xfe\x6f\x3b\xfe\x0a\xe6\x61\x0c\x73\xf7\x3d\x72\xd7\xf6\x47\x1e\xbf\x73\x7b\x2b\x5c\x73\x42\x4d\x71\xc5\x3d\x67\xa8\xf8\x9c\xfd\xb0\x06\x16\xec\xc3\x0b\x26\xed\xe7\x5e\xc0\x0f\xe0\x85\x70\x39\x9c\x0c\x27\xc2\x4b\x59\xdd\xaa\x08\xfb\xe0\x0f\xf1\xbf\xf1\x7f\xf0\x8b\xb0\xbc\xfd\x2e\xfb\x55\xe2\x9f\xe5\x7c\x6d\xfb\x2a\x74\xe1\xb1\x03\xdf\xb5\x51\x3e\x4f\xc6\x93\xa5\x5c\x76\x16\xbc\xa0\x84\x46\x44\x54\x21\x1c\x0a\x01\x60\x2f\x2a\xc8\xb1\x0b\x42\x69\x59\x61\x7e\xc4\x17\x09\xc9\x3e\x62\x8a\xfa\xf2\x58\x76\x47\x41\x9e\xa6\xac\x89\x5d\xdd\xd9\x54\xd3\x39\xa9\x90\xc1\x58\x66\x32\xaa\x1b\x93\xe8\xac\xe7\x0f\xe0\x4b\xdb\x5e\x7e\x65\xef\xae\x33\xe7\x5f\x70\xee\xf4\x39\x0b\xa7\xc3\x91\x29\x06\xcf\xdf\x0f\x4b\xa1\xbe\x0f\x5f\xde\xf8\xac\x71\x12\xb8\x1a\xe8\x83\x39\xf8\x37\xfc\xe9\x17\x07\x0f\x7e\xf1\xd1\xfb\x6f\x27\x7d\x59\x7c\x7d\xf1\x02\xb5\xe5\xea\x3a\xae\x11\x17\x08\xbf\x11\x5d\x5b\x05\x4e\x88\x17\x47\x1d\xa5\x85\x15\x01\x8a\xe8\x55\xe8\xe0\x6b\xaa\x03\x85\x4a\x61\x73\xa2\xbc\xa0\xd4\xeb\x56\xdc\x15\xa5\xd6\xd2\xe6\x84\x88\xac\x3c\xb5\xb2\x53\x5a\xb7\x73\x9e\x54\x16\x3c\x13\x71\x07\x0c\x95\xc5\xb3\x40\x9b\x64\xc0\xa4\x15\x01\xb7\x47\x33\x60\x93\x7d\x34\x3a\xc5\x95\x18\xaf\x8b\x5c\x1d\x3c\x05\x96\xf8\x4e\xea\x1b\x3b\xd9\x47\xf8\x48\xdc\x8a\x3f\xdd\xe7\x9d\x54\x5b\x77\xb2\x0f\x7f\x84\x77\x3c\x73\xe4\x15\xfd\x94\x7e\xf5\x09\xfd\xcd\x6f\xbe\x79\xc3\x73\x6a\xbf\xfe\xa7\x7a\xde\xf8\x9a\x7b\x81\x08\x65\xa9\xbf\xbc\xb6\xb6\xdc\x8f\x2f\xc7\xaf\xbd\x88\xdb\xf6\x29\x7d\xfa\xd5\xf7\xc9\x81\xab\x61\xec\x07\xfc\x72\xb0\x6a\xd0\xa0\xaa\x3c\x58\xfd\xef\x6f\x61\x65\xa0\x7a\xc8\x90\xea\x00\x7e\x9b\xd9\xaf\xe5\x1d\x6b\xf8\xbd\xfc\xfd\x0c\x9b\xf6\xf8\x78\x51\xa4\x77\x6e\x71\x28\x37\xe4\xf0\xd3\xf9\x4b\x15\xb9\x21\x99\x98\xab\x65\x41\xab\x2e\x7b\x7b\x17\x5b\x8b\x1b\x29\xc7\x4a\x06\xc7\xd9\x03\xb4\xcc\x3c\x2f\x1b\xa9\xa1\xd5\x1b\x9c\x79\x35\x1a\x88\x33\x38\x2b\xe6\xea\x15\x93\x61\x63\xe2\x81\xc9\x70\xf9\xe1\xd7\x3d\x27\xf6\x8d\x9d\xe8\x79\xf7\xc3\x2f\x5e\xf5\x9c\x18\x8b\x35\x79\xde\xf8\xfc\xa9\x9f\xb4\x93\xeb\x6a\x27\xba\x2f\x59\x70\xc1\x25\xee\x93\x6a\xc9\x57\xbf\x70\xf9\xff\x86\xf9\x39\x7d\xea\xeb\x7b\xfb\xf0\x3f\x8f\xfd\x86\x0f\xf9\x7b\xd7\xd7\x96\xeb\xb0\xe8\x0f\xbc\xa2\xaa\x6a\xd0\x80\x8a\xc0\xbb\x8f\xee\x79\x3b\xb7\x62\x40\xff\x3e\xf5\x74\x9f\xce\xea\x38\x62\xcd\x97\xde\x01\xd5\x60\x04\x68\xa4\xf9\xb7\x9a\xf2\xb1\x23\x27\x80\x09\x7e\x24\x0e\x2a\xd0\x34\x87\x88\x4e\x6c\x1a\x51\x53\x33\x68\xc2\x84\xc6\x31\x83\x1a\x07\x35\xea\x0d\x0d\xfd\x5a\x12\x0d\x7a\xa0\x39\xa1\xf3\x2e\xb2\xd8\x2e\xb7\x8d\xac\xb2\xcd\x3d\x66\x0c\x42\x15\xe4\x98\x66\x60\x71\x75\x6e\xe3\xca\x4e\x17\x4b\xeb\x9f\x85\x3f\x69\x5a\x4b\x35\x46\xfc\xbc\xe7\x28\x2b\x55\xef\xc6\xa1\xae\xab\x37\xc3\xb2\x1c\xc3\x63\x26\x82\x31\x54\x7f\x24\x7d\xdd\x45\x99\x05\x15\xa9\xab\x8d\xd4\x0a\xa3\xc7\xaf\x3e\x11\xc6\xe1\x79\x77\xe0\x57\xde\xc1\x3f\xdf\xba\x15\xff\xfa\x2e\x7e\xe5\x76\x78\x1e\x8c\x4f\x5c\x3d\x6e\xcc\xf0\x73\x6a\xbf\xeb\x00\xd0\xf5\xd5\xe2\xaf\x87\x0e\xfd\x7a\xf1\x57\xd0\xd5\xf1\x7d\xdf\x19\xc3\xe1\x1f\xd3\x9f\x38\x7b\xfe\xd5\x23\x2f\xbc\xca\xbf\x34\x74\x68\xdb\xd0\x65\x8b\xe7\xee\x98\x92\xbc\xc1\xee\x8d\x9e\x37\x71\xbc\x30\x39\x12\xc0\xcb\xf0\x03\x87\xf1\x23\xbb\x67\xcf\x7e\x10\x8e\x65\x37\x63\x20\xb2\x21\xe4\xa3\xd1\x59\x7c\x0c\x3f\x33\x69\xc4\x88\x49\xb0\x01\xf2\x34\x96\xeb\x0b\xc1\xbd\xb5\xfd\x1a\x2a\x66\xcf\xdb\xf6\x48\xaf\x78\xff\x6a\x74\x46\xaf\x41\x7d\x07\x9c\x31\xea\x5a\xa3\xc7\x63\x72\xc7\x11\x71\xa1\xb8\x01\x44\xc9\x59\x3a\x0e\x5c\x1e\x1f\x59\x0d\x7a\x57\x96\x54\xa0\x8a\x4a\x1f\x6f\x19\x98\xab\x59\xb4\x91\x23\xaa\x07\x56\x56\x96\x83\x2a\xa5\x8a\x93\x51\xd5\xc0\xf2\xf2\x81\x55\x68\x08\x3f\xa4\xbe\x29\x21\x0f\xf9\x69\x08\x67\x45\x43\x7c\x5e\x45\x26\xaa\x52\xf6\xda\x89\xaf\x64\xf7\x22\x5e\x49\x61\xff\x33\xf5\x91\x6a\xb0\xf4\x51\xe1\x1b\x60\x7a\x95\x6a\xf6\x34\x37\xd5\x10\x3f\x1d\x85\x57\x63\x42\x23\x97\x88\xac\xaa\x9c\x48\x55\x4f\xe3\x00\xb2\x2b\x17\x66\x88\xb7\x07\xe9\x0b\x7b\xaf\xde\xbc\xe1\xa3\x79\x3f\x7d\xb9\x77\xd9\x8a\x27\xbe\xfc\x69\xde\x87\x1b\x37\x5f\xbd\x76\xdd\x29\xf7\x56\xf7\xb9\xef\xd4\x75\x6b\x93\xd8\x90\x22\xd2\x7b\x10\x31\x57\xf8\xd6\x73\x37\x2c\xfd\xef\xa3\xf8\x07\xfc\xf9\xc4\x89\x34\x21\xd8\x7a\x6c\xe9\x0d\xcf\xbd\xf5\xfe\x9b\x03\xfa\x94\x0f\x7a\x8b\x9f\x9f\x92\xdd\x92\x4c\x89\xb2\xfc\x05\xcb\x09\x88\xff\x22\x77\x91\xca\x30\x33\x9e\x17\x1a\xc9\x1d\xe6\x7f\x14\x36\x34\x08\xc5\x30\x4e\xc1\xe8\xe3\xb5\x61\x3d\x2b\xe7\xc1\xe2\xe7\xc2\x52\xf2\x1e\xcd\x78\x0f\x37\xcb\xcc\x79\x84\x42\x6a\x31\x0c\x83\xb0\xd7\xc6\x65\xe4\x3c\x66\xe0\x93\x85\x59\xe4\xde\xf2\x81\xbe\xf1\x3c\xbb\xcd\x07\x54\x9e\x07\x36\x94\xe3\x97\x5c\x6c\xea\x31\x0f\x69\x27\x09\x24\x97\xd4\x41\x43\xee\x7f\x85\x6d\x9c\xb9\x9d\xeb\x55\xee\x49\xfc\x05\x7e\x19\xce\x81\x71\x13\xde\x61\xe3\xb7\xf8\x28\x94\x7f\x2c\xed\x8d\x4f\x86\x5b\x82\xf0\x62\x58\x0f\x4f\x82\xcb\x19\xbe\x03\x7e\x1d\xff\x8e\x31\x3e\xe8\x4c\xb6\x19\x7e\x4f\x23\xf1\x7b\xde\xe5\xc7\x12\x9a\xaa\x89\xdb\x92\x41\x51\x23\xa5\x48\x81\x9e\x2c\x80\xef\x4c\x92\x52\x90\xde\x20\x13\x96\x97\x35\x93\xc1\x9f\x5f\x7b\x0b\x82\x6f\xef\xfe\x38\xf0\x84\x6b\xfe\xb9\x9b\xaf\xdb\xbc\x61\x70\x05\x9e\x0c\x6f\x23\x57\x68\x3b\x31\xf1\x73\x18\xec\xee\xb3\x6f\xbd\xf9\xa1\x96\x7c\xde\xa8\x63\x3d\x8c\xda\x85\x8f\x68\xf7\x62\x3c\xdf\x65\x93\x2c\x9a\xca\x13\x81\x5a\x6c\xbc\x87\xec\x24\x08\x65\x87\x48\x2c\x71\xd9\x2e\xa9\x12\xa8\xac\xd4\xd2\x2a\xb0\x87\x5b\x4d\x8a\x22\x81\x7c\x44\xdc\xd1\x7a\x81\x7d\xc4\x10\x6a\x2f\xc3\xb7\x8d\x87\x67\x95\xe1\x9b\x97\xdc\xbe\x1a\xdf\x5d\x06\xa7\x8c\xc3\xb7\x97\xc1\xd3\x2f\xbf\xed\x6a\x74\xfd\xa6\x69\xf8\xfb\xe6\x4d\x2d\xb8\x16\xfe\x36\x75\xd3\x34\xa8\x4f\xdb\xdc\x0c\x9f\xc5\x3a\x95\x0d\xbe\x83\xbf\x04\xb6\x08\x5f\x03\x1d\x38\x5b\x2d\xc8\xed\xa2\x5d\x75\x07\x6b\x8c\x69\x90\x61\x03\x7b\x98\xe2\x59\x86\x0d\x50\x4b\xd8\x72\x7c\x2d\xbe\x6b\x78\x45\xcd\xb0\xe3\x6b\xe1\x69\xf4\xb3\x70\x7e\xcd\x20\x4f\xbf\x41\xf1\xbe\xc6\x27\xf6\x3b\x9f\xe4\x5f\x81\x63\x85\xa7\x09\xaf\x9e\xc7\x78\x55\xb5\x43\xab\xd5\x0e\x2a\x19\xf9\x95\x2c\xea\x6a\x1c\x07\xd1\xf0\xb5\xeb\xd9\x2f\x1e\x9b\xe0\x6a\x6b\xc3\xc3\x8a\x17\xcc\x98\x7e\x6e\xdf\x53\x7a\x9d\x3e\xf2\xcc\x73\xf8\x57\xc8\xc5\xe9\x1b\xbd\x26\xe4\xa9\xb8\x8c\xfe\xde\x8e\xdb\xf8\xe3\xc1\x19\xc2\xab\xc4\x16\x73\xb5\x72\x1c\x58\x22\x80\xca\xdc\x57\xfb\x57\x92\x2b\x42\x8f\x78\xe8\x10\xce\xc1\xf0\x8c\xc4\xf8\x85\x91\x7c\xe1\xd5\x3d\xd3\x66\xc6\xe6\x8f\x5d\x07\xba\xbd\xcf\x62\xc9\x7a\x1f\xf1\x26\xd9\x21\x3d\x23\x10\x5d\x38\x3e\x21\xbc\xba\xee\x84\xd9\x03\x66\x4e\xdb\xc3\xde\x97\x7c\x5b\x18\xc8\x55\x10\xbd\xe3\x06\xca\x23\xa2\x73\x89\x9b\x18\x29\x95\xb1\x9a\x5c\x26\x9e\x1e\x0e\x35\x57\xd1\xc3\x71\x15\x86\x64\x1f\x43\x00\x2c\xed\x51\xbc\x03\x7d\x2c\x3c\x46\xe8\x71\x13\xaf\x87\xce\x54\x18\x48\x6e\x95\x09\x60\x46\xbc\x76\x64\x24\x7f\xcc\x90\xe1\xa1\xd1\xa3\xa3\xe3\x6a\x64\x5b\xbd\xa3\x6f\x5f\xb5\x7f\xa9\x00\xfa\x78\x72\xb8\x5e\xbd\xa4\xca\x31\xc3\xc7\xd5\xf7\xef\x93\x53\x59\x99\xd3\xa7\x7f\xfd\xb8\xe1\x63\x2c\x79\x43\x07\x79\xf3\x28\x08\x2f\x55\x51\x95\xe6\x7f\xe9\x00\x4f\x2c\x65\xf1\xc5\x62\x19\xaf\x51\x1d\x46\x31\x2b\x95\x58\x8d\xee\x4e\x7f\x05\xff\xf6\x2b\xd4\xc3\x6b\xd1\xf4\x57\x5c\xfb\xfc\xf9\xe7\x7c\xf8\xa1\xca\xfe\x6e\xbf\x96\x7d\xe2\xfa\xb0\x4f\x47\x57\xb0\x4f\x87\x8c\xd7\xae\x67\x9f\x92\x39\xec\x13\x7a\x6e\xe3\x46\xa2\x62\xb0\xc8\x3e\x71\x3f\xb2\x4f\x47\xff\xc9\x3e\xf1\xc5\x99\xff\xd6\x7e\x98\x7d\xfa\x37\xfb\xdb\x90\xe1\x4c\xbc\x14\xdd\x26\x7c\xd3\x4d\x86\xd1\xb8\x3a\x61\xdc\x88\xf8\x70\xad\x4a\x2b\x89\xe6\xeb\x79\x36\xd5\x6a\x61\xf2\xa1\x7f\x62\xd4\xdb\xa6\x5b\xd0\x97\x5e\x78\x95\xc6\xb7\x62\xa2\x1e\xd3\x99\xfd\x40\x0c\xc3\xda\x58\x94\x2e\xa8\x5e\x1c\xd1\x23\x88\xac\x2b\x71\x14\x4a\xa4\x12\x48\x96\xbb\xa4\x9e\xf8\x0e\x3e\x44\x2c\x10\x1a\x9b\x28\xa9\xa7\x88\x8a\x14\x09\xd4\x27\x8d\xc8\x0d\x9c\x35\x6c\x0c\xfb\x2b\x79\xde\xa2\xe3\xa6\x96\x9d\xd2\x74\x33\xbf\xd3\xfc\x62\xf0\xa4\xaa\x4a\xdb\x28\xb9\x7f\xed\x9c\xf6\x11\xe4\x4b\xeb\x48\xf2\xe5\x5c\xc7\xa4\xea\x89\xd5\xa3\x66\x0d\xa8\x9d\x83\xde\x9e\x54\x75\x52\xf5\xa8\x39\xfd\x6b\x67\x0f\x64\xef\x68\xdc\xc2\x7f\x66\x7e\x91\x0c\xb0\xdf\xd9\x97\xfd\x8d\xff\x9c\x4c\x7e\x70\xe4\xec\x7e\xe4\x3d\x12\x7b\xcf\x6c\xfa\x3b\x87\x18\xbf\x9e\xfe\xa6\x95\x93\xaa\x2b\xe8\x93\xea\x66\x1b\xfd\x6f\x78\xba\xf0\x81\x44\x6b\x51\xf3\xc0\x94\x78\xb5\xee\xf1\x10\x1f\x8e\x83\x39\xb9\xb9\x16\xd1\xe9\xb4\xd1\x9e\xfd\x40\x90\xf6\xbe\x39\x35\x5f\xce\x3c\xcf\x12\xcf\xcf\x1e\xe4\x59\xa2\x09\x0a\x10\x21\x62\x91\xd2\x03\xcc\x2c\xfb\x2c\xf7\xd5\xa9\x35\xfd\xd3\x8d\x3e\x3d\x87\x0f\x59\x37\x7f\x8c\x45\xd8\xfb\xd6\x5b\x61\x08\xc5\xa8\x9e\x8c\x71\x46\x6f\xff\xfe\x27\x77\xae\x5a\x2d\x26\x73\xe1\x29\x78\x8b\x7d\x9b\xa3\xad\xcd\xb1\xcd\x9e\xea\xf5\x3f\xd6\x3b\xf9\x04\xbc\xc9\xe8\xf7\x17\x8e\xc2\xf8\x0b\x2f\xe0\xfd\x46\xdd\x05\x7e\x89\xdf\x24\xfc\x4c\x08\x09\x80\xd3\xe2\x7d\x72\xf3\xf2\x44\xde\x6e\xb7\x48\xa2\x57\xd7\x35\x05\x00\x4d\xd4\xf2\x83\xfe\x5c\x7d\x89\x5b\x93\x91\xcc\x2b\xba\xc5\x1e\xb7\x4b\x13\x13\x76\x9d\x97\x99\x32\xa7\x48\xca\x0c\x20\x8f\x70\x50\xd3\x75\xee\x6d\x46\x1a\x28\x8b\x78\xd6\x7b\x11\x4d\xd3\x6f\x74\x61\x3c\xf0\xcc\xce\x6b\x2f\x66\x9d\x18\x70\x77\x27\x07\xb4\x2b\x63\xf8\x5b\xe8\xec\xf6\x73\x70\x29\xac\xe7\x36\xd4\x5f\xa7\xd0\xce\x8c\x0b\x33\x78\xa0\xa0\x70\x3f\x99\xf9\xde\xf1\xf1\x52\xb7\xc3\x22\xf2\x7e\xbf\x06\x15\x87\xf2\xff\x9e\xee\x4d\x49\x3f\x35\xe6\x96\x76\x87\xeb\x91\xce\x84\x6f\x24\x95\xf0\xe5\xb7\xb5\x3d\xf6\x58\x67\xb6\x77\x1b\x5f\xfe\x37\xc9\x5e\xa3\x47\x8b\x18\x5a\x3f\x10\x1d\x49\x6b\x5c\x08\x9d\x3e\xbb\x24\x20\xb7\x5b\x05\xb2\x5d\x0e\x06\x68\x75\x8e\xa8\x6a\x2a\x71\xbb\x34\x89\xfc\x91\xa1\xec\x26\x96\x95\x0e\xc1\xff\x44\xa7\x41\x66\x67\xc6\x37\x52\x9b\x2e\xd0\xb9\xae\x75\xe1\x42\xe8\x60\xa5\x2b\x0d\x8b\x60\x85\x51\x95\x23\xb8\x9f\x78\x62\x59\xf2\x30\x2b\xdd\x5c\xbb\xec\xd8\x2c\xa3\x12\x87\xf5\xcf\x0a\x16\x86\x9b\x92\x4b\xf6\x73\x95\x37\x07\x38\x78\xa7\xcf\x29\xfb\x6c\x6e\x37\xcf\x0b\x36\x21\x90\x07\x1c\x5e\x94\xe3\x72\x21\x37\x6a\x4e\xf8\x73\xdc\xe4\x8f\x20\x8a\x1a\xf5\xae\x04\xad\x3b\xad\x6a\x16\xae\x9b\x46\x67\x3d\x19\x48\xaa\x8c\x4a\x95\xc9\x95\x9c\x6e\xa4\x94\x41\xf2\x0d\x39\xf1\xbe\x3a\xbe\x74\xe1\x4e\x7c\x46\x1b\xd7\xf4\x03\xe4\x27\x2d\x98\x79\x01\x7e\x1c\xaf\x80\xcb\x2e\x1f\x77\xc1\xac\xe9\x5e\x6e\xd6\xa8\xe4\xc7\xc2\xd2\xcf\x5e\xbe\x6d\xce\x65\x2d\xf0\x5b\xa8\x26\xdf\xe9\x73\xe9\xe9\x73\xeb\x80\x39\xcf\x2e\xcc\x8f\x23\x3b\x99\xce\xed\xa8\xee\xd5\x5b\xe0\x78\x54\x84\x82\xa0\x48\x73\x3a\x5d\xc0\x55\x59\x61\xf5\x4a\xb9\xb9\xc4\x45\xca\x55\x54\xd9\x95\x27\x70\x65\xbd\xf9\x72\xbe\x9c\xa8\x9e\xc6\x04\x6f\xcc\xe6\x35\x29\xf6\xa7\x86\xc0\xf6\xcf\xc4\x56\x4e\x81\xc0\x2a\x84\xe0\x92\x8c\x49\xce\x25\xb1\x7c\xce\x98\x03\x6b\x38\xc1\x29\x54\x62\xc6\x4c\x70\xda\x19\x67\x4d\x9b\x7c\xf1\xd1\x49\x02\xdf\x2a\x3e\x00\x79\x81\xaf\xba\x75\xe9\x8b\x07\x9e\x5a\xb4\x62\xe6\xc5\x0d\x2b\x37\x9f\xd2\xef\xc2\xb3\x9b\x23\x5c\x21\xfe\x7e\xf5\x79\xa7\x9e\x5d\xf7\xa4\xe5\x0e\x9c\x10\xc4\xed\x75\x7c\xf5\x74\xf7\x59\x53\x89\x5f\xff\xe9\x17\xcf\x9c\xda\xb6\xf9\xdd\x97\x7b\x2d\x3e\x6d\xc6\x19\x26\x36\x08\x44\x7b\xa4\x00\x90\x40\x24\xae\x0a\x22\x40\x22\xb2\x58\x25\x9e\xf6\x9d\x0a\x1a\x04\x95\x9d\xfd\x82\x66\x49\x93\xd1\xbb\x21\xb6\x26\xef\x6f\x13\x96\xc2\x9b\x93\x2f\x1d\x0b\x08\x4b\xd2\x7d\x87\xc8\x46\xf6\xa4\x44\xb5\x3a\xf9\xbd\x22\x14\x2d\x56\x9e\x4e\x0b\xe0\xe4\x54\x67\x4f\x65\xc6\x6f\x0b\x9b\x4d\xed\x70\x58\x2b\xfc\xf0\x4e\xdc\x8f\x1f\x00\xd7\x25\xbf\x37\x6c\x00\x72\x6d\x50\x0c\x1e\xe0\xa4\xf8\x12\xa2\xcd\x66\x41\x14\xa3\xd1\x2e\xbb\xac\x4e\xe0\x6c\x49\x88\x64\x8d\xec\x1a\x83\x31\x42\xe9\xba\xe3\xac\x49\xc1\x5a\x7f\xf6\x0c\x64\x56\x2f\xb0\x7e\x8f\x08\xbc\x17\x5d\x95\xec\x07\xb7\xe1\x29\x6d\xf7\xa2\x62\x6e\xca\x16\x1c\x5f\x9f\x9c\xcd\xad\x37\xe8\xf7\x98\x7d\x93\x4e\x62\xf3\x15\x20\x49\x72\xd8\x04\x7a\xca\x5d\xb2\xc8\x62\xea\x88\x02\x65\x39\xb9\xa6\x84\x53\xb6\xe8\xa0\x33\x61\xd3\xf9\x54\xba\x23\x6b\x52\x9d\x95\xf4\x08\xb1\x4a\x29\xd6\x61\xf9\xca\x2b\xad\x8b\x16\xf1\x03\x96\xe1\xd7\x97\x27\x31\xc7\x2d\x87\xad\xc6\x33\xb7\x93\x7d\xd6\x4e\xce\x48\x88\xe2\xb4\xbb\x40\xc0\xeb\xf5\x59\x24\xc9\xe7\xcb\x05\xa8\x30\x9c\xaf\x36\x27\x02\xf9\xf9\x3e\xbf\x3f\x8f\x1c\x0f\x64\xf1\xf1\xbc\xbd\x39\xc1\xfb\xc8\xd1\x78\xce\x84\xe4\x4c\xd5\xfa\xf4\xd0\xad\x6d\x84\x52\x0d\xb8\x3a\x4d\x55\xd8\x5e\x62\x80\x57\x84\x38\x8a\xe2\xcd\xb7\xaf\xc7\x7f\x3c\xf0\x24\xc6\x83\x1e\xea\x73\xc3\xb2\x67\x5e\x7b\xf0\x91\x01\xe7\x9f\xd7\xbc\x0f\x6d\x4a\x16\xef\x7d\x1a\x5a\xa1\x06\xc3\x9f\xe0\xbd\xf7\xae\x59\x93\x7f\xea\x38\x18\x25\x46\xb2\xeb\xa8\xbb\x20\x9a\xac\xa6\xf8\x49\x4b\x4e\xc3\x3b\x19\xfd\xd7\x12\xfa\x73\x88\xcc\x42\x14\x65\xcc\x05\xf2\x74\xdd\x4b\xe8\xf7\x92\xb3\x4e\xe8\x0f\x6a\x8d\x89\xbc\x60\xd0\x4b\xd8\x69\x4c\xf8\x64\x8b\x85\xf7\xea\xbc\x9d\x9c\x8f\xbc\xf4\x9a\xfd\x0d\x03\x51\x8f\x11\x23\xa8\x37\x47\x9a\xb3\xba\xea\x34\xfd\xc4\xa5\xe3\x73\x16\xbc\x7d\xcd\x83\x6f\x54\x3c\x94\x7f\xf1\xf4\x75\x1b\x4f\xde\x72\xc6\x82\xe9\xad\xdc\xe9\x78\xe2\x82\x0b\xd6\x7d\x79\xe9\x94\xdb\xbe\xbf\x64\xf5\x1a\xe7\x49\x63\x9e\x7a\x74\xde\xb6\x49\x21\x7c\x26\x3f\xe0\x1a\xbc\x20\xf2\x8f\xcf\x0c\xb9\x07\xf0\x0c\x69\x3c\x91\x7b\x09\xb8\x34\x1e\xcf\x2b\xd4\x88\x8c\x43\x41\xad\xb8\xb8\x44\x44\x56\x59\x2e\x31\xf0\x91\x4a\x82\xa8\xac\xb4\x10\xe5\x89\x51\x03\x09\x89\xce\xad\x94\x45\x84\xc2\xd6\x70\xa0\x39\x11\xd6\x0a\x28\x1e\x52\x89\xa0\x19\xb5\x48\x95\x0d\x9d\x0e\x69\x1a\xef\x36\xbb\x5e\x40\xcb\xea\xd8\xfe\x3f\xb0\x90\x62\x6c\xc7\xfe\x4f\x78\x48\x1b\xe6\xb5\x56\xff\x2f\x88\x48\xc9\xcd\x14\x2c\x22\x85\x8a\x64\xcc\x74\x9f\xc1\x7a\x68\x99\x1c\x40\xd8\x1f\xcc\xcf\x8f\x38\xac\xb2\xae\x0b\x7e\xa2\xa2\x15\x59\xb6\xd9\xed\x42\x84\x88\x21\xec\x00\x56\xdd\x4a\x6e\x14\x51\x17\x9b\x12\x7e\xdd\x41\xfe\x94\xc8\x25\x85\x4d\x89\x12\x3d\x1a\xf4\xca\xb2\x60\xd7\x33\xe5\x90\x75\xc5\x80\xae\x82\xc8\x10\x86\x21\x07\xc6\xa6\xfa\xd7\x9d\xb0\x4c\x18\xe8\x1f\xb4\xf9\xf0\xef\x7a\x61\xdd\xe3\xef\x8c\x1a\xdd\x88\x7f\xdb\x0d\x8b\x63\x46\x8f\x09\x04\xc3\x69\x7e\x53\xd8\x08\x6a\xc1\xdc\xf8\x80\x52\x4f\x81\x3f\x1a\x95\xcb\xab\xf8\xfc\x02\x5a\x94\x04\x88\x46\x27\xee\x0e\xd7\x92\x88\x55\xc4\x4b\x75\x4d\x27\x37\xbf\xae\x17\x56\x54\x38\x5a\x12\x36\x9b\x58\xe1\xce\xcf\x2f\x2c\x24\x47\xb3\x90\xcf\x00\x12\xa9\xcc\x9c\xdd\xcf\x66\x43\x64\x73\x9e\x66\xd9\x4b\xeb\xa8\x98\x99\xfa\x7f\x63\x41\x31\xf8\x7a\x7a\x4b\xc0\xfa\xc4\xa4\xa5\xfa\x73\x47\x9b\xfe\x0e\x16\xea\xd3\xa7\x0b\x96\x2c\xb8\x60\x62\x07\x88\x2c\x6e\x1c\x2a\xdc\xf9\xf0\x5f\x22\x44\xdd\x7f\xc8\x7f\xe9\x89\xcd\x73\x0a\x8d\xbd\x50\x4d\xfc\x6e\xda\x17\x1c\x03\xf3\xe3\x03\xdd\xd1\xc2\x40\x30\x68\xb7\x55\x08\xde\xc2\x42\xa5\xac\x4c\x00\x36\xbe\x6f\x6d\xd4\xad\xb9\xc9\xa1\x76\xbb\x0b\xa4\x40\xa0\xa0\x20\xa7\x31\x51\xa0\x54\x13\x95\x58\x2d\xc5\x7b\x4b\xb4\x46\x89\x38\xe8\xf4\xee\x63\x09\xc5\xf4\x60\x8c\x14\xbc\x7b\x65\xb7\xf1\x55\x9d\xe2\x70\x9b\x60\xf5\xcc\x6c\xff\x3f\xda\x80\x53\xc2\xb8\x7f\xf2\xf8\xf8\x40\xdf\xad\x7b\x7b\xff\x55\x4b\xf0\xe6\x35\xe1\x85\x17\x9d\x73\x12\x6e\x2f\x1c\xdc\x30\x61\x14\x7f\xe9\xe5\x7f\xd5\x1f\x7c\xd9\x3d\xbe\x99\x93\x66\x9e\x1f\x4e\xe1\xea\xf0\xb7\x13\xdd\xe0\x03\x4d\xf1\x52\x8d\xf6\xdc\x12\xad\x2c\x59\x2c\xe4\x9e\xf7\xb9\xfc\x39\x3e\x8d\xd3\x89\x32\xe0\x34\x4e\x05\xaa\xa3\x39\xa1\x6a\xb2\x01\x47\x95\x39\x05\x07\x74\xce\x21\xc8\xd8\xef\x5d\x00\xa9\x32\x4e\x78\x16\x28\xd5\x86\xd9\xad\x15\x3d\xc0\x52\x65\x9f\x5e\x3a\x43\x7b\x06\xeb\x0d\xf6\x81\x93\xe2\xe5\x76\xcd\xc2\x51\x3a\x7d\xfe\x1c\x42\xaa\x22\xbb\x5c\x39\x3e\x9d\xd3\x9b\x12\x9c\x46\x3e\x18\xa9\x4d\x09\x55\x97\xa5\x74\xd7\x9c\xb1\x4b\x19\xa5\x30\x65\x5f\xff\x55\x2f\x70\x06\xa5\xab\xba\x1c\xb7\x1e\x3a\x82\x8d\xe3\x65\x76\x05\x77\xe2\x7b\xf9\x89\x15\x58\xe1\xf0\xf9\xac\x7e\xbf\x5b\x52\xe8\x08\x74\x59\x51\x3c\xbc\x27\x27\xd7\xcb\x11\xc7\xb0\x25\xe1\x76\x48\x56\xbf\xd5\x66\xb3\xfa\xc9\x3f\x09\x48\xe7\x0d\xcd\x6a\xb8\xca\x94\xc2\x54\x69\x44\x86\x5f\xa0\x75\x8e\xae\x15\x8d\x6e\x16\xd6\x8b\x37\x04\xa6\x30\xbf\x08\xdd\x6f\x0d\xa8\x6e\x6b\x8b\x97\x5f\x10\xbe\xf0\xe5\x34\xea\xd7\x95\x17\x70\x1b\x95\xe4\x25\x54\xc0\x32\x5c\x87\x5f\x2a\xd9\x09\x2b\x4c\xec\xaf\x99\x78\x35\xdb\x07\xa9\xde\x6b\x2f\xa3\x5b\xd7\xad\x5e\xd5\x2b\x39\x5d\x2e\x4d\xf3\x53\xe2\x79\x9f\xdf\x43\xe9\x6e\x4c\xa8\x84\x6e\x2f\xa5\xdb\x8b\x78\xa7\x20\xbb\xcd\x89\xda\x3d\xd0\xdd\x79\xbf\xf5\x4c\xb7\x6e\xb6\x5e\x23\x3d\x02\x17\x47\x03\xad\xad\xa5\x39\xe7\x7e\x6a\xb6\x5e\x7f\x74\x2e\xfc\xda\x82\x23\x54\xd2\x56\x78\xfc\x8f\xf0\x42\xb3\xf9\xfa\xc6\x3f\x09\xad\xbc\x29\xe3\x3c\x70\x72\xbc\xdc\xa3\xf2\x94\x4c\xe2\xb8\xe4\xc1\x1c\x2d\x27\x18\xb0\xf8\x5a\x12\x1e\xd5\x22\xe5\x81\xbc\x94\xef\xc2\xb9\x73\x34\x27\x35\x9e\x62\xcc\x67\xec\xbc\xb2\x62\x5d\xfd\x46\x73\x33\x98\x5e\x41\x37\x38\x35\x35\xc2\xbc\x97\x1e\x30\xd5\xb6\x31\xe7\x05\x77\x74\xc3\x55\xe3\x7d\x4c\xbe\x36\x56\x03\x4e\xe7\x54\x9e\x16\xaf\x50\x3d\x2e\x8b\xc5\xa0\x98\x10\x4c\xc8\x77\x6b\x5a\xd0\xe2\x23\x7b\xd6\x62\x71\xba\x73\x74\x4a\x7b\x13\xa1\x1d\x70\x4e\x99\x03\xa0\x13\xaf\xd7\x68\x95\x23\x5f\xc2\x58\x67\x89\xa7\x69\x61\xa7\x29\xa7\x36\x43\xd7\xc6\x76\x35\x62\x5b\xd2\x0a\xab\xf0\x1b\xdd\xfb\xdb\x97\x08\xfd\xd7\xaf\x5f\x96\xdc\xd1\xad\xc7\x9d\x7f\x94\xd0\x5d\x46\xfc\x9a\x43\x6c\xe6\x00\xf1\xbc\xb2\xf0\xea\x1c\x6e\x80\xbc\x3e\x17\x83\xaa\xb3\x73\x1c\x70\xba\x35\x09\x01\xbd\x39\x01\x50\x06\xae\x6a\xac\x7b\x1d\xa1\x49\x6a\xb8\x07\xf1\x86\xcb\xb8\x25\x3d\x08\x17\x37\xf4\x08\x59\xc7\x7f\x6d\xe8\xf2\x52\xb2\x1f\x26\xb0\x3a\xea\x51\xf1\x22\x4a\x23\xa5\xce\x47\x09\x05\x6e\xaf\x8f\x23\xae\xa1\x41\x9f\x2e\x11\xd3\xdc\x1c\x35\x98\x41\x5f\xe6\x11\xcb\x24\xae\x8b\x04\xc3\xa5\xf0\xe3\xee\xd2\xc3\x1f\xf6\x88\x0f\x80\x76\x99\x98\x65\xdb\x19\x56\xd6\xf0\x78\xc4\xe9\xb0\x49\xb2\xc8\x71\x08\xc9\x0e\xa4\x2a\x22\x24\x8e\x9f\x28\xf3\xb2\x8d\x22\xe1\x38\x2d\x3c\x42\xac\xe0\xa2\xb2\x27\x5c\xdd\x98\x09\xdd\x9f\xc2\xa0\x65\x1a\x8a\x3f\x3d\x29\xb6\xb5\x71\x47\xdb\xae\x6a\x5d\xd7\x09\x34\x7b\xac\x80\xea\xcd\x74\xbf\x2b\x3f\x99\xcd\xc6\x1e\x19\x2f\xa2\x8f\x96\x14\xc5\x66\x73\x39\x91\x53\xd5\xec\x36\xc5\x46\x1c\x67\x48\x3e\x44\x5e\xd1\x5d\x16\xde\x40\x4c\x31\x60\xcb\xca\x7b\xe8\x49\xcb\x26\xa1\xde\x30\x52\xca\x70\x4e\x2b\x2d\xf3\x87\x17\xdf\x79\x4d\x46\x27\xc7\x28\x2e\x65\x73\x50\x0c\xac\xc3\x0c\x0b\x68\x70\x3c\xe4\xb4\x00\xa6\x4c\x80\x0d\xc9\x2e\x89\x63\x60\x52\x56\xab\x83\xce\x70\x13\x10\x30\x34\x60\x8f\xfc\x33\x4c\x04\xf3\xd9\x74\x7b\xa7\x78\xe7\x16\xe3\x78\x27\xef\x5b\x8e\xe5\xa5\xfb\x8d\x6d\xcc\xb7\x19\x1c\x2f\x80\x76\xbb\x43\xe2\x2c\xbc\xc5\x81\x5c\xb2\x53\x86\x36\xda\xfe\x82\x2c\x0e\x1d\x89\xc4\xcd\x31\xb7\x42\xcc\x1c\xa1\x94\xb9\x51\x8d\xb6\x6a\xb3\x79\xde\xc4\x10\x80\x9f\xe3\xb7\x3b\x61\x04\xae\x69\x6f\x32\x78\x66\x6b\x3d\xd9\xb2\x97\xf0\x19\x06\x13\xe3\xe5\xb9\x0e\x29\x1c\xf6\xb8\xc9\x01\x61\xb3\x3b\x23\x85\xd6\x20\xe1\x95\x99\xd9\x1c\xad\xf6\xf3\xf0\x8a\xe2\x6b\x4e\x28\x06\xcb\x7f\xe7\xde\xc4\x52\xe5\x36\x06\x15\x75\xa9\xec\x5a\xb6\xaf\x23\x4a\x86\x44\xf8\x8b\xf6\x3e\x4f\x9d\x99\xae\xbe\xce\x09\x3b\x96\xf3\x5f\x1d\xa3\x15\xaf\x5f\x11\x5f\x06\x3f\xd2\xd5\xd5\x29\x8a\x25\xab\xd9\x0c\xbc\xc9\xe2\xdd\x84\x1b\x3a\x8d\xbb\x8f\x2e\xc1\x40\x20\x48\xae\xd6\x60\x28\x1c\x0e\x4a\xa8\x28\x42\x47\xa9\x43\xe2\x10\x14\x16\x16\x34\x26\x0a\x65\x59\xb6\x07\xc3\x3a\x1d\x20\x68\xcf\xeb\x94\xe2\x5f\xfa\x38\x86\x40\xcd\x21\x74\x7f\xe1\xec\x50\x6f\xfb\x35\xe6\xd1\x74\x77\x76\x70\x21\x91\x7a\xf2\x5f\xc4\xa9\xb9\xb1\xab\xb7\x83\x1e\x6a\x1f\x9f\xc2\xf3\x19\xd2\x71\x44\xf8\x44\xb8\x01\x94\x83\x7a\x70\x6a\x3c\xa6\x5b\xe5\xca\xca\x60\x6d\x11\x28\x2a\xa9\xe1\x73\x83\x56\x4b\xbf\xfe\x35\x25\xb9\x3c\xcf\x85\x42\xbd\x9b\x13\xa1\x90\xe6\xd4\x9a\x13\x4e\x5e\xf4\x53\x54\x4b\xae\x8c\xb8\xd8\x99\x25\x0a\x29\x88\xd3\x4c\xec\x01\xd3\x5f\x13\x59\x82\x8d\xac\x46\x5f\x2d\x55\xb0\xc1\xe9\x34\x9d\x5f\x5f\xcc\xd5\xf6\xd5\x52\xb3\xf6\x68\x34\x03\xd2\xc4\x8c\xc6\x72\xdf\xc5\xc2\x27\x33\x57\xdc\x74\xd5\x8a\xfb\xf1\xa7\xf8\xc5\x25\xdf\x6c\x59\x3e\x79\xc2\xa0\xc6\x8d\x3b\xdf\x7b\x7b\xd0\x84\xc9\x33\x9f\xbe\x7b\xfa\xcd\x13\xcf\x9d\x32\x78\xf8\xd4\x51\x78\xdc\xe4\xb3\xa7\x37\x4d\x6c\x6e\x2e\x1d\x34\x78\x30\xbc\x0c\xb6\x7c\x00\xc7\xec\xa8\x5f\x51\x88\x9f\xfe\x0d\x7f\x86\x3f\x76\xb7\xc0\xf8\xee\x1f\x61\x70\xe5\x6f\x9b\xef\xc3\x2f\x9e\xe1\xae\x44\x5b\x9f\xbb\xf3\x1e\xfc\xc1\xf1\xa7\x41\xfd\xd6\x5b\xdf\xa1\x72\x88\x74\x1c\xe1\x35\x7e\x2c\x28\x06\x35\xa0\x25\xde\xb7\x04\x84\x23\xfe\x2a\x57\x9f\x3e\x79\x1e\xab\x35\xaf\x2a\xcc\xf7\x8d\xf1\xfe\x08\xb1\xfd\xb9\xfc\x5e\x8d\x89\xfc\x7c\xd1\xe1\x50\xe9\xd8\x71\x91\x5c\x42\xa2\x97\x2b\x32\x47\x16\x75\x83\xfa\xee\x2a\x09\xe3\x70\x9a\xd2\x30\x2b\x35\x8c\xea\x15\x1a\xc9\xa9\xa7\x08\x5d\x6c\xd0\x87\x22\xf9\x6a\xea\xd3\x85\x0e\xbe\x21\x90\xd7\x46\xce\x3c\xf5\xc4\xa6\x19\xff\xfc\xed\xbd\xe7\x8e\x3f\x3e\x1e\xaa\x3d\xef\x92\x5b\xd7\xd7\x1c\x37\x6a\xdd\x85\x17\xaf\x59\x55\x75\x5c\xd5\xbe\xfa\x8a\xca\xbe\x75\x95\x15\xb5\x91\xfa\x68\x14\x06\xa1\x08\x15\xd8\x27\x6f\xb1\xe7\xc8\x2b\xaf\x7e\x84\xc6\x7f\xfa\x8f\x87\xbe\xf8\xec\x21\xfc\xe7\x06\x54\x02\x2f\xba\x70\xe5\xaa\x05\xe7\x3e\xdd\xb7\xef\x1e\x86\x15\x8f\x27\x33\xec\xb8\x12\x70\x61\x7c\x44\xb4\xa8\xc8\x62\x75\xf9\x51\x7e\xbe\xc7\x6f\xe5\xcb\x4a\x65\xb2\xdd\x51\x34\x1a\x0e\x03\xe2\xd1\xf2\x9e\x5c\x55\xf5\xb6\x24\xd4\xdc\x5c\x07\xb0\x28\x96\xb8\xa5\xd1\xb2\xd6\xb2\xd5\xf2\x86\xe5\xb0\x85\x28\x0b\xf2\xe1\x10\x9b\x13\x8e\x4c\x84\x78\x35\x56\xd9\x79\x58\xb3\x9b\x2e\x3a\xd5\xb4\x91\x17\x64\xcd\x15\x29\xdb\xbd\xd6\x70\x7f\x8a\xb3\x81\xe2\xbf\xc3\xed\x50\xfe\x06\x96\x6e\xdc\x32\x06\x27\x77\x31\x2f\x86\xfa\x3b\x07\xf1\x7b\xb7\x64\x61\xc5\xb3\xac\x74\x12\x3f\x0f\xa3\xe3\x6f\xd9\xeb\x65\x3e\xcc\x55\xcc\xd9\x79\x18\x8e\xfe\xa8\x13\x39\x1e\x82\xc9\xc4\xa7\x79\x99\xf8\x34\xa5\x60\x49\xfc\x44\x55\x51\x82\xf9\x11\xc1\x67\xb3\x01\x21\x9f\xef\x55\x56\xa0\x2e\x56\xd7\xa8\x87\x54\x3e\x14\x9c\x17\x5c\x12\x7c\x23\x78\x38\x28\x80\xa0\x12\x6c\x61\xdf\xee\x27\x2f\x48\x56\x04\x40\xb1\x54\x4c\x5c\x9c\xe2\xbc\x60\x30\x1c\xce\x6d\x4a\x84\x75\xa7\x87\xd8\x7c\xaa\x53\x91\xd8\x44\x99\x8c\x86\x93\xcc\x3e\xc8\xee\x52\x30\x3d\x9c\xe2\x74\x2f\x69\xc6\x84\x14\xda\x6f\x91\xf6\xf1\x74\xe6\xd7\x7c\xf6\xaf\x9f\x0f\x9b\xf9\xca\x35\x4b\x56\x5e\xdd\xb2\x54\x7e\x54\xdb\x7a\x49\x61\xa6\x43\x03\x43\xe4\x22\x56\x61\x01\xcb\x5e\xee\xfb\xfc\x83\x37\x66\xcc\x72\x2c\x7d\x20\x6f\xe1\x78\xc3\x95\x61\xf3\x21\x67\x50\xdc\x56\x60\xa7\xf9\x5d\x28\x22\xde\xc6\x8b\x16\xde\xe1\x04\x16\xab\x85\xde\x31\xbc\xc8\x6e\x5d\x03\xb7\x50\x39\xd0\x90\x55\xc3\x62\x04\xfc\x22\xe9\x11\x07\xab\x1f\xdc\x6c\x8c\x33\x38\xb6\x97\xde\xa8\xc6\xf4\x02\x08\x22\xc4\x0f\xb9\x8a\xf5\x53\xd4\xc6\xf3\x44\xbb\xc5\x8a\xac\x76\x48\x9e\x61\xb5\xdb\xc5\x26\x3a\x49\x06\x72\xe4\x4e\xe5\xe4\x8c\x46\x35\xe5\x40\xe6\x43\x0c\x08\x76\xc3\xc7\xb8\x04\xdf\x43\x41\x59\x16\xdc\xb9\x02\x3d\xb6\x6c\x59\xfb\xab\xec\xd2\x64\xb1\x39\xbe\x99\x61\x31\x16\xc6\x65\x1b\x84\x3c\xc7\xd1\x3b\xcc\xca\x23\x8e\xd9\x08\x5a\x7f\xc3\xbc\x8e\xa5\x20\x66\x60\x0c\xfa\xea\x61\x8c\xbb\x61\x1f\x1e\xf4\x16\x2c\xee\xd3\x07\x96\xbc\xc5\x8d\x36\xa7\x57\xef\x3f\x67\x3a\x37\xd4\x8c\x7f\x4c\x46\xff\x65\xfd\xea\xa1\xb8\xcb\xe6\x70\x10\xd3\xd2\xe5\x14\xad\x9c\x6c\x0c\xc9\xcd\xfe\xad\xac\x1a\xad\x81\x7a\x16\x2a\xbc\x03\x9f\x4d\xcb\xd0\x94\x01\x7f\xb4\xe1\xa9\x78\x32\xbc\x8f\xef\x97\x6c\x2c\x7d\xbe\xf6\x51\xee\xa1\x63\x07\xf0\x64\x90\x41\xb3\x02\xea\xe2\xb9\x36\x1a\x3b\x04\xc4\x2a\x57\x1d\x0a\xa0\x53\x6f\x05\xa2\x92\x5c\x9a\x64\x98\xe0\xd4\xea\x4a\x07\x12\xd3\xad\x97\xee\xb0\xc9\x05\x34\xaf\xdc\x21\x70\x24\x5e\x9b\xe2\x06\x5f\x43\xbe\x9b\xbe\x0f\x4f\xe7\x0e\x73\xb7\x1b\x2c\x25\x9b\x37\x51\x0e\x33\xf8\xd2\xe8\xb3\x1d\x36\x99\xd8\xcc\x8a\xe2\xf6\x28\x79\x22\x20\xcc\xb9\x58\xff\x97\x9d\xd5\x9e\xa7\x6d\xe8\x86\xac\x67\xc7\xc2\x9d\xdc\x9a\x4f\x3f\x0b\x0e\xc9\x64\x9a\x7c\xf7\x4c\x2b\x7e\x86\xdc\x40\x69\xbe\x57\xe1\xcf\x61\x41\x6a\xdf\x09\xc3\x98\x9d\x37\x21\xde\x0b\x01\xd1\xca\x5b\x04\x9e\x87\x9c\xcd\xe9\x74\x10\x53\xd9\xc1\x39\x14\x55\x24\x87\x8b\x4f\x9b\x7b\x52\x6a\x29\x2b\x3b\xa1\x6d\xb2\xf2\x3f\xac\x04\x99\x21\x00\x58\x59\x25\x98\xd5\xf0\x4a\xb9\x07\x71\xe3\xdb\x9c\x1f\xab\x6f\xc3\x95\xf0\xb2\xb7\x71\x3e\xbc\x69\x65\x6b\x1d\x37\x23\xb9\x89\xfb\x84\xbb\x2b\xf9\x3e\x57\x96\x3c\x23\xf9\x94\x61\x01\x42\xe0\x23\x7b\xf5\x57\x86\x77\x42\xe8\xa2\x40\x0a\x7f\x47\x17\xcd\x99\x10\xba\x8c\xe1\x4d\xff\xaf\x74\x41\x8c\x3f\x7e\x06\x2e\xc5\xd7\xbf\x40\xce\xa8\xe3\x25\x7c\x3d\xec\x75\xd6\x9d\x15\xf0\x49\x7c\x1c\xd7\x9b\x73\xe1\xd3\xe0\x5d\xc9\x7f\xe3\x93\x53\x36\x61\x35\x9e\x21\xf5\x67\xf2\x1a\x12\x0f\xf3\x4e\x8b\x60\xb7\xd9\x04\xce\x09\x04\x45\xb5\xf0\x4e\xbe\x39\x61\x77\x6a\x74\x4c\x10\x90\x4d\x67\xc2\xe8\xda\x3b\xd0\xa5\xe6\xcc\x84\x36\xea\x84\xbe\x09\x57\xf3\x37\x60\x0f\xf7\xfb\x9e\x5d\xad\xc7\x6e\xc4\xba\xb0\x74\xcb\xb1\xbd\x14\x24\xd6\x38\xbf\x86\x8e\x28\x26\x6b\x35\x8d\x1f\x48\x7d\x00\xf6\x6c\x8e\x3d\xdc\x09\x78\xe3\xd9\xe4\x08\x3b\x75\x51\xa6\xcf\x6e\xcc\x80\x54\xea\xf2\xec\x1e\x1f\x5e\x8c\xc6\xe2\x17\x4d\xec\x1d\xbc\x95\x1f\xb8\xba\xfd\x9d\x14\xc0\x0b\xf1\x06\x18\x9e\x30\x79\xf6\x00\xc2\xb7\x17\x0c\x8a\x17\x58\x45\xd5\xe5\x25\x36\xa2\x57\x44\x3e\x3f\xc5\x0f\x76\x38\x24\x8f\xd7\xab\x36\x27\xbc\x9a\x01\x20\x6c\xe8\x0e\x73\x60\x6e\xc6\x83\xbb\x63\x07\x1b\xb6\x78\x26\x7e\xf0\xea\xd6\x1b\xba\x20\x08\xa7\x1d\x03\x08\x46\xe0\xb7\x79\x1f\x5f\x0c\xfc\x74\x56\x35\xd9\x26\x1e\x44\x21\xad\x01\xca\xcd\xd1\x88\x4d\xac\x69\x48\x77\xc8\xc8\x4f\x8d\x3d\xb2\x17\x5e\x4b\xdb\xc7\x5d\xa8\x88\x18\x23\x45\x2b\x68\xc1\xb5\xee\xa1\x03\xb1\x18\x29\xbc\x6f\xc3\x86\xbb\xd7\xce\x79\xf2\x84\xd6\xfc\x86\x44\xbf\xe9\x77\xb4\x2e\xc0\x6f\xc3\x3e\x70\x67\xdf\xb9\xad\xff\x80\xde\x97\x56\x9c\x7e\x5c\x51\x1d\xfc\xbc\x7d\x4e\x06\xbe\xb2\x8f\xda\x9b\x22\x72\x78\xbd\x56\x9f\x4b\xd3\x54\xd5\x87\x90\x3f\xc7\xe5\x6e\x49\xb8\x5c\x56\x1d\xd0\x21\xcf\x0e\xab\x8f\xc6\x1c\x7c\x88\xd7\x34\x99\x37\xd4\x88\x19\x71\x30\x3c\xf9\x6e\x0e\x93\x71\x17\x9b\x62\xf2\x91\xbf\x53\x53\x50\x89\xa5\xc9\x4d\xfe\xe4\xe3\x7d\x8b\x16\x5f\x72\xd1\xdd\xfb\xf6\xb5\x9e\x77\x09\x7c\xe6\xe1\x3d\x54\x4e\x17\xcd\x42\xf0\x1d\x5c\x6d\x2b\xa4\x78\xcb\xb0\xbd\xcc\x86\x7f\x05\x99\xb8\x49\x8c\x4e\x89\xcf\xa0\x93\x67\x74\x36\x31\x3a\x89\xe1\xdd\xd8\x49\xa7\xa0\xe9\xb2\x20\xff\xaf\x74\x4a\x26\xa1\x59\x74\xea\x11\xb8\xbf\x6e\xe9\x9a\xd6\x75\xf3\x86\x5d\xd8\xda\xba\x70\xe8\x3c\x78\x31\x47\x31\x95\xf0\x9c\x4d\x36\xe2\xca\xbf\x27\x15\x1a\x48\x4b\x95\xea\xfb\xc6\xde\xbe\x97\xc8\xf3\x5d\xa6\x83\xfb\xc4\xbd\x74\x0a\x0a\x50\x2c\x8a\xaa\xd1\x13\xe5\x74\x92\x9b\x0a\x58\x52\x53\xaa\xca\xb3\x40\x9d\x3a\xe7\x83\xc4\x8c\xd9\x20\xbc\x6f\xc9\x8a\x07\x8f\xee\xdb\x07\x6d\xf7\xa6\xc7\x82\x08\x4b\x31\xcf\x86\x82\x74\x62\xfb\xfd\xc8\xb0\x17\xc6\x00\x73\xc6\xa9\xb8\x9e\xcd\x90\x2c\x03\xd3\xe2\xd5\x5e\xb5\x38\xc7\x29\x4a\x52\x49\x28\xe4\x54\x51\xaf\x72\xe0\xf2\xbb\x9a\x13\xc5\xb2\x1f\xda\x91\xdf\xed\x77\xdb\x02\x81\x48\x4b\x22\x40\x6e\x64\x9b\x0d\xd1\xd2\x43\x90\x65\x55\x98\xf5\xe3\xdd\x82\x07\xa6\x6d\x91\x1e\xbd\x43\x9b\x57\x69\x11\x10\xad\x92\xf0\x0c\x84\x9a\x31\x78\xde\x23\x11\x23\x4c\x0a\x17\xd3\xb4\x19\x04\xaf\xdd\xfc\x6e\xff\xdd\x27\xe2\x97\xde\xc0\x1f\xe2\x2d\x9e\xe1\x17\x5e\xad\x6e\xf7\x2e\x2a\xc9\x81\xd3\x61\xf8\x15\xd8\x77\xbb\x90\x6c\xfe\x04\x77\x38\xd0\x87\x1a\xfe\x9d\x9b\xff\x15\x3e\xba\xe2\xe2\x91\xdb\xef\x87\x27\xc3\xea\xab\x16\x0f\x18\x38\xb0\x66\x1e\xac\x80\xa7\x3c\x88\x9f\x3a\x58\xd4\xc0\xad\xc3\x7f\x7c\xf7\x2f\x68\x37\xf9\xe5\x93\xc4\xd6\x0a\x82\x22\xb2\x2b\x7a\xe7\x4b\xc1\x22\x00\x7c\x0e\x8f\x2c\x3b\x82\xa8\x38\x0a\x9c\x5e\x67\x63\xa2\xc8\xab\x7a\x55\x6b\x6e\x6e\x98\x66\x4e\x45\xd1\x6a\x45\x8d\x09\xab\xb7\x3b\xab\x3d\xb4\x58\xb0\xa4\x96\x61\x2c\x71\xe1\x42\x8e\xb0\x99\xe6\x92\xd6\x58\xaa\xba\x59\xe2\x03\xff\x7b\xd3\x86\x7f\x5c\x9b\x73\xeb\xe9\xf8\x9e\x6f\xff\x63\xeb\xdb\x41\x99\xcb\xd5\xff\x7c\x07\x7e\xba\x47\x5e\x7b\xd5\xb2\xcd\x22\xfc\x73\xcf\xcb\xd3\x46\xf7\xe9\x00\xc4\x84\x16\xbf\x1f\x3c\x84\x70\xf4\xf9\x91\xe4\xd3\xfe\x55\xf7\xdd\xb2\x6b\xb3\xe1\x33\xd9\xf0\x2b\x6c\xed\xa2\xa0\x37\x98\x1d\xef\x9f\xe3\x01\x65\x65\x01\xc5\xee\xe8\x25\x45\x22\x0e\xc5\xc3\xf7\xa9\x00\x6a\x1e\x51\x4c\x65\x72\x1e\x59\xbe\x3c\x6f\x9e\xd7\x59\x50\x50\xdc\x92\x28\x20\x76\x4f\xdc\xe6\x14\x45\xa7\x93\xac\xa1\xd3\xdd\xd9\x6a\x93\xab\x1c\xfc\x3f\x17\x32\x7b\x29\xe9\xee\x2b\xfa\x5f\x57\xf3\x78\xfc\xdb\xb3\x57\xe2\xdf\xf1\x73\xda\xff\xb4\x9c\x1b\x76\xbb\xf0\xa7\xb0\xc8\x03\x27\xc2\xc0\x5f\x2f\x2a\x95\xc3\xcb\x6c\x4d\x0b\x88\xd7\x34\x33\x5e\xef\xf5\xa8\xc5\x00\xe4\xb8\x6c\x76\xb2\x91\x43\x05\x05\x76\x97\xca\x97\x94\x02\xd9\x4f\xae\x86\x62\xba\x89\x1d\x64\x13\x37\x26\xa8\xa4\xe2\x56\x87\x48\x5c\x28\xd4\x94\x70\x78\xff\x42\x0a\x3d\x04\xc2\xba\x2e\x34\x6b\x5a\x29\xfa\x3f\x97\xfa\x14\xfc\xf1\x95\x78\xbe\xf6\xd7\x6b\xfd\x8d\x0f\x7f\x02\x8b\x4b\xe1\xe1\xae\xcb\xdd\xc3\x2c\x29\x36\x3b\x45\x2a\xd7\x8a\xd1\x0b\x06\x6e\x04\x37\x15\x0e\x64\x35\x94\x45\x45\x42\x31\x2c\x06\xc5\xbd\x85\x40\xaa\x86\xd2\xe8\x19\x10\x26\x32\x4c\xcf\x6f\xcc\x79\x17\x09\xb3\xe6\xb2\xa8\x48\xed\xfa\xf3\x46\x5c\x84\xef\x60\xb3\xca\x26\xc6\xcb\x42\xbe\x40\x30\xe8\x72\x01\x9f\xdb\xed\xb1\x48\x92\x07\x78\x8a\x22\x21\x9f\x4f\x6b\x49\xf8\x7c\x01\x1d\x59\x3c\x46\xce\xd7\x93\x91\xf3\x8d\x19\xa3\x99\xba\xd8\x21\x46\xa8\x96\xa6\x4d\x33\x63\x21\xb5\x7d\x8b\xc2\x66\x78\x39\x15\x59\xe4\x01\xdf\xb1\x11\xff\xb1\x7d\x1f\x8d\x86\x54\x6c\xb9\x7c\xef\x9b\x64\xdb\xfc\xf1\x42\x5b\x3a\x03\x31\xaf\x2f\xcc\x83\xb5\x6f\x3e\x89\x0f\xdd\xb2\x7e\x6d\xfe\xd4\x09\x90\x3b\xfc\xd1\x61\xd6\x17\x99\x8a\x37\xde\x5e\xe3\x63\x35\xe4\x9d\xf9\xdf\x08\x39\xf1\xe5\x2c\x7d\x48\x78\xf1\x7b\x3c\x3a\xe1\x45\x07\x7a\xb4\x28\xec\xf7\x93\xcb\xc0\xef\xd7\x83\x5e\x9a\x00\xd6\xbb\x25\x80\x53\x93\xa6\xfe\x92\x9d\xae\x81\x11\x36\x2c\xb4\x33\x37\xe1\x05\x7c\xce\xfc\xb7\xae\x33\x43\x23\xd7\xdf\x30\xe7\xd9\x4b\x97\xb4\xa6\x72\x14\x27\x15\x7f\x0d\xb9\x29\xb7\x7f\xb7\x88\x05\x47\xf6\x3c\xb6\xf8\xe1\xa9\x38\x94\x11\x9d\xbc\xb4\xc8\x8b\x7f\xa3\x7c\x68\x78\x3a\xeb\x53\xa7\xf7\x7f\x81\x5f\x77\x43\xd5\xaa\xba\xc9\xed\xef\x77\x37\x27\xfc\xe6\x9c\x0f\xaf\x98\x31\xe9\x83\xfa\x4a\x59\xc0\x5a\x7f\x31\xea\x83\x55\x29\xb1\x71\x1f\xfd\x5a\xae\xbb\x3c\x73\xdc\xc7\x13\x4f\xee\x5c\xb5\x91\x8d\xfc\x38\x15\xef\xbe\x26\x63\xe4\x87\x51\x60\x65\xdc\x5f\x76\xfc\x12\xff\x02\xbb\x67\x09\x5d\x3e\x2f\xa7\xf3\x6e\x87\x5b\x47\x84\x2e\x62\x97\xb9\x65\xab\x8b\x98\x64\x56\xf2\xf2\xc4\x04\x67\xc2\xf1\x1c\xe8\x42\x16\xa5\xcb\x1d\xe9\x01\x3e\x35\x86\x50\xe2\xda\xcb\xbb\x43\xa8\xee\x78\x06\xbf\x04\xeb\xbb\x83\xec\xd0\xaa\x29\x33\x3f\x36\x99\x61\x99\xfb\xc0\xc8\x78\x04\xf8\x7c\x36\x8a\xd4\xee\x12\x45\xd5\xa6\xfa\x73\x58\x7d\x9a\x53\x26\xb6\x93\xcd\xe3\x21\x2a\xd0\x63\xeb\xba\x73\xbb\xae\x73\x75\x95\xc0\xb6\x6a\x4e\x46\x28\x55\x01\x61\xb2\x85\xe1\xbc\x8a\xed\xab\xdf\x79\xd2\x8c\xe9\xe2\xd7\xf1\x17\x2f\xe2\x23\xfd\x67\x4c\x19\x0f\x01\xf1\xc0\xae\x4b\xc7\x77\x67\xe1\x7d\x78\xe7\x4d\xeb\xcd\x39\x91\x0c\xc3\xc5\x07\xc6\xc5\x8b\x29\x4d\x29\xfa\x54\x5b\x8e\x1f\x00\x8f\xcd\x43\xee\x1b\x4f\x9e\xd3\xd2\x44\xa8\xb4\xc9\x76\xd9\xa6\x83\x86\x74\xac\xd3\x74\xdf\xff\x8a\xc4\xba\xda\x8c\xa1\x67\xc6\xb8\x46\x78\xbc\x7b\xd6\xcc\xcb\x2f\x32\x43\xbe\x87\x9e\x7f\xf8\x60\xe1\x92\x49\x27\x3c\xf4\x08\xbc\x3b\x1d\xf8\x15\x0e\xe1\x3f\x57\xdc\xc8\xe4\x36\x5d\xf8\x80\xd9\xf8\x83\xe3\x05\xb2\x8b\x73\x5a\x05\x41\x74\x8a\xaa\x62\x25\xd6\x88\xd5\x2a\xda\xd9\xd0\x4c\xce\xc9\x66\x73\x19\x6b\x99\xb6\x32\xd3\x85\x03\xa9\xe5\xec\x0c\x7c\x23\x7e\xde\xaa\xcd\xa6\x8c\x1e\x7f\x12\x4f\x87\x37\x65\x84\xbe\xc9\x56\x32\xe3\xde\x2f\xf1\x9b\x98\xdf\x33\x3c\x5e\xc8\xd9\x6c\x92\x28\x40\xa7\xd3\x25\xb8\x54\x05\x3a\x68\xf8\xd7\x86\x64\xd9\xa5\x5b\x88\xe1\x3f\x31\x61\xd3\x53\x5b\xbc\x87\xe7\x67\x80\x6b\xb2\x02\xbc\x34\x96\xec\xde\x67\x76\x5e\x7b\x5d\x3a\x10\x6c\xd4\xd8\xa5\x63\xc1\xc4\xce\x67\x76\xad\x97\x4e\x9d\xb5\x5b\x74\xaf\x02\x21\x31\xf4\x2d\xc4\xd0\x77\x09\xcd\xd4\x58\xf4\x7a\xe2\x1e\x62\xd5\x7a\x34\xd5\x6a\x5a\xfa\xb9\x7e\xe5\x60\x96\x91\x6d\xc6\x19\x63\x6a\xf7\x49\x21\xc4\xd6\x3f\xfb\x9a\x0c\x63\x7f\x63\xeb\x56\x38\xa5\xcb\xb8\x10\x36\xaf\x8c\xda\xae\xc4\x07\xdc\xc2\x72\x23\xc4\xe7\x80\x1e\x9b\x5d\x20\xa6\xa0\xc5\xee\x41\x5e\x1f\x52\x1b\x13\x08\x59\x45\x5d\xb6\x12\xa9\xd8\x29\xf8\xc3\xc1\xee\xc6\x7e\x2a\x36\x92\xc6\xfd\xa4\x6b\x91\x85\xfd\x79\xd9\x9d\xb3\xba\xa0\x7f\x52\x30\x73\x78\x82\x89\x00\xca\xf6\x82\x78\x80\xdd\x01\xa3\xe2\xd1\x1c\xaf\xd7\x17\x16\x04\x0e\x02\x10\xf4\xa1\x48\x51\x21\x0a\x6a\x56\xe4\xf5\x23\xa7\x57\xe3\x84\xb8\x00\xe8\x38\x31\x90\x2a\x90\x64\xe6\x73\x3a\x2c\x9f\x21\x16\xa3\x1e\xb2\x01\x4a\x2c\x43\x53\x01\x2b\x61\x01\x53\x95\x30\x1f\xfa\xd8\x7c\x1d\x91\x7b\x8e\xe8\x9c\x75\x16\x68\x2d\x2d\xc1\x1b\xae\xc4\x6b\x6c\xc7\x09\x22\x8f\x76\x1c\x83\x0b\x3d\x51\xd1\x42\x3c\xd7\x79\xbf\xdf\xcf\x8a\x3b\x77\x5e\xb6\xa6\xa0\x70\xd5\xcc\xf6\x38\xda\xef\x7f\xdf\xab\xcd\xdb\xdb\x7e\x92\xb0\xb4\xbd\x72\xe0\x55\xf9\xa5\x77\xea\xe8\xcd\x54\x2e\xe5\x25\xe1\x76\xd6\x9f\x4a\x78\x70\xe9\xba\xa6\x2a\x29\x48\x65\xe2\x36\xe9\x71\x5d\x99\x98\xd0\x75\x97\x6c\xe7\xfc\x44\x4f\xcb\x06\xa4\x32\x23\xde\x64\x25\xd3\xea\x8f\xf5\x08\xaa\x6c\xf0\xd4\x03\xb0\x32\x2d\xf0\x5c\xd4\x1d\x5c\xd9\xac\xec\x7c\x67\xfe\x05\x06\xc6\x14\x1c\xc2\xec\xf1\x09\x9d\x73\xea\xc4\xdf\xb4\x62\x3a\xa7\x4e\x95\xac\x3c\x5c\x64\xdc\xd3\x1c\x1d\x5c\xca\x79\x78\x4f\x80\x97\x32\xee\x75\x36\x07\x41\xf8\x27\xf9\xf9\xe3\x58\x2f\xe0\x4d\x50\x36\x70\x02\xab\xab\xd5\x62\xae\xef\xe3\x1d\xef\xb4\xf6\x1d\x80\xf2\xb2\xfa\x2f\x8c\x67\x3c\x94\x7e\x06\x84\x73\x52\x38\x81\x7e\xbf\x50\x8c\x38\xaf\xe8\xf5\x18\x4f\x31\x9a\x07\xd3\xcf\xb9\x24\xf5\x1c\x70\x1e\xf8\xc5\xe8\x39\x44\x5c\xbf\x7e\x14\x5b\xb0\xee\xf1\x8e\x37\x5a\xeb\xfa\x1a\x8f\xea\xec\x55\xa4\xd3\x8d\xee\x61\x76\x8b\x31\xc7\x6e\x18\xf1\x37\x9e\x61\x58\xc9\xf7\x64\xcc\x5c\xfd\x2d\x35\xa7\x95\xf0\xbb\xc5\xc0\xcc\xa2\x03\x55\xa1\xfc\x78\x07\x6e\x95\x7d\x5d\xe6\xb4\x1a\x38\x87\xff\x4c\xe1\x1c\x12\x9e\x3d\xa6\x8c\x28\xcc\x21\x17\x14\x83\x91\x4e\x64\x44\xf2\xf3\xd3\x3a\x8e\x08\xdb\x85\x1b\x14\x11\x36\x65\x62\xf4\x2b\x22\x97\xc7\xbe\x67\xff\x4e\xe5\x41\xff\x9d\xc9\xe3\xc1\x14\x6f\x25\x25\x54\x1e\xd1\xc7\x3b\x7e\x6d\x8d\x46\x82\x7a\x36\x6f\xff\x1f\x67\xdf\x01\x1f\x55\x95\x3d\x7c\xef\xbb\xef\xbd\xe9\x7d\xde\x94\x4c\xca\x4c\x26\xbd\x42\x26\x85\xd0\x32\x08\x22\x4a\x31\xf4\x0c\x10\x40\x04\xa4\x48\x91\x5e\xa4\x8b\x34\x01\x05\xa5\x89\x80\x88\x0b\x22\x22\x60\xc0\x28\x2b\xc8\xaa\xa8\x60\xc1\xb5\xaf\xba\x2a\x02\x4a\xb1\xe1\xae\xab\xc2\xbc\x7c\xe7\xde\xf7\x66\x32\x49\x70\xff\xfb\xfb\xcc\xae\x26\x93\xbc\x77\xcf\x39\xf7\x9c\x73\xcf\x39\xf7\x94\x78\xbf\x45\xfa\x1e\x46\x93\x0b\xb1\xe7\x02\x01\x4a\x93\x34\xfa\x5c\x5a\x8a\xdd\xd8\xf4\x39\x66\xbb\xd1\xf5\x14\xdb\x4d\x87\xb9\x09\xb1\xfa\xcd\xfc\x7c\x5a\xf7\x99\x5b\xdf\xd0\x50\x97\x9b\xad\x18\x64\x4d\xea\x3e\xc1\x86\x9b\x1b\xb3\xe1\xd0\x38\x3c\x1e\xa9\x13\x44\xf3\xf3\x69\xdd\x67\x2e\x6e\xfa\x10\x3c\xc3\x66\xca\xb1\xb5\xde\x50\x71\xcb\x8d\x3d\x53\x5c\x4c\xd7\x2a\x74\x14\xe6\x93\xcc\x26\xcf\xb0\xde\xfb\x6c\x9d\xef\x54\xbc\x1e\x88\x3d\x53\x50\x40\xd7\xc9\xd3\xe6\xe5\x90\xf4\x26\x7d\x24\x7b\xc2\x3a\xf7\x83\xae\x48\xa2\x79\x1e\x3c\x71\x9a\xcd\x36\x8b\xc3\xa1\x73\xbb\x6d\x84\xf8\x92\xcd\x4e\xa7\x69\x78\xc4\xe9\x44\x36\x87\xd5\x66\xa5\x76\x0a\x1d\xbb\x15\x9f\x4c\xa7\xc6\xa6\xd9\x38\xcc\xa6\xe6\x76\xac\x15\x52\xb3\x71\x74\x2c\x1a\x8b\x95\x1b\x29\x6e\x66\xe2\x04\xba\x2a\x5c\x7f\xfd\x23\x5e\x2b\x57\xbc\xf3\xe3\x82\x2b\xca\xe0\xb9\xc7\x97\x2d\x5d\xbf\x0e\xaf\xd9\xfa\xa4\x7c\x8f\xe1\xf3\x43\x4b\xce\x4c\xa7\xb4\xec\x02\x36\xa1\x81\xf6\x73\xe6\xfa\x25\xcc\xbf\xdc\x1a\x9b\x07\xc7\xad\xc2\x8f\xe2\x5b\x99\x7d\x6c\xb1\xd0\x79\x70\xc8\x6a\x6b\x9c\x7e\x19\xef\xf5\xd6\x37\xd6\xeb\x0d\xfe\x9e\x57\xed\x69\x8b\x85\x36\x7b\x33\x59\x6d\x8d\x9d\xde\xe2\xef\x3f\x14\x7b\x3f\xec\xc3\x86\xd8\x9e\x4b\x12\xdd\x07\x47\x7d\xc3\x1f\x75\x0e\x75\x91\xc6\x3d\x57\xd6\x99\x1b\xef\x29\x37\x0e\xfd\xa7\xf1\x39\x9b\xf2\x5c\x03\x3c\xa7\x2c\xd6\xf8\x1c\xab\x81\x67\x32\x5e\xa2\xae\xf7\x55\x4c\xc6\xd3\xd3\x29\x4f\xfb\x35\xfe\x54\x2d\x6a\xb2\xef\xac\x86\x9c\xc9\x78\x1f\x75\xad\x68\xec\x19\x5a\x57\x4c\xb8\x64\x4d\x72\x92\x98\xf0\x4c\x93\x5a\x7b\x09\xf8\xba\x2a\xec\xf7\x3a\x1c\xda\x24\xbb\x1d\x69\x51\x4a\xaa\x17\x0c\x53\xaf\x97\x37\x18\x5c\x37\x2c\xb0\xf7\x14\xff\x9f\xa5\xf5\xa8\x22\xa0\xd4\xd4\x07\xb2\x32\x6e\x54\x49\xff\x2d\x26\xa6\xeb\x0e\x0b\xd6\x9c\xfd\x54\x8e\x7a\xc9\x05\xaf\x7c\xfd\x06\x95\xf3\xd8\xfc\x9f\x1f\xe5\x4b\xfc\xd4\x9f\xbe\xf8\xec\x6a\x93\x5a\x79\x1b\xe8\x27\x80\xd9\x05\xfe\x80\x64\xb1\x88\x48\x4c\xf2\x4a\x96\xde\x70\x20\x10\xad\xd6\xce\x2a\xe4\x0d\xcd\x2a\xe4\x6f\x00\x73\x42\x71\x3c\x6d\xae\x9b\x8a\x1d\xb4\x45\x55\x11\x6e\x2c\x87\x97\x5d\x9b\x56\x6b\xa2\x87\x35\xab\x36\xad\x59\x6d\xe2\x6e\x31\xdc\xd7\xb4\xfe\x3d\x5a\x7a\xe4\xf5\x63\xc7\x49\xcd\x93\xcf\x1d\xd8\xd3\x64\xef\xe8\x5c\x78\xb6\x77\xff\x54\xf6\x81\x27\xd4\xb9\xe3\x49\xba\x90\xee\xff\xb3\xbd\xe3\xb7\xa8\x7b\xf7\x47\xec\x19\x5a\x54\xc7\x13\xda\xfb\x55\x6c\xfa\x0c\x9b\xd7\xc4\x78\xf2\x9f\xea\x3a\x0f\xc5\x78\x8b\xae\xc3\xe1\xf4\xfa\x86\x73\x75\xe9\x7e\xab\xbe\x29\x6f\xb1\x5e\xc7\x8c\x27\x65\x75\xad\x83\xb1\xe7\x82\x41\xca\x93\x01\xca\xcb\x81\x34\xe4\x6a\xf1\x9c\x90\xc6\x64\xec\x03\x55\x66\x66\xa9\x32\x46\x45\x00\xbb\xec\x2e\x77\xe3\xbc\xd8\x78\x6f\xc4\xbe\xb1\xde\x88\xdc\x2a\xf4\x86\x2a\x63\x1e\x0f\xed\x8d\x68\xf2\x26\xe9\x12\xf5\xbc\xf2\xfe\x43\xb1\xf7\x03\x3e\x0b\x62\x7a\xcb\xe7\xa3\xf8\x78\xdd\x5e\x75\x85\x38\x0d\x94\x35\xe6\xc6\xd6\x00\x5c\xde\x88\x3d\xa3\xd4\xd2\x27\x1b\x92\xd5\x55\xe2\xcf\x28\xeb\xfc\x1c\x5f\x87\xe0\x7b\x63\xcf\xa4\xa5\xd1\x75\xa4\x31\x52\xea\x0d\xd7\x39\x17\xc7\x65\x3b\xfa\x38\xf6\x4c\x7a\x3a\x5d\xc7\x33\xd1\x13\x68\xb6\x0e\x8b\xb3\x32\x7c\x3e\x51\xf1\x99\x1c\x7b\x26\x29\x89\xae\xe3\x31\x7a\x5c\x1a\x5b\x93\x67\x58\xcc\x93\xed\xcd\x6f\x2a\x3e\x7f\x8f\x3d\xe3\xf5\xd2\x75\xdc\x7a\xb7\x64\xd3\x36\xd1\xdd\x34\x97\x90\xe6\xb1\xeb\x50\x51\xd8\x23\x88\xc0\xfb\x22\x22\x06\xbd\x8e\xa3\x97\x6f\xa2\x56\x4b\xe2\x93\xd7\xd8\xe5\x5b\xc2\xa5\x58\xec\x46\xcc\xc6\x17\x47\xdb\xac\x3a\xb8\x59\x58\xbc\xf5\xda\x8b\x6c\xd6\xdb\x62\x25\x8f\x85\xe5\xaa\xb3\xf7\x12\xad\x00\xf2\xa5\x25\x7a\x83\x8e\xeb\x1d\xd1\x59\xe8\x7b\x7b\x47\xb4\xd2\x7f\x7f\x2f\x4d\x4b\x9f\xf6\xc4\x52\x3a\xfb\xe0\x2d\xa5\x21\xbe\x3a\x67\x72\x02\xa3\xcb\xe7\xea\xf9\xd9\x45\xe1\x3f\x9e\x50\xfa\xf3\x24\xa5\xbe\x21\x5a\x97\xe2\x13\xdc\x2d\x74\xa9\x50\xc2\x68\x73\x5d\x3d\x3f\xb7\x34\x3e\x67\x53\x9e\x93\xe1\x39\x6d\xe2\x73\x34\xcf\x1f\xce\x0a\x4a\x1f\x2f\x8d\x23\x5b\xbd\x5e\xac\x37\x9b\x9d\x02\xc1\xd8\xa8\x21\xbe\x24\xbb\x7b\x58\xc4\x6e\x22\x3c\x19\x1e\xd1\xf3\x3c\x16\x45\x1d\x2d\x0d\xc1\xe6\x61\x11\xdc\x74\x5c\x5d\xa8\xe9\xac\xea\x50\x62\x7f\x36\x96\x83\x1f\x2b\x02\x00\xd7\x32\xa0\x5e\x3e\x63\x69\xc2\x53\xf1\x7a\x80\x88\xfc\x6d\xbb\x5b\x4b\x6e\x9e\xcb\xad\x5f\xaf\x94\x05\xc8\x5a\x50\x23\x9f\x58\x77\xd8\x1f\x66\xb6\x2e\x92\x07\x32\x7a\x7b\xd1\xd0\x70\x2b\x80\xd1\xed\xf6\x62\xbb\xdd\xab\x35\x1a\x89\x57\xf0\xfa\x92\x0c\x98\xc3\xa0\xd4\x38\xce\xcb\x7b\x8d\xd5\x11\xaf\x64\x95\xaa\x23\x56\x1f\xaf\xe9\x1d\xe1\x2d\x2d\xb2\x06\x42\x37\xca\x25\x52\xef\x6f\x62\xd0\xd2\x64\xbb\x46\x68\x3b\xe0\xe0\x9a\x39\x73\xb8\x00\xad\x24\xe8\x2b\x7f\x1b\xba\xb5\x75\xc7\xf9\xc3\x58\x1d\x01\x2d\x29\x90\x37\xab\xc0\x3e\x34\x87\xdd\xbd\x0d\x14\xba\x33\x7b\xe1\x96\x70\x96\xe8\x91\x2c\x76\x01\xec\x69\xb7\x01\x39\x1d\x60\x22\x20\x5b\xb2\xcf\x45\x2c\x76\x8f\xc4\x5b\x9d\x84\x80\xbb\x4e\xac\x40\x4c\x96\xa9\xab\x3a\x16\x4d\x86\xf3\xd0\xbb\x2d\x21\x7e\x65\xcf\x22\x30\x09\x57\x5d\x2e\xa1\xfb\x8e\x85\xed\x6e\x6d\xdb\xa1\xac\x73\x5a\x7f\x79\x6d\xf3\xab\xb8\x2f\x7b\x3c\x31\x6d\x9d\x75\x87\xd4\xbe\x2a\xe5\xd6\x7b\x39\x6f\x93\x3b\xb9\xc1\xd3\xd9\x7d\xdc\x40\x22\xb3\x3e\x67\x5d\xc3\x59\x76\x8b\xe4\x11\x9b\xc3\x0a\x22\x13\x21\x3e\xc9\x63\xb7\xf0\x36\x97\xc3\x62\x53\xfc\x75\x77\xa5\x92\x58\xfd\x7f\x81\x4a\x12\x40\x25\xf2\x43\xb3\x00\xd4\x36\x95\x6d\x33\x26\x9e\x6c\x7e\x39\xd7\x65\xc0\xa6\x79\x0f\x03\xa4\x9d\x4a\x32\x07\x3f\x85\x8b\x9a\xdc\xd2\xb5\x9e\x8b\xd4\x19\xe5\x74\xfe\x26\x9c\x6c\x7d\xc2\x39\x58\x2f\x9a\xcd\x06\xa3\x91\x0e\x9b\xd7\x6a\x39\x62\x23\x0e\xbb\x55\x10\xc1\x97\x35\x61\xa2\xd7\x8a\x22\x31\x68\x09\x22\x6a\x06\x2b\xed\x7b\xa7\x76\xbe\x6b\x04\x3a\xf6\x3f\x96\x5e\x17\xa0\x9d\xcd\xe9\x64\x45\xd6\xe4\x02\x18\x00\xf3\x35\x72\x04\xe8\x89\xff\x29\xef\xc1\x03\xe5\x1e\x2a\x4d\xfb\xe2\x5e\xf2\x8b\xf8\x1d\x76\xbf\xf9\xd0\x26\xae\x86\x11\x73\xcf\xa6\xe8\x24\xc5\x27\x53\x67\x69\x28\x30\xea\xf1\x8d\x61\xac\x4e\x80\xd1\x82\x88\xf4\xff\x0f\x23\x09\xc8\x5f\x50\x4a\x56\xcb\x6f\xe1\x56\xf2\x49\x95\x9a\xaf\xe1\x72\xf9\x0d\xdc\x8f\xde\x75\xe2\x0b\xeb\xf0\xdf\x28\x19\xe5\x8e\xeb\xe4\x24\x25\xb6\x5e\x03\xba\x77\x0b\xcb\x49\xb0\xa3\xd2\x70\x92\x11\x09\xb4\x9b\x9d\xd6\xe1\xe4\x6d\xd4\x70\xd5\x89\x3a\x10\x70\x9d\x5d\x24\xa8\xea\x46\x86\x01\x6d\x31\xd1\x11\x87\x58\xe9\x50\x7a\x46\x05\x2b\xf6\xf2\xd7\x4c\xfd\x7c\x03\xde\x76\x3c\xfa\xec\xf7\xf2\xf5\x97\x71\x37\x3c\x57\x9e\x27\xbf\x8c\xf7\x2c\x3a\x39\x81\xcb\xfc\x63\xc1\x3f\xdf\x92\x7f\xe4\x0a\x90\x72\x96\x93\x1f\x99\x4f\x78\x0b\x83\x65\x70\xc3\x15\x76\xef\x6a\x40\x59\x34\x9b\x33\x35\x60\xf4\x7a\x5d\x1a\x4d\x00\xd9\x03\xf6\x9c\xec\x0c\xdf\xf0\x48\x86\x23\x2d\x4d\x92\x40\xf1\x18\x25\xc9\xe2\x26\x16\xd0\x45\x96\xc6\x31\x8f\x95\x8d\xf7\x16\x8d\xcd\x76\x95\x56\xf5\x2c\x84\xdd\x11\x77\xc0\x81\x74\x91\xc5\xde\x32\x94\xd1\x7c\x20\xd4\xb1\xde\x50\x34\x64\x80\x7d\xbb\x37\xdf\xfb\x6c\x7f\x79\xf9\xae\x5d\x84\xeb\xf1\xdd\x53\x67\xe5\x28\x16\xae\xe0\xb5\xc7\xaf\xcd\xbf\xe7\xf0\xf9\x63\x0f\x9c\xc0\x1b\x97\xae\xea\xbd\x75\xe2\xc1\x25\xf2\x53\x23\x06\x9e\x3d\x7a\xec\xef\x5c\xbf\xeb\x15\xf2\x6b\x8f\x6e\xc7\x0f\xc9\x37\xbf\xfc\xf5\x24\x86\x07\xe0\x25\xce\x15\xde\x42\x29\x28\x17\xf5\x0f\x17\xa4\x70\x1a\xb7\xdb\xe9\xc8\x48\x35\x99\x32\x38\x92\x9f\x27\x21\x8d\xde\x01\xde\xab\xde\x62\xc9\xa6\x63\x03\xf4\x81\xea\x88\xde\x25\x24\x55\x47\x84\x96\x39\x4d\x94\x0d\xaa\x12\x02\x88\x2a\x3a\x21\x9a\x9d\xe2\xcf\x6e\x3e\x51\x86\x05\xea\xcb\x32\x95\xff\x28\xf3\x64\x4e\x1e\x3e\xfb\xb2\xfc\xc7\xb0\xb6\x6f\xac\x79\xfb\x04\x5e\x33\x77\x57\x09\xc7\xd5\xdd\x33\x7f\xfe\xe4\x6b\x3d\x67\x2d\xdb\xbc\x72\xe5\xc6\xe5\xb3\xb9\x39\x17\x8f\x5f\x38\x3d\x76\x04\x76\x62\x0f\x9d\x12\x33\x1b\x9f\xb8\x76\x71\xfb\xf6\x6d\xdb\xc7\x7d\xf3\xea\x07\x5f\x7e\xfc\xc6\x9b\x94\x97\x87\xc3\xde\xa4\x0b\x8f\x00\x46\xbd\xc3\x79\x5e\xa3\x31\x8d\x64\x64\x67\x13\xad\x83\xcf\xcb\x4f\xd6\x6a\xb4\x9a\xe1\x91\xcc\x4c\xad\x16\xb9\xec\x76\x97\x0b\xec\x5f\x17\x8f\xd2\x87\x2b\xf3\x86\x9b\x14\x1d\x84\x9a\x94\x1d\xc4\x3b\xba\x67\xfd\xf7\x8a\x0b\x17\xbd\xf4\x63\x5d\xb3\x46\x9e\xfe\xe2\xd8\xa7\x2d\xcb\x2c\x36\xef\x9e\x7b\x2f\xd6\x1e\xfe\xdd\xf9\xf5\xbb\xf3\xa7\x35\x2b\xad\x70\x6d\x5d\xb0\xed\x61\x4c\xdb\xe0\xde\xfc\xd7\xf3\x4c\x2e\xfb\xc3\xfe\x60\xb0\x8b\xb3\x28\x2e\xc9\x1c\x27\xe9\x02\x19\x56\x41\x97\xc1\xe7\x64\x83\xca\xa3\x22\x99\x9e\x2e\x8a\xc8\x6e\xb1\xd8\xed\x70\x7e\xd8\xad\x28\x4d\x6d\x54\xff\x3f\xe0\xe2\x27\x45\x38\x78\xe3\x6a\x09\xd6\x2a\xcb\x56\x46\xf7\x8e\xbf\x5d\x5e\x5b\x64\x5e\x7f\xb4\x59\x95\xc4\x83\x73\x74\xfa\xc5\x23\xa3\x87\x2f\x3b\x71\xf7\xbb\xfa\x37\xaf\x8d\xb0\xdc\x79\xc7\xdc\x69\xb8\xc3\xc9\x8b\x27\xce\x31\x3c\x86\xcb\x63\x04\x0d\xec\x49\x90\xe6\x74\x5a\x6d\x7a\xb7\x3b\x98\x1a\xf0\xfb\x53\x05\x1b\x9f\x91\x99\x44\x31\x19\x1e\x11\x45\x67\x20\x18\x4c\x1d\x16\x09\xda\xad\x56\xf0\x4e\x87\x45\x9c\x4d\xba\xa7\xc4\x2e\xf0\x51\xcb\x3e\x47\x2c\xbc\xff\x27\x7b\x92\xa2\x16\x01\xfd\xf5\xb6\x47\x0f\xb5\xdc\x8e\xbd\x1b\x36\xd7\x6d\xc4\xd3\xc7\xcd\x29\x6b\xb6\x17\x9e\xdd\xeb\x7e\x6c\xcc\xff\xed\x2f\x8f\x21\x1f\xb1\xfb\x2c\x90\x12\x87\xd3\xe4\xf5\x0a\x88\x70\x1c\xd2\x39\x79\x7f\x20\x59\xaf\x63\xf3\x62\x40\x32\x1c\x0e\x97\xcb\x4a\x47\x39\x11\x41\x40\xbd\x23\x82\x94\x98\x20\xd5\xb2\x98\xa5\xb1\xd9\x9a\x62\x5b\xb1\xa6\x23\x2d\xf7\x83\x97\xc8\xb0\x99\x4f\x2c\x79\xe2\x85\x66\x7b\x80\x1d\x4b\x58\xc5\x44\xe6\xb8\x91\xcd\x37\x20\xe5\x73\x06\xb7\x1d\x64\xa1\x13\x8b\x17\x76\x0e\x07\x05\xc9\x4d\x52\xfc\x7e\x22\x19\xf9\x60\x46\x6a\xaa\x1e\x4c\xfc\x61\x11\x89\xe8\x2d\xec\xd6\x38\x29\x41\x08\x9a\xc4\xb4\x1b\x93\x44\x28\xf7\xdb\x6e\x70\x59\xa1\x08\x31\xd3\x4c\xc2\xba\xd7\xaf\xdc\xe0\xd2\x62\xd6\xe2\xc5\x33\x0f\x5f\x71\x7e\x75\x82\xf4\x6b\x79\x71\x71\xbd\x7c\xdb\xd6\xad\xdb\x28\xd7\x1f\x3f\xab\xcc\x82\x13\x4f\xb0\xda\x40\x0a\xb3\xd3\x45\x7c\xa9\xa9\xc4\x69\xe4\x03\xe9\xc9\xc9\x7a\xa7\x53\xe8\x1d\x71\x5a\xf4\x16\xaa\x88\x90\x27\x81\xd9\xff\x2b\xcc\x2d\x6e\x31\xa8\x2e\xed\xc0\x74\x93\xe0\x7a\xf9\x87\x96\xb7\x19\xbf\xcd\x9f\x0d\xf0\x7e\xf7\x12\x97\xd5\xfc\x3e\x23\x3a\x47\x7e\x65\xdb\xf6\x93\x17\x8f\x7d\x4b\xed\x74\xa0\xef\x2b\x40\x5f\x2f\xcd\x97\xd7\x8b\xa2\xc6\x6c\x20\x4e\xb7\x9b\x8e\x3e\xf0\x49\x92\x5e\x2f\xb0\xd6\xd3\x46\x2d\xd1\xd8\x91\xad\x91\xc0\xf1\xdb\xab\x04\x60\x9b\xc0\xdb\x78\x5d\xd0\x48\x5a\xd1\xf9\xfa\x15\x35\x5e\x3f\x35\x46\x4e\x8c\x62\x21\xfb\x26\x44\x54\xe2\xac\x40\xc7\x45\x2c\xce\x0a\x74\xc4\x2e\x97\x5b\xe0\x1c\x7a\x93\xc9\xe1\x26\xde\x24\x2c\xf5\x8e\x60\x03\x36\xb8\x89\xc7\xe2\x96\xac\x1a\x30\x3a\x5d\x8d\xa0\x55\x16\x37\x4d\x51\x69\x8c\xdd\x37\x92\x0d\x8e\xa0\x0e\x38\x1e\xc4\xff\x7d\xfe\xac\xc3\x97\x8f\xbf\x76\x31\x1e\xc7\x8f\x51\xe9\xe5\xf3\xdf\xfc\x6d\x08\x0b\xe6\xb3\x98\xce\x5d\xe0\xa7\xed\xa0\x71\x3f\x94\x17\x8b\xf3\x91\x1f\x69\xec\x91\xcb\x50\x6c\x25\xf8\xfd\x34\x56\x23\x51\x19\x4e\xd1\x13\xab\xc3\xa1\x25\x22\xef\x72\xdb\x6c\x48\xd4\x31\x33\x09\x8e\x77\x53\x53\x75\xcd\x62\x54\x09\xae\x8a\x42\x41\x96\x1b\x98\x40\x3d\xf2\x1a\x30\x66\x32\x7f\xbf\x9c\x3c\x2d\xce\x8b\x35\x5b\xb7\x5e\xff\x7b\x13\xde\xa3\xb9\xbe\x6f\xab\x31\xfe\x54\xde\xc1\xe9\x29\xc1\x68\x71\x86\xc1\x60\x45\x0a\x99\xc0\xee\x91\x12\x67\xc4\xdd\x88\xe9\x1c\xf1\xc5\xe3\xc4\x2a\x53\xc7\xc6\x4d\x9f\xcf\x48\x75\xec\x12\x1b\x1f\x17\x8d\x6e\xdf\xa6\x90\xe9\xc2\x71\x2e\x4b\xd9\xb7\x3e\x00\xc3\x02\xd0\x95\x59\x68\x50\xb8\x50\x4c\xd2\x5a\xcc\xe6\x60\x86\xa4\xd5\xa6\x92\x0c\x92\x93\x2d\x7a\x7c\x1e\x30\x2f\x3c\x1e\x64\x30\xd8\x87\x45\x2c\x16\x03\x1f\x0c\x22\x14\x48\x18\x99\x5f\x5c\xd5\xb4\x9a\xb0\xb9\xbd\xab\xcc\xcd\xcc\xa0\x2d\x31\x98\x6d\x11\xeb\xc2\xa3\x0c\xc5\x91\xd4\xe4\x52\x96\x76\xcb\x0d\xfe\x51\xbe\xb0\xfb\x51\xf9\x3b\xac\x79\xff\x55\x8c\x6f\x39\x54\xba\x6b\xee\xf2\x2d\xcf\x1c\xbe\xe5\x96\x53\x2f\x1f\xde\x82\xc9\xf4\x27\x23\xf2\x35\xe7\x8f\x7f\x5b\xf4\xb4\xbb\xf3\x6f\x7b\xcf\xec\x3a\xd8\x61\xe9\x14\x50\xa3\x33\x1f\x9e\xb1\x74\xc1\x5a\x6c\xed\xf9\xd7\x1d\x0a\x4e\xb7\xc2\x3e\xcf\x00\xfd\x99\x09\x7e\x50\xb1\x46\x4c\x12\xf5\x56\x8b\x25\x3d\xe8\xd2\xeb\x53\x48\x90\x64\x67\x89\xde\x24\x2f\x58\x15\x5e\x2f\x02\x7a\x03\x95\xad\x26\x6b\x7a\x3a\x42\xfe\xc4\xa9\x2b\xff\x27\x56\xf1\x03\xba\xbc\xa2\x4c\x49\x97\x8e\xb5\x69\xa7\xf8\xc4\x5a\x37\xd1\x94\x59\xfc\xc5\xf1\x0f\x37\xdc\x3b\x7e\xf5\x7b\x4f\xe2\xee\x45\x3b\x8d\x93\x07\xd5\xde\xb9\xe1\x89\xdd\xbb\x27\x8d\x7a\xb3\x6c\x7b\xe1\x49\xe7\xd3\x1b\xee\x5e\x6f\xe2\x74\x4b\xef\x5c\xf4\xb8\x2c\x3b\xbb\x82\x62\x1d\xd8\x7f\xc5\xe8\x3b\xfa\x8d\xde\x55\xb0\x68\x9e\xa2\x57\xc1\xff\xdc\x0c\x7c\x9a\x82\xda\x85\x03\xc8\x9a\x6c\xb7\xbb\xad\x1a\x3e\x35\xcd\x8a\x86\x45\xac\x44\x4a\x02\xbd\x2a\x08\xfa\x61\x11\x01\xfc\x24\x81\xee\x0b\x3d\x05\x5e\x6d\x7a\xc5\x0a\x32\x75\x03\x55\x1a\x4f\x72\xb6\x71\x1d\x5a\xa8\xd1\xcd\x6b\xdb\x85\x0b\x6e\x9a\x7b\xa3\xdb\xdf\xdf\xe5\x87\x36\x9a\x77\x58\x1f\x16\x6a\x94\xfb\xdf\x81\x6c\x9e\x66\x32\x2a\x0b\xa7\x18\x7d\x7a\x30\x9d\x7d\x0e\x3e\x25\xd5\x67\xec\x1d\xf1\x59\x6c\x2e\x3a\x67\x90\x55\xd8\xfb\x9a\x68\xcf\x46\x19\x8a\x39\x90\xe5\x37\x50\x9e\x7c\x8a\xfc\x6d\x87\x70\x41\x97\x8a\xb6\x2d\xf5\xe6\x22\xf9\x13\xf3\x56\x6b\xe7\xde\x7c\x49\x73\xbd\xc9\xe4\xfd\x0e\x79\x1e\x8d\x4d\x82\x1d\x5d\xca\x7e\x1e\x00\x7e\xdc\x4f\xec\xee\x41\x89\xf9\xea\x10\xd2\xdc\xcf\xee\x26\xda\xb2\xb9\x34\x51\xf0\x9d\xde\x62\x33\xfe\x06\xb1\xfa\xfe\x2e\xf2\x02\x74\xac\xe1\x34\x72\xa2\x40\xd8\x61\x13\xcc\x66\xfd\x97\x18\x23\x1c\xc6\xd5\x78\x38\xe6\xb1\x15\x15\xbf\x55\x5b\x5b\x42\xb3\x62\x99\x4b\xcc\x0e\x52\xb5\xbb\x31\x18\x33\x60\xa0\x1d\x1b\x9d\xd5\x2a\x94\x3d\xb2\x73\xd7\xd1\xdd\x3a\xcb\x0b\x8a\xcb\x8b\x8a\xca\x8b\x5b\xd7\x0c\x32\x0c\x1d\x6a\x18\xcc\xe6\xc0\x10\x94\x2f\xf4\xc2\xfb\xc5\xbf\xb2\x9e\x8c\x41\x94\x13\x76\x49\x3a\x9d\xc5\x42\xf0\xb3\xe4\x47\xd2\x40\x08\x09\xeb\x4c\xdd\x88\x2f\x50\x8f\x3b\x82\x03\xf4\x56\x7e\xed\x3d\x4a\xf1\xbe\x43\x49\xcf\x67\xc2\x5e\x91\xf0\xbd\x26\xe1\xfb\xfc\x22\x7f\x7a\x51\x51\xba\xbf\xe8\x7c\xec\x9b\x29\xf0\x4d\x61\x21\x7c\x23\x4e\xf2\x17\x16\x2a\x1f\x2a\xff\x7d\x96\x7d\xdf\xaa\x15\xc3\x7b\x82\xd0\x0b\xad\x17\xaf\x03\x4c\x86\x83\x48\x64\x4b\xbf\x05\x4b\x6a\xdc\xf0\x15\xac\xc8\x86\xaf\xf5\x8f\xc2\x3f\x07\x66\xd0\x7f\x3f\x2a\x5e\x1f\x10\xff\x47\xf1\x9d\x86\x02\x4e\x48\xc5\x29\x3d\xec\xd0\x35\x47\xc7\x22\x25\xa0\xd3\x14\x97\x44\xf8\x87\x03\xb4\xad\x8a\x83\xfe\x22\xae\x95\xdf\xdf\xaa\x38\x90\x5e\x24\x4e\x50\xc0\xa7\xe0\xd2\xcf\x8a\x14\x1a\x0e\x87\xf5\x5e\x57\xd7\xf3\x51\x1a\x7a\x89\xe7\xbf\x2f\xfa\xaa\xf5\x55\x6a\xc8\x35\xae\x25\x25\xc2\x00\x5c\x89\xb3\x19\x39\x28\x69\xfc\x81\x62\x4a\xbb\xd7\x27\x35\xae\xae\x40\x53\x54\x84\x27\xca\xeb\x80\x5e\xbd\x80\x4f\x36\x34\xec\x47\x1a\x64\x7d\x9e\x20\xde\xca\x73\x3c\xa2\xbc\x01\xb8\x69\x98\x2e\xc8\x2a\xeb\x32\x6d\xf4\xd6\x7d\x7d\x86\x8c\x1d\xb7\x63\xad\xd2\x3b\x62\x0c\x88\xce\x26\x71\x0f\x40\x6f\x38\x48\x30\x03\xed\x6d\x4a\xe3\xec\x8a\x4d\xf0\x8f\x88\xf6\xec\xd9\x43\xff\x4e\xfe\x50\xa8\xc6\xf9\xe2\x12\x14\x40\xfe\xb0\xc9\x96\x8c\x0c\xc9\xf0\x65\x71\x63\xb7\xba\x2f\xb5\x4a\x59\x24\x6b\x23\x41\x75\x8e\x5b\x93\xa5\x94\x6e\xb8\xd5\x5c\x94\xec\x0a\x15\xad\xec\x22\xbc\x35\x39\xb3\x32\x69\x42\x9f\x4e\xc5\xbd\xcb\x72\x2a\xfc\xec\x87\xde\x1d\x4b\xfa\x96\x16\xb4\x16\x2b\xb3\x32\xc3\xae\x6e\x59\xb3\x3a\xf5\x29\xbb\xad\xb2\x98\xfd\x90\x3b\xbd\x53\x9f\xf2\x5b\x3b\xe6\x31\x38\xea\x81\x27\x90\xb8\x00\x70\x74\x3c\x4f\x2c\x7c\x1a\xc5\x51\x85\x00\xd0\x24\xcc\x96\x74\x49\x93\xee\x19\xb3\x65\xbf\xd0\x6b\xc8\x98\x09\xdb\x95\x3e\x59\x08\xc9\x0b\xf0\x4d\x0d\xdf\x22\x01\x69\x0f\x62\x1e\xa8\x42\x33\x50\xb3\x2b\x42\x1a\x7c\xd3\x83\x87\x0e\x3d\xf8\x9c\xbc\xa0\xae\xae\x0e\x71\x0d\xb9\x8c\x86\x57\xe9\xfb\x91\x14\xd6\x69\x34\x7c\x98\x60\x62\xa3\x3d\xbe\x68\xa3\xa0\xe2\xd6\xad\xdc\x80\x05\xb5\x57\x85\x84\xad\xda\xb0\x77\xdb\xa8\x19\x0d\x28\xb6\x47\x7d\x56\xef\x1c\x37\x76\x88\x51\xdd\x1e\x65\x7d\xe0\x8d\x6e\x2a\xdc\xbc\x32\x2a\x53\x81\xfb\x6d\x0a\x37\x1d\xd2\x46\x55\xf5\xfe\x2d\xa3\xa7\x0a\xbd\x1e\xda\x31\x61\xd4\x30\xda\xd5\x43\x79\xc6\x2a\xf2\x1f\x50\x7e\xa6\xb8\xab\xef\xb0\xa0\xe4\xb0\xd1\x68\x30\xa8\x6f\xd2\x2a\xaf\x2a\x81\x77\x31\xa9\x8c\xbd\x2e\x90\xf0\x5a\xf9\xd6\x7d\x5b\xe3\x2f\x5f\xbb\x13\xfe\x05\xef\xe4\xa3\xbf\x0a\xed\x38\xbd\x26\x17\xd1\x1c\x7e\x5a\xf3\x14\x08\x5b\xbd\x84\x14\x17\xe7\xe2\x5c\x47\x59\x99\xae\x3a\x88\x83\xa8\xb8\x96\x9e\x35\xaf\xd6\xb6\x10\xf9\x6c\x60\x93\xac\x8a\x44\x6f\xd6\xa9\x76\x68\x51\x37\x5f\x93\xd0\x9a\x74\xd0\xfc\xc8\xe0\xf9\xf7\xd6\xb6\x2b\xac\xe9\x53\x93\x32\xbb\x22\x3b\xa7\x6d\xfb\xac\x8c\xb6\xf2\xfb\x29\xf0\x73\x61\xbb\x21\xf3\xe6\x0f\x8e\xcc\x9f\xdd\x36\x23\xab\x7d\xdb\x9c\xac\x36\x62\x9f\xc8\xfc\x79\x83\x22\xf3\x3d\x35\xfd\x6a\x8a\xdb\xe7\xb4\xa9\xcc\xce\xae\x6c\x93\xd3\xbe\x18\x7e\xf4\xd0\xcf\xe7\x47\x72\xda\xb4\xcd\x82\xcf\xa8\x9c\x23\xa1\x1d\xbe\xa2\xe2\x20\x85\xf5\x5e\x3a\xe5\xc3\x51\xad\xc3\x3a\x0a\xf9\xab\xb5\x25\xff\x1d\xe6\x0e\xf3\x23\x35\x0b\xe7\x0f\xaa\x6c\x3d\xa0\x5f\x8d\x6f\x66\x9b\x9c\xdc\x36\x6d\xb3\xb3\xda\x52\x00\xee\x1d\x3c\x68\x1e\x05\xa0\xa8\x43\x4e\x9b\x36\x39\xf0\x7f\x90\x97\x21\xc0\x7f\x7b\xc4\x2d\xf4\xc6\x06\xc4\x99\xe7\x75\x16\xd8\x5c\x6d\x8c\x03\x2b\x69\x03\x2e\x87\xb2\x0e\x0d\x49\x4a\x8a\x35\xb4\x67\xe0\xc0\x74\xf7\xa8\x51\xfa\x40\xab\x2c\x71\x4b\x49\xcd\x68\xfd\x68\xdc\x63\xa5\xb1\xb0\xa2\x04\xb5\xd4\xef\x16\x22\x8a\x5f\x0a\x18\x09\x61\xa1\x5a\x18\x2e\xf0\x82\x43\xe1\xbd\x5a\x45\xbf\xbb\xa9\x6b\x14\x2c\xa3\xfd\xe0\x42\x52\xcc\xd8\x3a\x76\x73\xd7\xd1\x9d\xbb\x8e\xcc\x0e\xb5\xca\x1a\x3d\x7a\xd0\x20\xc3\x90\x21\xfa\x41\x83\x5b\xb7\x2e\x6b\xd5\xaa\xac\x35\xbc\xbf\x9b\xbc\x0b\xad\x6d\xf8\x02\x78\xdf\x7c\x98\x20\x0e\x73\x31\xad\xe0\x06\x8b\x31\x54\xb6\x56\x7e\xe1\xb3\xa0\xfc\xfa\xb8\x77\x29\x2c\x43\x01\x96\x9d\x4d\xe5\xc4\xc1\xe4\x64\xe7\x83\x75\x75\x0f\xd6\x29\x62\x02\x7f\x37\x0e\xfe\xee\x90\xaa\x6b\x78\x44\xac\x94\x9f\x51\x31\x63\xe6\x98\x80\x1c\x7a\xfa\xb1\xd1\xd3\xfa\xac\xdd\x31\x6e\xdc\x60\xa4\xf0\x2f\xc8\x60\x37\xf6\x8c\x05\x79\x15\xfe\x55\x9e\xb4\xc0\xa3\x71\xe6\x95\xd4\xc7\x03\xea\x7f\x9f\x7e\xec\xae\x29\xf8\xf9\xbd\xdb\xee\x9a\x42\xdf\x35\x7e\x10\xc8\xd6\x78\xe5\x5c\x1c\x01\x30\x6c\x6d\xf8\x0d\xde\x67\xac\x0b\x63\x8c\x05\x8a\x16\xc0\x2b\x94\x55\x64\x67\x4a\x9a\xad\xf2\x37\xab\xf7\xe2\xb4\xb5\xf2\xa1\x50\xb5\xeb\xab\x50\x0f\x2f\x3d\x5b\xe9\xfe\xed\x02\x99\xd2\xf0\xef\xa1\x5d\x48\x81\xcb\x29\xb4\x83\x13\x38\xce\x3f\x8e\x62\x13\x36\x79\xab\x35\x58\x13\xe7\x1f\xf2\x5f\xf8\xba\x83\xaf\xa6\xdf\x80\x92\x36\x91\x05\x0b\x6b\x06\x2e\x9c\x09\x4c\xd9\xb6\x4d\x6e\x0e\x30\x70\x87\x22\xca\xac\x94\x87\x28\xb3\x56\x66\x03\xff\xc0\xfa\xea\x5e\x83\x4c\xff\x83\xe1\x00\x67\x14\xda\x29\x1e\x01\x7a\x1b\x0e\xf2\x38\x7e\xc6\x25\x90\x5c\xe8\xc5\x48\x4e\xf7\x11\xfe\x76\xad\xb8\x0c\xfe\xd6\x76\x98\xb2\x1d\xe1\xd4\xa3\x84\x22\x1d\xdf\x4a\x71\x19\xdb\x4b\xaa\x3f\x14\x7a\x03\xae\xef\xa0\x43\x88\xf9\x22\xd1\xbd\x42\x35\xe8\xcf\x25\xf0\xd9\x19\xf9\x43\x05\xff\x86\x5c\x61\x2e\xfa\x18\xf0\xa7\xe7\x96\xf5\x88\x44\xc5\xc7\xa2\x53\x14\x1e\x55\xa9\x09\x27\x7c\x82\xd8\x7c\x3c\x3f\x42\x25\x64\xf0\xbd\x33\xa9\x68\xb4\xcd\x52\x44\x86\x7e\x48\xd1\x55\xc4\x05\xde\x7d\x00\xf0\xad\x6e\xf8\x81\xbd\xdb\x1d\x36\x5a\x90\x84\xc3\xd2\x0e\x89\x93\x74\x84\xad\x40\x0f\x5e\xcd\x9f\x1c\x80\xd5\x54\x7d\xd2\xf3\x35\x76\xee\x8e\x08\x14\xc3\xb7\x09\xc7\xae\x20\xbf\x0f\x38\x16\xaa\xef\x07\x4d\x85\xda\xa1\xec\xb0\x33\xe4\xf3\x55\xa2\x00\x0e\x07\x76\x04\xb8\x40\x21\x58\x32\xd9\x16\xba\x1a\x8b\xce\xbe\x15\x33\x5d\x84\xff\xc1\x74\xc9\xfc\x93\xcf\xe5\xf7\x5b\xda\x34\x85\xfe\x60\x61\x61\xd0\x5f\x88\x6f\x8d\x7d\x14\xb7\x17\x86\x03\xcc\xea\x67\x45\x89\x56\xce\x8f\xea\x67\x71\x7c\x88\x7c\x15\xf0\xb1\x02\x3e\x84\x71\x63\x4a\x18\xf6\x19\x3b\x90\x17\x87\xbd\x3b\xbc\x9c\xd7\xa4\x51\x89\xc6\x14\x8d\x00\xee\x5e\xc5\x9f\xd0\x4e\xbe\x8a\x6f\x69\x03\xe0\x14\x17\x53\xb0\x54\xd0\x76\x4e\x98\x10\x8e\x2d\xa9\x5a\x15\x28\x61\x4d\x7a\xe6\xa5\x81\x0e\xb2\xb1\x32\x73\x37\x4a\xc1\xe1\x94\x1d\x29\x5c\x8a\x7a\xfa\xb1\x55\xd9\x01\x5f\x16\x84\x95\x83\x7f\xba\xf6\x8e\x89\xf8\x96\x71\x3b\x9b\x2f\x2e\x5f\x99\x32\x61\xc2\x94\x43\x2d\xd6\xc7\xc0\x23\xbb\x80\x47\x6e\x82\x3d\xd4\x1e\x64\x6c\xd1\x94\xeb\xe2\x6c\x20\x5f\x55\xf7\x1f\xf8\xaa\x03\x3c\xf3\x4a\x43\x17\xb6\xef\xe6\x3a\x6a\xac\xb2\x1d\xb6\x35\x7b\x36\x11\xc4\x57\x62\xdb\xf1\x5d\xec\x9c\x96\xff\xa5\x12\x3e\xbd\xf1\xa8\x46\x04\xde\xbd\x00\xde\x1d\xe3\x29\xd8\x03\x5f\x9c\x99\x12\x16\x6a\xc9\xbb\x7f\xc6\x45\xaf\x14\xa5\x2b\xeb\x7c\x47\x77\x9f\x62\x30\x3d\xce\xd1\xca\x2f\xd8\xe2\xf4\x8f\x9e\xa5\x1c\x12\xb3\x7f\x87\x34\x78\xd1\xae\x86\x25\xc0\x0b\xc6\x3a\xa2\x01\x05\x47\xf5\x11\x2c\x09\x7e\xf6\x2e\xdc\x4d\xae\x9f\x37\x4e\x39\x3f\x86\x00\x2d\xe8\xdf\x69\x90\x78\x80\x43\xc5\x8d\x1b\x54\x36\x09\x77\x1b\x2f\xef\x9a\x3e\x6e\xdc\x74\x46\x67\xe1\x2f\xa8\x5a\xec\xca\xec\x69\xa2\xab\xc7\x55\xa0\x3b\x9a\x91\x3a\x06\x8c\xf0\xab\x22\x75\xad\xa8\xce\x54\x9f\x03\x9d\xf5\x33\xa3\x8f\x1d\xe8\xf3\x53\xc3\x4f\x2a\x7d\x7c\x61\x93\x64\xb1\xf8\x7c\x0a\x81\x54\xb1\x2e\xb1\x33\x0e\x4d\xa4\x82\xfb\x4f\xbe\xff\x21\x26\x1a\xdb\x62\x8b\xef\x88\xcb\x8d\xca\x2c\xb7\xaa\xc0\x74\x8b\xc9\x09\xe0\xc2\xdd\x83\xaa\x89\x99\xf1\x0c\xd1\xb5\xe4\x99\x98\xda\xe0\x8e\x29\xdc\x57\x08\xcf\xbc\x09\x74\xaa\x60\xf4\xd4\x1e\x04\xb3\x81\x3d\x03\x0e\x52\xc5\x44\x79\xd7\x97\x5f\x82\x3e\x5d\xca\xcf\xe6\x4e\x08\x3d\xe0\xf7\xb6\xc3\x70\x98\xc0\xe1\x44\x3b\xbb\xe2\x78\x70\x63\x29\xd7\x3e\xfa\xaa\xd0\xe3\x7d\x46\x73\xe1\x04\x9c\x23\xf9\x6c\x6f\x90\x96\x8e\x56\x63\x7b\x43\x62\x7b\x23\xe6\xd3\xcd\xc1\xf8\x5f\xf2\x70\x6e\xb5\xe6\x63\x2a\xcf\x75\x44\xe0\xe9\xd1\xcb\x52\x66\x95\x72\x51\xfc\xaf\xcd\xf2\x70\xdd\xcc\x5f\x57\xa0\x16\x74\x6e\x41\x77\x0e\xd1\x02\xe5\x05\x7c\x25\xbc\x4b\x83\x5a\x87\xf5\x88\xe7\x89\x46\xa3\xd3\x62\xb0\xfe\x3a\xd7\x45\x30\xcf\x0b\x47\x71\x67\x14\x41\x3c\x6e\xab\x46\x60\xf3\x13\x4a\x32\x69\xab\x42\x8a\xee\x8b\xaf\xbd\xf6\x1a\x19\xf7\xee\xbb\xd7\x37\xbc\xfb\xae\xc2\x3f\x07\x44\x37\xac\x73\xe4\xff\xa4\xa5\x38\x9a\x09\x2d\xa3\xe5\x01\x79\x1c\xc8\xac\xf6\xff\x96\xd9\xfa\x98\xcc\x62\xb4\x05\x90\x38\xcd\x9f\x06\xcd\x56\x1e\x36\x88\x66\x8b\xd9\x66\xb4\x58\xac\xbc\xa6\x93\x1e\x87\x19\xd8\x95\xf0\x2b\x23\xfb\xde\xa2\xa2\x50\xa5\xb4\x2a\xb1\xd1\x78\x97\x72\x97\xc5\x62\x35\x66\x2c\xd1\x7b\xdf\x2d\x9d\x1f\xde\xbe\x68\xd9\xad\xbd\x02\x78\x76\xf4\x5d\xee\xa7\xfa\x53\x91\xbd\x6d\x97\xec\x89\xfe\xb0\x57\xb1\xf9\xcb\x40\xaf\x9d\x6f\xd8\x06\xfe\xb5\x78\x40\x43\xe5\x42\x08\xba\xc1\x76\xaa\x00\xe1\xc0\xe7\xeb\x1c\x13\xac\x87\xf0\x81\xb7\x77\x38\x9d\x3b\xc6\x2b\x7f\x7f\x13\x18\xc4\x57\x00\x3e\x2f\xea\x1e\x4e\x31\x7b\x4d\xc8\xc0\x19\x31\xcd\x3a\x36\x82\x0a\x76\x1a\x7d\xce\x24\x03\x67\xa6\x5a\xd8\x79\x14\xc0\x13\xe0\x91\x4a\x3a\xe4\x34\xa4\x5e\xb6\x29\x80\xd2\xa9\x2f\x0a\xbc\x95\xb1\x9e\x2a\xb8\xdc\x01\xa7\xb9\x99\x63\xbd\x40\x38\x0d\x09\x3a\x3a\x72\x15\xf3\xbe\xc1\xaf\x6c\x48\x76\x1f\x73\xeb\xdb\xdf\x79\x17\x1e\x7b\x29\xfa\x53\x7e\x59\xa6\xb7\xfa\x6f\xfd\x32\xda\x0f\xee\xc9\x9f\x8e\xae\x7f\x00\x73\x5f\x7e\x36\x7e\xdf\x86\xd1\x72\x90\x7b\x5b\xaa\x1a\xbd\x50\x9e\x80\xd7\x3e\xbd\xa6\x46\xa9\x19\xed\x03\xb0\x2e\x62\xb4\xac\x0c\x1b\xb4\x06\xa4\x13\x45\x9b\xce\x8a\xd1\x51\x46\x3e\x8c\x2b\x9f\x13\xf5\x3a\xbd\xf2\x93\x8e\x11\x53\x8d\xdb\x61\x05\x38\x16\x2b\x28\x0b\xf8\x5d\x5e\xb0\x23\x03\x65\xac\x84\x6b\x11\x9e\x8d\x9d\x3f\x2c\xbd\xf6\x1e\x77\xf5\x91\xe7\xf9\xc0\xde\x2b\xf2\x4f\xd1\xcf\xf6\xee\xe5\xb2\xeb\x95\xba\xbf\x2a\x10\xfe\x42\x58\x33\x09\xb5\x0f\xdb\xb5\x4e\x8d\x53\xa3\x11\xc5\x64\xaf\xc9\xac\x75\x3a\x93\x34\xe6\x63\x98\x5e\x4d\x7b\xd9\x92\x49\x94\x34\xb1\x64\x60\x4a\x1a\xf5\xce\x7e\xd9\xcb\x74\xb8\x6d\x2a\xe7\x76\x04\x89\x99\xb3\xe0\x60\x45\x47\x52\x51\xc4\xd1\x54\x3a\xfe\x8e\xb1\x5d\x2a\x4b\xf7\x1f\xb9\xa7\x5f\xcf\x12\x57\xe0\xa5\xa0\xa7\xa8\xdb\xdd\xab\x4a\x4a\x3b\x56\x2e\xe3\x4f\xa7\xdd\xfc\xc0\xd7\x51\x11\xff\x26\xb5\x9f\x31\xaf\xee\xc8\x7d\xf7\x0f\xe9\x90\xf5\xc1\xc3\x6d\xf7\x2a\xfd\x65\xf8\x0a\x80\x49\x83\x0a\x9e\xc7\x22\x88\x03\xd1\x82\x15\xd5\xf6\x39\x0d\xe1\xc9\xd1\x38\x5b\xa9\xd8\xc7\xb6\x48\x69\xa7\x48\x55\x24\xd9\xf6\x42\xb4\x0b\x6f\xde\x0c\xd8\xee\x65\x32\x06\x98\xf2\x93\xe0\x7d\xf4\xfc\x2d\x0b\x9b\x05\x9e\xb7\xe9\x11\xb6\x72\x1c\x36\x18\xf4\xc7\xd8\x0b\x0d\xf0\x42\x01\x48\xdc\x36\x61\x0c\x37\xbc\xb9\xa4\x24\x9e\x44\x11\xc2\xec\x56\x23\x40\xe9\x6b\xc3\x23\xeb\xeb\x89\xe1\x85\x47\x9e\x97\x8b\xf0\x87\x40\x5f\x92\x72\xfd\x1b\xee\xbd\xfa\x4d\x94\xbc\x0a\xdf\xed\x87\x7f\x8d\x66\x6b\x4a\xcf\x71\xbc\x40\x5e\x84\x57\x33\xde\xaa\x52\x34\x85\x23\x64\x0b\xee\xaf\xaf\xe7\x4f\x5f\x53\x66\x41\x87\x00\xd0\xd9\xfc\x17\xc8\x0c\x72\x44\xeb\x60\x2c\x46\x6c\x35\x59\x80\x57\x69\xb7\x4d\x8c\xb5\xe6\x17\x71\x1b\xa4\xa5\xf0\xb1\x5a\x69\x95\x19\x29\xee\x25\xea\xf5\xa4\x94\x6d\xe6\x58\x07\xcd\xf2\x8a\xcc\x32\x6e\xf6\x84\x76\x45\xce\xfa\xde\x77\xc8\x7b\x79\xef\xf1\xcc\xb4\xf2\xee\x95\xd1\x41\xdc\xb6\x71\xf7\xf9\xa7\x1e\x8b\xc1\xc7\xef\x00\xf8\x4c\xa8\x30\xac\x37\x19\x8d\x16\x41\x14\xcd\x26\x91\xee\xb7\x06\xc8\x4b\x69\xa2\x89\xef\x77\x4c\x5e\x95\x91\x53\x4a\xaf\x51\xca\x65\x41\xf2\xed\xfa\x7a\xf9\x54\x3d\xfe\x09\x68\xf0\x02\xf7\xde\x91\x2d\xd7\xbe\xe4\x4f\x53\x16\x6b\x4d\xd7\xd8\xd5\x00\x92\xc7\x7f\x09\x0c\x54\x15\x36\xd9\x8c\xa2\xd1\xe3\x49\x16\x09\xf1\x39\x2d\x9d\x14\x8d\xe0\x04\x9c\xe8\x56\x22\x60\x67\xfa\x33\xc2\xed\xd4\xd8\x7d\x5c\x45\x28\x4a\x42\x48\xe7\xd8\x65\x24\x35\x55\x95\xc2\xc4\x32\xa5\x6b\x88\x15\x71\xeb\x1b\x7e\xaa\x5f\xbf\xfb\xd5\x03\x35\xe3\x46\x0f\xeb\xb5\x62\xc5\x63\xdd\xe5\x1f\x9c\x70\xae\x1a\xb8\xf7\xa3\xa1\x17\xf7\x5d\xc5\x9e\x33\x27\x3a\x1d\xe8\x30\x23\x7a\x4a\xde\x2c\x1f\x54\x70\xe7\xba\xaa\x7b\xe3\x3a\x42\x38\x4e\xe0\xa9\xdb\x0e\xb8\xbe\xad\x68\xd6\x84\xcd\x51\xfa\x8c\x65\xcb\x0b\xc8\x4e\xf8\x7b\x03\x0a\x3e\x0f\x5e\x3f\xe8\x0e\x8d\xf8\x52\x9c\x44\x18\x77\x40\x8d\x00\xb3\x22\xd8\x38\x9f\x90\x9d\x2f\x00\x81\x56\x30\x19\x94\x17\xf0\x7d\x8e\x6c\x51\x38\x04\x23\xb0\xd8\xc9\x2b\xf0\x4e\x1b\x2a\x05\xfa\x13\x62\xd7\x22\xe4\x30\x9b\x54\xb5\x69\xc6\xf4\x44\x50\xb6\x81\xb4\x50\x9b\x2c\x31\x30\x17\x97\x05\xa8\xa3\xa8\xae\x65\x23\xaf\x44\xdf\x92\x4f\xe0\xce\xc7\x8f\x3c\x7f\x4c\x7e\x09\x57\x71\xa5\x5c\xbf\xe8\xbe\xbd\x1f\x7c\x90\xfd\xe1\xfb\x7b\xa3\xfb\xe8\x9a\x5d\x1b\xde\x27\x9f\x89\xb4\x16\xb4\x22\x6c\xb4\x9a\xf4\x1a\x8d\x8d\x37\x99\xec\xc8\xda\x49\x87\xdb\x03\x73\x95\x23\x3d\x60\x44\xd7\xd4\xc7\xb6\x3e\x61\xef\xe9\x3e\x54\x94\x67\xd8\xcb\x4a\x83\x2c\xf5\xc0\x6f\xb3\x22\xe1\xc4\x71\x6c\x5f\x7b\x49\xb6\xd4\xe3\x1e\xf8\x21\xb9\x8f\xfc\xf0\xce\x5b\x3e\xc5\xe8\xbe\xcf\xb8\xe1\xf2\x6d\xf2\xa3\xf2\xe7\xb2\x63\xb1\x12\xb7\xdb\xcf\xe6\xda\x9e\x46\x22\x70\x1c\x60\xac\x43\xc8\xa2\xc5\x54\x73\xaa\x18\x73\x94\x92\x00\x83\xa2\xe9\x6e\x80\x31\xcb\x72\x00\xc9\xb3\x31\xb5\xc6\xbf\x79\xed\x3c\xb0\x84\xf3\x87\xeb\x8f\x71\x7b\xd7\xd7\x33\xa6\xc3\x7d\xae\xaf\xe0\xb2\x8f\x6c\x61\x7b\x5c\x01\xeb\x7d\x06\xbc\xe7\x41\x91\xb0\x4b\x70\xb8\x88\x93\xb7\x58\x25\xab\xd3\xe9\xd5\xf0\x7c\x92\xc3\xe5\x12\x9c\x9d\x2c\xb0\xa6\x95\xca\x25\x88\xbf\xc2\x7e\x6d\x40\x09\x88\xec\x7b\x21\x0e\x03\xa5\x02\x4b\x15\x8e\xc1\xc2\x98\x92\xf5\xae\x65\x35\x3b\x8a\x9e\x4d\x17\x0d\x38\xe8\xa0\x13\xc0\xdc\x1d\x31\xd1\x5f\xfd\x32\xfa\x17\xbc\x63\xfe\xc6\x65\xfb\x6f\x9b\x77\x72\x45\x71\xf1\x1f\x9f\xce\xeb\x75\x88\xff\x52\xfe\x54\x3e\x1e\x5d\xb1\x17\x1f\xf9\xf7\x3f\xff\x2d\xbf\x15\xfd\x95\xf3\x1e\x9d\x81\x17\x9d\x9e\x31\x56\xe1\x4b\x38\xdb\x14\xbe\xf4\x1e\x66\x7c\x89\x5e\xa4\x7c\xc0\xf8\xab\x05\x6b\xfe\xce\xfc\x47\x9a\xa5\x0e\x7a\x43\x3d\x7f\x75\x18\xd4\x1a\xf8\xec\x36\xbd\x4e\x25\xab\x9e\x91\x95\xfb\x13\xb2\xd2\x2d\xa5\x7c\x64\x8b\x5d\x3b\x83\x44\x71\x70\xec\xe2\xd9\x81\x5e\xb7\x2d\x5b\xb4\x63\x7d\x97\xbd\x9c\x7d\xc7\xca\x76\x7b\x23\xa7\x9f\x87\x3d\x0c\x81\x3c\xbf\x0b\x6b\x59\x51\x2a\xea\x14\xb6\x24\xe9\xf5\xc0\x76\xc4\x49\x3b\x17\xa5\x99\xdc\x8a\x66\x36\xe1\x76\xcf\xd9\x78\x81\x3f\xaa\x52\xb1\xb2\xe9\x29\xa5\x26\x5d\xab\x31\x27\x7a\x6a\xc3\x9e\x82\x14\x07\xfc\xc8\x86\x45\x9b\xe2\x7d\xdb\xa8\x37\xba\xb4\x5d\x76\x1d\xb7\x09\x3b\x7f\x92\xbf\x96\xaf\xc8\x3f\xc8\xd7\xb0\xd8\xf9\xe0\xee\xe3\x4f\xaf\x79\x8e\x5b\x32\xfb\x6a\x68\xef\x65\xf9\xc7\x1a\xf9\x65\xf9\x30\x9c\x32\x55\xf8\xc4\x4c\xf9\xeb\xb2\xcf\xcf\x9d\xc5\xb8\xe6\x45\x65\xa6\x59\x6e\xc3\x97\xfc\x4d\x4c\xbf\x85\xc2\x36\x81\xe3\x4c\x5a\x6a\xe5\x83\x32\xe5\x04\x82\x4c\x47\x29\xbf\x03\x65\x2b\x59\xe6\x8f\x4d\xd5\xa4\x36\x35\x29\x1c\xf8\xdc\x4f\x9b\x4e\x94\xdb\x6d\x21\x2b\x28\xef\x5c\xec\xdc\x26\xaf\x3e\x8d\xbb\x3d\x30\xe7\xc4\x6b\x72\x67\x79\xec\xce\x10\xf9\xf5\x7a\xcd\x48\xfc\x04\x7e\x5c\x6e\x1d\xfd\x95\x8d\x26\xa0\xb6\x26\x88\x78\x0d\xdb\x8b\x0e\x61\xa3\x89\x37\x98\xcd\x56\x7a\xd6\x18\xcc\xf5\x38\x5c\x17\x31\x18\x2c\xc2\x31\xd8\x4b\x0b\xd2\xab\xe6\x50\x65\x3c\x8b\x26\xbf\x89\x94\x61\xa6\x5b\x99\x16\xb1\xc1\x41\x6e\xe3\x06\x00\xa3\xd7\xc3\x61\x73\xf9\x5f\x72\x1f\xfe\xf4\x25\xf9\x87\x6b\x07\xf8\x3e\xf5\x9b\xe4\xbf\xec\xe5\xf6\xc3\xba\x6b\x81\xd7\xef\x81\x75\x5d\xa8\x07\xe8\x59\x8d\x59\xd0\x6a\xdd\x2e\xb3\xd9\x23\x68\x61\xe1\x23\x11\x41\xb0\xe9\x74\xbc\xca\x10\x3a\x58\xd5\x86\xec\xec\x7b\x5b\x23\x43\xa8\xb7\x51\x8d\x50\xc4\x55\x3d\x05\x80\xee\x8e\xa4\x6a\x9c\x32\x72\xe4\x2f\x87\xe4\x2b\xbf\xc8\x7d\xf0\x7b\x18\x4c\x29\xd0\x3a\xb5\x78\xcf\xb1\x23\xdc\xde\x97\x5e\x64\x00\xc9\xff\x96\x2f\xf4\x01\xcd\xf3\xfe\x87\xac\xc7\x1d\xe8\xce\x0f\x79\x1a\x07\x83\x73\x4d\x0f\xda\x53\xb4\x58\xad\x2e\xb0\x31\x24\x27\xa7\xd7\x63\x8b\xf8\x62\x5c\x85\x32\xb3\x22\xd4\x64\x27\x54\x75\x5a\x84\x49\xc8\xee\x72\x77\xe4\xaa\x70\x88\x98\xb1\x86\x43\xf5\x05\xa3\xf7\x7d\xba\xef\x4e\xfd\x90\x31\x65\x06\xe7\x09\x9f\xe3\x8d\x2f\xa9\x8e\x8e\x3c\x74\x14\x0b\xf2\xaf\x67\x67\xba\xab\x97\xcd\xfb\x4d\xbe\xf8\xc9\xa7\x05\x6a\x9f\x3d\x9e\x67\xba\xf6\x96\xb0\xa4\x37\x18\xac\xa2\x40\x6c\x36\x07\xec\x0d\x67\xb7\x8a\x22\xd6\x0b\xa0\xfe\x9f\xb3\x71\x98\x3b\x9a\x20\x28\xb1\xb6\x20\xb6\x04\x53\x07\xce\x5c\x55\x19\xd1\x24\x30\xdc\x11\x58\x4f\x31\x02\x79\xfe\x7a\x35\x77\xfa\xfa\xe5\x0b\x78\x5e\xcf\xae\x46\xf7\x31\xa7\xb9\x62\x74\x2d\xae\xda\xcb\x07\xa2\x7f\x04\x16\x2d\xfd\xf2\xb3\x07\x1e\x1a\x9e\x29\x57\x2b\xba\x70\x2e\xf0\x49\x37\x26\xe7\x74\xba\x86\xd5\x61\xd0\x62\x8e\x73\x5a\xb4\x5a\x89\x10\xde\x68\x00\x6d\xdc\x0e\x44\xb6\x03\x38\x2b\x8e\x04\x6b\x27\x76\xdb\xde\x6c\x93\x68\x7f\x2c\x9a\x5e\x01\xca\xb8\x8c\xb5\x93\x0a\x06\xf0\xe8\xfa\x10\x27\xfe\xe7\x8c\x7c\x50\x3e\xfb\xde\xd7\xd3\xd7\x46\xaf\x92\x94\x6b\x23\xf8\x6d\x78\xff\xc1\xb7\xe4\x0b\x72\xee\xac\xf7\x87\xe2\xdb\xcf\xdc\xcf\x66\x52\x67\xc3\x39\xa4\x9c\x6d\x59\x47\xc0\x26\x86\xd3\x0d\x2b\x36\x80\xd8\xd4\x06\x60\xab\x52\xe6\x0c\xfc\xc9\xf1\x46\x4f\x7f\x76\xb8\x81\x2d\xd3\xf0\xab\xb0\x00\xde\x99\x82\xaa\xc3\x92\xc5\x8a\xb0\xc6\xab\xf5\x78\xdc\x2e\xad\x5b\x8b\xad\x7c\x5a\xaa\x57\x53\x8f\x6f\x3a\x12\xf1\x7a\x5d\x16\xe4\x3e\x06\x2b\xb8\x40\xf1\x77\x82\xd5\x5c\x31\x86\x0c\x35\xab\x37\xb3\xc7\x1b\x70\x87\x98\x89\xe9\xa0\x63\x14\x2b\x1c\x21\xc2\x99\x31\x18\x57\x6c\xea\x62\x05\xb7\xf5\x58\x9a\x25\x34\x72\xda\x86\xd6\x9e\x37\xaf\x3e\xd0\xd3\x5d\x75\x22\x9c\x36\xe5\x8c\xbc\x5e\xde\x77\xe9\xf8\xdc\x5b\xef\x1e\x60\xe0\x4f\xcb\xf5\xbb\x1f\xe9\x9d\x16\x94\xe5\xe2\x91\xcf\xff\x8d\x33\x45\xff\x90\xff\x88\xae\xaa\xe2\xf8\x0f\xa3\x2b\xcc\x9e\xd9\xeb\x00\xf6\x0e\xc0\x2b\xdf\x30\x7f\xa1\x53\xd8\x6c\xf6\x7a\x35\xd8\xe1\x48\x02\x7b\xcc\xe7\x70\x82\x30\x1d\x8a\x68\x1d\xd4\x12\x35\x61\x0e\x1f\x8d\x9f\x5b\x31\x5e\xc9\x6f\xa6\x45\x70\x50\x31\xc6\x55\x51\x76\x9a\x15\x25\xdb\x11\x54\x96\x78\x8c\xdb\x08\xba\xad\xfe\x91\x17\xe4\xaf\xc1\xe1\x31\xd8\xba\x56\xa7\x83\xbd\x0a\x4a\x2d\xda\x9a\x1a\x92\xd1\x17\xa9\xe3\x13\xba\x7b\x02\x8d\xf9\xc1\xd9\x49\x46\xf2\xa7\xad\x59\x02\xf8\x27\x56\x8d\x20\x60\x19\x35\xfd\x5c\xd7\xf4\x73\xae\x6b\x93\xcf\x75\xf4\x73\xc0\xed\x63\x5e\xe4\xba\xc1\xf9\x4f\x50\x0a\x78\x9a\x18\x73\x04\xbc\x57\xcc\xd5\xc3\xc1\x1f\xb3\x7d\x54\x0b\x06\xfc\x9b\xe1\x2b\x56\x7c\x07\x7f\x3f\x17\xf8\x15\x9e\xe3\x45\xf6\x9c\x06\xac\x45\x3b\x2f\x88\x82\x06\x9e\x85\x7d\xc5\x3a\xad\x80\x45\xe5\x0d\xa1\xb7\x4b\x9a\xdd\x64\x2b\x6f\x72\xc4\xde\xf6\xf1\x8a\x15\xdf\xd2\x37\x46\x97\x72\x73\x91\x3a\x5b\x9e\x7c\xc3\x53\x66\xd3\xd3\xce\x2b\x1a\x51\xa7\xd5\xe9\x09\xe0\x28\x18\x0d\x7a\xda\x16\x41\x2b\x16\xeb\xb1\x5e\xab\xd7\x0a\xa2\x05\x0b\x4a\xf5\x1c\xbd\x93\xaa\xb5\xb1\x39\x9d\xac\xe5\xb8\x3a\x0a\x35\x10\x24\x81\xd8\x08\xea\x6f\xf6\xce\x90\xa7\x4f\x7b\x16\x3f\xbc\xa7\xeb\xd6\x8d\xb8\x4c\x3e\xcd\xb7\x8d\x2e\xc1\x6f\xcb\x21\x58\xd3\x0b\x6f\x3f\xc0\xea\x40\x1d\x68\x68\xb8\x54\x6f\x36\xdb\xb0\xd5\x28\x68\x11\x0f\xc4\xc5\x44\x72\xea\x1c\x22\xbd\xb7\x87\xe5\xf5\x74\xe4\xb8\x1e\x1b\x88\x55\x6f\xd5\x63\xd1\x22\x48\xd8\xcc\x26\xef\xc4\x6c\x82\x4a\x75\xa0\x61\x93\x4e\x0d\x8d\x7d\x4d\xa9\xc5\x02\x20\xc5\x32\xaf\x03\x34\xc9\x44\x38\x10\xed\x2e\x2f\xdc\xf1\x37\x2e\x99\x8c\x90\x3d\xf8\x84\x5c\xc5\xe1\xeb\x60\x7d\x0c\xc5\x3d\xe4\x3a\xda\xa1\xfb\xc4\x4a\xf9\x49\xdc\x1d\x7f\x4a\xef\x1e\x95\x7a\xb6\x1e\x20\xa3\xa5\xa8\x1d\xda\x10\xee\x93\x9c\x92\x52\x68\x4b\x37\xb4\xcb\x71\xb9\x50\x3b\x70\x8c\xca\xb2\xb2\xda\xd9\x48\x87\xf6\x19\x6d\x68\x5f\x89\xec\xb2\xea\x48\x8e\xd4\x3b\x62\x30\x67\xa7\xe7\xf8\xd3\x72\x70\x76\x4e\x76\x8e\xd9\x8f\x92\xb1\x9e\x24\x27\xfb\xfd\xde\xea\x88\xdf\x65\x6e\x55\x1d\x31\xc7\xfb\x4e\x58\x9b\x0e\xf5\x6a\xec\x5f\x16\xa3\x32\x25\x74\xe2\x95\x7a\x93\x24\x05\x65\x8b\xcb\xb8\x80\x92\xe3\xe5\x77\xb0\xd1\x32\x92\x13\x36\xab\xb1\xa9\x97\xd2\x13\xcf\x56\x26\xb0\x71\xa9\x4a\x43\x7f\xa5\x98\xb8\x82\xb4\xd7\xc9\xe7\x59\xa3\x0a\x5c\x83\x3b\x8d\xbe\xfd\xef\xeb\x76\x3f\xf5\xfd\x2f\x3f\x4d\x9a\x3d\xff\x1e\xd3\x5f\x93\xbe\x78\xed\x8f\x3b\x67\x9c\x93\x83\xe4\xc0\x2b\x0b\x97\xf7\x18\x59\x3b\x7a\xcb\x80\xa8\xde\xf2\xe0\xb2\x05\xeb\x45\xae\xb3\x0d\xdf\x33\xb4\x5b\x21\x46\x72\xc3\x03\xd3\xf7\x6d\x78\xe6\x59\x9e\x6f\xb7\x6c\x52\xf5\x10\xdb\x23\x6b\x57\xad\xe2\xaa\x3c\x69\x3c\x57\x3c\xa2\xcf\xc0\x3b\x22\x9b\x06\xbe\xfa\xf4\x63\x4f\x3f\xa6\xdc\xe5\xc2\xde\xf3\xb9\xb0\xf7\x4e\xd0\x4c\x59\x34\x8f\x3d\x68\xd0\x8a\x62\x92\xde\x9c\xe6\x72\x39\xb1\xdd\x6c\xcf\xc9\x96\x0c\x4e\xe4\xac\x8e\xa4\x69\x2d\x08\x36\x1e\x21\x3b\x67\x77\x55\x47\xec\x12\x97\x5a\xad\x34\xf0\x6a\x3c\x2d\x69\x0b\x8b\x26\x0d\x79\x13\x46\xd7\x28\x86\x1a\xcb\x7a\xd3\x84\xa4\x20\x6b\xda\x4c\xdd\x26\xe0\x02\x25\xd6\x8e\x6d\x6a\xd0\xdd\x3b\x1d\x3f\xfb\xe2\x47\xdd\x77\xaf\x0a\x14\x9e\x3c\x25\x97\x4c\xc7\xb9\xd8\x3c\x7b\xf4\xc4\x7b\xe4\xab\x3f\xce\x1e\x3d\x7a\x36\x37\x02\x7f\xb2\xed\xc1\x91\x5d\x57\xa6\xd6\x86\xd6\x6d\xc2\x9f\xc8\x07\xfa\xf4\x89\xf4\xc5\x9f\xca\x07\xfb\xf7\xe9\x33\x40\xa9\x13\xa4\xfd\xdd\xec\x22\xea\xca\x64\x6a\x19\xe0\x98\xc2\x64\xca\x8a\x72\xc0\x93\x44\x26\x1e\xf1\x76\x9b\x60\xa4\x03\x97\x79\xe0\x68\x5e\x8a\x63\xd1\x38\xd6\xc0\x8a\x98\x79\x4d\x68\x46\x28\x85\x8c\x4f\x91\xcf\xcb\xbf\xc8\xeb\xf0\x44\x2e\xe7\x85\x67\x5e\xad\x3f\xfa\xfc\xf3\x5c\xa1\xfc\xbd\x7c\x01\x24\xe9\xdf\xa7\x0e\x5f\xff\xe2\x34\xbb\xa3\x53\xd7\x32\x80\x95\x5d\x1d\xce\xb5\x49\x92\x01\x3b\x74\x46\x41\x27\x78\x93\x9c\x06\x64\xa8\x8e\xd8\x54\x32\xea\x38\x9d\x04\xec\x26\x71\xd6\x1b\x92\xb1\xc9\x1c\x3d\x75\x84\x40\xcc\xc5\x00\xc0\x82\x99\x0a\x5c\xf4\xf6\xad\xa4\x7c\x19\x05\x4a\x01\x6f\x19\x19\x09\xc0\xfd\xfc\x33\x05\x6f\x32\x3e\x15\xfd\x85\x82\x88\x2f\xdc\x7a\xea\xb0\xfc\x37\x90\xa3\xd3\xa0\xf3\x80\x1e\x64\x3b\x83\xf1\x96\x70\x26\x8f\xe8\x24\x05\x38\xe4\xb0\xc9\x28\xea\x40\xba\x45\x80\x0e\x0c\x00\xb0\xb5\x29\x5c\x58\xdf\x28\xde\x8d\xd0\xe5\xc7\x67\x1b\x34\x3a\x22\x31\x91\x26\xdb\xaf\x7f\xc7\x35\x44\x0f\x73\x19\xd1\xcf\xb9\x91\x31\xf9\x65\xfd\xac\x68\x9d\x23\xdf\x0b\x65\xa0\x11\xe1\x12\x63\xaa\xcb\xe2\xf3\xe9\xd2\x25\x97\x8b\x27\xe9\xb4\x15\x4c\x16\xc8\x64\xaa\xd1\x60\x04\x1a\x19\x8d\xc8\x23\x49\x1e\x8f\xbd\x3a\xe2\xb1\x22\xb1\x9a\x96\x2e\xba\x12\x4b\x17\x13\xb2\x2d\xb1\x2a\x9c\x2d\x72\xa0\xb2\xfe\xef\xa6\xe1\xf8\xd4\xee\xd7\x0a\xff\xac\x51\xf8\xc7\xce\x79\x8b\xfe\xac\x37\xf8\xa6\x7d\xb0\xd7\x2b\xe4\x89\xb8\x03\xd0\x91\x9e\x01\xfe\xb0\x59\x04\x92\x61\xac\xd5\x69\x2c\x1c\xa1\x65\xcd\x1f\xbd\x5d\x95\x70\x80\x08\x52\xb0\xcc\x41\x33\xea\x3a\xd4\xd5\xd5\x5d\xd8\xb7\x4f\xf0\x5f\x3b\xc9\x12\xe7\x30\x6a\xd5\x70\x85\xfb\x07\xeb\x3f\x5b\x14\x76\xeb\x0c\x66\x38\xc1\x39\xbb\x8d\xd1\xc1\x42\x91\x87\x63\x25\x01\xf9\x38\x4f\xb0\x24\x5f\xb5\x05\x86\x0d\x8e\x55\x1b\xe0\x33\x57\xbe\x58\xba\xd5\x32\x2c\x7c\xfb\xd0\x1f\xf1\xce\x7a\x27\x4e\xc9\x1e\x39\x68\xcc\x14\xee\xce\x55\x51\x61\x7b\x1d\x52\xea\x9f\x79\xc2\xb7\xb5\x8a\xac\x5e\x0d\xc3\x9a\x88\x58\x59\x0f\xd8\xf6\xe1\x34\xad\xd1\x48\xcb\x6c\xf4\x88\x58\xcc\x5a\xc1\xc0\xf1\x3a\x02\x5f\xa0\xe6\xb1\xb1\x91\x0b\x98\x1e\xb4\xc7\xfb\x5b\xc6\xf5\xba\xa6\x8c\xd6\xbd\x57\x48\x1a\x60\x01\x6b\x74\xe6\xcc\x99\x75\x47\x8f\xe2\x0f\xf1\xf6\x51\xdb\x47\xe1\xeb\xf2\xe4\xed\xdb\xb7\xcb\x0b\xd5\xdc\x45\x80\xe1\x17\xa6\x73\x3a\x85\x33\x69\x75\xb8\xd9\x66\xb3\x5a\x0d\x22\x91\x5c\x0b\x5d\x07\x5c\x2f\xbb\x48\x95\x0b\x1b\x38\x27\x11\xcd\x1a\x8b\x4d\x94\xd8\x10\x58\xa5\x77\x36\xae\xad\xb5\xd9\x13\x0b\xee\x5b\x54\x87\xdf\xb0\x32\xfc\x99\x96\x55\xe1\xd7\x4e\xd2\x8a\xf0\x18\x3c\xac\x3e\xc2\x84\xba\x85\x0b\x0c\x18\x1b\x81\xff\x05\xa3\x60\xb6\x1c\xb0\xbc\x6c\x39\x63\x21\x07\x2c\x3f\x59\xb8\xc9\x96\x85\x96\x1d\xec\x13\x81\xd3\x1b\x89\xc9\x22\x1a\x63\x35\x12\x00\xd5\x3d\x53\x1a\xe7\x38\x28\x09\x95\x84\x65\x26\x2b\x93\x88\x94\xf9\x43\xfb\xd8\xec\x21\x3a\x6f\x48\xbe\x4c\x46\xc1\xfa\x0f\x67\xac\x4b\xa3\xb3\x86\x50\xac\x9e\x90\xe9\xac\x3e\xcc\x5e\xe9\x00\xb2\x72\x80\xe5\x4e\xba\x98\x0e\xeb\x88\x5a\xf3\x3b\xc8\x6f\x6c\xc6\x6a\x56\xd8\xee\x24\x66\x2d\xd1\x7a\xdc\xa2\xad\x6f\x44\x44\x86\xbe\xe0\xa8\x17\xab\xb3\x27\x1b\x35\x98\x9f\x8e\x14\x02\x85\x51\x9a\x21\xc4\x2e\x71\x41\x0c\xb8\x89\x38\x19\xbb\xe4\x2f\xc1\xac\x3a\x43\xfb\x44\x7e\x75\xfa\xdd\xcf\x3f\xfe\xe8\x0c\xf9\x2d\x56\x3d\xf9\xd2\xd2\xc7\xb6\xad\x5e\xf5\xc8\xce\x55\x94\x36\x9d\xd0\x78\xfe\x09\xf2\x4f\x38\x27\xf2\xc2\x92\xdb\x4a\xf4\x7a\xd1\x69\xe5\x7d\x49\x26\xd4\x37\x62\x72\x8a\xa2\x43\xa3\xdc\x12\x35\x1d\xb8\xa7\x74\x2f\xd5\xd0\x3c\xbd\x8c\x00\x05\x83\xcd\x61\xa7\x8b\xcf\x64\xfd\x28\xb7\xbe\x48\x87\x1e\x36\x76\xa9\x24\xe9\x4a\x2f\x4b\xe9\xab\x7d\xdf\xfc\x98\xd0\xe1\x52\x39\xa3\x8a\x1b\x3e\xe2\x0f\xf2\x43\xd9\xfc\xa5\x74\xd4\x25\x9c\xed\xb7\x18\x69\xb7\x75\x41\xeb\x92\x52\x6d\x66\xa3\x2e\x23\x68\x33\xa7\xba\x04\xad\xa8\x47\x7a\x5f\xdf\x88\x46\x8f\x1c\x7d\x23\x56\x7a\xd9\x4e\x69\x12\x6a\xd2\x8f\x55\x89\x8b\x66\xfa\x33\xca\x4a\x2b\xb2\xcb\xdc\xe5\x21\xbf\xcd\xa9\x71\x4b\xd9\x62\x76\x49\x05\xa6\x60\x3b\xd2\x35\x98\xd1\x69\x2a\xad\x19\x1d\x31\xed\xa3\x95\xe7\xb8\x56\x83\xc7\xbe\xb9\xf4\xa7\x45\x43\xa2\xef\xd4\x9c\xf9\x62\x71\x7f\xae\x75\xef\x77\x4b\xfe\xf8\xe1\x95\x19\x23\x77\xd7\xf7\x95\x7d\x6f\x4e\x1d\xbc\xfb\x99\xde\x2f\xb9\xf1\x37\x5d\x56\xec\x5c\xc5\xf5\xf4\xc8\xa9\x9d\x1f\xd8\xb6\x1a\xa9\x73\x2f\x35\x21\xd0\x79\x49\x6a\xd7\xa8\xb6\x60\xa2\x64\x79\x25\x83\xcf\x87\x0a\x02\x56\x6b\x81\x97\x14\x16\x25\x65\x55\x47\x24\xb7\x41\x97\x94\xe4\xd6\xb9\x73\xab\x23\x6e\x97\x03\x8e\x56\x87\xcb\x14\xac\x8e\x98\xfe\xcc\x2e\x69\x5a\x9a\x91\x90\xd1\x9b\x60\x86\xc4\x75\x9e\xdf\x5d\x1e\xa0\x3d\x90\x39\x36\x6e\x94\x5a\x1e\x0a\x37\x58\x69\x19\x8a\x6a\x78\x0c\x56\x1b\x64\x81\xdd\x61\x9f\x73\x2f\x96\x7e\xb8\x26\xff\x2c\x7f\x3b\x7d\xbe\x7c\x1d\xec\x8d\x13\x2b\xb7\xef\x5c\x2f\x7f\xb4\xeb\xc1\xeb\xbf\x2b\x2d\x94\xb8\xce\xac\x85\x12\x46\xcf\x3f\x4f\x59\x49\xbe\x28\x7f\x7b\xf0\x20\x58\x19\xd9\x9f\x9d\xf9\xf0\x23\xfc\xcc\x19\xf9\xe5\xc6\xbe\x59\x9d\x81\x97\x47\xb2\x7a\xae\x4c\x74\x73\x38\x60\x25\x48\x72\x3a\xfd\xa6\x24\x84\x7c\x1a\x93\x26\x2b\x9b\xb7\xa6\x84\x3d\x1e\x7d\x92\xd3\xa2\x0f\xf6\xa6\x99\xdf\xf1\x88\x7a\xd2\xdb\x95\x37\x4c\x70\xc5\x71\x0d\x1e\x6c\x4c\x09\x0d\x51\x9c\x6c\x0e\x6b\x3c\x63\x81\xf4\x5c\x3d\xfb\xbe\xcd\x67\x5e\x3e\x71\xe6\xf1\x59\xb3\x57\xd5\x8f\x1e\xf2\x72\xe0\xec\xdd\x53\xa6\x4d\x9c\x70\x0f\xdf\x76\x49\xbd\x87\x77\x9d\x58\xfd\xca\x99\xbf\x1f\x5f\xfd\x8a\x93\x4f\x79\x7e\xd1\x82\xe5\x58\x13\xed\x8c\x8d\x2b\x96\x2c\x7e\x60\x39\xd3\x0b\x03\xb8\x54\x56\xb7\x6c\x04\x89\xb3\x89\x1a\x64\xd4\x18\x4d\x66\xa4\x69\xdc\x0e\x9a\xf6\x59\x92\x28\x71\x4a\xba\x44\x90\xd6\x26\xdb\xc8\x70\x2a\x47\x2f\x51\x89\xe2\x52\xa9\x90\xb1\xd1\xdb\x5f\xd3\xf7\x52\x59\xe7\x52\x41\xdf\xc0\x7b\x91\x49\x04\x22\x98\x2d\xa2\x49\x4f\xed\x7b\x15\xfb\x66\xef\x55\x76\x2b\xa4\x54\x3e\x63\x07\x15\xce\x97\xa8\xb8\x72\xa9\x1f\x7d\x7c\xe6\x8b\x58\x6d\x33\x9b\xb7\x06\x4c\x77\x05\x68\x0d\x22\xa0\xd4\x51\x21\x6c\x15\xb1\xe8\x94\x8c\x7a\x7a\xac\xc2\xb1\x6e\x60\xc7\xba\xf4\x67\x75\x54\x81\xc6\x21\x5f\x5e\x1c\xb3\xcc\x6e\xaa\xc3\xef\x1c\xfa\xe7\x27\xf5\x60\x49\x98\xc7\xce\x98\x3e\x8e\x6f\xfb\xdc\xc3\x5b\xeb\x38\xb3\x3c\x67\xd4\xf0\xa1\x77\xd2\x75\x61\x71\xf2\x3a\xeb\x99\x2a\xd1\xb9\xc1\x04\x09\x60\xf9\x18\xf4\xb0\x9e\x4d\xd0\x0b\x6e\x17\x01\x6d\xdf\x3b\xe2\x74\x72\x5a\x36\xff\xd9\x62\xe0\xa4\x84\x6b\x85\x1b\x94\x3e\xb2\x7d\xa6\xb5\x65\x59\x34\xcb\x0b\xf4\xba\x37\x9e\xc4\xcc\xb9\xe5\xd7\x4e\xe3\x9a\xdf\x3f\x79\x17\x1f\xa8\xbb\xb4\x78\xd6\xf8\x7b\xa3\xf8\x94\x5c\x8e\x3f\x0e\x61\xe1\x91\x0d\xd7\x4e\xe2\x53\xf8\xe7\x21\xb5\x43\x6b\x9b\xc3\xd5\x25\x9c\xae\x33\xea\x11\x92\x24\x62\xd0\xeb\x6d\x1a\xa2\x71\xbb\x8c\x00\x8d\xce\x68\xe4\xb1\xde\xc2\x3b\x7b\xc7\x2d\xc1\x26\x2d\xef\x9b\x80\xc4\xc6\x5d\x01\xd3\x59\x69\x34\xcc\x1d\x03\x89\x38\xea\xe4\xea\x77\x3f\xf9\x5d\xde\x73\x1a\xb7\xbb\x1e\xbd\x77\xfc\xac\xc5\x97\xa8\xf9\x75\xed\xe4\x86\x47\xb0\x10\xc2\x1f\xcb\xe5\xf3\x00\xa2\x21\x8c\xaf\x82\x00\xd3\x32\x66\x8f\xb6\x0b\xa7\xf3\x02\x16\x10\xd1\xea\x16\xea\x70\x95\x0e\x5b\x75\x7e\x1d\x67\xd1\x81\x09\x26\x48\x44\x83\x34\x89\xb9\xe8\xd4\xd0\xa9\x8d\x9d\x7f\x6a\x1a\x7a\x50\x4d\x3c\xaf\x63\x09\xe7\xd7\x6f\x25\xcf\xc3\xd9\xb1\x14\xe4\x4d\xa6\x79\xb5\x64\x26\x5b\xaf\x0b\xaa\xe1\xd7\x91\x63\x20\x7f\x79\x61\xbb\x0e\xd9\x1d\x0e\x41\x30\xbb\x90\xcb\x97\x8c\x92\xec\x3a\x3d\x2a\x7e\xbb\xa4\xf8\xed\xa6\xb8\xd2\xd7\x97\x30\x8d\x4d\xc3\x1a\x25\x15\x92\x99\x8b\x09\x5c\xa0\x0b\xb7\x7f\xfc\x8c\xd2\x43\xdb\xa2\xab\x49\xdf\x97\xf2\x84\x82\xca\xdb\x27\xd7\x1e\x7c\x2b\x5a\x8c\x4d\x79\x43\x22\x8b\x37\xd4\x89\x7b\xc1\x8b\xe6\x48\xc7\x27\x66\x1f\x7a\x92\xe9\xc0\x9b\x51\x8d\xb0\x97\xad\x9f\x0a\xfa\xbb\x5b\x38\x5d\x85\x40\x97\x14\x48\x49\x49\x4f\x4d\x4d\x72\x91\x8c\x60\x7a\x9a\x2f\x35\x0d\xbe\xf4\x09\x30\x31\x53\xc3\xfa\xb6\xf5\xed\x1b\xf4\x83\xa3\x9d\xb5\xfe\x0c\x42\xcc\xcc\x62\x29\x88\x87\xfc\x09\xa8\xf2\xc5\x7a\xf8\xe7\x46\x00\xe3\x8e\x4f\x70\x85\x4f\x2a\x76\x4a\x55\x43\x84\x5f\xcd\xff\x0b\xe5\x82\x6d\xe4\xb3\x79\x74\x46\x1d\x0a\xf0\x92\x64\xcc\x4c\x0e\x24\xe7\xe5\xe7\x7a\xc0\x86\x07\x5d\xaa\xd5\xc5\x80\x2d\x0e\xbd\xdd\xd4\xed\x89\x0d\x49\x50\xa4\xa8\x19\x98\x71\x68\xcb\x62\xbf\xaf\xe2\xf6\x3f\x36\xeb\xc0\x8e\x46\x60\xa7\x0e\x1a\x31\x7e\xc2\xf0\x43\xa7\xa3\xc5\xf4\x37\xcf\x3e\x1e\x5d\xcd\xdd\x3b\x60\xf2\xd4\xfb\x9f\x53\x21\x6e\xbb\xe1\xee\xb9\x6b\x93\x49\x9b\xed\xf7\xec\x7a\xe4\xd0\x80\xc9\x33\x96\x28\x75\x18\x1a\x20\xfa\xef\x2c\xaf\x3a\xd2\x32\xcf\x1a\x7e\xdf\x17\x7e\xbf\x85\xfd\x5c\x8b\x1a\xed\x72\x5a\xc7\xdc\x27\x9c\x6b\x76\x2a\x8d\x44\x6c\x3c\x71\x13\x5f\x92\xd9\xe9\x34\x52\xb9\xb5\x21\xda\x49\x84\x79\x2f\x37\x30\xc7\x13\x3b\x89\x34\x16\x89\x36\xb7\xc3\x9b\x76\x12\x69\x34\xbe\x67\xaf\xd8\xd2\x0a\x97\x47\xbf\xe5\x2e\xca\xbb\xf7\x1c\x56\xcc\xee\x91\x83\xc6\x8f\x58\x81\x73\x57\x2d\x93\xff\x46\x9e\xde\xb8\x89\xdd\xd5\x74\x6a\xb8\x4c\xf2\x99\xef\x3f\x32\x5c\x96\x92\x9a\xca\x5b\x91\x43\xa7\xd7\x7b\x32\x32\x1c\x56\x92\x93\x9b\x8d\x01\x50\x07\xc8\xb0\x29\xdb\xe3\x0c\x64\x3b\xb3\x9d\xa6\x94\x40\xc0\x57\x1d\x09\x58\x75\x26\x93\x06\xce\x52\x57\x63\xe0\x1d\x51\xe8\x94\x19\xdd\xcc\x9f\x6f\xc1\x61\x34\x50\x93\x50\x54\x10\x3b\x67\x62\x79\x61\xd4\x9e\x51\xab\xd0\x38\x6b\xbb\x59\x77\x8d\xe8\xb7\xa3\x6c\x6f\xda\xe9\x8d\xbb\xff\xb6\x65\x51\xb3\x1f\xf1\xbe\xea\xde\xe1\x01\x4f\x3b\xd7\xac\xdf\xb0\x6c\xda\x6a\xf1\xde\xd8\x4f\x1b\xef\x87\x9f\x94\xb8\xfc\x15\xfe\x30\xdf\x13\xe5\x83\x86\xca\xf0\xe6\x18\x88\x45\x92\x02\x16\x12\x20\x85\x05\x39\x5e\x03\xb1\xfb\x33\x32\x52\x68\x30\xc3\x6e\x45\x80\x85\x42\x7a\xf5\x46\x10\x85\x9a\x8e\x3f\x74\xc7\x28\xce\x0e\xf5\x2a\x3a\xf1\xb4\x2c\x96\xae\x60\x51\x0a\xff\xd4\x08\x44\x56\x31\xd6\x98\x31\x2e\x1c\x38\xbd\x4d\x4d\x60\x50\x61\xfa\x2d\xde\xda\x87\x6e\x6b\xfb\xca\x0b\xf5\xaf\xb6\xbd\xed\xa1\x5a\xef\x2d\xe9\x85\x83\x02\x35\x95\x53\x6b\x06\xce\x69\x5b\x51\x51\x39\xdb\x59\x51\x35\x35\xbb\x34\x3d\xb8\xe4\xd0\xe0\xe5\x9d\xd7\x3d\xbe\x7d\x7d\xe7\x95\x83\x0e\x2d\x09\xa6\x97\x66\x4f\xad\xaa\xb8\x65\x70\xff\xfe\x83\xba\xc5\x6c\x69\x56\x13\x2f\xa0\x94\xb0\x99\x8e\x75\x10\x35\x02\xd7\x9b\xfa\xd9\xea\x89\x83\x2b\x2b\x63\x2d\x07\x94\x76\x03\x75\x4c\x71\xc5\x6a\x88\xe2\xbc\xcb\xf5\x8a\xdb\xe6\xaf\x33\x5d\xd9\x39\x9c\xcf\x61\x01\xce\x32\x9d\x76\x87\xee\x80\xee\x65\x1d\xd9\xa1\xfb\x4a\xc7\x0d\xd7\x3d\xa8\xa3\x3f\xf3\xa0\x35\xf5\x44\xc3\xf7\x8e\x80\xff\xa5\x74\x95\xca\x67\x1a\xb3\xd1\x34\x57\x22\xc3\x6c\x7a\xc2\xeb\x75\x72\x31\x2c\x7c\xed\x24\x6d\x3d\x1c\x5b\x5b\x3d\x3b\xed\xa2\xd0\x86\xad\x3d\x1f\xe4\xa6\x9c\xc9\x45\x38\x1c\xd0\x0a\x66\xaf\xd7\x80\x6c\x4e\x27\x12\x48\x92\xcf\x83\x0d\xb8\x3a\x62\x2e\x36\x60\x83\xc1\x6e\x14\x95\x59\x86\xa1\x50\x65\x71\xed\x0d\x9a\x94\xd2\xd6\xb1\x4a\x03\x60\x7a\x5d\x0b\xff\x56\xeb\x96\xe8\xc0\x14\x6e\xd1\xc6\xef\x17\x3c\x73\x68\xd7\xc1\x27\x0f\x3d\x73\xef\x95\xad\xb8\xfc\xee\x63\x33\xf1\x9d\xf2\x5b\x8f\x1e\xe0\x16\x44\x17\x3d\xbd\x03\x97\xca\x8f\xcd\x3e\x36\x4e\x3e\xa5\xe8\x24\x03\xf3\x13\xda\xc2\xe9\xde\x27\x5c\xc1\x81\x54\x3a\x6c\x3a\xe2\x94\x26\x4b\x0b\xa5\x07\x25\x32\x59\x3a\x20\x71\x48\xf2\x4b\xad\xa4\xe1\xec\x33\xd1\x44\x6c\x40\x7e\x9b\x45\x03\x1e\x9c\x06\x4c\x00\x8d\x4b\x99\xba\xc8\x24\x97\xd2\x87\x92\x27\x66\xb7\x07\x6e\x50\x4b\x47\xc6\xb4\xac\x03\x69\xd9\x07\xf0\xda\x49\xc4\x35\x5c\xc7\x97\xc8\x4e\x36\xeb\xd1\x4c\xbb\xbe\x1b\x8c\x3c\xd2\x68\xac\xc0\x04\x70\xda\x9f\x8f\x54\x51\x52\xf1\x5a\xe1\x02\xe2\xbf\x8b\x15\x97\xd7\x26\x86\x87\xe9\xe1\xaa\x04\x2c\x75\xf0\x52\xf8\x2e\x8b\xd8\x27\xc8\x35\x93\xd6\xe1\xe5\x5b\xf1\x62\xb9\xd8\x90\xb6\x10\x0f\x98\x1b\xc0\x60\xeb\xc8\x5f\x92\xb3\xd7\x53\xc9\xa8\xf4\x21\xf2\x53\xb8\x53\x1f\x38\xe7\x0d\xf8\x92\x50\x0e\x6b\xd3\x8d\x18\x1f\x6e\x67\xd0\x98\x9d\x9c\x04\x3c\x07\x92\xcf\xa6\x8b\x98\x89\xdb\xe5\x04\x28\x74\xc6\xf3\x11\x8b\x13\x03\xb3\x18\x89\x53\xe7\xd4\x21\xc1\xaa\x15\xb4\xe7\x23\xc2\x05\x80\xca\x74\x3e\x82\xbe\x8b\xdf\xb6\x33\xb5\xa6\x36\x66\xad\xcd\x6f\x36\xa7\x43\xb1\xb2\x59\xe5\x5c\x62\x3c\x53\xc2\x41\x0b\x80\xce\xad\x92\x37\xdd\xbf\x0e\xbf\x4f\x3a\x44\xa3\x74\xc8\x1c\x97\x1a\xed\x3f\xa8\xd8\xf3\x08\x2e\x8f\x41\x3f\x4d\x3e\x35\x45\xde\x3f\x8d\x4c\xbf\xab\x42\x7e\x01\xce\xc8\x32\xa0\x5d\x2a\xc0\x6f\x02\xf8\xe9\x1d\x41\xae\x23\x29\x89\x37\x6b\xb5\x2e\xc4\xa3\xd4\x34\x03\x9d\x82\x0a\x80\x3b\x00\x6a\x87\x83\x17\x04\x3b\x83\x38\xe9\x7c\x84\xff\xee\x06\xb1\x99\xa6\xf5\x53\x8a\x05\x29\xb2\xa1\xb2\x4a\xd5\x6c\x2c\xa6\xe5\x28\x55\x42\x5b\x24\xf5\xe8\x53\xf2\x5c\x3c\x18\x0f\xe8\xdf\x7f\xd2\xd4\xd7\xc6\xdc\xf1\xce\x3b\x6f\x56\x7c\x77\xe1\xe7\x29\xe3\x09\x7f\xdf\x06\x72\xf6\x97\xdb\xe7\x7a\x6c\x4b\xf0\xe8\xdb\x6f\x92\xdf\x91\x2f\xec\x93\x77\xd6\xb0\xfc\xb8\xcf\x01\xe6\x3b\xd8\xbc\x59\xea\x97\xd5\x84\x0b\xf4\x1a\xc1\x4f\xfb\x94\x62\xab\x4f\x10\x1c\x46\xab\x31\x98\xe1\xd2\xdb\x11\x00\xeb\x07\xb9\xb6\x72\x56\xf7\xf9\x88\xf5\x3b\x2e\xed\x7c\x84\xbb\xd0\xb4\x55\x47\xd3\xa0\x61\x2c\x66\xa8\x9c\x9f\x74\x5c\xa7\x5f\x09\x1a\xc6\x86\xcf\x0a\x31\xc0\x55\x44\x32\x86\x52\xe0\xbb\xfe\x75\x65\x0f\x8a\xc8\x50\xae\xfe\x5b\x00\x7e\x5c\x39\x43\x84\x2f\xc4\xdb\x7f\x19\x77\xd3\xac\x2e\x13\xee\xdb\x80\x4f\xef\xa6\xd0\x73\x12\xc5\x84\xf9\x26\x25\x80\xc3\x44\x36\x57\xdc\x4e\x63\x83\x16\x41\x0f\xaa\xcb\xe1\x14\xcd\xe7\x23\xe2\x05\xc1\x02\x64\xfe\xee\x06\xb1\x41\x2a\xb9\x34\x6e\xc9\x6b\x62\xd1\x41\x32\x71\xda\x27\x2b\xe5\x2d\xb8\xfd\x7f\xb0\x6e\xcd\xf1\x23\xfb\xde\xdc\x51\x4f\xce\x6f\xf9\x76\x0e\x39\x1b\xbd\x74\xe4\x78\x94\x7b\x9f\x9e\xb3\xb0\x56\x36\xac\x65\x00\x2f\x28\x43\xd0\xe9\x90\x86\x80\xc3\x6a\x34\x51\xfe\xb3\x08\xb0\xb5\x34\xdc\x8e\xf9\xf3\x11\x7c\x01\xe9\x1a\x59\xb1\x45\xd8\x2d\xa6\x54\x1c\x8d\x41\x37\xa9\x35\xf7\x8f\xe8\x73\x5c\x66\xf4\x33\x6e\x2c\xac\x12\x63\x2f\x45\x67\xf8\xe1\x13\x57\x6c\x5d\x11\x3c\x00\x2d\x0f\xdf\x9b\x8c\x02\xdf\xb8\xae\x4e\x07\x40\xe8\x2e\x20\xfc\xbf\xac\x5b\x16\xa0\x59\x45\xec\xff\x7e\x6e\x2c\xac\x99\x09\x6b\xff\x03\x5f\x9a\x86\xfb\x4c\xc1\xe5\xd3\xae\xa7\x2a\xeb\xb6\xc2\x9f\x93\x57\x85\xcf\x80\x9f\xe9\x5c\x27\xa4\x11\x45\x87\xc7\x23\x21\x92\x9a\xe6\x92\xce\x47\x5c\x1a\x97\xc6\x47\x7c\xd6\xf3\x11\xdf\x45\xa2\x3f\x1f\x21\xdf\x26\x2c\xcb\xe6\xe5\x35\x9d\x32\xe4\x28\x6d\x39\x20\xa3\x8c\x82\x40\x15\x16\x6a\x75\xed\xfc\x13\x6f\x96\xde\x97\xbb\x7a\xdc\xe3\xfb\x8e\x3c\x5e\xb3\xbd\x4c\x3e\x8b\x77\x74\xfb\x7a\xe9\x79\xb9\x81\x7c\x75\x15\xeb\xa6\xce\xcd\xed\x77\xfb\x5b\x47\x5f\xf8\xa4\x22\xf4\xec\x4c\x79\x77\xaf\x21\xd8\xa1\xd4\xa4\x02\x6d\x3a\x31\xda\x84\xc2\x5e\x2d\x42\x06\x3a\x78\xc9\xc0\x9b\x8c\x1a\x50\x16\x74\xec\x52\x13\x7d\xd5\xa2\x17\x55\x42\x31\x2f\x77\x48\xd6\xad\x5e\x8d\xff\xb3\x16\x44\x1c\xbc\x11\x72\x56\x1e\x8a\x77\x02\x29\x30\xba\x13\x5f\x42\x3f\xc3\x1a\x04\xb9\xc2\x3a\x8c\x10\x2f\x70\x17\xf0\x77\x89\x09\x0c\xf0\x8e\x9f\xd7\xac\xa1\x1b\x47\x61\xb2\xe1\xcf\xb9\x01\xf0\xf7\x56\xea\xc1\xe9\xcc\x84\xe3\x8c\x66\x02\x0e\x25\x41\x46\xa3\xe1\x7c\xc4\x78\x01\x89\xb0\x4b\x17\xd1\x0d\xcb\xa2\x69\xf4\xa5\x79\x54\xb0\xe2\xd7\x56\x2b\x4d\x7d\x3a\x76\xee\xf5\x3c\xee\xb2\x09\x7f\x8e\x75\x9e\x7e\x83\x46\x0c\xe7\x6e\x99\x16\xed\xf6\xe0\x1e\x65\xaf\x28\x6f\x0e\x66\x74\xe8\x18\x4e\xc5\x7a\x8d\x8e\xd2\x41\x0b\x3c\x6a\xe0\x0d\x46\x13\xa7\xd1\x6b\x30\x69\xa2\xbc\xd9\x6a\x37\x74\xd9\x94\x06\xe9\x54\x8b\x73\xfb\xe5\xfb\x67\x00\x4d\x5e\xd9\x25\xdf\x85\xdf\x05\xba\xfc\xa3\x56\x5e\x02\x84\x49\xc2\x17\xe4\xea\xe8\x3b\x74\xdd\x42\x7c\x89\xdb\x0a\xeb\x0a\x28\x0d\xec\x05\xa0\x8d\xa8\x01\xee\x27\x8d\x5c\x18\xb7\x18\x1c\x94\xce\x52\xe1\x6a\x7c\x96\xd2\xe9\xfa\xba\x69\x0c\xee\x52\xf8\xe1\x4b\x78\xde\x4d\x4f\x1c\x8b\xd1\x68\x92\x10\x02\x0d\x64\x22\x1e\xaf\x74\x81\xe8\xed\xc4\x64\xbe\xa0\x41\x26\x0a\x74\x93\x1e\x99\x8d\x3b\x58\x5a\x01\x87\x4d\x90\x64\x65\xbb\x59\x5f\x4c\x65\xbc\x85\x8d\x0c\x23\x7c\xa0\x61\xe4\xb5\x54\x1b\x59\x70\x18\x35\xe8\x92\x75\xa9\xd7\x0e\x00\xac\x1b\xe7\x64\x48\x77\x45\x6f\xe1\x76\xf5\xec\xb2\x2d\x3a\x16\xa4\xbb\x8f\x67\x5c\xe0\x0e\x6e\x7f\x8c\xe7\x63\xfc\x64\x44\x45\x61\x49\x04\x1a\x82\x64\x19\x79\xa3\xc9\xac\xc1\xbc\x3e\x91\x97\x2a\x9b\xb1\x92\x0e\x2b\xeb\xb3\x16\xa6\xdc\xa3\xb2\x49\x58\xb0\x03\xff\x26\x2e\x82\xf7\x95\xef\x8c\xde\x0d\x18\xbf\xd6\x6f\x08\xb7\xaa\xf9\x3a\x26\x54\x10\x76\x9a\x08\x9d\xa6\xa1\xd3\x22\xad\xd9\x22\x18\x45\x7c\x41\x47\xa9\xa7\x64\x6c\x36\x5d\x85\x12\xd1\xa9\x8c\x6e\x2c\xad\xc0\x45\x0b\x45\xfc\xdb\xe3\x0b\x05\xd9\x4c\x49\x1a\x9d\x6e\xde\x49\xda\x5d\x4f\xe5\x1e\x1e\xd4\xed\xfa\x29\xd0\x8d\xf9\x20\xbf\x17\x41\x7e\x69\xfe\x33\xe8\x46\xbb\x68\x44\x22\xf2\x78\x75\xa0\x15\x75\xdf\x12\x10\x61\x72\xf1\x46\xba\x91\x06\x29\xd8\x68\x27\x94\x58\x3e\x42\x2e\x36\x7c\xfd\x65\x83\x7c\xf6\x4b\xd4\xf0\xe0\x73\x8f\x6e\x3f\x74\xe8\xb1\xc7\x9f\x25\x5f\xfd\x20\x5f\xc2\xf6\xab\x3f\x62\xa3\xfc\xcb\x0f\x2f\xbe\x4d\xe5\xf3\x8c\x12\x33\x2a\xc5\x5f\x70\x9f\x09\x75\x60\x7b\x65\xa2\xdb\xc2\x19\x0e\x0d\xef\x76\xb9\x52\xa8\x31\x11\xd4\x5b\xf5\x59\xd9\x0e\x0d\x1c\x3a\x49\xe7\xc0\xc1\x31\x11\x97\xc9\x7f\x2e\x62\x52\x60\x29\x0e\xc5\xee\x05\x6e\x1c\x38\xa2\x61\x94\xd8\xfc\x54\xd5\xa6\x57\x42\x47\xee\x84\x10\x29\x5e\xde\x77\xc4\xa2\xbe\xb7\x0c\xb8\xe3\x2f\xcf\x3e\xf3\xe4\xf0\x81\xdd\xfa\x2c\x1c\x1a\xb9\x73\xea\xa8\x7b\xee\xb9\x73\x0a\xff\xea\xc2\xc9\x77\xef\xf4\xf9\x9e\x9a\xfd\x52\xdd\xe1\xbf\xce\xdd\x93\xe2\x7e\x6c\xca\x8c\x39\x77\x3e\x3c\x6b\xfd\xd2\xe5\x0f\xce\x7a\x98\xc1\x0e\x3c\x4d\x7c\xb0\x37\x7a\x96\xc9\x96\x64\x11\x04\xd1\x00\x94\xb3\x3b\x2c\x54\xe1\x5a\x44\x8d\x06\x4e\x17\xcd\x05\xf1\xbb\x3f\x8b\xc1\x28\xa7\x35\x0b\xc4\x68\xe8\x49\x17\x28\x21\xbe\xba\x2d\xf2\xf7\xab\xf1\xa6\xbf\x1c\x58\xfd\xe9\x35\x8c\xdf\xe7\xb7\xaf\xde\x2d\x2f\x20\x67\x1f\x5f\xfd\x57\x79\x91\xba\xe6\x14\xd5\x7e\xe8\x1d\xce\xc5\x46\xbb\xc9\x4e\xb9\xcf\x64\x32\xeb\x78\x9d\xcb\x6d\xe4\xec\xa0\xd0\x2c\x76\xd0\xf6\x76\x3b\x18\x10\x36\x6a\x40\xa8\xdc\x98\xa8\xe8\x6f\x1c\x87\x01\x93\xc6\x16\x8b\x0b\x81\x22\x28\x55\x2e\xed\xb8\xf7\xfe\x23\x7f\xb5\x1a\xbf\xfe\x97\x03\x73\xef\xc6\x96\x23\x1f\xca\xef\xe3\xd0\xb0\xc9\x20\xe6\x5b\xe4\xd1\xe4\xec\xa6\xfb\x27\x6c\x94\xe4\xfe\xdc\x2b\xcf\xc8\x5b\x86\x31\x9e\xcd\x03\x18\xbb\x32\xfb\x30\x23\x6c\xc7\x9c\xc8\xf1\x04\x9c\x67\x9e\x1e\x43\xc2\x05\x4e\xa1\x46\xdc\x74\x56\x8d\x75\xea\x2d\xca\x0f\xc8\xf5\x24\x59\xa8\xb9\xbe\x0e\x4e\x59\xf5\x4c\xcb\x06\xde\xa4\xef\xb2\xd1\xb9\xe2\x22\x31\x5a\x88\xc5\xee\x30\xf1\xca\xc1\x79\x31\x96\xa3\x99\xc0\x96\x8d\xbd\x81\xd5\x9e\x01\xf8\xe0\x91\x0f\x56\x2f\xba\x77\xe1\xf2\xd5\x9f\xe0\xcf\xdf\x7c\x96\x9b\x15\x5d\xbf\x74\xd5\x43\xcb\xb9\x91\xd1\x47\xea\xde\x63\x6b\x60\x7c\x89\xff\x0d\xd6\x70\xa2\xac\xb0\xd3\x69\x37\xe8\x78\xc9\x65\xbe\x60\xb0\x03\xd8\x0e\xdd\x05\xac\x8d\x6b\x42\x45\xa9\x50\x8f\x11\xd4\x88\xa8\x61\x77\xee\x54\x8b\x38\x5c\x6e\x47\x88\xfc\xbc\x6b\xb7\xcb\x61\x4e\xde\xbd\x4b\xfe\xfd\xe1\x53\x9e\x94\xbf\xdc\xbf\x3b\xd3\xf6\xc6\x7a\xd0\x25\x33\xaa\x17\x8f\x98\x1c\x5d\x09\xa2\x7d\xf0\x9e\xe9\x70\x8e\x6e\x5c\x33\x80\xf4\x84\xbd\x6c\x07\xb8\x69\xf8\x5f\x58\x9d\xcf\xf8\x70\xdb\x42\x62\xb6\xf8\xb5\x39\x39\x3e\x49\xb2\x10\xd2\xaa\xb5\x5f\x4c\x11\xf3\xce\x45\x44\x11\xd9\x2c\xe6\x34\x73\xb1\x99\x58\x88\xd9\x6c\xb3\x19\xce\x45\x6c\x57\x52\x3c\xe7\x22\x29\x29\x08\x65\x9c\x53\x34\xa8\xd2\x02\xad\xd9\x45\x76\xf3\x99\xbb\xa1\x46\x1a\x95\x82\xd3\x18\xef\xb3\x42\x37\x5c\x69\xa7\x2c\xb1\x8a\xd6\xa0\x19\x67\xb3\xee\x45\x1a\x36\x81\x1e\x27\x4d\x9e\xb4\x65\xd7\x93\x3d\x7b\xf7\xee\xa1\x59\xe8\xc7\x9a\x95\xab\x93\x73\x1c\xae\x50\x41\xd7\x76\x02\x5f\x3c\x3b\x7c\xd3\xd8\x0e\xf7\xcf\x1b\xd1\x09\x7f\x3e\x7b\xdc\xac\xf9\x84\xe4\x0d\xeb\xd5\xb6\xca\xf8\xce\x7d\xf3\xe4\xfa\xca\x4a\xe1\x76\x43\x8f\x9e\x03\x6e\x1b\x16\x9e\xd0\xbe\x23\x47\x6e\xef\x5d\xd5\x19\xfc\x87\x2b\x70\xee\xd5\xab\x78\xdf\x15\xce\xcc\xf5\x6b\xb5\x49\x4e\xb3\xa5\x90\x10\x8b\x13\xf0\xce\xd5\x9c\x8b\xf8\x73\xc3\x3a\x63\xb7\xdc\xdc\x14\x1b\x43\xf4\x8a\xb9\xbe\xe1\xe5\xb0\xdd\x6c\xeb\x16\x23\xc0\x45\x86\xf9\x95\xc4\x1e\x39\xf9\x71\x21\x6b\x3e\x32\x90\xe2\xdc\xec\x72\x5e\xa4\xb1\xbd\xc6\x74\x5a\x97\x3b\xd4\x11\xbb\xd3\xcd\x38\x05\x57\xb0\x60\x13\xfe\x54\xc5\xb9\x57\x0f\xfd\x42\xbf\xfc\x7b\x22\xce\x79\xf3\x3a\x75\x19\xdb\x8e\xe2\xcc\xff\x12\xc7\xb9\xac\x0b\xc5\x19\x77\x53\x71\xee\xdb\x73\x58\xa7\x89\x6d\xe3\x38\xd3\xbd\xe6\x9e\xe1\xaf\x82\x4f\x9f\x4e\xa7\xda\xa7\x18\x5d\x2e\x9b\x5b\xb4\x89\x19\x41\xf3\x65\x03\xd2\x12\x2d\xa8\x36\xed\x15\x02\x9a\xce\x49\xb5\x6d\x28\xc1\x42\xaa\x4a\x6c\xc1\x1d\x1f\x77\xa3\x34\x61\x2a\xad\x08\x69\x6c\x4e\x77\x30\xab\x0c\x27\xd4\xb2\x71\xc5\xc1\x49\xfd\x1e\x58\x8c\xcd\xfd\x26\x07\xb1\x66\x3a\xcf\x4f\x17\xe5\x15\xbd\x6b\xc7\x0c\x1d\x7a\xd7\x90\xbe\xdc\xa8\xdb\xaa\xfe\x76\x12\xaf\xe9\x74\x73\xa8\xeb\x72\x39\x6f\x54\x9b\xbc\xde\x98\x3c\xbe\x62\xc3\x63\x1b\x1f\x78\x40\xb9\x87\x29\xc4\x9f\xf3\x9b\x61\x7f\x72\x58\xee\xc5\xc6\x70\x51\x99\x36\xc7\x14\x6c\x57\xea\xf1\xe0\x76\x85\x69\x0e\x47\xbb\x1c\xd2\xbe\x43\x4e\xd9\xb9\x48\x4e\x4e\xa6\x21\xd7\x0d\x3a\xd9\x1a\x0c\xa8\x1b\x66\x0d\xa4\xd2\xad\x4a\x87\xad\x4a\x4d\x0d\x04\x7c\xe7\x22\x81\x40\x66\x66\x9b\x73\x91\xcc\x8b\xd6\x56\xe7\x22\xd6\x2b\x1a\x0d\x78\x87\xe7\x22\x86\x2b\x37\x48\xbf\x88\x37\xf2\x03\xce\x55\x6f\x3b\x12\x47\x5f\x26\xa6\x5f\xd0\xe4\x0b\x65\x0c\x04\x0b\xd0\xb8\x5b\xa6\x5f\xc0\x0e\xc7\xb3\x2f\x70\xb3\xec\x0b\xae\x94\xbb\x6b\x68\xf5\x70\xdb\xf8\xcc\x4d\x93\x3e\xbd\xa5\x62\xcd\x9d\x53\xa6\x6c\x7d\xfa\x89\x1e\x7d\xfa\xdc\xae\x5f\xe4\x97\xaf\x3e\xdd\xb9\xf7\x16\xf9\x28\xb7\x78\xe9\xc2\xbb\xba\x54\x75\x1d\x57\x19\xbd\x6e\xb8\xa3\x76\xc0\x9d\x02\x59\x6c\x5c\x7c\xdf\x4d\x21\xff\xb0\xfe\x87\xef\xec\x13\xdf\xf9\xf2\xce\xc6\x77\x46\x8c\xc0\x8f\xd8\x24\x8e\xf4\xe9\xd5\xe1\xe6\x4e\x77\xb7\x5f\x39\x7b\xe2\xec\x89\xec\x8c\x18\x04\xfb\xfe\x96\x88\x90\x07\x65\xd0\x6e\x24\x36\x21\x2d\xcd\xec\x05\xbf\x39\x33\xcb\x2e\xb8\x38\x57\xf2\xb9\x88\xeb\x8a\xe5\x12\x97\x7e\x2e\x62\xe4\x62\xfb\x5e\xd5\xe4\x5c\x8b\x6d\xbb\x35\x40\x25\xd3\x69\xe6\xa4\x20\xd3\x6c\x9a\x10\xc3\x39\xf1\xec\xe5\xde\x92\xaf\xf6\x9b\x14\xc4\x1c\x47\x66\xf0\x73\x08\x61\x5c\xb0\x30\xb6\xf1\x64\xbc\x7c\x4f\xd5\xcd\xf6\xec\x74\x0f\x69\x33\x8a\xcc\x96\x3f\xba\x1b\x18\xe1\xd4\x63\xab\xd7\x6f\xdf\xb8\xe6\x01\x14\xe3\x51\x80\x95\xf2\x68\x55\x38\xcd\x2d\xa6\x98\x5d\x2e\x87\x4d\xb4\x05\x33\x2c\x97\x4c\xff\x1b\x93\x86\x9a\x0e\x65\x52\xb8\xb4\x8c\xf5\x0a\xfb\x73\x2e\x05\x90\xf1\x9c\x1b\x31\xe9\xda\xf0\xcd\x60\xa6\xb5\xbf\xbe\x2c\x81\x4b\x57\xc7\x61\x7d\x13\x78\xd4\x01\xe6\x41\xef\x70\x1e\x9c\xb5\x4e\x47\x12\x18\x09\x0e\x53\xb2\x0f\x34\x26\x49\x42\xe7\x22\x49\x94\x25\x93\x92\xf4\x56\xab\x9b\x72\x9e\x9e\x9c\x8b\xe8\x9b\x5a\xd3\xf9\x2d\x9b\xfe\x2b\xe6\x53\x42\x0a\x0f\x2b\x91\x6d\x9c\x3a\xf2\xd7\xb1\x23\x29\xe3\xa4\x6d\xbd\x67\xd7\xde\xbd\x3b\x70\x97\xf9\xc0\x1a\x91\xbb\x04\xd2\xf3\xbe\x35\xc0\x19\x83\x23\x6f\xbc\xf1\xd2\x29\x79\xbc\xed\x0e\xc6\x01\x8d\x70\xda\x59\x56\x5d\xc0\xa1\x81\x6f\xbc\x46\xbb\x31\xc9\x67\x77\x9c\x8b\xd8\x45\xbb\x68\xd1\x59\x5c\xe7\x22\x96\x8b\x3a\x00\x4f\x77\xe5\x06\xbe\x51\x22\x13\xc4\x34\xb6\x5a\x98\x04\xdc\xad\xc6\xfa\xb8\x6e\x0a\x5c\xe1\x2b\x14\x2c\xf9\xaf\x31\xb0\x16\x33\xb0\xea\x28\x54\xc0\xa1\x77\xa8\x7c\x89\x51\x1b\x80\xeb\x0e\x80\x2b\x1d\x8d\x0d\x57\x88\x1e\x8b\xa4\xd7\x27\x11\xab\xc5\xe2\x27\xfe\x60\x46\x5a\x1a\x12\xdd\x1e\x37\x68\x5e\xab\xd5\x64\x71\xe3\x54\xe2\xa6\xa4\x74\xbb\xc1\xcc\xb0\x83\xb8\x5f\x41\x29\xe7\x9a\x3b\x26\xf9\x70\xe4\xc4\x4e\x1c\x7b\x0b\x92\x2a\xd6\x45\x93\xb6\x2e\xf1\xb9\x98\x21\x29\xbd\xb1\xa7\x4b\xf7\x45\xeb\x46\xf7\xef\x36\x7c\xf5\xe4\x6f\x52\x27\xda\x16\x55\x75\xfe\xe0\xab\x9e\xe1\x15\x19\x77\xa7\x2e\xc5\x9f\xcf\x19\xd7\xfd\x2e\x1d\xa7\x19\xde\x75\xd0\xa4\x23\xe6\x51\xed\x4b\xe7\x0c\x5f\x1d\xee\x3c\x2d\x6d\x70\x8d\xea\x83\x72\x11\x76\xa6\x00\x3e\x86\x94\x24\xa7\x24\xf1\xc4\x9c\x94\xa4\x0b\x90\x40\x46\x66\x8a\x91\xe7\x0d\xc8\x08\x07\x87\xc5\x08\xd8\xd0\xf9\x34\xdd\x9c\x46\xa7\xd1\x8d\xdc\xb6\x73\x11\xf7\x15\x24\x36\xc3\x87\xd1\x3e\x16\x64\x01\x64\x6e\x6c\x64\x36\x86\xbc\x83\x65\x25\x65\x4d\xf7\x26\x96\x79\xd2\x75\xea\xd2\xd4\xbb\x33\x56\x84\x7b\x7e\xf5\x41\xe7\xaa\x70\x77\xcd\xc4\xd4\x6f\xee\x79\x60\x44\xd7\xfe\xa3\xd7\xe3\xcf\x6b\x06\xa7\x4d\xeb\x1c\x5e\x3d\x7c\x4e\x69\xfb\xb2\x56\xe6\x23\x93\x06\xdd\x32\x4c\xc3\xe9\xc6\xdc\x36\x6e\x0e\xd3\x1d\xed\xd0\x31\x38\x33\x7e\x46\x69\x28\x1f\x8d\x0c\x97\xfa\x5d\x5a\x6d\x72\x52\x0a\x4f\x48\x96\x25\xc5\x52\x58\xe0\xbd\x2c\xe9\xec\x3c\x6f\x44\xc6\x5c\x8a\x57\x9a\x91\xd3\x11\xa3\x11\xd9\xed\x41\x60\x2c\x05\xa5\xef\x6f\x18\x34\xa2\xf8\x34\xeb\xf5\xa9\xde\x96\xab\x08\x75\xc0\xc1\xc6\xda\x70\x38\x64\xca\x2b\x42\x16\x0c\xa6\x94\x23\x41\xd7\xe0\x69\xf3\x57\x3a\xe6\x26\xad\xac\xe7\x6e\xf9\xcb\x03\x73\x56\xae\xec\x35\xd5\xcf\x69\xb8\x29\x98\x6c\x4c\x1d\x5f\x33\x74\x40\x9f\xe1\x91\xbb\x8f\x8d\xe9\x6f\x9f\xf8\xcf\xb9\x0f\xbf\x72\xfc\xad\xe3\xb7\xdd\x9c\x31\x84\x48\x2b\xa2\x2f\x3c\xfe\x38\xf7\xd4\x03\xdb\x1f\xd8\xbe\xfd\xfe\xc7\x58\x4f\x13\xf4\x2e\xfa\x98\x3f\xcf\x72\x6b\x32\x59\xa5\xae\x80\xb1\x4e\xab\xb9\xcc\x81\x6f\xc8\x51\xd3\xf9\x64\xcc\x3b\x8c\xc9\xa6\x9a\x60\xf3\xf1\xec\xd9\xb3\x71\xb7\xd9\xb3\xc9\x63\x51\x81\xbb\x46\x79\x60\x28\xd8\x5a\x47\x41\x7f\x19\xa8\xf6\x02\xdf\x96\xb9\xb5\x06\x13\x1b\xb1\xdc\xe8\xdb\x5e\x16\x2e\xa9\xf6\x70\x55\xdc\xb9\xb5\x85\x9a\x71\x2a\x49\x70\x6e\xf3\x7f\x1f\x34\x67\x0e\xee\xfc\xa0\xfc\x21\x6e\x07\x46\xef\x90\x9e\xf2\xcf\xbc\x2b\x3a\x15\x4f\x91\xeb\xe5\x9e\x74\xdd\x5a\xb0\x1f\x0b\x81\xf7\x32\x69\x5c\xdf\xa4\xd5\xea\x32\x51\x4a\x72\x32\xd2\x81\x91\xe8\x09\x9c\x8b\x78\xae\x48\x74\xe6\x22\x4f\x77\xc5\x70\x19\xa5\xe8\x14\x27\x35\xae\x39\x5b\xce\x96\x50\xc8\x0c\x10\x64\x87\xdc\x92\xa2\xe6\xdd\x21\xc6\x57\x4a\x7b\x39\xfa\x4b\x4e\xdf\xa6\x57\xaf\x21\x73\xc8\x54\x81\xcb\x1a\xd5\xa3\xdf\x1d\x4e\xae\xf3\xd6\xc9\xa3\x66\xb7\xb9\xbd\xd7\x60\x00\xf2\xdc\xf8\x9a\x39\x53\xe5\xae\x5c\xcd\x13\xc3\x83\xbd\x3a\x77\xed\xfe\xd0\x82\x35\x32\x4f\x3f\x9d\x39\x43\xee\xca\x60\x06\xde\xda\x07\x30\xa7\xa2\x36\xe1\x54\x97\xcd\x66\xd7\x81\x4f\x6e\x27\x69\x7e\x9f\xe9\x5c\xc4\x77\xc5\x6d\x77\x5e\xb6\x7f\xc7\x69\x60\x0f\xbe\x8f\xe7\x7c\x36\x81\x94\x7a\x2f\xf1\x2e\x47\x37\x00\x58\xe2\xf6\x1d\xcf\xcd\xf3\x15\x56\xdf\x34\x70\xe0\x5d\x73\x29\x98\x05\x13\xfa\xce\x9d\x88\xd7\xbe\xa7\x9f\x66\x18\xc3\x95\xdd\x3d\x30\x0e\x60\x75\xa7\x05\x6b\x62\x3a\xfd\x2d\x80\x49\x07\xbe\x0d\xf8\xa1\x56\x16\xa3\x73\xb9\x35\x00\x91\xe6\x0a\x07\xea\x92\xbb\x91\x1f\x6a\x0d\xa8\xe7\x4c\xb3\x93\xb0\x6e\xcb\xd3\xf8\xb6\x7d\x8f\x2e\x1c\x3c\xee\xee\xe1\x43\x47\x4f\x1c\x46\xc6\xc8\xd3\x5e\x79\x13\xaf\x7a\xed\xe4\xb6\xb5\xeb\x1e\xdd\xb0\x69\xbd\x52\x43\x02\x6b\x3e\x0e\x6b\xba\x51\x79\xd8\x27\x88\xa2\x1d\x81\x72\xf6\x78\xa9\x4a\x76\x38\x2c\x17\x05\x41\x17\xd7\xcb\x09\xfd\xab\x12\x7d\xb8\xa6\xb7\x44\xf1\x71\x45\x5c\x60\xe0\x88\xe5\xae\xf9\xd2\x86\x49\x9b\x77\x3e\xb1\x65\xfa\x66\xf3\x5c\x43\xcd\x4d\x2f\x90\xf1\x8f\x2d\x5f\xa5\x9f\x38\xe3\xad\xe3\x27\x4e\x2f\x99\xa8\xed\x71\x2b\x85\xa1\x1d\x19\xc3\xf0\x6e\x99\x7f\x10\x3f\x11\xfe\x34\xff\x00\xe8\xdc\x83\x62\xb8\x90\xe2\x4a\xc6\x50\xd4\x28\x8a\x0c\x37\x46\x4f\x32\x06\xde\x9b\x0d\xef\x15\x8c\x40\x4d\x93\xd9\x28\x70\x61\x4e\x07\xb4\xa4\x89\x44\x74\x10\x47\x49\x0b\x62\x86\x94\x43\x5a\xa1\xe1\xc2\x46\xda\x01\xcd\x1e\x65\x36\x0d\xf0\xce\x5b\x60\xcb\x52\x9b\xa6\x43\x38\x2d\xcd\x0e\x2c\xef\x85\x5d\x03\x9b\x86\x8f\xd9\x34\xc6\xcb\xba\xef\xa9\x55\x13\xdb\xb2\x3f\x37\x6a\xb2\x83\x8c\xad\x8b\x71\xc8\x99\xca\x49\x37\x36\x6a\x9e\x6a\xcf\x93\x39\x04\xcf\x20\x60\xd9\xa4\xdf\x3d\x60\xc5\xd2\x85\xfd\x06\x8d\x1f\x1c\x33\x6a\xee\x13\x6f\x91\x9f\x26\xab\x96\x49\x9c\x37\x23\xcf\x7e\x6b\xd5\xf1\xd3\x3b\xef\xdf\xf8\xe8\xc6\xd5\x6b\x59\x4c\xf4\x4b\x7c\x9f\xb0\x16\x7c\xbb\xca\x70\x8a\xc1\x62\xd1\x8a\xe0\x2b\xf3\x04\x1c\x3c\x51\x03\x1a\xd2\xa0\x0b\x83\xaa\xb1\x37\xc2\x99\xf4\x4e\x93\xc1\x64\x0a\x55\x60\x57\x69\x8c\x2d\x54\x11\x92\xe8\x8d\x33\x3b\xac\xf0\x7d\xed\xc3\xeb\xfb\x0f\xca\xe8\xb3\x7c\x79\x7a\x7e\x52\x21\xfe\xc9\xb6\x0f\x47\x6b\xf7\xee\xad\x95\xd3\x2a\x0a\x74\x8c\xfe\x83\x81\xfe\x7b\x41\xb7\x49\xa8\x75\x18\xb8\xd8\xa4\xc7\x4e\xbd\xd3\xed\x32\xd9\xb4\xd2\x65\xa3\xcd\xc6\x33\x37\x26\xa1\xd8\xa2\x49\x9b\xdb\x46\x17\xd6\x1d\xa4\x0e\x19\xeb\x3e\xf7\x21\x15\xa6\x39\xfc\x34\x9e\xcb\x9b\xd8\x6f\xee\x44\xfe\xbc\x9c\x3c\xb1\xff\x9c\xa9\xf8\xc5\xe8\x9e\x27\x16\xf7\xe8\xb2\x60\x0d\xbe\x0e\xeb\xe6\x73\x6e\xe2\xe7\x47\xc3\xba\xe5\xe1\x24\x2d\xec\xb9\x19\xf4\x9f\x0d\xd9\x5c\x6e\x09\x9d\x8f\x48\x26\x2d\x8d\x01\xeb\x69\x61\x74\x63\xe7\xec\xe6\x39\x01\xb1\x9b\xec\x0a\x29\x7e\x7f\x9d\x8f\xcf\xd0\xc5\xe4\x41\x5c\x97\x27\x16\xf7\xec\x0c\x1a\xc5\xc3\x3d\xd4\x14\x20\xc5\x67\xaf\xc5\x5f\x80\x3e\xbc\x80\xb2\xd0\x6d\xe1\x4c\x93\x46\xa3\x97\x70\x66\x5a\x72\x72\xa6\x9e\xe4\x64\x9b\x25\x6f\x96\x36\xe5\xb2\xd1\xce\xf4\xa1\xdd\xeb\x05\x1e\xf1\x5e\x44\x89\x0e\x40\x55\x48\x0d\x9b\x35\x6b\x5d\x98\x40\x90\x62\xac\x50\x24\x4e\x98\xb8\xc7\xcf\x2d\x54\xd5\x22\x0f\x8a\x7b\xc4\x6d\x54\x2f\xfa\xc7\x0c\xbc\x67\x24\x53\x8c\xfc\x05\x39\x99\x2a\x46\x46\xaf\xe1\xc1\xbe\x1d\xbb\x76\xef\xdc\x8b\x12\x8d\x7e\x3c\x73\x06\x7e\x51\xa9\x1f\xff\x05\xce\x91\x9d\xb0\x6f\x3a\x94\x1a\x36\x09\x7a\x9d\x81\xd3\x0b\x58\xcb\x5d\x66\xb1\x5c\xba\x51\xb1\x7a\x10\x4c\x03\x00\xe0\x7a\x38\x42\x78\xed\x43\xf2\xbf\x17\xef\x6c\x65\x76\x3e\xbf\x18\x9e\xbe\x26\x5b\x76\x97\x76\xe6\xd4\x39\xcc\x3c\xfe\x82\x78\x41\xbe\xb3\x69\x7c\xdc\xa5\xb3\xeb\x8c\x84\xa4\xa4\x90\xdc\x1c\xbf\x17\x3c\xdd\x8b\xc9\x19\x48\xe7\xb2\xf0\x3c\xb2\x34\xb1\x43\x58\x4f\x66\xda\x94\xb9\x2a\x31\xdd\x1f\x36\x47\x3d\xa4\xab\x70\x76\x56\xe2\x9d\x6f\xa3\xc5\x5a\x84\xb3\xcd\xdc\xe1\x50\xdf\xfc\xf6\xa5\x1d\x2b\xfc\x37\x8f\x89\x2c\x5c\xbc\x68\x61\x66\xe9\x88\x70\x7a\x69\x5a\x07\x77\xbb\xfc\x3e\xa1\xec\x76\xa5\x5d\x6e\x05\x1e\xfe\x22\x58\xd2\xa7\x53\xee\xc0\x85\x13\x47\xde\x35\x73\xe6\xe8\xc2\x3b\x6e\x9e\x3b\xb0\x28\x23\xa5\x4f\x49\x50\x2a\xa8\x1d\x9e\xef\x00\x59\x1f\x0e\xb2\x7e\x09\xce\x54\x27\x78\x83\x35\xe1\xa2\x54\xbb\x64\x95\x40\xdc\xd3\xad\x56\x1f\xd0\x27\x37\x2f\x2d\x95\x5a\xb1\x96\x34\x6c\x24\x69\x69\xc4\x64\xca\x04\xf3\xf0\x92\xee\x7b\x02\xb6\x63\x2c\x6a\x98\x60\x7e\x54\xfe\x49\xae\x0d\x6b\x30\x44\x8b\xd9\x6d\x2a\x42\x9a\x54\xac\x4e\xdd\xa2\x1d\xb0\x54\xff\x4d\x94\xb8\x4b\x4f\xae\x9b\x5b\xcb\xf3\x73\x1f\xdd\xb2\xfc\x81\x8d\xa3\xa6\x46\x7f\xce\xba\xa7\xfd\x9d\x23\x67\x4c\x1a\xd8\xb3\x4f\xf7\x11\x83\x88\x76\xcd\xb6\x9b\xd6\xfc\x9d\x47\x7b\xb6\x2c\x9a\x7e\xb0\x4a\x5a\x73\xdd\x97\x35\xb1\x76\xf4\xa4\x91\x8e\x11\x03\xba\x54\x8f\x9f\x45\xcb\x01\x01\x9f\x47\x61\x6f\xb5\x28\x2f\xec\xd0\x82\x36\x03\x9d\xaf\x07\xb5\xa2\xc3\xbc\xc0\x5d\xa6\x06\x13\x8b\xa6\x36\x2d\x66\xc9\x84\x9f\x7d\x98\x4e\x7e\x36\xcb\xff\x5a\x7c\xea\xf4\x62\xf9\xfb\x63\xb8\x90\xfb\x23\xba\x92\x9b\x11\x15\xe4\x0f\x62\x67\x17\xd0\x49\x0f\xd6\x5a\xd7\x70\x06\xf1\x99\x48\xb2\x3d\x59\xf4\x80\x39\x96\xe6\x21\xfe\x00\xf1\xf9\xa4\x94\x64\x43\x0a\x98\xa0\x29\x97\x24\xd0\xbf\xd2\xc5\x66\xcd\x2f\x13\xef\x92\x95\x12\xcb\xd2\xac\x6c\xb3\xe2\xce\x92\xf4\x6c\x37\x28\xc7\x78\x28\x33\x9b\x8e\xe4\xee\x71\xcb\xed\xd3\x96\xdd\x3d\xf4\xf5\x67\x43\xe5\x1f\x0f\xe9\x94\x71\x70\xc3\xa3\xcf\x6e\xdd\xfe\x09\xbe\x4a\xca\x7b\xed\xec\x9b\xb7\xe7\x9e\x59\xf7\x91\xb1\xe2\xf9\x91\xe3\x66\xdd\xbc\xf3\x68\xfd\x13\xcb\x4e\x56\xfe\xd8\xaf\x96\xd9\x95\x6d\xd1\x31\xd2\x93\xff\x15\xce\x3c\x3f\x48\x68\xb6\x07\x99\x74\x76\xbb\x90\xca\xf3\x82\x45\xa7\x13\x10\x49\x0f\x48\xe0\xb7\x4b\x57\x4c\xc6\x2b\xa9\xe0\xa1\xc0\x4e\x8a\x17\x05\x46\x19\x55\x3e\xab\x5a\x5c\x92\xaa\xd1\x4c\x6a\x35\x31\xeb\x1e\xdc\x6f\x36\x66\xd6\x1a\x53\xe6\x92\xad\x23\x26\x3d\x9f\xd9\x3d\xed\xf1\xbd\x1b\x97\x99\xf7\x8d\x1a\xfd\xc1\xe4\xfb\x16\xb5\x2b\x1f\x31\x71\x14\x99\x75\xe2\x3d\x1d\x9d\x1d\x2d\xbe\x79\x6c\xc7\x47\xae\xe1\x39\xf2\xef\x1b\x56\x8b\x78\x33\x4e\x39\xfd\xec\x8a\x87\x8f\xc9\xa3\x84\xcd\x54\x86\xd0\x71\xee\x04\xff\x2f\xa6\xd3\x52\x1c\x56\x44\x78\xbb\xd3\xe9\xd6\x73\x2e\x2b\x71\x20\x9e\xb3\x5d\x36\x6a\xc0\x85\xbe\x22\x71\x3f\xa8\x93\x82\x99\x71\x47\xfb\x1f\x03\x80\x8c\x9a\x24\x88\x99\x0b\xa7\x58\xe8\x69\x20\xb4\x04\xe4\xf7\xae\x6f\x16\xe2\x82\x69\xc5\x45\xc9\x76\x9b\x3b\xbd\xb8\xb2\x5b\xe5\xf0\xba\x05\x7f\x60\xe7\x22\x6e\x9d\x5c\xc8\x75\xbd\x3a\xb2\x5c\x33\xc4\x7c\xd3\xec\x33\xf8\x5e\xd9\x19\x3d\xd9\xd0\x80\x46\x35\xcc\x42\xff\x24\x6b\xac\x1a\x92\x8d\x1e\x8f\xae\x51\xfb\xa1\xce\xc2\xaf\x70\x8b\xac\x1a\x6e\x3a\x42\xea\x67\xc3\x1b\xc6\x71\xcf\x72\x53\xad\x1a\x61\x16\x12\x94\xcf\x1a\x7e\x69\x98\xc5\xed\x64\x9f\xcd\x55\xfe\x0e\xf6\x62\x84\x7c\x07\x77\x99\xac\x61\xf2\x35\x30\x5c\xc8\xe4\x4b\x6c\x21\x60\x96\xb4\xb4\x34\xce\xd0\x28\x61\x5a\x26\x5f\x4a\x2a\x70\x71\x93\x62\x82\x26\xd2\xa5\x8a\x57\xe6\xff\x2c\x5e\x97\x15\xf1\x9a\xb3\xe5\xd1\x65\xab\x37\x8d\x9e\x12\xfd\x39\x63\x46\xe5\x88\x51\xd3\x27\x0d\xec\xd1\xef\xd6\x11\x83\x36\x50\xe9\x7a\x89\x5c\xa6\xd2\xf5\x6c\x58\x7a\xf0\x5a\x52\xf6\xa4\xda\x51\x4c\xba\x6e\xe9\x09\xd2\xc5\x74\xa7\x3c\x9c\x7b\x9c\x9b\x82\xcc\x28\x23\x6c\x31\x18\x8d\x66\xa4\xd5\x5a\x91\x85\xc7\x46\x0d\x86\x03\xa7\x58\xd5\x9e\x36\xb5\xd3\x27\xa1\xb1\x53\xa6\x40\x45\x4d\xb0\xbc\xc2\xb4\x78\x77\xba\x89\x14\xed\x5a\x24\xff\xa7\xb5\x6b\xb1\xa9\x98\x9b\x22\x67\x8c\xee\x64\xd9\x8c\x3f\x8b\xe6\xad\x3a\x38\xf2\xa8\x72\x67\xd0\x1e\xd6\xf8\x8a\x5b\xc4\xba\xb5\xdc\x1a\xce\xb6\x59\xad\x1e\x41\x9f\x9a\x0a\xe6\x4d\x66\x86\x93\x1a\x8b\x60\x74\xeb\x35\x1a\xe6\xe4\x69\x9c\x1a\xce\xc6\xf9\x54\x7b\x87\x26\xd1\xb2\xbe\xb8\x4a\x26\x50\x13\x9f\xbf\x82\x59\x53\x2c\xca\x92\xca\x2c\xee\x60\x11\xd3\xa5\x38\xc1\x16\x69\x4f\xad\x2c\xb9\xae\x7a\x4c\xa6\x7d\xd9\x93\x0f\x8f\xd0\x4e\x12\x2a\x16\x6c\xd9\x76\x13\x67\xa3\x26\xd8\xb0\x51\x13\x87\xfd\x8a\x57\x9d\x7c\x4d\x9e\x5a\xd6\xfa\xbe\xa1\x6d\xfa\x4b\x96\x51\x3f\xe0\x34\x6a\x92\x6d\x04\x6b\x13\xe4\x4e\xbe\x83\xf4\xe4\x16\x22\x2f\x78\xdd\x3d\xc2\x59\x49\xc8\xcf\xf3\x0e\x93\x60\x65\x42\x97\x11\x34\x19\x8d\x6e\x37\x38\xd6\x70\x78\xc3\xe6\x12\x51\x04\x8b\x17\xac\x95\xe2\xe2\x78\x70\x57\x49\xbd\x4a\x50\x14\x8d\xf7\x08\x09\x92\xc7\x74\x86\xdb\xd6\xd8\xd8\x2b\x2e\x7b\x3b\x9e\xde\x74\xbf\xb9\x6f\xcd\xc8\xd1\x63\xc7\x83\xf4\xb5\xad\x00\xe9\xc3\x84\x4a\xdf\xef\x58\x23\xbe\xfe\xf2\xe3\x1f\xb8\x86\xdb\x37\xdc\xbf\x61\x0d\x48\xdf\x8a\x47\x4e\x1f\x50\xa4\x6f\x8b\x32\xdb\x4c\xee\xc9\x9d\xe0\x16\x03\xef\x2e\x8a\xf3\xee\xd2\x86\x2b\xe2\xcf\x7c\x2f\xd8\x85\x3c\x74\x77\xb8\x8d\xd3\x66\xf0\xe5\xa5\x22\xe4\x13\x35\x9a\x8c\x60\xd0\x67\x23\xf9\x05\x34\x14\x93\x87\xaa\x23\x79\x79\x7e\x9d\x3f\xbb\x3a\xe2\xb7\x1a\x52\xcd\xc9\x76\x8b\xd9\x53\x1d\x31\xbb\xe2\xf3\x7f\xd5\x44\x67\x7a\xee\x57\x25\xb6\x87\x8d\xdf\x77\xc6\x18\x3a\xa1\xbb\xbe\x32\x09\x38\xbb\xd1\x00\x50\xef\x42\x43\x52\x62\xb8\x86\x7c\x1f\x9f\x07\xfc\xd3\xfc\xd0\xf1\xb5\x9f\x9f\x3e\x5c\x38\x6a\xf8\x83\x53\x0f\xdf\x5b\xd7\x72\x24\xf0\xe6\xea\x5b\x9f\x3b\xc5\xbd\x17\xed\x33\x61\x5a\xe9\xbc\x4d\xdc\xfe\x01\xe3\x12\x06\x03\x73\x0d\xeb\xd8\x2c\xa0\xb7\x50\x21\xaa\x04\x7c\x2b\x32\x85\xd2\x52\xa3\xd7\xe3\x31\xda\x1d\x0e\x63\x9a\xbf\x08\x21\xbf\x91\xb4\x6d\x67\x71\x05\x93\x5d\xc9\x76\x3f\x7c\x79\xb3\x85\x7c\x2e\xbf\x75\x75\x24\xdf\xea\x45\x7a\x89\xab\xa8\x8e\x70\xae\x66\xf6\x30\x0b\x35\xc4\x6a\x0a\x9a\x68\xd5\x50\x8b\xd8\x1f\x95\x91\x32\x9b\x62\xfb\x83\x9d\xec\x2e\x53\x1a\xf2\x55\x84\x40\xc0\xb3\x69\xe6\x04\x35\x9e\xed\x24\x81\x61\xf9\x14\x79\xca\xdc\x27\x42\x9c\x96\xdb\x2f\x26\x25\x65\xfb\x16\x73\xe3\xfb\x55\xd4\x25\x3b\xd3\x92\xc4\xc5\x83\x86\x57\xf0\x7c\xc9\x93\x73\xde\x3e\xf1\xd2\xac\x65\x9b\x56\x2d\xdf\xbc\x7c\x36\x97\x1e\x3d\x15\xb9\x33\x6d\x81\xbe\xfc\x29\x72\x5d\xdb\xaa\x78\xcc\xbd\xc2\xd8\x67\x34\xc5\xad\xa6\x4c\x11\xa7\x75\xaa\x19\x33\x48\xbe\x22\x9f\xfd\xe6\xd5\x33\x67\x3f\x3c\xfd\xa6\x32\x77\x80\xff\x07\xd0\xa3\x00\xb5\x41\xa3\xc3\xa5\x1e\x13\x0a\x85\xb2\xfc\x81\x40\x52\x96\xc3\x59\x28\x8a\xce\x2c\xd2\xb6\x32\x47\xb2\xba\x33\x52\xdc\x29\xce\x00\x7c\x25\x21\x16\xea\x2e\x67\x13\xa0\x5a\x35\x9b\x00\x05\x9e\x30\xab\x38\x51\x48\x51\x65\x6b\x36\x15\x5c\xa9\x2c\xcb\x6c\x32\x81\xa0\xec\x4f\x48\x41\x63\x8d\x20\x0c\x89\xc1\x46\x52\xc6\x30\x55\x27\x12\xdc\x80\x14\xe2\x3e\xa2\x89\xfe\x23\x36\xa3\x60\xff\x98\x41\xf1\xf1\x04\x67\x9a\x12\xe2\x7a\xd7\xa7\xca\xad\xd3\xf2\xf0\xe4\xf8\xb4\x02\xaa\xf7\x5e\x02\x06\x19\x24\x9c\x42\xf9\x68\x42\xb8\x02\x04\x20\x2f\x18\x2c\x74\x38\x9d\xa6\x5c\x6c\x34\xa6\xf8\xbc\x26\x53\x41\xa1\xd5\xad\x27\x6e\xe2\xd0\xc0\x57\xae\x31\x17\xf5\x8e\xe4\x5a\xfc\x99\x20\x12\x28\xd9\xdb\x3b\x92\x6c\x31\xb2\x7c\xad\xc4\x94\xff\xa6\x9c\x51\xa9\x8e\xb6\x09\x25\x04\x2b\xa8\x59\x9c\x80\x76\x30\x81\x37\xa8\xbf\xa2\x84\xd9\x24\xa5\x7f\x6e\x48\xc2\x63\xe3\xd8\xd6\xc5\x29\xb0\x69\xd3\xe2\xfb\xbb\x97\x16\x06\x6f\xee\xf8\x3e\x79\x5e\x9e\xa0\xe0\x28\x8f\xc0\x5f\x29\x58\xe3\xdb\x97\xcc\x79\x78\xb1\x71\x85\xb6\xeb\x90\x3b\x96\x20\xd2\xf0\x3a\x02\x1b\x15\x64\xbe\x18\x64\xe0\x26\xb4\x3e\xdc\x33\x94\x9f\x9f\x95\x9e\xe7\x43\xb0\x75\x1d\x50\x5b\x27\x78\x1a\x3a\x41\x40\x79\xa4\x4b\x67\x9f\x33\x2d\x5f\x4a\x83\xcd\x4e\xb3\x16\xb5\x6a\x85\xdb\xb7\x6f\x4b\x47\x42\xb7\xcd\x2d\x28\x08\x96\x64\xb6\x2d\xd1\x6a\x4b\xda\x66\xf2\x1e\xe4\x09\xd3\xe2\x2f\x0b\x4d\x1c\xa4\x14\x50\x04\xc3\x4d\x71\xa7\x0d\x58\x9b\x30\x80\x2d\x14\xab\x4c\x4a\xf0\xcf\x42\xf1\x81\x76\xea\x1c\x49\x5b\x06\xa5\x04\x90\x81\xc6\x1a\x4b\xb3\x43\xa9\x9c\x3b\x16\x43\x61\xff\x49\xc1\xca\xdd\x30\x25\x57\x26\x1d\xee\xae\x9e\x7e\x99\x2e\x41\xe5\x15\x24\x9f\x59\xfb\xdc\xcd\x8b\x27\x0c\xba\x41\xfe\x6d\xd5\xe2\x11\xc3\x0e\x3d\x25\x5f\xc2\x85\xeb\x68\x26\x6e\x74\xed\x6e\xec\x19\x30\x79\xda\x12\xbc\xaf\xad\x49\x36\xe1\x9f\x3c\x7d\x6a\x96\x3a\x3f\x6f\x9a\xd7\xfb\x6b\xc6\xbd\x33\xb7\xbb\xe5\x43\xb8\x9b\xa9\x54\x9e\xc9\xd9\x2a\x8d\x67\x69\x9a\xaf\x68\xaa\x98\xfd\xd8\xac\x03\x4c\xb7\x3c\x87\x10\x7f\x0c\xe8\x9a\x8d\x42\x68\x4c\xb8\xac\x10\xa1\x60\x5a\x76\x8e\x53\xa3\xb1\x9a\xb4\xd9\xda\xb2\x52\x4f\x32\xca\xc2\xd8\x5f\x20\xea\x74\x39\x56\x53\x81\x35\x18\xb4\x16\x98\x78\x4d\x72\x72\x6b\x3a\x71\xdb\x69\xd1\xfc\x77\xea\xc5\xbd\xcb\x18\xc5\x54\x52\x15\x11\x4a\x2b\x38\x31\x5a\x10\x2b\x4e\x25\xec\x72\xbb\xdc\x74\x9c\x0e\xa5\x4c\x65\xa7\xc5\x0b\xe6\xb6\xad\x2b\x28\x5c\x3c\xe7\x8e\xc4\x74\xea\x5e\x8b\x27\xdd\x11\xed\x37\x6c\xef\xb3\x55\x2c\xd5\x1a\xf7\xd4\xe7\x14\x15\x9a\x65\x0f\xbe\x6a\x68\x97\x55\xbb\xcc\xfa\x69\x63\x56\xf6\x7f\x32\xe6\xcd\x7c\xcc\x23\x1f\xe4\x26\x3b\x3b\x54\x99\x3e\x1b\x3f\xa3\xf4\x39\xc0\x7f\x03\xeb\x75\xdd\x13\x15\xa1\x76\xa8\x36\xdc\xaa\x18\x95\x67\x68\x9c\x4e\x7f\xb2\x24\x99\x11\xe9\xd0\x3e\x87\x2f\xe0\x0a\x4a\xaa\x23\x80\xb8\xc5\x93\xa6\xb7\xa5\xd9\x92\xcd\xf0\xc5\x39\x7d\x5c\x65\xa3\x52\xb5\x27\x2a\x90\xc6\x80\x43\x9c\x53\xe2\x31\x8e\xec\x20\xe0\x17\x17\x1c\xda\xdb\x34\x41\x95\xd8\x18\x19\xa4\x04\x65\xaa\x5a\xe1\x4c\x9b\xfe\x31\x40\xe0\xfd\xaa\x18\x79\x82\x75\x6e\xaf\x22\x47\x21\x71\x3f\x78\x10\x7c\xab\x6d\x8b\xde\x38\xf9\xd2\x9c\xa5\xe3\x67\x57\x2d\xdf\x7c\xff\x5c\xaa\x4f\xff\xaa\xdd\xb9\x4f\x4b\xa5\x4a\x3b\xe3\x79\x0d\x95\x29\x9e\xbc\xbe\xbb\x9c\x6f\x3d\xda\x31\xb2\x56\xfe\x97\xfc\xc5\xd9\xbf\x0d\x3a\xbe\xf9\xc3\x53\xaf\x29\x7a\x64\x1b\x30\xc3\x72\xe0\x83\x3c\x6a\x21\xa4\xda\xf2\xf2\x0c\x1a\x84\x32\x3c\xa4\x20\xdf\x66\xce\x23\xfa\x6c\xbf\xde\x2f\x66\xc0\x97\x94\x27\x49\x49\x7d\x23\x92\xd5\x6c\x51\xd5\x46\x22\xf2\xca\x7e\xc7\xf1\x6e\xdd\x2a\x64\x6b\x8a\x9f\x4b\x41\x2f\xa6\x1b\x12\x48\x61\x5b\xe3\x71\x2a\x28\x15\x8b\x7b\xb5\x7c\xfe\xe4\xd1\x19\x99\x19\xed\x27\xcf\xf0\xa6\x29\x38\x27\x07\xf1\x12\x91\xa1\x81\x4b\xa7\xac\xac\xcf\x5c\x35\x5a\xff\xa4\xfe\x44\xdd\x04\x1d\x43\x51\x3e\x9e\x80\x43\x26\xea\x14\xf6\x1b\xbd\xde\x00\x4a\x4a\x72\x80\xc1\x9c\x95\x92\xe1\xb2\x64\x58\x02\x0e\xf8\xe2\xbd\x12\xaf\xeb\x1b\xe1\xad\x2d\x77\xae\x49\xec\x85\x8d\xfb\xb9\x21\x9c\x89\xca\x6e\xcd\x90\x63\x0b\xdb\x01\x98\xf7\x4e\x6c\x04\xf3\x40\x1c\x0f\x6e\xff\xc2\x17\x29\x94\xab\xf6\x3c\x1b\x83\x32\x86\x03\xa3\xf9\xef\x0d\x57\xc8\xaf\x7c\x77\x54\x41\x33\x2a\x72\xbc\x6e\xd1\x57\x5e\x1a\x30\x21\x1f\x6a\x53\xe9\x75\x39\x9d\xe5\xa5\xad\x4c\xad\x72\x48\x2a\x49\x05\x6d\x9d\x9e\x6a\x25\x34\xbd\x96\x1e\x5d\xec\xfe\x2b\x56\x75\xa6\x4a\x56\x4c\xca\x18\xbb\xa9\x29\x1e\x09\x13\xcc\xb3\x8a\x31\x15\x24\x09\x6c\xdd\x58\x78\x3d\x96\xe8\x96\xca\xa5\xc5\xf0\xd3\xb8\xc8\x91\x6f\xcf\x9c\xfa\x2c\xb0\xdd\xfd\xe0\xc2\x15\x0b\xfa\xdd\xb5\xb0\xff\xfd\xf9\xdd\x17\xf3\xf7\xa7\xbd\x7f\xea\xb9\xf7\x93\x77\x5a\x96\x4c\x9c\x33\x2d\xbf\xe7\xdd\x9d\xba\xaf\x2c\xf6\xb9\xc5\xc5\x77\x04\x70\xfe\xe6\xbf\x2c\x5d\x9d\x36\xb0\x77\xbf\x7e\x1d\x7b\xa4\x64\x26\xe5\x8c\x3d\x94\x5b\x76\xdb\xc3\x8f\xce\x5f\xe5\xec\xd6\xf3\xb6\xee\xb9\x15\x39\x69\x76\x29\x27\x35\xb4\xbb\xa0\xbd\xc2\x67\x87\x1a\x7e\xe2\xba\x0b\x05\x70\x76\x0f\x0f\xb7\xf2\xbb\x0a\xbc\x52\x76\xb6\xdd\xa2\xe7\x0b\xf8\xa2\x42\xd1\x14\x4c\x36\x25\xeb\xd3\xe0\x4b\xe2\x24\x4f\xef\x88\x33\x2c\x59\xec\x96\xde\xe0\x87\x70\x79\x8d\xd2\xc6\xc2\x65\x6f\xdf\xe8\xa4\x4a\x38\xaa\xe8\x99\xcd\xc2\x67\xd9\x89\x07\x93\x1a\x48\x53\xae\xae\x42\x0a\x89\x94\x3b\x20\x2e\x2f\x52\xfb\x49\x96\xb2\x71\xb9\xf3\xee\x2b\x9b\xf5\xc6\x1b\x42\x88\x53\xf6\x54\x68\xcb\x85\xaa\x32\xba\x68\x3d\xff\xc6\x2e\x81\x6e\x1f\xc1\x65\x4b\xae\x5e\x5d\x22\x2f\xe7\x98\x80\x69\xb8\x67\x7a\x55\x99\xd5\x3c\x37\x84\xc8\x11\xbe\x2d\x0a\xa0\xc1\xe1\x56\x5a\x07\xe7\xe5\xd3\xcc\x66\xa2\x49\x73\x7a\x78\x8f\xa4\xe1\xd3\x83\x1e\xc9\x25\x55\x47\xf4\x36\xe4\xb3\xf9\xcc\x69\xf0\x25\xb8\x2c\x1a\x90\xe0\x6a\x65\xde\x0b\x73\x74\x13\xb9\xb2\xe9\xfc\xd4\x98\x8b\x9e\x9e\x4d\x73\x82\xcb\x70\x9c\x15\x4b\xdc\x4a\xe5\x43\x8c\x53\xb9\xb3\xa1\x5d\xf2\x4f\xdc\xd1\xeb\x73\x71\xa8\x4d\x72\x76\xea\x62\x6e\x52\xff\xb2\xf9\x98\x8f\xae\x27\x6d\xe4\x8f\x6e\xcb\x63\x98\xe1\x67\xb3\xe5\xc3\xab\x56\xe0\x99\x26\x8a\x95\x1f\x77\x58\xb5\x42\x7e\xc4\xd1\x0a\x50\x52\xea\xda\x41\x37\xfa\x81\x3f\x53\x61\xb7\xba\x87\xb3\xb2\x88\x35\x4d\xef\x76\x27\x25\x5b\x93\x8b\x0a\x4d\xb9\xd5\x11\x17\x9b\x6f\xe1\x08\x56\x47\x40\xce\x7c\x4a\xed\x80\x55\xad\x1d\x88\x8f\x5b\xa8\xac\xcc\x6f\x3a\xd9\x8b\xe5\x44\x30\xee\x03\x6b\x99\xde\x2e\xb0\xba\x41\x66\x67\x32\x33\xd3\xea\x70\xc6\x5d\x44\xd0\x80\x5c\x9f\x83\x7f\x4f\x3d\x6c\x9f\x3b\x52\xfe\x85\x8c\xbd\xfa\xfa\xd1\x37\xdf\x9e\xfa\x54\x11\xaf\x7f\x5a\x7c\xae\xdb\x92\xbe\x2b\xe7\xcf\x58\xdb\xff\xbe\x6e\x7c\xf7\x55\x0b\x93\xba\xf7\x96\x5f\xdb\xff\x9e\xfc\x9b\x7c\x5e\xfe\x5a\xfe\x71\xec\x1d\xa3\xfb\x96\xef\x25\xed\xf0\x1b\xd7\xdb\xde\x77\x7c\xd4\x1b\x5f\xfd\xf3\x6f\xe0\xc6\x61\x34\x02\x7f\xc6\x3d\xc5\xef\x61\x77\x35\x01\x96\x83\x88\x94\x14\x44\x0d\x07\x0e\x1c\x75\xdd\x34\x1a\xd1\x40\x88\xe1\x3b\x9d\x4e\xbc\x0c\xb2\x46\x23\xef\x2c\x31\xe0\xbf\xe6\x66\xb6\x96\xf7\xcc\x9c\x89\x6b\x66\xe1\xcf\x70\x67\xf9\x25\xee\x6d\xf9\x13\x9c\x13\xa5\xbd\x2f\x7a\xd2\x59\x83\x6c\x1e\x4d\x01\xbd\x2f\xb6\xe4\xe5\x79\x0d\x76\x3b\xaf\xc9\x30\x22\xa4\xf1\x92\xa2\x42\x3e\x50\x1d\xb1\x9b\x78\x3e\xc5\x94\x02\x7e\x4a\x8a\xcf\x62\x34\x19\xab\x23\xa6\xe6\x13\x42\x1a\x4b\x30\x43\x09\x01\xd3\x0a\xaa\xa5\x98\xfb\x55\xc5\xb6\x5f\xa0\xf2\xcc\xd3\x29\xba\xcc\x83\x4c\x48\x39\xeb\x39\xff\x9f\x4b\xfc\xb9\xf9\x95\x07\xa3\x4f\x93\x4c\xf9\xdf\x85\x1d\x6a\xc7\xd7\x76\x58\xf8\xed\x9a\xb5\xdf\xcc\xc5\xdf\x6f\x79\xe2\xc9\x4d\x8f\xee\x7d\xaa\xcd\xf2\x7f\xcc\xf6\xb7\xcf\xca\x6d\x5f\xb0\x62\xd5\xb2\x2f\x32\x52\x92\xcb\x3b\xf7\x9f\xb6\x65\xd4\x9a\xcf\x66\xcd\xfc\x0c\x9f\x3f\xf8\xe4\xee\xba\x23\x4f\xee\x3a\xa4\xf0\x79\x5e\xc3\xeb\xc2\x8b\xc2\x65\xb0\x1a\xee\x0f\x77\x4b\xf6\x39\x25\x87\xd5\x9a\x99\x99\x65\x30\x9b\x0b\xb2\x74\x26\x53\x48\xe4\x39\x2e\xcb\xe1\xe3\xcb\x4a\x4d\x48\x57\x52\x5c\x0c\xf2\x5b\xec\xca\x94\xb2\xcd\x76\xe2\x4e\x96\xdc\x80\xb4\xdb\xea\xb0\x22\x3a\xf1\x5c\x1b\xd6\x59\x44\xd2\x3b\x22\xaa\x4d\x0a\x92\xde\x56\xc6\xd0\xc7\x86\x03\xc6\xc6\x37\x55\x36\x1d\xb4\xd8\x18\x04\x62\xbd\x0b\x40\xaf\x25\x48\x38\xad\xa2\xd3\xd0\x76\x52\xb1\xcb\x2b\x45\xd9\xd1\xd2\x8c\x58\xba\x51\xb6\x26\xf8\x9c\x91\x4a\xfa\xab\xaf\xa2\x86\x3a\x0e\xd7\x3e\x2e\x7f\x56\x79\xf3\x81\xdd\x87\xf3\x86\xf7\x5f\xb0\xb9\xee\xb2\xaf\x73\x46\x97\x48\xed\xad\xad\x8a\x1e\x9f\x57\xd8\x8e\xfb\x3b\x15\xf8\xe8\x51\x3c\x9d\x3b\x2f\xcf\x1f\x8a\x1b\xe4\x7e\x96\x67\xdf\xa1\x75\x53\x53\x26\x95\x1e\x78\x24\xba\x18\x5f\x97\x9f\xca\x32\x2f\xf5\xf8\xba\x28\xf4\x49\x82\x7f\x3d\xc3\x7a\x20\x94\x84\x3d\x06\x0c\xcc\xc4\x6b\xb5\x26\xa3\x86\xb5\x68\x00\xf5\xcf\xe9\x24\xda\x94\xa1\x4a\xa9\x03\x44\x71\x43\xdb\xa6\xf6\xb1\x08\xb1\xd6\x0b\xf0\x95\x34\xa1\x6e\xca\x94\xba\x09\xdc\x58\xfc\x9e\x5c\xbc\x54\x4e\xc6\xe7\x98\x5f\xac\xbe\xdf\x2e\x0a\x8f\xb2\xdc\x99\x54\xe0\xb3\xb1\x60\xc7\xa4\xb2\x3a\x60\xf0\x12\xf3\xd2\xd3\x41\x94\x72\x83\x82\xcf\x97\x8a\x93\x1d\x20\xb2\x3e\x5f\xd0\x91\x8a\xc2\xb9\xb9\x56\xb7\xa4\x33\xa9\x5d\x22\x24\x93\x94\x56\x1d\x91\x5c\xa6\x2c\x5a\x0b\x2c\xc4\x0e\xf5\xc6\xd8\x0e\x9b\xcf\x17\x2a\x4e\xb2\xbe\x5d\x52\x52\x95\x68\xcc\xc5\x0d\x1b\x47\xa8\x2c\xc1\x72\x01\x6b\x57\x0a\x72\xf1\xeb\x95\x60\xd3\x19\xba\xa9\x77\xc7\xed\x95\xa3\xaf\x19\x7b\xf5\x74\xcb\x2b\xa9\x61\x53\x77\x37\xd7\x69\xde\xbd\x9a\xe8\x97\xda\x55\x0f\xae\x59\x66\xe0\x52\x74\x73\xb9\xb1\xff\x8a\x59\x2b\x97\x7f\x5f\x2a\x6b\xc1\x9c\x91\x23\x64\xb5\xbc\xfa\x99\x93\x27\x0e\x91\xde\xfb\x9f\x7e\x7e\x27\xd5\x51\xa9\xe0\x0b\xde\xa4\xf6\x17\xe9\x1f\xce\x17\x3c\x1e\xbd\xd6\xc8\xfb\x7c\x4e\x6c\x37\xda\xd3\x52\x93\x94\xde\x22\x5a\x5e\x45\xd7\xc2\x59\x40\xfb\x5a\x5c\x22\x25\x7e\xe8\x7f\x68\x2b\xa2\x6e\x46\x40\xd9\x90\xd8\xe8\x22\x8a\x55\x07\xd0\xc0\x4e\x57\xea\x5d\x87\xf1\x0f\x87\x47\x8d\x3a\xfb\xd6\x9b\x5f\xdf\xc5\xd9\x17\xcd\x94\xed\x33\x95\xbd\x62\xfb\x35\xf7\xf9\x93\xaf\xd5\xcf\x95\xd7\xaf\x5c\x55\x53\xb3\x7a\x39\xc0\xab\x07\x78\x17\x03\xbc\x41\xd8\xa5\xf1\xe1\x36\xc6\xec\x6c\xb7\xcb\x6e\xc8\xcb\x73\x58\xb4\x3c\xef\x0b\x0a\x38\xe0\x0b\x14\x15\xe6\x7a\x83\x08\xd4\xaa\xcb\xa0\x82\x9d\x2a\xa6\x66\x54\x47\x52\x5d\x0e\x36\xb5\xcd\x4a\x25\x25\xd4\x44\x3d\xdc\x00\x03\x10\x1d\x80\xb9\x44\x6d\xed\xe1\x80\xcd\xa9\xa0\x2a\xc2\x8c\xe9\x3e\xd0\x40\x2e\xec\x0a\xdd\x2b\xb7\xe4\x44\xc1\x74\x94\x88\x94\xbe\xd6\x35\x78\xac\xfc\x1b\x3e\xd9\x6b\xa6\x8f\xeb\xe9\x9b\xd9\x0b\xbf\x2e\xff\xe7\xae\x21\xae\x61\x3d\xb0\x7c\xf5\xdc\xd7\xf2\x4f\xb7\x71\xed\xd6\xee\x89\xae\xdf\xcd\x8d\xed\xbd\x76\xf4\xaa\x55\x59\x7f\x99\x33\x7b\x77\xd6\xaa\x55\xa3\xd6\xf6\x59\x6a\xb7\xbf\x27\x47\x31\xfa\x20\x43\xde\x78\x6c\xbb\xd1\xb8\xfd\x98\x12\x3b\xbb\x8f\xda\xd9\xe0\xb3\x67\xa0\x56\xa8\x6f\xb8\x20\x33\xd9\x9e\x9f\xef\xd5\xd2\xbc\x01\x2f\xf2\x96\xb4\xe6\xec\xa9\x24\xdd\x92\x9e\x03\x86\x8e\xd5\x87\xdc\x92\xa5\x88\xee\x92\x00\x16\x8f\x90\x30\x64\x26\xe6\x65\xc4\xba\x83\xc4\x1c\x8d\x12\x6a\x5d\x6b\x12\xe6\x96\x2a\xd9\x84\x6a\xdc\x82\x66\x24\xdf\x28\x42\x31\x54\x19\xbf\x3a\xaf\xaa\x5b\x2c\x52\x51\xd7\x32\x2e\x21\xff\xb0\x56\x96\x95\x99\xac\x33\x9d\x6a\x88\x82\xff\x5e\x8e\x34\x8f\x4a\xb0\x79\x88\x80\xe3\x4d\x80\x23\xd5\xf5\x03\xc3\xc5\x66\x94\x9d\x6d\xb5\x26\x27\xdb\x03\xa2\xe8\xb6\x83\xaa\x4f\xb1\x82\x82\x97\x9c\xde\xea\x88\xd3\x67\x56\x42\x12\x79\x2c\x24\x91\xd1\x32\x24\xd1\x6c\xa8\x4e\x3c\x24\x93\xd9\x7c\x14\x62\x93\x71\xad\xff\x35\xf8\x50\xa7\xce\x9b\x9d\x37\xe0\xcf\x22\x0e\xf8\xc4\x1f\xef\xc6\x26\xd0\xce\x6c\x11\x6b\x40\x29\xf2\x40\xae\xbd\x70\x0a\x6c\x9b\xea\x70\x81\xdf\xeb\x35\x12\x2b\x36\x6b\xcd\x84\x04\xd3\xd3\x50\xef\x48\x9a\xc5\xe5\x03\x9e\x45\x8a\xc5\x66\xe6\xaa\x23\x66\xa9\xf9\x0e\x36\x1f\x17\x44\x39\x54\x39\x4c\x9b\xe0\x71\xc3\x20\x42\x3f\xf9\xdb\xf2\x9b\x8b\xab\xe6\x0d\x6b\x12\x3a\xb8\x7e\x8e\x42\x6c\xd9\x61\x7b\x78\x26\x79\x3e\x31\x66\xc0\xf6\x43\x78\x04\xec\x97\x22\xd4\x1e\xcd\x0c\x87\x85\xdc\x1c\xa4\xd1\x14\xfb\xed\xe5\xc6\xa4\x24\x7b\x2e\xe9\xd8\x21\xd3\x92\x23\x56\x47\xfc\x29\x0e\x77\x4e\x4e\x8a\x3b\x25\x04\xdb\x63\x75\x83\x5f\xe7\x96\x0a\x00\xfa\x82\x02\x9d\x0e\x76\xac\xcc\x84\xb3\x4c\xd8\xa4\x03\x2c\x42\xb5\xb5\x09\x09\xaf\xcd\x3a\x24\x28\xd9\x22\xb1\x13\x3a\x16\x27\x11\x18\x42\x01\x25\xbe\x4b\xad\x71\xbf\xad\x2c\xa8\xee\xa1\x3d\x9e\xe5\x02\x27\x53\x80\xe1\x4f\x4a\x1b\xcb\x4f\x3a\x62\x3e\xbf\x30\x67\x86\xfc\x8b\xdc\x4e\x35\x81\xb0\x89\x0b\x1d\x9a\xa9\xda\x40\x9c\x96\x7f\x5a\xc4\xfb\xe4\xef\x73\x8b\xfe\xdd\x68\x0a\xad\xd7\x6f\x5c\x35\x5a\x6e\xc3\xec\x21\xdc\x6e\xff\x98\xb1\x58\x8b\x7d\x38\x0d\xdb\xc6\xde\x91\xfa\xb0\xa6\x7c\x6f\xf4\x05\xf9\x0b\xf9\x13\x2d\xe9\xd9\x68\x14\xb1\xbd\x5d\x09\xbc\x8b\x58\x9d\x03\x48\xa7\x60\x76\x11\x93\xc1\xa0\xd1\x68\x8d\x26\x13\xb1\x6a\xad\x1e\xaf\x03\x55\x47\x1c\x34\x51\xc1\xfc\xff\x58\x7b\x0f\xf8\x28\x8b\xf4\x71\x7c\xe6\xad\xdb\x7b\xcb\x6e\x36\x9b\xcd\xee\xa6\x93\x0d\xd9\x84\x10\x5a\x16\x41\x8a\x18\x08\x35\xac\x18\x29\x62\x01\x45\x9a\x4a\x13\x01\xdb\xa9\x28\x58\x38\x2c\x88\x8a\xe8\x57\xf1\x14\x38\x5d\x34\x7a\x16\x2c\xe7\x59\xb0\xdc\x9d\xf7\xf5\xeb\xa9\xa7\xe7\xa1\x87\x82\xc2\xa9\xe7\x79\x68\xde\xfd\x3f\x33\x6f\xd9\x77\x37\x01\xef\x77\x9f\x3f\x1a\x12\x36\x4f\x9b\x99\x67\x9e\x36\x0d\x3e\xb7\xd8\x4d\x48\xf4\xb2\xd0\x39\xac\x7a\x33\x57\xbb\xf2\x08\x69\x7b\x9f\x85\x36\xf9\xd6\x4e\x62\x5e\xf2\x7b\x5b\xd4\xc1\x66\xfe\xbc\xb6\x4a\xba\xe5\xaa\x6c\x16\x7f\xf0\x47\x69\x3c\x3e\x63\x29\xd5\x50\xe9\x9f\x5b\x56\xe0\xaf\x17\x49\xeb\xf8\x03\x3f\xcd\x65\xac\x52\x52\x6a\x52\xb4\x52\x96\xd5\x2e\x75\xe1\x5f\xd2\xb3\x78\x03\xd2\x01\x70\xac\x66\xb3\x60\x67\x1d\x4e\x2b\x8c\x99\x35\x24\x22\x72\xcb\x90\xe0\xcd\xaf\x01\x6a\x07\x57\xfc\x8a\x72\xa9\x93\xc6\x5e\xd7\xb2\x6e\x7e\xb6\x4b\xfa\xfb\x80\x74\xce\xb2\x65\x05\x7f\x40\xd6\x7e\x33\xe1\x71\xad\xd4\x25\x5c\x0d\xb9\x64\x0b\x3a\x3b\x3d\x68\x40\x79\x79\x5d\x45\xa0\xa5\x05\x39\x0d\x06\x8b\xd1\x88\x2a\x2b\xb8\x56\xf8\xb0\x33\x33\xc0\x1b\x87\x38\x38\x1e\x92\xab\x21\xce\x80\xd7\xe8\x85\x40\xde\xeb\xb0\xd8\x91\x91\x1e\x11\xcd\x6f\xb6\xe9\xab\xf8\xba\x6a\x5a\x34\xbf\x93\xa5\x9f\xc2\x91\xb7\x68\x72\x28\xb0\x2c\x3a\xd1\x59\xed\x79\xca\x44\xbf\x80\x54\x8a\x4e\x78\xe8\xfb\x75\x6d\xaa\xab\xa7\xbf\xe5\x76\x73\xe3\xe8\x9b\xa1\x13\xd3\x35\x71\x8e\x2b\x2b\x63\xca\x7d\x56\xab\xd3\x56\x6e\xab\xae\xaa\x00\x25\xa8\x08\xf9\x82\xb6\x20\x74\x71\xd0\xe1\xb4\xdb\xbc\x5c\x59\xfe\x7a\x2b\x75\xc5\xb5\xbd\xf8\x91\x64\x3a\xc3\x65\xd1\xb5\x38\x4c\xdf\xce\x7c\x03\xd9\x8a\xb5\xe7\xf6\x3d\x34\x7f\x86\xa6\x16\xfd\x9f\xb7\x57\x5b\xa2\xfa\x19\x88\x83\x12\xa8\x09\x6c\x70\x43\xe5\x80\x88\xd7\xe7\xf3\xb3\x56\xd1\x8a\x82\x7e\xe4\x6f\x4e\x31\xae\x08\x1b\x73\xc4\x60\xd8\x62\x8e\xa0\xdd\x1f\x72\x34\x92\x77\xf9\x4e\xee\x69\x52\xda\xdd\x3b\xaa\xaf\xf1\x6a\x4f\x9c\x51\x67\xa3\x04\x3b\x27\x29\xe0\x5c\x26\x1d\x26\x43\x32\x3c\x3d\xa8\x95\x06\x3c\x27\x28\xdb\x48\x2f\x6d\xfc\x80\x36\x65\xd4\xe4\x25\x56\x1a\xf2\xf0\xc2\x09\x8a\x36\xf2\xfb\xe0\xd7\xd2\x77\x45\xc7\xa7\x2b\x21\x33\xe3\x4a\x18\xc6\x11\xe6\x39\x07\x17\x2d\x0f\xc1\x50\x85\x42\x26\x1b\x67\x73\x4f\xcd\xd8\x1c\xa2\x9d\xf3\xeb\x06\xaa\x78\x9c\x74\x37\xc4\xca\xc3\x54\x54\xa9\xc9\x0f\xd0\xe2\xb5\x67\x15\x94\x67\xe4\x77\xc1\xc9\xd0\xb0\x23\x74\x65\x19\xe9\x3c\x6d\xc6\x62\xd4\x26\x75\x41\x4e\x3c\x01\x35\x93\x3a\x47\x22\x1e\xf7\x81\x5d\xb5\xdb\x39\x54\x57\x86\xca\x06\xb5\xf8\xea\x2c\xd1\x28\x38\xfe\x44\xd4\x61\x21\xb7\x00\x5a\x0a\xde\x96\xcb\xd7\x3a\xda\xf2\x83\x21\x7b\x8d\xa6\x82\xb7\xe6\x14\xa7\xaf\x2f\x78\x30\xc5\x95\x0e\xec\x2f\x63\xbd\xec\x13\xca\xec\xb8\xf0\x3e\xad\xd2\x31\x73\xde\x86\x6d\x57\x9e\xa6\x2b\x72\x34\x9e\x75\xdb\xe6\xcb\xc7\x57\x6f\x90\x27\xc8\xd6\x94\x52\xe3\x48\x77\x06\x2b\xaa\x3b\x2e\xea\xd4\x0a\x1c\x0d\xc3\x6a\x13\xf1\xe1\xa7\xcd\x1d\x41\x6a\x1b\x0f\xc2\x78\x1c\x07\xbb\x94\x80\xb9\x53\x17\xf6\x04\x5c\xe5\xe5\x82\x60\xf1\xb0\x55\xa8\x32\x44\x6e\xb4\x83\x40\x3b\xe4\xb2\x58\x5c\x21\x36\x66\x8c\x81\xb1\x8a\x85\x8c\xb6\xce\x8c\x11\xe5\x3d\xbf\x5c\x40\xad\x23\xa7\x96\x5d\xba\xc7\x76\x59\xea\x0d\x5a\x88\xd7\x57\xc7\x23\xaa\xb3\x08\x51\xf9\xa1\xa4\x4c\x4b\x74\xd0\xd0\x20\x1e\xd6\x55\x3f\xf0\x94\x8e\x09\xf8\x39\xe2\x19\x88\xff\xf8\xeb\x96\x3b\x9b\x53\x39\x64\xab\x9b\xbc\x88\xdb\x8c\xe7\xb9\x76\x86\x16\xac\xff\xe9\x75\xea\x06\xb6\x83\xb7\x78\x23\xbb\xc7\x2c\xdb\x55\x51\x9a\x41\xce\xc6\x23\x1f\x3a\x25\x1d\x33\x33\x8c\xcf\x8a\x5c\x36\x97\xe0\xe3\x02\x7e\x97\xd5\x6b\xb3\x73\x30\xeb\x39\x71\x6a\x86\xb3\x5a\x41\xbb\xac\xca\xf3\xb4\x2f\xd7\x29\x4b\x68\x85\xc7\x29\x13\x7a\x9b\x15\xc5\x64\xbd\x95\x1c\x59\x61\xee\xf8\x5a\x95\xeb\x21\x69\xc5\xfe\xaf\xad\x83\x63\x55\xdf\x3f\xbf\x11\x9c\x1c\x95\x66\x25\x37\xa4\x37\x5d\xfd\xdb\x4b\x2e\x65\x5e\x94\x65\xf2\x83\x4c\xc7\x41\x26\x3f\x9a\x90\xae\x25\x97\xc6\x71\x7e\x2f\x78\x20\x83\x01\x09\x1c\x17\x28\xf1\x9b\x89\xb7\xb6\x81\xde\xd8\x42\xa2\x1d\xb1\xe0\x0d\x30\x2f\xdf\x3e\xa3\xa6\x8e\xed\x85\x89\x73\x4a\x3e\x0c\xa7\xbd\xd0\x5e\x60\x5a\xb1\x54\xfc\x44\x7b\x62\xa9\x22\xee\x10\xf2\xb2\xb8\xee\x7d\xf6\x6e\x4d\x64\xb9\xee\x03\x72\x3e\x41\xcf\xcd\xd3\x33\xb0\x6e\xcc\xf3\xe0\x2c\xac\x6e\xd6\xe3\xa5\xcf\xcd\xba\x91\xe0\x86\x58\xc3\xed\xe5\xc1\xaa\x81\xdf\xb4\xeb\xaf\x8a\x20\x9d\x58\x70\xd9\x23\xa4\xb3\x72\x39\xa7\x60\x98\x07\x32\xbf\x24\xe5\x9b\xde\x85\xcc\x6f\x14\xa1\x7a\x83\xd7\xb1\x95\x1b\xaf\xfb\xe9\xcf\x3a\x61\x18\xd4\x25\xcd\xe0\x07\x81\x5d\xa8\x41\x83\x20\xee\x19\x59\x29\x36\x34\x78\xbd\xb1\x58\x59\xd0\x66\xb7\x37\xb3\x41\x76\x70\x6b\xdc\x3f\x39\x13\xf7\x46\x4b\x3b\x33\xd1\x90\xd0\x38\x39\x53\x49\x0e\xfb\xb4\xdb\xb0\xdd\xb6\xd8\xc6\x98\xe5\xd3\x3e\x9d\x19\xa7\x03\xd5\x16\x3f\x08\x4d\x4e\xf4\x3b\xe9\x1b\xe4\x3a\x87\x56\x68\xeb\xa9\xfc\x7c\xd1\x59\x1f\x97\x7c\xd6\x87\xe4\xde\x1e\x39\x01\x87\x40\xa8\xe0\xc4\x0f\x43\x4e\xfc\xdc\xbd\xf3\xfe\x8f\xbe\xff\x76\xc9\xca\x55\x17\x99\x9f\x69\xc0\x57\x1d\x78\xab\x3b\x18\xbd\xb4\x7a\x40\x43\x8d\xf4\xd5\xbd\x46\xe1\xd4\x27\xcf\x38\xfb\xce\xcc\x6f\xd7\x5d\x39\x66\xb6\xe7\x91\xad\x0f\x65\x05\x6e\xe8\x55\xcb\xa6\x9c\xe1\xc4\xf1\xdf\xfc\x5a\x6a\xd8\x21\x7e\x7d\x9b\x69\xbb\x01\x57\xaf\x32\xbf\x79\xd9\x79\xbf\x38\x63\x3b\x68\x2a\xd3\x38\x7f\xf2\xcc\x39\x34\x16\x9c\xc1\xfd\x00\x7d\x52\x01\xd1\xe0\xec\x74\x53\x89\x25\x16\x8b\x46\x8d\x46\x0e\xd5\x40\x82\xd8\x98\x0c\x3b\x4a\xac\x3e\xa7\xaf\x92\xbc\xbe\x2c\x82\x0b\x17\x99\xa9\x19\xd1\xe9\xac\x27\x4f\x5d\x9a\xa3\x9d\x19\xb3\x57\xf3\x0d\x8a\xc2\xf7\x39\x24\xa3\x6b\x7b\xbe\x85\xb1\x2a\x2d\xda\x8b\xea\x82\xbd\x54\x41\x26\x32\x40\x69\xe1\x64\x86\x1b\x74\xf7\xba\xb7\xf6\x43\xbc\x7e\xef\x20\x08\xef\x1e\x15\x47\xff\x70\xfd\x6d\xd7\xad\x5c\x75\xcd\x1d\xd7\xaf\x94\x9b\x76\xc5\x8a\xa1\x17\xcc\xc2\x3e\xec\x63\x06\x75\x9d\x53\x76\x2b\x3f\xf4\x48\xef\x42\x7c\xcf\x1f\x0f\x1c\xf8\xf8\x6f\x2f\xff\x59\xcd\x41\xde\xe3\xff\x4c\xdb\x39\x25\x5d\x57\x63\xab\xa8\x28\xf1\x84\xc3\x25\x31\xb1\x44\x6c\x4c\x96\x43\x80\x5e\x1e\xa2\x2f\x78\x22\x0b\x32\x72\xc6\x7a\x72\xd3\x14\x07\xcd\xe6\x8a\xf2\x8f\xc2\xed\xae\xf9\xf4\x23\x56\xb8\x10\xaa\x5a\x24\x65\x68\x49\x9b\x0b\x12\x90\x36\x4e\x9f\x81\xe0\xd0\xc8\x31\x43\x86\xae\x5a\x9d\xae\x6d\x1f\x2e\x1d\xea\x3f\x07\x79\x10\x57\xdb\x1f\xf2\x6e\x39\xfe\xd7\x2d\xf6\x3b\xed\xb8\x9a\xb9\x47\x4d\x41\x88\x5e\x77\x71\x1f\xc3\x18\x86\x21\x8b\x9c\x95\x6e\x10\x9c\x4e\x8b\xc1\x50\x56\x8a\xe2\x71\x7f\xa9\xbf\x32\x41\xd6\xfc\xe3\x60\x98\xe2\x71\x4f\x30\x18\x25\x01\x8a\x87\x85\x54\xcb\x67\x07\xdf\x6e\x0f\xf5\x79\xe8\xb9\xdf\x23\x18\x29\xfd\x32\x7f\xbe\x4d\x2d\x82\x12\xb0\xe7\x17\xf8\xb1\x47\x5e\xe0\x57\x1a\x73\xfe\x8e\x63\x3f\xfe\xf8\x45\xf1\xd2\xbe\x74\x87\xdc\x8a\x5f\x8f\xc6\x65\x38\x88\x2d\xb8\x2c\xbf\xb0\x8f\xd1\x78\x68\xcf\x19\x74\x4d\x73\x79\x7a\x68\xc5\x80\x01\x71\x91\xdc\x8c\x0a\xae\xb1\x3a\x4e\xdf\xb6\x8d\xb3\x03\x1b\xeb\x60\x6c\xea\x42\xfd\xbc\x70\xdb\x80\xfa\xbc\x71\x0b\xd1\x77\xe1\x2b\xb7\x7d\x67\xa7\x2b\xbf\xd3\xf3\x3f\x79\xec\x56\xdf\x03\x27\x7b\xf6\x56\xe9\x84\xb3\x4f\xf6\xf8\xad\xb4\x4d\xee\x8b\x5d\xc3\xe4\x37\x65\xba\xd8\x79\xb4\xed\x0b\xd3\xad\xee\xca\x32\x7f\x2c\xe6\xa8\x0d\x97\x95\x21\xa3\x91\xaf\x85\x76\x57\x7a\xdc\x1e\x68\xa9\xc7\x53\x9e\x1c\x60\x36\x0f\x18\x60\x85\x60\xdb\x17\x0e\x97\x97\x07\xc9\x66\x0e\x11\x4c\xa8\x18\xd2\xdb\x25\xad\x0b\x9c\x7d\x4e\x1f\xe6\xb7\xd7\xfb\xd5\xe6\x94\x60\xf5\xca\xa0\x13\x3c\x61\x2f\x7b\xd4\xcf\x94\x76\xdd\xd3\xf2\xda\x39\x8b\x1f\x7c\x50\x77\x83\xe7\xfd\x7f\xd8\xb4\x70\xcd\x6d\xef\xee\xbf\xe6\xec\x35\x72\xab\xf0\x05\xf5\xf7\x9f\x33\x7d\xee\xb9\xf9\xbb\x3c\xef\xbd\xe2\xec\xab\x8d\x8c\xf5\x96\x45\x5b\x7f\x35\x4c\xae\x81\xcc\x84\x7c\x74\x17\xb4\x99\xd4\xe8\xe6\xa4\x07\xa2\x44\x22\x10\xb0\xf8\xfd\x2e\x5b\x44\x0c\xdb\xc2\x55\x95\x81\x48\x19\x84\x08\x96\xb2\xb2\x90\x31\x54\x01\xb1\x82\xcf\x0b\x19\x96\x37\x74\xa2\x8b\x83\xe5\x9b\x2d\xfa\xdc\x8a\xa4\xc6\xdb\xf9\x46\xb9\xdc\x29\x67\xbe\xe5\x36\xac\x3b\xbe\xc3\x9e\xa9\xdd\xca\x77\xe8\x07\xd3\xa3\x4a\x7b\x7d\xdf\xbf\x2b\xc5\x9e\x2e\xba\x88\x4f\xfa\xb7\x74\xbc\x77\xb4\x32\x2b\x87\x7e\x7a\x84\x69\xd7\xb6\xa8\xd0\xbb\x4a\xbb\x98\xcb\x68\x4e\x46\xee\x57\x8f\x5a\x8d\x46\x86\x71\x8b\xa2\x83\xe3\xbc\x1e\xa7\x63\x2a\xd8\x1b\xde\x4e\x63\x07\x2f\x29\x80\x22\x7d\xa8\x9d\x7f\x5c\x49\x15\x9d\x18\x4e\xaa\xa6\xb2\xd4\xb8\x25\xe5\x65\x90\x74\x68\x76\x76\x16\x11\x50\x3a\x3d\x0b\x09\x60\xf5\x06\x6e\xc8\x4f\x73\xa5\x2f\x89\x40\xc2\x6b\x8f\x3c\x42\xee\x11\x07\x9d\xda\x4b\xf7\x05\x8d\x49\x27\x04\x77\x89\xb5\xa2\xa2\xcc\xcd\x26\xe2\xb2\xd5\x0b\xf8\x10\xf2\xf9\xa0\x23\x7d\x3e\x8b\xc5\xe1\x30\x92\x69\x84\x8a\xb5\x47\x1f\x2c\x40\x30\x9c\x5f\x88\x50\xce\xfb\xc9\x6b\x15\x55\xde\x7c\x77\x7e\x6b\xdf\x30\xe7\xfa\x5f\x6c\xd8\xb4\x60\x99\xed\xa9\xf0\xfb\x0f\x7e\x72\xec\xe8\xdf\x36\x9e\xab\xf4\x23\x9e\x78\xe1\xf9\xbf\x7f\xef\xd3\x67\x17\x9e\x61\xbb\xed\x11\xb2\x2a\x21\x7d\x25\xfd\x75\xec\x6e\x45\x63\x5e\x22\x31\xe3\xcd\xd0\x6f\x63\xa1\xdf\xa2\xd0\x6b\xe5\xa5\x08\x79\x0d\xde\x58\x05\x38\xe0\x0a\x27\x48\xea\x74\x96\x98\x4b\x20\xc1\x2a\x41\x66\x88\x1d\xcc\xa1\xfe\x5e\x0e\xd0\xee\x1e\x4a\xd0\x63\xe7\xea\x59\xda\xe1\x58\x89\x19\xf3\x55\x14\x2f\x1e\x76\xd9\x3a\x26\x39\x94\xc8\xb6\x71\xdd\xb0\x36\x98\xdf\xb7\xdd\x7a\x01\x0d\x16\xdf\x7a\x74\x97\xf9\x94\x21\x20\xd6\xf5\xb7\x3e\x1c\xa8\x9a\x78\x1e\x7b\xed\xa3\xfb\x5c\x0f\x42\x9c\xa8\xbc\xb1\xd0\xc5\x93\x3b\x81\xe2\x10\x83\x55\x95\x1a\x0c\x66\xb3\xcf\x69\xc5\x31\x6b\xac\x32\x51\x8a\xca\xcb\x79\x72\xc7\x75\xc0\xd2\x99\x09\x78\x3d\x76\x52\xdb\x32\xd9\xc9\xa5\x72\x45\x9b\x4a\xf2\x7e\x52\x5b\x3f\xd1\x76\x4e\x39\x53\x3a\x43\x13\x6b\x60\xb4\xed\xd5\x78\x88\x9c\x0c\x66\x56\x8f\x8c\xb7\x0f\x96\x0e\x75\xe4\x73\x42\x08\x14\xa7\xd0\x5c\x90\x59\xae\xaa\x01\xe8\x84\x9a\x12\x32\xbf\x27\xf7\xd2\x81\x7d\x35\x83\xdc\x09\xb0\xaf\x23\xc8\xbb\x19\x56\x18\x77\xc1\x6d\x0d\xc6\xdd\xf1\xaa\xca\x12\x3f\x42\x7e\x16\xb2\x22\xb3\xd3\x69\x9a\x9c\x61\xc9\xda\x8f\xdd\x89\xcd\x2c\xeb\x64\x9d\x15\xb6\x8a\x30\xc9\x75\x1d\x56\x1b\x58\x1e\x5b\xe1\x6a\x8c\x72\x67\x0f\xbd\x83\x5c\x33\x3b\x05\x17\x93\x91\x9a\x87\x96\x89\x68\xb7\x92\x71\xf4\x46\xa6\x0a\x65\xc5\x51\x56\x9f\xef\xdd\xb7\x6d\xbc\xfa\x7f\x76\xf6\x4c\xc1\x97\xf6\x4e\x67\x97\x4b\xeb\xf1\xfd\xab\xde\xbb\xfe\xed\x4b\x47\x8f\x90\x55\xe8\xc0\x95\x97\x6c\x3a\x6f\xd3\x86\xf5\x78\xfa\x8d\x5b\xa5\x6c\x58\xda\x74\xde\x63\xe7\x5c\xd8\x34\x7e\x82\xac\x42\x23\xe9\xdc\xeb\xc2\x1f\x30\xaf\x73\xdf\x22\x2f\x68\xd1\xc8\x74\xd4\x27\x94\x7a\x6d\x36\x97\xd5\x2e\xd8\x63\x15\xc8\xcc\x1a\x22\x86\x83\x99\xc8\xc7\xae\xc3\xf6\x43\x6c\xc9\xc1\x0c\x7b\xa4\xdf\x93\x11\x9a\xf7\x53\x6e\x14\x97\xb7\x7e\xd1\xbd\x9b\x24\x19\xd4\xef\x46\xfc\xdf\x8a\xc5\xd3\x6e\xb8\x52\xfa\xc7\xb4\xc5\x15\x0c\xb3\x86\xbb\x44\xc4\x97\x76\x92\xf3\x93\xe7\x9e\x31\x9d\x5b\x48\xce\x4f\x4a\x4b\xd2\xa7\x4e\x8f\x32\xdd\x57\x05\x07\x9e\x26\xfd\xb4\x7d\xd3\x6d\x77\xdd\xb6\x69\xa3\x1c\xcf\xa7\xf1\x87\xcc\x1d\xdc\x77\x10\xcf\x37\xa4\xfd\xc8\xe2\x12\x2c\x42\xa0\xc4\xee\x3d\x98\x71\xdb\x8f\xf0\x60\x34\x0e\x66\x8c\x5f\xe8\x2e\xf7\xcf\x1f\x11\x71\x3b\x0a\x4f\x46\x92\xbc\x8e\x88\xb4\xff\xe9\x53\x66\x98\x2f\xb3\xdd\xb6\xe2\xf6\x07\x76\x6c\x5b\x76\xab\xe7\x72\xdf\x75\xf3\x66\xb0\x17\x4a\x7f\x1a\x7f\xba\x61\xd1\xd5\xaf\xbd\xfc\xdc\x9b\x2b\x2f\x34\x5d\x7f\x2d\xe9\xa7\x14\x7e\x98\xd9\x0c\xbc\xc3\xa8\x0a\x4d\x4d\x37\x54\xd8\x82\x95\x82\xc7\xc0\xf0\xbc\x41\x08\x72\x35\xd5\x81\xf8\xc1\x8c\xaf\x52\x60\x38\xfa\x3c\xbe\xf3\x60\xc6\x6e\x3e\x82\xca\x0e\x66\xb8\x39\x20\x37\x08\xd5\xfd\x4a\x3e\x17\x0d\x24\xfd\x6d\x85\xd5\x59\x7a\xbe\xbd\x4a\x20\xaf\xe2\xea\xc5\xf3\x7a\xfc\xf0\x0f\xb2\x22\x57\x45\x6f\x13\x8c\x55\x88\x3e\x7c\xd9\x85\x1d\xb1\x92\x69\xa7\x8d\xda\x71\x27\x11\xd8\xbd\x71\x6e\x97\x7f\xc3\x2f\x9e\x68\x5f\x35\x6b\x70\x47\xcd\xb4\x25\x67\x27\xf1\x47\x83\x5b\x9b\x47\x5e\x72\xee\xce\x67\xdf\x22\xc2\x5f\xb9\x63\xf6\xa9\x1b\xef\x1b\x7e\x56\xdb\x59\x65\x8d\xe1\x09\x57\xa6\xe4\x7b\x85\x3e\x62\xde\x10\x7c\x60\x48\xab\xd0\x19\xe9\xa4\xa1\xb4\xb4\xc4\xeb\x32\x59\x39\x8b\xdb\x5d\x62\xa9\x60\x4b\xd8\x9a\x6a\x93\xd7\xea\xe2\xcc\x6e\xb7\xc3\x2c\x08\x91\x83\x19\x03\xc4\x47\x8e\x2f\x51\xa2\x60\xa7\x7f\x9b\xbc\xb3\x33\x90\xcc\x5f\xf3\xa6\x14\xed\x94\x49\xaa\x74\xb6\xbf\xb2\x4a\x6c\x69\xad\x04\x4d\xf0\xb7\x7a\x45\x9f\x2b\x8c\x8b\x4e\xe5\xad\xda\xfe\xf0\x43\x3b\xcf\x4a\x9f\x36\xe3\xc0\x96\xf6\x73\x37\x37\xb7\xbf\x73\xd3\x92\x35\xbb\xaa\xbb\x17\x5d\x34\x7b\xde\xbc\xc5\xf3\xf1\x47\xfb\x1e\xf9\xd5\xbe\xda\xdb\x3b\xbb\x3b\x4f\x69\x19\x1a\x68\xec\x9e\x34\x72\x81\xf4\xf9\x23\xdc\x93\xcf\xe3\xb9\x57\xaf\xdd\xb0\xe1\x9a\xb5\x6b\xe9\x9d\x0b\x1f\x30\x93\xb9\x6f\x60\xbe\xae\x4c\x8f\x76\xc4\x42\xde\x68\xd4\x82\x82\xa1\x90\x28\x20\xa1\xaa\x32\xe6\x74\x38\x1d\x07\x33\xce\xb4\xcd\x39\xce\x49\x26\xab\xd3\xc9\x96\xd9\x83\xd8\xc7\x06\xc9\x47\xc1\x60\x59\x59\xe0\x60\xa6\xec\x08\x6b\x3c\x98\x49\x8b\x58\x14\xe9\x51\xe1\x64\xb7\xee\x98\xb7\x7a\x3b\x41\x5d\x9f\x3b\xac\x52\xf9\x8b\x5f\x63\x85\x17\x0a\xf6\xb9\x90\x0f\x8c\x2c\x33\xf9\xe6\x2b\x2e\xbb\xc9\xbc\xca\x72\xcb\x84\x8e\x8e\x89\x23\x87\xb7\x77\x8c\x3a\xf5\x12\xef\x6a\xeb\xf5\x8b\x57\x5e\xbb\x75\xca\x4c\x26\x3b\xff\x92\x15\xab\x4d\x77\x9f\xda\x3e\x7c\xf4\xfc\x91\xad\x83\x4e\xbd\xc9\xbc\x70\xd5\xb2\xb9\x6b\x1b\x6d\xf3\xd4\xbb\x55\xf0\x3d\xbc\x84\x3c\x90\x2b\xc6\x9c\x18\x8b\x1c\xe3\xb6\x32\x56\xaf\x4f\x60\xc9\xb5\x0b\x2e\x17\x22\x47\x54\xb0\xc9\x64\x3b\x98\x31\x7d\x89\x0b\xae\xf1\xd0\x9f\x9b\xd1\x76\x16\x39\xf5\x05\xf3\x2a\xa5\x5e\xee\x58\x73\xde\x79\x33\xcf\x6c\x0b\x0f\x4a\xd6\x6e\xe6\xae\xeb\x9d\xcb\xdc\x73\xe6\xf4\xf3\xcf\x34\xcc\x15\x06\x8e\x1c\x2d\xdf\x13\x5a\x8f\x7e\x8f\xb7\x73\x9f\x81\x1c\xa3\xd3\x15\x6e\x0b\x72\x3a\x79\x56\xb4\x88\x5e\x1f\x72\x91\x8b\x4f\x58\x56\x20\xfb\x81\x19\x59\x0e\xe6\x30\x6a\x4f\xf6\x2b\x46\xfe\xba\x28\x79\xd1\x92\x86\x4e\x2d\x7e\x52\x1a\x8b\xb5\xfc\x46\x27\x05\x93\xc3\x9f\x4b\xc1\x33\xa5\x6f\x14\x31\x7a\xcf\x94\xef\xc5\x53\xce\x9b\xba\x04\x7e\x11\x95\x6b\x0e\xfe\x92\x79\x84\x9e\x07\x6f\x4b\x47\x8c\x82\xcf\xee\x76\xbb\x04\x97\x3f\x60\x81\xee\x41\x93\x2c\xb3\x2d\x8b\x2d\xac\xc5\x22\xba\x0f\x39\xc4\x2f\xe5\xf7\x29\x92\xdd\x6d\x75\xfa\x44\x4c\x3b\x07\xee\xd4\x5d\xc9\x41\xae\xa4\x61\x5a\x6a\x16\x4f\x5b\xb1\x6c\xcd\xd8\xc9\x33\xcf\x5d\xb3\x46\x60\xaf\xed\x18\xbd\xf6\x26\x72\x0e\xe7\xe2\x49\x6b\xcf\xc7\x2f\xfe\xf8\x25\x76\x2c\x29\xa3\xf7\xba\xc2\x18\x35\xd0\x33\x9d\x76\x72\x3b\x9f\xdd\x28\x9a\xcd\x16\xf2\xec\xa4\xc3\x69\xb1\x7e\x69\x02\x37\x74\x30\x23\x52\x9f\xc1\xb2\xfc\x61\x72\x15\x46\x3b\x28\x96\x7a\x50\x41\xbf\x6d\x92\xf6\x0c\x0c\x8f\xd2\x3b\xe4\xe9\xc8\xf9\x53\xa7\xae\x9a\x3c\x79\xd5\x2a\xe0\xb1\x70\x26\x6e\x93\x7e\x37\x53\xda\xca\x6e\x5f\xb5\x0a\xda\x3e\x1f\x7f\x89\x3e\xa2\xe7\x52\x7d\x69\x23\xb9\xaf\x88\xc7\x32\x75\xed\x2e\x27\xa0\x33\x7f\x15\x39\xeb\xd3\xcb\xf7\x03\xcf\x73\x27\x87\xa7\xed\x02\x78\x33\x1a\x94\x2e\x25\x8d\x22\x6d\xb2\x58\x4f\xda\xa0\xc2\xb5\x69\x5d\x5b\xe4\x76\xe8\x5b\x41\xef\x6d\xcb\xa1\xe7\x99\x04\xf4\x9d\x03\xac\x53\x04\x4d\x4b\xd7\x97\x8a\x5e\x6f\xc4\x62\xb2\xd9\xca\xa3\x25\x2c\x5b\x1e\x2e\xfd\x2c\x13\xfe\xd2\xea\x13\x7c\xa0\x57\x76\x01\x5b\x59\x30\x4d\x86\xc3\x08\x4c\x2e\xfa\x5a\x33\x4d\xea\x23\x05\xba\xc7\x16\xd5\x2e\x05\xe7\x4a\xed\xd2\x50\xac\x2d\xcb\x56\x51\x75\xa3\xe6\x88\x3c\xd0\x79\x68\xd1\x65\x67\x5f\xb0\x61\x75\x77\xf7\xaa\xd5\x43\x47\xac\x6d\xae\x6f\xfd\x9f\xd5\xcf\xcf\xcd\x64\xce\x60\x9e\xea\x1d\x3b\x2f\xb8\xf0\x17\xf3\x3b\x4e\x73\xd4\xd4\x54\x35\x70\xf3\xa1\xd7\x89\xce\x75\xa1\xe7\xf1\x7c\x90\xd9\x42\xee\x8e\x41\x26\x93\x95\xb7\x99\xbf\x34\xf0\x9f\x65\x0c\x2c\x7c\x11\xa9\x94\x17\x79\xe4\x9d\xe0\x6e\xed\xd6\x12\xd0\xac\x3f\x54\x25\xe2\x15\xf5\x15\xcf\xaf\xc1\x77\xb4\x25\x4d\xcb\x4c\xef\x70\x4b\x29\x4d\x16\x68\x5a\x81\xa6\x1d\x35\xa7\x4b\xcc\x1c\x67\x34\xda\x05\xc1\x09\x4a\x6b\x65\x3e\xcb\x58\x85\xb4\x00\x96\x4a\xa0\xd7\x50\x91\xf3\x90\x05\xc7\x8d\x29\x8f\xfc\x72\x85\x97\x1c\x79\x65\xcb\x2b\x66\x8c\x5e\x3d\xec\xf9\xea\x18\x1e\x64\x38\x7f\x1a\xe7\xfb\xa9\xeb\xd5\x77\x44\xe0\x33\x13\x46\x97\x87\x31\xa5\x77\x5c\x71\x18\x23\x41\x64\x0e\x63\xee\x60\x06\x17\xdf\x71\x85\xe9\x2b\x72\x0c\x2f\x4d\x5d\x09\x41\x09\xd1\x89\x8b\xc8\x79\x41\xf4\x1c\x57\x0b\xf1\xc3\x00\x34\x39\x5d\xef\x73\x38\x5c\xce\xb0\x28\x1a\x06\xc4\xe3\xd5\x06\x27\xd7\x90\xac\xac\xfb\x2c\x53\xf9\x55\x39\x4c\xbe\xf2\x23\x41\xcb\xc1\x4c\xf0\x48\xd8\xe7\x74\x1f\x36\x38\x0f\x29\x8f\xc3\xf4\x59\xdc\xd0\xef\x13\xce\x2f\x6c\x9c\xf8\x70\xb1\x76\xa0\x97\xfd\x35\x39\x45\xb7\x8a\xfe\xc5\x2d\x17\xc8\x09\xe3\xa9\x73\xdd\xec\xa8\xbb\x96\xcc\x7f\xbe\xb6\x29\x51\x3f\x99\x7d\xf3\x42\x7a\x94\x18\xff\xed\xc2\x99\x6b\x96\x15\x1e\x34\xee\xdd\xf5\x7b\xcb\x72\xeb\x02\x39\xce\x20\x6d\xaa\x84\x3e\x89\xa1\x8e\x74\x15\xa8\xb9\xc9\x85\x2b\x4a\x4b\x4a\x2a\x4c\x90\x0f\xb8\xdc\x16\xb7\x2f\x66\x08\x1e\xb6\x43\x1f\xd9\xed\x3e\x1f\x78\x47\xdf\x17\xe6\xaf\x94\x0b\x82\xe4\xe5\x3d\xe5\xa2\xf3\x93\x1c\x07\x8c\x39\x4f\x74\x16\x70\x6d\x5b\x07\x34\x60\x65\xe5\x39\x13\x40\x7a\xa6\x7c\x41\xd7\x92\xf9\xab\xc8\x47\xe4\xdc\xe4\xa2\x19\xe4\x1c\xe0\x8f\xef\xe3\x07\x4f\x1f\x7e\xea\x84\x53\x26\x5e\xbe\x09\xf7\x92\x4f\xe9\x31\x40\x9c\x7b\x01\x6c\xe1\x6e\x18\x8b\x08\x1a\x92\x2e\xe3\x7d\x3e\x98\x41\x36\x6b\xc4\x5a\x1e\x0d\x84\x3f\xcb\x04\xbe\xe2\x19\xdb\x21\xa3\x8b\x1c\xcf\x25\xf6\x58\x99\x2a\xed\xc5\x0e\xc1\xdd\xac\x3b\x0f\x9d\xef\x7a\xad\x9b\xe7\x71\x17\xd3\x63\xd1\xab\x17\xaf\x39\x65\x46\xd7\x79\xcf\x57\xb7\x54\x24\x3b\xb9\x53\x36\x7b\xe4\x33\xd1\x12\x87\xff\xb6\x64\xda\x9a\x65\xbd\x87\x7f\x6f\x59\x66\x91\xdf\xc9\x9b\x8d\x9e\x63\xc7\xd0\x73\xdb\x20\x97\x91\x43\x7e\xa7\xd3\xed\x42\xae\xf2\x88\xfe\xdc\x36\xbd\xd3\xae\xe8\xdc\x76\x9b\xae\xa8\x89\x3d\xda\xa4\xe9\xf7\xe4\xf6\xee\xce\xba\x70\x6d\xed\xf3\xa7\x4c\x9f\x79\xde\x6a\x32\xfc\xf5\x8b\xa6\xac\xb9\x08\xdf\xb1\xc0\x72\xb1\xe9\xf7\xcc\x08\x22\x52\xc1\xc9\x6d\x2a\x17\x68\xf1\xc3\xdc\x41\x98\x63\x0d\x69\xaf\xd9\x6a\xb5\x71\x2c\x2b\xda\x44\x87\x93\x35\xdb\x78\xfb\x61\x83\xed\x44\xf7\xa1\xb9\xb1\xcf\x4f\xd6\xcf\x63\x58\xbe\x99\xed\x4f\x78\xb8\xd3\xc7\x5e\xbc\x4c\xfa\x9d\xab\x9c\x5f\xce\x1d\x94\xc2\xa1\x86\x99\xf8\xdd\x5e\x01\x1f\x09\xa5\x97\x4b\xf5\xcc\x71\xba\xcf\x66\x08\xc4\xaf\x6f\x40\x0c\x69\x04\xeb\x46\x6b\xd2\x1e\x9b\x8d\xf7\x5a\xad\x30\xf9\x02\x25\x1e\x70\x94\x1e\x12\x8c\x78\xe8\x19\x20\x0f\x23\x8a\x4e\x7a\x86\xdc\x54\x70\x86\x5c\xbe\x01\xa4\xcf\x7e\x32\xed\x40\x79\xe1\x96\x19\xe6\x0d\xf5\x48\xb9\xf4\xf8\xb9\x67\x89\xd2\x72\x71\xf6\xfc\xb3\xe7\x88\xf8\x46\x71\x16\xbb\x40\x5a\xfe\xd2\xeb\x78\xe3\x2b\x92\x65\xcd\x86\xb5\xeb\x98\x33\xd7\xac\xdd\xb0\x42\xbe\x4b\xa7\x15\x6c\xf0\xab\xd4\xf6\xf8\x50\x29\x44\xbb\x75\x7e\xce\x63\xb4\xdb\x4b\x20\x06\xb4\x58\x10\xc7\x86\xcb\xc4\x2f\x8d\x6e\x50\x24\xa3\x20\x04\xc1\x0c\x1d\xf1\x94\x60\x48\x0e\x6c\xf8\x0b\x62\x82\xf3\xbb\x4b\xd4\xe9\x50\x70\xf6\x47\xce\x37\xc9\xb9\x1f\x47\x02\x3e\x23\x6f\x82\xf2\x4e\x08\x07\xab\x9c\x23\x70\xc2\xe1\x87\x79\x81\x47\x6f\xb8\x01\x5b\x97\xdc\x74\x95\x74\x64\xcb\xb8\xd3\x27\x8c\x97\x16\xdf\x38\x7e\xf4\xf3\x38\xea\x78\xe1\x49\x3c\x3f\x8e\x1d\xd2\x31\xdb\x4b\x4f\x4a\x5b\xcb\xa4\x8f\x99\x5d\x37\xdc\x64\xed\xdd\x6d\xbf\xe9\x7a\xe9\xa7\x38\x33\xd1\xa3\x8c\x6b\x12\xed\x67\x36\x41\x2c\x38\x10\x64\xaf\x75\xf3\xf5\x25\x25\x56\x6b\xb4\xaa\x31\xda\x98\x6a\x6a\xa8\xf9\x2c\xd3\x10\xe7\x4b\x1c\x95\x71\x84\xe2\x71\xb0\x4b\xf1\x2f\x1c\xe0\x4a\x3c\x1e\xc7\x11\x12\xf1\xe5\x03\x3e\x52\x0d\x6a\x93\x6b\xeb\xf2\xc2\x11\x69\x40\x53\x93\x92\xd8\x93\xbd\xe5\x55\xf9\x45\x22\x25\x98\x8d\x60\xe5\xc0\xa3\x96\xe4\x83\xb6\x6e\x73\xcc\xeb\x7a\x3c\x3a\x7c\xe5\x79\x67\x36\xdd\x74\xdd\xea\xcd\xee\x8b\xbc\x77\x4c\x9d\x34\x68\x64\xe7\xaa\xae\xe6\x6d\x9b\x97\x4f\x9a\x5a\x1e\xaf\xab\x78\x96\xc9\x0e\x6f\xbb\x34\x3e\x20\x52\x5e\x3a\x68\xd2\xe0\xf3\x17\xcd\x3c\xdb\xb6\x20\x35\xa8\xba\xc9\xe5\x8b\x0e\x9a\x36\xe2\xc2\x4b\x6a\x97\x9c\x63\x58\x66\x78\x07\xdb\xe8\x3e\xd8\x3d\xe0\x1b\x6e\x86\xf1\xf1\xa3\xa6\x74\xa9\xc3\xe7\x63\x8d\xc6\x40\x89\xd5\x05\x7e\xc1\x01\x5f\x5f\x22\x1e\x7c\x21\xb9\xa5\x50\xf5\x3c\x75\x75\xba\xab\x28\x5a\xe5\x79\x5c\x94\xde\x3b\x3d\xa6\x81\xb5\x8d\xe5\xf1\x1a\xf7\x39\xe7\x8e\x2f\x8b\xd5\x0d\x6a\x7a\xde\xba\xd4\x59\x36\xe4\x74\xb6\x75\xd5\x7a\xcb\xa5\xee\x09\x99\x9f\x0e\x1c\x27\x7d\x5b\x01\xbc\xaf\xe6\x6f\x82\xb9\x3c\x3e\x9d\xf0\x9b\x90\xb7\xa4\xc4\xe5\xe0\x6c\xc8\x56\x1e\x71\xff\x25\x40\xa3\x6c\xaf\xf3\xb0\xb9\xf4\x60\xc6\xfc\x05\xbd\x8a\xe1\x6b\xdd\x51\x29\xe5\x05\x60\xdd\x6e\x5b\x65\x6a\xc7\xb4\x05\xd1\xfe\x4e\xad\x5f\xfd\x48\x7d\x63\x22\x1e\xab\x35\xde\x3a\x3d\x43\xcf\xae\xd7\x97\x55\xe3\x6b\x7e\x67\x59\x6a\xad\x6e\x9b\xf4\x28\xee\x3d\xf3\x57\xbf\x3a\x53\x8a\x0c\xae\x37\x41\xec\xe5\x86\xdc\xe6\x18\xd8\xee\x00\xe4\xb3\x67\xa6\x1b\x2d\x4c\x69\x29\x79\x50\x2d\x12\xf1\xfb\xdc\x46\x77\xac\xc2\x62\x2d\x33\x78\x7d\x90\x33\xf2\xd8\xea\x23\x33\xcd\xe7\x33\xb3\x81\xc3\x0e\xd0\x5f\xc7\x17\xe6\x43\x8a\x5d\xa4\x17\xf5\xb5\xa9\xbb\xa2\xfa\x79\x30\x8a\x5e\x70\xaa\x04\x10\xda\x59\x77\x12\xb3\xa6\x9c\xda\x4e\xa8\xff\xc5\x5d\xab\xc7\x8f\xa7\xe6\xf2\xa2\xc9\x6b\x16\x8f\x1b\x87\xdd\x33\xcf\x93\x76\x9d\x02\x96\xfc\x29\x3c\x56\x7a\xea\xac\xc7\xef\xbb\x62\x72\xfb\xe5\x9b\xba\xce\xc2\x63\x7b\xcf\x58\xb7\xdc\x3e\xe2\xa2\xe9\xca\x3d\x37\x1f\x31\x1f\x42\x1b\x06\x92\xd7\x0a\x0c\x4e\xa7\xcf\x67\x61\x6b\xa3\xd1\xd2\xd2\xca\x24\x9b\x6c\x4a\x55\x59\xac\xe0\x49\x0d\xb5\x28\x6e\x3d\x8c\x4a\xf2\x29\x19\x31\x54\x7d\x2f\xc9\x4b\xe9\x92\x31\xfa\xa2\x17\xcd\x4b\x20\x17\xa1\x8b\x26\x34\x43\xa1\x7a\x4c\xdf\xf4\xa6\x5b\xba\xc9\x0d\x30\xd7\xdf\xfe\x74\xbc\x36\x1e\x0e\x0f\x9e\x36\x6c\x42\xb8\x22\xbc\x6c\xee\x9c\xe5\xf0\x6d\xc2\xb0\x69\x83\xc3\x61\xf8\xc5\x53\xf8\xa3\xc7\xb7\x8e\xe8\x1a\xd5\x12\xf6\x85\xe7\x8d\x69\x4f\x8e\x19\x79\x6a\xc3\xd2\xab\xaf\x5a\xd6\x70\xea\xc8\x31\xc9\xf6\x31\xf3\xe0\xe3\x96\x51\x5d\x23\x7e\x99\x55\xee\x14\xf8\x88\x79\x10\xda\x63\x97\xef\xc3\x33\x59\x59\xab\xc3\x69\xe6\x0e\x23\xc3\xc1\x93\xde\x87\x47\x6e\xe9\xa0\xb7\xe1\x6d\xb8\x65\xcb\x9a\x5f\xfd\x6a\xcd\x16\xfc\xd1\xa6\x7b\xf0\x07\x52\xf8\xa5\x97\xf0\xdf\xa4\xc4\x3d\x9b\x48\xec\x05\xb4\x77\xd2\x3c\xa4\x26\xed\x36\x0a\x4e\x9b\x0d\x09\xc8\xeb\x73\x8a\x87\x59\x4b\xfe\x38\x77\xaa\xcf\x15\x86\x79\xa7\x0b\xee\xa4\x2a\x05\x79\xd9\xce\x1d\xb7\xde\x7a\xf5\x9a\xd3\xbb\xf6\xd6\x24\xd6\x47\xeb\xd8\xb5\xbf\x7b\xff\xd6\xfb\xf0\x1f\xa5\x9a\xf3\xce\xc7\x43\xbb\x5f\x3c\x7d\xdc\xab\xfd\x9c\xb3\x37\x32\x8c\xd9\x68\xe2\x59\xe3\x21\x74\x98\x9e\xc2\x56\xa3\x4d\xf2\xf2\x21\x8e\xb1\x55\xe4\xfa\x4e\x2c\xdc\x8c\xcd\xca\x39\x7b\xee\xb3\x5e\x1e\xff\xe3\xc1\xe6\x51\xbd\x1f\xcb\xb6\x6a\x18\xd0\xdb\x41\xe9\xb5\xa4\x83\x22\x8b\x8c\x0c\x24\xac\x26\xb3\xc0\x72\x60\x9b\xb8\xc3\x58\x44\xa2\xee\xb6\xbc\xf6\xa2\x8a\x2d\xb9\xef\x56\x59\xec\xf3\x0e\xc3\x2f\x4a\x19\x66\xa0\x34\x02\x7f\x80\xbf\x9c\xc3\xb4\xcd\x9b\xd3\xfb\x3b\x25\x67\x04\xff\xeb\xa6\x7d\x74\x5a\xba\xca\x6d\xb7\x98\x78\x84\x6c\x2e\x8b\xcb\xeb\x73\xd9\x1d\x76\x50\xfc\xc3\x56\x88\x6a\x0e\x66\x2c\x87\xb4\xa0\xf5\x2b\xd5\x74\xf4\xc7\x55\x99\xb4\x6a\x14\x0b\xda\xae\x0a\xc1\xdc\x1a\xae\x8c\x96\x0e\x8c\xef\x94\xdc\x3a\x69\xee\x68\x6b\x34\x2c\x35\xfe\x7e\x16\x11\x6a\x6e\xef\xab\xb4\xee\x94\xc0\x8b\x18\x72\x87\x8e\x8f\x46\xf9\x75\x3e\x97\xd3\xeb\x15\x4a\x6c\x56\x9b\x3d\x2c\xd8\x85\xf2\xa8\xd7\xe5\x26\x87\xb8\xfd\x24\x8b\xb4\xbb\x0f\x97\x38\x7c\xe4\x7a\x13\x8b\xc9\x4e\x7c\xf2\xcb\x74\x5e\xca\x2f\xb1\x16\xbc\x45\xa6\x0c\x31\x31\xd3\x58\xbd\xdd\xa4\x0e\x93\xc2\x4a\x4c\x11\x31\x51\x21\x2a\xf7\x68\xc6\xc7\xac\x3b\x65\xca\x19\x67\x9d\xff\x48\x59\xf0\xac\xc4\xdb\xf8\x05\xe9\x0c\xa6\x11\xc4\x5d\x73\xca\xe4\x4b\x9a\x1b\x2b\x99\xd3\x57\x2d\x9e\x39\x6e\xda\x8c\x21\xa3\xea\xa6\xcc\x65\x06\x93\xce\xdc\xb0\xa1\xbc\xb2\x34\x22\xf7\x27\xf3\x3c\xc8\x5e\x42\xe2\x43\x1f\x5b\x12\x60\x18\x97\x50\x62\xb5\x08\x96\x50\x90\xf5\x11\x89\x8d\xc8\x08\xfd\x6a\xb5\x1a\xbf\x62\x4a\xe8\x14\x3d\xac\xd5\xa5\x92\x45\xb7\x6a\xea\x0a\x08\xee\x28\xb9\xeb\xcd\xdb\xa7\x8c\x80\xa3\x13\x99\x8c\xf4\xe3\x2f\xb6\x3e\x7d\xd7\xb5\xf7\xdb\x57\x95\x3d\x74\xce\xb2\x35\x4b\x06\x63\xb3\x54\xc1\x7d\x76\xb9\xe4\xde\x7d\xe3\xb6\x17\xaf\xdb\x60\x7c\x6c\xe3\x25\x17\xad\x3b\x07\x3b\x64\x1f\x3e\x0c\x7f\xca\x3c\x2e\xf0\xf4\x9e\xcf\x00\x79\x4b\xcd\x6b\xb7\x0b\x3e\x3a\x3b\x4a\x82\x5e\x10\xce\xee\xc5\x16\xd6\xeb\x35\xb0\x06\xe8\x67\xc3\x97\xac\xf9\xa0\xfe\xca\xd4\xa2\xcb\x95\xf3\x71\x06\xa3\xac\xe0\xb9\x8a\x02\x8d\xc7\xef\xdf\x76\xeb\x03\x78\xf8\xfd\x5b\xa5\xfd\x73\x33\x9c\x74\x23\x3b\x73\xde\xdc\x99\x1c\x5e\xce\x4d\x67\xff\x29\x7d\x2b\x1d\xc7\x1c\xb6\x33\x0e\xe9\xdf\xbd\x23\x5f\x78\xfd\x85\xd7\xd9\x0b\x9e\x7e\xed\xb5\xa7\x41\x4e\x69\x2f\xf7\x22\xee\x14\x6a\x20\x04\x32\x22\x2b\x0a\xa5\xcd\x66\x23\x32\x18\x58\xb4\x1e\xc2\x22\x94\x6c\xa2\x7b\x87\xc9\xd5\x4f\xd0\x3b\x90\xfd\xba\xbd\xad\x90\xa0\xf1\xf0\x55\xff\x87\xe7\x66\x0f\xda\xd9\x3b\xe7\x01\xc0\x3f\x25\x21\x3d\x1d\xdd\xd3\xd3\xb3\xbb\xa7\x87\xb4\x5d\xba\x0a\x3e\x5b\xab\xd1\x24\xd7\x80\xc1\x7f\x06\x76\x3d\xe8\x7d\x32\x15\x7c\xb3\x89\x9c\x90\x18\xd8\xc8\xb6\xb8\x53\x5e\x36\xa1\xd0\xbb\x61\xf6\x73\x7f\xc0\xa1\x9d\xbd\x22\x10\x8c\xe2\x31\x09\xe9\x39\x95\x20\xce\x5d\x2d\x4d\x44\xe7\xe6\x1e\x46\xf5\xc8\xb6\xcf\x19\xa9\x61\x03\x20\xd9\x01\x52\xa6\x75\x57\xc8\x36\x95\x18\x50\xf2\x5d\x39\xa8\x2f\xdb\x56\x62\x48\xa9\x8d\xf5\x9f\xf1\x78\xb4\x26\x0a\xff\x83\xe1\x1c\x58\x97\x34\x0e\x1b\xb6\xa0\x3c\x51\x1e\x06\xeb\x1a\x0f\x57\x35\x49\x13\xd3\x0e\x8f\xcd\x24\x18\x0d\x26\x87\xcb\xee\x75\x39\x8c\x4e\x4f\x63\x74\x44\x20\xec\xb6\x1a\x04\x83\xc5\xe3\x74\xb8\x2d\x46\x51\x74\xd0\xe7\xfb\xb0\xb4\x8b\xfb\x1b\xee\xe6\xff\x84\xdc\xc8\xf5\x04\x76\xb9\x4c\xeb\x21\x49\x84\x46\x1d\x68\x52\x5e\x85\xb0\x91\xe3\x10\xf2\x6d\x38\x23\x98\xa1\x18\x77\x57\x0c\x9e\x33\xe7\xbc\xf4\xa2\x6b\xd6\x9d\xd2\xd6\x7c\x46\xf7\x82\x51\x31\xfe\x8c\xc4\x80\xc4\xd5\x8b\xda\xc6\x56\x37\x56\xcb\x34\x5f\xe1\xde\xc5\xf5\xfc\xbb\xe4\x72\xf1\x27\x79\x66\x3d\xc3\x6e\xca\xdf\xb4\x03\x44\x79\x72\xa5\x0a\xae\x97\xfe\x21\xed\xc2\x43\x8e\xf0\xe7\x6f\x59\xbf\x5e\xc6\x7b\x17\xf0\x86\x50\x3c\x5f\xda\x8a\xb9\x4d\x19\x3b\x1b\x61\x93\x2c\xcb\x42\x08\xf6\x66\x77\x1d\x49\x19\x13\xad\xfe\x28\x1e\x22\xed\x92\xfe\x91\x3e\x82\x87\x70\xef\x6e\xb9\x70\x7d\x31\x4f\xc0\xe5\x18\xc0\xe5\x22\x5c\x92\x63\x39\xa4\xe0\xba\xab\x80\x2d\x7f\xe4\x88\xf4\x0a\xee\xc2\x76\xee\xdd\xf5\xeb\xb7\xf4\xe1\xc9\x63\xc0\xe3\x23\x7c\x92\x67\x79\x90\xf8\x65\x99\xa7\x58\x95\x20\x3c\x5f\x39\x92\xc6\x76\xdc\xc5\x4f\x5b\x7f\xe1\x16\x99\xe7\x3c\xc0\xdd\x01\x7d\x27\x12\x9d\x80\xf8\x9a\x5f\x2f\x50\x59\x41\xb5\xd5\x0e\x14\xab\x44\x10\xb9\x15\xef\x18\xfe\xc9\xf7\xd2\xbb\xc3\x8f\x1c\xe6\x47\x2e\x5a\xbd\x7a\xcb\x22\x68\xb2\x1e\x1f\xf4\x54\x14\x04\xcc\xad\x27\xcf\x7e\x13\x3d\x05\x6c\x50\x2c\x79\xb7\x74\x15\x08\xe0\x6f\xf5\x5f\x7a\xf8\xc8\x70\x5c\xff\xfd\x27\xc3\x89\xec\x8b\xb6\xac\x5e\xbd\x88\xe8\xd2\x62\xa9\x0b\x5d\x98\x7b\x1d\x66\xa5\x63\x1f\x0f\x5a\xce\x92\x2b\x6d\x80\x3d\xb9\x4b\x9e\x54\xcb\xe9\xae\x36\x75\xe7\xea\x26\x76\x1a\xc7\xf8\x5b\x07\xc6\x5d\xe1\xe1\x2d\x52\x17\x0e\x8c\xf0\x9d\xd6\x18\x65\xcf\xe0\xc6\xb6\xde\x05\xb4\x2e\xe6\xd6\xa2\x1b\x85\x28\x4c\x69\xcb\xe3\x0c\x5a\xcf\xa1\x64\xf0\x2d\xa2\x95\x5e\xd1\xef\x4d\xb4\xdc\xf8\xf0\xc3\xd2\xdf\x85\xe8\xb2\x39\x73\x96\xed\x9a\x42\x6c\xae\x74\x48\x9a\x81\x1f\xcd\x1d\xa7\x6f\xba\x43\x0f\x98\xc9\x7e\x44\x8e\x59\x2f\x50\xbc\x54\x32\xf5\x26\x59\xe6\x84\xd9\xd0\x5a\xd5\x02\xbe\x2b\xe5\x6f\x4d\x61\xe9\xef\x0f\x3f\xcc\x94\x4e\xd9\x45\xa8\xec\x91\xbf\x49\x0f\xe0\x92\x87\x1f\x96\xcf\xd7\x77\xf1\x53\xf8\x0d\xae\x4a\x04\xc1\xb4\x53\x64\xfe\xce\x3c\x02\x7c\xec\x69\x23\xcb\xf8\xb1\xdf\xc9\x89\x89\x3a\x67\x4b\x8b\x5c\xa7\x23\xeb\xef\xcb\xb9\x89\x00\x3b\x5a\x81\x6d\x83\x5f\x38\x1f\x63\x99\xd6\x9e\xdc\xbb\xd9\xd6\x81\x6c\x48\x86\x06\xd8\x87\x10\xe2\xbe\x14\xfe\x01\xb0\x09\x0a\xbb\x0d\xdf\x8d\x13\x28\xf0\x04\x5b\x51\xc1\x57\xb2\xe5\x3d\xb9\x37\xb2\xe5\x15\x3c\x22\xf0\x88\x7c\x11\x9c\xab\xe4\x73\xee\x80\x73\xaa\x82\x73\x0b\xd0\x37\x65\x99\xaa\x2a\x67\x25\x81\x22\x74\xa5\xd7\xb8\x2f\xa9\xbc\x94\xae\xd1\xc5\x7a\x88\xbc\xbf\x26\x24\xb3\x79\x92\x32\x3d\x80\xd5\xd1\x33\xba\x98\x6f\xe0\x17\x96\x27\x99\x84\x29\x51\x65\x52\x00\x29\xcd\x67\xf4\x34\x99\x6f\x99\xf5\x32\xcd\x68\x4f\xee\xc9\x6c\xb4\x88\xe6\x33\x05\x32\x7e\xcb\xb4\x52\x58\xa6\xb2\x27\xf7\x79\xb6\x52\x23\x4b\x60\xcf\x97\x26\xf2\xab\x84\x63\x8e\x2a\x83\xc4\xf8\x11\x72\x54\xa2\x4a\x82\x83\x56\xd3\xb7\x81\x6d\x4f\x22\x9e\xe7\x2b\xcb\x9b\x71\xb7\xd2\xb6\x2e\x69\x1e\xfb\x3a\x7f\xd0\x51\x05\x10\x2e\xe4\x01\xf8\x31\x14\xfe\x52\x7c\x1e\x85\x67\x40\x39\x2b\x23\x79\x78\xe8\x63\xfe\x1c\xda\xc7\x55\x4a\x7f\x1d\xa0\x7d\xcc\xf8\xfd\x7c\x25\xe3\xed\xc9\x3d\x93\xf5\xfa\x85\xc2\x3e\x9e\x91\x3b\xc2\x1e\xa5\xf2\x8f\x55\x70\x38\xb9\x8f\x63\x31\x7d\x1f\xf3\xe7\xd0\xfe\xa8\x52\xfa\x78\x9c\xdc\x46\x20\xf9\xab\x3c\x49\x99\x9e\xf4\x9a\x9e\x1e\xf4\xf1\xdd\x32\x6c\xbc\x27\xf7\x59\x36\x5e\x29\xb8\xf2\xb0\xd0\xcf\x7a\xba\xd0\x77\xd7\xcb\xb0\xbe\x9e\xdc\x95\x59\x5f\x11\xdd\x67\x0a\xe4\xfc\x96\xa9\x51\xc6\x4e\x48\x68\x44\x29\xcd\xb6\x02\x9a\x87\x98\xad\x32\xcd\x40\x4f\xee\xc6\x6c\x20\x5c\x48\xb3\xad\x80\xe6\x21\x26\x2c\xc3\x56\xf5\xe4\x7e\xc8\x56\xd5\x17\xca\xda\x55\x40\xf7\x28\xf3\x8c\x0c\x1b\xea\xc9\xfd\x3a\x1b\xf2\x16\xd2\xed\x2a\xa0\x7b\x94\x71\xc9\xb0\xb5\x3d\xb9\xc3\xd9\xda\x78\x01\x5d\x98\x17\x92\x58\x07\xb0\xd5\xb4\xbf\x5e\xa1\x74\xc3\x60\xcb\xb0\xdb\x0d\xa3\x86\x3d\x3d\xb9\x2f\xb3\x1e\x2f\x36\xcb\x53\x49\x9d\x4f\x5d\x30\x37\x02\xc2\xbf\x00\x0f\xc6\xc2\x51\xc5\x6c\x24\xef\x6b\x82\x6e\x8c\x42\x2f\x63\x37\x8a\xa6\xfd\x6c\xa4\x0c\x37\x96\xdd\x5b\xb6\xb7\xec\x9d\xb2\x4f\xca\x8e\x95\x09\x65\x4c\x30\x28\x0f\x69\xb2\x7b\x69\x4b\x7f\xbc\x7f\x47\x79\x07\x9f\x64\xb0\x97\x70\xf6\x12\xce\x5e\x8f\xc6\xb9\xa5\xa5\x2f\x5f\xd0\xc5\x8b\xb0\x1b\xda\x48\xf9\x13\xbe\x4c\x24\x82\x1b\x23\xf7\x46\xf6\x46\xde\x89\x7c\x12\x39\x16\x11\x22\x6c\x79\x79\x11\x5f\xb0\x1b\x12\xed\xcb\x6a\xa5\x7f\x5e\xa3\xfd\x83\xdd\x3d\xb9\x7f\x64\xdd\x56\x99\x63\xde\xc6\x04\xa8\x8d\x19\xa7\xc0\x8e\x97\xc7\x3d\x6a\x89\x86\x2c\xfa\x71\x2f\xa4\xf9\x8d\x32\x3e\x4a\x2b\xa2\x27\xa3\xf9\x0d\x33\x48\x1e\x9f\x58\x4f\x2e\x97\x8d\x25\x2d\x05\xe3\x3e\x11\xfa\xa8\xd3\x41\xe9\x42\x3f\xdf\x89\x37\xe0\x85\x74\xce\x92\x4b\xba\x88\x8f\xb4\x58\xf8\x4a\x6c\x47\x10\x7b\x31\xea\xcc\xa2\x3c\x26\x72\x01\xfe\x73\x87\x3a\x3e\x77\x92\x20\x8e\xe2\xd5\xca\x78\x74\x34\x40\xe1\xc2\x31\x8b\x53\x87\x47\xc6\xe4\x66\x3a\x87\x6b\x74\x73\x98\xf0\xb1\x5a\x81\x8f\x39\x61\xb6\x8a\x46\x1d\x3c\x68\x2c\x33\x8c\xc2\x8f\x97\xe1\xd1\x15\x0a\x7c\x49\x09\x53\x89\xfd\x13\xfc\x25\xbc\x57\x07\x7f\x5e\xee\x08\x7f\xaf\x70\x17\xc0\xd7\x52\xf8\x8d\x10\xcb\x8f\xa7\xf0\xe5\xe5\x40\x3f\x1a\x8e\x56\xa0\x80\x0e\x5e\xd6\xe5\xa9\x00\x7f\x9a\x0c\x8f\x3e\x57\xe4\x6f\x6c\x04\xf9\x07\x1a\x07\x36\x39\x4b\x0b\xe5\xe7\xcb\xa9\x3c\x75\x8a\xfc\xdf\x2a\xf2\xd8\xed\x40\xdf\xca\x5b\xed\xbc\x59\x07\x4f\xde\x40\xfa\x9a\xc2\x4f\x50\xe0\x2f\x57\xe0\x4b\x4b\x41\xfe\xe0\xa0\x60\xa9\x5b\xd4\xd3\x07\x5b\x54\x4e\xc7\xb9\x4e\xb1\x45\x17\xc8\xe3\x6c\xed\xc9\x1d\xcb\x6a\xc4\xe5\xf7\x95\xc0\x16\x7d\x4d\xe7\xe1\x04\xc5\x16\x29\x7a\x16\xec\xc9\x7d\x97\xd5\x08\xab\xf3\x10\xe4\x7e\x4c\xa3\x8b\xf1\x8d\x85\xf3\xd0\xd9\x93\xfb\x2a\xeb\x54\xe8\xe7\xe7\xa1\x2c\xff\x67\x2a\x0f\xb4\x10\x57\xe0\x85\x28\x98\xb6\x33\xd0\xa1\x0c\xe0\x95\x55\x95\x29\x8c\x64\x24\xc0\xb9\x19\xfc\x80\xd6\x06\x87\x80\x56\x07\x65\x19\x2e\x94\x26\xe6\xe5\x25\x9f\xff\x53\xd5\xc1\x65\xfa\x36\x33\xc7\x98\xf7\xe4\x76\xd8\x7b\x72\xdf\x66\xed\xfe\xc2\x36\x2f\xd3\xb7\x19\x60\x47\xd0\xf9\x82\x4b\x51\x69\x5c\x6d\x70\x2e\x97\xdb\x27\x75\x31\x57\x50\x9a\xf5\xf2\x1c\xc0\x21\xad\x1f\x73\x59\x6b\x09\x66\x35\x9a\xb9\xcb\x00\x76\x3c\xa5\x79\xba\x0c\x8b\x3e\x95\xe7\xa0\x13\x39\xc3\x7c\x9e\xe6\x0f\xa0\x8b\x1d\xd4\x9e\x50\x9a\xc6\x66\x5c\x01\x70\x65\x69\x27\x0b\xdd\xe7\x04\x37\xcf\x60\xbb\x60\xb7\xca\xa4\x95\xee\x68\x91\xdf\xe0\x62\xd6\x08\x87\x00\xef\x5b\xea\x15\x17\xfe\x99\x7a\x39\xb4\x11\x7c\x51\x2c\x1d\x60\xc9\x9d\xf3\x8b\x6d\x9b\x6d\xdc\x3d\xb6\x3d\xb6\xb7\x6d\xac\x8d\xc1\x06\x83\x6c\x52\xf4\xb6\x8c\x6f\x17\x8e\x01\x8d\x06\xc2\xdb\x20\x91\xe7\xdb\xa9\x1e\x11\xce\x18\xa6\x8f\xa3\x40\xef\xe8\xbb\xc4\x62\x00\xe0\x27\xca\xf0\x68\x1b\xcc\xf0\xc0\x13\x00\x0e\x6a\x07\x9d\xb0\x34\xab\xc7\x50\xc6\xe1\x35\xbe\x9d\xf6\x59\x83\xa2\x7b\x23\xb5\x3e\x7b\xb2\x48\xf7\xae\x87\x58\x83\xa5\x7d\x36\x51\xd1\xbd\xfb\x35\xd8\xdf\x15\xc1\x12\x3f\xa8\xa3\x0b\xbe\xed\x09\x19\xd6\xd6\x93\x7b\x31\x6b\x2b\xa2\xfb\x8c\x9e\x2e\xc0\x56\x6a\xb0\x1f\x17\xc1\x92\xd8\x28\x49\xe9\x26\x15\x79\x2d\xb2\x2e\x88\x46\x50\x70\x5e\xb3\x9d\xd7\x49\xaf\xe1\x11\x94\xe6\x24\x19\x0e\xaf\x96\x69\xf2\x44\x17\x78\x51\xa7\x0b\x32\x4d\x6a\x3f\x92\xc4\xae\x01\x4d\xa4\xd8\x91\x2a\xb0\x23\x10\x37\x98\x4c\xbc\x12\x37\xe4\xde\x01\xba\xff\x14\x76\xc8\x74\x09\x2c\x5e\x23\xc3\xe6\xb6\xe3\x89\x04\xd6\x60\x60\xf2\x31\xc6\x33\x7a\x59\xa1\x5d\x0b\x64\x19\x0c\x3d\xb9\xde\xac\x41\x13\x97\xe8\xd9\x1f\xa5\x67\xf0\x0f\x79\x79\x99\x6f\xa9\x4d\x82\x76\x09\x58\xd0\x84\x55\x7c\x82\x9e\xe6\x51\x66\xbe\x36\x06\xdf\x65\xad\xa2\x9e\xe6\x9d\xa0\xe3\x95\x3a\x9a\x47\xd1\x67\x32\xac\xb9\x27\xf7\x53\xd6\xcc\x17\xf4\x01\x42\x02\x43\x75\xad\x51\xd6\x1d\xe6\x5a\x45\xd7\xa8\x0d\x2d\x9d\x54\x1a\xb1\x07\x75\xba\x06\xbf\x15\x62\xfc\x41\x80\xef\x94\xe3\x37\xe6\x49\x05\x3e\x99\x74\x56\xe2\xba\xb5\x75\x0d\x96\xf2\x42\x1b\x0a\xf4\xff\xa1\xd2\x67\xb6\x31\x67\x2b\x36\xb1\xac\x8c\xd0\xe7\x4a\xcb\xfa\xa1\x7f\x40\xa5\x4f\xe0\x15\xfa\x03\x06\x10\xfa\x6c\xdd\x80\x42\xfa\xd2\x6b\x02\x43\xfb\xa5\x51\xd1\x8b\x7f\x28\x36\x82\xd7\x28\x93\x76\x5e\x0b\x70\x31\xea\x27\x3b\x15\xb8\xaf\x65\xb8\x3a\xac\x51\x44\x05\x36\x7f\xa0\x62\xc3\xbf\xa2\x71\xa7\x3c\xf5\xec\x44\x89\xec\x4e\xc1\x5a\x30\x97\xae\x25\x76\x93\xca\x3c\x59\xc1\x99\xa6\xc8\x5c\x56\x06\x32\x97\xda\x4b\xcb\xac\xc1\x7e\xed\xfe\x40\x45\x96\xa5\x9a\x0d\xfc\x3e\x4f\x5e\x95\x9b\xfd\x9a\xca\x3d\x59\x99\x7b\x6f\xc9\xb0\xa5\x64\x2c\x35\xc2\xda\xdc\xd3\xd1\x05\xbd\xfb\x54\x86\x75\xf4\xe4\xa4\xac\xa3\x88\xee\x33\x7a\xba\x00\x3b\x44\x86\x0d\x93\x26\x86\x8b\xe8\x76\x15\xd0\x3d\xca\xfc\x9f\x16\x8f\x1c\xcd\x7a\xed\x85\x74\xbb\x0a\xe8\x1e\x55\xe9\x56\xf4\xe4\x8e\x67\x2b\x4a\xf5\x74\xe7\x82\xff\x7e\x8f\xda\xd8\x26\xda\xb6\x57\xd9\x18\xfc\x22\x90\xb6\xb1\x4c\x8c\x58\xd8\x98\x18\x4b\x1a\x90\x16\xb1\x21\xed\xad\x6f\xe1\x38\xe0\x4c\xa1\xb1\xc8\xdd\xe8\xb0\x62\x23\x37\x22\x13\xaa\x4d\x97\xb2\xeb\x9a\xef\x69\x3e\xda\xcc\x76\x36\xef\x6f\x66\x9a\x21\x5d\x70\x02\xa5\x72\x54\x5e\x2f\x20\xcd\x71\x25\xbb\xbb\x5b\xfa\xe1\xff\x1a\x5b\x0e\xfc\x4b\xd3\x0e\x8e\x65\xea\xf8\x4a\xf2\x37\x57\xd7\xaa\x48\x40\x45\xd0\xcb\xf0\x4c\xb1\x0c\x46\x8c\x72\x20\x43\x77\x7a\x3c\xc7\x46\x9a\x93\xcd\xed\xcd\xb3\x9b\x39\xf9\x87\x49\xf0\xe3\xe2\xe6\x3d\xcd\x1f\x37\x1b\xec\xcd\xea\xef\x16\x37\xcb\xa2\x1a\xf7\x37\x63\x59\x50\x8e\x4d\xa1\x54\x53\x79\x7d\x42\x27\xb0\x4e\xe6\xa5\xcb\x64\x3f\x5d\x2c\xf7\x2b\xe4\xaa\x6e\xe2\xdf\x59\x86\x66\xa0\x24\xf6\xfb\x24\x1b\x8b\x1b\x50\xa1\x7f\x97\xe5\xfe\x97\x26\xf7\x46\x59\x6e\x88\xb3\xf7\x41\x9c\xdd\x90\x2e\xef\x27\xce\x96\xfb\x2f\x80\x02\xfe\x82\xfe\x5b\xda\x5f\xff\xfd\x8e\x91\x68\xcc\xcd\x32\x71\x22\x05\x64\x49\x7f\xcb\xc6\x63\xba\x11\x3c\x89\x0c\x97\xe2\xd9\xff\x95\x0c\x72\x2e\x4e\xec\x57\x4a\xd1\x03\x92\xe3\xab\x79\xa2\x9b\x28\xb3\xdb\x27\x16\xe5\xe2\xf4\xbc\x36\xb1\x61\x53\x15\xde\x8b\x94\x38\xb0\xb6\x16\xe2\xc0\xca\xc1\x95\x35\x16\x54\x14\xc7\xca\xf9\x7e\x4a\x99\xdf\xbf\x93\x73\x51\xaf\x57\xe6\xf1\x5d\xd6\xed\xed\x97\xc7\x01\x95\x07\xe0\x2c\x57\x78\x54\x57\x13\x1e\x81\xca\xea\x62\x1e\xfc\xf9\x94\x47\x8b\x02\xff\xa2\xcc\x23\x18\x04\x1e\x90\xf0\xed\xcd\x06\x82\x7c\x1f\xbb\xc3\x5c\x4b\x79\x4c\x57\xe2\xe5\x7b\x15\xbb\x43\x7a\x0c\x7b\x6d\x5e\x3f\x6b\x2d\xb2\x3b\xe7\xd3\x79\xdc\xa2\xd8\x9d\x73\xb5\x7c\xf2\x77\x79\xf2\xaa\xdd\x21\xe7\xef\x54\xda\x60\x77\xc2\xda\x9c\x97\xb2\x1a\x61\x2d\x96\x38\x9f\xfa\xd1\x16\x79\x4c\xf1\xb5\x78\xbc\x46\xdf\x93\xb6\x30\x01\xd2\x06\x18\x3f\x5e\x09\xf7\x65\xf9\x2f\x06\x1e\x77\xd0\x78\x7c\xba\xec\x53\x09\x0f\xa7\xc0\x6c\x1c\x29\xf7\x54\x20\x00\xad\x28\x41\x25\x01\x64\x29\x8a\x5d\x9e\xd1\xb7\x83\xf9\x96\x15\xe4\x76\x94\x10\xd9\x4a\x0a\xda\x31\x4d\x7a\x46\xdf\x0e\xe6\x5b\x5a\x6f\x80\x76\xf8\x48\x8c\xe1\x2b\x68\x47\x37\xe8\xe6\x0f\x74\x0c\x06\x15\xe5\x2b\x03\x07\x82\xf1\x4f\xfa\x93\x03\x79\xfd\x98\xb5\xe5\x8e\xb0\x4f\xd0\xfe\x9f\xa1\xc0\xf3\x4a\xff\x37\x34\x80\xe4\xf5\x6c\x7d\x83\xa0\x87\xef\x86\x78\xe3\x07\x7e\xab\x4a\x1f\xfa\x67\xb4\xec\x83\x92\x8c\x46\x99\xc8\xd1\x06\x36\xff\x09\x6e\x82\x4a\x17\xfa\x65\xb3\x0c\x57\x8f\x34\x8a\x9a\xbc\xa2\x57\xa3\xf7\xba\x9c\xf3\x92\x78\xbd\xb5\x95\xc4\xf9\x8d\x0b\x1b\x07\xf1\xa8\x20\x5e\x97\x65\xfe\x3f\x8d\xf6\xeb\xf8\x7f\xa5\x97\x64\x9c\xe6\x66\x50\x4c\x3c\xa0\x75\x40\x4a\x28\xc4\x91\xf9\xd4\x69\x7c\xde\x60\x76\xaa\xf9\x44\x2a\x45\xf8\xb4\xf4\xe4\xfe\x9d\x6d\x19\xca\x17\xd9\x1b\x99\xd7\xd7\x1a\xaf\x37\xf0\x8f\x2a\x2f\x9a\x70\xe1\x26\xb6\x69\x70\x31\x2f\xd2\x47\xea\x18\x80\x2e\x6d\xc3\x59\x9c\xa0\x7d\x35\x4a\xeb\xdb\x7e\xc7\x82\xf4\x99\x3a\x16\x14\x0f\xeb\xfa\xee\xc4\x63\x02\x51\x2a\x97\xa5\xfc\x5a\x95\x31\x5c\xa3\x8c\xb9\xd9\x0c\x7c\x8c\xc8\x68\xe6\xf5\x39\x5b\x24\x77\x8c\xa9\x15\xde\x07\xf8\x2e\x65\xce\x25\xb0\x95\xc4\x07\x01\xd0\x71\xa2\x54\xff\xca\xfa\x02\xa2\xa7\x40\x5f\x1b\xa0\x4d\x59\xaa\xaf\xad\xca\xb8\x1b\xe4\xf1\xd4\x51\x27\x70\x11\x98\x0f\xb5\x7c\xbd\x4a\x1b\x62\xcc\xef\x64\x38\xdf\x60\x8d\xa6\x4c\xef\x19\x3d\x3d\xf0\xdd\x4b\x64\x9d\x36\x11\x73\x67\xd2\x48\xca\x34\x9f\x61\xe6\xe4\x69\x82\xfe\x4f\x94\x69\xfa\x6b\xfc\x85\x34\xbb\x0a\x68\x1e\x65\xf2\x31\xc9\x8f\x59\xbb\x51\x4f\xd3\x00\xf1\xe5\x16\x1d\xcd\xa3\x78\xaa\x12\x73\xd5\x94\xfa\x74\x34\xef\x86\xb8\xa1\x86\xd2\x1c\x4c\xe1\x3e\xa7\xf1\x88\xf3\x31\x06\xcb\x13\xd5\xcf\x3b\xb4\x9a\xea\xd5\x10\x37\x1c\xe6\x86\x00\xec\x4c\x05\x96\xc6\x0d\x44\xc7\xca\x71\x79\x59\xd0\xaa\xab\xd5\x16\xd3\xfd\x86\xf9\x9b\xcc\x3f\x8c\xc2\x35\x32\x4d\xd4\x1f\xcd\x6f\x68\x4d\x17\xe0\xe2\x38\xde\x18\xb4\x9e\x50\xce\xa3\x8c\x12\x2f\x87\x48\xbc\x1e\xf2\xaa\x24\xfb\xa3\x79\x54\xcd\x59\x20\xbe\xf9\x02\xe2\x9b\xa0\xce\x9e\xdc\x0d\xfe\xb1\x86\xce\x9b\xc1\x72\x7c\x43\xe5\x84\xf8\x86\x81\xe8\x14\xd4\x1f\xd2\xd8\x6a\xb5\x0b\xd4\xf8\x86\xbc\x3f\x7f\x98\xc6\x37\x33\x95\xd8\xe2\x43\xc5\xaf\x9d\x2d\xc7\x37\xcc\xba\x96\x7b\x5a\x8e\xb6\xb0\x9d\x2d\xfb\x5b\x98\x16\x1c\x0a\x91\x89\x14\x47\xd0\x20\x53\x71\x7c\x53\xcc\xff\x00\xf3\x57\x5a\xd7\x32\x43\xf2\x1a\x0e\xd3\x1c\x36\x44\x06\x42\x6d\xa1\x9a\xc6\xe6\xe5\xb8\x44\x93\x63\x23\xfa\x4e\xae\x09\xa0\x23\xe8\x38\x3a\x35\xdd\xc4\x32\x91\x78\x32\xde\x1e\x9f\x14\x5f\x1c\xe7\xed\xf0\x03\xb3\x3f\xfe\x4e\xfc\x93\xf8\xb1\x38\x17\xa7\x52\x41\x18\x82\x62\x15\xe1\xb2\x04\x69\x67\x48\x96\x4e\x1f\xcc\xc8\x7c\x8c\xe0\xf7\x3a\x44\x01\xf8\xb4\x51\x19\x19\x3c\x57\xf6\x19\xd8\x05\xf3\xc9\xc5\xbb\xca\x18\x83\xde\x67\xd0\x37\xae\xf9\x67\x01\x3e\x43\xfb\xff\x6e\xb4\x9b\xcc\xef\x7d\xd8\x03\xb3\xdb\x43\x5a\xe3\x29\x67\x4c\x0a\x06\xa1\x0f\xbe\xa9\x83\x8e\x6d\x9b\x32\xf7\xd2\xda\x5c\x91\xb2\x26\x8b\x42\x5d\xa6\x0d\x36\xe4\xdf\x74\x6c\x33\x8a\xed\xb8\x51\x86\xb5\x90\xb8\xdc\x62\x53\xe8\x22\x45\x6e\xf1\x1a\x1a\x77\x0c\xa1\xe3\xd3\xcb\x8c\xa4\x71\x07\x26\xfe\x9a\x74\x6b\x4f\x36\x54\x66\x2c\xd1\xdb\x01\xf9\x2d\x79\x1a\x77\x9c\x21\xc7\x5d\x78\x9c\x8c\xe3\xf5\x3a\xa9\xed\xb8\x2f\xeb\x2b\x31\x14\xda\x8e\x62\x3e\x12\xf3\x2f\xa5\x7f\x08\x9f\xe0\x84\x60\x58\x65\xd2\x3f\x8f\x4b\xa9\x7e\x12\x78\xc2\xc3\xdb\xed\x0d\xa8\x0c\xf4\xf4\x1f\x53\xe9\x1b\x31\x73\x8d\xea\x43\x68\xe4\x81\xcb\x98\xb2\x52\x99\x85\x6a\xa3\x15\x1e\x6b\x34\x1e\x0b\xf1\x0e\x15\x87\xb4\x84\x21\x3e\xdb\x2f\xb3\xd1\xec\xba\xcc\xe7\x1f\x2a\x1f\xc8\xeb\xfe\xa0\xd8\x59\xa2\x89\x38\x84\x42\xe1\x7c\x6f\x69\x3c\x0e\xa8\x3c\xc0\x2e\x7f\xad\xd8\x71\x1a\x15\xf8\x90\x2f\x90\xef\x29\x79\x9c\xc5\x6b\xe8\x38\xcb\xed\x70\x71\xb3\xe5\xb9\xae\xa3\x4c\xfb\x07\xf4\xe1\x00\x1d\xe3\x33\x14\x7d\xb8\x4c\xb1\xb1\x79\x8a\x48\xf6\x0b\x7c\x1d\x95\x77\xa8\xc2\xff\xf9\x82\xda\x9f\xc1\x6a\x67\xf5\x35\x18\x3f\xe8\xe5\x97\x54\xde\x59\x0a\xbc\x51\x1e\x5b\xbb\xdd\x59\xa9\x14\xa2\x74\x18\x3a\x1e\x8f\xa9\x3c\x8c\x18\x2f\x56\xfb\x51\xa9\xd3\x09\x4e\x05\x47\xeb\x47\x99\xcf\x1a\x95\x0f\xcc\xc7\xa7\xf3\xb5\x3d\xa7\x5c\xdb\xeb\xcd\x16\xa2\x11\x5e\x03\x80\x57\x0d\x6d\xcf\x30\x45\xbe\x1e\xa5\x3d\xb4\xe6\x6b\x62\x4d\x16\xce\xa0\x6b\x0f\x0f\x76\xee\x27\xda\x9e\x33\x15\xf8\x12\xa5\xff\x49\xad\x17\x07\x6c\x81\xa0\xd1\xa5\x83\x07\xed\xe7\x76\x0a\x12\xc0\x0f\xa7\x7a\x9a\xa3\xe7\x77\x08\xbc\xc3\x01\xf4\x9d\x41\xa7\x99\xd1\xd7\x7a\xc1\x63\xb0\x77\xf2\x7f\x04\xf8\x6e\x4a\xff\x5a\xf4\x80\xdc\x5f\x0e\x07\x90\x77\x92\x64\xd1\x69\xc6\xc6\x82\xfe\x1a\x09\x7e\x74\x27\x1d\xe3\xe1\x3a\x3f\x2a\xd7\x35\x72\x59\xb3\x55\x61\x40\x61\xa7\xc2\x5c\xbe\x93\x8e\x73\xb7\x32\x97\xaf\xd5\x60\x7f\x04\x58\xac\x83\x1d\x09\xfe\x54\x47\x17\xfc\xe9\x32\x59\x27\x2c\xc8\xa2\x11\xa5\x34\x9f\xd1\xd3\x04\x5f\xfa\x9d\x66\x1f\x7a\xb3\x96\x02\x9a\x9b\x48\x7e\xad\xab\x5d\x7e\xcb\x0c\xd3\x7c\x0a\x58\xdc\x82\x7a\xad\x19\x62\x8a\xc1\xc2\xb5\xaa\x3f\x45\x0b\x73\x7f\x81\x98\x82\x8e\x69\x29\x75\x14\x41\x42\x3f\xa8\xb8\x6b\x6d\x4c\xe5\x39\x22\x2c\xd7\xe6\xc8\x5d\x58\x5b\x6f\x21\x93\x84\x51\xfd\x97\xa1\x10\x4f\x1e\x5b\x8a\x27\x8f\xed\x5d\xe8\xef\xf9\x39\x4f\xf0\xc2\xe6\xb0\x5f\x1e\x5d\x4d\xef\xc8\x5a\xc9\x72\xfe\x5b\x97\xba\x3e\xba\x9e\xc4\x57\x60\x77\x99\x11\x80\x30\x82\xd4\x01\x46\x0c\x95\x97\x48\x65\xbb\x7b\x3d\xe4\x26\x4e\xa2\x6f\x44\x0f\x68\x9c\xd4\xa9\xd6\x51\x18\x5a\x47\xf9\x77\xd6\xee\x64\x0c\xf9\xf1\x45\x18\x3d\x04\xfe\x6a\x14\xbf\x15\x25\xe8\xeb\x73\x8e\x18\x5b\x11\x0a\x95\xba\x2a\x2a\x2c\xa8\x14\x55\x56\x39\x63\x31\xfb\x9c\x8c\x2b\x16\x2b\xe7\xca\xbd\xb3\x33\xe5\x5c\xa9\x8b\x33\xce\xce\x70\xee\xc2\x17\x31\xfa\x6e\x31\x93\x6f\xe9\x91\x8f\xa7\xe9\x77\xad\x34\xd0\xed\x08\x64\x9f\xae\x03\x45\xcb\xdd\xb8\x0c\xf3\xa3\x56\x7c\xb4\xe9\xee\x2b\x42\x17\x6c\xba\x73\xcb\x43\x7f\x38\x15\xb7\x34\x3d\x32\xe3\xec\x6b\x3a\x13\xcf\x63\x16\x97\xe2\xf9\xcf\x49\xfb\x5e\xfd\x08\xdf\xb4\xfe\xb9\x73\xcb\xef\xae\xda\xb4\xee\x86\x35\x37\xe0\xd9\xad\x23\x1b\xce\xba\x7b\xeb\x4f\xaf\xb0\xd5\x78\x3c\x4e\x48\xdf\x4a\xdb\x6d\xef\xca\x6b\xcf\xaf\xe9\xd7\x9e\x41\x57\x9b\xe5\x1c\xc5\xd5\x93\xfb\x26\xeb\xf2\x70\xa2\x7e\x0d\xe7\x35\xfd\xda\x33\xe8\xea\xab\x32\x6c\x53\x4f\xee\x40\xb6\xa9\x59\xe9\x57\xf9\xce\x78\x18\xf3\x29\xd4\xa7\xcb\x6b\xda\x6f\xb0\xef\x2a\x79\x25\xa9\xd7\x31\xfe\x80\x3f\xc4\xe9\xe3\x55\x79\xdc\xbe\xd7\xc6\xed\x0d\xb6\x59\x7a\x83\xe4\x95\xe9\x34\x0c\x5c\x6b\x4f\xee\xf9\x6c\xab\x36\x70\x8a\x9e\x17\xf1\x30\xfe\xc4\x3c\x2a\xeb\x07\xcb\xc8\x61\x43\xd9\xb9\x65\x6e\x4e\xec\xab\x1f\x42\xa5\xca\xc7\xc4\x31\xa7\xaa\x38\xc3\x87\x93\x60\x60\xc4\xe8\x11\x29\x75\x0d\x5d\xc1\x29\xe6\xd3\x4b\xf9\xd0\x3a\x86\xcc\x07\x72\xcd\x3b\xb3\xde\x80\x9e\x15\x91\x6f\x60\x11\x2f\x9e\xf2\xa2\x78\xed\xed\x84\x17\xe4\x23\xab\xb2\x2d\x43\xf4\xec\xfa\x6b\x97\x94\x6f\x57\x75\x35\xe1\x57\x33\xbc\x26\xd8\x6f\xbb\x2e\xd1\x78\x09\xcc\x40\x15\x67\xfc\x78\xc2\xeb\x34\xff\x69\x43\x7e\xa6\x5d\x39\xba\xef\x80\xe2\x90\x44\x92\x65\x4a\x70\x49\xa2\x5f\x3e\x47\x35\x3e\x22\xe5\x43\xdb\x04\x9a\x0c\x38\xa3\x7a\x72\xaf\x67\x47\x35\xf7\x69\x13\xd1\x33\x6a\x77\xe3\x24\x4e\x03\xbb\x3b\x47\xd1\x37\x25\x5f\x62\xa8\x2b\xf1\x23\xbf\x8b\x17\xf4\x7a\x41\x74\x8e\xda\xdf\xd1\x34\xbe\xbb\x16\xfd\x45\xd1\xbd\xf7\x14\xbc\x41\x83\x88\x82\xa0\xd6\x26\x56\xef\x67\x8b\xda\x66\x42\xcc\x6e\xb5\x6d\xa4\xe2\xc2\x32\x41\x36\x58\xd1\x6f\xdb\x8e\x69\x6d\x33\xe4\xdb\x36\x70\x20\x69\x5b\x33\xd1\xf3\xe6\x9f\x1b\x2f\x13\xfe\x2f\x78\x19\xff\x4b\x5e\x4c\x9e\x97\xbc\xdc\xe3\x61\x3d\xa5\xfd\xf1\xa2\x38\x32\x2f\xd3\x7f\xc9\x8b\xcd\xeb\x87\xcc\x2b\x81\x13\x4d\x3f\xa3\x1f\xe6\xff\x94\x17\xd5\x8f\x6f\x55\xfd\x30\x72\xf8\x52\x9d\x3d\x8a\x83\xcd\x27\x2c\x19\x0f\xf2\x94\x82\x7e\x90\x9d\x26\xdf\x64\xcb\xa3\x32\x73\xbd\x4d\x90\xf5\xe5\x73\x4d\x5f\xee\x24\x7b\x2b\x34\x5b\x45\xe8\x10\x31\x98\x66\x04\x22\x78\x13\xec\x08\x22\xcd\x88\xb4\x2c\x4d\x5d\xe1\xba\x93\x7e\x6d\x1b\xe4\x38\x53\x5b\xc7\xf8\x06\x42\xa4\xc2\xb5\xed\xd7\xf4\x6b\xdb\xc0\xeb\xcf\xd4\x2f\x33\x21\x73\x28\xac\x5f\x2f\x2f\x5c\xfb\x07\x1b\xf7\x81\x1c\x4b\x84\x42\x24\x87\x20\x1b\x20\x5c\x3e\x5c\x18\x7b\xd1\xb5\x7f\x6a\x17\xc7\x29\x38\x53\xc0\x2e\x12\xbd\xaf\xa9\x81\x76\x94\x9b\xca\xe3\x16\x57\x51\x0d\x50\xa2\x79\x4a\xb5\x92\xa7\x5c\xa3\xc6\xd5\xc0\xc3\xcb\x68\xab\xf2\x75\x7a\xfa\xcf\x6a\xf4\xef\x46\xc7\x94\x5a\x58\x0c\xc8\xc7\x0c\xda\xca\x7c\x5d\xbf\x6d\x00\x9b\xfb\x27\xd5\x27\x93\xca\x02\xc4\xd4\xe7\x96\xd8\xb0\xb9\x8f\x4e\xcc\xa0\x76\x70\x5c\xb1\xcd\xad\xac\x24\x3a\x51\xb5\xb4\xaa\xd4\x52\xe8\xc7\x8b\xf9\xf4\x32\xbf\xcf\xc7\x0c\x84\x8f\xa3\x27\xb7\x35\xeb\x70\x17\xef\xd1\x18\x48\xf7\x4a\xe4\x79\xe9\x6c\x2e\x29\x68\x82\x4f\xe8\xc9\x3d\x98\x2d\x8b\xe9\xd9\xf5\xd7\x2e\x89\x79\x41\x6d\x57\x2c\x46\xf8\xc5\x6b\xe2\xde\x7e\xda\x15\xa2\x36\x77\x9c\x62\x73\x87\xaa\xed\x22\xbb\x84\x58\x26\x35\x29\x15\xfb\x99\x76\xe5\x98\x77\xd4\x76\xd5\xd7\x2b\x7b\x4f\x48\x6e\xd8\xff\xde\x93\xa3\x1a\x2f\xd9\xee\x92\x1a\x76\x05\xe1\x54\x4f\x0a\x3a\xf5\x61\x8d\x59\x8b\xba\x4f\x4b\xa2\x36\xb7\x5a\xb1\xb9\x2b\x74\xba\x0c\x73\x41\x5e\x2c\x72\x21\x97\x15\x33\x09\xc6\x4f\x34\xdb\x1f\x90\x39\x17\xcf\xa9\x00\xb5\xc1\xe3\x14\x1b\xfc\x85\x4e\xcf\x0d\x8f\x33\x74\xaf\x89\x0c\x3b\x19\xe2\x29\x46\xac\x73\xa8\x6b\xdc\x6f\xd0\xfa\xc8\x59\xe9\x89\x34\x55\xc0\x26\xab\xc9\x86\xd9\x84\x3d\x80\xdd\x28\xe0\x08\x94\x07\x1a\x03\xe9\x00\xdf\x86\xe0\xef\xce\xc0\x9c\xc0\x92\xc0\xbd\x81\xbd\x81\x63\x01\x03\xf9\x25\xf9\x88\xfc\x73\x3f\xf9\xa0\x5c\x83\xb8\x09\xfe\x29\x76\x2f\x5d\x76\x56\x37\xd9\x57\xab\xea\xbd\x09\x02\xb3\xdf\x08\x66\x47\xa5\xb1\x49\xe6\x8b\xbf\x95\x3e\x41\xa3\xd3\x83\x68\xba\x81\x4d\x88\xf2\x8d\x04\xee\x09\x7c\x1c\xc8\x05\xb8\x49\xf0\x8d\x89\x04\x30\x02\x82\xeb\x29\x8f\x4f\x02\xc2\x4d\x1a\x3b\x7e\xe9\x32\xe0\xa0\xef\x83\x67\xa4\xd7\xf0\x65\xf9\xb5\x7b\xa3\x0b\x3f\x8a\xd4\xf5\xda\xe3\x45\xeb\xb5\x64\x6d\x77\x78\x7e\xed\x5e\x59\xdb\x05\x7b\x50\x54\x47\x9b\x0b\x36\xef\x3d\x5a\x67\x6d\x52\xc6\xe5\x11\x39\x9e\x2a\x25\x61\x67\x69\x99\xa1\x70\x8f\x17\x17\xa6\x36\x66\x8a\xd2\xf7\xaf\x68\x35\xf1\xef\xb3\x81\xa0\x7e\x2f\x54\xd1\x7a\x07\xf3\x06\x37\x58\x5b\x37\x00\x15\x8b\x9a\xa3\x09\x83\xbe\xb6\x28\xaf\x75\x98\x55\xda\x60\x63\xc6\x42\xdf\x41\xec\x45\x66\x27\x13\x26\xc1\x79\x38\x5a\xb4\x87\xad\x78\x4d\xe5\x27\xb6\x54\xd5\xfd\xaa\x2a\xe2\x1b\xaa\xe7\x57\x87\x0d\x85\x35\x53\xc2\xe7\x34\x3a\x37\xa7\x28\x76\xa0\x4d\xc5\x21\x3b\xdf\x58\x26\x7e\x76\xbc\xa4\xa8\xce\x5a\xcc\xa7\x97\xf2\xa1\xf3\x59\xe6\x13\xe9\xc9\xdd\x9e\x8d\x54\x14\xaf\x21\x25\x68\x9b\xf2\xbc\x78\xca\x8b\xe2\x25\x12\x84\x17\xe4\x1c\x77\x64\x43\xe5\x42\x11\x5e\x31\x3f\x29\xdf\xae\xa6\x26\xc2\x2f\x35\x34\x15\xef\xa7\x5d\x61\x6a\x07\xa6\x14\xc7\x5e\x64\xb1\x99\x65\x1a\x47\x35\x96\xff\x4c\xbb\x72\x79\x3e\x43\x87\xf2\x72\x51\x2a\xd9\x2f\x9f\xa3\x1a\x1f\x5d\xec\x15\x89\x10\x3e\x35\x3d\xb9\x7f\x66\x6b\x82\x7d\xda\x44\xf4\x4c\x64\x65\x5e\xd4\x0e\xbc\x8a\x78\x4d\xdf\x88\x4f\xa4\x31\x79\x05\xaa\x28\x05\x8e\x6c\x25\xd1\xbe\xca\x2a\x03\x2a\xb6\x03\x54\x07\xa9\x1d\x98\xa2\xd8\x81\x4f\x74\xba\x48\xe8\x94\x96\xca\xfb\xab\x02\x20\x02\x5b\x41\x34\xb3\x22\x26\xf4\xa1\x03\x6d\x17\x1e\x25\xb1\x0f\x9e\xa7\xd4\x8a\xda\xa8\x1f\x64\xea\xea\x40\x8c\xaa\x9e\xdc\x5b\xd9\xaa\x5a\x83\xb7\x40\xdf\xa0\xed\x3c\x4b\xea\x45\xf8\x6c\x65\x2d\xec\x1c\x19\x87\xea\x28\xb0\xfa\x53\xb6\x22\x21\x38\x8b\x75\xb4\x80\x4f\xaf\xba\xe6\x46\xf9\x54\xf7\xe4\xce\xce\x56\xd7\xfd\x0c\x9f\x51\x68\x97\x8e\x4f\xac\x27\x37\x34\x1b\xab\xec\x8f\x0f\x19\x4b\x99\x8f\x32\xdf\x00\xa7\xa5\x05\xf8\x80\x69\xde\x91\xad\x6f\xec\x8f\x0f\x99\x73\x32\x9f\xfc\x9c\xa3\x2b\x0e\xd0\x07\xd7\x67\xab\xea\xfa\xe5\x23\xa8\x7c\xc0\x65\xbc\x21\xe7\xb6\x49\x60\x93\xec\xc9\x6d\xc9\x26\x87\xaa\x6c\x5a\xb4\xb6\x3c\xab\xf1\xb8\x9b\xd4\x46\x09\x3c\x59\x3d\xac\xed\xc9\xdd\x96\xad\x1d\xa4\xb2\x68\x91\xf5\x44\x78\x94\xd8\x23\x85\xbe\x66\x8f\x40\x9c\x4d\xd9\xaa\x1a\x85\xb6\xaa\x0b\x3c\x4b\xec\x91\x4c\x5b\xdb\xe7\x45\x86\xe2\x9a\x6c\x45\x5c\xa1\xab\xd4\xad\x5f\xd3\xd7\xad\x81\xee\x45\x48\x5d\xa3\xfb\x2e\xeb\xf5\x17\xd6\xad\x5f\xd3\xd7\xad\x81\xee\x43\x48\xdd\x47\xf0\x3e\xd8\xc4\x93\xd4\xad\xa1\x0f\x0f\xc9\xf1\x14\xf1\xd8\xca\x86\xb3\x32\x85\xb8\xda\x87\x72\xbd\xd8\xac\xd5\xc5\xd5\x7e\xc7\x64\x49\x15\x47\x49\x81\x26\x9a\x08\x16\xae\x5f\x02\x1f\x61\x3d\xd5\xa3\xa5\x8a\xbe\xfa\x65\x3e\xf1\x38\xf0\x81\x50\xf4\xfe\x6c\x79\x8c\xf7\x17\xf3\xe1\x4b\xa9\x1e\x2d\x53\xf4\xf5\x3a\x19\xa7\xae\x0e\xf8\x54\x11\x7d\xad\xaa\x4d\xb8\x4e\xca\xa7\x17\x9f\xa1\xe3\x03\xb2\x19\xb3\xd1\xf8\xcf\xf0\x19\x45\x56\x5b\x35\x3e\xd5\x3d\xd2\xf7\xa0\xe3\xfd\xf1\xa1\xfa\xba\x54\xe9\x83\x9f\x64\x1c\xba\x64\x95\xe8\xc9\x75\x67\x13\x35\xfd\xf1\xa1\xfa\xba\xac\xb0\xdf\x5a\x5a\xc8\x72\x55\x4f\xee\x5c\xd0\xf1\x7e\xf9\x08\x2a\x1f\xd0\xd7\x87\xe4\x1a\x38\x24\xb1\x20\x5a\x6e\x41\xb6\xba\x59\x65\xd3\xa2\xb5\xe5\x59\x8d\x87\x1c\x8b\x02\x3c\xd9\xb1\x03\xfa\xbd\x18\xf4\x5b\x65\xd1\x22\xeb\x95\xb0\x9e\xe8\x95\x42\xdf\xc5\x2e\x94\x75\x05\x86\x64\x34\xd9\x87\xee\x2f\xd0\x2b\xbe\x94\xe8\x95\x4c\x1b\xf4\x4a\xf1\xdf\x30\x14\x63\x40\xb7\x13\xba\xfd\xa7\x72\x0d\xf2\x98\x5a\x83\x84\x71\xa8\x90\xfb\xc7\x68\x24\x21\x4c\x4f\x6e\x5f\xd6\x64\xe5\x0c\x05\x6d\x95\xeb\x90\x07\x95\x5a\x95\x80\x46\x2d\xa0\x18\x74\x81\x3b\x40\x42\xce\x40\xa8\xa0\x0e\x39\x40\x9b\x13\xc3\x14\xd9\x4f\x91\x6b\x79\x10\xa9\xa8\x15\x4e\x8d\x2e\x9d\x0f\x40\xd7\x41\xe0\xf6\xe7\x65\xa4\xba\x3f\x4c\x19\x8f\x17\xb4\xba\x33\xd9\x00\xc4\xdb\xdd\x7d\xeb\xa4\x54\xef\xcf\x54\xe0\xbd\x30\x7e\x04\x9e\x18\x36\x1c\xe6\xc2\xd1\x42\xf9\x28\x7d\x41\x93\x8f\xc1\xe7\xeb\xd7\x3b\x2c\xae\x32\xae\x60\xbd\x43\x6e\xff\xb3\x1a\xfd\xbb\xd1\xcb\x0a\x3c\x04\x87\xb8\xdc\x5d\x5e\x6f\x2c\xc8\x23\x88\x2f\x3b\x47\x68\x74\x55\xb2\xd4\x7e\x88\xb7\xa0\x0f\xd1\x7c\x62\x9b\xea\x9d\xd4\x64\xbe\x97\xad\xaf\x16\x1c\x05\xb6\xac\x00\xfe\x00\x7a\x0b\xe0\xc1\x5e\x92\xed\x56\xcc\x40\xb2\x69\x6f\x60\xbd\xe0\x28\xb6\xb1\x05\x38\x3b\x28\x0f\x12\x33\xd3\xe8\xbc\x89\x1c\x80\x68\x52\xb8\xe8\xf7\x7d\xe8\x71\x76\xa3\x57\x01\x87\xfa\xd8\x54\x8a\x60\xb5\x92\x7d\x87\xad\x79\x2c\xdd\x9e\x15\x3d\xde\x7d\x38\x40\xe4\x23\x7b\x84\x64\x66\xe6\xa6\x1a\xa1\x68\x0d\xad\x18\x67\x0f\xc5\xa1\x31\x80\xc2\xcb\xdc\x5a\xa3\x67\xa4\xe2\x88\xf5\x1a\xce\x4e\xf4\x07\x34\x46\x96\xef\xd4\x53\x69\xac\x41\xea\x2f\x8d\xc3\xfb\x95\x4f\xac\xd0\xf0\xf6\x02\xde\x30\x19\x6f\xcc\x98\x93\xe0\xd1\x1a\x00\x8d\x65\x49\x0d\x40\x10\x6f\x01\x33\x26\x3e\xc6\x38\x11\x6a\xef\xf7\xf7\x07\x6e\x2d\xfc\x7d\x2d\x42\xc2\xe5\xfc\x01\x47\x15\x8a\xe3\x7a\x0a\x41\xd6\x60\x8c\x8f\xb3\x8c\x8f\x80\x9c\x00\x66\xf7\x7f\x00\x73\x9f\x02\xe3\x3c\x09\xcc\x9e\x3e\x30\xed\x04\x46\xf8\x5c\x07\xb3\xb3\x53\x86\x69\x3e\x09\xcc\xde\x3e\x30\x63\xc0\x8f\x2c\xa4\x63\x77\x9e\xa2\xbf\xd7\xc0\xd8\x11\x7d\xaf\x27\xf6\x50\xa8\xaf\x36\x71\x7a\x7d\x2f\x86\x3f\x80\x6e\x25\xfa\xae\xee\x17\x1c\x68\x19\x58\xaf\x22\xd0\xf9\x57\x08\x0f\xbd\x36\x7f\x3e\x3d\x25\xd0\x44\xf7\x23\xf4\xe4\xfe\x0f\x34\x57\x46\xc8\xeb\x53\x31\xce\xee\xf9\xf3\xd5\xdd\x0f\x04\xab\x95\x60\xb5\xe6\xb1\xb4\x75\xea\x62\xd9\xee\x43\x37\xc8\xba\xab\xb2\xe3\x9b\x6a\x4e\xce\x0b\x74\x97\xe2\xd0\x7c\x59\xe1\xc6\xb7\xd6\xe8\x59\x01\x8e\x1d\x74\xe5\x15\x3a\x3e\xd5\x30\xab\x68\xaf\xe5\x48\xd4\x2b\x3e\x86\x2d\xaa\xbe\x18\xfa\xc0\x1c\xe8\x03\x13\x80\x7f\xce\x90\x61\x98\x99\x72\xef\x7c\x4d\xc6\x87\xc1\xf9\x71\xee\x0b\xb3\xfb\x3f\x80\xb9\x4f\x81\xb1\x9c\x04\x66\x4f\x1f\x98\x85\xd2\x4c\xf6\x6b\xda\x17\x0b\x14\x5d\xf8\x54\xd1\x05\x88\xca\x71\xc4\x16\x09\x59\xf5\x6b\x9f\x7d\xe0\x0f\xa0\xaf\x14\x5d\x20\xa7\x36\x70\xdc\x15\x8f\x58\x75\x6b\x8c\x7d\xe0\x77\x50\x9b\x44\xb4\x21\x41\x7a\x1a\x1c\xf6\xa1\x6c\x42\xe1\xa1\xda\xb1\x62\x1c\xcd\x8e\x31\xd4\xe0\x33\xb8\x96\x60\xd5\xe6\xb1\x9c\xfd\xb7\xe5\x3e\x3c\x48\xd5\x05\x99\xd9\xac\x44\xa9\x8e\x53\xbf\xed\xd9\x03\x4e\x4c\xd1\x05\x85\x57\xb2\xb6\xd4\x5a\xb0\x36\x2b\xe3\x50\x7b\xb4\x40\xb1\x63\x9f\x82\x3d\xa2\x38\x83\x07\x13\x9c\x98\x39\xd6\xf8\x33\x38\x7b\xa1\xdf\x14\x1c\x52\x7b\x06\x1c\x5f\x1f\x1c\xa2\x73\x87\xe8\xf8\xd5\x9d\x54\xe7\x0a\x61\xfa\xd7\xb9\x95\x32\xcc\x09\x75\xae\xb6\x0f\x8c\x6c\xc7\x8a\x75\xae\x10\xa6\x7f\x9d\x2b\x84\xe9\xa3\x73\xb9\xe3\x04\x86\xda\x28\x15\x66\xa7\x59\x86\x49\x9e\x04\x66\x6f\x31\x0c\x02\x73\x8e\x6f\xa4\x63\x77\x81\x6c\xdf\xb7\x13\x2f\x8c\xc9\x62\xb0\x9d\x9c\x9c\xb2\x9b\xb9\x82\xbd\x70\xc5\xf0\x07\xb6\xcf\xd7\x56\x43\x3d\x3d\xb9\x83\x59\x8f\x9d\xd3\xad\x9f\x92\xb7\x2d\xf1\xbf\x74\xf0\x3b\xae\x93\x35\x97\xae\xbf\x7b\x89\xcf\xf1\x2a\x1c\x34\x7d\xea\x83\xb3\xfb\x3a\x45\x73\x7d\x3e\xa7\xbc\xca\xf8\x7a\x36\x98\xc7\xd2\xec\x18\x8b\x10\x33\x59\x87\x77\xdf\xfb\x8a\xe6\xca\xcc\x22\x5e\x8b\x8e\x53\x3f\xf0\x7b\xde\x57\xb4\x56\xe1\x13\x09\x5a\x0a\x99\x80\x6c\x37\x00\x4e\x46\x3c\x4d\xc3\xd9\xb9\x5d\x91\x8d\x6e\x97\x24\xa7\xa9\x0e\x65\xdd\xe5\x7d\x64\xeb\x83\xb7\x57\xc5\xa3\x65\xdc\x13\xe2\x11\xfd\x65\x46\x53\x5d\xa8\x2f\xd6\x5f\x4e\xa7\xbf\x45\x30\x07\xfa\xc0\x80\x4e\xb1\xef\xca\x30\x45\xfa\x6b\xd4\xeb\x5d\x11\xcc\xee\xff\x00\x46\xd5\x5f\xee\x24\x30\x7b\x8a\x61\x88\x6e\xb2\xef\x52\xdd\xac\x2f\xd2\xdf\xaa\x93\xc0\xec\x2d\x86\x51\x6a\x22\x8d\x6a\x4d\x04\x6c\xef\x5f\xe4\x38\x92\x54\x22\x4a\x49\xe9\xaa\x34\xa0\x96\xae\x5a\xfa\x81\x3f\x40\xe1\x21\x8e\x0c\x87\x01\x21\x4a\x4a\x16\xd1\xd2\xbe\xe7\x35\x0b\x70\x54\xfb\xab\xd4\x5e\x21\xe3\xfd\x20\x5b\x11\x10\xfa\xd9\x3f\x9c\xc7\xd1\xc5\x91\x72\xad\xab\x8a\x60\x55\x05\x8a\x6b\x35\xc5\x78\xba\x38\x52\x66\x96\xac\x28\x11\xfa\xdd\x6b\x9e\xc7\xd1\xc5\x91\x0a\xaf\x64\x55\x71\x5d\xcd\x0e\xb9\xd9\x50\x18\xa3\x4a\xd4\x34\x5f\xaf\x55\x4c\x88\x6a\x8c\xbc\x7f\xae\x08\x46\xd5\x2a\x26\x91\x87\x09\xe4\x8e\x88\x6f\xd0\xb1\x6e\x22\xbb\x0c\x34\xbd\x62\x99\xba\xbc\x3e\xf4\x81\xd9\xdd\x2f\xcc\x79\x0a\xcc\x4d\x3a\xbd\x3a\x39\xcc\x9e\x3e\x30\x24\xbf\x97\xe8\x9c\x5e\xa1\xe8\xc3\x7b\x54\x1f\x70\xc8\x49\xb7\x3b\x7d\x9d\x0d\xf9\x45\x54\x90\x73\x16\xc0\x1f\x80\xb8\x98\x5a\x34\x52\xca\x22\x89\xe4\xa7\xd9\xf2\x50\xd1\x9e\xe9\x62\x9c\xbc\x3f\x8e\x92\xb9\x0c\x4a\xf4\xc7\x6c\x54\xe1\xa2\xea\x43\x31\x8e\xce\x1f\x57\x54\x10\xac\x4a\x82\x55\x99\xc7\x72\xf6\xdf\x9e\xfb\x20\x22\x55\xac\x9a\xcc\x6c\x68\x34\x20\x16\xe9\x43\x31\xce\x1e\x8a\x43\x2d\x9b\xc2\x6b\x68\x65\x40\x2c\xd4\x07\x8a\x43\x7d\xeb\x0a\xc5\x1f\xbf\x27\xe7\x07\xea\x7e\xdb\x08\xf1\x06\x91\xfa\x7e\xe5\xd3\xe1\x69\x79\x05\x43\x2b\x03\x14\xef\xf3\x7e\xf0\xc0\x66\x09\xd3\xe9\x58\x0e\xa3\x31\xb6\xce\x66\xb9\xf5\x3e\x77\x83\x0c\x53\x64\x8f\x4a\x0a\x7c\xe5\x67\x0a\xcc\x33\x05\xb6\x46\x83\xc9\x1d\x25\x74\xa8\x1d\x51\xe9\xec\x55\xfc\x72\x85\x46\x67\x6a\xee\x08\x7f\x98\xf6\xd9\x1a\x59\x6f\xf0\x8b\xb2\xde\x34\x82\x1a\x34\x92\x33\x2c\x8d\xf5\x21\x5b\x5e\x6f\x8a\xe1\x0f\xe0\xdd\xb2\xde\x90\xe5\x45\xb2\xd1\xf8\xaf\xd9\x96\x46\x15\x41\xdd\x97\x53\x84\xb3\x83\xf2\x20\x7a\x43\x96\xb0\xf1\x20\xb2\x3b\x65\x90\xc2\x45\xd5\x9b\x62\x9c\xdd\x14\x87\xf6\x6f\x6b\x2b\xc1\x1a\x4a\xb0\x86\xe6\xb1\x9c\xfd\xb7\xe7\x3e\x98\x79\x8a\xde\xc8\xcc\x2a\x07\x0d\xd0\x71\xea\x57\xbe\x3d\x14\x47\xd9\xa7\x4d\x79\x55\x0e\x1d\xa0\x67\xa4\xe2\x50\xbf\x26\xe3\xec\xcc\xcb\x47\xf6\x1d\x80\xf6\x90\x6a\x72\xf3\xc8\x7e\xe5\xd3\xe1\xed\xa5\xfd\x47\xf1\x4e\x3b\x4d\xc1\xfb\xac\x1f\x3c\xf0\x87\x82\x48\x6c\x12\x3b\xab\xc0\x6e\xe1\x06\x9d\xdd\x2a\x82\x39\xd0\x0f\x0c\xd1\x9b\xdb\x88\xde\xb0\xb3\x0a\xec\x16\x30\x2e\xd0\xad\x42\x98\xdd\xfd\xc2\xa4\x14\x98\x9b\x0a\xfc\xe1\xc9\x60\xf6\x14\xc3\xe4\xbe\x20\x30\x44\x47\x35\x98\x9d\xc7\x65\x98\xb1\x27\x81\xd9\x5b\x0c\xa3\xd4\x14\x44\x2d\xcf\xdf\xaf\xd4\x03\x99\x7a\x52\x58\xa9\xe9\xc9\xad\xcf\xd6\xf4\x5f\x27\xd1\x70\xd8\x36\x7a\x3e\x40\xc5\xa9\x26\x35\xd1\xea\xba\x22\x1c\x39\xff\x13\xb5\x5c\x73\xff\x40\x5a\xef\x22\x18\x18\xb8\xec\x06\x2e\xfd\xe4\xb3\x2a\x3c\xf0\x40\x3b\x95\x7a\x15\x45\xa9\xae\xa8\xae\x2b\x80\x97\x73\x0a\x51\x8b\xf5\xf7\xa3\x07\xe5\x1a\x1c\x59\xe9\x20\xc5\xe0\x77\xb2\xa5\xba\x2c\x49\x97\x87\x68\x38\xd0\x8e\x98\xc2\x83\x22\x85\x26\x86\xca\x0a\xf2\x2a\x07\x8d\x65\x45\x25\x26\x03\x1e\xb9\x53\x51\x7e\x2f\xa4\xa5\x27\xb7\x39\x6b\xd1\x45\xb3\x5a\xfc\xbb\x43\xc3\x11\xd8\xb6\xfd\x48\xd9\x6d\x09\x28\x66\x8b\xd9\x56\x04\x2f\xfb\x66\x51\xf3\xcd\xfb\xd1\x3d\x72\xdf\xd2\xa5\x92\x92\x9e\xdc\x6f\xb2\x25\xfd\xc7\x1b\x1a\x0e\xb4\xc3\xac\xac\xdf\x51\xa4\x40\x75\x20\x54\x70\x36\x40\xb6\xf7\xa2\x62\x83\x61\x2c\xd6\x29\xbb\x0a\xe4\xda\xe3\xad\xd9\x80\xce\x83\xf5\x81\x27\x63\xd1\xab\xf4\x13\x45\xf1\xbb\xfc\xc1\x02\x78\xd9\x2e\x88\xda\x5c\xdd\x4f\xf7\x7f\x02\x07\xb2\x56\x81\x07\xf4\xe4\x1e\xc8\x0e\xe8\xdf\xd6\x69\x38\x6c\x1b\xe3\x56\x78\x50\xa4\xfa\x09\xf5\xc9\x3c\x06\x5d\x4f\xe8\xca\xd7\xc2\x1c\x55\xe0\xb7\xc1\x3f\x02\x9e\xc8\x94\xca\x6b\x16\x27\xaa\x0b\x16\xe1\x1d\x40\x4f\xeb\xf0\x7e\xa6\x3e\x58\x84\xbb\xa3\x80\xe7\xcf\xd4\x09\x8b\x70\x77\x17\xe0\xfe\x07\xf5\xc2\x22\xfc\xfb\xc0\xed\xe9\xe4\x3e\x79\xdd\xb0\x08\x77\x4f\x01\xee\xcf\xd4\x0f\x09\xae\x5a\x07\x04\xdc\x9d\x20\xf7\xb0\x42\xb9\x4f\x5e\x47\x2c\xc2\xdf\xdb\x17\xff\xe4\xf5\x44\x7a\xd7\x8d\x52\x2f\x74\x54\x42\xbe\x89\x28\xf6\xa3\xa8\xa8\xae\x58\x04\x77\xe0\x04\x70\xb5\x52\x97\xbe\xe6\x07\x90\x3b\xa8\xbe\x89\xec\xfb\x7d\x6b\x88\x7d\x60\x77\xff\x3f\xc0\xde\x57\x04\xeb\x3c\x09\xec\x9e\x13\xc2\xb6\x13\xd8\x7c\x6d\x11\x60\x77\x76\x16\xc2\x36\x9f\x04\x76\xef\x09\x61\x17\x92\xf3\xac\x6a\x0d\x86\xce\x9f\x4f\x65\x9d\xa0\xe7\xb4\x4f\x56\x8b\x2a\xc4\xa3\xb5\x28\x0d\xef\x64\x35\xa9\x42\x3c\x6d\xee\x50\xbc\x9f\xab\x4d\x15\xe2\xee\x2e\xc0\xfd\x4f\x6a\x54\x85\xf8\xb4\x46\xa5\xe1\xff\x5c\xad\xaa\x10\x77\x4f\x01\xee\xcf\xd5\xac\x00\x97\xc6\x2c\x0b\x94\xb9\xf3\x69\x31\xee\x49\x6a\x57\x85\xb8\x7b\x0b\xfa\xf9\x67\x6a\x58\x30\x17\x74\xf5\x29\x32\xba\x24\xa2\xa1\x9a\xf0\x48\x71\x2d\xab\x0f\xec\x81\x13\xc2\x06\xa4\x2e\x7d\x9d\x89\xcc\x9d\xaf\x29\x24\x3f\xac\x6f\xdd\xaa\x0f\xec\xee\xff\x07\xd8\xfb\x8a\x60\x2d\x27\x81\xdd\x73\x22\xd8\xdc\x47\x04\x36\x5f\xcf\x22\x73\xa7\x08\x36\x71\x12\xd8\xbd\x27\x82\x45\x53\xa1\xcf\xb4\xb8\x97\xf4\x2e\x89\x61\x69\x8f\x95\xcb\xeb\x8f\x27\xca\x01\x8a\xf0\x68\x0e\xf0\x5f\xe0\xed\x28\xe0\xf7\x33\xf9\x40\x11\xee\xee\x02\xdc\xff\x20\x2f\x28\xc2\xa7\x79\x81\x86\xff\x33\xf9\x41\x11\xee\x9e\x02\xdc\x9f\xc9\x13\x08\x2e\xf5\x1b\x32\x2e\xc9\x13\x86\x15\xca\x7d\xf2\x7c\xa1\x08\x9f\xe4\x0b\x45\xf8\x27\xcf\x1b\xc0\x96\x6a\x39\x41\xc1\x0c\x9a\xd3\x37\x7f\x28\x82\x3d\x70\x12\x58\xa2\xbf\xba\x1c\x21\x3f\x87\xb8\x63\xa8\x4f\x1e\xd0\x07\x76\xf7\x49\x61\x75\x39\x43\x7e\x0e\x71\x37\xfc\x07\xb0\x7b\x4e\x04\x9b\xfb\x82\xc0\xe6\x73\x08\x32\x87\x8e\x17\xc2\x8e\x3d\x09\xec\xde\x13\xc1\xca\x39\x04\xd9\x77\x2b\xe7\x10\xcc\x9d\x74\xed\x1e\xe2\x2f\x72\x6f\x1c\xd9\x6c\xf2\x6c\xb6\xb6\xb1\xbf\xbc\x83\x9c\xab\x56\x70\x36\x92\x33\x84\x04\x87\xd6\x52\x21\x8b\x78\x39\x5b\x53\xdb\x6f\xcc\xa6\xe4\x2a\x20\xd1\xfe\xcb\x91\x3e\xda\xeb\x3f\xcb\x51\xf1\xc8\x7e\x15\x25\xc7\x91\x31\xe4\xb3\x0b\x5f\x64\x9b\x06\x08\x0e\xfd\xde\x16\x3d\x8f\x2a\x88\xbf\xed\xa8\x2f\x97\xfe\xf3\x22\xb9\x4d\xcf\x6a\x6d\xba\x1b\xfd\x41\x8e\x5f\xc9\xb6\x9e\x46\xd2\xa4\xc6\x61\x7d\xe2\x57\x15\x9e\x9e\xa3\xfc\x83\x8e\xd7\x89\xf1\xe8\xba\xab\xba\x5f\xda\x29\xca\xfb\xa5\x69\x8e\xa0\xed\x93\x2e\x38\x5f\x21\xc3\xdf\xa5\x9d\xc7\xd8\x88\xcf\x97\xef\xa0\x62\x5c\x2e\x72\x39\x00\xe3\xf6\xf4\x03\x2f\xaa\xf0\x90\x1b\x2d\x90\x23\x2f\x4f\x5e\xf7\x0b\x61\x20\x17\xba\x5e\x07\x91\xeb\x73\xaf\x21\xb4\x69\x0f\xdd\xe3\xc0\x94\x36\x94\xfa\xb5\x83\x25\x18\x7d\xcb\x5d\x8d\x9f\xe3\x0f\x20\x13\x2a\x4f\x5b\xc9\x62\x8c\xd1\x68\x31\x1b\x8d\x68\x3d\x8f\x92\xc1\x03\x6d\x49\xe5\xd6\x6d\x7a\x1b\x30\x79\x1b\x2e\x36\x02\xb7\xc4\x5a\xf0\x73\x91\x01\xeb\x06\x34\x74\xf1\x07\x3a\xba\x2e\x6a\x49\x9d\x1e\x7b\x00\x68\x61\x8f\xd4\x85\xbf\xcb\x6d\x40\x16\x72\xb7\xa4\xc5\x6c\xe6\xad\x36\xd6\xbc\xde\x10\x42\xed\xc1\x37\xdb\xb4\x37\x18\x78\xdd\xa5\xbb\x29\x7c\xbb\x37\x60\x8b\xd6\x57\x6e\xba\xea\xa7\xa8\x5f\x58\x62\xbe\xfd\x96\xfe\x64\x32\x99\xcc\x96\xff\x4e\xa6\xdc\x17\xdc\xaf\x99\x27\xf8\x67\x91\x9f\xec\x91\xf3\x78\xbd\x25\x06\xa3\x31\xc0\xbb\x3c\xd6\xf5\x06\x72\xe7\x25\xbd\x49\x55\xbe\xf0\x58\xb9\xb6\xb9\x81\x21\x8f\x9d\xc5\x46\x30\xa9\xa6\x32\xf8\x6a\x4d\xd9\x30\x3e\x52\x3b\x6d\xe2\xd8\x48\xeb\x20\xe3\x2c\x73\xe3\xe4\xf6\xfa\x69\x13\x4f\x2d\x9b\xef\x3c\xd3\x39\x9f\xfb\x75\x62\x40\x62\x44\xdb\xb9\x0b\x86\xc3\xf7\x15\x5b\x56\x22\x16\x39\xb9\x97\x98\x6d\xc2\x7e\xf8\x49\xa4\x6f\x18\x04\x1d\x02\x8f\x19\x9e\x71\x86\x4a\x9d\xa5\xe5\xd1\x12\x6b\xc8\xb3\xde\x61\x30\x40\x96\xcf\xa1\x64\xea\xcd\xa6\x26\xe5\x36\xd7\xc2\xeb\x7f\xc9\xdd\xbf\xca\xa5\xae\x6e\x4d\x22\xac\x49\xc4\xe0\xe7\x77\xf6\x7e\xfe\xc0\xbf\x2a\x4f\x1f\x33\xb2\x34\xd5\x68\x98\x6a\xed\x9e\x58\x7d\xfa\x98\x74\x68\x96\x7d\xaa\xa5\x76\x1c\xf7\x72\x4f\x0f\x86\xff\x4d\x15\xd5\x15\x83\x9b\x37\x2c\x83\x6f\x17\xce\x3e\x6b\x90\x2e\x06\x13\xb5\x58\x88\xe6\xf6\xf9\xf8\x4d\xc9\xf1\x43\x64\x62\x86\xfa\xe6\xf8\xca\xbd\x2d\x14\x57\xc1\xe9\x4b\x53\xce\xfd\x4f\x40\xb3\xac\xbf\xba\x01\x9d\x83\x0b\x94\x39\x7b\x50\x89\x99\x63\x80\x43\x6e\x77\xe9\x27\x66\x56\xe1\xe9\x9c\x3d\xa8\xe3\x75\x62\xbc\x0a\x84\x84\x5a\x41\x24\x6b\xc9\x4a\xcd\x73\x7f\xae\x0b\x30\xbc\x59\x30\x30\xe4\x2c\xe1\xb2\xac\xd3\x89\x31\x45\x51\xe7\xd8\x29\xc5\x38\x6c\x5b\xee\x12\xd9\x0b\xd9\xd5\x79\x46\xe8\x9e\x4e\x61\xea\x0a\xe8\xea\x61\x4e\x29\x86\xe9\x87\x4e\xfe\xfe\x9c\x3a\x65\xbe\x1e\x94\xf7\x24\xf9\x6b\xfd\x2e\xed\x92\x2b\x06\xd5\x72\x57\x33\x17\xc1\xdc\xe0\x91\x03\x35\xa5\x7d\x36\x41\x30\xdb\x59\x64\x47\x4e\x97\xdd\x6e\xe2\x38\x87\x69\x3d\xc3\x98\x40\xb3\x92\x41\xc7\x01\x72\xe9\x70\xfe\x7d\x4f\x65\xbe\xc4\xd8\x96\x54\x34\x3f\x6b\x98\x8b\x96\x3d\xfb\xb9\xf4\x8e\x3c\x75\xb8\x47\x2c\xb8\xcc\x96\x9f\x3e\x0a\xbf\x95\x79\x7e\x1c\x43\x39\x32\x76\x97\xd3\x6e\x37\x43\xbb\xcc\xeb\x39\xce\xdc\x0f\x3f\xe5\x9d\x18\x9c\xf2\xb2\xb1\x16\x56\x37\x4b\x6f\xf9\xfc\xd9\x65\xd3\xd4\x99\x6a\x93\x3e\xb5\xe0\xf2\x3c\x43\x26\x77\x94\x5b\xc3\x3c\x23\x7c\x8e\x02\x28\x86\x26\xa6\xab\xa2\xc1\x60\x59\x2c\x16\x4f\x78\x7d\xbe\x04\xcc\xdc\x78\x34\xec\xf5\xf2\x56\x72\xe7\xbd\xd5\xea\x42\x06\x98\xc3\xf6\x18\x8e\x85\xc9\xbd\xb9\x30\x93\x92\xc0\x37\x59\x07\x5f\xce\xfc\x9c\x76\xba\x34\x5b\x51\x3c\xb7\x07\x91\xc9\x2d\xea\x64\xfb\x26\x3f\xcf\x93\x53\xda\xeb\xa7\x77\x8e\x2d\x1b\xd4\x64\x38\xd3\x71\xf6\x16\x45\xe0\xaf\xc3\xf1\x70\x73\xdb\xdc\xb3\xdb\x22\x89\x48\xcb\xe0\xeb\x2f\xaa\xcf\x8b\x0e\x3e\x7b\x2b\x34\xa0\x91\xfa\x61\x5a\x9f\x62\xee\x7c\x8a\x6a\xbf\xc9\x24\x9f\xee\xfd\xbf\xac\xd5\x5d\xb0\x3e\xfb\x36\x18\xa8\xef\xa8\x0f\x96\xe1\x37\xde\x45\xe1\xcd\x66\xb9\x02\xf6\x5e\xd6\x62\x2d\x80\x7f\x0d\xe0\xbf\x27\xf7\xe2\x10\x78\x72\x6f\xdc\x5d\xb2\xbe\x55\x82\xbf\x1f\x93\x4e\xb1\x6f\x7b\x30\x13\xf1\x24\x3d\x93\x3c\x8b\x3d\x9c\xdd\xd3\xee\xd9\xe3\x79\xde\xc3\xa5\x3d\x9d\x9e\x39\x9e\x25\x9e\xf5\x1e\xde\x43\xee\xa5\x23\x05\x02\x6c\x43\x36\x2b\x47\xaf\x03\x53\xe2\x34\x72\xda\x7e\x76\xb7\xbc\xce\x0a\xb9\x0b\xfe\xa7\x9e\xcf\x36\x59\x67\x3f\xfd\xff\x99\xcf\x0a\xba\x76\xfa\xac\xd6\xfe\xbb\x37\xd1\xc8\x9d\x9c\x19\x70\x93\x15\x19\x77\xa4\x60\xfd\x3b\x77\x1f\xc0\xd7\x0b\xfb\xb5\x75\xdc\xad\x37\xab\x37\x15\x28\xdc\xc0\xc4\x7c\x98\x0d\x55\x2a\x2b\xb9\x32\x43\x65\x0d\xf8\x75\xc0\x9d\x2f\x76\xaa\x67\x08\x98\x3b\x73\x5f\xe1\x85\xa4\xb7\x39\x8e\xaf\xc4\x22\x39\xf0\x2b\x2a\x37\xf5\x69\xb6\x09\xb2\x1f\x66\x20\xbd\xcf\x4d\xc6\xd9\x98\x7b\x1f\x4f\xa4\x79\x39\xb9\xb8\x16\x0b\x8c\x76\xfb\x9a\xec\xb7\x21\x1a\x66\x1e\xa2\xf3\xbc\x5e\xb3\x05\xd3\xe5\x79\x2e\xaa\xf3\xbc\xab\x08\x46\xf5\xdc\x0a\x44\x9f\x39\xde\x98\xf6\x72\xd8\x20\x08\x0e\xec\x70\x01\x41\x0b\xcf\x0b\x16\x98\xe2\x96\x7e\xa6\x9c\x32\xe3\x94\x19\x1e\xf3\xf8\xfc\xb1\x06\x3c\x1c\xcb\x33\xfc\x40\x57\x03\xa8\x70\x44\x9e\xe1\x0f\xc4\x4e\x4f\x0d\xba\x68\x46\x47\xd1\xfc\x26\xbc\x18\xc2\x8b\x91\x79\xc1\xf4\xb6\xac\x67\xd9\x93\xf0\x52\x66\xb7\xc6\x8b\xce\xee\x99\x32\x2b\x75\x76\x6b\xcc\x50\xf1\xfc\xae\x49\x7b\xfb\x9b\xcd\x11\x72\x7b\xb6\x7e\x36\x9f\x78\xea\xe6\x19\x9f\x70\xea\xde\xae\x48\xd3\x67\xea\xea\xe4\x52\xeb\xb2\x74\xee\xae\x50\x62\xe8\xef\x64\xdf\x45\xf6\x23\x90\xbb\x48\x3e\xca\x96\x44\xfa\x5b\x8b\xa4\xf3\x77\x85\x12\x43\x7f\x8c\x0a\x76\x9e\xfe\x2d\x1b\x28\xe9\x77\xfd\xf2\x5f\x32\x0e\x68\xc1\x42\x65\xd7\xc0\x7e\x74\xa6\x3a\xbb\xa2\x30\xbb\xa2\xc9\xe8\xa4\xe8\xe2\x28\x67\x8f\xb6\x47\xf7\x44\x9f\x8f\x72\xe9\x68\x67\x74\x4e\x74\x49\x74\x7d\x94\x8f\xca\x9b\x24\x40\xdf\x83\x28\x58\x22\xd8\xfb\xce\xae\x13\xf3\x01\xdf\xcc\xfd\xff\xca\x87\xdc\x61\x35\x94\xe6\xa5\xcb\x95\xb5\x3b\x4e\xde\x03\x10\x87\xd8\x39\x4e\xf6\x00\xc4\xcb\x2d\xba\x35\xdf\x62\xf8\x03\xe8\xb8\xbc\x07\x80\x9c\x0c\x21\xd9\xc3\x91\x6c\x4d\xdc\xd2\x5f\x3f\x3f\xab\xf5\x33\xbd\xef\x84\x58\x0a\x5a\x56\x23\xf7\xdd\x46\xea\xfa\xae\x2b\xef\xd7\xd6\x45\xb7\xd2\xfb\x0f\xe4\x7b\x39\xc9\x56\x03\x96\x6c\x62\xa8\x6a\x12\xf5\x2d\xd2\xf6\xdd\xd2\xb8\x7e\x98\x12\xd7\x2f\x43\xf9\xbd\xc7\x16\x52\x4c\xb0\x78\x8a\xf6\x1e\xcb\x38\x77\x69\x7b\x81\x37\xe2\x0b\x95\xfb\x65\xc9\xc5\x90\xd8\x2c\x98\x0b\xef\x4c\x98\x00\x93\xea\x29\x3a\xff\x87\x29\xeb\x48\xfb\xd7\xeb\x2a\x43\x94\xe6\x6a\x80\x39\xac\xc0\xbc\x28\xdb\x88\x47\x8b\x61\x48\x58\xfc\x18\xad\xdd\xa4\x8a\xf6\x9d\x90\xe4\x85\x40\xb1\xb9\x2f\xb9\x77\x98\x17\xf8\xbf\x41\x2c\x4a\xde\x10\xa8\x4d\xbb\x78\x0c\x33\xcc\x64\x30\x9b\x6d\x8c\xc5\x62\x5c\x6f\x16\x30\xbd\xb8\xfd\xad\xb6\x64\x8a\xfa\x4b\xed\x31\x9b\x58\x4b\x4a\xa4\x76\x04\xa6\x77\x8a\x79\xe1\xd1\x47\xbf\xbc\x64\xff\x63\xcf\x3e\xfa\x28\xf7\xce\xd3\x8f\x5a\xb1\x68\x91\xbe\x7a\xba\x3f\xfa\x02\xa5\x6f\x94\xe9\xf3\xeb\xcd\x86\x93\xd0\x4f\x50\xdb\x21\x2a\xf4\xa5\x5f\x3e\xb6\xff\x92\x61\x94\x41\xc6\x22\xfd\xdb\x6a\x7d\x1a\xf2\x80\x37\xb8\x17\xf1\xc7\x82\x48\xee\xf4\x07\x3b\x2d\x88\x2c\xf4\x54\x32\xf8\x26\x35\x41\x40\x84\xbe\xa5\x80\xb7\xbc\xf6\xf6\xa9\x00\x57\x9e\x90\x3e\x8c\x6a\x75\x12\x51\xab\x55\xd0\xf5\x12\x87\x52\xab\x50\x7f\xcf\x4d\xd2\xd6\x46\xe4\x1a\x06\xc4\x59\x83\xea\x06\x0d\x54\x0a\x45\xa8\x2f\x1d\x98\x37\x87\x75\xf0\x24\xce\x24\x7b\xfc\xeb\x5a\xeb\x1a\xb4\xea\x52\x7e\xed\x85\xea\xaa\x7c\xf7\xe7\xdd\xf8\x75\x59\x57\x9b\x01\xbc\x99\xb8\x99\xe6\x74\x9f\x7a\x94\x0a\x4f\xe2\x59\x02\xaf\xaf\x63\x9d\x00\xef\xcc\xdc\x11\x91\x05\x1d\x81\x2c\xfc\x66\x80\x47\x4d\xc4\x9b\xc0\xe8\x93\x8d\x55\x8a\x8e\xe4\xbe\x20\x7b\x48\x88\x1e\x81\xef\x26\x55\x14\x81\xec\x25\x29\x84\x21\x3b\xc6\x85\xb7\xf3\x74\xd8\x59\x7d\xe9\x90\xdb\x44\x05\x51\xa1\x33\x8f\xea\xe3\xac\x3e\x74\xba\xa0\x1d\x3b\xc9\xf9\x15\x76\x96\x12\xbf\x4a\x72\xbf\x26\xeb\x92\xb5\x21\x93\x2e\xdf\xfc\x15\xf8\xfc\x17\xe9\x98\x42\x8e\x24\x14\x8e\xa9\x9b\xbc\x67\x21\x7e\x7b\xc5\xdb\x00\xe6\xc1\x6c\xf8\x38\xc5\x39\x02\xf9\xe0\x93\x34\x1f\xac\x48\xdb\x18\x23\x8f\x61\x42\x9a\x2d\x0c\x83\xe8\xb5\xff\x5a\x42\xe8\x54\x23\x5c\xcd\x29\x3c\xae\x7a\x22\xbd\x0f\xc2\xb9\xff\x95\x8e\xa2\x5a\x5e\x04\xf1\x4d\x8f\x31\x2c\x7d\xa2\x83\xbe\xeb\xe8\xac\x9d\xc6\x8b\xff\x3e\x24\x04\x00\xa6\x1c\x60\x3e\xe1\xaf\x41\x36\xe0\xe9\xb4\x31\x66\xde\xc0\x1b\xad\x46\xd1\xca\xb2\x58\x24\xef\x2d\xb4\xcb\x8f\x69\xc9\x17\x47\xb8\x63\x4e\xb1\xaa\xb5\xaa\xd5\xdf\xea\x17\xfd\x62\x55\xed\xb4\x75\xad\xbb\x76\x29\xff\xaf\x93\x8e\xf2\x99\xf5\xad\x0f\x3d\x38\xf8\xe1\x87\x07\x3f\xf8\x50\xeb\x7a\x59\x86\xf7\xa4\xa3\xf8\x71\xa0\x6f\x22\xef\x56\x42\x10\x22\x8a\x82\x89\x15\x28\xdd\x64\x4a\x79\xc6\xa1\x35\x06\x32\x45\xab\x5a\xf1\xe3\x1f\xb7\x5e\xf5\xc3\x14\x7c\xda\x55\xad\xdc\xae\x0f\x5a\xd7\x1e\x5f\xc4\x7f\xba\x76\x30\xa5\x23\x9d\x0e\x72\x56\x53\x3a\xe1\xb4\xcd\x6e\x89\x58\x20\xd7\x64\x4c\x26\x4d\x48\x42\x0c\x77\x53\x11\x63\x20\x1a\x08\x18\xad\x9e\xf2\xc3\x55\xad\x1f\x03\x49\x7c\x1a\xc8\x76\xeb\xda\xd6\x0f\x3e\x1a\xbc\x96\x8c\x21\xc2\x2f\x71\xcb\x98\xd3\x5d\x82\xf8\x17\xda\xef\xca\xbf\xa1\x9f\x06\xa6\x2b\x10\xc3\x81\xf9\x78\x3a\x63\xc7\x11\xdc\x8e\x27\x61\x2e\x09\xdf\x16\xe3\x3d\xf8\x63\xcc\xe3\x74\x65\xdd\x38\xe0\x57\xd7\xbd\xb4\x4e\x19\x49\x67\x4b\xd4\xcb\x2d\xc3\x2f\x5d\x77\x1d\x52\x69\x19\x90\x4a\x8b\x21\xcf\x74\xfe\xbf\xd1\x32\xa0\x13\xd1\x82\x4c\xfa\x3f\xa2\x85\x69\xb7\x16\xd0\x82\x36\x3f\x0e\x41\xc9\x36\xb0\xa3\x02\xbe\x92\xce\x99\xbf\x4a\x13\xb9\xeb\x73\xbb\x20\xea\x3d\x05\x7d\x06\xf3\x8a\x9c\x0c\x79\x0e\xf8\x24\x48\x81\xc3\x81\xcb\xf1\x4d\xf8\x13\x7c\x0c\x48\xe3\x08\x8f\xdb\xf9\x49\xfc\x6c\x7e\x31\xbf\x8e\xe7\x11\x7f\x13\x0f\xa2\xd0\x4b\xab\xe8\x1d\xcd\x20\xe7\x3a\xb6\x07\x8f\xe3\x37\x80\x75\x8c\x81\xed\x35\x1a\x21\xc4\x33\x9b\x90\x78\xd7\x2c\x1e\xed\x9a\xc5\xb3\xa8\xf0\x51\x33\x77\x4b\x33\x44\x35\x82\x37\xe5\x5d\x97\xa8\x5b\x35\x3b\xc3\xf6\xdc\x32\xf7\xd6\x51\xd7\xad\x7d\x09\xf5\xa1\x25\x20\xc4\x19\x0c\x66\x93\x01\x68\x19\xd8\x5d\xf0\x55\x44\x0b\x93\x9c\x66\x10\xa4\x34\x29\x3c\xae\xb2\x7a\xcd\x59\x33\x5f\xe2\x8e\x2d\xd8\x9c\xbe\xf6\xb2\xdf\x52\x5a\xd2\x71\x3c\x0e\xbd\x04\xb4\x40\xb7\x35\x5a\x40\x47\x34\xdc\x35\x4b\x44\xc9\x02\x52\x89\x3e\xa4\x52\x0b\x37\x8d\xbc\xf6\xf2\x97\xe4\xb1\xb8\x1c\xe4\x1a\xab\xca\xc5\x61\xc6\x80\x81\x96\x91\xdb\x35\xcb\xc8\xdc\x95\x31\x6a\x72\xa9\xaf\x62\xc1\xe4\x54\xe6\xe6\xc8\x99\x67\xad\xa9\xae\xe4\x37\xfc\xf6\xb2\x6b\xd3\x37\x9f\x77\x33\x89\x7b\x27\xb0\x3d\xcc\x6c\x4a\xcb\x8d\x4e\x4b\x57\xda\xdd\x6e\x13\x4f\x3a\xcd\xe8\x34\x19\x4d\x5e\x8f\xe8\x34\x39\xef\x02\xeb\x62\xb2\x9b\x76\xcd\xe2\xec\xec\x1e\x2f\xbe\xc7\x8b\xbb\xbb\x91\xf2\x28\x5b\x52\x77\xab\x4b\xfe\x3f\x52\x49\x51\x3b\x36\xaa\xfd\x84\x6f\x8b\xd7\xae\x3e\x6b\x66\xef\x37\x6a\x57\xcf\xfe\xe5\x28\x68\x93\xda\xe3\x7d\x64\x71\x98\x4c\x2e\xc1\x08\x1d\x65\xb4\xb9\x8c\x2e\x22\x8b\x0b\x64\x61\x59\xab\xcb\x0a\xdd\xef\xfa\xcf\x65\xd1\x7a\x93\xd7\x7e\x62\x66\x57\x0c\x58\x75\xd6\xcc\x17\xa5\x7d\xea\x50\x75\xdf\x32\x1e\x84\xb9\x99\x8c\x98\xdc\xcf\x20\x8f\x74\x9c\x99\x4d\xc7\x8c\xc8\x93\xa0\xf2\xd0\x91\xb3\xb9\x40\x1c\x55\x10\x83\xcb\xe9\x82\x21\x74\x6a\xe2\x24\x75\xe2\x04\x92\xda\xb0\x6a\xf2\x24\xfa\x95\x27\x56\xaf\x97\x27\x35\xfb\xd6\xb1\x20\xc7\x4d\xf2\xb0\xc3\x9c\x19\x07\x7d\x33\x86\xdf\x00\x3e\xe3\xf3\xd7\xc1\xb7\x8a\x9f\xa3\x1c\xd5\x85\xeb\x73\x97\x92\xfb\xad\x90\x19\xb5\xa6\x23\x66\x23\x84\x28\xa2\xc0\x81\x68\x16\x93\xf9\x85\x8c\x68\x7a\x31\xc3\x73\xf0\x9d\x7f\x31\x43\x1e\x6d\x4d\x82\x66\x68\x8a\xa6\x3e\x14\x8c\xd9\x18\xcb\xb7\xf0\x6c\x8a\x4d\x78\x99\xeb\x7c\xcb\x7d\xd2\xbd\x78\x4e\xe9\x7b\xa5\x78\x2e\x7b\xe8\xc7\x4d\xdc\xb2\xd0\xfd\x61\xbc\x52\xba\x36\x7c\x3f\xe5\x77\x6d\x6e\x39\xfb\x05\xf0\xf3\xa2\xb9\xe9\x61\x16\x83\x81\x17\xcc\x36\x3b\xcc\x33\xe4\xc6\xd8\xe3\x64\x39\x07\xd8\x76\xbf\xcf\xe5\x7e\x21\x63\x77\xbd\x38\xcb\x6a\x81\xef\xd6\x17\x67\xd9\x45\xc3\x0b\x19\x4e\x7c\x71\x16\x83\xe1\x3b\xf3\xe2\x2c\xb2\x31\x96\xc8\x82\xe8\xab\x94\xb2\x48\x7e\xf5\x69\x3f\xf2\x13\x1d\x38\x55\xac\x04\xeb\x86\xbf\xdc\x31\x37\x7c\xe0\xc6\xff\x90\x6e\xc7\xe7\x3b\xf6\x38\xf0\x02\xe9\xb6\x60\x10\x9f\x2f\xdd\x0e\xff\x90\x6e\xc3\x0b\x82\xec\x21\x4d\xd8\x90\xf4\x84\xf4\x14\xfc\x4b\xba\x16\xaf\x84\x7f\xe1\xb1\x20\xfb\x64\x7c\x33\x73\x19\xfb\x0c\xf4\x55\x39\x99\x83\x16\xeb\x66\x30\xd8\x6c\x23\xcb\xb0\x76\x23\x36\x82\x1d\x79\xb3\xbb\x5b\x0d\x74\xe4\xa7\xde\xe8\x33\x8d\xcc\x65\x3b\x2f\x5d\xba\xe3\xbe\x25\x17\x3f\xc0\x3c\xbc\xf4\xa1\xff\x59\xbe\xfc\x1e\x72\xa4\x07\xb1\xd8\x07\x3e\xfa\x4b\xf4\x01\xad\x3b\x9a\x51\x43\xda\x67\x36\x88\x1c\x79\x3f\xd9\xc0\x5a\xac\x3c\x36\x1a\x8c\xdb\xa0\xa1\x06\x12\x8f\xc9\x0f\x02\xe6\x5f\xaa\x1d\xd8\x18\x6d\x21\x73\x43\xfe\x12\xaa\x5f\xfc\xe9\xc9\xfd\x3f\xed\x7b\xe9\x03\xfa\x47\xf3\x55\xdc\xef\xc1\x67\x9b\xc0\xe7\x33\x28\x99\x94\xdf\x41\x76\x46\xbd\xb5\x53\xf1\x87\xdc\x15\xc4\x21\x4d\x92\xfd\x51\x07\xf8\xa3\x1a\x05\x96\x23\xc3\x4c\xd3\xb7\x96\x28\x40\x4b\x1d\xf8\xc3\xa9\xdc\x15\x93\x8e\x97\xf1\xb7\x52\x1f\xe8\x02\xd8\xaf\xf9\x2b\x41\x62\xe7\x13\x90\x52\xb3\x02\xcb\x2a\x3e\x4b\xf6\x57\x84\xc3\xd7\x2f\x4f\x7b\x19\x7f\xc8\xfe\xfe\xc7\x32\xee\x53\xfc\x18\x2a\xc0\x33\x13\xdf\x69\x22\x98\x46\x19\x95\x3c\x79\x98\xd2\x21\x7b\xa3\x2a\x01\xe9\x12\xbc\x51\x25\x32\x49\x3a\xdc\x0f\x1d\xe8\x36\x33\x67\x64\xa1\xcf\xda\x53\x49\x85\x0e\x0b\xf8\x54\x74\xf8\xef\x6b\xbc\x11\x88\x7c\x08\xd4\xb8\x08\xf6\x4e\x92\x26\x12\x62\xb2\x0f\x51\xfe\x38\x04\xf1\x7f\x49\xec\x84\x5a\x73\xff\x14\x5f\xe5\x6f\x44\xa4\x2e\x47\xde\xa7\x4f\xa1\x76\x34\x01\x7f\x9a\xce\x35\x24\x22\x89\x7d\xb3\x10\x66\x58\xcc\x46\x22\xd5\xd5\xd6\x31\xc3\x5b\x87\xef\x9b\x95\x6e\x75\x88\x56\x71\xdf\x2c\x9f\xb5\xd5\xda\x71\x7a\xf3\xa8\x27\x32\x43\x9a\x9f\x9c\x35\x64\x3c\x7c\x77\x97\xd6\x3d\x91\xa9\x28\x7d\x72\x56\xc5\x40\xf8\xee\x36\x95\x3c\x91\xe1\x4c\x4f\xce\xe2\xdc\xf0\x9d\x83\xd8\xc5\xb5\xaa\x03\x2f\xe8\xc0\xdd\x1d\x78\x7c\x07\x6e\xeb\xc0\x75\x1d\xd8\xd7\x81\xff\xdd\x81\xbf\xea\xc0\xaf\x75\xe0\xdf\x74\xe0\x3b\x3a\xf0\x9a\x0e\x7c\x2e\x05\x18\xd4\x81\x4b\x3a\xb0\x11\x50\x00\xe2\x70\x07\xfe\xa8\x03\xef\xea\xc0\x5b\x3b\x30\x50\xb9\x80\x42\x0c\xa5\x10\xe6\x0e\xdc\xdb\x81\xdf\xef\xc0\x6f\x50\x80\x6d\x1d\xf8\x46\x15\x66\x96\xca\x26\x44\xd9\x1c\xa6\x6c\xf4\x44\xe0\xb7\x95\x94\xc7\x60\xf8\xf5\xe7\xf4\xd7\x4f\x50\x29\x36\x76\xa4\xa7\xe0\x4c\x07\x1e\xd3\x81\x6b\x0a\xd1\x41\xca\x47\x3b\x30\xde\x42\x25\x9d\xdf\x81\x27\x74\xe0\x76\x0a\x61\xef\xc0\x07\xa9\x10\x7b\x3b\x30\x73\x6f\x07\xde\xdc\x81\x97\x74\xe0\xd9\x1d\x38\xdd\x81\x23\x1d\x18\x75\x60\xc3\x59\xdd\xf2\x9f\xd9\xf0\xb5\x54\xfe\x33\x9b\xfe\xbd\x4c\xfb\xa3\x82\xe4\x21\x8a\x00\xf4\x10\x2a\x08\x6a\x6f\x6f\xaf\x53\x5e\x1e\x55\xfe\x56\xcc\xb9\x1c\x49\xd4\x29\x4f\x61\x3b\x65\x0b\x4f\xfe\x09\xf3\x28\x86\x53\x09\xfa\x60\x9f\x3c\x61\x95\xc7\x9f\xe9\x13\x95\xfc\x09\x3e\xc7\x27\xfa\xbc\x71\x1b\x7b\xe7\xf6\x9f\x6e\xdf\xba\xf9\xf6\x9b\xb7\xfc\xf2\x66\xdc\x30\x6a\xd2\xb4\x31\xe3\x27\x4d\x18\xcf\x94\xf5\xf9\x08\xf7\xf6\xf9\x88\xdf\x60\x79\xf2\xb1\xec\xd3\xcf\x3c\xb6\x2f\x2b\xdd\x76\xf5\xca\x15\xd7\x5c\xb5\xea\xb2\xf7\xfa\x7c\x82\xbf\xec\xf3\x11\xcc\xd9\xe9\xec\x6a\x9c\x01\xdf\xc7\x92\x75\x1c\x50\x56\x44\xe2\x35\x84\x61\x66\xbc\xa9\xf3\xe5\x21\x9c\x62\xa7\xa7\x5f\xbe\x9b\x5d\xcd\x88\xbd\xff\x26\xf3\x00\xf0\x98\x3d\xd4\x2f\x7c\x4f\x33\xd2\xef\xf1\x0c\xb2\x56\x99\xc5\xdc\x1c\x0e\x77\x3b\xe9\xba\xe6\xfd\x00\xf3\x47\x80\xa9\x12\xbf\xcf\x4d\xa2\xab\x88\xdf\xcf\x27\x3e\xe4\x7b\x7a\x4f\x07\x46\x33\xd1\x8d\xcc\x64\xf6\x11\xb0\x54\x89\xb4\x4f\xc0\xd8\xc0\xb3\x26\x08\x23\x8e\xce\xb2\xb3\x49\x76\x31\xbb\x8e\x4c\xd0\x64\xb7\xfa\xd0\x36\x38\x30\xdc\x82\x53\x5e\x23\xf6\xe2\x87\xa4\xbd\xb8\xf3\x41\xe9\xd7\x78\xf2\x8d\x78\x51\x3b\x5e\x1e\x91\x6e\x90\x6e\x0e\x13\x9a\x19\xa0\x39\x45\xa5\xc9\x1a\x30\xd8\x44\x93\x51\x20\x34\x85\xa4\xb0\x58\x58\x27\x70\x42\x21\xcd\x58\x8b\x11\x43\xbc\xe3\xc5\xf8\x21\x3c\x45\xda\xfb\x3f\x40\x32\x0c\x31\xe5\xc5\x11\xe9\xc6\x76\x68\xe7\x53\x60\x70\xc7\x92\x76\x22\x7a\xbf\x11\xc4\x9f\xaf\xd2\x9c\xd0\xcc\x32\x86\xa4\x01\x93\xc7\x7b\x71\x77\x4b\x4b\xb7\x7c\x90\x04\xe7\xf6\xf3\x1f\x33\x87\x85\x69\x64\x75\x68\x1f\xe2\x31\xc7\x90\xb7\xe5\x94\x78\x94\xbc\xe8\xc8\x1c\xfe\xe9\x4f\x6c\x1d\xff\xf1\x25\x60\x3f\xe7\x80\xb3\x9f\x47\xfb\xde\xfd\x24\x4b\x60\x61\x8e\x93\xd7\xec\x65\x68\xa2\x60\xd2\x77\x5b\xd8\xa5\x37\x03\x08\xfc\xe1\xd0\x6f\x80\xc1\xe5\xe0\x03\x65\xbb\x6f\x47\xe3\xd2\x95\x16\x03\x88\x65\x37\x8b\x2c\xeb\x70\x5a\x2d\xdb\x32\x46\xc3\xb6\x8c\x15\x92\x17\xc4\xf3\xdc\xb6\x0c\x0f\x08\xdb\x32\x84\xa8\xf6\x4c\x62\x5b\x20\x99\xec\xe3\x8a\x53\xe0\x0b\x58\xdd\xd7\x6f\x5e\x92\xff\x7c\xf0\x01\xf7\x8f\x0f\x3e\x90\x66\xc1\x57\x86\xb8\x07\x9d\x1d\xb5\xa3\xd2\xb4\x15\x19\xcc\xac\xdd\xce\x59\x81\x3d\xb5\xa5\x4e\x6a\x4d\xfd\xc4\x9a\xa6\x9c\x31\x88\xbe\x63\xf4\xe9\x7c\x62\x51\x5f\x06\xc3\xfc\xf2\xcb\xaa\x45\x05\xb3\xac\xda\x54\xc4\x68\x34\x59\xd9\x3a\x1b\x10\xc7\xf1\x26\x96\x2f\xb6\xce\xac\x53\x36\xcf\xdb\xc9\x63\x79\x93\x89\x79\x26\xb4\xa4\xed\xf8\x31\xcd\x40\xe3\x9c\x03\x68\x1d\x03\x5a\x3c\xb2\xef\x83\xec\x88\x25\x29\x5f\xbb\xfc\x8c\x7d\xcc\xc9\x46\xd9\xda\x69\xaf\xe0\x4f\x5e\x81\x5c\xa8\x12\x5f\x24\xdd\x82\x74\x38\xd7\x23\x01\x7c\x13\xf0\x66\x78\xe2\xf7\x54\xdf\x44\x58\x86\x30\xa0\x1d\x3b\xa6\x38\x95\xa7\xa4\xb1\xb2\xdc\x4e\xc0\x3b\x0a\xf9\x98\x40\xb3\x55\x87\xc0\x98\x78\x91\x85\xd0\xdf\xc4\x62\x03\x47\x73\xb2\x94\x4b\x75\xbc\xb2\x00\x24\x27\x6b\xad\x12\xfd\xb5\xd3\x7e\x7b\xf4\xe8\x6f\xa7\x5d\x7e\xf9\xe5\x20\x09\xbf\xef\xa3\x8f\xf6\xed\x5b\xba\x74\x89\xbe\x7f\xad\x28\x90\x36\x23\xc1\xc8\x5a\xad\x9c\x39\xef\xa9\xf2\x7d\xab\xef\xd9\x80\xd6\xb1\xd2\x5d\xf9\x7e\x45\x36\x26\xc5\x6c\x05\xe5\x31\x21\x07\x9a\x98\x6e\xb0\x0b\x0c\x84\xec\x36\x1e\xf3\x2e\x27\xe2\x6c\xdc\x67\x19\x03\x3f\xdb\xb6\xd8\xb6\xce\xc6\xda\x6d\x11\xf8\xb6\xd9\x76\x8f\x8d\xb7\xd9\xb0\x59\xf8\x10\x7f\x4c\x9e\x87\x05\x86\xdd\x4b\xe5\x20\x22\xbf\xb4\x24\x57\x75\xbc\x20\x42\x0b\x51\x54\x2f\x2b\x88\x30\x3a\x4c\xd5\x95\xd2\x42\x7c\xc5\x6d\x8b\x8f\x79\x87\xff\x0e\xfb\x99\xcf\x1e\x7b\x6c\x31\x33\xa0\xf7\x4f\x4b\x19\x7f\xf5\x6c\xe9\xaf\xf8\x7c\x98\x9b\x2d\x4c\x35\x73\x19\xc8\x13\x46\x17\xa7\x47\xb9\x43\x60\x64\x42\xd8\xc8\xf9\xac\xc8\xef\xf1\xb8\x03\x2e\x97\xe0\x46\xee\x48\x59\xc8\x71\x30\x33\x5a\x9c\x26\xce\x17\xd9\x16\x11\x60\x44\x87\x58\x0e\xdd\xca\x8b\xae\x50\x88\xf5\x78\xfc\x9f\x65\x3c\x1f\xb2\xa6\x83\x19\xf6\xa3\x82\xd7\x3f\xdb\xda\x66\x9f\x45\x3c\x43\x5d\xe1\x73\xc2\xf0\x03\xa2\xbf\x50\x63\xab\xaa\x56\xf2\x1e\x36\xb9\xf3\x31\x56\x21\xc6\xdc\x10\x37\x88\xf4\xe5\x55\xe6\xb2\xdb\xae\x5f\xb1\xcd\x73\xb5\x79\x6a\x7a\xec\x8c\xc9\x13\x66\x0d\xdb\x10\xc5\xc7\xa5\x65\xee\xf0\xac\x41\x57\xdc\xcc\x8e\xba\xea\xb6\x65\x17\xd8\x87\x8d\x9d\xde\x3d\x79\xfa\x30\xfc\xee\xd2\x7f\x06\xa3\x37\x53\x1b\x56\xc7\x34\x33\x2b\xa1\x4d\x66\x54\x9b\xf6\x18\x38\x9e\xbc\xe1\x69\xb4\x5a\x90\xd1\x64\xfc\x2c\x63\xfa\x90\xfb\x58\x79\x68\x5f\x96\x8a\x78\x11\xb2\xde\x6b\x63\xbc\xb1\x66\x57\x2b\xb1\x07\x2b\x37\x5c\xd8\x72\xf5\x65\x0f\x4b\xcd\x4c\x07\x5f\xfa\xf2\x47\xef\x2e\xdf\x86\xc7\x1e\x27\x77\x6d\xb3\x68\x00\xf4\xd7\x15\xfc\x26\x32\x2b\x50\x23\x79\x1d\x7a\x40\x79\xad\x10\x8f\x3b\xc3\xa8\xb6\xd6\xe2\x0f\xfb\x07\x36\x0d\x88\x1a\x6d\x46\xdb\xc1\x8c\xdd\x18\x31\x32\x46\xd0\xbd\x60\x55\x15\x7b\x30\x53\xf5\x97\xa0\xe7\x60\x26\xf8\x51\x3f\xcf\xa3\x22\x6d\xf9\x59\x7d\x6d\x99\x3e\xe5\xaa\xf7\x46\xee\x66\xed\xc7\x56\xd5\x5b\xb5\xb6\x34\x60\x39\x2a\x25\x4b\x68\xde\x32\x8c\x3f\x1e\x7d\xea\xa9\xa3\xc6\x8c\x1a\x3d\xda\x7b\xf7\xe9\x93\x26\x76\x4e\x3e\x6d\xd3\x9d\x37\x6d\xda\x3e\xfb\xb4\xd1\x93\xb7\xae\xbb\xe2\x97\x53\x46\x4f\xc9\x70\xbb\xc6\x0c\x1d\x31\x6a\x4c\x7a\xa8\xf4\xce\x4d\xa7\x8f\x99\x7a\xfa\x84\x71\x97\x5e\x71\xc5\x25\x93\x97\x59\x58\xfb\x85\xe3\xe7\xad\xb8\x74\xfe\xf8\x0b\xad\xac\x6d\x91\x9c\x5b\x9e\xc3\x88\xcc\x95\xdc\x76\x88\xef\xe7\xa5\xfd\x56\xc8\xbd\x90\xd7\xe8\xf5\xf9\xad\x9c\x93\x3b\x98\x31\x6e\x44\x3f\x82\x3e\xf7\xe4\xf6\xa7\x63\x46\xeb\x38\xe4\x34\x9b\x27\x38\x67\x39\x19\x67\xda\x5b\x32\xce\x99\x76\xb8\xc7\x25\x9d\xed\x4e\x26\xe4\xc4\x76\x27\x66\x9c\x28\x49\x22\x84\xba\xba\xee\x54\xd2\x71\xa0\xae\xbb\xa9\x28\x3f\x83\xd6\x16\x3c\xc9\xaf\xbc\xc8\xef\x64\x98\x41\x63\xc6\x4d\x5f\xcf\xad\x10\x98\xd8\xd9\xa7\x5d\x34\x97\x11\xf1\xa6\x33\xc6\xcc\x3f\x4b\xda\x82\x73\x1b\x17\x8f\x1c\x72\xe1\x2a\x69\x12\x8d\x01\x87\xe7\xce\x63\x8d\xcc\xe5\x0e\x91\x3f\x1b\x31\xbd\x1b\xe9\x67\x83\x72\x0b\x99\x97\x99\x0d\xf0\xd9\x82\xdc\x8f\xbd\x9b\xe8\x67\x43\x73\x0b\x98\x03\xcc\x7a\xf8\x6c\x19\x42\xbd\x37\xca\x7b\x39\x72\x2b\x99\xed\xcc\x72\x87\xc8\x0e\xc4\x13\x15\xb8\x41\x00\xf7\x32\x85\x5b\x08\xb8\x37\xd2\xfe\xb0\x81\xc1\x3f\x8f\x7f\x17\x95\xa1\x0b\xd3\x23\xf8\x80\xd5\xe9\x34\x78\x50\x99\xd9\xe5\x72\xdb\xcb\x3c\x01\x21\x52\x6e\xb4\xcc\xc9\x38\xbc\x06\xef\x9c\x8c\xd5\x60\x37\x4c\x32\xbc\x6d\xc8\x19\xc0\x52\x40\xf0\x6f\x08\x79\x42\xcc\x9c\x0c\x0a\x71\x1e\xe7\x9c\x8c\x47\xb1\xfe\x29\xcd\xfc\x83\x22\x38\xe9\x9c\xae\xd3\x25\x06\x6a\xcf\x28\x6a\xe0\x97\x03\x6a\xe5\xab\x92\x71\x36\xbb\xc8\xc3\xf1\xcc\x3b\x03\x1e\xdf\x7e\xdd\x0d\x77\x30\xb3\xa5\xe9\xf8\x2a\xe9\x32\xfc\x72\xef\xb5\xdf\x1c\x95\xbe\xb8\xeb\x9d\x38\xf7\xc8\xb6\x5f\x3f\xf3\x72\x0f\xc6\xfb\x36\x4a\x7f\xba\x5e\x7a\x6a\x23\x7e\x1b\x7c\x1f\xe6\xff\x8d\xf9\x9b\xaf\xa4\x79\x0b\x3a\x3f\xb7\x99\x5f\x25\x18\x50\x05\xaa\x46\x0d\x68\x65\x7a\x58\xcc\x68\x30\x54\x20\x9b\xd5\x1a\x2e\x43\x65\x9c\xcb\xe9\xf4\x07\xb8\x40\xb2\xb1\x22\x1c\x4a\x27\xea\x1b\x58\xec\xf7\xe3\x48\x28\xe4\x9d\x9d\x09\xb9\x6b\x3c\x26\x97\xcb\x6a\x34\xa5\x4d\x75\xb3\x33\x76\xd1\xc4\x81\x41\x4c\xd1\x27\x5f\xdf\x6c\x22\x96\xb1\x8d\xce\xb2\x14\x79\x08\xdf\xdf\x16\x74\xbc\xd5\x94\xd7\x72\x97\x5e\xdb\x61\xf6\xf1\xad\x95\x4c\x8b\x03\x25\x5a\x53\xa2\xcf\x4f\xff\x12\x2b\xab\x70\xdc\xed\x17\xb8\x3a\x2c\xc6\x5a\x2b\xab\x44\xd6\xe3\xc7\x02\x83\xe1\x63\x9f\x1f\x37\x0e\xbf\xf2\x0a\x7c\x3a\x6e\x8c\x6e\xaa\x98\x3e\xae\x76\x53\xdb\xed\x63\xf7\x45\xda\xa5\x8f\xb1\xfb\x96\xbb\xba\xa4\xdf\xbe\x63\x09\x6e\x2a\x9b\x3a\xa6\x76\xcb\x5a\x6c\x7f\xf6\x6d\xe6\xc9\x53\x67\x48\x7f\x48\x4f\x5f\xfa\xe7\xb9\x78\xf0\x6f\xf1\x29\x78\x8d\xe3\xe2\x4b\x0d\xbe\x2d\xaf\x67\x1e\x19\x36\x71\xf8\x4f\xd8\x8c\x83\x13\x9f\x78\xae\x7b\xa1\xb5\xec\x97\xec\xe0\x7f\xdf\xc9\x3e\x17\x96\x3e\xc4\xf1\xb0\xf0\xe3\x7b\x35\x2e\x3a\xee\xe7\xe7\x8e\xf0\xab\xf8\xad\xa8\x1e\xad\x48\x9f\x5a\x5b\x53\x63\x29\x29\x11\x05\xc1\x5d\xca\xc6\x4a\x63\x0d\x03\x1c\xd0\x17\x46\xa3\xc3\x11\xa9\xb4\xd7\x62\x2b\x5b\x5b\x5b\x59\x89\x66\x67\x2a\x39\xa1\x24\x52\x32\x1b\x46\xdc\x11\x62\x1a\x43\xe9\xd0\x92\xd0\xfa\xd0\xfe\xd0\x3b\x21\x21\x14\x8a\xb8\x89\xe7\x20\x35\x31\xf5\x61\x6c\x6a\x09\x9c\xc4\xbb\x69\x6f\x3a\xab\x3d\x24\xbf\x29\x5b\x81\x9c\x1e\x97\x9f\x3c\xee\xea\xf3\xd2\xb9\xa1\x3e\xef\x4a\xbb\x28\x56\x11\x27\xbd\x17\x6d\xe2\xfc\x62\x03\x66\x03\x5f\x4a\x3f\x3d\xfd\x90\xf0\xb0\x81\xab\x5b\x72\x6e\x3c\x11\x1f\xb6\xe4\x52\x6c\xdb\x4c\x3b\xe6\x4f\xd2\x6b\x3b\xf1\x85\xf8\x94\xbf\xe2\x86\xb1\xfb\x06\xbe\xcf\x1d\x97\xfe\x28\x1d\xff\xa3\xf4\x7e\x23\xde\xbb\xec\xfa\x9e\xc4\xc6\x73\x4d\x0f\x98\x5e\xc8\x3e\x65\xc3\x3e\xe8\x92\x5f\xe3\xf1\x7f\xc5\x93\xf1\xe5\x7b\x1f\x1d\xb6\xe6\x0a\xe8\x07\x08\x6b\xb8\x06\xb0\xab\x4e\xb4\x24\x9d\x86\x9c\xd6\x68\xb3\x88\xac\xc9\x61\x72\xb8\xdc\x06\x8b\xd5\x32\x39\xc3\x47\xac\x18\x59\xb1\x81\xb5\xe2\x34\xe6\x66\xe7\x6b\x82\x76\xf8\xc6\x18\x58\x8c\x8d\x76\x3b\x74\x8e\x9d\x35\xba\x50\xbb\xce\x08\x2e\x95\x1f\x0a\x26\x3f\x35\xe9\x2d\x73\x5b\x13\x79\x0f\x97\x5a\x07\xd0\x79\xf2\x1f\x71\xaf\x2d\x29\xf8\x17\x3e\x8f\xd9\xd3\x3b\x19\xdf\x22\x5d\x94\xdd\xb3\x87\x5d\xc3\x7d\x2e\xc5\xb7\xff\x69\x83\xf4\x05\xf6\x6f\x60\xbf\xd8\x46\xc7\x6d\x08\xc8\xdb\x09\xe3\x36\x00\xdd\x9e\x9e\x31\x20\x5e\x8e\x62\x91\xca\x4a\x87\xc5\x10\xf0\xfb\x6b\x51\xad\xdd\xcc\x71\x06\xc4\x26\x1b\x2a\x6c\x76\xdb\xe4\x4c\xa5\xc9\x6c\x9a\x9c\x89\xed\x31\x63\x64\x76\x98\xcb\xcd\xac\x39\x1d\xb1\xdb\x23\xf6\x24\x08\x4b\x02\x2a\x8f\x27\xb4\x3c\x63\x0f\x60\x33\x1f\xf0\x88\x7c\x2d\x57\x7b\x71\x66\x00\x17\x50\xeb\x4d\xed\x29\xd5\x94\xd3\xf6\xa4\x82\x6f\x75\xcb\x36\x4e\x69\x8d\x5f\x7e\xfa\x5f\x2e\x5a\xa7\xe4\xdd\x20\x6d\xd4\xeb\xe0\x58\xb4\x65\x04\xa6\xcf\xfe\x93\xe2\x8f\x6c\xd0\xc9\x30\xd2\xe1\x55\x5a\x4d\x0c\x7c\xb4\xa9\x95\xeb\x74\xee\xbd\xa9\x77\x4c\x66\xc6\xd3\xf0\xe7\xad\x97\x6f\x7d\xb5\x62\xb7\x77\xf1\xd8\x65\x4b\xf0\xed\xd2\xf9\xe4\xeb\xcc\x0e\xfc\xb7\xdd\x61\xdc\xba\x75\xc7\x9d\x0d\xf7\xae\x2a\xd9\x70\xc3\x86\x2b\x5e\x7a\x6d\xd5\xa2\xb6\xf4\x84\xe5\x6b\xaf\x87\x7f\x89\x2b\x9e\xae\xd9\x8b\x94\xda\xcd\x60\x21\xc6\xa7\x61\xce\x9f\x9d\x6e\x69\x40\xc8\x65\x34\x5a\x4d\x25\x75\x75\xb8\x3e\x18\x0a\xc5\x62\x15\x15\xa5\xf5\x26\x2e\xd9\x58\x56\xd5\x99\x09\xa5\xcb\x1c\x03\x5c\x25\xac\xcf\xe4\xe3\x3b\x33\x3e\x87\xcd\x5e\x17\x43\x26\x2f\x6a\x7f\x2b\x95\x92\x07\xd1\xdf\x16\x68\x0f\xbe\xa5\x37\x5d\xf9\xc9\x4d\x4d\x18\x8f\x5b\x34\xeb\x0e\x3a\x5c\xc6\x28\x06\xde\xef\x4e\x89\xd4\x81\x91\xcf\x89\xf3\x67\x61\x74\x59\xbc\x16\x5f\x39\x63\xc9\xf2\x6b\x1e\x17\x1e\x86\xec\x87\x61\x87\x6c\xbd\x70\xcd\x4d\xe1\x8f\xef\x5e\x53\x1b\xbe\xff\x97\x8f\xcd\x58\x32\x20\xfe\xd0\x63\x7f\x7d\x95\x15\x17\x6f\x5f\xb9\xf7\xde\xde\x1b\xd9\xa9\xcf\xd6\xf2\xf5\x6d\x93\x96\x9f\x31\xef\x02\xfc\xfc\xbf\xf8\xc7\xde\xe8\x4d\x32\xbb\xb7\xaf\xb4\x4a\x8f\xf6\x6e\xef\x95\xc8\xbd\x94\x3c\x2a\x81\xbf\x76\x83\xee\x86\x50\x04\xc5\x10\x79\xed\xf2\x96\xf4\x84\x90\xdf\x5f\x53\x5d\x55\xee\xf1\x94\xe0\x44\x98\x8f\xc7\x23\x51\xd6\xeb\x30\xd9\x6c\x10\xc2\x3b\xbc\x8e\xda\xba\x84\xdb\xee\x0f\xf8\x67\x67\xca\x4b\x2d\x81\x58\xc4\x1c\x42\xa1\xd9\x99\x2a\x88\xee\x2b\xbd\x81\x9a\xea\x00\xaa\xae\x46\x01\x96\x71\x7a\x5d\x02\x43\x62\x41\x1a\x59\x26\x93\x64\xf3\x0b\xdd\xf3\x22\x17\x7a\x52\xba\x9f\x14\xf3\x97\x52\x16\x2e\xc8\x8f\xb2\x82\xa7\xe4\x69\xee\x86\x5f\xb8\xa3\xa4\xe3\xbc\x31\x2f\x8d\x25\xb1\xa2\xf0\x2d\x31\xf2\x82\x36\x1f\xad\x8a\xe1\x98\x1b\xa7\xaa\x4a\x36\xff\xe5\x47\xfc\xed\x23\x9b\xe0\xcf\xe7\xd2\xfb\x52\xfb\xc3\x9b\x37\x6f\x66\xcf\x44\x39\x69\xb1\xb4\x18\xcf\xb9\xf9\x6d\xb6\x62\xfb\xae\x9f\xde\x59\xbc\x82\xfd\x06\x6f\x96\x96\x92\xaf\x6d\x7f\xdf\x26\xd5\xe1\x3f\x91\xaf\x6d\x7f\x27\x7f\xa4\xcb\xa5\xef\xd8\x9a\xe7\x60\x56\xdf\x9d\x3b\x62\x38\x8f\xc6\xa4\x4e\x54\x85\x26\xe2\x8d\xe9\x4a\x3b\xcf\x0b\xa3\x4e\x39\xa5\x1a\x99\xcb\x5d\xc3\xca\x2a\x2a\x42\x25\xfe\x64\x43\xc3\xb8\x61\xc3\xfc\x66\x56\x68\x6e\xae\xae\x16\x84\xce\x49\xe3\x7a\x72\x3f\xa4\xdf\x73\xfb\xc6\x35\x1b\xe0\xaf\x71\xcd\x90\xa4\x37\x75\x66\x92\x75\x3e\x4f\xa2\x33\xe3\xf1\xd9\xc1\x02\xb4\x8f\xe9\xcc\xb4\x8d\xc2\xac\x7d\x54\x64\x54\x72\x14\x6b\x15\x46\xb5\xb7\x07\xa3\x25\xc1\x92\xce\x4c\x59\xb0\xb4\x34\xd8\x6e\xc7\xf6\xb4\xd1\x39\xce\x1e\x8c\x04\x19\x07\x6b\x0f\xda\x83\x82\x28\xda\x66\x67\x44\x56\x70\xa5\x3b\x71\x63\x27\x2e\xef\xc4\x8e\x4e\x8c\x3a\xf1\x3b\x9d\x78\x7f\x27\xde\xdb\x89\xef\xed\xc4\x37\x75\xe2\xf5\x9d\x78\x49\x27\x9e\xd3\x89\x3b\x3b\xf1\xb1\x4e\xfc\x89\x0e\x40\x8f\x35\xf4\x93\x93\x62\x02\x8f\xcd\x9d\x78\x5d\x27\x5e\x5c\x88\x26\x9e\xa5\xaf\x47\x14\x97\x29\x0a\x8b\x18\xaa\x29\x53\x1c\x79\x1d\xb8\xf2\xa4\xec\xcd\x9d\x60\xd9\x53\x34\xd4\x95\x8b\x18\x79\x9f\xaf\xe4\x7b\x6d\x9a\x26\xa8\x86\xc1\xa5\x2f\x59\x93\x00\x19\x1c\x20\xa9\xa5\x35\x71\xa2\x23\x0a\xb9\x5b\x39\xa6\xe1\x1f\x51\x8a\xd6\x14\x55\x12\xba\x9f\x33\xa1\x0b\xa4\x5b\x9a\x1b\x70\x15\x79\x4f\x3e\x6f\x4a\x48\xf8\x50\xc6\xb0\x4f\x4b\x3f\x7e\x72\xc5\x3e\x5c\xf7\x15\xe6\x9e\x90\x7a\x16\x2c\xc5\x69\x66\xcd\xe9\x93\x17\x74\x9f\xbf\xb8\xe5\xa2\xed\xdb\x6b\x5a\x4b\x87\x33\x87\x9e\x7c\x78\xc7\x9e\xd2\x7b\x9c\x67\xcf\xec\x89\x8f\x5d\xbf\xe8\xfc\xc1\x0f\xed\xb8\xf1\x01\xdf\x0e\xd3\x8c\x31\xdb\xba\xae\x58\x76\xe1\x30\xf6\xfd\x57\x8f\xf4\x7e\xc0\x6f\xf8\xcb\x01\xec\xec\x7d\xb7\xf7\xf4\xc0\x9a\xd5\xf8\xb7\x57\x7e\xf3\xcd\x95\xd2\xbc\x89\xe3\x6d\xf3\x56\x6e\xb8\x68\x65\x70\xf8\x90\x05\x91\xda\x48\x79\x68\x68\xd7\x88\x25\x2b\x16\x5c\xec\x6c\x6c\x9e\x5e\xd9\x1a\x0e\x0e\xeb\x96\xeb\x75\x0f\xe5\x8e\x18\x45\x9a\xbf\xb7\x90\xb5\x61\x34\x83\x9f\x4c\xeb\x76\x6e\xf8\x8b\xe4\x22\x64\x86\x92\x33\x1c\x0d\x68\x20\x6a\x46\xeb\xd3\x23\x1b\x9a\x06\xb2\xbe\xb2\x48\x04\x0b\x7e\x9f\xcf\xe3\x10\x1c\x83\x5a\xea\xaa\x62\xac\xdb\xe3\x9e\x9d\x69\x0e\x07\xb0\xa7\xb1\xde\x24\xda\x1d\xf6\xd9\x99\xea\x78\x39\xef\x68\xf2\x7b\x06\x36\x38\x3c\xf0\x9f\xb5\x2c\xe4\x67\x8d\x56\x17\x9d\x9d\xa4\x6b\xc9\xec\x54\xa7\xa7\x32\x2b\x53\x05\x3f\x17\xc5\xe1\xf4\x5a\x7a\xe8\x64\x31\xe5\x8d\xb2\x31\x96\x7e\xb5\xa4\xaa\xa0\xf3\x59\x98\xa9\x6e\xfa\x85\x53\xad\x51\x9e\x7c\x29\xb3\x13\xfe\x17\x53\xa2\x71\xd1\x9d\xa7\x7c\x28\xfd\xf0\x8b\x83\xeb\xa5\xeb\x37\xfc\x7f\xbc\xbd\x09\x7c\x54\x45\xd2\x00\xde\xd5\xef\x9a\xfb\xcc\x64\x26\x77\x26\x93\x8b\x84\x30\x90\x49\x08\x41\x21\x03\x72\x44\x04\x0c\x37\x03\x84\x04\x88\x9c\x22\x87\xdc\xc8\x0d\x0a\xa2\x22\x72\xc8\xa1\x88\xa2\x88\x1c\xa2\x1c\x01\x2f\x10\x75\x75\x5d\x45\x74\xfd\x14\xf1\xc2\xfb\x53\xd7\x55\x76\xd7\x75\x35\xc9\xbc\xfc\xab\xfb\xbd\x49\x26\x80\xfb\xed\xf7\xfb\xfe\xff\xff\x24\x6f\xde\x31\xfd\xaa\xab\xab\xab\xaa\xab\xbb\xab\xab\xbf\xba\x43\xfd\xf5\xa3\x9e\xdb\xa7\xdf\xfa\xda\xcd\x70\x62\xe6\x89\x19\x70\x62\xda\x6b\xd1\x55\x5f\x75\x57\x77\x35\x5d\xfa\x32\xac\xee\x82\xd7\xc0\xdf\x7d\x0f\xbd\xee\xde\xbe\x4d\xbf\xdc\xd3\x17\x9e\x08\x56\x0b\x7f\xdf\xf9\xcd\x4e\xb5\x00\xde\x67\x07\x5e\xc6\xc4\x18\x36\x34\x5d\xfa\x86\x7d\xd4\x65\xea\x9f\xa1\x83\xfa\x67\xd1\xfa\x32\xeb\x57\x1e\x23\x44\xf6\x8a\x6f\x10\x3b\x52\xaf\x3a\xec\x75\x3b\x24\xd9\x21\xa7\x58\x6d\xb6\x4c\x5f\x4a\x8a\xdf\xe9\xb4\xcb\xb2\xc3\x9e\xd4\xc3\x0e\xe5\xc4\x06\x5d\x31\x99\x05\xc2\x24\x42\xd8\xbd\x83\xb8\xf9\xb5\x03\x9f\x57\xc4\xd8\xb4\x82\x59\x23\xcc\xdf\x28\xe6\xc7\xe7\x6a\x99\x43\x2a\x4e\x07\xd4\xd7\x8c\xc9\x02\x4c\x3b\x01\x3e\xf6\x17\x77\x87\x52\x3c\xb3\x00\xfe\xf4\xcc\xa1\x17\x23\x27\x3b\xcd\x9e\xa9\x3e\xfd\x0c\xdc\x73\x12\x86\xce\x98\xd5\xf1\x99\xd1\x67\x0e\x88\x6f\x4c\xfd\xee\x4f\xea\xaf\x4d\xdb\x1f\xea\xdb\x78\x51\x7c\xa3\xb1\x94\x5e\x88\xbe\xd3\x77\xcf\x16\xfa\x48\x74\xf0\x1b\xdf\x4f\x46\x5b\xf4\x61\xf2\x9d\xc0\xc6\x52\xd2\x50\x3b\x17\x91\x49\xe1\xe4\x74\x49\x2a\x72\xda\xb2\xb3\x13\x7c\xbe\xf6\x45\xed\x3b\x04\xf3\x0c\x5e\xbb\x3d\xc1\x41\xac\x06\xd6\xed\x48\x36\xbb\x2a\x33\x1d\x60\x70\x18\x1c\x2e\x7f\xb2\x10\x36\xda\x2b\x85\x82\xaa\x22\x28\x42\xab\xad\x22\x58\x1d\x7a\xb3\x10\x75\x2b\xab\xf2\xea\xc2\xb8\x8d\x06\xe2\xba\xcc\x7a\x79\x10\xe7\x4c\xa7\x26\x2b\xa1\x3c\xde\x06\xeb\x72\xe5\x0d\xe4\x96\xe6\x24\x24\xc6\x7a\xa6\xb2\x80\x2d\x31\x7d\x34\x70\xf3\x70\xf5\x8b\x2d\x77\x0d\x9f\x12\x00\x58\xb0\x60\xe9\x98\x31\xe2\x02\x45\x5d\x56\x35\x7e\x46\xf5\x98\x19\xe3\x07\xad\xa4\x6f\x45\x8b\x69\xd9\xf5\x15\xb0\xf8\xcc\x4b\x15\xbd\x3b\xef\x1f\x33\x69\xd2\x98\x68\x55\x5d\x97\xa4\x71\xff\xda\xbe\xe6\xde\xfb\x37\xde\xb1\x2e\xba\xbc\x5a\x6b\x83\x1d\x2c\x36\x34\xda\x27\x85\x64\x7f\x78\x4a\x66\x5e\x9e\xd8\x2e\x23\x3b\xdb\xe6\x30\x9b\x5d\x26\x5b\x92\xcf\x27\x88\x36\xb1\x7d\x51\x96\xc3\xe9\x18\x14\x69\x67\xb6\x98\xd1\x46\x61\x13\xcc\xcb\x2c\x1b\x2c\x0f\x59\x24\x4b\x38\x2f\x58\x49\x2c\x0e\xcb\x72\x8b\x60\xb4\xa0\xad\xe2\xcc\x70\xd6\x38\x05\x76\xda\xe0\x3c\xec\x14\xed\x78\xa2\x66\xc1\xe9\x24\x1e\x4f\xea\xad\x91\x24\x8f\xa2\x90\x5b\x23\x82\x92\xc4\x4c\x96\x16\x3d\xa4\x59\x5f\xb3\x43\xc9\x6f\xa2\xde\x9a\x15\x6f\xb1\x94\xc7\x2b\x25\xdd\x7f\x95\x0f\xce\x61\x0f\xd4\xcb\xf6\x69\xa0\x42\xa0\x2c\x94\x57\x86\x5f\xae\x38\x93\x45\xf1\x2b\x7e\xec\xac\x78\xf1\x94\x0e\xf4\x68\xdd\x02\xdb\x33\xe9\x1f\x3d\x79\x21\x9a\x7e\x20\x7f\x81\x20\xec\xce\x5f\x91\xf9\xeb\x47\x87\x3f\x4a\x7b\xc6\xb6\x70\xea\x3d\xf7\x7b\xe0\x54\xbe\x3a\x41\x10\xe1\x95\x7c\xf5\xe6\xc4\x47\x96\xd6\x8d\xb6\xed\xdc\x07\x32\x88\x2b\x06\x0e\x5f\x06\xd0\xf8\xc4\x0e\xdb\xe8\xba\x27\x9f\x5f\xe6\xeb\x9e\x9f\xbb\xe2\xe5\xe3\x8c\x66\x19\x6c\xdf\x5d\xd4\x11\x09\x64\x70\xb8\x9d\xcd\x60\x16\x04\x6c\x2f\xac\x46\x8b\x40\xb1\x8f\xe9\xb2\xb8\x12\x3d\x76\x73\x02\x49\xa8\x89\x18\x44\x07\xf2\x01\xb5\xba\x5a\x5b\xe7\x72\xec\x93\xb4\x4e\xbf\x68\x4d\x71\x8b\xda\xe5\x7e\x04\xfc\x16\x42\xcc\xec\x02\x94\x65\x85\x35\xbe\x19\xeb\x4e\x4f\xa5\xdd\x3e\x8f\x9e\xa0\xf7\x46\xff\x40\x7b\xfd\x35\xfa\x66\x60\xf3\xe9\x75\x42\x11\x1d\x1a\x3d\xc8\x8e\xdd\xd1\x5b\xe9\xdd\xb3\xa2\x5f\xb1\x8d\x88\x40\xdb\xab\x0c\xf1\xf3\x92\x01\xe1\x7c\xc2\x66\x50\x6d\x36\x93\xd3\x6a\x35\x09\x8a\x62\x34\x9a\x3c\xa6\x44\x21\xc9\x47\xdc\x1e\xd4\x5c\x16\x87\x4c\x45\xa3\x47\xb3\x85\x31\xff\x38\x53\xf1\xf2\x3f\x66\x00\xe7\x78\x24\x0f\x1e\x88\x92\x54\x9a\x53\x8a\x07\x9b\x1b\xf1\xd0\xb7\xa1\xaf\xfa\x0c\x3b\x4e\x69\x27\x3c\x52\xc5\xdb\xc5\xaf\xd5\x07\x0f\x3e\xb4\xff\x31\x3c\xd4\x6a\x08\x3f\xb1\xe3\xc0\x5e\x3c\xe0\xb5\x07\x1e\x40\x5b\xa8\x9d\x3a\x45\xf9\x51\xbe\x95\xb8\xd0\x42\xee\x43\x86\x91\x1a\xb2\x25\x3c\x64\x74\x5a\x81\x77\xf8\x80\x40\xa7\x10\xd6\xe9\x10\xb4\x99\x7a\x0c\x31\xe6\x05\x86\xa7\x19\x6a\xc7\xe5\xf5\x0d\xf5\x1d\x17\xf1\x0e\x18\x1e\x10\x33\xdd\x99\x23\xc7\x45\x24\x87\xe0\xe8\x5e\x1b\xc9\x74\x64\x3a\x92\x3b\x86\xc2\x45\xa1\x82\x82\x90\x98\x3c\x76\x5c\xc4\x98\xec\x72\xdf\x58\x1b\x71\xbb\x84\x5e\xb5\x11\xc1\xd5\xaa\x4d\x5e\xe5\x1c\x87\x8d\x62\xb2\xe3\x2c\xd7\xc2\x9c\xf9\x34\xd3\xf1\xaa\xc5\x8e\x4d\xd6\x06\xb2\xf2\x04\xee\x1e\x5c\xe6\xe6\x06\x23\x64\x61\xd3\xc6\xb8\x4f\x9f\x8f\xf3\x96\x25\x43\x99\x0d\x94\xd2\xce\x39\x65\xc8\x97\xb2\x92\x0e\x2e\x4f\x02\x15\xdb\x8c\xe4\xdb\xa8\x42\x15\x76\xe5\x2a\x2d\xa1\xd0\xf2\x83\xf2\xe3\xe1\x7b\x6e\x1e\xde\x25\x37\xfd\x68\x4a\xb1\x71\x56\xf6\xce\xa5\x2b\xf7\x35\x96\xf4\x9a\x70\x4b\xf7\xdc\x15\xfd\x46\x56\xd7\x0d\xca\x1d\x9e\x96\x79\xcd\xed\xa3\x97\xfe\xd0\xf3\x59\x28\xce\xbd\x71\x59\xc7\xfe\x03\x77\x7c\xbd\x70\x0f\x5a\x4d\x9b\x86\x55\xf6\x1f\x33\xb2\xef\xf5\xd5\x8d\xcd\xed\x2b\xbb\x95\xf4\x29\x5e\xbb\x7e\xfe\x6b\xf3\x5e\x8a\x4e\x0a\x5f\x5f\xd8\xad\xbc\x68\x26\x74\xbe\xe7\xe0\x00\x55\x7d\xb8\x5b\xf9\xae\x5c\x78\x65\xcb\x9d\x3b\xd4\x41\x69\x15\x65\xbd\x07\x0e\x19\xd4\x67\xa4\xcf\x75\x18\x6e\x81\x27\xe7\x28\xc5\xd9\x3d\xc6\xd0\x76\x91\x91\x29\xfd\x6f\x15\xf7\xa9\x17\x4f\x9e\x57\xd7\xbd\x0a\xe9\xe3\x66\xcd\x19\x3b\x6e\xce\x02\x71\x6b\xbf\xe7\xdf\xfe\x41\x3d\xb6\x70\xe1\x4b\x50\xf3\xc2\xaf\x50\xd0\xb8\xb8\xa0\x5d\xa7\x4e\x45\x7c\x0c\x51\x52\x47\x88\x06\xd4\x93\x7e\xd4\x92\x03\xc2\x05\x59\x0e\x29\xd9\x5d\x48\x45\x92\x9f\xea\xf5\x25\xa5\x4a\x44\x0e\x76\x70\x17\x7a\x7c\x85\xbe\x8c\xc4\x8c\x9c\xda\x48\x86\x94\x90\xe8\x32\x58\x6b\x23\x06\x12\xe4\xf5\xa0\x5b\x2b\xba\x3e\x64\x84\xe7\x26\x08\xeb\x8e\x24\x08\x6e\x6d\x3a\x24\xaf\x54\xd3\x7b\x79\x66\xaa\x04\x20\x05\x74\x6b\x42\x89\xd1\xd5\xdb\x1d\x44\xc3\xb7\x47\xbd\x3b\xee\xaa\xac\x1a\xd2\xbb\x7b\xd8\xb5\xe8\xf3\x27\x96\xed\x83\xdc\x3d\x87\x1e\x7d\x70\xf9\xd2\xad\x7b\xbb\x87\x3a\x86\x4b\xdb\x95\xf5\x17\xeb\x9f\x57\xc7\x44\xb7\x0e\x0c\x2f\x5d\xe7\xde\x99\x75\x6d\x59\xa8\x27\x9c\x51\x47\x83\xbb\x81\xa6\xab\xef\x43\x2f\xf8\xe1\xde\xe5\xdb\xb6\xce\x2e\xed\x73\x5d\x97\x81\xea\xd2\x15\xdf\xf2\x31\x75\x66\xab\xf7\x40\x19\x4a\x26\x99\x24\x87\x14\x90\x23\xe1\x89\xc9\x00\x29\x29\x24\x49\x10\x48\x5e\x20\x90\x9a\x91\x61\x22\x0e\x8b\xc5\x94\x9b\x93\x6e\x34\xba\x6c\x26\x62\x6a\x5f\x98\x63\xa8\x8d\x64\x8b\x3f\x59\xc0\x62\x4d\x07\x6b\x5a\xf2\x4f\x0e\x70\x38\xc3\xb9\x5e\x67\xc7\x9c\x70\x4e\x55\x8e\xd0\xd1\x1a\xb6\x56\x59\x85\x20\xf6\x50\x9d\x0e\x67\xa6\x13\x7b\x75\x39\x56\xa7\xd3\x9a\x23\x98\xdc\xee\x82\x9a\x88\x5b\x30\xc5\xfa\xa4\x5e\x66\xc8\x31\xc5\x88\x1f\x64\x45\xe4\xd9\x6a\x6e\xa5\xf3\x73\x61\x9c\xea\x08\xc5\x79\xb8\x5f\x26\xae\x68\x30\x04\x6c\x5a\x03\x19\xeb\xd9\xf9\x59\x03\x83\xa6\x44\x1e\x6a\x97\xce\x50\x5c\xe6\xf7\x38\xfd\xb9\x01\xbf\xf8\xbd\x30\x6a\x49\xe8\x9b\xbd\xea\xf8\xd3\x68\xc4\x6f\xa0\x83\x9e\xba\xd4\x69\x7e\xe4\x94\x10\x0d\xd3\xd3\xa2\xfa\xe2\x73\x03\xa3\x73\xe8\xfa\xc1\xa7\xd4\x35\xc2\x85\x2e\x6b\xe6\xae\x8c\x7e\x24\xa4\xae\x19\xbf\xe6\xb7\xa5\x8b\xd7\xb4\x6f\x3f\x3e\x59\x8d\xd6\xd5\xc1\xdb\x13\x38\x5f\x4c\x6a\x6e\x2f\xed\x96\x03\x24\x1d\xa9\x36\x25\xdc\xc5\x64\x34\x3a\x13\x6d\x72\x72\x72\x96\x90\x82\x6a\x33\xc5\x9d\x28\xe6\xe5\xda\xb2\x52\xb3\x6a\x22\xcc\x70\x4a\x4c\x4d\x48\x10\x52\xc2\x49\xa9\x6e\xd9\x5a\x13\x31\x99\x64\x51\x08\xd4\x44\x44\x41\x24\x15\x67\x35\x71\xe5\xdf\xc9\x67\xb9\xde\x2c\x6c\x23\xa6\xa1\xb8\xbe\x9d\xdb\x41\x72\xb0\xc5\x4c\xe4\x63\x0f\x79\x4e\x14\xd5\x52\x36\x14\x2e\x8b\x8a\x27\x50\x9a\x4d\xdc\x6c\xdc\x42\xa6\x93\x60\x10\x74\xbe\xed\x35\x90\x6e\xa8\x2f\x3d\xb4\x6c\xe6\xd9\xeb\xff\x06\x0f\xd7\xa9\x9f\x1c\xbe\x4d\x7d\x53\x3d\xf4\xd2\xa5\xf7\x3e\xfe\x8e\xbe\x06\x95\x30\xcf\xbe\x61\x83\xf9\xc1\x47\x3a\x4f\xbd\xd9\xda\x78\x9f\x61\x60\x2f\x75\xb7\x9a\x3c\xf1\x36\xf3\x4b\x2f\xb9\x61\x35\xf4\xfc\x4d\x3d\xe7\x16\x6f\xb1\xab\x9f\x6a\x63\x57\xac\x63\x37\x82\xeb\xda\x14\x92\x45\x66\x86\xaf\x11\x68\xa6\xd9\x20\x66\x82\xc7\xc5\x9c\x16\x13\x12\x1c\x4e\x09\xbb\xb5\x16\xa7\x25\x90\xed\x70\x25\x29\x5e\x82\x7d\xb9\x54\x91\xd8\xcd\xdc\x72\x4c\x36\x24\x64\x62\x3b\x92\x20\x58\x5d\xc8\x57\xa8\x82\x99\x62\x62\x55\xa9\xb5\x10\xfa\xd9\x57\x71\x99\x4d\xa8\xdb\xeb\x9d\x3a\x3a\xb9\xfd\xe7\xf1\xb3\x4a\x75\x73\xdb\xd0\xcd\x8c\xf2\x76\x54\xf1\x43\x28\x37\x08\x8a\x0c\x2b\x5e\xba\x70\x0a\x96\xa8\xa7\x47\x7f\xb3\xff\xb1\x97\x1f\x8e\x2e\x7d\xe4\xd5\x7d\x07\xbf\x1b\xa3\x3e\x27\x54\xab\xbb\x47\x50\xbb\xba\xf2\x87\xde\x89\x29\x46\xbf\xf0\x38\x7c\xa8\xe6\x6e\xf9\x7c\x8b\x5a\x07\x0f\xb0\x63\xcb\xe7\x9f\xc3\xbc\xa3\xbd\x86\xa4\xde\xc2\xda\x14\x3b\x5f\x57\xf7\x3e\x5a\xcb\x2b\xc2\xd7\x75\x28\x2d\x35\x9a\xd2\x12\x4a\x7c\x41\xb1\x20\x90\x9d\xe4\x76\x0b\x76\x7b\x76\x81\x49\x2c\xeb\x1c\x08\xb4\xcf\x6b\x9f\x1c\xc4\xce\x15\x1b\x90\x02\x0b\xb8\xdc\x2e\xb4\x8f\xdd\xc9\xf8\x97\x67\xc9\xcb\xac\x8d\xe4\x59\xe4\xda\x88\x45\xdb\x8c\x29\xd8\xd2\x65\xd1\xbb\x2a\xae\x72\xdd\x6b\x46\xbb\x8c\x0d\x5a\x38\xb5\xc6\xb1\x38\xa6\x93\xfd\xb1\x61\x68\x2f\xf5\x67\x65\x97\x96\x94\x61\x99\xbb\x43\x05\x9b\x47\xd3\xcd\x24\x25\x4f\x1b\xbc\x4d\xd0\x64\x40\x41\x9b\x40\x8c\x34\x1d\xb3\xed\xb9\x7d\xcd\x23\xde\x03\xbd\xd4\xc8\xa7\xcd\x44\xae\x98\x9b\xb7\xf5\xd1\xde\xd1\xaf\x51\xea\xd6\x2d\x9a\x71\x87\xbb\x3e\xff\x9d\x33\xef\xfe\x64\x5c\xf7\x56\xfe\xea\xed\x33\xfb\xd2\x53\xf0\x55\x7e\xaf\x85\xeb\xd7\x2c\xcd\x51\x77\x5c\x3c\x13\x6c\xb7\xa5\x62\x4c\x27\xcf\x96\xc2\x1e\x33\x97\x2e\x98\xee\x3f\xba\xeb\xec\x8b\x45\x45\x5b\x82\x7d\x0b\x32\xb2\x18\xdf\x4f\x46\xbe\x5f\x28\x67\x12\x1f\x5a\x07\x63\xc3\x1d\xcd\x6e\x87\xd1\xeb\x4d\x95\x7d\xa8\x2e\x7c\x6e\xc1\x9f\x69\x4f\x93\xd3\xb0\xb9\xb5\x18\x95\xb0\x2c\x92\xd4\x9a\x88\x8f\x84\x13\x89\x0b\xcd\x03\x47\x4d\x84\x30\x72\x68\xde\x39\x4c\xd2\x19\xcf\x27\x9f\x65\x8e\xef\x57\xe1\xf7\x4e\x1d\xa5\x6c\xd4\x1e\x9c\xdf\x45\x37\x67\x77\x3e\xfe\x86\x9c\x0e\x1a\x9b\xd3\xb7\xd4\x4f\xd4\x17\xa0\x0f\x64\xde\x06\x3b\xef\x38\x5e\x78\x6a\x35\x28\x77\x3d\x30\x58\xfd\xe2\xf4\x6d\xea\x98\x2f\xcf\xbc\xf6\x89\xd3\x0b\x2b\x91\x5a\xdd\x61\xa1\xe7\xee\xbb\x12\xd4\x67\xae\xbd\x65\x95\xa9\xf1\xbe\x44\xb0\x0d\x3c\xf0\xbc\xf9\x25\x61\xe7\x5f\xd4\xb7\x52\xc4\x49\x5e\xf5\xa3\xe6\x66\x75\xa7\xf0\x0e\xcc\x97\x77\x63\x0f\xc9\xaa\x2e\x82\x0c\xae\x1b\x7b\x37\xff\x2c\xbf\x2d\xdd\xc5\xe7\x1a\x53\xb0\x77\xb4\x20\x5c\x69\xb3\x5b\xac\xd8\x39\xf7\x67\xe5\x67\x1d\x19\x9d\x9a\x9f\x28\x13\xf9\xc8\x68\x07\x21\x76\x6b\x96\x9c\x2f\x77\x2e\x25\x7e\x30\x4b\xfe\x9c\x9c\xf4\xfa\x48\x61\xce\xc9\xd1\x85\xc5\xf5\xd8\x47\x17\xed\x82\xc5\x65\x74\xd7\x47\x04\xe3\xc9\xd1\x42\x12\x9e\xdd\x44\x9f\x6a\xaf\x40\xdb\x90\x8b\x3b\x1f\x93\xe4\x14\x68\x9d\x73\x8f\xf7\xa4\x6a\x69\x85\xd1\x56\x0a\xb9\xe3\x5b\x5c\x47\x28\x66\x25\xe6\xb6\x19\xd0\x92\xdf\x7e\x64\xd7\x03\x0f\x6d\xdf\xfb\xe8\xb6\xc6\x6b\xd8\xf4\xfa\x96\x01\xa3\x47\x0f\xba\x71\xf4\xc8\xc1\x0d\x3b\x5f\xe9\x3d\xd6\x7c\xb7\x6d\xef\xaa\x27\x9e\x7e\xea\x89\xa5\x8f\xb8\x37\x98\x86\xdc\x70\xf3\x08\x38\x72\xfe\xbf\x3f\xff\xe4\xab\x8b\x5f\x47\x67\x4a\x2b\x9a\x3a\x1d\x7d\x78\x57\xfd\x81\xc7\x1e\xa7\xaf\xaa\x87\x06\x8f\x30\x2e\xda\xf6\xed\x87\xe7\xbf\xbb\x7b\x9e\xb9\x72\xd8\xa3\x5c\xff\xb9\x9b\x7f\xa0\x4b\xa5\x2d\x6c\x27\x32\x72\x43\x38\x37\x3b\x39\xd9\x6e\x31\xa6\x25\x26\x52\xd4\xf5\x79\xf9\x37\xe6\x83\x29\x29\xdb\x8e\x7f\x19\xd9\x94\x66\xd3\x6c\x39\xd3\xad\x10\x99\x04\xcf\x56\x68\x36\x09\xea\x7a\xc7\xd9\x62\x60\xe3\xb0\xf1\xb6\x2f\x33\x79\xd9\x6a\x07\x2c\x4b\x37\x90\xd1\xd2\x28\x73\xea\x93\x2e\x54\xc1\xe2\xea\xe5\x76\x76\x76\xc1\xd3\x93\xfc\xbd\x13\x16\x4c\x9f\xb1\x2c\x34\xe8\xc6\xd2\x55\x8b\x6f\xba\xe5\xe1\x3b\xc3\xf7\x76\x09\x85\x8a\x6b\x66\x0d\x7c\x6f\xc7\x83\x0f\xed\x3c\x9c\x92\x71\x7d\x46\x2a\xbd\xe1\xbe\xed\x0f\xdc\x7b\x4a\x7d\xe9\xc6\x9f\x27\xce\x13\x13\xa6\x2e\x99\x32\x5f\x95\xc2\x6c\x29\x1a\xd6\xef\xf3\x84\x18\xd8\x18\xab\x05\xb5\x1a\xeb\x05\x0f\x0f\x77\xc8\xf5\x59\x73\xd2\xdd\x16\x62\x94\x41\x10\x44\xd1\xe8\xb6\x8a\xed\xf2\x83\xed\x20\x25\xd1\x6e\x02\x49\xf0\xdb\x1d\x19\x0e\xea\x70\xe4\x64\x67\x2b\x44\x64\x5d\x5d\xe4\x5e\xfc\xaf\x66\x5d\xde\x8a\x10\x2b\x8f\x37\xae\xcb\xa3\xcd\x15\xfa\xc1\x8b\x2d\x53\x08\x72\x59\xaf\xad\xb5\x2a\x33\x85\xf8\x5a\x64\x2e\xa4\xb9\xd1\x8e\xf2\xee\x3f\xd1\x0f\x0c\x8f\x08\x9d\x9f\x3a\xbc\xef\xe9\x23\x07\x60\xf4\x43\x43\x6f\x9a\x38\x72\x44\xcd\xa4\x51\xaa\x83\x2e\x16\xf7\xaa\x4d\x23\xa5\x15\x8d\x83\x77\xcf\x16\x1e\x68\x58\x46\x8f\x3c\xff\xc6\xeb\xa7\x5e\x78\x5d\x5d\xb4\x69\xd5\x9a\x8d\x1b\x6f\x5f\x16\xfd\xe6\xbe\xfb\xb0\x5c\x19\xcd\x97\xa4\x3f\x60\x5f\xc7\x84\xf2\x16\x20\x21\x32\x2c\xdc\x3e\xdb\x82\xca\x8d\x2d\xac\x49\x68\x9f\x9a\x90\x5a\x5a\x92\x99\xff\xc7\x48\xa6\x68\x31\xbd\x1e\x41\xdd\x65\xf1\x51\x5f\xc7\x3f\x46\x7c\x6e\x6a\x7e\x3d\x42\x1d\x97\xcf\x96\x6b\x37\xf1\x4b\x36\x35\xfb\x85\x0d\x94\x30\x03\xa6\x10\x92\x62\x33\x8a\x80\xe6\x20\x1f\x20\x2f\x71\x65\x87\x8a\x45\x97\x52\x42\xb3\x03\x59\x22\xf5\x24\xb8\xc4\x50\x71\xb6\x8b\xce\xb8\x03\x46\xad\x7e\xe2\x91\xf5\xef\xfe\xa9\x6a\xe4\x88\x41\xf4\xae\x33\xea\xe1\x33\x7f\x50\x0f\x3d\xf7\x12\x54\x9d\x79\x09\x06\xbd\x38\x66\x9f\xfa\xd1\xfe\x7d\xea\xc7\xfb\x9e\x80\xac\x27\x9e\x80\xdc\x7d\x90\x27\x14\xae\x9e\x35\xf7\x0e\xb8\x53\xfd\xb8\x7f\x65\x9f\x7e\xea\x07\xec\x95\xd7\x61\xc0\x0b\x67\xa0\xea\xa5\x97\xd5\x23\x2f\x3d\x01\xfe\xfd\x4f\xa8\x1f\x3f\x8e\xc7\xbe\x7d\x90\x8d\xbc\xf9\x3c\x5d\xa4\x24\x61\xbd\xba\x51\x6a\x6f\x0c\x17\x7a\x12\xad\x26\x93\xd9\x49\xb0\x87\x60\x4e\x14\x52\xd3\x12\x7c\x49\xbe\x3f\x45\xec\x66\x89\x90\xc4\xcc\xc4\xaa\xc4\xe5\x89\x62\x22\x28\x8a\xd3\x92\x24\xf0\x0a\x75\x86\xde\x44\xdb\xa3\xb8\xf8\x2a\xc6\x32\xeb\x1b\xd8\x99\xe3\x5e\x9e\x9d\x0d\x14\x85\xdc\xde\x32\xec\xc7\x00\x37\x3c\xfc\x1e\x79\xa7\xd1\xfc\xcd\xcd\x7b\x06\x00\x2c\x3f\x75\xd1\xde\x6f\xdf\xc9\xc6\xfc\xdb\x9b\xe9\x9d\x74\x11\x9d\x96\x98\x19\x7d\x03\x1e\x7c\x2b\xc1\x19\x7d\x56\x50\xa2\x67\x0b\x5e\x84\x07\x9b\x7e\xa3\xdb\xa2\x93\xe9\xb6\x19\x33\x58\xbb\x73\x33\xb6\xaf\x27\xb1\xce\x02\x28\x4d\x39\xe9\x49\xb2\x39\xc9\xec\xb1\xdb\x4d\x82\x27\xd9\x2f\xf8\x73\xb2\xd3\x7d\x16\x83\x9c\x92\x9c\x52\x13\x31\x27\xbb\x08\x36\x35\x58\xcd\xb1\x21\x2e\x3e\x98\x12\xd7\x8d\x0c\x39\x5b\xc7\x0f\x32\x89\x13\x45\xa7\x02\x98\xbf\x1b\x33\xc9\x35\x8e\x73\x79\x99\xfb\x5b\x06\xf0\x79\x20\xc1\x05\x41\x18\x7d\xfe\x9d\x41\xcb\x7e\x8e\x1e\x3d\xfa\xdc\x8f\x1f\x7c\xf8\xe3\xb3\xc7\xa2\x47\x7f\x5e\x36\xe8\xed\x0f\x60\xb4\xb4\x55\x7d\x5a\xfd\xf0\x75\xf5\xe0\xad\x92\xfc\xc0\x67\x35\x90\x76\xf2\x5b\x55\xfd\xf6\x84\xfa\x65\xed\x67\x0f\xc8\xd2\x2c\x18\xf6\x27\xc8\x85\x1b\xb5\xf9\xf6\x91\xcd\x9f\x8a\xb7\x89\x95\x28\x4d\x19\x24\x1c\xce\xca\xb0\xd9\x44\x9f\xc7\x92\xe9\x07\x8b\xe8\xcf\xb4\x06\x33\x20\x23\x83\xa4\x1a\x1c\x4e\x39\x01\x3c\x09\x90\x40\x12\x49\x45\x71\x75\x35\x57\x09\xc1\x6a\xcd\xdd\xa6\xba\x65\xa8\x40\xca\xca\x65\x6c\xc4\xa4\xdf\xe5\xf1\x3b\xf9\xa4\x35\x53\x73\x6e\x27\xd3\x6e\x8a\x93\x4e\xdb\x75\x69\xcd\x5d\x3f\x6f\xba\xff\xe7\xdb\x9b\xfe\x50\xbc\x67\xd8\xea\xe3\x83\x2b\x6b\x3f\xba\x2f\xb4\x67\xf8\xd1\xb9\x59\x1b\x41\x79\xf0\x00\x90\x3b\xef\x56\xd5\xbd\xea\x03\x9d\xfb\x4c\x5e\x59\xb0\xfd\x36\x7a\x27\x78\x4a\x7b\xcc\x55\xbf\x67\xb2\x6f\x68\x7e\x4d\x19\x2f\x7d\xc7\x7d\x2e\x6c\xd8\xda\x2f\x09\x5f\x97\x9f\x62\x17\x48\xa2\xc7\xd3\x21\x4b\x34\x03\x55\x0c\x06\xd9\x42\x25\x73\x16\xb1\x1b\xcb\x3a\x77\x48\x61\x81\xfb\xeb\x23\xed\x72\xac\x72\x7d\xc4\x62\xb4\x5a\x45\xa3\x68\xc8\xc1\x3f\x81\xba\x5c\xbe\xfa\x48\xa2\xcb\x2d\xb0\xe8\xa5\xaf\xf2\x1e\xbf\xe3\x15\x3e\x18\xc2\x9b\x77\x66\xd0\x69\x93\x8d\xda\xdc\xf3\x65\xc3\xf6\x5c\x45\x18\x21\x60\x04\xc1\x8f\xd6\x7f\x08\xcf\xa1\xd8\x4c\xbd\x3e\x1c\x12\x37\xbe\xa8\xd5\x5f\x3a\x78\xd3\xa9\x7c\x6b\xe3\xd1\x7b\xc4\x01\x4d\x8f\x47\xd4\xd3\xd5\x77\x43\x9f\x3b\xa1\x87\xba\x70\xf1\xaf\xd2\x90\xfa\xbd\x5b\x8e\xa4\x2d\xcd\x3f\x35\xbd\xae\xcf\x80\xb3\xf3\xc3\x8f\x3f\xbc\x61\x6f\xe2\xf2\xa4\x23\xe3\xc6\x64\x5f\xb7\x62\xe9\xac\xb0\xf4\xdd\x6f\x9f\xca\x59\x4d\x73\x49\x73\xb3\x70\x4b\xd3\x7d\xf4\x1b\x75\x6d\x34\x6d\xe1\xea\x5b\x16\x26\xdd\x1b\xee\x59\xd2\xcd\x1d\xea\x3e\xa6\xe7\xdc\x25\x13\x67\x38\xe6\x95\x5d\x9b\xd5\x3e\xc3\x9f\xd9\x63\x1c\xf2\x67\x2d\x1a\x81\x35\x62\x57\x62\x24\x9d\xc3\x29\x8a\x40\x8d\x92\x44\x05\x6a\x32\x1b\x94\xaa\x88\xc1\x20\x10\x41\xac\x8a\x08\x1e\x6c\x28\x5b\xa6\x9a\x5a\x7d\xa1\x9d\x7c\xad\x42\x88\xfb\x17\xb2\x29\xff\x03\xc7\xa2\x40\x6f\x88\x7e\x4c\xb3\xc5\xae\x8d\xaf\xae\x87\x8a\x3b\xb5\xb1\xca\x2a\x6c\x6f\x17\xf3\xb1\x4a\x6d\x3d\x4b\x94\xfe\xc6\x7d\x8e\xe6\x0a\xbf\x45\xcf\xb2\xd5\x3e\xae\xa4\x96\x35\x18\x59\x98\x76\x8d\x74\x37\xa6\x9d\xf3\x1b\x4f\xcb\x3c\x5d\x58\x5a\x51\xd0\xd2\x06\x5a\xd3\x56\x35\xff\x22\x0f\xbc\x12\x2e\xa2\xfd\x66\xf4\x2d\x12\x0a\xfb\x45\x81\xda\x83\xf6\x19\x76\x0a\x96\xd3\x16\x70\x58\xc2\x96\x5a\xcb\x4c\xcb\x72\x8b\x14\xec\x01\xf8\x5b\x3b\x1f\x8b\x3e\x51\x0a\xac\x8b\xc2\x3d\x9d\x74\xb8\xdd\x38\xdc\xbb\x63\x10\x1d\x79\x1a\x44\xa7\x4c\xe6\xa2\xad\x84\x70\x41\xa0\xe9\xc1\xf4\x19\xe9\x94\xc0\x69\xe6\x51\x1f\x86\x5a\x98\x09\xcb\x41\x0a\x8e\x01\xf6\xdb\xef\xc0\xad\xd6\xf1\xbd\x02\xae\x41\xce\xff\x1f\xe0\x0e\xfd\x77\x70\x37\xc6\xc1\x7d\xa1\x0d\x5c\x65\x22\x21\x85\xe1\xa4\xb6\x70\x97\x03\x04\x7b\xfe\x2e\x3c\xe4\x89\x6b\x9a\x7f\x10\x9e\x14\x07\x62\x1f\x72\x7c\xb8\x87\xac\x28\x6e\x62\x75\x5b\x93\x53\x1c\xde\xaa\x48\x26\x5f\x1c\xfb\x76\xc2\x67\x09\xd8\x37\x70\xe8\x6b\x65\x5f\xc4\x07\x8a\x11\xbb\x0a\x89\x76\xee\x8a\x76\x4e\x16\x4d\x82\x2c\x9b\x4c\x42\x55\xc4\xe4\x20\xad\xb3\xb3\xd8\x1f\x1a\x1b\x5b\x12\xd1\xa2\x78\xe3\xec\x5d\x97\xd3\x41\x5b\x5d\x59\xe8\xdf\x57\xdc\x33\x65\xb6\xed\x99\xb4\x0b\x8f\x7f\x76\xe9\xa7\x2f\x0f\x7c\xee\xa9\xb7\xaf\xa8\xbd\xf3\x0e\x9a\xf5\xc5\x0b\x53\x47\xd9\xee\x3f\xa8\x7e\xae\xfe\xa4\xfe\x55\xfd\xfc\xd9\x07\x2c\x37\x4f\x7e\x87\xe3\x0e\x8f\x90\x3a\x79\x2c\xed\x45\xac\x2c\x56\x02\x31\x4b\x46\x4a\x25\xc9\x62\xb3\x53\xab\xc1\xc2\x83\x15\xb4\x64\xae\xf9\x87\x24\x7a\x03\xb9\x79\xa5\xcc\xa3\x5e\xf1\x7b\xe8\x8a\xf2\xee\x95\xcb\x36\x6c\x58\x56\xd9\xbd\x5c\xf8\x04\xda\x5d\xb7\x72\xcb\xf5\xd9\xd7\x6f\x59\x79\xdd\x70\x0e\xdb\xd1\xfc\x32\xbd\x24\x2e\xd3\x60\x1b\xcc\x66\xe4\x4c\xb4\x1b\xcd\xc4\x48\xb5\xa8\x0e\xc5\xe5\xe5\xc1\xf8\x05\x0c\xdc\xd0\x09\x25\x7a\x3d\x6c\x53\x57\x78\xaf\x15\x9a\xb0\xbb\x35\x9f\xa6\xc0\x95\x78\x9b\x09\xc7\xdb\x2a\xd9\xec\x06\x8b\x60\xbd\x1a\xde\xb9\x79\x0c\x30\x73\x77\x2f\xf3\x97\x4a\xcb\xe2\xe1\xc1\xb2\xdf\xc5\x3b\x2b\x6c\x13\xac\x48\x09\x24\x08\x31\x53\xa3\xb6\xf6\x48\x8f\xdc\x10\x5b\x2b\xd1\xb9\x8c\x81\x45\xa2\x24\x7a\x9d\x21\x5a\xd8\x0a\xeb\x91\x78\xe2\xc4\xe3\xec\x25\xd7\x86\x53\x88\x59\xa6\x46\xa3\xec\xb5\x38\x3d\x36\x9b\x53\x76\xfa\x92\x6c\x46\xa3\xd9\x23\x30\x45\x1c\x44\xf4\xdb\x0e\x1d\xbb\x7e\xaf\x0e\xe2\xca\x15\x5f\x1b\x54\x6d\xbd\x8e\xab\x97\x96\x8b\x36\xe5\xf4\xa2\x2e\xf3\xd9\x0d\x58\x43\x84\xe5\x4f\x7c\x49\x16\xaf\xcd\xe3\x6a\x5b\x51\xad\xc5\x8e\x33\x02\xe2\x6b\x2c\x8e\x0e\x71\x75\xd7\x72\x11\x5f\x87\x51\xda\x7a\x4d\x28\xe2\x51\xc9\xf1\x10\xd0\x4e\xe9\x1e\x4e\x75\x5b\x2c\x60\xb7\x8b\x49\x0a\x9a\x96\x62\x5a\xaa\x23\xc5\x95\x94\x88\x0d\x92\x5d\xb4\xca\x46\xc2\xf1\x08\x7e\x7a\xd6\xd1\xa6\x1a\x5a\x86\xef\x24\xec\x1b\xbb\x7f\x0f\x2b\x07\x7c\xa6\x66\xfe\xe1\x4a\xd4\x26\x57\x89\x23\x7f\x07\x39\xde\x9e\x77\x69\xfe\x5a\x78\x56\xfa\x03\xda\xf8\x05\x24\x12\x0e\x79\x0d\x69\x0e\xa7\x93\x64\x1b\x88\xa1\x7d\xa1\x37\x21\x39\xa1\x2a\x62\xc9\x1c\x14\xb1\x5b\x50\x4f\x26\xcf\x48\xbe\x98\x2c\xd8\x93\x4f\x27\x53\xa3\x90\x2c\xe5\x55\x45\xa4\xc4\x60\x7b\xa8\xd6\xba\xbf\x6c\xdc\x9b\x39\x5c\x14\x5e\xe6\x89\xa4\x2d\x62\x4b\x30\x69\xd3\x6c\x5a\x63\xef\x0d\x95\x69\x92\x5e\x86\x77\x2e\x81\x77\x65\xa8\x66\x24\xbb\x84\x67\x2b\x37\xbd\xbf\xfa\xe1\x83\xcb\xde\x5a\x3a\x74\x4d\xa6\x28\xae\x5c\x51\xba\xb8\x43\xf6\xac\x99\x2f\x9f\x7b\xd7\x39\xbd\xf7\xa0\xdb\x47\x8c\x1a\x3c\xf0\x8e\x1a\x61\xff\x2e\xf5\x0e\xf5\xeb\x4d\x6f\x1c\xdb\x0b\xdd\x1f\x9d\x30\x74\xee\x2b\xef\xe4\x07\x36\x75\x57\xbf\x8d\x36\x8e\xbc\x75\xb5\xda\xb8\xfa\xd6\xdb\xef\x07\x33\x96\x8f\xf9\x58\x7c\x8e\x76\xa2\x84\x16\xc0\xc9\xf0\x6d\x40\x4c\x26\x6a\x93\xa8\xe4\xb0\xcb\x12\xb5\x89\xb6\x9a\x88\xe8\x32\x65\xba\x13\x2b\x8d\x26\x70\x99\x88\xb0\xcc\x01\x41\x07\xd8\x1d\xd0\xec\x80\x8b\x0e\x38\xed\x80\xc3\x0e\xb8\xd7\x01\x33\x1d\x90\xe9\x80\x0d\x0e\xa8\xe0\xbf\x76\xd5\x7e\x3e\x17\xfb\xb9\x16\x15\xb4\x03\x6a\xf8\x6f\xda\x6b\x0f\xf1\xd4\xf8\x5a\x15\x7f\x93\x38\xa0\x75\xb2\x33\xce\x4d\xbb\x75\xde\x13\x0d\xa5\xb1\xd5\x85\x15\x6d\xa6\xb6\x5d\xda\xc8\x08\x84\xc0\xe3\x2f\xcb\x01\xec\x20\x63\xef\x1f\xa8\xe9\x02\xa8\x8d\x01\x10\x13\xd4\x27\xd3\x43\xd4\x98\x51\xa8\x1e\xc2\x1e\x83\xe5\xee\xbb\xed\xc2\xd8\x7e\x0f\x5b\x32\x67\x4c\x6d\x7a\x14\x75\xf7\x5f\xd4\x81\xd2\x41\x2c\xbb\xc2\x3c\x37\x05\x91\x28\xa2\x62\x30\x4a\xb4\x26\x22\xe1\x0d\x09\x16\x57\xb4\x59\xca\xc4\x3d\x4f\xfd\x4e\xf1\xe7\xa6\xfa\xd3\xe2\x19\x75\xa0\xbc\xf1\xb7\x19\x4a\xe8\xd7\xb3\x5a\x3b\xb0\x03\x61\x75\xe4\x3e\x80\xbd\xc3\xd9\x8a\x80\x76\x90\x81\x9a\x64\xa4\xaf\xc5\x2a\x88\x08\xb8\x26\x42\xb9\x3f\xa8\x91\x18\xd1\x70\xcd\xb4\x22\x5b\x68\x23\x22\xbe\x8a\x72\x3e\x30\xdd\x6a\x16\x69\xa3\x5c\xcc\x25\x19\x19\xda\x08\x7e\xcf\x0e\xba\x38\xba\x45\xec\xd9\x74\x84\x56\x46\xf7\x09\x8f\xa8\x03\xa7\x0b\x1d\x85\xf6\x53\xb7\x45\xc5\xa6\xdf\xb6\x71\xbf\xb9\x5a\xb1\x92\xfe\x1d\x65\x28\x31\x6c\xd2\xd6\xed\x1d\x8a\xc0\x51\x52\x51\xd8\xb2\xcc\xd2\xef\xb9\x49\xf8\x92\xd6\x62\xd7\x08\xfb\xf9\xba\xcf\xb1\x43\x56\xa2\x1c\xf7\xe7\xe0\x14\x2c\xa5\x3b\xf0\xfd\x40\x38\x81\xad\x21\x41\x00\x3b\xb9\x33\x0d\x85\xb0\x3d\x57\x5b\x51\xa7\xfb\x0b\x33\x60\xcc\x39\x18\x4e\x7d\xfc\x31\x7b\x37\xd4\xfc\x77\x71\xbc\x3c\x94\x18\xc8\xa3\xe1\x9b\x15\x20\xb2\x6c\xe0\x2e\xb7\x06\xa3\x49\xa2\x87\x23\x76\x09\x4c\x92\x04\xca\x51\x19\x0e\x9b\xe0\x5e\x13\xcc\x34\x41\x95\x09\x3a\x9a\x60\x83\x09\x66\xf0\x0b\x87\x09\x2e\x99\xe0\x46\x13\x04\x4d\x80\x1d\xcc\xf2\x9f\x4c\xf0\xb6\x09\x9e\x32\x01\x5e\x9c\x33\xb1\xd7\x36\xf0\xd7\x0e\xc7\xde\xd1\x92\xb6\x99\x2c\x1f\x1b\xbb\xd1\xe6\xc7\x83\x21\xe6\xb9\x3b\xb6\xba\x30\x4e\x87\x22\x5d\x99\xdf\x57\x00\xb0\x97\xe2\x86\x10\xbd\x65\xaa\xfa\x75\x3d\xd8\xfe\x0e\x4f\xae\xb0\x09\xbe\xb9\xd1\x81\xd2\x1d\x6c\x8c\x6f\x04\x79\x43\xaa\x16\xce\x13\x0f\x1f\xed\x1e\x1c\xee\x94\x91\xe4\x90\xb2\x44\x92\x6f\x26\xe6\x60\x87\xc4\xcf\x72\x20\xc7\x96\xfa\x53\x21\x14\x4a\x49\x59\x0e\x51\xa8\x30\x80\x21\xec\xf2\x54\x12\x43\x95\x81\x1a\xdc\x76\x1b\xd8\x08\xf6\x84\x3f\x66\x93\x5b\xde\xf2\xb3\xd5\xc5\x6c\x0c\x37\xc6\xac\x5e\xee\x81\xc3\xec\x5a\xa1\x75\xa8\x42\x9b\x67\xc8\xc9\x62\x53\x09\x9a\xa9\x2b\x71\x79\xd7\x57\x11\x54\x1f\x59\xf3\xc6\xea\x5e\x07\x46\xae\x7f\xf2\xe9\xb5\xaf\x2f\xef\x71\x68\xdc\x5d\x4f\xa8\x47\xfb\xcc\xef\x12\x9a\x3f\x60\xc8\xf4\xe9\x6a\x28\x34\x7f\xe0\xd0\x29\x93\x47\xf4\x59\x40\x07\xee\xfd\x04\x92\xd7\x6c\x78\xf7\xa9\x03\x1f\xa8\x5f\xaf\xdc\xf4\xfe\x90\xa5\x2b\x97\x2f\xdf\x38\x6b\xda\xa6\x86\xe5\xcb\x37\xcd\x98\x79\xcf\x52\xae\xf7\xb7\x11\x22\xd7\x8a\xaf\xa1\xbc\xfb\xc2\x46\xca\x16\xe1\x28\x14\xab\x3b\x18\x3c\xdb\x12\xb0\x89\x59\xa9\x1e\x3f\x6c\x1b\x2b\x4e\x6d\xec\x22\xbe\xd6\x78\xff\x58\x7c\x2f\xb1\x59\x15\xf7\x8b\x06\xec\x4f\x66\x84\xad\x6e\xb6\xae\xd1\x94\xe0\xb1\x4b\x66\xe6\x58\x5e\x1c\x8c\x5f\x27\x20\x39\x4b\x78\xe8\x22\x88\x39\xd9\xc8\x1e\x27\x24\xce\x79\x67\xe5\xaa\x77\xe7\x4f\x7a\x65\xf7\x23\x2f\x52\x4a\xb6\xfe\xb4\x66\xf5\xdf\x37\xab\x84\xd2\x53\x5f\x7d\xf1\x92\x4a\x34\x1f\xec\x5d\xea\x40\xba\x59\xfa\x92\x24\xc2\x03\xe1\x66\x5b\x42\x82\xa0\x28\x3e\xaf\xd9\x51\x15\x21\xe6\xb0\x99\x5a\x05\x6c\xea\xf1\x7a\x8e\x0f\x26\xfa\x60\xa8\x0f\x7a\xf9\xa0\xb3\x0f\x72\x7d\x90\xe8\x03\xd9\x07\x5b\x7d\x70\xbd\x0f\xca\x7d\xd0\xce\x07\x49\x3e\x30\xfa\x60\xd2\x6f\x3e\xf8\xce\x07\x1f\xf9\x60\xaf\x0f\xe6\xc5\xfd\x80\x0f\x9f\xf1\xc1\x13\x3e\xd8\xee\x83\x75\x3e\x58\xec\x83\x69\x3e\x18\xed\x83\x1b\x7c\x70\x4d\x2c\x99\xd9\x07\x8d\x3c\xe5\x05\x1f\xbc\xe1\x83\xe7\x7c\x70\x80\xa7\x5f\x1f\x97\xbe\x25\xbf\x14\x9e\xbe\xac\x25\x3f\xed\x85\x43\x3e\x78\xd0\x07\x77\xf3\x17\xa6\xfb\x00\x6a\x7c\x10\xf6\x41\x47\x1f\x64\xfa\xc0\xc1\xf6\x43\x85\x9f\x7d\xf0\x95\x0f\xfe\xcb\x07\xaf\xf8\xe0\x98\x0f\x76\xfb\xe0\x5e\x1f\xd0\xe5\x3e\x98\x19\xce\xf3\x41\xad\x0f\xaa\x78\xca\x8b\x3e\x78\xd1\x07\x4f\xf1\x04\x33\xf9\xf3\xa0\x0f\x32\x7c\x60\xf7\xb5\xfa\x8d\xe8\xc2\x50\xd3\x66\xb5\x4b\xcd\xd5\xd7\xbc\x5c\xb1\x36\x66\xd6\x65\xa9\x62\x8f\xf9\x04\x8e\xee\x35\xdc\xba\x70\x55\x9b\xac\x29\x15\x18\xfb\x6a\x7e\x81\x1e\x67\x82\x9c\x7d\x63\xd9\xb5\xe5\x07\xe9\x93\x7b\x47\xb4\xef\xd4\x73\x48\xe4\x49\x75\xa0\x7b\x93\xef\x3b\xf1\xf9\x83\xf5\xae\xcd\x29\xf3\x67\x37\xf6\x3c\x78\x82\xb5\xa7\x50\x25\xb6\x17\x7e\x46\xf9\x6a\x4f\x5e\x0d\x5b\xd3\x0d\x05\x2e\x83\xab\xa8\x43\x62\xde\xa1\x48\xfa\xc9\xe6\x17\x8f\x05\xae\xad\x4c\x4f\xc4\x8b\xa3\xde\xd4\x4a\x7e\x76\x24\xf0\x73\x38\xcb\x68\xa9\x4c\x0c\xb7\x0b\xb7\xbb\xb6\xb2\x9d\xdf\x9f\x72\x28\x32\xc3\x0f\xc4\xef\xf0\x53\xb3\xe0\x37\x87\x89\xe3\x50\x84\x4d\xd2\x1f\xcb\xbb\xb6\xd2\x40\xf4\xf7\x89\xfe\xbe\xee\x34\x6c\xa9\x24\x61\x17\x7b\xdf\x65\x36\x4b\x87\x22\x76\xf3\x39\x33\x35\x87\x31\x1d\x72\x97\xbb\x12\xa5\x9b\xeb\x64\xd4\x74\xac\xef\x5a\x98\xfc\x49\x61\x61\xe1\x2b\x85\x2d\x8e\x82\x97\x3d\x8e\x6f\x19\xd0\x0a\xe7\xad\x75\x29\xa3\x07\x93\xe2\x32\x8f\x0d\x84\xf8\xa7\x89\xad\x8f\xf3\x7b\x6f\xbc\x7e\xcd\xd0\x8a\xd9\x7d\x67\x6f\x99\xb4\xfa\x96\x5b\x8b\x56\xce\xee\x3a\x77\x18\x7f\x76\xdd\x9c\x1e\x33\xb6\x95\x2c\x5b\x99\xb1\x00\x1f\xf6\x9c\x45\x7f\x29\x4c\x2e\xca\x09\xdd\x3b\x34\x98\x9f\x39\x76\x4b\x41\xae\x3a\xaa\x7d\x72\xb0\x5d\xf0\xee\xa1\xc9\x1d\x2c\xfe\x31\x9b\x82\xdc\x16\x26\x3d\x48\x99\x98\x2d\x39\x50\x2e\xa7\x84\x7b\x58\xcc\x56\x93\x43\xc1\xbe\x97\x00\xd4\x62\x74\xd9\x24\xa3\xcd\xe8\x49\x70\x60\xab\x66\x38\x14\x11\x28\xa0\x66\x17\x0f\x45\x9c\x72\x86\x14\xe4\xeb\x98\x2f\x4a\x92\x64\xb5\x98\x4d\x76\x23\x54\x19\xdf\x36\x52\xb6\x0e\xb1\x9a\x0d\xa4\xbc\x55\xad\x0d\xfd\x84\xda\x4e\x5f\xc7\x1c\x54\xf8\xcc\x83\xdf\x8d\xfd\x58\x77\x88\x39\x29\xe0\x01\x2f\x6e\xdb\x78\xff\x5f\xa1\xec\x94\x6a\xa6\xdd\x76\x6c\xd8\x06\x1e\xf5\x91\xd3\x34\x0d\x46\xaa\x17\xc1\xbf\x19\x6e\xde\x0c\xd9\xea\xc7\x9b\xd5\xcd\x9b\x51\xc7\xd6\x91\x9f\xc5\xbe\x62\x95\xbe\x86\x65\x44\xb8\xc4\xac\x60\xe3\x88\xcc\x61\xb5\x30\x44\x8d\x46\x11\x44\xac\xa0\xa7\x44\xb0\x8b\x15\xe2\x0c\x71\x99\x28\x5a\x04\x91\x35\x6a\x55\x00\x9a\x8f\x27\x5b\x59\xc1\xab\x84\x4f\x9b\x5d\xd6\xdb\xd6\xc6\x13\x58\xa3\x07\xfa\x51\x27\x7c\xd9\x94\xa6\x1d\xc2\xf3\x9b\x37\x47\xbb\x6c\xde\x0c\x75\x88\x0b\x65\xfb\x8f\x89\xd9\xe2\x39\xbe\x7e\xe3\xfa\x70\x81\x44\x45\x85\x98\x28\xa1\x66\x8b\x82\xa8\x28\xd2\x8d\x72\x8d\xbc\x41\x16\x64\x21\x4c\xab\xe8\x72\xca\x88\x58\x25\x2e\x17\xa9\x48\x92\x50\xcf\x87\x50\xbb\xe3\x7f\x7c\x47\x5f\x6f\xbd\x81\xad\x51\x92\x30\xeb\x1e\x98\xed\x5e\x61\x54\x53\x0a\xb6\xbf\xf3\xcf\xc2\xfa\x1d\xea\x3e\x75\xdf\xf6\x1f\x36\x6e\xd4\xec\xcb\x1e\x6d\xf3\xa7\xb2\xa0\x10\xa3\x4c\x64\x3d\x7f\x21\x2c\xb2\xec\xb0\xf4\x37\x92\x1a\xb2\x01\x49\x26\x4b\x0c\x0f\xd4\xa1\xff\x2e\xff\x32\x66\x3d\x00\x2f\x7a\x0f\xcc\x7b\xaf\x56\xf4\x1f\xb6\xc3\x48\x18\xb9\x43\x9d\x7b\x36\xba\x2e\x96\xff\x83\x98\x7f\x99\xb8\x02\xed\x40\x23\x69\x1f\x4e\xa0\x06\x89\xc8\x22\x41\x53\xc5\x6c\x12\x00\xd0\x88\x91\xd0\x12\x3a\x1b\xd4\xd6\xbe\xc5\xaf\x21\x0d\x39\x8d\xe0\xcc\xf1\xe3\xf7\x83\x70\x16\xce\x36\xd5\xd3\x06\x75\x95\xba\x8a\x2e\xa6\x72\xb4\x21\xba\x66\x30\x95\x61\xbf\xca\xfb\x54\x58\xdf\xc7\xc4\xbe\x68\x9f\x48\x24\x25\x6c\x41\x78\x2c\x8e\x12\xf2\x21\x20\xe4\x16\xc4\x11\x67\xee\x66\xce\x6a\xea\xc9\x63\xb4\xfb\x7d\xea\x50\xf6\x2e\xcd\x8a\xee\x10\xfe\x2c\xef\x47\x7d\x91\x8c\xb6\x0d\x18\xc0\x9b\xe8\x34\x6b\x0d\x56\x6b\x88\x41\x08\xc4\x86\xc8\xd9\x4c\x32\x97\x3b\x45\xf6\xd0\xe3\x9b\xf6\x2d\xad\xb8\x21\x94\x93\x6e\x75\xe4\xfa\x1d\xd9\x46\x39\xba\x43\x19\xfe\xca\x2f\x15\x1d\xf3\x4b\x4c\x86\x82\xbc\xbc\xc0\x14\xad\x1f\x2c\x45\x77\xd0\xe3\x98\x47\x02\xcb\x83\x26\x18\x12\x3c\x2c\x0f\x72\x59\x1e\x21\x67\xeb\x0c\x84\x37\xd1\xcb\xc7\xa5\x68\xd6\xa6\x3d\xab\xaf\x19\x58\x9c\xed\x4f\x36\x65\x64\x38\xd2\xbc\xf2\xfe\x5f\xf7\xbd\xfc\xcf\x6e\xc1\xbc\x52\x87\xd8\x2e\x27\xb4\x8c\xb7\x6b\xbf\xd0\x1c\xe9\x38\xad\xc7\xca\xf3\x1d\x17\x78\xf8\x82\x93\x40\x8f\x44\xa0\x89\x59\x68\xda\x42\x2f\x01\x6b\xca\x24\x9d\xa6\x39\x5a\xbd\x00\x7c\x10\xdd\x44\xa7\x28\x95\xf8\x8e\xf7\x28\x15\x44\xe1\x24\xc8\xc7\x46\x0b\x2a\x69\xe0\x83\x4b\xa0\x21\x14\x80\x0f\x36\x6e\x54\x2a\x7f\xb9\x81\xbf\x43\xef\x8e\x6e\xe2\xf9\x48\x24\xf7\x28\x32\x0a\xe6\x22\xd7\x8f\xa6\x8a\xa4\x12\x81\x67\x48\x9a\xb4\xf1\x52\x7c\x5d\x07\xc1\x1d\x9c\xe9\xdd\x42\x7e\x74\xca\x46\x5a\xbf\xb1\xf1\x16\x0d\xdf\xe8\x26\x21\x5d\x87\x43\x25\x59\xe2\x70\x90\x2d\x54\x2a\x71\x38\xf4\x72\x38\x02\x5f\x34\x6b\x12\xf2\x37\x62\x01\x1a\x3e\x11\xef\xd3\xf1\x61\xe5\xc6\x32\x48\x24\x3b\x06\xe7\xd8\x68\x51\xe1\x50\x8e\x31\x28\xb1\xc2\xb4\x14\x88\x39\x3c\xdd\xbd\x91\xde\xdf\xf4\x81\x52\xd9\x78\xcb\x46\x8d\x76\x42\x3a\x87\x91\x7b\x54\xa2\x32\xd5\x71\x11\x1a\xfe\x1d\x2e\x21\xa7\x89\xde\xcf\x70\x11\xef\x6b\xf8\x24\x8e\x36\x08\x47\x21\x45\xc7\x25\xc6\xd8\x1a\x75\x44\xa3\xa2\x5e\x86\x4f\x2b\xb0\x56\x63\x88\x11\x09\xd1\x42\x2a\x71\xbc\xe2\xe9\xc4\x61\xb6\x3f\xa6\x88\xd4\xc0\x90\x0b\x1b\x47\x13\x83\xac\x22\x7e\x4a\x1b\xfc\x62\x30\x5b\x30\x0c\x70\x1c\x35\x24\x7f\xb9\x01\x49\xc6\xe1\xf1\xfa\x53\x48\xf0\xb8\x60\xc4\xce\x88\xd2\x0a\x90\xad\xad\x8e\xe3\x1a\xe6\x02\x1e\x87\x25\x63\x1f\x5e\x05\xd2\x69\x56\x93\xc8\x45\x8d\xb7\xb0\x5a\xd0\x79\x8f\xe3\x18\x3c\xae\x60\xe7\xa6\x15\x49\xa1\x81\xd1\xe1\xdf\xc2\x64\x9e\x76\x1e\x4e\xca\xfb\x39\x9e\xac\x4a\x62\x78\x22\x4c\x33\xb9\x26\x6c\x54\xac\x92\xc1\x80\xea\xd2\xcc\xe0\x9a\x47\x13\x8b\x09\x0b\x6f\xc0\x96\x15\x21\x1f\x8d\x48\xac\xfc\xba\xcb\x7a\x0b\x09\x9c\x6d\xe0\xfb\x75\x52\x70\xf2\xc6\xb2\xd1\xd0\x27\xb4\xf9\x17\x98\x25\x1d\x17\xa6\xf2\xb6\xa2\x43\x98\x7b\x35\x11\x51\x34\x48\x22\xaf\x33\x29\x1a\x2b\x41\x63\x6c\xc6\xa6\x35\xb6\xa7\xa0\x2b\x7f\x24\x4a\x43\x0f\x94\xad\x0b\x1b\x37\xaa\xdb\x74\xbd\x07\x17\xb0\xee\xfe\xcc\xe5\x4b\x21\xf9\x47\x25\xd1\x80\x00\x95\x63\xa3\x35\xc6\x10\xeb\x47\x2b\x02\x92\x1c\xf9\xa1\xb8\x22\xd4\x86\x43\x03\xfc\x40\x50\x30\x59\x13\x3d\xe3\x71\x14\x3f\x9d\xbf\x10\x4f\x23\xb9\xf6\x38\x76\xff\x50\x9b\x6b\x74\xa6\xb2\x6c\x36\xaa\xa2\xc2\xd1\x15\xa3\x31\x49\x6c\x6c\xf5\x55\x6a\x99\xea\x74\xea\x12\xe9\x89\x93\x4a\x4e\x14\x61\xea\xc6\xf3\x1b\x9b\xb2\xb8\x5e\xb8\xa0\xf3\x88\x91\x74\x39\x2a\x1b\x4d\x46\x44\xf6\xd8\x68\x2a\x99\x90\x87\x95\xfa\xd1\x60\xa6\xb2\x51\xc6\x2c\x8e\x47\x8c\x4d\xa2\x41\x25\xdc\xf9\x86\x84\xf4\x12\xe8\xa5\xf0\xe8\x4b\xdc\x9d\xd2\x71\x35\x0d\x41\x73\xc9\x67\x64\x97\x02\x31\xda\xf0\xb2\x48\x58\xc3\xbd\x8e\x1a\x65\x8b\xcc\x69\x23\x10\x8b\x46\x1b\x6a\x30\x58\x65\xcc\x99\x9e\x88\xc8\x51\x73\xab\x7a\xd1\x0b\x15\xaa\x68\x9d\xbe\x8d\xd7\x33\xfa\xf7\x05\xe1\xe3\xa6\xe3\x48\x3e\x3a\x07\x33\xc7\xa2\x35\x3c\x2b\xce\x60\xa5\xd3\xe5\x89\xd3\xb0\xeb\x31\xa3\x2c\x98\x04\x8d\x84\xd8\x17\x37\x19\x54\x59\xe0\x24\x94\x1b\xa9\x51\x13\xac\xe8\x55\x48\xa8\xd5\x7a\xa9\xb6\x88\xdf\xc4\x88\x87\x3a\x09\x66\x61\x19\x1b\xda\x09\x9f\xc6\x64\xf6\xcf\x9c\x7e\x5d\xaf\xa0\x5f\xd8\x34\x9a\x98\x90\x6a\xf2\x95\xb2\xd6\x96\x82\x42\x2c\x48\x00\xea\xbc\x8f\x19\x01\x35\xad\xa7\x31\x2d\xd5\xf2\x68\xa1\x9f\xd9\x60\x31\xf0\x5c\x88\x60\x11\x78\x2d\x89\x46\xa3\xc5\xa4\xd1\xcf\x14\xa5\x8a\xca\x99\xf9\x48\x44\xfa\x7d\xfa\xb1\x91\x87\x52\x36\xd9\x58\xea\x17\xfe\xbc\xb1\xe9\x38\x9d\xb3\x51\x4d\xa3\x73\x84\xa9\x0d\xed\xa4\x3e\xbc\x6c\x1b\x19\x0f\x32\x59\x41\x9e\x36\x92\xf2\xe3\xc8\x77\xbc\x74\x4c\xc7\x19\x0c\x66\x5e\x5d\x48\xbd\x68\x4c\xd9\x35\xb6\x28\xbb\xc2\xb6\x0c\x18\x8a\xad\x7c\xd1\x35\x9e\xa6\x8c\x9b\xb2\xb0\x98\x9c\xff\x74\x7d\x62\x24\xa5\x47\x29\xcf\x01\x39\xc3\xc0\xe9\x87\x45\x14\xcd\x06\x06\xbf\x3e\x42\x0d\x4d\x44\x6e\xe0\x6e\x90\x85\x6d\x99\x4f\x13\x79\xcc\x4b\xe8\xb1\x11\xbe\x6c\xca\xde\x78\x9e\xab\x54\x29\xc0\x94\x2a\xf2\x9e\x5e\x06\x8d\x76\x06\xae\x57\x14\x56\x43\x16\x89\xf3\x9e\x49\x14\xad\x06\x33\x2f\x83\xa1\x91\x17\xe6\x38\xb2\x82\xac\x89\x6a\xdb\xe2\xc4\x67\xa8\x7f\x5f\xd8\x28\xdc\xd0\x94\x8d\xa2\x0b\x5f\x46\xef\x52\x2a\x1b\x9e\xdd\x28\x9d\xc7\xa2\x31\xbe\x80\x59\x5c\x97\x6b\xbc\x47\x4d\xb4\x95\xf7\x94\x86\xff\x2d\xef\x85\x34\xde\x43\xa5\xc6\x79\x4f\xf8\xb4\xa1\x9d\xae\x8b\xb9\xce\x61\xbc\x47\x14\x93\xc2\x4b\xa6\xf1\xb9\x88\xbc\x07\x26\x83\xd8\x20\x53\x0a\xad\x0d\xc7\x55\x78\x0f\xb4\x0c\x18\x01\xff\x8c\x45\xf9\x52\x63\x3f\x9d\xf9\xb8\xbe\xe4\x79\xc4\xd3\x2f\x9e\xf7\x8c\x00\x2d\xbc\xd7\x28\xca\x0d\xb1\xdc\xa2\xbf\x2f\xbb\x2c\x3f\x7f\x48\xe3\xbd\xa6\x6c\xe1\x86\x8d\xaa\xb2\x31\x7a\x17\x7c\x89\x65\x93\xfa\x34\x72\x85\xda\xda\xbe\x9a\x49\x8f\x7a\x24\x9f\x49\x6f\x10\x8c\x8c\xfb\xac\x66\xf5\xdf\xf1\x5f\x5b\x1d\xd8\x86\x07\x5b\xda\x5d\xbd\xed\xe5\x6c\x88\xba\x42\xd7\x51\xbc\x5d\x33\x93\x8a\xa3\x5a\x76\x4c\x35\xc9\xb2\x62\x61\x84\xc5\xa6\x48\xb4\x2a\x66\x95\x18\x2e\xb7\x14\x42\x2d\x04\x75\xb6\xe5\x49\xae\xda\x39\x57\xa2\x62\x62\x2d\x85\xde\xd6\x73\x0d\xcf\x62\xae\xc4\xf2\x64\xf1\xef\xec\xa4\xaa\xde\x62\x30\xd8\x8d\x0e\x4d\x04\x08\x38\x80\x63\x60\x93\x65\xa7\xc5\xce\x0b\x69\x69\xe4\x7a\x3f\x6c\x44\xc5\x6f\xa2\x0d\x46\xe0\xfa\x38\x74\x15\x36\x0d\xe9\x56\x2c\xf7\xef\x62\x93\xea\xdc\x12\x9a\xba\x71\xe3\x79\xae\x25\x39\xbb\x46\x37\x19\x8f\x23\xc3\x36\x65\x19\x8f\x33\x96\x8d\xb3\x3f\x90\x02\xc7\x19\xcf\x5a\x4c\x5a\x1b\x8c\x4c\x8b\xad\x70\x3c\xdb\x9a\xaf\x60\xdb\x38\xbe\x6d\xc3\xb8\x81\x16\xd6\x8d\xf1\xee\x2f\x37\x08\x9f\x6a\x6b\xdd\x7f\xd1\xdb\x4c\x46\xf3\x6e\x3a\xcd\x95\xe3\xa3\xd1\x2c\x63\x2d\x84\xc8\x5b\x7f\xb3\xac\x1a\xae\x30\x7e\x5a\x49\xde\xc6\x48\x0b\x30\x1c\x02\x26\xe4\x61\xde\x9a\xb6\x98\x42\x52\x80\x11\x5c\x68\xc9\x4f\xa3\xf7\x8d\xf5\xb2\xc9\x64\x34\x3b\x34\x86\xa6\x82\x43\x63\x68\xc5\x6a\x75\xd8\x2d\x9c\xa1\xed\x51\xc1\xac\xc6\x9a\xbf\x46\x22\x72\xfd\x73\x35\xae\x8e\x69\xba\x80\x36\x21\xeb\xd6\x14\x6b\x0f\x6e\x1f\x30\xce\xde\xc8\xb5\xab\xd6\xba\x23\x83\x6b\xfa\x95\x6a\x76\x0f\xea\x75\x56\xfe\x9e\x27\xcc\x82\x60\x15\x39\xb3\xa1\x8e\x35\x20\xc9\x8d\x06\xad\xb2\x8d\x8d\xf1\xe6\x5a\x34\x26\xc6\x6d\x14\x6d\xbc\xd1\xa6\xdb\x28\xc8\xe0\xd1\x29\xd2\x69\xa4\x3a\xd6\xb1\xf0\x29\xa3\x48\x9c\x4d\x68\x26\xe1\xe3\x82\xb5\x45\x9e\xc5\x16\x2e\x27\x16\xd9\xa4\x1a\xae\x30\x0f\x2f\xd3\x1b\xf1\xf9\x05\x34\x43\x51\x6b\xfa\x75\x53\x51\xb7\xb7\x84\x96\x32\x4a\xdc\xe3\x6b\x08\xb6\xfe\x0e\xd6\xfa\xa3\x20\xdb\x04\xc1\x21\x51\x07\xe5\x5c\x6e\x35\x18\x9c\x76\x1b\x57\xf5\xf6\x46\x23\xef\x9f\xe0\xa5\x2c\x46\xcd\x3a\x93\xc7\xd6\x9a\xc6\x17\x59\x97\x36\x4e\xed\x90\x26\x71\x1e\x7f\x29\xb2\x39\xa3\xb6\xc6\xe9\x74\x4e\x43\x0f\xac\xf5\x4f\x19\x0d\xa4\xf3\x5c\xb7\xe8\x36\xa0\xce\x77\x3d\x4f\x10\x83\xc1\x22\x51\x8b\xd6\x13\x50\xcc\x66\x6b\x0b\xdd\xa3\xf1\x26\x6d\xe3\xbf\xa3\x3b\x17\x30\x4e\x77\x6e\x78\xea\xe6\xa1\xf0\x29\x0a\x16\x37\x11\x5b\xed\x66\x46\x77\xcc\x22\x66\x03\x69\x19\x6b\xac\xae\x08\x0d\xc6\x2b\x4c\xe8\xab\xd3\x5d\x9f\x36\xc3\xfc\xb8\xc2\x86\x2f\x5b\x54\x36\x37\xa9\x19\xdd\xe3\xda\x3d\x3b\x19\x7c\xc2\x68\xb1\x38\x0c\x2d\xcc\x2e\x39\x34\xfb\x4e\xb4\xdb\x9d\x56\x0b\xa7\xb5\x35\x2a\xf1\xe6\x97\x35\xb6\xa6\xc6\xd6\xc6\xb6\x2d\xd9\x5b\x4b\xdd\xda\x0e\x96\xfa\x59\xc9\xb9\xa2\x8b\xde\xa5\x73\xbc\x9a\x26\x9d\xe6\xea\x55\x9c\x81\x0c\x8f\x0a\x7e\x63\x9c\x9d\xef\x26\xa3\xc2\x56\xb3\xdd\xee\xb1\x1a\x1d\x0e\x99\xba\x13\xdc\x4c\xcf\x58\x99\x9e\x49\x70\xa1\x9e\xb1\x88\xdc\x82\x39\x11\x31\x4a\x8d\x0e\x8d\x11\x8f\x46\xac\x8c\xf3\x63\x8b\x55\x5b\x3b\x00\x31\x9d\xe3\x8c\xeb\x06\xe8\xaa\xa7\x75\xc5\x6d\x4c\x05\xb5\x68\x7e\x5d\x15\xe9\xea\x5f\xd3\x47\xf1\xf8\x0d\x0f\x1b\x45\x8f\xcb\x68\xb4\x5b\x12\x90\x3a\xe2\x09\xa4\x98\xe4\x36\x24\x18\x34\x11\xb1\x26\x10\x07\x56\x95\xd5\x66\xe5\x58\xba\xa8\xad\x89\xb5\x0c\x7c\x8d\xd6\x65\x75\x16\xef\x75\xd8\xda\x30\x68\xd1\xa5\x4a\x5b\xcd\x16\x2e\x3b\x6a\x1a\xab\x4c\xbd\x91\xd0\x6a\x93\x57\x2a\xf3\xab\x6b\xc1\x8d\xd5\xa7\x93\x78\xc9\xf4\x7a\x6a\xb7\x4b\x16\x9f\x85\xa1\x64\x19\xed\x31\x1a\x7d\x09\x66\xb3\xd7\xe0\x63\xb6\x21\x6b\x26\x6d\xb6\x24\xc9\x93\xe8\x61\xac\x6c\x8e\xd0\xc4\x46\xe2\x6a\xb0\xc7\x2a\xd8\x62\x8a\x3a\x95\x78\xb9\xd2\x2f\x2e\xf7\x92\x8c\xd7\x6d\x6c\x58\x2e\x5e\xd2\x42\xba\x8e\x63\x95\x7e\x3e\x4e\xe2\x74\x06\xe0\x95\xdf\xf0\xac\x26\x79\x5c\xeb\x69\xf3\x5a\x84\x4e\x97\x0e\x70\x1d\xec\xaa\xe7\xb1\x6c\x1a\x58\x4c\x93\x96\xde\x8a\xd3\x2f\x1d\x68\x18\x26\x1d\xa0\xd3\xc5\x8f\xb4\xf4\x58\x6e\xbc\x6b\x4d\xcf\xf4\x41\xf0\x8a\xf4\xd1\x4d\xe2\x87\xad\xe9\x39\x7c\xf7\x09\x1d\xbe\xda\x1a\xff\x26\xfe\x05\xe3\x71\x3d\x3d\x7d\xff\xaa\xe9\xf9\x3c\x2a\xa6\xa7\xef\x47\x0b\xf0\xd0\xd2\xd3\xf7\xe2\xe0\x83\x48\xa4\x2b\xd3\x23\xec\x96\xf4\x05\x64\x52\xf4\x9f\xd2\x01\x79\x4f\x4b\x7c\x1d\x37\xf7\xf6\x8e\xad\x10\x0c\x92\x10\x29\x23\xd7\x90\x0a\x72\x1d\xe9\x4b\x6e\x20\x37\x92\x21\x64\x04\x19\x4d\x6a\xc8\x04\x32\x89\x4c\x23\x33\xc8\xad\x64\x3e\x59\x4c\x96\x91\x55\xe4\x0e\xb2\x9e\x6c\x20\x9b\xc8\xfd\x64\x27\x79\x88\xec\x61\xfb\x2e\xb8\x43\x9e\x40\x8e\x7e\x48\x71\xd7\xca\x7f\xf0\xdc\xfb\x7f\x48\x0f\xff\xe6\xda\x79\x95\x63\xd2\xe4\xc9\xb0\x0b\x8f\xdd\x93\x26\x45\x37\xe2\xf9\x21\xed\x38\x37\x69\x92\x5a\x3b\x79\xb2\x3a\x7e\xf2\x64\xd1\x8a\xe7\x71\xda\x71\xae\x35\xf5\xb9\xab\x3e\xfd\x1d\x18\xe7\x5a\x9f\x36\xbd\xd4\x7a\xdd\xf8\x8f\xd6\x37\xd9\xb9\xf5\x23\x65\x8d\x67\x9f\x71\xb5\xad\x9f\x09\x57\x5e\x8f\x63\x9f\xf1\x63\xd9\x67\x3c\xbf\xd6\x1e\x2b\x7f\xe5\x2f\x43\x80\xdf\xa9\x17\xc7\xab\x17\x6b\xd5\x4f\xf0\x7f\x9c\xfa\xe9\x38\xe5\xc7\x5a\x32\x14\x79\xeb\xff\xbb\xba\x3f\x40\x0e\x93\xa3\xe4\x04\x79\x8e\x9c\x26\x2f\x93\xd7\xc8\x1b\xe4\x1c\x79\x97\x9c\x27\x1f\x91\x8b\xe4\x4b\xf2\xdf\xe4\x2f\xe4\x27\xf2\x0f\xf2\x2f\xec\x43\x37\x83\x00\x0a\x98\xc1\x0e\x6e\xf0\x42\x0a\x64\x40\x00\xf2\xa0\x10\x82\x10\x82\x32\xb8\x06\x2a\xe0\x3a\xe8\x0b\x37\x30\x87\x43\xc6\x4f\x65\x57\x39\xa4\xff\x1f\x9e\xe7\x5c\xf6\x2c\xc6\x8b\x79\x57\x39\x94\xdf\x81\xe3\xfd\x5f\xa6\x87\xff\xe5\x73\xb7\x0e\xcb\xfb\x3f\x9c\x9d\x7a\xda\x49\x9c\x29\xf1\xff\x6d\xfe\x8f\x17\x8d\x77\x21\x53\x6b\xff\xda\xd3\x49\x93\x9a\x46\xfd\x1f\x52\xc1\xae\xf8\x34\x2f\x4d\x9a\x24\x3c\xd6\x36\x11\xfe\x4f\xba\x02\xd8\xa4\xff\x20\x4d\xe3\x3f\xfe\x13\x1c\xb4\x57\x27\xfd\xde\x37\x3b\xeb\x52\x36\xfe\x0a\x59\xab\xfd\x1d\xb9\xfb\xdd\xe7\xe3\x5a\x3f\x9a\x3c\x8e\x8d\x93\xca\x71\x71\xb2\xd9\x46\x42\xc7\xc7\xcb\x69\x6d\x4c\x5a\xc7\xe9\xc0\xf1\x40\x60\xec\x16\x93\x63\x22\x82\xd2\xc8\xda\x90\xf7\x50\x6e\xaf\x27\x03\xc8\x20\x32\x8c\x44\x48\x35\x19\x47\x6e\x22\x53\xc8\x74\x32\x8b\xcc\x25\x0b\xc9\x12\xb2\x82\xac\x21\xeb\xc8\xdd\x64\x23\xd9\x42\xb6\x93\x07\xc9\xc3\xe4\x31\xf2\x04\x39\x44\x9e\x26\xc7\xc9\x33\xe4\x05\x72\x86\xfc\x81\xbc\x4e\xce\x92\x77\xc8\x7b\xe4\x02\xf9\x84\x7c\x4e\xbe\x26\xdf\x91\xbf\x92\xbf\x91\x7f\x92\xdf\x48\x14\x00\x24\x30\x82\x15\x9c\xe0\x81\x24\x48\x03\x3f\xe4\x40\x3b\x28\x82\x4e\x50\x0a\xe5\xd0\x0d\x7a\x40\x6f\xb8\x1e\x06\xc0\x20\x6c\x74\xd0\x4e\x28\x0d\x5c\xe5\x08\x79\x7e\xef\x08\x78\xb0\x33\x72\xe5\x01\x97\x25\xf4\xe2\xb3\xbc\xb8\x43\xb9\xec\x77\x09\x9f\x95\xc5\xdf\xe3\xe1\xc7\x43\x29\x0d\x78\x72\xf0\xec\xc6\x73\x20\xee\xb8\xfc\xfd\xff\xf1\xf7\xcb\xf2\x87\xcb\xef\x2f\xc3\x33\xf6\xbe\xa2\xe3\xc5\xf0\xf1\x22\x5c\xef\x65\xf0\xdd\x97\xdf\xeb\xef\xc7\xce\xd2\x7b\x0d\x85\x53\x5b\x3f\xd3\xd8\x1f\xfb\xc4\xce\xb1\x4f\xc3\x96\xd6\x47\xef\xe3\xff\xd4\xa9\xef\xe1\xbf\xfe\x2c\xfa\xfd\x54\xfd\xc7\xa6\xfd\xd3\xa0\x62\xda\x7b\xd3\xe0\xc0\xb4\x56\x30\x71\xb0\xda\xde\xb7\x00\xa2\x89\xfc\xe6\x3d\xfe\x4f\xff\xc2\x52\xb4\x64\x30\x8d\xc1\x56\x87\xe3\x2f\xef\xc5\xde\x6e\x39\xb3\x34\xd3\xf8\x4b\xd1\x4d\x90\x35\x8e\xfd\x07\x6a\xc1\x3f\x9e\xff\xb7\x91\x9e\x33\x2d\x8d\x12\xfe\x8f\xc5\x6f\x79\x6a\xec\xa7\x17\x2f\x17\xc8\x17\x63\x17\x2f\xc7\xcb\xc9\x15\xf2\xd6\xfa\xa8\x25\x95\x7c\x36\x26\x63\x31\x49\xc7\x5c\xf5\x2c\xc6\xb5\x80\xd6\xc0\x9e\x69\x01\xa6\x01\x6a\x05\xc0\x5f\xd6\x6c\xc4\xc5\x64\xae\x38\x4a\xd4\xe2\x1d\x02\x91\x78\xd8\xbb\x60\xcc\xf5\x08\x2d\xac\xc5\xc2\xc5\x26\xbf\x38\xb4\xc9\x4f\x28\x61\x41\x8c\xcf\x89\xaf\xf3\x36\x36\x3d\x6c\x11\x89\x02\x04\x0c\x46\xcd\xe3\xea\x6c\x1b\x47\x12\xf6\xaa\xdb\xc9\x56\xf6\xbd\xde\x58\xd6\x5f\xec\xc4\x4e\xe2\x92\xc6\x73\x62\x27\xcc\x73\x3a\x2c\xa3\x53\x84\xc5\xdc\xe7\xc9\x28\x50\x49\xa4\x55\xc0\x22\x31\x56\xc7\x32\xe6\xa6\xe0\x14\x55\x84\x26\x58\x86\x9d\x33\x36\xd7\xd9\xfa\x8e\x42\x0a\xc2\x89\x92\x20\x53\x81\x1a\x0d\xcd\x32\xc8\x54\x61\x03\x38\x55\xda\xbc\x32\xa2\x31\x2b\x7e\x7e\x5f\x8f\x3b\xa8\x41\xeb\xaf\x3e\xc0\x00\xaa\x55\x30\x5e\xdd\xa5\xdb\xc8\x84\x18\x08\x9d\xcc\x6d\x5e\x56\x7e\xc2\x96\x22\xc7\x42\xdc\xe3\x8b\x7e\x03\xf9\x15\x7f\x8f\x6e\x23\x00\xbb\xd8\xde\x50\xe2\x93\x88\x8d\x87\xed\xa3\x48\x04\x36\xb1\xad\x27\x67\x73\xeb\x7e\x23\xa6\xa1\x23\xe9\x70\xf1\xc9\xc6\xc1\x98\x7e\x63\xf3\xd7\xf2\x28\xf1\x20\xa6\x67\xb0\x45\x81\x50\x77\x2b\x6c\x04\xb0\x91\x53\xe5\x60\x74\x57\x94\xc7\x20\x82\x5d\x98\xbe\xbf\xb8\xa9\x15\xbe\x28\x50\x70\xb7\xc2\x37\x52\xb9\x7f\x74\x7f\x74\x9f\xb8\xa9\x71\x30\xa2\xc1\xdf\x89\xcf\x83\x50\xcc\x03\xe2\xf2\x40\x8d\x27\x8f\x62\x59\x34\x96\xd3\x9b\xb4\x39\x63\x03\x76\x58\x7f\x94\x76\x13\x16\xe7\xae\x53\xd8\x8b\xf5\x27\x88\x06\x41\x96\x25\x85\x1a\x25\x2a\x99\xcc\x32\xde\xb3\x50\xc0\x15\xf1\x4e\xac\x4e\xaf\xbe\x14\x28\x60\x84\x90\x51\xa4\x81\xc1\x6a\x19\xbc\x3e\x18\xde\x50\x6d\xea\x2e\x18\x0f\xb5\xf4\x1c\x7d\x27\xda\x89\x96\x46\xdf\x88\xbe\x44\xbb\x63\x3e\x8f\x93\x47\xc4\x0e\x62\x3b\x1e\x63\x02\x79\xc5\x41\x7c\x06\x62\xc8\xf4\x27\x58\x52\x45\xe4\x95\x8f\xdb\xf0\x4a\xcc\xe7\x88\x45\x84\xc8\xea\x00\x65\x09\xcc\xe1\xa2\x3b\xf0\xa8\x11\x59\x36\x78\x7c\xc1\x3b\x0b\x17\xfd\x79\xe1\xc2\x77\x16\x2f\x7a\x7b\xc1\xf0\xf1\x8f\x4f\x18\xff\x44\xdd\xf8\x03\xe3\xc7\x3d\x31\x9e\xd6\xb1\xe7\xef\xe2\x4f\x0b\x16\xbc\xbd\x68\xfc\x13\xe3\x6a\xf7\x8f\xc7\x5f\xc6\x3f\xc1\x43\xfc\x92\xf1\x64\xb8\x58\x23\x0e\x46\x8e\xb1\xf3\x35\x1d\x79\x68\x07\x96\xa1\x0d\xd8\x17\xed\xbf\x11\x68\xfb\x4d\x42\xbb\x6f\x3e\xda\x7c\x04\x12\x02\x59\xa5\x25\xa1\xe2\x3c\xfd\xec\xd6\xcf\x5e\xfd\x1c\xfb\x5d\xb9\xec\xfe\xf2\xf3\xe5\xbf\x5f\x7e\x9f\x73\x19\xfc\x58\x7e\xc2\x07\x25\x5d\xba\x94\x6c\x66\x5f\xff\x2a\x2b\x2d\x2b\xcd\x66\x57\x6a\x59\x67\xfc\x1c\x2a\x2b\x2d\x2d\xa3\x83\xd9\x77\x34\x99\x3d\xa0\xab\x5a\xd2\x46\x9f\x2c\xe9\xd2\xb9\x33\x4f\x0c\x7f\x64\xbf\xa9\x63\xd8\xf7\xbf\x58\xe2\xcd\xec\x4a\xd8\x8a\x5f\xed\xf1\x4e\x7d\xb7\xac\xac\xf4\x4b\xbc\x81\x4d\x78\x31\x8a\x01\x9b\x8f\x5f\xf0\x4c\xe7\x50\x79\xb4\x17\x5e\x6d\x2f\x29\xe9\x42\x53\xf5\x44\xaa\x80\x17\x5f\xb1\xd7\xde\xeb\x52\xd2\xa5\x00\x2f\x34\x59\x39\x42\xd6\x89\x01\xa1\x81\x58\x99\xdc\x8a\x26\xbb\x4d\xb1\x33\x09\x8a\xad\x7d\xd1\xc3\x7d\x24\x90\x40\x16\x29\xc5\x3a\xa5\x53\x6f\xb9\x30\x5b\x55\x4f\xd4\xab\xea\x8c\xf3\x42\xc3\x9c\x0f\xa7\x9e\x50\x55\x10\xea\x6f\x7e\x6f\xbe\xc6\x8b\xed\x50\x9f\x1c\x14\x59\xdc\x50\x37\xe3\x11\x0b\x15\x81\xe2\xfb\x0e\x30\x5c\xa1\x4f\xb0\x07\xec\x84\xcb\xf8\xa2\x9d\xb8\xaa\x49\x9c\xf7\xc6\xfc\x79\x67\xe7\xcd\x7b\x13\xbf\xe7\x8a\xab\x1a\x97\xd0\x1e\xf3\xde\x9c\x87\xd7\xf8\x70\x3e\x8b\xb4\x1a\x9f\x47\x80\xed\x7b\x62\x49\x4d\xa5\x62\x42\x02\xe6\x94\x93\x6d\xc8\x04\x87\x0f\xf3\xfa\xe4\x2d\xfc\x6f\x13\x01\x5e\xcf\xf1\x32\xce\xcc\xbb\x0a\x06\x83\xc6\xef\x1f\x37\x0e\xd9\x8e\x7f\x0f\xb8\x12\x9d\x96\xdf\xf0\x3b\x1e\x35\x2c\xff\xad\xb0\x86\x4e\x10\xe6\x22\x3d\x93\x48\x7e\x38\xc1\x46\x12\x14\xa2\xa4\x24\x3b\xc3\xa6\x7b\x4d\x34\xc3\x04\x26\xaf\xc0\xe8\x50\x5d\x1d\x4f\x09\xee\x83\xa8\x07\x73\xf4\xb6\xae\xb1\x67\xeb\x08\x26\xdc\x3f\xae\xd7\xcc\x5e\x9b\x6e\x9a\xd4\xb7\x5f\xff\x89\x7d\xfa\x4c\x1c\xdf\x6f\x40\x0d\x5d\x32\xed\xee\x1e\xb3\x7b\x4f\xda\xd8\xaf\xef\xa4\x3e\x13\x27\xf6\xe9\x7b\x13\x73\x9c\x90\xe0\x69\xd4\x1b\x0b\x51\x6f\x98\x89\x8f\x64\x93\x8e\xa4\x2b\x99\x19\xae\xb0\x74\x4d\xca\xe8\x5c\x98\x93\x91\x43\xdc\x32\x91\xaf\xbd\x26\x3f\x35\xab\x43\x56\x69\xa7\xc9\x9d\x20\xd2\x09\xfa\x76\x82\xa4\x4e\xd0\x29\xd4\xc5\x9e\x55\x93\x35\x23\x4b\x30\x74\x09\x1b\x6d\x95\x59\x5d\xb2\xba\x08\x76\x16\x07\x3d\x91\x21\xfb\x71\xb5\x1e\xb3\x61\x6c\xb5\xe3\x6c\x48\x5b\x14\xcf\x97\x4a\x5e\x16\xa9\x4e\x0b\x20\x40\x94\x2c\x92\x57\x42\xfc\x99\x44\x29\x21\x79\xcc\xef\x23\x81\x78\x8b\x49\xfc\x72\x51\x29\x7e\xe9\x28\x0b\x5e\xe4\x65\x6e\x22\xf2\x42\x75\x5b\x53\x54\xdd\x01\xa8\x7b\x28\xfe\x8d\x1f\xa5\xbe\xf5\xc1\x87\xf7\x6f\x87\xe2\x0f\x2e\x40\xc7\xe8\xe8\x0e\x99\x99\x45\x45\x99\x99\x1d\xe0\xdd\xf6\x99\x99\xc1\x60\x66\x66\xfb\xe8\xf7\xfd\x37\x6d\xec\xdf\x7d\xfc\x33\xcf\x8c\xa7\x95\x2a\xb6\x03\x30\x31\xda\x00\x53\xd5\x2d\xbf\x5d\x80\x62\xd8\xb1\xfd\xc2\x07\xea\x5b\x00\x25\x30\x3c\xb3\x43\xec\x65\x7e\x56\x4f\xaf\x5b\x17\x78\x96\xed\x49\x24\xc2\x3b\x48\xb3\xed\x9c\x66\x6c\xbd\x65\x11\xa9\x0b\x97\x67\x5b\x5c\xf9\xe9\x3e\x97\x0f\xc9\x45\x3a\x04\xfd\x1e\x7b\x8a\xbd\x5d\xd1\xe4\x22\x88\x14\xc1\x0d\x45\xd0\xad\x08\x8a\x0a\x73\x59\x64\xb8\x1a\xfb\x0c\xbb\x68\xb8\x31\xb7\x26\x97\xda\x73\xed\xb9\x46\xa4\xd5\x9b\x7c\x1d\x29\xd2\xe9\xad\x56\x3a\xc5\xc2\x1e\xba\x5a\x5d\xa1\xe2\xa9\x24\xc5\xd5\x76\x4e\xfc\xea\x4b\x46\x98\x3c\x4e\x98\xed\x97\x11\x26\x4a\xae\x42\x8b\x27\x19\x19\xba\xf7\xdf\xb8\xa9\x7f\x5b\x5a\x2c\x8a\x2b\x38\x3b\xab\x1f\x3f\xfb\x6c\x80\xed\xbe\x41\xa1\x4f\xf3\xad\xb2\x4d\xbc\x86\x14\xa0\x06\x5d\x1a\xbe\xae\xd4\x61\x56\x4c\xb4\xa0\x20\x31\xa9\x43\x6e\x56\x5a\x20\x90\x64\x12\xca\xbb\x14\x16\xd0\x02\x8b\xd9\xec\xcf\xea\x94\x94\x98\x64\xc8\x29\xb0\xa7\x67\x25\x15\x64\x25\x25\x65\x15\x08\x90\xea\xbc\xe8\xfd\xc9\x4b\xbd\x79\xf2\x0c\x6c\x82\x37\x68\x8d\x35\x5f\x79\x1a\x8b\x84\xc6\xca\xcc\x8a\xed\x38\x8b\x9c\x83\xc2\x8f\x17\x2d\xc1\xf0\x42\x2d\x6b\x6c\xb5\x9d\xcc\xd2\x81\x6d\xdf\xc2\x43\x24\xc8\x6c\x17\x17\x1b\x65\x01\x04\x72\xf3\x94\xbc\xb2\x5c\x16\x70\xa9\x33\xdb\xe0\xa5\x73\x99\x57\x27\x50\x19\x73\xcd\x15\xd6\xf5\xec\x39\xe1\xda\x67\x8b\x4e\x0e\x97\xcf\x9f\x77\xde\x70\xb2\x53\x7d\x76\xbf\xee\xa5\x3d\x17\xd6\x3d\x5f\x58\x3f\xd0\x71\xfe\xbc\xa5\xea\x58\xfe\x0b\xb7\xcc\xca\x58\x7f\xe6\xe5\x75\xeb\x6b\x27\xbc\x22\x5e\x73\x41\xce\x2b\xaa\x2f\x3a\x39\x6b\x4e\xf7\x25\xb5\x98\x28\xb9\xc0\x61\xb8\x70\xc1\x79\xfd\xb1\xa2\x93\x75\x4b\xba\x2f\xaf\x41\x08\x03\xac\xdd\x5e\x5d\xbb\xf6\x95\x71\xe3\xee\x5c\xfb\xaa\xe6\x9b\xf0\x21\xa9\x12\x73\xc5\x15\x28\x55\x79\x64\x4c\x38\x94\xed\x30\xbb\x6c\x36\x0f\x49\xf3\x8a\x22\x31\x0b\xed\xf2\x5d\x1e\x9f\xdd\x67\xfb\x89\x34\xa3\xfc\x67\x66\x64\x06\x33\xa9\x2f\xd3\x97\xa9\x84\xdd\xe0\x4e\x0a\xe7\xe4\x57\x26\x29\x28\x45\x85\xc1\x6a\x6d\x95\xb1\xe3\xec\xac\xe2\x98\xf8\x78\xe3\xb6\x83\x60\x54\xd0\x17\xd5\x79\xb5\x88\xae\xda\x58\x27\x9b\x10\x41\xbd\xd4\x52\xe8\x0e\x40\x3f\xee\x3f\xad\xd7\x93\xb3\xe7\x0d\x19\x7e\xef\x54\xc0\x5c\xfb\xa1\x0a\xa6\x81\x2e\x63\xca\x17\x0f\x1e\x71\x4d\xb7\xf2\x6a\xda\xd3\xdc\x7f\xd1\x0d\x4b\x1f\x1b\x3e\x64\xd1\xf4\x47\xac\x7b\xfb\xa8\x0d\x20\xf7\xa1\x1b\x4b\x6b\xca\x87\x2f\xec\xde\x6d\x68\xd7\x9a\x12\xad\x5c\x83\x48\x83\x78\x18\xcb\xd5\x9e\x74\x21\xdd\xc3\xfe\x8e\xed\xc5\x0c\x21\xaf\x73\x82\x3f\xcf\x5f\xde\xb5\x7d\x46\x41\x88\x64\x2f\xcf\xa6\xd9\x45\xf7\x9a\xc1\x6c\x2f\x00\x43\x01\x09\x8e\xad\x7e\xb3\x5a\xd7\x07\x2d\xfb\x4c\x6a\x5e\xd4\xb9\x79\x28\xd0\x65\x9d\x43\x5e\x8e\x65\xa8\xd8\xc3\x04\x3f\x03\x12\xec\x3c\x62\x8b\xd2\x1a\x63\x1d\x4b\xa7\xc4\x78\x9c\xd5\x60\xf3\xa6\x42\x83\x2c\x1b\xfc\xbd\xae\x19\xd9\x2e\xdb\xea\x90\x1d\x16\x51\xb4\xb9\x73\xb2\xad\x7f\x1d\x7a\x78\xce\x9c\x43\x4f\x2c\xea\x3b\x64\x47\xe4\xb6\xa5\x23\x22\x8b\x6e\x13\x49\x61\xa1\x64\x35\x18\x45\xd1\x69\xb5\xd8\x52\xae\x1d\x3f\x30\x94\x69\x94\xe5\x1e\xa3\x8a\x7f\x1c\x34\x7d\xc9\x93\x7b\x16\x2d\xd8\x5f\x98\xb9\x28\x52\x33\x6f\xc9\xc8\x11\x2c\x8e\xfa\x35\xcc\x75\x5e\x3c\x47\xfc\xa4\x63\x38\xc9\x95\x6a\xf6\xda\x65\xd9\x9b\x2a\x64\x05\x8c\xf6\xa4\x8c\xa4\x60\x92\x60\x48\x4a\x72\x32\xb7\x32\xe6\x9b\xde\xd6\x9b\x0e\xd8\x72\x46\xf0\x72\xff\xb5\x74\x9a\x01\xfe\xb2\x62\x16\xa4\x31\x16\x79\x17\x1b\xc2\xcc\xa4\xda\xfb\xef\xee\x43\x57\x8e\x78\x70\x82\x70\xe3\x9e\xd5\x86\xa6\x6f\xe5\xdb\x0e\x8e\x18\xb5\x3f\xb2\x32\x32\x61\xfd\x6a\xf1\x5c\xed\x13\xeb\x97\xae\xee\x5b\xbb\xfc\xf4\x43\x7b\xc7\x1a\x73\x72\xc6\x1d\xdc\x68\x3b\xbd\x7c\x4c\x64\xed\xe0\xf9\xcf\xb2\x76\xf7\x5a\x54\xd8\xa2\xf8\x1a\x29\x21\x5d\xc2\x69\xd4\x5e\x92\x8f\x2a\xc7\x2e\x96\x76\xce\x2e\x34\x04\x13\x32\x45\x73\x86\x19\x5c\x66\x97\x19\x52\x98\xed\xae\x31\x0e\xa3\x74\x2b\x96\x9d\x3a\xb6\x83\xb2\xee\x42\x69\x9e\xd6\x8c\x31\xac\x8a\xbd\xbc\x16\x34\xcf\x3b\xa5\x73\x59\x8c\x93\x78\x33\x97\x2e\x78\xc5\x3e\x4d\xf5\x86\x3b\xe6\xd7\x94\xd2\xf2\x23\x91\x01\x2b\xfa\xdc\x57\xdd\xbd\x2e\xd7\x69\x7e\x64\xd6\x9c\xdd\xbd\x87\x3a\x12\xf3\xa6\xf4\xba\xfe\x81\x39\x5d\xe6\xd5\x74\x93\x3a\x4d\x5f\x36\x3b\x90\xd2\x79\xc1\x96\xfe\xc1\x05\xf3\xfa\x2f\x1d\x70\xeb\x2e\x08\xf5\xc8\xcf\xc9\x5d\xb8\x75\xf7\xb4\xe1\xe3\xf3\x05\xc3\xc0\xfe\x73\xe6\x3c\xd6\x69\xf0\x94\xa5\xdb\x17\x94\x7a\x58\x79\x26\x36\x7f\x87\x7d\x8e\x85\x28\x23\xa9\x61\x0b\x5b\x73\xa7\x08\x49\xc9\x56\x87\x89\x91\x37\x54\xde\x12\xda\x5d\xea\x00\x41\x88\x85\x2d\xf6\xea\x71\x22\x64\xc5\x06\x74\x7c\xe2\xe8\xa7\x46\xdd\xd0\x79\xfd\x4d\x23\x36\xe4\x66\xdd\x33\x72\xdc\x86\x91\x33\xee\x5a\xe1\x1d\x5e\xff\xc3\xe2\xba\x15\x3d\xa7\xad\x9b\xbd\x60\xfe\xdc\xb5\xe3\x87\x9f\x5a\x77\xf4\x3d\x6e\xb7\xf4\x6c\xfe\x6f\xe1\xcf\x48\x3f\x0b\xc9\x08\x5b\x4c\xb2\x40\x88\xd5\x26\x98\x4c\x32\xaf\xce\xa4\x60\x28\x16\x4d\x9d\x2d\xd1\x22\x5e\x99\x28\xb9\x34\x37\xaf\x33\xa1\x4a\x25\x18\x17\xf5\x52\xdf\x1a\x92\xf3\xcc\xe6\x61\x73\x40\x10\x5f\x5b\xa2\xde\xbf\xae\x8f\x3a\x65\x73\x5f\x90\x4e\x4f\x5c\x07\x11\xcd\x2e\x7a\x85\xa4\x09\xd7\xa0\x6c\x24\x91\x0e\x61\x8f\x49\xa2\x36\x5b\x52\x42\x92\x24\xa4\x24\x5b\x29\x35\x18\x88\x97\xf3\x0d\x5b\x24\x7c\xb9\x1f\x26\x6a\x32\x46\x74\xb6\x97\x4b\x49\x6e\x5e\xbc\x8f\x22\x7c\xd7\x7f\xfb\xf4\xb1\xc1\xf2\xd9\xe1\x4d\xd3\xca\xbb\x2e\x19\xd8\xbe\x83\xb8\xa2\xee\xcc\xa6\xfd\x5b\x17\x2e\x5f\xb0\x60\x97\x59\x95\x17\xdf\xdf\xb9\xc3\x80\x39\x6e\x2e\x9b\x8e\xe6\xf7\xc4\x9f\xc4\x3b\x48\x2a\xc9\x44\x9d\x93\x90\x6e\xb1\x90\x34\xbb\x3d\xd9\x93\xac\x10\x31\xcb\x6f\x4b\x4b\xb3\xa6\x9f\x6c\xfe\x8c\x79\x53\x33\x37\xed\x70\x82\xc1\x5c\x99\x9e\x9e\xea\xca\x4c\x49\xc9\x48\x35\x65\x8a\x20\x8a\x3e\x17\x6a\x9d\x10\xeb\x3d\x69\x51\x4b\xca\x83\x85\x85\xda\x55\xdc\x72\x5f\xd6\x16\xb5\xae\x7d\xf0\x3a\xa5\x16\x84\xbd\x78\x97\x03\x39\xa5\x92\xf8\x53\xe7\xc5\xd7\x97\x97\x2f\x1a\xd8\xb1\x20\xfa\xe1\xba\x5b\xcb\xbb\xde\x76\x63\x51\x11\x7d\x36\x7a\x2f\xcd\x8d\x7e\x08\xbd\x06\xce\x1a\xda\x39\x38\x68\x86\x0b\x5e\xdc\xa2\xce\x9b\xbb\xb3\xb4\xa8\xff\x02\xc1\x4d\x2f\x1d\x51\x27\x6d\x99\xbb\x4d\xb3\x09\x8b\x9b\xbb\x08\x6f\x49\x6f\xf2\xb1\xdb\xc9\xe1\x32\x5f\x86\x4b\x96\xed\x66\x25\x39\x91\xd2\x54\xb7\xa0\x08\xc4\x6a\x24\x46\x7f\xa6\xd7\x91\x98\xe6\xb2\x58\x53\x92\xc5\x0c\x83\xd1\x68\xc8\x10\x93\x53\xac\x16\x57\x5a\xa2\xc3\x22\x24\x28\xac\x0b\xf7\x4a\x50\x6b\x56\x5a\x3e\xa1\x36\x16\x88\xa6\x48\x5b\x2c\x11\x16\xbc\x8b\x45\xcb\x52\x4a\xcb\xf8\x11\x72\xe6\xe0\x51\xe6\x51\x9c\x65\x12\xfe\x20\xbc\xf5\xc7\x5a\xf5\x58\xed\x1f\xf1\x53\x0b\xfd\xd9\x59\xfd\x40\x3d\x06\x2f\x44\xb0\xed\xec\xb6\x5b\xdd\x09\xdd\x23\x0f\x45\xe0\x9f\xec\xab\xaf\xfa\xd9\x6e\x18\xa3\xbe\x81\xd7\xaa\x39\xb2\x1c\xfe\xb9\x5b\x35\x33\x1e\x49\x42\xfd\x12\x94\x56\x10\x0f\x99\x1f\xee\x6b\x75\xda\xcd\x6e\x37\x61\xf1\xdc\xd9\xae\x04\x09\x82\x37\xd1\x26\x2b\x72\x6d\xc4\x85\x9d\xda\xda\x88\x5d\x08\xbb\x13\x2b\x89\xe0\x10\xa8\x10\x36\xdb\x95\x0c\x25\xa8\xdc\xa8\xd4\x28\x3f\x29\xb2\x51\x50\x14\x82\xd6\x83\xbb\xa6\x65\x5b\x00\xac\x2c\x3d\x8a\x6c\xe1\x55\xa2\xc8\xb6\x2e\xb1\x0b\xc5\x82\x0b\xc5\x4d\xd7\xf9\x3d\xfb\x58\x1c\xa1\xd3\x3c\x16\x34\x1e\xf4\x8f\xf0\xd5\x9a\xcd\x6b\xa0\x59\x05\x3c\xa9\x27\x1f\xe0\xfc\x9d\x8a\x5f\x07\xb1\x4e\xdc\xa4\x36\x5c\x66\x75\x3a\xdd\x3a\xe2\xac\x10\x68\x1a\x23\xe6\x55\x1c\xf3\xaa\x36\x98\xeb\x88\x73\xaf\x3f\x2c\x76\x45\x45\x39\x36\xf6\xaf\xb6\x45\xb2\x6d\x6c\xa4\xcb\x90\x0c\xe9\x81\x4d\xef\xbc\x05\x3f\xc7\xd8\x17\xb5\x20\x56\x34\x2b\xfa\x29\x9e\xa2\x3f\xf3\x79\xc4\x7f\x20\x5d\xc3\x3c\x56\x6b\xdf\x70\x8e\x35\x29\x89\x49\xb5\x3b\x59\x48\x4b\xa5\x46\xa3\xcb\x9e\x98\x28\x2d\x77\xb1\x3d\x4b\x5d\x2e\x6c\x7d\x49\x52\x1b\xaa\x15\x26\xbf\xc9\x97\x6b\x06\xe3\xc9\xc5\x50\xc8\xc3\x36\x87\x6d\xe1\xed\xc5\x5f\x79\xf8\x9a\x10\xd7\xed\x48\xad\x0f\x03\x79\x29\x2b\xe9\xb4\xa1\xb9\xa7\x53\x93\x33\x92\xe5\x95\xa3\x6a\xfd\xa9\xf4\x71\xfa\x8c\xd8\x31\x38\xf9\x36\x81\xf6\x8c\xce\x93\x82\x1d\x67\xcf\x96\xd4\x82\x07\x90\x97\x93\x11\xb7\xef\x11\x37\x1b\xd6\x7e\xff\x70\xbe\x5d\xf6\xba\xcd\x66\x1b\x58\x2c\x1e\x19\x95\x83\xd7\x54\x13\x49\xb4\x11\x5b\x6d\x84\xcd\x55\x78\x09\xb5\xb8\xa8\xab\x26\xc2\x02\xd0\x69\x08\x96\xc7\xc2\xed\x14\xc6\xe1\x17\xd2\x63\xbf\xfa\x8b\x45\x4f\x82\xa8\xc5\x8c\xca\x71\xb4\x03\xad\x42\x33\x93\xef\xa1\x83\xfe\x0a\xa2\xda\xf8\x99\x3a\xfe\xf4\x3d\xa2\x43\x3d\xa9\xae\x41\x76\x7c\x14\x56\x41\x58\xb4\xc3\xec\x4f\xff\xc4\x22\x72\x0a\x77\x0e\x00\xe7\x85\x35\x6f\x21\x8e\x6c\x2f\xeb\xc9\x3c\x2e\x52\x26\xa9\x0a\xb7\x23\x5e\xaf\x2f\x11\xdc\x69\x69\x82\x60\xb3\x19\xdd\x42\x96\x3f\x91\xa6\xd1\x9a\x48\x5a\x1a\xb1\xdb\x53\x59\x34\x66\xb3\x5c\x13\xe1\x2b\x87\x5e\x89\x8b\x4d\xdf\x36\xd4\x04\x8f\xc5\xcc\xb7\xc0\x00\xbf\xb3\x65\x07\xf9\xdc\x52\x0d\x69\xb6\x11\x2f\xda\xae\xc8\x7c\xc5\x9d\xc5\xbb\xd4\xfb\xd4\xeb\x83\x25\xd7\x16\xf7\xe9\xbe\x62\x3d\xbd\xff\x47\x10\x4e\x3c\x0c\xf7\xfe\xfa\xf8\x83\xea\x35\x70\xf6\xfe\xc7\xe8\xf5\xd1\x7e\x83\xfa\x3b\x76\x39\x37\xaf\x95\x6d\xef\x9d\x7a\xf0\xfd\xd4\xe8\xc3\xc2\x0f\x8b\x57\x44\x7f\xbd\x9b\x88\xa4\x4a\x1d\x29\xde\x8a\x7c\xd9\x0e\xfb\x2f\x9d\xb1\x05\xdf\x14\xae\x2a\x0b\x74\xe8\xe0\xf3\xb8\x4a\x42\x20\x11\x77\x42\x42\x9a\xcf\x6a\xb3\x09\xd8\x07\xec\x24\xf8\x84\x6e\xd7\x86\x0a\xf2\x0a\xaa\x22\x25\x1d\xbb\x76\x1c\x14\x51\x02\x79\x5d\xbb\x3a\xda\x85\x21\x2f\x31\x33\x65\x50\x24\x33\xb1\xdc\xe4\x30\x55\x45\x3c\x6e\x47\x8d\x15\x82\xd6\x0d\x56\x6a\xb5\x3a\x1c\x5a\xf0\x6d\x34\xd1\xf5\xc9\x79\x1e\xe5\xea\x2d\x2d\x3a\xe0\xd5\x02\x20\xea\xd2\x16\x8b\xa2\xc2\x76\x5e\xe1\x46\x40\xc8\xad\xad\xfe\x76\xf9\x8b\xbd\xee\x90\x90\xe8\x89\xa3\x4b\x5e\xc0\x06\x85\x20\xb8\xbb\xd3\x6e\xa0\x48\x09\x5e\xb7\x0d\x3b\x22\x79\x4a\x59\xd5\xa9\x13\x9f\xfc\x62\x58\xde\x71\xc0\xc2\x5b\xcc\xcf\x77\x80\xd5\x75\x83\xea\xef\x79\x67\x76\xc1\x35\xc9\xfe\x5e\x7d\xeb\x46\xcb\x72\xef\x13\xab\xcc\xc7\x2e\x8d\xdb\x36\x6c\xb3\x7a\x47\xf8\xf1\xc5\x37\x53\xab\x6d\xc0\x68\x75\x24\xec\xef\xf9\xfd\xbe\x63\x32\x64\x24\x0e\x1e\xe5\x84\xec\x24\xb8\x5f\x6d\x3f\xf6\xa4\xda\xa1\x6a\x90\x32\xd3\x31\x65\xe6\x6d\x93\xd4\x9b\x69\x0a\xd4\x6c\x1f\x14\x11\xbe\x9d\x14\x84\xf9\xf6\x5b\x20\x7c\x7d\xfe\x93\x54\xf3\x13\x5a\xa4\x8e\x14\x86\x22\x4d\x7d\x28\x51\xb5\xe1\x62\x2b\x9a\x3d\x80\x5d\x64\xaf\x24\x80\xc9\x6c\x76\x81\x2b\x35\xcd\x97\x92\x64\x01\xaf\xe8\x91\x3c\x0e\xa4\x57\xa2\x01\xa9\x67\x56\xc2\x06\xbb\x44\x07\x45\x24\xbb\xc6\xbd\xc9\x67\xdf\x8c\xb1\x07\x0b\xf8\x1c\xbf\x66\x36\x2e\x6c\x84\x00\xb1\xd0\xb4\xee\x90\x6e\xb4\x7a\x78\x18\x3f\x70\x07\x6e\x87\xac\x25\xab\x4b\x17\xbc\x72\xe4\x9e\x68\x53\xa8\x22\xbb\x57\xa4\x7a\x72\xe7\xb3\xd0\xf7\xce\x3b\xd5\x91\x74\x03\x7d\x7b\xd5\xdf\xff\x0e\xf7\x35\xce\xec\x38\xb0\xc2\xb6\xc6\xd7\x45\xed\x28\x7a\xa1\x92\xe9\xaa\x7d\xea\x64\xe9\x00\xf2\xb3\x1d\xf5\x41\xb6\x41\x14\x25\xe6\x34\x67\xb1\xdb\x6d\x92\xcd\xe1\x34\x08\x35\x11\x83\x01\xd0\x04\x90\x5c\x76\x7c\x5e\x13\x01\x4d\x1d\x38\x5e\xd5\x76\xcb\x28\xbc\xca\x36\x70\xfe\x80\x53\x77\xeb\xe2\x4f\x02\x62\xc3\xf6\xa8\x7c\xfa\x34\x6d\x38\xbd\xfe\x69\x7a\x77\xf4\x56\x69\x05\x8b\xed\xd8\x98\x11\x65\x5b\x71\x93\x7b\xd4\xc9\xe2\x04\xa4\x5f\x2a\xa9\x0c\x67\xa7\x26\x79\x3c\x89\x16\x45\x31\x19\x13\x8d\x69\xe9\x5e\x92\xe8\x21\xa9\xa9\x82\xc9\x62\x51\x06\x45\x2c\x1e\xc1\x59\x15\x11\x1c\x2d\x6e\x5d\x8e\x57\xd9\x3a\x8d\x8a\x8a\xb6\xec\xc4\x5a\x5d\x7d\x7f\x83\x10\x77\x65\x28\xd1\x56\x18\x72\x8c\x98\x2c\x75\xeb\xba\x67\xc9\x53\x8f\xcf\xdd\x73\x47\x41\xed\xb0\x65\xdb\x8f\x1d\x43\xe9\x5a\x31\x75\xc2\xe1\xb7\xa2\x47\xa2\x5f\xc3\x36\xfa\xe4\xec\x19\x25\x4f\x6d\x89\xae\x94\xde\x54\x97\x76\x5b\x69\x22\x31\x1a\xf5\xe0\x34\x1a\x1c\xce\x27\x8a\xdd\x6a\x35\x1a\x4d\x36\xbb\x5d\x90\x45\x11\x04\x93\x80\x84\x22\x56\xc5\x2a\xdb\xcc\x82\xc9\x25\xca\x32\xd4\x44\xe4\x36\x74\xe2\xe8\x5d\xc6\xf5\x9a\xdc\xb3\x50\x20\x1c\x4f\xde\xa4\x32\x27\x07\x7a\x3f\xcd\x58\xff\x74\xf7\xe8\xd9\x93\x48\xb3\xc7\x3f\x17\xd2\xa2\xab\xa2\x7f\x44\xc4\xf6\xdd\x15\xfd\x0a\x49\xd7\x9d\xbe\xc4\x71\xba\x53\x9d\x2c\x44\x91\x6e\x76\x32\x08\x35\xa5\xc9\x64\x31\x12\x59\x31\x18\xac\x16\x6c\x6b\x04\x8b\xe0\x74\x18\x01\xfb\xd8\x8a\xd5\x6e\x37\x0d\x8a\xd8\x3d\x8a\x5d\x24\x02\x6b\x54\x2a\x62\xa4\x8b\xc3\x29\x26\x84\x2d\x43\x26\x31\x5c\x62\xb8\xbd\xb4\xfa\xd8\x31\xf8\xe8\x5d\xf5\x7a\x98\x34\x6e\x4f\x10\x7e\x9c\xae\x2e\x93\xde\x6c\x1a\x47\xad\x6a\x50\x4d\x66\x64\xd3\xec\xba\x1e\x58\x97\x7b\xf8\xba\xe0\xae\xe1\x74\x20\x92\xd1\x24\x08\xb2\x91\x88\x56\x8b\x11\xdb\x3c\x16\x77\x5a\x34\x09\xa8\xc5\x81\x19\x1c\xaf\xb6\x46\xe8\x6f\x6b\xe3\x71\xf7\x5f\x16\x7e\x13\xfc\xe2\x9e\xa7\x9b\x6e\x14\x46\x35\xfd\x24\x7c\xdf\xb4\x57\x58\xc7\x02\xb1\x6f\x10\x87\x3f\xb0\xbe\x71\x2f\xcf\xaf\x13\xd2\xa0\x5e\xec\xca\x7d\xf3\xd3\xa8\x2c\x9b\x8c\x0a\xdf\xae\xd7\x22\x0b\xa2\x50\x15\x41\xfd\xad\x10\xa5\x2a\x62\x62\xad\x69\xdb\xec\x5a\x22\xe7\xf0\xcd\x80\xf4\xdc\xb0\xa8\x9d\xe8\x96\xe8\x26\xa1\x4b\x74\x2a\x7d\x6e\xcf\x3a\x21\x77\xfd\xba\xa6\x0f\xa3\x9f\x60\xf1\x28\x19\xd7\xfc\x83\x54\x2a\x6d\xe5\x6d\x53\xd7\x70\x9a\x57\x46\x23\xd5\x26\xdb\x92\x53\xc0\x4c\x2c\x82\x31\xa1\x26\x62\x14\x05\x7b\x0d\x0b\xf5\xe5\x8a\x73\xf6\x6c\xed\xcc\xe9\xc2\x51\x2a\x07\x32\x59\x98\x33\xd4\x6b\x65\x68\x35\x15\x97\x39\x51\xd1\xb1\x07\xe2\xbc\xfa\xfd\xea\x33\xea\x7d\x30\x1b\xfa\xbd\xbc\x7b\x6b\x46\xf4\xf3\xef\xe7\xdd\xfa\xcd\xdf\xd4\x7f\x81\xb9\xef\x68\xb8\x1d\x86\xc1\x60\x58\x32\xa0\x4b\xc3\xb2\x35\x93\x84\x43\x75\xea\x79\xf5\x1f\xea\xdf\xd4\xb3\x9c\x0e\x0a\xb6\x9b\x5f\x8a\x03\xb1\x98\x1d\xc3\x3e\xb6\x6a\x4b\xa6\x72\xa2\xcd\x6b\x71\x0d\x89\xd8\xed\x16\x87\x0c\xd4\x0e\x1e\x1e\x84\x8f\x05\x1e\xe4\xee\x20\xb1\xf5\x8d\x6c\xd3\x25\x77\xa2\xb7\x02\xf8\xd2\xdc\x58\x9c\x59\x7a\xd3\x7b\xea\xfc\x17\x7f\xb4\x76\x71\x74\xbd\xa7\x60\xd1\xe4\xc7\x6a\xa7\xb6\xbb\x26\xbb\xa0\xd8\x2b\x76\x8d\x86\xf3\xff\x50\x5a\x0f\x6f\xaf\x5b\xb2\xb3\xee\xda\xbc\xae\xbd\x78\xfe\x68\xaf\x18\x9e\x46\xda\x64\x93\xb2\x70\x7a\x82\x3b\xdd\xe6\x75\x8b\x39\x34\x37\x45\xb0\xa5\x7b\x05\x97\x5b\x70\xb9\x8c\x2e\x22\x21\x6d\x58\x10\xa3\x62\x2d\x0c\x1a\x6a\x7c\xee\x98\xa2\x75\x5d\xa0\x58\x0b\x75\xa3\x40\x40\xc0\xfe\x94\xac\x08\x1a\x5e\x9d\x5d\x6e\x76\x2a\xeb\xcc\x42\x94\x2a\x4f\xef\x1a\x3f\xab\xe7\xf5\xc5\xd7\x26\xa8\xc7\xbe\xfa\xd9\x51\x64\x74\x95\xfe\xf2\x95\x3a\xee\xb5\x68\x51\xae\xaf\xe2\x97\x13\xff\xec\x92\x69\x2c\x77\x3f\x1b\xb8\x47\xda\xba\x69\xda\x84\xf2\xde\x8d\xab\x84\x65\xa5\x7f\x28\x9e\xf1\x42\xd3\x0a\x69\x45\xd3\x8a\x7d\x47\x6e\x01\x51\x98\xd4\xb4\xe9\xfc\x96\xc0\xcf\xd7\xd1\xed\x2b\xf8\x9e\x5c\xcd\x51\x42\xe4\x6f\x90\x76\x59\xd8\x57\xcc\x40\xb9\x11\x02\x29\xd9\x46\x83\x21\xe0\xcb\x18\x12\x49\xf5\x39\x9c\x16\x41\x50\x6c\x0e\x83\x5d\xf1\x10\x4d\x7c\x18\xe2\x2d\xae\x66\x7c\x89\xa0\x9f\x87\x87\xd2\x31\x2e\x43\x84\xbd\x0c\x5d\x1a\x17\xb7\x57\xdc\xfa\xce\xa1\x12\x25\x78\xe4\x6d\xf5\x9d\x23\x27\x8c\x59\x81\xb7\xcf\xbc\xd0\x21\x29\xe1\x76\xef\x75\x63\x86\xf6\x5b\x54\x3a\x35\xbd\xa2\xb0\x7d\x67\x27\x7d\xf6\x2f\x81\x37\xa3\xfd\x90\xc6\x79\xfe\xfd\xf7\x0a\x09\xd1\x8c\x57\xee\xec\x09\xcd\x23\x27\x77\xe8\x33\xac\xae\xa8\x73\xf7\x30\xb7\xf7\x8b\x08\x11\x7e\x13\x7b\x23\x17\x06\x50\x1b\x15\x26\x1b\x53\x15\x7b\x7a\xba\x62\x14\x24\xe2\x12\x04\x49\x4a\x24\x42\x4e\xb6\xe0\x4a\x75\x61\x8b\x9d\x98\x9a\x4a\x93\xec\x16\x7f\x55\xc4\xe2\xa0\x1e\x9d\x2b\x59\xb7\x2a\x74\x99\xfd\xd1\x2a\x7d\x46\xac\x00\x25\xaf\x73\x59\x6e\xeb\xe6\x37\xde\x44\xb6\x08\xd1\x8d\x0d\x6d\x2c\x54\xf3\x6f\xea\xcd\xef\xbd\x3a\x35\xd4\xa7\x5d\xee\xca\x9b\xc7\xcc\x9a\x70\xcb\x30\x77\xb6\xcd\xd1\xf5\x97\xe8\xf9\xac\x29\x59\x69\x69\x41\x16\xe4\x87\x06\xb2\x97\x27\x38\x66\x57\x4e\x5c\xb9\x60\x42\x64\x79\xc9\x97\x9d\xee\x28\x2d\xad\xa7\x2f\x7d\x5a\x34\xec\x9a\x01\x59\x85\x79\x9a\xbe\xd8\x87\x7c\x3b\x8e\xc7\x24\xc8\x0b\x33\x1b\x59\x20\x82\xd1\xc0\xb5\x27\x13\x60\x81\x87\xee\x8d\x6f\x63\xf8\xf4\x14\x6f\x59\xc4\x71\x5a\x93\x12\x6b\x4f\x34\x78\xf7\x20\x6d\xda\xa1\x3e\xe0\xf0\x40\x92\x50\x0c\x8c\x06\x10\x07\x45\x00\x64\xc5\x2e\x7b\xae\x02\x4f\xf7\x79\x83\x9e\xf0\xdf\x6a\xd2\x31\xb1\xab\xda\x79\x95\xea\x46\x10\x9c\xd6\xc3\x9a\x7f\x10\x3f\x14\x07\x63\xc5\xa7\x93\xf2\x70\x7a\x22\x49\x35\xda\x2d\x12\x36\xd9\x42\x66\x86\x3b\xa9\x2a\xe2\x76\x18\x0d\x8e\x54\x3b\xb5\x57\x45\x68\x62\x8b\x07\x7b\x45\x61\xdb\xe8\x06\xe0\xf0\xa3\xc4\x97\xb8\x58\x30\x2b\xbe\xd3\x0c\xa3\xac\x8b\x0f\x44\x27\x61\x53\x25\x7e\x18\x3d\xa9\x7e\xac\xfe\xf7\xc5\x3f\x78\x6e\x5b\xbe\x61\xe7\x8e\x5d\x8f\x9f\x7e\x61\x44\xd5\xbd\x0f\x6f\xa5\xa5\xd1\x13\x90\x0a\x49\xff\x0d\x05\x99\x6b\x53\x3e\x3c\xf9\xd6\x9b\x46\xda\xe3\xcc\x7f\xa9\x1f\xff\xf3\xcc\xbb\xea\x3f\xa2\xcf\x2b\x1f\x68\x6b\x2a\xd7\xd3\xa9\xc2\x1d\x7c\x9e\x2f\x3b\x6c\x97\x80\x79\xc7\x1a\x8c\xa0\x80\xc2\x76\x14\xd3\xc7\x37\xe2\x8b\xcc\xa2\x1b\xe3\x41\xa7\x46\xcf\xd3\x76\xec\xa0\x5f\x5f\x7a\xe4\x52\xf4\x67\xfc\x42\x7b\xa6\x9f\x50\x4f\x8e\xe9\x7b\xae\xb9\xea\x49\x18\x49\xb7\x5c\x64\xbb\x58\x97\xe3\xc1\x3c\x18\xb1\x0b\x8e\x80\xea\x77\x0c\x5b\x2c\xde\xba\x69\xd3\x0b\x34\x31\xfa\x3d\xb3\x83\x8e\x0a\xff\x82\x3b\xf4\xf7\x12\x4e\x28\x0a\x60\x1d\x2e\x07\xf6\x62\x31\xdb\xc7\x8b\x71\x56\x1e\x66\x1d\xf2\xc0\x1d\xea\xa6\x11\x30\x5d\x5d\xb5\x43\xaa\x53\x37\x0d\x87\xe9\x2b\x36\x6d\x22\x54\xfd\x51\xac\x01\x97\xfe\xbe\xe3\xb8\xa2\xc8\xcb\xd9\x4e\x72\x21\xb6\x03\xb6\xe6\x97\xcf\xe2\x42\x82\x8b\x05\x91\x52\x1f\xde\x21\xd6\x2c\x1c\x87\xaf\x11\x68\x79\x4f\x22\x96\xa3\xc2\x72\x3c\xb1\x77\xf8\x1b\xc8\x26\xea\x8f\xf0\xf8\x92\xe8\xc7\xe2\x07\x3f\xab\x9b\x90\x2c\xdb\x45\x45\x98\xac\xcc\x43\x7d\x95\x1e\xb6\x32\x6e\x93\x04\x93\x99\x6d\xb1\x69\xc0\xde\x7c\x79\x4b\xb7\x46\x67\x33\xb6\xdd\x17\x08\x93\xd5\x2f\x36\xa9\x5f\xc0\x68\x27\x4c\x90\x4d\xd1\x28\x15\xbc\x30\x4c\xdd\xaf\xf1\x5b\x1b\x78\x06\x89\x48\x02\xc2\x43\x1b\x0a\x94\xcb\xe0\xa1\x54\x81\xe6\xf6\x89\xf0\x1e\x74\xaa\x8f\x41\xfa\x26\x48\x97\xaa\xd5\xfd\x30\xcc\x4b\x85\x68\x54\xe3\xb7\xa7\x84\xbd\x70\x97\x72\x96\xd3\x20\x2b\x6c\x53\x04\x2a\x0a\x22\x72\x30\x08\x12\xdb\x19\x30\x78\xd6\x59\xde\xa6\x26\x03\x42\x88\xd5\x07\x0c\x99\xd2\xe5\xc3\x8f\xcf\x8b\x7f\xa6\x8d\x8d\x17\xb6\x6d\xbb\x12\x16\xf2\x85\x0c\x68\xe0\x23\x5f\x50\x8a\x15\xa3\xb0\x71\x2f\x3e\x6a\x11\x1f\x95\x28\x80\x9a\xcb\x13\x28\x85\xbb\x3e\xec\x32\xa5\xe4\xbc\xb0\x97\x36\x42\x7b\x06\x0d\x61\xc1\x63\x70\x97\x5e\x37\x99\x61\x6b\x0b\x2c\xd0\x20\x9d\x75\x96\xff\x3e\x1c\x78\x2c\x06\x07\xd4\xdd\xe2\x14\xe8\x82\x70\x8c\x58\xc3\x12\x31\x2e\xc7\xd6\x9a\xd5\x56\x31\x0f\x2e\xa8\x39\x62\x38\xfd\xd0\xe5\xa7\x25\x87\x97\xd0\x6d\xd2\x8d\xdf\x7c\xf3\x0d\x4c\xe0\xef\xe1\x57\x17\xbc\x34\x22\x47\x22\x79\x5b\x18\x4b\x1f\xa9\x73\xea\x2e\x1b\xd0\x25\x3a\x19\x5f\xfd\x09\x26\xe0\x9b\xbc\x1f\xae\x8e\xa0\x5b\x9a\xe7\x10\x99\xed\xdd\x87\x0a\x52\x50\x0c\xe2\x72\x3b\x05\x03\x65\xa3\xad\xc9\xb1\x69\xe2\x14\x54\xdc\x81\x3c\x25\xf5\x2f\x07\xbf\xd8\xbf\xe5\x3e\x75\x04\xa4\xa9\x5f\x9e\x3a\x85\xe5\x7e\x8e\xbc\x0e\x4b\x51\x19\xe8\xf3\xf7\x44\x14\xb1\x73\x6e\x30\x4a\x6c\xf9\x76\x30\xd4\x32\x0e\x16\x0b\x14\x12\xdb\x49\x50\x98\x76\xee\x5c\x74\xec\xb9\x73\xbc\x1e\xea\xc8\xcf\x42\xaa\xbe\xa6\x4f\xf3\x01\xa0\x84\x72\x18\xd0\x02\x23\x36\xaf\x1b\x5b\xc0\x4d\x4f\x46\x2b\xe9\x49\xfa\xfe\xe6\xcd\x6a\xfa\xe6\xcd\x1a\xaf\xd5\xd1\x08\xa4\x71\x3e\x4f\x38\x21\xb0\x3d\xeb\x59\x1d\x68\x13\xd7\x9c\xea\x42\x00\xb3\x87\xb4\xd2\x41\xa1\x67\xc4\xbf\x44\x6f\xa1\xf7\x7d\xae\xbf\x27\x54\xb5\x7d\x8f\x8a\xbf\xff\x9e\x7a\x13\xec\xe4\xef\x09\x24\x0d\xbf\xe6\xf1\xfd\x87\x93\xf0\x7a\x78\xb8\xbd\x2c\x52\x8f\xdb\x0a\x40\x13\x93\x93\x93\xd2\x68\x5a\x7a\x46\xaa\xdd\x97\x34\x24\xe2\x23\x26\x3b\xb3\xb1\xd8\x70\x30\xaa\x44\xc9\x9e\xcc\x6c\x8d\x56\xf7\xec\xd8\xaa\x97\xb6\x56\xba\x6e\xa9\xeb\x11\x9c\x5b\x83\x2b\xa4\x41\xc8\xc3\x69\xc9\xec\xcf\x29\xc7\xb6\x6d\x5b\x79\xfb\x0d\x25\x45\x81\xde\xdd\xdf\xbd\xfd\xd8\xb1\x63\xc2\x89\xa6\xeb\x85\x13\xab\x16\x6d\x5e\x69\x59\x67\xe8\x33\x66\xdc\x2a\x98\x72\xf0\x60\xc3\x67\xac\xc1\x61\xb4\x66\x38\xcf\xd7\x71\xc6\xde\x84\xc7\x0d\x88\x34\x47\x39\x89\x26\x25\xa7\x5c\x81\x69\xe2\x15\x98\xb6\xe9\xce\xfc\x5b\x1c\xaf\xc0\xef\x8e\x2b\xb1\x6b\xba\x5e\x7a\xb3\xa1\x44\x8b\xc5\xf6\x24\xe4\xc2\x44\xf1\x0d\x57\xae\x64\x64\xfb\x72\x88\x3f\x83\x49\x3d\x8e\xbc\x5d\x2f\xed\x85\x7e\xf2\x97\xc4\x4a\xdc\xf5\x32\x9b\x1e\x66\x2b\xa4\x2a\x10\xad\xb3\xd5\xc5\x2d\x81\x60\x43\xda\x88\x3e\xf4\x3b\xb6\x75\xeb\xb1\x47\x46\x0d\x1c\x30\x5a\xfe\x72\xe3\xc1\xc3\xf7\x0c\xa8\xae\xed\xc7\x61\x5f\x2b\xd4\x89\x6f\x38\x34\xd8\x79\x12\x5b\x7c\xc3\xf2\xf8\x89\x9a\x68\x00\x7f\x6f\xd7\x7c\x51\xec\x89\x79\xcb\x92\x8b\xe3\xd2\x13\x49\xf0\x03\xbf\xd7\x70\x6b\xc7\xd7\xc5\xb3\x7b\x81\xdf\xa3\xb0\x8a\x33\xf8\xbd\xa8\xc5\xd3\x43\xba\xbe\xcc\xef\xcd\xfc\xbe\x4f\xf3\xbb\xc2\x47\xf2\x0a\xbc\xb7\x68\x65\xc3\xf4\xaf\xf3\xdf\xad\xfc\x1e\x9b\x77\xe1\x11\x7e\xef\xd3\xe2\xe6\x71\xfb\x94\xdd\x27\x73\x9e\x1c\x45\xa9\x98\x27\x4e\x66\x6b\x89\x51\x9b\x08\x02\xdb\xf5\x1e\x1b\x7e\x0a\xf4\x24\xf4\x38\x12\x01\xf1\x24\x94\xb1\xf1\x92\x36\xdb\x08\xb6\xac\x06\xf3\x8b\x79\x4d\x21\xb8\xe3\x39\x58\x4f\xe9\xb3\x70\x90\xad\x9d\xc7\x3c\x42\xcd\xbf\x48\xcb\xe4\x3e\x48\xdf\x24\x16\xeb\x4f\xfc\x9b\xc4\xe2\xb9\x5b\x4e\x40\xba\x3d\x3d\xdb\xee\xc8\x29\x74\x96\x5e\x99\x0e\x69\xf4\x37\x56\x5a\xfd\xf9\xee\x96\xe7\x79\xf8\x7e\x15\x87\xf3\xb3\x70\xaa\xf9\x69\x52\x10\x4e\xa1\x35\x05\x50\x40\x77\x16\xc0\xea\x02\x58\x5c\x00\x43\xf1\x2e\x0e\xb6\x93\x4d\x49\x96\x12\x67\x75\xe9\x15\x79\xe4\x69\x30\x18\x4e\x84\x39\x9a\x67\xa0\x6d\x52\x93\x0e\xe9\xb0\x33\x1d\x56\xa7\xc3\xe2\x74\x18\x8a\x77\xad\x00\xb4\x3a\xe9\xd9\x9c\xc4\xeb\x28\x97\xd5\x11\xaf\xcb\x55\xda\x73\xf5\xd1\x36\xcf\x2f\xc5\x9e\xeb\x75\xca\x9f\x33\xbc\x69\x79\xf4\x04\xb1\x9d\x80\xda\x00\x74\x0c\x40\x00\x21\x73\xdc\x06\x63\xba\x15\x3c\x1d\x68\xe9\xe0\x5d\x7c\xc1\x74\x8c\x05\xa5\x72\xe8\xf8\x57\x60\xfd\x15\xf1\x34\x54\x4b\x43\x5e\x27\xfd\x19\xac\x1b\xb3\x21\x98\x0d\xd9\x31\x58\x31\xbe\xc9\x95\x04\x1d\xd6\xb2\x2b\x60\xc5\x78\x29\x57\x12\x75\xbc\x56\xf0\x34\xb4\x35\x4d\x33\x9b\xb4\xd1\x64\x03\x91\x77\xca\xe2\xcf\x26\x0d\x8a\x88\xc6\x0c\x27\x08\xa6\x79\x03\x05\x7c\xa1\xf8\x09\xa6\x91\xb5\x34\x29\x6d\x72\xe2\x34\x78\x14\xed\xb5\x37\xc4\x8b\x98\xc6\xa0\xe7\x55\xaf\xe3\xa3\x21\xcd\xf3\xa2\x7d\x5a\xe5\x90\x97\xcd\x44\x0e\x92\x94\xb0\x13\xde\x10\x61\x83\x08\xcb\x44\x08\x8a\xb1\xac\xb5\x3a\xd1\x78\x5a\x5d\xc6\x79\x3a\x57\x32\xe9\x65\xdd\xa6\xc3\xb6\x80\x45\x2f\x6b\x4c\x4e\x72\x99\x9c\xf0\x34\xef\x34\x3f\xc7\xd3\xb8\xc0\xa5\xa7\x89\xc9\x4e\x2e\x93\x1d\x9e\xe6\x20\xdb\x24\x26\x6c\x02\x9a\x0c\xc9\x20\xe2\x97\x33\x9e\x0f\xca\x90\x7e\x1f\xf1\x32\xd9\xf4\x32\xfd\x8a\xe9\xbd\x61\x2b\x74\xcc\x02\x92\x05\x59\x50\x87\x5f\xda\x2b\xb1\x77\x2a\x39\xad\x18\x1e\x8e\x96\xfa\xbb\xbc\x5e\x42\x48\xab\x73\x3c\x8d\x53\x87\xbb\x57\xaf\x97\x2c\xb6\x21\x1e\x4f\xb3\x46\x5d\x26\x8e\xe4\x69\xdc\x9a\xce\xa2\xa5\xe4\x59\x7c\xbe\x01\x71\x9a\xc5\x9f\x27\xe8\xcf\x8b\xc8\x31\x7c\xce\x54\xab\xc8\x9f\x27\xea\x65\xab\x54\xff\x8b\xe3\x1a\x44\x02\x40\xb6\x0b\x1c\x78\x76\xb6\xe1\xf3\xc5\x98\x47\x25\x7f\xc7\xab\xe3\x31\x14\xdb\x4c\xdb\x09\xba\x3b\x0d\x3a\xa6\x41\x5a\x8c\xd7\x62\x3a\x25\x97\xe9\x94\x36\xf4\x8f\x2f\x13\xca\x1d\x4f\x93\xa4\xcb\xee\x49\x94\xdd\xff\x4c\xde\x62\x3a\x2a\x97\xe9\x28\x8e\xc7\xe7\x3a\x7c\xac\x11\x1d\xfe\x93\x8c\x4f\xb9\x5c\x4b\x9a\xee\x00\x13\x7f\x97\xcb\x94\x5c\xa8\xc9\x14\x3e\xff\x17\x8d\xd3\x9b\xfc\xb9\x59\x7b\x0e\xef\xf1\xe7\x9c\x7e\xfc\x79\x82\x9e\xbe\x27\xd7\x8b\x55\x4c\x86\x65\xb6\x07\x60\xbf\xb0\x97\x0d\x9f\x98\xec\xa8\x82\xc1\xe9\x70\xb8\x45\x00\x97\x5d\x96\x45\x67\x0f\x23\x74\x45\x06\x30\x42\x39\xdb\x34\x10\x58\x58\xc1\xce\x6c\xeb\xda\x0a\xb6\x81\xaf\x33\xd4\xba\xa5\x50\x6c\x26\xd3\xcd\x3a\x4c\x21\xe8\xec\x2e\x0b\x29\x36\x8a\x1d\xec\x1f\x77\x3d\x3b\x1c\x5e\xde\x9a\xea\x3d\xe5\x35\x5d\x3b\x61\x12\x4c\xf9\x5e\x0c\xd2\xc1\x6a\xbf\xe8\xa6\xbb\x80\x5e\xfc\x68\xda\xc1\xad\x13\x55\x1e\x6f\xa7\xe9\x3b\xf1\x34\x11\xe5\x62\xb4\xbb\x4c\x47\x8c\x5a\x84\x44\x06\x2f\x4b\x54\x02\x9d\xb3\xfd\x21\x11\x0d\x86\x13\x63\xd7\x2c\x80\xa5\x60\xf5\x49\x27\xe6\xad\x3c\x75\x5c\x5b\xab\x14\x15\x4f\x0b\x3e\xfd\x3d\x88\xbd\x27\x84\x32\x45\x6f\x20\x37\xbb\x10\x04\x1f\x58\x60\xd9\x82\x35\x63\xd5\x13\x7f\x41\xf0\xc7\x4f\xad\x9c\xc7\xdf\x6b\x6a\x12\x5f\x21\x44\x7a\x1b\xdb\x42\x07\x42\x12\xcc\xcb\x0d\xdc\xcc\x63\x3d\x00\xa7\xe6\x40\xc4\x76\x2b\xc1\x66\xb8\xf6\xa9\x3e\xa3\x67\x75\x77\xdd\x97\xf9\xf1\xb3\xf3\xcf\x8b\x8d\xde\x76\xde\x0e\xc5\x1b\x96\x94\x72\xff\x44\xf1\x15\xec\x05\xbf\x4d\x6c\xd8\x1f\x50\x96\x0b\x66\x66\x61\x62\xbf\x45\x8f\x27\x1c\xb2\xf1\x38\xa2\xe3\x9e\xee\xbd\x7a\x65\xc2\xe6\xa4\xe9\x47\x16\x0d\x3c\x34\x52\xda\xe9\x2b\x28\xb9\x6e\xe2\xac\xd2\x2c\x8f\xe6\x07\xc7\x7d\x1c\xa5\x33\xdc\xe7\xcf\xca\x57\x34\xa5\x11\x3f\xc9\x41\x7d\x17\xc4\xfe\x96\xe6\x0b\x37\x95\xcc\x23\xbf\x85\x57\x2a\x19\x19\x2e\x39\x3d\xdd\x65\x06\x8f\xc7\x35\xeb\x26\x5f\x41\xed\xb4\x61\xd5\xd5\x7d\x06\xf4\xab\xea\x39\xb2\xa2\xab\xe0\x76\x77\xbd\x36\x34\xb2\xaa\xcf\xb4\x82\x9b\x4c\x85\x26\xe2\x72\x2d\xc8\x4a\xee\xd0\xa1\xd0\x9e\x97\x57\x68\xcb\xcd\x0d\xa4\x14\x16\xce\xcf\xcf\x4c\xc0\x27\xb7\x4c\x9e\xdc\xf7\xda\xa1\x43\xbb\xf5\x85\x14\x4b\xf6\x98\x61\xe6\x40\x9f\x8e\xe3\xc7\x57\x97\xcd\x49\x6c\xdf\x37\x25\x7b\x58\xa0\x64\x4e\xfb\xf6\x73\x4a\x02\xc3\xb2\x53\xfa\x1a\x0a\xed\x8a\x90\x94\xe4\x30\x88\xa9\x79\x19\xee\x42\x2d\x26\xf9\xab\xc5\xfa\x5e\x77\xce\xd6\x49\xbc\x16\x3b\xcb\x19\x3f\xd2\xce\xa7\x6f\xb4\x5f\x20\x6e\x26\xa9\xe5\xd7\xd6\x1d\x9c\x2f\xdb\x77\x23\xee\x96\x99\xeb\x6c\x1f\x0a\xb6\x6d\x1e\x5b\xc8\xcb\x1a\x66\xd6\xe1\x2a\x65\x4e\xd2\xcc\x84\x8f\x7b\x2e\xb1\x8d\x9b\x43\x39\xad\xfb\x10\xf3\x2d\x26\x13\xe4\x1c\x16\x47\xdc\x19\xca\x64\x23\x0c\xe9\x6c\x82\x83\xdd\x15\x7b\xf5\x33\xf6\x99\x63\x4e\x4c\xf1\x1e\x5b\x06\x52\x77\x11\xae\x8b\x9e\x51\x5f\x80\xeb\x68\x45\x5d\x5d\xe3\x4a\x76\x25\x2e\x55\x5f\xb8\x58\xf7\xdb\x75\x17\xeb\xb4\x6b\xb8\xae\x61\x4f\x5d\x9d\x90\xce\xae\x58\xda\xba\x8b\x12\xa9\xae\xf1\x4c\xb3\x14\x74\x2c\x6e\x3f\xf6\x4f\x75\xea\x86\x9d\x1b\x9e\xba\x07\xd2\x07\x0c\x9c\x30\xf1\xc1\xc8\xf0\xcc\xcc\xc3\xc1\x9b\x6e\x2a\xe9\x76\x46\x0d\xab\x17\xb6\xdc\x77\xdf\xd6\xcd\xf7\xcd\x8a\x8c\xa9\x1d\x31\x6a\x4c\x75\x44\x5c\x7a\xb1\xae\xae\xae\x69\x29\x5c\x07\x1f\xd5\x35\x54\xd4\x5d\x14\x93\x11\x01\xbc\x80\x8f\xe0\xba\xa6\xa5\x75\x98\xe3\xc5\x2f\x6b\xe6\xbb\x6e\xe8\x75\x5d\x0d\x7c\x31\x2a\xfa\xda\xca\xdb\xfe\x76\xf3\x42\xa1\xf0\x95\x5e\x13\x9d\xe6\x69\x10\xe8\x59\xae\xaa\x5f\xf5\xee\xa7\x7e\x08\xd7\xa9\xa3\xce\x5e\x78\xef\xf5\xd7\xdf\x3b\xb0\x7d\xc7\xfe\x27\x1f\xba\x9f\xf1\xea\x32\x75\x20\x54\x36\xef\x42\xbd\xd9\x21\x9c\xa4\x10\xd1\x48\x8c\x16\x33\x0b\xae\x6c\x74\xb0\xf8\x54\x82\x43\xc8\x14\x04\xb6\x25\x3c\x73\x6f\x89\xef\xf9\x49\x09\x7c\xdf\x1e\x36\xef\x07\x95\xed\xf3\xe7\x16\x75\x1a\xf9\xf2\x99\x11\xd3\x82\x1d\x87\x77\x78\x00\xe5\xef\x6b\xf1\x29\xfa\xb2\x74\x09\xb9\x37\x27\xec\x50\x0c\x06\xb3\x40\x4d\xd8\xed\xc0\xde\xf1\x3d\x11\xc2\xc2\x9c\xb1\x30\x5f\xc5\x58\xff\xc5\x7a\x6d\x66\x0a\x21\x36\x97\x10\xa2\x30\x54\x7d\xc0\xfc\xa8\xe5\xf4\x69\xcb\xa3\x66\xf1\x29\x08\xbf\xf6\x9a\xfa\xa2\xd6\x8f\xb8\x4d\x4c\x85\xde\xd2\x0a\x1e\x39\x29\x49\x26\xa2\x81\x18\xcc\x26\x83\x72\x5f\xa4\x4a\xa8\x15\xe8\x6e\xe1\x29\x81\x0a\x88\x79\xc5\x9b\xf1\x71\x7c\xb9\x01\xcb\x66\xeb\x19\xa2\xbd\x11\xd1\xb1\x23\x5f\x96\xbc\x23\xe6\x06\xeb\x46\x3d\x8e\x30\x57\x8a\xcf\xc1\x0d\x72\x26\xc2\x2c\x0b\x67\xc9\x46\xd1\x60\x34\x98\xcc\x46\xf9\xbe\x48\x8d\x30\x43\xa0\x87\x85\xd3\x08\xb3\xca\x08\x76\x63\x85\x71\x99\x51\x60\x01\xbb\x66\x9d\x6d\x0b\xde\xcd\xa6\x8a\x64\x36\xeb\xb9\x52\x87\x9e\xa3\x43\x67\x38\x4f\x95\x1a\xa8\x4b\xbe\xc4\xe2\xe9\x84\xbd\x20\xca\xca\x43\xf4\x30\x3d\x4d\x05\xba\x3c\x03\x25\xb9\x02\xa5\x98\x39\x62\x63\x47\xb0\x3a\xe6\x8f\x99\x53\x1a\xf2\x7a\x60\xb7\xfa\xa7\x73\x17\xa4\x86\x0b\x69\x5f\x24\x70\x38\x95\x52\x03\x5c\xfa\xdf\xc0\x71\x97\x96\x85\x3c\x52\xe5\x85\x73\xea\x9f\xa4\x86\x84\x2f\xd2\x2e\xe8\xbe\xd3\x88\xcf\x56\x59\xc5\xf2\x96\x84\xd3\x8c\x06\x34\x7c\x59\xf0\x2b\x93\xf0\x90\xe1\xb0\x81\x1a\x96\x4b\x19\x10\x84\x0a\xa8\x01\x91\xfb\x7a\x21\xb8\xf2\x56\xf3\x97\xc7\x32\x09\xe4\x05\x94\x00\xc2\xa6\x5b\xa7\x7c\x44\xbf\x9d\xfc\xfd\x9b\xb2\x2d\x61\xfd\xfa\x84\x4b\x6d\x60\x77\x0c\xa7\x10\x90\x24\x04\x8f\xd4\x7c\x48\x38\x8c\x44\x5c\xde\x06\x72\x0c\xcf\x16\xb8\x81\x3c\x2c\x36\x9b\x56\x82\xfa\x37\xbf\x9f\xfc\x2d\xfd\x68\x8a\xd4\xf0\x93\x67\xfd\x7a\x0f\x1b\x6f\x44\xb8\xa3\xe4\x23\xfa\x38\x02\x36\x56\xcc\xcb\xda\x60\x04\x49\x94\x36\xb2\xa0\xf4\xc1\xb6\xbb\xa5\x23\xb4\x52\x16\x7b\x1e\x61\x9d\xd8\x13\x7d\xf7\x31\xa9\xe1\x24\x7e\x90\x27\xbf\x43\x38\xf5\x8a\x8c\xba\xf4\xfa\x70\x41\x82\xc7\x93\x64\x60\xab\x42\xad\x56\x69\x43\x24\xc3\x0a\x4f\x59\x5f\xb4\xbe\x6d\x15\xec\xd6\x0c\x6b\xd0\x2a\x18\x05\x2b\x09\x13\xd7\x86\x08\xf3\x6b\x2d\xd6\x36\x3d\x66\xa1\xcf\x66\xb5\xac\x03\xd5\xb3\xca\xea\x40\xd9\xf0\x6a\x80\x0d\xb6\xa6\xd3\x10\xdf\x4a\x02\x7e\x28\x18\x3a\xb0\x6f\x46\x59\x67\xe3\x68\x73\xc7\x41\x15\xed\x87\x0e\xec\x9d\x5e\xe7\x1c\xe3\xac\x93\x1a\x72\x8a\x72\xba\x97\x4f\x9c\xd2\x0d\xcf\xf3\x37\x2f\xd0\xc6\x49\x32\xa5\x06\xc1\x2e\xff\x8d\xaf\x5d\x2d\x0a\xa7\x9a\x44\x05\x44\x8b\xd5\xd0\x52\xc3\x72\x9b\x2a\x2e\x4e\xd6\x42\x5c\x7a\x5b\x2a\x39\xc4\xbf\x33\xff\x80\x55\x1d\xfd\x83\x56\xdf\x5f\xa6\x7d\xc8\x0e\xad\x2d\xfc\x16\xcb\xbd\x52\xfe\x07\xb6\x23\xb9\x61\xb7\xc9\x6c\xb6\x8b\x82\xcd\xc4\x6a\xe5\x34\x8a\xf6\x72\x85\x39\xee\x72\x98\xad\xc2\x88\xaa\x32\x14\x6b\xad\x00\x4a\xd6\x1c\x77\xcd\x75\x4e\x1f\x3d\x7a\x9a\x73\xae\xe7\x98\xd4\x70\xe7\x8c\xd2\x6b\xbb\x95\xcc\xbe\x83\xd9\x11\x53\xc5\xa7\xa9\x4b\xfa\xca\x21\xb3\x75\x41\xff\xc1\x7d\xa5\xf8\x34\x5c\xe2\xf7\xf3\xfe\xe7\x7b\xec\x9b\x7a\xa5\xd7\x9b\xff\xa8\x14\x12\x17\x1b\x5b\x73\x18\xec\xdc\x07\x13\x5b\x72\xbe\x9b\x6c\x1e\x73\x44\x63\x9e\x74\x81\xd2\xee\x70\x31\x54\x50\xd9\x27\x63\xd4\xd4\xbf\x0e\x1a\x3d\xb3\x77\x47\x79\x45\x46\x96\x6f\x42\xfa\x96\x6b\x86\x99\x8b\x17\x08\xe9\x0c\x56\xd4\x29\xbd\xae\xbe\x74\x25\x2c\xb8\x12\x96\x9a\xf2\xef\x81\x41\xd3\x48\x84\x65\xfc\x8f\x60\x45\xc7\xff\x5b\x58\xd8\x1f\xf8\x0e\x69\x54\x2f\xbd\xe0\x90\xe9\x2e\x72\xb5\xfb\x4f\xf0\x7e\xbe\xf4\x0d\xde\xef\xe0\x34\x22\x78\xbf\x55\x7a\x17\xef\xd7\xf2\xfa\xb5\xab\xaf\x37\xbf\xdc\x3c\x17\xe5\xc3\xf0\x34\x1b\x16\xd2\xc7\x48\xff\x76\x4c\x7d\xfd\xe0\xc1\xff\x80\xe6\xff\x43\x9d\xc5\xea\xc0\x25\xd3\x37\xae\x76\xff\x3f\xe2\xff\x7f\xbc\x6f\x6a\x56\x5f\x8f\x1e\x6d\x9e\xeb\x50\x8c\xae\xe8\x25\xc2\x6d\xe5\xa6\xf5\xf8\xac\x42\x7f\x76\x9b\xf6\xac\xf1\x2f\xea\xeb\x4d\x0f\x69\xcf\x9a\x3e\xd6\xd3\x9d\xc3\x74\xab\xf4\x74\x2f\xea\xe9\xf6\x62\xba\x51\x7a\xba\xfb\xb5\x67\x97\xe7\x19\x9d\xae\xbe\xae\xfa\xb5\x34\xea\x58\x2d\x8d\xba\x1a\xe9\xdc\x45\x7b\x86\xd4\xd6\x9e\xfd\x09\x9f\x2d\xc5\x67\xb2\xd1\xf5\x1c\xcb\xef\x37\xcc\xef\x90\x9e\xdf\xf7\x5a\x9a\xe8\x22\x84\xd5\x41\x87\x35\x4d\x7f\x36\x11\x9f\x25\xeb\xcf\x46\xe8\xb8\xee\xc2\x77\x07\xeb\xef\x6e\xd0\xd3\x05\xf0\xd9\x79\x3d\x5d\x82\x9e\xae\x2b\xe2\xff\xa3\x9e\xae\xf0\xea\xf8\xff\xef\xee\xd9\x7e\xd1\xf8\x75\xad\x98\xab\xaf\xef\x61\xe3\x53\xd4\xce\x67\x9b\x62\xa3\x74\x4c\xdf\xad\x3d\x26\xe6\x36\x32\xa5\x22\xa8\xef\x4b\x47\xa0\x10\xf9\x5f\x5b\xbb\x9b\x13\xf6\x18\x1e\x32\x37\xb3\xf8\x9e\x46\x6b\xa5\xd9\x2c\x01\x88\x33\xf8\x3a\x83\xd9\xcc\x26\x2c\x0e\x16\x56\xeb\x03\x94\x4c\x2d\xe7\xa0\x4d\xb6\x76\x4f\xf4\xc0\x1e\xd8\x11\xfd\x88\xe6\x48\x47\x98\x7e\x6e\x58\xa6\xc3\xdd\xc7\xe1\x6a\x76\xef\xb0\x70\xaa\x45\x11\x15\x51\x06\xab\x75\x9a\x0c\xf2\x6a\x80\x4b\x00\xf4\x29\x78\x1b\x3e\x03\x01\xf8\x2e\xa1\xe9\xfe\x4a\x3b\xe0\xed\x25\xa0\x0f\x01\x74\x84\x30\x54\x69\x1b\x13\xf0\x90\x95\xa8\xb0\x67\xd5\xcc\x9a\x1d\x9c\x1d\xe2\xde\xca\xc1\x20\x77\xc5\xf1\x48\x81\x52\xaf\x8e\x4d\xf7\x2f\xd4\xc6\x95\x3f\x31\x74\x94\x42\xcb\x01\xd3\xfb\xbc\xb1\xe0\xb8\x9c\x43\x5c\x42\x88\x8b\x81\x58\xd0\x22\x1f\x1d\xce\x30\x08\x8a\xdd\x2c\xe0\x9f\x63\x1a\xf6\xb8\x15\x65\x35\x01\x6c\xf7\xe8\x53\xe4\x6d\xf2\x19\x52\xa2\x05\x1d\x02\x9f\x91\x4b\x84\x3e\x44\xa0\x23\x36\x22\x55\x64\x26\xb3\x7b\x48\x1c\x3a\xc5\x41\x44\xa8\x65\xb7\x0e\x8e\x91\xc2\x5b\xc0\x18\x89\xb6\xed\x7c\xfb\xe5\x77\x76\xde\x7f\x87\x86\x96\xe9\xd0\x01\xcb\x38\xf5\x53\x0d\xb3\xcb\x69\x34\x24\x9c\x62\xc6\xa6\x9b\x1a\x24\xd3\x34\x23\x18\x57\x4b\x28\xdb\x88\x93\xf4\xb6\xf4\x99\x24\x48\x2d\x38\x49\xf0\x99\x74\x49\xa2\x0f\x49\xd0\x51\x0a\x4b\x55\xd2\x4c\x69\xb9\x84\x7d\xc8\x36\x24\xd2\xfd\x97\x10\x1f\x4f\x00\xcd\x10\x41\x47\x66\xf2\x4a\xb5\xf1\x8b\xbf\xee\x01\xfb\x1e\x79\xa9\xe9\x80\x45\x5d\xc2\x11\xa1\xea\x8f\xd2\xf3\xe0\xd6\x79\x20\x2f\x9c\x24\xda\x95\x1a\x85\x1e\x56\x9a\x15\xaa\x30\x36\x50\x14\xa8\x62\x64\xc0\x82\xcf\x2a\x66\x2c\x30\x2b\xa4\x29\xa6\x32\xac\xff\x11\x7b\x5e\xe3\x75\xff\xfc\xc9\x93\x97\x96\x21\xac\x97\xa4\x97\xa1\x82\xc3\x4a\x41\x4b\x2c\xdb\x6b\xc8\x74\x74\x74\x84\x1d\x82\xc3\x01\x09\x66\xd1\x00\x3e\xa0\x30\x83\x2e\xa3\xac\x51\x14\x69\x38\x29\xbd\x92\xb2\x28\xd9\xa1\x59\x41\x16\xd1\x3d\x38\x2b\xa4\x0f\xce\x09\x59\x5a\x14\x58\xde\x1e\x7b\x13\xf5\x0e\x17\xb8\x59\x66\x9b\x43\x43\x87\x65\x17\x15\x19\x46\x9b\x0b\xfb\x57\x94\x0d\x19\x92\xd5\xb1\x50\x1e\x63\x29\xb8\x41\x3e\xb8\x4c\xdd\x96\x9b\x13\xc8\x1f\x5c\x99\x9f\x93\x9b\x9b\x33\xa8\x5f\x1e\x97\x89\xdd\x48\xec\x13\xdc\xde\xcc\x0b\xbb\x14\x60\x1b\xe4\x9b\xcc\xc8\x03\xd8\x3c\x4b\x02\xf3\x42\xe1\xfe\x27\x15\x71\x86\x87\x3f\xe0\xe4\x1d\x0f\x67\x48\x38\xb1\x56\x7d\x54\x3d\x0b\x37\x41\xc1\x5a\xe1\x41\x18\xb3\x56\x7d\x1f\x0a\xae\x06\x93\x88\x68\xc3\xfe\xe7\x30\xef\x55\x3f\xe7\x30\xe9\x7b\x34\x7b\xad\xda\x1b\x9e\xfb\x7f\x01\xe6\xed\xea\x5f\x60\x06\x64\xae\x85\x87\x84\x51\x6b\xa3\xa3\xe8\xde\x38\x98\x06\x12\x08\x63\x43\x40\x04\xe6\xd8\x20\xcb\x80\x96\xd7\x15\x10\xf9\x14\x7e\x2b\xb8\x65\xea\xdf\x39\x38\xf1\xb7\xb5\x4d\xbd\x84\xe7\x35\xbb\x73\x40\x0b\xbc\x9c\xb0\x93\x61\x68\x32\x52\x45\x60\x10\x75\x14\x59\xac\xfe\x96\xf5\x6b\x1c\x43\x23\x94\x19\x81\x43\x3c\xa9\x4e\x1c\x03\xdd\xa1\x72\xad\xf8\x9a\xfa\x26\xac\x19\xa7\xfe\x17\x94\x20\xcc\xc1\x57\xaf\x9f\xcb\x81\xb6\x2d\xb7\x1f\xca\xd8\x82\x61\x06\x76\xb3\xba\x61\x3c\xf4\x85\x92\xb5\xc2\xe3\x30\x63\x9c\x7a\x12\x06\xb7\xc5\x95\x71\xb5\x8b\x45\x9c\xc1\x86\xd5\x28\x0b\x54\x92\x40\xfc\x5d\xb8\x08\x96\x43\x8d\xa6\xd7\xd0\x55\x6b\x69\x3f\xfa\xe6\xd8\xe8\x4e\x3a\x3b\x1e\xde\x65\xf5\x43\xb1\x82\x7e\x17\xcf\x52\x2c\x3d\xb8\x9d\xb1\xe2\x0f\x81\xa3\x1f\xaf\xfd\x81\x3e\x06\x6b\xa6\xa9\x93\xd5\xa0\x30\x85\xc1\xed\xd3\x42\xd3\xec\x58\x1d\x61\xd1\x45\x45\x89\xd5\x51\xd0\xd9\xda\x67\xd3\x16\x02\xb6\xc0\x7c\x5c\x9d\x39\x0a\x9e\xfc\x7c\xad\xf0\x30\x2c\x9a\xa8\x4e\x8d\x3e\x20\x34\x10\x1d\x26\x9d\x19\x5f\x76\x3e\x1f\xfe\x9f\x94\x9d\xce\x5c\xab\x8e\x1d\x85\x95\x84\xec\xbe\xbc\x4e\xfd\x00\xf2\x19\xbc\xd2\xff\x4b\xbd\x1f\x53\x07\x4f\xc3\x0a\xc2\x7a\x5f\x18\x7d\x9f\x7e\x35\x30\x7a\x91\xfa\xe3\x60\xf2\xd5\x90\xad\xf4\x14\x64\xa4\xa8\xd4\x06\x32\x1f\x8e\xba\x1c\x5b\x0e\xdf\xd9\x9a\xc1\x38\xe8\x80\x64\x50\x9f\xa6\x5f\xdd\x10\x3d\x0a\x45\x90\xc9\xf0\xbe\xb1\x25\x8f\xdc\xb0\x33\x96\x07\x43\xdb\x10\x27\x52\xa1\xdf\x65\xad\x7d\xea\x82\x39\x50\x07\x86\xb5\x74\x27\xdd\x55\x19\x7d\x84\x8e\x45\x98\x45\x57\x83\xc9\xb8\xe0\xdf\xc0\x64\x55\xe6\xd5\x60\xee\x52\x6b\xe7\xc1\xe6\x5f\xd7\x82\x0d\x26\xd0\x3f\xf5\x89\xf6\xf9\x4d\x38\xaa\xf5\x0d\x75\xb8\x32\xc9\x0c\xdb\xb0\x8f\x40\x0d\x8a\x28\x22\x15\x5a\x81\xc6\x0b\x6a\x8c\x4f\x93\xe6\x63\x8d\x49\xdd\x7a\x35\x6e\x17\x27\x69\x7c\x5f\xd4\x52\xf7\x88\x5f\xac\xee\x59\xcd\xcb\xe2\xef\xe2\xd7\x52\xf5\xbd\x6f\xc5\x7a\xa2\xc3\xe9\x97\x95\xbc\x96\x18\xbc\xec\xff\x9b\xcc\x77\xbb\x4d\xab\xfb\xa4\xa6\x4f\xc4\x48\x71\xd3\x27\x42\x00\x61\xe6\xb4\xd0\xb0\x63\x38\x31\x26\xf3\x2d\x35\x1f\x4f\x48\x97\xee\x58\x72\x45\xd5\x97\x72\xf8\x2f\xa9\x25\x4b\x61\x24\x13\xfe\x87\xa2\x6b\xc4\xfc\xd2\xa6\x6f\xe9\xc4\x23\x1a\x1d\xae\xc8\x43\xab\xfb\xff\x4d\x1e\x5a\x8d\x1d\x55\xaf\x5b\x0c\xff\x0f\x75\xef\x01\x5f\x45\xd1\xfd\x0f\x4f\xdb\x9d\xdd\x4b\x48\x23\x81\x10\x42\xb8\x14\xa9\x92\x84\x7b\x09\x21\x14\x49\x20\x09\xbd\xf7\x12\x20\x84\x40\x02\x21\x09\x29\x54\x81\x60\x23\x8a\x8a\xbd\x2b\xf6\xae\x88\x62\x2f\x48\x51\x51\x51\x3a\xa2\x88\x20\x5d\x45\x41\x40\x6c\xc9\xe6\x3d\x73\xee\x24\xdc\x40\x50\x9f\xe7\xf1\xf7\xf9\xbc\x7f\x23\xdf\x9d\x3b\x3b\x7b\xda\x9c\x99\x73\xb6\xcd\x16\xd1\x28\xb0\x8b\xb3\x5a\xf4\xf1\x94\x2f\xa2\xa1\x6c\x36\xf2\x68\xf5\xbf\xf9\xd7\x9d\x4e\xe6\x7c\x7a\x35\x0d\x28\xa3\x43\xb9\xe3\x29\x1f\xc3\x9f\x56\xf7\x72\xab\xed\x1d\x95\x14\x60\xaa\x65\xdc\x5c\x30\x15\x98\xd4\xf7\x79\xfc\x0b\xe6\x81\x06\x55\x73\x4b\x9f\x25\xf4\x85\x9d\x65\xb4\xb7\xe0\x09\xe5\x61\xbb\xc5\xfa\x6a\x1b\xd4\xf4\x05\x35\x07\xfe\xb5\x2f\xc4\x57\xfb\x42\xf7\x85\xd0\x6f\x67\xc4\x04\x5f\xa7\x21\xbd\xc6\xd5\xb2\x35\x4b\x0a\x52\xbd\x66\xbb\x4c\xc6\x25\x28\xcb\x43\xf5\xd7\xbb\x13\x2f\xe5\x08\x9d\x16\xd1\x81\x6a\x5e\xf9\xa2\xbc\x8d\x31\x34\xae\xbc\x0d\xff\xc2\x47\xb3\x41\xb5\x0d\xdb\x26\xd5\xab\xf2\x05\x93\x01\x5d\xab\x06\xdd\x1a\xcf\x9e\xd4\xf4\x82\x37\x9c\xb8\xc5\x74\x2c\x4d\x2e\xe3\x25\xe5\xcb\x8d\xc1\xb1\xe5\x0d\x78\x6e\xa9\xa2\xdd\xe9\x7f\xa1\x5d\x65\xda\xc1\x4b\xe8\x20\x7a\x79\x19\x5b\x51\x31\xdb\x18\xde\xfe\xcf\x43\x6c\x16\x5d\x5d\x1b\x6d\xd5\xf7\xff\x8c\x36\xbd\xac\x9a\xf6\x62\x5a\x4c\x65\x19\xed\xec\x6c\x52\xb4\x17\xfe\xc1\x6f\x54\x72\xc7\x55\xc7\xae\xe8\xa4\x40\x83\xa8\x37\xd2\xd5\xfc\xcd\x85\xea\xb4\xcf\x7a\x9c\x7f\x1e\xa4\x0d\x05\x6a\x5e\x45\xcd\x69\xe7\x0c\x5a\x4a\x6f\xff\xa1\xcc\x18\x1e\xf3\xa7\x14\xbf\xa3\x6d\xdb\xe8\xfe\xff\xe7\x73\x8a\xea\xf8\xe4\xa5\xf4\x0a\x45\xe6\x7c\x1f\x0d\xae\x96\xa7\x59\x52\x30\x68\x6a\x1a\x5c\xbd\xe0\x45\xb9\x59\x83\x52\x83\xc4\x6a\x1f\x6f\x45\x9b\x2a\x0d\x37\x3b\xaf\x66\x80\x86\x67\xc5\xef\xce\x1b\x19\x14\xbf\x57\x38\xc0\x6f\x5c\xe2\xbc\x6f\x70\xc2\xd5\x0c\xaa\x3e\xf8\x42\xad\x6a\x92\x55\x79\xac\xdf\xbb\x54\x68\xbd\x56\x55\x3d\xf3\xba\xb3\x6e\x3c\xbd\x5f\xb9\xd4\x6d\x34\xde\xd9\x3b\x8d\xce\x87\xb4\xa2\x23\xa9\xc9\x23\xc6\x37\xf6\xfd\x78\x5c\xc4\xe2\xd2\x1c\xee\x71\xbe\x1a\x89\x1c\x58\x1b\xb6\xd4\x39\x97\x4d\xe7\x57\xac\x63\x3d\x6a\xd0\xbf\x3c\x29\x1c\xfb\x1e\x9f\x00\xaa\x95\x7c\x0d\xea\xf1\xd4\xa8\xa6\x7e\x8d\x73\x62\x38\x52\xff\x8e\xbf\xa0\x68\x97\xef\xe0\xed\x81\xf6\xc4\xea\x31\xd6\x3a\xa9\x9e\x49\x04\xc3\x8c\x40\x11\x95\xcc\xa8\x8d\x32\xf6\xdd\x79\xb2\x37\x39\x67\x86\x02\xd9\x4e\x65\xe2\xfa\x63\x60\x93\xf2\xee\x7c\x43\x95\x4d\xce\xfb\x82\x1a\x09\x52\x5d\x37\x64\x46\xad\xbe\x10\x02\x1d\x88\xbe\xb0\x7e\x22\x7d\xa0\x4c\xac\x77\xf6\xe5\xd0\xf9\xa4\x46\x3e\xed\x37\x07\x08\x98\x51\x20\x26\x5c\x34\xa3\x20\x25\xa9\x72\x4a\x25\x59\xa5\x53\x40\x47\xd0\xae\x65\x62\xe3\xb7\x65\xb4\xfe\x05\xb9\x79\x8c\xb6\x23\xc6\x52\x61\x48\xf8\x03\x4b\xea\xf8\xe2\xf3\x83\x0b\x63\xd6\xf9\x5c\xf5\x7e\x48\xcb\x55\xfc\x67\x39\x74\x01\x88\xcc\x46\xd4\xa4\xed\x37\xf6\x6b\xa7\x7c\x29\xba\x0f\x39\x3b\xe8\x12\x1a\x5c\x46\xe3\xd9\x8b\x65\x15\xa7\x79\x8b\x9a\xfa\xc3\x9c\xea\x9b\x9f\xb9\x30\xe1\x8f\xca\xda\xa8\x56\xa5\xd5\x3a\x63\x7b\xc1\xd9\x48\x1f\xfa\xb9\x8c\x1f\x2a\xab\xe8\xa1\x46\x17\xde\xab\x3b\xdf\xdf\x6a\x6c\x09\x0e\x14\x4d\xc3\xac\x61\x53\x3f\x3f\xbd\x60\x66\x7d\xd3\xc9\x9e\x4c\xa3\x69\x46\x99\x98\x57\xb1\x8b\x3e\x32\xc5\xd9\xcb\x46\xd5\x1c\x03\x9d\x92\x22\x51\x7f\x53\x8d\x01\x5f\x04\xb4\x90\x7e\x0d\x33\x54\x47\xc1\x06\x97\x98\x07\xb3\x26\xd3\xae\x6a\xb4\xbd\xe4\xbc\x49\x1f\x98\xec\x7c\x00\x71\x3d\xd8\x2f\x7f\xb5\x41\xfe\xd0\xf3\x31\xf0\x42\xfa\x97\x8e\x82\xd3\x9c\xd5\x53\x68\x5b\x9a\x0e\x59\x16\x9d\x33\xc1\x79\x8d\x4d\xac\x31\x86\xa5\xa2\x7b\x3e\x8f\x11\x86\xa0\xe6\xa5\xe9\x56\x27\x46\x8d\x27\xb2\x6b\xcb\x68\x2b\x76\x38\xb3\x62\x21\xbf\xc7\x8f\x1e\xfa\xad\xce\xb3\x2f\xea\xb5\x5a\xb3\x6c\x50\x7d\x3c\x7d\x69\x4f\x19\x2b\xa2\xf7\x65\x3a\xc3\x9d\x4c\x31\xde\x6f\x3c\x55\xcb\xe7\x8b\xad\xff\x44\x3e\x35\xb0\xa6\xa6\xd3\x1e\x65\x6c\x2a\x7d\x20\xcb\x59\xc7\xc6\xd7\x88\xfb\xe8\x07\xaa\xb7\x5c\xf6\x7f\xe4\x07\xbd\x4b\x80\xfa\x88\x32\xd1\xb8\xfc\x08\xcf\x48\xab\xb8\x97\xf7\x50\x76\x4c\xbc\xd0\x0f\x94\x87\x55\x65\x5b\xff\x89\x1f\x54\xc5\xda\x61\x73\x68\x67\x3c\x41\xa8\x98\xcd\x7b\xf7\xae\x78\x84\xad\xc0\x35\x06\x7b\x54\xf3\xe9\x98\xd4\xf0\x42\x3e\x17\xb1\xf9\x1b\x6f\x5b\xef\x0c\x9a\x4b\xd3\x55\xce\x55\xe4\x3c\xce\xc7\x74\xaf\x18\x49\x3b\xb3\x3e\xa4\x26\x9f\xb6\x49\x61\xbe\xb9\xd7\xc7\xa7\x36\x8f\x6b\x50\xab\xc7\x3d\xe6\xcc\x9a\x0b\x27\xb7\xae\x32\x3a\x8a\x37\xec\x5e\xe1\xe1\x8f\xf9\xd1\xb5\xd4\xfc\xe8\xf3\x0f\xf5\x00\x66\x55\xe6\x75\xf1\x39\x58\x83\xaa\xb3\x8f\x09\x73\xe9\x7d\xfb\x61\x92\xe0\x5d\xba\x97\x7f\xf3\x69\x55\xee\xd5\xa3\xb6\x3c\xfc\x22\xf7\xb8\x84\x77\x8c\x9e\x4b\x3d\x65\xb4\x3d\xef\xd9\xbd\xe2\x59\xde\x8e\xf8\xe7\x32\x6a\xde\x09\xad\x9a\x27\x4c\xf5\x31\x2a\x59\x95\x6e\xa8\x27\xb2\x13\x6b\xf7\x0e\x48\x35\x16\xd1\x8e\x55\xf9\x97\x1d\x57\x3e\xbb\x2a\xb6\xc7\x5f\x18\x2b\x7d\xfd\xc6\xa4\x29\xd5\x03\xad\x35\x69\xff\x95\x5f\x0c\x5a\x44\xbb\x55\xe5\x60\x76\x87\xf2\xf1\x17\xe5\x60\x9a\xbe\x6f\x1e\xfa\xe7\xf4\x6b\xcb\xc3\xea\xb4\x2f\x6f\x77\x51\x1e\x76\x01\x7d\x1f\x79\xd3\x47\xdf\xc7\xa0\x16\xfa\xb5\xe7\x62\xae\xf6\x7f\x6e\xd4\xb9\x58\x27\xff\xdc\xa7\x2a\x17\x53\x77\xdc\x7c\xd9\x58\x95\x67\x5c\x94\x8f\xc5\x29\x82\xf7\x1f\x28\x53\xb4\x86\xea\x7c\x2c\xbe\x96\x7c\x0c\x48\x9d\x3f\x91\x4a\xac\x2d\x1f\x1b\xb8\x04\x4e\x70\x80\x4c\xf9\x02\xbe\x95\x5c\x30\x37\xfe\x87\xf9\xd8\xb7\xce\x73\xf9\x74\xae\xca\xc7\x2a\x36\xf4\x67\x0b\x6a\xcd\xc7\x7c\xb9\xcc\x7f\x9e\x8f\x6d\x77\xde\xca\xaf\xca\xc7\xa2\x9d\x00\x20\x5f\x4b\x3e\xf6\x3f\xf2\x58\xed\xec\xcd\xaf\xca\xc8\x86\x3b\x49\xc0\x03\x33\xb2\x5a\x73\x3e\x3f\x1e\x7f\x93\xf3\xc5\xfb\x71\xb8\xdf\xf9\x39\x5f\x67\x65\x25\xce\x44\x60\x80\x69\x59\x8d\xf8\x81\x71\x5f\x9d\x07\x5f\x2a\x2b\x3b\x3f\x4b\x54\x93\x7d\xc8\xf9\x29\x9f\xbe\xa0\xb2\xb2\x61\xce\x0c\x45\xd5\x97\x96\x01\xdd\xec\x9a\x79\x19\x11\x96\xfc\x07\x79\xd9\xc9\x7c\x5a\x5a\x26\x16\x3b\xdd\x06\xaa\x5e\xf4\x97\xef\x9f\xe7\x77\x2a\x4c\xce\x1c\xc4\x0e\x95\x89\x2d\x15\x5b\xb3\xab\xe8\xa4\xd5\x9e\xdb\x72\x15\x2c\xcd\x8b\x33\xa7\x1a\x33\x6c\xab\xaa\x19\xf6\x3d\xe7\xed\x29\x74\x06\x5d\x02\x89\x8e\x73\xcf\x04\x7a\x87\xce\xf7\x06\xf8\xc5\x88\x48\xff\x3e\x02\xea\xd2\x34\xd5\x25\xaf\x2a\x06\xbe\xa5\x49\x6a\x89\x11\x17\xe7\xff\x6c\x69\x75\xfe\xcf\x52\xff\x8e\x8f\x14\x26\xf0\xfa\x4f\xf8\x54\x9f\x05\xd0\x86\xd5\x67\x01\x7c\x30\xa9\xe9\x13\x10\x8b\xc0\x27\x98\x9a\x93\x99\x61\x02\x37\xa3\x46\x62\x71\x7e\xe6\xc1\x91\xcd\xab\x89\xe7\x1c\x99\x4e\x8b\x68\x41\x19\x4c\x18\x87\x27\xd0\xf5\xe5\x8f\x8b\x16\x35\x72\x0b\xc8\x5d\x31\x76\x08\xbc\x86\x63\xe2\xbc\x53\xe3\xba\x58\xcd\xf8\xd1\x0a\x66\x63\xe5\x1e\xeb\xd2\x21\x6d\xe7\x1f\x3b\xeb\xb2\xe8\x03\xe7\xfe\xbb\xbc\x9d\x57\xe5\xed\xc7\x9c\x31\x74\x14\x4d\x2c\x13\xe3\x9c\xe4\x32\x95\x9c\x5d\x22\x6f\x17\x06\xcc\xb9\x96\xe1\x17\x84\x6b\xbd\xb2\x22\xab\xf3\xeb\xd3\x4e\x26\x9d\x46\xdb\x94\xf1\x7b\x9d\x32\xda\x85\xb6\x20\xff\xe6\x39\xc1\x83\xce\x4e\x9a\x09\xe1\x82\xb6\xa0\x73\xcb\x9c\x0f\xf8\xbd\xff\x43\xee\x4e\xab\x2e\x07\x7e\x4c\xaf\xa7\x26\xe4\xa9\x65\x8e\x10\xe3\x80\xde\xa8\xff\x36\x77\x37\x7c\x51\xf9\x7d\x67\xfa\x24\x6a\xd3\xd9\x65\xa2\x45\x45\x08\x5d\x3e\xd1\xe1\x19\x68\x83\xd1\xff\x76\xce\x56\x30\x91\x86\xd2\xec\x32\x5e\x5a\xf1\x2e\xbd\x7a\xa2\xf3\x1b\x5b\xf0\xb3\xe2\x33\xf6\xdf\x3e\x47\x28\x1c\x0f\x49\x46\xef\x32\x96\x0b\x53\xff\x55\xd3\x9c\x5d\xd4\xc3\xc6\xd5\xd0\xe7\xbf\x3c\x47\xb8\xc7\xb9\x65\x0a\xed\x4f\xdb\x41\xc6\x46\x73\x27\x38\xef\x43\xc6\x46\xfc\xec\xaf\xe3\x29\xf3\xcd\x79\x46\xcd\xc8\x7c\xd1\x35\xd3\x56\x93\xd8\x82\x32\xf6\xfe\xc4\x8a\x87\xc4\x07\x3e\x9f\x9b\xf0\xbf\xe5\xf2\xc5\xe9\x34\xb6\x0c\x14\x5f\x9e\xe5\x6c\xe7\xcb\x81\x5e\xe7\xda\x72\x35\x48\x47\xd4\x04\x54\x95\x8f\x5c\x18\xa3\xcf\xe7\x6a\x9f\x38\x3d\xf2\x69\x3b\x38\x21\xe2\x1b\xca\xbb\xb3\x2f\xfb\x3b\x0d\x45\x8a\x4f\xce\x84\x8b\xe2\xa8\xce\xd5\xd4\xb8\xbb\x20\xd9\x09\xfd\xeb\x6c\x6d\x48\x3e\x9c\x73\x4d\x2a\xe3\xed\xcb\x77\x28\x16\x01\x3c\xfb\xbb\x4b\xf0\xa8\xce\xa7\xfe\x31\x8f\x90\xf3\x3c\x7a\xd0\x7e\x65\xac\x07\x04\xe9\x2f\xfb\x57\x7c\xc7\xfa\xb3\x36\xc8\xa3\x73\x65\xc5\xff\x92\xb3\x55\x71\x78\x53\x71\x18\x07\x27\xfe\x74\xac\xf3\x38\xfb\xba\x7f\xc5\x5b\x34\x99\x4f\xf1\xb3\xbf\xce\xd9\x08\x65\x90\x1f\xfd\xa3\x9c\x6d\x68\x3e\xbd\xe9\xcf\x32\x25\xed\x54\x9d\xb3\x75\xbe\x38\x67\xfb\x1b\x1f\x63\x05\xd7\x2b\x3a\xc9\x48\xe6\x90\xd0\x71\xb5\xf7\x7f\x98\xb3\x35\xd7\x39\xdb\x4f\xce\x92\xf9\x10\x7e\x76\x89\xdf\xcb\xd3\x3d\xdc\x27\x53\xea\xbf\x95\x4f\x1d\x76\x5e\x58\x48\x1f\xa4\x03\xcb\xf8\x3c\x1a\x5a\xbe\x19\xe8\x3b\xab\xe9\xe0\xda\x79\xfc\xb7\xd7\xe9\x3e\x77\x36\x2c\xa4\x8f\xaa\x38\x9d\x49\x7f\xae\x60\x1d\xf8\x1f\x15\xc7\x58\x43\x3f\x1e\xd7\xfc\x77\x7a\xf8\x67\x6d\xaf\x3a\x5f\xfb\x78\x3c\xc8\x4b\x2a\x52\x3c\xbc\xbc\xfc\x61\x9e\x4e\x6a\xe8\x51\xe3\x7a\x1a\x50\x36\xff\xea\x7a\x9a\x1f\xe9\xe7\x9d\x23\x3e\xd2\xbc\xa2\x62\x2c\x18\xc8\x77\x55\x14\xe9\xfe\x17\xd7\xd3\xf6\x00\xad\xeb\x45\x54\x45\x17\x5f\x57\x02\x9d\xa5\xfe\xe7\x9d\xea\xf1\x3b\x3c\xef\xf4\x0f\xcb\x35\xae\xa6\x29\xc1\x94\x5c\xfb\x9d\xa7\xe7\xd2\x29\x74\x40\x99\x58\xff\x69\xc5\xa4\xee\xec\x4d\x1a\x5f\x93\x5e\xf5\x75\x2f\x83\x5c\x3a\x7b\xf3\x9b\xcd\x9a\x57\x67\x6f\xdf\x39\xab\xe7\xd0\x42\xda\x0d\x92\xb7\x8a\xa2\xee\x6c\x8f\x4a\xde\xfc\xaf\x23\xfc\x0b\xb9\xdb\x76\xe7\xc5\x39\xf4\x45\xe5\x13\x63\xe9\x8d\x15\xb3\x7b\xf3\xde\xce\x08\xd6\x97\xd4\xe4\x13\x97\x14\x51\x23\xff\xbc\x04\x97\x4b\xf9\xc4\x4b\xce\x56\x1f\x8f\x57\xd9\x4f\x15\x6b\x80\x45\x85\x9b\x5f\xe9\xb3\x51\x17\x3f\x9f\x08\x35\x31\x17\x62\x30\x1e\x2f\xcc\xda\x42\x13\x3d\xb5\x67\xf3\x4f\x3b\x7b\x4a\x20\x9b\x07\x9f\xb8\xbd\x62\x63\x1a\xef\x53\x7e\xa7\x90\x5a\xf6\x9a\x79\x9b\xf0\xdd\x6f\xf9\xc7\x79\xdb\xa6\xb9\x74\x55\x19\x7f\xb3\x62\x65\x77\x3e\x70\xa5\x4f\xd6\x5b\x6b\xfa\x87\xa1\xf2\xb6\x4b\xfb\x07\xaf\xf2\x8f\x3d\xce\x9d\xe3\x21\x58\xf6\x29\x13\xe3\x9d\x4c\xe7\x9e\x4c\x3a\x92\x15\xd5\xa0\x87\xb1\x8e\x4b\x69\x32\xd3\xb2\x09\x08\x48\x85\x0c\x15\xbc\xea\x3c\xd4\x5f\x42\x1b\xe5\x0b\x69\xce\x63\x2b\xde\x1d\xcf\x1e\x2a\x2b\xe3\x5f\x57\x2c\xc8\x64\x87\x8e\xe0\xe3\x3e\x7e\x34\xab\xcf\x19\x0c\x9d\x47\xfc\x27\xe7\x0c\x07\x9c\x7d\xe3\x69\x1f\x3a\x0a\xf2\x2b\xe7\xed\x4c\x3a\x43\x5f\x07\xbc\xf5\x7f\xf6\x3b\xbf\x74\xfb\x9d\x4a\x9f\x51\x68\x4f\xda\xc1\x39\x94\x49\xe7\x39\x9b\xf9\x35\x17\xda\xf9\xf2\xa4\xfa\x35\x72\x79\x03\x4f\xf3\x6a\xf5\x3a\x9c\xf3\xe5\xf9\xb3\xbc\x6f\x26\x22\x79\x36\xe0\xf7\x69\x74\x5e\xc5\x0e\xb1\x88\xd4\xb8\xf6\xfe\x5f\xf8\x45\xc8\xf9\x7c\x9e\xdd\x81\xf9\x3c\x6b\x77\x41\x3e\xdf\x02\xe3\x09\x9c\x8f\x0a\x26\x0d\x3f\x0f\x56\x4b\xe5\xd4\x9a\xd1\xef\x75\x06\xd0\x61\xb4\x7b\x19\xff\xa2\x02\xce\xd0\x1e\xfb\x8b\xbc\xfb\x1f\xe6\xf4\xbc\x3a\x49\x3e\xe9\x4c\xa6\x83\xd4\x55\xa0\x16\x8e\xa7\x8c\xe5\xe1\xa4\x54\x0b\x6d\x03\xaf\xc5\xff\x23\xda\x7e\x09\xf8\x6e\xe7\x7e\xda\x04\x4e\x96\xd8\xed\xce\x86\x32\xba\x8c\x45\x5d\x74\x5e\x03\x51\x43\xda\x2e\xca\x20\x77\xb3\x42\x0d\x7e\xd1\x79\x8d\x26\x06\x93\xdd\x5a\xfd\x08\x0e\x64\x94\x65\xce\x0f\x42\x3d\xb9\xe6\x7f\x3e\xe7\x97\xcf\x2b\xa3\x72\x79\x61\xde\x53\x6b\x3e\x8f\x57\x8a\x09\x85\x01\xb2\xbd\x3c\x86\xce\x9f\xf6\x83\xb8\xe9\x12\xd7\x3f\xfe\xc3\xbc\xcd\xa8\xce\xdb\x80\x41\x00\xbd\xb2\x8c\x8f\x2c\x7f\x0e\x18\xfc\xca\xf7\xac\xfb\x37\xe8\xfb\x5d\xe5\x1f\x4f\x1b\xd3\x99\x98\xb3\x01\x7d\xe7\x0f\xb6\x44\xe7\x6c\xff\x2e\x8f\x1e\xb4\x2f\x64\xcc\x70\x96\x00\x3c\xf6\xd2\x78\x7e\xdb\x05\xf7\x19\xdd\xea\xbe\x27\x61\xb5\x5d\x69\x4b\x3c\x9f\xb5\xe1\xcc\xe1\x74\x70\xa6\x4f\xa4\x73\x69\x9d\x32\x3a\x27\xc7\x79\x46\xfc\x5e\x7d\xcf\xd2\x3f\x6f\xfb\x07\xe7\x06\x6a\xa0\x01\xa5\xae\x48\xe7\x40\xd5\x75\xdc\xf3\xf7\x62\xa3\x92\x02\x54\x7c\xb6\x31\x2f\x11\x17\xdd\x8f\xaf\xce\xd8\x7e\x70\x66\x2d\xa5\x2f\xab\x8c\xed\x4f\x19\x63\x0c\xaf\x71\x8d\xb2\x6a\x7e\xd4\xb9\x94\x14\xfe\xc4\xaa\x7c\xd5\xcf\x6e\x97\x9d\x0f\x3a\xbf\x3b\x37\x2e\xa6\xab\x55\xd0\xb9\xf1\x8f\x3f\x17\xb6\x37\x86\x3b\x9b\x68\x67\x42\x6a\xbd\xcf\x4d\x8c\x4b\x53\x4f\xac\x35\x22\x7f\xed\x3c\xbb\x04\xa9\xb3\x7e\xf4\xc7\x3f\x3f\x01\xf2\x15\xbb\x60\xa6\xa9\xe5\xfe\xfc\x3f\xa3\xed\x1f\x89\x37\x38\x8f\x2d\xa6\x5b\x81\xf6\xf7\x3c\xb8\xdc\x8e\x35\x06\x97\xef\xe5\x97\xd5\x7c\x9e\xe0\xfc\x35\x35\x76\xd1\x13\x05\x97\xba\xa6\xf6\x86\xf3\xca\x22\xfa\x89\xbe\xa6\x1d\x67\x0c\x3d\x7f\xbf\xba\xcd\xc5\xd7\xd4\x18\xe3\x86\xdf\xb5\xe6\x5a\xef\x75\x2e\xa5\x6b\x91\x96\xea\x34\xa4\x53\xe3\x59\x0c\x5f\x6e\xa6\x02\x6f\x2d\x7d\x5f\x9d\x97\xed\x74\x86\x2f\xa1\x6f\xa8\xb8\xbb\x7e\x77\x79\x58\x02\x44\xa7\xde\xe4\x12\xcf\x8a\x18\xf8\xac\x08\xd8\x51\x13\xbc\xb8\x7f\xce\xe7\x64\x67\x9d\xac\xf9\xf4\x55\x3a\xbc\x4c\x7d\x94\xdc\x23\x12\x7d\x39\xd9\xf9\x67\x5c\x3c\xfe\xb9\x12\x5e\xe7\x82\x3f\x7f\xd2\x89\x7f\x93\x91\x1d\x76\x6e\x5a\x48\xdf\x85\x33\x01\x36\x1b\xce\x04\x16\x79\x44\x1f\x67\x35\x1b\x55\xeb\x73\x34\xd8\xff\x7f\xc5\xa1\x76\x2f\xf8\xc2\x79\x70\x31\xfd\x82\x7a\xcb\x3e\x64\x33\xca\xb7\xc6\x8b\xa4\x8a\xa5\x70\xb2\x7c\xc1\x33\x46\x78\x1d\xcd\x97\xa3\x33\xbc\x6b\xe4\x7f\x77\x23\xf1\x82\xc8\x5b\xc3\x17\xde\xbc\x92\x6e\x50\xbe\xd0\xbc\x7c\x9f\x47\x8c\x2d\xdf\x27\x1a\x5e\xe2\x19\x18\x1d\x7b\x95\xf7\x56\x11\xbe\x64\x3e\xf6\xc6\x42\xba\x01\xce\x8d\xca\xcb\x3c\xe2\xfd\x15\xe4\x82\xe7\xb4\xd0\x27\x54\xde\xcf\xce\xbb\x6b\x6d\xd7\x58\x6f\x99\xcb\x8e\x95\x89\xe9\x7f\xde\x9b\x62\x74\xaf\x7e\x46\xeb\x62\x5f\xf0\x8d\xa9\x6a\x73\x5e\x74\xdd\xac\x5a\xd9\xdf\x9c\xdc\x39\xf4\x61\x3a\xa5\x8c\xbf\xf2\x7b\x45\x5a\x1a\xfb\x84\x66\xd2\x40\x52\xeb\xf3\x6e\xbe\xdc\xff\x2f\x7d\xcc\x2f\x03\xfb\xcd\x79\xa0\x98\x96\xd1\x31\x90\x81\x55\x64\xf5\x61\x7b\xf1\x79\xb7\xf8\x7f\xcf\xc7\xb6\x3b\x2b\x67\x42\x46\x3e\xa0\x8c\xba\x69\xfb\x8a\x57\xfa\xb3\xc3\xce\x6a\xfe\x48\x8d\xe7\x0b\x5b\x62\x3e\xee\xeb\x7f\xf3\xc2\x7b\x5b\x97\xee\x7b\x1f\x59\xd6\xb4\x62\xff\x20\x76\xb8\x62\xb7\x98\x7f\x89\x67\xe1\xfe\x59\xdf\xfb\x42\xc1\x1b\x45\xf4\x6d\x24\xd9\x87\x1d\x62\xa3\x48\xcd\x67\x35\xff\x6e\x3e\xa8\xce\xc3\xbf\x75\x86\x8d\xa3\xb7\xd0\xb1\x65\x70\xda\xfb\x80\x33\x63\x1a\x5d\x00\x1a\xd7\x7c\x9e\xd4\xaf\xaf\xfe\xc6\x07\x90\x2a\x66\x02\x5f\x3b\x03\x87\xd3\xfb\x94\xbf\xe7\x38\xb1\x4e\xf6\x4c\x7a\x2d\x7b\xe2\x04\xa9\xf9\xdc\x6b\xd5\x7d\x73\xdf\xb5\x63\xd0\x99\x73\xb5\xa4\x98\x27\xf6\x52\x5a\x2b\x67\x5d\x34\x89\x1d\x2c\x63\x85\x15\xf7\x4f\x64\x9b\x59\x3f\xe2\xff\x7c\x6e\xd5\xb5\xbb\xea\x79\x4b\x88\x6a\x7a\x7f\xe1\x55\x9b\x9d\x37\xa7\xd0\xd9\x34\x17\x32\x2d\x67\x4d\x06\x2d\xd2\xd7\xee\x06\xd6\x76\x5e\xee\xbb\x9d\xc9\xb9\x89\x84\xcf\x53\xae\xb5\xd7\xd7\x4f\x40\x0b\x40\x1a\xb1\x33\x83\x5e\xeb\x6c\x16\x1f\xd5\x7c\xf6\xb5\x16\xfd\x31\xf6\x5f\x52\x7f\xec\xf5\x71\xf4\xd1\x32\xda\xda\xd9\x33\x95\x96\xf2\x07\x49\xcd\x67\xa8\x43\xaa\xee\xcb\x33\x21\xb9\x21\x42\x7d\xa7\x60\x3d\x6a\xa6\x83\xb4\x2a\xcd\x86\x33\x9a\x5b\x69\x20\x5d\x5a\xc6\xdf\x29\x4f\x29\xab\xca\x4b\xce\xe7\xc2\x6d\xce\x3f\x37\xe6\xeb\xf7\x1a\x14\x6b\x4b\x83\xe3\xab\xc9\x06\xab\x7b\x2b\x2d\xcb\xbf\x2a\x13\x6d\xb6\x5e\x48\xb7\x9d\xce\xdf\xab\xf2\xb3\xda\x28\x37\xa8\x35\xc1\x3e\xe8\xac\xa0\x51\xb4\xa8\x8c\xa5\x54\xbc\x53\xc6\xce\x30\xb3\x36\x79\x05\xb9\x24\xd5\x4b\xa7\xed\x5e\x3a\xa1\x8c\xb6\x75\x76\x97\xd1\x09\x60\x55\xf5\x4e\x58\x82\x78\x8f\x7e\x6c\xa8\x35\xfe\xd4\xbb\x2a\xea\x3c\xd4\x2e\xad\x03\x19\x7b\xe4\x67\x1e\x4f\xa2\x7a\xc1\x83\x4a\x7c\x4b\x11\xff\xd1\x8f\xc7\xb5\x8e\xdd\x15\x8b\xff\xc6\x19\x4b\x37\x64\xc1\x7f\x78\xff\x4c\xbd\xbf\xb0\x07\xdf\x5f\x30\xf0\xc9\xec\x08\x66\x58\x87\xad\xb3\x16\xb3\x64\x81\x41\x87\x18\xa5\xc6\x29\x83\x07\x19\x14\xdf\x91\x98\x1d\xeb\x4d\xf7\xbd\xa9\x81\x6f\x46\x28\x11\x4b\xd5\x5b\x11\xb4\xb3\x7a\xb1\xc0\xf7\x5a\xc4\x0b\x4b\x2e\xa0\x79\x59\x52\x03\x6e\x1e\x36\xcf\xaa\x35\xc0\x0a\x08\x1d\x42\x4a\xc9\x29\xc2\xf5\xf7\x37\x7c\x24\x13\xab\xde\x46\x91\x4d\xc3\x9b\xb6\x54\x6f\xa2\xdc\xce\x2e\xab\xd8\x8b\x6f\xa2\xb4\xf2\x7f\x2f\x42\xbd\xff\xdd\x2b\xa9\x7d\xbd\x46\x11\xc1\x22\x20\x20\x38\xc2\x1d\xc1\xb6\x46\x1c\x88\x38\x15\xc1\xb7\x44\xd0\xc9\x11\x05\x11\xec\x54\x04\x5d\x19\xb1\x2a\x82\x25\x45\x0c\x89\x28\x8d\xe0\x11\xea\xbd\x3e\x0f\xbe\xde\x31\x7b\x76\xa1\xba\x45\x0e\xe7\x74\xc0\xad\xd6\xf7\x23\xb8\x7a\xff\x24\x7e\xc9\x25\xde\x8f\xb8\xe7\xe0\xb1\xab\x8c\x0d\x35\x5f\x90\xa0\xd9\x01\x57\xbb\x08\xf7\x7b\x6f\x43\x92\x26\x64\xce\xab\x01\x11\x56\xa3\x46\x61\xea\xad\x93\x7a\x0d\xdd\x7d\xc2\xc2\x82\x2c\xb6\xdf\x38\x69\x54\x1a\xfc\x7d\x30\xa5\xaa\xef\x14\x5a\xbf\x8f\xc1\x83\xa5\x5b\x26\xc9\x21\x72\xb2\x2c\x95\xe6\x56\x79\x40\x9e\x92\x7c\x8b\xa4\x93\x65\x81\x64\x6a\x11\x62\x76\x4a\xd2\x95\x72\x95\x64\xaa\x51\xa9\xe4\x92\x68\x55\x66\x17\x7a\x3f\x6b\x37\x7b\xb6\x27\xd6\x9b\x18\xdb\x4e\xaf\x5f\x59\x4f\x7f\x41\x8b\xd6\xaa\xdc\x57\x73\x3f\x98\x4b\xc7\x5c\x42\x37\xd9\x6e\x19\xfc\x57\xcb\xeb\x1f\x84\x55\x8e\x35\x0e\xd2\x31\x32\x1c\xbf\x87\xdc\x20\xc9\xa5\xbe\xcd\x50\x0a\x67\x89\xbe\xb5\xc8\xd2\x55\xcc\xea\x10\xc7\x9b\xab\xf7\x64\xa0\x0f\xa9\x7b\xd9\xb2\xb8\x2f\xb7\x38\xaf\x99\x57\x5d\xef\x7c\x11\x46\x9b\x34\x76\xbe\x87\xfe\x7b\xd5\xf8\x8a\xf6\x47\xfb\xd4\x25\x4d\x5e\x23\xb6\x51\x87\x25\x59\x60\x86\x57\xed\x90\x3e\x16\xae\x4b\xb0\xaf\x5d\xe4\xe7\x5e\x9f\x1a\x40\xab\x5e\xf5\x8b\xb0\x29\xcb\x96\xb5\xd2\xaf\xc2\x9a\x8f\x5e\xef\xac\xf2\xbd\x0d\x4b\x2e\x7a\xf7\xca\x9b\xd4\x9c\xb9\x6c\xc3\x90\x36\x57\xe6\x2c\x90\x3e\x6b\x9a\xca\x70\x05\x60\x3a\xfc\xa1\xcc\x37\xdb\x1b\xeb\x3b\xb3\xc7\xd7\x78\xe3\x9b\x2a\x83\xa9\xa1\xd6\xee\x31\xe7\xe7\xc7\x58\x77\xe5\xc8\xb2\x9d\x7a\xb5\xc7\x59\xb6\x04\xe7\x85\x48\x80\x17\x70\x6d\x4b\x88\xdf\x75\xa8\x6d\xc3\xcc\x6d\x05\xd4\x95\x75\x48\x9d\x21\x63\xd5\xf5\x6c\x3b\x9c\x05\xe9\xc7\xb8\x2f\x58\x1c\x1a\xd7\x3b\xf6\xe2\xf7\x2d\xe1\x2f\x72\xd6\x9a\xc2\xc2\x35\xb3\x58\x0e\xdd\xe6\xc4\x5e\xeb\x44\xd1\xc3\xf8\x9e\xe1\xa8\xca\x13\x22\x4b\xb6\x0d\x6d\xc9\x33\xd5\x1a\x35\x6c\x39\xf9\x5a\xad\x7b\x21\x1f\x21\x47\xe9\x44\xd2\x29\xa9\xa5\xe0\x4d\xe2\x62\xe3\x06\xc7\xf1\xb5\x71\x34\x38\xae\x34\xee\xe1\xb8\xf7\xe3\x4e\xc5\x19\x71\xac\x75\x08\xec\x63\xad\x49\xeb\x56\x66\x3d\xb5\xf4\x4d\x7c\x3c\x69\x17\xaf\xc6\x54\x7c\xfc\x5f\xd0\x7d\xd4\x8f\x6e\xd7\xd8\xae\x83\xbb\xf2\xb5\x5d\x69\x70\xd7\xd2\xae\x0f\x77\x7d\xbf\xeb\xa9\xae\x46\xd7\xff\x92\xee\x8b\xff\x47\x74\x57\xfd\xcb\x74\x37\xb1\xc8\xca\x2f\xab\xed\x1b\x97\xe4\x16\x3c\x36\xb5\x47\xea\xe0\xd4\xb5\xa9\xa2\x34\xf5\x54\x2a\x4b\x65\xad\x5a\x21\xc5\xb6\xa4\xad\xe7\x3c\xc5\x10\x45\x32\x3e\xbe\xb6\x3e\xf3\xd9\x34\x44\xfa\x68\x2b\x9a\x8c\xc7\x26\xf4\x48\x18\x9c\xb0\x36\x41\x94\x26\x9c\x4a\x60\x09\xa2\x73\x67\xa4\xd9\x95\x74\xed\xf5\xcf\x68\xbe\xf8\x7f\x40\x73\xd5\xff\x4e\xb3\x12\x4e\xeb\x99\x89\x34\x67\x02\xcd\x96\x6c\xf9\xa3\xe8\xad\x95\xf7\x80\x35\x3b\x27\xb5\xe2\xac\x49\x74\x6c\xf4\xe0\x68\xbe\x36\x9a\x06\x47\x97\x46\x3f\x1c\xfd\x7e\xf4\xa9\x68\x23\x9a\xba\x5c\x21\x2d\x39\xa3\x01\x24\xa0\xae\x30\x6a\x10\xc6\x7e\xaa\xdc\x05\x74\x5b\x5c\x44\xf7\xd1\xca\xe7\xff\x47\xba\xef\xaa\x0f\x0d\x5c\x44\xf7\xc5\xca\xdb\xff\x05\x79\xbd\x17\xd1\x5d\x55\xf9\xf6\xff\x48\x57\xd9\xb7\x4e\x35\xdd\x56\x60\xd9\x07\x7d\x7d\x46\x8e\xfa\xfa\x8c\xb2\xd8\xc8\x1e\x91\x83\x23\xd7\x46\x8a\xd2\xc8\x53\x91\x2c\x92\x37\x6a\x14\xd2\x92\x72\x16\x4d\xa2\x5b\x5e\x40\xd2\xaf\xcf\xc2\xfd\x68\x3e\xfa\x2f\xd1\xf4\x97\xf3\xc5\xff\x03\x39\x57\xfd\xef\x34\xc9\xb5\x95\x27\xb8\x83\x34\xe7\xea\x79\x65\xbb\x9e\x5f\x37\x55\xf7\x54\xdb\xd8\xb6\x83\xdb\xf2\xb5\x6d\x69\x70\xdb\xd2\xb6\x0f\xb7\x7d\xbf\xed\xa9\xb6\x46\x5b\x5a\xbf\x3e\xf6\x54\x04\x89\x68\x68\xd6\xbd\xb0\xa7\x6a\xa3\x0d\xf3\xc0\xd7\x28\x2f\xf2\x50\xb4\x29\x6b\xd2\x32\xb6\xe5\xe0\x96\x7c\x6d\x4b\x1a\xdc\xb2\xb4\xe5\xc3\x2d\xdf\x6f\x79\xaa\xa5\xd1\x92\xb7\x6e\x8d\xb4\xdb\x90\x36\x6d\xff\x21\xed\x17\x95\xbc\xff\x47\xb4\x57\x91\x53\xff\x67\xb4\x1f\x21\xdb\xf5\x9c\x13\x55\xdd\x87\x2d\x7b\x00\xed\xb5\x2d\x45\x29\x10\x65\x2d\xb9\x9a\x6f\xa9\x9e\x6f\x83\xfe\x41\x1f\x56\xdb\xf9\xdf\xa4\xf9\x22\x79\xef\x5f\xa7\xb9\x8a\x8a\xff\x95\x66\xe5\x16\xb5\xd0\x82\x6c\x57\x35\xcf\x90\x19\x8f\xbe\xad\xbc\xb8\xf2\x61\xf2\x64\x88\x74\x05\x54\x8e\x81\x1e\x7b\x39\xe9\x0e\xd1\x2e\xa2\x6b\xc4\xcc\x88\x85\x11\xa2\x4e\x44\xa3\x08\xf5\x63\x7c\xc4\xf2\x88\xfb\x23\x64\x57\xa8\xbb\x3f\x82\xef\x8c\xa0\x67\x23\x68\x04\x5f\x19\x06\x7d\x1b\x16\x1b\x96\x1f\xb6\x24\x6c\x65\xd8\xda\xb0\x2d\x61\x27\xc3\xac\x20\xa8\xe8\x11\x36\x29\x6c\x05\xfc\xac\x0c\x93\xaa\xa8\xf6\xaf\x08\x5b\x05\x2d\xf6\x43\x8b\xca\x30\x57\x18\xa3\xae\x49\x2e\x4a\x5c\xc1\x2e\xb7\x2b\xce\x95\xe4\x32\x54\x21\xc9\x35\xc4\x35\xd9\x55\xe0\xda\xea\x3a\xe0\x3a\xe5\xb2\x5d\x18\x3c\x68\x20\x09\xac\x9e\xdc\x40\x9d\xd9\x85\x85\x50\x82\xdc\xab\x70\x52\xba\xda\x40\xe1\xef\x75\x33\x5d\x75\x77\xff\xff\x4f\xb3\x20\x12\x14\xf0\x37\x9a\xe9\x79\xcc\x75\x91\x5e\x30\x8b\xf9\xf5\xd9\x23\x49\x57\x8b\xfc\x66\x4b\x9a\xad\x68\xb6\xb6\x99\xe8\x01\x9b\x95\xcd\x78\x50\xb3\x1e\xcd\x06\x43\xdd\x4a\xa8\x33\xb7\x36\xa3\xa7\x9a\xd1\x66\xbc\x49\x78\x6c\x78\x7e\xf8\x92\xf0\x95\xe1\x6b\xc3\xb7\x84\x9f\x0c\xb7\x7a\x84\xaf\x80\x1f\x3c\x08\xea\x7b\x60\xbd\x11\x0e\x26\x9f\x14\x48\x49\x60\x70\xa0\x3b\x30\x2e\x30\x29\xd0\x50\x85\xa4\xc0\x21\x81\x93\x03\x0b\x02\xb7\x06\x1e\x08\x3c\x15\x68\x07\x2a\x0d\xc2\x49\x78\x63\x90\xbf\x46\x17\xa9\x7f\xfe\xaa\x9c\xef\x22\xf2\x37\xba\xf8\xfa\xe8\xff\x01\x4d\xaa\xc7\x66\x3b\xbf\x38\xf0\x29\x79\x32\xb8\x15\x99\x41\x3e\xab\x7c\x1b\x34\x09\x98\x4f\xc8\x4b\x49\xb7\x8b\x76\x2d\xba\xb6\x98\xd9\x62\x61\x0b\x51\xa7\x45\xa3\x16\xea\xc7\xf8\x16\xcb\x5b\xdc\xdf\x42\x76\x85\xba\xfb\x5b\xf0\x9d\x2d\xe8\xd9\x16\xb4\x05\x9c\x65\x82\xb7\x45\xc4\x46\xe4\x47\x2c\x89\x58\x19\xb1\x36\x62\x4b\xc4\xc9\x08\x2b\x08\x2a\x7a\x44\x4c\x8a\x58\x01\x3f\x2b\x23\xa4\x2a\xaa\xfd\x2b\xe0\x8c\x74\x6d\xc4\x7e\x68\x51\x19\xe1\x8a\x60\x7c\x52\x34\x25\xd1\xc1\xd1\xee\xe8\xb8\xe8\xa4\x68\x43\x15\x92\xa2\x87\x44\x4f\x8e\x2e\x88\xde\x1a\x7d\x00\xb2\x04\x3b\xda\xe7\x6c\x10\xd4\x1a\xcb\x20\x7f\x67\xbb\xd8\xd7\xfe\x46\x2f\xe9\xaa\x4b\xd4\xf7\x66\xfe\x9f\xd3\x8c\xd4\xd2\x67\x3e\x9d\x30\x87\x0f\xf5\x8d\x24\xf5\xb4\x06\xb9\x2b\x69\xa1\xc8\x8f\x59\x12\xb3\x22\x66\x6d\x8c\xe8\x01\x9b\x95\x31\x3c\x28\xa6\x47\xcc\x60\xa8\x5b\x09\x75\xe6\xd6\x18\x7a\x2a\x86\xc6\xf0\x26\x4d\x63\x9b\xe6\x37\x5d\xd2\x74\x65\xd3\xb5\x4d\xb7\x34\x3d\xd9\xd4\xea\xd1\x74\x05\xfc\xe0\x41\x50\xdf\x03\xeb\x8d\xa6\x8c\x4e\x8a\x84\x93\xbe\xe0\x48\x77\x64\x5c\x64\x52\xa4\xa1\x0a\x49\x91\x43\x22\x27\x47\x16\x44\x6e\x8d\x3c\x00\x49\x87\x1d\xe9\xd3\x21\x92\x44\x36\xac\x4d\x87\x4b\xf7\x0d\xc8\xff\xa1\x96\xbf\x0e\xca\x5f\x97\x7c\xfb\xff\x6b\xf9\xd5\xb3\xd5\xc1\x4a\x7e\x75\xf7\x32\xc4\xb4\x1c\x77\x57\xd2\x22\xa9\x21\xab\xbb\xb2\xee\xaa\xba\x8c\xd4\x7d\xbf\xee\xa9\xba\xbc\xae\xd1\x92\xd9\x63\xed\x00\x43\xe2\xda\xae\xed\xd2\xd3\x01\x29\x7e\x9f\x27\xdd\xb8\x93\x34\x53\x2b\xb6\xdb\xee\x88\xd0\xd0\xb0\x7a\xf5\xb8\x9b\xb7\x68\x1e\x55\x77\xd2\xd8\x28\xd1\xb0\x5e\x38\x27\xe6\xa4\xb1\xa4\x5e\xa8\xfe\x24\x4f\x68\x62\xf5\x8a\xed\xd5\xeb\x4a\xb5\x6c\x95\x80\x2b\xee\x86\xa8\x25\x85\x02\xa9\xfa\x7a\x08\xf7\xd6\x0f\xf7\x76\x6a\xe1\xf5\x90\x86\x34\x98\xf1\x97\x26\x3d\xde\x75\xc9\xb8\x19\xa5\x33\x36\xbe\x34\x77\xeb\xfc\xb5\xe2\x0d\x29\xfa\xd0\xa0\xc7\xce\x50\x63\xa7\x33\xba\x5f\xbf\xa2\xbc\xdd\xbf\xb3\xa2\x2f\x7e\xce\x7e\x39\xab\xfc\x5a\x91\x42\xbb\xdf\x97\xb1\xf4\x66\x67\x8b\x73\xa8\xa2\xd8\x59\xe7\xec\xf5\x5d\xfb\x53\xb2\xba\x0d\xf5\x1d\xb4\xae\x49\x8d\x1b\x84\x87\x93\xc0\x90\x90\x80\x50\x12\x6a\x10\xde\x28\x32\x3c\x30\x34\xa2\x1e\xe7\xd6\xa4\xb1\x3c\xb4\x4a\x54\xfd\xa2\x6e\x03\xb5\x74\x17\x2e\x17\xa5\xa4\xc5\x2f\x7e\xb6\x8a\xaf\xef\xc5\xaf\xe8\xd1\x26\x6a\xc1\x62\x2f\x6d\x19\x1f\xe2\x35\xdc\x8b\x16\x0c\x4b\xee\xd8\xba\x7d\x87\xf0\xf2\x43\x86\xf1\xec\x37\xec\x8f\x80\xe7\xaf\xbb\xeb\xa6\xc0\x7b\xea\x44\x25\x0f\x1f\x2f\x5e\xc9\x78\xaa\x7c\x8c\xb1\xf4\xcf\x6b\x36\x8e\xe1\x93\x95\x3c\x95\x27\xd0\x76\x97\x91\xbe\x49\x2d\x02\x9a\x37\x0a\x0f\xaf\x6f\x08\xd1\xa0\x7e\xf3\xfa\xad\x5a\x36\x6a\x52\xbf\x7e\x93\x26\xc1\x93\xc6\x36\x11\x11\x9c\xd8\x93\xc6\x0a\x41\xea\xa9\xab\xc8\xf8\x39\x07\x5c\x41\xd9\x77\x7f\xbd\xc6\x47\x4e\x40\xba\x66\x2d\xd4\x7a\x56\xcc\xeb\x09\x0d\x89\xf7\x59\xb3\x31\xf5\xb7\x66\x48\x78\x30\x61\xbf\xaf\x71\xfe\xb8\xde\xb5\xd6\x95\xfe\xc8\x0d\x3b\x3f\xf7\xb7\xa8\xf5\x2c\x58\xd4\xf9\x34\x6c\xfe\xa1\x47\x96\x3c\xd8\x8f\x72\x5a\xef\x5e\x34\xea\x5a\x5a\x06\x36\x1d\x38\xf7\x1a\x65\xd3\x97\x9d\xe7\x9d\xe7\x08\x73\x36\x93\x19\xd4\xc3\x67\xa8\x6b\x93\xa4\x55\x52\x03\x3b\xe8\xc8\x58\x62\xd3\x36\xdc\xe6\xe1\x47\xc6\xc6\xf2\x1e\x9c\x05\x73\xaa\xd6\xd3\x9b\x0d\x42\xab\x8f\x80\xb5\xab\x5e\x61\xf9\xc2\xa5\x06\xa9\xe7\xa1\xbb\xef\xba\xff\xce\x87\x1f\xb8\xf3\xb6\x01\xc3\x47\x0d\x1c\x34\xec\x51\xfa\xfd\xbb\x1b\xd6\xad\x5d\xff\xde\xba\xb5\xcb\x4b\x97\xde\x70\xcd\x32\x42\x21\x9e\x2e\x22\x4f\xc1\x39\xae\x49\xda\x25\x35\xa2\x84\x95\xc6\x8a\x95\x82\xad\x55\x6b\xc7\xaa\xeb\x8c\xc1\x6a\xf9\x15\x04\xe5\xdf\xf0\x2f\xf2\x33\x75\x15\x13\xbf\x98\xe6\x0d\x69\xf2\xd1\xd6\x25\x8b\xd8\xd8\x79\x37\xce\xaf\x88\x24\xd4\xd9\x47\x16\xd1\x16\x20\x7b\x14\x49\x4e\xba\x4c\x36\x08\x21\x75\xeb\x86\x84\xb8\x40\x81\x10\x50\x20\x44\x8d\x1a\x28\x5f\x4c\xd5\x67\x78\xa5\x0a\x16\x7c\x97\xe4\x2e\x8b\xbf\x82\x26\xa8\xaf\xee\xfa\xbe\xa1\xe4\xf7\x25\x40\xd9\x34\xdc\xd9\xd7\x62\xc1\xd4\x09\xa9\x69\xdd\xbb\x0c\xb7\xae\xab\xf3\xc0\xfc\xab\x6f\x1d\x31\x74\xc1\xc8\x70\x7a\xf7\xa2\x5e\x69\x57\xa6\x25\x0d\xbf\xbc\x53\xe7\x4e\xf1\x8d\xc7\xcc\x2c\x98\x9a\x3a\xa7\xd3\xd0\xd4\x16\x79\xe8\xab\xce\x56\xb0\x6d\x1c\xc8\xd7\x9c\x4c\x4a\xea\xd2\x34\x38\x28\x38\xe8\xf0\xd8\x60\xf5\xa5\xb0\xe0\xe0\x28\x1e\x14\xa1\x66\x6e\x1e\xc4\x23\x22\xa2\xa2\xea\x83\xa0\x51\x20\x74\x14\xb7\x8f\x8c\x55\x57\xc5\x98\x94\x35\x8c\xef\x8d\x4d\xaf\xb2\x7f\x95\xf4\xbe\x2f\xe8\xa9\x6f\x63\x55\xf5\x88\x1e\x80\x1d\xdb\xd1\x04\xdc\xaa\x95\xbd\xb4\x22\x32\xbc\x3e\x8d\xbb\xef\xb6\xab\x1f\x0b\xbc\x3d\xf4\xe6\x3e\xc3\xde\xea\x11\xe8\x1d\x3d\xf0\xc6\x6b\x03\x6e\x04\x6d\xae\xb9\xfd\xc5\x8f\x68\xff\xe9\x0b\x66\x4d\x8c\x2c\x48\xea\x3a\x63\x66\x6c\x87\xac\x29\x41\xe3\xf3\x0a\x26\x2e\x6b\xca\xea\xa9\xeb\xce\xeb\xc1\xce\xc9\xd0\x67\x2e\xb0\x61\x72\x52\x1b\x22\x82\xc4\x91\xb1\x96\x51\xc7\x0c\x52\xca\x04\x05\xb1\x58\x73\xa5\xc9\xd6\x9a\xd4\x54\xef\x0c\xb1\x60\xc6\x10\x58\x55\x1f\x2a\x41\x43\x13\xbd\x78\xcd\xcd\x77\xf1\x53\x7d\x27\x20\xc4\x0b\xe9\x04\x35\xa5\x77\x6b\xb1\x33\x8d\xde\xb4\x74\xf6\x89\x16\xaf\xd4\x8d\x28\xa7\x51\x2b\x57\x8e\xa0\x67\x9c\xb6\xb3\xe9\xaa\xf8\xfd\x30\xc0\xa9\xb3\x05\xec\xd8\x81\x8f\x27\x8d\xc9\xd4\x24\x57\x44\xa3\x7a\xf5\x1a\x35\x02\x4b\x36\x52\x17\x67\x3d\x20\x40\xa3\x46\x61\x3c\xac\xc1\x91\xb1\x2a\x63\x5c\x15\xc6\x83\x20\x69\x54\x09\xa5\xa8\xcb\xc3\xd0\x9c\xe6\x64\x93\x99\xe6\x25\xcc\x39\xbb\xea\xeb\x62\x55\xc3\xd1\x67\x4c\x77\xd5\xd2\x9b\x3e\x7f\x68\x5e\xaf\x69\x78\x53\x89\xb6\xa4\x1d\x9e\x58\xee\x54\x76\xb8\x3d\x6c\xf0\x15\x03\x46\xf7\x1d\xd2\x63\xa8\xbb\xa4\x31\xad\x70\x0a\x43\x9a\x8f\xe8\x71\xd5\x5d\x74\xc1\xa2\xdb\x3f\x8e\xe8\x1a\x3f\xbc\x77\xaf\x61\xad\xa3\xe9\xdd\x25\xab\xa3\x9a\x2f\x53\x36\xfc\x82\xe4\x40\xff\xce\x80\x51\xd6\x8c\xf4\x7e\x35\x2c\xf2\xf0\xd8\x10\xbc\xea\xdc\x0c\x14\x08\x03\x39\xed\xc0\xc3\x63\x03\x02\xf4\xd0\x73\x1f\xc6\xa1\x37\x98\xf3\x0b\x06\x9f\xfa\x14\x8d\x4f\xdc\xc4\x9a\xe3\xd0\xf7\x29\x98\x70\x94\xd0\x7f\xf5\x4f\xda\xe6\x81\xab\xef\x7a\xf0\xa9\x3b\x36\x26\x2c\x8b\x9a\x38\x68\x7c\x83\xc9\x7d\xe6\xdc\x7a\x6b\xda\xd0\x5e\x7d\xfa\xa6\xa5\x0e\xa2\xf9\x73\x57\xbc\xf3\xca\x47\x9f\xde\xdb\x70\xc0\xc2\x45\xcd\x3a\x94\x2e\xec\xdf\xab\x5f\x4a\xea\xa0\x41\x04\xc7\xd6\x95\xb4\x39\x9f\x00\x7d\x1e\x9b\xe4\x26\x96\x6d\xc1\x6c\x60\x2f\xb1\x57\xda\x27\x6d\x31\xd8\x5e\xab\xd6\xda\x14\xc1\x82\x21\x08\x25\x61\xac\x6f\xa9\x41\x90\xca\x64\xe1\xcd\x3b\x86\x26\xe0\x82\xa6\x2b\x17\xdd\x51\xfa\x84\x93\xca\xd2\x58\xf9\x73\xce\x9e\x17\xee\xa2\xcd\xdf\xc8\xc7\x6b\xc2\x5f\xe8\xb1\xd1\x10\xec\xd1\x9e\xa4\x26\xb5\xae\x6f\x37\x6d\xd9\xb4\xe5\xe1\xb1\x4d\x95\x4f\x35\x6d\x1a\xcc\x83\xa3\x0e\x8f\x25\xc1\x60\x8f\x60\xde\xee\x70\xed\x53\x51\x75\xd7\xc1\x36\xd1\xcf\x1e\x09\xf1\x55\x9f\xf4\xc4\x55\xed\xd4\x5a\xa9\xcd\x9b\xa1\x41\x1a\x68\xdb\x28\xd3\xc4\x3d\xb8\x62\xc5\x43\x93\x87\xf4\x1f\x7c\xf7\xe2\x25\xf7\x0d\x1d\x30\x34\xe3\xf1\x1b\xae\x4f\x4d\xbd\x3e\x74\x68\xff\xbe\x43\x1e\x1c\xd4\x8f\xf6\xcc\xc9\x2f\x98\xde\x67\x5a\x00\x0b\x9a\x78\xc5\xa8\xdc\x19\x63\xbb\x4f\x0c\x64\x75\xa6\xd0\xb0\x9c\x9c\x4e\x89\x07\xbb\x74\x4d\x4a\x58\x9a\xe4\xbb\x2f\xb3\x07\xfa\xb6\x2d\xe8\xa2\xbe\x72\x9d\x96\xd4\x36\xaa\xfe\xe1\xb1\xf5\xec\xa8\x24\x3b\xa8\x4f\x14\x0c\x68\x3b\xf8\xf0\xd8\xba\x75\x9b\xd8\xb1\x76\x0f\x1b\xa2\x00\x75\x41\x07\x37\x03\xd5\x50\x97\xc2\x2a\x37\x3c\xdf\xb3\xa1\xd8\xb5\x55\xd2\x37\x3f\xbf\x0a\x2c\x7e\x17\x33\xa1\xea\x43\xb5\xa0\x86\xb3\xe7\x81\xab\xef\x58\x79\xcf\x63\x59\x65\x51\xcb\x82\x06\xb5\xab\xea\xde\x01\xfd\x7d\xdd\xcb\xa6\xce\x5d\xf1\xf6\x9a\x4d\x9f\x0c\x1f\xd8\xb0\x4d\xab\x79\xaa\x83\x17\x0d\x4b\x1a\x90\x96\xda\xaf\x1f\xc8\xfc\xba\xf1\x1a\x0b\xc1\xfb\x3e\x41\xa4\x51\x52\x40\x29\x4c\x93\x49\x9c\xdb\x81\xa5\x96\x6f\xf9\x5f\x8f\xfa\x76\x49\x3a\x7e\x3e\x54\x36\x8f\x6f\xa0\x97\xd1\xac\xe7\xa5\x9d\xbf\x3c\x38\xb9\x38\x67\x2f\xfb\x26\xfb\xc0\x66\xd9\x2e\xe0\x25\xd7\xaa\xb0\x67\x9e\x09\x83\xd4\x9e\x55\x9c\x30\x5e\xa3\xbd\xfc\x68\x1a\xd4\x48\x62\xec\x62\x9a\x3c\x5c\xdd\x34\xa0\xd5\x34\xb7\x4f\x3e\xf8\x25\x5b\xac\x69\x9a\xf3\x5d\x2f\x05\x38\x2b\x35\x51\xb4\x2f\xc8\x4a\xd7\x02\xdd\x60\x12\xa9\xee\x4c\xb2\x00\x75\x57\x23\xe9\x54\x20\x0d\x0c\x0c\x6b\x58\x5a\xaf\x7e\x15\xf1\xf4\xc8\xcd\xe9\xbe\x45\x0d\xcf\xaf\x69\xa8\x6e\xb3\x78\xe4\x79\xf1\x47\x74\xf5\xb6\x0e\xeb\xd2\xeb\x9e\x5e\x9d\xba\xf7\x0f\xa9\x62\xb9\xb1\x79\x70\x52\xd8\xe4\xcb\x3b\x37\x18\xb4\xd3\x9f\xef\x7a\xe0\xeb\xbb\x97\xe5\x86\x51\x10\x55\x4f\x04\x05\x34\x09\x60\x01\xaa\x63\x03\x82\x25\x21\x11\x2b\xa2\x56\x46\xad\x8a\xe2\x51\xee\x86\x20\xc2\x67\xe9\x1e\x4f\xac\x57\xdd\xec\x51\x1f\xe7\xa8\xfd\xbe\x55\x10\x55\x4b\x91\x82\x35\x2f\x75\xeb\xea\xdd\xbb\xef\xdf\xb6\x61\xeb\xfd\x66\x4e\xcd\xfb\x3b\x05\xbd\x02\x6e\x5a\xe1\x52\x32\x7d\x04\x32\x25\xa2\x8d\xeb\x91\x94\xa4\xd6\x2b\xc9\x2a\x08\x6b\x75\x4d\x5c\x51\x16\xa6\x8b\xaa\x93\xe1\x52\x38\x19\x36\x7d\xe7\xc3\x3c\xc9\x45\x5d\x30\xd5\xac\x09\x8f\xe8\xe3\x32\x49\xec\xe6\x76\x30\x2b\x83\xb5\x0a\x43\x13\x55\x67\xd4\xf3\x75\x70\x8d\x15\x34\x9b\x1f\xdc\x77\xd5\xd8\xa5\x4f\x84\xce\x0c\x99\x31\x62\x44\x76\xc8\xcc\xfa\x6a\xa9\xb9\xdb\x5c\xdf\x5e\x5b\x9c\x92\xd0\xb9\xd7\xbc\xa5\xb5\xc8\x61\xac\x32\x98\x01\x72\xb0\xc9\x30\xf1\xb3\x60\xb7\x9d\x64\x0f\xb1\x27\xdb\xa5\xf6\x56\xdb\xdc\x6a\x1f\xb0\x4f\xd9\x3c\xc9\xa6\xb6\x96\xc3\x36\xd5\x17\xa8\x6b\xca\x81\x4e\x51\xaf\x86\x1c\x13\xae\xda\x77\xd0\x5d\x43\x0e\xf3\x6e\xd7\x6d\x01\xce\xf2\x6a\x41\x88\xbf\x4d\xea\x42\x84\x18\x93\xd4\x32\x38\x2a\x3c\x92\x34\x6a\x44\xc2\x93\x02\x23\xfa\x84\x4b\x97\xcb\x2d\x92\xc4\x10\x31\x59\x94\x8a\xad\xc2\xdc\x2a\x0e\x88\x53\x82\x0b\x90\xe4\x95\xc6\xee\x3e\xb8\x05\x89\xd4\x76\x4d\xdd\x90\x3e\x6a\xc9\xd2\xaf\xdb\xb5\x83\x1c\xdb\x13\x9a\xb8\xb9\x5d\x88\xba\x01\x85\x09\x02\xaf\x21\x19\xf7\x73\xb1\x76\x34\xde\x43\x6b\x48\x99\xa9\x9d\xac\x5f\xdf\xe6\xfd\x8d\xd7\xaa\x84\xa5\x81\xe8\x66\x71\x1d\x13\xfc\x7c\xab\x0e\xcc\x19\xfd\x93\x9a\x34\x0e\x0b\x08\xb0\x84\x70\x87\x94\x46\xd0\x21\x11\xea\xfe\xa8\xef\x6e\xa9\xa9\x80\x45\xa8\x48\x11\xdc\x36\xb6\x4f\x7e\x84\xba\x65\xca\x93\x22\x68\x84\xa9\x6f\x97\x2a\x2b\x7a\xbd\x89\xe0\x79\xb1\x78\x1b\x4b\x89\x59\xdf\xb7\xac\x6b\x02\xae\xf5\x7a\x7e\xa9\x57\xdf\xd2\x72\xd3\xae\x0d\x1c\xd9\xf8\xfa\x65\x8d\x47\x86\x2f\x6d\xd8\x3c\x25\xb9\x7b\xa3\xa1\x21\xe3\xc1\xf3\x92\x5a\xa4\x25\x75\x8d\x54\x6e\x58\xa7\xed\x00\xe3\xb5\x19\xe9\xc3\x87\x4f\xcd\xdc\x5b\xaf\x7e\xbd\x6e\xc9\x89\x6e\xd8\x34\x69\x9c\xd4\xb5\x89\x1e\x8f\x62\x35\x0b\x31\x5b\xe2\x38\x0f\x7b\x9d\xe0\xb4\x51\xc7\xaa\x1a\x85\x9f\xfd\xcd\xa4\x61\xb6\xf4\x9b\x34\x14\xbd\x8a\x13\x62\x35\x4d\xab\xa6\x67\x30\x56\x47\x96\xd6\x75\xf9\xd1\xf3\x4d\x18\x0d\xd4\x37\x72\x90\xa2\x9a\x30\x76\x6d\x3e\x90\xfd\x8d\x5a\x76\xb7\x18\xe6\x8b\xe1\xce\x69\x45\xd0\x27\x1b\x3d\x60\x96\x90\x10\xd2\x08\xe6\xa0\x3a\x41\x61\x4c\x06\x06\x86\x47\x96\x36\x08\xab\xa2\xb7\xd9\x13\x72\xc1\x1c\xe1\x5b\xf7\x94\x9f\x17\x77\xec\x80\xee\xf1\x91\x69\x63\xdf\xef\xd9\x77\x7c\xdb\xf8\xfa\x5a\x6e\xe3\xec\xe5\xf5\x86\x44\x14\xc4\xa5\xda\x2d\x27\xb2\x50\x1f\x43\xa5\x01\x73\x5e\x45\xf9\x4f\x12\x9b\x34\x25\xf1\x49\x21\x8d\x03\xeb\x27\x35\x88\xec\x53\x5f\xcd\x13\xf5\x93\x22\x43\xd4\xe0\x4b\x72\x05\x04\xf5\x71\xb9\x0c\x52\x2a\xa4\x4f\x10\x38\x0b\xf0\xc2\xb6\x5d\x3b\x35\x5b\xf0\x6a\xd5\x6a\xbf\x25\x3c\x4d\x2b\x4b\xdf\xb8\xc4\xbc\x61\xec\xd0\x02\x65\x5f\x74\x63\x98\x39\xaf\x80\x7c\x03\xcd\x53\xe0\x6b\x21\x60\x5f\x38\x61\xb2\x78\x29\xba\x8f\xfa\x8e\x10\xda\xd7\xcf\x69\x38\x2e\xce\x4b\xaf\x79\x2d\xb4\x24\xea\xdd\xb7\x1a\x97\x84\xbf\xf2\xb3\x5a\x93\x59\xac\x7e\x76\xf9\xbd\xf7\xde\xfc\x14\xed\x5b\xb5\x36\xf3\x85\x74\x83\xc0\x83\x2f\xa0\xeb\xef\x8c\xdc\xb7\x4e\xf4\xb2\x97\xc3\x4b\x1a\xbf\xf5\x6e\x54\x49\xe8\x6b\xcb\xd5\x92\xd1\x62\xf5\xd3\x37\xdd\x7b\xef\x8d\xcf\xd0\xbe\x7a\xe9\xe8\x2a\xba\x38\x36\x1a\xab\x3e\x6c\x14\x11\x58\x2f\x32\xd2\xf6\xa7\xbd\xd9\x53\x3d\x24\xab\xc8\x5f\xd4\x9f\xfe\x2a\x0c\x4b\xf7\x5b\xd1\xb6\x5a\x95\xaf\x12\x22\x32\xa3\x97\x77\x1d\x59\xa7\x75\x1e\x8f\xae\xd6\xe7\x24\xf0\x6d\x4e\xda\x24\x85\x37\x09\x8e\x50\x5d\x18\x01\x33\x7f\x40\x80\x5d\x0a\xf1\xba\x4a\x02\xdf\x4c\x0f\x9d\x87\x7d\xe7\x2f\x45\xed\xab\x39\xfa\x49\x62\x5f\xa2\x03\xab\x85\xba\xf2\xc2\x0e\xa4\xe4\x53\xb3\x13\xdd\xef\x9b\x6b\x5f\x13\x54\x9a\xbc\x94\xa8\x3b\xfa\x21\x7a\x01\xee\x56\x68\xd8\x3b\x3e\xde\x92\x6a\x76\xda\x7a\xd9\x4e\xdf\x5a\x66\xfe\xc7\x10\x6e\xca\x9a\xc7\xe0\x3a\xcc\xf2\xd3\xd4\x2d\x1f\x9b\x9d\x9a\xee\xbc\x6c\xab\xef\xfa\xe1\x4c\xff\xef\x6c\x04\xb7\x14\x3f\xbf\xed\xfb\xea\xce\xb3\x24\xac\x96\xfd\xa6\xda\x7f\xf1\x77\x3e\xd4\xf7\x55\xe8\x52\xde\xaf\x96\xfa\xe3\xf4\x1e\xde\x4e\x7d\xe3\xc1\x59\xa2\xbe\xd9\x10\xda\xd2\x3a\x83\xf5\xdf\x31\xdf\xf7\x64\x2e\xac\xff\x89\x5d\xab\xeb\x1f\xaf\x51\xff\x23\x5b\x5e\xeb\x37\x75\xfe\xd1\xf7\x5c\x88\xe9\xb4\x74\x96\xd0\x9c\xca\x9f\xa0\x9f\x1b\x40\x4f\xc7\x92\xae\xa4\x07\xf1\x26\x45\xb4\xf7\xb6\x4a\x4c\xec\xd1\xc8\x86\xd3\x92\xa6\x4d\x7b\x5c\xd1\xaa\xd5\x15\x41\x41\x57\x70\x7e\x85\xfa\xe6\x54\x08\xfe\x1f\xac\x3e\xcc\xa6\x2e\x7a\xa8\x2f\xc4\xc5\x75\x30\xfc\x92\xb4\x04\xbf\xb2\xf4\x2b\x5f\xe6\x57\x0e\xf7\x6f\x03\xa7\xfa\x4e\xcb\x18\x77\xb3\x98\x98\x66\xee\x98\x23\x55\x85\xc2\xf6\xee\xe6\xed\xdb\x37\x77\xb7\x67\x9e\xaa\xaa\x18\xb7\x3b\x2e\xb6\x69\xb3\xcb\x37\xe5\x4d\x56\x3f\xaa\x2a\x61\xbb\x0a\xcb\x71\x71\x27\x75\x1d\xfc\x8e\x83\xc6\x31\x31\x34\xdf\xb9\x95\x08\x27\x14\xf4\x8c\x04\x3d\xb9\xca\xc7\x48\x13\xd2\x34\x29\xb0\x6e\x3d\xd9\xb0\x61\x93\x68\x29\xa3\x39\x63\xd1\xbe\xaf\x69\x69\xbd\x50\xa3\xf8\xa6\xe1\x7f\x29\x71\x28\xed\x4d\x9b\x81\x7c\xb1\xb1\x4a\x4e\x2d\xeb\xa6\xbc\x47\x67\xcd\x4a\xaa\x12\x02\x04\x52\xc2\xf9\x84\x80\xff\x84\x33\x01\xe4\x98\x0a\x72\x48\xc8\x15\x9a\x80\xc5\x3b\x26\x05\x85\x34\xa8\xd3\xb8\x71\xf3\x66\x49\x75\xea\x34\xa3\x86\x21\x61\x86\x7c\x3d\xb4\x7e\x1f\x59\x2a\x44\x33\x25\x54\xe4\xe6\x76\xf8\x7c\x55\x6c\x64\xb5\x68\x6a\xe5\xfe\xa6\xe1\xcd\xff\x5a\xbc\x4f\xf2\x68\xef\x19\xf4\x46\x3f\x01\x63\x63\x51\x40\xe7\x44\xe1\xac\x59\x85\x2f\x5f\x4a\x46\x86\xf7\xdf\x1b\x9b\x8d\x40\xc2\x38\x18\x3e\x1d\x63\x58\xab\x40\x1e\x1e\xa6\xa2\xe6\x15\xcc\xa6\xf5\x1b\x44\xb3\xf0\x30\xf5\x21\x8c\x18\x16\xdf\xf1\x0a\x96\x40\xe3\x5b\x18\xe1\x2d\xf9\xe4\x0e\xa9\x03\x22\xfb\x5e\x37\xad\x5b\xf3\xbe\xf9\x03\x87\x16\xa4\x36\x71\x0a\x69\xec\xb8\x20\xef\xe0\x0e\x49\x0b\xd7\x14\x15\xae\x59\xd4\xb3\xef\x92\x67\x26\x3b\x07\xe9\x5d\x34\xe6\x38\xfd\x62\xe4\xad\x45\xa3\x1a\x45\x0e\x2d\xbc\x6d\xfc\x80\xab\x27\x27\x74\x9a\x74\x35\xff\xd0\x79\x77\x72\x48\x97\xeb\x56\x66\xe4\xbd\x76\x75\x9f\x94\x25\xaf\x17\x15\xbc\xb4\x2c\xa3\x29\xed\x32\xf7\x9d\x11\xd7\xe8\x27\xb3\x49\xf8\x28\x42\xf9\x8d\xe0\xe2\xb6\xdd\x07\xfa\xb2\x45\xe5\x0a\xc0\x84\xca\xbd\x80\xdd\x14\xf2\xae\xaa\x86\xa7\x20\xf6\x46\x1c\x84\x38\x0a\xf7\x8e\x46\x4c\x07\x0c\x23\x61\x95\xd9\x90\x6f\x70\xd8\xdb\x02\x28\xa8\x72\x22\x62\x97\xca\x35\x80\xdd\xb0\x3c\x16\x5a\xb6\x20\xe3\x10\x27\x28\x94\x87\xa1\xbe\x0d\x09\xaa\x6c\x0c\x18\x82\xa8\x64\x88\x05\x3a\x6b\x00\x15\x9d\x58\xa4\x13\x0b\x74\x14\x76\x43\x9c\xa0\xf6\xc2\xb1\x2b\x88\x17\x5a\xee\x05\x0c\x72\x7e\x03\x0c\x41\x6c\x01\x6d\xe2\x51\x8b\x78\x38\x56\x61\x17\x44\xa5\x51\x02\xb6\x4f\x40\x8e\x09\x24\x18\x28\x24\x20\xdf\x04\xd2\x18\x31\x1a\x51\x51\x48\x20\x1e\x6c\x99\x82\x35\x69\x88\x7d\x10\x07\x00\xf7\x04\x32\x0c\xcb\x23\xb1\x3c\x0a\xcb\x63\xb0\x3c\x0e\x69\x4e\x00\x4c\x04\x2e\x29\x80\xc1\x58\x0e\xc1\x72\x63\x68\x93\x08\x5c\x14\x2a\x2e\x89\x40\x5f\x61\x1f\x6c\x33\x00\x38\x26\x02\x65\x55\x1e\x89\x6d\xc6\x20\x2a\x7d\xbb\x00\xb5\x15\x80\xc1\xd0\xa6\x0b\x50\x53\xe5\xc6\x58\x8e\x46\x6c\x81\x6d\x52\x10\xfb\x60\xcd\x30\xc4\x91\x88\x63\x10\x27\xc0\x48\xe9\x86\x16\xe8\x86\x16\xeb\x06\xd4\x52\x00\x43\xb0\xdc\x18\x68\x76\x03\x6a\x0b\x01\x95\x6c\xdd\x50\xb6\x6e\x40\x4d\xb5\x51\x5a\x77\x03\x9a\xaa\x3c\x1c\xeb\x47\x60\x79\x0c\x1e\x35\x16\xb0\x2f\xe9\x0b\x94\xfb\xca\xc3\xe4\x32\x32\x12\xa5\x1d\x89\x72\x8e\x84\x9a\x01\x64\x2c\xd4\x64\x03\x86\x00\x8e\xc3\xbd\xe3\x70\xef\x04\xac\x9f\xa0\xea\x79\x57\xde\xbf\x72\x17\xe0\x30\xc4\x51\x58\x33\x1a\x71\x4c\xe5\x07\x80\xe9\x58\xce\xaa\xdc\x0b\x98\x8f\x38\x1f\x30\x09\xda\xbc\xc7\x93\x79\x2f\xf2\x2c\x20\xc8\x0c\xd8\x1b\xb1\x7f\xe5\x4d\x80\x83\xb0\x3c\x0c\xcb\x63\x10\xc7\x57\x3e\x04\x38\x19\xeb\x33\x2a\xd7\x00\x66\x56\xa6\x01\xe6\x60\xcd\x4c\xac\xc9\xc5\x72\x1e\xe2\x6c\xdc\x5b\x82\x38\x0f\xf1\x4a\x32\x05\x70\x31\x94\x7b\x02\xf7\x6d\x80\xe9\x80\x29\xca\xff\x79\x0a\x6a\x91\x82\x5a\xa4\xa0\x16\x29\xa8\x45\x0a\x6a\x91\x82\x5a\xa4\xa0\x16\x29\xa8\x45\x0a\x6a\x91\xa2\xc6\x02\x4f\x03\x6b\x34\x01\x0c\x51\x08\x1a\x3d\x0e\x98\x52\x99\x02\xd8\x1b\x71\x10\xe2\xcc\xca\xa7\x01\xaf\x24\x63\x78\x6f\xe4\xd8\x1b\x39\xf6\x46\x8e\xbd\x81\xe3\xf5\x80\x8a\x63\x6f\xe4\xd5\x1f\x28\xec\x05\xec\x8d\x38\x08\x51\x59\xac\x3f\xec\x7d\x8f\x0f\x84\x63\xd7\x01\x0e\x43\x84\xde\x04\x9c\x58\x79\x0c\x30\x13\x71\x1a\x62\x36\xe2\x0c\xc4\x02\xc4\xd9\x88\x25\x88\xf3\x10\x17\x22\x2e\x46\x2c\x05\x1c\x84\xb2\x0d\x42\xd9\x06\xa1\x6c\x83\xd0\x1a\x83\x50\xb6\x41\x28\xdb\x30\x94\x6d\x18\xc8\xb6\x0b\x70\x10\x96\x95\x6c\xc3\x50\xb6\x11\xca\x57\x01\x83\x9c\x3f\x00\x43\x14\x62\xff\x8e\xc0\xfe\x1d\x81\x3d\x3b\x92\x17\x42\x6f\x8e\xe4\x73\x00\x47\x61\xfb\x51\x68\xc3\x51\x68\xc3\x51\xe0\xd5\x0a\xa3\x15\x82\x3d\xdf\x01\x54\x14\x46\x21\x85\x51\x20\x1b\xb4\x47\x3a\xa3\x40\x42\x55\x1e\x83\x38\x1e\x71\x22\x1e\x35\x09\x71\x4a\x25\x48\x0f\x36\x51\xe5\x2c\x2c\x4f\xc7\x72\x4e\xe5\x0c\x40\xe5\x33\xa3\xc0\x5b\x54\x39\x1f\xb4\x1e\x05\xf6\x51\x7b\x4b\x10\xe7\x56\x0e\x01\x9c\x87\xe5\xf9\xb8\x77\x01\xb6\xbc\x12\xe5\x59\x84\xd4\x16\xe3\xde\x25\x50\x1e\x8d\x5a\x8c\x46\xad\x47\xc3\x08\x4d\x03\x0c\xc1\x32\x8c\x50\xc0\x68\x85\xa8\xcb\x68\xd4\x65\x34\xea\x32\x1a\xbd\x7d\x34\xea\x32\x1a\xbd\x7d\x34\x7a\xfb\x68\xf4\xf6\xd1\xe8\xed\xa3\xd1\xdb\x47\xa3\xb7\x8f\x06\x2d\x54\x7d\x0e\xd6\xcf\xc4\xfa\x5c\x2c\xe7\x21\xce\xc6\x36\x25\x88\xf3\x10\xaf\x24\xf3\x01\x95\xcf\x8f\x01\xbe\x1f\x00\xaa\x9e\x1a\x83\x3d\x35\x0e\x6c\xf5\x32\x60\x26\xe2\x34\xc4\x19\x95\x5f\x02\xce\xc6\x72\x09\xe2\x3c\xc4\x85\x88\x8b\x11\x4b\x01\xc7\xe3\x08\x1a\x8f\x23\x28\x1d\x75\x4f\xc7\xb1\x9c\x8e\xda\xa5\xa3\x76\xe9\xa8\x5d\x3a\x6a\x97\x8e\xda\xa5\xa3\x76\xe9\xa8\x5d\x3a\x6a\x97\x8e\xda\xa5\xa3\x76\xe9\xa8\x57\x3a\xea\x95\x8e\x7a\xa5\xa3\x5e\xe9\xa8\x57\x3a\xea\x95\x8e\x7a\xa5\xe3\x58\x4e\x47\xbd\xa6\xf1\x59\x20\xf3\x34\xf0\xa8\x43\x80\x73\x10\xe7\x57\x7e\xcc\xb3\x41\xbb\xb9\x80\x93\x41\xb6\x6c\xa0\xaf\xca\x59\x95\xcf\x02\x4e\x03\xfa\xd9\xc0\x4b\xd5\xcf\x00\x49\xb2\x81\xa3\x2a\xe7\x22\xe6\x63\x9b\xd9\xd8\xbe\x10\xcb\x25\x58\x9e\x83\xe5\x79\x58\x5e\x88\xb8\x18\xb1\x14\x70\x06\xca\x90\x8b\x63\x30\x17\xc7\x60\x2e\x8e\xc1\x5c\x1c\x83\xb9\x38\x06\x73\x71\x0c\xe6\xe2\x18\xcc\xe5\xc5\x88\x25\x88\xf3\x10\x17\x22\x2e\x46\x54\x23\x71\x16\x50\xfb\x16\x30\x13\x71\x1a\x62\x01\xe2\x6c\xc4\x62\xb0\xfc\x2c\xa0\xa0\xca\x73\x2b\xb7\x00\xce\x03\xf9\x67\x01\x1d\x55\xb3\x18\x71\x09\xd6\x97\x42\xb9\x00\xa8\x7d\x0c\x98\x89\x38\x0d\x31\x1b\xb1\x00\x71\x36\x62\x31\x62\x09\xe2\x3c\xc4\xc5\x80\xb3\x51\xbb\xd9\x68\xe1\xd9\x68\xe1\xd9\x68\xe1\x42\xa0\x79\x08\x30\x13\x31\x1b\x71\x36\x62\x31\x62\x09\xe2\x3c\xc4\x85\x88\xa5\x80\x45\x48\xad\x08\xa9\x15\x21\xb5\x39\x48\x67\x0e\xd2\x99\x03\xb2\x29\xcc\x46\x9c\x8d\x58\x8c\x58\x82\x38\x0f\x71\x21\xa2\xa2\x36\x0f\xa9\xcd\x43\x6a\xf3\x90\xda\x3c\x94\x6d\x3e\xea\x3b\x1f\xf5\x9d\x8f\xfa\xce\x47\x7d\xe7\xa3\xa6\xf3\x51\xd3\xf9\xa8\xe9\x7c\xd4\x74\x3e\xd0\x54\xb8\x18\xb1\x14\x70\x21\x52\x5e\x88\x94\x17\x22\xe5\x85\x48\x79\x31\xd6\x2f\xc6\xfa\xc5\x58\xbf\x18\xeb\x4b\xb1\xbe\x14\xeb\x4b\xb1\xbe\x14\xeb\xd7\xc0\xcc\x66\x02\x86\x20\xce\x02\x6f\x59\x43\x16\x29\x94\xfb\xe1\x7c\xe5\x2d\x88\x20\x93\xf9\xdb\x80\x73\xf9\x3a\xfe\x01\x49\x01\xdc\x54\xf9\x1d\xe0\x66\xd2\x1e\x70\x0b\xb4\x59\xc7\xb7\x62\xcd\x76\x2c\xef\x80\xf6\xeb\xf8\xce\xca\x27\x01\x77\x55\xbe\x03\xb8\x07\x6b\xbe\xc1\xbd\xdf\x92\x06\x80\x67\xb0\x7c\x16\x8f\xfa\x05\x6b\x1c\x45\x0d\xb8\xdc\xc4\xd7\xf3\x75\xb0\x77\x3d\x72\x59\x0f\xf4\x15\x6e\x47\xdc\x51\xf9\x38\xe0\x4e\xf0\xab\xf5\x40\x59\xd5\xec\xc6\x96\x7b\xb0\x7e\x2f\xf0\x5a\x0f\x5c\x54\xfd\x01\xc4\x13\x88\x67\xa1\xcd\x06\xa0\xf9\x0e\xe0\x07\x58\xfe\x08\x71\x13\xd6\x6c\x86\x36\x1b\x80\x8b\x2a\x6f\x47\xdc\x01\x9a\x6e\x00\x2e\xaa\xbc\x0b\x71\x37\xe8\xb2\x01\xb9\x6c\x00\x2e\x37\x01\x1e\xc0\xfa\x23\x78\xec\x8f\x88\x67\xb0\xe6\x2c\x96\xcf\x21\xfe\xa6\x6a\x04\x81\xf2\x46\xb4\xf0\x46\xb4\xf0\x46\xb4\xf0\x46\xb4\xf0\x46\x90\x4a\xe1\x07\x88\x9b\x40\xaa\x8d\x20\xcf\x4d\x80\x9f\x81\x8e\x1b\x41\x2a\x55\xde\x0e\x7c\x37\x22\xc7\x8d\xfc\x5b\xac\x39\x84\x78\x04\x8f\x3a\x8a\xf8\x1d\xd6\x9c\x40\xfc\x11\xf1\x27\xc4\x93\xb8\xf7\x67\x2c\x9f\xc5\x72\x39\x96\x2b\x10\x2b\x15\x82\x84\x50\x8f\x7d\xfd\x01\xdf\x09\x7d\xf1\x01\x68\xad\xca\x7b\x2a\xdf\x02\x3c\x0e\x3d\xfe\x01\x3f\x89\xf5\x67\xa1\x8f\x3e\x44\x39\x3f\xe4\xa7\x41\xaf\x8f\xb0\x8f\x3e\x42\x1f\xf8\x08\xfb\xe8\x23\xbe\x03\x5a\x7e\x04\x74\xda\x03\xee\x45\xfc\x16\x6b\x8e\xc2\x8c\xf1\x11\xc8\xa3\xda\x28\x2b\x6d\x42\xcb\x6f\xc2\xfe\xdd\x84\xc7\x6e\x02\xcb\xef\x00\xdc\x89\xe5\x5d\x88\x7b\xb0\x46\xf5\xe6\xa7\xc8\xeb\x53\x6c\xff\x29\xb6\xff\x14\xa5\xfd\x14\x5a\xbe\xc5\x37\x63\xfb\xcd\xfc\x20\xd4\x6c\x06\x39\x1b\xf0\xcf\xb0\xe6\x33\xa0\xa0\xf0\x5b\xac\x39\x8a\x78\x12\xf1\x34\xa2\xaf\xe5\x6f\xd8\xc6\x81\xf2\x16\xf4\xbd\x2d\xe8\x27\x5b\xd0\x4f\xb6\xa0\x9c\x5b\x40\x2a\x55\xde\x0d\x7d\xb1\x05\xa5\xda\x02\x52\x29\x3c\x82\x78\x02\xdb\xa8\x7e\xdf\x06\x11\x76\x11\x60\x08\x62\x63\xd8\xbb\x0d\x62\xab\xc2\x45\x60\xed\x6d\xd8\xe3\xdb\xb0\xc7\xb7\x01\x7d\x68\x8f\xf6\xdc\x86\xfd\xbe\x0d\xfa\x5d\xd5\x6c\xc1\x9a\xed\x58\x56\x3e\xbf\x0d\xb9\x6f\x43\x8d\xb6\xa1\x0c\xdb\x90\xfb\x36\xf0\x87\x77\x00\x8f\xc0\xf8\xda\x06\x16\x7e\x12\xf0\x24\xa2\xa3\xf6\x42\xcf\xbe\xc3\xb7\xa3\x46\xdb\x51\xa3\xed\x68\xc3\xed\xc0\x4b\xd5\x7f\x86\xe5\x2d\x58\xbf\x03\x6b\x76\x22\xee\x06\x49\xb6\x83\x8e\xaa\xbc\x17\x6c\xbb\x1d\xc7\xd4\x76\xb4\xe1\x76\x7e\x0c\xfa\x74\x3b\x5a\x6c\x87\x3a\xdf\x01\x0c\x41\x9c\x05\x7c\x77\x80\x8e\x80\x38\xd6\xc0\x83\x10\x3f\x82\xa3\x76\x20\xdf\x1d\xc0\x77\x07\xe0\x16\x90\x7f\x07\x8e\xac\x1d\xa8\xc5\x0e\xd0\x42\xd5\x1c\xc2\x63\x8f\x02\xf7\x1d\xe0\xcf\xaa\xfc\x03\xe2\x09\xdc\xfb\x23\x96\x4f\x82\xa6\x3b\xf8\x29\x2c\xff\x8c\x2d\x4f\x23\x9e\x45\x3c\x87\xf5\x7f\x20\x96\x23\x56\x20\x56\x2a\x04\x6b\x40\x1b\xf4\xf3\x9d\xd0\x47\xa7\x00\x43\x10\x1b\x63\x4d\x34\xa2\xd2\x62\x27\x68\xf1\x38\xdf\x89\x3d\xb5\x13\xb4\x50\x65\xd5\x47\x3b\xd1\x6e\x3b\x71\xae\xd8\x89\xf2\xef\xc4\x39\x6d\x27\x6a\xb1\x93\x1f\x44\x54\x63\x73\x27\x3f\x8c\x47\xa9\x7e\xd9\x89\x23\x74\x27\x3f\x86\xed\x8f\xe3\xde\xef\x70\xef\xf7\x58\xf3\x03\x96\x4f\x60\x9b\x1f\xb1\xfc\x13\xe2\x49\xac\x39\x85\xe5\x9f\x11\x4f\x63\xcd\x39\x2c\xff\x8a\xf8\x3b\xe2\x1f\x88\x95\x0a\x71\x2c\xef\x04\x1d\xbf\xe3\xbb\xb0\xdf\x77\x61\x2f\xec\x42\xc9\x77\x41\x2f\xdf\x04\xb8\x13\x5a\xee\x42\x1f\xde\x05\x92\xbf\x05\x78\x02\xf6\xee\x46\x1d\x77\xa3\x76\xbb\x71\x26\xdc\x8d\x3a\xee\x06\x1d\xdf\x02\x54\x23\x77\x37\xce\xa5\x5f\xa0\xcf\x7c\x01\xfe\xd0\x9e\x7f\x85\x5e\xf1\x15\xce\x0c\x7b\x71\x8e\xda\x8b\x91\x62\x1f\x72\xdf\x87\x5e\xb7\x0f\xfc\xfc\x1d\x40\xe5\x03\xfb\x40\x92\xb7\x00\x3f\xc3\xfa\x2d\x88\xdb\x11\x77\x54\x7a\x01\x95\x6f\xef\xc3\x78\xb1\x0f\xbd\x6e\x1f\xd0\x84\x1a\x8c\x41\xdf\xa0\x2e\xdf\x00\xb5\x63\x80\x8a\xda\x37\xa8\xd7\x37\x70\xd4\x5b\x80\xaa\x17\xbe\x01\x9b\xab\x9a\x63\x20\xd5\x37\xa8\xd7\x37\x38\x3f\x7f\x83\xf3\xf0\x7e\xf4\xcc\xfd\x40\xe7\x49\x40\x35\xba\xf7\x03\x85\xc7\x01\xb7\xe0\xde\xed\x88\xca\x4a\xfb\x51\x92\xfd\x38\x0a\xf6\x03\x4d\x55\x3e\x81\xa8\xa8\x7d\x0b\xfd\xa8\x50\x45\xb1\x6f\x71\x36\xfb\x16\x46\xc4\x0e\x7e\x10\x3c\x79\x1b\xa0\x6a\x7f\x10\xfa\xfd\x3b\xc0\x63\x88\xc7\x71\xef\x09\xac\xff\x11\xcb\xa7\xb1\xfe\x2c\x96\x7f\xc1\xf2\x39\xe0\x75\x10\xa3\xc6\x41\xfe\x27\xa2\xa3\xea\x41\x72\x18\x1b\x40\xf9\x3b\xc0\x83\x88\x47\x10\x8f\x22\x1e\x43\x3c\x8e\x78\x02\xb8\x1f\x42\x09\x0f\x61\x7f\x1d\x42\x2e\x87\x50\xce\x43\xc8\xeb\x10\xf2\x3a\x04\x5c\x1e\x07\x54\x5c\x0e\xa1\x65\x0e\x63\x84\x3a\x8c\x11\xea\x30\xf0\xda\x01\xa8\xb4\x38\x0c\x5c\x54\x59\xd1\x3f\x0c\xf4\x55\xf9\x24\xe2\x69\x85\x78\xec\x11\xa0\xb3\x03\x50\xcd\x9f\x47\x51\xc2\xa3\x38\x2b\x1e\x45\xd9\x8e\xa2\xee\x47\xb1\x2f\x8e\x62\x94\x3c\x8a\x16\x3b\x0a\xfa\xaa\x7a\xa5\xef\x31\x9c\xb7\x8f\xe1\x6c\x7c\x0c\xe7\x96\x63\xfc\x4f\xf0\xa8\xe3\x48\xed\x38\x52\x3b\x8e\xfa\x1e\x47\x49\x8e\xe3\x7c\x7b\x1c\x75\x3c\x8e\x3a\x1e\x47\x9a\xc7\x51\xbb\xe3\x48\xf3\x38\x4a\xf5\x03\x7a\xe9\x0f\x40\x5f\xa1\x9a\xff\x7f\x80\x88\xa6\xf0\x04\xe2\x49\xc4\xd3\x88\x67\x10\xcf\x22\x2a\x5d\x4e\xe0\xde\x13\xd8\xb3\x3f\xa2\x24\x3f\x22\xf7\x1f\xb1\xcd\x49\x94\xea\x24\xea\x78\x12\xeb\x4f\xa2\x7d\x4e\xa2\xb5\x4f\xa2\x3c\x27\x31\x22\x9c\x44\x0a\x3f\x43\xfb\x6d\x80\xaa\xe5\xcf\xd0\xf2\x2d\xc0\x33\x58\x7f\x16\x6b\xce\x21\x62\x4b\xb4\xea\x69\xf4\xe1\xd3\x28\xc3\x69\xb4\xc9\x69\x94\xea\x0c\xce\xba\x67\x70\xd6\x3d\x83\x5e\x71\x06\x7d\xfe\x0c\xda\xe7\x0c\x1c\x95\x02\xa8\x24\x39\x83\xf6\x39\x83\xf6\x39\x83\x32\x9f\x85\x63\xbd\x80\x21\x88\x8b\x54\x0d\x52\x38\x8b\xf6\x3f\x8b\x74\xce\x22\x9d\xb3\xc8\xfd\x2c\xd2\x39\x8b\x1e\x75\x16\xa8\x41\x0f\xc1\x5c\xa4\xca\xa7\x11\x7f\x41\x54\x5e\x7a\x16\x65\xfe\x05\xad\xf4\x0b\x5a\xe6\x17\x3c\xf6\x17\xd4\xf1\x17\xd4\xf1\x17\xd4\xee\x17\x6c\x79\x0e\xf9\x9e\xc3\xf6\xe7\x90\xe3\x39\xb4\xcc\x39\x94\xf9\x1c\xd2\x3f\x07\xc7\x2a\xfc\x05\x51\x1d\xfb\x2b\xb6\xfc\x15\x5b\xfe\x8a\x2d\x7f\xc5\x96\x7f\x60\xfd\x1f\x58\xf3\x07\x6a\x5a\x01\xc7\x4e\x06\xfc\x0d\xe6\x22\x07\xe5\x71\xb0\xf7\x1d\x3c\xd6\x41\xd9\x1c\xb4\xad\x83\x12\x3a\x68\x7f\x07\x65\xab\xc4\xf6\x95\xd8\xb3\x95\xd8\xb2\x12\x2d\x50\x89\x2d\x2b\xb1\x65\xa5\x92\x47\x04\x29\x7b\x02\x82\x3d\x45\xb2\x1a\x41\x80\x21\x88\x10\x53\x00\xa3\x11\x67\x55\x4e\x06\x5c\xa4\x50\x45\x1f\x79\x48\x1e\xaa\x84\x59\x52\x5d\x8d\x04\x1c\xa5\xca\x30\xbf\xed\x95\xdf\xf1\x57\x2a\x27\x03\xbe\x83\xb8\x03\x11\xe6\x1f\x40\xc8\x6c\xd5\xa5\x55\x12\x4d\xf3\xd4\xf5\x55\xfc\x6f\x34\x79\x49\x97\x29\x09\xa2\xad\x75\x99\x11\x49\xfb\xe8\x32\x27\x91\xf4\x3a\x5d\x16\xd0\x66\x9d\x2e\x1b\x24\x90\x9e\xd4\x65\x93\x04\xb2\x28\x5d\x96\x64\x01\x6f\xaa\xcb\x16\x09\xe3\x1f\xea\xb2\x4d\x02\xf9\xef\xba\xec\xa2\x39\xe6\xd7\xba\x5c\x87\x44\x59\xa5\xba\x1c\x40\x62\xac\x3f\x75\xb9\x2e\x89\xb7\xef\xd2\xe5\x40\x12\xe9\x62\x20\x09\x15\x36\xfc\x7a\x11\xa5\x52\x65\x0a\xba\x58\xba\xcc\x40\x9e\xce\xba\xcc\x49\x47\x3a\x44\x97\x05\xb4\x79\x44\x97\x0d\x12\x45\xb7\xe9\xb2\x09\x65\x47\x97\x25\x39\xcb\xda\xe9\xb2\x45\x5a\xf3\x07\x74\xd9\x26\x51\x7c\xaf\x2e\xbb\xd8\x76\x51\xc5\xab\x0e\xe9\x6c\xa5\xe9\x72\x00\x99\x60\x3d\xa8\xcb\x75\xc9\x0c\xbb\xad\x2e\x07\x92\x8e\xf6\x66\x92\x42\x72\xc8\x74\xf8\x57\x0c\xff\x16\x90\x2c\x32\x95\xb8\xe1\x5f\x06\xfc\xce\x80\x52\x26\xc9\x27\x05\x64\x3e\x29\xc4\x56\xd9\x50\xeb\x26\xad\xa1\xb6\x0d\x6c\x3d\x24\x8e\x74\x80\x7f\x6e\xd2\x1b\x5a\xe5\xc3\xfe\x5c\x38\xde\x4d\x7a\x41\xb9\x10\x8e\x52\x98\x81\x74\xf3\x49\x1e\x89\x81\x3d\x2e\xdc\xf7\xd7\xf4\x3c\x50\x1a\xa6\xe5\xe8\x83\xc7\x5f\x0e\xa5\xbe\x40\x21\x13\x68\x90\x94\x9c\xe9\x39\xc5\x39\x0b\xb2\xa6\xba\xa7\x66\x14\x67\xb8\x33\xf3\x0b\xe6\x17\xe6\x4c\xcf\x2e\x76\xb7\xce\x6c\xe3\xf6\xc4\x75\x88\x73\xf7\xce\xcf\x9f\x9e\x9b\xe5\xee\x95\x5f\x58\x90\x5f\x98\x51\x9c\x93\x9f\x17\xe3\x76\xf5\xba\xb0\x9d\xc7\x3d\x0c\x68\xf4\xc9\x28\xbe\xdc\xdd\x37\x2f\x13\x08\x0f\x00\x89\xa6\x00\x5f\x7f\x99\xdd\x64\x38\xfc\xca\x23\x45\xb0\x3b\x67\x4a\x96\x8f\x9a\x7b\x78\x46\x1e\x54\x28\x19\xa7\x93\x12\xd0\x39\x03\x8e\x21\xc3\xb2\xa6\x97\xe4\x66\x40\x21\x19\x5a\x67\xc2\xbe\x3c\xd0\x40\x51\x73\x93\xf6\xf0\xef\x6f\xa8\x27\x17\x65\x66\xe5\x4d\xcd\x2a\x74\xb7\x77\x5f\xc4\xe8\x3f\x15\x6c\x14\xb6\x2d\xaa\x6e\xe9\x01\xb3\xc5\xc1\x5f\x0c\x18\x97\x8c\xca\x2a\x2c\x52\x4d\x3d\x31\x71\x71\x31\x1d\x6a\x27\x5e\x0b\xe9\xbf\x92\x24\x07\x9a\xba\xd1\x59\x8a\x71\x8f\x52\x7b\x16\x1a\x65\x26\xd4\xe5\x93\x69\x7f\xd9\xa1\x6e\x68\x97\x85\x0e\x58\x04\x7b\xb2\xf0\xd7\x54\xa4\xaa\x68\x8f\x84\x16\xc3\xb1\xd5\x10\x3c\x52\x99\xb5\x18\xb9\xe5\x61\xab\x11\xb5\x70\x1c\x0c\x1c\xa7\xc1\xf1\x99\xe8\x8c\x55\x2d\x33\x91\xb6\x72\x6a\x1f\xe5\x7c\x28\x67\xeb\x0e\x9a\x01\xdd\x58\x88\x12\x4c\xc5\xe3\xaa\x74\x2b\x52\x0e\xe7\x67\xdf\x9c\x22\x77\x86\xbb\xb8\x30\x63\x6a\xd6\xac\x8c\xc2\x99\xee\xfc\x69\x35\x7d\xc8\x5d\x98\x35\x3d\xa7\xa8\x38\xab\x10\x2a\x73\xf2\xdc\x23\x63\x86\xc7\xb8\x87\x64\x14\x67\xe5\x15\xbb\x33\xf2\xa6\xba\x47\x54\x1f\x38\x78\xda\xb4\x9c\xcc\x2c\xac\xcc\xcc\x2a\x2c\xce\x80\xc6\xf9\xc5\xd9\xd0\xfb\x33\x4a\x0a\x73\x8a\xa6\xe6\x64\x2a\x6e\x45\x31\xb5\xf9\x52\xed\x63\xeb\xbc\xff\xf8\x79\x3d\x01\xcb\x29\x8b\xcd\x41\x3b\x0c\xc4\xe6\xea\x77\x91\xef\x90\xe1\xc5\x59\x73\xb2\xdc\x03\x33\x8a\x8b\xb3\x8a\x54\xe3\x9e\xd0\xa0\x48\x1b\xdf\xd7\xb1\xc9\x68\x94\x59\xf0\x4b\x75\xd8\x5c\x30\x97\x32\x4e\x36\x96\x33\xb0\xd3\xa7\x22\x39\x35\x92\xf3\xf4\x91\x53\x60\x6c\xbb\xff\x92\xb1\x5b\x1f\x9b\xa1\x9d\x27\x0f\xfe\xf2\xa1\xad\x4f\x1b\x75\xcc\xe5\xda\x29\xa6\x21\x16\x21\xdf\x3c\xe0\xe1\x86\xb2\xcf\x33\xdd\x28\xa9\x92\x6e\xda\x05\x52\xb8\xb1\x5b\x33\xd0\x49\x7c\x8e\x39\x0b\xf6\x16\x63\xdb\x4c\xa8\xcf\x85\xbf\xf9\x7a\x5e\x9b\x05\x76\xf4\x71\x9d\xa2\x67\xae\xb9\x38\x0f\x66\x57\xeb\x0e\xed\x9b\x36\x43\xf7\x3b\x6f\x0b\x9f\x4b\x4f\xd3\x83\xcc\x8d\xb5\x05\x50\xce\x47\xd9\xab\xac\xd7\x1e\x7b\x4e\xc9\x9f\x85\x52\xa9\x52\x06\xce\xab\x53\xe0\x88\x5c\xe4\xe3\x93\x23\x1b\x1d\x37\x03\xdd\x2e\x4b\xbb\x61\x31\x4a\x5b\xe4\xe7\xbe\x3e\x67\x75\xa3\xc4\x8a\x7a\x2a\xba\xac\x9a\x4b\xb3\xb4\x25\x47\xc3\x2c\x3c\xa0\x56\x8a\x3e\x6b\xf9\x0f\x1b\xd5\x13\xb9\x28\x6f\x91\x1f\xed\x3c\x94\x76\x2a\xd6\xe5\x57\x5b\x56\xb5\xca\xd5\x9c\x7c\x1a\xe7\xe2\x6c\x3f\xb3\xba\x57\xa6\xa1\x37\xfa\xac\x37\x15\xa9\xb5\xbf\x84\x7d\xa7\xa1\x6d\x8a\x35\xd7\x7c\x94\x68\x2a\xfc\xf9\xfa\xd9\xe7\x51\xf9\x70\x6c\x09\xf6\x9a\x6f\xa8\xfb\x7c\xbd\xf8\x22\xcb\x65\xa0\x7d\xf3\xf5\x71\x05\x38\x0f\x17\x6b\x59\x66\xf9\x86\x6e\xcf\x8c\x22\x18\x8a\x30\x70\x93\x0b\x73\x66\xe5\x5f\xee\x9e\x9b\x9d\x93\x99\xed\x9e\x9b\x51\xe4\x9e\x9a\x55\x94\x33\x3d\x0f\x76\x4e\x99\xef\xae\x39\x10\xdc\xb0\x37\x03\x86\x7a\x5e\x5e\xfe\x1c\x18\x46\x73\xb2\x2e\x87\x61\x3d\xad\x30\xab\x28\x3b\x27\x6f\xba\xbb\x08\xe6\x41\x77\x51\x56\x61\xce\x34\x4d\xc2\x5d\x9c\x9d\x51\xac\x26\x86\x59\x59\xc5\x85\x39\x99\x19\xb9\xb9\xf3\x21\x26\xcd\x2a\x80\x43\xa7\x40\x10\x9a\x9b\x53\x9c\xad\xb8\x67\xe4\x3e\x1b\xe3\x93\x02\x66\x8d\x69\x30\x07\xbb\x73\x66\x15\x14\xe6\xcf\x41\xf1\xda\x17\x65\x16\x66\x65\xe5\x01\x9f\x8c\xa9\x19\x53\x72\x72\x73\x8a\x81\x46\x76\x46\x61\x46\x26\xcc\x25\x30\xa1\xe4\x64\x16\xe1\x5c\x01\x53\x84\xbb\x20\x23\xaf\x7d\x6a\x49\x61\x7e\x41\x16\x08\x39\xba\xf7\x80\xf3\x0d\x41\x2c\xdf\x3c\x53\x94\x9f\x3b\x27\xab\x08\x5b\xe7\x65\x65\x4d\x2d\x52\xf3\xd4\x54\x50\x31\x17\x0e\x02\xc6\xb9\xf9\xf9\x33\x95\x2a\xd3\xf2\x0b\x41\xbc\xa9\xc5\xd9\xed\xfd\xe4\x9d\x96\x9f\x57\x0c\x87\xe6\xbb\x33\xa6\x4e\x05\x9d\xc1\x50\xf9\x99\x25\xb3\xd4\x0c\x06\xb3\x4a\x71\x95\x70\x19\x99\x85\xf9\xb0\xaf\x20\x37\xa3\x18\xa8\xcc\x52\x33\x55\x36\x8e\xf1\x02\xd2\x85\xc4\xc2\xdf\x5c\xfc\x8b\xc1\x91\xee\x3f\x7f\x65\xea\xd9\x2b\x46\xfb\x47\x2c\x1c\x58\x5c\x5c\xd0\x25\x36\x76\xee\xdc\xb9\x31\x19\x7a\x12\xcb\x84\x39\x2c\x06\x84\x8a\xfd\xef\xc9\x2a\x17\x29\x40\x67\xf6\x9f\xa0\x0a\xd1\x2d\x14\xcd\x59\xe0\x2e\x7f\xc9\xba\x78\x7e\x41\x96\x76\x92\xc2\xa2\x98\xec\xe2\x59\xb9\xbe\xf0\xe7\x63\x5b\x35\x4f\x96\xf8\xcd\xcc\x55\xa3\x68\x38\x84\xb6\x01\x18\x86\x0a\xf4\xd8\x4f\xd3\x5e\xef\xbe\x80\x82\x9a\xe7\x2e\x0c\xd6\x1d\x7c\x61\x7a\x00\xc4\x87\x3c\xe5\xbc\x25\x38\xab\xab\xbe\x1c\xde\x77\x80\x7b\x70\x01\xb8\x49\x1a\xf4\x91\x5b\x37\xb8\xdc\x5d\x15\xd0\x3b\xa8\x68\x5e\xd3\x5c\xbe\x19\x28\x07\x7e\x17\xa3\xe2\x45\x38\x7e\x62\xd0\x58\xd3\x61\xff\x60\x90\x6c\x40\xb5\x19\xc0\x09\x73\x0a\x8a\x8b\x62\x8a\x72\x72\x63\xf2\x0b\xa7\xc7\x0e\x4e\x1b\x80\x79\x36\xfe\x57\xd9\x8a\xdc\x45\x6a\xf9\xcf\xd5\x08\xf3\x72\x95\xf9\x0a\xc8\x5d\x4d\xc8\x53\x2d\xc8\x49\x5d\x90\x7f\x06\x40\xae\x19\x48\x82\x48\x30\x09\x21\xa1\xa4\x1e\x09\x23\xe1\xa4\x3e\x69\x40\x22\x48\x43\x12\x49\x1a\x91\x28\xd2\x98\x44\x93\x26\xa0\x73\x53\xd2\x8c\x34\x27\x2d\xc8\x65\xa4\x25\x69\x05\xd9\x60\x1b\xd2\x96\xb4\x03\xeb\xb4\x07\x59\x63\x75\x4e\xe8\x25\x1d\x49\x3c\xe9\x44\x12\x48\x67\x92\x08\xfa\x75\x25\xdd\x48\x77\x72\x05\xe9\x41\x92\x60\x6e\xee\x09\x71\x31\x05\xe6\xc4\x34\x98\x03\xfb\x80\xfd\xfb\x91\xfe\xa0\xd9\x40\x32\x08\x74\x1c\x42\x86\x42\xfa\x31\x1c\x52\x85\x91\x60\xed\xd1\x64\x0c\x19\x4b\xc6\x91\xf1\x64\x02\x49\x27\x13\xc9\x24\x32\x99\x64\x50\x46\x1e\x23\xd7\x90\x6b\xc9\xbb\xa0\xe5\x71\x72\x1d\xb9\x99\x2c\x27\x0f\x92\x67\xc8\xe3\x94\x93\x1b\xa8\x20\x57\x93\xdb\xc9\x69\x72\x86\xdc\x44\x0d\x52\x46\x4d\xf2\x0d\xf9\x99\x3c\x44\x9e\x25\xbf\x90\xb3\xe4\x1c\x79\x94\xbc\x40\x3e\x26\x1f\x41\xd6\x3f\x05\x2c\x7e\x0b\x78\xc4\xa7\xd0\xab\x9b\xc8\x27\x64\x0b\xd9\x4c\x3e\x23\x9f\x93\xef\x60\x5e\xda\x41\xb6\x92\x6d\x64\x15\x58\xfe\x14\xb9\x95\xec\x26\x3b\xc9\x2e\xe8\xaf\x1f\xc8\x8f\xe4\x7a\x48\x40\x72\x60\x3e\x55\x4e\x99\x47\x1e\x86\xfe\x99\x8d\x11\xa5\x08\xfc\xab\x18\xe6\xdf\xb9\xe4\x7b\x32\x0f\x72\xf3\xf9\x64\x21\x9c\xcb\x5e\x49\xde\x20\x8f\x90\x25\x64\x31\x29\x25\x4b\xc9\x09\xf2\x13\x79\x8b\x4a\x6a\x51\x9b\xba\x68\x1d\x1a\x40\x2a\x88\x43\xeb\xd2\x40\x1a\x44\x83\x49\x25\x25\x34\x84\x86\xd2\x7a\x94\xd2\x30\x1a\x4e\xeb\xd3\x06\x34\x82\x36\xa4\x91\xb4\x11\x8d\xa2\x8d\x69\x34\x6d\x42\x7e\x23\xbf\x53\x37\x6d\x4a\x9b\xd1\xe6\xb4\x05\xbd\x8c\xb6\xa4\xad\x68\x6b\xda\x86\xb6\xa5\xed\xe8\xe5\xb4\x3d\x8d\xa1\xb1\xe4\x0f\xf2\x05\x8d\xa3\x1d\xa8\x87\x7a\x69\x47\x1a\x4f\x3b\xd1\x04\xda\x99\x26\xd2\x2e\xb4\x2b\xed\x46\xbb\xd3\x2b\xc8\x41\x72\x88\xf6\xa0\x49\x34\x99\xf6\xa4\xbd\x68\x0a\x4d\xa5\x69\xea\x9b\x9b\xb4\x2f\xed\x47\xfb\xd3\x01\x74\x20\x9c\xc5\xad\xa6\x83\xe8\x60\x3a\x84\x0e\xa5\xc3\xe8\x70\x3a\x82\x8e\xa4\xa3\xe8\x68\xf2\x27\x29\x27\x87\xc9\x11\x3a\x86\x8e\xa5\xe3\xe8\x78\x3a\x81\xa6\xd3\x89\x74\x12\x9d\x4c\x33\xe8\x14\x9a\x49\xa7\xd2\x2c\x3a\x8d\x4e\xa7\xd9\x34\x87\xce\xa0\x33\x69\x2e\x9d\x45\xde\xa6\x79\x34\x9f\x16\xd0\xd9\xe4\x28\x39\x46\x0b\x69\x11\x2d\xa6\x25\x74\x0e\x9d\x4b\xe7\xd1\xf9\x74\x01\x5d\x48\xaf\xa4\x8b\xe8\x62\xba\x84\x96\xd2\xa5\xf4\x2a\x7a\x35\xbd\x86\x3c\x49\xaf\xa5\xd7\xd1\x65\xb4\x8c\x5e\x4f\x6f\xa0\xcb\xe9\x8d\xf4\x26\x7a\x33\x5d\x41\x6f\xa1\xb7\xd2\xdb\xe8\xed\xf4\x0e\x7a\x27\xbd\x8b\xde\x4d\xef\xa1\xf7\xd2\xfb\xe8\xfd\xf4\x01\xfa\x20\x7d\x88\xae\xa4\x0f\xd3\x47\xe8\xa3\xf4\x31\xfa\x38\x7d\x82\x3e\x49\x9f\xa2\x4f\xd3\x67\xe8\xb3\xf4\x39\xfa\x3c\x7d\x81\xbe\x48\x57\xd1\x97\xe8\x6a\xfa\x32\x7d\x85\xae\xa1\xaf\xd2\xd7\xe8\xeb\xf4\x0d\xfa\x26\x7d\x8b\xbe\x4d\xdf\xa1\xef\xd2\xf7\xe8\x5a\xfa\x3e\x5d\x47\xd7\xd3\x0d\x74\x23\xfd\x80\x7e\x48\x3f\xa2\x9b\xe8\xc7\xf4\x13\xfa\x29\xdd\x4c\x3f\xa3\x9f\xd3\x2d\x74\x2b\xdd\x46\xb7\xd3\x1d\x74\x27\xdd\x45\x77\xd3\x2f\xe8\x1e\xfa\x25\xfd\x8a\xee\xa5\x5f\xd3\x7d\xf4\x1b\xba\x9f\x1e\xa0\xdf\xd2\x83\xf4\x10\x3d\x4c\x8f\xd0\xa3\xf4\x18\x3d\x4e\xbf\xa3\xdf\xd3\x1f\xe8\x09\xfa\x23\xfd\x89\x9e\xa4\xa7\xe8\xcf\xf4\x34\x3d\x43\xcf\xd2\x5f\xe8\x39\xfa\x2b\xfd\x8d\xfe\x4e\xff\xa0\x7f\xd2\x72\x5a\x41\x1d\x5a\xc9\x08\xa3\x8c\x31\xce\x04\x33\x98\xc9\x24\xb3\x98\xcd\x5c\xac\x0e\x0b\x60\x75\x59\x20\x0b\x62\xc1\x2c\x84\x85\xb2\x7a\x2c\x8c\x85\xb3\xfa\xac\x01\x8b\x60\x0d\x59\x24\x6b\xc4\xa2\x58\x63\x16\xcd\x9a\x30\x37\x6b\xca\x9a\xb1\xe6\xac\x05\xbb\x8c\xb5\x64\xad\x58\x6b\xd6\x86\xb5\x65\xed\xd8\xe5\xac\x3d\x8b\x61\xb1\x2c\x8e\x75\x60\x1e\xe6\x65\x1d\x59\x3c\xeb\xc4\x12\x58\x67\x96\xc8\xba\xb0\xae\xac\x1b\xeb\xce\xae\x60\x3d\x58\x12\x4b\x66\x3d\x59\x2f\x96\xc2\xd4\xcb\x26\xbd\x59\x1f\xd6\x97\xf5\x63\xfd\xd9\x00\x36\x90\x0d\x62\x83\xd9\x10\x36\x94\x0d\x63\xc3\xd9\x08\x36\x92\x8d\x62\xa3\xd9\x18\x36\x96\x8d\x63\xe3\xd9\x04\x96\xce\x26\xb2\x49\x6c\x32\xcb\x60\x53\x58\x26\x9b\xca\xb2\xd8\x34\x36\x9d\x65\xb3\x1c\x36\x83\xcd\x64\xb9\x6c\x16\xcb\x63\xf9\xac\x80\xcd\x66\x85\xac\x88\x15\xb3\x12\x36\x87\xcd\x65\xf3\xd8\x7c\xb6\x80\x2d\x64\x57\xb2\x45\x6c\x31\x5b\xc2\x4a\xd9\x52\x76\x15\xbb\x9a\x5d\xc3\xae\x65\xd7\xb1\x65\xac\x8c\x5d\xcf\x6e\x60\xcb\xd9\x8d\xec\x26\x76\x33\x5b\xc1\x6e\x61\xb7\xb2\xdb\xd8\xed\xec\x0e\x76\x27\xbb\x8b\xdd\xcd\xee\x61\xf7\xb2\xfb\xd8\xfd\xec\x01\xf6\x20\x7b\x88\xad\x64\x0f\xb3\x47\xd8\xa3\xec\x31\xf6\x38\x7b\x82\x3d\xc9\x9e\x62\x4f\xb3\x67\xd8\xb3\xec\x39\xf6\x3c\x7b\x81\xbd\xc8\x56\xb1\x97\xd8\x6a\xf6\x32\x7b\x85\xad\x61\xaf\xb2\xd7\xd8\xeb\x64\x0f\xf9\x96\xbd\x41\xbe\x62\x6f\xb2\xb7\xd8\xdb\xec\x1d\xf6\x2e\x7b\x8f\xad\x65\xef\xb3\x75\x6c\x3d\xdb\xc0\x36\xb2\x0f\xd8\x87\x64\x2f\xf9\x9a\xec\x23\x07\xc8\x97\x64\x3f\xfb\x88\x6d\x62\x1f\xb3\x4f\xd8\xa7\x6c\x33\xfb\x8c\x7d\xce\xb6\xb0\xad\x6c\x1b\xdb\xce\x76\xb0\x9d\x6c\x17\xdb\xcd\xbe\x60\x7b\xd8\x97\xec\x2b\xb6\x97\x7d\xcd\xf6\xb1\x6f\xd8\x7e\x76\x80\x7d\xcb\x0e\xb2\x43\xec\x30\x3b\xc2\x8e\xb2\x63\xec\x38\xfb\x8e\x7d\xcf\x7e\x60\x27\xd8\x8f\xec\x27\x76\x92\x9d\x62\x3f\xb3\xd3\xec\x0c\x3b\xcb\x7e\x61\xe7\xd8\xaf\xec\x37\xf6\x3b\xfb\x83\xfd\xc9\xca\x59\x05\x73\x58\x25\x57\x2f\xb8\x30\xce\xb9\xe0\x6a\x41\x3a\xc9\x2d\x6e\x73\x17\xaf\xc3\x03\x78\x5d\x1e\xc8\x83\x78\x30\x0f\xe1\xa1\xbc\x1e\x0f\xe3\xe1\xbc\x3e\x6f\xc0\x23\x78\x43\x1e\xc9\x1b\xf1\x28\xde\x98\x47\xf3\x26\xdc\xcd\x9b\xf2\x66\xbc\x39\x6f\xc1\x2f\xe3\x2d\x79\x2b\xde\x9a\xb7\xe1\x6d\x79\x3b\x7e\x39\x6f\xcf\x63\x78\x2c\x8f\xe3\x1d\xb8\x87\x7b\x79\x47\x1e\xcf\x3b\xf1\x04\xde\x99\x27\xf2\x2e\xbc\x2b\xef\xc6\xbb\xf3\x2b\x78\x0f\x9e\xc4\x93\x79\x4f\xde\x8b\xa7\xf0\x54\xf5\x64\x0e\xef\xc3\xfb\xf2\x7e\xbc\x3f\x1f\xc0\x07\xf2\x41\x7c\x30\x1f\xc2\x87\xf2\x61\x7c\x38\x1f\xc1\x47\xf2\x51\xea\x39\x0c\x3e\x96\x8f\xe3\xe3\xf9\x04\x9e\xce\x27\xf2\x49\x7c\x32\xcf\xe0\x53\x78\x26\x9f\xca\xb3\xf8\x34\x3e\x5d\x3d\x41\xc0\x67\xf0\x99\x3c\x97\xcf\x22\x4f\xf3\x3c\x9e\xaf\xee\xa2\xf3\x42\x5e\xc4\x8b\x79\x09\x9f\xc3\xe7\xaa\x3b\xd1\x7c\x01\x5f\xc8\xaf\xe4\x8b\xf8\x62\xbe\x84\x97\x92\x95\x7c\x29\xbf\x8a\x5f\xcd\xaf\xe1\xd7\xf2\xeb\xf8\x32\x5e\xc6\xaf\xe7\x37\xf0\xe5\xfc\x46\x7e\x13\xbf\x99\xaf\xe0\xb7\xf0\x5b\xf9\x6d\xe4\x6e\x7e\x3b\xbf\x83\xdf\x49\xee\xe7\x77\xf1\xbb\xf9\x3d\xfc\x5e\x7e\x1f\xbf\x9f\x3f\xc0\x1f\xe4\x0f\xf1\x95\xfc\x61\xfe\x08\x7f\x94\x3f\xc6\x1f\xe7\x4f\xf0\x27\xf9\x53\xfc\x69\xfe\x0c\x7f\x96\x3f\xc7\x9f\xe7\x2f\xf0\x17\xf9\x2a\xfe\x12\x5f\xcd\x5f\xe6\xaf\xf0\x35\xfc\x55\xfe\x1a\x7f\x9d\xbf\xc1\xdf\xe4\x6f\xf1\xb7\xf9\x3b\xfc\x5d\xfe\x1e\x5f\xcb\xdf\xe7\xeb\xf8\x7a\xbe\x41\xdd\x17\xe5\x1f\xaa\x7b\x8c\xfc\x63\xfe\x09\xff\x94\x6f\xe6\x9f\xf1\xcf\xf9\x16\xbe\x55\xdd\x1b\xe3\xea\x5e\xcb\x2e\xbe\x9b\x7f\xc1\xf7\xf0\x2f\xf9\x57\x7c\x2f\xff\x5a\xdd\x33\xe0\xfb\xf9\x01\xfe\x2d\x3f\xc8\x0f\xa9\x2b\xd8\xea\x1a\x34\x3f\xce\xbf\xe3\xdf\xab\x2b\xbe\xfc\x47\xfe\x13\x3f\xc9\x4f\xf1\x9f\xf9\x69\x75\x45\x94\xff\xc2\xcf\xf1\x5f\xf9\x6f\xfc\x77\xfe\x07\xff\x93\x97\xf3\x0a\xee\xf0\x4a\x41\x04\x15\x4c\x70\x21\x84\x21\x4c\x21\x85\x25\x6c\xe1\x12\x75\x44\x80\xa8\x2b\x02\x45\x90\x08\x16\x21\x22\x54\xd4\x13\x61\x22\x5c\xd4\x17\x0d\x44\x84\x68\x28\x22\x45\x23\x11\x25\x1a\x8b\x68\xd1\x44\xb8\x45\x53\xd1\x4c\x34\x17\x2d\xc4\x65\xa2\xa5\x68\x25\x5a\x8b\x36\xa2\xad\x68\x27\x2e\x17\xed\x45\x8c\x88\x15\x71\xa2\x83\xf0\x08\xaf\xe8\x28\xe2\x45\x27\x91\x20\x3a\x8b\x44\xd1\x45\x74\x15\xdd\x44\x77\x71\x85\xe8\x21\x92\x44\xb2\xe8\x29\x7a\x89\x14\x91\x2a\xd2\x44\x6f\xd1\x47\xf4\x15\xfd\x44\x7f\x31\x40\x0c\x14\x83\xc4\x60\x31\x44\x0c\x15\xc3\xc4\x70\x31\x42\x8c\x14\xa3\xc4\x68\x31\x46\x8c\x15\xe3\xc4\x78\x31\x41\xa4\x8b\x89\x62\x92\x98\x2c\x32\xc4\x14\x91\x29\xa6\x8a\x2c\x31\x4d\x4c\x17\xd9\x22\x47\xcc\x10\x33\x45\xae\x98\x25\xf2\x44\xbe\x28\x10\xb3\x45\xa1\x28\x12\xc5\xa2\x44\xcc\x11\x73\xc5\x3c\x31\x5f\x2c\x10\x0b\xc5\x95\x62\x91\x58\x2c\x96\x88\x52\xb1\x54\x5c\x25\xae\x16\xd7\x88\x6b\xc5\x75\x62\x99\x28\x13\xd7\x8b\x1b\xc4\x72\x71\xa3\xb8\x49\xdc\x2c\x56\x88\x5b\xc4\xad\xe2\x36\x71\xbb\xb8\x43\xdc\x29\xee\x12\x77\x8b\x7b\xc4\xbd\xe2\x3e\x71\xbf\x78\x40\x3c\x28\x1e\x12\x2b\xc5\xc3\xe2\x11\xf1\xa8\x78\x4c\x3c\x2e\x9e\x10\x4f\x8a\xa7\xc4\xd3\xe2\x19\xf1\xac\x78\x4e\x3c\x2f\x5e\x10\x2f\x8a\x55\xe2\x25\xb1\x5a\xbc\x2c\x5e\x11\x6b\xc4\xab\xe2\x35\xf1\xba\x78\x43\xbc\x29\xde\x12\x6f\x8b\x77\xc4\xbb\xe2\x3d\xb1\x56\xbc\x2f\xd6\x89\xf5\x62\x83\xd8\x28\x3e\x10\x1f\x8a\x8f\xc4\x26\xf1\xb1\xf8\x44\x7c\x2a\x36\x8b\xcf\xc4\xe7\x62\x8b\xd8\x2a\xb6\x89\xed\x62\x87\xd8\x29\x76\x89\xdd\xe2\x0b\xb1\x47\x7c\x29\xbe\x12\x7b\xc5\xd7\x62\x9f\xf8\x46\xec\x17\x07\xc4\xb7\xe2\xa0\x38\x24\x0e\x8b\x23\xe2\xa8\x38\x26\x8e\x8b\xef\xc4\xf7\xe2\x07\x71\x42\xfc\x28\x7e\x12\x27\xc5\x29\xf1\xb3\x38\x2d\xce\x88\xb3\xe2\x17\x71\x4e\xfc\x2a\x7e\x13\xbf\x8b\x3f\xc4\x9f\xa2\x5c\x54\x08\x47\x54\x1a\xc4\xa0\x06\x33\xb8\x21\x0c\xc3\x30\x0d\x69\x58\x86\x6d\xb8\x8c\x3a\x46\x80\x51\xd7\x08\x34\x82\x8c\x60\x23\xc4\x08\x35\xea\x19\x61\x46\xb8\x51\xdf\x68\x60\x44\x18\x0d\x8d\x48\xa3\x91\x11\x65\x34\x36\xa2\x8d\x26\x86\xdb\x68\x6a\x34\x33\x9a\x1b\x2d\x8c\xcb\x8c\x96\x46\x2b\xa3\xb5\xd1\xc6\x68\x6b\xb4\x33\x2e\x37\xda\x1b\x31\x46\xac\x11\x67\x74\x30\x3c\x86\xd7\xe8\x68\xc4\x1b\x9d\x8c\x04\xa3\xb3\x91\x68\x74\x31\xba\x1a\xdd\x8c\xee\xc6\x15\x46\x0f\x23\xc9\x48\x36\x7a\x1a\xbd\x8c\x14\x23\xd5\x48\x33\x7a\x1b\x7d\x8c\xbe\x46\x3f\xa3\xbf\x31\xc0\x18\x68\x0c\x32\x06\x1b\x43\x8c\xa1\xc6\x30\x63\xb8\x31\xc2\x18\x69\x8c\x32\x46\x1b\x63\x8c\xb1\xc6\x38\x63\xbc\x31\xc1\x48\x37\x26\x1a\x93\x8c\xc9\x46\x86\x31\xc5\xc8\x34\xa6\x1a\x59\xc6\x34\x63\xba\x91\x6d\xe4\x18\x33\x8c\x99\x46\xae\x31\xcb\xc8\x33\xf2\x8d\x02\x63\xb6\x51\x68\x14\x19\xc5\x46\x89\x31\xc7\x98\x6b\xcc\x33\xe6\x1b\x0b\x8c\x85\xc6\x95\xc6\x22\x63\xb1\xb1\xc4\x28\x35\x96\x1a\x57\x19\x57\x1b\xd7\x18\xd7\x1a\xd7\x19\xcb\x8c\x32\xe3\x7a\xe3\x06\x63\xb9\x71\xa3\x71\x93\x71\xb3\xb1\xc2\xb8\xc5\xb8\xd5\xb8\xcd\xb8\xdd\xb8\xc3\xb8\xd3\xb8\xcb\xb8\xdb\xb8\xc7\xb8\xd7\xb8\xcf\xb8\xdf\x78\xc0\x78\xd0\x78\xc8\x58\x69\x3c\x6c\x3c\x62\x3c\x6a\x3c\x66\x3c\x6e\x3c\x61\x3c\x69\x3c\x65\x3c\x6d\x3c\x63\x3c\x6b\x3c\x67\x3c\x6f\xbc\x60\xbc\x68\xac\x32\x5e\x32\x56\x1b\x2f\x1b\xaf\x18\x6b\x8c\x57\x8d\xd7\x8c\xd7\x8d\x37\x8c\x37\x8d\xb7\x8c\xb7\x8d\x77\x8c\x77\x8d\xf7\x8c\xb5\xc6\xfb\xc6\x3a\x63\xbd\xb1\xc1\xd8\x68\x7c\x60\x7c\x68\x7c\x64\x6c\x32\x3e\x36\x3e\x31\x3e\x35\x36\x1b\x9f\x19\x9f\x1b\x5b\x8c\xad\xc6\x36\x63\xbb\xb1\xc3\xd8\x69\xec\x32\x76\x1b\x5f\x18\x7b\x8c\x2f\x8d\xaf\x8c\xbd\xc6\xd7\xc6\x3e\xe3\x1b\x63\xbf\x71\xc0\xf8\xd6\x38\x68\x1c\x32\x0e\x1b\x47\x8c\xa3\xc6\x31\xe3\xb8\xf1\x9d\xf1\xbd\xf1\x83\x71\xc2\xf8\xd1\xf8\xc9\x38\x69\x9c\x32\x7e\x36\x4e\x1b\x67\x8c\xb3\xc6\x2f\xc6\x39\xe3\x57\xe3\x37\xe3\x77\xe3\x0f\xe3\x4f\xa3\xdc\xa8\x30\x1c\xa3\xd2\x24\x26\x35\x99\xa9\x3e\x90\x60\x98\xa6\x29\x4d\xcb\xb4\x4d\x97\x59\xc7\x0c\x30\xeb\x9a\x81\x66\x90\x19\x6c\x86\x98\xa1\x66\x3d\x33\xcc\x0c\x37\xeb\x9b\x0d\xcc\x08\xb3\xa1\x19\x69\x36\x32\xa3\xcc\xc6\x66\xb4\xd9\xc4\x74\x9b\x4d\xcd\x66\x66\x73\xb3\x85\x79\x99\xd9\xd2\x6c\x65\xb6\x36\xdb\x98\x6d\xcd\x76\xe6\xe5\x66\x7b\x33\xc6\x8c\x35\xe3\xcc\x0e\xa6\xc7\xf4\x9a\x1d\xcd\x78\xb3\x93\x99\x60\x76\x36\x13\xcd\x2e\x66\x57\xb3\x9b\xd9\xdd\xbc\xc2\xec\x61\x26\x99\xc9\x66\x4f\xb3\x97\x99\x62\xa6\x9a\x69\x66\x6f\xb3\x8f\xd9\xd7\xec\x67\xf6\x37\x07\x98\x03\xcd\x41\xe6\x60\x73\x88\x39\xd4\x1c\x66\x0e\x37\x47\x98\x23\xcd\x51\xe6\x68\x73\x8c\x39\xd6\x1c\x67\x8e\x37\x27\x98\xe9\xe6\x44\x73\x92\x39\xd9\xcc\x30\xa7\x98\x99\xe6\x54\x33\xcb\x9c\x66\x4e\x37\xb3\xcd\x1c\x73\x86\x39\xd3\xcc\x35\x67\x99\x79\x66\xbe\x59\x60\xce\x36\x0b\xcd\x22\xb3\xd8\x2c\x31\xe7\x98\x73\xcd\x79\xe6\x7c\x73\x81\xb9\xd0\xbc\xd2\x5c\x64\x2e\x36\x97\x98\xa5\xe6\x52\xf3\x2a\xf3\x6a\xf3\x1a\xf3\x5a\xf3\x3a\x73\x99\x59\x66\x5e\x6f\xde\x60\x2e\x37\x6f\x34\x6f\x32\x6f\x36\x57\x98\xb7\x98\xb7\x9a\xb7\x99\xb7\x9b\x77\x98\x77\x9a\x77\x99\x77\x9b\xf7\x98\xf7\x9a\xf7\x99\xf7\x9b\x0f\x98\x0f\x9a\x0f\x99\x2b\xcd\x87\xcd\x47\xcc\x47\xcd\xc7\xcc\xc7\xcd\x27\xcc\x27\xcd\xa7\xcc\xa7\xcd\x67\xcc\x67\xcd\xe7\xcc\xe7\xcd\x17\xcc\x17\xcd\x55\xe6\x4b\xe6\x6a\xf3\x65\xf3\x15\x73\x8d\xf9\xaa\xf9\x9a\xf9\xba\xf9\x86\xf9\xa6\xf9\x96\xf9\xb6\xf9\x8e\xf9\xae\xf9\x9e\xb9\xd6\x7c\xdf\x5c\x67\xae\x37\x37\x98\x1b\xcd\x0f\xcc\x0f\xcd\x8f\xcc\x4d\xe6\xc7\xe6\x27\xe6\xa7\xe6\x66\xf3\x33\xf3\x73\x73\x8b\xb9\xd5\xdc\x66\x6e\x37\x77\x98\x3b\xcd\x5d\xe6\x6e\xf3\x0b\x73\x8f\xf9\xa5\xf9\x95\xb9\xd7\xfc\xda\xdc\x67\x7e\x63\xee\x37\x0f\x98\xdf\x9a\x07\xcd\x43\xe6\x61\xf3\x88\x79\xd4\x3c\x66\x1e\x37\xbf\x33\xbf\x37\x7f\x30\x4f\x98\x3f\x9a\x3f\x99\x27\xcd\x53\xe6\xcf\xe6\x69\xf3\x8c\x79\xd6\xfc\xc5\x3c\x67\xfe\x6a\xfe\x66\xfe\x6e\xfe\x61\xfe\x69\x96\x9b\x15\xa6\x63\x56\x4a\x22\xa9\x64\x92\x4b\x21\x0d\x69\x4a\x29\x2d\x69\x4b\x97\xac\x23\x03\x64\x5d\x19\x28\x83\x64\xb0\x0c\x91\xa1\xb2\x9e\x0c\x93\xe1\xb2\xbe\x6c\x20\x23\x64\x43\x19\x29\x1b\xc9\x28\xd9\x58\x46\xcb\x26\xd2\x2d\x9b\xca\x66\xb2\xb9\x6c\x21\x2f\x93\x2d\x65\x2b\xd9\x5a\xb6\x91\x6d\x65\x3b\x79\xb9\x6c\x2f\x63\x64\xac\x8c\x93\x1d\xa4\x47\x7a\x65\x47\x19\x2f\x3b\xc9\x04\xd9\x59\x26\xca\x2e\xb2\xab\xec\x26\xbb\xcb\x2b\x64\x0f\x99\x24\x93\x65\x4f\xd9\x4b\xa6\xc8\x54\x99\x26\x7b\xcb\x3e\xb2\xaf\xec\x27\xfb\xcb\x01\x72\xa0\x1c\x24\x07\xcb\x21\x72\xa8\x1c\x26\x87\xcb\x11\x72\xa4\x1c\x25\x47\xcb\x31\x72\xac\x1c\x27\xc7\xcb\x09\x32\x5d\x4e\x94\x93\xe4\x64\x99\x21\xa7\xc8\x4c\x39\x55\x66\xc9\x69\x72\xba\xcc\x96\x39\x72\x86\x9c\x29\x73\xe5\x2c\x99\x27\xf3\x65\x81\x9c\x2d\x0b\x65\x91\x2c\x96\x25\x72\x8e\x9c\x2b\xe7\xc9\xf9\x72\x81\x5c\x28\xaf\x94\x8b\xe4\x62\xb9\x44\x96\xca\xa5\xf2\x2a\x79\xb5\xbc\x46\x5e\x2b\xaf\x93\xcb\x64\x99\xbc\x5e\xde\x20\x97\xcb\x1b\xe5\x4d\xf2\x66\xb9\x42\xde\x22\x6f\x95\xb7\xc9\xdb\xe5\x1d\xf2\x4e\x79\x97\xbc\x5b\xde\x23\xef\x95\xf7\xc9\xfb\xe5\x03\xf2\x41\xf9\x90\x5c\x29\x1f\x96\x8f\xc8\x47\xe5\x63\xf2\x71\xf9\x84\x7c\x52\x3e\x25\x9f\x96\xcf\xc8\x67\xe5\x73\xf2\x79\xf9\x82\x7c\x51\xae\x92\x2f\xc9\xd5\xf2\x65\xf9\x8a\x5c\x23\x5f\x95\xaf\xc9\xd7\xe5\x1b\xf2\x4d\xf9\x96\x7c\x5b\xbe\x23\xdf\x95\xef\xc9\xb5\xf2\x7d\xb9\x4e\xae\x97\x1b\xe4\x46\xf9\x81\xfc\x50\x7e\x24\x37\xc9\x8f\xe5\x27\xf2\x53\xb9\x59\x7e\x26\x3f\x97\x5b\xe4\x56\xb9\x4d\x6e\x97\x3b\xe4\x4e\xb9\x4b\xee\x96\x5f\xc8\x3d\xf2\x4b\xf9\x95\xdc\x2b\xbf\x96\xfb\xe4\x37\x72\xbf\x3c\x20\xbf\x95\x07\xe5\x21\x79\x58\x1e\x91\x47\xe5\x31\x79\x5c\x7e\x27\xbf\x97\x3f\xc8\x13\xf2\x47\xf9\x93\x3c\x29\x4f\xc9\x9f\xe5\x69\x79\x46\x9e\x95\xbf\xc8\x73\xf2\x57\xf9\x9b\xfc\x5d\xfe\x21\xff\x94\xe5\xb2\x42\x3a\xb2\xd2\x22\xe4\x65\xf2\x8a\x45\x2d\x66\x71\xf2\x1a\x79\x9d\x6c\xb4\x04\x59\x43\x5e\x25\x1f\x58\x06\xb9\x8a\xac\x27\xcb\xc8\x73\x96\x69\x49\xcb\xb2\x6c\xcb\x65\xd5\x21\x1f\x5a\x01\x56\x5d\x2b\x90\xbc\x47\xd6\x5a\x41\x56\x30\x79\xc7\x0a\xb1\x42\xad\x7a\x56\x98\x15\x6e\xd5\xb7\x1a\x58\x11\x56\x43\x2b\xd2\x6a\x64\x45\x59\x8d\xad\x68\xab\x89\xe5\xb6\x9a\x5a\xcd\xac\xe6\x56\x0b\xf2\xab\x75\x99\xd5\xd2\x6a\x65\xb5\xb6\xda\x58\x6d\xad\x76\xd6\xe5\x56\x7b\x2b\xc6\x8a\xb5\xe2\xac\x0e\x96\xc7\xf2\x5a\x1d\xad\x78\xab\x93\x95\x60\x75\xb6\x12\xad\x2e\x56\x57\x72\xa3\xd5\xcd\xea\x6e\x5d\x61\xf5\xb0\x92\xac\x64\xab\xa7\xd5\xcb\x4a\xb1\x52\xad\x34\xab\xb7\xd5\xc7\xea\x6b\xf5\xb3\xfa\x5b\x03\xac\x81\xe4\x1e\x6b\x10\xb9\x8f\xdc\x4b\x4e\x5a\x83\xc9\x06\xf2\x04\xb9\xcd\x1a\x62\x0d\x25\x0f\x90\xa7\xc8\x0a\x6b\x18\xb9\x83\xdc\x69\x0d\xb7\x46\x58\x23\xad\x51\xd6\x68\x6b\x8c\x35\xd6\x1a\x67\x8d\xb7\x26\x58\xe9\xd6\x44\x6b\x92\x35\xd9\xca\xb0\xa6\x58\x99\xd6\x54\x2b\xcb\x9a\x66\x4d\xb7\xb2\xad\x1c\x6b\x86\x35\xd3\xca\xb5\x66\x59\x79\x56\xbe\x55\x60\xcd\xb6\x0a\xad\x22\xab\xd8\x2a\xb1\xe6\x58\x73\xad\x79\xd6\x7c\x6b\x81\xb5\xd0\xba\xd2\x5a\x64\x2d\xb6\x96\x58\xa5\xd6\x52\xeb\x2a\xeb\x6a\xeb\x1a\xeb\x5a\xeb\x3a\x6b\x99\x55\x66\x5d\x6f\xdd\x60\x2d\xb7\x6e\xb4\x6e\xb2\x6e\xb6\x56\x90\x37\xad\x5b\xac\x5b\xad\xdb\xac\xdb\xad\x3b\xac\x3b\xad\xbb\xac\xbb\xad\x7b\xac\x7b\xad\xfb\xac\xfb\xad\x07\xac\x07\xad\x87\xac\x95\xd6\xc3\xd6\x23\xd6\xa3\xd6\x63\xd6\xe3\xd6\x13\xd6\x93\xd6\x53\xd6\xd3\xd6\x33\xd6\xb3\xd6\x73\xd6\xf3\xd6\x0b\xd6\x8b\xd6\x2a\xeb\x25\x6b\xb5\xf5\xb2\xf5\x8a\xb5\xc6\x7a\xd5\x7a\xcd\x7a\xdd\x7a\xc3\x7a\xd3\x7a\xcb\x7a\xdb\x7a\xc7\x7a\xd7\x7a\xcf\x5a\x6b\xbd\x6f\xad\xb3\xd6\x5b\x1b\xac\x8d\xd6\x07\xd6\x87\xd6\x47\xd6\x26\xeb\x63\xeb\x13\xeb\x53\x6b\xb3\xf5\x99\xf5\xb9\xb5\xc5\xda\x6a\x6d\xb3\xb6\x5b\x3b\xac\x9d\xd6\x2e\x6b\xb7\xf5\x85\xb5\xc7\xfa\xd2\xfa\xca\xda\x6b\x7d\x6d\xed\xb3\xbe\xb1\xf6\x5b\x07\xac\x6f\xad\x83\xd6\x21\xeb\xb0\x75\xc4\x3a\x6a\x1d\xb3\x8e\x5b\xdf\x59\xdf\x5b\x3f\x58\x27\xac\x1f\xad\x9f\xac\x93\xd6\x29\xeb\x67\xeb\xb4\x75\xc6\x3a\x6b\xfd\x62\x9d\xb3\x7e\xb5\x7e\xb3\x7e\xb7\xfe\xb0\xfe\xb4\xca\xad\x0a\xcb\xb1\x2a\x6d\x62\x53\x9b\xd9\xdc\x16\xb6\x61\x9b\xb6\xb4\x2d\xdb\xb6\x5d\x76\x1d\x3b\xc0\xae\x6b\x07\xda\x41\x76\xb0\x1d\x62\x87\xda\xf5\xec\x30\x3b\xdc\xae\x6f\x37\xb0\x23\xec\x86\x76\xa4\xdd\xc8\x8e\xb2\x1b\xdb\xd1\x76\x13\xdb\x6d\x37\xb5\x9b\xd9\xcd\xed\x16\xf6\x65\x76\x4b\xbb\x95\xdd\xda\x6e\x63\xb7\xb5\xdb\xd9\x97\xdb\xed\xed\x18\x3b\xd6\x8e\xb3\x3b\xd8\x1e\xdb\x6b\x77\xb4\xe3\xed\x4e\x76\x82\xdd\xd9\x4e\xb4\xbb\xd8\x5d\xed\x6e\x76\x77\xfb\x0a\xbb\x87\x9d\x64\x27\xdb\x3d\xed\x5e\x76\x8a\x9d\x6a\xa7\xd9\xbd\xed\x3e\x76\x5f\xbb\x9f\xdd\xdf\x1e\x60\x0f\xb4\x07\xd9\x83\xed\x21\xf6\x50\x7b\x98\x3d\xdc\x1e\x61\x8f\xb4\x47\xd9\xa3\xed\x31\xf6\x58\x7b\x9c\x3d\xde\x9e\x60\xa7\xdb\x13\xed\x49\xf6\x64\x3b\xc3\x9e\x62\x67\xda\x53\xed\x2c\x7b\x9a\x3d\xdd\xce\xb6\x73\xec\x19\xf6\x4c\x3b\xd7\x9e\x65\xe7\xd9\xf9\x76\x81\x3d\xdb\x2e\xb4\x8b\xec\x62\xbb\xc4\x9e\x63\xcf\xb5\xe7\xd9\xf3\xed\x05\xf6\x42\xfb\x4a\x7b\x91\xbd\xd8\x5e\x62\x97\xda\x4b\xed\xab\xec\xab\xed\x6b\xec\x6b\xed\xeb\xec\x65\x76\x99\x7d\xbd\x7d\x83\xbd\xdc\xbe\xd1\xbe\xc9\xbe\xd9\x5e\x61\xdf\x62\xdf\x6a\xdf\x66\xdf\x6e\xdf\x61\xdf\x69\xdf\x65\xdf\x6d\xdf\x63\xdf\x6b\xdf\x67\xdf\x6f\x3f\x60\x3f\x68\x3f\x64\xaf\xb4\x1f\xb6\x1f\xb1\x1f\xb5\x1f\xb3\x1f\xb7\x9f\xb0\x9f\xb4\x9f\xb2\x9f\xb6\x9f\xb1\x9f\xb5\x9f\xb3\x9f\xb7\x5f\xb0\x5f\xb4\x57\xd9\x2f\xd9\xab\xed\x97\xed\x57\xec\x35\xf6\xab\xf6\x6b\xf6\xeb\xf6\x1b\xf6\x9b\xf6\x5b\xf6\xdb\xf6\x3b\xf6\xbb\xf6\x7b\xf6\x5a\xfb\x7d\x7b\x9d\xbd\xde\xde\x60\x6f\xb4\x3f\xb0\x3f\xb4\x3f\xb2\x37\xd9\x1f\xdb\x9f\xd8\x9f\xda\x9b\xed\xcf\xec\xcf\xed\x2d\xf6\x56\x7b\x9b\xbd\xdd\xde\x61\xef\xb4\x77\xd9\xbb\xed\x2f\xec\x3d\xf6\x97\xf6\x57\xf6\x5e\xfb\x6b\x7b\x9f\xfd\x8d\xbd\xdf\x3e\x60\x7f\x6b\x1f\xb4\x0f\xd9\x87\xed\x23\xf6\x51\xfb\x98\x7d\xdc\xfe\xce\xfe\xde\xfe\xc1\x3e\x61\xff\x68\xff\x64\x9f\xb4\x4f\xd9\x3f\xdb\xa7\xed\x33\xf6\x59\xfb\x17\xfb\x9c\xfd\xab\xfd\x9b\xfd\xbb\xfd\x87\xfd\xa7\x5d\x6e\x57\xd8\x8e\x5d\xe9\x22\x2e\xea\x62\x2e\xee\x12\x2e\xc3\x65\xba\xa4\xcb\x72\xd9\x2e\x97\xab\x8e\x2b\xc0\x55\xd7\x15\xe8\x0a\x72\x05\xbb\x42\x5c\xa1\xae\x7a\xae\x30\x57\xb8\xab\xbe\xab\x81\x2b\xc2\xd5\xd0\x15\xe9\x6a\xe4\x8a\x72\x35\x76\x45\xcb\x92\xbc\x9c\xb8\xb8\xe4\x38\xbd\x4d\xb1\xf3\xe7\x64\x15\x16\x65\xe6\x17\x66\xf1\x59\x25\x1d\xcc\x59\x39\x53\xa7\xe6\x17\xcb\xe4\x59\xea\x4a\x73\x9e\xcc\xf0\x6d\xcd\xe4\x29\x85\x59\x73\xb2\xcc\x0c\xdc\xc8\xe4\xfc\xe9\xf9\x79\x59\x33\x65\x86\x6f\x5b\xa7\x57\x66\x4e\x61\x66\xc9\xac\x69\xb9\x59\xf3\xea\x64\x9e\x2f\xbb\x7a\x01\xa9\x8c\xcc\xcc\xac\xbc\x62\x57\x66\x75\xd1\x4c\xc9\xcc\x50\x24\xa7\xfa\x36\x29\x40\x3f\xa3\x58\xa6\x6a\x86\x59\x9a\x61\xaa\x8f\x61\x16\x6e\x5c\xa9\xe7\x09\x65\x55\x17\x65\xaa\x16\x23\xcb\xb7\x35\x53\x7d\x14\xb3\x70\x53\xa7\xb7\x9f\x50\xd3\xfd\x84\xea\x7d\x9e\xd6\xf4\xea\x62\x40\xef\xcc\xfc\x59\xb3\x32\xf4\x8f\xe9\x7e\x3f\xea\xf4\xf1\xa3\x93\x7d\xbe\x2c\xfa\x4c\xc9\x28\x14\xd9\x00\x66\xdf\xe2\x9c\xdc\xa9\x59\x66\x0e\x6e\x64\x5f\xad\x49\x8e\xd6\xa4\xaf\x4f\x93\x1c\x9f\xe9\xfa\x6a\x99\x73\x7c\x5b\xd6\xb7\x1f\xcb\x99\x51\xa7\x9f\x1f\x8f\x19\xe7\xcb\x01\xfd\xfd\xa5\x9a\x59\xe3\xc7\x74\x75\xe3\x22\x37\x23\x6f\x6a\x4e\xa6\x39\x20\x23\xb3\xa4\x38\xcb\xcc\xc5\x4d\xc0\x00\xff\x76\xb9\x7e\x3f\xcc\x01\x3e\x03\xe5\xe2\x46\x0c\x00\xed\x45\x2e\x80\x39\xc8\x77\x7c\x9e\xef\xf8\x41\xfe\xc7\xe7\xf9\x1f\x3f\xc8\x77\x7c\x9e\xcf\xc0\x79\x19\x05\xf9\x45\xc5\x85\xf9\x05\xd9\x59\x3c\x35\x6f\x3a\xcf\xca\x9b\x2e\x07\x6b\xe5\xf3\xb5\xf2\x83\x7d\xca\xe7\xe3\xa6\xee\xe0\xec\x92\xbc\xe9\x19\x85\x25\xb3\x72\x33\x4a\x8a\xeb\xe6\xfb\xff\x32\x87\xf9\x64\x28\xf4\xc9\x30\xcc\x5f\x86\x42\x7f\x19\x86\xf9\x64\x28\xf4\x6d\x86\xfb\x8e\x2a\xc2\x4d\x9d\xe1\x7e\x66\x2c\xf2\x33\xe3\x08\x7f\x6a\xc5\xfe\xd4\x46\xf8\xc8\x14\xfb\x2c\x32\x42\x75\x69\xb1\xea\xd2\x91\xbe\x2e\x2d\xf1\x75\xe9\x48\xad\x55\x89\xd6\x6a\xa4\x4f\xab\x12\xdc\x18\x23\x0b\x73\xf2\xa6\x1b\x25\x0a\xeb\x8e\xac\xa1\x61\x89\xff\x2f\x39\x52\x77\x7d\x89\x1e\x35\xa3\xfd\xa4\x9d\xeb\x57\x1e\xeb\x57\x9e\x7f\xbe\x6c\x8e\xf3\xe9\xba\x00\x37\xae\x71\xe7\xdd\x78\x41\x75\xd1\xc8\xcd\xcf\x9b\x5e\x84\x43\xbb\x43\xe7\x38\xbd\xed\xa0\xb7\x1e\xbd\xf5\xea\x6d\x47\xbd\x8d\xd7\xdb\x4e\x7a\x9b\xa0\xb7\x9d\xf5\x36\x51\x6f\x93\xf5\xb6\xa7\xde\xf6\xd2\xdb\x14\xbd\x4d\xd5\xdb\x34\xdf\x36\x51\xf3\x4f\xd4\xfc\x13\x35\xdf\x44\xcd\x37\x51\xf3\x4d\xd4\x7c\x13\x35\xdf\x44\xcd\x37\x51\xf3\x4d\xd4\x7c\x13\x35\xdf\x44\xcd\x37\x51\xf3\x4d\xd4\x7c\x13\xd3\x8c\xc1\xd9\xf9\x85\x70\xfa\xa9\xd0\x57\x97\xac\x75\x4e\xd6\xbc\x93\x35\xef\x64\xcd\x3b\x59\xf3\x4e\xd6\xbc\x93\x35\xef\x64\xcd\x3b\x59\xf3\x4e\xd6\xbc\x93\x35\xef\x64\xcd\x3b\x39\xd5\x18\x89\x3c\x4b\xce\xf3\xec\xa9\xf5\xed\xa9\x79\xf7\xd4\xbc\x7b\x6a\xde\x3d\x35\xef\x9e\x9a\x77\x4f\xcd\xbb\xa7\xe6\xdd\x53\xf3\xee\xa9\x79\xf7\xd4\xbc\x7b\x6a\xde\x3d\x35\xef\x9e\x5a\xef\x9e\xda\xde\xbd\xb4\xbd\x7b\x69\xfe\xbd\x34\xff\x5e\x9a\x7f\x2f\xcd\xbf\x97\xe6\xdf\x4b\xf3\xef\xa5\xf9\xf7\xd2\xfc\x7b\x69\xfe\xbd\x34\xff\x5e\x9a\x7f\x2f\xcd\xbf\x97\xe6\xdf\x4b\xf3\xef\xa5\xf9\xa7\x68\xfe\x29\x9a\x7f\x8a\xe6\x9f\xa2\xf9\xa7\x68\xfe\x29\x9a\x7f\x8a\xe6\x9f\xa2\xf9\xa7\x68\xfe\x29\x9a\x7f\x8a\xe6\x9f\xa2\xf9\xa7\x68\xfe\x29\x9a\x7f\x8a\xe6\x9f\xa2\xf9\xa7\x6a\xfe\xa9\x9a\x7f\xaa\xe6\x9f\xaa\xf9\xa7\x6a\xfe\xa9\x9a\x7f\xaa\xe6\x9f\xaa\xf9\xa7\x6a\xfe\xa9\x9a\x7f\xaa\xe6\x9f\xaa\xf9\xa7\x6a\xfe\xa9\x9a\x7f\xaa\xe6\x9f\xaa\xf9\xa7\x69\xfe\x69\x9a\x7f\x9a\xe6\x9f\xa6\xf9\xa7\x69\xfe\x69\x9a\x7f\x9a\xe6\x9f\xa6\xf9\xa7\x69\xfe\x69\x89\xae\x64\x35\x97\xf8\x86\x79\x46\x75\x51\x26\xa7\xfa\xb6\x19\x59\xbe\xd9\x6e\x70\x51\x6e\x46\x51\xb6\xaf\x9c\x7f\xbe\x8c\x54\x3c\x71\x71\x7a\xdb\x41\x6f\x3d\x7a\xeb\xd5\xdb\x8e\x7a\x1b\xaf\xb7\x9d\xf4\x36\x41\x6f\x3b\xeb\x6d\xa2\xde\x26\xeb\x6d\x4f\xbd\xed\xa5\xb7\x29\x7a\x9b\xaa\xb7\x3e\x6b\x78\x3a\x68\xfe\x1d\x34\xff\x0e\x9a\x7f\x07\xcd\xbf\x83\xe6\xdf\x41\xf3\xef\xa0\xf9\x77\x48\x08\x18\xee\x3f\x5b\x17\xf9\xfd\xd0\x2d\xb4\x24\x1d\xb4\x24\x1d\xb4\x24\x1d\xb4\x24\x1d\xb4\x24\x1d\xb4\x24\x1e\x2d\x89\x47\x4b\xe2\xd1\x92\x78\xb4\x24\x1e\x2d\x89\x47\x4b\xe2\xd1\x92\x78\xb4\x25\x3c\xda\x12\x1e\x6d\x09\x8f\xe6\xef\xd1\xfc\x3d\x9a\xbf\x47\xf3\xf7\x68\xfe\x1e\xcd\xdf\xab\xf9\x7b\x35\x7f\xaf\xe6\xef\xd5\xfc\xbd\x9a\xbf\x57\xf3\xf7\x76\xb2\x67\xc4\xc0\x8c\x9e\x9b\x55\x54\xa4\x6b\xb4\x04\x5e\x2d\x81\x57\x4b\xe0\xd5\x12\x78\xb5\x04\x5e\x2d\x81\x57\x4b\xe0\xd5\x12\x74\xd4\x12\x74\xd4\x12\x74\xd4\x12\x74\xd4\x12\x74\xd4\x12\x74\xd4\x12\x74\xd4\x16\xe8\xa8\x2d\xd0\x51\xf3\xef\xa8\xf9\x77\xd4\xfc\x3b\x6a\xfe\x1d\x35\xff\x8e\x9a\x7f\x47\xcd\xbf\xa3\xe6\x1f\xaf\xf9\xc7\x6b\xfe\xf1\x9a\x7f\xbc\xe6\x1f\xaf\xf9\xc7\x6b\xfe\xf1\x9a\x7f\xbc\xe6\x1f\xaf\xf9\xc7\x6b\xfe\xf1\x9a\x7f\xbc\xe6\x1f\xaf\xf9\xc7\x6b\xfe\xf1\x9a\x7f\xbc\xe6\xdf\x49\xf3\xef\xa4\xf9\x77\xd2\xfc\x3b\x69\xfe\x9d\x34\xff\x4e\x9a\x7f\x27\xcd\xbf\x93\xe6\xdf\x49\xf3\xef\xa4\xf9\x77\xd2\xfc\x3b\x69\xfe\x9d\x34\xff\x4e\x9a\x7f\x27\xcd\xbf\x93\xe6\x9f\xa0\xf9\x27\x68\xfe\x09\x9a\x7f\x82\xe6\x9f\xa0\xf9\x27\x68\xfe\x09\x9a\x7f\x82\xe6\x9f\xa0\xf9\x27\x68\xfe\x09\x9a\x7f\x82\xe6\x9f\xa0\xf9\x27\x68\xfe\x09\x9a\x7f\x82\xe6\xaf\x33\x01\x8f\xce\x04\x3c\x3a\x13\xf0\xe8\x4c\xc0\xa3\x33\x01\x8f\xce\x04\x3c\x3a\x13\xf0\xe8\x4c\xc0\xa3\x33\x01\x8f\xce\x04\x3c\x3a\x13\xf0\xe8\x4c\xc0\xa3\x33\x01\x8f\xce\x04\x3c\x3a\x13\xf0\xe8\x4c\xc0\xa3\x33\x01\x8f\xce\x04\x3c\x89\x9a\xbf\xce\x08\x3c\x3a\x23\xf0\xe8\x8c\xc0\xa3\x33\x02\x8f\xce\x08\x3c\x3a\x23\xf0\xe8\x8c\xc0\xa3\x33\x02\x8f\xce\x08\x3c\x3a\x23\xf0\xe8\x8c\xc0\xa3\x33\x02\x4f\xa2\xe6\xaf\x4f\x76\x3c\xc9\x9a\xbf\xce\x0a\x3c\x3a\x2b\xf0\xe8\xac\xc0\xa3\xb3\x02\x8f\xce\x0a\x3c\x3a\x2b\xf0\xe8\xac\xc0\xa3\xb3\x02\x8f\xce\x0a\x3c\x3a\x2b\xf0\xe8\xac\xc0\xa3\xb3\x02\x4f\xb2\xe6\x9f\xac\xf9\xf7\xd4\xfc\x75\x66\xe0\xd1\x99\x81\x47\x67\x06\x1e\x9d\x19\x78\x74\x66\xe0\xd1\x99\x81\x47\x67\x06\x1e\x9d\x19\x78\x74\x66\xe0\xd1\x99\x81\x47\x67\x06\x1e\x9d\x19\x78\x74\x66\xe0\xd1\x99\x81\x47\x67\x06\x1e\x9d\x19\x78\x74\x66\xe0\xd1\x99\x81\x47\x67\x06\x1e\x9d\x19\x78\x74\x66\xe0\xd1\x99\x80\x47\x67\x00\x1e\x9d\x01\x78\x74\x06\xe0\xd1\x19\x80\x47\x67\x00\x1e\x9d\x01\x78\x74\x06\xe0\xd1\x19\x80\x47\x67\x00\x1e\x9d\x01\x78\x74\x06\xe0\xd1\x19\x80\x47\x67\x00\x1e\x9d\x01\x78\x74\x44\xf7\xe8\x88\xee\xd1\x11\xdd\xa3\x23\xba\x47\x47\x74\x8f\x8e\xe8\x1e\x1d\xd1\x3d\x3a\xa2\x7b\x74\x44\xf7\xe8\x88\xee\xd1\x11\xdd\xa3\x23\xba\x47\x47\x74\x8f\x8e\xe8\x1e\x1d\xd1\x3d\x3a\xa2\x7b\x74\x44\xf7\xe8\x88\xee\xd1\x11\xdd\xa3\x23\xba\x47\x47\x74\x8f\x8e\xe8\x1e\x1d\xd1\x3d\x3a\xa2\x7b\x74\x44\xf7\xe8\x88\xee\xd1\x11\xdd\x93\xa6\xf9\xa7\x69\xfe\x69\x9a\x7f\x9a\xe6\x9f\xa6\xf9\xa7\x69\xfe\x69\x69\xf6\xf4\xc2\x8c\x39\x59\x10\xfa\xa6\xd8\x18\xd3\x55\x09\xf7\x79\xe3\x3c\x36\x9e\x93\xf8\xd5\x74\xd4\xdb\x78\xbd\xed\xa4\xb7\x09\x7a\xdb\xb9\x6e\x76\x7e\xfe\xcc\x8c\x29\xf9\x73\xfc\x8f\x4a\xd6\xdb\x9e\x7a\xdb\x4b\x6f\x53\xf4\x36\x55\x6f\x7d\xb6\xf0\xea\x78\xee\xd5\xf1\xdc\xab\xe3\xb9\x57\xc7\x73\xaf\x8e\xe7\x5e\x1d\xcf\xbd\x3a\x9e\x7b\x3b\x68\x29\x3a\x74\xd6\xdb\x44\xbd\xd5\xfc\x75\x14\xf7\xea\x28\xee\xd5\x51\xdc\xab\xa3\xb8\x57\x47\x71\xaf\x8e\xe2\x5e\x1d\xc5\xbd\x1e\x4f\x00\xc4\xc8\x29\x59\xb9\xf9\x73\xcf\x2b\xa5\x43\xb9\x57\x87\x72\xaf\x0e\xe5\x5e\x1d\xca\xbd\x3a\x94\x7b\x75\x28\xf7\xea\x50\xee\xd5\xa1\xdc\xab\x43\xb9\x57\x87\x72\xaf\x0e\xe5\x5e\x1d\xca\xbd\x3a\x94\x7b\x75\x28\xf7\xea\x50\xee\xd5\xa1\xdc\xab\x43\xb9\x57\x87\x72\xaf\x57\xf3\xf7\x6a\xfe\x3a\x90\x7b\x75\x20\xf7\xea\x40\xee\xd5\x81\xdc\xab\x03\xb9\x57\x07\x72\xaf\x0e\xe4\x5e\x1d\xc8\xbd\x3a\x90\x7b\x75\x20\xf7\xea\x40\xee\xd5\x81\xdc\xab\x03\xb9\x57\x07\x72\xaf\x0e\xe4\x5e\x1d\xc8\xbd\x3a\x90\x7b\x75\x20\xf7\xea\x40\xee\xd5\x81\xdc\xab\x03\xb9\x57\x07\x72\xaf\x0e\xe4\x5e\x1d\xc8\xbd\x3a\x90\x7b\x75\x20\xf7\xea\x40\xee\xd5\x81\xdc\xab\x03\xb9\x57\x07\x72\xaf\x0e\xe4\x5e\x1d\xc8\xbd\x3a\x90\x7b\x75\x20\xf7\xea\x40\xee\xd5\x81\xdc\xab\x03\xb9\x57\x07\x72\xaf\x0e\xe4\x5e\x1d\xc8\xbd\x3a\x90\x7b\x75\x20\xf7\xea\x40\xee\xd5\x81\xdc\xab\x03\xb9\x57\x07\x72\xaf\x0e\xe4\x5e\x1d\xc8\xbd\x3a\x90\x7b\x75\x20\xf7\xea\x40\xee\xd5\x81\xdc\xab\x03\xb9\x57\x07\x72\xaf\x0e\xe4\x5e\x1d\xc8\xbd\x3a\x50\x7b\x75\xa0\xf6\xea\x40\xec\xd5\x81\xd8\xab\x03\xb1\x57\x07\x62\x6f\x42\xaa\x51\x9c\x9f\x97\x5f\x54\x77\x6a\x4e\xd6\xff\xc7\xde\xd7\xc0\xc9\x51\x5c\xf9\x55\x77\xf5\xec\xce\xcc\x7e\x4a\xc8\x20\x64\xf1\x11\x87\x70\x80\x65\x45\x3b\x53\xf3\x85\x39\xc2\x7e\x74\x19\x30\x06\x05\x03\x16\x9c\x0e\x34\x92\x46\xda\x81\xdd\x9d\xd5\x7e\x68\x05\xc6\x1c\x71\x88\xe3\x23\xc8\x70\x44\x21\x0e\x21\x1c\x47\x14\x21\x64\x87\x38\x3a\x85\x38\xba\x0d\xc1\x5f\x20\xdd\xc9\x02\xb1\x02\x73\x08\x63\x09\x64\x21\x81\x00\x21\x04\x08\x1d\x68\xf2\xea\xf5\x7f\x66\x7a\x7a\x67\xc5\xca\x1c\x17\x2e\x89\xf4\xab\x57\x1f\x5d\xf5\xfe\xaf\x5e\x55\xf7\x7b\xaf\xbb\x67\x7b\x20\x37\x98\x1f\xe4\x5a\xb4\xbd\xa7\xbf\x3b\xcb\xc5\x48\xb6\xaf\x30\x94\xeb\xc9\xe5\xb3\x8d\x6e\xff\x60\x9e\xa2\x77\x6e\x0e\xbb\x43\x38\x7e\x51\x01\xa5\xc6\xcb\x7a\xf3\xe6\xde\x83\x57\xb9\xd2\xd7\x39\x7a\x59\x6f\x6e\xa9\xd7\x69\x4a\x9e\xba\x57\x61\x85\x18\xcb\xe9\xc8\x0d\x65\x43\x5f\xc9\x92\x27\x5d\x0f\x1c\xe7\x1a\x6a\x92\x84\x13\xba\xa2\x9b\x4a\x8e\x01\x0a\x7d\x35\xdb\xdf\x9f\xad\xbb\x24\xdb\xbb\x70\x71\xd6\xfe\xda\xb0\x7d\xe9\xb0\x3d\x2f\x5f\x0f\x64\x7b\x6e\x5e\x5e\xde\x5d\x08\x7d\x3d\xbf\xb4\x37\x2b\xaf\xc8\x0e\xd7\x43\x0a\x39\xb7\x3b\x2f\x3b\x29\xcd\x1d\xcc\x37\x5e\xe4\x93\xa0\x05\x1d\x4a\xf5\x68\xb6\x3c\xf1\xc6\x9c\x7f\xba\xb9\xd2\x74\xf3\xa5\xe9\x4e\x1b\xae\x1e\xea\x4d\x86\xc7\x3b\x0b\xcd\x64\x96\x9a\xc9\x84\x16\xe7\x7a\x86\xb2\xf5\xe0\xe5\xdc\x64\xa6\x64\x0e\x0e\xf1\x94\x0c\xb3\xd0\x0d\x3c\xa5\x1e\x6f\x4a\x7d\xc3\xf6\x8a\x7c\x7d\xc1\x9b\x8f\x1c\xe8\x2e\xd4\x0d\x9a\xc9\xb4\x85\x38\x93\x43\x34\x27\xe0\xca\x7e\x9a\xcf\x22\x4a\x54\x0d\x15\x8c\x82\x1b\xfd\xba\x6d\x09\x88\xd7\x58\xf0\xaf\xce\xb0\x7f\x75\x0a\xe5\xd5\xf1\xf6\x04\x8c\x64\x1c\x46\x32\x0e\x23\x19\x87\x91\x8c\xc3\x48\xc6\x61\x24\xe3\x30\x92\x71\x18\xc9\x38\xc2\xe4\x38\xc2\xe4\x38\xc2\xe4\x38\xc2\xe4\x38\xc2\xe4\x38\xc2\xe4\x38\x8c\x6a\x1c\x46\x35\x0e\xa3\x1a\x87\x51\x8d\xc3\xa8\xc6\x61\x54\xe3\x30\xaa\x71\x18\xd5\x38\x8c\x6a\x1c\x46\x35\x0e\xa3\x1a\x87\x51\x8d\xc3\xa8\xc6\x61\x54\xe3\x30\xaa\x71\x18\xd5\x38\x8c\x6a\x1c\x46\x35\x0e\xa3\x1a\x87\x51\x8d\xc3\xa8\xc6\x61\x54\xe3\x30\xaa\x71\x18\xd5\x38\x8c\x6a\x1c\x46\x35\x0e\xa3\x1a\x87\x51\x8d\xc3\xa8\xc6\x61\x54\xe3\x30\xaa\x71\x18\xd5\x38\x8c\x6a\x5c\x7b\xf8\x0a\x81\xb1\x42\x60\xac\x10\x18\x2b\x04\xc6\x0a\xe6\x54\xc1\x9c\x2a\x98\x53\x05\x73\xaa\x10\x18\x2b\x04\xc6\x0a\x86\x54\xc1\x90\x2a\x18\x52\x05\x43\xaa\x60\x48\x15\x0c\xa9\x82\x21\x55\x30\xa4\x0a\x86\x54\xc1\x90\x2a\x18\x52\x05\x43\xaa\x60\x48\x15\x0c\xa9\x82\x21\x55\x30\xa4\x0a\x86\x54\xc1\x90\x2a\x18\x52\x05\x43\xaa\x60\x48\x15\x0c\xa9\x82\x21\x55\x30\xa4\x0a\xe1\xb0\x42\x38\xac\x60\x43\x15\x6c\xa8\x82\x0d\x55\xb0\xa1\x0a\x36\x54\xc1\x86\x2a\xd8\x50\x05\x1b\xaa\x60\x43\x15\x6c\xa8\x82\x0d\x55\xb0\xa1\x0a\x36\x54\xc1\x86\x2a\xd8\x50\x05\x1b\xaa\x60\x43\x15\x6c\xa8\x82\x0d\x55\xb0\xa1\x0a\x36\x54\xc1\x86\x2a\xd8\x50\x05\x1b\xaa\x60\x43\x15\x6c\xa8\x82\x0d\x55\xb0\xa1\x0a\x36\x54\xc1\x86\x2a\xd8\x50\x05\x1b\xaa\x60\x43\x15\x6c\xa8\x82\x0d\x55\xb0\xa1\x0a\x36\x54\xc1\x86\x2a\xd8\x50\x05\x1b\xaa\x60\x43\x15\x6c\xa8\x82\x0d\x55\xb0\xa1\x0a\x36\x54\xc1\x86\x2a\xd8\x50\x05\x1b\xaa\x60\x43\x15\x6c\xa8\x82\x0d\x55\xb0\xa1\x0a\x36\x54\xc1\x86\x2a\xd8\x50\x05\x1b\xaa\x60\x43\x15\x6c\xa8\x82\x0d\x55\xb0\xa1\x0a\x36\x54\xc1\x86\x2a\xd8\x50\x05\x1b\xaa\x60\x43\x15\x6c\xa8\x82\x0d\x55\xb0\xa1\x0a\x36\x54\xc1\x86\x2a\xd8\x50\x05\x1b\xaa\x60\x43\x15\x6c\xa8\x82\x0d\x55\xb0\xa1\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\x36\x56\xc1\xc6\x2a\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\xd8\x60\x05\x1b\xac\x60\x83\x15\x6c\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\x42\x30\xac\x10\x0c\x2b\x04\xc3\x0a\xc1\xb0\xc2\x6d\x72\x85\xdb\xe4\x0a\xc1\xb1\xc2\x6d\x72\x85\x20\x59\x21\x48\x56\x08\x92\x15\x82\x64\x85\x20\x59\x21\x48\x56\xb0\xff\x0a\xf6\x5f\xc1\xfe\x2b\xd8\x7f\x05\xfb\xaf\x60\xff\x15\xec\xbf\x82\xfd\x57\x5d\xe9\x48\x76\x49\x3e\xdf\x36\x27\x5d\xba\x32\xc1\x03\x50\xf0\x00\x14\x3c\x00\x05\x0f\x40\xc1\x03\x50\xf0\x00\x14\x3c\x00\x05\x0f\x40\xc1\x03\x50\xf0\x00\x14\x3c\x00\x05\x0f\x40\xc1\x03\x50\xf0\x00\x14\x3c\x00\x05\x0f\x40\xc1\x03\x50\xf0\x00\x14\x3c\x00\x05\x0f\x40\xc1\x03\x50\xf0\x00\x14\x3c\x00\x05\x0f\x40\xc1\x03\x50\xf0\x00\x14\x3c\x00\x05\x0f\x40\xc1\x03\x50\xf0\x00\x14\x3c\x00\x05\x0f\x40\xc1\x03\x50\xf0\x00\x14\x3c\x00\x05\x0f\x40\xc1\x03\x50\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xf0\x00\x12\xb0\xe8\x09\x58\xf4\x04\x2c\x7a\x02\x16\x3d\x81\x2b\x47\x02\x57\x8e\x04\xae\x1c\x09\x5c\x39\x12\xb8\x72\x24\x70\xe5\x48\xe0\xca\x91\xc0\x95\x23\x81\x2b\x47\x02\x57\x8e\x04\xae\x1c\x09\x5c\x39\x12\x99\x12\x0e\xe4\xc6\x95\x23\x81\x2b\x47\x02\x57\x8e\x04\xae\x1c\x09\x5c\x39\x12\xb8\x72\x24\x70\xe5\x48\xe0\xca\x91\xc0\x95\x23\x81\x2b\x47\x02\x57\x8e\x04\xae\x1c\x09\x5c\x39\x12\xb8\x72\x24\x70\xe5\x48\xe0\xca\x91\x68\xd7\xa1\xc1\xee\xdc\xf2\x6c\x94\x62\x87\xec\x92\xc1\xdc\xd2\x42\x8f\x57\xec\x27\xd2\xdd\xc0\xc5\x65\xd9\xde\xec\xd0\x60\xa8\x3b\x3f\x90\x5f\x16\x1a\x1a\x24\xaf\x3c\xc4\x1d\x43\xdc\xa7\xae\x74\xb8\x40\x81\x80\xc7\xb4\xa3\xbd\x6e\xd9\xf0\xc2\xe1\xa1\xc1\xba\xc5\xd9\xa5\xb9\xc1\xee\x50\x6f\x6e\x28\xb7\x34\xd4\x9b\x5d\x96\x5d\xe2\x0c\x64\x97\xe4\x68\xe4\x60\x6e\x59\xbd\xf9\xf1\xa1\x79\x44\x3e\xc8\x59\x78\xb0\x40\xa8\x83\xc3\xcb\x22\xc3\xfd\xfd\xb9\x81\xeb\x4c\x53\x4f\x61\x24\x37\x60\xde\x99\x60\xbe\x9d\xc9\x06\x0f\x6c\x19\x01\xf7\x39\xd9\x9e\xdc\x12\x49\x01\x4b\x68\x69\xbe\x37\xd7\x13\x5a\x4c\xf5\x21\xbb\x3b\x27\x97\x67\x97\x87\x6e\xca\xde\x98\xef\x93\x14\xaa\xc8\x21\x4a\x37\x16\x16\x87\x97\xe4\xfb\xb2\x3d\x37\x64\x97\x48\x4a\x21\x12\x35\x87\xa6\xde\x5c\xaf\xa4\xe4\x55\xfa\x86\xfb\x24\xa5\xba\x41\x3a\x7e\x43\xb7\x63\x98\xd4\xf3\x81\xfe\x9c\xdd\x9f\x8b\x72\x71\x68\x90\x42\x95\x10\x53\xb9\xac\x40\x13\xa2\x19\x3a\x66\x2a\x14\xe3\x2c\xaf\x23\xf0\xe5\x5e\x46\xa0\x75\x94\x4c\xb6\xd4\x44\x32\xdd\x11\xca\x06\xbb\x89\x27\xab\xa9\xad\xcb\x3b\x57\x28\x6f\x43\x1e\x43\x1e\x47\xae\x90\x27\x90\x27\x91\xa7\x90\xa7\x91\x67\x90\xb7\x23\xef\x40\xde\x89\xbc\x0b\xb9\x8b\x5c\x7b\x79\x1b\xf0\xdb\x80\xdf\x06\xfc\x36\xe0\xb7\x01\xbf\x0d\xf8\x6d\xc0\x6f\x03\x7e\x1b\xf0\xdb\x80\xdf\x06\xfc\x36\xe0\xb7\x01\xbf\x0d\xf8\x6d\xc0\x6f\x03\x7e\x0c\xf8\x31\xe0\xc7\x80\x1f\x03\x7e\x0c\xf8\x31\xe0\xc7\x80\x1f\x03\x7e\x0c\xf8\x31\xe0\xc7\x80\x1f\x03\x7e\x0c\xf8\x31\xe0\xc7\x80\x1f\x03\x7e\x1c\xf8\x71\xe0\xc7\x81\x1f\x07\x7e\x1c\xf8\x71\xe0\xc7\x81\x1f\x07\x7e\x1c\xf8\x71\xe0\xc7\x81\x1f\x07\x7e\x1c\xf8\x71\xe0\xc7\x81\x1f\x07\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x02\xf8\x09\xe0\x27\x80\x9f\x00\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x12\xf8\x49\xe0\x27\x81\x9f\x04\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x0a\xf8\x29\xe0\xa7\x80\x9f\x02\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x3b\xf0\xdb\x81\xdf\x0e\xfc\x76\xe0\xb7\x03\xbf\x1d\xf8\xed\xc0\x6f\x07\x7e\x3b\xf0\xdb\x81\xdf\x0e\xfc\x76\xe0\xb7\x03\xbf\x1d\xf8\xed\xc0\x6f\x07\x7e\x07\xf0\x3b\x80\xdf\x01\xfc\x0e\xe0\x77\x00\xbf\x03\xf8\x1d\xc0\xef\x00\x7e\x07\xf0\x3b\x80\xdf\x01\xfc\x0e\xe0\x77\x00\xbf\x03\xf8\x1d\xc0\xef\x00\x7e\x27\xf0\x3b\x81\xdf\x09\xfc\x4e\xe0\x77\x02\xbf\x13\xf8\x9d\xc0\xef\x04\x7e\x27\xf0\x3b\x81\xdf\x09\x7c\x0d\x1c\xcf\x27\x6b\x73\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x85\x9d\x71\x61\x67\x5c\xd8\x19\x17\x76\xc6\x4d\xe9\xba\x6f\xf0\xb3\xce\xba\x11\x2f\xfb\x86\xf7\x92\xe3\x08\x67\x91\x6f\x94\x6e\xb0\x47\x46\x4a\x25\x6f\x1c\xec\x8c\x0b\x3b\xe3\xc2\xce\xb8\xb0\x33\x2e\xec\x8c\x0b\x3b\xe3\xc2\xce\xb8\xb0\x33\x2e\xec\x8c\x0b\x3b\xe3\xc2\xce\xb8\xb0\x33\x2e\xec\x8c\x0b\x3b\xe3\xc2\xce\xb8\xb0\x33\x2e\xec\x8c\x0b\x3b\xe3\xc2\xce\xb8\xb0\x33\x2e\xec\x8c\x0b\x3b\xe3\x66\xdc\x48\x7b\xe9\x79\x65\x24\x5b\x2a\x45\xdb\xcb\x4f\x66\xa3\xd9\x72\xb1\xb5\xbd\xf2\xd2\x27\xab\xa1\x35\x1b\x6c\xf0\xf5\x60\xb5\xf9\x7b\x70\xc3\x34\x5f\x8f\x32\xe3\x69\xd9\x1a\x8d\x7e\x5e\xfc\x64\xd9\xcf\x8b\x1b\x4e\xf0\xf5\x28\x49\x7e\x42\x76\x7c\x5b\x83\xf7\x92\xb8\xf7\x42\x5a\xd6\x57\xf6\xda\x59\x2e\xb4\x73\xb9\xc5\x6b\x2f\x4b\xd2\x92\xad\xae\x63\x1c\xcb\x80\x71\x5c\x6e\xf6\xda\x4b\xb0\xcd\xd9\xaa\x6a\xc4\x2d\x97\xca\x6d\x51\xb7\xa2\xe7\x0a\xff\x3a\xd7\x7b\xc9\xd7\xe3\xda\xea\x06\x95\x9c\x0b\x36\xb8\x41\xad\xe7\x82\x5a\x77\x6b\x69\x3d\x57\x4b\xeb\x6e\x50\xeb\xb9\xa0\xd6\xdd\x1a\x5a\xcf\x8d\x6f\x8b\x5e\x54\x99\x5b\xbe\x5c\x8c\x5c\x54\xd6\x42\xbe\x5c\xba\xac\x5c\x2a\x94\x47\x5f\x56\x19\x5d\xa8\x48\x77\x59\x70\xea\x85\x60\xc3\x65\x41\x5d\x14\x82\xba\xb8\xac\x96\x2e\x0a\xb5\x74\x71\x59\x50\x17\x85\xa0\x2e\x2e\xab\xa1\x8b\x42\x0d\x5d\xf0\x0b\xc0\xde\x8b\x93\x85\x4a\x91\x5b\x59\x28\xaf\x95\x8b\xcd\xdc\x5a\x16\xa2\xb9\x50\x55\xf5\xc6\x30\xb8\x37\x86\x8b\x4d\xdc\x5a\x42\x6b\x2a\xf8\x6b\x91\x2b\xcb\xa5\xe1\xb2\x3c\x57\x56\x18\x0e\x57\x8a\x57\x56\x44\x1b\xae\x14\xaf\xac\x48\x39\x5c\x91\xf2\xca\x6a\x29\x87\xab\xa5\xbc\xb2\x22\xe5\x70\x45\xca\x2b\xab\xa4\x1c\xf6\xd7\xea\xae\xf6\x2e\xb3\x37\x72\x16\xb9\xba\x2c\xf3\x8d\x65\x99\xaf\xae\xb0\xbf\xb1\x72\xae\x5c\xed\x9d\x2b\x37\x7a\x2f\xc4\x9b\x6b\x9a\x86\xcf\xa6\xe1\xb3\x69\xf8\x6c\x1a\x3e\x9b\x86\xcf\xa6\xe1\xb3\x69\xf8\x6c\x1a\x3e\x9b\x86\xcf\xa6\xe1\xb3\x69\xf8\x6c\x1a\x3e\x9b\x86\xcf\xa6\xe1\xb3\x69\xf8\x6c\x1a\x3e\x9b\x86\xcf\xa6\xe1\xb3\x69\xf8\x6c\x1a\x3e\x9b\x86\xcf\xa6\xe1\xb3\x69\xf8\x68\x1a\x3e\x9a\x86\x8f\xa6\xe1\xa3\x69\xf8\x68\x1a\x3e\x9a\x86\x4f\xa6\xe1\x93\x69\xf8\x64\x1a\x3e\x99\x86\x4f\xa6\xe1\x93\x69\xf8\x64\x1a\x3e\x99\x86\x4f\xa6\xe1\x93\x69\xf8\x64\x1a\x3e\x99\x86\x4f\xa6\x63\x25\x3c\xcc\x0f\x3e\x99\x86\x4f\xa6\xe1\x93\x69\xf8\x64\x1a\x3e\x99\x86\x4f\xa6\xe1\x93\x69\xf8\x64\x1a\x3e\x99\x86\x4f\xa6\xe1\x93\x69\xf8\x64\x1a\x3e\x99\x86\x4f\xa6\xe1\x93\x69\xf8\x64\x1a\x3e\x99\x86\x4f\xa6\xe1\x93\x69\xf8\x64\x1a\x3e\x99\x86\x4f\xa6\xe1\x93\x69\xf8\x60\x1a\x3e\x98\x86\x0f\xa6\xe1\x83\x69\xf8\x60\x1a\x3e\x98\x86\xcf\xa5\xe1\x73\x69\xf8\x5c\x1a\x3e\x97\x86\xcf\xa5\xe1\x73\x69\xf8\x5c\x1a\x3e\x97\x86\xaf\xa5\xe1\x63\xe9\x44\x89\x2f\xe4\x87\x4f\xa5\xe1\x53\x69\xf8\x54\x1a\x3e\x95\x86\x4f\xa5\xe1\x53\x69\xf8\x54\x1a\x3e\x95\x86\x4f\xa5\xe1\x53\x69\xf8\x54\x1a\x3e\x95\x86\x4f\xa5\xe1\x53\x69\xf8\x54\x1a\x3e\x95\x86\x4f\xa5\xe1\x53\x69\xf8\x54\x1a\x3e\x95\x86\x4f\xa5\xe1\x53\x69\xf8\x54\x1a\x3e\x95\x86\x4f\xa5\xe1\x53\x69\xf8\x54\x1a\x3e\x95\x86\x4f\xa5\xe1\x53\x69\xc4\xea\x1a\xb1\xba\x46\xac\xae\x11\xab\x6b\xc4\xea\x1a\xb1\xba\x86\x0f\xa5\xe1\x43\x69\xf8\x50\x1a\x3e\x94\x86\x0f\xa5\xe1\x43\x69\xf8\x50\x3a\x5d\xc2\xc3\x7c\xe1\x43\x69\xf8\x50\x1a\x3e\x94\x86\x0f\xa5\xe1\x43\x69\xf8\x50\x1a\x3e\x94\x86\x0f\xa5\xe1\x43\x69\xf8\x50\x1a\x3e\x94\x86\x0f\xa5\xe1\x43\x69\xc4\xea\x1a\xb1\xba\x46\xac\xae\x11\xab\x6b\xc4\xea\x1a\xb1\xba\x46\xac\xae\x11\xab\x6b\xc4\xea\x1a\xb1\xba\x46\xac\xae\x11\xab\x6b\xc4\xea\x1a\xb1\xba\x46\xac\xae\x11\xab\x6b\xc4\xea\x1a\xb1\xba\x46\xac\xae\x11\xab\x6b\xc4\xea\x1a\xb1\xba\x46\xac\xae\x11\xab\x6b\xc4\xea\x1a\x31\xba\x46\x8c\xae\x11\xa3\x6b\xc4\xe8\x1a\x31\xba\x46\x8c\xae\x11\xa3\x6b\xc4\xe8\x1a\x31\xba\x46\x8c\xae\x11\xa3\x6b\xc4\xe8\x1a\x31\xba\x46\x8c\xae\x11\xa3\x6b\xc4\xe6\x1a\xb1\xb9\x46\x6c\xae\x11\x9b\x6b\xc4\xe6\xba\x13\xb8\x9d\xc0\xed\x04\x6e\x27\x70\x3b\x81\xdb\x05\xdc\x2e\xe0\x76\x01\xb7\x0b\xb8\x5d\xc0\xeb\x02\x5e\x17\xf0\xba\x80\xd7\x05\xbc\x2e\xe0\x75\x01\xa7\x0b\x38\x5d\xc0\x71\x81\xe3\x02\xc7\x05\x8e\x0b\x1c\x17\xf3\x73\xb1\xae\x2e\x70\x5d\xe0\xba\xc0\x75\x81\xeb\x02\xd7\x05\xae\x8b\x79\xba\xc0\x77\x81\xef\x02\x5f\x03\x4f\x03\x4f\x03\x4f\x03\x47\x03\x47\x03\x47\x03\x47\x03\x47\x03\x47\x03\x47\x03\xc7\xbb\x07\x12\x9b\xe3\xd9\x51\xca\xdb\x90\xc7\x90\xc7\x91\x2b\xe4\x09\xe4\x49\xe4\x29\xe4\x69\xe4\x19\xe4\xed\xc8\x3b\x90\x77\x22\xef\x42\x5e\xc2\xd5\x5e\xde\x06\xbc\x36\xf0\x6f\x4b\x36\xf1\xdf\xbe\xe3\x1f\x85\x2e\x5e\xd8\xd3\xb4\x6c\xb8\x60\xfe\xb4\xaa\xf9\x9d\x68\x6e\x31\xfa\x60\x6c\x0c\x58\x31\x60\xc5\x80\x15\x03\x56\x0c\x58\x31\x5d\xd7\x9b\xef\xe3\x9f\xea\xe5\x16\x15\xfa\xc0\x25\xae\x22\xb9\x15\x8b\x7a\xb2\xbd\x84\x12\x19\xc8\x2e\x36\x7f\xc5\x31\xb7\xc2\x3b\x96\xc0\xc8\x24\x10\x92\x40\x48\x02\x21\x09\x84\x64\xa9\x9f\x6e\x5c\x52\x18\x1e\x18\x1c\xee\xcf\x0d\xe4\x0b\x03\x8d\x4b\xf2\xcb\x73\xa5\x4a\xd3\x20\x09\xdf\x57\xae\xe5\xcc\x5f\x23\x2e\xd5\x22\xe5\x76\x8f\x4f\x06\xab\x91\xc1\x6a\x64\xa0\x9d\x0c\x56\x23\x83\xd5\x68\x47\xbf\x76\xf4\x6b\x8f\x39\x3d\xf9\x81\x2c\x2a\x50\x65\x7b\xb2\xae\x3f\x37\x98\x1b\x2a\x35\x63\xa5\xda\x33\x75\x83\xdd\xb9\x65\xb9\x1e\x67\x71\xa1\x6f\xa9\x63\xfe\xaa\x24\x0e\x60\x52\xed\x98\x54\x3b\xd4\xdc\x01\xb0\x0e\x80\x75\x40\xa8\x0e\x08\xd5\x01\xa1\x3a\x80\xeb\x3d\x62\x8d\xb5\x61\xcb\xb4\x79\x2e\x11\xe5\x49\xe4\x29\x79\x59\x77\x6f\x24\x37\x38\x94\xef\xcd\x0e\x61\x51\xdb\x3c\xc3\x4c\xb9\x1b\x2e\xf4\xe5\x86\xba\xf3\x03\x8b\x23\x43\x23\x05\x2e\x0c\x46\xa8\x89\x15\xd7\xdd\x38\xd4\x3d\x90\x43\x79\xb0\xc1\xe8\x19\xe5\x46\x56\x33\x2a\x1e\xab\xb4\x8a\x64\x07\x06\x0a\x23\x3d\xb9\x25\x43\xf5\x5c\x1a\xee\x8f\x72\xce\x7f\x12\xda\x3b\xb8\xb8\x30\xd2\xe7\x95\x16\x12\x58\x04\xdd\x16\xf7\x35\x96\x4b\x0b\x07\xd9\xe7\x8c\xe1\x67\x4a\xb1\x58\x5b\x22\x5a\x18\x18\xea\x36\xbf\xa4\xcc\xf6\x34\xe6\xfb\x86\xcc\xde\xe4\x3f\xde\xdb\x90\x5b\x36\x9c\x5f\x4e\xfb\xa8\x6f\x51\x2e\xd4\x5d\x18\x1e\xcc\x35\xd1\xd6\xed\x29\x2c\x35\x9b\xab\xaf\x30\x14\x35\x9d\xc9\xfb\xed\x19\xea\x2f\x17\x17\xf2\xc3\xbb\x18\x9e\x0c\xc7\xf0\x44\x38\x86\x27\xb9\x31\x3c\xb1\xa5\x5c\x21\x4f\x23\xc7\xf1\x18\xda\xb1\xfb\x13\x71\xd4\xe3\xa8\x27\x30\xde\xf3\x74\x28\x07\x7f\xcf\xd3\xa1\x1c\xfd\x3d\x4f\x87\xf2\x24\xf2\x14\x72\xe0\x79\x1e\x0f\xe5\xed\xc8\x3b\x90\x97\x70\xba\x90\xbb\xc8\xbd\xed\x93\x48\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\x7c\x9c\x93\x09\x9c\x93\x09\x73\x4e\xf6\x2f\xec\x29\x2c\xba\xa1\x9e\xd6\xca\xe4\x21\xaf\xd6\xb3\xc4\xcb\x07\x86\x50\x1f\x1a\xec\xce\x2e\xce\x85\x98\xd6\x2f\xbe\x81\xf3\xc8\x92\x7c\x4f\x0f\x5d\x68\x0a\xde\x99\x8f\xe7\xcb\x31\x3c\x1f\xa6\xbc\x23\xea\xf5\x18\xa0\x15\xae\x1f\x1a\xc8\x67\x97\x0e\xf7\x7b\xf9\x00\xea\x8b\xfb\xbc\xbc\x67\x49\x9d\x89\x0a\x7b\xbc\xdd\x92\xe8\x84\x5e\x3a\x75\x24\xdf\xb7\x7c\xe1\x30\x31\x19\x32\x25\xaf\x4f\xb4\xd0\x9f\xeb\x43\xe3\x60\x6f\x9e\xb6\x68\x76\x51\x8e\xf6\xd2\xf2\x72\x45\x0e\x0e\xf7\xd5\x2d\xc9\xf5\xd2\x6e\x72\x0c\x09\x0d\xf6\x93\xbc\xce\xa2\x9e\xe1\x85\xa1\xee\x5c\x96\xd0\x17\xe7\xb3\xbd\x74\x39\x6b\xe8\x1d\x1e\xc4\xfe\xca\x35\xfb\xca\x74\x5d\x63\x09\x92\x9e\x4f\x18\xeb\xc4\x4a\x74\x62\x25\x3a\xb1\x12\x9d\x58\x89\x4e\xac\x44\x27\x56\xa2\x13\x2b\xd1\x89\x95\xe8\xc4\x4a\x74\x62\x25\x3a\xb1\x12\x9d\x58\x89\x4e\x5c\x1d\x3b\x71\x75\xec\x4c\x01\x27\x05\x9c\x14\x70\x52\xc0\x49\x01\x27\x05\x1c\xcf\xf7\x8c\xe1\xbe\x76\x7b\xaa\x9c\xa7\x91\x67\x90\xb7\x23\xef\x40\xde\x89\xbc\x0b\xb9\x8b\x5c\x7b\xb9\x17\x4b\x51\xde\xe6\xe5\x69\xf0\x4b\x83\x5f\x1a\xfc\xd2\xe0\xe7\xf9\x9a\xe4\x52\xb5\x21\x8f\x79\xb9\xc7\x9f\x72\xb7\xd1\x7b\x6e\x7d\x1d\x3f\xe0\x6f\xa1\xd3\x39\x47\x81\xb4\xf9\xab\xc1\xe6\x81\x78\xd8\x3c\x77\x1f\xc9\xd3\xde\xe2\x27\xee\xa6\x54\xd7\x9d\x33\x59\xfd\x0d\x59\xef\x00\x3f\x5e\x37\xa5\xc6\xd2\x23\x76\x53\x09\x9b\x87\xe0\xdc\x6f\x28\xbb\x9c\x8f\x12\xe7\xeb\xfa\x7b\x86\x07\xcd\x1f\xa4\x6d\x30\x8f\xd0\xf1\x46\x40\x94\xcb\x5c\x9c\xc2\x4d\xfc\x1a\x01\x0e\xb6\xfa\x5a\xb8\x21\x62\x04\x62\x51\xa3\xa6\xe4\xbd\x22\xc0\x8d\xbd\xd9\xfe\xfc\xb2\xc8\xc2\xdc\x90\xd7\xbd\x81\x5f\x14\x40\x99\x85\xf7\xca\xe1\xee\x9c\x57\x88\x2c\xcf\x2e\xc7\x61\x7e\x81\x00\xad\x43\xa5\x8e\x11\x52\x8a\x57\x6a\x2e\xbd\x4e\x80\x03\xe5\x52\x03\xcf\x1d\xad\x34\x71\x94\xfa\x86\xc1\xac\xd1\x7b\xb5\xc0\xab\x34\xe1\xdd\x02\x88\x51\x2a\x34\xf0\xcb\x05\x18\xb9\xac\x00\xce\x51\xa3\x3e\x14\x2b\x2a\x88\x0c\x95\x44\x0e\x93\xf0\xde\x4b\x18\x34\x61\xf3\x96\x85\x59\x0e\x93\x93\x99\x34\x19\x6b\x84\xa5\xe3\x65\xc6\x63\x11\x8d\xc7\x22\x1a\x8f\x45\x34\x1e\x8b\x68\x72\xa9\x1a\x7c\xbf\x0f\x8d\xf0\x8d\xc0\xd9\x8b\x6e\x1c\x68\xe5\xdf\xf3\xfb\x0e\x4d\xf1\x95\x07\xcc\x4b\xe6\xb9\x30\xdf\x01\x99\x3d\xbc\x28\xcc\xb7\x5f\xa8\xd0\x54\xb9\xa1\x64\x9a\x99\x05\x15\x1a\x4a\x77\x9e\x4d\x23\xdf\xfe\xa0\x42\x8b\xff\x97\xfd\xe6\x80\x07\x3d\xbc\x28\xea\xb1\xa5\x5d\xd3\x56\x29\xc6\x2a\xc5\x78\xd4\x83\xe3\x0e\xe5\x62\xac\x52\x8c\x37\x97\x6f\xba\x70\xa7\xea\x6a\xac\xba\x1a\x8f\x7a\x02\x31\xb7\x72\x31\x16\xf5\xa4\x31\xad\x2d\xbe\x49\x99\x7a\x53\xe9\x3e\x4f\x40\x02\x55\x29\x26\x2a\xd2\xaa\x4a\x31\x51\x8d\xac\xaa\xab\x89\x0a\xba\x4f\x26\x55\x29\xfa\x3a\x24\x2b\xc5\x54\xa5\x98\xae\x92\x2c\x56\x55\x8b\x57\xd5\x54\x55\x2d\x51\x55\xf3\xf1\xce\x54\x1d\x48\x55\xd5\xaa\xc1\x32\xcd\x55\x4a\x99\x53\x5d\x6d\xab\xae\xc6\xaa\xab\xf1\xea\xaa\xaa\xae\x26\x1a\x2a\xeb\x33\xc7\x57\x6e\xf3\x95\x63\xbe\x32\x4f\xd4\xfc\xf0\x37\xef\x2d\x1e\x6d\x72\xf3\x03\x2e\xf3\x23\xaf\xd9\x8b\xb2\xfd\xbe\x7a\x5b\xa0\xde\x19\xa8\xcf\xf1\xd5\x53\x81\xf1\xf1\xaa\x7a\xcc\x4d\x20\x25\x03\xf5\x54\xa0\x9e\x0e\xd4\x33\xbe\x7a\xd2\xe4\x81\x7a\x32\x50\x4f\x05\xea\xe9\x40\x3d\xd3\xe0\xab\xfb\x8e\xa5\x02\xbc\x53\x35\x8e\xa7\x02\xf5\x74\xa0\xee\xe7\xed\xef\x9b\x0e\xf0\x4e\x07\x78\xa7\x6b\xf4\x4f\x07\xea\x7e\xde\xfe\x63\x99\x00\xef\x4c\x80\x77\x26\xc0\x3b\x53\x63\xbc\x9f\x77\x49\xdf\xc9\xd2\x1a\x04\xea\xc9\x40\x3d\x15\xa8\xa7\x03\xf5\x12\xef\x64\x80\x57\xad\x7a\x2a\x50\x4f\x07\xea\x7e\xd9\x52\x81\xf1\xa9\x80\x6c\xa9\x00\xbf\x54\x80\x5f\x2a\x20\x9b\xbf\x6f\x3a\xc0\x3b\x1d\xe0\x9d\xae\xd1\x3f\x1d\xa8\xfb\x79\xfb\x8f\x65\x02\xbc\x33\x01\xde\x99\x00\xef\x4c\x8d\xf1\x7e\xde\x25\x9d\xa4\x02\xeb\x95\x0a\xac\x57\x2a\xb0\x5e\xa9\xc0\x7a\xa5\x02\xeb\x95\x0a\xf0\x4a\xd6\xa8\x27\x03\xf5\x54\xa0\x9e\x0e\xd4\xfd\xbc\xfd\x63\x83\x58\xb5\x8e\xa7\x03\x75\xff\xbc\xd3\x81\xf1\xe9\xc0\xf8\x74\x40\xb6\x74\x80\x5f\x3a\x20\x9b\xff\x58\x26\xc0\x3b\x13\xe0\x9d\x09\xf0\xce\xd4\x18\xef\xe7\x5d\x92\x3b\x1d\x58\xaf\x74\x60\xbd\xd2\x81\xf5\x4a\x07\xd6\x2b\x1d\x58\xaf\x74\x80\x57\xb2\x46\x3d\x19\xa8\xa7\x02\xf5\x74\xa0\xee\xe7\xed\x1f\x9b\x0a\xf0\x4e\xd5\x38\x9e\x0a\xd4\xd3\x81\xba\x9f\xb7\xbf\x6f\x70\x1e\x41\xec\x5a\xfd\xfd\x3a\xcd\x04\xc6\x67\x02\xe3\x33\x81\xf1\x99\x80\x6c\x99\x80\x6c\x25\xde\x99\xc0\x7a\x65\x02\xeb\x95\x09\xac\x57\x26\xb0\x5e\x99\xc0\x7a\x65\x02\xbc\x92\x35\xea\xc9\x40\x3d\x15\xa8\xa7\x03\x75\x3f\x6f\xff\xd8\x54\x80\x77\xaa\xc6\xf1\x54\xa0\x9e\x0e\xd4\xfd\xbc\xfd\x7d\xd3\x01\xde\xe9\x00\xef\x74\x8d\xfe\xe9\x40\xdd\xcf\xdb\x7f\x2c\xa8\xa3\xe0\xbc\x82\xb2\x78\xe3\xc9\x35\xa7\x48\x3e\xbf\xe8\xba\xc2\x90\xf9\x1c\x13\xfc\x11\x15\xf0\x57\x54\xc0\xbf\x89\xd7\xa8\xa7\x7d\xf5\x36\xe3\xe3\xf8\xea\x9d\x81\xba\x2a\xf5\x6f\x5c\x98\x1d\xc8\x97\xfe\xb6\xca\x09\x7c\xb0\xa3\xcd\xeb\xd0\x66\x98\xce\xa9\xd1\xd6\x16\x68\x53\x35\xfa\xa9\x40\xbf\x64\x0d\x7e\xc9\x1a\xfc\x92\x35\xf8\x25\x03\xfc\x32\x35\xe4\xcb\xd4\x90\x2f\x53\x43\xbe\x4c\x0d\xf9\x32\x35\xe4\xcb\xd4\x90\x2f\x53\x43\xbe\xcc\x78\xf9\x3a\x13\xe3\xe5\xab\x6a\x0b\xf6\x53\x35\xfa\x05\xf9\x25\x6b\xf0\x4b\xd6\xe0\x97\xac\xc1\xaf\x96\xfe\xd2\xa5\x4d\x56\xa3\x2d\xd8\x2f\x59\xa3\x5f\x32\x80\x1b\xe0\x57\xd5\x16\xec\x97\xac\xd1\x8f\xf9\x99\xbf\x5f\x30\x94\x5b\x9c\xe7\xb8\x2b\xec\xf6\x2d\x65\x97\xbf\x54\x88\x95\x0a\xf1\xf0\x4d\xb9\x81\x82\x29\xd5\x17\xfa\x38\x4a\xa8\x1f\x1a\xe1\x7a\x84\xef\xc3\x9a\x52\xd8\xdc\xf9\xf6\x0a\x79\x2f\x1e\xab\x1f\xcc\x73\xbc\x17\xe1\x5b\xb2\x5c\xe2\xfb\xb2\xdc\xa9\x2f\xef\x31\x6a\x09\xbc\xd4\xd1\x12\x78\x85\xa3\xb9\xfa\x65\x8d\x96\xc0\x5b\x19\xd1\xca\x2b\x3e\xd1\xca\x5b\x3d\x91\xf2\x4b\x3c\xd1\xca\x2b\x3b\x53\x03\x48\xb3\x7b\x16\x4d\x0d\x80\x51\xd3\x94\x6a\xbc\xea\x4e\x5e\x90\xd4\xb3\xa8\xa9\x82\x5a\xae\x95\x18\x34\x96\xb1\xcb\x87\xca\xc3\x86\xbd\x47\x3a\xb3\x07\xbb\x0b\x03\x43\x0d\xfc\x83\x6c\xaf\xdc\xca\xf7\x1b\xf8\xae\x04\xee\x5c\x54\x1a\xca\xb7\x50\xbc\x1b\x36\x4d\xa5\x2a\xff\x1e\xe5\x84\xf2\xcd\x8a\xca\x0f\x53\x9a\xcb\x6d\x81\x2a\xff\x26\xa5\xd5\x77\x9b\x8a\x5b\xf9\x66\x10\x6e\xa8\x98\x2d\x92\xa0\x4b\x40\xa2\xa3\x0b\xe5\x98\xaf\x1c\x37\x65\xe7\xeb\xd7\x75\xb8\x02\x5f\xde\x0c\x0b\x5b\x4c\x11\x56\xb1\x68\xbe\x29\xc9\xdf\xc1\x14\x62\x85\xb8\x95\xbf\x1c\x34\x45\x08\x67\x93\xb0\x9c\xcd\xce\xbb\x42\x3a\xef\x39\xef\x51\xf9\x7d\xe7\x7d\x2a\x1f\x76\x0e\x53\xf9\x03\xe7\x23\x2a\x1f\x75\x8e\x52\xb9\xe8\x10\x87\x90\x08\x3f\x21\xac\xf0\x93\xe1\x27\x85\x0c\x6f\x0a\x1f\xa4\xf2\x3b\xe1\x77\x84\x1d\x3e\x14\x25\x8c\xe8\xd4\xe8\x34\x61\x9b\xbf\x26\x4a\xe5\x93\xa2\x27\x0b\x19\x9d\x11\x9d\x41\xa8\x0e\xbe\x53\x64\xf9\x52\x54\x2c\x14\xf7\x08\x87\x2e\xf5\x3d\x62\xc6\xd2\x81\xdc\x0d\x22\xd6\x9d\x5b\x38\x20\xce\xef\xc9\x0e\xf5\x09\xfe\xb2\xd1\xd7\xbe\xda\x75\xba\x68\xfd\xfa\xe5\x1d\x44\x85\xa0\x19\x58\xfc\x15\x23\x81\xb2\x28\x97\x6d\xfe\xc2\x51\xd5\x91\x45\x8b\x7a\xfb\xc5\x0c\xa6\xa7\x2f\xee\xc9\x2f\x15\x67\xf5\x14\x16\x99\x6f\x2b\x89\xb2\x3c\xe6\x9b\x48\xa6\x56\x92\xa8\x8e\x74\x73\xa2\x38\x55\x9c\x49\xbd\x92\x68\x9d\x43\x7d\x4d\x0f\x85\xbc\x8b\x7a\x51\x6e\xd7\x31\x0f\xcb\xbe\xc0\x6b\xaf\xff\x21\xd1\xba\xba\xb4\x29\xcb\x97\x89\x4e\xa5\x14\x36\x48\x46\x3b\xa1\x46\xd3\x1e\xa2\xfe\xd6\x7d\xe2\x64\x91\x16\x1d\x34\xbf\xab\xc4\x02\x71\xbd\x18\x12\xb7\x88\xef\x8a\x7b\xc5\x6a\xf1\x88\x78\x5c\xbc\x20\x76\x53\xc7\xa8\x35\xcd\x3a\xd5\x3a\xcb\x8a\x59\xe7\x59\xda\x9a\x6b\xdd\x6d\xf8\x44\x4f\x12\x36\xad\x92\x29\x4d\x2f\x97\x4e\x2e\x97\x4e\xa4\xd2\x21\xc6\x7b\xa1\x5c\xda\x51\x2e\xbd\x58\x2e\xfd\x9a\x4b\x36\xcd\xa2\x31\xfc\x16\x95\xdf\x0e\xbf\x54\x3e\xf6\x9b\x72\x69\xa7\xaf\xd7\x2e\x53\xa6\x55\xb7\x9d\xfd\xbc\x9b\x9a\xc5\x34\x5a\x6b\xdb\xd9\x1b\x6d\x25\x7a\x20\xfc\x72\x79\xd4\x2b\x5c\x32\x7d\x5a\xc5\x89\xd1\x66\xda\x39\x87\x9c\xb7\xa3\x2d\x8c\xb2\xbb\xdc\xeb\xb7\xe5\xd2\x9e\x72\xe9\xd5\x72\x69\x6f\xb9\xb4\xaf\x5c\x7a\xad\x5c\x7a\xbd\x5c\xda\xcf\xa5\x7a\x42\x9a\xce\xdf\x27\x9d\x43\x2b\x76\x5e\xf8\x39\xc2\x3c\x42\xd2\x3e\xc7\xd8\x47\xc2\xcf\x52\xfe\x01\xd5\x9f\xe5\xfa\x07\xe1\x37\x78\x2e\xdb\x89\x1e\x09\x8f\x11\xfd\x80\x79\xbd\x89\xd9\xd6\x3b\xfb\x9c\xd7\xcd\x47\x69\x43\x75\xb4\xd3\xc3\xb4\x6a\xd1\x50\x73\xa8\x59\xf0\x77\x16\x44\xab\xf9\xce\x82\x98\x1a\x3a\x31\x34\x43\x4c\xe3\x9d\x63\x53\xfe\x05\xe2\x30\x8b\xf7\x4a\x88\x68\x88\xbf\xd8\xd0\x10\x9a\x16\x3a\xc5\xec\x55\xfe\xc2\xc3\xfb\x66\x9f\x51\xfb\x29\x42\x84\x57\x86\x57\x8a\x53\xc3\x7f\x19\xde\x26\x4e\xa3\xfd\x70\x3d\x8d\x69\xb5\xbe\x60\x2b\xa9\x9d\x79\x62\xa6\x38\x97\xf6\xc5\xc5\xe2\x72\x71\x0d\x9d\x19\xd7\x8b\x01\x71\x93\xf8\xb6\xb8\x5d\xdc\x4d\xbb\xe3\x41\xb1\x4e\xac\x17\x1b\xc5\x4f\xc5\x5f\x8a\x67\x68\x97\xbc\x2c\x5e\x13\x07\xc5\x11\xda\x2b\x75\x56\x63\xe4\xeb\x42\xda\x3f\xb0\x7f\x10\xb9\x9c\xf3\x75\x91\x7f\xca\xf9\xc3\x91\xb9\x9c\xaf\x8d\x5c\xc6\xf9\x43\x91\xaf\x51\xbe\x8e\xfa\x5d\xc2\xf9\xba\xc8\x57\x39\x7f\x38\x72\x31\xe7\x6b\x23\x17\x71\xfe\x50\xe4\x2b\x94\x3f\x4c\xfd\x34\xe7\xeb\x22\x2e\xe7\x0f\x47\xba\x38\x5f\x1b\xe9\xe4\xfc\xa1\x48\x3b\xe5\x6b\xa9\xdf\x05\x9c\xaf\x8b\xfc\x13\xce\x1f\x8e\x9c\xcf\xf9\xda\xc8\xef\x73\xfe\x50\xe4\x3c\xca\x1f\xa2\x7e\x5f\xe6\x7c\x5d\xe4\x5c\xce\x1f\x8e\x64\x38\x5f\x1b\xb9\x54\xd8\xd4\x7a\x05\xd1\x1f\x44\x3a\x88\xae\x8d\x5c\x48\xf4\xe1\x4f\xa0\x91\x02\x34\xd2\x07\x8d\xf4\x42\x23\x3d\xd0\xc8\x0d\xd0\x48\x1e\x1a\xe9\x86\x46\x96\x42\x23\x4b\xa0\x91\x1c\x34\xb2\x08\x1a\x59\x08\x8d\x64\xa1\x91\x05\xd0\xc8\x75\xd0\xc8\xb5\xd0\xc8\x1f\x42\x23\xf3\xa1\x91\x3f\x80\x26\xae\x86\x26\xe6\x41\x13\xdf\x80\x26\xae\x82\x26\xae\xe4\xfc\xa1\x48\x3f\xeb\x62\xb1\xd1\x42\xe4\x1a\xa2\x0f\x45\xae\x37\x3a\xfa\x04\x1a\xf9\x57\xd0\xc8\xed\xd0\xc8\x1f\x43\x23\xdf\x85\x46\xfe\x25\x34\xf2\x2f\xa0\x91\xdb\xa0\x91\x7f\x0e\x8d\x7c\x1b\x1a\xf9\x67\xd0\xc8\xad\xd0\xc8\x1f\x41\x23\xb7\x40\x13\xdf\x82\x26\xbe\x09\x4d\xdc\x04\x4d\xdc\x08\x4d\xac\xc0\xde\x18\x81\x46\x86\xa1\x91\x21\x68\x64\x10\x1a\x19\x80\x46\x96\x41\x23\xdf\xe1\x3d\x72\x07\xeb\x65\x39\x6b\xe4\x66\xb3\x53\x3e\x81\x46\x1e\x82\x46\xd6\x40\x23\xff\x09\x1a\x59\x0d\x8d\xfc\x47\x68\xe4\x41\x68\xe4\xcf\xa0\x89\x07\xa0\x89\x3f\x85\x26\xfe\x03\x34\x71\x1f\x34\xf1\xef\xb1\x37\xee\x85\x46\xfe\x1d\x34\xf2\x6f\xa1\x91\x7b\xa0\x91\x7f\x03\x8d\xac\x82\x46\xfe\x35\x34\xf2\x27\xd0\xc8\x5d\xd0\xc8\x9d\xd0\xc8\xf7\xa0\x91\x95\xd0\xc8\xfd\xbc\x3b\xd6\xb2\x46\xee\x66\x8d\x7c\xff\x13\x6a\xe4\xe7\xd0\xc4\xcf\xa0\x89\x9f\x42\x13\x3f\x81\x26\xfe\x17\x34\xf1\x18\xf6\xc6\xff\x84\x46\x46\xa1\x91\xbf\x80\x46\xfe\x07\x34\xf2\x63\x68\xe4\xbf\x43\x23\x8f\x42\x23\xff\x0d\x1a\xf9\x73\x68\x64\x3d\x34\xf2\x5f\xa1\x91\x1f\x41\x23\xff\x05\x1a\xf9\xcf\xd0\xc8\x0f\xa1\x91\x1f\x40\x23\xeb\xa0\x91\x87\xa1\x91\x8d\xac\x91\xc7\x79\xa7\x3c\xc2\x1a\xd9\xc0\x1a\x21\xef\xc0\x8c\x67\x7b\x7e\xb1\xb9\xe6\xd2\x55\x7b\x16\xd9\x8b\x0b\x60\xe1\x9e\x67\x3b\xf6\x2b\xa2\x6f\xb1\x3d\x38\x40\xa5\xf7\xb9\xf4\x76\xb9\x74\xb0\x5c\xda\x84\x7e\xd5\xd7\x7a\xcf\x9f\x59\x73\x0c\x7f\xa6\xb5\xa6\x3f\x23\x26\xe9\xcf\xc8\x1b\xc8\x21\x14\xd3\x98\xce\x30\x31\x31\x59\x3d\x33\x9f\x29\xf0\x5d\x04\x71\xfc\xb8\xaf\x3c\xce\xa0\x39\x9f\x2f\xb4\xb8\x94\x7c\x8f\x6b\xc5\x12\xd1\x27\x6e\xa6\x7d\xf1\x7d\x92\xfa\x11\xf1\xa8\x78\x4c\x6c\x17\x87\xc4\x51\xda\x09\xcd\xd6\x89\xe4\x7f\x9c\x69\xcd\xb6\x92\xd6\xf9\xc4\x33\x42\x7e\x4b\xab\xe7\xe7\x84\xa7\xb3\x57\x63\x45\x7f\x4c\xf5\x7a\xca\x77\x7b\xed\x0d\x51\xe4\x2f\x78\xf9\x94\x7b\x3d\xef\xe7\xa4\x27\xa6\x4f\x9f\x7e\xfd\xf4\x51\xaf\x76\xb2\x38\x79\xc5\xc9\x47\x66\xdc\xec\xd5\x66\xec\xf9\x7c\xfa\xf3\xb7\x7f\xfe\x45\xaf\x36\xf3\xf4\x99\x0f\x9e\x32\xe3\x94\xfb\xbc\xf1\xa7\xd6\x79\xf9\xe9\x8f\x79\xf9\x3f\xbc\x9e\x7b\x85\xcf\x3c\xf1\xcc\xdb\xce\x7c\xe9\xf7\xd2\xbf\x77\xf7\xef\xed\x3f\x4b\x9f\xf5\x00\xb7\x36\x9d\xf5\xe2\xd9\x8d\x67\x9f\x77\x76\xcf\xd9\xf7\x9d\xbd\xe5\xec\x0f\xcf\x99\x75\xce\xfc\x73\xee\x38\x67\xf4\x9c\xfd\x5f\x9c\xc9\xc7\xed\x2f\xce\xfa\x22\x5d\x45\x4d\xf9\x8b\xb7\xb0\x17\x67\x7d\x79\xd4\xe3\xfb\xe5\x9f\x7b\xf9\xf9\xfd\x5e\xde\x01\x7f\xcf\xed\xf1\xfa\x5d\x34\x0b\xb9\xe2\x35\xb1\x2e\x9a\x4b\xa7\xca\x3a\xd2\xb0\x10\x6d\xfc\xa5\xe2\x1e\xb1\xd5\xba\xc5\x9e\x6d\x27\xc5\x56\xd1\x63\xef\x94\xaf\x89\x1e\xe7\x12\x7b\x27\x79\xd2\x5b\xed\xd9\xa2\xa7\x8e\xfe\x99\x3e\xe6\x18\xd3\xd9\xde\x7f\x8c\xed\xe1\x5e\x5b\xed\x9d\xe6\xa8\xd7\xea\x8d\x35\x6d\x54\x6b\x0d\x35\x16\x7f\x55\xfc\x55\x68\x2a\xd3\x93\x98\x9e\x6c\x68\x78\x33\xd3\xad\x4c\xc7\x98\x6e\x67\xfa\x2c\xd3\xe7\x98\xee\x66\xfa\x3a\xd3\x37\x0c\x8d\x36\x33\x6d\x61\xfa\x39\x43\xc5\x29\x21\xab\xf8\xb3\xe2\xcf\x42\x76\xf1\xde\xe2\xbd\x21\x87\xcb\x75\xe2\x6c\x71\x76\xa8\x9e\xcb\x51\xa6\x0d\x4c\x9b\x98\x36\x33\x9d\xc2\xf4\x04\xa6\xd3\x98\xce\x30\x34\xbc\x85\xe9\x2f\x99\x3e\xc5\x74\x1b\xd3\x5f\x33\xdd\xc9\xf4\x15\xa6\xaf\x32\xdd\xcb\x74\x1f\xd3\x37\x99\x1e\x60\xfa\x36\xd3\x83\x86\x46\x5b\x99\x32\x22\xcb\x6b\xb4\x60\x17\xf7\x17\xf7\x87\x24\x4b\xea\x70\x4b\x3d\xd3\x28\xd3\x06\xa6\x4d\x4c\x79\xce\x24\xaf\xa1\x27\x30\x9d\xc6\x74\x06\xeb\x65\x0b\xd3\x5f\x32\x7d\x8a\xe9\x36\xa6\xbf\x66\xba\x93\xe9\x2b\x4c\x5f\x65\xba\x97\xe9\x3e\xa6\x6f\x32\x3d\xc0\xf4\x6d\xa6\x07\x59\xb3\xad\x4c\x19\x91\xbc\x3c\x9b\xf3\x99\x65\xb9\x0d\xfd\x2c\x4b\x3c\x6b\x52\x92\x36\xb2\xfe\xc7\xcb\x3b\x95\xdb\xfd\x52\x9f\xc4\x2d\x27\x33\x9d\x81\xbd\x4b\xe5\xaa\x79\x6c\xe5\x16\xff\x6c\xc6\xb8\x65\x3b\xd3\x67\x99\x3e\xc7\x74\xfc\x2c\x77\x73\xfb\xf8\xb9\xbe\xce\xed\x6f\x30\x9d\x68\xde\xcd\xe6\x28\x9d\x0f\x86\xfa\x74\x40\xe7\x06\xb5\xf0\xd9\x67\xa4\xf6\xe6\xe4\x9b\x07\x66\xe0\x49\x3d\x91\xa4\x9e\x5c\x3e\x29\xaa\xd0\x3c\x04\xb3\x2b\x0c\x57\x87\x69\xe9\xbc\x33\xe5\x28\xd3\x06\x68\xd9\x50\x1e\x4d\x5a\xf6\xf4\x6b\xe8\x34\xe8\xd4\xd3\xa6\xa1\xbf\x84\x1e\x0d\xdd\x06\x7d\x19\xba\x93\xe9\x2b\xd0\x94\xa1\x7b\x99\xee\x83\x76\x0c\x3d\xc0\xf4\x6d\xa6\x07\xa1\x11\x43\x19\x51\x7c\x69\xc2\x5d\x11\x86\xbc\xff\x6f\xed\x8d\xcf\x43\x1f\x9f\xe5\x33\xd9\x12\x6d\xe5\x2f\x08\xd6\xf9\xbe\x1d\xd8\xcc\xdf\x0d\x3c\x21\xf4\x39\x7c\x2f\x70\x66\xe8\x14\xfe\x2e\x91\xf9\x2a\x91\xf9\x26\x51\xf0\x8b\x44\x2f\x86\x77\x86\x5f\x0e\xef\x0e\xef\xc5\x97\x87\x0e\x94\xbf\x1e\xc3\x77\x7a\xec\x7b\xec\x3e\xa2\xf7\x91\xa7\x71\x09\xf9\x98\x0f\x90\x3f\xf1\x43\xf2\x32\x7f\x4c\x1e\xc5\xcf\xc9\xcf\x7c\x5a\x3c\x27\x5e\x24\x4f\x73\xaf\x78\x93\xfc\x0b\xf8\x9a\xd6\x54\x6b\x3a\xf9\x18\x67\x58\xe7\x58\x73\xc8\xcb\x38\xcf\xea\xb0\x2e\xb4\x2e\xb5\xae\xb0\xae\xb1\x16\x58\x4b\xac\x1e\x6b\xc0\x5a\x61\xdd\x62\xdd\x66\xdd\x6e\xdd\x65\xdd\x63\xdd\x67\x3d\x68\xad\xb5\x1e\xb1\x36\x58\x1b\xad\xc7\xad\x27\xac\x2d\xd6\x33\xd6\xf3\xd6\x4b\xd6\x6e\xeb\x35\xeb\x80\xf5\x9e\xf5\xa1\x6d\xdb\x61\xbb\xd9\x9e\x66\xcf\xb0\x4f\xb7\xcf\xb4\x67\xd9\x31\x3b\x6d\x9f\x6f\x77\xd9\x17\xdb\x73\xed\xab\xec\xf9\xa4\x8b\xf3\x42\xf7\x04\xa8\xa8\x94\x2d\x27\xd8\x52\xa3\x27\xd3\xe2\x2d\xb5\x39\x4c\xd8\x32\x8e\x43\x8d\x16\x7f\xfb\x5c\x1f\x5d\x1c\xfa\xb3\x63\xf0\x9f\x48\x1e\xbf\xb4\x3f\x1a\x57\x1e\x2f\xdb\xb1\xe5\x9f\xa8\xc5\x8f\x3e\x7e\x5e\xc7\x94\x79\x22\x09\xfd\x3d\x8f\x6e\xaf\x50\xdf\x51\xf2\xd8\xab\xee\xa5\x6c\x22\x7f\xfc\x34\xbe\xa3\x72\x3a\xed\xdb\x83\xe2\x2c\xda\x9b\x53\xc4\x85\xc6\x57\x73\xde\x16\xde\x5d\x3d\x6f\xa4\xb9\xfb\x39\x5d\x98\x3b\x73\x9e\xc7\x3c\x15\x7d\xc8\xcf\x26\x8e\xe4\x6b\xd3\x39\x32\x83\xbc\x7a\x3a\x1b\xc4\x0c\xe6\x38\x93\x7a\xcc\x14\xb4\xc3\x29\x5e\x30\x77\xf0\xc8\x33\xb4\xe7\xb1\x24\x16\x61\x9b\xd1\x1f\x54\x21\x58\xe2\x09\x71\x3f\xd1\x2d\xd4\x7b\xaa\x38\x93\x62\x8c\x98\x48\x93\xc7\xdd\x45\x51\xc7\x5c\xf2\xb9\xe7\x53\x84\xd0\xcd\xdf\x99\xbf\x49\xdc\x2a\xbe\x23\xee\x20\x7e\xb7\xdb\xa3\x44\xd7\xda\xb7\x92\x26\xb6\x72\x79\x95\x3c\x9d\x78\xac\xb0\x67\x96\x5a\x8a\x5b\x4d\x8b\x47\xed\x79\xf6\x3c\xa2\x67\x5a\x24\x8b\x75\x33\xf7\x5f\x6e\xa8\xf5\x63\x7b\x15\xd1\x47\xec\xa7\x89\xde\xcb\xed\xbb\x0d\x95\x8f\xda\x3d\x25\x2a\xa6\x86\xea\x43\x4d\xa1\x96\xd0\x54\x3a\xf3\xf9\x1b\xa1\xa4\xc3\xca\xf7\xc8\x70\xe6\xf3\xbc\x0e\x55\xe6\x65\xb8\x38\xef\x39\x5b\x85\x1d\x9a\x69\xce\x70\x2b\x66\xa5\xad\xf3\xad\x2e\xeb\x62\x6b\xae\x75\x95\x35\xdf\x5a\x68\x75\x5b\x7d\xd6\x90\x75\x93\x75\xab\xf5\x1d\xeb\x0e\xeb\x6e\xeb\xfb\xd6\xfd\xd6\x6a\x6b\x9d\xf5\x23\xeb\x51\x6b\xd4\xfa\xa9\xb5\xc9\xda\x6a\x6d\xb7\x5e\xb0\x76\x5a\x7b\xac\xfd\xd6\x41\xeb\xb0\x75\xd4\x76\xec\xa8\xdd\x6a\x9f\x68\xcf\xb4\xbf\x60\x9f\x45\x1e\xb1\xb2\xcf\xb5\x2f\xb0\xb5\x7d\x89\x7d\x39\xcd\xf1\x5a\x7b\xb1\x7d\xbd\xdd\x4f\x73\xbb\xd9\xfe\xb6\xfd\x5d\xfb\x7b\xf6\x2a\xfb\x5e\xfb\x01\x7b\x8d\xfd\x43\x7b\xbd\xfd\x63\xfb\x31\xfb\xe7\xf6\x5f\xda\x4f\xdb\xcf\xd9\x2f\xda\x2f\xdb\x7b\xed\x37\xed\x43\xf6\x11\x29\x64\x9d\x6c\x94\x53\xe5\x74\x79\xaa\x3c\x43\x9e\x23\xe7\xc8\xa4\x3c\x4f\x76\xc8\x0b\xe5\xa5\xf2\x0a\x79\x8d\x5c\x20\x97\xc8\x1e\x39\x20\x57\xc8\x5b\xe4\x6d\xf2\x76\x79\x97\xbc\x47\xde\x27\x1f\x94\x6b\xe5\x23\x72\x83\xdc\x28\x1f\x97\x4f\xc8\x2d\xf2\x19\xf9\xbc\x7c\x49\xee\x96\xaf\xc9\x03\xf2\x3d\xf9\xa1\x63\x3b\x61\xa7\xd9\x99\xe6\xcc\x70\x4e\x77\xce\x74\x66\x39\x31\x27\xed\x9c\xef\x74\x39\x17\x3b\x73\x9d\xab\x9c\xf9\xce\x42\xa7\xdb\xe9\x73\x86\x9c\x9b\x9c\x5b\x9d\xef\x38\x77\x38\x77\x3b\xdf\x77\xee\x77\x56\x3b\xeb\x9c\x1f\x39\x8f\x3a\x66\x25\xfe\x34\xa4\xcd\xba\xd6\xad\xa6\xb5\x39\x64\xca\xd6\x21\x2e\x77\x73\xb9\xdb\x94\xed\x99\xdc\x67\x26\x97\xe7\x71\x79\x1e\xf7\x69\xe6\x3e\xcd\x5c\x5e\xcd\xe5\xd5\xdc\x67\x55\x85\xa7\xbf\x5c\xd5\xff\x2e\x2e\xdf\x15\x2c\xfb\xf9\xfb\xc7\xca\x46\x53\x96\x8d\xe3\xf8\x5c\xc0\xe5\x0b\xb8\xff\xad\xdc\xff\xd6\x71\x7c\x26\x2a\x87\xb9\x1c\x1e\x57\x9e\xc3\xe5\x39\xe3\xe6\x75\x98\xdb\x0f\x73\x79\x94\xcb\xa3\xc7\xe4\xe3\x2f\x4f\x84\xeb\xd7\xd5\x44\x7a\x9e\x84\x7e\xaa\xe4\xf4\xcb\xe6\x97\x79\x32\xe5\x09\xd6\xae\x0a\xeb\x53\xd8\x27\xc7\xbb\x37\xaa\xf6\xc3\xf1\xee\x81\x4f\xb0\xd6\x90\xd0\xa3\x87\x7c\x74\x4b\x85\x7a\xdc\x40\x27\x90\x61\x82\x39\x4e\xde\x82\x4c\x29\x7f\xeb\xd9\x7c\xe9\x79\x3b\x7f\xe1\xf9\xaf\x9d\x9d\xfc\x3d\xe7\x57\x9d\xf7\x9d\x0f\xc3\x4f\xf2\xfd\x17\x4d\xc9\x3c\xaf\xba\x9c\xd2\x3c\x4a\xd7\x52\x5a\x4c\xe9\x7a\x4a\xfd\x94\x96\x53\xba\x99\xd2\xb7\x29\x7d\x97\xd2\xf7\x28\xad\xa2\x74\x2f\x61\x3c\x40\xf9\x1a\xca\xf7\x18\xf9\xc8\x8a\x18\xba\x8e\x65\x75\x7c\x2d\x1e\x7d\xc0\xd0\xe2\x7d\xe3\xda\x3d\x3a\xad\xaa\xa5\xaf\x62\x35\xeb\x9a\x4b\x65\x5c\xc7\x67\xff\xff\xeb\xf8\xef\x74\x1d\x5f\xc5\x4f\xfc\x3c\x3a\xa7\x42\xad\x9f\x56\xa8\x3c\xbf\x42\xfd\xfd\xad\x66\x1f\x9d\x55\xa1\xf6\x5a\x5f\xcf\xb5\x15\x5a\xd5\x7f\xb5\x8f\x6e\xf1\x51\x5f\xbb\x7f\xac\x9f\x1e\xfd\xd0\xc7\xa7\xbb\x42\xab\x7a\xfa\xe5\x3c\x54\xa1\xf6\xbc\x0a\x95\x8f\xfb\xb0\x7c\x73\x97\xf3\xb9\xdc\xc3\x65\xe5\x1b\xfb\xb4\x8f\xfa\xf5\x16\x9e\x04\xf5\xe1\x56\xb5\xfb\xf8\x40\xc3\x73\xc6\xc9\x3f\x09\xfd\x54\xc9\xe9\x97\xed\xe9\xe3\xa3\xd0\xe4\xaa\x60\x79\xf2\xfb\xa4\x86\xfc\xc7\xde\x27\xde\xde\x98\xee\xa3\xde\x1c\xaf\x98\xec\xdc\x27\xda\x03\x13\xad\x7b\xd5\x1e\x38\xce\xb5\xf6\xcf\xa5\x4a\x0f\x3e\x39\xfd\xfc\xab\xf6\xf9\x78\x7a\x45\xa0\x3c\xf9\xeb\xf8\x0c\x67\xb3\xb3\xd5\x19\xab\xfa\x32\xff\xcb\x35\xbe\xc5\xff\x8e\xf3\xae\xf3\x91\x53\xf4\xbe\x84\x2a\x66\x88\xc9\x5c\xc1\x05\xae\xe0\x82\x62\x5e\xf3\xb5\x66\x41\x71\xaf\xa0\xc8\x57\x50\xec\x2b\x28\xfa\x15\xc2\xe8\xe5\x39\x4a\x2f\x52\x32\x6f\x06\xec\xa5\xfc\x4d\x4a\x46\x77\x47\x84\xb9\x34\x1b\x5f\x7b\x1a\xd1\x2f\x89\x4a\xb9\x16\x35\x47\x3f\xff\x31\x7d\x82\xfd\x45\x55\xff\x89\x5a\x62\x44\x3f\x32\xe5\xe2\xcb\xa6\xbd\xf8\xf3\x32\x1f\xc9\x31\x90\xc5\xf5\x18\xb7\x9d\x40\xd4\x76\xde\x27\xdb\x37\xc1\x73\x6d\xd1\x7c\x2c\xbb\x49\x1c\x6d\xe2\x78\x1e\xf3\x14\x01\x8e\x1f\x37\xb6\x36\xe2\xc7\xc8\xc8\x3b\x43\xf0\x9e\xb0\x78\x4f\xfc\x83\x4f\x5b\xc6\x1a\x88\x46\xc6\x8b\x21\xe3\x82\xb2\xfe\x4f\x3e\x8e\x9d\x59\xda\x97\x13\x69\x3d\x5a\x8b\xd7\xdf\x01\x6e\xcb\xc7\x8c\xfb\x5b\x95\xa0\xe6\x5a\xfe\x9f\x97\x60\x22\xdd\xdb\x42\x55\xed\xa2\xcf\x7d\xec\xee\x39\xf6\xb9\x65\x66\xa2\x30\x93\x8b\x27\xc9\x71\xa2\x75\xf3\x70\x3e\xa1\x8c\x13\xec\xf4\xdf\x41\xc6\x9a\x7a\xad\xc8\x78\xb1\xe8\xf1\xc9\x78\xe2\xef\xb8\x7e\x1f\xbf\x57\x26\xd2\xbb\x91\x60\xe1\xdf\x8a\x04\xb5\xf7\xca\xb1\x70\xff\xce\x66\x5e\x73\x35\xff\x0e\x66\x5e\x6b\xed\x71\x57\xf9\x81\xcf\xf8\x5d\xe5\x03\x1c\x6f\xf9\xe9\x1d\xbe\xf2\xa6\x71\x2d\xe3\xdb\x37\xf9\xe2\xb6\x03\xe3\xda\xfd\xfd\x37\x4d\x80\x75\xc7\x04\x2d\x9b\x26\xa0\x07\xc6\x95\xc7\xcb\x3c\x91\x3c\x77\xf8\x8e\xde\x31\xae\xe7\x44\xf4\xd8\x3a\x99\x48\x1b\xe3\x67\x31\x11\xcf\xf1\xb3\x5e\x5c\x7b\xa6\xc5\x4b\x2a\xd4\x37\x6a\xf2\xbe\xa4\x74\xb6\x39\xbb\x9c\x3d\xfc\xfe\x5f\x33\x5b\x12\x21\x66\x88\x1a\xf1\x38\xf6\xef\xfd\x9f\xed\xfd\xeb\xa4\xf9\x1e\xcf\x6d\xde\xdd\xa6\x4a\x59\xee\xf5\xee\x39\x31\xdd\x52\x69\xf1\xb7\xcb\xd3\x7d\xb4\xbf\x76\x1f\xf0\xdc\x3b\x01\xbd\x2d\x88\x28\xe7\x1b\x1a\xe2\x7b\x19\x0e\xaf\x52\xe9\x2e\x94\x8f\xee\xad\x94\xfd\xf2\xa3\xdd\x2f\x95\x8f\xa7\xc7\x2d\xb4\xa1\xc2\xdf\x5f\xf6\xf8\xf8\xe9\xe4\x75\x52\x43\x1b\x3e\xf4\x09\x35\x70\xcc\x59\x7b\xf7\xc9\xd0\xe7\xf4\x09\x66\x57\xa1\x93\xdf\xbf\xb6\xf3\xac\xf3\x3c\xbf\x8b\x1d\x15\xde\x3b\x43\x7f\xff\xf6\xec\x19\x1c\x81\x5e\xc8\x91\x63\x17\xd3\xc3\xdc\xf2\x38\x5b\xa8\x0d\x4c\x0f\x70\xcb\x87\x15\xea\xb5\x3b\xad\x95\xfe\xf6\x28\xb7\xa4\x2b\xd4\x1f\x99\xca\xbd\xa2\x1c\xf3\x3a\x3f\xe2\xf2\x6d\x3c\x6a\x37\x97\x4f\xf7\x45\xaf\x87\x83\x7c\x3c\xce\x7e\xea\x71\x03\xe2\x19\x41\x99\xc7\xcb\x33\x9e\x67\x0d\x7a\x46\x90\x4e\x5e\x27\x13\x6a\xe3\x8c\xa0\x06\xfc\x73\x9f\x70\xd6\x67\x54\x78\x42\x86\xc3\x3e\x8d\xf9\xf4\xe0\x21\x32\x3d\x9e\x3d\xfb\x8c\xf3\xdb\xea\x3d\x2b\xce\x12\xde\x3b\x77\x5e\xa4\x76\xbe\xcf\x3f\x39\xa9\x3c\xe2\xe3\x7d\x1e\x4b\x9c\xc8\x4f\xc7\x43\xa1\xba\x50\x24\xd4\x18\x6a\x0d\x4d\x0f\xff\x15\x3f\x0b\xdb\x11\x7e\x31\xfc\x52\xf8\x37\xe1\x5d\xe1\xdd\xe1\x3d\xe1\xfd\xe1\xb7\xcc\x33\x6f\x42\x93\xe2\x54\x71\x86\x38\xc7\x8c\xac\x81\x67\x39\xfb\x99\xee\xfd\x14\x38\xbf\xfb\x29\x73\xde\xff\xa9\x71\x7e\xe3\x53\xe3\xfc\xd6\xa7\xc6\xf9\xc0\xef\xc0\xd9\xec\xc4\x2f\x4c\xb0\x13\x3d\xbe\xc7\xcf\xd1\x93\xb4\xc4\xd1\x3c\xbf\xae\x63\x2f\xda\xf3\xa0\xdf\xad\x5a\xbf\xc9\xf6\xdf\x81\x55\x39\x3e\xfe\x93\xef\xef\xf1\x7f\x73\xd2\xfd\x9f\x39\xce\xfe\x5b\xb1\xf6\x93\xed\xbf\x17\x2b\x3a\xd9\xfe\xfb\x8f\xb3\xff\xd6\xe3\xec\xff\xcc\x71\xf6\xdf\x71\x9c\xfd\x5f\x3c\xce\xfe\xef\xfa\xfa\x7f\x81\xae\xac\x36\x9d\x19\x33\x31\xe2\x64\x1f\xc7\x5f\x8b\xd2\x5b\x15\x56\x68\xea\x24\x7b\x1f\x42\x6f\xab\xa5\x9f\xdf\x67\xce\x8b\x17\xd9\x6b\x88\x59\x17\x58\xd7\x5a\xfd\xd6\xb7\xad\x2d\x64\xf1\x95\x3d\x60\xdf\x6c\xdf\x6e\xaf\xa2\x74\xbf\x79\x26\x24\x67\xca\x33\xe5\x15\x72\xb9\xbc\x4b\xae\x91\xbb\xe5\x51\x67\x9a\x33\xdb\x49\x3b\x8f\x85\x66\x85\xce\x95\x33\x43\x8b\x43\x1b\x43\x5b\xea\x4e\xac\x9b\x59\x77\x79\xdd\x77\x43\x1b\xeb\xd6\xd7\x3d\x5f\xb7\x27\xb4\xb1\xbe\x95\xda\xe9\x7f\xfd\xf9\xf5\x57\xd4\x5f\x53\xbf\xa0\x7e\x4d\xfd\xce\x70\x32\xbc\x36\xfc\xd3\xf0\x96\xf0\x7b\x91\xe9\x91\xd9\x91\xf3\x22\x0b\x23\x77\x45\x0e\x46\xe7\x44\x1f\x69\xb8\xb0\xe1\xfa\x86\xef\x36\xdc\xdd\x70\x5f\xc3\x9a\x86\x9d\x8d\xcd\x8d\x17\x34\x5e\xde\x78\x57\xe3\x33\x8d\x1f\x36\xd5\x35\xcd\x6a\x3a\xbf\xa9\xa7\xe9\x9e\xa6\x07\x9a\x1e\x69\x7a\xba\xe9\x60\xb3\xd3\x3c\xbb\xb9\xbf\xf9\x7b\xcd\x1b\x9a\x9f\x68\xde\xde\xfc\x52\x8b\x68\x39\xb5\xe5\xac\x16\xdd\x72\x49\xcb\x35\x64\x85\xce\x28\xde\x29\x52\xc5\x1d\xe2\xbc\xe2\x0e\xf9\xe5\xe2\x9d\xb2\x8b\xd2\x57\x28\x5d\x4a\xe9\x2a\x6a\xfb\x06\xa5\x3f\x2c\x9a\x75\x9c\x56\xec\x16\x11\x21\xb9\x7f\xb7\xc8\x50\x3a\xb7\xb8\x81\xc6\x75\x8b\xab\xe9\xf8\x35\x94\xe6\x17\x77\xd4\xef\xa6\xba\x14\x2d\xc5\x53\xc4\x14\x4a\x86\x7b\x3d\x8d\xd9\xe0\x1b\xd3\xcd\x63\xe6\x17\x37\x50\xdf\x3b\x49\xb3\x92\x46\xb6\x1c\x3d\x2c\xa6\x50\x3a\x83\x8e\x38\x2c\x4f\x86\xd2\xb9\x9e\x5c\x62\xaa\xd7\x87\xf8\xb5\xd2\x08\xc3\xf7\x14\x4a\xa7\x32\xff\x6e\x11\xa3\x63\x5d\x54\xd6\x94\x2e\xa4\x74\x09\xa1\x5d\x4e\xf9\x95\x94\x5f\x45\xf9\x3c\xca\xaf\xa1\x71\xf3\x29\x35\x11\x97\x2e\x70\xe9\x22\x2e\x1b\x88\xcb\x06\xe6\xd2\x45\xe9\x42\x6a\xbf\x84\xb8\x5d\x4e\xb9\x19\x6d\x46\x92\x9c\xe4\x53\xb6\x50\x4b\x2b\x1d\x99\x42\xf9\x29\x94\x9f\x4a\xe9\x0c\x3a\xd2\x45\xe9\x42\x1e\xb1\x83\x46\xec\xa0\x11\x46\x0b\x6f\x8a\x96\xf2\xac\x5a\x09\xc7\xcc\xec\x14\x1a\x79\x6a\xf1\x9b\x3e\xac\x2e\x48\xda\x25\xbe\x4e\xf5\x2b\x28\x9f\x47\x7d\xae\xa6\x64\x8b\x8b\x8c\x26\xc5\x3f\x62\x4d\x1a\x59\xef\xa4\xda\x25\xd4\xde\x42\x3d\xa7\x50\xb2\x4b\xed\x22\x22\xbf\x5a\x7c\x56\x5e\x4e\xe9\xaa\x62\x37\xad\x56\xb7\x9c\x57\xfc\x05\xad\x58\xb7\xcc\xd1\xca\x15\x28\xdd\x68\x56\x8f\x8e\x3c\x26\xa6\xc9\x4e\xb1\x8e\x56\xb8\x9b\x56\xb8\x9b\xc6\xad\xa4\x55\xee\xa6\xb1\x2b\x69\xcc\x4a\xf9\x07\xc5\xfb\xe5\x02\xaa\x67\x8b\x1b\xe4\xa2\xa2\x96\x79\x2a\xdf\x40\xe5\x1e\xca\xfb\x28\x2d\xa3\xb6\x61\x4a\x2b\x28\xdd\x2c\x16\xca\x5b\x8a\xe4\xbd\x13\xdf\x6d\x84\xb6\x4d\x34\x98\x9d\x31\x19\x59\x78\x87\x84\x49\xfe\xd3\x48\xfe\xd3\x48\xa2\xd5\x24\x51\x17\x49\xd4\x45\xd2\x74\x11\xe2\x5a\xe2\x3e\x4f\xd4\x05\xf8\xfd\x31\xf3\x23\x5e\x22\x44\xfd\x77\x50\xff\x1d\xd4\xdf\xec\xcf\xc7\xa8\xf5\x31\xd1\x42\x7d\x7f\x42\x7d\x7f\x42\x98\x77\xca\x6b\x8b\xaf\xd2\x1c\x5e\x95\x4b\x28\x75\x53\xba\x9e\x52\x3f\xa5\x65\x94\x86\x29\xad\xa0\xf4\x4d\x4a\xb7\x50\xba\xb5\xf8\xea\x38\xb4\xee\x71\x68\xcf\x56\xa1\xd5\x61\x7d\x8f\xd0\xda\x1e\x29\x6b\xf4\x52\xb3\x32\x72\x80\xf4\xb8\xbc\x78\xbf\xb9\x03\xc5\xbb\x96\xe7\x49\xeb\x7f\x1a\xad\xbf\x99\xef\xa8\x6f\x05\x76\x60\x05\x76\x90\xd4\x3b\x68\x05\x76\x90\xe4\xa7\xc9\xeb\x28\x2d\x2c\x5e\x4a\x33\x38\x8d\x34\x77\xa9\x5c\x4a\x79\xbe\x78\x3d\xaf\x46\x1f\xe5\x05\x92\x75\x19\xb5\x0d\x53\x1a\x29\xce\xa5\xd9\x9c\x46\x9a\xbd\x53\xde\x44\xc7\x6e\x26\xfe\xdf\xa2\x31\xb7\x50\xdb\x1f\x15\x2f\x15\x9f\x2f\x4b\xda\x4a\xeb\x45\xd2\x62\x27\xde\x19\x90\xe4\xd8\x7b\x21\x47\xf5\x63\xef\x87\x1b\x79\x3f\x48\xe2\xf8\x8b\xb2\x96\xa2\x34\x9b\xf5\x34\x7e\x3d\xad\xc3\x7a\x5a\x83\xbf\xa6\x31\xeb\x69\xcc\x7a\x1a\xb3\x9e\xf4\xbf\x9e\xc6\xac\x27\xfd\xaf\x17\x9f\x33\x52\xfe\xad\xef\x4e\x47\xf6\x12\xe6\x40\xf1\x15\x5a\x8f\x57\x48\x43\x9b\xc5\x54\x92\x68\x84\xf8\xec\x20\x1e\x23\x34\xab\x75\x24\xd9\x06\xe2\xb5\x83\xa4\xbb\x9f\xf8\xed\x20\x7e\x66\xa7\xae\x23\x7e\x23\x34\x72\x1d\xf1\x1c\xa1\xd1\xeb\x88\xef\x08\x49\x3c\x42\x7c\x47\x48\xe2\x11\x3a\xa3\x88\xb7\x68\x3a\xe6\x4e\x1b\x9a\x60\xb7\x99\x51\xbb\x68\xd4\x2e\x1a\xb5\x8b\x7a\xef\xa2\xde\xbb\xa8\xf7\x36\xea\xbd\x8b\x56\xf4\x29\x1a\xb1\x83\x46\xec\xa2\x11\xbb\x68\x15\x9f\xa2\x51\xbb\x58\x9b\x9b\x69\xd4\x66\x1a\xb5\x99\xb0\x36\xd3\xc8\xcd\x34\x72\x33\x8d\xdc\x4c\x23\x37\xd3\xa8\xcd\x34\x62\x33\x5d\x13\xae\xa5\xf9\x2e\xa2\xd4\x4d\x69\x19\xa5\x21\x4a\xc3\x94\x56\x50\xfa\x26\xa5\x5b\x8b\xaf\xd0\x5a\xf9\xb4\xc3\xdc\xbd\x31\x4b\x3e\x66\x5c\xc3\x38\x39\x82\x32\x7c\xd3\x93\x83\x7a\x6f\x16\x21\x3a\x03\xea\xe8\x0c\xa8\x13\xbd\xa4\xb5\x6f\x15\x47\xea\x7f\x53\x1c\x13\x16\x5d\x05\x16\x30\x1d\x11\x53\xe4\x2f\x44\x97\xdc\x54\xdc\x27\xb7\x88\x2f\xc9\xa7\x8a\x63\xf2\x69\x2a\x3f\x43\xf9\x58\x71\x81\xdc\x5e\x5c\x23\x9f\x2d\x8e\xca\xe7\xa9\xfc\x12\xb5\xed\x12\x27\xc9\x77\x28\x3f\x44\x7d\xde\xa5\xf2\x51\xf1\x25\xe2\xb2\x52\x34\xcb\x9f\x50\xab\xe1\xf2\x14\x8f\xde\x47\xa3\x57\xd3\xe8\x6d\x34\x7a\x9f\x7c\x8e\x8e\x3d\x4f\xf5\x1d\xc4\xe9\x25\xaa\xef\xa4\xb4\x9f\xd2\x21\x92\xe5\x73\x34\x72\x54\xfe\x82\x7a\x3c\xc9\x1c\x46\xe5\x16\xe6\x32\x4a\x5c\x46\x89\xcb\x08\x71\x19\x65\x19\x9e\x23\x59\x3c\x2e\x2b\x89\xc3\xa8\xfc\x2d\xf5\x7b\x83\xd2\x3b\x54\x36\xf2\xbc\x47\xe9\x70\x71\xd4\x11\xc5\x7d\xe4\x57\x04\xe6\x4d\x28\x23\x84\x32\x42\x08\x63\x84\xb0\x52\xfe\x92\x64\x7b\x8a\xf2\x67\x88\xa3\xe1\xb6\x8b\xca\xaf\x50\xfa\x2d\xf5\xd9\x43\x69\x1f\x95\xf7\x53\x7a\x83\xd2\x9b\x94\xde\xa2\xb6\xb7\x29\x3f\x44\xf9\x87\x94\x7f\x44\xa9\x58\x5c\x49\x68\x9e\x4e\xeb\xe4\x76\xd2\xc7\xb3\x3c\xd3\x8d\x14\x01\x77\xc9\xb7\xa8\x7e\x48\x7c\x89\xae\x49\x06\xf3\x20\x49\x15\x85\x86\xc6\x3c\x0d\xd1\xf1\xed\xa4\xf3\x1d\x94\x8c\x5e\xf7\xd0\xfe\x7c\x8b\xb5\xb2\x4f\x84\xa1\x85\x92\x2e\xc7\x48\x0b\xfb\x58\x97\xcf\x53\x99\xf4\x47\x57\x46\xbf\xb6\x3d\xec\x8d\xb4\xab\x4c\x9f\x97\x19\xf9\x24\xda\x89\xde\x88\x7d\x1e\x7f\x4a\x46\xa6\x83\xde\x51\xd2\xd5\x3e\x5a\xbf\x93\x68\x47\x99\xb5\x2b\xad\x80\xc1\xdd\x4e\xf9\x73\xa4\x17\x0f\x6b\x8c\x74\x32\xc6\xeb\x45\x1a\x26\x4f\xb0\xe5\xe8\xb7\xe8\x4a\xf6\x2d\xba\x92\x8d\xd1\x95\x6c\x8c\xb4\xbb\xb2\xac\xdd\x27\xa9\x57\x45\xc3\xbe\xb9\xf2\x6e\x18\xc3\x6e\x58\xcd\x5c\x77\xf1\x1a\x2e\xa0\x79\xaf\xa1\x79\xaf\x91\x47\x8b\x63\xa4\xcd\x51\xb2\x25\x25\x79\x78\x57\x52\xaf\x12\xa7\x31\x2a\x6f\xe7\x9d\xb0\x92\x64\x1b\xa5\x9d\xb0\x91\xf7\x93\x99\xdd\xab\xa4\x45\x9a\x91\x38\xad\xec\xfd\xf4\x16\xd7\x90\x6c\x6b\xb0\xbf\x46\xe5\x93\xd4\xcb\xe3\x38\x46\xdc\x56\xf3\x9e\xf2\xe4\x58\x4d\x2b\xbf\x86\xe4\x58\x49\xab\xbe\x46\xbe\x4e\x69\x3f\xb5\xbd\xc1\x72\x2d\x90\x07\x28\x37\x2b\x7f\x90\x57\x7f\x25\x69\x61\x8d\x3c\x42\xe9\x43\x4a\x1f\x51\x2a\x16\xd7\x90\xdc\x2b\x79\x17\x9c\x49\xda\x39\x40\xda\x39\x50\xd6\x8e\x27\xc5\x6a\x68\x68\x35\xb4\x33\xca\x3b\xfc\x59\x3e\x1f\x3c\x1d\xbf\x4c\xc9\xec\xbf\xdd\xd4\xc7\xd3\xca\x88\x7c\x95\x8e\xef\x65\xa9\x56\xcb\xd7\xa8\xfc\x3a\xe5\xfb\xa9\xfd\x0d\xca\xdf\xa4\x64\xf6\xe4\x01\xca\xdf\xa6\x74\x90\xca\xef\x51\xfe\x3e\xa5\x0f\x28\x1d\xa1\x54\x2c\xae\xc6\xfe\x34\x3b\xca\xd3\xea\x28\xa3\x8f\x11\xd7\xed\xe5\x15\xde\x48\x5c\x47\x45\x3d\xcb\x56\x3a\xf3\x3c\xd9\x36\x62\x47\x8e\xd1\x2e\x7e\x8a\xcf\x7f\xb3\x9f\x77\x95\x77\x36\x9d\x39\x7c\x15\x69\xf6\xed\xa1\x51\x68\x79\x23\xad\xdb\x18\x76\x80\x59\xbb\x38\xf6\xd4\x02\x5c\x03\x56\xf3\x55\xa8\xc1\x5b\x1b\xda\xfb\xa5\xd5\x7e\x8e\x46\x7a\xbb\x6e\x94\x56\xf5\x24\x23\x9b\x39\xcf\xf9\xbc\x6e\xc4\x6a\xae\xc1\x5e\x5d\xed\x3b\x47\x56\x82\xbf\xd9\x55\xab\xb1\x82\xfb\xc8\x0a\xed\xe5\x6b\x84\x77\xcd\x3a\x4c\x33\x69\xa1\x15\xdf\xc6\x7d\xf6\x50\xcb\xab\x94\xf6\xf2\xfe\x36\xfd\xf9\x3c\x35\xf3\x95\xef\xf2\x7e\x1f\x35\x57\x14\xf9\x37\x94\x8e\xb2\x04\x63\xa2\x95\x46\xd3\x19\x46\xc9\x5c\x7f\x2a\x1c\xcc\x15\x6d\x1b\x5f\x8f\x8c\xc6\x0e\x96\x31\x3d\x4e\x87\x89\xfb\xdf\xe0\xda\x14\x2d\x5d\x9b\x88\xd3\x18\xe4\x18\x03\x87\x31\x1a\x6d\x64\x18\xe3\x9e\x36\x8d\x19\xe3\x73\x34\x02\xc4\x31\x9f\xbc\xa3\xbe\x2b\xdf\x98\x91\x93\xe6\xfa\xb2\xef\xdc\xfe\x1b\x5a\xa1\x86\xf2\xb8\x3d\x65\x29\x2b\x12\xf2\x55\xdc\xbb\x6a\x1a\x24\xba\x3e\xd1\xfa\x12\x8f\x2f\xf1\xb5\x62\xaf\xd1\xbd\xef\x9a\xf1\x0e\x78\x1b\x79\x6c\x6e\x35\xda\x94\x8c\x60\x38\x9b\x2b\x4e\xd8\x27\xa3\x37\x9f\x92\xe6\xdf\x83\xf6\x4d\x8f\x6d\x38\xba\x31\x78\x94\x67\xed\xf0\xaa\xbf\xe5\xbb\x42\x45\x4b\xe7\x34\xeb\xde\xec\x0b\xd6\x3b\x5d\x63\x3d\x8d\x61\x36\xd4\xb3\x95\x7a\xc6\xa9\x67\x5c\x7c\x8b\xc6\xef\xc2\xb5\xb0\x32\xe2\x24\x1e\xe1\xad\xd2\xab\x74\xde\x78\x23\x8d\x0e\x8e\x62\x87\xd5\x97\x35\xe6\x97\xbe\x24\x5b\xa4\xbc\xfa\x25\x7d\x56\x56\xbb\xa4\xcb\x31\x9a\x41\xe0\x28\x69\x69\x0f\x6a\x87\x58\x7b\xef\xd0\x59\x70\x98\xce\x1b\x4f\x5f\xac\xed\xd2\xfa\xc3\xc2\xbe\x57\x96\xa7\xa4\xd1\x92\xe4\x38\xca\x48\x76\x79\xbe\xf5\x65\x8b\x57\xb9\xf2\x2c\xa0\x2b\xcf\x02\x58\xfc\x57\xc8\x0f\x95\x1c\x0b\x5e\xc5\x51\xc0\x0e\xb2\x20\x7f\x4e\x52\x8c\x52\x32\x96\xde\xbb\x9e\x8e\x52\xa4\x99\xa7\x7e\xd3\x28\xfe\x3f\x5b\xfc\x63\x11\x17\x09\x91\x12\x19\x71\xae\x38\x4f\x5c\x24\xae\x14\x57\x8b\x6b\xc4\x7c\xf9\x65\x79\x81\x6c\x97\x1d\xb2\x4b\x6a\xf9\x15\xf9\x55\xf9\x35\x79\xa9\xbc\x9c\xa2\xee\x2b\xe5\x55\xf2\x1b\x72\x9e\xbc\x46\xfe\x81\xfc\x43\xb9\x44\x76\xcb\xeb\x65\x8f\xec\x95\xfd\x72\x99\x1c\x90\x83\x14\x95\xaf\x90\x37\xca\x6f\xca\x5b\xe4\xad\xfc\xbe\xe5\x5f\xc8\x9f\xc8\x9f\xca\x9f\xc9\x9f\xcb\x5f\xc8\x27\xe4\x93\x72\x93\xfc\x2b\xb9\x45\xfe\x52\x3e\x25\xb7\xc9\x67\x24\xd9\x3c\xf9\xac\x7c\x4e\xfe\x4a\xbe\x20\x77\xc8\x5f\xcb\x97\xe4\x6f\xe4\x2e\xf9\xb2\x7c\x85\xe2\xfa\xdf\xca\x3d\xf2\x55\xb9\x57\xbe\x2e\xf7\xcb\x37\xe4\x5b\xf2\x6d\x79\x50\xbe\x23\x0f\xc9\x77\xe5\x7b\xf2\x7d\x79\x44\x7e\x24\x8f\xca\xa2\xd3\xe2\xb4\xd7\xbf\x52\xbf\xbb\x7e\x1f\xcd\x2a\x4a\xbe\xd0\xc9\x44\x71\x27\xe2\xef\xc9\x13\x8b\x05\xe6\xed\x5b\xf9\x43\x43\xed\x5b\xb9\xfc\x38\xd3\xbd\xfc\xdb\xa3\x43\xdc\x3e\x93\xdf\xd0\x4d\x57\xa8\xd7\x2e\xfb\x83\xd4\xf9\x51\x85\x62\xec\xed\xbe\x76\x8f\xc3\x25\x15\x2a\xb7\x57\xa8\x77\x54\xce\x37\x34\x34\xb7\x32\x6a\x3c\x8a\x27\x1b\x10\x17\x04\x65\x1e\x2f\x8f\xc7\xd3\x2b\xd7\xad\xae\xf0\xf7\x97\x3d\x3e\x7e\x3a\x29\x9d\xdc\xf7\xf1\xda\xa8\xd2\xc0\xb8\xb9\x4f\x34\x6b\x7b\x15\xb7\x7f\xe8\xeb\x79\xc9\x04\xda\xe8\x3f\xae\xdf\x1e\x95\xde\x8f\xf1\x3f\x65\x2b\xff\x8e\x09\x7b\x76\xcb\x67\x7b\xcf\xe2\x4d\xce\x33\xf9\x79\x10\xbf\xb3\xea\x7f\x5b\xd5\xff\x86\xaa\xff\xed\x65\xb1\x89\xdb\xfd\xef\xa3\x8e\x7f\x07\xf5\xc7\x4c\xfd\xef\xa0\x7a\x3c\x1f\xf1\x3d\x5d\xf2\xd3\x1e\xdf\x53\x24\xdf\x5b\xa6\xfe\x77\x59\xc1\x6d\x9e\xaf\xbc\x6a\x9c\xcc\xe3\xe5\x19\xf5\xf5\x9c\xe0\x2d\x5f\xef\x09\x1a\x9e\xd3\xf9\x78\x7e\x8c\x4e\xfc\x6f\x71\x4f\xa0\x0d\xbf\x06\x6a\xcc\x7d\xa2\x59\xfb\xde\xa7\xf5\xbf\x43\x5b\xe3\x5d\xd9\xe3\x7b\x4b\xf6\x77\x79\xa7\xe7\x64\x42\x58\x42\xc9\xc8\x3a\x20\xcc\xdf\x15\x13\xe2\x16\x4a\xe6\xb9\xdf\xed\x94\xee\xa2\x74\x0f\xa5\xfb\x28\x3d\x48\xc9\xcc\xd5\xcc\xd4\x3c\x29\xdc\x48\xc9\x68\xf5\x09\x4a\x66\x1e\xcf\x50\x7a\x9e\xd2\x4b\x94\xcc\x33\xd6\xd7\x28\x99\x27\x96\xef\x09\xab\x98\xe6\xb7\x52\x27\x41\x8f\x3e\x3a\xae\xbd\xf5\x13\x51\xef\xbe\x36\xd1\xa3\x8f\x33\xff\x1f\x32\xdd\x6e\x28\xce\xe3\x47\x3f\xeb\xe7\x71\xe5\x2d\x04\xef\x4d\x05\xfc\x86\x88\x7f\x29\x83\xdf\x04\xf1\xdb\x06\xa5\xdf\x0a\xf9\xda\xef\xaa\x50\x7b\x6d\xe5\xa8\xf7\xee\x05\xfa\xf0\x2f\x83\xf0\x9b\xa0\x79\xe3\x68\xd8\x47\xe7\xf8\xb0\x46\x7d\x88\xe1\x71\xd4\x3f\x76\x55\x65\x2c\x64\xdb\xe2\x93\x67\xed\x38\xf9\x47\x2b\xef\x46\x54\x95\x57\x8d\x9b\xe3\xa4\x75\x32\x91\x36\xa0\x87\x89\x34\x70\xcc\x59\x8b\x0d\xbe\xb7\x49\x66\x8d\xd3\xf3\xda\x00\xe2\xe4\xcf\xe3\x63\xbf\x69\x69\xae\x1e\xe7\x52\xba\x40\x1c\xef\xef\x96\x2c\x6b\x27\xcb\xbd\xc9\x27\xf1\xf8\x16\xff\x7c\x0e\x55\x8e\xd6\x7c\x0b\xad\xef\xef\x99\x2d\xf4\x5f\xf7\x5f\x18\x67\x87\xc6\xd9\x42\xeb\x66\x2e\xcf\x3c\x96\x2d\x14\x77\xd4\xb6\x85\x55\xbf\x8b\x98\x55\x29\xf3\xaf\x0d\x6a\x59\xaf\x89\x7e\x45\xe3\xff\xe5\xcc\x0b\xc7\xb4\x85\x7e\xf4\x71\xef\xaf\x78\xb4\xea\x97\x1b\x93\xd7\xc9\x24\xb4\x51\xa5\x81\x71\x1e\xc0\x44\xb3\xc6\xa8\x63\xda\x42\x0f\x91\xe9\xff\x15\xb6\x90\xce\x87\x69\xa5\x7d\x43\x63\xa7\x95\x5b\xbc\xf2\x03\x4c\x37\x55\xb4\x53\xd5\x87\x8f\x5a\x17\x30\x9d\x55\xa1\xc4\xcd\xd0\x03\x3e\xba\xa9\x42\x2d\x87\xcb\x2b\x7c\xeb\x77\xb3\x8f\x03\x97\xcd\xdf\x56\x22\xbe\x95\x77\x75\x4c\x5b\xdd\x47\xbb\x4b\xff\x8f\xf6\xd7\x78\xf2\x6c\xfa\x98\xff\x8d\xfc\xb4\x78\x53\x31\x8d\xa7\xc7\x6c\x6f\x0d\xd9\xf2\xfb\x0f\x3e\x65\xf2\x4d\x17\x7c\x70\x2f\xd7\xff\xe4\xcd\x7d\xff\x3b\x00\x00\xff\xff\x62\xa3\x61\xd4\xf8\x57\x05\x00") + +func liberationsansRegularTtfBytes() ([]byte, error) { + return bindataRead( + _liberationsansRegularTtf, + "LiberationSans-Regular.ttf", + ) +} + +func liberationsansRegularTtf() (*asset, error) { + bytes, err := liberationsansRegularTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationSans-Regular.ttf", size: 350200, mode: os.FileMode(420), modTime: time.Unix(1459927769, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationserifBoldTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xfd\x77\x60\x55\x55\xd6\xff\x8f\xaf\x7d\xce\xb9\xf7\x26\x81\xf4\x40\x02\x29\xf7\xa6\x41\x20\x40\x42\x42\x0b\x2d\x17\x48\x42\xe8\x01\x02\xa4\x50\x02\x04\xa4\x0a\x1a\x44\x04\x14\x2c\x20\x62\x01\x3b\x2a\x2a\x33\xc3\x28\x56\x82\xa2\xa2\x22\xa2\x32\x76\x66\xb0\x80\xa8\xd8\x40\x89\x1d\x66\xac\xb4\x7b\x7f\xaf\x7d\xee\x4d\x0c\x8c\xce\xcc\xef\xf9\xfc\xf9\xcd\x33\x8b\x7d\xce\xda\x6b\xaf\xf2\x5e\x6b\xb7\x13\xe4\x11\x25\x22\xb1\xfc\x61\x49\x6e\x49\x49\xf9\x88\x09\xdf\x18\x9f\x89\xe3\xa6\x24\xb8\x49\x83\x8b\x8a\x4b\x2e\x7d\x63\x51\xa8\x38\x8a\x67\xf1\xbe\x66\x70\xd9\xa8\xb1\xd6\xe7\x63\x3a\x8b\x63\xe4\x6e\x91\x41\x55\x83\xc7\x8e\x1b\x38\xe2\xd5\x4e\x31\xf4\x1f\x17\x09\xd9\x37\x6a\x6c\x4e\x9e\xcb\x78\x75\xa7\x88\xda\x81\x7c\xcd\xf4\xf9\x53\x17\xa6\xae\x2d\x7e\x56\xa4\x63\x85\x88\xb3\xc7\xf4\xc5\x8b\x3c\x35\x97\x8e\x5a\x22\xd2\x67\xbd\x88\x71\x70\xe6\xc2\xf3\xe6\x5f\x36\xf5\xc9\x68\x91\x5c\xde\x5d\xdb\xcf\x9b\x5a\xb7\x50\xe2\x44\xdb\x43\x5e\xa2\xce\x9b\x77\xc9\xcc\x37\xa7\x0f\x79\x46\x64\xe6\xc3\x62\x4d\x98\x35\x6b\xc6\xd4\x5a\xd9\xbd\xaa\x2b\xfa\xfb\xd2\xdf\x43\x33\xc2\x0f\x47\x8c\xe1\x7d\x11\xef\x19\xb3\xe6\x2f\x5a\xf2\xe3\xeb\xfb\xef\x42\x77\x82\x48\x96\x77\xee\x8c\x0b\xcf\xef\xe7\x4f\x5d\x27\xd6\xae\x38\x91\xb8\x8a\x79\x0b\xa6\x4f\x8d\x6f\x78\x60\xa5\x48\x7f\xe2\xc9\x2a\x9a\x3f\x75\xc9\xc2\xf0\x22\xab\x33\xe3\x37\x30\xde\x73\xfe\xd4\xf9\x33\x1e\x5f\xd8\xb9\xa3\x58\x6f\xcf\x13\x69\xb1\x63\xe1\x82\xba\x45\xdf\xbd\x97\x71\xbf\x58\x1f\x67\x88\x9c\x97\xb7\xf0\xc2\x19\x0b\xe3\xb7\xe4\xf5\x10\xe9\x55\x24\x62\x0e\xb1\xb1\x33\x44\x8a\xea\x4e\xfd\x34\x25\xb2\xef\x4f\x86\x3b\x44\xf4\xcf\x9b\x37\x27\x97\x36\xb6\xa7\xee\x3b\x73\x73\xd8\x0b\x21\x51\xc8\xea\x4e\x65\x0b\xf0\xa7\x2b\xd5\x57\x2c\x13\x5a\x24\x9f\xba\xef\xe4\x27\x61\x2f\x04\xf9\x4d\x3f\x61\x5a\x9e\x3f\xd5\x18\x29\x97\xf5\xe2\xc4\x4a\x94\xe4\xc8\x44\xcc\xcd\x31\xda\x88\x49\xaf\x69\xdd\x63\xec\x14\x87\x88\xe3\x4e\x47\x3e\x2a\x33\x03\xad\xb9\x49\x66\x1a\x31\xca\x61\x18\x21\xa6\xcb\xe1\x30\x4c\xeb\x53\x09\xf3\x97\xc9\x12\x3f\x6a\x53\xb5\xee\xae\x03\xc6\x0e\x12\x8f\x78\xfc\xa7\x1d\x73\x7d\x25\x2a\xdf\x95\xaa\x9e\xad\x11\xf5\xfc\x27\xbf\x30\xfa\x61\x47\x3f\x8d\x84\x44\x38\x0b\x02\x9e\x18\x8d\xf4\xa0\x3c\x6a\x5d\x20\x47\x2c\x91\x44\x68\x08\xc1\xbc\xed\x7c\x50\x16\x1b\x05\xb2\x91\xbe\x2a\x68\x20\xfc\x71\xd6\x3a\x99\x87\x7c\x22\xef\xc3\x68\xab\x8c\x02\xff\xb7\xf0\x47\x42\x9b\xa1\xf1\xd0\x08\x28\x09\x1a\x03\x95\x40\x17\x41\x45\x50\x2f\xc6\x6c\x81\xe6\xa0\x63\x66\x90\x66\xc1\x5f\xee\xba\x40\xe6\x3a\x5e\x91\x38\xc7\x78\x49\xa3\xad\x85\x32\x78\x4e\xb7\x8e\x48\x3a\x7e\xd6\x42\xe9\x66\xb2\x14\x23\x5b\xad\x9f\x75\x9f\xeb\x7a\xda\x57\xa4\xbd\xee\x6f\x94\xe3\x3d\xdd\xaa\x93\xf9\xf4\x7b\x78\xce\x87\xe2\x89\x23\x99\xb6\x5d\x50\xe7\x34\xec\x6f\xd0\x3e\xd3\x0e\xb5\xee\x93\xa5\x96\xf8\x8f\xf3\x5c\x81\xee\x81\x8c\x6d\x6b\x5e\x8f\xcf\x75\x32\x56\xb7\xf0\x23\xe1\xf7\xe0\x3d\x1f\x1c\x3a\x1b\x0f\xfa\x8f\x05\x9f\xb3\xc0\xa6\x27\xcf\x3d\xed\xd8\x19\x07\x95\x33\xa6\x27\x7e\xf6\x67\x5c\x2a\xef\x6e\xfa\x04\xbb\x4e\xda\x10\x28\x8e\xfe\x2c\xb3\xbd\x0c\x54\x2f\xc9\x9d\xb4\x65\x56\x07\x89\x6a\xc2\x5e\xa4\x32\x88\x59\x39\x64\x68\x19\xda\x2b\xe8\xeb\xee\x38\x29\x15\xc6\x4c\x1b\x53\x1b\x3b\x8d\xbd\xe6\xe1\xfb\x31\x33\x5f\xa6\x59\xb5\x32\x9e\xfe\x5e\x10\x3e\xca\x8d\xd6\x46\x70\x18\x23\x53\x8d\x87\x64\x2b\xef\xcb\xe0\x0f\x37\x36\x4b\x81\xf6\xd5\x49\x8e\xa0\x51\x50\x8d\xc6\xde\xc6\xfd\x77\x08\xdc\x22\xec\x5c\x8c\x0f\xe0\xdd\x48\x3a\x0f\xcd\x29\x88\x73\xfb\x60\x9e\xce\x22\x7c\xdd\x10\xcc\x4b\xfe\x39\x94\x41\xce\xb2\xc1\x28\xdb\xc6\xfd\x77\x08\x99\x81\x3a\x07\xe7\x12\xb9\xfb\xd1\xce\x45\x81\xff\x10\xad\x19\xc4\xbf\x67\xb0\x06\xcf\xa6\x5a\xbb\x1e\x4b\xec\x5c\x34\x27\x72\x41\x1b\xa1\x5b\x1d\x6b\xd0\xde\xb9\x6d\xad\xb6\xf7\x1f\xda\x0c\xc7\xc7\x32\x56\xc7\xa3\xeb\xc5\xc6\x46\xf3\xff\x4b\x6b\xe3\x42\x4d\xfd\x87\x56\xd7\x70\x7e\xb0\x35\xc0\xb8\x2f\xb1\xee\xd5\x58\xd3\x7e\x1e\x6c\x7f\x0c\xb4\xd2\xb9\xb1\x75\xde\xca\xfc\x98\x2b\x9d\xf5\x1c\xd1\x75\xda\xa8\x47\x93\xb6\xad\x6b\xb6\x79\x6b\xee\x0e\xb6\x1d\x25\x3b\xc8\xd7\x58\xb4\xd7\x58\xfe\x5b\xbb\x5f\xc2\x9d\xed\x25\x4b\x3f\x07\xfd\x1c\x79\x6e\x4b\xbd\x5c\x80\x7c\xae\x9e\x83\x7a\x1e\x9c\xdb\xea\x79\xa9\xe7\xc6\x1f\xb5\x7a\xce\xea\x79\xa3\x5b\x2b\x3b\xd0\xda\xef\x01\x7c\xdd\xff\x6b\x1b\x9c\xef\x4e\xbb\xc6\x02\xf9\xb5\xe7\xbd\x9e\x7b\xe7\xb6\xc4\xec\x62\x4c\xb8\x33\x8c\x79\x3a\xd4\xc6\x6b\x69\xb0\xd5\xf3\x76\x63\xb3\x5c\xe7\x3b\xd7\xd8\x32\xe3\x74\xae\xad\xf6\xd2\x17\x1d\xb3\x1d\x5f\x49\x5f\xab\x80\x75\xe4\x88\x5f\xaf\x1f\xb7\x04\x6b\x3d\xde\x39\x80\x35\x62\x91\x74\xd1\xb9\x09\xe6\xa1\x37\xb6\xe2\xcd\xef\x25\xc6\xb5\x5a\xda\x38\x5e\xf1\x4f\x6f\xc4\xd2\xc6\xef\x7c\xf0\xab\x93\xa1\xce\x8e\x32\xd2\x71\x03\x5b\x75\x1d\x6b\xf0\x11\x7b\xdc\x04\x74\xe4\x39\xfa\xc8\x20\xab\xad\x74\x09\xe2\x23\x8d\x38\x39\x27\x13\xf3\x5e\x71\x3b\x67\xc9\x24\x47\x4f\x7c\x1c\x1b\x8c\x39\x18\x9f\x75\xbf\x74\x82\x86\x98\x0f\x49\x11\xfb\x46\x91\xbd\x3e\x87\x4a\x07\x33\x4e\x0c\x74\xb4\xb0\xfe\x26\x83\x59\x67\x6e\x34\x36\xc8\x7c\xa3\xaf\x84\xeb\x75\xa8\x45\xb2\x64\x84\x96\x4b\x06\x38\x8e\x0d\xa5\x2e\x68\xf5\x3a\x9c\x15\x4a\x2d\x84\x5c\x20\xed\x5d\xc9\x76\x4e\xed\x39\x12\xac\xc5\x23\x8d\x35\xf0\xbf\xe6\x28\x88\xe9\x59\xf3\x2d\xb8\xde\x0c\x0c\xea\x92\xdf\x99\x0f\x67\xd5\x9b\x8e\x8d\xb8\x52\x75\xad\x37\xf7\xb9\x71\x9c\xeb\x25\xd6\xab\x8e\x81\x3d\x22\x58\xcb\xbf\x67\xa7\xd1\x8f\xa4\x26\x7f\x02\xf3\xd4\x6a\x9c\xaf\x66\xb2\x7f\x2b\x31\x76\x0d\xc6\xfa\x4d\x70\x5c\x68\xb3\x98\x91\xf3\xbf\xd7\xac\xde\xcf\x8a\xf5\xdc\xfa\x26\xd7\x03\x0c\x9f\x14\x34\xc6\xe5\xf8\xc4\x6e\xc7\x3a\x66\x33\x7f\x4d\xf4\x35\xd6\xe8\xd9\xfe\x94\xfc\xd1\xbc\x6b\xe6\x87\x9d\x7b\xea\x2c\x44\xc7\x6b\x1c\x91\xd6\xf6\x3a\x70\x2b\x75\x76\xab\xf4\x0a\xae\xeb\x5a\xb6\x32\xb8\x96\x7b\xb4\x5f\x76\x9d\x0c\x94\x3b\xcc\x67\xa4\x1f\x3c\xdb\x6f\xc7\x4e\x69\xd9\x68\xb7\x69\x3d\xb9\x43\x86\xa0\x37\xa7\x59\x9c\xb6\x3d\xc8\x6d\xdd\xc1\x9c\xb8\x43\xba\xe8\xf9\x43\x5f\x3e\x34\xc0\x9e\x27\x81\x7d\xb4\xbb\x26\x87\x25\x83\xcd\xb9\xd8\x9b\x2b\x69\xd6\x2e\x49\x33\xb7\x48\x11\x7a\xdd\xd6\x6c\xe4\x34\x3d\x2b\x17\xe8\xbc\x5b\x19\xd4\x6c\x00\x37\x7b\x7f\x25\x1e\x31\x96\xb1\xde\x8f\xd0\xcf\xfe\xbd\xf6\x7b\x01\xb6\x3e\x0c\xec\xc1\x8d\x64\xd5\xf9\xaf\xb0\xc7\xe4\x82\xb1\xc6\x25\x16\x4c\xde\xb7\xd7\xe7\x61\xd8\xef\xdc\x8c\x7a\xda\xd4\x5d\x72\xa1\xcb\xf0\xbb\x40\x93\xbd\x6f\xcf\xf5\xdf\x84\x4f\xdb\x8d\x7f\xf8\x7f\x36\x6e\xf0\xed\xd2\xf9\x6a\xda\xcb\x8f\xb3\xdf\xe6\xda\x7b\x47\x48\x70\x4f\x6f\x65\x15\x05\xf6\x74\x2b\x91\x7d\x9d\x5a\x84\x34\x9e\x43\x9a\xe8\x54\x30\x6f\x63\xc0\x80\x78\xed\x18\x37\x4a\x0f\x6c\x9c\x87\xbf\x27\xad\x08\xd6\x8e\xc0\xb9\x21\x43\x93\xf3\x08\xf5\x7b\x52\xc6\x72\x1e\x1a\xeb\xc8\xc1\xee\x30\xe6\xf9\x03\x92\xea\x7c\x83\x73\xc8\x09\xec\xec\x81\xda\x80\xdd\xfb\xac\x3f\xe3\xa4\x9b\x26\xe3\x4e\xce\x10\x77\x4a\x8c\xba\xd0\xdf\x60\x84\x4a\x0c\xd4\xd2\x48\x85\x5e\x93\x58\xf3\x22\xb1\x8c\x5a\x69\x61\x78\xe5\x6a\xf3\x57\x79\x93\x58\xfe\x04\xad\x80\x6e\x86\xfe\x69\x93\x29\xc9\x9a\x9a\xce\x63\xeb\x58\x93\xd7\xd9\x67\x98\x98\x00\xa9\x14\x5a\x7d\xde\xbb\x51\x9f\x93\x9a\xbd\x4f\xb3\xa9\x40\x1e\xb1\xa9\x51\xdf\x83\xb2\x36\x48\xb7\x07\xe5\xda\x43\xcf\x41\x57\x42\x0b\x20\x8b\xf8\x8f\xe8\x9a\x32\x23\x24\xc7\x98\xc1\xd9\x76\xae\xa4\xaa\xe7\xa8\xd7\xa1\xe0\x8e\x2f\x66\x94\xdc\x76\x2e\x35\xd9\x0b\xf8\xa5\xcf\xa8\x23\x68\x2f\x0b\xd2\x3f\x82\xb4\x32\x20\xe3\x7f\x08\xda\x13\xb0\x65\x9f\x81\xfe\xda\x9c\xcc\x2e\x92\xa4\x89\x67\xee\x0d\x67\xde\x17\xf1\x71\xb2\xf6\xed\xd4\xe5\x47\xfb\x32\x3c\x1f\xed\x3b\x22\xfe\x99\xb4\x9f\x42\xf1\x3c\x73\x8f\xf0\xdd\x10\x90\xf3\xbf\x06\xb1\x12\xfb\x66\x04\xe4\x6c\xd9\x29\xbf\x91\xfe\xf1\xbb\x83\x34\x30\x40\xbe\x65\xb4\xc7\x20\xee\x2f\xfe\xee\x41\x1a\x18\xb0\xe7\x3b\x16\x1c\x13\xb4\xa7\x6d\xd9\xba\xba\x40\xed\x02\xf6\xf4\x78\xdf\x4d\x01\xfb\x36\x05\xed\xfa\x1e\xfd\xcd\x67\xdb\xef\x66\xef\x3e\x0f\xf4\x6c\xc0\xa6\x6d\xbf\x27\xed\xed\xb4\xe9\xd0\xca\xa0\x4c\xff\x80\x6d\x3d\x4e\xdb\xf4\xfd\x85\xf6\xbc\x80\xbc\xee\xd7\x71\xda\xe3\x1e\x6d\x46\xdf\xc3\xe3\x9e\x76\x46\xc7\x77\x49\x50\xff\x3b\x41\xbd\x4b\x03\xa4\xb1\xd2\x7c\xf9\x8a\xb6\x23\xef\xd8\xf3\x73\xcf\xf2\xbf\x71\x0e\xed\x08\xb6\x63\x8d\xf1\xd2\xc6\x88\x91\x44\x5d\x0f\x06\xb5\x4f\x5d\x47\x1b\xb1\xd4\xd0\x46\xf8\xd4\xb9\x79\xcc\xae\xef\x18\xf5\x18\x3c\x90\xa7\x5e\x7e\x21\x87\x9f\x07\x6b\xeb\xd9\xe0\x5a\xa3\xcf\x89\xdd\xf5\x3d\x03\xfa\x95\x3a\xf8\x55\xaf\x7d\xba\x0e\x9c\xb5\xfe\x47\x5c\x25\xfe\x47\xac\xce\xfe\xa7\x9c\x05\xfe\x65\xce\x6f\xfc\x2f\x39\x67\xf9\x27\x1a\xcb\xfc\x07\x9b\xee\x1f\xf1\x92\xc9\x5a\x95\x14\x5c\x23\xa7\xe9\x75\x5a\xcf\xe1\xc6\xbd\x5c\xaf\x8d\x8d\x77\x0f\xc7\x5c\x99\x1a\xdc\xc3\xb3\xf4\x7e\xad\xf7\xe9\xe0\xdd\x23\xc3\xf9\x67\x19\xa5\xef\x1d\xce\x7e\xe2\xd2\xfb\x73\xf0\xac\x9c\x61\x5d\xcc\x7a\x34\x57\x7a\x59\xd7\x8a\x9b\x75\xcd\xcd\x59\x22\x45\xf3\xac\x9e\xb2\xc8\xdc\xe5\xff\x89\x77\xbb\xdf\x1c\xc9\x1e\x87\x0c\xb7\xd7\x71\x7a\xfd\xe3\x6e\x96\xc9\xf9\x21\xc1\xba\x86\x3b\xca\xcd\xfe\x33\xe6\x8d\x8c\xd1\xfb\xe0\x34\xee\x1e\xa5\xac\xbb\x35\x32\xdc\xaa\x92\x91\x66\x3d\xbe\x68\x9d\x3e\xd6\x9f\xc7\xfc\x27\x1c\x97\x4b\x8a\x5e\x07\x89\xf1\xb4\xcd\xd7\x63\xda\x07\x78\xda\xa6\xf5\x86\x24\xea\x33\x8b\x6b\xba\x28\xdd\x32\xae\x8c\x3e\xb1\xfe\x22\x49\xcd\xf6\x96\x5a\xf4\x0f\xb3\xcf\x24\x53\x38\x9f\xbf\x24\xe7\x63\x67\xa4\xd3\x94\x30\x6b\x01\x7b\xf5\xcf\x9c\xff\x59\x83\x1d\x7b\x65\xb1\x85\x7d\xc7\x37\xd2\x87\x1c\xe8\xcb\xeb\x8d\xd6\x36\xd9\xe2\x58\xc4\x9d\xf0\xa0\x4c\x71\xbc\xc9\x7e\xe2\x91\x5c\xd6\xc3\x81\xe6\x9d\x52\xaa\x6d\xa0\xbf\x2c\x70\xd7\xb2\xcf\xac\xb5\xe6\x64\xc9\x81\x12\x83\xf7\x03\xbd\x57\x2f\xb2\xf1\xae\xe3\x1e\x56\x6a\xdf\x0f\x37\x69\x9e\xdd\x06\xef\x24\xce\x99\x60\xae\xf3\x36\x1f\x7f\x03\xfb\x6d\x71\xe3\x7d\x31\xc4\x29\x0e\x2e\x5f\xc8\xf8\x8f\xe2\x5f\xba\x9d\xc3\x4f\xa4\x37\x6d\x9a\x9d\xf3\xa1\xb6\x8e\x40\xde\x2f\x0f\xec\x7b\xae\xaf\xc4\xe2\x5c\x37\x39\x98\xfb\x74\x3d\xce\xf1\xb3\x38\xb4\x1f\x8d\xf5\xd0\x94\xf3\xc0\x1d\xc9\x63\xeb\xfc\x24\x98\x73\x7d\xc6\xfe\x44\xda\x84\xbc\xc6\xf9\x09\x72\xba\x39\x37\x7d\x88\xac\xb6\x35\x5f\x6e\x08\x35\xec\x71\x66\xf0\xae\x53\x66\xef\x0f\x7f\x26\xbe\x96\xd2\xc6\x3e\x1b\xed\x15\xcb\xec\x29\x6d\xf4\x5e\x11\xa4\x4e\xd6\xa5\x9c\x1b\xeb\x82\xef\x3a\x87\x1b\xed\x7b\xa9\x7d\x5f\xa5\x2e\xda\xd8\xe7\xbe\x6b\x64\xb0\x7d\xd7\xd4\x7d\x57\x4a\x8a\xf3\x05\xce\x4f\x90\xc5\x3d\xd6\x59\x48\xdb\x47\x7a\xb0\x27\xe4\x3b\x93\x79\x2e\x97\x56\x8d\x77\x2a\x6b\x38\xf7\x8c\x3f\xdb\x7d\x25\xf6\x3e\x68\xdf\xaf\xc4\xb4\x73\xd2\x4f\xda\x38\x6b\x6c\x5b\x86\xed\x47\xc0\x7e\x9c\x6e\xc3\x14\x78\xff\x20\x0e\x67\x92\x74\xe4\x1c\xda\x26\x24\x92\x1a\x1f\x65\x9f\x0d\x5a\x6a\x3f\x88\xbd\xd8\x99\x2b\x3d\xc1\xb3\x0b\x31\x45\x84\x7d\x26\xc5\xae\x33\xec\xd1\xdc\xbf\xcd\x9e\xfe\xc3\xe8\x16\x30\x97\xa6\xb3\xcc\x6a\xea\xef\x3d\xde\x83\x6d\x68\x8a\x54\xb9\x26\x4a\x91\xf3\x76\xc9\xb4\xb6\x4a\x6a\xe8\xe7\xb2\xdc\xb9\x58\xc6\x34\xda\x6d\x3c\x9f\x1b\xdb\x25\x96\xf5\xe5\x1e\xe8\xce\xdf\xd6\xe0\x33\x3c\x9f\xce\x86\x72\xed\xb3\x16\xfe\x82\x7f\x06\x18\xa4\x07\xcf\xd6\x6d\xb9\x7f\x67\x12\x6f\x27\x9d\x7b\x1d\xbf\xe3\x65\xec\xdc\xcd\xd9\x91\xfc\xeb\x1c\xe8\x1a\xd0\x79\xd0\xf9\xd7\xb1\x9f\xdb\x3a\xff\x44\xde\x5b\x80\x4f\x50\xbf\x6b\x8a\x5d\x4b\x3d\x42\xbe\xe1\x6c\xb2\x1b\x7d\x07\xa4\x9f\x55\x6c\xdf\x89\x6a\x83\x77\x40\x8f\xce\x55\xf0\xec\x24\xcd\xda\x76\x1a\x2f\xe7\x71\x99\x60\x7d\x62\xd7\x67\x1b\x9d\xbf\x66\x6d\x67\x7d\x56\x74\xb5\xe0\x4c\x70\xa5\xa4\x36\xb6\xba\xc6\x1b\x7d\x75\x1c\xc5\x87\xe7\xb1\x49\x9d\xea\x5a\x69\xf4\xa9\x29\xf6\xa0\xae\xc6\xb9\x64\xdf\x03\xff\xe0\x0c\xde\x74\x67\xe5\x7e\x63\x9f\xdd\x82\xed\xb9\xb8\xd0\x8e\xd1\xe7\x9e\x73\x6d\xfd\xe1\x19\x95\xda\xd7\xf5\xa7\xe7\x8a\x5d\xaf\xff\xde\x06\xe2\x0d\xe6\x43\xcf\x19\x5d\xb7\x4d\xf9\x09\xe2\xd4\xd4\x0e\x95\x31\xfa\x8c\xe9\x7c\x8b\xf3\xbc\x57\xb2\xa9\xd3\x22\x6c\xe4\x5a\x2f\xb2\xde\x6e\x95\x3e\xae\xe5\xd4\x66\x5f\x69\xa3\xef\x02\xce\x4a\x69\x85\x1f\xd3\x39\x83\x2d\x76\x3c\xc3\x1d\xf3\x9f\xb6\xff\x43\x89\x23\xaf\x19\x66\x7a\xfd\x28\x6f\xbc\x43\x06\xf6\x38\xfd\x5d\xcf\x5f\x4e\x3b\x12\x2a\xe4\x99\xaa\xf5\x0f\xa5\xd6\xfe\x06\x6d\xe1\xf9\x5b\x28\xea\xb7\x6f\x7b\x9a\xe7\x63\xac\x3e\x5b\xf8\x8b\x02\x3a\xfc\xa5\xd0\x70\x68\x5a\x70\x4c\x79\x80\x7c\x41\x1b\x76\x5f\x69\x60\xfc\x99\x6b\x82\xfb\xff\x3d\xc1\x9a\xfe\x17\xc4\x8a\xec\xdf\x04\x25\x07\x69\x62\x50\xc7\xa6\x00\xd9\x7b\xaf\x7e\xde\xc1\x59\x69\x95\xee\xb7\x2e\x57\x47\x1a\xfb\xc9\xf5\x25\x4d\xcf\x77\xea\x67\x72\x9a\x4e\x0e\x3f\x64\x1f\xdd\xcc\xbe\xfa\x3e\x58\xdc\x29\x33\x0d\xd6\x1f\xa3\x8f\xcc\xb1\x76\xca\xb5\xd6\x7e\x19\x6f\xb4\xe1\x2c\x4f\xbd\x9a\x5f\x71\x26\xdb\xe5\xff\x96\xbd\x61\x13\x67\xf7\x1c\x23\x8c\xfd\x95\x33\xa7\x75\xbd\x4c\xb3\xae\xe6\x9e\x93\xc9\x5a\x5e\x45\xad\x67\x33\xb6\xab\x74\x65\x9d\xbe\xc0\xae\xf3\x07\x59\xa7\x3e\xa3\x96\xb4\x8e\x5f\x91\x43\x9f\x7a\x5f\xfa\x99\x61\xc8\xb6\x93\x28\xc7\x26\xbb\xf6\x07\xea\xf5\x8f\xb3\x75\x99\x75\x0f\x2d\x64\xee\x87\xa8\x2f\xfc\x4e\x31\x73\xd8\x2b\xbf\xe4\xfd\x13\x7c\x6e\xbe\xfe\xe5\xca\x14\x72\x35\x22\x48\x51\xfa\xdb\x03\xf7\xa7\xa2\xa6\x6f\x3f\x7d\xd8\x3f\x58\xe3\xec\x75\x4e\xaf\x8f\x53\x98\xdb\xa3\x64\x98\xe3\x09\xf6\xc0\x51\xf6\xbd\xc6\xfe\x36\x67\x7f\x93\x9b\xc4\xbd\xe0\x09\x59\x48\x0c\xc3\xed\x75\xf0\x0b\xf6\xca\x8d\xf6\x7a\x99\xcd\xfe\x28\xba\x36\xcc\x39\xf0\x5e\xf6\xff\x6c\x66\x4b\x6b\x9b\x16\x42\xee\x20\x3d\x4d\x1d\xb1\x77\xaa\x2f\x24\xd3\xb8\x01\xd9\xb7\xe0\x75\x96\xd6\xd6\xad\xc4\xbe\x9a\x3b\xc2\xbb\xc4\xb1\x51\xaa\xcc\x0c\x69\x65\x34\x48\x84\x79\x03\xd4\x4a\xc4\xbc\x02\xdd\x2f\xfa\xbf\xb7\xcf\x3d\x9a\x1e\xc7\x97\x2a\x49\xe3\x3e\x1e\x66\x9f\x79\x38\x0b\x41\x6e\xc3\xc1\x59\xd5\xc1\xd8\xc9\x12\xcd\xd9\x28\xc9\xd8\xc6\x3a\xa2\xcf\x42\x8b\x90\xd5\xe7\x24\x7d\x46\x1a\x2a\x1d\x6c\xba\x2b\x78\x3e\xd2\x67\xa7\x4b\xc9\xdb\x31\x89\xb5\xcf\x4a\xb7\x48\x47\x6c\x64\x19\x5e\xff\x0f\x46\x35\x3a\x3e\x44\x7f\x49\xe0\xec\x6d\xdf\x1b\xb4\xbc\x96\x6b\x94\x19\x86\x7c\x50\xc6\x69\xe8\xfb\x98\x7f\x87\x9e\x6b\xec\x09\xc7\xd9\xeb\x63\x78\x86\xfc\xcf\xeb\xbb\x32\xf7\x28\x8b\xb5\x28\x84\xbe\x2f\xec\xfb\x90\xd8\xe7\xad\x24\xce\x19\x23\x9d\x2f\x89\x8b\xbb\x5b\x1b\xfb\x0c\xa3\xd7\x5c\xd6\x48\xee\x52\xc9\xc1\x6f\xa6\x63\xed\x6f\xac\x9f\x34\x7d\x63\xfd\xed\xbb\x6a\x60\x6f\xb3\xbf\xa7\x9a\x0f\xf8\x6f\xb2\x02\x87\xf3\x90\xa0\xfe\x81\xf6\x9d\x33\xf8\x9d\xb6\xf1\x5e\x69\x9f\xfb\x0a\xec\x3b\x5e\xbe\x71\x94\x31\xfa\x5b\xc3\x43\xec\x65\x8f\x4b\x8a\x8d\x51\xac\x24\x10\x57\x9a\xc6\x52\xad\xf7\x9f\xd2\x64\x0c\x94\x50\x7d\xb6\x04\x87\x30\x75\x97\xb8\x69\xdb\x41\x31\xea\x80\xff\x18\x6d\xa6\x8d\xcf\x2c\xea\xef\x98\x74\xb4\xb1\xbc\xd3\xbf\x0b\xf9\x8e\xc6\x6d\xdc\x9b\xc0\xde\xac\x16\x0f\x77\x17\xf2\xe2\x7f\x05\xdc\x63\x6d\x1c\x3f\x90\x2e\xb4\x71\xc6\x25\xe0\x3c\x43\x1c\x46\x3f\xee\x40\x9a\xae\x83\xfa\x4b\xba\x51\x25\xfa\x5c\x7e\x5b\x80\xfc\x9b\x69\xd7\x37\x3b\xd7\x9f\x43\xfe\x9c\xc0\x19\xdb\x77\x43\xb3\x6f\x02\x69\x1a\x9f\x7f\x6b\x9b\x7d\x9b\xb4\xbf\x29\xfc\xb7\xf6\x7f\xfc\x66\xa9\xf7\x4b\x9d\xa7\x3f\xf8\x46\xf9\x87\x2d\xb9\xeb\xcd\x9d\xfd\x9d\xe0\x37\x4a\xf3\x8f\xe4\xce\xfe\x3e\xe9\x7f\x2b\xd8\x7e\x1d\x6c\xbf\xb1\xcf\x5d\xd4\xc5\xb9\xed\x1f\x7e\xaf\x0c\xb6\xff\xed\x9b\x49\xd3\x39\x20\xd8\xfe\xd1\xb7\xcb\xff\xf5\x1b\xe6\xef\x7d\xcb\xfc\xdd\xf6\x7f\xff\xa6\x19\x1f\x5c\xa7\xec\xb6\x71\x5f\xfa\x6f\xed\xbf\xed\x93\xaf\x9c\xfd\x5d\xf0\xdc\xd6\x9e\x7b\x01\xbf\x9c\xc1\x6f\x3a\x03\xf5\xb7\x51\x67\x94\x7d\x4e\xfd\xa3\xef\xe3\xb4\xfe\x7f\xfe\xe7\xfe\xff\xa1\xfd\x9f\x6a\xd0\xff\xee\x1f\xf5\xff\xdb\x77\xf0\xff\x98\x73\xff\x8f\xff\xb1\xff\xfc\xff\xde\x9e\x9b\xa3\xa6\x6f\xb0\xff\xa5\x6d\xfe\x3d\xfa\xf7\x5a\xfb\x0e\xf8\x1f\x28\xf8\xfd\x2e\xce\x79\x9e\xff\x3b\x4d\x8e\x13\xdc\xd7\x4e\xd0\xbe\xa2\xef\x6d\xfe\x8f\xec\x3b\xe3\xef\x90\x73\xb6\x28\x4d\xae\xaf\xcf\x26\xfb\x6e\xf9\x1f\xc8\x35\xdc\xff\xb5\x6b\xb8\xa8\x90\xbd\xbf\x4f\xf6\x37\x39\x9b\xfc\xef\x04\x88\xf5\xce\x26\xff\x3f\x35\x59\xb9\xfe\xaf\xd9\xa3\x95\x63\xdb\xef\xd3\xef\xfe\xbe\x06\x72\x29\xff\x31\x97\xa2\x96\x2f\xc5\x0e\xe4\x6a\x08\x90\x7d\x77\xfd\x0f\xe4\xfc\x1e\xf9\xea\xdf\xc8\xfe\xf6\xf7\x1f\xc8\x15\x8f\x5e\x28\x64\x43\x90\x5a\x9f\x4d\x8d\xb8\x37\xe2\xd8\x88\x4b\x63\xdc\x4d\x3e\x07\xed\x37\xea\xfd\x7f\xcd\xe3\xff\x6b\x5e\xfe\xc7\xb8\xe5\xbf\xc5\xfd\x9f\x7c\x6f\x4e\xac\x1b\xaf\xeb\x6f\x2f\xc1\x56\x7f\x6f\xb3\x7e\xcf\x6f\xee\x43\xca\xf9\x2e\xb6\xff\x02\xbd\xc0\x73\x81\xbd\xa7\xc4\x05\xc9\x02\x53\x5d\x53\xba\x8d\x0d\x90\xff\x1b\x4d\x4d\x77\xf9\xab\xf1\xed\xaf\xc8\x34\x1b\xf3\x6f\x75\x50\x2a\x4b\x6d\x6a\xcc\x89\xfe\xdd\x0f\xe4\x9a\x8f\xcd\x8b\xc1\xe6\x67\x3d\xde\xff\x6b\x80\xe4\xc9\xdf\xc5\xe7\x3c\x7c\xbb\xdc\xff\x9d\xeb\x36\xda\x8d\xd0\x2c\x99\xa8\x65\xa1\xb7\x82\x6b\xb0\x34\xb6\xc6\x43\x81\xdf\x9d\xab\x71\x01\x9e\xfd\xcc\xad\x53\x1e\x6a\xbc\x0b\xf8\x0f\x40\xec\xf5\x7e\x6e\xb3\xbe\xe1\xac\x3f\xff\xd2\x14\x12\x24\xfd\x7b\x97\xe0\xef\x9f\x1b\xbf\xcb\x5e\xa4\xbf\xcd\xa2\x6b\xba\x15\xf8\x3d\x7a\x9f\x60\xdb\x5d\x93\xb1\x57\x46\x63\xf7\xc1\xa0\xbe\x11\xb4\x31\x8d\xa4\xed\xd2\xd7\x51\x7f\xeb\xb5\xe6\xca\x9b\xd0\xf4\xc6\xef\xa3\x9c\xe5\x1f\xd5\xdf\x43\xd5\x78\xdf\xb5\xfa\x77\x3c\xcd\xc6\x45\x05\x29\x5a\xbf\x1b\x33\xa5\x35\x94\x07\x75\x87\xdc\xc6\xab\x12\xdf\xf8\x4d\xce\x3e\x67\xea\xef\xb3\x31\x92\xe4\x48\xb0\xef\xb0\xb5\xc1\xdf\x27\xa4\x43\x63\x82\xfb\x71\x92\x6b\xb7\xc4\x85\x3e\x61\xff\xde\x28\xd9\xfa\x48\xae\xb4\xda\xda\xbf\xfb\x6e\x4b\xbe\xc3\xf4\xfe\x17\x72\xdc\xfe\x46\xe1\x64\xcf\x0d\x0b\xfe\xbe\x4c\xff\x2e\xb6\x93\xd6\x45\x4c\x13\xd0\xd3\xcb\x14\x69\x11\x12\x26\xed\xf5\xef\xb8\xed\xdf\xe9\x64\x82\xc3\x5e\xa9\x70\x55\x70\xa6\xd8\x2f\x97\x07\x7f\x87\xdd\x2f\xd8\x96\x42\x25\xd0\x55\xfa\xfc\x17\x22\xea\xcf\x96\xa8\xa8\x73\x5b\x4d\xe6\x8f\xdc\x0f\xbe\x90\x28\xe7\x6d\x52\xe1\xd8\x2e\x13\xf5\xdf\x65\xb0\x31\x11\xa9\xb2\x6a\x39\x87\x6c\x97\x02\xd7\x7e\xb5\xc1\xb1\x5b\xb5\x36\xba\xfa\x6f\x85\xd7\xc9\xfe\x1d\xb2\xfe\x36\xae\x5b\x4d\x7b\xe5\x0e\xfb\x7d\xbf\x91\x66\xed\x57\x0e\xc7\x43\xfe\x9f\x1d\x0f\x19\xd7\x07\xa8\xf1\xb9\x79\x7b\x2e\xa9\xf7\x03\x7d\xba\xd5\xd4\xbc\xef\xff\x5f\xfe\xff\x42\x9c\x1f\xce\x22\x63\x3f\xed\x79\xf6\xf3\x7e\xea\x76\xbf\x2c\x83\x9c\xc6\x01\x99\xaf\x49\xd7\xb5\xeb\x1b\x75\x0f\x74\x63\x63\x0b\x6e\x21\xc8\xdc\x6f\xbd\xc0\x7d\x6f\xbf\x3c\x06\x75\xd0\x84\x7c\x5d\x48\xb6\xda\x16\x32\x57\xbd\xe5\x1a\xa7\xc8\x81\xfa\x00\x1a\x6d\x79\xa5\x8f\xc3\x2b\x7d\xad\xdd\xe0\xd4\xca\xfe\xc6\xb5\xc7\x69\xe7\x80\x39\x39\xde\xbe\xd7\x65\x05\xff\x7e\x47\xb8\x3e\x5b\xd9\xe7\x8d\x07\xc5\xf3\x3b\xe7\x42\xfb\x7c\x42\xbe\x86\x90\x37\x09\xd9\x21\xc9\xce\x6d\xdc\xd9\x8e\x51\x83\x9d\xd9\xff\x3f\xe6\xde\xe0\x93\x21\x8c\xcd\xa3\x7e\x73\xa1\x61\xc1\x73\xf3\xe7\xe8\x5c\xa6\x89\xbe\xeb\x1a\xa9\xf1\xcc\x1d\xfc\x1d\xc2\x56\xc3\x2f\x6d\xf1\x65\xbc\x4d\x0f\xca\x03\xd8\x8c\xd4\xa4\xef\xbd\xfa\x3b\xb7\xbe\xaf\xea\xfb\xad\x7d\x57\x0e\xde\x91\x9b\xdf\x85\xed\x7b\x25\xf7\x5b\x6b\x85\x54\xe9\xbb\xee\x59\xc4\x98\x46\xfa\xf7\x7b\xb6\xff\xb0\xd1\xc7\xff\x46\xe0\x8e\xed\x7f\xff\xac\x3b\xb6\xbe\x5f\x37\xde\xad\x1b\xef\xd5\xbf\x73\xa7\xd6\x77\x75\xad\x57\x8f\xd3\x32\x8e\x74\xfd\x1d\xe2\xb4\xfe\xd6\x7e\x86\xf6\xb4\x04\xd7\x28\xfd\xa3\xbf\x11\x33\xff\xdf\x22\xc6\xbb\xa1\x7a\x58\x15\xcd\xe8\xc6\xdf\x48\xff\x9e\xe3\x0c\x6b\xc1\xe9\x8a\xe0\x32\xa7\xa9\x3d\xa4\xd7\x8a\xc8\x66\xb2\xc1\xb1\x5a\x5e\x53\x93\xec\x39\x74\xda\x0f\x5d\x2b\x72\xea\x1b\xda\x7f\xd0\xde\x17\xe0\x9f\x99\xcf\xb8\xab\xa0\xd7\xe1\x9f\xe0\x7d\x29\x34\x93\xe7\x7b\x68\xd3\x69\x7b\x9f\xab\x4b\x9f\xed\x02\xbf\xd7\xf0\xb3\x3c\xf8\xf6\xd1\x3a\x82\xbf\x3b\xd9\x69\x4d\x90\x4d\xe7\xd0\x08\x68\x4c\xb0\xd5\x54\x62\x46\x71\x8f\x99\xc0\x3a\x1a\xa0\x51\x50\x67\xa8\x14\xbe\x6e\x33\xa0\xcc\x20\xb5\x87\x72\xe0\xeb\xe7\x64\x28\x1e\xea\x11\xa4\x5c\xf8\x1d\x82\xe3\x87\x37\xa3\xc9\xf0\x87\xff\x8e\x1f\x65\xc1\xfe\x92\x46\xd9\xa0\x5c\x0e\x54\x00\x15\x36\x12\xfc\xc2\xa0\x8d\xee\xcd\xec\xf5\x80\xdf\xfd\x1c\x5b\x8d\x7a\x66\x9d\xab\xbb\x99\xfe\x73\xfd\x18\x0f\x4d\x80\x2a\x83\xed\x78\xe4\x26\xd2\xf6\x82\x7a\x06\x49\x3f\xf7\x82\xaf\xdb\xc1\x50\x71\x73\x82\xaf\xdb\xcb\x83\x54\x10\xa4\xde\xf0\x75\x7b\xe3\xb9\xf4\x07\x7e\x9c\x1b\xc7\x28\xe4\x34\x96\xb9\xcd\x62\xd6\x78\x27\x07\x71\xce\x09\xe6\xa3\x31\x37\x19\xc1\xbc\x94\x06\xf3\x37\xaa\x31\xa7\xc1\x3c\x96\x34\xcb\xb9\x9d\xff\x60\xde\xcf\xf2\x83\x9a\xc9\xd1\xf3\x81\xf6\x95\x20\x35\xde\xb7\x5f\x08\xd4\x96\xef\x15\xfd\x7b\xe6\xff\x76\x96\xe3\x9c\xa2\x7f\x37\x6d\xfc\xd6\xfa\x4f\xd1\x46\xd0\x7e\x49\xdb\xe2\xbf\x9d\x59\x83\xe3\x34\xc5\x6b\xfa\xb7\x7e\x7d\x9f\x69\x6f\x9f\x61\xda\xd3\xea\xdf\xc1\x7d\x4e\xdd\x27\x41\x4c\x6d\x1f\xf3\xdc\xc7\xaa\xe8\x57\xc1\xd6\x0a\xfc\x5e\xce\x77\x30\xf8\xbb\x4f\xd6\x42\x7f\x99\xde\xef\x02\xb1\x9d\xf9\xa1\x59\x9c\x1f\x37\xa3\x9d\xac\x3b\x83\x6c\xd2\xeb\x90\x5e\x63\x58\x4b\x1a\x49\xaf\x49\x7a\x0d\x43\xae\x2d\xa4\x7f\x3f\x38\x41\xff\x8e\x8a\x39\x69\x06\x29\x29\xf0\xb7\x1b\xad\x4e\xf6\xdf\x5b\xd4\xef\x96\x15\xa5\xff\x12\xa4\xfe\x6b\x90\xbc\x5f\x66\x2e\x30\x2f\x32\x2f\x33\xd7\x9a\xd7\x99\x7f\x32\xff\xee\x88\x75\x70\x4b\x75\x7c\xed\xf8\x31\xf9\xf5\x94\xbb\x52\xee\x49\x39\xe1\x6e\xe5\x4e\x76\x17\xbb\x47\xb8\x27\xb8\x2b\xdd\xd5\xee\x49\xee\x4b\xdd\xdb\xdd\x7b\xdc\xef\xb8\x3f\x74\x1f\x73\xff\xe8\xf6\x79\x22\x3d\x69\x9e\x76\x9e\x5c\x4f\x37\x4f\x6f\x4f\x5f\x4f\x7f\x4f\x91\x67\xb2\x67\x81\xe7\x22\xcf\x12\xcf\x0a\xcf\x2d\x9e\x27\x3c\xc7\x53\x1d\xa9\xb1\xa9\xf1\xa9\x69\xa9\xed\x52\xbb\xa4\x8e\x4c\x2d\x4f\x9d\x9c\x7a\x55\xea\xad\xa9\x5b\xd2\x8c\x34\x67\x5a\x64\x5a\x4c\x5a\xab\xb4\xb6\x69\xee\xb4\x0e\x69\xd9\x69\xa5\x69\x53\xd3\x66\xa4\x1b\xe9\x51\xe9\xa9\x99\x92\x69\x64\xb6\xcc\x8c\xca\x8c\xcb\x4c\xc8\x4c\xca\xcc\xc8\xec\x94\xd9\x2d\xb3\x6f\xe6\xbc\xcc\x95\x99\x57\x65\xae\xc9\xbc\x2e\xf3\xe6\xcc\x3f\x65\x3e\x9c\xf9\x58\xe6\x33\x99\x3b\x33\xf7\x64\xbe\x99\xf9\x8f\xcc\xf7\x33\x8f\xb6\xeb\xdb\xce\xdb\x6e\x60\xbb\x9a\x76\xd3\xdb\xcd\x6c\x37\xb7\xdd\x82\x4e\xf3\x3b\x5d\xdc\x25\xfe\xfe\xd4\xfb\xaf\x3b\x6e\x9d\x32\x4e\xf5\x38\xd5\xf7\x54\xff\x53\x03\x4e\x15\x9d\x1a\xe5\x4b\xf7\x9f\xf6\xfb\xed\xbf\x6f\xb9\xc9\x5c\x64\x2e\x35\xaf\x02\x81\x1b\xcc\xbf\x98\xfb\x1c\x6d\x1d\x37\x3a\xf6\x39\x8e\x27\x4b\xb2\x0f\x04\x36\xb9\xc5\x9d\xe0\xf6\xb8\x4b\xdd\x65\x41\x04\xa6\xb8\x57\xba\x9f\x74\xbf\xec\x3e\xe0\xfe\xc8\xfd\x2f\xf7\xcf\x1e\xf1\xc4\x80\x40\x47\x4f\x9e\xa7\xa0\x09\x81\x39\x9e\x45\x9e\x8b\x41\x60\xbd\x67\x53\x10\x81\xd6\x41\x04\x46\xa4\x8e\x4d\xad\x06\x81\xf5\x4d\x08\x44\x83\x40\x9b\xb4\x94\x20\x02\x35\x69\xb5\x36\x02\x9e\x3f\x40\xa0\xac\x09\x81\xf5\x99\x9b\x32\x1f\x6c\x42\xe0\x75\x10\x38\x08\x02\xbd\x9b\x10\x98\xd1\x6e\x0e\x08\xd4\x74\xba\x00\x04\xe2\xef\x5f\x03\x02\xea\x54\xf2\xa9\x5e\x20\xe0\x3d\x35\xe8\x54\x89\xcf\xa3\x11\xf0\x1f\xf1\xbf\xe8\xdf\xe5\x7f\xc6\xff\x84\x7f\xbb\xff\x71\xff\x63\xfe\x6d\xfe\x87\xfc\xbd\xfc\xb9\xfe\xec\x2f\x3d\x0d\xdf\x35\x7c\xd3\xf0\x75\xc3\xe7\x0d\x87\x1b\x3e\x6d\xf8\xb8\xe1\x50\xc3\x87\x0d\x1f\x34\xbc\xdf\x70\xb0\xe1\x40\xc3\xfe\x86\x77\x1b\xde\x6e\x78\xab\xe1\x1f\x0d\x7f\x6f\xd8\xdb\xf0\x46\xc3\xab\x0d\x7f\x6b\xd8\xd3\xb0\xbb\xe1\xf9\x86\x5d\x0d\x4f\x37\x6c\x6a\xb8\xb5\xe1\xc6\x86\xf5\x0d\x6b\x1b\x96\x36\x2c\x68\xe8\xde\x90\xda\x10\xd7\x10\xd3\x10\xd2\xe0\x38\xea\x3b\xfa\xe9\xd1\x43\x47\x0f\x1c\xdd\x76\xf4\xbe\xa3\xb7\x1c\xed\x73\xb4\xd7\xd1\xdc\xa3\x39\x47\x3b\x1f\xed\x78\xb4\xfd\xd1\x94\xa3\xc9\x47\xd5\x17\x5f\x7f\xf1\xe5\x17\xc3\xbf\x28\xfc\x22\xf7\xc8\x98\x23\xa3\x8f\x94\x1e\x29\x3e\x32\xf0\x48\xe1\x91\xbe\x47\xba\x1f\xe9\x72\xa4\xfd\x11\xcf\x91\xf0\xc3\x27\x0f\xff\x72\xf8\xc7\xc3\xff\x3c\xfc\xfd\xe1\xc3\x87\x3f\x38\xbc\xff\xf0\xdf\x0f\xef\x3d\xfc\xf2\xe1\x17\x0e\x3f\x7f\xf8\xa9\xc3\x0f\x1d\xae\x38\x3c\xee\x70\xf9\xe1\x9e\x87\xbb\x1f\xee\x76\xb8\xeb\xe1\x2e\x87\xfa\x1f\xea\xf3\xc1\xc6\xa9\x77\x4f\xed\x99\xb0\x3b\x7c\x4f\xf8\x83\xe1\x0f\x84\x6f\x09\xbf\x3f\xfc\xbe\xf0\xbf\x86\xed\x0f\x39\x73\xee\xdf\xfd\xfd\xff\xe0\x8f\xd3\x08\xd3\x8d\x92\x7f\xc3\x42\xd9\x97\x26\xfd\x63\xfc\x17\x1d\x81\x91\x26\xa7\x01\x87\x38\x59\x57\x42\x24\x54\xc2\xa4\x85\xb4\x94\x70\x89\x90\x48\x56\xb9\x68\x4e\x29\xb1\x12\x27\xad\xa4\xb5\xc4\x0b\x77\x14\x69\x2b\x89\xac\x46\xc9\x92\x22\x6e\xe6\x60\xaa\xa4\x49\xba\x64\x48\xa6\xb4\xe3\x4c\x93\x25\x1d\xa4\xa3\x64\x4b\x27\xce\x15\x5d\x24\x47\x72\xa5\x2b\xa7\xc8\x7c\xe9\x26\xdd\xa5\x07\x6b\x6d\x2f\x29\x90\xde\xd2\x47\xfa\x4a\x3f\xe9\x2f\x85\xe2\x95\x01\x32\x50\x06\x49\x91\x14\x4b\x89\x0c\x96\x52\x19\x22\x43\x59\x07\x87\xcb\x08\x19\x29\xa3\xa4\x4c\x46\xcb\x18\x19\x2b\xe5\x32\x4e\xc6\xcb\x04\x4e\x47\x95\x52\x25\xd5\x32\x51\x26\xb1\x7a\x4e\x91\x1a\x99\x8a\xff\xab\xe5\x6a\xb9\x46\xae\x95\x9b\x65\x83\xdc\x23\x7f\x91\x3f\xcb\x66\xb9\x4f\xfe\x2a\xf7\xcb\x03\xdc\x1a\x1f\x94\x87\xe5\x11\xd9\xca\x0d\xad\x5e\xb6\xc9\xe3\xf2\x84\x6c\x97\x27\x65\x87\x3c\x25\x3b\xe5\x59\x79\x4e\x76\xb9\xbe\x91\x0b\xb9\x27\xcd\x90\xd9\xae\xef\x64\x89\xfc\x49\x16\xca\xdc\x90\x8e\xb2\x58\xe6\x84\x0c\x95\x35\x72\x67\x48\x31\x27\xf2\xe1\x21\x23\xe4\x3c\xb9\x38\xa4\x5f\x88\x37\xa4\xd0\xbc\x30\xa4\x54\xe6\xc9\x72\xb3\x5a\xb6\xc8\x33\x72\xb9\x4c\x97\xf3\x43\x8a\x54\x79\xc8\x90\x90\xfe\x32\x5f\x2e\x75\x7d\x2f\xd3\xe4\x0a\x59\x25\xb7\xab\x38\xd5\xca\xf5\xb1\xeb\x13\x57\x83\xeb\x4b\xd7\x11\xd7\xe7\xf2\x74\xc8\xb5\xf2\x82\xea\xed\x3a\x13\x92\xe8\x3a\xe1\x3a\x19\xf2\xb7\x90\x97\x5d\xdf\xca\x25\xae\x2f\x5c\x5f\xb9\x7e\x92\xab\x38\x4f\x5f\x29\xd7\xcb\x5a\x59\x27\xeb\x39\x13\xde\x20\xb7\x0a\xa7\x6b\xb9\x45\x36\xca\xdd\x72\x97\xfc\x60\xac\x31\xee\x91\x0b\x8c\x3b\x8d\xbb\x8c\x8d\xb2\xd4\xb8\xd7\xb8\xdb\xb8\x46\xc4\x3b\xb8\xba\xaa\xb2\x62\x5c\xf9\xd8\x31\xa3\xcb\x46\x8d\x1c\x31\x7c\xd8\xd0\x21\xa5\x83\x4b\x8a\x8b\x06\x0d\x1c\xe0\x2d\xec\xdf\xaf\x6f\x9f\xde\x05\xbd\x7a\xf6\xe8\xde\x35\x37\xa7\x4b\xe7\x4e\x59\xed\xdb\x65\x66\xa4\xa7\xa5\xba\x13\xe2\xa2\xa3\x22\x23\xc2\x5b\x84\x85\x86\xb8\x9c\x0e\xcb\x34\x94\x74\xf2\xd4\xab\x9a\xe2\x7a\x33\xd3\x13\x5d\x32\x35\xbd\x38\x7d\x6a\x69\xe7\x4e\x9e\xe2\x84\x59\x45\x9d\x3b\x15\xa7\x97\xd4\xd4\x7b\xa6\x7a\xea\x69\xac\x76\xe9\xa5\xa5\x36\x2b\x7d\x6a\xbd\xa7\xc6\x53\xdf\x8e\x66\x6a\x33\x76\x4d\xbd\x17\xc9\x99\xe7\x48\x7a\x03\x92\xde\x26\x49\x15\xe5\xe9\x2b\x7d\xb5\x89\x74\x4f\xfd\xde\xa2\x74\xcf\x0e\x55\x35\xba\x82\xe7\xeb\x8b\xd2\x2b\x3d\xf5\xdf\xd9\xcf\x23\xec\x67\xab\x9d\xfd\x12\xce\x4b\x6a\x2a\x23\x6c\xaf\xb4\xb7\x9e\xe2\xfa\x92\xc5\xb3\xd6\x16\xd7\xe0\xa3\xda\xd6\x22\x6c\x50\xfa\xa0\x19\x61\x9d\x3b\xc9\xb6\xb0\x16\x3c\xb6\xe0\xa9\x3e\x2b\x7d\xe1\x36\x95\xd5\x5f\xd9\x0f\x46\x56\x71\xef\x6d\x86\x84\x84\x6b\xb3\x44\x5a\x3c\xb5\xb6\xbe\x6c\x74\x45\x71\x51\x62\x6a\x6a\x65\xe7\x4e\x43\xea\x23\xd2\x8b\xec\x2e\x19\x64\xab\xac\x77\x0e\xaa\x77\xd9\x2a\x3d\xb3\xb5\xeb\x72\xad\x67\x5b\xa7\xdd\x6b\xaf\xdb\x11\x25\xd3\x6a\xb2\x5b\xd6\xa6\xd7\x4e\x9d\x58\x51\x6f\x4e\x65\xec\x5a\xb3\x78\xed\xda\xab\xeb\xa3\xb3\xeb\x3b\xa4\x17\xd5\x77\x58\xfa\x79\x02\x91\xcf\xa8\xef\x94\x5e\x54\x5c\x9f\xad\xb5\x0e\x1b\xd3\x64\x67\xd8\x6f\x26\x55\xbd\x23\x93\x6d\x63\xed\x4f\x42\x38\xe9\xdf\x7d\x7b\x36\x67\x6a\x90\xe3\xcc\x8c\xfa\x49\xf4\x63\xbd\x31\xa8\x5e\x8d\xa9\x48\xd5\x3f\x89\x25\x60\xbd\x76\x6d\x49\xba\xa7\x64\x6d\xcd\xda\xa9\x3b\xfc\x2b\xa7\xa5\x7b\xa2\xd2\xd7\x6e\x6b\xd9\x72\xed\xc2\x62\xe0\x96\xb2\x0a\x54\xec\xf0\x3f\x73\x6d\x62\x7d\xc9\x75\x95\xf5\x51\x35\xb3\x54\xef\xca\x60\xe8\x25\x63\x86\xd5\xc7\x8e\xae\xae\xa8\x37\x32\x4b\x3c\xb3\xa6\xc2\xe1\x7f\x85\xe9\xa9\xbd\x12\x53\xa3\x9b\x64\xca\xfe\xa8\x5b\x80\x05\x70\x40\x38\x35\x55\xc3\x70\xed\x0e\xaf\x4c\xe3\xa5\x7e\xe5\xe8\x8a\xc0\xbb\x47\xa6\x25\x3e\x26\xde\x9c\xec\xca\x7a\xa3\x46\xf7\xec\x6e\xec\x69\x35\x4e\xf7\xac\x6c\xec\x69\x1a\x5e\x93\x4e\x6e\x87\x8d\xad\x58\x5b\x6f\x65\x0e\xa9\x4d\x2f\x06\xf1\x6b\xa7\xd6\xaf\x9c\x46\x75\xcd\xd1\x89\x49\x8f\xaa\x8f\xf8\x39\x31\x35\x7d\x6d\x4c\xb4\xa7\x20\xa7\xd2\x96\xf5\xe0\xd5\x90\xda\xd9\x9e\x7a\x47\x3b\x40\x62\x54\xf3\x01\xd4\x8d\x1e\xb2\x36\xca\x7e\x89\xf8\x39\xd0\x7c\x97\x88\x81\x76\xd1\x31\x9e\x82\x74\xd4\x68\x3d\xc5\xe9\xc5\x35\xc1\xff\x2d\x9e\x95\x80\x02\x0f\x40\x97\x66\x07\x0a\xa1\xbc\xa2\xde\x5b\xc4\x83\x77\x6a\x30\x63\xc5\xdb\x72\x73\x18\x31\xb5\x86\x84\xcd\x2e\xb2\x93\x59\x9f\x93\xbe\xb0\x3e\x2e\x7d\x60\x53\x76\xb5\x5b\xc5\xb3\xc7\x56\xd8\x43\x82\xc3\xea\xe3\x06\xd5\x4b\xcd\xf4\xe0\xa8\xfa\x9c\x62\x7b\x5e\x79\x8a\xd7\xd6\x14\x05\x5c\xd0\xba\xd2\x47\x57\x3c\x2d\xf9\xfe\x4f\xb7\x75\xf3\x24\x3e\xae\x97\xce\xca\x22\x2d\xdc\x7a\x10\x55\xd6\xae\x78\x6d\x45\xed\xcc\x7a\x77\x4d\x62\x2d\xf3\x6e\xa6\xa7\x22\x31\xb5\xde\x5b\x49\x86\x2b\xd3\x2b\x66\x54\xea\xb2\x03\xa1\x0e\x9f\x26\xda\xc5\x51\x69\xd7\x4a\x79\xc5\xb0\xb1\xe9\xc3\x46\x57\x55\xf4\x0a\x3a\x12\xe8\xd0\xea\xac\xcc\xe2\x73\xd4\xa4\x57\x24\x06\xd4\x50\x80\xf5\x21\x99\x21\x9e\x0a\x23\xd1\xac\x44\x30\x0a\x86\xa7\x84\x87\xf4\x81\x7d\xf9\xb3\xde\x95\x19\x02\x45\x01\xb8\xcd\xd5\x85\x3b\xb0\xaf\xa7\x42\x25\x4a\xa3\x34\x6e\xd4\x77\xf0\x14\xcf\x28\x0a\xca\xe9\xf7\xb3\x94\x3a\x74\x39\x0d\x2a\x6d\xd4\xe6\xd4\xaf\xe8\x19\x54\x9a\x98\x5a\x99\x1a\xf8\xe9\xdc\xc9\xa0\xdb\x13\x34\xcc\x88\x10\x0d\x6a\x69\x63\x17\xcb\x14\x1d\x21\xd4\xe7\xa0\x52\x9b\xa5\xb1\x4c\xd0\x45\xef\xa9\x48\x9f\x91\x5e\x99\x3e\xcb\x53\xef\x2d\xab\xd0\xb1\x69\x78\x6c\x94\x83\x60\xd8\x98\x07\x73\x55\x7e\xd6\x5b\x33\xb0\x80\x49\x52\xe9\x6e\x7c\xd1\x60\xd6\x97\x64\x27\x36\x07\xb7\x7e\xb0\xfd\xde\xf4\x5a\x7a\x4e\xf7\x90\xc6\x6e\xcf\xda\x90\xf4\x61\x63\xd7\x6a\xe5\xe9\x41\x85\x82\xe7\x43\xea\x45\x97\xb0\xb7\x57\x74\xa2\xbd\x16\xe8\x09\x9d\xce\xda\xeb\x89\x62\x4a\xdb\x13\x7a\xed\x36\xaf\x57\x4f\xe6\x59\xbd\xb5\x92\xf4\x21\xb5\x6b\xd3\xc7\x56\xf4\xb5\xa5\x59\x4f\x2e\x4d\x5c\xaa\x6d\xc5\xc8\x30\x35\xac\x7c\x60\xe7\x4e\x2c\x6d\x03\xb7\xa5\xab\x35\xa3\xb7\x79\xd5\x9a\xb1\x55\x15\x4f\x73\x69\xf0\xac\x29\xaf\x78\xcc\x50\xc6\xa0\x9a\x81\x95\xdb\x32\xe8\xab\x78\xda\xc3\xa6\x61\x73\x0d\xcd\xd5\x4c\xfd\xe2\xd1\x2f\x5a\xd3\x18\x5e\x42\x6c\xf9\xc4\xa7\xbd\x22\x2b\xed\x5e\xcb\x66\xd8\xef\xd3\x77\x28\xb1\x79\x21\x8d\x3c\x25\xd3\x77\x18\x01\x5e\x54\xc0\x50\x3b\xdb\x90\x97\x33\xc8\xf4\x1d\x56\xa0\xc7\xdb\x28\x6d\xc1\x0b\x09\xf0\x56\xda\x3c\xfb\x67\x9b\x68\xc8\xbc\x61\x0e\x6f\x88\x37\xd4\xdb\xd2\x08\x37\x12\xb7\x29\xcd\x7a\x0c\xce\x33\x9c\x55\x42\x95\x3c\xde\x52\x85\xab\xc4\x6d\x8c\x1a\x63\xb3\x77\xa8\x95\xdb\x42\xbd\x89\x01\x89\x95\x48\x78\x03\x1e\xae\x19\xf7\x9b\xe9\x71\x55\x15\x8f\x73\xa2\x51\x89\xf6\x9f\x18\x1a\xa8\x7f\x28\x97\x84\x59\x24\x9b\x6d\xa5\xd8\x53\xab\x0b\x65\x79\xe5\xac\xb5\x35\x95\x7a\xb2\x49\x6b\x52\xc3\xff\x54\xbd\x4a\xef\x4f\x9a\xd2\xfb\xe3\x88\xb3\x65\x7d\x58\xfa\x8c\x81\xf5\x2d\xd2\x07\x6a\x7e\xa1\xe6\x17\x06\xf8\x4e\xcd\x77\x51\xa2\xaa\xb5\x62\xf8\x4a\x72\x5f\x56\xaf\x74\x05\x54\x57\xa4\x32\x25\x3d\x6d\x5f\x4b\x5c\x1b\xf5\x9d\xce\x54\x25\x8b\xca\xda\xa8\x2f\x3a\x0f\x98\x25\x6e\x35\x43\x56\x40\x5b\x21\x53\xcd\x52\xe7\x71\xb6\x72\xab\x1a\x19\xa9\xa6\xc8\x38\x35\x40\xfa\x29\x2f\x2d\xd8\xaa\x81\xb4\x83\x78\xd7\x6d\x17\xd5\x4f\x56\x22\xd7\x0f\x7e\x7f\xde\x39\x4b\xa9\x3e\x9c\x8f\x22\xf9\x33\x07\x2a\x84\x56\x40\x16\x60\xf4\x09\xca\xe4\x22\x93\x43\x9b\x13\x7c\xef\xcc\x7b\x27\xc6\x6c\xe5\x4f\x65\x93\xe6\x16\xc2\xd5\xed\x50\xde\x4b\x69\x07\x07\xdb\x12\xf8\xc5\xb4\xc5\xc1\xf7\x21\xbc\xd3\x8a\x57\xb9\xc8\xbb\xdb\xfe\xf3\x5e\x65\x79\x4b\xd5\xee\x33\x6a\xeb\x19\x25\x67\x54\x58\xce\x29\x25\xa7\x54\xf8\xe1\x4f\xbb\xbb\x3f\xc9\xff\x68\xdc\xc7\xf9\x87\xc6\xc9\x47\xf8\xfa\x51\xee\x47\x65\x1f\xad\xfc\xa8\xfe\x23\xc7\x47\xca\x1c\x77\xc8\x6c\xed\x5e\xf0\x8e\x9a\xf2\xce\xb1\x77\x8c\x51\xef\xa8\xc2\x17\x95\xfb\xc5\x4f\x5e\x34\x76\xf8\x77\x7b\x37\xee\x0e\x0b\x2f\x29\x7b\xbe\xe6\xf9\x85\xcf\x9b\xbb\x06\x77\x74\xcb\x0e\x95\xf3\xd4\x94\xa7\xd6\x3d\xb5\xf5\xa9\x4f\x9e\x72\x2c\x78\x42\x45\x6e\x77\x6f\x37\x16\x6c\x57\xee\xc7\x47\x3d\xee\x7f\xdc\x7c\xf4\xe1\x81\xee\xc8\x2d\x2b\xb6\x18\x5b\xb7\xa8\x85\x5b\x54\xe1\x16\x15\xb5\xc1\xb3\x21\x77\x83\xb9\x70\x83\xba\xfd\xb6\x24\x77\xce\xad\x85\xb7\x1a\x89\x37\xa9\x1b\x57\xd5\xba\xb7\xde\xa0\xae\x1b\xe5\x76\xcb\xaa\x9a\x55\xc6\xfa\x55\xca\xbd\x4a\xad\xbf\x52\x5d\x01\x67\xd6\x62\x15\x75\x91\xe7\x22\x63\x51\x8d\xdf\x5d\x37\xc5\xef\x5e\x88\xe1\x05\xd0\xf9\x83\xfd\xee\x36\xf9\x09\xe3\x5c\xf9\xe6\x38\xa7\xe9\x77\x6b\x07\xef\x9f\xde\x25\xbf\x64\xf7\x34\xf5\xe9\x54\x55\x33\xa5\x9b\x7b\x8a\x56\x38\x59\x79\x27\x87\x86\x97\xac\x98\xb8\x6e\xe2\xbd\x13\xcd\xea\xaa\x6c\x77\x4e\x95\x92\xaa\x9a\x2a\x63\x7d\xd5\xf1\x2a\xc3\x5d\xa5\x62\xf3\x63\xc6\x39\x88\xdc\x42\x53\xa4\xe9\x36\x0b\xcd\x51\xdc\xe4\xd7\x99\xcf\x9b\xae\x90\xb1\x43\x53\xdd\x65\xa8\x59\x30\x72\xc5\xc8\x75\x23\xcd\x11\x83\xd3\xdd\x43\x07\x7b\xdc\x91\xa5\xca\x5b\xda\x22\xb2\xa4\x04\x47\x22\x07\xbb\x07\x1b\x49\xa5\x89\xe3\x5a\xe7\xb7\x1a\x17\xad\x22\xc7\x45\xe5\x47\x8e\xe3\xe0\x36\x4e\xe5\xcb\xb8\x9c\x48\x7f\xa4\x11\x19\x39\x25\x72\x45\xa4\x19\xc9\xe9\xda\x58\xdf\x5a\x39\xd4\x0e\xb5\x7e\x5b\xf9\xd8\xec\xec\x61\x3b\x5c\x7e\x36\x7c\x57\x59\x75\xbd\x5a\x53\x9f\x39\x56\xff\xe9\x1d\x5d\x55\xef\x5c\x53\x2f\xe3\xaa\xaa\x2b\xb6\x29\x75\x43\xe5\xaa\xeb\xaf\x97\x81\xc9\xc3\xea\xf3\xc6\x56\xd4\xd7\x24\x57\x0e\xab\xaf\xe5\xc1\xab\x1f\x56\xf2\x10\x95\xbc\xad\xb5\x0c\xac\xac\xab\x5b\x94\x6d\xff\xa8\xba\xec\xec\x45\xd9\x02\x65\x4f\xae\xb3\xdf\xeb\x16\x5d\xc4\xdb\x22\xc9\xce\xae\xab\xb3\x25\x20\x5e\x16\xd5\x29\x18\x75\xf0\xeb\x68\x79\x5e\x24\xfa\x35\xbb\x4e\xd5\x2d\xaa\x93\xba\x45\x2a\x5b\xea\x34\x2d\xe2\xfd\x22\x3d\x58\xab\x83\x31\xb9\x8e\x27\x06\x40\x12\x30\x99\x6d\xab\xb5\xad\x05\x5e\x13\x38\x1e\x3b\xae\xe7\x7e\xb2\xc0\xd1\x8f\x1b\x4b\xe0\xcf\xb3\x7e\xcc\x87\xb9\xb5\x3c\x16\xf8\x3b\x65\xcd\xff\xf4\x0d\xf7\x9f\xfc\x3f\xde\xbd\x7e\xf7\x27\xf0\x65\x58\xc5\xa8\x54\xf9\x9b\x9c\x50\xf9\xca\x90\xe5\x2a\x96\xfb\x4a\xad\x2c\x90\xe5\xb2\x96\x14\x35\xbf\x7a\xf5\x51\xc3\xe9\xbb\x54\x0e\xd1\x7f\xbe\x5c\xcf\x2c\xba\xe7\xf7\xb4\xaa\x54\xd5\x4e\x85\xa3\xa1\xca\x96\xbb\x54\xf6\xca\xe1\xdf\x35\x7f\x81\xec\x92\xe3\x67\xdb\x80\x77\x1b\x77\xa1\x87\x35\x5f\xe9\xbf\x97\x74\x8b\x7a\x49\x0d\x57\xb5\xe8\xd0\x9a\x87\xf3\xc7\xc4\xdf\x53\x65\xcc\xe1\x8f\x75\xd0\x12\xfe\x9c\x6f\x04\xef\x97\xc6\x31\x79\x53\x0e\xca\x44\x63\x97\xf1\x39\xb7\x93\x47\x83\xfe\x45\xc8\xb7\xaa\x88\x76\x18\x1e\x3e\x15\x54\x30\x8c\x3b\xdb\xb9\x3f\x3b\xf0\x22\x8c\x3b\xd4\x25\xdc\xd7\xd6\x07\x58\x8e\x7e\xa7\x3f\x90\x50\xff\x0f\xe8\x1a\x2a\x2f\xc0\x18\x22\xcb\xb8\xfd\x34\xfe\xfc\xaa\x6c\x1b\x66\x98\xf8\x9b\x78\x13\x1a\x1f\x5c\xa5\xe6\x1c\xe3\x49\xc3\x38\x73\xb3\xe8\xaf\xe7\xe7\x41\x53\xd5\xfb\x78\x79\xbd\x39\xe0\x77\xf1\xf9\x3f\xfc\x98\xe3\xd8\x2f\x3a\x98\x99\xdc\x8a\x7f\xe7\xc7\xe8\x26\x91\xbe\x93\x46\x9e\xff\x98\x99\xc1\xad\x79\x9c\xff\x78\x23\xcf\x3f\xcc\xff\x83\x39\xf5\x7f\xb3\xe1\xbc\xd1\x9a\xcf\x68\xf1\x7f\xe1\x5b\xe6\xab\x75\xe4\x38\x5a\xaa\x44\xd5\x9e\x8c\x7f\x2d\x1f\xfe\xfe\x08\xfd\x6b\x7e\x55\x8e\xad\x2c\x3c\xa4\x75\xec\x0b\x7c\x12\x74\x75\x83\x36\x40\xa7\xa9\x45\x10\x0e\x45\x2e\x74\x21\xb4\x09\xfa\x5c\x24\x2c\x09\xe2\xb9\x05\xfc\x16\x5b\x44\x5a\x2e\x17\xae\xf9\x50\xbd\x48\xc4\x22\xe8\x5d\x91\xc8\xed\x22\x51\x4b\xa0\x1f\x45\xa2\xd1\x15\x4d\x1b\x83\x8d\x18\x64\x62\x91\x89\x7b\x53\xa4\xd5\x66\x91\xf8\xbe\x22\x7a\xe6\x25\x60\xa7\x0d\xf2\x89\x14\x7f\x52\x06\x04\x06\xc9\xe8\x4d\xa6\x75\x53\x5f\x6e\x74\xa6\xd2\xa6\x7e\x2a\x92\x86\x2f\xe9\x3b\x45\x32\x3d\x10\x7a\xdb\x7d\x29\xd2\x1e\x1b\x59\xf8\xdd\x01\x3d\xd9\xe8\xeb\xc4\xd8\xce\x57\x89\xe4\xdc\x02\x1d\x14\xc9\xe5\xf8\x92\x8b\xfd\x5c\x6c\xe6\xa2\xab\x2b\x31\xe4\x31\x3e\x8f\xf1\xf9\x6b\x44\xba\xa1\xb3\x7b\xae\x48\x0f\xf4\xf6\x44\x5f\x2f\xa8\x80\xb1\xbd\x4b\x45\xfa\x56\x40\xbc\x17\x82\x93\x17\xdf\xbc\xbf\x8a\x0c\xc0\x8f\x81\x7b\x44\x06\x61\xa7\x68\x16\x44\x7f\x31\x76\x4a\xd0\x5d\x8a\xcf\x43\xb1\x35\x0c\xb9\x11\xaf\x8a\x8c\xbc\x4e\x64\x14\xf1\x96\xe1\xdb\x68\xec\x8e\xee\x24\x32\x06\xfc\xc6\x62\xb3\x9c\x8a\x1f\x87\xbf\xe3\xf0\x63\x02\x63\x2a\xc0\xa7\x8a\x3c\x54\x83\xfd\x44\xb0\x9e\x04\x6f\x12\xe3\x26\x21\x3f\x25\x0e\x42\x7e\x0a\x3a\x6b\xf0\xa9\x06\x9b\x53\xd1\x3b\x0d\xfe\x34\xda\xe9\x60\x39\x7d\xa5\xd8\xbf\xf6\xad\x65\x3e\xd6\xd2\x3f\x03\xb9\x19\x60\x33\xe3\x90\xc8\x4c\x80\x9e\x49\x7b\x5e\x4b\x08\xd9\xf3\xe6\x41\x1b\x21\xec\xe9\xff\xd4\x7b\x36\xf1\xcf\x46\x7e\x36\x78\xcc\xde\x01\x31\x7e\x0e\xfe\xce\x01\xf7\x39\xc4\x39\xe7\x61\x88\xb8\xe7\x82\xe1\x5c\xe2\x9c\xc7\x98\x79\x60\x3e\xaf\x16\x02\xab\x79\xf8\x35\x1f\x1d\xf3\xf1\xfd\x7c\x62\x3c\x1f\x1f\xce\x27\xf6\xf3\x77\x43\x60\xb2\x80\xf1\x0b\xa9\x97\x85\xe0\x74\x81\xfe\x4f\x52\x7b\x41\x60\x77\x01\x3e\x5c\x80\x0f\x75\xc4\x51\x87\x5f\x75\xf8\x55\x07\xaf\x8e\x98\xf4\x3f\x2d\xb0\x08\x9d\x8b\xd0\xb5\x08\x5d\x8b\xd0\x75\x11\x7a\x2e\x22\x8e\xc5\xc4\xb1\x18\xf9\xc5\xc8\x2f\x46\x7e\x31\x3a\x2e\xa6\x86\x96\x20\xbb\x04\xd9\x25\xe4\x72\x09\xeb\xf3\x25\xe4\xf9\x92\x32\x91\xa5\xd4\xc0\x52\xf0\x5b\x8a\xd2\xa5\xc4\xb0\xf4\xdd\xe0\xaf\x21\xe9\x5b\xc6\xb8\x65\xf8\xb6\x0c\xdf\x96\xe1\xff\x72\x7c\x59\x8e\x7f\xcb\xe9\x5b\x0e\xa6\xcb\xc9\xcb\x72\x62\xbf\x14\x0c\x2f\xa5\x0e\x2e\xa3\x0e\x2e\x23\x37\x97\x51\x63\x97\x51\xeb\x97\x91\xab\x15\x8c\x59\x81\xfe\x15\xf8\xb3\x82\x9c\xad\xc0\xd7\x15\xc4\xbd\x12\xfb\x2b\xd1\xb3\x12\x3d\x2b\xd1\xb3\x12\x3d\x97\xe3\xcb\x15\x35\x10\x72\x57\x20\x77\x05\x72\x57\x21\xb7\x8a\x58\x57\xc1\x5f\x05\x7f\x15\xfc\x55\xf0\x57\xc3\x5f\xcd\xf8\xd5\xf8\xbd\x9a\x5c\xae\x06\xe7\xab\xf1\xed\x6a\x70\xbf\x1a\x2c\xae\x06\x8b\x35\xd4\xc7\x1a\x72\xb6\x06\x0c\xae\x01\x8b\x6b\xc0\xee\x1a\xe2\x58\x8b\x4f\x6b\x91\x5d\x4b\x7c\x6b\xb1\xbd\x16\xdb\xd7\xa2\xef\x5a\x74\x5c\xc7\xf8\xeb\xc8\xdb\x75\xd4\xf1\x75\xe0\x74\x3d\x3e\x5d\xef\x85\xa8\xcb\xeb\xb1\x7d\x03\x75\xb0\x0e\x3f\xd6\x11\xdf\x3a\xe2\x5b\x4f\xce\xd6\xa3\x6b\x3d\xf1\xad\xc7\xde\x8d\xc8\xdc\xc4\xd8\x9b\xa8\x93\x9b\xc1\xe5\x66\x7c\xbf\x99\xfa\xb9\x99\x5a\xb9\x19\x2c\x6f\xc6\x87\x9b\xf1\xe1\x16\xec\xdd\x82\xff\xb7\xe0\xc3\x2d\x8c\xbb\x05\x1f\x6f\x25\xaf\xb7\xa2\xff\x56\xde\x6f\xd5\xef\xc8\xdd\x86\x4f\xb7\x53\x0f\xb7\x13\xe3\xed\xfa\x99\xf9\xb3\x01\xac\x37\xa0\x73\x03\xb2\x1b\xc8\xe7\x06\xf0\xb8\x03\xec\xef\x80\x77\x07\x78\xde\x81\x9d\x3b\xc8\xd9\x9d\xf8\x76\x27\xbe\xdd\xc9\xf8\x3b\x89\xff\x4e\x6c\xdf\x89\xce\xbb\xa8\xc3\xbb\x90\xbd\x8b\xf1\x77\x11\xc7\x46\xc6\x6e\x64\xae\xdd\xcd\x98\xbb\xf1\xfb\x1e\xea\xe0\x5e\x64\xee\x45\x7e\x13\x63\xff\x44\xfe\xfe\x4c\x4d\xfc\x19\xdc\xfe\x8c\x0f\x7f\x01\x8b\xcd\xf4\x6f\xc6\xee\x5f\x19\x7f\x1f\xef\xf7\x63\xe7\x7e\x7c\xdb\x82\xed\x07\xf0\xff\x41\xe6\xc7\x43\xe8\x7d\x08\x7f\x1e\xc2\xe6\xc3\xe0\xf2\x08\xf5\xa7\xff\xd9\x80\x47\x79\xde\x4a\x8e\xea\xc9\xe9\x36\xea\x75\x1b\xf3\x69\x1b\xba\x1e\x83\xf7\x38\xf6\xb6\x83\xcd\x76\xe2\x7f\x02\x9f\x9f\xe4\xfd\x29\xfa\x9f\xc2\x97\xa7\xc8\xe9\x0e\x74\x3c\x8d\xad\xa7\x89\xfb\x19\x72\xf5\x2c\x31\x3e\x4b\xcd\xee\xc4\xe7\xe7\xa8\xbb\x5d\xd8\xdc\x05\xfe\xcf\x33\x76\x37\x31\xbe\xc0\xd8\x17\xc8\xef\x8b\xbc\xbf\x04\xde\x7b\x78\xdf\x43\x8c\x7f\x23\xef\x2f\x93\xb3\x57\xb0\xff\x0a\x31\xbc\x82\xcc\xab\xd8\x7d\x15\x9c\x5f\x25\x86\x57\xd1\xf9\x2a\x98\xbc\x46\xcc\xaf\x11\xeb\x6b\x60\xf0\x1a\x73\xe8\x35\xea\xed\x35\x7c\x78\x0d\x7b\xaf\x81\xc5\x6b\x8c\x7b\x9d\x98\x5e\x47\xef\xeb\xd4\xc9\xeb\xd8\x7c\x9d\x5c\xbf\x4e\x0d\xbd\x8e\x8f\x6f\x90\xd3\x37\xc8\xd7\x1b\xd8\x7a\x03\xde\x1b\x60\x4c\x28\xf2\x26\xfa\xde\xa4\xbe\xf6\x32\x76\x2f\xeb\xe9\x5e\xb0\xd8\x0b\x2e\x7b\xa9\xa9\xbd\xe0\xf5\x77\xf4\xee\x43\x66\x1f\xf6\xf6\x61\x6b\x1f\xb6\xf6\x21\xff\x16\x3a\xdf\xc6\xdf\xb7\x91\x7b\x07\xdf\xde\x41\xe6\x1d\x64\xde\xe5\xf9\x5d\xfc\x7c\x97\xf7\x77\xf1\xf3\x5d\x7c\x7c\x17\xd9\xfd\x8c\x3d\x80\xfe\x03\xd4\xd9\x01\xe2\x3a\x80\x8e\xf7\x90\x7b\x0f\x99\xf7\x90\x79\x0f\x99\xf7\xe0\x1d\x24\xf6\x83\xcc\xdd\x83\x60\x78\x10\xfd\x07\xc1\xe8\x7d\x62\x7a\x9f\x3c\xbe\x4f\x3c\xef\x83\xd7\xfb\xd8\xfc\x00\x3b\x1f\x60\xe3\x03\xf4\x7d\x40\xbe\x3e\x20\x27\x1f\x82\xe1\x87\xc4\xfe\x21\x7e\x7c\x88\xbd\x0f\xc1\xee\x10\x79\x39\xc4\x3a\x74\x88\xb8\x0f\x81\xfd\x21\x72\x72\x08\x3b\x1f\x31\xfe\x23\xf2\xf7\x11\xcf\x1f\x53\x27\x1f\x93\xe7\x4f\xc0\xe3\x13\x7c\xfb\x14\x5f\x3e\xc3\xf6\x61\xfc\x3a\x42\x1e\x8f\xf0\x7e\x04\xb9\xcf\xf1\xe3\x0b\xfc\x3b\x8a\x9d\xa3\xd8\x3e\x8a\xec\x51\xec\x36\x80\x75\x03\x35\xdc\xc0\x1c\x6f\x40\xee\x4b\x70\xfe\x12\xde\x97\xf0\xbe\x62\x0d\xfe\x1a\x9f\xbe\xc1\x8f\x6f\xa8\x93\x6f\xe1\x7f\x87\x7f\xdf\x13\xcf\x31\xf0\x38\xc6\xfb\x31\x6a\xee\x38\xb8\xfe\x13\xdc\xff\x45\x0d\xff\x40\x2e\x7e\x20\xff\x3f\x32\xfe\x27\xb0\xf8\x89\x71\x3f\x33\xe6\x17\xe2\xff\x15\xbf\x7f\x25\x71\x27\xf0\xf9\x24\xfc\x53\xc4\x70\x4a\xff\xfd\x05\x30\x38\x43\xbf\x8f\xda\xf2\xa1\xcf\x7f\x1d\xf7\x35\x7d\x63\xdf\xc3\x7d\x6e\x91\x28\xa3\xaf\x28\xd3\x82\xb6\x70\xb4\xa8\x11\xe5\x28\x17\xe5\xec\x06\x9d\x16\x15\x12\x02\x7d\x2e\x2a\x74\xb9\xa8\xb0\x59\xa2\x5a\x70\x57\x6c\xf1\xa6\xa8\x96\x57\x89\x0a\xcf\x80\x78\x8e\xb8\x45\x54\xe4\x12\x51\x51\x49\x10\xfd\x51\xf4\x45\x67\x41\xbb\x39\x0c\x23\x13\xcb\x71\x25\xf6\x4b\x51\x71\xfb\x44\xb5\x7a\x57\x54\x6b\xec\xc7\x97\x41\x9f\x42\xc7\x45\x25\x1c\x14\xd5\x06\xdb\x6d\x37\x88\x4a\x4c\x80\xd0\x97\x94\x0b\x6d\x17\x95\x3c\x1c\xda\x21\x2a\x05\x7d\x29\xc8\xbb\xe9\xf3\xe0\xb3\x87\x71\xa9\x3c\xa7\x21\x9f\x86\xce\xf4\x0a\xe8\x90\xa8\x8c\x7a\x51\x99\xe8\x6a\x47\x7c\xed\x18\xd7\xbe\x14\xfa\x56\x54\xd6\x42\x51\x1d\xf0\xad\x23\xf1\x74\x44\x26\x7b\x93\xa8\x4e\xc4\xd8\xe9\x55\x51\x9d\x27\x42\xf8\xd7\x05\x7b\x5d\xc0\x24\x67\x8d\xa8\x5c\x78\xb9\xf3\x44\x75\xc5\x8f\xae\xc4\x9f\x07\x26\xf9\xc4\x92\x8f\xad\x6e\xf4\x77\x27\xc6\x1e\xe8\xef\x09\x46\xbd\xe8\x2f\x00\x87\xde\x5f\xda\xff\xc4\x8e\xea\x4b\x3c\xfd\xc0\xab\x3f\x63\xfb\x23\x53\x08\x36\x5e\xe2\xf5\x22\x37\x00\x9f\x07\xe2\xf3\x40\xda\x41\x51\xd0\x66\x51\x45\x45\x10\x7e\x14\x63\xa3\xb8\x16\x22\xbe\x62\xf4\x17\x23\x53\x4c\x7f\xf1\x8f\xa2\x4a\x90\x29\x01\xbf\xc1\xf8\x35\x18\xbf\x06\xa3\x7f\x30\xba\x07\xff\x2a\xaa\x14\xdd\xa5\x0f\x43\xe0\x33\x24\x0e\xc2\xcf\x21\xc4\x36\x84\x98\x87\x6c\x84\xb0\x3b\x14\xfc\x86\xa2\x77\x28\xfa\x86\xa2\x6f\x18\xfa\x86\xe1\xd7\x30\xb0\x18\x86\xdf\xc3\x19\x37\x9c\xf7\xe1\xc4\x3f\x02\xcc\x47\xa0\x6f\x54\x4b\x08\xde\x28\xfa\xcb\xa8\x91\x32\xc6\x8d\x06\xd7\xd1\xe0\x39\x06\xbd\x63\xd1\x39\x96\x7a\x19\x8b\xce\xb1\xc8\x94\x83\x6f\x39\xfe\x97\xd3\x57\x8e\x2f\xe3\x88\x7f\x1c\x7e\x8e\x23\xdf\xe3\xc0\x64\x3c\x7e\x8d\xa7\x86\xc6\xa3\x7b\x02\x18\x70\x6e\x52\x13\xb0\x5f\x01\x0e\x15\x60\x5a\x81\xfe\x4a\x64\x2a\xe1\x57\x12\x7f\x25\xf9\xa8\x24\xbe\x2a\xf4\x54\xa1\xa7\x8a\x71\x55\xe8\xad\xa6\xce\xaa\xb1\x55\x4d\xdc\xd5\xc4\x54\x0d\x0e\xd5\xf8\x34\x91\x5c\x4f\xa4\x86\x26\x52\x1b\x93\x7a\x41\xf4\x4d\xe2\x7d\x12\xb9\x99\x8c\xbd\xc9\xd4\xc5\x64\xe4\xa6\xa0\x6f\x0a\x7d\x53\x18\xc7\x92\xa6\x6a\x88\xa9\x66\x25\x44\x7f\x0d\x18\xd7\x90\xd3\xa9\xf0\xa6\x12\xfb\x54\x78\x53\xf1\x7d\x1a\x75\x33\x0d\x9b\xd3\xc0\x74\x1a\x7e\x4d\xc3\xc6\x74\x70\x9a\x4e\xec\xd3\x91\xaf\xc5\xe7\x5a\xe2\xae\xa5\xe6\x6b\xe9\x9b\x41\x9c\x33\xf0\x77\x06\xcf\x33\xc1\x6e\x26\x18\xcc\x44\xee\x3c\xe2\x3b\x8f\x71\xe7\x61\xef\x3c\x30\x9b\x05\xc6\xb3\xf0\x67\x16\xf5\x3b\x8b\x18\x67\xa1\x7b\x16\xf9\x9a\xed\x81\xa8\xd1\xd9\xd4\xf4\x1c\x72\xc9\x39\x4e\x71\x8e\x53\x73\x78\x9f\x4b\xee\xe6\x82\xd7\x5c\xf4\xcd\xc3\xcf\x79\xf8\x34\x0f\xbb\xf3\xc0\x6f\x3e\x39\x99\x4f\x2d\x9d\x8f\xfc\x02\xfa\x16\x80\xe3\x02\xe2\xbc\x90\xb8\xeb\xc0\xad\x0e\x3b\x75\xe8\x58\x04\x1e\x8b\xc0\x6b\x11\x31\x2e\x22\xe6\x8b\xf0\xe3\x22\xf4\x5e\xb4\x5e\x14\x67\x33\xb5\x18\x9d\x8b\xd1\x79\x31\xb9\xb9\x18\xfb\x17\x33\xee\x62\xde\x97\xf0\xbe\x04\xb9\x25\xd8\xba\x04\xdd\x4b\xc1\x6f\x29\xb2\x4b\x79\x5f\x46\x5d\x2e\x47\xcf\x72\xfc\xbe\x14\xbd\x97\x12\xfb\x65\x8c\xbb\x0c\xfb\x9c\xaf\xd4\x0a\x78\x2b\xc8\xf7\x4a\xd6\x1a\xce\x54\x6a\xa5\x7e\x26\x9f\x2b\x91\xbb\x1c\x0c\x2e\x27\x4f\x57\xd0\x77\x05\x7e\x5d\x41\x0c\x57\x32\xf6\x4a\xfa\xaf\x22\x96\x55\xd4\xe7\x2a\x72\xb1\x8a\xf9\xb7\x0a\x7c\x56\x61\x6f\x35\x18\xaf\x06\xc3\xd5\xd4\xc8\xd5\xe4\xe7\x6a\x62\xba\x1a\x5d\x2c\x8d\x6a\x0d\x7e\xae\x61\xfe\xac\x21\x3f\x6b\xc0\xf4\x1a\xf0\xba\x86\x5a\x58\x4b\x0e\xd7\x12\x1f\xe7\x29\xb5\x16\xd9\x6b\x91\xbd\x1e\x9b\xd7\xa3\xff\x06\xf4\xaf\xd3\x04\x3e\xeb\x19\xbf\x1e\xfc\xd6\x13\x1b\x67\x26\xb5\x1e\xdf\x6e\x44\xf6\x46\xda\x9b\xd0\x79\x33\xf5\xc5\x19\x49\xdd\x02\xae\x9c\x85\xd4\x6d\x60\x74\x1b\xcf\xb7\x53\x93\x9c\x7f\xd4\x06\xf2\x7d\x07\xe3\xef\x00\xb3\x3b\x99\x53\x77\xe2\xf7\x5d\xc4\xbf\x11\xbd\x1b\xe1\xdd\x4d\x6c\x77\x83\xfb\x3d\xc8\x6f\x22\x2f\x9b\x88\xe3\xcf\xc4\xb3\x99\xf9\xbd\x99\x1c\x6c\x66\xcc\x66\x62\xfc\x2b\xf5\xf2\x57\x6a\xeb\x3e\xc6\xdd\x87\x5f\xf7\x83\xdb\xfd\xd8\xbf\x9f\x9a\xe4\x1c\xa3\x1e\x20\xae\x07\x91\x7f\x08\x7c\x1f\x42\xfe\x61\x62\x7e\x84\x1a\x78\x84\xf1\x8f\x32\xee\x51\x6c\x6c\xa5\x96\xb6\xe2\x77\x3d\xba\xb7\x21\xfb\x18\xf9\x78\x1c\x4c\xb7\xe3\xf3\x13\xe8\x7f\x12\xdd\x4f\xd2\xff\x14\xf9\xdb\x81\x9e\xa7\xc1\xf1\x69\x62\x78\x06\x1d\xcf\xa2\xef\x59\xe2\xdc\x89\xcf\xcf\x61\xfb\x39\xf8\xbb\xc0\x7a\x17\x32\xbb\xe0\x3d\xcf\x7c\x7f\x9e\xb9\xf4\x3c\xb5\xb0\x1b\x3d\xbb\x77\x8a\x7a\x01\x3d\x2f\xe2\xc3\x8b\xe0\xfe\x12\x7d\x7b\xb0\xb3\x07\xb9\x3d\xe0\xff\x37\xf4\xfd\x0d\xbd\x2f\x83\xcf\xcb\xcc\x97\x97\xa9\xe9\x97\xc9\xc5\xcb\xe4\xe2\x15\xe2\x7b\x95\xbc\xbf\x86\x7f\xaf\x81\xc7\xeb\xd8\x78\x9d\x5a\x78\x83\x9a\x7a\x03\x8c\xde\x24\x9e\x37\xd1\xf3\x26\x3a\xf7\x92\xc7\xbd\xe4\xf1\x1f\xd0\x3e\xfc\xd9\x87\xff\xfb\xf0\xf3\x2d\xc6\xbe\x8d\xcc\xdb\xc8\xbc\x8d\x4f\x6f\x63\xef\x6d\xf0\xe2\x3c\xa2\xde\xc6\xee\xdb\xe4\xe1\x1d\xf8\xfb\xb1\xbf\x1f\xfb\x07\x88\xf7\x00\xb8\x1d\xc4\xb7\x0f\x98\x97\x1f\x52\x0b\x1f\xe2\xc7\x21\x74\x7d\x84\x2f\x1f\x13\xcf\x27\x60\xfc\x09\xfd\x9f\x82\xd9\x67\xf8\xf3\x19\x36\x0e\xb3\xee\x1d\xa6\x36\x3e\x27\x07\x5f\x90\xd7\xa3\xe4\xf1\x28\xf8\x34\x90\xf3\x06\x62\xf9\x12\xfe\x57\xf8\xf1\x15\x7e\x7c\x05\x66\x5f\xe3\xe3\xd7\xc4\xf3\x0d\xd8\x7c\x83\x9e\xef\xf0\xeb\x3b\xfc\xfa\x9e\x3a\xfa\x9e\x7a\x3e\x8e\x4f\xff\xe2\xf9\x5f\xd8\xfd\x81\xf7\x9f\xf0\xe3\x27\x62\xfa\x19\x7c\x7e\xc1\xce\x2f\xd4\xd8\x2f\xf8\xfe\x2b\xbe\x9d\x00\x8f\x13\x3c\x9f\x40\xee\x04\xbe\x9f\x04\xeb\x93\x8c\x3d\x45\x2e\x4f\x63\xe3\x0c\xef\x67\xa8\xaf\x33\xf8\xed\x5f\x23\x86\x74\x12\x43\x15\x41\xc7\xc5\x30\x0e\x8a\x61\xbe\x2a\x86\xf5\xa9\x18\x0e\xc8\x59\x2f\x86\x0b\x99\x10\x78\x61\x02\x7d\x2b\x46\x8b\x43\x62\x84\x27\x88\x11\x51\x26\x46\xe4\x6e\x31\xa2\x79\x8e\x66\x6c\xcc\x46\x31\x62\x17\x89\x11\x37\x1c\x42\xa6\xd5\x3c\x68\x13\xf4\xae\x18\xad\x19\xc7\x5e\x6e\x24\xbc\x29\x46\x9b\xf5\x62\x24\xb6\x14\x23\x89\xfe\x24\xc6\x24\xc1\x4b\xe6\x39\x25\x04\xd2\xed\x4e\x31\xdc\x49\x50\x0d\xb4\x19\xfa\x55\x8c\xd4\x5a\x31\xd2\xb1\x97\x31\x51\x8c\xcc\x72\x31\xda\xe1\x4b\xbb\x87\xc5\x68\x8f\x4c\x16\xfe\x67\xa1\xa7\x03\x3a\x3b\xc0\xeb\x58\x2a\x46\x76\xae\x18\x9d\x2c\x31\xba\xa0\x93\xeb\x8b\xd1\x15\xca\xd3\x84\xbf\xf9\x57\x89\xd1\x0d\x1f\xbb\xc7\x41\x5f\x8a\xd1\x03\x5e\xcf\x25\x62\xf4\xf2\x8a\x51\x00\xaf\x60\x9f\x18\xbd\xd1\xd7\x67\x96\x18\x7d\xd1\xdf\x0f\x7d\xfd\xa1\xc2\x5e\x62\x78\xd1\xe7\xc5\xdf\x01\xf0\x07\x10\xcf\x40\x74\x0e\xdc\x22\xc6\x20\x74\x14\x2d\x14\xa3\x98\x38\xd9\x7f\x8d\x52\x7c\x2a\x05\xb3\x21\x2b\xc5\x18\xca\xb8\x61\x60\x34\x8c\x38\x86\x23\x3b\x7c\x87\x18\x23\xc0\x60\x24\x71\x8c\xc2\x66\x19\xb1\x96\x21\x5f\x46\x6c\x65\xd7\x89\x31\x9a\x31\x63\x88\x77\x2c\xfc\xb1\xd8\x2a\xdf\x2e\x06\x7b\xa4\x31\xbe\x42\x8c\x09\xf0\x26\xe0\x5f\x05\x32\x95\x8c\xad\xc2\x9f\x2a\x74\x57\xe1\x5f\x15\x31\xb0\x07\x1a\xec\x81\x46\x15\xbe\x55\xe3\x5b\x35\x38\x54\xe3\x6b\x35\xbe\x55\x33\xa6\x1a\x5d\xd5\xc4\x3c\x11\x3d\x13\xc1\x73\x22\x58\x4c\xc4\x9f\x49\xc8\x4c\x42\x66\x12\xf9\x9a\x84\xfe\xc9\x60\x37\x19\xbf\x27\x13\xcb\x64\x78\x53\xf0\xad\x86\x1a\xa9\xc1\x46\x0d\x36\x6a\xb0\x31\x15\xac\xa6\xc2\x9b\x4a\xce\xd9\x07\x8d\xa9\xe4\x7c\x5a\x14\x04\x6f\x1a\x72\xd3\x90\x9b\x9e\x01\x6d\x80\x88\x83\x23\xa7\x51\x4b\x3b\xe3\x16\x31\x66\x82\xed\x79\xdd\xa0\xd3\x62\xcc\x22\xdf\xb3\xc1\x62\x36\x31\xcf\x21\x2f\x73\x89\x6b\x5e\x16\x04\x5e\xf3\xf1\xf7\x7c\xf8\x0b\xd0\xb9\x10\x9f\x2f\x40\xff\x85\xe8\xb9\x10\x9f\xeb\xf0\x79\x11\x72\x8b\xb0\xbb\x08\xdc\x2f\x42\x76\x31\x76\x2f\x26\xe6\x8b\xd1\x71\x31\xf1\x5d\x8c\xcc\xc5\xc4\x75\x31\x31\x2d\x21\x86\x25\xe4\xf5\x12\x30\xbb\x84\x9a\xbe\x04\x1d\x97\x7c\x2e\xc6\x52\xfc\x5f\xba\x07\x42\xc7\x32\xec\x2c\x23\x37\xcb\xd0\xb9\x1c\x4c\x2f\x25\x2f\x97\xa2\xf7\x32\x6c\x5e\x86\xae\xcb\xc8\xc3\x65\xfa\x9d\x71\x2b\xb0\xb3\x02\xdf\x56\xf0\xbe\xb2\x2f\x84\x6e\xf6\x2b\xe3\x72\xfc\xbc\x9c\x38\x2e\xe7\xf9\x0a\x6c\x5e\x41\x6d\x5c\xc9\xb8\x2b\x89\xe7\x2a\x7c\xb9\x8a\x9a\x5e\x85\xbe\x55\xe4\x63\x95\x7e\x06\x93\xd5\xc4\xb5\x1a\x7f\x57\x63\xf7\x6a\x70\xbd\x1a\x6c\xae\xc6\xde\xd5\xe8\xbc\x9a\x7e\xf6\x2b\x63\x0d\xbe\xb1\x57\x19\x6b\xc8\xdf\x35\xd8\xb8\x86\x98\xd6\x92\xa7\x6b\x91\xbd\x96\x39\x76\x1d\xba\xae\x67\xcc\x0d\xf8\x74\x03\x7a\xd6\x61\x93\x3b\xbd\x71\x23\x76\x6e\x62\x6e\xdc\x04\xee\x37\x83\x17\xf7\x76\xe3\x16\xe6\xf9\xad\xe8\xbd\x0d\xbc\x6e\x27\xc6\xdb\xd1\x79\x07\x7c\xee\xdb\x86\xfe\xa7\x1e\x37\x52\x53\x77\x13\xc3\x3d\xe0\x78\x0f\xd8\x6c\x22\x8f\x7f\xc2\xd6\x9f\x18\xf7\x67\xe2\xf9\x0b\xd8\x6d\xc6\xcf\xcd\xf8\xc3\xfe\x63\xdc\x47\x9c\xec\x3d\xc6\x16\xda\x2d\x60\xf3\x00\x76\x1f\xc4\xc7\x07\xf1\xe3\x21\xea\xe7\x61\x9e\x1f\xc6\x9f\x47\xc0\xe9\x11\x74\x3c\x82\xbd\x47\xc0\xe3\x51\xec\x3d\x0a\xde\x8f\x52\x07\x5b\xf1\xa5\x9e\xf7\x6d\xd8\xd9\x86\x8e\xc7\xb0\xfd\x18\xf1\x3f\x4e\x7c\x8f\x13\xfb\xe3\xc8\x6c\x27\x8e\xed\xc4\xf1\x04\x3e\x3e\x81\x0f\xdc\xad\x8d\x27\x19\xf7\x24\xf9\x7c\x92\x3a\x7b\x8a\x9a\x7d\x8a\xda\xdf\x81\xcd\x1d\xac\x5d\x3b\xf0\xf5\x69\xc6\x3e\x8d\x8f\xcf\x10\xd3\x33\xcc\xc9\x67\x79\xdf\x89\xce\x9d\xf8\xf6\x1c\x75\xbb\x0b\x4c\x76\x81\xe5\xf3\xf8\xcc\x35\xca\xd8\x4d\x4c\x2f\xe0\xc7\x0b\xd4\xc5\x8b\x60\xf2\x22\xba\x5f\x42\xe6\x25\xf8\x7b\x98\x83\x7b\xc0\xed\x6f\xd8\x7a\x19\xdc\x5e\x26\x96\x57\xc8\xdb\x2b\x8c\x7f\x15\x1b\xaf\x82\xfd\x6b\xd8\x79\x0d\xdb\xaf\x23\xff\x06\xb6\xde\x80\xff\x06\xfc\x37\xf0\xeb\x4d\xfc\xda\xcb\xfb\xdf\xc9\xd3\xdf\x19\xf3\x0f\x6c\xfe\x63\xb9\x18\xfb\xc0\x77\x1f\x3e\xed\x63\xce\xbc\x85\x0f\x6f\x21\xf3\xd6\x8f\x62\xbc\x0d\x16\x6f\x83\x33\x7b\x95\xf1\x0e\xb6\xdf\x21\xde\x77\xc1\xf2\x5d\xc6\xee\x07\xeb\x03\xd4\xc5\x01\x62\x7c\x0f\xf9\xf7\xe8\x7b\x0f\x5d\xef\x81\xe7\x7b\xd4\xc2\x7b\xe0\xf3\x1e\xbe\x1e\x24\x8e\x83\xc4\x70\x10\x2c\xdf\x27\x07\x1f\x50\x83\x1f\xe2\xcf\x21\xb0\xfa\x08\x7b\x1f\x33\xfe\x13\xda\x4f\xe9\xfb\x0c\xcc\x0f\x63\xf3\x30\x38\x1d\xc1\xd7\xcf\xd1\xf1\x05\x75\xfe\x05\xb9\x6a\x20\x96\x06\x64\xbf\x44\xe6\x2b\xc6\x7e\x8d\x9f\xdf\x80\xc1\xb7\x60\xf5\x2d\xf9\xfc\x0e\x1d\xc7\xf0\xed\x18\x79\x3a\x8e\xcd\x7f\xa2\xef\x5f\xd8\xf9\x81\x3a\xfa\x11\x99\x1f\x91\xf9\x09\x7d\x3f\x63\xff\x17\xf8\xbf\x82\xd3\x09\xe4\x4f\x30\xef\x4e\x52\xbf\xa7\x18\x7f\x1a\xbf\xcf\x80\xad\x0f\x7f\xfd\xd8\xf5\x7f\x2e\xa6\x6c\x10\x53\x4d\x14\xd3\xe8\x04\xed\x86\xf6\x89\x69\xce\x13\xd3\xf2\x40\xb9\xd0\x26\x31\x1d\x49\xd0\x41\x31\x9d\x0b\xc5\x74\x59\x50\x39\xb4\x59\x4c\xee\xa7\x66\xc8\x1e\x31\x43\xe9\x0f\xbd\x0e\x3a\x2e\x66\xd8\xa7\x62\xb6\xd8\x2e\x66\xcb\x1a\x31\xc3\x5b\x42\xb7\x88\x19\x91\x21\x66\xa4\x40\x6f\x8a\x19\xd5\x17\xc2\x46\xf4\x7a\x31\x63\x2a\xa0\x77\xc5\x8c\xc5\x7e\x2c\xb6\xe3\xb0\xc7\x3d\xd5\x6c\xb5\x46\xcc\xd6\xe8\x6c\xbd\x45\xcc\xf8\x04\x88\xf7\x84\x28\x08\xbf\x12\x36\x42\x8c\x69\x83\xee\x36\x45\x10\x7d\x6d\xd0\xdb\x36\x0b\x42\x5f\x5b\x6c\xb7\xc5\x07\xf6\x40\x33\x11\x5b\x89\xf8\x9a\xb8\x1c\xc2\xdf\x44\xe4\x12\x7f\x14\x33\x89\xd8\x92\x86\x43\xf0\x93\xf0\x2f\x69\x27\x04\x16\xc9\x8c\x49\xee\x06\xe1\x4f\xf2\x55\xd0\xc3\x10\xb6\xd8\x3b\xcd\x14\xf8\x29\xb3\x20\xe4\xd9\x43\xcd\x14\xe4\xdd\xc8\xbb\xe1\xbb\x6b\x21\xe2\x71\x13\x83\x1b\x0c\x3c\xe8\xf7\x94\x41\x2b\xa1\x7a\x08\xec\x52\x89\x3f\x15\xd9\x54\x74\xa4\xc2\x4f\x05\xf7\x54\xe4\x53\xbf\x14\x33\x8d\xd8\xd2\x7a\x41\xe0\x9b\x86\xee\xb4\x6f\xc5\x4c\x27\xfe\x74\xe2\x4b\x27\xe6\x74\x6c\xa6\xc3\x4f\xc7\x66\x06\x36\x33\x90\xcd\xc0\x66\x06\x98\x67\x10\x6f\xc6\x21\x31\x33\xc9\x4b\x26\xfa\x33\xe1\x67\x22\x9f\x49\x5e\x32\xd1\xd3\x2e\x0e\x42\x4f\xbb\x45\x10\xd8\xb5\x83\xdf\x0e\x7e\x7b\xf8\xed\xc1\xa7\x3d\xf2\xed\xf1\xa5\x3d\x3a\xb2\xe0\x65\x11\x7b\x16\xb1\x64\x61\x2f\x8b\x58\x3a\xe0\x47\x07\xb0\xea\x00\x56\xec\xff\x66\x07\xe4\x3a\xe2\x43\x47\xc6\x76\x64\x6c\x47\x7c\xe8\xb8\x03\x22\xc6\x6c\x62\xcc\x26\x0f\xd9\xe4\x21\x9b\xbc\x64\x13\x7b\x36\xfc\x4e\xc8\x77\xf2\x42\xf8\xd0\x89\x9c\x76\x02\xd3\x4e\xe4\xa1\x33\x75\xd1\x19\xd9\xce\xe0\xd1\x19\x7e\x67\x72\xdf\xf9\x57\x31\xbb\x80\x5f\x97\x52\x08\x3c\xba\xe0\x5b\x17\x70\xea\x02\x4e\x39\xe0\x94\x43\xec\x39\x60\x92\x83\xee\x1c\x78\xb9\xd4\x6d\x2e\x3e\xe7\xe2\x47\x2e\x58\xe4\xe2\x5f\x57\xec\x75\xc5\xbf\xae\xc8\x75\x25\xe6\xae\xe8\xcd\x03\x9f\x3c\xf0\xc9\xc3\xe7\x3c\x64\xf3\x90\xcd\x03\xcf\x7c\x62\xce\xc7\x56\x3e\xf1\xe5\x13\x5f\x3e\xe3\xbb\x31\xbe\x1b\xe3\xbb\x21\xdb\x0d\xd9\x6e\xc8\x76\x83\xdf\x1d\x1d\xdd\xc1\xb2\xfb\x12\x08\xd9\xee\xf0\x7a\x20\xdb\x43\xb7\xc4\xd3\x93\xe7\x9e\xd4\x70\x4f\xf4\xf5\xc4\x76\x4f\x6a\xa8\x27\x71\xf5\xc4\xff\x9e\xd8\xea\x79\x5a\xcc\x5e\xc4\xd6\x8b\x18\x7a\xa1\xbb\x17\xfd\xbd\xe8\xef\x45\x7f\x2f\xfa\x7b\xd1\x5f\x40\x7f\x01\xfd\x05\xc4\x54\x00\x5e\x05\xcc\xbf\x02\xfa\x0b\xc0\xb1\x80\x7c\xf4\xc6\xdf\xde\xc4\xdc\x9b\xfa\xea\x4d\x2d\xf5\xc6\xbf\xde\xd4\x76\xef\x57\x21\xea\xbe\x0f\x3e\xf6\x21\x67\x7d\xc0\xbb\x0f\xd8\xf6\xc1\x46\x1f\xfa\xfb\xd0\xdf\x47\xf7\x83\x6f\x5f\x70\xec\x4b\x9e\xfa\x22\xd3\x17\x3f\xfa\x12\x7b\x5f\xec\xf4\x25\x8f\x7d\x89\xa5\x2f\xb1\xf4\x63\xde\xf5\x23\x96\x7e\xcc\x9f\x7e\xc4\xd2\x8f\x3c\xf4\xa3\xbf\x1f\xfd\xfd\xe8\xef\x4f\x7f\x7f\xfa\xfb\xd3\xdf\x9f\xfe\xfe\xd4\x4c\x7f\x62\xe9\x8f\xaf\xfd\xf1\xb5\x3f\xbe\x16\x32\x6f\x0a\xf1\xb5\x10\xcc\x0a\xf1\xb5\x90\x3c\x17\xe2\x4b\x21\xb5\x55\x88\x2f\x85\xf8\xe2\xc5\x57\x2f\x79\xf1\x52\x63\x5e\x7c\xf1\x52\xbb\x5e\x6a\xd4\x8b\x1d\x2f\x76\x06\x60\x67\x00\x76\x06\x60\x67\x00\x76\x06\x90\xcf\x01\xcc\x63\xce\x86\xe6\x40\xc6\x0d\x44\xef\x40\x78\x03\xc9\xf1\x20\x62\x1f\x44\x4d\x0d\xc2\xde\x20\xf8\x83\xc0\x66\x10\x75\x32\x88\x7a\x1b\x84\xad\x22\x6c\x15\x61\xa7\x88\x78\x8b\xe0\x17\x81\x79\x31\xfa\x8b\xe1\x15\x53\x6b\xc5\xd8\x2e\x26\xc6\x62\x6c\x97\xa0\xbf\x04\x5d\x25\xd8\x2d\x01\xc3\x12\xf8\x25\xcc\x9b\xc1\xe4\x67\x30\xbc\xc1\xd4\xf7\x60\xe2\x18\x4c\x1c\xa5\xd8\x2d\x05\xcf\x52\xf4\x94\xa2\xa7\x14\x3d\xa5\xc8\x97\xa2\x67\x08\x35\x31\x84\x5a\x1a\x02\x7f\x08\xb1\x0f\x01\x9b\xa1\xe0\x32\x14\xde\x50\x78\x43\x91\x1d\x8a\xec\x50\x64\x87\x61\x73\x18\x36\x87\x51\x3f\xc3\x88\x75\x18\x98\x0e\x03\xcf\x61\x60\x39\x1c\xfe\x70\xf2\x39\x9c\x98\x86\xc3\x1b\x8e\xef\x23\xd0\x33\x02\x7c\x47\x50\x0b\x23\xa8\x95\x11\xe4\x68\x04\x79\x1e\x41\xac\x23\xe1\x8f\x64\x0d\x1e\x89\xfe\x91\xf0\x46\x52\x5b\xa3\xc0\x71\x14\xbe\x8f\xa2\x7e\x47\x81\xd9\x28\xf4\x8c\x42\x77\x19\x31\x95\xc1\x2f\x23\xa6\x32\x62\x2a\x83\x37\x1a\x7b\xa3\xb1\x37\x1a\xac\x46\x53\x1b\xa3\xc9\xc9\x68\xe6\xdb\x18\xe2\x19\x83\x9e\x31\xc8\x8f\x41\xcf\x18\x72\x3e\x86\x98\xc6\xe2\xcb\x58\xea\x76\x2c\xb8\x8f\xc5\x8f\xb1\xd8\x1c\x4b\xfe\xca\xd1\x53\x8e\x6c\x39\x18\x72\xd6\x36\xcb\xf1\x7b\x1c\x35\x3c\x8e\xda\x1b\x47\x8c\xe3\x90\x1d\x87\xee\x71\xd8\x1c\x4f\x7e\xc6\x13\xfb\x78\x62\x19\x8f\x7f\xe3\xe1\x8f\x87\xcf\xb9\xdc\x9c\x00\x7f\x02\xfc\x09\xf8\x32\x81\xfc\x4f\x20\xc6\x0a\x74\x57\x10\x7b\x05\x3e\x56\xe0\x47\x05\x79\xae\x04\xc3\x4a\x62\xaf\xc4\xf7\x4a\x6c\x56\x92\xe7\x4a\xb0\xe5\x2c\x6f\x56\x51\x2f\x55\x60\x52\x05\x86\x55\x60\x5e\x85\x2f\xd5\xcc\x85\x6a\x72\x51\x8d\xdf\xd5\x60\x55\x0d\x26\xd5\xe4\x79\x22\x75\x31\x91\x3a\x9a\x48\x8e\x26\xe2\xcb\x44\xe2\x99\x48\x3c\x93\xc0\x6a\x12\x79\x9e\x84\xcd\x49\xac\x01\x93\x88\x7d\x32\x36\x27\x63\x73\x32\x73\x76\x32\xfc\xc9\xf0\x27\x63\x73\x32\x98\x4f\xc1\xf7\x29\xe8\x99\x82\x8e\x29\xe0\x57\x43\xdc\x9c\xf1\xcd\xa9\xe8\x9d\x0a\x6f\x2a\x98\x4c\xa5\x86\x38\xdb\x9b\xd3\xc0\x75\x1a\x58\x71\xbe\x37\xa7\xd1\x37\x0d\x5f\xa6\x31\x66\x3a\x3e\x4f\xc7\x4e\x2d\x7e\xd7\x92\x9f\x5a\xfc\x9b\x81\xec\x0c\xf0\x98\x41\x4d\xcd\x20\x8e\x99\x60\x3a\x13\x3b\x9c\xfd\xcd\x99\xc8\x9d\x87\x4f\xe7\xd1\x3f\x0b\x7f\x67\x81\xd1\x2c\xe6\xde\x2c\xe6\xc8\x6c\xde\x67\xf3\x3e\x9b\xf7\xd9\x60\x33\x9b\xb1\x73\x18\x3b\x87\xb1\x73\x18\x3b\x87\xb1\x73\xe0\xcf\x05\xab\xb9\x60\x34\x17\xfc\xb9\x2f\x98\xf3\x18\x33\x8f\xfa\x98\x07\x6f\x1e\xbe\xcc\x23\xb6\xf9\xe8\x9a\xcf\xb8\xf9\x8c\x9b\x8f\x3e\xee\x13\xe6\xf9\x2d\xff\x0f\x44\xdd\x9c\x4f\x1c\x0b\xc8\xd1\x02\x74\x2d\x20\xfe\x05\xe4\x73\x01\x76\x16\xc2\x5b\x48\x2e\x16\x12\xef\x42\x6a\xe5\x02\xe2\xba\x80\xba\xb9\x80\x58\x2e\x24\xbf\x75\xe4\xae\x8e\x5a\x58\xc4\x5c\x59\x4c\xfe\x96\xe0\xff\x52\xe4\x97\xe2\x0b\x77\x0e\x73\x19\x35\xb2\x0c\x9d\xcb\xa8\xa5\xe5\x3c\x2f\x27\xae\xcb\xe0\xaf\xc0\xf7\x15\xe4\x60\x05\xb5\xb4\x12\xec\x57\x82\xfb\x4a\xf4\xae\xc4\xc6\x4a\x64\x2f\xa7\xbd\x02\xdb\x57\xc0\xbb\x02\xdf\xae\x20\x0f\x57\x82\xc1\x95\x60\x73\x15\xb9\xbe\x0a\xfb\xab\x68\x57\x93\xdf\xd5\xe4\x69\x35\xb5\xb7\x1a\x99\xd5\xe0\x72\x35\xfa\xae\xc6\xd6\x1a\x7c\xbe\x06\xcc\xd6\xa2\xe3\x5a\x6c\x5d\x87\x7f\xd7\xa3\xf7\x06\x64\x6f\x04\xf7\x9b\x18\x7b\x33\x76\x6f\x21\x4f\xb7\x52\x37\xb7\xe1\xfb\xed\xf8\xba\x01\x3b\x77\x80\xfb\x9d\xe8\xdb\x88\x9e\xbb\xf1\xf5\x1e\x64\xef\x25\xae\x7b\x89\x75\x13\x98\xfd\x09\x1c\xfe\x44\x2d\xfc\x99\x3a\xdb\x4c\xdf\x5f\xc1\xf0\x3e\x6a\xeb\x3e\xec\x6f\x01\x93\x2d\x60\xf7\x00\xeb\xd2\x03\xf8\xc0\x7d\xc1\x7c\x80\x9a\x7b\x80\xb8\x1f\x44\xee\x41\xe6\xd2\x83\xcc\xa3\x07\xd1\xf5\x10\xb6\x1e\x02\xeb\x87\x89\xe5\x61\x62\x7b\x84\xda\x7e\x14\x7d\x5b\xb1\xb9\x95\xb8\xeb\x79\xaf\xc7\xb7\x7a\x7c\xdb\x86\xfc\x63\xd8\xdc\x8e\x4f\xdb\xa9\xf5\x27\xc0\x7c\x07\x36\x76\x20\xbb\x83\x78\x9e\x66\xce\x3d\xcd\x3c\x79\x06\x3f\x9e\x21\xd6\x67\xc0\xe8\x59\xf0\x7e\x96\xe7\x67\xe1\x3f\xcb\xf8\x9d\xf8\xb6\x93\x5a\xd9\x09\x66\xcf\x31\xf6\x39\xe2\x7f\x0e\x3b\xcf\x31\xb7\x76\x51\x4b\xbb\xf0\xf3\x79\xf8\xcf\x63\xf7\x79\xfc\xd9\x4d\x0e\x76\x53\x0f\xbb\x89\xf3\x05\x74\xbd\x80\xec\x8b\xf0\x5e\xc4\xfe\x8b\xe4\xee\x25\xe2\x7b\x09\x8c\x5f\x42\xf7\x1e\xb0\xdb\x83\xcd\xbf\xe1\xc7\xdf\xc8\xe1\xcb\xd4\xed\xcb\xe8\x78\x05\x7f\x5f\x41\xe6\x55\xf2\xf2\x2a\x35\xf3\x2a\xb8\xbe\x06\xe6\xaf\xf3\xfe\x3a\x38\xbc\x81\xae\x37\x88\xef\x0d\x62\x7b\x03\x8c\xde\x24\xfe\x37\xb1\xff\x77\x70\x7a\x1b\x9c\xf7\xe3\xef\x7e\xfc\xda\x8f\x8f\x07\xd0\x75\x80\x5c\x1e\x60\x7e\x1e\x20\xa6\x03\xd8\x7d\x0f\x3b\xdc\x11\xcc\xf7\xb0\x75\x10\x1f\x3f\x00\xd3\x0f\xd0\xfb\x21\x71\x7c\x88\xbf\x87\x98\x5f\x1f\xa1\xeb\x63\xe2\xfb\x04\xd9\x4f\xb0\xf1\x29\x35\xf0\x19\x3e\x1c\xc6\xce\x61\xe6\xd4\x11\x72\x7b\x84\xda\xf8\x9c\x18\xbe\x40\x86\x3b\x81\x79\x94\xb1\x47\xf1\xa9\x01\xfc\xbf\xc4\xc7\xaf\xc0\xe1\x6b\xb0\xfe\x9a\x98\xbf\x06\x8f\x6f\xf0\xe1\x5b\xf8\xdf\xf2\xfc\x1d\x31\x7f\x0f\x2e\xdf\x83\xf5\x31\x30\x3e\x06\xef\x38\xcf\xff\x24\xaf\xff\x04\xa7\x7f\xe1\xf3\xbf\x68\x7f\xc0\x97\x1f\x58\x4f\x7e\x20\xe7\x3f\xe0\xc3\x8f\xc4\xfa\x23\xfb\xee\x8f\xc4\xf2\x13\x76\x7f\x02\xa7\x9f\xc8\xcd\x4f\xd8\xff\x19\x7f\x7f\x06\xc7\x5f\xc0\xe9\x17\x9e\x7f\xc1\xdf\x5f\x58\xab\x7e\xc5\xe7\x5f\xc1\xe3\x57\x72\x7e\x02\x5f\x4e\x10\xef\x09\x74\x9e\xc0\xc6\x09\xb0\x3a\x41\x5d\x9c\x20\xfe\x13\xe0\x71\x02\x5d\x27\xc8\xc9\x09\xc6\x9d\x44\xf6\x24\x38\x9c\x44\xf6\x24\x72\x27\x91\x39\x49\xec\x27\xe9\x3f\x49\x4e\x4e\x81\xf5\x29\x70\x38\x85\xdc\x29\xe4\x4e\x21\x77\x8a\x98\xb9\xbb\x98\xa7\xf0\xe3\x14\x31\x9d\x22\x07\xa7\xa9\xff\xd3\xe4\xe1\x34\x71\x9e\xc6\xf7\xd3\xe0\x73\x9a\x58\x4f\x23\x77\x1a\xb9\xd3\xc8\x9d\x46\xee\x0c\x72\x67\x90\x3b\x83\xdc\x19\xf2\x73\x86\x79\xe0\x43\xc6\x87\xdf\x7e\xe2\xf6\x83\xb5\x7f\xa7\x58\x46\x46\x90\x16\x42\x87\xc4\x32\xb3\xa0\x95\xd0\x7a\x68\x13\x54\x0f\xed\x86\xf6\x41\x9f\x8a\xc5\xbd\xc8\xb2\xe8\xb7\x78\xb7\xf4\xfb\x71\xb1\x1c\x02\x45\x41\xf4\x39\xbc\x50\x19\x54\x03\xa1\xd3\x81\xac\x03\x5d\x0e\x74\x39\xd0\xe5\x40\x97\x83\xb1\x0e\xc6\x3a\x18\xeb\xb4\xa0\x04\xa8\x13\xc4\x58\x67\x39\x54\x0b\x2d\x81\xae\x83\x36\x42\x8c\x73\xee\x81\x0e\x42\xdf\x8a\xe5\xc2\x9e\x2b\x0e\xc2\x6f\x57\x37\xa8\x08\x62\x9c\x0b\x1b\x21\xf8\x1f\xb2\x41\x2c\xee\x65\x16\xf7\x32\x2b\xf4\x57\xb1\xc2\x66\x41\xc4\xda\x02\x1f\x5b\xa0\xbb\x05\xfa\x5a\x62\xb7\x65\x05\xb4\x19\x42\x26\xbc\x14\xba\x05\xfa\x52\xac\x08\x9e\x23\xb0\x1b\x81\x7f\x91\xbd\xa0\xab\x20\xb0\x89\xc2\x56\x14\x32\x51\xc8\x44\xc3\x8f\x26\xb6\xe8\x77\xc5\x8a\xc1\xf7\x18\x64\x62\x88\x29\x16\x9f\x62\xe7\x41\xdb\xc5\x8a\xc3\x5e\x1c\xcf\x71\xaf\x8a\xd5\x8a\x18\x5b\x81\x49\xab\x2d\x62\xb5\xc6\xff\xd6\xf8\xdb\x1a\xdb\xad\x4f\x8b\x15\x0f\x3f\x1e\xf9\x04\x7c\x4a\x80\x9f\x40\x1c\x09\xf8\xd4\x66\x22\x04\x5e\x6d\x89\xb5\x2d\x7e\x73\xbf\xb3\xb8\xdb\x59\x89\x3c\x27\xc2\x4f\x22\xc6\x24\x9e\x93\x1e\x86\x7e\x14\x2b\x99\xb1\xc9\xc8\xa4\x20\x93\x82\xce\x14\x6c\xa5\x80\x97\x1b\x7c\xdc\xd8\xf2\xa0\xdf\x83\x4e\x0f\xf2\x1e\xec\xa6\x22\x9f\xca\x73\x2a\xcf\x69\x60\xc1\xfd\xcb\x4a\xf7\x40\x8b\x20\x9e\xb9\x6f\x59\x19\xe8\xc9\xc0\x56\x26\xb6\x32\xc9\x49\x26\xcf\xed\x42\x20\x72\xdc\x0e\x1c\xdb\x13\x63\x7b\xf2\xdc\x9e\x18\xb3\x78\xce\x42\x3e\x6b\x87\x58\x1d\x88\xb7\x03\xf2\x1d\xc0\xa7\x23\x98\x74\x44\xa6\x23\x63\xb3\xe1\x67\xc3\xcf\xa6\x06\x3a\x61\xab\x13\xfc\x4e\x8c\xe5\x3e\x64\x75\xc6\x6e\x67\x9e\xb9\x03\x59\x5d\xc0\xb6\x0b\x98\xe7\xc0\xe7\xce\x63\x71\xe7\xb1\x72\xf1\x27\x97\x5c\xe6\x52\x0b\x5d\xd1\xd3\x95\x58\xba\x12\x63\x57\xfc\xcf\xc3\x7f\xee\x35\x56\x3e\x32\xf9\x3c\xe7\x93\xbf\x7c\xf2\xd7\x8d\xd8\xbb\x81\x67\x37\xf0\xe4\xfe\x62\x75\xa7\x16\xbb\x7f\x2e\x56\x0f\x6a\xb5\x07\x39\xe3\xfe\x62\xf5\xa4\x66\x7a\x62\xbb\x27\xb6\x7b\x11\x67\x2f\x7c\xea\x85\x8d\x02\x6c\x14\xa0\xab\x80\x9c\xf7\xe6\xb9\x37\xf5\xd7\x07\xd9\x3e\xd8\xec\x8b\x8f\x7d\xa9\xb3\xbe\xd4\x42\x3f\x6a\xa1\xdf\x1a\x88\xfe\xfe\xd4\x08\xf7\x01\xab\x3f\xb8\x17\x52\x47\x85\xc8\x14\x22\xe3\x45\xc6\x8b\x8c\x97\x1a\x19\xc0\xf3\x00\x64\x06\xc0\x1f\xd8\x17\xe2\x79\x20\x3e\x0d\x82\x3f\x08\x5b\x83\xf0\x9b\xb3\xba\x55\x84\x9d\x62\xb0\x2e\x26\xe6\x62\xfc\x29\xc1\x66\x09\xb2\x83\xa9\x9f\xc1\xe4\x7d\x30\xfe\x0e\x46\xb6\x94\xb8\x87\xe0\xff\x50\xe6\xcf\x50\xe2\x1e\x8a\x0d\xce\xd1\xd6\x30\x7c\xe0\xdc\x6c\x0d\x27\xc6\x11\xcb\x21\x72\x3a\x12\xb9\x51\xe4\x69\x14\x76\x47\x61\x63\x14\x36\xca\x88\xa9\x8c\xfe\x32\x72\x32\x9a\x71\xa3\x91\x1f\x83\xae\x31\xd4\xcc\x58\x70\x1a\x8b\x6f\xe5\xd4\x4e\x39\xd8\x94\x13\x5f\x39\xe3\xca\xb1\x5f\xce\x98\x72\xfc\x2d\x47\xae\x1c\xdd\xe3\x68\xc7\x33\x17\xc6\xef\xd4\xff\xff\x5f\xc4\x90\x47\xfd\x47\xd4\x49\x47\x3f\x31\x25\x52\x5e\xf1\xae\x31\xc3\xc3\x0d\x97\x2b\x2a\x5a\xc2\xbc\x56\xd8\x5d\xd5\x56\xac\x69\x1e\x8f\x56\xeb\xa3\x55\x4d\xb4\xd2\xff\xe6\xda\xa6\x68\xe5\x8d\x56\x9f\x46\xab\xad\x36\x77\x65\xb4\x1a\x15\xad\x72\xa3\x95\x27\x5a\x1d\x8b\x56\xfb\xa2\xd5\xee\x68\xb5\xce\x96\xce\xb1\x07\xf4\x39\x6e\x4b\x07\x3a\xea\xa3\xd5\x42\xbb\xaf\xcc\x1e\x40\xf7\x71\x9b\xb9\xa9\xd1\x02\x63\xdc\x36\x3f\x64\xf2\xa4\xe0\xcf\x05\x4d\x3f\x93\xcf\xe6\x5c\x78\xa1\xcd\x90\xc2\xc2\x6c\x69\x9b\x10\xf5\xf7\xe8\x18\x55\x10\x9d\x9f\x1f\x9d\xdf\x35\x57\xa5\x9b\xa9\x66\x5a\xbb\xee\xdd\x7a\xe4\xe7\xb5\x6e\x15\xe7\x54\xd7\xd7\x4d\x54\xd9\xb7\x16\x4f\xad\x29\x81\xd4\x66\xf3\x8e\x93\xf7\xd9\x8f\x90\xfe\xef\x20\x8f\x98\x13\xcd\x75\x36\x06\x2e\x49\xf7\x46\x39\x2c\x25\x96\x84\x84\xba\xa2\x0c\x65\xb0\x47\x4a\x61\xde\xde\x49\x79\x5a\x3f\x06\x6c\xfd\xa9\x66\xba\x26\xe3\x7a\x65\x8c\x9c\xe5\x0b\xd3\x7f\x3a\xfa\xf9\xdc\xea\x33\x9f\x5b\xeb\x4b\x64\xa3\xf8\x02\x7d\x89\xe2\x96\x69\xde\x3e\x21\x89\xc9\x6e\x2b\xd5\xa3\x55\x86\x3c\x52\x99\xdc\x26\x34\x29\xa1\x65\x78\xcb\x47\x2a\x5b\x45\x87\x6f\x0d\x57\x91\xe1\xa3\xc2\x8f\x85\xfb\xc3\xad\x42\x1e\xee\xd5\x0f\xa1\xe1\xa1\xe1\x2a\x36\xd2\x74\x38\x95\xe4\xe4\xe7\x17\xe6\xc7\x14\x14\xe4\xe4\x4c\xba\xe0\x42\xc2\xcb\x8e\x16\x1d\x63\xb0\x8d\x51\xf1\x05\xb8\x63\xa6\xc7\xe2\x4d\x6c\x7a\xf7\x7c\x28\x35\x36\xdf\xd4\x94\xdf\x2a\x1d\x52\x3c\x1b\x5f\x0c\x5f\x37\xdc\xf7\xaf\xa1\x37\x0d\xbf\xfb\xc9\xee\xdf\x28\x63\xc8\xfa\xa1\x2a\x62\xe8\xba\xa1\x1b\x1f\xcb\xff\xe2\x4c\x7d\x77\x15\xd1\x43\xdd\xe5\x9b\x11\xa0\x65\xca\xbd\x4c\x5d\xef\xab\xd3\xb4\xcc\xf7\xd9\x32\x75\xa7\xef\x33\xe5\x06\x83\x21\xfe\x5a\xf3\x65\xc7\x1b\x92\x25\xb9\xd2\x4b\x96\x79\x87\x75\xb5\x22\xe2\x92\xbb\x98\xed\x43\xa3\xbb\xb7\xb7\xb2\x3a\xc4\xa7\xa7\x67\x45\x98\x05\xbd\x7b\x24\xc5\x25\x4d\xa9\xec\x1a\xd1\x3d\x39\xac\x73\x7a\x87\x10\x49\x88\x8c\x75\xc7\xe6\xc4\x9a\xc1\xa6\xb5\x19\xeb\x8d\x8e\xb3\xba\x84\x4a\xe8\x94\xca\x7d\x59\x2a\xab\x9d\x43\x62\x01\x18\x84\x75\x48\x09\x85\xf9\x6d\xf7\x4e\x99\x3c\xe9\x82\xfc\x98\xf8\x02\xcd\xb0\x43\xd4\x69\x8d\xb7\xff\x97\x0f\xfa\x8e\x2e\xaa\x7d\x74\x7e\x7c\x8a\x8a\x8f\xee\x62\x90\xe3\x9e\xdd\xf3\x5b\xb5\x8e\x8f\x4e\x6f\xaf\xf9\x29\x16\xf9\x76\xb5\x4a\x57\xdd\xf4\x5b\x7f\xa5\xe2\xb4\x5c\x84\x52\x6f\xcf\x6d\xe8\x39\x29\x23\xe5\x81\x01\x5b\x56\x0f\xfb\xfb\x43\x33\x6f\xbf\xab\xda\x93\x5c\xdb\xe3\xd2\x99\x65\xbd\x53\xdf\x7b\x6a\xa6\x4a\xc9\x28\x1e\x55\x39\xc5\x57\x98\xd2\x77\xc8\xa8\xf2\x38\xa3\x53\x1b\xe5\x7d\xa6\x83\xd7\x50\x5f\x0e\x9c\xbb\xf1\xe2\xf5\x4f\x46\x5c\xbe\xc2\x99\xe9\xfb\x6a\x5d\x72\x67\x87\x6f\x6a\x5e\xcf\x41\x15\x8b\x87\x6f\x7d\x2f\xfc\x3a\x75\xb4\x6b\x49\x5e\xb2\xaf\x5f\xd4\x0a\x73\x54\x97\x01\x39\x29\xea\xe2\x96\xd3\xc5\x21\x6f\xfb\xbf\x70\x79\x1d\x63\x40\x2d\x5c\xda\x48\x86\xe4\xaa\x23\x5e\xbf\x61\x8a\x52\x66\x68\xdb\x08\x2b\x2e\x34\xdb\x9d\xd9\xd6\x72\x87\xb6\xb5\xf2\xba\x3a\xe3\x9f\xac\x6c\xe1\xdc\x51\xdd\x22\x9a\xb6\x85\x61\xa5\x65\x3d\x59\x99\x94\xb6\xa3\x3a\xa9\x0b\x6d\x92\xc4\x5e\x9a\xa7\xc6\xe7\xa9\x92\x3c\xd5\x2d\x4f\x85\xe6\xa9\x53\x79\xea\x68\x9e\x3a\x90\xa7\x5e\xcb\x53\x0f\xe5\xa9\xbb\xf2\xd4\xb5\x79\x6a\x71\x9e\xaa\x69\x14\xeb\x91\xa7\xda\xd8\x92\xb3\xce\xd8\xa2\xc8\xdd\x97\xa7\xee\xc8\x53\xd7\xe4\xa9\x4b\xf2\x54\x6d\xa3\x5c\x41\x9e\xca\xce\x53\x89\x79\xea\x44\x9e\xfa\x26\x4f\xbd\x6b\x8b\x21\xb3\x2c\x4f\xcd\x6f\xb4\xd7\xae\xd1\xe4\x77\x79\x6a\x4f\x9e\x7a\xd2\xd6\x83\x92\xb9\x79\xaa\x3c\x4f\x15\xd9\x96\x5a\xe4\xa9\x5e\x3f\x36\x3a\x85\xd0\x76\x5b\x51\x40\xa8\xda\x56\xd4\x21\x4f\xb5\xce\x53\xde\x09\x01\x55\xd8\xfa\x30\x4f\xbd\xdc\xa8\xad\xc9\xa2\x9a\x82\x8c\x6d\x35\xce\x56\x7a\xaa\xd1\xad\xdd\xb6\xce\xcd\x79\xea\x16\x5b\x27\x62\x06\x72\xb9\x79\xca\x9d\xa7\x22\xf3\x82\x2b\xc5\x94\x49\x67\xad\x17\x53\x9a\x16\x8d\x0b\x9b\xff\x34\x2d\x2a\x67\xad\x2b\x7f\x2c\xd3\x28\x46\x7d\xe6\xe8\xff\x56\x81\xea\xd4\x6d\xb0\x26\x83\xff\x17\xd3\xb8\x2a\x38\xd2\x55\xbe\x8a\x4a\x65\xdd\x89\x4a\xcd\x6b\xed\xea\xd6\x2e\x3d\xcd\xd9\x2a\xae\x75\x7e\x5e\x8f\x00\xd7\x5e\x8d\x9a\xb3\x8d\x95\xb7\x99\xdb\x6f\x3f\x93\xe5\x7b\xf2\x4f\x9b\xd4\xe0\x7b\xff\x7a\xb0\x67\x9f\x5e\x79\xf9\x3d\x7b\xf7\xb2\x9e\xf5\x3d\xf5\xa7\x3f\xfd\xf9\xbe\x7b\x37\xbf\xd7\xc8\x8a\x73\xcc\xf4\xdd\xe8\xbb\x6e\xd7\x93\x6a\xc1\x8e\xa7\x6e\x5a\xb1\xf4\xf6\xbb\x96\x5f\xe1\x6b\xe9\xbb\x76\xd7\x53\x8f\x3d\xd7\xc4\xd0\xff\xb5\xf6\x62\xff\xb7\xce\x12\x6a\x2f\x43\x3a\x33\x4f\x97\x78\x07\x67\xb7\x89\x74\x58\x5d\xad\x2e\x51\x5d\xba\x49\x5c\xfb\xac\x64\xcb\x1d\x1b\x1b\x15\x1d\xd5\xd2\x25\xee\x36\xae\x82\xde\x2d\x5d\xa1\xae\x91\x95\xa1\xa1\xb1\xd2\x55\x45\x3a\xe2\xda\x47\x3a\x10\xe9\x1a\x92\xd6\x3a\xad\xc7\xa8\xca\x34\xab\x75\x66\x59\x65\xeb\xd6\x51\xb1\xad\xa4\x30\xbf\x50\x23\x40\xf4\x12\x5f\xc0\x14\x8d\x2e\x48\xc8\x69\x36\x43\xa3\x63\xf4\x9f\x79\x81\x86\x35\x29\x2e\x42\xb9\x54\x8f\x9e\xed\xbb\xa7\xb6\x8a\x54\x4e\x97\x5b\xb5\x4a\x6d\xef\x4c\xf5\x64\x74\xef\xd6\x5f\xf5\x0c\x82\xa1\xf2\x7a\xaa\x08\x05\x18\xb1\x71\xad\xe3\xfb\xab\xee\xdd\x80\xc6\x8a\xed\x7b\xc1\x62\xb5\x3c\x3f\x64\x81\xfa\xe8\xfc\xc4\x7e\x95\x87\x16\xf9\x56\x5e\x5c\xef\xfb\xc9\xf7\x9d\xef\xa7\x92\x65\x17\x5f\xb6\xe7\x89\xad\xcf\xfa\x2e\xdf\x77\xa5\x2f\xbd\xa8\xef\x0d\x31\xd9\xde\xe1\xbd\x16\x16\xf5\xb1\xba\x0e\x5f\x38\x2e\xc7\xf7\xc0\x95\xf5\x6d\xbd\xde\xb6\xd5\x7f\x5f\xfd\x72\x9b\xc2\xf3\xaf\xd8\xb9\xb3\x66\xdd\x79\x39\x37\x6e\xbb\x76\xe3\x2d\xa7\x36\x2c\x51\x3b\xbb\xac\x9d\xbe\x6e\xad\xf9\x8d\x77\x41\x49\x87\xf3\x27\x3f\x62\xff\xc7\x02\x4a\x36\x9a\x13\xd5\x3d\xf6\xda\xdf\xc6\xdb\x42\xd9\xa7\x64\x56\x7d\xc5\xa2\xbf\x77\x52\x60\x4b\xe9\x9a\xab\x57\xd7\x8d\x8d\x8b\x3c\x63\xaa\x7c\xc3\x8d\x59\x8e\xeb\x25\x5a\x92\xbc\x2d\x23\x2c\x4b\x42\x43\x63\x62\xc3\xc5\x91\xc8\x66\xd4\x7c\x1b\x8a\x8b\x69\x1d\xdf\xaa\x8b\x62\x91\x8a\xe9\xd1\xb3\x55\x04\x6a\xe7\xe6\x2f\xa8\x7e\xf9\x93\xd9\xb3\x3f\x79\xb9\xfa\xfc\x6e\xea\xfb\xef\x7c\x1f\x1f\x2a\xbe\x70\xf6\x09\x35\xfa\xf8\xf7\xaa\xec\xd7\x59\x17\x16\x7f\xa0\xff\x81\x10\xed\xd7\x40\x6c\x94\xd9\x36\x52\xbc\xe1\xa1\x4a\x45\x44\x38\x1c\x31\xb1\x61\x22\xbf\x19\x09\x94\x5d\x6c\xf7\xfe\x2a\xa6\x7b\x37\xa3\x5d\xfb\xee\x29\x2a\xa6\x55\x9c\xe1\x1c\x58\xbd\x20\xbf\xdb\xf9\xd5\xaf\x7e\x3c\x6b\xd6\x27\xbe\xe1\x17\x96\x1c\x52\x99\x5f\x7d\xa7\xd2\x0e\x96\x5c\x38\xf7\x17\xdf\xb6\xef\x8e\xf9\xb6\x9e\x08\xd8\x18\x67\x0c\x32\x1f\x72\x0c\xc6\xc6\x20\x6f\x96\xab\x85\x52\x61\x46\xa4\xb4\x34\x43\x0d\xa7\xcb\x11\x15\xe1\x88\x88\x89\x7d\x5e\xfd\x43\x19\x2b\x95\x5a\xa0\x94\x28\x0f\x01\xb4\x00\x98\x37\xf5\xc4\x08\x6e\x87\x31\x81\xd5\x39\x3f\x8f\x70\x63\xd3\x63\x1d\xed\x3b\xab\x9e\x0e\x33\xdf\xcc\x8c\x0f\x57\x2e\xa3\xd3\x90\xaf\x4a\x7c\x9f\x4d\x56\xf9\xbe\xbd\x93\x95\xbb\xe4\xab\x21\xca\x33\xc5\xf7\xaa\xea\x35\xc5\x5c\xe1\xdb\xa3\xbc\xdf\xee\xaf\xa8\xda\xff\x95\xea\xe7\x7b\xe9\xc8\x5b\x15\xe3\xdf\xb1\x7d\x9a\x27\x6f\x58\x19\xd6\x2a\x69\x21\x03\xbc\x19\x61\xa1\xca\xe9\x50\xa6\x61\x84\xb7\x6c\xa1\x22\x2a\x43\xc2\x22\x24\xc4\x1b\x62\x84\x9a\x21\x61\x56\x8b\xb0\x16\x8f\x54\x3a\xc2\x1e\xa7\x30\xed\x9d\x23\xea\x65\x8a\xd2\x9e\x9c\x05\x8d\x3b\x85\x8a\x4e\x8f\x4e\xed\x9e\x0a\x4e\xa9\xad\x8c\x75\xeb\x7c\xf3\xd4\x2d\xeb\xd4\xad\x46\x8d\x6f\xae\xba\x75\x9d\xba\xcd\x37\x67\x5d\x00\x87\x44\xdf\x4b\xea\x31\xd5\x59\x62\xa4\x93\x37\x3e\x44\x2f\xdb\xe1\x71\xb1\xa6\x75\x77\x65\x94\xb9\xa5\x3a\x24\x2a\x36\xea\xae\xea\x28\xb1\x8b\x3d\xa8\x3f\x90\xdf\x4c\x76\x9a\xee\xfd\xc9\x6e\xbb\xf6\x8d\x05\xfd\xd8\xbe\x57\x0a\xab\xba\xa6\x74\x1e\x5e\x55\x3c\x6e\xe1\x9c\x8d\xef\x75\x9b\x18\xdb\x7f\x58\x5a\x6b\x4f\x9b\xac\xf2\x01\x45\xf3\xb5\xad\x61\xea\x5a\x63\x8a\xfe\xb7\x59\xa5\x95\x37\x54\x4c\xcb\xa1\xe4\x99\x4a\xa5\xb5\x6b\x40\x75\x3a\x53\x5b\x0d\x33\xe2\xd4\xb5\x8f\x3e\x6a\xfb\x56\xc5\xf9\xec\x3e\x95\x03\x1e\x09\xde\x16\xa1\xa6\xfe\xa5\x95\xf3\xae\x6a\xbd\x67\x66\x37\x96\xa7\xa3\xf9\x51\x47\x82\xa7\x9c\xe4\xa6\x03\x8e\xf2\x7f\xeb\xff\xd6\x18\xe9\x28\xc6\x26\xf5\xaa\xf7\x21\xd3\xa1\x2c\x4e\x36\xb1\xba\x94\x54\x7e\x63\x25\xc5\xb3\x80\x5d\x72\xbd\x3a\x70\x5d\x9c\xa3\x52\xf4\x39\x66\xa4\xff\x5b\xf3\x31\xd6\x92\x30\x69\x2d\x59\xde\xb8\x68\x47\x0b\x36\xb7\xf8\x84\x90\x88\xba\xca\x10\x97\x11\x57\x57\x69\xb4\x91\xc6\x45\xe1\xb7\xc3\x11\x8b\x9d\x11\x1d\x15\x93\x9f\x17\xa3\xa2\x8c\xf4\xc6\x67\xf3\x31\x5f\xe9\xbb\x07\x0f\x1e\x7a\xf7\x90\xef\xc3\x92\x61\x43\x0b\xbd\x43\x86\x0e\x36\x36\x9f\x29\x55\xb5\xaa\x5c\x8d\x50\x53\x7d\x7f\xf1\x6d\x55\xbd\x54\xb4\xef\x57\xdf\xf3\xbe\x67\x7c\xff\x52\xad\x02\xb9\xd9\xcc\xa2\x76\x9b\xa3\x14\x1f\x7a\x7a\x93\x5c\xe2\x70\xb4\x6c\xe1\x0c\x0d\x11\x57\x94\x8b\x32\x70\xb9\x42\x9d\xe2\x30\x1d\x8b\x2a\xcd\x04\x0d\x88\x7d\x80\xc8\xa1\x0e\x38\x32\x05\x13\x45\x9a\xe2\x5b\xa5\x76\xef\x19\xed\xea\x9e\x99\x6f\x3c\xf2\xd5\x99\x88\x2f\x1b\xd4\xd2\x1b\xce\x4f\x18\x3f\x3e\xc1\xfc\x61\xf8\xb8\x8f\xb1\x31\x1e\x1b\x5b\x1c\xc3\x25\x85\x9a\xf3\x44\x46\x49\x94\x11\x12\x9f\x6c\xc4\x1b\x1e\x77\x48\x72\x64\x5c\x5c\x8b\xba\xca\x38\x97\xa1\x92\x55\xf2\xc5\x95\xca\xb6\x13\x23\x05\x09\xb6\xb9\x80\x19\x3b\x72\x7b\x1f\xe8\x9a\xdb\x41\x75\xef\xd1\xd3\x2e\x0a\x16\xb3\x48\x95\xce\x19\xc4\xce\x0c\xcb\xa1\xd3\x95\x6a\x6e\x39\xfd\xe8\xf8\x21\x9b\x6e\x29\x9e\x53\xd1\x7f\xa8\x3b\x7b\x42\xd9\x1d\x55\x1f\x7d\x53\x72\xfb\x67\xe3\x6b\x8d\x9b\x9e\x9b\x38\xe4\x9e\x27\x5e\x5c\x3e\x7f\x75\xdb\xb6\x2f\xaa\xae\x31\x6d\x9e\xdc\x32\xfb\xa1\x3f\x3f\x55\x52\x19\xc0\x61\x04\xb9\x78\x06\x1f\xb3\x64\xbc\xb7\x53\xfb\x98\xd6\x19\xc9\x29\x29\x31\x19\xa6\x33\x5c\x5c\x4e\xa7\x74\xe8\xd8\x3e\x26\x3a\x26\xfa\xa2\xca\x98\x18\x33\x39\x2d\xad\x4d\x5d\x65\x9a\xcb\x0c\xab\xab\x74\x99\x6d\xf4\xfc\x90\x46\x6f\xf5\x92\x8d\xf3\xbf\x39\x1d\x1f\xf4\x5d\xaf\x56\x56\x7a\x5a\x7b\x33\x3f\x5e\x6f\x4d\xb8\x9f\xa3\xba\xf7\xd4\x6b\x72\xb3\x38\x3c\xd1\x54\xbc\x65\x3e\xe3\x3b\xf9\xd5\x33\x3b\x5a\x4e\xec\x36\x61\xca\x25\x6b\xe6\x2f\x5d\xb4\xb0\x72\xdc\x8c\x49\x3d\x8a\x09\x67\xe6\x2d\xa5\xea\xa5\xf5\xab\xd5\x18\x35\xff\xa9\xd7\xb3\x54\xf1\x7b\x5d\xef\xba\xf6\x92\xcb\x43\x5c\x97\x84\x38\x2f\x5e\xb2\x70\x65\x6a\x2c\x81\xb5\x8d\xf6\x3d\xb9\x66\x4b\x5c\x07\xea\x2b\x09\xdc\x3f\x70\x14\x91\xdb\x48\x90\x4f\x0b\x0d\x51\xce\xc8\x70\x2a\xd3\x60\xad\x8b\x8e\x72\x84\x44\x98\x91\x66\xe4\xe2\x4a\x31\x4d\xc3\x19\xee\x72\x1a\x60\x5f\x98\x8f\xb3\x39\x7a\xc6\xc7\xe7\x07\x32\xdc\x6c\xb6\xa7\x32\xdb\x75\x39\xb7\x52\xdd\x7a\x72\x3e\x2f\xf7\xfd\x70\x66\xbf\x31\xf1\xd0\x6a\xdf\xfc\x30\xdf\x05\x6a\x95\x0a\xf5\xfd\xa2\x42\xff\x62\x6e\x38\x7d\xd3\x5e\xa3\x6a\x61\xed\x99\x7b\xc1\x75\x0c\xb8\x3e\xc1\xfa\x9f\x2c\x63\xbc\xd9\x49\xf1\xf1\x6d\xcd\xb0\xd0\x28\x33\xd4\x4c\x71\xb7\x8e\x95\xd8\xba\xca\x48\xce\xf0\x46\x4b\x53\x24\xc1\x99\x90\x78\x71\x65\x82\xd3\x49\xf5\x87\x39\x7f\x83\x55\xd7\x82\x2e\xb9\xe0\x5e\x78\x56\x31\x28\x7b\x4e\x06\x60\x4d\xa1\x0e\xa2\x35\x9a\x1a\xcc\xd4\x56\xa9\xd1\x3d\xd4\xa7\xdf\x37\x9c\xfa\xda\x46\xb2\xfd\x85\x5d\x8e\x5e\xb4\x72\x70\x1f\x77\xad\xb1\xf3\xcc\xe3\x4b\xcd\x36\x7b\x5e\x7e\xfd\x7d\x0d\x60\xeb\x44\xd5\x6d\xd3\xba\xb6\xe1\x46\xfd\x27\xbe\x4d\x89\x60\x56\x82\xbf\x7b\xa8\x83\x04\x49\x97\xd1\xde\xec\x88\xf0\x70\xa7\xc4\xa5\x25\x49\x1a\x55\x90\x91\xd9\xda\x7d\x51\x65\x64\x6b\x77\x6b\x3c\x6e\xdd\xda\x0c\x0b\x8b\xae\xab\x8c\x08\xa3\x08\xea\x2a\xcd\xe0\x54\xcd\x6f\xee\x71\xa3\xbb\xf6\x31\x26\xb0\x65\x39\xf5\x8c\x65\xbf\xca\xcf\xd3\x47\x6a\xdc\x35\x5c\x81\xad\xba\x87\x5d\x0a\xae\x56\x51\xe6\x9e\x0f\x5e\x3b\xfa\xd3\xe5\x5f\xde\xbe\xf1\xc6\x09\xd9\xc5\x63\x6a\x2f\x6d\x31\x7f\xee\x53\xaf\xf8\x2a\x87\xf4\x1a\x39\x62\xe8\x08\xb5\xe9\x9d\xcf\xd4\x64\x35\xfc\xa0\xea\xbd\x39\xdb\xf7\x8f\x17\xbb\xf9\xe5\x68\xce\xdf\xcf\x1c\xbf\xe7\x9e\xeb\x37\xc4\x3b\xce\x3c\xab\x6b\xf9\x22\xf2\xfe\x77\x30\x0f\x91\x7c\x6f\x82\xc3\xe9\x54\x2e\x8b\xb3\xb1\x15\x1a\xe6\x4c\xb0\x8c\x10\x23\x84\x69\x66\x38\xa5\xd1\xd5\xc2\x66\xa8\xda\x1b\x9e\x86\x4f\x71\x01\x7b\x73\x82\x59\x79\xe6\x97\x63\x46\xf7\x33\xc7\xcc\x5d\x6a\xc5\xa8\x53\x31\xd6\x64\xd1\x67\xa0\x22\x30\xda\xc9\xba\xd5\x5a\xd2\xa4\x8b\x94\x7b\x3b\x46\x98\xd1\xe9\xd2\x21\x3a\x5a\x9c\xc9\x2d\xe2\x9d\x2d\x9c\x39\xb9\x66\x44\xa7\xb6\x9d\xda\x2e\xaa\xec\xd4\x29\x34\x2e\xae\x9d\x9e\xe0\xa1\x9e\xba\xca\xd0\xdf\xd6\x33\x69\x9c\x2b\xe7\xcc\x70\xbb\xb1\x81\x72\xa5\x28\x9d\x5c\x4f\x34\x57\x90\x2e\x2a\xb0\x02\x9b\xcd\x8e\x77\x67\x3d\xdf\x3d\x6f\x5a\xdd\xd2\x0f\x1b\x7c\x43\x97\x9f\x3f\x75\xce\xfb\x2f\xbf\xf8\xfe\x99\xb2\xf1\x63\x4a\x87\x8c\x1e\x5f\xe6\x1e\x38\xc8\xdb\xaf\xef\x80\x62\xaf\xf9\xc3\xf9\x77\xa5\x67\x6f\xbf\x6c\xd7\x6e\x75\xd9\xca\xed\x1d\x32\xef\x5c\xb8\x79\xc7\xb3\xa7\xdf\xb9\xf3\xba\x35\xf7\xdc\x75\xd9\x55\x66\xca\x95\x17\x2f\xbe\x6a\xcd\xc2\x3a\x6a\xa0\x17\xf1\x3d\x49\x0d\xb4\x69\xaa\x01\x71\xb6\x4a\x49\x71\xb6\x15\x71\x66\x64\xc6\x27\x5d\x54\x29\xf1\x51\xf1\xd4\x40\x7c\x7c\x98\x19\x16\xa3\x6b\xa0\x8d\x99\x46\x0d\xb8\xfe\x97\x1a\x88\xd5\x91\xc4\x44\x73\x90\xa0\x70\xa3\x03\x85\xdb\xa3\x27\x2f\xed\x32\xa3\xf2\xf3\x7a\x76\xd7\x8b\x7a\xaf\xaf\xf7\x7d\xf3\xfe\x8a\xef\xef\xbf\x8f\x12\x48\x9f\xda\x79\xde\x25\x61\xb3\xce\x7b\xe2\x2d\xd5\x6e\xe3\xf0\xa1\xc5\x13\x6e\x33\x37\xbf\x79\xc8\xf7\xa4\x6f\xd3\x61\xdf\xeb\xf7\x64\xab\xae\x2f\xb6\x49\xfa\xe9\xcb\xcc\x83\xcf\xfb\x0e\xc7\x44\xa8\x54\x95\x61\xef\x2d\x5b\xd8\xd7\x7e\x30\x77\xb3\xaf\xc5\x4b\xae\xb7\x6d\xab\xd0\xd0\x48\xd3\x6c\x93\x10\xd3\xf2\xae\xea\x98\xa8\xc0\x16\xb7\xa9\x8d\x5a\xdf\x46\xe9\x2b\x7e\xd3\x1e\x13\xdc\x79\x9b\xef\x78\x67\x5d\xf4\x47\x94\x4c\x99\x62\xef\x7b\x25\x53\x26\x95\x0e\x9e\xa2\x77\xc1\x92\x1a\xbd\x0b\x1a\x37\xea\xa7\xa9\xc5\xec\x87\x86\xcc\xf1\xbd\x64\x18\xb6\xed\x14\x19\xe8\x6d\x17\xd7\xb2\x65\x1b\x76\xd6\xc8\x36\x6d\x3c\xee\xc8\xa8\xbb\x2b\x93\x22\xb7\x54\xc7\x25\xb9\x93\xee\xaa\x76\x0a\x14\xb5\xc9\xa3\xd6\x7b\x02\x7e\x9c\x73\x06\x08\xee\x78\xcd\x3c\x88\xfd\xf7\x33\xc1\xa8\xa0\x2f\xf3\xf7\xbd\x5a\x58\xdd\xd5\xd3\x79\xc4\x84\x61\x63\x2f\x34\x16\x35\xfa\x73\xe6\xe7\x8d\x07\xba\x73\x4c\x18\x9e\xda\x3a\x35\x21\xab\xbc\xef\x90\xf9\xf6\x7a\x3f\x53\xee\xb3\x52\xac\x07\xc4\xc9\x1c\x49\xb1\x84\xf9\xe0\x74\x85\x58\xce\xad\xd5\x96\xb1\xb5\x5a\x49\xa4\x55\x68\x2d\xb0\xee\xb5\xfe\x61\x39\x2c\x69\x93\x33\x29\x3f\xe8\x56\x41\xe3\xa1\x50\xb5\x0a\x55\xad\x66\x9a\x3b\xce\x28\xc3\x6f\x2c\xab\x52\xef\xae\xf3\xdd\xe0\xbb\x7e\x9d\x8d\xfd\x4c\x75\xb3\x95\x62\xee\xb4\xbf\x77\xf4\xf2\xa6\x38\x0d\x07\x27\xbb\x90\x50\xd3\x78\x84\xb5\x56\x25\x9a\xa6\xcb\xeb\x72\x3e\x52\x19\xe9\xba\xd7\x65\xb8\x24\x67\x52\xe0\x03\xcb\x59\xd5\x42\xd4\xec\xaa\x9a\xac\x94\xd3\xa5\xe6\x8e\xd3\xa5\x46\xfa\xfa\xf5\xea\x8e\x75\xeb\xf0\x7d\x16\xbe\x7b\x6c\xdf\x7b\x78\xdd\x8d\xbe\x3b\x1d\x86\x61\x6d\xad\x36\x64\x6b\x75\xa4\x51\x68\x2c\x30\xee\x35\xfe\x61\x38\x0c\xed\x7c\x76\xe3\xd7\x8c\x46\xdd\x3d\xbb\x87\x2a\x94\xcf\x32\xe5\x8c\x98\x3b\xee\x5b\xa7\xea\xd4\x85\xeb\x7c\x9d\xaa\xf0\x7d\xb9\xff\x88\xb9\x9a\xda\x6f\xc1\xdc\x1e\xe7\xcd\x0e\x35\xd3\x5a\xb6\x8c\x08\x37\xc3\x53\x12\xda\xc4\xa4\xa4\x84\x9b\x6d\xac\xf4\x8c\x34\x6f\x44\x44\xcb\x84\xa4\xa4\x56\xa3\x2a\x93\xac\x96\x4e\x6f\xd3\x89\xc9\x8e\xa3\x69\x2b\x6c\xbb\xb7\xe9\x26\x67\x4f\xed\x60\x3a\xcf\x2a\xae\x74\xb3\x71\x13\xd4\xcb\x76\x0f\x7b\x0b\x8c\x54\xea\xb9\x60\x9d\x25\x9c\x57\x30\x65\xd6\xd8\x9a\x85\xe5\x03\xb2\x2b\xef\xbb\x47\xbd\x7c\xd7\x0d\x13\x9a\x4a\x4e\xfd\x45\x15\xb4\x49\xbc\xfc\xfc\x6b\x96\x75\x7c\x51\xb5\xcf\xf6\xdd\x7d\xe3\xab\x59\x09\x36\xfe\x73\x7d\xcb\x5c\x4e\x47\xb9\xf4\x96\xc1\x72\x91\x77\x50\xec\xc0\x01\x03\xe3\x4d\x67\x9f\x96\x9d\x9d\x6c\x34\x99\xdd\x52\xa4\x9b\x94\x0e\xb1\xda\xbe\x57\x69\x85\x86\xf6\x3f\x58\x19\x5d\x74\xa0\x32\x32\xda\x1d\x6d\x44\x86\xba\x43\x0d\x36\xa7\xe8\xd0\xe8\xdc\x5e\xbd\x52\xf7\x57\xf6\xb2\x3a\xe5\xe6\x76\xd8\x5f\x99\xcb\xf9\x51\x12\xa2\xf6\x04\x16\x2e\x42\xd3\x53\x3b\x00\x6b\xf6\x39\x7b\x7d\x7c\xf0\x6a\x62\xe8\xdd\xde\xa5\x67\x35\x37\x32\x83\xd5\xde\xb4\x6f\x62\x4c\x75\x2e\x13\x92\x9e\x66\x19\xd1\x71\x31\x56\x7e\x5e\x46\xcf\x78\x27\xa2\x19\x46\xf7\x28\xc9\x48\xf5\x88\xb2\x65\x7a\xc6\x82\x88\x3e\xd2\xbc\xe8\x7b\xec\xe9\xe5\x56\xb7\xda\x8b\xc7\xd7\xce\x7c\xe2\xd3\x6d\x13\x6a\x2e\x09\x8d\x88\x4e\x9d\xbc\xb1\xda\x77\xe4\xe4\x61\xdf\x5d\x7b\x6f\x52\xd1\x4f\xdf\xac\x8c\x35\x9d\x6e\xf0\x1d\xa8\xff\xdc\xb7\xe5\x69\x2a\x6d\x97\x8a\x52\xe3\xd4\xe2\x53\x1f\x67\x27\xa5\x55\xba\x97\x44\x77\x9a\x39\x6f\xa8\x71\x7c\xa7\x6f\xdb\x9b\x97\x66\x8f\xb9\x6e\xf1\xe5\x3f\x6d\xab\x6a\x71\xe6\x48\x66\x6d\x5c\x7c\xea\x26\x95\xb0\xe1\x07\x15\xfe\x99\x6f\x8a\xcf\xf7\x9c\xef\xfd\xbf\x94\x4d\xf1\x5e\x38\x73\xa7\x9a\x70\x48\xa5\xa8\xbf\xfb\x7c\xcf\x9f\xe9\x50\x3a\x2c\x2b\xc9\xe8\xea\x98\xed\x03\xd7\x38\x11\xc7\x0e\xce\x8a\x91\x9c\xe4\xaf\xf1\x8e\x0d\x8f\x69\xd9\x12\x9c\xa3\x23\xa2\x22\x23\x2d\x2b\xca\x65\xc6\xc5\x86\x47\x44\x47\xd4\x54\xc6\x44\x47\xab\x28\x87\xe5\x6a\x19\x69\x5a\xca\x9a\x52\x19\xa6\x62\xea\xe3\xd4\xfa\x38\xb5\x32\x4e\x95\xc5\x29\x6f\x9c\xf2\xc4\xa9\xa8\x38\xf5\x69\x9c\xda\x17\xa7\x36\xd9\xfc\x85\x71\x2a\x37\x4e\x9d\xf5\xed\x20\x70\xf3\x88\xd7\x67\xce\xe0\x99\xe4\xb7\xcb\x70\x41\x41\x5e\x1e\xad\xde\x2a\x32\xf5\xf1\x93\x75\xcf\x3e\x86\x9a\xa9\xa6\x32\x53\xd5\xc3\xbe\x59\xb5\xea\x23\x95\xa6\x3e\x9c\x79\xe6\xa1\xbb\x56\x9e\x39\xb3\x4c\x5d\xfe\x91\xda\x3e\x64\xc8\x90\x44\xeb\xf3\x53\x49\x89\xb4\xaa\xda\xf7\x57\xab\xed\x99\xad\xcc\xd2\x34\xff\x49\x47\xb2\xbd\x5f\xc6\x48\x3b\x95\xe8\x7d\x29\x34\x4d\x92\x1c\x11\x11\xad\x5a\xb9\x93\xd2\xac\xac\xf6\x6e\x47\x4b\x47\xcb\x9a\x4a\x87\x23\x21\x36\xa1\xf5\x94\xca\x04\xb3\x06\x8a\x8d\x9a\x52\x19\xdb\x0a\x8a\xd9\x9a\xa5\xd6\x65\xa9\x15\x59\x6a\x54\x96\xca\xc9\x52\xee\x2c\x15\x99\xa5\x8e\x65\xa9\x7f\x64\xa9\xe7\xb3\x14\xbd\xf7\xda\x02\x0b\xb2\xd4\x94\x2c\x55\x98\xa5\xfc\x59\xea\x13\xbb\xf7\x5e\x7b\x54\x13\x3f\x30\xb0\x57\xa0\x3b\x30\x72\x5d\x33\xa5\x4d\x1a\x9b\x74\x05\xba\x02\xf2\x01\x5d\x4d\x5a\x42\xce\xf9\x9a\x7b\xc1\xef\x7c\x7f\x39\xf7\x03\x8d\x5e\x7f\xf5\x46\xd0\x7c\x77\x3e\xeb\x5b\x0c\x75\xdd\xad\x5d\xb6\xe2\x36\xda\x23\xd6\x7e\xd0\xa5\xea\xe0\xec\xdf\xbe\x7b\xaa\x47\x4f\x67\x7b\xcb\xb6\x52\x33\xcd\xf3\x67\x2c\xba\xf6\xe6\xb9\x33\x67\xac\xba\xfd\x91\xf5\x63\x2f\xba\xe0\xf4\xa8\x47\x1e\x31\xae\x55\x2d\x7c\xb7\x5d\xf6\xec\x6e\xdf\xa7\xbe\x1f\x7c\xbd\xcc\x7f\x5d\x34\xcb\xd7\x79\xa1\x2f\x71\xd5\x15\x67\x3e\x75\xde\xf0\x33\x89\x59\xdc\x76\xc8\xba\x4d\x4b\x1e\x4d\x8c\xfd\xeb\x0d\x2f\xbd\xee\x64\x9d\xab\xf5\x7f\xeb\xc8\x66\x2d\x4a\x94\x89\xde\x9e\x51\x1c\x1c\x43\xe3\x13\xcc\x84\xa4\x64\x67\xf8\x94\xca\xf1\x61\x2a\xcc\x69\xdd\x17\xaf\x6e\x8f\x57\xc5\xf1\xca\x94\xf8\xdc\x78\x23\xdc\x11\x2f\x12\x3b\xa5\x92\xc5\x28\x59\x2d\x4c\x56\x39\xc9\x54\xd4\x05\x81\x9b\x0b\x33\x56\x7f\xc5\xa2\x98\x9a\x96\xd9\xc6\x05\xc9\x23\xd1\x51\x92\x9a\x17\x1f\x1b\x38\x90\xd9\x17\xaa\x1e\x85\x2a\xdf\x74\x5a\x66\x8e\x6f\xab\x6f\xb5\x9a\xad\xa6\x7e\x75\xd2\x59\x95\x74\xd5\xd6\x2f\x0f\x7c\x7a\xe0\x82\x07\x72\x3d\xd5\xce\x2a\x1f\xf5\x3b\x53\xf5\x53\x15\x6a\xc6\x20\xdf\xae\x17\xab\x7c\x9f\xf8\xf6\xf9\x1a\x7c\x1f\xf4\xed\x70\xc8\xf7\x70\xba\xfe\x7f\xb4\xc4\x9c\xc9\xf0\x9f\x76\x4c\xa7\xb6\xc2\x38\x51\xe6\x79\x93\x24\xc2\xd1\x2a\xa2\x55\xdb\x36\x76\x1d\x59\x76\x1d\xe9\x1a\x72\xd5\x50\x47\xcd\xf0\x6f\x76\xdb\x33\x02\x38\xf7\x57\x2a\xe0\xe6\xff\x8f\xb8\x37\x81\x8f\xa2\xca\x16\x87\xef\xa9\xa5\xf7\xa5\x7a\xa9\xde\x3b\xdd\x9d\x4e\xa7\x49\x02\x26\x10\x92\x80\x01\x52\xc4\x10\xc2\x62\x12\x20\x2c\xcd\x92\x44\x45\x64\x91\x4d\x11\x15\x1c\x45\x1f\xea\x20\xb2\x8d\x08\x0a\x2a\xa8\xe8\xe8\x18\x85\xd1\x3c\x47\xc7\x19\xc5\x11\x67\x74\x90\x91\x99\x27\xe3\x43\x44\x70\x86\xd1\x37\xe3\x02\x32\xe8\x53\x20\x95\xef\xde\x5b\x55\xdd\xd5\x21\x33\xff\xef\xfb\xfd\xfe\xbf\xdf\x27\x42\x75\x55\x9d\x7b\xea\x2e\xe7\x9e\x7b\xb6\x7b\x6e\x2a\x49\x3b\x9c\xf3\x7f\x70\x7a\x7c\x67\xf3\x5d\xdb\x1b\xe5\xfb\x70\xf5\x32\x58\x1e\x78\x51\xae\xfb\xac\xab\x8b\x79\x0c\x93\xbd\xf3\xc2\x93\xa6\x65\xa7\xd9\x15\xf2\xab\xf2\x3e\xf9\xa7\xf2\x5e\x4e\xe9\x5e\xdc\xa7\x49\x84\xb8\xaf\xa8\xed\xfc\x7e\x69\x4a\x20\x68\x34\x38\x5c\x2e\xc1\xe6\xf5\x02\x08\x86\x20\x17\x8d\x38\x3c\x36\x4f\x67\xc6\x35\xc8\x86\xbb\xd4\x26\xd8\x18\xb3\xc1\x66\xe3\x82\xe1\xb0\xb7\x33\x13\x86\x8e\x4c\xd8\xcd\x59\x3b\x33\x46\x8e\x63\x3a\x32\x1c\xbb\x35\x0a\x2b\xa2\xd0\x16\x05\x29\x0a\x4c\x45\x14\xe2\xa4\xbf\x3b\x14\xb7\x01\x65\x8e\x4a\x73\x94\xe5\x80\x0e\x40\xde\x2c\xae\xcc\x11\x56\x1d\x10\x22\x22\x12\x31\x6e\x6e\xa2\xa6\x12\xff\x4a\xb8\x2a\xe3\x64\x10\x12\xc9\xae\x2e\x6e\xe5\xac\xf8\xb2\x0f\x0e\x43\x47\x2c\x93\x89\xc9\x8f\xe3\x45\xb7\x75\xf8\x2c\xcf\x85\x71\x4a\xb3\xe4\xe7\x8e\x3a\x64\xef\x56\x79\xee\x43\x3d\x17\x84\xef\xe5\xfb\x90\xda\xce\x3b\x71\x3b\x03\x30\x52\xfa\xb3\x1b\xc0\xe0\xf5\xfb\x7d\x36\xab\xd5\x67\x60\x83\x21\x2f\x9e\xe8\x9d\x19\x7f\x87\x7b\xa9\x9b\x19\xe4\xc6\x2d\x75\x0b\x6e\xc6\xcc\xbb\xdd\x66\xce\xec\xea\xcc\x38\x6d\xe0\x64\x6d\x36\xb3\xd9\xd8\x91\x31\xb3\x60\xe0\x0c\xb8\xb1\xee\xdd\x21\x58\x13\x82\x96\x10\x94\x87\xc0\x19\x82\xde\x10\x9c\x0e\xc1\xde\x10\xdc\x11\x82\xce\x10\x48\x21\x40\x21\x38\x13\x82\x93\x21\xd8\x1f\x82\x4d\x21\x58\x1a\x82\x0e\x0a\x5f\x47\xe1\x2f\x57\x0a\xbc\x4f\xcb\x6c\xa6\x65\x5a\x43\x50\x11\x02\x81\xe2\x3a\x11\x82\x37\xe8\xab\x0e\xad\xc0\x69\xfa\x10\xc3\xef\xa3\xf0\x18\xe3\x32\x5a\x04\x7f\x29\x4e\x3f\x76\xa9\xb5\xb5\x1f\x2b\xab\xfe\x8d\xa6\xc2\xd3\x7f\x55\xe9\x14\x69\x23\xd3\xef\xd0\x10\xad\x4f\x51\xef\x95\xd1\xb9\x0c\xb2\xc3\xc3\x58\x4e\xf4\x8c\xdd\xd5\xc5\xb5\xb7\xc7\x07\xff\x65\xf4\x53\x30\x96\x0c\x0d\x33\x42\x1e\x10\xd6\x46\x65\xfb\x57\x46\x63\xcf\xb1\x9f\xc9\x23\xba\x94\xb9\x6c\x00\x3c\x97\x0b\xd1\xd3\x52\x81\xdf\x28\x38\xb1\x72\xea\x34\xb2\xc9\x22\xa9\x68\x59\xd1\xfe\x22\xd6\x59\x04\x42\x51\xbc\xa8\xb3\x88\x2d\x22\x09\x7e\x26\x4d\x9a\xde\xb4\xb7\x08\x36\x17\x41\x47\x11\xa0\xa2\x0a\x0c\xc6\x0e\xdb\x57\x74\xb2\xe8\x4c\x11\xfb\x7e\x51\x6f\x11\x9e\x58\xad\x45\x6b\x8a\x36\x17\x71\xbb\x8a\xa0\x15\x17\x5b\x46\x50\xc4\x8a\x18\x13\x5b\x18\x8d\x45\x3b\x32\xb1\x18\x16\xcd\xbd\x1d\x19\xc1\xc2\xb1\xa1\x8e\x0c\xeb\xc9\x17\xcd\x49\x5b\x81\x2c\xe2\xb8\x83\x94\xde\x2a\xc3\x7d\xe4\x72\xfb\xb3\x76\xbf\x54\x76\x59\x4e\x0c\x21\x3e\x0e\xd2\x78\x8d\x39\xd0\xee\x10\x8d\xfc\xed\xb7\xc9\xaf\xfc\xc7\x31\xf9\xd5\x9f\xc3\x9d\x70\xed\xf4\x4d\xb7\x3d\x3d\x33\xd0\xf2\xfa\xb5\x7f\x3f\xf2\xe9\x91\x15\x0b\xba\x98\x85\xff\xd1\x58\x32\x78\x37\x0c\xf9\x23\x4c\x82\xeb\x1d\x81\x72\xf9\xbd\x17\xaa\x47\xc8\x9f\x60\x26\xf1\x37\xf9\x78\x12\xd6\x86\xc6\x8f\x0f\x21\x95\x56\x0d\x7e\x3a\x27\x6f\x94\x46\x5b\x7c\x3e\x97\x39\x18\x64\x5c\x4c\x34\x62\x0e\x60\x62\x34\x83\x95\x35\x9b\x11\x2f\x58\x4d\x2c\xcf\x76\x64\xec\x3c\x1b\xf4\xb9\x18\x84\x67\x20\xa6\xe3\xce\x28\x60\x5e\xb7\x2f\x0a\xbb\xa3\xd0\x4a\x27\xa2\x32\xea\xa8\x6e\x08\x95\xfa\x2a\x03\x8a\xfd\x8e\xc8\x7f\xfd\xa8\x24\xb8\xa1\x95\x55\x6a\x73\xb0\x7e\xaf\x5c\x95\x11\x4f\xe0\x2b\x9e\x7a\xcc\x03\x5d\x4c\x51\x17\xf3\xe0\xf3\xcf\xf7\x2c\xea\xea\xf9\xb8\x6b\x7c\x88\xbb\x89\x0c\xb1\x2c\xc0\x19\x72\xbd\xb0\x9e\xb4\x83\xf1\xf7\xfc\x3d\x34\x1e\xb7\x65\x0c\x66\x7a\xff\x8d\xdb\x62\x45\xb3\xa4\xe1\xc4\x9c\x64\xb7\x1a\x4c\x78\xfe\x98\x58\x62\x48\xc2\x03\xe1\x3e\x69\x87\xfd\x76\x58\x66\x07\xc9\x0e\x15\x76\x88\xd3\xdb\x7d\x76\x58\x63\x87\x0e\xed\xa1\x8e\x76\xf3\xa8\x56\x33\xc9\xa5\xb2\x44\x29\x1a\x99\x81\x5d\x3d\x8b\x69\x3d\xe7\x92\x9a\x28\xb5\xa3\xfd\x3a\x0b\xeb\x71\xef\xe0\xba\x88\xa8\x54\x12\x6d\x06\x51\xf4\xf9\xcd\xee\xce\x8c\xc3\xec\xe1\x31\x67\xee\xc8\x30\x6c\xd6\xa8\x55\x96\x35\x67\x81\xd2\x07\x44\x51\x2f\xce\xaa\x67\x55\xf0\x6d\x17\x73\xc7\x43\x67\x3e\x99\xb0\xa5\x2c\x53\xe0\x69\x2c\x1d\x33\x8b\xfb\x28\x34\x6e\x5c\xe8\xe2\x9f\x8f\x7e\xe1\xc2\x55\x7e\xc9\x1f\xea\x6c\xd7\xc6\xb2\x04\x7f\x33\x88\xce\x4b\xcf\x9a\x58\x23\xe7\x67\x7c\x16\x0b\x16\x90\x58\x86\x0b\x87\x44\x3f\xc3\x0a\x6e\x2c\x39\x98\xcc\x3e\xd6\x1e\x74\xb3\x16\xce\x69\x77\x76\x64\x8c\x76\x77\x77\x18\x26\x84\x21\x1c\x06\x6b\x18\x2e\x84\xe1\xb5\x30\xac\x0f\x43\x59\x18\xbc\x61\xe0\xc2\x70\x2e\x0c\x07\xb0\xc8\x42\x61\x86\x52\x98\xe1\x18\xe8\x8b\x30\x1c\xa4\xa0\x3b\x29\xf4\xea\x30\xd4\xd2\x32\x56\xfa\x7b\x91\x56\xa0\x56\xc3\x7b\x8c\xc2\xef\x0b\x03\xb3\x3b\x0c\x6b\xc2\xd0\x1a\x06\x29\x0c\xf1\xb0\xd2\xdf\x1d\xfd\x30\x12\x8d\x93\xe4\x1e\xab\xf6\x60\x2a\x95\x51\x1f\xa2\xbf\x1f\xa6\x21\x1a\xcd\x44\x1e\x03\xa3\x4b\x37\x50\x2e\xdc\xb5\xfc\xaf\xf7\xc8\x63\x98\xe6\x1f\xc9\xe3\x65\xeb\x8a\x37\x7b\x66\xe0\x71\xdb\xfa\x3c\x73\xcd\x6a\x7e\xe4\xb8\x90\x7c\x6b\x8f\x2b\x3c\x8e\xb9\x67\xae\x5c\xaf\xf1\x90\x71\xa1\x9e\x4f\x98\x42\xbc\x70\x69\xf3\x84\x47\x34\xc7\xd4\x58\x69\x00\x63\x35\x18\xad\x46\xc1\x05\x36\x87\xad\x23\xe3\x60\xcd\xd6\x8e\x8c\xc1\x6c\x66\x3a\x33\x66\xf7\x6e\xea\x08\x97\xa8\xe7\xbc\xcf\x6a\xa4\xb7\x22\xe1\x8a\x62\xa2\x1f\x52\x43\x3c\xba\x4a\x25\x99\xa3\xef\x83\xeb\xc8\xdc\xc9\x33\x8b\x2f\x8c\xeb\x7a\x8e\xf9\x4f\xee\x5c\xe8\x02\x96\x5b\xfd\xf2\x22\x75\x01\xd5\xea\x61\x9c\x4c\xd7\x96\x02\xe9\x4d\x40\x76\xbb\x29\x64\x63\x59\x93\xc3\xef\x77\x9b\xdc\xc1\x10\xb2\x0b\x76\x46\xe0\x30\xe1\xbb\xcc\x56\x33\x26\x33\x9b\x23\xc0\x59\x59\xd6\xed\x67\x4d\x06\x13\x96\x4e\x40\x64\x0d\xee\xb2\x10\x84\x43\x60\x0d\xc1\x85\x10\x7c\x11\x82\x63\x21\x38\x18\x82\xd7\xe8\x12\xb0\x8b\x72\x7b\xa6\x8e\x2e\x35\x02\x5d\x03\xde\xd0\x9e\xde\xa1\x5b\x58\x62\x74\x9d\x18\xde\xab\x2b\xe4\xd4\xa0\xf7\xea\xa0\x5b\xe8\x62\x72\x98\x2e\x4c\xfb\xb4\x87\xad\xda\x9a\xd5\xef\x52\x91\x2f\x26\x76\xe8\x24\x45\x54\xe7\xd7\xc4\x72\xbf\xba\x64\x50\x77\x95\x9e\xa9\x50\x4b\x07\xee\xde\x44\x52\xb7\x7c\x98\x21\xc7\x5b\xd8\x1b\x6a\x64\x57\xb7\x4c\xd8\x8b\x13\xee\x80\x7b\x99\x50\x57\x57\xcf\xb5\xdd\xdc\xe2\x0b\xff\xab\x0d\xfd\xc5\x8d\xec\x0d\xe3\x42\x17\xee\xa3\xf7\x66\xda\xef\x69\x3c\xfe\x5d\xb8\xdf\x3d\x78\xfc\x8b\xdc\x78\x79\xc6\xf7\x58\x4c\xf7\x8a\x3c\x72\xba\xf1\x2c\x32\x31\x6e\xd6\xec\xb0\x39\x88\x40\x65\x73\xb7\x8a\x80\x07\x5e\x71\xe5\x07\xea\x72\x2e\xfd\xe1\x6e\x5a\xcf\x21\xae\xdc\x64\xd7\x57\x13\xb8\xff\xe8\x86\xe3\x5d\x37\x5d\x7c\x9b\xd6\x0f\x0e\x32\x5b\x94\xa9\x7e\xa1\x98\xab\xbe\x78\x59\xb6\x7a\x3f\x55\xe4\x3b\x22\xa3\x1e\xa1\xfa\xb2\x8f\xd8\x59\x90\xcd\xe0\xb2\xb9\xfc\x01\x2f\x66\xd4\x5e\x8f\x03\x8f\xbe\x83\xab\x0b\x40\x79\x20\xdf\xce\x92\x95\xee\x88\xe9\xde\x45\xcd\xf8\x20\x24\x14\x01\x0f\xeb\x80\xfb\xf6\xbe\xfe\xeb\xbd\x7b\x7f\xfd\xfa\x5e\xb9\x9b\x79\x15\xcb\x97\x9d\xf2\x23\x72\x97\xfc\xbc\xbc\x83\xd9\x2d\xbf\x29\x9f\x06\x37\x8c\xc2\x72\xa7\x45\xfe\x4e\x7e\x8b\xe9\x92\x9f\xc2\x22\xea\x73\xf2\xe3\xd0\x4e\xea\x43\xe4\x9e\x67\xa9\x2e\x13\x40\xdf\x49\xcf\xf2\x98\xf7\x20\x9f\xd3\x17\x0c\x99\x0d\x78\x66\x98\xdd\x76\x37\x96\x3a\x09\x07\xc2\xbc\x87\xb2\x1e\xfb\xff\x7f\x82\x4d\x56\xa4\xc9\x51\xe1\xff\x47\x41\x26\xa7\xaa\x64\xa9\x4f\xa7\xa4\xf0\xb9\x51\x8d\x73\xa2\x90\x60\xaf\xbb\x79\x5b\xcb\x94\xf5\xb7\xcb\x7b\x4e\xf4\x34\xee\xea\x62\x5a\x20\x0a\x21\xd9\xc7\xee\xdb\x7d\x47\xcf\xf3\xf7\x9f\x97\xa7\x69\x83\xfb\xc6\x7b\xf2\x6c\x32\xb6\x72\x37\x7f\x02\x8f\xad\x1f\xf7\xea\x5f\xa4\xed\x78\xc1\x0f\xa0\x02\x3b\x66\x41\x45\x29\x0b\x12\xc0\xcc\x0a\xa2\x24\x86\x31\xf7\x16\x3d\x4c\x02\xcf\x73\xee\xb5\x14\x3c\x97\x82\x9d\x29\x58\x9f\x82\xd5\x29\x08\xa7\xc0\x9a\x82\x73\x29\x38\x95\x82\x6e\xfa\xa4\x96\x3e\xb9\x90\x82\x2f\x52\x70\x2c\x05\x07\x53\xb0\x28\x05\xb3\x52\xd0\x90\x82\xa1\x29\xe0\x52\x30\xec\x20\x2d\x8c\x1f\x4d\xa0\xd0\x65\x14\x0b\xc6\xbb\x35\x05\x6d\xf4\xb7\xfe\xb9\x33\x05\x26\xa6\xa3\x3d\xdb\x3f\xff\xa2\xd3\x72\xfa\x1d\x95\x80\x88\x95\x86\x04\x81\x0c\xc9\xa9\x41\xd4\xe6\xea\x51\x28\x90\x27\x1e\x0a\xe2\x4e\x4d\x16\x5e\xc6\xa4\x8b\x90\x9e\x48\xe7\xaa\xe4\x78\xdf\x90\x07\x16\x0c\x2d\x10\x1f\x1e\x35\x6e\xf9\x55\x73\x16\xca\x2f\xc9\xbb\x61\xa2\x46\xb3\xcc\x6e\x95\x26\x9d\x9b\x46\xbe\x62\x9a\x66\x89\x85\x87\xcf\xb9\x97\x81\xab\x60\x52\x3e\xed\x2a\xf3\x87\xf0\xf4\xa3\x98\x5e\xbd\x28\x8a\xae\x93\x6a\xbc\x4e\x67\x48\xb4\xdb\x31\xe9\x78\x04\x30\x18\x84\x82\x98\xd7\x89\x42\x58\x58\x0f\x85\xb0\x6c\x1e\xc4\x24\x4c\x65\x72\x41\x11\xca\x3d\x9c\xfb\x70\x0c\x2a\x62\x74\x72\x69\xcb\x52\x99\x4e\xc4\xab\xd4\x11\x06\x99\xf6\xaa\x15\x3e\x9f\x2e\x78\xb2\x54\x99\xb3\x54\xc3\x58\xbb\x7a\x6e\xc5\xd4\x71\x27\x0c\x80\x22\xf9\x2c\xcc\xdb\x22\x37\x63\x1d\xcb\x78\xdb\x53\xf7\x6f\xd9\x71\x17\x33\x4c\x1e\xa8\x91\xc9\xcb\x6f\xca\x27\x27\xcb\x02\x5e\xb3\x86\xc1\xfd\xdb\x6e\xea\xf9\x70\x8d\xb2\x3e\x2c\xee\xfd\x92\x8b\x50\x5f\xd2\x6a\x69\x02\x20\x14\x71\xfa\x44\xd1\x98\x74\x26\x4b\x4a\xc3\xc6\x32\x23\x83\x22\x15\x11\x29\xb2\x2f\xc2\xd9\x39\x63\x24\xe5\x4e\x61\xb1\x68\x32\x40\x03\x80\x08\x40\xa2\x58\x6c\x06\x48\x79\xdc\xc1\x8e\xcc\x74\x1f\xf8\xdc\x5c\x4b\x29\xd4\x95\x42\x79\x29\xd0\x95\x0c\xab\xaf\x64\x14\x55\x75\x56\x31\x48\x11\x12\xd0\xeb\xb4\x8a\x8d\x92\xca\x2e\x71\x62\x2a\xbd\x8c\xa5\x16\x37\xd5\xe3\x40\x6c\xe6\xfe\x02\x46\x24\x51\x13\xe9\xc5\x33\x06\x95\xfe\x6c\x16\xc4\x16\xdf\xd4\xb5\x7d\xfe\xa8\x6f\xfe\xe7\x99\xf7\x32\x83\xe6\xfd\x78\xf5\xda\x25\x37\xfd\xed\xb9\x99\xb2\xf9\xc6\xd3\xd3\x60\xe7\x87\x83\xeb\xbf\x1c\x3f\x6f\xc0\xf0\xb1\x9d\xeb\xe6\xfe\xfc\xd5\x32\xf9\xcd\x57\xc6\xcf\x6a\xbf\xa2\x23\x35\x61\xe9\x9e\xa5\xf2\xd4\x74\x9c\xb4\x19\xff\xc3\xd7\x50\xde\xbc\x58\xaa\xc7\x7a\x96\xcb\x68\x32\xb9\x18\xc6\x2b\x12\x67\x4f\x67\xc6\x66\x32\xb3\x8a\xcc\x8a\xdc\x92\x08\x15\x22\x08\x22\x20\x11\xce\x88\xb0\x5f\x84\xcd\x22\xac\x11\x61\x99\x08\x98\x67\xe3\xb7\x71\x11\xf4\x04\x9c\x15\xd2\x2a\x73\x22\x60\x56\xd4\x20\xe3\xa8\xfa\x7c\x54\xed\xd1\x2f\x42\xf5\x91\xca\xbf\xcd\x09\xcf\xe2\xfd\xb3\xc3\x53\xbe\x1d\x7c\x04\x8f\xd6\x52\xef\x0f\x70\xb3\xbc\xee\x07\xf7\x85\x07\xc2\xe3\x48\x7d\x2b\x7b\xbf\xe2\xb7\x52\x39\x6d\xac\x54\xe2\x17\x58\x8b\x60\x09\xe1\x75\xc6\xc7\xba\x3c\x2e\x2c\x48\x78\x58\x3b\xba\x2a\x63\xf7\x60\x39\x69\x99\x26\x27\x55\xa8\x72\x52\x56\x93\x50\x7d\x64\x2a\x33\x4f\x61\x31\x51\x15\x74\xbc\x5c\x32\x5e\x94\xbd\xf1\xb1\x8d\xdb\xf6\x74\xc3\x3b\x0f\xc9\xe7\x7e\x90\xff\x29\x7f\xfa\x10\x73\x47\xd7\x93\xab\x9e\x79\x92\x15\xa9\x04\xf9\xcf\xff\xf9\xfe\xc2\x57\x2c\x4f\x7f\x7f\xf5\x38\xd1\x95\xfc\xbd\x9f\xf2\xfb\x70\xdd\x1c\x10\x91\x0e\xb0\x9c\xd5\xca\xdb\x18\x0b\xcf\xf0\x82\x93\xb1\xd8\x58\xde\x88\xe9\xc5\x61\x64\x2b\xac\x90\xb0\x82\xd7\x0a\xac\x15\x1c\xac\x95\xe5\x3c\x45\x02\x78\x05\x38\x27\xc0\x07\x02\xec\x13\x60\x8f\x00\x6b\x05\x58\x21\xc0\x5c\x01\x1a\x04\x18\x2a\x00\x27\xc0\x62\xfc\xee\x80\x00\x5b\x05\xa8\x15\x00\x17\x38\x28\x40\xb7\x00\x3b\x05\x98\x25\x40\x19\x2d\x8f\x81\x4e\x51\x98\x3d\x14\x0c\x97\x6f\xa3\x90\xf8\xf9\x48\xfc\x68\x3d\xc5\x84\xcb\x6c\x16\x80\x59\x23\x40\xab\x00\x92\x00\x71\x01\x04\x01\x4e\x0a\x70\x58\x80\xdd\x02\xe0\xe7\xcb\x04\xe8\x14\xa0\x42\x00\xcc\x29\xf3\xd8\x51\x07\x65\x48\x7d\x03\x10\x2f\x95\x3a\xc8\xda\xad\xf0\xb6\xbe\x7d\xad\x4a\x17\x58\xca\x84\xa4\xb2\x82\x9b\x89\x68\xb9\xef\x8e\x9e\xf3\x77\xf7\x9c\x58\xc2\x8c\x5d\x0f\xb7\x42\xe7\xbd\x58\xa6\x0c\x5f\x30\x71\xdf\x93\xe9\x7a\x71\x0b\xbb\x34\x4c\xec\x1f\xd1\xde\x4f\x8d\x27\x09\xbf\x21\x76\x3e\xa7\xd7\xc2\x7b\x79\x9f\xb8\xc6\x01\x6b\xac\x60\x63\x90\x1d\x33\x75\xbb\xdd\xe8\xb5\x38\x95\x6e\x76\xbb\x8c\xc4\x9d\x6f\x75\xf0\x9c\x67\xa8\x0f\x8a\x7c\x70\xce\x07\x7b\x7c\xb0\xc2\x07\x6d\x3e\xa8\xa5\x4f\xac\x3e\x58\xf4\x81\x0f\x5e\xa3\x2f\xf0\xa3\x2f\x7c\xf0\x9c\x0f\x56\xe3\xa7\x3e\xc0\x65\xbc\x3e\xe0\x7c\x70\xca\x07\xdd\x3e\xd8\xe9\x83\xb5\x3e\x98\x4b\x9f\x87\xe9\xf3\x5a\x0c\xfd\x01\x05\x2d\xa3\x10\xf8\x75\xab\x0f\x24\x7a\x8b\x4b\x22\x1f\x30\x67\x7c\x70\xd2\x07\xfb\x7d\xb0\xcf\x07\x9b\x7d\xb0\xc6\x07\xcb\x7c\xd0\xe9\x83\x0a\x1f\x94\xfb\x74\x46\x80\x0e\x5d\x4f\xf6\xd7\xbb\xed\xba\x9e\xf5\x57\x2a\xb3\x89\x58\xab\xa9\x52\x58\x59\x39\x67\x8e\x8e\x96\xf9\xa4\x39\xd7\xb5\x95\xe0\x51\xd4\xdd\xe3\xab\xe5\x17\xe5\xff\x5c\x2d\x37\xdc\xc4\xcc\x7c\x14\x0a\xe0\xf2\x1f\x41\xed\x57\xcf\xc2\x8b\x37\xc5\xd8\xda\x8b\x6f\x73\x3f\x50\x12\xfe\x94\x15\x2e\x9e\x65\xa3\xe4\x37\x99\x67\xc5\x98\x2f\xec\x25\xba\x2d\xb8\xa5\xc6\x90\xe8\xf0\x78\xed\x86\xb0\x8d\x04\x1a\x18\x21\x6c\xb5\x07\x9d\x1e\xd1\x12\x8d\x0c\xa5\xb6\x23\x2e\xea\x8d\x32\x67\xc8\x75\x68\xb4\x21\xda\x16\xe5\xae\xdf\x13\xfd\x20\x7a\x2e\xca\x92\xdb\xb9\xd1\x15\xd1\xad\xd1\xee\xa8\x21\xfa\x4a\xef\xfe\x97\x6e\x5c\xd5\x44\xaf\x73\xae\xa1\x57\x29\x34\x63\x56\x53\x3c\x57\x72\x45\x74\x6d\xd4\x50\x7b\x00\x97\x65\xe8\xeb\xa9\x63\x26\x36\x2d\xa2\x96\xaa\xda\x28\xbc\x16\x3d\x18\xfd\x22\x7a\x21\xca\x91\xef\x0d\xc5\x88\x39\xfc\x4d\x06\x45\x85\x68\x45\x54\x8a\x2e\x8b\xae\x89\xee\x8e\xee\x8b\xee\x8f\x9e\x8c\x5a\x4c\xac\x3d\x6c\x66\x6d\x0e\x0f\x6b\x24\x0b\x8f\x60\x66\x91\x18\x62\xa9\x22\x1b\x60\xdd\x3a\x03\xb5\x4a\xa0\xc3\x87\x03\x65\xcc\xb4\xc7\xcb\x70\x97\x2f\x2f\x2b\x2b\xa3\x06\x06\x3c\x08\x39\xeb\x42\xd6\xc6\x40\xd7\x21\xb3\xd2\xd1\x1e\xad\xbf\xe9\x43\x80\xf1\x4f\xcb\xd5\x5b\x61\xaf\xbc\x66\x3b\xb3\xe1\x67\xff\x80\xe8\xd3\x70\x70\xab\xfc\x00\xfc\xe2\xa1\x9e\x1b\x7f\x26\x7f\x32\x97\x50\x35\x53\xc4\x4c\x26\x1d\x2d\x6f\x83\x85\xf4\x3a\xb8\x27\x43\x6d\xdb\x6f\xd0\x75\xa8\x08\xf7\xfd\x6e\xba\xb6\xbe\x2a\xdd\x86\x8c\x46\xd1\x67\x77\x7a\x59\x93\x85\xe8\x20\x46\x70\xf2\x46\xe4\x60\x39\x97\x25\x6b\xe1\x9a\x45\xa9\x32\x4b\xbf\x13\x28\x79\x7b\x35\xe2\xc5\x34\xdf\xa0\xd0\x2c\x06\x3a\x46\x81\x16\x51\x82\x3f\x49\x49\xb8\x9b\xd2\xff\x56\x4a\xc2\x98\x40\x99\x4e\x4a\xc6\x15\x94\x86\x35\xed\x32\x2b\xa7\xb4\xe7\x49\x27\x59\x06\xef\xa6\x91\x6f\xba\xe0\x83\xdc\x5a\x9d\x9b\xe7\xf8\xc2\x6e\x3a\xd2\x13\x3a\x22\xcf\xdf\xce\xbc\xd8\x0d\x43\x60\xc0\x1e\x78\x67\x23\x23\xc8\x6d\xb4\xed\x4f\x33\x87\xa9\xe2\xf8\x07\x66\x08\x25\x42\x40\x57\x63\x99\xf8\x6b\xdc\x0f\x6e\x78\x57\xea\x75\x0a\xbc\x01\xcb\x6e\x06\x0b\x32\x23\xaf\x47\x40\x16\xb7\x05\xcf\x73\xb7\x19\x19\xc0\x6e\x30\x80\x09\x3a\x33\x26\xb6\xcd\x0b\x0d\x5e\x18\xea\x85\x22\x2f\x78\xbd\xc0\x79\xe1\x9c\x17\x3e\xf3\xc2\x9f\xbd\xf0\x5b\x2f\x74\x7b\x61\x9b\x17\xd6\x7a\x61\x85\x17\xae\xf6\x02\x06\x6e\xcc\x07\x5e\xf8\x9d\x17\x4e\x51\xe8\x03\x5e\x78\xda\x0b\xf7\x78\x61\xa5\x17\xe6\x51\xb8\x6a\x2f\x14\xeb\x90\xfe\xc5\x0b\x1f\x50\xb0\x17\xbd\x40\x5c\x21\x9b\x35\x6f\xc8\x5c\xea\x2b\xd1\xd7\xe2\x1c\x45\xaa\x40\xe3\x2a\x6c\xa5\x30\xfa\x9a\x62\x8c\x97\x63\x88\xfd\xf4\xf5\x1e\x0a\xb1\x96\x02\x0d\xa5\xc5\x70\x6d\x3b\xbd\x52\xbd\xea\x82\xa9\xa0\x45\x04\xad\x1e\x7a\xcc\x4a\xd1\x35\xb4\x44\xf6\x13\x71\x2f\x30\x18\x1a\x33\x4e\xe2\x5b\xc8\x05\x84\xea\xb8\x4c\xbf\x5e\x06\x7d\x28\x68\xc7\xff\x31\x1e\x74\x8e\xe6\xfa\x51\x4d\xf6\xaa\xdd\xa7\x32\x27\xdd\xa8\x53\xa7\x06\xb4\x48\x0f\x48\x10\x7f\x19\x56\xe1\xaf\x66\x3e\x3b\xf3\xd7\x39\xb1\x0c\x67\xeb\x11\x21\x70\xc3\xf1\xc1\xb5\x33\xc3\x17\x36\xdd\xc0\x5d\xe5\xfd\x2f\x98\xb4\xf0\xc2\x83\x3e\x2b\x20\xf9\x66\x4c\x0f\x0f\xc9\x5f\x33\x9d\xfc\x06\x64\x44\x31\x89\x84\xe3\xf3\x08\x99\xcc\x1c\x20\x7c\x2d\x3f\x54\x77\x48\xe7\x08\xf7\xb8\x14\x9d\xf5\x21\x78\xe7\xe0\x41\xf9\x6b\xc3\xae\x2b\x4a\xce\x0f\x2f\xb9\x22\x2f\xe6\x2b\x24\x59\x59\x86\xe1\x01\x71\x8c\x07\x71\x4a\xc8\xd7\x10\xa5\x92\x6c\x25\x24\xbd\xf7\xc3\x9f\x37\xf0\x63\xce\xff\x54\x91\x0d\xc7\xe3\x6f\xbb\xb5\x6f\x73\x58\x02\x36\x1a\x4d\x66\xc6\xc8\x1a\x10\xaa\x3b\x54\x9e\xf7\x6d\xd5\xea\x3a\xfe\xe0\x41\x78\x47\xfe\xfa\x8a\x12\xfe\x77\x25\x57\xfc\x70\x15\xc6\xb1\x0a\xee\xe6\x06\x62\x7a\x36\xa0\xa4\xe4\xe4\x39\x00\x03\x6b\x60\x4d\x46\xe0\x58\x16\xb7\x60\x48\x9d\xda\x5b\xea\x32\x69\x66\x48\xe0\x2c\xfb\xa8\xfc\xb2\xfc\xf2\x26\xe8\x9a\x09\x5d\x70\x37\xf3\x43\x8f\x91\x38\x95\x69\x9d\x7a\xcf\xc8\x7f\xe5\x84\xde\x1b\x95\x98\x39\x96\x47\xb8\x2b\x5e\x55\x62\xe6\x40\x69\x06\x9e\x73\x02\x17\x97\xff\xba\x79\x33\x6d\xc3\x0c\xae\x9d\x09\xf1\x9b\x70\x7f\x25\x25\x37\xcb\x20\x2c\x9a\x18\x8c\x88\xd9\x32\x8b\x06\xf3\x20\xe2\xd1\xd6\xad\x25\x66\xa8\x4a\x78\x44\x38\x20\x6f\x85\xe8\x53\x5c\x3b\xd8\x52\xf2\xe9\x38\x95\xfd\xeb\x7b\xbf\x64\x3f\x65\xdf\x44\x61\x94\x42\xeb\xa4\x56\x7f\x20\x60\x73\x19\x53\x29\x36\x6e\x63\x6d\xe9\x62\xbf\x1f\xb9\x5c\x91\xe6\x8c\xcb\x85\x2c\x96\xe4\xa4\x8c\xd1\xe2\x33\xb0\xcd\x19\x83\x88\xbc\xcd\x19\x24\xa0\x34\x4c\x68\x4d\xc3\xc9\x34\xac\x49\x43\x67\x1a\xf0\x6f\x29\x0d\x48\xbb\xc5\xbf\x73\x1c\xa6\x5d\xd3\xbd\xf3\x2c\xc0\xf4\xa2\x53\x10\x34\xed\x20\x1e\x24\x2c\x38\x8d\x15\xa0\xb8\x6b\xe8\x28\xa8\xa3\x81\xb3\x98\xd6\xaa\x46\x81\xc7\xa8\x7a\x71\x6b\x98\x42\xb8\xaa\x5d\x7e\xda\xd7\x7c\xbb\x24\x1f\x9f\xf6\xc4\x0b\xab\xd6\xb7\xcd\x2f\xae\xdf\xbe\xf1\xbe\xb6\xab\x26\x8c\xa8\x68\x68\x65\xdf\x94\x2f\xf6\x3c\x1a\xa8\x6f\xaa\x4a\x43\x60\xe1\x1d\x23\x39\x76\xdd\xcf\x86\xde\xf4\x57\xbf\x4d\xf6\xb3\x5c\xfb\x82\xa9\xad\x49\x45\xff\x09\x61\x5d\x21\x8e\xe9\xc1\x8a\xf5\x9f\x65\x52\xa3\x60\x34\x46\x51\x20\x1a\x28\x88\x85\xcd\x2d\x99\xb0\xcf\x2d\x8a\x6c\x6b\x46\x14\x1c\xb6\xe6\x8c\x03\xa1\x18\xc4\x63\x20\xc4\x48\xe2\xff\x5a\xac\xf9\xb4\xc6\x60\x7f\x0c\xf6\xc5\x60\x77\x0c\x96\xd1\x5b\x49\x55\x87\xe8\x7f\xca\xec\x5a\xae\xd9\x1d\x14\x23\x6a\x1f\x4d\x19\xab\x03\x46\xea\xc7\x23\x9c\xd5\xe5\x35\xaa\xe1\x74\x58\xd9\x4b\x31\x17\x66\xcd\x2f\x9e\x19\x95\xe6\x5c\xd3\xd9\x73\x47\x27\xdc\x69\x19\xb0\xbd\xe9\xbd\x5f\x7d\x73\xec\x09\xf9\x1d\xf8\xe6\xd5\x2e\x97\xab\x67\xb0\xf0\x26\x17\xf3\x8f\x96\x7f\x3a\xa7\x33\x31\xe8\xe4\xb7\x67\xe5\xaf\x49\x32\x72\xd4\xd8\xfb\x15\x3b\x93\x7d\x1b\x8f\xeb\x28\xa9\xd0\x67\x70\xd8\xed\x61\x43\x38\x12\xb5\xb8\x5b\x32\x76\x8b\x10\x66\xd9\xe0\xa4\x0c\xeb\x3b\x1d\x85\xf7\xa3\xb0\x37\xaa\xa8\x35\x7a\x3b\x6c\xce\x06\x4f\x94\x50\xe2\x40\x07\x45\x79\x21\x16\x78\x6d\x00\xd8\x99\x83\x76\xb5\x5d\xf8\x61\xf9\x9f\xd6\xdf\xff\x54\x53\x69\x61\x7d\x75\x6d\x67\xd5\x8f\x7e\x7c\xdf\xd5\xc3\x8b\x06\x9c\xfd\x61\xe7\xf1\x9b\x92\xf2\x3f\x9e\x0a\x7a\xdb\x9f\xbb\xf9\xdd\xae\x28\xee\xe7\x29\xb8\x9f\x67\xe3\x7e\xf6\xa1\x04\xba\x4d\xba\xd2\x6f\x74\xa0\x48\xc4\x63\xf4\x14\x26\x7d\x9e\xe6\x8c\x4f\x74\x39\x31\xa5\x21\x4b\xac\x25\x63\xb3\x08\x5c\xa8\x35\x43\xf6\xa8\x25\x21\x9e\x04\x21\x09\xf8\x47\xed\xe1\x24\xb4\x26\x61\x7f\x12\xf6\x25\x61\x77\x12\x96\xd1\x5b\x29\x09\x15\xc9\x4b\xba\xbb\x52\xd5\xb3\x03\x7d\x0c\x3e\x6a\x9b\x98\xa4\x1a\x01\xe1\x2f\x1e\x49\x7b\x9d\x58\x4a\x69\x9b\x5c\x64\x38\x98\xe3\xc3\x46\x4c\xbc\xec\xf0\x7b\xc7\x0e\x2f\x5e\x6a\xc0\xdd\x7e\x9d\xbc\x4d\xbe\xa7\x7d\x46\xeb\xb4\xe6\xd6\x99\x73\xab\x8a\xfc\x8e\xd3\xdf\x9f\x93\xc3\x89\x55\x5f\x07\xea\xcf\x1f\x0a\xd4\xc3\xb1\xd7\xde\x2e\x63\x0e\x88\x6f\x2b\xf4\x44\xfa\x7e\x06\xfb\x16\x12\x31\x3d\x5d\x25\x5d\x1e\xe4\x79\x4f\xc8\xc6\x79\xb8\x82\x58\x88\x6b\xc1\x5a\x34\x12\x04\xcb\xa4\x8c\xe0\x43\xbe\x16\x3c\x89\x4e\xc7\xe0\xfd\x18\xbc\x11\x83\xbd\x31\xb8\x23\x06\x4b\x63\xd0\x11\x83\xba\x18\x94\xc7\x72\x82\x65\xdf\x90\x2d\xbd\xeb\x14\x86\xf8\xa2\x90\x10\xbd\xc4\x48\xae\x98\x0c\x48\xcb\xfc\x58\xc5\xac\x1c\x7a\x19\xc0\xd7\x6f\x3c\x27\x7b\x2a\xae\x6f\x9f\x71\x4f\xcd\xde\x29\x9f\x1f\xff\xaf\xdf\x8f\xa8\xfd\xc8\x5d\xc6\xbe\xf5\xde\x87\x93\x85\x07\x6f\xaf\x8f\x5e\x99\x28\xfb\xa6\xe7\xbb\xb3\xd7\xde\xf5\xd4\x3d\x8b\x87\x2a\xfc\xd1\x89\x1b\xf1\x3a\xff\x04\x0a\x41\xad\x74\xd4\x2d\x5a\x2d\x2e\x0b\x9e\x02\xa1\x50\x24\x2c\x86\x02\xa1\xe6\x4c\x00\x4f\x7f\x97\xb7\x25\xc3\xba\x9c\x46\x47\x6b\xc6\x6a\x84\x45\x11\xb0\x46\xe0\x42\x04\x8e\x45\x60\x67\x04\x26\x44\xa0\x2c\x02\x31\xfa\x70\xc1\xb9\x08\xbc\x16\x81\xe7\xe8\x8b\xf5\x11\x58\x1d\x81\x59\x14\xa2\x36\x02\xe5\xb4\xcc\x17\xb4\xd8\x41\x0a\xa6\xc0\x2c\xd2\x60\xea\x22\xc0\x38\x23\xd0\x1b\x81\xd3\x11\x38\x11\x81\xf7\x23\xb0\x37\x02\x77\x44\x60\x69\x04\x3a\xe8\x17\xf0\xdb\xe1\xf8\xdd\xe1\x08\xbc\x11\x81\xcd\x11\x68\x8d\x80\x14\x81\x8a\x08\xc4\x23\x80\x68\x49\x5c\x66\x37\x2d\x73\x26\x02\x6b\x22\xd0\xa9\x15\xeb\x6b\xb1\xc9\x57\x7d\x72\xdb\x2b\xfa\xb1\xc4\x2b\x9a\x91\xa6\x81\xe6\xf9\x45\x2a\x55\x5b\x0e\x89\xe1\xab\xaa\x51\x48\x4c\xa4\x2a\x7f\x14\x2a\xc5\xa4\x22\x49\x3d\xba\x71\xe3\x81\x5f\x5c\x73\x85\x14\x0d\xa4\xe7\xbe\xf1\xc6\xc3\x3d\x27\xe7\xb1\x0d\x63\xd2\xd7\xee\x3f\xe4\x39\xb9\x38\xd0\xbb\x6e\x7e\x8f\x2f\x50\x5f\x1f\xa0\x71\x7e\xd5\xf2\x08\xf6\x4b\x2e\x8c\x65\xf8\xc1\x68\x24\xba\x59\xaa\xb3\xd8\x91\xdb\x5d\x5b\x65\xaf\x65\x18\x7b\x31\x1b\x4f\x07\x93\xa5\xa5\x03\x07\xc6\x83\xf1\xba\x51\x6e\x64\x35\x71\xbc\x20\x0c\x69\xc9\x24\x4b\xb0\x42\x8d\xff\xf0\xd1\x68\x79\x6b\x26\x1a\xe1\x87\xb5\x64\x78\x21\x5e\x07\xcb\x75\xa4\x44\x82\x68\x08\x0d\x29\xfb\x1d\xf2\xac\xc7\xee\x3e\xce\x04\x35\x5c\xc8\x5f\xe3\x37\xaa\xe1\x9e\xc6\x02\xa8\x85\xb8\xcb\xab\x11\x1c\x89\x0f\x84\xa1\xc9\x84\xb6\x1f\x44\x0d\xa6\x24\xb7\x00\x2f\x7e\x74\xb0\xec\xde\xd8\xa7\xc9\x1b\x46\x7d\xf8\x87\x96\xf1\x01\xa6\xb1\xf2\x18\x4c\xbf\xf9\xf3\xae\xf7\x4e\x8e\x5b\x50\x3b\x85\xf9\xc5\x1d\xf2\x5b\x33\x56\x2f\xda\xf2\xa8\x7c\x7c\x7c\xfd\xe8\x09\x63\xea\x46\xc1\xac\x09\x1f\x3d\xf2\xac\xd3\xb2\xb4\xec\x89\x89\x77\xed\x7a\xce\x36\x31\x5a\x29\x7f\xbf\xf8\xd1\x19\x37\xcd\x1b\xd4\x36\xd2\x7f\x43\x9d\xfc\xeb\x0e\x69\x92\x24\xb5\x33\x5b\x6f\xbc\xf1\xc6\xc5\x8b\xc9\xf9\x18\x40\xce\x57\xe6\xda\x30\x7f\x89\xa2\x5d\xd2\x7c\xe4\xf5\x06\xed\x26\x53\xb0\x20\x16\xc5\x24\x1b\x45\x26\xbb\x97\x0d\xfa\x83\xcd\x19\xbf\x68\x15\x79\xd7\xe4\x0c\xd6\xe5\x8b\x62\x30\x2b\x06\xde\x18\x70\x31\x18\xfe\x41\x0c\x0e\xc4\x60\x6d\x0c\x56\x50\x2e\xce\x28\x6c\xfc\x4c\x0c\x4e\x52\xf6\xde\x49\x9f\xc6\xf2\xb9\xbd\x36\x47\x35\x3a\xe9\xc8\x52\x89\x46\x20\x75\xaa\x76\xd2\x87\xe9\x7b\x8d\x35\xd5\x95\xca\x22\x87\x45\x0c\x1a\x75\xaa\x33\x7f\x77\x1b\xc6\x6c\x5c\x0e\x5c\xbb\x3c\xa8\x6d\x6c\xfd\xc4\x89\xd3\xe4\x41\xb3\x31\x13\x62\xbf\xab\x9f\x99\x6c\x92\xbf\xe8\xf9\x19\xa1\x0e\xa6\xbc\xad\xbd\xb0\x67\x34\xf9\xc9\x1d\x0d\x90\x3c\x7d\xe4\x2c\x63\x26\x8c\xdb\x6f\xc6\x9c\xa7\x43\x1a\x21\x58\x2c\x58\xc5\xf3\xf9\xe3\x24\x2c\x43\xf2\xaf\xf1\x6f\xf6\xb3\xbd\x7e\xd8\xec\xdf\xed\xdf\xef\x67\x9d\xfe\x98\x7f\xa9\x9f\xb5\xb2\x1e\xfb\x94\x8c\xc7\x2c\x99\x0d\xcd\x19\xb3\x93\x38\x08\x9b\x33\xac\x98\xb5\xee\xd2\x70\xb2\x32\xd5\x4d\x7b\x83\x22\xcf\xe4\x7b\xff\x40\x0b\x24\xc3\x74\x00\xdd\xd7\xc9\xee\x79\xb8\xae\xf2\x91\x59\x75\x52\x66\xc6\x68\x69\xe6\x4c\x5a\xd9\xef\x31\x93\x6c\x1a\x3d\x23\x23\xd5\xcd\xa2\x71\xf7\xbd\xa7\xe5\x89\x4c\x89\xba\xe6\x4e\x95\x2a\x91\xc1\xe6\x32\xb0\x41\x3c\x5a\xac\x79\x4a\x86\xc5\x3a\x60\xa8\x25\x13\x75\x3a\x7d\xad\x19\xb7\x33\x8c\xe8\x20\xe0\x8e\x5f\x43\x7b\x5d\x19\x0a\x75\x26\x6a\x41\xca\x4a\x45\xb3\x5b\x23\xd4\x38\x5f\x95\x6e\x59\x4a\xb2\x55\x6a\xe0\x37\xf5\x32\x95\x64\x24\x69\x66\x66\x74\xdd\x4c\xd3\xc1\xd7\x32\x53\xa4\xb2\x40\xb0\xba\xee\x69\xf8\x1d\x77\x4e\x79\x9a\x39\xff\xd4\xaf\xfe\xe8\xfe\xf4\x06\xcf\xdd\xab\xd8\x4d\x85\xf5\x94\x2f\x12\xfa\x5a\x86\xeb\x1c\x84\x17\xa5\x5e\xa3\xc3\x61\x74\x1a\x9c\x88\x98\x48\xed\x26\x41\x34\x89\xe1\x50\xd0\xd7\x9c\x09\x22\xc1\x6e\x12\x3d\x22\x96\x8f\x9c\x9c\x15\x0b\x5d\x58\xb1\x6b\xce\x70\xce\x05\x61\x98\x16\x86\x86\x30\x54\x87\xc1\x17\x86\xcf\xc2\xf0\x67\xea\x4f\x7c\x31\x0c\x7b\xc2\xb0\x2d\x0c\x2b\xc3\x30\x97\xc2\x34\x86\xa1\x38\x0c\xc1\x30\x98\xc3\xb0\xe0\x3b\x0a\xb7\x96\xbe\x9e\x47\x5f\x64\x9d\x91\x0a\x8a\xa7\x69\xe1\x15\xf4\x2d\x2e\x59\x44\xb1\x1b\xc2\xf0\xf7\x30\x1c\x0d\xc3\xbb\xda\x07\xb6\x52\x24\x2b\xb4\x6f\xd4\x87\x81\xd8\xd2\xe2\x1a\xba\xe1\x18\xdf\xa9\x30\x7c\x10\x86\xfd\x61\xe8\xa6\x25\x56\x87\xa1\x33\x0c\x6d\x9a\x33\xf3\x0c\x05\x38\x4c\xeb\x8c\x91\x49\x03\xd7\x52\xb3\x1c\x06\x61\x14\xd3\x5c\x39\x85\xc1\x00\x77\x84\x61\x69\x18\x3a\xc2\x50\x47\x3f\x80\xc2\xf9\x5b\x5d\x3b\x2e\x65\xab\x37\xf4\xd9\xe0\xd6\xef\xd6\xb5\xf6\x4b\x75\x94\x9c\xd2\x3a\x7c\xb8\xe6\x69\xcf\x5b\xea\x5d\xd4\xe5\x3e\x9c\x58\xd6\x15\xb5\xd5\x09\x6a\x8c\x9a\x51\xd4\x4d\x37\x58\x3a\x17\xe6\x5d\x7f\x12\xae\x68\x93\x47\xd4\xfc\xea\xc6\x39\x72\x49\x06\xd3\x30\xbc\x85\xe7\x4a\x7d\xbd\xef\xcb\x9e\xb3\x84\x86\x61\x5c\xeb\x0f\xb9\xd9\x46\xe8\x61\x00\x26\x64\x1f\x9d\x6f\xf3\xa4\x2b\xf0\x54\xb3\x58\x4d\x78\xa8\x4d\x48\x9b\x44\xfb\xac\xb0\xdb\x0a\x9b\xad\xc4\xb0\xd5\x6a\x05\xc9\x0a\xca\x93\x4e\x2b\xc4\xac\x70\xd2\x0a\xfb\xe9\x93\x4d\x56\xa8\xb3\x42\xb9\x55\xe7\x71\xbf\xa1\x4f\xac\xc8\x25\x2e\x77\xd8\xab\x4e\xb4\x99\xd9\x2a\x01\x39\xcb\xd9\x70\x2f\x96\xf9\x06\xc1\xcb\x52\x2f\x1f\x08\x44\xa3\x25\x4e\xa7\x05\x15\x15\x95\x58\x4a\xca\x2f\x1b\x58\xda\x9c\x19\xe8\x2c\x8a\x06\x9c\x96\x92\x74\x49\x73\x26\x64\x4f\x8b\x46\xcf\xe4\x0c\x6f\x14\xd8\xc4\xe4\x0c\x62\x85\x95\xe5\x70\x75\x39\xb4\x95\x43\x63\x39\x54\x97\x43\x71\x39\x58\xcb\xe1\x5c\x39\x9c\x2a\x87\x3f\x97\xc3\x6f\xcb\xe1\xe9\x72\x78\xb8\x1c\xee\x29\x87\x15\xe5\x30\x57\x83\x0c\x96\x03\x57\x0e\xf3\xcf\xea\xe0\xb6\x52\xa0\x79\xe5\x30\x9c\x62\x31\x68\xaf\xba\x29\x8a\xb5\xe5\xb0\x92\x96\x9f\x56\x0e\x43\xcb\xa1\xa8\x1c\x7c\xe5\xf0\x59\x39\xfc\x46\x03\x58\x57\x0e\xb7\x96\xc3\x02\x0a\xd0\x40\xab\x82\xbf\x61\x2e\x87\x61\x18\xcb\x9f\xca\x01\xf6\x53\xc0\x3d\xe5\xb0\xbe\x1c\x3a\x69\x35\x1a\x28\x9a\x6c\x6d\x0f\x97\x83\x54\x7e\xa0\x1c\xf6\x95\xc3\x73\xe5\xb0\x8c\x7e\xac\x81\x56\xf3\x83\x72\x52\x9a\xc1\x2f\xd6\xd0\x17\xad\xe5\x50\x57\x8e\xd5\xac\x2c\x89\x76\xe8\x69\x2f\x4b\x9f\x1d\xff\x52\x9d\xee\x47\x38\xc8\x03\xd1\x4b\xa2\xaa\xff\xb3\x0f\x99\xaa\xae\x5a\xca\xb2\x6a\x88\xb8\x80\xff\xe6\x2d\x0c\x58\x30\xee\x7f\x99\x78\xb1\xe1\xfe\xa5\xcf\x0c\x3b\xb4\x41\x26\x0b\xc5\xe8\xfa\xf1\xd3\x2c\xca\x8f\xfa\xa9\x64\xc5\x98\x0d\x8b\x59\xbc\x5e\xac\x5a\xa5\x5f\x31\x4a\x4b\x6b\x72\x37\xe9\x9e\x46\x8d\x39\x53\x7a\xae\x21\xeb\x27\xd5\x19\x76\x49\xd7\x59\x0d\x58\xce\xf0\x1b\xfc\xd1\x48\x28\x80\x89\xc5\xe9\xb6\x1a\xfc\xa2\xbf\x39\x23\x8a\x66\x91\x75\x52\x7a\x29\x8a\xc2\xac\x28\x78\x89\xc9\x0f\x2f\x9f\x51\x38\x10\x85\xb5\x34\x1a\xad\x35\x8a\x97\xcf\x28\x54\x44\xe1\x4c\x14\x4e\xd2\xd0\x98\x4e\xfa\x34\x16\x85\xfd\x5a\xa4\x8c\x16\x1b\xf8\x7f\x5c\x3e\x2f\xe9\x2f\xa5\xa3\xfe\xe5\xea\x89\xbb\x65\x59\xfe\xe2\xa9\x76\x45\x3f\x4b\xa7\xda\x76\x75\x1f\x18\x6e\x3b\x89\xd5\x5f\x2b\xcd\xb0\x21\xb7\x01\x19\x82\x01\xb3\xb3\x25\x63\x16\x58\x11\x0b\xbb\xbe\xa2\x20\x9c\x0a\xc2\xdc\x20\x34\x04\x61\x68\x10\xf0\xad\x37\x08\x5c\x10\x37\x3d\x08\x07\x74\xf7\xe7\x82\x70\x32\x08\xcc\xe1\x20\xec\x0f\x42\x67\x10\xa4\x20\xe0\x25\x63\x17\xfd\x91\x67\x7f\xd7\xc9\x93\xfd\xf8\xa5\x75\xcb\x17\xaf\xdf\x66\xf1\xe2\xd1\x13\xff\xfd\xc1\x87\xc7\x4f\xfc\x51\x3e\x36\xba\xf5\xca\x11\x23\x27\xb6\x60\xfd\xa3\xe7\xec\xb7\xe7\x7f\xf8\xe6\x87\x6f\x3e\x7e\xf6\x89\xbf\x7e\xbe\xe7\x79\x55\xaf\x95\x27\x72\x71\xdc\x26\x1f\x8a\xa1\x35\x52\x4b\x04\xd9\xed\x6e\x3f\xef\xe6\xe3\x09\x11\xeb\x5b\xa2\xd3\x6d\x77\xda\x9b\x33\xce\xb0\xa9\xa0\x35\x63\x31\xf9\x98\x20\xd6\xb8\x18\x01\x25\x20\x9e\x00\x21\x01\xf8\x47\xed\xe1\x04\xb4\x26\x60\x7f\x02\xf6\x25\x60\x77\x02\x96\xd1\x5b\x29\x01\x15\x89\x7f\xa7\x71\x5d\xa2\xe6\x92\xf6\x54\x6b\x4a\x6d\x1a\xeb\x2b\xb9\xd1\x12\xc8\xe0\xe1\x86\xc1\xc3\x8b\x1e\x3e\xf0\xc6\x27\x87\x17\x5e\x6f\xb8\xaf\xe7\xf4\xbc\xeb\xe0\x47\x30\xf7\x85\x39\xcd\x93\x66\xec\x63\x6f\x1b\xf7\xd9\xf7\xdf\xc9\x17\xc2\xf5\x93\x0f\x51\x6e\xd7\x15\xa8\x97\x87\xc2\xca\xe2\x9e\x5a\x91\xb6\xb3\x0d\xb7\xb3\x93\x3d\x8a\xc7\x2e\x4e\xbc\x7d\x05\x06\x97\xcb\x86\x82\x41\x5b\xa2\x30\x16\x89\x60\x15\x3e\x22\x78\x7d\x3e\x96\x6c\xf2\xb5\xb9\x9c\x2e\xd2\x62\x54\x08\xf1\x42\x10\x0a\x01\xff\xa8\x3d\x5c\x08\xad\x85\xb0\xbf\x10\xf6\x15\xc2\xee\x42\x58\x46\x6f\xa5\x42\xa8\x28\xbc\x54\x89\xcf\xc5\xee\xe5\x87\xb1\x28\x4d\x54\xe2\xc6\xa9\x06\xa9\xb4\xb0\x6a\x68\x4d\x76\x14\xfd\x35\x95\x70\xeb\x9c\x45\xc5\x53\xa3\x0d\x6d\xf3\xae\x66\xee\x9c\xd7\x73\xfa\x3e\xcb\xd5\x0f\xfc\xf1\xdd\x4f\x3f\x6e\x7a\xff\xe6\x59\xb0\xbf\xfb\xe7\xa2\x8b\x79\xcf\xf5\xfb\x8b\x6e\xd2\xca\x0f\xe7\x74\x36\xff\xef\xff\x7e\x73\xde\x5f\xa6\xcd\x4d\xf6\x2a\xf6\xf7\xc8\x8b\x96\x4a\x02\xb2\x5a\x05\x03\xcf\xf3\x60\x67\x05\x5e\xf4\xf9\x88\x79\xbd\x72\xf0\xd0\x26\xe2\xaa\x40\x3e\xc1\x57\xe1\x6b\xf5\x75\xfa\x96\xf9\xf6\xf9\x4e\xfa\xce\xf8\xcc\x4e\xd6\x8b\x5b\xed\x75\x5a\x05\x87\xd0\x9c\x71\x88\x16\x64\xec\x35\x82\x91\x13\x88\x27\x13\xd7\x5c\x6b\x10\xb5\x9b\x2f\x2f\x23\x2b\x26\x89\x26\xd1\xe6\xda\x28\x2c\xe8\x63\xc5\x9f\x18\x29\x72\xc3\x76\xe8\xfa\xe7\xc6\x56\x0f\xab\xad\xdb\x3d\x72\x7b\xcf\x1f\x56\xad\x82\xf5\xcc\xdf\x6f\x59\x20\x3f\x7b\x7b\x4d\xaa\xe7\xed\xdc\xc4\x02\x34\xaa\xf7\x4b\xe6\x0b\x4c\x83\x03\xd0\x8d\x52\xa3\xc9\x68\x14\x23\xe1\xb0\x13\x25\x45\xa7\x18\x13\xcb\x45\x16\x21\x01\x0f\x1a\x6b\x37\x20\xb1\xb4\x24\xe9\x0c\xb0\x81\x78\x73\x26\x12\x10\x58\x1b\x5e\x48\x59\x9f\xb3\x14\xf6\x96\xc2\x1d\xa5\xb0\xb4\x14\x3a\x4a\xa1\x45\x73\xc1\xe6\x51\x5c\x6e\x07\x13\xf5\xc1\x56\xea\xb7\xad\xf4\x09\x21\x23\x7e\x58\xc8\x2a\x65\xc4\x94\xa1\x38\x62\x81\xf9\xe2\xcd\x57\x26\xfe\xa2\xbc\xbe\x38\x79\x43\xed\xf4\xa9\x93\xef\xdb\x72\xeb\xeb\xdb\xae\x7b\xa1\x3e\x1e\x5d\x50\xde\x34\x66\xda\x3d\x3f\x59\x05\xa5\x8f\x3e\x9e\x70\x03\x5a\x9b\x2c\x9f\x70\x79\x4d\x7d\xd9\xa0\x47\x6e\x58\xf3\x50\xf4\x9b\x25\xd1\x54\x6d\x65\x55\xc3\x80\x41\x0f\xe0\xb6\x26\x70\x5b\x1f\xe7\xee\xc4\xf3\x6d\xb8\x14\xb1\x60\xf9\x90\x65\x3d\xfe\x00\x67\xb7\xd8\x31\x13\x91\x8c\x16\xa7\x17\x21\xd7\xa4\x0c\x7e\x5f\x97\x4d\x04\xa1\xa3\xa2\xec\xce\x0c\x57\xb2\xaa\x0e\x2b\x8b\x44\x5d\xf4\xaa\x71\x00\xf0\xf2\xbd\x0f\xac\xde\x72\xd3\xb6\xdf\xfe\xb6\x7a\x60\xd5\x95\x05\x5b\xbc\xab\x6e\x64\x16\x8d\x4e\x1f\x39\x32\xbf\xe7\xa7\xa3\xeb\x85\xa9\x62\x21\x39\x89\xb2\xf7\x73\x6e\x04\xdb\x85\x39\xd8\x63\xd2\x75\x16\x1e\x39\x9d\x5e\xde\x1b\x08\xfa\xbd\x44\xe9\x11\x0c\x44\xc2\x77\x63\x62\xb0\x13\xe6\x4d\xb8\xd9\xac\x3e\x1c\x6c\x6d\x10\x56\x04\xa1\x15\xf3\x2e\xcc\xa9\x2a\x82\x20\x04\xe1\x0c\xe5\x65\xfb\x28\x1f\xc3\x2f\x62\x94\xa7\xe1\xdb\xdd\x41\x58\x16\x84\xf2\x60\x3e\xff\xee\x87\x81\x57\xf6\x67\xf3\x4a\x19\x0d\x49\xcc\xbe\xa9\xb5\xcb\xa7\x86\x72\x12\xda\x62\xde\xc4\xac\x5b\xbe\xd8\x0e\x77\x50\xce\x0d\x37\xcf\x96\x1f\x98\x9c\x6c\x02\x91\x99\x16\xa8\xef\xb9\x19\x73\x6d\xe6\x8d\x40\xfd\xc5\x17\xd4\xf5\x0a\xf5\x7e\xc9\x91\xd3\x0d\x1d\x68\xbf\xf4\x1f\x46\xc6\xec\x60\x1c\x4e\xc1\x61\x34\xb3\x0c\xc7\x34\x67\xac\x9c\xd3\x84\xc0\xb7\x53\x80\xd5\xd4\xb3\xda\xa0\x79\x50\xb3\x9e\xd5\xb5\x9a\x5b\x56\x79\x5e\x7b\x8a\x3e\x9d\x4b\x3d\xb0\xa7\xa8\x07\xf7\x00\xf5\xb2\x2a\x0f\xdb\x28\xe8\x39\xfa\xea\x98\x56\x5e\x12\x80\xa9\xa0\xae\x57\xc5\xc5\xda\x91\x2f\x1f\xf4\xe3\x07\x24\x2e\xd5\x4b\x1d\xd7\xbc\xea\xe9\x0b\x2b\x17\xa6\xe1\x56\xf9\xe6\x7a\xf8\x74\xd9\x37\x47\x97\x40\x65\x83\x97\x9d\x87\xe7\x54\xa8\xe7\x7f\x98\x10\xbe\x7a\x49\xdb\x0d\xbd\x5f\xf2\xbf\xc2\x6d\xf7\x12\x7f\x0a\x63\x74\xdb\x8d\x76\xd1\x67\x41\xc8\x2b\x78\xe3\x5e\xd6\xcc\x7a\xbd\x4e\xfc\x94\xa5\x1c\x9e\x73\x3a\xc1\x64\xb6\x7a\x78\x9b\x2f\x43\x5d\x4a\xb5\x3e\x28\xf1\x41\x90\xfa\x4d\x2f\x50\x6f\xd3\x51\x1f\x1c\xf4\xc1\xab\x3e\x78\x96\x7a\x48\xd7\xfb\xe0\x56\x1f\xcc\xd2\x80\xcb\xa8\x53\xca\xec\x83\x85\x0a\xf4\x71\xac\xd2\x1f\xa4\xee\xd6\xe7\x28\xac\xe2\x68\x55\x60\xcb\x29\x6c\x16\xf1\x31\x9f\x0a\xb9\x53\x07\xa9\x47\x1c\xf3\x81\xf3\x12\xe0\xe7\x74\xf0\x4b\x75\xf0\xe5\xd4\xf9\x75\xf9\x39\x9d\xc3\x6b\x85\x0f\xa4\xc6\xb9\xd4\xcb\x55\x44\x1d\x5d\xa7\x7c\x70\x40\xf3\x83\xad\xa1\x9e\xde\x36\xea\x35\x53\x7c\xc7\x02\x7d\xbe\x3e\xeb\x1f\x6b\xed\xe3\x22\xd3\x47\x60\xfe\x2b\xe3\x50\x5f\x11\xb0\x8f\x32\xd3\xf1\x6f\x5c\x2a\xfe\xec\xd8\x6b\x3e\x5f\xfd\x92\xaf\x8e\x3e\x24\xad\x90\xa5\x07\x76\xe1\xd1\x97\x97\xc0\xe0\x26\xf9\xc0\xad\x1f\xfe\xf9\x56\xf9\xa5\x46\xf8\xe3\xb2\xdf\x7f\xc4\x36\xf7\xfc\x9d\x09\x13\x62\xb8\xb8\x8d\x71\xf6\x7c\xa3\x12\xc8\xe7\x8c\x1f\xd3\x06\xd6\x40\xd8\x6f\x31\x6d\x84\x51\xaf\xd4\xe8\xb6\x1b\xac\x36\x3e\xe4\xe1\xc2\xde\xa0\xc9\x03\x46\x1e\x2c\xc1\xb0\xe8\x71\xb1\xbc\xd1\x6a\xb7\x44\x23\xf1\x68\x6b\x94\x71\x46\x61\x25\x16\xd5\x36\x45\x77\x45\xf7\x46\x59\x89\x3c\x3a\x11\x3d\x1d\xa5\x0e\x59\xe2\x0d\xa6\x0e\x5c\x4f\x66\x76\xd3\x52\x05\x82\x3c\x8f\x47\xd9\x7a\xfc\x7c\x8d\x14\x19\x39\xba\x29\x1e\x25\x85\xd6\x44\x37\x47\xf7\x47\x0d\x12\x75\xdf\x12\xe7\x2d\x4f\x1d\xc4\xc3\x47\x28\x8e\xe2\xc1\xd5\x8a\xa3\xb8\xa4\xe4\xb2\xa6\x18\x8d\x99\x36\xb3\x76\x77\x90\xf5\xfa\x30\x87\xf2\x84\x6c\x3c\x87\x87\x47\xe4\x0c\x56\x36\x0c\x61\xcc\xff\xc1\xa9\xdf\x7e\xa4\x06\xba\x82\xb2\xed\xab\x6c\xce\xf2\x32\xf2\x63\x8e\x16\xc9\x40\x3c\xbb\x2a\xfb\xcf\xd9\xad\x48\xa6\x01\xa3\xbf\x46\xef\xd4\x4d\x1b\x55\x87\x6f\x0c\xbe\x5b\xb0\xee\x3f\xdb\x41\x9a\x22\x7f\x0f\xa5\x33\x65\xcb\x82\x3d\x1f\xb5\xcb\xfb\xdb\x60\xa0\x7c\x96\x5d\x34\x7a\x74\xf8\xbf\x8e\x04\x47\x8f\x16\xe5\xdf\xcb\xd5\xe2\xe8\xd1\xfe\x9e\x5e\xfc\xaf\x00\x9d\xf0\x38\xe5\x3d\x5e\xb9\x91\xfd\x12\xf7\x71\x14\xea\xa4\x8f\x8d\x26\x87\x11\x3f\x34\xd9\x7d\xa2\x68\x00\x3b\xc4\x90\xd1\xc1\x16\xb8\xb1\x3c\xe5\x73\x47\x0c\x26\x3b\x0b\x2c\xe0\x69\x68\xb1\xb2\xac\xb3\x8e\x1a\x91\x7a\x63\x70\x82\x1a\x7d\x77\x51\xa3\x6f\x47\x0c\x5a\x34\xa3\x2f\x7e\xeb\x8c\xc1\x22\x0c\x71\x9a\x02\x65\x8d\xc3\x59\xd0\x7f\x85\x42\x79\x4e\xfc\x12\x8a\xd5\xaa\x53\x33\x5f\x1d\xd6\x59\xad\x36\xe7\x5b\x51\x24\xea\xce\x40\x3a\xb0\xdd\x14\xa0\x93\xbe\x42\x31\xe8\x9f\xde\x2f\x8d\x70\xbb\x74\x96\x28\xf4\x9e\xe7\x9d\xd7\x19\xae\xa9\x25\x89\xd8\x49\xf9\x3c\xce\x07\xc4\x34\xaf\x5a\x6a\x46\x31\xf0\x07\xf9\xc7\x84\x0d\x1e\x7f\x9b\xb0\x41\x79\x83\xd4\x79\xd3\x84\x49\x6d\x23\xca\xa2\x83\x8a\x2f\xaf\xbc\x2c\xca\x2e\xa5\x54\xff\x3d\x63\xa1\x33\x61\xe9\x93\x0f\x8c\xf3\x9c\xbd\xdd\x5f\xd4\x70\x8d\xa6\x9f\xb3\x9d\x78\x8c\x3c\xb0\x4e\xea\x75\xb9\x9d\x4c\x8c\x61\xdc\x8c\xd5\x68\x52\x76\xd5\xd8\x4c\x80\xac\xe0\x04\xb0\xf2\x56\x10\xbd\x56\x0b\x63\xc1\xcb\x06\x5e\xa6\x01\xd9\x10\x96\x3f\x8c\x6e\xb0\xb2\x6e\x24\x86\x45\xb8\x20\xc2\x17\x22\x1c\x14\xa1\x5b\x84\x3d\x22\xcc\x15\xa1\x4d\x84\x06\x11\x38\x11\x96\x9c\xa3\x4f\x77\x8b\xb0\x55\x84\xb5\xba\x77\x5e\x11\xf0\xab\x0f\xb4\xe7\xb3\xe8\xc3\x30\xc5\xf2\x9c\x08\xeb\xe9\x93\x09\x22\x0c\xa5\xb1\x56\x5e\x8a\x6b\xd8\x29\x5a\xe0\x80\xf6\x9d\xad\xf9\x9f\x3a\x23\xc2\x49\x11\x0e\xd3\x70\xad\x7d\x1a\xc0\x5a\x1a\xb4\xa5\x80\x61\x5c\x45\x34\xa4\x0b\x7f\xf8\x14\xfd\xd2\x66\x11\x18\x1a\xd6\x25\xb9\xa0\x45\x84\x3a\xfa\x31\x25\xec\x2b\x6b\x94\xe9\xe8\x77\x78\xff\x45\x1c\x63\xbf\x61\xa1\xa8\x6e\x48\x76\x27\x8b\x2a\x90\xe9\xe4\xb1\x4a\x45\x96\x24\xa2\x26\xd9\xe9\x00\x6a\xb2\x85\x84\x08\xea\x16\xaf\x01\xb0\x6f\xd1\xb0\xf9\xde\x58\x13\xf3\x91\xdc\xba\x6d\xf8\xed\xa1\xaa\xa6\xf0\x20\x36\xe5\x11\x76\x42\x60\xf0\xc5\x13\x61\xef\x51\xf9\x31\x25\x5f\xcc\xd7\xcc\x87\xfc\x06\x94\x44\xb3\xa4\xaa\xa0\x2f\x6a\xb4\x46\x59\xce\x95\xe4\x92\x45\xa9\xa0\xc9\x68\x32\x7e\x9b\x71\x9a\x62\xa6\x0e\xd3\x52\xd3\x26\xd3\x2e\xd3\x5e\x13\x96\x04\x4c\x26\x27\x72\xba\xf0\x0b\x84\x0a\xbf\xcd\x20\xba\x87\x34\x2f\xa1\x81\x2e\x53\x84\x96\x63\x81\x48\x60\x58\x50\xac\x1a\x05\xf8\x5a\x5d\x0b\x22\x91\x12\x49\x5a\x08\xb1\x00\xf0\xd5\x87\x9f\x30\xad\xdb\x1e\xbf\x6e\xd9\xbc\xe5\x8f\xec\xbc\x77\xd4\x98\xda\x25\xb3\xdb\xaf\xaf\x1d\x33\x4a\xfe\x7a\xc7\xfd\x90\x5e\x78\x3d\x37\x95\xbd\xe6\x06\x28\xde\xf0\xd0\xf4\x19\xd3\xe5\x97\xdb\xef\xf3\xb0\xe2\x3d\x57\xcb\x2f\x4e\xcb\x4c\xc7\x6d\xd8\x21\x37\x02\xb1\x7b\xb2\x50\x2c\xfd\x17\x4b\x72\xf1\x90\xe0\x44\x89\x07\x3c\x0f\xe2\x3c\x78\x79\xc0\x4f\xce\xf1\x70\x8a\x87\xf5\x3c\xac\xe0\xa1\x93\x87\x56\x1e\x1a\x78\x18\xca\x43\x91\x06\xb0\xe8\x18\x0f\x07\x79\xe8\xe6\x61\x0f\x0f\x9b\x79\x3c\xc6\x3c\x2c\xd3\x60\x7b\x79\x38\xc9\xc3\x61\x1e\xf6\xf3\xb0\x8f\x87\xdd\x14\x42\x01\x88\xe1\xaf\xf1\x70\x86\x02\x64\x5f\xb5\x68\x1f\x17\xe8\xdb\xe1\x59\x44\xb8\x56\xa7\x79\xd8\xab\x2b\x8f\x9f\x3b\x2f\xc1\x5b\xc7\x43\x39\x45\x8d\x5f\x99\xfa\xa5\x97\xfe\x36\x3c\x2a\x6f\x3a\xfa\xe1\x1a\x74\xa1\xac\xcb\x26\x26\xc2\x23\xb3\x63\x93\xdc\x68\x1c\xfb\xfd\xab\xb8\xff\x5a\x31\x0d\xfc\x4d\xa3\x01\x37\xb2\x9b\xf9\x40\x84\x67\xe3\x28\x5e\x94\xb2\x84\x23\xe1\x08\x1e\xea\x70\x2c\xdc\x11\x5e\x1a\xde\x14\xde\x15\xde\x1b\xc6\x34\x10\x0e\x7b\x91\xd7\xfd\x6d\x06\xcb\x4d\xcc\xbf\xa7\x01\x7f\x36\x6e\xb3\x8a\xda\x89\x49\xe2\xb5\xcb\x08\x15\x14\x97\x41\x15\x51\x5f\xf1\xe8\xfb\xb1\x34\x4e\xa8\x21\xd9\x8a\x47\xfe\xfa\xf6\xd9\x4b\xf0\xc8\xdf\xbb\xf3\x91\xe5\xf3\x96\xcf\x7b\xe2\x41\xf9\xeb\xe9\x99\x69\xd0\x7c\xf5\x3d\x22\xeb\xb9\xf7\x2a\x18\x8f\x29\xe0\xa1\x0d\xf2\x47\x37\x5c\xc3\x4e\xe5\x16\x2f\x90\x8f\xde\xbf\x83\xd0\xb1\x00\x9f\x72\x11\xf6\x6a\xbc\x3e\x57\x48\x7e\xb3\xc5\x1f\xb0\x04\x22\x51\xe4\x7d\x3e\x83\x2c\x0e\xc9\xef\x70\x18\x9e\xcf\x38\x94\x5c\x3c\x24\x4a\x78\x48\x9e\x55\xa0\xb0\x58\x51\x5b\x8c\x49\xb2\xa3\xd9\xa7\x66\x2e\xa8\x74\x30\xcc\x0f\xc3\x57\x8d\x9f\x36\x25\x31\x76\xb4\x7d\x83\xb3\xfe\xa6\xd9\xc3\x6e\x9e\xda\x3c\x2d\x56\x5f\xef\xdc\xec\x6d\xb8\x11\x3e\xad\x1d\xd5\x34\x78\xe9\x7f\x3c\xf8\x50\x5b\xf5\x98\x31\x43\x6e\xbc\x63\xfb\x76\x72\x40\x75\x6f\xf6\x5c\x69\xc1\x80\x58\xaa\x4b\xbf\x20\x5f\x07\xe7\xd9\x37\x49\xae\x44\x18\x86\x57\x36\xbb\x9d\x61\xd9\x5c\xae\x44\x81\x63\xc1\xc6\x86\x5d\x60\xa5\x89\x0d\x4f\xb9\xe0\x03\x17\x1c\x70\xc1\x56\x17\xcc\x72\x41\x83\x0b\x86\xba\xa0\xc8\x05\x5e\x17\x70\x2e\x58\xb4\xd3\x05\x6b\x5d\xb0\xc2\x05\x73\x5d\xd0\x46\x5f\x1f\xa3\xd0\xdd\xb4\x00\x7e\x35\xc1\x05\x61\x0a\x7a\x4e\x43\xb4\xde\x05\xab\x35\xe0\xa1\xf4\x55\xed\x17\xb4\xd8\x41\x5a\x6c\x0f\x2d\x59\x46\x8b\x59\x69\x31\x25\xf3\xe2\x01\xed\xad\xa4\xab\xc2\x39\x5a\x41\xa5\xc8\x1a\x17\x30\xd9\xc4\x8c\x31\x17\x38\x5d\x39\x71\xaf\x5f\x93\xdf\x25\x84\xdc\xff\x0a\x57\xde\x3e\xa7\x9f\xe4\x8c\x95\x9e\x84\x47\xf3\x89\x60\x75\x13\xc2\x37\xce\x96\x8f\x68\xc9\x19\x19\x74\xf1\x3a\x7e\x66\x36\x77\x11\x83\x48\xc2\xf4\x5d\xfc\x48\x14\x42\x09\xd4\x2e\x55\x04\x04\x8e\xb3\x17\xb0\x3c\x8f\x4c\x5e\x8f\x07\x85\x4d\x26\x54\x98\x8c\xf9\x05\x7f\x4b\xc6\x6b\x17\x0a\x42\x58\x49\x9e\x94\x31\xb0\x02\xfe\xc3\x39\x59\x4e\xc4\x93\x85\x66\x4f\x74\xe5\x65\x4e\xec\x63\x5f\xd4\x98\x9b\x03\x8c\x62\xb2\xaa\x88\x04\x55\xd4\x82\x96\x55\x10\x6b\xc8\x43\x6a\x00\xd3\xb6\xcb\x01\xec\xae\x81\xf7\x8f\x9f\x2d\x07\x56\x1e\x7b\x90\x99\x7d\xd7\xa2\xa6\xea\xca\x11\x0f\x2c\xed\x39\xde\x79\xed\xec\x05\x60\x88\x17\xf3\xaf\xbd\xe6\x81\x0f\x77\x7c\x72\xd3\x73\x7b\x2d\xa2\xfc\x8f\xa7\x12\xe6\x1e\x47\x14\x66\x3c\xb5\xd7\xcf\x7c\xee\xf9\xbd\x62\x17\x9f\x8c\xdb\xb3\x9f\x9f\x88\x52\x68\x9e\x54\x19\x8f\x16\x86\xcd\x36\x47\xa1\xa1\xc0\x80\x1c\x58\x3e\x42\xd6\xb0\xc3\x81\x8a\xd3\xe6\x58\x41\xec\xc6\x8c\xad\xa0\xc0\xc5\xb8\x82\x37\x66\x7c\x2e\x23\x9b\x62\x98\xd4\xcd\x19\x26\x97\x7e\x48\x8b\x13\xa9\xcc\xd7\x92\x5d\x6a\x46\x3a\x37\x0d\xb0\xd1\xb6\x9f\x53\xed\x3e\x59\x55\xa9\xb9\x2a\x95\x40\x6b\xd1\xeb\xc7\x7a\x34\xdd\x18\xcd\xee\xbf\xb8\x7d\xec\xa6\x84\xff\xc9\x19\x57\x7c\xf5\xe5\x88\xdb\xee\x98\x5e\x36\xbd\xfd\xa5\xd0\x85\xaf\x1d\xd5\x45\x27\x4e\xac\x1e\x75\xcb\x8f\x06\xcd\x19\x7a\xed\xf6\x7b\x9e\x79\xd9\x11\x95\xdf\xff\x4d\xd5\x0f\xf7\x6c\xbf\x36\x23\xb5\xad\x18\xa4\xd8\x98\xd0\xf7\xec\x0b\x5c\x1b\x9e\xb3\x69\x12\x51\x11\x33\xa7\xfc\x66\xff\x80\x12\x54\x02\x5e\x96\x29\xc4\x53\x97\x39\xcc\x9c\x61\xb0\xe2\xc5\x08\x92\x10\x79\x3e\x43\x92\x69\x11\xb2\x78\x8f\x70\x18\xa0\x9b\x73\xb2\x73\x98\xba\x4f\xd3\x24\x43\x5c\x4d\xba\xc6\x4f\x4d\x43\xd4\xad\x6a\xf4\x1b\x41\x33\xf3\xe1\xc6\x30\x27\xae\xba\xfd\x96\xeb\x16\xcc\x9d\x77\xc5\x15\xf3\xe6\x5f\xbb\x60\xe5\xca\x05\x0b\xe6\xcd\x1f\x33\x66\xfe\x5c\xf9\xe5\x85\x5b\x1f\x5c\xb0\x60\xfb\x36\xe8\xc4\xb7\xf3\xae\xbb\x76\xd5\xea\xb9\x0b\xe6\x2f\x6a\x6c\x5c\x30\x77\xd1\x75\xb7\xdc\x3c\xff\xba\x79\x4c\xd7\xf6\x05\x0b\x1e\xdc\xba\x70\xe1\x36\x32\x1e\x0c\x1e\x0f\x19\xd3\x57\x21\x5a\x27\xa5\x0d\x56\xae\xd0\xe1\xb6\x09\x6e\xd6\x1b\x0b\x87\xa3\x09\x2f\x17\x0c\x16\x5a\xd9\x64\x91\xb3\x20\x51\xd0\x81\xc5\xf0\x68\xa8\x23\x23\x50\x39\xbd\xc8\x6c\x6b\x8a\x4a\x36\x3e\x21\x99\xed\x4d\x89\x04\xf8\xbd\x41\x7f\xb0\x23\xe3\x77\x13\x11\xbd\x10\x0a\x3b\xb0\x88\xce\xe6\x44\x74\x75\x23\x52\xa0\xbc\xac\xb2\x32\xf4\x5e\xd9\x10\x25\x35\x83\xb6\x9f\x95\x10\xa0\xf2\x4f\x4e\x32\xd7\x64\x3e\x3c\x42\xc4\xda\xa1\xb8\x64\xaa\x12\xf4\x4f\x25\x30\xf0\xcf\x65\x7f\xf8\x60\x09\x8c\x99\x26\xf7\xfe\xe5\xdc\xb9\x73\x9b\x7a\x7e\xb3\x51\xee\x05\x90\x7b\xff\x2e\x9f\xe7\x2e\x10\xc9\xef\x14\x53\x40\x24\xbf\x9e\x87\xe6\xdd\x37\xef\x7d\x62\x76\x7a\x1f\xff\x60\xe6\xe2\x16\x93\x75\x76\x00\x59\x67\x91\x11\xaa\xa5\x63\xac\xd1\x88\x38\xce\x64\xe6\x11\x8f\x80\x8b\x00\x92\xcc\x50\x61\x86\xb8\x19\xbc\x66\xe0\xcc\x70\xce\x0c\xa7\xcc\xb0\xde\x0c\x2b\xcc\xd0\x69\x86\x56\x33\x34\x98\x61\xa8\x19\x8a\x34\x80\x45\xc7\xcc\x70\xd0\x0c\xdd\x66\xd8\x63\x86\xcd\x66\xbc\xe2\x9a\x61\x99\x06\xdb\x6b\x86\x93\x66\x38\x6c\x86\xfd\x66\xd8\x67\x86\xdd\x14\x42\x01\x88\x99\x01\x99\xe1\x0c\x05\xc8\xbe\x6a\xd1\x3e\x2e\xd0\xb7\xc3\xb3\x88\x70\xad\x4e\x9b\x61\xaf\xae\x3c\x7e\xee\xbc\x04\x6f\x9d\x19\xca\x29\x6a\xfc\xea\xff\xde\x8a\xab\x30\x11\x7d\xe0\x5d\xa5\x8b\x25\xab\xef\xc6\x8d\x1b\xd9\x04\x73\x7d\xcf\xd6\x0b\x29\x66\x49\xcf\x4f\xe8\x7c\xb8\xab\x17\xd8\xdb\xf9\x25\x68\x18\x6a\x44\x1b\xa5\xd6\x86\x6a\x09\x85\x46\x0e\x2f\x8b\x3a\x51\x14\x13\x43\x51\x32\x59\x69\x32\x1a\xfd\xc3\x2b\x25\x7f\xa5\xbf\x69\xac\xa9\x0c\x2c\x23\x61\x5e\x03\x4c\x69\x00\xd6\xee\x04\x2b\xe7\x6c\x18\x59\xc6\xc5\xd9\xf8\x80\xe6\x4c\x72\x4d\x1c\x9c\xf1\xf2\x78\x5d\x1c\x4f\x9f\xb8\x62\xf9\x43\xe5\xc4\x7a\x44\x53\x7c\x54\x66\xd3\x31\x52\x5e\x9d\xbf\xc9\x2d\xcb\x0b\xf4\xdc\xe0\x12\xa3\x5f\x39\x28\x59\x54\xfb\xb5\xfd\xb1\x4a\xd2\x04\x96\x64\x53\x25\x81\x4d\x05\xe0\x1f\x05\xec\xf4\xb7\x5e\xa6\xf6\xc0\xf4\x0d\x35\x93\x66\x4c\x99\xdc\xb9\x68\x6e\xcd\x8a\x79\xed\x53\x75\x56\xc1\xd6\xe9\x8f\x5d\xd3\x50\x74\xf3\xe2\xab\x66\x3f\x99\x9e\x70\x95\x34\x73\xc0\xc4\xab\xeb\xa7\x96\x6e\xdc\x99\x70\x03\xbf\x36\x5d\x31\xe1\xf2\xda\xab\xca\x86\x0c\x9b\x7d\xd3\x84\xb9\x9b\x0b\x2a\xef\x99\x95\xb5\x16\x0e\x9f\x96\x1a\x33\xf2\xca\xf6\xba\x25\x8f\xc4\x47\x6c\x85\x97\xca\xa4\xea\x52\xd3\x94\xf2\xd2\x86\x11\x43\x6d\x73\x14\xbb\x7d\x15\xb7\x90\xb9\x89\x9f\x49\x7c\x11\xf0\x27\xa9\xd7\xcc\x8a\x4e\xd6\x19\x08\x1a\xdc\x36\xf7\xe6\x0c\x32\xdb\xc0\x6c\xbb\x35\x08\x0b\x82\x30\x2e\x08\xc1\x20\xd8\x83\xf0\x43\x10\xbe\x08\xc2\xb1\x20\x1c\x0c\xc2\xaf\x83\xf0\x7c\x10\x1e\x0d\xc2\xfa\x20\xac\x0e\xc2\xa2\x20\xcc\x09\xc2\x95\x41\x18\x49\xed\x75\xb1\x20\x98\x83\x30\xff\x82\x56\xe0\x90\x56\x60\xa7\x56\x60\xb1\x56\xa0\x2e\x08\x65\xf4\x03\xd6\x20\x5c\xd0\x7d\xe0\xd9\x20\x3c\x1c\x84\x75\x1a\xf6\x59\x14\x78\x78\x10\x4a\x82\x10\xd6\x80\xbf\x0a\xc2\xf1\x20\xbc\x1b\x84\xd7\x34\xf8\x6c\x6d\x32\xb4\xde\xc3\x29\x72\x05\x7e\x58\x4f\x10\x08\xfa\x83\x14\xfc\x39\xea\x2b\xd9\x44\xc1\x6b\x31\x94\xd4\x42\xe1\x9c\xda\xe7\x31\xc8\x5e\x1d\x88\x52\x83\x09\x0a\x2c\x6d\x5f\xb6\xa2\x6f\x50\x48\x66\x73\x10\x3a\x82\xd0\x42\x1b\x84\x82\xda\x84\xe9\xbb\xf0\xf7\xb5\xe1\xf4\xb5\xe0\xfc\x1b\x83\x4f\xbf\xf6\x21\x75\x5a\x61\xf9\xa0\xb2\xef\x86\x57\x5d\xf2\x9d\x84\x3e\xb3\x93\x5c\x31\x6e\x5c\xc5\xe0\xc6\x46\xf9\x8e\x8a\x71\x4d\x83\xf1\x0f\x6e\xe1\xd8\x21\x43\xc6\x34\x54\x0e\x19\x3b\xbe\xbc\x62\xec\xd8\x8a\x21\x63\x69\x4c\xd0\x8c\xde\x2f\xf9\xd7\xf9\xc9\xc8\x89\x4a\xd1\xe5\x68\xa9\x34\x2a\xe1\x09\x0e\xf0\x0c\x40\x35\xa6\x72\x64\x42\x23\x6a\x7d\x05\xef\x64\x70\x43\x6d\x86\xa0\x6f\x80\x20\x14\xe1\x1b\x9f\xe0\x63\x9c\x42\x4c\x60\xcc\x2c\xfe\x29\x70\x36\x5b\xe5\xbb\x19\x9b\x87\x2b\x7b\x37\xc3\x71\x7d\x22\x82\xa8\x7d\x85\xd4\xb8\x32\x6f\xa3\x7a\x76\xf9\xf2\x0c\x75\x17\x55\x0e\xe1\x48\x1a\x4e\xba\x3b\x5f\xcb\x25\x14\x83\xdc\xac\xaa\x1c\x82\xf5\x3a\xa3\x81\x2d\xe4\x18\x51\x49\xb1\x43\xd2\x77\x16\xcd\x78\x0d\x46\xfe\xf2\x35\x90\x5e\xfd\x4f\xf9\x8d\xd7\x7f\x29\xef\x7f\x85\x39\xf2\xbb\xbf\x1e\x7f\x7f\xe5\x36\x6e\x8c\xa7\x64\xf2\xf0\xbb\x96\x2d\xba\x73\xd5\x38\x5f\x23\x77\xc7\x1b\x8f\xcb\xff\x78\xfc\x71\x10\x9f\xd8\x0d\xfe\x27\x77\xcb\x5f\x30\x8f\xfd\x1a\x46\xbf\xfc\x8a\xfc\xe6\xaf\x5f\x95\xdf\xfa\xd5\x2b\x20\x7d\xf6\xc9\xaf\x0e\x1f\x2d\x78\x7f\x41\x30\xf4\xd0\xeb\x4f\xfd\xb4\xf6\xe6\x63\x69\x0e\x3d\x21\x7f\xb6\xe7\x49\xf9\x6f\xb8\x5c\xe4\x89\x27\x20\xf8\x14\x9d\x4b\x11\xd6\xc0\x4c\xc1\x7d\x15\x45\xc5\xb8\xa7\x2a\x0b\x43\x76\x97\xa9\xb8\x98\xb3\x73\xe9\x01\xc1\x20\x72\x21\xf1\x54\xc6\x15\x3b\x45\x02\x5c\xad\xd6\xa2\x53\x19\x23\x87\xff\x1a\x4d\xc8\x0a\x71\xeb\x66\x2b\xb3\xcf\x0a\x56\xb2\x12\x5a\xac\xce\x26\xfc\xcc\x64\x25\xc1\xc5\xef\xb5\x13\xb3\xd3\x0d\x43\x48\xc2\x5c\x35\x22\xaf\x6f\x20\xab\x2a\x6c\x0d\xa1\xae\xdb\x24\x09\x63\x2d\xc4\x7d\x54\x97\x4b\x35\x98\x8d\x63\xad\xc4\x82\xd7\x15\x73\x57\x0c\xfb\xb3\x31\x34\x6d\xd0\xaf\x6f\x7f\x70\x54\x4d\x69\xa2\x2c\xe4\x1f\xbc\x70\xca\xe4\x61\xa3\x2e\xab\x2b\xaf\xe6\x27\xb7\x4f\x96\xf7\x39\x07\x97\x85\xa2\xcf\x64\x66\xb1\xcc\x98\x21\x43\xdc\xf6\x2b\x1f\x16\x78\xf9\xcf\x0c\x53\x33\x22\x13\x56\x78\xc6\x42\x34\x9e\x7d\x91\x6d\x43\x06\x64\x47\x03\x25\x1f\xc3\x72\x2c\x32\x5b\xac\xac\x11\x19\x1d\x4e\xce\x6a\xb6\x9e\xce\x30\x66\xa4\x97\xa4\x68\xb6\x69\x3c\x9c\x58\x01\xf7\x24\x21\xa5\x5c\x16\xc2\xf8\x6b\x7f\xf1\x8b\x6b\xe5\x97\x61\x07\x8c\x9f\xfb\xf2\xcb\x58\xd6\x80\x33\x30\x57\x5e\x2d\xaf\x86\xb9\xf5\xda\x0f\x9a\xbb\xeb\x20\x17\x63\xce\xe0\xe5\x34\x22\xd9\x19\xe0\xc0\x60\xe4\xb9\xe7\x33\xc0\xbf\x84\x3b\x48\xa3\x1a\x2d\x3d\x29\x17\xdb\x78\xf1\x08\x73\xa6\xe7\x18\x3c\xb8\x19\xeb\x1c\x6a\x7e\x50\xac\x73\x08\xb8\xee\x9c\x8e\x9e\x53\xe8\x32\x34\x0a\x3d\x25\xb5\xbb\x0a\x0b\xcb\x62\x42\xb2\x38\x96\x8c\xd5\x96\x79\x3c\x81\x80\xa9\x16\x55\x9a\x90\x49\xaa\x0b\x96\x86\x4b\xdf\xc9\x14\xba\xca\x5c\xef\x64\xca\xca\xc2\x49\x4f\xc0\x17\x78\x27\x93\xf2\xa1\xb0\x10\xc6\x2d\x54\x3d\x5f\x1c\xf2\xad\xa1\xce\x2f\xce\xcd\x86\x7d\x61\x9f\x8d\xb3\x95\x63\x8a\xe7\xb8\x1a\x4c\xf1\x9e\x4b\x29\x7e\x39\xb1\x51\x50\xf1\xd9\xad\x6e\x5b\xec\x93\xeb\x50\x37\x05\xb2\x79\x04\x15\xfa\xaf\x52\xe7\x03\xb0\xc9\x9c\x7f\x8c\x4e\x68\xa3\xc7\x2f\x66\xb7\x34\xf6\x9d\x0b\xfc\xeb\xda\x24\xd0\x26\x85\x6c\xfe\x6c\x70\xbb\xfc\xf4\xc4\x36\x68\x7f\x64\xf7\xac\x19\xef\x37\xca\x9f\xb7\xdd\xe2\xf1\xcf\xef\xbc\xfb\x92\xd9\xa0\xce\x82\x5f\xaa\xb3\xa2\xe7\x55\x98\x2e\xff\x53\xb8\xfc\x72\x81\xd9\x2a\xd4\xdc\xb8\xf0\xca\x15\x11\xf9\x84\x70\x39\xd3\x38\xb9\x5e\x7e\xa7\x89\xb9\x74\x66\x40\xef\x69\x7e\x19\xe7\x36\xf0\x6a\x8e\x56\x1e\x0f\x20\x93\x17\x6f\x0e\x58\x06\xe3\xdc\x17\x8e\x73\x49\x7e\xd9\x83\x98\xbe\xae\x66\xfe\xc6\xbc\x8f\xc7\xc8\x81\xb5\x94\x32\x49\x0c\x98\x4c\x6e\x84\xc2\x11\x9b\xf8\x02\xee\x55\x89\x73\xbe\xa0\x32\x12\x22\xf2\xea\xd3\xd8\x79\x68\xe0\x30\xc9\x49\x44\x03\x05\xf5\xf2\xed\xd5\x93\xb7\x4c\x99\xb2\xb9\x6d\xea\xe6\xc9\x77\x75\x43\x55\xeb\x92\xa5\x2d\x93\x96\x2e\xe1\xc2\xf8\x11\xfe\xbf\x6d\xcb\xa4\x6e\x18\x77\xe3\xb4\x29\x2b\x56\x4c\x99\x76\xa3\x42\xe3\xd3\x30\xb1\x38\x69\xde\x5c\x27\x6a\x93\x06\x99\x01\x0c\x0c\xc3\xdb\x2c\x4e\xde\xc2\xbb\x04\x87\x13\xab\xcd\xff\x6f\x53\xe8\x22\xfd\x86\xe5\x6c\x50\x9b\x3e\x99\xae\x0b\x0f\x25\x73\xab\x9a\x50\x77\xdb\xc5\xb1\x4a\x4a\xdd\xcd\xf0\xa0\xbc\x68\xb3\x3c\x68\xc3\x06\x3c\x07\x86\x31\x01\xa6\x9a\x6f\xc4\x3d\x52\x2b\x45\x83\x0e\x26\x64\xf4\x32\xde\x70\xc4\x18\xb4\xbb\x5c\x16\xcc\x53\x3e\x61\x00\xaf\x9f\x9f\x65\xe0\x78\xff\x09\x55\x55\x2e\x91\xa8\x1a\xc5\x6a\xe9\xd7\xaa\xaa\xd5\x4c\xaa\x4e\x48\x30\xd5\x32\x73\xe5\xca\xd6\x92\xcb\xab\xaa\x52\xa1\x51\xcb\x5b\xef\xde\x30\xf0\x9a\x85\x4b\xe0\x66\x26\xb0\x7c\xca\x8a\xf9\xcb\x5a\xea\xc7\xc4\x56\xbc\x19\x5a\x32\xb7\xe1\xfa\x05\xd3\x3b\x88\x9c\x3f\x88\xb1\x32\xb5\xfc\x18\x3c\x8b\x6e\x90\xc6\x84\x0d\x62\xdc\x86\x50\x3c\xe9\x32\xf0\x58\x2f\x72\x09\x2e\xe1\x54\xa6\xc5\xd5\xe1\x5a\xea\x62\x6d\xae\x88\x8b\x31\xbb\x5c\x6c\x59\xa8\x36\xc4\x84\x42\xc0\x3a\x43\x60\xe3\x43\x05\x05\xfe\x53\x99\x82\x4f\x58\x5c\xf9\xcf\x8d\x60\x64\x4f\x68\x5b\x5d\x73\xc9\x9b\xc8\xf4\x68\x9f\x33\xa7\x6f\x62\x2a\xd5\xd5\x5a\x0e\xd4\x70\xab\x4b\xad\xaa\xb5\x2a\xae\x48\x59\x4c\xed\x8e\x4d\x37\x5f\x67\x1c\x1d\x1f\x54\xfd\x60\xdd\x44\x69\x54\xf5\x90\xa5\xc5\x03\x43\xa3\xe6\xcd\x02\x47\xcb\xf4\xf9\x57\x33\x67\x17\xaf\x0a\x1c\x5a\x1b\x7a\xba\x71\x02\xcf\x4d\xe1\xb8\xfa\xa6\x7b\x22\x37\xbf\x19\xfa\xed\xc4\x05\x0e\xbb\x62\xd3\xdd\xc2\xb5\x33\x6d\xda\xbe\x07\x86\x65\x79\x84\xfa\xdb\xf7\x90\xb5\xe3\x78\x12\x22\x6c\x79\x1a\xa2\xf2\x03\x5c\x7b\x02\x84\x94\x7c\x4e\xcd\x1f\x21\x4f\xe4\x6e\x21\xf6\x7b\x34\x55\x1a\xc4\x0b\x82\xd5\x68\xc2\xdc\x5d\x14\x43\xd6\x90\x1a\x31\x2a\xfa\x6c\x24\xe2\x3f\xe0\x70\x1a\xc3\xac\x67\x72\xc6\x8a\x27\x8b\x6f\x5f\x4c\x49\x68\xa0\x04\xa7\xf4\xe3\xdc\xcc\x0b\x9b\x4f\x7b\xd9\x44\x95\x9b\xc6\x1b\xe6\x3b\x3a\xb1\xd6\xb4\x60\xd8\xcc\x6a\xbb\xfc\x59\xa0\x1d\xee\x98\xd8\xd2\xd1\x41\x9d\x9d\x3b\x67\xd7\x0d\x1e\xba\x44\xde\x31\x08\xb8\x7f\x30\xff\x08\xd6\xf7\xac\x98\x35\xa5\x05\xcb\x2f\xf5\x17\x5f\x08\x8e\x56\xea\x7d\x95\x2c\xb3\x17\x68\xfe\x8d\x6a\x29\xc8\x1b\x0c\x8c\x85\x01\x0b\x08\x2e\xa3\xd1\x6e\x40\x78\x59\x6b\xc9\xd8\x59\xc6\x80\xca\x0f\xe4\xd4\x31\xad\x76\xee\x2c\x47\x26\x7f\x14\x59\x38\x21\xb2\xcf\xdc\x7f\xef\xfd\xbf\xf9\xec\x2f\x87\xe1\x7f\xb8\xe3\xe7\x13\xfc\x89\xf3\x09\x36\x69\xfc\xf0\xd5\x5f\x1e\xa4\x7b\x74\xf7\x42\x2f\x5c\x60\x27\x10\x59\x54\xb2\xd0\xdc\xcc\x34\x61\xa4\x9a\xcc\xb9\xaf\x38\x03\x53\xb5\x03\x28\x7a\x73\xb9\x99\xd1\x6a\x79\x26\x13\x43\xc3\xf1\x6a\xdb\x20\x85\x6c\x56\xab\xc5\xe8\x74\x5a\x18\xd6\xed\xb1\xb4\xda\x3b\xed\x8c\x5d\xb2\x09\x4d\x76\xbb\x8d\x2e\xb4\xee\x50\x93\x8d\x67\x2a\x88\x77\xb7\x7c\xce\x90\x43\xe5\x65\xc3\xcb\xcb\x96\x1f\xca\xa7\xb4\xc2\x74\x95\x42\x64\xe9\x9a\x4a\x1a\x8e\x0c\xe1\x99\x8d\x4d\x75\xb3\x47\x8d\xa9\x5c\xea\x7f\x75\xb3\x3c\x33\x36\xd3\x33\x6d\x60\x39\xff\xd6\x92\xf0\x86\xf6\x45\x4a\xbf\x4d\x64\xfc\x8c\xc8\x5f\x81\x2c\xa8\x44\xf2\x20\x9e\xb7\xda\x0c\x26\xa3\x64\xfe\x84\xc4\xea\x9d\xca\xb0\xc7\x35\x97\x7c\xe8\xd0\x90\xe1\xd9\x96\x69\x59\x95\x6b\x2a\x61\xdd\xfd\x72\xcd\xfa\xf5\x7f\x9d\xc9\xcc\x77\x5c\x71\x85\x83\x19\x7d\x59\xfd\x3d\x94\x27\x0d\x67\x19\x66\x21\x3f\x89\xe6\x9e\x18\x2d\x09\x2e\x83\x0d\x2f\xc1\xfe\x00\xeb\x3d\x95\xd9\xc7\x02\x4b\xda\xe4\x22\xc2\x03\x0b\x26\x96\x35\x4b\x66\xc7\xa9\x8c\x39\xcb\x28\x09\x2b\x9a\xf3\xaf\x82\x7e\x8c\x43\x73\x59\xf4\x17\x6e\xd8\x74\xef\xc6\x8d\xeb\xef\xdd\xb2\x6f\x51\xd5\xe0\xc1\x55\xd5\x55\x5c\xd9\xe6\x87\xb7\xff\x64\xf3\xb6\xad\x3f\x39\xb1\xf0\xa6\x95\x8b\x17\x2b\x31\x4c\x58\x06\xd8\xa6\xca\x00\xa5\x92\x97\x2e\xff\x1c\x83\x8c\xc8\xe1\x64\xcc\x56\xf3\xe9\x0c\x67\x45\x7d\x6c\x29\x7e\xba\x39\x28\xe9\x61\x2b\x81\x57\x2e\xec\x36\xf9\x65\x22\x02\xc0\x78\x79\x9e\xfc\x32\x11\x01\x60\x3c\xbc\x20\x3f\x02\x77\xc3\xdd\xf2\x23\xf5\xda\x0f\x62\x3b\x9c\xd6\x2b\xf3\x2b\xf9\x2b\x84\xb4\xb1\x87\xb9\x0d\x21\xa1\x18\xad\xb6\x20\x97\xd1\xc4\xb3\x89\x9e\x7f\xa0\xb0\xe4\x42\x50\x01\x12\x6c\x86\xdd\x58\x86\xe0\x59\x46\x10\x51\x5d\x55\x15\xcc\xb9\xac\x4a\xb1\x3d\xb6\x20\xc4\xff\x5c\x2d\x7f\x87\x52\x9e\xc5\xe5\xd1\x0a\x76\x35\x2e\x1f\x93\x7c\x4a\xf9\x65\xb0\x86\xe2\xd8\x8f\xb1\x98\x14\x24\x39\x1c\x9d\xb8\x0e\xeb\xf9\x31\xba\x3a\xdc\x54\xa9\xd4\xa1\x1a\xe3\x08\x4a\x4e\xad\x0e\xfb\x81\x63\x99\x81\xba\x1a\x30\xe8\x36\x79\x06\x7b\x0f\xfb\xa6\x9a\x67\xb3\x14\x53\xb7\xc3\x51\x58\x18\x74\x17\x04\x82\x05\x41\x35\xc5\x66\x90\xa6\xd8\x44\x11\xb0\xb1\x11\x2d\xcd\xa6\xa0\xa5\xd9\xd4\x72\x22\x67\x33\x6d\xea\xa5\x05\x7d\x72\x64\x32\xa4\x9e\xca\xec\xce\x25\x2c\x1c\xbb\x94\xac\xba\x75\xc0\x8c\xe9\x37\xcf\xa6\x7c\xf9\xce\x8d\xd3\xd9\x37\xb5\x44\x9b\xf2\x1c\xf9\x77\x5a\xa2\x4d\xf9\x68\x19\x5c\x43\x13\x6d\xe2\xf6\xd3\x7c\x90\x86\xe3\xee\x62\xb2\xd3\x14\xf7\xdd\x15\xb0\x08\x9a\x91\xd8\xcd\x78\xf8\x62\xe6\x95\xde\xd7\xbb\xbd\x7e\xc6\x94\x82\xb2\x2a\x84\xff\xef\x07\x7e\x25\xbc\x8b\xe1\x3d\x92\x95\x16\x98\xea\xf1\xe5\xa0\x51\x0e\xfe\xac\x06\xcf\xfc\x18\x36\xea\xf1\xcb\xdd\x9e\xfe\xf0\x9f\xc8\xc2\x3f\x86\xc9\x45\x07\xff\x6d\x77\x78\x40\x3f\xf0\xcf\x64\xeb\xb3\x10\xd6\x63\xf8\xe0\xcb\x2c\x29\xc0\xe2\x12\xe7\xbb\x0b\x23\x4a\x09\x52\x44\x57\x66\x77\xf6\x1b\x8f\xc0\x3d\xe8\x08\x0a\xfc\x27\xcb\xa4\x58\x52\xe4\xbb\x6e\x5f\x84\x37\x28\x45\xf0\x70\xd3\xb9\xe1\x40\xc8\xb8\x0d\xf3\xcd\x24\xd6\x03\x9e\x95\x66\x15\x47\x53\x05\x16\x37\x4a\xb9\x53\x61\x9b\xd3\xe9\xb0\x87\xfd\x05\x49\x9e\xe3\x7c\xfe\xa4\x3f\x3d\xa0\x38\xda\x99\x29\x2e\x66\xe2\xc9\x82\x78\x41\x47\x26\xee\xb6\xb9\x2c\x24\x23\x9d\xd3\x02\x56\xd6\x62\x61\x82\x41\x77\x67\x26\x18\xee\xc8\xf8\x83\xee\x94\x99\x31\xe3\x57\x3c\x38\x49\xee\x57\x5d\x3e\x2b\x95\x32\x88\x0d\x33\xe7\x6a\xc8\xdb\x2d\xd2\x77\x27\x8f\x3b\x1b\x49\xa6\x59\x35\x94\xdc\x38\x7d\x13\xf2\x0d\xa1\x09\xf9\x48\x72\x30\x56\xd9\xa5\xec\x02\xb6\x76\x13\xb7\x6d\x56\x7c\xd9\x43\xef\x40\x98\x66\xe7\xfb\xdb\xb7\xbf\xa5\xc9\xf9\x36\x74\xc9\x95\x87\x1e\x92\xdb\x56\xb1\x43\xe5\x15\xdc\x29\xf7\xd8\xbe\x69\xfa\x94\x1c\x9c\x74\xcf\xee\xbb\xcc\x4f\x7b\x32\x74\xcc\xe7\xca\x33\x49\xce\x47\xdc\xbf\xc5\x74\x4c\x56\xc1\xbb\xb8\x0f\xad\x2f\x43\x73\x41\x19\x1b\xa0\x83\x47\xe1\x68\x1e\x43\x4a\x4b\x03\x54\xda\x9b\xa6\xd0\x12\x44\xf8\x62\x30\x46\xe3\x28\x98\x47\x4b\x7d\xe1\x57\xc2\x3a\x1d\xfc\x8d\x91\x58\xbf\xf0\x67\x35\x78\x4c\x7b\x6d\x3a\xf8\xc2\x48\xff\xf8\x9f\xc9\xe2\x5f\x48\xeb\xe3\x27\xfa\x09\x2e\xc0\x40\xb2\x2c\xa5\x94\x50\x28\x89\x96\xa1\xb9\xd2\x68\x9d\x06\x2a\x6d\x40\x95\x94\x5e\xb1\x38\x54\x0c\xaf\xf4\x7e\xd2\x6d\x17\x58\xd0\xd1\x6b\x5f\xf8\x95\x68\x8e\x5a\x27\x52\x60\xb4\xcd\x99\x83\xd6\xe1\x3f\xab\xc1\x33\x3f\x46\x55\x7a\xfc\x3d\xdd\xb6\xfe\xf0\x3f\x93\xc5\xbf\x10\xd5\xd0\xf9\xc0\x90\x02\x0c\x90\x19\x17\x16\x95\x12\x6a\x2b\x18\x54\xd9\x7b\x91\xbf\x15\xd3\xb6\x0b\xc5\x51\xab\x54\x16\x74\xfb\xc3\x61\x8b\x9b\xb5\xb0\x89\x42\x6b\xc8\x1f\xea\xcc\x38\xfc\x7e\x97\xc9\xe5\xeb\xcc\xb8\x9c\x1d\x19\x17\x6b\xc2\xf4\x6d\xb2\x74\x64\x4c\xee\x3e\xe9\x46\xfb\x3a\x0e\x68\xce\x7c\x5d\xca\xcb\x64\x55\x25\x96\x60\x94\x7c\x98\x24\xbd\x3b\xcd\x89\xc9\xfc\x22\x97\xfb\xf2\xf0\xb6\x97\x5e\xea\x62\xff\xf9\xc1\xe9\xf1\x80\x30\x6f\x26\xa9\x31\xf9\x91\xba\x04\x98\xd0\xb3\x0a\x7a\x43\xe3\x7a\xae\x22\xf9\x31\x65\xdb\x2a\xd9\x65\x5a\x76\x9a\xf6\x13\xcd\x2b\x45\xf9\xc6\x60\x95\x6f\x3c\xac\xf6\xab\x17\x77\x14\x1f\x29\xb1\xb1\x79\xfd\x4a\x73\x3e\xd1\x71\x18\xa2\xd2\xde\x03\x0a\x9f\xf1\x53\x3e\xb3\xaf\x3b\x10\xb6\xb9\x74\xfd\xda\x17\x7e\x25\x53\xac\xf2\x3d\x52\xe0\x36\x7f\x28\x07\xad\xc3\x7f\x56\x83\xc7\xb4\xf7\x3b\x1d\x3c\xf2\x87\xfb\x85\x3f\x91\x85\x7f\x0c\xde\xd6\xd7\xa7\xb7\x3b\x36\xb0\x9f\xfa\x3c\x93\xad\xcf\x42\x38\xa4\xd0\x2a\x4b\x4a\xb0\x0c\x5f\x1c\x57\xe0\x35\x5a\x25\x7b\xa6\x91\xcc\x7e\xc5\xb5\xe1\xf5\x2a\x25\x09\x26\x0e\x8b\x79\x88\xc4\x2c\xd8\xec\x87\xcd\x60\x26\x49\xa6\x73\x7b\x8e\xe9\x69\x25\x66\x48\x9b\xa1\xc6\x0c\x7e\x33\x18\x99\x7a\xf9\xb5\x6b\xa1\x41\xfe\xd5\x7c\xa8\x87\xc6\x6b\xe5\x5f\x41\xc3\xb5\xf8\xd9\xaf\xe6\x41\x23\xd4\xcf\x27\xb7\xf3\xe4\x5f\xc9\xbf\x9c\x47\xec\x4b\x73\x7b\xdf\xe5\x8f\xf0\x4b\x91\x1b\x6b\x36\x85\x68\x82\x34\x20\xea\x2b\x10\x39\x4f\xd8\xc3\x84\xad\x8c\x35\x59\x14\x15\x03\x71\x47\x9c\xa4\x7a\x43\x02\xc7\xb9\x25\x87\x87\x0b\x60\x6a\x22\x0a\xe0\x7b\x84\x9c\x42\xef\xd1\x60\x9d\xbc\xc4\xf2\x24\x3c\x07\x4b\xc5\xc5\x2e\x21\x41\x22\x61\x8d\x3e\x42\x54\x85\x69\x63\x12\xbc\x7e\x20\x19\x5f\x61\x68\x1a\x7c\xe4\x40\x8d\xe4\x1b\xcc\xab\x17\xf7\x5c\xbf\xe5\x89\x5f\x93\x8c\x5b\xdf\x3f\xbd\xe8\x41\x18\x1c\x63\x16\x4f\x7b\xf7\xf5\xbd\xcc\xd1\x58\xcf\x83\xd3\xde\xf9\xf5\xde\xcd\x7b\xe1\x2a\xa6\xab\xe3\xae\xb7\x9f\x97\x9f\x24\x79\xb7\x3a\xee\x62\x3e\xfc\xdd\x2d\xcc\xe9\xed\x24\x1d\xd7\x6f\x6e\xea\x11\xb6\x83\x5b\x19\x17\x9a\x63\x86\x8e\xfb\x30\x95\x4e\x36\x28\xf3\x2f\x44\xe7\xdf\x5f\xbb\xc3\x05\x6e\xa3\x6e\x5c\xfa\xc2\xaf\x64\x06\xab\x74\x48\x0a\xec\x0f\x45\x73\xd0\x3a\xfc\x67\x35\x78\x4c\x27\xef\xe9\xe0\x47\x85\x0a\xfa\x85\x7f\x26\x8b\x7f\x21\xa5\x2b\xca\xa3\x42\x64\x82\x0f\x2b\x49\x2a\x25\x74\x3c\x8a\xe6\x90\xa0\x75\x1a\xa1\xf2\xcd\xb3\xea\x37\x44\xfc\x8d\xbb\xc4\x80\xd9\x9d\xfb\x06\xe6\x07\x65\x6a\xde\x55\x0f\x8a\xa0\xd9\x52\x65\x10\xab\x81\xbc\x57\xe0\x85\x68\x81\x2d\xd0\x99\xf1\x04\xf1\x82\xe5\x89\x79\xb0\x7e\x6c\xf3\xd8\x3c\x26\xb6\x6f\x72\xc8\xd6\x02\x98\x93\x9f\xf0\x51\xb3\x92\x94\xf5\x89\xe9\xd6\xa7\x80\x14\x2b\x69\x7e\xaf\x64\x2e\x87\x93\x5b\xcb\x09\x39\x4c\xc9\xf1\x75\x37\x0c\xba\x79\x5b\xbc\x68\xfd\xed\xba\x1c\x91\x8f\x91\x34\x5f\xf0\x04\x4d\xfe\x45\x69\xbc\xac\xf7\x4b\x4e\xe2\x9f\xc0\xb3\x62\x9e\x34\x34\x55\x54\x84\x58\x8f\x0f\x37\xc4\x3e\x30\x6a\xb1\x47\xed\x43\x2b\x7d\x03\xe3\x1e\x89\x65\x5d\x25\xf1\x92\xe6\x0c\x4a\x81\x83\x4b\xc5\x7d\x2e\x43\x4b\xc6\x05\x16\x7b\x73\xc6\x22\xea\x76\x99\xe7\xb2\xab\x86\x0e\xb9\x2f\x3d\xe4\x40\xdb\x7f\x4d\xfc\x02\x34\xc4\x83\x6e\x26\xc0\xaa\xaa\x27\x9b\x9e\x49\xf1\x24\x90\x68\xa4\x5a\xa0\x39\xd2\xd3\x97\x31\x4c\x70\x66\x8b\xa1\xb1\xf9\xca\x91\xf2\x86\xc9\x7f\x3e\x06\xcf\xda\xae\x5b\x58\xd3\x34\xe3\xf2\xe8\x2f\x9f\x68\x78\x20\x5a\x5f\x5c\xd6\x60\x19\x2c\x8d\x1a\x5f\xda\x96\x64\x5d\x33\xd7\xc7\x1f\xfc\xc9\xe3\xa7\x2e\x36\xd5\x07\xd8\xf6\x0b\xa7\xe5\x9a\xf1\x8d\xc3\x16\x8c\xcb\x4c\x99\x7b\xf9\x7d\xbb\x42\xce\xef\x37\x56\x33\x53\x2e\xbf\xfc\xba\xb1\x25\x2b\x6f\xa0\xe3\x4c\xf7\xe2\xf3\x9b\xf0\x38\x37\xa8\x6b\xd1\xcf\x70\x9f\x60\x1e\x52\xec\x22\x3c\xe4\x4f\xdd\xe9\x52\x1b\xa7\xa3\xd5\xbe\xf0\x2b\xd1\x47\x18\x9e\xf0\x28\x52\xa0\xb6\xb8\x24\x07\xad\xc3\xbf\x47\x83\xc7\x6b\xd1\x33\x7a\xfc\x5f\x75\x17\xf7\x87\xff\x81\x2c\xfc\x63\xe8\x69\x4c\x5d\x59\xf8\x2f\xba\x2f\xab\xed\x07\x7e\x66\xb6\x3e\x0b\x51\x17\xc6\x4f\x64\x39\x5c\x80\x08\x66\x67\xba\xab\xca\x95\x12\x59\x59\x4e\x29\x73\x30\xfb\x8d\x47\xd0\xbe\xfc\x32\xdf\x76\x97\xe4\x95\xc1\xfc\x09\x97\xe1\x6f\x25\xfb\x9c\xf0\x7c\xb8\x02\xad\x91\x1a\x06\x0e\xf6\xb2\x31\x9e\x97\xa4\xaa\x58\x2c\x38\xda\xce\x16\xa7\x2f\x4f\x07\xd9\xe0\x98\x86\xe2\xe2\xd2\x82\xd2\x64\x73\xa6\xa0\x1a\xff\x2d\xf0\x95\x0a\xbe\xcb\x26\x65\x7c\xbe\xd1\x58\x4d\x1e\x3d\x1a\xb9\x5c\x96\x49\x19\x97\x0f\x8d\x24\xdb\xb0\xf3\xb7\x58\xab\x24\xe4\x1e\xde\xd7\xb6\x9b\xcb\x52\x90\x65\x6a\xea\x06\xec\x02\x86\x44\x62\x28\x1b\xb0\xd3\x5a\xd2\xf9\x3a\xd0\x5b\x76\xfc\x64\x5b\x2c\xa6\xb6\x91\x60\x74\x30\x64\x63\x2c\xdd\xa4\x5d\xcc\x7e\x7c\xe8\x70\xcf\xb7\xcc\xb0\x15\x57\x5d\xf6\xa3\x01\x43\x77\x37\xff\xf8\xb9\xaa\xc7\xde\xde\xbc\xa5\x62\xce\x8e\x8d\xd7\x34\x8c\x9d\x3d\x23\x3d\x7a\xef\xee\xc7\xc6\xcf\x91\xd7\x0f\x6b\x1f\x14\x4a\x8c\x1f\x3b\xa6\x50\x62\xc6\x4b\x23\x4f\x95\xb3\x6f\x1f\x39\x3c\xb9\x6a\xc5\xaa\x7a\xb7\xf5\xca\xc2\xd2\xba\x91\x3f\x5a\xb7\x69\xc2\xf5\x63\xd3\x3c\x7b\x6f\x66\x4a\xe5\xca\xbf\x14\x35\x8e\xbf\xb8\x3b\x15\x8a\x6f\x98\x32\x94\xe5\x06\x4c\x1b\x37\xb5\x95\xf9\xe1\x3f\xf6\xfc\x74\x0d\xe9\xf7\x46\x79\x26\xc9\x0f\x80\xfb\xbd\x51\x91\xf1\xd0\xa3\x8a\x8c\x17\x2a\x28\x33\xa0\x9c\x8c\x47\xf7\xb2\x53\x1a\x6b\xc2\x70\x06\x74\xc5\xcd\x94\x62\x0a\x28\x05\x7c\xda\x1d\x2b\xf4\xe4\xaf\xcb\xf9\xf0\x84\x26\x8f\xa8\x34\x49\x8a\xdc\x52\x90\xe8\x17\x7e\x8f\x06\x8f\x69\xf2\xc7\x3a\x78\x67\x41\xff\xf8\x67\x66\xf1\x2f\x44\x6b\xf1\x0b\xba\x6e\x16\x10\x82\xb1\x0c\x4a\x2b\x25\x72\xfc\xb3\xf7\x1c\xdd\x17\x4b\xea\xf4\x4f\xa5\x0d\x8f\x90\x36\x80\xc5\x45\x56\x80\x9f\x77\x5b\x1d\x7d\x64\x36\xb2\x8f\x76\xb2\x0e\x7e\xa5\x4c\x6b\x44\x0b\x4c\xb4\xd8\xf5\xf2\x5a\xef\xc7\x18\x76\x2e\xad\x3f\x85\x65\x7e\xfc\x7b\x1d\xee\x8b\xdd\x96\xbe\xb8\x59\x0c\x7f\x05\xad\xbf\x82\x7b\xe1\x1f\x10\x95\xee\x70\x01\x22\xdd\xf5\x76\x07\x3d\x79\xd2\x5d\xee\x8c\xaa\x97\x50\x90\x5a\xf6\x24\xb3\x21\x00\x5c\xd0\x64\xb2\xc6\xe3\x2e\x5f\x28\x64\xb5\x06\x59\x17\x57\x9c\x0e\x80\xd9\xc0\x05\x89\xab\x3e\x18\x34\x7a\xbd\xd1\x96\x8c\xcf\xeb\xe5\x1c\x8e\x64\x4b\xc6\xe1\x33\x1a\x39\x8e\x6d\xcd\x70\x88\xe4\xe4\x50\x99\x7b\x79\x5d\x4e\xec\x53\xa8\xde\x9f\x97\x6b\x9e\xd8\x29\x09\x7d\x7b\x6a\x30\x0b\xf4\xf9\x53\xa2\x11\x79\xc4\xec\x31\x7f\xfe\xe2\xb4\x11\x74\xfb\x92\xfe\xf6\x7c\xa6\xa3\x6b\x33\x44\xdf\x80\x1a\xa3\x72\x0c\x56\x7d\x2a\x31\xb7\x17\x9e\x69\x9c\x30\x4e\x1a\xdd\x34\xa1\x91\x9b\x33\xb7\xbe\xe0\xfa\xf4\x8c\xa7\x6e\x5b\x2a\xcb\x72\x30\x29\x57\x7c\xfd\x97\x13\x5f\x9a\xee\x5b\xb8\xb5\xe7\x93\xd7\xba\xf6\xbc\xf5\xce\x53\x2f\xe1\xfe\xa1\x7b\xd0\x28\xcf\x99\xa4\xf2\x9c\xb3\xb8\x07\xa8\xcc\x8f\xbb\x94\x29\x1a\x2c\xe6\xaf\xa7\x4a\xdf\x90\xb1\x9a\xac\xf2\xcc\xf5\x0a\x4f\x0b\x50\x0a\x3d\xd0\x1d\x8c\xa8\xe4\xac\xf0\xa8\xbe\xf0\x2b\xd1\x67\x2a\xbd\x91\x02\x33\x02\xe1\x1c\xb4\x0e\xff\x1e\x0d\x3e\xc7\x33\x15\xfc\x72\x77\xa0\x3f\xfc\x0f\x64\xe1\x1f\x43\x7b\x14\x9e\xa9\xc0\x9f\xef\x8e\x0f\xea\x07\x7e\x66\xb6\x3e\x0b\x29\xcf\x27\xfc\x2f\xa0\xf0\xbf\xde\xee\x74\x42\x29\x91\xe5\x7f\xd3\xd0\x2f\x38\x07\xf7\x30\x3d\xcf\x36\x8c\xc6\x4b\x03\xec\xc6\xa0\xd1\xe3\x01\x06\x98\x68\x64\x93\xb0\x4b\x60\x04\x1f\xbb\xc6\xb2\x19\x0b\x87\x88\x03\x1b\xcb\x31\x12\x39\xf7\x84\x7d\x49\xb5\x5b\x7c\x8c\x17\xc6\x43\x73\x84\x8f\x0f\xe9\x04\xc6\xca\xec\x79\x27\xff\xe2\xdc\x19\xce\x71\xb1\x09\x8e\x0d\x6b\x6e\x1e\xa6\xfb\xcb\x9c\xde\xb4\xa9\xe7\x1d\xed\x96\xf9\xb3\xf6\x0b\x51\x3f\x65\x63\x6f\x17\xfb\x0a\x2b\x53\x39\xa4\x08\x2d\x94\x2e\x47\x2e\x8b\x91\xb3\x31\x05\xfe\x98\x8f\xf3\x46\xbd\x8c\xdb\xe3\x61\xa2\x36\x93\xd9\x6c\x63\x6c\xa9\xe2\x02\x5f\xa8\xd0\x59\xd8\x92\x31\x5a\x90\x8b\xe3\x3d\x92\xd3\xc7\x87\x5a\x32\x66\x5e\x90\x8a\x09\xcd\xfe\x6b\xd1\x32\x1b\x08\xe0\x57\x29\xb6\xa6\xd8\xa5\xee\xb8\xca\x66\x2b\x48\x82\xe8\x07\xba\xce\xf3\x69\xa0\x71\x01\xfb\x6f\xf8\xf0\xf8\xe6\x8e\x09\xb7\xad\x5c\x76\xf4\xc4\xba\xf6\x2b\xd7\xc0\x20\x06\x38\x67\x6d\xe5\x95\x23\x20\xc4\xc8\x17\x1c\xc3\x2a\x5a\xea\xdb\x57\x01\xfb\xc3\x37\x55\x4b\x9e\x5f\x75\xb1\xe7\xec\x90\x1b\x98\xf2\x91\xc3\xe0\xb6\xba\xba\x27\xfe\xba\x50\xbe\x6b\x44\xed\xf3\x78\xfc\xe8\x9e\x1b\x4a\x4f\x33\x54\xfa\x7b\x89\xd2\x07\x04\x28\x07\x78\x03\xd3\x9f\x51\xd4\x8d\x77\x5f\xf8\x95\xe0\x54\xe8\x8f\x16\x68\x0b\x84\x73\xd0\x28\x07\xbf\x47\x83\xc7\xf4\x77\x5c\x07\xcf\x07\x22\xfd\xc2\xcf\xcc\xe2\x5f\x88\x3e\x55\xf8\x23\x43\x0a\x30\x60\x4a\x27\x94\x12\x3a\xf9\x92\xc6\xb2\xd3\x3a\xcd\x56\xeb\x64\x55\xbf\x81\x59\x2a\xfc\xa8\x20\xc1\x58\xf3\xe4\x4b\x87\x3c\x91\xab\x24\xfb\xe0\xf1\xa8\x4e\x90\xd2\x71\xce\xeb\x0d\x86\x6c\x41\x3c\x84\x41\x1a\xca\xef\x0b\x3b\x0b\x5b\xb1\xae\xe9\x33\x47\x5b\xb1\x92\x20\xb0\xa8\x39\x83\xf9\x5e\x5d\x6e\x23\xec\x25\x69\xa0\xa9\x38\xe9\xe9\x9b\xfe\x26\xbb\x53\x10\x94\x3d\x9e\x84\xcf\xdc\x79\x23\x6c\x35\x8f\x58\x75\xc5\xe1\x3f\x7e\xfc\xc1\x6a\x65\xaf\x20\xb3\xe1\xea\xcc\xac\x69\x93\x66\xcc\x5c\xc0\x57\x91\x4c\x38\xd7\x4c\x2d\x89\x9f\xfe\xfe\x8c\x2c\x6b\x3b\x06\xd9\x8a\x57\x7f\x57\xd6\x33\x82\xe6\x67\xc9\xb6\x77\x66\xb6\xbd\x0b\xd1\xdb\x5a\x1f\x91\x45\x07\x42\x83\xd2\x4a\x8b\xf5\x7d\x44\x6d\x4e\x63\xb2\x36\xa7\xf5\xf9\x76\xb0\x9e\x6e\x8f\x98\x67\xd7\xa2\x72\x0d\xf7\xbf\x59\xb9\x66\x3d\x7a\x4e\x2f\x6b\x9d\xee\x2e\x1e\x90\x27\x3b\x29\xf8\xbf\xc9\xe2\xdf\x01\x9b\xf2\xf1\xfb\x0a\x2e\xc5\xcf\x3f\x99\xc5\xbf\x83\xca\x5a\x3a\xfc\x25\x83\xf3\xf1\xcb\x93\xc9\xb9\x31\x59\xfc\x8f\xb2\x41\x0c\x3f\x58\x72\x31\x3e\x29\x10\x68\xf2\x49\xa2\x88\xff\x71\x08\x4d\x64\x33\xe1\x4b\x36\x1b\xbd\x4a\x66\x8b\x05\x3f\x35\x9b\x9b\x7c\xae\x32\xfa\x9f\xf2\x6d\x79\x32\xc9\x19\x95\xfd\xf6\xa3\x40\x12\x6b\xd9\x5f\x45\x4c\x6f\x77\x77\x49\x49\x2a\x95\xca\xe9\xb8\x65\x54\x6f\x29\x56\x75\x29\x8f\xce\x7e\xf3\x7a\x24\xa6\x1a\x93\xf4\x6b\xfb\x4c\x4a\x87\x8d\x2a\x6f\xfe\x42\xa5\x43\xc2\xfb\x37\x44\x62\x7d\x78\x33\xc5\x6f\xac\xd2\xf0\x63\xdd\xeb\x23\xd8\x82\x4c\x2f\x41\x11\x5f\x4c\x81\xb2\x38\xf7\x28\x38\x05\x32\x7f\x5e\xca\x95\x35\x1c\xcb\x96\xdd\x09\xe7\x70\xdd\xfa\x2b\xbb\x21\x5b\x76\x27\xda\xab\x2b\x7b\x36\x5b\x76\x1d\x2d\x4b\xe7\x0b\xd1\xc7\xe2\x91\x7e\xdb\xb5\x47\x6b\x17\xb3\x0e\xbd\xae\x9b\x5f\x0d\xf1\x48\x9f\x76\xd1\xf3\x4a\x28\xfe\xb4\x8a\xbf\x5d\xa1\x85\x30\xa5\x85\x6f\xba\xa3\x41\x8f\x43\x37\xb6\x53\x70\x7d\x8e\xf3\x1b\x85\x62\x34\x96\xc0\x9b\x7a\xd8\x8f\xb0\x64\x1c\x96\xcc\xcc\x60\xc4\xa4\x24\x3c\x86\xaf\x30\x7f\xea\x4e\x15\x1a\xbd\xb8\x50\x19\xb1\x89\x6a\xba\x28\xb5\x1b\xb9\x0d\x48\x89\xe9\xd2\xf2\x33\x15\xa0\x12\x74\xa7\x34\x31\x66\x44\x4e\x37\x5b\x54\xe4\x0f\x1b\xc3\xa5\x65\x05\x61\x2c\x42\x8b\x21\xc1\x25\xb4\x64\xfc\x2e\x92\x11\x88\xec\x21\x46\x96\x74\x4b\xc6\x86\x2c\x82\x05\xab\x93\x16\x81\x2b\xa4\x49\x9b\xf6\x95\xc1\xee\x32\x58\x56\x06\xad\x65\x20\x95\x41\x45\x99\xba\x8b\x44\xdd\x13\x48\x2d\xa1\x39\x61\xbb\x8f\x17\x4d\x3b\xbf\xa9\x4f\x92\xa6\x64\x55\x65\x15\x51\x34\xd5\x24\x3a\x97\x24\x6b\xfa\xe3\xc1\x8f\xdf\x5f\xbc\xd4\xf0\xd1\x47\x24\x5d\xd3\x75\x34\x61\x53\xc7\xf4\x2b\x33\x93\x27\x2a\x09\x9b\xfe\x7e\xee\xcc\xf7\xe1\xc4\x7d\x96\xeb\xee\x0c\xd4\x1f\xbb\xee\xa2\x33\x50\x0f\x7f\xfc\xc5\x1b\xa5\xcc\x8b\xde\xfd\x3a\xdb\xe1\x98\xac\xad\x71\x3d\xb4\xe8\x68\x35\x12\x29\xe8\x63\x6b\xa4\x72\x28\x9d\xdf\x4d\xea\xfc\xbe\x5f\x27\xb7\xba\x0b\xe2\x7d\xe4\x56\x05\xff\x37\x59\xfc\x3b\x60\xba\x0e\x7f\x32\x96\xee\x0f\x3f\x9d\xdf\x4d\xea\xfc\xde\xa8\xc3\xef\x49\x94\xf4\x8b\xff\x58\x16\xff\x4e\xb8\x52\xc5\x9f\xc2\xf8\xc3\x91\xc2\x7e\xf1\x6f\xc8\xe2\xdf\x99\xad\x7f\x9a\xe0\x2f\x28\xea\x8b\x5f\x9e\x4c\xce\xac\xc9\xe2\x7f\x94\x79\x41\x99\xf3\xd0\x7b\xaa\xbb\xb4\x34\x18\x54\xe7\x7c\x23\xe6\x0d\x33\xd8\xb7\xb2\x78\x1f\x05\x4c\xc3\xc8\xf2\x32\x63\x1c\x38\xd0\x66\xc3\x40\xfd\xd8\x75\xd7\xc1\x68\xdd\xfc\x71\xc6\x23\xfd\xd6\x35\xa7\x23\xac\x43\xf7\xa8\x75\x8d\xe3\xba\xda\x0b\x0b\x3c\x97\xd8\x06\x0d\x40\xf9\x42\xa9\xca\x17\xbe\xc2\x7c\x81\xe0\x4f\x62\xfc\x42\x32\x6d\x8c\xe7\xc1\xd3\x1c\x4b\x14\xff\x78\x75\x8d\xdd\x41\x79\x29\x3b\x0a\x8b\x60\xaf\xf4\x9e\xe8\x1e\x55\x1f\x0f\xe6\xdb\xee\x0c\x40\xc7\xb2\x54\x1d\xcb\x8b\x6a\xfd\x09\xfe\x68\xf1\x65\xfd\xe2\x7f\x32\x8b\x7f\x07\x7a\x56\x8f\xff\xcb\xee\xd1\xe3\xfa\xc1\x7f\x2c\x8b\x7f\x67\x96\xbf\x0c\xc4\xf8\x03\xc9\x92\x7e\xf1\x6f\xc8\xe2\xdf\x49\x4e\x94\x25\xf8\xc7\x52\xfc\xff\xe8\x1e\xd5\x90\x8f\xbf\xe7\x5b\x72\x0e\x8c\xa0\xe2\x37\x1d\x00\x2c\x23\x40\xe5\xab\xa8\x1a\xb3\xfe\xb9\x73\x9b\xaa\xc9\x12\xd0\xd1\x41\xaf\x92\x79\xf6\xec\xa6\x6a\x69\xc6\x0c\xe5\xe9\xf4\xe9\xca\x75\xda\x34\xe5\x3a\x75\xaa\x72\x6d\x6b\x53\xae\x53\xa6\x28\xd7\xc9\x93\x95\xeb\xa4\x49\xca\xb5\xb9\x59\xb9\x8e\x1f\xaf\x62\x1d\x37\x0e\x63\xad\xaf\x57\xef\x46\x8f\xc6\x77\x23\x47\x2a\x30\x23\x46\x28\xd7\xda\x5a\xe5\x3a\x6c\x98\x72\xad\xa9\x51\xae\xd5\xd5\x4a\x29\x47\x65\x25\x2e\x95\x4e\xe3\x7f\x8a\x8a\x94\x57\x89\x84\x72\x8d\xc7\x95\x6b\x34\xaa\x7e\x00\x2f\x71\xd5\x92\xcb\xa5\x3c\x75\x3a\x95\xab\xc3\xa1\xbc\xf5\xda\xed\xf8\x2d\x5e\xe5\xaa\x25\x93\xa9\x09\xac\xe9\xa4\x31\x81\x29\xb5\xec\xff\xfc\x9f\xae\xff\x0d\x49\xad\xff\x4d\x32\x7a\x5e\xe9\xff\x2b\x69\xff\x7f\xd5\x3d\x6a\x74\x5e\xff\xd3\xb3\x66\x28\xfd\x97\xa9\xf4\xf9\x5b\xc5\x26\x19\xa1\x36\xc9\xde\xee\x48\x1c\xe9\xf9\x3b\xcd\x6b\x65\xac\xc7\xf0\x13\x54\xfa\xfc\x2b\x3c\x46\xe0\x0b\x18\x02\xff\x5d\x77\x41\x61\xd8\x9c\xa5\x08\x26\x7b\x96\x4d\x12\xaf\x1f\xaf\x48\x4b\x7c\x7c\x31\xcf\xd8\x79\x48\xdb\x13\x09\x03\x53\xe4\x28\x28\x10\x83\x4c\x90\xc4\xae\x77\x96\x30\x52\x49\x6b\xc9\xee\x92\x7d\x25\x5c\x71\x80\x73\x72\x60\x66\x79\xae\x33\xe3\x13\x8b\x45\xc6\x2e\x82\xe8\xb3\x17\xdb\x19\x3b\xcd\xc8\xcc\xa7\xb1\xa4\xd7\x99\x41\x69\x21\x8d\x59\x7d\x3a\x8d\xcc\x5e\xa7\x8d\x66\xe4\x75\x99\xd9\x44\x41\x90\x26\x16\x8f\x20\xf7\xbf\x39\xf4\x86\xfa\xbc\xc9\x4e\xb1\x39\x43\xe6\xe0\x3b\x9a\x63\xa0\x12\xe6\x2c\x77\xb9\x73\x79\x45\xc9\xff\x68\xce\x1c\xe5\x48\x1c\x8d\xe7\x1b\xb1\x0c\xa8\x1a\x19\xb5\x14\x6a\xf4\x68\x1c\xc0\xcf\x92\x5d\x5d\xfa\x03\x72\xb4\x23\x72\xe0\x96\x9e\x8f\xc7\x87\xd8\xb6\x25\x2f\x11\x33\xe3\x4b\xca\xbf\x4b\x2e\x76\xe5\x0e\xca\x61\xfe\xfe\xfe\xfb\x8a\x5d\x9d\x51\xf3\x86\xa5\xc8\xbe\xf9\x22\xf0\xf9\x62\x61\xa7\x25\x6c\x29\x4e\x3b\xd3\x30\x4a\x48\xc7\xd3\x15\xe9\xd6\x74\x67\x7a\x77\x7a\x5f\xfa\x64\xfa\x4c\xda\x5c\x81\xbb\x62\x73\x7a\x7f\xfa\x70\x9a\xef\x25\x49\x2f\xd7\xe0\xbb\xdd\x69\x0e\x43\x5b\x59\x88\x16\x60\xcd\xbb\xa8\xa0\xc0\x58\x58\x18\x6f\xce\x14\xa2\xb0\xcf\x69\xb1\x59\x9a\x33\x41\x1b\xcd\xb6\xc3\xd1\x63\x9d\x8d\x02\xaa\x9b\x93\xdb\x1f\xaf\x26\x38\xc9\x2e\x86\x5a\xba\xad\xdc\xae\x01\x35\x54\x28\x29\xfe\xeb\xc4\x61\xd9\x05\x92\xd9\x7b\xe1\xd2\xfc\x61\x5b\xb6\xe0\x75\xf1\x02\x37\x61\x81\x9a\x43\xec\x75\x9a\xa4\x21\x4c\x12\xa1\x4c\xa5\x22\xf2\x37\x74\x65\xa4\xf4\x3c\x02\x13\xd1\x49\xea\xcb\x18\xa8\xea\xb0\xc3\x74\x3e\x2e\xe4\x4d\xe4\xdb\x34\x7a\x0f\x61\xf8\xe5\xfc\x96\xac\x0d\xe4\xb1\x77\x75\x36\x90\x0b\xdd\xee\x58\xbf\x3e\xb1\x31\x59\xfc\xeb\xd1\x70\x3d\x7e\x5b\x1f\x9b\x49\xef\x29\x0c\xaf\xac\xb5\x0a\xfe\xf5\x7a\xfc\xe7\xbb\x2d\xb6\x7e\xf1\x7f\x93\xc5\xbf\x03\x5d\xae\xc7\xef\xf4\xf7\xc1\x4f\xec\x43\xcd\x94\x3f\x2b\xf8\x77\x1c\xd2\xe1\xef\xe9\xb6\x8b\x7d\xf1\xcb\x93\xc9\xf9\x4a\x2a\x7e\x03\xf3\xe8\x4a\x6a\x39\xab\x70\x86\x54\x40\x62\x43\xc2\x30\x11\xca\x93\x27\x2a\x30\x3f\x10\x18\xa6\x20\x58\x94\x83\x51\xea\x79\x2c\x5b\xcf\x9d\xd9\x7e\x16\x69\x3f\xb8\xf5\xdf\x25\xf1\x5d\xc4\x8e\xc5\x76\x21\x33\x6a\x94\xca\x48\x0c\x8b\x25\x3f\x69\xdb\x3e\x2d\xb5\x54\x7f\x79\xa5\x96\x2f\x5f\xfe\xef\xf2\x49\x75\xeb\xf3\x49\x91\xe4\x1d\xa4\x7e\x78\x1d\xba\x8e\x1f\x29\x68\xbe\xc8\x41\xcc\x2e\x5c\x0f\x01\xd7\x2f\x6e\x5b\x63\xdb\x67\x3b\x69\xe3\x6c\xae\x39\x8a\xac\x3c\x48\x9e\xc8\xfe\x83\xdf\x20\x28\xed\x35\xa2\x2b\xe1\x4d\x0c\x3b\x50\x8a\xb3\x8c\xb3\x02\xf0\xff\xb1\x8a\xf2\x8a\x59\x15\x4b\x2b\x6e\xa9\xd8\x5b\xf1\x5a\xc5\xfb\x15\xa6\x0a\x40\xa7\xf1\x32\x87\x11\x54\xb9\x70\xed\xaa\x14\x3c\xe4\xbc\xa8\xc3\x94\x37\x0e\x52\x79\x63\xb5\xda\x27\x98\x8d\xc1\x2a\x5f\x48\xef\x07\x54\xf3\xc8\xbd\xc3\xef\x41\x2e\x14\x42\x0b\x25\xc9\xe7\xf1\xd8\x8d\x3c\xef\x44\x76\x7b\x24\xec\x0d\x6e\xcc\xb8\xbd\x3f\x99\x15\x70\xba\x63\x6e\xcc\xb4\xdc\x2e\x47\x0b\x56\x4b\x59\x0b\xd6\x4a\xd9\x30\x8a\xc0\xc9\x08\xec\xa7\x49\x21\x97\xd1\xbc\x90\xad\x91\x4b\x92\xca\xa9\x6e\x7b\x2d\xa6\x2c\xeb\x35\xe0\x2f\x49\x28\x97\xaa\xf2\x54\x7a\x44\x2c\x5b\x30\x89\xbc\x84\x72\x72\xec\xa3\x23\x47\x27\x7e\xff\x7d\x5a\x9f\x4e\xee\xc5\x04\xa4\xe4\x63\x89\x27\x9e\x50\x64\x2b\xbc\x1e\x97\x50\x7a\xba\x8c\xe8\x19\x78\x3d\x7e\x47\x91\xcf\x7b\xbe\x25\xf9\xe6\xf0\xf3\x66\xe5\x39\xfa\x1b\xca\xe6\xa1\xc3\x74\x10\x44\x4b\xa4\xe1\x2b\x8d\xf7\x18\x19\xc6\x08\x66\xce\xe8\x30\x38\x1d\x46\x30\x1a\x0c\xbc\x60\x37\x9b\xc3\x4e\x24\x08\xa2\x18\x12\x05\x93\xdd\x6a\x27\xe9\xe8\x58\x8f\x55\x34\xf8\xe8\x5e\xf4\x00\xeb\xd4\x1f\x22\xa5\xa5\x4f\x53\x4f\xca\xcf\xc6\x23\x0c\xcf\x46\x22\x10\x6e\x3d\xe7\xff\x5a\x0e\x35\x35\xed\x92\xb2\x16\xf2\x88\xea\x88\xe5\xaa\xce\xd7\xa5\xac\x85\x02\x5d\x0b\x37\x74\x0b\x1e\xb3\xde\x3f\x47\x72\xae\x35\x1b\x07\x61\xf8\x16\x05\xbe\xf7\x3c\x5e\x0b\xa9\x75\x16\x2f\x86\x57\xea\xad\xb3\x5a\xdf\x92\xf3\xaa\x14\xfc\xb4\x6f\x67\xd0\xe7\x03\x7a\xbe\x25\xb9\xdb\x54\x3c\x06\xd3\x81\xdf\x11\x29\x15\x38\x9f\x85\x47\x29\x55\xff\x53\xce\xba\x9a\x2c\xa8\x75\x33\xf5\x30\xc4\xb6\x93\x7a\x15\x25\xb1\xd0\x60\xc3\x42\x03\xc4\x38\xf0\x48\x16\x5b\xd3\x2b\xb0\xbc\xdb\x23\xd0\x8a\x52\xfd\x0a\xca\xd4\xba\xb2\x3b\xe8\x9c\x68\x51\xca\xc3\x76\x54\x4b\xf4\x32\x08\x22\xb0\x53\xbd\x0c\xde\xe9\xb6\x5b\x68\x95\x75\x7a\x99\x7a\xc6\x96\xd6\x27\xcc\x4e\xa6\xba\x47\x46\x5e\xc9\x02\x4e\x01\x68\xa6\x11\x01\xe1\x69\x03\xda\xdc\xc3\x52\x04\x3b\x51\xf9\x0e\xab\xc8\x8b\xb3\x31\x7c\xea\xe7\x60\xa1\xb2\x4f\x24\xd6\x64\x91\x82\xa1\x26\xe5\x4e\xf4\xe3\x3b\xab\xa3\xc9\xe2\x52\xf4\x79\xdd\x99\x5e\x7e\x34\x4d\x2a\x37\x5a\xad\xc8\xeb\x14\xbc\x42\x20\x88\xb5\x3b\x23\xe7\xc3\x32\x11\x6b\x75\x5b\x3b\xf1\x54\xea\xc8\x08\x6e\xb7\x01\x13\x50\x47\x86\x65\x95\x14\x30\xfa\xbc\xc1\x59\x67\x9b\x2e\x99\xa8\xba\x93\x48\x39\x86\xa3\x46\xd4\x9f\xf5\x65\xac\x7a\xff\x67\x4c\xf7\xfb\xa7\x4f\x83\xeb\xd0\xf5\x93\x67\xa6\x2f\x8c\xef\xda\xc3\xdc\xc2\x5c\x45\x4f\xb6\x6b\xbb\xef\x9e\xfb\x7a\xde\x12\xc1\x2f\x2f\x1c\x1f\x82\x0d\x1d\x3f\x26\x39\x17\xf0\xd8\x97\xe3\x75\xda\x85\x66\x4a\x55\x06\x0b\xee\x0e\xa7\xc7\x4d\x4e\x50\x6a\xce\x90\x6c\xf2\x9c\x4b\x32\x1a\x79\xbb\xc8\x33\xcd\x19\x1e\xc5\x3c\x70\xd2\x03\xfb\x3d\xb0\xcf\x03\x9b\x3c\x50\xe7\x81\x72\x4f\x6e\x7a\xab\xce\x1d\x52\xd5\xbc\xdc\xad\xc4\xda\x4d\x83\x34\x6b\xb2\xe7\x64\x19\xbd\xab\x30\x21\xaf\x59\x43\x18\xe4\x2a\x46\x6c\x64\xfe\x3b\x50\xdf\x73\xd3\xf8\xdb\x26\xf4\x1c\xa1\x24\xbd\x76\x6c\x2e\x7e\xe1\xb8\x16\xbf\x80\x56\xc2\xdf\x75\xf1\x0b\x37\x78\xfd\x7d\xe2\x17\x14\x3b\xf7\x26\xcd\xce\x8d\xe1\x47\xe8\x6c\x1d\x0b\x22\xb1\x3e\x76\xee\x34\xa6\xe3\x2e\x4a\x13\x83\x55\x99\xfd\x79\x4d\xff\x3a\xdd\x1d\xf7\x9a\x3d\xaa\xfe\x55\x83\x79\x46\x1b\xf5\xeb\x4c\x52\xe0\xd0\x0f\x54\xff\x02\xd3\x80\x88\xdb\xaa\xe8\x5f\x4a\x5d\xcf\x66\x63\x2d\xd6\x69\x3e\x71\x1f\xaf\xac\xa8\x01\x6f\xae\xb6\xd9\xba\xee\xc9\xda\xe4\xd7\x51\xbb\x0c\x91\x3f\x55\x2f\x47\x3c\x22\xea\xe7\xa8\x9d\x9e\x11\xb6\x5e\x48\xa3\x49\x64\xb6\xb9\x0c\xc6\x53\x1b\x87\xa3\xa1\x3f\x87\x18\x91\xba\xb1\x14\x4e\xae\xff\x69\xb1\x36\xc5\x90\x5f\xa1\xd0\x48\x93\x5f\xf2\x78\x9b\xc8\xdd\x4b\xf8\xb9\x9f\xd0\x66\x95\x8b\x92\x27\xc9\xe3\x40\xfc\x7d\xfc\x58\x54\x88\xc7\x7d\x70\x34\x5c\xe8\x13\x0c\x06\xab\x2f\x4c\x36\x2d\x06\x89\x48\x1a\x01\x2b\x1f\x09\x7a\x04\x9e\xf5\xb0\x57\x65\x3c\x9c\x72\x18\x9d\xc1\x4a\x8e\xa3\x33\xbb\x73\xa9\x4c\xd5\x3c\xf6\x59\xcf\x70\xdf\x63\x75\xf3\xd2\xc8\xf9\x47\x01\x91\xb3\xbc\xea\x09\xf1\x24\xe0\x94\x1b\xb9\x70\xde\xd6\xdf\x5f\xdb\xd3\xfd\xdc\x73\x70\xd4\xb1\xf2\xbf\x16\xc2\x2f\x8e\x9e\xb8\x7b\x66\x26\x51\x22\xdd\xc2\x1e\x5d\x76\xeb\xfc\x8b\x16\xe7\x54\xc5\xb3\xbd\xea\x8a\xd1\xf2\x9d\x3d\xff\x73\xfc\xf3\x02\x70\x3f\x5a\x72\x40\x59\xbf\x6b\xf0\x1a\xf9\x25\xfb\x36\x9e\x6f\x3b\xa4\xf9\x1e\x03\x0a\x85\x62\x06\x5b\x8c\x2d\x4a\x7d\x40\x8f\xa4\x1a\xd5\x96\x9a\x9b\xda\x93\xea\x4e\x9d\x4a\x9d\x4b\x19\x2a\x52\xc0\x08\xa9\x78\x8a\xa9\x48\x49\xa9\xcd\xa9\xfd\xa9\xc3\x29\xbe\x37\x05\xad\xa9\x35\xf8\x6e\x77\x8a\x73\xe2\x32\x2c\x15\x31\x9d\xa1\x58\x34\x46\x02\x96\xcd\x42\x6b\x86\xa6\xb6\xb0\xf0\x36\x73\x98\xf5\xd3\x24\x7d\x5a\x1e\x26\x2a\x80\x07\xf4\xa9\xbe\x88\x84\xd9\x91\xcd\x9d\xa2\x4f\xad\x37\x44\x6d\x77\x76\x7d\xeb\x2f\xc5\xde\xf9\xdc\x32\x37\xf2\x92\x3c\x7b\x25\xda\x6a\xc7\x1c\xbe\xa6\x25\x2f\xd7\x5e\x36\xf6\x65\x4c\x36\x56\x66\x3d\x8d\x81\x30\xbd\x44\x22\x5f\x34\xdb\x1b\xf5\x8b\x50\x99\x6f\xb2\xce\x7e\xaa\xf9\x69\x50\x20\xd4\x8f\x2d\xf0\x08\x95\xf9\x86\xa8\x3a\xf9\x3b\xfd\xe3\xa4\x72\xde\x64\x9d\xcd\x34\x8b\x33\x9c\xec\x17\x67\x2e\x06\x68\x17\x73\x45\x5e\x8c\xce\x6a\x7f\x9f\x18\x1d\xf5\x1b\x6f\xeb\xfc\x45\xbb\x90\xac\xf9\x27\xa9\x43\x67\x4a\x20\xdf\x9b\x43\xf4\xb5\xe5\xbd\x3f\x18\xb7\xf3\x63\x50\x02\xcb\x59\xeb\xa5\x09\x85\xc8\xed\x14\x04\xcc\xc7\xa2\x22\xd6\xb3\xc2\xc8\x64\x34\x86\xc2\x28\x3c\xe8\xb2\x58\x8a\x9c\xa9\x1a\x15\xbc\x76\x2f\x09\xe5\xb2\x63\x02\xb0\xdb\xf9\x68\x54\xec\xcc\x84\xa3\x6e\xb6\x94\x70\x65\x9e\x9c\x92\xfd\xae\x11\xe6\x63\x41\x80\x27\x9b\x73\x95\xcd\x5c\x8a\x4b\xbb\xb2\x4f\x28\x22\x49\x42\xa4\x8f\x41\x54\xf7\x89\x67\x59\x21\x3d\x91\xf9\xd2\x00\x44\x9a\xb4\x23\x61\x48\xc6\x95\x73\xc9\xa8\x15\x8e\x59\x0e\x19\xe8\x6c\x5b\xc6\x4e\x9d\x15\x5f\x76\xf2\x7a\x30\xd2\x38\xc4\x1f\x1e\xbe\xea\xbf\x53\xc3\x67\x79\x2e\x66\x6e\x1e\x21\xff\x4c\x7e\x14\x26\xbe\xf0\xc6\x92\xe1\x23\x17\xbe\xd9\xc5\x3c\x49\x82\xf9\x4c\xfa\x78\x44\xb3\xf1\x7b\xf9\x3e\x23\x4c\x87\x29\xf2\x01\xf9\x3b\x0f\x37\xc7\x23\x9f\xa7\x7e\xa4\x0a\x3c\x0e\x0f\xe1\x79\x13\xc5\x2b\x5d\x25\x96\xf2\x6a\x22\xee\x82\x72\x9e\x2f\x28\xe0\x52\xfe\x0a\x07\xe7\xe7\x86\x56\x45\xdc\x21\x6f\x28\xd1\x92\x09\x09\xde\x92\x96\x8c\xd7\x57\xc1\xb5\x64\x2a\x2a\x88\x5d\x72\x52\xc6\x21\xf8\xd0\xc0\x9c\x8b\xbf\xb2\x8f\x8f\x3f\xcf\x9b\xa4\xdf\xeb\x93\x9f\x5a\xbd\xba\x46\x24\x53\x22\x97\xce\xaf\x9a\x1d\x5a\xac\xa4\xc2\xa7\xaf\x41\x4d\xb8\xce\xf9\xde\x7d\xb5\xe7\xdb\xa1\x37\xcc\x1d\x79\x5d\xf5\xea\x9f\xfc\xe3\xa6\xce\x3f\x7c\x78\xf8\x83\x63\xbf\xea\xec\xfc\xae\xee\xca\xa1\xc3\x02\xc1\x61\x95\x57\xd6\xc1\xd3\xa3\x47\x9c\x72\x0f\x64\xdf\xfa\xe3\x9f\x26\x0b\x5b\xd6\x34\xb8\xad\x57\x4e\xbc\xe7\xde\x6f\xcf\x5f\xfc\x7a\xd5\x2d\x72\xe0\xf3\xc7\xc6\x6c\xed\x7a\x71\xeb\x98\xdd\xcc\x92\x3b\x9f\xde\x34\x6f\x48\x56\x26\x38\x4a\xd7\x97\x2a\x75\xbd\xd8\xa9\xd0\x77\x41\x8e\xbe\x69\x8e\x40\xba\xa6\x4c\x55\x65\xa9\xdf\xaa\x6b\x8a\x88\x19\xf5\xf5\x62\xc0\xc1\x5d\x22\x1b\x1d\xa5\x6b\x4a\x95\x2a\x1b\xfd\x0c\xa9\x6b\x08\xc9\x35\xa8\xe2\xc1\xb2\xd1\x69\x84\x1c\x64\xa5\xb9\xbe\x3b\x20\xaa\x38\x72\x75\x3a\xab\xd5\x09\xaf\x23\x2b\x94\x3a\x25\xfa\xd6\x69\x8f\x86\x8b\x59\x77\x9b\x52\x23\x3f\xae\x91\x21\x28\x3a\xf4\x3e\x0a\x7a\x66\x1b\x6d\x63\xb5\xda\xc6\x16\xc5\x26\x5f\x92\xc3\x47\xf2\x09\x7e\x4d\xdb\x38\x4d\x6d\xe3\x0e\xb5\x8d\x25\x18\xe3\x2d\x25\x03\xc5\xfc\x39\xac\xe0\x3c\xab\xe1\xa4\xb6\x93\xfe\x70\x7e\x41\xeb\x38\x4d\xf1\xe1\x0f\xa3\xab\x5b\x89\xaa\x5f\x96\x0c\xea\x8b\x53\x9e\x49\xce\x96\xcb\xd6\x73\x15\xfa\x12\xa9\x3d\xf4\x6d\x77\xd9\x30\x94\x24\xd0\x04\xaf\x3c\x93\xe4\x3e\xd4\xf0\xa2\x55\xa3\x55\xa8\xf3\x18\x4a\xc5\xd9\x5f\x1d\xd7\xa1\x7f\xaa\xb2\x43\x19\x5e\x90\xb9\x41\x25\x0a\xc6\xec\xf7\xfb\xd6\x77\xdd\x48\x5a\xdf\x32\x97\x62\x3d\x1a\x54\xd2\xa7\xbe\x71\x79\x26\x39\x17\x0e\xcb\x87\x35\x6a\x3c\xef\x02\xfc\x62\xf1\xab\x28\xad\x98\xc8\xd2\x64\xd9\xc5\x6b\x30\xbd\x86\x42\xca\x35\x18\x54\xae\x81\x80\x72\x15\x45\xe5\xea\x76\x2b\x57\xbc\x8c\xd3\xab\x20\x28\x57\x87\x43\xb9\x62\xb1\x98\x5c\x5f\xb4\x5a\x9b\xf2\x2c\x65\xb8\x1e\x09\xdc\x1f\x8f\x73\x77\xe2\x7a\x4f\xa7\x19\x47\x56\xb5\xa8\xf5\x23\xe7\xd6\xd1\xf6\xd7\xa8\x74\x34\x55\xa7\xf3\xa1\x80\xd7\x64\xc9\x6b\x4f\x02\xf7\x57\x80\xdf\x2e\x50\x3c\x54\x2e\x17\xb1\x2e\xed\x96\x6c\x10\x92\xbc\x62\x53\x88\x98\xf2\x42\x54\x7a\xc8\x9d\x89\x47\xce\x75\x6e\xb4\x8a\xc1\xa0\x81\x11\x18\x9b\xd3\xe6\x8c\xd0\x14\x66\x0c\xc2\xff\x54\x44\x5b\xa3\x9d\xd1\x65\xd1\xdd\xd1\xc3\xd1\x93\xd1\x33\x51\x8b\x95\xf5\x9a\xec\xa6\xce\x4c\x80\x23\xd6\x30\x91\xe7\x91\x60\xb3\xb3\x41\xf5\xec\xbc\xdc\x59\x78\x58\x82\xac\xd4\xf6\x0a\x92\x15\x55\xb1\x64\xb9\x87\x2b\x72\xef\x10\xe5\x64\x3c\xb2\xa1\x2c\xff\x74\x3c\x12\x3a\x4b\x4f\xc8\x93\x3f\x87\xa0\xfe\x94\x3c\x08\xca\x9f\x1f\x51\xa2\x64\xbf\xd7\x0e\xcb\x93\x2d\xab\x64\x56\x39\x2f\x4f\xcb\x2f\x59\x80\xc6\x4a\xc5\x02\x0f\x91\x48\x3c\xe6\x0b\x06\x3d\x93\x32\x41\x1f\x63\x35\x59\x5b\x32\xce\x02\x54\xd0\x92\xb1\xb5\xa2\xdd\x78\x59\x31\xf2\x26\xa2\xe4\x1d\x7a\x6f\x4e\x36\x15\x43\xde\x49\x05\xf4\x7c\xc2\x5c\xae\x49\xfa\xd7\xeb\xcb\x1d\x22\xe1\x4a\x26\x56\x2b\x39\x27\xb5\xac\x93\x23\xee\x7d\x60\x35\x33\x06\xf5\xd2\xc4\x93\xbd\xf3\xcf\x2a\x99\x27\x57\xdd\x08\x9c\x2e\xb6\xf1\x44\x36\x16\xf2\x31\x78\x45\x17\x0b\x59\x5a\x58\xde\x27\x16\x52\xf1\x55\x6f\xc9\xfa\xb6\x1f\xcb\xf7\x6d\xc7\x07\xf5\xf1\x6d\x2b\xf8\xc7\x64\xf1\xaf\x87\x37\x75\xf8\x87\x84\x22\xfd\xe1\xa7\x32\xc4\x0c\x55\x86\xf8\x48\x87\x1f\x02\xa1\x7e\xf1\x7f\x93\xc5\xbf\x03\x7e\xaa\xc3\xef\x8f\xa6\xfa\xad\xff\x93\x59\xfc\x3b\xd0\xc7\x3a\xfc\x4c\x38\xd9\x1f\x7e\x63\x30\x8b\xff\x11\x78\x3f\x2f\xf6\x73\x74\x34\xe9\x32\xf7\x91\x27\x94\x6f\x1c\xcc\x7e\xe3\x11\xda\x86\x9c\x3f\x9f\x09\x5f\xea\xcf\xef\x1b\x93\xba\x0b\xbe\xcd\xfb\xce\xbc\xd0\xa5\x31\xa6\x7d\xe3\x0c\x76\x81\x3f\xef\x3b\xa3\x02\xfd\x7c\x47\x9e\x4c\xce\x6f\xcc\x7e\xe7\x51\xa6\x02\x51\x4b\xd8\x83\xd1\x01\x6a\x57\x29\xb8\xe5\xc9\x24\x2f\x69\x16\xf7\xa3\xf0\x8d\xca\x2f\xc1\xd6\x1d\x2e\x56\xf0\x62\x38\x7a\x2e\x20\xad\xf7\xe5\x0a\xaf\x66\x2e\xe8\xec\x61\x93\xc5\xa0\xc1\x9d\xd7\x9f\x34\x07\x26\xad\xf3\x4c\xd5\x56\xf4\xb6\x6e\xbd\xbb\x5c\x0c\x3a\xf8\x7c\xbf\x2a\x8d\xa3\x3d\xab\xc5\xd1\x62\xf8\x87\x75\xf8\xed\x62\xd0\x9c\x8f\x5f\x89\x13\xd8\xa3\xc5\x09\xe0\xb5\xe3\xe7\x3a\xbf\xad\xb1\xa0\x50\x1f\x17\x91\xc5\xff\x4c\x36\x4e\x77\x21\xa5\x7f\xda\x87\x22\xe9\xf7\xb2\xa2\x02\xe5\x0b\xba\x3e\xa4\xe7\xa2\xd1\x35\x6f\xa4\xba\xe6\xad\x55\xeb\xe4\xc1\x75\x6a\xf6\xf8\x90\x90\xf7\x0d\x9a\xd3\x8e\xae\x7f\x73\xd4\xf5\xef\x29\xb5\x4e\x5e\x5c\xa7\x29\x5e\x3f\xca\x6f\x83\x82\xff\x98\x86\x9f\xd9\x99\xb7\x87\x82\xf1\x04\xfb\xc5\xbf\x41\xc5\x6f\x60\x76\x2e\x53\xb0\x47\x09\x45\x7b\x43\x39\xec\x59\xdc\x67\xb3\xb8\xd7\xc1\x1c\x5d\x7f\x5a\xfd\x9e\x7e\x71\xef\xc9\xe2\x5e\x77\xa3\x82\xdb\x47\x23\x59\xbc\xba\x9a\x03\x32\x62\xc1\x78\x23\xff\x04\xe6\xb6\x83\xa5\x80\xdd\xed\xf6\x78\x8d\x06\x83\x57\xcd\x58\x2d\x2a\x26\x3c\x40\xba\x48\x12\xc8\xed\xcc\xf6\xe8\x4e\x5d\x51\x73\xa7\x2f\x3e\xf0\x8b\xb9\xf5\xf4\xbc\x15\x72\xda\x0a\x27\xaa\x47\xad\x5c\x4c\x29\x07\xad\x30\xc8\xae\x9e\x01\x45\x62\xec\x66\x49\x97\xd9\xad\xc6\x44\x82\x09\x84\x3c\x01\x4f\x71\xda\x6e\xf7\x09\xbe\x64\x4b\xc6\xe7\xb3\xe0\x9a\xb5\x64\x8c\x00\x24\x9a\xba\x35\x23\x60\x95\x93\xd8\x1a\xf2\x62\x47\x73\xee\xec\x4b\x52\x02\x28\x99\xc5\xa8\x95\x9e\xfc\xc9\x3b\xe9\xc9\xa5\x3f\x08\xca\xbe\x98\xd8\xce\x92\xf2\x71\xdd\x79\x4f\xcc\x9d\xd9\xa3\xa0\xb8\xe6\xf9\x77\xf8\x47\x7f\x38\x3f\x94\x3b\xf3\x89\x2b\xe8\x79\x52\x3b\x0f\x8a\xc8\xcc\xa8\xf7\x3c\xff\x1b\x7a\x06\xb5\x1b\x0d\x22\xbb\x42\x78\x87\x63\x20\x8a\x99\x53\xa9\x58\xe1\xc0\x00\x7f\x59\xb9\xe0\x18\x58\x3a\xb0\x23\xc3\xdb\x3b\x33\x7c\x80\x0f\x84\x4b\x4a\xdd\x24\xc4\x1f\xab\x12\xac\xfe\x58\x85\x72\x12\x00\xab\x1c\xfe\xd6\x47\x5b\x56\xa2\xbc\x3d\xf4\x87\x4f\x11\x80\xf1\x22\xe7\xa9\xae\x4c\xc4\x7d\xca\x66\x5f\xd1\xcb\x25\x52\x64\x09\xe4\x3c\xd7\xae\x58\xff\xc0\xa2\x79\xd7\xde\xbd\xfd\xf9\xcd\x53\x6e\x5a\x7e\xf1\xa3\x96\xab\x03\x43\xa6\x1b\x3b\xf6\x33\x03\xc1\x2a\x6f\xbb\xfd\xb5\xfd\xf2\x49\xf9\x9f\xf2\x30\xf9\xfc\xf3\xec\xd9\x9b\xe6\xcb\x83\x96\xc9\xe1\xbb\xef\xea\x39\x69\xd8\xc8\x1e\x1d\x54\x7b\x2b\x14\x0c\xde\xb4\xfb\x96\x17\xc2\x9e\xa7\x36\xbe\xf5\x7b\xc3\xb8\x30\xb7\x28\xeb\xf3\xfe\x94\xc4\x2f\xb0\xbf\xa1\x7a\xd4\xaa\xec\x39\x5e\x49\xd4\x24\xa5\x90\xad\x20\x6c\x34\xba\x5c\xc4\x98\x51\x54\xe0\x14\xc5\x84\x3b\xc1\xb6\x66\x12\x82\x3b\xd4\x92\x71\x23\xa7\xf9\xff\x21\xed\x4d\xe0\xab\xa8\xce\xfe\xf1\x39\x73\x66\xe6\xee\x77\xe6\xde\xb9\x73\xf7\x7d\x4f\x6e\xf6\x4b\x12\x90\x25\x97\xb0\x06\x30\x0b\xfb\x04\x30\x41\x40\x16\x45\xc1\x5d\x5c\x10\x45\x2c\x82\x0a\x5a\x41\x44\xeb\x86\x8a\x12\x85\x22\xd6\xa5\xad\x4a\x55\x8a\x7b\x2d\x2e\x55\x6a\xad\xb5\x55\x5b\x57\x7c\xd5\x56\x21\x93\xff\x39\x67\xe6\x6e\x09\xf6\xfd\xbd\x9f\xbf\xb4\x88\x21\xb9\xe7\x3c\x67\x79\xb6\xf3\x3c\xdf\x2f\xb2\x97\xce\x62\xb9\x78\x7e\xc3\x8a\x35\x90\xd9\xc1\xfc\x5c\x09\x75\xa7\x22\x22\x46\xba\xc8\x00\x2c\x25\xd9\xc1\x12\x96\x2e\x90\x50\x37\xeb\x63\xcb\xa9\x4d\xb5\x77\x55\xce\xd6\x41\xb2\x83\x45\xb2\xae\xf7\xf0\x6e\xb1\x0b\x94\x6f\x6f\xd2\x9b\xee\x69\xd9\xef\x47\x1b\x98\xe7\x0c\xff\x8c\xec\x97\x8b\x6a\xcc\xf9\x4c\x2c\xeb\xa0\x78\x07\xef\xf6\xb0\x0e\x9c\x77\x33\x21\x3f\xc4\x64\x32\xd8\xed\x06\x48\x90\x7a\xd4\x5d\x39\x39\xe5\x36\xbe\x09\xb8\x16\xbf\x02\x90\x68\x1d\xde\x7d\xe3\xda\x8d\x37\xaf\xbd\x46\x71\xce\x38\x00\x1c\xc0\xd3\x7f\xa4\xff\x8c\x3d\x7d\xe0\xd2\x0d\x9b\xfb\x8f\x5e\xcf\x4c\xee\x7f\xfa\xe0\x33\xca\x35\x6d\x5e\xe8\xbb\xb9\x0d\xbf\x84\x15\xd6\x30\x48\x0d\xcf\xf9\x29\x8f\x68\xd3\xe9\x82\x9e\x60\x38\x24\xfa\x9d\x04\x4c\x5d\x85\x52\x17\x78\x74\xea\x8b\xeb\x56\x9e\xef\x1b\xc4\x69\x86\x26\xf4\xd3\xa4\x66\x6b\x40\xf7\xd8\x93\xb2\x9a\xd1\x5b\x76\x8e\x45\x87\x63\x10\xaf\xd9\xed\x48\xe7\x2f\x62\xa7\x21\x7f\xae\x31\xe7\xd7\xbb\x05\xe8\x86\xfe\x80\x81\xe3\x2c\x98\x30\x98\x12\x7b\xe4\x36\xf7\x46\x37\xed\xc6\x38\x1d\x0d\x0b\x86\x94\x99\x15\xda\x99\xa2\x29\x48\x72\x1b\x2a\xa7\xb6\x7a\x70\xe3\xf4\xad\xa0\x0b\xac\x51\xb6\x2b\x77\xfe\xf3\x47\xae\xdb\xbf\x7e\xef\xa7\x6f\xff\xf5\xed\xd5\x0f\xd6\x85\xe7\x71\x67\x00\x07\x3b\x4d\xb9\x4d\x79\x4e\xd9\xad\xec\x1c\x07\x5a\x7f\xd7\x0d\xc2\x00\xf9\x6b\x20\x39\xaa\xe2\xcf\x60\x66\xb2\x06\xcf\x0d\xbf\xdb\x5f\xc9\xad\x40\x7a\x6e\x46\x2e\x43\xa5\xd3\x95\xd6\x40\x54\xe7\xd2\x05\x60\x45\x25\x95\x48\xa0\x1d\x4c\x84\x25\x7d\x34\xaa\x97\xa0\x37\x1c\x36\xf5\xc8\x61\xc6\x6b\xeb\x91\xbd\x25\x70\x14\x2e\xdc\x68\x51\x2b\x3c\x8f\xfe\x5b\x78\x7e\xf0\x95\x23\xe8\x2a\x92\x48\xd4\x1a\x6d\xc3\x91\x37\x09\xc4\x39\x26\xa6\xca\xd4\xe0\x22\x1c\x6d\x12\xd7\x18\xb4\x8f\xaf\xb8\x76\x90\x04\xdd\xca\x5f\x2f\x53\xf6\x2a\x1b\xc0\x72\xb0\x70\xcf\xd3\xf4\x0d\xd7\x5d\xd9\xc1\xce\x3d\xcf\xe5\x7d\x5a\xd9\xf8\xbb\x6e\xe5\x03\xe5\x0f\xca\x27\xca\x7b\x48\x18\xa5\x2f\x56\x0f\xce\x00\xa3\xc1\x5c\xb0\x24\x79\x6b\x5f\x50\xeb\x97\x9f\x38\xf0\x05\x73\x80\x79\x0f\xc9\xd6\x86\x7c\x4f\x7f\x54\xe7\xd4\xf9\x61\x45\xba\x32\xc1\xb4\xcb\x09\x2c\x97\xa4\xf7\x84\xc3\x66\x14\x66\x53\x61\x41\x75\x49\xb5\x70\xbb\xb6\x84\x6b\x8a\xc0\x4b\x68\xc9\xa6\x82\x44\x83\x48\xe5\xa4\x52\xc2\x39\x55\x22\xe6\xdc\xa0\x38\xb1\x72\x73\x29\xc5\x5c\x9e\x78\x6e\xc6\x52\xd3\x96\xcb\xae\xec\x80\x87\x37\x61\x51\x0e\x15\xe8\xe6\x4e\xd5\x28\xe8\xac\x37\xdc\x12\xfc\xf6\x24\xb5\x4e\xd4\xc0\x09\x2e\x8b\xee\x9b\x91\x0a\x51\xe3\x72\x31\xd6\x4e\x99\x4c\x76\x0f\x8c\x84\x3d\x1e\xc1\xcf\x38\xfc\x8e\x5e\xd9\x0f\x75\x76\xc1\xde\x23\xf3\x6c\xaf\xcc\x0b\x84\x69\x76\x50\xff\x66\x61\x87\x90\x2c\xa4\x29\x8e\x34\xc4\x25\x0a\xed\x72\x45\x8d\x48\x31\x9f\xbc\xf9\xd5\x14\xd2\x10\x07\xa6\xa9\xbd\x72\x1f\xf7\xb5\x17\xb4\xe0\x54\xdc\x42\x87\xfc\xe5\x28\xe0\x8f\xdf\xab\x5f\xf5\xd5\xfb\x5a\xbf\x1c\x73\xa6\xaa\xfd\x94\x27\xf1\x9c\x51\x04\xcd\x8a\x5a\x5f\xcf\xc4\x5c\x42\xe7\x70\xa0\x19\x43\x8b\x1d\x06\x03\x36\x83\xd5\xd0\x2b\x73\x4e\xf4\x7f\x0b\x67\x01\x56\x68\xf7\x03\x7f\x8f\x0c\x0a\xc1\x4a\x51\x95\x97\xf5\xd2\x57\x80\xb0\x6d\x58\x3c\x92\x55\x23\x14\x91\x30\x6d\x26\x6c\x5a\x51\x37\x6b\xef\x5f\xd5\x7f\x04\x1d\x72\xc7\x43\x8f\xbf\xb5\xb8\xb9\xdb\xc4\x2c\xe8\xdb\xa3\x78\xd7\xae\xbd\xf1\x9a\xb5\xe0\xd2\x67\x0e\x82\x3f\x39\x5e\x01\x53\xda\x7c\xc7\xaf\xf3\x86\xe8\xc4\xe6\x0d\x1b\xae\xa7\x4a\xea\xc8\x30\x9e\x61\x02\xcd\x33\x19\x16\xac\x34\xed\xf1\x19\x0c\x4e\x0f\x4c\x25\x5d\xf6\x0e\xd9\x05\xcd\xc8\x9c\x9a\x05\x2e\x88\xcc\xb8\x13\x78\xda\x65\x50\xd2\xb7\x93\x67\xc2\xc8\xcf\x32\x4b\xe6\x99\x1a\x54\x0e\xa6\x45\x54\xae\x92\x42\x30\x66\xbe\xb2\x4d\x2a\x21\xee\x7b\xb6\xfd\x9c\xcc\x54\xe8\x58\xda\xef\x1f\x4a\xdd\x57\xf9\xa1\x78\x3f\x08\x1f\x0f\xb8\xc1\x8e\x32\xee\xbe\x51\xca\x78\xf8\x2a\x7c\x81\xd4\xc0\xb5\xe6\xa2\x51\x29\x90\x00\x7c\xda\xe7\xe3\x13\x9c\xc4\x56\x66\x74\x09\x5d\x82\x71\xbb\x43\xed\xb2\x5b\x60\xcc\xed\x32\xe3\x1b\xcc\xa7\x56\x7e\x69\x59\x29\x9f\x48\x2d\x23\x20\x88\x63\x5d\x28\xb0\xa4\x01\xc4\x11\xc2\xad\x45\x02\x9c\xfd\xda\x13\x57\x5d\xd1\x1a\x73\x76\x54\xe6\x26\x75\xdf\xf1\xb3\x2d\x80\xfe\xe0\xf9\xcf\x95\xc3\x07\x95\x47\xdb\xe7\x1f\x96\x1a\x5b\xf7\xdb\xcf\x5f\x1f\xfa\xe4\x52\x9b\xef\x94\xba\x61\x8b\x96\xca\xfd\xbf\x78\xeb\xd8\xa7\x87\x95\x3f\x5d\xbf\x1e\x6e\xb9\x6d\xc7\xc7\x3b\x84\x9a\x97\x2e\x07\xa7\x92\xbb\x8a\xa2\x7b\x36\x4b\x62\xde\xe5\xb9\x11\xbc\x4e\x67\x35\x18\x4c\x26\xaf\x28\xd1\x92\x17\x06\xfc\x1e\x9b\xe8\x44\x66\xde\x4c\x4e\x8c\xa9\xda\x0a\x20\x65\x45\x3b\x64\xe0\xac\xe8\x06\x3a\xa1\x97\x03\x5c\xaf\x4c\x03\x7b\x1e\x31\x05\xbb\x01\xb5\x04\xfc\xa3\x10\xeb\xe6\xcf\x90\xd6\x69\xa8\x1e\x24\xac\x50\xd1\x41\x8a\xe8\x62\xb6\xac\xab\x10\xf2\xe2\x03\xc5\x66\x8f\xb7\x89\xf3\x46\x74\x02\xba\x5f\xb9\x1b\xe7\x05\x41\xcf\x1f\xfe\x74\x56\x78\x1e\x73\x61\x5f\x1f\xb8\xf0\x3f\x02\xcd\xde\x0a\x6e\xff\x39\xf8\xdc\xfa\x2e\x98\xd5\xe6\x3d\x7e\x9d\x0f\xef\x03\xd2\xf3\x0f\x23\x3d\xef\x40\x52\x9c\x9a\xab\xf0\x08\x90\xb1\xbb\xdd\x46\x23\x23\x20\x7d\xcf\x07\x80\x09\xda\x3c\xbd\xb2\x8d\xb1\x31\x18\xf9\xbe\x47\xb6\x88\x3a\xaa\x47\xd6\x0d\x06\xb3\xd2\xa0\x17\xcb\xf4\x68\x54\xbd\x94\xaa\xd2\x44\xbf\x37\x47\xe8\x24\x6c\xb0\x8b\x11\x2f\xa0\xdf\x3e\xb2\xc5\xdf\xcd\xfd\xf8\x4f\x70\x3a\x58\x82\xdb\x0f\x95\x87\x95\xdb\x68\x26\x6a\xf8\xed\x7d\x4f\xee\x65\xfa\x53\xec\x3e\xe6\x93\xd3\x7e\x07\x5a\xc7\xa1\xfb\xf9\x30\x6e\x3c\x04\xa7\x81\xd9\x6d\x40\xfc\xec\xf8\x72\xc0\x82\xa4\xf2\xb6\x32\x80\xf9\x65\x07\x3e\x87\x5f\x10\xfc\xcb\x8e\x5c\xa5\x87\xb2\xb1\x26\x63\x28\x1c\x36\x3a\x69\x96\xe2\x92\x29\xda\x29\x49\xe8\x9e\x4a\x92\x2e\x14\x8b\xf9\x7a\xe4\x98\xa8\xe3\x91\x81\xc7\x53\x2f\x78\xb3\xf6\x3c\x39\xea\xa0\xe3\x24\x0a\x09\x74\x7c\x70\x0b\xa5\xa6\x34\xd1\x35\x0d\x01\x49\xc7\x49\xe8\x6b\xaa\x35\x88\x85\xe3\x53\xc0\xfc\x4d\x77\x82\xcf\x9e\xe8\x9b\x93\x89\x9c\xd3\xf4\xfa\x59\xf2\xf9\x17\x1f\x03\xa6\xaa\x4b\x53\xc3\xe6\x9b\xef\x7f\x45\xe9\x57\xfe\x02\x56\x82\x54\xa5\xd4\x77\x35\x98\x92\x51\x5e\xff\x9d\x2b\xf0\xf5\x45\x17\x73\xfa\x4b\x74\xfc\xff\x28\xef\xf9\x9c\xef\x28\xbf\x4e\xbf\x82\x39\x69\xe7\x2a\x13\x99\x5d\x04\x37\x72\x7a\xae\xda\x8f\x9c\x5e\x97\x24\x85\x05\x18\x8b\x1b\xf4\xfa\x98\x9f\xea\x95\xf5\xc8\x19\xf0\xeb\x21\x23\x8a\xbe\x5e\x19\x73\xf6\x8b\x90\x41\xfe\x64\xe1\x52\x14\x4d\x5a\x46\xf3\xcf\x4b\xde\x19\x6c\x83\x60\xfa\x6c\x6a\xaf\x3b\x76\xac\xb4\x5c\x33\x5d\xfd\xf5\x5f\xa6\x6e\xcd\xc8\x58\xf9\x4f\x98\xd7\xc7\x9c\x76\x5a\xb8\xfe\x6f\x63\xef\x03\x93\xf0\x19\xa2\x47\xf5\xbf\xf6\xee\x67\x36\x0b\xa8\x7b\xd4\xe5\xed\x3d\x8d\x3d\xcb\xdb\xa6\x6c\xff\x42\xa7\xeb\x3f\xfa\x90\x32\xaa\x8f\xdc\x83\x9f\x2b\x1f\xc1\x6d\xec\x74\xe4\x51\xf5\xe6\x1a\x24\x93\xe8\xb4\xbb\x5c\x76\x06\xb0\x68\x1f\xcc\x26\xca\xe4\xf6\x38\x91\xc9\x91\x3a\x64\x91\x61\xed\x0e\x07\xf2\xbc\xf4\x7c\xa7\xdc\x64\x9a\x68\x9a\x6d\x82\x26\x3d\xa3\x81\xdf\xd4\xe2\xf3\x3f\x62\x44\x36\x5b\x4a\x82\x4c\x7a\xc0\x46\x34\x90\xc7\x71\xdc\x25\xed\x03\xb1\x16\x5a\x35\x56\xc4\x3e\x23\xc5\x9f\xd5\xc5\xe0\x81\x8d\x0f\x5a\xf6\x44\xa4\xe7\xae\xbf\xa0\x23\xe7\xf7\x25\xab\x1b\x6d\xe1\xaf\xf8\xaf\x36\xa2\x79\xfd\x71\x42\xf4\xf3\x1d\xbf\x14\xff\xba\xda\x71\xf6\x25\x7f\x5d\x76\xa2\xe0\x3f\x1c\x44\xfe\x43\x0d\xb5\x38\x97\xa5\x6a\x6a\xea\xf8\x68\x5a\xe7\xf0\xf9\x74\x51\x58\x5b\x47\x65\x32\xc8\x83\xc8\x24\xbc\x92\x0b\x1d\xf7\xb4\x3e\xe1\xd2\xbb\xf4\xc1\x44\xc2\xdc\x23\x27\x98\x20\x32\x53\xc1\xc1\xb0\x56\x68\x6e\x2a\xe4\xd1\x49\xdc\x89\xa1\xe6\x57\xf5\x28\xb4\x66\x4e\x1b\xa7\x42\x5b\x61\xaf\xc2\xe9\x52\xc3\x29\xee\x42\xe2\x56\x74\xbb\x3b\x9e\x5e\xf2\xcf\xb7\x3e\x7c\xeb\xfc\xe5\x7d\xf4\x8a\xab\x2f\x53\x9e\xb8\xfa\xa8\xf2\xe4\x2f\x51\xb8\xb2\xa4\xfb\xd1\x75\x5b\x37\x16\xdc\x8a\x6b\x1e\x69\x1a\xa5\xfc\x05\xf9\x15\xff\x50\xde\x8f\x81\xf5\xb8\xf0\x4a\x99\x56\x51\x7f\x17\x68\x78\x03\xb9\x59\x67\x89\xa1\x7b\x1f\x26\xce\x05\x4d\xb9\x94\x89\xec\x3e\x62\xd7\xdc\xd4\xa4\x5c\xdc\x21\x98\xed\x56\x49\xb2\x0b\x90\xe2\x8c\x46\x2f\xe5\x71\xb1\x3c\xe0\x91\x13\xcc\xfb\x38\x06\x30\x25\xa8\xa3\xd9\x42\xf6\x5e\xad\x5b\x28\x39\x5e\x62\x09\x55\x39\xb0\xbb\xd8\x54\x93\x68\x00\xcd\xc9\x14\xe7\xa2\x27\x6d\x02\xf3\xc1\xe5\xd7\x82\x4d\x6b\x95\xb1\xbf\xf2\x2b\xcc\x9c\xf8\x79\xfd\xfd\x34\xbd\xca\x10\x6f\x62\xbe\x6d\x6b\xf3\x9d\x78\x10\xce\xc1\x6f\xd0\x27\xa0\x32\xfc\xa0\x25\xb2\x11\xd8\x98\x3f\xfd\xf0\x36\x3b\x76\xe9\x1a\x5c\x7b\x81\xf4\xd2\xff\x20\xff\xb8\x82\x92\x73\xb5\x7e\x18\x4d\x39\x8c\x46\x9e\x87\x29\x98\xa9\x74\x3a\x2d\x89\x44\x0c\xb9\x43\xbc\xce\x23\xd8\x85\x76\x14\x63\xa8\x8f\xd3\x16\x89\x42\x06\x83\x72\x96\x91\x00\x63\xd7\xa8\x24\x48\x2c\x33\x1a\x2a\x02\x79\xd9\x93\x9b\x2d\x5f\xf8\xe5\x28\x54\x9c\xa0\x0b\xc4\x9c\xfb\xd6\xe1\x12\x86\x48\xb5\xec\xab\x79\xdc\x88\xb1\x67\x83\x8b\x9e\x75\xdc\xb6\x03\xac\x28\x23\x89\x54\xb4\xea\x2f\xe5\xd2\x2b\xce\x5d\xbb\x9a\x4e\xb9\x5b\xfb\xcf\xdb\x7e\x3b\xb9\x2b\x35\x03\x9f\xd3\x0b\x91\x5c\x02\x15\xcc\xf1\xd0\x8e\x0e\x40\xbb\xcc\x51\x94\x09\xcd\x5b\x2c\x21\xa7\xd2\x26\x57\x00\x34\xc2\xd4\x34\xd7\x5d\x8e\x99\x89\x6b\x2b\x2b\xea\xc2\xeb\x1d\x17\xae\x63\x3a\xdd\xad\xc7\x67\x8d\x6f\xb2\x4c\x77\x85\x55\xdf\x91\xd4\x39\x91\xfd\x1d\x91\x0b\x20\x83\x27\x98\x2c\xc8\xfb\xa5\xf4\x06\x3d\xd2\xe0\x06\x03\x63\x29\xb0\xdf\x17\xbd\x95\x62\x62\x55\x1d\x16\x14\xab\xdc\xb4\x23\x9a\x95\xe8\x2a\xd2\x61\x4c\xca\xff\xfa\xe8\x1b\xfa\xdf\x26\xc5\x7d\x95\x6b\xc0\x1b\xa4\x84\xa0\x76\x8d\x5a\xdb\xc0\x55\xb0\x5d\x54\x18\xf9\xe4\x55\x2e\x86\x31\x04\x69\x10\x72\xfb\xfd\x21\xda\xc0\x44\xa2\x6e\xf2\x94\x46\xbb\x6c\x36\x17\x0d\x75\x5e\x0b\xfa\x7b\x9d\xa1\x07\x23\xff\xdb\xa9\x96\x12\x46\x7c\xa2\xc1\xa8\xec\x90\x2b\x54\x01\x40\x7e\x8f\xc8\x25\xd1\x30\x87\x0b\x4c\xf9\x2e\xae\x42\x99\xa2\x98\xce\x3f\xd8\x3f\xb7\xef\xf5\x43\xdd\x0b\xba\x70\x06\x82\x5e\x74\x29\x78\x79\x97\x32\x81\x6e\xbf\x9c\xde\xb0\x58\x69\xc5\x93\x85\xbd\x87\x5f\x70\x2b\xfd\xb7\xb8\x07\x94\x37\xe9\x28\xe6\xcc\x57\x2e\xe9\xb7\xf9\xd4\xf5\x3b\x85\xf0\x4e\xde\x83\xf4\x70\x4f\x6e\x98\x9b\x65\x8d\x21\x48\x87\x3d\x81\x40\x18\x1a\x99\x58\x3c\x04\xa7\xcb\xee\x90\xde\x17\xf4\xf8\x90\x23\xe5\xe3\xad\x52\xa7\x6c\xb7\x02\x3a\xcc\x42\xa3\xde\x88\xf6\x4f\x2f\x95\xd0\x68\x14\x43\x22\x5c\xf3\x33\x58\x9e\xd2\xaa\x9e\xb2\x24\x4a\xb1\xf0\x87\xee\xd3\xaa\x7b\x0a\x19\x95\x62\xe5\x4f\xb1\xc0\x07\xfe\x5a\xcb\xb0\xf4\xdf\x50\x52\x00\x84\x64\x71\xa1\xb3\x30\x9c\xd4\x70\xa0\xe8\x92\x13\xed\xf8\x14\xa0\x38\x1c\x9f\x02\x0b\x3a\x6c\x16\x4a\xe3\xcb\x94\x4a\x8a\xd5\xca\xa0\x29\x86\x1c\x05\x74\x10\x54\x36\xc4\x8b\x2e\x42\xc7\x70\x23\xbd\xbd\xff\x39\xf2\xda\x3c\x7a\x19\x3d\x0c\x1d\xf0\x73\x97\x91\x35\xb4\x53\x14\xfc\x12\xad\x61\x04\x69\x98\x4a\x10\x09\xf8\x82\x06\x96\xe3\xec\x46\xb3\xc1\x47\x47\xf4\xb1\xa8\xcf\x1c\x34\x18\x69\x8e\xf3\x53\x6e\xfb\x0c\xd9\x6d\xed\x92\xdd\x00\x70\x78\xe5\x54\x88\x0c\xbb\x6b\xb0\x2d\x8e\xc4\x20\xf2\x9d\x22\x8d\x20\x05\x1a\x81\xd6\xe3\x3b\x06\x12\x92\x5c\xa4\x72\x9c\x2e\xf8\xe5\x8b\xef\xd9\x72\xcf\x29\x47\xc1\xab\x36\xe5\x3e\x30\x6c\x62\x6f\x2c\x90\x19\xe5\x4c\x24\x2a\xfc\xbd\x97\x64\x9f\xdb\x01\xa6\xbb\x3a\xe9\x9b\x6a\xee\x53\xc6\x36\xc0\x07\x1a\x95\x7d\x5b\x40\xe6\x21\x57\xef\x9f\x59\x83\x9e\x99\xbb\xea\xb7\x5b\x6e\x39\x51\x39\x51\x52\xf7\xdf\x33\xf0\x99\xce\x8f\xee\x4f\x1d\x35\x3f\x57\x9f\xa4\xa8\xea\x30\x27\x9a\xcd\x3e\x17\x57\xcd\x36\xd4\xd7\x55\xf7\xc8\x75\xf6\xaa\x54\xc8\x8b\x93\x63\xe8\x5a\x71\x9c\xa1\xc2\xcf\xc3\x98\x64\x90\x16\xca\xd0\x50\xe2\xc7\x11\x7f\xad\x9c\x82\xb0\x54\x20\x95\xe9\x3b\xa5\x25\xff\xd5\x4b\x86\xf1\x29\x8b\xff\xa1\xd2\x9b\x91\xff\xc0\xd8\x33\xec\xc2\xa9\xf7\x8d\x68\x5d\xe5\x9f\xf6\xfc\xd8\xfb\xf6\xf6\xd1\x53\x17\xaf\x1e\x79\x91\x6d\x09\x0d\x17\x8d\x3e\x25\x70\x5a\x78\x09\x1d\x5d\x07\xd6\x29\x33\x3a\xab\x46\x0c\x1b\x51\x35\x76\xcb\x35\xf0\x3d\x7c\xae\x4f\x4c\xed\x8b\x35\x8d\x85\xbf\x57\xff\x3c\x43\xb6\x99\x99\xf1\xf8\xcf\x28\x88\x98\x82\x7c\x8e\x45\xc8\x16\xf4\x21\x59\x03\x54\x7b\x2e\xe5\x62\x44\x37\x0d\x44\x10\x0c\x99\x4d\xa6\xa0\x87\x72\x38\x91\x15\x70\x43\xda\xe7\x84\x26\x13\xae\xa2\xed\x95\x75\x3e\x5a\xbd\xaa\xe4\x94\x14\x4b\xd9\xf2\xf9\xc0\x22\xcc\x9e\x2d\x76\x52\x97\x03\x10\x79\x58\xea\x82\x13\x2f\xec\xb8\xbb\x76\x71\x58\x0e\x0a\xa3\x63\xe3\x26\xf6\x81\x97\xe9\xad\x07\xc0\xfb\xcc\x7b\xc7\x93\x4c\xd3\xf1\x96\xed\xb7\xa2\x3b\x55\x83\x5c\x8d\x45\xb3\xd9\xd5\xde\xb6\x13\x0f\xd0\xdf\xa3\x59\x17\xea\x3a\x34\xde\xc4\x4e\x14\xf7\xdb\xed\x2e\x13\xe7\xe2\x34\x2f\x55\x23\x4f\xd4\xa8\x13\x71\x4d\x4a\xbb\x6c\xf0\x61\x02\x45\x28\x94\x93\xc2\x17\xea\x32\x6c\xf6\xff\xff\x44\x87\xc7\xbf\x27\xb7\xf0\xa3\x72\xa2\xc3\x7c\x4d\x03\x3b\xcd\xce\x31\x3b\x88\xed\xc5\x3e\x47\x37\xfb\x32\xc1\x35\x9f\x9a\xab\xf4\x53\x26\xce\x66\x8b\x3a\x9d\x0e\x86\x62\xd2\x15\x7c\x45\xa8\x82\x36\x41\x06\x2d\x3b\xe3\xa1\x3d\xa1\x1e\xd9\x23\xd2\x89\x1e\xd9\x4a\x23\xef\xe8\xf9\x82\xb7\x51\xe2\x65\x17\x4a\xbe\x84\x48\x58\x24\xf1\x4e\xb1\x85\x54\x87\x62\x1e\xec\x71\x93\xaa\x01\x35\xf3\x42\x2f\xa6\x9f\x04\x7d\x0f\x4c\x09\x24\xc7\x4f\x1b\x35\x69\x6e\x4f\xef\x29\x79\xaf\x1b\x4c\xdb\xfb\xf4\x6f\xf7\xee\xfd\xed\xd3\x7b\xe9\xbb\xe8\x3e\xe5\xdb\xea\x26\xbb\x5f\x8a\x8f\x1b\x3e\x71\x51\xfb\xbc\xdb\x87\x5f\x77\x30\xef\x7d\x2b\x07\x95\xaf\x80\x1d\x85\x50\xa3\x81\x51\xf9\x9e\xd2\xfa\xa5\x99\x5e\x66\x27\x8a\x92\xd3\x54\x2e\x17\x8b\x99\x02\xac\xcb\x8e\x59\x59\x05\x13\x5b\x51\x29\xc0\x76\x59\xd0\x5b\xad\xe1\x0e\xd9\x6b\x15\xf4\xc9\x0e\x59\xaf\x59\xe6\xe7\x55\x61\xb4\x6b\x91\x2d\x40\xb2\xe9\x8a\x20\x5e\xd9\xb0\xab\x54\xa8\xd2\x06\x68\xa6\x77\xf1\x19\x7e\x95\x9b\x11\x18\x96\xb6\x6b\x12\x29\xd5\x79\x92\x46\xf8\xaf\xd3\xee\x1c\x3e\x6f\xad\xca\xd4\xf8\x44\xcd\xf0\xbc\x38\xfd\xf7\x16\x49\x1b\x69\x6a\x8a\x32\x41\x5f\x8b\x62\x07\x3b\x8a\x40\x51\xec\xcc\xf9\xa1\xcd\x69\xb2\xf9\x4d\x30\x1c\x22\x79\x08\x68\x15\xd1\xf2\x33\x7a\x0f\x72\x83\x44\x1b\x04\x10\x05\xf9\xbe\xb2\x12\xa7\x41\xd1\x33\x01\x98\x44\xca\xd2\x96\x4f\x13\xb1\x38\x68\xce\x27\x90\x50\xe0\xac\xaf\x45\x46\xf4\x98\xf2\xa7\x7e\xe5\x17\xca\x1a\xb0\x10\xcc\x02\x3b\xe8\x7f\xf5\x1d\xe7\xde\x3e\xfc\xc2\xc1\x71\x3b\x62\xdb\x94\x09\x53\xbc\x5c\xf2\xf8\x45\xdd\x60\x11\xc8\x81\x5e\xb0\x80\xff\xe1\x2c\x2f\x37\x57\x39\x4a\x5c\xbb\x77\xd3\x5e\x66\xb4\x5b\x8d\x9d\xdb\x95\x69\xec\x3f\x08\xdf\x64\x0c\xcf\x9d\xf5\xd2\x8e\x88\xc9\xe1\x35\xc1\x44\xdc\xce\x74\xc8\x76\xde\x1a\xec\x90\xd1\x92\xbb\xf0\x92\x3b\x68\x8a\x46\xc6\xe9\x7f\x9b\x3b\x99\x7a\x11\x15\xcf\xe5\xcc\x92\xb7\x53\x7c\x79\xf3\x60\xc3\xf0\xe8\xba\x87\xde\xfe\x1b\xee\x38\xaf\xbd\xfc\xf2\x46\x3a\xb0\xec\x84\x34\x7d\x6c\x48\xf6\x4d\x19\x3d\x46\x99\x86\x1c\x9f\x5f\x28\xdb\x7f\xf8\xfe\x9b\xfe\x1f\x8e\x99\x2d\x3f\xfe\xe8\x6e\xa5\xe1\xbe\x3f\x83\xe5\x26\xdb\xae\x0f\x3f\x7a\x50\x9d\x37\xfa\x87\xed\x22\xb9\xd7\x10\xce\xab\xb0\x16\x8b\x9d\x32\x18\x48\x36\x48\xcd\x04\xe1\x9a\x1a\xd6\xc3\x7a\x04\x3f\xb4\x90\x94\x90\xf0\xbf\xe5\x55\x0a\xc9\xd8\x84\x10\xc9\x77\x2c\x94\xa4\x83\x18\x86\xbf\x68\x5b\xc7\x8c\x4d\x57\x80\x56\xc5\x79\xe0\x83\xfe\x89\x77\x26\xf2\xb9\x20\xf0\x2d\x46\x4b\x81\xfb\x08\x24\xca\x43\xca\x7c\x65\x36\xf6\x0f\xf2\x89\xa0\x67\xf0\x7c\x7d\x98\xd7\x13\xd9\xb2\x10\x3a\xdf\x48\xe3\x24\x6c\x3a\x87\xc3\x03\xa8\xb0\xd9\x4c\x79\x60\x45\x65\x80\xe9\x94\xd1\x67\x38\x54\xb6\x73\x1f\x9f\xea\x94\x79\xa7\x21\xda\x29\x1b\x84\xd2\x6c\x37\x9e\xfd\xf3\xe5\x36\x40\xed\x31\x50\xc9\xea\x4f\x42\xd7\x49\x36\x40\xcc\x13\x76\xd2\xf7\x10\xeb\xbf\xfc\xa6\x12\xd6\x4e\xcc\x6a\x2f\xab\xac\x9d\xcc\x5e\x64\xfd\x1f\x1d\x57\xc6\xdc\xc9\x9e\x83\xbc\x82\x13\x5d\x05\xea\x4e\x9c\xf7\x1e\x08\xb1\xbb\xc8\xda\x47\x90\x47\x5d\x67\x08\x85\x28\xbf\x31\xe8\x66\xcd\x66\x9b\x2d\xe8\x87\xb1\xa8\xcb\xee\x40\x0b\xce\x9a\xf0\x6b\xbc\xfa\x54\xc1\x3b\x20\xe6\xf1\xec\x91\x0d\x3c\xda\x86\x43\x65\xfb\x50\xb6\x11\xd9\x42\x76\xa2\xf8\x5c\x01\x4a\x40\x7a\xf3\xa0\x35\x2c\x92\x0f\x2e\xbb\xec\xbe\x51\x63\x6f\xbb\xea\x3a\xe5\x9c\xd9\x7d\xfd\x97\xdc\xd9\x47\xff\xbc\xaf\x0d\xa4\x41\x5c\xf9\x06\xac\xdb\x0a\x4d\xdb\x2e\xe8\x7f\xe7\xca\x13\xfb\xe9\x5e\xe5\x1f\x64\x3f\x2e\x44\xda\xdf\x37\xeb\x57\x07\x95\xbf\x4e\xef\xff\x14\x3f\xcf\x23\x3b\x30\x07\xe9\x1d\x0e\xdd\xdd\x34\xd5\x9c\x0b\x46\x58\xb3\xc7\xc3\x8a\x69\xa6\xa2\xd2\x2c\xa6\x22\x0c\x74\x3a\x51\x98\xef\x64\x60\xac\x47\x86\x65\x29\xdf\x92\x2c\x22\x36\xc1\x61\xcc\xcd\x41\xb0\x53\x55\xa7\xc2\xa6\x41\xc2\xd2\x04\x3d\x50\x0d\xf3\x19\xae\xfb\xab\x73\x14\x83\xbc\xfb\x5f\x17\xac\x5c\x77\xc5\xcf\xce\xa8\x96\x7f\xff\xf0\xa7\xc7\xc6\x2c\xdb\xf1\xd0\x05\x2b\x41\x68\xfe\xee\x4c\xf5\xdc\x6c\x24\x09\xf6\x9c\x73\xcf\x39\xa7\x26\x7b\x5a\xe7\x9d\x36\xe5\x09\xd0\x92\x79\xf2\x97\x8b\x37\xf6\x4e\x1a\x91\x5e\x32\xf5\xf3\xd6\xfa\x77\x54\xdb\xd5\x80\xfc\xfe\x0f\x08\x3f\x27\x9a\xb3\x97\xe2\x1c\x0e\xca\x1a\x45\x73\xb6\x46\x38\x2f\x93\xb4\x25\x03\xed\x72\xd2\x69\x33\xb4\xcb\x36\xe1\x27\xe6\x2c\x0e\x6b\xca\xcf\x96\x2b\x22\xd8\x72\x79\xac\x43\x3c\x5d\x1b\xf1\x29\x1a\x2e\xdd\x7a\xdd\xf4\x09\x93\x6b\x97\x05\xc3\xad\x8f\x2c\xdd\xfe\xdb\x4b\xb6\xfe\x6c\xe6\xac\x39\xa3\xcf\x8d\x24\x5b\x87\xef\x9b\xf2\xc4\x41\x50\x79\xce\x4d\xd5\x95\xe3\x86\x65\x47\x26\x02\x67\x1f\x0b\xdc\x7a\xe5\x79\x3b\xab\x2b\x5b\x87\x9f\x32\xb5\x2e\xba\x7e\x80\x72\x84\xee\xc6\xf6\x6b\x1c\xf2\x85\x8f\x92\x37\x9f\x59\xe4\xfc\xd4\x28\xd3\xe0\xd5\xec\x0e\xf2\x6e\x37\x3a\x17\x0e\xc0\x98\xcb\x68\x33\x42\x98\x4c\x85\xa9\x4e\x39\x1c\xe6\x04\x87\xc3\xd2\x29\x3b\x7c\x9c\xb7\x53\xe6\x40\xe1\x02\x08\xcf\xe3\x47\x94\xa2\xaa\x2f\xe2\x98\xda\xd5\x18\x0b\x57\x45\x10\xb5\x63\xe3\x60\x09\x68\x31\x00\x73\x2e\xbb\x74\xee\xa3\x4f\xb7\x34\x79\xdc\x99\xdc\x0c\xf9\xa9\x57\x92\x95\xa9\x91\x23\x53\xa9\x91\xa3\xe0\xb1\x4b\xbb\xbb\x2f\x51\x5e\x50\xfe\x70\x62\xd3\x9a\x6b\xc4\x73\x3f\xb4\xbf\xf1\x1b\x26\x2d\x80\xe1\x23\xd3\xf8\x3b\xd2\x23\x49\x0d\x87\x32\x8d\xd4\x70\xc4\xa8\x09\xb9\xb8\x29\xcc\x40\x9f\x20\xc0\x30\xd6\x90\x5e\x97\xb7\x43\x96\x72\x0e\x17\x6f\x09\x76\xc9\x16\x27\xa5\xeb\x94\x21\xd6\x8f\xaf\x16\x00\x8d\x0a\x74\xa1\xe5\x60\xa8\x6a\x95\xe6\x68\xa0\x8b\x9d\x8c\x3c\xd4\xc1\x81\xf5\x6a\xa1\x66\xe3\x48\x97\xab\x94\x46\x74\xab\x32\x0d\x17\x69\xae\xbf\xb4\x91\x2e\xa7\x13\xdd\x7c\xf8\x4f\x84\x5f\x53\xab\x9d\x71\x52\x4d\x39\x3f\x4d\x71\x26\xbb\x49\x4f\x31\x6e\x17\x4b\x5b\x24\x4b\xaf\x2c\x0d\x2d\xb1\x2d\x7b\x29\x54\x75\x49\x06\x0c\x51\x7f\x6c\x33\xa9\x76\x79\xab\xdf\xfb\xd6\x93\x79\xb5\xc7\xd8\xe0\xa1\x1f\xec\xc7\x6f\x26\x97\x6b\x65\x2d\x51\x76\xf9\x9a\x97\xd7\x49\xec\x33\x3e\x87\xae\x03\x4e\x08\x38\x79\x67\x3c\x16\x84\x9d\x72\x10\x18\xdc\x5e\x37\x8a\x1e\x78\x91\xf3\xf2\xa2\xa5\x4b\x16\xf3\x8f\x0e\x64\x73\xcb\xbb\x8a\xb5\x9c\x07\x51\x6e\xa5\xd4\xaa\xda\xa2\x35\x6b\xb4\x31\x12\xbd\x3e\x8e\xd4\x5a\x69\xc9\xcb\xa5\xcf\x3f\xde\xb8\xc2\xc3\x6c\xd9\xec\x1e\xd8\x58\xe0\x5b\x25\x2b\x16\xc1\x0a\xcd\xf4\x2d\xae\x33\x42\x7e\x6b\x33\xf1\x5b\x27\xe6\xe2\x68\xad\x24\x8f\xcf\x27\x59\x29\x26\x14\x44\xcb\xe5\xf1\x7b\x16\x22\x33\x6d\x41\xbf\xec\x7e\x68\x37\xf4\xca\x76\x5f\xbe\x06\xbd\x48\xdc\x33\x68\x63\xd5\xb5\x2b\xbf\x42\x8d\xf9\xb4\xaa\xb6\x84\xf3\x26\x54\x4e\x14\x83\x72\xfa\xc6\xce\xf7\xbf\xd1\x0a\x89\xf0\x32\xfe\x78\xc7\x69\xbd\x5e\xd7\xa3\xca\x1f\xcc\xf6\x7f\xbd\xc7\xbc\x88\x4b\x89\x48\xdf\xc8\xc0\x17\xdc\x34\xe4\xeb\x55\x50\x53\x72\x29\x9b\xd1\xef\x62\x42\x14\x15\x67\x8c\x4c\x65\xc6\x8f\xfc\x08\xbf\x5f\x67\x71\xab\xb1\x79\xca\x6b\x81\x3a\xc7\x42\x59\xa7\x29\xaa\xec\xf3\xda\xd6\x6a\xa0\x95\xa5\xef\xa3\xe8\xaa\xdb\x1c\xc8\xb9\x88\x97\x85\x09\x6a\x8e\x40\xc5\xcc\xd2\x9c\x25\x6e\xda\xbe\xbb\x94\x6f\x7f\x50\xfe\x47\xf9\xf0\x56\x7a\x6d\xdf\xbd\x77\x6c\xdb\x75\x00\xd4\x2d\x98\xa1\x79\x4a\xac\x77\xed\x33\xd5\x4a\xf0\xd3\xff\x1c\xff\x02\xb2\x24\x3a\xf8\xe2\xee\xbe\xdd\xf7\x42\xc9\xdb\xa6\xbc\x15\x9a\x96\xcc\xfb\x4b\xaa\xde\xc2\xf5\x2a\x1f\x22\x1f\x2f\x4d\x4d\xcf\x65\xec\x16\x3f\xc3\xb8\xf4\x31\xbd\x05\x99\xbf\x20\x45\x55\xba\xad\x82\xb5\x5d\xd6\x4b\x7e\xbf\xa4\x87\xba\xa4\x57\xe0\x4d\x4e\x1d\xd3\x2e\xeb\xb4\x67\x06\x24\x50\x49\x54\x5f\x4c\x4d\x96\xf8\x7c\xf8\xd4\xa6\x4e\xc2\x53\x2b\x95\xfa\x7f\xcc\x87\x57\xae\x9b\xaf\xdc\x6c\x1d\x44\x5b\xbb\x50\x13\x09\xfe\x6b\xc5\xde\xa6\xfe\x67\xdc\xad\x43\x49\x6c\x1f\xac\x6f\x29\x11\x08\x50\x0b\x06\x8e\x71\x16\x74\x7e\x2a\xa8\xd9\xb9\x9a\x94\xdb\x1f\xb3\xea\xd0\x41\xb1\xeb\x62\xee\x08\x57\x99\xb1\x06\x8c\x11\x9e\x8b\x43\x5f\x04\xfd\x92\x50\x60\x61\xe1\x02\xba\x28\x94\xa8\x1e\x59\xb2\x6b\x5b\x84\x2b\xbc\xd5\xe3\xa4\xb1\xec\x0c\x8a\xee\xd4\xd7\x07\x88\x1f\xaf\xd1\xc1\x72\x39\x19\xc9\x81\x9d\xf1\xc6\x61\x54\x0b\xd0\x5e\x7f\x20\xd1\xd9\xb0\xf1\xe9\x57\x6f\xdd\xec\xa2\x57\xbb\x66\x8f\xee\xdc\xbf\x92\xfd\x0e\xe8\x94\x0d\xca\xbd\xca\x2e\xe5\x1a\xc0\x7d\xcf\xae\xdc\xdf\x39\x7a\x36\xfe\xdb\xcd\xb7\xbe\x32\xfb\x4f\x2f\x3d\xfa\x8a\x13\xec\x53\xae\xbc\x52\x58\x9e\x50\x5e\xfc\x8f\x72\x0c\x58\x7f\x38\x4c\x0d\x24\x96\x0b\x57\x82\x2b\x95\x4e\xe7\xab\xfb\x5f\x7c\x57\x3b\x7b\xcc\x09\xb6\x0b\xdd\xe3\xc6\x9c\xcf\xab\x73\x58\x28\x8b\x0e\xe2\x6b\xcc\x88\x68\xaf\x90\x47\x05\x8d\xae\x85\xb2\x51\x2c\x8d\x89\xca\x54\x89\x6a\x57\x4e\x7a\xd2\x34\xd3\x03\x13\x1d\x57\x5e\xb5\x61\xd0\x09\x1b\x3b\x2a\xd2\x6a\x0f\x32\x2d\xdf\x06\x7f\xb1\xad\x7f\xdf\xe0\xc3\x45\xf7\xe2\x8b\x72\x1e\x9a\x5f\x9c\xa2\xb8\x06\xf2\xae\x3c\x32\x17\x74\x1a\xac\x36\x2b\x05\x03\x7e\x46\xb2\x4b\xc8\x68\x03\x60\xf6\xd8\xa1\xc1\x6a\x46\x13\x35\xdb\x4b\xca\x23\x6a\x47\x94\x28\xe4\x82\xf3\xc4\xe9\xf2\x3a\x4f\xcb\x3f\x8a\xd8\x71\xe2\x1a\xa6\xc6\x12\x75\x4d\x53\xe2\xca\xf3\x58\xf3\x29\xcb\xb6\xd3\xfb\x0f\x80\x86\x7f\x9f\xf5\xeb\xd5\x1d\xcc\x29\x1b\xbc\xb9\x71\xfd\x4f\x2a\x33\x09\x14\xeb\xfd\xf4\x1f\xf0\x1c\xfb\x5f\x03\x6f\xbd\x1e\x54\xcf\xbb\x03\xe9\x97\x55\xec\x66\x74\xde\x67\xe5\xaa\x42\xbc\x2f\xa2\xd7\x87\x3d\x3e\x64\xa8\xc3\x06\x8f\xa7\x02\x00\x7f\x22\xc1\x74\xc9\x09\xca\x1b\xf2\x87\x50\x7c\x23\x58\xfc\xbc\xc5\xd1\x29\x5b\x0a\x7a\xa6\xb6\xbc\x2c\x85\x94\x79\x17\x2e\x72\x7e\xe6\x56\x30\x88\x80\xb3\x59\x95\x40\x04\x2a\xdb\x1c\xbb\x6a\x54\x65\xa0\x3a\x3d\x72\x58\x93\xd2\x3a\xbe\x77\x75\x09\x17\x67\x95\x46\xd4\x09\xac\xb9\xf9\xab\x3a\xea\x47\x0d\x67\xae\x3d\xdf\x55\x39\x7b\xc3\xf1\x27\x1f\xb8\x31\x4f\xca\x79\x7a\x81\xaf\xf3\xd0\x43\x5b\xc6\xeb\xcc\x58\x2e\x52\x43\x44\xde\x0a\xe7\xe6\x6a\x18\x1d\xd4\xeb\x1d\x36\x49\x90\x20\xb4\x08\x14\xe3\xf7\x09\x16\xbd\x55\xdf\x2b\x3b\x58\x0e\x05\x3f\x36\x8e\xa3\xad\xd0\x0b\x25\x1a\x6d\x0a\xad\xed\xc3\xa0\x6c\x61\xe1\xcc\xa0\xab\x90\x07\xd1\xc5\x49\x9a\x08\x8a\x97\xf3\x4f\x52\x20\x22\x45\x00\x72\xa4\x9a\x45\xe6\x4b\xdf\xf1\x1b\xc1\x42\xe5\x33\xb0\x04\x34\x7e\xfd\xd1\x82\x90\xcc\x98\x95\x57\xd0\x79\xdf\x8d\x02\x50\xf7\xb9\xef\xd7\x8f\x04\x1b\x95\x8b\xce\xa5\xa5\x35\xe0\x8f\x8e\x23\xa0\x6b\x85\x52\xb3\xa6\xff\x43\xa7\x09\x50\xa5\xfc\xa2\xf8\x9d\x6d\x94\x28\x38\x78\x07\xcd\x02\x8e\xe3\xbd\xbc\x05\x30\xfe\x80\x95\x6b\x97\xad\xbc\x08\x19\xd8\x21\x0b\x0c\xcf\x84\x18\x9a\x37\x87\xcc\xb4\x19\x7a\x18\xb3\x99\xf1\x40\xca\xc2\x53\x0e\x14\x03\x69\x4a\x49\xd5\x48\x2a\x67\x66\xd1\x78\xe5\x85\x69\x50\x85\xc9\x36\x8a\xb1\xc6\xac\x58\xe0\xd0\x84\xc8\x94\xc1\x3c\x8f\xe6\xeb\x77\xbe\xf3\x60\x9e\x49\xf3\xd9\xed\xaf\x3f\x91\xe7\xd2\x04\x57\x2f\x03\xa7\xa8\x74\x9a\xca\x1d\xcb\x94\x87\x34\x46\x4d\x2c\x43\x95\x32\x81\xe9\x41\xeb\x1f\x42\xe7\xaa\x86\x81\x92\xd3\xcb\x7b\x6c\xa6\x40\xc0\xc6\x3b\x21\x1b\x8e\x78\xec\x2e\x7b\xaf\x2c\x78\xbd\xc8\x77\x85\x5e\xa7\xd3\x0b\x21\xe5\x82\x94\xbe\x47\x8d\xdc\x0a\xb3\x2e\xe7\xfa\x2a\x7d\x64\x20\x95\x16\xf9\xc7\xcf\x0c\x68\x2c\xee\x02\x43\x49\x02\x05\x3e\xf8\xe2\x77\xcc\xfc\xaa\x86\x7b\x46\x3d\xd6\xf7\xc6\xb1\x36\xb0\xf9\xc2\xbf\xcf\x0f\xc9\xf0\x0a\x65\x2a\x70\xa0\x80\x7e\x9f\x32\x21\x0d\x16\x7d\x27\xf9\xbf\x52\x3e\x7a\x6b\x05\xed\x25\x9b\xd0\xff\x66\x52\xf9\xee\x0b\xe5\x5f\xca\x1f\x55\x19\xda\x90\x0c\x97\x11\x19\xa6\xe5\x2a\x25\xc8\xeb\x38\x5b\xc0\x68\xd3\xe1\xf9\xeb\x78\x3d\xdf\x2b\x73\x38\x64\xe3\xfc\x9c\xc9\x84\xe2\x69\x4a\x0f\x29\xf7\xe0\xf9\xdb\xb2\x27\x89\xe1\x50\xbc\x3c\x8c\x4a\x80\x3c\x04\xb3\x4a\x04\x9a\x37\xc8\x90\xa3\x5f\x44\x11\xf0\x3e\x60\x04\x0e\x65\x2a\xbc\x42\x0e\xcd\xff\xfb\x85\x60\x73\xdb\xd7\x7f\xec\x7b\x6c\xe4\xbd\x0d\x55\xf3\x99\xdf\x29\x13\x40\x0d\x70\x7e\x01\x4c\x49\xba\x6a\x85\xb2\xf7\x88\xa3\xff\xe3\x15\x6f\x7d\xa4\x7c\xe5\x97\xbe\x53\xee\x48\xab\x73\x1f\xaf\x4c\x84\xd7\x11\x1e\x82\x8e\x5c\x06\xcd\x9d\x63\x6d\x06\x9f\x0f\xf9\x9c\x4c\x30\xc4\xf1\x3a\xbe\x5d\x66\xed\xe8\x3e\xb3\x5e\xd6\x68\x64\xbd\x90\xd2\xf1\x94\xbb\xeb\x7f\x9d\xbc\xba\xf2\xf1\x46\x41\x9b\x3d\x7e\x54\x2b\x4e\x1f\x7b\x3d\xf4\xb4\x13\xca\xb7\xe0\x74\xe5\x20\xe4\x26\x87\xc4\x25\xa3\xee\x00\xf1\xd3\x6e\xd8\x70\xe3\x75\x9b\xaf\x18\xb1\x47\x99\xf8\xd5\x9f\x41\xf7\x48\xf0\x56\xbd\xf2\xe9\x4e\xde\xa1\x8c\x1e\xb5\x7b\xcf\xee\x6d\xe1\x53\x93\x15\xc5\x39\x5f\x89\xe6\x5c\x89\xeb\x90\x8d\x7e\x8f\x25\xc6\x30\x92\xc5\x9f\x72\x73\x55\x19\x8f\x25\x65\x91\x24\x4b\x0a\x52\x4e\xa7\xd0\x2e\x3b\x79\x2a\x51\x9c\x6e\xf1\x3d\xd0\x36\xd8\x8b\x25\x74\x04\x24\x8e\x88\xc4\x4a\x29\x62\x55\xe6\x10\x2d\xf4\x21\x13\xf7\xdf\xfc\xd6\xaa\x43\x8f\xcf\x9a\xac\x1c\xeb\x02\x15\x7b\xc8\x69\x87\x21\xa5\xef\xa1\xab\x4f\x59\x75\xd1\x86\xf3\x81\x6e\xcb\x35\x58\x82\x19\xdb\x17\x6f\x7c\xd8\x69\x1e\xde\x78\xd9\x28\x30\x56\x3b\xfa\x0f\x04\x7b\xbb\x46\xb6\xd7\xd9\xa5\xb3\x96\xfe\x45\x95\x06\xe0\x0a\x7a\xb8\x1b\xe9\xfd\x38\x75\x5a\xae\x5e\xcf\x1a\x29\xa3\xc7\xce\x05\x7d\x51\x4f\x14\x19\x04\x4f\x2c\xc0\x26\x13\x41\x4e\xc7\xf5\xca\x3e\x9d\x5d\x67\x47\x42\x59\x70\x10\x07\xa2\x54\xf4\xa2\x92\x52\xf0\xc2\x9b\x5b\xd9\x25\x28\xf2\xc5\x90\x8b\x8b\xa4\x6b\x46\x6a\xa8\xa9\x10\x2a\xd9\xb4\x9a\x28\x1d\xba\xc3\x84\xf1\x43\x9a\xfd\xb3\x3b\x96\xc4\x94\x8d\xe0\xc9\x8a\x15\x73\xc7\x4c\x09\x65\xe6\x74\xee\xe8\x7e\xff\xb3\xe1\xd3\xfb\x6a\xb6\x6e\xd9\x4e\xdf\xf4\xdb\x1b\xee\x38\x27\xbb\x66\xf9\x86\x95\x1b\xbc\xde\xdf\x81\x7a\xbb\xe7\x57\xbb\xd7\x9f\xb1\xa6\x61\xed\x05\x57\xfd\x0d\xcb\x52\x31\xf0\x39\xc4\xef\x68\x71\xa4\x4b\x1b\x02\x02\xc3\x19\xe3\xc0\x19\xe7\x04\x24\x83\x25\x8c\x4b\xfd\x68\xde\x12\xb2\x20\xfd\xe3\xb4\x38\x2d\x22\x2d\xfa\x7a\x64\x51\xa4\x0d\x17\xc9\x05\xe0\xf2\xc1\xb4\x38\xe4\x09\xb1\x74\xa3\xc4\x22\x20\xb9\x36\x79\x5c\xde\xa0\xdd\x70\x9b\x16\xb1\xbe\xfd\x30\xec\xc6\xee\xe9\xda\xd0\x82\x29\x6f\xbe\x71\xfc\x5f\x4f\x3d\x61\x9e\x3f\x2c\x75\x6e\xcd\xc7\xbd\x67\x8e\xac\xf3\x2e\x66\xde\xf5\xb5\x29\x63\xde\xb0\x2b\x77\xe9\x1c\xbf\x3b\xfc\xd2\xbb\x69\x30\xe1\x1d\xa7\x0f\x0c\xbb\xfb\x06\xaf\x85\x9c\x2f\x1a\xc9\xe1\x40\xe7\x2b\x8e\x5f\xfe\x8d\x80\x65\x02\x82\xc0\xc4\x9d\x80\x4d\x24\x2d\xe1\x0e\x19\x85\x1f\x79\x01\x3a\x90\xc7\x6f\xa0\x69\xaa\x5d\xa6\xf9\x21\x7b\xf1\x5f\x26\x2f\x0d\x9d\xbc\xba\x2b\xba\xd8\xd6\x1b\xe9\xfe\xa9\x99\x25\xa7\x3f\xe7\xef\x18\xf5\xe8\xaf\x8f\xbe\x7c\xff\xed\xc6\x8e\x1a\xff\xb2\x8a\xc3\x1d\x0b\x7d\x55\xd5\x3d\x70\xba\xbb\x55\xd9\x73\x83\xf8\x96\xce\x76\xeb\xfa\x5b\x7e\x11\x03\xce\x87\x05\xf7\x6b\x3d\xb2\xd1\xad\xde\x0d\x13\x8a\x57\x36\xa2\xf8\x2e\x41\xd5\xe7\xbc\x06\x2a\x28\x08\x3a\xca\xc5\x24\x53\xa2\xaf\x1d\x47\x27\x06\xce\xd0\x21\x43\x8e\x2f\x7d\xbf\x2c\x46\xd2\xc5\x5a\x7c\x0c\x3f\x0b\xa4\x42\xba\xda\x99\xaf\x1d\x81\x0b\x67\x9f\x75\xc1\xb6\xe7\x9e\x8b\x4c\x58\x34\xa6\xef\xf6\xd6\x9d\xf1\xd6\xe4\xa8\xb9\xcd\xe3\x26\x4e\x9f\xd5\x18\xb7\xc2\xf1\x24\x84\x9b\x5a\x95\x6b\x6c\x5f\x3f\x73\xe7\x9e\xa8\x0d\x50\xeb\xa7\xb7\x36\xb7\x2c\xa8\xae\x6e\x9a\x34\x89\xc4\xcb\x93\x94\x69\xcc\xa5\x28\xde\xb7\xa1\x3b\xd9\x96\x4b\xda\x31\x57\xbc\xc3\x0a\xad\xfe\x80\xde\xce\xd9\x6d\x1d\xb2\x5d\x32\xb9\xba\x64\x93\x40\x1e\x00\x91\x53\xd5\xae\xe6\x17\xcb\x6b\x73\xa8\x11\xe5\xc8\x6d\x20\x9f\x51\xd1\xd6\x95\x62\x31\xc5\xa8\xea\x50\xd0\x9c\x32\xf6\x17\x3b\xc0\x53\x8d\x8f\xac\xfc\xd9\x1d\xca\xb3\xca\xcb\xa0\x63\xf2\xf8\x50\x73\xe3\x70\x92\x9c\xeb\x73\xb7\xee\xe9\x59\xf2\x5c\xdf\x3f\x95\xdb\x97\x2e\x79\x14\xdc\x76\xce\x95\xb1\x16\x19\xf3\xbc\xa0\xc5\xac\x27\xfc\x8d\xb6\x5f\xa1\x13\x40\x53\xe4\x45\x4e\x7d\x00\x8a\xc4\x6c\x59\x50\x7f\xd7\x5d\xac\x56\x6f\xb4\x12\xfd\x96\x51\xb9\x1e\x29\x77\x0e\x1d\x18\x83\x9e\xe6\x28\xc0\xe2\xa7\x8f\x16\xf5\xc5\x5e\xfb\x21\xf4\x7f\x3a\x73\xd7\x5d\xca\xdf\xf0\x0f\xff\x78\x1e\xf9\x00\x80\xfb\x55\x49\x5f\xb1\x88\xdf\xa4\xa0\xe4\xb0\x19\x8c\x86\x85\xb2\x15\x7d\x10\xc7\x2e\x94\xed\x9c\x11\xfd\x82\x66\x0a\xda\xcb\x99\x56\x6d\xa5\x6f\x52\x84\x54\xa5\x31\xdb\x88\x1f\xa5\xd0\x2f\xdc\x4e\x41\xd7\x1e\xbc\xeb\x20\xfa\x07\xff\x06\x8e\x28\xd5\xe0\xc8\xd6\xf5\x5b\x69\x47\xff\xe7\x5b\xd7\xab\xf5\xd0\x8f\x0c\x7c\x04\x7e\x24\x35\x69\x4c\x1e\xf7\xcb\xf8\x18\xf7\x8d\x40\x70\xbf\x84\x14\x35\x9a\xfd\xbd\x5a\x57\xad\x8b\x93\x9e\x25\x58\x5b\xec\x59\x42\xdf\x6b\x48\xb1\xbb\x0a\xdf\xbb\x00\x7f\xaf\x80\xbe\x97\x3b\x85\xd2\x30\xc1\x74\x47\xc8\xdf\x4f\x52\xff\x9e\x39\x4f\xfd\x7b\xe6\x63\xb5\x76\x76\xe0\x73\x43\x90\xf4\x04\x91\xbe\x78\xaa\x9a\x9d\xad\xe1\x3c\x4d\xd3\xad\x25\xbd\xe4\xea\xd7\x4f\xd5\xbe\x9e\x46\xe7\xe6\xf4\x7c\x2f\x3b\xfe\x3a\x3d\x42\xed\x4b\x46\x9f\x73\x23\xf9\x9c\x7a\xed\x73\x7e\xaf\x7e\x1d\x7d\xce\xd7\xe4\xfb\xeb\xb5\xcf\x51\xbf\xde\xac\x4c\xe3\x6e\x27\x5f\xef\x52\xbf\x8e\xe7\x35\x30\x94\x67\x62\x23\xb8\x49\xed\x25\x73\x16\x65\x2e\xc3\x2f\xc6\xb2\x60\xac\xe0\x81\xa1\x18\xfb\x1b\x09\x8e\x86\xfe\x51\xc0\x17\x7e\x76\xe0\x23\xf4\x3d\x67\xe6\x71\x5a\x05\x8e\xde\xf8\xc6\xc9\x7b\x3c\x37\x92\x9e\x0c\x34\xae\x77\x70\xdf\xa8\xd6\xd3\x49\xc6\xdd\x73\xd2\x3e\x8b\x8d\xe0\x41\x75\xdc\x40\xf1\x67\xcb\xfa\x2a\xc8\xcf\xfe\xa5\xa4\x17\x24\x92\xff\x59\x43\x35\x44\x2b\x40\x99\x1f\x83\x34\x50\x3b\xfa\x1a\x4b\x7f\xfe\xb8\xf6\xf3\x29\x6a\x05\xf5\xde\xc0\x03\x6a\x2f\x0b\x72\xa0\x42\x39\x11\xee\xad\x03\x75\x34\xe8\x74\x83\xbd\x6e\xe0\xce\x99\x6d\x93\xdd\x94\x2d\xb3\x60\x35\x46\xd5\x28\xeb\x3b\x71\x16\xc6\xaa\x81\x0e\x90\x54\xc7\xf2\x0e\x19\x8b\xbb\x79\xf0\x58\xd4\x85\x80\xfe\x3f\x8e\x55\x94\xab\x16\x8d\x15\xfd\xc9\xb1\x76\xe7\xc7\x42\xeb\x72\x14\x30\x04\x8b\x11\x8d\x89\xc7\x22\x43\xd0\xb0\xb3\x0e\xe0\x41\xf1\x58\x75\x27\x1f\x2b\x5a\x18\xab\x0e\x8d\xd5\xa0\x8e\x15\xfe\x7f\x91\x6b\x1c\xf5\xd0\xff\x9b\x5c\x48\xc7\x10\x0c\x32\xf8\x1c\xf2\xd5\x03\xd8\x2a\x71\xac\xc7\xe3\x35\x8b\x50\x84\xa1\x20\x1f\x0a\x85\x68\x03\x64\xbc\x1d\x28\x7a\x60\xcc\x94\x80\x9b\x4e\x05\x81\x72\x76\x94\xd4\x7c\x94\xd7\xa3\xa9\x5d\x62\x0d\x44\x77\xb2\xd1\xe4\x68\xa4\x3f\x87\xe1\xe7\x0c\x5d\x63\xde\x30\xa5\x90\xc2\x8f\x39\x82\x00\xec\x7b\x66\x0f\xf8\xa2\x6e\xe5\x82\xb9\x1b\x9a\xf7\xce\xf8\xe4\xfd\x23\x2f\x8d\x1a\xf9\x9e\x3d\x23\xbe\xf2\xce\x74\xe1\x96\xcb\xc7\x05\x4e\x8d\x64\x8e\xf5\x7f\xff\xcd\x92\xab\xee\xdb\x70\x56\x63\xfe\x1e\x91\xf5\x8f\xe3\xf3\x66\xa8\xa6\x3f\x28\xb9\x3b\xc7\xb5\xbb\x83\xd7\x60\xaf\x76\x8e\xf6\xaa\x6b\xc0\xec\x1d\x83\x82\x3c\xd8\x99\x04\x7b\x93\x20\x89\xd7\x20\x39\x78\xbd\xd5\xcf\x6e\x2c\x7c\x76\xfd\xc9\x3f\x9b\xde\x49\x3d\xac\x7d\xf6\xc3\xe8\xb3\x47\xe6\x2a\x60\x6d\x03\x08\x35\x80\xbd\x0d\xa0\x21\x67\x10\x27\x37\xd0\x5b\x92\xe0\xca\x24\xe8\x4d\x02\x2a\x09\x5e\x1f\x34\x22\x21\xce\x6c\xc4\x43\xaf\xd6\xc6\x25\xdc\x2d\xa4\xef\xeb\x67\x6a\x1f\x17\x94\xd5\x3b\x9a\x2a\xd3\x0d\xec\x25\xa4\xd7\x6b\x37\xb9\x67\x9b\xc0\xcf\xa8\x7c\x4d\x15\x40\xfe\x5d\x25\xf2\xef\xb2\x1e\x43\xd0\x46\x1b\xe8\x4c\x15\x08\x47\xc2\xbd\x72\x45\x24\x1d\x4b\xc4\x50\x28\x10\x11\x22\xc8\x2b\x8a\x24\xec\xf6\x44\x04\xb2\x66\xb3\x13\x85\xf9\x0c\xeb\x47\x2e\xd3\x90\xda\x6c\x8d\xd7\xc5\x36\x88\x92\x9a\x60\x33\x95\x14\x4d\x05\x81\xab\xbc\xae\xaa\xb1\x88\x65\x95\xe5\x40\x59\xd9\xd4\x9c\x1b\x2f\xbb\xbf\xa4\xaa\xea\xc3\x0f\x71\x5d\xd5\xd5\x00\xfe\xb6\x58\x2c\x65\x75\xd7\x2a\xaf\x94\xd6\x53\x5d\xbf\xe6\x72\x5c\xec\x72\x39\x85\xf9\x13\x29\x65\x14\x43\x31\x3e\xa4\xfd\x86\x53\x63\xd0\xa9\xde\x99\x9b\x57\x39\x6a\x54\x55\x9d\x3f\x6a\x35\xf1\x7c\x24\xd2\xd4\x64\x6b\x1d\x69\x40\x5e\xac\xcd\x3a\xd6\x5f\xa5\x9b\x30\x3e\x54\xdd\x21\x9b\xc6\x8c\x49\x46\x78\xaf\x8b\x09\x25\x43\x49\x07\x74\x64\x3b\x64\x87\xd0\x4a\xe9\xf4\xba\x76\x79\x64\x25\xaf\x0f\xe9\x6b\xf5\x7b\xf5\xcf\xe8\x5f\xd7\x73\x06\xa8\xcf\x85\x63\x93\xf5\xb0\xa5\x53\x86\x7e\xb2\x22\xb5\x19\xdc\x43\x9e\x07\x90\x29\x1c\x6f\xd5\x93\x29\xa4\xd5\xb3\xb6\x41\xbf\xd0\x69\x57\x8b\x0c\xd0\x6a\x10\x3a\xde\xe6\x3c\x5b\xb7\xca\x80\x4d\xa0\x7a\x83\x60\x24\x08\xdb\xb0\x57\x0c\x1a\x34\x67\x19\x67\xa5\x38\x5d\x24\x19\x83\x0d\xcd\x11\x27\x7c\xbe\xe9\xdf\x8f\x3d\xf3\xa1\xa9\xb9\x3d\x79\xfe\xc8\x19\x0f\xec\x7f\xef\xe5\xcc\xb5\xa1\x0f\x63\xe7\x8e\x79\xe7\xb5\x8e\x29\x6e\x7a\x62\xf6\x28\x98\xa3\xf3\xf5\x7f\x39\xa5\x75\xec\xd4\x09\x2d\x63\x66\x0c\x97\x68\x03\x73\xe9\xde\xd7\xc7\x29\xd6\x58\x7f\xef\xd2\x15\x0b\xe6\x35\xb6\xba\xce\x6d\x79\x7a\xea\x7b\xb7\x3f\xc8\x1b\xcf\xc9\xdc\x33\xed\xaa\x3b\xf7\x98\xa7\x05\xb2\xca\x7f\xdc\xe9\x79\xf4\xf6\xf3\xce\x3b\x6f\xe5\x4a\xf4\x9b\x12\xaa\xac\x9f\xa7\x7c\x35\x6f\x5e\x01\x93\xef\x9b\x02\x26\x5f\x11\xf3\x33\x89\x7b\x03\xd3\x71\x5d\xe4\xbf\x62\x0a\x6e\xa4\xb6\x51\x04\x13\x6e\x2c\xc1\x84\x3b\x7a\x60\x5c\xcb\x10\x4c\xb8\x0a\xf2\xf9\x35\xda\xe7\x3f\x31\xc4\x96\x10\xdc\x1f\x9d\x57\xc5\x03\x22\x9f\xf9\x1d\xb8\x90\x7c\x0f\xad\x7e\x0f\x7e\xcf\x57\x16\xe2\xf7\x7d\xf2\x1e\x32\x25\x57\xe1\x0e\x87\x2d\x76\x16\x7a\xf5\x7a\x68\x81\xa9\x24\x9f\x0a\xa5\x68\x13\x34\xa2\x43\x6f\x64\xd8\x00\x8a\x8a\xd1\x09\x97\x7a\x0b\x35\x5e\x6a\x79\x50\x69\xcd\x6c\x21\x40\xc3\x6c\xe5\x71\xca\x26\x44\xc8\x2b\x32\x9b\x8f\x24\xb9\xd2\xc7\x7c\x78\xdb\xea\x35\x53\x94\x67\x94\x3e\xfa\x49\x30\x17\xf4\x2a\x7f\x56\x3e\xa9\x3d\xa5\x69\x54\xfb\xbc\xfe\xdd\xf9\xc7\x7c\x65\xe1\xea\x33\x16\x77\xe9\x41\x0f\x98\x46\xf7\x29\xf7\x29\x7b\x95\x57\x94\x5d\x81\x39\x33\x4f\x69\x09\xcc\x6a\x62\x5a\x06\xbd\xe6\xe3\x37\xe5\x45\x70\x3f\xf2\x57\xbd\x54\x92\x5a\x9f\xf3\x8b\x2c\xf4\x79\xac\x11\xbd\x15\xea\x61\x3a\xc5\xa4\xd7\xa7\x9f\x4f\xc3\x96\xf5\xe9\x9f\xa7\xe9\x34\xee\x3e\x1e\x31\x7a\x32\xfe\x77\xae\x36\x9d\x99\x7c\x57\x1a\xd0\x54\x3a\x9c\xbe\x32\xbd\x25\xcd\x3c\x9b\x06\x3d\x69\x40\xa5\x81\x05\x9a\x82\xe8\xf4\x23\xf5\xdc\x29\x53\x6c\x8e\x8d\x77\xc8\x36\xd6\x49\x6a\x6f\xbd\x6e\xe1\xd5\xc2\x02\x20\x3d\xd4\xb3\x3a\x93\x39\xb7\x6c\x29\x0a\x2b\xa1\x31\x49\x93\x87\xae\xc2\x52\xc0\x92\x6a\x00\xfa\xdc\xd5\x6b\xda\x5e\x7c\xf2\x9d\xf7\x3f\x78\xe3\xce\x7b\xea\xc8\x22\xcc\xc8\x57\x02\x28\x8b\xd0\x1a\x74\x9a\x8f\x7f\xfc\xc3\xb1\x1f\x8e\xbd\xf7\x65\x60\xd6\x1c\x22\x3d\xbc\x38\x5f\x08\x80\xcf\x1b\xde\x47\xac\xf3\x40\x5f\x09\x46\x06\xc6\xaa\xa8\xc0\xfc\x33\xa9\x0a\xbd\xa5\x1c\xa7\x1c\xaf\x13\xd6\x7f\x18\x17\xa6\x0c\x2f\xa3\x12\x63\x5b\xa4\x2b\xf5\xd6\xb2\xef\x27\x79\x1f\xdd\x28\xf4\xfd\x97\x68\x67\xe9\x73\x70\x2b\xee\x22\x8f\x69\xbc\x44\x48\x13\x06\x4a\xce\x67\x04\xc5\xfc\x4b\xf1\x79\xa6\x67\xaa\xbd\x7b\x67\x91\x9e\xf3\x08\xe9\x39\x57\x0e\xc4\x42\x8c\x6f\x08\x2e\xd7\x1b\x1a\x2e\xd7\xc4\x5c\x4c\xa4\x28\x27\xcf\x5a\x2c\x3e\xbf\x97\x77\x01\x03\x74\xb9\x3c\x92\x24\x08\xd6\x0e\x59\x28\xe0\x71\x15\x8b\xd3\xdc\xb5\xd9\x2c\x01\xa9\xc8\x77\x2a\x67\x4f\x8e\xb9\x25\x4a\x30\x06\xd1\x17\x9a\x07\x61\x6e\xed\x3b\x09\xe4\x16\xf8\x4f\x44\x39\x0a\x12\x79\xcc\x2d\xe2\x6b\x13\xbf\x35\x45\xfc\xd0\xd1\x9a\x7f\xaa\xfa\xd5\xc5\xaf\x2f\xd0\xbe\xae\xfa\xd3\xd7\x6b\xfe\xb4\x4e\xf5\xa7\x0b\x7a\xe1\xfd\xbc\x5e\xa0\x2e\xa4\x4d\x9a\x5e\x48\xa3\x85\x9c\x1a\x4f\x9d\x54\x2f\xdc\x98\xd7\x0b\xd4\x85\xd4\x80\xba\x4f\x70\x1c\x52\x0c\xbd\x2d\x25\x48\xa3\xc4\x7e\x21\x3f\x5d\xb7\x1d\xc5\xf4\x29\x6a\x65\x6e\xa4\x9d\xe3\x4c\x5e\x11\x86\x13\x09\x68\x82\xe9\x8a\x58\xa4\x47\x8e\xf1\x76\x5c\x16\x62\x07\x26\x68\xb7\x1b\xac\x1e\x87\xcd\x8c\xe1\x6f\x9c\x25\xf8\x37\xe8\x9a\x53\xe5\x79\xf5\xc1\xb8\x8c\xa5\x61\x68\x69\x0d\x6a\xa4\xf4\xad\x1c\xfd\xd7\x90\xf7\x1d\x07\xc7\x7e\xf3\xe9\x9f\xfb\xff\x9c\x67\x7a\x51\x41\x18\x47\xb7\xb5\x4c\xbc\x18\xdc\xf6\x07\xc7\x8e\xdb\xc0\x7c\x0c\xb5\x98\x67\x7b\x51\x04\xf0\x35\xa9\xac\x9d\x7e\xd9\xf9\x6b\x57\xd3\x41\xcf\x94\xfe\xf3\xb6\xdd\xa1\xd6\x01\xa0\xf3\x88\x6b\xe6\xf1\x79\x19\x9f\x8b\x49\x38\x2e\x75\xa3\xb8\xd4\xe7\xd7\xdb\x38\x1b\x52\x51\x36\xbb\xdd\xc4\x70\x4c\x0f\xee\xfb\xcc\x17\xbd\x50\x65\x75\xb4\xff\x35\x24\x45\x2a\x4b\x8c\xea\x6c\x4d\x76\x64\x50\x68\x93\xe2\x7d\xa8\x0f\x7c\x3a\xe1\xb1\x33\x9f\x7c\x5e\x59\xaf\xdc\xf6\x97\x0b\x96\xbf\xf4\xda\xe9\xca\x84\x36\x1f\x57\xef\x6d\xfb\xfd\xb2\xb3\x95\x4f\x91\x5a\x6a\xbd\x8a\xd9\x70\xed\x89\x0b\x17\x83\xf3\x95\xed\xbb\x0a\x18\x4f\xba\x54\x01\xe3\x69\x1c\xb8\x48\xbd\x33\x1e\x72\x67\x7e\x7f\xc0\xe9\xb1\x31\x43\x70\x93\x8a\x18\x4f\xe3\x08\xb7\x49\xe1\xd6\xec\x3a\x10\x8c\x78\x87\x70\xe1\xe9\x05\xcd\xbf\x4a\xa9\xbc\x76\xc4\xff\xfe\x88\x5e\x47\x45\x31\x86\x4c\x02\x32\xe7\x64\x6a\x68\x7d\x22\xcf\x73\xa7\x51\xe3\x11\xf4\xb0\xc6\xbc\x2f\xa6\x9b\x56\xf0\xc5\x08\x9f\x0a\xf9\x0c\x33\xf8\x2d\x15\xcc\x99\x99\xf0\x18\xb0\x72\xcc\x58\x33\x93\x18\xc4\xae\x92\x59\xd0\x58\xf0\xb5\xde\xcf\xfb\x5a\xd4\x85\xf0\x39\x15\x7b\x3a\x85\xb1\xa7\xc1\xa2\x03\xa9\xca\x88\xab\x1c\x87\x9c\xbd\x84\xc8\xb8\x5b\x1b\xe7\x25\xed\x3c\x8f\x47\xe7\xb9\x67\xfc\x24\xcf\x60\x6c\xde\x17\x35\x1e\xae\xdb\xb4\xfb\xa2\xf1\x70\x41\xa4\x78\xe0\x65\xb1\xe4\xa0\x9e\x6a\xc2\x21\x40\x3e\xff\x29\xaa\x8c\xaf\x01\x26\xd0\xe7\xcb\x89\xb4\x68\x28\xef\xd9\x2e\xe7\x37\xa4\xdf\xa0\xaf\xd0\xf8\x04\x83\x2a\x9f\xe0\x7d\x07\xa4\x20\x34\x94\x71\xd0\xf8\xcb\x79\x74\xe8\x37\xc0\xe3\x94\xca\xc1\x50\xaf\x72\x30\x3c\x7a\x20\x5d\x6f\x66\xcb\x7e\x46\x1d\xe7\xeb\xc2\x38\x47\xe8\x4f\x35\xfd\x8c\xc6\xa1\xe9\xa0\x13\x1a\x4e\xc2\xbd\x73\x4f\x61\x8c\x23\x34\x4f\xce\x02\x1e\x82\xf0\x48\xd4\x57\x98\xd9\x72\x7f\xa0\x94\x2b\x0f\xc9\xd1\xa2\xf1\xc0\xa5\x54\x1e\xb8\xe7\x0f\x04\x53\x3e\x4f\xd9\x9c\x98\x72\xee\x15\x24\xc7\x9d\x9a\x1c\x15\xaa\x1c\xef\x1f\x08\x57\x88\xe5\xfc\x3b\xea\x38\x5f\x17\xc6\x39\x42\x6f\xd5\xf4\x17\x1a\x07\x18\x52\x21\xdf\xc9\xb0\x98\xef\x29\x8c\x71\x04\xfc\x43\xb3\x33\x68\x0c\xda\x59\x11\x11\xcb\x30\x66\x06\xf6\x62\x63\x50\xe4\xcb\x43\x73\x9a\xa2\xc9\xe1\x52\xe5\x78\xf1\x80\xd5\xa5\xe2\x7b\xe4\xe7\x34\x80\x6e\x17\xbd\xae\xc0\xbf\x82\x7e\x86\x7a\x85\x52\x59\x52\x24\x95\x25\xe5\xb1\x03\x66\x89\xa1\xcb\xe4\x50\x73\x00\x5f\x17\xc6\x39\x02\x36\xab\x98\x66\x2e\x56\xb5\x50\x2e\xbe\x88\x22\x82\xc6\xf8\x0c\x7d\xff\x04\x22\xc7\xff\x68\xdf\xef\x56\xef\xa6\x44\xee\xe6\xb7\x07\x24\x8b\x3a\x42\x11\x93\xb9\x94\x3f\x0e\xed\xc7\x7e\xed\x5c\x45\xd5\x73\x75\xef\x01\x4f\xb4\x14\x0d\x0a\xfd\x8c\xa1\x9c\x6b\x04\xc9\xbe\x4b\xdb\x8f\x98\xba\x1f\xbf\x3c\xe0\x8d\x95\xa2\x41\x15\xc6\xf9\xba\x30\xce\x11\x18\xd6\xce\x15\x1a\x87\x86\xd1\xc1\x3c\x75\x6a\x6e\xe2\x9e\xc2\x18\x47\x48\x39\x1b\xfe\xfe\x18\xb6\xfb\xb1\xc1\x7c\x26\x83\x70\x84\x90\x1c\x15\x9a\x1c\x15\xaa\x1c\xc3\xd1\x19\x29\x45\x29\x40\x6b\xf5\x4e\x39\xae\x10\x92\xe3\x5c\x6d\x3f\xc2\xea\x7e\x3c\x7a\xc0\x15\x16\xd9\xc1\xe7\x0a\x8d\xf3\x75\x61\x9c\x23\xf4\x0e\x55\x8f\x54\x10\x0c\xfb\x9d\x07\x2a\x22\x06\x7b\xb9\xae\x44\x63\xdc\x53\x18\xe3\x08\x78\x5b\xc3\x35\x40\x63\x00\x63\xd8\x2d\xb2\x27\xc1\xea\x28\xf0\xb4\x21\x39\x7e\xae\x9d\xab\x84\x7a\xae\x9e\x3e\xe0\x4f\x88\xe5\xbc\xa1\x83\xb8\x37\x90\x1c\xbf\xd7\xe4\x88\xa9\x72\x3c\x80\xf6\x43\xef\x2c\xfb\x19\x75\x9c\xaf\x0b\xe3\x1c\x81\xad\x25\xb8\xea\xa7\x25\x02\xa2\xfe\x24\x98\x20\xf7\x14\xc6\x38\x42\x67\xd4\x73\x15\xcb\x7b\x4a\x3e\x75\x84\x3c\xe6\x51\xff\x77\xa5\x58\x42\xfa\xe7\xa9\xc3\x1a\x36\xc6\xc0\x6b\x07\xaa\x2b\xd2\x05\x2c\xa1\xfe\xef\x4a\xb1\x84\xf4\xcf\xd7\x69\xdf\xf5\x71\x11\xef\x87\x60\xe9\xf4\x7f\x87\xeb\x50\xf2\x58\x3a\xfa\xe7\xc1\x42\x15\x93\x83\x72\x3b\x0c\xa6\x22\x26\x47\x04\x7d\x5e\x01\x8b\x07\x7f\xde\x24\x15\xc3\xd6\xe7\xe2\x1c\xea\x77\x01\x6a\x2c\xb2\xc9\xa3\x91\x4d\x8e\x52\xb9\x5c\xd4\xe4\x65\x6c\x41\xa7\xd3\xe6\xa0\xbc\x6c\x2c\x4e\x81\x5e\x39\xe2\x30\x51\xe8\x97\xd5\xeb\xb3\xea\x70\x4d\x6a\x49\x45\xcb\xa0\xe6\x02\xdc\x8e\xd3\x14\x2f\x29\x68\x0b\x33\xd8\x71\x66\x70\x07\x0b\xdb\x58\x45\x8a\x44\xb8\x3f\xfe\x00\xec\x37\xff\xfc\xda\x45\x99\x39\x1f\x3d\x09\xaa\x01\x7d\xcb\xe5\xe0\x94\x23\xca\x58\x65\x1b\x58\x0d\x66\x2c\x3f\x6b\x07\x78\xf8\x92\xc4\x5f\xee\xde\x7e\xcd\xe8\xdf\x81\xfa\x61\x4f\xbd\x74\xcd\xd1\x61\x0b\x94\x77\x7e\xfd\xdd\xf6\xe8\x19\xc3\xbe\x7a\x6b\xdd\xee\x40\x9a\xf8\x4b\x23\x94\x09\xf4\x31\x14\x2f\x44\xa9\xc9\xb9\x94\xc9\xc7\xd8\x43\x6e\xb7\x5d\x02\x3e\x34\x67\x3e\x8e\x1c\x4f\x0a\x74\xc8\x11\x89\x4c\x9c\xf7\xf9\x78\x5d\x87\xcc\x0b\x83\x26\x5e\xde\x32\x58\x5f\xd7\xdc\x58\x52\x8c\x97\xcf\xcf\xa8\xf0\x06\x2c\xf9\xab\x14\x77\xe0\xea\x0b\x5b\x27\x8f\x1a\x55\x3d\xa1\xe9\x81\xf1\x2f\x3c\x74\xd6\x79\x57\x5d\xa3\x3c\xa6\xdc\xfe\xa7\x5f\x5f\x3c\xe5\xf3\x25\xd1\x3b\xaf\x5e\xd9\x9b\xbc\x1d\x70\x66\xf1\xc6\x3b\x16\xef\x1b\x13\xbe\xe1\xb2\x77\xff\x1a\x9a\x91\x7e\x6c\xf7\xe3\xa7\x38\xf3\x77\xb2\x0c\x0f\x7c\x23\x78\x5e\xd5\x5d\x21\xcd\x17\x8f\x04\x58\x71\x08\x1e\x38\xf2\xdd\x35\x3c\xf0\x8d\xd4\x37\xc8\x0f\xc1\x67\x32\x82\xac\x29\x13\x0b\xf9\x8d\xe5\x3e\xa4\x32\x8d\x73\xb1\x93\x90\x67\xd5\x99\xab\xb4\x1b\xf5\x7a\x0b\xed\xb6\xb8\x7d\x7e\x89\x5d\x28\x4b\x8c\xdd\x24\xa8\x05\x18\x18\x26\xb6\x47\x36\xd9\xdd\x2a\xce\x91\x8f\x2a\x2f\x4d\xcf\x13\xd8\x97\x7b\x59\xb8\x2c\xb4\xac\x2a\x5d\x52\x71\x13\x5d\x12\xbc\xaa\xef\x93\xad\x7d\xc4\x33\x04\x9f\x5c\xf9\xce\x45\xe0\xa6\x87\x95\x69\x53\xbc\xac\xfd\xf8\x92\x13\xe6\xbc\x4f\x78\xfe\x84\x11\xca\xfa\x1f\xff\xe1\x9d\x82\x31\x2b\x66\x28\x13\xd8\x10\x7b\x3d\x5a\x8f\x1a\x74\x7a\x57\xe5\x46\xd5\x06\x02\x15\x51\x91\x65\xb3\xee\xb8\xd9\x0c\xdc\x70\xc4\xf0\x70\x63\xa7\x1c\xf6\x11\x92\x19\x8a\xb3\x19\x78\xbe\x0a\x6f\x60\x14\x64\x3d\xd9\xe9\x32\xf4\x78\x80\xc1\x90\xea\x94\x0d\x4e\xec\x1e\xe6\x6b\x1d\x46\x14\xa7\x8e\xb3\x14\x2d\x43\xfc\xdd\xac\x56\x24\x1a\x6b\x6a\x4e\x8e\x06\x5a\xfb\xb9\xd6\x67\x4c\xb0\x40\x0b\x6f\x45\x5c\x49\xb7\x31\xa9\x29\x25\xa1\xde\x33\xcb\x02\x4b\xd8\x51\x4b\xc6\x6b\x6d\xc7\xbd\x60\x9d\xd3\x79\xc1\xc6\xeb\xce\x7f\x71\x46\x8d\x72\x77\xbe\xf5\x18\x7a\xc6\xb4\x49\xc6\xae\x50\x54\x99\x76\xcb\x72\x7f\xc5\x5d\x69\x9f\xda\x88\xbc\xe6\x4b\x77\xeb\x8f\xe3\xe8\x55\x3d\xb3\x97\x5d\xd7\x04\x5b\xb5\x66\xe4\x13\x33\x22\xd5\x9b\x12\xc8\x2f\x9e\x80\xec\x41\x98\x5d\x46\xd6\x64\x61\xae\x29\x65\x08\x43\x9f\x54\xc5\xf3\x92\xdd\x1d\xe3\xa0\x41\x5f\x57\xcb\xd9\x2b\x82\xc1\x8a\x1e\x39\x18\x74\x99\x29\x9c\xcd\xc2\x14\x60\x14\xe5\x72\xb9\x7b\x64\x97\x39\xde\x23\x9b\x45\x2d\x65\xa3\xe2\x00\xe6\xe1\xef\xf2\xb0\x77\x65\x6f\xc6\x4c\x09\x74\x47\x38\xde\x48\xb8\x11\x1b\x85\x84\x4b\x2d\xe6\x0c\xdb\x70\x05\x11\x72\xfe\x85\x08\x89\x73\xe9\x0f\x01\xfb\xe3\x83\x37\x3d\x76\x48\x79\x41\x79\x55\xf9\x83\xf2\xdc\x8b\xbf\xda\xfa\x08\x50\xc0\xea\x33\x37\xae\x03\xa6\x33\x2e\xac\xbd\xff\x5e\xe5\xf1\x5d\xbb\xee\x61\x97\xf1\xbb\xef\xbc\x72\x9f\x5f\xfc\xe5\xc6\x43\xbf\x3f\xf4\xfb\x8d\xbf\x14\xbd\xbb\x2e\x00\xba\xe0\x12\x71\xc9\xac\xb5\x57\x01\xdf\x8a\x2b\xa4\xe3\xa7\xde\xb4\x0d\x58\xd7\x5f\xb7\x7d\x2b\x45\x15\x39\xcf\xb6\x50\x61\x64\xcf\x3b\x73\x55\x54\x0d\x0a\xdc\x23\x94\xd3\x2f\x18\x53\x2c\x6b\xd4\x59\xdd\x21\x3f\xa5\xaf\xa9\xd6\x85\xe2\xa2\x88\x42\x78\x51\xa4\x3d\x16\x8a\xae\xec\x90\xe9\xb2\x12\xc0\x21\x32\xa2\xbb\x8d\x9b\xf5\x31\x8b\x99\xa0\x46\xf1\xcd\xae\x42\x75\x67\xaa\x99\x3c\xba\xe9\xca\xea\xfa\xe1\x7e\x4c\x67\xf6\xfd\xd2\xd5\xfb\x6e\xa9\x98\x3b\x7a\xcc\xd8\xdc\xdc\x8a\x5b\xf6\xad\x5a\xf1\x1f\xe5\xe8\xf8\x69\x6d\x63\x5b\x27\x4f\x9d\x00\x1e\x53\x9a\x3f\x7f\x1f\x4c\x98\x15\xb9\x61\xd9\x95\x77\x9a\xc6\x4d\xdc\x72\xc5\x85\x57\x9e\xbf\x65\xe2\x38\xd3\x5d\x6b\x97\xde\x10\x9d\xa5\x3c\xfb\xab\x47\xee\x3d\x78\x68\xd7\x01\x5c\xef\x82\xce\xb8\x1e\xc5\x73\x6e\x6a\x6c\x2e\x4a\x4b\x7a\xc1\xc6\x49\x16\x4e\x60\xbc\x1e\x37\x2e\x76\xe1\xf5\xa4\xc6\x1f\xea\x50\xd0\x83\x42\x9d\xc2\x03\x73\xbe\xd4\xa5\xfc\xd5\x9c\x64\xc7\x22\x25\x25\x15\x11\x55\x37\xc1\x5b\x2f\xbf\xee\xca\xfe\x39\xf4\xc7\x5a\x49\x4b\xbf\x04\x1e\xfc\xc3\x6b\x37\x3d\xa8\x6c\x9f\xba\x7a\xa6\x7c\x2e\xb3\x90\x94\x51\x1c\xbf\x65\xd5\x65\xd3\xb6\xcd\x52\x75\x44\x5a\x99\x00\xcf\x26\x98\xd2\xad\xb9\x98\xde\x46\x3b\xed\x9c\xd5\x89\x0c\x03\xeb\xf3\x7a\x7c\x36\xbd\xa0\x6f\x97\x2d\x02\xcf\xf3\x3a\x3b\x67\x6f\x97\xb9\x42\x7b\x56\xfe\x1d\xf3\xa7\x26\x96\x7f\xc7\xd7\xb4\x26\x1d\xdf\x7c\xd5\x4a\x65\x29\xd8\x97\x2f\x53\x51\x3a\xb7\xec\x79\x7c\xf3\x56\xe5\x9a\x33\x17\x75\x2e\xa8\x86\x09\xf5\xa9\xfe\xc4\x07\xe7\x9c\xd3\xb6\x6d\x6e\xc1\xcf\x3e\x5a\xf0\xb3\x77\x12\x5e\x24\xec\xdf\x60\x4a\x67\x4a\xf4\x9c\xd4\xcf\xbe\xbe\xe0\x67\xef\xcc\x73\xed\xd0\xb5\xc8\xc6\xc3\x64\x95\x99\x1d\xa4\x1b\xbb\x31\xaf\x09\x55\x4d\x5d\x96\x1b\xe7\xf6\xe8\x38\xbb\x85\x0f\xa6\xfd\x55\x66\x87\x03\x80\x4c\x55\x9a\xe7\x3c\xba\xda\x9a\x64\xa4\x3a\xe3\xf7\x57\x5b\x45\xb3\x88\x22\x51\xb3\x99\xf1\xb9\xab\xab\x1d\xbd\x72\x35\xe8\x91\xab\xed\x8c\xa9\x57\xd6\x31\x0c\x52\x9a\x8c\x86\x9d\xa3\x75\x3f\x53\x59\xd2\xc9\xad\xbd\x16\xda\x70\x2b\x6e\xc3\xa0\x0a\x19\x6d\xc5\x5a\x80\xed\x24\x54\xdf\x61\x02\xb4\x99\x4f\x8c\x36\x3a\xc9\x2b\x75\xaa\x39\x12\xeb\xeb\x63\x2e\x9c\x17\x5e\xf5\xe6\x1f\x40\x0f\xc1\xd9\xbc\xbb\x1f\xd0\x98\xf0\xbb\xff\x6b\xd3\x93\x5b\xce\xef\x9e\x38\xb9\x65\xfe\x98\x09\xf1\xfe\x97\xd5\x42\xf5\xc1\xa4\xdf\x8d\xbe\xeb\x4f\x3b\x33\xd4\x2d\xce\xae\xaa\x65\xaf\xc3\x6f\x1b\x4a\x37\x79\xdb\xc0\xb9\xc7\x45\xb9\xe6\xa8\x29\xae\xcb\x48\x95\x4e\x97\xcb\x2a\x05\x74\x26\x23\x6d\xd5\xd5\xd5\xf2\x75\xa1\x3a\xda\x00\x2b\x9d\x1d\x72\x65\x65\xc4\x66\x8c\x46\x59\x2a\x12\xf1\x75\xc9\xa6\x88\xd3\x96\xea\x28\x94\x87\x67\x49\x6d\x75\x83\x5a\xf6\x50\x3b\x34\x95\x98\xaf\x59\xce\xcb\x92\x4f\xa4\x15\x70\x36\x71\x8d\x07\x0f\x54\xf6\x39\x15\x51\x13\x3c\xa7\x09\x14\xd9\xdf\x77\xe4\xad\x67\xf6\x28\x62\xdd\x59\xa7\xcd\xdd\x50\xf7\xe0\x2c\xdd\x93\x5b\x66\x92\xe7\x10\xa5\x5b\x13\xe7\x0a\xcf\x67\x1f\x7d\xff\x0d\x79\x1c\xb9\xa2\x35\x70\x6a\x28\x43\x47\xb1\xb0\x2c\x73\xd5\x7d\x1b\x56\x0e\xcb\xfb\xd7\xe4\x7d\xa4\x41\x7b\x77\xc3\x4d\xaa\xbe\x1c\xcf\x40\x1c\xe2\xa2\xdf\xa1\x5b\xf3\xb1\x55\x27\xb0\xcc\xcf\x3e\xae\xbd\x01\xe2\xf7\x93\x3d\xda\x1b\xc7\x1e\xc0\xa0\xbb\xec\x63\x28\xfc\x4c\xe5\xf4\x4d\xc6\x6f\x49\xf8\x8f\x06\x71\x72\x1d\xa4\xa9\x38\x88\x3f\x31\xf0\xec\xaf\x52\x99\xc9\x9d\xea\x1f\x1f\x0b\xc6\x26\xc7\x6d\xc8\xd6\x67\x56\x67\xce\x6d\xc4\x0f\x1d\x0b\x32\xab\x8b\xbe\x3f\x79\xcf\x52\xe7\xd6\x00\xc3\x03\x5f\xa8\xd8\xb1\x71\xec\x9c\xd3\xf1\xda\x93\xe2\xcd\xee\xe7\xd8\xfc\xbc\xe8\x5f\x94\xcc\xcb\x4a\x75\xe7\xc2\x70\xa0\x0e\x7c\x55\x07\x5e\xc7\x08\xfc\x60\x00\x4f\x2c\x18\x9d\xac\xce\x8e\xbe\xcb\x0d\xdc\x38\x6b\x5a\x59\x3f\xd9\x4d\x18\x55\xec\xe9\xc9\x18\xa5\x96\xaa\x6f\x40\x61\x43\x19\x5d\x21\xbe\x32\x19\x34\x5f\x5b\x26\xa3\x3e\xd0\x14\x62\x95\xa3\x85\x58\x65\x27\x79\x3b\x25\xbc\x3c\xe8\x6e\x1a\x5c\x81\x93\xc6\x2a\xd7\x17\x62\x95\x9d\x84\xeb\x10\x7f\x7f\x84\x60\xfa\x06\x4f\x86\xbf\x4b\xde\x9b\xd4\xf5\xa8\x27\x7b\x55\x5c\x8f\xe2\x4e\x0d\x5e\x8f\xb1\x85\xf5\xd8\x89\xd6\xe3\x79\x6d\x3d\xa6\x50\x9e\x1c\x0f\xe3\x39\x03\x3f\x39\x4e\xbf\x1e\x01\x7b\x23\x20\x42\xd9\x16\x2c\x40\x42\x35\x16\xf1\xdb\x26\x14\xf0\xe1\x36\x15\xf0\x0b\xdd\xc8\x11\xcb\x38\xdd\x46\x71\x28\x3e\x1c\x79\x73\x9a\xaf\xe5\x5c\xf3\xf8\x73\x38\xc1\xe3\x0d\x45\xa0\xb9\x34\x27\x4a\xe9\x91\x6f\x3a\x80\xfc\x1b\x89\x0a\x52\x6d\xb9\x84\x17\xfd\x90\x2d\x1c\x72\xb2\x6c\xd8\x68\xf1\xd0\x9e\x2e\x99\xa7\x69\x8b\xc3\x81\xf4\xab\x83\xb2\xf8\xf4\xfe\x4e\x59\xaf\x65\xb9\xca\x5d\x99\x22\xd6\x19\xc9\xd4\x35\x15\xdd\x13\x1d\x76\x61\xd4\xd4\x28\x52\xc0\x3a\x82\xbf\xb4\x37\x9e\xb8\x6c\xd3\x8d\xe7\xbd\xbc\xa8\xc3\x7b\x9a\xff\x72\x11\x79\x27\x2f\x8e\x1d\xd7\x6a\x3f\x3d\x95\x99\xca\x2c\x9b\xdb\xb5\x68\x67\x6e\xe6\x1d\xa7\x8f\x9b\xcd\x76\xb8\x5b\x7f\x58\x14\xad\x66\x36\x27\xf0\x5c\x9b\x91\x9d\x9a\x88\xfc\xe8\x14\x55\x47\x5d\x9c\x1b\x9b\x66\x59\xde\x68\xb3\x55\x51\x51\xb7\x3b\x10\xb0\x50\xb0\xa1\x9e\x6f\xc0\x00\xd4\x89\x84\x34\x5d\x4e\x08\xe1\x60\xbb\x1c\xe6\xdd\x01\x5f\xa0\x5d\x36\x5a\x32\x74\x46\x15\xc6\x27\x21\x39\x6a\x4a\xe4\x50\x4b\x66\x49\x97\x5d\x29\x26\x77\xb9\xcb\x8d\xff\xd7\xf0\x13\xa2\x0d\x46\xe9\xc6\xfd\x91\xb6\x82\xb0\xf0\xfb\x72\x61\x4b\xfa\x22\xad\xa4\x59\xf2\xa4\xa2\xd3\xf7\x95\xb5\x49\x4e\xc7\x0d\x94\x27\x72\xda\x52\xa0\xb5\x70\xa2\x33\x65\x61\xd6\x21\x8f\x18\x57\x56\x55\x87\xdd\x14\x85\x17\xc3\x92\x4c\xf8\x59\x36\x29\xfa\xdc\xbe\x0e\xd9\x18\xb2\xd0\x21\x55\x68\x67\x4e\x72\xf3\x16\xa7\x3e\xda\x59\xe8\x2c\xc4\xad\x1b\x65\xa2\x97\xb6\xa7\x6a\x9e\xf4\x50\x59\x0b\xe5\x40\xc5\xcd\xfc\x6d\x89\x7c\xbe\x2b\x44\xb5\x97\x23\x2f\x14\x98\x4f\xa4\xba\x6d\xf4\xec\x9d\x8b\x5b\xe7\x80\x27\xd5\x86\x8e\x19\xd1\x6a\x16\xb9\x92\x18\x28\x5e\x99\x46\x47\x90\x8d\xb7\x51\xe1\x9c\x60\x11\xed\x27\x4f\xbf\xab\x5d\xfe\x43\x72\xed\x83\x52\xec\x65\xb9\x75\xe4\xbb\x37\x0f\x7c\xce\x9d\x46\xb8\xe3\x2a\x51\xc4\xdf\x95\xab\x64\x92\xc9\x60\x5d\xc6\x15\x32\x9b\xeb\x5c\xb0\xb9\x29\x9a\xf5\x66\x91\x95\xe0\x1c\x06\xaf\x90\xae\x71\xa0\x33\xc1\x23\xff\x11\x17\x6e\x15\x88\x21\x0b\x98\x73\x83\x8a\x19\xb5\xc6\x8d\x41\xdc\x90\x89\x52\x3f\xbd\xb1\x1c\xa5\xad\x48\x0d\xf7\x04\x3a\xee\x79\x74\xb1\xdd\xca\xeb\xcd\x67\xe6\x9d\xf4\x12\x34\xbd\x13\xb1\xbc\x8f\xae\xd2\x47\x16\x00\xc7\xc6\x25\x03\x9a\x8f\xde\xdf\x97\x47\x25\x7b\xa1\x80\x16\x04\xa9\xe1\x28\xae\x9a\x0f\xdf\xa5\x22\xc8\x7b\x68\x42\xb7\x64\x4c\x34\x1b\x10\xc3\xe1\x34\x07\xa1\xa9\xc6\x6d\x72\x37\x0f\xe7\x44\x4e\x0c\x08\x01\x24\x79\x40\x12\x2a\xf0\x6a\xd7\x65\xac\x99\x0e\x59\xb2\x59\x85\xc6\x84\x3e\xd1\x29\xfb\xf4\xce\x30\x2c\x54\x59\x15\xd3\xf3\xee\x96\x43\xd9\xd2\x3b\x52\x84\x17\x1a\xa1\x01\xef\x68\x91\x8b\x9a\xe9\x6e\x1c\xd6\x5c\xec\x91\x6c\xce\x4a\xe5\xdd\x7b\x40\xeb\xdc\xc6\x4b\xc2\xe6\xfb\xf7\x98\x65\xfd\x2f\x5f\x67\x3c\xfd\xe6\x37\x5e\xfc\xf0\xcf\x93\x5f\xbf\x68\x5e\xb1\x91\xef\xc4\x77\x0b\xce\x4c\xce\x0a\x8c\x9f\x79\xc6\xe9\xf0\x3d\xb5\x9b\x0f\xd7\x6a\xbd\xb3\xa0\xb7\xfd\xdf\xff\x3e\xf6\xa3\x2b\x33\xa7\xa4\xad\x0f\x36\x1c\xf8\xa5\x64\xa3\x5f\xb1\xbd\x74\xa0\xd8\xd7\xc7\x50\x8e\x81\x5b\xd9\x27\xd8\xf3\x28\x17\xba\x35\x41\x74\x6f\xa6\xe5\x2a\xf4\x21\x77\xa8\x17\x2d\x04\xe5\xf5\x33\xa2\xdb\x6d\xf6\x39\x45\x26\x62\xd0\xfa\x29\xad\x39\xb3\x7d\x30\x0a\x84\xf7\xd5\xbc\xdb\x7b\x08\x7b\xf3\x48\x3f\x90\x25\xa9\xaf\x33\x68\x04\x24\x11\xe8\x92\x62\xba\x58\x73\xac\xb1\x19\x20\x55\x90\x05\x59\x11\x8a\xba\x2c\x0b\x75\xae\x66\x11\x7e\x06\x96\x9e\xd1\xbf\x67\xe7\x95\xca\xa7\x5f\x0e\x5b\x3e\x6e\xd3\xb8\x5d\x8b\xc1\xfb\x20\x3a\x76\xd3\xa6\x13\x6f\x5f\xf1\xfb\x65\xb7\x9d\xbd\x47\x89\x2d\xd7\x43\xe6\x25\xc6\x79\xa2\x9d\x94\xdd\xcf\x53\x6e\xd2\xb7\x2d\x5b\x86\x9c\xa6\xbf\xef\x79\xfb\xc4\x53\xa0\x1e\x84\x95\x39\xbb\xcf\x56\xde\x11\xa1\x1e\x34\x53\x5a\xbf\xf4\xd5\x6c\x86\x7d\x89\x8a\xa2\x73\xbe\x3c\x37\x26\x9c\x4c\xb8\x19\x57\x24\x42\xe9\xf4\x12\xe3\x8c\x3a\x5d\x31\x9f\xcf\x15\x85\x02\x5b\x95\x49\xea\x12\x7a\xc6\x98\x0e\xa6\x7b\x64\xc9\x4d\x85\x19\x31\xc2\x04\x19\xd1\x88\x02\x34\x97\xe0\xa2\xf5\x2e\xab\x88\xe2\xb2\xec\xf3\xea\xfb\x4b\xf6\x90\xc6\x6b\x5b\x0a\x33\x80\x05\xd6\x28\xc6\x9d\x2e\xdc\xb6\x91\x02\xce\x22\xe8\x1b\x26\xb5\x6d\x4e\xaa\xe5\x06\x58\x76\x87\x0b\xa3\x10\xd0\xcc\x65\xed\x93\xb8\x6e\x7f\xc5\x30\x85\x5b\xb1\xbf\x08\xfd\xb6\x7b\xe3\xd4\xab\x4f\xbf\xe9\x76\x8c\xfe\xb6\x64\xc5\xf8\x8d\x27\x3e\x9e\x02\xfe\x58\x53\xf7\xe9\xdb\x6c\x86\x17\x95\xa7\x7f\xe7\x75\x1d\xef\x5f\xac\xa1\xbf\xd5\xde\xfa\xe2\x0c\x90\x78\x19\x03\xc0\x59\x36\x9d\x38\xfc\xd1\x0d\xf0\x29\xbd\xf2\x01\xb2\x77\x32\x3a\xf4\x77\x92\x7a\xb5\xc5\x54\x39\x6f\xc8\x84\x5c\x9c\xe3\x79\x93\xc7\x0d\x48\x8b\x3e\x6b\xb3\xdb\x7a\x65\xda\x6e\xb7\x38\xa1\x85\xef\x41\x16\xc1\xc2\xf5\xca\x16\x7b\xd1\x39\x1e\x0c\xf0\x41\x70\x3b\x81\x8e\x40\x23\x17\x19\x42\x34\x84\x07\xfa\xdd\xd7\xc1\x0a\x65\x1b\xb0\xbd\xb5\x78\x7a\x77\xf2\x78\x5b\xdf\x15\x57\xec\xa1\x1f\x63\xbe\xf5\x2a\xc9\x35\xfd\x7f\x77\x00\x97\x72\x66\x9b\x8f\x8e\xae\x01\xef\x79\xdb\xf0\xbd\x0c\x0f\x3c\xcb\x36\xb3\x3b\x51\x8c\xe5\xa3\x42\xd4\xb2\xdc\x08\xa4\xe9\x82\x01\xa7\x13\x7a\x74\x06\x03\xed\xf3\x04\x05\x2e\x12\xb6\x19\x0c\x46\xbf\x83\x35\xb2\xf8\x48\x42\x2f\x43\x59\x49\x71\xbe\x01\x9a\x8d\xd0\xe9\xa1\x3c\x3d\x48\x33\xd9\x71\xf3\x9d\x7a\x19\xf1\x6b\xa4\xdd\xa5\x61\x0b\xe0\x07\xca\xf2\x07\x33\x02\x08\xa1\x8b\x81\x7c\x7f\x56\x73\x56\x87\x7d\x78\xb4\x63\xc8\x56\x25\x1a\x75\x40\x6a\x4e\x81\x61\x95\x9b\xc0\x66\xd2\xa6\x05\xbf\x1e\xbd\x69\xf4\xed\xf3\x7d\x0d\xa3\x95\xef\xdf\xea\xff\x6a\x17\xf8\xeb\x55\xe9\x1c\xbd\x90\xde\x8f\x5b\xb5\x4e\x3b\x4d\xd9\xf8\x83\x01\x2a\x4b\xfb\x1b\x7c\x6d\x8b\x3f\x39\xc1\x5c\xf5\xd2\x8b\x00\xaf\xf7\x18\xe4\x3f\x7c\x86\x6c\xf2\x48\x6a\x6a\xae\x22\x4a\x35\xa5\xd3\x1e\x2f\xac\xb1\x50\xba\xd1\xa3\xa2\x4d\x30\x93\xc9\xb6\xcb\xb5\x19\xc1\x2c\x08\x86\xe9\xb2\xe0\x83\xa1\x76\xd9\x2b\x41\xfc\xb4\x9d\x2d\x7b\xfb\x2b\x8b\x89\xb5\x06\x77\x97\xca\x5e\xaf\xb6\x3c\xa6\x6a\x30\x34\x50\x11\x26\x41\x03\x2d\xd3\xf0\x40\xf2\x6d\xd7\xe8\x2f\xe9\xcf\x7e\xb3\xdf\x93\x88\x44\x52\xbe\x58\x25\x37\xd6\xdb\xb2\xe2\x96\xb6\xf0\xa8\x98\x6d\xb6\xb9\x35\x19\x3b\x77\xe4\x9c\x59\xd3\xaf\xdb\x7a\xc9\xd3\xdb\x96\x3e\xd2\x1a\x0e\x2c\xaf\x9d\x3c\x61\xf6\x86\x9b\xd6\x80\xca\x1d\xf7\xd2\x89\x19\xd3\x6a\xbd\x15\xee\x3f\x98\xd6\x3c\x38\xa5\x8d\x83\x4e\x16\x50\xeb\x63\xb5\x53\x4f\x69\x6e\xcd\x54\xdf\x7e\xee\x95\xb7\x06\x8e\x9d\x1d\x48\x8c\xcc\x36\x8e\x4f\x57\xdf\xac\xc5\xa6\xcd\xc8\x6e\x45\xa8\x71\xb9\x38\x6d\x32\x03\xa0\x37\x39\xd1\x05\xf0\xd8\xa7\xcb\x1e\x9f\x09\x1a\x0c\x48\x7f\xea\x0d\x3c\x30\x53\x94\x59\xeb\xa7\x50\x53\x3e\xd9\x92\xac\x55\x5e\xde\x6c\x79\x79\xb9\x2a\xa3\x2a\x79\x0d\xa8\xc5\x1c\xd1\xe9\x92\xf0\x74\x52\x53\x57\x2c\x3a\x2a\x9d\x4c\x71\x63\x6d\x23\xa7\xae\xec\xaa\x4e\xc7\xe7\x8e\x2a\xc6\xa9\xaf\x49\x4b\x67\xce\x9c\x88\x45\xa9\x99\x39\xbf\x6b\xf2\x78\x72\x2f\x76\x20\x05\x08\xd9\x7b\x50\x2c\xdd\x92\x8b\x18\xac\x22\xcb\x5a\x3d\xd0\xeb\xe3\xf5\x3d\x32\xcf\xa3\x23\xa6\xf5\x11\xe1\x2e\x16\x0f\x5d\x06\x62\x5b\xde\x5f\x57\x5f\x27\xe6\x6b\x0c\x34\x8f\x07\x17\xc8\x0b\xe4\x88\xed\xd8\xf7\xe6\xbf\x4e\x3c\xbc\x0f\xa7\xd7\xce\xbb\xf6\xf2\xf7\xaf\x5b\x11\x98\xc7\x76\x4f\xfe\xf0\xad\x7d\xff\xac\x56\xc6\x10\x6d\xf6\x6f\x0b\xff\xf4\xe3\xa0\x63\xea\xad\x64\x4e\xa3\xd1\xc5\x58\x44\x30\x2a\x46\xe5\x82\x1e\x5a\x27\x49\x34\x0f\xfd\x01\x37\x84\x14\x6f\xb7\x1b\x3b\x64\xbb\xe0\x51\x3b\xf2\xa5\xd2\xbc\x1f\x09\x5f\xcb\x16\x4f\x9d\x44\xa1\x84\xbd\x64\x82\x4f\x9f\x31\xe3\xcc\xd3\x96\xae\x6c\x59\x1a\x48\x4c\x7a\xe0\xd7\xef\x7c\x71\xc3\x96\xa5\xad\x6e\x10\xe6\xc5\x8b\x2e\x5f\xbe\xc4\xe7\xd8\x05\xf8\xcc\x7d\x5b\xce\xdb\x18\x53\xfe\x49\xc8\x9f\x20\x15\x1a\xf8\x91\x0d\x10\xfd\x91\x40\x91\xe7\x19\xb9\x26\x4b\x32\x28\x66\x62\x1e\x0f\x2d\x88\x49\x9a\xa9\xab\xad\x24\xfc\x82\x2a\x0a\x7b\x8c\x15\x32\xd1\x4c\xb4\x57\x46\xea\x37\x43\x19\xa0\x4f\x85\x63\x77\x15\x19\x07\xf3\x4d\xe0\xc4\x45\xce\x0e\xe9\x48\xc9\x16\x24\x68\xd4\xf4\x4a\x19\x4e\xad\x28\x39\xf3\x3d\x2a\x52\x44\x12\xf3\x0d\xe3\xd1\x87\xf7\xed\x7b\x18\x45\x02\xa5\x28\xb5\x7f\xc3\x18\xb6\xd7\x6c\x7f\x18\xd8\x66\xa8\xb8\xb6\x6d\xbe\xc3\x6b\xe0\x30\x6f\x5b\x09\x48\x2d\xa8\x7a\x9a\xbb\x61\xeb\x35\x57\x7d\xba\x86\x3e\x44\x00\x6d\x91\xed\x20\x6f\x09\x48\x5e\x3f\x92\x77\x56\x2e\x63\x8f\xc5\x4c\x3a\xe4\x2f\x78\x01\xd0\xa5\x92\xf9\x97\xfb\x28\x65\x30\x1a\x7a\x65\xaf\xdd\x68\x64\x9c\x56\xc8\x04\x16\xca\x8c\x58\x4c\x69\x69\x35\x57\x85\x86\xd1\x42\x6f\xab\x7a\x97\x25\xd2\x1f\x47\xd8\x72\x07\xbd\xda\x93\x6a\xaa\xd1\x38\xca\x76\x32\x27\xf2\x4d\x72\xb7\xe2\x36\x39\x7a\xcd\x01\x70\xf8\xd6\xed\xfd\x8f\x6e\xdb\xd5\xbf\xe1\x5e\x7a\xc3\x93\xb8\x4b\xee\x97\x44\x9b\xb6\x21\x15\x9b\xff\xf7\x9a\xfe\x6f\x77\xdf\x7b\xf0\x99\xbb\xfb\x48\xec\x83\xae\x1a\xbb\x8f\x9d\x6c\xe7\x60\x3b\xd9\xcb\xd8\xc0\xd5\xcc\x17\xc4\x2e\xa6\x90\x65\xbc\x26\x37\xd5\xc6\xbb\x3c\x62\x45\x3a\xe6\xf7\x73\x5c\x45\xc2\xe1\xe1\x23\xba\xaa\x8c\x3d\x65\x48\x21\xd9\xa4\xca\x58\x65\xaf\xec\x16\xd3\xd5\x31\x80\x7e\x54\x88\xd1\x06\x2e\x16\x63\x04\x8b\xc9\x80\x37\xdc\x00\xc3\x0c\xe3\xef\x95\xb1\x37\x40\x53\xd8\x1f\xc8\x1e\xca\x14\x9c\x21\xe1\x50\xb6\x80\x48\x38\xa2\x64\x39\x4e\xaa\x90\xb1\x6b\x80\x17\x40\xd5\xc7\xb5\x00\x66\x49\x6e\x25\x06\x25\x35\xb9\x82\x3c\x86\x54\xcc\xd6\x1c\x03\xd7\x8d\xbc\xfa\x94\x8f\xfa\xfa\xa0\x3c\x6e\xe3\xb8\x9f\xcf\x0b\x77\x7e\xbc\x0e\x27\x56\x7e\xf5\x60\x3e\xb1\x52\x37\xe7\x93\x9c\x12\x8b\x5d\x7e\xb9\x9a\x52\xb9\xfe\x7a\x65\xcf\xbb\x3a\xc5\x87\x93\x2a\xca\xce\xbb\x70\x56\x85\xfe\x08\x7c\x06\xfa\xe5\xa9\xaa\xff\x33\x51\xb9\x1f\xce\x65\xad\xe8\xbe\x45\xa9\x24\x55\x41\x5d\x9a\x6b\x4d\x21\x67\x83\xa5\x2b\xc2\x86\x84\xc3\x25\x39\x63\xa1\x78\xdc\xe3\x71\xba\x12\xe1\x08\xcd\x58\xf5\xc6\x4c\xa5\x21\x19\x4a\x76\xc8\x15\x71\x7b\x3a\x14\xa2\x5c\x4e\xbb\xc3\x6a\xb7\x9b\xbb\x64\xbb\x93\xf2\x77\xc8\x2c\xa4\x31\x81\x49\xc3\xa1\x6c\x91\xc7\x48\x78\x9e\xb4\x20\xda\x47\x9c\x54\xfe\x92\xac\x6e\x83\x0b\x19\x54\xa7\x4d\x8a\xc0\x42\xcf\x73\x0a\xc6\x44\xcc\x92\xef\xc2\x49\x16\x31\x09\x5d\xcd\xb1\xe6\x94\x0e\x7c\x19\xa9\x3d\x7f\xc5\xe5\x4f\x2a\xbb\x7a\x4f\xb9\x91\x54\x9c\x2e\x9a\x7a\xf1\x8a\x0d\x4f\xe1\xaa\xd3\x29\xbd\xd2\x36\x3a\x91\x3a\x4a\xc7\xe1\x73\x2c\xe8\x54\xb6\x9f\xaa\x1c\x9e\xae\x7c\xde\x85\x4b\x50\x25\x65\x17\xb8\xfa\x2c\x30\x91\x14\xa2\x02\xc9\xae\x34\x54\x9f\xb9\x7c\xe9\x52\xa4\x77\x30\x9f\xdf\x61\xd2\x17\x3d\x3a\x17\x02\x92\x64\x08\x05\x7d\x4e\xb7\xb3\x47\x06\xa2\x43\xec\x95\xfd\x0e\x07\xeb\x86\xac\xb5\x57\x36\xe0\x5a\xcb\xff\xe2\x1b\xc4\xa4\xc1\xe0\x3d\x25\x50\x60\xf0\xf0\xad\x65\x50\x81\x7d\x7d\xf4\x5a\x74\xb6\xaf\x7b\xaf\x04\x21\x10\x5c\xb8\x06\xbc\x4d\x8e\x72\xa5\x56\x9f\x74\xbd\x86\xf7\x3d\x39\x97\x08\x03\xab\x35\xa5\x4b\x06\x62\x33\xb0\x83\x9a\x27\xb9\x66\x24\x49\x44\xce\x3a\xcf\x98\x3a\x65\x1d\x53\x12\x22\x15\x71\xbe\x85\x43\x04\xd2\x56\x6b\xff\xb4\x95\x87\x4d\x45\x84\x2a\x58\x84\x30\x71\x96\x46\x52\x67\x9f\x8d\x62\xa9\xb3\x16\xcb\xb9\x5c\xb7\x3c\xb6\xa5\x1b\xec\x53\x0a\xcc\x49\xe0\xdf\xcb\x40\x5d\xb4\x55\x39\x6b\x19\x1c\xaf\xfe\xad\x8c\x74\x48\x9b\x32\x81\xfb\x9e\x9d\x46\x99\x48\xf7\x55\xdc\x20\x8a\x71\xe8\x8b\xfb\x32\xe6\x2a\x47\x04\x39\x9e\x41\xaa\x57\x0e\x32\x2e\xe4\x6d\xb9\xc4\x4a\x9e\x4f\xf6\xca\xfc\x10\x84\x15\x3b\xc1\xcb\x2b\x05\x19\x2a\x41\x83\x01\x36\x62\x07\xd5\x67\x90\x02\x02\x20\xba\x34\x0e\xe2\x79\xc2\x99\xff\x78\xf7\xc8\x1f\xa7\xec\xac\x59\x05\xdd\xbd\x77\x9c\xff\xfa\xf2\xe4\x9d\x67\xff\x49\x79\x72\x3f\xd8\x04\x2e\x38\x77\x6b\xe2\xfd\x53\x36\xc5\x46\x0a\x09\xe6\x2f\xca\xdf\x94\x23\xca\xe7\xca\xd1\x84\x8f\x11\xeb\x7f\xbc\x41\xf9\x77\xf0\xc2\x83\x97\xc7\x6d\xe1\x7b\x40\xf6\x35\x30\x1b\x2c\x75\x73\xfc\x8f\xd9\x83\x5e\xf7\x26\xec\x53\xd7\x2a\xd3\x98\x8f\x50\x1c\x65\x44\xba\x63\x72\x2e\x2e\xb0\x6c\x98\x72\x85\x5d\x69\x53\x85\x3d\xe0\x08\x7a\xbd\x7a\xc2\xeb\x03\x3b\x65\x87\x33\x69\xb1\xc4\xb4\xae\xd6\x52\x99\x84\x43\xb6\x21\x42\x95\xbc\xd4\xa8\x6b\xaf\x45\x48\x48\xd0\x10\xc0\x02\xa9\x20\x0f\x60\xe6\xa2\xde\x49\x33\xba\xa6\xcd\x5f\x0c\x6f\xec\x99\xfa\xd8\x11\xfd\xf2\xbb\x7f\xfb\xdc\x57\x6f\xb6\x6e\xae\xbf\x78\x79\x63\x4b\xd0\x91\xc9\x81\x97\x0e\xfc\x1a\xc7\x7c\xaf\x1f\x7f\xcd\xfe\xca\xa3\xf5\xc3\x27\xff\xf0\xe5\xa7\xc0\xe8\x37\x8c\x38\x7e\xe8\xe2\x95\x8e\xd5\x1a\x8e\x09\x7e\xef\x26\x79\xfd\x08\x75\x5a\xae\xc1\xe5\x70\x8b\x1e\x5b\x10\x00\x8e\xb3\x89\x48\x27\x47\x5d\x76\x51\x05\xbc\x0b\x12\xa8\xb3\x00\x72\x87\x4d\x3d\xb2\x05\x3a\xca\x83\x9e\xac\x86\x9a\x99\x3f\x5f\xe5\x99\x75\x4d\xb2\x72\xfc\xb3\x3c\x82\x49\xc4\x50\x40\x39\xa1\x4d\x18\xc2\xe4\x81\x07\xfa\xe8\x75\x1a\x84\xc9\x19\x5b\x95\x76\xe5\x3a\xa0\xbb\xec\xbe\xcd\x5b\x6f\xbb\x8a\x1e\xae\x54\x11\x1f\xe1\xcd\xb3\x69\x64\xb6\x08\x8a\x89\x22\xf8\xda\xe8\xe1\x60\x33\x01\x3a\x51\x73\xe3\xe4\x4d\x1e\xbe\x84\xec\xd5\xdc\x5c\xb5\x97\x47\xc2\xd0\x22\xb0\x30\x22\x17\x0c\x78\x78\xa7\xd3\x2e\xa8\xe0\x6d\xde\x02\x78\x1b\xff\xdf\xc0\xdb\x70\x3f\xb7\x66\xb2\x08\xf3\xaf\x76\x63\xca\x64\x71\x8d\x01\x23\x91\x0f\x9d\x42\xa1\xbc\x84\x0c\xd6\x1f\xb7\xf7\xbf\xb6\x06\xfd\x03\x36\x99\xce\xda\x33\xa9\x69\xf8\xc8\x96\xbb\x46\xaf\x07\xf7\x28\x4f\x10\xe2\xbd\xc9\xcb\xc0\x64\x77\xeb\x73\x17\x2f\x57\x1e\xbc\xa2\x39\xb1\x69\x19\xd9\x07\x92\xc3\x23\xfa\x26\x4c\x9d\x9a\x4b\x07\xf5\xfa\x68\xc4\xe7\xb4\x8a\x82\xd8\x23\x87\x81\xc9\x6c\xc2\x3a\x27\x88\xdd\x7c\x33\xe7\x16\x20\xd4\x73\xfa\xd2\x77\x16\xac\x50\x5d\x23\x86\x18\x59\x15\x46\x09\x6a\x93\x45\xb1\x49\xb6\x16\x73\x0f\xeb\x5c\x91\x66\x15\x18\x2f\x0b\xc4\x08\x7b\x97\xf2\xde\x67\xb8\xb5\xfb\x07\xe5\xa5\x63\xdd\xb8\xbb\x7b\x36\xd8\x37\x73\x17\x38\x7c\xc3\xec\xbf\xf7\x1f\xf8\xb9\x72\x04\x1e\x54\x3a\xf2\x1d\xde\xe0\xf1\x35\x77\x62\x65\x74\xa7\xfa\xbb\xb2\x12\x78\xc8\xfc\x49\x4e\x11\xf9\xba\xd8\x66\x74\xe4\x2a\xe2\xae\x74\x05\x53\x99\xa9\x00\x0e\xc9\xd1\x21\x27\x02\x92\xe4\x49\xd9\xe9\xca\x78\xc8\xe5\xf7\xf8\xdb\xe5\x88\x87\xe7\x2c\x9d\xb2\x81\xcb\xeb\xa6\xfc\x9c\xb3\xda\xcb\x43\x49\x4f\x34\xd6\xa1\xb0\xbc\xb9\x1b\xc6\x0a\x82\x64\x0b\x82\x34\xc7\xe0\xe7\x2f\x7c\x93\xeb\xbd\xa0\xb4\xbb\xfb\x7f\x7e\xbf\x53\xc6\xfd\xdd\x73\x4e\x74\x9c\x0d\xb2\xe3\x67\xdf\xa6\x5c\xd8\xf1\x20\xed\xed\xdf\x73\xef\xcd\x85\xee\x6e\xba\x79\xd9\x1f\x70\x7f\xf7\x6b\xf8\x77\xc7\x9b\xca\xa1\x3f\x22\x79\x42\x48\xff\x3f\x0d\x0f\xa2\x33\x94\xa4\xe6\xe5\xea\x03\x3a\x51\xa4\x23\x16\x0b\xed\x81\xa9\x34\x95\x06\x21\x68\x8c\x77\xc9\x46\x21\x60\x6f\x97\x75\x01\xd6\x1d\x70\x07\x28\x96\x90\x2a\xf0\x94\xd4\x3e\xb4\x7f\x02\xf7\xf4\x0d\x2e\x51\x56\xbb\x28\x54\x9c\x06\x97\x96\x20\xc2\x6f\x08\x92\x43\x45\x71\xb1\x02\x98\x77\x59\x75\xe0\x2f\xca\x9d\xa7\x81\x6e\x67\xfb\x15\xb9\x1b\x7f\x3e\x7b\x57\xdf\x9a\x4d\x33\x97\x25\x5b\xb7\xdf\x70\xdd\xcc\x05\x1d\xa3\xea\xc6\x77\x3a\x00\x43\x2f\x72\xb7\x4e\x6e\x4c\x5d\xbf\x69\xc5\xda\xd1\x0c\xdc\xf8\xd0\xb0\x0b\x3e\x72\x99\xc1\x3f\x21\x3d\x7f\xe5\xac\xce\x58\x1e\xdf\xfa\x4c\xe4\x4b\xf3\xc8\xba\x8f\xcb\x45\x9d\x3a\x9f\x19\x42\x5e\xc7\xfb\x03\xd0\x4c\x5b\x78\xa3\xd8\x89\x24\x62\x3d\x5d\x32\xeb\xa4\xf9\x76\x99\x1e\x84\x6d\x6d\x1f\x31\x08\x2e\x3f\x21\x45\x52\x1c\xc6\xfd\x41\xaa\xc9\x85\xcc\x45\xc9\xeb\x63\x33\x73\xa6\x72\xb9\x7d\xf5\x63\xca\xbd\xaf\x3f\xb1\x7f\x0a\x88\x28\x1f\xf4\xce\x98\x33\xb3\x6d\xe6\x9c\x15\xad\xad\x0b\x56\x83\x77\xbf\x05\xe6\x33\xa7\x9f\x78\x04\x6c\x7b\xf0\xd9\xb7\x9e\xdb\xf5\x68\x8f\x8a\x89\x33\xf0\x09\x33\x11\x3e\x8b\xe6\xe7\xc5\xf3\x13\xa0\xc5\x62\x75\xea\xac\x3a\x9f\xdf\x0c\x81\x55\x22\xf3\x73\xb2\x6e\x34\x3f\x01\xa0\xf9\x01\xfe\xa7\xe7\x67\x53\x39\x2b\x22\x2e\x9c\x66\x25\xf9\x24\x14\xa0\x6b\x18\xa4\x38\x91\x54\x03\xae\x46\xb3\x03\x0b\xf0\xec\x94\x0f\x40\x04\xcf\xee\x8e\x05\x8b\xe1\x0a\x34\x3b\x25\xf5\xad\xf2\xed\x99\xd3\xe1\x74\x65\x05\x9e\x1d\x98\xd3\x53\xe0\x68\xb8\x87\xd8\xdd\x5c\x2e\xaa\x8f\x44\x44\xaf\xd5\x4a\x89\x30\x99\x72\x31\x9d\x32\xe5\x02\x7a\x9b\xc9\x16\xeb\x90\x6d\x4e\x53\xa0\x13\xd7\x69\x97\x90\x33\xb4\x64\x33\x43\x30\x52\x30\x06\x72\x19\x8f\x86\x8a\x52\x55\x92\x0f\xa4\x77\x12\xa0\xaa\x12\x92\x01\x0c\x53\xd5\x5b\x64\xd3\xd8\xbb\xd2\xfd\xd9\xb9\x05\x96\x01\xf8\x8f\xdf\xbd\x2c\x9e\x38\xbd\x40\xa6\x41\xb0\x2b\xe0\x24\x12\x3b\xd5\xe4\x5c\x4e\xce\x4c\x71\x54\xc0\x6f\xb4\x77\xc8\x16\xa3\xd3\x07\x21\xda\x68\x82\xe5\x57\x88\xaf\x0b\x64\x03\x62\xe1\x34\xaa\x24\x92\xd8\x71\xc9\x9f\xc4\x6c\x1e\xc1\x7e\xf3\x7d\x93\x2b\x43\xe3\x86\x6b\xb8\xf6\xf0\x12\x0d\xb8\x3e\x06\x9c\xf7\xb9\x9c\x2a\x98\x3d\x5a\xb7\xb1\x03\x0f\xc3\x76\x34\x87\x08\x95\xa1\x2a\x73\x4e\x3a\x31\x1d\x79\x03\xb4\x5e\x92\x02\x1d\xb2\x47\x12\xf4\x15\xd3\x0b\xc9\xe6\x6c\xe1\xb1\xe0\x64\x59\x65\x15\x57\xbf\x88\xb9\xaf\xf2\x5e\x92\xe4\xf2\xf2\xd3\xcf\xb8\x6a\xe7\xde\x5b\x7f\x75\x6e\xc4\xb9\x54\x1c\xd9\xa6\xcd\x4d\xc5\xdc\x07\x67\xc9\xd3\xe7\x9f\xda\xb0\x65\xf2\x14\x70\x43\xf6\xaa\xc5\xab\xd6\xf6\x8e\x9b\xbf\xf1\xdc\xf3\x7f\x83\x67\xaa\xfc\x4b\x85\xdd\x57\x3e\xaf\x1a\x51\xb5\x25\x4b\xce\xe0\x0c\x65\x22\xf3\x1d\xf2\xaf\x8c\x2a\xda\x0c\xe5\x0e\x05\x58\x9b\x2d\xee\x8e\x57\x9a\x32\x1a\x31\x3a\x32\x1d\x3e\x41\x42\x66\x5d\x72\x56\x58\xad\xc9\x4e\xd9\x7a\x12\x30\xb8\x82\x4d\xcf\x0e\xb1\xea\x24\x57\x71\xb2\x7a\x0d\x72\xef\xc1\xc5\x85\xca\x8b\xcb\x5b\x17\x3f\xf1\xdc\xe8\x65\xb9\x62\x7d\xc6\xe2\x94\x3b\x00\x8e\xe6\x6b\x2d\xee\xfc\xab\xf8\xca\xc1\x05\x69\x7f\x49\x41\x46\x72\xc0\xbd\x92\xca\xdf\xf5\xef\xd0\x79\xc5\x78\xf0\x93\x73\xc9\xb8\xc7\x65\x32\xe9\x42\x76\x9d\xbd\x92\xca\xf8\x31\xd0\x9a\x1f\x48\x29\xe4\x23\x0a\x7c\x14\xc3\xac\x19\x75\xed\xb2\x71\xd0\x7d\xcf\x66\x4a\x3d\x93\x22\xd8\x06\xa1\xa6\x29\x83\xb5\x57\xff\x55\x8a\x68\xff\x1d\x39\xba\x4b\xcb\x71\xed\xf1\xf1\x3d\x71\x75\x5e\x3c\x02\xb4\x86\x89\x6c\x0a\xe0\xf6\x55\x2d\x18\x66\x6d\x5a\x19\xae\x7d\x23\x39\xc3\x6a\xff\xda\xa4\x5c\xca\x6b\xf7\xd9\x6c\x10\x1a\xec\x30\x18\xd2\xfa\xd7\xbc\xe8\x40\x7b\xbd\x1c\xc5\xa1\x98\x83\x73\x92\xee\xb5\xb2\xcb\x37\x18\x4b\x9d\xd0\x23\x6a\x4e\x79\x23\x21\x3e\x20\x6d\x6c\x28\xa2\x40\xa7\x2a\x3b\x2c\x09\xee\x7c\xeb\xc8\x9f\x3f\xed\xfa\x65\xf3\x86\xb9\x3d\x67\xd6\x29\xe2\x43\x2f\xa7\x32\xb6\xf7\x4e\x81\xcf\x7d\xf3\x7d\xff\xb1\x4c\xe4\xd4\xc0\xb8\xb5\x37\x0b\xd3\xdf\x7e\x75\x49\xd3\xaa\x75\xbb\xae\x1e\x3c\xc7\x79\xb9\x66\xdc\x63\x27\x7a\xcd\x85\x1e\xbb\x96\x50\x47\xa8\x27\x74\x63\xe8\xce\xd0\xde\xd0\xeb\x21\x83\xe9\xff\xda\x71\x97\x2d\xd8\x8a\xff\xde\x71\x77\xe7\xff\xa1\xe3\x4e\xed\xa9\x46\x71\x3d\x83\xe6\x1d\xa7\xaa\xa9\xa5\xb9\x26\xa6\x3a\x00\x93\x66\x7b\x14\xba\xab\x2d\x66\x5d\x6d\x8d\xc5\x6d\xf6\x25\x98\x24\x84\x3e\x9f\x33\x69\x8e\xa0\xe0\x6e\xba\x6c\x0e\x85\x0c\x76\xa7\x53\xe8\x92\x9d\x82\xa1\xb2\x43\x36\x94\x80\x43\xdb\xd5\x87\x3e\xad\x64\xa0\x36\xab\xb5\x0b\x8e\x18\x84\x98\x90\x6c\xcc\xe3\x52\xa6\x40\x41\x92\x30\x32\x80\xcd\x2e\x6c\xf9\x9a\x5d\x56\x90\xd0\xa9\xdc\x94\x8d\xcc\xf0\xa5\xab\x7d\xe2\x91\xb7\x1e\xdf\xa3\x03\x1f\x9b\x2f\x5e\x45\x44\x03\x55\x8b\x6a\xdc\xd6\x05\xab\xe7\x34\x35\x98\xce\xe9\x7f\xf0\xa8\xbd\x32\x35\xe6\x14\x70\xfb\xcf\x2e\xb5\x4e\x5f\xf1\xfd\x37\xbf\x79\x09\x50\xe7\x2c\xc1\xd2\xbe\xee\x71\xb9\xad\x2d\x2f\xae\xac\x9f\x73\xce\xe2\xf3\xb6\x9e\xdf\xb4\xf1\x17\x38\x17\x89\xec\x7a\x1b\xd2\x47\x19\x6a\x61\x6e\xb8\xd3\x10\x85\x69\x3e\xc0\x19\x20\x57\x5d\xe5\xe1\xc2\x30\xe8\xf3\x05\xbb\x64\x9f\x8f\x32\x9b\x51\x00\xf5\xbe\x00\xbc\xc2\x43\x02\x0d\x79\x01\x98\x59\xc1\x2c\xa4\x29\x82\x0a\xe1\x2c\x28\x4d\x12\xcc\x2f\x28\xa9\x4c\x2a\x43\x98\x63\xc9\x05\x69\x6e\xd4\xee\x87\x4e\x05\xd9\xc1\x29\xc8\xa6\x91\x18\xd5\x22\xa5\x55\xea\x10\x34\xea\xcf\x5f\xfe\x68\xe5\xc2\x27\xfe\x7a\xe4\x91\x4b\xc0\xe4\xd8\xa8\xa5\xb3\xe6\x8d\x6a\xb8\xb8\xa5\xae\x2e\x7c\xf7\x79\xe7\x9d\xd3\x7d\x59\xfd\x88\xc7\x1c\xb7\x6c\xee\xbd\xc4\xa1\x1b\x7d\xfb\xb9\x97\xc4\xbf\x58\x5b\xd3\x3e\x65\xc4\x4c\xc1\xbc\xce\x9a\xda\x30\x47\x0e\x8b\x9d\x99\x61\xaa\xef\x1b\x45\xf2\x55\x13\xf9\xa6\xe6\x2a\x9c\x31\x63\x45\x45\x2c\xc9\x07\xb0\x7c\xe6\xa4\x08\x05\x5e\xe0\xc9\x89\x0b\x84\xc3\x9e\x0e\x39\x2c\x50\xba\x2e\x99\xc1\x02\x35\x0c\x86\xf0\x1f\x2c\x49\xaa\x51\x4b\xaa\xa6\xb8\x0c\x68\x24\x14\x27\xf9\xe2\xc2\x94\xaa\xac\x75\x12\xa9\x42\x02\x6b\xcf\x79\x6c\x44\xfd\x65\xdd\xe7\x9c\x77\xde\xdd\xe1\xba\xba\x96\x8b\x1b\x46\x75\xcf\x5e\x3a\x2a\x36\x19\x5c\xf2\xc8\x9b\x1f\x3c\xd1\x7b\xf6\x87\x8e\x61\x99\x4e\x31\xdc\x3d\x7b\x43\xca\xba\xce\xcc\xcf\x1a\x31\xa5\xbd\x66\xed\x17\xf1\x35\xab\x6f\x1f\xad\x73\x5c\xd2\xbb\x69\x9b\x26\x07\xf3\x34\xc9\x19\x2f\xce\x0d\x37\xba\x62\x75\xc3\xe0\x08\x58\xa7\x73\xf9\x2b\x05\xfd\xe8\x51\x4d\xe8\x28\x86\x39\x0f\xf4\x07\x02\x7e\x64\xc5\xea\xea\x02\xd5\x4d\x81\xa6\x80\xa5\xb2\xba\x3a\xd9\x21\x57\x0b\x16\x47\x97\x6c\xb3\x38\xcb\x98\x09\x34\x37\x8c\xb4\xf9\x51\xae\x41\x75\x9e\xe4\x58\x72\x9a\x04\xb1\xff\x5d\x5a\x57\x0b\x28\x9c\x56\xf8\xcd\xd2\xd5\xe6\xd0\x16\x24\xd8\xab\x3f\x2d\xf9\x53\x1f\x48\xb6\xfc\x99\xc5\x67\x55\xb7\x38\xab\x0a\x7b\xd2\xb5\x58\x38\xdf\xe3\xd3\x8e\x2e\xba\xa7\xe3\xd1\x9e\xe2\x37\x6d\x17\xda\xd5\xee\xdc\x30\xc9\x60\xf0\x45\x83\xa1\x10\x0f\xd3\x69\x3e\x0a\xab\xab\x82\x82\x99\xe7\xc5\x8c\x30\x52\x98\x2a\xe0\xb3\xda\x22\x74\x08\x03\x02\x14\x04\x37\x97\x70\x4e\x46\x8b\xe9\xc6\x6c\xca\x0b\x48\x90\xb0\x60\xf5\xea\x6c\x16\x53\x03\x94\x03\x68\xaa\x6b\x50\x84\x0b\x4c\x61\x44\x44\x4c\x16\x8b\xff\xac\x66\x4a\x0b\x6b\x83\x4d\x31\xf8\xfa\xb6\x47\xf6\xdd\xba\xfc\xea\x55\xbd\xd9\x55\x95\x95\xe1\x4b\xde\x5b\xbb\xf2\xae\x5f\x9d\x33\x63\xce\x99\x8f\xdd\xfd\xc6\xd1\x65\x07\xe9\x23\xeb\x2f\xbc\xe0\x9a\xc6\xda\x9a\x61\x2c\x63\x58\x67\x32\xcd\xac\x1e\xf6\xcd\xcf\xd7\x75\xac\xe2\x75\xe6\x8b\x66\xaf\xbf\x49\xf9\xea\xb6\xf7\x2f\x20\xe7\x75\x20\xa4\x4c\xa4\x6f\x27\x38\x32\x38\xcf\x62\xb7\x87\x0c\x24\xcf\xd2\x41\xf2\x2c\x5d\x6a\x9e\x85\x67\xad\x28\x56\x60\x7d\x27\xcb\xb3\xa8\x39\x0c\xe4\x8b\x0e\xce\xb3\x94\xe6\x12\xb3\xf4\xed\xbb\x4b\xf3\x2c\x2f\xbd\x84\xf3\x2c\xbb\x9b\xaa\x4a\xd2\x2c\x87\xd7\xd0\x3b\x08\x78\xd5\x52\xcd\x0f\x98\xc0\xfc\x1b\xd9\xcf\x14\x95\xa5\xa6\xe7\xaa\xea\xbd\x95\x61\x49\xe2\x38\x8b\x17\x0e\x4b\x35\xc6\x91\xf1\xa7\xe2\xc0\x19\x76\x07\x02\x35\x9d\x72\x40\x70\xa7\xbb\x64\xb7\xd3\x88\x82\x01\x8b\xb1\x90\x6e\x29\x6a\x73\xcd\x94\x96\xa2\xcf\xa9\x86\xd4\x41\xde\xc3\x8a\x53\xce\x7b\xd3\x4e\x97\xf6\x6c\x01\x1a\x54\xf8\x64\xbc\x33\xcc\xe3\xd8\xa6\x5e\xad\xfc\x70\xc7\x95\xb7\xb4\x66\xc2\x67\x67\xae\x59\xa5\x3a\xd8\xb3\x2f\xaf\xc0\xa0\xe6\xfd\xc1\x39\x2b\x88\x97\x4d\x2c\xeb\xf1\x43\xeb\x0e\x9d\x13\x07\xd6\xfb\x1d\xbe\x07\xf7\xf7\xaa\x2e\x77\xfd\x29\x04\xde\xfc\xf8\xaf\x7b\x40\x4a\x75\xbc\xf3\xb2\xc2\x7f\x13\x3f\x31\x85\x6c\x6c\x22\xe8\xe1\x79\x2a\xe1\x70\x70\x14\xac\x48\x0b\x1e\xbb\x97\x77\x21\x1f\xc1\x25\xd8\xfd\x38\xa9\x87\xd9\x63\x4a\x72\x4a\x65\xbe\x77\x69\x5c\xf3\x53\xa2\xb9\x9a\x23\xa5\x42\xc1\x7f\x9f\x44\xa0\x5f\x4e\x11\x80\x5d\xc9\x8b\xc3\x0e\x15\x04\xc5\x0e\x4f\x97\xca\x00\xa8\xd5\x48\x5f\x34\x11\xfe\x9b\xd6\x5c\x54\x64\xdd\x14\x65\x66\x61\x28\xac\x81\xcb\x5b\x7c\x16\x5a\xaf\x17\x3a\x64\xbd\x40\x3b\x8b\xb5\x96\x45\x63\x5b\x9a\x87\x44\x87\x89\x8b\x44\xe9\x46\x75\x23\xa4\x82\xd6\xc6\xdd\xd0\x2a\x86\xf8\xbf\xf6\x0f\x50\x47\xbe\xfd\xee\x6f\xf3\x6e\x5b\x39\x39\x31\xbd\xf7\x8a\x8b\x56\x9c\x9e\x1d\xd6\x0b\x5e\x9d\x56\x95\x03\xe0\x6f\xc7\x00\xeb\x4e\x9c\xb8\x29\xf7\xc2\x8b\x4f\x1d\xf2\xfc\x93\x10\xf5\xd1\x14\x85\xce\x13\x85\xce\xb9\xa4\xf2\xc2\x78\x59\x4a\x6f\x71\x43\xa7\xe0\x70\xd8\x9c\x6e\x3d\x6b\xd4\x05\xfc\x6e\x9e\x31\x49\x82\xc1\x6a\xb2\xb6\xcb\x76\x13\xcf\xf8\x3a\x0a\x8c\x24\xc5\xce\xb7\x11\x43\xd2\x2a\x09\xbb\xd3\xc5\xa6\x90\xf9\x54\x21\xcf\x7c\x1a\x76\x5b\x12\x39\xce\x2e\x7a\x79\xf7\x64\x93\x32\x76\x34\x3f\xbc\x59\x41\x61\xd8\x87\x4b\x9e\x3a\xbe\x18\x64\x3b\x94\xc9\xfa\x78\xd6\x64\x7a\x78\x80\xea\xef\x35\x05\x96\xec\xbb\x14\xf6\x12\x80\xb3\xaf\x68\x11\x87\xc0\xc7\xe7\xce\x5a\x7c\xc1\x38\x1d\x39\x1b\x55\x48\xf7\x7c\x8a\xe6\xed\x40\x31\xd9\x98\x5c\xc4\xe5\xb0\x19\xa1\x04\x38\x00\x1d\x56\xd6\xef\xf3\x18\x29\xb3\x8e\x77\x49\x94\x84\x2e\x44\xde\x8b\x29\x16\x44\x94\x23\x2e\xb2\x29\xe4\xc7\xe3\xb0\x1d\xd9\xbf\xe6\xac\x84\xd4\xad\xd3\xee\x4a\xb8\x30\xb9\x05\x98\xd5\xe5\x5e\xdf\x71\xc7\xcf\xc0\xa5\x0b\xc7\x76\x5e\xfc\xce\x2f\x16\x2e\x6d\x99\xe9\x57\xe6\x58\xce\x76\xf8\x46\x3a\x02\xf7\x7d\xba\xf7\xdb\xfa\xd6\x5b\x2e\xb9\x60\x47\x6b\xcd\xa5\x37\x5f\xa5\xfc\xf0\xc8\x22\x1d\xb7\xbc\x6b\x35\xc1\x53\x54\xa6\x31\x39\xa2\x3f\x26\xe6\xe2\x22\x1d\x08\x78\xad\x3a\xaf\x2e\x14\x0c\x78\xdb\xe5\x80\xcf\xe3\xb0\xe8\x8d\x7a\x14\xca\xb2\x4e\x23\xcf\xda\xa6\xcb\x6c\xb1\xca\x56\x5d\xd2\x21\x95\xe1\xec\xb0\xe6\x02\x7a\xa2\xd6\x34\x98\x6f\x24\x44\x6e\x2f\xfd\x0c\x37\xfe\xc6\xd5\x18\x33\xf1\x88\x0a\x5e\x0e\x8e\xcc\xef\x55\xd6\x4e\xc1\xfc\x14\x2a\x52\x62\xab\xbb\xff\x0d\x0d\x2b\xb1\xd5\x7d\x7c\x26\x79\x32\x52\x73\x52\xcc\x4c\xa4\x4f\x92\xd4\xac\x5c\x75\xd0\x6f\x30\x58\xe9\x78\x5c\xb2\xaa\xd9\x04\x01\x06\xcd\x91\x08\x37\x1d\x73\xfc\x79\x3a\x65\xa7\x1d\xc4\x0d\xb4\xd5\x8c\xce\x01\x65\xd6\x48\x10\xc8\x54\x8b\x69\xdc\x21\x79\x84\xc1\x38\xeb\x25\x2c\x08\x01\x90\xe7\xe0\x70\x49\xf4\xba\x02\xe6\x7a\x81\x07\x41\x65\xdf\x38\xad\xd5\x4d\xd7\x16\xea\x89\x0a\x3c\x08\x2d\x2a\xf3\x46\xff\x43\x44\x10\x82\x19\x0f\xbf\x47\x72\xd4\x50\x3d\xb9\xc6\x8a\x94\xc3\xe1\xb1\x50\x14\x32\xc5\x4c\x6d\x1d\x55\x87\x04\xa9\x70\x55\x55\xa1\x75\xae\x12\x02\xf1\x4e\x39\x52\x40\x73\x26\xcc\x97\x90\x9b\x21\xe3\x82\x9d\x4c\xe9\xb3\xee\x4f\x4a\xc4\xfe\x34\x95\xff\x49\x84\xb3\xc1\xef\x8b\xd9\xe9\x9f\x10\x31\x55\x24\xf7\xff\x49\x41\x35\x5c\x6d\x7a\x04\xe1\x7a\x08\xe0\x0a\x01\x3b\xc7\x85\x82\x3e\x69\x86\xec\xb3\x0d\x66\x7d\xf8\x5f\x12\x87\x99\x42\x0e\x6e\x28\xf5\xc3\xb0\x42\x84\x9b\x04\x07\x30\x0d\xc4\xcd\x37\xa3\x00\xef\x1a\xa5\x73\x5e\x4b\x4e\x9e\x3b\x36\xd7\x0d\xee\x55\x1e\x27\xf9\xc2\xb6\x65\x60\x92\xbb\x55\xe9\x59\x06\xbb\xc6\xce\x95\x73\x2d\xf3\xe4\x81\x01\xaa\x7a\xe0\x73\xfa\x7c\xd8\x67\xe7\xe0\x99\xf9\xf3\x45\x3b\xd1\x3d\x30\x51\xa9\x9c\x48\x59\xcc\x1a\x62\xbf\xc4\x52\x83\x51\xa6\xf2\xd0\x3f\x62\xe1\x50\x37\x36\x6f\xeb\x01\x1f\xf4\xf4\x28\x11\x02\x13\x85\x4e\xb0\x5e\xa5\x17\x45\xf6\xf9\x55\xf4\xb9\xab\xd1\x5a\xf8\xb1\x5e\xe5\x83\x01\x09\x50\x06\xc1\x80\xc2\x2e\x83\xc1\xc6\xba\xdd\x16\x1f\xd1\xaf\x45\xc2\x98\x41\xeb\xa0\xf5\x43\xe7\xd1\x86\x5c\x28\xda\x6a\xce\x5a\x0b\xe4\x23\x38\x61\x1a\x43\x5f\x22\xb4\x00\x7b\x1d\xa2\x8b\x37\x2f\x37\x2d\x9c\x8d\x97\x43\x8c\x7a\x0d\xcb\x4d\x3d\x73\xd0\xa2\xd0\xef\x41\x4b\x70\xc2\xcd\xeb\x39\xa5\x8e\xd4\xba\x75\xc1\xea\x89\x37\x5d\x6d\x00\xef\x91\x33\xa9\xee\x57\x1c\xcd\x11\x73\x6e\x9d\x92\x0b\x61\x90\xed\x76\xdc\x0f\x82\xcc\xb1\xde\x0d\xd1\xfc\xdc\xd0\x0d\x39\x5e\xd2\xb8\x61\x8a\x5d\x33\x79\x2f\x42\xad\xce\x41\xc7\xaa\x59\xdb\x9d\x3c\xd8\x76\x0d\x68\x46\xde\x7a\xa3\x15\x74\x8d\x46\xf3\xb8\xe0\x02\x3c\xb1\x31\x9d\x5d\x31\xaf\x37\x46\x3f\x3c\x6a\x81\x1e\xfc\xc3\xdd\x7a\xe2\x8d\x2e\xe5\x54\xb2\x51\xfb\xf5\x0b\x46\x05\x32\xba\x3b\x74\x95\xea\x9d\xaf\x51\xa6\xd1\xcf\x92\x73\x94\xce\x39\x74\x94\x85\x94\xae\xb5\xcb\x02\xa6\x07\x42\x1e\x84\xb1\xa4\x53\x85\x9c\x93\x06\x7c\xe8\xcb\x20\x9c\xc9\xb2\x14\x21\x9b\xd1\x1c\x26\xe5\x11\x9a\xd9\x6e\xc2\x4b\x92\x56\x26\x32\xb7\xa1\x31\x92\xe8\x3e\x66\x43\x92\xe4\x8d\x5a\xf8\x88\x21\x1e\x8f\x58\x18\x2f\x9b\x4a\x47\x84\x90\xd0\x2e\x47\x2d\x16\x77\x88\x0f\xf8\x90\x4a\xa4\x24\xaf\x1b\xa9\x46\xb7\x44\x71\xd8\xf3\xf7\x95\x78\xfe\x79\x4b\x5e\xfb\x53\x88\x88\x6a\xbc\x5c\xc4\x43\xe4\x78\x50\x42\xf4\x83\x91\x11\x6d\x0e\x86\xbe\x49\xee\x1b\x71\xc5\xe6\xeb\x6e\xdc\x70\xc3\x69\x20\xfe\x00\xae\x47\xc0\xab\x86\xb7\xf1\xb0\x72\x10\x9c\xae\x7c\xab\x4c\xac\x48\x9e\x1a\xde\xb6\xbb\xef\x81\x51\xe0\x39\x51\xd8\xd9\x7f\xa8\xc0\xf3\x13\xaa\x57\x32\x23\x95\xfb\xdf\xff\x52\x3d\xd3\x03\x9f\x70\xd7\xa2\x33\x5d\x4d\x9d\x9e\x1b\x66\x33\xba\x9d\x21\x2e\x0e\x40\x26\xc3\x39\x8d\x4c\x4d\x6d\x25\x72\x54\x30\xea\x6f\xbb\x0c\x38\x2a\xe5\xb3\xf0\x4c\x74\xba\xcc\xe8\xf5\x0e\x92\x51\xca\x14\xf1\x29\xf3\xb5\x3b\xd9\x02\xc9\x46\x36\x3b\x54\x3c\x02\x9a\x8b\x42\xb2\x58\xb4\x4c\xf5\x97\x91\x88\x14\x0d\x01\xeb\xb5\x8e\xdf\x7c\xce\xee\xe1\xaf\x5e\xaf\x60\x53\x30\xb6\x75\xca\x6c\xa3\xfa\x87\xd6\x59\xd8\x26\xcc\x9f\x1e\x9b\xbc\x66\x4d\xa9\x45\xa8\xac\x6c\x2e\xfe\x47\x8a\x7e\x2a\x7f\xcf\x54\x9d\xaa\xc9\xd9\x93\xab\x8b\x53\x14\x16\xd4\xc9\x65\x6c\xc6\x8c\xb1\xb6\xa6\x54\x4c\x3d\x16\x33\xea\xc0\x22\x32\x9a\x8c\xbe\xf2\x2a\xc4\x41\x22\xaa\x35\x77\x45\xb6\x3b\x60\xfb\x3f\x09\x69\x6c\xdd\xb4\xea\xbf\xc8\x88\x8e\x37\xf7\xff\x22\xa6\x6a\x05\x55\x39\x2b\x90\x8f\xd6\x88\x6b\x26\x8c\xd9\x1a\x51\x74\x57\x84\x42\xf1\xb8\x1b\x66\x99\xe6\x26\xab\xbf\xca\x3f\x5d\xae\xab\x12\x6a\x2a\xa2\xa9\x54\xa2\x5d\x4e\xf1\x21\xb7\x18\x8f\xc6\xdb\x65\x67\x54\x2a\xa0\x8a\x37\x94\xf8\x43\x65\x0e\xf6\xc9\x41\x3c\xcb\xed\x87\x53\xb2\x9d\x94\x92\x04\x97\xe3\xa2\x60\x27\xdb\xe0\x01\xc8\x6f\xbd\x37\x6f\x47\x54\x91\x95\x6a\x55\xe4\x42\x3d\xae\xba\xef\x2f\xab\x28\xe4\xaa\x35\x41\x62\x63\x13\xa9\xda\xd0\x54\xff\xc4\x92\x9a\xdc\x35\x6b\x90\xf9\xac\xf8\xcd\x1b\x6a\xbc\x73\x95\xc6\xb9\x12\xc3\xaf\x3c\x98\x5b\x92\x8e\x38\x23\x09\x3e\xee\x0b\x06\x91\xfd\x0f\x0a\x1e\x57\xbb\xec\xe1\xcd\x62\xa7\xcc\x9b\x7d\x91\x41\x95\x2d\xd9\x52\x16\x84\xf2\x67\xc3\xa2\x50\x43\x2a\x60\x5d\x83\x8c\x7f\xd1\x4e\x16\xca\x8b\xf3\xc6\xff\xc4\xb3\x85\xf2\xd8\x1d\x5a\x41\x31\xb1\xfc\x64\xef\x58\x1d\x99\x37\xf2\x5f\x30\x77\x18\xf4\xf2\xde\x78\x82\x4f\x00\x13\x74\xb8\x5c\xba\xe9\x38\x40\xc0\xdc\x61\x7c\xde\x14\x84\x29\x2a\xd0\x39\xb4\x1d\xaf\xac\x72\x7a\x44\x59\x00\x7e\xd2\x22\xe9\x12\x54\x7b\x66\xde\x53\xaf\x0c\xa9\x8c\xd6\xb4\xa3\x32\xed\x8d\xdf\xd0\xfb\x86\xd6\x43\xf7\x1b\x54\x85\x49\x30\xd9\x91\x0f\xc6\xa3\x7b\x26\x62\x64\x0f\x3b\x72\xc1\x74\xa2\xc8\x59\x39\x07\x32\x92\xbc\x0d\xcd\x59\xd4\x9b\x69\x1b\x6f\x20\x8e\x97\x59\xc2\x98\xdb\x2d\xe5\xc5\xbd\xa5\xc4\xc5\xf9\xe2\x5e\x74\x53\x62\x25\x6a\x10\xc0\x51\x4b\xc1\x29\x3d\x3b\xfb\x3f\x58\xaa\x1c\xea\xe9\x01\x67\x81\xbd\x70\xba\x6b\xdc\x38\xd7\x89\x47\xe8\x17\xfb\xb7\xaa\x73\x73\x8d\xeb\x7f\x23\x5f\xf3\x0f\x5f\xb0\x73\xcc\x6d\x5a\xef\xd8\x71\xf6\xd7\x70\x3f\x15\xa2\x2a\xa9\x45\xb9\xe1\x16\x49\x4a\x84\x29\xaf\xce\x96\xa0\xd8\xaa\x8c\xc5\x81\x1c\x0f\x15\x06\xd3\x62\x09\xc0\x40\x0c\xd7\xe6\x7a\xfc\x7e\xe4\x79\xfb\x25\xd6\xdc\x29\xeb\x59\x1e\xa6\x3b\x64\xc8\x97\x42\xe2\x94\x1a\x63\x02\x01\x55\xd6\xdc\x3a\x2c\x1e\x69\x70\xe5\xbb\x77\xb4\x0a\x13\x1b\x59\x6c\x18\xd1\x85\xe3\x25\x05\xc9\xed\x40\x0f\x6c\xb9\xd9\xf4\xd5\xd3\x9c\x6d\xf7\xb6\xf4\x39\xa7\x4c\x71\xf6\xf5\x3c\x39\x2a\x3d\xcd\xd2\xdf\xba\x51\xf9\x41\xf9\x12\x54\xaf\xba\x74\x52\xa2\xb2\xf5\xf2\xb3\xc1\xbb\x5f\x7c\xce\x29\xdf\xde\x6a\x54\xde\x58\xa6\xbc\x70\xa6\xf2\x8c\xe9\x11\xe5\x7d\xf6\xd8\x17\xaf\x3d\x6c\xa1\xdf\x31\xef\x51\x73\xd3\xec\xb5\x04\xcb\xb1\x06\x79\x15\x11\x89\x0f\x18\xab\x62\x10\x1d\x29\x58\x57\xcb\xa4\x52\x3a\xb3\xd9\x83\x59\x56\xed\x61\x5d\xb8\x4b\xa6\x74\xce\x72\xd2\x3c\x77\xed\x88\x72\xa6\x1b\x9c\x9c\x8a\xa9\xd9\x74\x8c\xf2\xa3\xa5\x44\x87\x95\x70\xf3\x36\x35\xa7\x92\xa3\xd1\x09\x72\xf0\x20\x08\xe0\x37\xdd\xd7\x44\x8c\xe1\x6b\xe6\x3d\xf7\x47\xfa\x36\x30\x16\xc8\x6f\x7e\x75\x6a\x57\xf7\xfd\x17\x9c\xff\x40\x77\xd7\xa9\xc3\x67\x59\x4d\xb1\x37\xa3\x66\xeb\x2c\x47\xf7\xec\x59\xf3\xbe\x7e\x87\xb6\x2b\x5f\x0c\xfc\xe9\xab\x35\x7b\xee\xb9\xf6\x50\x6f\xef\x0b\x3f\xbb\xf7\xa1\xa5\xf3\x86\xdf\x9d\xcd\xe5\xb2\x77\x0f\x9f\x87\x53\x05\x14\xa4\xa6\xa2\xbb\x71\x29\xa9\x07\x0b\xa3\x08\x7a\x61\x2e\xeb\x36\x27\x9c\x0c\xe3\xe7\x0d\xe8\xc4\x19\xcc\x30\x5d\x21\xa9\x77\x03\xc6\x03\x7c\xa0\x43\x76\xf2\x42\xc2\x6f\xf4\xa3\xbd\x32\x3a\x31\x71\x1b\x0a\xa8\x07\x17\x51\x67\xcb\xbc\x35\x57\xe1\x25\x41\x7b\x4c\x60\x58\xed\xc4\xc5\x6d\xc3\xe2\x09\x4d\x61\x33\xc0\x81\xe1\xbb\xac\x34\x3b\x2c\x99\xb2\x8d\x01\xec\xa5\x03\x94\xf2\x1f\x6c\x7c\xfb\x7f\x00\x00\x70\x67\x80\x2f\x97\xd2\xfa\xe3\xdf\x55\x2d\x9a\x31\x6b\x61\x15\xfd\xf1\x8a\x4b\x2e\x3a\x0b\x1c\xfd\xdb\x17\x1e\xe5\x51\xe2\xbe\x4c\xab\x01\xbf\x7e\xff\x0b\x0f\x20\xdc\xf2\xca\x9f\xeb\x95\x53\xaf\xdb\x32\x5b\xa0\x7f\xb4\x4d\xbf\x61\xe3\x81\x07\x7c\xfd\x56\xef\x1e\xd5\xaf\xa9\x1e\xf8\x1b\x9c\x43\x62\xc2\x53\x72\x01\x13\x00\x76\xd6\x2e\x39\x71\x15\x18\xb2\x51\x80\xb2\xf2\x7a\x0e\x85\x59\xf6\xa2\x01\xce\x66\xf3\x38\xde\x25\x6f\x4c\x91\x94\x15\x33\x66\x66\x5d\x05\x6a\x2e\xcc\x8f\xf3\x8a\xf6\x60\x3e\xee\xc1\xba\xed\x74\xc3\x9a\x35\xcf\x5d\xbc\x1c\xcc\xb9\x62\x74\x88\x1e\x59\x62\x2f\xc9\xf8\x68\xbd\x1d\x54\x53\xce\x87\xc7\xb7\xb3\x48\xb1\x93\xf1\xad\x30\x3f\x38\xc0\xa3\xbf\xaa\x0d\xff\xff\x6b\x6c\xf8\x0a\x31\x62\x17\xa9\x63\xa3\xf8\xe7\x4b\x12\x6f\xe6\x72\x61\x97\xc5\x82\x0e\x71\x50\x17\x0a\xb8\x31\x5f\x96\xd5\x6a\xf3\xf2\x0e\xbb\xcd\x39\xd8\xbf\x2b\x59\x80\x82\xd2\x1e\xe4\xeb\x8d\x06\x5c\xf9\x8c\xe8\xf7\x8b\x7e\xdf\x0b\x3f\x2f\x4e\xab\xe0\x00\xfe\xfd\x68\xc9\xca\x14\x62\x33\x5c\xf7\xe0\xc0\x7c\x85\x94\xc9\x24\x30\x82\x53\x12\x91\x2f\x2c\xf2\x26\xc1\x8a\x0e\xa0\xd5\x67\xa4\x74\x3a\x0e\xbf\xfa\x91\xc3\x54\xea\x7e\xe6\xab\x6a\x8b\x95\x0c\x25\x4a\xed\xd5\x42\x19\x03\xa9\x6c\x00\x9b\xe8\x7f\x6a\xe5\x0b\x27\x6c\xc4\x79\xeb\x2b\xc4\xb9\xda\x1c\xfc\x38\x9f\xe7\x62\x59\xbb\xcf\x62\x87\x81\xa0\x8b\x41\x27\xc3\x2b\x48\x62\xbb\x2c\xf1\x26\x9e\xd7\x77\x0e\x2a\xf0\xc9\x6a\x45\x16\x45\x8e\x6d\x3c\x83\x21\xde\xb0\x5a\x68\x01\x2b\xf0\x54\x8a\xeb\x93\x2f\xb4\xa0\xcf\x43\x33\xea\x8f\xe7\x57\x08\x5e\xa2\x95\x59\xa0\x79\xd5\x21\x05\xfb\x04\xd2\x39\x76\xaa\x32\x27\xe9\xcc\x94\xd9\x21\x0a\xf8\x19\x4c\x10\x74\x66\xa3\x59\x7b\xfc\x2a\x7f\x09\x2d\x7b\xef\xca\x47\x9d\xf4\x13\x24\xa0\x3c\x43\xb1\x2f\xc5\xd1\x25\xfd\x47\x14\x3a\x2a\x34\xb9\x3f\x7f\x41\x91\x24\x59\x83\x2b\xd0\x1a\x70\x64\xac\xea\x9c\x93\x35\x9b\xed\x0e\x31\x4f\xa0\x66\xa7\x69\x6b\xa7\x4c\x0b\x83\xc3\xb1\x11\xc5\xaa\x59\x6d\x34\xb5\x5c\xf6\x8a\x31\xcb\x9e\x78\x0e\x5f\x61\xfc\xf2\x97\x83\xfb\xc5\x57\x0e\x9e\x38\x9b\xc4\xad\xfb\x29\xf5\xa9\x0f\xe9\xd3\x11\xc8\xae\x6d\x26\x76\xcd\x8f\xd1\xd0\x29\x9b\xc3\xea\x81\x50\xaf\x17\xac\x36\x26\x18\x10\x3c\x1e\xba\x43\xf6\x78\x38\x93\xc9\xdd\x21\x9b\x90\xb6\x31\xf1\x36\x5c\x3f\x42\xda\x61\xf3\x46\xae\xa4\x80\xe7\x24\x98\xdc\x11\x58\x42\x3f\x84\x31\xee\x44\x97\x54\xa8\xda\x81\x61\xa5\x77\xb5\xc2\xf7\x2c\xa3\xed\xe0\xfe\x27\xff\x79\xa6\x32\x71\xe6\x85\x13\xdb\xce\x9a\x07\xd6\x29\xef\x12\x7b\xf7\x83\x73\x9c\xf2\xc3\xe1\x16\xe5\x37\xee\x56\xfa\x8e\xf9\xd3\x94\x7b\x3b\x87\xce\xbb\x33\x97\xb1\x79\x3c\x46\x07\x0b\x58\x68\x64\x02\x41\x91\xb7\xa1\xd9\x42\x9b\x4d\x6f\x11\x68\x93\x1a\x6c\xeb\x91\x59\xc0\xcc\x90\x98\x18\xb2\x90\x43\x50\x8b\x8f\x89\xb5\x2b\xcf\xe8\x4b\x3a\xe8\x94\x84\x0a\x50\xc0\x81\xca\x8a\x30\x3f\x65\x66\xf3\x99\xff\x7c\x52\xe9\xee\xff\x72\x59\x0f\x38\xb6\xba\x57\x69\xef\x5e\xd9\x36\xf1\x82\x59\xb0\x0f\x29\xbe\xdf\xb4\x1c\x56\x7e\x18\xe7\xa4\x09\x1f\xa4\xf2\x2e\x58\xd7\xbf\x68\x71\x97\x72\xef\x54\xf5\x7c\x8f\x41\x4e\x2f\xae\x65\x1f\x46\x4d\xcd\xa5\xc3\xf6\x0c\x34\x27\x93\xee\x06\x68\x67\x1b\x9b\xc2\x66\xa9\xa2\x02\x2d\x2f\x5b\xe1\x94\x02\xed\xf8\x75\xbb\x9e\xa2\x6a\x4a\x5d\xa0\x6c\xf1\x99\x7b\xe8\xab\xd8\xff\x5e\xb6\x8e\x2c\x5b\x46\x35\x68\xe4\x4e\x80\x43\x4f\xbd\xf2\xd3\x05\xeb\x07\x9f\xb0\x95\xb8\x46\x60\xe2\x4f\x16\xaa\x9f\x7d\xc7\xdd\xd9\x82\x8f\x34\x70\x13\x92\xef\x79\xf6\x1e\xca\x8b\x63\x56\xd1\xe7\xf5\x9b\x7d\x2e\x48\xea\x1b\x0c\x42\xa7\x6c\x36\x94\x14\xec\xe0\x56\x30\xcc\x21\x5c\xc8\x65\x97\xa5\x6b\xc8\xf4\xe9\xf5\xf8\xb2\x14\x1d\x4e\xfc\x02\xac\x66\xa7\x77\xe5\x1d\x4d\x66\x3e\x4e\xc0\x10\xdf\xf8\x00\x1a\xfb\x63\xc2\x99\xd3\x9a\x8b\x72\x06\x83\xcf\xed\x8e\x45\xe3\x42\x2c\x84\x27\x10\x02\x9c\xd7\xe3\xed\x90\x0d\x1e\x09\x13\x44\x08\x96\xb2\xd2\xa1\x92\x09\x95\x67\xd8\x09\x28\x75\xc9\xcc\xd4\x67\x01\x6d\x76\xf7\xe3\xd9\x5d\x7b\x6d\x71\x7e\xd7\x5e\x8b\x2f\xb5\xfa\x32\x9d\x5d\x56\xc8\x17\x4d\x5a\x06\x1f\x26\xb3\x04\x03\xdf\xa3\xbb\x9d\x26\xb8\x7e\xf5\x39\xb7\x0d\x42\x9f\xdb\x6f\xf4\xe1\x3e\x91\x4e\xd9\x22\xb8\x28\xca\x31\xd8\xe5\x2d\xcc\x4a\xdb\x65\xf5\x5e\xe7\x59\x41\xf2\x7b\x49\x5f\xf6\xd4\x2b\xe4\x8a\xe3\xfb\x5e\xea\xd2\xae\xc5\xd7\x1c\xbf\xf3\xf7\xaf\xd3\x36\x89\x56\x9e\x56\x26\x92\x3d\x0a\x51\x15\x58\xcb\xea\x39\x2e\xea\x76\x57\x86\x32\x29\xbb\xbd\xd2\x8f\xd7\xca\x0f\xa4\xf8\x74\xa4\x68\xc3\xd3\x55\x2d\x8b\x41\x14\x8a\x7b\x36\x74\x91\x1c\x3a\xa7\x2b\x96\x4c\x95\x74\x62\xd9\x0a\xcf\x0f\x5a\xf2\x5b\xdd\xc9\xc9\xd5\xd2\x4a\x9b\xe3\xfc\x47\x77\x3c\xb2\xf3\xaa\xa5\xbd\x80\x3c\xe8\x1f\xbb\x7b\xd8\xd4\x05\xd3\xe5\x09\xea\xbe\xfe\xfd\xae\x0b\xe4\x9e\x61\xa9\x85\x6b\x57\x2d\xbe\x2a\xcb\x33\x41\xbc\x6c\x3f\x06\xb7\x66\x46\x54\xa5\x6b\xf3\xbc\x48\x98\x47\xca\x89\xeb\xf9\x59\x00\x9c\xa2\x08\x4d\xd0\xe5\x76\x12\xba\x09\x91\x61\x00\xb2\x0e\x86\x2e\x99\x07\xc8\xed\xab\x2d\x94\xf2\x97\xe8\x24\xd5\x76\xc6\x48\x31\x3c\x09\x18\xb4\x97\x70\xb4\xd5\x3a\xb0\x73\x5b\x29\x01\xd2\x56\xc7\xff\x47\xdc\x7b\xc0\x47\x55\x65\x8f\xe3\xf7\xbe\xfb\xde\xf4\x99\x37\xbd\x66\x66\x32\x99\x4c\x26\x90\x84\xc9\x64\x18\x42\x68\x79\x44\x08\x09\x2d\x24\x34\x87\x16\x54\xa4\x57\x45\x51\xd0\x05\x04\xc5\xb6\x20\x2a\x2a\x16\x2c\x2b\x36\x50\x59\x65\x11\xbb\xab\xac\x0d\xbb\xb8\x16\x54\x74\x75\xf5\xab\xae\x6b\x59\xcb\x2a\xe4\xe5\x7f\xee\x7d\x6f\x5a\x02\x7e\x77\x7f\xbf\xff\xff\xf3\x47\x33\x79\x6f\x72\xcb\xb9\xf7\x9e\x7b\xda\x3d\xf7\x9c\xb7\xe6\x73\x99\x6c\xde\xa3\xae\x6d\xc3\xe3\x28\x9b\xcb\xea\x15\x80\xc1\x03\x7c\xb2\xc4\x89\x90\xd9\x6d\xf6\x6a\x7d\xa2\xc7\xe9\x69\xcb\xd8\x25\xab\x53\xec\xc5\xbf\xd5\x04\x56\x27\x62\xde\x05\x57\x1e\xf1\xe3\x79\xb6\xa4\xdc\x72\xcc\x31\x6c\xa2\x64\xaa\x52\x68\x1f\x8b\xb7\xc3\x72\x70\x44\x41\xeb\x4f\x3a\x22\x11\x8b\x21\xe4\x14\x04\x1f\x36\xe0\xf2\x98\x8b\xe9\x23\xa5\xc8\x64\x36\x01\xe9\x76\x08\x66\x33\xef\xb1\x89\xba\x12\x6a\xda\xe0\xb1\x6a\x70\xcc\xba\x69\x50\x5f\xea\x62\x7f\xf2\x86\x5c\x42\xcb\xbc\xe3\x25\xcb\x09\x64\xcb\x5e\x21\x50\xdc\xeb\x99\x73\x7d\xbd\x8d\xfa\xd6\x93\x8f\xf2\xf9\x80\x66\xcd\xc2\x6b\x71\x64\x0a\x5e\x35\xa3\xeb\xab\xb1\x63\xe5\x23\xa3\xf0\x6e\xf9\x3e\x35\x19\xd0\x9e\xf9\x78\x98\xb7\x49\x56\x3f\x41\xc0\x2f\xc3\xbe\x4b\x26\xcd\x62\xf3\x7a\x72\xf7\x3f\xf8\xf5\x30\xa6\x3e\xe8\x2c\xa9\xc2\x6e\x22\x21\x6f\x3c\x1e\x2d\xb1\x68\x89\xa6\x6f\x55\x54\xa7\xd7\xf9\x74\x2f\xe8\x88\xce\x1c\x36\x95\x07\xc4\xd7\x34\x1f\x69\x38\xa2\xa1\xb7\xb8\x5d\xfe\x16\xf8\xfd\x91\xe4\xd1\x8b\x2d\x1a\x0d\x62\xd7\x99\x1c\xbc\xa9\xc4\x2c\x22\x57\xde\x31\x42\xcd\x13\x94\xa8\xaa\xea\x9c\xa9\x46\x68\xa5\xce\x98\x39\x9c\x60\xbe\x74\x34\xf2\x47\x8f\xac\x40\xa9\x1e\xf9\x83\xd8\xb5\x09\x6e\x09\x88\xc6\x5f\xbd\xb6\x8f\xf7\x3c\xd2\x5c\x39\xc6\x82\xff\xe6\xca\xcc\x58\x75\xce\x39\xab\x66\x4c\x77\xe1\xbf\x89\x63\x2a\xc7\xfe\xd1\xc3\x3f\xf4\x92\xfc\x2f\xe7\x5f\x9e\xbd\xf2\xc9\x92\x32\xc3\x5c\xec\x96\x3f\x11\xaf\x3e\xe7\xba\xcb\x2f\xbf\x6e\xd5\x36\x11\x07\xe5\x2f\xe7\x1a\xca\x4a\xfe\x7c\xc5\xd3\x2f\xb0\x9c\x4e\xff\x20\x1f\x00\x4d\x08\xd3\x7c\x63\x6e\x9d\x8e\x88\x25\xa4\x84\xe6\x20\x99\x90\xf1\xa9\xf1\xe8\x91\xa1\x3d\xef\xe2\x81\x8a\x0f\x1d\x0a\x73\x53\x53\xf7\xc6\xec\x41\xb3\x9a\x91\x8e\xd3\x70\xfc\x53\xcf\xc1\x92\x6c\xab\x5e\x38\x7d\xe8\xc4\xd1\x35\x15\xb1\x31\x6d\xa7\x5f\xb5\xed\xac\xbf\x3a\xdf\xfe\x0b\x7e\xd1\xdb\xd4\xb5\xf4\xc1\x3e\x0b\xf6\x5e\xbe\xe9\x5a\xd7\x96\x1f\x42\xaf\x3f\xf1\xb0\xfc\xcb\xa5\x0a\xaf\xa2\xb1\x08\x7f\x26\x4f\x21\x0b\xcd\x0d\x44\xcc\x26\x23\x2f\x18\x74\x06\xde\x8c\x04\xab\xc8\xeb\x8c\x56\xb3\x81\x08\x3a\x01\x44\x65\x5d\xe1\x21\x83\xbd\xc7\xb1\x0d\xe5\xa0\x46\xe5\xe2\x22\x4e\x61\x0f\xf9\x59\x8e\x9e\xf6\xf6\xbb\x9d\xf2\xfb\xa3\xf0\x98\x17\xf0\xe8\xd1\x8d\x01\x6e\x56\xd7\x6d\x81\xc6\xc6\x00\x99\x7b\xec\xfa\x00\xf4\xab\x41\x48\x78\x0c\xfa\x75\x42\xbf\x25\x76\x33\xa7\x35\x6b\x41\x0e\x05\xc4\x16\x8c\x3a\xab\xdd\xac\x45\x9c\xc0\xd1\xdc\x20\xf9\x5e\xb3\xe7\x45\x85\x42\x7a\x2c\xd7\x69\x80\xf6\x4b\x1f\x8d\x98\x3b\xf9\xdd\x7d\x4b\xe5\x57\x5b\xf0\x90\x73\xdf\xfe\xeb\xb9\x78\x5c\xb3\x9c\x58\xfe\xe2\x7b\xb3\x38\x4f\xd7\xdf\xe9\xc9\x15\x59\xd8\xf5\x1d\x27\x1e\xbb\x9e\x9e\x66\x71\xbe\xae\x2f\x94\x79\x70\xc1\x3c\x7c\x2d\xcc\x05\x99\x7d\x98\x54\xaa\xc1\x3a\x33\x80\x80\x5d\x42\x38\xa4\xb5\x19\x6d\xf4\xbc\xc5\x66\x86\x6f\x8d\x20\x10\xf1\xc6\x82\x99\x48\xa4\xb2\xe1\x19\xb3\x42\xa9\x3e\x0b\x86\x02\x18\xa3\x3b\xea\x39\x84\x85\xe3\x52\xf8\x9c\x26\x39\xbc\xfc\x83\xbf\x2c\x95\x5f\x1e\x81\xcf\x9c\x78\xf3\xd2\xda\xa1\x03\xb3\x9e\xa8\xe4\x85\x63\x5b\x19\x54\xba\xae\x9f\x18\xa4\x5b\xdf\xdb\xa9\x35\x29\x1e\xa8\x2c\x4f\x12\xc8\x42\xb5\x4c\xa7\x4a\x49\x3e\xbd\xcb\x6d\xd5\x98\x6c\x06\x2c\x9a\xa8\x59\xc2\x24\xe6\xc4\xb5\x5e\x91\x30\x55\xc3\x7a\x8f\xcc\x4d\xec\x10\x90\xaf\x5d\x2c\xff\xba\xad\x6b\xef\x36\xf9\xeb\xb3\xb8\xca\x95\x8f\xed\xcf\xe0\x71\x64\xa1\x47\x0e\xc9\xec\x50\x12\x3b\xf1\xdf\x3d\x4d\x4d\x1e\x79\x27\x9e\xee\x69\x52\x62\xa9\x8c\xe5\x57\xb0\xfb\x6a\x6d\x52\xdf\x12\xab\x3d\x60\xc1\x38\xe0\xb5\xf2\x65\xfa\x68\xc0\xee\x07\x9d\xca\xe3\x17\x7d\xa2\xad\xc4\x5a\x02\xba\x9d\xd5\xa5\x35\x1a\x41\x82\x36\xf6\x54\x5d\x1b\x73\x07\xf3\x05\xf2\x8d\xad\x58\xd7\xe9\x11\x62\x85\x3a\xe8\xcf\xce\xd3\xcd\xae\x2f\x0a\xe3\xac\xb0\x64\x40\xf8\x54\x79\x6a\x96\x8e\xc6\x0b\xc2\xad\x04\x9c\xef\x2a\xf4\xb4\xb2\x7b\x0d\x6f\x05\xd8\x4b\x50\x39\xf5\x65\x72\x08\x51\x12\x46\x65\x5c\x99\x4f\x67\xe3\x88\x5d\xab\xb5\x10\x9b\x4f\xa8\x88\x29\x11\x61\xac\xa2\x1b\x04\x34\xb7\xc5\x6d\xd1\x88\x62\x58\x09\x0d\x43\x10\xcb\x9a\xfd\x6c\xd1\x95\x2c\xd4\x43\x05\x57\xae\xb7\x2a\x6e\x4d\x20\x15\x33\xd7\xc4\xe2\xb1\xe4\x12\x74\x38\xca\xb4\x2c\x54\x08\xfe\x25\xe8\x99\x68\xf7\xc9\x97\x15\x8e\x69\x5c\xeb\xb3\x8b\x66\x2d\xdb\x78\x6e\xf9\xb6\x55\x7f\xbf\x61\xf8\x90\xd6\x31\x83\x0a\xc6\xb4\xe1\xb2\xb9\xe3\x26\x9d\x82\x2d\x7b\xa7\xf7\xa9\x55\xf9\x55\x33\x99\xc7\x74\xce\x11\x52\xb9\xcf\x2c\x7a\xf5\x81\x80\xd7\xec\x22\x42\x28\xec\x15\x3d\x80\x21\x1e\xd1\x07\x9a\xa8\xcb\x2d\x16\x1b\xf5\xd9\xbd\xab\x9e\x03\x38\x81\x21\x3f\x9a\xb5\xdf\xe3\xce\x42\xfb\xfd\x4d\x4a\x9e\x1a\xcd\xf1\x2d\xf7\x34\x39\x4d\xce\x5e\xcf\x81\x6c\xac\xc0\x59\x8e\x12\x68\x9a\x94\xac\xd1\x86\xec\x65\x95\xe5\x9c\x33\x68\x29\x2d\x0d\x72\xa6\x4a\xbb\xd6\xaf\xab\x4d\x06\x9d\x25\xce\xf1\x99\x12\x31\x64\xb7\x1b\xfc\x01\xd1\xd0\xb7\x23\x63\xe0\x63\x1d\xd9\xb3\xee\xc4\x09\x21\xcf\xc1\x5f\x24\xa9\x1c\x6f\x10\x20\xce\xc4\x40\x91\xce\x8a\x2e\xdf\x5b\x9d\x67\x3f\xa0\x8a\x2c\x1b\xb6\xf6\x18\x55\x6b\x8d\xb3\xeb\xe7\xb6\xc5\x81\xf1\xd3\x41\x86\x91\xc7\xd6\x56\x29\xa2\x8b\xd5\x76\xfb\x1d\xc5\x83\xbc\xfe\xac\xe9\xd3\xd7\x37\x8d\xaf\x6e\xa8\x8e\xd7\x2a\x74\x85\x5e\xda\x9d\x2f\xec\x02\x59\x90\xde\x4d\x24\x3a\x97\xc5\x05\x02\x61\x89\x17\x84\x18\x8b\x72\x37\x11\xfb\x08\x06\xb1\x06\xff\xe6\xdd\x44\xa6\xa2\xe4\x6f\x48\xe6\x43\xb5\xd9\x3c\xdc\x37\x5d\x4b\x76\x2f\x5a\x7a\xfa\x9e\xd3\x16\xc6\x33\xd2\x37\x93\x5e\x7c\xe3\xea\xad\xbb\x47\xfb\x39\x62\x36\xef\xdd\x87\xa7\x8d\xb9\x15\x1b\xfc\xfd\xfe\x76\xe8\x81\xef\xfa\xc9\x92\xbf\x37\x4c\x76\xc1\x83\x4d\xa0\x50\x05\x4a\x38\xb7\xdb\xaf\xf3\x60\x3f\x6e\xcb\xf8\x5d\xd4\x11\xc2\xac\xeb\x75\x81\xb3\x10\xa6\x46\x6c\xcb\x46\xb8\xa1\x3e\xb7\x30\x93\xb0\x83\xc3\x8c\xc8\x3c\xbd\x7b\xeb\xd5\x6f\xbe\x30\xf9\x1f\x4d\x99\xf8\xc2\xd3\xf6\xcc\x59\xb6\x68\x77\xd7\x92\xd1\x7e\xfc\x54\xbf\xef\xff\xf8\xd6\xc7\x35\x01\xf9\xa7\x5b\xc7\xc8\x77\xec\x7b\xd0\x62\xee\xea\xa2\xe1\xd1\x28\x4c\xc0\x1f\xe7\xb3\x5c\x69\x0d\x52\xd0\x2e\x60\x8f\x49\xf0\x00\x4c\xd8\xe3\xf3\x50\x5f\x0c\xb7\x0e\xe6\x0e\x40\x32\xe9\xdc\x3d\x3c\x7c\x0a\xed\x01\x5a\x5b\x8f\xc4\x32\x20\xfc\x25\x58\xf4\x21\xee\x9b\x5e\x10\x71\x57\xf1\xff\xf2\xcb\xd7\xab\x20\x61\xc3\xad\x63\xf0\x34\x0a\x12\xbe\x9b\x81\x04\x30\x35\x03\xae\x4e\x03\x9e\x1d\xa4\xbe\xd1\x46\xbf\x8b\xf8\x49\x38\x44\xa1\x00\x16\x05\x33\x99\xcd\x55\xd5\xdb\x37\x5a\x31\x54\xf7\x70\x46\xce\x25\xe5\xe4\x06\xe5\x7c\xa3\x15\xff\x63\xea\x1b\x5d\x73\xb3\xdc\xfc\xfd\x2f\xf8\xce\x22\x9f\xe3\xcc\x0b\xbb\x83\xe3\xca\x69\x2a\xb6\x6c\x6e\x73\x64\x04\x09\xa1\x0c\x8d\x95\x2a\x51\xd0\xe3\x31\x69\x6c\x26\x5b\xb4\xbc\xb1\x1c\x97\x06\xfc\x98\x88\x7e\xac\x17\xfc\x7e\x8b\xd3\x49\x3a\x33\x4e\x87\x45\x9f\x8f\x5c\x98\x37\xef\x82\x64\x84\x55\xab\xba\x5d\x39\x4f\x2c\x8c\x72\x8e\xd5\x18\xe8\x34\x93\x79\xe1\xe9\xf3\x9e\x5c\x8c\xf3\xbd\x6a\xfc\x73\x35\x95\x39\x17\xce\x9e\x45\x73\xb7\x14\x07\x38\x97\x9f\x51\x83\xa0\x2b\xc9\xcc\x27\xe6\xcf\xa5\xd3\xc0\xc7\xec\xec\x5c\xfa\x13\x46\x13\xf2\xbe\x6b\x7d\x69\x6e\x6d\x57\x20\xa6\x2f\x27\xa2\x58\x19\x89\x94\x07\x48\x75\x55\xb9\xe1\x61\x2d\x1e\xaa\x1d\xa7\xe5\xb4\x5a\xaf\x3d\xd4\xcb\x5b\x6d\x66\x2a\x55\x68\xec\xcd\xfb\xa9\x29\x2e\x94\x09\x5c\x28\xe3\xd5\xd9\x73\xf9\xce\xeb\xd3\x0c\x7d\xf1\xf5\x4b\xd6\xbe\x77\x6e\x69\xdf\xbe\x8d\x73\x66\x2f\xdf\x38\x7f\xfb\xfd\xf7\x6f\x7f\xf6\xb3\xc3\xaf\xdf\xb2\x6f\xf1\x94\x89\xcb\xf6\x71\x6f\xf6\xaf\x99\x64\x34\xae\xe7\xf5\x42\xff\x7e\xb5\xfd\x2f\x3c\xeb\xec\x8d\xdf\xcb\x47\x3f\xff\x46\xde\x7a\xe1\x94\x55\x26\xad\xb8\xbc\x6d\xfd\xd5\xaa\x6f\x91\xe0\xe3\xdf\x83\x11\x4c\x96\xaa\x2d\xe1\x72\xad\xd6\xe1\x0f\xfb\xab\xfa\x54\xfb\x9c\x2c\xa2\x9f\xce\xad\x2b\x29\x17\xcb\x8c\x6d\x99\x32\x6b\x89\xad\x2d\x53\xe2\x8e\x83\xd0\x17\xa7\x6e\xc8\x07\x7a\x38\x49\x25\x8a\xac\x80\xb9\x63\x04\x8a\x46\x2e\x5b\x6f\x4f\x23\x5b\xce\x11\x89\x5d\x10\xf1\xb8\xf8\xb7\xa9\x07\xdb\xe5\xc5\x5e\x47\xaa\x37\xd2\xba\x45\xda\xad\x6b\xd7\xb5\x91\xe7\x2f\xf3\xf8\x9f\x90\x9f\x2d\x74\x40\x92\xdf\x53\x1d\x93\x7c\x57\xde\x18\xfa\x81\xc5\xf3\x86\x75\x9a\xcb\xd6\x89\xd2\x6e\xd2\x3d\x0f\x74\xca\xab\x55\x9f\x07\x7a\x9b\xad\x22\xe2\x15\x0d\x86\xca\x3e\x31\x8d\xa6\xd2\x15\x98\x48\x23\x7f\xc0\xf8\x2c\x22\x2a\xd3\x97\x81\x76\xa6\x77\x91\x50\xbb\xe2\xcc\x91\x57\xc1\xb3\x9e\xef\x36\x25\xc8\x4f\x2a\x97\x36\x01\x56\x62\x30\x3e\xce\x8d\x42\x0c\x44\x5a\xa5\xd1\x21\xeb\x07\x7b\x36\x5d\xb5\xf5\xdc\x2d\x77\xe0\xe7\xce\x5c\x94\xbd\x57\x28\x27\xc6\x9f\xcc\x6d\x69\x1c\x39\x6c\xf5\xb6\x5d\xe7\xce\x3f\xe5\x1c\xd2\x52\xd6\x74\x6c\xd2\x6a\x61\xa9\x7a\xb1\xf0\x97\xab\x67\xcd\x1e\x50\x5d\x95\x54\xce\xd6\x7e\x05\xf9\xa5\x9e\xc5\x82\x3b\x59\x4a\x70\x82\x45\x2f\xea\xac\x34\xa0\xa0\x4e\x2f\xf0\xfe\x80\xdb\xa6\xb8\x56\x89\x58\x47\x04\x87\x51\xd4\x32\x29\x14\x84\x50\xcf\xf8\x82\x44\x6f\xca\x71\x8f\x1a\x30\xe1\x38\x27\x8a\x36\x26\xfb\x35\x62\x35\xbf\x64\x76\x9d\x3c\x2e\x6e\x9f\xbc\x75\x8e\x7c\xfd\xe2\x8f\xe4\xc7\x27\xe1\x03\xf5\x8f\x9d\x39\x13\xbf\x9d\x99\x2d\x8f\x25\x37\xc9\xcb\x41\xcc\x72\xff\x83\xb3\xb0\x95\x78\x68\xc2\x2f\x85\x67\xa2\x34\x80\xe4\x07\x00\xb3\x88\xfa\x4b\x01\xce\xa8\x35\xda\xac\x98\x59\xb2\x35\x1a\xbd\x45\x64\x46\x43\xae\x2d\xa3\xcf\x5a\xbc\x8a\xed\xe8\x8c\x2c\xaa\xe7\x35\x8a\x99\x8b\x9b\xbe\xf5\xc1\xab\x5a\x1b\xc6\xf8\x8f\x6d\xea\xec\xe4\x6c\x64\xa1\xb7\xcb\x65\xd9\x25\x7f\xa4\x9c\x88\xc1\x7e\x9c\x04\x73\xf4\x2b\xb3\x1d\x54\x51\x4a\x53\xe1\x13\x4d\x26\x6d\xa9\x53\xeb\xac\x46\x35\x6a\x02\x76\x4f\x9f\xb6\x8c\xc7\x6a\x8b\x4e\xc8\xd8\xdc\xaa\x71\xb4\xd7\x05\x87\xdf\xbc\x1b\xd0\x23\xac\x4b\xc1\xed\x00\x35\x96\x0b\xff\xab\x62\x44\xed\xfa\x26\x1b\xc8\xa5\x61\x0b\x35\xbc\x1c\x5b\x9b\x0b\xe0\xc2\xac\x09\xbf\xae\xa0\x53\x95\x8d\xdf\x62\x99\x45\xaf\x07\x24\xb3\x61\x5b\x14\x3a\x5e\xae\xf2\xbb\x32\x34\x46\x8a\x7b\x4b\x4a\xb8\x88\xd6\xe9\x8c\x98\x49\xb4\xbc\x24\x12\x8e\xb4\x65\xa8\x3e\xd2\x9e\xf1\x62\x33\x36\xdb\xc2\x2e\x9b\xbe\x2d\x63\xc3\x05\x1e\x20\xc7\xbd\x6e\x4f\x43\xa7\xb2\xb4\x77\xbd\x38\x32\xcb\x71\xa6\x8c\xb0\xfc\xd3\x1e\x7c\xf9\xd3\x4f\x69\x50\x03\x79\xf5\x37\xbd\x78\xf3\xee\xd5\xd7\xd3\xb8\xa1\xd7\x17\xc3\x3b\x5e\xaa\x0c\x58\x0c\x1a\x4d\x29\x76\x61\x0b\xc0\x4b\x7d\x8b\xda\x33\xa5\x7a\xb7\xde\xcd\xdb\x6c\x3e\x0a\x28\xf5\x2e\x6a\xeb\xe9\x5d\xd4\x33\x5d\x5f\xd6\x0d\x50\x85\x8b\xe6\x6b\x39\x1e\xeb\x06\xd0\xb9\x8d\x14\xc2\x4f\x3f\xed\xc1\x2d\x3f\x95\x15\xf0\x56\xef\xee\xc5\xc2\xbf\x59\xcd\xe2\x9b\x76\xff\x43\xf3\x28\x8b\x91\xd4\x07\xd5\xa2\x53\xa5\x01\x61\xb7\xa3\xb6\xb6\x9c\x86\x5c\xef\xeb\x2a\x71\x69\x49\xb2\x2e\xe4\x1e\x9f\x09\xb9\x1c\x55\xf4\xac\x81\x9a\x2e\x6c\x28\x50\x8b\x08\x6f\x30\xc4\xdb\x32\x06\xd0\x20\x26\xe4\x4d\x16\x4a\x4a\x9a\x22\x4d\xd8\x53\x18\x1a\xa8\x8e\xa6\x93\xe7\x7a\xde\x8d\xc9\xea\x09\x80\xe9\x05\xf7\x4c\x62\x8a\x13\x0a\xf7\x41\xc1\x2d\x13\xea\x69\x72\xa5\xaa\x36\xb4\x04\x8e\x75\xc8\x17\xe5\x2e\xd4\x3c\xca\x24\xf0\xdc\x7d\x13\x76\x65\x46\x0e\x2b\x6a\x84\xbc\x23\x77\xb1\x66\x3f\x48\x7d\xb2\x6a\x5b\x9f\x28\x37\x6b\x3e\x82\xb1\xa7\xd0\x30\x74\x8e\xd4\x54\xed\x72\x35\xc4\x63\xbe\x84\xb9\x9f\xa8\x4f\xf6\x2f\x4d\x8a\x66\x5f\xa9\x20\x35\x56\xc3\x90\xab\xc5\xbe\x95\xe3\x33\x7d\x51\x02\x64\x71\x6f\x34\x3a\xa4\x2d\x13\xb5\x06\xeb\x27\x64\x82\x6e\xaf\xeb\x38\x0e\x37\x85\x1e\xc2\xde\x44\x43\xaa\x47\x78\xd7\xec\xc6\xfa\x6d\xd7\x9b\xf8\x71\x27\x8a\x89\xf1\x05\x97\x71\xde\x39\x8e\x47\x4e\xd1\xc5\x9c\x02\xe7\x9c\xa3\xb7\x67\x67\xeb\x78\x6e\x3a\xbd\xa6\x4e\xae\x1a\x24\xef\xfc\xe0\x9f\x64\x5b\xfe\xd2\x0e\x0f\xf8\xb2\x46\xbb\x88\xdd\xa1\xb2\xa1\x06\x34\x1c\xad\x93\x46\xa0\x98\xcd\x56\x1a\x12\xec\x43\x06\xc6\x8d\xc6\x81\x76\xe2\x6b\x4c\xf8\x12\x4d\x27\x0d\xa9\x6c\x80\x39\x4b\x35\xb8\x62\x40\x65\x62\x62\x34\x32\x3e\x13\x45\xd5\x83\x00\x7f\xaa\x6d\xd5\xee\x92\x12\x1d\x30\x53\xeb\x00\xb7\x9b\x80\x92\xae\xe0\x8f\xf5\xd9\x02\xaf\xdd\xe2\xcb\x4a\x39\xb2\x98\xf7\x22\xa4\xd3\x57\x57\x74\xfb\x4a\xc5\x18\xe1\xf8\x18\x96\xd3\xde\x54\xd5\x0e\x67\x95\xb8\x73\x7a\xe0\x90\xfc\x3f\xbd\x31\x2e\xab\xd4\xc9\x9f\x31\x8d\xaf\xeb\x57\x72\x0b\x53\xef\x7a\xe0\xd5\x4b\xbd\xd1\x4f\xd1\xf8\xa8\x1a\xa8\x6a\x7d\x1c\xb5\x93\xf2\xef\xf1\xeb\x41\x17\xaf\xa3\x99\xc2\x51\x22\x11\xb0\x54\xc5\x9c\x1a\x67\x55\x80\xef\x9f\x8a\x59\xbc\xc4\x5b\x07\x58\xe5\x2e\x25\x04\x78\x84\x96\x58\x83\xfd\x50\xbf\xb6\x4c\x18\x18\x89\x12\x56\x24\x1b\xd2\xb2\xf1\xf8\x01\x73\x23\xc7\x3d\x5e\x88\x46\x72\xc6\x4c\x9c\x3f\x89\xa8\x67\x49\xe7\xf1\xe3\xb8\x6f\x6b\x7b\x8f\x33\x06\x79\xb2\x92\x98\x1f\xdf\xa3\x1c\x42\x54\xdf\x38\xa0\x9a\xec\xf6\xf5\x38\x5f\x50\xb3\xf4\x1f\x7d\x3e\x7b\x02\x31\x65\x78\xd7\xc5\xc3\x9b\xe8\xfe\x8a\x00\x3f\xda\x09\xfc\xa8\x0f\x4a\x52\xae\x1d\x49\x24\xfc\xd5\x65\x0e\x87\xc6\xa4\xf1\x93\xba\x3e\xa9\x0a\x6a\xce\xae\xc0\x25\xfd\x22\x74\x70\x52\x28\x22\x7a\xfa\xb6\x67\x3c\xee\xe2\xc3\x08\x86\x00\xfe\x97\x0b\x0e\x02\x7a\x64\x01\xea\x7d\x42\x91\xbd\x7f\x97\xb5\xdc\x16\xf8\xdb\xd3\xd1\xf2\xa7\x17\x1f\x5c\xc4\x57\xd7\x28\x03\x7d\x8e\x79\xda\xaf\x4e\xd7\x3e\x37\xa0\xc7\x41\xc6\x74\xab\x57\x1d\xe7\x5b\x0b\x98\x97\xfd\xc3\x06\xee\x0d\x9a\x75\x9f\xd1\x11\x58\x4f\x61\x15\xac\x67\x0a\x0d\xa5\x11\xa2\xab\x02\x43\xb8\xfa\xa4\xe8\x70\xe8\xca\x92\x9c\x2f\xa0\xd3\x34\x0e\x0b\x03\xa9\x8c\x86\xad\xdc\x10\x61\x50\xbf\x41\x1d\x19\x5f\x75\xbf\x7e\x82\x68\xb0\x8b\x76\x10\xbb\x24\x93\x28\xf6\x77\x0b\x6e\xd0\x4a\x84\xbc\x3b\x44\xd6\x2c\xcd\x2e\x5e\x35\x14\xb8\x42\xf5\x94\x5a\x84\xb2\x78\xf1\x68\x5d\x51\x25\x1b\x4a\xef\x7b\x95\xc1\xec\xcd\xcb\xb8\x9a\xc3\x4a\xeb\xe6\x6b\x5f\x3a\xb7\xe5\xaa\x69\xca\xf8\xdf\x7b\x6f\x40\x75\xc5\x88\xe8\xd0\x22\x25\x67\xe6\xa2\x0b\x6e\xb8\x7f\x46\xcb\x68\x76\xd5\xd2\xb9\x66\xe8\xb0\xec\x44\xcc\xa7\xe3\x4f\xc4\x96\xde\x57\xa8\xfa\x4c\x60\xf7\x30\x37\xa5\xca\xe9\xad\x4b\xca\x13\x45\x79\xac\x46\x02\x1c\x18\x84\xce\x90\x86\x19\x06\xd6\xd9\x6c\xee\x5a\x9f\xaf\x2c\x14\xea\xe3\x26\x03\x85\x21\x83\xd3\x96\x8e\x4c\xda\x5a\x51\x33\x21\xd3\xb7\x02\xd7\x95\x94\x79\x4b\xcb\x4a\x27\x64\x6a\xcb\x44\x9f\xdb\x16\x2a\x09\x8d\xcf\x38\x4b\x4e\xe4\x1f\x96\xca\x4e\x50\x3e\x4a\x60\x8e\x67\x9e\xc0\x47\x4c\x35\xa4\x45\x72\x2e\xbb\xf5\xe9\x22\x7f\x63\xc5\x59\x8c\x39\x8a\x3d\x92\x45\x8f\xa1\xcc\x2b\xa9\xbe\x43\x7e\x7b\x4b\xd7\x97\x73\x37\x6f\xa6\x07\x23\x4c\xc4\xe1\x06\x51\x9b\xfa\xaf\x05\xbe\x62\xa7\xb5\x65\x5d\x94\xbe\xec\x72\x2b\xbf\x47\xc6\x4f\x57\x9d\x90\x2f\x51\x7c\x96\x98\xb7\x18\x46\x95\x40\x03\x1e\x00\x3a\x5a\x03\xb2\x42\xdf\x4a\xbf\x59\xe7\x44\xa5\xc8\xaf\xe3\x13\xfd\x9c\x95\x9a\x60\x30\x36\x3e\x13\x09\x5a\xd9\x81\x2e\x52\xcc\x83\xc4\x36\x3e\x43\xdc\xbd\x6e\x71\xf6\x3e\x6e\x64\x3b\x21\xeb\xb8\xf9\xbf\x1d\x3b\xf2\x0f\xfc\x79\xff\x84\x05\x5d\x77\x51\x1f\xce\x8a\xf4\xb3\xcb\x4e\x10\x1f\xeb\xa6\x5b\x9d\x8a\x17\xe7\xd1\xeb\x36\xc6\x93\x27\x08\x8a\xa5\xd8\xea\x80\x49\x9c\xc5\x74\x0d\x2f\xcd\xe5\xea\xd4\x1b\xe8\xed\x7a\x4e\x6f\x25\x7e\x9f\xde\xa5\x05\x6e\xe9\x40\x5a\x91\xdd\xa6\x47\xa2\xa1\xc8\x07\x2e\xe7\xa4\xda\x5b\x66\x4b\xe5\xfd\x50\x55\x49\x01\x84\x75\x7a\x99\xba\x72\x6e\xb1\x48\xd0\x35\x19\x0f\xa3\x44\x3c\xe7\x73\xaa\xf2\x7f\xee\x6a\x79\x09\xd7\xee\xb0\x32\x18\xcb\xba\xff\x45\x7e\x12\xc6\x20\x27\x50\xa6\x88\x64\x15\x05\x7f\x39\x5f\xd5\x57\x8c\x88\x11\x53\x39\x6f\x72\xe7\x32\xaa\xaa\x11\x0a\xa8\xc1\x35\x05\x92\x50\xd4\x88\xa3\x44\x31\xc1\xf2\xbd\xbe\xc1\xdc\xfc\xad\xab\x47\xbf\x9c\x7c\xb3\x7d\xeb\x96\xf6\x23\x09\x3c\x70\xcc\xa6\x2b\xa5\x5e\xdf\x70\xf5\xf2\x76\xbc\xc0\x56\x5d\x6d\xe9\x7a\x08\x9f\x22\xdf\xcc\x35\xc3\xb3\x5d\xbe\x0e\xcf\xe3\xde\x3a\xd1\x5f\x94\x79\x1d\x02\xc2\xda\x4d\xc2\x50\x64\x02\x0d\xa8\x4e\xf2\x78\x0c\x66\x60\xc1\x01\x3f\x36\x38\xbc\x06\xf8\xcf\x68\xf1\xb8\x34\x46\xc2\x92\xcb\xaa\xe9\x60\x8b\x0c\xee\x58\xc9\xb7\xad\x04\x82\xb3\x15\xbe\x90\x9b\x26\xc7\xc2\x0f\xce\xf0\x1e\x9c\x19\x9b\x44\x4e\x51\x9e\x5f\x9a\x41\x9f\xc9\x8a\xe7\xb4\x66\xe7\x73\xf8\xa5\x5f\x9f\x51\x1f\x00\x6f\xfb\xcb\x63\x85\xfe\xa0\xf3\x97\x53\x3b\xb2\x5b\x1b\x20\x08\x95\x95\x69\x45\x12\xab\x88\x94\x84\x4a\x40\x50\x14\x45\xbb\xdd\x38\x21\x63\xb7\x0a\xbe\x8e\x0c\x01\x8a\x56\x56\xe8\xc9\x5a\xe0\xb7\xd6\x73\x8d\xb1\x8d\x2a\x16\xa5\x3e\x5c\x74\x44\xd2\xc3\x6d\x95\x6c\xd2\xbc\x70\xa6\xfc\xc3\xb0\xfa\xac\x3d\xb9\x79\x44\x4b\xdb\x5a\xce\xb6\xe2\x72\x79\x2c\x5e\x32\xa5\x65\x11\x08\xdc\x53\xcf\xbd\x48\x31\x26\xcb\x5f\x8e\xeb\x2c\xe3\x1e\xf6\x35\x35\xf9\x8e\x4e\x56\xef\x38\x50\xf8\x1f\x06\xf8\x6b\xd0\x44\xa9\xda\xa5\x41\x7e\x7f\x24\xa2\xb1\x90\x7e\x95\x89\x78\x55\x55\xf9\x84\x4c\x55\xa0\x34\xc0\x9c\xa9\x45\x8b\xcd\x66\x00\x35\xc9\xca\x7b\x3b\x32\x1c\x5f\x78\xdf\xd0\x5b\x7c\x04\x5c\x60\x0b\x17\xfe\xd7\x21\x14\xda\xca\x4f\x38\x98\xbc\xb9\x3c\x3e\xa4\xe9\x44\x43\x3a\x36\x5f\x35\x9a\xb3\x71\x59\xb9\x3a\xee\x52\x61\x13\xcc\xf4\x50\xc9\x84\xec\x76\x8f\x51\xe3\xd1\x94\x04\xbd\xfe\xfd\xb8\x7a\x9f\x1d\x5e\x3c\x7a\xd7\x7e\x3c\xec\x01\x11\x93\xfd\x78\x08\xf5\x11\x52\xdc\x72\xb2\xc9\x88\x73\x7e\x83\x5a\x80\xf9\xf8\x9e\xb4\xa9\x9f\xf9\x33\xdb\x6e\x6c\x90\xff\xa7\xae\x6f\x65\xbf\x9a\x94\xfc\x3f\xf5\x0d\x9f\xf3\x57\xce\x94\xee\x90\xb7\x5b\x2a\x2b\x2d\xb8\x2d\x35\xd0\x29\x4f\xa3\x8f\xdc\x17\x96\x4a\x80\xc9\xce\x60\xba\x0a\x70\x65\xb8\x24\x72\x65\x01\xbd\xde\x62\x71\x96\x91\x8a\x58\x50\x13\x06\x20\x1e\xf0\xb9\xed\xfb\x71\xcd\xbe\x32\x3d\x67\xb1\x20\x13\x40\x87\x72\x30\x31\xe8\x8a\xc8\xda\x6f\xdd\x81\xc9\xc2\x8c\xcf\xc8\x81\x76\xce\x62\x29\x5a\x61\xb7\x78\x86\x30\x98\xb9\xba\x62\xf8\x86\x9e\x73\xb6\x71\x53\x93\x65\x7b\x85\x0a\x3d\xdb\x63\xdd\x9f\xe3\x6a\x3c\x14\xe6\xd0\x88\x82\xa8\xe2\x4f\x1a\x5f\x38\xe4\x2f\xd9\x8f\x07\x3f\xe0\xb6\x8b\x8f\xe2\xa1\xa0\x2c\xe9\x71\x35\xdb\x61\xf9\x0c\xce\xb8\xc0\xe2\x41\x7a\x79\xe7\xe2\xa1\x03\x2a\x62\xf5\xf5\xb1\x8a\x01\xc2\x79\x4b\xeb\x6b\x2b\xfc\x16\x31\x52\x31\x07\x24\xd4\xaa\x8a\xfa\x01\xf1\x78\x7a\xc0\xb1\x17\xcf\x38\xdf\xb8\x69\x84\xa9\x63\x14\x17\x75\x56\x22\x65\xce\xf0\xbf\xf9\x73\x90\x03\xd5\x4b\x46\x64\x30\x88\xbc\xe8\x72\x3a\xac\x30\x51\x83\x1f\x34\x88\xa2\x19\x66\xe9\x41\x8d\x80\x38\x75\x11\x29\x24\xea\x5c\xe5\xb6\x3a\xb3\x9e\x15\x39\x79\xa5\xb0\xe6\x9c\x69\xa5\x65\xd1\xf2\x39\x65\xd3\xe4\xfb\x5b\x5b\xbf\x26\xdf\x6d\x7a\x65\x6c\x99\x4b\xbe\x9b\x2d\xdc\xf3\x16\x25\x4f\x89\x89\x2b\xc5\xdf\xf3\x73\xa1\xef\xb4\x64\xc2\xcc\xc7\xcc\xe5\xb4\x1a\x8d\x66\xda\xb9\x56\xc0\xfc\xa3\xb8\x11\x08\x3b\xa2\x0b\x55\x97\xed\xbc\xb0\x67\xe5\x42\x6d\xb1\xe7\x9d\xa0\xcd\x75\x8d\xdb\x5b\x5b\xb9\xba\xb3\x58\xd7\x78\x2a\xed\x5a\x1e\xa8\xcc\x3d\xf4\x8d\xab\xb9\x71\x3c\x3d\xc7\x6b\x90\xcc\x5a\xea\x7c\x87\xec\xe1\x50\xd0\x4b\x11\x78\xf0\x83\x4e\xbb\xc5\xb6\x1f\x37\x3e\xa0\x21\x86\xfd\xb0\x12\x0a\x7e\x14\x77\x9f\x55\x05\x8a\x9c\xee\x0a\x81\xc1\x77\x57\x94\xda\x4c\xfe\x78\x2a\xbd\xf4\xbc\x95\xd3\xf3\x20\x71\xda\x96\x76\xd3\x88\x4d\xc6\xf3\xcf\xb8\x78\x43\x1e\x32\x4a\x73\x1d\x80\xbf\xbb\xd8\x7c\x94\xa0\x93\x24\x9f\xcd\xeb\x35\x38\x05\x60\x66\x82\x81\x04\x43\x5e\xe6\xbe\x64\x34\x3a\x08\x9d\x9e\x07\x7c\x06\x9d\x8a\xc0\x8d\xca\x09\x36\xb5\x73\xf7\x14\xcc\x5d\x2c\x88\x7c\x34\x97\xbe\xce\x95\xaa\x67\x6e\x4b\x2e\x1a\x11\x64\x97\x74\xf9\xb2\x2e\xf9\xe9\xc6\x06\xdc\x77\xc4\xa0\xeb\x12\xfd\x4f\xaa\xee\xdb\x9c\xe2\xe7\x56\x5a\x9e\x2e\x5f\xbd\xa3\xd2\x8c\x5f\xa0\x60\xfd\xf1\x73\x79\xd9\xe0\xe4\xeb\x35\x6c\xce\x78\xae\x82\xac\x00\xf8\x9c\x28\x29\x59\x04\x11\x9a\x76\x9a\x44\xce\x6e\x37\xf0\x22\x9d\x34\x87\x1e\xc3\xa6\x6a\x54\xd1\x24\x0b\x54\x16\x71\x8f\xc3\xd5\x30\x67\xda\xb0\xa4\xe9\xa1\xaa\x27\x5a\xd7\xaf\x6b\x7d\xae\x2f\xf6\x8c\x58\x7d\x01\xdf\x4f\x7e\x12\x9f\x04\x5d\x9b\xba\x7e\xc0\x43\xe4\x03\x9c\x01\x9e\x45\xf9\x09\x3c\x5c\x59\x37\x23\xee\xc3\x65\xd8\xba\xf5\x91\xf4\x46\x12\x0e\x69\x89\xcf\x05\xd8\x3a\x74\xaf\x4e\xa3\x31\x00\xad\x19\xac\x6c\x6a\x76\x7d\x21\xdb\x37\xc9\x1d\x64\x52\x08\x0a\xe3\xff\xe0\x7a\xec\xfc\xb8\x12\x47\x46\x5c\x78\x76\xd3\xfe\xca\x23\xf1\x86\xe6\x9a\x54\x6d\xb9\xdf\x5a\xe2\x8b\x85\x2b\xb8\x08\x27\xb2\xde\x9f\xc7\x0d\x0c\xa2\x0f\x4e\x9f\x54\x63\xdc\x3a\xc6\xe2\xef\x37\x99\xda\x3d\x37\x91\x19\xf8\x11\x1a\x0b\x56\xfb\x13\x8b\x07\xf8\x12\x99\x41\x6e\x11\x86\x5a\x35\xda\x9f\xd9\xfb\xad\xdc\xe7\x5c\x83\xd0\x01\x7f\xff\x84\xbd\xaf\x85\x77\x0f\x7b\xff\x94\xbd\x5f\x05\xef\x55\xec\xfd\x33\x36\xb6\xef\xf8\x34\x7e\x4c\x38\x88\xcc\x34\x47\x1d\xd2\x6a\x0d\x84\x88\x16\xc2\x1b\x0d\x28\x91\x7a\xa5\x4e\xcd\x03\xc9\x16\x16\x28\x53\x5a\x51\x2e\xd3\x75\x03\xf0\xe2\x96\xd4\xa4\x55\xab\x26\xd5\x8e\x11\x50\xaa\x65\xc2\xaa\x49\x93\x56\x4d\x68\xee\xd5\x9e\x91\x10\x68\xd2\x22\x1a\x0d\x84\xef\xd5\x1e\x20\xb2\x4b\x21\x2b\xae\x32\x0d\x1e\x3e\x3a\x49\xdb\x4b\xb5\x08\xa8\xff\x28\xa5\xbd\x16\xda\x5e\x10\x68\xc5\x31\x61\x3b\xf2\xc3\x7e\xb5\xd1\x33\x2a\x17\xb1\x64\xcf\xa8\x0c\x94\xb4\x3e\xe8\x23\x04\x2b\x68\xa9\xae\x40\xd1\x41\x10\xce\x86\xef\xec\xaf\x70\xab\x82\xc3\x29\xbc\x57\x5e\x39\x6f\x78\xd3\x90\x05\x8d\x43\xbc\xe9\xba\xf5\xe9\xd5\xe7\xcf\x9c\x38\x9f\xab\xab\xb6\xe2\xb4\x4e\xbb\x74\xf1\xab\x35\xb3\x6f\x76\xf8\x2e\x5e\xbb\x6c\x8b\x4f\xfe\x97\xb5\x18\x96\x7a\xc9\xd1\xeb\x6c\x0a\xfb\x29\xef\xb1\x9a\x61\x8f\xd4\x28\x7b\xa4\xe7\x0e\x01\xce\x53\x9f\x3f\x96\x72\xa9\x41\x74\xd4\x63\xa9\xd3\xe7\x4f\x9a\x71\xfe\xea\xfe\x1b\x6b\xd3\xde\x21\x8d\x0b\x86\x34\x0d\x9f\x27\xaf\xe4\x66\x59\xb1\xd9\xbf\x65\xe9\xda\x8b\x7d\x8e\x9b\x67\xd7\xbc\xba\x64\x89\x56\x27\x1f\xb4\x56\xc3\x3a\xce\x45\x77\xf0\x21\xfe\x6e\xbb\x06\x85\xd9\xba\xce\x87\xf7\x52\xf6\x1e\x51\xfc\xfc\xd0\x41\x7e\x04\xbf\x11\x69\x90\xeb\x21\x1e\x69\x75\x9c\x86\xc7\xb0\x04\x2f\xd7\xa9\xf8\x19\x8b\xea\x71\x14\xa7\xf8\x11\x5b\xe5\xcd\xf2\xe6\xad\xf8\xad\x19\x07\xb9\xee\x2e\x4c\x1e\xee\x51\x17\x11\x9d\x96\x20\x81\x2b\xac\xcb\x6a\xea\x31\x3f\x42\xae\x9a\x21\x57\x6d\xc5\x67\xe0\x33\xf8\x8d\xc7\x46\x91\x87\xbb\x30\xd7\x4d\xe9\x3b\x3f\x8b\xbb\x5e\xb8\x1d\xe9\x50\x3f\xc9\x47\x38\xad\x16\x09\x02\xd2\x1b\x38\xed\xe6\x0c\xe2\xae\x9c\xae\x11\x01\x66\x0e\xa1\xc4\xcc\xba\x2a\xf5\x64\x4a\x8d\xe3\xe7\x48\x3b\x52\x0e\x98\x17\xad\x5d\x49\x24\xca\xcf\x8a\xe0\x98\x7c\x98\xe5\x0e\x2d\x6a\x37\x29\xf9\xf3\xed\xea\x04\x22\x5c\x39\x9d\x40\xeb\x22\x09\x13\x8e\x40\xc3\x55\x79\x6b\x4a\x36\x44\x60\x2e\x65\xe9\xf5\x4a\xdb\xc2\xed\xf9\xbc\xa4\x08\xe3\x10\xdf\x86\x2f\x17\xb6\x02\x03\xf4\x4a\x06\x78\xe7\x05\x91\x60\x02\x53\xf6\xf2\xcc\xdc\x25\xc8\xa8\x2d\x85\x2f\x5f\xba\x14\x4a\x2a\x72\x56\x80\x3f\x85\xdb\xc2\xff\xcc\xea\x18\x11\xe1\x05\x9c\x1f\x99\x3a\x55\x0e\x20\x02\x01\x6e\x25\x7f\xca\x35\xd7\x28\xb9\x0b\xb6\xc2\x18\x68\x6e\x4a\x0d\x3a\x9b\xbd\x9f\x0c\xef\x7e\xf6\x7e\x92\x02\x87\x3c\x12\x5f\xde\xbd\x89\x46\x53\x96\x6c\xf0\x2e\xf0\xf0\x81\xe9\xc0\x12\x84\xd0\xa1\xf5\x86\x07\x6a\xa8\xf0\xc8\x1f\x72\x5b\xba\x57\x42\x5d\xdb\x9f\x30\xc7\xd3\xab\x93\x89\x54\x31\x20\xf2\x87\x0c\x10\x9a\x0f\xa7\x99\x2b\xef\x5e\x85\x04\x54\x26\x39\x78\x8c\xb5\x1a\x84\xac\x50\xe1\xb8\x3d\xe9\x31\xcd\xf9\x8a\x5f\x91\xaf\xc6\xc1\x9d\x72\x33\x36\xc5\xe4\x6f\x4a\x51\xef\x76\x40\x50\xd6\x68\x7f\xa3\x1d\x58\x5f\xd0\x6e\x4e\xdd\x89\x83\xf2\xd5\x72\x73\x29\xb6\xc5\xe4\x1f\xa0\xec\xbd\xd0\xd0\x65\x64\x37\xb4\x61\x44\x3e\xc9\xa0\x25\xc4\x64\xd6\x6b\x39\x41\x84\x6d\x94\xc8\xc7\x81\xd3\x46\x81\x82\x52\x7d\x36\xe5\xc1\x97\x4d\x1a\x30\xe9\xc3\x0f\xe1\x83\x6c\xda\xbd\x3b\x76\x6c\x52\x6c\xf7\x6e\x05\x9e\x7b\xb9\xc3\x6a\x5b\xd6\x3f\x11\x8d\xda\x48\xd6\xc9\x84\x36\xa0\x54\x65\xd5\x18\xbd\x42\x19\xfc\x18\xfe\xa6\x90\xfe\x59\xc4\xff\x86\xfe\xe1\xf2\x62\xfa\x57\xd8\xde\xff\x09\xfd\xc3\xe5\x45\xf4\xef\x52\xb4\x9d\x2b\xe5\xdc\x48\x0b\x7b\x91\xd3\xe9\x05\xc0\x4c\xc0\xaf\x97\x54\xa9\x40\xb1\xf4\x53\x83\xc8\xa5\x1b\x37\x6f\xdc\x7e\xdd\xdf\xff\x7e\x5d\x8f\x3a\xbc\x4e\x8f\x05\x01\xb6\x70\xe2\xa5\xba\x6c\x1d\x1c\x75\x51\xf7\xc3\x08\x57\x0a\x95\xf0\x35\xf8\x77\xb4\x1a\xd4\xbb\x16\x5d\xcf\x39\xa0\x9e\x11\x99\x1f\x24\x66\x93\x06\x25\x8a\xca\xb3\x8e\x38\xc7\xaa\xcd\xab\xe0\x7f\x6c\xa3\x9f\xab\x14\xbc\xc3\xc3\xb9\x2d\xf8\x6d\x86\x77\x88\xe2\x1d\xee\x85\x77\x78\xb8\x8a\x77\x71\x7e\x36\xb7\x5e\xf8\x03\xcc\x4f\x8d\xe4\x21\x46\x8b\x68\x80\x7d\xa6\x87\x79\x92\x90\x76\x4b\x26\xb7\x7f\x94\xa4\xd0\x9d\xb3\x72\x1b\x89\x9a\x90\x53\x6a\xc8\x68\x0b\xc6\x93\x7e\xbf\x83\x3b\xdd\x36\xb7\x7d\xea\x0c\xd7\xe9\xc2\x4d\xfc\xec\x7b\xb6\x4f\x1c\xd1\xdc\xbe\x63\x27\xeb\xe3\x71\x7e\x1a\xfe\x16\xf4\x73\x90\x71\x25\x11\xf0\x1a\xb0\x89\x6c\xcd\x88\xfa\xb0\x9e\xd3\xd3\xb6\x73\xe8\x58\x70\x8a\xfc\x78\xf6\xa8\x98\xff\x41\x3d\x0c\x56\x74\xd2\x0d\x7c\x94\xeb\x03\xfc\xcc\x88\x3c\x68\x90\x14\x75\xe9\x45\xa2\x27\x3e\xaf\xc6\x74\x79\x46\x23\xe9\x4d\x2d\xd0\xbc\xfd\x72\x06\x77\x23\xea\x44\x6b\x01\xef\x18\xf4\x5e\xeb\x81\xaa\x9e\xa7\xee\xd9\xde\x48\x41\x9c\x12\x3c\x65\xea\x79\x6b\x4e\x3e\x79\xcd\x9a\x93\xe3\x83\x07\xc7\xe3\x83\x87\xf0\xd1\x35\xd3\xa6\x9d\x7b\xee\xb4\xcc\x79\x78\xe0\xe0\x4a\xfa\x65\xe5\x60\x3a\xa6\x65\x72\x07\x17\x45\x16\xd8\x5b\x31\x09\x98\xbd\x16\xf4\x0c\x42\x6c\x40\x36\x00\x10\xe8\x92\x3a\x9e\xe4\x90\x2b\xdf\x61\x7d\x2a\x9f\x2f\x7c\xda\x8a\xd5\xad\x43\xd6\x8e\x66\x29\xb1\xe5\x8e\x15\x73\x47\xae\xae\x58\xb8\x88\x25\xc0\x66\x72\x16\xac\xcb\x5d\x40\xff\x3c\x58\x94\x9e\x72\x1a\x45\x3e\xcc\x27\x78\x62\x11\x8c\xfc\x96\xcc\x3a\x23\x16\x8d\x61\x23\xa7\x27\x46\x58\x26\xab\xd5\x5a\x6a\x85\xbf\x20\xeb\x96\x8c\xce\x08\xca\x18\x4c\xea\xa3\x3e\xbc\xcb\x87\x6f\xf0\xe1\xcb\x7c\x78\x8d\x0f\x2f\xf2\xe1\xe9\x3e\x3c\xc6\x87\x07\xfb\x70\xc2\x87\xb9\xb0\x0f\x77\xfb\xf0\xab\x3e\x7c\xb3\x0f\x2f\xf3\xe1\x46\xf6\xad\xc8\xbe\x3c\xc2\xbe\xbf\x9f\xfd\x69\x2d\xfb\x6b\x5b\xb6\x40\x98\x95\x69\x80\x42\xdf\xb0\x72\x3d\x9a\xe8\x5d\x7f\x9d\x0f\x4f\xf0\x61\x50\x4d\x67\xaa\xff\x56\xb0\x7f\x67\x9c\x71\xc6\xac\x99\x05\xff\x56\xa8\x5f\x77\x9e\x91\xfb\x87\x12\xb3\x66\x1e\xa8\x42\x80\x6f\x2a\xda\xcd\x64\x2f\xb0\x8a\xcc\xc0\xc6\x62\xda\x45\x15\x77\x39\x45\x82\xa3\x38\xf8\xfa\xe4\xe5\x0d\x11\x76\xcb\x7b\xd1\x29\xc9\xb6\xe6\xa1\x25\xca\xf5\xef\x05\xfc\xec\x93\x6b\x6a\x9a\xaf\xbf\xb0\xbc\xae\xc6\x1c\x1a\x79\xdd\x45\x4c\xef\xfa\x04\xe8\xfc\x73\xc0\xbb\x28\x8d\x1b\x20\x05\x74\x7a\xbd\x51\xa3\x41\x1c\x21\x80\x30\x26\x1d\xd7\x93\x2f\x66\x1d\xaf\xb3\xe7\x28\x74\x49\x09\x70\x47\x17\x4e\xb1\xcf\xe0\xa5\x47\xe5\xf7\xe5\x4b\x8e\xc9\x87\x19\x8f\x8c\xc9\x47\x94\x4f\x76\x8e\xfc\x0d\xbe\x91\xb3\x90\x21\xc8\x8e\xaa\x25\x87\xd5\xe1\x04\x32\xc4\xf3\x0e\x50\xac\xf4\x66\xc4\x13\x3d\xf4\xf0\x7e\xdd\x01\x55\x52\xc6\x59\x9f\x30\x35\x86\x10\x3d\x36\xcc\x07\xb2\xc2\x4d\xf3\x56\xac\x69\x0d\x07\xc4\x82\xc8\x3f\xc3\xcf\x8a\xdb\x3c\xfe\x6c\x74\x1f\x8a\x3b\x09\xee\x7d\xee\x08\xdb\x6f\x96\x07\x79\xb3\x09\x23\x9f\x4a\x38\xf4\x9c\x56\x8f\xe3\x7a\x5c\xaf\xc7\xdc\x11\xf9\x3b\x2c\xb6\xc8\xdf\xca\xdf\xb6\x60\xab\xfc\x6d\x2b\x16\xb1\x55\x18\x21\x7f\x47\xdf\x2d\xf2\x77\x2d\xd8\x86\xc5\x56\xf9\x5b\x2c\x2a\xfb\x0e\xe1\x4a\x6e\x2e\xc8\xdc\x34\x67\xcf\x18\x29\x1c\x14\x90\x8e\xb8\x6d\xee\x80\x4e\x10\x0c\x56\xa7\xb3\xd4\x62\x36\x18\x00\x2e\xde\x68\xb5\x58\xec\xc6\x47\x41\x04\x0f\x21\x9e\xa9\x4d\x8d\xa9\xac\x93\x5b\x6e\x02\x0b\x3d\xf9\x42\x58\x89\x36\x52\x2c\x9f\xf7\x23\x34\xdc\x08\x3e\x6b\x54\x4c\x27\xff\x33\x26\x84\xa2\x2f\x55\xe3\xc8\xd0\x15\xdb\x86\xec\x4f\xc8\x44\xd0\x19\xb4\x41\xa2\xe1\x6e\x78\xea\xdc\x94\xd6\x5e\xb7\xa8\x9d\xd3\x31\x11\xfd\x19\x3c\x8c\x89\xe8\x69\xb3\xd7\x17\x74\x8c\xaa\xe0\xa9\xaf\x1b\xc8\x88\xad\xa0\x5f\xeb\x51\xd9\x3e\x10\x4f\x8c\x06\x0d\xc8\x83\xd5\x0f\xd2\xe0\x9a\x79\x21\x35\xc7\xd2\xf2\xca\xab\x69\xa8\xfc\xce\xd0\x86\xcf\xb9\xf9\x05\xb6\x05\x37\x57\x81\xff\xc8\x9f\x85\x2a\x51\x9d\x64\x8b\xba\x60\x66\x02\x1a\x17\xdf\xa7\xaf\x18\x25\xa5\x25\x5e\x6a\x5d\x30\x69\x89\xaa\xfd\x28\x57\xa7\x8b\xd3\x0b\xb0\x38\x50\xff\xeb\xad\x0c\xfc\xc7\x25\x67\xa5\x96\x78\x2b\x3d\xf6\x93\x2a\xfb\xa7\x6a\x27\x4d\x6d\x5d\x31\x7d\x54\x67\xdc\x61\x1d\x16\xae\xea\x5b\x33\xf5\xe4\x56\xee\xef\x99\xb9\x6e\xfd\xf6\x36\x7b\xb8\x26\x5a\x1a\x0f\x04\x66\x34\x8f\x9b\x6e\xdb\xda\x24\xfa\xca\x43\xa1\x78\x49\x60\x2a\xc3\xb9\x9f\x40\x8f\x6c\x87\xf5\x0a\xa0\x49\x52\x94\x47\x26\xbf\x41\xa3\xd1\x0a\x56\x87\x1f\x69\x3d\x76\x51\x0c\xba\x9d\x1e\x4f\x89\xdd\xe9\x14\x4c\x7e\x10\x37\xac\x1e\x98\x8c\xbd\x1a\x9e\xd7\xe1\x02\xed\x89\xe5\xdd\x48\x1d\x77\xd9\x1c\x2c\x58\x6a\x3d\x5d\x2c\x11\x3b\xd8\xb4\xc5\xb5\x30\x90\x74\x23\x8e\xf3\xb8\xa6\xb1\x63\x49\xc3\x53\x75\x3b\x1e\x1c\x20\xbf\xd9\x78\xda\x06\x78\xdc\x7b\x1b\xdf\x18\x8f\x5b\xd7\xae\x13\xe3\x71\xf3\x23\xf2\x3f\xcd\xf1\xb8\xe5\xba\xed\xf0\x69\x78\xf3\x57\x74\x1c\x59\x1e\x7b\x4c\x9e\xff\x7f\x64\x79\x80\x05\x38\x23\xb7\x5a\xd8\x05\xb4\xc1\x2b\xe9\x81\x1e\x70\x5a\x0d\x48\xb1\x28\x91\xc8\xfb\x49\x44\x6c\x11\x1a\xa0\xf4\x0b\xf9\x5e\xfc\xa9\xe0\xdf\xfa\xeb\x64\x54\x50\x4f\x4b\x65\x0d\x2d\xc8\x05\x9c\x5e\x07\x14\x45\x43\xab\x36\xe4\x2a\xe7\x6a\xa7\x94\xfa\x13\xb7\x92\x97\xb6\xe2\xf1\xb4\x89\xff\x8b\x36\xb8\xab\xb7\x72\x17\xfd\x5f\xb6\x81\xc7\x03\x28\x3d\xda\x50\xe6\x80\xe3\x90\x96\x2a\x2c\x28\x51\x97\xc8\xcd\x41\x8a\xd5\xbd\x06\x2a\x6e\x15\xfc\xbf\xaa\xf9\x13\x4f\x85\x7a\xad\x64\xb9\x52\x0f\x26\x8d\xd7\x68\x09\xa5\xa1\x2f\xe7\xe7\x8e\xae\x5d\xc4\x75\xea\x02\xfc\x3b\xb2\xfc\xd8\x2f\x0b\x8a\xeb\x69\x41\xce\x36\x83\x54\xc5\x71\x1a\x9d\x1e\x76\x29\x0f\x32\xf3\xcb\x79\xa0\xd9\x42\xdb\xa2\xac\x85\x83\x0b\xa0\x09\xbc\x41\x3e\x9f\x2c\x97\xcf\x5b\x40\xf5\x11\x90\x7d\xaf\xef\xbe\x1c\xf4\x91\x0a\xc9\x45\x35\x11\x2d\x22\x56\xc2\xe9\x88\x40\x29\x79\x02\x11\x46\xcb\x5f\xce\x0b\x31\x42\x4f\x25\x64\x65\x81\x0e\xc2\xa1\x00\xf9\x89\xdb\x22\xcc\x86\x7a\x5a\x54\x2e\xd9\x40\x6d\x03\xbe\x00\x50\x71\x92\xde\xd2\xc2\x09\x54\x84\x3c\x50\x55\x57\x08\x19\xec\x0a\x41\x11\xb0\xba\x2e\x07\x2d\xe3\xc5\x6b\xae\x39\x44\xe5\x2c\xd0\x2b\xc6\x71\x9f\x93\xdb\x99\x9e\xff\x3f\xea\x9d\xbe\x0d\x5c\x4d\xf7\x15\x00\x6b\xb9\xe4\x24\x3a\x83\x1e\x23\x8d\x55\x53\xaa\x01\xb2\x46\x41\x55\xd8\xce\xcb\x39\x48\x69\xa4\x6e\x17\x95\x97\x1f\xdb\x7e\xfd\xb0\xb5\x7b\xd6\x2d\xbf\xe8\xa2\xc0\xf7\xdf\x07\x50\xef\xb6\x04\x64\x00\x8e\xa2\xb6\xa5\xa5\x42\x3f\xd3\xc0\x52\x2f\x17\xe8\x40\x20\xb1\x53\xad\xee\x77\xeb\xf6\xac\x1d\x76\xfd\x76\x79\x03\x6d\xea\xa2\x8b\x58\x5b\xaf\x82\x3a\xf1\x7e\xf7\x8f\xd0\x96\x5f\x32\x00\xc6\x68\x39\x4e\x6f\xc0\x02\x88\xab\x85\xb2\x32\x00\x42\xe1\xf1\xe0\xf7\x95\xaa\x72\xb3\xd2\x14\xea\xd1\x46\x89\x64\x04\x69\x57\x03\xa3\x01\xb5\x90\xcf\x37\xa2\x6e\x58\x4a\x0d\x61\x54\xaf\x2a\x83\x91\x37\x2a\x63\x63\x73\xbf\x4e\x1e\xc9\xf5\xed\xfe\x86\xc9\x79\x80\xc5\x76\x16\x6d\xd6\xeb\x73\x11\x11\x44\xc6\xd4\x4b\x85\xb3\x2e\x14\xd8\x43\xb5\x05\x09\x4b\xb9\xbe\xe7\x65\x32\xe7\xd1\x9f\xb9\x4d\x35\x35\x4d\xf4\xe7\x33\xe5\xfd\xbc\x8c\xf2\xda\x94\xc5\xbd\x67\xb9\x72\xfc\x33\xe0\xac\x5f\x32\x81\xee\xa5\xd1\xaa\x8a\x6b\xa1\xb6\x19\x2b\xd4\xb9\x9e\x55\x55\x2e\xae\x7b\x17\xd4\xed\x62\x75\x8d\x14\x47\xb4\x02\x36\x18\xcc\xd8\xa4\x53\x5a\xa0\x5b\x8e\xad\x62\x36\xcd\x59\xb6\x9d\x88\xd2\x9a\x87\xb5\x86\x07\x15\x36\x9a\xd5\xe6\xb8\xee\x03\xd0\xf6\xa7\x6a\xdb\x15\x92\x03\x19\x34\xc4\xac\x51\x9a\x06\x55\x4e\xa7\xb6\x3e\x2b\xdb\x3c\x6b\x9d\x69\x74\x11\xf6\x89\xcb\x14\xc5\x6e\xec\x1d\xf0\xeb\xaa\x67\x15\xf5\x2e\x82\xad\x54\xc9\x53\x6c\x79\xf2\x3c\xee\xae\xee\xeb\x60\x86\x2b\x24\xa7\xcb\xa7\xf3\x5a\x75\x8a\xb2\xe8\xe4\xc3\xc6\x84\x91\x33\x52\xbc\x39\xf0\xc1\xcc\x03\x0a\x0f\xf8\x3f\x10\xbd\xe4\x79\xbd\x44\x2f\x68\xfe\x7e\xdc\x8a\x8f\x0a\x17\x65\xd7\xd6\xa5\x07\x21\x9e\x78\x7d\xb0\xc8\x74\x40\x2f\x15\x69\x65\x45\x72\x7a\xfe\x19\x4f\x1e\x79\xca\xec\xe6\x82\x1f\xdc\x9a\x7d\xe4\xbe\xcb\x3e\xd1\x31\xee\x24\x1f\x70\x82\x30\x14\xe6\xd0\xf6\x27\x01\x68\x11\x43\xe5\x3a\x35\x62\x51\xc4\x05\x9a\xd4\x4e\x3c\xfb\xc3\x0b\x84\xa1\x17\x7c\x88\x7a\x96\x87\xfd\x43\x04\x6a\x72\xa8\xcb\xea\x5d\x4c\x4b\x13\x2e\xf8\x10\xcf\x26\x1f\x7c\x78\x01\x2b\x2f\x8f\xe2\x84\xee\x3b\x59\x79\x44\xf5\xdb\x82\xf2\x1e\xaa\x08\x46\x76\x5e\xf0\xa1\x7c\x4b\x86\x96\xee\x59\x1e\x94\x7c\xae\x10\x1e\x58\x37\xd0\xe9\x38\x41\xbe\xe5\xc3\x0b\xe4\x51\x14\x20\x8c\x4a\xe4\x66\x62\xef\xde\xaf\xd0\x72\x02\xe4\x14\x01\x5d\x2c\x36\x00\x65\xa9\x22\xf4\x05\xfa\x78\xc9\x75\xf8\xd9\xeb\x60\x03\x9e\xf1\xf1\xc7\xf2\x66\xa5\x4f\xd6\x06\x42\x45\x34\x99\xda\x22\x72\xf5\x59\x6d\xa0\xa8\x25\xd7\x71\xb3\xa0\xea\x23\xf2\xdb\x5b\xd9\x1d\x12\xb9\x85\xbb\xa6\xfb\x73\x90\x9d\x80\x26\x13\x9d\x0e\xf1\x5a\x2d\xb4\x62\x30\xf2\x28\xd1\x23\x72\x85\x27\x5d\xef\xd1\x46\x5c\x11\x8f\xd6\x79\x6f\x75\x0c\x76\x49\x5d\xac\xfa\x58\xfc\xb1\xe0\xa2\xcd\x8b\x83\x14\x86\xae\x77\x85\x6f\xbb\x6f\xd0\x46\x00\x06\xcb\xbe\x82\xdd\x05\x52\x34\xdb\x09\x8f\xb2\x1d\x20\x7c\xab\x22\x3f\x96\x53\x50\xfe\xa7\xe3\x95\xc7\x0c\xb7\xe5\x14\x43\x6a\xe1\xdb\x02\x7c\x96\x1f\xe3\x67\xe1\x11\xcc\x1e\x65\xdd\xa7\xa5\xe6\x22\x20\x19\x09\x4a\xf8\x58\x2d\xc5\x92\x25\x3f\x76\x1c\x53\x16\xd0\x67\x55\xdf\xb2\x6a\xb8\x1d\xac\xad\x67\xf9\x53\xf0\x20\x66\x4b\xd2\xfd\x91\xf1\x3d\xda\x46\xc4\x25\x3f\x9b\x33\x1e\xe1\x2e\x59\xb8\x06\xd8\x54\x4d\xcf\x32\x5d\x32\xcf\x0b\xd7\x5c\x7b\x2d\x6b\xe7\x4d\x7e\x36\xae\x61\xfa\xb5\x75\x9f\x41\xe4\x31\xaf\xa5\x05\x0f\x50\x98\x6c\x45\x2a\xf4\x09\x15\x68\xdc\x3d\x97\x9f\x86\xb6\x33\x79\x5e\xf7\x47\x50\x17\x12\x2f\xc3\xac\x15\xa8\xca\xd7\xf7\x56\x95\x39\xf9\x23\x7e\x21\x2e\x15\xa6\xb1\x3d\x66\xd9\xab\xb1\xdb\x4d\xb4\x5f\x16\xb4\xc7\x51\xb0\x8f\x22\x05\xcf\x77\xd7\xb6\xb6\xd6\x26\x9b\x9b\xe5\xb5\xb5\xad\x2d\x49\x78\xe0\x17\x8e\xaa\xab\x1b\x39\x22\x55\x37\x6a\x74\xa2\x76\xd4\xa8\xda\xba\x51\xca\x3c\x7b\x84\x17\xba\x9f\xd7\x56\x81\x3e\x63\xfd\x93\xd5\x0c\x98\x21\x52\x1c\x56\x74\x22\x76\x5e\x46\x43\x9a\x32\xf7\x46\x6a\xdf\x3d\x92\xea\xdb\xd2\x1c\x9e\xb6\xf0\xeb\xf6\xe9\xcb\x47\xd6\x6a\xd6\x87\xcb\xbc\xa7\x85\xb6\x0d\x9e\x6c\xac\x3b\x87\x84\x98\x2e\x56\xc3\x47\xd1\x9b\xaa\x4e\x6f\x7a\xd0\xa4\xb1\x2b\x64\x80\xcd\xd0\x71\xb5\xf4\xff\x48\x47\xe7\xe4\xcd\x80\x0f\x67\xa8\x3a\x9e\x75\x9f\x8e\x62\x44\x96\x20\x2b\x18\x91\xd5\xde\xe4\xcd\x27\x56\xdf\x7a\xe0\x15\x88\x12\x18\x51\xf3\x8d\x8a\x57\x59\x09\x02\x8f\x38\x8e\x19\x13\xd6\xee\x05\xbe\x0d\xd5\x33\x3b\x26\xac\x1d\x66\x6b\xe7\x00\xf1\xa5\x3e\x67\xb6\x84\xf1\x4f\x81\x32\xf7\xb0\x32\x5a\x18\xbf\x86\xd1\x1c\xd8\xdc\x30\x9b\x50\x92\x96\x1e\xb2\x74\xe9\x67\x4a\x05\xf9\x09\x56\x89\x93\x4f\x07\x98\xfe\x24\x6c\x61\x63\x73\x48\xfa\x1e\xfc\x26\xbb\xad\x14\x36\x93\x50\xb8\xcc\x40\xf6\x0b\xea\x15\xb1\x19\x68\x8b\xe1\xa8\x66\x03\xe0\xa8\x0f\x35\x48\xb1\x46\x4f\x9b\xe7\x88\x87\x78\x24\x9b\xb3\xc5\x43\x93\xa8\x7b\x3c\xda\x46\xd0\x06\x6d\xd8\xa6\x35\x2c\x27\x98\xed\x2c\xba\x19\x67\xd6\xa5\x0e\xcc\x5c\x61\xa3\x77\x28\x57\xf4\x44\xe7\xc2\x1b\x01\x45\xa8\x2d\x1f\xce\xa1\x6b\x0e\xc9\xf1\xa5\x05\x36\x1e\xba\x67\x3a\x61\xcf\xdc\xc6\xf6\x8c\x96\xce\xb7\x91\x89\x5a\x6c\xcf\x00\xdb\x89\x32\x65\x89\x32\xa1\x4b\x77\x08\xb4\xe1\x09\xa7\xba\x4f\xe7\x76\x08\xb7\xed\xdc\x31\xe9\xa4\xa6\xc9\xdb\xef\xa1\xf3\xde\xc9\x0f\x40\xb7\x0a\xbf\x20\x1b\x9d\x77\x8a\x9f\x6c\xcf\xd0\x2b\x15\x2e\x67\x88\x53\xe0\xba\x75\xe7\x4d\x63\x5b\xa3\x55\xd1\xd6\xc6\x91\xed\xfc\xfb\x2b\xb6\x04\x47\x3a\x07\x54\xfb\x4a\x43\xf1\x48\x62\xd0\xc9\x3d\xda\x10\x09\x6b\xc3\x01\x58\x9d\xa6\xa7\x17\xfd\x38\x05\x33\x0b\xdb\x10\x26\xfe\x76\x1b\x79\x38\x94\x68\xf8\x1c\x55\xf8\x5c\xfd\xf0\xad\xed\x23\x1b\x59\x1b\x63\x6f\xda\x29\x4c\x1c\x97\x19\x94\x88\xc4\x43\xa5\xbe\xaa\x7a\xe7\xc8\xe0\x16\x18\x3e\xe2\x07\xe0\xa6\x62\x38\x70\x4f\x38\x70\xd3\x6f\x02\x82\xd4\xd8\xb8\xe8\x63\x66\x1b\x0e\x82\x34\xa1\x9a\x85\x55\x5b\x76\x37\xe1\xa9\x98\xb8\x82\x92\x58\x07\xc3\x9a\xcb\x7a\x58\x97\xff\xf3\xfa\x84\x91\xe8\x8f\x8b\xcd\xca\x50\xbf\x49\x1e\x89\x9e\xec\x3e\x0c\x58\xae\xd9\x03\x2b\x4a\x77\x82\x62\xc6\x7c\x92\x1a\x4a\xe5\x91\x1b\x37\x6f\x44\x3d\xcb\x71\xb4\x9c\x96\xb9\x98\xb9\xa2\x4f\xd0\x72\x31\xa5\x18\xe0\xc9\x1a\x7e\x27\xbe\x50\x33\x1c\xe0\x31\x3c\xc0\x51\x33\x2c\xdd\x33\x20\x83\x83\x5e\xf2\x76\xd7\xed\xc4\xc0\xef\xfc\xf1\x4e\x79\x8e\x32\xf6\x6f\xc8\xe5\xf8\x4a\xe1\x63\x24\xc2\x1c\x1a\xd4\x75\x60\x4a\x78\x96\xc2\x58\x05\xdb\x6b\xee\x9a\x11\x53\x5a\x27\xcd\x93\x67\x92\x6f\x26\x4e\xb2\x07\xc2\xd5\xcd\xd2\xb8\x85\x1d\xf2\x87\xab\x94\x36\x6e\x00\xb8\xe6\x02\x5c\x66\x68\x83\x37\xa0\xc4\x2b\x00\x59\x91\xd5\xd8\x95\x35\x1a\x7f\x5b\x68\x33\xee\x4e\xc3\xbc\x1d\xec\x7e\x06\xc6\x63\xd9\x0b\xaa\x0d\xe2\x15\xe3\x2f\x9d\x28\xc5\x58\x7c\x10\x86\x24\x37\x33\x6b\x71\xcf\xf2\x9c\x46\x93\x35\x30\x03\x97\x75\x29\x96\x5f\x5a\x7e\xa8\x5a\x9c\xcd\x57\x33\x7a\xa2\xfb\x69\xa0\x04\x9a\x3d\x1a\x65\x5e\xf3\x06\xe2\x27\x14\xfb\xb0\xfc\x78\xce\x3e\x2c\x3f\x2b\x1f\xc1\x83\xba\xcf\x62\x34\x89\x9d\x49\xe4\x79\x9b\x7c\x44\xe1\x6d\xf2\x37\xf2\x58\x1c\x41\x57\xc3\x7c\x99\xf7\x5a\x0c\x4a\x5e\xdc\x54\xa2\x47\x14\xcd\xa1\x38\x82\x0b\x92\x38\xe1\x48\x2e\xc2\xc1\x61\x2a\x3f\x20\x79\x2c\x57\xa7\xb6\xc1\x9b\xf4\xcc\x9b\xae\x2e\xc1\x84\x3a\x25\x01\x5b\x36\xf0\xc4\x45\x8f\xbc\x84\x23\x05\x51\x0a\x1e\x3d\xac\xc6\x26\x00\xde\x27\x2f\x43\xdb\xbb\x6f\xa3\xb6\xac\x7d\x7a\xa6\xce\x31\x6d\x06\x66\xfe\x78\x1c\xf0\xe7\x42\x5b\xb1\xfc\x91\xbc\x15\x97\x76\xaf\x57\x79\x20\x32\x51\x01\x33\xa1\xea\x1e\xff\x29\x0f\x94\xb7\x1e\x8f\x07\x02\xcf\x92\x07\xa3\x37\xbb\x3f\x51\x79\x96\x1d\x51\xeb\x7c\xea\xbf\xe0\x59\xf2\xe0\xe3\xda\x95\xbb\x3b\xbb\x7e\x44\xb7\x82\xbc\x67\x43\x01\xc9\xbe\x96\x6c\x21\x37\x93\x57\xc9\x11\xf2\x0d\xd1\x90\x65\x22\x06\xc4\x9d\xf9\x12\xec\x30\xcf\x6f\x91\xa1\x7f\xf6\xde\xfc\xb8\xbb\x9f\x3c\x16\xbd\x81\xaa\xa0\x5d\x9f\x64\x32\x98\xcd\x02\x49\x20\x1a\x0b\xdc\x04\xb8\x35\xb3\x4e\x65\xde\x05\xf9\xe8\x53\x2c\xa8\x7e\x9d\x9a\x71\x3e\xb5\xcc\xf3\xf0\x15\xf2\x58\x35\xb9\xfc\x33\x4b\x69\x2e\x79\x05\xf7\x2a\xe4\x49\xe8\x3d\x20\x05\x56\x98\x05\x8b\x09\x50\x16\x50\xbb\x2e\x3b\xbf\x05\xe6\x6e\x5b\xa1\xb5\x7b\x52\xb1\xb5\x9b\xf1\x49\xd8\x5b\xf5\xec\x9c\x0d\x64\x29\x52\xc8\x27\xd5\xe3\x34\xba\xdf\x81\x18\x5d\xd8\xfd\x37\xc6\x25\x79\xc4\x69\x54\x2e\x49\xb5\x6e\xea\x61\xf6\xb6\xdc\x71\x1f\x31\xc8\xcd\x3f\xfe\x88\x6f\x84\x6d\x8f\xe5\x2b\xe5\x87\xf0\xd2\xee\x0b\x90\x17\xd5\x48\x7a\x83\xcb\x45\x65\x2f\xbb\x85\x26\x78\x37\xeb\xc5\x16\x8b\x55\x35\xaa\xf3\x4c\xcd\xa9\xa2\xc2\x91\x22\xcc\x6a\x61\xc1\x52\xca\xba\xa5\x9c\x6a\x7c\xc3\x0a\xfa\xcd\x1f\x60\x5b\x8f\xea\xcf\xce\x97\xe6\x0e\x1d\x3a\x17\xf6\xf7\xa8\x5f\x5a\xeb\x92\xa3\xe9\xd9\x53\x7b\xfb\xaa\x49\xc9\xd1\x8a\xbc\x00\x70\x8e\x60\x76\x08\x9f\x64\xd1\x22\x60\x97\xc5\x06\x08\xca\xc8\x84\x9e\x82\xc3\xca\x22\xb9\xa1\xb8\x0d\x42\x77\x13\x16\x35\x61\x4d\x02\x94\x7a\x55\x9b\xa7\x11\x57\xb5\x51\x26\xd7\xfe\xfb\xdf\xff\x1e\xfb\xee\x5b\xef\xc9\xcd\xb7\xdd\xa6\x48\xb5\x2a\x1f\x85\x36\x6a\xba\x2f\xa1\x7c\x9d\xc2\x01\x6d\x18\x8a\x86\xfc\xbf\x08\xa1\x72\x73\x4e\x08\x3d\x5e\x5b\x44\x34\x84\x0d\x09\x03\x31\xe4\xda\x72\xe4\x18\x33\xd5\x0e\x9f\x77\x9f\xd2\xde\x3e\xd7\x06\x9c\xf9\xf7\xc0\xa7\xe5\xe6\xc9\x4d\x23\x26\x6e\xbf\x67\xe7\x0e\x05\xb6\xfb\xa0\xbd\x0e\xe0\x25\x1e\x14\x96\xec\x79\xbd\x93\x9e\x6b\x24\x8c\x24\xaf\x79\x52\x54\x3a\xbe\xd2\xb9\xe6\x44\x3a\x67\x73\x6f\x9d\x93\xd2\xbc\x63\x40\xf3\xae\x84\x25\x30\xed\x85\xfd\x8b\x39\x85\x8a\xe4\xe8\xde\xb1\xac\x4c\x2f\x77\x71\x5c\xf7\xd5\xc7\x2b\x47\xe5\x7a\xb9\x8b\xc9\xf5\x1c\x94\x4b\xaa\xe5\x28\x36\x0a\x3c\xa3\xa3\x2f\xa9\x1a\x80\xa0\x96\x3e\x7a\x4c\xa9\xf1\x12\xad\x04\x63\xe6\x5c\xb8\x83\x34\xc3\x98\x3d\x92\x51\x19\x2b\x67\xa4\x63\x4f\x1c\x48\x7d\x30\xb3\xee\xc0\x7f\x3f\x56\xce\x75\xdc\xb1\x72\x9d\x78\x10\xf7\xe3\xf1\x74\x17\xae\x33\x3b\x4e\xae\x93\xe3\xb8\x9f\x8e\xa7\xbb\x70\x9d\xaa\xee\x52\xda\xfd\x0f\xfc\x11\xd9\xcd\xca\x30\x1b\x1e\x8d\xb9\x8d\x3d\xf2\x92\x71\xe4\xcc\x71\x4e\xfa\xa1\xf4\xf7\x28\x94\x9b\x0d\xfa\x09\x41\xfa\x07\x08\x3d\x7f\x68\x84\x3d\x14\xc5\xa9\xfd\xbf\xe7\x7c\x97\x3b\x85\x5b\x7b\xf2\x4e\x03\xcf\x78\xa7\xa7\xe8\x04\xd7\x9d\x3d\xc0\xfd\xb6\xf0\xfc\xb6\x68\xcf\x0b\x4c\x09\x64\x9a\x81\x60\x8b\x30\x7d\x17\x5f\x78\xec\xa7\xfb\xf0\x7d\x21\x79\x0e\xbe\xf1\xc7\x1f\x81\x2e\xd7\x03\x2f\x7c\xa1\xfb\x00\x5b\x17\x90\x8b\xb5\xb5\x58\xc2\x1c\xd6\x50\x81\xfd\x25\x86\xa3\x11\x5b\x84\xa4\xa3\xae\x17\xe4\xa5\xf8\xca\x8b\x2f\x80\xd6\x7f\xd7\x8d\x2e\xb8\x80\x8d\xe3\x5a\xf9\x26\xbc\x00\xe8\x85\x9f\xd2\x0b\x62\x32\x39\x90\xd5\xea\xd2\x29\xf4\xc2\xdc\xa2\xf3\x88\x8e\xb0\x23\xe1\x20\x0e\x95\x5e\x50\xab\xa4\x62\xa4\x60\x78\x1f\xc4\x51\x25\x1d\xac\xb2\x7a\x1e\x66\x88\xc6\x1e\x73\x63\x65\xba\x79\x42\x73\xba\xcf\x30\x73\x87\x65\xe9\xe8\x79\x43\x86\xcc\x6b\x59\x62\x93\xff\x56\x5e\xdd\x92\xf2\xfb\x6b\xc7\x54\x97\x8f\x98\xd1\xde\x9e\x19\x05\x73\x14\xe5\x43\xe8\x03\xe1\x6d\xa6\xe7\x69\x55\x5d\x41\x1b\xd7\xc6\xeb\xe3\xf5\x1e\x50\xaf\x3f\x18\x75\xcd\x35\xd9\xff\xf9\xd3\xe9\xaf\x6d\xca\x0b\x9d\xdf\x75\xbc\x19\x9d\xa7\x49\x30\x4e\x67\x32\x52\xae\x94\xa0\x79\x19\x80\xa8\xe7\xd9\x44\x81\xf0\xbb\xae\x7f\xff\xd2\x8a\xd2\x0d\xab\xd4\x5f\xfc\x5a\xe2\xf1\x7b\x6a\xea\x06\x45\xdb\x4f\x3e\x23\xff\x48\xf1\x5c\xb8\x16\x74\xdc\x5f\xd9\x7c\x46\x24\x17\x5a\xcb\xdd\xcf\x3d\xc9\x11\x4e\x72\xfb\x5a\x0a\xec\xa0\x2f\x55\x55\xcd\x3c\x0e\xf2\x6b\x4e\x53\x90\x1f\xcb\xc3\xf8\x4e\x84\x84\x2b\x4e\xa4\xff\x4f\x51\x74\x93\xce\xac\xfe\x0f\x32\x6f\x27\x7e\xfa\x78\xe5\x6d\x4c\xb8\x64\xb2\x25\xdf\x99\x93\x2d\xe5\xfb\xf8\x16\xdc\x21\x9c\xfb\xff\xe2\xde\xe2\x5b\x8e\xb3\xb7\x40\x9e\xb7\x83\x3c\xff\xd6\x7f\xae\x13\x24\x7a\x72\x63\x22\xff\x01\x60\x9d\x29\xbc\xcf\x64\x87\x20\x72\x3e\x04\x92\x09\x28\xe8\x01\x2f\xb3\x92\xff\xb6\x7c\xe2\xa1\xfa\x2a\xf9\xbe\x46\x1a\x5e\x5d\xdd\x38\xac\xeb\x3b\xf5\xe1\xd4\xc6\xef\x0f\xf3\x53\xa4\x9a\x9a\x61\x43\xfb\xf5\x6b\xa4\xbf\xa5\xaa\x7e\x8d\x96\x08\x3e\x33\x26\x6f\x65\x70\xcf\x83\xfd\x77\x3d\xd0\x3f\x13\x72\x49\x46\x1d\xa5\xdf\x61\x21\x21\x70\x02\xe0\xb2\x42\xbb\xcb\x94\x88\x96\xf4\x9c\x51\x63\xea\x98\x78\x63\x5d\x38\xd8\x47\x92\x47\x4e\x9d\x70\xc7\x8d\x23\x6d\xe3\x13\x85\xf2\x36\xdd\x8b\x1c\x13\x4b\xeb\x7a\xf3\x5f\x10\xba\x15\xfe\x5b\x4c\x23\x2b\x1f\x46\x42\xf7\x47\x92\x1b\xd0\x46\xb8\x85\xdf\xc3\x83\xbc\x5e\x0a\xcf\x28\xcc\x25\x80\x0e\xd1\x1d\x55\x05\xfb\xb3\xea\x37\xe8\x27\xe8\xc9\x30\x86\x7b\x98\x8c\xc0\xa8\x81\xb2\xab\x7b\xeb\xc9\x54\x60\x50\xf5\x64\x9c\xa3\x07\x02\x72\x3c\x40\xb0\x40\xe3\x03\x99\xac\x2d\x30\xec\xaa\x97\x53\x4c\xc4\x00\x6d\xe1\x85\x8b\xe5\x9f\xf0\x95\x40\x0a\xd0\xef\x14\xde\x44\xbe\x05\x5c\xba\x85\x79\x60\xba\xac\x0e\x8b\xcb\x65\x10\x38\x2d\xd2\x5a\x7c\x3e\x0b\x92\x4c\x20\x3a\x50\x9a\x60\x82\x07\x64\x41\x96\xb5\xa0\x17\x53\x81\x65\x26\xbb\x8d\x5d\x65\x4b\x25\x14\x53\x6f\x4a\x35\xf8\x02\xde\xc1\x16\x2e\x20\x0c\xb0\x95\xf3\xc8\xd7\x50\x9f\x3a\x67\x50\xb9\x5f\xc5\xbf\x01\x83\x52\xe7\x34\x54\x78\xb2\x18\x58\x1b\xee\x6c\x5a\xe8\xa3\x48\x18\x9a\x39\x7c\x81\x57\x41\x43\x02\xf0\xed\xc2\x1d\x9a\x7f\x03\xf6\x44\x41\xa8\x88\x4a\x22\xe0\xb9\xd3\xc8\x1b\x01\xa1\x8c\xf1\x48\xa0\x86\x59\x63\x14\x87\x7c\xeb\x81\xc4\x6f\xf1\xd0\x42\x2d\xdd\x56\xf0\x7c\x42\xde\x7a\xd7\xa8\x54\x6a\x54\xe1\x0f\xff\x70\xf1\x2e\xc1\x7f\xa1\xdf\xf7\x1f\x35\xaa\xeb\x7d\xf5\x41\x91\xc5\xef\x23\x5f\x02\xcc\xe3\x29\x5d\x42\x49\xc9\x57\x1d\x2d\x89\x02\xd4\x51\xf8\xcf\x9b\xe7\xfa\x95\xa5\x5e\xba\x5f\xdf\x87\xfd\xca\x2e\x14\x58\x0f\xa4\xe8\x10\x4e\x0c\x3f\xf9\x2f\xf7\xf4\x69\x27\xf8\x5e\x08\x16\x8f\x42\x7e\xf9\x78\x7c\xf5\x9f\x72\x0b\xb6\x77\x7f\x0e\xfa\x8c\x66\x8f\x81\xe9\x59\xf1\xfa\xa8\x47\x1b\xa7\xb6\xcf\x14\xd0\x68\xd7\xe9\xd5\xb1\xc7\x62\xd5\xf7\xde\xab\xfc\x92\x5b\x82\x8b\x17\x07\x1f\xa3\x56\xd0\x45\xf0\x4b\xa1\x1f\x49\xc0\xc7\xd7\xba\x0f\x22\x3d\xb5\x07\xe8\x14\x1a\x1f\x07\x6d\x0d\x50\x24\xe5\x79\x70\xf1\x66\x5a\xf2\x31\xf9\xfb\x8a\x37\xde\xa8\x80\x86\x68\x1d\x6f\x57\x18\x26\xf0\x23\xe1\xcf\x8c\x5e\xd0\x15\x1f\x8c\x46\xa1\x89\xa8\x13\x2d\x42\xab\xd0\x06\xb4\x05\xdd\x80\xee\x44\x0f\xa2\x27\xd1\x5f\xd0\x41\xf4\x3a\x7a\x1b\x1d\x46\x47\xd0\x27\xe8\x73\x74\xbb\x34\xf9\xc5\x43\x91\xc0\xfa\xc7\x1f\x5f\xf3\x50\xfb\xcc\x99\x63\xa6\xfe\x71\xc1\x82\x5d\xa7\x89\xc4\xa5\xd7\xff\xed\xb3\xb3\x76\xee\x5c\x76\x73\xc3\xc8\x91\xa9\xc6\x3f\xbf\xba\xfd\xf7\xbf\xbf\x6a\x53\x4d\xfc\x50\xe0\xa1\xa9\xa7\x91\xcf\x6e\x6e\x7c\x75\x53\x3c\xbe\xe9\xd5\xc6\x9b\x3f\x23\xa7\x4d\x7d\x28\x70\xc8\xf4\xda\x7b\xcf\xff\xf5\xaf\xef\x3e\xf7\xe6\x07\xcf\xbc\xfc\xf2\x87\x07\x5e\xa3\xac\x85\x12\x2a\xf5\x97\xdd\x03\x4b\x95\xff\x67\x2b\x72\x93\x28\xfc\x38\xce\x17\xd4\x8f\x2b\x8f\x76\xb1\xc2\x30\x12\x27\x40\x4d\xe1\x3f\x28\x5f\xf8\x7d\xfc\x04\x65\xc8\x7f\x50\x57\x38\x41\x99\xa2\xef\xd9\xa1\x80\x8d\x99\xee\xa9\x63\x96\x2d\xc2\x44\x93\x94\x10\x61\xdf\x46\x98\x57\x20\xfc\xc8\x38\xe4\x76\x87\xe8\x0f\xb9\x26\xfb\x24\xa7\xb3\x4f\xd9\x1f\x3c\x22\xfb\xd4\x75\x4e\xf6\x89\xbb\xb8\xf7\x77\x73\x72\x8d\x4d\xc8\x3e\xfd\x9b\x7e\x84\x5d\xd0\xea\x2d\xf4\x93\xb5\xd6\x99\x7d\xea\xba\x27\xfb\x57\x32\xfe\x38\xdf\x3d\x33\xe7\x10\x1e\x28\x3f\x7f\x68\xce\xd1\x55\x87\xe6\xd0\xa7\x39\x87\xb8\x91\xf2\xf3\xf4\x09\x0f\xe4\x46\xcc\x99\xf3\xeb\x1f\xe6\xcc\xe1\x3e\x2a\x86\x35\x24\x8f\x51\x1f\xc8\x6e\xf5\x61\x45\x8f\x12\x5d\x9b\x7b\x7c\x71\x8f\xf2\x3b\x8c\xcf\x52\x7a\x0e\x75\x3d\x91\x6d\x63\xae\xfa\xa0\x42\x17\xfe\x44\xfd\x2d\x3f\xa4\x16\xfd\x9b\xfa\x9b\xcc\x3d\x34\xe7\xd7\xc6\x39\x87\xf8\x18\x00\xfd\x6b\x23\x1e\x78\x68\xce\x1c\xfe\x97\x39\xc7\x36\x28\xe0\x2a\xfb\xec\x5c\xd2\x8d\x2e\x12\xee\x03\xfd\x49\xf7\x47\x0d\x56\xec\x3d\xd1\xb4\x72\xe2\xb8\x38\x40\x0f\x1c\x49\xf7\x30\x76\xde\xa8\xda\x76\x78\x0d\x9a\x2b\xdc\x08\xf2\xa9\xe9\xc1\x9c\x7b\x20\xd4\x39\xbe\x7d\x87\x7f\x3d\x6f\xe0\x29\xb6\x9f\x26\xa5\x10\x6f\x34\x7a\x76\xda\xfe\x64\xe3\x36\xda\xae\xb6\x71\x6e\x5b\x85\x8d\xe3\xa9\xed\x94\x99\x32\x3d\x4c\xdf\xb6\xa5\xa8\xe3\x93\xad\x81\x0a\x68\xc5\x26\xcd\x42\xb4\xa4\xe6\xcd\x9c\x12\x65\xce\x0c\x57\x8c\x1b\x9a\x0d\x3b\x77\x28\xba\x94\x7c\xb6\x34\x8d\x59\x3e\xa8\xec\x08\xbc\xf1\x83\x6e\x19\x68\x84\x76\x8f\x80\x7c\x89\x13\x8b\x8e\xf2\xe5\x45\xa2\x23\xd4\x5d\x0d\x34\x69\x13\x3b\xaf\x05\x5d\x40\x50\x64\x9a\xec\x09\xef\xa6\x5e\x07\xbc\xc5\xe5\xd9\xa9\x2e\xcc\x53\xf6\x2c\xf7\xa2\xde\x67\xb9\xf2\x66\x7a\x1c\xc5\xca\xdb\x40\xda\xb1\x1a\x8d\xbc\xa8\xa7\xf5\xde\x3f\x50\x67\x67\x53\x80\xb3\xb5\x63\xd9\xa3\x69\x79\xb3\xd2\x0e\x4e\xab\x67\xd4\x6a\x7b\x43\x73\x47\xd5\x3d\xd6\x2c\xe7\x22\x4a\xdd\x08\x8f\xab\x57\xf0\xaf\xe7\x15\x0b\x8c\xbe\xe0\xb7\x83\x7c\x79\x06\x93\xb5\xf5\x44\xb1\x81\x15\x46\x12\x79\x5a\xaa\xa9\x96\xa4\xea\x1a\x49\x10\x94\xdf\x92\xd2\x67\x5f\x18\xfb\x5b\xdd\xcf\x33\xf9\x8f\x1e\x90\x52\xfa\xed\x89\xd6\x2b\x33\x1d\x4f\x69\x61\xb2\x81\xbd\x97\xaf\x8c\x5e\x91\xb8\xfe\xfa\xc4\x15\xd1\x95\xe5\x57\x24\x6e\xbc\x31\x21\x7f\xba\xe3\x96\xb3\x17\x55\xd7\x2c\x5c\xb9\x63\xc7\x8a\xf9\xd5\x55\x0b\x11\xf0\xf1\x75\x20\xa9\xac\xeb\xfe\x46\xa5\xea\x61\xc9\x5c\x13\x08\x88\xf1\x48\x44\x63\xd7\x13\x97\xc8\x64\x9b\x86\x86\x9c\x55\x42\x39\xe6\x8e\xe7\xd3\x7c\xba\x95\x24\xbf\x42\xc1\x91\x77\x7d\xd6\xda\x44\xf3\x82\xae\x3b\x2f\x93\xce\x04\x83\xf0\x71\x5e\xfe\x49\x1e\x9b\x3d\x0b\x9f\x5f\x70\x28\xde\xaf\xb2\xb2\x1f\x3d\x18\xaf\xa9\xac\xac\xc9\x1d\x8e\xd7\xe4\x0f\xc9\x71\x77\x39\xdf\x86\x8e\x68\x96\x29\x36\x49\x41\x60\x36\x49\xb6\x76\xa4\x3e\xea\x48\x69\x53\xa4\xa2\xf1\xc7\xe5\xd7\x48\x3f\x2e\xe3\xdb\x5e\xc4\x53\x5e\x94\xef\x81\x3a\x07\xe5\x55\x82\xa5\xfb\x51\xe0\x97\xd6\x7d\x4c\xe4\x34\x0a\x59\x35\x0c\x97\x95\x57\xc4\x53\x6e\x3e\x55\x57\x4e\xf9\x35\xcf\x2d\xfe\xb3\x7c\xf8\x7e\xd3\xbc\x7e\xb8\xf6\xfd\xf7\x71\xb2\xdf\x3c\xd3\xfd\xf2\x7b\xf2\xaa\xc9\xd7\x64\x46\x75\x74\x8c\xca\x5c\x43\xfd\x6b\xba\x0f\xf2\x9d\x82\x45\xf8\x03\x6b\xcf\x28\x0a\x58\xd0\x31\x75\xf0\x3f\x6e\x8f\xef\xec\xd9\xde\x5d\xfc\x3d\xc2\xd0\x42\x1d\x98\x80\xe4\x99\xe6\x8f\xf0\x77\x6d\xdb\xa6\xac\xf7\x41\xf9\x23\xfe\x9e\x62\x5b\xa9\x5a\x46\xfe\x28\x5b\x66\x3f\x0f\xd4\x5e\x98\x83\xbc\x54\xf7\x70\x09\x2c\xaa\xbe\xd9\xae\x2f\xd0\x3d\x70\x59\x3f\x4e\xd9\xe0\x5c\xaa\x2e\xc4\xa9\xd6\x16\xf2\xf8\xbc\x27\xee\xbb\xb1\x79\xd6\x6a\x71\x81\xa9\xf3\x9a\xd3\xe0\x65\x47\xf3\x0c\x78\x71\x3f\xc5\xa7\xfa\x26\xfb\x4a\xa9\xb6\x0b\xc7\xf4\xa9\xeb\x33\x2c\x75\xc1\x8d\xa8\xe7\xf8\x75\x94\x98\x98\x84\xec\xb9\x08\xae\xe3\x69\xc8\xd5\xf2\x68\x19\x4f\xa9\x48\x39\xb7\xf8\x69\x1c\xa3\xe3\x97\x5f\xfb\xe0\x43\xf9\xf5\x1a\x18\x3f\xae\x10\xfe\x30\x79\xdb\xb4\x51\x1d\x13\x9b\xd5\xf1\x4f\x94\x5b\xc8\xeb\xec\x7c\x57\xb5\xc7\xe3\x78\x3d\x70\x2c\x2a\xc9\x90\xf2\xea\xd8\xb1\x01\xe4\x45\x55\x8c\xd9\xac\x0a\x30\x1c\xf2\x71\x15\xdc\x48\xfe\x4c\xa0\x74\x51\x7a\xc3\x2e\x64\xb2\x6a\xa3\x51\x42\x3c\x26\x52\x1e\x8b\x18\xf6\xe3\xc6\x87\xfc\x5a\x8d\xc7\x6a\x25\x9a\x47\xf1\x30\xe4\x80\x6e\x86\xb0\x8b\x5b\x0d\x89\x06\x7b\x83\xe2\x6a\x57\x78\xff\x92\x5d\xa1\x8b\x32\xa4\x66\xa1\x36\xb3\xd7\x42\x06\x38\xb4\x6a\x24\xa6\x7a\xdc\xf0\x66\xc3\x6b\xe6\xda\xf1\xd1\xfb\x96\x6e\x69\x9d\x58\x3b\xdc\x53\x79\xd5\xf2\xba\x41\xfd\xca\x83\xe5\x69\xfe\xcc\x1b\xe5\xad\x96\xca\xaa\x52\xcf\x5d\xd3\xa6\x72\x5c\xc7\xdc\xf0\xa8\x4b\x5c\xf2\x7b\x1c\x37\x68\x68\xaa\xd6\xa5\xf8\xf0\x70\x71\xfc\x2f\x7e\x25\xcb\xe5\x53\x2f\x39\xbc\x82\x46\xe3\xf0\x99\x79\x07\x5f\x12\x14\x4c\x56\xaf\xd7\x60\xa5\x17\xcc\x5c\x05\x70\x02\x98\xf9\x90\xa7\xca\x5d\x85\x3a\x77\x90\xda\xab\xa9\x99\x8c\x9e\x20\xb1\xcc\x00\x1e\xd8\x73\x34\xbb\xab\xef\xcc\x79\xf2\x3b\x25\xd2\xa0\x41\x63\x42\xcb\xfb\x5d\xbe\xe1\xdf\x55\xc1\x0d\x01\x7e\xe5\xea\x0b\x92\xfa\xa9\xe3\xfa\xd8\xfa\x39\xfc\x57\x5c\x87\x63\x43\x67\xb7\x2f\x1f\xce\xe0\xc9\xfb\x23\xba\x80\x57\x98\x0c\x82\xe0\xf6\x38\xcc\xf4\x94\xcd\xfc\x28\xae\x46\x1a\xa4\xc3\x83\x7b\x78\x27\x36\x56\x1d\xc7\x41\xb1\x48\xac\x51\x9d\x15\xf7\xd6\x57\x00\x65\x88\xc7\x07\x28\x5e\x8b\xf4\x8e\xdd\x5f\x2a\xfb\xf7\xaf\xac\xa8\x1f\xa0\xf6\x5d\xc1\xf5\xe5\xcf\x42\x06\xe4\x46\x31\xc9\x60\x13\x8c\xa0\x16\x79\xbc\x16\xdd\xa3\x30\x78\x27\x22\xcc\x73\xb1\xb1\xe8\x76\x9d\x93\xa5\xd9\xeb\xed\x59\x73\xc1\x45\x72\xf7\x9a\x4b\x37\x9d\xbf\xa7\x2c\x5d\x13\x8b\xd5\xa4\xcb\x48\xdb\x75\x5b\x71\x9f\x2d\xd7\x5e\x7d\xe5\x59\x2b\x67\x5f\x72\xd9\xa9\xe7\x00\x7a\xda\xb8\x28\x77\x31\x3f\x17\x7a\x1b\x2c\x59\xf4\x3c\xb2\x58\x1c\xbc\xc3\xe3\x45\x5a\x87\x9b\xba\x1b\x8a\x82\x60\xd3\x52\x4f\x51\x13\xe2\xd4\xae\x15\xb7\xc3\x86\xa2\xdb\xa1\x18\x86\x48\x6f\x36\xa6\x72\x77\x5a\x53\x14\x67\xf0\xce\x33\xc7\xdd\x38\xf0\xef\x55\x95\x35\xfd\xfa\x7f\x5c\x7f\x98\x3b\x4d\xba\x03\xcf\xb3\x54\xca\x6b\x52\x03\x9d\xf8\x0e\x78\xe0\x98\xcf\x26\x5d\xff\x1f\x60\xcc\x5e\xd4\x47\x32\x39\x98\x17\x91\xcf\x6f\x26\x56\x3d\x1d\xb3\x3b\x37\xe6\x82\x3e\xa1\xc7\x82\x54\xca\x45\xe9\xfa\xf0\x0f\xc1\xd9\xb5\xd7\x5c\xb3\x6d\xdd\xf8\x05\x55\xbe\xd8\xc0\x01\xcd\x63\xda\xa7\xd6\x73\x93\x3c\xee\x2d\xd7\x5e\x76\x93\xeb\xce\xd3\x02\xe7\x2f\x58\xb5\xc0\x96\xdb\x27\x17\xc2\x3a\x3b\x51\x18\x0d\x91\xcc\x26\xe4\xf7\xdb\x5c\x1a\x9b\x86\x46\x3b\x1f\x6e\x80\xb5\x35\x23\x11\xd6\x3b\x88\xf4\x00\x87\x37\x07\x47\x63\xf1\xdd\xd8\x1e\xc0\xc4\xd3\xea\xe0\x49\x41\xfa\xe7\x9b\x6b\x86\x95\x9f\xbf\xfa\x82\xdf\x35\x35\xf1\x0d\x9f\x0f\x7b\xef\x6f\x03\xd3\x89\xfe\x35\xc9\x01\x43\xb8\x8e\xa0\xb8\x65\xdb\x95\xdb\xad\x33\xb7\x58\x2a\x8f\x7d\x6c\xa9\xc4\xc1\x65\xab\x7c\xf8\x6e\xf3\xd9\xc5\x77\x77\x07\x9f\xf0\xee\x2e\xdd\xc1\x22\x80\x36\x24\xbb\x36\xff\x1f\xde\xdc\x55\xef\xa1\x92\xf7\x61\xad\xaa\xd0\x14\xc9\x21\x78\x3c\x25\x25\x62\x1c\x95\x95\xc5\x45\x43\xdc\x50\x5d\x53\xd9\x77\x3f\x1e\x2c\x19\xca\x4a\x3c\xf0\x1e\xf7\x9b\x63\x14\x87\xec\xe1\xb0\x36\x7b\xb9\xd8\xa6\xde\x38\x4c\xf5\x84\x93\xdd\x39\xca\xe5\x21\xf7\x14\x82\x5c\x94\xc3\xa7\x08\xfc\x1f\x47\x4d\x89\x9e\x16\xfd\x5d\xc7\x75\x0d\xf2\xe7\xa9\xb6\xea\xfe\x1a\xf6\x3b\x9e\xa2\x23\xa9\x3f\xcc\xa7\x2b\xfc\xad\xad\xb9\xb1\x2c\xf2\xf9\x4b\x73\xcf\x1e\x79\x66\xc1\x15\xd7\xa2\xfb\xb5\x69\x98\x6b\x83\x41\x14\x79\xa7\x0b\x99\xf3\x17\x6c\xe9\x44\x6b\x60\x13\x28\x13\x6d\xeb\x85\x8f\xff\x47\xb7\x6b\x29\xee\x57\xe0\x1b\xf8\xcf\x00\xcd\x4b\x1f\x22\x1e\xaf\x59\xa7\x15\x0c\x74\xbf\xd1\xeb\xb4\x8d\xca\x75\xda\x97\xb3\x57\x50\x7a\x07\xf3\x60\x59\x84\x2d\x1d\x53\x47\x4f\x6d\x9e\xb6\x6a\x55\xc4\x5f\xde\xd7\x39\x99\xab\x18\x3d\x02\xaf\x8c\x7b\xd6\xad\x1b\x26\x5f\x1b\xaf\x34\xa4\xcc\x4e\x6a\xab\x03\x5c\xa7\xbe\xe1\x16\x14\x05\x42\x66\x25\xa2\x5e\xab\x35\xf2\xb4\x27\x1d\xc2\xf9\x9d\x9d\x75\x22\x8b\x16\xb9\x7a\xe3\x19\xad\x5f\xd1\xcb\x97\x5b\x2f\x68\xda\x5f\x09\x0d\x65\xef\x7a\xb2\xfb\x9f\x0a\x7f\xfd\x19\x70\xb5\x83\xf9\x32\xd7\x49\xa2\x18\xfc\x6f\xfc\x96\x7f\xdb\x53\x59\xf8\x6f\x3d\x95\x31\xfa\x94\x0f\x73\x95\xc2\x6a\x6a\x4f\xda\xc7\xd3\xeb\x55\xcc\x2e\x59\x70\xa1\x2a\xe5\x22\x9f\x8e\xfe\xf5\x5b\x3e\x1c\xc5\x03\x2b\xe5\x97\xe9\xfa\x6f\x90\x47\xe3\xe7\xba\x77\x32\xff\x2b\x03\x26\x44\xa3\x5d\x96\x75\xa1\xc8\x56\xa4\xc7\x41\x69\x07\x7e\x0e\x6a\x4e\x8f\xca\xcf\x57\xe2\x14\xd4\x7b\x14\xe4\xc3\xaf\x98\xcd\xae\x4c\xb2\x19\x35\x84\x98\x2d\xc5\x96\x3b\xd5\xa7\x53\xa1\x13\x85\x06\x3c\x2c\x49\x23\x6f\xac\x08\xf5\xad\x98\x20\x8f\x6c\x3d\xe9\xcf\x77\x49\xde\x11\x0d\x0a\x2e\xa6\xd5\x7c\xd5\xa0\x87\x48\xb0\xc5\x2d\xc4\x45\x7c\x5e\x8b\xdd\x6e\x6a\xcf\xd8\xad\x4a\x48\xa9\xc2\xec\xcd\x85\x6e\x96\x05\x41\xa3\x0a\xf3\x85\xe3\xc9\x1d\x3b\x6a\x4f\xbd\xf4\x92\xf3\xd6\x5e\x44\x43\x53\x4e\x3a\xfa\xcb\xbf\x9d\xf1\x8a\x71\xc1\x7b\x9f\x7f\xfa\x6e\x1a\x91\xf2\xfb\x5f\x7e\xf9\x51\xf1\xb1\x6a\x86\xbe\xa7\x91\xbf\xd8\x2b\xc8\x1f\x10\xb2\x69\xb9\x1b\x70\xf5\xb1\xcf\x91\x43\x32\xe2\xdf\x47\xf0\x92\x08\x46\x11\x1c\x41\x36\x50\x8c\xd2\x4a\x79\x15\x56\x28\x9f\x56\xca\x77\x3f\xf4\x9b\xe5\x17\xca\xcf\x70\x1c\x79\xca\xaa\x41\x21\x36\xd6\x7f\xb3\xbb\x7d\xdf\x33\x7f\x05\x11\xe6\x5b\x0b\x7b\xec\xea\x82\x3b\x4d\xc5\xd7\xe0\xfe\xdd\x88\x83\xf2\xaf\xd4\xff\x47\x31\x9a\x92\x6e\x5a\xff\x01\xa8\xaf\xd8\x69\x07\x4b\xc1\x12\xaf\x57\xd4\x13\x12\x76\x89\x62\x48\x63\x97\x90\xc9\xe4\xf5\xfa\xa1\x45\x6f\xd8\xcb\x79\x59\x8b\x88\x86\x79\xf6\xbf\x5c\x97\x8b\xd2\x9f\x8f\xd4\x7f\x62\x73\x2e\x37\xea\xb8\xf6\xdc\xc5\x27\xb4\xe7\xc2\x58\x9d\x08\x09\xfb\x85\x16\x7b\x05\x8d\x00\x67\xd3\x92\x86\xee\x45\xdd\x63\x51\x70\x2f\x07\xcd\xb9\xf7\x77\x3f\xf5\x80\xde\xd4\xb2\xbf\x7b\xe1\x5e\xb7\x5b\x10\x62\xb8\xaa\x2a\x8d\x1a\xd3\x74\x4e\xee\xc7\xdd\xf8\x28\x19\x43\xc7\x24\x19\x60\x2c\xf4\x5a\xd9\x0d\xd3\x35\x28\x91\xcf\x2d\x79\x3c\x37\x4b\xdc\x9d\x75\xaa\xec\xee\xee\xbe\x17\xfa\x3e\x2a\x0c\xb3\xc6\x51\x25\xb6\x28\xbd\xcb\x7f\x82\xde\xe7\x48\x95\x51\xc9\xe9\x6c\x89\x4a\x0e\x07\x7c\xd8\xed\xf0\x61\xb1\xc0\x87\xd9\x0c\x1f\x26\x13\x7c\xe8\xf5\x2d\x38\x44\x70\x18\x20\x7c\x48\x14\x5b\xc2\xf4\xdb\xfd\xdd\xef\x48\xce\x70\x98\xe7\x63\x08\xd1\x4a\x68\x9d\xd1\xd2\x42\xc5\x5b\x6c\x9b\x09\x80\x57\x29\xc0\xc3\x18\xd8\x3f\xa5\x7f\x6d\x39\xeb\xbf\x0a\x9b\x0b\xfa\x3f\x43\x1a\x12\x95\xdc\x6e\xe8\xc6\xe5\x6a\xe9\x05\x89\xcd\x96\x05\xc2\x68\x84\x0f\x83\xa1\x00\x1c\xc9\x6a\x6b\xa1\x30\x3d\x60\x16\x01\x9c\x77\x25\x5b\x38\x0c\xd3\x06\xe0\x58\xdd\x2d\x88\x0a\x67\x00\x4b\x6f\x50\xe0\x1f\x5d\x8b\xee\x87\x00\x59\xfe\x87\xc1\x53\x8d\xad\x2a\x3c\x4f\x02\x3c\x8b\xa5\x3a\x07\x85\xc2\x41\xa1\x70\x50\x28\x1c\x92\xd5\x0a\x1f\x00\x85\x83\x42\xe1\xa0\x50\x38\x18\x14\x16\x82\x45\x0a\xa2\x98\x83\xe2\x09\xc9\x2d\x8a\x3a\x1d\x9b\x14\x17\x40\x01\x20\xe6\x41\xe9\x0d\x0b\xc0\xb1\x46\x89\xfb\x6a\xad\x40\x75\x2a\x14\x1b\x00\x8a\x75\xd2\xa9\x21\x3a\x2b\x21\x3a\x2b\x21\x0a\x4f\x88\xc2\x13\xa2\xf0\x84\x68\x97\x21\x0a\x54\x88\xae\x54\x88\xae\x54\x68\x1d\x80\x17\x5a\x07\xe0\x85\x28\x78\x21\x0a\x1e\xe7\x23\x9c\x97\x4e\x86\x97\x16\xf3\xd2\x8b\x76\x5e\x50\x3f\xe8\x37\x26\x7a\x08\x64\x62\xd3\x93\xb6\xf5\x9e\xa0\xec\x1c\x3d\x03\xb4\xf2\x00\x9b\xa3\x21\x58\xc5\x58\xf9\x20\x40\xb7\x46\xaa\x29\xa1\x30\x95\x50\x98\x4a\x68\xeb\x25\x74\x7a\x4a\xe8\xf4\x94\xd0\xfe\x4b\xd8\xf4\x78\x08\xf6\x52\x58\xbd\xd4\x80\x0f\xd3\xe3\x65\x28\xae\x87\x69\x7a\x5b\x2a\xf5\x7a\xf5\xfa\x18\xd2\xd0\x41\x6a\x24\x87\xb3\x45\xb3\x0e\xe6\x4a\x23\x19\x45\x78\xd2\x1b\x5a\x34\x6c\xc2\x94\x29\x2b\x02\x8f\xc2\x35\x03\xe0\x32\xd3\x39\x23\xd3\x55\xa8\xe6\x00\x54\xe7\x48\x33\x92\xb4\xb9\x24\x9d\xb3\x24\x85\x2f\x49\xe1\x4b\xd2\x39\x4b\x52\x38\x92\x74\xce\x92\x14\xdc\x24\x9d\xb3\x24\x85\x39\x49\x61\x4e\x52\x98\x93\x0c\xe6\x6a\x82\xab\x24\xab\xb3\xa5\x4a\x02\x7c\xae\x42\x76\x3a\x5b\x76\x3a\x5b\x76\x36\x5b\xb6\x13\xce\xd5\x3b\xdd\xff\xe0\xae\x14\xbe\x07\xba\xb7\xe8\x7b\x64\xd3\x90\x41\x1f\x21\x64\x7f\x80\x70\x78\x7f\xf7\xbf\xf6\x96\xfa\x05\x33\x6c\xe8\x74\x3a\x5d\x44\x07\x34\x94\x0e\xc0\x7b\x59\xf7\xaf\x42\x90\xc6\x23\x40\x31\x46\x03\xe1\x93\xbf\x0b\x74\x5c\x91\xe6\x12\xb0\x10\xbd\x8e\xe8\xac\x36\x8d\x79\x76\x46\xaf\xd1\xf0\x9d\x19\x60\x2a\x16\x64\xe9\xcc\x20\x7b\x61\x44\xe9\xc2\x9b\x92\xd9\x84\x37\x8e\x28\xa1\xc9\x6e\x3c\xdc\xe1\xae\x31\xbb\x76\xf3\x2b\xec\xd3\x86\xcd\x79\xeb\xe0\xab\xad\x7e\xfe\xec\x40\xab\xbc\x08\x7b\x9c\x47\xaf\xf0\x2b\xfe\xdd\x25\xd0\xe7\xc7\x42\x0b\xd0\x5d\x1d\x6a\x93\x2a\x35\x1c\x4f\x40\xf4\xd0\x09\x1c\xd1\x1b\xe6\xea\xce\xd6\x71\xfd\x75\x23\x74\x93\x74\xa0\x52\x5b\x75\xa5\x00\x10\x4f\x78\xad\xc0\xd1\xdc\x0d\x7f\xf2\x87\x60\xb9\xec\x34\xd1\x56\x5d\x1d\x95\x4f\xa8\x95\xac\x67\xf6\x00\x1c\xc1\xb1\x08\xe6\x3f\x3e\x3a\x18\xbf\x84\xcb\xf0\xdb\x47\x9f\xe1\xbe\x93\xd7\x9d\xc2\x7f\x7e\xd4\xe7\xe6\x05\x98\x83\x28\xf4\xff\x35\x9b\x83\x4a\x36\x27\xa7\xc2\xfb\x3f\xd9\xfb\x50\xf6\x0e\x7f\xd7\x78\xd8\x3b\xcc\x77\xaf\x78\xc9\x1d\x52\x75\xd8\x0f\xe2\x98\x1a\x30\x39\x38\xb4\x0c\x93\x8a\x32\xec\x2a\xc3\x66\xf8\x9f\x2f\x2b\x73\x5a\x7e\x2b\x66\xf2\x4c\x1a\x35\x39\x2f\x7c\xb2\x23\xa0\x13\x45\x4d\x66\x19\xf2\x22\xda\xa8\x2d\xe5\x39\x71\xd4\x64\x32\xc6\x3f\x62\x84\x5f\x3e\x4c\x3f\xff\x97\xb8\xc9\x2f\xcd\x95\x27\xcc\x99\x83\xf7\xcc\x55\xf8\xe1\x48\x58\x8c\x77\xd8\x38\xab\x73\xe3\xee\xc3\xde\xfb\x31\xdc\x00\xf1\x4a\xd8\x23\xd0\x43\xac\xe1\x52\xc4\xc2\x6b\x04\xb3\x49\xab\x35\xf3\x44\xb4\x8a\x66\x6c\x17\xcc\x1a\x81\x37\x69\x79\x0b\x06\xfc\x30\xd0\x45\xc9\x47\x41\x4b\xb1\x6c\x8b\x85\xeb\x12\x63\x19\x0c\x22\x8a\x82\xaa\xc7\xf8\x76\x79\xfe\xa9\xf8\x03\x5c\x8e\x0f\xcf\xed\xda\x75\x83\xbc\x49\xde\xd0\xda\xda\x1a\xe0\x3f\x3d\x5a\x12\x68\x6d\xb5\xf1\xbe\xa3\xdf\xa1\x2c\x4c\xda\x0e\x06\x53\x2d\x7b\x8f\x03\x4c\xbb\xd9\x7b\x92\xad\xcd\x29\xd4\xe1\x1c\xf0\x57\x39\xfb\xc8\x48\xfd\x4b\xc3\xa2\xd5\xe9\x08\x94\x94\x38\x38\xbd\x35\xac\x29\x8f\x95\x84\xc3\x41\x8d\x68\xc4\x6b\x8d\x5b\x8c\xdd\x46\x32\xc8\x38\xda\xc8\x19\x8d\x36\x6f\xd0\xee\xb0\x5a\xeb\x4d\xd8\x64\xa3\x21\xaa\x66\xaa\x62\x75\x62\xe6\xcc\x15\xaa\x52\x50\x1c\x27\xa5\x60\x2d\x1c\x4a\xbe\x0f\x9a\xe0\x23\xea\x50\xa2\xe1\x12\xea\xf0\x46\xae\x60\x2b\xc1\xd6\x63\xf4\xfd\x4b\xca\x27\x3a\xf9\xb0\x73\x62\xf9\xf2\xdd\xe2\x57\x13\xcb\x27\x3a\x8e\x9e\xef\x80\x5f\x1f\x13\x77\x76\x15\x70\x7f\xcb\xed\x78\xa7\x3c\xfd\x76\xcb\xb1\xc7\xad\x0f\xcb\xb5\xf8\xb5\x87\xad\x74\x8c\x2a\xbe\xc1\x18\xeb\xd8\x3a\x00\x96\x6a\x6c\x30\x46\x07\x9a\x20\x25\x2c\x7a\x1b\xa7\xe7\x5c\xce\x52\x17\x46\x2e\xab\x6b\xb6\x6b\xb9\xeb\x29\x97\x60\x26\x3a\x22\x00\xd6\x09\xd6\xd9\x19\x81\xd8\x2c\x7a\x0e\x71\x9d\x19\x13\xdd\xb6\x75\xb9\xdc\xa5\xd9\x3c\x98\x2b\x6c\xb9\xb4\x32\xa9\x74\x41\xb2\x71\x35\x0a\x5d\xe5\xee\xdd\xc2\x17\xf7\xde\xdb\xb5\x68\x77\xd7\xe7\xbb\x47\xfb\xf9\xb3\x60\x45\x02\x47\x2f\xa3\x31\x5b\xf9\x45\x47\xb7\xf9\x47\xab\xeb\xc2\xdf\xcd\xd6\x21\xc5\x60\x3c\x09\xde\x0f\x03\x8c\x2e\xd4\x2e\x55\x71\x46\x17\xbd\x56\x6a\xb3\x6a\x75\x3a\xa3\x15\x99\x05\xb7\xc7\x6c\x71\x59\x5c\xb3\x33\x08\x9b\x00\x3a\x62\xd4\xc3\x18\x4e\xcd\xe8\xf4\x0a\xd6\xd0\xbd\xd1\x98\xf2\x34\x14\xe7\xbf\xc8\xdf\x8d\x76\xe1\x48\x5d\xb9\x12\x75\x98\x86\x36\x50\x12\x48\x12\xad\x3c\x0f\x07\x97\xe3\xa6\x38\x9d\xdb\x35\xf8\x23\xb9\x92\x1f\x3a\xbd\xef\x99\x6f\x7d\x43\x92\x73\xe4\x41\x7a\x2d\xcc\xe8\x5c\xce\xce\x4d\x5b\x24\xef\x7a\xd7\x42\x61\x2e\x05\x5c\xa9\x67\x30\xd7\x33\x5c\x02\x8a\x28\xdc\xc2\xde\x87\x30\x5c\x6a\x83\x79\x06\x5c\x63\x76\xe8\x14\x5e\x26\x7d\x27\x54\xd8\x92\xc9\x30\x72\x9a\x9c\xfe\x2a\x7f\x55\xff\xf4\x9a\x34\x1e\x91\xc6\x89\x34\x0e\xa4\xf1\xa1\xf4\x0f\x69\xee\x60\x1a\xdf\x9e\xc6\x57\xa4\xf1\x9c\xf4\xc6\x34\x37\x3d\x8d\xf9\x74\x79\x7a\x44\x9a\xcc\x3f\x9a\xc6\x9f\xa6\xf1\x65\xe9\x1b\xd2\xbb\xd2\x07\xd3\xfc\x24\x56\x65\x25\x14\xba\x3d\x7d\x20\xfd\x69\x5a\xa8\x4a\x8f\x49\x2f\x4a\x13\x67\x1a\x1b\xd3\xf8\x60\xfa\xab\x34\x07\xed\xac\x81\xe2\x9c\x94\xc6\xe5\xec\xdb\x81\xac\x07\x5a\x9d\x5b\x99\xbe\x3a\xcd\x2d\x4a\xe3\x4e\xda\xcc\x60\xa8\x4a\x94\xf6\x1f\x4d\xe3\x49\xe9\x39\xd0\x26\x19\x43\xbb\x76\xa6\xb9\xaf\xd2\x78\x2f\xed\x17\x4f\x52\x8a\x72\x62\x1a\xeb\xb8\x58\x69\x59\x69\x67\xc6\xa6\x73\xeb\x3a\x33\xb5\x6e\x2b\x17\x02\xdc\xa8\x08\xb9\x99\xb4\x10\xb2\x86\xae\x08\xdd\x12\xda\x13\x12\xbc\x24\x44\xcf\xad\xed\xf0\xad\x3b\xe4\x0e\xd9\xcb\x48\xd2\x69\x77\x76\x66\xec\x39\xda\xaf\x04\x14\x67\x79\x3d\x95\x40\x87\xb9\x70\xc6\xb8\x73\x56\x8f\x2b\xdc\xf9\x5b\xdc\xb9\x2f\x66\x15\x5c\xe8\x56\xb3\x5a\xa4\xf2\x41\x78\xb1\x4d\xb5\xa3\x44\xd4\xb8\xb3\x36\x4c\xc3\x0b\x97\xd1\x4b\x9b\x34\x0b\x5f\x5a\x0d\x4f\x54\x47\x23\x87\xd2\x7c\x8a\x2e\x8f\x8b\x7b\x6e\xf8\x39\x5b\xb6\x2c\xc3\x77\x2e\xdb\xb2\xe5\x9c\xe1\xf2\xf0\xdd\x4b\x6e\xfd\x62\xfd\xb9\xff\xd8\x35\x7f\x37\xb7\x68\xf7\xfc\x7b\xbe\x3e\xf7\x82\x2f\x6e\x59\xb2\x1b\x8f\xe0\x9e\xdd\x7f\xcb\x6d\x2f\xbd\x74\xdb\xad\x0f\x75\x0d\x92\x1f\x1b\xed\x3f\x77\xf9\xe1\xcb\x2f\x7e\x6e\xe9\x7c\x8a\xd9\xf3\x97\x3e\xbf\xe9\xf7\x87\x97\x9d\xab\xe0\x75\x05\xe0\xc4\xfd\x0c\x27\x06\x33\xbc\xd6\x02\x4e\x0c\x00\x9c\x88\xe2\x32\xe9\x75\xa3\xc6\x15\x89\x58\x38\x6f\x30\xc8\x69\x48\x79\x8c\x8f\xf5\x8f\x71\xbb\x62\x87\x63\xdc\x96\x18\x2e\x87\x97\x11\xb1\x39\xb1\x95\x31\xc1\x18\xc3\x8b\xbb\x63\x98\x7b\x35\x76\x24\xc6\x49\xb1\x2b\x62\x7b\x62\x44\x8c\x85\x63\x8d\x31\xf2\x4d\x0c\x2f\x8f\xad\x8b\xdd\x12\x7b\x2a\xc6\x8b\xb1\xb6\xd8\xb2\x18\x91\x62\xcb\x59\x91\xa7\x62\xaf\xc5\x34\x6a\xb1\x81\x50\x8e\x96\xa1\x0d\x2f\x8f\x61\x5a\x8e\xab\x8d\x61\xfa\x57\xee\x0a\x56\x92\x2c\x8b\xe1\x09\x31\xdc\x18\xc3\x47\x62\xdd\x31\xee\xa9\x18\xbe\x3f\x86\xaf\xe8\x51\x54\x47\x40\x81\x03\xea\x5c\x4a\x08\xd2\x97\x38\x45\xad\x5e\xdb\x99\xf1\xd9\xf4\x24\xc2\xc8\x43\x9e\xa9\xa7\xf2\x09\x5e\xd4\xe4\x57\xb9\x05\xcd\x2f\x1f\x5b\x40\xe5\xa5\x53\x59\xcb\x15\xb6\xe2\xb8\xa7\x94\x82\x94\x96\xab\xa9\x85\xdc\x1e\x95\xb2\x0c\xc3\x69\x1b\x0b\x33\xc7\x53\xea\x82\xbf\xd8\x2d\xff\x28\x7f\x78\x0a\xde\x74\xd9\x79\xab\x39\xed\xea\xf3\x2e\xc3\x9b\x4e\x91\x8f\xc8\x3f\x00\xa9\xc1\x97\x74\xfd\x13\x63\x10\x17\xb6\xec\x3a\xc8\x71\x17\xd2\xd5\xe9\x5a\xc3\x1d\xdc\x85\x57\xb4\x06\xe4\xee\xaf\x65\x79\x15\x2c\x12\x46\x33\x15\x99\x0c\xf5\x41\x67\x4a\x83\x4a\x23\x11\xaf\x37\x6e\xd0\xeb\xed\xa2\x45\xa3\x2d\x2f\x09\x44\xb5\x51\x12\x27\xf6\xb8\xbd\xaa\x6f\xd4\x1e\x10\xcb\x35\xa2\xa6\x33\x23\x8a\x5a\x97\x0b\x75\x66\x5c\x7c\xc4\x50\x62\x19\x05\x3c\x4b\x4b\x49\xcf\x4c\x5b\xea\x40\x5d\x63\x41\x1e\x42\xab\xf7\x40\x63\x96\x39\x2b\x21\xf3\x55\x0c\x2d\x0c\xe0\xc9\x2e\x62\x3b\x18\xcd\x1f\x8c\xe3\x15\x28\xdd\x1f\xb1\x3c\xb0\x48\xc4\x6a\x70\x74\x07\x75\xf7\x01\xb5\xf4\x89\x97\xaf\xd9\xec\xe9\xda\xe2\x99\x32\x74\xc2\x03\x4b\x84\x6f\xe5\x1f\xf0\x6a\x3c\x13\xcf\xc0\x6b\xe4\x1f\xbe\x15\x96\x3c\x30\x61\xe8\x14\xfa\xd7\x2d\xdb\x5e\xe2\x3f\x7f\xe7\xc5\x3f\xbe\xe2\x96\x27\xe0\x75\xeb\xac\x0b\xca\x30\x7a\xf1\xdf\x58\x94\xbf\xff\xe5\x45\x90\xd8\x16\x58\xd7\xc9\xeb\xf0\x1e\xf7\xab\x7b\x5e\x78\x37\xcf\xb7\x35\x77\x81\x6e\x57\x4d\x65\x52\xb4\x10\xd5\xe3\xf1\xc8\xb7\x8f\xc3\x26\xa1\x82\x4a\x81\xf2\xde\x80\x8b\x60\x26\x05\x22\xfa\x93\xa5\x75\xac\xce\x10\xa5\x0e\x7e\x03\xea\x78\x24\x33\x87\x5d\xb4\xd2\xc8\xf2\x90\xde\x9e\xaf\xc1\xfa\x19\xd3\xfd\x0f\xfe\x54\x26\x67\x9e\xa6\xc8\xbe\xe8\x7d\xf8\x03\x68\x26\x5c\x85\xad\x82\xab\xaa\xe8\x43\x8c\xb4\x06\x54\x50\xca\x0f\x04\x7d\x7c\x38\x2b\x3f\x4f\x2d\x7f\x81\x52\x1e\x27\x6c\x15\x78\x51\xa2\x4e\x40\x45\xe5\xc3\xf2\x58\x3e\xc5\xca\x2f\x50\xcb\xff\xaa\x96\x0f\x42\xf9\x55\xc1\x52\x07\x29\x2e\x0f\x72\xef\xdc\x02\xb9\xb7\xe1\x51\xa5\xb4\x0d\x4a\x87\x6c\x4e\x45\xee\xa5\xa5\xa1\x6c\x08\x60\x39\xc2\xca\xae\x62\x6d\x0f\x42\x8f\x40\x23\x1e\xc9\x04\x62\x32\xfc\x6f\xad\x28\xe5\x9d\xaa\x98\xcc\x44\x65\x2a\x97\xb2\xf1\x92\xbf\x20\x1f\x48\xc5\x13\xa5\x9a\x20\x71\xeb\xa2\x51\x8b\xc1\x68\x74\xda\xed\x16\x42\x2a\xe2\xee\xa8\x45\xc7\x1b\x9c\x4e\xdb\xf8\x8c\xd3\x65\x10\x35\xfe\x09\x19\x8d\x15\x95\x76\x14\xa5\xda\x52\x23\x8e\x17\x47\x7e\xcd\x5a\x48\x94\xdc\x0a\xa9\xfa\x88\x4b\x43\x42\x38\x8c\x5d\x11\x96\x4b\xd8\x91\x3b\xa0\xeb\x87\xf1\xee\x9d\x8f\x7d\xfa\xe4\x2b\x53\x35\xfd\x70\xa0\x65\x4a\x20\x11\xa9\x95\x9f\x0e\x7b\x34\xa3\xae\xe2\xdb\xc7\x0d\x1f\x3a\xe2\xdc\x1a\xfb\x3c\xe7\xd1\x0f\xbf\xc7\x96\xf7\x9f\xa9\x5c\x29\xbf\x79\xdd\x9d\xa3\xc5\x31\x1d\x97\xac\x5f\x4a\x4e\x7f\xfc\xf9\x9b\x1e\xdc\x73\xdf\x43\x4f\xd1\xb1\xac\x94\xc7\x92\x6f\x85\xdb\x60\x8b\x57\xa0\x19\x52\x5d\x00\x68\x99\x31\xea\xd0\x95\x5a\x2c\xba\x28\xe6\xe3\x95\xa5\x95\x58\xac\xc4\x76\x62\x2c\x8f\x96\x47\xdb\x32\xe5\xe5\x82\xd5\x1a\x6c\xcb\x58\xdd\x82\xbb\x2d\x23\x60\xea\x8b\x5f\x28\xb8\xb2\x5f\x8c\x26\x64\xb7\xbc\x3d\x17\xb0\x2b\xe7\x7d\xa1\x75\xf1\x36\x6b\xa4\x2c\xce\x42\x4d\xd2\x2c\x25\xd9\x44\x19\xe9\x61\x18\x6f\x93\x8f\xbc\xf1\xe9\xc3\x87\x2f\x5f\x86\x6b\xe4\xbe\x93\x92\x98\x1b\x32\xac\x7e\x40\x20\x31\x7c\xc1\x8c\xf3\xce\x9a\x7b\xb2\x3c\x56\xb8\xe8\xeb\x4f\x1e\xb9\x65\xc3\x5e\xaf\xa1\x51\x7e\x45\x5e\x6e\xe3\x87\x9c\x7b\xc9\x90\xf5\xab\x8e\x4d\xb3\x5f\x71\xd3\xf6\x3f\x08\xb3\xb9\x35\xcc\xd6\xf7\x23\x8c\xeb\x36\x96\xc7\x2e\x2d\xf9\xb9\x00\xef\x74\xba\x75\x16\x8b\x3b\x40\x82\x3e\x1b\x5f\xe2\x0a\xe0\xc0\xf8\x8c\x11\x8b\x6a\x64\x4c\xba\x77\xb3\xe2\x84\x62\x69\x21\xe9\x88\xdd\x91\x72\x00\x58\xf1\x74\x0a\x80\xd6\x12\xb7\xdd\xa5\x8d\xf7\x1f\x50\xcf\xc5\x8d\x78\xcc\xe5\x19\xed\xc5\x83\xc7\xff\xd3\x31\xa5\xdb\xe4\xfa\xb1\x9f\xc3\xf1\xc6\x7c\xb2\xb0\x49\xbe\x54\xbe\x17\x9f\xb4\xf9\xe4\xf1\xb6\xe1\xb6\x61\x73\xf6\x76\x7d\x25\xc9\xcf\x77\x9a\x83\x93\x7f\x3a\x99\x3b\xfb\x35\x86\x37\x7f\x23\xef\x0b\xd7\xb2\x1c\x07\x92\x14\x29\x75\x6a\xfb\x78\x2a\xfc\x15\x16\x0b\xf2\x3b\xf9\xea\x9a\x3e\x5a\x5b\x30\xc8\x8f\xcf\xa0\x20\xb2\x45\xc7\x67\x6c\x6e\x74\xbc\x40\xb9\xd4\x23\x2c\x9f\x03\x56\xc3\x62\x13\x64\x33\xd0\x50\x57\xf9\x6c\x30\x08\x9c\x4b\x3f\x62\xc1\x64\x79\x53\xb4\x61\x42\xe3\x88\x91\x6d\x33\x2f\x9c\xf7\xcb\x5b\xaf\x7f\x7f\xfb\x2d\xa3\x26\x3d\x73\xf7\x92\x3f\x74\xfd\x38\x73\x5c\xdb\xf4\xd9\x2b\x1b\x46\xf1\x5b\xd7\x54\xb7\x0c\x6c\x58\x36\xa2\x63\xe5\x5b\x97\xbc\xf1\xc3\xe7\x2f\x5c\xf1\xe1\xa8\xa6\x3b\xc7\x5f\x70\x6d\xf8\x98\x75\xd7\x6d\x3b\x37\xaf\x7c\x76\x72\x1d\xcd\x29\xc7\xf6\x2e\xe0\x7e\x3f\xb4\x48\x6a\xf4\x1a\x2b\x05\xc1\xa8\x2b\xb5\x21\x4d\x6d\x42\x17\x88\x05\x62\x6d\x99\xc3\x01\x2c\x06\xc2\x01\xce\x44\x02\x01\xce\x62\x71\xb5\x65\x3e\xb0\x61\xbf\xed\x1e\x1b\x47\x44\x1b\x10\x1e\x9b\xc5\xda\xaf\x8a\xab\x6a\xcf\x70\xee\x1c\x57\x61\x29\x62\x66\x16\xe8\x3e\x3d\x13\x9c\xc5\x72\xe9\x53\x7a\x1d\xa7\x78\xea\x99\x55\xbb\x2c\x4e\x07\xaa\xde\x05\x21\xc3\x37\xbf\xf6\xca\x07\x73\x4e\xde\xf6\xf7\x03\xdb\x2f\x1e\xde\xff\xa4\x69\x63\xa6\xf6\x8d\x2e\x6a\x35\xa5\x52\x96\xd1\x53\xcb\x92\x75\x2b\x66\x5f\x78\xda\xa0\xe6\x69\xd7\x5c\xda\xbe\xd6\xaf\x95\x36\x9f\xb9\xa9\xfc\x9d\x33\xcb\x3b\x4e\x1a\x34\xd5\x61\x33\xef\xb0\x58\x39\xd7\xd4\xc1\x13\xe6\x46\x58\x6e\xf6\xf1\xf2\x6a\x72\x9a\xb0\x03\x45\x68\xee\xcf\x12\xb3\xdd\xeb\x25\x4e\x50\xde\xa2\xc0\xef\xa3\x0e\xaf\xc7\x29\xb9\xb4\xc8\x5c\xc2\x13\x0f\x26\x7c\x5b\x86\xb0\x88\x3d\x8d\x80\xfa\x7f\xf5\xbf\x6c\x53\x43\x95\x64\x77\x02\x3b\x7a\x57\x3c\x3c\x95\x98\x1d\xc3\xb0\xbd\x3e\x2d\xa4\xcb\xeb\x5d\x06\xac\x06\xed\x20\xa7\xed\x7a\xfc\xa4\xf6\x59\xa7\xfc\x75\x77\xd3\xb9\x6f\x3d\xdf\xf5\x33\xfe\xe2\xa1\x0f\x6f\x99\x32\x7f\xf5\xb6\x0d\x95\xe7\xdd\x35\x68\x81\xaf\x69\x40\x2a\x6d\xef\x73\xdf\x9e\xcc\xd3\x07\x31\x79\x81\xef\xbc\xd9\xef\x3b\x59\xfe\x44\xfe\xf9\xa7\xd5\xd3\x4e\x2b\x29\x3f\x57\xb1\xcd\x32\x7a\x09\x6b\x54\x82\xea\xa5\x12\xb7\xd5\x6a\xa3\x82\x6a\x30\xe4\xf6\xf9\x4c\x1d\x19\x9f\xd5\x69\x07\xb2\x24\xda\x5c\x02\xdd\xbb\x8d\xbd\x2c\xb4\x6c\xbe\x9d\x76\x90\xf3\x01\x46\x9b\xe2\x89\xac\xa4\x65\x54\xfc\x04\x5c\xbc\xe8\x12\xe5\x37\x4c\xc6\x96\xe6\xf2\x39\x95\xf2\x91\xe5\xf8\x77\x96\x95\x3b\x46\xad\xbf\xb4\xf9\x52\xf9\xab\x7e\x35\x27\xbd\xf9\x0e\xd7\x36\x65\x46\xc8\x7b\xec\x28\xe9\xf0\x36\x75\x0c\xab\xb9\xec\x52\x90\x99\x27\x03\xde\xbc\x2d\x5c\x07\x32\xb3\x08\x44\x70\xa2\xd4\xcf\x61\x36\xf3\x4e\x93\x09\xf1\xc8\xe3\x15\xbd\x40\x61\x1c\xe6\x09\x19\xb3\x63\xa8\x63\x1c\x4d\xbc\xe9\x70\x70\x1a\x8d\xb5\x2d\xa3\xc1\x9c\xbe\x4d\x41\x95\x22\xed\xb8\xaa\x38\x4f\x3f\xdb\x10\xa0\x10\x03\x59\xa9\xb3\xe3\x3a\xbb\x23\xe2\x07\x5a\xc9\x91\x88\x01\x93\xb7\xe5\x06\x79\x24\x7e\xe6\xc8\x47\xf2\xe0\xf1\xed\x82\xfc\x24\x37\xb6\x6d\xfc\x38\x0e\x0f\xe7\xdb\xb9\x03\x5d\x95\xdc\x3b\xdc\x21\xf9\xca\x63\x15\x58\x87\xeb\x60\x22\x3f\xe1\x3f\x91\xbf\x93\xdf\xc5\x35\x58\xaf\xcc\x65\x0d\xf0\x92\x95\x40\x47\xac\xf4\xe6\xbc\x8e\x85\x66\x62\x89\x13\xcd\x46\x64\x54\x53\x27\xe6\x73\x55\x17\xe7\x4c\xcc\x9e\x7d\xdc\x74\xfe\xda\x95\x78\x5b\xa2\x6f\x9f\xda\xd2\x8d\xce\xb3\xd7\x73\xcb\xbc\x4d\x5d\x03\x46\x0c\x30\x77\x78\x4a\x51\xce\xb6\x72\x1a\xf4\x61\x43\xb3\xa5\xfe\x44\xc7\xe9\xf5\x06\xad\x60\xe3\x38\x2c\x10\x87\xd5\x00\x7c\xc5\xee\xe0\x4c\xa2\x69\x7c\x86\xb3\xda\xad\x9c\x95\xd7\xeb\xac\x84\xd7\xda\x44\xd1\xa8\xd5\x02\x30\xda\x7c\xfa\x3d\xc0\x34\x26\x75\x23\xf5\xa4\xb7\x20\xd6\x8a\x6a\x41\x70\x89\x98\xea\xd6\x44\x5d\x52\x1b\xe6\xcb\x97\x7c\x8e\x4b\xcf\x94\xaf\x7c\x67\x89\x7c\x64\x21\xbe\x0c\xdf\x47\x76\x37\x59\xbf\xeb\xfa\xc1\x37\x02\xdf\x3b\x43\xbe\x9f\x2e\xa2\xec\xc6\x5f\xd2\x04\x48\xa0\xfc\xfc\x00\xbc\xa2\x04\x68\x6a\xc0\xe7\xe5\xbc\x9c\x1e\x93\x20\xf5\x2c\xf3\x61\x22\x7a\x3d\x25\x2e\x51\xa0\x19\x52\xb3\x89\x31\x69\xdf\x98\xa1\xbf\x12\x88\x28\x95\x66\x01\xef\x59\xb8\x46\x42\xe5\x73\x0f\xa6\x21\x56\x08\x10\x28\x2f\x7e\x39\xd0\xb1\x22\x1a\xac\x1a\xe2\x8e\xc5\xfa\x94\x4c\x5a\x3a\x65\x10\x1e\xe0\x99\xf0\xc2\x7b\x36\xe9\x99\x3a\x72\xe7\xa4\x9f\x3c\xb3\xdf\x17\xf4\x3a\x7e\xf8\x55\xbb\x8e\x9d\xdb\xec\x1a\xce\x5d\xd9\x6f\xa7\x3c\x1c\x60\xf2\x03\xae\x2f\x63\x39\xe8\xda\xa5\xbe\xc0\x9b\x8c\x54\x95\x44\x2e\x97\xdf\xe8\x0f\x85\x83\xfe\xf1\x99\xa0\xcb\xcd\xf2\xd6\x78\x2d\xa2\x36\x40\x1c\x1d\x19\xa3\x80\x68\x2c\x72\xa0\xf8\x8c\x0b\xa7\x7a\xe6\x1a\xcf\x63\x54\x8c\x1e\x99\xc6\x9d\xa0\x4d\xda\x0b\x96\x54\x89\x4d\xee\x8a\x70\x3f\x37\x2e\x18\x38\x6d\x80\x59\xfe\xcc\x3b\x0b\xaf\x1d\xdb\xd6\xd9\x49\x33\x93\xca\x37\xcc\x68\x4c\xf6\x5f\x2a\x5f\x5f\x83\xf9\x2f\xb9\x2f\x7d\x4d\x5d\x2b\xa7\x4f\x6c\xe3\xae\xf0\x35\x1d\xbb\xcf\xa7\xc4\x1d\xed\xee\x82\xbd\x70\x0e\x5b\xef\x41\x52\x89\x0d\x09\x3c\xc6\x1c\x30\x27\x41\x70\x70\x76\x23\x4f\x08\x1e\x9f\x01\x5a\x29\xb0\x03\x94\x3a\x35\x99\x34\xcd\x6a\x63\x6b\xc8\xb2\x53\x8a\x67\x34\x39\x44\x00\xe7\x19\x14\xc6\xeb\xe4\x3f\x0d\xc4\xc3\x3f\x9f\x33\xb4\xed\x9f\x8e\x94\xfc\xb6\x93\xcc\x05\x4c\x3b\x0d\x1b\x6e\x9d\x35\xce\x5f\x13\x19\x90\x39\xab\xeb\x74\x86\x6f\x63\x80\xa6\x6d\x01\x9a\x36\x00\x9d\x2a\x0d\xf4\x55\x1b\x52\x48\x53\x11\x0e\x6b\x6c\x65\x89\x14\xae\xd6\xd5\x0f\xac\x35\xbb\xcd\xc0\xdd\xcd\xe6\x32\xae\x0c\x78\xfe\x48\x1f\x4e\x19\x7c\xd5\xe1\x0a\x8d\xa6\x8c\x5e\xa5\xc4\x00\xae\x06\x16\xf9\xaf\x2f\xcf\x04\x12\x97\x80\xe5\x9d\x59\xc8\xfd\x7b\x1a\x44\x84\x34\x75\xa6\x61\x77\x06\x72\xc4\x5a\xa5\xd5\x4a\x72\x87\x42\x92\x98\x4d\x90\x55\xcf\xb5\xcb\x55\xb3\xb6\xe3\x75\xed\xb7\x3d\x33\x22\x51\xbb\xc4\x5d\xd9\x27\xb4\xbe\xff\xb2\xb9\xe7\x6c\xbe\x79\xf3\x73\x3b\x27\x8d\xe8\xdc\xf4\xe6\x43\x0f\xed\x59\xb6\xfc\xe9\xc7\x84\xba\x41\xdb\x0c\xda\x25\xd1\xbb\x57\x8c\x3c\xcb\xa6\x77\xed\x70\xe8\x93\x5b\x4e\x99\x91\x09\x84\x57\x2f\x5e\xb3\xaf\x7c\x7e\x68\x58\xb2\x6e\x80\x37\xf6\xf0\xad\x1b\x9e\x1d\xac\x8d\xad\x9f\xb2\xe4\xe6\xbe\x4c\x46\x1c\x0f\x6b\xf0\x00\xf9\x0b\xe8\x6f\x1d\x6c\x4e\xfc\x20\xd3\x8d\x63\x79\x1a\x9b\xa5\x98\xc3\x6c\x10\x75\x81\x80\xe8\x26\xc1\x90\xe8\xc2\x46\xde\xe5\xd0\xfb\xbd\xfe\xb6\x8c\x57\x34\xbb\x88\x46\x83\xda\x33\x9a\xdc\xce\x57\x16\xa8\xd8\x92\x45\x91\x47\x71\xf1\x28\x4d\xdb\xa2\x44\xa3\xa5\x17\xd8\xeb\x1d\xa0\x72\xd0\x58\x11\x36\x27\xf9\x47\xd5\x80\xd2\x33\x06\xcb\xff\x7a\x27\x64\x0a\x7f\x78\x52\xad\x21\x32\xe7\xa4\x76\x17\x1f\x7a\x78\x81\xb9\xd3\xee\xfb\x9a\x5b\x24\x0f\x7e\x6e\x7f\xcd\xc8\x4d\x97\xe3\x27\xef\xc2\xd6\xf9\x5d\x77\x5e\x40\x65\xb5\xd5\x20\xd3\xfc\x40\xfe\x0c\x14\x94\x9e\xb6\x87\xfd\x16\x8b\xe8\xd0\x8a\xda\x92\x20\x0a\x4a\x41\xce\x4a\x2c\x01\xa3\xb5\x3d\x63\x74\x13\x77\x7b\x86\xe6\xd2\xcf\x4a\x9a\xc5\xb4\x52\x8d\x8f\xa7\x68\xc7\x80\xdf\xb6\x08\xce\xba\x7a\x81\x24\xb6\xfa\xfd\x83\x17\xff\xf5\xac\xce\x5d\x8b\x57\x2e\x93\x8f\xe0\xbb\x4e\x9e\x92\x99\x28\xb5\x0e\xe2\xfa\x1e\x78\x73\xfd\x37\xb7\x5e\x76\x70\x69\x5f\x79\x00\xe7\xbb\xf5\xce\xc7\xdf\x5c\xbb\x5a\xae\x77\x2b\xf4\x6b\x2c\xe0\xd3\x59\xc0\x6f\xa2\x20\xd5\x94\x1a\x63\xb0\xfb\xca\x63\xa1\x60\x90\x1d\x3a\xe8\x44\x62\xf4\xf9\x22\x6d\x99\xa0\xcf\x6a\x34\xb5\x65\x8c\x28\x91\x13\x6a\x3c\xf9\x50\x5e\xca\x11\x17\x75\x14\x01\xaa\xc0\xae\x96\x14\x62\x85\xbd\x20\x69\x90\x06\xcf\xad\x68\xcb\x5c\xb6\x66\xf0\xdd\x4f\x4d\x6a\x9a\xb9\xea\x85\x87\x2f\xfc\xf2\xa2\x86\xd9\x8b\x5b\xfa\x0e\xea\x98\xbf\x1a\x7f\x30\x66\xf6\x60\x6f\xf9\x49\xb3\x5b\xcf\xb8\x6b\xf0\x82\x70\x53\x55\xb2\xc1\xd7\xe7\xc9\xfb\x77\x60\xed\xb5\x46\xaf\x2c\x6f\xad\x79\x95\xce\x23\xac\x3d\x3f\x9e\xef\x8b\x0c\x40\x35\xfa\x4b\x01\xc1\x8d\x80\x94\xfa\xdc\x7c\x28\xcc\x19\x7d\xc6\x09\x99\x40\xc0\x27\x3a\x74\x6d\x19\x47\x56\x02\x4b\xf4\x4c\xfa\xd7\x3f\x2b\x6b\x0c\x70\xb8\xb2\x13\xc9\xa5\xfb\x97\xa7\x22\xf5\x29\x2d\xf7\xc2\xa9\x67\xae\x3f\xb9\x6d\xf2\xb4\xd9\xd3\x67\xaf\x7a\xe7\xd2\x17\xff\x85\x03\xbf\xe2\x69\x52\xbb\x15\x3f\xf2\xe1\x75\x8e\x57\xee\xba\xe9\x91\x27\xb8\xa4\x66\xfc\xc1\x85\x17\xbf\x76\x06\xd6\x7c\x70\x44\xfe\xdd\x57\xca\x3c\x56\x02\x4e\x5e\xc7\x72\xad\xd6\x49\x7e\xad\x43\x30\x3b\x38\x1e\xa8\x97\xc1\x6a\x68\x07\x81\x5b\x43\x2d\x4f\x19\x90\xa2\x50\x9e\x66\xe5\xa0\xa2\x2e\x14\x14\xb7\xf2\x6c\x87\xa5\xd5\x78\x0c\xb0\x8a\x4c\x97\x5f\x6f\xa8\x66\xf8\xb6\xe9\x2a\x32\x42\xc1\xa7\xe1\xc3\x29\xa2\xd1\x74\x18\xd0\x2f\xd3\x81\xc8\x01\xa0\x37\xfd\xa5\x12\xb3\x53\xcb\x71\x56\x27\xf1\x7a\x6c\x56\x10\x42\xad\x1a\xc2\xf2\x04\xeb\xdb\x7a\xe5\x09\xce\x49\x35\xa5\x3e\x9c\x4d\x12\xcc\x96\x2c\x4d\xa7\x04\xd8\x97\x7c\x5e\x27\x5e\xb7\x61\xd0\x49\xc1\x9a\xe1\x07\x5e\x39\xe6\xc4\xb3\x38\x1d\x10\xa4\x39\x4f\x35\x6f\xb9\xf3\xfd\xeb\x2a\x67\x78\x7f\x79\xfb\x0b\xf9\x17\x58\x8f\x56\xa0\xe1\xfb\xc8\xb3\xd4\x17\x0c\x4f\x91\x7e\x31\x09\x11\x04\x2a\xb2\xdf\x8d\x75\x6e\x81\x2f\x8f\x2d\x88\xe1\x29\x31\xdc\x10\xc3\x65\x31\xcc\xc7\x9c\x31\xee\xa7\x18\x3e\x14\xfb\x34\xc6\xdd\x11\xdb\x17\x7b\x36\x46\x36\xc6\xf0\xd9\x31\x3c\x29\x86\x9b\xa9\x75\x05\x6b\x62\xee\x18\xb7\x60\x7b\xec\x85\xd8\x2f\x31\x72\x41\x0c\xaf\x8c\xe1\xb9\x31\xdc\x11\xc3\xb8\x34\x26\xc5\x38\xd6\xc2\xed\xb1\xbd\x31\xda\x04\xbf\x8e\xfd\x7d\x11\xab\x3e\x98\x55\x3f\x1a\xc3\xca\xdf\xc8\x0d\x31\xbc\x91\x19\x4f\x46\xc4\xa0\xaa\xd2\x75\x03\x33\xe3\x5c\x1d\xc3\x6b\x62\x78\x4e\x0c\x07\x62\x55\xb1\x31\xd4\x68\x83\xb9\x6f\xa8\x79\x65\x76\x6c\x1d\xb3\xd0\xf0\x6d\x31\x6c\x8d\xd5\xc6\x38\xf8\xcb\x47\x31\xbc\x85\x1a\x78\x66\x53\x63\x4b\x1b\x35\xb6\x88\x11\xba\x21\x38\x9f\x5b\xa7\x1f\x9f\xd1\xe9\x1c\x0e\x50\xa8\x1c\x56\x45\x95\x62\x27\xbf\xb9\x54\x21\xaa\x75\x85\xd9\xca\x3a\x8b\x8c\x65\xf9\x70\x87\x6a\xbc\xc3\x59\xc5\x71\x10\x7b\x58\x5c\x70\xd4\x56\x41\x93\x50\x67\xe9\x70\x56\x17\x43\x5a\x87\xba\xf3\x87\x61\xee\xb1\xf3\x7e\x92\xbb\x0f\xff\xbd\xa3\xf5\xf4\x25\x9b\xd6\xdd\xf5\x9c\x7c\xec\xa7\xb7\x52\xc3\x06\xf4\x5b\xb4\x50\x1e\x8b\x6f\xb7\xfd\xf0\xd9\x07\xdf\x04\x67\x94\xee\x7b\xe8\x91\xa7\x2d\xdc\xc8\x2b\x77\x1c\x7b\xf3\x33\xf9\x7b\x27\xfe\xe9\xc0\xc3\x0b\xe7\x74\x3d\x65\x7a\x46\xe1\x6d\xbf\x00\x8d\x3a\x00\x38\x1c\x46\x19\xa9\x5f\xc0\xe9\xf4\x38\x4a\xac\x21\x13\x3d\x1c\xb2\x5a\x3d\x9e\x48\x08\x19\x79\x16\xfd\xa5\x34\xe0\x2c\x71\x10\x13\x6f\xd4\xe9\x42\xc8\x1b\xb0\x5a\x74\x62\x36\xdc\x9d\x4a\x16\x8a\xfe\x53\x73\xdb\x2a\x83\x21\x03\xec\xf5\xa4\x22\x81\x81\xef\x79\x1c\x76\xaa\x23\x83\x50\x03\x74\xc3\x15\xad\x88\x13\x0d\x89\x68\xa7\xec\x9f\xff\x4e\x50\x8a\xbe\x18\xac\xfa\xfd\xa5\x43\x70\xd5\x85\xab\xc6\xa3\x6e\x7b\x45\xed\xbd\xe5\x15\x8f\x4c\xda\x26\xbf\x2a\xaf\xbf\x1d\x2f\x79\x0d\x3f\x3a\xd8\xac\x19\xee\x9b\x2d\x3f\x8a\xe3\xd7\x0e\x3e\xfa\xfd\x8e\xae\x1f\x63\xa5\xfa\xe1\xc1\x0c\xbe\x69\x97\xcc\xe2\xa6\x86\x40\xdb\x5c\xcc\xbf\x86\x02\x38\x2c\xbd\xae\x23\x16\xbf\xdf\x18\xb0\xb9\x41\x87\x24\x25\xc1\x31\x41\xdc\x3f\x88\x03\x41\xcc\x07\xf1\x57\x41\x7c\x28\x88\x1f\x0d\xe2\xdb\xe9\x37\x83\xe1\x6f\x8b\x82\x6b\x82\x37\x04\x35\xf0\xb7\x45\x87\x83\x47\x83\xdc\xab\x41\xbc\x2b\xf8\x68\x90\xbb\x39\x88\xab\xe0\xcf\xd3\xe1\xcf\x97\x05\x85\x70\x10\x1b\x83\xf8\xa3\x20\x5e\x19\xdc\x18\xbc\x3d\xb8\x37\x78\x28\x28\xcc\xa6\x2d\xf6\x0f\x72\xf4\x95\x5b\x04\x8d\x70\xec\x75\x10\xf4\x71\x24\x88\x0f\xd0\x1a\x01\xa8\x7f\x19\xb4\x26\x28\xdf\x41\xbf\xf7\x07\x31\xb7\x25\x88\x51\xb0\x16\x18\x01\x81\xb7\x2b\x82\x38\x1c\x6c\x0b\xae\x0d\x12\x14\xc4\x3a\xe2\x0f\xb8\x78\x2a\xb6\xda\x4d\x1a\xd1\x02\x82\x6b\x5b\xc6\xa7\x78\x67\x30\x32\xf2\xac\x4a\x4e\x72\xc8\xd6\x99\x35\xe5\xcd\xea\x65\xd6\xcb\x9b\x65\x8b\xd0\x4b\xa8\xc6\x79\x6b\x5e\xaa\xc0\x92\xa7\xb5\x45\xb9\x8b\xe4\x5f\xe4\x2e\x10\x91\xce\x3e\xf3\xbc\x55\x8b\xf1\xa6\x79\xf2\x2f\xc7\xce\x73\x18\x9e\x39\x88\x5f\x06\x6a\x70\xf3\xb2\xb5\x7a\xfe\xbc\xa3\x17\x9a\x36\xce\xe5\x4e\x69\xf2\xca\xa9\x87\x5f\xb3\xc8\xb3\x14\x7a\x38\xb1\xfb\x1f\xc2\x26\xa0\x4b\x09\x7c\xba\xd4\x1d\xf6\x59\x6b\x0c\xda\x9a\x32\x52\x01\xff\x25\x6b\x2b\x92\xcd\x49\x8e\x4b\xe2\x1f\x92\xf8\xb3\x24\x7e\x23\x89\x0f\x24\xf1\x6d\xc9\x07\x92\xdc\x35\x49\xbc\x31\x89\xe7\x26\xcf\x4e\x72\x93\x92\xb8\x39\x89\xcb\x93\xfd\x93\x9c\x26\x89\x17\x29\x45\xa1\xdc\xbe\x24\xbe\x3b\x89\xcf\x48\xe2\x39\x49\x3c\x25\x89\x9b\x92\x18\x5b\x93\xa5\xc9\xda\x24\xe1\x93\xf8\xdb\x24\x3e\x94\xfc\x34\xc9\x3d\x95\xc4\x2b\x93\x57\x27\x6f\x4f\xee\x4d\xf2\x13\x68\x2b\x23\x92\x9c\x31\x89\x5f\xa3\x5f\x6f\x84\xaf\x0f\xb0\xaf\xf9\x24\x6d\x7e\x44\x92\x1f\x74\x28\xf9\x43\x92\xdb\x93\xc4\x37\xb0\xfe\x17\x25\x71\xff\x24\xae\x4a\x62\xc4\x40\x7c\x8d\xf5\x7b\x45\x12\x73\xb5\xc9\x09\xc9\xd9\xc9\x75\x49\x3e\x91\x84\x4e\xf1\x2d\xc9\x8f\x92\x5c\x67\x72\x4b\x92\xa3\xfd\x4b\x49\x22\x26\xb1\x81\x38\x9d\x1a\x54\xa6\xd5\x68\xc7\x67\xa2\x1a\x6b\x89\x19\x99\xdb\x33\x0f\xf4\x29\x58\xb1\x5c\xf6\xa0\x44\x9e\x40\x74\x16\x2c\xd4\x19\xb3\x8e\x43\x20\xce\xe8\x1d\x2f\x55\xd9\x56\xcc\xcb\x89\x5a\xd6\x99\xdd\x09\xa9\x24\x82\x1a\x99\xe2\x8a\x2b\x90\x88\x73\xa1\x26\xd3\x6e\xa4\x5e\x87\x89\x82\x66\xf3\x3f\xcf\xbc\x81\x35\x5f\x9e\x3e\xb7\x7d\xdc\xc0\xc9\x16\x63\xf4\x50\x99\xc9\x32\x79\xe0\xb8\xf6\xb9\xa7\x7f\x81\xb5\x87\xfe\x3c\xed\xc2\x88\xa1\xf4\x42\xe7\xb7\x6f\xbf\x8b\xdd\x65\x33\x12\x47\xee\xfc\xc3\x3d\xf3\xa6\x0f\xbc\x35\x25\x49\xa9\x5b\x07\x4e\x9f\xb7\xeb\xb6\x3b\x8e\xd4\xce\x28\x93\xbf\x7c\xf7\x9d\x6f\xa6\x4d\x99\x3c\x9d\xd9\xee\xba\x8f\x31\xdb\xdd\xb4\xac\xed\x0e\x2d\x7c\x0e\x31\x8b\xa5\xcd\xc6\x2c\x96\xef\xe5\xcf\xad\xf3\xf6\x47\xc5\x86\x37\x2d\x6b\xc3\x43\x0b\xd1\x3e\x66\xc3\x33\x73\xd8\x43\xab\x99\x72\x46\xbc\x7c\x1d\x26\xff\x51\xbb\x1f\x95\xff\x98\x4d\xf1\x56\xd5\x66\xe9\x85\x2a\xa3\xbc\x01\x4d\xb1\x0d\xb2\xa7\x9d\xb0\x81\x46\xb7\x66\x56\x45\xe8\x02\x4f\xf2\xf8\x95\x1e\x72\xe5\x19\xee\xb2\xf2\x6b\x94\xf2\xf8\x3a\xb5\x7c\x2d\x94\x6f\xaf\x4d\x91\x8a\x7c\x79\x6a\x87\xeb\xfe\xa7\x6a\x87\x8b\x33\x09\xd4\x5e\xaa\xf1\x99\x4c\x1a\x43\x89\x5d\xa8\xec\xa3\x2f\x09\x06\x4b\x40\x84\x0a\x8a\x44\x04\xc1\x1c\xe4\x52\x10\xcb\x09\x46\xbd\x2c\x6f\x45\x69\x47\x1c\x85\xf6\x36\xc5\x3e\x24\x38\x0b\x4c\x6d\x69\xd5\xfc\xb6\x32\x6b\x6f\xfb\xf2\xfd\x0f\xdf\xc1\x91\x41\xe3\x27\x9f\x4c\x4d\x6d\xcc\xee\x46\xde\x28\xb0\xb6\x3d\xff\xfc\xd3\x07\xca\xb7\x2c\xff\xfd\x2d\x8a\x9d\xed\x66\x66\x78\xa3\xbe\xd1\x20\x4f\xd1\xbc\x49\xa5\xa8\x2f\x6a\x93\xfa\xf4\xb5\xdb\x43\x15\x1e\x0f\x36\x69\xb1\xb6\xba\x0a\x39\xfb\x38\x27\x64\x42\x7d\x44\x7f\x74\x42\xc6\x8f\x0c\xba\xf1\x19\x9a\x18\xa4\x23\xc3\xf7\x4e\x08\x95\xcf\x94\x47\xb3\x04\xd7\xa9\x19\xda\x59\x46\xbc\x9c\xfe\x35\x00\x04\xea\xac\x67\x51\x10\xb0\x13\xf7\x57\xec\x40\x83\x31\x1f\x3e\xfa\xf5\x7b\x9f\x02\xa1\x69\x1f\xbd\xa0\x73\xf8\xea\x2d\xd7\x6c\xba\xf7\xb6\x29\xf2\xc5\x73\x92\xf5\x23\x1a\x5b\xc9\x20\xf9\x8e\xef\x65\x79\xf7\xbd\x9c\x19\xa8\xce\xd2\xf6\x93\xaf\x7f\x1a\x2f\xb9\xed\xe2\xcd\x37\xbc\xf8\x49\xff\x33\xb0\xfb\xcd\x53\xa6\xce\x3c\x15\xb1\x7b\x35\x48\x78\x4e\x18\xcb\x72\x79\x94\x04\xcc\x76\x8f\x3d\x44\x48\x38\xc0\x5b\xbd\xc4\x6c\xb7\xda\x3b\x33\x56\x3b\xd2\xcd\xce\x20\xbe\x30\x31\xab\x1a\x94\xd6\xae\x86\xc3\xc4\x75\x1e\x87\x1a\x8a\x95\xcb\x39\x85\x72\x15\xd1\x74\x29\x72\xd8\x11\xff\xdd\xf2\x4e\xed\xf4\x5a\x77\x7d\xcd\xc9\x37\x4f\x7f\xab\xcb\xff\xd6\x55\xbf\x6c\xc5\x1d\x78\x7d\x20\x8e\x91\x30\xb6\x51\xfe\xea\xdc\x86\x9a\xe7\xe4\x3b\xfe\x2a\x6f\xa4\xe7\x1a\x78\xcf\xe3\x78\xd2\x5f\x26\xca\x77\xcb\x8f\xe3\x51\xf8\x54\x86\x5b\x18\x21\xed\x69\xc2\x6a\x6b\x9c\x6c\xc0\x37\x32\xec\xaa\xeb\xa6\xd1\xd1\xb4\x0f\xe0\x08\x4f\xfd\xb3\xa0\x0c\x1b\x07\xb5\xe3\x93\x0d\xaa\x1d\x7f\xbd\x6a\xfb\xef\xab\xd8\xfe\x3f\xdf\x5b\x13\xf7\x92\x82\x5d\x41\xd0\x04\x90\xc3\xee\x55\xf3\x5f\x85\xd1\x34\xa9\xd6\x17\x44\x5a\xad\x0b\xe4\x78\x62\x37\x11\x53\xa4\x54\x8c\x84\x23\x9c\x11\x54\x8b\x12\xb7\xe8\x9e\x90\x41\xa2\x55\xef\x9a\x90\xd1\xbb\x75\x01\x4d\x70\x82\xa2\x12\x31\xc3\x76\x3e\xf5\x6e\x5e\xf5\x28\xcc\xa3\x89\xdd\xbc\x8b\xf1\x06\x1b\x3d\x14\x29\xaf\xb7\xa5\x30\x65\x1c\x16\x2c\x00\x66\x52\x49\xe4\xf1\xaf\x31\x91\xbb\xbe\x3e\xff\x9f\xb2\x8c\x85\xaf\xce\x97\xf7\x2f\xee\xec\x5c\xcc\x39\x96\x4f\x3f\x65\x21\x79\xd2\x77\xf4\xb5\x43\x5d\x5e\x79\x1a\xde\xe9\x43\xdd\x6f\xbc\x7e\xd4\x8b\x5f\x39\x36\x7e\xc7\x93\x61\xee\xfb\xd0\x23\x3b\xb6\x3f\x1c\xe9\x72\xc5\xfe\xcc\xf6\x14\x62\xfc\x63\x37\xcc\x45\x12\x8d\x91\x2a\xbc\xae\x78\xc8\x52\xa3\xd3\x59\x5c\xa4\x2e\xd5\x37\x60\x0f\xb4\x67\x44\x3b\xa8\xb8\x1c\x31\xda\xdd\xb5\x8a\x78\x4d\xa5\x6b\x35\x9f\x97\x92\x8b\xea\x78\x19\xbd\x14\x51\x3b\xea\xb6\xe5\x28\x21\xf3\xe4\xaf\x77\x1c\x97\x6a\x5a\xe3\x11\xcd\xd5\x20\x87\x0b\x67\xec\xdd\x9b\x25\x8a\xd3\x9f\x79\x63\xef\x8a\x1e\x54\x73\xab\x5c\x7f\x85\x22\x9e\x6f\xed\x46\x0a\x49\xfc\xf6\x6d\xe0\xeb\xf2\xb2\x9e\x74\x13\x07\x57\xae\x54\xe2\xf1\x8d\xe5\x37\x81\xde\x35\x04\x9d\x22\x0d\x34\x0c\x4a\xf5\xb1\x55\xda\xfd\x11\x8f\x9f\xd8\x12\x83\xb4\xc3\x86\x0e\xb4\x55\x46\x22\x95\xb6\x81\xbc\xab\x5a\x2c\x0f\x76\x64\xca\xad\x2e\x97\xd9\x6d\x4c\x77\x80\x8a\x48\xd3\xd2\x21\x32\x51\xc9\x6e\x95\x3b\x91\x68\x54\x8d\x97\xec\xfa\x65\xee\x5c\x22\x55\x9c\x8e\x6e\x28\xd6\xb2\x14\x35\x5a\xa7\x36\xaa\xd8\x64\xad\x74\x07\x46\xd5\x1d\x59\x4f\xc3\xb5\x28\x54\xc7\xca\x22\x9f\xc0\x2c\x91\x85\x4a\x68\x9f\xf4\x60\x9d\x6e\xfd\xe2\x9f\x43\x9f\xba\xc6\x4c\xbb\x78\x60\x53\xf3\xe2\x53\xe0\xcd\x6a\xf9\xd4\x35\x7e\x2a\x7d\xdd\xaa\x64\xa3\xdb\xb8\xa6\x3f\x7e\xf6\x90\xed\xae\x6d\xd3\x46\x49\x99\x4b\x86\xcf\xc7\xe1\x09\xc3\x36\xdd\xf0\xec\xa1\xd4\x9d\xed\x57\xf6\x1d\x35\x7c\xfa\xf5\x23\xc7\xc8\x1f\x4f\x18\x26\x7f\xf8\xfc\x3b\x0a\xed\x9c\x03\x72\x1a\xf5\xbb\xa1\x39\xa2\x87\x49\x11\xbd\xc5\x2b\xd8\x91\x60\x41\x24\x0c\xda\x7b\x67\x46\x27\xda\xf5\x16\x93\xa5\x33\xf3\xff\x10\xf7\x26\xf0\x51\x55\xe7\xff\xf0\x3d\xf7\xdc\x7b\x67\xdf\xe7\xce\x3e\x73\x67\x9f\x4c\xf6\x64\x48\x42\x48\x48\x86\x24\x04\xc2\x92\x85\x4d\x2e\xdb\x04\x8c\xec\x90\x20\x88\xca\x8e\x82\x4b\x05\xc1\x8a\xfe\x45\xad\x20\x22\xad\x12\x15\x2d\xc5\xaa\xad\x82\x45\x6c\x4b\xad\x60\x71\xa5\x2d\x5a\x97\xda\x82\x2d\x5a\x77\x98\xcb\x7b\xce\xbd\xb3\x86\x60\x7f\xff\xdf\xfb\x7e\x3e\x6f\xa9\x77\x96\xdc\x99\x39\xcb\x73\x9e\xfd\xf9\x3e\x6a\x27\xe9\x4c\xf0\x64\xde\xd1\xcd\xeb\x4a\x88\xb6\x36\x95\x55\x43\xa7\x8e\x6d\x90\xc8\xcd\xb9\xe9\x49\x65\xd4\x7c\x26\x7c\x27\xf6\xd4\xfd\x46\xf8\x0c\x8c\x4b\xe7\xdb\x90\xbb\x53\x39\x34\x6f\x0a\x3f\x0d\x09\xcf\xe1\x34\x08\x30\x2a\x0c\xa6\x80\x92\xfc\x5c\x1b\x69\xcc\xed\x48\x4f\x7e\x06\xed\x9d\x91\xf0\x10\xed\xf1\x22\x13\xa5\x50\x10\x76\x24\xe9\xbd\xdc\x61\x2f\x48\x78\x01\xe1\x05\x1a\xa8\x47\xcc\x5e\xaf\x57\xba\xda\x79\xa8\x64\x29\x85\x0c\x99\x0b\xb2\x9c\xee\xef\x78\x12\x92\x02\x90\xdf\x5b\xdd\x9c\x49\xf0\x4e\x03\x19\xe7\xd6\x76\xc1\x67\x6e\xbf\x7f\x81\xa0\x9f\x7b\xef\x8f\xde\xfe\xcb\x99\x93\xc2\xe9\x11\x9d\xe3\xeb\x87\x8f\xeb\x68\x02\xa7\x5f\xf9\x2a\x24\x3c\x8e\x5b\xff\x21\x7b\xeb\x8b\xdf\x7e\xf7\xf9\x77\x9f\xff\xf9\xb1\x3d\x1f\xfe\x7d\xef\x13\x88\xd6\x7a\x84\x1e\xda\x8a\xd6\xd8\x4f\x14\xc7\x59\xc8\x59\x14\x0a\x1d\x07\x83\x01\x8b\x9a\xf0\xab\x4d\x88\x2b\xaa\x29\x29\x94\x52\x26\xa5\x9c\x67\x2c\x65\x51\xcc\x94\x81\x20\xce\x54\x12\xd9\x22\x1a\x08\xc9\x8a\x56\x3e\xc4\x44\x02\xb7\x4c\x1c\xb9\xf2\xa6\xc7\x92\x1f\x80\xd5\xa0\xe3\x1f\xdf\x33\xd3\x5c\x9b\x9e\x7a\xe7\x93\xa9\x3f\x7d\x7c\xce\x9e\xeb\x46\xbc\xf0\x07\xe1\xb7\xbe\x91\x15\xb1\xae\xe2\xda\x17\xc0\x6f\x40\x39\x98\xd2\x2c\xbc\xf8\xf2\x34\xe1\xfb\xef\x6e\x7a\x6e\x53\x43\xb0\x71\xec\xec\x91\xf3\xee\xae\x4a\xf9\xb4\x6e\x86\x05\x54\x05\xa2\x80\xf2\xb8\x55\xaf\x20\x2d\x2e\x8b\x02\xed\xbf\x9e\x54\x3b\xed\x76\xa2\x93\xb7\xeb\x34\x6a\xa2\x2c\x26\xb5\x6a\x1d\x80\xa8\xed\x35\x88\xe3\x19\xe0\x8b\xd2\x13\x75\x00\x5b\xf3\xeb\x84\xcf\xa2\x9d\x4b\x97\xcc\x7b\xf2\xa5\xce\xd1\x6d\x57\x1f\xd9\x09\xd4\x67\xe7\x0f\x6d\x35\x22\x81\x32\xae\x69\x52\x15\xc7\xf5\x4e\x5a\xb9\xa3\x24\xc1\x8d\xaa\x28\xab\xb5\x96\xee\xdb\x09\xf4\xa0\x66\xf3\x37\xe2\x98\x70\xee\xcb\x46\x7a\x38\x52\xdc\xc6\xc5\xa3\x32\x8d\xc6\xa8\x50\x21\xa6\xa4\x32\x22\xdb\x5a\xa6\xee\xe6\x65\x32\x74\x20\xd1\xda\xb1\x4c\x37\x0f\xd8\xac\x78\xc9\xec\x6f\x56\xb2\xe7\x7b\xd4\xa4\x16\x78\x62\x2f\x3c\x5f\x26\x93\xdf\x47\x6d\x9c\xe5\xad\xf8\xdb\x88\x47\xc1\x4b\x3c\x27\x3c\x77\x26\x39\x6a\x57\x3f\x35\x0b\x9e\xfa\x4c\x26\x4b\x9e\x16\x3e\xe9\x17\x0a\xb0\x38\xa1\x56\x3a\xda\xc4\xb1\x35\x21\xde\x11\x10\x7d\x0d\x48\xdb\x30\xea\xcc\x0a\x19\xd2\xe7\x48\x99\x99\x84\x16\x56\x8b\x18\xa1\x56\xcb\xd2\xb4\xa6\x83\x97\xd3\x62\xbf\x43\x1d\x99\xb6\x4e\x07\x1d\x14\xf6\x77\xa5\x1c\xca\xa9\xc1\xc5\xc4\x3c\x28\x70\x5e\x38\xb3\x15\x7e\x30\x1a\x0f\xec\xfa\x33\xdc\xe8\xd1\xdc\xd3\xc9\x07\x68\xc6\xd6\x24\xbc\x77\x00\x8d\xeb\xcd\xc7\x85\xa6\x54\x7f\x8f\xa5\x68\xad\x26\xa3\xb5\xb2\x13\xc1\xb8\x5e\x61\xb5\x28\xad\x4a\xa7\x43\x69\xb1\x50\x7a\x48\x19\xc5\xae\x86\x79\xd8\xcd\x21\x33\xb6\xf6\x10\x71\x9b\x7c\xd9\x18\x1d\x23\xf3\x21\xf3\xef\x64\xcf\x7f\x54\x6c\xc3\xc5\x8f\x7a\xec\xe8\x89\xab\x1c\xba\x16\xd9\x9f\x9a\xa2\x1b\x63\x8f\x15\x6f\x00\x1c\x78\x73\x45\xa9\xf8\xa2\xf2\x81\xb7\x05\x6a\x85\xf4\xdb\xed\x48\xf8\xcd\x41\x72\x0f\xa3\x33\xeb\x29\x24\x85\x01\xad\x90\xd3\xe8\x4d\x24\x13\xd8\xcb\x7f\x1b\xf8\x20\xce\xea\x8a\x01\x86\x9c\x71\x60\xcd\xca\xe4\x9e\x17\xd6\xc0\xda\x8b\xaf\x92\x51\x28\x61\xc4\x11\x4a\x61\x24\x7d\x0f\xbd\x90\xf0\x11\x43\xe3\x6e\xaf\xcf\x66\x37\x28\x95\x76\x1f\xa4\x02\x7e\xbb\xd1\x6d\xf6\x42\x4e\xe3\x24\x38\x86\x9b\xc3\x8b\xe9\xd2\xa2\x02\x61\xad\x6d\xcc\x6f\x19\xc7\xc8\x22\x0d\x20\xe6\xa5\x8c\x48\xff\x91\x45\xaa\x8d\x55\x43\x48\xec\x73\x42\x22\x13\xf1\xd7\x70\xc8\x10\x00\x05\xb7\xf5\x46\xd6\x5d\xb8\x13\xc8\xc0\xfd\x1f\xae\x9f\x75\x7d\x4d\xc3\x54\x7e\x58\xdd\xdf\xb6\xae\x7f\x55\x78\x73\x37\xb5\xc3\xd4\x75\xff\x94\x31\x97\x84\x12\xe1\x93\xbf\x08\x15\x5b\xb9\x95\xa0\xf5\xe9\x47\x40\xc3\x66\xf3\x2d\xeb\xd0\x51\xfb\xfb\xee\xbf\x95\x9f\xf1\x08\x4d\x22\xb6\x5a\x9c\x2a\xa7\x34\x84\x83\x28\x8b\x3b\x0d\x2a\x95\xc9\xc2\x3a\x28\xc6\xe5\x34\x9b\xec\x16\x1b\x06\x6a\xd5\xba\x64\xe4\x04\x5e\x96\x09\x6c\x65\x1c\x4e\x40\xcc\xde\x47\xdc\x85\x32\xb2\xe2\x18\x0d\x43\x22\x74\x24\x14\x46\x17\x72\xeb\xfd\x6f\xdc\xf8\xb3\xfe\x67\xdf\x02\x23\x0e\xad\x5c\x94\x58\x6a\x10\x36\xb5\x82\x5d\x9e\x32\xa1\xab\x95\x3c\xfe\xa4\xbf\x77\xd4\x73\xc2\x8f\xbf\xec\x17\xee\x7b\xa8\xf8\x2b\xa0\x9e\x3e\xeb\xbd\x95\xff\x9a\xd9\xfe\xcd\x4a\x71\xed\x22\xc2\x48\xe6\x3d\x44\x07\x23\x89\xc5\xf1\xba\x7a\x96\x6d\xae\x2e\x8b\xfa\xfd\x8a\xb2\x12\x57\x33\x33\xaa\xb5\x69\x78\x55\x79\x41\x20\x14\x48\xf0\x16\x97\x8b\x6b\xac\x0c\xc1\xda\x22\xae\x68\x36\xaf\xa1\xd1\x7f\x1a\xc2\xce\x99\x14\x4e\xc2\xd8\x9d\x69\xda\x28\x66\xea\x15\xa5\x73\x57\xd0\xf3\x54\xff\xfc\xd8\x65\x69\x7b\xfe\x48\xaa\x74\x5a\xac\x47\x90\xb0\xf5\x53\xbd\x78\xd3\x3d\x6a\x53\x4d\x10\x63\x95\x35\xd9\x17\xa2\xc0\x97\x5e\x40\x33\x43\xdd\x75\xcf\xbe\xe9\xd7\xd6\xcc\xec\xb3\xcd\xa8\xbe\xbf\x65\xd7\xde\x19\x0b\x2b\x97\xf4\x74\x3c\x5c\xd3\xd4\xe7\x1a\x77\x74\xc4\xa3\x4f\xf5\x91\xba\x9e\x65\x75\xd7\x1b\xae\x21\xe1\xd5\xc3\x87\xb9\x67\x79\xaf\x21\xb5\x4b\xc0\xf7\xc2\xc8\x96\x20\xd7\x5e\x7b\xdc\x1d\xec\x2a\x0d\xac\xbd\xf1\xb1\x92\xea\x21\xb5\xc5\x23\xb6\x6f\x86\xef\x39\xda\xda\x1c\x17\xc7\xf6\x07\xaa\x47\xc0\x57\xa5\xe7\x13\x79\x83\x9a\x6a\xc1\xcf\x2f\xd4\xfe\xf9\x0b\x89\xde\x6a\xd0\x9a\x61\x3d\x67\x04\xb1\x24\x5e\x57\x5e\x5a\xe3\x89\xfa\xeb\x6d\xb8\xb5\xbc\xa7\xd4\x4f\x37\x37\x0d\xaf\xae\x28\x20\xd0\xa2\xb5\xf3\x76\x8f\xb7\x31\x16\xd2\x0d\x2b\xf6\x16\x4f\xe0\x0d\x8a\x2e\xde\x60\xa0\x5c\x5e\x8b\xc6\x49\x21\x6d\x8e\xba\xc2\x9a\x0d\xbe\x64\x29\xdd\x1c\xa3\x9a\x5d\xb6\x70\x48\x37\x48\xa1\x9d\x89\x8e\xc1\xd4\x3a\xe5\xaf\x9a\xb4\x68\x4c\xd1\xe7\x27\xc4\x25\xbb\x7a\x8d\x63\x34\x5a\xb2\x87\xf7\x4c\x58\x1e\x3b\xd9\x7c\xe7\xe2\x9f\x0d\x7d\x6d\xab\x30\x0b\xfc\x69\xd2\x88\xa6\x31\x53\x94\xd2\x93\xa6\xc9\x53\xc0\x9f\xe0\x84\x8b\x47\xde\xfd\x0a\xad\x57\xe3\xe8\x23\xee\xe0\xb8\x48\xe8\xeb\x7e\xff\xe8\x55\xab\x00\x4b\x4e\xc1\x92\x2b\x79\x72\xd2\xac\xc2\xc2\x9a\xec\x8b\x08\xf9\xbc\x2d\x8d\xcf\x8d\x28\x8c\xfe\x15\xdd\x45\x84\x71\xdf\x5a\xa4\xd6\x87\x1c\x4a\xa5\x31\x04\x0b\x22\x41\xce\xc7\x25\x78\xc6\x35\x9b\x67\x18\x74\xba\xb5\xd6\x6e\xde\xa4\xa5\x42\x10\xc0\x04\x0f\x8c\x79\x02\x37\xbd\x36\x79\xa7\x55\xcc\x6d\x66\xd2\x29\x68\x29\x5f\xb5\xd4\x8a\x41\xef\xcb\x76\x00\xa5\x9f\x4c\x2e\x7d\xf6\x8f\xcf\xde\xfb\xee\x82\x15\xc7\xd7\x95\xdd\x10\xe6\x3d\xda\x4a\x77\x63\x3d\xa0\x7b\x9f\x5c\x4d\xf6\x3c\xb1\x0b\x69\xfb\xcf\xcd\x58\x76\xe2\xae\x3b\x7e\xb7\xd0\xa0\x11\x4e\xfc\xdc\xea\xd8\xff\x98\x70\x78\x18\x39\x4e\x4a\xac\x74\xa6\x72\x3c\xa9\xcd\xc8\x4e\xf4\x13\xe3\xe3\x51\xab\xc2\x05\xa1\xcf\xa7\x57\xc0\x40\x90\x71\x74\xe1\xd1\xbb\xdd\xde\x76\xde\x4d\xa8\xcd\x1d\x88\x50\xd0\x5c\x00\xe2\xde\x80\xcd\xd7\x19\x2e\xe7\xe0\xd9\x29\x90\x62\xe6\x49\xc6\xd9\x2e\xd5\x2b\x8a\xce\x1c\x2b\xb5\x59\x30\xce\xdb\xf6\xc8\x2b\x67\x3e\x3e\x11\xed\x2b\x1b\x5d\xe2\x2b\x69\xed\x5a\x7a\xed\xfa\x49\x60\x63\xf7\x5c\xa4\x33\xbc\x30\x16\x90\xff\x38\x0b\x48\x93\x5e\xf8\xe7\xd3\xbe\xe3\xbf\x38\x72\xd0\x05\x8b\x9a\x6c\x17\x22\x36\x3c\xee\x3a\xc4\x13\x6f\x40\xe7\xba\x82\x48\xc4\x87\xb0\x65\x05\x2e\x97\x4f\xe1\x2b\x83\xb1\xca\x42\xfb\x6c\xbe\xa0\xb0\x90\x0b\x46\xfc\x41\x7f\x82\x0f\x42\x17\x32\x32\x12\xe9\x13\xcd\x19\x07\x1c\xe8\x2c\x6d\x66\x5b\x4c\xe7\xcf\x24\x53\x23\x9d\x73\x92\xab\x06\x14\x15\xe2\xf9\x48\x31\x10\x83\x99\x82\x5b\x66\x6c\xbd\xa1\x37\x9e\x3a\xb5\x77\xff\x64\xf2\xbc\x8a\x6b\x16\x2f\x9b\xd3\xfb\xe4\x23\xc9\x15\x4f\xec\x22\x7f\xfc\xec\xfb\x5b\x7e\xfa\xe2\x34\xe1\x2b\x61\x64\x61\xac\x50\x3a\xa6\xc5\xa1\x0d\x2b\xc9\x79\x0b\x57\x0c\x4b\x1e\x14\xa5\xaa\x98\xfa\x2a\x4c\xea\x98\xf5\x8b\xdb\x85\xd8\xdb\xdf\x88\xb6\xc7\xd7\xb0\x0b\xe9\x77\x45\x44\x95\xd8\x6d\x76\x88\xb9\xcc\x5c\x50\xe6\x54\x38\x0b\x60\x4d\x75\xa5\xad\x83\xaf\xac\x54\x70\x5c\x71\x07\xcf\xe9\xd5\x74\x27\xaf\x8e\x2b\x58\xc2\xd0\x25\xf5\x13\x46\xf3\x74\xbc\x36\xf8\x4e\x89\x41\x5c\x3a\x53\x05\x0e\x52\x55\xe0\x48\x02\x4a\x19\x12\x52\x61\x62\x4d\x8c\xc1\xb0\x8b\x18\xd7\x26\xb5\x83\x61\x70\x7a\xf4\x35\x63\x86\x3a\x9d\x1e\x79\x27\x39\xa1\xa5\xa0\x69\x78\x43\x68\x74\xb3\x76\xe9\xaa\x85\x9b\x5a\xd7\x4f\x7a\x7e\x93\x43\x37\x55\x57\xde\xdb\xbd\xff\xab\x96\xc9\xcd\x2d\xf3\xe6\xd4\x2a\x23\xe5\x91\x8a\xe6\xeb\xfa\x82\x45\xc1\x9b\xfe\xcf\xc2\x09\x2d\x37\xcc\x1a\xb1\x74\xf8\x92\xf2\xea\x89\x57\x6d\xf9\xdd\xa6\x37\x96\xc3\x79\x23\x87\xc5\x5a\x5a\x9e\x91\xce\xd5\x5d\xc8\xfe\x1f\x8b\x74\xc3\x02\x62\x44\x3c\xe0\x80\x32\xd6\x1b\x0a\xb1\x7e\x1d\xa4\xa3\x85\xd0\xe1\x08\xc8\x20\xa1\x35\x1a\x95\x09\xde\x48\x11\xee\x04\x4f\x98\xb2\xfa\xb7\xe4\x45\xcc\xdd\x3d\xec\x83\x2a\x06\xa9\x78\x14\x6e\xf2\x9b\xc6\xb8\x4d\xbb\x2e\x22\x35\xe2\xcc\xc8\x8d\x5f\x5e\x44\xaa\x96\x75\xdd\x9a\xde\x9a\xf9\xa1\x92\xe9\x2f\xee\xf9\xd3\x85\x86\x55\xef\x09\x97\x96\x6d\xb8\xe1\xde\xda\xb2\x5f\x2d\x3f\x61\x3e\xfa\x4e\xcf\xbe\x23\x9b\xd7\xdd\x59\xe8\xfd\x25\x68\x2c\x7a\xb5\x7f\xe6\xfd\x1b\x6f\x5e\xfc\xc0\x2d\xd7\x5f\x35\x6e\x44\xd3\xa8\xbb\x27\xdc\x3e\x1e\x8f\xfd\x67\x97\xce\xc1\xef\xd0\x79\xc2\xd5\xb5\x1c\x63\xb2\x92\xa4\xc6\x6d\xa2\x7c\x5e\xf4\x84\xd0\xe8\xf5\x0a\xa4\x80\x03\x17\x41\x38\xf2\x63\xfd\x84\x14\x87\xcd\x8d\x81\xc0\x06\xb2\x2a\xd5\x3a\x37\x3d\x66\x20\x4b\x57\x7a\x93\x3f\x16\xca\xec\x6f\x9e\x5d\x32\x77\x6a\x62\x4c\xe1\xe8\xc7\xef\x78\xe3\xeb\xf9\xaf\x7d\xa7\xda\xb4\x69\xf5\xc6\xd8\x2f\xcc\xe0\xf9\x69\x4f\x9c\xda\x7e\xcf\x3d\xc5\xfb\x80\x25\xf0\xee\x0b\xb7\xfc\xfe\xd1\xeb\xfb\xb7\x16\x75\x15\x94\x61\x3b\x01\x0d\x92\xb6\x89\x7a\x77\x88\x98\x1c\x2f\x0e\xc9\x03\x4e\x99\x3a\xa8\x34\xb3\xac\x52\x2d\xf7\xd1\xe8\x90\x3a\x95\x36\x82\x65\x6d\xd0\x60\x33\x74\xf3\x9c\x8d\x52\xc9\x83\xca\x60\x37\xaf\x34\x66\x2d\x59\x29\x07\x37\xed\x46\xcf\xa6\x4d\xc7\x32\x4d\xe8\xb1\x07\x1d\xc3\xe0\x41\x4c\x59\xe9\x29\x58\x6b\xa4\x1e\xec\x0a\xe0\xa3\x8e\xd4\x14\x0f\x19\xb1\x60\x48\x11\xf8\xf0\xc2\x53\x60\xfd\x8f\x9b\xbc\x2e\x93\xc7\x5b\x72\xd5\xec\x75\x77\xbd\x32\x55\xd7\xb4\x7b\x4d\xdf\xec\xe4\x6c\xe1\x3d\xb2\x0b\x9e\x7d\xd7\x38\x65\x4e\xd7\xc5\xbd\xcb\x96\x91\xfb\x80\xea\xfa\xa8\x41\xf7\x2e\x18\xe5\x58\x77\x9b\x7d\xfd\x52\x87\xf0\x9c\xf0\x58\xf2\xcf\xa2\xfd\x93\x40\x7c\xec\x46\x74\x3e\x7c\x44\x90\xb8\x2a\x5e\x1a\x94\xfb\x1d\x8c\x2a\xa8\x34\x9a\x4c\x4a\x15\x9a\x57\x28\xec\xf0\x07\xa1\xc2\x42\x98\x4c\x16\xa8\xb3\xe8\x3a\x79\x8f\x45\xaf\x94\x05\x14\x48\x8a\x29\xd8\xc1\x66\x66\xbd\xc2\xcc\xa4\x89\x99\x20\x66\xc7\xa9\x89\x21\x65\x3f\x35\x33\x00\x7d\x54\x45\xd8\x3b\x64\xf1\xf0\x71\x60\x58\x52\x73\x61\x5b\xa8\x3c\xc0\xba\x42\xa3\xc7\x5c\x35\x7f\xcd\xc2\xea\xc2\x8a\xdb\xae\x99\x3d\x2e\xf9\xbb\x7b\x41\x31\xb9\xe3\x39\xf3\xf2\x3b\x93\x7f\x2c\x2d\x05\x87\x80\xb2\xa9\x50\xf3\x1c\x70\x5a\x4a\xe7\xcf\x19\x33\x75\x0a\x2b\x7c\x24\xfc\x45\xf8\x07\x9a\x53\xeb\xa5\x73\xf4\x8d\xf4\x4b\x68\x4e\xa5\xc4\xa8\x78\xc8\xef\x66\x70\x46\xbe\x09\x96\x95\x73\x45\x09\xde\xcd\x71\xc8\x8a\x33\x68\xb5\x4a\xa5\x23\xc1\x2b\x29\x18\x4a\xf0\x30\xe7\x2c\xd8\xca\x8e\x89\xbd\x68\x72\xd8\x99\x98\xd5\x82\x73\x46\x0d\x43\x8c\x41\x34\x5e\x51\xdb\x10\x5b\xc4\x4a\x0c\xa0\x3a\xe6\x25\x68\x6c\x9f\xa6\x6a\x29\x19\xfa\x46\x64\x7f\x3e\x8b\x96\xf9\xc9\xfd\xa0\xe6\xf1\xc9\x9d\x9d\x55\xc3\x17\x9a\x67\xcc\xd8\x39\x74\x72\xfb\x84\xaa\xc4\xb6\xc0\x53\xcf\x82\x62\x50\x7f\xd1\xfe\xc8\xe3\xfb\x1f\xbe\xe7\xa1\x67\x7f\x2a\x07\x82\x70\x51\xf8\x02\x74\x83\x49\x2f\x83\xe1\xcf\xea\x74\xe3\xea\x8e\x8f\x30\x59\x4c\x7b\x1e\x9a\x2e\x7c\x3e\x5d\x38\x2a\x9c\xfd\xdd\x27\x1f\xbc\x3a\x7b\x9c\x74\xce\xcb\xd1\x59\xf9\x27\x85\xb3\xd7\xba\xe2\xc5\xee\xa8\x15\x42\xbf\x36\x4a\x95\x14\x13\x25\xc8\x56\x0d\x7b\x3b\xf8\x70\x98\x90\x29\xf4\x9d\xbc\x42\x21\x93\x21\x01\xa4\x96\xe9\x08\x47\x36\x6e\x78\x2c\x15\xdc\x4a\x31\x35\xc9\x35\x64\xcd\x56\x85\x8a\xdc\x8b\x03\xe9\x29\x66\xe5\xcf\xc0\x4a\x51\xd2\xf1\xf9\x77\x9b\xff\x7d\xcf\xb4\x49\x6d\x73\xcc\xc3\x3a\xe7\x94\x76\x74\x96\x2f\x58\xbe\x60\xe6\xe4\xc9\x33\x7b\xaa\xcb\x5d\xf3\x9b\x7e\x71\xf2\x73\xf3\x67\x1f\xef\x78\x7f\x15\xc3\xb4\xd6\xfe\xa6\x44\xa3\x7e\xed\xd0\x33\xbf\xb9\x61\xd9\xaa\x3e\x76\x94\xc1\xff\xcc\x3d\x0f\x1f\xc4\xf6\x0f\xa2\x3f\x5c\x2b\x11\xc5\xd4\x17\xe6\x08\xb3\x13\xd2\x0a\xbd\x9e\xe6\x60\x51\xa1\x83\xb5\xb2\x09\xde\xaf\x89\x32\x26\x64\x9a\x39\x4d\x1a\xf4\x0f\x5a\x21\x41\x43\x1a\x6d\x59\x7e\x96\x7b\x6e\x82\x7b\x7a\xdf\xac\x92\x89\x22\x09\x1b\x29\x49\x4d\x26\x5a\xe2\x39\xc9\xe9\xa2\xb9\x12\x91\x9c\xb0\xe4\xab\xd8\x9b\x30\x7b\x42\x51\x6d\x78\xde\xd2\x35\xbd\x89\x7e\xf2\xee\xfe\xc4\xd2\xb5\x4b\xe7\x85\x6b\x8b\x26\xcc\xee\xc1\x9e\x04\xb8\xa6\xa0\xb2\x60\x54\x41\xf5\xf0\x15\x23\xdb\x26\x6c\xc3\xd2\x66\xdb\x84\xb6\x91\x2b\x86\x57\xa3\x37\x2b\x71\x8d\xf6\x68\x64\xae\x4c\x40\x36\x8c\x8e\x28\x8d\xdb\x18\x83\x5e\xa9\x69\xe7\x95\x04\x90\xc9\x65\xc8\x96\x93\x23\x5e\xdc\xce\x43\x96\xc8\x75\xcd\x15\xa5\x9b\x51\x18\xf0\x30\x03\x55\x31\x51\xca\xc7\xe0\x84\x2f\x84\x1b\xe6\x7d\xf3\x0d\x92\xea\x5f\xc0\x96\x8b\xbf\x6a\xb2\x91\xff\x9c\x0f\x3e\x68\xb2\x09\x37\x8a\x3e\x27\xc4\xeb\x6f\x15\xf3\xff\x9a\xe3\x41\xa7\x26\x4c\x15\xfb\x29\x8d\xd2\xcc\x94\x97\x51\x4e\x39\xa7\x33\x5b\xad\xfa\x09\xbc\x55\x2f\x67\x8b\x08\xa2\x60\x42\x0e\xd3\xcc\x71\x95\xe6\xb0\xcd\xff\x1b\x47\x92\x99\x81\xcf\xff\x80\xf7\x68\xb1\xf9\x7f\xe0\x34\xba\xed\x7e\x74\x4e\x3b\x85\x56\x78\x10\xcd\xc1\x49\x44\xf0\x2c\x5c\x94\x5f\x49\x10\x26\x0a\x46\x0b\x88\xe8\xe1\x28\xa9\x81\x66\xa7\x52\x29\x23\x65\xa1\x0e\x5e\x66\x21\xb9\x0e\x9e\xd4\xe7\xb9\xda\x1b\xb3\xa4\x9b\x71\x1a\x49\xaa\x70\xc0\x43\x5a\x3d\x10\xc3\x30\x95\x81\x52\x40\x82\x1c\xb7\x4b\x27\xe8\x07\xbf\xfc\xc3\xdb\xa7\xbb\x64\xca\xea\x1b\xae\xbb\x7a\x47\xcf\x10\xd8\xaa\x98\xbe\x74\xc5\x23\xbf\x99\x4e\xc6\x9b\x3a\xc6\x0d\x1f\x3e\xae\x73\x04\xe8\x25\xa7\x08\x86\x2f\xbe\x7d\xf4\xfa\xee\x72\xad\xda\xd5\xd0\xd7\x6d\xb1\x2b\x95\x86\x5d\xc8\xa2\xbe\xf6\x4c\xff\xde\xbf\x7f\xbc\x7b\x3f\xda\x83\x54\xfd\x33\x61\x45\x7b\x6d\xc5\x30\x6c\x50\x61\xb3\x33\xea\x2e\x5e\xc9\xe8\xcd\x04\x61\xcc\x95\x55\x79\x35\x78\x74\x06\xf1\x87\xcd\x2a\x77\x58\x3c\x0d\xbb\xf8\xed\xb7\x17\x27\xee\x2a\x9d\xf3\xa3\x5b\xd7\xad\xbd\xed\x47\x73\xca\x7e\x62\xfe\xf2\xfb\x6f\xbe\x2c\x08\x8e\x77\xff\xec\x37\xbf\xeb\x77\x8f\x0f\x15\x5c\xba\x74\xe9\xdf\xc2\x38\x32\x4a\x6f\x35\x32\x58\x2a\xe5\xd6\x1f\x51\x22\x9e\x13\x51\x76\xe9\x33\xd8\x8c\xc6\xe5\xc0\xfc\x41\x67\x34\x1a\xa0\x0d\x0d\xcd\xe9\xd2\xa1\x11\xfd\x59\x07\x74\x3a\x4e\x47\xaa\xa1\x4e\x47\x30\xa9\xc1\x5a\x09\x82\x1d\x38\xd8\x9c\x14\xd0\x54\x28\xa0\x72\x90\xa1\xe3\x1e\x21\x19\xe1\x1a\xc8\x8c\x7e\xcd\x7a\x05\xa8\x11\x7e\x27\x5b\xb3\x11\x97\x90\x9b\xbe\xfc\x4e\x9a\xc3\xb6\x07\x56\x3d\xb2\x13\xd7\x90\x4b\x7c\xcc\x89\xc6\x59\x26\x8e\xb3\x23\x5e\x6c\x80\x6a\x85\xc2\x66\x53\x42\xe8\x74\xa9\x94\x68\xa0\xa9\xa6\x88\x6a\xa8\x52\x11\x06\x96\xd5\x75\xf1\xec\x20\x05\xed\xc6\x9c\x61\xe6\x69\x2f\x52\x6d\x3b\xc6\xbf\xc1\x12\x27\xa7\xbc\xbd\x6e\xc2\x6e\x34\xc2\x8d\x6b\x19\xe1\x77\xa0\x46\xb1\x7e\x4d\xba\xc8\xdd\x84\x47\x78\xff\x9e\x55\x0f\x6c\x93\xaa\xdc\xbf\xfd\x0a\xaf\x6d\x91\xe4\x3b\x42\x6b\xbd\x5b\x5c\x6b\xad\x98\x03\x8f\xd7\xfe\xb0\x38\x87\x15\x68\xed\x23\x48\x2f\xb0\x63\x1a\x20\x34\x26\x99\x46\xe6\x70\xea\xad\x09\xde\xac\xa7\x18\xa5\x12\x19\x2e\x4a\xd3\xa0\x34\x20\xfa\x33\x71\xf1\x01\x13\x90\xea\x07\x33\x5e\x39\x70\xf8\x9d\x4f\x9e\xda\xe4\x9a\xc6\x7c\xff\x0f\xe1\x61\xe1\x1e\xb0\x08\x24\x52\x0e\xb9\x4f\xde\x21\x77\x0a\x6f\x09\x9f\x4c\x7b\x59\x78\xb1\x19\x09\x8b\x4e\xd0\x05\x12\x92\x2b\xee\x63\xc9\xcf\x85\x6b\xef\x08\x1b\xda\xf7\x02\xad\xd5\x6a\x54\x43\x28\x37\xca\x1d\x76\x83\x42\xa5\x48\xf0\x36\x92\x54\x69\x00\x60\xb4\x2a\x68\x35\x42\x39\x23\xc7\x2e\xaf\xbc\x32\x40\x63\x0a\x02\x77\x40\x1e\xaa\xe4\xec\x02\x59\xad\x1d\x29\x22\x99\x0a\x34\x38\x3b\x2c\x18\x0e\x0a\x81\xfe\x7e\x92\x06\x77\x82\x2d\xa4\xbe\xbf\x3f\x79\xcd\x41\x20\x90\xfb\x2e\x1c\x4e\xbb\xba\x92\xdf\x91\x32\x64\x29\xff\x48\x7c\xdd\x81\xd7\xad\x5a\x18\x47\xc7\x90\xad\x6c\x23\xa6\xc6\x4b\xf1\x58\xa1\x5c\x6e\x74\xd8\x75\x0e\xa0\x80\x46\x2b\x6b\x6d\xe7\x59\x16\x0f\xbb\x1d\x0f\x5b\xab\xd2\xe1\xf1\xb6\xf3\x8c\x53\x83\x8d\xa8\x58\xa6\x0c\xc6\x90\x93\x82\x33\x30\xbd\xca\x97\x3b\x64\x53\xce\x90\xc9\xd5\xe5\xc2\x8b\x33\x84\x93\x89\x04\x58\xf1\x1d\xa0\xc0\x96\xc9\x93\x85\x9a\x19\xe4\xf9\x0b\x87\xb0\xb5\x4a\x3d\x61\x6d\x4a\x3e\x4f\xb6\x22\xbb\x55\x8e\x5f\xe3\x06\x32\x24\xe1\x4f\xe5\x7c\xe1\xaa\xc5\x8e\x78\x81\x9f\x45\x0b\x49\x3a\xb5\xa4\x36\x18\x32\x1b\x95\x04\x45\x53\x1d\x3c\x4b\xd3\xa4\xd1\x68\xeb\xe2\x8d\x16\xa5\x67\x02\xaf\xd4\x93\x03\xb2\xf2\xd3\xf1\xe2\xcc\xda\xa6\x74\x0b\x34\x2a\xcc\xf7\xf3\xd2\xc1\xd8\x18\x0b\x73\xf2\xc1\xc0\x03\xc2\x99\xa9\x53\xb3\x49\x61\x5f\x2d\x4d\xa5\x84\x09\xdf\xf6\xf7\xcf\x27\x7f\x9f\xc9\x0b\x3b\x34\x1f\x2c\x19\x90\x17\xb6\x1b\xd1\xe8\xc4\x34\x8d\x1a\x65\x84\x46\xa6\x91\x68\xd4\xa4\x37\xc9\x24\x1a\xa5\xae\x40\xa3\x92\x16\x6a\xc2\x0a\x0e\xa6\x51\x7f\x44\x2c\x9c\xac\x34\x52\xb2\x0c\x8d\x82\x59\x60\xb1\x70\x8f\xf0\x70\x0e\x8d\x22\x9e\xeb\x9a\xf6\x32\x68\x6a\x16\xf6\x08\x4f\x0a\x07\x84\xdd\xcd\xa0\xe9\xe5\x69\xc0\x29\xc6\x57\xd3\xe7\x25\x84\xb3\xd4\x4c\x72\xaf\x83\xd0\x68\x1c\x72\x18\x09\xbb\x03\x01\xa5\xfe\x07\x8e\x8e\xb8\x82\xf9\x26\xe6\x95\xcf\x50\x2e\xf6\xdb\x0f\x9d\xa7\xb1\x69\x18\xbe\x2b\x9f\x2c\xe1\xbd\x34\x2c\x1f\x1a\x7f\x76\x2d\xc5\xf1\xcb\x8c\xd2\xf8\x8d\x30\x1c\x09\xb8\xdd\x7a\xe5\x0f\x2c\xeb\x60\xe3\xbf\xd2\xfa\xe6\xa2\x53\xfe\xd0\x5a\x27\x7f\x91\x6e\x95\x70\xe5\x55\x07\x95\xe9\x2e\x0a\xe9\x5a\x6a\xe6\x2f\xc6\x30\xf6\x60\x18\x64\x44\x33\x98\x02\xda\xc5\x78\xb8\x8f\x0e\x23\x43\xc9\xe7\xb4\xe7\xc5\xcf\xa5\xfb\x7f\x96\xb9\x7f\xa1\x78\xbf\x18\xd3\x77\xe1\x00\x66\xa0\x28\x44\xd8\x73\x63\xfa\x88\xde\xbc\x42\x03\xfd\x32\xe2\x43\x65\x44\x5f\x7c\xb8\xd7\x57\x68\xb1\x38\x43\x41\x1d\x41\x04\x65\x4e\x1f\x5d\x5e\x51\xc8\x9a\x8a\x4d\xb3\xf9\xe2\x62\xbf\x3d\xe8\xf3\xf9\xa3\x6e\xbf\xbb\x9b\xf7\x43\x8b\xd3\xee\x4c\xf0\x76\x23\x54\x77\xf3\x66\x59\x10\xc9\x7d\xe8\xc2\x25\x5f\xd9\x18\x51\x8e\xf9\x24\x55\x7f\x5d\xee\x0a\x0b\x49\xa1\x40\x43\x6c\x30\x7f\x83\x64\x78\xa4\xca\x51\x25\xe3\x90\x7e\xf9\xfc\x5f\x5b\x1f\x0c\xf1\x1e\x53\x6b\xe1\xc8\xe9\x8b\x7b\x46\x75\x61\x67\x43\xec\xf0\x34\xe7\x74\xea\xdf\x33\x9c\x13\xbf\xaa\xd8\xb6\xfa\xc4\xef\xc8\x77\xcf\xb2\x2a\xe0\xda\x65\x75\x75\xcf\x22\x9f\x99\xbf\x90\x4d\x8a\xaa\x1f\xd5\x6b\xfe\x0e\x5c\x2f\xfc\xe4\x63\xa3\x70\x73\xc1\xef\x8f\x8b\xeb\x25\xd6\xe7\xe3\xf5\x85\xad\xe2\x7a\xad\x04\x2b\x53\xeb\xab\x47\xeb\x7b\x93\xde\xcc\xc8\x73\xf2\x0d\x00\x96\xdd\xd4\xbf\x11\x3d\x79\x08\x3e\x5e\x41\xc8\x81\x5c\x61\x45\x3a\x17\xd0\xeb\x2d\x0a\xe8\xe5\xdc\xa0\x9b\xd7\xb9\x81\x0a\xba\xdd\x1a\x93\x09\x99\x2b\x56\x13\xa5\xa1\x12\x7c\xab\xfc\x16\x39\x29\xd7\x98\xd2\xeb\x93\x23\xb0\xf3\x03\x02\x52\xe3\x59\x9f\x03\x2f\x86\x78\x50\xa8\x01\x27\x85\x81\x3e\xb8\x57\x50\x53\x27\x8e\x2c\x78\xa0\xc4\x33\x9d\x99\x2c\xfc\xfb\x7a\xe1\xb0\x70\x1f\xb8\x0a\x74\xbc\x7f\x96\x99\xe6\xb8\x71\xcf\xb1\x57\x35\xe0\x0b\x72\x95\xf0\xb9\xf0\x69\x7d\xf4\xcf\x42\x7f\xa0\x02\x5c\x03\x1a\x00\x0f\x7a\xc4\x03\xf2\x8d\x20\xa0\x79\x2f\x41\xf3\x70\x89\x35\xd0\xd5\x83\xd6\xaa\xff\x6f\x6a\xe0\xa6\x23\xfd\xea\xb7\xe2\x77\x94\x88\xb6\x2a\x7d\xe9\x9c\xec\xa7\x62\xbd\x6f\x21\x31\x33\x3e\xc4\x41\xd3\x41\xc2\x13\x36\xab\x3d\x41\x35\x2c\x2a\x76\x50\xdd\xbc\xc3\xe1\xb3\xf8\x90\x71\xe0\x0b\xa2\xff\x8c\x76\xb3\xc5\x9c\xe0\x2d\xe1\x6e\xde\x02\x15\xfa\xab\x79\xb5\xc2\x94\xaa\x33\x4a\xbb\xae\x06\x38\x76\xb2\xd2\x4e\xac\x67\x45\x6b\x06\x32\x27\xd2\x99\x72\xa1\xc6\xbc\x38\x66\x2e\xba\xe9\x7c\x50\x09\x18\x66\xe6\xf6\x75\x2d\x2d\xeb\xb6\x7f\x3f\x6e\x56\x9d\x6a\x54\xb1\xb1\x70\xda\xcd\x7e\xfb\xaf\xa8\x8f\xfe\xd1\x0b\xf4\xc0\x8d\xb8\xc7\xbf\x92\x8f\xf7\x0b\x2b\xed\xbe\x59\x3b\xc0\xc6\xcd\x3b\x92\x7f\xdc\x21\x9c\x2f\x03\xf4\x92\x28\x78\x18\x89\x4b\xce\x85\x1d\x56\x65\xc7\x8e\x1c\x3e\x82\xab\xb5\x91\x01\x7b\xbb\xb0\xf4\x59\x34\x57\x2c\xcb\xf7\xa1\xb9\x7a\x90\x6e\xdc\x1b\xaf\x33\xd0\xb4\xd2\x1e\x0c\x1a\x49\xce\xe5\x22\x95\xb0\x20\xea\x41\x33\xf4\x18\x03\x94\x01\xcd\xda\xae\x33\x20\x12\x31\x18\xe4\x1a\x9b\x49\xaf\xd2\xa8\x90\x5c\xd7\x40\x9a\x54\xca\x95\x09\x5e\x3e\xc0\xfd\x90\xaa\x19\x45\x84\x92\x63\x7e\xe4\xe4\x90\xa5\xcb\x42\x7d\x79\x3e\x3a\x9f\x21\x3d\x79\x83\xde\x67\x4a\x2f\x0e\x1c\x73\x9f\x50\x70\x5f\x72\x23\x12\xfd\xeb\xef\x03\xef\xdc\x47\xae\xef\x9f\x41\x96\x24\xff\xf4\xe1\xb6\xf5\x15\x75\xeb\x37\x8f\x71\x90\x5c\xf2\x03\xb1\x0c\x5d\xf2\xcb\xd9\xc0\xa7\xd2\xa3\xb0\x59\xf8\x11\x58\x79\xcb\xad\xc9\x8f\x6f\xc3\xb9\x8a\x9f\x48\xf8\x0d\x44\x98\x58\x13\x6f\xf5\xaa\xd5\x06\xa7\x83\x26\x08\x87\x01\x46\x0a\x2c\x56\x6b\xc4\xab\x52\xf8\x15\xb3\x79\xc2\x0f\x08\xbf\xde\xdf\xe9\xef\xf6\xef\xf6\x1f\xf0\x33\x0a\xe8\xf7\xdb\x48\xa7\xd5\x6a\xe3\x4c\x36\x53\x37\x6f\x83\x06\x35\x6e\xc9\x9f\xe0\x75\x64\xae\x56\x93\xc7\x35\x70\x35\x7d\x3a\x91\x3f\x5b\x11\x64\xc8\x35\x14\x7f\x90\x63\x20\xf1\x4c\xdf\xb6\x2d\xf9\xf4\xe6\xde\xd9\x83\xb0\x8a\xc9\x3f\x7d\x71\x5a\x8f\x98\x2d\x72\xb0\x67\xe9\x60\x4c\x62\xd6\x2f\x6e\x97\x78\x2a\xfd\x82\xc8\x23\x8e\xa7\x78\xc4\x3f\x53\x3c\xc2\x81\x78\xc4\x12\x87\x5b\x43\x0f\xe4\xc1\x8c\x55\xbc\xff\x77\x29\x9e\xfd\x3c\xba\x9f\x3d\x28\xb2\xec\x5f\x5e\x7a\xeb\xa0\xc7\x47\x9b\x72\x6a\x29\x87\x21\x19\x75\x88\x79\x1d\xdd\x7f\x0a\xdf\x2f\xbf\x88\xbe\x7f\xbc\x54\xa7\x89\x3e\xd0\xea\x2d\x20\x14\x79\x3c\xc8\x2f\x24\x18\x0b\x5a\x7f\x2b\xe2\xd7\x2d\x8c\xc2\x6a\x36\x43\xbd\xc9\xa4\x86\x0a\x35\xb4\xd9\xbd\x76\x40\xd8\xf5\xf6\x6e\x7b\x9f\xfd\xb0\x9d\xd6\x40\xa8\x56\xaa\xb1\x64\xee\xe6\x19\xa5\x91\x90\x75\xca\x76\xcb\xde\x97\x51\x6a\x28\x63\x8d\x1a\xb1\x4a\x59\x47\xc0\x2c\x88\x01\x5e\x70\x31\x82\x9a\x41\x32\x18\x10\xba\x90\x94\x32\x18\x80\xf9\xc4\xc6\x58\x90\x16\xf9\x93\x99\xcb\x67\x26\x1f\x7c\xe2\x09\xf2\x9e\x7e\x32\xd8\x4f\x0f\x1f\xe3\xb8\x70\x87\xb3\x4d\x48\x80\x87\xb1\xab\x17\x13\xd6\x85\x7b\xa8\x45\x52\x1d\x78\x1e\x6e\x8a\x74\x7e\xa8\x0f\x44\x0c\x06\x17\xf1\x56\x7c\xa7\xd6\x6e\x87\x0a\xb9\xd9\x68\x94\x43\xe8\xf6\x38\x3d\x45\x9e\x3a\xcf\x74\x0f\xf5\x91\x07\xa8\xd0\xab\x3a\xcf\x03\x1e\x6a\xc1\x69\xcf\x05\x0f\xe9\x89\xcf\xee\x19\xbd\xde\x03\xc8\x5e\x0f\xd0\x7b\xca\x3d\x9d\x1e\x78\xc0\x03\x74\x9e\x0e\x4f\xaf\x07\x7a\xe2\x2d\xa3\x46\x13\x9e\x6e\xcf\x76\x0f\xac\xed\xf5\x3c\xe5\x79\x1d\xbf\x17\x2d\x1e\x7d\xde\x03\x9e\xc2\xf7\xc7\xd1\xdf\xfa\x3c\xd4\x25\x0f\x78\x1f\x7f\xa8\xd1\x43\xca\xa1\xd6\xd6\xcd\x6b\xb5\x88\x51\x68\xba\x79\x79\x0a\xa4\x05\xd8\x13\x7c\x26\xa8\x91\x16\x70\xb9\x0e\x19\x31\x6b\xb0\xe8\x5a\xc4\xce\xa5\xc4\xc1\x22\xb1\x96\x3b\x9f\x5e\xb3\x48\x2e\x22\x75\x62\xc6\xa4\xcf\x30\x2e\xf2\x60\xb2\x6f\x7f\x3f\x35\x53\x35\xad\xa6\xe7\xcd\x67\x1f\x07\x66\x60\x17\x0e\x6d\x5b\xbf\xfe\xf6\xf5\x9b\x53\x10\x2f\x87\xfe\x60\x16\x0a\x8e\xbc\x24\x6c\x06\xab\x6f\xd9\x92\x3c\xbd\x95\xb8\x1c\x6f\x26\x2d\xcf\xf0\x6b\x2c\xcf\x70\x7f\x21\x61\x2c\x3d\x17\xad\xab\x01\x51\xcb\xd4\x78\xb9\x05\x89\x25\x3d\x2d\x97\x5b\xad\x94\x46\xaf\x50\x53\x7a\x4c\x32\x94\x46\xa1\x49\xf0\x0a\x6b\x37\xaf\x30\xaa\x18\x27\xd4\x13\x7a\x5c\xbc\xde\xcd\x63\xca\x48\x47\xb4\x1a\x73\xc3\x37\xc6\x4c\x45\x4d\x4a\x60\x61\xb2\xc0\x44\x81\xfe\xab\xa9\x36\x9a\x22\xb4\x4f\x09\x64\x3e\x60\xa2\x86\x3e\xf1\xdb\xc0\xda\x8d\x17\xcf\x6d\x5e\x1b\xf8\xed\x8a\x9b\xa8\x17\xc8\x4e\xe1\x63\xf2\x86\x85\xe0\x12\x3d\x5c\x8c\xcd\x08\x24\xf8\x85\x30\x16\x08\xf6\x8f\xc8\x31\x60\xb4\x2b\x24\x9c\x48\x3e\xf1\xd7\x81\x18\x32\xb8\x57\x2a\xe2\xaf\x1f\xa3\x79\x44\x40\x6f\xfc\x92\xc7\xce\xd9\xb8\xa0\xd7\xeb\xb2\x29\x69\x85\x42\xa5\x87\x1a\xca\x60\x08\xd9\x6c\x2e\x9d\x5a\xa3\x89\xba\x1d\x2e\x57\xc1\x94\x28\x68\x89\x82\xea\x28\x08\x46\x01\x13\x05\x53\xa2\x2b\xa3\xf7\x46\x0f\x45\x8f\x45\x3f\x89\x32\x6d\xf8\xad\x70\x94\x5c\xf0\x5c\xf4\xdd\x28\xf9\xe3\x28\x00\x9b\xa2\xa0\x2f\x0a\x7a\xa2\xa0\x53\xfc\x18\xda\x2a\x73\x14\x10\x51\xf0\x65\x14\xbc\x1f\x05\xa7\xa2\xe0\x70\x14\xdd\xb3\x37\x4a\xf6\xe1\xbf\x0c\x89\x4e\x8a\xf6\x44\xa9\xbd\xd1\xa3\xd1\x8f\xa2\x70\x75\x14\xe0\x37\x48\x55\xb4\x28\x4a\xd6\x5e\x10\x6f\xbf\x23\xba\x3f\x7a\x3c\x0a\x7b\xa3\x80\xf4\x46\xe3\x51\xf2\xa9\xe8\xeb\xd1\x33\xd1\x4b\x51\x8a\x88\xea\xa3\xe5\xd1\xce\x68\x5f\x74\x43\x94\xc9\xbe\xd8\x1e\xdd\x1d\x3d\x1c\x7d\x3f\xaa\x90\x43\xb7\x55\x6d\x34\x1b\x13\xbc\xca\x13\xa2\xec\x7a\x9b\x41\x4e\x38\x1d\xac\xce\x6c\x0c\x72\x4a\x1a\x86\x89\x30\x12\x94\xcf\xc8\xc4\x23\x5b\x99\x0e\x30\x62\xc3\x4a\xcc\xff\x96\xde\x10\x0f\x6e\xaa\x9d\x7f\x7e\x42\xab\xf4\xbf\x44\x36\x41\x79\x59\x46\x8e\x48\x79\x66\xa9\xba\x37\xa9\xae\x24\x5d\xfa\x86\x37\x57\x12\xa6\x0a\x5c\x02\x07\x32\xe1\x20\x20\x42\xcd\x88\x7f\x01\x86\x08\xf9\x5b\x92\xdf\x09\xfe\xba\x0c\x3c\xb8\x5d\xd8\x0f\x8e\x2d\x17\xfa\x84\x5d\x8b\x77\x25\x1f\xd8\xb5\x44\xd8\x2d\xf4\x2d\x07\xaf\x08\xfd\xdb\xc1\x83\xcb\xc0\x5f\x77\xa2\xad\x77\x24\xdf\x20\x4b\x71\x34\x56\xb8\x36\x69\x73\xb6\x91\xeb\xae\x12\x86\x8b\x8c\xf8\x37\x57\x25\x6f\x6a\x73\x92\x9f\x82\x3b\xf1\x5f\xc5\xbb\xc4\xfd\x9f\x85\xf4\x15\x80\xf4\xae\x10\x31\x21\x5e\x24\x63\x9c\xae\xa0\x9e\xf5\x69\x08\xc2\xa7\x77\x31\x74\x38\x12\x34\xe8\x0d\xfa\x6e\xde\x60\x80\x2e\x8e\x43\x2a\x3d\x47\x41\x15\x3e\xb8\x19\x05\x22\xe5\x7a\xc8\xcf\xf6\xcc\xd4\x58\x9b\x29\x49\x95\x47\x4a\xa8\xd7\x30\xa4\x0c\xe0\xae\xff\x18\x0a\x37\x15\x49\xc1\x5e\x2a\x19\x45\x01\xe1\x7d\xe1\xc2\x1f\xf6\xa9\x67\x0c\x89\xac\x2a\x01\xaa\xcf\x6f\x58\x31\x6b\xde\xeb\x55\xbd\xfe\xa2\xab\xfa\x7f\x09\xce\xee\xfe\x11\x98\x01\x96\x1c\x7c\xad\x00\x8c\x7c\xdb\xe2\x04\xe1\xff\xe8\x64\x37\xca\x99\x75\xcb\xce\xbb\xad\x2f\x83\x8a\x22\xe1\xd0\xa6\xfd\x6c\x61\x3a\xbf\x45\x94\x9f\x4e\x62\x41\x7c\x18\xe3\x74\x2a\xec\x76\x52\x63\x36\x2b\x2d\x16\x03\x69\x70\xb9\xbd\x38\x23\x5d\xef\xee\x76\xf7\xb9\x0f\xbb\x11\x07\xb7\xea\x55\x12\xf8\x8c\x86\x86\x76\x8b\x41\x82\x9e\x31\xe7\x40\xcf\x64\x75\x85\x7c\xf8\x99\x74\x92\x49\x3e\x10\x4d\xca\x97\x9a\xda\x44\x8c\xf2\x81\x7d\x01\x77\x63\x96\x4d\xde\x23\xc1\xd2\xfc\x39\x03\x4b\x73\xf1\x27\xb0\xb0\x36\x8b\x4f\x03\xd7\x5e\x7c\x6b\xa2\x63\x4c\x46\xc6\x9d\x48\xcb\x38\x24\xb3\x8e\xa7\x64\x22\x32\x33\x00\xc9\x45\x08\x6d\x9e\xcc\x12\x65\xa8\x98\xa7\x32\x33\x5e\x26\xd5\x6a\x5a\x49\x40\x91\x90\xb6\x28\x95\x3a\x5a\xe7\x90\x39\x2d\x0a\x82\xd1\x29\x29\xcc\x71\x35\x8c\xd1\xca\xea\xc5\x89\x1a\x73\xc5\x53\x6a\x9e\xa9\xb4\xad\x94\xdd\x6b\xcc\x8d\xf1\x81\xcb\xa8\xb4\x2a\x45\xbf\xf4\xae\xbd\xc2\xd5\xe0\xcb\x05\xc2\x35\xc2\xdc\x35\x47\x92\x53\xd1\xa4\x77\x3c\x41\x8e\x5c\x8d\xa9\x51\xb8\x31\x69\x40\x54\x78\x47\x42\x18\x9a\x76\x81\x20\xe2\x7b\x9d\xac\x70\xb4\xa1\xb1\x23\x3d\x96\x3e\x85\xc6\xee\x22\x46\xc5\x23\x4a\x5a\xed\x62\xcd\x66\x17\x0d\x3d\x6e\x83\xed\x6a\xde\x6c\x30\xd1\x29\xcd\x8d\x72\x01\x17\x92\x11\xaa\x6e\x24\x2b\x32\x8c\x73\xd0\x74\x39\x90\x0b\x09\x84\xb5\xd2\x40\x8e\xde\x0a\xf4\xd4\x51\x71\x1f\x84\xe9\x58\x0b\x5d\x96\xa3\xa7\x52\x5f\xe6\x40\x05\xa5\x94\xcf\x1c\xe5\x74\x10\x3c\xa7\x3c\xac\xad\x81\xd8\x47\xe8\x75\x0a\xfb\x08\xc9\x8b\x89\xc4\x65\xb8\x43\xa9\xfb\x8b\xc4\xfb\xc3\xc4\x65\x18\x3f\x68\x6d\x44\xdd\x45\x5c\x9b\xb1\xf1\x08\x6b\xa6\x19\x27\xe3\x34\xab\x94\x2a\xb3\x8b\xa0\x3d\x6e\x27\xad\x07\x7a\xbc\x48\x7a\x93\x8a\x91\x96\x47\x8e\xd7\x26\x96\xb3\x9f\xd9\x22\x7d\x11\xf9\xb9\x36\x03\x1a\x9a\x66\x2d\x5a\x9c\xc8\x9c\x5a\x9e\xea\x1a\x30\x8c\x7c\xe6\x20\xa8\x04\x05\x7b\xc1\x6f\xef\x14\xc6\xdd\xb0\x7a\xd3\xa4\x8a\x1e\x97\x7a\xc4\x90\x60\xf5\xe8\x95\xad\x82\x11\x2f\x91\x23\xf9\x47\xb2\x52\xcc\xfb\x78\xe7\xcc\x83\x63\x1d\x06\x60\xbf\xae\xa2\xef\x36\x38\x35\x85\x41\xb4\x3d\x83\x41\xb4\x2c\xfe\xd5\x40\x0c\x22\x09\x06\x08\x83\x00\x91\x9c\x88\x13\xf4\x42\xd5\xe9\xaa\x0b\x55\x50\x44\x20\x52\x55\x61\x60\x21\xb8\xe0\x92\xf4\x36\xb9\x0b\x83\x0a\xdd\x51\x45\xb6\x54\xf5\x54\x91\x75\x22\x74\x91\xaa\xca\x59\x45\x0e\x80\x16\xc2\xef\x61\x3c\x22\xea\x6c\x15\x38\x83\xf1\x88\x30\xaa\xd1\xf4\x2a\x8c\x47\x04\xe3\x12\xa8\x11\x39\xf4\x2c\xc6\x3c\x02\x77\x88\x80\x46\xe8\xd7\x40\xea\xb7\x8e\x56\xe1\x2f\x83\x0f\x60\x78\x23\x09\x72\xe8\xcb\xd4\x8f\xef\xc0\xc3\xc4\xdf\x02\x83\x55\xe0\xff\x0f\x1c\xa2\xcb\x40\x87\x72\xcb\x25\x96\xfd\x7f\x88\x42\xf4\x49\xb7\x88\x42\xf4\x31\x46\x21\xea\x16\x46\xf4\x6f\x91\x50\x88\x6e\xc5\x28\x44\xb7\x4a\x28\x44\x5b\xfe\xe7\x28\x44\xc4\x60\x38\x44\x05\xc2\x58\xc6\x2e\xe2\x6b\x4d\x8f\x57\x69\x65\x80\xa2\x74\x3a\x42\x46\x58\xac\x5e\x2b\x20\xac\x7a\x6b\xb7\xb5\xcf\x7a\xd8\x8a\xb8\x31\xab\xd7\xc8\x95\x68\x7d\x8d\x4a\x48\xc8\x68\x59\x82\xa7\x75\xdd\x3c\x6d\x94\x5c\x87\x39\x65\x26\x79\xbc\x38\x2d\x68\x42\xd6\xcb\x34\x67\xf4\x48\x77\x61\x1d\xe9\x42\xb9\xa4\x39\xd3\x98\x19\xf7\x88\x8a\x51\xbe\xda\x3c\xc6\x81\xc6\x69\x17\x73\x71\xb0\x9d\xd9\x19\x2f\x60\x3c\x2a\xab\xd5\xe8\x31\x72\x5e\x9b\x4a\xe1\x40\x36\x97\xc3\x61\x26\xad\xa2\xfa\x60\x36\xa6\xad\x2b\x2d\x09\x07\x5a\x57\xb9\xfe\x98\x9c\xf2\xd6\x81\x59\x46\x69\x0e\x25\x65\xe8\xfc\x6c\x1b\xd9\xb1\x59\x4c\xef\x20\xb7\x3c\xb1\x2b\xb9\x54\x4a\xef\xa0\xde\x15\x4d\xc4\xa9\x0b\x57\x64\xf3\x6d\xb0\x1c\xef\xc7\x39\x1d\x12\xdf\x97\x63\xbb\xd8\x09\x46\xc5\xcf\xeb\xe4\x56\xbd\x0d\x42\xbd\x1c\xba\xdc\x66\xf7\x10\xf7\x24\x37\x54\xb9\xc1\x79\x37\xf8\xc8\x0d\x4e\xb8\xc1\x41\xf7\x51\x37\x79\x87\x7b\xbf\x9b\xec\x71\x83\x4e\x37\xc0\xb7\xb4\x88\xb7\x2c\x3c\xeb\x06\x3b\xc4\x42\x2f\xd8\xeb\x06\xd3\xdd\x20\x2e\x96\x91\x79\xc5\x32\xb2\x9e\x54\x15\xd8\x47\x6e\xba\x0e\xbf\x11\x74\x93\x2f\xb8\x4f\xbb\xc9\x4d\xee\x1d\x6e\x72\xb5\x54\x17\x86\x7e\x69\xd8\x79\xfc\x0b\xa7\xd0\x6d\x50\xfc\x8d\x3e\xfc\x49\xfc\x33\x2a\x77\x91\x9b\xc4\x7f\x21\x1f\xc0\xef\x6f\x73\x03\xf4\xa1\x5e\xe9\x9b\xd0\xcf\x7f\x29\x16\xaa\x9d\x49\x57\x9b\x1d\x75\x53\x09\x37\x20\x09\x24\xa6\xe3\x6e\xa8\x84\x56\x1d\x83\x08\x40\x72\xcf\x33\x46\x0b\x86\x86\xb3\x13\xc8\x5c\x30\xa9\x06\x2a\x69\xb9\x67\x28\x71\x19\x98\x57\x46\x55\xbb\xbc\xe6\x68\x59\x8e\x21\x91\x31\xc1\x2e\xb3\xf5\xf1\xa3\x7c\x5f\x7f\xff\x37\x6b\x11\x1d\x6d\xbc\x0f\xbc\x70\x1f\xb9\x18\x5f\xd3\x76\xd8\x40\x62\x4a\xd9\x62\x78\x8f\x84\xb1\xf2\x27\xd1\x1e\xb9\xc1\xc4\xf8\xd7\x4a\x68\x54\x39\x09\xc2\x64\x72\x38\x54\x10\x7a\x38\x33\x37\x84\x9b\xc4\x41\x15\x07\xce\x73\xe0\x23\x0e\x9c\xe0\xc0\x41\xee\x28\x47\xde\xc1\xed\xe7\xc8\x1e\x0e\x74\x72\x00\xdf\xd2\x22\xde\xb2\xf0\x2c\x07\x76\x70\x07\xb9\x53\x1c\xec\xe5\xc0\x74\x0e\xc4\x39\x30\x84\x03\x5e\x0e\x50\x1c\xe8\xe1\x36\x71\x7b\xd1\x1f\x3f\xe2\xe8\x3a\xfc\x46\x90\x23\x5f\xe0\x4e\x73\xe4\x26\x6e\x07\x47\xae\xc6\xef\x88\xbf\x34\xec\x3c\xfe\x85\x53\xe8\x36\x28\xfe\x46\x1f\xfe\x24\xfe\x19\x15\x57\xc4\x91\xf8\x2f\xe4\x03\xf8\xfd\x6d\x1c\x40\x1f\xea\x95\xbe\x09\xfd\xfc\x97\x1c\x40\xbf\x7e\x86\x03\x2b\xc4\xdf\x39\xca\x51\x09\x0e\xed\x13\xe7\xe5\xe2\x1c\xda\x27\xb7\xd3\x6e\x36\xa8\x15\xa2\x7a\x61\xd1\x32\xd0\xa8\x04\xca\x6e\xde\x91\x97\xab\x96\x0f\xd6\x15\x4b\xd5\x61\xfc\xaf\xf6\xca\x58\x3b\xd0\xec\x1b\xb0\x55\x29\x93\x49\xb6\xf5\xdb\x7b\xa5\xfd\x7a\x5a\xdc\x2f\x74\xdd\xd0\x8f\xd8\xc1\xe0\xbb\x25\xee\xa4\x80\xf4\x22\x11\xa7\xf1\x25\xb4\x67\x66\xc2\x4d\x4c\x8e\x97\xeb\x0d\xc0\xe1\x50\xb2\x34\xad\x34\xa0\x3d\xd3\xa1\xc5\x42\x36\x2b\xd2\x43\x80\xdc\x60\x34\xaa\xbb\x91\x16\x85\x38\x16\x94\x3b\x90\xfc\x4d\x3b\x99\x32\x7e\x35\xe3\xc0\xac\x82\x74\x96\xa2\x68\xa1\x8a\xc3\x4f\x69\xc2\x3e\x36\xeb\x4b\xf2\xf7\x61\x1b\x35\xf9\xa7\xe4\xe3\xfb\x63\x4d\xbb\xc2\xc5\xd3\xe0\x87\x8b\xb6\xad\x1f\xd9\xb1\x7e\x33\xf5\xae\xe0\xc7\x76\x2a\xb2\x5b\xfb\xd4\xf2\x3f\x80\x31\x6d\x17\x6f\x4d\x59\xac\x50\xd4\x4f\x7e\x29\xca\x5f\x1b\xb2\xfc\x67\xc6\x63\x4a\x9a\x36\x11\x5a\x8f\xdd\xae\x35\xc1\x10\xb2\x6f\x80\x05\x06\x39\x85\xe8\x09\x54\x52\xdd\xbc\x52\x69\xf0\x59\xa0\xc7\x6e\x32\x98\x90\x64\xa3\x13\xbc\xcb\x20\x3a\x8b\xb2\xc5\x26\x52\x5e\x5b\x2c\x36\xc8\x0c\x32\x5e\xc1\x9c\xa9\xe0\x95\x07\x39\xe7\x07\x6e\xdd\xb6\xfe\xba\xf5\xeb\x37\x0b\x6b\x77\xa7\x26\xb4\x6a\x7f\x3f\xf9\x3a\xe5\xc0\xb9\x05\x98\x15\xa7\xcc\x6d\xf8\x51\x66\x56\xc8\x1a\x6f\xbb\xd0\x97\x75\x94\xa5\xfd\x17\x67\x53\xf3\x7a\x35\xbe\x5d\x9a\x95\x49\x6b\x77\x38\x91\x5a\x51\xe7\x98\xee\xa0\x3e\x72\x00\x15\x7a\x55\xe7\x78\xc0\x41\x2d\x38\xed\xb8\xe0\x20\x1d\xa2\xef\xc2\x01\xc8\x5e\x07\xd0\x3b\xca\x1d\x9d\x0e\x78\xc0\x01\x74\x8e\x0e\x47\xaf\x03\x3a\x44\xdf\x85\xa3\xdb\xb1\xdd\x01\x6b\x7b\x1d\x4f\x39\x5e\xc7\xef\x61\xdf\x85\x03\x3c\x85\xef\x8f\xa3\xbf\xf5\x39\xa8\x4b\x0e\xf0\x3e\xfe\x50\xa3\x83\x94\xc3\xbc\x75\xb3\x40\xbc\x5e\xe2\xba\xa5\xf7\x3b\xbd\x5a\x3f\xe4\xb2\xc8\xe9\xfc\x70\xa5\xf5\x83\x0f\x6f\x5b\x7f\xfb\xdd\x68\xcd\x16\x1c\x4c\xad\xd9\x5c\xbc\x66\x83\xaf\x94\xa4\xff\xdf\x89\xf4\x44\x9d\xe8\x37\x9f\x1e\xaf\x94\xc9\xe5\x16\x16\xb8\xdd\x5a\xad\x87\x85\x9c\x97\xf0\x74\xf3\x3a\x02\x91\x2c\xb2\x24\x54\x06\x44\xa3\x84\x25\x6e\x21\x35\xb4\xc5\x60\x92\xa9\x54\xe8\xbc\xaa\xa8\x5c\xc8\xa3\xc1\x7d\xe7\xa9\x14\x73\x32\x3c\x20\x42\x13\x4c\xd9\x75\x18\xdc\x06\xbc\x0e\xbe\x50\x1d\xfc\xf5\xee\x1b\x5d\xd3\x98\x6f\xde\x06\x0d\x60\x94\xb0\x47\x38\x7a\x9d\xf0\x19\xcf\x4c\xf7\x16\x3f\x38\xff\xf9\xdf\xd3\x82\x86\xfc\x27\x50\xfe\x5b\x8a\xcb\xec\x17\xee\x13\x8e\x08\x0f\x56\x04\xc0\xa4\x3f\x47\xeb\x71\xda\x9c\xe4\xab\xba\x74\x4e\xfe\x10\x9a\x8b\x03\x69\x11\xf3\xe2\x43\x31\x8c\xab\x53\x63\xf7\x99\x4c\x76\x1a\xbb\x40\x3d\x88\xc1\x98\xf4\xc1\x04\xaf\xa7\xd4\x0e\x34\x33\x35\x9a\x99\x5a\x0d\xe5\x2a\x46\xce\xa0\xb3\x77\x59\x3e\x4c\x46\x24\xe3\x19\x5d\x86\x13\x90\xef\xec\x4c\xf1\x0f\x23\x91\x01\xb1\x85\xbe\x50\x4e\xa5\x0d\xa9\xcc\x90\xed\x75\x46\x30\x0a\x54\x83\x91\x60\xac\xf0\x8c\xf0\xa2\x70\x4c\xf8\xb9\x52\xd8\x4a\xbe\xb4\xb3\x7f\xff\xce\x9d\xfb\xf7\xdf\xdf\x93\xe3\xe8\x35\xa0\xfb\x8a\x85\x7d\xc2\x93\x22\x8e\xed\x18\xd0\x12\x16\x4b\x6f\x0c\xa0\x51\x2c\xbd\xc1\x79\x99\x68\x6f\xe8\x47\x45\xfd\xc8\x43\x5c\x1d\xaf\xb6\x68\x4d\x26\xc2\xe1\x50\xab\x65\x3a\x83\x8c\x30\xe0\x4d\xf4\xee\xf6\x92\x6a\x88\x48\x5e\xdb\xcd\xdb\xed\xd0\xa8\x16\xd1\x10\xf5\x0a\x23\x74\x21\xf9\x88\x66\x0e\x61\x8a\x0a\x25\xfe\x9a\x56\x42\x06\x9c\xdb\x54\x31\x8e\x69\x48\x30\x9a\x95\x74\x01\xec\x6a\x00\xa5\x20\x84\xeb\x15\x31\x37\x7a\x1e\x04\x40\x94\xdc\xd5\xbf\x2b\x79\x63\xff\x3b\xc2\x09\xa1\xfd\x2e\xe0\xbe\x7e\x03\x18\x7a\xef\xde\xbb\xb6\x1c\xd8\x06\x8f\x1d\x39\x94\x0e\x5f\x83\x53\xc9\xdf\xa2\xeb\x37\x05\x2f\xaf\xbf\xf7\x36\x32\xba\x0e\xe9\x7e\x4d\x97\xce\xc1\x0f\xe0\x11\xa4\xfb\xb5\x88\xfb\xd9\x89\x5e\x1f\xa4\x9f\x17\x63\x84\xf3\xe3\x6a\x87\xc2\x62\xf0\x7a\x09\x0b\x11\x09\x47\xb0\xa2\x1c\x2b\x28\x1a\xbd\x3b\x82\x44\x49\xc4\x1b\xd9\x10\xd9\x1e\xa1\x0e\x47\x40\x22\x02\x88\x08\xd0\x40\x5b\xa0\x83\xb7\x59\xcc\xee\x0e\xde\x68\xd6\x77\x2b\xb6\x2b\x76\x2b\xa0\x4e\x01\x14\x44\xd9\xcc\x99\x79\x95\x46\xcb\x12\xcb\x8a\x72\x0a\xfa\x70\xf2\x8b\xb1\xba\xa6\x81\xac\x89\x69\x49\x19\xfa\x7f\xac\x5a\xf4\xd5\x7b\xf3\x52\x5f\xa6\xbf\xf2\xf0\x83\x3d\x0d\xf2\x56\xd8\x7c\xc7\x91\xb5\xcb\x63\x4a\x59\xd7\x69\xf0\x88\x30\x5a\x98\x44\xc6\xd3\xd5\x47\x64\x13\xae\x90\x3a\x60\x36\x5a\x7d\x8e\x15\x37\x8f\xb2\x1b\x6a\x97\xde\xf1\xa8\x60\x41\x5b\xfa\xef\x74\x11\x92\x88\xbd\x8a\xcc\x70\xca\x28\x62\xe7\x38\x08\x1f\x31\x27\x5e\xa3\x72\x2a\x9c\x56\x2b\xe9\x51\x18\xb5\x48\x65\x81\xfe\x80\xca\x69\x71\x5a\xda\x79\xb5\xd3\x25\x81\x90\x11\x34\xed\x6b\xe7\xa5\x2a\x16\xc2\xda\xce\x13\x64\xbb\x94\x66\x9b\x12\x1c\x39\x87\x70\x00\x78\x4d\x0a\xb4\x48\xa4\x56\x1c\x14\x95\xb1\x14\xc6\xdd\xcf\xc8\x0e\x80\x7b\x9c\x17\x81\xaa\x44\x02\x7c\x70\xfe\xc4\xdf\x80\xe7\x6f\x42\xf2\xe5\x59\x8b\xfb\x7a\xe7\x2c\x10\x8e\xcd\x7c\x78\xff\xc4\x26\x1b\xf9\xad\xad\x69\xf9\x75\x4f\x14\xc8\x2d\xbf\xdb\x76\x23\x30\x76\x4e\x16\x1e\x99\x02\x66\xff\xf4\x7e\x91\x97\x54\xa3\x09\x2d\x41\x73\xd1\x11\xb1\xb8\x93\x51\x01\x42\x45\xe8\x0d\x18\xab\x48\x4b\x77\xf0\x40\xab\xc3\x07\xad\x9d\x97\xb3\x79\x15\x41\xd9\x20\xb9\xe4\x7e\xcd\x9c\x27\xb8\x64\x6c\x51\xef\xd4\x55\x3b\x93\x7f\x4f\x24\x60\x0d\x79\xc3\xf3\xa6\x24\x2b\xe6\x11\xa0\x21\x48\x35\x67\x76\xe1\x41\xf8\x95\x88\x65\xc5\xe2\x9c\x64\x46\xa1\x30\x1a\x69\xb3\x41\xaf\xc5\x7d\xdc\x2d\x56\x5a\xab\xd4\xb6\xf3\x4a\x63\x07\xaf\x64\xd5\x32\x0a\x59\xbc\xed\x3c\x30\xa1\xff\x74\x69\x27\x40\x59\xd6\x7b\x2a\x61\x5e\xc6\x62\x69\xbc\x3c\x53\x55\x9e\xef\xd4\x68\x82\x3e\x43\x80\x7c\x1d\xca\x13\x6b\xf5\x0b\x6e\x17\xa2\xb7\x2f\x30\x2c\xbb\x23\x58\x09\x3a\x0f\x72\x70\xd1\x08\x31\xc7\x41\x98\x06\x7a\x84\x07\xc1\x93\x26\x20\x07\x9f\x25\x59\xf2\xac\x60\x4a\xf7\x77\xf8\x0c\x4e\x85\xbf\x41\x74\x3d\x3a\xed\x33\xa5\x7f\x8b\xc6\x1d\x01\x4f\xc5\x2f\x79\xdc\x6e\x3f\x11\x08\xf8\x7d\xd0\xe5\xa0\x00\x49\x5a\x59\x39\x2d\x53\x68\xcd\x3a\x8d\x52\x1d\x09\x86\x54\x6a\xbd\x4e\x2b\x0b\xc9\xa2\x05\x93\xa2\x2b\xa2\x64\x2b\x76\x6a\x82\x70\x14\x18\xa3\x80\x8a\x82\x8f\xa2\xe0\xad\x28\x38\x1a\x05\x87\xa2\x60\x4f\x14\x80\xed\xd8\x59\x8a\x6e\x93\xdc\xa5\xde\x68\x79\x94\xa4\xa2\xe6\x28\x39\x3f\xe3\x30\x3d\x80\x33\xc2\x36\x45\x77\x44\xf7\x46\xa1\xe4\x5a\x8d\x63\xd7\x69\x30\x3a\x24\x0a\x25\xc7\xea\x89\x28\x38\x18\x3d\x1a\x25\xb7\x63\xd7\x2a\xe8\x8e\x82\x49\xf8\x9b\xe2\x51\xd2\x8c\x7f\xef\xcb\x28\x89\x6e\x58\x11\xc5\x5e\xd7\x83\x51\xaa\x1b\x0f\x03\x7b\x5e\x5b\xa2\xd4\xd0\xf3\x51\x70\x3a\x0a\xf0\x57\x1f\x8d\xc2\x0d\xf8\x2e\xb0\x28\xe5\x84\x45\x32\x8a\x44\x5f\x7f\x09\x7f\x55\x67\x74\xbb\xe8\x54\xa5\xb9\x28\xe8\x8b\x57\x44\x0f\x44\xc9\x04\xf6\xea\xa2\x9f\x90\x43\xbf\xdb\x69\x31\xeb\x0c\x3a\x44\x34\x01\xd6\xa5\x20\x80\x8c\xe2\x6c\x06\x5d\x50\x23\x23\x29\x44\xe8\x11\x15\x85\xf3\x56\x72\x10\xb7\x33\xee\xd5\x58\x56\x7a\x66\x11\x02\x66\xe5\x42\x8b\x64\xf5\xc2\x8c\x66\x98\xab\x43\x66\x32\xe0\xd2\xfe\xb9\x74\xd7\x9c\x1c\x1d\x3f\xa3\xe2\x63\x6b\x11\x94\x81\x94\x8f\xb5\x2a\xe3\x8b\x4d\xc1\x91\xbd\x38\x63\xac\x70\xed\xd8\x59\xef\x0a\x27\x27\x00\xf6\xbd\x04\x28\x1f\x01\xda\xc6\x82\x3b\xc7\x82\xb6\x11\xa0\x3c\x71\x1a\x58\x26\x08\x27\xc1\xaf\x6a\x84\x37\xc5\xf2\xc4\xa2\x5a\xa1\x29\x6e\x26\xf5\xff\xb6\x36\x35\x59\x85\xcd\x60\x15\x7e\x57\xb8\x05\xac\xc6\xaf\xff\x9d\x3c\x6f\x8e\x8b\x74\x63\x47\xfc\x90\x86\xaf\x20\xe9\xd6\x1d\xaf\xb1\x04\x74\x10\x06\x8c\x6e\x05\x5d\x10\x09\x9b\x8c\x26\x44\xe6\x2e\x53\xb1\x89\x84\x26\x13\x53\xe2\x02\x4e\x17\xd0\xb8\x80\x8a\x72\x79\xbd\xb6\x0e\xde\xab\x57\xaa\x71\x8e\x1a\x93\x97\xf3\x2d\x2e\x97\x28\xe0\x2e\x03\x28\xcc\x40\x30\xa6\x5b\x9b\x20\xb6\x80\xb9\x83\xa4\x70\x56\xa5\x0b\xf1\xc9\xb2\x59\x37\xbc\xff\xe9\xd4\xa7\xdc\x7d\x1b\x97\x2e\xfa\xc5\x98\xab\x76\x3e\x18\x18\x6f\xf7\x8f\x7e\x60\xf5\x6b\xaf\xce\x99\x05\xce\x69\x57\x4e\xb9\xfb\xee\x98\xab\x33\x30\xf1\xaa\x87\xaf\x79\xfa\x3e\x87\x65\xed\x17\xdc\xf2\x35\x63\x57\x06\x88\x34\xbf\xa0\xe6\x8a\x98\x96\xab\xe3\x6d\x46\x92\xb4\x8b\xd1\x59\xa5\xdb\x65\x33\xa9\x8c\x4e\x63\x91\x11\x1a\xf5\x45\xc8\x10\x10\xfb\x5c\x2b\x68\xa8\xd2\xa8\xda\x79\x56\xa3\xb3\x7b\x0d\x80\x32\x98\x0d\xa4\x41\x49\x13\x94\x9e\xf2\x52\x50\x41\x51\x24\x66\x84\x72\xcc\x09\x2b\x53\x93\x8b\x61\x9c\xfc\xb4\xdd\x2f\x1a\x0c\xe8\x8d\xd8\xc0\x8c\xac\xb4\xb7\xd5\x37\x88\x27\x96\xbc\x6b\xb2\x70\x62\xb2\x50\x84\x38\xe2\x9b\x93\x41\xf9\x64\xf0\x66\x22\x81\xf6\xeb\x3f\xc2\x8a\x79\x69\x56\x84\x36\x4a\x0e\xb6\x2c\x16\xeb\x73\xe4\x88\x33\xa1\xf3\x2e\xce\x8b\xbe\xc9\x18\x86\xff\x90\x7c\xb0\x44\x32\x85\x95\xe0\x32\x84\x01\xe4\x22\x72\x4b\x9e\x0f\xb6\x18\xdd\xbf\x53\x5c\x87\x99\xf1\x52\x99\x96\xd1\xe9\xf4\x80\xa1\x19\x05\x6e\xb3\xae\x51\xb0\x0a\x97\xdb\xc2\x00\xa7\xcd\x89\xf8\xbc\x4e\x05\x6d\x3a\xec\xea\x50\xc9\xdb\x91\x29\xcb\xe6\x67\x9d\xd5\xa6\x23\xd3\x99\x09\x1a\x73\xe1\xf6\x53\x8e\x3b\x5a\x52\xb3\x61\x9e\xb9\x0a\xfa\xc1\xfd\xdd\x60\x7e\x0f\x52\x2f\x7a\x66\x08\xba\x29\x7f\x5f\x94\x99\xf6\x09\xb0\xde\xdd\xd8\x68\xff\x3a\x79\xc1\xde\xd8\xe8\x04\xd3\x46\x0b\xff\xca\x4e\x3e\x45\x97\xd4\x28\x11\x6b\xac\x33\x5e\xac\x87\x76\xad\x42\x61\xf7\xb8\x75\x9e\x32\x0f\xa9\x80\x76\x96\x25\xba\x78\xd6\x82\x4b\x96\x91\x14\x63\xb1\xcb\x1c\x89\x2e\x7d\x07\x16\x5f\xf9\xce\xd8\x81\xc9\x67\x68\x73\x6a\x2a\xd3\xf9\x02\x29\x85\x03\x92\x62\xf5\x5a\x19\x88\x59\x2d\x7b\xe6\x8d\x8b\x5e\x07\x1b\x12\x09\xc1\x97\x78\xbb\xa0\x60\x7c\xef\x44\x5f\x83\x41\x1e\xf7\xe9\x16\x82\x0f\x01\x65\x6f\xca\x64\x9e\x9d\x15\x92\x42\xf2\x93\x25\x7a\xd5\xe9\xa9\x5e\x89\xee\x52\x39\x73\x89\x78\x05\xce\xed\x03\x84\x06\xa7\xce\x19\x35\x72\x68\x77\x88\xa9\x73\x1a\x15\x6d\x33\x90\x62\xde\x9c\x56\xa5\xb3\x1a\xa5\x51\xb3\x0c\x41\xb3\x12\xd4\x5e\x9e\xdf\x1b\xaf\x6f\xbe\xba\xf4\xbf\x4d\x9d\x4b\x2e\x14\x07\xfc\xdd\xe5\xa9\x73\x79\xe7\x65\x66\xbc\x42\x4b\x92\x32\x9d\xd3\x69\x91\x59\x5c\x6e\x2d\xe8\xe0\xd5\x5a\x97\x16\xe9\x07\x5a\x2d\xa5\x94\x5c\x61\xed\xbc\x51\xa9\x73\x5a\x48\x19\x25\x6b\xe7\xed\x14\x9b\xef\xdd\xcd\xcd\x60\x28\x1a\x98\xa3\x38\x78\xd2\x82\xf8\x1e\xf9\x89\x70\x02\xaf\x77\x02\x9c\x41\x5c\x0d\x5f\xf1\x2b\xf0\x84\xf0\x44\xce\x81\x78\x19\x34\xd8\x32\xab\x4f\x0c\x8a\x4f\x97\x9e\x8b\x09\xd7\xa9\x98\xb0\xae\x25\x63\xcd\xd2\xb0\x95\x68\x36\x4a\x9d\x49\x2b\x71\x7c\x43\xde\xc8\x8b\xf2\x52\x2a\x2f\x1b\x6a\xfe\x10\xa9\x72\x71\x70\x70\x64\x56\x71\xc8\x0e\x0a\x8d\x09\x63\x2d\x7a\xc5\x31\x4d\xcc\xc8\xe9\x69\xe2\xeb\x56\x89\xdf\x22\x7d\xe6\x4d\x3c\x46\xa0\x89\x3f\x24\x53\x03\xb5\x11\x9a\x59\x33\x0b\x4e\xb1\x1f\xb1\xe4\x1d\x2c\x58\xc1\x82\x38\x0b\x9c\x2c\xa0\x58\xb0\xe4\x23\xf6\x4b\x96\x3c\xcd\x82\xa3\x2c\x78\x80\x05\x9b\x58\x50\xc4\xd6\xb1\x8b\x58\x78\x09\xbf\x3e\xce\x9e\x66\xe1\x36\x16\xf4\xb0\x2b\x58\x12\x7d\x26\xc8\x0e\x61\x49\xbd\xf8\xc1\xa3\xec\x29\x96\xdc\xcd\x02\x72\x3d\x0b\xca\xd9\x6e\x96\xe4\x70\x83\x03\x50\x77\x9e\x05\x67\x58\x70\x98\x05\xbb\x58\xd0\xcd\x6e\x60\xc9\x46\x16\x78\xf1\xab\xd7\xd9\x33\x2c\xdc\xc0\x82\x5e\x76\x3d\x4b\x1e\x66\x4f\xb0\xef\xb3\x90\xc5\xfa\xb0\xdf\xe6\x1c\xcd\xb1\x8d\xe8\x6d\x88\xbe\x40\x0e\x19\x64\xe7\x76\xf0\x06\x92\x34\xe9\xb0\xce\x9f\x2d\x34\xb1\x35\xa6\x3c\xc7\xa2\xc0\x2c\x9a\x39\xc0\x7f\x92\xc8\x0a\xcc\x7c\x9c\x24\x89\xbc\x45\x5f\x71\x8e\xaa\x26\xe5\x76\xc0\x37\x91\xb6\xd6\xee\xdc\x99\xdc\xb3\xd7\xd1\xde\x5b\x34\x16\xf6\x0b\xef\xef\x43\x1a\x9b\x7d\xc4\x08\x3b\x79\xd6\xb4\x0f\x78\x25\x3a\x30\x0b\xad\xf0\x1c\xec\x47\x6b\x3c\x43\xd4\x7f\x47\x09\xe3\xe8\x26\x7a\x2b\xd2\xf0\xcb\x89\x61\x60\x41\x5c\x08\xd3\xd5\x7a\xaf\xb7\x48\x15\xaa\xb0\x5a\x43\x34\xac\xab\x6f\xab\x07\xd5\xf5\x20\x58\x0f\x2c\xf5\x80\xac\x07\xa7\xea\xbf\xac\x27\x8f\xd5\x83\xbd\xf5\x07\xeb\xc9\x7b\xeb\xc1\xa6\x7a\x30\xa5\x7e\x65\x3d\x39\xa4\x1e\x84\xeb\x01\x55\x0f\x16\xfc\xa3\x1e\xec\xab\x3f\x54\xff\x56\x3d\x44\x7f\x9b\x8b\xff\x36\xa9\x1e\xb4\xd6\x83\xca\x7a\x00\x88\x7a\x6f\x3d\xf9\x65\x3d\x38\x51\x0f\x8e\xd6\x83\x03\xf5\x60\x52\xfd\xa6\x7a\xb2\xbc\x1e\x38\xc5\xcf\xf6\xa0\x57\x07\xeb\x8f\xd6\x9f\xaa\xa7\xcb\xeb\x3b\xeb\x49\xaa\x3e\x58\x4f\xd6\xe2\xf7\xbe\xac\x87\xce\xfa\xb1\xf5\xe4\xe9\x7a\xb0\xa2\x7e\x47\xfd\x5e\x74\x13\xb5\x08\x7f\x1c\xd4\x89\x83\x3b\x5b\x0f\x0e\xa2\x8f\x91\xab\xeb\x1f\x10\x7f\xcf\x59\x5f\x57\x4f\xea\xea\x81\x82\xf4\x86\xfc\xa1\x76\xde\xef\xac\x2e\x8a\x0e\x75\x0c\xed\xe4\xdd\x24\x49\x00\x37\x45\x38\x2c\xa2\x6a\x4c\x54\xc5\x8a\x4b\xe5\xa5\x9d\xbc\xd9\xa0\x94\xeb\xf3\x98\x8b\x68\x93\x89\x72\x2c\xd7\x4b\x7c\x59\xcb\x81\x59\x39\x1a\x4e\x46\xf3\xb9\x12\x7c\x5a\xda\x22\x4f\x21\x10\x1b\x53\xdd\x13\x7d\x06\x59\x2a\xb1\x5b\x0c\xea\x58\xdc\x29\x19\x91\xed\xa7\x48\xeb\x71\x3a\x8f\xd8\xe5\x32\x3e\x6b\xee\xae\x7b\x9f\x7c\xac\xb9\x87\x9e\x0d\x96\xc2\xc0\x92\xc6\xbb\xee\x7b\x66\x6f\x70\x56\x80\x99\x2b\x04\x17\x7c\x16\x1f\x55\x58\x5f\x5d\xd8\xd2\x46\x7e\xb8\xa9\x0c\xe9\x09\xa3\x86\x57\x8c\xfc\xd7\x7f\xbe\x06\x64\xf8\x17\x67\xec\x23\x84\xc7\x9e\xb6\x47\xbe\xfe\xd7\x17\x42\xd2\x62\x18\xdd\xf4\x21\x3e\x8a\x30\xf2\xc2\x33\x21\xf2\xb0\xf9\xb5\xfd\xa0\x97\x4b\xc6\x5d\x47\x44\x3a\x91\x23\xe2\xf8\x4a\xa4\x93\xe9\x12\xbf\x10\x1e\xa4\x56\xa1\xb3\xc8\x12\xa3\xe2\x41\x25\x44\x9a\xb5\x4a\x85\xf4\x03\x8b\xd5\x6c\x50\x53\x0a\x06\xf3\x69\x46\x67\x94\xca\x43\x95\x1d\x52\x89\x68\x9e\xd7\xdf\x56\x96\x83\xc5\x73\x05\xff\x1f\x56\xf7\x6f\xb8\xf8\x62\x0e\x73\x5b\xae\x5f\x9e\x61\x1c\x48\xa3\x4f\x31\x10\x61\x9a\x38\x26\x0f\xe2\x61\x18\x63\xd3\x43\xb4\xc5\x43\x84\x8d\x31\x99\x34\x36\x0d\xe7\x65\xe1\x04\x9e\x65\x15\x3a\xa3\x46\xa7\x69\xe7\x75\xac\xc7\x2e\x1d\x3f\xa7\x42\x37\xb8\xc3\x3f\xaf\xab\x67\x6e\x09\x76\xd6\xcf\x9f\xae\x35\x06\x0f\xd5\xd4\xd4\xf0\x15\x69\xbe\xfb\xcc\x9d\x9b\xef\xc0\xcf\xc9\xa1\x1d\x23\xac\x7a\x70\x73\x96\xc1\x01\xdf\xb4\x5b\x36\x81\x48\x8a\x01\x8b\xfc\x96\xb9\x03\xcb\x0e\x30\x32\x7e\x4e\xa1\x47\x22\x8f\x65\x81\x1e\xba\x5d\xd7\xba\xc1\x14\xf7\x5c\x37\xd9\xe2\x06\xd5\x6e\x10\x74\x03\xb4\xf7\x6f\x89\xd0\x6f\xf7\xba\xc1\x26\x37\x58\x29\xba\xe3\xab\xdd\x53\xdc\x24\xfa\xa3\x5e\xf4\xec\xcf\xff\x5a\x0c\x0d\xbc\x95\x0a\x0d\xb4\xba\x57\xba\xef\x75\xef\x73\x53\x76\x37\xf8\xc4\xfd\xb5\x9b\x3c\xe5\x06\xc7\xdc\x60\xa7\xfb\x39\x37\x79\x93\x1b\x80\x8c\x47\x9f\x92\x02\x07\xe8\xa3\xd8\xd3\x7f\xdc\x0d\x25\x57\x7e\x8f\x9b\x1a\x2a\x45\x1a\x56\x88\x8e\x7c\xb8\x08\xc7\x18\x82\xa9\x5b\x8f\xe3\x90\x42\x8f\x1b\x87\x19\x28\x55\x26\x54\xb0\x41\xf4\xf5\x77\xba\xfb\xdc\x50\x0e\xf5\xac\x89\xc5\xba\x9f\x89\xe8\xe0\x4d\xac\xd3\xa2\x53\x4a\xb2\xc3\xa6\xa6\x74\x44\x9e\xdf\x78\x80\xaf\x3f\x2f\x5a\xb6\x2c\x8d\x3a\xb6\xec\x32\x70\xb1\x65\x79\x87\x48\x3c\x3f\x97\xf9\x8c\x73\x74\xa9\x43\xc0\x21\x92\x90\x78\x4d\x7c\xb7\x5f\x24\xa8\x79\x29\xf2\xc9\x92\x51\x56\x89\x12\xe9\x9b\x39\x88\x71\x7f\x41\x47\xfc\x73\x02\x42\x8b\xc5\xcd\x6a\x35\x0c\xa3\x75\x43\xce\x73\x2d\x07\xa6\x70\x73\x39\xb2\x85\x03\xd5\x1c\x08\x72\xc0\xc2\x81\xb7\x38\xb0\x97\x03\xf7\x72\x60\x13\x07\x56\x8a\xae\xf8\x6a\x6e\x0a\x47\xa2\x3f\xea\x45\xaf\xfe\xfc\xaf\xc5\xb0\xc0\x5b\xa9\xb0\x40\x2b\xb7\x92\xbb\x97\xdb\xc7\x51\x76\x0e\x7c\xc2\x7d\xcd\x91\xa7\x38\x70\x8c\x03\x3b\xb9\xe7\x38\xf2\x26\x0e\xed\x51\xda\x9b\x4f\x49\x41\x03\xf4\x51\xec\xe5\x3f\xce\x41\xc9\x8d\xdf\xc3\xa1\x3d\x12\xa3\x0c\x2b\x44\x27\x3e\x5c\x84\xe3\x0b\xc1\xd4\xad\xc7\x71\x38\xa1\x87\xc3\x21\x06\x4a\x95\x09\x13\x6c\x10\xfd\xfc\x9d\x5c\x1f\x87\xf6\xc8\x65\x35\xa7\xc4\x90\xdd\xa0\xd0\xb1\x1a\x4a\xd3\xc1\xbb\x19\x8a\x69\xe7\x91\x10\x24\xca\x06\xf5\xf3\xff\xbf\xdc\x25\xc9\x92\x0f\x0d\x16\xda\xcb\x3c\x32\x07\xf5\xcb\xd7\x7f\xbf\x29\x91\xdd\x2f\xe9\xda\x84\xad\xf9\xcb\x8e\x7e\x66\xef\x44\xff\x83\x0e\x9d\x7f\x8c\x7b\x6c\x41\x1c\x60\x76\x7c\x18\xf0\x78\x34\x0e\x86\xd1\x98\x20\xe7\xd5\x79\x81\x16\x7a\x71\x3f\x38\xe0\x46\x5a\x2f\x70\x01\xa4\x9b\x01\xa0\x32\x99\xcd\xba\x0e\xde\x4c\x60\xc4\x72\x95\xa7\x9d\x57\x21\x0e\xa1\x62\x07\x7a\xfd\x45\x40\xf0\xa2\x3c\x85\x52\xf4\xfb\xa7\xab\x1a\x72\x52\x2a\xa5\xe2\x06\x24\x8c\xc9\xeb\x86\x3e\xf6\xca\xcc\xee\xe3\xfb\x84\xf6\x84\x11\x4b\x60\xf2\xdd\x31\x33\xa6\x1f\x2a\x84\x13\x84\x3f\x56\x5d\xbb\x60\xfe\xf2\x2a\xac\x08\x63\x41\xdc\x74\xf1\xfc\xa4\xab\x7f\x21\xec\x10\xe5\x2f\xe6\x0b\x0a\x34\x07\x99\xe8\x35\x5d\x14\x1f\x8e\x2c\x29\x96\xd0\x86\x7d\x3e\x2d\x0b\x23\x05\x27\x0a\x00\x51\x00\x4a\xa1\xd7\x29\xb7\xd8\x2c\x48\x85\x40\xfc\x55\xad\x70\x29\xd0\x6c\x14\x0a\x93\xdb\xa6\x0b\xfb\xc4\xb3\x67\xa2\xda\xf9\xa0\x89\x1d\x10\x01\xc0\xf3\xc8\x8b\xb9\xe6\x47\x01\x32\x4e\xec\xdc\x79\xe1\x6d\xa1\x73\xb5\xb9\x53\x2f\x5c\x3d\xfd\xea\x6e\xe1\x6f\x2b\x1e\x7b\x15\x4d\xef\x31\xc1\x84\xf6\xea\x3f\x64\x77\x46\xf5\x34\xa0\xa9\x4c\x22\xf7\x8a\xb3\x9c\xb7\xbc\x3a\xbd\x67\x79\x0a\x28\x29\xea\x9b\xe9\x79\xbe\x1a\xdf\x2e\xcd\x92\xd5\x3a\x5d\xbb\x5c\xa0\xdb\x05\x74\xae\x32\x17\xb9\xe2\x25\x17\xd8\xe0\x02\x65\xae\x0e\x17\xb9\xcd\xf5\x94\x8b\xec\x73\x01\xce\xd5\xe8\x22\xd7\xa3\xbb\xc8\xf4\x5d\x23\xb6\xbb\x0e\xb8\x4e\xb8\xde\x77\x9d\x77\xd1\xeb\x5d\x80\x70\xc5\x5d\xdd\x2e\x58\xee\xda\xe0\xda\xed\x3a\x2c\xbe\xcd\xf4\xb9\xa4\x7b\x28\x9d\x0b\x7f\x1e\xaa\xe0\x60\xab\x67\xd3\xe1\x55\x13\x57\x8f\xcd\xc6\x01\xd2\x6b\x26\x8a\xf9\x65\x59\xa2\x4f\x3d\xcb\x8f\x03\x5c\x71\x05\xc9\x4f\x5e\xb8\x6e\x09\x5a\xb5\x13\xb7\xa4\x56\x0d\xe0\x55\xbb\xc2\x5a\x61\xf9\x10\x4b\xd5\x90\x39\x89\xde\x78\x13\x01\xe4\xc0\xe1\xd0\x6a\xe5\x2c\x74\xb9\x09\x27\x32\x2e\x90\x6d\x87\x06\x8d\xe3\x00\xac\xd5\x60\xed\xe2\x0d\x16\xb5\x0c\xdc\x2e\x03\xe3\x64\x60\x98\x0c\x59\xe8\x32\x4e\x56\x26\x83\x0a\x1a\xc7\x05\x3a\x78\x95\x9e\x68\xcc\xd8\xdc\x68\xf4\x03\x7c\xe9\xb9\xe5\xff\x15\xe5\x26\x5f\x4e\x29\xb3\x25\xd7\xeb\x50\xe3\xfb\x33\x28\xa5\x12\x13\xae\x6a\x2c\x1c\xfd\xe8\x6d\xa7\x3e\xf8\xfe\x7c\xc7\x3d\xa5\x0b\x57\xac\xbb\x9e\x16\x4e\x92\xb6\xfb\xfb\x4b\x1e\x05\x96\xc0\xc5\x4f\xbf\x16\x70\xc5\xd9\xa3\x8f\x48\xfb\x7c\xe9\x1c\xfd\xba\x58\x0b\x17\xc6\x59\x5c\x68\x12\x26\x1f\xa1\x76\x32\x8c\xda\x84\xc8\xd9\x81\x98\x8e\xda\xe1\x72\xa0\xb9\x38\x1c\x06\x0b\x4e\x6c\x6f\xe7\x2d\x3a\xad\xc9\x60\x42\x96\x06\xab\x08\x76\xf0\x0a\x0b\xf4\x74\xe4\xc1\x4d\x0f\x12\x0d\x18\x18\x05\x00\xe9\xaa\x38\x11\x3f\x2d\xcf\x24\xc9\x85\xaa\x22\x17\x6b\xde\x3c\x79\xe6\xe4\xbb\x67\x4e\xfd\x51\x71\x28\x6d\x45\x91\x5f\x66\x7c\xc6\xe6\x3f\xbf\xf9\xdd\xe7\xc9\x2f\x3e\x39\x9d\x6f\x4d\xd5\x66\x3c\xc6\x24\xee\xc8\x4e\x79\x44\x3d\x08\xf3\x9c\x21\xa4\x4c\xa6\xf4\x20\x3d\xc4\xe0\x50\x42\x86\x66\x94\x06\xca\xcb\xc9\xdc\xa4\x1b\x09\x3f\xb7\xdb\xa4\x61\x08\x83\xc9\x80\xe9\x4b\x63\x6d\xe7\x35\x7a\xf4\x9f\x4e\x44\x00\xca\xe4\xca\x66\x54\x90\xcb\x5d\xc5\x22\xef\x34\x88\xbc\xd3\x24\xe1\x6e\xa5\xcf\xa4\x29\x8d\x50\x48\x3e\x74\xc7\xa3\xc2\x4f\x27\x1c\xbc\x6a\xfa\xab\x7f\x24\xbd\xe2\x71\x9c\x37\xe9\xaa\x29\x1d\x4b\xa6\x81\x72\x61\x65\xdc\x0c\x96\xb8\xd7\xb4\xdf\xbe\x3a\x75\x10\xa1\x3e\x31\x69\x46\x22\xed\x0f\xa5\xb7\x19\xc3\xd8\x1f\x6a\x60\x88\xe6\xeb\x09\x82\x3d\x48\x06\x0c\x61\xf2\x97\x97\x3e\x38\xe8\x0d\x98\xa8\xbc\xbc\x6d\xe9\xfe\x69\xa9\xfb\x71\xcd\xc3\x26\x09\x0f\x13\x92\x1e\x43\x18\x92\xca\x92\x88\x09\x0e\xa8\x9d\x21\x85\xd1\xf0\x38\xb2\x2b\x4a\x89\x4d\xf1\x71\x0a\x26\x12\x01\xc5\x0e\xbb\xd7\x64\xb2\x17\xc3\xb2\xf2\xee\xf2\xdd\xe5\xa4\xae\x9c\x2b\x2f\x2b\x87\x4a\x18\x29\x2e\x2c\x6e\xe7\x0b\x59\x8b\xbb\x93\xb7\x5b\x9c\x8a\x52\xa2\xb4\x83\x67\x08\x42\x47\xe9\x82\x13\x10\xe9\xeb\xf4\x3a\x52\x01\x75\x7a\xac\x51\x50\x84\x44\x17\x52\xde\x7f\xb6\x18\xcd\x96\x4d\x67\xcc\xeb\x16\x93\x2e\x4d\x33\xc5\x44\x9f\x52\x8c\x0d\xb0\xe6\x94\xa6\x2d\x55\xd8\xa6\x40\xe8\x06\x14\xd8\x90\x77\x75\x83\x8d\x17\x2e\x30\x63\xf6\x8d\x58\x71\xc3\xf1\x17\x24\xb4\xb9\xea\xc6\x9a\xba\xba\xb6\x29\x42\xc9\x8c\xbb\xa8\x67\x36\xda\x9a\x4e\xcf\x5b\x30\x7c\x5a\xf1\xb0\x6d\xb7\x24\x6b\x7f\x75\x12\x03\xcd\x6d\x5e\x45\x1e\x4e\x4c\xf4\x27\x27\x8b\x6a\xf5\xe7\x44\xca\x17\x05\x97\xe0\xb5\x86\x1f\x49\x39\xf2\xc4\x93\x29\x5f\x94\xde\x10\x06\x1d\x7a\x93\x82\xc8\xf3\x45\xa5\x6c\x60\xc2\x8d\x64\x41\x83\x85\xd5\xb0\x36\x1b\xa3\x21\x18\xc2\xc3\xb1\x36\x74\x76\x58\x17\x8b\xce\x0e\xcb\x42\x25\xf6\xab\xab\xb5\x60\xac\x16\x14\x6a\x87\x69\x49\xa8\xd3\x72\x5a\x52\x41\x6b\x95\x7a\xb7\x13\x3a\xbb\x78\x38\xb0\x1d\xca\xb2\xfc\xf8\x60\x4e\x13\xf2\x54\x67\x82\x34\xdc\x47\x1a\x6b\x26\x53\x13\x0b\xa7\x89\x95\xa5\xcb\xde\xb8\x63\xcb\xa3\xa3\x0b\xfd\x4d\xd5\x13\xfb\x54\xa0\x56\x78\x85\x5e\x77\xd3\x8f\xe6\xd4\xe2\x1a\xd3\x07\xfe\x72\x5d\x40\xf8\xe7\xa3\x76\x73\xff\x8e\x9e\x67\x76\xb9\xd1\xbc\x1b\x2e\x9d\x23\xcf\x8a\xb6\xfc\x14\x71\x1d\x4a\xd0\xe1\x71\x8a\xf5\xa6\xe3\xc4\xd7\x88\x97\x91\xcd\x22\x4d\xfd\x47\xa4\xc1\x85\x7f\x94\x70\x59\x95\x12\x2e\xeb\xa5\x83\x76\x53\x6e\x15\x8d\x88\xe5\x9a\x57\x2f\x8c\xe3\x0f\x97\xce\x31\x2a\x74\x16\x03\x44\x11\x31\x2f\x5e\xe7\x28\x2a\x22\x23\x9c\x99\xd2\x70\xa4\x06\x16\x97\x38\x0a\xdb\xb3\xbc\x26\x60\x09\x14\xb5\xf3\x01\x44\x41\x01\x36\xc5\x75\x60\x07\xe2\x3c\x0a\x43\x17\xaf\x51\x58\x06\x2f\xa7\xc9\xe1\x34\x79\xde\xca\x3c\x27\x58\x2c\xe3\x21\xcb\x08\x81\x48\x5a\x25\x18\x9a\xf8\x69\xae\x5b\xcc\x2e\xfa\xcb\xfc\xcb\x53\x32\xc1\x78\x75\xf7\x0b\xd7\x0d\xf0\x8e\xa5\x1d\x67\x69\x09\x31\x4d\xd2\x14\x44\xf9\xc9\xd4\xa0\xb9\xfa\x89\x42\x62\x59\x7c\xb8\x9e\xa2\x14\xb6\xc2\x42\x03\x08\xbb\xdd\x40\x01\x8b\x8a\x7d\x68\xb6\x3e\x36\x0a\xf5\x68\x5a\x36\xb5\xde\xa5\x47\xd3\xd6\xeb\x65\x6a\xab\x51\xa7\x54\x2b\x91\xba\xa3\xd6\x29\x00\x95\xdb\xde\xe3\xff\xa6\x92\x26\x74\xc5\x42\x9a\x8c\xe0\x0b\xa5\x27\x7d\x43\x42\x38\x93\xf1\x50\x21\xfd\xe0\x3f\xcb\xaf\x4d\xc9\x40\x16\xbc\x8b\xa6\x3c\x1b\x19\x47\x73\x84\x87\x72\x18\xec\x1f\x41\xa5\xed\xf2\x39\x03\x8c\x7a\x43\x4d\x12\x7d\x13\x0f\xc5\xe7\x05\x81\xc5\xc2\x39\x75\x4a\xa7\x32\x1c\xd1\x45\x40\x83\x3e\xe2\x8d\x94\x47\x3a\x23\xdd\x91\xdd\x91\x03\x91\xf7\x23\xe7\x23\x8a\xf2\x48\x3c\xb2\x3d\x72\x38\x72\x22\x42\x5f\x8a\x80\x4e\x31\x28\xb9\x3b\x42\xa1\xbb\x55\x10\xb8\x3d\xee\x0e\x3e\xe8\xf1\xc8\xfc\x7e\x6f\x3b\xef\x27\xb0\x95\x82\x17\xc6\xae\x66\x65\xa6\x09\x88\xb1\xc8\xf4\x32\x52\x86\xc4\xce\xcc\x58\x36\x16\x1b\xcb\x2f\x79\x4d\x05\x38\xae\xcd\x71\x91\x4a\x85\xaf\x98\xab\xd4\x54\xc7\xbc\x76\x30\x48\xed\x4d\x55\x8a\xf7\x90\x4f\x5d\x60\x46\xde\xb9\x0c\x50\xb3\x84\x92\x49\xa3\x9a\xc6\x8d\x13\x59\x89\xc8\x69\xa8\xb1\x0b\x9a\xa6\x05\x46\x0b\x67\x93\x2f\x8a\xeb\xe2\x9c\x34\x2b\xc3\x46\xe6\x61\x56\x23\x9e\x19\xd1\x4f\x2d\xf2\x92\xb3\xa9\x7a\x9b\xe6\x1c\xbf\xf6\x44\x17\x67\x52\xe4\xf1\x6d\xc9\x0f\xbe\x2d\xed\x07\x27\x9a\x89\xe7\x08\x42\xac\xb7\x31\xe0\x7a\x9b\xbd\x07\x3d\x3e\x8d\x33\xa7\xde\x46\xf4\x0d\xd1\x37\xe9\xc3\xd8\x37\x24\xfa\xcd\x11\xaf\x02\x9f\xc4\xdf\x29\x89\xaf\x5b\x37\xba\x24\xbe\x66\x0d\xba\xac\x5a\x85\x2e\x37\xdc\x80\x2e\x2b\x57\xa2\xcb\x8a\x15\xe8\x72\xed\xb5\xe8\xb2\x6c\x19\xba\xf4\xf5\xa1\x4b\x6f\x2f\xba\x2c\x5d\x8a\x2e\x4b\x96\xa0\xcb\xe2\xc5\xe8\xb2\x68\x11\xba\x2c\x5c\x88\x2e\x0b\x16\xa0\xcb\xfc\xf9\xe8\x32\x6f\x1e\xba\xcc\x9d\x8b\x2e\xd7\x5c\x83\x2e\x3d\x3d\xe8\x72\xf5\xd5\xe8\x32\x67\x0e\xba\xcc\x9e\x8d\x2e\xdd\xdd\xe8\x92\x48\xa0\xcb\xac\x59\xe8\x32\x73\x26\xba\x4c\x9a\x84\x2e\x13\x26\xa0\x4b\x67\x27\xba\xb4\xb7\xa3\xcb\xb8\x71\xe8\x32\x66\x0c\xba\x8c\x1e\x8d\x2e\xad\xad\xe8\xd2\xd2\x82\x2e\x4d\x4d\xe8\x12\x8f\xa3\x4b\x43\x03\xba\xd4\xd7\xa3\xcb\xb0\x61\xe8\x52\x5b\x3b\xba\x04\x37\x6d\xae\xa9\x91\x1e\xcb\xca\xa4\xc7\x82\x02\xe9\x31\x12\x91\x1e\xc3\x61\xe9\x31\x14\x92\x1e\x83\x41\xe9\x31\x10\x90\x1e\xfd\x7e\xe9\xd1\xe7\x93\x1e\xbd\x5e\xe9\x91\xe3\xa4\x47\x8f\x47\x7a\x74\xbb\xa5\x47\xa7\x53\x7a\xb4\xdb\xa5\x47\xab\x55\x7a\x64\x59\xe9\xd1\x64\x92\x1e\x0d\x06\xe9\x51\xa7\x93\x1e\x35\x1a\xf1\x31\xae\x15\x7b\x83\xa3\x0d\x24\x7d\x51\x32\xdd\x07\x2f\xbf\x59\xf3\xff\xea\x7f\xa2\x0d\x7c\x8f\xe8\x13\xb6\xe2\x5e\xaa\x48\xd5\xd4\x02\xb9\x5c\x6b\x80\x36\xbb\xdc\xa0\x43\x5a\x8c\x4a\xa7\x43\xf6\xbd\x8e\xd5\xa9\x81\x19\x22\xc6\x22\x79\xb6\xcd\x54\x8e\x57\x45\x2c\x93\x4a\x5b\x92\x79\x99\xdd\xa1\x1c\x3b\x3d\xd7\x20\x44\xb6\x7a\xca\x8b\x3d\xaf\x75\x79\xab\x30\x3f\xcf\x54\x47\x5a\x0b\xae\x73\xce\x8d\x75\xf4\x5c\x3a\xa7\xc0\x39\x26\xf5\x22\xca\x8f\x3b\x5a\x6b\x93\xeb\x2b\x6a\xdd\x72\xba\x61\x78\x31\xab\x62\x13\x7c\x85\xc1\xa0\x0a\x78\xbc\x9e\x04\x4f\x7a\xbd\x54\xb5\x8a\x0a\x3b\x29\x67\x82\x27\x28\x53\xa6\xcf\x45\x06\xb8\xcf\x10\x33\x5c\x3e\x52\x5a\x44\x9a\x0b\x92\x55\xb8\xba\xd4\x03\xd2\xe2\x90\x34\xe0\x74\x92\x34\xff\xb3\xa4\x33\x4b\xc4\xfc\xaf\x06\x12\x67\xd5\x98\x49\x8a\x79\xf2\xf4\x9f\xfe\xf4\xde\x87\x42\xff\x2f\xc1\x28\x50\x92\xf8\xd9\x53\xe4\x34\xdb\xd0\x1d\xed\xcf\xec\x39\xfb\xfe\xea\x25\x38\xfb\x64\xc9\xea\x0f\xce\x3e\xfc\xf3\xf6\x7b\x6a\x6c\xd3\xd6\xf7\xae\xee\x00\x25\x60\xd4\x2f\x85\xfd\xe6\xe1\xc3\x77\x83\xca\x93\x60\x02\x58\xe4\x18\x06\x84\x3f\x3c\x39\xa4\x41\x38\x23\xbc\x2e\xfc\x5d\x38\x1d\x00\xe7\x70\x42\x8a\x60\x0e\x80\x20\x70\x80\x72\xe0\x6f\x8c\x3d\x89\x0c\x0f\xa7\x4e\xb8\x47\x78\xf2\x84\xf0\xda\x6e\x49\x6f\xa0\x2f\x9d\xa3\x3e\x12\xfb\x24\xd4\xc7\x39\xa5\x5e\x46\x13\xac\xcb\xe9\xe4\x58\xb5\x9e\xf6\x21\x95\x94\x65\x65\x1c\xb4\x6a\xa0\x53\x67\xb6\x62\x69\x27\x05\x6e\xb3\xb0\xbc\x19\x88\x23\xa4\x69\xfa\x2c\x56\x53\x4d\x4e\x1f\xa0\x80\x0a\x04\xd2\xef\x93\x63\x63\x76\x60\x50\x85\xd6\xd5\xa4\x9a\x02\xd5\x9e\xfc\x7c\xa8\xf0\x77\xce\x86\xdf\xbc\x85\xdc\x78\x73\xdf\xd0\x4d\xdd\xc2\xaf\x77\xe4\xb4\x08\x22\x8d\xc9\x7f\x91\xc7\x3b\x97\xe0\x3f\x3c\x2a\xca\xed\x42\x82\xa0\x71\xcf\x5e\x1f\x7a\x76\x75\xbc\xca\xc3\x46\x22\x5a\xda\x8f\xc8\x8e\x56\x53\xc5\x45\x38\xfa\x9c\xe0\x3d\xe1\x6e\x24\xc7\xd4\x1a\x37\x23\xd3\xc8\xba\x79\x56\xe3\x41\xff\xa0\x01\x46\xae\x0c\x9a\x23\x6d\x67\xde\x7e\xa6\xd8\x73\x7e\xb2\x5e\x2a\x95\x3a\x0b\x2d\xea\xa5\xe8\x74\x0a\x06\x7d\x5a\x4c\xda\xd2\x5d\x75\x3f\xe7\x9c\x0e\xee\xe9\x27\x5f\xff\x14\xdc\x33\xc3\xc9\xed\xbc\x4a\x77\x30\x5d\x7b\x86\x33\xbc\xc0\x6a\x9c\xc7\x05\x5f\xd3\xc8\x7e\x0e\x2a\x1a\x71\x3e\x4d\xa3\xf0\xfa\xcf\x65\x1a\xe1\xf8\x91\x97\x52\x39\x7d\x24\x8e\x5f\x50\x07\x90\xfc\x0a\x22\xce\x7d\x4d\xbc\x2a\x4a\x78\xad\xa1\x90\x5e\xa6\x95\xd9\x08\xaa\xb4\xc4\x22\x99\x06\x84\x17\x29\xbf\x5e\x2f\xad\xc3\xed\x77\x38\xb9\x42\xa7\xe8\xe0\xad\x3a\x5d\x48\x46\xa3\xc3\x45\xe7\xe4\x6a\xa4\x67\x28\x59\x0c\x44\x5e\xbb\x96\x4c\x9e\x57\xd6\x3b\x21\xcd\x35\x23\xae\xd3\x73\x45\x14\x0d\x52\x01\x65\xea\x80\x64\x98\x2a\xcc\x0b\xc3\x45\x63\x41\x00\x8b\x6a\x10\x1d\x5b\x54\x38\xdf\xa8\xc3\x2a\x4a\xf2\x89\x25\x58\x43\x01\x7a\xc9\x52\x3d\xab\x92\xef\x03\x5e\x70\xab\x28\xaa\x6f\x14\xde\xdf\x27\x57\x09\xa7\xab\xae\x15\x3e\x40\xe2\x5a\xa2\xc1\x91\x97\xce\xc9\xee\x42\x67\xb3\x84\x58\x1f\x1f\xc5\xf9\xfd\x46\x5b\x21\x8e\x28\x17\xfa\x8c\x50\x49\x97\x95\xb2\xae\x04\x6f\x67\x29\xbf\x58\xeb\xcb\x95\x18\x00\x24\x0c\x7a\x03\xa9\x60\x70\xc5\xaf\x54\xef\xab\xa1\xd2\x35\x23\x51\x82\x08\xa5\xb0\xdd\x06\x44\x28\xd3\xda\x4a\x62\x66\x6c\x90\x1a\x92\xd4\x19\xf6\x12\x30\xdf\x0c\x8c\x19\xf3\x6a\xc5\xd9\xdc\x52\x72\xfa\x49\xe1\x15\x61\x27\xf3\x5e\x3a\x45\xec\x2f\x56\x30\x19\xd4\x7c\xf0\xcf\x6c\xd5\x78\x7e\x61\xb9\x19\xf0\xa0\x2a\xf9\xcf\xbc\x44\x31\xa4\x0b\xa6\xab\xc8\xfb\x72\x2a\xcc\x25\x3c\xcd\x4b\x9f\xd1\x43\x91\x4e\x5f\x48\xac\x8d\x8f\x44\xeb\x62\xb0\x46\xb0\xfe\xa6\x65\x22\x3e\x34\x7d\x1a\x91\xbc\x0b\x29\x6d\x66\xbd\x5f\xd4\xde\xb8\x1c\xed\x4d\x52\x51\xd4\xba\x14\x56\x33\x1b\x41\xab\x32\x10\x39\x2e\x7f\x55\xae\xb4\x26\x29\x50\xb9\x01\x8b\x32\xb8\xbe\xcf\x6a\x01\x65\x13\xec\x9a\x25\x69\x35\xae\xcf\xf8\x9f\x63\x83\xa8\xfe\x25\xbb\x4c\xe0\x35\x61\x77\x8e\x26\xf7\x87\x57\xfe\x96\x6b\x07\x88\x08\x39\x64\xa6\x9f\xbb\x1d\x71\xa7\x59\xf1\x32\x64\x3f\x43\x9b\xd5\x22\x53\x3b\x74\x9c\x5e\xcf\xb2\x6a\xce\x46\xf9\xbc\x94\x4e\xe7\x41\xda\xba\x89\xb3\x50\x36\x56\x2d\x83\x7a\x93\x1e\xb7\x77\x37\x19\xf3\x1d\xc8\x52\x44\x3d\x96\x05\xa0\x10\x5f\x63\x6c\x7f\x03\x0e\xb1\xe3\x83\x0e\x99\x0c\x48\x7e\x04\x5a\xd3\xfd\xdf\x81\xc5\x5a\x5d\x03\xe9\x03\xc9\x8f\x67\x3f\xd9\xd9\x29\xcc\xef\x9c\xf8\xc4\x74\xe1\xe9\x74\x2f\xf8\x8b\xe1\x0d\xe1\xe0\x86\x47\xda\x0c\xe0\xa3\xe6\x3b\x85\xcf\x44\x0f\xbe\xe9\xae\x46\x21\xe2\x4c\x77\x87\x27\xaf\x1e\xd1\x3d\x7b\x04\x38\x86\xe6\x83\x63\x23\xdf\xc0\xc3\x84\x13\x69\xe3\xd7\xc4\x87\x50\x3e\x08\x1d\x76\x9b\x47\xae\x71\x19\xfc\x46\xa3\xd5\xaa\xf1\x3b\xa8\x60\x80\x32\xb8\xd0\xf9\xf6\xb9\x3c\xe8\x1f\xeb\xb7\xe9\x1d\x56\x68\x64\x8d\x18\x3d\x93\xc5\x1e\xc7\xfc\xc4\x81\x0c\xf0\x57\xee\xac\xf2\xa7\x15\xd1\x02\x1c\x15\x0a\x54\xd5\x60\x40\x69\x99\xf8\x0c\xc4\xc4\x89\x35\x80\x9a\x08\xfc\x46\x58\xee\x9f\xa3\x75\x44\xbf\x88\x9a\xbd\x0b\x0a\x3e\x1e\x05\x56\xac\x06\xbd\x63\x92\x53\xda\x58\x75\xbd\x2b\xd1\xe8\xbc\xa0\xae\x2b\xb9\xd5\xd9\xd8\xe8\xbc\x95\xab\xf2\x5e\xc0\x4f\xe0\xdc\x8b\xf7\x3b\xc1\xec\xfa\xa1\x81\xa1\xd6\xaf\xd1\xbc\x46\x12\x84\xfc\x57\x68\x9f\xa2\x44\x19\xb1\x27\x7e\x15\x55\x0a\xcb\x60\x81\x25\xc4\x86\xc3\x91\xb2\x62\x44\x8c\x85\xfa\x32\x3d\x1b\xb4\xd9\xdc\x6e\x56\x5d\x56\x40\x57\x94\x97\x85\x29\x4a\x57\xa8\xeb\xe6\x4b\x0b\x83\xd6\x6e\xbe\xb8\x50\x1d\xac\x0f\x8e\x0b\x42\x15\x0c\x06\x9d\x5e\x49\x0a\x7b\xa1\x4d\x8f\xb6\xd3\xed\x74\x27\x78\x93\x12\x38\x8d\x39\x21\xb6\xd8\x00\xe2\x95\x12\x28\xd2\x21\xd2\x1c\x02\x96\x96\xc3\x90\xae\x70\x93\xd2\x29\x06\xdf\x6b\xd3\x00\x43\xc5\x94\xd9\x7b\xf9\xaf\x06\xec\xfd\x8b\xc9\x2f\xd3\x47\x9e\xac\xfe\xea\xbf\xd3\x01\xf8\x8f\xa0\xc9\x1e\x7a\x24\xd5\x36\xe6\xd3\x45\x0d\xb2\xd1\x42\x88\x2e\x8a\x88\x4a\xe2\xde\x78\x07\x55\x01\x2b\x61\xa1\x2d\x62\x2d\x28\x88\x56\xca\x4b\x0d\xc5\xc6\x4a\xa3\x35\xec\x70\x70\x9c\x55\x53\x5a\x59\xc8\x0c\x89\x55\x16\xe8\x29\x43\x31\xa2\x92\x8a\xe2\xb0\xbd\x9d\x2f\x2d\x0e\x87\xdd\x7e\x5c\xac\x84\x0c\x14\x5d\xa1\xc3\x6a\x84\x9c\x9b\x6b\xe7\x59\xe0\x4e\x91\xcc\x60\xeb\xf6\xc3\x8b\x36\xc8\x9a\x0d\x46\x48\x97\xad\x5a\x96\xb0\x98\xd0\x00\xc2\x5a\x2b\xfc\x3a\x63\xdf\x2d\x38\xf9\xdf\x88\x0c\x04\x85\x3f\xe7\x70\x88\x5b\xc0\xa7\xb9\x44\x27\xea\x03\xa5\x04\x21\xfb\x35\xd2\x07\x30\x26\xe5\xdc\x78\x35\xf0\x05\x9d\x01\x97\x95\x51\x85\x6c\x7a\x93\xc9\xa6\x72\x62\x58\x4a\xa7\x2d\x64\x0f\x75\xf3\xb4\xda\xaa\x4e\xf0\xe8\xaf\x56\x85\x1d\x02\x83\xd1\x67\x62\x54\x0a\x24\x38\x14\x69\x78\x08\xb1\x24\x1b\xe3\x3f\x65\x4a\xb3\x62\x79\x38\x8e\x99\xe2\x03\x58\x0a\x22\xa9\x39\x6b\x81\x0c\x29\xa4\x8d\x00\xcd\x16\x27\x94\x01\x0f\xc9\x91\x0a\xe0\x93\xfd\x5a\x58\x71\x63\xfd\xb6\x6b\x76\x27\x77\xee\x9e\xf7\xe3\xa1\xd7\x0b\xd7\xad\x58\xb9\xf8\xa3\x57\x85\x89\xd4\x1b\xc2\xec\x3b\x9e\xdf\xda\xb1\x7c\xc5\xc5\x3b\x41\x5b\x72\x21\x18\xb9\xe7\xff\xc8\x93\x7f\xc5\x44\x41\xfa\x55\xf7\x3f\x28\xbc\xd0\xe6\x3c\x7f\xa6\x5f\x41\xd2\x9d\x9d\xc9\x0b\xf4\xb8\x5d\x7b\xcf\x3b\xc9\xbf\x81\x47\xf1\x5c\xb5\xb8\x3e\x01\xe9\x69\x21\xa2\x80\x98\x1f\xaf\x01\xc1\x88\x87\x0b\x87\x1d\x32\x75\x81\xd3\xc8\xb2\x4e\xb5\x27\x48\x17\x46\x3d\xce\x02\x57\x41\x3b\xcf\x68\x1c\x9a\x76\x3e\xcc\x39\x1c\x4a\x97\x0e\x98\xd8\x20\x2b\x53\x2b\xd5\xed\xbc\x92\xfd\x1f\x4e\x36\x5b\x6a\x11\x29\x25\x33\xb3\x25\x75\x40\x9c\x2d\x99\x9d\x2d\x30\xf9\xe8\x97\x84\xe7\xa7\x04\xca\x1a\xcb\xe6\x0b\xd5\x0b\x2a\x1a\xca\xfc\x93\x85\xe7\xa6\x76\xd6\x4f\xdb\xd0\x2b\x9c\x86\xbb\x84\xbf\x2d\x59\x7b\x55\xbc\xf3\xaa\xe4\x9a\x0f\x85\xa1\x1f\xcf\x18\x1d\x91\x09\x7b\x6d\xcd\xcd\x36\x30\x53\x16\x6e\x9b\xf9\x71\x93\x7d\xef\x9a\x59\x85\x24\xb8\xa6\xa9\x49\x78\x80\x8c\xf2\x37\xed\xb5\x83\x2f\x40\x48\xe2\x29\xca\x23\x68\x6f\xcb\x89\x18\x71\x67\x7c\x3c\xe6\x1e\x7a\x53\x2c\x5c\x51\x18\x62\x54\x95\x88\xd1\x44\x55\x96\xb0\xc9\x2d\xaf\x1a\x12\x0d\xc7\x22\xb1\x6e\x3e\xe2\x55\xd3\x56\xcc\x4c\x2a\x10\x33\x01\xf9\x8c\xa4\xcc\x66\x52\x31\x22\x23\x51\x38\x8d\x40\xac\x77\x68\xbc\x02\x27\x89\xa5\xf5\xa5\xfc\x45\xc9\x69\xa9\x7e\x05\x1a\xa8\xae\x19\x70\x12\x72\x29\x42\x79\xe4\x72\x8a\xb8\xa6\x27\x39\x2a\xcd\x45\x28\xd9\xff\x90\x38\xfe\x38\x25\x79\x2e\x47\x7d\xd0\x5d\x4e\x29\x84\xc4\x4f\x64\x9f\x23\x5a\xa9\x24\xaa\x88\x1f\xc5\xc7\x82\x8a\x21\x45\xc5\xb1\xaa\x02\x23\x2b\x32\x11\xb6\x20\xa2\x8e\x15\x55\xc8\x6b\xaa\x8b\x0a\xaa\xa2\x55\xed\x7c\xd4\xcf\x68\xc2\x88\x60\x62\x88\x8d\xd8\x31\x78\x66\x96\x97\x54\x38\x90\x48\x15\x79\x89\xd2\xcd\x02\x31\x4e\x34\xe8\xca\x89\x6f\x65\x2b\x1b\x07\xe2\x12\x5d\x91\x9a\x6a\xd0\xd1\xb9\xd2\xba\x21\xda\x92\x7d\x3e\x08\x6d\x2d\x28\xb3\x0b\x4b\x33\x4e\xf8\x43\x79\x54\x76\xed\x15\xa8\xec\x9d\x89\x4e\xe1\xb9\x1c\x6e\xf2\xf3\xcb\x28\x0e\xad\xdb\xa5\x73\xc2\x48\x0a\x30\x5f\x10\xad\x44\x07\xb1\x35\x3e\x7e\x44\x49\x65\x43\x61\x73\xb3\x09\xd9\xff\x63\x6b\x65\x9d\x5d\x32\x8e\xeb\xec\xd0\x8d\x03\x0a\x38\xae\x7d\x4c\x7d\x7c\x44\x69\x49\x69\x09\x12\x61\xa5\x54\x6d\x7d\xfd\x90\x04\x5f\x4f\xe9\xac\xb3\x79\x9d\xce\x45\xb8\x94\xdd\xbc\xcb\x69\x76\x52\x81\x6e\x9e\x32\x12\x91\x1c\xac\xe1\x74\xbf\xf5\x1c\x55\x3c\xe3\xc8\x77\xd8\xf4\x7f\xad\x7c\x0d\x11\x61\xe5\x00\x70\x16\xd1\xb6\xcc\x46\x23\x6a\x24\xf8\xc1\x80\xa4\x7c\xe5\xe0\x2d\x4b\x19\x9f\x57\xa8\xb6\x37\x20\x15\xdf\xc4\x22\x13\xba\x2a\x66\xad\x21\x67\xce\x69\x6e\x76\x37\x4d\x1a\xdf\x50\xc2\x8f\x5c\xbd\xa9\x6a\x55\x64\x06\x3b\xbf\x21\x3a\xb1\x65\xd5\xba\x2d\xfb\xc6\xde\xd6\xd1\xd8\xd2\xec\xeb\xbe\x76\x90\x82\xfc\xbe\xdf\x74\xbd\xf7\xe6\xbb\xe3\xbe\xfd\xd6\xac\x54\x26\xda\xc7\x4c\x0b\x96\x74\x85\x5c\xc7\xeb\xc7\xba\xc3\x2d\x5b\x6f\x9c\x74\x73\x9b\x4a\xfd\xe0\xad\x83\x16\xea\x0b\xef\xf6\x1e\x98\x23\x63\x7c\xc2\x69\x10\xf2\xed\xd9\x23\xae\xf7\xdf\x84\x56\xa8\xa1\xf7\x12\x23\x88\x31\xc4\xb6\x78\x97\x93\x51\x5a\xa1\xa7\xc2\x63\x6d\x66\x0c\xad\xb2\xb1\xe3\x22\x0d\x0d\x63\xcb\xaa\xbb\xf8\xb2\xb2\x3a\x5f\x5d\x61\x27\x5f\xe7\x8c\x39\x89\x11\xbe\xe0\x88\x2e\xde\x21\x43\x13\xef\xe0\x1b\x65\x1d\x32\x52\x26\x33\x07\x59\x9f\x65\x8c\x6e\x14\xda\x99\x51\xa3\xda\x46\x8e\x34\x98\xcd\xea\x0e\xde\xac\x4f\xfb\x2b\x11\x9f\x13\xcf\xb6\x88\xda\x2d\xa5\xcc\x4a\x7b\x90\xdd\x8b\xcb\x56\x3c\x74\xe5\xe4\x59\x36\x95\x63\x5b\x06\x52\x3b\x82\xcc\xf8\xca\xd4\x7e\x88\xb5\xd5\x38\xe6\x02\xd2\x4b\x0d\x66\xd6\x8f\x19\x98\x61\x3b\xeb\x86\xa7\x37\x73\xe3\x83\xf1\xc9\x6d\xd5\x91\xa6\x51\x53\x86\x77\x4c\x18\x6d\xee\xac\x0c\x37\x8f\x9d\x35\x62\xc5\x2d\x3f\x59\x0e\x9e\x95\xd6\x78\xf1\xcc\xb6\xfc\xf4\x5b\x46\xbb\x72\xca\x2d\xbb\x95\xe4\xf4\xf1\x1d\x5d\x05\xe5\x05\x85\x87\x6b\xea\x82\x85\xc1\xad\x1b\xd6\x3e\x42\x57\x64\x56\x16\x60\x26\xc0\x0c\x17\xf1\x84\xa6\xc6\x4b\x83\xa4\x97\x61\xec\x2a\xb3\xc1\xa0\x22\x61\x41\x84\x33\x00\xa4\x2d\x23\xae\x68\x57\xdb\x13\x48\x2c\xaa\x15\x21\x17\x34\xc1\x7c\x69\x98\x02\xdf\xcf\x4a\x87\xd8\x65\x81\x33\xdc\x54\x2f\x7d\x72\xfd\x88\x1d\x42\x9c\x28\xe9\x21\xad\xa9\x63\x5c\x29\xb6\xde\x63\x86\x2f\x10\xbe\x17\x3e\x3a\x94\x5c\x72\x68\xf9\x6d\x57\x0f\xbf\x75\x01\x58\x77\x5d\xa0\x20\x1a\xbc\x93\x6c\xbe\xb3\x67\x41\x29\xd8\x4e\x7d\xe9\x14\x7e\xff\xe1\x31\x61\x91\xab\xad\xcd\x05\xee\xa9\xdb\xfa\x28\xb8\xd6\xd9\x26\xc4\x37\x2f\x2e\x21\xc9\x35\xa2\xb6\xb4\x29\xb6\xe2\x7e\xb0\x4b\xb4\x87\x08\x61\x1c\xbd\x51\xec\xb1\x3c\x2a\x1e\xb2\x33\x8c\x45\xe6\x24\x0d\x38\x05\x11\x72\x1e\x2d\x70\x81\x76\xde\xa5\xb3\xea\x75\x76\x8b\xdc\x82\x4c\x60\xb9\x05\xf7\xa8\xc9\xf8\x6e\x1a\x07\x38\x6c\xd2\xd3\xd0\x33\x01\x43\x00\x4d\x81\x4c\x4f\x01\xff\xb5\xda\x0e\x7c\xf4\xc6\x55\x6f\x7f\x7f\x74\xfe\xad\x53\xeb\x22\x13\x57\x82\xa5\x73\x3c\x85\x95\x05\x47\x4f\x82\x55\x70\xa1\x4d\xf8\x91\xf0\xd5\x47\x18\x87\x27\xd8\x71\xe7\x4b\xe0\x51\x5b\x53\xf2\xab\x3d\x77\x0c\x85\x7d\x17\xb7\x93\xe0\x0e\xf0\x21\x8e\xcf\xa7\x70\x01\x08\x25\xb2\x5e\x0a\x88\xd6\xb8\xdf\x6d\x34\x12\x61\x9b\x8d\x26\xe8\x68\x61\x50\xa5\xe7\x54\xe8\x9f\x9c\x94\xe3\xbe\x40\x26\xd2\x91\xdb\x0e\x08\x17\xf0\xdb\xb0\x62\x6f\x18\x98\xf2\x9c\xee\x0a\x84\xae\x21\xa9\xdf\x81\x4c\x34\x47\x4d\x0c\x10\x51\x98\x25\x94\xf9\x1a\x32\x9c\x6e\x10\xf4\xa0\xd0\x2f\x3c\x21\xdc\x0f\x57\xaf\x5c\xdf\x3c\x2d\xdc\x50\x4b\x1e\x78\xe1\xc0\x53\x2a\x5e\xf8\xf7\x13\x4f\xea\xf8\x31\xcb\x6f\x6a\x9b\x14\xaa\x6f\x94\xf5\x67\x5a\x06\xe1\x72\xa5\x59\xc7\xc6\x86\x83\x06\xe1\x98\xf0\xf5\x39\xa0\xa9\x25\xdf\x3e\x7d\xbe\x7a\x0c\x32\xc5\x81\xf7\x5b\x3c\xaf\x54\x3e\x28\xa1\x22\x1c\x48\xdf\x9f\x12\x2f\x89\xd8\xed\x84\xc7\x64\x62\x08\xa6\xa8\xf0\x70\x11\x48\x14\x01\xa2\x08\x68\x60\x48\x6d\xf0\xaa\xd1\x3f\xa8\x50\x38\x3b\x78\x85\x1e\x5a\x3a\xa4\xd0\xd2\xc0\x29\xe6\x36\x0e\xca\x26\x53\xe5\xa0\x17\x8a\x18\xd3\x32\x89\xf3\x31\x50\x9a\x27\x06\x9b\xaf\x29\x05\xf0\x99\x77\xcf\xbc\x73\x4a\x6c\x1f\xf4\xa0\xa7\x24\x1c\x60\x6d\x8e\x86\xb1\xa3\x9b\xe9\xf0\xc2\x96\x46\x3a\xe4\xf4\x14\xa3\xb7\xac\x0e\xb2\x19\x9c\x4e\x7e\xf1\xd5\xf7\xdf\x7d\xfe\x9d\xb0\xcf\x1b\xf2\xea\xde\xda\xb3\x15\x8d\xf4\x5f\x1b\xfb\x8b\xb9\x10\xa7\xf9\xd5\x03\x62\xbf\xb5\x4b\x1f\x30\x7d\x68\xbf\x2c\xb8\xa3\xb1\x42\xae\x07\x84\x4e\x49\x28\xf5\xd0\x6a\x33\x53\xdd\x3c\x30\x53\x4a\x9d\x5a\x97\xe0\x91\x79\x2d\x82\xa8\x0d\x06\x43\x91\xaa\x85\xc1\x4c\x19\x04\xd2\x00\x2f\x22\x63\x66\xfa\x3a\xfd\x9e\xca\x96\xee\x02\xa1\x6d\x73\xf2\xcc\x52\x72\xd4\x1d\xe0\x46\xe0\x6b\x7c\xe0\xc6\xd9\x1d\x94\xef\x01\xcb\xac\xee\x0b\xaf\x51\xdf\x8a\xf0\x20\x77\x91\x47\xee\xbb\x9d\xc3\xb4\x7e\xe9\x1c\xf5\x1b\xb4\xce\xe2\x78\x64\x72\x1d\x61\xd1\x2a\x2c\x0a\x1d\x1a\x8f\x09\x76\x22\x79\xa2\x57\x68\x55\x5a\xd1\xb7\x2a\xb7\xfc\xc0\x78\xf2\x87\xe3\x94\x86\xc3\x52\x37\x96\x59\x0a\xc2\x8d\x2e\xe1\xb9\x1b\x85\xeb\x9b\xc0\x07\x7d\x9f\xf7\x97\xad\xbf\x66\x62\x07\xf9\xea\x5a\x7d\x59\x3c\x29\xc3\x0d\xbb\x9b\x1c\xc9\x4f\xc1\x63\xd7\xf5\x72\x67\xc4\x98\x80\xb8\x3e\x18\x83\x8b\x0a\x61\x1f\x3f\x79\x92\x4c\xa6\xf0\xeb\xfc\x12\x7e\xdd\xab\x07\xed\x7e\xb5\x25\x0f\xbf\x4e\x9c\x03\x8e\x23\x50\x61\xe9\x33\xe0\x53\x42\x8a\xd6\xf9\xa5\x68\xdd\x0e\xf4\x19\x95\x25\xaf\xf7\xdb\x34\xa1\x55\xe1\x41\xfb\xa0\xc2\x5d\x80\x91\xd5\x3f\x84\x0b\xba\x6d\x8c\x81\x50\xab\x0d\x45\x36\x6b\xc8\x13\x94\x57\x85\x3c\xd6\xea\x68\x39\x32\x1b\xa3\xce\x20\x67\x73\x3b\x90\x5e\xe7\x73\xe8\xcc\x30\xc1\x9b\x4d\x5a\x45\x82\xd7\x52\x44\x7e\x33\xbf\x9c\x90\xd5\x80\x6e\x2b\x39\x95\x7e\x20\x7b\xb6\x14\xe9\xd5\xca\xe2\x65\xa4\xe2\xbd\x0d\x24\xd8\x77\xcb\x8e\xbb\x6f\xb9\xe5\xee\x1d\xb7\x08\x07\xc9\xb9\xa0\x1c\x54\x09\xaf\x0a\xa7\xd0\xbf\x63\xcc\x3e\xe1\x36\xbc\x96\x7f\x79\x65\x29\x88\xb5\x08\x5b\xe3\xdd\xd7\x8d\xed\x9a\x54\x5f\xe4\x2e\x09\x0f\x8b\x95\x92\xbb\x85\xa3\xc2\x39\x60\x06\xf5\xa0\x16\x68\x85\x2f\x85\x57\xd0\x91\x7b\x44\x78\x1a\x1d\xcf\x5d\xe8\xa0\xfe\x1f\xd8\x2b\x2e\xf9\xb7\xa4\x12\x3d\x9a\x2f\xf6\x3e\x72\x77\x9b\xe9\x8b\x75\xd6\x60\xcb\xd5\x52\xbd\x59\x8b\xd0\x2a\x9b\x25\xc6\x77\xa3\x48\xab\x4b\xc4\xab\xe4\x1a\x06\x14\x7a\xca\x83\x41\xb3\x07\xc8\x08\xad\x42\xa3\xa8\xd6\xca\x88\x9a\x48\x49\x07\x1f\xd1\xfb\x62\x1d\xbc\xcf\x62\xb4\x77\xf2\xac\xd1\xa9\x91\x03\x06\x32\x48\x85\x83\xba\xbc\x5c\xf2\x9c\x34\x89\x81\x0b\x43\xff\xd0\x0a\xe4\x1c\xce\xdc\x24\x09\x3a\xfe\x43\xf3\x17\x76\x64\x8e\x6a\xa6\xd3\x97\xfb\xca\x93\x26\xa7\xa5\x4e\xec\xe7\x39\x39\x14\xa1\x4b\xbb\x99\x6b\xe9\x7b\x09\x2b\xb2\x09\x0a\xe2\x66\x0f\x53\x6a\x64\x8c\x43\xaa\x14\xce\x6e\x5e\x41\xc1\x40\x2e\x8c\x7d\x1e\xd6\x74\x24\x88\x37\x36\x24\x75\x44\xa1\xc4\xb6\x6a\xb8\x25\x45\x38\xc2\x90\x06\x33\x92\x59\xd2\x1f\x1a\x60\x95\x1e\xf7\x36\x82\xe3\x22\x71\x2d\xe2\x9b\x7b\xc0\x14\x30\x43\x1b\x8f\x44\x1a\xb4\x88\x97\x4e\x17\xf6\x08\xfb\x35\xc3\xa3\x81\x3a\xc3\xb3\xbf\x08\x4c\xda\x32\x4f\x5f\x1f\x0a\xd5\xe9\x36\xfe\x78\x94\xe1\xe7\xcf\xeb\x6a\xbb\x4b\x02\x76\x30\x13\x0c\x03\x75\x60\x92\x3d\x50\x54\x14\xb0\x0b\x8f\x09\xbf\x45\x4c\xf4\x11\x7b\xa0\x84\xba\x18\x72\x3b\x85\xcf\x84\xf3\xbf\x7f\x71\x65\xb3\x12\x99\x6d\x9c\x66\xc6\x3d\xaf\x6d\x00\x7a\x60\xf0\x78\x42\x92\xce\xee\xbb\xb4\x9b\xba\x83\xd2\x22\xaa\x2f\xc6\xbd\xc0\xdd\x4c\x51\x28\xe4\xf0\x16\x18\x8d\x5e\x06\x96\x94\x2a\x1c\x9d\x98\x87\x7a\x3b\x73\x79\x68\xbe\x44\xc6\xf3\x94\x5a\xd6\x4b\xd3\x41\x4a\x8a\x3e\x35\x4d\xa9\xd5\xb2\x78\xf4\xa5\xae\x62\x0c\xd9\x5e\x10\xd7\xbe\xf7\x97\xf7\xfe\xa2\x8d\x17\xa0\xf9\xfd\xed\x53\xa1\x46\x33\xbc\xd0\x57\x6b\x98\x30\xb6\x85\x37\xd4\xfa\x9a\x23\xdd\xed\xed\xdd\xc1\xee\xb2\xa0\xe3\x9b\xb7\x4f\x7e\xed\x0c\x96\x14\x05\xac\xff\x39\x2d\xb4\x96\x05\xca\xe0\x0a\x9f\xd3\xf9\xcc\xcf\x1e\x7c\xc9\xeb\xf0\xd6\x71\x2f\x3d\xf4\x93\x17\x3c\xc3\x25\x1a\x5d\x73\xe9\x9c\x62\xae\xec\x3a\xa2\x9a\x68\x23\xa6\x13\x0b\xe2\x43\xc7\x74\x85\x86\xd8\x14\x43\xe2\x25\x5d\x53\xf4\xe3\x6b\x14\x8a\x99\x33\xa0\xc7\xc3\x8c\x87\x6d\x0d\x7c\xed\x88\x11\x9a\xd6\xda\x5a\x4d\x01\xab\x41\x22\xb0\xc4\x60\x28\xd7\x50\x7e\x27\x83\x23\x2e\x4c\x4e\xc4\x25\x1d\x68\x89\x89\x0d\xdd\xca\x8c\xb5\x31\xd1\x70\xad\xbd\x0c\xed\x1a\xb7\xb8\x4f\xb7\x27\xc8\x8b\xbc\x54\xd7\xc4\xc4\x6a\xe5\x6c\xd4\x45\x6a\x15\xa5\x27\x80\x11\x0b\x12\x6b\x8c\x4d\xb7\x31\xa0\xd3\x7d\xd7\x4a\x49\x89\xbc\x99\x87\x36\x9d\x9a\x3c\xf9\xd4\x26\xe1\x49\xe1\x47\x07\xc0\x88\x37\xf6\xec\x9c\xe6\x2c\xdd\x30\xea\xf1\x87\x4e\xbf\x3b\xe5\x95\xe1\xc3\xea\x5f\xb9\xea\x9d\x3f\xff\x64\xff\xa8\x0d\xa5\xce\x69\x3b\xf7\x9c\x04\x4d\x07\x84\xdb\x2f\xbc\x41\xbd\x5b\xbb\xf4\xda\x35\xad\x66\xdf\xd8\xb5\x4b\xe6\x94\x0f\x8b\xab\x41\xd5\x0d\xcb\x6b\x87\x38\x38\x47\x4d\x49\x49\xdc\xdc\x34\x7e\x7c\x13\x98\x0d\x9a\xde\x02\xc3\x1f\x6f\x16\x5e\x3c\x30\x64\xa8\x70\x46\x38\x21\x7c\x2a\xbc\xbb\xaa\x3b\xb1\x1a\x84\x81\x1d\x20\xc5\x72\xe8\x90\x03\xa0\xa9\xf9\x31\xe1\x37\x6f\x0b\x2f\x0a\xbb\x98\xc5\xc0\x5d\x5c\x5d\x0a\xb6\x44\x4a\x23\xc3\x1b\xc7\x74\x2d\xb0\xc4\xb4\x51\x8f\xd1\x6a\x75\xd9\xfc\x45\x75\xe2\xda\x4f\xb8\x74\x8e\xf1\xd2\x02\x51\x8a\xb4\xe9\x89\xc4\xb2\x78\x83\xb7\xb8\xa9\xcd\x24\x93\x95\x8d\xd4\xb4\xb7\x85\x87\x16\x2b\x26\x4f\x1a\xa9\x1f\x51\xdd\x55\x51\x5b\xab\x6c\xa8\xc0\x09\x8e\x15\x15\x4a\xbf\x41\x69\x40\x06\x9f\x56\xab\x24\xed\x76\x2a\xaa\xd4\xbb\x2d\x94\xa5\x8b\x27\x28\x4b\x7e\xcc\xcb\x90\xb3\x0d\x45\x99\x7d\x18\x24\xfa\x25\x75\xed\x49\x35\xed\x49\x75\xa5\x8a\xa5\xda\x4f\x66\x72\xc5\x70\x9b\xae\xff\xbe\xf6\xd4\xea\x37\xfa\xfa\xde\x38\xfe\xde\x9f\x9e\x5b\xb4\xb1\xad\x2c\x3c\xe4\xe6\xe5\x0b\x9b\x97\x19\x9b\x4c\xbd\x2d\x0b\x97\xdf\x3c\x24\x5c\xd6\xb6\x71\xd1\x2f\x4f\xbd\x77\xf1\xe5\xff\xb2\xdc\xdb\xb7\x03\xfa\xdc\xc7\x00\x06\x85\xb3\xbb\x62\xc2\xfa\x43\x2f\x26\x1a\x47\xcc\x7c\xf1\x10\xd8\x18\xdb\x05\xd8\xa0\x90\xfc\xf8\x9c\x70\x81\xfa\xea\xbf\x2c\xaf\x84\xdb\xa4\x78\x88\x79\x1c\xc9\x32\x03\x96\x65\x8a\x97\x68\x00\x96\x88\x31\xf4\x51\x74\x18\x10\x6d\x63\xe4\xb5\x79\x31\x74\x31\xae\x46\x0f\x47\xf7\x1b\xa5\xfb\xc9\x15\xa9\x98\x7b\xa1\x01\xdd\x5f\x5c\xe2\xd4\xe7\xe3\xe0\x22\xdd\xd6\x2a\xd6\xc0\xd7\xc7\x3d\x8c\x59\xaf\x72\xa8\xcc\xd0\xe9\x32\x28\x95\x5a\xab\x15\x89\x36\xc2\x4a\xa9\xf4\x5a\x3d\x92\x6e\xce\x2b\x63\x2a\xa7\x04\x3e\x26\x7c\x0e\x64\x3a\x47\xa6\xe0\x6e\xa9\x5f\xbb\x36\x3d\xf5\xe9\x5b\x6f\xfd\x75\x8d\xd8\x33\xf2\x9c\xf0\x27\xb0\x00\xcc\xfe\xc7\xf7\x0c\x7c\xf5\xe5\x69\x22\x0d\xfe\x53\xf8\x50\x27\x17\xe6\x8b\x1d\x23\x47\x06\xc1\x74\xe0\x44\x8c\xef\x1a\x44\xa4\x38\xbf\x48\x18\x07\x47\x22\xf9\xe3\xc2\xe3\x33\x6a\xe4\x2c\xab\x71\x41\x8f\xdb\xa4\x56\xeb\x11\xe9\x74\xf0\x84\x5d\x8f\x1b\x07\xb6\xf3\xfa\xff\x32\x3e\xd1\x4a\xc2\x0c\x29\x3b\x42\x43\x2a\x7f\x88\x4c\xe2\x48\x41\x5d\x77\xd5\xe2\x1b\x47\xcc\x13\x8c\x73\x85\x77\xc4\xd4\x21\x72\xcb\xa3\x76\xf3\xac\xfd\xd7\xff\xfa\x61\x8d\x4c\x18\x26\xba\x56\xbb\x27\x80\x0d\x52\xee\x10\x5e\x3b\xd3\xa5\x73\xe4\xc3\xf4\x56\x64\x64\x9b\x9e\x25\xd5\xac\x59\x6d\x42\xfa\x53\x63\xa3\x28\x04\xd0\x4f\x9a\x62\xd0\x2a\x8b\xc8\xd0\x7f\x30\x60\x8a\xd4\x58\x6b\x22\x35\x60\xde\x53\x1b\x5e\x38\x16\x79\x35\x7e\x2c\x72\x6c\xef\x4d\xcf\xbc\x12\x39\x16\x7f\x25\x02\x7f\x0c\x2e\x24\xff\xda\xb2\xbc\xe5\x85\xe6\xe5\x2d\x82\x8f\x64\xd0\xd3\xe7\x5b\x96\x8b\xfb\x23\x3c\x44\xb9\x41\x37\xbd\x93\x60\x09\xf9\xd3\x48\xa9\x2f\xc3\xed\xdf\xad\x19\x49\xe8\x8b\x64\xf0\xaa\x6f\x20\x47\x96\x57\x8e\x1c\x53\x03\xae\x22\x47\x95\x97\x8f\x1c\x35\x94\x7a\xcc\x14\x6b\x6d\x2b\xaf\x6a\x62\x2b\x5a\x47\x56\x0e\x19\x29\x7d\xdf\xfd\x54\x02\xcc\xa5\xd7\xa0\x31\xdb\xe3\x6a\xa8\xd3\x73\x7a\x52\x4f\x28\x15\x0a\x82\x28\xab\x2c\x8b\xe9\x8f\xce\xac\x14\x83\xaa\xa2\x85\x8f\xcc\xd0\x9a\xca\x14\x5b\x07\x72\x6d\x7c\xa8\xb3\x7c\xfc\x92\x5b\x66\xce\x9f\xd5\x57\x3f\xb1\x70\xc9\x62\x8a\x4a\x34\xd7\x9a\x8a\x1a\xb6\x80\xb6\x88\x77\xcb\x5d\xe2\xf7\x5f\x4a\x50\xd5\xc4\xc3\xf4\x77\x84\x01\x8d\x17\xc9\xfd\xb2\x3f\xa0\xf1\x0e\x49\xf7\x30\xc2\xe2\x80\x2d\x05\x0f\x77\x8d\x6c\x6c\x0b\x14\x05\xda\xc6\xfd\xe4\x51\x7a\xe2\x78\x7e\x58\x99\x2f\xe2\xf1\xda\x8b\x6a\xcc\x23\xdd\xdb\x06\x7c\x87\x0e\x8a\xdf\x61\x1a\x78\x4c\x1f\x7e\xf4\x27\xe3\xc4\xef\x68\x1c\xd9\x45\x4f\x5c\xb6\xcd\x3d\xd2\x5c\x5d\x6c\xf7\x7a\x22\xbe\xb2\x61\x53\x09\x90\xbc\x9f\x9a\x43\x0e\xa1\x37\x61\xbc\xcc\xb8\x4a\xad\xd1\x10\x38\xe5\x94\x94\xa1\x6f\x43\x53\x14\x49\x02\xfa\x65\x01\x6c\x41\x23\x9d\x9e\xf5\x87\x4a\xc1\x67\xfd\xea\x23\x4c\xd7\xc3\x1b\x13\x47\x7f\xf7\xda\xfc\x3f\x0a\x17\xef\xdd\x42\x07\x5f\x5e\x7c\x7d\x63\x65\x7d\xe5\xea\x59\xd5\x11\x42\x7e\xb1\x48\x38\x00\xdf\xa4\x9f\x26\x34\x84\x13\x69\x43\x35\xc4\x48\xc4\xf1\x66\x13\xbd\x44\x63\xdc\xe3\x6a\x6d\x0d\x8c\x1f\x3a\x67\x4e\xe3\x82\xc2\x49\x93\x2a\xa6\x8f\x5f\x30\x7d\xfa\x82\xf1\x50\xa6\x65\x09\x99\x4c\x45\xa1\x6d\x43\x3f\x59\x96\x0e\x61\xc7\x62\x19\xf9\x29\x8e\x84\xcd\x74\xfd\x40\x0f\x61\x98\xf7\x0a\xfc\xc0\xdf\x4c\xff\xe3\x3b\xf3\x5f\xc5\x46\x77\x5e\x3f\x69\xd2\xf5\x9d\xad\x55\x99\x67\xe4\xa4\x41\xde\x1c\x97\x79\xf6\xfd\xd0\xaa\x56\xe9\xe9\xe8\x58\xe6\xd9\xc1\xcc\xb3\x37\x47\xc7\x26\x5d\x7f\xfd\xa4\xf2\xb1\x4c\x75\xfa\xd9\xf7\x27\xd2\xcf\xa8\x48\xfa\x99\x20\x4f\x3f\x4b\x9e\x1c\x57\x86\x9f\xc5\x46\x53\x91\xf4\x33\x41\x9e\x7e\x46\xa0\xb5\x2e\x17\x7a\xe0\x09\x86\x22\x10\x0f\x21\x2a\x89\x66\xe2\x2a\x62\x11\xb1\x9e\xb8\x1b\x63\x9f\xde\x7c\x5b\x47\x4b\x49\x38\x16\x6b\xa8\x2e\xf0\x4f\x9d\xbb\xa2\xb7\x4d\x7b\x5b\xcb\x5d\xb5\xd5\xfe\xb5\x57\xcf\xe5\x7a\x67\xce\xec\xe5\xe6\x5e\xbd\xd6\x5f\x5d\x7b\x57\xcb\x6d\xda\x36\x2d\x34\xa3\x2d\x2f\x4b\xf5\xf4\xcd\xfe\x2f\xad\x72\x66\xf5\x18\x2b\xa6\xb0\xea\x2c\x81\x21\xaa\xad\x61\x91\x8a\xe9\x21\xa5\x34\x5d\x80\x0e\x41\x20\x9c\xf5\xb4\x60\xe1\x1f\x4b\x39\x61\xc4\xfe\x16\x22\x42\x42\x24\xd5\x39\x40\xba\x07\xe0\x6b\x8d\x35\xa5\xa8\x4a\xf7\x85\xf0\xb7\x5b\x65\x29\xfd\x35\xf5\xdd\x62\x6a\x67\x4d\xaa\xd5\x8f\xf4\xfb\x7d\x3d\x6b\x6e\xf0\x17\xfa\x6b\x8a\x62\x23\xde\xcf\x3e\x85\x53\xa7\x2e\x0a\x35\x06\xab\xac\x16\xd6\xe7\x0f\x17\x8f\xff\x7e\x61\xfe\x6b\xea\xa7\x0d\xf3\xea\x4a\x82\x16\x8b\xb9\xc4\xe6\x29\x6d\xbe\x58\x97\xf7\x12\xce\xbc\xae\xa5\x6d\x69\x71\x6b\xc4\xcc\x99\x4a\xbc\x05\x4d\x17\xff\x9a\x7d\x5d\xe6\x29\x68\x3a\x98\xff\x65\xf4\xbd\xf9\xaf\x93\x2f\x0f\x3a\x26\xe1\x4c\xfe\xb7\x42\x7f\xfe\xeb\xf9\x57\x1c\x12\x57\xd2\x2c\xe2\xb0\x08\xe3\x98\x4a\xe6\x04\xb2\x31\x8a\x88\x75\xf1\xd1\xac\x42\xeb\xf7\x15\x44\x2d\x8c\xdb\x1d\xf5\x69\xa9\xe2\x12\xa2\xa4\xbb\x84\x8c\x97\x74\x96\xec\x2e\x39\x50\x42\x15\x88\x5d\xb8\x15\xd0\xe7\x0b\x79\x3c\x06\x5c\x26\x82\xf3\x2f\x58\x99\xda\x6e\x80\x6e\x05\x23\x76\x3a\xa6\xd4\x12\x90\xdb\x60\xc5\xce\x59\xbf\x1c\x98\x99\xad\xe1\x4f\x19\xae\x21\xdc\xda\xf4\x8a\x05\xde\x00\xef\xb9\xa8\x56\xd4\xc4\xb4\x80\xa9\x7c\x63\x6d\xa9\xb0\x0c\xc3\x6c\xa6\xa3\x72\x22\xf4\x66\xf2\xe7\xcf\xbe\x4a\x9f\x64\x66\x8f\x1d\x3b\x9b\x39\x49\xbf\xda\x26\x40\x70\x30\x03\xb9\x39\x08\x20\x27\x3d\x66\xfb\x8f\xe7\xce\x9e\x3d\xf7\xc7\xdb\x71\xde\xa4\xb0\x82\xda\x46\xdf\x24\xae\xc5\xa2\xf8\x50\xdc\xda\xc2\x65\x96\xcb\x35\x1a\x5f\xd4\x45\x95\x14\xe7\x4d\x5e\xef\xb4\x98\xb4\x7a\x64\x8d\x9b\x19\x95\x4d\xaf\x73\xc9\x69\x0d\xae\x0f\x81\x00\x07\xdf\x8e\xfd\xf0\xdc\x2f\xf3\x48\x05\x4c\x81\x2b\x17\xb6\xe7\x4f\x1c\xbe\xb6\x3c\x76\xf1\xb2\x42\xf7\xdb\x92\x2f\xe6\xcd\x5b\x58\x01\xb6\xfc\x60\xed\x3b\xe5\xc9\x99\x77\x30\x85\xbb\x84\x71\xa3\xdb\xe3\x51\x33\xa1\x57\xdb\xed\x0a\x1a\x77\xb1\xf6\xb8\xf5\xb6\x6e\x5e\x27\x93\xcb\xba\x79\xb5\x5c\x8f\xfe\x41\x25\xb4\x5f\x39\xaf\xa6\x68\x60\x92\x49\x2a\x9d\xa6\x2a\x26\x65\x54\xe7\x25\xd0\x50\x67\xc5\x04\x9a\xfd\xfb\x41\xdd\x99\x33\x83\xa5\xcc\xbc\xb7\xea\x96\x5b\x56\x09\x2f\x66\xd2\x64\x52\x18\x51\x0a\x24\xf7\x71\x1d\xcf\xd8\x78\x44\x41\x3b\x9d\x24\x6b\xd5\xb2\x5a\xce\xeb\x14\xab\x5b\x14\x0e\x5c\x5d\x06\x88\x0e\x9e\x06\x0a\xf4\x0f\x9a\x58\x48\x88\x8d\x74\xb3\x83\xcc\x2b\x4c\x96\x88\xcf\x94\x1d\x61\x6e\x7d\x46\xba\x6c\x23\x70\x2d\xf0\x6d\xdd\x9a\x2d\xd0\x20\xbb\xc4\x9a\x0d\xaa\x7d\xfe\xdb\x6f\xcf\x4f\xbe\x91\x2e\xd1\x80\x5f\x5e\xfc\x0d\x2e\xdb\x20\x32\x63\x7d\x4c\xc4\x17\xf3\x11\x2d\xf1\xa0\x1b\x00\xc6\xa6\x61\x34\xfe\x80\x9b\xe8\xe6\xdd\x6e\x4a\xa1\x70\x21\x2b\x56\x96\xe0\x15\x10\x30\x14\x93\xc0\x81\x83\xc6\xfc\xb4\xe2\x01\x05\x87\xd9\xb0\x09\xc6\x92\xc2\xea\x0d\x13\x30\x59\x53\x20\x90\xb1\xca\x9a\x08\xa9\x3a\x93\x6c\xdd\xd5\x4f\x76\x00\x37\x70\x1c\x5b\xd4\xbc\x75\xc2\x12\xd9\x9a\xd0\xf5\xf7\x76\x4c\x9c\x57\xb7\x96\xd4\x0a\x53\xd2\xd0\xac\x2f\xfd\x41\xf8\x6a\xf6\xc2\xd6\x2d\x66\x30\x79\x4d\xeb\xcd\xbb\xd7\x27\x9f\x08\xae\xc3\x63\x4e\xd5\x59\x8b\x52\x76\x74\x3c\x1c\xb4\x6a\x34\x4a\x23\x47\x18\x89\xc2\x22\xbb\xaf\x93\xb7\xeb\x59\x53\x3b\xcf\xea\xd2\x7a\x9f\x3c\xdc\xc9\xcb\x2d\xb9\x4d\xcd\xf3\x6d\xf1\x94\x4b\x0a\xf1\x77\x71\xac\xfe\x4c\xb5\x2a\x9e\x83\x55\xf4\xf5\x59\x45\x3b\x41\x4c\x93\xab\x89\x50\xde\x29\xfc\xdc\xa6\x35\x63\x67\x2c\x5c\xcc\xfc\x28\xf9\xef\xb9\xf3\xc0\x5a\x72\xd1\xce\xa3\x2f\x09\xcd\x2b\x82\x4f\xce\x6c\xef\x9a\x5a\x1d\xdc\x04\xfe\x7e\xf7\x07\x8d\xd7\xb4\xac\x76\x38\x9b\x26\xbc\x26\x76\xaf\xe9\xb7\x35\x95\xb7\x7d\x22\x5c\x7d\xdd\xd5\x07\xc0\xca\x70\xb2\x8e\x0d\x6e\xc6\x3a\x22\x32\xb3\xe1\xf7\xcc\x56\xa4\x33\xd4\xc4\x5d\xa4\x4c\x45\xc8\x08\xad\x4e\xad\xc4\xc8\x93\x4a\xd0\xcd\x2b\x21\xae\x3c\xcc\x5f\x75\xdc\xa1\xfb\x0a\x25\xeb\x48\xa5\xfc\x5e\x30\xbe\x9e\x1c\xbb\xbf\x9f\xfc\xd3\xfa\xe5\xd4\x9f\x2e\x6c\xc7\xf0\xa8\x18\x9f\x0b\x74\xa6\xb1\x21\xc8\xaf\xa8\xd7\xa5\xdf\x23\x68\x85\x9a\x56\x6b\x75\x72\x4d\x07\xaf\x94\x8b\x60\x3a\x3a\x0c\x26\xd9\xce\x93\x99\x44\x2d\xf1\xe7\x72\x1d\x17\xa1\x9c\x5f\x33\xf9\xc0\xa1\x6d\xc9\xbf\x2f\x58\x00\xbe\x6b\x5c\x6b\x16\x8e\x4c\x4b\x9f\x64\x10\x10\xa4\x7e\xc5\x29\x9c\x72\xc2\x8a\xbb\xf3\x30\x4a\xa5\x49\xae\x03\x84\x8e\xb0\xd9\x69\x11\xc2\x4c\x61\x30\x1a\xba\x79\xc6\x08\x8c\x40\x63\x81\x4a\x9d\x06\xb1\x6a\x4d\xfe\xa1\x8d\xe5\xe4\x5f\xa6\x1a\x5e\x55\x4a\x1c\x09\x62\x8a\xf2\xb1\xbe\x6c\x62\xb2\xd8\xe7\xfb\x67\xd3\x1a\x7a\xde\x3c\x0e\x66\x08\x7b\xc5\x85\xe8\xef\xa7\x96\xc1\x9f\x01\xab\x59\xa8\x5a\x95\x7c\x13\x2f\x07\x59\xb4\x0a\x9c\x74\xb6\xe5\x61\x0c\xe1\xf1\x45\x69\x85\x42\x4b\x58\xb4\x16\x9b\x5d\xae\x37\x60\x44\x09\x03\xd2\x0f\xd5\xac\x48\x4e\xb8\x8f\x90\x2e\x0d\x3a\x91\x7f\x04\xb0\xcb\x78\x60\x6f\x26\xd1\xe4\xc1\x04\xcf\x06\xf2\x87\x67\x80\x7e\x0c\x43\xf4\xd2\x4b\x22\x10\x51\x1a\x8a\x48\x38\x3d\x5f\xf8\x7f\x68\x7b\x13\xf8\xa8\xaa\xb3\x71\xf8\x9e\xbb\xcd\x3e\x77\xe6\xde\xb9\x73\x67\xbf\x33\x99\xcc\x4c\x26\x93\x7d\xb2\x87\x90\x4b\xd8\x02\x81\x24\x04\x10\x26\x84\x24\x80\x22\xb2\x2a\xa0\x28\x54\xc1\x5a\x17\x5c\xea\xfa\x6a\x5d\x6a\xd1\x52\x45\x8b\x85\x2a\x22\xad\x56\x6d\x6b\x5b\xad\x5a\xa9\xcb\x6b\xad\x1b\xad\xd5\xb6\xaf\xd6\xaa\xb5\xda\x2a\xb9\xf9\xce\x39\xf7\xce\x96\x05\xfb\xbe\xbf\xef\x8f\x42\x66\x92\xcc\x3d\xe7\x39\xcf\xfe\x9c\x67\xb9\x1b\xbb\x10\x43\xeb\x50\xf6\xb8\xfa\x1c\x3a\x3b\x75\x36\xb3\x07\xcf\xe0\x1b\x51\xea\x23\x4e\xa7\xdb\x92\x48\xf8\x69\x37\x5d\x9e\x8a\xda\x47\x32\x91\x68\xd4\xe5\x0d\x4b\x5e\x69\x38\x13\xf0\x52\x4e\xb7\xcb\x8d\xb2\x42\x81\x05\x1a\x45\x2e\x9e\x30\xe6\x67\xc2\xf2\x2d\x38\xf1\x3f\x97\x75\x37\xf9\x50\xd8\x6c\xe7\x5d\x2d\x20\x51\x50\x7f\x2a\xe4\xc7\xb2\xa0\xe8\x04\xf9\xee\x86\xef\xcf\xa7\x87\xc4\xa1\xcb\x7f\x70\xf0\xe6\x7d\x67\x5e\x89\xcf\x98\x3e\x87\xc7\x87\xfe\xe4\xa5\x4f\xff\x73\xab\x7a\x8f\x3a\xbb\xdc\x07\x1c\xd7\x0e\x00\x3b\xf0\x82\x14\x60\xa3\xa3\x17\x65\xc9\x50\xbd\xf7\x75\x97\xba\xb9\xed\x4a\xf5\xbd\x31\xf5\x09\xf5\x01\xbd\x16\x7b\x0e\xdd\x87\x73\x08\x86\x94\x74\xc8\x6e\x17\x1c\xa4\x29\x1a\xf5\x90\x02\x1d\x4f\x84\x2d\xbd\x99\x70\xd8\xe9\x76\x07\x7b\x33\x5e\x77\x61\x79\x15\x45\x38\xa1\xf5\xdc\x5b\x00\x66\x3e\x7b\x6c\xaa\xc9\xf0\x25\x68\x02\x0d\x04\xd2\xe9\x88\x14\x82\x58\x38\x79\xc6\x45\x93\x9d\x17\xdc\x38\xb7\xb2\xf3\xb4\xf7\xd5\x37\xc2\x69\xbd\x5d\x14\x6e\x1d\x95\x59\xf4\xf9\xbf\xd5\x8f\xd5\x39\x32\xf0\xdd\x97\x04\x1b\xc1\xb9\x06\xf5\xa5\x2c\xc1\xab\xcf\x41\x24\xde\xea\xf9\xe8\xcd\xbf\x7c\xa9\xf5\x64\x52\xbb\x71\x1f\xfb\x24\xd8\xa4\x8c\x25\x69\x8a\x60\xca\xd8\x44\xa2\x24\x1e\x61\x59\x9f\x5d\xb0\xb9\x5c\x5e\x91\xe7\x9c\x4e\xd1\x16\x27\x98\x54\xf9\x92\x14\x50\x52\x48\x8e\x87\x53\x80\x4e\x81\x25\xa9\xed\xa9\x9b\x52\x47\x52\x4f\xa5\xfe\x94\x62\xbb\xd1\xb7\x4a\x53\xe4\x59\x8f\xa6\x5e\x4f\x91\xd7\xa5\xc0\xe9\xf0\xa7\x64\x5f\x0a\xcc\x4a\x81\x9a\x14\x70\xe1\x8b\x8d\x4f\x53\xe0\x44\x0a\xbc\x9c\x02\x4f\xa6\xc0\x37\x52\xfb\x53\xe4\xd9\xe8\x27\xf5\xa9\x25\xa9\xd3\x53\xf4\x7e\xfc\x20\x6a\x17\x5a\x61\x49\x8a\xb4\xa4\x52\x29\xb2\xe5\x4b\xfc\xeb\x57\xa5\xbe\x9f\x7a\x36\x45\x6d\x49\x01\x32\x9c\x52\x52\xe4\xa1\xd4\x0b\xa9\xb7\x53\x63\x29\x9a\x48\x39\x52\x35\xa9\xbe\xd4\xd9\x29\x26\xff\xf2\xba\xd4\xbe\xd4\x93\xa9\x13\x29\x93\x91\x4a\x94\x84\xfd\x2e\xaf\xdb\x8b\x62\xdc\x8c\x5d\xb0\xaf\xc9\x94\x09\x3e\xf8\x9f\xb9\x34\xe8\xa6\x68\x07\x9f\xe4\x0d\xda\x40\x0a\x3e\x37\x19\x5f\x4b\xef\x48\xa7\x27\xcc\x85\x4c\xff\x07\xcd\xec\x87\x8a\x3b\x0f\x64\xf3\x80\x70\x46\x59\x36\x25\x48\x37\xd0\xa8\xe8\x54\xad\xeb\x1b\x0a\x5b\xdc\x1b\xde\x8d\x5e\x78\xf1\x96\xa9\x7a\xd7\x17\xf5\xb8\x9f\x87\x9a\xf4\x9e\xb2\x77\xfd\xbc\xe2\x4e\xf7\x84\x4e\x03\x77\xe0\xbe\x5c\x49\x70\xa6\x72\x92\x4c\x46\xe2\x74\x02\xdf\x79\xda\x78\x8f\xe0\x12\x78\x4b\x22\x1e\x4b\x1a\x31\xf2\xbb\x35\x6c\x91\x1f\xa5\xc0\x9f\x52\xe0\xf5\x14\x40\x28\x23\xf7\xa4\xc0\xf6\x14\xd8\x80\xf0\x8f\x7e\x4a\xad\xdf\xae\xd3\x04\xbd\x02\x7d\x6f\x56\x8a\x7c\x3f\x05\x8e\xa4\x5e\xc6\x54\xf1\x8d\x14\x18\x41\x94\x03\x30\x1e\x5d\xe8\x41\x9f\xa6\xc8\xe3\xe8\x11\x88\x20\x8e\xa4\xe8\x91\xec\x83\x66\xa5\xe8\xe6\x8f\xf0\x32\x37\xa5\xd0\x42\x54\x6e\x21\x4c\x1f\x0e\x48\x0c\x90\xa4\xc6\xd0\xa3\xfa\x20\xce\x11\xc6\x19\x39\x05\xce\x4e\x1d\x4e\x91\xf8\x1e\x0d\x2e\x60\xa4\xe2\x11\xd9\x27\x78\x44\x4f\x4f\x26\xec\xa5\x6d\xbc\xad\x3f\x93\xe0\xbd\xf0\x3f\x53\x34\x20\x72\x14\x27\x96\x39\xd1\xe5\x6d\x4f\x06\xa0\x36\x21\xbf\xfc\x8f\x08\xe0\x94\xcd\xb6\x0a\x6b\xb3\x8b\xca\xb2\x0b\x52\x39\xa0\x4e\x88\x52\xff\x51\x4f\x2d\xe6\xd8\xb6\xdd\x95\xaf\x7f\x45\x57\x2d\x4f\x9f\x7a\x07\x38\xfd\x3f\xee\xab\xf5\x81\x5d\xc3\xfb\x90\xda\x8f\x67\x18\x34\x12\x83\x4a\x5d\x2d\x69\xac\x0f\x26\xc5\xaa\xaa\x64\x45\xbd\x87\x2c\xb5\x1b\x9b\x9a\x2b\xbc\x1e\x2f\x1a\x3e\x52\x5b\x9a\xf0\x7a\x6b\x13\xb5\xc2\x70\xc6\x52\x2b\x24\xe4\xe1\x4c\x82\x66\x90\x38\xab\xeb\x28\x1c\x1e\xc5\xb7\xf0\x2d\x13\x2b\x2a\xb1\x34\xd3\x9b\x69\xc5\x13\xf1\xaf\x9c\x6a\xe0\x74\xd1\x06\x9c\x20\x00\x0e\x6d\x5e\xd1\x33\xad\xb1\x75\xe9\x8c\xdb\x67\x9f\x62\xc4\xc1\x18\xf1\xa7\xe6\xd9\x3b\xd5\xfe\xc6\xa5\xc1\x8e\xd6\x39\x67\x19\x79\xfe\x54\xf3\x0e\xd4\xd7\xee\xfb\xb5\xd5\x7f\xc6\xec\xb5\xe7\xa0\x3e\x37\x6a\x3f\xee\x2b\xd6\x48\x9c\xa5\x4c\xaf\x25\xeb\x8d\xbe\x84\x50\x55\x95\x48\x19\xdd\x64\xc4\xd0\xd4\x5c\xeb\x58\x94\xb1\x5b\x6a\xdd\x92\xbb\x37\xc3\x49\xb2\x34\x2c\x6d\x91\x0e\x49\x8c\x95\xa2\x24\x4a\x22\x22\xa5\xa5\x81\xde\x4c\xa9\x83\x60\xfa\x72\xa2\x5d\x4b\x47\x41\x6a\x56\x6f\x9d\x99\x4e\x4f\x22\xda\x0b\x0e\xe3\x94\x4d\xc6\xb4\x3c\x09\xfd\x30\xe6\x68\x87\xd1\xdf\x71\x57\xc5\x64\x3d\xc7\x86\xce\x3f\x70\xa8\x75\x5e\xf6\x18\x66\xad\xb7\x04\x2b\x26\x76\x1f\x43\xe9\x0f\x17\x5f\xeb\xf4\xaf\x9d\x0b\xc1\xd7\xfa\x2c\xe3\x19\x08\x7e\x22\xa3\xd4\xd0\x14\x94\x93\x8c\x4f\x30\x18\xac\x56\x9f\xd7\x4f\x30\xc1\x80\xd7\x85\x5a\x79\x0c\x67\x7c\x02\x43\x99\xdd\x1c\xe5\xcf\x8a\x4a\x5a\x13\x96\xb9\x72\xb6\x5c\x2f\xba\x71\x79\x4b\x13\xe5\x5c\x91\x64\x63\x1e\x85\x92\x6d\x67\xf1\xf4\x03\xf0\x2c\x9e\x8a\xa0\x49\xb2\xc9\xe6\x1f\x68\xc3\x11\x34\x1b\x51\xbd\x03\xf7\x0f\x0b\x12\x2b\x94\x1a\x32\xc8\x04\x44\x9f\x9f\xc5\x4e\x26\xeb\x0b\x04\x19\x39\xe4\x13\x35\xbf\xd2\xef\x62\x29\x8b\x74\x2a\xcf\x72\x0a\x00\xb2\xbc\x3a\xbe\x6b\x98\x33\xd7\x51\x8c\xde\xbb\x6d\xf7\xdf\x0b\xbb\x86\xdd\x8e\xbb\x89\x7d\x88\xba\x89\x41\x9e\x9c\xd0\x37\x4c\xbd\x08\xec\x41\x5d\xc5\x3e\x1f\xfd\xd2\x5b\x38\x87\x22\x4c\x2c\x53\xaa\x03\x84\x44\x51\x2e\x1a\xe3\x80\xf6\x7a\x08\xa6\x24\x12\xf4\x68\x38\x90\x04\x86\xa4\xcd\x3e\x8e\x92\xb3\x48\x40\x4d\xa2\x4f\x89\x81\x5c\xda\x18\x70\x46\x9d\xc5\xdb\x6f\x82\xf6\x5e\x6e\x84\x0a\xf3\xa8\x7a\x86\xfa\xd4\xe6\x8d\x59\x2c\x6c\xdc\x0c\x36\x64\xf1\x70\x16\xf8\xa7\xfa\x11\xb8\xb5\xbf\x18\x0f\xeb\xc0\xac\xdf\x83\xe1\x2c\x2e\xfc\x85\xbd\xdc\x4a\x50\x4e\x83\x2c\x08\x1e\x82\xe3\xc2\x0e\xc0\x30\x0e\x0f\x55\x1a\x0d\xb1\xc0\xeb\xf7\xf6\x64\x08\xd9\x69\xa7\xdd\x94\x9f\x13\x6c\x46\x8f\x1b\x8a\x64\x8b\xbb\xb8\x95\xdb\x04\x30\xf2\x68\x68\x2a\x6c\xe2\x96\x10\x27\x01\x89\x3c\xed\xe3\xfc\xe1\x73\xa7\x1d\x18\xe8\xcb\x62\xa5\x6f\x80\xdc\xfc\xc7\xec\xb1\x77\x74\xf8\xbf\xfc\x15\x70\x35\x16\xa3\x65\x3e\x28\x9a\x0b\x12\x21\xd6\x28\xf5\x20\xec\x0d\x91\xb2\x87\x86\xde\xa5\x1c\x0a\xd3\xd1\x92\x90\x17\x11\x14\xc4\x86\xc5\x6a\x19\xc9\xb8\xac\x56\x40\x7a\x0c\x7e\x07\x15\x46\x85\x02\xc3\x19\xc3\x38\xa4\xb4\xb4\x4c\x91\x05\x94\x4f\xe9\x03\xe3\xcb\x15\x0d\xd8\x71\x2e\x46\x8e\xce\x21\x18\x3b\xdf\xfe\x76\x9e\x4b\xce\xca\x71\x08\x95\xd9\xf9\x5d\x84\x8f\xef\xee\x54\x3f\xc8\x73\x89\xbf\xa0\xcf\x1e\xf4\xf3\x23\xc4\x7a\xa5\x05\xc2\x13\xa4\x42\x12\xc3\x98\xcd\xa1\xa0\x0c\x61\x0a\x7a\x7c\x10\x11\x6e\xab\xcd\xda\x9b\x11\x6c\x36\x67\x08\xd2\xa0\xd1\x87\x5b\x51\x3a\x09\x19\x8f\x81\x83\x88\x33\x16\x75\x23\x43\x66\xac\x54\x04\xdc\x04\xd0\x0a\x3b\xed\xe9\xb0\x39\xf3\x90\x21\x34\x92\x07\xb2\x7c\x03\x71\xb4\xe7\xbd\xf7\x0a\x58\xa7\x80\x6d\xa8\xa7\xd7\xdd\x07\xcd\xd6\xd1\x75\xa3\x3f\xc8\x73\x4e\x87\x36\x27\x92\x20\xd8\x4b\x50\x9f\x78\xa2\x4f\x29\x07\x90\xfb\x49\xbf\x0b\xe2\x8a\x33\xf9\x7d\x01\xc8\xfd\xa2\x60\x71\x40\x2c\x91\x2e\x83\xc4\x39\xa8\x09\x18\xf2\x68\x1a\x7e\xb2\x7c\xcb\x62\xc4\xe8\x0d\x47\x0a\x86\x0e\xb1\x97\xe4\x90\x12\xfd\xf6\x0c\xff\x0a\x6a\xf8\x81\xc9\x90\xa2\x8d\x6e\x2b\x16\x5c\x7e\x7d\x66\x82\x13\xf2\x4a\x18\xcb\xad\x10\x15\x94\x02\x6e\x86\x21\x9c\xe6\x40\x30\x04\x59\x5e\x12\x79\xb1\x27\x13\xb0\xf2\x56\x94\xf2\x63\xf4\x3a\x79\x2e\x34\x29\x1a\x72\xfb\xff\x6a\x04\x64\xfb\xa5\x17\x48\x2e\x91\x0a\xeb\xe7\x6f\xe2\x67\xba\x53\xdd\xe4\xc8\xd2\x82\x56\x88\x85\x82\x4b\xab\x40\xc2\xb2\x2b\xdf\x11\x51\xd3\x1f\x78\x6e\x50\x90\xd8\xac\x74\x88\xd0\x27\x0d\xba\x59\x0a\xe2\xc4\x4e\x85\xe4\xb0\x0c\x08\xd9\x21\x8f\xc8\x67\xcb\x4f\xca\x68\x4c\x05\x74\xf4\x44\xd1\x9a\x8b\x73\x9e\x32\xc8\x59\x50\x1e\x9d\x2a\xea\xa0\xa2\x83\x96\x6d\x6d\x33\x79\x6d\x34\x2b\x41\xb5\xa2\x5e\x3d\x21\x9e\x89\x75\xca\x7c\x1f\x29\x8d\xfe\xb5\x20\x07\xd8\x01\x3e\xd2\xc2\x97\x44\xae\xdf\xd6\x5a\xac\x53\x32\x4a\x15\x45\x40\x88\x10\x60\x76\x96\xa0\x20\x41\x19\x7b\x0b\x60\x40\x0d\x7d\x38\x0d\x86\x9e\x0c\x4d\x5a\x8b\x35\x4a\x21\x08\xe3\x63\x94\x58\x27\x4e\xb9\x7d\x7a\xad\x63\xdb\xee\x37\x87\xc7\xb7\x1b\xd4\x1b\xf3\x80\xc5\x93\x77\x1c\xd4\x65\x97\x21\x0c\xf1\x21\x13\xa7\x2b\x0d\xa8\x03\x88\x9f\xb5\x90\x04\x61\xb4\x08\x74\x24\xec\xb3\x8d\x64\x38\x1f\xb0\xe0\x06\x20\x01\x2f\x43\xe2\xb8\x46\x08\xb8\x29\xbb\x85\xc5\xdd\xec\x4d\xce\xa2\x61\xce\x59\x8b\x77\xea\xe6\x1f\x85\xdd\xf0\x26\x81\xc5\x10\x1e\xf4\xf7\x3f\x5b\xa2\x4f\x70\xca\xa3\x82\xba\x93\xfa\xe5\xbf\xf9\x2f\x6f\x44\x48\x98\x0c\x19\xd9\x78\x07\x53\x8b\x79\x64\x58\x49\xb3\x7e\x0b\x02\x47\xb6\x08\x54\x49\x04\xf5\x32\xe1\x7c\x72\xb6\x97\x49\x00\x47\x68\x7a\x32\x21\x02\x3a\xdc\x18\x92\x1e\x08\x89\x38\x09\x24\x93\xf4\x61\x49\xeb\x57\xaa\xa7\x02\xc3\x49\xbf\x97\x4a\xac\xf1\xf0\x08\x1d\x45\x48\x21\xef\x27\xaf\xbe\xc7\x68\xd1\x9a\x2c\x4e\x86\x17\xf5\x04\xa1\xcf\x72\x99\x6d\xbc\x1b\xe2\xa5\x92\x58\xa7\x34\x9b\xa2\xd1\xb2\x20\x97\x22\x39\x77\x19\x49\x57\x57\xb9\x79\x82\xf7\x8d\x64\x78\xbf\x25\x3c\x92\x31\x59\x2c\x04\xa3\xcd\xd6\x62\xca\x47\x32\x0c\x95\x2a\x8b\xe2\xa1\x53\xf1\x82\xe9\x5a\xb9\x66\x90\x38\x3a\x92\x4d\x07\x1c\x67\x66\xe6\xc7\x6b\x65\xe3\x21\x91\x29\x22\x27\x08\xe2\xb2\x83\x07\x99\xbf\x3e\xb0\x6f\x8b\x16\x14\x79\xa2\x30\x70\xb2\x78\x1d\xc6\xdf\x9f\x73\x13\xb8\xd4\x1d\x15\xd9\xa0\x48\x71\xf0\x44\x1a\xdd\xa6\xcd\x81\xfa\xf2\xbf\xf0\x50\x1b\x1c\x2f\x61\x51\x9f\xa8\x32\x62\x83\xd2\x6a\x87\x70\xc7\x3c\xb2\x40\x1a\xbc\x82\xa7\xcc\xc0\x94\x27\xbd\x6e\x06\x45\x4b\xdc\x7e\x47\xa4\x37\xe3\x70\x30\xe6\xc2\x36\x98\x10\x70\x5c\x89\x19\x67\x26\x69\x83\x99\xcb\xfe\x9e\xd0\xbe\x65\x62\x6b\x4c\x3d\x58\x12\x2d\x08\xa9\x4c\xd2\x2f\x73\x86\x82\x42\x26\x63\xb9\x80\x4a\xf9\xc4\x06\x9a\xea\xcd\x76\x14\x35\xc9\x05\x55\x48\xf5\x37\xb8\x38\x9a\x24\xda\xc7\x3e\x60\x7e\x86\xeb\x2f\x9b\x88\xa5\x0a\xf4\xa0\xd2\x51\xbf\xcd\x16\x0d\xbb\x2a\x92\xa4\xa1\xa5\x39\x5e\x3b\x9c\x31\x36\x9a\x45\x67\x3c\x6e\x76\x3a\x3d\xc3\x19\x27\x5d\x59\x11\x0e\x99\x43\x10\xcb\x66\x81\x98\xd0\xf2\x00\xf9\x51\xe3\xc2\x5e\xb1\xba\x26\x11\xf7\xd8\x61\x8b\xb2\x74\xe2\xb9\xf2\x68\xad\x51\x8d\xe6\x37\x48\x54\xbd\x96\x3d\x22\x35\xd2\x6f\xed\x3a\x6b\xdd\x5d\xd3\xb6\x84\x97\x7d\x5f\x7d\x40\xdd\xff\x24\x18\xf9\x9f\xfb\xaf\x5a\x1a\x5a\xba\xe9\xbd\xdf\x1d\x3c\x5a\x55\xba\x75\xe7\xdf\x7f\xfe\xab\xcf\xbe\x79\xa1\xb8\xa0\x75\xda\xb9\xb3\xea\xce\x5d\x5c\xd1\xb9\x88\xb7\x87\xc1\x20\x58\xfe\xdf\xa0\xe1\xae\xca\x31\x62\x6f\x9b\xfa\xb1\xfa\xac\xfa\x94\xfa\x11\x3d\xe3\xc3\x6f\xff\xec\xc4\xbb\x8f\xdf\xf5\xfe\x0c\x12\xfc\xec\xe0\xed\xea\x8f\xbe\xf1\x48\xfd\x39\x38\x36\x5f\x33\xf6\x01\x9d\xc6\x75\x96\x75\xc4\x80\x52\xe3\xab\xae\x2e\x49\xb9\x82\x95\x1c\x65\x2a\xa9\xe4\x5d\x14\x5b\x9f\x96\x6a\x7b\x33\x65\x95\x84\x99\x95\x24\x82\x65\x21\x03\xb3\x8e\x50\x10\x52\x7e\x6f\x26\xa6\x4d\xe3\xd7\x2c\xa6\xa9\x0e\x20\x9b\x22\x43\x34\xd4\x97\xe2\x54\x71\x08\x79\x18\x01\x18\x2f\x80\x5a\x2b\xa0\x8c\xe2\x5c\x26\xc1\x85\x02\xf9\xf0\x74\xd2\x27\xd5\x7f\x03\x6e\xf4\xbb\x47\x3a\xd3\x8b\xcf\x56\xff\x7d\xf1\x39\x97\xde\x77\xd1\x45\xf7\xf5\xcd\x10\xa5\xee\xe9\xc1\xb5\xd3\xd2\x4b\x05\xd7\x60\xe7\xb4\xe9\xed\xed\x2e\x00\x3e\xfa\x1f\xb5\xec\xb3\x2b\xaa\xd5\xdd\x0f\x1f\x67\xce\xb8\x77\xd7\x2d\xb7\xec\xea\xbb\x31\x41\x3a\xbb\x44\xbf\xc3\x62\x71\x80\x3d\x5f\xef\xe9\xdb\xf6\x7d\x2d\xd7\xa4\x1f\xcd\x20\x83\x76\xd5\x74\x25\x92\x20\xcb\x8d\x7e\xbb\x2b\x6a\x24\xed\x4c\x55\x65\x49\x22\x01\xd1\x6a\x49\x08\x08\xcf\xa2\x33\xeb\x26\xe7\x5b\x5b\x8c\x8b\x66\xe6\x9d\xc1\xd2\xe2\x01\xe4\x5a\xee\x95\x56\x27\xab\xb9\x80\xe4\x09\xcd\x05\xec\x9d\xa1\xaa\xea\xbb\x7a\xee\xc9\x00\xce\x49\x39\xf1\xdf\xe7\xdc\x57\x13\x5e\xc1\x0e\xaa\x5f\x6c\x4a\x77\x66\xbd\xc0\xee\xf5\xd6\x0a\x30\x00\x38\x3d\x09\x45\x4f\x52\xf9\xb3\xfa\x7b\xad\x46\xb6\x1a\x04\xd6\x29\xd8\x0f\x9e\x03\xfd\x60\xd4\xfb\xa6\x82\x98\xa1\x94\x88\xa5\x09\xd2\x58\x1e\xb2\x97\x93\xf6\x52\xba\xaa\x32\x9a\x48\x44\x16\x65\xcc\x09\x37\xef\x83\xac\xca\x3b\x4e\x05\xd0\x78\x90\xb4\x19\x5a\xf9\x84\x32\x9c\xb6\xa2\xa1\x49\xf7\x6a\x8f\x6b\x20\x75\x4d\xbf\xf3\x96\x7c\x97\x9b\xb6\x91\x86\x0b\xaf\xb8\x72\x75\xea\xba\x81\xf4\xcc\x1c\x2c\x9b\x9c\x15\x7f\xf9\x59\xae\xdd\xcd\xd0\xf7\x77\x3c\x73\x30\xb8\x30\x52\x46\xf9\xce\x9c\x89\x61\x08\x43\x5f\xb6\x09\xcf\x83\x98\xa3\x44\x79\x41\xb0\x41\x73\x1e\x52\x9a\x4d\x72\x03\x41\x70\x31\x76\x97\x1d\xda\xeb\x14\x0b\xdd\x3f\x88\x1e\xde\xe4\xcf\x19\x81\xd9\x7e\x04\x28\x26\x5e\xec\xf6\x69\xda\x4d\x37\x35\x74\x2b\x90\x69\xc2\x93\x7a\x5f\x41\x16\x46\xdb\x2b\xe9\x77\x57\xfa\x57\x30\x92\xa6\xce\xb2\x13\xb2\xb0\xd1\xa7\xf5\xd1\x55\xef\xc0\x7d\x74\x45\x78\xae\x11\x16\xee\x88\x17\x08\x9b\x40\xb9\x25\xbc\x25\x0e\x77\xc4\xe3\x58\xec\x91\x9a\x2c\xd9\xe0\x53\xd1\x8e\x0a\x48\x65\xd2\xed\x64\xbb\xcf\x42\x8b\x41\xdd\xaf\x37\xa0\x7d\x0c\x6a\x25\xd4\x80\x56\x5d\x01\x4e\x2f\xee\x41\x5b\x0a\x75\xea\x3e\x3c\x63\x6c\x5a\xb6\x1e\x80\x26\xe0\xfe\x5c\xd0\xd6\xa9\x46\x13\x66\x1d\x26\x4e\x10\xdc\x61\x37\x20\x09\xb7\xc3\x4d\x5a\x28\x9b\xc9\x24\xda\x69\xb3\x8b\x33\xda\xcc\x70\x97\x4e\x33\x07\xb4\xd6\x85\xfe\xe2\xfa\x78\xdc\x37\x0b\x95\x80\xe0\xfa\x70\xb4\x63\x2d\xd0\x89\x3a\x69\xe9\x73\x1d\x0b\x13\x62\xc9\x6f\xe1\xf4\xa4\x67\x71\xea\xf4\x6b\x28\xdd\xf5\xd0\xe8\xe7\x58\xd2\x12\xe4\x41\x2d\x75\x9a\xf4\xa1\x94\x56\x4d\x7f\xea\xfb\x26\x7c\xc4\x51\x65\xb6\x44\x90\x2c\x6b\x71\x73\xa2\xc3\xe9\xb0\x71\x16\x82\x0d\xf8\xfd\x81\x15\x01\xb2\x3b\xb0\x2b\xf0\xfd\xc0\xfb\x01\xda\x15\x28\x0d\x90\x74\x60\x56\x60\x7b\xe0\x48\xe0\x4f\x01\xa6\xcd\x1f\x00\x6d\x81\x0d\xf0\x87\xaf\x07\xe8\x13\x01\xf0\x72\x00\x04\x50\x43\x8f\x5a\xa7\xab\xeb\xec\x00\x04\x35\x50\x83\x5b\xd9\xd1\x26\x4a\x72\x00\x68\x7b\x43\xb1\x6c\xb3\x43\x6b\x89\x74\xa3\x51\x14\x5e\x7e\x42\x71\x87\x9e\xc1\x97\xf7\xeb\xb4\x7e\x8d\x29\xad\x45\xcd\x39\xe7\x6c\x9d\x30\xa5\xd8\x00\xf2\xd7\x3f\x91\x86\x48\xd6\x91\x80\x5f\x98\x7d\xdf\x54\x2f\x04\x35\xea\xf1\x57\x46\x7d\xaf\xa8\xc7\x41\x85\xba\xf1\x96\xfc\x40\x41\xfa\x53\xdf\x68\xe3\x4e\xf5\x37\x38\x9c\x5b\xb7\x93\xfc\xb5\x2f\x37\x4c\xb0\x00\x7f\x01\x62\xa1\x52\x1e\x0e\x41\x50\x42\x8e\x10\xc4\x1a\x6f\xb4\x7b\x04\xab\xd3\xee\xec\xc9\x88\x76\xce\x67\x32\x9a\x7a\x91\xe7\x30\x29\xea\xc6\xb7\xf2\x1e\x5e\x09\x3d\x87\xfc\x4e\x1b\x8a\x13\x99\xc5\x88\xa8\xe3\x6e\x2f\xd8\x51\x88\x3f\xf5\x0d\xb0\x4e\xbd\x07\x1b\x42\x03\xeb\xa6\x17\x23\x71\x34\x33\x77\x1d\xc6\x63\x1c\xf2\xe8\x21\x3c\xd7\xcb\xac\x4c\x67\x83\x6e\x3f\xa2\x2b\x1b\x67\x0f\xf8\x83\xac\x1c\xca\xce\xe5\x72\xc9\xe4\x47\xd9\x76\x9c\x4b\x64\x7a\xe3\x7e\xf9\x65\xf9\x53\x99\xaa\xc7\xcd\x38\xb7\xe3\x5e\x9b\xac\x8c\x3a\xb3\x6c\xdb\xd9\x85\xbf\xae\x5c\x83\xbf\x2a\xbe\xe5\x2b\xba\xc2\xf9\x4f\xa2\xb1\x5b\x6c\xdb\x53\xf0\xb3\x24\xfe\xf1\xb2\xd9\x0b\xba\x36\xc8\x60\x89\x0c\xda\x64\xf0\xa8\xfc\xac\xfc\xbe\xfc\xa5\x4c\xd3\x78\xa0\xd8\xe9\x32\xfd\x11\x6e\xda\xe9\x90\x6b\x64\x05\xfa\x2c\x7b\xe4\x7d\xf2\x61\xe8\xb9\x9c\x90\xcd\x46\xca\xef\xe6\x5c\x4e\x68\x2c\x8b\x01\xbb\x81\xb6\x78\xa0\xe7\x62\x63\x8d\x16\x23\xf4\x5c\x2c\x13\xd2\x33\x0a\x87\xde\x0e\xaf\xc4\xd1\x60\x34\xc8\xe8\x9c\x54\x2a\x75\x0e\x1e\x68\x74\xce\xb8\x76\x90\xba\x2f\x63\xd2\xe2\x1a\xfa\x1d\x80\x90\x0b\x91\x1d\x42\x92\xe6\xa6\xfb\xd5\xb7\xd4\x7d\xf7\xa8\x8d\x37\x81\x43\xea\x9e\x5b\xc8\x6b\xee\xff\x1f\x10\xbc\x07\x3c\x7b\x93\x7a\x23\x78\x64\x9e\x26\x77\xc0\x13\xea\x0c\x5c\xec\x58\x4a\xf6\x63\x67\xf3\x66\xb0\x1e\x7f\xad\x1d\xcd\xc0\xb3\x37\xea\x33\x43\x82\x40\x50\xaa\x51\xa4\x4c\xb0\x1b\xac\x56\xbb\x0d\xba\xca\xf0\xec\x6f\x90\x01\xea\xa7\xda\x87\xfd\x35\x7c\xd4\xa4\x03\xba\x70\x24\x3c\x11\x70\x1e\x3c\xbd\x3d\x47\xb7\x9c\xdb\x75\xb6\x0c\xf0\x79\x6f\xd8\x8c\xce\x7b\x8f\xe2\x3c\x63\x5d\xd7\xdb\xf2\xdf\x65\x7c\x6c\x08\x67\xf8\x98\x85\xcc\x60\xd7\x16\xf9\x3b\xf2\x21\x99\x42\xdf\x0f\xcb\x54\x27\xfe\xed\x40\xfb\x8c\x2e\x34\xfa\xac\x0f\x9e\xed\x75\xf0\x64\x59\x05\x1f\x32\x3a\x62\x06\x3f\xb6\x65\x9a\x86\xce\xda\x46\x0d\x9d\x65\xc9\xaa\x2e\x19\x79\x91\xc0\x44\xf9\x44\xbb\xe0\x80\x86\xbd\xcb\x6f\x63\x69\x33\x8a\xe4\x59\x19\x83\xd9\x80\x22\x79\xe6\x29\x22\x79\x5a\x8f\xef\x54\x0a\x1e\xbd\xde\xec\x3b\x95\xda\x9a\xd2\xa7\xa7\x0d\x8f\x9f\xcc\x85\x1d\x32\x54\x93\x9d\xc7\x81\xd4\x94\x75\xf7\xa9\x77\xb7\xed\xfe\xf4\xac\xfd\xbf\x1f\x52\x9f\x5c\x02\x19\xf4\x93\x15\xe0\xb3\xb3\xf6\x3e\x3c\x04\x94\xc5\xea\xbf\x40\xf9\x00\x8a\xf3\xcd\x90\x46\xc7\xc4\x19\x33\x1c\x60\x04\xdc\xe5\x9d\x31\xc3\xff\xd2\x2b\xf0\x5f\x51\xfd\xb5\xda\x28\x69\x32\x6c\x19\xf4\x95\x5f\xc5\xb1\xd6\x61\xa5\x5e\x60\xed\x0e\x97\xdf\x84\x06\x4c\xf9\x1d\xac\x85\x09\x06\x7c\xa2\x04\xe5\x8e\x64\xe5\x2c\x16\x2b\x6f\xb0\xa2\x0c\x11\xca\xaf\xe5\x31\x08\xa8\x08\xb2\x70\x9c\x63\x4e\x3f\x4c\xee\xf7\x67\x9d\x63\x36\x37\x7a\x3e\x91\x77\x8d\x5f\xd5\x06\x3b\x7e\x7d\x96\x7f\x05\xf5\xd8\xa0\xbf\xf3\x2a\x92\xd9\x40\xf6\x1f\xd4\x69\x88\xde\x40\xd9\xd0\xb0\xf9\xbd\xff\xb6\xd2\x5f\x7e\x27\x3b\xe0\x4d\x8b\x8b\x41\xbf\xf8\x45\x7c\xff\x3c\x57\x89\xf3\x92\x93\x35\xb3\x36\x89\xf6\x7a\xec\x66\xb3\xc5\xed\x30\x58\x0c\x7d\x19\xc1\xc2\x49\x9a\x88\x71\xf6\x66\x48\x1a\x2b\xb4\x42\x11\x53\xa4\xd3\xf2\xfb\xd4\xb7\x59\x0d\xe0\xbf\xd8\xff\x7d\x11\x6a\xb3\x93\x8f\x0f\x2f\x49\x75\x93\x0f\x77\xa7\x96\x80\x1a\xb0\x27\xd7\x96\xf6\x4f\x56\xa8\xcd\xd4\x13\xf7\x58\x47\x93\xd4\xec\xac\xdf\xeb\x85\x72\xe5\x31\x1c\x43\xed\x55\xca\xbd\x2c\x1b\x76\xd9\xe0\xc9\x86\x6d\xd0\x59\x94\x7d\x5a\xc0\xce\x24\xad\xca\x98\x4c\x74\xc0\x41\x85\xf5\xec\x10\x32\x6f\x02\x14\x0c\x6d\x1b\x67\xcd\xe4\xce\x12\x4f\x9c\x74\x4e\x1c\x48\xc9\xfc\x00\xf1\xe7\xb5\xda\xec\xc9\xc2\x81\x94\x59\xae\xc4\x73\x27\xc1\xd7\x26\x0c\xa5\xc4\x7d\xb4\xe1\x99\x2e\xc4\x3e\x6e\x8f\x92\x24\xc3\x1e\x86\x91\x79\x8b\x45\x0e\xc3\x7d\x87\xbc\x4e\x2b\x6a\x93\x6e\x14\xfb\x33\x46\x28\x81\xec\x9c\xcc\x50\x4c\x4f\x06\x50\x79\x3b\x61\xea\x6d\x6b\xe4\x5c\xd8\x3f\xdb\x59\xdc\x5e\x9b\x6e\x47\x21\x86\x6c\x17\xed\x82\xd6\xda\x77\xe0\x18\x43\xbe\x87\xb6\xfa\x5e\x61\x83\x6d\x2f\x91\x9d\x0f\x80\xcf\x3b\x46\x6c\x54\x5a\xfd\x06\x83\xc7\x18\xa4\xa8\x52\xd1\x5e\x6a\xb4\x53\xd0\x78\x0d\x69\x11\x1e\x13\x6b\xa6\x3d\xe6\x55\x99\x20\x3d\x92\x31\x02\x6f\xd0\x4f\x39\x3d\x1e\x10\x76\x52\xa5\x45\x33\x0e\x75\x75\x8a\xa2\x89\x7a\x96\xc2\x24\x20\xa5\x73\x8d\xcb\x59\x83\x18\x6d\x30\x14\x61\x43\x82\xbf\x91\x07\x8d\xf9\xc1\xe8\xe6\x47\x96\x6e\xdc\xdc\xae\x23\xe4\xf4\x95\x9b\xd7\xae\xc0\x23\x42\x11\x36\x64\xdf\x5b\xcf\xd1\x05\x18\x59\xbd\xdd\x48\xba\x47\xff\xc1\xcb\xb9\x61\xa1\x05\xfd\xcd\x31\x7c\x3e\x96\x95\x0c\x01\x92\x8c\xba\x6c\x51\x83\x0d\xc2\x57\x12\xd4\x2e\x15\x8c\x8c\x99\x92\xcc\xfd\x99\x00\xd5\x93\x31\x10\x9e\x80\x8f\x72\x40\xef\x46\x76\x70\x51\x32\x37\x9a\xea\x7f\x05\x5f\x24\x0b\xde\x38\xbc\x15\x81\x27\x92\x9b\x87\xeb\x1b\x07\x94\x69\x1a\xea\x1a\x1b\x06\xc2\xf3\x31\xea\x10\xda\x7c\xe2\xbe\x4b\x1d\x85\xa8\x03\xf3\xd5\x27\x58\x4f\xbe\x3f\xba\x86\xbf\x4a\x88\xbf\xe3\xfa\xcc\xd6\x72\x34\xee\x9a\x0a\x72\x41\x39\xec\x36\x8d\x64\x3c\x86\x55\x19\xb7\xc7\x63\xe3\x45\x07\xef\x40\x23\x1a\x83\x66\x0a\x27\xbb\x00\x1b\x3f\x59\x13\xf7\x96\x54\x71\x56\x15\xc6\x51\x61\x17\xbe\x9c\x13\x0e\x0d\x7e\x88\x9c\xe3\xa3\x3f\xd4\x58\x64\x74\xfb\x03\xdf\x21\x6f\xd0\xf9\x06\x62\xe6\x00\xe4\x8d\xd1\x23\xda\x54\x50\x8c\x9a\x25\x88\x71\xd4\x6f\xf8\xa1\xdd\x9a\xd6\xfa\x11\x42\xbb\xb5\x5b\xaf\xf5\xf9\x80\x7d\x19\xfa\x5f\x32\x11\x47\x79\x6b\x51\xa7\xd3\x24\x97\x72\x94\xec\xe5\xe8\xb2\x84\x93\x30\x12\x23\x99\x28\xe5\x31\x1a\x03\xd6\x00\x14\xaa\x01\xc1\x1a\x1e\xce\x58\x0b\xcb\x43\xe1\xbe\xd3\xc5\xc2\x13\x6f\x5e\xc0\x31\x82\x10\x48\x37\x69\xf3\xec\x0c\x11\x54\x27\x89\x7d\x30\xe8\x76\x53\xa0\x84\xa4\x22\x66\xf0\xfc\xca\x5e\xa5\xce\x39\x3f\x35\xdf\x04\x56\x81\x1e\xb0\x18\xac\x25\xbf\x7c\x8b\x1d\x38\x7a\xc3\x1f\xaf\x0b\x0c\xb0\x5f\xfc\x4b\xbd\x5b\xbd\xd6\x45\x1e\xfd\xd1\x21\x9a\x7c\x8d\x39\x4c\xf6\x42\xd3\xf7\x56\x57\x08\x80\x0e\xd0\x07\x7f\x74\xff\xbc\x27\x5e\x5d\x37\xf4\x33\xf5\xf1\x99\xa0\x02\x34\x91\xb7\xaa\x5f\xaa\xbf\x07\xe5\x00\x68\x70\xfd\x8d\x5e\x46\xfd\x1c\xc2\x95\x20\xe6\x23\xb8\x78\x5e\x2e\x75\x50\x1e\x87\x49\x66\x92\x65\x08\xb0\xde\x4c\xd4\x68\xb4\x7a\x02\x01\xf7\xa2\x4c\xc0\x6d\x0d\xf7\x66\xac\x8e\xc2\xab\x47\x4f\xf5\x78\x9d\x50\x00\x56\x9b\xd6\xad\x37\x08\x6d\x51\x57\xb6\xdf\x10\x72\x97\x51\xc2\x75\xba\xbe\x4a\x03\xcc\xd1\x9d\xa8\x17\x8e\xff\xf4\x89\xef\xab\x42\xcd\xc6\xa1\xe5\x97\x35\x1d\x5a\xfc\xce\xdb\x24\xf8\xf6\xb4\xb6\xdf\xf3\x29\xf0\x1b\x27\x10\xae\x15\xbc\xcf\xfc\xfc\xb9\x57\xfb\x1d\xff\x75\x51\x27\x74\xc1\x52\x7f\xfd\x17\xb8\xee\xeb\xdf\xbb\x6c\x53\xbd\x86\x1b\xf5\x39\x8c\x9b\x12\xad\xba\x35\x18\x8a\x43\xec\x94\x24\x38\x8a\xf3\x86\x4a\x98\x54\xb9\x86\x9e\xb8\x27\x00\xe1\x08\x41\xbb\x1b\x22\x48\x86\x18\x8a\xe6\x31\x04\x5d\x4b\x9f\xc7\xf1\x7c\xde\xc6\x1e\x1f\x77\x3c\x05\x9a\x0c\xce\xa8\xb3\xf4\x3f\xc4\xd4\xdf\x3e\xb8\x58\x7d\x41\xfd\x95\xf3\xab\x51\xa5\x50\xea\x09\x50\x2a\x82\x5a\xe0\x2d\x40\x18\x86\x15\xe3\x0b\xf5\x06\x5d\xa6\x54\xc5\x21\xbe\x4a\x82\xa1\x84\x83\x72\x84\x4c\x25\x1e\xb6\x22\xa5\xa1\x2c\x0e\x41\x95\x21\xac\x39\xb4\x45\x8b\xd1\x86\xa0\xcd\x95\x8b\x17\x8b\x85\x53\x23\x0f\x41\x5b\x05\x4e\x8d\xbf\xd2\xcb\x16\x5f\xfc\xd3\xc7\x4e\x81\x40\x29\x69\x82\xc6\x7b\xa9\xf3\xaf\x7f\xca\xa3\x11\xf2\xdc\x6c\x88\xcc\xdf\x61\x5f\xb1\x02\xbf\xa7\x09\xc2\xf0\x2e\x9e\xaf\xff\x2b\x5c\x8f\xf3\x24\xb9\x4f\x9f\xaf\x5f\x86\xea\x77\x52\xe9\x80\xbd\xa8\x7e\x07\xcf\x7a\x63\x4e\x87\xbf\xff\x67\xed\xf7\xc1\x0d\x63\x7f\xd4\x7e\xdf\x89\x7f\xdf\x1a\x2f\x9e\xc7\xaf\xb6\x32\xb7\x43\x99\x54\x41\xac\x56\x1a\x9d\x74\xac\xbc\x54\x92\x82\x41\x73\xaa\x9c\x66\xaa\x2a\xcb\x63\x5a\x2b\x12\xc2\x35\x92\x49\x95\x4a\xc8\x6c\x4a\x84\x29\x0f\x6e\x49\x62\x66\xfd\x3c\x0b\x9d\x7b\x36\x50\x9c\x5e\x85\x4e\x54\x6a\x99\x42\x3f\xe2\x90\x68\x3e\x22\xda\xe8\x74\xe0\x31\x9d\x93\x5c\xf1\x82\x46\x6a\xe3\x0b\x9f\x6c\x1e\x3d\x23\x1b\x14\xfd\xd1\x5d\xdf\x3c\xd0\xb8\xf0\xaa\xdc\x95\x75\x10\xdf\xfb\x34\xd6\x51\xd2\xf9\xaa\xfa\xf9\xe8\x4d\x5a\x50\xf4\x1f\xc0\x0a\x7c\xef\x5a\x37\x4c\x7a\x7f\x5d\x63\x23\x72\xf9\x64\x3b\x50\xde\x0d\xca\x9b\x8b\x96\x39\xe8\x12\xb7\xdb\xef\x37\x13\x65\x34\x64\x94\xb2\x28\x6a\x61\x05\xf5\x08\xdf\x9b\x11\x4b\x08\xc2\x1b\x0b\x71\x6e\xbf\xd7\xdf\x93\x31\x1b\xbc\xa2\xc1\xde\x9b\x31\xf8\x27\x42\xdc\x32\x15\xc4\x4d\x13\xa2\xa0\x93\xc3\xcb\x90\x1b\xfd\xc5\xa1\x50\x39\x5d\x96\xbb\xdc\xce\xde\x0f\xfd\x13\x14\x85\x42\x0d\xfe\x71\x57\xdc\xda\x35\x11\xee\x8f\xa8\x2e\x60\x5e\xc6\xba\x66\x9e\x52\xc6\x52\x21\xa3\xc7\xe1\x09\x51\x61\x19\xdd\x3a\x0e\x67\x7c\x46\x34\xf2\xd8\xe6\x5a\x93\x71\xd8\x84\xd0\x24\x96\x59\xae\x3b\x70\x5e\x08\xe4\x93\xdb\x23\x94\x19\xa0\x3c\x58\x3d\xac\x9d\xed\x07\xcc\xbc\x8c\xf2\xd9\xaf\x3e\xa8\xae\xf0\x46\x86\x6e\x3a\x67\xa8\xcd\x32\xb7\x82\x2f\x1f\xb8\xa4\xc4\xfb\x18\xfd\xd4\x03\x7a\x1a\x3b\xbd\x41\x7d\x53\xdd\xab\x6e\x7e\xa4\x1a\x30\x9b\x92\xe0\x2e\xf0\x4d\x20\x07\x0a\xee\x81\xbc\xea\x76\x3c\xdb\x2b\x44\xcc\x51\xe2\x06\x89\x09\x06\x25\x07\x25\x87\x03\x92\x57\xea\xc9\x78\x0d\xbd\x19\x2f\x67\x75\x2d\xca\x38\x80\xd5\x1d\xc4\x96\x19\x95\xd3\xf7\xbf\x9c\x64\xd7\xb9\xc4\xf4\x29\x7a\x18\x4b\xd4\xa5\xdb\xd2\x6f\x16\x4f\xf3\xf2\xe6\xc6\x7c\xe1\x0c\xf4\x49\xfb\x15\x43\xa5\x9e\xe5\x9f\xd9\xf8\x2e\xae\x94\xd8\xa4\xb4\x85\x1d\x0e\x12\xdd\xc1\x7b\x4c\x24\x15\x8f\x11\x71\x60\xa7\x64\x7e\x24\x83\xc7\x30\xcb\xb2\xdb\x1f\x09\xa1\xeb\xf8\xe1\x4c\xd4\x4f\x09\x1e\x37\xc4\x83\x89\x71\xf3\x8c\x6d\x24\xc3\x8c\x27\xa9\x71\x37\x27\x93\xcc\x34\x36\x38\x8b\xee\x16\xbc\x93\x0d\xd1\x62\xa5\x07\xd4\x43\xea\x51\x9d\x85\xae\x7e\xfc\xc0\xb8\xab\x39\xfa\x53\xff\x97\x9f\xa9\x3f\x57\x1f\xd2\x6f\x14\x0c\x20\x0c\xf6\x4f\x76\x31\xa4\xf1\xcc\x5a\x9c\x67\xb0\x41\x69\x0d\x38\x1c\x62\xd0\x66\x03\x3c\x0b\x58\x91\x8a\x96\x06\xb8\xde\x0c\x1a\x3d\x40\x5a\xa9\x40\x40\xf0\x84\xfc\x04\x1e\x3f\x10\xf6\x70\xda\xa4\x14\x03\x2d\x88\xb4\xa5\x57\x8b\x81\x9c\x02\xcc\x89\x77\x0a\x5a\xd3\x72\x8d\x77\x26\x05\x51\xa4\x0d\x9f\x7f\xae\xf1\xcc\xf3\xe3\xae\xee\xa8\xfe\x93\xef\x7e\x3a\x9a\x65\x96\x9b\x26\xb9\xbf\xc3\xf8\x5b\xa0\xdf\xa5\xae\x55\x1a\xdd\x2c\x1b\xc4\xf7\xa9\x76\x39\x04\xfd\x5f\x3b\xbe\x3d\xe5\x44\x88\xbd\xff\xcb\x15\x6a\x1e\x71\x2d\xc5\xae\x8d\x70\xaa\x3b\x54\x8d\x87\xc6\xdf\xa1\xce\x87\x6e\xcd\x91\xaf\xbe\x43\xdd\xae\xdf\xa1\x0e\x2b\x75\x22\xc3\xe0\xc2\x8f\x80\x4d\x0e\xb9\x20\xdf\x70\x2e\xd9\x05\xf1\xe3\x72\x59\x72\x65\x1f\xa7\xaa\xf9\x98\x88\x99\xa2\x46\x17\x1a\x53\x4d\x31\xb7\x8d\xda\x8f\x78\x6a\xe2\xdc\x36\xad\xa0\x63\x8a\x8b\x54\x4f\x96\xff\xb3\x3e\xe5\x3c\x25\x8e\x3c\x33\xc1\x2a\x5b\x91\x5f\xa6\xa5\xe3\x18\xdd\xab\xa0\x5f\x06\xfc\x1c\x45\xf9\x19\x19\xc8\x85\xfe\xcc\x38\xc7\xac\xd0\x38\x46\x23\x55\xa7\x76\x26\xa1\xef\xa2\x5e\x7b\xf1\x85\xd1\x89\xde\xe4\x77\xd4\x6e\xa0\x4e\xed\x4c\xea\x79\x1e\x79\x7f\xb2\x4b\x89\x49\x34\x1d\x72\x98\x43\x66\x94\x42\xe4\xc0\x13\x24\x0d\xae\xfe\x8c\xc1\x40\xf8\x6c\x1c\x1d\x22\x42\x3d\x19\x34\x54\xa1\xe3\xf9\xc9\x7c\xc9\xfc\x96\x23\xd9\x1d\x4f\xe1\x48\x8a\xd4\xd9\xbb\xb7\x39\x26\xf7\x24\xef\x39\x85\x23\x39\x43\xcf\x3f\x33\xf4\xe3\xb8\xee\x0a\xa5\x1a\xd2\xbc\xcf\x64\x14\x5d\x16\x0b\x64\x6a\x1f\x15\xf0\x8b\x76\xc1\xeb\x14\x9c\xc3\x19\x83\xd9\xec\x16\x28\x9f\x85\xc5\xf5\xbb\xb4\x9d\x37\xe9\xe9\x67\x05\x37\xbc\xd9\x58\x48\xcb\xc4\xfc\x27\x44\xe8\x31\x14\x81\x2e\x9c\x49\x68\xc2\x33\x09\x0d\xfd\x88\xca\x2f\x3b\xa2\x1a\x9a\x54\xe7\x11\x35\x0a\x09\x9d\x03\xbb\xc1\xe5\xa4\x0f\x47\x44\x8e\x00\xa8\xba\x4d\x5f\xde\x48\x6f\xfa\xf2\xf3\xac\x1a\x3f\xf9\x4d\x6a\x2b\x1a\xe5\xac\xd3\x39\x9e\xa7\xe8\x83\x3c\xdb\x20\x58\xa1\x23\x65\x34\xb8\x50\xa5\x93\xd7\xeb\xe2\x28\x7f\x80\x0b\x00\x13\xe5\xb2\xf1\x1e\xe8\x4b\xf5\x64\x58\x93\x49\xe4\x39\xaf\x99\x81\xfe\x14\x22\x74\x9b\x88\x92\x39\x0a\x69\x3d\x0f\x45\x5e\xce\xe6\x21\x29\x28\x6e\x9a\x64\xba\x22\x7d\xce\xb6\xf4\xaf\x06\xd5\x87\x27\x8e\x57\xd4\x94\xc7\x9d\xa3\xc6\x49\xa7\x2c\x22\x5b\x0d\x35\x0b\x75\x63\xff\xaa\x57\x9b\x55\x07\x6d\xb7\x63\x06\x1f\x1f\x47\x91\x77\x6c\xbb\x5d\x07\xbe\x85\x26\x55\x08\x0c\x9a\x54\xa1\x1e\x71\x87\x28\x53\x41\xff\x72\x3c\xbf\x1a\xcd\xfd\x44\xf3\xab\xd1\xef\x13\x37\xe3\x7e\xe7\x64\x1c\x4f\xb6\x78\xed\x48\xb2\xd6\xca\x14\xf6\x3b\x47\xcf\x67\x0f\x64\x9f\x4f\xac\x07\x57\xe1\x5e\x28\x14\x29\x33\x71\x0a\x7e\xe2\x8b\x23\x25\x01\x6d\x85\x5c\x2f\x14\x6d\x8d\x81\xec\x1a\xc4\x7a\xe2\x20\xee\x85\x42\x91\x75\x4e\xfc\x99\x8f\x8e\x34\x54\x6b\xab\xe4\x3e\x63\x87\x36\xeb\xcd\xd8\x86\xbd\x82\xd0\x9f\xc1\x5c\x80\x67\x23\x1c\xc0\xef\x51\x4d\xd1\xdf\x90\x4d\x8b\x4e\x00\xc3\x39\xa4\xdb\xb4\x01\x68\xd3\x96\xcb\x09\xbf\x77\xc2\x3c\x8e\x0c\x86\xb3\x4b\x87\xf3\xeb\x5a\x4d\x3a\x1a\xc7\x41\x1a\x22\xc9\x71\xf3\x3b\xa6\xc1\xf5\x1e\x60\x16\x38\x58\xb0\x08\xbf\x6f\x80\x9f\x9f\x4b\xfd\xdc\xc1\x42\xf2\xcd\xfd\x1c\x9d\x03\xfa\x39\x3e\x87\x6f\xea\xe7\x50\xa6\x9d\xc3\xdf\x8f\xa4\x62\x0e\x73\x11\x4c\xf8\x19\xe8\x1c\xd0\x33\xd0\xfc\x86\x01\xed\x14\xca\xb5\x53\xf8\xf8\x48\x65\x82\x16\x8a\xe7\x37\xe8\xb6\xfb\x81\xac\xed\x4e\xac\x27\xbf\x03\xd7\x91\x14\x1b\x09\xea\x51\xf3\x19\xa2\xa9\x56\xb3\xde\x8b\x3f\x03\xed\xf7\x81\xac\xfd\x0e\xf7\x76\x9d\xde\x7b\xa6\x3e\x3b\x29\xa2\xa9\x56\xb3\xe1\x73\x7b\x1b\x1a\xfb\x80\x06\x78\x9d\xa7\x75\x1c\xed\xd3\x7b\xdc\xd4\x69\x3d\x6e\x7e\x09\x71\xc4\x12\x45\x9f\xc1\xb3\x7d\xf1\x3a\x7f\xd1\xe0\x29\xd3\x56\x49\x6b\xab\x7c\x78\xa4\xb1\xc6\x3c\x7e\xc6\x49\x3f\xfc\xcc\xdf\x70\x9e\xcb\x0c\xa5\xc4\xe9\xb5\x04\x7d\x1c\xe9\x0e\x7a\x39\x26\x12\xf6\xf2\x12\x34\x74\x7c\x1c\x47\xb8\xa1\x9b\x60\x1c\xce\x50\xa8\x75\x5c\x1d\xf6\x2b\x27\x71\xb1\x70\xdf\x05\x7d\x1e\xbf\x56\xf9\xd5\x00\xb2\xf9\x5e\x78\x14\x30\x0d\x9e\x7e\xee\x1e\x7a\xb0\x22\xb1\xb3\xf2\x8a\x4b\x6e\xbc\x62\x31\xa8\x9e\xf5\xa7\x41\x39\x43\x2d\x50\xef\x7e\xec\x59\xf5\x84\xab\x0c\xac\xf9\xa7\xdb\x7f\xeb\x5d\xb7\xdd\xb5\x1e\x7c\xd7\xf5\x12\x58\xb4\x5e\xed\xf6\xfe\xee\xe0\x4f\x5f\x46\xb0\x45\xd4\x39\xd4\x99\x68\x96\x1f\xb9\x24\x4b\x6f\xac\xc4\xce\x86\xb0\x3e\x83\xfb\xf9\x5c\x05\x9e\xd6\xe9\x4d\x46\x3e\x54\x50\x66\x84\x89\x73\x04\xe8\xcf\xb3\x73\x04\xc8\xab\x88\x7f\xeb\x3d\x10\x64\x27\xfe\xfd\xfc\x14\x81\x82\xe7\x1f\xc8\x3e\x1f\xe2\xec\xe9\x2c\x9e\xcb\x30\x9e\x53\x31\x66\x3c\x6d\x68\xb3\x0a\x06\x72\xb3\x0a\xd6\xe3\x35\xb4\xcf\x38\xb5\xcf\x68\xab\x14\x7c\x06\xf7\xe6\xc2\xfc\x5b\xa7\xaf\xf3\x6b\x6d\x1d\x8a\x8c\x22\xc2\x25\xe3\x61\xab\x73\xdc\x67\x70\xdf\x2b\xcc\xbf\xfd\xfa\x3a\xf7\xeb\xfc\x5b\xaa\x51\xee\xd8\x91\x44\xa4\x90\x36\x8a\x7a\x80\x39\x09\x0f\xb1\x48\xa9\x10\x11\x5e\xed\x76\x86\x60\xd0\xb8\x5a\xd9\x47\x42\x83\x88\x1b\xc9\x58\x35\xcb\xc8\x48\x1a\x2d\xb8\x1b\x18\x3f\xae\x1b\xd8\x54\x26\x50\x41\x3b\x30\xa6\x8e\x17\x22\x3e\x20\xa0\x1e\xd5\x13\xda\x7f\x91\x3f\xfa\xd1\x21\x7a\x34\xc1\x1c\x3e\x76\xe4\x90\x89\x7c\xd5\xf4\x40\x71\xbf\xaf\x2f\x00\x03\xe2\xea\x7f\xab\x63\xf4\x2d\x1f\xab\xff\x00\xb6\x8f\x8b\xfb\x7c\xf1\x84\x97\xb8\x5a\xf1\xb9\x1d\x0e\x56\x82\xfb\x67\x09\x9f\x9f\xf6\x7f\xc3\xff\x94\x9f\xea\xf8\x86\xff\x26\x3f\xe9\xc7\x97\x1f\xed\x5d\xe8\xab\xd2\x88\x66\xfb\xfb\x01\x49\xf8\xc3\xfe\x3d\xfe\xeb\xfc\xf4\x93\x7e\x30\xec\x07\x84\x1f\xd8\x28\xb7\xa3\x37\x63\x75\x07\xdc\xd0\x7a\x72\xbb\xd1\x20\x2d\xdc\x17\xcc\x3a\xae\x2f\x58\x1e\x58\x6d\xc8\x7f\x6a\xeb\x78\xb0\x8b\xba\x83\xa1\x69\x53\x2e\xb7\x80\xba\x50\x17\xf5\x03\x9b\xbf\x60\x26\xa9\xbe\x37\xbd\xbb\xab\x83\x04\x5e\x3a\xdf\x01\x6c\xf4\x1b\xdf\x79\xfe\xd7\x77\x53\x8e\x6b\x7f\xf0\xc3\xab\x8b\x68\x81\xbe\x55\xa7\x85\xe7\x35\x5a\xa0\xa9\x18\x13\xa7\x29\xa6\xac\x84\x60\xa6\xa2\x05\xfa\xb6\x22\x5a\xa0\x29\xa8\x30\x68\x0a\xd1\x42\x32\x3a\x4e\x4e\x7c\x13\xae\xc3\x61\xda\x7e\x4b\x5f\xa7\x59\x97\x2d\x29\x4d\xb6\x3c\x71\xa4\xaa\x4c\xb4\x17\x7d\x06\xcf\xf6\xc2\xb4\xad\x6a\xb2\x25\xaa\xc9\x96\x32\xa7\xde\x71\x2b\x15\x13\xc7\xcb\xbd\x56\xb8\xce\x51\xcc\xa3\x2f\xeb\x3c\xfa\xa8\xce\xa3\x61\xc8\xa3\x9e\x50\x18\x98\x8b\x78\x0e\xcf\xee\x40\x3c\xaa\xcd\xee\x80\x3c\xfa\x73\x9d\x47\xd1\xb0\x0f\x8f\x1c\xa1\xac\x45\xbf\xaf\x3d\xff\x40\xf6\xf9\x10\x8e\x47\xb3\x3c\x9a\x44\x80\x78\x2a\xe2\xc0\x3c\x6e\x4f\xda\x7c\x90\x81\xec\x1a\xf0\xbc\x7e\x9e\xe5\xd1\x72\x04\x8a\xa7\x32\xa1\xad\x32\x01\x8e\x4f\x72\x70\x7c\x87\x14\x8b\x64\xc1\xd6\x50\x62\x8a\x75\xf6\xe7\x60\xf9\x0e\xf1\x59\x76\x9d\x24\x5a\xa7\x5b\x2e\x9b\xb0\x0e\xbe\x0b\xc0\xf0\xfc\x4e\x87\xe7\xdc\x62\xbc\x9c\x80\x78\x21\x1d\x45\x78\xc1\xf1\x75\x8c\x97\x7f\xe9\xf0\xfc\x21\xbb\x4e\x0a\xcb\x9c\xaa\x32\x3f\x37\x4e\xe6\xc7\xd4\x6e\x5c\x9f\xe9\x24\xea\x14\x3f\x6b\x23\x6c\x02\x8f\xee\x75\x1c\xcc\x48\x06\x38\x26\xcb\xeb\x48\xe7\x22\xd3\xb9\x12\x4c\x29\x3f\x00\x43\x2f\xbe\x7c\x01\xdd\xde\x6c\xfc\x7e\xb6\xf2\xf2\xcb\xeb\xb5\x24\x0e\x5c\x01\x98\xcb\x07\xc5\x75\x97\x4e\xa2\x56\xf1\x65\xd7\xed\x81\xeb\xf6\xc2\x75\x27\x49\xde\x28\x5e\x36\x31\x6e\x59\x6a\x13\x2e\xd0\xbb\xd5\x71\xd6\x5e\xf5\xaf\xd9\x9a\xca\x51\xd1\x93\x1f\xba\xa8\xcb\x71\x03\xb6\x8f\xa8\x37\x74\x7d\x7d\x5b\x96\xa7\x6a\x11\x4f\x81\xfa\x2a\x77\x74\xa2\x1c\x67\x4d\xf8\x4c\x4f\x66\x65\xb2\x76\xa6\x34\x95\x46\x4c\x45\x34\xd6\x78\xa2\x13\xce\x74\x0e\x3e\xd3\x52\x54\xff\x63\xf5\xb0\x66\x73\x80\x27\x3c\x01\x3a\x1e\x33\x85\xe4\xd0\x48\x86\x95\x65\x5f\x34\x1a\x19\xce\x44\xd1\x29\x47\x29\x73\xc0\x17\x18\xce\xf8\x78\xce\x3d\x92\xe1\x39\x3f\x91\x9f\xfd\xa5\xc3\x4d\x4c\x12\x80\x1e\x57\x00\xab\x35\xfe\xc4\x7e\x74\x3b\x98\xa4\x1a\xb6\x4a\x7d\xf1\x85\xab\x77\x0e\xce\x31\xcc\xad\x92\xab\xb7\x8e\xfe\x62\x42\x5d\xec\x9f\xf6\xde\x1c\xfd\xeb\xce\xd2\x9f\xef\x1d\x57\x1f\x0b\x69\x17\xe1\x09\xc3\x62\x91\x18\x93\xc9\xef\x8f\x4a\x4e\x08\x8b\x11\x4f\x20\x62\x42\x21\xaf\x36\x81\x08\x35\xdb\x29\xe1\x4c\x38\x94\xe6\x15\xed\x62\x5f\xc6\x69\xff\xcf\x61\x29\x28\x96\x9d\x0a\x14\xbd\x72\xf6\xf1\xc7\x6f\xcd\x03\xa2\xae\x2a\xa8\xa1\x7d\x6d\x9d\xba\xdf\xf3\x66\x16\x0e\xe8\x8a\x0e\xae\x03\xf5\x7a\x2d\x6d\x5c\x9d\xcd\xac\x82\x38\x29\x27\x66\x2a\x51\x83\x5c\x91\x2a\x8b\x93\x11\x84\x83\x04\xe5\xa5\x82\xe5\x51\xca\x27\x07\xa1\xb7\x19\xe4\x2d\xc2\x70\xc6\x6e\x09\x14\x6f\xbc\xb0\x7e\x02\xf7\xee\x41\xf7\xd7\x7a\x09\x7e\x36\x6a\x8e\x0c\x9d\xc4\xc4\x74\x03\x66\x15\xca\x26\x58\x3c\x6d\xd6\xba\x47\xcf\xbf\x74\xfb\x69\x92\x30\xa7\xbc\x67\x70\x95\xfa\xe2\xc4\xbc\x03\xa6\x1d\x67\x15\x7c\x32\xf8\xed\xbe\xb3\xef\xc9\x94\x02\xd7\x3e\xc9\x77\x46\xdf\xf2\x5b\xc1\x6f\x27\xcb\x40\xc0\xb9\x07\xb3\xa9\xe7\x20\x6e\xca\x51\xe5\x7e\x80\xae\x48\x95\xc7\x42\xd1\x70\xb4\x27\x53\x4a\x04\xdd\xb4\x2f\x11\xe6\x02\x92\x4f\xea\xc9\xf8\x44\x23\xd7\x9b\xb1\x18\xfd\x5f\x01\x94\x54\x08\x91\x9e\x6c\x56\x0d\x26\xbb\xbc\x27\xcf\xb9\x6a\xd3\xbc\xd5\x3f\x58\x7f\xd9\x40\x57\x79\x7c\xf6\x82\x4c\xe7\xc6\x75\x93\xdc\xe2\x93\xe1\x57\xbe\xf7\x93\x95\xab\x6f\xe9\x89\x02\xf7\xfe\xea\xd3\x3a\x9a\x6e\xdd\x7f\xd7\x24\xb7\xf9\x5a\x0e\x0b\x94\x77\x87\x70\xcf\xf4\x85\x4a\x22\xc0\x94\x46\x25\xde\xe2\xb0\x41\xbf\xd4\x6f\x34\x19\x47\x32\x1e\x67\x09\xf4\xf3\xa0\xd3\x47\x45\x02\x0c\x34\x03\x86\x33\x32\x55\x94\x55\x8d\x63\xb4\xe9\xe2\x9a\x10\x04\x94\x56\xad\x0e\x12\x11\x28\x24\x0a\x53\x40\x50\xe2\x90\x86\x2b\x00\xe6\x6b\x98\x98\xad\xde\x06\xa4\x0f\x0a\xb3\x40\x4e\x80\x3e\x75\x2b\x38\xf0\xad\xd1\x6d\xf7\xab\x6f\x9d\xae\xe1\x60\xc3\x4e\xb0\xa9\x28\x0f\xe4\xc6\x9d\xa3\xe7\xe0\x3c\xa2\x27\x10\x1c\xfa\x9c\x69\x08\x47\xaf\x52\xe6\x08\x94\x46\x03\xa2\x03\x23\x81\x93\xc3\x32\xb4\x33\x18\x77\xd0\x17\x0e\x03\xc1\x27\x96\x58\x58\x1a\xd0\x3d\x19\x23\xe0\xc6\x01\xc2\x4f\x0a\x89\x90\x3f\x7f\x0e\x40\x4e\xd1\x0b\x76\x0c\x3a\x80\x90\x49\x12\x72\xee\xe8\x1f\x39\xf4\x05\x28\x1d\x50\xcd\xb9\xec\x8a\xce\x3f\xde\x79\x05\xb5\x01\x9e\xf9\x6f\x5f\x42\x67\xfe\xea\x3a\xb5\x03\x62\x22\x97\x5d\xb1\x76\xdd\x4b\x5a\x3f\x08\x68\x45\x32\x3e\x88\x07\x23\xb4\x0c\x67\x2a\x25\x84\x20\xd1\xb4\x5d\xb0\xfb\xbc\x6e\x76\x24\xe3\x76\x3b\xcd\x76\xca\x49\x0d\x67\x9c\xbc\xcd\x63\xf6\x0c\x67\xcc\x14\x31\x7e\x68\xc7\x84\xf9\xd3\x6d\x00\xd5\x49\x08\xd9\x69\x49\x61\x67\x7d\x69\x24\xed\x04\x77\x5c\xba\xfb\xc6\xbd\xbb\xaf\x3d\x44\xbe\x70\xf0\xfb\xa3\x6b\x47\x5f\x02\x5e\xe0\x3a\x02\x76\x5d\x76\x0d\x19\xbb\x9a\xfc\x07\x8a\xbf\x5c\xe9\x9b\x07\x76\x3d\xf1\x53\xf0\x16\x94\xc3\x8b\xa1\x0f\x34\x88\x7d\xe9\xb9\x78\x9f\xd0\xe7\x64\x7f\x8b\xe9\xa5\x8a\xc8\x28\xb5\x21\xd2\xe3\x2c\x8f\xda\x6c\xe5\x65\x24\x5d\x53\x2d\xf1\x2e\x68\xab\x02\x39\x02\x39\xda\x51\x31\x92\x89\x38\x22\x0e\xb3\x8b\x32\xc7\x51\x7d\x17\xe3\x1f\xce\x30\x05\x7d\xaf\x71\x35\x6a\x6a\x42\xb9\x47\x36\x0a\xeb\xca\xe6\x07\x97\x36\xe0\x7d\x17\x44\x6b\x70\xe8\x06\x0f\xd8\x6e\x8a\x37\x20\x18\xd9\xdf\x6e\x3e\xfe\xca\xea\x03\xed\xb7\x5c\xaa\x7e\xac\x7e\x86\x00\xba\xfa\xd7\xe4\x0f\x0f\xb6\xcf\xeb\x98\xb3\x19\xa8\x5f\x3c\xba\xf5\xa2\x33\xe7\xd5\xae\xda\x7d\x2d\x79\xad\x57\xbd\xef\xe6\x6f\x07\xcb\xd3\xc7\x7e\x8e\xe0\xc3\x0d\x5f\xfa\xbf\xb6\x7d\xf7\x39\xa0\xdb\x3b\x5f\xbd\xfb\xb2\x6b\x7c\x8b\x76\x83\xb6\xab\x21\x9c\x29\x08\xa7\xc2\x5c\x03\xe1\xac\x25\x56\x29\x0d\x82\x33\xe5\x61\xa3\xd6\x10\x49\xb2\xc9\x94\x95\x81\x96\x26\xaa\x88\x27\x10\xa8\x3d\x19\x36\x19\x89\xd0\x1c\x57\xdd\x9b\xe1\x1c\xa6\x78\x5f\xc6\xe4\xa6\xa1\x2c\xa6\xdd\x85\xa3\x47\xb5\x5b\xda\x5c\xa9\xfc\xb8\x5b\x31\x60\x40\xd7\x37\x09\x7d\x7a\x22\x6a\x44\x14\x6f\x47\xfc\xa2\xc1\x8b\x5f\x32\x5a\xa0\x0a\x02\x8c\xbb\x80\xb1\xca\x0a\x75\xe0\xfd\xb3\xe6\xed\xed\x3f\xfe\xdc\xeb\xc7\x07\x37\xb2\x23\xe0\xe2\xf6\xae\x79\xed\x2b\xc0\xab\x5f\x3a\x86\x96\x37\xf5\x97\x47\xa6\xd5\x06\x07\x4e\x07\x3f\xf6\x6c\x51\x7f\x74\x46\x63\xf5\xdf\xff\xf5\xa9\xea\x8f\xec\xfc\xd0\xd3\xf9\xe5\x9e\xb3\x57\xaf\x3e\xfb\xbf\x3c\x9d\x91\x47\x7f\x11\xf1\x75\xae\x20\x25\x8e\xfd\x05\xe2\xa1\x59\x10\xe6\x11\xe8\x9f\x54\xa1\xac\xe7\x72\xb2\xd4\x14\xe2\x23\x36\xaf\x8d\x37\x91\x4c\x4d\x35\x48\x55\xa6\x86\x33\x11\x9b\x1d\xa5\x12\x56\xda\x2b\xed\x8c\x37\x10\x70\x0d\x67\x02\x34\x93\x28\x40\x6c\xae\x62\x54\x6f\xab\x3d\x31\xa1\x56\x43\x6d\x15\x68\x07\x53\x95\xcc\x0a\x62\x1e\xcd\xec\x08\x44\xed\xbd\x8f\x8d\x7c\x34\xa1\x52\x76\x80\xd4\xf1\xab\x63\x75\xfe\xb7\x77\xc7\x26\xaf\x91\x7d\x7d\x56\x16\xc5\x9a\x9d\x50\x03\x6d\xc9\x4d\x38\x3f\x78\xb1\x52\xe1\xb7\xcb\xe6\x32\x52\x24\xed\x66\xba\xaa\x32\x95\xec\xc9\xa4\x52\x16\x60\xb6\x98\x7b\x33\x21\x8b\x85\x16\x3d\x1e\xe8\xa5\x78\x1c\x74\xac\x00\xa1\x45\x57\xd3\xe9\xe2\x82\x98\x2c\x2e\xe3\xa7\xac\x82\xcd\x63\x75\xd3\x22\x75\xe0\x95\x97\x26\x96\xbf\x22\x5c\x2e\x02\x3f\xd7\xd0\x77\xf3\x75\xe3\x0b\x5f\x77\x0c\xe8\x38\x44\xf0\xac\x84\xb6\xe4\x85\x10\x6f\x11\x62\x81\x02\x2d\x4d\x36\x12\x32\xbb\x23\x9c\x19\xd5\xf7\x59\x2c\xe6\x91\x0c\x84\xc3\xed\xf5\x3a\x87\x33\x5e\x3a\x32\xf1\x4e\x2a\x0b\xce\x04\xdb\x20\x9b\x2c\x34\x15\x9a\xbc\x80\xbe\x10\xd9\x9b\xd7\x3d\x32\x11\x39\x83\xd9\x7c\x21\x61\x8a\xb2\x65\xf5\x73\x0d\x17\x6d\xd0\x1e\x3d\x1f\xe2\x22\x4a\xcc\x56\x62\x54\x89\xcf\x26\x1a\x6d\xc1\x92\x28\x1b\x2b\x0d\x9a\x4c\x46\xe8\x11\x9a\xa8\x2c\x0e\xa8\x92\x5c\xbe\x10\x31\xc5\xb6\xb5\x54\x21\x27\x0e\x7c\x68\x7a\x34\x77\xfa\x61\xfd\xf0\x83\x40\xa2\xd6\x6d\xdb\xbd\x7b\xd3\xda\xf9\xcb\x96\xac\x59\xd9\x13\x5b\xe9\x86\xa7\x7e\x25\xf8\x2e\x3a\x75\x9c\x30\x04\xf8\x79\xcb\xcf\x58\xd5\xd7\xbd\x30\xe0\x82\x07\xfe\x77\xbd\xd0\xf8\x98\x97\xd0\xe7\xa3\x19\x2e\xc3\xf6\xcc\x72\xa5\x26\x6c\x34\xfb\xe2\x24\x69\xf4\xf1\xd0\x08\x00\x89\x24\x64\x84\x64\x92\x09\xc8\xb8\xa3\x3a\xee\xfa\x4f\x71\xee\x35\xd0\xb6\x14\x98\x68\x9e\x47\x0a\xaf\xd3\x26\x3b\xf7\xac\xf0\x6b\x98\xea\x42\x30\xcf\x1d\x86\xcb\xce\x3f\xfe\xca\xa7\xc7\xd5\xbb\x26\xde\x0c\x5e\xf4\x00\x62\x8f\xf3\x49\x5e\x67\x8f\x1f\x1c\xa3\x2e\x9c\xfc\x8a\x30\x2f\x01\xd1\x3d\x01\x94\x01\xed\xb8\xc6\x05\xc2\x67\xf4\x84\xd8\x52\x28\xf2\x3c\x4e\xba\x3c\x09\x62\x09\xc8\x04\x89\x04\xed\xd3\x2a\x2c\x7d\x10\x3b\x3e\xce\x26\x2e\xca\x38\x6d\x6e\x3a\x92\xe7\x8f\xaf\x86\x0f\x32\x48\xd8\x0b\xa6\xb8\x3a\xcc\x33\x07\xdb\x0e\x99\x43\xcd\x1c\x9a\x78\x89\xe8\x1e\x2e\xe2\x0f\x30\x97\xe4\x27\xbb\x4c\x7c\x34\xcb\x24\x80\x88\x42\xbc\x3d\x8f\x7b\xba\x9c\xab\x4c\x97\x2c\x16\x87\xec\x31\xc6\x20\xea\x1c\x54\xaa\x1c\xc4\xcb\xa0\x86\x2a\x2b\x93\x24\x88\x32\x4e\x02\x16\x4a\x92\xec\x42\xc8\xeb\xc6\xe1\x7a\xbf\x40\xe9\x9d\x36\x79\xa6\xa4\x58\xd2\x4d\x72\x9f\x43\xa4\xc7\x41\x3c\x11\xa9\x93\x5e\xee\x14\xe0\xf4\x79\x88\xd3\xbf\xbc\xa1\x86\xb2\x37\x55\xe0\x8f\xe8\xa6\xaa\x18\x9b\xb7\xde\x06\x06\x27\xbb\xb2\x2a\xc2\xa5\x08\x71\x99\x81\xb8\x4c\x10\x3b\x14\x05\xdf\x59\x89\x4c\x09\x00\x8c\x8d\x4a\x96\x11\xd1\x18\x34\x58\x63\x31\xd7\xd4\x77\x58\x46\x9b\x36\xd5\x9e\x82\x2a\x8e\x72\xff\xdf\xa0\x46\x98\x76\x36\x9c\x02\x64\x8c\x68\x91\x35\x22\x44\xab\xbf\xcf\xdd\x6c\xc5\xd1\xbf\x59\x1c\xdf\x8d\x51\xbc\x73\xd2\xfb\xad\x2c\x8a\x11\x8e\xd7\x40\x78\x01\xce\xd5\x81\xbe\x86\x64\x84\xca\x9a\x0b\x1b\xe9\xd2\xa8\x6e\x90\x58\x22\x11\xc6\x62\x81\x2a\xcb\x42\x17\xd9\x22\xd9\x22\x9d\xf1\x92\xc4\x20\xba\x08\x3d\xa0\x56\xe7\xce\x37\x11\xc6\xe9\x2a\x3a\x81\x82\xf3\xd5\x13\xea\x1f\xd4\xef\xa9\xdb\xc1\x2e\xb0\xec\xbc\x37\xee\x1e\xf0\x2c\x7c\x64\xe0\xad\xe7\x56\xfc\x64\xcf\xed\x97\x6a\xd8\xba\x62\x4c\x1d\x05\x67\x80\xe9\xa0\x07\x6c\x29\x49\xab\xcf\xfd\xa0\xa1\x5d\x7d\x55\x7d\xf5\x21\xf5\x9a\xfb\x5f\xbc\x17\x69\x24\x40\x9c\x07\x6d\xac\x8b\xa1\x0c\x8c\x10\x9d\x4a\x89\xdb\x10\x00\xc0\x6e\xa0\xa2\x25\x44\x50\x0e\x42\xfb\xd5\x2c\xcb\xb4\xd9\x2c\xf4\x66\xcc\x0e\xda\xdb\x5b\xa0\x85\xa6\xd8\xb6\xa8\x87\xc3\x78\x6d\x2a\x88\x36\x93\xad\x40\xe5\x88\x74\xcd\x7b\x7f\xf9\xe8\xe4\xc9\x77\x47\xee\x59\xdb\x15\x8b\x9d\x9e\xfe\xfa\x85\x67\xac\x1e\x59\x78\x06\x78\x15\xdc\xbd\xe8\xf0\xc3\xff\x7a\xff\xef\xc0\xe0\x8b\x9e\xbc\x21\x18\x7d\xfa\x97\xc7\x9e\x5e\xbb\xe1\x62\x3c\x59\x1e\xd7\x27\x43\xbd\xf9\x63\x5c\x4b\x3e\xa4\xd4\x49\x46\xa7\x60\xb5\x07\x49\x52\x90\x8d\x76\x26\x5a\x02\xb4\xe1\x3a\x61\x86\xe3\xed\x76\x4e\xb0\x72\xd6\x55\x19\xb7\x99\x43\x1c\x45\x31\xbe\x62\xbe\xc9\x57\x84\x4c\x94\x0f\xc5\xcc\xa2\x07\xaf\xf5\x46\x41\x79\x26\x61\x7e\x8c\x05\x5f\xfa\xe8\x80\x7f\x05\xfd\xd0\xa0\x7f\xd1\x2f\x6a\x27\x88\xbb\x8b\x5d\x5a\xee\x2f\x7f\x72\xa0\x58\xff\x43\x19\xc7\xd0\x78\xc6\x65\xaf\x92\x74\x31\xf6\x80\x0f\x80\x00\x63\xa1\x21\xb2\xfd\x41\x3f\x9a\xb8\x4e\xe1\xc4\x65\xc1\x60\x85\xcc\x61\xe5\x28\xa9\x98\x01\xa6\xda\xba\x4e\xef\x5e\x30\xc9\xae\xf5\xa3\x7f\x08\xd1\xb9\x5e\xd7\x82\x4b\x5d\x8a\x69\x9c\xe4\x05\x2d\x1f\x58\x18\x7d\x3a\x47\xd8\x38\x1e\x32\x1f\xdf\x11\x2c\xe0\x59\xd0\x8f\x61\xa8\x83\xef\x43\x90\x66\xd0\x4c\x8f\x1a\x07\x25\x45\x89\x78\xdc\x65\x0a\xb8\xa8\x28\x53\x96\x20\x44\x9e\x17\x21\x5b\xf3\x32\x0f\xd9\x9a\xe7\xd9\x40\x38\xec\x5b\x94\x09\xbb\x59\x3b\x24\x23\xd6\x51\xe0\x8f\xe6\x2f\xa2\x27\xf6\x39\xd1\x8b\xf0\xb2\x44\x24\xba\xda\x80\x88\xbe\xb8\x73\xb9\x76\xa8\xbd\x38\x30\xae\x5c\xf3\xcb\xdf\xec\xba\xbd\xab\xc4\xbb\x30\x7a\xc7\xad\xcb\xe6\x3f\xbc\x71\xd3\xc5\x67\x87\x0e\x2d\xfb\xcb\x89\xf3\x87\xc0\x27\x25\x3b\xba\xbf\xb6\x4d\xfe\xe4\x42\xb7\xef\x5b\x3f\x3c\xe3\xae\xe5\xfd\xd1\xbe\x40\xfa\xc6\x1b\x97\xee\xd0\x7b\xb6\x30\xea\x1c\x9c\x4f\x13\x87\x3c\x1b\x73\x92\x42\xd4\x1f\x35\x91\x74\x59\x02\x40\xf9\x34\x9c\x89\x09\x23\x99\x18\xe5\x91\xd7\x64\xfc\x1e\x81\xb1\x8f\x64\x4c\x4c\xd6\x99\x9e\x3c\x29\x25\xeb\x37\xe4\x42\x03\x93\xea\x50\xe6\xe5\x07\xfe\xf1\x46\xf7\xf5\xa9\x4c\x48\x98\x53\x3e\x7b\xc5\xa4\x89\x35\x28\x87\xa3\xf6\xf5\xbf\x3a\x6d\xa0\xe6\x21\xc9\x37\x32\xc4\xac\x9a\x4c\x7b\xea\x77\xeb\x0b\x70\x6e\x4d\x29\x82\xc1\x0e\x1c\x61\x6f\xd8\x00\xe8\x78\x8c\xd0\xa6\x26\x41\xe3\xa5\x84\x13\x83\x8b\x32\x5e\xd1\x4d\x5b\xfa\x32\x06\xfa\xd4\x30\x8c\x1b\x28\x3f\xa9\x9a\xa4\xfe\x92\x9f\x26\x3f\x59\x92\x0d\xd5\x7f\xf2\xf2\xec\x30\x79\xea\xea\x89\xba\x51\xbb\xf7\x50\x8f\x30\x6f\x23\x9a\x22\xea\xf1\xfb\x25\x10\x8e\x11\xea\x35\xf8\x5e\xbb\xdf\x09\x8e\xfd\xc1\x70\x02\xdf\x37\xb6\xe2\xf7\x2c\xe4\x9b\xc7\xd0\xfd\x0f\x31\x80\x7b\x0a\xd7\xaa\xbb\x89\x17\xc6\x9e\x25\x04\x22\xa2\x08\x8c\xc3\x66\x33\xbf\x0d\x00\x01\x14\xd0\x07\x46\x00\x0d\x50\x97\xe1\x95\x2b\xeb\xd0\x58\x31\xe8\x45\x47\x35\x63\x2c\x08\x8d\xb1\xfa\xa6\x86\x34\x32\x83\x5f\xb8\x3c\x1c\x2f\x0f\x5f\x7e\xd5\x15\x5d\x33\xd5\xdd\x89\xca\x04\xfc\xbf\xf6\x80\x38\x34\x64\x59\xb9\x94\x40\x77\x0e\x46\xa6\x1a\xfc\x96\x7d\x81\xb0\x10\x12\xb4\x0f\xc3\x0a\x17\x11\x45\xff\xb5\x1c\xe0\x50\xbb\x72\x8e\x32\x1d\x03\x67\xc0\x83\x7c\x2e\xb5\x52\x6b\x4c\x27\xe4\x7a\x2e\x97\xc4\xa9\x82\xd7\xb1\x82\xd7\x57\x35\x27\x13\x2d\xcd\x65\xc9\xe6\x4b\x5a\xe3\x89\xd6\xe6\x64\x59\x33\x30\xb6\x26\xb4\x6f\x31\xd7\x24\x9b\x9b\x93\xa5\xad\x2d\xc0\x90\x6c\x6a\x4a\xc6\x5a\x5b\x63\xc9\xa6\xe6\xb2\x58\x6b\x0b\x84\x75\x09\xd3\x43\x1c\x64\x4f\xc2\xbd\x58\x7e\x48\xb0\x78\x65\xd4\xfe\xd8\x20\xc1\xff\xa2\x4d\x09\xf8\xdf\xc1\x3b\xe0\x9f\xc3\x07\xd0\xbf\x77\xb0\x27\x4f\xcb\xfd\xd1\xfc\xfb\x1e\x08\x8b\x83\x7d\x13\xc3\x12\x52\x9c\x22\xc7\xc9\x5c\x35\x77\x88\x7b\x82\x7b\x81\x63\xf3\xb0\xa0\x36\xcf\x85\x70\x14\xbe\xee\x69\x2e\x43\x1b\x2d\x6b\x26\xe1\xde\xf1\x8b\xec\x8e\x5b\x81\x0b\xed\x14\xbe\xc0\xe7\xd6\x01\xd7\x7a\x13\xae\x45\x11\x1c\xe1\x27\xe2\x8a\x08\x04\xc2\xe0\xe5\x04\x59\xa8\x16\x0e\x09\x4f\x08\x2f\x08\xac\x60\xb0\xe5\x56\x74\x3c\xe5\x78\x0a\xae\x0a\xa9\xaf\x69\x8a\x95\x3b\xae\x5b\x30\x71\xed\x76\x70\x9d\x7a\x76\xdf\xc4\x0d\x80\xb1\x76\x75\x0b\x71\xf3\xd8\x0f\x50\x4b\xc5\x87\x29\x82\x06\x34\x81\x28\x01\x42\x86\xa6\xb6\x88\x50\x6a\xa4\x37\x0c\x7d\xef\x48\xff\x92\x91\xab\x0e\xdc\x82\x7e\x7f\x3e\x33\x8b\x38\xca\x3e\x06\xf7\xeb\x78\x84\xea\x03\x90\x80\x20\x19\x55\xaf\x3c\xe7\x79\x74\xc0\x89\xa6\xa3\xf0\x0f\x4b\x3c\xf6\xd8\x63\xa8\x4f\xf6\x2f\x98\x4e\xd0\xc6\x5e\x0f\x75\x7c\x42\x11\x9d\x41\xc2\xe0\x31\x78\x38\x2b\xb0\x1e\x0a\x82\xbe\x20\x50\x82\x20\x88\x3e\xb9\xf2\xf9\x95\x28\xba\x50\xa7\xf5\x93\x46\xda\x4f\x32\xe8\x37\x44\xb9\x90\x61\x93\x0e\x1c\x94\x6d\x77\x88\x81\x50\x49\xfd\xce\x15\x5d\x0d\x99\x86\xf2\x2a\xaf\x2b\xa8\xd4\xef\x5c\x3e\xb7\xe1\xb4\xd6\xf2\x2a\x36\x19\x90\xe4\xa8\x7d\x75\xe5\x85\xf3\x33\x2d\x0b\xda\x63\x01\x6f\xbd\x6f\x75\xc5\x45\xf3\x06\x1a\xfa\x5a\x92\x70\x3f\x07\x20\x5d\x10\xec\x35\x10\xd6\x94\x12\xa6\x38\x0c\x6c\x0d\xd1\x47\x8c\x10\x7b\x88\xeb\x88\xc3\xc4\x93\xc4\x09\xe2\x23\xc2\xac\x10\xc7\xd1\x18\x7a\xb8\x35\x7c\x10\xa8\xa2\xb9\x01\x9e\xee\xb5\x1b\x86\xbe\xfb\x30\xd3\x03\x4f\xe2\x9e\x5b\xb5\x3e\xdd\x1f\xa8\xbb\xc1\x69\x63\x7f\x26\x18\xc2\xf8\x43\xf8\x2c\xd4\x63\x1b\x44\x13\x4d\x69\x03\x38\xed\xd8\x83\x0f\x1e\x7b\x50\xdd\x7d\xe4\xc8\x11\x82\x1c\x73\xc0\x33\xbe\x67\xec\x13\xb8\xae\x40\x88\x8a\xc9\x60\xa0\x15\x0a\x50\x4e\x0b\x51\x8d\x50\xda\x52\x8d\x1b\x27\xc3\x35\x1a\x1b\x98\x02\x44\xde\xf3\xe0\x3d\x43\x1b\xd4\x7f\x67\x99\xa0\xff\x96\x03\x57\x8d\x2c\x09\xea\x64\xaf\xd5\x50\x32\x3d\x60\x79\x16\x1e\x9a\x83\xcf\xfc\x0a\x78\x9e\x47\xf0\x38\xe1\x1a\xa8\x5b\xf6\x91\xfd\x43\x1b\x98\x9e\x6f\xdd\x0b\x9f\xfa\xff\xeb\xb3\x48\x74\xce\xfa\xb3\x38\x22\xad\x94\x5a\xac\x34\x7e\xa0\xf1\x2b\x9e\x58\x07\x1f\xe9\x4c\x17\x3c\x35\x52\xf0\x74\xd5\x5b\xb0\x86\xb6\x10\xfc\x43\xab\x2c\xd3\x01\xbe\x30\xc4\x30\xf7\xa4\x88\x26\x62\xba\x52\xe2\xad\xae\x4e\x0a\x36\x5b\x43\xb5\xdc\x21\x93\x32\xb5\x27\x09\xc2\x49\x25\xd9\x97\xdc\x93\x3c\x9c\x3c\x9e\x3c\x91\x34\x24\xf1\x2c\xf6\x50\x57\x92\xa8\x4e\xad\x3c\x27\xfd\xd4\x4a\xad\x43\x5e\xee\x7e\x32\x01\x09\x59\xa7\x40\x43\xc1\x90\x94\xac\x6c\xd2\x5b\xa0\xc6\x9b\x5c\xee\x9c\xdf\x0a\xbe\xd8\xb5\x3c\x9d\xe8\x3f\xb3\x9f\xdf\xb5\x7c\xf9\xae\x5d\xe9\x58\x2c\x8d\xfe\x9e\xbc\x1c\xbd\xe5\xe1\xf7\x13\xe9\x82\x6f\xb3\xfd\x05\xdf\x5c\xae\x7d\x2f\x1d\x43\xaf\xb3\xcf\xd0\xbf\xa7\xc9\x23\x57\x01\x8c\x35\x8a\x5f\xa8\xb6\x75\xd8\x48\x9b\x77\x0f\x05\xc2\x94\x42\xf5\x51\x7b\xa8\xc3\xd4\x71\xea\x04\x65\xa0\x74\xc0\xa8\x1c\x60\xa7\x86\x68\x8a\x5d\x4f\xba\x3d\x48\xef\xb3\xa0\xee\xff\x29\x7b\x1b\xe1\x24\x84\x87\x6d\x34\x6d\x22\x8c\x58\x2e\x3d\x8f\xd4\x06\x64\x7f\x4c\xb6\xa8\x39\x52\x5a\xd4\xac\xa8\x9f\x0e\x0f\xc5\xdc\x97\x5e\x6a\x29\x89\xcb\xec\x6d\x8d\x43\x1b\xcd\x67\x82\x95\xbb\x2c\xc9\xba\xd4\x04\x7d\x64\x73\x38\xde\x46\x3d\x4f\x15\xae\x8f\x1b\xe1\x68\xce\x04\x30\x6f\xac\xd4\xf4\x91\x21\x9d\x35\x89\xe1\x0b\x54\xa4\x02\x8d\x9d\x02\x7d\xd4\x30\x41\x1d\xc1\xe7\x77\xa9\x37\x12\xfb\xc6\xde\x84\xbc\x89\xe4\x1a\x09\xc8\xac\x5c\x93\x9c\x91\x86\x74\xc3\x3e\xf5\xc0\xaf\xa3\xea\xd1\xab\x1f\x47\xbf\xbb\x00\xee\xe5\x68\x31\x1f\x0b\x98\x8f\x8f\x16\xb0\x31\xfc\xbd\xd5\x90\x8f\x7f\xac\xcb\x4a\x9a\xc0\x2c\x52\x8d\xd9\x20\xcb\xbe\x3f\x46\x2c\xab\x31\x2a\x81\xf8\x40\xdd\x02\x96\xe3\xdf\xe7\x08\x49\x31\x43\x36\xb0\xa0\x4f\x71\x68\x4e\xc0\xf3\xba\x22\x14\xf5\x8f\x46\xf4\xaf\xe8\x09\xe0\xcf\xf9\xe7\x68\x0f\x83\x3a\x4d\xbd\x80\x38\x38\xf6\x2f\xf8\x2c\xeb\x11\x24\x73\x19\x04\x0e\xdc\x27\xd3\xd0\x94\x88\x89\x86\x83\xea\xe3\xbb\xff\x0b\xb4\x5f\xa8\x3e\xd8\x72\xb6\xf8\x64\xeb\x59\x2e\x22\xa7\x07\xff\xb7\xf2\x4e\xd0\xe5\x5d\x70\x9c\xbc\x23\x11\xaf\x41\xcf\x3c\x47\x87\x9e\x6a\xaa\x83\x22\x29\x61\x8f\x0d\x84\x6d\x8a\xad\xcf\xb6\xc7\x76\xd8\x76\xdc\x76\xc2\x06\xf5\x95\x46\x87\xb6\x42\x3a\x3c\x05\xf7\xa8\xec\x94\x6c\x32\x91\x25\xfe\xdf\xd3\xce\x02\x78\x6e\x47\xd9\xa3\x90\x1e\x62\x4a\x80\x26\x40\x0d\x36\x92\xf6\x80\xeb\xc0\x61\xf0\x24\x38\x01\x3e\x02\x66\x05\x1c\x07\x24\x56\x7c\xe3\x88\x85\xe9\x41\xc4\x02\xe9\x0f\xf2\xca\x3e\xf6\x72\xf8\x8c\xa0\xe2\xe4\xa0\x80\xa5\x76\x93\x87\x48\xb2\x8f\x04\x0a\x22\x46\xa4\xf7\xd2\x18\x81\x39\x72\x64\x2f\xd7\xe9\x91\x20\x72\x74\x33\x4e\x27\x4b\xba\x4e\x86\xaa\xe8\x9e\x07\x73\x3a\x79\x74\x2f\x03\x6d\xc4\xff\x95\x9e\x05\x5f\xad\x67\xd5\xa4\xdb\x1f\x2c\x49\xef\x5a\x31\xaf\x61\xa0\x3e\x59\xe9\x73\x05\x3b\xd2\xbb\x06\xe6\x34\x2c\x6b\xae\x4e\xe5\x15\x6d\xd7\x8a\xd6\xee\x69\x71\xac\x68\x2b\x2f\x9c\x3b\xd8\xd4\xd3\xae\xcd\x44\x1a\xab\x64\x76\x13\x2f\x41\x5a\x41\x36\x14\xa4\x15\xaa\x9a\xeb\xe0\x48\xce\xb4\x47\x04\x61\x51\x11\xfb\xc4\x3d\xe2\x61\xf1\xb8\x78\x42\x34\x88\x3a\xad\x88\x1a\xad\xe4\x48\x70\xbc\xd4\x45\xdb\x5a\x9e\xa5\x0c\xf5\x15\x2c\xb0\xe0\x5f\xb6\xbf\x50\x7c\xc2\xbf\x70\xed\x3b\xd5\x0e\x62\x64\xec\x43\xbc\xb6\xa4\xa0\xb1\x6f\xe0\xb0\xe9\x49\x13\x69\x12\x39\x4c\x1a\xe7\xd4\xe5\x07\x6a\x8c\x37\x9f\x56\x67\x6d\x26\x32\x6b\x45\xa9\x77\x6a\x96\x25\xb2\x9b\x34\x03\x0a\x2a\x4b\x15\xae\x01\xb2\x6b\x44\x89\x6a\xa2\x0d\xd2\xa2\x23\x41\x51\x95\x7b\x4c\xc0\xd4\x12\x11\xfd\x69\x11\x8d\xee\x90\x50\x7c\xe5\x39\x9d\xd7\xa9\xff\xc0\xe8\x95\xa6\xd8\xd7\xdb\xd9\x7d\x5d\x92\xdd\x17\x30\x66\x5f\xfd\x6b\xe2\x9e\x0f\xea\x26\x1e\x60\xf4\x3d\x97\xea\x5f\x9f\x9d\x00\x0c\xa5\x7e\x02\x61\xa9\x85\xb0\x68\x36\x28\x7f\x94\x00\xc0\x60\xf3\x0a\xe8\xac\x34\xd1\xce\x40\x2f\x66\xaa\x8d\xa9\x9f\x80\xb9\x8d\x13\x36\xf0\xf8\x35\xd7\xec\x9f\x78\x6c\x70\xad\xd7\xe0\x5a\x49\xfd\xdc\x64\x88\x1d\x53\xc8\xe7\xf3\xfb\x29\x1d\x35\x68\xb9\xf1\xee\x41\xe1\x6b\xa6\x21\x0a\xb7\x12\x15\xd7\x66\xfd\x00\x72\x5a\x0c\xbd\x48\xb4\xaa\xaf\xae\x05\xcb\x57\x67\x71\xd5\x02\xc4\xf2\x26\x6c\x28\xdd\x7a\xee\x55\x57\x9d\x0b\xf9\x71\x1f\xd4\x07\x23\x63\xfd\x70\x5d\xe3\x0f\x4d\x94\x36\x03\xa6\xe0\xc1\x23\x59\x08\xd4\x4f\xf4\x6d\x43\x3a\x0a\xaa\x37\x13\xef\x8e\x2d\xc1\x7b\xb5\x1f\x11\x4d\x26\x34\x48\x45\xbb\xf4\x9a\x0a\x7d\xef\x64\x9f\x03\x5d\x95\xec\x13\x3f\xd5\x71\x51\x5a\x60\xf7\xc3\x67\xf7\xc0\x67\x67\xe9\x87\x3f\x4a\x99\x90\xc3\xc4\x69\xcf\x7f\xae\xee\x3f\x23\x96\x91\x53\x10\xc5\xd4\x24\x80\x65\xdc\xa0\xfa\x2f\x62\xff\xd8\x25\xc8\x73\xfb\x21\x05\xf0\x79\x18\x22\x62\x64\x3f\xe8\x52\x8f\x5d\xa8\xe5\xd2\x43\x9d\x73\x09\xd4\x39\x97\x40\x39\xc4\x1e\x86\x22\x0b\xee\x49\x3f\xfe\x39\xf8\xac\x2f\xc1\x47\x8b\xce\x96\xfe\x15\x31\xc2\x5c\x0a\x61\x11\x15\x1b\xc5\x99\x64\x53\x87\x69\xd8\x74\xc8\xc4\x98\xa0\xdc\x99\xea\xa0\x99\x58\xfe\x38\xd0\x33\x98\xcb\x89\x11\x76\x0e\x7c\x86\xa0\x58\xa8\xb0\x49\x31\xf5\x99\xf6\x98\xe8\xc9\x9e\x90\x85\x90\x79\x37\x07\x10\xa5\xbe\xa4\xee\x02\x95\x63\x9f\xea\xe7\x29\x2b\x0e\x53\x98\xaa\x81\xda\x89\xf2\xfb\x95\x08\x88\xe8\x9c\x5f\x87\x86\xc8\x22\x50\x0b\x9e\x97\x28\xa4\xaf\xc9\xd6\x79\x3e\x77\xb8\xb7\x65\x37\xff\xac\xbe\xf2\xd7\xf5\xaf\x37\x17\xc3\x42\x8e\x10\x23\x94\x0c\xf7\x62\x3d\x42\x1d\x87\xf2\xe0\x14\x40\x90\x8f\x67\x81\x00\x63\xc7\xd4\xfd\x44\x97\x8e\x13\xa8\x91\x31\x8d\x42\xef\xbb\xeb\x3a\x75\xff\xdb\x6f\x43\xbd\x70\x29\x7d\x33\xf9\x53\x66\x01\xfc\xb9\xf3\x61\x92\x62\xa0\x09\x42\x54\xe7\x6e\xbe\x21\xf2\x2e\x25\xa7\x8d\x3e\xc5\x2c\x38\x8a\xf1\x4b\x7f\x41\xec\x87\x38\xa1\xe0\x59\x88\xc4\x13\x14\x90\xa1\xb2\xde\x42\xed\xa6\xfe\x4e\x31\x94\xc2\x8b\x59\x1b\x11\x2e\x91\x45\x3b\x73\xa9\x86\x77\xf0\x8e\x3a\x42\xde\x69\x78\x15\x7e\x56\x38\x0a\x6d\x1c\x86\x46\xd6\x41\xb5\xd6\xa4\x06\xc5\x3c\xd2\x4e\xf0\xce\xa3\xea\x88\x69\xc7\x67\x7b\x75\xdc\x59\x21\xfe\x9f\x85\xf0\x7a\x20\xfe\x65\xd3\x16\xd3\x6e\x88\xfd\x17\x20\xfe\x8f\x81\xb5\x44\xc7\xd4\x08\x5c\x9f\x87\x3d\x8f\x7f\x48\x8f\xa6\x89\xfc\x39\x11\xe9\x24\x71\xc1\xd8\x3b\xe0\x17\xd4\x4f\x31\xce\x23\x8a\x15\x33\x28\xe5\xf5\x58\x79\x96\x38\x06\x56\x13\x1d\x75\xd5\x7a\x67\x1d\x3d\xdb\x36\xdf\xb1\x89\x2a\x78\x0d\xe4\xae\xa1\xa1\xae\x99\x6b\x56\xcd\xee\x1a\x1a\x9c\x3f\x7b\xd5\xaa\xe0\xaa\xd9\x73\x46\x46\xe6\xcc\x5e\x45\xde\x80\xfe\x5d\x33\x73\xce\x48\x96\x46\xff\x05\xf7\x78\x74\xca\x3d\x66\xa9\x83\x3d\x2d\x4b\x0e\x48\xee\x0c\x40\xb9\xe3\x9d\x52\xee\xe4\xd8\xf5\x58\xee\x2c\x88\x0b\xa0\x02\xdd\x4b\x1f\x25\xca\x89\x26\xc5\x5a\x42\x10\x62\x82\xaa\x48\x11\xa5\x65\xb1\x19\x66\x70\x26\x91\x21\xca\xc0\x2a\xc2\x4a\x78\xf0\x6b\x2b\x18\x2e\x08\x76\x6a\x91\x29\x24\x3f\xf1\x25\x60\x02\x41\xd9\x06\x90\x6a\xc7\x2b\xa6\xb0\xde\x97\x81\xcb\x80\x95\x6b\x44\x88\x54\x81\x0b\xfc\x65\xd1\x5a\x63\xcb\x69\x0b\xe2\x01\x8f\xab\x6c\x87\x1c\x4c\xf9\x18\xc5\x6a\x73\x01\x71\xae\x1a\x73\x96\x02\x5e\xae\xee\xda\x34\xb8\xee\x93\x44\xa0\xa1\x9c\xf7\x86\x2e\x9e\x79\x67\x75\xac\xf4\x60\xcd\xb4\xad\x6e\x93\xc5\xa2\xbe\xd3\x72\x54\x8b\x0d\x36\x40\x9b\xe5\x5d\x68\xb3\x98\x08\xf3\x43\x46\x03\x30\x40\x92\x87\x47\x1e\x95\xa0\xc5\xd5\x04\x85\x06\x78\xf7\xbb\xfc\x35\x8e\xbb\xc1\xe1\x37\xf7\xb9\x5c\xfb\xf4\x5a\x9d\xa1\xb1\x77\xe9\x77\xe8\xc7\x88\x1e\xa2\x5b\x71\xfb\x2a\x12\x61\xc2\xa6\x98\xa6\x87\xa5\x9a\xfa\x8a\x52\x4b\x6f\x1f\xab\x2c\x50\x8e\x81\xf5\x8a\x29\x53\x23\x4d\x37\xd1\xd1\xe6\x05\x3f\x81\xc0\x96\x12\x51\x08\xbe\x13\xe1\x17\x35\xca\xd6\x13\x74\x0a\x63\x72\x2e\xd6\xa0\x0d\xdf\x62\x72\xb9\x3a\xa8\x52\x55\x9b\xa4\x88\xbe\x65\x88\xe0\xcb\x5e\x3c\xa5\xa8\x03\xe4\x5b\x45\x85\x80\x04\x1a\x0b\xda\x99\xa5\x9b\xea\xdc\xf4\x3b\x9c\xc5\xe5\xb1\x57\xbd\xd5\x00\xec\x9d\xb1\xce\x05\x6e\xd1\x6a\xee\x28\x1b\x3d\xd9\x52\xdd\xa4\x28\x8d\x21\x75\xf3\x86\x64\xac\x32\x36\x30\x18\xbc\x38\x1c\x6e\x59\xec\xe2\xb9\xc0\xca\x24\xb0\xae\xba\xbe\xbe\xa5\x36\xc8\x92\xed\x2b\x1b\xa7\x51\x1f\x45\x07\x38\x97\xed\x81\x8b\x54\x45\x29\x09\x6e\xea\x16\xbd\xcb\xcb\xc8\x64\xd5\xfc\xc6\xf4\x3a\x48\x67\x15\xe9\xe4\x92\x6a\xef\xf4\xbe\xb5\x33\xfa\x2e\x53\xc4\x8b\xc3\x75\xc1\xe8\x70\x8f\xab\xf2\xbc\x0a\xf5\xcd\xcb\x16\x82\xe5\x8b\xd3\x0b\x2c\xce\x2a\x6a\x16\x3e\x2f\x3f\x14\x74\xb7\xd1\x47\xa0\x9d\xd7\xa2\x58\xd9\x80\x1d\x80\x40\x09\x55\x1a\x75\x5b\x1e\xc5\xa4\xe0\x06\xc3\x0f\x45\xa0\x71\xa9\xbd\x03\xf0\x94\x3a\xc6\xa7\x30\xa0\x3a\x20\x21\x82\x67\x80\x81\x68\x44\x67\x82\x20\x70\xa5\x23\x75\x68\x46\x93\xc1\x0e\x0c\x69\x6a\xe0\xe4\x4f\xe7\x91\xd5\x3e\xce\x59\xd1\xa9\x66\x6a\x5a\x2a\x7c\x7c\x25\x78\x70\xe9\xc2\x12\x1b\xcf\x56\x0a\x3f\x01\xc1\x59\xbb\x7a\x97\xee\xaf\xda\xd8\x3f\x73\x15\x2f\x94\x04\xe6\xbc\x7a\xd1\x5f\x67\xb9\x66\xb9\xe0\xfe\x1c\x63\x1f\x92\x9b\x20\xdd\xd6\x12\x33\x14\xae\xd2\x24\x10\x82\xdf\x46\xd7\xa5\x4d\xb6\x68\xd4\x3b\xc3\x8a\x77\x15\x85\x18\xb4\x11\x76\xfc\xda\x06\x77\x48\x61\x3c\x8e\x6f\xa8\x87\x2e\xb4\xb3\x76\x68\x02\xee\x29\x22\xa4\xeb\xa6\x83\x04\xda\x35\x24\x61\xbc\x69\x11\xe5\xcc\x68\x13\x5e\xe0\xc6\x21\xea\xc8\x4d\x51\xc1\x6a\x67\x9d\x9d\x65\xc1\x45\x36\xf5\xef\xad\x97\xce\x6a\x6a\x20\x85\x8a\x0a\xd7\xda\x72\x49\xf0\x96\x05\xfb\x66\xc6\xac\x9c\xb5\x3f\xee\x3b\xbd\xb4\x9f\x97\x66\xdd\xd6\x5a\xfb\xdb\x4a\x10\x0c\xef\x9a\xf3\x7a\x7b\x99\xeb\xb6\x05\x17\xc1\x67\xb8\xab\xcb\xfd\xed\xfd\x9b\xba\x9f\xd9\xd7\xb3\x54\xbb\x7b\xf8\x33\x75\x01\x3c\xef\x6a\xa2\x5a\xb1\x87\x08\x9f\xb1\xc4\x48\x50\x90\x7f\xe5\x94\xfc\x13\x0c\x41\x0a\x42\xe3\xd2\x20\x98\x48\x83\x88\xde\x24\x9c\x46\x60\xa7\xd0\xa4\xf7\x86\xa6\xc6\x86\x6a\xe8\x05\x35\x65\xcf\x5d\x44\x21\xb6\x08\x24\x34\xea\x02\xb3\xa5\x29\xc1\xd9\x9d\x76\x53\x28\x1c\x30\x04\x8d\x02\xe5\xa3\xa8\xba\xe6\xd1\xc3\xd3\xa7\xa5\x7c\x02\xc9\x4b\xe4\x2d\x91\x24\xf5\xad\x12\x2f\x65\x5d\xb4\xb4\xfb\xe0\x03\xbb\xc3\xa5\x0e\x03\xef\xe4\x68\x9b\x60\x69\xbd\xed\xc5\xef\x2c\xdb\xd1\xba\x72\xcd\xcc\x61\x87\xe4\xe4\xe2\x61\x2d\x66\xb0\x76\xec\xcf\x34\x0b\x71\x51\x49\xcc\x26\xa6\x2b\x7c\xdd\x74\xd1\x18\x20\x08\xe3\xf4\x30\x3d\x67\xee\xcc\x99\xe5\x8e\x66\x28\x21\x1f\x22\x83\xe5\x41\x8d\x5a\xca\xb1\x18\xc9\x95\x63\x15\x5f\x94\x60\x71\xa1\x81\xc2\x72\x14\x06\x44\x13\x2d\x1a\x28\x88\x77\x82\x00\xc3\x22\xe2\xdf\x15\x5c\x68\xc0\x17\xfa\xb5\x44\x3d\x1e\xed\x45\xb3\xae\x6a\x5f\xcc\xc1\x39\x6a\x78\x9e\x97\x28\x9b\xe0\x2a\x4f\x8f\xa6\x6b\x5a\x5c\x11\xce\x65\x97\xc8\x13\x33\x47\x07\xec\x02\x23\x4d\x5f\xe0\x72\x53\x61\x52\xea\xe8\x16\x58\x2b\xb5\xde\x6f\x0b\xcf\x5d\x78\xf3\x8b\xb7\x27\xca\x38\xd1\x6f\x31\xd0\x12\x97\x1e\x39\xeb\x81\x83\xc1\xae\xe1\x8a\x8d\x4b\x2a\xe7\x57\xf2\x10\xdc\x25\xea\x7a\x26\xd4\x39\xa2\xbe\x52\x57\x59\x11\x91\xec\xca\xda\x0f\xe7\xb7\x75\x54\x1a\xb3\x77\x47\x9f\x82\x1d\xf0\x0c\x02\x44\xf4\x11\x03\xe1\x20\x82\x21\x8f\x4d\x43\x9c\x07\x82\x4b\x23\x06\xe9\xc8\x67\xcc\xc6\x5c\xda\x35\x89\x53\xa3\xb2\x1c\x6f\xb4\xa1\xa9\x64\x60\x87\xbb\xd3\x66\x65\x2d\x81\x44\x4b\x65\xba\xdc\xeb\x4c\xb6\xac\x9f\x3e\xe0\xf6\x37\xc0\xdd\x3f\xdd\x90\x72\x66\x16\xce\xdd\xc1\x0b\xa5\xf5\xa7\xe1\x75\xd7\x8f\x7d\x44\x1a\x31\xdd\x24\x15\x9b\xdf\x16\xb5\x21\xaa\x71\x45\x0c\x15\x86\x47\xc1\x7a\xb8\x7a\x45\xee\xb0\xab\x73\x12\x5b\x0b\xd3\xc4\xb5\x46\x75\xe8\xac\x0d\x68\x37\xb9\xa3\x9e\x0e\x9a\x4a\x72\x27\x8d\x76\x44\x1a\xed\x46\x93\x5d\x0c\xf8\xab\x24\x0e\x4a\x97\x6d\x4e\x8e\x09\x18\x8d\xee\x74\xea\x05\x29\x61\x97\x6a\x2f\x98\xd3\x4d\xfd\x34\xa1\xd8\xa5\xfa\xed\x33\x9a\x9f\x7e\xa6\xb6\x26\x2e\x75\x38\x84\x81\xbd\x8d\xa7\x9f\x3e\x77\xf1\xca\xc1\xfa\xeb\xab\xe6\xd5\xda\x85\x78\x06\xef\xf7\x2a\x48\x2b\x49\x78\x4e\xd3\x89\x06\xc5\xde\x56\x61\x70\x78\x1d\xf1\x8a\x2a\x46\xe9\xa8\xb5\x20\x2a\x21\xdc\x11\xb7\x46\x25\x91\x02\x2a\x29\xa4\xf6\xdc\x9e\x0b\xc9\x3c\x9a\xd7\xb1\x88\xca\x83\x05\x64\xa4\xfd\x28\x4b\x44\xe0\x5b\x4d\x71\xab\x25\xd2\x93\xb6\xd3\x3c\xc3\x28\xdd\x1d\x75\xed\x95\x82\xc9\x99\x22\xdf\x88\x79\x1c\xf5\xe1\xf0\xb6\x28\x6b\xb6\xba\xc4\x58\x8a\xea\xef\xdc\xb2\xa2\xed\x8a\xbd\x5d\x4b\xcb\x7a\x9c\x5c\xd3\xf6\x63\xcf\xf6\xed\x59\x38\xbc\x50\x39\xdf\xc9\x25\xc3\xf1\x07\x63\xd6\xf8\xd2\xd9\xbf\xfb\xdd\xa2\xe9\x83\x56\x93\xa5\xb2\x7c\xe3\x0b\xbf\x09\x37\x0c\x20\x7d\x0a\xb1\x42\xaf\x87\xf8\x68\x25\x36\x28\x25\xe9\xfa\x4a\x22\x6e\x76\x98\xeb\x09\x7a\x5a\x1b\x97\x96\xd3\xbd\xe9\xe1\xf4\x13\xe9\x17\xd2\xac\x99\x4e\xa7\x99\xa6\xa6\x9a\x47\xc1\x3a\x08\x6b\x13\x18\x79\xc8\x56\xe2\x29\x81\x3a\x77\xbd\x4e\x31\x0c\x9a\x52\x01\x5f\x33\x58\xb4\xe6\x27\x25\xe5\x4a\x1f\xc6\xb1\x8d\x1d\x50\x11\xd4\x6a\x1f\x01\x99\xe7\x79\x88\x3d\xb1\x10\xd9\x6e\x09\x0b\x64\x3c\xec\x3b\xc1\xe3\x6e\x25\xf4\x7a\x67\xf9\xf2\x51\x3f\x17\x4e\x04\xe4\xee\xc6\x6a\xd9\x4d\xa7\x7b\x2e\xe5\x4c\x2c\xed\x97\x7c\x72\x24\x56\x49\x2a\x55\x15\x4b\xe6\x74\xaf\x9f\x76\xda\xc0\xb7\x36\xb6\x6f\x9b\x49\xde\xdf\x7b\xd9\x21\xf5\xf7\x33\x77\x5d\x79\xf7\xc6\x55\x97\xcf\x9d\xb1\xb2\x7d\x89\x43\x2c\xd9\x5f\x3a\x8f\x09\x95\xed\x6a\x5d\xfa\xe0\x45\xa7\x7f\x6f\xe5\xe0\x96\x8d\xdf\x90\x41\xe4\xb5\xed\xc7\x31\xce\xd3\xe0\x35\xf0\x20\xfd\x20\xb4\x95\x4b\x15\xb3\x9d\x20\xdc\x31\xa6\x34\x14\xe2\x35\x3c\x87\x34\x3c\x23\x81\x9c\x4d\x27\xc7\x2c\x8d\x54\x63\x93\xa6\x3d\xc6\x71\x48\x88\x04\x0f\x96\x0d\x9f\xc5\xd3\xa6\x12\x73\xfb\x99\x42\x55\xab\x3d\xad\x54\x04\xdc\xd1\x25\x89\x8e\x0a\x0f\xb5\x7a\xed\xee\x55\x33\xd9\x6a\x8e\x65\xa3\x9b\x5b\xe3\x65\x8e\x95\xab\x66\xaf\x74\x08\x25\xe6\xf4\x46\xfd\x4e\xee\x1c\xaa\x07\xd2\x5f\x98\x88\x1f\x35\x87\xc3\x7c\x49\x84\x7d\x1c\xac\x81\xea\x8e\xc3\xbb\xf1\x67\x4d\x9c\x7c\x72\xbb\x8b\xe5\x00\x9b\x65\xd6\x42\x45\x86\x84\x10\x54\x0a\x54\x8f\xd5\x1b\xf0\x59\xad\xac\x35\x54\x36\xfa\x59\x65\xba\x4c\x94\x04\x1f\xe9\x9a\x37\xdd\xab\xfe\xd5\x59\xe2\xf2\x7a\x1c\x5e\x7a\x76\xba\x86\xcf\x2c\xec\xda\xce\x0b\x16\xaf\xbb\x01\xf5\x94\x0e\x42\xfd\x7a\x21\xa4\x93\x10\x51\xa7\x98\x4d\x04\xe5\x20\xa8\xb0\xec\xb5\xe9\x56\x97\x17\x6e\x03\x45\x63\xd0\x6b\x2a\x4f\x01\x39\x06\x76\x40\x35\x15\xa9\xd3\x50\x59\x28\x17\xb1\x6e\xa5\x2e\xbc\x63\x74\xda\x3c\xf0\xc3\x81\x33\xea\xd6\x6f\x51\x2f\x9e\xde\xe1\x92\x6d\x6e\xa8\x56\x97\x2c\x9b\x1d\x23\x2f\x51\xb7\x7c\x02\x82\x9d\xdf\x3c\xeb\x92\x0b\x96\x2d\xaa\xc8\x34\x40\xb5\x5a\x75\xf1\x0b\xfa\x1d\xc3\xd8\x3b\xd4\x69\xec\xf5\xc4\x2c\x68\x0b\xda\x9c\x16\x2f\x31\xad\xa4\xc4\x42\x50\x73\x66\x57\xcf\x30\x81\x21\xa8\x49\xa1\xf6\x81\xf8\x42\x9b\xea\xc8\x9e\x53\xc7\x04\x3a\x34\xe0\xb9\xa1\x39\xce\x83\x38\x44\x82\x05\x1f\x1d\xc6\x29\xe2\xc5\xac\x19\x94\xb5\x92\xf0\x47\xb4\xcd\x9f\xe6\x59\xbc\xfe\x96\xd9\x3e\xae\x31\x59\xde\xb8\x6e\x5b\xf7\x52\x7e\x83\x98\x5e\xae\x8e\xd4\x54\xb9\x62\xe6\xea\x80\xd7\x57\x61\x93\xf8\xd8\xb2\xf2\x64\x6d\x32\xd1\x00\x5e\x68\xe8\xf0\x3b\x29\xff\xa5\x3b\x46\x66\x8e\x74\x34\xc9\xf6\x32\x2e\x55\x5f\x9f\x5a\x76\xc3\xfc\xea\x26\x67\xfb\x25\xa5\xeb\x7c\xad\x97\x6c\x5d\xdc\x27\x7a\x65\xde\xdc\xd6\x19\x69\x4b\xb9\xac\xa2\xd1\x15\x08\xb8\xda\x17\xad\x6e\x69\x89\x55\xac\xd6\xe6\xc3\xed\x83\x3c\x3b\x04\xe9\xd3\x47\x24\x88\x36\xc5\xee\x27\x62\x14\x65\x25\xa8\x64\x59\xd8\x24\x9a\x74\x8c\x88\x18\x23\xb1\xf1\x18\x19\xa7\x89\xa9\x08\x85\xc4\x67\x4e\x1c\x65\x51\x62\xc0\xf0\x63\xd1\x15\x69\xa4\x87\x1c\x27\xd7\x92\x82\x52\x11\xad\x9b\x56\x23\x39\x2c\x49\xb2\x61\xcd\xa2\xb4\x74\x6e\x64\xc6\x12\x75\xcb\xbc\x2a\x33\x79\xa7\x9b\xbc\xf3\x2d\x55\x01\xef\xdc\xbd\x68\x49\xd9\xfa\xfe\xd9\xc3\xac\x51\x0a\xd7\xac\x7f\xf8\xf3\xad\x17\x37\xcf\x59\xdb\x73\xef\x4d\xeb\x34\x9d\x53\x3d\xf6\x05\xbd\x04\xd2\x50\x23\xb1\x44\x71\x5a\x09\x07\x94\x9d\x34\x41\x37\x37\x79\xab\xe9\xfa\x7a\x3b\xdc\x38\x92\x2d\xf5\x60\x84\x28\x83\x58\x5b\x8f\x8d\xf9\xe1\x87\x5c\x34\xcd\x68\x9c\x47\x17\x58\x6d\x59\xa3\xa8\xa5\x08\x1c\x52\x23\x33\xaa\x01\x65\xeb\xb8\x58\x6c\x0f\xf1\x4d\xb8\xe7\x69\x56\xc6\x68\x2a\xcb\xe0\x92\x10\x9a\xd3\x75\x3c\xbd\x24\x1e\x1e\x7d\xa8\x05\x9c\x5d\x12\xf2\x0b\x36\xf5\x27\x6a\x3b\xe7\xae\x8d\xae\x1c\xa0\xeb\x16\x35\xb4\xc6\x3d\xbe\x54\x65\x57\x3f\x4d\x9f\xb1\xd0\x3c\xaf\xf4\x85\x77\x48\xe2\x52\xf5\xe3\x8d\x40\xb6\xc6\x5b\x57\x94\x81\x05\x27\x5f\xf0\x89\xa9\x0f\xc0\x25\x7b\xd9\x40\xa4\x84\x1a\xea\x6b\x58\x10\x89\xcf\x6c\x9d\x13\xb4\x0e\x9f\x9e\x36\xeb\xb3\xa9\x1a\xd4\xd3\xc1\x7e\x08\x73\x25\xd4\x77\x26\x91\x89\x30\x04\x55\x5d\x65\x7d\x1c\x9c\x4e\x24\x75\xd2\x4c\x16\xb0\x70\x56\xdf\x41\x0e\x86\x96\x82\xc6\xc8\x28\x67\xb1\x1d\x08\x1a\x69\xa2\x6c\xcc\x22\x71\x09\xd5\xef\x7e\x29\x16\x70\x79\x2a\xab\xbd\x66\x23\x6d\x24\x49\xb3\x93\x83\x76\x7f\x53\x67\x4a\x72\x91\x89\xcb\x67\x54\x50\x8f\xa5\xda\x16\xb4\x6e\x3c\xb9\x9b\x97\x03\xb2\x60\x29\x59\xbc\x75\x64\x04\x0c\x7d\xed\x92\x59\xbe\x60\xb5\x2b\x72\xd6\xe2\xd6\x8d\xbc\x18\xae\x48\xc3\xbd\xf2\x90\xb8\xa2\x50\xd6\x54\x10\x69\xc5\x62\x2f\xa3\x3d\x65\x04\x5d\x55\x19\x76\xeb\x24\x15\x46\x86\x01\x14\xf0\x79\x5c\x14\x33\x39\x34\x81\xd0\xf1\xeb\x33\x4e\x9b\xb4\xba\xcd\x42\x8b\x14\x6b\x41\xc4\x42\x6e\x32\xea\xf7\xa9\xa5\x5d\x90\xbe\xac\x52\x10\x2a\xe9\x0a\xbf\xbc\xa3\xcc\xe5\xf1\x27\xba\x97\xb5\x18\xeb\x82\xd5\x7e\xc0\xbb\x6f\x5f\x05\x82\x16\x8b\x29\xd5\xa2\x84\x3d\xc3\xc3\xe5\xb1\xea\x3b\x67\xef\x0e\x79\xf9\x64\x63\x20\xf1\xe7\x6d\x4b\xd7\x64\xd2\x98\x17\x56\x8f\x7d\x48\x57\x42\x5e\x08\x10\x29\x64\xf9\xc7\xdd\x41\x8e\x70\x73\x54\x65\x85\x90\xd4\x74\x95\x00\xb5\x74\xd4\x67\xf2\x69\x34\x64\xca\x6b\xe9\x42\xcb\x5f\x28\x12\x48\xa2\x8b\xcc\x0a\x03\x34\x3c\x15\x82\xa3\xf1\x02\x0a\xb9\xae\x16\x4b\x39\x7f\x92\x8c\x77\x2f\xe9\x2b\x3f\xf7\xf5\x5b\xde\xf9\x9f\x05\x33\xda\xeb\x1a\xa8\x7e\x4f\x7a\x76\xb7\x7a\x64\xd6\xc2\xfb\xef\x3e\xfc\x18\x6d\xaf\x98\x57\x6d\x97\xc2\x8d\x77\xff\x68\xd3\x2f\xd5\xff\xbe\x7e\xf4\x93\x5d\x0f\x76\x2d\x57\x0f\x74\xac\xec\x0a\x34\x5f\xd7\x7b\xe3\x4d\xf7\x6a\xfc\x80\xfa\x67\xd9\xe1\x79\x0f\x10\xf3\x14\xd7\x2c\xba\x8d\x6f\x94\x6c\x21\x09\xea\x09\x76\x70\x45\xfd\x02\x5f\xc2\x07\x3d\xbc\x07\x33\xcb\x12\xc7\x20\x1b\x4c\xb7\xdb\xec\x8f\xe6\x5c\x83\xa2\xfc\xb5\x49\x0c\x52\x3c\x54\x16\xb9\x06\xb9\x91\xc6\x4d\x25\x59\x19\xa6\x2b\x25\x2d\xbf\x4a\x4f\x88\x71\x6b\x16\x6c\xa4\x0e\x8f\x87\xcd\xa2\xae\xc8\xcc\xa3\xed\xf1\x46\xa7\xe8\x2c\xf5\x9e\xbc\x7c\xfe\xfd\x8c\xa9\xa4\xbc\xc4\x1b\x50\x1a\x82\x52\xcc\x2e\x35\xcd\x69\xab\xf2\x38\x4c\x26\x13\x1d\x77\x54\x4a\x1d\xd3\xa5\x26\xb0\xdf\xe3\xe8\xf1\x84\xa3\xb1\x96\xfa\x84\xd7\x95\x9c\x3f\x6b\x1e\xcd\x4e\xbf\xfc\x67\xd7\x57\xf6\x29\x75\x5c\xfd\x25\x2d\x10\xb3\x0d\xbe\xc4\x92\x15\x6b\x5b\xca\x66\x56\x85\x66\xb6\x27\x67\x24\x1d\x8e\xa4\xbf\xa3\x35\xdd\xc0\x32\x86\x76\x47\xdb\x45\xdb\x16\xb8\x1a\x97\x39\xbc\x2b\x1a\x37\xfc\xaa\xdd\xee\x0a\xce\x9a\xdb\x71\x26\xf4\x42\x1a\xf1\xb9\x75\x41\x9d\x78\x29\x3c\xb7\x69\x84\x02\x6d\x48\x47\xb4\xa5\x85\x4a\x3a\xe8\xe9\xed\xb1\x5a\x78\x60\x47\x32\xb1\x98\x55\x3a\x06\xd6\x3c\x14\x26\xac\xc4\xa3\x05\x81\x00\xa7\x36\x12\xb0\xba\x08\xf1\xc5\xea\xd1\x2d\x3a\xc7\xa9\x4f\x84\xf7\xb4\xa4\x87\x24\x74\x4b\x24\x4b\x1c\x87\x75\xe5\x09\x3e\x39\x77\x21\xd2\xa9\x16\x1b\xd2\xa9\xea\x1d\xb5\x73\x6a\x3b\x9b\x67\x57\x85\xbd\xb1\xa6\xba\x46\x96\x71\x05\xc3\x0b\xe6\x52\x4b\x32\x0b\x67\x9d\x8f\xf4\x69\xf7\xd6\x2f\x5b\x0a\xf5\xac\x7f\x45\x49\x98\x9c\x3d\x7d\xf0\x32\x6f\x55\x45\xb8\x3c\xb0\x2a\x73\xe6\xe1\x19\x1a\x7d\xb4\x43\x9d\xfb\x21\x94\x1d\x2d\xc4\x72\x85\x77\xc4\xa1\xd6\x8d\x57\xb8\x09\xa6\xad\xd5\x1b\xa5\x04\x21\xa4\xf9\xff\x82\x40\xd5\xdb\x92\xf5\x49\x9d\x49\xeb\x27\xd7\xc4\xf9\xda\x8a\x71\x32\xb3\x48\x33\x4f\x0d\x6c\x4e\x45\xe4\x94\xf6\x87\x77\x9c\x7c\x7f\x3e\x49\xac\xc0\x4a\xfb\xb7\x25\x65\x08\xe4\x6a\x19\x81\x5c\x6f\xa2\x5d\xa1\xf0\x59\x41\xe8\x0c\x88\x52\x25\x78\x5d\xd7\xe3\x5b\xff\x09\x82\x33\xaf\x81\x7a\x5c\x68\x74\x46\x20\xc0\x2b\x2e\xf3\x54\x55\x04\x2b\x82\xa7\x9f\x76\x70\xcb\xca\xee\x99\x3b\xb2\x9a\x1d\xfa\x08\xea\x2e\x5a\x86\x70\x2f\x24\x66\x2a\x7c\xbb\xa9\x95\xf7\xa5\xc3\x89\xb0\x8f\x30\x31\xbd\x3d\xad\xf3\x10\x6e\x8f\x56\xcf\x33\x45\xdb\xe7\xb5\x6b\x3e\xc3\xbc\x2c\x7a\x51\x16\x7b\x47\x41\xaf\x89\x82\xb2\x5a\x4c\xe8\x06\x3b\x1d\x44\x62\x4a\xc7\x6f\xa3\xa6\x1a\xf4\x89\xcc\x78\x74\x3b\x0e\x81\x60\xbd\xd7\x48\x34\x15\xd0\x06\xe6\x18\x5a\x76\x99\x18\x23\x63\x36\x5b\x82\xa9\x65\x2f\xdd\xb6\x25\xe6\xf4\x55\x71\x36\xa3\x3f\x19\xf3\x95\x95\xd7\xba\x6b\xbd\x82\x3d\x5a\x3b\xbd\xdb\xd3\x59\x6b\x5c\x00\x6a\x77\xa5\xa7\x37\x89\x7c\x44\xee\xa9\xaf\xf6\x51\x7f\x28\x5f\x68\xa4\x58\x36\xd9\xf3\xdf\x47\x1f\xda\x7f\xd5\x2f\x24\x97\x23\x62\xf7\x92\xea\x9a\x5b\x96\xf7\x8a\x82\xc0\xd0\x72\xdd\xf4\xfa\x75\x6e\xc1\x0b\x28\x72\x5e\x73\xcd\x9c\x2b\x1e\x5e\x5c\xb6\xe6\x3c\xd0\x7f\xc6\xcc\x69\x6d\x3b\xec\x0e\x89\xf7\xb7\xc1\x73\xa9\x85\xf4\xf0\x0e\xa4\xfb\x05\xc4\x1a\xc5\x63\x69\x71\x8a\xf6\x36\x43\x83\xdf\x59\xea\xb7\x13\x06\xb6\x67\x21\xfc\xce\xbc\xca\x88\x76\x24\x95\x50\x64\x18\xa6\xcd\x9b\x96\x3b\xa0\x87\xec\xbc\x53\xb7\x60\x9d\x85\xd1\x8f\x9c\x91\x5e\x98\x35\xc7\xe3\x72\xae\xbc\x21\x6e\x60\x90\xe8\x46\x84\x02\x6d\xa1\x18\x12\x24\x1d\x00\x51\x47\xd1\xf9\xe8\xd2\x3d\x04\xa4\xc6\x22\x83\x02\xff\x8c\x7a\x87\x37\x9a\xac\x86\x40\x78\x68\xa0\x19\x58\xa7\x75\x9d\xfc\x43\x17\x78\x4d\x10\xd5\x0f\xd6\x56\x89\x74\x49\x73\x45\x5b\xa5\xe4\xb0\x4a\xd5\xb3\x67\x39\x9c\xa1\x39\x17\x0d\x5e\x1b\x2a\x2b\xaf\x12\x59\x8b\x18\x6e\x9b\xdf\x42\xa9\x81\x73\xad\xd6\x4d\x37\xec\xfc\x6d\x55\xc4\xf2\x07\xe0\x35\x1a\xb8\x67\xba\xdb\xcb\xcb\x86\x42\x41\x7e\x64\x56\xc5\x30\x2f\xda\xf9\x74\x85\xb7\xa6\x66\x66\x49\xcb\xcc\xa1\x63\x3b\xba\x57\x56\x0f\x98\x8d\x82\x53\x68\x81\xfa\xe1\x1c\x75\x17\x3c\xb3\x23\xd0\xc3\xed\x80\xbe\xbe\x33\x11\xa9\x16\x1d\xc6\x26\x63\x44\xa4\x67\x28\x36\x5b\x47\x29\xb4\x14\x57\x43\x9d\xb6\x06\xfe\xb8\x61\x9c\xa5\x38\xd1\xd7\xc7\x94\xa3\x11\x0e\xf2\xdd\x40\x9d\xee\xf8\x8f\x37\x21\x35\x4d\x8d\xd4\x46\x49\x8e\x69\x80\xc4\x4b\x11\xaf\xcb\xee\x6f\xb0\x1a\x19\xb2\x72\xb5\xbf\x84\x0f\x06\x97\x76\xde\x5b\x67\x6f\x48\x56\xd4\x6f\xd9\xdf\x5a\x97\x6e\xe2\xa4\x86\x59\x6a\xe5\x85\x88\x6d\xd4\x57\x25\xc9\x19\x0c\x52\xc7\x45\x87\x33\xca\x9a\xc0\xa3\x3d\x3b\xaf\xdc\xb6\xbd\xa2\x6a\x5a\xe5\xf9\xb3\x2b\xa1\xdd\x58\x59\xd7\x98\x1c\xb8\x65\x7d\x3c\x19\x3c\xbd\x23\x74\x5a\xcc\x76\x00\x33\x50\xce\xb7\xc7\x3e\x83\x0c\x7d\x06\xbf\xd3\x49\x45\xc2\xd2\xe3\x38\x2c\x4a\x14\x87\x45\x73\x3e\x83\x30\xc1\x49\x70\xba\x0a\xa5\xe0\x05\x85\x5e\x42\x2c\xeb\x3c\x20\x91\x96\x73\x11\x4e\x5e\x59\x1e\x42\x22\x8d\xfc\x19\x14\x69\x70\x0f\x3d\x04\xc1\xa0\x78\xdc\x20\xb1\x58\xf1\xce\x27\xa6\x97\x1b\x67\xc6\x4b\x2d\xe5\x0e\x0b\x11\x67\x86\x56\xda\x22\xe5\x0b\xe9\xe9\x0d\xd3\xa1\x08\x7b\x28\x93\x91\x1a\x90\x86\x8b\xcf\x34\xce\xd4\x08\xd4\x58\xa0\xe1\x90\x8a\x93\x26\xe6\x63\x23\xb3\x1d\x18\x50\x33\x41\x28\x9b\xf4\xa8\x24\x94\x5d\xba\xe8\x4a\x68\x57\xa4\x02\xc2\x44\x36\xf9\x33\x04\x64\x80\x7f\x8a\x7e\x68\x40\xee\xa7\x8e\xa6\x5c\x3f\x7c\xc8\xfe\x58\x02\x30\xb7\x91\xcd\x43\xd3\x17\x37\xee\x1d\xdd\xd2\xd3\x29\xb7\x24\x1b\x24\xfb\xe0\xc2\x69\x3c\x9a\x5f\xe6\x2a\xf1\x8f\xa4\xcf\x3a\xb7\xb2\xa6\xa2\xc9\x6d\x25\x59\x4f\xa8\xed\x5c\x97\xc5\xed\x12\x42\x92\xa7\xe5\x45\xf0\x4c\xba\x67\x79\xba\xcd\x19\x68\xa9\x96\xcb\x6d\x56\x92\x61\x43\x43\xa9\x7a\xea\x83\x69\x67\x6f\x5b\xf0\x9d\x2b\xd4\x7b\x40\x00\x6c\xeb\x3b\x63\xb6\xb3\xaf\xa5\x61\x90\x6f\x6e\x6e\x4e\x0f\xd8\x6c\x4a\xc7\x1b\xea\x5f\x36\x3c\xf3\x87\x21\x63\x77\x7d\xe3\xd9\xe6\x60\x00\x7e\xea\xfc\xca\x15\x76\x5b\xa2\x7c\x93\x3a\x78\xc1\xa3\x5b\x3b\xfb\x44\x87\xc0\x7a\x3a\xaa\xcb\xba\x52\xc0\xc8\x07\x58\xa7\x51\xeb\xd1\x33\xf6\x01\xdd\x05\xed\x9e\x66\x62\x9a\x62\x13\x4a\x2d\x20\x90\x2a\x05\x74\x6b\x4b\x20\x78\x0c\x9c\xf9\x60\x86\x0d\x1c\x03\xab\x1e\x72\x94\xa5\xcb\xb4\x23\x4d\x17\x44\x27\x52\x45\x59\xd6\x8e\x6c\x30\x25\xaf\xef\xb2\xd6\x80\x90\xae\x6b\xc0\x87\xd3\x38\x41\xfc\xd3\x5d\x51\x61\xba\xcd\xc9\x4a\xa1\x19\xbd\xea\xc5\x2d\x9d\x95\x5e\x4f\x53\x50\xfd\xb0\x7f\x50\x36\x89\xa1\x99\x8b\xa6\x4d\x9b\x5b\xe1\x76\xc7\xc8\xbe\xd5\x7d\x15\x2e\xb2\x7d\x87\x7a\x65\xca\x1d\xb5\x96\x6d\x02\xcb\xaf\xbe\x63\x76\xfd\xde\xb9\xbd\xe7\x57\x56\xda\xa3\x3f\x9a\x09\x64\x5e\x2c\xdd\xdc\x3c\x78\x4b\xef\xf2\xfe\x19\xe7\x42\x93\xa9\xfa\x82\x17\xb5\x18\x1d\xa2\xe1\xe5\x38\x3e\xd5\x42\x34\x2a\xb6\x58\x4b\xc0\xe8\xa8\x34\xb6\xd0\x6d\xad\x11\x1a\x81\x56\x6e\xf3\xd8\x30\xa4\x0d\x9e\x63\x08\xb6\xf4\xc4\xd0\xcb\xa9\x83\x56\xff\xdb\x88\x16\xf8\x83\xbb\xd3\x6a\xfb\xea\x28\xd7\xc9\x1d\x93\x87\xbe\x20\x4c\x69\x08\xd3\x08\x86\x49\x81\x58\xe3\x8c\x81\x60\x2a\x1d\x4f\x39\x02\x4c\xe7\x8c\x12\x0f\xfd\x63\x48\xf5\x6d\x90\x0f\x6a\x20\x64\x8f\xe6\x22\x71\xd9\xde\x55\x7c\xcb\x7f\x0a\x19\xf3\x95\xe1\x08\x6a\x04\x82\x62\x35\x98\x7d\xc9\x56\x08\x8a\xcf\x81\x40\x51\xfb\xa7\x0c\x51\x64\xa1\x4c\x57\xf0\x39\x80\x2e\x9e\x3a\x6a\x41\xa2\xf8\x09\xa5\xc5\x4f\xe6\x42\xcf\x5c\xac\x2b\x25\xec\x6e\x93\xbd\xb5\xb2\x94\x9d\x97\x64\x98\xae\x50\xa3\x10\x12\x30\xee\x3a\x43\x79\xdc\xa1\x1e\x51\x69\x67\x81\x33\xf7\x55\x50\x7c\x35\x9c\xa7\x08\xbb\x90\xc4\xff\x25\x22\xf3\x15\xb1\x9a\x76\xf2\x5a\x70\x07\xbd\x89\x70\x11\xee\xa3\x66\x82\x80\x6e\x26\x8f\xe1\x7b\x3e\x77\x3d\x08\x6d\x0b\x52\xdb\x66\x53\x23\x0f\xb7\x0d\xb7\x09\xee\xe0\xce\x5a\xe5\x75\xcd\x32\x59\x59\xfb\x55\x1e\xa3\xd3\x3d\x18\xa4\x07\x5d\xd2\x8b\x87\x22\x36\xa3\xd1\xec\x07\x0d\x8a\xd3\x8d\x66\xd9\x90\xd7\x92\xcf\xe3\x67\x27\xf1\x7d\x9e\x0c\x17\x90\x53\xe5\x86\x00\x9f\xd0\xce\xf0\xf9\xba\xc2\x99\xde\x93\x2c\xc4\x4c\xf2\x3d\xf2\x79\xe7\xb6\xa5\x1e\xa9\xd3\x64\xb1\x8b\x3b\x7c\x46\xc1\x35\x14\x54\x5f\x98\x64\x3f\x0e\xff\x7b\xdf\x96\x6d\x46\x4b\xa8\x02\x18\x67\xf3\x50\x3b\x14\xee\x8f\x17\xe1\xfe\x1c\xd0\x97\x89\x50\x0f\x12\x1c\xf4\x22\xfb\x95\x72\x1b\x6f\x75\x58\x0d\x2c\x63\x77\x72\x0e\x8e\xa6\x1d\x06\xca\x25\x38\x71\x7f\x06\xa7\x93\x64\x38\xab\x81\xe6\x48\xae\x27\x63\x26\x0b\xa7\x08\xe1\xd2\xe5\x9c\x74\xc2\x55\xcc\xda\x57\x48\xf1\xb8\x48\x39\xad\xd7\x2c\x47\x0c\x02\x15\x01\x5d\xea\xd3\x73\x41\xf7\xdf\xc0\xbc\x79\x6a\xdd\xc6\xa5\xea\x23\x7d\xff\xbe\x1c\xb0\xd3\xa6\xb5\xb8\xa8\x33\x4e\xde\x2e\xb4\x4e\xe3\xdf\x7b\x97\xdc\xaf\xde\xae\xf1\x1e\xfc\xc3\x7c\x1d\xe7\xb6\x27\x88\xbd\x4a\x9f\xe4\xf0\x30\xb4\x99\xe7\x63\x44\x22\x14\x90\xe5\xd2\xd2\x80\x8d\xf6\x30\xc9\xb2\xd2\x80\x5c\x22\xf7\x64\x24\x9f\x8f\xef\xc9\xf8\x4a\x12\x21\xb8\x47\x27\x2e\x5e\x31\xf7\x9a\x87\xcd\x5b\xcc\x8c\x95\x4a\x98\x13\x66\xb2\x44\x8c\x6b\x83\xce\x4d\x3d\x19\x86\xc4\x15\xd8\x59\x07\xa3\x45\x1b\x33\x9a\x2d\x10\x29\xf2\xd1\xf0\xc8\xe1\xba\x7c\xbd\x2c\xca\x81\xd7\xaa\x2b\xd2\x4d\x69\x67\x34\x81\x46\xf3\xe3\xe9\x32\x10\xcc\x86\x88\x5e\x9b\xed\xa4\xc8\xf6\x35\xd4\xa6\x6e\xb1\xef\x9a\xce\xbb\xc5\xee\x6e\xf1\xee\xa1\xfe\xb3\x2a\x93\xdd\xf6\x93\x07\x2f\x57\x8f\x5f\x34\xa4\xde\x77\x2e\x59\xf7\x25\xb5\xc8\xdb\xf9\xef\x6f\x19\xd4\x1f\x9d\xa9\xbe\xb2\x5e\xbd\x8f\xa1\x7e\xa0\x7e\xd4\xe9\x79\xed\x35\x3c\xfc\x21\x0d\x0e\xaa\x4b\x50\x4e\xb5\xde\x6b\x0b\xfa\xf8\xad\xc4\x0c\x34\x4b\xb1\x5e\x96\x99\xe9\xcd\x9e\x0e\xca\x16\xf7\x4c\xa7\x98\x99\x9d\x95\x66\xa7\x79\x51\x26\xd4\x41\x77\xf4\x66\xea\x53\x84\xcb\x49\xd3\x84\xdb\xe6\x74\x94\xb4\x11\x6d\xbd\x99\x58\x32\x89\x27\x03\x39\xb3\x02\x57\x2b\x38\x2f\x18\xbb\x31\x7e\xaa\x1a\x53\x12\x47\x6d\x18\xa0\x35\x04\xbd\x89\x06\xdc\x2d\x57\xc2\xa5\x97\x76\xca\x80\x7d\x6a\x08\x2e\x1a\xa2\x94\x60\x41\x09\x9a\xaa\x1a\x04\x9a\x5a\x46\x57\xb3\x51\x97\x1b\xbc\xfd\xfc\x71\xd2\x42\x36\x6f\x5f\x55\x75\x61\x59\xfd\xbe\x9e\x2b\xbe\xdf\xf0\xad\x67\x41\xa4\x74\xe6\x99\x97\x3d\x35\x6b\xee\xe0\xf2\xc4\x8c\x23\xb7\xdf\x39\x7f\x10\x6c\x6f\x1e\xaa\x0c\xc8\xf3\x57\x2d\x54\x46\x8f\x2a\xed\x7f\xaa\x76\xbd\x72\xbc\xbf\x61\xfb\xce\x4e\xde\xb2\xb0\xa4\xbc\xa3\xfd\x42\xf5\x2f\x33\x47\x66\xa5\xdc\xcc\xe5\x99\xc5\xe9\xf3\xfe\x58\x3a\x67\x3e\x35\x12\xf3\xc5\xaf\xe8\xaf\xa7\xc8\xa1\x0d\x4b\xfb\x46\x0d\x97\xec\xbf\x77\x0f\x81\xf3\xce\x1b\x20\x2d\xf3\xb8\xa7\x7e\x18\x52\xcb\x1a\xa5\xc1\x5d\x1a\x09\x06\x6d\x26\xe0\xf1\x10\x14\x55\x6a\xa2\x92\x65\x09\x5c\x5c\x16\x00\x16\xab\xa5\x27\x13\x71\x73\x56\xd9\x4a\x5a\x29\x28\x54\x1d\x5c\xd0\x64\x80\x34\x61\x10\x0b\x3c\x4e\x48\x0e\xfa\xb0\xb3\x82\x03\x2a\xec\x85\x07\xa2\x48\xe3\xe2\x26\xdd\x7a\xb3\x0a\x6c\x4e\xa7\x99\x7a\x4c\x1a\x75\x8d\x00\x5d\xca\xa6\x00\xcd\xaf\x5d\xfb\x47\x75\x54\x35\xe2\xd9\x8c\x7f\xf8\xe8\xf8\xb6\x43\xea\x9b\x43\x1b\xcf\xde\xb2\xfa\x2c\xf5\x97\x2b\xef\xfa\xfe\x62\xf0\x48\xf3\x8e\x6b\x2f\x80\x08\x5f\x39\x00\x66\x78\x3a\xb7\x9d\xfb\xb5\xa6\xb1\xbe\xa5\xea\x77\x4f\x03\xab\xee\xbd\x0d\xc9\xa8\xbe\xb1\x0f\xa8\xdf\x42\xfc\xfb\x88\x2a\x45\x72\x50\x26\x0f\xe5\xf1\x07\x58\x5b\x0f\x2a\xa7\x91\x08\x42\xe8\xc9\x20\xf4\x16\x58\x0a\x59\x91\xa2\x4d\x79\x8a\xd4\xc9\x20\x9a\xc8\x67\xa0\x41\xdc\x19\x58\xf2\xcc\x2f\xd5\x3f\x01\x07\x30\xdc\xf0\x4b\x7a\x91\xb7\xf7\xbc\x1b\xae\xbe\xfe\xf2\xfe\x4d\x92\x6f\x31\x7d\xc8\x05\xc0\x3b\x9f\xab\xf5\x9f\xdd\x95\x7e\xe6\xa5\x9f\xbf\x10\x77\xed\xff\xb8\x53\xe3\xc7\x86\xb1\x51\x3a\x01\xcf\xd8\x08\x4f\xb9\x49\xf1\x33\x2e\xc2\xea\xb2\x7a\xbc\xb4\x28\x89\x90\xfd\x38\xe8\x35\xf3\xae\x9e\x8c\xd3\xc1\x23\x01\xa1\x9d\x5d\x2e\x7e\x99\x93\x72\xf8\x74\xa4\xba\x46\x2a\x8c\x8e\x2f\x85\x9a\x18\xa0\xe2\x3c\x8a\xfc\xc6\x8d\x8d\xbb\xb6\x8e\xfc\x11\x58\x4e\xfe\xe3\xf3\xda\x0f\xff\x8a\x9a\xe4\x3e\xfd\xf0\xa8\x89\x3e\x48\xde\xf7\xde\xfb\x9f\x7c\x40\xe9\x3d\x5d\x0a\xf6\xc1\x43\x6b\x79\xa1\x92\x08\x89\xa2\xc5\x4b\x59\xa0\xc9\x1c\xc4\xcd\x01\x5d\x36\x3b\x3c\x9b\x90\xdd\x6e\xe2\x39\xb7\x88\xe7\x51\x1b\x0d\xa6\xc2\x3d\x8d\x1b\xb6\x59\xd0\xb9\xa0\x70\x53\x1a\x56\x41\x14\xed\xb6\x41\x43\x2a\x19\xce\x6f\x6f\x78\x98\xac\x7b\x10\xee\x18\xee\xfb\x41\xea\xa0\xbe\x45\xd0\x33\x00\xfa\x3c\x9d\xa3\x27\xd5\x87\xe8\x83\x2f\x3e\xfd\xb0\x7a\x18\xc5\x13\x21\x81\xde\x85\x67\xcb\xac\x51\xda\xbc\x3e\x03\x6b\x75\xc1\x33\xe6\x58\x1f\x1d\x0a\x5a\x21\xf6\x10\x25\xf6\x5a\x87\xad\x5b\xac\x0c\xa2\x47\x1a\x15\xb7\x23\x42\x85\x7f\x45\x1a\x35\x9b\xa4\x69\xb2\x27\x43\x73\x1a\x8e\x73\x75\x3b\x93\x76\x58\xad\xad\xe9\xd0\xe6\x5e\x4f\x21\xa1\x86\x87\xa9\x5a\x24\x94\xb6\xbf\x8c\x84\xd2\xcb\xd7\xe9\x42\xe9\x6e\xed\x74\xc7\xcb\xa2\x5c\xcd\x1a\x9e\xed\x1c\x27\x96\x28\x55\x51\x37\xc1\x73\x54\xd0\x44\xb9\x79\x54\xed\xc5\x0b\x02\xdf\x9b\x41\xf5\x1d\x90\x97\x04\x81\x0d\x86\xc3\x9e\xde\x4c\xd8\xc1\x5a\x17\x41\xf2\x74\x7f\x75\xb5\x17\x3c\x74\x3d\xae\xf5\x15\x23\x9c\xc9\xea\xa1\xf3\x4f\xfc\x65\xf9\xa1\xe0\x64\x33\x9b\xc1\x07\xf6\xf3\x4e\xbb\xf1\xc6\x74\x60\xe2\xa4\x66\x8d\x76\x43\xaa\x0c\x37\x78\x90\x30\x11\x22\x51\xab\x78\x1d\x26\x93\xe4\x16\x6c\x8b\x33\x82\xc9\xc4\xf6\x64\x4c\x22\xa3\x69\x06\xae\x20\x5a\xed\xf8\x65\x2a\x6b\x04\x08\xd9\x16\x9d\x91\xc2\x86\x5f\x97\x9e\x09\x3e\x5c\x3b\xa2\xee\x06\xa9\x15\x1d\x4a\x66\xf9\x0c\x65\x80\xea\xcf\x4e\x07\x50\x8f\xcd\x58\x9e\x51\x3a\x56\xa0\x79\x31\xcd\x63\x9f\x90\xef\xc3\xb5\x05\xa2\x5c\x81\x0b\x11\x16\xd1\x65\x84\x74\x6a\x31\xba\xc7\xaf\x9a\x2e\x68\x78\xa4\x2d\x89\x5a\x33\x34\x64\x0b\xca\xc0\xf0\x05\x24\xb3\x41\xbd\xf9\x86\x05\xdd\xb2\xa5\x46\xaa\x9c\x4e\xf5\x7b\x67\xcc\xf0\x8e\xbe\xa1\x3e\x25\xbf\x75\x91\xdd\x35\xb3\x53\x8b\x5f\x43\x59\xf8\x30\x5c\xcf\x4b\x2c\x52\xca\x0d\xb4\x91\x92\x48\x34\x99\x80\x23\x29\x9a\xf6\xfb\x24\x91\xc4\x6c\xe2\x36\xda\xbc\x3c\x67\xa6\x71\x0b\x4d\x9b\x88\x84\x5f\xe1\xb4\xdd\x49\x5a\x5f\x6b\xce\x87\x36\x36\x78\xe2\x18\x6a\x7a\xfd\xf5\x50\xa2\x5c\xb7\x4e\xbd\x41\x7d\x64\xde\xf7\x46\x5f\x87\xfc\x21\xdd\x02\x2e\xe9\xa6\x0e\x76\x7a\xbe\x50\x49\x4f\x27\x38\xd0\xae\xfe\xbd\xa0\x8c\xf6\x5e\x90\xd1\x7a\x08\x20\xfe\xf8\x01\x96\xdd\xbd\x4a\x39\x4f\xb9\x25\x4a\xf2\x78\xb5\x01\x86\xb4\x9d\xe3\x18\x99\xa9\x66\x28\x13\xc5\x70\x0c\x07\xcc\x1c\x4f\x01\x0a\xee\x1e\x88\x39\x07\x22\xab\xbe\xf5\x5d\x17\x48\x1b\x24\x9d\x1b\x0c\xd9\x5d\x8a\x4d\x70\xa7\x5a\x77\xfb\x1b\x4f\xde\x8d\x39\xd8\x79\xfd\xc1\x83\x37\xdf\x36\xa7\xb9\xbb\xd3\xf3\x6e\xd3\xf6\x46\xb0\x0f\xed\xec\x8b\x35\x5b\xd7\xa8\xdb\xed\x4f\xe8\xbd\xa0\x50\x5f\x52\x9e\xa5\xfe\x96\xef\xf1\x87\xdf\xff\x35\xdf\x7f\x0d\xf7\xc1\xd4\x6a\x23\x87\xe1\xfb\x13\x58\x56\x57\x2b\x12\x4f\x59\xb0\xac\xe6\x45\x11\x6a\x1e\xd1\x41\x40\x88\x28\x6d\x48\x1f\x31\x41\x32\x32\xb8\x01\x52\xb6\x7b\x22\x2e\xe3\x6c\x82\x3a\x97\x16\x5d\x04\x78\xe6\x91\x43\xf4\x62\x9f\xb4\xa9\xff\x8a\xeb\xae\xba\xf1\xbc\x5e\xef\x22\xfa\x97\x37\x00\x16\x38\xd5\x77\x5d\x9d\x1f\xef\x77\xc5\x7f\xf3\xd4\x4b\xcf\xa4\xef\xfa\xac\x5e\xfd\xfc\x8f\xaa\x8a\xe9\x7d\x21\x11\xa7\xe3\xd4\x95\x7a\xcd\x97\x95\x33\x89\xf0\x04\x3d\x5e\x9e\xb5\xa2\x6c\xfd\xea\x22\x91\x5c\x97\x0f\x83\x08\x59\x25\x01\xb7\x40\x36\xa1\x3e\x75\x5f\x7c\xf4\xaf\x4f\xde\xb8\xef\xee\x77\xfe\xbc\xff\x01\xea\x4a\xd4\xd2\xee\xb5\x37\xde\xfa\xad\xfa\xfa\x8c\xbe\x85\xd3\xda\x17\xf4\x62\xfc\x2d\x24\x3c\x70\xad\x5b\x21\xcc\x25\x8a\xdd\x23\x98\x08\x1b\x4b\xb0\xfe\x80\xc9\xe3\x40\x09\x62\xb9\xb5\x78\x68\x46\xa1\xb0\x3d\x81\xc6\x66\xba\x38\x80\x93\x01\x74\xb5\x24\x03\x31\x11\x5f\x38\x51\xf1\x80\xaf\x7f\x09\x02\xea\x47\xea\xbf\x27\xaa\x29\x4d\xef\x3b\x88\x00\xbd\x9a\xfa\x26\xe4\xad\x00\xb4\x13\x5d\x8f\x48\x72\xd0\x15\xb4\xba\x48\x7d\x61\x9c\x4a\xd8\xa8\x69\x66\x49\x4c\xe8\x81\x51\x24\xd5\x0d\x00\x5b\x2c\x54\x93\x96\x48\xf5\xb3\x9d\x80\xfa\xf7\xc7\x0d\x9b\x1f\xd8\x79\x72\xf4\x93\xba\xad\x64\x75\x7b\x33\xf8\x5a\x47\xc7\xdd\xef\xac\x57\xbf\x3e\xad\xed\x01\xca\xb5\xf5\xd5\x37\xaf\x1b\xee\xfe\xda\x79\x67\xbf\xf6\xf6\xde\xa1\x85\x7b\xd4\x97\x48\xf5\x24\xd7\x96\x5e\x38\x4d\x7d\x8f\x04\x8c\xbd\xb9\x06\x9d\x05\x85\xfb\x7b\x7c\x0b\xe2\x3f\x04\xad\xb5\x7a\x62\x44\x49\xc7\x3d\x72\x50\x60\x99\x9a\x5a\x8a\xb2\xd5\x78\xe8\xc6\x06\xb1\xbc\x17\x92\x02\x5d\xdb\x9b\x09\x12\x02\x32\xd4\x6c\x4e\x64\xbc\x41\x63\xad\x92\xa8\xec\xcd\xf8\x73\x43\x1c\xf3\x62\x13\xd9\x6a\x85\x17\x37\xce\x34\x1e\x26\x9b\x37\xd4\xea\xb5\x04\x31\x6c\xa9\x49\xb9\x6c\xbc\x04\x2b\x20\x5c\xea\xe9\x51\x25\xac\x66\x9d\x85\x00\x78\xf0\x99\x1f\x91\x96\xa6\x1d\x83\xed\x67\x36\x76\x5f\x38\xfb\x7f\xce\x1d\xf9\xcd\xab\xc7\x5f\x7e\xfd\xb1\x91\x91\xcf\x3a\x16\xd6\x37\x7b\xbc\xcd\xe9\x85\x1d\xea\xc0\x8c\x69\x7f\xe2\x2b\xf8\xdf\xbe\xd8\xef\xf8\xe6\xde\xe9\xd0\x24\xab\x08\x5f\x76\xf9\x3f\xbf\x38\xf9\xe1\xce\xf3\xc1\x5f\xfe\x7c\xe7\xec\x9b\x0e\xfe\xf0\xa6\x39\xfb\x46\x6f\xb8\xf8\x9e\x6b\xd7\xd6\x61\x9a\x9b\x05\x69\xff\x31\xdc\x4f\xa3\x82\x18\x54\x42\x01\x31\x4c\x95\x73\x71\x93\x89\x62\xa3\x5e\x5e\xe4\x8c\x55\x95\x3c\x5b\x16\x0a\x95\xf5\x65\xbc\x1e\x0f\xea\xd0\xc8\x9b\xdc\x5d\x21\x4f\xc8\x63\x25\xac\xa5\xa8\x1f\x63\x14\x85\xfc\xea\xf4\xd8\x26\xee\xe3\x92\x9e\x10\xe7\xcc\x6b\x0c\x43\x08\xe4\xc3\x77\x5a\xc8\x43\xc2\xd1\x70\x74\x23\x92\xa0\xb0\x06\x81\x98\x25\xc5\x5f\x1c\x1d\x5a\xbc\xee\xdc\xb7\xde\x7e\xe3\xed\x73\xcf\x58\x3a\xf0\xa3\x27\x41\x7d\xc5\x79\xe7\x55\xd4\xbb\xf7\xed\xdb\x37\x97\xfa\x85\x65\xfb\x79\x0b\xce\x0b\x7b\x76\x2d\xbd\xf2\xba\x6b\xaf\x5a\xb9\xc3\x15\xd8\x34\xf7\xf4\xb5\x96\x0d\xd6\xf6\xda\x9b\xef\x53\xa0\x6a\xfc\xfc\x91\xef\x7d\x6f\xe9\x6a\x44\xe7\x3d\xe0\x77\xb8\x0f\xa5\x8d\x28\x53\x78\x48\xe4\x06\x9b\x81\xb3\x13\x06\xb3\x62\xa6\x50\x85\x3c\x0a\xd0\xa1\xf9\x13\x75\xc5\xe6\x4e\x54\xaf\xfc\x0a\x3b\x45\xf2\x9a\xce\xde\xee\xe9\xea\xeb\xbf\x7b\x03\x1c\x06\xbf\xfb\xc3\xbd\x77\x7c\x70\xf2\x63\xd5\xc3\xe0\x67\x23\x39\x02\x7e\x47\x58\xd1\xb3\xad\x04\xcb\x30\x84\xcd\x6e\x65\x28\x85\x32\x65\x9b\x52\x4e\x78\x36\x04\x3e\xec\x8c\x68\xec\x8a\xda\x4d\xaa\x4b\x40\x0c\xf1\x24\xf8\xdd\xc9\x8f\xc0\x07\xef\xdd\xfd\xc0\xeb\x9a\xee\x4b\x41\xc2\xfc\x0c\xdb\x6d\x5e\x42\x51\x22\x8c\x24\x59\x08\xde\xc2\xfb\xfc\x34\x9e\x8b\xc4\xb8\xe1\x5f\xc6\x64\xe7\x24\x6c\x2b\x99\x0a\xad\xe0\xd4\x44\x13\x29\x67\xde\x6a\x62\xb5\x4e\xb3\x98\xd0\x34\x9d\x97\xba\x33\x3b\x2f\x5c\x36\x7f\x74\xf5\xf0\x59\xa4\xf8\xea\xdb\xbf\xfa\xf1\x93\xb7\x91\x37\xac\x5b\xae\x6e\x3d\x73\xf4\x15\x4d\xea\x5f\x7d\xcd\x0d\x37\xab\x1f\x7b\x67\x6a\x75\xe5\x22\x94\xa5\x21\x24\x4b\x69\x6d\x9f\xfa\x7b\xf8\x35\x44\x2c\x55\x2a\x5d\xa1\x10\x23\xd8\x7d\x16\x9e\xe3\x2c\x76\x86\x0e\xcb\x4e\x8e\x09\x1a\x83\x3d\x19\x41\xea\xc9\xd8\x8d\x82\x00\x8c\x22\x47\x8b\x00\x1a\x9f\x40\xd7\xa0\x39\x87\x54\x03\x60\xa2\xf6\xca\xaa\x71\x8d\x68\x50\x77\x30\x21\xed\xd5\x9b\x14\xb4\x01\xb2\x03\xb5\xdb\x1e\x3d\xf1\x9b\x5f\xad\x58\x76\xa4\x1f\x64\xbe\x77\xd5\xa6\xbe\xa5\xcb\x17\x9f\x49\xad\xd7\xb5\xfa\xae\xbd\x3d\x5f\x0b\x82\x4d\x2e\x45\x3d\x0f\xd4\xa8\xe7\x0d\x0f\x2e\x1d\xd2\xfa\x36\xa2\xd9\x94\x50\x27\xfc\x43\xeb\x05\x38\xf6\x01\x3d\x0d\xeb\xdf\x34\xb4\x34\x24\x33\x25\x51\x7e\x9f\xdb\x69\xa2\x59\x1a\x6e\x9e\xe5\x08\x5b\x9f\x66\xb1\x13\x05\xed\x2c\x0a\xf4\x40\x71\x7f\xf0\xdc\x1b\x96\xec\x7a\xe3\xed\x75\x60\xec\xbc\xf5\x67\x6c\xdb\xfc\x35\x30\xb0\xfe\x39\xd7\x03\xf7\x93\x1c\xb6\x38\x3e\xde\xbe\x7d\xc3\x56\xd2\x27\xcd\x9c\xe9\x1e\x7d\xff\x9e\x83\x9a\xdd\xd6\x3d\xf6\x30\xed\xa0\x5e\x84\x1a\xc0\xa7\x98\x91\xf4\x27\x1c\x0e\xc1\xc4\x6a\xa2\x31\xdf\x01\xce\x2d\x3a\x92\xc0\x10\x75\xe2\x6b\x60\xe8\xa7\xc3\x57\xd0\x6a\xa4\xbe\x17\xed\x52\xdf\x1f\xbd\xdf\xd3\x49\xee\x5d\x32\x54\x32\x0a\x3d\x13\x64\xdd\x90\xcb\x66\x5d\x7d\xb6\x7a\x72\x08\xec\x9e\xdb\xb9\x60\xc1\x69\x60\xc7\xa0\x7a\x23\x92\x7b\xa1\xb1\x87\x99\xeb\xf1\x5a\xa8\x7a\x04\xd2\x70\xa8\x9c\x32\x95\x53\x35\xb5\x95\x7e\x56\x18\xb7\x6e\x8e\x9f\xa7\x5e\x3d\x56\x60\x66\x39\x0b\x5e\x33\xf1\x49\x77\xf5\xe5\xcd\x73\xeb\xea\x66\xcf\x4a\xd7\xcd\x9d\x5f\x5d\x33\x77\x6e\x4d\xdd\xdc\xc9\xf6\x29\xd6\xcc\x9b\x57\x53\x3b\x67\x8e\xba\xbb\x66\x5e\x57\x2d\x7c\x81\xe7\xb5\xde\x4b\x5b\xe8\xcf\x89\x4a\xb8\x67\x27\x95\xa8\xae\x22\x4a\x4b\x93\x8c\xc7\x13\x0c\x72\x49\xce\x8c\xb6\xcc\xe7\x29\x28\x7f\x62\x2e\x03\xfc\x8b\xf7\x9d\x96\xb4\x9d\xb3\xd1\x48\xc1\x3b\xfd\x35\x3a\xc7\x7d\xd1\xae\x9d\x3b\xb5\x3d\x43\x26\xa8\x5e\x32\x54\x5e\xde\x94\x7f\x93\x18\x9d\x93\x35\x89\xa8\xaf\xcd\xba\x7a\xcb\x81\xe6\xe7\xaf\x1e\x1b\x02\x2f\x2d\x99\xd1\x39\xff\x34\xb3\xf6\xa2\x73\xe9\x69\xe0\xa5\x41\x08\x00\xa4\x35\x02\xd2\x16\x81\xeb\xe0\x33\x13\xeb\xe2\xb5\xfe\xe3\xd4\x08\x7e\xbf\x12\xd3\x40\x25\x94\x2b\x5e\x3c\x3f\x60\x96\x12\xf3\xd8\x24\xce\xe4\xf7\x73\x36\x17\xcd\x84\x64\xc9\x21\x42\x33\xd0\xe6\x81\x7f\x6d\x84\x4b\xe4\x08\x76\x51\x86\xce\x59\x27\xe9\x02\xee\x2f\x6c\xf1\x9c\xb3\xd2\x51\x9f\x23\x21\xdb\xe0\x99\xd2\x66\xd0\x2e\x5a\x7c\x67\x7a\xf3\x25\x9b\x37\xae\x5b\x3e\xfb\xcf\x0b\xef\x4a\xcb\x5d\xe4\xe1\xbf\x5f\xb8\xf7\x6d\x57\xb2\xb4\x3f\xba\x7c\x38\x93\x59\x06\xca\xa3\xb7\x03\xcf\x52\xf5\x15\xfb\xf5\x17\xfc\xd7\x8d\x70\x7f\x67\xc3\xfd\xcd\x80\x32\x35\x49\x4c\x53\x22\x7e\xc6\xec\x91\x29\x3e\xe1\x61\x28\x26\x55\x6e\xe6\xe3\x32\x4d\x88\xa2\x0d\xe9\x4b\xa2\xa4\x37\xc7\x33\x48\x27\x48\x2d\xe3\xf7\x85\x4a\xfb\x9b\xb2\x99\x67\x5a\xaf\x28\xac\xf6\x45\x43\x36\x0f\x00\x1a\x7e\x4e\x96\x34\xfe\xe4\xf5\x3f\xf6\x2d\x5a\xb9\x74\x6d\xcd\xe9\x52\xb4\xfb\xf6\x1b\x72\x6f\xd7\xfa\xa2\xdd\x97\xba\xf6\x6c\xfe\x61\x6a\x2b\xcb\x2e\xea\x9e\xd3\x13\xe4\xbf\x0b\x40\xdd\x9e\xcd\x0f\xa6\xce\x61\xff\x3f\xd2\xde\x03\x3e\x8e\xe2\x7a\x1c\xdf\xd9\x72\xbd\xec\x95\xbd\xde\xbb\xba\x74\xa7\x6a\xb5\x93\xdc\xe4\x82\x24\xcb\xf5\xdc\xc1\xc6\x36\x06\xdb\xb8\x62\x8c\x01\x53\x4d\xb5\x29\x81\xd0\x42\x80\x50\x03\xb1\x29\x02\x4c\x09\xc6\xd4\x24\xc0\x17\x42\x20\xf9\x02\xe1\x0b\x4e\x62\x08\x01\x42\x71\x08\x21\x58\xab\xff\x9b\xd9\xbd\xbd\x3d\x59\x24\xff\xcf\xe7\xf7\x31\xd8\xa7\xd3\xcc\x9b\x37\x6f\xde\xbc\x36\xf3\xde\x68\x86\xa6\x4f\xe9\x0f\x38\x7e\x26\x8e\x66\x09\x5d\x67\xc2\x3a\x58\x08\xde\x8d\x79\xbf\xc1\x65\x8f\x04\xd2\x9a\xaa\x4a\x56\xe7\xe5\xe3\x56\x1d\x18\xd4\xa9\x88\xdd\x68\xa4\x74\xd8\x01\x22\xea\xba\x28\x51\x09\xd6\x04\xdf\x3a\x44\xa2\xf8\xc5\x62\x0b\x2d\xf2\x91\xa6\x0b\x5f\xf1\xd6\x62\x33\x90\xc4\x58\x98\x4d\x2b\xb7\xb6\x36\x36\xb6\x9c\x79\xe2\xc0\x09\x9d\xf1\x48\x75\xcf\xa2\xae\xa5\x85\xec\xfe\xeb\xae\x7d\x28\xbb\x60\x79\xc7\xe2\x89\xd5\x91\x44\xc7\x09\xce\xe6\x09\xcd\xf0\x9f\xfb\xcd\xb3\x9c\xf9\xf9\x27\x5f\x74\xc9\xf4\xcb\x6f\xbf\xf3\x92\x69\xbb\x2f\x5c\x3d\x77\xa2\xf3\xac\x37\xdd\xb2\xdd\x8a\x6b\x7a\x82\x8c\xfa\x0b\xe6\x93\xd1\x63\xf0\xf3\xa7\xcc\xb3\xbc\x86\xee\xff\x87\xfc\x46\x3c\x79\x67\xc2\x01\xeb\x10\x76\x58\x68\xad\x45\x2b\x38\xd5\x8f\x88\xe3\xef\xf0\x23\xe2\xb6\xf1\x1e\x11\x2f\xe9\xa4\xf2\x72\x3b\xc7\xbd\x0d\x7e\xfc\x53\xe0\x58\xac\xf6\x7a\x08\xef\xca\x7a\xca\xae\xe1\x5a\xa5\x7c\x70\xc0\xe9\x15\xc0\x29\x8e\xdf\xd4\x35\x82\x16\x8d\x5a\x68\xfc\x50\x11\xad\xd1\x71\xc9\x44\xc0\x69\xd5\xea\xb5\xf8\x59\x56\x06\x8c\xeb\x08\xc3\x50\x5e\x9b\xde\x1a\x1d\xfb\x60\x5c\x4e\xed\xec\xe7\x8e\x3b\x95\xc2\x31\xbb\x58\xa9\xe0\x9d\x8c\x37\x29\xde\x01\x0e\x03\x48\x1e\xc1\x2d\xa0\x8e\x1b\x0f\xbd\x31\x09\x35\x2c\x9c\x3e\x17\xbd\x3a\x6f\xda\x22\xd4\x30\xe9\x8d\x43\x7b\xf3\xbe\x6f\x9f\xbc\x07\xfc\x05\x71\x64\xcb\x65\xe8\x1e\xe2\xd1\x14\x2e\xd9\x86\x98\x5e\xcf\x6d\xf7\x3c\xf9\xad\x2f\xaf\xf8\xce\xa4\x3e\x47\x80\x1a\xcc\xd7\xf0\x8c\x05\xac\x21\x2f\x13\x0a\x5a\x43\x75\x21\x1a\x3e\x0a\x02\x35\xab\x20\x08\x7a\x8b\x09\xe6\x60\x12\xf0\x7b\xf5\xa0\x8c\xf9\x81\x02\x87\x35\x5a\xf9\x81\x2f\x95\x53\x3f\x19\xd3\x50\xdf\x52\x7a\xf1\x86\x90\xbc\xac\x58\xc7\x1d\xca\x83\x37\xd1\xf2\x97\x70\xd6\xaa\x9e\xbb\xe9\x1d\xf3\x12\x0e\x45\x8f\x1e\xa3\xb3\xcc\x7a\x6e\x09\x89\x09\xd7\xe7\x2d\x5a\x3b\x58\xa8\x0e\xa7\x45\x8a\x01\x1f\x40\x75\xc3\x26\xab\xd5\x40\x1f\x40\x5d\x12\x63\x4b\xea\x36\x27\x73\x35\x3a\x2e\xe2\x9b\x43\xb4\xf8\xef\x56\xe4\x7f\x05\xf9\x26\x88\x67\x2e\xee\x13\x3f\x9a\xfc\xf6\xe6\x0f\xe9\x93\x73\x0d\x36\xfa\x93\x11\x37\x9f\xcd\xf1\x2f\xbe\x40\x4f\x14\xff\x07\xe7\x58\xfe\x93\xce\xb2\xfb\xb8\x05\xb0\xde\x29\x6a\x6b\xbe\x29\x15\x4c\x86\x92\x7e\x83\xdd\x4e\xf9\x43\xf1\xb8\xdf\xcc\xba\xb9\x4c\xda\x2f\xd8\x43\xa1\xa8\xcb\xeb\x8d\x06\x53\x36\xc3\x2f\x0d\xaf\x19\xe8\x45\x86\x53\x0d\x67\x19\x98\x94\x21\x65\xa0\xa3\x80\xd9\xa3\xa0\x6a\x92\x1c\xe0\x58\x87\x71\xcc\x65\xb3\x92\x83\xb8\x64\x49\xc9\x12\xb0\x1d\xc7\x09\x92\xab\x30\x6e\x6c\x17\xc7\xcb\xca\x43\xbb\xe8\xf0\x5c\xfa\xcb\xbc\xbd\x63\xd9\xa2\xcb\xec\x3d\x3d\xf6\xcb\x06\x4f\x5b\x14\xcf\x9b\x46\x52\x5b\xc4\xef\x4f\x9b\x25\xbe\xbb\x12\xfd\xe9\x0f\x9c\x41\x68\xfb\xfd\xf9\x1a\xf1\xaf\x0b\x46\xa9\x45\xe2\xbb\xda\xeb\x3e\x69\x73\x3e\xf9\xa4\xb3\xad\xcd\x89\xb4\x68\x83\x78\x35\xd6\x99\x2e\xa0\x75\x15\xcc\xd7\x06\x96\x42\x84\xea\xcd\x7b\x7c\x6e\x37\xad\x0f\xda\x2d\x16\x53\x90\x66\xa3\x31\x97\xd1\xe7\xe3\x80\xb1\x31\xdd\x1f\x71\xd3\x34\x45\xc8\x9e\x05\xaa\x63\x84\x71\x3e\xf0\x18\xbb\xd8\x51\x32\xc9\xb4\x02\xf1\x01\x5a\x64\x6b\x8d\x91\x62\x91\xae\xa1\x21\x74\xd2\xab\xc3\xcf\x7d\x73\xf0\xf0\x3d\x73\x0b\x89\xc4\xbe\x37\x9d\x97\x5d\x63\xa2\xb3\x6d\x4e\xfa\x72\xa1\xed\xc4\x55\x3f\x8a\x6b\x1d\x0f\xec\x58\xf3\x69\xdf\x64\xf1\x6d\xb4\x7d\xef\x85\x92\x8f\x55\xc4\xd3\x4d\x5e\x09\x2c\xe4\x53\x24\xa8\xea\x8a\x47\x82\x41\xbd\x3e\xce\x30\x99\x74\xca\x62\xe1\x03\xc8\x68\x8c\xb8\x16\x99\x4e\x35\x9d\x25\x45\x55\x31\xd6\xd0\x40\x2b\x31\x8b\xc4\x2b\x4b\x88\xdf\x52\xd4\xa6\x63\x1e\x6d\x94\x22\xaa\xf1\xe8\xd8\x88\xaa\xb6\x7c\x12\x4c\xd5\xfc\xf9\x07\x0f\x8b\x97\x0f\x0d\x49\xb3\x59\x71\xfd\x77\xa5\xb9\x30\x3f\xaf\x5b\xbd\x63\x0d\x50\xb9\xea\x04\xe4\xc0\x53\x3a\xad\xf6\xdd\xd2\x6c\x68\x98\x4b\x1d\xb3\x12\xe6\xa2\x03\x65\xd2\x90\x37\x71\x0e\xca\xe4\x30\x79\xdc\xac\xd3\xe9\x02\x7c\x1f\xd5\x70\x0e\x07\x6f\x53\xd8\x5b\xa2\xf4\x78\xd1\x4b\xc9\xc5\x92\x83\x97\xf4\x29\x1b\xcf\xf1\xcd\x3d\x71\xf6\x73\x1f\xff\xfe\x8d\xb7\xfe\xf4\xab\xa1\x21\xe6\x85\xfb\x7e\x32\xb2\x8d\xb9\x86\x9e\xf6\xeb\x97\x5e\x7f\x85\x91\xc8\x4b\xe4\x01\xa6\x25\x07\xe3\xfb\x41\x1e\xc4\x70\x1c\xd0\x0b\xba\x8a\x0d\x06\x1c\xbf\x34\xbd\x66\xa2\x15\xea\xf9\x59\xb7\x13\x21\x8f\x1f\xb3\xb3\x51\x47\xd3\x5a\x56\x66\x67\x82\x13\x21\x18\xa6\xe6\x12\xf5\xd9\xa9\xa3\x65\xdc\xc0\x1f\x61\x5f\x58\x78\xfa\x97\x3d\xf6\x8e\xa5\x17\x3f\x6a\xcf\xe7\xed\x8f\x9e\x25\x71\x6c\x90\x3e\x95\xa0\x56\xce\xa9\xe5\x78\xf6\xe6\x5d\x56\xad\xd6\xe7\x33\x0a\x34\xe0\xe9\xb5\x39\x1c\x2e\xbd\x05\x54\x2a\xa1\x97\x4f\xc3\xb2\x34\x52\xd3\xcb\x4e\x52\x5e\x6d\xb9\xb2\x4b\xab\xd1\x34\x88\x24\x5c\x13\x96\x98\x45\x39\xa9\xb4\x96\xfc\xb0\x10\x37\x12\x34\xe5\xe3\x8b\x4e\x3b\x4b\xc2\xec\xa2\x65\x1d\xf6\x1e\xfa\x97\x80\x6f\xf6\x93\xeb\xb4\x28\xb5\x08\x51\x0b\x90\x47\x73\xfe\xef\xdb\x84\x91\xad\x4e\x42\xc3\xe9\x74\x94\xb9\x88\x5b\x07\x5e\x42\x73\xde\xe9\xa1\x1c\x1c\x65\xf2\x61\xff\x20\xe4\xf5\xfa\xfd\x34\x6f\xd6\x3d\x85\xea\x61\x79\x69\xd4\x4d\xe1\x94\xaa\x22\x4a\x2a\x7c\x4a\x06\x25\x2e\x30\xa5\x84\xc6\x5b\x9a\x88\x3c\x65\x26\xdd\xf8\xde\xa3\xbf\x7d\xe3\xf9\xe9\x97\x2c\xed\x8a\x4c\x1b\x58\xbf\x72\xd1\x9c\xda\xca\x21\x74\x79\x0f\xbd\xa0\xe5\x8f\xcf\xbd\x76\xd8\x19\xf9\xdf\xb3\x5b\xee\x7b\xe0\xa7\x3f\x17\x7e\x85\x37\x34\xc1\xc9\x0d\xf4\xda\x47\xe8\x35\x37\x1f\xb1\xfa\xfd\x2e\x0b\x2c\x9a\x4b\x1b\x0c\xa0\x75\x96\xb3\x2d\xf4\x22\x0b\xb2\x58\x40\x26\x00\x72\x3a\xbb\x01\x28\xf7\x98\xdf\x45\x6b\xb5\x5e\xae\x44\x3a\x79\x5d\x55\x0b\x5b\xf6\xd0\xc0\x0f\xbc\xcb\x44\x14\xec\xc9\xe2\xf7\x43\xe2\xc9\xb0\x1b\x6e\x1e\x42\x1c\xfc\x3d\x6b\x16\xfc\xc4\xdc\x21\xbe\x8f\xd1\xc3\xeb\xdb\x26\x88\x5f\x22\x1e\xff\x0b\x34\x94\x50\xc6\x7e\x0a\x9d\x45\xcf\x02\xce\x46\x2a\xf6\x18\x6d\x36\xe9\x64\x49\xa3\x1f\x2b\x69\x00\x13\x45\xb6\x90\x31\x93\x64\xa8\xa1\xa2\xdc\x90\xa0\xca\xfa\x8e\x4e\xd1\xa7\x00\x4c\x07\x95\xcc\xeb\x35\x0e\x83\xc3\x29\xf0\x46\xdd\x01\xd4\xfd\x30\x47\xc9\x22\x39\xdb\xad\xf8\x3b\x3f\x10\xe6\x74\xad\x41\x4f\x2d\x16\x7f\x73\xe6\x64\x30\xad\x32\xce\x54\x33\x67\x70\xb5\xb6\xba\xc4\x2a\xf1\x2b\xff\x33\xa7\x99\x6c\x6d\xf2\x58\x98\x47\xff\x0a\x63\x79\xa9\x13\xf2\x01\x2d\xeb\xa6\x75\x0c\x89\x73\x32\xb4\x14\xe7\xe4\x79\xc6\xa5\x63\xcc\x5e\x3b\x9e\x15\x7c\x6f\x7e\x12\x66\xa5\xc5\x33\x23\xe2\x08\xe7\xda\x95\x31\x6a\x29\xc6\x69\x45\x52\x8c\x53\x18\x13\xe3\x64\x1e\xda\x79\x14\xcd\x1f\x10\xdf\x10\x3f\xea\xba\x52\xac\x00\x32\xbc\x72\x1e\x9a\x91\xe7\x16\xb4\x09\xbf\x17\x67\x38\xdb\xd0\xa9\x8d\x7f\x53\xd1\xfc\x1d\x94\x16\x54\xb8\xf2\x80\xab\x95\xaa\xca\x1b\x0c\x0c\x63\xb5\xf1\x7a\x96\xd5\x60\x8d\x0a\x3f\x59\x4a\x5b\x48\x25\x71\xf0\xaa\x2b\xa3\x93\x8d\x4c\x7f\x37\x12\x84\x41\x5f\xda\xb9\xeb\x8a\xc6\xfa\xbc\x9a\xfe\xa6\x3b\xa5\x71\xe2\xa0\x43\xd7\xc2\x38\x1e\x6a\x4a\xde\xc1\xe8\xdc\x76\x9d\xdd\x07\x76\x91\xde\xe8\xa1\xcd\xb4\xc6\x62\xc4\xac\xe7\xb6\x33\x3a\x9d\xa0\xc1\xd4\x40\x12\x35\x64\xfe\x2b\x3d\x6d\xa1\x12\x79\xea\x07\x92\xfc\xa8\x64\x6e\xd0\x42\x85\xf8\xd9\x80\x78\x0c\xf0\xe9\x7e\xfb\x03\x34\x67\xda\x34\x71\xfb\x00\x9d\xa5\x2f\x1c\xf9\x35\x21\xc1\x15\xce\x36\xd1\x8c\x8e\x16\x59\x8e\xee\x22\xf8\x39\x81\x0e\x9b\x08\x7f\xe4\xf3\x0e\x87\x56\x63\xd7\x5b\x34\x16\xc1\xc9\x51\x56\xab\x43\x67\xa2\x6d\x84\x01\x41\x01\x8e\x5d\xaa\xb6\xe2\x52\xb5\x49\xc7\x70\x25\xd6\x51\xe3\x87\xe8\x67\x0a\xc8\x3c\xeb\x22\xb1\x66\x81\x78\x14\x10\x6b\x45\x9b\x38\x83\x73\xc2\x04\xe7\x48\x86\x5e\x31\x22\x2f\x8d\x73\x82\x18\x25\xb8\x84\x00\x97\x47\xc9\x9e\x9d\x98\x77\xda\x69\xaf\x8d\x35\x78\x0d\xc1\x80\xc7\xc1\x1b\x8d\x36\x46\x27\x98\x31\xb1\xbc\x1c\x6d\x30\xe0\xca\x30\xaa\x7d\x2a\x63\x33\x06\x1d\xfc\x9a\x54\x39\xc3\x34\x29\x0f\x0d\xc7\xa7\x89\xdf\x4f\x13\xd7\x03\x4a\xd7\x4c\x43\xdc\x34\x74\xcd\xac\x59\x78\xf5\xd0\x03\xe2\x03\x0b\x54\x0c\x33\x0b\xcd\x5e\xac\xde\x4f\x34\xb5\x10\x64\x5d\x2f\xc8\x3a\x23\xac\x68\x32\x6f\x30\x51\xe0\xd9\x69\x7c\x5e\xab\x5e\x92\x71\x8c\x2c\xe3\xc6\x84\x85\x62\x63\x8a\xe3\x90\x7d\xc5\xf4\x3e\xf5\xcc\xc1\x07\x1f\x7d\xf6\xe0\xf0\xf7\x6d\x93\xf2\x4d\xae\x86\xda\xde\x76\xe6\xd7\xef\xbc\xfe\xee\xff\xfc\xee\xb7\x6f\xbf\x7e\xe8\x8a\xdd\x2f\x5d\x7d\x5e\xfe\x4a\x1c\x87\x81\x31\x2d\x30\x66\x8c\xaa\xa6\xfa\xf2\x2e\xbf\x33\xcc\x54\x5a\x48\x1c\x2f\x66\x73\x5a\xb4\xb5\x35\x19\x9b\xc6\x8d\xe3\x77\x7a\x8b\xa7\x2f\xe8\x0e\xba\xe3\xb0\x5c\xdd\x40\xd1\x7a\xbc\x5c\xa4\xb4\xf6\x38\xaf\x66\xaa\x63\x76\x91\x1f\x08\xd9\x35\xcb\x31\x3b\x74\xe7\x5d\xb7\x0d\x4d\x29\xac\x3c\xf8\x8c\x78\xe1\xca\xf9\xbd\x73\xee\xb8\x1d\xd5\x24\x4f\x3e\x39\x59\xe3\x98\xd9\x79\xe9\xa5\x93\xb8\x75\xfa\x93\x56\xe7\xd7\xf8\x9c\x6b\xfb\xce\x38\xeb\xeb\x81\x55\x36\xd7\xc2\x89\xf3\xe7\xe9\x17\x1b\x1a\x2b\xcf\xbb\xba\xa5\xc7\x38\xb2\x6a\x6e\xdf\x9e\x3d\x43\x33\x60\x2e\x16\xe0\xc8\x7f\x10\x7d\xef\xa5\x3a\xf3\x4e\x29\xf6\x65\x37\xfa\x7d\xac\xc9\x64\x71\x69\x70\xdc\x8b\x58\x57\x46\xa3\x5e\x6d\xa7\x28\x26\x4a\x5b\xf6\xbf\x04\xbe\xb0\x7f\xf0\xfd\xa4\x69\x16\xdb\xf4\xbc\xe8\x1f\x5a\x88\x36\x3c\xfe\xec\xcf\x6f\x9b\x7e\x01\xbb\x6a\xd1\x34\xf1\xfe\x05\x62\x52\x5a\xdb\xed\x67\x9e\x7d\xde\xdf\x8a\x6b\x0a\x38\x31\x37\x93\x3d\x10\xa0\xa6\xe5\xbd\x5e\x86\xd1\x21\xde\x69\xa1\x6c\x36\x0b\xaf\x63\x83\x21\x9e\xf6\x7a\x35\x1e\x3d\xde\xab\x8f\xc0\x4e\x25\x1b\x95\x2a\xed\x85\x9c\xfd\x38\xd3\x8f\xe0\xc7\xc4\x4b\xdc\x17\x01\xbb\xc9\x01\x98\x15\x71\xa6\xd7\xbd\xdb\xb8\x5c\x9c\x3f\xab\x80\xee\x45\x6b\x7f\xfa\xab\x21\x71\xef\x8c\x93\x42\x91\xa5\x27\x80\x06\x98\x3e\x22\x6d\x57\xc7\x84\x3f\xfd\xa2\x51\x04\x24\xe9\xce\xa1\x2e\xf1\xed\x29\x92\x3c\xa1\x00\x57\x81\xe0\x9a\xcb\xf3\x5a\x93\xdd\x44\x31\x82\x93\xb6\xdb\x1d\x1a\x8b\xc5\x81\x11\xd4\x9a\x4c\x06\x85\x72\xa5\x40\x89\x1c\xde\x91\xad\x11\xd9\x41\x21\x5a\x9f\x11\x7a\x12\xb3\x27\x3b\x2e\x1c\xf9\xd7\x95\xb6\x49\xb3\x93\x3d\xdc\x82\x6f\xf7\xf0\x23\xbb\x84\xd6\x56\x81\xde\xc5\xef\xf9\xb6\x38\x6e\x94\x39\x8f\xd8\x9c\x75\x79\xab\xd5\xa9\x63\x9c\x8c\xd7\xe3\xb4\x82\x8e\xb2\x71\x4f\x81\x1a\x31\x42\xa3\x6e\x1c\x2c\xce\xa9\x77\xa2\x74\x86\xeb\x2d\x56\xf3\x2d\x8b\x9e\xa1\xb7\xc5\x0b\x0b\xe8\xb1\x93\x1f\x3a\x69\xd9\x5a\x94\x59\xf4\x0b\x3a\x8a\x52\xe8\x79\xb2\xed\x3a\x5f\x5e\x74\x12\x7a\x0d\xe4\x84\x43\x6c\xdd\x7b\x2d\xc9\x53\xfa\x3b\x1d\x65\x7f\x07\xe3\x3b\xc1\x4a\xe4\xb5\x66\x17\x99\xb4\x15\x39\x1c\x06\x13\x6b\xc5\x08\xe8\x29\x93\xbc\xf7\x14\xa9\xa9\x04\x88\x64\xbf\x0c\xc5\x8d\x20\x3d\xc9\x47\x3f\xa2\x7f\xff\xe4\x2d\x4b\x11\xd7\x25\x7e\xbd\xe6\xc0\x81\xd5\xe2\x9f\x3a\xd0\xde\xe5\xbf\x78\x8a\xd3\x8a\xcd\xe8\x35\x40\xc2\x36\xe2\x40\xcf\x8b\x9d\xf4\x27\xf0\xd9\x25\x36\xa2\xdf\xe0\xb8\x22\xe8\xd2\xc9\xec\x66\xf0\xd9\x93\xd2\xfd\x3a\xe9\x67\xca\x47\xaa\x3d\x5a\xfd\x5a\xbb\x9d\x0e\x9b\xcd\x5e\xfc\x30\x69\x0c\xb8\xa5\xe3\x71\x37\xa5\xe5\xfc\x7e\xac\xc6\xdb\x1f\x76\xda\x40\x8b\x63\x12\x01\x8d\xa4\xeb\x1e\xdd\x63\x1e\xb3\x46\x31\x4c\x9d\x9c\xbb\x45\x4a\x93\x02\x43\x14\xef\x44\x29\xec\x50\x8c\xa4\x68\x51\xf2\x77\x6d\x6f\x98\xfd\x9e\x19\xf1\x7d\xeb\xf7\x4e\x9b\x5d\xdf\xe3\xce\x5c\x7b\x7a\xb6\xb1\x31\x11\x4c\x34\xd1\xa9\x5b\xd0\x06\x4b\xa6\xca\xc6\xbb\xee\x5d\x38\x9f\xa6\x87\x56\x85\xa7\x5e\x2a\xa0\x14\x8d\x72\x93\x73\xf5\x02\xc6\x39\x03\x38\xdf\x0c\x38\xf3\x20\x65\xf3\x79\xab\xd9\xcf\x30\xbc\x4b\xc7\xeb\x82\x01\xc6\x4c\xe3\xfc\xa1\x76\x20\xb1\x11\x75\xc0\xf6\xd4\x00\xb6\x3c\x58\x6d\x5d\x84\xaa\xdd\x78\x1f\xb6\xa9\xac\x20\x99\x9d\xb0\x8b\x6b\x23\xb7\x43\xb1\x8b\x80\x51\x94\x4c\x37\xfa\xe6\x8f\x8d\xfe\x65\xcd\xbf\xdd\xb9\xfe\xd4\xea\x5f\xfc\xa2\x2d\xbb\xba\x2a\xd7\xdc\x45\x17\xd2\xad\xa1\x14\xf2\xff\xe8\xd6\x7c\x83\xc8\x1e\x5d\xb9\xf9\xe8\x8a\x53\xdb\x88\x4f\x13\xa3\x53\x4c\x0f\xe0\x95\xa2\x72\xd4\x04\x6a\x41\x3e\xde\xe0\xac\xf1\x7a\xd9\x96\x56\x9a\x36\xb4\x24\xa3\x4e\x4d\x47\x7b\x5a\xa7\xb3\xb4\xd6\x78\x92\x61\xaa\x82\xb7\x30\x8c\x1d\x04\x45\xc7\x70\xa0\xb1\x31\x5e\xa4\x2b\x66\x78\xf2\x72\x03\xb9\xf6\x54\xee\xd4\x14\x37\x65\x8c\xdc\xa3\xc1\xf7\xd8\x95\xc3\x19\x12\xe0\x29\xbf\x45\xe3\x88\x8d\x73\x89\xc6\xfb\x2d\x6a\x63\x86\xfa\xbb\xbb\x7d\xcb\x9a\x7e\x9c\x5f\xb4\xe3\x17\xed\xeb\x6f\x88\xd7\xb7\xe5\xdc\xe9\x2d\x73\x97\x57\xb6\x7d\xd8\x30\xc9\xe8\xad\xee\xa8\x4e\x89\xb7\xa7\x13\x97\xfa\xe9\xd4\xb1\x86\xc8\xaa\x01\x5b\xad\x2d\x30\x7d\xc6\x3d\x3d\x33\x93\xf4\xac\xda\xb6\xf0\x94\xdd\xae\xca\x6a\x9a\x4b\x99\x4f\xe8\x0e\xd3\x4c\x5b\x67\xae\x5e\x6c\x1b\x38\x71\xd9\x2c\xc2\x4f\x06\xba\x9a\xde\xc2\x5d\x01\x7b\x29\x88\x7d\x21\x5e\xab\x0d\x52\x9e\xa0\x27\x14\xd6\xfb\x9f\x81\x55\x60\x28\x01\x56\xc7\x44\x59\x51\xb5\xbc\x22\x63\x0f\x02\xf0\x99\x93\x8d\x14\x5e\x03\x36\x02\x89\x43\x2e\x0a\x49\x47\x4f\xe8\x85\xe6\x6e\x77\xb3\x2d\xd5\xda\xd1\x26\xee\x9a\xf0\xb1\xc6\xb3\xa8\x6a\xc7\xc6\xab\x2f\x38\xf1\x29\xe6\xa4\x0d\xab\x0d\x46\x71\x96\x7e\x33\x7d\xa6\x25\xfd\x7a\x6b\x9b\xc3\x7f\xf1\xb5\x57\xdf\x99\x91\xf9\xfd\x22\x6e\x37\xf0\x7b\x15\x89\x07\xf9\xe9\x34\x3a\xca\x6e\x81\x9f\x53\x04\xdf\x30\x9d\x42\xdf\xc2\x9a\x39\x81\x97\x72\x79\xbb\x97\xd1\x70\x1e\x8f\xc3\x61\x62\x98\x40\xd0\xcb\xb2\x06\xfe\x29\xe0\x23\x41\x11\x0c\x6d\x75\xc7\xbd\x49\x5f\x3a\x2c\x93\x6f\x35\x09\x7c\x5a\xa2\xf6\x77\x9b\x57\xa3\x4c\x20\x3f\x61\xc2\x8c\xd0\xe9\xb5\x97\x5d\xf4\xaf\xaa\xe0\x05\x40\xd2\x1d\xe7\x37\xe8\xe7\x9f\x50\x61\xab\x75\xf8\xf6\xde\x28\xbe\xd7\xb9\x7c\xd6\xe9\x72\x9e\x47\x00\x70\xf9\x12\x70\xa9\x04\x1f\x44\x88\x33\x6e\x43\x86\x0f\x69\x0c\x8c\xa6\xaa\x3a\xac\xb1\x99\x03\x01\xa7\x19\x23\x93\x54\x21\x63\x6f\x2b\xf7\x89\xa4\x23\x88\x26\x55\xa1\x5b\xd9\x0f\x71\x37\x93\x5a\xb7\x69\x0d\xde\x8d\xb8\xd8\x2d\x0a\x9d\xb5\x7b\x6a\x53\x7b\xe3\xee\x73\xd6\x4d\xaa\x12\x62\xf9\xc6\xe6\x4a\xcf\x1c\x5f\x30\x18\x99\x33\xf9\x92\x99\x43\xb1\xf5\x74\x6a\xe1\x50\xd7\x64\x23\x2b\x74\xd7\x4e\x9a\xe6\xda\x33\x33\x50\x5f\x55\x51\xa3\xd3\xf6\xeb\x3d\x03\xa7\x84\xeb\x7d\x61\x8c\xaf\x00\xf8\x7e\x02\xf8\xe2\x38\xab\x2f\xea\xd4\xa5\xd3\x09\x27\x6c\x46\x4d\x65\x55\xc2\xec\x0f\x59\x32\x46\x6b\x9f\xc5\xe2\x0e\x61\xa4\x35\x2a\xa4\xab\xc6\x60\xed\x90\xe3\xbf\x38\xe0\x4d\xae\x69\xb8\x65\x39\x51\xf6\xcc\x00\xfe\xfb\xe3\xde\xf5\xb1\xa1\x99\x97\x4c\x9e\x13\x09\x06\x7d\x73\x3c\x95\xcd\x8d\xf9\x98\x50\x35\x69\xdd\x39\xbb\x73\x1d\x3b\x2f\xa6\x53\x61\x5f\x7d\xf8\x94\x01\x8f\xbe\x5f\xab\xab\xa9\xa8\xaa\x0f\xcc\xdc\xe3\x9a\x36\xa9\xb6\x5b\x60\x83\x1b\x87\x16\x4a\x71\x07\x1b\x8a\xd3\x33\xd8\x7b\x80\x8a\xf5\x54\x07\xb5\x2c\x5f\x3d\x81\x76\x24\xed\x54\xa3\xb9\x2a\x9c\xf2\x7a\xcd\xe0\xbf\x84\x35\x5d\x9d\xb1\x8a\x0a\x57\x83\x0e\xb4\x3a\xcb\xf3\x79\x93\xb5\xcf\xc5\xbb\x78\xae\x36\x70\x00\xd5\x3e\xdc\x62\x00\x49\xd8\x41\x75\xbf\x20\x49\x69\x7c\xa0\x48\x4c\x7e\xdb\x58\xed\x49\xa6\x56\xf4\x08\x5b\xdc\x5a\x99\x89\xb5\xf8\xad\xf8\x6c\xd9\x21\x23\xd7\x58\x85\xe4\x23\x72\x26\x5b\x3a\xbf\xbe\xfc\xd4\x8b\xb6\xa7\xa6\x59\x76\x0b\x93\x92\xe7\xef\xc8\x56\x5a\xe9\x8a\xf0\x85\xaf\xdd\x79\xdd\x8e\xdd\x5d\x35\xd1\x46\x74\xfb\xcc\x67\x9a\xa6\xe7\x97\xcd\xdb\x8f\x8b\xb3\x55\x26\x93\x0c\x5d\x73\xfe\x89\x27\x1a\xb8\x89\xbe\x13\x6b\xfa\x4f\x5a\xa1\xad\xb1\x87\x7e\x7a\xf2\x86\x29\x9d\xf1\x26\x9f\x69\x72\xfa\xb9\xb6\x54\x43\x2a\xd5\x81\x2e\x99\x34\x79\x72\x3e\x3f\x79\xf2\x24\xcc\xfb\x01\x64\x43\x93\xd8\x55\xe4\xfe\x0a\x78\x56\xf2\xfd\x15\x0d\x36\x5a\x24\xcf\xaa\x5d\xf2\xac\x5e\xc8\x1e\x77\x67\x25\xee\x56\x59\x84\x85\x4e\x94\xe9\x6c\xfb\x78\xb8\x25\x95\x6a\xca\x65\xd2\xcd\x6c\xbd\x25\x93\xb1\x88\xad\x96\xcc\x8b\x99\xc6\xc6\x4c\xaa\xa5\x59\xe2\xef\x08\xd8\x4d\xf7\x73\xbb\x41\x2c\x4f\xcd\xdb\xcc\x3a\xa4\xa1\x78\x5e\x10\xb4\x1a\x1d\x78\x56\x2e\xcf\x01\x54\x0d\x38\x98\x05\xc1\x42\x31\x46\xc7\x53\xd8\x91\x00\x53\xb4\xbd\xa8\x0e\xe5\xc8\xc9\xd8\x67\xd3\xb1\x90\x00\x15\x2a\xbf\x61\xa3\x18\x2b\x39\xa4\xfd\x63\xc7\x1f\x7a\x76\x3f\x97\x13\xbf\x8c\x9e\x3e\xb9\x45\xfc\xa8\xa9\xed\x63\xa6\xe7\x4b\x73\x26\x63\xbe\x52\x7c\x01\xe3\xf7\x62\xfd\x75\xf8\x1f\xfa\x13\x0b\x96\x13\x76\xb0\x49\xfe\xc8\x6e\x05\xb9\x50\x43\x70\x8d\xa1\x6a\x7a\x11\xf0\x76\x8c\xea\xc9\x5b\xec\x1c\xe5\xf5\x86\x42\x06\x8e\x49\xc4\xc3\x51\xa0\xcb\x23\xf0\x53\x00\x93\xc9\x6a\xd4\x3d\x85\x3a\x49\x60\xa0\x43\x0a\x0c\xc8\x36\x4b\xd9\x65\x24\x2c\xa0\xc7\x54\x41\x26\x7a\xd0\x56\x42\x97\xdb\x31\xe5\xfa\x9d\xeb\x1b\x73\x69\xaf\x85\x8f\xa4\x12\x99\xda\x9a\x9c\xf8\xd7\x96\x96\xf7\xd8\x5c\xfe\x6e\xb1\x7f\xd3\xd9\xc6\xdd\x93\x4c\x43\x53\xd1\xbe\x8e\x3a\xa7\xb8\x18\xe3\x8d\x7e\x45\xf0\x8e\x82\x7c\xab\x24\x78\x67\xa4\xfa\x27\x74\x02\xfd\x83\xdd\x08\x96\x7d\x45\xde\x68\xa4\x1c\x60\xd9\x7b\x7d\xbc\x49\x8f\xbd\x65\x8f\x8b\x21\xac\x2b\x85\x05\x4a\xd6\x8d\x43\x25\x63\x9b\x94\x17\x9b\x00\x3f\x7f\x70\x79\xfd\xf5\xd7\x5f\xb7\xab\xff\x94\x2a\x6f\xb2\xb5\x79\xca\xcc\xc1\xf9\x2d\xec\x24\xb7\x6b\xef\xf5\x97\xff\x44\xb8\x67\x85\xff\xec\x53\xb6\xaf\xb6\x49\x6b\x5b\xc1\xcc\xa4\x1b\x80\x5e\x66\x7c\x2b\xb9\x74\x8e\xcd\x18\xa4\x11\xc7\x3b\xc0\x8e\x4b\x47\x13\xe8\xbc\x68\x73\x4d\x72\xff\x59\x97\x5d\x7c\x36\x33\xf3\x8c\x2d\xcb\x2f\xbf\xea\xc7\xd7\x5d\x23\xc1\x84\xb9\x35\x30\x33\x41\x5d\x00\x4c\x7c\x7e\x4d\x71\x16\xb3\x89\xd3\x33\x44\x57\x8e\xbd\xe9\x8c\x0f\xae\x73\xd2\xe9\x26\xdd\x70\xe1\x85\xa3\xd4\xfe\x54\x75\x73\x94\x99\x79\xc3\x1e\x94\xba\xf4\xc4\x6d\x5b\x24\x3b\xd9\x8e\x6a\xe8\xb3\x00\x4f\x7c\x1e\x0c\x2b\xeb\x37\x50\x26\x93\xcd\xc5\xd9\xb8\x70\xc4\xee\xc4\x2b\x6b\xb2\xd9\xac\xcf\x20\xfc\xd0\xb7\x0e\x46\xf1\x28\x0b\xab\xac\xab\x62\x3b\x60\xca\x95\xee\x45\xb8\x4b\xbc\xe7\x68\xc4\x6b\x0b\x98\x7c\xdb\xbb\x70\xdb\xa6\x0b\xce\xcd\xe7\x99\xd9\xe2\xf3\x9d\x9d\x7f\x79\x7b\x4d\x5b\x6d\x73\xfd\x29\xec\xd4\xea\x4b\xaf\xbb\xea\xa7\xfc\xc4\xab\x08\x03\xbe\x66\x4d\x8b\x9f\x7e\xe8\x16\x17\x98\x89\x7e\x4a\xa1\x9b\xd9\x8f\x60\x3d\xeb\x88\xbe\xb2\xd1\x71\xfa\x12\x76\x15\xfc\x5c\x41\x68\x12\xa4\x39\x7a\x19\x7b\x16\x70\x5c\x2a\xcf\xdb\xc0\xbb\xd5\xd1\x6e\x8f\xcb\x6a\xb5\xeb\x38\xce\x5e\x3c\x0d\x2d\x33\x5d\x01\x3f\x7c\x8c\xd8\xa4\x1c\x22\x36\x45\x5b\x72\x02\x1d\x06\xbe\xba\xc9\x9a\x46\x17\x65\x5b\x9d\xe2\x22\xf8\x30\x62\xc9\x30\x37\x6c\x9e\x79\x4b\xeb\x91\x4a\xcc\x7d\x1f\xb6\xbc\x8b\xc7\x73\x80\x4d\xf3\x1e\xc8\x88\x4a\x6a\x76\x1e\x3c\xf5\x68\x26\xe8\x02\x39\xe1\x72\x72\x19\xae\xba\x2a\x1d\x0b\xb8\xad\x06\x03\x97\xf0\x9a\x80\x74\x8f\x86\xed\x76\x06\x69\x9f\x02\xb2\x65\x24\xdf\x02\x5b\xd2\x92\x7b\x21\xf9\xb6\xc7\x3b\x70\x69\x62\xaa\xc4\x63\x8a\x49\x2d\xbd\x81\x54\xfa\xa1\xf4\x90\x35\xa5\xdb\x3c\x73\x45\xfc\x9c\xa1\x1b\x5a\x91\x27\x37\x50\xdd\xa8\x69\x43\x9e\x6c\x3f\x88\x20\xe4\x69\x69\xa1\xb3\x8d\xf9\x69\xd3\xee\x46\x2b\xad\xe9\xb4\x55\x7c\x64\xad\xd7\x9e\x51\x3e\xbb\xd1\x6d\xe4\x53\xab\x35\x2d\xdd\x11\xa0\x80\xaf\x56\x11\x9a\xd6\x13\x9a\x56\xc2\xcf\x6b\x81\x27\xd2\xe0\xcd\x59\xfc\x21\xbb\xc0\x1a\x52\x86\x54\xa6\x82\xd5\x81\x50\xea\xc8\x1b\xa3\x56\xab\x2e\x11\x22\x67\x6f\x12\xe7\x49\xee\x81\xe4\xd6\x49\xa4\xb6\x93\xa3\x8a\x71\x0e\xe0\x94\x42\x49\x9a\xd2\xf9\x1b\x6d\x6a\x9b\x9c\x0c\x47\x62\xd3\x5a\x1b\xaa\x13\x82\xc3\x9f\x6c\xac\x18\x6c\x5f\xb9\x74\xde\x69\xed\xb3\x62\xad\x15\x7e\xbb\x2b\x51\x47\xa7\x82\xa9\x48\x24\x11\xb6\x9c\x3d\xcd\x14\x6d\x9b\x7f\xe6\x84\xc1\x15\xcb\xe6\x4c\x38\x63\x41\xb6\xc2\x34\xed\x6c\x0b\xb6\x81\x51\x2d\xdd\xcd\x5d\x4d\xd9\x71\x76\x45\xde\xe7\x85\x79\x18\x4d\xa6\x88\xce\x11\x02\x1f\x2a\x82\xd8\x44\x32\x82\xdf\x87\xf0\xf3\xbf\x04\x8c\x05\x8a\x43\x35\x14\x02\xae\x96\xea\x41\x8d\xe3\xeb\x11\x39\x10\xb7\x35\xaa\xf5\x6d\x34\x96\xc6\xac\xac\x11\x6c\x92\x48\x48\x83\x7d\xf3\xfb\x7d\xe7\x5e\xb2\xfe\xc2\xd9\x93\x1e\x15\x3f\x6a\x08\xdd\x34\xad\x3e\xea\xab\xe8\x6a\xbd\xba\xb7\x1e\xd5\x32\xfd\x7b\x76\xaf\x3f\xb1\xff\x34\x8b\x26\xf1\xc4\x97\x06\xfa\xb2\x9b\x16\x2e\x1d\x79\xc3\x38\x77\xf9\x13\xda\x09\x68\x90\xf8\x3f\x47\x61\xef\x65\xd8\xd5\xe0\xa1\xd6\xe6\x79\x9d\xc5\xe6\xa5\x03\x01\x2f\x6b\x61\x43\x41\x16\x09\x58\x8c\x1a\x01\x47\x22\xf0\xed\xe5\x27\xb1\x4c\x53\xce\xe5\xce\x91\x0a\x0c\xf0\x09\x8c\x42\x7c\x34\xac\x4d\x83\xf6\x4c\xd1\x69\xf3\xcb\xf3\x72\xdc\xac\x44\xdd\x5e\x63\xe3\x8d\x1a\xcb\xb5\x7e\x93\xa1\x62\x4b\x98\xed\xce\x7c\xf2\xfc\x73\x73\x9b\xea\xf5\x69\x63\xa2\x6b\xad\xf8\x6c\xec\xb1\x89\x3a\x7b\xf3\x2d\x15\xe7\xa3\xd6\x4e\xa2\xfb\xe8\x24\xdd\x05\xba\x28\x04\x9c\x9d\xcb\x3b\xb4\xde\xb0\x33\x69\xb1\x64\x5c\x5e\x27\xf0\x75\xc6\xc6\xa2\xc0\x53\x60\xa2\xc6\xc0\x5e\x50\x02\xbe\xe5\x32\x5d\x31\xad\xc2\xa8\x74\x67\x48\xc9\x32\x43\xc5\x0b\x6f\xe0\x5b\xa0\x91\xb4\x90\xa8\x4d\x65\x2a\x6b\x5b\x87\xda\x7f\xb4\xeb\x9c\xab\x9e\xab\xca\x6e\x5b\x39\x71\x99\xf8\x72\x6b\x6d\x5d\x4b\xdb\x94\x78\x25\xfb\xb7\xe9\xbe\xaa\x58\xac\xb7\xa2\xa1\x6f\xfb\xd0\xce\xab\x76\x9f\x71\xef\xc2\xd4\xc9\x75\xfd\x0b\x1d\x23\xf7\xad\x5a\xb2\x78\xc1\x94\x8d\xb9\xd0\x16\xec\xab\xa1\x0a\xfa\x10\xf0\xa9\x17\xf0\x9a\x94\xb7\x9b\xf4\x5c\x84\x02\x4b\xda\xe7\x72\x21\x8e\x89\x27\x90\x17\xaf\x75\x90\x72\x80\xc4\xd2\xa1\x8e\x47\x22\x56\x2b\x2d\xf1\x2b\x30\x6a\xb7\x5a\x29\x29\xbe\x4f\x5c\x32\x15\xb1\x41\x88\x8d\xc4\xd2\xf2\x93\xea\xa2\x82\xad\x0b\xa1\xab\xa7\x5f\x7f\xc3\x45\x97\x64\xab\x3a\x7a\x67\xcd\x5c\x79\xe6\xed\x7b\x77\x85\x93\x1d\x3d\xdd\xa8\xe2\x98\xf1\xba\xdd\x17\xef\xe5\x5b\x9c\xa7\x6e\x38\x7d\x8b\x0e\x2d\x9e\xbf\xfc\xfa\x5d\x57\xde\x66\x44\x35\xdb\x36\xec\x14\xef\xd6\x6d\xc1\xfe\x36\xe8\xd0\x29\x20\x3b\x82\xe0\x6f\x3b\x03\x94\x9e\xf5\x38\xcc\x56\xab\xc3\xe6\x33\xd2\x2c\xa5\x0b\x85\x83\x4f\xc2\x9a\x6b\xf1\x8a\x77\x8f\x91\x0b\xb6\xe6\x16\xa6\x16\x3b\x00\x40\xdd\x66\x90\x56\x80\x50\x08\x81\xd5\x01\xfb\x4b\xa3\x8d\xaf\xd9\x7e\x9e\xa5\xca\x79\xa6\xe0\x9a\x3b\x3f\xf2\x48\xff\xf6\x1b\x0d\xee\xe0\x6a\xa7\x77\xc3\xac\xf6\xc7\xd1\xcc\x97\xfe\x81\x0c\x01\x9e\x49\x3b\x9a\x9f\x7f\xa6\x3f\x7e\xcd\x37\xe2\x4b\x0e\x97\x06\xd8\xf8\x5f\x0f\x5c\x4b\xf6\x7e\x74\x74\x26\x9a\x46\xdf\xce\x6b\x19\x10\x06\x23\x3e\xf2\x9d\x1d\xbe\xfb\x17\xba\x86\xd7\xd2\x5b\x95\xef\x6c\xa3\x9d\xf4\x25\x68\x17\xb4\xab\x50\xbe\xa3\x46\xf3\xf4\x2a\xf2\x5d\xbd\xf2\x5d\x46\xec\xa3\xbb\xe9\xfb\x79\x2d\x77\x76\xf1\xbb\xd1\xa3\xe2\x54\x3a\x83\xce\x83\xef\xce\x91\xbe\x83\xb5\xab\x14\xa7\xd1\x39\x74\x1d\x28\x94\x04\xae\xaa\x10\xd6\x53\x5e\x1b\xe8\xb3\x64\xca\x7e\x00\x4d\x7d\xc4\xc0\xc4\x40\x6e\xf6\xc1\xce\x60\xd0\x14\xd9\xe2\xe9\x2e\x8b\x04\xb6\x90\xdb\x5e\x3c\x88\x96\x38\x50\x22\x44\xbb\xe3\xb5\xa8\x0e\xd5\x22\xa4\x2a\x03\x5b\x79\xde\x2e\xa4\x3b\x76\x5e\x8e\xd5\xf4\xae\xdb\x3e\x98\xa6\x2b\x35\xcd\xbd\x53\xf6\x9e\x83\x16\xc6\x9a\x6a\x52\xa9\x9a\xa6\x58\xed\x81\xfd\xe2\x1f\xc4\x77\x57\x2c\xec\xb2\x58\x52\x53\xf2\x66\xab\x46\x63\xf9\x15\x4a\x6e\xdd\x7e\xe2\x15\x97\x2d\xdb\x22\xbd\x17\x2b\x4e\xa4\x0f\xa1\x2b\x01\xf7\x5d\xa5\x79\x8b\x53\xe8\x29\x78\xde\xdc\x79\xca\x7c\xc2\xa3\x1f\x73\xaf\x31\xcf\x83\xcc\xac\xc3\xef\xc9\x55\x6b\xab\x74\x7a\x7d\x32\xec\xf3\x25\x79\x2d\xdb\x50\x9f\x22\x0f\x8f\x54\xe9\x06\x0a\xae\xaa\x2a\x0f\x15\xe4\x3d\xb1\xa1\x02\xe8\x29\x87\xc3\x3c\xab\xe0\x70\x31\x99\x81\x02\xc3\x97\x15\x08\x92\xaf\x87\xb4\x8d\xbd\x1f\x22\x9f\x54\x48\x49\xc4\x51\x29\xec\x28\xbf\xd6\x81\x5f\xd3\xf3\x96\x9e\x95\x03\xb5\xc1\x01\x29\x72\xe0\x8b\xd1\xa7\xa0\xd9\x33\x16\x1f\xbc\x5f\x74\xd4\x9f\xb6\x74\xc1\xc5\x2d\xfb\x67\x6f\x7b\xbc\x67\xed\x87\xe2\x63\xe4\xee\x4e\xdf\xe0\x3c\xf4\x45\x47\xfb\xbb\xf6\x2a\xe6\x01\xf7\xab\x7f\x18\xe2\xaf\x3b\xa7\x37\x78\x42\xb4\xaa\x67\xee\x2d\x28\x45\x4f\xf6\xf4\x8e\x9c\x31\x6f\xf1\xaa\xc5\x74\xd8\x63\x3a\xff\xae\x8b\xd7\x35\xe2\x73\xe4\x03\xa3\x9f\xb1\x11\xee\x4a\x2a\x4a\xd5\x50\x43\xf9\x0a\xb3\x91\xae\xa8\x88\x7a\x62\x0e\x8f\xa3\xb6\xce\x0c\xee\x41\x15\xcc\xd4\xc5\x78\x43\xda\xa8\x11\xfe\xf0\x14\x9f\x1c\x2c\xf0\x3c\x90\xaa\xbb\x74\xf5\x10\x27\xfd\xe4\x94\x22\x6e\x6d\xc5\xad\x48\x0c\x89\xa8\xe0\xce\x76\xa1\x96\x1c\xb8\xf1\x9a\xa2\xcf\x4b\xc7\x63\x49\x5b\x1a\xfc\xe1\x38\xfc\x46\xed\x1a\xef\x40\x51\x87\xc3\x6d\x35\x9d\x62\x5c\x3e\x9f\xd1\x64\x7e\xdc\xf7\xea\xd3\x5f\xbd\x77\x87\xf8\x2b\x67\xcc\xa7\x3f\xc5\xb8\x6c\x01\x7d\xde\xa2\x35\xa9\x85\xc1\xfc\x92\x15\xcb\xb9\x2b\xdf\x62\xcc\xa1\xc9\xd7\x5e\xa0\x5d\xd4\x12\xad\xf9\xf0\x9b\xaf\xc5\xbf\x4f\x62\x0b\x6c\xcd\x94\x6b\x2e\xd4\x1d\x7b\xe2\x89\x07\x6c\xb6\x91\x06\xfe\x90\x64\x1b\xe1\xb7\x11\x1f\x87\x39\xa6\xa9\x2c\xb5\x24\x5f\x5f\xe3\xb6\x98\x28\xca\x97\xc8\x68\x13\x5a\x30\x4c\x13\xfd\x85\xb4\xe0\xb7\x3a\xc3\xee\x38\xfc\x31\x78\x28\xca\xc4\x1a\x0c\xf5\xe4\x1d\x9f\xaa\xc1\xf2\x77\x7c\xda\xe4\x0b\xd4\xca\x8c\xd5\xb3\xc5\x89\x8b\x38\x65\x4f\xf5\x32\xa0\x3c\xc7\x26\x15\x15\xa4\x8b\xf1\x38\x0a\x63\xc3\x13\xa7\xdf\x6f\xed\x98\x59\x8b\xdf\x06\x5c\xb7\x41\xe3\xc0\xf3\xd4\x2d\x2f\xa0\xa8\x53\x22\xc3\x89\xf3\x56\x8b\xd7\x8b\x17\x2f\x5d\x30\x38\xaf\x7f\x70\xe1\xca\xa6\x84\xdb\x22\xbf\x0f\x38\x99\xa9\x99\x72\xe5\xa5\xba\xb9\x12\x15\x2e\xd4\x1c\x9b\xe5\xe9\x45\xef\x3d\xf5\x62\x15\xfd\x82\xf0\x22\xe8\xa4\x2f\x61\xe2\xcf\x70\x77\x50\xd5\x38\x5b\x8d\xaa\xae\xd6\x24\x93\xb5\x35\x15\xcc\x20\xae\xc7\xa2\x8f\x27\xe3\x83\x05\xa3\x2f\x64\x89\xda\xe1\x8f\x4b\x93\xb4\x3a\x3c\x2e\x4f\x7f\xc1\x25\xa8\x0a\xc1\x15\xa7\xa9\xbe\x6d\x6f\xcb\x65\xe5\xd7\x68\xe3\xb1\x20\x22\xcf\xd1\x82\x31\x90\xc3\x7a\x55\xb6\x12\xf1\x8c\xb1\xab\x1e\x6f\x6a\x91\x7d\x75\xfa\x9c\xa0\x27\xbd\xf2\xe0\x41\x67\x75\x42\xdf\x33\x7f\xfe\x8d\x23\x1f\xae\x72\x64\x32\xfa\x9e\xb9\x0b\xf6\xec\x79\xe1\xf1\x15\x13\xd9\xfd\xeb\x3c\xa3\x97\xae\x11\x1f\x60\xda\x9b\xae\xb9\x50\xfb\x11\xc9\xe7\x5a\xcd\xe4\xf2\xb0\x92\x6f\x4f\x4e\x9f\xfc\xec\x6b\x8e\x0f\x25\x1f\xd7\x4e\x51\x9a\x9f\x33\x2f\x52\x8d\x54\x9e\x9a\x4e\xdd\x94\x1f\xe4\xaa\xfc\xfe\x89\x91\x48\x65\x8b\x20\xf0\xd4\xf4\x64\xb2\x92\xaf\x9c\x39\x23\xd7\xd0\x5f\xc8\x59\x93\x11\xbf\xc0\x57\x66\x2a\xfb\x0b\x13\x0d\x4d\x4c\x6b\xab\xa7\x7e\x7a\x6d\x6d\xb4\xca\xc7\x24\x12\xd3\xad\x1e\x93\x89\xa3\xa6\x7b\xe0\x0f\x13\x72\x64\x84\x8e\xa9\xcc\xd4\xa1\x82\x96\xe1\x4b\x69\xb6\xd2\xfc\x6d\xd8\x3d\x23\x77\xda\xdc\x6d\xd9\xe2\x07\xe9\x6e\x4c\x4e\xae\xb0\xd2\x56\x52\x3c\xf6\xd2\xf1\x06\xce\x9f\xc7\xe1\x2b\x9b\x00\xd4\xd1\xc8\xfe\x50\x93\x16\x97\xc8\x97\xe8\x54\x0a\xf4\x02\xbd\x9a\xa5\xf3\x18\x57\xbb\x1c\x46\x74\x09\x5c\xd6\x2d\x7d\x14\xd0\xc3\xd2\x45\xb7\x2b\x45\x9f\x6e\x99\x73\xdd\x52\xb1\x66\x8e\xc3\xb1\x79\x17\xfe\xf7\x8e\x55\xf6\x79\x62\xcd\x62\xaf\x1e\xbe\x5f\x8c\xd6\xd1\x33\x7e\xba\x96\x27\x37\xe1\x46\x3e\xdd\xb2\x0b\xdf\x84\x63\x16\x4a\xd7\xe9\xee\x70\x87\xce\x1c\x12\xff\x84\x09\xfb\x1c\xf2\xff\x91\x10\xb8\xaa\x4e\xbc\x9b\x7c\x70\xb8\xc3\x3b\x86\xd0\x80\xa7\x57\x9c\x5e\x7b\x88\x5c\xb8\x1b\xf4\x4f\x9a\xb3\x34\xfd\xa8\xec\x57\x50\x14\x7b\x06\xd0\x3c\x4d\x35\x50\xdb\xf2\x9d\x19\xca\xed\x8e\x07\xaa\xec\x76\x8d\x39\x60\xce\xe6\xac\x39\x64\x64\x52\xb0\x83\x52\x56\xb7\xdd\x1c\xf0\x05\xfa\x0b\x9a\xaa\x2a\x53\xd0\xe5\x8a\x83\xc9\x46\x65\x1c\xf0\x87\xe1\x7d\x02\x53\x37\xa4\xc8\xc5\x22\x69\xe5\xfc\xc7\xac\x9c\x6a\x47\x08\x5a\x7a\x2b\xbf\x28\x23\x65\x6a\x46\x08\x25\x2d\xc5\x4c\x8a\x26\x50\x98\x25\xfa\xc1\xce\xc2\x04\xc4\xaa\x54\x8e\xc3\x02\xd1\x4e\x47\x2c\x50\xc6\xd0\xd5\x86\x49\x35\x6b\x6f\x0f\x26\x95\x5f\xbb\x4c\xdf\xdd\x06\xb4\xe2\x87\xf6\xe6\xf1\x5d\x47\x4c\x21\xf1\xd3\x7b\xfd\x91\xf6\xb3\xab\xc5\xef\x31\x3d\xde\xb6\xb4\x79\xc4\x57\x09\x65\x3c\xf8\xeb\x1a\xd4\x0c\xa4\xf9\xa9\xb5\xd5\x75\xf3\x9c\xa5\xa4\xfe\x00\x3d\x7a\x50\x9c\xc9\x46\x80\x26\x49\xaa\x96\x5a\x94\xaf\xab\x32\x1b\x80\x2a\x51\x4f\x8a\xe3\x3c\xf5\x75\x89\x58\x7f\x21\x61\x35\xfb\x42\xb0\xb1\xe0\x8f\x07\x3c\x31\x1d\xad\xab\x19\x2c\xe8\x5c\x74\x66\xb0\x40\xf3\xe5\xe2\xe4\x3f\x49\x13\xd4\x5c\x14\x97\x69\xd0\x11\x8a\x04\x81\x69\x17\x05\x0b\xe1\x1b\x5e\xf6\xca\xd0\x8d\xa7\xde\xf8\xc2\xc1\xff\x7b\x63\xed\x69\x1a\x59\x8a\x9e\x34\x47\xfc\x40\x92\x9d\x27\xcd\x5d\x8d\xce\x46\x2b\xf7\x2d\xe9\x9f\xb5\xe0\x41\x66\xe7\xb4\x8f\xfe\xf5\x4f\xf1\x7b\x7f\xef\xd0\x44\x56\x12\x1f\xb9\x61\x90\x27\x3f\xba\x50\xc3\xdc\x09\xb3\x6d\x44\xdb\x52\x23\xed\xd2\xbb\xc3\x2c\x6c\xbc\x13\x99\xdf\x50\x29\x6a\x6d\xbe\xc3\x48\x39\x9d\x31\x2f\xcd\x22\x33\xeb\x65\xd3\x19\x93\x63\xa8\x10\xf3\xc3\xff\xbe\xa1\x42\xd8\x64\xb4\xc6\x62\x56\xa3\x29\xcc\xb9\x93\xe4\xc9\x3a\xab\xd3\xeb\xf6\xf6\x17\xdc\x82\x81\xd2\x4a\x7b\x0b\x47\x3a\x4a\x15\x39\xdc\x58\x75\xd4\xe1\xa7\x65\xa5\x99\xe3\xa5\x2f\xae\x38\x4e\xde\xb5\xc5\xf1\x2c\x85\x1f\x12\x30\x78\xe6\xaf\x9d\x76\xff\xd4\xe6\xd6\xf6\xee\xdb\x3a\x65\xe1\xf2\xe3\x91\xff\xd9\x21\x0b\x97\x1d\xe8\x72\xfa\x93\xed\xa7\x88\xf7\x9d\xd3\x92\x7c\x58\x12\x2d\x52\xaa\xe8\x42\x49\xb4\x7c\x29\xe5\xd3\xc0\xfc\xe8\x37\xc9\x3d\xfc\xbe\x7c\x5c\x63\xb5\x06\x9d\xce\x78\x22\xa9\x75\xf9\x0c\x41\x0b\xfc\xb1\x47\x22\x58\x66\x46\x78\x2b\xc9\xd7\xb3\x0b\xea\xec\x23\x95\xf6\x2b\xd9\x34\x8a\x74\xfc\x01\xc4\x49\x64\x5b\xa0\xaf\xc1\x42\x51\xc6\x7a\x95\x68\x5f\x4d\xb0\x9e\x3f\xdf\x74\xe8\x17\x2b\x26\xd2\x6f\x82\x44\xdc\x3a\x0e\xce\xfb\x1e\x05\x51\x88\x28\xdd\xe8\x67\x0c\x0f\x38\xe7\xa8\xea\xbc\x9b\xf2\x35\x35\x66\xa2\x5a\x2b\xcb\x04\x83\xc9\xfe\x42\x90\x67\x4c\xea\x57\xd0\xe4\xdb\x9f\x4a\xc1\x13\xd5\x93\x5b\x8d\xa9\x44\x3a\x86\xa5\x4f\xaa\xec\xf9\x30\xa9\x82\x15\xe8\x27\x10\x5c\x2e\xfa\xd3\x43\x07\x66\x3e\x5e\xd7\x9b\x8a\x6f\x6a\x9f\x3f\x77\x48\xfc\xac\xae\x89\xef\xe5\x7a\xf8\x67\xae\x5f\xbd\xaf\x37\x12\x3c\xa5\xae\x6f\xf2\x09\x27\x5f\x9b\xed\xb5\xf7\xb2\xcd\x02\xaa\xfc\xc9\xed\x51\x3b\xa2\x2e\x8c\xd7\xcd\x98\xd0\xdc\xbb\x00\x75\xee\x19\xa8\xef\xda\x75\x43\xf0\xab\xf5\xc1\x64\x7b\x2e\x3b\x31\xdc\x30\xe1\x9c\xc1\x46\xe2\x33\x1d\x19\xfd\x8c\xbe\x9d\x3d\x0f\xf8\x6a\x76\xbe\xca\x65\x0f\x85\x8c\x0c\x93\xce\x98\x05\xfc\x1e\x9a\x9b\xd3\xfb\x8c\xd6\x60\x38\x48\x5b\x98\xa0\x31\x68\xa4\xf8\xbc\xd5\x6e\xa5\xa2\xb3\x4a\x37\xc1\x7d\xaf\xa9\x12\x99\xb2\x4a\x72\x62\x91\x81\x48\xaa\x07\xa1\x38\x8f\x55\x11\xf6\x4e\x15\x65\xc5\x6b\x95\x97\xd1\xd0\x63\xbb\xaf\x75\xa4\x22\xfa\xb9\x8f\x9f\x75\xf5\xd6\xeb\x5f\x7a\xc9\x99\x8c\xea\xe7\x1e\x68\xae\x6e\x3a\x21\x74\xb5\x73\xc7\xe6\x23\x4c\x63\x37\x32\xdb\xfe\xb7\x27\xfd\xf6\xdb\x6b\xc4\xfb\x98\x5c\xa7\xf8\xa5\x79\xa8\xa7\x97\x9f\x2b\xc4\x30\xef\xc8\xf7\x87\xa9\x2a\x6a\x56\xbe\x4a\x6f\xaa\xa9\x8e\xf9\x22\x11\x1f\x6c\x7f\x4b\x5a\x67\x67\xa8\xb0\x2b\x62\xa5\xc2\x14\x4c\x02\xd0\x86\xcf\x26\x23\x63\x64\xf0\x43\x8d\x72\x7d\x45\x69\xf3\x4b\x12\x0f\x2b\x98\x5c\xc9\x82\xc2\x3e\x77\x5a\xab\x24\x22\x3a\xa4\xfd\x4e\xc3\x22\xb5\xc8\x17\x76\xa3\x02\x43\x66\x63\xa1\xe9\x96\x50\xf8\x9c\xeb\xdb\xce\xf1\x35\xf5\xf9\x8f\xfd\xf9\x0f\x96\xae\x26\xae\x4f\x97\x5b\x7e\x42\x20\x7a\xfe\xa9\xad\x6b\x9c\xe1\x3e\xfa\xdd\x77\x2c\xed\xcd\xf0\x65\xe3\x89\x68\x82\xf1\x53\xbf\xf3\x1d\xf1\xd6\x1a\x74\x35\x6a\x6f\xdd\xb0\xb1\xdb\xf8\xb5\x83\xbf\x19\x79\x1a\xc4\xf5\x68\x42\xf3\x86\xcd\x1d\x58\xcf\x3a\x47\x3e\x62\x7e\x43\x72\x18\x1b\xa8\x4e\x62\x05\x47\xda\xe9\x94\x83\xb2\x37\x99\xd3\x5e\xaf\xd9\xee\x88\xd3\x11\x6d\x77\x17\x9f\x1d\x28\xc4\x2b\x2a\xdc\x94\x51\xc7\xf0\x6e\xde\xcd\x05\x83\x75\x83\xc0\x80\x5c\xeb\x40\x41\xcf\x05\x94\xf7\x5f\xe5\x7d\x22\x19\xbe\x55\xe3\xf8\xe7\xc9\x62\x35\x76\xe5\xa5\x1a\x77\x0b\x2e\x77\x10\xb1\x35\x16\x23\x78\xf8\x2c\x1c\x97\xe6\x28\x3e\xb9\xa3\x4e\xbd\x1a\x7d\xf8\xdd\x57\xaa\x76\x87\x0f\xc7\x37\x75\xbd\xfb\xca\xc0\x74\x0f\x3b\xb5\xfe\x3d\xf1\xbe\x33\x3e\x7e\xe0\xd5\x0f\xfb\xd6\xb6\xcf\x1e\x99\x76\x2e\xea\x5c\x70\xd6\xa9\x57\xff\x04\xc5\xa7\xf7\xf6\xcc\x98\xdc\xdd\x75\xf7\x8c\x77\x6f\xb9\xcf\x6a\xd8\x50\x75\xc7\xcc\xf3\xef\xb8\xd7\x34\x33\x5a\x87\x74\xeb\x7e\xb2\x60\xeb\xaa\xaa\x39\xdd\xee\x4d\xdd\x68\xe2\xb2\xfc\xac\x7c\x7e\xe9\xc8\x69\x9b\x37\x6f\x5e\xb7\x0e\xfe\x2a\x9e\x63\x64\xe9\x2b\x59\x7c\x07\x22\x92\x37\xd3\xb6\x40\xd0\xa3\xd7\x73\x4e\x8a\x32\x73\xb8\x74\x7f\x5d\xd6\xde\x56\x2a\xc9\xae\xe4\xd1\xe5\x9a\x54\xb7\x8f\x9a\xf0\xb1\x73\x60\xea\x54\x64\x9d\x7a\x18\xff\x35\x55\xfc\x0a\x3e\xd0\xd9\x90\x11\xbd\x65\x84\x3d\xf0\xca\x2b\xf8\x6f\xb1\x1a\xff\xfd\xde\x7b\xc6\x90\xa4\x83\xfb\xc5\x29\xcc\x4b\x24\x47\x22\x45\x4d\xcf\x67\x82\x6e\x87\xde\xa9\x4d\x30\x0c\xaf\xd5\xe3\x6b\x9e\x0e\xa3\xcd\x08\x7a\x37\xda\x5f\x70\xda\x34\x1a\x8a\xb7\x59\x29\xdf\x40\x01\xb0\x54\x9c\x0f\xfb\x71\xde\x87\xea\x54\x25\xdd\x84\xa2\x0a\x53\x91\xfb\xfa\x9a\xb4\xfc\xb4\x3d\xf1\x9e\xd1\xc8\x8b\x7f\x7b\xef\xb5\x49\x28\x20\x7e\xc8\x67\x4f\xe2\xc3\x7d\x8c\x4e\xfc\xea\x8a\x7d\xdf\x1f\x1a\xe8\xab\xcd\xd8\xd7\x2e\x01\xec\x5e\x79\xe4\xfe\xc3\xe9\x13\x06\x50\xb7\x60\x01\x5e\xea\x11\xff\xf8\xd3\x17\x8f\x3c\xff\xcd\x8a\x9b\x6e\x5f\x79\x5b\x9d\x90\x3e\xb0\xe7\x02\x72\x4e\x4c\x69\x47\x3f\xd3\x3c\x0d\x76\x78\x37\x75\x6d\x7e\x88\xee\x6c\x6a\xd0\xeb\xab\x2d\x69\xbe\xaa\x2a\xe4\x8f\x04\x23\x19\xc1\xd2\xa9\xe9\xc9\x37\x34\x56\x5b\xab\xf8\x90\x5f\x17\xcc\x66\xeb\x5a\x26\x4c\xd0\x0c\x15\x26\xf0\x75\x35\xfd\x85\x3a\x2a\x16\xab\x4c\x57\x0e\x14\x92\xf9\x44\xda\x1a\x74\x79\x1d\xb3\x0a\x5e\x57\xa7\x9e\x26\xf7\x81\x29\x53\xd9\x55\x6b\x5c\xdf\x08\x84\x84\x54\x68\xb7\xec\x35\x68\xbb\x72\x1b\x5e\xbe\x5d\x59\xf4\xc5\xc8\x13\xca\xaa\xe8\x35\x2a\xbd\x9f\x98\xd6\xc6\xc9\x0b\xe6\x8a\x20\x91\xd2\x86\x5b\x72\x20\x4a\xb4\xd8\x3a\xf1\x82\x13\xcf\x7e\x32\x87\xa4\x4f\x80\x9d\x21\xde\x2b\xc9\x90\x8e\xa5\x5d\xce\xb3\xba\x6b\x25\xe1\x82\x16\x2c\x47\xe7\x65\xb6\xdf\xa6\x99\xbc\x67\x23\x62\x97\x4a\x29\x0d\x24\x2b\x03\x3e\x6e\x14\x23\x92\x5c\x09\x04\x16\x4c\x58\x44\x9f\x2a\x89\x9c\x59\xe8\xff\xd0\xb3\x9e\xde\x4b\x5a\x3f\x58\xd3\xbb\xb0\x98\xcc\x21\xdf\x1d\x03\xc6\x68\x24\x77\xd0\xdb\xf2\x41\x40\xc3\x46\xd2\x93\x90\xde\xa0\x1f\x28\xd8\x0d\x06\xce\x62\x95\xae\xa0\x73\xea\x0c\xa5\xb2\x44\x6e\x1c\x26\x29\x5e\x36\x68\x2a\x5e\xe6\xce\xd1\x8d\x67\xe3\x6b\xd0\x67\x9f\x8d\x1f\x76\x3d\x1b\x3d\x20\xee\x23\x0a\x68\x68\x8d\xf4\x8e\xab\xf8\x9c\x94\x27\x41\x6f\x81\xb1\x3d\x54\x63\xde\x67\xf6\x79\x29\x2b\x6f\x05\x37\x91\xe7\x0d\x4e\xa7\x1d\xb8\xd0\x6a\x60\x67\x15\x0c\xe5\xef\x9f\xaa\x87\x55\xbf\x4c\xd9\x89\xe4\xc1\x6d\x39\x01\x3d\x57\x57\x59\x51\x1f\xb9\x30\x77\xf6\xb9\x5b\xb6\x6c\x41\xd7\xed\x45\x0f\xfc\x66\x52\xb3\x79\xc8\x1d\xd9\x76\xde\xaf\x09\x02\xe2\x9a\x35\x20\x9f\x7c\x60\x7f\x6d\x06\xf9\x14\xa4\x12\x20\x7b\xd7\xe7\xdb\x32\x71\x8a\xe7\xcd\x42\x45\x34\xaa\x13\x74\xd5\x35\x31\x9d\xdb\xe3\x1e\x28\x64\x38\x8f\xc7\x1c\x08\x80\x40\x0e\x58\x79\xc1\x21\xf4\x17\x1c\x7e\xb3\xd1\x18\x02\xd7\xc7\x45\x83\x1b\x4b\xd1\xea\x07\x36\xc7\x54\xf4\xcd\x29\x75\x2d\x4a\x37\x16\x4a\x46\x99\x1b\x98\x80\x30\x06\xb6\xcb\xd4\x24\x74\x80\x4c\x8e\xda\x5c\x0e\xe0\xa2\x68\x2d\xc2\x16\xd9\x53\x07\x75\x73\xe6\x9a\xff\xef\x10\x58\x65\x97\x8d\x7c\xb1\x6a\xf5\x6a\x30\xc4\x86\xe7\xcc\xd5\x88\xf7\xce\x5a\xb8\xa4\x1f\x2d\xe0\xe6\x81\x39\xf6\xdb\x0f\xd7\xbc\xf3\x31\x98\x63\xaf\x61\x1a\x33\x1a\x32\xd7\x63\x3f\xbf\xff\x7e\xf1\xa0\xc0\x50\x29\xf1\x2f\x37\xde\x87\xe5\x00\xae\x89\x34\x81\xdc\x8f\x4f\x52\x73\xf3\x55\xf6\x78\xdc\xa8\x75\x80\xc6\x41\x5a\x94\x4a\x7b\x65\x16\x88\x51\x84\x07\x7c\xc0\x04\xac\xcb\x62\x65\x83\x25\x17\x56\x0a\x90\x2a\x75\x1a\xd4\x77\xb2\x8a\xa6\x8b\x24\x88\x95\x45\x51\xdd\x9e\x84\xe5\xc1\x2f\x29\x45\x61\xf1\x98\x37\x5e\x7d\xe6\x8f\x1f\xac\x59\x83\xf3\xab\xd0\x83\x38\xbb\x6a\xad\xd8\xb3\x79\xbd\x38\xb8\x16\x3d\xb0\xfe\xee\x07\x7e\xf1\xf3\x53\x14\x6e\x41\x5d\x38\xcd\x4a\x3c\xb4\x46\xdc\x7f\xea\xa6\x2d\xa7\x6c\xd9\x82\xe7\x11\x84\x79\xbc\x09\xf3\xa8\x04\xfd\x72\x65\xbe\x55\xa8\xab\x63\x5c\xb5\xb5\x99\x40\x26\xea\xb3\x19\x18\xab\x2e\x9b\x0b\x5a\xad\x7c\xd4\x68\x35\x86\x8d\xaf\x1b\x19\x07\x67\xe4\xeb\x32\x2c\xc7\xc2\xd6\x17\xb8\x98\x9e\xd2\xf3\x7a\x3a\xc2\xe8\xf1\xe3\x41\x82\xaf\x0f\xfe\xfd\x30\x6f\xd3\x5b\xfb\x38\xfc\xe8\x88\x8f\xb7\x52\x55\xa5\xf4\x17\xf9\x28\xb3\x8a\x18\x97\xb6\xe2\xa2\xe6\xe4\x1f\x6d\x63\x45\x22\x17\x4b\xa4\x61\xea\x5d\xa8\x5b\x7a\x1b\xd6\x11\x65\x70\x09\xfa\x5a\x94\x66\xa2\x0e\x72\x3d\x07\x3f\x14\x00\x8b\xaf\x61\xd3\x78\xa5\x43\x88\xde\xfe\xb5\xf8\x77\x6b\xdf\x0c\xe1\xb5\x9f\xb2\xee\x27\xa7\x64\x66\x58\xd0\x9f\x84\x19\x8b\x8d\xe8\x0f\xc6\x85\xfd\x02\xfa\x93\x75\x46\x66\xe6\x43\x6e\xf6\xae\x17\x84\x19\x7d\x56\xf1\x8b\xaf\xb7\x6c\xd1\x88\x09\xed\x56\xe7\x83\x0f\xae\xd9\x71\xab\x27\x66\x58\x85\x5c\xe2\x9f\x8d\x1b\x97\x2d\xdc\x6a\x42\x41\xf1\x6f\xab\x0c\x31\xdf\x4f\xcf\x58\xf3\xe0\x83\x2b\xcf\x3e\xf7\x82\x33\x81\x56\x98\xd7\x71\x7c\x26\x02\x9e\xfc\x9c\x7c\x0d\x9b\xc9\x44\xfc\xd6\xa8\xc9\x64\x15\x22\x6c\x6d\x8d\x25\xa0\x0f\x85\x40\x24\x86\x5c\x76\xef\x60\x41\xb0\xfb\xf5\x89\xc1\x82\x46\xcf\x93\x4c\x79\x4a\xf5\xcc\x77\x6e\x9c\x8a\xb2\x72\x70\x9c\xc4\x99\xe4\xd0\x0c\xaf\x55\x9f\x96\x75\xe2\xbb\xbf\xc9\xb2\x00\x0d\x88\x30\x03\x89\xcb\xdc\xb2\xf3\xd2\xc9\xe4\x5d\xd3\xad\xb3\x66\xdf\x21\xfe\x4a\x1d\x99\x69\x72\xf7\x88\xf7\x2c\x59\x8e\xa3\x32\xe2\xa7\x97\x5d\x71\xf0\x49\xfc\xbc\xe9\xa7\xcb\x3c\x93\xd0\xa1\x31\x71\x19\x98\xdb\x62\x98\x5b\x1c\xfc\xa8\x42\xbe\xc1\x42\x55\x54\x38\xa2\x42\x42\x2b\x38\x7c\x5a\xb6\xbe\x2e\xee\xe8\x2f\xc4\x05\x4f\x78\xb0\xe0\xf7\xf8\x6d\xd6\xfe\x82\x8d\x32\x54\x0f\x14\x4c\x06\x9e\x4d\xc3\xee\x65\x5d\x65\xaf\xb3\xaa\x26\xa9\xbe\x2b\x7f\x7c\x4c\x86\xbc\x72\x5d\x36\xcb\xf8\x0f\xc5\x63\x60\xb6\xab\x95\x79\xfe\xdf\xb8\x71\x98\xbf\x7b\x7a\xff\xfd\x9a\xe7\x6c\x79\x92\x8b\x4a\x21\x18\x90\x93\x56\x71\x26\x89\xc1\xa4\x71\x86\xa6\x4d\x10\x98\x74\xdc\xed\x0e\xa6\x99\x8c\xa1\x42\x48\x27\xd3\xe0\x23\x09\xbe\x28\x58\x4c\x3e\xbf\xd6\x02\x42\x49\x8b\x9c\x88\x41\x83\x05\x1b\x63\x2d\x05\x22\x54\xf3\x02\xf9\x89\x72\x76\xf5\x1d\x8d\x52\x90\x25\xae\x8a\xc8\x94\x4f\x0e\x84\xd3\x4f\xa4\x40\x4b\x5e\x8a\xc3\xdc\xa8\xcc\x48\x3c\x6d\x15\x33\x49\x8e\xb0\x90\x18\xcc\x88\xab\x34\x13\x9c\x67\x04\xb2\xb6\x59\xec\xe0\x5c\xac\x9f\x6a\xa6\x7a\xa8\x13\xa8\xab\xf2\xb3\x72\x13\x26\x74\x74\xd4\xcf\xa0\xe3\xcd\x31\x2a\x64\xb1\x4c\xae\x68\x11\x5a\x26\x53\xcd\x74\xbd\xb6\x3f\xc8\xf3\x03\xf0\xeb\x94\xcf\x31\x58\x88\xf4\x0e\x14\x2c\x21\xd0\x0a\x54\x8c\x89\x18\x2d\xba\x94\x2f\x62\xd1\xe9\x2c\x11\x5f\x8a\xab\xe1\x6a\xba\x07\x0b\x35\x01\xae\x0f\xdb\x89\xbc\xca\x4e\x2c\xba\x84\x92\x41\x5c\x55\x25\x3f\xe2\x8c\x70\x70\xa5\xdc\x68\x54\x6c\x98\xb2\x8b\x08\xda\xe8\x98\xb9\x6b\xa2\xf2\xc5\x04\x5c\x8e\x07\x95\x6e\x26\xa0\xc6\x78\xb4\xf8\x0e\xa2\xea\x66\x02\x42\x25\x53\x12\xa1\xf3\x4b\x84\xfa\x76\x86\xf8\x24\x58\x96\xf4\x94\xdc\x7b\x68\x3e\xb1\x2c\xa7\x9d\xd2\x3e\x9b\x7e\xfc\x5c\xf1\x79\x62\x59\x8a\xef\xcb\x96\x25\x5a\xa4\x32\x2d\xed\x03\x32\x31\xb5\x6f\x98\x66\x06\x73\xe2\xbf\x88\x8d\x59\x33\xa7\x13\x6c\x4c\xf1\x97\x92\x8d\x49\xff\xa8\xdc\xc6\xcc\xc1\x9e\x38\x1d\xf6\x44\x8a\x3a\x39\xdf\xea\x32\xf8\xf0\x6d\x82\x60\x30\x16\xe3\xb5\x1a\x9d\x41\x93\x49\x13\xd7\x9a\x0a\xfa\x74\xb1\x48\xac\xbf\xa0\xa5\xfc\x0c\xe3\x89\x08\x66\xe7\x60\x81\x37\xfb\x35\xc0\x3f\xe0\xfc\xa9\x4a\x64\x10\x11\x58\x8c\x59\x8d\xdd\x1c\x98\x80\x7a\x72\xe7\x8e\xdc\xe1\x1e\xcb\x36\x8c\xea\x4a\x37\x1a\x46\x1b\x56\xa2\x55\xa7\x7d\x88\x26\xce\x29\x91\xe5\x57\x2d\x4f\x6f\x5e\x22\x56\x14\x60\x9f\xa0\xe7\xd1\x55\xee\xde\x5e\xd7\x67\x23\x5f\xab\x79\x08\x4d\x1b\xfc\x0e\x6b\x02\xf6\x1d\x8f\x54\x6f\x23\x03\x7b\xc2\x05\xf3\x73\x51\xb5\x79\x8f\xdd\xe3\x16\x60\x93\x0b\x14\x65\xe7\xc1\x70\xe0\x05\xce\x34\x58\xd0\x29\x4f\x47\x97\xea\x18\xe3\x0a\x59\xc7\x23\x48\x10\xdb\x5f\xda\xa1\xe2\xad\xab\x00\x93\x85\xea\xf1\x95\x71\x5b\xc4\x99\x9a\xdd\x60\x33\x4c\xa0\x36\xe6\x3b\xb8\x64\xb2\xb2\x32\xd0\x1c\x30\x50\x0d\x0d\xcd\x86\xe6\x8e\xf6\xb6\x96\xfe\x42\x9b\xb5\xa1\x32\x19\x30\x34\x37\x36\xf7\x17\x32\xbe\x46\xc1\xea\x1a\x2c\xd8\xad\xfe\x48\x2d\x53\x3b\x54\xe0\x62\x38\xef\x5b\x4b\x91\x38\x06\xd8\xfa\x55\x6a\x02\xe7\xc6\x0b\x09\xda\xe4\xc8\xa1\x3a\x1c\xe8\x1d\x87\xca\x36\x39\xe4\x27\x9b\x62\xe5\xf7\x27\xa2\xa5\xf0\xdf\xd2\xd2\x34\x9f\x90\x13\x5e\xc5\x1a\x29\xe1\x15\x2c\xce\xc5\x68\x5d\x31\xda\x07\x36\xa2\x8a\x00\xff\x29\x89\x56\xa6\x0b\x3b\x07\xe8\x92\xa1\x96\xe4\x73\x54\x38\x9c\xf0\x68\x9c\x3a\x9d\xc6\x9c\x60\x2b\x2a\xad\x95\xc8\xc8\xa4\x93\xfd\x85\xb4\x35\xec\xd1\x24\x62\x89\xfe\x82\x2b\x26\x18\xed\x83\x05\x8b\xd1\xcf\x04\x86\x0a\x12\x39\x54\x4a\xa6\x3c\x8e\x57\x7e\xa3\x45\x36\x93\xc7\x9f\x7f\xf9\x8c\x4f\x07\xfb\x58\x3d\xdd\xa2\x5d\x2d\xcf\x72\xbc\x39\x16\x0d\x69\x32\xad\xa2\xde\x94\xeb\x2b\xac\xc8\x37\x27\x38\xa7\xae\xc2\x4b\x05\x02\xe1\xb0\x45\xc7\x81\xe6\x24\x2f\x7e\x5b\x83\xe1\xfe\x42\xd0\x2f\x68\xdd\xb4\xbb\x6a\xb0\xe0\x75\xbb\xe4\xc9\xd1\x29\xb5\x79\x58\x9c\x9c\x14\xb1\x1b\x5b\x5c\xa2\x74\x17\x86\xa4\x92\x8d\xd5\x9f\x69\x58\xda\xe2\xd4\xca\x23\x75\xcb\x94\x29\x16\xd6\x82\x75\x28\x9e\xb9\x6a\x6c\x8c\xee\xf0\x05\xcf\xc8\xb3\x5c\x97\x02\xeb\x50\x7c\x07\x18\xfa\x01\x75\x80\x8e\xac\x1f\x89\xcf\x45\xb1\x75\xa0\x75\x04\x38\xce\x4d\x47\x90\x99\x75\x9b\x1d\x11\x36\x1e\x0b\xb0\x08\x85\x79\x9f\xa7\xbf\xe0\xb3\x72\x6e\xc1\x0d\x9b\x4d\x30\xd8\x06\x0b\x66\xc3\x98\x4d\x86\x67\x58\xcc\xef\x50\xac\x23\x1c\xcb\x8a\x91\xf0\xf5\x78\x5b\xcf\x4d\xa2\x74\x4c\x05\x8e\xbf\xfd\xb8\xb4\x5c\x0b\x77\xec\x40\x97\x1b\x71\x64\x8e\xde\x7c\x4e\x4b\x72\xe4\xc5\xb2\xa5\x82\xf5\x79\x1e\x47\xe5\x30\xee\x5d\x20\x0b\x3e\x85\x35\x6a\xa2\xa6\xe6\x33\x75\x51\xbf\x89\xa2\xd2\x1a\x47\x94\x6b\x6e\xa9\xcb\x80\xa9\xce\x59\x13\x89\xea\xfe\x42\x82\xb7\x02\xfa\x56\x17\x63\x00\xd3\x86\x51\xd0\x1e\x9b\xdb\x2c\xd9\x6f\x63\xa9\x5f\x16\xee\x4a\x8f\x79\x28\x5f\x23\x3f\x77\x40\x7f\xaa\x60\xbf\xf8\x6a\x55\xb4\xeb\xb2\xab\xcf\x54\xc5\xb9\xe6\x5d\x7c\xcd\x8e\x76\x79\x26\x3b\x72\x4a\x9c\xab\xa5\xb7\xaa\xe6\x96\x4d\x4a\x90\xab\x69\x52\xa6\xe6\xda\xf5\x44\x96\x8f\x5e\x03\x6b\x73\x9f\x7c\x06\x53\x6d\xa8\xcc\x98\xcd\x3e\x1f\x1b\xad\x64\x6b\x1d\x35\x2c\xa5\xa3\x06\x0b\x19\xd3\x40\x41\x97\xd1\x65\xf8\x50\x08\xfc\x91\x58\x08\xf1\xee\xc1\x82\x83\x2f\x3d\x3b\xaf\x14\xf7\x28\xd7\xfe\xb2\xf7\x5e\x5a\x10\x61\xcc\x25\xac\x92\x4d\x00\xcc\x07\xbf\xa4\xef\x0c\xae\x74\x4b\xcb\x73\x4f\xe9\x41\x7a\xc5\x28\x40\x47\x76\x8a\xef\x9a\x39\x3c\xb3\x13\xee\x29\x3e\x47\xcf\x2e\x96\xed\x82\x63\x8f\x5c\x77\xf0\x49\xe9\x6d\xd2\x99\x38\x9f\x9e\x0a\x51\x03\xf9\x2a\xa7\x37\x60\xb0\x9b\xcd\x26\xd6\xe1\x33\x78\xb5\x91\xb0\xc3\x64\xf5\x3a\xcd\x76\x2b\xc8\x71\x97\xd5\x6a\xf2\xe1\x1a\x25\x94\x0e\x9c\x0f\x1c\x88\xc8\x96\x4c\x34\xd9\xf1\x18\x73\xeb\x40\x3d\x99\xe2\x2d\x70\xe9\x5e\xf8\x18\xf4\xf7\x89\x67\xf4\xa2\xc3\xa7\x7f\xf5\xce\x7a\x94\x9b\x24\x0e\xa3\xb6\x9d\xe2\x4c\x09\xf3\xa9\xcc\x2a\x90\x00\xbe\x91\xbf\xd2\x3e\xf8\xd7\x79\x4c\xdc\x8b\xb1\xc6\x78\xeb\x60\x1d\xbe\x01\xbc\x33\xd4\xa6\x7c\x8f\xdf\x12\x36\x6b\x8c\x26\x2e\x1d\x61\x33\xd1\x54\x2a\x13\x8b\x84\x18\x4e\xd0\x7a\x8d\x66\x8b\xb9\xb2\x22\x15\x36\x47\x13\x51\x90\xf5\x26\xf8\x3d\x0a\x26\x04\xd9\xae\xce\x18\x35\x2c\x62\xfb\x0b\x3a\x64\x55\x85\x19\xc6\xe8\xd7\xe3\x42\x5b\x52\x9e\x29\xcc\xc2\xdd\x42\x26\xa3\x1f\x47\xfe\xa5\xa5\x4c\x59\x3d\x0a\xa3\x7f\x9e\x72\xe9\xa3\x4b\x51\x7e\xb6\xf8\x2f\x54\xb9\xb0\xb4\xa1\xae\x3f\xe5\xce\x77\x97\x8a\xcf\xce\x41\xd5\xe2\xd7\xcc\xa9\x3d\x3d\xfe\xdf\xbd\xed\xed\xe9\x11\xc4\xdf\x88\xcd\xc2\xce\xe2\xd6\xea\x71\x8f\x8c\x0a\x3d\x3d\x3c\x5a\x8e\x6e\x97\xf5\x2c\x89\x4d\x46\xa8\x13\xf2\x15\xfa\x90\xd9\xe5\x36\x1a\x1d\xb4\x2b\xc4\xc5\xa2\x2e\x8b\xd3\x69\x01\x67\xd8\x69\x35\x19\xdd\x46\x10\x09\x01\xa3\x40\x69\x07\x0b\x8c\xb2\x52\x39\x39\x3e\x99\x1b\xa7\x00\x99\x1a\x79\x54\x8a\x1b\xc9\x25\x03\x60\xad\x16\xc9\x78\x8f\xcc\x41\x0f\x16\x03\x90\xe2\xa0\x14\xa0\x84\xc5\x92\xd0\xad\x61\x92\x52\xdc\xf1\xd8\x07\x38\x1e\xb9\x02\x96\x8a\xa6\x7a\x81\xbf\xbe\x66\x0e\xc1\x3a\x65\xc1\xab\xef\xac\xf1\x86\x9c\xd9\x2c\x63\xe3\x38\x26\xe9\x65\x73\xc6\xc6\x50\x05\xc8\x81\x64\x38\x49\x9b\x98\x50\x32\x94\x74\x53\xee\xfa\x59\x05\xa7\xdb\xe5\x60\x60\x36\x82\xc1\x62\x81\x49\x58\xfc\x14\x2c\x1f\x75\xfc\x19\xbc\xb2\x97\x48\x5d\x35\xd5\x56\xca\x15\x13\x21\xdc\xca\x8d\x7e\xc9\x05\xc6\xd7\xe7\x49\x08\xb2\x1b\xe1\x54\x1b\x7c\x6b\xb7\x0b\x39\x8a\x15\x12\x5a\xe8\x18\x3a\x71\xe9\x56\xaf\xa7\x2a\x3f\x7b\xf2\xa5\x3b\xff\xc7\xd5\x7f\x4e\x5e\x7c\x7f\xde\x1d\xfb\x76\x5c\x3e\x67\x4d\xaa\xf7\xc7\x7b\x2e\x9b\x73\xe2\x8c\x8e\xfa\x49\x83\xcc\x21\xf1\xd8\xc8\x4f\x3c\x3f\xf9\xd4\xb1\xe9\xb0\xfd\x89\x67\xdb\xfb\x9a\xd2\xc8\xb3\xf6\xdc\x4e\x96\xb9\xf4\xe7\x8d\x5b\xff\xec\x36\x89\x6e\x86\x5d\x7a\xca\xdc\xc1\xb8\xec\x13\x71\x3b\x41\x26\x06\x80\x0a\xf3\xf3\xb5\x71\xa7\x97\xcf\x64\x02\x66\x84\x02\x4e\xa6\x42\x5b\xe9\xb3\xba\x23\x58\x51\xf1\xf6\xd4\xac\x02\x6f\x77\x59\x03\x40\x12\x41\x63\x30\x30\x83\x05\x2c\xd2\xd5\x13\x2e\xfe\x75\xdc\x64\x93\x63\x27\x8a\xaf\x18\x36\xda\x71\x9a\x40\xd4\xa6\xba\x78\xd1\xc2\x9e\xaa\xcc\xef\x5b\xfb\xc6\x47\xc5\x9f\xbd\x7e\xe0\xe1\xe9\x28\x2a\x7e\xb0\x7c\xf6\xfc\x39\xd3\xe6\xcc\x5f\xdb\xab\xcc\x6a\xc9\x46\xf4\xce\x3f\x90\xe9\xd4\xa1\x63\xfb\xd0\xf5\xf7\x3d\xfb\xf6\xf3\x77\x3e\xb2\x4c\x9a\xcf\x14\xf6\x1b\x90\x81\x60\x6a\x51\x0b\xf2\xb5\x46\xaf\xb7\xba\x92\x0b\x85\xec\x54\xd2\x9e\xcc\x65\xeb\xac\x83\x05\x53\x1d\xaa\xcc\x64\x74\x03\x85\x0c\x1f\x8e\xc5\x60\x1e\x31\x97\xdb\xef\x07\x83\xd6\xef\x1f\x5b\xc6\x7d\x4c\xd1\x46\xac\x7d\xa5\xf3\xe8\x92\xff\x86\x64\xa9\x57\x36\xc3\xa2\xe9\x8f\x3d\x40\xf9\x1e\xd3\xf6\xa2\x2f\xc7\x9c\x4d\x44\xe0\xca\xb4\x27\x98\xef\x5d\x79\xe0\xf9\xce\x35\x79\xd9\xfb\xc3\xe2\x51\xf1\xe7\x68\x01\x24\xe1\xf7\xe7\x8c\x7a\xd6\x7d\xe8\x78\xf5\xd0\x92\x4c\x80\xf8\x7f\xd5\xdd\x20\x23\x89\xbd\x31\x85\xd8\x51\xcf\x83\x1e\xae\xc0\x96\x54\x8a\x67\xbc\x49\x9b\xdd\xae\xd7\x7b\x79\xa6\x32\x52\x65\xad\x0a\x57\xd1\x7a\x26\x69\x1b\x28\x24\x93\x1a\x93\x29\x06\xe2\x91\xd7\xb8\x66\x15\x34\xae\x10\x45\xf9\x07\xa5\x70\x6d\xf9\xdb\x2f\x9e\x3a\xc9\x8e\x52\xf9\x7c\xb2\xac\xec\x54\x25\xe5\xaa\x2e\x8f\x14\xe7\x8c\xe4\xdb\x22\xcc\xd3\x97\xee\x5c\x3c\xeb\xe3\xf7\x7f\xf7\xb6\x72\x63\x44\x5a\xcf\x91\x3f\x91\x5b\x22\xe2\xcc\x27\x9e\xed\x72\x7d\x35\xf2\xcf\xaf\x8b\x97\x45\x0e\x93\xe5\xe4\xec\xf2\xf5\x10\x49\x47\xb3\x0b\x81\x1f\x5b\xa8\x65\xf9\x9c\x4b\xdf\x54\x51\xd7\x16\x63\x2a\xac\x41\x8d\x9e\xd1\xb4\xb6\xd5\x66\xb3\x60\x37\x65\xfd\x9a\x90\xdf\x1f\x9a\x85\x57\xcc\x64\x72\x0c\x14\x78\x13\x9f\xa1\xa8\xe4\xac\x31\xb5\x36\xa9\xe2\x0b\x0d\x63\x5e\xea\x29\xc6\x5e\xa4\x4b\xfe\xf2\x0a\x69\xc7\xbb\xe3\x4f\xee\x1e\x96\x73\xaf\x06\x7d\xf6\xca\x9f\xd7\x9d\x78\xe0\xc3\xdf\xed\x3b\x13\xf5\xc5\x3b\x56\xcf\x5d\xd4\x91\xdd\xde\x5d\x5f\x1f\xb9\x7d\xf3\xe6\x0d\x0b\x77\x36\x28\x2c\xbc\xd8\x79\xdd\x15\xcb\xcf\x74\x6a\x3b\x6f\xd9\x74\x66\xe2\xf3\x73\x6b\xfb\xa7\xb7\xcd\xe1\x4d\xe7\x59\xd2\x17\xcf\x2f\x44\x1c\xff\x94\x39\x79\x62\x40\xba\x27\x0d\xf2\xb3\x86\xcc\x7b\x61\xbe\xc1\xd5\x14\xab\xa3\xf1\x03\x1e\xfa\x86\xba\x26\x6d\x5b\x6b\x43\xc0\x1f\xf0\xcf\x2a\x04\x02\x54\x45\x75\x75\x72\xa0\x50\xcd\xeb\x4c\x26\x0e\x58\xd9\x4f\x39\x60\x5b\x96\x55\xad\x2b\x45\x9e\x8f\x17\xa6\x5c\x2c\x5d\x3e\x99\xe2\x5b\xdc\xc7\xe5\x0b\xa4\x8b\xe6\xa5\x54\x3b\xe6\xdc\xad\x8b\x95\x69\x35\xec\x5c\xb8\x61\xf3\xe6\xdb\x23\xf5\xf5\xdd\xdb\xb3\x1d\x0b\xe7\xad\xee\x88\xf7\xa1\x33\xf7\xbd\xf5\xc1\x81\xe5\xeb\x0f\x3b\x03\x2b\xe4\x79\xfd\xde\x11\x59\x38\xef\xe2\xb4\xe5\x3c\x93\x75\x6e\xdb\xf4\xfe\xda\x73\x3f\x4f\xec\xd8\x78\x4b\xa7\xd6\x79\xe6\xf2\xcb\xaf\x97\x6b\x96\xc2\x5a\x1f\x01\x1e\x4e\x52\x35\xd4\xa9\xf9\x09\xfe\xba\x4a\x46\xc3\x55\xc4\x05\x47\x34\x5a\x61\x62\xd8\xda\x3a\x6b\x5d\xb8\x0e\xb8\xd8\x17\x0a\x81\x9d\x12\xf2\xc7\x63\x95\x6c\xe5\x40\xc1\xc1\xb2\x94\x89\xe7\x0d\xb3\xf0\xc5\xa0\x94\xba\xf4\x8c\x34\x6f\x75\x75\xd3\x92\x63\x90\x2b\x71\x34\x77\x7c\xae\x89\x3b\xa7\xde\xc1\x4d\xb6\xb8\x05\xa5\x8b\x15\xd9\x7e\x7a\xf0\x7e\xf4\x79\xfd\xba\x25\xe4\xfe\xd3\xe1\x0f\xd8\x2b\x15\x52\x70\x8e\x37\x1e\x23\x9c\xed\x20\x0c\x7d\xf6\x44\x7c\xfb\xe9\x93\x7f\x8d\x3c\x2f\xd3\x00\x0d\xff\xfa\xf9\x93\x81\xb7\x4f\x6b\x22\xf3\xad\x81\x35\xae\x26\xbe\x68\x8c\xea\xce\x47\xdd\x0e\x47\x22\x1e\xf1\xcd\x2e\x44\x04\xe2\x95\x5a\x8b\x5e\xa9\xd6\x68\x64\x07\x0b\xc6\xb1\xe2\xa8\xac\xea\x65\x72\x8c\xf6\x28\x9a\xfc\xaa\xf7\x5e\xd1\xf0\x6a\x05\x53\xc9\x55\x15\xdf\x2e\x16\xc3\x5c\x58\xd2\x0f\x92\x91\x8c\xfa\x4a\x35\x31\x73\x80\xe7\x54\xe2\xa3\xe5\xf3\xb1\xb8\xc6\xec\xcd\x78\x9d\x1a\xb6\xb2\xc2\xee\x72\x81\xfc\x74\xf9\x0d\xe1\x81\x82\xcf\xe0\xca\x30\x0c\x28\x05\x72\xcd\xa2\xe4\x9c\x8e\x79\x12\xab\x78\x25\x9e\x04\xaf\x85\x32\x12\x4b\x76\x72\x31\x95\x2d\x57\xf3\xd3\x39\xdf\x7f\xb7\xf1\xcd\xcb\x07\xe6\x29\x48\xf7\x55\x86\x27\xb6\xb6\x2f\x6f\x3a\xfb\x92\xcb\x4e\x62\xce\x4c\x64\xbe\xfe\xee\xe6\xf7\xb7\x1a\x67\x17\x89\x7b\xe2\x5d\x6e\xd7\xd2\xfb\xcf\xf8\xf5\x03\x41\xc9\xf6\xa5\x5f\x20\xb1\x2f\xc0\x59\x13\x89\xd8\xd3\x4c\x45\xc6\xe0\xf5\x66\x12\xf8\x3c\x3d\x81\x6c\x82\x60\x01\xcb\xca\xaf\x0f\x82\x3a\xd3\xbb\xca\x9c\x91\x5c\x15\x09\xf9\x48\x7c\x22\x9f\xa7\x0b\xe4\xbd\xab\xe3\x50\x56\xdb\xbb\xf4\x85\x58\x90\xbf\xf2\x14\xcf\x2b\x18\x97\xec\x5c\x72\xcb\x68\x64\xd2\xd3\xbf\x45\x7d\x45\x7c\x7d\xd8\xca\xa5\x9f\x2e\xde\x2f\x42\x54\x18\x74\xef\x09\xa4\x86\x36\xf8\x52\x06\xce\x15\xb3\x52\xf8\xc2\x03\x98\x1f\x81\x54\xc2\x09\x9e\x88\xe0\x0f\x87\x3d\x83\x85\xb0\x9f\xd7\xe8\x34\xfd\x05\xbb\xce\xca\x98\xb1\x17\x5c\x8a\x44\x96\xa9\x2b\x94\x2b\x73\x81\x93\xda\xb2\x7b\x7d\x84\x3f\x6c\x63\x8d\x0e\xfa\xd0\xd8\x5a\x5c\xca\x64\x0e\x0f\xc1\xc6\x16\xe8\x79\xf8\x1e\x1f\x38\xbc\xf4\x41\x4f\xef\xb1\x7d\x25\xbe\x91\xe6\x80\x79\x1a\xd7\xb0\xaa\xa0\xe6\xe5\x6b\x19\x6b\xc2\xeb\x8f\x0b\xe9\x74\xdc\xe0\x8d\x58\x35\x95\x55\xf1\x68\x20\x0a\x16\x43\xc2\xeb\xa5\x22\x51\xab\x22\xb4\xec\xc7\x0b\x2d\xb9\x14\x50\xb9\xc4\x1a\x57\x66\xfd\x87\x0a\x57\x33\x67\x2a\xc8\x8f\x57\xe9\xca\xb1\x50\xc6\xfd\xa5\x71\x0b\x5e\x49\xb5\x68\xe9\x24\x7d\x15\xbb\x99\xb2\x52\x3e\x9c\x13\x29\x68\xcd\x0c\xcf\x5b\xb4\x96\x80\xdf\xc4\x20\x9c\x13\xd9\x45\x39\x28\x03\xc9\x68\xe0\x50\x07\x34\x93\x6f\x5a\x8f\xcd\x89\x94\x6d\xf1\x1c\xb9\x95\x45\x6c\x70\x1c\x2a\x75\x92\xf4\x2c\xcc\xef\xa1\x8f\x8d\x13\xd7\xbd\x71\xd6\x86\xd3\x2a\x71\x42\xe4\xaa\xaa\x5c\x53\x17\xdb\x95\x6e\x9a\x28\xfe\xe5\x9a\xdb\xf2\x39\x34\xf2\xd5\xc9\x9b\xff\x71\xd2\x69\x6d\x4a\xae\xdd\x3f\x48\x6e\x4a\x25\xc1\xd1\x43\x33\xe8\x33\xf6\x0c\xd0\xfd\x55\x94\xff\xd1\x24\x4d\xeb\x02\xc2\x53\x80\x46\x05\x49\xb5\x28\xde\x4c\x2f\xcb\xaa\xd0\xc8\xf7\x2e\xa4\xdb\x20\x92\x3b\x0a\x86\xa5\x5b\x0a\x06\x01\x45\x7f\x33\xa1\xeb\x84\x25\xa7\x2c\x5a\x37\xc9\x69\xee\x32\xc5\xab\x27\x9d\x33\x7b\xce\x8a\x2a\xaf\x90\x8e\xc6\x27\x84\xdf\x6d\x6e\x68\xa9\x0d\xcd\xab\xaa\x61\xe2\xa1\x13\x3a\x26\xce\x6c\xcb\xb4\x0c\x4d\x9a\x72\xfa\x92\x0b\xa7\x0a\xf7\xac\xb0\x9a\x5a\x57\x4f\xbd\xcb\x17\xf3\xcd\x0f\x63\xdc\x62\x74\x9a\xae\xe4\x7e\x42\xee\xe7\x76\xe7\xfd\x61\x9b\xe0\x65\xbc\x26\x13\x63\x63\x92\xa9\x80\x06\x1c\x12\xd6\x21\xc0\x1f\x36\x66\xc1\x69\xe9\x2c\x4e\x5f\x2c\xde\xd0\x72\xb7\xa9\xca\xba\x4b\x45\x53\x70\x42\x9b\xbb\x45\xd0\xba\x1c\x02\x8f\xeb\x02\xf2\x51\xb0\xa8\xd2\xd2\xad\x6a\x59\x3d\xef\x5c\xd3\xd4\xb6\x64\xf9\xfd\x9b\x9f\x62\xc5\x7f\xed\xda\x85\xb8\xb4\xdb\x35\xe1\x46\x31\xd5\xd0\x10\xcd\x54\x36\xa4\xd8\x37\x3a\xd2\xf6\x1e\x47\xdb\x8a\xe9\x13\x6f\x12\xff\x28\x88\x7f\xdb\x73\x09\x72\x70\x73\xba\x16\x88\x4f\xac\xda\xb8\x71\xd5\x8e\x13\xb7\xe0\x5a\x87\x40\xdf\x4f\xd8\x2d\xbc\x86\x3b\x0d\x38\x1a\x8d\x7e\x4f\x67\xd1\x8f\xb9\xab\x81\x03\xc2\x0f\xf9\x3c\x07\x50\xd7\x30\x43\x39\x19\x1b\x26\xb1\x85\xd2\x4a\x19\x97\x6e\xa0\xf2\x0f\x47\xc4\x41\x1a\xcf\x9a\x37\x6f\xeb\xfa\xf6\x4c\xca\x6e\x71\x77\x6c\xda\xb4\x48\x7c\xb2\x8b\x4d\x55\xba\x3b\x36\x9f\x65\xbc\xb8\xc7\x72\xc3\x50\xb7\xd8\x63\x49\xa7\x2d\xc4\x6f\xff\x1e\x69\xd1\xf5\xec\x6a\x18\xaf\xf2\x31\x67\xc0\xef\x13\x04\xf7\x01\xd4\xfe\x38\xe5\x70\x58\x0c\x5a\xc6\x2e\x65\x70\xbf\x90\xcd\xe6\xd4\x35\x3f\x60\xa4\x31\xc1\x1f\xe5\x0c\x0d\xf5\xcc\x9d\xbb\xfd\xd4\xae\x64\x71\x6c\x34\xb9\x93\xde\x54\xe1\xe9\xd8\xbe\xcd\xb8\xbb\xd7\x72\xe3\x50\x17\x3a\x88\x13\x66\x08\x2f\xe9\x51\x25\xdd\xc2\x6e\x05\xfb\x3f\x4d\x4d\xcc\xdb\x92\x42\xd8\x67\x05\x31\xa4\x11\x98\x4c\x05\xef\x73\xf8\x9f\x81\x49\xc7\x29\x0f\xb0\x3a\xbe\x10\xdf\xfd\xb0\x09\x57\xbb\xe9\x94\x72\x9f\x14\x96\x2f\x7b\x1d\xaa\x98\xb7\x41\x6c\x0b\xc9\x16\x96\x04\x66\x4b\x0e\x65\x5b\x9a\xe4\xac\x60\xba\x65\xfe\xf5\x4b\xa6\x2f\xce\x78\x5d\x79\xef\xc0\x24\x9c\x1c\x8c\xf7\x82\xe1\x4e\xf1\x83\xe6\x2e\x9c\x20\x4c\xd7\xcf\xd9\xda\x29\xdc\xb1\xc2\xcc\xaf\x3c\x6d\x02\x4e\x13\xbe\xf6\xb6\x7c\x56\x34\xb6\x3d\x04\xfb\x62\xc5\xa9\x92\xec\xe1\x51\x03\x7d\x29\xd0\x0d\x14\x65\xde\x6c\xe2\x6c\xc8\xef\xf7\x70\x9e\x40\x10\x97\xe6\xe9\x7c\xcc\x6d\x37\x6a\x34\x4e\x1d\x4e\xb7\xb6\x22\x39\xd5\x29\xa7\x94\x89\x28\xdf\xa8\xa8\x45\x9d\x3b\xe3\x52\xe7\xcb\xc4\xd1\x1d\xec\xe6\x81\x5b\x5a\x91\x3b\x4b\xf2\x79\x90\xbb\x65\xc2\xc7\xb4\x61\x49\x5e\x49\x92\xc9\xb6\x3a\xd1\xcf\xf0\xc7\x91\x66\x9c\x19\x83\x73\x77\xb3\x68\x19\x77\x11\x65\x03\x9a\xb5\x3d\x66\x37\x1a\xc3\x21\xbf\x40\xd2\xf2\x28\x9d\xce\xaa\xd7\xb3\x46\x33\xce\x90\x42\x1a\x0d\x5b\xca\xce\x97\x0b\x1b\x74\xe7\x94\xc7\x2d\x04\xf9\x0a\x47\x13\xbe\xd2\x81\xef\x01\x94\x29\x77\x6b\x97\xf8\xbf\x9d\x0b\x16\xb4\x7d\x34\x28\x8e\x34\x66\xd2\x4d\x4d\xe9\x4c\x23\x53\xf3\x22\xc9\xc8\xeb\x7a\xc9\x9a\x3e\xd6\x85\x46\x52\x4d\x4d\xa9\x74\x73\x0b\xd1\x35\xc0\xe3\x3b\x81\x56\x16\xca\x37\x4c\xf3\x56\x86\xc3\xdc\xac\x57\xb2\x49\xe5\x3a\x32\x52\xd2\xb9\x4d\xce\x6d\xfd\xfe\xc7\x93\x8f\x36\xb9\x43\xae\x7e\x3a\xfd\x23\xb4\xcd\x9a\x16\x67\x4f\xd3\x35\x58\xed\x84\xf6\x29\x98\xe3\x64\x80\x67\xa4\x22\x8f\x19\xf1\xdb\x2e\xc6\xe3\xd2\x1d\x8b\x9c\xea\x50\x5d\x48\x59\xd6\x86\xc2\x6d\x6d\xe2\xe1\x36\xb6\x81\x10\xaf\x45\x62\x44\x84\xf3\x06\xd1\x5c\xf6\x64\x10\xae\x89\xbc\xde\xae\x43\x46\x23\x67\x33\x59\xf0\xe2\x69\xe9\x62\x21\x9e\x62\x79\x05\x92\x71\x51\x46\x1d\x72\xf1\x05\xcd\x9d\x81\x21\xcf\x98\x81\xc7\x98\xc1\x64\x5f\xc1\x1b\xec\x95\x2e\xc2\xeb\x07\x29\x8a\x19\xfd\x02\x55\xa1\xdf\x73\xbb\xc9\xba\xa4\x80\xdb\x2d\xf8\x01\x58\x60\xf6\x4c\x42\xa3\x49\x0b\x7e\x9c\xa8\x62\xa4\xcc\xa8\x7d\x98\x8a\x46\x71\x11\x8f\x2e\x2a\x44\x31\x84\xd9\xe5\xea\x2f\xdd\xf2\xd9\x90\x6c\x4e\x92\x77\x93\x24\xc7\xa8\x1d\xc9\x77\x0a\x18\x55\x3e\x27\xb0\xbb\x7c\xce\x73\x95\xf1\x82\xb5\xb3\x16\xcc\x9f\x36\x77\x05\xe2\x27\xe7\x5b\x12\xa9\x96\xa6\x4c\xaa\x49\xfc\xdb\x49\xf4\xdc\x54\x45\x12\x7d\xba\xe8\xe4\xbe\xee\xf6\xa9\xe8\x5b\x21\x3d\xf2\xda\x34\xa6\x27\xd3\xd4\x9c\x4e\xb4\x34\x1d\x4b\x6f\x8a\xfa\x7c\x41\xa9\x1e\x10\xaa\x43\xfb\x09\xee\x81\x61\xb3\xdd\x61\xe1\x81\x9f\x1e\xd6\xe0\xb4\x40\x79\x33\xca\x52\x41\x95\xba\x4e\xf2\xbf\x72\xc8\x98\x8a\xd8\xcc\xde\x74\xae\x71\xfd\xce\xb6\x8f\x68\x7d\xdf\xa0\x71\xd2\xc5\xc6\x9d\x9b\x98\x46\x60\x56\x44\x45\x51\x0d\x9a\x06\xbc\xea\xa2\x32\xc3\x76\x8f\xdb\x81\xf9\xf4\x11\xca\x6e\xe7\xf1\x6a\x9a\x74\x5c\x09\x7e\x69\x8c\xb1\xc7\x99\x72\xea\xa5\xb1\x6b\xfa\x50\x45\x2e\xed\x33\xda\xa7\xbc\xd5\x09\x43\xad\xb1\xcc\xd8\x74\xba\xf1\xe2\x49\xc6\x2b\x5a\x32\x16\xfa\x63\xbc\x37\x10\xd5\x44\x67\xe9\x02\xac\xb3\x95\xaa\xc8\x1b\x68\xa3\x51\xcb\xdb\x90\x89\x2c\xf4\x23\x46\x0d\x2d\xd7\xf9\xc8\x8d\xa9\xb4\xa3\x2d\x55\x7a\x23\x46\xee\xa6\xf9\xa7\xcd\xae\x8f\xd5\x58\x47\x3e\x6d\x6b\x43\x9d\x6c\x97\x55\xec\xd1\xad\xfe\x45\xc6\x82\x5e\x26\x73\xaa\x44\x35\xcc\x93\xec\x16\x72\xfb\xde\x5b\x65\x77\xbb\x0d\x31\x43\x7d\x1a\x9f\x6a\xd1\xf5\x4c\x63\xce\xec\xf3\xd5\x54\xa5\x2b\x70\x3a\x75\x1c\xe8\xda\xfe\x58\xd0\x6d\x8f\xc5\x84\x08\x9e\xb1\x96\xa1\xc8\x8c\xb3\x59\x45\x52\x74\x4b\xf5\x9c\xd5\x66\x09\x61\x00\x55\x6c\x0a\x9b\x84\x65\x87\x2a\x65\x39\xa9\x6e\xf9\x34\x06\x9b\x94\xf4\x1b\x2d\xf5\x29\x9f\x99\x8f\xa6\x70\xe6\x5d\xab\xf8\x09\xc9\xbc\x23\x19\xaa\x52\x5a\xde\xac\x1b\x77\xa2\x1a\x4c\xb4\x59\x53\xd1\x83\x6b\xbd\xbe\x88\x78\x13\xc9\x52\x1d\x58\xeb\x16\x97\x92\x4f\x30\xc7\x06\x9c\xa3\x27\x9e\xb0\x69\xa7\x24\x07\x1d\xa8\x8e\x79\x0f\xf6\x22\xce\x2d\xf4\x45\x81\x9f\xc7\xc9\x2d\x94\x52\x0b\x1f\x0b\xdb\xed\x9c\x2a\xb7\xb0\x53\xce\x2d\x24\xab\x2b\xdf\x03\x3e\xee\xda\x96\xed\xff\x77\x6e\x21\xfd\xed\xe6\x19\x3f\x98\x5a\x08\x0c\xdc\x4c\x72\x0b\x57\x91\x9d\xff\xd0\x5a\xaf\x33\xa5\x7c\x76\xa3\x3b\x88\x04\x6d\x24\xb9\x85\xa0\x13\x9f\x41\x35\xf4\xed\xb0\x86\x31\xbc\x4f\xfd\x30\x1b\x3a\xe2\x8a\x24\xac\x71\xbf\x26\x88\x17\xce\x4d\x79\x41\x34\x38\xac\x30\xa9\xce\x47\x22\x65\x45\xb1\xa4\x25\xc3\xc6\xb0\xaa\x1e\x82\x72\xee\x53\x1e\xb8\x96\x57\x07\xaf\x1b\xba\x14\xe4\x7b\x4d\xed\xce\x75\x78\x81\x8c\xf6\x48\x0a\xaf\xc8\x09\x37\xb7\xd1\x59\x4c\x7d\x9c\xdc\x69\xd9\xb4\x13\x2f\x4c\xff\x74\x3a\x83\x97\xe0\x6e\xbc\x32\x52\xde\x23\xf0\x9b\xa9\x88\xab\xd3\x60\xb0\x32\x5e\xab\x37\x1e\x4d\x38\xb5\x2e\x8c\x2b\x4f\xd9\x81\xbb\x71\x8d\x2b\xcc\x61\xe1\x40\x89\xc3\x6c\xe3\xe2\x4a\x1e\xa2\x4a\x1d\xc7\x42\x82\x4d\xd9\xdb\xf4\x5d\xeb\x77\x62\x64\x8b\x8c\x73\xc2\xcd\x78\x8f\xfb\x52\xf5\xa8\x66\xe7\x26\x74\x0b\xc9\x44\x2d\xf1\xca\xdd\x62\x9b\xb4\xe9\xa5\xbc\xd7\x2c\x7d\x06\x91\xb3\xdd\x79\x5b\x79\x8d\x27\x1d\xae\xf0\xd4\x4e\x2a\x3c\x3d\x45\xcc\x5c\xad\x5c\xee\x43\x61\x8e\xb1\x25\x9e\x72\xc5\x12\x4f\x45\x11\x80\xbe\xeb\x7a\xba\x6d\xb1\xf8\x04\xfc\xdd\xf6\x2e\xa2\xd9\x3a\x92\xc0\xce\xa0\xfb\xc5\xcb\x25\x7c\x2c\x19\xf1\x21\x72\xce\x8f\xf3\xad\x2b\x80\x66\x46\xca\x4e\x79\xa9\xa6\xbc\xdd\xc5\xf3\x1a\x37\x98\x1e\x1a\xca\xe7\xe7\x5d\x2e\xc6\xa1\xc7\xb4\x33\x29\x55\x94\x94\xcb\x8e\x2a\xce\x2c\x93\xb5\xcd\x2d\x71\xa7\xcb\x11\xd3\x68\x73\xb5\x88\xae\xb8\xe0\xa2\x8b\x77\xe0\x54\x68\xf1\xbb\xc6\x18\xba\x2f\x55\x5d\x17\xa5\xef\xa3\x93\xcc\xc0\x4d\x7b\x7f\x7c\xcd\x9e\x1f\xff\x48\x3c\x7f\xdd\xba\x9d\x4b\xd1\xef\x97\x2f\x5d\xbe\x94\xe0\x13\x41\xd5\x4c\x3b\x37\x07\x57\xe4\xa7\x92\xd4\xe2\xbc\xe0\x31\xc5\x5d\x2c\xeb\xb7\xea\xc1\xac\xd5\x9b\x98\x54\x5a\xe0\x79\x5c\xac\x6c\x38\x16\x08\xb8\xac\x07\x50\xc7\x23\x71\xbf\x1f\xc4\x6f\xf7\x23\xac\x5e\xaf\xc5\x19\x78\x04\xd3\x62\xa9\x1d\x75\xbd\xb0\xd2\xc9\x5d\x11\x6d\xf9\xa4\xbb\x29\x61\x93\xaf\x96\x83\xfe\x62\x11\xce\x1c\xb4\x20\xae\x31\x95\xb6\x75\x21\xa6\xfd\xa6\x9f\x60\x15\x2f\xfe\xfa\xda\x3b\x3b\x51\xa6\x0b\xb5\x8c\xfc\xa8\x67\x6a\x5f\x1e\xfd\xb2\x7b\x5a\x5f\x9e\xe9\xdf\xbd\xd7\xfa\x32\xde\x32\x2f\xfb\x91\xe1\x9c\x6b\xf9\xfd\xf8\xf3\x7e\xbf\xf8\xef\x2d\x2b\x71\x4a\xfb\x8a\x8d\xa7\x9e\xcc\x8b\x1d\xfc\xc9\x78\xcd\x6d\xa8\x16\xdd\x0f\x36\x5e\x8e\x6a\xcf\xdb\xc2\xf6\x4a\xc6\x94\x4c\x7a\x1a\x18\x3b\xd7\xd8\xa4\x67\x2b\x70\x46\x7b\xd0\x0b\x72\xbf\xe3\xe1\xfa\x1a\x95\xf4\xeb\x1e\xf3\x12\x2e\xa9\xd0\xf1\xc3\x87\x5b\xc5\xa7\xbc\x71\xd9\x25\x85\x51\x8f\xad\xdf\x99\x71\xdb\x27\xa6\x9b\xb2\x75\x73\xe7\x4d\xdb\xb8\x68\xea\xb2\x8c\xc3\xda\x1d\x9a\x5b\x3f\x67\xee\x8c\x75\x5b\x8c\xa9\x28\x4f\xb8\xb6\x76\xe7\xa6\xe7\x07\xec\xe1\xea\x78\x24\xe3\xf7\x2f\x9e\x7c\xc2\x22\xdb\xd5\xbd\xbc\xa7\x37\x54\xe1\xf3\xcd\x9b\x54\x58\x15\x2e\xb2\x2f\xc8\x85\x97\x41\x5f\x3d\xc4\x5d\x03\xb6\x72\xe8\x51\x87\x3f\xc0\x50\x60\x2a\xd7\x3c\x4c\x12\xf3\x3b\x55\x19\xf9\x2a\x2f\xfe\xf8\x83\x2a\x74\xb9\xdd\xe4\xed\xd8\xb9\x9e\x88\x62\x5b\x24\xb5\xfd\xd4\xce\x14\x47\xf5\x58\x6f\x1c\x59\xa9\x6c\xf1\x9f\x6c\xdf\x66\xba\x58\x92\xad\xe8\x1a\xf6\x63\x5c\x39\xfb\x71\x3e\x99\xf0\x09\x4e\x9b\xfb\x97\x60\xe1\x98\x61\xb1\x43\x94\x11\x68\xa7\x56\x19\xb8\x5c\xdb\x6b\x8a\x31\x55\x1c\xb7\x13\x69\xa5\xa0\x92\x72\x9f\x53\xba\x90\xe8\xd4\x7c\x8c\x0b\x15\x98\x6d\xe1\x84\xc5\x32\x6b\xc1\xb4\xf9\x53\x16\x6e\xdb\x16\xf1\x25\x2a\xe7\xa1\x3a\x8c\xc6\x60\x5f\x04\x4d\x9f\x84\x36\xa7\xdd\xbb\x76\x75\x89\x37\xa4\x33\x86\x39\xdb\x2e\x00\xfb\x12\xe7\xb2\xef\x86\x3d\xec\x03\x89\xb3\x34\x1f\x0f\x3a\x38\xce\x83\xec\x91\x88\x59\x6f\x05\x33\x4c\x40\x6c\x22\xee\xb4\x58\xf8\x30\x65\x34\x7a\xec\x26\x13\xeb\xe2\xb1\x1d\xe5\xe7\x88\xd8\x47\xe0\x74\x75\x15\x4b\x2c\x48\xe6\xd4\xd8\xa2\x9f\x39\x55\x2e\x8c\x80\xd7\x17\x68\x48\xdc\x0b\xc9\x0e\x95\xad\x51\x2e\x8b\xaf\x17\x83\x25\x3f\xd8\xf2\xae\x1e\xe7\xbb\xb7\xb6\x1e\xf9\x45\xee\xc3\x16\xf1\x50\x6d\xcd\x2f\x2a\x99\xec\x6f\x2c\x19\x90\x3d\xa7\x74\x3f\x63\x4d\xff\x03\xff\xdf\xfd\xb4\xf3\xde\xa1\x6c\x2b\x20\x50\x0b\x3e\xe2\x03\xa0\xaf\x32\xd4\xcc\x7c\x24\xe4\x49\xdb\x4d\x0c\x03\x1e\x36\x8c\x53\x59\x11\x36\x99\xfc\x56\x6b\x42\x13\xd7\xea\x74\x66\x8d\x26\x60\xc6\x76\xaa\x50\x56\xaa\xa5\x78\x85\x36\x6b\x53\x3d\xfd\xa4\xdc\x2f\x96\x6f\xd2\xb5\x44\x95\xd2\xd2\xe4\x6a\x71\xd4\x5d\xbc\x4e\x27\x38\xd1\xba\x9b\xee\xda\xb1\x81\xb1\x2c\xe9\xf0\xd4\xe8\x50\xd4\xdc\xd8\xda\x37\xb5\x6f\xea\x84\x9c\x19\x45\xf5\x35\x9e\xc9\xb3\x2d\xcc\x69\x3b\xe9\xf4\xd6\xed\xf3\x37\xd9\x05\x4d\xe7\xdd\xf7\xeb\x17\x4c\x5b\x32\x34\xb4\x64\xfa\x7c\xfd\xfd\x77\x77\x6a\x04\xdb\xa6\x05\x9f\xcb\xf5\xf2\xd2\xb0\x0e\xab\xa5\x3a\x58\x16\x41\x4f\x0b\xb4\xaa\x0e\x56\xfb\x7f\xac\x83\xa5\xd2\x9f\x92\x1e\x92\xea\x60\x2d\x16\xff\xd9\x85\xb2\x53\x76\x4e\xc9\x4f\x7f\xbd\x7b\x07\x9d\x7e\x0d\x75\x12\x0d\xf9\xfc\x65\x3d\x13\xd1\x44\x90\xa1\x66\xf1\xe0\xca\x55\xe4\x6e\x78\x1a\xec\x28\xec\xb7\x35\xe4\x4d\x3a\x06\x6c\x1a\x27\xc3\x04\x43\xbc\x1b\xef\x63\x27\xab\xc1\xe3\x1b\x4a\xe3\x77\x8f\x2d\x6f\x53\xb4\xf3\x9b\xc7\x56\x88\x41\x5d\x5b\xb6\xb5\x1e\x29\xcc\x3e\x29\x57\xe5\xf1\xb9\x6a\x1a\x5b\xe7\x2d\xba\x81\x4e\x9f\xbf\x15\x39\xc0\x01\xd8\x7a\xea\x0d\xe7\x0e\x2e\x32\xcd\xbb\xc6\xbe\x63\xeb\xdd\x4f\x60\x1a\x70\xa0\x4f\x96\xb3\x1b\xc1\xaf\x48\x3d\x6a\x36\xf0\x56\x16\xd7\xba\x7a\xcc\x6c\x60\x38\x0e\x95\x17\xe6\x2b\x26\x1a\x80\xdc\x33\x22\xa2\x32\x1c\x39\x87\x9b\x5e\x2e\xfe\xa9\x63\xd3\xd6\xee\xdf\x56\xbe\xbc\xfd\xa5\x6a\x3a\x9b\xe2\x51\xa7\xf8\x3c\x9f\x4a\xf1\xb4\x7e\xe4\x5b\x9e\xd0\x39\x0d\x63\x08\xc0\xef\x76\xaa\x3a\x6f\x31\x52\xb4\xc1\x66\xd0\x52\xac\xc3\xa9\x65\x88\x77\xc7\x1b\x65\xed\x9f\xed\x2e\xaf\x87\xd3\x84\x8a\xb5\x4c\xe5\xe3\x42\x6d\x1a\x31\xf9\xd9\x5e\x47\x15\x7a\x54\x14\x0b\xb1\x69\x8e\x70\xb5\x8d\xce\xfa\xd1\x9f\x84\x25\xf7\x06\xc5\x88\xd5\x7c\xfe\x5b\x64\x3c\xb0\x3d\x0e\xc0\x78\x11\x6a\x42\x9e\xb7\x20\x3b\x28\x24\xde\xed\x43\x6c\x2c\xea\x76\x78\xf0\x88\x11\x3f\x31\x8f\xb5\x78\xb2\x45\xa9\x33\x56\x5c\x22\x75\x15\xa9\x94\x7c\x7a\xa9\xc6\x86\x16\x12\x31\x22\xfe\x5a\xd6\xef\x14\x9f\x1d\x8b\x18\xa3\x19\x9d\x32\x24\x59\xea\x6e\x35\x82\xd8\xbf\x4c\xa3\x3f\xd1\xe7\xc8\xfb\x7f\x7a\x5e\x88\xb8\xb5\xd6\xa0\x8d\x62\x79\x8e\x33\xb1\x56\x37\x97\x88\x9b\x74\xd8\xc1\xcc\x1b\x83\x3c\xcf\xf9\x9d\x4e\xe8\x23\xb9\x50\x2f\x01\x66\x52\x61\x0b\x35\xb6\xca\x41\x0f\x8e\x11\xc5\xd5\x68\x2a\xf5\x4c\x5a\x62\x5a\x12\xb8\x42\x9d\xe1\x06\x93\xf9\x03\x15\xb2\xb5\x95\xdb\x7a\xdb\x7a\x07\xfb\x5c\x0b\xa7\x5e\xb6\x38\x44\x67\x07\xeb\xa2\x0a\xba\x33\xe6\x77\xd7\x34\xb4\xdf\x71\x5a\xb3\x3d\x21\xd5\xbf\x44\x55\xb4\x97\xd4\x2d\x68\xcf\xbb\x3d\x66\xab\x5b\xef\xf3\xb9\xcd\x4e\x86\x0b\x86\x3c\x66\x16\xfe\x38\x79\x12\xc7\xd2\x94\x2c\x53\x12\x18\x3a\x4e\x0f\x1d\x5f\xe6\x1e\xd0\x65\x30\xa6\x87\x5b\x56\x47\xa6\x2e\x98\x33\xa7\x7f\x7e\xeb\xfe\xa5\x04\xc7\x37\x0e\xbe\x75\x1b\xaa\xf2\xba\x6b\x1d\x8b\x56\x9c\xbc\x2a\x81\x2c\x04\xb7\x8f\x13\xaf\x5f\x70\x15\xd1\xfb\x60\x87\x4c\xe0\xae\xa0\xb4\xc0\xc1\x02\xb6\x43\xb0\xc0\x74\x18\x8d\x14\x4b\xb9\xdc\x26\xbb\x9d\xb6\x6a\xb0\x5f\xa8\x53\x2a\xd6\x8e\x67\x87\xf0\xd1\x88\x0d\xfe\x27\x36\x48\x08\x15\x6d\x90\x09\xe2\x17\xe2\xb7\xe0\x21\x9a\xc4\x2f\x73\xb5\xf4\x21\xba\x32\x9b\xad\x84\x7f\x6a\x99\x77\xc5\x99\x68\x18\x3d\x7c\xec\xf7\x0f\xde\x75\xe7\x43\xf4\xe7\xfb\xef\xbc\x6b\x1f\xb6\x41\xc4\xeb\xd9\xa9\xe8\x24\xee\x3d\xf2\x2e\x50\x90\xe2\x1f\xf5\x51\x1a\x90\xdf\x54\x5d\xee\x85\x57\xc9\xeb\x3c\x45\x5b\x07\xe6\xc9\xa9\x3e\xe7\x98\xa6\x9c\x43\xf8\xb6\x26\xdf\x53\x5d\xdd\xdd\x35\xf2\x81\xfc\xe1\xc8\x7b\x5f\x77\x73\x4c\xbe\xa6\xa6\xab\xb3\xb6\xb6\xfb\x69\xfc\x21\x5f\x55\xdb\x8d\x36\x24\xc5\x2b\xa3\xff\x7f\xc6\x63\x7e\x60\xbc\x68\x93\x03\xfc\xdc\xd1\x9a\xae\xee\xea\xea\x9e\x3c\x7a\x19\xc3\x85\x0f\xe2\xa9\xdd\x5f\xbf\xc7\x31\xdd\xb5\xb5\x9d\xdd\xd5\x35\xf9\xa7\xbb\x6b\xab\xbb\xf1\x87\x28\xda\x9c\xc4\x35\xb5\xd1\xe8\x9d\xe2\x14\x6a\xe9\xe8\xe3\x54\x0d\x65\x78\xd8\x09\x56\x5f\xdd\xab\x78\x39\xc9\x6b\xc1\xb4\xf4\xac\x3e\xfe\x17\x9f\xc9\xc8\xb5\xf6\x69\xe9\xe5\x7d\xfc\xaf\x7b\xf1\xd0\x22\x87\xc7\x61\xb1\x5b\xec\x6e\xbb\xdd\x55\x9b\x69\xa8\x68\x85\x9f\xad\x76\xab\xe0\x15\x06\xc4\x29\x74\x3a\xe9\x70\x59\x0d\x1a\xad\xde\xe8\xb0\xf1\x2e\xbb\x45\x6f\xb6\x75\x08\xc9\xb8\xc3\x6b\x37\xc3\x97\x66\x87\xdd\xe6\xe2\x4d\x1a\x07\x47\x21\xf1\x2a\x76\x2e\x3a\x9d\x3b\x0f\x2c\x5c\x77\xde\x68\x47\x08\xdf\xfb\xa6\x8d\x66\x2d\x9e\xf9\x12\x12\x39\x25\x2f\xf6\x48\xb9\xf1\x39\x60\xb5\x2e\xba\x1d\xa1\xd3\x37\xd5\x2f\x6d\xeb\x98\x5f\xb3\x61\x1b\xbd\x38\xb0\xad\xa2\x7f\xe1\x86\x19\xab\x59\xb1\xa2\xaa\x26\x73\xe3\xb5\x97\x57\x35\x55\x11\xbf\x45\x7c\x9a\x3d\x84\x26\x71\x6f\x03\x0f\x1b\xc0\x3d\xc7\x4f\x1d\xbd\x8a\x77\x56\x14\x17\x8b\x41\x93\xee\x13\xa3\x68\xcf\xc1\x76\xee\x81\x4f\x2f\xbc\x6a\x6c\x7b\x47\xde\xc0\x59\xd9\x30\x5b\xc7\x32\x2c\xa2\xea\x5e\x5b\x22\x15\x67\x06\x1b\x22\x8a\x26\x89\xd1\xfb\xda\x9f\x41\x7b\xd9\x43\x9f\x56\x5c\x75\x7c\x3f\x46\x7e\x87\x8b\x23\xfd\xb2\xa4\xaa\x06\x8c\xe8\x46\x93\xda\x0f\x8a\x9b\xd0\x07\xf7\xb1\x87\xae\xba\xf0\xd3\xe3\xfb\x21\xab\x26\xac\xa9\xd3\x30\x1a\x86\xaa\x7b\x81\xf4\xc3\x65\x6d\x5a\xf0\x78\x1b\x9f\x69\xbf\x0f\x7d\xc0\xcd\xba\xaa\xa2\xd8\xef\x20\xf4\xfb\x03\xa5\xc7\x34\xe3\x68\xab\x2e\xac\xa3\x75\x5a\x04\x1d\x5f\xca\xbd\xbf\x24\xfb\x12\x19\x93\xc3\xd8\x26\xf1\xb0\x37\x8b\xdf\xdd\xdf\x7e\x33\xd2\xde\xcf\x1e\xda\x7a\xc6\xe7\x15\xf0\xff\x58\x18\x3a\x1a\x0f\x4e\x6b\xb4\x78\xb2\x0a\x0c\x6d\x12\x23\xc0\x61\x5a\xdd\x2f\x7e\x77\x73\xfb\xfd\x48\x7b\x33\x90\xeb\xf3\x33\xb6\x56\xc0\xff\xc0\x43\x75\xc0\x43\x6f\x8e\xbe\x47\x01\xff\xe4\x0d\x36\x87\x83\x35\xe2\xf0\x3c\x8b\xe9\x8c\xed\x01\xb2\x7a\xe4\xa2\x98\x20\xa7\x73\x16\x5d\x28\x21\x55\x48\xbb\x2b\x13\xee\x2e\x17\x58\xd5\x6d\x6d\x7f\x3e\xbb\xa2\xee\xa9\x3e\x87\xe9\x2d\x43\x32\x69\x40\x49\x43\x0a\x60\x9f\xc9\x8c\x52\x17\x73\xfb\x60\xb3\xeb\x1e\xc2\xa4\x7c\x15\x07\x78\xd3\x4d\x2d\xa0\x9b\xdd\x17\xfb\xbf\xfe\xda\x7f\xf1\xc5\xcc\xe8\xae\x07\xcf\xed\xba\xe9\x46\x1c\x3b\x15\xf7\x88\x53\xd0\xa6\xd1\x6f\xa0\xbd\x0d\x63\x63\xb0\x1a\x6d\x56\xf8\xa3\x03\x6c\x5e\x95\x05\x57\xb1\xb6\x96\x5b\xd0\xc6\x91\x1b\x43\x02\x80\xe2\x9e\x8b\x09\x38\xb4\xf9\xc6\x9b\xba\xce\x7d\x70\x97\x78\xa1\xf4\x2f\x9a\x2e\x7d\x8f\x63\xfe\x4e\xb1\x9d\x3b\xc0\xf5\xd9\x53\x14\xc8\x4e\x9b\x96\xfe\x98\x5e\x05\x63\xf2\x0f\x31\xf4\x81\xd1\x5d\xc3\xae\x00\xa3\x4f\xa2\xaa\xa6\x26\x72\x3e\xd0\x2b\xb6\x33\x87\x99\x43\xd0\x76\x92\xd4\x16\xbd\xa7\xb4\xfd\xcd\x70\x45\x9d\x89\x2b\xb5\x8d\x8d\xfe\x9b\x0b\x6a\xde\x83\xb6\x49\xd2\xf6\x66\x14\x40\xfd\x94\x30\xcc\xd4\x73\x29\xe6\xc0\xe8\xef\x86\xd3\x35\x9e\x18\x6e\x4e\xc1\x7f\xd0\xde\x27\xd5\x6b\x80\xf6\x93\x01\x24\x6e\x3f\x5d\x82\x23\x6e\xe0\x82\x5c\xa7\x02\xe7\x08\x0d\xe6\x00\x65\x7c\x8c\xf1\x2a\x00\x48\x3b\x9f\xb8\xa1\xd4\x9f\xb4\x9b\x4b\xda\xd1\x2d\xa1\x84\xc5\x53\x6a\x17\x13\x8f\x95\xc1\x3b\x4a\x6f\x83\x5f\x58\x9e\xa0\x98\xd1\x3f\x0c\x67\x2a\x25\x90\x04\xde\xb1\x32\x78\x47\xe9\x80\xd4\x8e\x1e\x1d\x1d\x0e\x47\x25\x90\xd0\x6e\xa5\xb8\x90\xab\xd2\xbc\x0f\xed\x52\x80\x77\x9a\xda\x81\x7e\x8d\xdb\x53\xdb\xd0\x9b\x30\x5f\xdd\x23\x74\x2d\x97\xc2\x53\xc4\x63\x4f\x11\x17\x32\x0b\xb9\xbd\xd0\x76\x8a\xd4\x96\xba\x54\x6a\x4b\xdd\x00\xb0\x71\x5b\x9b\xd2\x36\x31\x7a\x8c\x5b\x41\xe8\x97\x2e\xa3\x1f\x1d\xe3\x52\x40\xee\xfd\xc3\xde\xb0\xc7\xa2\xa2\x1f\xae\x05\xb1\x98\xe0\x3b\x15\x60\x6b\x68\xf2\x7c\x2e\x86\x03\xf4\x5b\x41\xe6\x9b\x56\xd1\x8f\xcc\xe3\x1b\x05\x06\xee\x0f\xf4\x53\xfa\xe3\x76\xe8\x58\xb1\xdd\x9d\xc3\xb1\x8c\x56\x90\xdb\x25\x80\x7e\x6a\x78\x47\xe9\x05\xc5\x76\xd7\x0d\xfb\x02\x2a\x78\xc7\xca\xe0\x1d\xa5\x53\xc5\x76\xaf\x0f\xc7\x93\x25\x78\x23\xdf\x94\xc1\xfb\x2b\xfd\x17\x69\xdd\x22\x41\xaf\x3c\x41\x32\x8f\xd9\x23\xdf\x94\xc1\xfb\x2b\xdd\x58\x84\xf7\xfe\x70\x2a\xa6\xc2\x6f\x4a\x19\xbc\x2f\xe8\xa7\x8b\xed\xbe\x1b\x0e\x46\x55\xf8\x4d\x29\x83\xf7\x45\x19\xbc\x4a\x05\x5e\x9c\xa2\xd8\xcf\xb5\x51\x68\x97\xc1\xed\xf4\x87\x68\xfc\xb0\x92\x3b\x6f\xa6\x51\x12\x56\x02\x25\xe3\x49\xbf\x57\x62\x7b\xc2\xfa\x64\x9d\x47\x3f\x67\x16\x68\xb6\x42\x9f\x3e\xbc\xce\xf4\xe5\xd4\xde\xd1\x3f\xc3\x3a\x4f\xa4\x96\x51\x1f\x51\x86\x61\xfa\xd9\x10\x0a\x51\xb6\x25\xe3\xc1\x7f\xee\xff\x01\xfe\x36\xea\x97\xc7\xc3\x87\x79\x7e\x4e\xe8\x91\x91\xe7\xf9\x30\xa1\x2f\xaa\x8c\x24\x24\xc0\x32\x4c\x71\x0a\xb3\x80\x79\x5e\x82\x89\xdb\xa1\xff\x93\xd6\xc1\x1a\x4b\x39\xd8\x52\xbb\xb1\xf0\xbe\x56\xe0\x25\x1a\xfe\x13\xbc\xaf\xd1\xab\x45\xfa\x8e\x0c\xa7\x72\x12\x48\x02\x6f\x21\xfb\xb9\xe6\x2b\x7b\x0a\xfd\x8d\xb4\xbb\x09\xcd\x03\x3e\x77\xe4\x8d\x08\x36\x0e\x8a\x35\xb4\xd5\x78\x8b\x5c\xae\xec\xa1\x05\xdc\xcf\xa0\x3d\xe8\x0b\x9b\x86\xbe\x69\x27\x85\x5b\xd3\x75\x36\x20\x56\x76\x82\x45\x50\xed\x09\x4c\xdb\xf3\xc8\x1e\xaa\x50\xed\x21\x0c\x1b\x36\x11\x8a\x78\xc3\x7a\x63\x19\x6c\x2b\xae\x2d\xa2\xad\x81\xf6\xd3\xa4\xf6\xd4\xaf\xd0\x6d\xa4\x7d\x82\x4e\xa1\x03\xfe\x28\x6d\x28\x6b\xbf\x72\xf4\x33\x0d\xd2\x4c\x86\xf6\x95\xa4\xfd\xe5\xb4\x4e\x86\x9f\x02\xf8\x95\x89\x94\x36\x5a\xd6\xbe\x59\xec\x60\x3e\x63\xbf\x85\xf6\xd3\xa5\xf6\xd4\x30\xfc\x02\x64\x62\x8f\x0d\xcb\xc4\x7f\x0d\x77\xf7\x44\xbc\xe5\xf8\x6b\xdc\x04\xff\x2a\x19\xff\x5f\xcb\xf0\x81\x35\x10\x1d\x88\x71\x8e\x32\xf8\x39\x98\xef\x1c\xcd\x11\x68\x3f\x43\x6e\x3f\x09\x2d\x20\xed\xd3\x80\xff\xfc\x50\x22\x50\x8e\x7f\x5c\xdc\xa0\x71\x93\xb5\x94\xe0\x1f\x61\x22\xd2\x5a\x96\x40\x4b\x70\x41\x36\xcc\x21\x7b\x65\x86\x2c\x43\xf2\xd2\x5a\xa2\xd1\x63\xc3\x45\xa8\x0a\xbe\xf7\x16\xe1\x51\x6b\x09\xbe\x84\x97\x33\x98\x97\x51\x55\x52\x02\xab\xe2\x65\x09\xe7\xaf\x8b\xb0\xa9\xb5\x40\xf3\x1b\x28\xef\x63\x34\xc2\x55\xde\xd0\x81\xd1\x77\x87\x6b\xd2\xd2\x08\x52\x2f\x89\x67\x4a\x78\xf3\x5a\x90\xb9\x31\x19\xcf\x85\x25\x3c\x79\x0d\xb5\x63\x48\xe1\xd9\xb2\x79\x7e\xc9\x84\xe5\x79\x86\xd3\xe5\xf3\x9c\x52\x36\xcf\x2f\xe9\xee\xd2\x3c\xa3\x15\xca\x3c\x27\x80\x19\xf8\x7f\x04\x5e\xb5\xcc\xdb\x57\x14\xdb\x89\xc3\xce\xa8\x4e\x6e\x37\xfa\x3b\x68\x77\x06\x81\x37\x53\x6e\x97\x94\xf6\x14\x0a\x55\xb1\x74\x69\x5c\xd0\x30\xf4\xff\x6a\x23\x45\x78\xfa\x5a\xb4\x07\xd5\x53\xfe\xbc\x95\xa1\x91\x07\xd4\x25\x8d\x28\xbf\x20\x41\x95\x88\x20\xf7\x63\xa0\xdf\x90\xe6\x5a\xe8\x77\x14\xe6\x9b\xa2\xd6\xfe\xcf\x41\x2c\x05\x46\x45\xc4\x52\x15\x79\x1f\xb3\x3f\x86\xf6\xc6\x50\x8c\x46\x1f\x1a\xd0\xe9\x06\x34\x68\x40\xfb\x0d\x68\xaf\x01\x19\x40\x36\x2c\xd9\xb8\x71\x63\x53\x13\xfc\x5b\xe4\x05\x58\xbb\x0a\xa2\xc7\x6a\x65\xfd\xf5\x20\xd1\x37\x28\x0c\xac\x76\x00\xf6\xac\x3f\x64\xd7\xa8\x78\x13\xaf\xdb\xe9\xda\x34\xb4\xef\x97\x75\xd8\x5b\xb0\x6e\xb8\x3d\xde\x2a\xa0\x5b\xfc\x21\x8f\x41\xcd\xcb\xc0\x6b\x15\x84\x66\xb5\x32\x0f\xfd\xbd\x48\xb3\x5f\x0d\xfb\x22\x12\x6c\x99\xd7\x4e\x27\x34\xeb\x97\xdb\x35\x17\xdb\xfd\x05\xda\x79\x14\x5e\x13\x8f\x95\xc1\x3b\xca\xb8\x8a\xed\xbe\x1c\xf6\x07\x55\xf0\x8e\x95\xc1\x93\xf4\x15\xac\xbd\xc6\x1f\x94\x11\x2c\xee\x05\x8e\x22\xf0\xea\xe4\x71\x6f\x95\xda\x99\x78\x97\x41\x5b\x6a\x97\x11\x37\xe0\x3c\x1f\x68\x37\x20\xeb\x49\x79\xcf\x50\x06\x5e\xbd\xa6\x04\x1e\x91\x0d\x75\x92\x8c\x46\x53\x51\xbf\x02\x57\xf7\x08\xe2\x15\xbb\x60\xf4\xb7\x00\x73\xb2\x66\xaf\x04\x13\xb7\x1d\x7d\x0c\xdd\xa0\xc0\x86\xb6\x06\x5a\xb1\x0b\x60\xde\x65\x78\x1e\xa5\x9f\x94\xc6\xcf\xd8\x1c\x2a\x3c\x47\xff\x26\x1e\xa3\x97\xaa\xf0\x3c\x8a\x12\x52\x3b\xce\x68\x2e\xc7\x73\x4a\x19\xbc\x2f\x64\xfd\x8b\x86\x9c\x1e\x35\xbc\x4f\x81\x97\x37\xab\xe0\x7d\x81\xea\xa4\x76\xbc\xc5\x5e\x06\x8f\xa2\xb4\x43\x84\x8f\xea\x25\xbe\xa0\x27\x49\x7c\x14\x22\x7c\x74\x6c\xd8\x17\x34\x3a\x55\x7c\xd1\x02\x7c\xb7\x9b\xd8\x44\x83\x72\x7b\x6c\x27\x60\x99\x95\xb3\xa5\x50\x5b\x5d\xb6\xda\x54\x2e\xb3\x08\xfc\xf7\x8a\xf0\xe9\x9b\x81\xdd\x08\xfc\x18\x81\xff\x1c\xd8\x34\xe3\xc0\xbf\xb2\x08\x1f\xda\x1b\x64\xf8\x2d\x00\x1f\xd5\x36\x8e\x85\x2f\x6e\xd0\x0e\x11\x7a\xd4\xcb\x32\xb1\xbf\xc8\x57\xd7\x2a\xb0\x31\x5c\xe0\xe7\xdd\xcc\x8b\x0a\xdc\x23\xcc\x72\x99\x0f\x14\x90\x04\x1e\x58\x21\xdc\x03\x04\xdf\x06\x59\x26\xef\x95\xf0\x0d\xca\xf4\x70\xfa\x6c\x6c\x39\xbe\xb2\x0c\x9a\x25\xeb\xa0\x4f\x88\x8e\x40\x49\x1b\x6e\xff\xef\xe1\x40\xcc\xa7\x53\xb5\x4f\x03\x9f\x3d\x40\xf0\x6d\x90\xf9\xf6\xa3\x92\xcc\x2a\xc2\x96\xf0\xc5\xf9\x50\x0a\x5c\x95\x0c\x2f\xc1\x24\xf0\x8e\x95\xc1\x3b\x4a\x1f\x2e\xb6\xfb\xd7\xb0\xe0\x56\xc1\x3b\x56\x06\xef\x28\xdd\x51\x6c\xf7\xed\x70\x30\xac\x82\x37\xa5\x0c\xde\x17\xf4\xe7\x12\x9d\x18\x4f\xc0\xa6\xb2\x2b\x5a\xb0\xec\x55\xc1\xfb\x82\x9e\x2a\xb5\x43\x91\x84\x3c\xe1\xa2\xce\xe5\xde\x26\xf6\x52\x96\xc8\xca\xe7\x89\xce\x02\x1d\xc3\xd0\x11\x2c\x2a\xe9\x48\xb5\xc9\x36\x46\xc7\x90\x77\x55\x35\x7f\x86\x3e\x43\x64\x7f\xdd\x4a\x3d\x34\xfa\x22\x91\x59\x0f\xa3\x39\x54\x34\x2f\x30\xaf\xd7\xa3\xfd\xf5\xa8\x3e\x6f\xb4\xf6\xd5\xd3\xaf\x47\xd0\xfe\x08\x6c\x3d\x2c\x1c\x6d\x55\x58\x42\x2a\xe3\x46\x94\x71\x5f\x20\xe3\x82\x8c\x66\xc9\xc0\xac\x7a\x64\xb5\x8c\x96\xc6\xbe\xf8\xb8\xb1\xd7\x52\xf7\xa1\x6a\x2a\x9e\x77\xb1\xa5\xc1\x6d\xe3\x0d\xfe\x03\xf3\x3e\xc4\xb8\xe1\x17\xde\xc7\xe4\x69\x63\x4e\x0a\x45\xd4\x33\x57\xc6\xde\xa6\x8c\x7d\x39\x75\xbf\x6c\x87\x5e\x4e\x7d\x4c\xec\x44\x0f\xf2\xc8\x76\xe2\x58\xf8\xcf\xfd\x3f\xc0\xdf\x46\xfd\xfa\x38\xf8\xd8\x16\xbb\x8f\xc8\x85\x9c\xac\x5f\x26\x4b\xb6\x0c\x0d\x82\x81\x9e\xe5\x0b\xda\x5d\x65\xfb\x50\xca\x0f\xc7\x72\x61\xb6\xdc\x5e\x2b\xed\x5b\x1a\x36\x02\xbd\x38\x9a\x10\xb8\xb1\x72\x01\xe0\xbf\x57\x84\x5f\xb2\xf5\x88\xc3\x64\xf2\x86\xc7\x85\x7f\x65\x11\x3e\xec\xb3\x63\x32\xfc\x0a\x80\xdf\x14\x49\x1d\x0f\x9f\x7b\x87\xc0\x6f\x92\xe1\x37\x4b\xfe\x58\x9a\xf8\x63\x7b\xc1\x0e\xd2\xdb\xcb\xf7\x31\x73\x22\x81\x3f\x57\x86\x7f\x85\x2c\x77\x42\xb0\x91\x5d\x82\xdf\xc1\x8d\x95\x3b\xdc\x3b\x64\x9f\x34\xc9\xf2\xc4\x28\xd9\x0a\x26\x05\xb0\xbc\x4f\x36\xe0\xbc\x38\x05\xee\x11\xd4\x5b\xdc\x77\xdb\x86\x8b\x50\x8b\xf0\x88\xfe\x69\x22\x6b\x43\xe0\x61\x9b\x13\x2d\x25\x7e\x29\x53\x59\xf2\x4b\x09\x4c\x62\x97\xce\x95\xda\x62\x98\xe0\x43\x5e\xbe\x8e\x52\x74\x8e\x1a\xb7\xa3\xf4\x1b\x45\x5b\xfe\x4d\xf0\x85\x25\xf4\x24\x99\x50\x86\xdb\x51\x74\x67\x11\xb7\xff\x1d\x76\x79\x14\xdc\xd6\x81\xaf\x1a\x20\xb4\x6c\x96\x69\xf3\xa6\x24\x13\xb3\x44\x26\xfe\x65\xb8\xa2\x2e\x13\x57\xd1\xb2\x6b\xf4\x33\xfa\x53\x42\xcb\x79\xc4\xe6\xbf\xb9\x86\x48\xc4\x2c\x91\x88\x5f\x40\x6b\x81\x2a\xa3\xe5\x3a\x90\x75\x01\x6e\xa6\x02\xff\x08\x9d\x2c\xe2\xf1\xa1\x02\x1b\xc3\x05\xbd\xfb\x29\x91\x39\xf3\x64\x5a\x9e\x5f\x6c\xf7\xb9\x02\xb5\x88\x2f\xd9\xfb\x04\x9e\xfe\x45\xfa\x8a\xa2\x8f\x36\x01\xdb\xb5\x53\xaa\xdb\x24\x98\x2a\x99\xd3\x85\x6b\x59\x71\xb7\x14\x61\xeb\x5f\x44\xbf\x13\x77\xca\x7d\xb0\xab\xd2\x59\xdd\x26\xc1\x57\xf5\x19\x3b\xce\x4b\xf4\xa4\xe2\x38\xd5\x78\x1c\xaa\xb6\x72\xbc\x71\x80\x36\xff\x50\xc6\x79\x09\xdd\x2e\xbe\x25\xf7\xc1\xe3\x98\x6a\x2b\x8f\x1f\x07\xd3\xa7\x48\x7f\x58\x6f\x42\x7f\x85\x4e\x60\x6f\x64\x4b\xbc\x41\x68\x54\xa4\x3d\x9f\xc2\xb4\xe7\x8b\x94\xc2\xbf\x07\x29\xc8\xb5\x10\x58\x2d\xf2\xbe\x98\xa3\xd6\x6f\xa3\xa0\x83\x4a\x5e\x16\xa9\xe7\xfa\x19\x7d\x3b\xe1\xcb\xf9\xf2\xda\x6b\xa8\x03\x94\xf7\x71\x74\xae\x1b\x6d\x70\x23\xa2\x12\xdd\x41\x8d\xa4\xc2\x65\xd9\x1b\x01\x5e\x6e\x21\xfc\xd7\x22\xaf\xe7\x03\xb2\xae\x55\x80\x4b\xb5\x62\x01\xd7\xdb\xd9\xf3\x14\xd8\x47\xd0\x1e\xa9\x5d\xb5\x02\x51\xc2\x19\xf8\x59\x0d\xef\x28\x7d\x4f\x49\x67\x0a\x6e\x09\x24\x81\x77\x8c\x7e\x59\x05\xef\x28\xba\x52\x86\xe7\xf1\x95\xc3\x9b\x52\x06\x4f\xf1\xb1\x35\x9e\x40\x39\x7e\x53\xe8\xbf\xaa\xe0\x7d\x41\xf6\x07\xb4\x9b\xe8\x0f\xab\xe1\xe5\xc4\xab\xb9\x1f\x11\x78\xad\xa4\xdd\x47\xc4\x26\x33\x3f\x0e\x1c\x50\x11\x77\xe8\xa4\xd5\x84\x76\x61\xf1\x6a\xfc\xc6\x34\xb4\x5b\x20\xb7\xeb\x96\xdb\xd9\xd2\x51\x9d\x4b\x69\x07\x7e\x4d\x19\xbc\xaf\x8b\x36\x1e\x15\xab\x73\xa8\x74\x6b\x18\x74\xb0\x1a\xde\xd7\xf4\x04\xd9\x06\x8e\xd4\x48\xe0\x14\x3f\xa9\x0c\x9e\x62\x33\x52\xa1\xd8\x7f\x82\xf7\x05\x3d\x5b\x6a\x97\x0c\x44\xca\xe0\x8d\x7e\xce\xfd\x88\xe8\x9e\xd6\x72\x9d\x4e\xa3\x38\xe6\xfb\xf6\x78\x5d\x71\xd6\x0a\x0f\x87\x47\x3f\x66\x3b\x88\x4e\x5f\x20\xeb\xd5\xbf\xc8\x3a\xfd\x88\xa4\xd3\x69\xb5\x4e\x47\xe3\xea\x74\x69\xdc\x88\x32\xee\xcb\xf4\x3f\x25\x9d\x0e\x1e\x57\x13\xf1\xbb\x1c\xb9\x26\x79\x64\xb5\x4e\x97\xc6\xb6\x28\x63\x5f\x4e\x1d\x19\x7d\x9d\xe8\xf4\x23\xe0\xd1\xc7\xf2\x2e\x86\xae\xca\xeb\xf9\x3e\x86\x36\x55\x25\x35\xe0\x60\x9a\xbc\x3e\x0d\xf1\x33\xe5\x29\x00\x0c\xf7\xe8\x61\xee\x41\xcd\x07\x00\xa3\x8d\xd0\xe6\x56\x74\x85\xb4\x6f\xac\xf2\xbe\x71\x27\xb4\x48\xb5\x6f\xc8\x9b\xcf\xdc\xd5\xd0\xbe\x20\xb5\xa7\xee\x95\xec\x42\x2b\x91\x82\x22\xb4\x67\xcd\xaa\xf6\x6e\xd8\x33\x0f\x92\x35\x6a\x93\xf7\xcc\xa7\x12\xed\xb5\x56\x41\x06\x2c\xd7\x0a\xde\x40\xde\x92\x2e\xc2\x3d\x42\x6b\x65\xde\xb5\x0a\x32\x40\xd2\x2e\x38\x7a\x58\xfb\x21\xd1\xdf\x13\x88\x3e\x9e\x48\xdf\x2f\xe1\x2b\x10\x7c\x3f\x1a\x76\x79\x35\x6a\xfd\x47\xde\xa4\x26\xfa\x7b\xa1\xd4\x1e\x5d\x24\xe1\x2b\x10\x7c\xdf\x87\xf6\x16\x4e\xd5\x7e\x2c\xfc\x6d\xcc\x80\x1c\xeb\xc0\x03\x3c\x2f\x78\x4a\xd0\xa9\xf1\xe0\x6f\xa3\x6d\xb2\x7e\xc5\x03\xdc\x21\x78\x2c\xe5\xfa\x55\x82\x7f\xaf\x02\x7f\x2d\xfd\x6d\x31\x36\x21\x60\x1e\x3b\x21\x11\x92\x46\x50\xf1\x98\x34\xc6\x42\x65\x8c\xb5\xe8\xa1\x22\x5f\x0a\x58\xb6\x26\x13\x21\x0b\x37\xa6\x8f\x34\xce\x7b\xc5\x71\xc0\xdf\x78\x57\x9e\x07\x76\x80\xb2\x82\x5f\xeb\x18\x67\x1e\x57\x16\xc7\x00\xf9\x79\x40\x65\x27\xd4\x08\x7e\xab\xa6\x7c\x1e\xe0\x9f\x7c\x48\xd6\x55\x82\x7f\x84\x75\x4a\xeb\x25\x28\xa0\x25\xb8\xb0\xfe\x4f\x93\x75\x5d\x28\xaf\xeb\xc7\xb2\xff\xa7\x80\x24\xed\xc0\xdb\xe2\xf6\x13\x7c\xdb\xe5\xf1\x77\x4b\xeb\x9a\x24\xeb\x7a\x14\x7c\x03\xd6\xad\x5a\x27\x1d\xd8\x35\xdf\x10\x7c\x17\xc9\xf2\xfb\x56\xb5\x7f\xf2\x4f\x68\xef\xb1\xaa\xda\x4b\xf0\xef\x2d\xc2\x07\x1a\x62\xf8\x38\xbe\x43\x42\x42\x07\x46\xbf\x1e\xae\x4a\x4a\x23\x28\x76\xa5\x34\xc6\xc2\xe2\x18\xb0\xaf\x6e\x25\xb6\x28\xf4\xb1\x91\x3e\xdf\x40\x1f\x69\x14\xa5\x0f\x78\xb7\xdc\x6d\x64\x1e\x1d\xf2\x3c\x1e\x51\xd1\x3d\x2d\xf8\x0d\xe5\x74\x77\x8a\x53\x98\xcf\xc8\x3c\x16\xcb\xf3\xf8\xa3\x4c\xf7\x34\x4c\x24\x1b\x4a\x30\xe5\x7e\xe1\x49\x60\x5f\xfe\x9d\xc4\xa9\x3a\x49\xfb\x4b\xd0\x16\x19\xbe\x1f\xc7\x29\x9d\x1e\x3b\x5f\xd6\x9e\xd4\x50\xe4\xee\x84\xf6\x4b\xa4\xf6\x8a\xfd\x17\x00\xf8\x21\xc1\x8b\xca\xf9\xf9\x24\xd8\x87\x7f\x27\xeb\xda\x29\xaf\xd7\x39\x45\x9d\xf4\xfb\x61\x87\x57\x82\x2e\xc5\x1f\xc8\xdb\xee\x45\xb8\x47\xd0\x53\x25\xbf\xcb\xe9\x43\x45\x5b\xec\x24\xf0\xcf\xd4\xf0\x8e\x82\x94\x92\xdb\xfd\x79\xd8\xe9\x52\xc1\x3b\x56\x06\xef\x28\xba\xaf\xd8\xee\x08\xe8\x42\x05\x1e\x8e\xa3\xa8\x63\x63\x2a\x7f\xef\x3b\xb0\x01\x95\xd8\x18\xd1\xef\xdc\x47\x45\x1d\x07\x6b\x67\x80\x99\xa7\xf2\x3c\x8d\xf6\xa7\xd0\xde\x14\x3a\x37\x85\x36\xa4\x10\x4d\x64\x56\x2a\x22\xa9\x3d\xac\xe9\xb1\xab\xa3\xec\x87\x57\x14\xbe\xbd\x05\xa7\x7d\xab\xf6\x9c\xcb\x13\x92\xd8\x57\xb5\xe7\xa4\xb5\x7c\x45\x59\xcb\x5b\xc8\x5a\x92\x3e\x21\x12\x16\x8e\xa6\xa5\xd5\x54\xf5\xe9\x05\xfb\xec\x30\xe9\x23\x9d\x65\xed\xa2\x7e\x25\xdb\xff\xf5\xd0\xc5\xdc\x50\x63\x2a\x97\x1f\x20\x15\xe9\x3d\xda\xa4\x3d\x85\x7a\x8a\xf6\x3c\xba\x41\x5a\x4f\x3a\x85\x6e\x70\x78\x6d\xaa\x7d\x8a\xef\x20\x8c\x7e\xc3\x3d\xcc\xcd\x02\xff\x7f\x5e\xbe\x56\x97\x0c\x5b\x62\x06\xc1\xe3\x61\x0c\x96\x24\x57\x91\x89\x19\x8c\x46\xc3\xf2\x82\xd1\x48\x05\x02\xb6\xe5\x85\x00\xeb\xf2\x2c\x2b\xb8\xec\x14\xb7\xbc\xc0\xe0\x1b\x93\x59\x75\x25\x88\x71\x32\x2c\xe5\x7c\x25\xe9\x76\x02\x1f\x4d\x2b\xa5\x7e\x48\x45\x8e\x46\x2a\x1a\x61\x8b\xef\x2c\xb2\xcc\x19\x0f\x6d\xda\x75\xe1\x05\x7b\xc5\xad\x68\xef\x0d\xbb\x37\x6f\xbf\x4c\xf4\x3d\x80\xaa\x11\x8f\x38\xd4\x7e\xd3\x25\x8f\xfd\x4e\x7c\xd5\xd8\xb2\x24\x75\xd9\x79\xc8\xb6\xfd\xc2\xb3\x4f\x39\xff\x67\xfb\x8e\xad\x9f\xee\xa3\xff\xf6\x0d\xb2\x3c\x73\xf3\xc6\xdb\x03\xf6\xa7\xae\xd8\xf7\x3f\x84\xc6\x1b\x4a\xe7\x84\xd8\x02\xa4\xef\x92\xcf\x04\x37\x94\xce\x04\x89\x65\xf8\x89\xb4\x26\xb0\x1f\x0f\x68\xde\xb4\xcb\xe7\x8a\xfa\xef\x18\x4a\x3a\x0f\x0b\x94\x6c\x4b\x69\x0d\x56\x17\xfb\xea\xbf\xa3\x93\xa3\x7f\x2e\xf6\x25\x7a\x59\xea\xfb\x3d\xfd\x31\xf4\x35\x0c\x33\xb4\x83\x74\x6e\x92\xfa\xb2\x46\xee\x4d\xa5\xef\xf7\x48\x2c\x8d\xab\xea\x7b\xec\xf8\xbe\xa3\x5f\x91\x71\x4b\x7d\x8f\xfd\x40\xdf\x91\xf1\xc7\x2d\xeb\x3b\x52\xd6\xb7\x5b\xe9\x2b\x42\xdf\xd4\x78\x7d\x35\x5e\xa5\xaf\x58\xec\x8b\x69\x4b\x64\x4b\x82\xd8\x13\x97\xa0\x3d\xb2\x3d\x7e\x17\xb1\xc7\x65\x10\x25\x7a\x13\xb9\x32\x49\x6a\x8b\xed\x80\xb1\x74\x57\xcd\x61\x54\x99\x83\xf7\x07\xe7\x30\x3a\xfe\xfc\x0d\xd4\x7f\xef\x6b\xa0\x7e\xa0\x2f\xfa\xef\xb4\x33\xa0\xb2\xbe\xb3\x95\xbe\x34\xf4\xad\x27\x7d\x2b\xc7\xd0\x2e\xae\xf4\xa5\xcb\x68\xf7\x95\x42\x3b\x42\x33\x72\x8e\xb4\x47\xf2\x73\xc3\x63\x69\xf7\x33\x85\x76\x37\x51\x8f\x94\xd1\x0e\x7c\xe6\xd2\xd9\x16\xe1\xf1\x9b\xe5\x33\xa7\x0d\xa5\xb3\x2c\xd2\xfe\x5b\x25\xe6\xf0\x39\xe1\x71\xe9\xec\xee\x3b\xfa\x09\x32\x26\xd6\x9d\xca\x99\x2f\x3e\xab\x23\x3c\xde\x27\xf3\xb8\x8d\xf0\xb8\xd4\xf7\x83\x62\x5f\xb0\xff\x2e\x92\xfa\x26\xc6\xf6\xbd\x5a\x19\xf7\x56\xea\xfa\xd2\xb8\x84\xd6\x19\x79\x7f\xfc\x9c\xd0\x9a\x96\x3b\x37\xc9\x7d\xff\x4e\x68\xdd\x27\xef\x8f\xc3\xe3\xf6\x3d\xa6\xf4\x0d\x2b\xfb\xe3\x2d\x32\x6e\xa9\xef\xb1\x1f\xe8\x3b\xf2\x03\xe3\x0e\xab\xfa\x8e\x94\xf5\xed\x56\xfa\x8a\x60\x3f\xa6\xca\xc7\x95\xcf\x35\xbd\x4a\x5f\xb1\xd8\x17\xaf\x0b\xd9\x1f\x19\x79\x8d\x6f\x96\x75\xf0\x1c\x49\xa6\x64\xd4\x67\xec\xb0\x56\x64\x7f\xf4\xc9\xfb\xe3\xa6\xb2\x35\x23\x67\x2d\x64\xcd\xa4\xb3\x96\xef\xd0\xfd\x12\xdd\x85\x12\x8c\x1a\x68\xe3\x27\x6b\x76\x54\x5a\x33\x34\x8d\xac\xd9\x64\xf0\x2f\xff\xb7\x78\xee\xc3\xcb\xfe\x25\x6e\x0f\xdf\xfb\x8b\xe7\x3c\xe4\xfb\x84\x14\xb3\x03\xde\x7c\x9b\xc4\x21\xb2\xd2\xf7\x4c\x48\x8a\x09\x02\x8e\x0f\x93\xb8\xc3\x90\xcc\x67\xaa\x18\x1f\xc1\x2d\x2b\xcb\xcc\x89\xd2\xfc\x22\x25\xdc\x48\xcc\x8d\xe0\x36\x54\x26\x33\xc7\xc6\x27\xbf\x67\x82\xd2\xda\x30\x6e\x85\xbe\xd0\x97\xb5\x90\xb5\x91\xfa\x7e\x0f\x0e\xe5\x78\xb1\xcd\x63\x4a\x5f\x9f\xc2\x13\xff\x20\xe3\x96\xfa\x1e\xfb\x81\xbe\x23\x72\x5f\x86\x2e\x1b\x97\x79\x4b\xd5\x77\xa4\xac\x6f\xb7\xd2\x57\x84\xbe\xa9\xf2\x71\xe5\x18\xa3\x57\xe9\x2b\x16\xfb\x62\xda\x12\x9e\xc8\xca\xf1\xad\x90\xcc\x13\x2f\x4b\xfb\x3e\xae\xa2\x19\xa6\x37\xe1\x89\x21\x99\x27\xee\x19\x4b\x77\xcd\x42\xec\x7b\xa0\x93\x8a\x67\x10\xc7\xf1\x15\xa6\xdd\x72\xec\x6f\xa0\x15\xe4\xcc\x71\x1b\xf5\xd1\xb8\x7d\x27\xa2\x6b\xff\x6b\x5f\x1c\x7f\x2d\xf5\x7d\xb3\xd8\xb7\xb4\xde\x0d\x63\xfb\xae\x2e\xf6\x55\xaf\x37\xf4\xfd\xa0\xd8\x17\xe4\xc7\x8b\x3f\x30\xee\xb5\xc5\xbe\x20\x3f\xee\xc4\xd7\x57\x30\xed\x34\x0b\xb1\xed\x83\xfb\x96\xf3\x25\xbb\x9c\xbd\x59\x69\x5f\xa4\x4f\x0e\x68\xad\xf8\xfb\xe4\xfb\x3f\xcb\xfe\xfd\x86\x92\x7f\x4f\xbe\x6f\x2f\xf9\xf3\x84\x8f\x5b\xe5\x79\xd5\x49\x7b\x4c\xb5\x26\xc4\x87\x26\x7c\xbc\x40\x9e\xd7\x7c\x32\x2f\xe8\xab\x99\x49\xe8\xb9\x51\x5e\x8b\x06\xa9\x6f\x65\x79\xdf\xc3\x84\x9e\x9b\xa4\xb5\x40\xce\xe2\xb8\x65\x7d\x27\xa2\x2b\xff\x6b\xdf\x89\xd4\x01\x55\xdf\x37\x8b\x7d\x4b\x38\xe7\xc6\xf6\x5d\x5d\xec\x5b\x8e\xb3\xd6\x51\xec\x0b\x6b\x71\x29\x3a\x7f\xdc\x71\xaf\x2d\xf6\x85\xb5\xf8\x80\xac\x05\xd0\x56\x33\x93\xac\xc5\xc6\xe3\x68\x7b\x98\xac\xc5\xa6\x32\xda\x4a\x7e\xce\xfb\x45\x3f\x07\xe6\xb8\x5e\xed\x87\xbf\x08\x7e\x75\x59\x1c\x5a\xb2\x8d\xf7\x16\x6d\x63\x98\xef\xb5\x92\xbf\x16\x22\xfe\xda\xab\xc3\xe1\x18\xad\x8e\xcf\xe1\xfb\x42\xb7\x91\xb5\xee\x90\xc7\xfd\xaa\x64\x63\x93\xb5\x5e\x2c\xf3\x8c\x53\x85\xcf\x9b\x45\x7c\x4a\x74\x0b\x95\xe6\x2e\xe1\xb0\xba\xd8\x17\xe8\xd6\x45\xe8\x46\xfa\x62\xba\xc9\x3e\xdb\xad\xe8\x12\x89\x6e\xc2\xd8\xbe\xd7\x2a\xe3\xde\x4a\xdd\x4d\xe8\x36\x03\x78\xfb\x24\xee\x26\x7b\x8a\x59\x81\xfb\x6a\xaf\xa1\xbe\x24\xf3\xa2\x5b\x6c\x38\x1e\xff\xf1\x70\x4b\x63\xc9\x83\x1b\xa7\xfd\xab\xd4\x3f\xa5\xf6\x29\xd2\xfe\x1f\xc3\x15\x2d\xe3\xb4\xbf\x5b\x69\x7f\x3b\x81\x8f\xcf\x43\x3a\x6d\xe4\x3c\xe4\xc8\x70\x67\x95\xda\xab\x18\xa7\xcf\x3e\xea\xdf\x72\x9f\x6a\xa9\xcf\x17\xc3\x75\xff\xad\xcf\x1d\x4a\x9f\xce\x62\x9f\xce\xca\xff\xd2\x67\x3f\xf5\x5d\xf9\x38\x47\x87\xeb\xc6\xed\xa3\xd9\xa7\xf4\xf9\x99\x32\xce\x80\xd4\xe7\xdf\xc3\xb5\xed\xff\xa5\xcf\x83\x4a\x9f\xae\x1f\xec\x43\x6c\x39\x6e\x8e\x6c\xcb\x69\xb4\xd7\x7c\xfd\x24\xa5\x7d\x98\x0e\xb1\x54\xf7\xb8\xbf\x7f\xf5\x1d\xf2\x7b\xaf\xfc\xfb\xd1\xcf\x29\x4a\xb3\x80\x5b\xce\xa7\xe1\xf7\xb7\x91\x16\xb7\x43\x0b\xfd\x23\x0c\x9d\xc0\x4d\x7e\xa0\xcd\x3e\xb9\x4d\xb8\xd8\x06\x57\x75\xe3\xfe\x06\x6d\x60\x9c\x2c\x6e\x71\xc7\xe7\x65\x50\x28\x19\x4e\x59\x9b\xfd\xe5\x50\xa8\x22\x9c\x03\x9a\xcb\x15\x7c\x7f\x36\xf2\x3e\x69\xd3\xac\x82\xf3\xfe\x98\x36\x0f\xbe\x23\xb5\x69\x50\xc1\x69\x05\x3d\xd6\x43\xf8\x6f\xb5\xcc\xaf\xcf\xc8\xf1\x80\x3c\x6c\xc4\x81\x7c\x27\x57\x5b\xe6\x6f\x8e\x6d\xff\x2a\x75\x8d\xdc\xbe\x0e\xda\x57\x66\xf3\xe3\xb6\xbf\x5b\x69\x7f\x3b\xb5\xab\xe8\x03\x4f\xc1\x3e\xb0\x65\x4a\xa3\xd4\x43\xe5\x03\x8f\xed\xb3\xaf\xd4\xa7\x89\xf4\x69\xfd\xef\x7d\xee\xa0\xee\x2a\x1b\x27\x37\x25\xf7\x5f\xfb\xec\x2f\xf5\x21\xe3\xb4\xb6\x1e\xdf\x07\xe8\xae\xa1\xfe\x3f\xde\xde\x03\xc0\xa9\x2a\x7d\x1c\x3d\xdf\xb9\x25\xb9\xe9\x75\x92\x99\x4c\xcb\x64\x7a\x66\x26\x33\x93\x29\x0c\x6d\x12\xea\xd0\x04\x29\xa3\x21\xc0\x0c\x48\x47\x05\x14\x6c\xa8\xa0\x62\x59\x11\x11\x7b\xa7\xc8\xba\xa8\x08\xac\x02\xa2\xae\x65\x15\x2b\xb2\x96\xb5\xac\x2b\x96\x5d\xdb\xee\x5a\x60\x5d\x7e\xae\x32\xe4\xce\x3b\xe7\xdc\x9b\xe4\x26\x33\xa0\xbf\xf7\x7f\xff\x97\x99\x9b\xdc\xdc\x7c\xe7\x3b\xed\xeb\xa7\x09\x1d\xa4\x8f\x2b\xc1\xa9\xb4\x58\x6f\x6b\xef\x4e\x42\x2b\x50\x91\xa4\xa5\xbe\x30\x6f\xf4\xd6\x2b\x30\x25\x1a\x18\xdd\x15\xc2\x54\x0a\x83\x6f\x55\xe8\xe9\xbb\x9d\xa4\x77\x30\xd4\x6a\x69\x25\x0b\x66\xa7\x0a\x53\x79\x0a\x98\xad\xbf\x02\xcf\xae\x3e\x78\x8a\xe4\xf1\x7c\x98\xf5\xeb\x22\x95\x0e\x7a\xd5\x7e\xad\x23\xfd\x1a\xa8\x0b\xba\xf8\x8c\x7e\xcd\x86\x7f\x03\x90\x0a\x5f\x40\xe0\x83\xc5\x75\xfd\xc2\x3f\x98\x82\xdf\xc2\x78\x96\xb5\x75\x13\x6d\xeb\xfc\xa6\x12\x25\x85\x36\x96\x9e\x95\x66\x67\x3a\x4d\x80\xa5\x29\xff\xe5\x34\x5b\xe9\x1c\x2c\x4d\x3e\x23\x9a\xfc\xbf\x98\x66\x57\x3a\x0d\xcb\x67\x4c\xf9\x49\xd2\x30\x19\xb4\x48\x23\xb7\xd2\xf4\x56\x51\xd6\xf8\x8b\x69\x76\xa7\xd3\x34\x9f\x24\x4d\xef\xbf\x48\xdf\x55\x33\x5a\x0a\xa6\xe8\xad\xb8\x2f\xbd\x65\xc1\xf4\x4b\x6f\xfa\x47\x18\x0d\x04\x4f\x45\x6f\x59\x30\xfd\xd2\x5b\x16\x4c\xbf\xf4\x96\x05\xd3\x97\xde\x18\x8c\xb8\x4e\x03\xa3\x48\x30\x0c\xed\xa7\x80\xd9\xad\xc2\x0c\x4c\xc1\xb0\xb3\x11\x18\x1d\x2e\x51\xe4\xfa\x37\xcc\x8a\x28\x61\x56\xc4\x3f\xf6\x94\x14\x89\x96\x0c\x3a\xcc\x86\x7f\xe3\xdf\x0c\xde\x6e\x57\x66\x87\xb9\x4a\x32\xe1\x7b\xff\xcc\xe0\x1f\x4c\xc1\x6f\x79\x2e\x23\xe2\xfb\xd4\x9e\xca\x1c\x25\x85\xa6\xcf\xb2\xd3\xec\x54\xd3\x78\x92\x69\xf2\xfa\xa4\x41\x2e\x92\xe6\x4a\x4d\x9a\xad\x99\x91\xe5\x9e\x3d\x95\xee\x7e\xd3\xdc\xa0\x49\xb3\x2b\x49\x4d\x2c\x23\x94\x97\x91\x42\x89\x2f\xe1\xdb\x18\xfd\x29\xf0\x0f\x7c\xa7\xe4\x31\x50\xc9\xe3\x3f\x7b\x72\xcb\xfb\xd4\x25\x3b\xcd\x6e\x35\x4d\xd5\x29\xd2\x10\x9a\xe5\xbe\x61\xf4\x58\x93\x4d\xb3\x1e\x0d\x3d\x66\xc1\xa4\x68\xd6\xa1\x81\x11\xce\x66\x74\x54\x93\x45\xb3\x05\x19\xfa\x34\x13\x26\x49\xb3\xde\x53\xc0\x6c\xfd\x15\x78\x76\xf5\x8f\x87\xd1\x63\x4d\x16\xcd\x86\x4e\x01\x93\xa4\xd9\xea\x14\x8c\xe2\x2b\xdf\xad\xf8\x7d\x4c\xd6\xee\x52\x6c\xbe\x2a\x66\xf3\x25\xf6\x54\x95\x8b\x48\x63\xf3\x65\xc3\xbf\x41\xe3\x43\x2c\x26\xec\x25\x09\x74\xbe\x2a\x31\x73\x9e\x81\x02\xff\x60\x0a\x7e\x0b\x7a\x4c\xb5\x8f\x42\x8a\x7d\x94\xd8\x13\x2a\x10\x51\xdf\x39\x33\x9a\x34\x3b\xd1\x3d\x6a\x9a\x42\x25\xcd\x57\x7b\xfc\xbf\x94\x66\x2b\xb3\x1d\xd8\x9c\x27\x96\x91\x14\xca\x17\xb3\xc7\xf8\xb3\xd3\xec\x4a\xa7\x61\x19\x59\xfc\x7d\xd2\xf4\x1e\x21\x3e\xe5\x7d\xc2\x78\x1b\x3d\x4f\xf2\x55\x95\x9e\xca\x18\xad\xe0\x94\x7c\x13\xfb\xc0\xbc\xd1\xdb\xac\xc0\x14\xa4\xe8\xa9\xf7\x5b\x7d\x2e\xeb\xe3\x46\x3a\x83\x21\x45\x4f\x1c\xd6\xc8\xa5\x3e\x30\x3b\x55\x98\x80\x16\x46\x77\x95\x02\x03\x3b\x35\xf4\x94\x85\x27\x0b\x66\x57\x1f\x3c\x85\xa4\x2d\x3e\x65\xb2\xe8\x42\x95\x0e\x0e\xa9\x3a\x94\x70\x3d\xe4\x57\x96\x09\xae\x8c\x7e\xcd\x86\x7f\x03\xbd\xa2\xc2\x13\x86\x87\x82\xbc\xca\x7e\xe1\x1f\x4c\xc1\x6f\x41\xcf\x25\x25\x44\x1d\x65\x5f\x63\x5d\xbe\xe0\xca\xea\x9f\xec\x34\x3b\xd1\x7a\x55\x12\x15\xd8\xd5\x79\xcf\xc5\x19\xa9\xfa\x49\xb3\x35\xad\xd7\x58\x3e\xa3\xea\x7c\xbf\x98\xcf\x2e\xf4\xb7\x64\x1a\x96\x51\x63\xf1\x49\xd2\x30\x59\x74\xa1\xaa\x73\x3f\x48\xa6\x89\xd0\x34\x75\x45\x35\xbf\x98\x66\x37\x1b\x4f\x61\x69\xd8\xd4\xfc\xa2\x7e\xd2\x50\xfb\xed\x15\x26\x9b\x06\x43\x45\xa6\x6c\xf2\x69\xf5\x69\x13\xeb\xdf\xc1\x59\x72\xc7\x9f\xa1\xbf\x32\x61\x76\xf5\x0f\xc3\xe4\xc5\xe0\x2c\x79\x11\x4e\xc1\x4c\xe9\xfd\x56\xb8\x96\xf5\xfb\x2a\x85\x4e\xe0\x6e\xc5\x57\x8e\x32\xad\xd5\xb3\x27\x3a\x94\x2b\xd7\xc8\x8b\x6c\xf8\x37\xe0\x3e\x95\x4e\xea\x49\x02\x3e\x1c\x4d\x43\xa3\x34\xfc\x83\x29\xf8\x2d\x70\x93\xda\xe7\xa3\x95\x3e\xff\x7e\xcf\xe8\x66\x25\x4d\xaa\xcf\xb3\xd3\xec\x84\x73\xd4\x34\x2d\x4a\x9a\x83\x7b\xda\x7e\x29\xcd\x56\x48\x8d\x87\xb1\x8c\x06\x8e\x6e\xd2\xa6\xe8\xb7\x6c\xbb\x60\x4f\x32\x0d\xcb\xc8\xd3\x76\x92\x34\xac\xcf\x95\x34\x0f\xb0\xf9\x2c\x2c\x4d\x8c\xa6\x31\x0f\x18\xf9\x8b\x69\x76\xa7\xd3\x74\x9c\x2c\x0d\xa5\x93\x87\xa9\xcc\xd1\x07\x29\x67\x69\x7d\x81\x66\xad\x2f\x90\x09\x93\xa2\xa5\x7a\x2d\x2d\xb5\x51\x3a\xd1\x07\xf1\x69\x19\x7a\x6e\x50\x06\x9d\x64\xc2\x24\xe9\xad\x25\xc3\xce\x7f\x42\x81\xa1\xab\x5a\x34\x7a\x6e\xd0\x29\x60\x76\xf5\x8f\x87\xd2\x64\x0a\x26\xa9\xe7\x26\x9c\x02\x26\x49\xb7\x1d\x29\x18\x25\x1e\xb0\x2d\xe5\xa7\x3f\x4f\xd7\x95\x51\x3d\x17\x64\x7a\xee\xba\x3d\x95\xc1\x7e\x62\x1b\x69\xf8\x83\x60\x52\xf5\x1c\x4d\x60\xa8\xa8\xce\x1a\xfb\x56\xfc\xb7\x6d\xaa\xff\x26\xea\x9e\x9f\xce\xb8\xa2\xc9\xae\xcc\x10\x68\x68\xea\xd7\x17\xdd\x96\xf2\xf7\x0e\xa2\x37\x55\xbe\xa0\x49\x16\xd4\x87\xb3\xe0\x15\xbf\x60\x5b\xca\x5e\x7f\x1e\xbd\x88\x34\xd6\xe5\x91\x3d\x45\x25\x2e\xed\x1c\xe9\x6c\xf8\x83\xd0\xa2\xe2\xa7\x09\xe6\x14\xfa\xb3\x7c\x22\xc5\x16\xdd\x96\xb2\xad\x9e\xdf\xc1\xb0\xe7\x30\xec\xbf\xdf\xe3\xcc\xe9\xd7\x76\x4d\xc3\x1f\x2c\x52\xb0\xd3\x04\x01\x87\x5b\xb4\xf4\xb1\x19\xd4\xd8\x32\xc5\x3d\x8d\xb5\x7c\x01\x6b\xf9\x87\xf7\xe4\x15\xf4\x6b\x33\x6c\x4b\xe9\xe5\x83\xe8\x2f\x6a\xdb\xd3\x24\xb5\xb9\xf9\x59\xf0\x8a\xfc\xde\xa6\xca\x55\x82\x7f\x05\x2b\x7b\x3e\x2b\xfb\xc1\x3d\xb9\xf9\xfd\xea\xa2\x6d\x29\x39\x7c\x90\xc5\xb9\x92\xf3\x0e\xc6\x7b\x7d\x59\xf0\x0a\xdf\x6f\x4b\xf1\xe3\xf3\x30\x5b\x69\xfb\x66\x96\xc3\x6b\x7b\x1a\x9b\xfb\x91\x79\x69\xf8\x83\xf0\x99\x8a\x9f\x26\xe8\x68\x68\xca\x92\x79\xe3\xe4\x91\xe9\xb8\x9b\xad\x82\xe8\x5e\x66\x35\x70\x3a\x3c\x5c\x19\xdb\x6c\x4d\xaf\x79\xcc\x86\x7d\x83\xb6\x8d\x16\xb6\x3c\x1b\xf6\xc1\x14\xec\x16\xf4\x0f\x0d\x2c\x1d\x7f\x50\x80\x9b\xfb\x81\xdd\x49\x63\x79\xbf\x12\x76\x2b\x48\xbf\x1a\x76\x17\xfa\xec\xd4\xb0\xc9\x58\x1a\x81\x7d\x80\x8e\x1f\x64\xc0\x4e\x3c\x29\xec\xee\x3e\xb0\x43\x53\xb0\x2e\x79\x64\x3a\x9e\x66\x2b\xa7\xf1\x36\x06\xf9\x32\x81\xcc\x88\xbb\x65\xc1\xbd\xf1\x66\x06\x5c\x3a\xfe\x26\x8f\xd4\xc6\xd6\x08\xe4\x96\x0f\x19\x24\x37\x83\x40\x66\xc5\xe1\xfa\xc0\xee\xcc\x82\xd5\xc4\xe3\x48\xfe\xa9\x58\x1b\x81\xdc\xfa\x9d\x92\xff\xf7\x99\x58\x91\x8a\x37\x03\x76\xd7\x87\x99\xb0\x19\xf1\x39\x5a\xaf\x64\xec\x8d\xc0\x12\x09\x9a\xaa\x57\x9f\x38\x5d\x16\xec\xee\x0f\x33\x61\xb5\xf1\xba\x22\xd2\x07\xa9\xb8\x0b\xa3\xdb\xe3\x4a\x1f\xd0\x78\x3c\x8d\x51\x6b\xd6\xea\x66\xc3\xb2\x18\x8d\x16\xb6\x20\x1b\xf6\xc1\x14\xec\x16\x1a\xff\x49\xc1\xd2\xf1\xd0\xa6\x54\xdf\x66\xc3\xee\x4c\xd2\x62\x0a\x36\x70\x52\x58\x16\x8f\xf9\x95\x78\x77\xf5\x81\xcd\xc2\x9b\x8c\xa5\x30\xba\x3d\x9e\x05\x3b\xea\xa4\xb0\xbb\xfb\xc0\x36\x27\x61\x7b\xff\x25\x8f\xd4\xc6\x52\x68\x0b\x53\xdf\x95\x42\xf3\x73\x19\x4d\x6a\xe2\x2e\x7d\x60\x99\x6e\xd7\xc2\x96\x68\x60\xb5\x31\x11\x4a\xbf\xdf\x31\x48\xe1\x4b\xd6\xcb\x19\xf1\x93\x3e\xb0\x3b\xb3\x60\x2b\x4f\x01\xbb\xf5\x7f\x81\x77\xd7\xa9\xf1\xa6\x63\x2f\x69\x0a\x4e\xc1\xb6\x67\xc1\xde\xa0\x81\xdd\x9d\xf8\x24\x03\x36\x1d\xaf\x99\x42\x68\x3d\x65\x9b\xd2\xd6\x85\xcd\x4a\x5f\x70\x43\x15\x9a\x8c\xa6\x69\x32\x1b\xf6\x0d\xb8\x23\x13\xb6\x3e\x1b\xf6\xc1\x14\xec\x16\xf8\x8d\x06\x96\xf6\xf1\xe8\x14\x3d\x64\xc3\xee\x84\x25\x59\xb0\x2d\x27\x85\xdd\x0a\x1f\xfc\x6a\xbc\xbb\x60\xd7\xa9\xf1\x26\xed\x4d\x4a\xbf\xd4\xde\xcc\x80\x8d\x9d\x14\x76\x77\x1f\xd8\x8e\x14\x2c\xe9\x0b\xad\xbd\xc9\xe8\xb7\x55\xa5\xc9\x76\x85\x26\x53\xb6\x29\xea\x03\xfb\x46\x6f\x28\x13\xb6\x5e\x4b\xbf\x1a\xfb\x53\x43\xbf\x6f\xaa\x7d\x3c\x28\x83\x1e\x32\x61\x77\x66\xc1\xb6\x68\x61\xb5\xf6\xa8\x86\x7e\x27\xf4\x87\x37\x0b\x76\x57\x16\x6c\x16\xde\xb4\x7d\xaa\xa1\xdf\x24\xec\x84\x53\xc0\xee\xce\x82\xcd\xb6\x69\x1f\x48\xda\xa8\xf8\x6e\xe6\xeb\xa6\xc6\xeb\x7e\xda\x53\xd5\xd0\xd7\xa6\xa5\x6b\x58\x54\xf8\x75\x49\x78\x25\xd6\xf3\xf3\x9e\x8a\xaa\x4c\x78\xa6\xbb\xb7\xa5\x74\xec\xf3\xe8\xc6\x53\xdb\x1a\x74\xbe\x86\x82\x5b\x85\x61\xeb\x5f\xbe\xdb\x53\xad\x96\xa3\x1f\x9c\x07\xe9\x9a\xa5\x93\xe1\x64\xf5\xdb\x98\x2a\xef\xfd\x99\xf5\x4b\x8f\xac\x65\x94\x77\x63\x12\xb7\x02\x6f\x53\x71\xf7\x26\xe7\xdb\xfd\x3b\x39\x87\x0a\xdf\x0d\xeb\x94\xf5\x49\x4e\x41\xa9\x7f\x4e\xa1\xb2\x95\x47\x72\x5c\x98\xc1\x8f\x4c\xc1\xaf\x63\xf3\xa5\x08\x7c\x8e\xa0\xc4\xc6\x5c\x39\x7d\xe1\x53\xfb\x84\x10\x3b\xf4\x37\xf7\x50\xbb\xc1\xcd\x65\x8c\xeb\xa5\x7f\x3f\x78\x5f\xd6\xef\xcc\xfe\x48\xed\x33\xa2\x6a\x5d\xd6\x86\x7f\xdb\xe3\x49\x96\x0d\xd0\xeb\x7c\x0e\xbc\x2d\xdc\x4d\xf7\x9f\x8d\x18\xf5\x88\xb3\x58\x10\x72\x38\x8d\x76\x14\x7a\x43\xd9\xb0\x98\x6e\x8b\xcb\xf6\xfb\x57\x76\xf2\x51\xf7\x0a\xd2\xbd\x3e\x61\x40\x49\x75\xc9\xe0\xe6\xb6\x51\x57\x5f\xc9\xcf\xf0\x56\xe5\xdb\x9d\xde\xf2\x40\x79\xcb\xe4\xf6\xae\x95\x45\x04\xef\xd3\xf2\x48\xf8\xa6\xf7\x66\x64\x42\x79\x11\x93\xc8\x71\x66\x0b\xd2\x4f\x54\x0e\x71\x3a\x94\x3a\xec\x80\x1d\x41\x12\xa6\xdb\xc0\xb7\x7a\x44\x88\x44\x46\xde\x5b\x5e\x58\x5d\x3e\x49\x1e\x39\x66\xf8\x1f\xb7\x47\xbc\x23\xda\x48\x91\xff\x2f\x96\x91\xe7\xc7\xe0\xed\xc2\x25\xc8\x43\xca\x68\x70\xe7\xea\xbd\x2e\xde\x68\xd3\x23\x14\x3a\x10\xfe\xb8\xf1\x00\xdb\x12\x98\x6d\x06\xcb\xce\x2d\x0d\x28\xe7\x49\xd0\x5d\x83\xa0\x35\x6c\x01\x78\x7b\xda\xb2\x36\x7f\x49\x9e\xb4\xc8\xb8\x64\x76\xc3\xc4\x51\x43\xf2\x9d\x1e\xab\x69\x91\x71\x11\x3f\xe6\xcc\xda\xda\x51\x77\x5f\x5d\xda\x58\x6b\x2e\x1c\x79\xe7\x35\xb4\x0e\x1c\xc9\xeb\x74\xbc\x5d\xdc\xc9\xf6\x64\x0a\xa1\x96\x88\x57\xe2\xac\x5c\x6d\x6d\x83\xbb\xb8\xbe\xd8\xeb\xad\xac\x74\xd4\xe4\x07\x44\x87\x83\x38\x86\xa1\xc6\x46\x7b\xf8\x70\xe3\x01\xba\x21\x95\x8d\x96\x82\xed\x7f\xd3\x96\x3e\x69\x5b\xdd\xad\x49\x73\xef\x3c\x59\x19\xe5\xfa\x31\x63\xea\x1b\x46\x8d\x92\x57\xd7\x8f\xe9\x68\x20\x37\x3f\x9c\xac\xd0\xa7\x8f\x6e\x6c\x1c\x39\x22\xdc\x38\x7a\x6c\xa8\x7e\xf4\xe8\xfa\xc6\xd1\x50\x93\x59\x8d\x94\x1d\xb3\x2d\x69\x6f\x28\x76\x46\xca\x7f\x24\xfc\x56\x9d\x65\x77\x31\x1e\x5e\xa4\xf0\x0d\x85\x3d\x05\x8e\x83\x30\xb2\x1f\x1c\xd4\xef\xdc\x98\xf4\x3b\xf1\xfd\x90\x87\xd2\x63\x71\xa3\x93\xa3\x4a\x1a\xbf\x76\x64\x1a\x9e\xf2\x2c\x85\xd7\xe4\x4d\x63\x16\x67\x08\x43\xd9\xf8\xe5\x62\xa5\xe4\xbd\xe3\x7a\xef\xa6\xfa\xa0\x88\xd3\xc4\x35\x56\xaa\x30\xd7\x29\x25\xeb\x0f\x46\x77\x05\x83\x09\x9e\x0a\x8f\x6e\x93\x0a\x73\x32\x3c\x01\xa2\xa7\x34\xfb\x24\x10\xbd\x77\x3a\x62\x6b\x06\x9a\x8a\xd3\xfb\x24\x20\x8c\x5c\xbc\x85\x8e\xa1\x20\x81\xd0\x4e\x69\xc4\x6a\x91\x44\xe0\xf9\x5c\x97\x28\x7a\xb1\x9d\x92\xd3\xcb\x87\x15\x62\x55\x18\x81\xee\xc5\xc7\x35\xfb\x9d\xee\xb2\x6c\x7e\xc0\x2d\x3f\xa0\xde\xf6\xc4\xcd\xa3\x47\x96\x06\x4b\x87\x35\x0d\x1e\x7b\xfd\x3a\xbe\x94\xb4\xa3\xbc\xd7\xdf\xe4\xae\x2d\x72\xb8\x73\x2b\xca\xaa\x5b\x3b\x87\x9f\x75\x71\xe0\x24\xf9\x22\x8e\x3b\x65\xbe\xcd\x4e\xbf\x9b\xeb\x93\x2f\x8c\x68\x47\xbd\x3f\xc8\x6b\x33\xf2\xf5\xc3\xb8\x32\xf9\xc9\x7e\xf3\xe5\xb9\x7f\x30\x5e\xf1\xa0\x2a\xd4\x14\xf1\x96\xfb\x7c\xc5\x55\x9c\xdb\x1d\xd4\x57\x13\xe6\xb4\x05\xc8\x5f\x15\xe1\xd4\x2a\x14\x62\x5c\xc2\x36\x64\xb2\xa9\x25\x51\x4f\xfa\x38\x19\x3f\xf4\x29\xd9\xc9\x98\x58\xde\xac\x91\x1d\xc2\x65\x99\xac\x20\xff\x3e\x4b\x96\x28\x71\x71\xbc\x82\xe9\x4f\x16\xc3\xc0\x77\xff\x55\x33\xfe\xf6\xc9\x1e\x57\x7e\x56\xcc\x83\x27\xf0\x17\x31\xfd\xa9\xc0\xaf\xfb\x27\x83\x77\x31\xf8\xef\xf7\x38\x5c\x59\xf0\x4e\x8a\x5f\xfc\x8b\x02\x4f\xf7\x9e\xf8\xe4\x39\x46\x77\xdb\xa0\x09\xf9\x23\x2e\x6e\x75\x10\xba\x82\x60\x0d\x42\x10\xc3\x2e\x3b\x6c\xb0\x83\x9d\x2d\xbe\xa2\x5b\x4e\xcc\x3c\x25\x8e\x83\xc8\xfb\xeb\x71\xf4\x7e\x43\x70\x6c\x60\x3c\xa6\x94\xfb\xfe\xaf\x35\xf5\xfc\x2e\x35\x6a\x96\x1a\x67\x64\xf0\xe2\xb5\xe9\x3c\xff\xf5\x1c\xe5\xe4\xde\xaf\xd1\x8f\xa8\x28\xe2\xe4\x48\x86\xc1\x88\x64\xef\xe8\x93\x65\x70\x39\xe3\x11\x65\xfe\xe8\xbf\x93\xf3\x47\x89\x5d\xd2\xa6\xcc\xbf\x32\xa9\xeb\xb6\xac\x1e\xbd\x76\xdf\x0b\x05\x7e\x64\x0a\x7e\x1d\x83\xa7\x32\x83\x2e\xf4\x42\x66\xab\x3e\x73\x4f\x16\xc2\xa7\xfc\x30\xc6\xa7\x35\xd9\xbc\x6c\xd5\xf0\x32\xdf\xad\xc2\x64\xf1\xb2\x02\x93\xc5\x2b\xc5\x11\x33\xf0\x2e\xab\xc4\x4b\xb9\x5e\x6c\x42\xa2\xc2\x29\xa9\x3d\x96\x93\xfc\x29\xa8\x3b\xed\xaa\x3b\xe2\xe5\x78\x14\xfe\x94\x7f\x77\xc3\x6f\xc6\x0d\x6a\x8e\x12\x5e\xe9\x18\x91\xe4\xcf\x9c\xc0\x25\x73\x86\x77\x0e\xa8\x2a\xab\xc8\x75\x3b\x8a\xeb\x9c\x29\xfe\xbc\x21\x9d\x27\xe2\x48\x9e\xdc\x49\xf3\x64\xbc\xa9\xcb\xce\x13\x4e\xa3\xbc\xb9\x3c\x23\x4b\x85\x35\xfb\xc9\x32\x8b\x37\x6b\x22\x39\x7a\x9f\x9b\x0b\x56\x53\xa5\x59\x58\x48\xd4\xa7\xb2\xe3\x9e\x97\x70\xe6\x4c\x45\x81\x11\x55\xca\xd6\x51\x9c\x9c\x27\xb9\x3e\x25\x3a\x19\x4f\xc6\xae\xbc\x7a\x54\x5b\xf3\x60\xc2\x96\x2d\x13\xfb\xb0\xe4\x92\xa2\x95\x5d\xed\x93\x5b\xcb\x02\xe5\x5e\xa7\x3d\xbf\x32\x37\x1d\x9b\x7b\x20\x19\x9b\x23\xb4\xf3\x04\x4a\x8f\x2b\x99\xf2\x4a\xfa\x8b\xe5\x31\x9e\xbc\x50\xa5\x9d\x24\x7c\x1e\x81\x37\x7b\xf3\xfa\x83\x67\xfc\x74\x21\xd5\x37\x68\x31\x7a\xa9\x97\x71\x25\xba\x9e\x70\x54\x6d\xa4\x80\x3b\x12\x82\x9b\x42\xb0\x26\x04\xab\x43\xd0\x15\x02\x6b\x08\x42\x84\xce\x03\xb0\x21\x00\x81\x34\x6b\xcd\x54\xd7\x47\x9e\x0c\xdf\x41\x80\xff\x57\xf8\x2e\x91\xc7\x73\xc7\x98\x9f\x79\xbe\x3a\x0e\xf7\x81\x62\xf3\xd6\x32\x9b\xf7\xfb\x3d\xb5\xd5\x56\x9d\x86\x77\xb2\xe1\xdf\x40\x7f\x55\xe0\xf3\x55\x1f\xa0\xa8\x36\x03\x5e\x69\xdf\x8d\xa9\xf6\xba\x3f\x35\xce\x47\xdb\xb7\x34\x39\x02\x95\xd5\x5e\xd7\x6a\xea\xf7\x4e\x2f\x93\x06\xe8\x4d\x22\x0d\xec\x11\x29\xab\x2e\x34\x8d\x32\xdf\xf1\xdf\xa9\x39\x8b\x77\xc3\x7e\xcd\x3a\xc5\x6a\x6f\x71\xd6\x3a\x33\x05\x7e\x64\x0a\x7e\x5d\x0a\xde\x4b\xe0\x83\x39\xde\x2c\x78\xaa\xa7\x47\x31\xde\x1e\x0c\x0f\x66\xf2\xbf\x57\xab\xcb\x27\xa9\x30\xbb\x33\xf9\x5f\x0b\x23\xfc\x81\xc5\x4c\xc2\x59\xe3\xfe\x4a\xf8\x8c\x9e\x53\xf1\x13\x3f\x0b\x3f\x26\xbc\xae\xee\xcb\x49\x34\x6a\xbe\x55\x92\x8a\xac\x85\xc4\xee\x43\x26\x93\x8f\xb0\xcd\xa1\x30\x3b\x2c\x44\x3d\xb6\xaa\xed\xe4\x16\x9f\x87\xed\x0d\x8a\x47\x27\x37\x07\xfd\xb7\x7a\xf3\xe6\xd3\x1f\x35\xf0\x67\x27\x37\x07\x4d\xee\x0d\x6a\x51\x84\xc8\xff\xd7\x65\x60\xfb\x85\xf6\x2d\xc3\xfc\x86\x8f\x9e\xee\xa7\x0c\x8a\x54\xa1\xf6\xfc\x3e\x7e\x00\x1c\x13\xb6\x11\xb9\xe5\xdc\x27\x00\xe8\x44\x8e\x58\xbd\x87\x52\x4e\x01\x13\x8e\xb0\x9d\xca\x42\x02\xa8\x96\x3c\x1d\x0b\xd9\x96\x8c\x17\x10\x7b\xa9\x58\x8d\xa1\x4f\x50\xe9\x2e\xdc\x34\x88\x2b\x2f\xa3\x53\x39\x49\x07\xa7\xd6\x5c\xb2\x74\xdc\x81\x64\x0c\x5d\x49\x47\xed\x2c\x05\x3c\x13\xae\x1f\xfc\xe9\x98\xfb\x49\xf0\xb3\x18\xfd\xc6\x24\x7e\x62\x77\xde\x8d\xd2\xe3\x92\x5c\x72\x84\x0d\x65\xe6\xb3\x31\x99\x8f\x02\x6f\x53\xcb\xa5\xd8\x12\x3a\x4e\x19\xf3\x87\xba\x0c\x9a\xc4\x79\x5c\x32\x6e\xdc\xfb\xad\x58\x40\x60\xca\x51\x63\x87\x42\x91\xad\x5a\x88\x14\x6d\x57\x29\x71\x10\x18\x9a\x49\xdb\xb5\x5a\x7b\x77\x36\xc5\xa3\x0f\x5e\x90\x41\xd9\xb5\x69\x3c\x33\x88\x9d\x6a\x52\x60\xfc\x4a\x39\x1f\x40\xd9\xfd\xc8\x13\x3c\xba\x8c\x7e\x74\x32\x85\xb3\x8f\xaa\x17\x7e\x80\xda\xf9\x80\xde\x26\xbe\xdc\x5f\x98\x2f\xe7\x8d\x48\x16\x89\x18\x94\x0e\xa7\x88\x52\x9e\x1c\xdb\xef\xbb\x8f\x46\xf8\x8b\x46\xf2\xf3\x39\xd9\x92\x9e\x96\xa5\xf7\x7d\xf9\x08\xaa\xa6\x07\xab\x23\xfb\x5e\xc0\x98\xc7\x04\x67\x48\x75\xe1\x9c\xf6\x80\xbd\x7a\xaa\xa0\xfb\xf9\x1f\xa2\x97\xc2\x16\x13\xd8\xcf\x84\x6b\x90\x05\xd5\x47\x3c\x26\x03\x29\x39\x0f\x60\x35\xeb\x8d\x82\x05\x0b\x3a\x8e\x03\x49\x07\x24\x35\xdd\x12\xd8\x41\x0f\xaf\x82\xe4\x2e\xff\x74\xdf\x50\xbb\xae\xa2\xb5\xa2\xd5\xd3\xea\xd1\x79\x74\x15\xd5\x53\x57\xb7\x3e\xf4\x90\xfa\xbf\x5a\x3e\x22\xc4\xd6\xb4\x6e\xff\xdd\x80\x87\x1f\x1e\xf0\xbb\xed\xad\x6b\x68\x5e\x1f\xc8\x47\xe0\x71\x92\x97\x01\x35\x12\x6d\xc9\x71\x48\xc2\xa4\x68\x82\x20\x1a\x79\x1d\x90\x3f\xd1\x40\x54\x75\x48\xb5\x62\x55\x67\x2f\xbd\x01\x31\xc9\x2b\x40\x0a\xef\xaf\x68\x85\xc7\x3f\x6d\x5d\xfb\xd3\x64\x18\xbb\xb6\x95\x7f\xe8\xa3\xd6\xcb\x8e\x9f\x23\xfc\xfd\xb2\x01\xac\xee\xf2\x78\x52\x9f\x4a\x96\x47\x7d\xc4\xad\xe7\x79\x51\xe2\x38\x51\x44\x60\xe4\x24\x81\xfc\x01\xab\x8d\x26\x8b\x46\xcd\xa9\xc2\x04\x3d\xa9\x07\xa9\x8d\xbf\x72\xf2\x4f\x6b\x5b\x3f\x25\xb9\xc0\x58\x52\x91\x5b\x2e\x6b\xfd\xe8\xe3\x01\x97\x31\x1b\xee\x07\xb8\x9d\x58\x1a\x65\x0e\x51\xf7\x09\x6b\x6b\xf5\x3b\x69\x6b\x77\x44\x02\x01\xf3\x1c\x7e\x32\xc6\xa1\x50\x30\xe9\x32\xbb\xfd\xcd\xbc\xa5\xe7\x0b\x5c\xb6\x61\x83\x0a\xaf\xff\x25\x78\xbd\xe5\xbf\xfd\xc3\xa3\x5f\x80\x27\xf4\x79\x0e\x31\x4c\x82\xc2\x7a\x9b\x08\x57\xb1\xf2\x1e\x4d\xfc\x8b\xb7\xf5\x9e\xef\xa8\x40\xc3\xc8\x77\x9d\x4d\x44\xca\xd9\xfd\x5b\xf0\xd7\xb8\x4d\x98\x8c\x1c\xa8\x92\x58\xbb\x66\x33\xb1\x5a\x9c\x2e\xbd\x8d\xb3\x6d\x8f\x73\xfc\x7d\x31\x8e\xc8\xe9\xa0\x7a\xce\x61\xd2\x6a\x72\x36\xb5\xb4\xba\x15\x2a\x54\x0f\x68\xda\xf2\xa7\xd7\xdb\x63\xe1\xa2\xba\x09\xb1\x31\xd3\x96\x71\xdb\xef\xf9\xb0\x65\x86\x73\xf0\x84\x80\xa7\xc8\x5b\x35\x65\xc8\x98\x73\x68\x3e\xab\x49\x3e\x1e\x96\x4f\x59\xc4\x49\x17\x57\x9b\xcd\x2e\x27\xcd\xc1\xc6\x6d\x8f\xeb\x6d\x3c\x3d\xe5\x2f\xa8\xc9\x84\x1e\x1c\xd1\x4c\xb7\x48\x2e\xaf\x50\xa5\x2b\xf6\xbc\xf5\x6a\x7b\xbc\xa1\xbc\x7c\xfc\x19\x63\xa6\x2e\xe7\x37\xdc\xf7\x7e\xf3\x4c\xe7\xd0\xf1\x7e\x6f\xa9\xb3\xbc\x73\x48\xc7\xd9\x4a\x5c\x64\xa5\xfc\x22\x36\x41\x2d\xe1\xa5\x9a\x88\x87\x2e\x98\x35\x99\x9c\x0e\xcc\xdd\x17\xb3\xe2\xed\x71\x9d\xd5\x61\xbd\x27\x6e\xa5\xad\x86\x32\xb3\x2b\xb3\x09\x59\xb9\x99\xe4\x45\xed\xd3\x1b\x0a\x6b\x49\x6e\xd3\x96\x2e\x96\x0f\x2c\x99\xe1\x1c\x3a\xae\x24\xa7\x38\xb7\x72\xea\x90\x8e\x73\x59\x5e\xb7\x90\x3a\x05\x59\x9d\x02\x11\x87\x51\x44\x56\xe4\x72\xda\xac\xa4\xd1\x48\xe3\x19\xb9\x74\x95\x94\x13\x74\x9c\x2a\xff\xb2\xbd\xfa\x0b\xc1\xe3\xae\x83\x5b\x96\x4f\x1d\xdb\x39\xbe\xac\xa2\x21\x16\x7d\xf5\x2d\x7e\xc3\x19\x67\x77\x0c\xe9\x2c\x77\x96\x7a\x4b\xc6\x0d\x71\xcd\x6c\x7e\x9f\xda\x96\x67\xe1\xaf\xb9\x67\x94\x76\x43\xd1\x48\x71\x4e\x71\xb1\xcf\xc9\xba\xc9\x89\x2a\xca\x7d\x81\x80\xd2\x55\x1e\x9e\x36\x65\x8e\x92\x27\xad\x1b\x3d\x15\xd4\xae\x39\xc3\xe4\xa4\x5d\x57\xd6\xe7\xc9\x59\xda\xce\x84\x17\x4e\xdd\xb5\x53\xfb\xf6\x35\x46\x13\x48\x99\xb7\xa9\x65\x1e\x1e\xf1\xb3\xde\xf6\x39\x9d\x39\xc5\xe6\x62\x56\x66\x5b\xb2\xb8\x9a\xbe\x57\x0b\x6d\xef\xaf\xd4\x7d\x69\x41\xe8\xf3\x84\xdb\xf6\xc6\x6b\xa4\xbf\xca\x2a\x48\x41\xa7\x9e\x2b\x47\xde\x7e\x39\xf5\x6d\x19\xbf\xe1\xde\xf7\x5b\x66\xd2\xee\xf3\x06\x5c\x15\xd3\x86\x8e\x3e\xa7\xf3\x9e\x0f\x9b\xb4\x0f\x96\x32\x3b\x7e\x90\xfc\x22\x77\x2b\xa3\x9d\x00\x1a\x1b\x29\x63\xd4\x93\xeb\x70\xb8\x0a\x4d\x85\x65\xa5\xb9\x7e\xbf\x95\x68\x76\x42\x49\x2e\xac\xd0\x52\xa9\x86\x96\x4e\x55\xfc\x3e\xb4\x25\x64\x3f\xe0\x6e\x4d\x12\xdb\xf4\x51\xd3\x96\xca\x43\xb5\xdf\x32\x49\x2f\x3a\xe2\xdc\x69\xf2\x4b\x67\x67\x3c\x40\xd9\x6d\xee\x8f\x58\x29\x75\x04\x18\x69\x14\xe6\x28\xa4\x18\x0e\x27\xd9\xb8\xad\x5f\x5a\x2c\xeb\xfb\x68\x82\x96\x3c\xe1\xb9\x53\x13\xeb\x7d\x7d\xa9\x97\x9d\x81\xd5\x6b\xe3\x0e\x0a\xeb\x91\x19\x0e\x44\x7a\xcd\x06\x1d\xcf\x73\x46\x09\x89\x7a\xa2\xe4\x38\x8b\xd5\x68\x7a\x2e\x26\x19\x5f\x88\x8b\x02\xf9\x14\x5f\x88\x4b\x08\x56\x58\x61\x8e\x15\x26\x5b\x61\x84\x15\x9a\xac\x50\x6e\x05\x87\x15\x78\x2b\x1c\xb3\xc2\xdf\xad\xf0\x8e\x15\x5e\xb0\xc2\x6e\x2b\x6c\xb5\xc2\xcd\x56\x58\x6b\x3d\x29\xfc\x42\x92\xe0\x2b\x2b\xbc\x6f\x85\x3d\x56\x78\xd0\x0a\xb7\x9f\x04\xda\x95\xc4\x9e\x05\x3c\xd7\x0a\x53\xad\x30\xca\x0a\x8d\x56\x28\x65\x60\xd8\x0a\x3f\x58\xe1\x0b\x2b\xbc\x6b\x85\x97\xad\xf0\x98\x15\xb6\x59\xe1\x56\x2b\x5c\x63\x85\x0b\xac\x30\x3f\x09\xdf\x62\x05\xd1\x0a\x03\x7e\xd4\xc0\xc1\x66\x2b\xdc\x64\x85\xc8\x68\xa5\x04\x93\x92\xd9\x2b\x19\x1f\x4c\x96\xac\xef\xf3\xa7\xad\xb0\xce\x0a\xab\xd8\x4f\x38\x62\x85\x7a\x2b\x20\x2b\xe8\x67\x11\x6f\xa6\x4b\x71\x6a\x96\xab\xaf\xf3\xd4\x57\x17\x7d\x9b\x35\x33\xe3\xb5\x5c\xfb\x3a\x2f\xf3\x95\x05\x9a\x06\x46\x21\x22\xf8\x55\x19\xe9\xa1\xa4\xec\x60\x1e\x2b\x17\xe0\x5a\x85\x66\x81\x0b\x73\x65\xee\x32\x7c\xf5\xdc\x61\x73\x27\xc9\x8b\xe1\xf6\x61\xdf\x0f\x83\xdb\xe5\xc5\xf8\xa7\x13\x5e\xee\x1f\x9b\x87\x7d\x1b\x81\x75\xf2\xca\xc8\xb7\xc3\x32\x68\x20\x17\x6e\x8f\xf4\x72\x22\xe2\x74\x5e\xc8\xc1\x42\x0e\xa7\x73\xda\x0c\x66\x5e\x72\x58\x5d\x46\x8b\x8b\x93\x24\x9d\x2e\xcf\x67\x77\x3c\x17\xb3\xda\x5f\x88\x9b\x8c\xe4\xd3\xf4\x02\xe1\xb0\x5c\xef\x73\x31\xc8\x7d\x21\xce\x13\x22\x01\xfe\x85\x38\xac\xf2\xc1\x12\x1f\x8c\xf3\xc1\x20\x1f\x84\x7c\xe0\xf3\x81\xd1\x07\x3d\x3e\xd8\xe3\x83\x75\xc9\xe7\x41\xf6\x70\x21\x79\x7a\xc4\x07\x1f\xf9\xe0\xa0\x0f\x9e\xf6\xc1\x2e\x1f\x6c\x62\x10\xc1\x64\x9a\x6f\x32\x7f\xbd\xc7\x07\x1b\x7c\xe9\x0c\x9a\x7c\x50\xea\x03\x97\x0f\x78\x1f\x1c\xf3\xc1\xbb\x2c\x0f\x6d\x06\x03\x94\x0c\xc8\x0f\x07\xd8\x6f\x2b\xd8\xcf\x29\xd4\x5a\xbc\x6b\xd9\xaf\x91\xe2\x26\xf6\x7b\xea\x17\x4c\xf2\x5b\x4d\x9e\xfb\xa0\xde\x07\x56\x9f\xd2\xb9\x4a\xf7\xf6\xed\xb4\x59\xfd\xf5\xa8\xb6\x4f\xb3\x00\x88\x74\x22\x2f\xba\x89\x43\xb2\x2b\xc3\xa9\xce\xd4\xf4\x6a\x99\x33\xe0\x24\x9d\x4a\x8d\xb8\x54\xdf\x52\x5b\xae\xcc\x8d\x9b\x47\x7c\x1f\xa1\x1d\x3c\x79\xc6\x8c\xc9\xf4\x33\xf2\xfd\x08\xda\xd1\x9d\xdd\xdd\x9d\x70\xfb\xbd\xf2\x0a\xb8\x81\x3c\xb9\xfd\xb1\x3d\xb7\xa7\xfb\xfc\xf6\x3d\x8f\xdd\x3e\xe2\x7b\xd2\xef\xa7\xc3\x46\xbc\x8a\x7b\x1a\x19\x61\x56\xe4\x04\xb1\xbf\xcc\x26\x24\x5e\x60\x86\xb9\x66\xe8\x34\x43\x8b\x19\xca\xcd\x90\x63\x06\xd1\x0c\x3f\x98\x01\xbe\x30\xc3\xbb\x66\x78\xde\x0c\xbb\xcd\xb0\xd9\x0c\x37\x99\x61\xad\x19\x56\x98\x21\x62\x86\x26\x33\x94\x9a\xc1\x66\x06\x22\x45\x16\x1e\x33\xab\xa0\x07\xcc\xb0\xc7\x0c\xb7\x32\x38\x82\x72\x92\x19\x46\x30\xd0\x62\x33\xb8\xcc\xc0\x27\xc1\xb6\x99\x61\x99\x19\x70\x37\x83\x20\xc8\xea\x19\x04\x41\x76\xd4\x0c\x9f\xb1\x0c\xd7\x30\x88\xee\xe4\xaf\x4a\x3e\x03\xde\x4a\x16\x63\x0d\xfb\x6d\x12\x4b\xa6\x2d\x9e\x92\xc6\x6a\x86\x4f\xcd\xb0\xcb\x0c\x9b\xcc\xb0\xda\x0c\x4b\xcd\xd0\x65\x86\x89\x66\x68\x37\x43\xc8\x0c\x45\x0c\x40\x3f\xab\x2f\x7f\xf5\x65\x3f\xe5\x79\x57\x5f\x1e\xcd\x64\xd1\xae\x74\xdf\x1e\xd2\x8c\x19\xa5\x3c\x50\x98\x7f\xde\x03\x0f\x9c\x47\x2e\xd8\xb8\x65\xc5\x8a\x2d\xf4\xa2\x63\x2d\x0f\xf7\x7e\xae\x9b\x0e\x21\xe6\xe3\x06\x50\x43\xc4\xe3\xb6\x5a\x7d\x12\xe7\xf3\x73\xfe\xd2\xb2\x42\x87\x88\xc4\x7b\xe2\x5e\x13\xdb\xf8\xa3\x51\xb1\x1e\x92\xe7\x7e\x28\xe7\xd3\x0a\x27\x71\x78\xb5\xf7\x30\x69\xe4\xec\xee\x51\xe4\xc2\x67\x67\xdf\x14\xb0\xf7\x7e\xae\x94\x3f\xc0\xbf\x4d\x7c\x26\xe2\xff\x10\xe7\x17\x63\x22\x23\x30\xf5\x36\xd4\x50\xba\xe2\xae\xf8\xdd\xd5\x53\xe0\x30\x7f\x25\x35\xf3\x27\x52\x1b\x7f\x02\xb1\xf1\xab\x58\x3a\xf7\x13\x74\x34\x49\xe4\x09\xd1\x85\xc2\x8a\x8b\xc3\xc2\x7b\x7e\x92\x4c\x9e\x00\x87\xa7\xf0\x57\x4e\x3c\x5e\x28\xdc\xa2\xf8\x45\x0e\x92\xee\x7b\xe1\x2a\xa4\x43\x85\x11\x13\xc2\x58\xe0\xf4\x20\x08\xc4\x85\x63\x2e\x41\x28\xe9\x0f\x28\x9e\x00\xcd\xf8\xfb\x03\x53\x0f\xc0\x61\xee\xed\x9e\x42\xfe\xef\xf0\x58\x06\x0e\x23\xb1\x33\x9d\x06\x41\xa0\xc6\x02\xe6\x4c\x04\x8f\xc1\xc0\x49\xf4\x90\x89\x90\x72\x7c\x4a\xca\x81\xc9\xc0\xe8\xf6\x27\xb1\xca\x2b\x61\x5d\x12\xf3\x44\xf9\x9b\x4c\xdc\x75\x11\x17\x88\xa2\x9e\x37\x1a\xf5\x92\x64\xd2\x19\x8d\x08\xf1\x12\x47\x4f\x80\x08\xa5\x90\x27\x4f\xb4\x22\xd8\x39\x82\x95\xd5\x99\xfc\x7d\x4f\xb9\x11\x0e\x93\x3c\xf8\x22\x70\x4f\x94\x4f\xa3\x59\x28\xbe\xab\xfa\xb2\x89\x3a\xaa\xa4\x75\xa8\x9a\xd0\xc6\x7b\xc2\x54\x42\x25\x94\x3a\x8a\x50\x10\x85\x51\x3b\xfc\x23\xd2\xdb\x54\x33\xb0\xbe\xd8\x8b\xb9\xf2\x7c\x13\x69\x5a\x87\x5e\x0f\x7c\x3e\xe7\xad\xaf\xd1\x47\x23\xb1\x28\x44\xa2\xd0\x18\x85\xd2\x28\xe4\x44\xe1\xe7\x28\x7c\x13\x85\x8f\xa3\xf0\x66\x14\x76\x47\x61\x6b\x14\x6e\x8d\xc2\x05\xd1\x6b\xa2\x78\x4c\x14\x06\x45\xa1\x24\x0a\xae\x28\x88\x51\x58\x9c\x82\x7c\x4d\x03\x79\x4d\x14\x62\xd1\x45\x51\x3c\x2e\x0a\x43\x18\x4a\x31\x9a\x13\xc5\x3f\x46\xe1\xc3\x28\xbc\x1c\x85\x87\xa2\x70\x53\x14\xae\x8c\xc2\x8a\x28\xcc\x8f\x42\x5b\x14\x82\x51\x70\x44\x81\x8f\x02\x81\x79\x37\x09\x73\x0f\x83\x99\x1b\x5d\x11\xc5\x9d\x51\xa8\x8a\x82\x2f\x0a\x66\x02\xfe\x72\xf4\xab\xe8\x8f\x51\x4e\x81\x58\x9f\xc4\x32\x86\x62\x19\x14\xc5\x05\x51\xb0\x32\x3c\xef\x44\xff\x1e\xc5\x07\xa2\xb0\x2f\x0a\x77\x45\x61\x1d\xa9\xe0\xac\xcb\x28\x3a\x20\xc8\xa4\x68\x15\x2b\xcf\x5b\x51\x78\x21\x0a\xb4\xe0\xdb\xa2\xb0\x2a\x0a\x4b\xa3\x44\x2f\x53\x04\x45\x51\xac\xe7\x44\xf7\xbe\x98\x41\x7c\x22\x6e\xb0\x92\x4f\x03\xe6\x1b\x5b\xf7\xc5\xea\x1a\x9f\x88\xd7\x0d\x21\x9f\x75\xa8\x30\xb0\x2f\x96\x57\xf8\x44\x3c\xaf\x8a\x7c\xe6\x31\x5e\xa3\xf2\x99\x9e\x09\x1e\x52\xc4\x74\x98\x7e\xd2\x73\xfc\x15\xf5\xde\xbf\x12\xc8\x94\x08\x27\xd5\xed\xb3\xfa\xaa\x75\xbb\xe6\xcc\x74\xcd\x2e\x3e\x01\x08\x27\x8f\xf5\xe1\x34\xa7\x4d\xf7\xf7\xac\xac\x3f\xb8\xd2\xdb\xb9\x3d\x77\x24\xf6\xca\xaf\xcb\xef\x10\x4c\x0d\x87\x1a\x5b\xc3\x84\xfa\x5b\xc2\xdc\x05\x7d\x1f\x2d\xe9\xf3\xc8\x25\xcc\x97\x7f\x2b\x6f\x82\xd9\x30\x53\x7e\xe0\x86\x8b\x96\xdd\x7a\xdb\x8a\x8b\x13\x1f\x67\x3d\xb8\x29\xeb\x3b\xb3\x2b\xae\xe5\x66\xc0\x53\xc2\x10\x42\xb7\xb9\x11\x23\x70\x1c\x2f\xd8\x30\x60\xf2\xb5\xfd\xd0\xcc\x54\xc4\xc5\xcf\x05\xf6\x03\x3e\xb8\x50\x18\x22\x17\x11\x3b\xf9\x0d\x6e\x06\xb7\x99\xa5\xd1\x11\xaf\xcd\x06\x9c\xa0\xe3\x74\x7a\x49\x47\x53\xf2\x34\x69\xe3\xa1\x99\x8d\x9a\xd3\xcb\x68\x7a\x20\x57\x82\xe2\x80\x77\x92\x98\xe0\x6f\x72\x11\x1b\xc3\x3e\x8b\x9b\xc1\x4b\x2a\x3e\x23\x2a\x88\x98\x79\xa4\x27\x8a\xce\x48\x90\x22\x9e\xa3\x76\xf7\xa1\xc6\xc6\x64\xb8\x5f\xc5\xc5\xae\xbd\x80\x4f\x5b\x28\xcf\xa1\xef\xf8\x4c\xfa\x9e\x44\xab\xa2\x26\xf5\xbb\x1c\x8d\xc5\x35\xdc\x14\x24\x22\x5f\xc4\x8c\x39\x9e\x13\x45\x1d\x91\x54\x47\x62\x40\xbd\x0e\xc5\x30\x23\x25\x84\x30\xe7\x0c\xc0\xe5\x30\x76\xee\xbe\x7d\x73\xe5\x7d\x70\x04\xe6\xca\xab\xe4\x4b\xe9\x06\x0a\x49\x1c\x53\xd3\x38\x08\xc3\xeb\x05\x38\x12\x13\xb4\x38\x24\x08\x38\xb9\x30\xe0\x1a\x79\x1f\x45\x02\x63\x61\xa7\x7c\x2f\x5c\x0d\x57\xcb\xf7\x12\x79\xb1\xb3\xf7\x73\xbe\x42\x18\x62\x2b\x47\x3c\xdb\xaf\x80\xc7\xb5\x4c\x06\x1e\x10\x79\xfc\x95\x38\x95\xc5\x97\x90\x00\x3c\xa6\x47\xf2\x24\xe3\x11\x44\x10\xe1\xaf\x4e\x7c\xc2\x95\x88\xfc\x24\x22\xab\xd7\x11\xf9\xf8\x2a\x6b\x27\xe7\x13\x1c\x85\xe5\x88\xab\xd2\xde\xae\x42\x07\x01\xc2\xc7\x57\x71\x2f\x5d\x44\x20\x78\x92\xdf\x3e\x38\x2e\xdc\xa9\xea\xaa\x10\x1a\x19\x29\xab\xf5\xbb\x25\xa9\xc2\x67\xe5\xb8\x86\x7a\x93\xe3\x9e\x98\xb7\xf0\x9e\x98\xc9\x6b\xf2\xa2\xd2\xea\xd2\x7b\x62\x44\x79\xc5\x50\x35\xa0\xf6\x03\x41\xb6\x4d\x55\x9b\x37\x14\x4a\xb9\xf7\xca\x99\x6c\x99\x1a\x8c\xfb\x15\xf7\x30\xb5\x7f\x8d\x95\xba\xc6\x26\xef\xe0\xda\xd4\xdd\x75\x7d\x9f\x65\xea\x1c\x2b\x1a\x18\xc9\xe3\xad\x56\xb3\x60\xd0\x1b\x4c\x60\x32\x9b\x6d\x46\xab\x95\xb8\xc8\xbc\x59\xc7\x31\xc9\x6e\x57\x64\xbb\x46\xb8\xa7\xe5\x7b\xd8\x4e\x4f\xff\x0a\xd8\xe9\xb9\x8a\x54\xc6\x1f\x20\x0a\xe4\xc0\x81\xa4\x8c\x27\xea\x43\x95\xf2\x38\x95\x1f\x95\xe9\xf5\x11\x37\xe8\x74\x92\x64\x20\x3a\xd2\x60\x30\xe9\x79\xd2\x8d\x82\x81\x13\xb2\xd4\x88\x3d\x43\x8f\x70\x76\x45\x91\xdc\x07\x03\xe5\x97\x4f\xa7\x8a\x84\xe6\x21\xdf\x07\x8f\xa9\xaa\x04\x7a\x6d\x24\x8f\xa3\x24\x0f\xaa\x7f\x09\x61\x01\x88\xf4\x7c\x23\x55\xfd\x36\x32\x65\xc7\xf9\xb9\xea\xa9\x2f\xc3\x67\x2f\xcb\x47\x84\x72\x38\x57\xbe\x19\xa5\xd2\x5d\x4f\x68\x92\xe8\x5f\x11\x78\xc0\x84\xa6\x78\x2c\xe0\x3e\xfa\x97\x96\xc0\x07\x04\xc3\xd1\xa3\xaa\x8e\x7c\x52\xa6\x7b\x72\xe3\x5e\x3b\xc1\x71\x44\xb8\x86\x9e\x3d\x85\x9a\x22\x1e\x62\x5d\xea\x04\x81\x20\x37\x8a\xd8\xa0\x93\x0c\xe4\x0f\xf4\xbc\x1a\xb1\x54\x8f\x27\xea\xa3\x89\x69\x88\xaf\xb5\x42\xe7\xa9\x9e\xfa\xd2\x91\x23\x2f\x4d\xbd\xfc\xf2\xcb\x49\x29\x85\xbd\x1f\x7f\xbc\x77\xef\xf2\xe5\xcb\x32\xfb\xcd\x4c\x75\x31\x6f\x36\x1b\xf5\x06\x83\xd1\x68\x91\xcc\x66\x91\xf4\x99\x31\xad\x8b\x33\x5b\x31\xd9\x57\xda\x9e\xf2\xa6\x3a\x4a\xbe\x37\xd9\x4f\x28\x07\xbb\xf0\x34\x42\xf5\x06\x64\x41\xc3\x22\x25\x66\xd2\x0e\x7a\x00\x8b\x88\xb1\xd5\xa6\x17\x2c\x9c\xe5\xcb\x18\xda\xc0\x6d\xe2\x30\xc7\x61\xa3\xee\x30\xfe\x98\x1e\xbb\x4a\xf2\x9b\x19\x4e\x59\x69\xc9\x53\xed\x94\x30\x20\xc9\xb4\x99\x96\xc3\x4d\x3c\xb5\x30\x16\xb6\xcb\x4f\xc2\xa2\x6b\x26\xfd\xc4\x7d\xf0\x57\xfc\xf8\xa6\x4d\x73\x70\x65\xe2\xdf\xab\xe0\x55\xf9\x71\x22\x1b\x1a\xb1\x11\xb7\x93\xbc\x7d\x68\x5c\xa4\xca\x95\x97\xe7\xf6\x5a\x31\x76\xeb\xb9\xfc\x02\xe4\xf8\x22\x66\x25\x96\x00\x96\x88\xbc\x10\x72\x72\x72\xbf\x8a\xe5\x1c\x16\x4c\x5f\xc4\xf4\xc2\xa7\x34\x5a\x93\xde\x16\x8e\xe8\xaa\x60\xfa\x64\x4a\xe5\xbc\x47\x16\x47\x0a\x81\x7a\x10\x29\x3b\xde\x97\x99\x3c\xee\x16\xf0\x43\xe1\x5d\x37\x9e\xbb\x5c\x37\xac\xa8\x61\xf0\xf8\xa1\xd1\xc9\x75\xb5\xa3\xe0\x51\x79\xd3\x28\xee\x3f\xdf\x5e\x78\xb5\xf7\xd0\x55\xbe\x19\x53\xa6\x4f\xf6\xc2\xf6\x9b\x5e\xb7\xa9\xf1\x03\xec\xc5\xe3\x48\x19\xf5\x28\x14\xc9\x11\x05\x01\x74\x1c\x70\x92\x41\xf8\x98\xb4\x13\xd6\x7f\x15\x03\x7c\x98\x85\x8f\x68\x61\xda\x55\xb9\xad\x58\xac\x4e\x76\xae\x1f\x11\xb6\x8b\x9a\x70\x8e\xfc\xca\x03\x30\x45\x7e\x81\x9f\x70\x34\x94\x30\xe0\xdb\x94\xf9\x47\x45\xa4\xfe\xa3\x85\x31\x28\x07\x95\xa0\x3a\x34\x37\xd2\x5a\x15\xb0\x70\x76\x64\x47\x46\x51\xf4\x14\x18\x8d\x9e\x50\xbd\x85\xab\xc9\xab\xc9\xfb\x22\x66\xaa\xc9\xaf\x19\x5f\x33\xa3\xe6\xec\x1a\x41\xe2\x6a\x6a\x24\x97\xab\xfc\x8b\x98\xeb\x13\xa9\xf8\x8b\x98\x44\x5a\xa4\x4f\x83\x10\x19\x94\x3e\x38\x8f\x1e\x78\x4c\x2e\xca\x12\xa0\x6e\x89\x27\x06\x8a\x89\xa0\x69\x4d\x46\xf5\xb5\xea\x54\x7b\x8f\x9b\xa3\x83\x22\xa7\x5d\xbb\x51\x3e\x3a\x2e\x3a\x30\x72\xdd\xaa\x4b\xaf\xde\x1a\x6c\x6b\x2d\x2b\x6b\x6d\x0b\x3a\xfd\x75\x75\x05\x05\x75\xa1\x62\xfe\x82\x61\x33\xdd\xde\x85\xa7\x9f\x7f\xfe\x57\x93\x16\x79\x73\x66\x0e\x9f\xb3\xf4\x3c\x39\x6f\x5a\x67\xe7\xb4\x29\xe3\xc7\xc3\x5f\xa2\xe3\xc6\x45\x47\x8e\x1b\x47\xdb\xd2\x83\x3d\xf8\x09\x7e\x3a\xeb\xef\x20\x72\x38\x3c\x46\xd1\x23\xe6\x17\x6c\x2e\xd8\x5d\x80\x3d\x0e\xa3\xa8\xf7\xe6\xe5\x59\x51\x17\x86\x10\x6e\xc7\x5d\x78\x29\xde\x45\x78\xd2\xad\x27\x24\x17\x3e\x3c\x73\x79\xe3\xa1\x70\xe8\x90\x8d\x68\xb3\x46\x98\x69\xd7\x9e\xe1\xcc\xe4\x65\xf2\x34\xf0\xcc\xb3\x9c\xc1\x72\xfe\x84\x29\x33\xdb\xe4\x3f\x87\x83\x15\x75\x75\x4d\xf2\xbb\xad\xad\x47\xf8\xbc\xc8\x19\x13\xe5\x07\x2c\x8d\x8d\x16\x18\x4c\x8f\x6f\x3e\x97\xdd\xee\xb1\x36\x50\xdb\x34\xb7\x37\x82\x47\xc2\x7a\x9b\x8e\x2b\x43\x28\x91\xc7\xec\x55\x5f\x6f\x14\xfe\x03\x37\x92\x67\xe5\xa9\x67\x7e\x02\x57\x0d\x1b\xc8\xb3\xca\xe4\xb3\xde\x1f\x7b\xc7\xe3\xd3\x61\x8d\x4d\x47\xf7\x5f\x53\xe1\xf2\x7b\x23\x70\x8c\xe2\x13\x16\xf7\x26\xe8\x33\xd2\x0e\xb9\x84\x73\x4f\x08\x57\x10\xcd\x72\x59\x64\x74\xa9\xbf\xbc\xbc\xb6\xb8\xb2\xd2\x0d\x79\xf9\x0e\xa1\x36\xdf\x48\x4c\xf8\x86\x7a\x6f\x51\x57\xcc\x9b\xd3\x15\x2b\xae\x20\x57\xb1\xdb\x8d\xbb\x62\x26\xbd\xcf\x5b\xe3\x76\x87\xbc\x56\xbd\xb5\x2b\x66\xd5\x83\xc4\xe9\x43\x95\x5d\xb1\x10\x90\xcb\x41\xc3\xe4\x48\xe9\x7d\x42\x0b\x84\x41\xdb\x08\x15\xb6\xa5\x6c\x3b\xcd\xc6\x89\x2a\xaf\xd2\xc0\x60\xab\xbd\x04\x35\x37\xa1\x70\x63\x11\x04\x2a\xd4\x5e\xf7\xb0\xc3\x52\xd9\x01\xae\xf6\x70\x2b\x11\x22\x15\x01\xe5\x44\x78\xce\x0f\x77\x5c\x79\x54\x3e\x0a\x38\xb1\x75\x3f\x3f\xd6\xdd\xbd\xfc\xd6\x1b\xaf\x3a\xef\x4a\xae\x7a\xbc\x6b\xcc\xdd\x8b\xff\x94\xd3\xd1\x91\xf3\xa7\xdf\xfc\x7e\x70\xf9\x78\xf3\x89\xed\x43\x9c\x70\x26\xea\xfd\xe2\xbf\xa8\xb7\xbe\x67\x5d\xf4\xa5\xb7\x1e\x7d\xcd\x0a\xd3\x1c\x43\x7e\xbe\xd1\x20\xbf\xb4\x50\x3e\xb8\x44\x7e\xdc\xb8\x4d\x3e\x4a\x79\x60\x6e\xef\x2a\x21\x28\xbc\x86\xaa\x51\x3d\x6a\x41\x77\x45\xe2\xe5\x15\xf9\x3e\x77\x53\x58\xe0\xf9\x1c\x52\x96\xba\x5a\x03\x2f\x39\x1c\x4e\x6f\x51\x31\xe6\x39\x0f\xc7\xeb\x1a\x5a\x5c\xbc\x53\xaf\x97\x82\x66\xb3\xc4\x3b\x3d\xbe\x0a\xdd\x80\xd6\xba\xa6\xa2\xda\x86\x70\xb1\xae\xa4\xc5\xde\x42\x37\x91\x74\xb8\xdc\x5e\x83\x4e\x20\x62\x3d\xdf\xce\xa3\x92\xae\x98\x9e\x23\x5d\xc7\x7c\xcb\x10\x13\x1e\x34\xec\x10\x0e\x31\xb6\xf5\x68\x36\x95\x54\xcc\xd3\xbe\xef\xca\x56\x93\xba\x40\x6b\x39\x7b\xc3\xcd\x36\xe4\x27\x6d\xa3\xf3\x90\x2b\xc7\xe3\x24\x8d\x55\x01\x39\xca\xb1\xa7\x1c\xd1\x41\x2e\x0f\x88\xd8\x99\xe3\x81\xf2\x0a\x2e\x34\x22\x52\x75\x76\xa8\x64\x70\xdb\xd9\x1d\x1b\xee\x80\x45\x30\xdb\x18\x3c\xbb\x66\x5e\xe8\xec\xe6\x33\xc7\x8a\xd3\xf3\x2b\x1b\xe4\xeb\x87\x9f\xbe\xfc\xa1\xfa\xe2\xb8\x38\x5d\xfe\x4c\x16\x1a\xa1\x71\xff\x8e\x0b\x8a\xea\x61\x79\x63\xa3\x4b\x7f\xf1\x3a\xbd\x7b\xfb\x7b\x53\xa1\xe4\x35\x38\x13\xe6\x5d\x76\x85\x61\xdd\xbd\x76\xa7\xfc\xec\x0b\x79\xee\x9e\xdd\xee\xc1\x55\x87\xe5\x1d\x81\x06\xfc\xe0\x1f\xae\xe0\xae\xcb\x93\x3f\x4b\x0c\xaa\xf4\xf3\xc3\x8c\xa0\xc8\x2d\xba\xaf\x58\x50\x18\x8f\xaa\x50\x2c\x52\xe7\x29\x29\x71\xe4\x4b\xe5\x36\xae\xdc\xc1\x71\xc1\x6a\xb7\xb3\x2b\x56\x98\x57\x86\xdc\x79\x1e\xf2\x87\x44\xd1\xdc\x45\xdc\x06\xde\x51\x42\x9b\x8a\x36\x13\x23\x1b\x55\xaa\x51\x5b\xc6\x41\x89\x29\x1c\xcc\x3c\xb4\x98\xb4\x49\x31\xb2\x93\x96\x68\x64\x2d\x10\x28\xc1\x76\x1b\x23\x1e\x76\x24\xa0\x9d\x1d\x09\x68\x57\x9b\x84\x0b\xc9\xbb\xe4\x6b\x68\xf5\xff\x79\x9c\x54\x7b\xed\xae\x7f\xbc\xff\xd5\x25\x70\xa1\x71\xc2\x9e\x31\x2d\x03\x6a\x87\x3e\x1a\xdc\x3e\x4f\x69\x01\x17\xcc\x87\x21\xb4\xb2\xc3\x49\x35\xa7\xcb\x9f\xca\x6f\xc9\x8b\x2e\xc1\x0d\xde\x61\x2f\xce\x5f\x25\xbf\xd2\x3d\xa4\x48\xee\xb6\x4e\x7d\x56\x7e\x3d\xd0\x40\xf7\x17\x25\x04\xf4\x15\x91\xcd\x45\x68\x6b\xa4\xd4\x6e\xb1\xd9\x04\x97\xc9\xeb\x85\x02\x9d\x50\x20\x14\xfb\x2d\x4e\x93\xb3\x3b\xe6\x29\x42\x84\x95\x5c\xc4\x6e\x24\xca\x6e\x7f\xef\xf3\x91\x36\x8b\xbd\x03\x45\x16\xd9\xc1\x6e\x35\x15\x99\x42\xa6\x2e\xd3\x52\x13\x91\xa9\x26\x13\x5f\xe0\xcd\xf3\x76\xc5\xf2\x1c\xbc\xb1\x3b\xb6\x48\x07\x79\x3a\xe0\xac\x3a\x90\x44\x1d\xd1\x89\x5d\x31\x6a\x4c\xd3\x76\x21\x1c\x46\xdc\x22\x45\xe0\x22\x22\xea\x19\xcf\x85\x67\xe6\xbd\x11\x9c\xd9\x98\x0a\xc3\x27\x45\x2f\x8b\x70\xa9\xc3\x2f\x61\xda\x36\x76\x85\xb1\xfc\x8c\xb1\xfc\xf4\x7c\x6a\xf5\x74\xf2\x40\xfd\xa6\x1d\xdc\x8b\xb3\x8a\xe7\x5c\x75\x31\x38\x8b\x62\xb1\x22\xf9\xbb\xaf\xbe\x7a\x22\xb1\x74\xd3\x26\x58\xc3\x4d\xcf\x1b\x23\xdf\xf1\x9d\x25\xf1\xd1\x0d\xf2\x45\x37\xfe\x61\xfe\x3e\xdf\x98\x31\xbe\x7d\x4a\x3f\x4f\x26\x6d\xf0\x3c\xe9\xe7\x1a\xf4\x40\xa4\x2e\x88\xab\xab\x11\xf0\xbc\x58\x59\xe9\x75\xe5\xe6\xb8\x1d\xbc\x4f\xb4\x05\x4a\x0c\x25\x92\xcd\x67\x16\x6b\xeb\x90\xc7\xeb\x39\x3f\xc6\x3b\x5d\xce\xf3\x63\xe0\xa2\xad\x11\x92\xac\x1d\xae\x48\x75\xbb\x77\xa2\x17\x5b\xbd\x45\x5e\xa2\x70\xbd\x5e\x53\x61\x61\xf9\xf9\xb1\xdc\x12\x52\xff\x12\x52\xff\x92\x42\x9d\xd9\x24\x99\xa4\x0b\x89\xc5\x8b\x54\x35\xd3\xae\xb4\x43\x5a\xe7\xcc\x0c\xe7\xfd\x29\xa8\x6d\x00\x85\x52\x08\xff\x34\x52\xff\xc3\xa3\x34\x02\x78\x48\x8d\xd9\x2c\xbf\x32\x5a\x6b\xa2\x9c\x2b\x02\xcd\x61\x7a\xa9\x76\xaf\xc7\xce\x48\xc9\xed\xf2\x10\xdd\xf9\x5b\xdb\x77\x7f\x17\xaa\x9a\xf0\x99\x27\xee\x18\xbd\xc1\xfe\xfa\x3d\x2d\xf3\x06\x96\x7d\xf7\xed\xe0\x4b\x57\x9f\x11\x3c\x63\xd6\xe3\x46\x30\xe0\x77\xe6\xcf\xcb\x2d\x1a\x7a\x7e\x04\x3e\x5d\x35\xf4\xa2\xcb\x2a\x1b\xe6\xcd\x9f\xb7\x70\xe2\xf6\x7d\x96\x02\xf9\xcd\x17\x9a\x7f\x3e\xb3\x6b\x1e\x6b\xa3\x56\xf9\x98\x78\x2d\x7f\x3f\x91\x30\x67\x47\xda\x1c\x66\xbd\x20\xe4\xe5\x15\x14\xa3\x8a\x8a\x9a\x9a\x62\x33\xd7\xd8\x10\xaa\x25\x12\xd4\x5a\x91\xe7\x30\xd7\x54\xd7\x74\xc5\x8a\x0a\x6c\xd5\x0e\x43\xce\xe4\x98\x81\xe3\x4a\x27\x13\xd9\x21\x8a\x02\xe2\x6c\x6c\x0c\x23\x64\x57\xc6\x5a\xa8\x0c\x09\xbf\xcc\x4c\xa0\x70\x98\xe9\xde\x6c\xf9\x4a\x0f\xa3\xa4\x27\xa0\x3b\xc3\x1c\xf9\xc8\x85\xb4\x7e\xb2\xd2\x53\xfc\x89\x0b\xe6\xcc\xd2\x56\x7e\x78\x6c\xc4\x0d\x4b\xef\x1c\x7c\xe5\xb2\xf3\xae\xe9\x96\x67\xc9\xb5\x53\xa3\xc3\xea\xda\x42\xb3\xe4\xeb\xce\x59\xf6\x7e\x74\xd8\xb0\x69\x9d\x72\xed\x8c\x19\x70\x0e\x37\x3d\xd0\x31\x0f\x86\xca\xff\x1a\x22\x7f\x93\x78\xd8\x3b\x6c\x98\x17\x87\xa6\xce\x72\xae\x4c\xfc\xce\x3b\x4c\x3e\x86\xcd\x70\xdd\xd4\x59\x15\x89\x51\xec\x87\x9f\xbc\x34\x04\x4e\x7c\x9a\x7c\x62\x47\xed\x23\xbc\x52\x46\x24\x42\x2d\x69\x89\x2d\x91\x69\x9e\xda\x1c\x2f\xf1\xf6\x43\x95\x15\x1c\x35\x7e\x03\x45\x90\x53\x57\x2e\x08\x0e\x8b\x01\x0c\x8d\x0d\x85\xb9\x4e\x2a\x27\x78\x64\x32\x9b\xba\x62\xd5\xe5\x01\x73\x6d\x55\x89\xcd\x6e\xeb\x8a\xd5\x15\x79\xea\xed\x6e\xab\x1d\x8c\x9c\xd9\x6e\xb6\xd3\xe9\x66\xd4\x99\x20\x52\xd6\x81\xa9\x4f\xa5\x4a\x0f\x66\xf7\x12\xca\x20\xba\xba\x51\x8d\xe9\x31\x4f\x88\xdd\x69\x43\x7c\xe1\x70\xea\x52\xc5\xad\x32\x71\xd5\x4e\x6c\x27\xb5\x71\xe8\x79\xe8\xe4\x62\x8d\xe4\x57\x4f\xf3\xa6\xbc\x13\x76\x97\xf9\x2b\x02\x02\xf9\xb1\x2c\x5c\x21\xa0\x95\xf2\x3a\x79\xe0\x1e\x39\xb0\xe3\x09\xf2\xda\x01\x07\x61\x21\x54\xed\x81\x8f\x77\xec\xdb\xb7\xaf\xe7\x6e\xb8\x68\xfd\x37\xf8\x8b\x89\x87\x13\x0f\xdd\x7f\x3f\x7c\x25\xe7\x91\xeb\x72\xca\x48\x70\xe5\xbc\xfd\xf3\xe0\x3c\xc2\x62\x41\xfa\x3e\x26\x4f\xbe\x91\x3c\x98\xb7\x7f\xff\xfe\x79\x7f\x52\xe7\xfa\xf6\x7e\xab\xdb\x48\xda\x6e\x12\x8a\xe1\xdc\x48\xac\xd3\x60\xb0\xe6\x9c\x9e\x5f\x5c\x9c\xcb\x0d\x2b\x6f\x1a\x58\x33\x66\x4c\x13\x77\xba\x55\x98\x1e\x3f\x37\x0e\xe3\xe3\x33\xe2\xb8\x36\x3e\x24\x8e\xf3\xe3\x60\x8e\x43\x22\x0e\xdf\xc6\xe1\x99\xf8\xa1\xf8\xc7\x71\x6e\x47\x1c\xee\x8b\xc3\x0d\x71\xb8\x24\x0e\xe3\xe2\xf1\xf8\x92\x38\x57\x13\x1f\x1c\xc7\xe6\x78\x41\x1c\x2f\x42\xf1\xfd\x80\x22\xbd\xf3\x16\x76\x3c\x1a\x7f\x26\x8e\x37\xc5\x61\x55\x7c\x5d\x1c\xc7\x9f\x8f\x75\x75\xf4\xc4\x21\xfe\xfc\xd4\x33\x3a\xe2\x6b\x26\x4e\xe9\x88\xc5\x61\x50\x7c\x5c\x1c\x57\x91\x87\x6b\x46\x8d\xed\x38\x14\x87\xa7\x29\xe6\x47\xe3\x78\x5d\x1c\x2e\x4b\xe1\x96\xe2\xb9\xf1\xb6\x38\xd7\xf6\x73\x1c\x0e\xc6\x3f\x8a\x7f\x13\xe7\x9e\x8c\xc3\x3d\xf1\x47\xe2\x78\x4c\x7c\x51\xfc\xe2\xf8\x6f\xe2\xfc\xa0\x38\x10\x2c\x3e\x56\x54\x20\x99\xec\x89\x1f\x88\xe3\x71\x24\xf1\xaa\x38\xd7\xce\x7e\xb0\xc6\xe1\x18\xc5\x4f\x31\x70\x9b\xe2\xbb\xe2\x18\x17\xc7\x27\xc5\x97\xc5\x39\xf2\x8b\xc4\x0d\xab\x69\x1d\x3f\xbe\xfa\xb4\xd8\x79\xe5\x30\xb5\x7c\x6e\x39\x1e\x5e\x0e\xa5\xe5\x4d\xe5\xc4\xbb\x2e\xb7\x95\x63\x83\x50\x3e\x3e\xa7\xb5\xfd\xb4\xd8\xa5\x03\x61\xc9\x40\x98\x31\x10\x06\x0d\x1c\x37\x10\xe7\x0d\xac\x1e\x88\x39\xeb\x40\x30\x88\x03\x5b\x5b\xf3\x8b\xf8\x7c\xfe\xb4\x98\x2f\x3f\x92\x9b\x2f\x75\x46\x8a\xbb\x63\xf9\x52\xbe\xe4\x30\x39\xa6\x75\xc7\x1c\x84\xdc\x1c\x9c\xd5\x60\x22\xd4\x65\x72\xa0\xc0\xc4\x18\x31\x96\xdb\x93\xc2\x97\x0e\x2b\xa4\xdc\x6d\xf2\x3d\xcf\x6b\x3b\xa4\x8c\x82\x7a\x43\xaa\x9c\x9e\xa9\x88\xea\xd4\x37\x05\x3e\x15\xe1\x52\x63\xde\x7d\x62\x56\x41\xf2\x34\x18\x5c\x1e\x24\x8f\x82\x5d\xd9\x31\x72\x55\x9a\x69\x5d\xe3\x64\x84\x9a\x10\xaa\x18\x84\x34\x47\xd3\x3d\xa8\x75\xf4\x5c\x72\xea\x86\x51\x8b\xba\xb5\x99\x79\x25\xcd\x4d\x75\x50\xa1\x4e\x7a\xa6\x87\xfe\xd7\x01\x33\xbe\x0a\x95\x33\xf3\xe9\x28\x78\x85\x08\x4d\xcc\x04\x6b\x6c\xe1\x1f\xb9\xf0\xc2\x79\x2b\x0e\x2f\x5b\x25\x5b\x62\xf3\x61\x13\x98\x41\x3f\x76\xda\xc5\x8b\xaf\xbf\xbe\xa8\xac\xba\x65\x98\xbf\x65\xfe\xb9\x79\x75\xd3\xa7\x4e\xa8\xb9\xe5\xba\xf9\x6b\x86\x15\x3b\x46\x05\xaa\x9b\x8b\x5b\x66\x9d\x3b\x79\xcb\x2d\x03\xd6\x35\x77\x24\xae\x9d\x7f\x65\x69\xe5\x45\x67\xbb\xce\x59\x03\xcb\x2b\xce\x92\x3b\x29\xcd\xf3\x17\xe4\x8d\x79\xfa\xad\x3f\x4e\x37\x7e\xf4\xde\x2c\x79\xfd\xf0\x88\xf5\xfa\x09\x67\x4c\xce\x2d\xc9\xcd\xf3\x0c\x98\x16\x99\xbb\xb2\xe0\xd0\x24\x9f\xbf\xb4\x2c\x37\x90\x9f\x57\x34\x3f\x7e\xf6\xca\xfc\x9c\x46\xee\xc0\xe6\xd5\x89\x47\xd7\x33\x9b\x36\xd0\xfb\xad\x74\x15\x8b\xc7\x34\xd3\x19\x4c\xa8\x53\xa4\x67\xb7\xfa\x22\x46\x8c\x4a\x81\xfc\x4f\x2a\x85\x52\xa2\x5c\x1e\x37\x7a\x3b\x4a\xed\x41\xd2\x68\x6c\xce\xbc\xa8\x9c\x0b\x40\xf8\xa8\x02\x05\x89\xed\x1b\x26\xf6\x5e\x1b\xba\x28\x32\xdc\x13\x6c\xaa\x0e\xb5\xd6\x95\xeb\x07\x0d\xac\x28\x29\xcc\xf1\x79\x7d\x5d\xb1\xd6\xa6\xb6\x16\xa3\xce\x6a\x23\x96\x6e\x7d\x4d\x25\x6f\x0b\x05\x39\xa2\xb5\x88\x2d\x9c\x8f\x5c\x21\x17\x34\xd9\xc2\x2e\x57\xd8\xd6\xc4\x9b\x4b\xbd\x9c\x64\x76\x2a\xa7\x85\x7b\x88\xc0\x09\x85\x66\xa6\x84\x0c\x93\x29\xea\x6d\xd8\x9e\xba\x51\x83\x61\xa4\x4b\x74\x7e\x2a\x87\xd9\x9f\xbf\xd9\x4f\xd5\x10\xc7\x64\x8b\xd3\xef\x0c\x93\x8b\xdd\x43\xb8\x95\x08\x18\x7a\x55\x04\x80\x7c\xb4\x06\xc4\xff\x3e\xf3\x71\x1b\xe4\xc8\xaf\x6f\x59\xf5\xf6\xcf\x6f\xae\xda\x2b\xef\x86\xda\xc8\x77\xaf\x5f\xb1\x12\x4f\xbf\x6f\x2d\x8c\xdc\x70\xd9\x06\x08\x9e\xfb\x10\x3c\xb6\xb2\x27\x76\xce\xd8\x9f\xb9\xba\xb9\xad\x5f\xca\xd3\xb7\x8f\x75\xc9\xdf\xdb\xfd\x1c\x36\x15\x70\x0b\x89\x7c\x49\xf4\x60\x81\x5e\xaa\xec\xa1\x52\x07\xce\x92\xef\x53\xee\x13\xcb\xf7\xd3\x97\xbc\x3f\x58\x55\x45\xe4\xcf\x55\xbd\x9f\xf2\x67\xf2\xeb\x91\x1f\x0d\x27\xd6\x5c\xae\x17\x0d\xaf\xb6\xeb\x1a\x06\x0f\xd6\x55\x23\x7e\xe4\x88\xc2\xa1\x66\xf3\xd0\xf2\x72\x6e\xe8\x80\xa8\x19\xe6\xa0\xa1\xa8\x0e\x16\xa1\x18\x1a\x0a\x5d\xc4\xbc\x76\xb1\x7b\x0e\x66\xab\x5c\x83\xa8\x93\xda\x16\xb2\xb7\x85\x6c\x07\xb2\x36\x53\x07\x1b\xe7\x2f\x21\x0e\xa1\x9d\xf8\x85\x8a\x4b\xe5\xca\x19\x04\xd4\x81\x0e\x01\xa3\xd3\x1c\x70\x59\xa0\x82\x52\x39\xa5\xcc\x12\xec\x76\x15\x29\x4f\x2a\xca\xed\x36\xa7\xbf\x91\x90\x2e\x7f\xe6\x83\xf2\xd5\x53\x6b\x6d\xb6\xdc\x3a\xab\x91\x77\xd6\xff\x38\x69\x88\x99\x1b\x6b\x73\xf2\x39\xf2\x87\xd6\x0e\xa3\x59\x74\xd7\xfc\x34\x61\xa8\x95\xb3\xb7\x1b\xac\x42\xee\x83\xb0\x6a\x5c\xbd\x03\xef\x96\xaf\x92\x0f\xd9\xab\x87\x62\x4c\x18\xa7\xca\xe4\x91\xef\x0d\xe7\xfe\xf4\xda\xd6\xbb\xeb\xdd\x43\xf2\xee\x95\x0b\x5c\xb9\xed\x9c\x39\x07\xe6\xb7\xba\x65\xf9\xd9\x5d\x37\xd6\x5b\x72\x1a\xb1\xef\x59\x10\xe1\x52\x08\x5b\x2b\x23\xa4\x92\x7a\xf9\x73\xde\x2e\xac\x27\x77\x25\x44\xb7\xad\x89\x8c\x2c\xf0\xfb\x8b\x2a\xbd\x39\x4e\x1b\xcf\xfb\xb8\xa2\x00\x32\x1a\x5d\x45\x5c\xa8\xae\xa4\xe8\xb4\x58\x89\xa3\xd0\xe5\x76\x4d\x8c\xf9\xdc\x6e\x4b\x6e\xae\xe7\xb4\x58\x2e\xaa\x0a\x5a\x82\x13\x63\x36\x8b\xb5\xb2\x5c\x5f\x3e\x29\x46\x6c\xaa\x18\xf0\x7a\x4a\x53\x2f\x07\x53\x96\x30\x0a\xa7\x3c\xec\xf4\xb7\x64\xd8\x41\xa5\xb4\xe4\x58\x11\xf5\xfb\x2d\x38\xa0\xc6\xf2\x3c\xe5\x43\x80\xea\x2f\x4a\x4d\x54\x0c\x10\xe1\x00\x4c\x14\xd8\xa9\xc7\xa5\xe7\x91\x7c\xfd\x80\xc1\xe3\xeb\xde\x3e\x78\xf8\xcd\x73\x96\x8a\x7f\xfd\x6b\x37\x5c\xb1\x60\xc1\x02\xf9\x76\xf9\x9a\xae\x33\x26\xc4\x26\x8f\x9f\x3e\x57\xfe\x7c\xc3\x06\x98\x5c\xea\xb1\xfc\xf3\xd8\xd1\x9f\x7c\xfe\xeb\x0d\x0b\xae\xf0\x0e\xfb\x68\xc1\x09\xab\x77\x18\xbc\xfd\xc4\x73\xd5\xf8\x31\xd7\xf3\xd4\xce\xc9\xeb\xfd\x96\xfb\x27\xb1\x05\xab\xd1\x6f\x22\x3e\x8b\xd9\x5c\x92\xe7\x72\x05\xf2\x9d\x1e\x4f\x95\x0e\x07\x70\x4d\xb0\xca\x97\xe7\x23\x86\x5f\x9e\x62\xf8\x99\x3a\xf2\x5c\x11\x22\x9f\xdc\xe7\xc7\x74\x56\x57\x11\x61\xab\x2e\xd7\x52\x17\x31\x85\x5d\x2e\xa9\xbc\xbc\xe8\xfc\x58\xa0\x3c\x57\xb2\x9f\x1f\xab\x32\x83\x59\xd2\x91\xd6\x50\x24\x69\xda\xe4\x0b\xab\x32\x57\xb5\xfb\xb4\xda\x9c\xda\xbc\x6a\x08\x2d\x5c\xd1\xdc\x4a\xaa\xef\xf0\x37\xe6\xa8\x7e\x02\x47\xb8\x4e\x47\x0d\x3c\x7f\x21\x28\x9e\x25\x11\x78\xa8\x22\x90\x77\x2e\xc6\xe7\x5e\x30\x18\xfe\x38\xef\x86\x69\x7c\x2c\x7f\xea\xc2\x8f\x0a\x20\x5f\xfe\x1b\xc7\x41\x91\xfc\x85\xfd\x37\xf3\x2f\xef\xc8\x8f\xf1\x5b\x77\x1e\x96\x7f\x2c\xba\x00\x4f\x1e\x5e\x5e\x31\x0f\x0b\x36\xbb\xfc\xf9\xed\x51\x79\xce\xbc\xd1\xad\x8e\x79\x6f\xbd\x3e\xe9\xb7\xf2\xfb\x8d\x20\xfd\xa4\xd8\xc6\x74\x16\x61\x15\x91\x37\x01\x34\x2f\xd2\x6c\xd4\xfb\xb1\x89\x2b\xb2\x5a\x5d\x2e\x0e\xeb\xf9\xb2\x52\x7f\x21\xce\xf5\xe5\x76\xc5\xcc\xc4\x85\x23\x9e\x76\x11\xcf\xf9\x3c\x1e\x47\xc0\xc7\x59\xf5\x2e\x87\x8b\xe8\x1d\x87\x31\x69\xcd\x28\xe6\x0c\x71\x83\xb4\xd6\x4b\x38\x83\x7f\x94\xe0\x97\x0e\x68\xb5\xa8\xad\x07\x01\x5d\xda\x76\x49\x5a\x2c\x50\xd1\x2c\x3c\xb3\x4d\x1e\xb9\x98\x1e\x84\x05\xb7\x5d\x26\x8f\x95\x03\x83\x27\xfd\x31\x71\xe6\x8e\x97\x5e\xda\x81\x6f\x7d\x34\x07\x4f\x58\x25\x0c\x21\xb2\xe0\xe2\x6b\xe7\x25\x12\xbe\x31\x78\xc1\x48\x79\x18\x95\xd7\x98\x9b\x87\x2d\x4c\x32\xfc\x40\x3f\x49\xdd\x8a\xe9\x99\x53\xac\x6e\x17\x45\x86\x9a\x8d\xb9\x85\xa2\x5e\x5f\x68\xe4\xca\x4a\x73\x0b\xf3\x0b\xbb\x62\xee\x92\x1c\xbf\xbf\xd8\x8e\x1d\x00\xc8\x5b\xe4\x29\xf6\xe4\xb8\x02\x4e\xe4\x74\x38\x72\x50\x31\x2f\xe5\x3b\x4c\xc4\x83\xb6\xf1\x12\xdf\x1d\x93\x54\xbf\x86\x56\xc1\xdb\xae\x7a\xbd\x6d\xfd\xbc\x67\xd8\xf5\xca\xea\x05\x52\x39\x62\xcd\x06\xec\x49\xb7\xa6\xd5\xad\x73\x93\x4b\xad\xb8\x8e\xb8\x35\x10\xfc\x2c\xfc\xe5\x4c\x5f\x5c\xf0\xcc\xf0\x4d\xf9\x9f\x86\xc3\xe4\xf5\x5e\x22\xef\xbd\xcf\x3e\xc3\x83\x96\xcd\x86\x57\x5c\x3f\xc3\x85\xf2\x6f\x7e\x76\xc8\x07\xba\x97\x75\x9f\x47\x2e\xd9\xcf\x4c\xb2\xce\xd9\xcb\x66\xd3\xf5\xf2\x02\x1a\x2d\x2f\xd2\x5f\x2f\xbc\x8b\xe8\x3e\xca\xa3\x88\xb7\x33\x03\xad\x8d\x74\x70\x53\xa2\x96\x22\x67\xa0\x6d\x42\x28\x54\x3f\xba\xe2\x4c\xa9\xa2\xbe\xcd\x69\x99\x22\xe9\x66\xcd\xb4\x44\x4d\xc3\x87\x4f\x8a\x8b\xf1\xae\x98\x73\x70\xd1\xe0\xae\x58\x6e\x51\xcb\xd8\xee\xd8\x14\x6e\x1a\x32\x4d\x23\x9d\xdc\x62\xaa\xa9\x31\xb5\x10\x8b\x03\xd5\x57\x8b\x0e\xca\xe2\xe1\x03\x8a\xda\x50\x2c\x03\xed\x64\x2a\x35\x70\x06\xfd\x8d\x59\xf9\x89\x86\xb6\x40\x8a\xc5\x5b\x87\xe2\x56\x0b\xe8\x9a\x5b\xca\x86\x42\xab\x47\xd4\x15\x12\xe1\x88\x79\xa0\x9a\xbc\x42\x27\xea\xfc\x2d\xad\x4e\xb6\xc4\x82\xe8\xf4\x0a\x11\xeb\xb0\x8e\x46\x0b\x1c\xa0\x89\xb4\x09\xa9\x5b\x2e\xd6\xb9\x7e\xec\xd0\xeb\xbb\x3a\x17\x5e\x76\x56\x63\x43\x7d\x79\x64\x4a\xcb\xd2\xf7\x4e\x7f\x0b\x4a\x86\x5e\x78\xc6\xc2\xe6\xce\xdb\x3f\x5a\xb9\x43\xfe\x8c\xbf\xe2\xd5\x07\xa7\x0c\xad\x28\x0e\xcb\x9f\x87\xeb\xce\xa9\xf8\xfd\xad\x77\xbd\x78\xa2\x62\xed\xca\x96\xee\xb6\xf6\x41\xf3\x97\x9f\xb5\x6d\x2e\xfe\x73\xb8\xba\x6e\x60\x53\xb0\xb6\xed\xe7\xef\xeb\x5a\x2a\xdb\x1a\x4a\x3b\x9b\x06\x0c\x6a\x98\x32\x7c\xcc\x19\xc6\x9e\x3f\xfc\x69\xdf\x48\x53\x7b\xe5\x39\x33\xc5\xa1\x67\xb4\x36\xd5\x2e\xb5\xde\xfd\xf3\x3d\xcf\xc8\x3b\xf6\xc1\xa0\x0d\xbb\x73\x9f\xd9\x38\x6b\xce\x63\xb0\xef\xee\x6b\xef\x85\xb2\x97\xfe\xeb\xea\x94\xff\x7b\x5c\xfe\xdb\x65\x13\xef\x87\x2a\xf9\x58\x6c\xee\xc2\x69\x67\x2e\x3c\x5b\xe7\x2c\xcd\x0f\xf8\x99\x6d\x2c\xca\x1d\xdc\x77\x44\xe6\x18\x88\x4f\x31\x3b\xd2\x54\x5b\x9c\x87\xf2\xed\xf5\xd4\x13\xb7\x58\x5c\xe5\x36\x3b\x2a\xd6\x35\x36\x18\x8d\x01\x4b\xa0\xba\x3b\x56\x1e\xf0\xd5\xdb\x4c\x9c\x45\xef\xb1\x5a\x2d\x1e\x0f\x26\xee\x39\x6f\x51\x98\x8c\x09\x15\x47\x1b\xa1\xbf\x94\x88\xe9\xd3\xf4\x84\xe4\x9a\xd4\x20\xd5\x50\x00\x4e\x17\x00\x27\x0d\xc6\xa8\x03\x26\x1c\x6d\x74\xda\xe0\xcd\xa9\xc0\x6f\x05\xd7\xb1\xa4\x6e\x48\x5d\xc3\x80\x76\x79\xe5\x0b\x17\x5d\x06\xf5\x4f\x4f\xbc\xb8\xf3\xf7\x5b\x2e\xba\x7a\xf7\xe2\xf1\x15\xaf\x3e\xd0\x3d\x3e\x12\xf4\xe6\x36\x47\x1b\x06\xf0\xa3\xee\x3e\xed\xcc\x69\x8f\x5f\xb4\xec\xdd\x9e\x6d\x30\xe8\x63\x5c\x2b\xbf\x75\xdf\x7f\xc0\xd8\xb5\x79\xef\xd5\x2b\xf6\xca\x0f\x7e\xf5\xfa\x23\x93\xef\xda\xe7\x39\x7c\x9e\x73\x5e\xe7\xc2\x43\xab\xa9\x3f\x45\x64\x0b\xff\x39\xe1\xbf\x62\xe2\x51\x05\x51\x03\xda\x1a\xe9\x6e\x28\x2f\xe5\x79\xbb\x59\x0a\x55\x94\xf9\xfd\xc4\x86\x6d\x0c\x37\x70\xdd\xb1\x7a\x64\x34\x19\xbb\x62\xa5\x85\xa6\x80\x8f\xd9\x33\xe5\x5e\xdb\x24\x53\xb7\x09\x87\x4c\xed\xa6\x89\x26\x0e\xd9\x6c\xb6\x62\x1b\x27\xa1\x06\x5b\x03\xb6\x70\x0d\x26\x9b\xcd\xd4\xc0\xe9\x5c\xae\x60\x77\xcc\xe5\xe8\x8a\xb9\x38\x5e\xd2\x49\x5d\x31\x9d\x03\x69\x8d\x5e\x0f\x35\x7a\xa9\x14\xa6\xd6\xa9\x3d\xe9\x50\xa5\xe4\x53\x2a\x00\x91\xba\x48\xe3\x89\xfe\x40\xa6\x3f\x45\x75\x52\x23\x4f\x7d\x72\x8f\x4b\x47\x7c\xa9\x0a\x22\xbc\xca\xfc\x75\x10\x04\x67\x63\x4b\xab\xdf\xcd\xdf\x78\xa6\xfc\x9b\x3d\x9f\x26\x46\x6d\x7a\xe9\x25\x2a\xa1\x26\x7e\x0a\xf6\xd0\xe4\xc1\x98\x1f\x2a\xaf\xc5\xf2\x83\x10\x93\x7f\x07\x63\xbc\x17\x2e\x99\x38\x65\xde\xf2\x3c\xf9\x19\x8e\xff\x51\x31\x2f\xf1\xe6\x79\x97\xcc\xbb\x39\x6f\xcc\x05\xab\xe7\x35\x94\x95\xce\xdb\x11\xbe\xe4\xd3\xb1\x43\x12\x8f\x0e\x1f\x79\x1d\xa3\x99\xb9\xbd\x73\x45\x10\x0e\x12\x6d\x5d\x85\x16\x45\xda\x5c\x92\xdf\x5f\x2e\x96\xe4\x14\x04\xb8\x02\x8b\xb7\x84\x13\x82\xd5\xf9\x9e\x5c\x0f\xe1\xdd\x5c\xb1\xa4\x38\x52\x4c\x64\x71\xb1\x53\xac\xe8\x8e\x89\xc4\x00\xb4\x4a\xba\x88\xc8\xa3\xf2\x6e\x25\x50\x45\x34\x52\xde\x21\x52\x61\xc5\xb8\xa1\x0e\x00\x91\xd3\x59\x92\x4a\x9d\x26\x2e\x94\xd2\x68\x55\x59\x73\xd8\x5d\x88\x69\x98\x81\x58\xe0\xf6\x96\x56\x55\x34\x8b\xbc\xce\x1d\x00\x97\xc3\x63\x17\x31\xe7\x94\x9f\x91\x6f\x85\xb3\x60\xfc\xfc\xb9\x7b\xf7\x19\xa6\x7b\x47\x3c\x7f\xd6\xc2\x39\x6b\xf1\xb0\xab\x16\xc9\xff\x58\x3b\x5f\xbe\xef\xf7\x8f\x3d\xf9\xb0\xd3\x08\x0b\xa0\x1e\x86\xc1\x12\xeb\x9a\x35\x5c\x5e\x13\x27\xbf\xb1\xb3\x3e\x82\x7b\x96\xf1\x45\xb0\x36\x6f\xec\xd8\x3c\x79\x7c\x20\x24\x5e\xcf\xd5\xfe\x2c\x7f\x52\xc0\xaf\xf5\xc9\x7f\x53\x62\xfe\xea\x1a\x71\x54\x44\x6a\x5f\x8e\x2e\x8c\x8c\x32\x08\x66\x87\x28\x94\x96\xf9\x8b\x03\x26\x87\x54\x59\x61\xe2\x89\x7d\xd2\x15\x0b\x80\xbb\x1c\x79\x73\xbd\xa4\xee\x05\xb9\xd6\xdc\xa2\xdc\xf6\xdc\x89\xb9\xab\x73\x37\xe4\x8a\x12\xe7\xce\x75\xe7\xda\x4a\x7c\xbc\x83\xa4\xb5\x99\x89\xdf\x6d\x73\xa8\x53\x58\xc3\x19\x8e\x77\x16\x55\xa4\x9a\x44\x8d\xc3\x38\x19\x2d\x70\x7e\x8e\x7d\x3a\x09\x3d\x10\x45\xed\x27\x76\xaf\x9f\x78\xd5\x46\xf0\x57\xf8\xf9\x8b\xea\x5e\x7b\xe0\x9a\xf9\x89\x47\xee\xb9\x52\x46\x97\xee\x90\x17\xce\xbd\x66\xdb\xeb\xa1\x9f\xa1\xe8\x30\x94\xfc\x15\x0a\x4f\x5c\x0b\x8e\x6b\x3f\x81\x7d\x35\xf2\x03\xf8\x81\x4b\xe6\xc9\x9b\x99\xec\xee\x4e\x7e\x12\x1a\xc0\x91\xc4\xf3\xf3\xe6\xc1\x05\x89\x47\x2e\x21\x3a\xab\xa6\xf7\x5b\x7e\x19\x91\x15\x4d\x68\x4e\x64\x80\xbb\xbe\xb9\x45\x60\x15\xc4\xb9\xa8\xa0\xb0\xa0\x2b\xd6\x58\x5d\x58\x6b\x2d\x2c\x2a\x0c\x15\x76\x15\x2e\x2d\x24\x86\x88\x25\xb7\xb0\x30\xd7\xc2\x39\x6b\x6b\xcb\xbb\x62\xb5\xbc\x93\x38\x81\x4e\x67\x7a\xb0\x23\xc5\x02\x34\xc2\xa0\xa8\x30\xcd\x14\x53\x10\xa9\x75\x4f\x27\x93\xfa\x59\x60\xd6\x4e\xc4\x75\xb1\xbd\x89\xda\x22\x2d\xb4\x9e\x6c\x02\xac\xa2\xbe\xd4\x89\xa7\x61\x37\xf7\xc2\xc8\x3b\xe0\xfa\xc4\xfc\xd3\xda\xa1\x68\xc6\xf6\x60\xed\x99\xd3\x8f\x2c\x95\x25\xfd\x98\x73\x6a\xe7\x9c\x80\x7f\x5e\xb7\xa0\xe5\x8a\xcb\xaf\x9b\x5f\x1b\x7b\xe5\xd1\x7f\xfc\xdb\xbb\x02\xff\x63\xda\xe0\x79\xe5\x67\x0c\xf8\x76\x58\xc3\x07\xf2\x9d\xfe\x72\x78\xa4\xa1\x7a\x5e\xe7\xa0\x79\xb5\x03\x3a\x1a\xe2\xb3\xc6\xee\x87\xf6\xe0\x93\xbf\x9f\x38\x6a\x1e\x4a\xd2\xbc\x10\x24\x34\x9f\x4f\x34\x76\x3c\x12\x32\xd9\x25\x9f\xaf\x58\xcc\xcf\xcf\x29\xe0\x72\x88\xd6\xce\xcf\x8b\xb8\xf3\xf2\xec\x5d\xb1\x3c\xa7\xe8\x27\x94\x4e\xfc\x5e\xb3\x42\xe9\xc5\xfd\x51\xba\xea\xec\x6a\xc6\x9b\xc2\xea\x98\x67\x9a\xca\xd5\xc0\xb4\x7d\x28\x50\x13\x8b\x68\x27\x42\xe0\xb6\x24\x81\x3f\x29\xdf\x09\x71\x98\x3a\xff\xd9\xbf\x8a\xd3\xf3\x57\x3f\xb4\x78\x53\x5d\x71\x5c\x8c\x7d\x37\x9f\x50\xf7\x53\x0f\x3d\xb1\xc3\xa9\x87\x79\xd0\x0c\x93\x61\xae\xb8\xe6\x0a\x7d\x9b\xfc\xec\x0b\x9d\x7c\xcf\x32\x6e\x50\xc5\x61\x79\x87\xbf\x46\xb8\x9e\xab\x93\x4f\xc8\x5f\xe6\xf1\x6b\xf3\x64\x65\x4e\x8f\x7c\x06\xf7\x5b\x78\x54\x7c\xc8\xa6\x43\x66\x19\xd3\x33\x15\x88\x8c\x1c\xd0\xfb\xa5\xb8\x42\x98\x4c\xa8\xde\x82\xf2\x88\xbf\x77\x46\x24\x6c\x75\x4b\xc0\xf1\x75\x7e\x7f\x85\x4f\xe2\x85\xe6\xa6\x70\x43\x61\xc3\x3e\x22\x1c\xf7\xc7\x4b\x83\xfb\x62\x15\xa5\xa5\x1c\x6f\x72\xec\x8b\x89\xa6\xfd\x71\xd1\x4b\x3e\x45\xa0\x76\x78\x6a\x76\x4a\x38\x18\xd4\x30\x37\x33\x4d\x1a\x53\x13\x48\x92\x63\xe7\x3a\xed\xdc\x10\x8d\x92\x76\xa7\xc6\x38\x88\xf1\x0d\x7b\xe8\xa4\x11\x30\xca\x4f\x6c\xd9\xb2\xf5\xc1\x4d\xdb\x3e\x68\x1d\x34\xa0\x31\xdc\x3a\x70\xc0\x89\x6f\x02\x17\xb4\x3f\xf7\xe4\x53\x5b\x56\x2c\x6f\x09\x34\x0e\x1d\xd5\xd9\x35\x6f\xe1\x18\x97\x30\xff\x84\x5e\x5e\xf7\xec\x13\x8f\x3d\xb3\xff\x89\x9b\x57\x5f\x72\xc7\x3d\x97\x5e\x09\x5f\xe4\x17\xec\xdf\xff\xe8\x4b\x79\x6f\x5f\x5c\x76\xff\x95\x77\xae\xc9\x61\xfd\x6c\xec\xfd\x16\x7f\x2f\x4c\x21\xfd\x5c\x8e\x46\x44\xfc\xa5\x79\x79\x56\xa9\x20\x07\x73\x5c\x8e\xc4\x55\x54\x1a\x4c\xb9\xa5\xd6\x52\x93\xb9\xb4\x14\x15\x3b\x79\x84\x45\x5a\xbb\x43\xed\x54\x68\xbd\x4b\xde\x48\x8f\xb6\x65\x46\x12\x1b\xea\xcb\x1a\xe9\x8a\xcc\x00\xdd\x95\x41\x24\x06\x46\xab\x5d\x55\x77\x58\x47\x2a\xe2\x54\x8f\xbc\x1a\x0a\x18\x5d\xe7\x1f\xe9\xb9\xfa\xc2\xcb\x6f\x9e\xb8\x7c\xc9\xb4\xdf\xac\x59\x7c\xde\x5d\x0f\x76\xdc\x3b\xb4\x75\x40\xeb\xca\xa5\xa7\xbd\x77\xdf\xdd\x9b\xee\xd9\x55\x50\x30\xa6\xa0\x10\x4b\x37\xdf\x75\xdf\x86\x9d\xbd\x28\x7e\x6c\xfe\x05\xdc\x3b\x67\xaf\x5a\x74\xa1\x3c\x7a\xf4\xbb\xac\xbf\x2a\x10\xd2\x5d\x42\x74\x9a\x93\x48\x27\xea\xa3\xdf\x16\x99\xe6\x90\x24\x8b\x4e\x74\x56\x96\xe6\x15\x57\xb9\x5c\x79\x4e\x0b\x5f\x53\x5b\xee\x29\x29\x30\x7a\x7c\x9e\xa0\x87\x33\x16\xf8\x0a\xb0\xe4\x29\xf0\x14\xe0\xca\x60\xc0\x49\x4a\xe1\xb4\x39\xb1\x55\x70\x4a\x16\x93\x85\xe8\x2c\x93\xc3\x5a\xad\x07\x62\x51\x83\x55\xd0\x0b\xa4\x79\xba\x62\x76\xcc\x25\x85\x15\x0b\xca\x24\xdd\x2b\xe5\x9b\x57\x1d\x2f\x9f\x45\x95\x9a\x3d\xac\x71\xb1\xd2\xe3\xbb\x8a\xc4\x0e\x68\xc2\x2c\x50\xc6\x62\x26\xc9\xee\xa7\xf1\xe3\x70\xa3\x40\xd8\x9f\x67\xe1\xbf\x95\x89\x22\x1a\x14\xdc\x01\x07\x71\x2b\x77\xfa\xcd\x1b\xae\xbd\xe5\x96\x75\xd7\xde\xfe\xd4\xfc\xd9\xb3\xe7\xcb\x37\xe3\xdc\xc4\xd7\xfc\x5f\xa9\x6d\xdd\x53\xce\x97\x9c\x18\x96\x0c\x8f\x9c\x78\x3a\xff\xa6\xbb\xee\xb8\xf9\xa6\xdb\x6f\xbd\xf9\xd3\x4f\x3f\x7f\xf2\x22\xd2\x3e\x67\xf6\x7e\x2b\x3c\x4b\xe8\x99\x8e\x4c\x57\x12\x7b\xf4\xea\xc8\xa4\xda\xb2\x82\x02\x47\x6e\xb1\xa3\x58\xdf\x8c\xf4\xa8\x6d\x60\x81\xc3\xe6\x78\x35\x56\x96\xff\x6a\xac\xd4\xe9\x76\xbe\x1a\xa3\xda\x1d\x17\x95\x41\x7b\xd9\xc4\xb2\x23\x65\x5c\x59\xc4\xe6\xea\x40\x6e\x9b\x1b\x4b\x9c\xad\xcc\xed\x2e\xb3\x11\x7a\x37\x55\xbd\x16\x33\xf1\x7c\xc3\x6b\x31\xbe\x3f\xe9\x16\x9c\xb9\x7c\xa6\xba\x5e\x24\xe5\x64\xa5\x86\x3f\xd9\x90\x2e\xe6\x03\x25\xa5\x44\x9c\x39\x4a\xc3\x8d\xbc\x03\x94\x36\x21\x34\x62\xf3\xd3\xd1\x05\x67\x32\x8e\xc4\x95\xf0\xc4\x42\x72\xf0\xe1\xc6\x52\x47\x73\x13\x2e\x15\x9e\xdd\x2b\x3f\xf7\xec\x53\xf2\xf3\xfb\x9f\x86\x21\x4f\x3d\x0d\x91\x27\x4f\x94\x8d\x9f\x0a\xb3\xee\xdd\x2c\x7f\x7c\xfe\xac\x2b\xa6\x5e\xe4\xf4\x9c\x3b\x7d\xcf\x16\xf9\x5f\x5b\xb6\x80\x7b\xeb\x66\xf0\x3c\xb0\x59\xfe\x06\xdf\xff\xa4\xfc\xe2\x1f\xf6\x43\xe4\xa9\x67\x20\xba\x6f\xbf\xfc\xc7\xc4\x93\x03\x6d\xf8\x56\x5b\xeb\x25\xe7\xc9\xf2\x77\xb6\x81\xb8\x75\xfa\x18\x79\xfb\x54\xec\xda\x2a\x7f\xb5\xed\x01\xf9\x4b\x92\x36\x7f\xeb\x56\xc8\xfd\x2d\xe9\xfc\x29\x38\x4f\xf7\xb8\xd0\x4e\x74\x60\x2d\xba\x31\xd2\xe9\xf7\x7a\x0b\x0a\x2a\xb0\xc9\xe1\x90\x70\xa0\xa6\xa6\x02\x57\xd4\x85\xec\x85\xe5\x1c\x67\xe0\x5e\x8d\x95\xb8\xdd\xc8\xe1\x2d\xa8\xa8\x11\x30\xc2\xaf\xc6\xaa\x7d\xcb\xd0\x66\xf4\x3c\x3a\x4a\xba\xc1\xe3\x0f\xd4\xf2\xa3\xcd\xd0\x4c\x1c\xd3\xd1\x12\x34\x4b\x20\x19\xb8\x5d\x21\x98\x18\x82\xf6\x10\x10\x73\x88\xfa\xaa\x33\xc9\xbf\x27\xfc\xc6\x4c\x16\x79\xf6\xb0\xb6\x52\x6e\x52\xa3\xe2\xca\x02\x95\xe4\x34\x2b\xe6\xcb\x88\x44\x1b\xa4\x06\x3f\x09\x75\x69\x69\xcc\x07\xfe\x94\x67\xf3\xd5\x9a\xa2\xea\xf6\x26\xdb\x68\xfc\xd5\x68\xdb\xe8\xe9\x85\x6b\xf0\x2b\x7e\xf9\x5f\x0b\xe4\xbf\x2c\x58\x00\x13\xdf\xff\x2b\x0c\x23\xee\xfb\xb2\xb3\x71\xde\x60\x1b\xbe\x8d\x37\xdc\xf6\xf5\xd7\xb7\x99\x13\x67\xdb\x06\xe3\xab\x13\xaf\xd8\x06\x93\x87\xeb\x6d\x83\x65\x3b\x1c\x19\x6c\x4b\x9c\xcf\xbe\x8f\x25\xba\x71\x10\xb1\x0b\xbe\x61\xe3\x75\xab\x22\xc3\x7c\xf9\xa5\x5c\x40\xb4\x58\x89\x89\xab\xf3\x3a\x0c\x92\xc4\x39\x8a\x89\xc8\xf4\x3a\xbc\xd5\xc1\x80\xa3\x54\xf4\x59\xad\x22\x31\x85\xac\x3a\xd2\x48\xc4\xd7\xe3\xf3\x2d\x16\x9d\xdf\x60\xd0\x39\x56\x07\x61\x69\x10\x26\x06\xd5\x56\x50\xea\x99\x3e\x41\x8f\x85\x46\xdb\xb3\x16\x88\x30\x2f\xc7\x13\x66\xf3\xb0\x40\xb1\xae\x9d\x7e\x8e\xd8\xd0\x83\xa0\xa2\x9c\x0e\x0f\xfb\x8b\x91\xdb\x85\xac\xaa\xaf\xee\x67\x5b\xba\x94\x73\xce\x67\x0f\xdd\x7e\xa3\x27\xb1\xc1\xd3\x39\x64\xd2\x63\xe7\x08\x47\xe5\x63\x70\x09\xcc\x84\x19\xb0\x4a\x3e\x76\x54\x38\xe7\xb1\x49\x43\x3a\xe9\xaf\x1b\x6e\x7b\x83\xff\xfa\x2f\xaf\xff\xfe\x4f\x39\xf2\x24\x58\xb3\xc6\xb6\xa8\x04\xd0\xeb\x3f\x81\x55\xfe\xe1\xe7\xd7\x7b\x51\xc9\x22\xdb\x1a\x79\x0d\xec\xce\x79\x73\xf7\x6b\x1f\x32\xf9\x79\x66\xef\x27\xfc\xa5\x7c\x07\x9b\x07\x3a\x29\x52\xe3\x45\xd6\x22\x9b\x4d\x67\xd5\xf9\x8b\x8b\x6c\xa7\xc5\xac\x45\x45\x45\xd8\xc8\x15\x15\x71\x46\x63\xfe\x69\x31\x23\xe7\x3a\x2d\xe6\xf2\x80\xe0\x01\x0f\x97\xc3\xba\x9d\x0e\x82\x67\x4e\x0d\x49\x75\x37\x91\xa5\x4c\x90\x52\x4e\xa1\x82\xc2\xe1\xf6\xdb\x69\x04\xa2\xa5\x95\xb3\xd3\x00\xac\xce\xce\x0f\xed\xfe\xe8\xce\xfb\x8f\x5e\x7d\xc3\xb1\x5b\xee\x38\x76\xcd\x89\x97\x9a\xb7\x9d\xbe\x76\xef\xe4\xd9\xe1\x07\x3a\x1f\x5f\xf9\x9f\xbb\x2e\xdd\x08\xba\xfb\x1e\x01\x74\xfd\x7a\x59\x7e\x50\xbe\x77\xc0\x88\x85\x57\xc2\x38\x70\x37\x47\x57\xca\xff\x62\xf2\x33\xdc\xfb\xba\x4e\x12\x16\xd2\x39\x66\x28\x07\x0d\x45\x97\x46\x22\x35\x85\x6d\x98\x6b\xf4\x94\xdb\x73\x6c\x36\x23\x02\x83\xe4\x76\xb8\x9c\x4e\xbd\xde\x05\xc6\x72\xae\x4d\x17\x69\x77\xb8\xeb\x6b\xab\x6c\x46\xbd\xd3\x69\x11\xdd\x55\xa2\x58\xe5\xe6\xa4\x7c\x0f\x0c\x72\xb8\x24\x8c\x25\xba\x70\x26\x44\x7a\xf0\x40\x58\x8d\x6e\xa6\xc3\x4d\x29\xe1\x48\xfb\x4f\x5d\x3e\x98\xee\x56\x55\x29\xba\x03\xcd\xad\xe4\x83\x51\x6d\x85\x5f\xe7\xe4\xfc\x10\xf6\xd0\x3a\x53\xe7\xa8\x8e\xd3\xea\x45\xda\xef\xc4\x83\xa2\x6a\xb4\x02\xdf\x7b\x01\xf7\xd0\x8a\xe3\x5f\x1c\x1b\x0c\x85\x8f\x42\xc1\x10\xf9\xee\x99\xe3\xe5\x83\x63\xbf\x5e\x0b\x02\xde\xd1\xec\xcb\x9d\x3b\x60\x47\x74\xd4\x39\x9d\x43\x4b\x37\x5e\xbf\x72\x71\xb3\x6f\xf0\x94\x3b\x47\x0e\xbf\x7e\x5e\x8b\xfc\xe7\xc8\x6d\xe1\x16\xe1\xfe\x13\xff\xad\xa9\xb1\xe1\xef\x13\x0e\x1b\xf9\x7c\xeb\x2d\xbc\x52\xbe\x2f\xb1\xf2\x8a\xfc\xca\xf5\x35\x43\xbc\x65\x95\x83\xa6\xb4\x2d\x5e\x9a\xf7\xdc\xd2\x9a\xa5\x95\x03\xdd\x75\xc3\x66\x0f\xef\x45\x5e\x27\x8b\xd7\x5c\x41\x0c\xe4\xf5\xdc\x0e\xd2\xf7\xe3\x23\x95\x0e\xb3\xd9\xaa\x17\x9c\x46\x23\x26\xfa\x84\xcb\xf5\x82\x2b\x87\x74\xb6\xc3\x4c\x2e\x87\x90\x63\xc5\x46\xc1\x78\x5a\x4c\x14\xdc\x28\x19\x9d\xa3\x86\x7f\x96\xe5\xaf\x2a\x0c\x85\x6d\x19\x45\xdb\x03\xba\x80\x3d\xec\x61\x11\x19\x6e\x7d\x57\xd7\x89\x63\xe3\xdc\x93\x66\xaf\xda\xe9\x1e\x37\xce\xbd\x73\x3d\x36\x73\x8b\xbd\x09\xbd\x77\xd8\xcf\x77\xea\x60\xf4\x02\x08\x2e\x86\x33\xe8\x00\x5a\x6f\x2f\xea\xec\xfd\x1f\x61\x87\x30\xdc\x56\xa1\x4b\xe0\x0e\xb6\x6b\xc6\x2a\x03\x8d\x7d\xaf\xe4\x96\x27\xfe\x45\xd7\xf8\x3a\x72\x52\x6b\x73\x87\x30\xd8\x51\x0c\x76\x2a\x83\x5d\x21\x64\xc0\x96\xa4\x61\x3b\x7b\x8f\x0b\x4f\x13\xbc\x0c\x5f\x12\xbb\x5d\xa7\xd7\x73\x2b\x12\x47\x50\x6e\xc4\x02\xa6\x88\x69\x8d\xe9\xa8\x89\xe3\x39\xec\x75\xd3\xad\xc1\x9a\x61\x66\x1d\x5b\x27\xdc\xc1\xd2\x8e\x4c\x95\xa9\x42\x49\x65\x17\xd1\x4a\x1f\x8d\xc7\xdb\x10\x44\x60\x0d\x7c\x06\x47\x81\x07\x0e\x9b\x35\xa9\x59\xde\xa3\x58\xfa\x21\x7d\xd3\xeb\x45\xd7\xaf\x49\xbf\x96\xa4\xff\x9d\x9a\x3e\x47\x4d\xdf\xcd\xd2\xeb\x26\x22\x54\x1d\xc9\xe5\xdb\x22\x6d\x93\xda\xba\xdb\x96\xb5\xad\x69\x13\x38\x0c\xd6\x89\x56\xc8\x44\xa4\xbc\x13\x5c\xcd\xbd\xdf\x72\x63\xb8\x97\x1c\x22\x47\x91\x03\x6c\x45\x73\xc5\x59\x78\x04\x32\xa3\x92\x88\xc5\x48\x84\x23\x61\x07\xc1\x24\x58\x2d\x66\x93\xba\xf0\x40\xb3\x38\x00\x72\x3c\x81\xf2\x0a\x62\x1c\x85\xa9\xd1\x8f\xaf\x68\x1b\xda\xb1\x7a\xc3\x86\xd5\x1d\x43\xdb\xb8\x8f\xa1\x6a\xf8\x95\xb7\x8d\x29\x1d\x73\xdb\x95\xc3\x3b\x09\x5e\x5b\xef\x8b\xf8\x28\xbf\x5a\xc1\x2b\x99\xb0\xc9\x6c\xb6\x58\x8d\x48\xc2\x66\x81\xe0\x3d\xd0\xa8\xcc\x9b\x4a\x2e\xfc\x63\x16\x57\x38\xc7\xe3\x26\x76\x74\x00\xde\x4b\x63\xe2\x36\xa7\xf3\x38\x11\xc8\x2e\x2f\x32\x1a\x59\x79\xcd\x82\xc5\x6a\x32\xf7\x53\xde\xf2\x0a\x8a\x54\xd4\x05\x88\x97\xdd\x2c\xac\xd6\xe2\x82\xd5\x27\x2f\x2f\x36\x4b\x66\x93\xc9\x62\x45\x46\x2c\x89\xa4\x1d\x3e\xce\x2a\x6f\x59\x4b\x2b\x45\x4a\x9a\x22\xc7\x63\x0f\xe3\x60\x1a\xd3\x56\x6d\x93\x68\xdb\xd7\x43\xd7\x40\x93\xf6\x15\xb1\x44\x50\x7a\x3c\x76\xb7\xc5\x62\x17\xed\xde\x5c\x64\xcc\x2e\xf7\x49\xda\x5b\x53\x17\x6d\xcb\x63\x39\x7d\xaf\xe9\x83\xd4\x8d\xa6\x6e\xac\x0c\x16\x89\x18\x45\x46\x4c\x8a\xe2\xcd\x35\x79\x2c\x6e\x07\xed\x14\xd2\x27\xb4\x8a\x99\xf5\xb4\xf7\xed\x1b\x4d\xbd\x35\xbd\x94\xba\xd1\xf6\x56\x02\xa7\xef\x11\x26\x65\xe8\x60\x65\xe0\x90\x0f\x0d\x8e\xf8\xc0\x61\x46\xb9\xa2\xd9\x2a\x5a\x79\x3e\xbf\xc0\xe6\x73\xe4\xe6\x70\x28\xc7\xca\x9b\x45\x09\x85\xde\xa0\x45\xf9\xe4\x90\xed\x8d\xcc\xd2\xa8\xf2\x96\x98\x9b\xce\x93\x95\xc9\x06\x9f\xc9\xc5\x2f\xf5\x2d\xd8\xc2\x49\xfc\x99\x27\x29\x1a\xd1\x85\x23\x7a\xbf\xe4\x36\x0b\x2f\x11\x5f\xa2\x1a\x8d\x8e\x94\x97\xea\x0b\xac\x76\x3b\x42\x1e\x3d\x17\xac\xc9\x71\xe5\xb9\x26\xc7\xac\x79\x20\x71\x79\xa6\xe2\xd3\x62\x36\x93\xb5\x42\xc8\x09\xd5\x00\xd1\xfb\x87\xd8\x0c\x49\x45\xff\x69\xe4\xa1\xd2\x6c\x2e\x03\x28\xb6\x32\xd3\x81\x9e\x70\x2b\x9b\x84\x50\x41\x87\x7c\x1c\x1c\x1b\x87\xc4\x8a\xeb\xe4\xe0\x36\x77\x6c\x78\xed\xd2\x3b\xb7\xdf\x70\xf8\xba\x99\x1b\x4a\x78\xfe\xb6\x1b\x97\x5c\x5c\xba\x68\xe2\x69\x4f\x1c\x38\xdf\x71\xf1\x69\xf1\xdb\x67\x2f\x8c\x9d\x7e\xcb\x32\xee\xe1\x87\xe5\x6b\xe4\xef\x6e\x7c\x7a\xc7\x3d\x50\x77\xc7\x59\x53\x56\x7c\xfe\xc3\x54\xff\xed\x01\xf9\x9b\xc4\x9f\x67\x5c\x7c\xbd\xfc\xfd\xba\x4b\xaf\x5f\xcf\xf6\x08\xc3\xc8\x46\x94\xe4\x7b\x42\x07\x12\x88\xa9\xfc\x4e\x64\x23\xcf\xe9\xf5\x02\x16\xb0\x41\xd2\xd3\x09\x08\x3a\x8e\x78\x7b\x8e\x5d\x06\xd8\x64\x80\xd5\x06\x08\x19\xc0\x6a\x80\x5e\x03\x7c\x6a\x80\xe7\x0c\x40\x9e\x6f\x30\xc0\x52\x03\x74\x19\x60\xa2\x01\xda\x0d\x50\x94\x04\x38\xc2\x60\x36\xb0\x87\xe4\xc9\x40\x25\xcd\x9b\xc9\x34\xab\x59\x9a\x76\x86\xb1\x88\xdd\x5b\x93\x48\x37\x25\x91\x16\x1b\x00\x19\x20\x35\xc8\xdb\x67\x11\x43\xf6\x1a\x07\x6a\x5b\x79\xc2\xed\xaa\x35\xa9\xce\xf0\xa9\x22\x1e\x33\x71\x45\xfc\xc0\xbf\xd7\x33\x08\xde\x80\x12\xf8\xa0\xe7\x45\xfc\x6f\x79\xcd\x6c\xfe\xeb\x9e\xdc\x1c\x9e\x4e\x0f\x46\x67\xca\xe3\xc5\x28\xf3\xb1\x06\x47\x8a\xed\xd8\x22\x61\xc9\xe5\xd6\x73\x02\xd7\x15\x13\x6c\xdd\x31\x81\x93\x2c\x76\x8e\x98\xbc\x5d\x31\x13\xdd\x97\x4f\xb1\x5e\xbd\xed\xc1\x8c\x69\x45\x8a\xbd\xaa\xf8\x41\x8a\x45\x4a\x27\x4a\x9c\xb9\x63\x87\xf0\xcf\x47\x1f\x4d\x2c\xd9\x91\xf8\x7a\x87\x3c\x7e\x6c\x9e\x58\x45\x9d\x99\x9f\x3f\xa0\xe1\x28\xb1\xe8\xe7\xbf\xe5\x8d\x55\xc6\x45\x66\xc8\xe3\x85\x36\x52\x86\x1c\x34\x21\x52\x91\x63\x36\x63\x40\x26\x93\xd1\xa6\x37\xea\x3d\x5e\x73\x8e\x25\xa7\x3b\x66\x02\xc4\x19\x6c\x16\xce\x88\x0d\x06\x3c\x27\xa6\x37\xf8\xd2\x93\x5c\xa9\x25\x92\xe1\x8a\xd0\xc0\x43\xa3\x32\xfe\x01\xfe\xc6\xd2\x56\x27\x31\x12\x89\x51\xce\x26\x3b\xd5\xe1\x32\x6e\xae\x0c\x70\x39\x51\xa6\xfe\x09\x9d\xce\x9e\x16\x3c\x24\x71\x94\x9f\xd7\x39\x34\xb0\xea\x2c\x79\x39\xbe\x76\x41\xa2\x5e\xd2\x41\x71\xe2\x8d\x25\x5c\x15\x3e\x7a\x8e\xbc\xfe\xbf\x9c\x8e\x57\xe7\xb0\x9d\x8d\xbb\xf9\x52\x7c\x84\xf0\x66\x4e\xc4\xc0\x21\x9e\xa8\x90\x47\x63\xdc\xe3\x6c\x0e\x92\x12\xe3\xa1\x9b\x1a\x94\x9e\xe8\xc0\x47\x36\x6c\xe8\xed\x4d\xce\xf1\xb7\x89\xba\x04\x4b\x3f\x1d\x7a\xe1\x41\x6e\x1c\x32\xc2\x90\xc8\x97\x12\xc7\x99\xcc\x22\xba\x27\x2e\x8e\x60\x0b\xf4\x90\x19\xb4\x4b\xf9\xb6\x25\x97\xf2\x29\x6b\xf7\x16\x6b\x1f\xad\x60\x0b\xfc\xa6\xb2\x05\x7e\xa7\x48\x99\x5a\x29\xa8\x5d\xfe\x77\xa0\x3f\x0c\xe4\xd7\x81\xef\xb2\xe5\x83\x4a\xe2\xa9\xec\xe9\x31\xb6\x20\xf0\xad\xe4\xca\x42\xe5\x27\x65\x65\x21\xee\xbb\x70\xf0\xad\xe4\xe2\xc0\x65\xc9\xf5\x81\xe4\xa7\x8c\x89\x0a\x5d\x59\xeb\x72\xfa\xac\xf5\x3b\xf9\xb2\x1e\x65\xe9\x66\xbf\xcb\xfb\x90\xba\xfa\x00\x7a\x35\x0b\x0c\x80\xd8\xbe\x3f\xf0\x73\xc4\xa9\x84\xb3\x6f\x8f\xcc\x11\x00\x89\x22\xd6\xe9\xb1\x9e\x78\x66\x3c\x2f\xea\x44\x94\xe2\xdf\x89\x9a\x1b\x85\xc7\x53\x37\x6d\x47\x92\x6c\x7b\x44\xc3\xbf\x4b\x35\x37\x13\x93\x5c\xac\xa9\x86\x5a\xf0\x54\x5d\x50\xa8\x91\x4e\x88\xcf\x08\x8e\x29\x41\x22\xe2\xdb\x49\x10\xc6\x4b\x97\xc8\x1f\x6c\x07\x2b\x60\x38\x30\xdd\xc2\x0d\x99\x94\x28\x12\xf6\xb1\xd8\x6c\x1b\x3a\x28\x5c\xc2\x7d\xa0\xce\xc7\x7e\x3f\x72\x73\x95\x60\xcf\x0b\xf0\xc6\x62\xaa\x0b\xeb\x3d\xe5\x96\x82\x1a\x21\x2f\x60\xe7\x39\xa4\x9f\x44\xea\xe6\xb2\x5a\x40\xb2\xac\xae\x87\xae\x7a\x98\x58\x0f\xed\xf5\x10\xaa\x87\x37\xeb\x61\x53\x3d\x90\x87\x4b\x33\x9f\x17\xd5\xc3\x91\x7a\x78\xae\x1e\x36\xb0\x5f\x95\x9f\x94\xe7\xd6\x7a\x18\xa2\xfc\xa0\x3c\x45\x2c\xb1\x92\x52\x79\xa8\xc0\x91\xe7\xea\x4a\xce\x64\xaf\xcd\xea\xdb\xa1\x8a\x78\x0a\xcd\x9a\x19\x3e\x3c\xb3\xd1\xd3\x76\xa8\xd1\x76\x28\xb9\x9c\x88\xce\xc5\x63\x33\xc0\x03\x25\x5c\x3a\x2c\x46\xc7\x52\xc8\x7b\x59\x09\x9d\x18\xae\x0c\x9b\x80\x3a\x1d\x85\x8d\x4b\x5d\xf2\xd4\xba\xf7\x6f\x19\xf6\x50\xf7\xc6\x27\x9e\xd8\xb8\x74\x7f\xfb\xb0\xad\x67\x6f\x7c\x4c\x7e\x7b\xca\xba\x61\x43\xd7\xc5\xce\x5a\xbd\x26\xf1\xfe\xa0\x75\x33\xbb\x2f\xbb\x78\xe1\xd4\x1b\xf0\x69\x0f\x7e\x0c\xfa\xd5\x57\xfd\x79\xf7\xf6\x8f\xd6\x5e\x7e\xd9\xea\x77\x97\xdc\x70\xe3\xfa\x1b\x37\x5d\x7e\xc9\xfd\xf2\xb7\x37\x6c\xd8\x7c\xd9\xe5\xf7\xac\x67\x7c\x0d\x77\x12\x73\xa3\x9b\x7f\x45\x59\x6f\x89\x05\x81\x10\x08\xd1\xf4\x6c\xbd\xa5\x52\x52\x3a\x3b\x83\x4e\xd8\x87\x3b\x67\xf1\x8b\x7b\x06\xf0\xaf\xf4\xdc\x31\x8b\xa4\xcb\xe9\x95\xf9\x87\x79\xba\xf5\xc4\x0f\x11\x97\xd1\xe0\x44\x06\xe2\x98\xce\x75\xc3\x24\x37\x34\xb9\x47\xb8\xb1\x9b\x0e\x6c\x1b\x2e\xb8\xa4\x63\x33\x7d\x00\xec\xab\x67\xe9\x79\x1d\xc5\x6e\xa0\xe3\xdc\x78\xd1\x01\xf7\xbb\xee\x63\x6e\x6e\xb7\xfa\x5b\x71\xd7\x59\x1d\x93\x94\xdf\x68\x7a\xfe\x98\x1b\x3e\x73\xc3\x1e\x37\x05\xe3\x36\x27\x11\x8c\x9b\xdc\x71\x34\x09\x34\xd5\xbd\xc2\xbd\xd6\x7d\xab\x5b\xd7\xc6\x7e\x1b\x34\x62\x34\xfd\x0d\x23\x77\xb1\xbb\xde\xbd\xcc\xbd\xc6\x7d\x93\x7b\xb7\xfb\x2d\xf7\x67\x6e\xc9\x46\x1e\x4d\x72\x77\xbb\x9f\x27\x5f\xc5\x08\xb9\xd9\xed\x3e\xea\xe6\x8b\xdc\x80\xdc\xa0\xb7\x0a\x46\xba\xa7\x68\x28\x0c\x8c\x72\xcf\xeb\x3a\x2f\x38\x4b\x99\x74\x44\xfa\x2f\xc8\xfa\x35\xa8\x7c\x4f\x4e\x74\x27\xf4\x6b\x6f\xa2\x1d\x55\x08\x6e\x7b\xc0\xae\x86\xfd\x20\x67\xc5\xdb\x57\x5e\xf5\xe7\x0b\x17\x1c\xd8\xbc\xf5\x79\x8c\xd1\xed\x47\xae\x5e\xfb\xc3\xad\x32\xc2\xf8\xd9\x2f\xfe\xfe\x82\x4c\xd7\x8f\xdc\x96\xf8\x08\xdf\x45\xe8\xbb\x02\x8e\x47\x7a\x25\x67\x01\xf1\xb4\x2a\xab\xfc\xa5\x79\xa5\x13\x63\x79\xd4\xcc\x99\x18\x13\x61\x4e\x15\x4c\xae\x82\x11\x55\xd0\x54\x05\xa5\x55\xe0\xaa\x02\xbe\x0a\x8e\x55\xc1\xdf\xab\xe0\xdd\x2a\x78\xa1\x0a\xf6\x54\xc1\xd6\x2a\xb8\xb5\x0a\xd6\x56\xc1\x8a\x2a\x98\x5f\x05\x9d\x99\xf0\xb8\x0a\x16\x91\x04\x5f\xb1\x04\x07\x58\x82\x6d\x9a\x04\x73\xab\x60\x6a\x15\x8c\xaa\x82\x96\xcc\x0c\xbe\x60\xf0\x2f\x57\xc1\xbe\x2a\x78\xb0\x0a\x6e\xaf\x82\x6b\xaa\xe0\x02\x4d\x06\x8d\x55\x50\xa2\x81\x27\xf8\xdf\x4f\xe2\xcf\x82\x9f\xca\xe0\x09\xfe\xf2\x2a\xc8\xa9\x02\xb1\x0a\xda\x7e\x4c\x26\x78\x59\x85\x8b\x9c\xad\x62\x56\x4a\x42\x30\x3b\x34\x25\x51\x00\x95\xaa\xc2\x4d\x55\xb0\xa6\x0a\x96\x25\x8b\x1e\xa9\x82\xfa\xfe\x8a\xfe\x3c\xa9\xfa\xee\x2a\xd8\x5c\x95\x4e\xd0\x5d\x05\x93\x58\x82\xf4\x82\xe9\x0c\x81\xdb\xf5\x8b\x4b\x25\x67\xf6\x59\x5f\x9f\xbd\x69\xc2\x49\x13\xa8\x43\x84\xa1\xec\x1d\x73\x6c\xce\xa1\x98\xb2\xba\xdb\x0a\x01\x46\x3a\x4e\x17\xe6\xd8\x14\x95\x8a\x66\xba\xe5\x1f\x1b\x2f\x7d\xca\xa2\x3b\x6b\xf3\xa8\xdc\x98\xd5\x61\x73\x8f\x6a\x6b\x1e\xc5\xeb\x24\x71\xde\x3d\xa3\x0a\x26\x9b\x78\x37\xef\x1a\x39\xb0\x79\x14\x1c\x07\x13\xd8\x17\x3f\x73\x91\xcb\x24\x0d\x8b\x8e\xba\xef\xd2\xc4\x57\x63\xe4\x67\xe5\x2f\xcf\xfd\xc3\x79\x1e\x83\xde\xdc\xe5\x19\x79\xdf\x2a\xe2\xcb\xd5\x80\x9f\x1f\xc0\x47\x6d\x15\x68\x36\xb1\x5d\x3f\xb5\xe9\xe8\x67\x6f\x84\xe9\x89\x4e\x74\x03\x6f\xe1\x0f\x10\x1e\xbe\x20\x32\x06\x39\x81\x77\x58\x05\xbd\xc5\x28\x19\x4c\xd8\x6e\xc2\x3a\x93\xce\xe5\xe6\x6d\x76\xdb\xa3\xb1\xe9\xd2\x62\x09\x23\xc9\x26\x61\x23\x27\x49\x66\xbd\xc9\x6c\x7a\x34\x26\x10\x0d\x68\xb6\x83\x7d\x25\xba\x1a\xe1\x10\xdd\x28\xcb\x6a\xdf\x64\xc7\x76\x14\x9a\x19\x0e\xd1\x90\xb1\xed\x4f\xcb\x1b\x93\x53\x00\xe9\xc4\xbd\x0c\xb3\x49\xdd\x41\x22\xec\xf6\x73\x6c\xe2\x97\x93\x0d\x77\x91\x8b\xfb\xf7\x93\xef\xcb\x2f\x3f\x05\xc7\x12\xdb\xf7\xdf\xb5\xff\x15\x08\x3e\x25\xfb\xf0\x98\x27\xf9\x03\xf2\x4f\x1b\xe4\x1f\x6f\x92\x7f\x06\xdd\x4d\x60\xd8\x00\x7a\x65\x0c\x6f\x3e\xe8\xf8\x42\xbe\x43\x5d\x73\x39\x34\x52\x62\x20\xde\x93\x40\xf4\x89\xc9\x6c\x30\x1a\x39\xb1\x5b\xb7\x4c\x87\xad\xba\x22\x5d\x88\xee\xf1\x8c\x38\xd0\x73\x54\x22\x1f\x22\x25\x3c\xa4\xd1\x4c\x8a\xdf\x40\x6d\x98\xe4\xc5\x17\x9e\xe8\xe0\xf6\x2b\x17\xdc\xbe\x61\x03\x7e\x6c\xc3\x06\xf9\x77\x1b\x36\x10\xdb\xb9\x93\xd8\xce\x16\xfe\x23\xb6\xde\x8c\xe4\x28\xf1\x48\x8f\x45\x11\x19\x4d\x7a\xdd\xa3\x31\x3d\x2f\xee\x8a\xf3\x78\x57\x1c\x50\x37\x7f\x13\x8f\xd7\xf0\xc0\xa3\xdc\xd0\xcc\xe5\xca\x78\x51\x28\x98\x91\xa3\x93\xe4\x25\x41\x01\xf6\x37\x77\x72\xfb\x13\x80\x7b\x89\x01\xf5\xe8\x74\x78\x77\x83\x7c\xa3\xbc\x7e\x43\xc7\x4d\x37\x21\x35\x3f\x1b\xc9\x8f\x23\xf9\x8d\x88\x94\xe9\x31\x2f\x82\x81\x37\x18\x4d\x06\x49\x14\xf5\xbb\xe2\x22\xbf\x2b\x6e\x23\xd6\x80\xf8\x99\x88\xed\x9c\x88\xb9\x47\x63\x98\x98\x0c\x24\x57\xd2\xec\xcb\x83\x19\xf3\x7b\x95\xd8\x1b\x9b\xe6\x4e\xcc\x42\x70\xf3\x16\x92\x23\x87\x12\x88\xdb\x7f\xd3\x4d\x37\x75\x6c\x80\xf3\xe1\xbc\x0d\x72\xcd\x74\x9a\xef\x5d\x24\xdf\x30\x7f\x05\xe2\x91\x44\x57\xe7\x09\x48\xe4\x11\xc9\x56\xcf\x14\x44\x63\x48\x6b\x03\x87\xed\x12\xd8\xcb\xfc\xe4\xfd\x2e\x38\x04\x87\x4e\xec\xc3\xc7\xe5\xab\xe4\xab\xf0\x2a\x2c\x26\x8e\x27\xae\x9e\x8c\x45\x78\x58\x26\x3e\x34\x9a\x8f\x0e\xf2\x45\xf8\x28\xd1\x37\xbe\x88\x89\xd8\x23\x48\xd4\x09\xc4\x92\x14\x78\x14\x4a\x35\x0d\xeb\x08\x22\x59\xf9\xa2\x13\xef\xdd\x88\x8f\xde\x24\x2f\xc1\x65\x84\x5e\x71\x49\xe2\x6e\xee\x1d\xf1\x61\xe4\xa6\xfb\x51\x13\x1d\xa4\x27\x9e\xb5\x51\xa0\x0b\xfb\x0e\x69\xb4\x55\x20\x39\x2a\x43\xe7\x1f\x94\xd3\x70\x9a\x4e\x74\xe3\xbd\xb7\x6c\xbf\xbc\x7d\x5c\xb8\xac\xd0\x6c\x2b\xf7\xdb\x4a\x25\x31\x71\xb7\xae\xf3\xc0\x8f\xed\xf5\x95\x4d\x06\x7d\x75\x45\x45\x60\x91\xa2\x0f\x85\xc4\xdd\x78\x2f\xc9\xc3\x45\xf3\x70\x61\x3d\x76\xe7\x90\x3c\x50\x56\x1e\x61\x7b\x7a\x90\xc3\x93\xa3\x4c\x71\xc0\x25\xb7\x3c\xb0\x76\xd0\x69\x8d\xa5\xfe\x3c\x43\x51\x91\xad\xc0\x23\x3e\xfc\xd3\xf6\x17\xff\x67\x48\xa8\xa2\xd9\xc6\x57\x95\x85\x57\xb3\x35\x84\x3f\xe2\x32\x61\x2f\xde\x47\xfa\xd2\xbb\x97\x13\x10\x31\xaf\xf7\x03\x7e\x2c\x06\x27\xa8\xb8\x50\x16\xc0\x72\xc4\x97\x30\x08\xcf\xe1\xb2\x8d\x1b\x59\x99\xf0\xfa\xc4\x2d\x5c\xa1\xae\x83\xd9\xde\x12\xa6\x6b\x9b\x39\x19\x1d\xa7\x2b\x66\x93\x46\x61\xd8\x1e\xc0\xeb\x37\x6e\xd4\x75\xfc\x38\x4e\x81\x67\x79\x08\xa8\x84\xda\xea\x48\x04\x9d\x20\x93\x0e\xa6\x19\xa1\x13\xca\xb0\x06\xc9\x4b\x8d\x1f\xd0\xfd\x07\x48\x6a\xae\x32\xb1\x68\x23\xde\xb7\xb1\xe7\x5c\xa5\x9c\x34\xcf\x24\x0e\x01\x63\x1d\x88\xbc\x8c\x05\x86\x03\x67\xe3\xe0\xd8\x46\x03\x06\xae\x72\x23\x29\xf4\xf1\x8f\xf9\x9b\xd5\x72\xd3\xba\xea\xa8\x8f\x59\xf4\x04\x31\x2d\x44\x5e\xc7\x10\xec\xa1\x08\x8e\xb3\x99\x26\xa9\x42\x30\x13\x83\x54\x01\xdf\x71\xe2\x2f\xba\x8e\x9e\x73\x37\xaa\x6d\xc5\xea\xcd\xca\x80\xe9\xbe\x0a\x22\x77\xfc\x54\x65\x08\xdb\x0d\xf8\x0e\x5a\x06\xfe\xe6\xe3\x1f\xa7\xda\x8e\x95\x41\x87\xaa\x08\x05\x03\x3d\x4e\x8b\x97\x74\x72\x56\x41\xd2\x88\xd2\xa5\x61\x4d\x8a\xef\x20\xad\xc2\x0a\xa4\x6d\x17\x15\x9f\x85\xae\xd2\xe5\x25\xa4\x17\x65\x52\x2e\x5d\x46\xb9\xb4\xf8\x94\xa2\x05\x58\xe1\x94\xd2\xfd\x38\x4e\x6d\x23\x8a\x8f\xf5\x95\x0e\xd5\x44\xac\xbc\x4e\x87\x38\x8e\x21\xa4\xdb\x57\x68\x28\x83\x06\x55\x93\x3b\x4e\x26\x69\x84\xb5\xb9\xf0\x1c\xed\x36\x42\x2a\x3d\xe7\x12\x94\x2a\x7d\xb1\xf2\x11\x7c\xa4\xdf\x90\x4e\x47\xf0\x71\xc7\x69\xd5\x4f\x8d\xcf\x4e\x6b\xcd\xda\xef\x0e\x56\x46\xda\x09\x6a\xf9\x08\x3e\x23\x6a\x8d\xb8\x04\xbd\x1e\x1b\x8d\x04\xa5\x19\x99\x0c\xa4\xce\x7a\x23\x36\x12\xa4\x8f\xc7\x04\x5a\x6d\x35\xf6\xab\xc1\x1b\xd6\xa2\xf6\xab\x2d\xc0\x9a\x34\x99\x03\x2b\x35\x5d\xc3\xfb\x23\x2c\x17\xf6\x72\x8b\x99\x1c\xaf\x23\x54\x4b\x8b\xcd\xf3\x7a\x81\x67\xfd\x24\x24\x92\xa5\xef\x49\x8e\xca\x41\x2a\xfa\x44\xdb\x02\x14\x9e\x39\x1e\x25\x7c\xf3\xe1\xc6\x8d\xf2\x9d\x0a\xef\x60\xf8\x90\xf4\xd7\x3b\x3a\x45\x3f\x14\x47\x2c\x80\x88\xa4\xe1\xf5\x92\x8e\x23\x2d\x4c\xba\xbe\xb1\x5d\x2b\xc5\x28\x1f\xb1\x8b\xa0\x80\x85\x0a\x3f\x49\x7b\xd3\x3c\x45\xca\x27\xa1\xb6\x88\x95\x48\x7b\x23\xe9\x7b\x84\x0c\x46\x49\xe6\x75\xac\x88\x7c\x22\xc9\x61\x3d\xda\xf9\xbd\xa0\x9d\xd5\x4b\xd7\xbd\x6a\xd8\x8d\xb5\x04\xb7\x78\xe3\x07\x1b\x4f\x94\x50\xd9\xf3\xa1\x4a\x0b\x12\xaa\x8d\x98\x45\x62\x8d\x4b\x82\x01\x8c\x58\x94\x44\x82\x78\x6f\x4c\x3a\xc1\xeb\x65\x3a\xbb\x9a\x29\x52\x08\xa7\xcc\x51\x45\x5a\xd2\x3f\x61\xaf\x5c\x40\xd0\x31\x36\xa6\xed\x2b\x04\xd4\x36\x60\x65\x17\x48\x2f\x0e\x8a\x58\xb0\x5e\x6f\xe6\x90\x24\x22\x91\x38\xe1\x12\x41\xfd\x44\x4c\x4c\x18\xd3\x12\x42\x2d\x7f\xb8\x5d\x3b\x62\x93\x16\x15\xea\xfb\x87\xdc\xe1\x13\x7b\x49\x2b\xe1\x15\x24\x4b\x52\x89\xe3\x4f\xf1\x4b\x95\x7a\x28\x3c\x92\x6c\x2b\xb6\xd7\xa2\xc1\xc8\x93\xc6\xd2\xcb\x22\xc7\xda\x4a\xec\xc1\x92\xc2\x2d\x09\x4d\x5b\x81\x76\x10\x90\x74\x6a\xb3\xb2\x7f\x89\x81\x36\x13\x11\x2d\xb0\x9c\xd4\xec\x78\x15\xf7\x49\x8a\x0f\xdf\x61\x6d\x55\x17\xb1\x49\xa2\x80\x45\x6c\x44\x06\xd2\x40\x62\x5f\xc6\xc9\x68\x2c\x2e\xb9\x29\x0a\x91\x57\x87\x69\x5b\x29\x12\x4b\x21\x44\xac\xe0\x4d\xb7\x95\xde\x48\x17\xcd\x9b\xcc\xbc\x24\x11\x6d\xcb\xda\xca\x90\xc0\x3a\x99\xd1\xe5\x63\x31\x41\xd3\x56\x10\x4e\xcd\xd0\x0c\xb3\x15\x33\x76\x62\x48\xd0\x37\x3f\xf7\xce\xc6\x13\x7b\xf1\x8a\x8d\x72\x01\x5e\xc1\x2d\x3e\x5e\x25\x8c\x62\xf5\xd8\xc8\xe4\x13\xa5\x7b\x42\x9f\x12\xe1\x2f\x33\xa1\x2b\x49\x22\x6d\xa5\xd7\x1b\x59\xc7\x90\x96\x4a\x24\x25\x55\x4f\x4a\x52\x05\x33\x5b\x4a\x91\x56\xee\xa4\xfc\xa4\x64\x45\x65\xe8\x89\x12\x52\x39\x45\xa7\x7d\xa8\xca\x04\x09\x55\x47\x8c\x7a\x81\xd8\x47\x92\x81\x27\x37\x04\xf1\xbe\x18\xd6\x9f\x40\xe2\x71\x36\x69\x3f\x98\x41\x54\x0a\xcf\x92\x7b\x2e\xba\x11\x3e\x3f\x51\xba\xf1\x03\x26\x07\x85\x00\x91\x84\x84\xa6\xd4\x72\x27\x69\x4a\xd0\x1b\x05\x23\xb1\xb9\x78\xde\xac\x37\xb2\x12\xeb\x7b\x58\xd1\xf7\x92\x4e\x16\x15\x56\xcb\x28\x7c\x46\x36\xea\xfb\x87\x1b\xb9\x71\x27\x4a\x09\xe7\xc1\xe7\x89\x1b\x74\x1d\xc7\x9f\xda\x28\x7c\x40\xea\xc1\xfa\x1b\x96\x33\xb9\xcb\x68\x4a\xc4\x98\xb5\x13\xa1\x29\xdd\xf1\xff\x3d\x4d\x85\x15\x9a\x22\xb2\x88\xd1\x14\xf7\xc9\xf1\xaa\xa4\x6e\x66\xb2\x82\xd1\x14\x27\x12\x75\x83\x8c\x60\xd0\xf3\xc7\x49\x7e\x90\x96\xee\x7d\x69\x0a\x14\xac\xb4\xad\xde\x21\xe5\xff\x5c\x21\x2b\x95\xa8\x98\x6c\x63\x78\xd5\xb6\x32\x12\x13\x54\x4f\x68\x4a\x02\x48\xd1\x54\x0f\x2f\x1e\x4f\xe6\x91\x38\x29\x4d\xb1\x6c\xfc\x61\x85\xa6\x4e\x94\x72\xe3\x36\xca\xba\x8d\x89\x1b\xe0\x73\x52\x0f\x61\x54\x8f\xc6\x5e\x50\x65\xf6\xd0\x88\x4d\xc4\x74\x93\x02\x42\xc1\x84\xeb\x8d\xf2\xa9\xc8\x2a\xab\xbd\x32\x48\x2b\xa5\x0c\x55\x85\xc8\xa8\x8b\x72\x7b\x4a\xbe\x30\x9d\x63\x44\xe1\x88\xd3\x40\x44\x96\xa8\x33\xea\x4c\xbc\x59\x67\x94\x91\x3e\x5b\x65\x87\xb5\x8d\xa7\xd5\xb7\x54\xf4\x32\x62\x23\x12\x85\x4a\x70\x55\xef\x32\x09\x4c\x6c\xfd\x54\x3e\x44\x78\x21\x2b\x1a\x1d\xb1\x5b\x44\xd1\x8e\xc0\xa4\xd7\x5b\x25\x90\x6c\x76\x93\x95\xd5\xc9\xd4\xc3\x44\x72\x44\x22\x32\xd9\x80\x8f\x4b\xc0\x84\x66\x38\x39\x9b\x23\x3d\xe0\xae\xe6\x1e\xb0\x87\x9d\x8a\x7a\x52\xac\x90\xc5\x1b\x37\x7e\xc0\xa4\x1a\x23\xc3\xc4\x2d\xd2\x5e\x42\x88\x27\x4a\xa4\xbd\x8c\x14\x35\x36\x00\x6d\x5f\x07\x6d\x5f\x22\x1c\xcc\x84\x18\x89\x4e\xd4\x92\xa3\xb1\x0f\x39\x66\xb7\x6f\x9a\x20\x03\x29\x92\x4c\xd2\xe4\x8f\xe3\x88\xa4\x53\xe5\x91\xda\xb6\x0d\x11\x07\x91\x73\x06\xa3\x68\x24\xfa\xd7\x28\xca\xfa\x3e\x56\x47\x46\xd3\x6a\x2c\x0f\xda\xb2\x06\x42\x97\x4c\xab\xa5\x2c\x10\x21\x40\x1b\x96\x4b\xe5\xa1\xb4\xeb\xa8\x88\x5d\x24\x55\x32\x62\xce\xc8\xd9\xec\x3a\xb3\xd9\x66\x35\x31\x22\xb5\x26\x38\xa3\x9c\xd4\x45\x3d\x88\x67\x42\xa3\x3f\x4a\xd5\xea\x52\xea\xd2\x29\x42\x30\xca\xd4\x32\xa5\xd6\x8d\x4c\x12\x2a\xca\x95\x10\xad\x2a\x0b\xb1\x62\x6b\x10\xd9\x4b\xeb\x1a\x61\xd6\x90\xc9\x6c\xe4\x38\xba\x0f\xad\x49\xd2\x2b\x5d\x2a\xf5\x68\x6d\xa3\x44\x92\x1d\x35\x06\x41\x96\x85\xa4\x5a\x06\x84\x6a\x13\x8b\x84\xe7\x48\xe3\x92\xae\xe4\x3e\xa1\xed\x90\x61\x7f\x19\x51\x53\xc4\xa9\x37\xf2\x94\x6e\x39\xd2\xbc\xa2\x41\xd6\xf7\xb1\xc1\x54\xbe\xb7\x67\x68\x93\x94\xf2\x25\xb9\x28\xda\x57\xb5\xc6\x54\xdb\x86\x4b\xd5\x8b\xf2\xbf\x15\x8d\x89\x38\xcc\x7a\xbd\x9d\x88\x61\x11\x8b\x36\xbb\x85\xe3\x6c\x56\x0b\x13\xc5\xd6\x1e\x89\xe3\x39\x76\x2b\xf2\x09\xa3\x4a\xb7\xc9\x15\x2e\xda\x16\x4e\x51\x2e\x69\xd8\xb0\xc2\x3b\xc4\xa5\x23\x94\x4b\x1b\x56\x21\x5e\xbc\xe2\x78\x94\xf4\xeb\x27\xb4\xbe\xc2\x07\xa4\xb6\xaa\x8d\xa5\xd2\x12\x69\x5f\x9d\xd1\x68\x26\x16\xa2\xc9\x8c\xf4\xfa\x74\xfb\x26\xb4\xb6\x62\x4f\x76\xfb\x3a\xda\x34\x56\x17\xe3\x17\xd6\xbe\xcc\xac\x53\x8d\x2f\xee\x13\xc2\x27\xaa\x01\x96\xb6\x47\x59\xfb\x2a\x75\x36\x51\xf2\xd5\x71\xc7\xa5\x3e\x36\x69\xbf\xed\xab\xd6\x97\xe4\xc2\x04\x2b\x7c\x9e\x12\xad\xcc\x4d\xa0\xed\xab\xd1\x45\xac\x7d\x79\xab\xd5\x4e\x6c\x53\xc1\x28\xd8\xec\x92\xc9\x64\x33\x9b\x58\xa3\x9a\x13\x44\xf1\x49\x8a\xd6\x33\xf4\xa4\xb5\xde\x49\xdb\x37\xa5\x9b\x9a\xfd\xb4\x9a\x4c\x36\x25\x6e\x50\xa9\x58\x2e\x10\x9e\x63\x82\x90\x5f\x4a\x88\x98\x08\xe2\x8d\x48\x63\x2f\x3b\x51\x67\x24\xcf\x2c\xd9\x88\xfc\x75\x3a\x5d\x6e\xa3\xd5\xea\x26\x12\xc2\xe5\x20\x12\xc2\xc4\x33\xeb\xe1\x89\x98\x24\xf4\xd8\x14\x12\x7b\x3c\x66\xa6\xb4\x1c\xce\x58\xe2\xd4\x9e\x49\xd2\xe1\x6c\x99\x91\x12\xcd\x29\xd9\x91\x12\xd0\xaa\x0c\x51\xa5\x34\x33\x99\x32\xca\x36\x26\x92\xeb\x90\x24\xab\x89\x38\x55\x4e\xbd\x49\xef\xe2\xdd\x66\x17\xb2\x91\x1e\x31\x5b\xcc\xac\x68\x0e\x6c\x39\x41\x85\x37\x6d\xa0\x70\xdf\xae\x09\x6b\xd9\x3c\xcd\x01\xaa\x1a\x4c\xca\xf0\x0f\x08\x39\xd2\x3e\x53\xe5\xb8\xd2\x69\xac\xef\xd8\x3a\xe8\x54\x79\x68\xbf\xd1\x03\x73\xe6\x44\xf2\x78\x8b\x25\xd7\x65\x34\x7a\xf4\xd8\x6a\x15\x4c\x7a\x93\x37\xd7\x2d\x49\x5e\xc1\x9d\xe3\xa6\xe4\x69\x8c\xe1\x9c\x1e\xe4\x38\x6e\x4d\x76\xa3\xc9\x90\xb0\xeb\xb4\x6c\xa2\xde\x68\x3a\x33\x35\xb5\x4a\x53\x5c\x4e\xcb\x38\x61\x55\x3a\xd1\xae\xfd\x40\xc3\x40\x6a\x37\xb3\x2e\x3e\xfe\x94\xc2\x48\x4c\x5e\xb1\xd8\x19\xc2\xe7\x08\x8f\x30\x99\xe9\xd8\xc7\xf6\xbb\x3a\x0e\x28\xd4\x9e\xda\xf0\xca\xee\x17\x1e\x39\x3e\x4d\x78\x04\x9f\xc3\x7f\xa4\xc0\x93\xba\x92\x6f\x69\x78\xca\xdd\xa1\x3e\xf0\x89\x5b\xf8\xbf\xa6\xe1\x19\x7e\xe7\x13\x2a\x7e\x39\xbd\x47\x96\x36\x81\xb4\x57\x85\xc7\xef\xf7\x0b\xcf\x8e\x28\x20\xf0\xf8\xfd\x44\x35\xb9\x14\x78\xfc\x9e\x06\x3f\xf0\x48\xe8\x0b\x4f\x70\xa7\xe0\xab\xd1\x82\xc4\xff\x08\x8f\x88\x0f\xa8\x71\x36\x2b\xa1\x21\x0f\xf2\xa1\x22\x14\x48\xad\x20\x6d\x45\x83\x50\x3b\x1a\x8e\x46\xa3\x71\x68\x22\x9a\x82\xce\x40\x71\xd4\x85\xce\x42\x0b\xd0\x12\xb4\x14\x9d\x8f\x2e\x44\xab\xd0\x6a\x74\x15\xba\x16\xad\x43\x1b\xd0\x2d\xe8\x0e\x74\x0f\xda\x84\x1e\x40\xbf\x43\xc8\x19\x76\x07\xca\xd4\x4b\xd0\xdc\xeb\x7e\xc5\x73\xcf\xff\x01\x3c\x9c\xe2\xde\xde\xcf\xb5\x60\xe1\x42\xb8\x9f\x5c\x9b\x17\x2c\x48\x6c\x24\x9f\x9b\x94\xeb\xcd\x05\x0b\xe4\xee\x85\x0b\xe5\x39\x0b\x17\xf2\x66\xf2\x39\x5b\xb9\xde\x4c\x43\xbf\xd9\xef\xd3\x93\xe0\x78\x33\xfd\xf4\xc4\x0b\xe9\xfb\x9e\xff\xa4\x53\xd2\xcf\xf4\x4b\x28\x99\x43\x5f\xb3\xbb\xd3\xaf\xb3\xfa\xde\xcf\xa6\xaf\x39\xb3\xe8\x6b\x0e\xbb\x57\x1e\xeb\xbe\x63\x89\x21\xc0\xbe\xc9\x9f\xce\x91\x3f\xed\x96\x3f\x26\xff\xb3\xe5\x4f\x66\xeb\xbe\xef\x46\x53\x09\x6d\xfd\xdf\xeb\xfb\x47\xd0\x2e\xf4\x38\x7a\x02\x3d\x8d\x9e\x43\x2f\xa2\x57\x10\x3d\x9b\xfb\xcf\xe8\x03\xf4\x11\xfa\x14\x7d\x8e\xbe\x46\xdf\xa0\x23\xe8\x3f\xe8\xbf\xc4\x29\xed\x05\x0e\x74\x60\x04\x2b\x38\xc1\x03\x3e\x28\x82\x00\x54\x40\x10\x42\x10\x86\x56\x18\x04\xed\x30\x1c\x46\xc3\x38\x98\xa8\xd0\x53\x6b\x3f\x97\xf0\xff\xc3\xf3\xb2\xac\x67\x49\x5a\xac\xe8\xe7\xd2\x9d\x04\x8f\xe7\x7f\x09\x0f\xff\xcb\xe7\x4e\x15\x97\xe7\x17\x3e\xed\x2a\xec\x02\x46\x94\xe4\xff\x2d\xf6\x4f\x6e\x7a\x6e\x20\x44\xad\xfc\x2b\x4f\x17\x2c\x38\x31\xfd\xff\x00\x0a\xee\xd7\xc2\xbc\xb0\x60\x01\xf7\xdb\x4c\x20\xf2\xbf\xa0\x0f\xb2\x05\xbf\x02\xa6\xe7\x3f\xbf\xa6\x0c\x4a\xd2\x05\x27\x7b\xa7\x9f\x2a\x97\xcd\xe9\xc3\x6b\xdd\x27\xe1\xbb\x93\x3e\x9f\x9d\x7e\x29\xfc\x38\x4b\xc3\x95\xb3\x35\xbc\x99\xc1\xa1\x73\xb4\x7c\xda\x9d\xe4\xd6\xd9\x2a\x72\x72\x11\x64\xf4\x2b\x01\x27\x40\x88\x70\x23\xd5\x21\xef\x11\xbe\x1d\x83\x26\xa0\xd3\xd1\x34\x14\x43\x33\xd1\x6c\x34\x0f\x2d\x42\xe7\xa0\xe5\x68\x25\xba\x18\x5d\x86\xae\x40\x57\xa3\xdf\xa0\xf5\x68\x23\xba\x0d\xdd\x85\xee\x43\x5b\xd0\x6f\xd1\x43\xe8\x51\xf4\x7b\xb4\x17\x3d\x89\x9e\x41\x7f\x44\x2f\xa1\xd7\xd0\x21\xf4\x36\x7a\x0f\x7d\x88\x3e\x46\x7f\x43\x5f\xa2\x7f\xa2\xef\xd0\xbf\xd1\xff\xa0\x9f\x51\x02\x00\x04\x90\xc0\x0c\x76\x70\x43\x2e\x14\xd0\x49\x37\x50\x05\xb5\xd0\x00\xcd\xd0\x06\x43\x20\x0a\x23\x61\x0c\x4c\x80\xd3\x89\xd2\x21\xc6\x41\x73\xa0\x9f\x2b\xec\x3e\xd9\x15\x70\x13\x2f\xa2\xef\x05\x59\x80\x1e\xf2\xac\x42\x73\xe9\xb2\x7e\x17\xc8\xb3\x56\xed\x77\x72\xf9\xc9\xa5\x6b\x0e\xb8\xcb\xc8\xa7\x93\x7c\x06\x34\x57\x76\xfa\x5f\xfc\x3d\x2b\x7f\xc8\xfe\x9e\x55\xce\x64\x7a\x9d\x5a\x2e\x5a\x1e\x0f\xc1\xeb\xc9\xc2\xef\xcc\xfe\xae\xa6\x4f\x7e\x0a\xef\x1d\x0f\x2e\x4e\xbf\x96\xd0\x3f\xfa\x4a\x7e\x26\x5f\xc7\x6f\x4b\x3f\x7a\x9f\xfc\x2f\x5e\xfc\x1e\xf9\x57\x9f\x25\xfe\xb5\x58\xfd\xf1\xc4\xc3\x4b\xa0\x7d\xc9\x7b\x4b\xe0\x91\x25\x69\x34\x1a\x5c\x99\xdf\x53\x88\x70\x0e\xfb\xf2\x1e\xfb\xc7\xdf\x50\x88\x54\x06\x4b\x28\x6e\xb9\x93\xfc\xf2\x5e\x32\x75\xea\x93\xc2\x2c\x61\x89\x12\xb7\x40\xc9\x6c\xfa\x1f\xe8\x06\xff\x1c\xf6\x9f\xc1\x3d\x7f\x4c\x29\x25\xf2\x3f\x8b\xbc\x8b\x8b\x93\x3f\x3d\x9f\xcd\x90\xcf\x27\x6f\x5e\xd4\xf2\x49\x1f\x7e\x4b\x3f\x4a\x41\x89\x87\x92\x3c\x96\xe4\x74\x92\xab\x9a\xc5\xec\x14\x6a\x05\xed\x1f\x53\xc8\x14\x44\x69\x04\x2c\xb1\x32\x67\x6a\x15\x5a\xc9\x4f\xe7\x95\x3d\x51\x39\xcc\x0b\x1c\x3b\x73\x47\x3d\x75\x81\x58\x58\xab\xb8\x4f\x4f\xf8\xf9\xa9\x27\xfc\x74\xed\x2e\x31\x88\xdf\xe4\x5f\x63\x3a\xb6\x30\x62\xd2\x01\x75\x3e\x25\xe2\x82\x92\x54\xa1\x43\x1f\x1f\xca\xd8\x86\xd6\xee\x77\xda\xfd\x76\x91\x7f\xad\xa7\x75\x3c\xdf\x40\x3f\xf8\xcb\x7a\xde\xe4\xe9\x3e\x5c\xe7\xc0\x6a\xbc\x88\x5b\xa5\xe6\x29\xf0\x80\x93\x53\x47\x55\x2b\x70\x91\xcc\xc3\x09\x58\x4d\x5c\x2e\x36\x0f\x30\x0d\xcf\xf2\x15\xe8\xf0\x21\x96\xf4\x3a\x10\x71\x76\xbe\xa0\xee\x04\xaa\xa0\x18\x2f\xdf\x4b\xb1\xc8\x93\x60\x8e\x7c\xbf\x52\x5f\xf2\xd2\x23\xbc\x50\x39\x63\x08\x09\x3c\x07\xe9\xfa\x92\x74\x7e\x3d\xfa\x89\xfc\x9c\xb8\x93\xc6\x24\x49\x12\x71\x3c\xbf\x93\x94\xc0\xbe\x17\x61\x8e\x4e\x33\x4b\xc1\xfa\x25\xf2\x3b\x3e\x13\x77\xf2\x3b\x7b\x26\x13\xd8\x8d\xbd\x5f\x8a\xd3\xf9\x1d\x0a\x2c\x70\xea\xd9\x45\x0a\xac\x84\x61\x23\x6b\x80\x1d\x89\xfb\x13\xf7\x28\xf1\xce\xfb\x09\xfc\x78\xfe\x16\x06\x8f\x51\x26\x6e\x09\x8b\xe3\x13\x0f\x27\xb6\xf3\xb7\xf4\x4c\x26\xd9\x33\x78\x2d\xfe\x6c\x78\x22\xd8\xc4\xe9\x14\x7d\x4f\x1b\x9e\x47\x20\xe8\x01\x26\xdf\x0b\x9b\x89\xcf\x22\xa1\xb2\x88\x4d\x2f\x0a\x3a\x2c\x09\x58\x30\x18\x45\x9e\x8e\x49\x87\xb4\x23\x0a\x6c\xef\x24\x7f\x40\x82\xb0\xc4\xe3\xc0\x64\xb9\x15\x5e\x9b\x0c\x07\x65\x8b\x7c\x3f\xcc\x81\x6e\xfc\x26\x7e\x3b\xd1\x80\x9b\x13\x07\x13\x2f\xe0\xa1\x04\xf7\xef\xd0\x56\xbe\x8e\xaf\x62\x6b\x9a\x48\x5f\xd8\x90\x57\x8f\xf4\xc5\x7e\x97\x29\x9f\x27\x7d\x71\x38\x83\x06\x92\x13\x50\x5c\x74\xf6\x50\x1d\xb4\xba\xe8\x84\x21\x76\x7c\x27\xf9\x6e\x81\xdf\x5d\xf4\xf6\xc5\x97\xbc\x73\xf1\xc5\x6f\xaf\xba\xe4\xad\x8b\x3a\xe7\xfc\xee\xac\x39\x0f\xcd\x9d\xf3\xc8\x9c\xd9\x0f\xcd\xc1\x73\xe9\xf3\x3f\x93\x9f\x2e\xba\xe8\xad\x4b\xe6\x3c\x34\xbb\xfb\xe1\x39\xe4\x97\x39\x0f\xb1\x6d\xc0\xd1\x1c\xd4\xc9\x77\xf1\x93\x09\x35\x58\xd9\xba\x8f\x0a\x62\xdf\xb5\x12\xdb\x6e\x34\xb1\xeb\xce\x20\x36\xdd\x02\x62\xcf\x5d\x48\x6c\xb9\x3f\x45\x96\x4c\x5a\xb8\x70\xea\xd9\x03\x2e\xba\x68\xf0\xa5\x95\xcb\x96\xd5\xac\x28\xee\xee\x2e\x9d\xab\xef\xe8\x30\x8d\x47\x91\x08\x3f\xc2\x56\x5f\xef\x6a\x3a\x73\x46\xbe\xd7\xdb\x34\x62\xfc\xdc\x15\x97\x9e\x3d\x43\xba\x62\xcd\xff\x43\xdb\x97\x00\x46\x51\x64\x7f\x77\x75\xf5\x5c\x49\x26\x73\xe4\x98\xdc\x99\xdc\x77\x26\xc9\x10\x42\xc2\x91\x49\x08\x21\x40\x08\xc8\x3d\x40\xee\x83\x84\x23\x01\x12\x08\x01\xb9\x54\xd6\xf1\x43\x05\xbc\x56\xf1\xda\xc5\x5d\xd7\x75\xf1\x42\x54\x3c\x76\x95\x4b\x74\x81\x55\x40\x04\x44\x44\x39\x44\x57\x14\x45\x74\x11\x32\x3d\xdf\xab\xd7\x3d\x93\x49\x08\xde\xff\x75\x79\xa9\xa9\xae\xfe\xd5\xab\xf7\x5e\x55\xbd\xae\xae\x7e\x35\x7a\xe1\xc2\x8a\xc5\xc5\x4b\x97\x96\xae\xc8\x99\x3d\x7b\x60\x6b\xd8\xf4\xe9\x51\x55\xc6\x09\x13\x82\xa7\xf0\x05\x05\xca\x61\x3e\xa9\xa9\xfe\x99\x8b\x57\xb4\x56\x4d\x19\x96\x99\x39\x6c\x4a\x55\xeb\x8a\xc5\xaa\xa6\xc4\xa6\xba\xd8\x44\x16\x58\x15\x23\x52\x59\xa4\xff\x79\x3f\xd6\x5d\x8f\xf4\x89\x02\xf6\x63\x84\xed\xc4\x8a\x8b\xcd\x1d\x60\xcd\x49\x92\xff\x06\xc8\x7f\x4d\xf2\x5f\xf7\x75\x55\x9f\xdf\x7d\xff\xf6\xbd\xde\xf7\x77\x42\x1f\x7c\x77\x7d\xf4\xe8\x80\x41\x83\x06\xdc\xc3\xc8\xff\xf2\x72\xf3\x72\xe3\x59\x4a\xcc\x1b\x08\xff\x7b\x2a\x2f\x37\x37\x8f\x9f\xc0\xa8\x33\x8c\x65\xf0\x37\x7b\xca\x3a\x9f\x1e\x30\x68\xe0\x40\x2c\x4c\xde\x62\xd7\xc4\x99\x8c\xfe\x8f\x15\xbe\x87\xa5\xe8\x7d\x40\xd2\xe1\x97\x78\x28\x2f\x2f\xf7\x34\xfc\x20\x77\x43\x62\x3a\x03\xeb\x04\x42\x5e\x1e\x68\xcd\x77\x96\x40\xea\x81\x01\x03\x06\xf1\x11\x72\x21\x91\x42\xe2\x0c\xbb\xed\xf0\xa0\x01\x83\x52\x21\xc1\xfa\xf7\x16\xee\x36\x21\x8e\x5e\xe1\xb4\xec\x3d\xb4\x8f\xe0\xaf\x53\xe9\x58\xaf\xb7\x54\x7a\x06\x18\xb4\x48\x2e\x8e\x45\xb2\x1c\x46\xf8\xd9\xad\xc7\x16\x8a\xe2\x4b\x2f\x8a\x62\xdb\x11\x7a\xa5\xe3\x83\xd9\x2f\x89\x22\xa1\x2f\xce\x3d\xdc\x29\x8d\x3d\x29\x30\xe6\x6d\x16\x6e\xc6\x6f\x74\xc0\xde\x05\xe2\xc7\xf3\x24\x30\x48\x8f\xfd\xa8\xf7\xd8\x03\x0f\xe9\x06\xd2\xc7\xc6\x53\x84\x9b\xbb\x85\xc5\x7b\x3b\x17\xef\x5f\xbc\x78\x1f\xd0\x45\xc2\xcd\x57\x97\xf3\x45\x8b\xf7\x2d\x86\x34\x64\x76\xee\x03\x64\xef\x3a\xe2\x58\x7c\x7e\x21\x30\x90\xf8\x45\x44\x40\x4d\xf1\x09\xfa\x10\xe8\x5f\xac\x05\x27\x4e\xfc\x47\x7f\xe2\x3f\x7d\x5e\x77\x61\x9d\x7d\xfa\x59\x52\x3f\x3c\xdc\x50\xf7\x64\x6d\x2d\x74\x22\xa4\x63\xaf\x65\xc8\x73\x0d\xa8\x37\x73\x28\x83\x76\xb2\x86\xaf\xa7\x8b\x40\xa6\xa1\x4c\x06\x81\x2a\x7f\xe8\x7a\x61\xe1\x26\x6a\xf0\xe9\xdb\xe7\x71\xb7\xa0\x1c\x25\xd6\xd4\xeb\xcb\x5a\xbe\xfe\x8f\xb5\x25\xf3\x4b\xee\x6e\x9c\x35\x72\x74\x79\x53\x69\x69\x53\xdd\xe8\xb1\xd5\xfc\xf2\x39\x77\x14\x2d\x1c\x31\x6b\xc3\xe8\x91\xb3\x4a\x9b\x9a\x4a\x47\x36\xb6\x70\x0a\xf2\x1c\x8c\x75\x5d\x30\xd6\xf9\x72\x21\x5c\x3c\x97\xc5\x15\x70\x6d\x36\x5b\x80\xb2\x20\x34\x7a\x60\x5a\x82\x1f\xc7\x25\x44\x2b\x85\xc1\x43\x92\x23\x62\x33\x63\x73\xb3\x9b\xb3\x89\x3d\x9b\x8c\xcc\x26\xa1\xd9\x24\xdb\x3a\x48\x17\x5b\x1d\xdb\x16\x4b\xd5\x83\x6c\x1a\xff\xb2\xd8\x41\xb1\x83\xa8\x8e\x2d\xbc\x07\xb3\x19\xea\x43\xb6\x9d\x06\xba\x67\x5a\x55\xa5\x7e\xbf\xb5\xb2\x52\xfa\x66\x54\xda\xf0\xe8\xd9\xf2\x2e\x37\x83\x53\xc5\x72\x49\xf8\x2d\x9b\x6a\x00\x97\xc4\xb6\x67\x04\x72\xa6\x1c\x8e\x78\x7d\x38\xaa\xf0\x4a\xb3\x70\x9e\x79\x26\xb6\x9b\x43\xd9\x25\xde\xdf\xed\x14\x37\x12\x18\x3e\x79\xf8\xaf\x6e\xba\xf8\x9f\xa3\x1f\xfc\xf1\x01\x92\x73\xf4\x18\xc9\x72\xce\xc8\x34\x9b\x33\x32\xcc\xe6\x4c\x72\x28\xdd\x6c\xb6\x58\xcc\xe6\x74\xe7\x7f\xcb\xef\xde\x50\x3e\xac\xee\xe5\x97\xeb\xf8\x32\x11\xa6\x2c\xd2\xe4\xbc\x42\x66\x8b\xf7\xfe\x70\x8c\xe4\x90\x8d\x0f\x1c\x3b\x2a\xfe\x87\x90\x01\x64\x8a\x39\xd3\x7d\x33\xfe\x15\x5f\xbf\xed\xb6\xb8\x57\x5e\xc1\x75\x2a\x72\x00\x64\xf6\x00\xca\x8c\xc5\x20\xcf\xe0\x1a\x6c\xf9\xf1\x7e\xc6\xe4\xa8\x10\x63\x88\x12\x26\xee\x4c\x4b\x4c\x90\x2e\x5c\x97\x92\xd1\x9c\x41\xec\x19\x64\x4c\x06\x19\x9a\x41\x32\xd2\x12\x75\xba\x68\x5d\xb5\xae\x4d\x27\xa8\xc7\x25\x56\x27\xf2\xba\x44\x5d\xa2\x06\x44\xb5\x8f\x89\xa9\x12\xc4\xf4\x9f\x1e\x31\xfd\x27\xc7\xbd\x7b\xbd\x67\x2f\x92\x97\x98\x14\xde\x51\xf7\xbd\xbf\xa8\x66\x92\x49\x42\xc9\x3c\xd0\x47\x32\x4e\xae\x1f\x61\x3c\xcd\xe4\x30\xac\x7c\xc3\xdd\xe5\xbd\x85\xb1\xd4\xab\xe5\xec\xaf\xf8\xe1\x2b\xaf\xc4\xdd\x76\x1b\x7b\xb7\x53\xea\x6a\x57\xfa\x0b\x83\xb9\x54\x98\x05\x86\xd8\xe2\x33\xe3\x72\x7d\xe2\x7c\x06\xe5\x67\xaf\x0a\x7d\x37\xf4\xe3\x50\xba\x32\x94\x64\x85\x12\x4b\x28\x09\x4d\xd3\xa5\x16\xa6\x8e\x4b\xa5\xea\x54\xdc\x5f\xf5\x21\x6b\x5b\x2f\xeb\xb5\x06\x45\x11\x76\x2c\x60\x30\x7b\xba\x54\xb2\xd3\x01\xfd\x79\x15\xb8\xb7\x89\x49\xaa\xa4\xbc\xc4\x24\x8c\x05\x90\x94\x67\x1a\x98\x67\x72\x7f\x17\xce\xf6\xbf\xd2\xdb\x8a\x8b\xeb\x87\xbc\x92\xb1\x6d\x8a\xf2\xc8\x11\xc3\x98\x6d\xd9\x2f\xc6\x8f\x1e\x96\x5b\xdc\xd5\xf0\x5a\xda\x8b\x15\xfa\x23\x47\xfc\xc6\x6f\x4d\xfe\x67\xeb\x82\xe8\xb5\xdb\x77\xde\xb6\xb6\xa6\x7e\x97\x30\xf8\x98\x32\x29\xe3\xc5\x8c\x6d\x0b\x3a\x86\x2d\xaf\x81\x42\x61\xa9\x7a\xf5\xb1\x63\x86\x51\x5b\x33\xb6\x35\x2c\x1f\xb6\xaa\x1a\x10\xc6\x6a\x87\xbe\xe9\x70\xec\xaa\xad\xfd\x7f\x8e\x37\x59\x1b\x3f\xe0\xc6\x0b\x89\xc2\x6a\xe8\x11\x49\xdc\x68\x5b\x52\x64\xb0\xd1\xdf\x3f\x08\x14\x1f\x1f\x6f\xf0\x15\x7c\x93\x53\x8c\x41\x3a\x2e\x44\x1f\x32\x3e\x84\x86\x98\xfd\x39\x6e\x15\xc7\xab\xb9\x50\x15\x33\xfa\xaa\xca\x9c\xfd\x96\x4a\xab\x67\x5b\xaf\x67\xdb\x43\x0e\xdb\xdd\xeb\x0e\x2a\x87\x41\x36\xe5\xa5\x5a\xf6\x3e\x24\x96\x45\x42\x90\x1b\x98\x49\xf8\x0f\xcb\xe7\x94\x3c\xbd\x70\xf1\xc4\x29\xeb\x67\x13\xce\xc5\x8d\x86\x41\x92\x8f\x1b\x34\x33\x7f\xd9\x84\xa9\x83\x87\xe6\x57\xf2\xc5\xbe\xe5\x4b\xc7\xac\xf8\xeb\x94\x89\x4b\xe7\x6d\xd2\x3e\x5e\x2a\x5e\x21\xca\x52\x7e\x43\x6e\x75\xfe\x94\xae\x61\x43\x27\x15\x54\x0f\x60\x6d\xb8\x81\xbb\x22\x3c\x03\x6d\x48\xe7\x06\x71\x25\xb6\xb8\xac\xe8\xf4\x98\x24\x93\xc1\x30\x50\x88\x49\x8a\xc9\x2f\x48\x8f\x4e\xb5\x72\xf1\xab\xe2\xf9\xf8\x8c\xf5\xbe\xc4\x57\x97\x4a\x24\x35\xed\xab\x94\x3b\xae\x57\xc0\x28\x0c\x4f\x8d\xdf\x45\x41\xff\xcb\x1b\x88\x01\x5c\xd8\x17\x29\x41\xac\x9f\x46\xb3\xc3\xaf\xd8\x38\xa8\x92\x4f\x88\x93\x5a\xa8\x72\x5b\x24\xd3\x98\xeb\xee\x34\xb5\x52\xa9\x8e\x29\x19\x3c\x2d\x25\x5e\xab\x57\xea\xfd\x04\xc1\x3f\x20\x21\x5e\xfb\xe5\xa4\x67\x3a\x3a\x9e\xfa\xfb\xd2\x91\x13\x37\xda\x6f\x5c\x31\xd5\xbe\xf4\x46\x81\x4b\x4b\x53\x68\xd5\x1a\x16\xab\xc5\xcf\x3f\x7c\x48\x5d\x85\xd5\xac\x51\x2a\x8b\xa6\xe7\x7c\x75\xc3\xbc\xe5\x4f\x3f\xb6\x74\xc9\x93\x69\xe6\xa5\xf6\xea\xc5\xcb\xa7\x4d\xbd\x11\x7d\xcc\xc1\xa0\x17\x85\xf0\x0e\x17\xc3\x0d\xb0\x45\x70\xbe\xbe\x26\x83\xde\x44\x95\x11\xca\x88\xd8\x38\x4d\xa8\x4d\xed\x5b\x16\x6a\x18\x07\x6e\x0a\x73\x11\x2b\x61\x34\x72\x7f\x15\x22\x85\x28\x80\x56\x61\x58\x3f\x13\xee\x0d\x8b\xe2\xa3\x49\x4c\x1e\x0c\xe6\x43\xe5\xaf\x70\x06\xe6\xc1\xa4\x65\x0e\xad\xf9\xe3\x1d\xa5\xfc\x4d\x53\x1f\xae\xa7\xe3\x1e\xbb\x45\xdd\xfd\x99\xf2\xc6\xcd\x53\xa7\x3f\x69\xbf\xc9\x5e\xbf\xf6\x16\xe1\x9d\x9a\xbf\xaf\x5d\x71\xcb\xc8\x9a\x55\xaf\x3f\xfa\x78\x95\x26\x21\xa1\x76\xf3\x06\xff\xd7\x57\xcd\xb4\x3b\x26\x74\xbe\xc2\xf8\x1b\xc2\x81\xe3\x2b\xec\xe1\x06\x70\x85\xb6\x18\x8b\x9a\x70\xea\x90\x28\x45\xb2\x2e\x59\x97\x9b\x3c\x30\x3e\x4d\x6d\x09\x34\x0b\xbe\xd1\xbe\xc4\xe8\x6b\xf4\x25\xe1\x9e\x73\x27\x2b\xd9\x7e\x70\xf7\xab\x3b\xa3\x74\x48\x7b\x0a\xc9\x1b\x46\x73\x93\xa4\x79\x87\x31\x97\x63\xf2\x1c\x12\x17\x14\xa8\xc2\xc0\x70\xf2\x39\x7d\xa0\x8f\x28\x6a\x12\x4a\xbb\x5f\x54\xdf\xda\x59\x9d\xcb\xe7\x6f\xb1\x8f\x5d\x5d\x7a\x57\xe5\xb0\x86\x44\x83\xef\xa6\x05\x1d\x7f\x1a\x31\x49\x1f\x9c\xd4\x52\x32\xea\xa1\x8e\x41\x8b\xab\x87\x2a\xb2\xe7\xad\x5c\x18\x17\x3e\x70\xc9\xbd\xe5\x96\x25\x8b\xcb\x57\x8c\x6d\x7f\x84\x58\x8b\x92\x13\x12\xbb\xee\xfb\xd3\x9c\x29\x75\xc9\x54\x5d\x51\xde\xd1\xf1\xd7\xec\x09\x2d\x2b\x1e\x58\x92\x1b\x84\x72\x6f\x72\x7d\x0e\xcf\x32\x5d\xd0\x47\xd8\xde\x3b\x6d\x80\x4a\x15\x10\x1a\xe6\xe3\x71\x94\x0d\xe8\xea\x2a\x32\x89\xc5\x73\x3a\xa9\xb4\x97\x9d\x99\xbe\x3f\xe1\xeb\x82\x67\x3c\x3b\x7d\xcc\xc0\xb5\x8d\x53\xd7\x25\xc6\xde\x39\xad\x76\xdd\xb4\xb6\xdb\x57\x9b\xa6\xbc\x78\x7e\x59\xc3\xea\xe2\x39\xb7\x2d\x5c\xd2\xb9\xc8\x51\x37\xe5\x5f\xb7\x3d\x7f\x18\xea\x2a\x76\x9d\xa3\x07\x41\x86\x7e\x5c\xb4\x8d\x85\xd6\xf7\xa1\x3e\x54\xeb\x3f\xc6\x87\xf8\xb0\x8d\x94\x3d\xdf\xf9\xb0\x8f\xdf\x38\x93\x92\x53\x25\xf2\x89\x49\x03\x39\x5e\x55\x46\x34\x4b\x4b\xc4\xff\x4c\x4c\x78\xf9\x9e\xc9\x1d\xf0\xa0\xb0\x67\xb9\xf8\xc7\xdb\x4a\xc5\x96\x7b\x46\x12\xc5\xeb\x4d\xb7\x11\xbb\xf4\x9c\xb2\x8b\x8b\xa4\x83\xa1\xaf\x84\x72\x99\xb6\x20\xde\xdf\x3f\xd4\x47\xa1\x08\x0c\x0d\x0d\x0b\xd7\xaa\xd5\x6c\x23\xab\xc9\x00\x7d\x7b\x5f\x65\xbe\xe5\x9a\xef\xdc\xac\x41\x4c\xe2\xaa\x38\x0c\x68\xe4\xbd\x07\x90\x7c\x5e\xfe\xc0\xbc\x2a\x4b\xfe\x42\xdb\xdd\x73\xf2\x0b\x96\x57\xa4\x67\x0a\xab\x1b\xb6\xdf\xfd\xe4\x7d\x5d\xab\x96\x2c\x79\xc4\x57\x54\x2e\xfb\xe3\xc0\xcc\xb1\x1d\x78\x2e\x39\xd1\xbb\x0e\x0b\x17\x84\x5b\xb9\x08\xce\xcc\xd5\xd8\x06\x44\xea\x74\x41\x61\x51\x2a\x3f\x3f\x2e\x8c\x8b\x89\xf5\x8f\x9c\x12\x49\x86\x47\x92\x48\x6d\xd4\xc0\x28\x92\x10\xc5\xbc\x1e\x1a\x45\xd4\x51\x11\xe6\xf0\x69\xe1\x24\x3c\x3a\x22\xc4\xe8\xc3\x9e\x07\xe0\x3f\xab\x15\xa7\x8f\x2a\x69\x1e\xb1\xe2\x64\xe2\x1d\xee\x58\x9a\x6e\xbd\xc2\x6e\x18\x14\x1e\xa6\x4d\xf0\x2b\x81\x24\xe4\x2a\x84\x0b\x03\x97\x8d\xca\xcf\x5f\x5a\x91\x95\xea\xfc\xe0\xb6\xf6\xfc\x82\x1b\xc7\x65\x64\xf0\xaf\x38\xd7\xf3\x89\xce\x0f\x48\x49\xc5\x82\x49\x03\x2d\x37\xb4\x19\xc9\x1b\xf7\x8a\x8b\x17\x3d\x98\x9b\x51\xbe\x84\x06\xf0\x5f\x6f\x11\x67\xdd\xbb\xe8\x7e\xc9\x87\x89\x72\x0d\xa2\xa7\x14\xfb\x70\x4d\x78\x9c\x2d\x5d\xeb\x63\x54\x44\x47\xeb\xd4\xbe\x01\x42\x44\x44\x30\x09\x0b\x09\x0f\x0f\xf3\xf5\x11\xcc\x31\x54\x63\xd2\x07\x1b\x23\xfd\xb4\xe1\x61\xd1\x82\x5a\xa3\x55\x05\xa9\x58\x07\x90\x3e\x9c\x76\x7b\x09\x56\xef\xcf\xaa\xf1\x83\xe1\x38\xe0\x3a\x8e\x45\x30\xc3\x7f\xd6\xa0\x04\x28\xc7\x22\x9b\xe5\x29\xe0\x02\x3d\xb5\x7f\x85\x78\x70\xc5\x7e\xf8\xdf\x0a\x92\xc9\xfe\x8a\x2f\x88\x07\xc9\x93\x55\xe2\x56\x12\x7a\x97\xf8\x1c\x09\x9f\x71\x7c\x06\x79\x89\x91\xac\xee\xbb\x48\xa9\xf8\x65\xd5\xf1\x2a\x71\xf4\xcc\x0d\x64\xdb\x5d\xa2\xfc\x0d\x56\x28\x0b\x6e\x86\xb1\xab\xe7\xd9\x06\x87\x47\x47\x86\x12\xe2\xa3\x8c\xf6\xa1\x31\xe6\x10\x8c\xbb\x2b\x85\xdd\x8d\xd4\x46\x60\xc8\xdd\x50\x43\x4f\xb8\xdd\x20\xca\x62\xed\x2a\xd4\x6a\x52\x63\x57\xcb\x41\xa1\xa4\x98\xef\xee\xb0\x3f\x3d\xb1\x70\xfa\xf9\xfe\xcf\x10\x93\x23\x7d\xa1\xd5\x2b\xaa\x2e\x34\x4d\x7a\xb5\xc7\xfb\x10\xc3\xe1\x86\x09\xd3\x13\xaf\x8e\x62\x61\x73\x5f\xfc\x07\xff\xc2\x3b\xe4\xff\x89\x8b\xc9\xff\x23\x67\xc4\x3f\x04\x12\x93\x38\x67\x54\x38\x59\xd5\xfc\x52\x33\x69\xc3\xb0\x95\x1b\x20\x09\xed\x49\x06\xa5\x04\xb3\x33\xf6\xb8\x99\x36\x03\x08\x9b\x85\xeb\x1c\x67\x67\x11\x3c\xc7\xd9\x05\x3d\xfb\x58\x22\x5a\x63\x28\xd3\xeb\x39\x16\x6a\x90\x67\x41\x06\x7d\x43\x42\x82\x2b\xec\xe0\x0d\x6b\x7d\xb5\x15\x76\xdf\x20\x4f\x78\xab\x9e\x00\x83\x56\x18\x4c\xbd\x63\x6a\x4b\x51\x3b\xdd\x51\x14\xfb\xc4\x05\x7e\xa6\x11\xfe\x37\x4b\x34\x36\x35\xc0\xff\x6a\xc8\x6a\x3a\xad\x79\x74\xb3\x18\xc1\xc2\x20\x93\x33\x90\x24\xc7\x31\x16\x32\x8b\x5f\x2a\xc9\x5e\x0f\x8f\x78\xec\x3c\x19\xfe\x11\x2e\xce\xf9\x38\xd8\x94\x16\xc6\xf9\xbf\xe3\xb7\x79\x66\x6e\xba\x2d\x3b\xd0\xc0\xb4\xa2\x54\x86\x19\x68\x6c\x0c\x17\x59\x63\x8f\x50\x6b\xd4\x35\xf6\x50\x0d\x3c\x86\x6b\x04\xad\x36\xa4\xc6\xae\xf5\xad\xb6\x6b\x29\x51\x0a\xca\x6a\xbb\xd0\x3b\x40\x17\x46\xa5\x75\x6b\xa1\x8f\x0a\x7a\x98\x97\x62\xc4\xea\x63\x30\x48\x07\x86\x03\x67\xae\xb5\x2f\x0b\xb9\xb5\x63\xc7\x66\x7e\x1c\x89\x24\x61\x62\xf0\x13\x9d\xf7\x8d\x7b\xe3\x8d\x89\x6b\x57\xf0\xfe\x52\x80\x2d\x2a\x2c\xfb\x5f\xd8\xa8\xd7\xf7\x89\x33\xc9\xa6\x3f\xad\x3c\xbf\xec\xfc\xed\xac\x4f\xc4\x89\xa5\x8a\x63\xc0\x7f\x14\xf8\x14\xd5\xb6\x01\x7e\x9a\x68\xa5\x56\x1d\xaf\xd3\x45\x45\x99\xd4\x4a\x8d\x22\x25\x39\x38\x3c\xdc\x58\x63\x0f\x0f\x57\xfb\xc7\xfb\xd7\xd8\xe3\xe3\xfd\x78\x3f\x0d\x0b\xac\xcb\xc7\xd5\xd8\x59\x6c\x16\x16\x9a\x25\xcd\xeb\x2c\x09\xb7\x42\xfa\xf9\xa8\x3e\x40\xe6\x5c\x21\x05\x3b\xc4\xe0\xb6\xee\x30\x4b\xd0\xd7\x3d\xc1\x6b\xdf\xd9\xcc\xaf\x26\xc9\x24\x5e\xbc\x48\x9a\x36\x88\x15\xe2\xff\x7b\x7c\xc6\x88\xd4\xd2\x80\x28\x7b\xf2\xba\xf1\x27\x2e\xf2\x9f\xdf\xf8\xd7\xdb\x37\x6c\xbc\x89\x05\x60\x79\x71\xbb\xf8\xf1\x04\x51\x1f\x3e\x8a\x1f\xe4\x1c\x58\x55\x13\x66\x7a\x5e\x7c\xd7\xcf\xf8\xdf\x0f\xe8\x2b\xf7\x2d\x72\x1e\x59\xc5\x09\x5c\xb1\xb8\x86\x7e\xa2\xc8\xc4\xb8\x61\x2c\x86\x75\x97\xad\x38\x83\x57\x69\x33\x33\x23\x92\x92\x42\x42\xe2\xb4\xbc\x90\x9d\x93\x96\x9a\x9c\x60\x4e\xb8\xc1\x9e\x99\x5c\x61\xe7\x94\x66\x4b\x66\x90\x56\xa7\x8d\xd6\xf2\x7e\x34\x53\x9b\xa9\x35\xc4\xd8\xcc\xc1\xe1\x21\x15\xf6\xf0\xa0\x00\x83\x41\x53\x61\x37\xe8\x71\x13\x8b\xfe\x4d\x39\xc0\x92\xa7\x13\xe1\xf1\x09\xf9\x69\x9e\xa3\x34\xdc\xfa\x93\x4f\xa3\x4b\x64\x0f\x9b\x79\x01\x52\x00\xa9\x5c\x98\x75\x58\x9c\x6f\xe9\x14\x0a\xe6\x62\xd2\x38\x74\x93\x0d\x3a\x92\xa7\x0c\x22\xb9\x2a\xa2\xd9\x73\xc3\x43\x8f\xd4\xc5\xe4\x4d\x6a\x4e\x2c\xfe\xe3\x9d\xa3\x07\xae\x98\xbf\x66\x47\x95\xf8\x78\x70\x7e\xc9\x84\xcc\x1b\x5b\x49\x48\x40\x68\xc9\xf8\x11\xaf\x96\x94\x10\x2e\xc1\x37\xf9\xdc\xac\x15\xc3\x94\x24\x22\x7c\xc0\xa2\xd3\x26\x3f\x9e\xb4\x89\xab\xb3\x76\x38\x1f\x0e\x29\x2e\x4b\x8c\x0e\x22\xe2\xfd\xe4\xbf\x3e\x71\x64\x3c\xfd\x68\x77\xd2\x5a\x92\x34\x7b\x8e\x34\x1e\x9a\x41\x36\x36\x90\x4d\x38\x68\xbf\xd8\x16\x13\xe1\x4f\xa9\x39\x3a\xc2\x9f\xd0\xb0\x30\x9f\xc0\x90\x10\xe3\x0d\x76\x2e\x24\x58\x11\xe5\x13\x35\xce\xee\xa7\x56\xf9\xe8\x58\xdc\xa1\x37\x25\xfd\xee\x72\x07\xb2\x37\xb9\xe7\x9e\xec\xac\x70\x82\xc1\x8c\x31\x74\x71\x80\x55\x76\x1d\x83\x98\x6e\x93\x28\xc9\x8b\x33\x3f\x97\xbb\x6c\xc3\xa2\xfb\x3a\x1f\x9a\x2f\x2e\x87\x47\xfd\xb1\x51\x1b\x86\x4c\x2a\xd8\x48\x2c\x63\xc7\x8a\x6b\xc8\x4b\x83\xeb\xf8\x39\x45\x49\x87\x0f\x93\x9b\xba\x87\xff\xa1\xa8\x58\x3f\x39\x28\x36\x58\xbc\x99\xba\xde\x60\x7d\x4f\x1c\xa3\x34\x29\x86\x1a\x95\xc2\x44\xe9\xbb\x41\xf1\x21\x61\x12\x8c\x1b\x66\xae\xc8\x16\x63\xd0\x50\x12\x12\x12\xa9\x89\x8c\x8d\x31\x47\x55\xd8\xcd\x5c\x88\x41\x13\x19\x1e\x59\x61\xd7\x69\xc3\x83\x82\xa8\x12\x63\xb0\x17\xbe\xe9\x09\x75\x96\xe6\x3d\xf3\xb0\x8e\x15\xa8\x02\x0f\xc5\xcc\x82\xad\xb3\xa0\xbe\xd7\x9c\x07\x42\xb6\x2a\x47\xdc\xb9\x80\x08\x55\xda\x96\xdb\xde\x9b\x34\xb2\xb8\xbc\x9c\x85\x54\xaf\x51\xdc\x21\xb6\x14\x4f\x8f\x2b\x93\xc2\xa9\xc3\x33\x4a\x83\x14\x52\x3d\xd6\x59\xc4\x46\x0f\xe1\x58\x88\x74\x8e\x28\xe3\x3d\x05\xcf\xab\x99\x66\xb3\x68\xd4\x42\x28\xef\x43\x43\xfc\xfc\x0c\x06\xca\x0b\x42\x64\x44\xa8\x89\x37\xb2\x88\x7d\x34\xc4\x87\xea\xc2\x03\xa9\x9f\x00\xa3\x76\xb5\x5d\x67\xd4\x18\x55\xe1\x5c\xa1\x57\x28\x51\xe9\x03\xda\x6b\x22\x88\x4a\x21\x44\x35\xc4\xc4\x98\x27\x5e\x81\xe1\x61\x74\x76\x87\x0e\xe5\x2b\x96\xc7\x2d\x5f\x7d\xaf\xe8\xdb\xc1\xc2\x86\xb2\xa0\xa1\x7c\xbd\x1c\x33\xd4\x69\x08\x17\x79\xf2\x02\xff\x87\x06\xd1\x13\xc5\x68\x54\x98\xf3\x23\x3e\x36\x6c\x94\x47\xd6\xf3\x41\xd6\x11\x9c\xdd\x96\x65\xd0\xf0\x2a\xa3\x9a\x04\x82\x13\xa2\x56\x69\x84\xa8\xc8\x88\xb0\x0a\x7b\x04\x17\x68\xd0\x84\x9a\x42\x2b\xec\x6a\x62\xa4\x82\x4e\x6b\x0a\x52\xf1\x02\x5f\x61\x17\x74\xee\xc1\xed\xcd\x1e\xf6\x7b\xc7\xbd\x77\xef\x41\xc5\xf8\x4c\x3a\xe2\xd1\x01\x55\x05\xf5\xc8\x9f\xb4\x35\x90\xa6\xb9\x1f\x93\xe1\x93\x40\x05\xbb\xf3\x5e\x6b\xaf\x14\x53\xec\xa0\x80\xee\x81\x64\xbd\xa9\xb8\x38\xf8\xbc\xf3\xa2\x5b\x03\x64\xd4\xf8\x1f\xbc\xc4\x0f\xfc\xd7\x89\x63\x84\x0f\x40\xfe\x7a\x6e\x98\xcd\xac\xd7\xf2\x3e\xbe\x1c\xa7\xf2\xd1\x0a\x46\x83\x2e\xdc\x87\xaa\x69\x8d\x5d\xa5\xa6\xc4\x97\x83\x41\x99\x33\x7a\x9d\x62\xc1\x49\x41\x6f\x7a\x22\x97\x5a\x73\x89\x1c\xb8\x34\x88\xc4\x30\x36\xeb\xf8\x4f\xbf\x3e\x5d\x19\x6d\x17\xfc\x9c\x41\x34\x34\x76\xf9\xea\x85\x42\x6d\xe0\x21\x72\xc3\xec\xab\xf7\xa6\x8b\x3a\xf2\x82\x54\x7f\xb2\xf8\x10\xad\xa1\x9b\x39\x03\x37\xc8\x16\xa9\x17\x94\x3a\x4e\x07\x8f\x19\xc6\x00\x9d\x4a\xab\xaa\xb0\xfb\x69\x75\x0a\xbd\xa0\xaf\xb0\xf3\x02\xcc\x65\x6f\x7a\xd5\xee\x15\x78\x2f\x06\x43\x4d\x13\x29\xd4\x10\x56\x4f\x6b\x40\x12\xce\x3d\xe4\xd9\x39\x83\x9a\x03\xa3\xcb\xf8\x0f\xc4\xf1\x30\xd3\x82\x04\x32\x68\x42\x80\xfe\x41\x12\x92\xdd\x7d\x12\xfa\xf7\x28\xd7\x79\x65\xa5\xa2\x9c\xf3\x05\x8f\x01\xbc\x7c\x8d\x9f\x5f\x04\x0d\x88\x08\x88\x81\x4e\x5e\x6d\x8f\x36\xfa\x85\xea\xc2\x68\x30\x57\x63\x0f\x16\x74\xca\x1a\xb0\xb9\x9e\x0d\x80\x30\xa4\xf5\xda\x55\xcd\xbe\xe7\xe5\x0d\x7a\x23\x0b\x7c\x63\x48\x0c\x60\x7d\x3a\x1e\x4f\x34\x01\xf7\x39\xcf\x8a\x47\x13\x4c\x3a\x7b\xec\xd0\xc1\xd1\x0f\x66\xce\x5f\x31\x6a\x7d\xe5\x09\xf1\xf9\xe7\xc9\x5a\xb2\x68\xe1\x86\x84\x13\x05\x87\x45\x3f\xe1\x23\xf1\x94\x78\x48\x3c\x2f\x1e\x4f\x08\x17\x02\xb2\xaf\xe6\x85\x18\xfe\x4c\x72\xde\x25\x53\xc8\xac\x10\xa5\xee\x6a\x52\xf8\x28\x5c\x97\x77\x9d\x17\x76\xd2\xdd\x5c\x30\x97\x67\x8b\x54\xab\x74\xfe\x1a\x8d\x2e\x88\x86\x98\x02\xe8\x78\x3b\x17\xa0\xd7\xf8\xfb\xfa\xc3\xa4\xaf\xd7\xa9\x83\xdd\xbb\xcb\xa5\xd8\xc2\xee\x81\x96\xc5\xf9\x62\x8b\x0e\x2a\xf6\xc6\x9d\xf5\x80\x70\xc2\x7c\x7b\x53\x90\xd0\x65\x09\x4e\x4e\x2c\x8c\x10\x5f\xee\x12\x3b\x8b\xc9\x27\xf3\xbf\xd9\x6c\x59\xd9\x38\x71\x1c\xbf\x67\xb9\xde\x62\x73\xaa\x68\x13\x18\x4d\x98\xf3\x33\xf2\xf7\x45\x6d\xd1\x27\x51\x6f\x91\xae\x4f\xd4\xdb\x40\x76\x91\x5c\xbe\x2d\x92\xf3\x8f\x8e\x0a\x17\x6a\xec\x24\x1c\x1e\x10\xf5\xe0\x69\x99\xc0\x15\x09\x0a\xd2\xea\x05\x1f\x29\x8e\x38\x3b\x3b\x27\xdf\x60\xf5\x62\x09\x97\x19\x31\x48\x8e\x3f\x01\x7e\x34\x6e\x96\x34\xc4\x4a\x30\xae\xab\x49\xbd\x6d\x7c\x6c\x54\x4e\xee\xf0\x82\x60\xf1\xa9\x2e\x71\x8b\xf8\xc2\x32\xb1\x84\x85\x03\x87\x47\xbf\x82\xe5\x64\xf0\xb3\x99\x5b\xee\xac\x1d\x27\xc4\x3c\x18\x9c\x34\x61\xc4\xd5\xfd\x74\x70\xf7\x6e\xe1\x07\xd6\x39\xbb\x3f\xa1\xfa\xee\x8b\xfc\xf8\x87\x37\x45\x03\x9f\x4a\xd0\xb1\x83\xb2\x78\x0f\xc0\xa7\x5f\x78\x54\x64\x28\x13\x56\xa8\xde\xcf\xe0\x6f\xa8\xb0\x07\x19\x8d\x9a\x80\x00\x5f\x7f\xbd\xda\x37\xf8\x47\xf8\x74\x4b\xcd\xb7\x47\x70\x56\xb7\xec\x94\xc3\x40\x76\x29\x25\x21\xe2\xf9\xae\x23\xef\x77\x89\xcf\x97\x92\x03\xf3\xff\xfd\x41\xf5\xb1\xf5\x89\x6b\x9a\x25\x09\x66\x14\x39\x95\xbc\xce\xf9\x8d\x2c\xc5\x73\xbc\xc9\xf9\x39\x79\x72\x41\x7b\x34\xb3\xc1\x08\xd0\x29\x47\x5f\x05\x9d\x9a\xb9\x31\xb6\x54\x1d\x3c\xeb\x07\x6b\xc3\x4d\x2a\x41\xa5\xe0\xc3\x83\x95\xb1\x31\xc1\x86\x00\x60\x34\x54\xa7\xe0\xa9\x82\x04\xe8\x7c\x60\x0c\xf7\xd1\xeb\x49\xb0\x7b\xd3\x66\x4f\xe4\x00\xcf\xa0\xc1\x1e\x90\x15\x71\x94\x2d\xc7\x78\x1e\x33\xc3\x25\xc6\x15\x81\x26\xe9\xf4\x2e\x25\x5f\xd2\x75\xf8\x99\xb4\x2d\x59\xb7\x76\x54\x37\xad\xb8\xe9\x58\x2b\xb1\x96\x38\x8f\x99\x87\x04\x87\x9a\x82\x03\xc9\xd1\xe9\xd3\x67\x74\x4c\xac\x6b\x9f\x3c\xa2\x7a\xb6\xf8\x31\x1f\x06\x8c\x07\xe6\x24\x8c\xca\x1f\x60\x8a\x8f\x93\xfa\x2d\xfc\x11\xbe\x40\xbf\x6e\x9c\x2d\xc5\x9f\xe7\x55\x3a\x8e\x33\xaa\x8c\x81\x30\x9f\x41\x57\xf1\x07\xc7\xda\xdf\x5f\xe1\xa3\x55\xfb\xa8\xab\xed\x3e\x94\x57\x29\x54\xe0\x5f\xf7\x78\x73\xc8\xf1\xb5\xf1\xa4\xe4\xd7\x53\xde\x83\x34\x1e\xeb\x22\xb4\x3b\xff\x78\xd2\x39\xf2\xd1\xcd\xfc\x9b\x27\xf9\x96\x68\xbb\x9d\x5f\xe6\xfc\xdc\x33\x1e\x87\x8b\xfa\x27\xc5\x21\x12\x5f\x03\x39\x8e\xfe\x95\x3e\x05\x7c\x4d\xb5\x65\x6b\xc1\xd5\xf4\x0f\x08\x30\x28\x0d\x81\x41\x5a\x8e\x4d\x79\xd1\xda\x71\xda\x6a\x6d\x9b\x56\xe1\x47\xb5\x5a\x41\xe3\xa7\xd2\xc0\x28\xa3\xd1\x31\x6f\x13\x06\xe4\xa0\x9f\xc5\x9f\x87\xbd\x04\x37\x7b\x49\xe4\xc5\x3b\x9c\xdf\x56\x57\xf3\xda\x3b\xc8\x8a\xc4\x31\x63\x12\xc9\x56\xf1\x71\xf7\x59\x21\xa4\x38\x44\x7c\xf5\x31\xb1\xf2\x71\xf4\x29\x60\xcc\x11\x5e\xa4\x6f\xa2\xbe\x07\xda\x22\x4d\x81\x51\x5a\x1f\x4a\x55\xda\x40\x21\x36\xc6\x10\x36\x0e\x9c\x27\xa5\x3e\x4a\xcb\x69\xe5\x53\x19\xdc\x9b\x36\xbd\x47\x5a\x85\x99\xcb\xc5\x13\xfe\x09\x1e\x2d\x25\x6b\x98\xf3\x8a\x5b\xb8\x5c\xfc\x42\xfc\xe4\xf8\xd9\x09\xa3\x1a\xe7\xdd\xba\xea\x89\x3d\xe2\x21\xb5\x75\xd8\xc0\xcc\x39\xb3\x03\x09\xf9\xea\xc4\x85\xc8\x99\xe6\x17\x5f\x7a\x65\x87\x3f\x3f\xe2\xae\x47\xba\x0f\x7d\x2f\x7e\x41\x7e\xd8\xf5\xf2\xec\x06\xe7\x1b\x7e\x3b\x25\xbf\x27\x87\x5b\xca\x77\xd1\x9b\xf0\x5d\x62\xba\xcd\xa4\xc0\x77\x98\x6a\x8d\x86\x84\x12\x5e\xa9\x0a\x56\xf1\x44\x45\x15\xd2\xc1\xba\xf9\x95\x95\x5e\x6b\x83\xec\x4b\x44\x03\xfc\xe3\xbb\x9c\x2f\xf3\x23\xd9\x3f\xfe\x80\xf8\xe1\x73\xe0\xa9\x46\xe0\x1f\x8e\x77\x65\x09\x9b\xb8\x77\x55\xa9\x80\xad\xe3\xfc\xb7\xfa\x08\x02\x61\xab\xce\xf9\x16\x0c\x6b\x0e\x03\x79\x4e\xcf\x7a\xd4\xb8\xd5\x64\xf5\x13\x96\xb2\xd2\xec\xac\xd2\x91\xaa\x54\xe7\x12\xf2\x6a\x89\x35\xab\xb4\x34\x2b\xbb\x14\x70\xc6\x08\x97\xc9\x12\x55\x82\x8c\x03\xc6\xe8\xc3\x63\x30\x19\x0b\x0b\xc4\x4a\x92\xf2\xbc\xc3\x2b\x44\xce\x10\x07\xce\x68\x85\x5b\xb3\xb3\x4b\x4a\x55\xf8\xeb\x6c\x69\x56\xce\x88\x11\x39\x59\xa5\xd0\x5e\xf1\x35\xc5\xed\xa4\x44\x95\x86\x58\x7e\xcf\xab\xb4\xec\x9c\x62\xeb\xbe\x1c\xe9\x3b\x52\xef\x30\x88\xa4\x84\x71\x31\x32\x4b\xe2\x42\xa9\x5d\xbd\xfa\x89\xec\x52\xe4\x8f\xd9\x9e\x78\x46\x98\x4c\x22\x14\xef\xc3\x83\x90\xcf\x16\xca\xb1\xa3\x18\xf7\xe1\x66\x7f\xab\x21\x46\x3c\x43\xfe\xb6\xc1\xf9\x96\x70\xea\x92\xb8\x52\x7a\xa7\x4c\x3f\xa7\x7f\x50\x2d\x86\xc7\x9e\x10\x9b\x86\xfa\xfa\xb0\xc3\x8a\xd5\x9e\xc3\x8a\xa5\xe7\x32\x69\x9d\x11\x06\x44\xfa\x07\xf1\xd4\x3b\xe2\x29\x32\x63\x2c\xa9\x57\x9c\x77\x3a\x79\x3a\x91\xe4\x89\x6f\x5d\x83\xa3\xf0\xf5\x51\x0b\x02\xaf\xe2\x7b\xe1\xb0\xb1\x55\xda\x68\x0a\x38\x0f\x8f\x15\xff\x4a\xa2\xde\x21\x51\x8a\x18\xf1\x2d\x92\x37\x91\xa7\x4e\x27\xd3\xf9\xed\xd4\x8f\x8f\x52\x99\x71\x5f\x58\xc2\x0b\x7e\x4a\xa5\x41\xaf\xd9\xe6\xfa\xda\xa6\xd1\xf8\x95\x69\x74\x3a\xaa\x95\x79\xcb\xef\x89\x60\xe1\x2d\x18\x76\xfa\xe9\x95\x9a\xd2\xd2\xea\xca\xb2\x91\xd5\xe2\x5d\xe4\xae\xb6\xad\x74\x0b\x0b\x65\x51\x5a\x53\x4b\x53\x9c\xb7\x72\x7d\xeb\x88\xb5\xe9\xb1\x12\xaa\x87\x0a\xa8\x9f\x9f\x46\xa7\xf9\xb1\x0a\xa8\x35\x20\x86\x55\x50\x56\x59\x5d\x3a\xa2\xd6\xb5\xb5\x4d\x6c\x55\x2e\x1d\x51\x5b\x3b\xa2\xb4\xa6\x46\xdc\xed\xc6\x27\xf9\x7c\x94\x62\xec\xef\x84\x2f\xfc\xad\x37\x3e\x11\xef\x13\xa6\x90\x62\xc5\x7e\x90\xb5\xfe\x05\xd0\x97\x86\x1d\x2e\x0d\x76\x22\x6d\xe1\x96\x36\x95\x18\x62\x48\xf1\x85\x0d\x0f\x6e\xe0\x37\x2b\x86\x7c\xfa\xe9\xa7\xa4\x13\xef\x03\x52\x0c\x49\x76\x1f\xe8\x47\xc9\xde\xa7\xef\xcf\xb1\x4a\x8b\x83\x06\x79\xf3\x09\x29\x76\x4e\x82\x1b\x2f\x90\x4e\xb8\x4f\x1a\xcb\x8c\xe2\x28\x7e\xa3\x6b\x1d\xa7\x86\xd6\x18\x89\xa0\x61\xb1\xf7\x89\x52\xa5\xa3\xd1\xd4\x42\x29\x65\x1f\x68\xbb\x0f\xb6\x65\x5f\x20\x07\x58\x03\x82\xe2\x92\x54\xc6\x0f\x0e\x1f\x2b\xbf\x7c\x59\x1c\x15\x43\x12\xc4\xe3\x31\x9b\x36\xa1\x6c\x9e\xe1\x6e\x21\x57\xe8\x57\xf8\xee\x63\x80\x2d\x3c\x08\x5c\x07\x4a\x43\x42\x8d\x7e\x0f\x82\x63\x13\x6d\xe4\x35\xd4\xc8\xd9\xf0\xcc\x55\xf6\xc5\x71\x58\x88\x7e\x9f\x7b\xe8\x73\xc7\xc1\xba\xee\x91\xaa\xa5\xd5\xd5\x18\xb5\x44\x52\x7e\xcd\x2d\x4c\xe9\x2c\x86\x09\x1f\x85\xea\x1f\x31\xa2\x16\xea\x0f\x23\xf7\xf0\xc7\xe8\x6b\x38\xa6\xc4\xb2\x2f\x7f\x58\xe4\x52\xb5\x46\xa9\x13\x88\x80\xfd\x6d\x57\xaf\x23\x7a\xdd\x5f\x6f\xf3\xc7\x9c\x45\xfc\xeb\xf0\x2f\xf6\xce\x3b\xc9\xc6\x3b\xef\x94\xbe\x77\x27\x55\xe4\xb4\x7c\x46\xb0\x0f\x61\x0b\xc9\xec\x94\x55\x78\xce\x36\xe4\x5b\xbc\xcf\x08\x9e\x42\xee\x98\xff\xb4\x62\x68\x77\x0c\xbb\x87\x5f\x21\xdf\x13\xf8\x12\xdb\xd2\xd0\xeb\x06\x4f\xf1\xb6\x67\x14\x43\x9d\x45\xac\x8e\xbf\x3b\xbf\x23\x5f\xb8\xb6\x81\x5f\x9a\x61\x0b\x14\xa8\x4d\x12\x7a\x1b\x15\xe0\x39\x84\xde\x6b\x57\xe9\xd8\x61\x2c\x3e\xfe\x65\x3a\x8e\xad\xa7\x70\x20\x2c\x16\x3c\x18\x06\xe7\x40\xa5\x2a\x17\xdf\x2b\xca\x41\xd4\xc9\x17\x7f\x7d\xb8\x7c\x54\x5c\x5a\xdc\xa8\xc2\x11\x37\x7c\xb5\x60\x5d\xe4\x88\xc0\x81\xe9\xa1\xe6\xa8\xa4\x18\x4b\xc1\x34\x49\xcf\x30\x75\x0a\x2d\x8a\x4d\xf0\x0c\xce\x25\xf4\x84\x1e\x92\x96\x33\xf2\x72\x07\xc4\x63\x94\x01\xe9\x40\x1b\x43\x50\x8c\xc0\xb3\x05\x19\xf1\x04\xa3\x20\x10\xd7\xc7\xc3\x1e\x34\xdb\x92\x0c\xa5\xe9\xfb\xf9\x92\xe9\x38\xe9\xfc\xd7\x19\x2c\xfd\x1d\x91\x74\xc3\xae\x13\x21\x7e\xff\x5d\xa8\x8f\x12\xbf\x5c\xe4\xa9\xab\x06\xea\x32\x73\x5c\x00\xa2\xb3\xe5\x44\xab\x5c\x1d\x9b\x40\x22\x89\x67\x29\xe8\xe1\x3b\xef\xdc\xfb\xca\xf0\x7f\x1e\x61\x35\x4d\x29\x1b\x5a\xf8\xfa\xeb\x0b\x44\x75\x13\x2d\x19\x91\xd4\xf8\xaf\x77\x82\xae\xec\xc7\x27\x89\xa7\x32\x56\x77\xdc\xdd\x2c\xd5\x08\xcf\xa2\x56\xee\x3c\xd9\x22\x6c\x31\x26\x2a\x34\x2c\xe6\x9e\x70\x89\xf8\x88\xb7\x73\xe1\x36\x03\x19\x9f\x44\x6c\x49\xe4\x4f\x48\xb3\x92\x48\x12\x67\xc0\x18\x0b\x78\x8e\x0d\x11\x9f\x56\x6c\x21\x13\x94\xa7\x39\x2d\x8c\x63\xbe\x9c\x52\xe9\x0b\x4f\x84\x3c\xe7\xc3\x7a\xd8\xee\xca\x1c\x62\xd9\xe7\xe9\xaf\x56\xe9\x05\x05\x99\xb0\xf5\x91\x87\x5f\xd8\x39\xb2\xac\x64\x8c\xf2\xf4\xfa\x3f\xff\xe5\x8e\x31\x33\xec\x63\xa5\xb5\x28\x2b\x77\x85\x02\x0f\xfa\x24\xe1\x02\xb9\xcc\xf3\x7a\xe4\x45\xaf\x52\x68\x78\xf7\x75\xf6\xdd\xff\x8b\x46\x25\x38\x24\xec\x77\x95\xeb\xac\x70\x5a\x78\x0d\x7e\x4b\xd7\x43\x5d\xe7\x68\x97\xb0\x15\x7e\x53\xfc\xdd\xe4\x3a\x27\x28\xb1\xbc\x80\xbf\x23\xc1\xc7\x58\x8e\xd7\x7d\xf1\x8c\xca\xf3\xae\xd3\x74\x8a\x72\x03\xfc\xf6\xc3\xeb\x7f\x02\xfc\x2a\x90\x81\x52\xa1\x95\xf1\x2e\xd1\x0a\xbc\x3f\xc4\x7d\xd6\x8f\x50\x86\xd7\xc3\xe4\x98\x4a\x17\x85\x24\xa1\x19\x7a\x46\xb2\xcd\x0f\x46\x07\xca\x51\x8d\x5a\xc9\x13\x7e\x1b\x99\xb3\xc5\x4e\x84\x6d\xa4\x9a\x93\x56\x14\x64\x3f\xc0\xf3\xa5\x5a\x8c\x90\xd4\x6d\x25\x9d\xc7\xc9\x32\x72\xf1\x38\x79\x50\x6c\x44\xfc\x0a\x8e\x53\x3c\xac\xd8\x0b\x3a\x08\x65\xed\x16\x7e\x00\xbb\x77\xe7\x6f\xf4\xce\xe7\x4e\xf7\x53\x3e\x49\xb8\x44\x27\xb8\x1e\xbc\xee\x7d\x49\xd2\x7d\x70\x1d\xcb\x31\xf9\x89\x97\x51\x7e\x89\x4c\x7e\x90\x7f\x81\xdf\x26\xc9\x55\xbc\xb9\x57\xfe\xd7\xee\x7c\x59\xde\xee\xfc\x4b\xfc\x13\xce\xa3\xec\x4c\x50\x90\xeb\x46\x90\x6b\xa2\x82\x48\xf9\xe4\x3e\xc4\xd7\xbb\xbe\xe2\xe7\x81\xfc\x12\x15\xbc\x94\xcf\xfd\x0b\xf3\xdd\x7a\x4a\x64\x7a\xc2\xf2\x2b\x5d\x76\x2f\x7d\x25\x2a\x04\x19\x7f\x34\xcb\x77\x9d\x72\x5d\x22\x9d\x98\xaf\x90\x71\x8a\x31\x7f\xaf\xeb\x6b\x5e\x8d\x38\x4a\x39\x3f\x0d\x71\x58\xbc\x86\xd9\x98\xaf\x96\x6c\x99\xbf\xd9\xa5\x81\x31\x47\x4f\x6c\xc3\xc8\xc9\x61\xe4\x9d\x61\x64\x98\x4d\xab\x2b\x1b\xc6\x19\xd2\xc0\x94\x59\xfc\x48\xd7\x31\x72\xac\xc7\xfe\xf5\x4a\xe1\x52\xbe\x4b\xb2\x01\x71\x01\xda\x40\xa2\xc2\x47\xe6\xf5\x7e\xac\xc3\x6d\x4b\x89\xcc\x96\x30\xff\x00\x6b\x9b\xc7\xa6\x12\x99\x4d\x61\xfe\x66\xd7\x2e\x28\x6f\x71\x5d\x11\x26\x61\x79\x7f\xb9\x6d\x8f\xa3\x2c\xc0\x92\xf9\x38\xc4\xd7\xcb\x6d\xd8\x84\xf9\x75\xae\xaf\x84\x0c\xe4\xc7\x20\xb7\xa1\xca\x75\x23\xe7\xff\x12\x6f\xb1\x90\x68\x0b\xb1\xb0\x5e\xc8\x62\x45\x96\x01\x7f\x6b\xf0\xfe\x00\x19\x77\xb6\x6b\x14\x8b\xbb\xc9\xf6\x49\x61\x7d\x81\x72\xfe\x76\xd7\x8d\x90\x9f\x0d\xf9\xa7\xb1\x7c\xb0\x5c\xdf\x5e\xf1\x02\xe4\x2f\x10\x97\x41\x3e\x2b\x6f\x92\xcb\x5b\x5d\x2f\x7b\xf5\x81\x44\xd6\x07\xbc\xda\x8f\xb6\x85\xe5\x43\x7b\xd9\x94\xbb\x8f\x24\xb2\x3e\x82\x38\x5d\x58\x3e\x94\xe9\x50\xb1\xc6\xa3\xc3\x6f\xb8\x73\xd2\x79\xb2\xcc\x76\x30\x5f\xb2\x9d\xff\x91\xd7\x7a\xfa\x2a\xe6\xfb\xca\xf9\xaf\x48\xf1\x44\x71\xff\xd7\x1a\x4f\xbb\xfe\xc7\xfb\xe1\xb7\x35\xe7\x99\x6d\x2a\x37\x70\x13\xb9\x89\x36\x63\xe2\xe0\x20\x01\xaa\x17\x06\x0f\xcf\x55\x4c\x9e\x54\x18\x1f\x39\x72\x1b\xa9\x7b\x3e\x71\x70\xf6\xe0\x22\x3f\x32\x9b\xb3\x73\xd9\xd0\x33\x23\xb9\xf1\x78\x20\x54\x24\xa4\xb5\xa4\xca\xf3\x71\xaf\x14\x3f\x35\xbf\x97\xeb\x1e\x30\x00\xcf\x67\x64\xaf\xd6\xd8\xd3\x23\xc6\x87\x65\x7b\x52\x58\x78\xc0\xc1\x04\x86\xf9\xe0\x68\xd2\x73\x82\x70\x50\xa0\x35\x4f\x7a\xf3\x26\x6d\x52\x51\x29\xdc\x1b\x58\xd8\x41\x0b\x18\x51\x2a\x93\xc4\x24\xf8\x58\x22\x42\xc3\xd2\xb5\x26\x63\xc2\xd4\xd4\x94\xec\x94\xa4\xdc\xe5\x71\xd1\x3e\xe9\xb5\x2f\x34\xdf\x33\x20\x3f\x3b\x52\xc9\x0f\xad\x1c\x38\x44\xe7\x1b\x18\xe2\x1f\xfb\xd0\xec\x38\xe2\x3f\x38\x2d\x67\x5c\x48\x90\x9f\x4f\x61\xb2\x73\x59\x4c\x5a\x4a\x6e\x6a\x80\xb0\x7a\xe2\xf8\xa0\xd0\x68\xa3\xcf\xe0\xe2\x98\xc1\x69\x81\x7e\x41\xea\xc0\x88\x88\xc0\xa1\x37\xd4\xe5\xe7\xc7\x05\x47\xcd\x9a\xb5\x7d\x5d\x05\x99\x36\xd1\x5a\xee\x6b\xc8\xa4\x25\xf9\x71\xd3\x75\x81\xda\xb9\x9d\x13\xc4\xfc\xe1\x89\x21\xd5\x93\x82\x42\xa7\x25\xf3\x4f\xc6\x18\x2c\x6d\x4c\x7e\xdd\x9f\x0b\xaf\x73\x82\x32\x07\x7c\x1d\x9f\x2d\x9c\x46\xc1\x7c\x72\x76\x6c\xb3\x59\x50\xc5\x0d\x8c\x8f\xb1\x0a\x82\x8b\x13\xf7\x4f\x5e\xb7\x84\xac\x20\xda\x10\xc5\x63\xf3\x3a\xff\xf5\x02\xca\xdd\x29\xbc\x4e\x43\xe4\xfb\xd4\x44\xbe\x8f\x5a\xcd\x82\x29\x2e\x31\x3e\x8d\xd0\x10\xe2\x47\x56\x2e\x59\x67\x17\xf7\x77\x03\xfc\x0b\xff\xea\xc2\x35\x5a\xd2\xdd\x2d\xec\x02\x0b\xfa\x00\xe6\x0d\x93\xcd\x17\x86\x5b\xaa\xf3\x8d\xf6\xe5\x7d\xd5\xe0\x61\x55\xe6\xe0\x50\x69\x90\x85\x17\x87\xcf\xeb\x35\xcf\x96\xce\x9c\x3b\xc8\xf8\x50\xcc\x89\x6d\x9d\x47\x84\x6f\x4c\x29\x01\x49\xd6\x7b\x6e\xca\x95\xf6\x3d\x0a\xaf\x50\x85\xe2\x5d\x98\x23\x43\x6d\x7e\x3a\x86\xa5\x8e\x56\xf3\x6a\xea\x07\x93\xd0\xfe\x4a\x83\x84\x26\xed\x1b\xca\xb3\x4a\x91\x7e\x6a\x9f\x1b\x31\x73\x6e\x81\xff\x23\xe1\x0d\x4f\xfd\xa1\xe2\xa9\x69\x8a\xbf\x86\xa4\x06\xa4\x66\xcd\x9e\x57\x18\x1b\x24\xed\xc3\xc3\xbd\x94\x8a\xed\xb8\xcf\x50\x8b\x5f\x47\x45\x72\x31\x78\x62\xa4\x85\x2b\x92\xf7\xe2\xcd\xe6\x16\x73\x97\x6d\xab\x54\xd1\xd1\x46\x65\x54\x94\xd1\x97\x04\x05\x19\x17\x34\x86\xa4\xce\xa9\x19\x3b\x7a\x72\x65\x65\xe9\xf8\xd1\xd3\x8a\x07\x58\x69\x40\x41\x61\x61\xc0\x10\x6b\xf1\xe8\xd2\x9a\xd4\x46\x9f\x34\x1f\xce\x68\x5c\x12\x1b\x96\x99\x99\xa6\x4b\x4a\x4a\xf3\x4f\x4c\x8c\x0b\x4f\x4b\xeb\xf4\x8d\xcb\x0c\x4e\xaf\xcc\xeb\xe8\x28\xcd\xaa\x9b\x39\x99\x84\xb7\x36\x37\x8f\x1c\x32\x69\xd2\xd0\x91\xe9\x75\x03\x26\x87\x8f\x1c\x19\x3e\x79\x40\x5d\xba\x32\x22\xd9\x1c\x98\x99\x99\x14\x1d\x90\xe6\x17\xaf\x53\xd1\xd0\x50\xbd\x5a\x88\x80\x56\xca\xe7\x9a\xbc\x99\xe3\x49\x7a\xf6\xea\xc9\xaf\x4f\x2d\xee\x75\x55\x69\x81\x58\xbf\x2b\x47\x3a\x1a\xde\xea\xb5\xe4\x8a\xc4\xd8\xf7\x88\x1f\x63\x7e\x9f\x22\xee\x8f\x1f\x73\xe3\x72\x63\x14\xec\xd3\xbc\x38\x83\x95\xcd\x6b\xec\x89\x29\x97\xed\xbd\x66\xde\xb4\x57\xbe\x82\x9d\xbc\x6e\x05\x3f\x34\x29\x4f\x8a\xaa\x86\xc7\x40\x05\x2a\xe1\x09\x8d\xbd\x17\x61\x47\x94\xab\xa2\x08\x95\xdf\x92\x98\xe4\xbf\xd7\x39\xc4\x40\xcd\x35\x9c\x24\xc3\x9d\xdb\xc5\x7f\x92\xe1\x7c\x61\x43\xc3\xd5\x9b\x58\x4a\x58\x21\xfe\xf3\x64\xc3\x0f\xc3\x4f\x36\x48\x69\x32\xfc\xca\x63\x0d\x0d\x34\x8a\xa5\x58\xd9\x86\x93\x0a\xae\xb2\x3a\x68\x8e\x5f\x6a\x56\x4e\x7a\xd5\xbf\x1b\xc4\x75\x0f\xae\x7b\xf6\x4e\x12\x35\xb6\xa2\xbe\xe9\x61\xfb\x14\xb3\xf9\x19\x4b\x63\xe3\x80\xa1\xdb\x45\x9b\x78\xec\xde\xbb\xee\xba\xef\x9e\xbb\x16\xd8\x67\xd6\x4c\x9d\x3e\xb3\xd2\x2e\xac\x38\xd9\xd0\xd0\xd0\xbd\x82\x0c\x27\xc7\x1b\xae\x14\x36\x9c\x14\xc2\x80\x01\x48\x90\xe3\x64\x78\xf7\x8a\x06\xa8\xf1\xe4\xe9\xea\x4e\xe3\x98\x92\xe1\xd5\xe4\xd4\x74\xe7\x9e\x9b\x6e\xfc\x66\x6e\x17\x4d\xdb\x55\xd2\x64\xf0\x9d\x43\xe2\x8a\xf3\x45\xf1\xcc\x88\xd1\xe2\x07\x64\xb8\x38\x7d\xff\xb1\xc3\x6f\xbf\x7d\xf8\x1f\x0f\x6c\x7c\xf2\xe9\x47\xff\x88\xe3\x59\x18\x8c\x97\x63\xe9\x66\x83\x92\xb2\x33\x9e\x06\xd9\x32\xa2\x6c\xcb\x97\x97\x45\xd9\x96\x2d\x03\xb2\x70\x21\x90\x59\xb3\x80\xcc\x9c\x09\x64\xe2\x44\x20\x65\x65\x40\x06\x0c\x00\x92\x92\x52\x96\xe6\xfe\x1f\xf6\xc5\x03\x42\x0d\x7f\x44\x71\x13\xd8\x6b\xae\x2d\xc2\xc7\xd7\x57\x27\x50\x7f\x1f\xe6\x00\xc3\x53\x02\x85\xa7\x04\x55\x85\x74\x90\x3c\xdb\x9b\x21\x1d\x10\x03\xee\x6f\x8e\xfb\x24\x7e\x8c\x6d\x98\x64\x95\xa2\x80\x5b\xfd\x09\x99\xf4\xd2\x1e\xc5\x01\x65\xed\x98\x31\xb5\xca\x03\x8a\x3d\x42\xcd\xfa\xbb\xd8\x29\x01\x77\xad\xc7\x3e\xf7\x30\x1d\xc6\x53\xc5\x04\xe8\x19\xda\xad\x02\x55\xe9\x58\x74\xee\x0f\xf7\x4b\x87\xaa\xa3\x1f\xed\xd9\x2b\xc1\xd3\x17\x9e\x1b\x5f\x17\x15\x3f\x7c\xdc\xd0\xb2\x46\xe1\xc9\x5b\x5e\xb6\x8c\x0f\x99\x91\x15\x18\x65\x8c\x1d\x35\xa8\x60\x26\xc3\x7a\x56\xa8\x21\x17\x95\x71\x80\x15\x61\xf3\x47\x9f\x9d\x39\xea\xba\x68\x1d\xaf\x63\xcf\x4a\x12\xab\x6c\x10\x96\x17\x4f\xe4\xc3\x8d\x12\x9f\xf5\xf2\xd0\x15\xca\x3e\x2e\x3a\xc8\x76\x9a\x50\xc5\x87\x29\xd6\xe9\x95\xec\x5b\x8c\x9f\xf1\x7b\x03\xfc\x9e\x84\xbf\x17\xff\xf4\x6f\xf0\x7d\x4d\x8a\xb7\x5d\x6f\xa9\xd2\x60\x0e\xd7\xbf\xa0\xd7\x6a\xa9\x5a\xc7\x86\x3f\x14\x25\x95\x22\xc9\xb2\x6d\x3b\x6c\xef\x11\x7b\x2d\x76\xd2\x9a\x5a\x56\x1a\x3d\x7d\xf6\x97\x37\xcc\x98\x3f\x22\x4b\xb9\x3a\x3a\x36\xa4\x3e\xea\xde\xc1\x93\x7d\x73\x96\xd0\x28\x86\xe7\x34\x28\xde\x16\x77\xf4\x8f\x47\xae\xc5\x13\xc3\x7f\x1c\x90\x74\x4f\x03\x3c\xcd\xcf\xc6\x73\xd6\xfd\x28\x1e\xb4\x5f\x00\xfb\x7a\x42\xb1\x41\xaf\xe4\x1f\xe1\xfa\xfb\x9d\x04\xbf\x57\x2b\x1e\x83\xdf\x1b\xf1\xb7\x11\xe4\xb5\x51\xf1\x17\xf8\xed\x40\xfb\xd4\x89\x6f\xbb\x76\xba\x16\xb1\x53\x0a\x9f\xe3\xd8\xb3\x23\xfb\x9a\xd6\x1a\xf4\xcd\x56\xf1\xed\xcd\x9b\x7f\x86\xfc\x7f\x42\x7f\x6e\x7d\x18\x95\xfc\xde\xfe\x7e\xff\x24\xff\xbf\xf1\x77\xb7\x4b\x7c\xdb\xf9\xbc\x6b\x91\x5e\xa5\xf1\x73\x7e\xcd\xe1\x33\x49\xf7\x5a\xc8\x2b\x94\xf3\x6e\x94\xf2\xae\x7e\x21\xbe\xdd\xfd\xa8\x94\xd7\xfd\xa1\x5c\xee\x1d\x28\x77\xb3\x5c\xee\x0d\xb9\xdc\xe3\x50\x6e\xba\x5c\xee\x8f\x52\x5e\xdf\x3a\x9d\xf3\xc4\xb7\xc5\x18\xa9\x8c\x58\x25\x95\x11\x6f\x01\x39\x0f\x92\xf2\x5c\x8b\xe4\xbc\x7f\x43\xde\x0a\xc8\x53\x6a\xfc\x5e\x65\xf5\xfd\x00\xf5\x3d\x25\xd7\xf7\x5f\xa9\x8c\x73\x29\x60\x65\xca\x58\x73\xe4\xbc\x26\xc8\x0b\x93\xf3\xa6\xca\xbc\x3e\x02\xf7\x4e\x90\xef\x5d\x27\x97\x8b\x83\xbc\x23\x72\xb9\x40\xb9\x5c\x01\xf0\xff\x95\x5c\x2e\xad\x7f\xfe\x7f\xd9\x6f\x18\x2b\x32\xc0\x5f\x0e\xa7\x9b\x61\x56\x8e\xb5\x19\xd8\xba\x99\xb2\xc2\x0e\x76\xad\xa0\x8a\x0a\x3b\xf5\xde\x37\xc1\x56\x07\x12\x7a\x4e\x45\xd9\xca\x1e\x86\x6b\xc8\xea\xe9\x9e\xa3\xa0\xa9\xf8\xa6\x62\x3d\x29\x50\xc5\xe0\xfa\x61\x38\x97\x61\x0b\xf7\x09\x0e\xe6\x06\xc3\xf3\x9b\x5e\xb0\x69\xf5\x65\x85\x02\x09\x17\xd2\x04\x5e\x27\x10\x5e\xe0\x2c\x2c\x76\x61\x1a\x3b\x45\x43\xea\x40\xec\x7b\x74\xaf\xe5\x94\x18\xaf\xb4\xf8\x26\xdf\xb1\x31\x61\x48\x7e\x72\xca\xc0\x3c\x71\x63\x52\x41\x7e\x72\x72\x5e\x81\xf2\xbe\xb5\x6b\xc5\x2b\x79\xa9\xc9\x79\x79\xc9\x49\x05\x05\x49\x49\x83\xf2\x92\x53\xf3\xf0\xfb\x79\x2a\x0c\xe3\x9c\x8a\xaf\x71\x8d\x27\x92\x33\xbe\x18\x12\xae\x34\x1a\xfd\xd8\xb7\x0c\x30\x30\xa3\x1f\x76\x9d\x8a\xf2\x72\xf3\xac\x41\xaa\x47\xdc\x55\x3d\x22\x57\x35\xac\x61\xe7\x01\x61\x58\xdf\xaa\xce\xc4\x3c\x95\xc0\x3e\x32\xa0\xe2\xbb\x82\x8d\x64\x29\x5c\x58\x9f\x99\x9d\x55\x1b\x1d\x1e\x6e\x8c\x0c\xe9\x55\xa9\xe4\x35\x5d\xaf\x62\x12\xa4\x8a\x63\x67\xcb\xe5\xfd\xa9\x6f\xdd\xe4\xaf\xc7\xff\xf1\x41\xf9\x99\x33\x82\xad\x6f\xfd\xe4\xf5\x98\x03\x07\x62\x96\x2f\xe7\xb0\xcd\x0a\xc1\xc6\xb9\x14\x2c\x0e\x9d\x01\xdb\xec\x17\x12\xc2\x51\xa3\x12\x17\xe6\xa4\x11\x94\xe1\x07\x99\xae\xc3\x80\xf9\xc0\xce\x86\xd9\x7d\xeb\x56\xc4\xfe\x3d\xe1\xa9\x98\x53\xfd\xc8\x98\x07\x5d\x77\x82\xae\x73\x51\xd7\xd9\x36\xb3\x4a\xc5\xf1\x69\x5a\xf2\xa0\x76\xaf\xf6\xaa\x96\x6a\x51\xdd\x5a\x12\xae\x4d\xd3\xf2\x3a\x2d\xe1\xb5\xb2\xba\x2b\x17\xc8\x4b\xd3\xa0\x6d\x45\x4f\x58\xbb\x44\xa6\x61\xb1\x70\x42\x5e\xc1\xd8\xf2\xc1\xf9\xe3\x95\x4f\xae\x5d\xfb\x6c\xfe\xe8\xf2\xbc\xdc\x8a\x72\x69\x5d\xfa\x4e\x52\x8c\x75\x85\xb2\x95\xae\x10\x0d\x3b\x68\x93\xe3\xfd\x04\xb9\x75\xf9\x16\xab\xc7\x82\x32\x79\xf6\x8a\x2a\x0e\xa0\xa3\x78\x9c\x78\xd1\x7a\x5e\xcf\x18\x53\x38\x30\x2c\x29\x45\x53\x1d\xb8\x25\x73\x34\x24\x13\xd3\x20\xc9\xea\x11\xcf\x44\xc4\x44\x24\x5a\x3f\x09\x8f\x0e\x4f\xc8\xfa\x44\x5a\x87\xfa\x13\x08\xf4\x25\xc5\x6a\xe8\x13\x89\x36\xbd\x8a\x10\x16\x97\xc7\x97\x57\xa9\x88\x5a\xc0\xe8\x7c\xd6\x5d\x46\x69\x8b\x97\x7b\x4d\x30\x26\xce\x80\x0e\x9a\xc1\x4a\x5f\x72\x88\x7f\x11\xf7\x93\x46\x92\xea\xa0\x0f\x93\x99\x0e\xf1\x7d\x92\xfa\x3b\x60\xae\x17\x3f\x41\x4c\xfe\x30\x1f\xef\x10\x47\x90\x57\x7f\x07\xcc\x3f\x88\x5f\x90\x36\x62\x76\x90\x47\xe9\x74\x87\x73\x3a\xff\xb8\x37\x26\x5b\x6b\xf5\x27\x4a\x25\xe5\x38\x8d\x8f\x92\xa8\xd8\x57\x44\x32\xa2\x37\x9e\x17\xdc\x4a\xf1\x22\xc2\x09\x3f\x38\xba\x4b\xe8\x6b\x80\x35\xd6\x1b\x8b\x7d\x85\x04\x48\x94\x12\x05\xaf\x46\x2c\xab\x7b\x69\x1e\x5f\xc9\x02\x6f\x1a\x92\xa7\x21\x88\xb5\x4d\x6c\x9a\x49\x86\x91\x32\x87\xb0\x47\xdc\x47\xd6\xd4\x8a\xef\x91\x01\x92\x6e\x26\x78\xda\x1c\x6f\xd3\xb9\xdb\xcc\xa2\xbb\x2b\x34\x08\xea\x85\x29\xb7\x38\x86\xe4\xb1\x2f\x35\x19\xec\x3d\xe2\xba\x3a\x32\x92\x0c\x70\xd0\xbf\x91\xb6\x5a\x71\x1b\x99\x80\x98\x6e\x3e\x55\x0c\x53\x41\x08\xb4\x59\xcd\x62\x07\x13\x41\x25\x63\x5e\x23\xc5\x3c\xa9\xd1\xce\xa8\x6a\xfe\x66\x07\x3f\x9a\xdf\x57\xe5\x7c\x90\x5f\xe8\x85\xd5\x8b\x3f\xd4\x89\xa2\x7f\xac\x5c\x68\x35\x09\x30\xb8\x9b\x3d\x91\x3c\xff\xa1\xe3\x3c\xff\x57\xb2\x66\x8e\xd8\x2c\x5a\x68\x0b\x60\x96\x7a\xe4\x68\xb6\x69\xbd\x74\x22\xb8\x11\xbd\xf1\xbc\xe0\xfe\x26\xce\x9f\x4e\x9e\xfe\xc4\x41\xff\x4c\x96\x36\x89\xb3\x9d\x0f\xd1\x2b\xd8\x5e\xf6\xb2\x67\x7e\x7f\xed\x55\x0a\x3f\xd6\x5e\x7e\xbe\x43\xac\x9a\x0e\x4a\x01\xc3\x5e\xd5\x20\x1e\x25\xc9\x80\x95\xdb\xbf\x8e\x55\xbc\xe2\xa7\x74\xbc\x55\x9c\x30\x07\x94\x01\x3a\xee\x72\xbe\xcf\x9f\xa9\x70\x9e\xe4\x63\x24\x1d\xe7\x7a\x64\x98\x69\x0b\x74\xcb\x50\x49\x41\x8a\x0a\x80\xf6\x08\xd2\x22\x3f\x49\xf5\xe2\x14\xf1\x0d\x3d\x15\xd4\x92\x4c\x68\xbf\xf8\x1c\x7f\x66\x8c\xf3\x79\x92\x41\xcc\x80\x3f\xee\x7a\x36\xd4\x03\x7d\x7d\x1b\x7a\x42\x5c\xd2\x41\x1a\x88\xda\xc1\x3f\xc8\x3f\x52\xe6\xdc\xc4\x57\xb9\xe7\xd1\x5f\xa6\x77\xc6\x29\x31\x49\x98\x8f\x88\x35\x8b\xc9\x3d\x97\x1d\xc4\x9f\xd4\xf3\xff\x2e\x75\x96\xfe\x40\x9f\x07\xcc\x32\x19\x53\x89\x7a\x17\xd8\x77\x82\x6a\x50\xba\x82\xf6\xa7\x77\x8f\x49\x86\x76\x82\xa2\x14\x43\x4b\xae\x3e\x20\xcc\xe2\x3c\x73\xfc\xaf\xd4\xf7\x88\x76\x50\x10\x3f\x85\x3f\x5d\x86\xea\x21\x5c\xbc\x47\xdf\x9e\x31\xe7\xfa\x1a\x37\x5c\xdb\xaf\x87\xde\x28\xe9\x3c\xb4\xfb\x84\x60\xcf\xe9\x3e\x41\xe5\xf7\xe8\x09\xfd\x8d\x65\x0c\x57\xfd\x13\xb8\xb9\x08\xbc\x43\x1c\xb0\x82\x4c\x63\x3d\xfb\x51\xe7\x1a\x21\x39\xb7\xfb\x33\xbe\x69\x4b\x6f\xdc\xdf\x64\x4b\xcf\x8b\xc3\x97\x91\x76\x12\x01\xb2\x10\x9f\x13\xca\x72\xba\x97\x13\x23\xbf\x00\xf0\x93\x7e\x8b\x2d\xdd\x2b\xd6\x77\x91\x9b\x89\x9f\x83\xdc\x40\xc5\x9c\xee\x69\xf4\x09\x94\x85\xa5\xdf\x31\xd8\xab\xc3\x5b\xae\xe9\xf1\x26\xf7\x00\x52\xb6\x92\x3c\xf5\x9e\x83\x8c\x14\x68\x5e\x77\xe0\xfb\xc2\x0e\x59\x06\xb2\xfe\xc1\x8e\xdc\xfa\xf7\xd6\x7e\xaf\xf1\xc8\xa3\xfb\xa1\xcb\x40\x51\xdf\x0a\x33\x65\x2d\x11\x5c\x43\x94\xf8\xf2\xb4\x15\xf8\xe2\x89\x0a\x2d\xd2\x6a\xb1\x1a\xf3\xf3\xaf\xaf\xf9\x81\xcb\xc9\x58\x36\x78\x1c\xe9\x4e\x51\xdc\x90\xd5\x9d\x42\x8f\x30\x4c\x53\x7f\xf2\x03\x4c\x85\xe6\x47\x31\x73\x65\xd0\xac\x15\xc4\x4e\x8a\x1c\x74\x51\xf7\x5a\xc5\x38\x4b\xb7\x89\xce\x5d\xd5\xb3\xff\xe1\x57\xe0\xba\xc5\x38\x6e\x25\xa9\x20\xe9\x0e\x7e\x9d\x73\x81\x62\x62\xc6\xd5\xd3\xfc\x3c\xf2\x5c\x1f\xdc\x54\x9b\xd1\xbb\x9f\x2b\x34\xcc\x5a\x39\x0b\xae\x0d\xf5\xdf\xdb\x13\x3c\xe8\x2b\x48\x07\x51\x39\xc8\x20\xf1\x2d\x86\xbe\xec\x0a\xbd\x9d\x61\x67\x79\xe6\xa1\x30\x16\xa3\x96\x69\x49\x89\xf3\xae\xd5\x6b\x0c\x4d\x21\x80\x64\x65\x48\x62\x9a\x58\xb1\x9a\xdc\xfd\x85\x43\x31\x31\xf3\x2a\x7b\x8b\xc1\x30\x52\x64\x5d\x7b\x8d\x19\x2a\xf5\x8f\x8e\x19\x4c\xd5\x45\xab\xc9\x30\x06\x23\x69\x85\xf3\x1a\x23\x55\x5c\x84\x8d\xc5\x0b\x66\xdf\xb4\x10\xaa\xec\x6d\x80\xb2\x3d\x27\x91\x18\xd6\xae\x7d\xe2\x0b\xb5\xd0\xae\x4b\xc2\x0f\xe2\xb6\x5a\xd2\x26\xe1\x94\xf7\x91\x97\x82\xc9\x4b\xc5\xf3\x80\xa6\x96\xe1\x18\x5e\x3f\xf2\x4a\x72\x6b\xe3\x25\x71\xfb\x0c\xf2\x20\x33\x9d\xbb\x48\xae\x78\xbc\x89\x74\x81\x4f\x30\xe0\xf7\xc1\xbe\x5f\xfc\x60\x32\x62\xf3\x29\xfc\x6a\xf1\xfb\x66\xd2\xe5\xdc\xce\x17\xf6\x8f\xed\xeb\xf3\xd3\xd8\xb9\x44\xe1\xc1\xbe\x45\x3c\x3f\x11\xb1\x3f\xa7\x4f\x31\xe4\xee\x43\x34\x03\x65\x52\xe5\xdd\xbf\x95\xfd\x8e\xa0\xf9\x5e\x73\xa6\x17\xe4\x1d\xe2\xb7\x37\x00\xe4\x40\x87\x70\xdb\x39\x90\x43\xf7\x50\xba\x53\xe2\x55\xd6\x39\xe0\x29\xd0\x26\x55\x6a\x00\xe4\x95\xfd\x8e\x17\x06\x50\x18\x6a\x7d\x47\x15\x79\xc8\x21\xec\x10\x4f\xb4\x90\xae\xde\xbe\x1f\xd8\x8e\x34\x97\x0b\x30\x4b\xc8\xee\x5a\xdf\x99\x5c\xc5\x5c\x3f\xc6\x95\x4b\x9c\x4f\x26\x91\xc1\x0e\x61\xd7\x27\x0e\x12\xdc\xcb\x2f\x4d\xb6\x19\xdc\x7d\x84\xed\xf5\x54\xb0\xd8\x1a\xf2\xf6\x83\x6b\x46\x5b\x2f\x57\xf2\x41\xf0\x9a\xd9\xc4\xcd\xb7\x90\xa5\xc0\x26\x3b\xe8\xac\xb7\xbf\xeb\xd5\xa7\x05\x55\x6f\xd4\xeb\x61\x3e\x22\x1e\x22\x2b\x89\xde\x41\x72\xf9\xa7\x1d\xce\x8b\x34\xbe\x37\x26\x8e\x69\xd2\x58\xeb\xa3\xa1\x4a\xa6\xe6\xfe\x31\x19\xa4\xec\x5f\x3d\x25\xee\x22\x8f\x7c\xe3\xa0\xa7\x1d\xce\x42\x77\xbf\x19\xef\xc1\xf3\xb4\x9d\x69\x17\x9e\xa7\x7b\xe4\x98\x6f\xb9\xfe\x0c\xf9\xb2\xd8\x5c\x43\xa2\x48\xad\x43\x58\xe2\x3c\x4c\xfe\x5c\x27\x1e\xe7\xa7\xf4\xee\x47\x59\xb6\xa0\x9e\x79\x0c\x2c\x52\x81\xe0\x1a\xcf\xb7\x57\x3f\x31\x93\x6d\x13\x1b\x6b\xc8\x60\xd6\x9b\x9e\x15\x5f\x26\x0f\xd5\x88\xbb\x61\x42\xd6\xbb\xfd\xc2\x6b\xe7\x60\xaa\x54\x28\xbd\xe1\xaf\x3f\x9b\x35\x89\xcf\xd5\x91\x54\x52\x09\x9e\x11\x59\x3c\x53\x7c\x11\x3c\xa3\x1e\xbe\x55\x0c\x53\x9a\x7b\x34\x6a\x76\x2e\x87\x40\x54\x6e\x01\x5f\xd7\xbb\x8e\xac\xe2\xd7\x38\x48\x12\x7f\xa6\xde\xb9\x8c\xde\xdf\x6b\x3c\xe9\x3d\x37\x7a\xab\xeb\x7a\xde\x30\x34\x7c\x06\x79\xf6\xa8\x83\x6f\x27\x1b\xeb\xc5\x89\x62\xbd\x30\xc3\xab\xef\xa8\xe4\xbe\x23\xcd\x8d\xbd\xb8\xeb\xdf\x33\x6a\xa8\x24\x85\x0e\xbe\x81\x3c\xd4\x28\x6e\xe7\x67\xf4\x99\xb7\x7f\xad\xee\x47\x2e\x02\xfc\x49\x0e\x21\xb2\xfb\x2c\xad\x2d\x75\x3e\x40\x0b\x19\x6e\xfe\x6f\xd7\xbd\x7b\xbe\x9c\xb0\x98\x0c\x42\x0f\xde\xb9\x80\x8e\x1c\xe9\xfc\x33\xbf\x4e\xde\x7f\x5c\xe8\x55\x47\xb0\x77\x1d\x14\x94\xc5\xc3\x60\x22\x55\x22\x1f\x14\xf9\x23\xf6\xb5\x43\xac\xe8\x24\x95\xcc\x53\x6a\x17\xff\x42\xa7\x0d\x75\x4e\x26\x83\xd8\x09\x80\xbd\xea\xf8\x55\xf6\xf5\x98\x38\xaf\x13\x9e\x30\x7d\x1c\x64\x0a\x0d\x1d\xea\xcc\xa1\x8f\x79\x61\xfe\x02\x7b\x30\xb9\x1f\x0f\x66\x76\x92\x8d\x27\x61\x40\xa0\x05\x43\xbb\x3f\xda\x2b\xf9\x4a\x85\x1e\x7b\xf0\xd8\x2b\xfa\xca\x3f\x69\xaf\xcc\x26\xa6\x76\x92\x1c\x07\xc9\xa0\xc5\x43\x9d\x4f\xd2\xb4\x5e\xfe\x42\x2f\x7f\x99\x0d\x84\x6a\xdc\xfe\x64\xb5\xf6\x63\x63\xde\x5e\xd3\xb8\xe5\x64\x80\xdb\x6b\xd2\x64\x75\x2f\x70\x8f\x33\xb9\xfd\x3e\xfb\xb3\xa1\xf0\x27\x70\xdd\x96\x50\xb1\x9c\x0c\x71\x7b\x4e\x9a\xec\xee\x19\xe8\x39\x5d\xc7\xbf\x61\x96\xd6\x17\xf9\xc7\x46\x18\x6f\xef\xc9\x37\xa3\x3b\x0d\xbd\xa7\xdf\x84\xdd\xbf\xef\xe4\x93\x71\x75\x97\xec\x3b\x0d\xf4\x8c\x33\x2c\xea\x0b\xfa\x4e\x94\x0a\x2a\xc9\x7b\xea\x99\x01\x7b\xf9\x4f\x59\x0c\xec\xc1\x8f\x1d\x0c\xe7\x06\xd9\x7f\xca\xf5\x9e\x4b\x3d\xfe\x13\xd8\xbf\xb2\x5f\x7b\xf2\xa8\x7e\xec\x4a\x78\xf8\x00\xa0\xee\xa5\xf4\x5d\xae\xd7\xb8\xc7\xf8\x21\xd7\x71\xa0\xfa\x78\x50\x9f\x88\xff\x68\x23\x9d\xcc\x83\x72\xee\x1c\xc3\x2f\xed\x3d\xee\xa7\xdb\x02\xdc\x3e\x0e\xf8\x9b\xca\x3e\x8e\x48\x7f\x1e\xa7\xc7\x6d\x38\x28\xbe\xd2\xe6\xf6\xa0\xa2\x44\x3f\x80\x46\x0f\xea\x77\xc3\x7f\x4e\x3c\xde\xe6\xf6\xa2\x26\x8a\x36\xc0\x47\x2f\xaa\x37\xbe\x64\xa7\x92\x8f\x76\x8d\x17\xd5\x67\x45\xc4\x83\xfc\xa0\xf8\x4d\x9b\xec\x43\x2d\x12\xab\x00\x58\x72\xa2\xfa\xcc\x03\x3f\xed\x43\x79\x41\x3e\x22\x7e\xd5\x46\x9e\x62\x3e\xd4\x04\x71\x36\x43\x64\x4e\x14\xf2\xda\xfc\x2b\xfd\xa8\x0b\x6d\x64\x95\x43\x58\x21\x0e\x19\xdb\x5b\x67\x4a\x29\x0a\xc8\xf5\x50\x3c\x18\x6c\xaa\x9b\x53\xc1\x9f\x76\x08\xef\x38\xdf\x6d\x96\x30\x4a\xfb\xf8\x50\x0a\x69\xac\x14\xe0\x3f\xaf\xc1\xb2\xaf\x4e\xd0\x92\xa4\x66\xfe\x4b\x7c\xb5\x8e\xcc\x26\x2b\xc1\x3d\x11\xef\x9f\x49\xee\x21\xc1\x7d\xf4\x21\x3d\x0f\xcb\xfa\xa6\xaa\xbe\xd0\xc6\xfc\x9c\x9f\xe3\x93\xf3\xab\x3d\x3e\x39\x3f\xe2\x47\xf0\x95\xaa\x3e\xf8\xfd\xce\x54\xd7\xfa\xe5\x24\xd4\xe3\x97\xd3\x71\xbd\xf4\x0e\x63\x08\x8c\xf7\xf2\x78\x2a\xcd\xb2\xea\x5e\xe8\xbd\xfa\x29\xf5\x40\xb7\x9c\x9d\x05\x4f\xf2\xf3\x1d\x30\x00\x9c\x99\x49\x76\x74\xff\x45\x88\xef\xe5\x07\x80\xbc\x25\xdd\xe3\xb8\xaf\x62\x46\x25\x77\xfd\x7e\xd6\x49\x92\x60\x3c\x65\x26\xb0\xbd\x12\x5c\x69\xfa\xb6\xb8\xbd\x91\x3c\xf4\x7d\x6f\xbf\xd2\x6b\xdc\x17\x78\xb5\xc2\xc3\x25\xfc\xbf\x0f\x1a\x75\x7b\xd4\xe7\xc4\x69\x64\x0a\xc9\x77\x08\xd3\xc5\x22\x07\x5b\x60\xf2\xf6\x7d\xa5\x7e\x2a\xf9\xbe\x0a\xe8\xa9\x1a\x2f\xff\xb7\xbf\xf9\x5f\xe5\xf1\x81\x2f\x8a\xf5\xa4\x89\xa4\x38\xe8\x03\xa2\x83\x14\x90\x78\xee\x7a\xbe\x3a\xaf\xea\xeb\x55\x5f\xdf\xaf\x7e\x58\x7c\x8f\xd4\xc3\x60\x4f\xe2\x49\xa7\x43\xdc\x4d\x1f\xb8\xae\x5f\xad\xf1\xf9\x29\xbf\x9a\xb8\x97\xd8\xde\x26\xb7\x11\x25\xf8\x91\x0e\x51\x10\xa6\x4b\x7b\x5d\x3d\x78\x9e\x75\x1c\xd6\xe3\x79\x85\xba\x8f\xe6\x0d\xfd\x3e\x7b\x2b\xa4\xf9\xf4\x0d\x71\x56\x35\x34\x6b\x81\x43\x88\x77\x1a\xc8\xda\x2a\x91\xd6\x02\xf6\x54\x8f\x0c\x72\x7a\xfb\x3e\xbc\x42\xd3\xc7\xc1\x32\xfc\xa4\x87\x35\xbf\x8a\x18\x49\xb3\x83\xae\x72\xfe\x93\xdc\x5c\x25\x5e\xe6\x97\x7e\xc3\xf8\xb7\xff\x7e\xfe\xfb\xc2\x19\xe0\x12\x8c\x74\xf0\x73\x61\x10\xbf\xa9\x49\x3c\x4c\x72\x78\x49\x46\x53\x7f\x9b\x7f\x75\xbf\xb8\xbe\x8e\x8c\x21\x69\xe0\x5f\x91\xb9\x33\xc5\x37\xd0\xbf\x9a\xe2\x19\xcb\xbc\xe6\x43\x36\x1d\xf6\x9d\x59\xfb\xac\x42\x26\x55\xf3\x4b\x1d\xfc\x1b\x55\xce\x47\x84\xdd\x8c\xb7\x99\xbf\xc5\xaf\xea\xa8\x24\x16\x07\x34\x7a\x6d\xa3\x78\x90\xae\xc5\xb6\x0e\xf2\xb6\x2f\xe9\x59\x55\xea\x5c\x5e\x8e\x84\x31\xbf\xff\x95\xe7\x7f\x8b\x85\x6d\x24\x0d\x1e\x54\xe8\xce\xee\xa1\xfc\xb1\x31\x62\xa8\x50\xc2\x30\xf3\xfa\xeb\x63\xa0\x21\x4d\x1f\x07\xa5\x5f\x0b\xeb\xb1\x80\xf1\x6d\xf0\x14\x54\xed\xa0\x19\xdd\x87\x18\xb8\x1f\x6d\xfe\x5c\xea\x13\x79\xbf\x87\x6f\x05\xe8\x85\x64\xb4\x83\x2f\x84\x29\xf6\xd8\x18\xe7\xe7\xfc\x18\x3e\x85\xc9\xc3\xe5\xec\xa7\x1f\x2b\xc0\xba\x34\x4a\xf6\x69\x09\x42\xe7\x5b\x2c\xd7\x45\x7e\x99\x21\x4f\x87\x87\x6e\x62\x17\xff\xc2\x7f\x38\xc6\xf9\x0a\x29\xa2\x75\xbd\x64\xfd\xcb\x7c\xab\x1b\xda\xc8\x1d\x57\x1d\x8c\xc7\x06\xd9\xb7\x1a\xd4\x9f\x6f\xf5\x13\xb6\xc4\xcf\xbf\x8d\x21\x15\x21\xd0\x69\x01\xe7\xc6\x91\xbf\xc0\xb7\x8a\x93\x7d\xab\xaf\xc4\x95\x5d\x30\xa1\x1c\x16\x7e\xe8\xae\xcc\xa1\x12\x3f\x23\x7e\x0f\xdf\xe7\x8c\xf8\xd4\x32\xf2\x30\x19\xeb\xa0\x4b\x88\xb1\x7b\x1f\x60\x8b\xcf\xb1\x98\xbd\xbf\x17\xfe\x7f\xc4\x9d\xcb\xc8\x26\x36\xd3\xd6\x93\x6f\x9c\x7c\x36\xbd\xe2\x3c\xc7\x87\x7a\xe1\xdf\xf2\xcb\xf1\xbd\x3d\xac\x17\xc4\x0f\x25\xfc\x87\xe9\x22\x67\x49\x0e\xed\xee\xfe\x13\xad\xe4\x7a\xf1\x8f\xcf\xb3\xee\xb9\x56\xa9\xe8\xe3\x66\x5d\xf3\xfe\xc9\x03\xbd\x59\x3c\x2b\x41\x53\xa7\xd3\x0e\x82\x71\xaf\xf9\x8e\xf8\x95\x7e\xd6\x51\x40\xbb\x4d\x88\x70\x16\xa0\x02\xa5\x33\xfd\x3d\x3e\xa0\xd4\x7e\x0d\xfb\x92\xaa\x67\xc1\xaa\xcf\x4c\xc8\x58\x63\x9c\x9d\x14\x9f\xe8\x24\x75\xa4\xdc\x21\xec\xd8\xeb\xac\x1e\xca\xbf\x4c\x72\xbd\xf1\x7e\x99\xcf\x15\xe7\xf1\xb9\x3e\x17\x9f\x5b\x4c\x16\x92\x21\xe0\x72\x39\xdb\x87\xf2\x47\xd1\xe5\xea\xf5\xfc\xfe\x9b\x7c\xae\x83\xe2\xd3\x8b\xc9\xd3\xcc\x12\xec\xe4\x76\xe7\x82\x91\x74\xa4\x38\x89\x1f\xf5\xdb\xf0\xbd\x2d\xe1\x59\xf1\x5d\x09\xff\x05\xfe\x2b\xe7\x56\x80\x77\x9a\xe9\x8d\x8c\xff\x82\x7e\x7d\x2e\xa5\xa2\xcf\xcc\xcb\xd0\xaf\x63\x09\x4f\x88\x47\x17\x81\xcf\x0d\x96\x70\xb7\x73\x57\x29\x2d\xeb\xbe\x57\x50\x79\x64\x73\xad\xdf\xc5\xce\x67\xfb\x79\x7e\xd7\x5b\x9d\xe4\x19\x07\x7d\xd9\xf9\xe8\x50\x3a\xf6\x51\x86\xb7\xc1\xc3\xab\x3c\x36\xf4\x6f\x11\x92\xbf\xe5\xb6\x87\xa3\xe2\xbd\x33\x60\xd2\x2b\x73\x08\x33\xc4\x7a\xf1\xfe\x7a\x32\x99\x6f\xf7\xc2\xc2\x39\x8b\xaa\x54\xbc\x52\x09\x23\x1f\x8b\xb0\xa9\x50\x29\xfa\x9b\xb3\x34\xc8\x97\x21\x8e\x5a\x9c\xff\x9c\xc1\x3f\xe2\x70\xd0\x0f\x9d\x4b\xeb\xf9\xd3\x67\xaf\xac\xf4\xe6\xed\x57\xfb\xf4\x1f\x8b\x27\x66\x90\x32\x32\x05\x3c\x23\xf1\xd5\x7a\x32\x5b\x7e\xf7\xb8\xe1\x37\xd8\x97\x97\x63\xfc\x9a\x4b\x12\x02\x29\x26\xd9\xe2\xe9\x7a\xb2\x44\xdc\x47\x6f\xe9\x2d\xd3\x5e\x3e\xb7\xa4\x7e\xa5\x3c\x76\x5f\xcb\x39\x51\xf5\x3c\x73\x7d\x54\x85\xd0\x7c\xf9\x0f\x4d\x64\x89\xf3\x90\xb0\x9c\xbb\x9e\xcf\xfd\x73\x74\x6f\xe8\xf1\xb9\xf9\x7b\xd0\xe7\xe6\xd3\xfa\xfa\x9c\x1e\x9f\xbb\xdf\x15\xec\xbe\x1e\xf7\x71\xb1\x9c\x4c\x20\x43\x1d\xf4\x88\x13\x9e\x98\x1e\xeb\xbb\xde\xdc\xcb\xe7\x76\x7b\x04\x3f\xe2\x73\x53\x8f\x33\x7b\x41\xac\x21\x15\x6c\x9d\x25\x5e\xcc\x71\xf0\xad\x30\xd0\xfc\x16\x5c\x2f\x27\xf9\x7d\xf1\x41\x12\x0d\x8f\x31\xfc\xdd\xe2\x4e\x07\xb9\x95\x8f\xe8\xc7\xef\x56\x33\xef\x4a\xa5\xf1\x21\x3c\xaf\x14\xd4\xca\x7e\x64\x20\x03\xc2\x20\xf6\xba\xbc\xc3\x04\xbc\x3f\x87\xf8\x85\xb0\xed\xca\xca\x3e\xeb\xad\x5e\xcf\x31\x28\x52\xb7\xc7\x72\xed\x38\xdb\xe3\x6f\xe3\x9a\x2b\x47\xa0\x23\x1c\xec\xce\x24\x5d\x4d\x5f\x08\x77\xf4\x7a\x46\xf4\xf6\x55\xfa\xf1\xb2\xae\x45\xcd\xed\x81\xf5\x23\x37\x3a\xe8\xe4\xee\x7f\x00\xec\xff\xe8\xd1\xed\xfd\xac\x65\xfc\x42\xff\xcd\x6b\x99\x38\x92\xcc\x41\x0f\x0b\xb0\xc5\x2b\xfc\x4a\x3e\xa5\xdf\x77\x59\xbf\xca\x7f\x03\xf4\x42\x32\x0a\xbc\x59\xf0\xde\x01\xfd\x38\xc9\xa5\x77\xf5\x7a\xdf\xf6\x73\x7c\x2c\x1c\x0f\xc4\x6c\x71\x56\x15\xe9\x24\xbe\x0e\xb2\xb8\x45\xfc\xbb\xf0\x83\xfc\xde\xee\x57\xf8\x58\x0e\x86\x34\x18\x71\x3e\x96\xd6\x41\x7b\xbf\x8b\x44\x1f\x8b\x2a\xfb\xbe\x8b\xf4\xf2\xaf\xbe\x10\xe7\xad\x26\x5b\x98\x7f\x75\x55\x95\xa9\x98\xd8\xe7\x5d\xa9\xd7\x78\x87\x7b\x22\x3c\x50\xfd\xbc\x29\x4d\xe8\x99\x36\x7e\x10\x6f\x5f\x41\x9e\x63\xd3\xc6\xed\x57\xae\x2e\xcb\x50\x4c\x14\xdf\x22\x83\xfa\xbe\xdf\xfd\x25\xd8\x5e\x53\xd2\x87\xe2\x93\x2b\x11\x9b\x1f\x4d\xbe\xbc\xfa\x6f\x00\x77\x1e\xe6\xa5\x35\x5b\xd3\xaf\xc1\xf6\x9e\x49\x77\x8a\x8f\xad\x20\xef\x02\xf6\x7f\xa9\xbe\x5b\x63\x51\x8c\xeb\x3e\x4e\x13\x24\xbe\x23\xfb\xac\x57\x63\x7f\x52\xb1\x05\x0c\xb9\x37\x59\xaf\x37\x87\x6e\x13\x9f\x5f\x4e\xfe\x2d\xaf\x05\x67\x29\x6e\xe8\x79\x57\xdb\xf3\xce\x17\xe7\x3c\xc9\x9f\xe2\x95\xb4\x97\xb6\xfa\xbe\xfb\x5b\x4d\x5e\x47\x24\x54\x96\xf7\xbb\x0b\x8c\xd6\x2d\xf9\x52\xbc\x5a\xe8\x0f\xc3\xe3\x47\xbd\x27\x4e\x5c\x49\xb6\xb1\x79\x73\xc7\xfb\xdd\x81\x79\x02\x25\x23\xb9\x7e\xf6\x44\x28\xdc\x7b\x22\x34\x1e\x23\xbc\xae\x0f\x75\x49\x6c\xec\x22\x2f\x90\x89\xe0\x43\x75\x47\xe6\x08\xf9\x6e\x1f\x2a\xa1\xbf\x77\xbd\x38\xc7\x79\xc3\x5e\xbb\x52\xd1\xcb\x53\xbf\x63\x19\xf9\x27\x78\xea\xfc\x02\xf0\xd4\x97\xe7\x08\x65\xe2\x73\xfc\x94\x5f\x8f\xed\xad\xf1\x23\xe2\xc3\x2b\xc8\x11\x62\x75\xbc\xc9\xcf\xee\x7e\x37\x57\xb0\x39\x57\xb3\x07\xd5\x3e\xfb\x65\xbc\x7c\x27\x98\x39\xa9\x17\xf2\x75\x75\xfe\xf2\x8d\x64\x27\xd3\x79\x5c\xf7\x89\x1c\xc1\xde\x7d\x42\x08\xf5\xc8\xa3\xd7\x9e\x1e\xf7\xdc\x49\x54\x6e\xd8\xeb\xfa\x4c\xdb\x96\x91\x9d\xf0\xb4\xd2\xed\xc8\x11\xde\x58\xc7\xf5\xda\x67\xf4\xf3\xec\x87\x3d\xdf\xaf\xef\xe4\xcf\x39\x84\x59\x57\x1f\x28\x61\x1f\x47\x5e\xbb\xff\xc9\xfd\x2e\xbe\x47\x80\xd7\xac\x4b\x79\x9a\x79\x59\x9c\xbb\x98\xfc\x89\xd4\x39\xe8\xf3\x3f\x38\x4b\x4b\xf9\x7f\x93\x7a\xe2\xdf\xcf\x3e\xad\x9f\xb6\x23\x2f\x5f\xe9\xb2\xf8\x50\x07\x71\x90\x69\xe0\x2b\x39\x1b\xcb\xf8\xe3\xb2\xaf\x94\xfb\xdb\xed\xe8\xa0\xf8\xe8\x1c\xf0\x93\xcb\x1d\xc4\x4c\x32\x9c\xcf\x8f\xe1\xcf\x88\xcf\xd1\x3f\xf7\xda\x0b\xe7\xad\xeb\x3e\x8b\x12\x3f\xa6\x6b\x09\x96\x8f\x71\x9e\xac\xe0\xcf\x38\xdf\x17\xba\xfa\xdf\xbf\xf5\xb3\x74\x2d\x0d\xeb\xdb\xda\xc9\xab\x08\x58\xc6\x9f\x46\x5b\x2f\xfd\x05\xfd\xdc\xe3\x1f\x7f\x22\x4e\x98\x4e\xd6\x13\xbb\x03\x1e\x3e\x1f\x12\x67\x37\x91\xa5\xd8\xde\xbe\x7b\x1d\x7f\x5a\xe7\x88\x88\x73\xf8\x87\xe2\xd8\x89\x64\x23\xb3\xec\x16\xd1\x22\x36\xcf\x21\x6b\xf8\xbf\x9e\xef\x67\x2f\xe6\xcf\x6c\x2b\x33\xc9\xe5\xd5\xfc\x29\x07\xbf\xd0\xf9\x60\x15\xbf\x8f\x1f\xcd\x5d\xbb\x57\xf4\x17\xd9\xcf\x3e\xf1\xe5\x3a\xb2\x80\xcc\x05\x7f\x48\xdc\x5a\x4b\xda\xd1\x29\xf4\xde\xd3\xfa\xeb\x74\xbc\x63\x26\xb6\x1a\xa6\xff\xf7\x6a\xc9\x1a\x71\x9f\xb0\x87\xeb\x77\x4f\xe6\x2f\xd1\xf1\x74\xb2\xc9\x41\x92\xc5\xa3\x0d\x64\x15\x7d\x98\xeb\xb3\x87\xb7\xe7\x9d\xa3\x9a\x05\x30\xb1\xec\xb2\x5e\xe3\x59\x11\xb7\x17\x0c\x0f\x18\x1b\x88\x3f\x59\xed\xa0\xaf\x75\x97\x38\xc0\xa1\xb8\xce\x1e\x63\x5c\x19\xf5\x42\xeb\xcf\x4b\xcd\xf5\x00\xea\xd9\x4b\x88\xc4\xee\x0f\x1c\x42\xca\xbb\xd7\xdf\x5f\xfd\x73\x30\x25\x21\x9e\x12\xd7\x91\x08\xd2\xee\xe0\x4b\x9c\xaf\x39\xf8\x6f\x79\xe5\xef\x80\xc9\xbc\x69\x2b\x99\xe9\x20\xa9\xe2\xfb\x0e\x32\x13\xc4\xc8\x11\xd1\x22\x14\x92\x03\x30\xbc\x69\xb9\x48\x9b\x4e\x50\xab\x5f\xd7\x12\xad\x4d\xe3\x57\xa6\xf5\x61\x87\x49\x58\xad\xfb\xd3\x2a\xa5\xa0\x17\xaa\xb8\xa4\x38\xf9\x1f\x20\x1e\x98\x64\xcb\x7e\x35\x1b\xff\x4d\xa2\x9b\x14\x21\xc7\x58\xd0\xc8\x63\xd2\xfc\xef\xf5\x4d\x59\x84\x4d\xeb\xab\x63\x1f\x94\x09\xd1\x02\xcf\x1e\x87\x2d\x39\xfb\x2a\x73\xdc\x07\xa2\xfd\xec\x4f\xc7\x38\x5e\xdc\xa3\x58\x47\x06\xab\x62\xf0\xdb\x4a\xe3\x4b\x9c\x4a\x55\x48\x09\x05\x6f\x7f\x5f\xa5\xd5\x90\x8f\xe1\x14\xad\xa6\x20\x05\xdb\x1e\x7f\x60\x67\x83\xd8\xca\x77\x28\x27\xb2\x8d\xfd\xbb\xee\xbb\xef\xda\xfb\xf5\x2f\x72\xec\x6e\x15\x7e\x39\x50\x99\xcf\xbe\x28\x62\xdf\x44\xb0\xbb\xed\x0d\x3b\x0f\x88\xff\x66\x77\xb3\x2f\x1f\xf0\x6e\xb6\x37\xbf\x8d\x14\xc3\xbd\xc1\x5c\x04\x97\x64\x0b\x0e\x52\x98\xfc\x58\x34\x75\x3f\x3f\x83\x2e\x2c\x3a\xcc\x12\x46\xc3\x0c\x1a\xfc\x08\x62\x5f\xa5\x21\xdf\x92\x96\xcf\xdc\xc6\x00\xf7\x2e\x7d\x8c\x45\x2f\x6f\xd3\x4f\xc0\x7a\x96\x79\x36\xea\xfb\xd4\xdb\x7b\x76\xea\x8b\x5d\x50\xb7\xa2\x0d\xb7\xea\xb7\x35\xe3\x5e\xfd\x23\x3d\xdf\x5f\x48\x3c\x98\x81\x87\x58\x2e\x93\xcb\xb3\x99\x4d\x71\x71\x81\x0a\x60\x21\x65\x46\xe4\x3f\x22\xf9\x48\x9b\x9f\xbe\xcc\x12\x49\x78\x5d\x64\x34\xfc\xf2\xf0\x53\x5d\x99\xb6\x20\x07\x3f\x1e\x40\x2d\xf6\xcb\x55\xd2\x75\xbe\x97\xb8\x0e\x9f\xeb\xaf\xf9\x84\xa2\x37\xcf\xdf\xf4\xfb\x2d\xc5\x76\xc5\xf3\x64\x28\xc6\x83\x31\x70\xfe\x5b\xfd\xfd\x39\xa5\x9f\x3b\x86\x8f\xf7\x27\x31\xa6\xdc\x80\x98\x20\xb2\xcf\x52\x32\x22\xd3\x32\xbc\xa8\x70\x3d\xd1\x88\xff\x54\x0e\x1e\x9e\x95\x55\x5c\x94\x9d\x35\xdc\x11\x43\xfc\x13\xc4\xef\x19\xde\xbb\x8a\xe5\x24\x0b\xf0\xd4\x5c\x20\x48\x23\x5e\xad\x50\xa8\xf2\x35\xa3\x34\x7c\xb2\x86\x68\xd8\x67\x80\x6d\x3a\xfa\x8e\x8e\xe8\x6c\xfe\x86\x32\x1d\xb3\x67\x9d\x14\xc0\x25\x2d\xad\x72\x41\x4e\x25\x53\x93\x15\x83\x05\x4a\x5f\xa4\xa8\xbc\x3f\x53\xc9\x92\x3e\x46\x39\x23\xf3\xa0\x6c\x93\x3e\x41\x19\xe0\x66\x02\xbf\x45\x91\xed\xc9\x8c\xdf\xc3\x84\x73\x31\xb6\x00\xce\xcf\xcf\xb8\x52\xb9\x4e\x79\x52\x49\x95\xac\x42\x65\x68\x08\x56\x58\x99\x23\x4b\xbe\x7f\x21\xab\xc0\xe8\xae\xf9\x18\x67\x07\x18\x60\x4d\x5f\x31\x1e\x00\x63\xc4\xf3\x5a\xf8\x7c\x39\x86\x5e\x84\x32\xc0\x08\x23\xa8\x7a\x9c\x5d\xa7\x61\x01\x55\x7d\x2b\xec\xda\x7e\xc2\x5b\x61\x28\x52\xef\x18\xb0\x3d\xf1\x53\xd9\x67\x4e\x06\x6b\x90\xf4\xa5\xd3\xdd\x77\xd7\x90\xd5\x6b\xc8\x63\xe2\x4b\x18\xf3\x75\x54\x33\x19\x19\x52\x2c\x56\x37\xe3\x37\x55\x63\x5c\xe7\x85\x3a\xe5\x07\xc6\x44\x5a\xcf\xe2\x42\xf0\x6b\x89\xbf\xeb\xb4\x41\xa5\xfa\x33\x31\x91\x01\xf0\x2c\x1a\x28\xd0\x95\xa9\xa4\x3a\x95\x14\xa6\x12\x5d\x2a\x49\xe5\x53\x0c\x89\xfc\x36\xd7\x0f\x5b\x93\x52\xa8\x5f\x02\x49\xcb\xe5\xd2\x72\x59\x10\x90\xca\xdc\xdc\x1f\xc5\xdb\x44\x26\xfe\xae\x78\x4f\x73\x17\x7e\x57\xbc\x67\x48\xcc\xaf\xc7\x53\x8d\xf6\xe0\x6d\xe4\x3e\x75\xed\x66\xf2\x03\xfe\xfe\xc2\xe5\x23\xde\x00\x52\x3d\x80\x14\x0e\x20\xd1\x03\x88\x6e\x00\x19\xc0\x27\x6e\x73\xbd\xf1\xa2\x31\xa4\x2c\x11\xa1\x2f\x6f\x4d\xc9\x76\x43\xcb\xd8\x0c\xfc\x47\xb0\x37\x91\xe4\xff\x33\xec\xa7\xb9\x23\xff\x67\xd8\xcf\x70\x57\x7e\x33\x36\xe7\x3a\xcf\x2f\x46\xfd\xcd\x01\xec\x44\x7e\xed\x39\xb4\x56\xd7\x79\xd0\x5e\x86\x2d\x92\xf2\x2b\x83\x48\x75\x10\x29\x0c\x22\xd1\x41\x44\x17\x44\x82\x88\xc1\x90\x48\x7c\x8c\x01\x82\xca\x5b\x7b\xa8\x3e\x86\xc7\x03\xde\x5f\xae\xc1\xdb\xc4\xc5\xfe\x4a\xbc\xfe\xf9\x7b\xfa\x37\xf1\x77\xfb\x35\x78\xcf\xc0\x74\xfc\xab\xf0\x5c\x57\x01\xaf\x43\x35\xd0\x83\xb7\xf1\x1c\x5a\xab\xeb\x1c\x59\x0f\xe3\x6d\x20\xe0\x45\x93\xea\x68\x52\x18\x4d\xa2\xa3\x89\x0e\x28\x31\xb0\x20\xd5\x5a\x50\x0d\x03\x0e\x8c\xf0\x00\xf7\xd6\x8b\x3f\xe0\x6e\xbd\x06\x77\x13\x97\xf3\xdb\x70\x5d\x9f\xf5\xcb\xef\xd3\xae\xf7\x7e\x23\xbf\xbe\x80\x7b\xf3\x35\xb8\xcf\xb8\xfe\xf7\x1b\x71\xa3\x5c\xe7\xe9\x49\xd4\x57\xa7\x34\xbe\x70\x6f\x49\xe3\x29\x77\x00\x34\x96\x65\x33\x01\x72\x38\xa9\x0e\x27\x85\xe1\x24\x3a\x9c\xe8\xc2\x49\x38\x31\x01\xe0\x36\xd7\x85\xad\x21\xa1\x34\xf0\x1a\xa5\xfd\x08\xe6\x26\x42\x7f\x77\xcc\xa7\xb9\xd7\x7e\x77\xcc\x67\x7e\x6b\xdb\x71\x2c\xe9\x94\xc7\x92\xb7\xe4\xf1\xf5\x2d\x69\x2c\x01\xcc\x04\x52\x9d\x40\x0a\x13\x48\x74\x02\xd1\x25\x90\x04\x62\x92\xc7\x12\x37\x76\x58\xac\x1b\xbb\x1f\x5d\xf5\x83\xbd\x89\x04\xfe\x9f\x61\x3f\xfd\x7f\xc8\xf7\x33\xdc\x87\xbf\x19\x9b\x8d\x5f\x1d\xca\x83\xee\x7e\xc1\xcd\x3e\xf7\x9c\x41\xa5\xd9\x4e\xf2\x5d\xcf\x71\x43\x6d\x29\x02\x5d\x9f\x42\xcc\x29\x24\xc5\xe6\xaf\x2f\x4b\xb1\x69\x02\xca\x52\x78\xc2\x19\xc8\x33\x06\x62\x60\x3e\x99\x81\x27\x3e\xe6\x30\xa9\x6b\xe4\xb2\x90\x4a\x0b\x72\x73\x0d\xe0\x9c\xf5\x1a\x1f\xaf\xc5\xdf\xf1\xbb\xe1\x9b\x10\x7f\x4f\x6f\x7c\x1f\x8e\xe4\x73\xdf\x71\x83\x6d\x49\x02\xb5\xa4\x90\x0b\x29\x64\x3d\xab\xe2\x67\xa2\xb3\xb0\x50\xb9\xd7\xc5\xd6\xb8\x7e\x17\x6c\xa9\xef\x1c\x74\xeb\x94\x9b\x0d\x3a\x45\xc9\xf3\xe1\x20\x99\x72\x5b\x3a\xa0\x5b\xc8\x05\x0b\x39\x69\x21\xcf\x58\x88\xd9\x42\x2c\x4c\x44\x16\x9b\xc6\x50\x66\x81\x8a\x4c\xe4\x19\x13\x31\xb1\x8a\x4c\x3c\x2a\x38\xd1\x2c\x29\xb8\x97\x94\xa4\xea\x7e\xac\xbe\x1d\xff\xa7\xf5\xed\xe9\x5b\x9f\x0f\xc7\x87\x83\xf4\x8a\x6d\xf1\x02\x1d\x07\x75\x60\x95\xcf\xb0\xca\x7c\x7e\x76\x3d\x18\x81\x2e\xf7\xfa\x75\x68\x5c\xbf\x63\x1d\x6c\x3d\xcb\xac\xca\x32\x26\xb2\x37\x2a\x06\x15\xb7\xd8\xb5\x8f\xfc\x99\xf3\x7d\x91\x0f\x33\x85\x09\x3c\xf6\x28\x5c\x27\x88\x17\x4b\x14\xf5\x8a\x91\x5c\x22\x57\x61\x4b\x8d\x31\x99\x22\x74\x1c\xa7\x8a\xa0\x49\xc9\x71\x01\xb5\xf6\x38\x21\x26\x2c\x3a\x3a\xb2\xda\x1e\x4d\x4d\x11\x61\x11\xd5\xf6\x30\x23\xf5\xab\xb1\xab\x68\x38\x3b\x77\xde\x13\x79\x4a\x72\xf1\xfb\x44\x8e\x95\x62\x99\x26\x19\xac\x26\x39\x80\x0e\x06\xc4\xf1\x0a\x8a\x6e\x62\xb1\x06\x83\x14\xf5\x5f\x7f\x34\x66\x43\x9a\x3d\x2a\xa0\x34\x75\xc4\x8c\xda\x79\x43\x1e\xee\xdc\xec\x6c\xdd\xbc\x99\x9c\xe1\x89\xfa\xc8\x9e\xe7\xd5\xc7\xbe\x30\x68\x49\xd6\xf3\xa6\xb0\x9a\x2a\xc1\xf6\x87\x5b\x32\x87\x76\x87\xba\x83\xf1\x2e\xbf\x75\x1b\xee\x03\x4e\x12\x4b\x15\x9b\x15\x43\xe1\xc9\x74\x9c\x2d\x35\xd4\xcf\x1c\xa2\x0b\x0c\xa4\x66\x1a\x1f\x17\x1d\x16\x64\x0a\xaa\xb6\xfb\x87\x6a\xa9\x31\xc2\x44\x75\x81\xc6\xc0\x6a\xbb\xd1\xc8\x69\xaa\xed\x02\x3c\x35\x15\xe6\xf4\xb4\xc1\x13\x15\x5d\x6e\x84\x15\x5f\xbe\x10\xaf\x16\x0c\x25\x3d\xd1\x78\x63\x88\x1c\x31\x38\x50\x49\x6f\xcb\x70\x44\x8e\x89\x33\x95\x46\xb4\x2d\xee\xde\xbf\x55\x8c\x03\xde\xf7\xf2\x1b\xb6\x92\x13\x9b\x5f\x11\x4b\x03\x7c\x88\xf0\x80\x4e\xbf\xb4\x65\x89\x90\xde\x9d\xe9\x66\xbc\xfb\x6f\xfc\xf7\x2c\x7c\xf4\x95\xfd\x9b\x5f\x60\x7b\x96\x5c\xe7\x15\x23\x40\x07\x09\xdc\x78\x5b\x8a\x5e\xa9\xf4\x4d\x30\xf9\x9a\x12\x93\x94\xbe\x1a\xdf\x6a\xbb\x46\x13\xe6\x1f\x16\x5b\x6d\x8f\x0c\x0b\xd0\x07\x04\xf0\xb5\xf6\x00\xc1\xdf\x0f\xda\x44\x39\xaf\xd8\x5f\x56\xaf\x03\x1f\xd8\x43\x96\x47\x0b\x44\xdf\x47\xe8\x03\x51\xea\x06\x3d\x17\x13\x9b\x44\xdd\xba\x11\xe2\x3f\x1f\xb5\xb7\x7d\xb3\xf3\x48\x65\x25\x69\xf3\x5f\x4a\x7c\x5a\x8e\xee\x13\xb7\x8a\x8f\xbf\x7b\x9f\x30\x32\x39\xa3\xfe\x86\xf7\xdf\xa6\xcf\x10\xdd\xe0\x02\xb1\x35\xb4\xa8\x28\x94\x4f\x0f\x2d\xba\x75\x78\xc5\x6b\xfb\xc4\x59\xe2\xc7\xe2\xa7\xc9\xc4\xf0\x80\x39\xf4\xd4\x05\x69\x9d\xe3\x0c\x37\x8a\xbb\x4c\x6f\xe6\x54\x5c\x00\x17\xf0\x9c\xaf\xf2\x55\x52\x04\xcf\x8a\x3c\x19\x8e\x07\xee\xc3\x73\xa8\x3e\xc6\x6c\x80\x7f\xd4\x2b\x3e\xd2\x65\xf1\xa2\x78\x85\xf8\x12\xcd\x0b\xa9\x99\xe9\x89\x89\xe9\x30\x3c\x7d\x2e\xd6\x90\x3f\x91\x8d\x62\xd3\x8e\x7b\xd7\xef\xd9\x73\xd7\x03\xb8\xae\x13\xc1\x4d\xe1\xce\xd2\x9b\x38\x1f\xce\xf4\x9c\x52\xb3\x8d\x14\x3d\xcf\x29\x14\x74\x1b\x29\x06\x6c\x03\xa2\xe7\x49\x0d\x55\xe5\xe6\x59\xed\xb7\x8b\x79\x6b\xd7\x9e\x9e\xfe\x37\xff\xe1\xc3\xfd\xf9\xa2\xcc\xe2\x3f\x20\x86\x9a\x9b\x42\x94\xf4\x16\x2e\x8c\x0b\xda\xe2\xef\x63\x60\xec\x85\x72\x04\x21\x0a\x99\xc6\x13\x62\x72\x87\x51\x8c\x5a\xcd\x0e\x86\x90\x1e\x92\xfd\x89\x0e\x9e\xba\x94\x22\x3f\x76\xf1\xf8\x94\x82\xdc\xdc\x84\xb0\x61\x0b\xc6\xaf\xb9\x23\xbd\x7e\x76\x2b\xe9\x9c\xb2\x60\x62\x47\xf3\xfc\x71\xc5\x23\xa2\x3b\xb6\x87\xb5\x36\x94\xcc\x6d\x99\x5a\xcd\x11\xd1\xc9\x8d\x26\xbe\x50\x4f\x02\xdb\xef\x18\xa7\x9f\x69\x98\x6b\xb8\xd1\x40\x7d\x0d\xe1\x86\x34\x03\x35\x18\x68\xb8\x29\x0a\x1a\xb0\xc5\x47\x09\xfc\x0f\xc7\x63\x11\x70\xa3\x4f\x65\xa5\x74\x8e\x1b\xf4\x1d\x0b\xc1\x63\xb4\x80\x17\x0b\xc9\xcd\x63\xe1\x89\xdc\x3c\xc9\xd1\xa7\x88\xef\xc6\x75\x9d\xb3\x54\x45\xe6\x8c\x81\xf7\x16\x96\xdb\x86\x0d\xcc\x69\x4b\x4c\x0f\x1b\xd6\x34\x83\xf8\x8f\x9b\xda\x5c\x47\xb2\xe7\x2d\x0d\xd9\x7f\x4b\xd8\xe3\xa5\x63\x14\xc2\x44\x41\x28\x2e\xfb\x43\x44\xe7\xf6\xb0\x37\xcb\x5b\xfc\xb5\xf5\xa8\xab\xb3\xdc\x64\x12\x4f\x57\x80\x3c\xfd\x39\xab\xcd\xc4\x09\x82\xfa\xef\x5a\x92\xae\x25\xbe\xda\x70\x2d\xaf\xd5\xf2\x4a\x5f\x3f\x3f\xe5\x2b\xc4\x06\xfa\x03\x01\x15\xe2\x82\x3d\xe3\xb1\x52\x5a\xde\xcb\x0b\x8a\xcb\x65\x31\x83\xe1\x09\x9e\xc6\x51\xeb\x7b\x4f\x88\x2f\x93\x96\x3f\x8c\xbf\x4c\x8f\x7c\x70\xe9\xd1\x47\xeb\xf8\x64\xe7\x37\xcb\xc8\x5b\xe2\xf3\x4c\xee\x84\x1b\x45\xfc\xe9\x32\xe8\x75\xe9\x2f\x19\x83\xc2\x38\x4e\x11\x1a\xbc\x8d\xd8\x6c\xbe\x7e\x03\xd5\xa5\x6a\x3e\x5e\x4d\xd4\x0a\x49\x12\x80\x5e\x88\x5b\xcb\xd9\x89\x62\xd4\x1c\xe4\x25\x0b\x29\x9c\xb8\x2a\x0e\xcf\xba\x19\xa8\x27\x51\x0f\xdc\xd9\xba\x40\x55\x1c\x9d\x3d\xa4\x7c\x58\xd1\x84\xcc\x8c\x52\xf2\x94\xf8\x68\x29\x9f\x7d\xbe\x73\x4d\xc8\xfe\x9b\xc3\x67\x4e\x9c\x3e\x21\x84\x3c\xb1\xfe\xdf\x7a\x4e\x6e\xef\x28\xd0\xfd\xcd\x78\x8a\x61\xa6\xcd\x18\x13\x18\x1d\x18\x1c\x4c\x0d\x4b\xfd\x89\xdd\xbf\xc5\x9f\xf7\xf7\x91\xac\x81\xca\xc6\x0a\x8c\xc8\xaf\x29\x7a\xe2\xf7\x4a\x71\xd8\xe3\xa4\x20\xed\x18\x72\xd5\xcd\x14\x98\x32\x51\xde\xb2\xec\xd6\x07\xc7\xdd\x39\xa3\x66\xfa\xb0\xb0\xb4\xb4\x41\x15\xea\xa2\xa2\xf9\x5d\xa2\x98\x1e\x9b\x69\xb1\xa4\x67\x93\x71\x2b\x1c\xfb\xf7\xad\xfe\x67\x7d\xd8\xf6\xce\x88\xff\xb7\x2e\x62\xb9\xf8\xce\xf4\x69\x15\xd3\xfc\x85\x47\xff\x26\xad\x5b\x0a\x60\x9b\x61\x20\x23\x35\x17\xf0\x32\xa7\x24\xc5\x5b\xd4\x2c\x2c\xa7\x0d\xad\x03\x44\x01\xc2\x0e\x22\x71\x24\xe6\xad\x01\x7c\xb0\xb8\xe7\x31\x32\x51\xdc\xc1\xaf\xfd\xda\xe2\xf4\xe1\xef\x95\xd6\x84\xbe\x82\xf6\x05\xd3\x5b\xe5\x35\xba\x54\x9b\x9e\xfa\xfb\x87\xcd\x48\x9f\x93\xbe\x2c\x9d\xa6\xa7\x6b\x12\x03\x59\xfb\xcc\x9c\x46\x6e\x1f\x53\xa5\xd5\xdd\x3a\x15\x0b\xf7\xa7\x8c\x33\xb3\x68\xdf\xee\x98\x80\xde\x7d\xd4\x3b\x4d\x84\xa2\xc1\xb6\x8a\x5b\x37\x88\x5f\x8f\x29\x2a\xb0\x39\x96\xdd\xb8\x66\x53\x5a\x7e\x5e\x42\x42\x5e\x7e\x5a\x40\x4c\x66\x66\x64\x64\xa6\xc5\xcc\x6f\x2d\xae\x0c\x0a\x69\xbe\xa1\xbd\xfd\xd3\xf1\x2d\x21\xc1\x95\xc3\xeb\xda\x16\x8a\x61\x93\xa7\x4c\x99\x3c\xb1\xbc\x9c\x1c\x2d\x1a\x33\xa6\x68\xc4\x98\x31\x92\x5e\x8e\xc2\x98\xf1\x83\x5b\x2f\x2f\x46\xfb\x18\xfd\xfc\x42\x8d\xd0\x3b\x5e\x54\xbd\x48\xdf\xa4\x3c\xdd\xe6\xfa\x6c\xab\x56\x5f\x46\x39\x34\x90\x9c\xb4\xca\x9c\x42\x2b\x6e\xed\xce\xce\x4a\x8a\x65\x0b\x68\x8c\xa9\xbc\x9e\x00\xcb\xac\xc7\x52\xf7\x81\x80\xa0\x9d\xc2\x36\xa6\x8f\x02\x59\x1f\x77\xac\x5c\xbf\x66\xdc\x9d\xc5\xb2\x52\x46\xc9\xca\xb8\xa9\x63\xe5\xaa\x9d\xef\x83\x72\xf8\x6f\xbd\x94\x42\x5c\xbb\x94\x02\x7f\x4e\x29\x9d\xc7\xcc\x29\x88\xc0\xe3\xe7\xc7\xc4\xb3\xb1\x83\x3f\xc7\xbe\xdc\x56\x0a\xe3\xd9\x7a\x02\x59\xcb\x57\xf3\xf9\x46\x25\xc6\xe2\x23\xae\xf1\x42\x35\xb7\x5d\x71\x0b\x67\xe4\x22\x6d\x7a\x1f\x95\x4a\xaf\xe3\xa3\x79\x9e\xd7\x69\xa2\x35\xbc\x86\xb3\x54\xba\xe3\xf2\x50\x89\x69\xe8\xdc\x49\x72\x3f\x57\x3d\x3b\x66\x5a\x75\xdb\x33\x3e\x33\x7d\xe3\xd3\x63\x0b\x8b\xb3\x15\xb3\xc3\x86\x0f\x6e\xd5\xa5\x36\x29\x55\x61\x21\x19\x3a\x8e\x67\x35\x08\x87\x15\x65\x9c\x02\xac\x65\x9c\x2d\x59\xc9\x0b\x54\xad\x52\x28\xd4\x3c\xd5\xf8\x34\xa9\x17\xab\xf9\x01\xea\x12\xf5\x24\x35\xe5\xd4\x7a\xb5\x59\x4d\xd5\x02\x65\x51\xfe\x95\xe0\x5d\xbf\x10\x16\x55\xa6\x24\x46\xae\x70\x7f\x5a\x4e\x0e\x48\x92\x9d\x28\x69\xe8\x75\xc0\x51\x0a\xc9\x65\x67\xb2\xc7\x10\xe1\xf0\xd5\xc1\x64\x1f\x89\x25\x47\xae\xee\xe4\xbf\x11\x57\xd5\x0a\xe7\xae\x86\x06\x0b\x0a\xb6\x26\x2d\x54\xf1\x5a\xc5\x41\xa8\xdd\x9f\x45\x30\x64\x3b\x40\xfc\x38\x9d\x32\x5a\xc9\x2b\x59\xfc\x33\xb6\xb2\xca\x24\x04\x03\x31\xeb\x2e\x2a\x69\xe5\x59\x7c\x4d\x8a\x17\x4d\x3e\x62\xd1\x7e\xaa\x62\x44\x31\x66\xcd\x9a\xc7\xe5\x35\x66\xde\xf9\xad\x50\x45\x4a\x7a\x30\x59\xd8\x6b\x3f\xea\x89\xfe\x96\x23\x63\x06\x24\xa9\xe2\x10\x36\x01\xd7\xdc\x2f\x5f\xbe\x5c\x7e\xec\xf0\x07\xce\x55\x07\x76\x36\x08\x55\x6b\xd6\x30\xd0\xc7\xd9\xd2\xbb\x64\x5b\xc0\x27\x39\x84\x98\xe1\xa0\x05\x7f\x95\x51\xc9\xf3\xa1\xbe\x7d\x38\x45\x53\xf2\xf0\x4a\xae\x55\x87\x87\xf1\x67\xad\xa3\xcb\xa6\xdc\xaa\x2a\xd5\x44\xc4\x86\x66\x59\x13\xdc\x6d\x20\x35\x81\xd6\xcc\xc9\x3e\xe6\x0a\x85\x22\xd0\x18\xeb\x8b\xf5\x16\x91\x62\x65\x28\xd4\x1b\xcd\x59\x6c\xe1\x91\xfe\x41\x41\x61\x46\x8d\x86\x28\x6c\x1a\x6d\x19\xcc\x5a\xac\x59\x85\x5c\x35\x27\x60\xd3\x72\x2c\x69\xb8\x2f\xc1\x8a\x51\x76\x3c\x2d\xa4\xfd\x2d\x97\x9f\x39\x73\xa6\xfc\xcd\x43\x7b\x5e\xe8\x7f\x75\x5c\x28\x9a\x37\x2f\x66\xfb\xf6\x18\x42\x7a\x2d\x8a\xa3\x2c\x3e\x12\x46\x90\x58\x90\x85\x02\xe6\xe6\x68\x9b\x41\xef\xe3\xe3\xef\xcf\x51\x26\x8a\x42\x65\xb5\x52\x60\xe2\x90\x43\xfd\xb8\x5f\x49\x98\xd8\x31\x81\xf8\x8e\x84\xbd\x22\x99\x06\x5a\xe3\xa7\xac\x1e\xc5\xd7\x1b\x6a\x2a\xee\x49\xaf\x53\xfc\x59\x21\x30\xe5\xbd\x3e\xb4\xa5\x30\x75\x40\x55\xd3\xca\x5f\x58\x87\xf4\xd2\x44\xd5\xab\x0e\xf6\xfa\xc4\xde\xa7\x0e\xa6\xcd\xfe\xea\xd0\xc2\x60\x96\x60\x0b\xf4\x09\x0e\x52\xc3\xd4\x15\xa5\x57\xf7\x16\x2a\x0b\x08\x65\x91\x0e\xa6\x34\xf4\xaa\xa3\x1f\x05\xf7\xaa\x51\xfc\x5f\x1f\x2d\x8f\x70\x57\x4e\xba\xae\xd5\xf3\x08\xd0\x73\x1c\x8c\xb9\xf1\x5c\x91\x2d\xd5\xa0\x29\xe4\xc6\x31\x7b\x8d\x79\x27\xfc\x64\xf8\x85\x70\x1a\x1e\x1e\x1d\x1d\xa8\x78\xd6\x8f\x48\xaf\x6c\x74\xa6\x68\x53\xa1\xa9\xda\x24\x98\x98\x20\xd8\xe2\x3c\x93\x05\x3b\x29\x6d\xc1\x75\xdf\xda\x90\x5e\xcc\x5f\xef\xed\xcd\xc1\xde\x42\x2b\xef\xa5\x7e\xf1\x07\x8f\xf8\x5c\x2e\xd7\xf0\x5e\xf1\x7e\x13\x85\x6f\x1e\xf3\x44\xfd\xe5\xae\xbd\xae\x64\xd7\xfb\x8d\x2b\xfc\x35\x59\x4d\xfd\xfa\xc9\xff\x8c\x3c\xce\x7f\xc5\xe2\x0a\x8b\x85\x2c\xbe\xad\x31\x51\x7d\x09\xf3\x3f\x67\xdf\x50\x60\x7e\x45\xaf\xfc\xaf\xf8\x9b\xe5\xfc\x4d\xbd\xf2\xbf\x84\x7c\xbf\x7e\x62\x5e\xf7\x1b\xd3\x99\x53\x8a\x61\xa2\x8d\xfc\xc7\xf5\x95\x7c\xe6\x6e\x12\x67\x05\x63\xc8\xb0\x99\xa8\x46\x13\xaf\xcf\x26\xcf\x66\xbf\x91\xcd\x67\xc7\x84\x87\xe7\x05\xe9\x74\x43\x13\xf2\x30\x04\xa9\xe4\x27\xef\xab\x5c\x00\x5d\x90\x8d\x01\x5e\xf1\xb2\xa8\x57\x3a\xc1\x2b\xcd\xb6\xf2\xe5\x79\xfd\x0e\xf0\x8e\xb1\xf5\x70\x41\x62\x52\xfe\xa0\xe4\xe4\x41\x37\x0f\x4a\x96\x12\x44\xed\x49\xf9\xaf\x2f\x77\xa7\x79\x77\x39\x71\x73\x4a\xde\xa0\xe4\xf8\x82\x02\xa2\x48\x19\x34\x28\x05\x12\xf1\xf2\x5f\xf1\x2c\x59\x2f\xce\x1f\x2f\xff\x22\x81\x72\x39\x4e\x10\xab\xa1\x9d\xeb\xa1\x9d\x14\xbd\xec\x68\x2e\xc6\x66\xa0\x1c\xe7\x2b\xe8\x0d\xe4\x59\xc3\x1b\x06\xde\x10\xa9\x30\xb1\xd6\x61\xb3\xb0\xa7\x29\xc0\x61\x52\xfc\x18\xdf\xd5\xa4\x4c\xdc\x46\xee\xee\x87\xc1\xdc\xb5\x17\xaf\xc7\xc7\x54\x99\x0f\x95\x2c\xf1\x68\x9b\x1e\x9c\x52\x9d\x3e\x88\x3c\x1b\xf4\x46\x10\x1f\x14\xa3\x09\xf7\x62\x83\x8d\xb0\xcc\x85\x89\x0b\x32\xfd\x18\x27\xff\x6c\x22\xd3\xea\xfe\xda\x9f\xa4\xf6\x2e\x5a\xbb\x76\xd1\xf2\xfe\x99\x61\xe3\x1b\x37\xc6\x75\x8a\x7e\xa8\xf8\x23\x97\xce\x4e\x54\xc5\x90\xc5\x4a\x16\x78\xd3\x14\x45\x59\xd8\xe3\xb8\x58\x16\x26\x7f\x18\x9f\x97\x49\xd9\x1f\x16\xe8\x9e\x30\x0f\x61\x18\xcf\x02\x7f\xfa\x53\xea\x1b\x5c\x9a\x51\x58\x92\x58\x3c\x2d\x3b\x7f\xda\x90\xe8\x11\xcb\x9e\x6c\xa8\x7f\xbc\x73\xf8\x00\xfb\xe2\xa2\xf0\x41\xe9\x11\x99\x33\x1c\x33\xc6\xdc\xeb\x2f\x9a\x2a\xc7\x26\x15\xa6\x87\xd4\x74\x98\x32\x12\x4c\x0a\x3f\x43\x78\xd9\xa0\x8c\x8a\x31\x63\xd3\x72\xea\x5b\x57\x8d\x6b\xfb\x7b\xfb\xe0\x41\xf3\x36\xb5\x4c\x72\xcc\xb9\x21\x32\x74\xc4\xf8\xe9\x96\x21\xb3\xc6\xa4\x15\xf9\x75\x0f\xfb\xc7\xa6\xd4\x71\x0b\xcb\x3a\xde\x9c\x1c\x38\xbc\xba\x13\x9f\xbc\xb9\xc0\x49\x1c\xa1\xb5\x7e\xec\x63\xfd\x52\xd0\x65\xbc\x6b\x1d\xd0\x3c\xd7\x71\xa0\xf9\x48\x0b\x90\x0e\x71\x6d\xe5\x28\x1d\xcc\xae\xd2\x12\xa4\x23\x91\x56\x20\x9d\xc2\xca\xd0\xa9\x58\xa6\x12\x68\x20\x17\x08\xf9\xf1\x1c\x45\x9a\xe7\x6a\x06\x9a\x2f\x5e\x06\x5a\xe0\x8a\x04\x3a\xc4\x55\x02\xd4\x8e\xf9\xd3\x91\xce\x64\x54\x75\x06\x68\x0a\xdc\xb5\x15\xa8\x0e\xca\xa4\x70\x06\xa4\xf1\x90\x6f\x41\x34\x0b\xa0\x95\x00\xcd\x47\x5a\x80\x74\x08\xd2\x99\xec\x2a\x20\x94\x40\x8f\x63\x25\xad\x88\x60\x45\x04\x2b\x22\xe4\xc2\xbd\xdb\x80\xe6\x23\x2d\x40\x3a\x04\xe9\x4c\xa0\x79\x70\xd7\x71\xa0\x3a\x28\x99\xc7\xe9\xe1\xae\x3c\xb8\x97\xa5\x23\x91\x46\x21\x8d\x47\x9a\x83\x25\x4b\xb0\x4c\x29\xd2\x32\xa4\xe5\x98\x3f\x01\xd3\x93\xb1\xe4\x14\x4c\x4f\x43\x3a\x1d\x73\x58\x4b\xf3\xb1\xae\x7c\x4e\x07\x32\xc9\x87\xba\x58\x8e\x01\xd3\x91\x50\x32\x1f\xea\x62\x34\x1e\x73\x72\x5c\x47\x80\x96\x60\x4e\x19\xd2\x72\x90\x4f\x3e\xd6\x92\x8f\xb5\xe4\x23\x7e\x3e\x20\x97\x70\x05\x88\x5c\x80\x6d\x2f\x00\xe4\xad\x40\x0d\x98\x8e\x04\x99\x14\x00\x32\xa3\xf1\xa0\x85\x02\xae\x04\xd3\x65\x48\xcb\xf1\xae\x09\x98\x9e\x8c\xe9\x69\x48\x67\x02\xc2\x10\xd4\xc8\x10\xc4\x1c\x82\x92\x19\x82\x98\x43\x90\xdb\x21\xc8\xed\x10\xc0\x64\xb4\x04\x90\x87\x00\x26\xa3\xe5\x78\xd7\x04\x4c\x4f\xc4\xab\x93\x30\x3d\x0d\xd3\x76\x48\x8f\x52\x9d\xe1\x16\x70\x93\x91\xe7\xc9\x88\x3f\x19\x79\x9e\x8c\xf8\x93\x41\xb6\x2c\xbf\x0c\xe9\x04\xa4\x93\x18\x85\xbb\x12\x38\x3b\x94\x5f\x07\xd4\x00\x74\x3a\xa6\xa7\x63\x7a\x26\xa6\x67\xb2\x34\x1d\xcc\x2c\x81\x0e\xa6\x63\x5c\xb7\x01\x9d\x80\x74\x8a\x2b\x1f\xe8\x54\xf1\x0a\xd0\x69\xae\xd9\x40\x2b\x31\xdd\xe8\x5a\x09\xb4\xcd\xd5\x0c\xb4\xcb\xf5\x2c\xb5\x81\x3d\xef\x05\x5a\x09\xb4\x88\x0e\xe7\xe6\x01\x2d\x11\xbf\x02\x3a\xd2\x65\x04\x5a\x81\xe9\x2a\x57\x34\xd0\x1a\xd7\x13\x40\x6b\x5d\x5b\x81\xd6\x63\x4e\x13\xd2\x16\xcc\x9f\x83\x74\x2e\xd2\x56\xa8\xbd\x88\x2e\xc0\xab\x8b\x90\x2e\x41\xba\x02\x68\x09\x72\x5b\x82\xdc\x96\x20\xb7\x25\xc8\x6d\x09\x72\x5b\x82\xdc\x96\x20\xb7\x25\xc8\x6d\x09\x72\x5b\x82\xdc\x96\xb0\xbe\x43\x4b\x99\xa6\x80\xea\x5c\x6a\xa0\x06\x46\x81\xf3\xb5\x40\x4b\xc4\x8b\x40\x47\xba\xfc\x80\x56\x60\x7a\x8e\xeb\x15\x3a\x12\x6b\x1c\x09\x35\xee\x05\x3a\xc1\xf5\x0e\xd0\x29\xae\x05\x40\xa7\xba\xf2\x80\x56\x02\x1d\x03\xfd\x7d\x36\xd0\x91\x50\x7e\x0c\xf4\x77\x96\x66\x92\x19\x83\x92\x19\x0b\xf7\x3e\x01\x74\x02\xd2\x69\xae\x99\x40\xab\x5c\xc7\x80\xd6\x23\x6d\x42\xda\x8c\x74\x36\xd2\xf9\x48\x17\x20\x5d\x84\x74\x09\xd2\x65\x48\x57\x20\x5d\x05\xb4\x02\xe5\x50\x81\x72\xa8\x40\x39\x54\xa0\x1c\x2a\x50\x02\x13\x90\xab\x09\xc8\xd5\x04\xe4\x6a\x02\x72\x35\x01\xb9\x9a\x84\xed\x9a\x04\x72\x28\x05\x6a\x60\x14\x24\x70\x08\xe8\x48\x97\x05\x68\x05\xa4\x27\xd3\xc5\xae\x47\xe8\x14\x66\x7b\x40\xa1\xd7\x03\xd5\x43\xc9\x29\xac\xd7\x03\x8d\x44\x1a\xc5\x28\xc8\xb0\x13\x68\x09\xf0\x30\x05\x10\xe6\x01\x1d\xc3\xee\x82\x7a\x59\xce\x04\x4c\x4f\x43\x3a\x03\x69\x15\xc3\xa1\xd5\x48\xeb\x91\x36\x22\x4e\x13\xc8\x67\x0a\x9d\x85\x39\x2d\xae\xfb\x80\xce\xc1\xf2\xad\x98\x6e\xc3\x32\x0b\xf0\xea\x22\xa4\x9d\xae\xbb\x81\x2e\xc1\x74\x17\x5e\x5d\x8a\x25\x97\x23\x5d\x81\xf9\x2b\x21\x3d\x15\x5b\x3a\x15\xf9\x9f\x8a\xed\x9d\x0a\xfc\x33\x1a\xc5\x28\x5a\xef\x54\xb4\xde\xa9\x68\xbd\x53\x81\xff\x17\x81\x56\x60\xce\x04\x4c\x4f\x03\x0d\x4e\x05\xfe\xf7\x02\x65\x56\x3d\x15\xad\x7a\x2a\x5a\xf5\x54\xb4\xea\xa9\xd0\x8a\xd9\x40\x9b\x30\xdd\x82\x57\xe7\xe0\xd5\xb9\x98\x66\xb6\x3d\x15\x6d\x7b\x2a\xda\xf6\x54\xb4\xed\xa9\x68\xdb\xd3\x40\x7a\x15\x40\xa7\xba\xce\x02\xad\x04\x6a\x47\x8d\xdb\x51\xd7\xd3\xa1\xc6\xdb\x80\xd6\x23\x6d\x42\x3a\x1b\xf3\x17\x60\x7a\x11\xd2\x25\x48\x97\x21\x5d\x81\x74\x15\xd0\x19\x88\x39\x03\x31\x2b\xb1\xa5\x95\xd8\xd2\x4a\x6c\x69\x25\xb6\xb4\x12\x5b\x5a\x89\x2d\xad\xc4\x96\x56\x62\x4b\x2b\xb1\xa5\x95\xd8\xd2\x4a\x6c\x69\x25\xb6\xb4\x12\xdb\x58\x89\x6d\xac\xc4\xfe\x5b\x89\x6d\xac\xc4\x36\x56\x62\x1b\x2b\xb1\x8d\x95\xd8\xc6\x4a\x6c\x63\x13\xe8\xe8\x1c\x6d\x06\xcc\x57\x80\xd6\xb8\x76\x03\xad\xc7\x74\x23\xf0\xd9\x0c\x98\x2c\xdd\x82\xf9\xb3\x31\x3d\x07\x7a\x5c\x33\x20\x33\xda\x86\x65\x16\x60\xfe\x22\xa4\x8b\x5d\x8b\x80\x2e\xc1\xf4\x32\xa4\x2b\x90\xae\x02\x3a\x17\x6a\xd9\x0d\xb4\x1e\x69\x13\xd2\xd9\xe0\xa1\xce\x05\x04\x96\xee\x40\xba\x08\xe9\x12\xa4\xcb\x90\xae\x40\xba\x0a\xe8\x3c\x5a\x07\xe5\xe7\x81\x8d\x31\xba\x1c\xe9\x4a\xa0\xf3\x01\xf9\x09\xa0\x35\xae\x43\x40\xeb\x31\xdd\x84\x94\xf5\xe2\xf9\xc0\x3f\xcb\x5f\x80\x39\x8b\x90\x2e\x41\xba\x02\xe8\x02\x94\xc0\x12\xa4\x5d\xc8\x61\x17\x72\xd8\x85\x1c\x76\x41\xdf\xdf\x09\x74\x01\xa6\x3b\x90\x2e\x42\xba\x04\xe9\x32\xa4\x2b\x90\x32\x0e\x97\x21\xce\x0a\xa4\xab\x90\x6e\x85\x19\xf3\x2c\x50\x03\xd2\x79\x30\x06\x6e\xe5\x96\xbb\xf6\xd3\xad\xaa\x93\x40\x5f\x81\x31\x70\x23\x7d\x15\xe9\x76\xfa\x16\xe4\x6c\xa7\xef\x60\xfa\x5d\x4c\x1f\xc4\xf4\x21\x57\x39\xd0\xf7\x90\x1e\x06\x84\xed\xf4\xa8\xf8\x36\xd0\x8f\xb0\xcc\x27\x60\x45\xdb\xe9\x29\xd7\xfd\x40\x3f\xc5\x9c\x0b\x98\xbe\x88\xe9\x6f\x11\xe1\x12\xd2\xef\x5c\x5b\xe8\x76\xa8\xab\x9c\xee\xa0\xdb\xe1\xae\x1d\x74\x37\xe4\xec\xa0\x7b\xa0\xe4\x0e\xba\x0f\xe9\x3b\xae\x8b\x40\x0f\x22\x3d\x84\x65\xde\x73\x6d\x03\x7a\xd8\xf5\x09\xd0\xf7\xb1\xcc\x51\x40\xdb\x41\x8f\xe3\xbd\x1f\xbb\x5e\x03\x7a\x16\xf3\xcf\x63\xf9\x4b\x90\xde\x09\xf8\x2b\x81\x32\xfc\x9d\x88\xbf\x13\xf0\x59\x9a\x61\xee\x04\xcc\xe9\x40\xdf\xc7\x7c\x86\xb6\x13\xd0\xee\x06\xfa\x31\xa6\xcf\x62\xfe\x25\x2c\xf9\x3d\xd2\xcb\x90\xb3\x0b\x46\x8c\x50\xa0\x06\xa4\x4c\x92\xbb\x50\x92\xbb\xa0\xae\x18\xa0\xbb\xa1\x5d\xbb\xe8\x5b\x9c\x15\xe8\x3e\x71\x2f\xd0\xfd\x70\xef\x2e\x68\x11\x2b\x73\x10\xd3\x1f\xbb\x9a\x80\x7e\x82\x25\x4f\x03\x3f\xbb\xa0\x2e\x96\xf3\xa9\xab\x01\xe8\xe7\x98\x73\x9e\xe1\xd3\x2f\x31\xfd\x15\xd2\x0b\x58\xfe\x1b\x56\x23\x70\xc5\x72\xba\x31\xed\x44\xea\x02\x9e\x77\x09\x1c\xc3\x41\x9d\xee\x46\x1e\x76\xd3\xf7\xb8\x50\xa0\x87\xa1\xde\xdd\xf4\x23\xcc\xf9\x14\x73\x3e\x83\xf4\x9b\x50\x26\x14\xe8\x3e\xb8\xba\x07\xf5\xbe\x07\xf9\xdc\x03\x7c\x32\x7a\xc8\x75\x02\xe8\x7b\x60\xdb\x7b\x40\x32\xe7\x81\x7e\x82\xf9\xa7\xa0\xae\x3d\xc0\xed\xfd\x40\x2f\x40\x8d\x7b\x80\x9f\x06\xfa\x16\xb4\xfd\x66\xa0\x7b\x00\xed\x2d\xc0\x7c\x1c\xe8\x7b\x50\xfe\x2d\x90\xed\x16\xa0\x1f\x23\x3d\x8b\x39\x4c\x47\x7b\xb1\xae\xbd\x58\xd7\x5e\x28\x79\x04\xe8\x61\x18\xab\xf7\x42\x79\x76\xf5\x23\xe0\x6d\x2f\xda\xd5\x5e\xa8\x6b\x0b\xd0\xcf\x30\x7d\x01\x6a\xdf\x8b\x76\xb5\x17\xec\x8a\xd1\x4b\x48\x45\xb8\xba\x0f\x5b\xba\x0f\x38\x64\xf4\x53\xb0\x9f\x7d\x50\x7e\x3f\x50\x56\x66\x3f\x5e\xdd\x0f\xf9\x8c\x5e\x40\x7a\x09\xe9\x65\xc0\xdf\x4f\x45\xa8\xf1\x1d\xd0\xe3\x46\xa0\xbb\x91\x32\x9b\x79\x07\xda\xc2\xd2\x07\xf1\xea\x7b\xae\x3b\x80\x1e\xc6\xf4\xfb\xae\x1a\xa0\x47\xb1\xcc\xc7\x58\xe6\x2c\xa0\xbd\x43\xcf\xc1\xd5\x03\x60\x27\x1c\x50\x03\xd2\x48\xae\x1c\x68\x14\xd2\xe5\x20\xf9\x03\x74\x3b\xcc\xc5\x07\xa0\x96\x04\xa0\x7b\xc0\xb6\x0f\xa0\x2e\x0e\x80\xcd\xec\x07\xba\x1f\x46\x8c\x03\x20\x9f\x4b\x40\x0f\x62\xfe\x21\xa4\x4c\x9e\x07\xa0\x15\x27\x80\xbe\x0f\xb6\x7a\x00\xeb\x3d\x00\xf5\x6e\x01\xca\xda\x75\x00\xdb\x7b\x00\xda\x02\xb5\x80\x3d\x80\x7c\xb1\x45\x07\xb1\x45\x07\xb1\x7f\x1d\x04\x9c\xb3\x40\xdf\xc7\xab\x47\x31\xe7\x38\xe6\x9c\x82\x5a\x0e\xa2\x85\x1c\xa4\x17\x91\x7e\x8b\xf9\x97\xb0\xcc\x65\x4c\x33\x29\x1d\x82\xd6\x59\x81\x1a\x90\xce\x03\xe4\x43\xd0\x0b\xf6\xd2\x43\x58\xd7\x21\xa8\x6b\x25\xd0\x7d\x98\x66\xf6\x7f\x08\xda\xc2\xe8\x61\x18\x03\x0f\xa1\x25\x1c\x42\x5b\x3a\x04\xf6\xcf\xca\x7c\x8a\x39\x9f\x63\xce\x17\x48\xcf\x63\xfe\x97\x98\xbe\xe0\xfa\x0b\xd0\xaf\xb1\xcc\x37\x48\x2f\x22\xbd\x84\x65\xbe\x47\x7a\x05\x73\xba\x31\xed\xc4\xda\x59\x8f\x38\x04\x12\xd8\x02\x7d\x40\x27\x32\x6a\x40\x1a\x89\x39\x51\x48\xe7\x41\x9f\x7a\x0f\x38\x5f\x49\xdf\x03\x8d\x74\x01\xdd\xed\xca\x06\xfa\x16\x70\xfb\x1e\xe8\xe2\x22\x50\x36\x12\xbe\x87\x96\xf9\x1e\x8c\x75\x2c\xff\x63\x76\x17\xd8\x18\x20\x00\xff\xd3\x80\x9e\x41\x7a\xd6\x35\x18\xe8\xa7\xae\x38\xa0\xe7\x10\xf3\x33\xcc\xff\x1c\xe9\x7f\xb1\xfc\x17\x98\x66\xbd\xfb\x3d\x68\x1d\x4b\x7f\x85\xf4\x02\xde\xf5\x35\xa6\xbf\x41\x7a\x11\x73\xbe\xc7\xf4\xff\x90\xfe\x80\xf4\x0a\x52\x17\xa3\xd0\x3a\xa8\x11\xfb\xfb\x61\x1c\xeb\x0e\xe3\xf8\x73\x18\x24\xdf\x04\xf4\x1d\xd0\xd4\x61\xe8\xc5\xec\xea\x7b\xd0\x43\x0f\x83\xae\x59\x19\x66\x33\x87\x51\xc2\xef\x63\xaf\x7f\x1f\xda\x78\x3f\xd0\x83\xc0\xe1\xfb\xd0\xd2\x05\x40\x59\x4b\xdf\x07\xae\xb6\x03\x65\xa3\xcd\x11\xd4\xe0\x07\xf4\x12\x60\x1e\x07\x84\x35\xf4\x38\x8c\xe1\x2b\xe9\x09\xa8\xf7\x09\xa0\xbb\xc1\xc3\x81\xd1\x02\x73\xde\x82\xf2\x27\x80\x87\xa7\x81\xee\x47\xca\x7a\xfa\x09\xec\xe9\x27\x80\x9f\x26\xa0\xef\x83\x37\x78\x02\xf8\x09\x07\xca\xea\x3a\x01\x98\x77\xd3\x13\x88\xf9\x11\xa0\x4d\x02\xca\x7a\xdf\x47\xd8\x2f\x3e\x02\x34\x96\xff\x0e\xa6\x0f\x73\x3e\x40\xdf\x07\x9e\x3f\x82\xbb\x66\x03\x3d\x8b\x25\xd9\xa8\x72\x12\xf8\xd9\x02\x74\x37\xd4\x72\x12\x10\x16\x00\x65\x76\x78\x12\xef\x3d\x89\xd2\x38\x09\xf7\x96\x02\x3d\x8a\x25\xcf\x62\xce\x39\xbc\xca\x10\x3e\xa1\xe7\x39\x23\xd0\xaf\x31\xfd\x2d\x58\xf5\x27\x20\x81\xfb\x81\x5e\x86\xb6\x9c\xc2\xf2\xa7\xb0\xaf\x9d\x02\x2d\xb3\xf4\x79\xa4\x5f\xc2\x08\x76\x0a\x47\x95\x53\x28\xb1\x53\xa0\x3b\x46\x2f\x23\xbd\xca\xca\x80\xbe\xf6\xd3\xd3\x38\x3a\x9d\x46\x9c\xd3\x80\xb0\x1b\xe8\x79\xcc\xf9\x12\xfa\xf5\x69\x40\xb8\x08\x94\xf5\xbe\xd3\x38\xbe\x9d\x06\xb4\x57\x80\x7e\x07\xa3\xc1\x69\x44\x3b\x8d\x68\xa7\x01\xed\x2c\x3d\x83\xf3\xd1\x19\x9c\x8f\xce\x00\xe6\x46\xa0\x8c\xb7\x33\x80\x79\x3f\xd0\x2f\x31\xcd\xc6\x84\x33\x58\xfb\x59\x18\xf9\x43\x81\xb2\xf1\xe1\x53\x1c\xaf\x3e\xc5\xba\x3e\xc5\x3e\xfe\x29\xfd\x0e\xd3\xdf\x43\x5b\x3e\xc5\xf9\xee\x1c\x72\x7b\x0e\x31\xcf\xe1\xbd\xe7\x10\xed\x1c\xd8\xe7\x71\xa0\x52\x99\xab\x70\xf5\x33\x40\x3b\x0e\xf4\x1c\x52\x56\xf2\x33\xa8\xfd\x34\xd0\x0b\xc0\xf9\x67\x80\x7f\x18\xe8\x77\xd0\xba\xcf\xe0\xae\x23\x40\xaf\x42\x7b\xbf\x80\x3e\xb8\x97\x7e\x01\xa3\xc1\x27\x40\x4f\x01\xda\x17\xe8\x3f\x7c\x81\xa3\xfd\x17\x28\xcf\x2f\x70\xb4\xff\x02\x10\x4e\x03\xfd\x0e\xd3\x97\xe1\xd9\xed\x0b\x1c\xf3\xbf\x84\x7b\x2f\x02\xbd\x80\x69\x36\x3a\x5d\x80\x5e\x09\xe3\x3b\xf0\xb3\x1b\xe8\x39\x4c\x33\x09\x5f\x00\x7e\x8e\x01\xfd\x16\xd3\x4c\x47\x17\xa0\xa5\xec\xea\x65\xe0\xe1\x82\x74\x2f\x48\xe9\x18\xfd\x06\x25\xf3\x0d\xb6\xe2\x1b\xd4\xef\x37\x70\xef\x27\x40\xbf\xc5\xfc\x4b\x48\x59\xdb\x2f\xd2\x4f\xa0\xcc\x45\x1c\x39\x2f\xe2\xc8\x79\x11\xe7\xd6\x8b\x58\xe6\x22\x70\xcb\xe8\xf7\x48\x59\xab\x2f\x62\x2d\xdf\x82\xd6\x9a\x80\x1a\x18\x45\x84\x6f\xb1\xc6\x6f\xd1\x0e\xbf\xc5\x7a\xbf\xc5\x7a\xbf\xc5\x76\x7d\x4b\xbf\xc1\x9c\x8b\x48\x2f\x61\x0e\xd3\xe0\xb7\x68\x03\x97\x70\x34\xbe\x84\xa3\xf1\x25\x18\xdf\x58\x4e\x14\x52\x36\xd7\x5c\xc2\x39\xf4\x12\xea\xf1\x12\xd4\xb2\x12\xe8\xa7\xd0\xaf\x2f\x81\x64\x58\x0e\xab\xe5\x12\xda\xc9\x25\xd4\xec\x25\x90\x36\xbb\xca\xe4\x7c\x09\x6d\xe6\x3b\xb4\xd5\xef\xb0\xe4\x77\x68\x27\xdf\x41\x5b\xde\xa6\xdf\x61\xed\xdf\x23\xfe\xf7\x38\x1e\x7e\x8f\xba\xfb\x1e\x75\xf7\x3d\xa0\xb1\x9c\x8b\xa0\x85\xef\xd1\x92\xbf\x47\x99\x7f\x8f\x1e\xe0\xf7\x80\xb0\x11\xe8\x55\x4c\x33\x3d\xfe\x0f\x5b\xed\x84\x92\x5b\x80\x5e\x86\xf1\x4a\x84\x7a\xef\x03\x7a\x0e\xe6\x5c\x11\x6a\x3f\x0e\xf4\x4b\xd7\x57\x40\x59\x5f\x10\x41\xaa\xcf\x52\x11\x79\x70\x41\xc9\xb5\x40\x99\xae\x5d\xc8\xa7\x0b\x5b\xe4\xa2\x17\x00\xd3\x85\x5a\x73\xe1\x5d\x2e\xbc\xcb\xc5\xfa\x91\xa0\x63\x72\x03\x6a\x40\xba\x9c\x0b\x15\x8a\x20\x27\x17\xa8\x01\x69\xa4\x6b\x3f\xd0\x28\xa4\x30\x53\x00\x5d\x0e\x77\x15\xb1\xf1\x56\x75\x5a\x75\xda\xd5\xac\x3a\x03\x4f\xc1\x8c\x4e\x71\x6d\x55\x9d\x61\x2b\x09\xaa\xb3\xf4\x79\x97\x15\xe8\x6b\x48\x0f\x21\x3d\x2a\xae\x04\x7a\x1c\xd2\x9f\xe3\xd5\xcf\xf1\xea\xe7\x78\xf5\x73\xbc\xfa\x39\xbb\xca\x71\x5c\x14\x69\x95\x76\xe9\xc3\xff\xa6\x70\x4f\xcb\x69\xc2\xe9\x49\x92\x9c\xe6\x39\x81\x14\xcb\x69\xca\x85\x93\x95\x72\x5a\xe0\x82\xc8\x1e\x39\xad\xe0\xfc\xc9\x55\x39\xad\xe4\x02\xf9\x01\x72\x5a\xc5\x2d\xa5\x85\x72\x5a\xcd\x05\xc2\xa8\x21\xa5\x35\x9c\xbf\x60\x92\xd3\x3e\xa4\x55\x25\xc8\x69\x5f\x2e\x42\xfd\x94\x9c\xf6\xe3\x32\x35\xc9\x72\x5a\xcb\xe5\x6a\x76\xca\x69\x7f\x2e\xcc\xc7\x02\x9c\x10\x41\x03\xbf\x36\x23\x57\x2c\x4d\x38\x33\x51\xc8\x69\x9e\x53\x93\x41\x72\x9a\x72\x03\xc9\x48\x39\x2d\x70\xa9\xe4\x41\x39\xad\xe0\x22\xc8\x09\x39\xad\xe4\x92\x79\x1f\x39\xad\xe2\x2e\xf1\xa3\xe4\xb4\x9a\x4b\xa6\xaf\xc8\x69\x0d\x17\x41\x7f\x90\xd3\x3e\xfc\x87\x42\xa2\x9c\xf6\xe5\x06\xa9\xdb\xe5\xb4\x1f\x37\x53\xfd\x6f\x39\xad\xe5\x66\x6b\xa6\xca\x69\x7f\x6e\x80\xe6\x07\xae\x84\x6b\xe1\x66\xc1\xbf\x0e\xf8\xb7\x94\x6b\xe4\x1a\x38\x33\xfc\xab\x85\xdf\xb5\x90\xaa\xe7\xda\xb8\xf9\x5c\x17\xb7\x10\x4b\x35\x43\xae\x99\x4b\x86\xdc\x14\xf8\x9b\xc3\x65\x71\xd9\xf0\xcf\xcc\x8d\x84\x52\x6d\x70\x7d\x2e\xdc\x6f\xe6\x86\x43\x7a\x21\xdc\xc5\x68\x2d\xe2\xb6\x71\xad\x5c\x26\xe7\x83\x57\x7e\x1c\x2d\x07\x52\x13\x64\x2e\xca\xf0\xee\x74\x48\x8d\x82\xfb\xeb\x01\x81\x2b\x69\x99\xd5\xd2\xd1\xb2\xb4\xb1\xc1\xdc\x50\xdb\x51\x6b\xae\x6f\x9b\xdf\xb5\xb0\x65\x56\x73\x87\x39\xb9\x3e\xc5\x9c\x93\x95\x9d\x65\x1e\xd9\xd6\x36\x6b\x6e\xa3\x79\x78\xdb\xc2\xf9\x6d\x0b\x6b\x3b\x5a\xda\x5a\x33\x7d\x86\xf7\x2d\x96\x63\x9e\x00\x10\x65\xb5\x1d\xe9\xe6\x51\xad\xf5\x80\x5b\x0e\x0c\xd5\x41\xb5\xde\x0c\x9b\xb9\x89\x98\xd3\xc2\x35\x41\x81\x96\xba\x46\x09\xce\x3c\xb1\x71\x61\x0b\xe4\x14\x43\xa1\xb9\xc0\x27\x57\xdc\x36\x17\x68\x11\xd7\x0e\x2c\x36\xc2\x7d\x0d\x78\x97\x99\xcb\x80\x7f\x3f\x89\x5b\xd4\x5e\xdf\xd8\xda\xd0\xb8\xd0\x9c\x61\xbe\xb6\x8a\x9f\xba\xdb\xdc\xc3\x44\xdf\x9b\xcd\x12\x57\x53\xb0\x6c\xbb\xe7\xde\x1c\x10\x62\x16\xfc\x97\xc9\x8e\xa3\x9c\xd2\xb8\xb0\x9d\xdd\x90\x93\x99\x95\x95\x99\xdd\x7f\x75\x3d\x95\x65\xf4\x57\x19\xd6\x95\x21\xd5\xd5\x3f\xb7\x2d\x50\xbb\x19\x4d\xa9\x03\xaf\x30\xe9\xcc\x83\xbf\x0b\xb9\x39\x90\xd7\x86\xad\xb8\xbe\xc2\xcd\x50\xae\x11\xcd\xb3\x1d\xae\x34\xe2\xaf\x06\x44\x65\xd8\x93\xa1\xc4\x44\x2c\x35\x1e\xef\x64\xd2\xef\xc0\xda\x5a\xb1\xd4\xa4\x7e\x6a\x1c\x07\x35\x36\xc1\xfd\xf5\x68\xaa\xee\x92\xf5\x88\xcd\x4c\x5e\x42\x6e\x83\x74\xb3\xac\xc7\xd9\xdc\x22\x14\x41\x3b\x94\x64\xf7\xb9\xdb\xd6\xce\x0c\xd2\x4b\xee\x2d\xed\xe6\x5a\x73\xc7\xc2\xda\x86\xc6\x79\xb5\x0b\xe7\x98\xdb\x9a\x7a\x1b\x99\x79\x61\xe3\xac\x96\xf6\x8e\xc6\x85\x90\xd9\xd2\x6a\x9e\x9c\x39\x31\xd3\x3c\xbe\xb6\xa3\xb1\xb5\xc3\x5c\xdb\xda\x60\x9e\xe4\xb9\x71\x5c\x53\x53\x4b\x7d\x23\x66\xd6\x37\x2e\xec\xa8\x85\xc2\x6d\x1d\xcd\x60\x22\xb3\x17\x2d\x6c\x69\x6f\x68\xa9\x67\xb5\xb5\x67\xf6\x67\x72\xfd\xf7\xbc\x1e\x23\xf3\xea\x15\x1c\x48\x8e\x49\x6c\x31\xca\x61\x2c\x16\x67\xbf\xdb\xa5\x5b\x26\x76\x34\x2e\x6e\x34\x8f\xad\xed\xe8\x68\x6c\x67\x85\x8b\xa1\x40\xbb\x2c\x7c\x49\xb1\x93\x50\x54\x6d\x90\xcb\x14\xd6\x09\xe2\x62\xc2\x69\xc6\x74\x2d\x2a\xbd\x01\xe1\x58\x4f\x6f\x95\xef\xac\x83\xbe\x6f\xfe\xd1\x8a\xcd\xf2\xbd\xb5\xb2\xf1\xb4\x62\x1d\x8b\xe5\xd6\xb0\x7b\xd2\x65\xa3\x68\x42\xda\x8e\xf5\xb6\x42\x1d\x66\xe4\xcf\xdd\x31\xbc\xeb\x36\xa3\x32\x6b\xd1\x34\x24\x73\x9c\x07\x57\x3b\xb0\x6c\x3d\xe4\xcf\x85\xff\xba\xe4\xb1\x6e\x1e\x48\x4f\xaa\xab\x4e\x1e\xcd\x3a\x71\x6c\x6c\x96\x5b\x3c\x0f\x71\xcd\x5c\x05\xfc\xed\x44\xd3\x6d\x43\xe3\x6a\x8d\x89\x45\x43\xec\x91\x8a\x64\xdc\x4d\x72\x07\x34\xe3\xbd\xf3\x21\xdd\x86\xad\x70\xcb\x31\x03\x75\xc8\x5a\xd2\x88\x9c\xb2\x54\x2d\x8e\xbf\x75\x70\xc7\x5c\xac\x5b\xe2\xad\x19\x4d\xb8\x16\x0d\xb0\x51\x36\xc8\x0e\x6c\x41\xbb\x97\x21\x4b\x66\x6b\xc6\x56\x30\xf4\x11\x68\xbc\x6c\xd4\x6d\x94\x65\x3a\x15\x46\xeb\xf2\x7e\x11\x25\x09\x7a\x77\xa0\x76\xec\xf1\x8b\xe5\x36\xbb\xb1\x5b\x91\xdb\x06\x4f\x1b\x25\x69\xb3\x52\x73\xe5\x9a\xa4\x16\xcf\xc5\x59\x61\x8e\x47\x3f\x4d\x68\x97\x92\x44\x1b\x10\x2d\xe3\x3a\x32\x6f\x42\xd9\x74\xc8\xb5\xb6\x21\x47\x0d\xf0\x9f\xa4\x71\xc9\xb6\xda\xe0\xde\x45\xa8\x0f\xa9\xd3\x4b\x56\xdf\x71\x8d\xe4\x6a\x51\xbe\x6d\xf2\x7d\xf3\xe1\x0a\xab\x4b\xe2\x65\x9e\xd4\x89\x8b\x6b\xdb\xa1\x53\x42\x17\x9e\xd4\xd2\xda\xd6\x9e\x6e\xee\x6c\x6e\xa9\x6f\x36\x77\xd6\xb6\x9b\x1b\x1a\xdb\x5b\x66\xb5\xc2\xc5\xba\x2e\x73\xef\x2e\x61\x86\xab\xb5\xd0\xe9\x5b\x5b\xdb\x16\x43\x87\x5a\xdc\x98\x0e\x1d\xbc\x69\x61\x63\x7b\x73\x4b\xeb\x2c\x73\x3b\x8e\xc1\xd2\xdd\xe6\x8e\xe6\xda\x0e\x36\x3a\xcc\x6b\xec\x58\xd8\x52\x5f\x3b\x77\x6e\x17\x4c\x5c\xf3\xe6\xc3\x5d\x75\x30\x53\x75\xb6\x74\x34\x43\xc5\xf3\x1a\xdb\xcd\x15\x8d\x9d\xe6\x09\x6d\xf3\x6a\x5b\x9f\xcc\x94\x58\x81\x41\xa4\x09\x06\x69\x73\xcb\xbc\xf9\x0b\xdb\x16\x23\x8f\x19\xed\xf5\x0b\x1b\x1b\x5b\xa1\xb2\xda\x86\xda\xba\x96\xb9\x2d\x1d\x80\xd6\x5c\xbb\xb0\xb6\x1e\x86\x16\x18\x5f\x5a\xea\xdb\x71\xe8\x80\x11\xc3\x3c\xbf\xb6\x35\x63\xc4\xa2\x85\x6d\xf3\x1b\x81\xd3\xa9\x23\xcb\x7b\x0a\x02\x83\xd2\xb0\xd3\xde\x36\x77\x31\xd4\xcc\x4a\xb7\x36\x36\x36\xb0\x1a\x81\xed\xc5\x8d\x73\xe1\x26\xa8\x78\x6e\x5b\xdb\x1c\xd6\x9e\xa6\xb6\x85\xc0\x68\x43\x47\x73\x86\x17\xe7\x4d\x6d\xad\x1d\x70\x6b\x9b\xb9\xb6\xa1\x01\x1a\x0e\xd2\x6a\xab\x5f\x34\x8f\x0d\x68\x30\xc8\x74\xb8\x99\xab\xad\x5f\xd8\x06\xd7\xe6\xcf\xad\xed\x00\x94\x79\x6c\xe0\x6a\xc6\x2e\x3f\x9f\x2b\xe0\x2c\xf0\x5f\x27\xfe\x97\x89\x1d\xdf\x7b\x38\xab\x97\x07\xb3\x4c\xd9\x48\x2c\x70\x63\x47\xc7\xfc\x02\x8b\xa5\xb3\xb3\x33\xb3\x56\x1e\xd3\xea\x61\x48\xcb\x04\xa6\x2c\xbf\x1e\x96\xd9\xc9\x7c\xb4\x68\xef\xf1\x6a\x21\xda\x06\xc3\x9c\x07\x36\xf3\xa3\x55\x77\x74\xcd\x6f\x94\x2d\x65\x61\x7b\x66\x73\xc7\xbc\xb9\xd2\x6c\x28\x55\xeb\x1e\x36\x17\x79\x0d\xd4\xee\xae\x34\x11\x66\xba\x72\x9c\x95\xe6\xcb\x03\x40\xa9\x6c\xfa\xe6\x3e\x08\x6c\xd8\xeb\x3b\x9b\x67\x4b\xf3\x78\x39\x4c\x17\xad\xcc\x82\x17\xe1\x20\xcf\x74\x39\x71\x54\xf9\xff\x67\xef\x4d\xe0\xa4\xa8\xae\xf6\xe1\xbb\xd5\xd6\x0c\x9b\xe2\x82\x22\xe2\x12\x63\x8c\x0b\x53\x55\xbd\x29\x1a\x67\xa9\x52\x11\xc1\x28\x28\x22\x2e\x03\xd3\x30\x83\xc3\x0c\xcc\x02\xb8\x13\xb7\xb8\xef\x1a\x43\x8c\x31\x86\x28\x2e\x71\x41\x62\x10\x89\x71\x17\x15\xd4\x28\xae\xe0\x2e\x8a\x8a\x8a\x88\xa8\x44\x99\xef\xd4\xad\x67\xa6\x6b\x9a\xc1\xe0\xfb\xfe\xf3\xff\xde\xf7\xfb\x7d\xf0\xbb\x5b\xd5\xad\xf3\x9c\x7b\xee\xad\xfb\x9c\xd3\x55\x3d\x3d\x68\xc4\x14\x5a\x26\x21\xcd\xd1\x20\x74\xd8\x73\x50\x07\xe3\x97\x47\x74\xdf\xd5\x5c\xf1\x36\x54\x4f\xed\x56\x3d\xf0\x16\x7d\x13\xed\xad\x8d\x35\x91\xce\x8f\x20\xcd\x86\x75\x9a\x81\x16\x61\xfd\x94\xd6\x96\xbd\x5b\xea\x1b\xf6\x6e\x6a\x9e\xb8\xcf\x88\x30\xfa\x13\x5d\xb1\xc3\xde\xbe\x13\x7b\x94\x75\xf3\x2f\x15\xff\x76\x80\x20\xef\x53\x91\x9f\x6b\x92\x4f\x6b\x47\xbf\x5e\x4c\xbe\x6a\x19\xf9\xa5\xbd\x58\x6f\xd6\x87\xf5\x65\x5b\xb0\x2d\x59\x3f\xb6\x15\xdb\x9a\x6d\xc3\xb6\x65\xfd\xd9\x76\x6c\x7b\x36\x80\xed\xc0\x06\xb2\x1d\x69\xc8\x3b\xb1\x9d\xd9\x2e\x6c\x57\xf6\x13\xb6\x1b\xfb\x29\xf9\x8e\x3f\x63\x7b\xb0\x9f\x93\x71\xf6\x22\x55\xf7\x81\x07\xe9\x31\x9f\xa5\x59\x86\x65\x59\x8e\xe5\x69\x78\xfb\xb1\x21\x6c\x7f\x76\x00\xfb\x05\x3b\x90\x38\xb3\x92\x58\xb2\x9a\xf6\xc5\x90\xf6\xc1\x83\xc9\xfc\x43\xd9\xa1\x34\xb0\xc3\x68\x47\x1f\x41\x6e\xc4\x2f\x69\x47\x3f\x92\x76\xf1\x51\x64\xec\xa3\xd9\x68\x76\x0c\x1b\xc3\x8e\x65\x63\xd9\x71\xec\x78\x76\x02\x3b\x91\xd5\x70\xc1\xfe\xc4\xce\x61\xe7\xb2\xbf\xb3\x6b\xd9\x4a\x76\x1e\xbb\x94\x5d\xc4\x7e\xcf\x6e\x65\xb3\xb9\x64\x17\x72\xc5\xce\x66\x57\xb1\x35\xec\x4b\x76\x09\xf9\xfd\xe7\x73\x93\xbd\xc9\xbe\x60\x37\xb0\xdb\xd8\x57\x6c\x2d\x5b\xc7\x6e\x62\x7f\x61\x4f\xb1\x27\x29\xa6\x19\x47\x06\xbf\x9c\x16\xc4\x33\x34\xa9\x8b\xd8\xd3\xec\x39\xb6\x98\x2d\x61\xcf\xb2\x8f\x68\x6f\x7a\x91\x3d\xcf\xfe\xc9\xee\x22\xc3\xaf\x66\x57\xb0\x97\xd9\x52\xf6\x12\x4d\xd7\x27\xec\x53\x76\x01\xb9\x23\xf5\xb4\xa7\x46\x6b\xb2\x91\xdd\x48\xd3\x33\x55\xb3\x4a\x0b\x2d\xaf\x56\xda\x83\xa7\xb3\x8f\xd9\x0c\xf2\xe3\x4f\x66\xa7\x52\x24\x77\x1a\x9b\xcf\xfe\xc8\xce\x64\x67\xb0\x99\xec\x57\x6c\x15\xfb\x8c\x2d\xe0\x16\xb7\xb9\xc3\x53\xbc\x07\x2f\x63\xdf\xb3\x0d\xbc\x27\x8f\xde\x0c\xef\xc3\xda\x39\xe3\x7d\xf9\x16\x7c\x4b\xce\x79\x3f\xbe\x15\xdf\x9a\x6f\xc3\xb7\xe5\xfd\xf9\x76\x7c\x7b\x3e\x80\xef\xc0\x07\xf2\x1d\xd9\x37\xec\x5b\x3e\x88\xef\xc4\x77\xe6\xbb\xf0\x5d\xf9\x4f\xf8\x6e\xfc\xa7\x7c\x77\xfe\x33\xbe\x07\xff\x39\xdf\x93\xef\xc5\xf7\xe6\xfb\xb0\xf5\xec\x15\x3e\x98\x97\x73\x97\x7b\xdc\xe7\x69\x9e\xe1\x59\x9e\xe3\x79\xbe\x2f\xdf\x8f\x0f\xe1\xfb\xf3\x03\xd8\xbb\xec\x3d\xfe\x0b\x7e\x20\xaf\xe0\x95\xbc\x8a\x57\xf3\x80\x87\xd1\x4f\x3d\xf1\x43\xf8\x50\x7e\x28\x1f\xc6\x0f\x63\x77\xb3\x7b\xf8\x70\x3e\x82\x1f\xce\x7f\xc9\x8f\xe0\x47\xf2\x91\x7c\x14\x3f\x8a\x1f\xcd\xfe\xc5\xbe\x63\xef\xb3\x15\x7c\x34\x3f\x86\x8f\xe1\xc7\xf2\xb1\xfc\x38\x7e\x3c\x3f\x81\x9f\xc8\x6b\xf8\x38\x3e\x9e\xd7\xf2\x02\x9f\xc0\x27\xf2\x3a\x5e\xcf\x27\xf1\x93\x78\x03\x9f\xcc\x1e\xe0\x8d\xbc\x89\x4f\xe1\x53\xd9\x07\xec\x43\xde\xcc\x5b\x78\x2b\x6f\xe3\xd3\xf8\x74\x3e\x83\x9f\xcc\x4f\xe1\xa7\xf2\xd3\xf8\xe9\xfc\x0c\x7e\x26\x9f\xc9\x7f\xc5\xcf\xe2\x67\xf3\x73\xd8\xcd\xfc\x5c\x7e\x1e\xff\x35\x3f\x9f\x5f\xc0\x2f\xe4\x17\xf1\x8b\xf9\x25\xfc\x52\x7e\x19\xbf\x9c\x5f\xc1\xaf\xe4\x57\xf1\xab\xf9\x35\xfc\x5a\xfe\x1b\x7e\x1d\xff\x2d\x9f\xc5\x7f\xc7\xaf\xe7\xbf\xe7\x37\xf0\x3f\xf0\x1b\xf9\x1f\xf9\x4d\xfc\x4f\x7c\x36\xff\x33\xbf\x99\xdf\xc2\xe7\xf0\x5b\xf9\x6d\xfc\x76\x7e\x07\xff\x0b\xbf\x93\xdf\xc5\xef\xe6\xf7\xf0\xb9\xfc\x5e\x3e\x8f\xff\x95\xdf\xc7\xff\xc6\xe7\xf3\xfb\xf9\x02\xfe\x00\x5f\xc8\xff\xce\x1f\xe4\xff\xe0\x0f\xf1\x87\xf9\x23\xfc\x51\xfe\x18\x7f\x9c\x3f\xc1\x9f\xe4\x8b\xf8\x53\xfc\x69\xfe\x0c\x5f\xcc\x97\xf0\x67\xf9\x73\xfc\x79\xfe\x4f\xfe\x02\x7f\x91\x2f\xe5\x2f\xf1\x97\xf9\x2b\xfc\x55\xfe\x1a\x7f\x9d\x2f\xe3\xcb\xf9\x1b\xfc\x4d\xfe\x16\x7f\x9b\xbf\xc3\xdf\xe5\xef\xf1\xf7\xf9\x0a\xfe\x01\xff\x90\xaf\xe4\x1f\xf1\x8f\xf9\x27\x7c\x15\xff\x94\x7f\xc6\x3f\xe7\xab\xf9\x17\x7c\x0d\xff\x92\xaf\xe5\x5f\xf1\x75\xfc\x6b\xfe\x0d\xff\x96\xaf\xe7\xff\xe2\xdf\xf1\xef\xf9\x06\xde\x2e\x98\xe0\x42\x08\x19\xfd\x00\x8b\x30\x85\x25\x6c\xe1\x88\x94\xe8\x21\xca\x44\x4f\xd1\x4b\xf4\x16\x7d\x44\x5f\xb1\x85\xd8\x52\xf4\x13\x5b\x89\xad\xc5\x36\x62\x5b\xd1\x5f\x6c\x27\xb6\x17\x03\xc4\x0e\x62\xa0\xd8\x51\x0c\x12\x3b\x89\x9d\xc5\x2e\x62\x57\xf1\x13\xb1\x9b\xf8\xa9\xd8\x5d\xfc\x4c\xec\x21\x7e\x2e\xf6\x14\x7b\x89\xbd\xc5\x3e\x62\xb0\x28\x17\xae\xf0\x84\x2f\xd2\x22\x23\xb2\x22\x27\xf2\x62\x5f\xb1\x9f\x18\x22\xf6\x17\x07\x88\x5f\x88\x03\x45\x85\xa8\x14\x55\xa2\x5a\x04\x22\x14\x07\x89\x83\xc5\x21\x62\xa8\x38\x54\x0c\x13\x87\x89\xe1\x62\x84\x38\x5c\xfc\x52\x1c\x21\x8e\x14\x23\xc5\x28\x71\x94\x38\x5a\x8c\x16\xc7\x88\x31\xe2\x58\x31\x56\x1c\x27\x8e\x17\x27\x88\x13\x45\x8d\x18\x27\xc6\x8b\x5a\x51\x10\x13\xc4\x44\x51\x27\xea\xc5\x24\x71\x92\x68\x10\x93\x45\xa3\x68\x12\x53\xc4\x54\xd1\x2c\x5a\x44\xab\x68\x13\xd3\xc4\x74\x31\x43\x9c\x2c\x4e\x11\xa7\x8a\xd3\xc4\xe9\xe2\x0c\x71\xa6\x98\x29\x7e\x25\xce\x12\x67\x8b\x73\xc4\xb9\xe2\x3c\xf1\x6b\x71\xbe\xb8\x40\x5c\x28\x2e\x12\x17\x8b\x4b\xc4\xa5\xe2\x32\x71\xb9\xb8\x42\x5c\x29\xae\x12\x57\x8b\x6b\xc4\xb5\xe2\x37\xe2\x3a\xf1\x5b\x31\x4b\xfc\x4e\x5c\x2f\x7e\x2f\x6e\x10\x7f\x10\x37\x8a\x3f\x8a\x9b\xc4\x9f\xc4\x6c\xf1\x67\x71\xb3\xb8\x45\xcc\x11\xb7\x8a\xdb\xc4\xed\xe2\x0e\xf1\x17\x71\xa7\xb8\x4b\xdc\x2d\xee\x11\x73\xc5\xbd\x62\x9e\xf8\xab\xb8\x4f\xfc\x8d\xbd\xca\xde\x11\xf3\xd9\xeb\xe2\x7e\xb1\x40\x3c\x20\x16\x8a\xbf\x8b\x07\xc5\x3f\xc4\x43\xe2\x61\xf1\x88\x78\x54\x3c\x26\x1e\x17\x4f\xb0\x65\x6c\x39\x7b\x83\xbd\xcd\x5e\x63\x6f\x89\x27\xc5\x22\xf1\x94\x78\x5a\x3c\x23\x16\x8b\x25\xe2\x59\xf1\x9c\x78\x5e\xfc\x53\xbc\x20\x5e\x14\x4b\xc5\x4b\xe2\x65\xf1\x8a\x78\x55\xbc\x26\x5e\x17\xcb\xc4\x72\xf1\x86\x78\x53\xbc\x25\xde\x16\xef\x88\x77\xc5\x7b\xe2\x7d\xb1\x42\x7c\x20\x3e\x14\x2b\xc5\x47\xe2\x63\xf1\x89\x58\x25\x3e\x15\x9f\x89\xcf\xc5\x6a\xf1\x85\x58\x23\xbe\x14\x6b\xc5\x57\x62\x9d\xf8\x5a\x7c\x23\xbe\x15\xeb\xc5\xbf\xc4\x77\xe2\x7b\xb1\x41\xb4\x4b\x26\xb9\x14\x52\x4a\x25\x0d\x69\x4a\x4b\xda\xd2\x91\x29\xd9\x43\x96\xc9\x9e\xb2\x97\xec\x2d\xfb\xc8\xbe\x72\x0b\xb9\xa5\xec\x27\xb7\x92\x5b\xcb\x6d\xe4\xb6\xb2\xbf\xdc\x4e\x6e\x2f\x07\xc8\x1d\xe4\x40\xb9\xa3\x1c\x24\x77\x92\x3b\xcb\x5d\xe4\xae\xf2\x27\x72\x37\xf9\x53\xb9\xbb\xfc\x99\xdc\x43\xfe\x5c\xee\x29\xf7\x92\x7b\xcb\x7d\xe4\x60\x59\x2e\x5d\xe9\x49\x5f\xa6\x65\x46\x66\x65\x4e\xe6\xe5\xbe\x72\x3f\x39\x44\xee\x2f\x0f\x90\xbf\x90\x07\xca\x0a\x59\x29\xab\x64\xb5\x0c\xa2\xf7\x4f\xe4\xc1\xf2\x10\x39\x54\x1e\x2a\x87\xc9\xc3\xe4\x70\x39\x42\x1e\x2e\x7f\x29\x8f\x90\x47\xca\x91\x72\x94\x3c\x2a\x7a\x0b\x41\x1e\x23\xc7\xc8\x63\xe5\xd8\xe8\xd9\xbc\x3c\x41\x9e\x28\x6b\xe4\x38\x39\x5e\xd6\xca\x82\x9c\x20\x27\x46\xcf\xcf\xe5\x24\x79\x92\x6c\x90\x93\xd9\x1c\xd9\x28\x9b\xa2\x67\xd1\xb2\x59\xb6\xc8\x56\xd9\x26\xa7\xc9\xe9\xd1\xd3\x67\x79\x8a\x3c\x55\x9e\x26\x4f\x97\x67\xc8\x33\xe5\x4c\xf6\x07\xf9\x2b\x79\x96\x3c\x5b\x9e\x23\xcf\x95\xe7\xc9\x5f\xcb\xf3\xe5\x05\xf2\x42\x79\x91\xbc\x58\x5e\x22\x2f\x95\x97\xc9\xcb\xe5\x15\xf2\x4a\xf6\x1b\x79\x95\xbc\x5a\x5e\xc3\x7e\x27\xaf\x95\xbf\x91\xd7\xc9\xdf\xca\x59\xf2\x77\xf2\x7a\xf9\x7b\x79\x83\xfc\x83\xbc\x51\xfe\x51\xde\x24\xff\x24\x67\xcb\x3f\xcb\x9b\xe5\x2d\x72\x8e\xbc\x55\xde\x26\x6f\x97\x77\xc8\xbf\xc8\x3b\xe5\x5d\xf2\x6e\x79\x8f\x9c\x2b\xef\x95\xf3\xe4\x5f\xe5\x7d\xf2\x6f\x72\xbe\xbc\x5f\x2e\x90\x0f\xc8\x85\xf2\xef\xf2\x41\xf9\x0f\xf9\x90\x7c\x58\x3e\x22\x1f\x8d\x9e\xac\xca\x27\xa2\xa7\x94\xf2\x29\xf9\xb4\x7c\x46\x2e\x96\x4b\xe4\xb3\xf2\x39\xf9\x7c\xf4\x84\x4c\xbe\x18\x3d\xa1\x91\x2f\xcb\x57\xe4\xab\xf2\x35\xf9\xba\x5c\x26\x97\x47\xcf\x15\xe4\x5b\xf2\x6d\xf9\x8e\x7c\x57\xbe\x17\x7d\x36\x2e\x3f\x88\x3e\xc1\x96\x1f\xc9\x8f\xe5\x27\x72\x95\xfc\x54\x7e\x26\x3f\x97\xab\xe5\x17\x72\x4d\xf4\x99\xaa\xfc\x4a\xae\x93\x5f\xcb\x6f\xe4\xb7\x72\xbd\xfc\x97\xfc\x4e\x7e\x2f\x37\xc8\x76\xc5\x14\x57\x42\x49\xa5\x94\xa1\x4c\x65\x29\x5b\x39\x2a\xa5\x7a\xa8\x32\xd5\x53\xf5\x52\xbd\x55\x1f\xd5\x57\x6d\xa1\xb6\x54\xfd\xd4\x56\x6a\x6b\xb5\x8d\xda\x56\xf5\x57\xdb\xa9\xed\xd5\x00\xb5\x83\x1a\xa8\x76\x54\x83\xd4\x4e\x6a\x67\xb5\x8b\xda\x55\xfd\x44\xed\xa6\x7e\xaa\x76\x57\x3f\x53\x7b\xa8\x9f\xab\x3d\xd5\x5e\x6a\x6f\xb5\x8f\x1a\xac\xca\x95\xab\x3c\xe5\xab\xb4\xca\xa8\xac\xca\xa9\xbc\xda\x57\xed\xa7\x86\xa8\xfd\xd5\x01\xea\x17\xea\x40\x55\xa1\x2a\x55\x95\xaa\x56\x81\x0a\xd5\x41\xea\x60\x75\x88\x1a\xaa\x0e\x55\xc3\xd4\x61\x6a\xb8\x1a\xa1\x0e\x57\xbf\x54\x47\xa8\x23\xd5\x48\x35\x4a\x1d\xa5\x8e\x56\xa3\xd5\x31\x6a\x8c\x3a\x56\x8d\x55\xc7\xa9\xe3\xd5\x09\xea\x44\x55\xa3\xc6\xa9\xf1\xaa\x56\x15\xd4\x04\x35\x51\xd5\xa9\x7a\x35\x49\x9d\xa4\x1a\xd4\x64\xd5\xa8\x9a\xd4\x14\x35\x55\x35\xab\x16\xd5\xaa\xda\xd4\x34\x35\x5d\xcd\x50\x27\xab\x53\xd4\xa9\xea\x34\x75\xba\x3a\x43\x9d\xa9\x66\xaa\x5f\xa9\xb3\xd4\xd9\xea\x1c\x75\xae\x3a\x4f\xfd\x5a\x9d\xaf\x2e\x50\x17\xaa\x8b\xd4\xc5\xea\x12\x75\xa9\xba\x4c\x5d\xae\xae\x50\x57\xaa\xab\xd4\xd5\xea\x1a\x75\xad\xfa\x8d\xba\x4e\xfd\x56\xcd\x52\xbf\x53\xd7\xab\xdf\xab\x1b\xd4\x1f\xd4\x8d\xea\x8f\xea\x26\xf5\x27\x35\x5b\xfd\x59\xdd\xac\x6e\x51\x73\xd4\xad\xea\x36\x75\xbb\xba\x43\xfd\x45\xdd\xa9\xee\x52\x77\xab\x7b\xd4\x5c\x75\xaf\x9a\xa7\xfe\xaa\xee\x53\x7f\x53\xf3\xd5\xfd\x6a\x81\x7a\x40\x2d\x54\x7f\x57\x0f\xaa\x7f\xa8\x87\xd4\xc3\xea\x11\xf5\xa8\x7a\x4c\x3d\xae\x9e\x50\x4f\xaa\x45\xea\x29\xf5\xb4\x7a\x46\x2d\x56\x4b\xd4\xb3\xea\x39\xf5\xbc\xfa\xa7\x7a\x41\xbd\xa8\x96\xaa\x97\xd4\xcb\xea\x15\xf5\xaa\x7a\x4d\xbd\xae\x96\xa9\xe5\xea\x0d\xf5\xa6\x7a\x4b\xbd\xad\xde\x51\xef\xaa\xf7\xd4\xfb\x6a\x85\xfa\x40\x7d\xa8\x56\xaa\x8f\xd4\xc7\xea\x13\xb5\x4a\x7d\xaa\x3e\x53\x9f\xab\xd5\xea\x0b\xb5\x46\x7d\xa9\xd6\xaa\xaf\xd4\x3a\xf5\xb5\xfa\x46\x7d\xab\xd6\xab\x7f\xa9\xef\xd4\xf7\x6a\x83\x6a\x37\x98\xc1\xa3\x3f\x11\x6e\x28\xc3\x30\x4c\xc3\x32\x6c\xc3\x31\x52\x46\x0f\xa3\xcc\xe8\x69\xf4\x32\x7a\x1b\x7d\x8c\xbe\xc6\x16\xc6\x96\x46\x3f\x63\x2b\x63\x6b\x63\x1b\x63\x5b\xa3\xbf\xb1\x9d\xb1\xbd\x31\xc0\xd8\xc1\x18\x68\xec\x68\x0c\x32\x76\x32\x76\x36\x76\x31\x76\x35\x7e\x62\xec\x66\xfc\xd4\xd8\xdd\xf8\x99\xb1\x87\xf1\x73\x63\x4f\x63\x2f\x63\x6f\x63\x1f\x63\xb0\x51\x6e\xb8\x86\x67\xf8\x46\xda\xc8\x18\x59\x23\x67\xe4\x8d\x7d\x8d\xfd\x8c\x21\xc6\xfe\xc6\x01\xc6\x2f\x8c\x03\x8d\x0a\xa3\xd2\xa8\x32\xaa\x8d\xc0\x08\x8d\x83\x8c\x83\x8d\x43\x8c\xa1\xc6\xa1\xc6\x30\xe3\x30\x63\xb8\x31\xc2\x38\xdc\xf8\xa5\x71\x84\x71\xa4\x31\xd2\x18\x65\x1c\x65\x1c\x6d\x8c\x36\x8e\x31\xc6\x18\xc7\x1a\x63\x8d\xe3\x8c\xe3\x8d\x13\x8c\x13\x8d\x1a\x63\x9c\x31\xde\xa8\x35\x0a\xc6\x04\x63\xa2\x51\x67\xd4\x1b\x93\x8c\x93\x8c\x06\x63\xb2\xd1\x68\x34\x19\x53\x8c\xa9\x46\xb3\xd1\x62\xb4\x1a\x6d\xc6\x34\x63\xba\x31\xc3\x38\xd9\x38\xc5\x38\xd5\x38\xcd\x38\xdd\x38\xc3\x38\xd3\x98\x69\xfc\xca\x38\xcb\x38\xdb\x38\xc7\x38\xd7\x38\xcf\xf8\xb5\x71\xbe\x71\x81\x71\xa1\x71\x91\x71\xb1\x71\x89\x71\xa9\x71\x99\x71\xb9\x71\x85\x71\xa5\x71\x95\x71\xb5\x71\x8d\x71\xad\xf1\x1b\xe3\x3a\xe3\xb7\xc6\x2c\xe3\x77\xc6\xf5\xc6\xef\x8d\x1b\x8c\x3f\x18\x37\x1a\x7f\x34\x6e\x32\xfe\x64\xcc\x36\xfe\x6c\xdc\x6c\xdc\x62\xcc\x31\x6e\x35\x6e\x33\x6e\x37\xee\x30\xfe\x62\xdc\x69\xdc\x65\xdc\x6d\xdc\x63\xcc\x35\xee\x35\xe6\x19\x7f\x35\xee\x33\xfe\x66\xcc\x37\xee\x37\x16\x18\x0f\x18\x0b\x8d\xbf\x1b\x0f\x1a\xff\x30\x1e\x32\x1e\x36\x1e\x31\x1e\x35\x1e\x33\x1e\x37\x9e\x30\x9e\x34\x16\x19\x4f\x19\x4f\x1b\xcf\x18\x8b\x8d\x25\xc6\xb3\xc6\x73\xc6\xf3\xc6\x3f\x8d\x17\x8c\x17\x8d\xa5\xc6\x4b\xc6\xcb\xc6\x2b\xc6\xab\xc6\x6b\xc6\xeb\xc6\x32\x63\xb9\xf1\x86\xf1\xa6\xf1\x96\xf1\xb6\xf1\x8e\xf1\xae\xf1\x9e\xf1\xbe\xb1\xc2\xf8\xc0\xf8\xd0\x58\x69\x7c\x64\x7c\x6c\x7c\x62\xac\x32\x3e\x35\x3e\x33\x3e\x37\x56\x1b\x5f\x18\x6b\x8c\x2f\x8d\xb5\xc6\x57\xc6\x3a\xe3\x6b\xe3\x1b\xe3\x5b\x63\xbd\xf1\x2f\xe3\x3b\xe3\x7b\x63\x83\xd1\x6e\x32\x93\x9b\xc2\x8c\xfe\x04\xb1\x61\x9a\xa6\x65\xda\xa6\x63\xa6\xcc\x1e\x66\x99\xd9\xd3\xec\x65\xf6\x36\xfb\x98\x7d\xcd\x2d\xcc\x2d\xcd\x7e\xe6\x56\xe6\xd6\xe6\x36\xe6\xb6\x66\x7f\x73\x3b\x73\x7b\x73\x80\xb9\x83\x39\xd0\xdc\xd1\x1c\x64\xee\x64\xee\x6c\xee\x62\xee\x6a\xfe\xc4\xdc\xcd\xfc\xa9\xb9\xbb\xf9\x33\x73\x0f\xf3\xe7\xe6\x9e\xe6\x5e\xe6\xde\xe6\x3e\xe6\x60\xb3\xdc\x74\x4d\xcf\xf4\xcd\xb4\x99\x31\xb3\x66\xce\xcc\x9b\xfb\x9a\xfb\x99\x43\xcc\xfd\xcd\x03\xcc\x5f\x98\x07\x9a\x15\x66\xa5\x59\x65\x56\x9b\x81\x19\x9a\x07\x99\x07\x9b\x87\x98\x43\xcd\x43\xcd\x61\xe6\x61\xe6\x70\x73\x84\x79\xb8\xf9\x4b\xf3\x08\xf3\x48\x73\xa4\x39\xca\x3c\xca\x3c\xda\x1c\x6d\x1e\x63\x8e\x31\x8f\x35\xc7\x9a\xc7\x99\xc7\x9b\x27\x98\x27\x9a\x35\xe6\x38\x73\xbc\x59\x6b\x16\xcc\x09\xe6\x44\xb3\xce\xac\x37\x27\x99\x27\x99\x0d\xe6\x64\xb3\xd1\x6c\x32\xa7\x98\x53\xcd\x66\xb3\xc5\x6c\x35\xdb\xcc\x69\xe6\x74\x73\x86\x79\xb2\x79\x8a\x79\xaa\x79\x9a\x79\xba\x79\x86\x79\xa6\x39\xd3\xfc\x95\x79\x96\x79\xb6\x79\x8e\x79\xae\x79\x9e\xf9\x6b\xf3\x7c\xf3\x02\xf3\x42\xf3\x22\xf3\x62\xf3\x12\xf3\x52\xf3\x32\xf3\x72\xf3\x0a\xf3\x4a\xf3\x2a\xf3\x6a\xf3\x1a\xf3\x5a\xf3\x37\xe6\x75\xe6\x6f\xcd\x59\xe6\xef\xcc\xeb\xcd\xdf\x9b\x37\x98\x7f\x30\x6f\x34\xff\x68\xde\x64\xfe\xc9\x9c\x6d\xfe\xd9\xbc\xd9\xbc\xc5\x9c\x63\xde\x6a\xde\x66\xde\x6e\xde\x61\xfe\xc5\xbc\xd3\xbc\xcb\xbc\xdb\xbc\xc7\x9c\x6b\xde\x6b\xce\x33\xff\x6a\xde\x67\xfe\xcd\x9c\x6f\xde\x6f\x2e\x30\x1f\x30\x17\x9a\x7f\x37\x1f\x34\xff\x61\x3e\x64\x3e\x6c\x3e\x62\x3e\x6a\x3e\x66\x3e\x6e\x3e\x61\x3e\x69\x2e\x32\x9f\x32\x9f\x36\x9f\x31\x17\x9b\x4b\xcc\x67\xcd\xe7\xcc\xe7\xcd\x7f\x9a\x2f\x98\x2f\x9a\x4b\xcd\x97\xcc\x97\xcd\x57\xcc\x57\xcd\xd7\xcc\xd7\xcd\x65\xe6\x72\xf3\x0d\xf3\x4d\xf3\x2d\xf3\x6d\xf3\x1d\xf3\x5d\xf3\x3d\xf3\x7d\x73\x85\xf9\x81\xf9\xa1\xb9\xd2\xfc\xc8\xfc\xd8\xfc\xc4\x5c\x65\x7e\x6a\x7e\x66\x7e\x6e\xae\x36\xbf\x30\xd7\x98\x5f\x9a\x6b\xcd\xaf\xcc\x75\xe6\xd7\xe6\x37\xe6\xb7\xe6\x7a\xf3\x5f\xe6\x77\xe6\xf7\xe6\x06\xb3\xdd\x62\x16\xb7\xa2\x3f\x7e\xa8\x2c\xc3\x32\x2d\xcb\xb2\x2d\xc7\x4a\x59\x3d\xac\x32\xab\xa7\xd5\xcb\xea\x6d\xf5\xb1\xfa\x5a\x5b\x58\x5b\x5a\xfd\xac\xad\xac\xad\xad\x6d\xac\x6d\xad\xfe\xd6\x76\xd6\xf6\xd6\x00\x6b\x07\x6b\xa0\xb5\xa3\x35\xc8\xda\xc9\xda\xd9\xda\xc5\xda\xd5\xfa\x89\xb5\x9b\xf5\x53\x6b\x77\xeb\x67\xd6\x1e\xd6\xcf\xad\x3d\xad\xbd\xac\xbd\xad\x7d\xac\xc1\x56\xb9\xe5\x5a\x9e\xe5\x5b\x69\x2b\x63\x65\xad\x9c\x95\xb7\xf6\xb5\xf6\xb3\x86\x58\xfb\x5b\x07\x58\xbf\xb0\x0e\xb4\x2a\xac\x4a\xab\xca\xaa\xb6\x02\x2b\xb4\x0e\xb2\x0e\xb6\x0e\xb1\x86\x5a\x87\x5a\xc3\xac\xc3\xac\xe1\xd6\x08\xeb\x70\xeb\x97\xd6\x11\xd6\x91\xd6\x48\x6b\x94\x75\x94\x75\xb4\x35\xda\x3a\xc6\x1a\x63\x1d\x6b\x8d\xb5\x8e\xb3\x8e\xb7\x4e\xb0\x4e\xb4\x6a\xac\x71\xd6\x78\xab\xd6\x2a\x58\x13\xac\x89\x56\x9d\x55\x6f\x4d\xb2\x4e\xb2\x1a\xac\xc9\x56\xa3\xd5\x64\x4d\xb1\xa6\x5a\xcd\x56\x8b\xd5\x6a\xb5\x59\xd3\xac\xe9\xd6\x0c\xeb\x64\xeb\x14\xeb\x54\xeb\x34\xeb\x74\xeb\x0c\xeb\x4c\x6b\xa6\xf5\x2b\xeb\x2c\xeb\x6c\xeb\x1c\xeb\x5c\xeb\x3c\xeb\xd7\xd6\xf9\xd6\x05\xd6\x85\xd6\x45\xd6\xc5\xd6\x25\xd6\xa5\xd6\x65\xd6\xe5\xd6\x15\xd6\x95\xd6\x55\xd6\xd5\xd6\x35\xd6\xb5\xd6\x6f\xac\xeb\xac\xdf\x5a\xb3\xac\xdf\x59\xd7\x5b\xbf\xb7\x6e\xb0\xfe\x60\xdd\x68\xfd\xd1\xba\xc9\xfa\x93\x35\xdb\xfa\xb3\x75\xb3\x75\x8b\x35\xc7\xba\xd5\xba\xcd\xba\xdd\xba\xc3\xfa\x8b\x75\xa7\x75\x97\x75\xb7\x75\x8f\x35\xd7\xba\xd7\x9a\x67\xfd\xd5\xba\xcf\xfa\x9b\x35\xdf\xba\xdf\x5a\x60\x3d\x60\x2d\xb4\xfe\x6e\x3d\x68\xfd\xc3\x7a\xc8\x7a\xd8\x7a\xc4\x7a\xd4\x7a\xcc\x7a\xdc\x7a\xc2\x7a\xd2\x5a\x64\x3d\x65\x3d\x6d\x3d\x63\x2d\xb6\x96\x58\xcf\x5a\xcf\x59\xcf\x5b\xff\xb4\x5e\xb0\x5e\xb4\x96\x5a\x2f\x59\x2f\x5b\xaf\x58\xaf\x5a\xaf\x59\xaf\x5b\xcb\xac\xe5\xd6\x1b\xd6\x9b\xd6\x5b\xd6\xdb\xd6\x3b\xd6\xbb\xd6\x7b\xd6\xfb\xd6\x0a\xeb\x03\xeb\x43\x6b\xa5\xf5\x91\xf5\xb1\xf5\x89\xb5\xca\xfa\xd4\xfa\xcc\xfa\xdc\x5a\x6d\x7d\x61\xad\xb1\xbe\xb4\xd6\x5a\x5f\x59\xeb\xac\xaf\xad\x6f\xac\x6f\xad\xf5\xd6\xbf\xac\xef\xac\xef\xad\x0d\x56\xbb\xcd\xd8\x5c\x76\xaf\xcd\x6d\x61\x4b\x76\x1f\xfb\x1b\x7b\xcc\x56\x6c\x1e\xfb\x2b\x7b\xdc\x36\xd8\x59\xec\x11\xf6\x6b\x76\xbb\x6d\xda\x96\x6d\xdb\x8e\x9d\xb2\x7b\xb0\x27\xec\x32\xbb\xa7\xdd\x8b\x3d\xc8\xfe\x61\xf7\xb6\xfb\xb0\x85\x76\x5f\x7b\x0b\x7b\x4b\xbb\x9f\xbd\x95\xbd\xb5\xbd\x8d\xbd\xad\xdd\xdf\xde\xce\xde\xde\x1e\x60\xef\x60\x0f\xb4\x77\xb4\x07\xd9\x3b\xd9\x3b\xdb\xbb\xd8\xbb\xb2\xaf\xed\x9f\xd8\xbb\xd9\x3f\xb5\x77\xb7\x7f\x66\xef\x61\xff\xdc\xde\xd3\xde\xcb\xde\xdb\xde\xc7\x1e\x6c\x97\xdb\xae\xed\xd9\xbe\x9d\xb6\x33\x76\xd6\xce\xd9\x79\x7b\x5f\x7b\x3f\x76\xb1\x3d\xc4\xde\xdf\x3e\xc0\xfe\x85\x7d\xa0\x5d\x61\x57\xda\x55\x76\xb5\x1d\xd8\xa1\x7d\x90\x7d\xb0\x7d\x88\x3d\xd4\x3e\xd4\x1e\x66\x1f\xc6\xae\xb3\x87\xb3\x59\xec\xb7\xec\x73\x7b\x04\x7b\x94\xfd\x99\x5d\x69\x1f\x6e\xff\x92\x5d\xcf\x6e\x61\x97\xd9\x47\xb0\xab\xd9\x35\xf6\x91\xf6\x48\x7b\x94\x7d\x94\x7d\xb4\x3d\xda\x3e\xc6\x1e\x63\x1f\x6b\x8f\xb5\x8f\xb3\x8f\xb7\x4f\xb0\x4f\xb4\x6b\xec\x71\xf6\x78\xbb\xd6\x2e\xd8\x13\xec\x89\x76\x9d\x5d\x6f\x4f\xb2\x4f\xb2\x1b\xec\xc9\x76\xa3\xdd\x64\x4f\xb1\xa7\xda\xcd\x76\x8b\xdd\x6a\xb7\xd9\xd3\xec\xe9\xf6\x0c\xfb\x64\xfb\x14\xfb\x54\xfb\x34\xfb\x74\xfb\x0c\xfb\x4c\x7b\xa6\xfd\x2b\xfb\x2c\xfb\x6c\xfb\x1c\xfb\x5c\xfb\x3c\xfb\xd7\xf6\xf9\xf6\x05\xf6\x85\xf6\x45\xf6\xc5\xf6\x25\xf6\xa5\xf6\x65\xec\x7e\xfb\x72\xfb\x0a\xfb\x4a\xfb\x2a\xfb\x6a\xfb\x1a\xfb\x5a\xfb\x37\xf6\x75\xf6\x6f\xed\x59\xf6\xef\xec\xeb\xed\xdf\xdb\x37\xd8\x7f\xb0\x6f\xb4\xff\x68\xdf\x64\xff\xc9\x9e\x6d\xff\xd9\xbe\xd9\xbe\xc5\x9e\x63\xdf\x6a\xdf\x66\xdf\x6e\xdf\x61\xff\xc5\xbe\xd3\xbe\xcb\xbe\xdb\xbe\xc7\x9e\x6b\xdf\x6b\xcf\xb3\xff\x6a\xdf\x67\xff\xcd\x9e\x6f\xdf\x6f\x2f\xb0\x1f\xb0\x17\xda\x7f\xb7\x1f\xb4\xff\x61\x3f\x64\x3f\x6c\x3f\x62\x3f\x6a\x3f\x66\x3f\x6e\x3f\x61\x3f\x69\x2f\x62\x0f\xb1\x87\xed\xa7\xec\xa7\xed\x67\xec\xc5\xf6\x12\xfb\x59\xfb\x39\xfb\x79\xfb\x9f\xf6\x0b\xf6\x8b\xf6\x52\xfb\x25\xfb\x65\xfb\x15\xfb\x55\xfb\x35\xfb\x75\x7b\x99\xbd\xdc\x7e\xc3\x7e\xd3\x7e\xcb\x7e\xdb\x7e\xc7\x7e\xd7\x7e\xcf\x7e\xdf\x5e\x61\x7f\x60\x7f\x68\xaf\xb4\x3f\xb2\x3f\xb6\x3f\xb1\x57\xd9\x9f\xda\x9f\xd9\x9f\xdb\xab\xed\x2f\xec\x35\xf6\x97\xf6\x5a\xfb\x2b\x7b\x9d\xfd\xb5\xfd\x8d\xfd\xad\xbd\xde\xfe\x97\xfd\x9d\xfd\xbd\xbd\xc1\x6e\x77\x98\xc3\x1d\xe1\x48\x47\x39\x86\x63\x3a\x96\x63\x3b\x8e\x93\x72\x7a\x38\x65\x4e\x4f\xa7\x97\xd3\xdb\xe9\xe3\xf4\x75\xb6\x70\xb6\x74\xfa\x39\x5b\x39\x5b\x3b\xdb\x38\xdb\x3a\xfd\x9d\xed\x9c\xed\x9d\x01\xce\x0e\xce\x40\x67\x47\x67\x90\xb3\x93\xb3\xb3\xb3\x8b\xb3\xab\xf3\x13\x67\x37\xe7\xa7\xce\xee\xce\xcf\x9c\x3d\x9c\x9f\x3b\x7b\x3a\x7b\x39\x7b\x3b\xfb\x38\x83\x9d\x72\xc7\x75\x3c\xc7\x77\xd2\x4e\xc6\xc9\x3a\x39\x27\xef\xec\xeb\xec\xe7\x0c\x71\xf6\x77\x0e\x70\x7e\xe1\x1c\xe8\x54\x38\x95\x4e\x95\x53\xed\x04\x4e\xe8\x1c\xe4\x1c\xec\x1c\xe2\x0c\x75\x0e\x75\x86\x39\x87\x39\xc3\x9d\x11\xce\xe1\xce\x2f\x9d\x23\x9c\x23\x9d\x91\xce\x28\xe7\x28\xe7\x68\x67\xb4\x73\x8c\x33\xc6\x39\xd6\x19\xeb\x1c\xe7\x1c\xef\x9c\xe0\x9c\xe8\xd4\x38\xe3\x9c\xf1\x4e\xad\x53\x70\x26\x38\x13\x9d\x3a\xa7\xde\x99\xe4\x9c\xe4\x34\x38\x93\x9d\x46\xa7\xc9\x99\xe2\x4c\x75\x9a\x9d\x16\xa7\xd5\x69\x73\xa6\x39\xd3\x9d\x19\xce\xc9\xce\x29\xce\xa9\xce\x69\xce\xe9\xce\x19\xce\x99\xce\x4c\xe7\x57\xce\x59\xce\xd9\xce\x39\xce\xb9\xce\x79\xce\xaf\x9d\xf3\x9d\x0b\x9c\x0b\x9d\x8b\x9c\x8b\x9d\x4b\x9c\x4b\x9d\xcb\x9c\xcb\x9d\x2b\x9c\x2b\x9d\xab\x9c\xab\x9d\x6b\x9c\x6b\x9d\xdf\x38\xd7\x39\xbf\x75\x66\x39\xbf\x73\xae\x77\x7e\xef\xdc\xe0\xfc\xc1\xb9\xd1\xf9\xa3\x73\x93\xf3\x27\x67\xb6\xf3\x67\xe7\x66\xe7\x16\x67\x8e\x73\xab\x73\x9b\x73\xbb\x73\x87\xf3\x17\xe7\x4e\xe7\x2e\xe7\x6e\xe7\x1e\x67\xae\x73\xaf\x33\xcf\xf9\xab\x73\x9f\xf3\x37\x67\xbe\x73\xbf\xb3\xc0\x79\xc0\x59\xe8\xfc\xdd\x79\xd0\xf9\x87\xf3\x90\xf3\xb0\xf3\x88\xf3\xa8\xf3\x98\xf3\xb8\xf3\x84\xf3\xa4\xb3\xc8\x79\xca\x79\xda\x79\xc6\x59\xec\x2c\x71\x9e\x75\x9e\x73\x9e\x77\xfe\xe9\xbc\xe0\xbc\xe8\x2c\x75\x5e\x72\x5e\x76\x5e\x71\x5e\x75\x5e\x73\x5e\x77\x96\x39\xcb\x9d\x37\x9c\x37\x9d\xb7\x9c\xb7\x9d\x77\x9c\x77\x9d\xf7\x9c\xf7\x9d\x15\xce\x07\xce\x87\xce\x4a\xe7\x23\xe7\x63\xe7\x13\x67\x95\xf3\xa9\xf3\x99\xf3\xb9\xb3\xda\xf9\xc2\x59\xe3\x7c\xe9\xac\x75\xbe\x72\xd6\x39\x5f\x3b\xdf\x38\xdf\x3a\xeb\x9d\x7f\x39\xdf\x39\xdf\x3b\x1b\x9c\xf6\x14\x4b\xf1\x94\x48\xc9\x94\x4a\x19\x29\x33\x65\xa5\xec\x94\x93\x4a\xa5\x7a\xa4\xca\x52\x3d\x53\xbd\x52\xbd\x53\x7d\x52\x7d\xad\xb6\xc6\xfa\xc1\x83\x2b\x06\xa3\xac\x76\x9a\xa6\x15\x9a\x5b\xc6\x37\x35\x17\xe4\xe4\xb6\x72\x73\x72\x7d\x6d\x6d\x53\xab\x55\x31\x39\xfa\x48\xb9\xd1\xaa\x89\x4b\xb3\x62\x5c\x73\x61\x5a\xc1\xac\xd1\x85\x55\xd1\x34\xb1\xa9\xb1\x70\x92\x55\x13\x97\x3d\xaa\xc6\xd7\x37\x8f\x6f\x9b\x3c\xa1\xa1\x30\xa3\xc7\xf8\x62\x3d\x55\x45\xa2\x6a\xc6\x8f\x2f\x34\xb6\xa6\xc6\x77\x56\xcd\xea\xf1\x35\x91\xc8\xda\xb8\xa8\x26\xf9\x35\xad\x56\x00\xc0\x02\x00\x83\x18\xb0\xa0\x8b\x54\x50\x14\x54\xe8\xac\x5a\x01\xd4\x28\xc4\xa5\x19\xc4\x12\x0b\xba\xe8\x71\x50\x42\xa9\x89\x09\xa5\x0e\x2a\xca\x9a\xd8\x59\x2d\x3b\x68\x7c\xd3\xe4\xc9\x35\x68\x4c\x4c\x34\x7a\x1c\x9c\x90\x53\x57\xac\xab\x83\xc7\xd5\x34\xab\x3a\xca\xcc\x43\x5a\xeb\x1b\x6a\x0b\x66\xbd\x2e\xac\x43\x30\x92\x7a\x8c\xe4\x90\x78\x24\xf5\xb1\xe9\x0e\x81\xce\xf5\x71\x29\x0e\x19\x2a\xea\x27\xf5\x18\x9a\xc0\x98\x54\xac\x97\x1d\x9a\xd4\xea\xa4\x2e\x8d\x89\xd1\x13\x8a\x86\x9a\xc6\xda\xfa\xf1\xe6\xb0\x9a\xf1\x6d\xad\x05\xb3\x41\x17\x65\xc3\x92\xfd\x1a\x12\x0d\x73\x58\x6c\xa0\x06\x5d\xa8\x61\x34\x7a\xd5\x40\x99\x39\x3c\xbe\xbe\x31\xbe\x7e\x78\xf2\xfa\xc6\xe4\xf5\xc3\xe3\xeb\x1b\x63\x03\x37\xd6\x4c\x69\x6a\x69\x6d\x6e\x9a\x52\x57\x90\x41\xe3\x44\x59\x68\x9c\x68\x8d\xc0\xe0\x9b\x30\xf8\x11\xf1\xe0\x9b\x74\xd1\x73\x44\x5d\x5b\xe3\xc4\x9a\xe6\xb6\xc9\x0d\x35\x6d\xad\x3d\x9b\x92\x2d\xf3\x88\x58\x87\xe6\x58\x87\x23\x92\x3a\x34\x27\x75\x38\x22\xd6\xa1\x39\x2e\x8e\x8c\xaf\x6a\xd1\x45\x8f\x23\x13\x66\x6c\x29\xd6\xf5\x52\x2f\xcf\xb8\x65\xad\x49\x41\x23\x63\x09\xad\xb1\x31\x46\x46\xb3\xd9\x1a\xcd\xe6\xa8\x78\x36\xdb\xe2\xd9\x1c\x85\x01\xb5\x61\x40\xa3\xe2\x01\xb5\xe9\xc2\x18\xd5\x5c\xdf\x38\xd1\x68\x8b\xf2\x9e\xa3\xba\x0c\xae\x2d\xd9\xb2\x46\x61\xd6\xdb\x70\xc3\x1c\x9d\x50\x74\x7a\xa2\x7e\x4c\xa2\x7e\x72\xb1\x6e\x8e\x89\x87\x79\x8a\x2e\x52\x63\x8a\x2b\xf8\x94\xce\xaa\xd1\xd0\xd4\x38\xb1\x25\x1e\x6a\x6e\x30\xca\x72\x94\x2e\x4a\x0f\xa5\x8f\x32\x8d\x32\x83\x32\x8b\x32\x87\x32\x8f\xb2\x02\x65\x25\xca\x2a\x94\xd5\x28\x03\x94\x61\x5c\xe6\x81\x9f\x07\x7e\x1e\xb8\x79\xe0\xe6\x81\x9b\x07\x6e\x1e\xb8\x79\xe0\xe6\x81\x9b\x07\x6e\x1e\xb8\x79\xe0\xe6\x81\x9b\x07\x6e\x3e\x34\x46\xd4\x35\x35\x53\x8c\x19\xe5\xf1\xb1\x0a\x8c\xb9\x02\xd8\x15\xc0\xae\x00\x76\x05\xb0\x2b\x80\x5d\x01\xec\x0a\x60\x57\x00\xbb\x02\xd8\x15\xc0\xae\x00\x76\x45\x60\x8c\xd2\x98\x6d\x45\xcc\x4a\x8c\xb7\x12\xd8\x95\xc0\xae\x04\x76\x25\xb0\x2b\x81\x5d\x09\xec\x4a\x60\x57\x02\xbb\x12\xd8\x95\xc0\xae\x04\x76\x25\xb0\x2b\x31\xee\x4a\xd8\xbb\x0a\xf6\xae\x02\x7e\x15\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\x7e\x15\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\xd5\xc0\xaf\x06\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\x01\xf0\x03\xe0\x07\xc0\x0f\x80\x1f\x00\x3f\x00\x7e\x00\xfc\x00\xf8\x01\xf0\x03\xe0\x07\xc0\x0f\x80\x1f\x00\x3f\x00\x7e\x00\xfc\x00\xf8\x21\xf0\x43\xe0\x87\xc0\x0f\x81\x1f\x02\x3f\x04\x7e\x08\xfc\x10\xf8\x21\xf0\xc3\x7c\xaa\x22\xda\x4b\xe2\xdb\xbc\xa6\xb3\x6a\x55\x04\x71\x59\x53\x88\x37\xba\x11\x2d\x0d\x35\x2d\x75\x71\xbd\xa9\x58\xd7\x52\xdc\xc1\x83\x51\x96\xa3\x74\x51\x7a\x28\x7d\x94\x69\x94\x19\x94\x59\x94\x39\x94\x79\x94\x15\x28\x2b\x51\x56\xa1\xac\x46\x19\xa0\x8c\xad\xe1\x96\x03\xbf\x1c\xf8\xe5\xc0\x2f\x07\x7e\x39\xf0\xcb\x81\x5f\x0e\xfc\xf2\x6c\xd9\x91\xc9\x6d\xbf\x25\xd1\x40\x0f\x68\x52\x0e\x4d\xca\xa1\x49\x39\x34\x29\x87\x26\xe5\xd0\xc4\x85\x26\x2e\x34\x71\xa1\x89\x0b\x4d\x5c\x68\xe2\x42\x13\x17\x9a\xb8\xb0\x84\x0b\x4b\xb8\xb0\x84\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\x19\x67\xd2\xde\xb4\xa3\x37\x14\x5a\x5a\x70\x04\x1a\x78\xd0\xc0\x83\x06\x1e\x34\xf0\xa0\x81\x07\x0d\x3c\x68\xe0\x41\x03\x1f\x1a\xf8\xd0\xc0\x87\x06\x3e\x34\xf0\xa1\x81\x0f\x0d\x7c\x58\xc0\x87\x05\x7c\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\xd3\xc0\x4f\x03\x3f\x0d\xfc\x34\xf0\x33\xc0\xcf\x00\x3f\x03\xfc\x0c\xf0\x33\xc0\xcf\x00\x3f\x03\xfc\x0c\xf0\x33\xc0\xcf\x00\x3f\x03\xfc\x0c\xf0\x33\xc0\xcf\x00\x3f\x03\xfc\x0c\xf0\xb3\xc0\xcf\x02\x3f\x0b\xfc\x2c\xf0\xb3\xc0\xcf\x02\x3f\x0b\xfc\x2c\xf0\xb3\xc0\xcf\x02\x3f\x0b\xfc\x2c\xf0\xb3\xc0\xcf\x02\x3f\x0b\xfc\x2c\xf0\xe1\x09\xb8\xf0\x04\x5c\x78\x02\x2e\x3c\x01\x17\x9e\x80\x0b\x4f\xc0\x85\x27\xe0\xc2\x13\x70\xe1\x09\xb8\xf0\x04\x5c\x78\x02\x2e\x3c\x01\x17\x9e\x80\x0b\x4f\xc0\x85\x27\xe0\xc2\x13\x70\xe1\x09\xb8\xf0\x04\xdc\x3c\xf0\xe1\x11\xb8\xf0\x08\x5c\x78\x04\x2e\x3c\x02\x17\x1e\x81\x0b\x8f\xc0\x85\x47\xe0\xc2\x23\x70\xe1\x11\xb8\xf0\x08\x5c\x78\x04\x2e\x3c\x02\x37\x0f\x7c\xc4\x39\x6e\x05\xf0\xe1\x15\xb8\xf0\x0a\x5c\x78\x05\x2e\xbc\x02\x17\x5e\x81\x0b\xaf\xc0\x85\x57\xe0\xc2\x2b\x70\xe1\x15\xb8\xf0\x0a\x5c\x78\x05\x2e\xbc\x02\xb7\x02\xf8\x15\xc0\xaf\x04\x3e\x3c\x03\x17\x9e\x81\x0b\xcf\xc0\x85\x67\xe0\xc2\x33\x70\xe1\x19\xb8\xf0\x0c\x5c\x78\x06\x2e\x3c\x03\x17\x9e\x81\x0b\xcf\xc0\x85\x67\xe0\xc2\x33\x70\xe1\x19\xb8\xf0\x0c\x5c\x78\x06\x2e\x3c\x03\x17\x9e\x81\x0b\xcf\xc0\x85\x67\xe0\xc2\x33\x70\xe1\x09\xb8\xf0\x00\x5c\x78\x00\x2e\x3c\x00\x17\x1e\x80\x0b\x0f\xc0\x85\x07\xe0\xc2\x03\x70\xe1\x01\xb8\xf0\x00\x5c\x78\x00\x2e\x3c\x00\x17\x1e\x80\x0b\x0f\xc0\x85\x07\xe0\x82\xd1\x5d\x30\xba\x0b\x46\x77\xc1\xe8\x2e\x18\xdd\x05\xa3\xbb\x60\x74\x17\x8c\xee\x82\xd1\x5d\x30\xba\x0b\x46\x77\xc1\xe8\x2e\x18\xdd\x05\xa3\xbb\x60\x74\x17\x8c\xee\x82\xd1\x5d\x30\xba\x0b\x46\x77\xc1\xe8\x2e\x18\xdd\x05\xa3\xbb\x60\x74\x17\x8c\xee\x82\xd1\x5d\x30\xba\x0b\x46\x77\x43\xe0\x87\xc0\x0f\x81\x1f\x02\x3f\x04\x7e\x08\xfc\x30\x74\x26\x36\xd7\x4c\x2b\x10\xf5\x8d\x73\x34\xa7\x47\x35\x7d\xce\x1b\xec\x3a\x3a\x26\x49\x1c\xf1\x51\xa6\x51\x66\x50\x66\x51\xe6\x7a\xd6\x35\x35\x9d\x54\x33\xae\x69\x5a\xf2\xaa\x0a\x94\x95\x28\xab\x50\x56\xa3\x0c\x50\xc6\xb6\xf0\xc0\xe7\x1e\xf8\xdc\x03\x9f\x7b\xe0\x73\x0f\x7c\xee\x81\xcf\x3d\xf0\xb9\x57\x0e\x2d\xca\x73\x28\xf3\x28\x81\x0f\x16\xf7\xc0\xe2\x1e\x58\xdc\x03\x8b\x7b\x60\x71\x0f\x2c\xee\x81\xc5\x3d\xd7\x2d\x23\x8e\x1c\x57\x68\x68\x9a\x5e\x1c\x14\xa8\xdc\x03\x95\x7b\xa0\x72\x0f\x54\xee\x81\xca\x3d\x50\xb9\x07\x2a\xf7\x40\xe5\x1e\xa8\xdc\x03\x95\x7b\xa0\x72\x0f\x54\xee\x81\xca\x3d\x50\xb9\x07\x2a\xf7\x40\xe5\x1e\xa8\xdc\x03\x95\x7b\x1e\xf0\x3d\xe0\x83\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xc8\x3d\x10\xb9\x07\x22\xf7\x40\xe4\x1e\x88\xdc\x03\x91\x7b\x20\x72\x0f\x44\xee\x81\xa8\x3d\x10\xb5\x07\x22\xf6\x40\xc4\x1e\x88\xd8\x03\x11\x7b\xd9\xc0\x68\x6d\x6a\x6c\x6a\xe9\x59\x5b\x5f\x68\x2e\xb4\xd4\xb7\xe8\x56\xaa\xa2\x61\x4a\x5d\x8d\xae\x3a\x35\x8d\x4d\xad\x85\x86\x42\x7d\x4d\x59\x30\xa5\xa5\x9e\xa2\x77\x7d\xd8\x0e\x5a\x71\xfe\x90\x26\xd4\xca\x46\x4c\xae\x8f\x3e\x7b\x88\x1b\xa3\x12\x9d\x53\x23\x26\x17\x26\xc6\x9d\xfa\xd6\x53\xf7\x2e\x58\x86\xc6\x52\x95\x85\xd6\x1a\xe3\xa0\x1a\xf2\xa4\x2d\xe0\xa8\x31\x74\x48\x12\x8e\x31\xb2\x8e\x6a\x2a\x02\x32\x0e\xad\x99\x32\xa5\xc6\x1c\x56\x33\x79\x5c\x6d\x8d\x38\xac\x4d\x0c\x6f\x13\xa3\xeb\x2d\x20\x8b\xc3\xeb\xe5\x11\x75\x4d\xc6\x91\xf5\x13\x27\xd7\xc8\x91\x35\x6d\x16\xb4\x90\x87\xd7\xd5\xcb\x2a\x4a\x87\xb7\xd4\x97\x1d\x92\xd0\xa0\x37\x3a\x74\xb4\x53\x35\x9d\x03\x2f\x2b\x24\x87\x5b\xe8\x18\x6e\x7d\xc7\x70\xfb\xb5\x75\xbd\x34\x1e\x8c\xbe\x5e\x8d\x8b\x06\x33\x31\x1a\x8c\x51\x5b\x68\x68\xad\xb1\x20\x4b\x9d\x12\x0d\x29\x3a\xd9\xaa\x87\x14\x09\x33\x4e\xd2\x43\x6a\x88\x87\xd4\xd8\x26\x66\xd4\x5b\x4d\xf1\x78\x64\x73\x5d\x93\xd9\x12\x0d\xa6\xdc\xd0\x85\x6c\xa5\x31\x01\x57\x4e\xa1\xf1\x8c\xa7\x44\x4d\xa3\x29\x32\x70\x59\xd2\xb6\xbd\x4b\xd4\x2b\x6b\x4a\xce\x4e\x5b\x72\x76\x9a\x3a\x67\x27\x5e\x13\x20\x49\x0f\x24\xe9\x81\x24\x3d\x90\xa4\x07\x92\xf4\x40\x92\x1e\x48\xd2\x03\x49\x7a\x08\x93\x3d\x84\xc9\x1e\xc2\x64\x0f\x61\xb2\x87\x30\xd9\x43\x98\xec\x81\x54\x3d\x90\xaa\x07\x52\xf5\x40\xaa\x1e\x48\xd5\x03\xa9\x7a\x20\x55\x0f\xa4\xea\x81\x54\x3d\x90\xaa\x07\x52\xf5\x40\xaa\x1e\x48\xd5\x03\xa9\x7a\x20\x55\x0f\xa4\xea\x81\x54\x3d\x90\xaa\x07\x52\xf5\x40\xaa\x1e\x48\xd5\x03\xa9\x7a\x20\x55\x0f\xa4\xea\x81\x54\x3d\x90\xaa\x07\x52\xf5\x40\xaa\x1e\x48\xd5\x03\xa9\x7a\x20\x55\x0f\xa4\xea\x81\x54\xbd\x30\xc6\xf7\x11\x18\xfb\x08\x8c\x7d\x04\xc6\x3e\x02\x63\x1f\x74\xea\x83\x4e\x7d\xd0\xa9\x0f\x3a\xf5\x11\x18\xfb\x08\x8c\x7d\x10\xa9\x0f\x22\xf5\x41\xa4\x3e\x88\xd4\x07\x91\xfa\x20\x52\x1f\x44\xea\x83\x48\x7d\x10\xa9\x0f\x22\xf5\x41\xa4\x3e\x88\xd4\x07\x91\xfa\x20\x52\x1f\x44\xea\x83\x48\x7d\x10\xa9\x0f\x22\xf5\x41\xa4\x3e\x88\xd4\x07\x91\xfa\x20\x52\x1f\x44\xea\x83\x48\x7d\x84\xc3\x3e\xc2\x61\x1f\x1c\xea\x83\x43\x7d\x70\xa8\x0f\x0e\xf5\xc1\xa1\x3e\x38\xd4\x07\x87\xfa\xe0\x50\x1f\x1c\xea\x83\x43\x7d\x70\xa8\x0f\x0e\xf5\xc1\xa1\x3e\x38\xd4\x07\x87\xfa\xe0\x50\x1f\x1c\xea\x83\x43\x7d\x70\xa8\x0f\x0e\xf5\xc1\xa1\x3e\x38\xd4\x07\x87\xfa\xe0\x50\x1f\x1c\xea\x83\x43\x7d\x70\xa8\x0f\x0e\xf5\xc1\xa1\x3e\x38\xd4\x07\x87\xfa\xe0\x50\x1f\x1c\xea\x83\x43\x7d\x70\xa8\x0f\x0e\xf5\xc1\xa1\x3e\x38\xd4\x07\x87\xfa\xe0\x50\x1f\x1c\xea\x83\x43\x7d\x70\xa8\x0f\x0e\xf5\xc1\xa1\x3e\x38\xd4\x07\x87\xfa\xe0\x50\x1f\x1c\xea\x83\x43\x7d\x70\xa8\x0f\x0e\xf5\xc1\xa1\x3e\x38\xd4\x07\x87\xfa\xe0\x50\x1f\x1c\xea\x83\x43\x7d\x70\xa8\x0f\x0e\xf5\xc1\xa1\x3e\x38\xd4\x07\x87\xfa\xe0\x50\x1f\x1c\xea\x83\x43\x7d\x70\xa8\x0f\x0e\xf5\xc1\xa1\x3e\x38\xd4\x07\x87\xfa\xe0\x50\x1f\x1c\xea\x83\x43\x7d\x70\xa8\x0f\x0e\xf5\x11\x0c\xfb\x08\x86\x7d\x04\xc3\x3e\x82\x61\x1f\x1c\xeb\x83\x63\x7d\x04\xc3\x3e\x82\x61\x1f\xc1\xb0\x8f\x60\xd8\x07\x07\xfb\xe0\x60\x1f\x1c\xec\x83\x83\x7d\x04\xc3\x3e\x82\x61\x1f\xc1\xb0\x8f\x60\xd8\x47\x30\xec\x23\x18\xf6\x11\x0c\xfb\x08\x86\x7d\x04\xc3\x3e\x82\x61\x1f\xc1\xb0\x8f\x60\xd8\x47\x30\xec\x23\x18\xf6\x11\x0c\xfb\x08\x86\x7d\x04\xc3\x3e\x82\x61\x1f\xc1\xb0\x8f\x60\xd8\x47\x30\xec\x23\x18\xf6\x11\x0c\xfb\x08\x86\x7d\x04\xc3\x3e\x82\x61\x1f\xc1\xb0\x8f\x60\xd8\x47\x30\xec\x23\x18\xf6\x11\x0c\xfb\x08\x86\x7d\x04\xc3\x3e\x82\x61\x1f\xc1\xb0\x8f\x60\xd8\x47\x30\xec\x23\x18\xf6\x11\x0c\xfb\x08\x86\x7d\x04\xc3\x3e\x82\x61\x1f\xc1\xb0\x8f\x60\xd8\x47\x30\xec\x23\x18\xf6\x11\x0c\xfb\x08\x86\x7d\x04\xc3\x3e\x82\x61\x1f\xc1\xb0\x8f\x60\xd8\x47\x30\xec\x23\x18\xf6\x11\x0c\xfb\x08\x86\x7d\x04\xc3\x3e\x82\x61\x1f\xc1\xb0\x8f\x60\xd8\x47\x30\xec\x23\x18\xf6\x11\x0c\xfb\x08\x86\x7d\x04\xc3\x3e\x82\x61\x1f\xc1\xb0\x8f\x60\xd8\x47\x30\xec\x23\x18\xf6\x11\x0c\xfb\x08\x86\x7d\x7c\x4c\xee\xe3\x63\x72\x1f\xc1\xb1\x8f\x8f\xc9\x7d\x04\xc9\x3e\x82\x64\x1f\x41\xb2\x8f\x20\xd9\x47\x90\xec\x23\x48\xf6\xc1\xff\x3e\xf8\xdf\x07\xff\xfb\xe0\x7f\x1f\xfc\xef\x83\xff\x7d\xf0\xbf\x0f\xfe\xf7\xab\x73\x4e\xcd\x84\xfa\xfa\xf2\xc1\xb9\x8e\x9d\x09\x1e\x80\x0f\x0f\xc0\x87\x07\xe0\xc3\x03\xf0\xe1\x01\xf8\xf0\x00\x7c\x78\x00\x3e\x3c\x00\x1f\x1e\x80\x0f\x0f\xc0\x87\x07\xe0\xc3\x03\xf0\xe1\x01\xf8\xf0\x00\x7c\x78\x00\x3e\x3c\x00\x1f\x1e\x80\x0f\x0f\xc0\x87\x07\xe0\xc3\x03\xf0\xe1\x01\xf8\xf0\x00\x7c\x78\x00\x3e\x3c\x00\x1f\x1e\x80\x0f\x0f\xc0\x87\x07\xe0\xc3\x03\xf0\xe1\x01\xf8\xf0\x00\x7c\x78\x00\x3e\x3c\x00\x1f\x1e\x80\x0f\x0f\xc0\x87\x07\xe0\xc3\x03\xf0\xe1\x01\xf8\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\xf0\x00\xd2\x60\xf4\x34\x18\x3d\x0d\x46\x4f\x83\xd1\xd3\xd8\x39\xd2\xd8\x39\xd2\xd8\x39\xd2\xd8\x39\xd2\xd8\x39\xd2\xd8\x39\xd2\xd8\x39\xd2\xd8\x39\xd2\xd8\x39\xd2\xd8\x39\xd2\xd8\x39\xd2\xd8\x39\xd2\xf9\x0e\x1c\xe8\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x8d\x9d\x23\x5d\x11\x1a\x2d\x75\x85\x69\x35\x29\x8a\x1d\x6a\x26\xb4\x14\x26\x36\x35\xc4\xd5\x29\x94\xd5\xf5\xd0\xd5\xa9\x35\x93\x6b\x5a\x5b\x8c\xba\xfa\xe6\xfa\xa9\x46\x6b\x0b\x79\xe5\x86\xee\x68\xe8\x3e\x66\xc7\xe9\x26\x0a\x04\x62\xa1\x95\x15\xe6\xd4\xb6\x71\x6d\xad\x2d\x66\x6d\xcd\xc4\x42\x4b\x9d\x31\xb9\xd0\x5a\x98\x68\x4c\xae\x99\x5a\x33\x41\x35\xd7\x4c\x28\xd0\x95\x2d\x85\xa9\x56\xf4\x2d\xc3\xe8\xe9\x78\x8b\x2e\xec\x96\x26\x42\x6d\x69\x9b\xea\xb4\x4d\x99\x52\x68\x3e\x21\x3a\xd4\xd0\x34\xbd\xd0\x1c\xbd\x2e\xa1\xe5\x56\x65\x7a\xc4\x60\x53\x09\xb8\x51\xd5\x34\x14\x26\x48\x0a\x58\x8c\x89\xf5\x93\x0b\x0d\x46\x2d\xb5\x5b\x45\x5d\x41\x4e\xab\x99\x66\x9c\x52\x73\x72\x7d\xa3\xa4\x50\x45\xb6\x52\x3a\xb9\xa9\xd6\x9e\x50\xdf\x58\xd3\x70\x52\xcd\x04\x49\xc9\x20\x55\x0b\x38\x34\xb9\x30\x59\x52\x8a\x1b\x8d\x6d\x8d\x92\x92\xd9\x42\xe7\x4f\xaa\x53\x91\x10\x4b\x9f\x98\x52\x10\x53\x0a\x29\x5d\x6d\x6d\xa1\x50\xc5\xd0\xb9\x9c\xda\x44\x03\xa2\x11\xaa\x68\x28\x14\xe3\x4c\x33\x09\x7c\x5a\x5c\x10\xa8\x49\x29\x2a\x26\x46\x91\x4c\x9d\x43\x45\x4b\x1d\xc9\xd4\x66\x2a\xaf\x8e\xef\x15\x2a\xcb\x51\xba\x28\x3d\x94\x3e\xca\x34\xca\x0c\xca\x2c\xca\x1c\xca\x3c\xca\x0a\x94\x95\x28\xab\x50\x56\xa3\x0c\x50\x86\x71\x59\x0e\xfc\x72\xe0\x97\x03\xbf\x1c\xf8\xe5\xc0\x2f\x07\x7e\x39\xf0\xcb\x81\x5f\x0e\xfc\x72\xe0\x97\x03\xbf\x1c\xf8\xe5\xc0\x2f\x07\x7e\x39\xf0\xcb\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\xef\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x06\x7e\x1a\xf8\x69\xe0\xa7\x81\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x05\x7e\x16\xf8\x59\xe0\x67\x81\x9f\x03\x7e\x0e\xf8\x39\xe0\xe7\x80\x9f\x03\x7e\x0e\xf8\x39\xe0\xe7\x80\x9f\x03\x7e\x0e\xf8\x39\xe0\xe7\x80\x9f\x03\x7e\x0e\xf8\x39\xe0\xe7\x80\x9f\x07\x7e\x1e\xf8\x79\xe0\xe7\x81\x9f\x07\x7e\x1e\xf8\x79\xe0\xe7\x81\x9f\x07\x7e\x1e\xf8\x79\xe0\xe7\x81\x9f\x07\x7e\x1e\xf8\x79\xe0\xe7\x81\x5f\x01\xfc\x0a\xe0\x57\x00\xbf\x02\xf8\x15\xc0\xaf\x00\x7e\x05\xf0\x2b\x80\x5f\x01\xfc\x0a\xe0\x57\x00\xbf\x02\xf8\x15\xc0\xaf\x00\x7e\x05\xf0\x2b\x80\x5f\x09\xfc\x4a\xe0\x57\x02\xbf\x12\xf8\x95\xc0\xaf\x04\x7e\x25\xf0\x2b\x81\x5f\x09\xfc\x4a\xe0\x57\x02\xbf\x12\xf8\x95\xc0\xaf\x04\x7e\x25\xf0\x2b\x81\x5f\x05\xfc\x2a\xe0\x57\x01\xbf\x0a\xf8\x55\xc0\xaf\x02\x7e\x15\xf0\xab\x80\x5f\x05\xfc\x2a\xe0\x57\x01\x3f\x04\x4e\xec\x93\x95\x07\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\xc8\x86\xe6\xd1\xfa\x59\xa7\x39\x3d\x2e\x8e\x8e\x5f\x72\x9c\xae\x0b\xe7\xe8\x8e\x0f\xd8\x9d\xe9\x1d\xb5\xf8\x3a\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x00\x3c\x13\x80\x67\x02\xf0\x4c\x00\x9e\x09\xc0\x33\x01\x78\x26\x00\xcf\x04\xe0\x99\x20\x1f\x38\x15\x1d\xcf\x2b\x9d\x9a\x8e\x5a\xaa\xa2\xf3\xc9\x6c\xaa\xa6\xb3\xda\xa7\xa2\xf8\xd2\xa7\x36\x43\x9f\x9a\xd2\x03\x89\x1e\xda\x6c\xc9\x1e\xfa\x40\xbf\x44\x8f\x4e\xc1\xfd\x6a\xba\x39\x98\x94\xa5\x9f\x2c\x27\x65\xe9\x03\x5b\x26\x7a\x74\x68\xbe\x65\xcd\xc6\xc7\x7a\xc4\xef\x87\xc7\x2f\xa4\xd5\x24\xea\xf1\x71\xad\x17\x8e\xeb\x7a\xef\xf8\x78\xa7\x26\xbd\x6b\xba\xb6\x71\x9d\xd6\x01\xd7\xe9\x7a\xaf\xf8\x78\x07\x6c\xaf\x9a\x2e\x4d\x27\xe8\xac\x75\x1e\x4b\x05\x45\x3b\x17\xe5\x9b\x41\xfc\x92\x6f\x2c\xb5\x4f\x50\x6a\xe4\x42\xe9\x81\xa0\xd4\xea\x85\x52\xab\x07\xdd\x59\xbd\xd0\x9d\xd5\x83\x52\xab\x17\x4a\xad\x1e\x74\x63\xf5\xc2\xc6\xc7\x52\x87\x14\xc7\x56\xdf\x59\x75\x0e\xe9\xb4\x42\x7d\x67\x6d\x44\x67\xad\xa9\xf3\xea\x11\xc5\xab\x9b\x8a\xda\x8d\x28\x1d\x7a\x53\xe9\x81\x11\xa5\xb6\x68\x2a\xb5\xc5\x88\xee\x6c\xd1\xd4\x9d\x2d\x46\x94\xda\xa2\xa9\xd4\x16\x23\xba\xb1\x45\x53\x37\xb6\xd0\x2f\x00\xc7\x2f\x4e\x36\x15\xab\xfa\xa8\x56\x2a\x3e\xaa\xab\xbd\xf4\xd1\x4e\x25\x7a\x35\x75\x69\xc6\xd7\x68\xf0\xf8\x1a\x5d\xed\xa9\x8f\x76\xa0\xf5\x6c\x4a\xb6\x9c\x51\x9d\xb5\xb6\x4e\x7d\x46\x15\x05\xb6\x15\xab\xa3\x8a\xaa\xb5\x15\xab\xa3\x8a\x5a\xb6\x15\xb5\x1c\xd5\x55\xcb\xb6\xae\x5a\x8e\x2a\x6a\xd9\x56\xd4\x72\x54\x17\x2d\xdb\x92\x2d\xf3\x98\x78\x9b\x3d\x59\x17\xce\x31\x9d\x3a\x9f\xdc\xa9\xf3\x31\x45\xf1\x27\x17\xef\x95\x63\xe2\x7b\xe5\xe4\xf8\x85\xf8\x68\x4f\x0b\xe1\xb3\x85\xf0\xd9\x42\xf8\x6c\x21\x7c\xb6\x10\x3e\x5b\x08\x9f\x2d\x84\xcf\x16\xc2\x67\x0b\xe1\xb3\x85\xf0\xd9\x42\xf8\x6c\x21\x7c\xb6\x10\x3e\x5b\x08\x9f\x2d\x84\xcf\x16\xc2\x67\x0b\xe1\xb3\x85\xf0\xd9\x42\xf8\x6c\x21\x7c\xb6\x10\x3e\x5b\x08\x9f\x2d\x84\x8f\x16\xc2\x47\x0b\xe1\xa3\x85\xf0\xd1\x42\xf8\x68\x21\x7c\xb4\x10\x3e\x59\x08\x9f\x2c\x84\x4f\x16\xc2\x27\x0b\xe1\x93\x85\xf0\xc9\x42\xf8\x64\x21\x7c\xb2\x10\x3e\x59\x08\x9f\x2c\x84\x4f\x16\xc2\x27\x0b\xe1\x93\x85\x6e\x07\x1e\xc6\x07\x9f\x2c\x84\x4f\x16\xc2\x27\x0b\xe1\x93\x85\xf0\xc9\x42\xf8\x64\x21\x7c\xb2\x10\x3e\x59\x08\x9f\x2c\x84\x4f\x16\xc2\x27\x0b\xe1\x93\x85\xf0\xc9\x42\xf8\x64\x21\x7c\xb2\x10\x3e\x59\x08\x9f\x2c\x84\x4f\x16\xc2\x27\x0b\xe1\x93\x85\xf0\xc9\x42\xf8\x64\x21\x7c\xb2\x10\x3e\x58\x08\x1f\x2c\x84\x0f\x16\xc2\x07\x0b\xe1\x83\x85\xf0\xc1\x42\xf8\x5c\x21\x7c\xae\x10\x3e\x57\x08\x9f\x2b\x84\xcf\x15\xc2\xe7\x0a\xe1\x73\x85\xf0\xb9\x42\xf8\x5a\x21\x7c\xac\x30\xdd\x21\x17\xfa\xc3\xa7\x0a\xe1\x53\x85\xf0\xa9\x42\xf8\x54\x21\x7c\xaa\x10\x3e\x55\x08\x9f\x2a\x84\x4f\x15\xc2\xa7\x0a\xe1\x53\x85\xf0\xa9\x42\xf8\x54\x21\x7c\xaa\x10\x3e\x55\x08\x9f\x2a\x84\x4f\x15\xc2\xa7\x0a\xe1\x53\x85\xf0\xa9\x42\xf8\x54\x21\x7c\xaa\x10\x3e\x55\x08\x9f\x2a\x84\x4f\x15\xc2\xa7\x0a\xe1\x53\x85\xf0\xa9\x42\xf8\x54\x21\x7c\xaa\x10\x3e\x55\x88\x58\x3d\x44\xac\x1e\x22\x56\x0f\x11\xab\x87\x88\xd5\x43\xc4\xea\x21\x7c\xa8\x10\x3e\x54\x08\x1f\x2a\x84\x0f\x15\xc2\x87\x0a\xe1\x43\x85\xf0\xa1\xc2\x5c\x07\x1e\xc6\x0b\x1f\x2a\x84\x0f\x15\xc2\x87\x0a\xe1\x43\x85\xf0\xa1\x42\xf8\x50\x21\x7c\xa8\x10\x3e\x54\x08\x1f\x2a\x84\x0f\x15\xc2\x87\x0a\xe1\x43\x85\xf0\xa1\x42\xc4\xea\x21\x62\xf5\x10\xb1\x7a\x88\x58\x3d\x44\xac\x1e\x22\x56\x0f\x11\xab\x87\x88\xd5\x43\xc4\xea\x21\x62\xf5\x10\xb1\x7a\x88\x58\x3d\x44\xac\x1e\x22\x56\x0f\x11\xab\x87\x88\xd5\x43\xc4\xea\x21\x62\xf5\x10\xb1\x7a\x88\x58\x3d\x44\xac\x1e\x22\x56\x0f\x11\xab\x87\x88\xd5\x43\xc4\xea\x21\x62\xf4\x10\x31\x7a\x88\x18\x3d\x44\x8c\x1e\x22\x46\x0f\x11\xa3\x87\x88\xd1\x43\xc4\xe8\x21\x62\xf4\x10\x31\x7a\x88\x18\x3d\x44\x8c\x1e\x22\x46\x0f\x11\xa3\x87\x88\xd1\x43\xc4\xe6\x21\x62\xf3\x10\xb1\x79\x88\xd8\x3c\x44\x6c\x1e\x56\x01\xb7\x0a\xb8\x55\xc0\xad\x02\x6e\x15\x70\xab\x81\x5b\x0d\xdc\x6a\xe0\x56\x03\xb7\x1a\x78\xd5\xc0\xab\x06\x5e\x35\xf0\xaa\x81\x57\x0d\xbc\x6a\xe0\x54\x03\xa7\x1a\x38\x01\x70\x02\xe0\x04\xc0\x09\x80\x13\x60\x7c\x01\xe6\x35\x00\x6e\x00\xdc\x00\xb8\x01\x70\x03\xe0\x06\xc0\x0d\x30\xce\x00\xf8\x01\xf0\x03\xe0\x87\xc0\x0b\x81\x17\x02\x2f\x04\x4e\x08\x9c\x10\x38\x21\x70\x42\xe0\x84\xc0\x09\x81\x13\x02\x27\xfe\x0c\xc4\x1d\x1c\xf3\x28\x95\xe5\x28\x5d\x94\x1e\x4a\x1f\x65\x1a\x65\x06\x65\x16\x65\x0e\x65\x1e\x65\x05\xca\x4a\x94\x55\x28\xab\x51\x76\xe0\x86\x71\x59\x0e\xbc\x72\xc8\x2f\xcf\xf4\xd4\x7f\xdf\x4e\x7f\x1f\xb4\x76\x5c\x43\xcf\xa9\x6d\x4d\xd1\x5f\x53\x8d\xbe\x22\x5a\xa8\x45\x1f\x5c\xeb\x02\xcb\x05\x96\x0b\x2c\x17\x58\x2e\xb0\xdc\xd0\x9c\x5c\xdf\xa8\xbf\xa5\x57\x18\xdf\xd4\x08\x29\x9e\xef\x14\x66\x8c\x6f\xa8\x99\x4c\x28\x4e\x73\x4d\x6d\xf4\x37\x1b\xe3\x6f\xea\xb9\x83\xd3\xb8\x32\x03\x84\x0c\x10\x32\x40\xc8\x00\x21\xd3\xd1\x2f\x2c\x9b\xd0\xd4\xd6\xdc\xd2\x36\xa5\xd0\x5c\xdf\xd4\x5c\x36\xa1\x7e\x5a\xa1\xa3\xd1\xb3\x85\x94\x6f\xec\x6c\x15\xa2\xbf\x50\xdc\xd1\x72\x3a\x8f\xc7\x72\xf2\x98\x8d\x3c\x66\x23\x0f\xeb\xe4\x31\x1b\x79\xcc\x46\x05\xfa\x55\xa0\x5f\x85\xab\x1a\xea\x9b\x6b\xd0\x80\x29\x2b\x32\xe6\x94\x42\x4b\xa1\xb5\xe3\x30\x66\xaa\x22\x6f\xb6\xd4\x15\xa6\x16\x1a\x54\x6d\x53\xe3\x44\x15\xfd\xe5\x48\x9c\xc0\xa0\x2a\x30\xa8\x0a\x98\xb9\x12\x60\x95\x00\xab\x84\x52\x95\x50\xaa\x12\x4a\x55\x02\x37\x7e\xc4\xea\x96\x63\xc9\x94\xc7\x2e\x11\x95\x19\x94\x59\x39\xa2\x6e\xb2\x53\x68\x69\xad\x9f\x5c\xd3\x8a\x49\x2d\x8f\x89\x99\xca\xc0\x6e\x6a\x2c\xb4\xd6\xd5\x37\xd7\x3a\xad\xd3\x9b\x74\xa5\xc5\xa1\x43\xda\x70\x75\x65\xad\x75\xcd\x05\xd4\x5b\x7a\x44\x76\x46\xbd\x4c\x9b\x19\x8d\x58\x54\xce\x77\x6a\x9a\x9b\x9b\xa6\x37\x14\x26\xb4\x5a\xba\xd6\x36\x25\xa5\x4b\xfd\x67\xa2\xe3\x93\xb5\x4d\xd3\x1b\xe3\xda\x38\x02\x73\xd0\xad\xb6\xb1\xac\xb3\x36\xae\x45\xfb\x9c\x2e\xbe\xa6\xe4\xba\xe5\xe9\x54\x53\x73\x6b\x5d\xf4\x4d\xca\x9a\x86\xb2\xfa\xc6\xd6\x68\x6d\xea\xbf\xd7\xdb\xa3\x30\xb5\xad\x7e\x1a\xad\xa3\xc6\xf1\x05\xa3\xae\xa9\xad\xa5\xd0\x93\x96\x6e\x43\xd3\xc4\x68\x71\x35\x36\xb5\xa6\xa2\xce\xe4\xfd\x36\xb4\x4e\xe9\xac\x8e\xd3\x0f\xef\x5c\x3c\x19\x76\xf1\x44\xd8\xc5\x93\x5c\x17\x4f\x6c\xa9\xf4\x51\xe6\x50\xe2\xbc\x8b\xe3\x58\xfd\x69\x0f\x6d\x0f\xed\x34\xae\x8f\x3d\x1d\x2a\x21\x3f\xf6\x74\xa8\x44\xff\xd8\xd3\xa1\x32\x83\x32\x8b\x12\x78\xb1\xc7\x43\x65\x05\xca\x4a\x94\x1d\x38\xd5\x28\x03\x94\xf1\xf2\x49\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x7e\x06\xf8\x19\xe0\x67\x80\x9f\x01\x3e\xee\xc9\x34\xee\xc9\x74\x74\x4f\x4e\x19\xd7\xd0\x34\xfe\x24\x8b\xe6\x2a\x2a\x8d\xb8\xd5\x30\x21\x2e\x9b\x5b\xd1\x6e\x6d\xa9\xab\xa9\x2d\x18\x3a\xb7\x6a\x4f\xd2\xa5\x33\xa1\xbe\xa1\x81\x36\x9a\xa6\xf8\xce\xc7\xf3\x65\x17\xcf\x87\xa9\xac\x4c\xc5\x3d\x9a\x69\x86\xad\xd6\xe6\xfa\x9a\x89\x6d\x53\xe2\xb2\x19\xed\xda\xc6\xb8\x6c\x98\x60\x46\x51\x61\x43\xbc\x5a\xd2\x55\xb0\x4b\x55\xe8\xd4\x37\x4e\x1b\xd7\x46\x42\x5a\xa3\x5a\xdc\x27\xd5\x34\xa5\xd0\x88\x83\x2d\x93\xeb\x69\x89\xd6\x8c\x2f\xd0\x5a\x9a\xd6\xd9\x90\x2d\x6d\x8d\xe6\x84\xc2\x64\x5a\x4d\x2a\xca\x8c\x96\x29\xa4\xaf\x1a\xdf\xd0\x36\xce\xa8\x2b\xd4\x10\x7a\x6d\x7d\xcd\x64\xda\xce\x7a\x4c\x6e\x6b\xc1\xfa\x2a\xf4\x4a\xd4\x69\x5f\xd3\x1a\x64\x62\x9f\xd0\xad\xc2\x4c\x54\x61\x26\xaa\x30\x13\x55\x98\x89\x2a\xcc\x44\x15\x66\xa2\x0a\x33\x51\x85\x99\xa8\xc2\x4c\x54\x61\x26\xaa\x30\x13\x55\x98\x89\x2a\xec\x8e\x55\xd8\x1d\xab\xb2\xc0\xc9\x02\x27\x0b\x9c\x2c\x70\xb2\xc0\xc9\x02\x27\xf6\x3d\x5d\x7c\xae\x5d\x91\xed\x2c\x73\x28\xf3\x28\x2b\x50\x56\xa2\xac\x42\x59\x8d\x32\x40\x19\xc6\x65\x1c\x4b\x51\x59\x1e\x97\x39\xc8\xcb\x41\x5e\x0e\xf2\x72\x90\x17\xfb\x9a\x21\xb8\x8f\x5c\xaa\x6a\x94\x41\x59\xfc\xbc\xfa\x04\xfd\x60\xbf\x37\xdd\xc6\x05\x0a\xa0\xa3\x3f\x0b\x1c\x3d\x08\xb7\xa3\xe7\xed\xd3\xeb\x69\x4d\xe9\x27\xed\x51\xcd\xac\x2b\x44\x85\x75\x52\x4d\x7c\x42\x3f\x56\x8f\x6a\x65\x1d\x8f\xd6\xa3\x86\x1d\x3d\xfc\xd6\xfd\x5a\x6b\xa6\xe9\xb3\x24\xf9\x84\x29\x0d\x6d\x2d\xd1\x1f\x9b\xed\x11\x3d\x3a\xc7\x9b\x00\x29\x5d\xd7\xd5\xbe\xfa\x90\x7e\x7d\x00\x27\xfb\x24\x8e\xe8\x03\x4e\xa4\x90\x56\x35\x15\xd5\xe2\x57\x03\xf4\xc1\xc9\x35\x53\xea\xa7\x3a\xe3\x0a\xad\x71\xf7\x1e\xfa\x05\x01\xd4\xb5\xf2\x71\xdd\xae\x2b\xc4\x15\x67\x5a\xcd\x34\x9c\xd6\x2f\x0e\xe0\x68\x6b\x47\x47\x87\x8c\x12\xd7\x7a\x75\xbc\x46\x80\x13\x9d\xb5\x1e\x7a\xec\x38\x4a\x03\x47\xad\xb1\x0d\xc2\xca\xe2\x57\x0a\xe2\x46\x4f\xbc\x53\x00\x35\x3a\x2a\x3d\xf4\x4b\x05\xb8\x72\x6a\x13\x24\xa7\x22\xf3\xa1\x5a\x34\x81\xd3\xda\xa1\xb2\x4d\xca\xc7\x2f\x5f\xd0\x80\xa3\xb7\x2b\xa2\xe9\x88\x4a\xa2\xc7\xa8\xd0\x16\xd1\xda\xe9\x69\xc6\xe3\x90\x10\x8f\x43\x42\x3c\x0e\x09\xf1\x38\x24\x24\x57\x4a\x35\xd2\x8d\x2b\xa7\xd4\x97\xf7\x1c\x7f\x72\x33\xed\x0e\xf5\xe3\xf5\xa7\x80\x7d\xf4\x17\xf9\x13\xdf\x19\xed\x9b\xa8\x37\x47\x6f\x97\x17\x52\xfa\xa3\x8f\xbd\x69\x7e\xcb\x8b\x55\xb7\x58\xf5\x52\xfa\xf3\x98\xb8\x43\x67\xd5\x2d\x56\xbd\x5e\x9d\x1f\x8b\xe8\x4e\x5d\x9b\x6e\xd7\xa6\x97\xd2\x9f\x98\xc4\xd2\x3a\xab\x6e\x4a\x6b\xab\x8f\xf6\x2e\x7e\x8e\xa5\xdb\x3d\x3b\x3e\x89\x29\xd1\xc0\x2f\x56\xd3\x45\x6d\xfd\x62\x35\xdd\x15\xd9\xef\xda\x4c\x17\xd1\x13\x3a\xf9\xc5\x6a\xa2\x43\xa6\x58\xcd\x16\xab\xb9\x2e\x9a\xb9\x5d\x5a\x5e\x97\x96\xdf\xa5\x95\xee\xd2\x4a\xc8\xce\x77\x39\x91\xed\xd2\xea\x0a\x96\xef\xd5\xc5\x28\x83\xbb\x36\xcb\xbb\x36\xdd\xae\x4d\xaf\x6b\xd3\xef\xda\x4c\xf7\x28\xce\xcf\xe0\x44\xbd\x3c\x51\x77\x13\x75\x3d\xd0\xe8\xab\xb9\xf5\xf1\xe4\xd1\x72\x8c\xbe\x62\x15\x7d\x0d\x6b\xef\xf1\x35\x53\x12\xed\xf2\x92\x76\x55\x49\x7b\x70\xa2\x9d\x2d\xb9\xde\xeb\xd2\x76\x83\x34\x52\xa6\xa4\x9d\x2d\x69\xe7\x4a\xda\xf9\x44\x3b\x13\x95\x25\xed\x4c\x49\x3b\x5b\xd2\xce\x95\xb4\xf3\x3d\x12\xed\xc4\xb9\x6c\x89\xec\x6c\x37\xe7\xb3\x25\xed\x5c\x49\x3b\x29\x3b\xd9\x37\x57\x22\x3b\x57\x22\x3b\xd7\x4d\xff\x5c\x49\x3b\x29\x3b\x79\x2e\x5f\x22\x3b\x5f\x22\x3b\x5f\x22\x3b\xdf\xcd\xf5\x49\xd9\x1d\xf6\xce\x74\xcc\x41\x49\x3b\x53\xd2\xce\x96\xb4\x73\x25\xed\x0e\xd9\x99\x12\x59\xdd\xb5\xb3\x25\xed\x5c\x49\x3b\xa9\x5b\xb6\xe4\xfa\x6c\x89\x6e\xd9\x12\x79\xd9\x12\x79\xd9\x12\xdd\x92\x7d\x73\x25\xb2\x73\x25\xb2\x73\xdd\xf4\xcf\x95\xb4\x93\xb2\x93\xe7\xf2\x25\xb2\xf3\x25\xb2\xf3\x25\xb2\xf3\xdd\x5c\x9f\x94\xdd\x61\x93\x6c\xc9\x7c\x65\x4b\xe6\x2b\x5b\x32\x5f\xd9\x92\xf9\xca\x96\xcc\x57\xb6\x44\x56\xa6\x9b\x76\xa6\xa4\x9d\x2d\x69\xe7\x4a\xda\x49\xd9\xc9\x6b\x4b\xb1\xba\x3b\x9f\x2b\x69\x27\xc7\x9d\x2b\xb9\x3e\x57\x72\x7d\xae\x44\xb7\x5c\x89\xbc\x5c\x89\x6e\xc9\x73\xf9\x12\xd9\xf9\x12\xd9\xf9\x12\xd9\xf9\x6e\xae\x4f\xca\xee\xd0\x3b\x57\x32\x5f\xb9\x92\xf9\xca\x95\xcc\x57\xae\x64\xbe\x72\x25\xf3\x95\x2b\x91\x95\xe9\xa6\x9d\x29\x69\x67\x4b\xda\xb9\x92\x76\x52\x76\xf2\xda\x6c\x89\xec\x6c\x37\xe7\xb3\x25\xed\x5c\x49\x3b\x29\x3b\xd9\xb7\x74\x1c\xa5\xd8\xdd\xf5\x4f\xda\x34\x5f\x72\x7d\xbe\xe4\xfa\x7c\xc9\xf5\xf9\x12\xdd\xf2\x25\xba\x75\xc8\xce\x97\xcc\x57\xbe\x64\xbe\xf2\x25\xf3\x95\x2f\x99\xaf\x7c\xc9\x7c\xe5\x4b\x64\x65\xba\x69\x67\x4a\xda\xd9\x92\x76\xae\xa4\x9d\x94\x9d\xbc\x36\x5b\x22\x3b\xdb\xcd\xf9\x6c\x49\x3b\x57\xd2\x4e\xca\x4e\xf6\xcd\x95\xc8\xce\x95\xc8\xce\x75\xd3\x3f\x57\xd2\x4e\xca\x4e\x9e\x2b\xb5\x51\xe9\xb8\x4a\x75\x89\xaf\xef\xf0\xa6\x4f\x68\x6a\x8d\x7e\x23\xc9\x89\xfd\x54\x3a\x0a\xcf\xc4\x2f\xf1\x5c\xfc\x12\x4f\xc7\xeb\xa6\x9d\x4b\xb4\xcb\x23\x6f\x27\xd1\xae\x2a\x69\xfb\x1d\xfd\xcb\xc6\xd5\x34\xd7\x77\xfc\x1d\x94\x2d\xf5\xc9\xca\xf2\xb8\x43\x79\x24\x74\x70\x37\xc7\xca\x4b\x8e\xf9\xdd\xf4\xf3\x4b\xfa\x65\xba\x91\x97\xe9\x46\x5e\xa6\x1b\x79\x99\x12\x79\xf9\x6e\xf4\xcb\x77\xa3\x5f\xbe\x1b\xfd\xf2\xdd\xe8\x97\xef\x46\xbf\x7c\x37\xfa\xe5\xbb\xd1\x2f\xbf\xb1\x7e\x55\xe9\x8d\xf5\xeb\x72\xac\xb4\x9f\xdf\x4d\xbf\x52\x79\x99\x6e\xe4\x65\xba\x91\x97\xe9\x46\x5e\x77\xf6\xcb\x75\x2c\xb2\x6e\x8e\x95\xf6\xcb\x74\xd3\x2f\x53\x82\x5b\x22\xaf\xcb\xb1\xd2\x7e\x99\x6e\xfa\x69\x79\xd1\xdf\x1a\x68\x2d\xd4\xd6\xeb\x08\xcc\x0e\x1a\x27\x6a\xe7\xbf\xa3\xe2\x76\x54\x3c\xfb\x94\x42\x73\x53\x54\xb3\x9a\x1a\x75\xbc\x60\xb5\x4e\xd7\x6d\x47\x7f\x66\x1a\xd5\xec\xe8\x53\xea\xb8\x52\x1f\x47\x66\x56\x4b\xbd\x8e\xfc\x1c\xfd\xf1\xa9\xae\xe9\xcf\x50\x75\xa7\xc6\xfa\x58\x50\x8f\xce\x8f\xc7\xf7\x8e\xff\x94\x1d\x3e\x2b\x26\xed\xf2\xd6\xa8\xe1\x87\x44\x1f\x8d\xf6\x2e\x79\x49\xa3\x77\xc9\x2b\x19\xbd\xba\xbe\x7c\xd1\xbb\xe4\x2d\x8b\x54\xf1\x95\x9d\x54\xf1\x2d\x1d\xa7\xf3\xa5\x9c\x54\xf1\x15\x9c\x3e\x3a\x56\xd7\x11\x3d\xa2\xfe\xe2\x81\xce\x8f\x1f\xe2\x0f\x3b\x7a\x76\x34\xf5\x77\x38\xb6\xec\x0c\xf4\x8b\x5f\xe6\xe8\xd5\x79\xac\xa4\xa9\xbf\xc7\xd1\x27\xf1\x11\x8f\x3e\xaa\x3f\x48\xc1\x87\x11\x91\x01\xd2\x74\x2b\xa6\x2b\xab\x51\x77\x13\x75\x2f\xaa\xab\x23\x4f\xa8\x0c\xf0\xeb\x95\x36\x13\xac\x27\xe3\xed\xed\xd1\xef\x32\xea\xdf\x92\x64\x6c\x06\x9b\xa9\x7f\xe5\xb2\x2f\x63\x6a\x11\xe3\xea\x29\xf5\x15\x93\x6a\x9d\x5a\x47\xf5\xaf\xd5\xd7\x54\xff\x46\x7d\x43\xf5\x6f\xd5\xf7\x54\xdf\xa0\x36\x50\xbd\x5d\x91\x04\x83\xd9\x4f\x32\x6e\x2f\xb2\x17\x31\x69\x3f\x65\x7f\x49\xf5\xb5\xf6\x5a\x26\xec\xaf\x52\x26\xe3\x29\x2b\xe5\x30\x11\xfd\xdd\x4d\xaa\x97\xa5\x7a\x31\x99\xea\x9d\xea\x4d\xa8\x8a\xc5\xbf\xdf\xc3\x13\x29\xc5\xc6\xb1\x6b\x99\xa2\x5d\xb6\x81\x6d\x37\xb1\xb9\x70\x12\x73\xeb\x0a\xe3\x9a\xd9\x01\x0d\x35\xad\x8d\xd1\x8f\x01\x31\x71\xd8\xa1\xd5\x83\x58\x9f\x23\x8f\xa8\xa4\x9c\x31\x1a\x01\xd7\xbf\xee\xc3\x50\x67\x9d\x75\xa1\x7f\xf9\xa7\xcb\x99\xf1\xe3\x27\x4f\x61\xdb\xe9\x7c\x50\x6d\x43\xfd\x44\xb6\x7b\x43\xd3\xf8\xe8\x27\x87\x58\xa7\x3e\xd1\x6f\x05\x45\xad\x0e\x8d\x4c\xb2\xcd\xd6\x6c\x20\xdb\x8d\x7a\x65\x70\x74\x30\x53\xba\x87\x8f\xb2\x9a\x7a\x51\x29\x4c\x2d\x83\x8b\x03\xe3\xe3\xd6\x1d\x94\x9b\xe6\x5e\x51\x5d\xbe\x4b\xf9\x16\x94\xec\x08\x29\xb2\x8e\x51\x16\x1d\x37\xa8\x3f\xbf\x9e\xf5\x67\x39\x56\x49\xe3\x3b\x8a\x9d\xc8\x26\xb1\x56\x76\x06\x3b\x9f\xcd\x62\xb3\xd9\x9d\xec\x21\xf6\x3a\x7b\x9f\x3a\xa6\x78\x3f\x3e\x90\xef\xce\x5d\x3e\x84\x87\xfc\x70\x7e\x65\x24\x27\x55\xc6\x04\xcd\x52\x54\xeb\xd9\x59\xeb\xd5\x59\xeb\x41\xb5\xb5\x1a\x6f\x59\x67\x6d\x79\x67\xed\x8d\xce\xda\x9b\xba\x26\x68\x14\x65\xf6\x6a\xaa\x7f\x61\xbf\xd5\x79\xee\xed\xce\xda\x3b\x89\x5e\xef\x46\x75\x9a\x75\xa1\x56\xe9\xd5\xd4\x8b\xf5\xa3\xb9\x16\x6a\x65\xca\xa0\x7c\xb5\xfd\x5e\xe7\x55\xef\xeb\x5a\xd4\xa7\x0f\xdb\x3a\x25\x69\xe5\xac\x55\x5f\xa4\x94\x46\x59\xd1\xd9\xeb\x83\xce\xda\x87\x9d\xb5\x95\x9d\xb5\x8f\x3a\x6b\x1f\x77\xd6\x3e\xe9\xac\xad\xea\xac\x7d\xaa\x6b\x16\x21\x6d\xab\x7f\xe5\x73\x30\xcd\xd8\x10\xfb\x15\xc2\x5c\x4f\xda\xbe\xa2\xb1\xd7\xdb\x2f\x53\xf9\x2d\xb5\x5f\xd6\xed\x6f\xed\xcf\xf4\x58\x5e\xa2\x7c\xbd\xbd\x94\xf2\x6f\xb5\xac\xcf\x31\x5a\x4b\x7d\xa4\x3e\x89\x7e\xd8\xd5\x30\x69\xa5\xdb\x34\x6b\x29\xa3\x97\xd1\x8b\xe9\xdf\x1f\x60\x7d\xa2\xdf\x1f\x60\x5b\x18\x5b\x1b\xdb\xb1\x7e\x7a\xe5\x08\x2a\x77\x26\x09\x7b\xea\xb5\x62\x50\x6e\xe8\x5f\x32\xe8\x61\xf4\x33\x76\x88\xd6\xaa\xfe\xe5\x83\xaf\xa3\x75\x46\xc7\x77\x60\xcc\xbe\xc4\xbe\x84\x0d\xb4\x9f\xb1\x5f\x60\x3b\xd2\x7a\x98\x44\xd7\xf4\xe1\x3b\x0b\x5f\x86\x6a\x34\x1b\xc0\xf6\xa5\x75\x31\x94\x1d\xc1\xc6\xd0\x9d\x31\x89\x35\xb3\x53\xd8\x59\xec\x42\x76\x25\xad\x8e\x9b\xd8\x6d\x6c\x2e\x5b\xc0\x1e\x61\x4f\xb3\x17\x68\x95\xbc\xcb\x3e\x66\x6b\xd8\x7a\x5a\x2b\x26\x2f\x73\x0e\x63\x52\xdc\x2e\x6e\x77\x86\xe9\xf2\x36\xe7\x50\x5d\xde\xea\x0c\xd5\xe5\x1c\xe7\x10\x5d\xde\xe2\x1c\x44\xe5\x6d\xd4\x2f\xd4\xe5\x6d\x4e\xa0\xcb\x5b\x9d\x6a\x5d\xce\x71\xaa\x74\x79\x8b\x53\x41\xe5\xad\xd4\xef\x40\x5d\xde\xe6\xfc\x42\x97\xb7\x3a\x07\xe8\x72\x8e\xb3\xbf\x2e\x6f\x71\xf6\xa3\x72\x0e\xf5\xdb\x57\x97\xb7\x39\x79\x5d\xde\xea\xe4\x74\x39\xc7\xc9\xea\xf2\x16\x27\x43\xe5\x2d\xd4\x2f\xad\xcb\xdb\x1c\x5f\x97\xb7\x3a\x9e\x2e\xe7\x38\x07\x33\x41\x47\x87\x53\x7e\xbb\x33\x84\xf2\x39\x4e\x25\xe5\xb7\xfe\x37\x2c\x52\x0f\x8b\xd4\xc1\x22\x13\x61\x91\x09\xb0\x48\x01\x16\x19\x0f\x8b\x8c\x83\x45\x6a\x60\x91\x13\x61\x91\x13\x60\x91\xe3\x60\x91\xb1\xb0\xc8\xb1\xb0\xc8\x18\x58\xe4\x18\x58\x64\x34\x2c\x72\x34\x2c\x72\x14\x2c\x32\x0a\x96\x38\x12\x96\x38\x02\x96\xf8\x25\x2c\x71\x38\x2c\x31\x42\x97\xb7\x38\x93\xb4\x2d\x8e\x8f\xac\xe0\x8c\xa4\xfc\x16\xa7\x36\xb2\xd1\x7f\xc3\x22\xe7\xc2\x22\xe7\xc0\x22\x67\xc3\x22\x67\xc1\x22\xbf\x82\x45\xce\x84\x45\xce\x80\x45\x4e\x87\x45\x4e\x83\x45\x4e\x85\x45\x4e\x81\x45\x4e\x86\x45\x66\xc0\x12\xd3\x61\x89\x36\x58\xa2\x15\x96\x68\x81\x25\x9a\xb1\x36\xa6\xc2\x22\x4d\xb0\x48\x23\x2c\x32\x19\x16\x69\x80\x45\x4e\x82\x45\x66\xea\x35\x72\x9e\xb6\xcb\x14\x6d\x91\x69\xd1\x4a\xf9\x6f\x58\xe4\x8f\xb0\xc8\x8d\xb0\xc8\x1f\x60\x91\x1b\x60\x91\xdf\xc3\x22\xd7\xc3\x22\xbf\x83\x25\x66\xc1\x12\xbf\x85\x25\x7e\x03\x4b\x5c\x0b\x4b\x5c\x83\xb5\x71\x35\x2c\x72\x15\x2c\x72\x05\x2c\x72\x39\x2c\x72\x19\x2c\x72\x29\x2c\x72\x09\x2c\x72\x11\x2c\x72\x21\x2c\x72\x01\x2c\x72\x3e\x2c\xf2\x6b\x58\xe4\x3a\xbd\x3a\x6e\xd2\x16\xb9\x58\x5b\xe4\xca\xff\xa6\x45\x1e\x84\x25\xfe\x0e\x4b\x2c\x84\x25\x1e\x80\x25\xee\x87\x25\xe6\x63\x6d\xfc\x0d\x16\xb9\x0f\x16\xf9\x2b\x2c\x72\x2f\x2c\x32\x17\x16\xb9\x07\x16\xb9\x1b\x16\xb9\x0b\x16\xf9\x0b\x2c\x72\x07\x2c\x72\x3b\x2c\x72\x1b\x2c\x72\x2b\x2c\x72\x0b\x2c\x72\x33\x2c\xf2\x67\x58\x64\x36\x2c\xf2\x27\x58\x64\x9e\xb6\xc8\x02\xbd\x52\xe6\x68\x8b\xdc\xa9\x2d\x42\xde\x41\x74\xbd\xe6\xf3\xa1\xd1\x9e\x4b\xbb\xf6\x9e\xc4\x17\x07\x82\xe1\x5e\xd3\x3c\xf6\x2a\xe5\x9f\x6b\x3e\xf8\x82\x6a\x5f\xeb\xda\x9a\xce\xda\x97\x9d\xb5\xa7\xd0\xaf\xeb\x5e\x1f\xf9\x33\x23\xd9\xc5\x5d\xfc\x99\xdd\xb4\x3f\xe3\x6a\x7f\xe6\x80\x6e\xfd\x96\xae\x75\xde\xe5\xb8\x38\x89\x3c\x40\xd6\x2b\x0a\x48\x89\x67\xf4\xef\x93\x53\xfe\xef\x7f\xe5\xb0\x3f\xf9\x2a\x43\xc8\x4f\x19\x46\xfa\x8c\xd5\xbf\x6a\x3a\x93\x5d\xca\xae\x27\x0f\xe3\x0e\x36\x8f\xe6\xfd\x63\xb6\x96\x7d\xc7\x15\x2f\x23\x2f\x63\x00\xdf\x95\xef\xc9\xe1\xdb\x70\x5b\x7b\x2c\x5c\xce\xa1\xb6\x45\xe5\xd2\xf8\xb8\x5c\x1f\x97\xea\xe9\xb8\x4c\x5d\x18\x7b\x36\x7d\xee\xeb\x6b\xf7\x1d\xd3\xf7\x8e\xb8\xd5\x77\xf5\x16\x75\x5b\x7c\xbc\x65\x43\xdc\xda\xf2\xe5\x7e\xbb\xf7\x3b\xa5\xdf\xe2\xb8\xb5\x55\x9f\xad\xae\xdc\x3a\xb5\xf5\xc5\xf1\xf5\x5b\xaf\x8b\xcb\xfe\x77\xc6\xe5\x80\x31\xba\x97\xbd\xa3\xb9\x63\xeb\x8e\xcf\x0e\xda\x7d\xd0\x59\x83\x96\xef\x94\xd9\xe9\x72\x7d\xb4\xe7\x4e\x8b\x77\xfa\x6e\xe7\x3d\x77\x1e\xbb\xf3\xc5\x3b\x2f\xdc\x79\xd5\x2e\x03\x76\x19\xb6\xcb\x69\xbb\xdc\xb1\xcb\xf2\x5d\xcb\xf4\x79\xb1\xeb\x80\x5d\x87\x46\xbf\x7d\xce\xf8\xae\x8d\xda\x86\xdc\x5b\x15\xcb\xf5\xd6\xc6\x65\xe6\xc6\xb8\xdc\xf7\xc4\xb8\xdc\xff\xfa\xb8\x5f\xc5\x58\x94\xb5\xda\x7f\xe4\x15\x33\x69\x9d\x5c\x2b\x48\x8a\xb8\x9e\xac\x39\x8c\xee\x97\x1b\xd9\xcd\x64\xb5\xb9\x6c\x3e\x7b\x90\x3d\x46\xb6\x7b\x9e\xbd\xcc\x96\xd3\x5d\xb3\x92\x7d\x46\x56\xc4\x7d\xc3\xb7\xe0\xdb\x92\xbf\xb6\x2b\xdf\x83\x0f\xe6\x19\xf2\xd9\x2a\xf9\xc1\x7c\x38\x1f\xc9\xc7\xf0\x13\xf9\x04\xde\xc0\x9b\xf9\x0c\x7e\x06\x3f\x87\x5f\xc8\x2f\xe7\xd7\xf2\xeb\xf9\x4d\x7c\x0e\xbf\x93\xcf\xe3\x0b\xf8\x43\xfc\x09\xbe\x98\xbf\xc0\x5f\xe5\x6f\xf2\xf7\xf9\xc7\x7c\x35\x5f\xc7\xbf\x13\x42\xd8\xa2\x97\xe8\x27\xb6\x13\x83\xc4\x6e\x62\x4f\xe1\x8a\x9c\x38\x40\x54\x8b\xa1\xe2\x70\x71\x94\x88\xb4\xae\x35\x5c\xca\x87\xe8\xfc\x46\x9d\x0f\xd4\x79\x7c\x7c\x51\xa2\x7e\x96\xce\x0f\x4f\xf4\x1f\x58\xac\xb7\xe7\x12\x12\x86\x24\xf2\x19\x09\x09\xb5\x09\x09\xc9\xe3\xc9\x9e\xfd\x12\x47\xce\x2a\x45\x41\x5e\xbb\x51\x7d\x60\xe9\xf1\x2e\xfa\xf4\x4b\x48\x8b\xcf\xbe\xbb\x51\xbd\x76\xa3\x7c\x63\x1d\x92\x58\x33\x36\xc3\x1a\x49\x09\x1b\x8f\x7d\x63\xfd\x13\xfd\xdb\x57\x6d\x34\x6a\x7d\x7c\xc3\x43\xe4\x39\x22\xc7\x55\x51\x4e\xbb\x4f\x17\xbf\xf0\x29\xda\x5b\x76\xd4\xde\xe1\x20\x7b\x29\xed\x38\xbb\xa7\x24\x79\xda\x07\xeb\x7b\xef\x0b\x16\x47\x28\x94\xab\xbb\x75\x24\xb7\x2d\x8b\xa2\x8c\x38\x72\xe9\x8b\x3e\x14\x03\x91\x44\xda\x45\x0c\x93\xbc\x54\x23\xfa\x7d\x2c\xb6\x9d\x96\x38\x80\x7a\x0c\xa0\xe8\x86\xd3\xde\x57\xa6\x77\x1a\x2e\x46\x6b\x7d\x38\x61\x47\x57\x7f\x5b\x44\x88\x22\x15\xf6\x04\xbb\x81\xf2\xc5\xd4\x7b\x0b\x8a\x88\xf6\x64\x2e\xc5\x2d\x07\xd0\xbe\x32\x94\x1d\x4e\xb1\xcb\x58\xe2\x96\x3a\xfd\x53\xb2\xa7\xd0\xfe\x72\x1e\xed\x7c\x24\x4f\x0c\xa6\x7c\x66\x94\xd3\xf6\x35\x58\x1f\x19\xdd\x51\x8f\xf3\xf6\x67\xc5\xfb\x1d\x79\x7c\x56\x8c\xe6\xa4\x0b\x3f\x4d\xf7\x1f\x1c\xe5\x7c\xb6\xce\xef\x14\x0d\x3a\x8f\x8e\x37\x44\xb9\x1c\xc4\xd7\x76\xe4\xe4\x87\x5b\x46\x4f\xa3\xb7\xb1\x85\xb1\x55\xfc\x3b\x60\x64\xc3\xe2\xaf\x8d\x44\xbf\x35\xb2\x94\xfc\xfc\x68\x5c\x6b\x8b\xe3\x12\x73\xa9\xbd\x4e\x3d\x4b\x11\xd9\x80\xe8\x0e\xa7\x08\x2b\xc7\x0f\xe0\xd5\x7c\x28\x45\x59\x47\xf1\xb1\x7c\x1c\xaf\xe3\x8d\xbc\x95\x9f\xc2\x67\xf2\xf3\xf8\xc5\xfc\x4a\x7e\x1d\xbf\x81\xcf\xe6\xb7\xf1\xbb\xf9\x7d\x7c\x21\x7f\x84\x2f\xe2\xcf\xf2\xa5\xfc\x75\xfe\x36\xff\x80\xaf\xe2\x6b\xf8\x37\x7c\x83\x50\x22\x25\xfa\x88\xad\xc5\x00\xb1\xb3\xd8\x5d\xec\x2d\x7c\xb1\xaf\x38\x50\x84\x62\x98\x38\x82\xc6\x78\xbc\xa8\x15\x93\xc4\x14\x31\x4d\x9c\x26\xce\x12\xe7\x8b\x4b\xc5\xd5\x62\x96\xb8\x51\xdc\x2c\xee\x10\x73\xc5\x7c\xf1\xa0\x78\x4c\x3c\x2d\x9e\x17\x2f\x8b\xe5\xe2\x5d\xb1\x52\x7c\x26\xd6\x8a\xf5\x14\x3c\x99\xb2\x4c\x6e\x21\xb7\x95\x03\xe5\xae\x72\x0f\x39\x58\x66\xe4\x10\x59\x29\x0f\x96\xc3\xe5\x48\x39\x46\x9e\x28\x27\xc8\x06\xd9\x2c\x67\xc8\x33\xe4\x39\xf2\x42\x79\xb9\xbc\x56\x5e\x2f\x6f\x92\x73\xe4\x9d\x72\x9e\x5c\x20\x1f\x92\x4f\xc8\xc5\xf2\x05\xf9\xaa\x7c\x53\xbe\x2f\x3f\x96\xab\xe5\x3a\xf9\x9d\x12\xca\x56\xbd\x54\x3f\xb5\x9d\x1a\xa4\x76\x53\x7b\x2a\x57\xe5\xd4\x01\xaa\x5a\x0d\x55\x87\xab\xa3\xd4\x58\x35\x4e\xd5\xa9\x46\xd5\xaa\x4e\x51\x33\xd5\x79\xea\x62\x75\xa5\xba\x4e\xdd\xa0\x66\xab\xdb\xd4\xdd\xea\x3e\xb5\x90\x66\xe2\xea\x68\xf5\x8a\xd1\x66\x1d\xcd\xcd\xfc\xa8\xce\xe7\xeb\xfa\x48\x5d\x1f\xa9\xeb\x8b\x75\x7d\x71\x54\x17\x83\x75\xff\xc1\x51\x9d\x2d\xd7\x2b\x7f\xb9\xee\x73\xa0\xee\x73\xa0\xee\x33\xba\x28\x33\x59\x67\xab\x75\xff\xd5\xa5\x32\xbb\xc8\xb7\x75\x7f\x5b\xd7\x67\x76\x2f\x87\x2b\xdd\x5f\x95\xea\x99\xd4\xad\x4b\x3d\x29\x73\x40\xa2\xbe\xa9\x3e\x89\xe3\x5d\x74\xfb\x46\x1f\xff\x66\x23\x7d\x36\x31\x96\x2e\xd7\x6e\xa2\x7f\x17\xfb\x6f\xc2\xce\x9b\x63\x9f\x4d\x61\x75\xd1\x79\x73\xea\x09\x7d\x36\x55\xff\x4f\xac\x93\x1f\xbd\x36\x92\xf6\xdc\xd4\x1a\xd8\xd4\xbc\xff\x37\xe6\x9a\xc6\xb2\xba\x73\x2c\xf3\x8d\xe5\x9d\x76\xb8\x53\xd7\x67\x43\xfe\xf2\x6e\xb1\x12\xf5\x4d\x8c\x71\xf3\x19\xa4\x6f\xe7\xef\x39\x46\xbf\xe6\xb8\x54\xff\x8a\xe3\x6b\xea\x6d\xfd\x9b\x8d\x1f\xaa\xaf\xd5\x77\xf6\xa2\xe8\xd3\x40\x16\x32\xa6\x3f\x7b\x3b\x82\xd2\x68\x4a\xc7\x53\xaa\xa5\x34\x89\xd2\x14\x4a\xd3\x28\x9d\x46\xe9\x2c\x4a\xe7\x53\xba\x94\xd2\xd5\x94\x66\x45\xbc\x4d\xe5\xcd\x54\x7e\x60\x0c\xd1\x2c\x12\x52\x7e\x5b\x54\xa7\x3b\xb0\x78\x24\xce\x6f\x8c\xf2\xf6\xeb\x13\x47\x58\xa2\x4f\xbf\x2e\x47\x66\x68\xd6\x5b\xa5\xeb\xeb\x75\x7e\x63\xe7\x3e\xbe\xf7\xff\xbf\x8f\xff\xd7\xf6\x71\xfd\xe9\x65\x34\xc3\xb4\x22\x13\xf9\xc8\x62\x2e\x9e\xd7\xf5\xcb\x75\x7d\x70\x31\xe7\x99\x44\xbe\x6d\x31\x8f\xa5\x6d\x9c\x93\xc7\xdc\x99\xc7\xd2\xba\xc9\x93\xb8\x33\x13\xf9\xe8\x62\xbd\xfd\xc4\x62\xbe\x49\xdc\xa4\x9e\x8b\x13\xf9\xda\x62\x4e\xbe\x47\xc9\x11\x1c\x5f\x58\xac\xcb\x41\x89\xe3\xa3\x4b\x35\x41\x3e\xa0\x98\x6f\x2c\x6d\xe3\x6b\xbb\x1c\x4f\xd8\x7f\x93\x76\xde\x0c\xfb\x74\xd1\x73\x63\xbb\x6d\x76\xce\xe3\x4f\xb3\x47\xb7\x3f\xdb\x59\x1f\x17\xd5\xff\xd3\xeb\xa4\xcb\xda\x98\x9d\xc8\x37\x35\xf6\xc4\x2c\x6c\x4a\xe6\xa6\xe6\x7d\xe3\xb9\x8e\xf3\xcd\x99\xeb\x2e\x63\x49\xda\x21\xa9\x67\x12\x65\xe4\x26\xf2\x64\xff\xe2\x78\x37\x7f\x1f\xdf\x4e\x3d\xa5\x9e\x55\x2f\x76\xf9\xf5\xdd\x77\xbb\xf9\xbd\xdd\x2f\xd5\x57\xea\x7b\xd5\x1e\xff\xfe\x19\xdb\x8e\x6d\xce\x0e\xce\xb0\x83\x33\x8a\x79\xa3\x5f\x64\x64\x2c\x1a\xe3\x83\x94\x1e\xa3\xf4\x34\xa5\x68\xa6\x5f\xa6\x14\xcd\x57\xf4\x94\x63\x25\x95\x9f\x51\x8a\xc6\xbc\x3e\x9a\x48\xed\x6b\x47\x51\xc5\x5e\x2c\xae\x0f\xec\x3c\xd2\x51\x8f\xf3\xe8\xec\xee\xff\xa6\x4f\x69\x7f\xd6\xa5\xff\x0f\x1c\x89\x57\x70\x7c\xbc\xfd\xdd\xce\x5c\xea\x18\x88\x6b\x24\x57\x9f\xdf\x82\x72\xa1\xbe\x26\xee\xdb\xc4\x67\xf4\xac\xd7\x0f\xf1\x26\x49\x14\x24\x71\x88\x96\xc9\x4a\x24\xfe\xbb\x6b\xbb\x47\xfc\x37\x3a\xea\x95\xc1\xf4\x9a\xe0\x7a\x4d\xec\xf4\x9f\xd6\xb1\x1b\xc4\x48\xc7\xa1\xd0\xf1\x44\x2d\x71\x4b\xca\xfb\xff\x88\x95\xd9\xb1\x2e\x37\x65\xf5\x54\x77\xb2\xfe\x2f\xe0\xf6\xfe\x37\xd7\xfd\x1f\xd5\xa0\xdb\xb9\xfc\x7f\x5f\x83\x4d\xd9\x5e\xe8\xcf\x15\x8b\xab\xa8\xdf\xbf\x5d\x3d\x3f\x7c\x6f\x45\x23\xf1\x31\x92\xa1\x9b\x29\x71\x53\xf3\x16\xe3\xfc\x37\x75\xdc\xc4\x4a\xff\x2f\xe8\xd8\xad\x5d\x8b\x3a\x0e\x65\x0d\x09\x1d\xb7\xfa\x2f\xce\xdf\xbf\x5f\x2b\x9b\xb2\x7b\xa4\xc1\xb8\xff\x23\x1a\x74\xbf\x56\x7e\x08\xf7\xff\xda\xc8\xbb\x9d\xcd\xff\x0b\x23\xef\x6e\xee\xf1\xa9\xf2\x8d\xff\xc3\x3f\x55\x46\x4c\xad\xa3\xcb\x3d\x37\xaa\x2f\x2a\xd6\x93\x67\x91\x2f\x2a\xd6\xdb\xef\xee\xbe\x4f\x37\x32\xe3\xfa\xb6\xa5\x72\x92\x88\x1b\xeb\x90\xcc\x37\xee\xb9\xb1\xfc\x8d\xf5\xe9\xa2\xdb\x90\x4d\xd4\x37\xca\x7f\xd8\x26\x5d\xec\xb0\x91\x35\xba\xc1\x4d\x8e\xfd\x87\x47\x9d\xfc\x9c\xff\xc6\x84\xe4\x3e\xc5\x3c\x21\x73\xf3\x7d\x49\xa9\xfe\xa9\xde\x51\x1f\xe8\x77\x19\x7a\xe9\xbd\x8d\x91\xa7\xd8\x35\x4e\xd7\x39\xd6\xef\x0d\xff\xb3\xd7\xaf\xfc\x4e\x7f\x5e\xb2\x50\x5b\x6e\x56\x94\xcb\x41\x3a\x3f\x27\xb1\x72\x2f\x2f\x1e\x89\xfb\xc7\xc7\x65\x59\x31\x8f\x25\xc4\x67\x93\x7d\x78\x5d\xe2\xda\x73\x12\xf2\x13\x28\x72\xac\xce\x0f\xd6\x72\xde\x8f\x72\x43\xcf\x9e\x5c\x1a\x7f\x3e\x54\x9a\xcb\x95\x09\xf4\x84\xfe\xb1\xb4\x58\x42\x52\x9f\xf8\x48\x2c\xcd\x58\x5e\x94\x9f\xac\x27\x35\xef\xc6\x26\x65\x9b\xb0\x49\x62\xa4\x71\xff\x64\x8e\xb3\x49\x0b\x24\x2c\xf6\xc3\xa3\x8e\xe5\x63\x2c\xef\x17\x2d\xd6\x45\x7e\x51\xda\xe6\xaf\x5f\xa1\x5e\x52\xaf\xea\xf7\xca\x52\x2c\x7a\x32\xfa\xbf\x71\xcd\xae\xd4\x31\xe6\xfd\x3a\x8f\x23\xd9\x1b\x75\x4c\xaa\xe3\x6e\xbe\x8d\xe6\xa9\xd5\xfa\xc8\x1d\x3a\xbf\x4b\x1f\x99\xa7\xeb\x4b\x75\xff\x87\x59\xe7\xe7\x09\x4a\xbf\xb3\x26\x1f\xd2\xd7\xea\xe7\xdd\xfc\x1a\x7d\x24\x8e\x73\xc7\xea\x5c\x23\x4a\xbf\x18\xab\x8a\x76\xc6\xba\x7e\x16\xa1\x72\x09\xf9\x6f\xe8\x3c\xd6\x73\x61\x51\x42\x5c\x57\x32\xa1\xf3\x05\xba\xfe\x4a\xa9\x3e\xb1\xcc\x58\x5a\x2c\x79\xe3\x5c\x7e\x57\x9a\x77\xb1\x49\x3c\x8a\x73\xb4\xce\x3c\x61\x93\x1f\xb4\x86\xd4\x9a\xf0\x58\xb7\x7b\x4a\xc7\x1e\x47\xfd\x9b\x1a\x75\x8c\x02\x1d\x1e\x2e\x5e\x85\xcf\x43\xae\x2e\xf6\xd4\xf9\x8f\x59\xb3\x2f\xa8\x15\x5d\xd7\x2c\xc5\xc1\xf1\xfb\x03\x71\xa4\x76\x40\xc2\x3f\xd9\xba\xf3\x8a\x7f\xef\xf3\x70\xb6\xb5\x21\x0c\x69\x18\x86\x69\x38\x46\x99\xd1\xc7\xd8\xd6\x5e\xac\x9f\x85\x45\xbf\xb1\x1f\xfd\xc2\xfe\xbb\xf6\x0a\xfb\x43\xfb\x53\x7b\x75\xf4\x3b\xe9\x84\x26\x29\x26\xde\x95\xed\x11\x5d\xd9\x0d\x1e\xd7\x9f\xb8\x72\xb5\xf2\x3f\x20\xf9\xab\xff\xb0\xe4\x55\xff\x31\xc9\x9f\xfe\xc7\x24\x7f\xfe\x1f\x93\xbc\xfa\xbf\x20\x39\x5a\x89\x3b\x6f\x62\x25\xc6\x72\x7f\xbc\xc4\x58\xd3\x0e\x89\xdb\x50\x6e\x6a\x2f\x3a\xf6\xa0\xbf\xea\x32\x7f\x9b\xdb\x7f\x19\x66\xe5\xc7\xc9\xdf\xfc\xfe\xb1\xfc\xcf\x36\xbb\xff\x0b\x3f\xb2\xff\xb3\x98\xfb\xcd\xed\xbf\x12\x33\xba\xb9\xfd\x57\xfd\xc8\xfe\xcf\xfe\xc8\xfe\x2f\xfc\xc8\xfe\xcb\x7e\x64\xff\xe5\x3f\xb2\xff\x57\x89\xfe\x3b\xd3\xce\x2a\x68\xe5\x0e\xc0\x15\xdb\x26\x24\xbe\xc1\x3a\xde\xaa\xe0\xc6\x16\x9b\xd9\x7b\x2d\x7a\xf3\x5e\x0b\xf4\x9b\x5a\xb5\xec\x05\xa2\xb8\x14\xf9\x0a\x95\xe4\x1f\x34\xf3\xf3\xf9\x0b\xa2\x0f\x71\x7b\xf4\x6c\x68\x9e\xfe\xff\xa0\x58\x29\xd6\xc8\x9c\x9c\x20\xcf\x97\x37\xc9\xf9\x72\x9d\xbc\x49\x95\xe9\x27\x36\x73\x8d\x41\xc6\xde\x46\xce\x18\x67\x34\x18\x8f\x18\x8b\xcc\x5e\xe6\x10\x73\x38\xd5\x1e\x31\x67\x44\x39\x95\x37\x9b\x0b\xe9\xff\x23\x56\x99\x35\xdc\x3a\xdf\x5a\x6f\xf7\xb3\x07\xda\xc3\xec\x46\x7b\x8e\xfd\xa0\xfd\xaa\x93\x72\xea\x9c\x9b\x52\xdb\xa6\xe6\xa6\x5e\x4d\xad\x4b\x7d\xd7\x43\xf4\x28\xeb\x11\xf6\x98\xd2\xe3\x86\x1e\xf3\x7a\xbc\x5b\xb6\x6d\xd9\xbe\x65\xd5\x65\xc7\x97\x9d\x56\x76\x53\xd9\xf3\x65\x6f\xf6\x2c\xeb\xb9\x47\xcf\xc3\x7b\x9e\xd7\x73\x51\xcf\x37\x7b\xf5\xe9\xb5\x75\xaf\x41\xbd\x0e\xe8\x55\xdb\xab\xb9\xd7\xe5\xbd\xae\xed\x35\xbb\xd7\x6c\xf2\x91\x76\x6d\xbf\x8c\x65\xdb\x97\xb1\x3c\xa5\x7d\x29\x0d\x69\x9f\x27\xf7\x6b\xbf\x4c\x56\x53\x3a\x88\xd2\x70\x4a\x47\xb5\x2f\x93\x47\xd3\xf1\xe3\xda\xe7\x45\xf3\x40\x57\x38\x4c\xea\xeb\xea\x58\x7e\xc3\x37\x74\xdd\x0e\x74\x5d\x35\x3b\x86\xda\x63\x28\x8d\x6d\xaf\xb3\xde\xa7\x92\xee\x7e\xba\xa2\x37\x9d\xe9\x4b\x69\x57\x3a\x62\xe1\xba\x6a\xc2\xab\xa6\xeb\xaa\xf5\x75\x63\xdb\x2f\xa3\xfe\xd5\xba\xff\x65\x5d\xfa\x1b\xd4\x77\x3e\xf5\x9d\x4f\x7d\xe7\x53\xdf\xf9\xd4\x77\x3e\xa3\x79\x23\x4d\x7b\xd3\xf9\x3e\xba\x6f\x1d\xdb\x81\xd2\x40\x4a\xd1\x35\x2e\x9d\xab\xa6\xe3\x21\xa5\x83\x29\x0d\xa3\xf6\x11\x54\x8e\xa2\x73\x47\x51\x39\x9a\x12\xb4\x64\xbd\x63\x49\x34\x86\x3e\xd4\xea\x4b\xe5\x0e\x74\x76\x60\x84\x4e\x75\xb7\xfd\x15\x2d\x29\x96\x32\xaf\x53\xca\x68\xad\x73\x35\xc5\x4e\xb1\x1e\xd5\x74\xf5\x3c\xad\xf3\x0e\xa4\xff\x40\x4a\xbb\x92\x45\xc8\x82\x74\xe5\x65\xc0\xbf\x8c\xae\x5c\x46\x57\x2e\xa3\x2b\xe7\x69\xdc\x79\xb8\xb2\x1a\x57\x02\x97\x52\x35\x5d\x7d\x30\xa5\x18\x73\x07\x76\x24\x1d\x1b\x49\xe5\x68\x6d\xe3\x1d\x18\xb7\xde\x67\x53\xf5\x1c\x74\x45\x0f\xa9\x7d\xb0\x46\x5b\x46\xfd\x97\x51\xaf\x9f\xd0\xca\xee\x4d\xd8\x7d\x29\xa5\x22\xeb\xca\x43\xdb\x2f\x90\x47\x50\x3a\xaa\x3d\x2f\x8f\xde\xb0\x5e\x8e\x6e\x9f\x24\x8f\xa3\xb2\xd0\x7e\xa6\x6c\x6a\xaf\x93\x27\xb7\xdf\xcd\x04\xcd\xf6\x33\x34\xdb\xcf\xb0\xbe\xb2\x8a\x4d\x96\xd5\x1b\x3e\xa3\xb5\xb0\x85\x1c\x4e\xe5\xf1\xed\x3b\xca\x13\xdb\xe7\xc8\x1a\x5a\x0f\xe3\xa9\x3e\x81\x52\x3d\xb5\x4f\xa2\xd4\x40\xa9\x91\xe4\x4e\xa5\x63\x6d\x94\x66\x50\x3a\xa3\x7d\x47\xd6\x63\x73\x91\xf5\xaa\xb1\x61\x1b\x9b\xb4\xb6\x09\xff\x22\xc2\x5f\x43\xf8\x65\x84\xbf\x86\x70\x16\x30\x13\xf2\x9e\x21\x79\xcf\x91\xbc\xa9\xa4\x6f\x96\xf4\xcd\x32\x83\xd6\xed\x24\xea\xbb\x80\xd6\xed\xa4\xce\x51\xf4\xa6\xbe\x73\xa8\xef\x1c\xc2\x1c\x4b\x23\x78\x8d\x34\x7f\x8d\x34\x7f\x4d\xd6\x51\x9a\x44\x69\x0a\xa5\xa9\x94\xda\x28\xcd\xa0\x74\x2a\xa5\x33\x28\xcd\x6c\x7f\x8d\x64\x96\x6a\x4e\x5a\xc7\x3a\x90\x96\x21\x69\x19\x92\x86\x2f\x12\xea\x3e\xa4\xe1\x8b\xe4\x19\x4e\x6b\xbf\x21\xfa\xd4\xa9\x73\x8d\x86\xc9\x35\x4a\x23\x9a\x4e\x5a\xe6\xa9\xff\x64\x92\xbc\x8c\x34\xcd\x93\xf4\x65\xa4\xdb\x32\x79\x2c\xa5\xe3\x49\xde\x09\x94\xc6\x53\x2a\x50\xff\x09\xa4\xf3\x44\xaa\xd7\xb7\x5f\x4b\xa3\x5f\x46\x16\xbe\x56\xdb\x6b\x2a\x1d\x6b\xa3\x34\xbd\xfd\x2a\xd2\x39\x24\xfb\xd5\xc9\x53\xe8\xdc\xe9\x94\xce\xa0\xf6\x99\xed\xd7\xb2\xed\xb5\x86\xb1\x06\x21\x69\x10\x92\x06\x61\x97\x39\x3d\xb4\xfd\x3e\x3d\xaf\x47\x50\x39\x9a\x2c\x74\x2c\xd9\xac\x74\x8e\x0b\x64\xcb\xe2\x3c\xcf\xdb\xe4\x3c\x4b\x1a\xd7\x70\xb2\xfa\x0a\xb2\x3a\xf9\xba\xda\x8a\x91\x05\x53\x24\xf1\x02\x92\x74\x01\x49\xb9\x40\xdb\x7b\x2a\x95\x6d\x94\x66\x50\x3a\x95\xd2\x19\x94\x66\xb6\x5f\xa0\x57\x5e\x7c\xf5\x56\x3f\x5a\xcb\xcd\x59\x89\x9c\xac\xf4\x21\xad\xea\xe3\x69\x85\x9c\xd8\xfe\x38\x5d\xb7\x80\x46\x17\xe9\xb5\x80\xae\x7d\x9c\x74\x5b\x40\xd7\x3f\x47\xd7\x3f\x47\x36\xbe\x80\xae\x5f\x40\xd7\x2f\xa0\x19\x6d\x23\x19\x0b\x48\xd7\x05\x24\x67\x01\xe9\xba\x80\xf5\x20\x29\x91\x84\xc7\xe9\xea\xe8\xca\xf7\xa8\xf7\xe3\xb2\x95\x52\x1b\xa5\x19\x94\x4e\xa5\x74\x06\xa5\x99\xed\x8f\x33\x25\xc7\x51\x8f\xe9\x94\x4e\xa7\x74\x66\xfb\x7b\xda\x2a\x73\x48\x8b\x17\x49\xc6\x1c\x92\x31\x47\xaf\xc6\x7a\x6a\x4f\xa5\x7a\x1b\xa5\x19\x94\xce\x68\x9f\x53\x82\x34\xa5\xfd\xd1\x1f\x44\x32\x68\x3f\x5b\x41\x7b\xd9\x0a\x36\xb9\xfd\x4c\x76\x7a\xfb\x12\xeb\xad\xf6\x25\xd1\x9e\xd1\x3e\x8b\x6d\x21\x17\xb5\x2f\x91\xcf\xb5\xcf\x92\xcf\x53\xf9\x02\x95\x2f\xb6\x0f\x93\x4b\x29\xbd\x44\x77\xe1\xab\x1b\x9e\x92\x6f\xd2\xf1\x77\x68\x0e\xde\x6d\xbf\x4e\x7e\x40\xf5\xcf\xa9\x5c\x43\xe5\x97\xd4\x77\x2d\xa5\xaf\xda\xe7\x92\xa4\x61\xac\x8f\x7c\x98\x7a\x3d\xde\x3e\x57\x3e\x49\x67\x17\x6b\xa9\x6b\x48\xe2\x1a\x92\xb8\x82\x24\xce\x27\x89\xef\xc8\x97\xe9\xf8\xab\x74\xd5\x32\xea\xf7\x76\xfb\x42\xb9\x82\xda\xab\xe8\xfc\x5a\xd2\xa8\x17\x49\x38\x33\x21\x61\x2e\xae\x1c\x93\xb8\xea\x2a\xba\x6a\x96\xbe\x6a\x2d\x9d\x5b\x47\xe9\x1b\xba\x72\x00\xad\xea\xfe\xb4\xa2\xfb\x77\x8c\x90\x24\xed\x44\x92\x86\xc9\x45\xcc\x93\x8b\x37\x3c\x23\x97\x50\xcf\xe7\xf4\x08\x57\x90\x84\x09\x34\xa2\x61\xf2\x3d\x42\x58\x41\xf5\x0f\xda\x6b\xe5\x47\x54\x5f\xd5\xde\x5f\x7e\x4a\xe5\x67\x94\x3e\xa7\xf3\x5f\x90\x36\x6b\xa9\xfe\x1d\x95\xdf\x53\x6a\x6f\x9f\xa5\x58\xfb\x04\x6d\x3d\x53\x4b\x5e\xca\xfa\xd3\xa8\x56\xc8\x37\xa9\xfe\x01\xd5\x57\x32\x8f\x56\xec\x22\xaa\x2d\xa6\x15\xdb\x03\xb6\x8d\x50\x97\xd0\x58\xde\xa0\xb1\xbc\x47\x63\x58\x45\xe8\x4b\xc8\x9e\xb3\x08\xf9\x3a\x42\x9a\x40\x28\xb5\xcc\x26\x7d\xcf\xa6\x91\xaf\xa0\x6b\x6f\xa6\x9e\xd1\x88\x23\x1b\xcd\xed\xb0\x11\xd9\xa7\x43\xd6\xd2\xf6\x57\x08\xb7\x8e\x7a\x44\xd8\xfd\xf5\xfc\x7c\x40\x3d\x57\x52\xf9\x39\xc9\x8d\xe7\x27\xb2\xd1\x12\xb9\x81\xae\x34\xb4\x96\xef\xea\x5e\x6b\xa8\x87\x3e\x43\x63\x78\x49\x1f\x89\xae\x59\xa1\xed\xf9\x0d\xc9\xd8\xc0\xfa\xb3\x32\xb2\xdf\x2c\xd2\x67\x16\x66\x62\x96\x7c\x81\x50\x96\xb6\x5f\x22\x5f\xa2\xf2\xe5\xf6\x13\x09\x79\x09\x66\x62\x85\xfc\x90\xae\xd8\x86\x66\x80\xd1\x0c\x30\x46\x2c\x45\xb1\xc8\x30\x76\x3a\xd9\xe4\x61\xda\x1b\x1f\x6f\xff\x09\x49\x99\x1f\x5b\x65\xc3\x12\x9a\x89\xd7\x68\x1c\x6b\xb5\xc4\x17\xb5\xd4\x25\xa4\xc7\x1b\x24\xb5\x63\x6e\xe7\x42\x27\xd2\x9d\x79\x64\xf1\x67\xf4\xca\x88\xf5\x59\xac\x47\xbf\x82\x7a\x3f\xa3\x75\x58\x16\x8d\x8b\xa4\x44\xd6\x5f\x43\xe9\xcb\x78\x2d\xd1\x48\x56\xe8\x91\xec\x40\x7a\x79\xa4\x97\x47\x2b\x63\x16\xad\x8c\x67\x20\xe9\x4c\x3d\xaa\x78\x55\xac\x20\xfc\x17\xb5\xa5\xa3\x79\x79\x4f\xcf\xcb\x5c\x5a\x11\x4b\xe4\x27\xda\xf2\xb3\x68\x55\x44\xeb\x7e\xb6\x5c\x4d\xc7\xbf\xa0\xb4\x86\x52\xb4\xf6\xd7\x51\x5a\xaf\x57\xc8\xac\xc4\x0a\x99\xcb\x76\xa3\x3b\x6e\x2e\xdd\x71\x73\x69\x87\x9d\x4b\x3b\xec\x5c\x42\x27\x8b\x50\x8f\x87\x37\x9c\x4c\xe8\xe5\xb4\x32\x68\x9e\x89\xbd\xa2\x3b\x2f\x9a\xc9\x37\xf5\xba\x1c\x46\x73\x34\x97\x34\x18\x2d\xdf\xa7\xb4\xa2\x7d\x3f\xd2\x64\x17\xf9\x21\x5d\xb7\x92\xda\x1f\x51\xfa\x98\xce\x7f\x42\x65\xbc\x56\x47\xd3\x5a\x1d\x4d\x9a\xed\x42\x9a\x8d\x26\xcd\x46\x93\x66\xbb\x90\x56\xa3\xe5\xd7\x94\xbe\xa5\xb4\x9e\x52\x7b\xfb\x68\xd2\x6a\x3f\xbd\x6e\x1d\xdc\x63\xc3\x68\xfc\x13\xe4\x73\xd1\x1c\x68\x8b\xd6\x92\x35\xcf\xd4\xf6\xa7\xf1\x32\x0b\x2b\xf7\x3a\x5a\x6d\x73\x49\xbf\xa9\x5a\xbf\xcf\xdb\x1f\x8e\xee\x07\xda\x33\xc9\x66\x94\xaf\x25\xfb\x0a\xba\xe6\x5c\xba\xff\xcf\xd4\x73\x34\x87\x24\x4f\xa2\xd9\x3e\x93\xae\x9f\x4b\x08\x77\x92\x85\xef\x4c\xdc\x01\x13\x68\xde\x26\x13\xd2\xf6\x18\xef\x55\xfa\xca\x14\x5d\x35\x52\xaf\xb4\xf8\xce\x39\x53\xeb\xf5\x12\x1d\x7f\x99\x34\x78\x9b\x24\x76\xdc\x01\x3d\x08\x63\x2e\xf5\x9e\x40\xbd\xa7\xea\x19\xec\x18\xc1\xcb\xc4\x62\xaf\xe2\x5e\xa1\xf5\xa8\x7b\x1b\x72\x15\xed\x6f\xab\x09\xe9\x4b\x9a\xf7\xb5\x24\xeb\x9b\xf6\x3b\x49\x46\xd4\x27\x5a\x61\x1f\x6a\xa9\x4b\xc8\x8e\xaf\xe0\x0e\x98\x4b\xb6\x9b\xab\xef\x82\x7f\xb5\x2f\x21\x9b\x2d\x61\x3d\xf5\x5d\xa3\xa5\xd2\x6e\x1a\xed\x54\x9f\xd2\x5a\xfd\x9c\xee\xa2\x78\xb5\x45\x77\xd2\x02\xda\x03\xd7\x26\xae\x5a\x41\x1e\x0b\xf6\x23\xba\x72\x96\xc6\x5a\x45\xe8\x9f\xc6\xab\x5a\xcb\x15\xb4\x57\xf4\x8f\xd6\x37\xdd\x85\xd1\x3d\x14\x49\x8b\xd6\xed\x57\x54\xae\x23\x7d\xa2\x5d\xcd\xc2\x1d\xbb\x42\xf7\x8d\xee\x87\x35\xc4\xf6\x74\x86\x70\x56\xd0\x4c\xae\xa0\xd6\x87\x94\xa2\xb3\x9f\xd2\xce\xf2\x39\x69\xb1\xb6\xfd\x25\xd2\x66\x0d\xf5\x7a\x85\x7a\xbd\x41\x9e\xd6\x64\x1a\xfb\x3b\xb4\xf3\xbe\xab\x47\xbd\x04\x7b\xc4\x0a\xbd\x47\xac\xa5\xab\xbe\xd2\x77\xcb\xdd\x7a\x9f\x90\xd4\x73\x8d\x3e\x1b\xdd\x3b\x3d\x68\x25\x2e\x21\x94\xc7\x61\xa9\x68\xec\xaf\xe1\x0e\x8b\x2c\x15\x5d\xf7\x4c\xd4\x93\x46\xf4\x1a\x69\xbb\x02\x9a\xc6\x36\x7d\x07\x3d\xe3\x1d\xda\x91\xef\xd0\x99\x8e\x3b\x95\xf6\x49\x7d\xe6\xab\xce\x3d\xfc\x15\x8d\xd8\x93\xec\x36\x81\xec\x36\x41\xf7\xc6\xde\xd2\x29\x33\xd2\xeb\x0b\xdc\xe7\x6b\xb5\x8e\x9e\xb6\x76\x9f\xce\x7b\x7c\x07\x6a\x0d\xa4\x14\xed\x3d\xef\x60\xc7\x5b\x41\xeb\xe9\x03\x5a\xb9\x1f\xea\x59\x58\xd2\x31\x0b\x34\xfe\x87\xa3\xb1\xeb\xd9\x30\xb0\xc2\x96\x60\xef\x78\x4a\xcb\x2d\x83\x8c\xb9\x09\xbb\x45\xf7\xfe\xe3\x98\xf7\xb9\x11\xf7\x51\xef\x59\x64\xe9\xb9\xda\x7e\xd1\xe7\x8a\xd1\x3d\xf1\xa5\x3e\x5e\xab\x6d\x72\x2d\x21\x5f\x42\xb2\x97\x11\xf2\x67\x7a\xa5\xac\x6b\xbf\x5b\xcb\x8f\x66\xf0\xa2\xc4\x2a\x24\xf9\xd8\xc1\xd0\x2b\x5a\x53\x14\x91\x76\x8c\xee\x74\x92\x6d\x51\x2b\x4d\xad\x34\x8d\x75\x09\x8d\x75\x09\x76\x96\xb9\xe0\xf4\xf7\xc8\xa7\x94\xe4\x69\x46\x91\xcd\x3c\xed\x3d\x1b\xf2\xde\x76\x4f\x2e\xa4\xf4\x22\xa5\x57\x37\x9c\x49\x7b\xa6\x47\x51\x5b\x2d\xf5\xeb\x47\x91\xf4\xcf\xd8\x3e\xb4\x0a\xd3\x2c\xcb\xf2\x6c\x5f\x36\x84\x1d\xc2\x46\xb1\x63\xd8\x18\x36\x56\xee\x27\x0f\x94\x15\xb2\x5a\x86\xf2\x20\x79\xa8\x3c\x4c\x0e\x97\x47\xc8\x91\x72\x94\x3c\x4a\x1e\x2d\x47\xcb\x63\xe4\x18\x79\xac\x3c\x8e\x22\xda\x3a\xd9\x20\x27\xcb\x29\x72\xaa\x9c\x21\x4f\x96\xa7\xca\x33\xe4\x4c\xfd\xc6\xe2\x03\xf2\x61\xf9\x88\x7c\x54\x3e\x26\x1f\x97\x4f\xc8\x27\xe5\x22\xf9\x8c\x5c\x2c\x69\x5f\x91\xff\x94\x2f\xc8\x17\xe5\x52\xf9\x92\x7c\x59\xbe\x22\x5f\x97\xcb\xe4\x1b\xf2\x4d\xf9\x96\xa4\x55\x2a\xdf\x93\xef\x4b\x5a\xf5\xf2\x43\xb9\x52\x7e\x22\x3f\x95\x9f\xcb\x2f\xe4\x1a\xf9\xa5\x5c\x2b\xbf\xa2\xa8\xf9\x6b\xf9\xbd\xdc\x20\xdb\x55\x6f\x55\x61\xbd\x67\xbd\x6f\xad\xb0\x3e\xa2\xb1\xa4\xc8\xc7\xe9\x4f\x39\x22\xf9\xff\x1d\x9f\xf8\xab\x13\x13\x4f\x64\x5e\x4e\x3c\x3f\x5a\x5a\x3c\x12\xbf\x65\x1c\x3f\x73\x51\xbb\x6e\xd4\x33\xce\x53\x1b\x3d\xa5\x9a\x9d\xe8\xb9\x34\x71\xf6\x94\x44\xfe\xdd\x46\xcf\xb0\xf4\x53\x1b\xe3\xe2\xc4\xd9\x03\x12\xf9\x39\xa5\x57\xc5\xfa\x27\x75\x46\x3d\xf1\x0c\x2b\x96\x19\xd7\xcd\xcb\x8b\xf2\x93\xf5\x58\x4e\x32\xdf\x1c\x9b\x6c\xd2\x1a\x09\xf4\x2e\x16\x48\x8e\xfd\x07\x47\x0d\x9b\x6f\x3c\xf6\xe4\x73\xae\x22\xe2\x8f\xf9\xc4\x3f\x7e\xbf\x24\xf1\x89\x3f\xde\x65\xbe\xb1\x73\xcd\x2e\xfe\x9f\xbd\x66\xe3\xe7\x1d\x5d\xde\xfc\x8c\x9f\x1c\xe9\xf7\x3c\xd9\xa2\x62\xde\xe5\xdd\xce\xf8\x78\xf2\xbd\xdf\xf8\xcd\xd2\x99\xc5\x1c\x32\xf7\x4c\x5c\x3b\x38\x71\x24\x7e\xb7\x76\x76\x11\x31\x7e\xab\xb3\x9b\xf7\x57\x37\xf1\xe6\x6d\xf2\x6d\xdb\xa4\xce\xdd\xe8\xb3\x19\x6f\xc9\xc6\x4f\xa0\xe2\x7c\x93\x36\x19\xdd\xbd\x4d\x7e\xd8\x1a\xc9\xb7\x58\x71\x7c\xc0\x46\xa3\x5e\xd8\xbd\x85\x93\x6f\xa2\xe2\x2a\x55\xcc\x13\x6f\xd8\x6e\xfe\x9a\xfd\xaf\xbc\x13\xd3\x9f\x10\x26\x50\x6a\xa0\xd4\xcc\xa2\xbf\x31\xc2\xd8\x19\x94\x22\x6b\x5d\x48\x29\xd2\xef\x5a\x4a\xd7\x53\xba\x89\xd2\x1c\x4a\x77\x52\x8a\x9e\xde\x2d\xa0\xf4\x10\xa5\x27\x28\x45\x63\x7d\x81\xd2\xab\x94\xde\xa4\x14\xbd\xad\xfd\x31\xa5\xe8\x89\xdf\xba\xe8\x7d\x07\xfd\x3e\xe7\x66\xe4\x1b\xee\xd8\xc4\xf1\xa5\x3a\x5f\x59\xac\xb7\xeb\x6f\xd5\x76\xe6\x25\x47\x92\x7d\x18\xd3\x47\xbe\xd3\xd7\x26\x72\xdc\xc7\xf7\xfd\x4f\xbf\x8f\xf5\xfe\x18\x7f\x1f\x27\xfe\x16\xcc\xe2\xe2\xde\x17\x7f\xef\x26\xfe\xc6\x4d\xc7\x77\x58\xf4\xf1\xd5\xc5\x9e\xe8\xbf\xb0\xb4\x0f\xbe\x63\x35\xb2\x28\x0d\x79\xfc\x1d\x96\x01\x1b\x1d\x19\x9c\x90\xf6\x4d\x42\xce\xec\xd2\x1c\xc7\xe3\x9e\x57\x97\xea\xbc\xb1\x3e\x38\x32\x3a\x21\x79\xe3\xfc\xea\xd2\x7c\xf3\x6d\xf2\xc3\xd6\xe8\x62\x81\xe4\xd8\x7f\x70\xd4\x5d\xbe\xb7\xbb\xa8\x68\xcf\xe4\x1b\x12\x09\xc4\xcd\xbf\x8f\x7f\xf8\x4d\xc5\xe8\x9d\x9f\x7d\x29\x1d\xc8\x7e\xec\xf7\x7e\x22\x3d\xa2\xa7\xd6\xf3\xa2\x37\x2d\xc8\x3a\xbb\xeb\x11\xee\xae\xb5\x0f\xf5\x5b\x24\x43\xf4\xdb\x22\xf1\xd9\x28\x5f\xab\xdf\xcc\x58\x8e\x11\x86\x9d\xf9\x72\xd8\x74\xc6\xff\x5e\x2e\x14\x73\x12\xbc\x92\xd8\x79\xbb\xf9\x7e\x45\x75\x62\xf7\xaf\x2b\xe5\x1e\x76\x71\x29\x13\xe0\xdb\x14\x89\xef\xa5\xe8\x37\xf4\x3b\xea\x17\x6f\xc4\x0a\x33\x37\x62\x8e\x4d\x70\x61\x17\x9d\x37\xd6\x67\x23\xa6\xe9\x86\x71\x13\xdf\xd6\xe8\xf2\xfd\x90\xcd\xb0\x09\xea\x73\x36\x42\x1f\xbd\x91\x05\x16\x96\x8e\x65\x53\xa3\x06\x4a\xf2\x5b\x19\x6b\x8b\x92\x21\xbf\xf8\xad\x8f\xff\x4f\x70\x21\xdd\x0f\xfd\x3a\x3d\x8b\x79\x6c\x97\xce\x23\x1d\xc7\x07\x76\xda\x45\xdb\x94\xae\xdb\xa5\xe4\xec\x9e\xe8\xd3\x99\x43\xda\x7a\xe4\x03\x13\x75\xd6\xd9\x7f\xcf\x84\x7d\x67\xe9\x23\xa7\x15\xf3\xe8\x6f\x31\x50\xad\xf8\xae\x4b\x84\x66\x6e\x28\xdb\x30\x65\xc3\xd8\x0d\xe7\xd0\xff\xa5\xdd\x3c\xb9\xd5\xdf\x44\xa7\xff\x65\xd1\xd3\x56\xae\x88\x55\xe3\xa7\xaf\x8c\x81\x75\x17\xef\x7f\xd3\x73\x51\xf9\x8f\xed\x6b\x56\xeb\xf6\x15\x1b\x76\xfa\x7f\x02\x00\x00\xff\xff\xe8\x0f\xe9\x8c\x38\x92\x05\x00") + +func liberationserifBoldTtfBytes() ([]byte, error) { + return bindataRead( + _liberationserifBoldTtf, + "LiberationSerif-Bold.ttf", + ) +} + +func liberationserifBoldTtf() (*asset, error) { + bytes, err := liberationserifBoldTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationSerif-Bold.ttf", size: 365112, mode: os.FileMode(420), modTime: time.Unix(1459927770, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationserifBolditalicTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xfd\x77\x60\x54\xd5\xf6\xf7\x8f\xaf\x7d\xce\x94\x24\x04\x52\x81\x90\x10\x66\x86\x10\x8a\x94\x04\x02\x84\xd0\x32\x40\x12\x02\xa1\x84\x12\x48\xa8\x09\x04\x08\x48\x6f\xa2\x48\x51\x51\x91\x22\xa0\xa8\xa8\xa8\x78\xed\x8a\x1a\x04\x15\xb1\xa1\x62\x41\x44\xb1\xa0\xa0\xa8\x08\x4a\xb0\xa0\xe8\xc5\x0a\xcc\xf9\xbd\xf6\x99\x09\x46\xc4\x7b\xef\xf3\xfc\x9e\xff\xbe\xf3\xb9\x6b\xf6\x3e\x7b\xaf\xbd\xca\x7b\xad\xdd\xce\x04\x3f\xa2\x44\x24\x8e\x2f\x87\xa4\xe7\xe5\x0d\xed\x3f\xfc\x5b\x73\x90\x38\x1f\x2a\xa6\xb5\x61\xef\x9c\xdc\xbc\x45\x1f\xce\x8d\x11\xe7\xa8\x9d\x3c\x2f\xef\x5d\x38\x70\x48\xec\xa2\x1e\xd7\x8a\x73\x62\x2b\x91\x5e\x17\xf5\x1e\x52\xd4\xb3\xc1\xde\x15\xc9\xe2\x1c\x9d\x2f\x12\x76\x64\xe0\x90\xb4\x76\x2e\xe3\x8d\x38\x11\xb5\x1d\xfe\xd2\xf1\xd3\xca\x66\xfa\xd6\xe5\x32\xf6\xa2\x72\x11\x57\xc7\xf1\xf3\xe7\x7a\xcb\x3b\x8e\x79\x4f\xa4\xdb\x4c\x11\xe3\xc0\xc4\x99\x93\xa6\x2d\x2e\x7b\x2a\x46\x24\x7d\xa3\x88\x7b\xdb\xa4\xb2\x39\x33\x25\x41\xc2\xd1\x57\xc9\xf8\xe8\x49\x53\x2f\x9d\xb8\x76\x77\x2f\xaa\x15\x1b\xc4\x31\xf5\x54\xc5\x84\xb2\x72\xb9\x64\xd9\x19\xe4\x77\xa5\xb1\x63\x05\x0d\xb5\xb7\xd5\xc9\xe5\x79\x2e\xcf\x4d\x2a\xa6\xcd\x5d\xb0\x64\x43\x8b\x37\x90\x9d\x20\xd2\xbc\xdf\xc5\x13\x66\x4f\xcf\x38\x1b\xf6\x86\x38\xf6\xaf\xc2\xc9\xc3\x53\x67\x8c\x2f\x4b\x18\x76\x75\xa4\x88\x1f\x7b\x9b\x17\x4e\x2b\x5b\x30\xb3\xce\x65\x8e\x6b\x18\xbf\x81\xf1\xde\xe9\x65\xd3\x26\xcc\x2b\x7f\xf1\x2e\x71\x7c\x3d\x55\xa4\xd6\xa9\x99\x33\xe6\xcc\xbd\x3c\xf0\xc6\x1c\x71\xfc\x5c\x2a\x32\x69\xe0\xcc\xd9\x13\x66\xee\xec\xee\x3b\x24\xd2\xa9\x50\xc4\xd9\xc8\xc6\xce\x80\x73\x5e\xe0\xdf\x63\xa3\xba\xfe\x6c\x78\xc2\x44\x7f\xde\xba\x31\xb9\x4f\x75\x79\xfa\xfe\xb3\x37\x46\xcc\x77\x1f\x14\x53\x74\xa7\xb2\x19\xf8\x76\xfb\x02\xb9\x32\x3c\xe2\xe1\xd3\xf7\xff\xf1\x79\xc4\x7c\x29\x97\x64\xa9\xf1\x89\x88\xd3\x3c\x11\x71\x6a\xb0\x0c\x95\x75\xe2\x42\x4b\xb4\xa4\xc9\x28\x11\xf3\x0e\x63\x16\xb2\x94\x98\x8e\x79\xc6\x73\xe2\xc4\x8e\xdb\x9c\x19\xd2\x4a\xa5\xda\x65\x3f\x73\x93\x4c\x34\x62\x95\xd3\x30\xdc\xa6\xcb\xe9\x0c\x37\x1d\x87\x25\xc2\x2a\x94\x05\x16\x62\x7d\x5a\x76\xdb\x1e\x43\x7a\x51\xf3\x5a\x67\x9c\x17\x07\xf2\x54\x86\xdb\xa7\x9e\x2d\x15\xf5\xe2\xe7\xbf\x22\x7d\xb3\xb3\x9b\x46\x42\xea\xb8\xb2\x82\x96\x18\x21\x32\x93\x65\xa3\x63\x96\x9a\xe9\x10\xeb\x34\x74\xdc\xf5\xb0\x2c\x83\xa7\x9d\x91\xa5\x12\x8d\x87\x65\x82\xf1\xb0\x35\xc9\x21\x72\x8f\x63\x8d\x2c\x32\xc4\xfa\x80\xb6\x96\x8c\x8b\x32\xb2\xac\x65\xb4\xf7\x86\xd2\x19\x57\x05\x9d\x84\x0e\xf3\x5c\x1f\xca\x83\x86\x41\xa9\x50\x23\xc6\xe4\x42\x89\xc8\x98\x00\xcd\x87\x6e\xa5\xfd\x19\xd7\x83\x92\xee\x1c\x66\xdd\x0c\x9d\x70\x0e\x93\x3c\xe7\xeb\xd6\x8f\xd4\x35\x05\x9c\xaf\x4b\x9e\x2b\xcb\xfa\xd1\x4c\xb6\xbe\x43\xee\x19\xdd\xee\x38\x6a\xfd\xe8\x4e\xb6\xbe\x82\xef\x04\xfd\x7d\x79\xb6\x74\x49\xdf\x59\xc7\x1c\x74\x1d\x95\x9b\x78\x7e\x00\x59\x0b\xdc\xc9\xb2\x9a\xf6\xb7\x68\x9b\x0c\xdf\x69\xf4\x67\x18\x59\x72\x25\xfe\xdc\x8c\xfe\xab\x90\x39\x89\xb6\x63\xd8\x91\x00\x25\x99\xab\xa5\x91\xae\x53\xa6\xd3\xce\xb4\xb1\x3e\x46\x66\x73\xc6\xb4\x37\xb2\x02\xa7\xe8\x6b\x48\xbd\x35\xd8\x34\xa3\xfd\x22\x9e\xbd\xf0\x4c\xa7\x4c\x04\xc3\x8b\xb0\xf3\x67\xfa\xbb\xd3\x57\x80\x8c\x38\x6c\x30\x34\x2e\xe6\x6a\x2b\x83\xbe\xd7\x8c\xdd\xd2\x50\xbd\x22\x2b\x8d\xdd\xd6\x72\xf4\x0f\x0b\x61\xdf\x8f\xf1\x0b\x83\xd8\xcb\x78\x28\x1f\x9e\xa7\x34\x6e\xd8\x70\x8f\xf3\x0f\x19\x6e\xf8\xa4\x98\xe7\x42\xc7\x41\x99\xad\xb1\xd7\x6d\x3c\x5f\x67\x66\xc8\x76\x47\xb9\x14\x19\x13\xb1\x71\xa2\xb4\xa0\xef\xac\x63\xa3\xf5\x3a\x7d\x29\xc8\xae\xc0\xcf\x37\x68\x2f\x80\x16\x21\x3f\xe0\x62\x72\x40\xad\x5d\x41\x3d\xd5\xb8\xff\x8d\xdc\xab\xad\xb1\x76\x2c\x86\x9d\x8b\x85\x4d\x3a\x0e\x35\xc9\x8e\x55\x28\x0e\xe7\x13\xfe\x6d\xa3\xef\xa0\x1d\x8b\x1a\x14\x8a\xc5\x8f\xd8\xf3\x64\x08\xf7\xbf\x11\x7c\x89\x3a\x16\x3a\x0e\x35\x09\x6c\xd3\x42\x94\xa0\x4b\xed\xe7\x9f\x71\x38\x8f\xca\xa5\x1c\x1d\xef\xea\x58\xd4\x24\x1d\x0b\xda\x4b\x74\xa9\x7d\xb5\xf5\xfd\xad\x94\x3c\xad\xff\x1f\x4b\xed\xf7\x59\x6d\xa7\xf6\xc3\x1e\xf7\xa3\xb6\xef\xbf\x96\xaf\xeb\x39\x61\x7d\xfc\x4f\xa5\xce\x75\x9d\x6f\x94\x3f\xe9\x52\x63\x8c\x9f\x49\xa1\xb2\x59\xa8\x4c\x0b\x96\xd6\x1b\xd5\xcf\xae\x9b\x98\x1f\x17\x4b\x7b\x3d\x47\x74\x9e\xda\xf3\x84\x5c\xb5\x09\xac\x75\xce\x06\x4b\xeb\x05\x1b\xfb\x96\xc1\x67\x53\xce\xb5\x9f\xd2\x71\xd4\x58\xfe\xad\xdc\x29\xc9\xae\x5c\xe6\xf5\x10\xdd\x46\x5c\xc1\xf6\xfc\xd2\xbd\x5a\x7a\x53\x6f\xad\xe7\xa0\x9e\x07\xc1\xd2\x7a\xb0\xfa\x59\xcf\x4b\x3d\x37\xfe\xb1\x64\xce\x62\x63\x98\x2e\x1d\x7e\xe6\x4f\xf0\x39\xc2\xce\x17\x62\xf6\xbf\x96\xa1\xf9\x7e\x4a\xe7\x98\x1d\xe7\xd0\xbc\xd7\x73\xef\xfc\x32\x38\xbf\x25\xc9\xb9\x5d\x3a\x39\xeb\x5a\xdf\xdb\xf5\xd8\x50\x39\xcc\xfa\xbd\x66\xac\x5d\xd9\x32\xc8\x19\x2b\x4e\x3b\x3f\x1b\xd8\xf1\x26\xf7\xa5\x8f\x83\x36\xe7\xb0\xc0\x03\xb4\x6f\xd2\x31\x74\xde\x23\xd7\xba\x06\xdb\xeb\x45\x6b\x7b\x7e\x84\xe2\xc0\x73\x2b\xec\xd9\xe1\x7a\x45\x8a\x9c\xaf\x07\xbe\x20\x37\x2f\x3a\x37\x4f\x0a\xc4\x1b\x96\xc2\xd8\xb7\xc0\x73\x80\xf8\xed\xf5\xe4\x28\xf1\x9c\xa3\x65\x90\xc7\xa7\xac\xcf\x8c\x6f\x64\x01\x32\xea\xe3\xcf\x58\x7b\x7d\x01\x1f\x57\x06\x3e\xef\xc1\xf7\xdf\xa4\xbf\xf3\x09\xe6\x56\x67\x7c\x7e\x5e\xfb\x1c\xf2\x73\x88\x35\x0c\xfa\xc4\x7c\xd5\xfa\x16\xda\x69\xaf\x43\x5f\x49\x98\x19\x8b\xbc\x1f\xc1\x3c\xc2\x1a\xcf\x3a\xb3\xce\xd8\x25\x57\xa9\x33\x52\x5b\xef\x01\x11\x0f\x5b\x3f\x86\x7d\xa9\xd7\x57\x49\x08\xd3\xeb\x6c\x43\xec\x9f\x2d\xad\xc3\xc9\x85\x30\xb1\x4e\xb8\x36\xdb\xb1\xb5\xe7\x48\x75\xee\xd5\xc8\x85\xff\x29\x46\x60\x5a\xff\xfc\xf9\x66\xaf\x37\xcc\xf9\xbf\xcd\x8b\x10\x7e\xe7\xe7\x9b\xf6\x0d\x9f\xd6\xe8\x5c\xaf\x69\x73\xf5\x38\xf7\xa7\xcc\xcf\xab\xad\xfb\xce\xe5\xf0\xdf\xf4\x58\x07\xf5\xda\x70\x81\xf9\xff\x97\xf9\x1a\x9a\x67\x33\x2e\xe0\x6b\xb0\x0c\xe6\xf9\x4f\xe7\xf2\xfe\x3c\x5f\xcf\xcb\xef\x68\xc7\x33\xd6\xc3\xe6\x8d\xd6\xbe\xea\x79\xee\xfc\x51\xef\x97\xe8\xed\x6e\xfd\xea\x18\x24\xfd\xab\x63\xf7\x37\x7b\xfe\x61\xde\x9d\xc3\x23\x94\xef\xd8\x3a\x4e\xfb\x4b\xb9\xde\x5e\x07\x3e\x41\xc6\x17\xf8\x6b\xaf\xeb\xf6\x7e\xbc\xd0\x9e\xff\x47\xc9\x0b\xec\xb2\xf3\x24\x56\xbc\xe6\x0e\x19\x61\xef\xbf\xaf\x4b\x17\xca\xe5\x41\xbd\xd6\xbd\xd5\xeb\x89\xab\x37\xbe\x88\x2d\x47\xfb\xfb\x03\xfa\x2e\xb2\xf7\xb4\x67\x25\x2b\xb4\x66\xb7\x0d\xed\x9f\x75\x68\x7f\xae\x7a\x1d\xa7\xfe\x8a\x8e\xb7\xe3\x41\xa9\x6f\xe6\xf3\x9c\x6f\x1d\x77\x94\x59\xc7\xcd\x87\xa4\x23\x72\x9f\xb0\xf7\x57\x9b\xb0\xe1\x88\x64\x9b\x0f\x88\x2f\x84\x5b\xf3\xe0\xbe\x6b\xe3\x3e\xc0\x28\x65\x0f\xcb\xb2\x5e\xd2\x6b\x04\x94\xec\xd8\x6d\xef\xc1\x05\x21\x62\x2f\x0e\xbc\x6b\xef\x03\xcd\xad\x77\x6c\x5c\x46\x42\x0f\xb0\x4f\x4e\x42\x6e\xb2\x75\xa4\x06\x1d\x22\x4e\xf5\xcd\x72\xf0\xf2\xc9\x20\xf3\xb8\xb5\xdb\xfc\xd1\xda\x49\xfb\x27\xc6\x03\x81\x5f\x6c\x1a\x2e\xe1\x94\xfe\x90\xee\x30\xe4\xd6\x75\x94\x49\x63\xf3\x5b\x19\x8f\x3f\x5f\x80\xc1\x97\xba\x34\x23\xac\x9f\x34\x7e\xd0\x2e\x9d\x8b\xd0\x57\x66\x01\x73\xad\x40\x32\x28\x77\x99\x4f\x59\x55\x3a\x3e\xe8\x78\x17\x7f\x83\x7b\xd2\xdd\xd6\x7e\xfc\x5e\x8a\xcf\xff\x36\x4b\xad\xfd\xf6\xb9\xa1\xc0\x3a\xca\x18\xbd\xa7\x27\xb8\xee\x22\x5e\xa7\xc1\x6e\x3f\x73\xbc\xb5\x74\x77\x76\x91\xee\xae\x09\xac\x53\xaf\xb1\x4e\xfb\x20\x2f\xeb\xc8\x41\xeb\x13\xc7\x1c\xf6\x78\xc8\x18\x20\x9d\x34\xa9\xc5\xd6\x13\xea\x71\xca\xc7\xad\xaf\xa1\x6f\x8c\xb9\xec\x1d\x0d\x38\x03\xb4\xb4\x8e\xe8\x33\x9c\x3e\xdb\xb1\xde\x1d\x87\x3e\x33\x1e\x56\x0e\xa8\xc8\xa6\x76\x9c\xc9\xda\xc9\x95\xa1\x33\xd9\xad\x50\x77\x4d\xf0\xcd\x82\x1e\x80\xe7\x06\xca\x2b\xf4\xb9\x42\x9f\x93\xa0\xbb\x39\x53\x0c\x87\xf6\x40\xbb\x78\x5e\x03\x8f\x3e\xa7\x1c\x82\xde\x80\xa6\x86\xe8\x52\xfa\xf5\x98\x27\xe9\xcf\xa0\xfc\x03\xf2\x42\x63\xa0\x07\xa1\x11\x66\x1d\x59\x62\x5c\x2b\x37\xa9\x91\x32\x43\x1d\xc5\x8e\xed\x32\x19\x5b\x66\x9b\xd1\x72\xf3\xf9\x04\xff\xb8\x20\x59\xa3\x29\x4b\xc1\xed\x69\xca\x70\x28\x0e\x1a\x06\x0d\x85\x22\x20\xfa\xad\x67\xa1\xd7\xa1\x5e\x3c\x3f\x8e\xfe\xc4\x20\xd9\xba\xc7\x98\x6d\xac\x27\x34\xd1\xbf\x55\xe4\xec\x6f\x22\x81\xb6\x22\x56\x5f\x8e\x62\x63\x28\xb9\x0b\x04\x16\x51\xde\xa2\xef\x28\x94\x57\xf0\x5c\x9f\xf2\x00\x34\x03\xba\x9e\xf6\xab\x82\x7d\x81\xcb\x82\x7c\x81\xa7\xf5\x7d\x25\x44\x05\xd0\x0b\xb4\xdd\x0d\x71\x77\xb1\x7a\x06\x29\xf0\x39\xed\x6b\xa8\xdf\x0e\x75\x08\x91\x6e\x7f\x06\xba\x8f\xfa\x49\xa8\x1e\xf5\x96\xd0\x42\x08\x5d\x01\x2e\x47\x56\x36\xb4\x3b\xd4\x76\x03\xc4\x7d\xea\xec\x36\xca\x3c\x4a\x64\x9e\xfd\x84\x7a\x23\xca\x06\xd0\x52\xea\xdc\x8f\x02\xdf\x41\x51\x90\x17\x7a\x36\xa8\x53\x8f\xb7\x32\x29\xb1\xd7\x4a\x81\x34\xef\xcd\x94\xe8\x96\x54\x4a\x7c\x91\xcf\x28\xc1\xc3\x6a\x17\xe4\x3f\x1b\xa0\x3e\x2c\x34\x0e\xbf\x03\x8f\x05\xc7\x04\xbe\xa7\x0d\xcc\xce\x7a\x18\xc3\x1d\xc5\xc2\x07\x8b\x3b\x5f\x80\x1d\x35\xf0\x0d\x74\x0c\xc2\x17\xeb\x67\xfa\xbf\x0e\xda\x60\x3f\xbf\x0d\xed\x39\x8f\xb6\x87\xca\x21\x90\xc6\x3b\x1d\xfa\x17\xfc\xdc\x68\x2c\xee\x79\xd6\x40\x08\x5f\x2c\xee\x57\x81\x4b\x83\x76\x5b\x4f\x84\xf0\x8b\x0b\xe6\xa5\xa5\x73\xb9\x21\x73\xf2\x3b\xd6\x1a\x8f\x2e\xf5\x3d\x03\xfa\x92\xbe\xdf\xf4\xda\x47\xfd\x1d\x57\xa6\x75\xd2\xdd\x82\x3b\x42\xa4\xf5\x87\xf3\xa0\x75\x83\x4b\xac\x57\x5d\xf9\xd6\x3a\xe6\x78\xf3\xea\xfb\x87\x63\x3f\x7b\xb6\xc3\x7a\x2e\x74\xcf\x38\xad\xd7\x69\x57\x12\x73\x38\xb4\x97\xeb\xb5\xf1\xdc\xdd\x23\x4f\x5c\x7a\x7e\xdb\x6b\x39\x77\x10\xbd\x4f\xdb\xe7\x17\xd6\x62\x57\xa1\x7d\x76\x7e\xcb\x35\x51\xae\x60\x7f\x8e\xb3\xef\x2f\xfa\x2c\x32\x8d\x35\x92\x75\x50\xef\xff\x7a\x5d\x63\x4d\xc9\xd5\x6d\x8e\x06\xd6\x4b\xe6\x50\xa9\xc5\xd9\xc2\x6b\xaf\x93\xd7\x4a\x1b\xcd\xe3\x68\x26\xfd\x35\x9f\xa3\x9b\xb4\xd1\xe7\x07\xe6\xfc\x43\xfa\x5e\x61\x6e\x90\xae\xf6\x7a\x32\x46\xa2\x1c\x1e\x6b\xaf\xb9\x4e\x3a\x3b\x0a\xa5\x0b\x7d\x17\xd9\x32\x1f\x13\x9f\xb9\xdd\x8a\x77\x16\xcb\x50\xe7\x6e\xee\x6a\xfa\xcc\xa8\xdb\xf5\x3a\x4b\xa9\xdb\xd0\x95\xeb\xe8\x24\xb1\x9c\x3b\xd6\xb9\x76\x58\x53\x75\xe9\xb8\x5b\xbc\xae\xda\xe2\x76\x5c\x2b\xf5\xfe\xdc\xe3\x24\xd7\xbc\xdd\xbe\x5f\x05\xcc\x27\xad\x4f\x1d\x8d\x25\xd9\xdc\x28\xed\x9c\xdb\x64\x08\x6b\x54\x3c\x67\x9a\xc9\x60\xf0\xbd\x73\xb3\x14\xb1\x56\x56\x38\xcf\x58\x97\x9a\xdb\xac\xb7\x1d\xdb\x65\x20\x74\x8b\xf3\x46\xf8\x96\x73\xef\x68\xce\x9d\x23\x5b\x9a\x9a\xf7\x4a\x07\x33\x9e\xbd\x08\x1d\x8e\xb1\x92\x89\xcd\xad\xed\xbd\x4a\xaf\x95\xb3\xb0\x7b\x16\xf7\xc7\xe0\xfd\xa0\x44\xef\x59\x36\xde\x7d\x2d\xc1\xcf\x1b\x79\x8e\x08\xde\x4b\x74\x19\xbc\x93\xb8\x56\xca\x15\x76\xdc\x7a\x22\x33\xb8\xdf\x7e\x57\x7d\x5f\x74\xe7\x58\xcf\xba\xdf\xb1\x0e\xb9\x16\x11\x87\x69\xf0\x66\x59\xff\x76\xae\x93\xeb\x28\x7f\xb0\x63\xce\xb9\xef\x5c\xdc\x2f\xb1\x26\x68\x79\xee\x62\x6b\xa5\x23\xd6\xfa\x4e\xf3\xda\xfc\x8c\x73\x2e\x42\x0e\x76\xe8\x58\xd7\x8c\xb9\xbd\xa7\xea\xfb\xa6\x96\xb9\x57\x7a\xd9\x31\xd7\xb2\xcf\xc8\x8b\xe1\x86\xf5\x83\x26\x57\x5d\x19\xe2\x7e\x89\x7c\xe1\x6c\xe9\x24\x6b\xc3\xe6\x20\xe3\x2a\x6b\x97\xbd\x3f\x06\xa4\x9d\x79\x23\xeb\xe2\x29\x89\x31\x7f\x93\x14\xbd\xd7\xbb\xef\xb4\x2c\xd3\x63\xbd\x77\xee\xce\x52\x87\x3c\x48\xb2\x76\x38\x17\x12\xff\x59\xd2\xd1\x8e\xbb\x7d\xe7\xb1\xa6\xeb\xf3\xa9\xde\xff\xec\xbb\xcc\x0e\xfb\x2e\x5a\x65\x8f\xc9\x90\x14\xee\xf0\x05\x9a\x1c\x99\xd2\xd4\xb9\x5a\xda\x9a\x0f\x42\x83\xad\xdd\xce\x8f\xb8\x27\x78\xc8\xb7\xd0\x9d\xca\x91\xc6\x5e\x91\x4a\xde\x0c\xe6\xbe\x15\xbc\xbf\xb6\x0f\xde\xb1\x88\x49\x1e\x7a\xb7\xa1\x53\xef\xc7\x75\xec\x73\x7c\xf0\xfe\x44\x19\xee\xc3\xf7\xb5\xf6\x99\x99\x3d\x51\x2e\x0a\x73\x58\x27\x9d\xe5\xd2\xd1\x59\xc2\xdd\x76\x99\xb5\x23\x6c\xa4\x75\xd2\x75\x4c\x46\x80\xe7\xad\xce\xd9\xd6\x8a\x88\x55\xcc\xbf\xcf\x90\x15\x6b\xbd\x8e\x7f\xcf\x33\x37\x06\xdb\xf9\x19\xca\x33\x57\x07\x59\xe0\xc8\x97\xb8\xea\x32\xec\x4b\xe9\xeb\xae\x4b\xfb\x03\xf4\x3f\x2f\xde\xf0\xd9\x92\xe7\x9a\x2b\x2d\xce\xe9\x0d\x9e\xcf\x3d\xe6\x12\x61\xfd\xb3\x10\x61\xb1\x16\xc9\xa0\xe0\x3a\x7c\x96\x75\xfb\x0c\x6b\xe9\x99\x74\x1d\x43\xfb\x4c\x06\xfe\x60\x50\x66\xcf\x55\x8d\xdd\x2b\xd6\x49\x70\xef\xa0\x63\xaf\xf1\x77\xfe\x44\xce\x44\x4a\x07\x1d\x7f\x1d\x03\x9d\x03\x3a\x0e\x3a\xfe\xda\xf7\xf3\xca\x86\xae\x75\xec\x43\xb7\x4a\x8c\x9d\x0b\xc4\xc5\xfd\x0b\x71\x0d\x93\x8e\xe1\x61\xe4\x59\x43\x69\xe3\x7c\x83\x79\x73\x46\x92\xab\xef\x11\xf6\x99\x5d\x9f\x55\xf4\x3a\x20\x92\x19\x2c\xad\xa7\xec\xf7\x13\xc4\x8d\xbe\xf6\xd8\xa9\x74\xee\xe8\xf8\xfd\x59\x72\xde\xd2\x77\xc2\x33\xd2\x94\xb2\x61\x75\xa9\x73\xbc\xda\xd6\x90\x4d\xad\x74\x9e\xea\x5c\xa9\xb6\xa9\xba\xac\x96\x65\xcf\x25\xf2\x48\xdf\x4f\xfe\xf1\x0c\xfe\xe7\x99\xb3\x8f\x7d\x56\x0f\x95\xe7\xe3\xc2\x7d\xb0\x0d\x67\x9e\x75\xd5\xf8\x9e\xc3\xf9\x9f\xce\xaa\xe4\xbe\x9d\x7f\xcc\x15\x3b\x5f\xcf\x2f\x43\x36\x56\xc7\xc3\x9e\x33\xe4\x2d\xcf\x01\x3b\x3e\x21\x9c\xaa\x4b\xf0\xab\xa7\xed\x76\x8d\x65\xad\x0a\x48\x63\x57\x67\x99\xef\x5c\x28\x23\x1c\x45\x32\xdf\xf4\x48\x73\xb7\xc7\x7a\x16\xec\x76\xd8\x77\x81\x2f\xa4\x45\xf0\x6e\x20\x8d\x9d\x4f\xca\x4d\xee\x87\x88\x03\x77\x37\x33\x53\xc2\xab\x31\x0b\xd9\x99\x18\xbc\x43\xea\xd7\x62\x81\x25\xe4\xd2\x53\xe4\xd5\xbb\x94\x1f\x41\x3b\x68\xd3\xfb\xd5\x57\xd0\x28\x88\x3d\xd8\x2a\xa6\x8d\x7d\x5d\xae\x0d\x92\xbd\x57\xbe\x43\x5d\xef\x69\xfa\x1c\xf0\x20\xb4\x21\x38\x2e\xc0\xbe\x75\xf6\x0f\x4a\x2d\xf3\xa7\x20\x9f\xee\xb7\xd8\x23\xad\x57\xa0\x85\xa1\xb3\xc8\xa7\xa1\x3d\x9c\x73\x47\x40\x9f\x47\x38\x9b\xe8\x17\x7c\xfa\x5c\x62\xcb\x7a\x21\x28\x43\x32\x83\x14\xd0\x67\x8c\xcd\x50\x24\x67\xa5\xa3\x94\x1f\x39\xae\x50\x2d\xaa\xfb\xf5\x79\x99\x72\x00\x7c\xa7\x8c\xdb\x44\xcb\xdf\xe8\x4c\x61\x2e\x7c\x62\xbd\x6f\xdc\x6b\x6d\x72\xa4\xca\x2c\xc7\x6d\x92\x64\x44\x72\x86\xea\x22\x39\x8e\xe7\x24\x8d\xf3\xe7\x15\x46\x03\x99\x61\x7e\x2f\x15\xe6\xd7\xd6\x66\xf3\x05\x29\x77\x04\xe8\x7b\xc1\xfa\xc3\x88\xe0\x0c\x7e\x9b\xf5\x2f\xc7\x6a\xf6\xa5\x6b\xad\x97\x18\xdf\xcd\x31\xc2\xda\xeb\x68\x29\x86\xa3\xad\xf5\x93\x23\x1f\xd9\x8c\x73\x3e\xcc\x7e\xf2\x05\x67\xad\xef\x64\x28\x6b\xdb\x0c\xf6\x9b\x19\xea\xa0\xe4\x98\x11\x50\x81\xd5\xc7\x51\x69\xf9\xc1\x5c\x99\xc7\x38\x1f\x6f\xe7\xce\x5e\xc0\xd9\x1d\x32\x0f\x70\x1e\x26\xbf\x38\x7f\x57\x99\x91\xec\x05\xe1\x7a\x6d\xb2\xee\x67\x0f\xd8\xe1\x6c\xa3\xdf\x63\xb1\x87\xdd\xc9\xfd\xe5\x57\xce\xe1\xbf\x92\x8b\xbf\x5a\x07\xf4\xbb\x07\xf3\x6a\x71\xd0\xa7\xd7\xc7\x2e\xe6\x8b\x9c\xd7\x7f\xb4\x1e\x35\x8f\x4b\x4b\xe6\xc9\x1e\xf6\xd3\x31\xe6\x07\xe4\x66\x3a\x6b\xec\x31\xea\x25\x12\xee\xd8\x61\xed\x33\xf6\x70\x7e\xf7\x58\xc7\xcc\x8e\xd6\x1f\x8e\x89\xac\xc7\x7a\x1d\x1c\x66\xad\x73\x1c\x96\x51\x5a\x86\xa3\x1d\x6b\x02\xb9\x61\x16\x71\xe7\xb8\xdd\x3a\x61\x9a\xac\x37\x9a\xc6\xb2\xe6\x26\x48\x77\x28\xd5\x1c\xcd\xbd\x60\x86\xc4\xaa\x5d\x52\xdf\xa8\x90\xf6\x66\x3f\x69\x61\x7c\xcb\x5a\xd9\x87\xbd\x6d\x15\x76\xdd\x0f\xff\x7c\x29\x37\x7b\x4b\x5f\xda\xdb\x21\x2b\xdf\xf8\x52\x56\x99\x2b\xe5\x31\xee\xd6\x77\x1b\x13\x24\x0f\x1a\xab\x4b\xe6\xd9\x68\x63\x90\x2c\x44\x8e\xdf\xe8\x28\xa3\xa0\x41\x46\x53\xc6\x35\xe5\x2e\xd4\x47\x7c\x9c\x95\xdb\x1a\x9d\x59\x57\xee\x90\x6c\xad\xcb\x28\xa6\xef\x22\xce\xce\xc5\x9c\x6d\x8b\x65\xb8\x31\xc5\xfa\x41\x5d\x81\xac\xf1\xdc\x97\x56\x48\x91\x79\xa5\xa4\x1b\x71\xf0\xbc\x24\x7d\x8c\x91\xa2\x94\xc5\x98\x32\x64\x56\x4a\xb9\xd1\xcf\x3a\xa5\x46\x5a\x1f\xa8\x37\xad\x7f\x1b\xe3\xad\x97\x8d\x38\xeb\x90\x31\xd2\x5a\xa1\x2c\xce\xce\xab\xac\x1f\x8c\x4a\xce\xd1\xfd\xac\xc9\xce\xc3\xf6\xdd\xaf\x96\x9e\x6b\x9c\xa7\x3e\x61\x9e\x1f\xe7\x1c\x72\x98\x39\xa8\xf7\x8b\xa7\xcc\x72\xeb\x57\xca\x53\xc4\xeb\x5a\xfb\x3e\xc9\x7d\xce\x74\x71\xb6\x68\x60\x1d\x77\x65\x5b\x3f\x19\xa5\xdc\x03\xb2\xf4\xbb\x13\xd6\xdc\x6b\xb9\x03\x97\x59\xfa\xdd\x66\x92\xbd\xff\xdd\xc9\xdd\x66\xb7\x7d\xff\x6b\xc8\xf8\x7d\x7f\xbe\x57\x85\x37\xf4\x3e\xd5\x5c\x10\x38\xa9\xcf\x3c\xf6\xfb\x0b\x5b\xfe\x9f\xef\x09\x69\x6f\x13\xba\x57\xee\xa3\x1e\xab\xf7\x2e\x4a\x65\x3c\x60\x6d\xb1\xf7\xaa\x57\xad\xef\x6d\x6c\xdd\xe0\xe5\x16\x07\x18\xf6\xd2\x58\xaa\xab\xc4\xa5\xae\xb2\xb6\x18\x6d\x44\xb8\x3f\xf5\x52\xa3\xa5\x11\x74\x29\xd4\x0c\xea\xae\x46\x5b\x33\x29\x07\x41\x1e\x15\xe0\xbe\x38\x55\x62\xa1\x3c\x63\x80\x35\x1f\xfe\x1c\x63\xb8\x75\x58\x63\x6f\xa6\x49\x43\xf5\x05\x3c\x57\x59\x13\x91\x59\x0a\xee\x2d\x8d\x6b\xd8\xcf\xc7\x13\xc7\xf1\x32\x0d\xec\x13\xd4\x49\xeb\x17\xc6\x44\x42\x49\x8c\xff\x95\x71\xe3\x99\x83\xad\x82\x14\x38\x0b\xb1\x9e\x04\x9e\xbb\x30\x59\x91\xd0\xa5\xfa\xfc\x5d\x63\xbd\x3e\x11\x7a\x47\x75\x5e\xf9\xe7\xfb\xaa\xe0\x3b\xd4\xff\x52\x5e\xf8\x1d\x65\x58\xe8\xee\xff\x4b\x8d\xf6\x80\x7e\x57\x76\x81\x77\x94\x17\x28\xad\xad\xd5\xcf\xc4\x6a\x09\x31\xcd\x3a\xf7\xee\xa4\xfa\x5d\xce\x79\x65\xe8\xfd\xe3\x1f\xe7\x95\x53\x42\x65\xb7\xe0\xb9\x4b\x9a\x9d\x5f\xfe\xe3\xfb\xca\x73\xe5\x7f\x7b\x67\x12\x3c\x07\x54\x97\xe7\xbd\xbb\x3c\x75\x5e\xf9\xd8\x7f\x7d\x87\xf9\xd7\x77\x3d\xdd\xff\x5a\x5a\xb7\x50\x2e\xa3\x9c\xfa\x3f\xbf\xd3\x1c\x26\x0b\x42\xbf\x21\xd8\x65\xf5\xbb\xcd\x0b\x97\x62\x54\x97\x17\xd8\x27\x43\xef\x42\x2f\xfc\x1e\x34\xf4\xfb\x46\x77\x3d\x36\xf8\x6e\x5c\xcf\x73\xe2\x7d\xd2\x96\xf1\x0f\xef\xc7\xff\x9f\x95\xff\xdb\x7b\xf3\x7f\x28\xcf\x7b\x1f\x6e\xfd\xb7\x98\xff\xc7\xb2\xe0\x7f\x2a\xff\x12\xa3\xea\x77\xb0\xff\xad\xac\xf9\x3e\xfa\x82\xa5\xbe\x03\xfe\x07\x3a\xf7\xdb\xcc\x0e\x6b\x24\x74\x15\x75\xfd\xdb\xc5\xa0\xea\xf6\xe0\x1a\xf8\x77\x72\x35\x92\x9e\xd0\x64\xf7\x63\xd2\x03\xd2\x65\x03\x5d\xb7\xef\x96\xff\x81\xdc\x4a\x5a\x42\x93\xc3\xfa\x49\x0a\x54\x10\xd6\xcf\x3a\x1d\xaa\xcf\xd4\x64\xbf\x93\x0b\x52\x1c\xd4\x45\xbf\xdf\xae\xd1\x36\xc0\xfc\x8a\x7d\xf7\x2b\x99\xec\x9c\x27\x3d\x20\x5d\x36\x08\xd5\x67\x6a\xba\xe0\xef\x35\xfa\x0e\xb0\x46\xd2\xa1\xe9\x61\x1e\xe9\x01\x4d\x76\x0f\xc7\xde\xe1\xd2\x43\xdf\x59\xff\x13\xb9\xa2\xe0\xed\xc2\x99\xaf\x8b\x08\x54\xa6\xef\xb7\xff\x89\x5c\x3b\xc5\x05\xb5\x0e\x2b\x94\x06\x50\x0f\xf7\x72\x6b\x37\xf4\xa3\x7b\xb9\x0c\xd6\x54\x8d\x7b\x35\x8e\xd5\xb8\x54\xfb\x57\x6d\x6f\xb5\xfe\x6a\xb9\xff\x07\x71\x9c\x01\xdd\x42\xbd\x37\x34\xa1\xba\xfd\xff\xdf\xb8\xfc\xbf\xf2\xfb\x3f\xda\x5e\x83\x8c\x87\x55\x2d\xce\x04\x6f\x05\x4b\xce\x15\x0f\xcb\xe8\x0b\xd9\xed\xba\x52\x16\x43\x39\xee\x09\xb2\x18\xca\xd1\x7b\x44\xe8\x9d\x5d\x2b\x68\x4e\x08\xd7\x7e\x35\x72\x28\x57\xd3\xb9\xbb\x7c\x1f\x59\xec\x78\x94\x7d\xf7\x61\xb9\x3c\x34\x6e\xce\xf9\x39\xa0\xdf\x83\xd8\xef\x42\xaa\x9f\xed\xdf\x7e\xc8\xbd\x47\xb8\x07\x3c\x62\x4d\x74\x3e\x22\x93\x19\x37\x2a\x48\x2a\xe3\x42\xf8\x90\x6b\x8b\x75\x0e\x82\xc5\x62\x70\x4a\xd7\xef\x6e\xe0\xff\x1d\x7e\xfd\x9e\xdb\xfe\x91\xbf\xba\x34\x1e\x09\xfe\x76\xae\x8a\x82\x6d\x76\xfd\x36\xbe\x1e\xa9\xfe\x9d\xdf\xfa\x10\xf2\xea\xf3\x38\xfb\x77\x3f\xd6\xe2\xcf\x35\x85\x89\xf5\x85\x26\xfd\xbb\x0b\xcf\x3f\xfe\xf9\x5e\x56\x52\xf4\xbb\x59\x64\xbd\xac\xdf\x6f\x42\xba\x7e\x1c\xd2\xbf\x63\x7e\x6e\xec\x95\x52\xf4\x96\x85\xe4\xf5\xa7\x8c\xad\x26\xad\x97\xbe\x36\x86\x9f\xf5\xe6\x62\x79\x8b\x3b\xdf\x2f\xc8\xd3\xef\x7c\x93\x9d\x79\xb2\x51\xbf\xab\x55\xc3\x02\x37\xf2\x7c\x67\x8d\x71\xd1\x21\x8a\xd1\xcf\xc6\x44\xa9\x03\xa5\x43\x53\xa0\x36\xc6\x1b\x9c\x21\x27\xb0\xae\x76\x14\xc3\x28\xb6\x3e\x31\xb6\x73\x96\xeb\x68\x05\x1c\x47\x98\xc7\xc1\x77\x30\xfa\x3c\xf0\x89\xfe\xdd\xba\x7a\x3f\x76\xef\xb4\xf6\x84\xfd\x22\x69\xec\x45\x2d\x1d\x9f\x4a\x0b\x47\xa2\xfd\xbb\xd3\xcf\xc1\xf7\x69\x72\x53\xf8\x48\x19\xc9\xf3\x82\xd0\x6f\xf6\x79\x76\xce\xcf\x91\x3a\x5a\x16\x36\x34\x72\x3d\x22\x2b\xcc\x8b\x25\xcc\x3d\x98\x7b\xea\x1f\x52\x8c\x4f\x37\xb8\x52\xa5\x8b\x63\xaf\x14\xbb\x23\xc4\x67\x1e\x90\x4e\x2e\x91\xa2\xd0\x6f\xd8\x9a\x5a\x40\x39\xd0\x03\xfa\xbd\x5f\x98\xa8\x7f\x39\x44\x45\x9f\x5f\x6a\x32\x4f\x71\x7f\xf9\x4a\xa2\x5d\x37\x4b\xb1\x73\x9b\x8c\x72\x1c\x94\x7f\xd9\x98\x88\x54\x90\xa3\xbd\x69\x2b\x73\xef\x57\x1b\x9c\x3b\x55\x3d\xa3\xad\xf5\x10\x6d\x05\xd0\x14\xc7\x1a\x99\x68\x97\x9a\xf6\xda\xef\xc8\x27\x3a\xf6\x1b\x8d\x1d\xfb\x95\x93\xbc\xfa\xc5\x71\x42\xed\x74\x3e\x62\xac\xd6\xf5\xbf\x97\xe7\x93\x3a\x18\xec\xd3\xa5\xa6\x9a\x7d\xff\xa7\xed\xff\x0b\xb1\x8f\xff\x85\x8c\xfd\x94\x93\xec\xfa\x7e\x12\x6c\xbf\x2c\x84\x5c\xc6\x87\x9c\x55\x21\x9d\xd7\xee\x6f\xd5\x9d\xd0\xba\xea\x12\xdc\x1a\xc2\xf3\x80\xe3\x25\x19\x47\xf9\x04\xd4\x42\x13\xfc\x73\xc2\x5a\xaa\x2d\x61\x17\xab\x77\xdd\x45\x2a\xcf\x25\xea\x63\x68\x90\xc3\x2f\x5d\x9c\x7e\xe9\xea\xd8\x09\x4e\x75\xa5\x27\xf9\xbb\xcb\x65\xc7\xc0\xda\x5c\xf3\xb7\xe8\xd0\xfb\xb3\x1b\x68\xd7\x77\x87\xa1\xe7\x7e\x13\xfb\xf3\x5c\x68\x9f\x4f\x5c\xc5\xc4\x21\x9f\xf3\xcf\x15\xb2\xda\xd5\xde\x3e\xa3\x7c\xee\x9c\x62\x05\xcc\x7f\x31\xdf\x1f\x13\x1f\x39\xdd\x2e\xf4\xde\xb8\x20\x74\x6e\xfe\x92\xf1\x67\x34\xd1\xf7\x05\xb4\x16\xaa\x08\xbd\xbb\x66\xcd\xb2\x4a\xed\x35\xc7\x92\x44\x6c\xb9\x0b\x7a\x8f\xe7\x45\xfa\x6f\x25\x38\xbf\xea\x33\xec\x8f\xfa\xee\xab\xdf\xf7\xeb\x3b\xab\xbe\xe3\xea\xfb\x72\xf5\x3d\xb9\xe6\x7d\x58\xdf\x73\xf5\x1d\xd7\xb1\x44\xb2\xf5\x7d\xf7\x2f\xc4\x98\x6a\xfa\xfb\x5d\xdb\xda\x6b\x74\xe1\x4c\x69\xdf\xb3\xb9\xf3\xd6\xbc\x67\xeb\x3b\x76\xf5\xfd\xba\xfa\x6e\x7d\x81\x7b\xb5\xbe\xaf\x6b\xb9\x7a\x9c\xe6\x71\xa6\x68\x1f\xcf\x46\x11\xc2\x6f\x28\x37\x53\x3e\x13\x16\x5a\x89\xec\xf7\xc4\x22\xf3\xf0\x53\xaf\x81\xfa\xdd\xc1\xb1\x1a\x74\xf6\x4f\xd2\xef\x1c\xce\xb2\x1e\x9c\x29\x0e\xfe\x1e\x62\xd3\x93\xd0\xac\xe0\x7b\xf8\x73\xbc\xa1\xb1\xf6\x3b\x8a\xfa\x35\x78\xcf\xa3\x33\x16\xb4\x52\xe4\xf4\xb7\x94\xef\x50\xde\x1f\x6c\x3f\x3b\x8d\x71\xcb\xa0\x37\x69\xff\x9d\xe7\xcb\xa0\x89\xd4\x59\x9f\xce\xa6\x50\x76\x3e\x5f\x96\x3e\xe7\xc1\xaf\x7f\x43\x30\x29\x7f\x0f\xbe\xef\x0b\xec\xd7\xbf\x69\x38\x86\xcb\xa6\xf3\xa8\x3f\x34\x38\x54\x6a\xca\x33\xa3\x59\xaf\x86\x4b\x87\x10\x0d\x84\x5a\x43\xf9\xb4\xeb\xb2\x09\x94\x1a\xa2\x66\x50\x1a\xed\xba\x9e\x0c\xd5\x87\x3a\x86\x28\x9d\xf6\x16\xa1\xf1\xfd\x6a\xd0\x18\xda\xfb\x5d\xc0\x8e\xc2\x50\x7f\x5e\x35\x6f\x88\x2f\x0d\xca\x82\xb2\xab\x89\xf6\xec\x90\x8e\x0e\x35\xf4\x75\xa4\xbd\xc3\x79\xba\xaa\xe5\x54\x9c\x2f\xbb\x86\xfc\xf3\xed\x18\x06\x0d\x87\x4a\x42\xe5\x30\xf8\x46\x51\x76\x82\x32\x43\xa4\xeb\x9d\x68\xd7\x65\x6f\x28\xb7\x26\xd1\xae\xcb\x2b\x42\x94\x15\xa2\xce\xb4\xeb\x72\xdd\xf9\xf4\x0f\x76\x9c\xef\xc7\x40\xf8\x34\x96\xe9\x35\x7c\xd6\x78\x27\x87\x70\x4e\x0b\xc5\xa3\x3a\x36\x4d\x42\x71\xc9\x0f\xc5\x6f\x60\x75\x4c\x43\x71\xcc\xab\x11\x73\x3b\xfe\xa1\xb8\xff\xc5\x0e\x72\x46\xff\xed\xd0\x3c\xca\x7b\x43\x74\x73\xe8\xf7\xab\x97\x20\xf6\xed\xc0\x23\xfa\xf7\xdf\xff\x76\x9e\x23\x27\x3b\x9e\x47\x03\xfe\x72\x0e\xfe\x2f\xe7\xd6\xff\xc6\xaf\xdf\x67\xe8\xbf\xbd\xd1\x7b\xab\x2b\x57\xf4\xbb\xc4\x77\x83\xef\x04\xec\xbc\xff\x30\x64\x77\xe8\x7d\xa1\xa5\x7f\x3b\xd4\xbf\x07\x7e\x15\xfa\x6d\x96\x67\x6b\x8e\xfe\x3d\x8b\xb6\x4a\xa8\x7b\xa8\x7c\x11\xaa\xaa\x41\x5f\x9a\x2f\x58\xcf\xd8\xa4\xd7\x21\xbd\xc6\xa4\xfc\x49\x7a\x4d\xd2\x6b\x58\xf0\xf7\xc5\xb3\x8c\x3d\xfb\xb4\xa3\x99\xd4\xb5\x7f\x5b\x98\x63\xff\xde\x69\x86\xa8\x61\xf0\x2f\x20\x1d\xad\xec\xbf\x61\xd4\xcf\x0e\x47\xb4\xfe\x83\x48\xfd\x27\x91\x3c\x2f\x36\x67\x98\xf3\xcc\xc5\xe6\x0a\x73\x95\x79\xb7\xf9\xb6\x33\xce\x99\xec\x7c\xdd\xf9\x8d\xf3\x54\xf2\x9b\x8d\x6e\x6f\x74\x67\xa3\xdf\x3d\x75\x3d\xc9\x9e\x5c\x4f\x7f\xcf\x70\x4f\x89\x67\xa4\x67\xb4\x67\x91\x67\x9b\x67\x97\xe7\x7d\xcf\x27\x9e\x1f\x3c\xa7\x3c\x01\x6f\x94\xb7\xb1\xb7\xa9\x37\xdd\xdb\xde\xdb\xd9\xdb\xd5\xdb\xdd\x9b\xe3\x1d\xe3\x9d\xe1\x9d\xe7\x5d\xe0\x5d\xe2\x5d\xef\x7d\xd2\x7b\xd2\xe7\xf4\xc5\xf9\xea\xfb\x1a\xfb\x9a\xfa\xda\xf8\x06\xf8\x86\xfa\xc6\xf8\x96\xf9\x6e\xf2\x3d\xd8\xd8\x68\xec\x6a\x1c\xd5\x38\xb6\x71\xdd\xc6\x89\x8d\x3d\x8d\x5b\x34\x6e\xd9\x38\xbf\x71\x59\xe3\x09\x29\x46\x4a\x74\x8a\x2f\x55\x52\x8d\xd4\xc8\xd4\xe8\xd4\xf8\xd4\x84\xd4\x86\xa9\x4d\x52\x5b\xa5\xb6\x4f\xed\x9a\x3a\x35\x75\x69\xea\xb2\xd4\xe5\xa9\xab\x52\x6f\x4c\xbd\x3b\x75\x73\xea\x13\xa9\x3b\x52\x9f\x4b\xdd\x95\xfa\x56\xea\x3b\xa9\x07\x53\x8f\x35\xed\xda\xd4\xdf\xb4\x67\xd3\xd2\xa6\xe3\x9b\x4e\x6c\x7a\x71\xd3\x19\xad\xa6\xb5\xba\xa4\x4d\xfd\x07\x7c\x0f\xac\x3a\xe9\x3c\x6d\x9c\xee\x78\xba\xeb\xe9\xee\xa7\x7b\x9c\xce\x39\x3d\x30\x90\x62\x9d\xb1\x2c\xfb\x6f\x2f\x37\x99\x73\xcd\xcb\xcc\x65\x20\x70\xbd\x79\x8f\xb9\xcf\x99\xe8\x5c\xe7\xdc\xe7\x3c\x99\x2c\xc9\x01\x10\xd8\xe4\x11\x4f\x82\xc7\xeb\xc9\xf7\x14\x86\x10\x18\xeb\x59\xea\x79\xca\xf3\x9a\xe7\x43\xcf\xa7\x9e\x9f\x3c\xbf\x78\xc5\x1b\x0b\x02\x17\x79\xdb\x79\xb3\xce\x21\x30\xc5\x3b\xd7\x7b\x09\x08\xac\xf5\x6e\x0a\x21\x50\x2f\x84\x40\x7f\xdf\x10\xdf\x48\x10\x58\x7b\x0e\x81\x18\x10\x68\xd0\xb8\x51\x08\x81\xd2\xc6\xe5\x36\x02\xde\x7f\x40\xa0\xf0\x1c\x02\x6b\x53\x37\xa5\x3e\x7c\x0e\x81\x37\x41\xe0\x00\x08\x74\x3e\x87\xc0\x84\xa6\x53\x40\xa0\xb4\xd5\x2c\x10\xa8\xff\xc0\xf2\x93\x8e\xd3\xea\x74\xf2\xe9\x4e\x20\xe0\x3f\xdd\xeb\x74\x5e\xc0\xab\x11\xb0\x8e\x5a\x2f\x5b\x2f\x58\x3b\xac\x27\xad\x6d\xd6\x56\xeb\x09\x6b\x8b\xf5\x88\xd5\xc9\x4a\xb7\x5a\x1e\xf7\x56\x9d\xa8\xfa\xb6\xea\x9b\xaa\x2f\xab\x8e\x54\x1d\xae\xfa\xac\xea\x50\xd5\x27\x55\x1f\x57\x1d\xac\x3a\x50\xf5\x61\xd5\xfe\xaa\x0f\xaa\xde\xab\x7a\xb7\xea\x9d\xaa\xb7\xab\xf6\x56\xed\xa9\x7a\xa3\xea\xd5\xaa\x5d\x55\x3b\xab\x5e\xac\x7a\xa1\xea\x99\xaa\x4d\x55\x37\x55\xad\xab\x5a\x5b\xb5\xa2\xea\xb2\xaa\x19\x55\x1d\xaa\x7c\x55\xf1\x55\xb1\x55\x61\x55\xce\x63\x81\x63\x87\x8f\x1d\x3a\xf6\xe1\xb1\x2d\xc7\xee\x3f\xb6\xfe\x58\x97\x63\x9d\x8e\xa5\x1f\x4b\x3b\xd6\xfa\xd8\x45\xc7\x9a\x1d\x6b\x74\x2c\xf9\x98\xfa\xea\x9b\xaf\x8e\x7f\xd5\xef\xab\xec\xaf\xd2\x8f\x0e\x3e\x3a\xe8\x68\xfe\xd1\xdc\xa3\x3d\x8f\x66\x1f\xed\x7a\xb4\xc3\xd1\x36\x47\x9b\x1d\xf5\x1e\xad\x7d\xe4\x8f\x23\xbf\x1e\x39\x75\xe4\xc7\x23\xdf\x1f\x39\x72\xe4\xe3\x23\xfb\x8f\xbc\x7d\x64\xef\x91\xd7\x8e\xbc\x74\xe4\xc5\x23\x4f\x1f\x79\xe4\x48\xf1\x91\xa2\x23\x43\x8f\x64\x1e\xe9\x70\xa4\xfd\x91\xb6\x47\xda\x1c\xea\x7e\xa8\xcb\xc7\x1b\xcb\xee\x28\xcb\x4c\xd8\x59\xfb\xd5\xda\x8f\xd4\x7e\xb8\xf6\x43\xb5\x1f\xac\xfd\x40\xed\xfb\x23\x3e\x0c\x0b\x84\xfe\x3e\xf8\xff\xcb\x1f\x97\x11\xa1\x0b\x25\x7f\xc3\x42\xd9\x17\x28\xfd\x31\xfe\x8b\x8c\xe0\x48\x93\x4b\x97\x53\x5c\xac\x2b\x61\x12\x2e\x11\x52\x4b\x22\xa5\xb6\xd4\x91\x28\x89\x96\x18\x89\x95\x38\x89\x97\xba\x52\x4f\xea\x4b\x82\x34\x90\x44\x49\x62\x35\x4a\x96\x46\xe2\x61\x0e\xfa\xa4\xb1\xa4\x48\x13\x49\x95\xa6\xd2\x4c\x9a\x4b\x0b\xb9\x88\xb5\xb2\x95\xb4\x96\x36\x9c\x31\xd2\xa5\x2d\x27\xca\x0c\x69\x2f\x1d\xa4\xa3\x64\x4a\x27\xc9\x92\xce\xd2\x45\xba\x4a\x37\xe9\x2e\xd9\xe2\x97\x1e\xd2\x53\x7a\x49\x8e\xe4\x72\x6b\xe9\x2d\xf9\xd2\x47\xfa\xb2\x0e\xf6\x93\xfe\x32\x40\x06\x4a\xa1\x0c\x92\xc1\x32\x44\x86\x4a\x91\x0c\x93\xe1\x52\x2c\x25\x32\x42\x46\xca\x28\x19\xcd\x49\x66\xac\x94\xea\x3b\x9c\x5c\x23\xd7\xca\x75\xb2\x52\x6e\x94\x0d\xdc\xc9\xee\x91\x7f\xc9\xbd\x72\xbf\xdc\x27\x0f\xc8\x43\xdc\x20\x1f\x96\xcd\xf2\xa8\x3c\x2e\x8f\x49\xa5\x6c\x91\xad\x9c\xc0\xb6\x71\x6a\xdb\x2e\x4f\xcb\x73\xf2\xac\x3c\x2f\x2f\xb8\xbf\x95\xd9\x52\x2e\x13\x64\xb2\xfb\x84\x2c\x90\xbb\x65\xa6\x5c\x1c\x76\x91\xcc\x97\x29\x61\x7d\x65\xb9\xdc\x16\x96\xcb\xe9\xbc\x5f\x58\x7f\x99\x24\x97\x84\x75\x0b\xf3\x87\x65\x9b\xb3\xc3\xf2\x65\xaa\x5c\x6e\x8e\x64\x1f\xd9\x21\x57\xc8\x78\x99\x1e\x96\xa3\x86\x86\xf5\x09\xeb\x2e\xd3\x64\x91\xfb\x7b\x19\x27\x57\xca\xd5\x72\x8b\x8a\x57\x75\xdd\x9f\xb9\x3f\x77\x57\xb9\x8f\xbb\x8f\xba\xbf\xe4\x1c\xb9\x52\x5e\x52\x9d\xdd\x67\xc3\x92\xdc\xbf\xbb\xff\x08\x7b\x2d\xec\x75\xf7\x77\x72\xa9\xfb\x2b\xf7\xd7\xee\x9f\x65\x99\xac\x92\xab\x64\xb5\xac\x90\x35\xb2\x56\xd6\xc9\xf5\x72\x93\xb0\x2b\xc9\x7a\xd9\x28\x77\xc8\xed\xf2\x6f\x63\xb9\x71\xa7\xcc\x32\x6e\x33\x6e\x37\x36\xca\x65\xc6\x5d\xc6\x1d\xc6\x75\x22\xfe\xde\x23\x47\x94\x14\x17\x0d\x1d\x32\x78\x50\xe1\xc0\x01\xfd\xfb\x15\xf4\xed\x93\xdf\x3b\x2f\x37\xa7\x57\xcf\x1e\xfe\xec\xee\xdd\xba\x76\xe9\x9c\xd5\x29\xb3\x63\x87\xb6\xe9\x69\x6d\x5a\xb7\x6a\xde\xac\x69\x6a\x93\x94\xc6\x3e\x4f\x42\x7c\x4c\x74\x54\x9d\xda\xb5\x22\xc2\xc3\xdc\x2e\xa7\xc3\x34\x94\xb4\xf2\x56\xaa\xd2\xdc\x4a\x33\xd5\x1b\x93\x57\x96\x92\x9b\x52\x96\xdf\xba\x95\x37\x37\xa1\x22\xa7\x75\xab\xdc\x94\xbc\xd2\x4a\x6f\x99\xb7\x92\xc2\xd1\x34\x25\x3f\xdf\x6e\x4a\x29\xab\xf4\x96\x7a\x2b\x9b\x52\x94\xd5\x68\x2e\xad\xf4\xc3\x39\xf1\x3c\x4e\x7f\x90\xd3\x7f\x8e\x53\x45\x7b\xbb\x4a\x57\xad\x22\xc5\x5b\xb9\x37\x27\xc5\xbb\x5d\x8d\x18\x54\x4c\x7d\x75\x4e\x4a\x89\xb7\xf2\x84\x5d\xef\x6f\xd7\x1d\x4d\xed\x87\xda\x3c\xf8\x7c\x8c\xb0\xad\xd2\xd6\x7a\x73\x2b\xf3\xe6\x57\xac\xc8\x2d\xc5\x46\xb5\xa5\x56\x44\xaf\x94\x5e\x13\x22\x5a\xb7\x92\x2d\x11\xb5\xa8\xd6\xa2\x56\xd9\x3c\x65\xe6\x16\xd5\xbc\xbb\xb2\x2b\x46\xf3\xdc\xce\x5b\x0c\x09\xab\xad\xd5\xe2\x69\x6e\x59\x79\x65\xe1\xa0\xe2\xdc\x9c\x24\x9f\xaf\xa4\x75\xab\x3e\x95\x75\x52\x72\xec\x2e\xe9\x65\x8b\xac\x74\xf5\xaa\x74\xdb\x22\xbd\x93\xb5\xe9\xb2\xd2\xbb\xa5\xd5\xce\x15\xab\xb6\x47\xcb\xb8\xd2\x96\x91\xe5\x29\xe5\x65\xa3\x8a\x2b\xcd\x32\xc6\xae\x30\x73\x57\xac\xb8\xb6\x32\xa6\x65\x65\x8b\x94\x9c\xca\x16\x97\x7d\x99\x80\xe7\x13\x2a\x5b\xa5\xe4\xe4\x56\xb6\xd4\x52\x0b\x06\x9f\xd3\x53\xf0\xa7\x4a\x55\xe9\x4c\x65\xdb\x58\xf1\xb3\xe0\x4e\xca\x89\xef\xfe\xda\x52\x16\x6a\x71\xa5\x46\xff\x2c\xba\x5a\x69\xf4\xaa\x54\x83\x8b\x7d\xfa\x93\x94\x07\xd6\x2b\x56\xe4\xa5\x78\xf3\x56\x94\xae\x28\xdb\x6e\x2d\x1d\x97\xe2\x8d\x4e\x59\xb1\x25\x32\x72\xc5\xcc\x5c\xe0\x96\xc2\x62\x44\x6c\xb7\x76\xac\x4c\xaa\xcc\x5b\x55\x52\x19\x5d\x5a\xa1\x3a\x97\x84\x5c\xcf\x1b\x5c\x50\x19\x37\x68\x64\x71\xa5\x91\x9a\xe7\xad\x28\xa3\x85\xff\x65\xa7\xf8\x3a\x25\xf9\x62\xce\xf1\x14\xfe\x53\xb7\x00\x0b\xe0\x80\xb0\xcf\xa7\x61\x58\xb9\xdd\x2f\xe3\x78\xa8\x5c\x3a\xa8\x38\xf8\xec\x95\x71\x49\x4f\x88\x3f\xad\x65\x49\xa5\x51\xaa\x7b\x76\x56\xf7\xd4\x2d\xd2\x3d\x4b\xab\x7b\xce\x0d\x2f\x4d\x21\xb6\x05\x43\x8a\x57\x54\x3a\x52\xfb\x94\xa7\xe4\x82\xf8\xca\xb2\xca\xa5\xe3\xc8\xae\x29\x3a\x30\x29\xd1\x95\x75\x7e\x49\xf2\xa5\xac\x88\x8d\xf1\x66\xa5\x95\xd8\xbc\x5e\xac\xea\x53\x3e\xd9\x5b\xe9\x6c\x0a\x48\x8c\xaa\x39\x80\xbc\xd1\x43\x56\x44\xdb\x0f\x75\x7e\x09\x16\x27\x92\x50\xd0\x34\x26\xd6\x9b\x95\x82\x18\x2d\x27\x37\x25\xb7\x34\xf4\xbf\xf9\x15\x09\x08\xf0\x02\x74\x7e\xcb\x60\x22\x0c\x2d\xae\xf4\xe7\x50\xf1\x97\x85\x22\x96\xbb\x25\x3d\x8d\x11\x65\xa5\x04\x6c\x72\x8e\x1d\xcc\xca\xb4\x94\x99\x95\xf1\x29\x3d\xcf\x45\x57\x9b\x95\x3b\x79\x48\xb1\x3d\x24\x34\xac\x32\xbe\x57\xa5\x94\x8e\x0f\x8d\xaa\x4c\xcb\xb5\xe7\x95\x37\x77\x45\x69\x4e\xd0\x04\x2d\x2b\x65\x50\xf1\x33\x92\x61\x1d\xde\xd2\xde\x9b\xb4\x55\x2f\x9d\x25\x39\x9a\xb9\x5e\x2f\xb2\xac\x69\xee\x8a\xe2\xf2\x89\x95\x9e\xd2\xa4\x72\xe6\xdd\x44\x6f\x71\x92\xaf\xd2\x5f\x42\x84\x4b\x52\x8a\x27\x94\xe8\xb4\x03\xa1\x16\x87\x93\xec\xe4\x28\xb1\x73\x65\x68\x71\xc1\x90\x94\x82\x41\x23\x8a\x3b\x85\x0c\x09\x76\x68\x71\x8e\xd4\xdc\xf3\xc4\xa4\x14\x27\x05\xc5\x90\x80\x95\x61\xa9\x61\xde\x62\x23\xc9\x2c\x81\x31\x9a\x06\x6f\x1e\x95\x94\x9e\x5d\xf9\xae\x74\xa7\x86\x41\xd1\x00\x6e\xb7\xea\xc4\xed\xd9\xd5\x5b\xac\x92\xa4\x9a\x1b\x33\x2a\x5b\x78\x73\x27\xe4\x84\xf8\xf4\xf3\x5f\x84\x3a\x75\x3a\xf5\xca\xaf\x96\xe6\xd2\x8f\xc8\xe9\x95\x9f\xe4\x2b\xf1\x05\x3f\xad\x5b\x19\x74\x7b\x43\x8a\x19\x11\xa6\x41\xcd\xaf\xee\x62\x99\xa2\x23\x8c\xfc\xec\x95\x6f\x37\x69\x2c\x13\x74\xd2\x7b\x8b\x53\x26\xa4\x94\xa4\x54\x78\x2b\xfd\x85\xc5\xda\x37\x0d\x8f\x8d\x72\x08\x0c\x1b\xf3\x50\xac\x86\xfe\xe5\xa9\x06\x58\xc0\x24\x3e\xba\xab\x1f\x34\x98\x95\x79\x2d\x93\x6a\x82\x5b\xd9\xdb\x7e\x3e\xf7\x98\x7f\x5e\x77\x9f\xea\x6e\xef\x8a\xb0\x94\x82\x21\x2b\xb4\xf0\x94\x90\x40\xc1\xf2\x3e\x95\xa2\x53\xd8\xdf\x29\x26\xc9\x5e\x0b\xf4\x84\x4e\x61\xed\xf5\x46\x33\xa5\xed\x09\xbd\x62\x8b\xdf\xaf\x27\x73\x45\x67\x2d\x24\xa5\x4f\xf9\x8a\x94\x21\xc5\x5d\x6d\x6e\xd6\x93\x45\x49\x97\x69\x5d\xb1\x52\xa0\x0a\x86\xf6\x6c\xdd\x8a\xa5\xad\xe7\x96\x14\xb5\x7c\xd0\x16\xbf\x5a\x3e\x64\x44\xf1\x33\x5c\x1a\xbc\xcb\x87\x16\x3f\x61\x28\xa3\x57\x69\xcf\x92\x2d\x4d\xe8\x2b\x7e\xc6\xcb\xa6\x61\xb7\x1a\xba\x55\x37\xea\x07\xaf\x7e\xd0\x92\x06\xf3\x10\x66\xf3\x27\x3d\xe3\x17\x59\x6a\xf7\x3a\xec\x06\xfb\x79\xfc\x76\x25\x76\x5b\x58\x75\x9b\x92\xf1\xdb\x8d\x60\x5b\x74\x50\x51\x53\x5b\x91\x9f\x33\xc8\xf8\xed\x8e\x60\x8f\xbf\x9a\xdb\x41\x5b\x58\xb0\x6d\xa9\xdd\x66\x7f\xb6\x88\x86\xcc\x1f\xe1\xf4\x87\xf9\xc3\xfd\x91\x46\x6d\x23\x69\x8b\xd2\x4d\x4f\xd0\xb2\x83\xb3\x4a\xb8\x92\xad\x91\xaa\xb6\x4a\xda\xc2\xa8\xc1\x76\xf3\x76\xb5\x74\x4b\xb8\x3f\x29\xc8\xb1\x14\x0e\x7f\xd0\xc2\xe5\x45\x7f\xaa\x2e\x1a\x51\xbc\x95\x13\x8d\x4a\xb2\xbf\x51\xd4\x53\x7f\x48\x97\x84\x0a\x82\xcd\xb6\x92\xeb\x2d\xd7\x89\x72\x79\x49\xc5\x8a\xd2\x12\x3d\xd9\xa4\x1e\xa1\xe1\x7f\xaa\x52\xa5\x74\x27\x4c\x29\xdd\x31\xc4\x15\x59\x19\x91\x32\xa1\x67\x65\xad\x94\x9e\xba\x3d\x5b\xb7\x67\x07\xdb\x5d\xba\xdd\x4d\x8a\xaa\x7a\x8a\xe1\x4b\x89\x7d\x61\xa5\xd2\x19\x30\xb2\xd8\xc7\x94\xf4\x26\xee\x4e\x5a\x11\x7d\x42\x47\xaa\x84\x45\x65\x45\xf4\x57\xad\x7b\x8c\x12\x8f\x9a\x20\x4b\xa0\xc7\x21\x53\x55\xa8\x49\x9c\xad\x3c\xaa\x54\x06\xa8\xb1\x52\xa4\x7a\x48\x37\xe5\xa7\x04\x5b\xd5\x93\xb2\x17\xcf\xba\x6c\x23\x4b\x55\x37\xca\x6e\xb4\x77\xa7\xe4\x2c\xa5\xba\x70\x3e\x8a\xe2\x3b\x0d\xca\x86\x96\x40\x0e\x28\xc8\x91\x0e\x47\x1a\x65\x5a\xe8\xb9\x35\xcf\xad\x18\xe1\xe1\x7b\x20\xf4\x22\x64\x42\xc1\xde\x6c\x7a\x75\xd9\x97\xe7\x7c\xb8\x44\xf5\x96\x68\xc8\x0b\x99\xd6\x4e\xd5\xfb\x89\x98\x7a\x79\x3d\xe2\x55\x1e\x7c\xb9\xf0\xe5\x06\xf9\x54\x1f\x9e\x35\x7f\xa1\x72\x93\x0d\x69\xf6\xf7\xe3\xca\xe1\xcf\x53\xfb\xce\xaa\x17\xcf\xaa\xe8\xb3\x6a\xc6\x69\xe5\x3f\xad\x7e\x4a\x7c\xc3\xf3\xeb\xd8\x0c\xcf\x2f\x63\x2d\xcf\xcf\x03\x2c\xcf\x8f\x27\x33\x3c\xd9\x27\x07\x9e\x34\xaa\x8e\x65\x78\xa2\x8e\x29\x39\x16\x7d\xcc\xf8\xea\x4b\xcb\xf3\xe5\x23\x19\x9e\x2f\x0e\xb7\xf3\xdc\x75\xf8\xf1\xc3\xc6\x0e\x15\x81\x82\x70\x7f\x44\xd1\xe7\xdd\x3e\x2d\xfa\xac\xdb\xa1\x22\x79\x4e\x85\xa3\x23\x1c\x9b\xc2\x9f\xa8\x15\x9d\xb7\x9d\xde\x34\x65\x16\xc9\xa7\x60\xf2\x69\xfa\xa7\x85\x9f\x2e\xfd\xb4\xf2\x53\x67\xd8\xa7\xb4\x1d\x32\xbb\x7a\x3e\xfa\xd0\xe3\xd9\x8f\xce\x0f\x3e\xb0\x3c\xaf\xee\xb2\x3c\xef\xee\xcb\xf0\x6c\xb7\x76\xfa\xe7\xed\x0b\x8f\xcc\x8b\x7a\x59\xf9\x77\x2a\xff\x4b\x85\x2f\x95\xbe\x64\x3e\xd7\xdb\xf2\xbc\xd0\xbb\xa5\xe7\xf1\xe7\x5f\x7c\xde\x78\xf1\xf9\x77\x9e\x37\xc6\x3e\x3f\xe3\xf9\x25\xcf\x3f\xfe\xbc\xc3\xff\x3c\xcc\x3b\x90\xf2\xcc\xa3\x96\x27\xea\xe9\xec\xa7\x8d\xa7\x70\x61\xc9\x93\x8f\x3f\x69\xa4\x6d\xcd\xde\xfa\xe2\x56\x33\x8a\x62\xec\xd6\x1f\xb6\x3a\xd6\x56\xaa\x4d\x24\x41\xe5\xce\x4a\xe3\xf1\x47\x3d\x9e\xc7\x1e\x6d\xef\x59\xbb\x59\x6d\xda\xac\x2a\x37\xef\xdc\x6c\x6c\x57\x75\x9e\x30\x13\x3c\xdb\x55\x6d\xbf\x27\xc9\xf2\x6c\x7a\xa8\xf2\x21\xe3\xa1\xdb\x33\x3c\x77\x20\x7b\x23\x94\x7e\xbb\xff\x76\x63\xdf\xed\x2a\xea\x76\xb5\x5d\x25\x3e\x71\x73\x43\x58\xe3\xfc\xde\x5b\x33\x3c\x77\x61\x5d\xf6\xad\x4a\x36\x44\x6f\xf0\x6e\x30\x4b\x37\xa8\x5b\xe8\x4c\xbf\xd9\x7f\xb3\xb1\xef\x66\x78\x23\xb7\x22\xae\xb4\x47\x2d\x55\x17\x70\x96\xaa\x78\xbe\xfd\x7c\x17\x42\x87\x55\xbc\xbf\x85\xb9\xfe\x46\x8f\x67\xe6\x0d\x4b\x6f\x58\x7b\x83\xb9\x6e\x4d\x86\x67\xed\xaa\x0c\xcf\xf5\x57\x5b\x9e\xd5\xcb\x2c\x4f\xda\x2a\x35\x76\x95\x8a\x5a\xe5\x59\xb5\x64\x95\xb9\x5d\xd5\xf2\x47\xac\xcc\xf0\xa4\xaf\xf0\xaf\x28\x5c\x61\x6a\xa8\x22\xaf\x4b\x6c\x94\xb7\xfc\xca\x0c\xcf\x35\x57\x5a\x36\x76\x7d\x96\x01\xc7\x25\x03\xba\x7a\x64\x7e\xf4\xfc\x4d\xf3\xcd\x91\xf3\xd5\xbc\xb1\x5e\xcf\xdc\x52\xcb\x33\x07\x27\x66\xcc\x5e\x32\xdb\xb8\x6b\xf6\xe3\xb3\x8d\x59\xbd\x1b\x79\x66\x4c\x6f\xef\x99\xde\xbb\x9d\x47\x12\xa3\x13\x8d\x44\x95\x50\xd4\x20\x23\xa1\xc8\x9d\x61\x16\xb9\x4c\xf0\x24\x8c\x49\x4f\xc4\x37\x24\x8c\xf5\x9f\x18\xd7\x1e\x6f\xeb\x6d\x1d\xdb\xde\x23\x3d\x22\x54\x34\xf9\x17\x4d\xfe\x45\xcb\x26\xc8\x01\x63\xb4\xff\xce\xa8\xb8\xbc\x32\xfa\x4b\xa1\xb1\x03\x3d\x9e\xa8\x31\x9e\x31\x69\x63\xee\x1a\xf3\xf8\x18\xe7\xc8\x11\x2d\x3d\xa5\x23\xf6\x8d\x30\xa2\x46\x78\x46\x18\xf1\x2a\xb6\x28\x2e\x23\xb6\xc8\x49\x16\x38\xd0\x15\x65\xa6\x99\xd9\xe6\x58\x73\x89\xf9\xb8\xe9\x92\x21\xd1\x43\x96\x0e\x31\x97\x0e\x52\x33\x06\x2c\x19\xb0\x66\x80\xb9\xb4\xaf\xea\xdb\x3b\xc2\xd3\xa7\x77\x86\x67\x60\xfe\xd8\x7c\x23\xaa\xb7\xa7\xb7\xfd\x95\xd6\xfb\xae\xde\x8f\xf7\x76\x26\xab\xa4\xa2\x86\xf9\x49\x45\xf5\x32\xea\x16\xad\x89\x51\x85\x31\x2a\x2a\x46\x2d\x8d\x51\x94\x45\xd1\x19\x51\x45\x9c\xa1\x8b\x54\x86\x14\x6d\x57\x09\xfe\x06\x49\x19\x9e\xb4\x28\x2b\xca\x88\x8a\x1a\x1b\xb5\x24\xca\x8c\xe2\xc2\x63\x2c\xad\xa7\x9c\x04\x69\xed\x96\xa1\x43\x5a\xb6\x2c\xd8\xee\xb6\x38\x83\xb9\x0b\x47\x56\xaa\xe5\x95\xa9\x43\xf4\xb7\x7f\xd0\x88\x4a\xd7\xf2\x4a\x29\x1a\x31\xb2\x78\x8b\x52\xd7\x97\x5c\xbd\x7a\xb5\xf4\x4c\x2e\xa8\x6c\x37\xa4\xb8\xb2\x34\xb9\xa4\xa0\xb2\x9c\x8a\x5f\x57\x96\x52\x89\x4e\xde\x52\x4f\x7a\x96\xcc\x99\x33\xb7\xa5\xfe\xcc\x99\x3b\x57\x57\xd4\x9c\xb9\x73\x78\x90\xb9\xf3\xe6\xcc\x69\x19\x7c\xe6\x49\xd7\x82\x6c\xf4\x29\x9b\x5b\xec\xef\x96\x2a\xd8\x25\x73\xe6\xce\xb3\x3b\x5b\xea\xf1\xf6\x20\x2d\x87\x76\x5b\xfc\x3c\x5b\xd0\x3c\xd1\x43\xe6\xcd\x99\xab\x90\x38\xc7\x1e\x3f\x4f\x69\x1e\x9e\x79\xd4\x55\x2d\x63\xcc\x9c\x31\x73\xf4\xb7\xad\x5d\x37\x21\x3a\x58\x61\x84\xfe\x28\x28\xf8\x14\xa2\xe0\x97\x5d\x49\x10\x71\xae\xe6\xce\x39\xc8\xd9\x8d\x5b\xe8\x0c\x67\x37\x67\xbf\xbf\x5e\x5c\xcd\xcd\xdc\x44\xb7\x89\x58\xdf\xe9\xa7\xea\xef\xc0\xd1\x40\x3f\xeb\x8f\xff\xdb\x0b\xf5\x85\x3e\xd5\x6f\xfd\x59\x7c\x3e\x96\x3f\x88\x6c\xf0\x33\x82\xfb\xe2\xe5\xdc\xca\xae\x39\xd7\x12\xe4\x6a\xa1\x32\xe9\x5b\xc4\x56\x55\x2e\xd3\x65\xb5\x72\x5c\x58\xaa\xaa\x2d\x67\xe0\xfb\x89\xdb\xaa\xe6\x5b\x24\x7b\xf5\x3a\x7b\x81\xcf\x30\x15\x8e\x86\x93\xdc\x87\xf7\x73\xc7\xbc\x54\x66\xc9\xab\xaa\xad\xdd\x72\x2f\xeb\xef\xa3\xb2\x93\x96\x22\xf5\x9c\xea\xa7\x46\x20\xe3\x7b\x19\xaa\xfa\xc9\x44\x99\x21\xab\x54\x9d\xf3\x45\x19\x53\x58\xf7\xd7\xb0\xb9\x47\xf2\xbd\x50\x2a\x28\x75\xeb\x0f\xf2\x92\x71\x87\x8c\x31\x8e\xf2\xf0\x18\x77\xea\x29\x2a\xc2\xc8\x42\xd2\x14\xf5\x2f\xf9\x4e\x15\x60\xe5\x0b\x1a\x67\x3e\x43\xed\xf7\x93\xe7\x3e\x56\xb4\xa5\xe4\x65\x30\x71\x71\x5f\x5e\xcb\x8d\x3b\xf4\x71\xfa\xcf\x7c\x2c\x2e\xeb\x27\xd9\x14\x1a\xd7\x87\x1b\xfc\x42\xb9\x3e\xd4\x5d\x2e\xdf\xa8\x65\x76\xed\x1b\x39\xa3\xff\xf5\x83\xf6\x52\x2a\x40\x93\x8f\x3b\xdf\x9c\x62\x3c\x65\x18\x67\x6f\xe4\x61\x1d\xf7\xed\x75\x52\xa6\x0e\x62\xe5\x6a\xb3\x87\x7a\xfb\xec\xbb\xd6\x8f\xb2\x23\x30\x28\x30\xc9\x39\x9d\xfe\xf7\xb8\x9b\x7f\xa0\x0c\xb5\x5e\x0e\x70\x6b\x3f\x1e\x58\xc5\x54\xef\x08\xa2\x5f\x5f\x18\xf3\xea\x0f\xfb\x43\x6d\xeb\x17\x33\x55\xc2\x2f\xd4\x6b\xb4\x97\xa8\xc0\x1f\x46\x3b\xeb\x94\xd9\x44\x22\xa4\x48\xff\x5b\x92\x60\x9b\x55\x60\xfd\xdb\x2c\xe3\x7e\xfe\x3f\x7c\x5c\xeb\x1c\xd3\x18\x2d\xd6\x57\x81\x85\x81\x72\x67\x9a\x33\x52\x25\xa9\x66\x44\xfd\x1b\xf9\xe4\xc2\x23\x0c\xa2\x61\xcc\x15\x71\x90\xe7\x4e\xb0\x0c\xe3\x39\x3c\x07\x42\x5f\xf8\x6f\x22\x11\xe5\xd0\x3e\x91\x5a\xf9\xd0\x66\xe8\xb0\x48\x64\x13\x68\x14\x44\xbd\x36\xe3\x6a\x53\xd6\xd9\x25\x12\x05\x6f\x74\x3a\x74\x4a\x24\x86\x7a\x6c\x57\xd1\x7f\xf2\x27\x71\x60\x1c\x8f\xdc\xf8\xb5\x22\x75\xe3\xa1\x0d\x22\xf5\x16\x88\x24\x70\x44\x4c\xd8\x2e\xd2\x00\xbd\x89\xc8\x49\x3c\x2e\x92\xf4\x86\x48\x43\x9e\x93\xe9\x6f\x84\x8e\x46\x87\x44\x3c\xa5\x1c\x25\x9b\x43\xcf\x89\xf8\xb0\xab\x71\x7b\x08\x7d\x29\x33\x45\x9a\x74\x12\x49\x65\xb2\xa4\x62\x6b\x53\xe2\xdb\x0c\xbe\x16\xad\x20\xe4\x5c\xb4\x5c\xa4\x15\xf6\xb4\x22\x1f\x5a\xc3\xd3\xda\x0f\xad\x87\xbe\x14\x69\x83\x1d\x6d\x90\x9b\x46\x99\x76\x40\x24\x1d\x59\x6d\xb1\xa1\x1d\xf6\xb6\x7b\x4b\x24\x03\x5d\xed\x19\xdf\x81\x15\xa1\x03\xfe\x77\x44\x76\x47\xfc\xcc\x1a\x2a\xd2\x19\x5f\x3a\x63\x63\x17\xfc\xea\x0a\x56\x5d\x19\xdf\x0d\x7d\xdd\xf1\x39\x9b\xbe\x6c\xfc\xf3\xd3\xde\x83\xb1\x3d\xd0\xd5\x13\x7c\x7b\x21\x3b\x07\xdc\x72\xb0\x33\x0f\x5d\x79\x4b\x45\xf2\xbd\x24\x29\xa4\xff\x7c\xa9\x00\x79\xfd\xb0\xb3\x7f\xa5\xc8\x00\x78\x06\xe2\xff\x20\x74\x0d\xa2\x3e\x18\xdc\x06\x7f\x00\x21\xab\x08\x19\x45\x8c\x2f\x02\xe3\x61\xd8\x37\x1c\xbd\x25\xe4\xca\x08\xb0\x1e\x49\x3c\x47\x4e\x85\xb0\x0b\xe8\x64\x14\xfe\x8d\xc2\xb6\xd1\xf0\x8f\x05\xdb\x52\x6c\x1a\xc7\xf3\xf8\x9d\x7a\x3a\x40\x3c\x97\x83\x67\x39\xb2\xcb\xd1\x33\x01\xec\x26\x62\xfb\x44\xfc\x9d\x44\xff\x24\xb0\x9b\x84\x8c\x49\x60\x36\x09\xbc\x27\xa1\xb3\x02\xfd\x15\xc5\x22\x93\x29\x27\x63\xdf\x64\x70\x99\x8c\xdd\x93\xb1\x6d\x0a\x58\x4e\xc1\xcf\x29\xc4\xec\x62\x74\x5c\x8c\x5d\x53\xf1\x6f\x6a\x21\x04\xdf\x54\xf8\xa6\xe1\xd7\x74\xf0\x98\x8e\xbf\xd3\xd1\x3b\x03\xdf\x67\x10\xcf\x19\xd8\x3d\x63\x93\xc8\x4c\xf4\xcc\x44\xcf\x2c\xc6\xcd\x62\xdc\x2c\x70\x9a\x05\x26\xb3\xc0\x7e\x36\xd8\xce\x26\xde\xb3\x2b\x44\xe6\xe0\xe0\x1c\xec\x9a\x83\x9e\x39\xe8\x99\x0b\xff\x5c\xf8\xe7\xa2\x67\x1e\xf1\x9f\x8f\xfd\xf3\xb1\x7f\x3e\xf6\xcf\x07\xbf\xf9\xc8\x9d\x8f\xdc\x4b\x91\x71\x29\x58\x5d\x8a\x1d\x97\x62\xc3\xa5\xe0\x72\x59\x43\x88\xfc\xbe\x8c\xb1\x97\x61\xe3\x65\xf8\xb2\x10\x5f\x16\x82\xcf\x42\x6c\x5d\x08\xdf\x42\x6c\xbd\x1c\x5b\x2f\xc7\xd6\xcb\x91\x79\x39\x98\x2e\x02\xbb\x45\xe4\xc9\x22\x76\x81\xc5\xc8\x58\x8c\xef\x8b\xc1\x7e\x31\xf3\x64\x31\xfa\x16\x9f\x11\x59\x82\x2d\x4b\xc0\x6b\x09\xb1\x5a\x42\xae\x2f\x41\xdf\x52\xf2\x62\x29\xfa\x96\x62\xc3\x52\x6c\x5b\x8a\x0f\x4b\xf1\xe1\x0a\x7c\xb8\x12\x1f\xae\x22\x4f\xaf\x42\xfe\x55\x1b\x21\x72\xf1\x2a\x62\xb3\x8c\xd8\x2c\x03\xef\x65\xc8\x5f\x86\x8d\xcb\xb0\xf1\x6a\xb0\xb8\x1a\x2c\xae\xc6\xbe\xab\xc1\xfc\x1a\xf4\x5e\x43\xec\xae\xc5\xce\x6b\x91\x79\x2d\xe3\x96\x33\x6e\x39\x76\x2d\x47\xde\x72\xe4\x2d\xc7\x8f\xe5\xd8\x75\x1d\xbe\xad\xc0\xe6\x15\x0f\x42\x60\xbb\x92\xb9\xb8\x12\x5c\x56\xe2\xef\x4a\xda\x56\x92\x27\x2b\xe1\x5b\x45\xb9\x1a\xf9\xab\x19\x77\x3d\x72\xaf\xc7\xff\xeb\xe1\xb9\x1e\x9e\xeb\xd1\xb9\x16\x5f\xd6\xd1\xb6\x8e\x84\x5a\x47\x3c\xd6\x91\x8f\xeb\xd0\x7b\x03\x7a\x6f\xc0\xde\x1b\xc0\xf4\x06\xe2\x77\x03\x3a\x6e\x04\xfb\x1b\xc1\xee\x46\xb0\xb8\x11\x2c\x6e\xc4\x87\x1b\xd1\xb1\x1e\x3b\xd6\xe3\xf7\x7a\x78\x6f\xc2\xd6\x9b\x79\xbe\x59\x97\xf8\x7a\x33\x3e\xdd\x8c\x9e\x5b\x18\x7b\x0b\xf6\xdd\x82\x1f\xb7\x60\xcf\x2d\xd8\xb5\x81\xb6\x0d\xe4\xe1\x06\xf4\x6c\x60\xec\x06\x70\xd9\x80\xcc\x5b\xf1\xe5\x56\xfc\xbb\x15\x3b\x6f\x25\xa7\x6e\x05\x93\x5b\xd1\x73\x1b\xb1\xb8\x0d\xfd\xb7\xf1\x7c\x3b\x71\xdb\x88\x5d\x1b\xc1\xe9\x0e\x70\xb9\x13\xd9\x77\xc2\x73\x17\xb2\x37\x11\x97\xbb\xf1\xe9\x6e\x64\xdc\x8d\x2f\xff\x82\xef\x1e\xda\xef\xc5\x9e\xfb\xc0\xfc\x3e\xf2\xe8\x7e\x64\x3c\xc0\xb8\x07\xc9\xc3\x87\x88\xe5\x43\xf0\x3d\x4c\xfb\x23\x60\xf4\x08\xbc\x9b\x89\xeb\xa3\xc4\xfd\x51\xec\x79\x0c\xbb\x1e\xa7\xac\xa4\xbd\x92\x7a\x25\xb9\xb1\x05\xbb\x9e\xc0\x97\xad\xe8\xd8\x46\xae\x6d\xc3\x9f\x27\x89\xf5\x53\xe0\xf2\x34\x7c\xdb\xd1\xb5\x9d\xfc\x7a\x06\x19\x3b\xc0\x72\x07\xed\xcf\xd2\xf6\x1c\xf5\xe7\xe1\x7f\x01\x3d\x2f\xa0\xf3\x45\x64\xed\xc4\xf7\x97\x3a\x05\xff\xe4\xe8\x65\xe4\xbc\xc2\x1c\xde\x05\x26\xaf\xb2\xe6\xbd\x4a\x5e\xbd\xc6\xd8\xd7\x19\xfb\x06\x3c\xbb\xe1\xd9\xcd\xf3\x6e\xf2\xf0\x4d\xe6\xc7\x9b\xf8\xff\x26\xbe\xbc\x89\xef\x7b\xc0\x7d\x0f\x38\xec\x61\xec\x1e\xe6\xe3\x1e\xe4\xee\xc1\xc7\x3d\xd8\xbc\x07\xdb\xf6\x20\xeb\x2d\x74\xbf\x85\x9c\xb7\xb0\xeb\x2d\x64\xbe\x85\x1f\x6f\x61\xc3\x5b\xc8\xdb\x0b\xee\x7b\x91\xb9\x97\xbe\xbd\x60\xb8\x97\xbe\xbd\xc4\xfd\x6d\xec\x78\x1b\x8c\xde\xa6\xfd\x6d\xe6\xf3\xdb\xb4\xbf\xcd\x98\xb7\xb1\xff\x1d\x74\xbe\x43\xbe\xef\x23\xf7\xdf\xc5\xb7\x77\x89\xfb\xbb\xe0\xf2\x2e\xb9\xf4\x2e\x76\xbe\x8b\x6d\xef\x22\xfb\x3d\xf4\xbe\x47\x8e\xbd\x47\xee\xbc\x47\xee\xbd\x4f\xfd\x7d\xf4\xbf\x0f\xdf\xfb\xe4\xc8\xfb\xf0\xbd\x0f\xfe\xfb\xb1\x61\x3f\xf9\xf2\x21\xf3\xff\x43\x72\xe3\x43\x7c\xf8\x90\xdc\xfd\x08\xbf\x3f\x22\xa6\x1f\x31\xee\x23\xc6\x7c\x84\xec\x8f\xe0\x03\x2e\x39\x00\xdf\x01\xec\x3b\x80\xcf\x07\x88\xdb\x01\xfc\x3d\x40\xc7\x01\x30\x39\x88\x5d\x07\x89\xd1\x41\xe6\xd9\x41\xe2\x71\x90\x5c\x38\x88\xbc\x83\xd8\xfe\x31\xb6\x7f\x8c\xed\x1f\x23\xf3\x63\xec\xfa\x18\x3b\x3e\xc6\x8e\x8f\xb1\xe3\x13\x72\xf3\x13\xe4\x7e\x02\x9e\x9f\x80\xe7\x21\xea\x87\xc0\xe2\x53\xec\xf8\x14\x3f\x3f\x45\xf6\xe7\xf4\x1d\x66\xfc\x17\xf4\x7d\x41\x1c\x8e\x90\x4b\x47\xc0\xe7\x08\xf1\x3f\x42\x7e\x1e\x41\xcf\x11\xf8\x8e\xa2\xe7\x28\x7c\x47\xd1\x71\x14\x1d\x47\xd1\x71\x14\x1d\x5f\x82\xf5\x97\xc8\xfe\x92\x3c\xff\x8a\xfa\x31\x78\xaa\xc0\xa9\x0a\x9f\x8f\xe3\xc3\xd7\xe8\xfb\x06\x3b\xbf\x65\x7d\xfa\x16\x39\xdf\x61\xfb\x09\x30\xfb\x1e\xfa\x01\x2c\x7e\xc0\xc7\x93\xc4\xe9\x47\x62\xfc\x13\x39\xf3\x13\xb8\xfe\x1b\x3a\x85\x8e\x9f\xf1\xf7\x17\xe2\xfc\x2b\xba\x7f\x65\xfc\x6f\xd8\xf2\x3b\xfe\xff\x01\xef\x69\x78\xce\x80\xd3\x19\xe2\x78\x16\xfd\x81\xe6\xa1\x7f\x53\x33\x95\x2b\x5f\x29\xb7\x72\xfd\xe6\xe0\xa4\x28\x63\xa3\x28\x73\x1b\xb4\x4b\x94\x63\x93\x28\xe7\x07\xa2\x5c\xb4\xb9\x87\x8a\x0a\x2b\x87\xe6\x8a\x0a\x4f\x87\x7e\xe3\x98\xfb\x9c\xa8\x5a\x15\xa2\x22\x79\xae\xcd\xd5\xb1\xf6\x3e\xe8\x30\x84\x9c\x3a\x9b\x45\x45\xcd\x84\xbe\x13\x15\x4d\x5b\xcc\x1b\xa2\x62\xb7\x8b\x8a\xdb\x29\x8a\x33\x85\xaa\x8b\xce\x7a\x1c\x6e\xeb\x45\x8b\xaa\xef\x85\x4e\x89\x4a\x40\x66\x03\xc6\x34\x38\x2e\x2a\x11\x9e\xa4\x30\x08\x1d\x0d\xe9\x6f\xf8\xa0\x28\xce\x17\xaa\x51\xa1\x28\x0f\xb6\x7a\x0e\x88\xf2\xc2\xe3\xeb\x24\xaa\x31\xfd\x8d\xe1\x4b\x29\x16\xd5\x84\xfe\xd4\x7e\xa2\x9a\x22\xbb\xe9\x52\x51\xcd\xe8\x6f\x86\x3d\xcd\xf1\xa5\x05\xb6\x5e\xc4\xd8\x96\xf4\xb5\x8a\x84\xf0\xb3\x35\x76\xb4\x41\x4f\x9b\xf5\xa2\xd2\x18\x9f\xde\x0a\xc2\x8e\xb6\xd8\xdc\x0e\x99\x19\xb4\xb7\xef\x0a\x55\x8a\xea\x00\x0e\x1d\xb1\x21\x13\xf9\x9d\x90\x9d\x85\xdc\x2e\x60\xd2\x15\x0c\xbb\x21\xa7\x3b\x3e\x67\x1f\x12\xe5\x47\x6e\x0f\x74\xf5\xe4\xb9\x17\x63\x73\xf0\x31\x17\x1d\xb9\xb4\xe7\x5d\x2e\xaa\x77\x02\x84\xdc\x7c\xda\xf3\x69\xeb\x83\xcf\x9c\x27\x54\x5f\x74\xf4\x05\x9f\xbe\xe0\xd8\x17\xfd\x7d\x91\xcf\x31\x5a\x15\xa0\xaf\x60\x83\xa8\x7e\xe0\xdc\x0f\x1c\xfb\xe1\x7b\x3f\x30\xea\xdf\x1e\x5a\x06\x51\x1f\x80\xdf\x03\x90\x39\x80\xbe\x01\xfa\x19\x1f\x06\x36\x87\x46\x41\xb4\x0f\x64\x5c\x61\x43\x08\xbe\x42\xfc\x28\x84\x67\x10\xfd\x83\xb0\x7d\x10\x7d\x83\xd0\x35\x18\xff\x87\xc0\x3b\x14\x3c\x87\x2e\x17\x55\x04\x56\x45\xf8\x30\x0c\x4c\x86\xad\x12\x35\x1c\xfd\xc3\xb1\xbf\xb8\x09\xc4\xf8\x12\x30\x28\x01\xa3\x11\xf8\x36\x82\xfc\x18\x01\xc6\x23\xb0\x7b\x24\xfe\x8d\x44\xef\x48\x62\x36\x0a\xbf\x46\x91\x1b\xa3\x78\x1e\x75\x2f\xc4\xb8\xd1\xc8\x1b\x8d\x3f\xa3\x91\x3d\x1a\xdd\xa3\xc1\x6c\x34\xfa\xc7\x80\xd9\x18\x64\x8c\xc1\x87\xb1\xc4\x67\x6c\x0e\x84\xde\xb1\xf0\x94\x22\xb3\x14\xdb\x4b\xb1\xab\x94\xfe\x52\xe4\x94\x61\x67\x19\x6d\x65\xc8\x1d\x87\x0d\xe3\x88\xcd\x38\x64\x8d\xcf\x87\x68\x1b\x4f\x4e\x95\x63\x73\x39\x76\x96\x63\xd7\x04\x62\x35\x01\x7c\x27\x32\x6e\x22\xb8\x4d\x44\xc6\x24\xb0\x9d\x44\x7d\x12\x7e\x4c\x02\xb3\x0a\x30\xad\xc0\x8e\x0a\x6c\xab\x20\x77\x27\x83\xd9\x64\x78\x26\xa3\x77\x32\x6d\x93\xe1\x99\x82\xce\x29\xe0\x34\x05\xf9\x17\x83\xd9\xc5\xf8\x79\xf1\x19\x51\x53\xb1\x77\x2a\xb1\x9c\x8a\x0f\xd3\xf0\x79\x1a\x7d\xd3\xc0\x7a\x1a\x7a\xa6\xd3\x37\x9d\x58\x4f\xc7\xf6\xe9\xf0\xce\xc0\xae\x19\xf4\xcd\xc0\x9e\x19\x5f\x8a\x9a\x89\xbf\x33\x69\x9b\x49\x3c\x66\xd2\x3e\x93\x1c\x98\x45\xee\xcc\xc2\x7f\xce\x50\x6a\x36\xe3\x67\x63\xe7\x6c\xe6\xe5\x1c\xec\xe1\x1c\xa5\xe6\xc2\x3f\x17\x7d\x73\xf1\x75\x2e\x72\xe7\x91\x4f\xf3\x18\x33\x0f\xf9\xf3\xf1\xe7\x12\x64\x5d\xa2\x4b\x9e\x17\xe2\x17\xe7\x22\xb5\x90\xe7\xcb\x89\xd5\xe5\xd8\x72\x39\xf6\x2f\x62\x7e\x2c\xa2\xbe\x08\x9e\xc5\x8c\x5d\xcc\x1c\x5d\x02\x4e\x4b\x88\xcf\x12\xfc\x5f\x4a\xdc\x96\xa2\x77\x29\xbe\x5f\x41\x3e\x5c\x81\x6f\x57\xb0\x26\x5c\x49\xbe\x5f\x09\xa6\x9c\x7b\xd4\x55\xf8\xcf\x59\x47\x2d\x63\x3e\x5e\x4d\x6c\xaf\x26\x8f\xaf\x41\xc6\x35\xc4\xed\x5a\xe4\x5f\x8b\xad\x9c\x69\xd4\x72\xe2\xb3\x1c\xf9\xd7\xe1\xcf\x75\xf0\x5e\x47\xff\x0a\xf2\x7b\x05\x76\xaf\x00\xf3\x95\xc4\x65\x25\x98\xad\xd4\x75\x6c\x62\xe9\x52\xab\xb0\x75\x15\xb6\xac\x82\x77\x35\x39\xb0\x1a\x7d\xab\xc1\x7f\x35\xfa\x57\x83\xeb\xf5\xf0\x5f\x0f\xff\xf5\xc8\xbe\x9e\x18\xad\x41\xef\x1a\xfc\x5c\x83\xcd\x2c\x77\x6a\x2d\xb2\xd7\x22\x77\x1d\xf5\x75\xd4\xd7\x61\xeb\x3a\x6c\xb8\x01\xdc\x6e\x20\x2f\x6e\xc0\x8e\x1b\xd1\x75\x23\xb8\xae\x87\x6e\xa2\x7e\x13\x72\x39\xcf\xa8\x9b\xd1\x7d\x33\x72\x6e\x86\xff\x66\xf2\xf3\x16\xf2\x7e\x03\x79\xb6\x01\xdc\x6e\x25\x46\xb7\x31\x17\x6e\x07\xe3\x8d\x60\xbb\x11\x2c\xee\x00\x9b\x3b\x19\x77\x27\x31\xbd\x0b\xdc\x36\x51\xdf\x04\x1e\x77\x13\xa7\xbb\xb1\x9b\x73\x89\xfa\x17\x58\xdc\x03\x26\xf7\x80\xe1\xbd\x8c\xbd\x0f\x79\xf7\x91\xb3\xf7\x33\xf6\x01\x7c\x78\x90\xd8\x3e\x88\xdc\x07\xc1\xf0\x41\x64\x3e\x84\xcd\x0f\x31\xf6\x61\x7c\x7f\x84\xfa\x23\x6f\x41\xd8\xb2\x99\xfc\xda\x4c\xf9\x28\xb6\x3e\x8e\x9e\xc7\x89\x7f\x25\xfe\x6f\x41\xd7\x16\x78\x9e\x40\xd6\x56\x70\xde\x0a\x76\x5b\xb1\x77\x1b\xbe\x3d\x49\xff\x53\xc4\x79\x3b\x71\x7e\x06\x79\xcf\x60\xc3\x0e\x64\x3c\x8b\x5d\xcf\xd1\xff\x3c\xb8\xbd\x80\xcf\x2f\x12\xab\x9d\xe8\xda\x49\xff\x4b\xe4\xcb\xcb\xe4\xde\x2b\xd8\xb0\x8b\xb9\xbc\x0b\xbc\x76\x61\xeb\xab\xe0\xfe\x1a\xf2\x5f\x43\xd7\x6b\xd8\xff\x1a\xb9\xf2\x1a\xb2\x5f\xc7\xf7\x37\xc8\x95\xdd\xe8\x7f\x13\x19\x6f\xe2\xc3\x1e\x64\xec\xa1\xe4\x1c\xa2\xf6\xe2\xdf\x5e\xfc\x7b\x9b\xf2\x6d\x30\x7a\x1b\x0c\x38\x5b\xa8\xb7\xf1\xf7\x1d\x70\xde\x87\x1f\xef\x22\xef\x3d\x64\xbf\x87\x2f\xef\x11\xe7\xf7\x91\xf3\x3e\x31\x7c\x9f\x79\xc2\x79\x41\x7d\x80\x1d\x1f\xa0\xe7\x03\xe6\xc8\x7e\xec\xff\x10\xfe\x8f\xb0\xff\x23\xfc\x38\x40\x79\x10\x1b\x0f\x22\x93\x7d\x5f\x1d\x84\xef\x20\x7c\x07\xd1\x7f\x10\xde\x8f\xc9\x83\x8f\x89\xf1\x27\x3c\x7f\xc2\xf3\x21\xf0\xf9\x14\x1b\x3e\x23\x26\x9f\x63\xdf\xe7\xe8\x3f\x4c\xae\x7d\x41\x7e\x1c\x01\xa7\xa3\xac\x25\x5f\xa2\x9b\x7d\x5b\x7d\x89\xfc\xaf\x90\x75\x8c\x9c\xa8\x02\x93\x2a\xb0\x3a\x8e\xee\xaf\xf1\xef\x6b\x70\xf8\x1a\xff\xbf\x41\xf6\xb7\xe4\xe0\x77\x8c\xfd\x8e\xd8\x7c\xc7\x98\x13\xc4\xf8\x04\x78\x9f\x00\xd7\x13\xe8\x39\x81\xcc\xef\x99\xd7\xdf\x93\x43\x3f\x20\x83\x23\x9a\x3a\x09\xef\x8f\x60\xf8\x13\xf6\xff\x1b\xdb\x4f\x81\xcf\xcf\xe8\xfd\x19\x99\xbf\x60\xcf\x2f\xf4\xff\x8a\x8c\xdf\x90\xf1\x1b\x36\xfc\x8e\x5f\xbf\xeb\x12\x3f\xfe\x00\x9f\x3f\xe0\x3d\x4d\x1e\x9c\x21\xdf\xce\x52\x9e\x65\xfc\x59\x7c\x38\x8b\x8e\x00\xf3\xc3\x5a\x2a\x86\xf8\xc5\x50\x39\x62\x18\x5d\xc5\x30\x2b\xc4\x70\x40\xce\x72\x31\x5c\xc5\x62\xb8\xf7\x89\x11\xde\x4a\x8c\x08\xa8\x16\x3c\x91\xf7\x8a\x51\xfb\x94\x18\x51\xa3\xc4\x88\xde\x2c\x46\xcc\x36\x31\x62\x97\x8b\x11\x37\x57\x8c\xf8\x7c\xe8\x4b\x31\xea\x4e\x85\xd6\x42\xf4\xd5\x3b\x2e\x46\x42\xb4\x18\x0d\x34\x31\x2e\x69\x83\x18\xc9\xe9\xd0\x50\x68\x81\x18\x8d\xbc\xd0\x5b\x62\x78\xb0\xc3\x83\x2e\x6f\x21\x84\x0e\xef\x19\x31\x7c\xc8\x4c\xc1\xb6\x54\x78\x9b\xa2\xa3\xd9\x2a\x31\x9a\xd3\xdf\x22\x5e\x8c\x8b\xc2\xc4\x68\xc9\xd8\x96\xc8\x6b\xf9\x9b\x18\xad\xb6\x8b\xd1\x9a\xfe\x36\xf0\xa5\x95\x8a\x91\xbe\x49\x0c\xee\xff\x46\x06\x76\xb7\x67\x7c\x87\x26\xd0\x01\x31\x3a\x9e\x14\x23\x13\x1b\x3b\x61\x57\xd6\x07\x62\x74\x7e\x4e\x8c\x2e\xcb\xc4\xe8\x8a\xbf\xdd\x90\xdb\x0d\xbd\xdd\xb1\x27\x1b\x1e\x3f\x72\x7b\x62\x77\x2f\x74\xf5\xc2\xf6\x9c\x37\xc4\xc8\x85\x2f\x0f\x7c\xf2\xb0\xbd\x37\x32\xf3\xe9\xcb\x47\x56\x1f\x6c\xef\xfb\xa0\x18\x05\xb4\xf7\xc3\x46\xf6\x60\xa3\x3f\xb2\x06\x62\xc3\x40\xe4\x14\x32\xb6\x10\xfd\x83\xd0\x37\x78\xbd\x18\xec\xa7\xc6\x50\xec\x1d\xba\x11\xda\x09\xa1\xaf\x08\xbe\x61\xf0\x0c\xaf\x14\xa3\x18\x1d\x25\xf8\x31\xa2\x93\x18\x23\xd1\x33\x12\x1d\xa3\x76\x89\x31\x1a\x5c\xc7\x80\xef\x58\x74\x8c\xa5\x7f\x2c\xb6\x8f\x45\xef\x58\x6c\x1e\x8b\x6f\x5c\x89\x8c\x52\x6c\x2e\x45\x7f\x29\xf1\x2b\x45\x4e\x29\x36\x95\xa2\xa7\x14\x3d\xa5\xe8\x29\xc3\xe6\x32\x70\x61\x8f\x34\xc6\xc1\x3b\x0e\xdb\xc7\xe1\xdf\xf8\x04\x88\x1c\x18\x8f\xdc\xf1\xc8\x1d\x8f\xdc\x72\x74\x4d\x00\xe7\x09\xc4\x7e\x02\xb2\x26\x60\xf3\x04\xec\x9b\x00\x76\x13\x18\x33\x91\x31\x13\x19\x33\x91\x31\xec\x9d\xc6\x44\xc6\x4c\xc4\x96\x49\xe8\xae\x68\x08\x11\xbf\x0a\x30\x9b\xcc\xf3\x14\xc6\x5f\x0c\x4d\xe5\x79\x1a\x72\xa7\x53\x9f\x11\x09\xc1\x37\x13\xec\x67\x51\xb2\xa7\x19\xb3\xbf\x13\x63\x0e\x36\xcd\xc5\xe6\x79\xc4\x77\x3e\x72\x2f\x01\xaf\x05\xe4\xc8\xa5\xf8\x75\xe9\x61\x31\x2e\x23\xbe\x0b\xd1\xb3\xf0\x90\x18\xec\x59\xc6\x22\xfa\x17\x13\xe7\xc5\xc8\x5e\x4c\xde\x2c\x66\xcc\x62\xdd\x46\x0c\x96\x60\xf3\x12\x78\x97\x82\xe5\x52\xf0\x5f\x8a\xdd\xdc\xcf\x8d\x2b\x18\x77\x25\xfa\xae\x44\xe6\x95\xe0\xca\xbe\x65\x5c\x45\x6e\x5e\x85\xec\x65\x8c\xbf\x9a\xbe\xab\xf1\xeb\x6a\xc6\x5e\x8d\x9c\x6b\x88\xc3\x35\xf8\xc1\xdd\xdc\xb8\x06\x1c\xaf\xc5\xef\x6b\x89\xeb\x72\xc6\x2f\xbf\x1c\x42\xf6\x72\x64\x5f\x87\xbe\x15\x8c\x5d\x31\x53\x0c\xee\xe1\x06\x77\x70\x63\x15\x63\x57\x31\x67\x56\x91\xa7\xab\xb1\x63\x35\xf5\xd5\xf0\xad\xc6\xcf\xeb\x89\xc1\xf5\xf8\x7a\x3d\x98\x5e\x4f\x0e\xac\x01\x87\x35\xe8\x59\x83\xbf\x6b\x88\xf9\x1a\xda\xd6\xe2\xdb\x5a\x72\x7b\x2d\x31\x5c\x07\x6e\xeb\xb0\xf1\x06\xe6\xc9\x8d\xe8\xbe\x11\xbc\xd6\xd3\x77\x13\xed\x37\x61\x17\x7b\x93\x71\x0b\xb1\xdd\x40\xcc\x36\x30\xfe\x56\x62\x70\x2b\xb6\xdd\x06\x96\xb7\xa3\x7b\x23\x31\xbb\x03\xfb\xee\x20\x8e\x77\xf6\x13\xe3\x2e\x30\xdb\x04\xef\xdd\xd8\xf8\x2f\x6c\xb9\x87\xf2\x1e\xfc\xbd\x97\xbc\xb9\x0f\x9e\xfb\x91\x77\x3f\xf6\xdd\x0f\x5e\xf7\x83\xc5\x03\xd8\xf7\x00\xba\x1f\x64\xbe\x3f\x04\xd6\x0f\xd3\xf7\x08\x58\x6f\x06\xd3\xcd\xf0\x3f\x8a\x9e\xc7\xf0\xfd\x31\xec\x7f\x9c\xfc\x7f\x9c\xb2\x12\x5c\x2b\xb1\x6d\x0b\xfd\x4f\xe0\xdb\x13\xd8\xfa\x04\x58\x6d\x65\xfc\x56\x74\x6d\x43\xee\x93\x60\xf1\x14\x78\x3e\x0d\xef\xd3\xc8\xd8\x4e\xf9\x0c\xf9\xfc\x0c\x98\xed\xc0\x87\x1d\x8c\x7f\x16\x9b\x9e\x43\xf6\xf3\xc4\xe5\x79\xe2\xf5\x02\x7a\x5f\xc4\x9f\x17\x19\xbb\x13\xfb\x5e\x42\xde\x4b\xcc\xa1\x97\xd1\xf1\x0a\x63\x5f\xc1\x9f\x5d\xe4\xfb\x2e\x78\x76\xd1\xff\x2a\x78\xbc\x46\xac\xb9\x43\x1b\xfa\x3f\x5d\xfa\x06\xf6\xec\x26\x16\xbb\xb1\xe1\x4d\x6c\xd8\x83\xce\x3d\xf8\xf6\x16\x7a\xb8\x07\x1b\x7b\x89\x35\x7b\x92\xf1\x0e\xe3\xdf\xc1\xcf\x7d\x8c\x7b\x17\x9e\x77\xb1\xfd\x3d\x78\xde\xa7\xfd\x7d\x6c\xfe\x00\x9b\xf6\x53\xdf\xdf\x5c\x8c\x0f\x89\xf9\x87\x8c\xfd\x88\xb8\x1f\x00\xd7\x03\xd8\x79\x90\xfa\xc7\xf8\xfc\x09\xf3\xee\x13\x62\x77\x08\xec\x3e\x25\x76\x9f\x32\x67\x3f\x63\x2e\x7c\x46\x0c\x3f\x47\xcf\xe7\xe8\x3b\xcc\xf3\x61\xec\xf9\x02\xbe\x23\xc4\x8b\x3b\xa3\x71\x14\x3c\xbe\xc4\xce\xaf\xd0\xf1\x15\x36\x1f\x43\x56\x15\xb2\xaa\x90\x5d\x85\x2d\xc7\xf1\xf1\x38\x7c\xc7\xc1\xe3\x38\xba\x8e\x13\xef\xaf\xb1\xf5\x6b\x7c\xfd\x1a\x7f\xbe\x01\xc3\x6f\xc9\x1d\xf6\x1e\xe3\x04\xf8\xfc\x80\xbd\x27\xe9\xfb\x91\xbe\x9f\xc8\xc3\x7f\xa3\xfb\x14\x7e\xfd\x4c\xec\x7f\x61\x2e\xfe\x82\x5d\xbf\x82\xd7\x6f\xf4\xfd\x41\xae\xfc\x01\xdf\x69\x30\x3d\x43\x2c\xcf\x42\x01\x6c\xb3\x36\x8a\x29\x0f\x8a\xc9\x81\xca\x34\x76\x8a\x69\x52\xd7\x7f\x6b\xec\x2c\x14\xd3\xd5\x5e\x4c\x77\x57\x31\xc3\x1c\x62\x86\x6b\x3a\x2e\x66\x44\xa5\x98\xb5\xb6\x8b\x19\xb9\x40\xcc\xda\x33\xa1\xa5\x62\xd6\x59\x25\x66\x14\x65\xf4\xbd\x62\xc6\xd0\x1f\xbb\x4b\xcc\xb8\xe5\x62\xc6\x23\x23\xfe\x8c\x98\x75\x3f\x10\xb3\xde\x3e\xe8\x30\x74\x4a\xcc\xfa\xeb\xc5\x4c\x98\x0a\x5d\x0e\x21\xb3\x01\xe3\x13\xcb\xc5\x4c\x42\x47\x12\xe3\x1b\x26\x40\x73\x21\xc6\x24\x63\x5f\xa3\x68\x68\x83\x98\x1e\xfa\xb9\xfe\x9b\xde\x2f\xc5\xf4\x61\x67\x63\x78\x52\xbc\xd0\x73\x62\x36\x41\x77\x2a\x3a\x9b\xc6\x43\x6f\x88\xd9\x0c\x39\xcd\xb1\xa9\x45\x43\x08\x7b\xb8\x1b\x9a\x17\x61\x77\x4b\x6c\x6e\xd5\x09\x3a\x24\x66\x6b\xc6\xb7\xc1\xc7\x36\xd8\x94\xc6\xf8\xf4\xe6\x10\x76\xa5\x23\x3b\x1d\x1d\x6d\x91\xdd\x16\x3f\xdb\x62\x47\x3b\x70\x68\x07\x7f\x3b\x7c\x69\xf7\x9d\x98\x19\xd8\x92\x01\x7f\x06\x72\x33\x8a\x21\xe4\x66\xa0\x3f\x63\x13\xf4\x16\x04\x4f\x7b\xec\x6e\x0f\x4f\x7b\x78\xda\xc3\xd3\x1e\x9e\xf6\xf0\xb4\x87\xa7\x3d\xb6\xb4\x47\x6e\x7b\xfc\xef\x10\x09\x81\x79\x07\xf0\xea\x00\x4f\x07\x78\x3a\xc0\xd3\x01\x9e\x0e\xf0\x74\x00\xc3\x8e\xf8\xd1\x11\x39\x1d\xc1\xa9\x23\xfd\x1d\x37\x43\xf4\x75\xc4\xf6\x4c\xc6\x67\x36\x81\xf2\x21\xec\xcf\x5c\x06\x81\x5b\xe6\x36\x08\x5b\xd8\x2b\xcd\x4c\x64\x74\x82\xa7\xd3\x50\x08\x9f\x3a\xd1\xdf\x89\xfe\x4e\xf4\x77\xa2\xbf\x13\xfd\x59\x60\x97\x85\x1d\x59\xd8\x9a\x85\x8c\x2c\x78\xb2\xe0\xc9\x82\x27\x0b\x9e\xce\x61\x10\xfd\x9d\xb1\xb3\x33\x58\x74\x26\x6e\x9d\xc1\xad\x33\x78\x77\xc6\xdf\x2e\x60\xd2\x05\x3b\xbb\x80\x69\x97\x7e\x10\xb6\x76\x21\xc6\x5d\xf0\xa5\x0b\x32\xba\x60\x6b\xd7\x1c\xa8\x02\xc2\x87\xae\xf8\xd0\x95\xf6\xae\x27\xc5\x64\xdf\x36\xbb\x11\x97\x6e\xa3\x20\xe2\xd6\x8d\x31\xdd\xf0\xbf\x1b\x3e\xb2\x9f\x9b\xdd\x91\xdb\x1d\xb9\xdd\x91\xdb\x1d\x8c\xba\x93\xaf\xdd\x89\x53\x77\x72\xb6\x3b\xb6\x65\x63\x5b\x36\xb6\x65\x63\x5b\x36\x3a\xb3\xb1\x3d\x9b\xbe\xec\x03\x10\xf2\xfd\xf4\xfb\x89\xa7\x1f\x1d\x7e\x78\xfc\xd8\xe0\x47\x8f\x9f\xbc\xf2\x93\x2b\x7e\x7c\xf0\x93\x9f\x9c\x17\xcc\x1e\xe8\xea\x41\xbc\x7b\x60\x7f\x0f\x74\xf4\xc0\xc6\x1e\xf8\xd7\x13\xff\x7a\xd2\xd7\x13\x1b\x7a\xa2\xa3\x27\xf6\xf7\x24\x8f\x7a\x11\xe7\x5e\xf8\xd5\x0b\x99\xbd\xc0\xa4\x17\x98\xf4\x22\x27\x7b\x21\x2f\x87\x31\x39\xe4\x40\x0e\x63\x72\xb0\x3b\x87\xdc\xcf\xc1\xaf\x1c\xec\xca\xc1\xae\x5c\xec\xca\xc5\xae\x5c\xec\xca\xc5\xae\x5c\x64\xe4\x22\x23\x17\x9b\x72\xc9\xb5\x5c\xec\xc9\xc3\xbf\x3c\x30\xe8\x0d\x46\xbd\xe1\xeb\x0d\x46\xbd\xb1\xbd\x37\x7a\x7a\x63\x77\x6f\x6c\xcb\xc7\x86\x7c\xf0\xc9\x27\x76\xf9\xd8\x96\x8f\xdd\xf9\xf4\xe5\xd3\xd7\x87\xbe\x3e\xf4\xf5\xa1\xaf\x0f\x7d\x7d\xc0\xb6\x0f\x73\xa2\x0f\xb9\xd7\x17\x99\x7d\xe9\xeb\x8b\x7d\x7d\xf1\xb7\x2f\x71\xe9\x8b\x5f\x7d\xc1\xbd\x2f\xf1\x2a\x60\x2e\x16\x80\x45\x41\x29\x44\x4e\x14\x20\xb7\x00\x3c\x0a\xb0\xbd\x1f\x63\xfb\x91\x93\xfd\xe8\xeb\x47\x5f\x3f\x72\xa5\x1f\x7d\xfd\xb0\xb7\x1f\xf6\xf6\xa7\xbf\x3f\xf6\xf6\xc7\xde\xfe\xd8\xdb\x1f\x7b\xfb\x63\x53\x7f\x6c\x1a\x80\x4d\x03\xd0\x3b\x00\x9b\x06\x60\xd3\x00\xe4\x0e\xa0\x6f\x00\x7d\x9c\xb7\xcc\x81\x60\x36\x10\xd9\x03\xb1\x69\x20\xfd\x03\xb1\x79\x20\xb8\x0d\xc4\xae\x81\xd8\x5d\xc8\x3a\x50\x88\x6d\x85\xd8\x56\x88\xfe\x42\xf4\x17\x12\xf3\x42\x62\xce\x19\xcd\x2c\x44\xff\x20\xf4\x0f\x42\xff\x20\x70\x1d\x04\xae\x83\xb0\x61\x10\xb8\x0e\x22\x66\x83\xf0\x6d\x30\xf3\x66\x70\x3a\xc4\x9c\x18\xcc\x9c\x18\x4c\x2e\x0c\xa6\x7f\x30\xb8\x0f\xc6\x8e\x21\xd8\x38\x04\x1b\x87\x60\xe3\x10\x6c\x18\x82\x0d\x43\xc0\x6d\x08\xfa\x87\x32\x76\x28\x63\x87\x32\x76\x28\x63\x39\x03\x9a\x9c\x01\x4d\xce\x80\x66\x11\x31\x2d\x22\x17\x8b\xd0\x5b\xc4\x3c\x29\x42\x6e\x11\xf9\x50\x44\x3e\x0c\xc3\xb7\x61\xf8\x36\x0c\xbc\x87\x91\x0f\xc3\xc8\x87\x61\xf8\x35\x0c\x9b\x86\xe3\xd3\x70\xe6\xe8\x70\xe6\xf1\x70\xe6\xf1\x70\x72\x7c\x38\x98\x0e\xc7\x9f\xe1\xf8\x53\x4c\x9e\x14\x93\x67\x9c\x2b\xcd\x62\x72\xa4\x18\x5b\x8b\xc1\xa3\x98\x58\x94\xe0\x6b\x09\xbe\x96\x80\x75\x09\x7e\x96\x80\x75\x09\x78\x96\xe0\xc7\x08\xfc\x18\x81\x1f\x23\xf0\x63\x04\x7e\x8c\xc0\x8f\x11\xf8\x31\x02\x3f\x46\xe2\xc7\x48\xfc\x18\x89\x1f\x23\xf1\x63\x24\x7e\x8c\xc4\x8f\x91\xf8\x31\x0a\x3f\x46\xe1\xc7\x28\xfc\x18\x85\x1f\xa3\xf0\x63\x14\x7e\x8c\xc2\x8f\xd1\xf8\x31\x1a\x3f\x46\xe3\xc7\x68\xfc\x18\x8d\x1f\xa3\xf1\x63\x34\x7e\x8c\xc1\x8f\x31\xf8\x31\x06\x3f\x38\xe7\x9a\x63\xf0\x63\x0c\x7e\x8c\xc1\x8f\x31\xf8\x31\x16\x3f\xc6\xe2\xc7\x58\xfc\x18\x8b\x1f\x63\xf1\x63\x2c\x98\x8f\x25\xd7\x4b\x99\x5f\xa5\xc4\xbd\x94\xb8\x97\x92\x8b\xa5\xe4\x62\x29\x3e\x96\xe2\x63\x19\x3e\x96\xe1\x63\x19\x3e\x96\xe1\x47\x19\xb6\x96\x61\x4f\x19\xf6\x8c\x43\xe7\x38\x74\x8e\x43\xe7\x38\x74\x8e\x43\xee\x38\xc6\x8e\x23\x1f\xc7\x81\xc1\x78\xfc\x1c\x8f\x2f\xe3\xb1\x77\x3c\xfd\xe3\xf1\x65\x3c\x18\x8c\x47\x6e\x39\x3a\xcb\x19\x57\x8e\x8f\xe5\x60\x53\xce\x98\x72\xc6\x4c\x60\xcc\x04\xc6\x4c\x60\xcc\x04\xc6\x70\x6e\x36\x27\x20\x73\x02\xfd\x13\xb0\x75\x22\xfa\x26\x82\xcd\x44\x6c\xe1\xcc\x6c\x4e\xc4\x87\x49\xd8\x31\x89\x31\x93\x18\x33\x89\x31\x93\x18\x33\x89\x31\x93\x18\x33\x09\x99\x15\xc8\xac\xa0\xbf\x82\x58\x54\x90\xb3\x15\xf8\x5e\x01\x66\x93\xc1\x7a\x32\x31\x9a\x4c\x2e\x4f\x66\xcc\x64\xda\x27\x23\x6f\x32\x79\x3a\x85\x31\x53\x18\x33\x05\x5d\x53\xc0\x7a\x0a\x58\x4f\x01\xeb\x29\x8c\xbb\x18\x7d\x17\x33\x0f\x2e\x26\xe6\x17\xa3\x63\x2a\x32\xa6\x32\x76\x1a\x32\xa6\xa1\x77\x1a\x3e\x4e\x23\x96\xd3\x91\x3f\x9d\x78\x4d\xc7\xae\xe9\xc8\x98\x8e\x8c\xe9\xc8\x98\x0e\xb6\x33\xb0\x65\x06\x18\xce\x24\x46\x33\xd1\x39\x13\x9d\xb3\xf0\x6d\x16\x39\x31\x0b\x4c\x66\x21\x67\x16\x7c\xb3\x68\x9f\x8d\xae\xd9\xcc\xb9\xd9\xc8\x9d\x83\xac\xb9\x60\x37\x97\xe7\xb9\xd8\x3d\x97\x38\xcf\x25\x77\xe6\xa2\x6f\x1e\xfa\xe6\x61\xf3\x3c\x62\x3c\x0f\x5b\xe6\x61\xd3\x3c\x64\xcf\x03\xb7\xf9\x8c\x99\xcf\xf8\x4b\x88\xe3\x25\xe8\xbc\x84\xf6\x4b\xc0\x66\x01\x7e\x2e\x20\x17\x17\xe0\xe7\x02\xf4\x2e\x20\x46\x0b\x88\xef\x02\x6c\x5b\xc0\xb8\x4b\xb1\xe7\xd2\x6d\xff\x17\xc4\xf8\xcb\xb0\xf5\x32\x6c\x58\xc8\x5c\x58\x48\xfe\x2d\x44\xc7\x42\x30\x5b\xa8\xdb\xb0\x99\x3b\x88\x79\x39\x7e\x5c\x4e\x4e\x2d\x02\xd3\x45\xf8\xb3\x18\x1f\x16\x33\x7e\x09\xf5\x25\xcc\x8d\x25\xd8\xb0\x94\x1c\xbe\x02\x6c\xae\x60\x6e\x5d\x09\xdf\x95\xe4\xe3\x95\xc4\xff\x4a\xda\xaf\xa2\x7e\x15\x79\x74\x8d\x26\x62\x7b\x0d\x7a\xaf\x25\xcf\x97\x83\xc7\x0a\x70\x58\xc1\x9c\x5c\x81\xaf\x2b\xf1\x73\x25\xb2\x56\xd1\xb6\x8a\x98\xad\x66\x2e\xad\x66\xcc\x6a\x6c\xe1\x1e\x61\x5e\x4f\xc9\xdd\xc1\x5c\x43\x7c\xd6\x62\xcf\x3a\xc6\xac\x63\xae\xae\x63\xee\xdc\x40\xff\x0d\xe8\xbf\x01\x5d\x37\x62\xd7\x7a\xf0\xb9\x09\xfb\x6f\x06\xbf\x0d\xcc\x8f\x5b\x91\x73\x1b\xb6\x6d\x24\xbe\x1b\x89\xdb\x9d\xf8\x79\x17\xb2\x36\x61\xe3\xdd\xc8\xfb\x17\xfc\xf7\xa0\xf3\x3e\x7c\xbf\x9f\xb8\x3c\x80\xdc\x07\x89\xeb\xc3\xe0\xfe\x08\xf2\x36\x83\xd3\x66\xca\xc7\x68\x7f\x1c\xbd\x5b\xb0\xf5\x09\xda\xb6\x22\x6f\x1b\xf3\xf1\x49\xfc\x79\x8a\xb8\x3c\x0d\x56\x4f\x13\xbf\xa7\x91\xfb\x34\xba\xb7\x23\x6f\x3b\x7e\x3e\x83\xae\x67\xf0\xeb\x19\x6c\xda\x01\xce\x3b\xe8\xdf\x01\x36\xcf\xc2\xfb\x2c\x73\xed\x39\xfc\x79\x1e\xb9\x2f\x60\xff\x8b\xe8\xd9\x09\xef\x4e\xe4\xed\x64\xfe\xec\x44\xce\x4b\xb4\xbf\x8c\x9d\x2f\xc3\xbb\x0b\x7f\x5e\x43\xe7\xeb\xcc\xc9\x37\xe0\x7d\x03\x39\xbb\xc9\x81\xdd\x8c\x7f\x13\x7b\xdf\x24\x47\xde\xa4\x6d\x0f\xf6\xbf\xc5\xf8\xb7\xa8\xef\x25\xb7\xf6\xc2\xbb\x97\x31\x7b\xb1\xe7\x6d\xe6\xc3\xdb\xc4\xe2\x6d\xc6\xbc\x03\x6e\xef\xe0\xf3\x3b\xb4\xef\x23\x37\xf7\x91\xaf\xfb\xf0\xf3\x5d\x6c\x7e\x17\x5c\xde\x43\xdf\x7b\xf0\xbe\x47\xdb\xfb\xf8\xf7\x3e\xf8\x7d\x00\xde\x1f\x60\xe3\x07\xc8\xde\x0f\xb6\xfb\x89\xcd\x87\xd8\xf8\x21\xb1\xfc\x88\xfc\xf8\x08\x19\x07\x88\xdf\x01\x78\x0e\x60\xf3\x41\xd6\xad\x83\xe0\xff\x31\x76\x7e\xcc\xf3\x27\xe0\x72\x08\x59\x87\x58\x0b\x0e\xe1\xfb\x21\xb0\x3f\x44\x1c\x3f\x45\xff\xe7\xcc\xc7\x23\xe4\xc8\x31\xec\x3d\x86\x5d\xc7\xb0\xb1\x0a\x59\x55\xc4\xac\x0a\xdc\xaa\xf0\xa9\x0a\xbd\xdc\x0b\xcc\xe3\xf8\xf1\x35\xba\xbf\xa1\xfc\x0e\xd9\xdf\xa1\xff\x04\xed\x27\xe0\xf9\x9e\x39\xf9\x03\x31\x3a\x89\x7d\x3f\x22\xf7\x47\xf4\xfe\xc4\xb8\x7f\x93\xb3\xa7\x90\x75\x0a\xdf\x7e\x06\x97\x9f\xd1\xff\x0b\x76\xfc\x8a\x4d\xbf\x81\xdd\xef\xc4\xf2\x77\xe2\xf2\x07\xf6\x9d\x06\xcf\x33\x3c\x9f\x25\x66\x01\xf2\x3a\xc0\xfc\xb4\x1e\x14\x87\x54\x40\xdf\x89\x43\xcd\x15\x87\x91\x0e\x6d\x13\x87\xb9\x5c\x1c\x8e\x1c\x71\x38\x9b\x40\xbb\xc4\xe1\x9a\x29\x0e\x77\x73\x68\x13\x74\x46\x1c\x61\xc5\x10\x7c\xe1\x91\x50\x29\x44\x3d\xa2\x21\xb4\x14\xfa\x52\x1c\xb5\xfa\x41\x1b\xa1\x53\xe2\x88\x44\x6e\xe4\x01\x71\xd4\x0e\x83\x3a\x41\xc8\xa8\x83\xdc\x3a\xe8\xa8\x73\x58\x1c\x51\x09\x50\x39\xb4\x0c\x5a\x0f\xdd\x0b\x21\x2f\x0a\xbd\x51\x1f\x40\xc8\x8b\x42\x4e\xb4\x03\x8a\x87\xd0\x1d\x8d\x3d\xd1\x8c\x8f\xc6\xfe\xe8\x37\x20\xe4\x44\xff\x26\x8e\x98\x68\x08\x3b\x63\xfc\x10\x7c\x31\xf0\xc5\xc0\x17\x83\xce\x18\x64\xc5\xe0\x67\x2c\x72\x62\xb1\x35\xb6\x3d\x84\x9d\xb1\xe8\x8e\x5d\x05\xa1\x37\xf6\x39\x08\xbe\x58\xf8\xe2\xe0\x8b\x83\x2f\x0e\xbe\x38\xf8\xe2\xe0\x8b\xbb\x1c\xc2\xc6\xf8\x9d\xe2\xa8\x4b\x7f\xdd\x42\x68\xb3\x38\xea\xa1\x37\x61\x41\x90\x1a\xe0\x5b\x83\xb5\x10\xf6\x70\xe7\x71\x24\xe2\x7f\x22\xbe\x25\x32\x2e\x11\x1d\x89\xf8\x96\x88\x6f\x49\xd8\x99\x84\xde\xa4\x93\xe2\x68\x28\x10\x32\x1a\x7a\x21\x62\xd0\x70\x14\x34\x15\x42\x5f\x43\x78\x1a\x82\x65\x43\xf4\x34\xc4\xbe\x86\x6f\x41\x87\x20\x6c\x6c\x48\x2c\x92\x89\x41\x32\x76\x26\x33\x2e\x99\x98\x25\xe3\x77\x32\x63\x93\x89\x45\x32\x76\x24\xa3\x33\x79\x3b\x04\x4e\xc9\x8c\x4b\x46\x5f\x23\x6c\x6f\x04\xee\x8d\x5a\x41\x60\xd5\x08\x3f\x1a\x11\xc7\x46\xe0\xd5\x88\x71\x8d\xf6\x89\xc3\x33\x14\x82\xdf\xcb\xb3\x8f\xd8\xf9\xe8\x6b\x8c\x9e\xc6\xba\xc4\xfe\x14\xc6\xa7\xe0\x5f\x0a\xb2\x9b\x60\x43\x13\xf4\x36\xc1\xc6\x26\xd8\x94\x9a\x0f\x61\x73\x2a\xf5\xa6\xc8\x6e\x8a\x0d\x4d\xb1\xb7\x19\xf1\x6f\x86\x4d\xcd\x8e\x8b\xa3\x39\x3c\xcd\xe1\x69\x4e\x7b\x0b\x30\x6e\x41\x9c\x5a\x10\xc7\x8b\xe0\xb9\x08\xac\x2e\x22\x67\x5a\x82\x47\x4b\xf2\xb3\x25\xfa\x5a\x51\x6f\x05\x1e\xad\xf0\xbf\x35\x79\xd0\x1a\x8c\x5a\x83\x65\x1b\x6c\x6b\x83\xee\x36\x95\xe2\x48\xa3\x3d\x0d\xfe\x34\x6c\x4a\xa7\x3d\x1d\x1f\xd2\xb1\xa9\x2d\xd8\xb6\x25\x0e\x6d\xc1\xa0\x1d\x76\xb7\x83\xa7\x1d\x31\xcc\xa0\x9e\x41\x7b\x06\xfe\xb6\xa7\xde\x1e\x0c\xda\x93\x53\x1d\x18\xdb\x01\x9e\x0e\xf0\x74\x44\x66\x47\x74\x75\x24\x87\x3a\x12\xd3\x4c\x74\x65\x22\xbf\x13\x32\x3b\xc1\xdf\x09\xbd\x59\xf0\x67\x51\xcf\xa2\xde\x19\x2c\x3a\x83\x51\x67\xf2\xa8\x0b\x31\xee\x42\xbd\x0b\x72\xba\x22\xa7\x2b\xba\xba\xa2\xab\x1b\xb8\x77\xa3\xde\x8d\x78\x76\x27\x16\xdd\xc1\xb1\x3b\x3e\x66\x93\x3b\xdc\x6d\x1c\xd9\xd4\xfd\xf0\xfb\x89\xa3\x1f\x7f\x7b\xc0\xdf\x03\x7c\x7a\x80\x49\x4f\x78\x7a\x32\xb6\x27\xed\xbd\x68\xef\x45\x6e\xf5\x42\x57\x0e\xed\x39\x8c\xe5\xde\xe1\xc8\x45\x6f\x2e\x75\xee\x17\x8e\x3c\xb0\xcd\x03\xf3\x3c\xda\x7b\x83\x61\x6f\x74\xf5\xc6\x9e\x7c\x62\x99\x4f\xbe\xe6\x23\x87\xfb\x83\xa3\x0f\x3e\xf6\xc1\xfe\xbe\xd8\xdf\x17\xdf\xfb\xc2\x53\x40\xbd\x80\xf8\x15\x10\xbf\x02\x7c\xef\x07\x9e\xfd\xc0\xb3\x1f\xf5\xfe\xe4\x5a\xff\x0d\x10\xf3\x73\x00\x31\x1b\x80\x8e\x01\xe4\x0b\xe7\x7a\x07\xe7\x79\x07\xe7\x78\x47\x21\x36\x15\xa2\xa3\x10\xdb\x0b\x89\x2d\x67\x75\xc7\x20\x62\x30\x98\x9c\x1e\xcc\x9c\x1e\x02\x36\x43\xc9\xfd\xa1\x3c\x0f\x45\xee\x50\x6c\x19\x4a\x3e\x14\xa1\x97\xf3\xb5\xa3\x88\x79\x57\x04\x06\x45\xf4\x17\xd1\x5f\x44\x7f\x11\xfd\xc3\xe8\x1f\x46\x3f\x67\x6c\xc7\x30\xfa\x87\xd1\x3f\x8c\xfe\x61\xf4\x0f\xa3\x7f\x38\xfd\xc3\xe9\x1f\x4e\x3f\xe7\x6c\xc7\x70\xfa\x39\x63\x3b\x8a\xb1\xa7\x18\x1f\x8a\xc1\xac\x18\x6c\x4a\x78\x2e\xe1\xb9\x84\xe7\x12\x62\x3a\x82\xbc\x1b\x09\xb6\xa3\xc0\x62\x14\xf6\x8f\x66\x4e\x8d\x26\x1f\xc6\xc0\x33\x86\xe7\xb1\xc4\xb8\x94\x58\x97\xd2\x5f\x06\xae\x65\xf8\x3b\x0e\x5d\xe3\xc0\x72\x1c\x63\xc7\xe3\xcb\x78\xe6\x4b\x39\x65\x39\x58\x4e\x00\x87\x89\xe4\xd5\x44\xf2\x74\x12\x38\x54\x60\x4f\x05\xf6\x70\x2e\x74\x54\x90\xfb\x15\xb4\x57\x60\x73\x05\x18\x56\x30\x57\x26\x23\x6b\x32\x36\x4d\x21\xf6\x53\xc0\xfc\xe2\xae\x10\xf3\x75\xea\x72\xfd\xff\xeb\x47\x0c\xd9\x68\x1d\x35\x1e\x70\x76\x13\x53\xa2\xd4\x3b\x7e\xcb\x34\x8c\xda\x6e\x77\x74\x8c\x52\x46\x84\x23\xe2\xf6\x91\x8e\x7a\x86\x39\x37\x46\x95\xc7\xa8\xa1\x31\xca\x1f\xa3\xda\xc7\xa8\x26\x31\x2a\x3e\x46\x39\x62\xd4\xc9\x18\xf5\x65\x8c\xda\x17\xa3\x76\xc6\xa8\x6d\x31\xea\xde\x18\xb5\x2c\x46\xcd\xb4\x99\x0b\x63\x54\x4e\x35\xb3\xc4\xa8\xc9\xa7\x6c\xd6\x0f\x6c\xa6\xb5\xf6\x1f\x3d\x9f\x13\x9a\xf3\x57\xa1\x41\xb6\x5d\x31\xaa\xd2\x66\x5e\x6f\x0b\x0d\x32\xd7\x64\x0b\x0a\xdc\x55\x2d\x30\xc8\x53\x6a\x2b\x0e\x5a\xe9\x8d\x51\xd1\x36\x67\xd6\xa9\x1a\x12\x37\xfd\x55\x62\x4d\x9f\x6c\x6f\xfc\xfd\x43\xfe\xfc\x13\x6f\xba\x2d\x39\xde\xf6\xea\x9c\x53\x8f\xd4\xf0\x08\x06\x23\xa8\x1b\x8e\xd1\xa3\x47\x8f\x1d\x1d\xfa\xcc\x3a\xef\x33\xbb\xe6\x67\xcc\xe8\xbf\x7c\xfe\x99\xf1\x9f\x38\x25\x3b\xbb\x65\x4c\xac\x64\x25\xa4\xc5\xc4\xaa\xac\x98\x8c\x8c\x98\x8c\xb6\xe9\x2a\x25\xce\xa7\x1a\x37\xed\xd0\xbe\x63\x46\xbb\x7a\x75\xe3\x5d\xea\xae\xb1\x5d\x55\xcb\xc0\xed\xb9\x65\xa5\x79\x90\xba\xd7\xbc\xf5\x8f\xfb\xed\x2a\x24\x86\x9a\x69\x8e\x32\xbf\xb6\x73\xc1\x2d\xdd\xfc\x8d\x9d\x0e\x87\xcb\xad\x44\x0c\xd3\x6d\x86\x85\xbb\xa3\x4d\xe5\x35\x2b\x4d\x43\xcc\x68\x73\x93\x69\x9a\x9c\x3a\x24\xbb\xdd\xde\xd1\xb3\x66\xb7\xd3\x3a\x83\x4a\xab\x35\x67\x98\x29\x9a\x8c\xd3\xdf\xdf\x33\x34\x70\x2d\x5f\xce\x6e\x01\x8f\xfa\x22\xe0\x41\x9c\x75\x9a\x64\x4e\x41\x4f\x92\x78\xd4\x38\xff\x89\x58\x4f\x23\xd3\x61\xc4\xd5\x4d\x68\xc0\x99\x21\x9e\xad\x27\xc6\x11\xed\x74\x47\xd4\xaa\xe3\x88\x72\x19\x71\x2a\x2e\x3e\xde\x17\xed\x8c\x72\xba\x5c\x5e\x87\x84\x85\x87\x3d\x56\x92\xdc\x20\xbc\x61\x42\x64\xed\xc8\xc7\x4a\xea\xc6\xd4\xae\x55\x7b\x61\x6d\xa3\x5e\x78\xed\xf0\xda\x2a\x2e\xca\x74\xa9\xd8\x7b\x7d\x6a\xbd\x4f\x2d\xf3\xa9\xb9\x3e\x55\xee\x53\x43\x7d\x2a\xc7\xa7\x9a\xf8\x94\xc3\xa7\x0e\xfb\x94\xb1\xcf\xa7\x76\xfa\x54\xa5\x4f\x6d\xf2\xa9\xb5\x3e\xb5\xd4\xa7\x4a\x7d\xca\xef\x53\x5e\x9f\x8a\xf6\x29\xf1\xa9\x93\x36\xdf\x4e\x9b\x81\xae\x42\xbb\x37\xdd\x66\xa0\x37\xeb\xf0\x85\x06\xd7\x1c\xb3\xf4\xaf\x03\x0e\xff\x55\xc7\x5f\xe3\xfb\xf7\xa0\xd6\x08\xfc\xd8\x3f\x43\x2f\xd9\x19\xd9\x19\xb1\x59\x59\x69\x69\x63\x46\x03\x71\xcb\x18\xd1\x38\x87\x4a\x95\x11\x82\x3e\x58\xc4\xd6\xcf\xaa\x49\x04\xc3\x24\x0f\xa0\x94\xcc\x0c\x9b\x32\x4c\x1f\x94\xe1\x4e\x81\x14\x75\x63\xf7\xfa\x5b\xd6\x07\xfe\xb8\xe1\xb6\xf5\xb7\xd6\x7b\x62\x52\x55\xbd\xc0\x9a\x0d\x6b\x95\x6b\xed\x2d\x6b\x37\xd4\x7b\x6c\xc2\x17\xf5\xce\x9e\x99\xa4\x5c\x15\xea\xf6\xc0\x84\x20\x2d\x54\x9e\x85\x6a\x75\x60\x8e\xa6\x85\x81\x2f\x16\xaa\xdb\x02\x5f\x28\xe2\x6a\x5a\xc7\xad\x72\xf3\x43\xe7\x1e\x69\x2c\x2d\x24\x5d\x1e\xf5\x67\xd7\x69\xd6\x34\xcc\x2d\xae\xc6\x51\x31\x0d\x12\x5b\xb7\xf1\xba\x7c\xd1\x8d\xa3\x7c\x51\xd1\xd1\x46\x9c\x91\x12\x19\x77\x51\xa3\xc8\x46\xed\xda\xb6\x0e\x4b\x6c\xea\x88\xf1\x36\x6b\x10\xd3\x60\x4e\x49\x54\x74\x8c\xbf\x4e\x8c\xc4\x47\xc7\x1b\x91\x66\xfc\x76\x6b\xe7\xd6\x7a\x9e\x7c\x5d\xfa\x93\x63\xe2\xf3\xe3\xe3\x63\x1a\xb8\xdb\x78\xdb\xcc\x29\xf1\x38\xd4\x8b\x0e\x55\xe8\xd0\xff\x99\xae\xc6\x3e\xaf\x5b\xb2\xf7\xb6\xcb\xc8\x48\x03\x3e\x0d\x49\x42\x76\x46\x5a\xcb\x96\x63\x35\x54\x89\xd1\x7b\xdb\xe9\xa6\x20\x1a\xd5\x59\xca\x63\xd6\x5f\xc0\x02\xa4\x7a\xf5\xcd\x94\x66\x4d\x9b\x99\x8d\x8c\xba\x64\x5f\x4a\x66\xd3\x66\x71\x19\xf5\x1b\xa9\xfa\x71\x6d\x8c\x0e\xd1\xa9\x99\x19\x66\x7b\x3a\xbb\x2b\x15\x5f\xaf\x7e\x5c\x1d\x65\xec\x5e\xbb\xa8\x53\x89\xbb\x7b\xc1\xe0\x75\xd3\xfc\x81\xa6\x89\x13\x1b\x7c\x70\xaf\xbf\x58\x79\x2f\x19\x59\xb6\x7c\x7a\xb6\xda\x95\x30\xa9\x43\x66\xaf\xe1\x65\x33\x03\x47\x7a\xb6\x2f\x18\x5d\xee\xec\x1b\xe6\x0b\xbc\xb4\xab\x4d\xad\x40\xc1\xe0\xf2\xcb\x07\x05\xa6\xa6\xac\x5a\x6e\xe6\xa8\x8a\x8f\xd2\x7a\x29\xc3\xec\x3d\x6e\xc9\x70\x55\x11\xbd\xf4\xf4\x9a\xec\x71\x6d\x02\xed\xea\x2d\x37\x1b\xf5\x18\xd1\x44\xad\x08\x9f\xa2\xff\xbc\xdb\x29\xcb\xac\xaf\x5c\x3d\x9c\x83\xf5\x1a\x2d\x0d\xa5\xb9\x74\x50\xcf\xf8\x2d\xc3\x14\xd5\x22\x25\x2d\xb9\x9e\x23\x3a\x42\x99\x8e\x88\xe4\x14\x57\x66\xc7\xa6\xed\x9e\x2a\xf1\x35\x7d\x7a\xa4\xaf\xe5\x53\x25\xe2\x6b\x10\x16\xfb\x54\x49\xed\xb0\xa7\x47\xd6\x6e\xf0\x54\x89\x51\xdb\x71\x6b\xa6\x5a\x99\xa9\x16\x65\xaa\x19\x99\x6a\x58\xa6\xea\x98\xa9\x1a\x64\xaa\x5a\x99\xea\x6c\xa6\xfa\x36\x53\xed\xce\x54\xcf\x66\xaa\xfb\x33\xd5\x75\x99\x6a\x7e\xa6\x9a\x98\xa9\xfa\x64\xaa\x2e\x99\xaa\x75\xa6\x4a\xce\x54\xe1\x99\x6a\xd2\xe9\x4c\x75\x2c\x53\x7d\x98\xa9\x6e\xce\x54\x97\x66\xaa\x8b\x33\xd5\xc8\x4c\x55\x90\xa9\xba\x65\xaa\x26\x99\xaa\x9e\x2d\xe2\xa1\x4c\x15\x54\xb3\xb0\x5a\x44\x47\x7b\xf0\x69\x5b\xc7\x27\xd5\x6a\xee\xb5\x85\x4c\xce\x54\x59\x99\xaa\x65\xa6\x4a\xca\x54\xb5\x33\x55\x26\x86\x1c\xc9\x54\x1f\x64\xaa\xd7\x32\xd5\x53\xb6\xa0\xeb\x6c\xa6\x92\x6a\x35\xca\x91\xa9\x4e\x66\xaa\x2f\x33\x95\xbf\xcb\x1e\x5b\xd0\xe3\xb6\xb2\x25\x99\xaa\x3c\x53\x0d\xb5\x65\x9d\xb6\xd5\xbc\x63\xf7\x2e\xcd\x54\x73\x6d\x2b\x07\x66\x2a\x23\x3b\x53\x79\x32\x55\x54\xa6\x72\x8f\xb9\xf0\xc2\x3c\x7b\xec\x3f\x2d\xb4\x17\x5a\x8c\xc7\xfc\xc3\x42\x9c\xa1\xff\xd1\x4b\x82\x5d\x90\x71\xe4\x57\xc6\x9f\xff\xd7\x36\xdd\xc9\xba\xa8\xe2\xdd\x86\xcf\x1b\xd3\x3e\x96\x65\x59\xc5\x67\xb4\xeb\xae\x3a\xb4\x6f\x9a\xd2\xb8\x8e\xfa\xe7\x8e\xd2\x9b\x1d\x0f\xde\x72\x36\xa1\x56\xcf\xc0\xf3\x81\x7f\xef\x7f\xfa\x9a\x95\x81\xc6\x83\xb3\x46\xb5\x6f\x9e\x9e\x55\xdc\xce\x11\xb8\x60\x73\xbc\x73\x62\xc0\x6a\xd5\x33\xb0\x4a\x99\x1f\x2b\xd7\x15\x81\x65\xd7\xcd\xde\x3d\xb4\x60\xc0\xbc\xfd\x81\xe4\x0b\xb5\x92\x5d\xed\xac\xef\x5c\x5e\xe7\x20\x69\xca\xec\xed\x22\x0b\xfd\x79\x19\x0e\x67\x94\x23\xba\x6d\x7c\x7a\xb3\x46\x0e\x6f\x74\x5c\x5b\x6f\x47\x89\x13\xaf\x99\xe8\x8e\x6c\x99\x18\x99\xd8\xad\x6b\xa4\x3b\xdc\x3d\xa0\x24\x3c\x3c\x2e\x3e\x3d\xca\xd9\xcc\xd1\x28\x23\x2c\xa5\x7e\x4a\xd6\xc0\x92\x14\x47\xfd\x36\x85\x25\xf5\xeb\xc5\x45\x0f\x28\x89\xab\x2b\xd9\x1a\x0f\x9b\xd8\xa2\x00\x84\x5d\x2a\x38\x27\xed\xf9\x18\x93\x11\x5b\x0d\xd2\x9f\xb3\x31\xbe\x8e\x72\x93\x39\xcd\x32\x7d\x51\x8a\xaa\x47\xb9\x7d\xcd\xea\xa8\x14\xbd\x99\x75\x57\x99\xc1\x2d\xad\x91\x52\x75\x8c\xba\xf1\xf5\x32\xda\x65\xaa\xf8\xfa\x21\xac\x5c\x8e\x82\xbc\x45\x77\xa9\x4e\x33\x1a\xce\xad\xa5\x3e\xad\xb5\xa8\xcd\xba\xc2\x47\x2f\xab\x15\x58\x3f\x61\xfe\xc1\x2b\x8f\x7e\x5f\xb2\x61\xe3\xb0\xb7\xb7\x4d\xbf\x73\xe8\xd9\x1d\xc3\xfa\xb6\x58\x3c\xf9\xd5\xeb\x03\x9f\x16\xce\x1b\x5e\x90\xd5\x77\x80\x63\xc0\xe0\x79\xc5\xd9\x81\xbb\x1f\x59\x97\xe8\xf7\x27\x4e\xfb\xbe\xf8\xe5\x06\xd9\x0b\x06\x76\x7b\x76\x5b\xf9\xba\x29\x99\xcb\xd7\xaf\xaf\xec\x31\xff\xec\x6f\xad\x06\x5c\xdc\x67\xf6\x35\x0b\xcc\x82\x59\x73\x3a\xce\xee\x3f\x74\x54\x05\xf3\x53\xa9\x44\x73\x94\x11\x63\xef\x9b\xad\xfd\x89\xf6\x86\x69\x3a\x9c\xe7\x6f\x97\x7a\xb7\xd4\x9b\x65\xcd\xfd\x59\xef\x92\x29\xa1\xcd\x51\x94\x4c\x08\xf4\x33\x53\x9d\xab\x99\xe5\xcd\xfd\xf1\x66\xad\x5a\xe2\x72\x45\xc7\xd4\x8a\xfc\xb5\xa4\x96\x98\xc6\x2f\x25\x66\x92\x54\xa3\x78\x4e\x44\x6a\x74\x7d\x77\x53\xa3\x43\xfb\x44\xc0\x72\xbb\x22\x94\x1a\x72\x77\xbd\x5d\x4f\x96\xdc\xf5\xfb\x3b\xf5\xae\x7d\x71\xfe\x82\xc0\x9e\x35\x15\xb3\x54\xe7\xa3\x0f\xa9\x7f\xa9\x16\x9f\x94\x5f\x3e\x22\xf0\xe0\xd9\x8f\xb5\xcd\xd6\xa4\x40\x3f\xa3\x59\xb5\x2e\x37\xab\x4c\xad\x5a\xd1\x31\x61\xee\x5f\x4a\xc2\xe8\xfd\xb5\x44\x2e\xa0\xcb\xcc\xec\x98\xa8\x3a\x44\x37\xcb\xac\x17\x5b\x37\x3e\x42\xb9\x6e\xad\x7b\xf5\x8b\x97\xdd\x15\xbb\x7b\x4b\xc9\x9d\xbf\x05\xfa\x5d\x3e\x42\x0d\x32\x5a\xbd\xae\xda\xad\xae\x98\x1f\xd8\xf3\xc5\x7d\x81\xb1\x81\x0f\x0e\xe9\xf5\x4b\xc9\x3d\x46\x07\x47\x84\x73\xa8\xc4\x48\x92\xbf\x4e\x44\x5c\xac\x57\x15\x2a\x63\x8d\x52\x2a\xc2\xa1\x31\x19\xad\x75\x80\x46\x5c\xb3\x38\x67\xb3\xd6\x2a\x33\xce\xac\x6f\xa6\xd6\xaf\xad\xdc\xc6\x82\x7a\xc7\x2e\x09\xec\xec\xaa\xba\x05\x3e\x5f\xfc\x6b\xdc\xb1\xcb\x94\xbf\x5b\xe0\x05\xd5\x6c\x89\x79\x69\xe0\xb9\x54\xd5\xf6\xb9\x2f\x9a\x5d\xf7\x4a\xe0\x84\xca\x69\x12\x78\x6f\xeb\xa7\x4d\xaf\x79\x09\x5d\x8b\x64\x8f\xa3\x83\xe3\x6a\xa9\x25\xb9\xfe\x26\x12\x1e\x6e\xba\x5c\x11\xce\x08\x67\xed\x48\xd3\xa8\x53\xe2\x72\xd7\x11\xb7\xaa\x6d\xba\x5d\x7e\x31\x5d\xe6\xa3\x25\xe1\xae\xad\x7a\xc2\x92\x8c\x89\x09\xd1\x7b\xd9\x31\xec\x39\x4b\x56\xc6\x9e\x8b\x51\x4c\x4a\x8c\xaf\x83\x8f\xec\xf4\xd5\x35\x36\xad\x09\x4c\x55\xeb\xd7\xa8\x9b\x8c\xd2\xc0\xc5\xea\xa6\x35\xea\xe6\xc0\x94\x35\xb6\x8f\xd6\x07\x81\x57\xd4\x70\xd5\x5a\x62\xa5\xb1\x3f\xc6\xac\x5d\x1b\x18\xe3\xe2\xa3\xcd\x07\x47\xc6\x45\x3f\x34\x32\x5a\xd2\x5a\xfe\x25\x6a\xf1\x2e\x77\x87\xee\x84\xad\x69\xb3\xd0\xe9\x4c\x0d\x7f\xed\xf9\x4e\x83\x5b\x25\xb7\xe8\x3d\x22\x77\xe8\xa4\x29\x77\x1c\x6c\x3b\x2a\xaa\x5b\xbf\xc6\xf5\x7c\x89\x2d\x87\xf4\xc8\x99\x1a\xc4\xb1\xa5\x5a\x69\x94\x1a\x59\x64\x52\x3d\x7f\x84\x18\x0e\xa7\x92\x67\x4a\xd4\xf3\x12\x8c\x12\x10\xc6\x65\xfa\xdc\x2d\x7d\x46\xbc\x4f\xad\x7c\xec\xb1\xe0\x98\x28\xeb\xa8\x1a\xa9\xd2\xc0\x23\xc1\x5f\xcb\x0c\x0f\x8f\xac\x2d\xae\xdb\x47\x4a\x3d\xa9\x0e\x6d\xdb\xf4\xfa\x35\x8e\x88\x4f\x86\xce\x86\xc9\xe7\x8e\x85\xf8\xb6\xcc\xfa\xce\xf8\xd0\x99\x8b\xde\x86\xfe\x48\xbd\xef\x98\x4e\xe5\x30\x1c\xac\x05\xd9\xd9\xf6\xe9\x23\xb8\xb4\xd5\x67\x69\x8b\x5e\x65\xbc\xb6\x2a\xde\x59\xa2\xff\x59\x92\xf4\xb6\xbe\x33\x0f\xb1\x6f\xd5\x92\x06\x3a\xcb\xe2\x5c\x91\xe2\x92\xc4\xa4\x88\xa8\xb9\x25\x11\x6e\x47\xdd\xb9\x25\x8e\x06\x35\xb2\x2c\x2b\x28\x45\xc5\x1b\xae\x14\xbd\x06\x76\xcc\xf0\x9a\xf6\x8c\x66\x43\xce\x68\x47\xea\x99\x87\xd6\x9d\x79\x32\xf0\xe8\xba\x3f\xb6\xa8\x92\x5f\x33\x73\x87\x5d\x3a\xe6\x92\xdc\x8a\x7e\x1d\xcc\xa7\x8f\x06\x6a\xfd\x5b\xdd\xf3\x9d\x3a\xfe\x43\x60\xc1\x8a\x35\x47\x03\xe6\xfa\xc0\xb7\xcb\x55\x8c\xaa\xc0\xff\x74\x0e\x26\x6d\x9d\xf9\x12\x21\x59\xfe\x86\x11\x22\x2e\xa7\xb3\x56\xa4\x2b\x8c\x34\x08\x37\xdd\xfe\x88\x70\xb7\x38\x4d\xe7\xdc\x12\x33\x41\x03\x62\x1f\x1d\x12\x75\x1e\xb4\xcb\xaa\x19\xae\xfa\x6e\x5f\xb6\x8a\x73\x67\xa6\x66\x18\x3d\x7f\x88\x3a\x5b\x27\xea\x97\x2d\x67\xa3\xd4\xdd\xcb\xa6\x27\x0c\x1b\x96\x60\x7e\xdf\xbb\xe8\x33\x3b\x07\xaa\xd0\xf5\xae\xb3\x1f\xde\x76\xf6\x37\x74\x4a\x5c\x5c\x52\x62\x42\x24\xcb\x03\x53\x2b\x3a\x6c\x4e\x49\xb4\xdb\x48\x50\x09\xf3\x4b\xd4\x39\x5d\xf6\x77\x5a\xe8\x00\x67\xa7\x5c\xdb\xf4\x16\x2a\x33\x2c\xb8\x94\x45\x71\x7e\xef\xae\xec\xb8\xd4\x51\x0e\xa7\xcf\xcc\x3a\xf3\x98\x4f\x5d\xa5\xda\x95\x0f\x2a\xc9\xeb\x3f\xbc\xe3\xd0\x3b\x46\x3c\xbb\x6f\xc0\x2d\x01\x2b\xb0\xdf\xd8\xf4\xbc\x6a\xa9\x96\x3f\x34\xb5\xac\xfd\xcb\xaa\x6d\x6c\x83\xdb\xae\x1d\xb7\xe3\x89\xbd\x2f\x63\xd3\x49\x62\xb0\x1b\x9b\x5a\x48\xb9\xbf\x43\x93\xa8\x28\xc3\x57\xab\x59\xb3\x38\x9f\xef\xa2\x96\x89\x86\x71\x51\x93\xe8\xa8\xe8\xa8\x79\x25\xd1\xd1\x8d\x24\x31\xb1\x51\xa3\x7a\x73\x4a\x1a\xb9\x45\x9b\x6a\xaa\x42\xbd\x78\xb1\x6c\x11\xa2\x76\x69\x9c\xab\xe4\x9c\xb9\xb1\x59\x69\xf6\x5d\x23\x18\xfa\x73\x27\xa9\xac\x58\x32\xd0\xd9\x38\x78\x6c\x22\x60\xf8\x90\xa6\xb2\x55\xc7\x98\xf3\x7c\x71\xb9\x1b\xa9\xba\xf1\x0e\x35\xb2\x6a\x59\xeb\x51\x75\xe2\x16\x77\x5a\x71\xdb\xf8\xb2\x39\xf5\x66\xfd\x50\x5a\x34\xa2\x27\x6e\x4d\x5c\x55\xbc\xe3\xdd\xcd\xf7\x5f\xb5\x36\xf0\x5e\x7c\x73\x95\xfb\x51\xb4\xef\xce\xdb\xe7\xcc\xaa\xe5\xbe\x34\x2c\x4a\xd5\x9a\x30\x51\x3b\x98\x18\x73\xfb\xf2\xdb\xb6\x37\xa8\x7b\xdf\x25\xaf\x1e\xe2\x3e\x71\x18\xdc\x5f\x76\xe6\x10\xe3\x28\x29\xf6\xb7\xae\x6d\xd6\x32\x6a\x19\x61\x2c\xcc\x2e\x7d\x95\x8d\x74\x38\xa2\xeb\xd4\x66\x09\xad\x6d\xce\x2f\x09\x73\x8e\xaa\x3d\xb5\xb6\x51\xbb\xb6\x51\xcb\xed\x72\x29\x23\xc1\x3e\x59\x73\xb4\x4e\x1b\x1d\x3c\x4e\x6b\x7f\xfe\xf4\x8b\x23\x77\x3b\x5d\xad\x3e\x45\x67\x2a\x7d\x70\x36\x95\x2f\xae\xa3\xe9\x48\xfb\x3d\xed\xec\xfe\x86\xc6\xe9\x3d\x77\xdc\xe1\xfb\x2d\x60\xa8\x2b\x72\xb9\x82\xb0\x1c\xc5\xdd\x6a\x6e\x38\xb3\xfc\x19\xb3\xf1\xd9\x5b\xd4\x95\xb9\xe4\x60\x7d\x62\xb0\x87\xfd\xa1\x91\x4c\xf4\x67\xc5\x9a\x66\x62\x78\xc3\xe4\xfa\x0d\x92\xcd\x84\x84\xf0\xf0\x44\x8f\x37\x21\x5e\xe2\xe7\x96\x44\x89\x47\x38\xf4\x8a\x34\x70\x35\x68\x38\xbf\xa4\x81\xcb\x15\x45\x1c\x6a\xa9\xc2\x5a\x95\xb8\x53\xcb\x45\x1c\x32\xce\xc5\xc1\xbe\xe9\xe9\xe5\xaa\xc6\x36\x5a\xbf\xda\x6a\x6c\xd5\x38\x3b\x7c\x8d\x9b\xd6\x08\x06\x13\xc9\x8d\x07\x6e\x9f\xd9\xd1\x70\xbc\xf4\x56\xe0\xc3\xc0\x89\x82\xcb\x16\x10\x81\x86\xe5\xed\x97\xdf\xf4\x6a\xf3\xa9\xad\x46\x5f\x66\x6c\x6b\x72\xf6\xcd\xec\x11\x66\xa3\x6d\x0f\x1e\xfe\x25\xb2\x21\xe0\xd7\x4f\x7c\xfe\xf1\x9f\xea\xc6\x1a\x4f\xee\x09\xdc\xd8\x40\xcf\xe9\x3c\xfd\xff\xd1\xc7\xce\xf1\xa6\x52\xe0\x6f\x1e\x93\x98\x68\x7a\xc3\xeb\x99\xf5\x9a\x35\x8f\x4b\x99\x57\x12\x15\xe7\x89\xc3\x89\xb8\x38\x71\xbb\xeb\xcc\x29\xa9\x55\xcb\xed\x96\xe4\x39\x25\x12\x9a\xe7\x19\x69\x35\x4d\xaf\x71\x69\xd4\x89\xc3\x22\x14\xdb\x24\xa3\x9d\x7d\x0c\x4f\x69\x6c\xb8\x3b\x86\x32\x5f\xe9\x1d\xbe\xa3\x3d\x23\xdc\x2e\xb5\xe7\xb9\xdd\xdb\x54\xe6\x93\xeb\xae\xeb\x38\x3c\xdc\xdf\x7f\xe9\x6b\x69\x2b\x16\xdf\xfa\xc0\x25\x9f\x06\x4e\x0c\x28\x28\xbe\x78\x54\x7e\xef\x71\x51\xf1\xa7\x3e\xfb\x51\xdd\xf7\x5b\xcb\xc0\x3b\x2f\xb7\x0f\x9c\x38\xd1\xe7\xb1\x3b\xd7\x56\x2d\x55\x5b\xef\x7f\x70\xdf\xc3\x0b\x66\xb4\x98\x4d\x3c\x86\x71\xff\xcc\x21\x1e\x61\x92\xed\x4f\x71\x2a\x97\x2b\x3c\xc2\x6d\x9a\x11\xce\x04\x87\x11\x66\x84\xcd\x0f\x86\x62\xac\x3c\x2e\x2f\xea\xff\x9c\x9e\xe1\x0a\x21\x6f\x9b\x9e\x5d\x23\x3b\x58\x70\x35\xa2\xca\xa7\x7c\x81\xe1\x39\x66\x49\x9d\xb3\x29\x81\xb3\xa6\xeb\xec\x0f\xe6\x0b\x6a\xc9\xc0\xd3\xb1\x8e\xd9\x7a\x0d\x36\x25\x95\xf8\x7f\xc1\x3a\x58\x4f\xbc\x72\x91\x0c\xf5\x5f\x54\xc7\xac\x25\xf5\x63\x62\x7c\xb5\x1a\x8a\x34\x75\xd5\x72\xb5\x6c\x55\xc7\x6c\xd0\xbc\x41\xf3\xb9\x25\x0d\x1a\x84\xc5\xc7\x37\x9a\x53\x12\xef\x0e\x4b\x99\x53\x12\xf6\xe7\xfa\x28\xf6\xa1\x89\x22\xeb\xbc\xcb\x76\x28\x3b\x83\xd3\x2a\xda\x67\xaf\xe5\x99\x6d\x54\x68\x5b\x89\xaf\x8e\xbd\xf9\x67\xed\x8b\x6b\xe7\x0d\x19\x1b\x88\x7c\xe6\xd5\xbb\x57\xfa\x07\x1c\xff\xec\xa1\xc7\xcf\x7e\x36\xa5\x68\xe2\x9c\xa2\xd1\x77\xde\x36\x7d\xd6\xad\xd3\xe6\x38\xba\xad\x7e\x2d\xa5\xd1\xca\x89\x81\xf6\x4f\x6e\xda\xf8\xa6\xb7\xf1\x0d\x25\xcf\xbe\xb2\x26\xf0\xce\xfa\xe7\x6f\xdb\xb0\xed\xcc\x47\xcf\xbf\xf1\xdc\xd3\x7b\xed\x7f\x76\x2a\x8d\xec\xf5\xbd\xa0\x3a\x17\xc8\x03\x9d\x0e\xf5\xcc\x60\x2e\x48\x5c\xf4\x79\xb9\xd0\xc0\xce\x05\xf7\x3f\xe7\x82\xed\x92\x4e\x5f\x0e\x18\x86\x23\xc5\x5e\x4b\x08\x7e\x6c\xa6\x2b\x74\xf2\x53\xf6\x86\x10\x3c\xf3\x75\x34\xfa\x3d\xf9\xc9\x63\x81\xb7\xb6\xdd\x7d\x2d\xb9\xd0\x63\xcc\xa2\x97\xda\x5c\x75\xc5\xc6\x47\x2f\x39\xa8\x12\x86\xf4\x2e\x9e\x36\xb8\x6f\xff\x29\x91\xce\x82\x80\xf5\xf1\x2f\x81\x71\x27\x5b\xaa\xb6\x2f\xb7\x57\xae\x93\xd9\x3b\xee\x5b\xfe\xd9\xa2\x40\xf3\x47\x5f\x7f\x7f\xf3\xec\x99\xcd\xca\x6c\x3f\x72\xad\xa3\x46\x43\x73\x27\xfb\x54\x7d\xbd\x4f\x85\x9b\x66\xdd\xa8\xa8\x84\x06\x91\xb1\xb7\x8f\x8c\xac\xe7\x92\xdb\x47\xba\xa2\xff\x7e\x1a\xaa\xf9\x62\xc5\xac\xf9\x92\x65\x7e\xde\xd8\xd1\xf9\xbd\xc7\x96\xbe\x1b\xda\x4a\x8d\xb9\xa5\x79\x79\xa5\x65\xb9\xb9\x65\x67\x67\xfc\xb9\xab\x6a\xbd\x89\x81\x57\x8c\x26\xe8\x8d\x65\x65\x48\xf7\x27\x36\xac\x57\x4f\x1f\x1b\x38\x3c\x78\xbc\xfa\xe4\xe0\xe1\xe4\xd0\x20\xee\xf6\x91\x0d\xb4\xf6\x1a\xe7\x87\x98\x7f\x38\x43\xfc\xc5\x8a\x3b\x6a\x9e\x27\x3c\x21\x93\xfe\x76\xae\x50\x5b\xff\x7f\xac\xbd\x09\x7c\x14\x45\xf6\x38\x5e\xaf\x8f\xe9\x39\x7a\x66\x7a\xee\xfb\x4e\x26\xc7\x24\x24\x10\x42\x20\x04\xd2\x84\x2b\x9c\x09\x97\xd0\x04\x48\x94\xfb\x90\xfb\x50\x50\x89\x88\x07\x22\x82\x27\x9e\x88\x27\xfa\x15\x05\x05\x5d\xbc\x71\x17\x5d\x58\x75\x61\x0f\xdd\x75\x5d\x15\xaf\x75\xdd\xf5\xc0\x6b\xbf\xab\x90\xce\xbf\xaa\xba\x67\x32\x09\xd9\xef\xf7\xf7\xfb\xfc\xfe\x4a\xba\x7b\xba\x5f\xbf\x7e\x55\xf5\xea\xd5\x7b\xaf\x5e\xbd\xca\xd2\x46\x74\x85\xf9\xe8\x11\x2e\xc2\x3d\x86\x07\xe9\x59\xf2\x40\xc6\xc0\x81\x01\x8c\x02\x47\xf4\x26\xce\x56\x6f\x00\x43\x1c\x41\x1b\x07\x88\xab\xe4\x9a\xb9\x36\xae\x9d\xdb\xc5\x19\x10\x17\xa7\x3f\xdb\xb9\x83\xdc\x29\xee\x34\x67\xe4\xb0\xb1\x7e\xb8\xa8\xac\x91\x3b\x84\x02\xf5\x19\xac\xef\x56\xe1\x01\x35\xa7\x56\x51\xca\x5d\xd5\xe0\x31\x81\x67\x3e\x7b\xa4\x03\x98\x4e\x66\xd3\x4c\xf8\xe3\x4e\xf5\x46\x75\xc7\x4e\x52\x27\xeb\xe1\x16\xae\x0f\xfb\x22\xf5\x41\xcd\x92\x87\x0a\x0c\x07\x0c\x18\x4d\x82\xe1\x09\xa5\x4d\x38\x2a\x30\x48\x68\x17\x76\x09\x6c\xbb\x00\x76\xa1\x49\x60\xf0\x20\xce\x32\xf8\x11\x7b\x94\x68\xda\xed\xec\x2e\x16\x1f\xc0\xce\xd6\xb3\x4d\x44\xe7\x26\x1e\x81\xd5\xb8\xe5\x08\x93\x91\xab\x7c\x3d\xc3\x93\xa8\x26\x7f\x5c\x9f\x73\x8d\xec\x91\x73\x8d\x4c\x6a\xd7\x2e\xb8\x73\xe7\x4e\x5c\x0f\x77\xe2\x7a\x98\xd4\xb3\x1e\x18\xce\xa6\x20\xc6\x56\x8f\x9f\xc7\x0d\x7c\x1b\x03\x88\xa9\x64\x9a\xb1\x3e\xd6\xce\xec\xc2\x22\x82\x89\xd3\x9f\xed\xcc\x41\xe6\x14\x73\x1a\xcb\x11\xbd\x1e\x98\xff\x5c\x0f\x35\xd5\x26\xc0\x24\xdc\xc9\xa2\x0e\xc4\x1e\x79\x64\x27\xac\x81\xd5\x3b\xd5\xb2\x99\x94\x37\x9e\xeb\xfc\x84\x7d\x16\xcb\x59\x2f\x4a\xa2\x55\x72\x43\xdc\xc1\x09\x42\xd0\x8c\x82\x28\x55\x20\x70\xf7\x2a\xe6\x0a\xe1\x80\xc0\x54\xe0\x5a\x30\xc4\x0c\xb8\x16\x0c\x72\xa8\xb0\x51\x30\x08\x06\x77\xc4\x17\xb9\xbb\xc5\xe7\x5d\x21\x01\x92\xb0\x8e\x23\x49\x6e\xb7\x78\x8f\xe2\xe6\x74\x9d\x83\xd6\x84\x26\x50\x70\xdf\xab\xc8\xd0\x8a\x19\x94\x25\x8b\x88\xb5\x7e\xfd\xa8\x38\xb1\x33\x29\xac\xf0\x3b\x88\xc4\x20\x83\x37\x95\x26\xf9\x2c\xff\xec\x33\xaf\x4c\xaa\x5f\xc8\x2c\xfd\xe1\xa5\xf4\x94\xe0\x30\xa5\x78\xcf\x5d\xbf\x7a\xbb\xe3\xd1\x51\xad\xad\x84\xc5\x39\xd7\xe3\xbf\xed\xef\xfd\x0d\x0c\xf2\x55\x81\xf3\x8d\x90\xfb\x97\x50\x54\x79\xff\xd9\x81\x84\xd9\x34\x5f\x23\xaa\x54\x37\x19\x56\x61\x9b\xa0\x16\x8d\x42\x47\xe4\xf5\x83\x25\x5f\xd0\x3c\x2c\xc8\xca\x95\xb2\xc4\xb2\x45\x35\x71\x96\xad\x19\xdd\xe8\x69\x78\x5b\x11\xc2\xef\x28\xd6\xa1\x7f\x52\x2a\xaa\x04\x6b\xab\x67\x85\x87\xb1\x5b\x5b\xad\x2b\xf0\x18\xcf\x7a\xac\x1e\x2b\xc2\xa3\xf6\xdb\x4a\x15\x4a\xbd\xad\x20\xee\x4c\x23\x9c\x6e\x84\x53\x8d\x70\xb4\x11\x0e\x36\xc2\xde\x46\xd8\xd5\x08\xed\x8d\xb0\xb2\x11\xda\x1a\xa1\xb9\x11\xe4\x46\xa8\x6c\x84\x78\x23\x48\x8d\x80\x1a\x61\x55\x0f\x67\xea\xec\xd9\xb4\x9b\x57\xe4\x6a\x87\x54\x0e\xa9\x94\x4c\x5e\xbb\x11\x1b\xd5\xa7\xf7\x41\x88\x23\x07\x15\x54\xe9\x9c\x71\xca\x90\x11\x0c\x4b\x28\x2c\x6d\x9d\xd5\xfd\x51\x2a\xc9\x61\x13\xd5\xc9\x11\x5b\xbe\xc6\x67\xc0\xa0\x05\x4c\xb5\xe4\x44\x2c\x15\x61\xae\xa2\xa4\x60\x03\xf6\x4d\x18\x0e\x17\x1d\x54\x3f\x7c\x68\xf8\x2c\xe3\xc8\xdd\xd5\xd3\xe6\xcf\x3f\xf6\xa7\x43\xd3\xdb\x2e\x8d\xf6\x1f\xbf\xa5\x59\x3d\xfb\xb7\xdf\xab\xcf\x3d\x77\x13\x38\x9f\x5b\x7c\xe8\xce\xb6\xfe\x37\xaa\xef\x1c\xfc\x54\x7d\xf0\xe5\x6f\xe1\xd1\x91\xc5\xe1\xe1\x13\x36\xd7\x2c\xae\x2f\x6b\xe4\xa7\xaa\xaf\xa8\xef\x1f\x57\x0f\xbc\x3c\x6e\xe0\xa0\xb1\x57\xae\xba\xf9\xbb\x5f\x5c\x60\xe9\xf8\xc7\x15\xd1\x01\xb7\x81\xff\x8e\x6f\xc0\xf8\xb1\xba\xb0\xe3\x79\xf5\xfd\x07\xd2\x23\x47\x8d\x5f\xbd\xe0\x45\x68\xf9\x33\x44\xe0\x4d\x80\xb3\x5f\x36\x0c\x93\x99\x62\xbe\x61\xa0\x4a\xf8\xae\xf3\x76\x6c\x0a\x32\x58\x5f\xb6\x63\xa9\x34\x4d\xce\x38\x6c\x76\x3b\x67\xe0\x9d\x56\x49\x14\xb1\x32\xc5\xb1\x2e\xb7\xd5\xe6\xb0\xb5\x29\x4e\x87\x83\x91\x78\xce\x2e\x62\x01\xc1\xb5\x2a\x66\xc6\xa9\x1b\x52\x55\x44\x87\xc6\xfa\x94\xae\x4d\x69\x0e\x10\xa2\x47\xf5\xc3\x67\x32\x54\x15\x12\x65\x1a\xaa\x5c\x54\xa9\x66\x13\xac\x09\x8f\x9f\x7d\x6c\xea\x7a\xdb\x42\xe6\x9e\x33\xea\xc5\xb6\x8e\xf7\x6c\xd7\x0f\x51\x8b\x8f\x30\x3e\xf5\x5d\xb8\x61\xcc\x98\x31\x21\xee\xd3\xb3\xe1\x10\x3e\x43\x8b\xfa\x30\xfb\x73\xc7\x49\xe2\x6b\xfc\xaa\xf3\x67\x6c\xd6\x0d\xc1\x52\xc2\x81\x0a\xd0\x72\x79\xb0\xdf\xe7\xf3\xc6\x84\xb0\x60\xc7\x46\xb3\xe4\xb5\x24\x93\x4c\xd8\x1b\x2e\x4c\xc7\x04\xbb\x60\x6f\xc3\xa3\x0e\xb6\xd2\x05\x21\xe0\x0e\xf8\x5a\xb1\x6e\xd5\xa6\x04\x58\xb7\xd4\xa6\xb8\xbd\xad\x8a\xdb\x49\xc4\x2b\x91\xee\xdd\x06\x24\xd4\x6d\xa0\x25\x5c\xa0\x59\x85\x5a\xbb\x63\xa5\x36\x03\xac\x8b\xea\x25\xf8\xc2\xeb\x2b\x24\x16\x42\x51\x4d\x22\xee\xc8\x2a\xb8\xcc\xc3\x50\x77\xe9\x3a\x65\xca\xe8\xc7\xf6\xdc\xb1\x7b\x75\xdb\xe2\x71\xea\x3e\xf5\x65\xf1\xe9\x13\x8f\xda\x98\xb1\xf0\xb7\xa7\xf6\xde\xf1\x84\xfa\x1a\x73\x0e\xec\xad\xf3\xd5\xf2\x8e\x65\xb7\xdc\xb5\x71\x73\xc7\x69\xc3\x72\x03\x2e\xee\xfa\xe0\x18\xf5\xbd\x1d\x8f\x79\xad\xfb\xb6\xfe\xee\x04\x96\x37\x58\xe7\xe2\x17\x63\x59\x10\x45\x75\x72\x2c\x64\x32\xc5\x5d\x2c\x1b\x8b\x0b\xf6\x56\x32\xa8\x72\x28\x88\x2d\xda\x60\x10\x21\x5c\x16\x62\x92\xe5\xba\xb9\x36\xc4\xc2\xa0\x9c\xeb\x09\x73\x6b\x56\xc5\xaa\xee\x03\x1a\x6b\x12\xdd\xaa\x1e\x6b\xb5\x06\x8e\xd9\xa3\x7e\xa2\xbe\x76\x0a\xb6\xfc\xfb\xe3\xff\xae\x9e\x3a\xe0\xce\xa9\x0f\xab\x3f\xdd\x7c\x64\xdf\x45\xaf\x0f\x99\x30\xad\x61\x95\xfa\xb5\x1b\x8a\x00\xfd\x0b\x36\xbc\xd9\x5f\x3d\xf0\xcb\x4c\xc5\x11\xf5\xa9\xdf\x9f\xfc\xfb\xa0\xb2\xbf\xaa\xfb\x0b\x2b\xe8\x78\xd6\xf9\x6d\xe7\x39\x7e\x37\xd5\xab\x7c\x98\xd2\x24\x12\x59\x8f\x87\x73\x8b\xee\x80\xdf\xe7\x69\x55\x7c\x6c\x1b\xfe\x73\xba\x5b\x15\x27\xae\x7f\xa7\x73\x6f\x00\x66\xe7\xd5\x7c\xbe\x32\x08\x52\x22\xc5\x62\xca\x50\xb6\x83\x15\xa6\x68\xed\x72\x6d\xea\x85\x85\xaf\x4d\x2b\xfa\x01\x02\xea\x35\x30\x09\xda\xde\x50\xaf\xfe\x59\x9d\xfd\x2b\xf1\xa9\x13\xfb\xac\xac\x01\x4e\x9c\x7d\xd0\x08\x0b\xd8\x8b\xd5\x8f\xd4\x7f\x7d\xa3\xee\x3e\xca\x69\x95\x49\x6c\xb3\x6f\xb1\xce\xf7\x13\x9d\x73\xb8\x4c\x1e\x67\x76\x98\x4c\x4e\x27\x0a\x85\xac\x3e\x96\x8b\x84\xed\x0e\xb3\xa3\x4d\x11\xad\x66\xb0\xb0\x66\x33\x13\x08\x38\x31\x7f\x84\x5a\x15\xbb\x37\xe6\x6d\xf2\xb6\x7a\x57\x78\x79\x27\xeb\x95\x43\xd1\x46\x6f\xc0\xc9\x98\xda\x14\x9e\x61\x50\xab\xc2\xb0\x52\x04\x56\x6b\x15\xae\x79\xfc\x74\x07\x82\xce\x44\xf9\x3d\x40\x63\x20\x5c\x32\xcc\x22\x6c\xaa\x86\xf0\x4c\xa2\xa6\x0a\xab\xba\x09\xb6\xaa\x1f\xa9\x7f\xd2\x27\x36\xec\xb3\x72\xe1\xba\x16\xc3\xc5\x7f\xbc\x7e\x3a\x04\x06\x29\x63\x14\x4e\xfd\xbc\xe5\x17\x1d\xd3\x16\xb6\x4c\x3d\xfb\xa0\xf8\x14\xf7\x17\xcc\x18\x8f\xbf\x6b\x53\xdd\xb7\xaa\xf3\xee\xe8\x38\x2b\xfd\x5b\xbd\x7e\x4c\x48\xf3\x3f\xe0\xde\xcb\xf7\xc7\xe5\xf3\xa3\x2b\xe4\x46\x8f\xd9\x60\x0e\x3a\x91\xc3\x01\x80\xad\x9c\x40\xd0\x87\x3b\x33\x66\xf6\x7a\x67\x93\x93\xb1\x3a\x71\x29\x9d\x4e\xce\x64\x22\x65\x36\x99\x84\x56\xc5\xc4\x82\x81\x33\xb4\x2a\x9c\x53\x0a\x42\x7b\x10\x2a\x83\x70\x3a\x08\x47\x83\x40\xdc\x9a\xab\xf3\x8d\xd5\xae\xc2\xe5\x4a\x97\x2b\x1c\xed\xe6\xc4\x4e\xd2\xac\x65\xad\xa0\x7d\x20\x57\x52\xa6\x6c\xfa\x5f\xc4\x8e\x16\xf1\x21\xdc\x56\xdc\x74\x79\x8e\xb9\x6f\xe7\x98\xeb\x67\xc3\xd2\x21\x4a\xb3\x02\x4c\xb3\xea\x26\x5d\x9c\xf2\xfe\xee\xaf\x04\xa1\xe3\x9b\xff\x52\xeb\xf6\x6b\x3e\x0c\xc2\xff\x07\x31\xff\xc7\xd1\x45\xf2\x20\x3b\x72\x87\x42\x9e\x20\x0a\x26\x0c\xc9\xa0\x87\x30\x96\xdd\x17\xf3\xd5\xfb\x9a\x7c\x9c\x89\xf5\xf9\x38\x67\xd4\xd9\xaa\x44\x5d\x9c\xa5\x55\x91\x8d\xcd\x46\x66\xaf\xf1\x0c\x56\xea\x8d\x1c\xf7\x1f\xed\x27\xd0\xa8\xd7\x79\xcf\x95\xed\x22\x35\xe9\x5c\x0f\xa9\x71\x51\x47\x24\xee\x24\xa9\x38\x1a\xf5\x36\x5c\x73\xf6\x5f\x9f\xd5\x4c\x85\x4b\x8e\xdf\xa7\xaa\x3b\x1f\xbf\x67\xcb\xd2\x11\xfb\x44\xe6\x02\xf1\xba\x09\xb7\xaa\x3f\xdc\xa9\x7e\xae\x9e\x60\x2c\x67\x61\xe3\x9b\x43\xd5\x37\x9f\x6c\x79\x41\x7d\xfc\xaf\xaf\x7f\x90\x81\xcb\xe2\x23\x46\xc4\xd5\xf1\x7d\xca\x30\x4f\x6b\xfc\x68\xb8\x98\xf2\xe3\x46\x59\x36\xf9\x8d\xc6\x40\x80\x65\xcc\x3e\xaf\xd7\x62\x71\x48\x8c\x84\x0d\x44\xbf\xc9\xdf\xa6\x98\xed\x26\x20\x6e\x1b\xc4\x4b\x16\x23\xcb\xb3\xad\x8a\x95\x67\x03\x5e\x07\x83\x0d\x14\xc5\x8d\x9c\x95\x11\x68\x8f\xc0\xec\x55\xd8\x48\xcf\x09\x5f\xed\x02\x37\x46\x37\x2e\x1c\x94\xd7\x50\x59\x6e\xd4\x7a\x15\x29\x59\x42\x3f\x6b\x6d\x97\xc0\x67\xbb\xf5\x20\x6e\x28\x66\xb3\xf5\xa9\xe9\xf0\xf7\xe9\xf8\xea\x4a\x2b\x96\x5d\xd6\x0e\x7c\x63\x8e\xea\x9f\xb3\xcf\x3a\x36\xc8\xad\x23\x4d\xa6\x4a\x70\x86\x9c\xcf\x6e\x0f\x8e\x1d\x1b\x64\x7c\x1d\x5f\x04\xc7\x6a\x3c\xf9\x25\x09\x4e\xc5\x65\xb4\xa0\x31\x72\xa9\x85\xfa\x5e\x44\xab\xc5\x60\xc4\xac\x86\xcb\x82\x68\x1f\x72\xae\xb4\x42\xb3\x15\xe2\x56\x68\xa7\x17\xc8\x0a\xb3\xcf\x63\xbb\xf3\x7d\x31\x94\x5a\x38\xb5\xcf\xda\xb1\x25\x47\xe7\x3c\xf2\x7d\x8d\x26\xed\xfb\xe7\xb0\xad\x3a\x00\x7f\xdf\x85\x6a\xe5\x98\x8b\x7e\xdf\x63\x71\x9b\xb0\xdc\xb7\x5a\x4d\x2e\x9d\x00\xb6\xdd\x03\xb2\x07\xe8\xd8\x9f\x9d\x3b\xa2\x2c\x91\xd5\xf3\x73\x4d\x9f\x35\x47\x06\xd4\x30\xf3\xf1\x17\x97\x5a\xef\xbd\x31\xad\xfe\xf8\xee\x1d\x6d\x03\xa6\x70\xf1\x49\x63\x17\xd9\x49\xff\x1c\x13\x3c\xf7\xce\x9f\xbf\x8c\x42\xe5\xa1\xbe\x0b\x66\x68\xed\xcc\x1f\xc7\x34\x04\x50\xab\x5c\xe1\x77\xb9\x9c\x01\x31\x60\x21\x75\xe1\x73\xbb\x79\xab\x93\x77\x06\x43\x62\xc0\x88\x07\x58\xad\x5e\xec\x46\xd6\x4d\x3c\x52\x44\x5c\xe6\x46\xd4\xfc\x36\x1d\xd4\x4d\x53\xeb\x1a\x96\xba\xd7\x0c\xab\x51\x6d\x02\x7c\x0f\x04\x78\xfb\x69\xb1\x63\x3d\x15\x92\xcc\x3a\xeb\xbe\x16\x46\x5e\x65\x85\xc7\xac\xdb\xd5\x22\xb8\xf0\x1a\x51\xbd\x42\xfd\xf3\xec\x79\xd9\xce\x37\x26\xd8\xf1\x03\x23\x92\xb3\x3a\xa5\xa3\x26\x34\x86\xb9\xac\x1c\x65\xe5\xe7\xb5\xb8\x1c\x12\x6a\x96\xcb\x25\x84\x2c\x66\xb3\xc1\xe1\x94\x2c\x56\xdc\xcf\xac\xac\xd1\xdc\xaa\x34\xf1\xdf\x60\xcd\x41\x76\x79\x1b\x11\x8f\x47\x24\x9e\x37\x1a\xb1\xd0\x31\x3a\xf3\x46\xa4\xcc\xec\xac\x1b\xa9\x8b\x21\x31\xe1\xa4\x4a\x5d\x54\x04\xea\xed\xfa\xce\xaa\xb6\x6f\xd3\xeb\xa6\x2a\x67\x89\x64\x7f\xc4\xca\xec\xb6\xfe\x66\x89\x55\x00\x9f\xba\x34\x4b\x24\xa5\xe9\x33\x84\x84\x0b\xa8\xcc\xbb\x58\xae\xc1\x9c\x63\x75\x18\x45\x86\x61\x59\x93\xd1\xe6\xc7\xea\x80\xd3\xe9\x30\x3a\x02\x41\x87\xc9\x62\x6a\x55\xfc\x0c\x63\x13\x2d\xac\xcf\xc9\x1a\x0d\xc6\x56\xc5\x83\x39\xcd\xe0\x5c\x19\x24\x43\x10\xae\xd8\x2e\xcd\x85\x90\xd4\x6d\x72\xa2\x6b\x62\x35\x67\xf5\x27\x52\x16\xc8\x55\xb6\x0b\xba\xfa\x0d\xf3\x69\xf9\xfb\x2f\x1c\x10\xd5\x14\xad\x6b\xf8\xea\x61\xf8\x2b\xe3\xb3\xe2\x6b\xb1\x63\x85\xf8\xab\x17\xb8\x6b\xce\x7e\x90\xad\xe7\x73\xb7\xb3\x4b\xc6\x04\xcf\x5e\x4f\x7f\x27\x35\x7e\xfd\x0a\xb3\x05\x47\xf9\x75\x9a\x5c\xe6\x34\x1a\x4d\x26\xbb\x4d\x70\x51\xc6\xb5\xf1\x6e\x0f\x8f\xec\x4e\x3c\xe6\x1b\x19\x27\x6b\xb2\x89\xb6\x56\xc5\x20\xb8\x58\xd1\xb9\xd7\x43\x0a\xe1\xab\xd2\xb9\x57\x9f\x14\xee\xa6\xbb\x64\x87\x55\x8d\x37\x52\x79\x22\x1a\xb8\x13\x07\xac\xf0\xbe\xf5\xa9\xbf\xac\xe9\xf8\xe4\x99\x2e\xd2\x9f\x82\x43\x1a\x37\x9f\x4d\x73\x33\xce\x89\x39\xaa\xb7\x10\xdb\x64\x2c\x96\xc7\x3b\xb0\x3c\xb6\xa2\x08\xb1\x97\x51\x50\x70\x06\x9d\xb1\xa8\x17\x4b\x27\x2f\x67\xc3\xac\x60\x73\xf5\xe2\xd7\xd5\x7d\xb9\x54\xe3\x70\x42\xb2\x40\xf7\xf7\x70\x5e\x62\xeb\x73\x6d\x77\x5c\xb7\xf1\xad\x2d\xb7\x5e\x73\xf9\x6f\xb7\xaa\xb1\x47\xd4\xce\x1b\x8f\xc1\xdc\xcf\x1f\x01\xb8\xf1\x84\xfa\x20\x3b\xee\xe5\xbf\x1c\x57\xaf\x7e\xe1\xc5\x77\x5e\x87\xb5\x1d\xad\xdb\x7e\xda\xf3\x1d\x6c\x3e\x89\x4f\x67\xd4\x0d\xbf\xc6\x7a\x47\x27\xe6\xcd\x33\x54\xef\x08\xa0\x89\x72\x09\xeb\xf5\x86\xb0\xc5\x28\x98\xcd\x92\xdd\x1e\x0c\x99\x8c\x6d\x8a\xc9\x64\x75\x3a\x25\xac\x79\x08\x58\xf3\x60\xcd\x76\x2b\xae\x47\xab\x33\x27\x62\xba\xfc\x2b\xdd\x86\x33\xea\x8a\xd0\x35\x3c\xa1\xab\xce\xfa\x71\xc4\xb9\xc6\x5c\x75\xe7\x81\x75\x6b\x47\x2e\x76\x8f\x7f\xcf\xd2\xd1\x62\x79\xe0\x37\x8f\x8a\x8c\x4b\x05\x5e\x7d\x47\xfd\x82\xb9\xec\xb9\xfb\x2e\xd9\xd2\xf1\xe4\x72\xf5\x82\x6c\xcd\x1d\x7e\xfa\xdd\x33\xb4\xee\xd4\xc3\xb4\xee\xc2\xa8\x14\x0d\x91\xe3\x05\x9c\xc3\x13\x31\x23\x0f\xca\x94\x05\xe2\x58\x33\xe5\x1c\x45\x78\x1c\x76\xb8\xac\x98\x50\x2c\x0a\xad\xd8\x82\xd5\x54\x8b\xbc\xda\xa4\x5e\x49\xcd\x51\x2e\x10\x79\x54\xe3\x23\xc6\x47\x1f\x28\xea\xc3\x64\xab\x94\xef\x56\xd9\xfc\x8e\x8d\x9f\xef\x89\xaf\x5d\xe6\x19\x61\x2d\x7b\xb8\xff\x8c\x2b\x96\xcc\xb9\xeb\xab\xf6\x6c\xfd\xaa\x7f\xe8\xaa\x79\xb6\xec\x39\xf5\x85\xcf\xab\xfa\x1e\x31\x4e\x74\xc6\xfa\x2e\xdd\x63\xba\xf1\xfb\x5b\xb5\xaa\xde\x9c\xd7\x02\x54\xd7\xeb\xc0\x72\xcd\x88\xeb\xdc\x83\xb5\xd2\xb9\x72\x55\x14\x45\x22\x44\xd9\xf0\x60\x7b\xd3\xe1\x08\x58\x0d\xc4\x87\x81\xa2\x51\x2c\x01\xa2\x51\xac\x6b\x44\x70\x1b\x50\x4d\xc3\xa1\xa9\x1a\x6e\x2e\x4f\xba\x65\xf2\xfd\x5b\xf9\xb3\xf4\x55\x79\x8a\x53\x57\xfd\xc7\xa9\x13\x99\xd8\x0f\x6c\x51\xb6\x79\x98\xe2\x29\xb8\x93\xed\xa0\xca\x05\xe3\x03\xc3\xb9\xc7\xf6\x9e\xb8\x45\x54\x57\x9e\x2a\x7d\xe8\xf9\x4b\xd7\x8d\xbc\x88\x19\xa8\x96\x65\x9b\xe2\x91\xfd\xf7\x9c\xca\xa8\x12\x96\x6d\x03\x97\x3f\x78\xf3\x96\xd5\x1d\x7f\xc2\x3a\x46\x21\x1e\x2b\x22\xb8\x5d\x32\x68\x85\x2c\x25\x18\x77\xc0\x52\xe2\x2e\x29\x2b\xb7\x48\xbe\x70\x63\xe2\x48\xe7\x19\xb9\x0a\x5f\x58\x12\xc8\xe7\x8b\x62\x35\x3b\x24\x85\x18\x14\x6a\x0e\xed\x0d\x1d\x0c\x9d\x09\xf1\x36\x36\x14\xf2\x71\x08\xcb\x95\x36\x16\x2a\x59\x99\x6d\x67\x89\xf7\xc1\xd5\xe5\x3a\xaf\x22\xe2\x4f\x73\x21\x0e\xca\xd7\x76\xab\x7a\xb8\xcc\xfb\x18\xaa\xfb\x17\x24\xb2\x4e\x50\xe2\xe9\xf2\x45\x59\xe2\x2d\x3f\xf8\xee\xd3\xf2\x0c\x48\xee\x9a\x74\xf3\x9e\xca\xa6\x79\x8b\xe7\x35\x55\x82\x05\xd0\xe3\x0f\x0f\x54\x84\x49\x5b\x56\x5d\x39\x7d\xd6\x35\x1b\x26\xf7\x55\xff\xe4\x1e\x0d\x8b\xfe\xd4\xb7\x61\xe3\xb2\x01\xcd\xc3\x06\x0d\x1e\x39\x73\xed\xc4\x23\xaf\x66\xd4\x57\x8f\x0d\xbd\x68\x5a\xdd\xfc\xaa\x71\x4d\x33\x57\x8f\xff\xf3\x27\x44\xa7\xba\x0d\xb7\x5f\x9a\xb6\x5f\xbd\x1c\x73\xba\x5c\x2c\xc3\x98\x2c\x5e\x8b\xcf\x6a\x32\x99\x71\x0f\xc1\xba\xba\x99\x75\x51\x2d\x03\x39\xbb\x0d\xc5\xe4\x7f\xd0\x46\x22\x4d\x7c\x57\xe1\x56\xd1\x9d\x04\x39\x8d\xcf\x27\xec\x13\xff\x72\x7c\xc8\xc0\xed\xd1\x71\xd3\x1b\xb8\xa6\x86\x19\xd6\xf0\x6d\x95\x83\x8f\x9f\x12\x71\x0b\xac\xb0\x19\x7e\x82\x0d\xea\xb6\x9f\x0c\xe2\xd9\x5b\x42\x63\x30\x2d\xfb\x3a\xbf\x32\xc4\x30\x2d\x61\x34\x54\x8e\x71\x82\x10\x0e\x88\x56\x2b\x1e\x29\x9d\x91\xa8\xd7\x74\xa1\xe2\x75\x39\xb1\x5e\x0c\x61\x3c\x3a\x02\x9b\x67\x65\x66\xce\x0b\x3b\x72\x69\x43\xb5\x47\x4a\x90\x11\xa5\x6b\xe0\x2e\xa8\xee\x5f\xe3\xa2\x43\xf6\x53\xab\x7c\x60\xb9\xff\xad\xe8\x36\x2c\xf5\x8e\x5b\xef\xbd\xb6\x5c\xfd\xe4\xfb\x1f\xd4\xff\x76\xaf\xe6\x7e\x20\x43\xdf\xca\x2d\xc3\xd5\x1f\x9f\xdc\xc7\x5a\xe8\x40\xde\xd1\xf1\xd5\xbb\x27\xe4\x4b\x98\x5b\x30\x8d\x97\x74\x7e\xc4\x7f\x84\x69\xb4\xc1\x51\xb9\x53\x64\xcc\x78\xa8\x93\xec\xc8\x02\x31\xac\xb5\x89\x2c\x2f\xe0\x11\xdb\x26\xb0\x16\xce\xb5\x5e\x82\x79\x12\x5c\x20\x41\x3f\x09\x20\x2e\x81\x9b\x3a\x62\x7e\x90\xe0\x53\x09\x4e\x49\x70\x54\x82\xc3\x12\xec\x95\xe0\x56\x09\xb6\x4a\xb0\x92\x42\x37\x4b\x20\x4b\xd0\x5f\x82\x02\x0a\xcf\x49\xb0\x18\xbf\x70\x5a\x82\x3f\xd2\x17\x0e\xe6\xbd\xb0\x96\xbe\x30\xb5\xfb\x0b\x1a\xf6\x3f\x66\xb1\xef\x92\xa0\x9d\x42\xb6\x51\xc8\xfe\xdd\x89\xf8\x63\x6f\xd8\x46\x74\xff\xfc\x20\x8d\xd8\x63\x14\xdd\x43\x59\xb8\x66\x1d\x4e\x1e\xa6\x17\x0c\x43\x9e\xa1\x38\x8f\xd1\x8f\xe6\x10\x62\xa8\x4a\x09\x18\x0c\x24\xd1\x0f\x9f\xa1\x85\x39\x45\x09\xaa\xa4\x77\x72\x41\x13\xad\xff\xaf\x01\x71\x3d\x41\xbb\xb0\xd2\xa9\x1d\xcc\x2c\xbe\x2a\x12\x0a\x94\x37\x12\x61\x0d\x23\xa5\x8d\x85\x2e\x7c\xe2\x3f\x12\xb7\x76\xf4\x59\xa5\xfe\x61\xb1\xc8\xa4\xc4\x5d\xbf\x81\xcf\xb7\x88\xfc\x10\xac\xcf\x1a\xb9\x7f\x13\x91\x71\xee\x26\x76\x45\x88\xd8\x90\x68\x47\xe7\x47\xc2\x6d\x98\x07\xdc\x68\x84\x5c\x80\xcc\x60\x32\x98\x79\xbb\x1b\x8f\xcc\x5e\xb3\xdd\xad\xf1\x80\xd5\x66\x61\x58\x51\xe4\x1c\x02\x0b\x9c\x4b\x0f\xdb\xaa\xf0\x0d\xd2\xe8\xc8\x11\x81\x09\x22\xa1\x20\x2c\xa4\x58\x9d\x8e\x2a\x97\x46\x11\xf7\xf2\x9c\x3d\xea\xf2\xf9\x2f\x6e\xb1\x32\xfd\xad\x0f\x2c\x81\x1d\xf3\xee\x80\x25\x0f\x59\xe1\xa0\x75\x63\x8c\x6d\x3e\x77\x90\xfb\x89\xb2\xe6\xef\xd9\x21\xe7\x5e\x66\xab\x74\x55\x08\xeb\x0e\x6f\xe2\xfe\xdc\x4e\xed\x89\xc9\x72\xa9\xcb\x66\x43\xbc\x20\x8a\x41\x0f\xef\x09\x47\x5c\x36\x12\xa7\xd1\xaa\x84\x0c\x6e\x2b\xc7\x4a\x26\x36\xe8\xd1\x54\x4c\x3f\xdb\xdd\x69\xe3\x1b\x94\x55\x33\x7b\xf4\x2b\x4d\xb5\x04\x36\x57\x67\x59\xdd\xb2\x1e\x6b\x9a\xb0\x5b\x54\x65\xf1\x4e\x78\xeb\xeb\x9b\xad\xcc\x7c\xeb\xc3\x3b\xa1\x6e\xb7\x15\x5e\xb5\xde\xa9\xb6\x01\x7b\x8b\xd8\x71\xb7\xf8\xf0\xc3\x54\xbd\x64\x7c\x4c\x2b\x55\x2c\x6f\x82\x15\xf4\x1c\xed\x58\x46\xdd\x3a\x0f\xe1\xba\x5d\xac\xd3\xef\x86\x29\xf2\x3f\x6c\x2e\x97\xd5\x2d\x0a\x82\x81\x77\xe3\xdb\xbc\xd7\x23\xda\x5c\x2c\x2d\x03\x2e\x02\xcb\xe3\x22\x68\x05\x60\x9d\x2b\xbc\x30\xce\x0b\x83\xbd\x10\xf2\x82\xc5\x0b\x9d\x5e\x78\xc3\x0b\xaf\x78\xe1\x6e\x2f\x6c\xf7\xc2\x26\x2f\x2c\xa5\x00\x99\x2c\xc0\x92\xf7\x28\xc4\xe3\x5e\xb8\x8f\x42\xb4\xe4\x3d\x3e\xeb\x85\x17\xbc\x70\x20\xfb\x1a\x46\x5a\xe1\x05\xe6\x43\x2f\x9c\xa4\x28\x77\x7a\xa1\xd5\x0b\x4d\x5e\xa8\xf7\x42\xdc\x0b\x76\x2f\xd4\xe2\xcf\x69\x8f\x37\x7b\x61\x05\x05\xc7\x77\xbe\xa1\x37\x8f\x66\x5f\xc8\x41\xbf\x42\x71\xef\xa4\x90\xb2\x17\x62\x5e\x40\x5e\xe8\x3d\xbe\xa8\x8b\xa5\x5b\x7b\xf2\xfc\x9c\x9e\xbd\x22\x67\xb6\x68\xcd\xe7\xab\xea\x72\xf9\xf4\x6c\x40\x57\xb7\x06\x04\xe6\xe5\x53\x62\x47\x1f\xf1\x2f\x4d\xff\xc0\x0d\x77\x99\xf5\xb9\xa7\x61\xd9\x7d\x44\x2a\xde\xa2\xf6\xa1\xed\x05\xcf\x33\x2f\x52\x83\xe0\x8f\x4c\x19\x3d\x8f\xc5\x7c\x46\x62\x37\x0f\x50\x1d\x75\x90\x1c\x96\x90\xd1\xe8\x31\x98\x9d\x4e\xb7\xcb\xec\xc4\x7a\x9f\xdd\xe9\x34\x21\x01\x5b\x55\xbc\x90\x15\xd4\xba\xed\xd2\x15\xa4\x48\xe3\x52\xf5\xe1\x42\x80\xac\xea\x5f\xc3\x8e\x39\x3a\xf7\x81\xf8\x08\x65\x30\xfb\x84\xeb\xdc\x89\x17\x2e\xfe\xaa\x6c\xd1\xcc\xb6\xb3\xdf\xbb\xb9\x3f\x58\x85\x3f\xc0\xa4\x25\x67\x6f\xf3\x99\x01\xa9\x1b\xc8\xfc\x5d\x95\xfa\x35\x8b\x95\x1a\xfc\x25\xac\x7d\x72\x3c\x0f\x08\x19\x4d\xc0\xfd\x4b\xc1\x17\xfc\xbf\x14\xf4\xdd\xf9\xb3\x35\x54\x4b\xc7\x1c\x5b\x85\x47\xa7\xc3\xe2\xef\xd5\xb3\xc7\x44\xf5\x6b\xc3\x7d\xc3\x4b\x7e\x1e\x54\x32\x9c\xf4\xed\x2d\x9d\x5f\xc2\xdb\xb9\x18\x07\x40\x2c\xb0\x1c\x0f\x7a\x8c\x43\x97\xec\xe0\x59\xdc\x51\xa7\xfc\x6e\xf3\x1f\xdd\xbc\xf2\xf3\x3e\x5c\x1f\xb7\xab\x5f\x33\xeb\xb2\xb4\x30\x82\xc0\x1a\x0c\x46\x13\xcf\xfe\x4b\xe1\xb1\x96\xd4\x3b\x2d\x2c\xee\x4a\x44\xf5\x5e\x22\xfe\x1e\xf8\x63\x22\x1c\x56\xdf\x56\xbf\x1e\x5e\xc2\xff\xba\x64\xf8\x4f\x74\x1e\xe6\x2a\xb8\x9a\xab\xc6\x75\x6c\x40\x29\xd9\xce\x73\xb8\xe3\x19\x58\x83\x60\x44\x0c\x70\xa4\x5a\xdf\xea\x97\x17\xa3\xd2\xb7\xd2\xc4\x90\x90\x32\xf6\x11\xf5\x59\xf5\xd9\x9d\xb0\x7f\x26\xec\x87\xab\x99\x9f\x3a\x04\x32\xa9\x81\xf4\x58\x9f\x4f\xd8\x6b\x3b\xd7\xe0\xb2\x79\x64\x13\x83\x4b\x45\xe3\x46\x10\xb5\x73\x29\x41\xd5\x09\xcf\x9d\x5c\x5c\xfd\x64\xd7\x2e\xea\x6f\xf9\x1b\x37\x87\xd9\xcc\xef\x44\x3c\x2a\x94\x7d\xc0\x19\x04\xc4\xde\xd0\xb2\x19\xed\x44\x0c\x99\x19\x3d\x80\x4e\x92\x8d\x56\xb5\x19\x51\x1a\x76\x62\x02\x6c\x06\x09\x4c\x4a\xfd\x95\x00\xa6\x6d\x06\x6e\x0e\x88\x85\xea\x37\x71\x3a\x8f\xe1\xef\xfc\x27\x7b\x92\x3d\x86\x95\x88\x18\x1a\x23\x17\xba\xcc\x5c\x20\x20\x05\x83\xc8\x69\x76\xc6\x13\x92\x43\xb2\x85\x9b\x14\x9b\xc4\x79\x05\xef\x24\x45\xf0\xb2\x68\xa2\xc2\x66\x03\xc6\x34\x9d\x83\x28\x4f\x5d\x8a\x6f\x3f\x47\x8e\x9f\xb3\x2e\x77\xea\xae\xa9\xa9\xd2\xa6\x89\x6b\x5c\x34\x5e\x8e\xad\xb9\xd8\xa8\x3e\xcc\x0d\xbe\x6d\xc2\xe5\xdb\x6f\x06\xfe\xde\xeb\x57\x4d\x1e\xd0\xd1\x3c\xb2\x7f\xf1\x45\x45\x73\xcb\x9b\xc6\x5e\x31\x66\x66\xbc\xf6\xfa\xb1\xd3\x0e\xef\x3d\x00\x99\xc7\xcb\x0b\x3b\x1e\x5c\x78\x69\xf3\x60\xa6\x2a\xb9\xe3\x5b\x42\x73\xa8\xf3\x0b\xf6\x57\xb8\x4d\xad\x28\x81\x26\xc9\x19\x83\xdf\xcb\x7a\x3c\x82\xe0\x74\xa0\xa8\x23\x9a\x4c\x19\xfc\x7e\x36\xc4\x4e\x52\xbc\x21\xc9\xe3\x9c\xa8\x78\x90\xcd\x8c\xcb\xe0\x15\xda\x52\xd8\x10\xab\xc8\x05\xbb\x55\xe9\xea\x52\x96\x79\xb4\xb9\x83\xac\x21\x24\xb0\x44\xe3\x1b\x0a\x2c\x99\xa4\x27\xbe\x32\x83\xa0\xc7\x47\x30\x06\xe6\xc5\xe1\x03\x0a\x5a\x33\x17\xba\x27\xc6\x46\x6e\x6c\x3c\x7b\xf1\x27\x17\x7c\x32\xcb\x02\x17\x8f\x77\xf9\x86\xdc\x34\xee\x92\x1b\xb7\x7d\xc1\x8c\x5b\x7c\xe9\x84\xa1\x1d\x7f\x71\x45\x76\x7d\xab\x86\x0b\x52\x3c\xef\x1b\xa6\x4e\x5e\x37\x61\xd2\xf4\x43\x77\x1f\x54\xdf\x7a\x1c\xb7\x21\x99\x9b\x5d\xc1\xbe\x86\x75\xaa\x81\x72\xc4\xc5\x06\xcd\xac\x39\x12\x15\xec\x4d\x0a\x12\xc1\xc4\x8a\xb2\x20\x05\xbc\xc8\xdb\xac\xd0\x48\x20\xe4\x97\x5e\xaf\x0f\xbe\xd9\x6d\x26\x36\x6f\x4a\xde\xab\xab\xa3\x36\xd0\x0c\x0a\x62\x70\xc0\xb5\xfb\x5f\xba\x05\x98\xdb\x1b\x1f\xab\xee\xdb\x68\x1b\x30\xab\x69\x47\xf3\x8c\x69\xe3\x36\x0d\x2a\x9b\x7c\xc2\xfd\xfc\x43\xcf\x41\x72\x6f\xc8\xa9\x9e\x7e\xbc\x6e\xc7\xb7\x3b\x56\x5e\x36\xa0\xb8\x7e\xcc\x64\xa4\xf3\xc3\x97\x5c\x00\xd7\xad\x17\x15\xa0\x36\xac\x54\xb3\x51\x93\x05\x0f\x98\x11\xb7\xdb\x2e\xb1\x52\x61\x5a\x0b\x19\xb4\x88\xd8\xc2\x9d\xa8\xd8\x50\x34\x21\x24\x9a\x14\x37\x96\x2a\x52\x24\x88\x82\x93\x34\x7a\x29\x67\x60\x0d\x34\xab\x96\xd2\x89\xf9\x7c\xad\x9a\x46\x14\x66\x4b\x30\x00\xf3\x87\xee\x90\xd4\xd8\x86\xd5\x59\x85\xf8\xc0\x49\x7c\xc1\xea\xeb\xaf\xfc\xe2\xc6\x8b\x87\xb1\x96\x3e\x7b\x45\x38\xf4\xd5\x5c\x51\x3d\x2c\x0c\xbe\x63\xe8\xa0\x3e\xe9\xa5\xa5\x17\xba\xa7\xc4\x46\xac\x1b\xe1\x3e\x78\xd7\x53\xd0\xe7\x40\x38\x3a\x07\x24\xff\xb0\x9f\x8f\x07\xea\x76\x35\x4d\x83\xf5\xcb\xd6\x63\xb6\x49\xbb\xc3\x37\x7e\x47\xca\x56\x89\xeb\xbc\x0d\xd7\xb9\x1f\xf3\xcd\x18\xb9\x28\x60\x30\x38\xed\xe1\x58\x98\x31\x19\xc2\x22\x09\x0c\x4b\x71\x81\x26\x85\xe3\xec\x5e\x6f\xac\x49\xf1\x4a\x76\x63\xb3\x62\xb1\x7b\x51\xce\xba\xcb\xd9\xa0\xa4\x14\x34\x7c\x59\x0b\x88\xb2\x11\xc3\xca\xad\x57\x7c\x2a\x5b\x26\x2f\x64\x43\x1e\xd9\xb6\xad\x3f\xed\xe1\x9f\x19\x7b\x45\x4d\xd9\x8c\xdf\xb6\x3e\xf5\xfc\xcd\x67\xae\xbc\xfe\xc1\x8e\x1f\x37\xde\x5b\x12\x1e\xb9\x81\xf9\xf7\xcc\x3b\x2e\x12\xdd\x95\x5f\x0e\x2a\xac\x1f\x3b\xe9\xe9\xfd\xfb\x21\xfd\xd8\x0a\xf5\x11\xeb\xee\xf9\xa5\xa5\x6f\x6a\xfe\x55\xa4\x8e\x67\xa7\xf2\x0f\x20\x1f\xba\x54\x1e\xed\x32\x79\x4d\x01\xa7\xc7\xe1\xf0\xe2\xde\xc8\x71\x3e\x9f\xdf\xe7\x0d\x21\x8f\xd3\xd3\xa4\x38\x6c\x4e\x4e\x60\x59\xa7\x5d\xb0\x35\x29\x71\x4b\xa5\x45\xb6\xb0\xe4\xb4\xd7\x72\xd0\x72\xd4\xc2\x5b\x2c\x02\x1c\x0d\xc0\xa9\x00\xc4\x03\x78\x60\x5b\xdd\xe5\x70\xa5\x9e\x13\xa7\xde\x5c\x5a\xbc\x13\x6e\xbd\x6e\x6e\x63\x57\xaa\x9e\x21\x1d\xc0\x27\x68\x96\x8f\x1d\x48\x80\x7a\xe2\x83\x07\xc4\xc7\x7c\x85\xef\x3c\xdd\x32\xa2\x48\x16\x3d\xa9\xea\x06\x7f\xe4\xb7\xce\xdf\x7e\xa0\x7e\xcf\x8e\x18\x59\xb4\xf1\xf5\xa7\x3d\x1f\xac\xf4\x2c\xdd\xbc\x67\xd1\x59\x2c\x1d\x3b\xff\x82\xcb\xf1\x1b\x5c\xff\x22\xb6\xe2\xe6\xcb\x03\x82\xc8\x9a\x36\x14\x14\x08\x82\xdb\x65\x75\x95\x95\xa7\x4b\x1c\x06\xb6\x04\xf7\xdb\x12\x6f\x81\x2f\x8e\x3b\x42\x08\xcc\xc4\x6e\x0b\x0b\x26\x87\x09\x17\x4e\x3a\x5d\x0e\xf1\xf2\x6e\x8e\x40\xd2\x21\x90\xbf\xa2\x3e\x1b\x18\xd4\xc3\x8b\x4a\xda\x26\x4f\xe8\xf0\x1a\xab\xb1\xb4\x8d\x8a\x6a\x34\x9b\x6e\x28\xd4\x0c\xa8\xa1\x77\xa0\x60\x58\xbf\x54\x6b\xf9\xd2\xc1\xa3\xc6\x6e\x6c\x54\x7f\xba\xee\x9b\xdd\x0f\x9e\xdb\x9f\xfe\xd7\x5f\x67\x3f\x37\xc0\x3b\xb0\xa0\x60\xf5\xc8\xe1\x33\x6b\x9c\x7e\xdf\x90\xdd\x8d\xeb\x6e\x84\xb9\x4b\x2e\x19\x55\xc7\x8c\x0a\x5c\xff\xc3\x13\x87\xa0\xdf\x63\xa5\xe7\x1a\x4e\xfe\xb2\x38\xd6\x71\x55\x61\x45\xbf\xb9\x0b\x6f\x19\xd3\xa4\x1c\xc6\xed\x56\x8c\xc7\x62\x2b\xee\x4b\x21\xb4\x58\xae\x73\xa1\x20\x1b\x08\xb8\xdd\x5e\x8f\xc5\x66\x33\xf2\x1e\x3e\x1c\x09\x78\x27\x2a\x01\xe4\xf1\xb8\x2d\xc6\x89\x8a\xc5\xe3\x42\x48\x62\xa4\x49\x4a\x90\x91\x9a\x23\x70\x30\x02\x95\x11\x38\x1d\x81\xbd\x91\xac\x9f\x5f\x97\x58\x54\x7c\x55\xd4\x9f\x67\x5f\x69\xd2\x4b\x9b\xff\xa5\xee\x10\x97\x1e\x56\xa4\x79\x8f\x59\x01\x0e\xdf\xf5\xe9\x85\xeb\x1d\xad\x6b\xad\xea\x15\x0b\xbc\x2d\xf5\x7b\xd2\x4b\xd4\x7f\xfd\xa3\x05\x8b\xae\xa9\x71\x16\x8e\x2d\x9d\xd5\x7f\x76\xc7\x57\xfe\x06\x66\xd0\xda\xe2\x0b\x6f\x98\xd1\xf1\x24\x5f\xe5\x6f\x50\xfb\xee\xa5\x72\xa1\x3f\x3e\x54\xd2\x71\xd4\x85\x46\xc9\x45\x36\xa3\x91\x15\x70\xf1\x58\xd6\xed\xb1\x38\xa6\x28\x16\x64\xe0\x26\x2a\x06\xbb\x36\x40\x1c\xf0\xc0\x66\x0f\xd4\x13\xaf\xed\xec\x6e\xd1\xc5\xdd\x23\x24\x08\x89\x84\xb0\xec\x9c\x35\x69\x84\x49\x1b\x2c\xea\x86\xdb\x09\x4d\xff\x68\xa9\x97\x95\x19\xc3\xe4\x99\x33\xfd\x0d\xec\x64\x7f\x03\x34\x0e\x9b\xa1\xc8\xf5\x2d\x34\x76\x51\xfd\x41\x1d\xcf\xd4\x63\x7a\x1c\x28\x82\xa6\xca\xfd\x9c\x7e\xbf\x8d\x31\x9b\x2d\x16\xbb\xcd\x16\x8d\x79\x42\x53\xb0\xd8\xb7\x5a\x9a\x14\xab\x1d\x09\x4d\x4a\x85\x16\x6f\x50\xcf\x1e\x60\x5f\xc1\xa3\x1d\xa6\x1a\xcb\xdd\xae\xb0\xb9\xf3\x68\xa3\x83\x6e\x92\xb0\x88\xc6\x3e\x84\x48\x1b\xb8\xf2\xe8\x9c\xa7\x34\x15\xd5\xfb\xdd\x81\xfe\x13\x3c\xf7\xef\xb5\xc0\xa1\xfd\xa9\x3f\xbf\x92\xa5\x57\x1d\xef\xfc\x68\xbd\xfd\x9a\x4b\xd9\x9d\xc9\x86\x73\xe5\xc7\x4e\x18\x1e\xcd\x11\x0e\xf8\xbb\x88\x3d\x83\xe9\x76\x11\xe9\x4a\x54\x68\x2b\xb2\xba\xb0\x3d\x20\xd9\x2d\x46\x23\x18\xec\x06\xb7\xc7\x89\x45\xac\x13\xd9\x3d\x56\x11\x09\x1c\x6b\xd4\x98\xc3\x80\x35\x79\x5c\xb5\xf6\x2e\x5b\x9f\x84\x6a\xfb\x7b\xe1\x82\x9c\xc3\xd9\x44\xf5\x48\x86\x3a\x62\x74\x1e\x80\xad\xd0\x7a\x81\x05\x66\x58\x66\x7d\xff\x41\xb3\x45\x7d\xfd\x91\x65\x23\xd4\xef\xff\x39\x4b\x84\x8b\xe1\x2c\xcc\xf0\x35\x34\x78\x4f\x77\xfc\x0d\x57\xf5\x6b\xa3\xd4\x2b\x49\xeb\x6b\xf2\xa7\x1c\x57\xf8\x00\xda\xf6\xfd\xe5\x88\xd6\xea\x46\x13\x6d\x6f\xa4\xb7\xb7\x09\x36\x9b\xa0\xde\x94\xd7\xde\x3d\xa6\x04\xe8\xc7\xc7\x92\xb6\xfd\x92\xb4\x2d\x6e\x52\x8a\x1e\x50\x11\x56\x09\xff\x84\x65\x42\x29\xfc\x43\xee\x8c\x60\x55\x46\x00\x01\xd7\x44\xb1\xb3\x18\xd9\x89\xdb\x27\xe9\x93\x1c\xc8\x81\x4d\x39\x87\xcb\x99\x74\x96\x65\x8a\x0b\x27\x2a\xc5\x9e\x48\x2c\xc6\x4c\x52\x62\x92\x2f\x18\xb4\xe2\x0e\x23\x79\x5c\x78\x9c\xb7\x3b\x3d\x46\xcf\xb6\x32\xb8\xb4\x0c\xc6\x94\x41\xa0\x0c\x2c\x65\x70\xb6\x0c\xfe\x59\x06\xef\x97\xc1\xc9\x32\x78\xa9\x0c\x9e\x28\x83\xfb\xca\x60\x47\x19\x5c\x5e\x06\x4b\xcb\x60\x76\x19\x8c\x2b\x83\xc1\x65\x90\x29\x83\x50\x19\x98\xca\x60\xd1\x4f\xf4\x85\xf7\xca\xe0\x44\x19\xbc\x40\x5f\xb8\xb7\x0c\x60\x53\x19\xac\x28\x83\x16\x0a\x5e\x5f\x06\x15\x59\xdc\xdf\x50\xd0\x93\x14\xf4\x40\x19\xdc\x5d\x06\xdb\xcb\x60\x73\x77\xe0\x10\x05\xee\xa4\x78\xdf\x28\x83\x57\xca\xe0\x71\x0a\xb9\xb3\x8c\xa0\xcd\x81\x61\x12\xe4\xa9\x31\x0a\x3b\x10\x43\x7e\x48\x71\x3e\x4e\xe9\x5d\x4b\xc1\x30\x00\x7e\xcc\x60\x44\xa7\x28\x16\xfc\xbd\x5d\xf4\x63\xcd\x59\x9a\x24\xfa\x99\x93\xf4\x29\xbe\x1f\x2f\x03\x7b\x99\xb6\x98\xa2\x9b\x89\xde\xfa\x7f\x64\xc5\xe7\x6c\x9a\xd6\xff\xc1\x8e\xa7\x0b\xdb\xf2\xb5\xc1\x2c\x6f\xe6\x8d\x91\x84\x2d\x67\x67\x9d\xf3\xb3\x35\xb1\xdc\x9f\xc8\x63\xc2\x93\xdd\x24\x94\xa6\x61\xf9\xba\x49\x30\xee\x58\x63\xaa\x75\x9c\x79\xae\xfa\xe3\x02\xef\xd8\xca\x8d\x05\x58\x62\xdd\xaa\x58\xa1\x91\x6d\x7c\x60\x9e\x32\x1f\x76\xbc\x36\x63\x51\x56\xa0\x31\x6f\x5f\xd8\x7c\x59\x4d\xc7\x5b\x54\x7e\x5d\xdd\xda\xf1\x24\x3b\x29\xd0\xf0\xe8\x45\xad\x8b\x67\xbf\xbe\x62\x5e\x61\x6b\xc7\x97\x54\xb4\x61\xa6\x2a\xc5\x2c\x6c\xc7\x3c\x17\x40\x2d\xb8\x0f\xf2\xd8\x22\x10\x7c\x08\xb9\x1d\x82\x23\x18\xf2\xb9\x27\x2a\x3e\x0f\x2f\x8a\x8c\x0d\x73\x98\x4d\xa2\xbd\xcf\x2e\x78\x9a\x43\xb0\x32\x04\x95\x21\x38\x1d\x02\x4d\x1a\xe7\x8a\xed\xe8\xc5\xd7\xa5\x17\x32\x57\xb2\x6e\x65\x62\xce\xe9\xb2\x97\x94\x64\xa2\xf1\xee\x8f\xe6\xae\x0d\x4c\xcf\x95\x81\x48\x5e\x42\xf9\x81\xe3\x4b\xda\xfa\x5f\xa5\x7a\x35\xaa\x89\x0c\x8e\x63\xfd\xe5\x79\x3a\x7e\x06\x51\x9d\x9c\x42\x3e\x83\xe4\x93\xc2\x21\x37\x83\x35\x30\xc9\x8a\xc7\x48\xab\xf7\x54\x18\x8e\x86\x61\x6f\x18\xda\xc3\xd0\x16\x86\xae\xa0\x99\x1e\xbe\xfe\x9c\xf7\x79\x28\x40\x4e\x61\xa1\xba\xed\xe3\x97\xd7\x6f\x1a\x37\xb6\x56\xbe\x64\x94\xfa\xcf\xff\x7a\xf3\x86\xb3\xf7\x92\x03\xb3\xea\xdb\x3b\x3a\xd1\xf6\x35\x97\xdf\x7a\x4e\xb5\xbe\x73\xf8\x01\x90\xee\xc5\x47\xf5\xcc\xbd\xd4\xd7\xbc\x1c\x8f\xeb\xbf\xc4\x74\xf9\xb0\xce\x38\x4b\xee\xeb\x47\xc8\x96\x96\xec\x76\x9b\xd1\x10\x8d\x70\x2e\x97\xc9\x64\xb3\x15\xba\x42\x9e\xd0\x24\xc5\x23\x39\xed\x58\xb8\xd9\xc9\xfc\xc8\x44\x45\x0c\x71\x58\x79\xe4\xbc\x3d\xed\x89\x9c\x41\xda\xb5\xf4\x44\x8f\x9b\x25\xb1\xe7\xc9\x22\x3b\x93\xf3\x35\xd3\x8a\xa5\xde\xf4\x9c\xc2\xfe\xcb\x2d\x5f\xde\x72\xc1\x48\x46\x4c\xef\x15\x3b\xfe\x2e\x2e\x7a\x67\xae\x08\x8a\xe1\xf2\x1b\xd7\xdd\xa8\xfe\x34\xa4\xdf\x88\x79\x17\xf9\x87\x07\x1a\x2f\x1d\xc1\x6c\x78\x5a\x7d\xfb\xc9\x44\xa4\xf5\x4b\xff\xb0\x61\x7e\xee\xe9\x40\xdd\xf5\x0f\x1e\x7e\x7d\xf1\xa5\x57\x77\xfc\xc9\xef\xdf\xf1\x8d\x1e\xff\x37\x9e\x7d\x13\x97\xcb\x82\xa2\x84\x53\x50\xc8\xe0\x71\xb1\x4e\xa7\x20\xd8\x6d\x21\x5b\x2c\xee\x31\xb0\x7e\xac\xae\xf8\xbd\xb4\x4c\x21\xc1\x24\xe2\x26\x10\xa5\x83\x71\x38\x1d\x87\x5d\x71\x68\x8f\x93\xfa\xef\x9a\x28\xd5\x4b\x96\x3f\xd9\xeb\xd3\x8b\x95\xd3\x52\x18\x17\x56\x50\x28\x93\xd4\xe4\x54\x49\x48\x0c\xeb\x9b\x5c\x5c\xb6\x78\xf0\xc4\x95\x77\x9e\x7d\xfb\xbd\xcf\x66\x59\xd4\x5b\xc6\xb8\x7c\x83\xee\x6f\x5c\x7f\xc3\x95\xff\x24\xaa\x48\x53\x1d\x33\x24\xa0\x9e\x82\x5b\x4a\xcf\x9a\x7c\xc3\xe0\xaa\x75\x13\xc6\xcf\x7a\xe6\xce\x67\xa0\x7c\x3f\x95\xdf\x98\xdf\xd9\x32\x5c\x0e\x07\x9a\x20\x67\x90\xc5\xe1\x10\x45\x9b\xd5\xea\xe4\x5d\x0e\xdc\x08\x0e\x3c\xf0\x58\x3d\x22\x6b\x9c\xa4\x34\x93\xa0\xbd\x98\x80\xad\x64\xc4\x4a\xd8\x24\xa7\x73\x6f\x15\xb3\x35\x1d\xcb\x39\xa8\x3e\x6f\xde\x55\xf3\xf9\x53\x85\x10\xdb\x1e\x39\x3e\x87\x67\x6b\xee\x6d\xaa\x4c\xd5\xd6\x94\x8d\x5b\xd9\x7f\xb1\xfa\xfd\xed\xeb\x2c\xb0\x81\xf9\x78\xe9\x25\x66\xf5\xc0\xb6\xf1\x53\x3a\xf6\x93\x81\x9c\xda\xbc\x3f\x76\x7e\xc9\x7c\x80\x69\x2a\x46\x6b\xe4\x91\x49\x83\x27\x60\x43\x1e\x54\x52\x3a\xdd\x06\x7f\xb1\xc1\x8c\x24\xbc\x91\x7c\x2f\xc9\xb0\x28\x09\x66\xde\x96\x64\x7d\xbe\xd8\x44\x25\x14\x02\x7b\x08\x44\x1e\xeb\x84\x12\x6b\x99\xa8\x48\x42\x9c\xd0\xca\x7a\x8f\x96\x42\x65\x29\xe8\x0a\x6d\xce\x9b\xaf\x05\x09\x0d\xc2\x57\xad\xb3\x57\xcd\x5e\xd5\xcd\xa7\x0f\x74\x10\xcf\xce\x17\xd3\x48\xf8\x3e\x50\x2d\x25\xa8\x7a\x4b\xcc\x0e\xcd\xb3\xcf\x30\xcf\xbc\xf9\xc6\x84\xa7\x32\x7d\x1a\xec\xf2\xaa\xc9\x17\x55\x0f\x6c\x58\x31\x0b\x2e\x5d\xbf\x2b\xd3\x60\xf5\x4c\xae\x1a\x3f\x7a\xf0\xbc\xd6\x29\xe5\x50\x72\xc7\xc3\x29\x17\xf0\x5b\x67\x4e\x1f\x56\x34\x2c\x9e\x1e\x7a\xed\x54\x88\xc4\xbf\x5d\x1e\xcc\x8c\xa8\x29\x1a\x31\xb0\x7a\xc2\x1c\xd2\x06\x43\x71\x79\x97\x71\x57\xe2\x9e\x3b\x4a\x2e\x64\x9d\x2e\x0f\xe7\xf7\x9b\xec\xa2\x68\x32\x85\xc2\xa2\xa6\xbd\x3b\xec\x4e\x3b\x83\x0c\xa8\x59\x31\x78\x37\x87\xa1\x4b\xcf\xad\xaa\xe8\x9a\x64\xa7\xff\xfb\xc8\xa8\xda\x2f\x67\x6d\xd4\x10\xe5\xbc\x4a\x20\x0a\x39\xa1\x1b\xf6\x27\xc7\x07\xfb\xee\x1e\xb1\x7c\x83\x73\xd6\x1a\xcb\x8d\xdb\x6f\x4e\xef\x71\xee\x69\x91\xaa\x97\x04\x47\xa5\x2a\x16\xcf\xeb\x73\x11\x9c\x1d\x56\xf4\xf6\xdb\x8b\x54\x76\x72\xba\xba\x12\xd3\x36\xae\xf3\xef\x5c\x25\xdd\x75\x69\x82\x5c\x42\x25\xa1\xc8\x53\xa9\xe8\x10\x82\x21\x2f\x16\x88\x5e\xbb\x2e\x0e\xbd\xba\x32\x62\xc7\x82\x70\x15\xea\x2e\xf9\x7b\xce\x68\x92\x10\x58\xca\xd6\xd4\xac\xd3\x43\x84\x07\x68\xb6\x34\xcc\x69\x91\xf7\xa6\x96\x80\xf9\xd6\x8b\xad\xea\x1e\x2c\x01\xe7\xaf\xb6\xce\x5d\x6b\x85\x2d\x0b\xbc\x7f\xbe\x70\xe7\x34\x66\xd2\xb9\x03\x81\x86\x83\xc7\x2f\x5e\xe0\x9a\xc5\x14\xfb\x1b\x3a\x8e\xaf\x21\x75\xe8\xc2\xf2\xef\x3e\xf6\x09\xe4\x46\x43\xe4\x04\x72\x3a\x3d\x5e\xde\x6a\xf5\x82\xc3\x6b\x72\x22\x6c\xe8\x9b\x91\xfd\x94\x17\x0e\x52\x37\x5e\xbb\xe6\xba\xd3\xc3\x2e\x88\x85\x03\x79\x62\x24\x44\x4d\xb3\x3e\x58\x3f\xaa\x22\x52\x99\x7a\x79\x61\xec\x6d\x6f\xc4\x93\x8e\x70\xb9\xf8\x79\x70\x8a\x3a\x6e\xd3\x9b\x43\x2c\xec\x13\x1d\xab\xa1\xb6\xdf\x45\xf1\x60\xc2\x6b\x1d\xe6\x2b\x9e\xd5\xde\xd1\xc2\x2e\x24\x0c\x0c\x58\xea\x7d\xc9\xcf\xa6\x75\x36\x5a\x2e\x72\x92\x79\x4c\x24\x08\x21\xaf\x4b\x64\x6d\x6e\xb7\xc3\xe6\xb0\x93\x9e\x85\xeb\xcb\xcb\xd9\x5f\x09\xc1\x81\x10\xdc\x17\xd2\xb4\xa3\xfa\xdc\x4a\x70\xd2\xfb\xf3\xa9\xea\x5f\x01\x39\x7a\x34\xc7\xb3\x0b\xaa\x08\xa9\xdc\xfd\x72\x81\xf8\x63\x6c\xb8\xba\x7c\xc3\x42\xf5\xcf\x57\x3f\xde\x6c\x81\xca\x2b\xa0\x7a\xde\xca\x87\xdd\x05\xac\x30\xca\x6d\x1e\xe6\x1f\xa4\xac\xea\x68\x61\x82\x1d\x7f\x63\x17\xe0\xea\x5a\xce\xf4\xef\x78\x13\x4a\x0b\x2f\x45\xb9\x75\x2f\xbf\xc5\xb4\x16\xa2\x0b\xe4\x72\x77\xc2\x95\x74\xd9\x91\x54\x58\x98\x94\x92\x16\x7f\x34\x5a\x84\x0d\xc3\x34\xb2\x27\xdc\x9c\x0b\xdf\x9b\xa8\x14\x7a\x42\x76\x6a\xe5\xdb\x4d\x1e\xbd\x89\xb3\x0b\x03\x21\x2f\xd6\x4e\x0b\x1a\xd4\xa3\xdb\x05\xb2\xd0\x0f\xf7\x1d\x1a\xdc\x5e\x48\x49\xaf\x21\x55\xac\x55\xb0\x1d\x88\x0e\x0a\xbf\x78\xb8\xa0\xc8\x51\x2a\xbe\x2f\x0d\x6b\x84\xf0\x6f\xb0\x1a\x9a\x79\x78\x41\xdf\xbe\x35\xe2\xdb\x9e\xeb\x4f\x7d\x7a\x81\x45\xfd\x3d\xac\xbf\x3e\x96\x49\x04\xa2\xa6\x61\xd6\x68\x6a\x4a\xdd\x37\x70\x4d\x60\x98\xfa\xc2\xb4\xe2\x61\xb1\x88\x79\x98\x14\x1a\xb7\xe6\x49\x75\x98\x67\x98\x56\xa6\x2a\x75\x14\x7b\x0b\x2e\x53\x92\xcc\xc5\x23\x9f\xd3\xc9\x7a\xcd\x2e\x57\xaa\x20\x84\x50\x41\xdc\xee\x73\x7a\x63\x2e\xaf\x8b\x70\x2e\xeb\x24\x5e\x15\x51\x14\xc2\x07\x0b\xa0\xbd\x80\xda\x8f\xb8\x43\x61\x91\x56\x95\xb5\x1b\xbb\x2d\x1a\x70\x66\x2d\x47\x01\x6c\x8c\x6e\x28\x52\xf1\x4c\x4a\x95\xcf\x38\xec\x2d\x93\xd4\x31\x6d\x57\x5d\x37\xbe\x6a\x48\xdf\xd2\x3a\x77\xa0\xbc\xee\xc6\x15\xef\x0c\xb1\x40\xc5\x1d\xcf\x84\x0a\x35\x3e\x62\x2f\x9e\xb9\xa5\xa3\xff\xbd\xb7\x4d\x10\xc4\xef\xae\xf0\x5d\xff\x02\x3b\x1d\x37\xce\x95\x50\x56\xb6\x38\xa6\xb1\x94\x56\x96\xd7\x71\xfb\x78\x70\x59\x5c\x98\x97\x0a\x9d\xd8\x8c\xf1\x88\x46\xdc\x0b\x2d\x26\xc6\xc4\x4c\x54\x04\xc1\x64\x07\x3c\xe6\x8b\x58\xe2\x39\xe2\x0e\xc6\xe1\x20\x93\x82\xd8\x78\xd1\xfd\x2a\x55\x79\xab\x7d\xb2\x1e\xdc\x54\x4d\x77\x1f\x2e\x89\x60\xab\x35\x32\xdc\xa8\x01\x8b\x03\x75\x8d\x7d\x99\x5b\x4d\x1d\xe7\xa6\x0c\xbc\x2c\x3e\xb9\x71\x6c\x3f\x36\xee\x92\xee\x06\xff\x80\x73\x9f\x86\xdc\x4f\xab\xaf\x11\x1b\x45\xfd\x9a\x1d\x81\xf5\xfd\x52\x34\x59\x2e\x2b\x0c\x04\x13\x1c\x5b\xe2\x76\xb3\x11\x8b\xd1\x2e\x59\xb0\xf2\x9f\x29\x8b\x88\x16\xd1\xf2\x23\xae\x55\x77\x49\x69\xc9\x8f\x4a\xe9\x77\x6e\xcf\x8f\x8a\x1b\x9d\xbf\x1a\x82\x0a\x2d\x5f\x55\x9e\xdc\x02\x4d\x62\x11\xa1\x5b\x84\x79\xa4\xc6\x35\x14\x06\x83\x40\x55\x25\xac\x12\x7a\xa2\xe0\x11\xa8\x14\xc3\x37\xe1\xe6\x8d\x5b\x84\x4a\x43\xeb\x0c\xfb\xc2\xab\xdc\x35\x81\xc7\xee\xbe\xd6\x3e\x74\xe4\x24\xbb\xec\xb8\xb6\x75\xdc\x74\xbe\xda\x50\x3d\x68\xa8\xa4\x7e\xbd\x69\x55\x71\x1a\x5c\x89\xf0\xe4\x46\x76\x1a\x3b\x17\x77\xd8\x1d\x5b\xa7\x8f\xbc\x40\xbd\xa3\xed\x3a\x17\xeb\x58\xd8\x5c\xad\x9e\x4a\x84\x87\x8c\x99\x8e\xcb\xb5\x5d\x1d\x05\x41\x5c\x2e\x16\xbd\x2c\x5f\xc3\x62\x25\x90\x78\xa6\x43\x12\x3e\xf2\x70\x86\x87\x53\x3c\x1c\xe5\xe1\x20\x0f\x2b\x79\x68\xe3\x21\x4e\xef\x2f\xc7\x0f\x4e\xd3\x67\xbb\xe8\x2d\x0d\x5a\x83\x93\x79\xa8\xa4\x37\x35\x80\x66\x7a\x47\x03\x18\x8a\xa1\xdb\x29\xa6\x0f\x29\xe8\x5e\xfa\xb8\x33\xfb\x11\x7c\xbf\x82\x87\x18\xdf\x35\xcf\xb6\xaa\x4b\xc3\xee\x35\xf3\x00\xd5\xb4\xb3\x2b\x02\x5d\xb8\x2e\xb7\xef\x54\x47\x09\xa3\xff\xfd\x1c\xe6\x9f\xeb\xd4\xaf\x99\x83\xb8\x5c\x25\xa4\xbd\x4c\x89\x04\x99\x3f\xc2\x76\x25\xe7\x88\x15\xa6\x1d\x5c\x30\x58\x9a\x31\x25\x92\x89\xe4\x8f\x4a\x22\xe1\x05\x2f\x6e\x29\xb2\x93\xc7\x8f\xf9\xbe\xef\xf3\xda\xcb\xd7\x65\x07\xd7\x50\x21\x8e\x5b\xaa\x1a\x0f\x91\x5a\xc3\x65\xb0\xa0\xd2\xf4\x59\x03\xe9\xf6\x44\x95\xc7\x43\xd1\x25\xd2\xd0\x91\xcd\xf6\x61\x8e\xad\x17\x35\xce\xe4\xfb\x1b\xaa\x07\x0e\xb5\x5f\xbb\x65\x93\xb1\xc2\xf0\xac\x7d\xc5\x26\xd7\x40\xff\x7f\xdd\xad\x7e\x8d\x5b\x06\x96\x5d\x74\x8d\x87\x95\x16\x35\x57\x41\x59\x22\x32\xa4\x71\xfa\xe5\x4b\xd2\x65\xea\xd7\x89\xf0\x6e\x6e\x1a\xb7\x64\x99\xfa\xda\x75\xd7\x93\x35\x40\xf0\x11\x77\x11\x7b\x11\x0a\x42\x4c\xf6\x9b\xcc\x5e\x9f\xd9\x17\x0a\xfb\x6c\x06\xdb\x13\x0a\x32\x48\x86\xb8\x81\xb5\xb0\x06\x92\x78\xe0\x29\x6f\xb0\xd1\x60\x70\x99\x71\xef\x79\x42\xa9\x70\xb5\xba\x56\xb8\x5e\x71\x9d\x74\xf1\x64\xa9\x53\x85\xab\x09\xdf\xb8\x0f\xff\x14\x4c\x2e\x39\xd3\xaf\xd1\xf5\x4a\x18\xee\x0b\x03\x1e\x5d\x5b\xc3\xd0\x14\x86\xfa\x30\x54\x84\x21\x16\x06\x7b\x18\xd6\x1e\x08\xc3\x4e\x7a\x0b\xff\xee\x0c\xc3\x87\x61\x38\x19\x06\xfc\x02\xbe\xbf\x32\x0c\xdf\xd0\x9f\x07\xb2\x2f\xd7\x67\x5f\x93\xb5\xd7\x56\x50\x7c\xda\x9b\xa7\xa9\x12\xde\x9c\x7d\x61\x27\x7d\x41\x0e\x43\x3c\x8c\xfb\x16\x18\xe7\xcc\xee\xd6\xea\xdd\x1a\x39\x7b\xaf\xcb\xd8\x42\x15\x99\x39\x5a\xda\x04\x6c\x67\xd0\xf5\x00\xdd\xc2\x9f\x68\x87\xd2\x54\x16\x21\x45\xa2\xdb\xbd\x9a\xb4\xaa\xb2\x31\x6c\xfd\xa0\x8d\x63\x2f\x98\x92\x18\x3d\xcc\xba\xc3\xde\xb0\x6e\x56\xed\x96\x55\x6d\xb5\x0d\x0d\xf6\x5d\xee\x11\x6b\xe0\xa3\xc1\x43\x1b\xfb\xae\xb8\xea\xb6\x3b\xa6\xd6\x5d\x38\x6d\xcd\xe6\xdd\xbb\xa7\x60\x51\x44\x22\x75\xb4\xff\x24\x62\xda\x13\x1d\x78\xbc\xba\x90\x99\xce\xbe\x4a\xf3\xcf\x5c\x28\xfb\x05\xab\x95\x61\x59\xc9\x81\x6d\xf3\x20\x06\x30\xb3\x34\x09\x8d\xc4\x1e\x01\x51\xfe\x60\xd3\x79\x49\x5b\x72\xb9\x5d\xee\xce\x4b\x3e\x83\x01\x42\x34\xf5\xcb\xe2\x37\xf2\x72\xc8\x9c\x75\xc0\x3f\x69\x9e\x9a\x16\x07\x8c\xa3\xef\xff\xa7\x34\x32\xf9\x79\x69\x7a\x49\x23\xa3\xa5\xba\xe9\x95\x8a\x5c\x16\x9c\xf3\xb3\xdb\xe4\xe7\x8b\xb9\xb5\x47\xbe\x98\x6c\xb2\x98\xde\x73\xc5\xfc\x2f\xd6\x74\xaf\xf9\x43\xba\xd2\xc1\xe8\x53\xdf\x5d\x2b\xce\x13\x90\xf5\x31\xe1\xb1\x14\xa6\xb6\xd6\xa9\x6f\xc3\xfc\xec\x52\x25\x74\x6e\x21\x3f\x33\x6f\x91\x12\x83\x36\xe1\xb1\xe3\x34\x8d\x5f\x4c\xa0\xeb\xe5\xc9\x41\xa3\x18\x8d\xf0\x9c\xd5\xca\x31\x3e\xaf\x9d\xb3\xd9\x58\x96\x73\x70\x46\x36\x99\xb2\x19\xa2\x5e\xd1\xbb\x46\x91\x5c\x20\xbb\x9a\x5d\x07\x5d\xac\xd6\x43\x58\x33\xeb\x72\xd9\xed\x62\xc4\xc7\xfb\xd6\x2a\x0c\xbf\x52\x6c\x17\x19\x91\x17\x31\x12\x03\xe7\x27\xeb\x6e\xeb\xeb\x69\x66\x93\xd9\x8e\xec\x8c\x89\xbe\x4a\x45\xcf\xe5\x91\x4b\xa2\x40\xad\x99\xac\x49\x43\x06\x9f\x1a\x6d\x82\x02\x0f\x3e\x42\x36\x7b\x07\xd6\x0e\x68\x82\x0e\x86\x5d\x73\xc3\x9d\xc9\x59\xf1\x27\x7f\x7d\x13\xea\xbc\x25\x3a\x2b\xb6\x6b\x7a\xdf\x46\x5b\xf1\xd8\xad\xf3\x37\xab\xf2\x98\x01\x57\x8f\xbe\x74\x04\xcc\xba\x34\xfe\xab\xe7\x5e\xba\xff\x19\x88\x3c\xc4\xed\x7f\xd2\x1a\x51\x4f\x3f\x5e\x2e\x76\xd8\xac\xd3\xaf\x59\xb0\x46\x62\xbe\xf5\xdc\xfe\x91\x3e\xdf\xc9\xf0\xe3\xb1\x6e\xb3\x5c\x1e\x14\x4f\x26\x85\xa8\x3b\x12\x0e\x9b\x44\xc1\x66\xc3\x56\x8c\xbb\x90\x71\x17\x31\x69\x53\x3c\x12\x5f\xa3\x88\x91\x88\xa3\x90\x64\x31\x41\x5e\xb0\xb1\x5e\xaf\x43\x60\x0b\x19\xa6\x70\xbd\xc2\xd0\x05\xbf\xfa\x60\x9a\x5d\x5d\xe0\xaf\xa8\xea\x61\x87\x66\x5d\xe2\xba\xf7\x92\x98\xa0\x54\xc7\x49\xd5\x54\xa5\x69\x54\x90\x37\x17\x16\xe4\x4b\x08\x29\x1f\x89\x82\x62\xb7\x15\x9e\xdb\xed\x99\xa3\xcc\x74\xdd\xef\x9c\x11\x04\x09\x0c\x43\x2e\x5f\x37\x60\xba\x69\x82\x72\xd5\x36\x16\x0c\xce\xef\x61\xd2\xe8\x37\xde\xd8\xd4\x38\xfc\xa6\xc9\x83\xc6\xce\x9f\x3b\xf9\xfd\x2f\xec\x61\xf5\xe4\x2f\xab\x3f\xff\xcd\xfc\xf9\x89\x82\x0b\x9f\x6b\x20\x6d\x3c\x17\xfd\x9b\x7d\x89\x9b\x8a\x42\xa8\x08\xe2\xf2\x1b\x85\xd8\x1a\x32\x99\x4a\x8a\x99\x24\x96\x85\xcc\x29\xe6\x0c\xc3\x9a\x58\x46\x92\xa5\xf0\x13\x8a\xf4\xc7\x12\x38\x56\x02\x0f\x95\xc0\xd6\x12\x98\x57\x02\x23\x4a\xa0\xa0\x04\xb8\x12\xf8\x94\xde\x3f\x5c\x02\x7b\x4b\x80\xd9\x55\x02\xed\x25\xb0\xb2\x04\xda\x4a\xa0\xb9\x04\xe4\x12\xa8\x2c\x81\x78\x09\x48\x25\x80\x4a\xe0\x4c\x09\x9c\x2e\x81\x53\x25\x70\xb4\x04\x0e\xd2\x17\xce\x87\x8f\x53\xc8\x9a\xd3\x14\x68\x2f\x7d\xdc\x96\x7d\xd0\x2b\xba\xf3\xc1\xf0\x23\x61\x4e\xf7\x7e\xf1\xbf\xb9\xa5\x5a\xf3\xfb\x1b\x16\x8c\x28\xe8\x97\x72\xb3\x62\xd9\x2e\x44\x3c\x04\x42\x11\xc9\x41\x51\x53\x54\x43\x9c\x49\xbe\x1a\x9f\x40\x06\x2b\x9f\x00\xfa\xda\x44\x32\x86\x31\x5f\x5f\x78\xc5\x25\x0b\x17\xcf\x5b\x30\x7c\xf8\x82\x45\xf3\x17\xaf\x5f\xbf\x78\xf1\x82\x45\x23\x47\x2e\x9a\xa7\x3e\xbb\xe4\xd6\xdb\x16\x2f\xde\x7d\x3b\xb4\xe1\x9f\x0b\x16\xce\xdf\xb8\x69\xde\xe2\x45\x4b\x47\x8d\x5a\x3c\x6f\xe9\xc2\x4b\x36\x2c\x5a\xb8\x80\xd9\xbf\x7b\xf1\xe2\xdb\x6e\x5d\xb2\xe4\x76\xcd\x3f\xda\x88\x79\xf0\x4a\xdc\x07\x93\xe8\x0e\x79\x32\x9f\x10\x13\xd1\x68\x40\xb4\x4b\x2e\x3b\xeb\x0e\x46\xdc\x6c\x20\x60\xe1\x92\xc9\x54\x81\xc1\x62\x29\xb0\x47\x13\x51\xcc\x89\x7c\xc2\x15\x8c\x04\x71\x67\x8c\x24\x64\x93\xb5\xd1\x1e\x01\x0b\x9b\x88\x24\x22\xe0\x73\x07\x7c\x98\x43\x7d\x7e\x8b\x81\x4b\x42\x72\x8d\x62\x04\x43\xb7\x90\x2a\xaa\xb0\xea\x6b\x9f\x32\xd9\x1e\x99\xc7\xa9\x4e\x2d\xf6\x38\x6f\x08\xd7\xa6\x6f\xf2\x03\x0b\xb0\xa1\x48\x8c\x45\x81\x78\x51\x98\x44\x0d\xf9\xbf\x8a\xbd\x4a\x84\x77\xc5\xb5\x17\x43\xfd\x12\x11\xc6\x89\x8a\xba\xfd\x0b\xa7\xea\x57\x9d\x6a\xe1\x76\x4b\xc7\x3b\x96\x9b\x0b\xd5\x4e\x27\x80\x1f\x1f\xbf\xb8\x8b\x3b\xdb\xd0\x10\xec\x78\x9f\x29\xf4\x37\x34\xb8\x3b\xee\x58\x70\xfd\x82\x93\xf8\xca\x7f\x12\x5f\x30\xf3\x30\xbf\x3e\x8b\xf5\xac\x11\x54\xcf\x12\xd0\xef\xe4\x9b\x0c\x0c\xc3\x03\x98\x8c\x1c\x6f\x53\xb8\x10\x20\x1b\xae\x32\xc9\x04\xc8\x04\x67\x4c\x70\xca\x04\x47\x4d\x70\xd0\x04\x2b\x4d\xd0\x66\x82\x38\xbd\xbf\x1c\x3f\x38\x4d\x9f\xed\xa2\xb7\x34\x68\x0d\x4e\x36\x41\x25\xbd\xa9\x01\x34\xd3\x3b\x1a\xc0\x50\x0c\xdd\x4e\x31\x7d\x48\x41\xf7\xd2\xc7\x9d\xd9\x8f\xe0\xfb\x15\x26\x88\x99\xfe\xef\x94\xae\xb7\xce\x0b\x55\xc0\x55\xca\xe2\xbf\x67\x6f\xbc\xf1\x46\x36\xc1\x2c\xeb\xb8\xf5\x6c\x21\xb3\xbc\xe3\x66\x6d\xfe\xb4\xb0\x13\xd8\x3d\xfc\x72\x34\x00\x35\xa0\xab\xe5\x41\x35\xfd\x65\x24\x1b\x3c\x25\x21\x3b\x1a\xe2\xaf\x0d\xd5\xc6\xfb\xf6\x45\x21\x0f\x37\x7c\x44\xff\x1a\xff\x10\x27\x5b\x53\x36\x24\x5a\x33\xa4\x66\x08\x1b\x8d\xa6\xef\x51\x50\x72\x65\xb2\x3d\x89\x15\x9b\x64\x32\x7a\x04\x6c\xb2\x85\x15\xef\x51\xda\x8d\x60\x34\xb2\xbf\xeb\xee\xdb\xc8\xad\x80\xd3\x26\xee\xb4\x66\xd6\x17\xb2\x38\x73\x2b\x75\x35\xe3\xac\x30\xe7\xeb\xc8\x2e\xfb\x2f\xa2\xcb\x8f\xb3\x8b\x90\xf3\x5d\x1e\x31\x88\x32\x5a\x06\x00\x96\x4e\x5e\x16\xd1\x29\x65\x16\xfd\xf9\x2f\xe3\x0f\x95\xf6\x69\xb0\xa5\x16\x0d\x98\xb1\x74\xe6\x65\xcb\x96\xec\xde\x36\xba\xe9\xcd\x17\x97\x3e\x52\xda\x60\xf5\xcf\xed\xd3\x34\x75\xd4\xa8\x49\x33\xa7\xf6\xb9\xf7\xe6\x29\x63\xd5\xb1\xcb\xc6\x2c\x1e\xbb\x74\xfc\xa0\xdb\x1e\x4c\x38\x81\xdf\x5a\xd2\x47\x19\x53\x3b\x6f\xe2\xf0\x9b\x95\x35\x8f\xa4\x4a\x2f\x1b\xbf\xe3\xce\xc8\xb7\xcb\x23\x85\x63\xeb\x2b\x26\xa7\xcb\xfb\x35\xb5\xd6\x6d\xda\x5f\x54\x7f\x15\x48\xd2\xf2\x86\xaa\xc9\x7d\xc5\x8b\xea\xab\x66\x91\x7a\x7c\x90\x5b\xc2\xfc\x37\x3f\x93\xae\xf9\xed\x2f\x47\xb2\x6b\x7e\x0d\x4e\xd1\x79\xa3\x82\x90\xd8\x2c\xae\x14\xd9\x5d\x22\xd8\x45\x10\xe9\x32\xd2\xaa\x1e\x0b\x11\xf2\x17\x43\x26\xf2\xae\x99\xf6\xca\x31\x63\x2a\xfb\x8e\x1a\xa5\x2e\xad\x1c\xd3\xd8\x17\x5f\x70\x4b\x46\xf7\xeb\x37\x72\x44\x55\xbf\xd1\x63\x2b\x2a\x47\x8f\xae\xec\x37\x1a\x73\xee\x74\x6c\xdf\xbf\xc4\x4f\x46\x76\x6c\x05\xd5\x62\x1d\xf4\xd5\x84\x2b\x50\xec\x2a\x46\x35\xc6\x0a\x64\x44\x75\x83\x39\xd1\xe6\x8d\x9e\x50\x50\x00\x44\x43\xc0\x5b\x2c\x49\x05\xf8\x87\x57\xf2\x32\x76\x29\x26\x31\x26\x16\x5f\x4a\x9c\x28\x56\x1d\x57\x44\x17\x97\x39\xae\x70\xdc\xe3\x75\x70\x77\x1d\x6c\xaf\x83\x4d\x75\xb0\xb4\x0e\x5a\xea\x60\x5c\x1d\x0c\xae\x83\x4c\x1d\x84\xea\xc0\x5e\x07\xcc\x87\x75\x70\xa0\x0e\xee\xab\x83\x15\x75\xd0\x5a\x07\xf5\x75\x50\x51\x07\x31\xfa\xec\xc3\xff\x70\x7f\xd0\xf9\x77\x73\x77\xb4\x9f\xb9\x8b\xee\x4c\x3e\xe7\x3c\xe9\x9a\x9f\x5c\x29\xcf\x30\xc8\xae\xb3\xd4\x24\x4d\x5e\x0a\x96\xfc\x30\x6c\x6d\x51\x0e\xa7\x2f\x0b\x2f\x60\x78\xbd\xc2\x63\xd0\xc5\x5b\x74\x1d\x95\x60\x60\x73\x2b\x2e\x0b\x9c\xd5\xfd\x99\x82\xe9\x2f\xc0\x90\xe7\x5f\x00\xf9\xb9\x67\xd4\x57\x5e\x7e\x5e\x3d\x7a\x84\x79\xfb\xd7\x9f\xbc\x7f\x72\xfd\xed\xdc\x48\x57\xc9\xe4\x41\x5b\x56\x2e\xbd\x72\xe3\x18\xef\x28\x6e\xf3\x2b\xf7\xab\xff\xb8\xff\x7e\xf0\x3c\xb0\x17\x7c\x0f\xee\x55\xff\xc9\xec\x79\x09\x86\x3d\x7b\x44\x7d\xf5\xa5\xe7\xd4\x5f\xbd\x78\x04\xe4\xbf\x7d\xf0\xe2\xa9\x77\xa3\x27\x17\x07\x82\x77\xbc\xfc\xf0\xbe\xc1\x1b\xde\x2b\xe2\xd0\x03\xea\xdf\x1e\x7a\x50\xfd\x0c\xbf\x17\x7e\xe0\x01\x08\x3c\x4c\xfb\xe8\x0c\xa6\x93\x79\x10\xb7\xad\x13\x85\xd1\x18\x39\xcc\x85\xc3\x2e\x17\x72\x3a\xa3\x7e\x93\x29\x12\xb5\x7a\x3e\x55\x1c\x56\x8e\x0b\x1a\x82\x9f\x29\x86\x23\x60\x3e\xcc\xa2\x4f\x15\xac\xe0\x9a\xf2\xdd\xd4\x55\x99\x1e\x61\x5c\x98\xe1\x70\x47\xca\x2d\x84\xa7\x21\x0d\x55\x82\x16\x23\x5c\xd5\xaf\x86\x69\x1c\x60\x7e\x83\x69\x9e\x3d\x66\xf6\xac\x47\x2f\xae\x1f\x6e\x88\xf7\x3b\x9c\x2a\x9c\x70\x51\x63\xe5\x60\x76\xa2\xbd\x6f\xd9\xe0\xf5\x17\x2d\x3e\x30\x37\xc8\x3a\x9b\xec\x4f\xb4\x6f\x2f\xc4\x34\x36\xa3\xb1\xec\xbb\xec\x54\x64\x40\x56\x34\x55\x0e\x99\x8d\x46\x93\x28\xf2\x2c\x00\xc3\xf3\x36\xbb\x55\x34\x99\xcc\x5f\x29\x26\x23\xfe\x3b\x02\x46\x59\x34\xf0\x0c\xc3\x7e\xa5\x30\x80\xff\xf0\x0d\xb2\xa6\x99\x8e\x19\xd9\x73\xb7\xe9\x4d\x5d\xd5\x04\x57\x0a\x6a\xb2\xa7\xf7\xe6\xab\x3f\x5f\x3e\x5f\x55\x45\x36\x30\x4f\x3d\x7b\xd9\x3c\x72\x35\x55\xdd\xa4\x6e\x82\x79\x0d\x30\x4f\xbf\xc0\x82\x7b\x35\x7a\x83\xcb\x30\x67\x10\x8f\x92\xb2\x9d\xc5\x27\x83\xc0\xb0\x32\x62\xb1\x2a\x72\x88\x54\x10\xc9\xd3\xa3\xf3\x47\x36\x39\x0f\x97\xb9\xf1\xdc\xdb\xcc\x99\x8e\xf7\xe0\xb6\x5d\xd4\xc6\xd0\xf3\xe4\x60\x1b\x43\xc2\xed\xc1\xe5\xf5\xb5\x42\xd4\x07\x0d\x85\x15\xf2\x0f\x8e\x64\xd2\x15\x93\x52\xe9\x58\x2a\x36\x38\xe3\x72\xf9\xfd\xc6\xc1\xa8\xca\x88\x8c\x72\xbd\xc8\xd9\x02\xa5\xa1\xd2\x13\x4a\xd2\x91\x71\x9c\x50\x32\x99\x50\xca\xe5\xf7\xfa\x4f\x28\x85\x5e\x1a\xf6\x6d\x42\xde\x66\x6f\x9b\x77\xa5\x97\x43\xde\x76\xef\x69\xef\x19\x2f\xe7\x64\x43\xde\x90\x57\xe4\xc4\x0a\xdc\x1b\x39\xae\x06\xf7\x46\xd7\x31\x19\x0e\xcb\xf0\x90\x0c\xb7\xca\xb0\x55\x86\xb5\x32\xcc\x93\x61\x84\x0c\xfd\x65\xe0\x64\xf8\x63\xf6\xe9\x2e\x19\x98\x76\x19\x56\xca\xd0\x26\x43\xb3\x0c\xb2\x0c\x95\x32\x48\x32\x20\x19\x4e\xd1\xc7\xff\xe9\xe9\xc0\x53\xbd\xbd\xb0\xa2\xfb\x75\xbd\x0c\x15\xd9\x3b\xc6\x39\x3d\xcc\xc2\xde\xd2\x0e\xb6\x76\x0f\xb0\x3d\xbf\x9f\xae\x9a\xa3\xeb\xe9\x55\x4e\x3d\x8d\x97\xbe\x2e\x30\xd7\x65\xf3\x3a\x6e\xd7\xb4\x8a\xb6\xf0\x59\xef\xc5\xc0\xa6\x1c\x3e\x4f\xa2\xba\xc6\x51\x54\x9d\xe8\xa7\x47\xf3\x7b\x80\xd8\xfd\x0e\x3c\x82\xf4\xec\xc1\xfc\x4b\xd9\xae\x9b\xed\xca\xaa\xe9\x6f\x7d\xe7\xa8\x8f\x8c\x9f\x0a\x73\xee\xd9\xdb\x32\xe3\xe4\x28\xf5\xf3\xa9\x97\xb8\x7c\x8b\xda\xae\x3e\xaf\x0f\xeb\x7d\xf7\x79\xbd\x2f\x77\x3c\x07\xd3\xd5\xef\xa5\xda\x5a\x89\xb9\x55\xaa\x59\xb3\x64\xc2\xda\xb0\xfa\xa1\x54\xcb\x8c\x9a\xdc\xa0\x1e\x6f\x64\x7a\xeb\xcf\x80\xb6\xf1\xfb\xb9\xfd\x06\x33\x96\xda\x7d\xe5\x04\x02\xe0\x78\x60\x9e\x57\xee\x03\x88\x41\x05\xb4\xc2\x4e\xe0\xec\xb0\x19\x0e\xc0\x37\xd0\x09\x3c\x90\xc8\xb8\xd5\xb9\xe4\x4a\x90\xa8\x4e\x70\xfb\xcf\xbe\xcf\xa5\xf8\xfd\x73\x70\xbf\x3b\xc2\x7c\xc6\x16\x62\x5e\xb4\xa1\x20\x2a\x97\x7d\x7e\xa3\xd1\x89\x50\x38\x84\xc5\xbd\xe8\x79\x92\x70\x8f\xfd\x49\x85\xac\x55\x24\x31\x59\xc7\xba\x25\x8d\x72\xd1\x6e\x4f\x96\x16\x6b\xe1\x24\x79\xba\xe6\x91\xc9\x37\x4d\x99\xb2\x6b\xea\xb4\x5d\x93\xb7\x1c\x86\xea\xe6\xe5\x2b\x9a\x26\xad\x58\xce\x85\xf0\x2d\xfc\x6f\xea\x4d\x93\x0e\xc3\x98\x35\x17\x4c\x59\xbb\x76\xca\x05\x6b\x88\x7c\x9a\x86\x3b\x85\x8d\xe6\xc8\xb2\xa3\x69\x72\xb9\x96\x25\x8b\x17\xcd\x76\xde\xcc\x3b\x24\x9b\xfd\x09\xc5\xe6\xff\x3f\x4d\x97\xd5\x6d\xe6\xaf\xd7\xac\x59\x0e\xdc\xd2\xcc\x25\x7a\xe6\xac\xdb\xcf\x8d\xd6\x72\x67\xed\x82\xdb\xd4\xa5\xbb\xd4\xf2\x1d\x3b\x34\x1d\xb7\x98\xf1\x31\xdb\xf8\x51\xc8\x8f\xbe\x94\xf7\x1a\x90\xcb\x15\xf4\x59\x01\x02\x41\x51\x94\x24\xd3\xa7\x8a\xf4\x01\xe3\x03\xdf\xe7\x0a\xbc\xdf\x4a\xd7\xa7\xbe\x12\x84\x03\x41\xd8\x15\x84\x58\x10\xec\x41\x58\xba\x33\x08\x9b\x83\x80\x9f\x7d\x13\x84\x0f\xb3\x8f\x9b\xb2\x8f\x3b\xe9\x82\xd6\x03\x14\x66\x05\x05\xc3\x37\x6b\x3b\xbb\x43\xef\xa4\x0f\xe2\x41\x38\x45\xd7\xbe\x1e\xa4\x4b\x61\x9b\xe8\xd7\xf0\x4d\x29\x8b\x02\xbf\x49\x7b\x52\x4f\xf3\x7c\xce\x79\x66\xf9\x9c\x9c\x8e\xd7\x2d\xdb\x53\x97\xa4\xa4\xec\x51\x43\x73\x78\xd0\x0c\x49\x35\xd9\x94\x37\x42\x82\x49\xab\x8c\xfb\xd1\x7b\x9b\xcb\xcb\xab\x4b\xfb\x0c\x4d\xac\x9f\xb4\x7e\xf3\xc4\x9b\xdf\x86\xa5\x8c\x6f\xf5\x55\x7b\x6f\x1d\xd3\x7f\x58\x6c\xed\xd1\xd0\x82\xe9\x63\xaf\xde\x7a\x93\x56\x7f\x25\x8c\x99\x69\xc7\xf5\x57\x00\xcf\xcb\x9d\xb1\x88\x68\x4a\x26\x45\x46\x8a\x44\xd2\x3e\x6c\x82\xa6\x63\xa2\xd5\x2a\x7e\xa6\x34\x69\xa9\x13\x44\x6b\xd8\xca\x98\xac\xd6\x20\x22\x2b\x9c\x19\x62\xab\x06\x83\xae\x4f\x95\xe0\x07\x48\xf8\x54\xe1\xd8\x5b\x59\xc6\xc7\xb2\xe8\xc3\x15\x69\x68\x49\xc3\xb8\x34\xd4\xa7\x21\x93\x86\xb3\x69\xf8\x67\x1a\xde\x4b\xc3\x1b\x69\x78\x21\x0d\x77\xa7\x61\x7b\x16\x60\x30\x05\x08\xa5\xc1\x92\x86\x25\x1a\x1c\x86\x78\x3c\x0b\xb4\x29\x0d\x4b\xd3\xd0\x4a\x41\x35\xa0\x7c\x5c\xaf\xa4\xe1\x00\x85\xd4\xc0\x30\xc6\xa6\x2c\xc6\x58\x16\xf8\x53\x8a\x2d\x07\x80\x6f\xd6\xe6\x50\x68\x5f\xca\xa3\x45\xae\xea\xf6\x95\xc7\xcf\x43\xce\x9c\xa6\x9f\x6c\x4f\xc3\xca\x34\xc8\x69\xb0\xa7\x73\xd2\xb1\xb5\x97\x55\x06\x73\x7a\x73\xcb\x74\x5f\x87\xd0\x4b\x32\x48\xe2\x43\x9f\x33\xbb\x2b\x6f\x16\xf5\xc4\x0c\xaa\xc8\x4e\x1c\x76\x8d\xef\x79\x6b\xa7\xb3\x31\x41\xd5\xfd\x69\xea\xac\x1e\x8c\x41\xf3\x0a\x18\x80\x5d\xb9\x24\x34\xcc\x54\x3a\xec\xd0\x8a\x11\xb6\xfa\xad\x95\x99\xfe\x65\x15\x43\x93\xcb\x94\x55\xd7\xfc\x66\xca\xb4\xe7\x18\x73\xe8\x8d\xad\x81\x97\xd6\x98\x0c\x53\x38\xe1\x91\xbe\xd5\xa1\x0d\xaf\x86\xe6\x34\x3f\x97\xb2\x4c\x1f\xb5\x81\xac\x63\xe9\xe0\xe6\x30\x9f\xd2\xd8\xde\x22\xd9\xcf\x22\x3c\xbc\xf2\xcc\x0d\x2d\x9b\xf9\x9d\x3c\x63\xe7\x63\xfc\x01\xfe\x24\xcf\xf1\xb9\xe0\x5e\x6d\x51\x0d\x71\xf2\x77\x18\x8e\x41\x84\x53\xd7\x70\x73\x12\x20\x15\xaa\x3f\x90\x79\x85\x5f\xab\xe3\xb9\x89\xec\x7e\x14\x45\x33\xe4\x0a\xde\x8b\x65\x46\x20\xc2\xb0\x51\xab\x18\x15\x63\x71\xc9\xe1\x30\x5b\x2c\x71\x7f\xc8\x21\xb8\x85\x49\x8a\xdb\x2b\x59\x27\x2a\x92\xc7\x62\x87\xe8\x44\x05\xec\x48\x9f\xf8\xc9\x69\x3c\xb9\xf9\x05\x67\x36\x9b\x95\x4f\x5b\xd1\xa3\x67\xd3\xc8\xce\xf3\x11\xe1\x57\x64\xc0\x17\x03\x9c\x35\xae\xc5\x74\x4a\x2f\x3b\xd7\xa7\x58\xd5\x5f\xb0\x03\x6f\xae\x6d\x8a\x97\x35\xaa\x5f\x1b\x93\xe3\xbd\xd7\xb3\x4b\x1a\x3a\x7e\xbd\xa6\x84\xcc\xf9\x4d\x26\x73\x7e\x07\x26\xaf\xea\xfb\xf3\x9f\xca\x47\x83\xe9\x32\xd6\x4a\xfa\x4d\x4a\x55\xd9\x97\xb0\x6d\x6d\x47\x55\x72\x80\x37\x30\x00\x06\x33\x2b\x39\x04\xc1\x6a\x40\x9c\x95\xbb\x47\xb1\xb2\x8c\x01\x5b\x47\xc7\x72\x93\x39\x15\x39\x87\x94\x26\xe7\xc8\xff\x9a\xa9\x93\xf0\xb0\x4b\x6e\xb8\xf6\x86\x5f\xfe\xed\xe3\x53\xf0\x77\xee\xfd\x9f\x13\xfc\x87\x3f\x27\xd8\x94\xf0\xa7\xe7\x9e\x7f\x63\x0c\xd6\x4b\x16\xe1\xf1\xe1\x30\x3b\xce\x69\x30\x0e\xa7\xf3\x32\xc7\xd5\x66\xb8\x1a\x55\x60\x3d\x71\x98\x1c\xc7\x3d\xd4\x62\x36\x33\x46\x23\x23\x49\x2e\xb7\x95\x94\x46\x16\xa5\x46\xab\x15\x8b\x69\xfe\x16\x05\x1d\xc1\x76\x08\x0d\xcc\x23\xe9\xd7\x72\xe3\x42\x4e\xe2\xba\x30\xeb\x68\xa3\x01\x66\x21\x8d\x51\x66\x37\x8f\x2c\xac\xa9\xac\x18\xb2\xe4\x82\x96\x4c\xb3\xf2\xa8\xda\x1c\xb9\xd0\xd5\xaf\x74\xa2\xf0\xab\xe5\x96\x49\x43\xe6\xae\xd3\xe4\xc6\x38\x2c\x77\xe3\xfc\x70\x64\x46\x15\xb2\xb7\x2b\x3f\x9e\x20\x9b\xfe\x4a\xd6\x58\x7c\xa6\xb0\xef\x67\xe5\x57\xf0\xad\x6e\x59\xf1\xf4\x25\xb0\x02\xd6\x43\xe1\xf6\xeb\x45\xb5\x46\xdc\x31\xff\x66\xcb\xd9\x99\xcc\x22\xdb\xf0\xe1\x36\xa6\xae\xa4\xe1\x1a\x3c\xd6\x5c\xce\x32\xcc\xe3\x78\xbc\x33\x63\x3b\xab\x4c\x76\x73\x1e\x4f\xc0\x64\xb3\xf9\x03\x4e\xc3\xa7\x8a\x93\xb3\x60\xd5\xd7\x82\x75\xe0\x6e\x41\x5d\xd9\x95\x97\xc4\x42\xa4\xfa\xad\x2f\xab\xf3\xd2\xcc\x46\xcb\x2a\x46\x97\x4e\x1b\x31\x7d\xf8\xfc\xcb\xa7\xdd\xd1\x3a\xff\xf2\x17\xd8\xc6\x59\xf7\x34\x6d\xfa\xf5\xd6\x0d\xa3\x36\x2f\xbf\xf0\xe1\xd9\x9b\x97\xef\x7e\x13\x31\x9d\x2a\xd6\x6f\xaf\xf9\x1f\xf5\x5b\x0b\xd6\x6d\x85\x7c\xfd\x96\xc3\xba\x2d\xfa\x3f\xd6\x6f\x0b\x53\xc0\x56\x81\x00\xfa\xe9\xdc\x7c\xe0\x2f\x9b\x0f\x20\x9e\xfb\xfb\x3c\xe0\x36\xcd\xc3\x57\x63\xe1\x6a\xb8\x5a\xbd\xa7\x41\xbd\x47\xbf\x20\xba\xa9\xdc\xa9\xf2\x37\xf0\xc3\xa5\x22\xa1\x83\xc1\x43\x9f\x94\x46\x9b\x7e\x44\x0e\xc1\xc8\xb3\xee\x8e\x7f\x30\xd3\x9e\x89\xcb\x9b\x37\x37\xc6\x49\xe6\xe3\xcb\x2f\xa7\x67\x39\x79\xd9\x65\x8d\x71\xf9\xd2\x4b\xf1\xe1\x92\x4b\xf0\x61\xc3\x06\x7c\x58\xbb\x16\x1f\xd6\xac\xc1\x87\x55\xab\x34\xf0\x8b\x2f\xd6\xce\xcb\x96\x69\xaf\xd9\x96\x2c\xc1\x4f\x17\x2d\xc2\x87\x85\x0b\xb5\x5b\xa6\xf9\xf3\xf1\xaf\xb9\x73\x75\x80\x0b\x2f\xc4\xbf\x5a\x5b\xf1\x61\xce\x1c\xed\x96\x7f\xf6\x6c\xfc\xab\xa5\x05\x1f\x66\xce\xc4\x07\x45\xc1\x87\x19\x33\x34\xc4\xd3\xa7\x6b\xe7\x0b\x2e\xd0\xce\xd3\xa6\x69\xe7\xa9\x53\xb5\x97\x5d\x93\x27\x63\xe8\xe6\x66\x7c\x68\x6a\xc2\x87\x89\x13\xc9\xfd\xf6\x43\x13\x26\x68\x70\xe3\xc7\xeb\x1f\x19\x3b\x16\x3f\x6d\x6c\xc4\x87\xd1\xa3\xf1\x61\xc4\x88\xc6\x78\xfb\xf0\xe1\x3a\x89\xc3\x86\xe1\x5b\xf5\xf5\xda\x2b\x43\x86\xe8\x77\xeb\xea\xf0\xdd\x41\x83\xb4\xbb\xfd\xfb\xeb\x88\xfa\xf5\xc3\x77\x2b\x2b\xf1\xa1\xa2\x02\x1f\x8a\x8b\xf1\xa1\xa8\x48\xfb\x6a\x32\xa9\x97\x32\x91\xc0\x77\x63\x31\x7c\x88\x46\xb5\xf7\x23\x11\xed\x1c\x0e\xeb\x78\x02\x01\xfc\xd4\xe3\xc1\x07\x97\x0b\x1f\x24\x09\x1f\xac\x56\x0d\x48\x14\xb5\xb3\xc5\xa2\x9d\xcd\x66\xed\xa5\xb1\x46\x63\x23\xcb\xb4\x4a\xd0\x44\x97\xb4\xc5\x25\xb0\x4b\x20\x11\xc7\xd0\x49\x13\xbc\x62\x82\x03\x26\x68\xa2\x21\x8b\x26\x6c\x6a\x91\xdd\xf4\x2b\x49\x32\x13\x78\x05\x41\x6b\xf6\x1a\xff\x43\x2c\x23\xf9\x51\x7d\x75\x35\x38\x72\x03\x47\xb5\x76\x39\x5b\x3f\x57\x57\x67\xfe\x5f\xff\x23\x7c\x57\x8e\x10\xff\x07\x9d\xef\xe6\x68\x7c\xf7\x31\xe6\x3b\xb4\x96\x1d\xdb\xf1\x0f\x34\x50\x2e\xc0\x84\x30\xed\x74\x69\x20\x2d\x45\x96\xf8\xcd\x08\xf6\x22\x58\x41\xc9\x46\x84\x22\x8d\x3e\x7c\x58\x55\x8d\x09\xa7\xf6\xd6\x5c\xcc\xd3\xf7\xf0\xa3\x28\xee\xc7\x29\xee\x75\xb5\x1a\x4f\x17\x60\x9e\x5e\x25\x77\xd6\xb6\xb7\xb7\x37\xd6\xb6\x63\xce\xae\x6d\xbf\xe2\x0a\x7c\xc0\xbc\x5d\x2b\x63\xbe\xae\x95\x37\x6e\xc4\x07\xcc\xdc\xb5\xed\x98\xb9\x6b\x8f\x62\xe6\xae\x95\xd7\xaf\xc7\x3f\xd7\xad\xc3\x07\xcc\xe6\xb5\x47\x31\x9b\xd7\x1e\x5d\xbd\x1a\xff\xc4\xbc\x5e\x2b\xaf\x5c\x89\xaf\x56\xac\xc0\x87\xe5\xcb\xf1\x01\xf3\x7d\xad\x8c\x99\xbe\x56\x5e\xba\x14\x1f\x30\xd7\xd7\xb6\x2f\x5e\x8c\x0f\x98\xf5\x6b\x09\xeb\xd7\xca\x0b\x16\xe0\xc3\xbc\x79\xf8\x80\x79\xbf\x56\xc6\x7c\x5f\xdb\xde\xd6\x86\x91\x62\xe6\xaf\x25\xcc\x5f\x2b\xcf\x9a\x85\xef\x61\xc6\xaf\x6d\xc7\x8c\x5f\x4b\x78\xbe\x56\xc6\x0c\x5f\x2b\x63\x6e\xaf\x95\xa7\x4c\xc1\x87\x49\x93\xf0\x53\xcc\xde\xb5\xed\x98\xbd\x6b\xdb\x31\x7b\xd7\xca\x98\xa7\x6b\xdb\xc7\x8d\xc3\x57\x98\xa9\x6b\xdb\xc7\x8c\xc1\x07\xcc\xd4\xb5\xf2\xa8\x51\xf8\x30\x72\x24\xfe\x89\xd9\x5b\xf6\xd4\xca\x98\xc1\x6b\xe5\x86\x06\x7c\x90\x65\x7c\x17\x73\x78\x2d\x61\xa3\x26\xcc\xd9\xb5\xf2\xc0\x81\xf8\x50\x53\x83\x0f\x03\x06\xe0\x43\x75\x35\x3e\x54\x55\x61\x30\xcc\xdc\xb5\xed\x98\xb9\x6b\xe5\x3e\x7d\xf0\xa1\xbc\x1c\x1f\xca\xca\xf0\xbd\x4c\x06\x5f\x95\x96\xe2\x03\xe6\xfa\xda\x76\xcc\xf5\xb5\x72\x3a\xad\xe1\xf4\x17\x14\xe0\x5f\x98\xef\x6b\x09\xdf\xd7\x12\xbe\xaf\x95\x31\xd3\x93\x87\x87\x42\x21\x72\x6e\x3f\x14\x0c\x6a\xc0\x11\xcc\xfc\xb5\xb2\xcf\x87\x0f\x98\xf9\x6b\x65\xa7\x13\x1f\x6c\x36\x8c\x13\xf7\x80\x5a\xbd\x07\xd4\xea\x9c\x4f\xdf\xe8\x27\x08\x98\xf3\x0f\x64\xa0\x89\xfe\xab\xcc\x40\x06\x76\x1a\x60\xb3\x01\x56\x18\xa0\xd5\x00\x4d\x06\x30\xa0\xa6\x2c\x93\x63\x0e\xcf\x74\x71\x78\x96\xa7\x1d\xff\x3f\x71\xf6\x7f\xe0\x77\x9a\x5f\x6c\x2a\x5b\xce\xbe\x84\x47\x9d\x14\xda\x20\xc7\x91\xd5\xe9\x70\x0b\xee\x44\x22\x64\x0d\x15\x14\xba\x1d\xf7\x2a\x68\xaf\x1b\x48\x8a\xc2\xb8\x8b\x35\xb1\x2e\x52\xb0\x58\x28\xd5\xe8\x76\xb9\x5d\xe6\xa8\x3f\x7a\x77\x8b\x5f\x6a\x33\x80\xdd\x00\x34\x83\xb0\x99\xb9\x47\x31\x6b\x23\xf0\x7f\x48\xa2\x96\x9f\x43\x2d\x3b\x42\xf2\xee\x6c\x72\x25\x6d\xb6\xad\x9e\xa9\x72\x09\x36\xe8\x36\x01\x37\x34\x97\x3e\xed\xb7\xbf\xf9\xaf\xa3\x2d\xf5\x0b\x99\x79\xd7\xac\x83\xb1\x7a\x1e\xb5\x4d\x24\x77\x9a\xfa\x6e\xe5\xbd\xbb\x1e\xff\x4b\x3f\xff\x6f\xd4\x5f\x07\x92\xbb\xd9\x27\x73\x69\xd4\x3a\x3b\xb5\x7c\x5d\x86\xf7\x9d\x69\x54\x80\x48\x7f\x1e\x0e\xb5\x30\x11\xa5\x64\x1f\xe3\xe2\xd3\xcc\x2e\x37\xb4\xbb\x21\xe6\x06\xbb\x1b\xf6\xba\x7d\x8c\xb1\x10\x32\xb4\xea\x51\xa6\x9a\xce\xc7\x9e\xf7\xfe\x7a\x78\x06\xbf\x5f\x2a\xbb\xe9\xfb\xad\x2e\x68\x72\x41\xbd\x0b\x62\x2e\xb0\xbb\xe0\x08\x28\x87\x5d\xde\x1c\x16\x8a\x26\x87\xe3\xbb\x2c\x0e\xe6\x3a\xb8\x18\xe3\xc8\xc8\x91\xee\x38\x2a\xb2\x68\xde\x75\x75\x51\x72\x3e\x2d\xaf\xe6\xf0\xec\x81\x19\xf9\x78\x42\xd0\x14\x82\xfa\x10\x54\x84\x20\x46\x43\xf5\xfe\x14\x4a\xff\x0f\x78\x1e\xcd\x95\x69\x09\x5c\x88\xf1\x98\x0f\xb3\x04\x0f\x86\xea\xa2\xf9\xf2\xdc\xb7\xee\x81\x29\xe8\x69\xe4\x95\x45\x96\x29\x64\x59\x06\x79\xc3\xbc\x01\xa3\xae\x26\x42\xae\x1a\xeb\x13\xad\x08\x09\x95\x58\x4f\x4c\xa1\x34\xfa\x44\xbe\x24\x1d\x89\x16\x84\x43\xa8\xb0\x30\xa4\xe5\x92\x0a\x85\x52\x3e\x2b\xcb\x16\x15\x47\x53\xa9\xa2\x54\x34\x44\xd3\x47\x69\x69\xa5\xcc\xe1\x48\x3a\xd2\xa6\x14\xa4\xed\x34\xbf\x54\xda\x9c\xd6\x32\x4c\x25\x02\xbd\xe4\x97\xf2\x06\x9c\x85\x26\x92\x62\x4a\xe6\x9b\xf9\x36\x9e\x45\xf4\xb4\x97\x3f\xc8\x1f\xe5\x0d\x26\x96\x27\x7c\x2a\xfa\x43\x8d\x7c\x36\x05\x55\x96\x23\x33\xad\x73\xf2\x36\x3f\x68\xd5\xbc\x34\x5d\x6e\x9b\xec\x4c\x4e\xd6\x61\x53\xd5\x23\x22\x29\xe7\xb2\xc1\xa7\xff\x35\x51\x95\xa6\x89\xd7\x03\xb8\x80\xad\xdb\x21\x72\xeb\xea\x5a\x0c\xcb\xee\x3c\x3e\x1d\x42\x5a\xce\xaa\xcf\x5a\x7e\x3c\x36\x6d\x5e\xcb\xd4\xb3\xf7\x8b\x4f\x0d\x51\xe7\xa9\xb7\x89\x6a\xb3\x78\x39\x3b\x7e\xa5\xda\x97\xfb\xd4\x39\xfa\xfc\x14\x56\x24\xb1\x1b\x5d\x71\x7a\x82\xb9\xb2\x63\x33\x1d\x53\x46\xa9\xcd\x24\xe7\x19\x6e\x9f\x34\x6d\xc3\x8d\x70\x12\x37\x6e\x48\x36\xeb\x3b\x6b\x48\x09\x38\xd2\xb9\xe7\x70\xa2\x82\x35\x69\x1c\xa0\xb7\x3d\xcd\xf3\x45\xf9\xb9\x58\xef\x0f\xa5\xb8\xed\x5d\xb2\x05\xc2\x7c\x1a\x16\x46\xe2\x01\x96\x34\x6b\x8e\x57\x7a\xc2\xaf\x87\x5b\x30\xbc\xe7\x30\x05\x3f\x02\xb6\xc3\xe1\x58\xd7\x1b\x39\xf8\xef\xb2\xf0\x98\xd7\xb7\xe5\xe1\x7f\x33\xdc\x3b\xfe\x47\x73\xf8\x97\xc0\x12\x0c\xef\x93\xad\x0c\x79\x81\x81\x5f\x66\x0a\xb5\x37\xc8\x2b\xfa\x3b\x34\x6f\x12\xa5\xa9\x4c\x2b\x03\x9a\xa8\x7f\x43\xc4\xdf\x68\xb5\x4a\xb4\xcc\x5d\xdf\x20\xf0\x97\xe7\xc1\xaf\x47\x77\xe6\xc1\xff\x5d\xb4\xf7\x02\xbf\x86\x96\xa1\x4c\x2b\x03\x5a\x9b\x07\x7f\xbd\xd8\x1b\xfe\x65\xb4\x0c\x1a\xfe\x25\x68\x5d\xb6\x0c\x22\x29\xc3\xde\x90\x47\x7b\x23\x5b\x86\xbc\x5c\x70\x64\xdd\xe7\x34\xb9\xd2\xeb\x0b\xb2\x21\x93\x68\x0d\x71\x46\x17\x32\xa2\x78\x22\x68\x12\x31\x97\xfb\x44\xd1\x6e\xb0\x7b\xdb\x14\xbb\x15\xf7\x17\xd6\x80\xfb\x09\xc9\xce\x63\x70\xf7\x48\xc9\x57\xd5\x23\xd1\xb1\x2f\xeb\x55\xa4\x89\xe1\xc8\xa6\x26\x24\x2f\x08\xa2\x79\xe3\x48\x8a\x63\x92\x3b\x8e\xdf\x9d\xcb\x0e\xa7\xec\xf7\xee\x9f\xb9\xcf\xca\x98\x48\xce\x38\xf5\x84\x7a\x61\xe1\x0c\x00\x8f\xaa\x4e\xa7\xa9\xe4\x58\xb7\x9e\x2b\x0e\x3a\x36\x42\x67\x70\x8c\xfa\x91\xfa\x77\x38\xa1\x8a\x1b\x55\x87\x11\x16\xe0\xf2\xd3\xbc\x3c\x54\x2e\xf5\xd5\xe5\xd2\xb7\x7a\x7d\xb9\x71\x7d\x1d\x0b\x17\x89\xdd\xda\x5c\xcb\x8f\x43\xdb\xa3\x9f\xce\x83\x97\x69\xf0\x4c\x14\x57\xd7\xf0\x58\xd2\x19\xfc\x1f\xe1\xd7\xc3\x3f\xf3\xe0\xcf\x44\x13\xbd\xc2\x7f\x97\x85\xc7\x3c\xf8\x9b\x3c\xf8\xdb\xa3\xbd\xe3\x7f\x35\x07\xbf\x07\xde\xca\x83\x7f\x22\xdd\xb7\x57\xf8\x47\x73\xf4\x2c\x81\xd7\x31\x7c\x48\x96\x58\xf2\x02\xcb\xd8\xcb\x61\x5f\x79\x11\x7d\x69\x76\x57\x9b\x03\x3a\x8c\x54\xce\xc4\x4d\xc5\x06\xeb\x04\xb9\x0f\xc7\x20\x83\xd1\x6c\x36\x30\xac\x68\x6d\x63\xb1\x1e\x50\xc9\x36\xb3\x6d\x34\x45\xab\x01\xb1\x71\xfa\xb3\x9d\x3d\xc8\x9e\x62\x4f\xb3\x46\x56\xcf\x96\xca\x66\xb3\xa5\xe6\xed\x9c\x41\x17\x1a\x99\xa0\xc6\x04\x3e\x13\x08\xcc\x1c\xf5\x85\xf9\x30\x42\x7d\x71\x11\x34\xc0\xa8\xf9\xea\x8b\x30\x62\x3e\xd3\xa0\xbe\xb8\x00\x46\x41\xc3\x22\xf2\x73\x81\xfa\xa2\xfa\xfc\x02\x92\x23\xf2\xdd\xce\x13\x06\x17\xbf\x82\xe6\xa8\x29\x42\x8a\xdc\x2f\x11\x48\xfa\x39\x6f\x4c\xb2\x32\x3c\xe7\xf4\x72\x42\xcc\xee\x14\x9c\xc5\x25\x49\x7f\x22\xc0\x85\x0a\x2c\x58\x66\x33\xbc\x64\xe5\x90\xcd\xc2\xa1\x82\x56\x45\xcb\xe0\x42\x27\x45\xe9\xe2\x7a\x1a\xa3\xda\x7d\x91\x29\x5d\x13\xc7\x27\x8b\xc8\x86\x31\xb9\xa5\xc8\x02\x4d\x69\x04\x6e\x1f\xd0\x2c\x3c\x85\xfd\x8b\x80\xe6\xe1\x61\x36\x7f\x70\xc7\xdd\xb7\x7d\xb6\x96\xa4\xde\xf9\xc7\x9d\xfb\x6e\xfa\x76\xe9\x09\xf5\x41\x55\x32\x32\x2f\x36\x1e\xda\xf8\xd6\x16\xe6\x0b\xa1\x63\xf4\xe8\xff\xba\xfc\xb7\x5b\xdd\x97\xdc\xfd\xd9\x8d\xa7\x48\xe6\x9d\xad\xfb\xbe\xbb\xe1\x35\x92\xe6\x08\x7e\x1a\x97\x61\x9e\x7f\xfe\xb8\x7a\xf5\xe3\x15\xb5\x1d\xa3\x1f\xa5\x79\x78\x70\x5b\xd1\xdc\x29\x94\x77\x06\xea\xbc\xb6\x47\x93\x5f\x11\x22\xbf\x3a\xbf\x3e\x1c\x4d\x20\xa9\x4b\x7e\x9d\x07\xbf\x9e\x89\xeb\xbc\x4c\x5e\x78\x22\x12\xef\x82\xce\xc3\xff\x5d\x16\x9e\xb9\x8e\x81\x3c\xf8\x0b\x22\x89\x5e\xe1\x1f\xcd\xe1\x5f\x02\x67\xb3\xb2\x22\x42\x64\xc5\xfc\xb2\xb4\xf6\x46\x97\xbc\xd3\x72\x3f\x50\x9a\xea\x74\xfe\x7f\x5d\xff\x86\x07\x7f\xe3\x97\x1e\xbf\xd1\xd1\xf5\x0d\x22\x5b\xb0\x4c\x7d\x9a\xe6\xfe\x0c\xa3\x39\x72\xb5\x5d\x30\x84\xb9\x50\x48\x92\xbc\x1e\xc6\xe2\xb1\x44\xa2\x21\xaf\xdf\xdb\xaa\x84\x0d\x58\xac\x08\xf8\xcf\x1e\xb3\x33\x26\x36\x6c\x0f\xdb\x5d\x7e\x56\xf2\xb8\x3c\xad\x8a\xcb\x99\xb7\x8a\x58\x8b\x75\xc8\x74\x0b\x7b\xcb\x2d\x77\xcc\x65\xfa\xa4\x19\xd5\xb5\x98\x06\x2d\x4d\x19\xc3\xf4\x07\xe5\xd2\x4d\xa5\x8b\xbf\x78\xef\xef\xea\xfb\xea\x0f\x37\x45\x1e\xb5\x76\x5c\x99\xcb\x46\x17\x86\x8d\x30\x69\xeb\x15\x1d\x4f\x30\xaf\x3e\xfb\xc4\x47\xff\x7c\xb4\x2b\x39\xdd\x1e\xe2\xfb\x79\xa6\xf3\x4b\xf6\x0b\xfe\x01\xd4\x1f\x97\xa0\x4a\x0c\x16\xa6\xd3\xa5\x28\x18\x2c\x89\x55\x56\xba\x0d\x25\x86\xea\x01\x6e\xd4\x2f\xc2\x95\x9b\xca\x93\x4d\x4a\x39\x14\x95\x4c\x54\x8a\x3c\x26\xc7\x44\x45\xb6\x35\xdb\x18\x9b\xcd\xe4\xcd\xcd\xd7\xe7\xed\xab\x92\xb7\x3c\x35\x9b\x1c\x8e\x2e\xfe\xf0\x51\x77\x50\x5e\xac\x31\x0d\x31\xa6\xb1\xd4\x9a\x8b\x91\x2c\xaf\xc0\xa5\xd2\x17\xe9\x08\x98\x67\xbf\xed\xd3\x77\x54\xc5\x9b\xbf\x68\x5e\x19\x4c\x35\x38\x4a\x6b\x86\x4d\x08\x94\x37\x8c\xbe\x74\x9e\xd8\x77\x40\xe3\xf4\xf4\x3e\xf5\x7e\xcb\x05\x77\x94\x7f\x7d\xf2\xc0\x03\x96\x75\x97\xb0\xc9\x8a\x0b\x07\x4f\x5b\x35\xec\xa1\xa3\x21\xdb\x87\xd7\x14\xb6\x4e\x2d\x1b\x37\x76\xc2\xb4\xd5\x2b\xf6\x47\x5a\xfa\x4f\x99\xfc\x5f\xef\x9d\x6b\x6c\xf0\xb3\x73\x00\xfd\xe3\xa1\xfb\xab\x9b\x5a\x49\x7b\xd3\x9c\x00\xfc\x4e\xdc\xde\x23\xf4\xf1\x6d\x1f\x6e\x57\x22\x8f\xe2\x8e\x34\xb3\x20\x51\x60\x76\x76\xe3\x29\x0c\xcf\x19\xf2\xe0\xd7\x03\x49\x98\xe6\x39\x4c\xc1\x8f\x40\xec\x70\x3c\xd5\xf5\x46\x0e\xff\x43\x59\x78\x3c\xbe\x1d\xcd\xc3\xbf\x35\xde\x0b\x7e\xf6\x3d\x7e\x4d\x0e\x7e\x0f\x7a\x20\x0f\x7e\x63\x71\x55\x2f\xf0\x27\xf9\x99\x39\x7a\x96\xa0\xc7\xa8\x6e\x82\xe5\x23\x7e\x81\x65\xee\xab\x80\x2d\x15\x25\xf4\xa5\xd9\xf9\x7c\xae\xbd\xf7\x46\xee\x3b\xf7\xa0\x83\xf8\x01\xee\x1b\xfa\x7b\xdb\x52\xda\x4b\x5d\x32\x95\x45\xc1\xce\x7f\xf2\x77\xb1\xaf\x21\x13\xea\x83\xea\xd1\x62\x79\x20\xf2\x7a\x93\x95\x95\x55\x66\x56\xaa\xad\x2d\x8e\x70\x52\xb1\x24\x0f\x2b\x1b\xd0\xa4\x98\xcb\xa4\xe4\x90\xc2\x21\x93\xc8\x3c\xa5\xbb\x49\x41\xc8\x1a\x8f\x07\x9a\x95\x70\xdc\x6b\x15\x9a\x14\xab\x9e\xc1\x3c\x9b\xc1\xb3\xe7\x4c\xf3\xa0\xae\xed\xb0\x74\xef\x9e\x3e\x2d\x61\x28\xca\x6d\x41\x21\x18\xba\x96\xff\xa7\x92\xf9\xe9\x17\xbc\x6c\x11\x8d\xf7\xe8\x4a\x11\xc0\x5e\x3d\x65\xfb\x84\xbe\xe1\xd1\x5b\x52\x55\xd7\x0e\xbd\xe1\xbe\x6b\xce\x3e\xc0\xcf\x9d\x55\xb5\x50\x29\x9b\xfe\xdb\xb6\xce\xc6\x89\x0f\xcc\x69\xbf\xe7\x4e\xb0\xef\x1d\x78\xf7\xeb\xec\xd4\x31\xfd\x97\x14\x8e\xbb\x76\xca\xa8\xfa\xb2\x4d\x70\xce\xd4\xb4\x76\x48\x69\xe9\xef\xff\x9d\x2c\x58\x39\x5b\xb9\xe3\x22\xab\xbb\x72\xd5\xa6\xd4\xe0\xfa\x31\x93\x9f\x9e\x35\xfd\x17\xf7\xee\x87\xcc\x93\x85\x1d\x8b\x1b\x2e\xff\xae\x25\x5d\xb8\xf3\xfb\x2b\x96\xae\xbb\x00\xd7\x6b\x54\x6d\x26\xb9\x0e\x70\xbd\x8e\xd2\x74\x45\x44\xf2\x58\x78\x9f\x05\x29\x06\x28\x86\xa5\xe0\xca\xc3\xb1\x72\xd6\x4c\xf5\x44\xac\xfb\x6b\xeb\xf4\x29\x3f\x35\x62\x78\x03\x1a\x3e\x4f\x6b\xed\x24\x6e\xed\x89\xa9\xb4\x13\xe5\xf1\x12\x81\x7d\x3d\x07\x4b\x74\xab\x8f\x35\xde\x4b\x52\xde\x33\x1f\x4e\x16\x9e\x07\x7f\x13\xe5\xbd\x46\x9d\xf7\x6e\x46\x5d\xd8\xb7\x24\xf3\xb0\xa3\x2c\xfc\xc5\x94\x97\x34\x5a\x96\xac\xd7\x39\x22\x49\x38\x62\x53\xdf\x8c\x06\xaf\x71\x04\x86\xaf\xc0\xc2\x43\xa5\xf4\x7c\xaf\xf5\x9d\xce\xcd\x1a\x7e\x30\x3a\xd2\x50\x62\x12\x59\xa1\x1b\x7e\x0c\xcf\x1c\xcb\xc1\x1b\xd0\xfa\xd3\x5d\xd0\xc7\x8d\x96\x2e\x68\xc2\x9f\x18\xf6\x11\x4a\x3b\x85\x65\xae\xdb\xd7\x05\x7b\x81\x51\xec\x06\x4b\xf0\x3e\x40\xe9\xd6\xf0\x2e\x79\x1c\x69\x52\x1e\x03\x33\xb0\xc2\xe7\xd0\xa0\x75\x4e\x66\x50\x0a\x97\xf3\x77\xfc\x21\x14\x42\x25\x68\x99\x5c\x17\x76\xf8\x52\x29\x23\x1f\x40\x4c\xd0\xe0\x30\x98\x1d\xe6\xd2\x4c\x00\x19\x79\xce\x10\xf4\xa5\x3d\xe9\x26\xc5\x1e\x8c\x05\x19\x91\x0d\x7a\x82\x1e\xd6\x66\x8b\x91\xfc\x1a\x06\x03\xb6\xcb\x9a\xf0\xa0\x9c\x35\x79\xba\xcd\x4b\xf7\xd8\xe4\x0d\x5f\x55\xe9\x93\xcf\x58\xea\x79\x7d\x85\x76\xf0\x3a\xe8\xea\xbe\x6c\xf8\x44\xba\x88\xaf\x61\xb5\x15\x8a\xfa\x26\x5b\x8c\x38\x51\x71\xdd\x71\x2d\xd4\x7a\xff\xf0\xc7\xed\xff\xba\x7f\xdf\xa9\xad\x3f\xde\x57\x37\xc8\x34\x5d\xfd\xdc\x1b\x6f\x1c\x3c\x6c\xc3\xa8\x61\xf5\x43\x2f\x1d\xcb\xbd\xda\x10\x5d\x56\xd0\xf2\xf0\x65\x2b\xde\x50\x9f\x7e\x53\x7d\xee\xe0\x6f\xf7\x3d\xfc\xf3\xb5\xd6\x6d\x2b\x6f\xbd\xe2\xdc\xcb\x0b\x16\xdc\xfe\xd3\xf6\x96\xb6\x5b\xbf\xa5\x75\x4f\xd6\x81\x7a\xa8\x5c\x99\xa4\xcb\x95\xbf\x52\x39\xe1\x80\x20\xae\xd1\xfa\x24\x54\x24\x61\x7b\xb2\x5c\xf0\x68\x9c\x99\x6b\x33\xba\x0e\x93\xb6\xd9\x64\x8d\x3f\x97\x6a\x1c\x14\xc2\x55\x5b\x19\x8e\x49\xbe\xbc\x76\x20\xb0\x2f\xe6\x60\x09\x7f\xfe\x19\x75\x41\xbf\x17\x8a\x76\x41\xe7\xe1\x7e\x28\x0b\x8f\xf9\xf3\xd1\x3c\xf8\x35\xa1\x58\x2f\xf0\x9a\x6c\x9c\xdc\x43\x36\x12\xf8\xf6\x54\x9f\x5e\xf1\xcf\xcc\xd1\xb3\x04\xdd\x9f\x95\x71\x21\xc2\xd1\x57\x96\x16\x68\x6f\xe4\xc9\xb8\x79\xe8\x17\x5c\x98\xbb\x93\xee\x6f\x17\x22\x6b\x08\x03\x56\x97\x55\x10\x80\x01\x26\x12\x36\x73\x07\x15\x33\x32\x4b\x66\xc6\xc4\x83\xd9\xa6\x20\xc9\x26\x79\x0f\x2a\x12\xee\x07\xd9\x98\x10\xbf\xf4\x3a\xf1\xfa\x60\x2e\xc8\xe5\xcf\xe8\x9a\x89\x26\x69\xfe\xff\xc3\x56\x0d\x5c\xf8\x5c\x23\xbc\x37\x70\xe2\xc4\x81\x79\x7f\xcc\x37\x3b\x77\x76\x1c\xcf\xfe\x64\xde\xc9\x5e\x61\x7d\xf2\x77\x9d\xfb\x39\x9e\x55\xb1\x3e\x19\x41\x05\x68\xaa\xdc\x27\xe5\xf3\x26\xbd\x1c\x55\x27\x85\x24\xd1\x25\x0b\xd3\x29\x6f\xd2\xc7\x05\xa2\x96\x40\x53\x4e\x97\x94\x50\x94\xb0\xad\xf7\x3f\xea\x92\xf8\x46\x3f\x7d\xa5\x53\x97\x2a\x39\xa0\x4b\x95\x34\x98\x34\x45\xd2\xe3\x23\xe9\x24\xc0\x0b\xb7\xb7\xb7\x2c\xdd\xfc\xd0\xb4\x1b\xce\xde\xbb\xa5\x65\xd1\x65\xf7\x4d\xbd\xe1\xac\xfa\x2f\x58\x17\x99\x52\xbf\x69\xdc\xd6\xfa\x4b\x46\x81\xba\x33\xe5\x1e\x72\xf9\xcb\x4b\x1e\x20\x0b\x69\xe5\x4b\x9f\x5b\x7a\x1f\x59\x4b\x0b\x4d\xf0\xf4\x3a\xb2\xcc\xf6\xcc\xcd\xff\x7d\x8b\x3a\x79\x39\x6d\x2f\xba\x36\x8f\xf2\xcf\x0c\x7d\x2c\x7e\x45\x97\x27\x84\x47\xfb\x87\xa2\x9e\xee\xf2\xa4\x27\xfc\x7a\xf4\x73\x1e\xfc\x13\xc1\x48\xaf\xf0\x0f\x65\xe1\x31\xbf\x7d\x9c\x07\x3f\x2b\xd8\x3b\xfe\x99\x39\xfc\x4b\xd0\xef\x90\x2e\x59\x82\x44\xb2\xb4\x95\xa4\x3c\x42\x0f\x7b\x99\xae\xd5\xa2\x34\xcd\xd2\x69\xba\x8b\xca\x68\x48\x39\x88\x0d\x5f\x74\x38\x95\x36\x77\x49\x5d\xa6\x53\x51\xc7\xe3\x3e\x43\xf2\x66\x94\xc0\xf5\x72\x67\x18\xa1\xd2\x8c\x90\xc2\x2d\xe9\x72\xd1\x9c\xa1\xa5\xf6\x64\x2c\x59\x91\x64\xcd\x3c\x16\x17\xb1\x40\x6c\x92\xe2\x15\xb8\x80\x44\x17\xad\x21\x92\x3c\x74\xa2\x82\x0d\xd9\x34\x59\x5a\x7c\x77\x06\x5a\x32\x30\x38\x03\x99\x0c\xb8\x33\xc0\x65\xe0\xd3\x0c\x1c\xcc\xc0\xde\x0c\xdc\x9a\x81\xf6\x0c\x4c\xcd\xc0\x88\x0c\xf4\xcf\x40\x3c\x0b\xb0\x10\x43\xfc\x31\x03\xc7\xb2\x40\x5b\x33\xb0\x36\x03\xf3\x28\x5c\x41\x1e\x96\x87\xb2\x28\xd6\xe6\x3d\x42\x19\x60\xce\x64\xe0\x54\x06\x8e\xd2\xf7\xf1\xe3\x95\x19\x68\xcb\x80\x4c\x9f\xd5\x9c\xee\x7e\xb7\x92\x7e\x17\x3f\x38\x9d\xf7\x8e\x06\xdd\x99\x81\x0f\x33\x70\x12\x5f\x4b\xaf\xd0\x37\xda\xb2\xb0\x42\x2f\xeb\x45\x7a\xcf\x4a\xf6\x9f\xe7\xc0\xb3\xcb\x10\xba\x2f\xbc\xa6\x29\x7b\xf4\x45\xb3\xd9\xf9\x5e\x2d\xf2\xbd\x6b\xf5\x35\x89\x09\xd5\xb4\x6c\xe2\x82\x32\x83\xb6\x68\x9f\xef\x9e\x34\xe9\xc5\xab\xbe\xba\xb9\x70\x5e\x9c\x17\x8a\xb5\x45\xd8\x50\x32\x57\x84\xd5\x95\xd5\xae\x81\xf7\x4d\x5b\x75\x8d\xfa\x93\x5c\x9d\x58\x5c\x4c\xf2\x27\x35\x5e\x3a\x8a\xd9\x70\x48\xfd\xc3\xe3\x2e\x5b\x6d\xd5\x59\xb2\x14\xdb\x70\x4b\xa0\x4e\xfd\x4a\x7d\x7b\xe0\x94\x96\xa7\x4e\x2c\xdc\x34\x79\x50\xc7\xfb\xae\xc8\xf6\x33\x5d\x7c\x34\x53\xe7\x23\x3c\xa6\x8d\xd3\x39\x2f\x45\x38\xef\x99\x7e\x65\xe6\x6e\x63\xb1\xee\x43\x9c\x9b\xf3\x21\x6e\x87\x59\xd8\x6e\x89\xe9\xbe\xd3\x9c\xc7\xf3\xcf\x2e\x4f\xd6\x4d\xd9\x53\x87\xf4\xe4\x74\xc1\xed\xe8\x39\xb2\x2c\x46\x36\x33\xf6\x38\xec\x88\x27\x75\xed\x31\xcf\x9f\xf9\x4d\xee\x3b\x77\xc1\xe2\x3c\x1f\xad\x96\x91\xae\x82\x66\x94\xb3\x7b\x31\xbf\x33\x87\xbd\xd1\x9e\x3e\x5a\xfd\x7b\xf7\xe7\xbe\x77\x17\xba\x81\xf6\x2b\x1b\xd5\x71\x2b\x52\x70\x79\x2a\x93\xfd\x66\xce\x8f\xaa\x4e\x26\x7b\x41\xe4\xbe\x7b\x2f\xf3\x89\x4e\xe3\x8a\x08\x58\x23\x11\xb3\x29\x47\x23\xf2\xab\x93\x49\x9e\xaf\x1c\xfe\x7b\xe1\x29\x0c\x1b\x97\xbd\xcc\xa9\x52\x68\x2e\x05\x99\xae\xa1\x46\xa5\x30\xaf\xb4\x94\x65\xba\x88\xa3\xbe\x3e\xb2\xbf\x01\xb5\xff\xd2\xba\x7e\xff\x83\x66\xc3\xc6\xa8\x0f\xce\x7a\x38\x96\xec\xf2\x48\x11\x7d\x2f\xa7\x93\x8d\xea\xa6\x93\x41\x84\xf6\x77\xf1\x70\x24\x4e\xb5\xbd\x2c\xbc\x86\xff\xbb\x2c\x7e\xe6\x3a\x78\x53\xb7\x2f\xc9\x07\xf6\xc7\x52\xdd\xfd\x5d\x14\xff\x33\x54\x66\x8d\xd2\x65\xd6\xb3\xba\xcc\x22\x1f\xd8\x17\x49\x74\x61\x47\xbd\xe1\xbf\x1b\x7e\xa7\xe3\x2f\xc6\xf8\x5f\x8f\x15\xf6\x82\x7f\x45\x1e\xfe\xbb\xa9\xbc\x22\xf0\x69\x8c\x7f\x6f\x24\xf5\xbf\xe0\xdf\x96\xa3\x3f\x81\xf1\x7f\x9c\x8a\xf5\x82\xff\x0f\x79\xf8\xb7\xa1\x3d\x3a\xfe\x18\xc6\xff\x5a\x22\xd2\x1d\xbf\xe6\xab\xa3\xf8\x8b\x74\xfc\xeb\x75\xff\x50\x10\xf3\xd7\xde\xb0\xdf\x29\xf6\xb0\x7f\xbe\x34\xb0\xfc\x0e\x29\x8d\x46\x13\x78\xa3\xca\x7e\x81\x06\x23\x27\xe6\x8b\x42\xc4\x1c\xee\xdf\xdf\x6e\xa7\xe0\xf5\xd5\x59\xdc\xfc\x10\xa7\x81\xea\xc1\x5a\xfe\xaf\xe9\x58\xf6\x46\x50\x06\xed\x94\x27\xb8\x2d\x3c\x0a\x41\x30\xea\x70\x79\x39\x1f\xcf\x67\x32\x3e\xf0\x05\x83\xe5\x85\x16\x4b\x59\x39\x72\x79\x5d\x4d\x4a\x88\xc6\x28\x99\x48\x8c\x92\x3d\xe8\x9b\xa8\x04\x51\x26\x5a\xec\x48\xd8\x13\x58\x49\x94\xf8\x62\x63\xf1\x24\xc5\xe8\xe5\x60\xa2\xc2\x75\xcf\x1b\x87\x8f\x64\x21\x43\xfd\xf9\xfb\x31\x0c\xea\x96\xd2\x5b\x5b\x78\xd3\xb5\x75\x41\x51\x5e\x8a\x2d\xdf\x80\x9a\x54\x4d\x15\xd9\x85\x54\xa8\x12\x20\xdf\xbe\xa9\x61\x3f\x3c\xa4\xe7\x09\x1b\xa3\xa7\x0f\x33\xd8\x7e\xef\xfc\x83\xf7\x7e\x11\x0e\x15\xcd\x77\xaa\xb3\xb5\xbc\x61\x83\xfb\x26\x96\x95\x70\xe3\xce\x99\x69\xc2\x30\x3d\x89\x58\x63\xcb\xc2\x2d\xfe\x61\xef\x2d\x54\xff\x46\x32\x87\x6d\x5e\xb8\x69\x52\x6d\x9e\xaf\x78\x6e\xce\xb7\xbc\x1d\x26\xe7\xf9\x96\x1f\x0e\x47\xbb\xfb\x96\xa9\xed\xb0\x9b\xca\x90\x46\x5d\x86\x5c\x97\x67\x6b\x5c\x97\x2c\xe8\x6e\x6b\xe8\xf8\xbf\xc9\xe1\xbf\x0b\x96\xe5\xe1\xff\x6b\xac\xa8\x17\xfc\xf7\x52\x99\xd1\xa8\xcb\x8c\x7c\xfc\x0f\x17\x96\xf7\x8a\xbf\xcb\x37\x7e\x37\x34\xeb\xf8\x0b\x31\xfe\x7d\xe1\x64\x2f\xf8\xdb\xf2\x6c\xa5\xbb\x73\xf8\x33\x18\xff\x0d\xc9\xe2\x9e\xf8\xd5\xc9\x64\x0f\x0f\x0d\xbf\x44\xe4\xd1\x75\x1a\x1e\x2c\x7b\xda\xa8\xfd\xd7\xa8\xcb\x9e\x4a\x6d\xae\x80\x69\x2e\x04\xb9\x10\x2a\x0b\xb1\x0d\xf8\xf1\xe1\xc2\x32\xca\xc7\x3d\xe7\x0a\xba\xe8\xdd\x06\xa3\x74\x7a\xa3\x98\xde\x2b\xe2\x61\xe6\x7c\x7a\x0f\xe5\xe8\x35\x30\xdb\xae\xd0\xa8\x2d\xc0\xd4\x3e\x94\x4e\x76\xb3\x03\xe9\x9e\x15\x14\x77\x69\x0f\x99\x43\xfa\xec\xb6\x44\x21\xf2\x77\x2b\x1b\xcd\x5d\x46\x71\x8f\xd5\x65\xce\xf5\x7a\x5d\x94\x61\xec\x2b\xcb\x2a\x83\xae\xf3\x64\xc2\x41\xda\x96\xa5\x7a\x5b\xfe\x2e\x0f\xff\x0b\x05\x65\xbd\xe2\xbf\x3f\x87\xff\xae\xac\x4c\xa0\xf8\x9f\xaa\xa8\xe9\x15\x7f\x17\xfd\x5d\x32\xad\x14\xe3\x7f\x20\x51\xf4\xbf\xd0\x7f\x37\xda\xa9\xe3\xaf\xc6\xf8\xb7\x95\xf5\xeb\x89\xbf\xe3\x47\xb2\xa7\x87\x86\x5f\x12\x8c\xc7\x60\x4a\x17\x1e\x43\x4a\xd2\xf1\x18\x3b\xc1\x9f\x47\xe7\x0b\x15\x3d\xf0\x68\xfb\x68\x50\x3a\x33\xba\x7f\x92\xcd\xe3\xe9\x1b\xc2\x71\x64\xeb\xf6\x5d\x92\x33\x2d\x26\x14\x60\xf8\x71\x7a\xbb\xc4\xa1\x5d\x83\x67\xd2\xf0\x52\x38\xee\x31\x75\xf3\x35\x7e\xa7\xef\xd3\x91\xc2\xb2\xf1\x51\x79\x56\xbc\x28\x6d\xe5\x44\x31\x91\x30\xb0\x82\xc0\xc4\x0a\x0a\x6d\x9c\xdd\x1e\x8d\x7a\xfc\x6e\x77\x80\x09\x14\x97\x14\xfa\xd9\xb4\x35\xdd\xa6\x78\x6c\x24\x03\x7a\x51\xbc\x4d\x29\x28\x42\x45\x52\x11\x83\xac\xd8\x4c\x30\xb1\xd6\x22\x6b\x91\x09\xb9\xed\x5a\x46\x5e\x87\x89\x4d\x44\x03\x34\xcb\x76\x18\xb9\x7b\xdd\xc3\xa3\x6b\x1b\x2a\x7d\x29\x56\x55\xb7\x1c\xbd\xfa\x9a\x41\x5f\xfe\xa5\xb6\xaf\x87\x2e\xb8\xec\x4c\x42\x3b\x91\xec\x1d\x5d\xbb\x7b\x00\x16\x69\x36\xeb\xc1\xdd\xfb\x9d\xfb\xe3\x9a\xbf\x32\x0e\x9f\xc7\xb5\x5d\x3e\xe2\x4f\x38\x9f\xd8\x9d\xdd\xe9\x23\x30\x67\x9f\x15\x5e\x29\x54\x03\x85\x63\x83\xec\xd4\xe5\x87\x88\x03\xf3\x90\x76\x5c\x7e\x6e\x7f\xd7\x8e\x1f\xcc\x17\x27\x4f\xa2\xbc\x9c\x74\x49\xb4\x49\x1e\x1e\x0d\xc5\x62\x41\x3f\xcf\x22\x2e\x99\x0c\x04\x82\x92\xcb\x65\x35\x9b\x21\xc8\xa6\x0a\x42\x2c\x62\x9b\x94\x28\x42\x49\x21\x19\x9b\xa8\x24\x51\x30\x20\x69\x01\x82\x7e\x9e\xf7\x08\x9e\x49\x0a\x12\x70\x0f\x17\x24\x54\x3f\xbb\x2b\x07\x12\xaa\xca\xa5\x7b\xac\xe8\xb1\xbb\x8e\x23\xaf\x1a\x48\x58\xad\x90\xb2\xff\x87\x54\x75\x7a\xc5\x30\x02\xea\x74\xab\x19\xe9\xae\x0f\xe7\xaf\xee\x91\xb2\xee\xd5\x5d\xee\x1b\x7d\x24\x8d\x18\xf7\xf4\xc2\x9f\x26\x1d\xbb\x78\x41\x2e\xb9\x93\x96\xb7\x8e\x1b\xb7\xf0\x4a\x9a\x66\x46\x9f\x1b\x3b\x40\xe7\x56\xca\x74\xfb\x78\x7d\xde\x5c\xda\x5e\x77\xcf\xb1\x39\x44\xd2\xc2\x52\x7b\x5a\xf3\xb1\xec\x79\xa9\xcb\xc7\xd2\x2e\x85\xf2\x7d\x2c\x14\xf7\x4d\x86\x47\x72\xb8\xb7\xa3\x2d\x70\x53\x0e\xf7\xa3\xa2\xad\x07\x6e\x3c\x7a\x33\xcf\xd0\xf1\x40\xc3\xbd\xfd\x91\x2e\xdc\xf3\x8d\xe6\xf3\x70\xdf\x2b\xf4\xcb\xe1\xc6\xb2\x3d\x0f\xf7\x1b\x76\x5f\x0f\xdc\xc4\xdf\xf3\x2a\x95\x1f\x1a\xee\xbb\xf6\x77\xe1\xbe\xce\xe2\xea\x8e\x1b\xcb\xe3\xe9\x54\x4e\x97\x51\xd8\x7b\x15\x84\x6c\x24\x91\xc0\xd9\xc3\x4e\x17\x07\x14\x92\xc0\x1d\x57\x27\x93\x9c\x7f\xb8\xaf\x8f\xd7\xe0\x1e\x45\x28\x2a\x7b\xd3\x24\x12\x25\x4d\xc2\xb0\xd2\xb2\x28\x36\x32\xee\x60\x90\xa5\x82\x98\x86\x76\xe4\xe6\x47\xbb\xe6\x2f\xef\x46\x57\xe4\xcd\x17\x3c\x26\x3a\xf3\x69\xc7\x3c\x49\x7c\x66\x1f\xb3\xfb\x91\x80\xca\x64\x5f\xb7\xfc\x72\x7a\x3e\xc1\xcd\x26\xf8\x9f\xf2\xca\x8d\xcf\xe5\x0c\xd4\x53\x05\x12\x1a\xb0\x0e\x74\x92\x1f\x22\x65\xe7\x44\xcb\x99\x3b\x75\x1d\xab\x4d\x84\x26\x11\xe2\x22\x88\x5a\xc8\x8b\x56\x7f\xfd\xd5\xf1\xdc\xfc\x5c\x59\x05\x34\x81\xc1\xba\x1c\xb6\x15\x9c\x2c\xf3\x8d\x17\x76\xd1\x8c\x32\x9b\xbd\xd8\xb6\x47\x2c\x38\xaa\xb3\x01\x32\x1a\x8f\x91\x7d\x6c\xe6\xd0\xf2\x96\xeb\x32\xab\x95\xce\xc7\x39\xe8\xfc\xe3\x87\x6e\x38\xe9\x06\xd5\xed\xb7\xb0\xf9\x7e\x24\x3d\x87\xe1\x41\xfe\x21\xe4\x40\x41\xb4\x4c\x1e\xe5\xf4\x31\x66\xb3\xdd\x82\x9b\xd6\x66\x0b\x87\xdc\x81\x9d\x4a\xd0\xbd\xab\xc5\xbf\x39\xb8\x33\xc8\x10\x7f\xdb\x81\xe0\xc9\x20\x67\x62\x83\xff\x17\x79\x0d\xe9\x8a\x90\x2a\x3d\x1c\xd5\xf7\x3f\xe4\x36\x64\x6b\xa0\xca\x25\xa4\x8a\x78\x9a\xd8\xd0\xe7\x0a\xe5\x25\x36\xcc\x18\xc0\xfa\xf6\x23\x86\xf1\x7f\x55\xbf\x24\xa9\x0d\x57\xbb\xf2\x52\x1b\x3a\x13\x50\xa8\xbe\x97\x78\xe0\x01\x2a\xeb\xf1\x98\x71\x9c\xf2\x55\x1f\x3a\x36\x1c\x83\x66\x5c\x4e\xf3\x61\x58\x59\x0c\xc5\xb8\xb2\x89\x9d\x13\xee\xf8\x91\xe4\x3f\xc4\x30\x13\x09\x4f\x19\x8f\x2d\xd6\x3c\x6e\x2b\x93\xd0\x96\x84\xe6\x24\x54\x26\xc1\x9e\x84\xa4\x1e\x70\x57\x9d\xcb\x99\x48\xf3\xa3\x2c\x91\x07\x0a\x22\x4d\x99\x68\xb3\x18\x8d\x76\x03\x4d\x9c\xa8\x65\x4d\x34\x80\x44\x12\x27\x9a\x11\xb0\x76\x2b\xd8\x0d\x34\x7b\xa2\x85\x75\xda\x49\xca\x22\xbb\xc5\xa3\xa7\x71\x25\x42\x88\xa6\x84\xca\x4f\xc5\x95\x0d\x6c\xd6\xa3\x9b\x9d\x5a\xd2\xe4\xf3\xb3\x27\x5e\x01\xf3\xb5\xec\x89\x3f\x7d\xdd\x6c\x51\x5f\x3c\xb8\x68\xa8\xfa\xfd\x6e\x9a\x3d\xf1\xaf\xb0\x81\x64\x4f\xec\x54\x79\x7f\x03\x3c\xd4\xa0\xee\xa1\x89\xae\x74\x1d\xe6\x5a\x6a\x3b\x55\xe8\xb6\xd0\x1b\x98\x37\xa2\x98\x0f\x1d\x98\x37\x76\x3a\x60\xb3\x03\x2b\x3f\xbf\x3d\xec\xf0\x5a\x6d\x39\xf6\xd0\xe2\x01\xd9\xa8\x60\xc7\xef\x35\xe9\xef\xd5\xe2\x71\x10\xdb\x50\x46\x86\xcc\x1b\x7e\x76\xd8\x68\x35\xe4\xf7\x69\x5c\xf7\x64\xff\x9f\xec\x77\x8c\xc7\xa8\xbd\x8a\xeb\xbe\x3d\x06\x31\xad\xee\x3b\x5f\xee\xf8\x91\xe4\x71\xcc\xe2\x34\x1e\xeb\x1c\xa6\xc1\x34\x13\xc6\xd6\x60\xc8\x7e\x48\xd5\xfc\xe4\x1c\x1e\x95\x25\x9b\x35\x61\xdb\x01\x1c\x1c\xa0\x78\xdc\x66\xc8\xd9\x0e\x84\x46\xae\x2f\xed\x33\x1a\x3e\x95\xf1\x61\x3b\x23\x82\x61\x8d\x08\x62\x3e\xb0\xfb\x30\xa5\xf7\x1c\xf6\xf9\x84\x10\x7e\x69\x95\x16\x90\x98\xad\x93\x2e\x5a\xb1\xee\xf2\x9b\x8e\x57\x90\xed\x17\x24\xeb\x82\xdd\x01\x0e\xd2\xf6\xd9\x3a\x18\xd7\x85\x1f\xcb\x91\xcf\x30\x5c\x1f\x39\x0e\xc8\x08\x67\xe8\xbf\x76\x23\x34\x19\xa1\xde\x08\x15\x46\x88\x19\xc1\x4e\xff\x19\x1d\x5d\x7e\x8e\xea\xbc\xbd\x91\xfc\xe8\x12\x79\x34\x62\xfd\x2c\x67\xc7\x72\x8e\x03\xb3\xcd\x66\x0e\x04\xfd\x2e\x8f\xab\x55\x41\x98\x53\x70\x01\x41\x02\xac\x05\x90\x18\x4b\xd1\xc3\x92\x3d\x7c\x9a\x4c\xdf\x98\x18\x13\xdd\x35\xc9\x04\x56\xb2\x41\xbb\xc8\xb5\x29\xe2\xf9\xbb\x26\x65\x27\x2a\xf5\x2c\xfd\x59\x37\x67\x36\x18\xa2\x50\xe0\xd9\xbc\x7d\x94\x84\xec\x5e\x4a\xcc\x64\x30\xf8\xd4\x9f\xe7\xaf\x9a\xff\x55\xa1\xbe\xa3\xd2\xe8\x23\xfe\x5f\x2c\xd5\x76\x55\x62\x33\x37\x5c\xb3\xad\xe3\x97\xd9\xbd\x95\xe0\xe6\x79\xd7\x5d\xc4\xcc\xd1\x76\x15\x80\xce\x1f\xb0\x10\x69\xc4\x63\xb9\x1d\x35\xca\xc5\xac\x11\x89\x76\x23\x67\xb1\x48\x0e\x4e\xb0\x8b\x1c\x6f\x95\x6d\xee\x46\x2b\x6f\xe5\x2d\x8c\x96\xb5\x8b\xc1\xb2\x94\x41\x3d\x96\x8c\x65\x74\x9f\x3c\x95\x0e\x7a\x58\x51\x8d\xb6\x61\x12\x21\x12\x1c\x84\xbd\xd7\xec\xf0\xee\xb8\x68\xae\x45\xbd\xfe\x82\x6b\xbd\xd7\x92\xc4\x9d\x1d\xeb\xc6\x5e\x36\xae\xe3\x6d\xcc\xeb\x1f\x8c\xbe\x62\x14\xca\xc5\x60\xbc\x9f\x8d\xc1\xc0\xa3\xec\x37\x79\x32\xb0\x82\x06\xb9\x7d\xee\xf6\x89\x6c\x0f\x5f\x3a\xf1\xc1\xa7\xa8\xaf\x60\x92\xfe\x5e\xbd\xe6\x2b\x08\x52\x5f\x81\xeb\x70\x30\x42\xfd\xef\x59\x3e\xff\xaa\xe3\x47\xb2\x07\x53\xf6\x3b\x58\xc6\xf0\x84\x3f\x0f\x81\x1c\xc4\xcc\x36\xe6\x70\x50\xff\x04\xe1\x9f\x52\xdc\x27\xec\xd4\xee\x98\xa4\xc9\x9a\x99\x44\xa2\x5b\x61\x2f\xcd\xcd\xb7\x32\x0e\x95\x71\xfc\xce\xc6\xc3\xf1\x88\xee\xe2\x27\x84\xe5\xca\xf2\x5d\x2e\x9e\x64\x1b\xbc\x48\xe7\xc8\x6d\xe0\x25\x7d\xd6\x0f\x4f\xf9\xdd\xfa\x57\xba\x95\x23\x44\xf5\xeb\x49\xba\x4d\xff\x37\x7d\xbc\x09\xe3\x82\xfc\x22\x1a\xec\x2a\x05\x85\x8f\xe0\x7e\x36\x8b\x9f\x24\x15\xa1\x49\x30\x81\xbc\x21\x7c\xda\x49\x4a\x2e\x3c\x0d\x18\x15\x09\xdc\xa5\x7b\xc3\xf3\x6f\xf1\xa3\x51\x1a\xb5\xca\x7d\x43\x52\x30\xe8\x70\xf8\x18\x2f\xe6\xc0\x82\x84\x37\x51\x54\x1c\x92\x6c\x51\xdb\x85\x4a\x94\x0b\xfa\x5a\x95\x20\xeb\xf0\xea\xbb\x65\x0a\x6d\x4a\x76\x73\x9b\xf3\xf3\x2a\x76\xdb\x6a\x4e\xdf\xa0\x2c\xbb\xc7\x0d\xdd\x49\x8f\x2a\x62\x79\xbb\x29\x65\xd3\x9e\x93\x14\x3f\xec\x96\xdb\x2e\xa8\x54\xf8\x54\xfd\x25\xa9\x95\xce\x27\x6e\xfb\xeb\xd3\x17\xd9\x3b\x4e\x58\x0f\x9c\x78\xc4\x0a\xaf\x19\xb7\xbe\xbf\xf8\xe9\x23\x9e\xa9\xc5\x9f\xb9\xa3\xe0\x7c\x38\x71\x8c\xb9\xbc\xad\x60\xdf\xa2\x73\x66\xfb\x34\x6d\x62\x7d\xe3\x08\xf9\xea\x9b\x13\x57\xab\xe9\x8f\x3f\x26\x39\x09\xf1\x78\x6b\x61\x5f\xc3\x7a\xfb\x74\xb9\xdc\x8c\xfb\x15\xc7\x19\x7c\x7c\x2c\x99\x74\xda\x79\x7b\x41\xa1\x27\xdc\xa4\xf8\xfd\x9e\x10\x6b\x36\x23\x11\x4d\x52\x44\xc9\x64\x98\xa8\x98\xec\x1c\x4f\x04\x79\xb7\xd4\x9b\x55\x15\x99\x5e\xcb\x04\xe7\x67\xdf\xa4\xf3\xa2\xb9\x91\x0f\x97\x94\xb9\xbf\x7b\x22\x4e\xac\x6a\xae\x49\xbc\xfb\x74\xd7\x18\xb8\xda\xcb\x0e\xe8\x4a\xc8\x49\x35\xcd\xa5\x47\xdf\xd2\x06\x41\xa6\x1d\xeb\x9b\x5d\xf1\x38\x73\x73\xf1\x3b\xdb\xe1\xd5\xbc\xf8\x9d\x7b\xa3\xf1\x1e\xf1\x3b\xda\x1c\x8c\x27\x37\x67\xb3\x9d\xce\x4f\x67\xe7\x6c\xb6\x86\x22\x3d\xe6\x6c\x34\xfc\xdf\xe4\xf0\xdf\x95\x8d\xbf\xa0\xf8\x5f\x49\x94\xf4\x82\xff\x18\xd5\x05\x27\xeb\xba\xe3\x01\xfc\xa0\xf0\x19\x8a\x3e\x4a\x62\x85\xed\x52\x63\x94\x06\xee\x9b\xcd\x8d\xfb\xa2\x69\xfa\xbd\x4c\xce\x36\x26\xdf\xbb\x31\x2f\x7e\xe9\x3e\x38\x8e\xbf\x17\x78\x56\x0f\x2f\x22\xbd\x32\xaa\x85\x17\x75\xcd\x7b\xe2\x6f\x72\x4b\xf2\xe6\xad\xee\x43\x0f\x75\x9b\x57\xfa\x3a\xd4\x73\x5e\x89\x41\xa3\x3b\x7f\x12\x6a\xf8\x91\x28\x81\xf5\x85\x07\xe5\x39\x65\xac\xc3\x2f\x49\x81\x40\x61\x41\x01\x1b\x75\x9b\x59\x73\x45\xa5\xd7\xef\xf0\xb7\x29\x2e\x3c\x28\x58\x58\x87\xc3\x14\x8f\x07\xda\x94\x78\xb2\x55\xb1\x47\x62\x91\xa6\x48\x6b\x64\x45\x84\x77\xb2\x11\x12\x99\x19\x89\xc4\x9d\xa6\xe2\x56\x85\xec\x1e\x28\x8b\xcd\x62\x9b\xc8\x22\x7a\xda\x2b\x1e\x14\x8f\x8a\x06\x11\x17\xf7\x59\x7f\xa8\x51\x14\x4d\x2c\x4d\x00\x87\x75\x24\x7d\x9b\xf3\xde\x77\x05\x1d\x94\x4b\x06\xa7\xc7\x5e\x92\x5e\x82\xf4\x18\xa2\x6c\xe8\x65\x15\x0d\xbd\x4c\xb1\x55\x71\x1a\x7a\x69\x28\xea\xa7\x65\xad\xa7\xc9\x55\x99\xcb\x54\xf5\xc4\x2b\x30\xf7\xcb\x96\xe5\x6c\x80\x6c\x1b\x7a\xba\x76\xfa\xdb\x34\x02\xf3\xed\x96\x85\x20\x92\x08\xcc\x73\xb7\x5d\x1a\xbc\x70\xc4\x2f\xeb\xc7\xa7\xda\x7f\x7f\xe5\xcd\x02\xa4\xce\x7c\x0d\x1b\x7f\x67\xec\x19\x81\x29\xcc\xf3\x73\x13\x5d\xe6\xe3\xea\xb6\x17\x9f\x3b\xa9\xcd\xc9\x95\xe3\x36\xba\x07\xf7\x9f\x18\x1e\x25\x07\xa0\x75\x72\x41\x91\xc7\x11\x8a\x73\x7d\xfa\xc4\xe3\x9e\xbe\xc8\x83\x6a\x06\xf6\xe1\x9a\x94\x3e\x7d\x22\xf6\x48\xff\x26\x25\x22\x05\x52\x4d\x4a\x88\xec\x93\x15\x34\x59\x1b\x1d\x12\x3e\x84\x1c\xae\x80\xe4\x2a\x6d\x52\x5c\xde\x1e\x99\xee\xf5\x99\x80\x4c\x2f\x69\xef\xf3\x62\x51\x7b\xc9\x7c\x5f\x64\x48\xc5\x1d\xba\x67\x2e\x37\x29\x90\xdd\xe5\xcc\x97\x4d\x87\xcf\xdf\x93\x4b\x87\x3f\xed\xf8\xec\x37\xa7\x6c\x7e\x49\x7d\x64\xd3\x17\xfb\x9f\x6f\x6a\x7f\xec\x96\xbb\xce\xfd\xbb\xff\xe0\x71\xff\x1f\x63\xdf\x01\x1f\x45\x99\xfe\x3f\xef\x94\xed\xbb\x33\xbb\xb3\x3b\xb3\xbd\x97\x24\x9b\xbe\x29\x04\x02\x59\x42\x4b\x28\x29\xf4\xa1\x25\xf4\x50\x94\x26\x2d\x72\x56\x54\x8a\x05\xb1\x80\xa2\x88\xa8\x87\x0a\x88\x60\xc3\x7a\xea\x61\x3b\xcf\x76\x9c\x67\x3b\xfb\xfd\x14\x4f\xfc\x59\xd1\x53\xc8\xe4\xff\xbe\x33\xb3\xbb\xb3\x49\xbc\xdf\x5f\x3f\x90\xb0\xd9\xbc\xfb\x3e\xef\xbc\xef\xd3\xde\xe7\xf9\x7e\x3b\x9a\xca\xea\x26\x2c\x1c\xd3\xd3\x1f\x21\x7f\xcc\xe4\x8b\x2f\x06\x93\x0f\x82\xfa\xbd\x9b\x37\x2f\xbf\x73\xca\xa4\x5d\xe2\x8d\xcb\xda\xdb\xf7\x82\x45\xd3\x33\x80\xf9\x50\x7f\x4b\xdc\x67\x92\x2d\xaa\x56\x6c\xca\x55\xca\x79\x09\xc0\xf3\x72\x26\x10\x26\xf3\xeb\x45\x10\x3e\xea\x85\x92\x0d\x9a\xa2\xf8\x5a\xbb\x14\xdd\x6d\x83\xba\xfb\x9f\x36\x87\x99\xca\xcb\x69\xf4\x40\x3f\x57\x27\xd9\xa0\x6a\xc5\x06\xa1\x67\xc2\x1f\xc5\x63\x70\x93\x1d\x33\xd3\x4d\xc7\x7b\x9f\x78\x38\x26\x7f\x4a\xe6\x77\xee\x85\x7e\x6f\xb1\x64\x8b\xa6\x28\xbe\x17\x8c\x95\x30\xfb\x23\xc0\x89\x62\xa8\xe3\xe2\x53\x0f\x3b\xe5\x8f\x51\x62\x2f\x59\x86\x1f\x32\x9f\x01\x6d\xd0\x02\x45\x86\x10\x94\xe1\x8d\x48\x60\x00\x19\xd6\x49\xe7\x6f\x8a\x9c\xfb\x1a\x2e\x4b\x60\x87\x12\x6c\xe6\x6c\x39\x09\xe0\x7b\x11\x97\x5a\x89\xb4\x3e\x35\xca\xfa\x34\xcb\xf9\xfc\x62\x29\x9f\xef\x7c\xb8\xb8\x0c\x77\xa9\x6c\xee\x19\xa8\x4f\xda\xa5\xf5\x99\x2a\xd7\x28\x9c\x27\x8f\x5d\x08\xc7\xfe\xa9\xb0\x58\xe3\xea\x33\xb6\x4f\x9a\x77\x8d\x12\x0b\x51\x4a\xec\x87\x06\xbf\xad\xb8\x3c\x37\x32\x96\x19\x7b\xb8\x34\xef\xa9\x72\x4d\x43\x63\x6e\xec\x1d\x85\x25\xf9\x63\x8b\x6d\x88\x03\x2e\x3b\xef\x6e\x80\x00\x14\x6b\xd3\x01\x80\x95\x82\xef\x4a\xc1\x27\xa5\xe0\x92\x52\xd0\x59\x0a\xda\x4a\x41\xba\x14\x94\x97\x82\x60\x29\x60\x4a\xa1\x8d\xbf\xfd\xe1\xd2\x7a\xe9\x83\xd5\x8e\xa1\xfc\xf9\x62\x1b\xc2\xa1\xcd\xca\xd6\xbd\x5a\x89\x85\x1f\x7f\x38\x59\xa7\xc1\x32\xb1\xb0\x24\xd7\x30\x95\x5c\x5b\x81\x5e\x91\xab\x14\xca\xf5\x8f\xf2\xe2\x01\xe4\x9a\xa7\x92\x6b\x6b\x89\x2c\x57\x12\xca\x75\xb4\xa4\x30\x4f\xae\x9b\xc4\x36\xc4\xf5\x06\xdf\x5b\x8b\x72\x6d\x50\xae\x2a\xe9\x33\x75\x70\x6e\xcb\xc9\x4b\xa1\xff\x3b\x4d\x9e\x5b\x1a\xfa\x07\x0f\x97\xa1\xc8\x5b\xea\x19\x92\x38\xe2\xa4\x39\xd5\x2a\x73\x9a\xa0\xf8\x29\x4e\x38\xa7\x15\x6e\x30\xdb\xcd\xe9\x8d\xf9\x7e\xca\x30\x28\xc7\x44\xc9\xa7\x9e\xa6\xf8\xec\x83\xa0\xcf\xee\x7c\x14\x78\x30\x40\x17\xc1\xa5\xda\xf2\x70\x51\x11\x5b\x2a\xff\x12\x72\x43\x54\x5c\x74\x3e\xac\x33\x5d\xce\xbb\x39\xce\xe3\x91\xd2\x6b\x38\x6d\xa6\xcd\xfe\x80\xd5\x6c\xb6\x70\x5a\x0b\x74\x3b\xdc\x84\x06\x91\x48\x6b\x34\x98\x85\xf0\xc8\xe4\x74\xf6\x5c\x21\x5f\x59\xb6\xba\x1d\x21\x88\x49\x3a\x36\x83\x57\x54\x97\x81\x14\x46\x64\x75\xa1\xda\x50\x3f\xc2\x3a\x54\x34\x2c\x91\xd6\x09\xe2\x57\x0e\xe0\x14\xfa\x52\xd7\x09\xc0\xe5\x10\xbf\x9c\x81\x08\xec\x50\x95\xf0\x7f\x72\x1c\x76\xa2\xa1\x1b\xc6\x30\x12\x3f\x98\x41\xc1\xe0\x0d\x63\x4b\xd2\xb5\x66\x83\x1e\x3a\x92\x14\xa7\x65\x98\x70\x00\x1e\x1e\xaf\x37\x12\xa5\xa3\x80\x21\x02\x66\x83\xb9\x55\x08\x1b\x0c\x1a\xa7\x83\x75\xb1\x6d\x82\x8b\xc3\xf4\x1a\x7d\xab\x40\x51\x84\x86\xc6\x32\x70\xbc\xce\x5c\xc3\xa9\x24\x13\x90\xfb\x87\x65\xfa\x47\x29\x11\x28\xa5\xfa\xb2\xd0\xbc\xd2\x1f\xb9\x42\x2b\x0b\xdc\x2b\x5d\x5f\x1c\xcd\x62\xf4\x96\x1e\xb0\x1d\xf0\x30\xd5\xf1\x0c\x7c\xaf\x36\xbe\xc8\xb6\x98\x18\x29\x81\xf5\xf6\x76\xdd\x8c\xd0\x7a\x65\x08\x5f\xbe\xee\xef\x5d\xd9\x5a\xce\xe7\xb2\xb5\x9f\x7b\xc1\x67\xaa\xda\xcf\xb1\xb1\xf2\x3e\xb5\x9f\xf2\xdd\xfd\x9a\xec\x5d\xff\x5e\xec\x2b\xd5\x5d\xff\xfa\x70\x49\x9f\xbb\x7e\x79\xfc\xf9\xd9\xf1\xb7\xc3\x30\x37\x37\xfe\x70\x5f\x60\xc0\xf1\x1d\xd9\xf1\xb7\x63\xff\x56\x8d\x7f\x81\xdb\x3b\xe0\xf8\xdf\x66\xc7\xbf\x15\xbc\xaa\x1a\x7f\x42\xb0\x60\xc0\xf1\xef\xcc\x8e\x7f\x2b\xf6\x9d\x6a\xfc\x5d\xbe\xd8\x40\xe3\x6b\x5d\xd9\xf1\x6f\x03\x1f\xe7\xd5\xba\x36\x07\xfb\xd7\xba\xca\x9f\xf1\x6a\xf6\x33\x6e\xc3\x4e\xe7\xd5\x37\x5c\xe8\xeb\x57\xdf\xd0\xaf\x06\xf7\x0e\xf0\x52\xde\xe7\xec\xf1\x0d\xfc\x39\x87\x54\x75\x17\x77\x48\xf1\x42\xee\x73\x3e\x76\x0f\xf0\x39\xe2\x44\xc4\xc3\x28\x7f\x8e\x74\xbf\xe2\x94\xc7\x12\x27\x22\xfc\x66\x26\x33\xd6\xed\xb8\x05\xc5\x50\x8f\x63\xc5\xd0\xc5\x33\x78\xbd\x4d\xc0\x1e\x0c\x1a\x8d\x52\x8a\x0e\xbd\x5f\xe2\xc9\x93\xe6\x3b\x58\xc9\xc9\x6f\x56\xe5\xe7\x92\x0e\x97\x26\xcf\xb6\xf4\xfe\x04\x7d\x8d\x56\x69\xae\x33\x7e\x90\x75\x7a\xbb\x6a\xdd\x17\xbb\xfd\x4c\xfe\xba\xcb\xf5\xc2\x3f\x64\xea\x85\xe1\xfb\x17\xa9\xc6\x2f\x74\xb8\xd4\xf5\xc2\xd9\x7b\xfd\xbb\x33\xf7\xfa\xf8\x96\x4d\xf2\xe8\xa8\x3c\xe4\xad\x48\xc2\xa0\xbe\xb7\x91\xc7\xfe\x3a\x5b\x8b\xbc\x14\x6c\x07\xd7\xcb\xeb\xe6\x40\x6b\x3d\x3f\xea\x97\x47\x57\xd5\x9f\x48\x9c\x68\x92\xbd\x1b\xaa\xd8\xbb\xe9\xaa\xfe\x80\x1f\xed\xbc\x4d\x97\x37\x1f\x84\xc7\x3b\x5e\xb2\x77\xb3\x65\x7b\xd7\x95\xb3\xa5\x5f\xdb\x79\x4c\x75\x77\xad\x8c\xfd\x43\x66\x6c\x7c\x0f\xf0\xab\xf6\xf0\x4d\x76\xf7\x00\x63\x3b\x24\x59\xa5\xb1\xf1\x3d\xd1\xdc\xcd\xf5\xe5\x76\xf7\x7f\x1d\x7b\x2b\x08\x2b\x63\xa3\x38\xf4\x49\xa7\x7d\x80\xb1\x87\xab\xc6\xde\x6a\x92\x73\x6b\x1c\x1c\x3b\xe0\x04\xb4\x13\x5c\xed\xb4\x63\x06\x55\x04\x9e\xe3\x16\xa2\xb1\x92\x34\x67\xc0\x8d\x46\xb3\xc9\xc4\x58\x8d\x1e\x94\x5e\x2c\x27\x01\x49\xc2\xf7\x48\x60\xc3\x98\xb3\x21\x9b\x7b\x95\xda\xbf\x33\x4c\x40\x5a\x10\x02\xc3\x00\xfe\x88\x42\x01\x54\x3b\xd2\x2e\xfe\x28\xfe\x08\x74\xc1\x93\xd4\x7e\xc7\x47\xe7\x39\xd7\xac\xff\x0d\xa7\x3e\x7a\xfa\x49\xd9\xe7\xcf\x70\x77\xb9\xb1\x02\xac\x2b\x5d\x1b\xb2\xd2\x26\xd2\x68\x0c\x87\xb5\xa4\x4e\x47\x78\x78\x82\x2f\x2c\x0a\x59\xad\x7e\xbb\xbf\x5d\xa0\x29\x0d\xd5\x2a\x98\x34\x1a\x83\x9d\x31\xe8\x50\x6a\x2f\x1c\xc3\x62\xd9\x52\x2d\x55\xd5\x8a\xda\xb2\xa8\xc1\xa9\x32\xf7\x2d\x14\xc2\x3f\xcb\xdc\x14\xc3\xff\x55\x5c\x5e\x6c\x5e\xe1\x0a\x78\xee\xbc\xcf\xa7\x3e\xb1\xd6\xb6\x96\x47\x84\x5e\x71\x50\x66\x13\xdf\x2c\x70\x28\xac\x5e\xcb\xd4\xac\x5f\x7c\x34\x42\xfa\xbb\x2e\xe6\x87\xbf\xd3\x75\xaa\x39\xc3\xeb\x85\xcf\xcb\xf1\x7e\x41\x1f\x7d\x50\xef\x6f\xd4\x72\x09\x9b\x33\x82\x25\x11\x0b\x6f\x32\x54\x54\x64\xb7\x86\xc3\x46\x8a\xf4\xf1\x7c\xdc\x4a\x5a\x8b\x4b\xec\xc9\x50\x32\xd4\x29\x24\x93\xb8\xa5\x48\x63\xd1\x74\x0a\x46\x0b\x81\xbb\x3b\x04\x9c\xec\x10\x00\x2e\x11\x40\xe6\xd8\xca\x6c\xfd\x59\x78\xad\xf2\x3d\x94\x12\xc7\xc7\x42\x39\xb6\xd7\x9a\x54\x28\x68\x95\xc0\xdc\x1c\x76\x32\x96\x61\xe2\xe5\x58\xa5\x64\x1e\xff\xb7\x78\x40\x7c\xc6\x74\xec\xa5\x70\xeb\xd2\xc8\x98\x69\x75\xcb\x9f\x00\xdf\x82\x2f\x8e\xee\xdb\x7d\x58\x7c\x41\x7c\xf5\xbe\xbd\xbb\x77\xad\xee\x5c\xd2\x05\xea\x37\xae\x15\x26\x69\x34\xcd\x1e\x72\x59\xc9\x90\x8d\xc0\x5f\x21\x7e\x70\xcd\x7d\x9c\xf9\xc0\xe6\xb7\x5e\x39\xff\x86\x5b\xbb\x2f\xee\xf9\x44\x83\xdf\x08\xe8\x8e\x85\x62\x09\xda\x83\xff\x0b\xf7\xec\x3f\x51\x3d\x01\xf1\x7c\xf6\x79\x7f\xa4\x3c\xef\xa9\xe9\x62\x6b\xc8\x12\x0e\x5b\x48\xc2\xa3\xcd\x7b\xd4\x76\x46\x63\x69\x15\x74\x3a\x8d\xcc\x2a\x83\x9e\x32\xa6\xa6\x85\x28\xcb\x05\xfc\xaa\x06\x8f\x54\xa6\x26\x4f\xa1\x68\x43\x58\x63\x49\x60\x01\xff\xf5\xe9\x7e\x3e\xcb\x48\x54\x84\x27\x78\xcb\x76\x95\x4f\x29\x28\x64\x7f\xe7\xd9\x4a\x8c\x6d\x3f\xed\xd4\x19\x3f\xff\xb2\x61\xc0\xa7\x8b\xee\x1e\x91\xac\x7b\x25\x6c\x0a\x27\x36\x22\x1d\xa1\x18\x92\xb4\x5a\x31\xda\xa1\xa7\xf5\x2e\x37\x05\x03\x51\x8a\x32\x13\x66\x6b\xa7\xa0\xd0\x59\x13\x84\x94\xbb\xe8\x13\x52\xa9\xf8\x14\x12\xb5\xb1\x14\x91\x92\xf8\xab\x0b\x01\x22\xf4\x94\xe1\x83\x22\xa0\xfa\x1e\x13\x78\x6a\xd2\xa2\x8e\xdf\x00\x26\xfe\x55\x7c\xaa\xe7\x65\xf3\x83\xe0\xaa\x39\xc3\xff\x74\xc7\xa6\x2d\xc4\x8a\xfd\xcd\x9f\xf7\x3c\x7a\xdf\x23\xaf\xbd\xdc\xec\xc6\xc3\x3d\x5f\x5d\x77\xc7\xea\xf5\xf9\x67\xcd\x0c\x3d\x9e\x31\xe9\x88\x45\x13\x0c\x6a\xb5\x5e\x0f\x66\xf7\xd8\x23\xd1\x00\xa6\x35\x38\x0d\x30\x28\x74\x72\x1a\x8b\x85\xb0\x12\xed\x82\x95\xc1\x72\x59\x95\x2c\xb8\x6b\x9f\x39\xe6\xaf\x68\x76\xa5\x23\xf2\x43\x40\xcd\xb4\xf9\xf4\x78\xe2\x29\x65\x89\x77\xc0\xc5\xbf\x6d\x8e\x11\xac\x1d\x3e\x9e\x55\x13\xe4\x81\xb6\xcc\x02\x47\x23\xc4\xba\x3d\xc3\x81\x51\x9c\x88\xc0\x2f\x40\xef\xaf\x50\xd7\x7b\xa9\x4e\xcc\x8f\xf0\xfe\x59\x82\x08\x04\x3d\x7a\x7d\x80\xf6\x04\x3c\x1d\x1e\xc2\x44\x79\x30\x8c\x83\x1e\x26\xa9\x85\xab\x6b\xd0\xda\xb2\x3c\x6d\x58\x2a\x53\xbe\x96\x29\x5c\x0b\x62\x56\x09\xe2\x2a\xc1\xa6\x1c\x68\xe2\x08\xb7\x2a\x9e\x39\x25\x51\xfc\x04\xf0\x81\x21\x6f\x8a\x17\xff\xfa\xd9\x2f\xd5\x93\x6b\x6e\x99\x7c\x0f\xd0\xee\x3c\x7e\x60\xfe\x4b\x43\x26\x4c\x69\x5c\x05\x6c\x54\xa7\xf8\x5e\x2f\xf6\x8b\xb8\xed\xaf\x55\xa0\xfd\xf9\x64\xd9\x71\xd0\xfa\xb7\x37\x4e\xd5\x15\xff\x13\x4c\x8e\xa1\xab\x2b\x74\x17\xaf\x65\x34\x4b\xb1\x62\x6c\x54\x3a\xe2\x4c\x04\xe9\x04\x5d\x42\x95\x12\xc6\x4e\x41\x4b\xc0\xe9\x60\xc9\xa4\xbd\x43\x60\x92\x64\x20\x1a\xf5\x74\x08\x51\x16\x6b\x50\x33\x6f\xa6\x9c\xcc\x89\x4a\x99\x5a\x23\x83\x5a\x92\x21\x5a\x93\x61\x9d\x89\x48\x35\xfa\x86\x54\x02\x69\xa9\x61\x99\x8c\x40\x99\x64\xb8\xae\x33\xfe\x43\x57\x5d\x3c\x2e\x39\xce\x60\x69\x28\x1c\x31\x8d\x1e\x2a\x49\x20\xfe\x0a\x25\x98\xf7\xe2\x50\x24\x81\xf8\xbf\x97\x89\x9f\x8b\x2f\xbc\x09\x2e\xfb\xcf\x01\xaa\xf8\xf6\x3b\xfd\x3f\xad\xe1\xdd\x9d\x73\xc4\xad\x48\x16\xf1\xa8\x2c\x8b\x78\x28\x56\x06\x12\x00\xfb\x19\xac\xff\x2b\x26\xf3\x13\x52\x16\xf2\x7d\xac\x10\xae\x7d\x80\x8f\xfa\xe9\x28\x5d\x44\x25\x0b\xd8\x56\x81\x61\x0a\x18\x9f\x3b\xe4\x6e\x13\x42\x1c\xa2\xe1\xd0\x12\x58\x59\x26\x6f\xc0\xbc\x28\xa5\xe3\xfe\x9b\x2c\x7d\x89\x0a\xb3\x4d\x0a\xf8\x6f\xe1\x43\x9b\xa0\x20\x8d\x1a\x4b\x63\xd1\xa8\x19\x74\x75\x1f\xda\xc2\x4e\x99\xd0\x70\x31\xf1\xd8\xd5\xbb\xfc\x3f\x6d\xe7\xdd\x1d\x1d\xe2\x31\x35\x81\xa1\x4c\x6b\x38\x40\x4d\x53\x7b\xef\x39\x0d\xad\x70\xa1\x8f\x4c\x47\x5d\x6e\xb7\x06\x73\x70\x66\x87\x39\x10\xb4\x79\x3b\x05\x1b\x2b\xb7\x1c\xe9\x5d\x9d\x82\x46\xaf\x07\x9d\x82\x5e\x69\xdb\xcd\xec\x27\xd5\x51\x95\x85\x52\x69\x58\x79\x6b\xa1\x3e\x47\xa9\xbb\x11\x75\x36\x82\x6f\x72\x2a\xf5\x01\xd4\xd2\x98\x6d\x74\x24\x8e\x89\x73\x63\x2f\x48\x5d\x8d\xe4\x1b\x8a\x3a\xfd\x54\xfc\x59\xe9\x6f\xc4\xf7\x83\x57\xce\xde\xa5\x03\x8b\xe0\x9c\x29\xb8\xf7\xc7\x4b\x5c\xc6\x88\xdf\xac\xc4\x6d\x21\x75\x9c\xc3\xa1\xd7\xb3\x36\xd2\xe6\x0f\x68\x79\xb8\xb7\xb4\x80\xa6\x6d\x1d\x82\x85\xa6\x0d\x9d\x02\x4d\x00\x1f\x34\x18\x2c\xfc\x63\xcb\x34\x67\xca\x33\xcf\x63\x2d\xcc\x51\xe3\x15\x4a\x55\xd7\xd1\x50\x8a\x95\x20\x8c\x58\xc4\xc5\xcd\xc7\x58\x05\xab\x91\x9c\xd3\xb3\xfb\x3f\xbf\x82\xd1\xa0\xf2\xb2\x49\xd7\xfd\x6d\xd9\xcc\x19\xa3\xc9\x6a\xf3\xd1\x57\xfe\x28\x06\xe6\x4e\xdb\xf5\xc0\xf9\xcb\xef\x39\xfc\xea\x47\xe0\x5d\xfb\x5f\xc1\xd8\x66\xcf\xd9\x6d\xee\x00\x1e\x7b\xe8\xb6\xc5\x2b\x94\xfa\xb1\xf5\x4a\xfd\xd8\xe2\x74\x35\x13\x63\xa3\x51\x92\x64\x59\xcc\xe7\x2b\xf1\xbb\x0c\x86\xe2\x12\xb8\xfc\xf6\x56\xc1\x8d\xc5\x18\xc6\x62\x29\x40\xec\xa2\xf0\x0d\xd0\x28\x0f\xc4\x2f\x6a\x4d\xf5\xf9\xaa\x02\xe7\x52\x00\xec\xea\xfa\xb0\x8d\xa2\xe4\xd3\xb0\x1c\xe3\x39\x0d\x40\x1e\x9b\x24\x51\xdc\xa7\x2c\x8c\xd4\x94\x4f\x29\xd9\x5b\xd1\x36\xa1\x9e\xa8\x30\x2e\xe8\xe1\xd5\xac\x92\x53\xd4\x55\x61\xa5\x55\xc0\x6b\xd4\xed\x04\xa6\xe1\xfc\xb9\x12\x15\xb1\x24\x94\x59\x1c\x47\xbc\x4d\x9c\xc0\x82\x50\x03\xb4\xa5\x0b\x13\x9a\x98\x2e\x66\xf6\xe9\xb8\x22\x82\xe0\x7c\x44\x49\xa9\x4b\x93\xd0\xb4\x08\x89\x84\x11\x33\xc2\xf3\x63\xb1\x40\xef\x2a\x04\x0d\x5c\xa6\xe5\xa7\x2c\xfb\x90\xb2\x05\x13\x2a\xf8\x56\x09\x8d\x00\xd7\xca\x90\x04\x19\xd6\x42\xb9\x43\x0c\xa1\x1a\x0d\x03\xbc\x74\x9c\xe4\xec\x1a\xde\x71\xe4\xa5\x2f\xfe\xb5\xf3\xf5\xa7\x57\x6e\x8b\x8f\xe0\xed\xcd\x85\xf5\xe3\x02\xb5\xf3\x67\x4e\xbd\xf6\xe7\xad\xe3\x56\x0f\xff\xc3\xa5\x9b\x47\x12\x27\x9e\x3b\x70\x4c\xec\x4d\xef\xda\xb6\xe1\x8a\xf8\xc7\xab\x79\xe7\xa8\xa6\xc8\xe8\xa6\xce\xd9\x7f\x5a\x7e\xe5\xd7\x17\xcd\x9f\x7b\xe2\xbc\x5b\xd7\x54\x9d\xdd\xb5\x74\x05\xd2\xbf\x30\xf2\xa1\x76\x48\x9c\xd5\xd3\xd3\x65\xb4\x4e\x0b\x43\x65\xb7\xcb\xe8\xf2\xfa\x1c\x00\x78\x01\xf4\x51\x2c\xfa\x4e\x28\x0e\xe0\x38\x57\x87\xe0\xe0\x38\x68\xe9\x38\x02\x40\x17\x06\x07\x6a\x6d\x9c\x11\x2f\x99\xd1\xc9\x2a\x0a\xa1\x42\x80\xee\x1d\xe0\x26\x0c\x69\x23\xf0\xbb\x90\x7a\x33\x92\x77\x9d\x6d\x2e\x9b\x69\x6e\x03\x58\xcf\x4c\xf1\xce\xc1\x42\xb3\x40\x81\x8e\xa9\x6f\xfe\x63\xe5\xe8\x99\xf5\xe4\x3a\xb8\x1b\x0f\x80\x75\xff\x61\x70\x6a\x37\xb8\xed\x46\x70\xda\xf2\x1e\x98\xd2\xec\x3e\xbb\xcd\x23\xdb\xbe\x66\x94\x33\xa7\xc6\x43\xcb\x1c\x44\x5a\x39\xe0\x23\xad\x5e\x3b\xc7\x19\xac\x86\x50\x98\xf5\x75\x0a\x2c\x6b\xd1\x5a\xe0\xb4\x2d\x2c\xa9\x45\x8c\xc8\x5a\x52\xcd\xac\xd7\xd7\x3c\x4b\x1e\x6f\x58\x3e\xf2\xf0\xc4\x33\xb8\xac\x7f\x6b\x43\xc8\x3c\x83\x4a\x1b\x1b\xd2\x38\x18\x22\xfa\xe2\x8d\x83\x67\x34\xfc\xf6\x21\x34\x27\xd1\x67\xc5\xdb\x4f\x89\xa7\xc5\x0f\x3c\xc4\xcf\xa6\x5b\xc4\xa7\xef\xfe\xa6\xa4\x27\xed\x20\xbf\x9c\xf3\x3c\x68\x1c\x01\xfd\xe3\x33\xa2\x28\x6e\xfe\x0b\xe0\x80\x7e\xd9\x9a\xf6\x51\x0f\x3c\x71\x76\x09\x54\xbe\xe4\x45\x0b\xc5\xe3\x50\xf7\x52\xf0\x0c\xa5\xe0\xdc\x0b\xb0\x59\x69\x0e\xa7\x78\x1e\x8b\x18\x0c\x45\x2c\x45\x79\x31\xac\xb0\x08\xe7\x9d\xbc\xf3\x38\xe0\xd2\x9c\x10\xe6\x4d\x26\x3e\x4c\xc4\x75\x71\x7f\x87\x10\x67\x75\x4c\x87\xa0\x23\x31\x55\xcb\xa1\xb3\xac\x4c\xc5\xeb\x90\xad\xc3\x91\xcb\x29\x59\x26\x86\x76\x50\x34\x24\x71\x38\xe5\x20\x80\x69\x80\x36\x94\x0a\x1a\x83\x02\xb7\xaf\xb9\x1c\x0a\x65\x79\xec\x9e\x9a\x69\x7a\xff\xb2\xd4\xc5\x97\x4e\x1d\xbb\x86\xdb\xb8\xf3\xa6\x4f\x8a\x2f\x2a\x9e\x31\x6b\xd4\x03\xaf\x9e\xea\x05\xd5\x60\x5a\xa5\x75\xc7\xf9\xcf\x3c\x97\x14\xdf\x78\xde\xe9\xbd\x79\xe7\xcc\xd9\x94\x6e\xa3\x56\x77\xdf\x9e\x7f\xba\xf9\x77\xc4\x27\x0b\x8e\xa0\xd6\xa8\x03\xe2\x68\xaa\x0a\xee\xa9\x10\x36\x2d\x5d\x6c\x61\x09\xd6\x60\x08\xb9\x60\xdc\x12\x8e\xd0\x36\xa3\x0d\x6e\x27\xa3\x91\xc3\x39\x7f\xa7\xe0\xe6\xbc\x38\xd4\x6b\x24\xd9\x17\x48\x41\xd5\x25\x97\x97\xab\xcf\x40\x5d\x2b\xc8\x08\x72\xda\x48\x81\x46\x80\xf6\x52\x82\x40\xd6\x4a\xaa\x00\xac\x3f\x60\x26\xa7\xa5\xe7\x18\x2a\x7a\x9b\xb7\xcd\x06\xcb\x86\x0a\x6d\x02\x10\x6f\x5a\x9c\x10\xbf\xf8\xe7\xf8\xeb\xa3\x35\x02\x1e\x14\x26\x6c\xa2\xc9\xf7\xdd\xcd\xe2\xae\x6f\xb4\xda\x9e\x6f\xef\x17\xeb\x0f\xf5\x3c\xf1\xcf\x53\x36\x13\x28\x7f\xa8\x62\xe9\x54\xb9\x6e\x65\x9f\xf8\x39\x71\x9c\x9a\x88\xf1\xd8\x79\xe9\x7a\x3b\x6f\x30\xb8\x58\xce\x66\xe3\x79\x12\x50\x50\x7d\x3b\x5d\x80\x63\xb9\x35\x82\x8d\x66\x29\xa4\x01\x75\x98\x8e\xbe\x40\x08\x9a\xca\x4d\x69\x13\x81\xbe\x3c\x6b\x22\x4c\x26\x44\x3d\xe7\x86\xe1\x8c\xcc\xc5\xaa\x88\x65\xcd\xb0\xb1\xca\x8f\xad\x2f\x17\xab\x07\x0c\x48\xc6\xba\xef\xe0\x7d\xf4\xe1\x84\xfb\xc9\x1d\x97\xb4\x18\xd2\x5e\x4f\xb4\xa0\xc2\x5d\xf0\x2d\xfb\xed\x41\x38\xcb\xbf\x8d\x0a\x7f\x76\xfb\x63\xec\x27\xab\xec\xb3\xb6\x7f\xd2\x75\xae\x54\x9e\x3f\xf2\x5b\x7c\xd0\x6f\x29\x85\x16\x26\xc9\x17\x7a\x7d\xbe\x48\x38\x4c\x17\xd2\x65\x54\x79\x00\x1a\x93\x00\x13\x60\xe2\x25\xc8\x8d\x21\x4a\x4a\xa0\x61\xd1\x96\x90\x71\x37\xda\x67\xf2\x0e\x3b\x21\x43\x60\x66\x2f\x92\x73\x56\x3f\xf5\x7b\x6e\x4c\x3c\xeb\xc5\xd4\xca\xb7\xdf\x6a\x47\x86\xc2\xfb\x3a\x32\x1b\x5e\xbe\x43\x14\xaf\x3b\x78\xdb\x65\xcb\x46\x1e\x30\xe1\x53\x4d\x5b\x26\xdc\x28\xfe\x74\x8b\xf8\xa5\xf8\xca\xdb\xe0\xca\xb3\x7f\xcd\xf3\x65\x9e\x9b\xf9\xa4\x78\xf0\x9f\x2f\x7e\x94\x04\x9b\x82\x23\x47\x06\xc5\xf1\xa5\xc5\xd0\xed\xeb\x3d\x0b\xba\xff\x2a\xe9\x83\xab\xc4\xd1\x9a\x12\xc5\x9e\xa6\xd3\x21\xd2\xae\x31\xda\x8d\xfe\x00\x65\x62\x5d\x24\x03\x18\xe8\x00\x30\x5e\xa3\x46\x63\x87\x21\x2f\x3c\x44\x20\x43\x8f\xae\x58\x1e\x55\x37\x90\x0c\xb9\xa7\x42\x53\xb7\xf9\x00\x95\xa8\x61\x01\x5b\x5b\x5d\x95\xb0\x10\x57\x99\xf1\x11\xe6\x1d\x2f\xe0\xf6\xcb\xcc\xe0\x3a\xf3\xe6\x9e\x6b\x66\x89\x54\x7b\xc3\x9d\xe2\x3b\xa7\x57\x31\x4c\xc0\xcd\x92\x3f\x35\x37\x7b\xce\xdd\x47\x4c\x43\x35\x7a\xe7\x08\x71\xf6\xeb\x4e\x73\xe8\x1a\x60\x26\xdf\xfd\xf5\x1f\x94\x69\x84\xe0\x49\x95\xc6\x50\x9d\x5e\xef\x69\x0d\xe2\x61\x2e\xc5\x16\xa5\x6b\xa2\x9e\x50\xc8\xeb\xf5\xfb\x8a\xa0\xc7\x6b\xd5\x68\xb5\x46\x83\xc1\xea\x23\xca\xca\x3d\xd1\xa8\x33\xe1\x6c\x17\x12\x4c\xd0\xdf\x22\x04\x31\x9f\xc3\x42\xb4\x08\x16\x4e\xaf\x45\x77\xa5\x39\xe6\xd5\x86\xbc\xf0\x89\xcf\x33\xa1\x19\x4d\x1c\xb3\xab\xeb\x81\x64\x5e\xb1\x61\x20\xa1\x26\x90\xa5\x41\xf6\x2e\x58\x43\xdc\x5c\x3f\x74\xc4\x78\xc7\xdc\xa5\x26\x30\x7f\x8d\xe7\x8d\x87\x5f\x7c\xc8\x18\x8a\xe0\x33\x07\x5f\x5a\x94\xe3\x94\xd5\x4e\xde\xb7\x7c\xee\x3a\x6b\x9d\xf1\xd1\xea\xd1\x6b\x2f\xc4\x13\xce\xc6\x9e\x35\x37\xed\x5d\xbf\x31\x5e\xf7\xa7\x17\xb8\xb9\x97\x2c\xc8\x32\xcc\xfa\x96\xce\x40\xe4\xb3\xe2\x33\x75\x52\xfe\x48\xe1\x1b\xb5\x21\x98\x22\xc5\x0e\xa1\x7a\x35\x8c\xc5\xa6\xa4\x5d\x7a\x8d\xc1\x40\x31\x2c\x4d\x43\xe3\x44\xd9\x1d\xb4\xc1\x64\x80\xce\x9b\x56\xa7\x45\x2a\x91\x16\x18\x9d\x8e\x30\x11\x08\x1a\xaf\x43\x20\x6c\x03\x26\x9f\x95\x0a\x73\x5b\x5d\xa6\x1a\x51\x61\xdf\x57\x60\x2a\xe0\xae\x84\xa7\x09\xbc\x79\xc0\xdc\x73\x99\xf9\xc1\xb9\xf7\x3b\x0e\x4e\x94\x2b\x30\x27\x1e\x76\x3c\xb0\x40\xaa\xa8\x2c\xea\x06\x6f\xa1\xc7\x27\x96\x75\x63\x72\x7d\x09\xf5\x32\xd5\x0e\x2d\xcd\xaa\x74\x1d\x1b\xb4\xd9\xb0\x80\xdb\xe8\x76\x21\xb0\x3e\xbf\xc7\x63\x77\x51\xae\x50\xd8\x6f\x73\xd9\x39\x18\x06\x04\x59\xb8\x07\xdc\x04\x47\xa0\x8b\x4a\x93\x9e\x84\xe6\x2a\x6f\xae\x72\xec\x25\xdf\xc0\x59\x15\x40\x98\x6c\x18\x96\xf3\x0b\xac\xa9\xfc\xb9\x67\x98\xf8\x24\x22\x44\x79\x63\xea\x11\x00\x20\xd0\x82\xb7\x8f\x99\x7a\xd6\x99\x8e\xee\x8e\x7c\xf4\xa2\x30\xa3\xa4\x9d\x70\xc4\x17\x16\x97\xe3\xe9\x55\x66\x70\x9f\x79\xbb\x98\x00\x73\xaf\x34\x89\x17\x89\xef\xce\x5e\x80\x24\x22\x3a\x5f\x7e\xc1\x29\xf6\xdc\xe4\xec\x15\xff\x8d\x9b\x50\xa1\x89\x38\xa9\xa7\xd6\xd3\x8c\x6f\x2a\x91\x75\x86\xcc\x5f\xbb\x1f\xfa\x04\x1d\xe9\x72\xcc\xec\xf1\x98\xb4\x5a\xbb\x45\x93\xe3\xaf\xf5\xfa\x6c\xae\x56\x81\xb3\x01\x33\x66\xd2\x62\x5a\xc2\xa8\xa3\xfb\x91\xd7\xa6\x32\x9a\x22\xbf\xbb\x39\x23\x5a\xa5\x75\xa0\x02\x2c\x5b\x28\xa3\xef\xb4\x03\xd2\xd8\x3e\x3e\x0a\x2c\x59\x30\x2c\x91\x36\x20\x01\xfb\xd3\xd9\x92\x0e\x70\x0d\xfb\xc9\x79\xce\x5e\x59\x8e\x62\xb8\xc7\xc6\x49\xb5\x33\xe3\xd3\x71\xa3\xce\x64\x82\x61\x0c\x4d\x93\xd0\x19\x60\xac\x84\xde\xa0\x87\xfe\x99\xc1\xa0\xb5\xc8\x2c\xe7\x5a\x12\x86\x39\x8e\x3c\xb6\xa4\xdf\xd9\x4a\x40\x29\xe3\xcd\x6c\x26\xf0\xfc\x56\xdb\xb6\x85\xa8\x3e\x71\xed\x3a\xdb\xfa\x05\xe8\x5c\xe0\xbd\x5d\x3d\x7f\x76\x36\xe2\xbb\xba\xf0\x2a\x89\x4b\xae\xf7\x09\xb8\xa6\xd3\xe1\x9a\xfa\xb0\xb9\xe9\x4a\xce\xed\x21\x30\x87\x83\xb1\x62\x66\xad\xd9\x6b\xb1\x58\xad\x01\x2f\xef\xf4\x5b\x1d\x0e\x1f\xe7\x34\x63\x8c\x87\xf4\x7a\x2d\x4e\x07\x0d\x67\x65\x30\x10\x6d\x82\x01\x64\x57\x15\x6d\x73\xbe\xce\x56\x97\x42\x2c\xfc\x70\x43\x54\x66\x2b\xda\x24\x66\x7e\x19\x30\x01\x29\xe3\x0c\x64\x29\x5f\x0b\xd5\x18\x07\x57\x95\x00\xa1\x5a\xe8\x80\xd4\x82\x8f\x4d\xf5\xb5\x7e\xae\x7c\x94\xb3\x75\xcc\x9c\x25\x9e\x8f\xdd\x0f\xde\x6a\x9e\x62\x7a\x77\xbc\xf8\x98\xf8\x81\x0e\xaf\xd4\x88\x2b\xdd\xe4\x25\xd3\x04\xd3\xa4\xa7\x1c\x0b\x17\x3f\xbe\x63\xe7\xb9\xc1\xe3\x3c\xc3\xf1\xf6\x9e\x23\x49\xe2\xd9\x84\xf8\xf0\x0e\x79\x6d\xa7\xf4\x7e\xad\x2d\x80\xe7\xb5\x06\xbb\x22\x3d\xc2\xe6\x70\x98\xe3\x91\x88\x9f\xf2\x78\xfc\x7e\x43\x09\x5c\xf7\x92\x92\x54\xa5\xa1\xb2\x76\x50\x65\x49\x89\x39\xe2\xf7\xdb\xcc\x08\x5c\xa6\x2c\x48\x13\xa9\x9a\x1a\xad\x9b\xa2\xb4\x5a\x7e\xae\xa0\xb5\xa1\x27\x84\x17\xce\x15\x70\x16\xeb\x13\x0b\x48\xd7\x47\x0d\xa9\x8c\x82\xb6\xe6\x65\x85\x32\x85\x7c\xd2\xff\xa8\x18\x04\x9e\x11\x29\x3b\xa1\x51\xb8\x12\x15\xc3\x23\x5f\x5b\x27\xd4\x2f\x64\x15\xa0\x5c\xff\x44\x1e\x7a\x7a\xc9\xf8\x65\xbe\xd7\x6f\xdc\x78\x99\x65\xff\x56\x33\xee\x32\x2f\xb9\xcb\x38\xc3\xb9\xaa\x8c\xd0\xde\xdf\x69\x06\xdf\x9a\xbb\xee\x32\x94\x97\xf9\xe7\x07\x9e\xed\x34\xe3\xa4\x79\xd3\x5f\x36\x99\xc5\xc5\x6d\x0b\x87\x15\x2f\x5d\x71\xfe\xa0\x26\x62\x27\x3a\x3d\xe7\xe6\x37\x06\xe6\x3b\x2c\xc5\xb1\x38\xf1\x92\xf4\xef\xb9\xe5\xa5\x25\xb5\x36\x23\x39\x12\xfd\x0b\x46\x4e\x63\xa1\x4f\xf4\x29\xb4\x4d\xa4\x74\xbf\x36\x31\x5d\xe8\xd5\xe9\xf5\x2e\x27\xa2\x59\xd6\x50\x4e\x2a\x40\xfb\xa1\x2b\xe1\xf2\x40\x4f\x55\xe7\xc1\x71\x0f\x61\x72\x74\x0a\x8c\xc9\xeb\x93\xf2\x1d\x4a\x49\x63\x59\x96\x99\x07\x64\xd1\xcd\x52\xd9\x44\xad\x2c\x4f\x04\x28\xbc\xe7\x2c\x42\x1f\xcd\x08\x0a\xc8\x57\x8e\x98\xc1\x87\xe6\xa3\xef\xaf\xe9\xf9\xfc\x63\xcf\x43\x77\x96\x2d\x70\x57\x0b\xc0\x58\x17\x19\x3e\xcd\x7a\xe6\x80\x19\x1c\x05\x0f\x21\x37\x08\x4e\x35\x4e\x4e\x3f\xeb\xdb\xbd\xcb\x6e\x02\xa5\x0f\xc1\xd8\x7b\x06\xb5\xca\xdd\x7c\xee\x32\xf9\xee\x59\x1c\x87\x6a\x79\x6c\x1a\x62\x49\xae\x5e\x85\x1a\x6f\xd3\x90\xb7\x48\xb6\x17\xfe\x5b\x73\x15\xf5\x1a\xf4\xf9\xca\xb0\xd1\xe9\x70\xa1\xd9\x4e\x10\x61\xca\x4c\x95\x57\x78\x79\x0c\xab\x20\xec\x76\xbd\xd5\x1a\x83\x0e\x87\x95\xd4\x17\x77\x08\xfa\xac\x83\x91\x71\x87\x40\x4e\x37\x64\x7c\x0b\xbb\x46\x46\x71\x89\x84\xa3\x4a\xfe\x80\x94\x42\xa0\x52\x5c\x6e\x1f\x06\x79\xb5\x07\x9a\xab\xae\xde\xee\x7b\x45\xbc\xeb\xd4\x1f\xc5\xde\x6b\x11\xbc\xcb\x11\x60\x1c\x31\x7c\x42\x24\x19\x69\x1a\xd4\x38\xa9\xe7\xbd\xdd\x5b\xba\x5f\xbb\xec\xc6\x2b\xff\xf0\xfa\x66\xaa\x62\xdd\x7d\xc9\x69\x0b\x10\xa4\xcb\xd6\x5f\xf7\x22\x88\x97\x5b\xb6\xd9\xa7\x24\x5d\x2e\x5f\x71\xb2\xaa\x66\x4a\xcf\xc9\x67\xde\x7f\x59\xbc\xe2\xc9\xa7\xfe\x21\x01\xbc\x48\x9c\xbc\xe4\x83\xe4\x16\xa8\xfb\x4b\x90\x6c\x36\xb3\xd3\x59\x96\x20\x0c\x1e\x4f\xc8\x47\xf8\x4a\xcb\x3c\x06\x03\xa6\xd5\x46\x5a\x05\x87\x96\xc1\x8a\x72\x59\xcd\x9c\x6c\x79\xb4\x99\xd2\x13\xa3\xb2\x84\xbc\x79\x12\x39\x14\x91\x35\x6c\x1e\x7b\xef\xcd\x12\x49\xef\xc6\x63\x45\x15\x8d\x8a\x38\x9b\x2f\x32\x5d\x7d\x76\x43\x96\xc6\xd7\x2e\xf3\xf5\xae\x5a\x6c\x9f\x18\xcb\x88\x31\x66\xcd\xdd\xc5\xa9\x21\xa8\xe9\x18\xbf\x22\xcb\xec\x2b\x3d\xab\xd1\xe2\x28\xed\xfb\x30\xf6\x30\x62\x61\x6c\x52\x3a\xa9\x31\x21\x80\xdb\x50\x38\xec\x35\xb2\x1e\xd6\x13\x89\x7a\x43\x81\x10\x7c\x52\x5e\x4f\xb8\x53\xf0\x10\x3c\xde\x21\xf0\x24\xa3\x87\xde\x13\xab\x22\x7a\xc7\x72\xd1\x3a\xf2\x64\xb3\x8e\x46\x25\x6a\xf7\xcf\xf9\x80\x79\xee\x5f\x00\x84\x64\xc4\x5a\x40\xae\x6b\xdf\x90\x71\xfc\xc0\x57\xaf\xaa\x7d\xbe\x09\x6b\x2b\x89\xb1\xe2\x3b\x07\x10\x90\xcb\x51\xe0\x20\xdf\x64\x15\xaf\x8f\x6c\x3f\xbb\x3e\xe7\xf1\x19\xc9\x5f\x97\x23\x43\xad\x89\x4b\x32\x41\x6f\x90\xba\x82\x78\x01\x33\x63\x51\x78\xc2\x92\x24\x0f\xe3\x40\xa3\xdd\xe1\xa0\x8d\x3e\x8b\xcf\x12\x8b\x87\xb0\x56\x21\xc4\xb8\xb5\xad\x30\xe8\xb0\xd3\x32\x9b\xaf\xc5\x01\x15\x3f\xdd\x9f\x99\x78\x20\x91\xb2\xfb\xac\x96\x0d\xc7\x63\x4a\xe9\x5c\x84\xc0\xb1\x6c\x46\x22\x00\xf0\x52\xe9\x79\x34\x2f\xf5\xb5\x7b\x26\x12\xd1\x4f\xce\x37\x89\x6e\x53\xd7\xbb\x37\x36\x94\x8b\x67\xdf\x90\x1e\xe1\xb4\x2f\x1b\x89\x79\xf2\xb3\x78\xe8\x0e\x70\x5c\x3f\xf6\xb7\x5f\x25\x6a\xe2\xa7\xc5\x83\xe2\x4f\xe2\xd7\xf2\x53\x74\x90\x50\x9e\x34\xf4\x19\x66\x42\x7d\xc1\xc3\x5d\x37\x29\x5d\xe4\xb1\xdb\xc3\x41\x2c\x10\x00\xc0\xac\xd5\x68\x42\xf0\xfb\x4e\x21\x68\x0e\x9a\x49\x26\xa0\x63\x74\x50\x5d\xc0\x98\x9c\xd4\x74\x08\xa4\x4d\x8d\x74\xae\xf4\xae\x64\x0a\xea\x53\x2a\x36\x0f\x90\x11\x21\x9b\xe5\x92\x52\xd2\xa1\x44\xe6\x0e\x01\xdf\x3e\xfe\x03\x63\xcf\x4c\xe3\xfe\x97\xe3\xad\x4b\xc3\x63\xa6\xd5\x2d\x7d\x06\x3c\x26\x02\x4a\xfc\x87\xf8\x55\xf1\x2d\x47\xd6\x5e\x30\x6a\x09\x6e\x11\xa7\x22\x87\x82\x5c\x5a\x32\x18\xa5\xb9\x1e\x3e\xf6\xde\x77\xe7\x3f\x7e\xc7\x86\xcb\x7a\x1e\xc0\xb2\x9c\xd1\xd0\xe6\xa1\x73\xd3\x99\x4e\x85\xec\x18\x56\x5a\xa6\x49\xc4\x11\x52\x90\x5e\x4f\x5b\x2c\xa5\x71\xaf\x37\xea\x8f\xb6\x0b\x7e\x46\x72\x28\xd2\x36\x60\xd1\x9b\xf4\x12\x6b\x74\x51\x5f\xd6\x68\xf7\x5f\x55\x1e\x6e\x9f\xc6\xe5\x1c\x6f\x74\xa6\x71\x99\x55\xc5\x4e\x5a\xe2\xf7\x18\xa4\xb3\xcd\xcb\xbf\xc4\xfe\x7e\x6c\xe1\xb0\x82\xb4\x81\x4d\x40\xcf\xa9\x7b\xfb\xc0\x4c\xd2\x4a\xfb\x32\xb5\xf2\xf5\x3f\x49\x6e\x86\x78\x66\x4f\x1f\x3e\xe9\xde\xd3\xbd\x01\xf2\x1f\xd2\x7d\x50\x18\x5b\x9b\x1e\xe6\x64\x59\xc6\x15\x0e\xa1\xfb\x2f\xa4\xec\x79\xbb\xdd\xc7\x50\x4c\x24\xca\xba\xc2\x2e\xe8\x1b\x86\x3a\x85\xb0\x29\x6c\x22\x74\x46\x8d\x0e\x3e\x3d\x1d\xc1\x43\xf7\x91\xef\xeb\xda\x32\x2f\xe6\x4e\x9b\xfc\x40\xd5\x31\x71\x0e\x2a\x49\xce\x84\xc7\x54\xf0\x48\xa9\xa0\xc2\xec\xa0\x45\xe1\x72\xe6\xd1\x66\xfc\x5e\x05\x25\x89\x4e\x00\xcd\xb9\xfb\xf6\xbd\x77\x83\x49\x5c\xf9\xc9\xf4\xd2\xbb\x9f\xd8\xb8\xb6\x68\xee\x82\x1c\x56\xd2\x94\x3f\x1e\xba\xed\xcd\x64\xcf\x29\xe8\x21\x76\x9e\x7f\xd7\xce\xcb\x56\xf7\xbc\x23\xfb\x00\x25\x50\x2f\x8e\x87\x7a\xa4\x18\xeb\x4a\x0f\x0b\xb3\x44\xa1\xc9\x45\xb8\x4a\x4a\xc3\x26\xa8\x01\x59\x86\xc5\x31\xb6\x8d\xdd\xc7\x3e\xc8\x7e\xc7\x52\x16\x82\x65\x39\x8e\xee\x10\x38\xb2\x1c\xd1\x82\x31\x85\x6d\x85\xd0\x87\x2f\x2c\xc4\x10\xc8\x17\xc6\xaa\x4a\xad\x57\xa9\xbe\x95\x4b\xf5\x55\xa4\xce\x92\xde\x1c\x86\xab\x00\xfb\xd9\x2c\x60\xbf\x85\xc8\x66\x34\x2c\x00\x7c\xf6\xee\x87\x35\x8b\x0f\xdd\x77\xff\x05\x0d\x4b\x37\x6c\x5b\xd5\x22\x0c\xfa\xdb\xfd\xaf\xff\x4d\x78\xfa\xf5\x31\x97\x2f\xa8\xff\x6d\xce\x23\xe5\x93\xa6\x37\xcc\xfa\xc1\x7e\xf8\xbe\x79\xbb\xd7\xce\xa9\xaa\x49\x4f\x1e\x3a\x7a\xf2\xd8\xe3\xa0\x21\xb9\x67\xe7\xda\xa3\x9b\xd2\x7c\xd9\x88\x39\xa3\xff\x34\xaa\xf4\x1d\x71\x77\x30\x81\x64\x85\x36\x00\x7f\x0b\xea\x97\x42\x6c\x46\xba\xc2\x63\xc1\x22\x5a\x3b\x66\x2f\x4a\x7a\xb4\x09\x2b\x16\x61\x22\x2b\x23\x84\x81\x88\x44\x12\x09\x18\xa3\x25\x38\x8f\x05\xd0\x16\x60\xa2\x90\x67\x07\x77\x73\xe6\xce\x25\x8b\x59\x9a\x83\xa2\xcf\x97\xae\xb6\x6a\x18\xa8\x55\x20\xb7\xf3\xb8\x08\x32\xc9\x74\x59\x36\xa8\x72\x82\x43\x57\x6e\xda\x3c\x79\x71\x71\x97\xbb\x74\x54\xfc\xce\x45\x17\xee\x18\xba\x72\xcd\xb6\xe9\xf5\xa3\x6a\x97\xc5\x07\x8d\x2a\x2c\x7d\x78\xc4\x75\xbb\xff\x77\xf6\x65\x42\x51\xb2\x6d\xf8\xcc\x84\xe7\xfc\xef\x7d\x97\x2e\x9f\x7d\xe9\xb4\x58\x59\xfb\xa8\x8a\x86\xb2\xc8\xe6\x5e\xcc\x16\xba\x5c\xba\x4f\xfe\x08\xc3\xc8\x0f\xa5\xbb\xbc\x29\x92\x1e\xdd\x20\x8e\xc7\xdf\xa1\x6e\xc1\xfc\x58\x11\xd6\x9c\x8e\x85\x09\xa2\x40\xa7\x33\x9b\x7d\x76\xb7\x3b\x59\x1c\xc3\xda\x84\x58\x8c\xd7\xd8\xed\x3c\xcf\xb4\x0a\xbc\x47\x13\x68\x15\x34\x40\x7d\x89\x87\xe0\xf5\x55\xfa\x26\x9f\xa8\x29\x68\x95\xe9\x44\x33\x3c\x41\x8a\xb7\xa6\x61\x55\x3c\x1a\xa0\x70\xdc\xa2\x6b\xcf\x03\x11\xcf\x3e\x63\x45\xd8\xed\x4e\xa7\x0b\xa6\xcc\xb8\xed\xb0\xfe\xc9\x02\x73\xd5\xf0\xd2\x68\x49\x53\x19\xf1\xfd\xd2\xb6\x25\x57\x88\xb7\x77\x5d\x7d\x6e\x7d\x7d\x55\xcb\x70\x76\xf5\xa7\xb6\x5b\x76\x94\xd6\x90\x05\x0c\x18\xd4\x50\x15\x29\x1b\x53\x1c\x29\x93\xf6\x27\x0f\x65\x41\xb5\x40\x71\x6c\x5a\xba\x34\xe4\xf7\x47\x71\x86\x81\xd1\xb4\xc7\xa3\x73\x38\x12\x05\xce\x90\x3f\xd4\x2a\x78\xd3\x1e\x3f\x6d\xe3\x18\x28\x19\xc3\x69\xcc\x50\x1c\xfd\x24\x41\xe3\xc9\xa4\xd7\x51\x60\x9d\x72\xbf\xa6\xca\x4b\xdb\xea\xb2\x19\x36\x89\xa0\x5b\xab\x2a\x38\x66\x6b\x35\x03\x93\x75\x97\x2f\xf6\x85\x8f\x5f\x23\xb4\x26\xd2\x3c\xeb\x59\x9a\x32\xa6\x98\x7e\xc4\xdd\x45\xf7\xbe\xfc\x2e\xaa\x39\xc6\x7a\xeb\x34\xfd\x09\xbc\x25\x79\x3a\x94\x1a\x2d\x1e\x1b\x9a\xf6\x43\xdb\x46\xe0\x7a\xdc\x69\x76\x59\xf4\x7a\x93\x9d\x94\x5a\x16\x08\x87\x5c\x91\x95\x6f\x05\xf2\xbd\x46\xb9\x00\x2b\xa7\xf7\x33\x79\x34\xa9\xf4\xea\xa5\x0b\xe5\x5b\x8d\xa5\xcf\x10\x8b\x94\xb2\xab\x97\x51\xc1\x15\x79\x5e\x99\x7c\x93\x81\xca\xad\xce\xde\x20\xd7\x5a\x0d\xeb\x3d\x4d\x44\xa0\x7e\x8f\x61\x13\xd2\x09\x5f\xd0\xeb\x8d\x44\x68\x13\xc3\x10\x7a\x7d\xdc\x9e\x30\x05\x7d\xc1\x56\x81\xf6\xd1\x48\xb3\x3b\x1c\x36\x20\x93\x9e\x67\xf3\xe1\xd9\xfb\x6e\x85\x6f\x5e\x55\x20\xd6\x97\xf6\x3c\x17\x15\x2a\x59\xb0\xfe\x0c\xe8\x1b\xd8\xd1\x60\xd1\x42\x39\x32\x2c\x1f\x6b\xf5\xf7\x67\x43\x0f\xad\x90\x63\xc3\xb5\x5d\x07\x73\x8b\x0a\xb0\x9b\xc4\xd1\xd2\x9a\x06\x11\xfe\x7f\x00\xc3\x18\x9d\x99\x33\x87\x9c\x61\x17\xc7\xf1\x01\x2b\x6f\xed\x84\xea\x58\xa7\x33\x1a\x89\x4e\xc1\xe8\x55\xa1\x1e\xf5\x59\xd6\x94\x8c\x35\x9c\xbd\xbb\x43\x35\xb2\xb5\xfd\x2a\xdc\xf0\xcd\x4d\xf5\x45\xe3\xf8\xa1\x42\xf5\xb2\xfd\xe2\x56\xd3\xbb\x7d\x2b\xdc\x7e\x7a\x61\xd4\x68\x37\xff\x90\xf8\xa6\x1f\x8c\xac\x1b\x43\xbe\x92\xab\x70\xfb\xed\x76\x38\x57\x54\x83\xf4\x34\xf4\xb1\x8b\xb1\x59\xe9\x12\x97\x3d\x10\x28\x85\xa1\x6c\x71\xa1\x35\x1c\x89\x30\xd0\x87\x63\x0a\x19\xa8\x7c\xad\xd6\x38\x88\xeb\xe7\x0a\x71\xd6\x4c\x16\x03\xe8\x6a\x7b\x69\x29\xd3\x75\xa2\x4f\xeb\x66\x36\xd5\x95\x43\x4b\x56\x7c\x53\x56\x89\x95\x98\x50\x26\x57\xd4\xd7\x45\x95\x72\xad\x51\xf4\x74\xa0\x05\x59\x66\x3e\xba\x8a\x07\x9a\x7d\xaf\xf8\xb7\xc2\x38\xa3\xbc\x6a\xf6\x1a\xc5\x47\x7d\xf6\xf9\x69\x25\xe2\x57\x3f\x7d\x2f\xfe\x6a\x5f\x8d\x32\x62\xee\x9e\x95\x97\x8d\x10\xcf\x1c\xbe\x97\x30\xba\x9b\xc5\x8f\xb8\xe9\x55\x59\x57\xf5\x8a\x07\xab\x44\xba\xe7\x9b\x77\x5e\x4d\x6f\xc0\x6f\x90\x9e\xcb\xb8\xde\x53\xd4\x18\xe8\x73\x27\xa1\x6d\xa9\x62\x8c\x1c\x57\x02\x4d\x45\x3c\xa2\x73\xb9\xdd\x5a\xca\xef\xd7\x68\xb4\x11\x6d\x71\x89\x4b\xa7\xf3\x15\x14\xc4\x5b\x04\xb6\x80\x86\xaf\xe2\xe9\x20\xe7\x73\xb7\x08\x3e\x07\x2a\xe2\x93\x76\x9a\xfb\x35\x18\x1e\xf6\x73\xc5\xe5\x22\xe7\x3e\x72\x67\xa8\xec\xb5\xfd\xc4\xfd\x7d\x6e\xfb\xf0\x90\x19\x8a\xb4\x07\x6f\x5b\xf0\x3b\x3c\xf7\x27\xd8\xe9\x39\xa7\x7c\xe3\x83\x85\x3d\xcf\x0d\xc0\x7b\x3f\xa1\xf7\x7b\xe9\xfe\xb2\x08\x5b\x92\xae\x29\x08\xfb\xa2\xd1\x18\x0d\x3d\xbd\x98\x8e\x88\xb9\x6c\x2e\x5b\xb2\x58\x13\xf3\xc2\xf0\x89\xc6\xbc\x8c\x17\xb7\xa0\x4a\x46\xce\x10\x0e\x47\x2c\x7e\x3f\x3c\x0f\x1c\x06\x0d\xab\x4d\x39\x5a\xd9\x68\xb9\xae\x4f\xa9\xbb\xca\xa3\x45\x51\x33\x3a\x67\xe8\x8e\x3c\x81\xf6\x67\x02\xfa\x05\x52\x11\x09\xba\xf5\x80\x4f\x16\x8b\xd5\x2a\xb7\x34\x84\x64\x7b\xf0\x3f\x7f\xf0\xcd\xa6\x55\xa5\xf8\x88\x92\xc6\x70\xdb\x9f\x46\x18\x1f\xff\xec\x69\x71\xdf\x29\xf1\x7d\xf1\x29\xb8\xaf\xf1\x40\xcd\x5f\xa6\xb4\x4d\x9d\x84\x4f\x5b\xf0\xc0\xf1\xbb\x67\x00\xf3\x77\x57\x1e\x73\x83\x1b\xc5\x6b\xaf\x64\x96\xc5\x3e\xdf\xfd\xa4\xf8\xd5\x0d\xa7\x4f\xfe\x1b\x0c\x8a\x2e\x63\xae\x04\xab\xc5\xe5\xee\xde\xbf\x3d\xf0\xa8\xbc\x9f\xa9\xd9\x54\x3b\x56\x80\x2c\x8d\xd5\x6e\x37\xe9\x5d\x50\x2e\x02\xd3\x63\x85\x45\x91\x78\xdc\xdf\x29\xc4\x49\xab\xc9\x62\xea\x10\x2c\x84\x86\x9b\x2b\x68\xd8\xbe\xe8\x12\xea\x7b\x01\xc5\xd2\xd8\x55\xbb\x33\x91\xb7\x93\x6b\xf2\xec\x2a\x35\x9b\xee\x2c\x11\x3f\xff\xf1\x27\xf1\x17\xfb\xea\x1b\x32\xdb\xd8\x78\xe7\x6b\xfe\xf9\xa6\xb9\xa1\x31\x5c\xe5\xb8\xe4\xe4\x4b\xba\xd6\x90\xd7\x8c\x6c\xed\xf9\xb0\xe7\x9b\xf7\x5e\x41\x5b\xd3\x9d\xdd\xc5\x0f\x1c\xc0\x07\x8d\x08\x74\xbb\xf9\x35\x3f\xf9\x17\x42\x59\x60\x54\xac\x61\xa1\x2f\xe4\x43\x15\x30\x26\xad\x96\xb2\x98\xcd\x5e\x9f\x0f\xc3\xec\x1a\x8a\xf2\x07\x6c\xd0\xdb\x73\xd8\x48\x33\xa1\xd7\x9a\xf4\x50\x20\x7d\xbf\xf4\x65\x96\xa7\x3e\xd5\xd7\x7c\xca\x0e\xbb\xe2\xd6\x11\x09\x39\x2f\x8d\x68\xa0\x73\xd5\x59\xf8\x33\x6f\x9a\x7a\x4a\x4d\xef\xb7\xfe\x7b\xa7\x19\xdf\x64\x7e\xfc\x18\x28\xab\x9c\xdb\xd5\xb6\x72\x5c\x72\x9c\xc9\x5f\x59\x37\xb5\x48\xbc\x52\x4a\xfd\x81\x27\xf0\xa7\x24\x19\xfe\x0e\xde\x18\x3f\xa3\xd0\xff\xd3\x95\xee\xc6\xe1\x3d\xaf\xc9\x5c\xfb\xd4\x37\xd4\xd5\xd0\x56\xd6\xa4\xbd\x4e\x1a\x37\x99\x12\x05\x0e\x5f\x9b\xe0\x72\x39\x30\x0b\xcd\x18\x1d\xa8\x58\x2c\xd3\x7b\x2a\xed\xb3\x86\x4c\x57\x8e\x7c\x75\x96\xeb\x37\x6d\x00\x68\x92\xf2\x14\x39\x65\x8e\xd0\x87\x01\x16\xa2\x58\x68\x2a\xaa\xb7\xf3\x65\xb5\x17\xd6\x8f\x93\x69\xf4\xc1\xa3\x8b\x2e\xfc\x43\x6b\xe5\xe0\x54\x65\xbd\x8d\x2f\x89\xa4\x47\x4d\xe9\xe9\x28\x9d\xbd\x64\xa3\x38\x9a\xfd\xe1\x22\x7e\xe9\xbc\x8d\x12\x9d\xfe\x65\xf8\x27\x87\xae\x1f\xae\x35\xfd\x70\x01\x5f\x34\x69\xeb\xd9\xc7\x9b\xb6\x2d\x6b\x54\x78\x81\x8f\x48\x77\x97\x8b\xd3\x21\x8b\xd5\x6c\x33\x9b\x08\x8c\xf4\x90\x4e\x93\xc9\xe7\xf5\xd8\x0c\x6e\xb7\x13\x7e\x71\xdb\x3a\x04\x2b\xc0\x01\xca\x1d\x33\x82\x05\xc7\x8d\x6e\x9b\x99\x32\x52\x9d\x82\xc1\x98\xb9\x02\xe8\x5b\x60\x06\x32\xa5\x47\xb9\x54\xac\x9c\xfa\x8b\xd4\x86\xd4\xac\xfb\xda\x10\xc8\x34\xfc\xd5\x82\x5d\xff\xcb\x81\x4a\x30\xfd\xd9\xf9\xfb\x83\x23\x85\x21\xc4\x61\x56\x3c\xfc\x0d\x27\xbe\x29\xae\x7d\xf2\xbc\x6f\x8a\xbb\x66\x74\x9e\xfd\xd1\x8e\x5f\xd5\x0d\xfe\x66\xd6\x9e\x04\xed\x4b\xc5\xd2\xee\x9e\x4f\x79\x03\xc0\xc4\xf5\xab\xa1\x2c\x52\xcd\x20\x71\x08\xca\x72\x41\xba\x9e\xc2\x35\x40\xe3\xb6\x30\x2c\x6d\xb7\xd0\x3e\xaf\x1d\x98\x30\xb8\xf0\x6e\xc6\x8d\x1b\x08\xb7\xdb\x4b\x6b\xcd\x5a\xa8\xf2\x70\x0a\x6f\x15\x18\x8a\xc2\xcc\x26\x93\x99\x06\xd0\x1f\x6d\x11\x30\x47\x36\x53\x28\xb9\x62\x79\xe5\xd8\x59\xc4\xa7\x6c\x0b\x6c\xf6\x06\x3a\x52\x2b\x65\x33\xb3\xa2\xa1\xf4\x38\xa1\x18\xb3\xc1\xba\x9f\xaf\xb7\x3d\xff\xea\xe8\x9a\x25\xae\xfa\xa6\x0a\xfc\x46\xfd\xe7\x37\xd9\x5e\xfa\x70\xd2\xa0\x4d\xc1\x89\x4d\x63\x2b\xc1\x45\x5d\x60\x30\xcb\xec\x01\xce\x1a\x71\x7f\x97\x78\xbf\xc7\x7e\x4c\x7c\x41\xf2\x57\x7a\xa7\x8a\xa3\x48\x94\x23\x0c\xa0\x9c\x97\x9b\xa6\x71\xa7\xd1\xeb\x0d\x86\x38\x0a\xc7\x83\x8c\xdb\x0d\xa3\x01\xb7\x1b\xe3\x5d\x36\xde\xd6\x29\x70\x30\xea\xd1\x21\xb8\x5f\x6f\x06\xa2\x4d\x55\x0c\x87\xe5\xd2\x43\x4a\xc3\x8e\x44\xb6\xa3\x54\xfa\xd8\xa4\x5a\xb7\x5a\xa0\x28\x2c\x2d\x20\x51\xb9\xc6\x77\x5f\x3c\x3c\x64\x56\xd9\x0d\x83\xde\xfb\xf8\xc4\xd3\x63\x6c\xe0\xd4\x86\xd7\xa7\x8f\x14\xea\x89\xa9\xac\x48\x82\x23\x47\xc5\x47\xc4\x51\x05\x60\xfe\x19\xce\x03\x0a\x01\xff\xc0\x63\x4b\x71\xb7\x1d\x3d\x95\x9e\xbf\x37\x88\x57\xbd\x25\xbe\xb2\x1f\xcd\xff\x03\x38\xff\x0b\xe1\xfc\xfd\x58\x6b\x1a\xda\x17\x8a\xf0\x1a\x75\xba\xa0\x45\xa3\xb1\x13\x44\x80\x62\xa0\x36\x86\x8b\xaf\xd5\x5a\x3a\x05\xbd\x96\xf0\x62\x18\x0f\x3d\x2f\xaf\xaa\xf0\x27\x93\x44\x06\xb9\x73\x9c\x01\x44\x84\xfa\x89\x89\x81\x0c\xbc\x3b\xd0\xa2\x14\x49\xce\x7b\x00\xff\x3e\x27\x7e\x83\x6f\x11\x5f\xb3\x11\x75\xf5\x82\xa6\xed\xcd\x75\x20\x66\x1b\x23\x7e\x2e\x8a\xdb\xae\xae\xb9\xb5\x66\xda\xac\x11\xcf\x8b\xa3\x7e\xfa\x1c\x4f\x4d\xc7\x8b\x97\x8a\x47\x4e\xda\x7b\xbe\x58\x2a\x7e\x24\xfe\x6d\xff\x43\x1e\xee\x8c\x78\x7b\x01\x9c\xfb\xd7\xe2\x68\xe2\x59\xe2\x20\x9c\x0f\x5c\x7b\x8d\xd5\x4a\xb8\x10\xf1\x25\xa3\xd5\x3a\x08\xc2\x67\xd5\x68\xd8\x16\x41\xa3\xc1\xa0\x63\xa3\xd3\x31\x2d\x82\x8e\xc6\xf8\x36\x79\xf2\x7d\x3c\xf9\xec\xd2\x67\x69\x87\x33\xee\xbc\xad\x16\x64\xeb\xf1\x58\x28\x80\x15\x71\x60\x22\x6a\x85\x43\xef\x9d\x3a\xf3\x85\x78\x5a\x47\x68\x2a\x9a\x48\xdb\xdc\xc1\x2f\x9c\x33\xce\x11\x0f\x7c\xbd\xed\x0a\xf3\x88\x23\xe2\xe8\xe7\x1e\x79\x0e\x10\x71\xf0\xf7\x0a\xf1\xd4\x1e\x86\x15\x87\xd5\x8b\xd3\xbf\x0a\x4e\x48\xa0\x39\x3f\x0b\xe7\xfc\x04\x3c\x03\x45\xa8\x07\xc1\xc2\x71\x1e\x78\x90\x89\x84\xde\xe3\x49\x16\x87\xe1\x92\x27\xf5\x30\xb2\x74\x9a\x5a\x04\xb3\xd3\x89\x39\x78\xda\x41\xb7\x08\x76\xbb\x83\xc6\x62\xb9\xa9\xa7\xca\xd4\x15\xfb\xe8\xda\xb2\xef\xce\xb1\xaa\x02\x12\x29\xd6\x92\xb7\x4e\xe6\x48\xcb\xdc\x7e\x99\x80\x4b\x92\x67\xde\x8b\xff\xfc\xea\xef\xf3\x26\x9e\x6d\x37\x80\x79\x07\x07\x2d\x75\x0e\x6e\xaa\x20\x02\x7a\x71\xc5\x4d\xeb\xd3\x17\x6d\xbb\xed\xea\xf5\xe7\x5f\xbf\xcd\x92\x3e\x2a\x8e\xbe\xed\x8a\x5b\x4f\x78\xcc\xe9\xc1\xe7\xd7\x83\xe1\xd2\x81\xa8\x10\x0f\x78\x26\x8f\x1a\x31\xbd\xc6\xc1\xff\xe1\x92\x19\xd3\x83\x13\xe2\x85\xd2\xb9\xf8\x12\x9e\xf5\xb7\xa0\xad\x08\x62\xb3\xd3\x6e\x97\x97\x0f\x68\x49\x3d\xae\x0f\xf2\x7c\x38\xc4\xe0\x01\x8a\x04\x20\xe4\x25\xb5\x24\x52\x58\xac\xe0\xd2\x6a\x01\x03\x6d\x63\x87\x60\x27\x41\x60\x9d\x5c\xfa\x83\x65\xc0\x95\x54\x0c\xe6\xbc\x5a\x5f\x29\x85\x17\xb5\x18\x62\x7e\xce\x72\x98\xb1\x99\xbb\x3d\x78\xba\x35\x94\x36\x44\xd4\x9d\x7b\x20\x04\x16\xde\x26\x5e\xed\x00\xc7\x67\x2e\x68\x17\x46\x4f\x98\x56\x33\xf9\xf6\x19\x4f\xbe\xd9\x31\xd9\xb1\xff\x1a\xf1\xd4\xfd\xf8\xbe\xa7\x01\xfb\x44\xf7\x75\x57\x2e\x9f\x5b\xf5\x3c\xa8\xb0\xb9\x6e\xbd\x6a\xd7\x8e\xee\x1b\x8f\xaf\x44\x3e\x8b\x0e\xc6\xff\xac\x84\xcb\xd2\x9a\x2e\x0c\x85\xc3\x3c\xc7\xe9\xdd\x36\x42\x4f\x44\x63\x98\xbd\x53\x80\x16\xd1\xe5\x0a\xad\x13\x3c\x2e\x17\x3c\x19\x2e\x42\x83\x6a\xf8\x90\x0d\xef\x57\x35\xd2\xa7\x15\x4f\x29\x88\x21\x43\x79\x94\xc6\x91\xb0\x96\x55\x5d\xfb\xd7\x80\x33\xcf\xfd\x55\xfc\x87\xf8\xcd\xb8\xee\x0d\x25\xb3\x2c\xde\x05\x55\x5b\x6e\x7a\x61\xce\xdc\x25\xf7\x9a\x88\x19\xe3\x66\x19\x42\xc7\x97\x5f\x3c\xac\x8a\xf0\x3f\x7c\xef\x27\x3f\x9b\xbc\x60\xd4\x3b\xbc\xfb\xe9\x23\x3f\x24\xf0\x76\x4f\xb3\x38\xf1\x2d\xad\x51\xbc\x5b\x27\x3d\x8b\x8f\x60\x0c\x93\x84\x7b\x2e\x8c\xb5\xa7\x0b\xf5\xa1\x10\x16\x0e\x3b\x7c\x04\x8c\x13\x1d\x11\x33\x0c\x6e\xcd\x66\x16\x67\xdd\xad\x02\xc7\xb1\x9c\x1e\x97\x0a\x15\x5a\x04\x3c\x73\xc9\x55\x86\x6e\xb7\x72\xa5\x3d\xd9\x48\x26\xc3\x07\x26\x17\xac\x22\xd7\x4a\x09\xe5\x35\x91\x4c\x13\xae\x2c\x50\xe4\xed\xed\x26\xfc\xed\xfa\x71\xb6\x8e\x85\x7b\x62\xde\x54\xd3\x75\x7b\x3f\xfb\xf4\xb6\x9b\xe2\xad\xcc\xa8\xa9\xcb\x97\x6c\x6a\x28\xe9\x40\x10\x03\xe2\xc1\x6b\xd9\xb7\x75\xcc\x45\xdd\x07\x1e\x8c\x00\xee\x70\xc1\xea\x2b\xaf\x0d\x4b\x73\x3f\xd3\x7b\x1a\x7f\x04\xc6\xb7\x85\x70\xfd\x13\x0e\xad\xb6\x28\x19\x08\x87\xbd\xb1\x82\x68\x14\x9a\x0b\xaf\xd9\x5c\x14\x28\x88\x15\xb4\x0a\x91\x74\x38\x46\x1b\x6c\x2d\x82\xc5\x62\x90\x30\xab\xa5\x83\xa2\x04\xb5\x20\xa5\x8a\x01\x6c\x39\x18\x40\x8e\x97\x58\xa2\x15\x56\x69\x25\x36\x2f\x03\xa8\x98\xa4\x01\x64\xfb\x5d\xc0\x5e\xaf\xb7\x63\x52\xc9\x5f\x5f\x9d\x70\x34\x59\xda\x48\xa7\x57\x4d\x9c\x57\x3d\xa8\xb1\x75\x02\x19\xc8\xc6\xb6\x1e\x7c\xa7\xc7\xcf\x54\x4f\x98\x93\xde\x7d\x4f\x84\x05\xd4\xe6\x19\xd3\x86\x27\x86\x07\xe3\xc5\x5d\x23\x5d\xfc\x61\x29\xc6\xdd\x85\xe1\xbd\xf3\xc5\xf1\x44\x0f\xf1\x02\x66\x85\x16\xb0\x25\x5d\xe4\xb0\x58\xbc\x3e\xab\xcd\xa3\x43\x95\x3b\x08\x2c\xc4\x6b\xb3\xb6\x0a\x36\x87\x47\xa7\x73\x1a\x9d\x13\x05\x23\x23\x63\x87\x00\x0f\xd6\xd0\xa7\x92\xac\x1f\xa6\x21\x9b\xdf\xe5\xcc\x60\x54\x6d\x8d\x52\x1c\xaa\xfd\x4d\x5c\x62\xea\x3e\x79\x9e\x09\xec\x0c\x34\xef\x5f\xba\x74\xa5\x78\x8b\xb8\x0f\xda\xba\xe2\x78\x6c\xe9\x10\x71\x7c\xa3\x93\x3c\xe4\x6c\x3c\x78\xde\xb4\x5b\x2e\x13\x7f\x15\x37\x6c\x5c\xb8\x0c\x4c\x7c\x77\xc2\x8c\xf9\xd3\xe5\x78\xfc\x7a\xf8\x57\x85\xc4\x81\xce\xa5\xf5\x12\x27\x29\x8e\xa1\xe3\xd9\x90\xa1\xed\x0b\x45\xa0\x2b\x51\xb1\x6f\x1f\x75\x8d\x94\x5b\xb9\x1c\xfe\x35\x5c\xe1\x4c\x0f\xa6\x2d\x24\x05\x30\x0a\xd3\xe9\x71\x0d\x06\x28\xf9\xaa\x47\x55\x7f\x20\xfd\x2e\xfc\x83\x0f\xdf\xb7\x4f\xfc\x0c\x8d\xf1\xdb\x1a\x69\x1c\x80\x99\xe1\x38\x65\xf0\x7b\x16\xee\xd9\xa4\x9e\x62\x30\x8b\x0d\x23\x70\xad\x11\xa7\xe0\x42\xd9\x1d\x56\xbd\x01\xc6\x7f\x16\x03\xa0\x34\xd4\x5c\xc1\xa6\x31\xc0\xff\x09\x13\x86\x5c\x4d\x19\xc1\x40\x4d\x44\x92\xc1\x05\xe0\x33\x8a\x51\x22\xd3\xab\x4e\x55\xc3\x3f\xe8\x15\x47\xc4\x91\xc2\xcb\x9e\xdb\xf7\x1c\xfc\x0f\xfd\x05\x4e\x8a\x25\xe0\xe4\xf5\x9b\xaf\xc7\xed\x3d\xa7\xaf\xdf\x2c\xdd\x05\xdd\xd6\xfb\x39\x7e\x40\xaa\xc5\x24\x33\x58\x76\x86\x75\x9a\x1f\x18\x09\xcb\x8e\x49\x60\x43\xa9\x97\xe4\xde\x06\xcd\x57\xa0\x05\xd3\x3d\x44\x94\x4a\x14\x30\x99\xf7\xea\x4b\xa8\xbb\xb3\xef\x9d\x4d\xbd\x2a\xf5\xbd\x6c\xa5\xfe\x93\xc1\xb9\xd3\x2e\x92\x7e\x3e\x46\xfe\x39\x49\xca\x3f\x27\x2b\x94\xdf\x3f\xad\x77\x49\x18\x30\x65\x52\x5f\x5d\x09\xf9\xb9\x82\x53\x36\x5e\x1b\x96\x7a\xe0\xe4\xd7\x27\xc8\xaf\x63\x25\xe2\x78\x72\x43\x06\x6f\x02\xbd\x8e\x4b\xf5\x08\xbd\xdf\xc0\x71\xc6\x49\xe3\x54\xc8\xe3\x50\x0e\xf9\x75\x71\xbc\x4e\x23\xbd\x5f\x7e\x7d\x02\x92\x45\xba\x0f\x1b\xaf\x39\x26\xbd\xde\xae\x8c\xbf\x46\x85\x13\x99\xe3\xe1\xd9\x0a\x2e\x90\x64\xc6\xb9\xac\xcc\x12\x0e\xe4\x29\x15\x36\xfa\x56\xec\x21\xf8\x5c\xe1\x7b\x22\xd6\xec\xba\xa0\x7a\x88\xfb\x54\xf8\x3a\x5b\x31\x79\x1c\x40\xe7\xc6\x41\x78\x40\xdf\xab\xb0\xa2\xb7\x3e\x85\x46\x01\x46\x69\x94\x01\x38\x2a\xb6\x82\x17\xe4\xb9\x84\x72\x63\xa0\x3e\xf2\x8f\x55\x3d\xdd\x5b\xb1\xfb\xe5\xb9\xf8\xb3\x73\xe9\xd7\xfb\xb4\x15\xbc\x21\xcf\x25\x98\x1b\xa7\x2f\xc6\xec\x56\xec\x4b\x69\x1c\xd4\xf4\x92\x37\x8e\x36\x94\x19\x47\x5f\x4a\xec\x83\xef\x31\x3d\x42\xe0\xa0\x44\x26\x05\x52\x8d\xa5\x71\xc9\x63\xc1\x67\xbe\x14\x7b\x49\x7a\xe6\xdb\x01\x09\xc8\xec\x38\x5c\x76\x9c\x32\xe2\x18\x88\xcb\xe3\x14\xf6\x1d\xa7\x51\xb3\x4a\x35\xce\x2b\xbd\x9f\x31\xa8\x37\x68\x0e\xf6\x59\x76\x9c\x78\x76\x9c\x72\xe2\x20\x48\xfc\xce\x38\xe5\x9a\x2b\xd5\xf3\xe9\xfd\x4c\x92\xf1\x53\xec\x33\xcc\x9b\x36\x10\xb5\x69\xa3\xb9\xa9\x16\x07\x6e\xd4\x78\x6f\x0f\x34\xb9\x31\x2b\xfc\x6d\x6b\x9e\xdc\x7c\xf6\x73\x2a\x88\xfb\x33\x9f\x53\xd6\xff\x73\xd4\xf3\x7d\x06\x7d\x0e\x36\x02\x5b\xfd\xff\xf5\x39\x3c\x7c\x96\x63\xd0\x1d\x2d\xee\xc9\xed\x45\x69\xbd\xa3\xca\x7a\x37\x4b\xeb\x4d\x12\x78\x44\xfd\xb9\x68\x3f\x7e\x27\xad\xf7\x48\xe5\x73\x8f\xc8\xeb\x8d\x7d\x8a\xd6\x5b\x19\xa7\x3a\x3b\x4e\x25\x51\x23\x61\xca\x10\x78\x30\xc3\xe5\x24\x8d\xf1\x75\x6e\x0c\x7c\x0f\x76\xb8\xf7\x80\xd4\x1f\xf8\x4f\x40\x62\xd6\xb4\x01\xdf\x51\x08\x0a\xd3\x26\xb6\xa9\x10\xce\x79\x95\xd4\xfb\x24\xf1\x39\x49\xbd\x87\x5b\xe4\x5e\x42\x42\x90\xf7\x67\x51\x6e\x5f\x49\xd8\xfb\x52\xbf\xe1\xbd\x4a\x7f\xe2\x16\x69\x5f\x11\x23\x94\x7d\x25\xd7\xb8\x21\x1c\x3b\xa9\x96\x92\xa1\x31\xbb\xcb\x15\xd1\xf8\x31\x7f\x61\x51\x98\xe3\x39\xe4\x45\x79\x85\x00\xef\x97\x2e\xd8\x79\x0f\xef\x89\x93\x71\x1b\x2a\x71\x23\x8d\xa8\x24\x94\xcc\xfa\x23\xd9\x22\x37\xb5\x6e\xcc\x06\xe2\x19\x02\x7c\x1e\xb9\xec\xd9\xfb\x4d\x68\x0b\x33\x18\x6f\x52\xef\x27\xba\xeb\x1c\x8d\x6e\x31\x7f\xfe\x9f\xda\xc9\x20\x57\xdc\xe6\x3c\xe3\x38\xc3\xcb\x05\x6e\xdc\x65\x8e\xcb\x43\x99\x0b\x4f\xdc\x88\xee\x32\x87\x89\x7f\x7d\x20\x53\xdb\x76\x45\xf7\x1f\x50\x71\xdb\x1f\xba\x9f\x96\xee\x3a\xd1\x9d\x92\x84\xc7\x07\x6d\x63\x1c\x4b\x61\x4b\xd3\x35\x09\x6f\xdc\x50\x42\x96\xc6\x70\xbc\xb4\x94\xe1\xac\x56\xc6\xc0\x54\x55\x73\x71\x0c\xa5\xc1\x30\xcc\xa5\x75\x85\x5b\x05\x97\xc7\x52\x8e\xca\xae\x4b\x50\xb5\x4b\x11\x2a\xbb\x56\x15\x58\x0c\x50\xe1\x92\xad\xa6\x50\xd8\xa7\x50\x7a\x88\x0f\xd5\xd6\xd4\xaa\x4b\xae\x09\x0d\x32\xfa\x72\x89\x41\xa6\x48\x19\x06\xfa\xca\xb5\xa8\x14\xe5\x7f\x0d\x5c\x7a\x27\x3f\x74\x57\xd3\xda\x6b\xb7\x7c\xbb\xeb\xae\x73\x87\x2c\xba\xcb\x98\x5d\x0d\x1f\xdf\x31\xfb\xf1\x1a\x6e\x50\x34\xba\x7a\xd4\xf8\xe9\x6e\xf1\xe7\xe6\xe1\x95\x91\x8e\x92\x65\x43\x46\x8f\xed\x6e\xea\x2e\xbb\xa1\xb9\x55\x78\xf8\xd6\x87\x40\xe5\x7d\x45\xe7\x1a\xd3\xfc\xcc\xf5\x5d\x05\x81\x9e\xcb\x63\x65\xf5\x35\xf8\xa0\xa5\x1b\x46\xd7\xe3\xa3\x5d\xdb\x7e\x1a\x00\x0f\x51\xc6\x60\x85\x3a\x26\x9a\xb3\x27\x68\xad\x3e\x55\x61\x20\x6e\xc5\x0e\xc9\xfa\xac\x2c\xa7\x5b\xa5\x5a\x2e\x69\x9c\x52\x65\x9c\x43\xf2\x38\xbe\xdc\xbe\x83\xe1\x1c\x59\xa2\x75\x2b\x18\x56\x68\x9c\xff\x80\x75\xe8\x3d\x3c\x9e\x7d\xcf\x58\x71\xa2\x54\x03\x21\xe9\x57\xd4\xab\x09\x1e\x90\x75\xaa\x38\x11\xc6\x31\x2f\xc8\x3a\x15\xbd\x8e\x3d\x93\x7b\x7f\x06\x43\x04\x9e\x91\xed\xa8\x87\xd4\xaa\xfc\x9e\xa4\x73\x55\x7a\x19\x8d\x41\x39\xd0\xbb\x30\x99\xcf\x51\xd6\xcf\xd2\x58\x58\xe9\xe3\x58\x05\xd4\x00\x1c\xd7\x54\x81\x34\x81\xc3\x21\x7f\x65\x59\xf9\xab\xd5\x2a\x7d\x3d\x46\xd3\x4d\x12\x19\x1f\x94\x59\x8a\xc5\x91\xcc\x60\xa3\x22\xcf\x8d\xb2\xcc\x91\xdc\xda\x5d\x07\xe3\xaf\x83\x68\xed\xf0\xc9\xb2\x3d\x59\x27\x69\xf0\xb0\xbc\x72\x12\x96\x19\x61\x56\xb0\xcc\xa6\xa7\xcb\x1c\xf0\xa0\x71\x9c\xcd\x66\x41\x2d\x85\xb4\xc5\xe2\xf1\xba\x9d\x0e\xe7\x8e\x99\x0e\xd7\x75\x82\xc3\x61\xce\x41\x98\x61\xc4\x24\x01\xf3\xa8\x3a\x16\x9c\xb9\x1b\xcc\x4c\x15\x8b\x42\x5c\x3e\x10\x6e\x19\x22\x78\x25\xe0\x6b\x31\x09\xb7\xcc\x69\x77\xa9\x70\xcb\xf0\x67\x35\xe2\x8f\x12\x70\x19\xb0\x23\xe0\xb2\x75\x74\x0e\xb8\x4c\x3b\x3d\x24\x7e\x00\x62\xa1\xfd\xfb\x33\x3e\x89\x64\xdf\x13\x92\xbd\x1e\x2a\xdb\x71\xf4\xba\xee\x13\xd5\xeb\x92\xff\xa1\xf8\x1d\xae\x0c\xbe\x2e\x7a\x9d\x24\x55\x98\x9c\x1f\x66\xf6\xa0\x82\x93\x0c\x57\x29\x9e\xbf\x07\xdf\x92\x7a\x4b\xc7\x2a\x58\x13\xdf\xc8\xcf\xb7\x22\xab\xb3\x90\xdf\xa2\x7d\x17\xc6\x4e\x49\x6c\x4b\xba\x49\x5f\xa0\xd3\x15\x16\x12\x38\xc3\xb2\x86\x84\xd1\x18\x8d\xe2\x3e\x97\xdb\xed\xf7\xe1\xbe\xe2\x92\x10\xd7\x21\x84\x58\x7d\x41\xa7\xe0\x75\x77\x08\xb4\x1e\x18\x09\xbd\x57\xef\xc5\x28\xc6\xa8\x23\x28\xa2\x43\x30\x53\x44\x61\x9f\x5b\x9f\x7e\xd0\x95\x79\x1c\xf1\xb9\x58\xbe\x2e\xaf\x3a\x34\x92\xc1\xab\x92\x4b\x41\xfb\xd4\x4b\x65\x0b\x46\x25\xec\x4a\x3a\x7b\x7b\x3c\x0d\x9c\x9a\x26\x63\x56\xfe\xd1\x34\x36\xdd\xbe\x82\xed\x58\x63\x06\x57\xae\xf1\x7c\xf3\xd9\x87\x2f\x69\x87\x8a\xce\x39\x07\xcc\x99\x8b\x64\x91\x01\xdf\x49\x15\xb1\x13\x47\x96\x0e\x19\xf1\x87\x35\xb8\xdf\x35\xb6\x67\xcd\xae\xdb\xd6\xad\x8f\x85\xc0\x2c\x84\x60\x29\xd5\xf5\xf7\xde\x23\x8e\xa2\x04\xa8\xcf\x6d\x98\x0f\x9b\x91\xb6\xd9\x78\x8e\xd0\xe9\x50\x14\xe0\xb1\x10\x16\x7f\xc0\xc6\x23\x9d\xae\x17\x6c\x2c\xa7\xd3\xb1\x46\xf6\x38\x60\xd2\xb4\x60\x24\x35\x64\x87\xa0\x21\x00\x5c\x12\xe0\xc5\xf2\x8b\x54\x52\x6a\x86\xfc\x54\x86\x57\x48\xc1\x37\xcf\xb6\x12\x62\x94\x84\x27\x54\x83\xa1\xe8\x00\xac\x15\xcb\xcd\x0f\x00\xa8\xb4\xc1\xc9\xc8\xf4\xb7\x96\xdf\x72\xc7\x49\x51\x10\x3f\x03\xcf\xa4\xaf\x19\xba\xef\x6e\xc0\x5d\xdf\x26\x8e\x6a\xf6\x68\x2a\xdc\xcd\x2f\x75\x9d\x7f\xe4\xae\x0f\xc4\x35\xe2\x9f\x3a\xc8\x2b\xc7\xa4\xcf\xad\x1b\x0d\x38\x30\xe6\xbe\x99\x4b\x07\xc2\xcc\x1a\x01\x6a\xe5\xfd\xe2\xca\x9d\x75\x84\x2b\x45\xab\xf0\xb1\x46\x20\x34\x06\xf4\x9e\x40\x4e\x67\xc9\x36\xf8\x3d\xd9\x06\x43\xad\x20\x71\x25\x4a\xfb\xef\x59\x7c\x2c\x36\x24\x9d\x20\x1b\x92\xa0\x2c\x09\x92\x88\x3b\x51\xf9\x3e\x90\x04\x54\xb2\x84\xf3\xc6\x08\xbc\x81\x03\x19\x3a\x45\xc4\xf9\x29\xa1\x60\x35\x48\x10\x87\x39\x2c\x74\x92\xd0\x16\x65\x7d\x80\x75\x20\x00\xf6\x64\xf9\x71\x4a\xd2\x76\x3c\x58\x4c\x12\x71\x6b\x9c\x24\xb6\x16\x96\x19\x6c\x31\xbc\x21\x08\x8e\x03\x6f\x86\xf7\x67\x76\xb5\xd2\x8e\xcd\xfc\xa3\x2a\x67\xdb\x3f\xcc\xd8\x76\x6c\x1d\xf4\xad\x10\xfe\x08\x9e\xa0\xe2\xf8\x71\x7c\xf2\xc3\x89\xa2\x90\x8a\xd3\x4f\xb1\xf3\xd7\x65\xec\x3c\xfc\xfc\x97\xe4\xfe\x73\x22\x6d\x8d\x13\x1f\xa6\x47\x14\xe4\xe1\x04\xc8\xbc\x62\xd2\xf8\xb7\xca\xef\xc7\x75\x72\xdf\x34\x51\x40\xc5\x89\xef\x0a\x92\xda\xfc\xfe\x76\x89\x37\x42\x1a\xff\x09\xe5\x4c\x7e\xad\x8c\x1f\x83\xe3\x7f\x10\x2b\xe8\xf3\xfe\x3e\x9c\x9c\xf8\x5b\xf8\x4e\x85\xbf\xd2\x9f\xe7\xf3\xa8\x38\x94\xf0\xb7\xc0\xcf\x8a\x5f\x94\xb4\xe6\x73\x5c\x7e\x97\x1d\xe7\x24\xd1\x2c\xfb\x38\xc1\xfc\x78\xe0\x0d\x6a\x7f\x76\x9c\x93\xf8\x75\xb2\xbe\x28\xc9\xb3\x59\x6a\x8e\x44\x38\x9f\x9f\xa5\xf9\xe0\x20\x91\x9d\x0f\xc2\x46\xbe\x3f\xc7\x93\x03\xdf\x63\x54\xe6\x53\x92\x9d\x8f\x3c\xce\x77\xd9\x71\x4e\x12\xf3\xe4\xfd\x58\x98\x9b\x0f\x1a\xe7\x02\x69\x3e\x4d\xca\x7c\xe6\xf4\xb3\xa1\x7d\xf8\x11\xa1\xec\xf7\x29\xf3\xe1\xb3\xfc\x9e\x2b\xe0\x61\xbe\x31\xc7\x93\x83\xbf\x85\x9d\x91\xe6\x83\x03\x36\x3b\x1f\x34\xce\x3c\x69\x3e\xc5\xca\x67\x8d\xef\x77\x3e\x50\x9c\xb3\x4f\x9a\x8f\x3c\xce\x49\xb0\x4d\x3e\x1f\x8e\x5c\x6c\xd1\x87\xbf\x0f\xca\xfe\xaa\xf2\xbc\x0a\xb3\xeb\x93\xcf\xe9\x82\xe6\xfc\x81\xb2\x3e\xf1\xcc\x7c\x94\x71\xbe\xcb\x8e\x73\x92\xd8\x2c\x3f\xaf\x64\x7e\xcc\xf4\x84\x34\x9f\x89\xca\x9c\x37\xc9\xeb\x53\x90\x5b\x9f\x3e\xf8\x44\x70\x3e\x0f\x28\xf3\x29\xca\xae\xcf\x0f\x50\xf6\xe2\x1c\x26\x11\x9c\xcf\x06\x65\x7d\x7c\xd9\xf5\x91\xc7\xf9\x2e\x3b\xce\x49\x62\xb2\x3c\x9f\xe2\x3c\xfd\x41\x94\x49\xf3\x99\xa2\xcc\xc7\xd5\x57\x7f\xf4\xe5\x9c\xc3\xdf\x22\x8a\x94\xe7\x55\x90\x5d\x9f\x3e\xbc\x22\x70\xce\x9c\x32\x9f\x58\x76\x7d\xe4\x71\xbe\xcb\x8e\x73\x92\x90\x63\x7a\x50\xd4\x37\x16\xdc\x9f\x1d\xe7\x24\xfe\x94\x3c\x9f\x44\x6e\x3e\xb1\x9e\x33\x39\x9c\x1f\xe8\x23\x9d\xc2\xe7\xca\x98\x3a\x3d\x67\x72\x58\x3d\xe8\x75\xc4\x61\x80\x70\x70\x7a\xce\xa8\xf1\x73\x74\x27\x30\xa9\x7e\x05\x63\xe0\xfb\x97\x93\x97\xda\x24\xac\x1b\x46\xa3\x3b\x71\x83\x7c\xf7\x70\x3f\xf4\x77\x2e\x81\x36\x24\x8c\x4d\x4d\x3b\x02\x3c\x8f\xd9\x3d\xa4\xd5\x1a\x89\x1a\x3d\x9e\x48\xc8\x8e\x59\x00\x26\xa7\x57\x01\xf0\x40\xc7\xa5\x43\xf0\x78\x8d\x16\x8b\xb6\x43\xb0\x0c\xd0\x23\x96\xc9\x22\xab\xac\x26\xba\x25\x8f\x62\xaa\x1a\xa4\xa0\xd4\xc1\x27\xdf\xa0\x52\xd2\x8f\x12\x9a\xb7\x1d\x50\x89\x0e\xbb\xe8\xe2\x2d\xe7\x4d\x98\x56\x73\xfa\x71\x60\xfc\xea\xd9\xfd\x1b\x36\x7f\x2d\xda\xc4\x25\x36\x70\x10\x5c\x78\xcf\x5e\x70\x78\x63\x11\xc0\x9e\x59\xbd\x68\xe8\xf3\xa0\xa2\x6a\xd7\xbe\xdb\xc5\x9e\xe1\xb1\x3b\x37\xbd\x25\x7e\x7b\x4f\x7c\xd1\x10\x60\xfd\xe5\xd5\xf2\x02\x59\x9e\x37\xc5\x51\x44\x18\xc6\x00\x21\x94\xcf\xf7\x73\x1c\x8b\xb9\x48\x86\x09\x47\x8c\x2e\x57\x38\xc8\x22\x79\x5a\xa1\x2c\x16\x97\xcb\xdd\x22\xb8\x24\x59\x90\xfb\xff\xff\x29\x4b\x03\x50\x70\xbb\x14\x59\x1c\x19\x44\x01\x4a\x2a\xb4\x4a\x68\x9e\xb0\x1d\xdc\x3b\xb2\x6e\xd8\xf0\xa6\x51\xa5\x37\xef\x00\x8d\xd7\xdd\xb0\xec\x3c\x71\xab\xb8\x82\x3e\xfc\xfe\xc2\x79\x53\x4e\x2f\x2c\x7a\xf4\xce\x31\xcd\xf1\xdb\x80\x26\xf0\xdd\x15\xcf\x35\x79\x2e\xef\xf8\xf7\xaf\xe1\x49\xc1\x95\xfb\xba\x6f\xae\xe1\x07\xc0\x07\xdf\x0a\x7e\x91\xf7\x4c\x20\xb7\x67\x10\x66\xf5\x70\x2d\x7a\xbe\xe3\x94\xf7\x98\xc0\x2d\xd2\x7b\xf0\xac\xcf\xf4\x9d\x38\x9e\xea\xa0\xc6\xc0\x35\xe8\x48\x57\x38\x0c\x76\xbb\xd1\x68\x65\x70\x8a\x0a\x78\x18\x4f\x38\x62\x70\x38\x74\x4e\xdd\x5c\xc1\x49\xb2\xd6\x0e\x81\x25\x8c\x8c\x85\x81\xcf\xd3\x16\x90\x9d\x23\x8f\xfa\xa2\xd5\xd9\x30\x10\xd8\x80\xaa\x03\x1e\xba\x42\x72\xd6\x7c\x00\x94\x44\xa9\x20\x00\xdf\x66\x3e\xfa\x09\x3d\xa1\x71\xd1\x93\xc7\xe4\x4a\xd5\x57\x90\xa3\x60\xdf\x7f\x74\xde\xc5\x3b\xcc\xc4\xc7\xf7\x9a\xc5\xf1\xd0\xed\xf9\x71\x52\x7a\xc8\xf8\x85\xe7\x4c\x99\x62\xba\x0b\xda\x4a\xb7\x5c\x1c\x59\xca\x9c\x35\xcb\xbe\x0e\x81\x39\xe1\x3e\xad\xa5\xae\xc1\x62\x30\xb6\x1b\x86\x5d\x92\x1e\x19\x0a\x94\x10\xc5\x61\x23\xc3\xb0\xc5\xc5\xe1\x70\xac\x8a\xa2\x62\xf0\xa4\xc5\x62\xe9\xb8\xcb\xd5\x90\x8e\x86\x5b\x84\x28\xe6\x2b\x47\x70\x6f\xc5\x2c\x5b\xc8\x15\xb6\x0b\x1c\x67\xf1\xe8\xea\x5b\x05\x9d\xd7\x58\x8b\xd5\xb6\x23\x5a\xa6\x32\x15\x74\x46\xdf\xb8\x0f\xa8\x62\xbd\x6c\x45\xb2\xcc\xc2\x50\x51\x4e\xd5\x66\xf2\xd4\xf1\x84\x46\x1b\xa9\xa9\xad\xaa\x61\xd5\x21\xa0\xbc\x12\xf9\xed\xb6\x88\x59\x47\xab\x50\xce\xd9\x23\x91\xae\xb5\xfb\x2e\x3f\xff\x0f\xae\xba\x68\xd7\xe0\xb5\x44\x2a\xd7\x84\x4b\x18\x4b\xf7\x99\xc0\x43\x3d\x1a\x75\xf7\x2d\xbe\xb9\xbb\x0c\x0c\x8a\x05\x4a\xcb\xf1\x19\xad\x0b\x2f\x6e\xa9\xaf\x1b\xbb\x6b\x31\x1d\x04\x7c\xb6\x25\xd7\x3f\x07\x30\xce\xe1\x67\xdf\xce\x75\xe3\xf6\x38\x1b\x4d\xc6\xba\x21\xc5\x92\xaf\xf8\x0b\xd4\xd7\x76\xaa\x0b\x8b\x40\xfb\x71\x41\x3a\x12\xe1\x71\x2b\x65\x4f\xe8\x74\x21\x1c\x2f\x29\xf5\xd8\xed\x49\x8b\xa5\x84\x77\x76\x08\x94\xd5\xea\x2f\xf4\x17\x76\x08\x3c\xc2\x44\x74\xe9\x2d\x4d\xbc\x9f\xf7\x63\xd0\xd9\xee\x10\x8c\x2c\x16\x81\x3b\x24\xad\x37\x41\x7b\x57\x96\xcc\xcf\x06\xc8\xad\x95\xaa\x5b\x3c\x15\x5e\xa0\xb4\x55\xc8\x2c\xfe\x46\x08\x55\x4e\x20\x0e\xbe\xea\xaa\x68\x2c\x5b\xb3\x07\xcf\x0f\x40\x7f\x23\xa0\x0e\x62\x1c\x78\xe5\xf5\xc3\xb7\x1e\x14\x6f\x11\x1f\x10\xff\x57\xfc\xd7\x77\x6f\x6d\xda\x09\x9d\xc5\x20\xb3\xf5\xa2\xb5\xe7\xef\xbd\xe7\x11\xb1\xe7\xe9\x17\xc5\x4f\xc4\x4b\xa9\x2e\xb7\xf8\xcb\xf5\xaf\x85\x98\x9b\x37\xbc\xf7\xf9\xfd\x7f\xbc\xeb\x6f\x0e\x7e\xc7\x82\x9b\xff\x68\x5d\xc8\x6f\x5a\xb9\x60\xf1\x03\xfb\xef\x0d\x9e\x9d\xf0\xe0\xe1\xf7\xc4\xa3\x5f\xa2\xbc\xf2\x84\xde\xd3\xa4\x9f\xda\x01\x75\x5d\x29\x36\x29\x5d\xc8\xb8\x7c\xfa\x20\x66\x33\x99\x0a\x35\x11\x0c\xe3\x7d\x1a\x5f\x59\x79\x50\xaf\xb7\xc7\xed\xf1\x56\xc1\x6e\x27\xdc\x34\x34\x3b\xad\x02\x91\xa9\xc5\x92\x2b\xf6\xb0\xba\x81\x8e\x82\x7c\x1a\xec\x4a\x95\xb3\x24\x5a\x4d\x2d\x2f\x37\x56\x40\xc1\x6a\x25\x56\x4b\x28\xbd\x54\x5c\x2b\xa7\x44\x6c\xc4\xcb\xe2\xbf\xbf\x7f\xe4\x4f\x07\xee\x9a\x24\x9c\x3c\xe4\xdb\x3a\xab\x75\x7e\x5d\xf5\x65\x37\x5e\x7b\xf9\xcc\x4e\xf1\x8b\xf2\x9a\xb9\x17\x17\x57\x77\x5e\x81\x3b\x44\xf1\xed\x47\x0f\xbe\x08\xb4\xd5\xbe\xf5\x53\x76\x3c\x69\x1e\xd1\x79\x72\xd7\xe1\x4d\xe7\xa7\x46\x18\xaf\x5c\xbe\xf6\xde\x44\xe8\x8e\xe8\xec\xa9\xe2\xb1\xbf\x4f\x9f\x0c\xd2\xd2\xd9\x3f\x0b\xcf\x09\xba\xeb\x77\x63\xe9\x74\xd0\x61\xb1\x60\x3a\x9d\xc7\xab\x31\xb8\x5c\x1e\xb7\xc1\x65\xe8\x10\x5c\x36\xab\x57\x0f\x23\xc5\x4e\x01\x1e\xcf\xec\xad\x7e\x43\xdf\xbb\x63\x75\x67\x7f\x48\x0b\x42\xf2\x79\x4e\xc8\xea\x2f\x54\x4b\x34\xe7\x6e\xef\xcf\xbd\x02\x2e\x7e\xf2\xe9\x87\xfe\x1c\x6f\x99\x74\xf1\xca\x9e\xad\x76\xf2\xa4\x7c\x71\x7f\xf6\xa6\x99\x0b\x3a\x0f\x4d\x9f\x98\x5c\x39\x6c\x4c\xf3\x6a\x34\xb7\x17\xa1\x6e\x46\x77\xf7\x2e\x54\x43\x46\x70\x9c\xde\x6a\xf5\xb0\xb4\x56\xeb\x76\x79\x6d\x06\xc6\xd0\x22\xd0\x34\x43\xeb\x58\x2d\xab\x74\x18\x29\xf7\xf3\x4a\xdb\x57\xf6\x76\x38\xa5\x34\x54\xca\x53\x51\x97\x19\x48\x0a\x19\xcc\x16\x66\xac\xe9\x14\xb7\xea\x70\x32\x77\x15\xdf\x73\x6e\x07\x18\xb6\xf7\x71\xf1\x8a\xfa\xd5\xc3\x46\x8e\xab\x24\x82\xf2\x4d\xfc\xb9\x7f\x3d\x32\xf5\xee\x45\x03\xe5\xa3\xf7\x80\x95\xb2\xff\xe0\xed\xeb\x7f\xe6\xf2\xd1\x7b\xb0\xa3\xb2\x3f\x53\xa8\xf2\x3f\xc5\x36\xc4\xfb\xc1\x28\xbc\x1f\x58\x37\xd8\xad\xf0\x7e\xb4\xe5\x78\x3f\xd0\xeb\xd8\xf3\x39\x7f\x4c\xca\x3d\x56\x2a\xb9\xc7\x3d\x99\xdc\x63\xa9\x3a\xf7\x88\x7c\xa9\x9f\xa4\xbc\xe1\x44\x25\xf7\x78\x50\xc9\x3d\xfe\x8f\x94\xeb\x95\xc7\xa9\xce\x8e\x93\x22\xee\xc9\xf8\xd8\x6a\xbf\x8e\xd4\x6a\x22\x99\x31\xf0\xbd\xd8\x41\x25\xf7\xf8\x1f\x60\xc1\xe2\x8f\xe1\xbd\x1e\xf0\x27\x0f\xf0\xa0\x93\x4f\x07\xc3\x4d\x98\x07\xbc\x01\xff\x99\x36\x59\x9b\x3c\x98\x15\xa1\x84\xae\x5a\x35\x50\xbe\x7c\x0f\xf8\x97\xbc\x56\x89\xbe\xbe\x5f\x2e\x5f\xbe\x47\xe2\x25\x82\xef\x89\xf6\xf1\x45\x55\x73\xae\x24\x36\x0f\x34\x67\xe2\x3b\x4d\x47\x76\xce\x7b\x90\xdc\x56\x39\xe7\x3a\x56\xe2\x84\xfa\x2e\x0a\x76\x44\xc1\xb3\x51\xf0\x60\x14\x44\x31\x2b\xe2\xf3\xca\xc3\xde\x9a\x9f\xc5\xde\xda\x0e\x76\xc8\xf6\xd4\x99\xcb\x41\xc8\x78\x5b\x8e\x2c\xde\xd6\xf6\xe5\x92\x07\x16\x57\x72\x39\xbd\xf3\xc4\x51\x78\x0b\xb4\x3b\x1c\xb4\xa6\x2d\xe9\x04\xaf\xd7\x13\x6e\x92\x24\x68\xbb\x1d\x5a\x25\x22\x1c\xb1\x79\x4c\x81\x56\xc1\xe4\xa5\x5d\x1a\x57\xbb\x60\xd7\xa8\x80\xa5\xcb\x52\x39\xe3\xd2\xdf\x9c\xc8\xdd\x48\xa0\x9f\x1d\xa9\xa5\x72\x66\x02\xb8\x50\x93\x9c\x78\x36\x18\x54\x1b\x0b\x2d\xd8\xdf\x5d\x08\x2a\xa1\x31\x40\x2d\xa3\xbf\x8d\x50\x59\x04\x5f\xc1\xcd\x39\x9d\x8f\x15\x41\x5d\x70\x27\xf4\x85\x0a\xa0\xcd\x5c\x95\x1e\x6c\xa2\x34\x1a\x9d\xb6\xd0\xe5\xb2\x16\xdb\xed\xd6\x40\x54\xda\xe8\xd6\xaa\xea\xb0\xc7\x5b\xd1\x2a\x78\xbd\x81\x24\x97\x6c\x17\xa2\x1c\x65\x32\xe1\x16\xbc\x1d\xba\x45\x12\xd2\x14\x8d\xce\xa2\x3a\x45\xd0\x57\xae\x7e\x76\x52\x2e\x13\x04\xaa\x76\xd9\x2c\xea\x70\x7f\x71\xd9\x1a\x95\x5d\xc4\xcf\xcd\xcc\x07\x21\x9e\x7f\x81\x6b\x65\x38\x5f\xfa\x0b\x39\x60\x55\xe4\xc7\xdf\x9e\x9b\x03\x24\x5e\xda\x59\x75\x79\xcf\xd5\x79\x8b\x81\xdf\x7f\xc1\xb9\xf1\x99\x05\xc1\x7b\x6f\x54\x30\x0f\x11\x06\xd5\xc2\x74\xca\xcd\xf3\xb4\x8f\x65\x69\x42\xa7\xd3\xeb\x6d\x36\x8b\x89\xa6\xa3\x31\xc2\x67\xf7\xb5\x09\x3a\xbb\x5d\x43\xeb\x6d\xb4\xad\x55\x30\xa7\xe1\xeb\x1a\xf8\xf8\xdb\xb2\x0d\x4b\xb9\x4a\xe7\xfc\xe6\xc7\x54\xaa\xef\x23\xa6\x32\x72\xe6\x0a\x9d\xe5\x05\xa8\xad\x8a\x27\xb4\x92\x75\x00\x95\x8b\x56\x31\xa9\xc4\xec\x91\xab\x17\x67\xef\x82\xa7\x51\x2b\x36\xde\x4a\xd7\xd5\x83\x91\xbc\xc7\xde\x5a\x5f\xdd\xfa\xd4\x74\x7c\xa8\x5c\xe6\xec\x9d\x32\xb6\x63\xdd\x63\xbe\x18\x30\x19\x17\x06\x31\x80\x72\x8d\xe0\x27\xa8\x53\xad\x58\xb1\x8c\x59\x46\x5b\x2c\x36\x36\x97\x53\x24\x90\x43\x57\x99\x4f\x17\x31\x60\xf6\x70\x80\xa4\x61\xdf\x44\xa1\xe4\x87\xf5\x7e\x45\xed\x85\xe7\x01\xf5\xaf\xd5\x43\x4f\x62\x58\x39\x51\x60\x2f\x2c\x64\xf4\x35\xd5\x44\x30\x68\x36\x33\x61\x86\x70\x11\xae\xa1\xc3\x7c\xd0\x74\xfa\xb8\x02\xbb\x3d\xc6\xc5\xa0\xef\xc5\xd0\x66\xa8\xdf\x31\x6d\x5d\xab\xa0\x65\xaa\x83\xc1\x14\x96\x6a\x97\x17\x54\xed\x75\xf5\xcf\x43\x29\x65\xe4\x19\xba\x14\xab\xba\x27\x8c\xaf\x4d\xc9\xb3\x4f\x69\x94\x0d\x26\xb5\xb6\xd4\x6a\xf2\x81\x99\x28\xb9\xc9\x5e\x71\xc2\xd8\x55\xdb\x2e\xfb\xe2\xba\x59\x83\x0d\x40\x2f\xf9\x59\x13\x70\x1b\xb3\x7e\xcb\x86\x6b\xb7\xfd\xcf\xf6\x2f\x1e\x65\xd6\xe3\x3f\x8f\xa8\x89\x8f\x4b\xce\x75\x8c\xf4\x8f\xbc\x60\xcc\xb9\x2d\xb5\x65\xa3\x16\xcc\xb5\x8f\xf4\x8e\x5c\x33\xca\x7e\xf8\xf6\x63\xa0\xfc\x90\xbb\x7a\x14\xf2\xb4\xc4\x89\xd3\x3b\xf7\x3e\xb4\xe7\x31\xf1\xf5\x7b\xc6\x08\xb7\xe3\x1d\x4b\x36\xb6\xd6\xf7\xbc\xef\xf0\x6c\xff\xb1\x6b\xe9\x86\xed\xc8\x03\xbb\xfa\x0c\xe2\x44\x86\xbe\xf8\x5d\x52\x3c\x52\x8a\x0d\xc6\xd6\xa4\x87\x85\xfd\x05\xce\xc2\x42\x07\x0d\xd7\x0b\xc7\x6d\x36\x47\x99\x5e\xef\xf0\x13\x43\xea\x0b\x9c\xce\x98\x07\xae\x94\x87\x73\xd8\x5a\x04\x87\xc7\x3c\x08\x3e\x42\xae\x9a\x20\x2a\x35\x95\xed\x82\x86\xc1\x8a\x73\x30\x29\x03\xaf\x99\x0a\x2f\x45\xbd\x5c\x08\x9d\x4e\x05\x4d\xa5\x74\xfe\xb0\xaa\x2b\x0b\x42\x71\x53\x11\x26\x01\x1e\x53\xd6\x0e\x79\x28\xb8\xf7\xa5\x0f\xf8\xda\x0d\x63\xd7\x5e\x7b\xe9\xbf\x77\x8e\x97\xbb\x80\xc4\xa6\x66\x96\x1f\x72\x7d\xd3\xba\xab\x2f\xfd\x7a\xe1\xf0\x8a\x80\x50\xd1\x35\xa4\x61\xe5\x2d\xc4\x85\x43\x2b\x23\x63\x4b\xe6\x95\x0f\x5e\x7e\x13\xf1\x42\xd1\x9a\xd1\xd3\x1e\xbe\xf5\x21\xf1\xef\x87\xe4\x5e\x20\x70\xf9\xda\x09\x2d\x33\x1e\xb9\xe5\x11\x50\x72\xa8\x67\xef\xd2\x0d\x4d\x23\xf0\x41\x94\x4b\x7c\xd3\xb5\x64\x63\x73\x7d\xcf\x3b\xe5\xa0\x0c\x86\x35\xbd\x37\xf7\xee\xa6\x9a\xa8\x35\x18\x0f\xf7\xac\x1f\xae\xd8\xce\xf4\x04\x97\xdf\xe9\xc5\x79\x9e\xf2\x7a\x75\x16\x23\x6d\x30\xe8\x3d\xc1\x80\x83\xb4\x3b\xed\xb4\xc9\x6c\x76\xea\x68\x1d\x1d\x8e\xd0\x76\x9b\xbd\x43\xb0\xd9\x38\xbf\xcb\xdf\x29\x84\x8c\x16\x4f\x90\xd4\xbb\x5c\xb8\xd3\xa4\x27\x79\xf8\x8b\x1a\x5d\x87\xa0\xb1\x91\x08\x3f\xee\xb5\xec\xd2\xbd\x88\xdc\x39\xc4\xbc\xdb\xb7\x48\x36\xd3\xb7\x80\x7e\x96\x6d\x2f\x4f\x65\x0a\x1b\x63\xda\x88\x36\x52\x8b\x00\x8e\x52\x3c\x9b\x02\xac\x14\xf4\x10\x11\x3d\x9e\x62\xf5\x20\x12\x4b\x68\x41\xa9\x45\x98\xba\x6d\xea\x01\xcb\x62\xfc\xb6\xef\x52\x3f\x6e\x17\x6f\x7f\xf0\x3c\x4b\xcf\x07\x96\x6d\x43\x7f\x10\xdf\x02\xf7\x8a\xef\x5d\xfc\x61\xcf\x8b\x00\x9f\x05\x4e\x38\x97\x35\x37\x77\x75\x35\x7b\xc8\x7f\x9d\x03\x09\x71\xd2\xb9\xbd\x52\xe1\xe9\x4c\xf1\x7a\xd2\xd2\xf3\x06\x30\xf6\xb4\x82\x41\xe7\x5f\x7a\xa9\xd4\x87\xd8\x7b\x39\xb5\x84\xfa\x0b\x5c\x91\x22\x6c\x6e\x3a\xc5\x47\x71\x8a\xf4\xfb\x63\x66\x8e\x21\xa1\x02\x2f\x0e\x6b\xb5\xc9\x62\x2e\x16\x4b\x18\x13\x1d\x02\x63\x36\xdb\x2c\x46\x32\xca\xf3\x2e\xcc\x05\xdd\x79\x1c\xf7\x93\xa8\x6d\xe8\x44\x2a\x73\x59\x27\x09\x9f\xfd\x47\xd6\x30\x21\x62\x57\x05\x20\x50\xa2\x75\x95\x3b\x11\x11\xad\x2b\x8f\xd0\x2a\x12\x20\x87\xb7\x05\xec\xbc\xdc\xba\x88\xef\xdd\xbb\x6e\xe1\xe5\x57\x7c\x8a\xe0\xb4\xba\xba\x67\x6d\xed\xea\xae\x9e\xec\x4b\xf4\x4c\x14\x76\x65\xe1\xb6\xc4\x8e\x12\xfc\xd2\x21\xd5\x08\x84\xcb\x5e\xba\xeb\xe5\xeb\x41\x2d\x42\xd5\x32\x6d\xdb\xc3\x8b\x47\x9e\xe7\xd9\xb3\x3d\xb3\x15\xc0\x2d\xdc\xbf\x63\x11\x71\xc2\x78\x5c\x94\xf3\x18\x17\x42\x65\xf3\x89\x54\x2b\xb1\x00\xc3\xf2\x78\x2b\xa6\xa5\xdd\x36\x9a\x65\x2d\x18\xe1\x74\x92\xa4\x8a\xb6\x82\x60\xac\x8c\x0c\x7c\x80\x59\xad\x26\x07\x41\x5a\x10\x69\x85\xe9\x77\x81\x0f\xfa\xb6\xab\x23\x5c\x5d\x15\x2d\x45\x16\x02\x01\x1f\x0b\xe6\x72\xe2\xbe\x8e\x55\x9d\xdf\xc7\x15\x5a\x8a\xce\x2d\xdc\x55\x93\x15\x5a\x0a\xac\xbb\xe7\x5f\x19\x52\x0a\x3c\xdc\x0d\xde\x97\x29\x29\x30\xa2\xf7\x83\xde\x67\xa9\x7a\x6a\x0f\xb4\x37\x5e\x2c\x88\xb5\xa7\x0b\xb8\x80\xdf\x6f\xe5\x79\x37\x49\x51\x5e\xa3\x37\x14\xb6\x19\x8d\x26\xbf\x43\x63\xd2\x74\x0a\x8c\xc5\x44\xf0\x5e\xcc\x8b\x4a\x3b\xe1\x8c\x4f\xc8\x53\x7e\x51\xd5\xd7\xad\x26\xd1\x52\x00\x82\x6b\xb5\x91\x1c\xba\x13\x7c\x52\x29\x22\x52\x9b\x40\x1d\x2a\x88\xc3\x26\xa2\xad\x3d\x40\x8c\xda\x86\x13\xeb\x95\xf6\x09\xe2\xea\x96\xed\x2d\x83\x1a\xa7\x9b\x19\xf1\xde\x4d\x6f\x9a\xc4\x86\x8f\x1e\xc2\x93\x43\x12\xc7\xec\x93\xf1\x15\xf8\xdd\x52\x0f\xc5\x9c\x39\xe2\xd6\x5f\x09\xb1\xb3\xa7\xd1\xd3\x0c\x66\x88\x3f\x71\xe4\x79\xef\xbf\x23\xd7\x50\x41\x3f\xe8\x23\xa8\xc7\x06\xa3\x2e\x4b\x8e\x20\xb0\x2a\x67\x22\x19\x34\x61\x09\x6c\x48\x7d\xb0\x8a\x28\x2c\xac\x68\x11\x8a\x0b\x19\x68\x2b\x75\xed\x02\xed\x25\x7c\x2d\x82\x8b\x43\xa1\x53\x2a\x95\xcf\xdf\x8e\xe5\x7a\xb9\x54\x75\x9e\x28\x38\x92\x16\x5f\xea\x76\x2a\x25\x13\xfd\xca\xa9\x98\x50\x0e\x3f\xc5\x21\x95\x5d\xe1\x8f\x3c\xfb\x8c\x83\x77\x27\x62\x91\x3a\x73\x6d\xcc\x3a\x74\xe2\xc2\xfa\xa0\x27\x1c\xea\xa8\xc8\x55\x58\xad\x98\x05\x36\xae\xdb\x91\x6c\x34\x3b\x26\xa6\xc6\x8f\x19\xb2\xa0\x63\x52\x09\x28\xbc\xf1\x2e\x2a\xd9\x39\xb1\xa6\xc0\xff\xa6\xb1\x66\xf2\xa2\x79\x6d\x0e\x86\xcb\x95\x5b\x0d\xbb\x6a\x32\xf0\x05\xbf\x3f\xdf\x9d\x1c\x59\x9b\x18\x39\xa8\x7a\xc2\x1c\x39\xaf\x94\x89\x5d\x42\xa8\x06\x9f\xc3\x0d\x86\x48\xc8\x64\xd2\x61\x58\xd8\xe1\x72\xd9\xda\x51\x2a\x89\xd0\x13\x2d\x82\x4e\x4f\x03\x13\x66\xca\x2b\x30\x56\x69\x18\x75\x85\x2b\x2a\x26\xce\x2b\xa8\x54\x2e\x8a\xe5\x15\x00\x48\xe8\xc8\xe0\xfc\x20\x46\x6c\xea\xf0\xf9\x06\x25\x15\x79\xc7\x76\x35\x25\x22\xfe\xd9\x8d\xb9\x68\xe6\x0b\x6e\xc5\xf4\x59\xcd\x48\xb0\x92\x49\x73\xda\x9b\x46\xa2\x7e\x3c\xc4\x21\x27\x61\x54\x8c\x4c\x87\x34\x5a\xad\xcb\x6c\x32\x79\x7d\x56\x82\xf0\x69\xcc\x66\x83\x0b\xb3\x63\x1d\x82\x9d\xd0\x9a\x0c\xa6\x0e\xc1\x90\x57\x64\x6f\xcb\xb6\x9b\xcb\x21\x61\xae\xe0\x10\xcf\x24\x7b\x6a\x33\x30\xf6\x52\x3e\x0c\xef\x7a\xfb\xb3\x1f\x3e\x6f\x3d\x60\xee\xd9\x6e\x3e\x3a\x7d\xdd\x7d\x07\xe7\xce\x6d\x58\x39\x6c\xd0\xcc\xd2\x27\xa8\xfd\x7f\x7e\xf8\x4f\xe2\xf7\xb5\xe2\x30\x49\xc7\xfd\x62\x66\xbf\x38\xb1\xe5\xda\x48\xc1\x6e\x80\x37\xc1\x39\xce\x80\x87\xe5\x4a\xb8\xb7\xdc\xa8\x6b\x9c\x77\x3a\x69\x02\xd7\x39\x70\x87\xc7\xcb\x13\x84\x0d\xa3\x69\x9b\xcd\xd0\x2a\xd8\x18\xdc\x89\x39\xd5\x0b\x9b\x2b\xbf\x4d\xf5\xc1\xa4\x4b\x49\x73\xc3\x33\x7d\x0c\x72\xeb\x23\x43\xc1\x59\x77\x99\x96\xa6\xa6\xce\x5e\x52\xfb\x68\xc3\xf2\x60\xe3\x98\xf2\x7b\x9f\x7f\xf6\x6f\xe2\xfd\x15\xf3\x4d\x8d\x4e\x10\xa4\x99\xc9\x7b\xd3\x37\x78\xec\x77\x03\x3a\x79\x65\xb7\x78\xae\x4d\xfc\x0a\x61\x52\x10\xbd\xdf\xf4\xfe\x46\x19\xa0\xee\xe1\x60\x6c\x58\x8c\x5d\x97\xf6\x85\x03\xfe\x62\x32\x99\xb4\x46\x2c\x11\x0a\xfa\x8e\x64\xc2\x62\x71\xdb\x49\x7b\x49\x29\x34\x9c\x1a\xa4\x82\xca\x85\x00\x54\xcc\xfe\x62\x68\x8f\x68\x6d\x40\x8b\xeb\xb1\x62\xe0\x26\xb4\xc5\xda\x62\xe8\xa1\x25\x3b\x05\xa3\xbe\x43\x30\x12\x38\xdf\x0f\xda\x34\xa9\xe6\x89\x47\x4c\xf1\x4a\x52\x25\xbf\x8d\x55\x52\x02\x08\xc6\x82\x57\x70\x4e\x71\x45\x59\xf5\xc7\x38\x45\x10\xaf\xda\x1c\xce\xe9\x16\x19\xe7\x34\xf2\x90\xe3\xa1\xeb\xef\xb5\x40\xcd\x96\x0f\x72\x5a\x08\x82\x0e\xf1\xe3\x90\x1a\xea\xf4\xe5\x6e\xa2\xca\xdd\xdc\x07\xe8\xf4\x54\xf7\x33\x39\xa4\x53\x29\xd6\x18\x82\xf2\xdd\x12\x6e\x43\x1c\x5b\x97\x0e\xc6\x28\x12\x9a\x28\xaf\xcb\xe7\xe3\xcd\x0c\xd4\xc6\x51\x4d\x24\xa2\xd5\x9a\x78\x53\xa2\x20\xc6\xb8\x3d\x6e\xb4\x48\x4e\xc1\x4c\x79\x3c\x76\x60\x0f\xce\x15\xec\xac\x49\x4b\xfa\x10\x6c\x9f\x3e\x87\x37\xa4\xea\xc2\x52\xf4\x60\x5f\xad\x9d\x87\x97\xce\xe6\xdd\xc9\x2a\x65\x26\x52\x83\x0b\x5c\x1d\x0f\x40\xcd\x2d\x0d\x20\xa4\x91\x5b\xb1\x26\xe2\x37\x4f\x3e\x62\x06\x2f\x9b\x6f\x9f\x74\xad\xe3\x3a\x7f\x91\xf8\xd9\x99\x9f\xc4\x5f\x02\xbb\x1d\xbb\x27\xde\x21\x75\xb7\x04\x7b\x96\x86\xa4\x6e\x2c\x31\x2e\xab\x74\x31\xde\x7d\xe4\xb7\xef\xde\x7b\x65\xd4\x31\xa8\xe3\xcf\x1d\x44\xad\x2d\x8f\xbd\x28\xc5\x90\x5b\xe0\x19\x7b\x8b\x6a\xb2\x69\x88\x16\x29\xd7\xf6\x7d\xef\xe5\xe4\xaf\xd0\x5e\x87\xa1\x76\xec\x4e\x0f\xf3\x06\x02\x61\x7b\x24\x91\x80\x81\x94\x03\x0b\xc7\x08\xc2\xa8\x81\x07\xd1\x1d\x76\x17\x14\x46\xd8\x4e\xc1\x14\x89\x04\x71\x47\x18\x51\x79\xf8\xbd\xee\xa0\xcd\x98\xc0\x13\x9d\x82\x46\x85\xf5\x85\xb0\x24\x53\x19\xb4\x98\x17\xf3\x0a\xb7\xb3\xd1\x57\x2a\x83\x19\xa3\x6a\x5d\x87\x0b\x91\x35\x0a\x0a\x3b\x87\x96\x90\x5a\x4a\x89\x50\xc6\x8b\x01\x89\x08\x82\x00\x23\xec\x33\xb7\xce\xba\xa4\x7e\xa6\x66\x88\xf8\xc2\x79\x12\x2f\xc7\xfe\xbb\x4b\x1f\xeb\x99\xb2\x78\xe6\xe4\x73\x27\xda\x2f\x6f\xbb\xdd\x74\x14\xec\x8e\x83\xa1\x97\x6d\x43\x10\x18\xd7\x5c\x23\x1e\x7c\x4f\x23\x7a\x11\x2b\xc7\x39\xf1\x17\x44\xcb\xf1\x87\x3f\x40\xeb\x77\x31\xf8\x37\x0e\xcf\xcb\xdd\xe2\x1f\x89\x45\x94\x05\x0b\xc0\xf3\x52\x84\xad\x4c\x0f\xa1\x89\x82\x84\x8f\xf2\x32\xb6\x50\xd8\x4d\x7a\xe0\x7e\xb0\x07\x49\xd2\xee\xf1\x7a\x63\x50\xff\x24\x8b\x13\x61\x54\x8a\x53\x80\xe2\x07\x9f\xc7\xc5\xd8\x68\xda\x6a\xd6\x9b\xcd\x9a\x36\xe8\x00\x67\x5a\xbb\x4f\x40\x91\x24\xa7\xcd\x9a\xea\x77\x1c\x72\x3e\xaf\x7c\x5f\x0d\x63\x37\x90\x83\xd4\x4c\x10\x11\x56\x72\x73\x87\x00\xe8\xb2\xc1\x98\x00\xd4\xb2\x16\x10\xab\x4a\x40\xaf\x98\xe8\xfc\xfe\xe4\x14\xef\x4e\x44\xbf\x31\xfd\xf5\x8e\x0d\x53\x9f\x5d\xf2\xd1\xc4\x9d\xdf\x5d\x4a\x5b\x0e\x2d\x7d\x78\xea\xf4\x9e\x33\xe6\x47\x1a\x56\x00\x82\xba\x62\xc4\x18\xfc\x3f\x9b\x1e\x0f\xdd\xb5\xab\x2e\xd6\x30\xb6\xbd\x48\xdc\x01\xee\x9b\x71\xe7\x21\x10\xbf\x0f\x80\xb1\xe2\xbd\xfc\x02\xf1\x39\x00\x66\x18\x5f\xbe\xd4\x6a\xed\x8d\x6f\x90\xec\x05\xe2\xc1\xab\x91\x7a\x6e\x66\xa4\x1d\x12\x4e\x93\xc7\x89\xd1\x3c\x8f\x90\x9a\xbc\x3e\xbd\xcb\xed\x42\x47\xc0\x21\x68\xdc\x6e\x33\x6e\xb6\x43\x07\xc0\xcc\x52\x58\x1e\xbc\x5b\x7f\x68\xb7\xbc\x12\xe4\xba\x2c\x9e\x49\x66\xab\x67\x4c\xa6\xd4\xa3\x82\x2f\x94\x36\xfa\xed\x93\xf6\x3b\xf6\xc7\xe3\xe2\x99\xf7\x76\x77\xd6\x4c\x22\x83\xed\x63\xbb\xe8\xc6\x47\x1d\x8f\xca\x48\x26\x62\x51\xf7\xfb\xef\x9e\xf6\x23\x20\xb7\x45\xd3\xc1\xba\x6e\xe9\x2c\x4b\x5c\x7c\x0d\x30\xc6\x73\x61\x31\x6c\x4a\xba\x38\xe8\x76\xa3\x54\x1d\xc7\x91\x2e\x57\x3c\xe1\x8b\x4c\x12\x7c\x18\xc1\xda\x59\x18\x8f\xd8\xed\x5a\xa7\x93\x6b\x15\x9c\xb4\xd6\xd2\x2a\x18\xb4\x1e\x75\x91\x58\x2e\x51\x90\x87\xb8\x27\x6d\x4d\x14\x09\xe7\x33\x10\x29\x1a\x8c\xa8\xca\x56\x80\xc7\xc1\xe1\x15\xb6\x95\x13\x23\xef\x1e\xcd\x85\xa6\xc2\xc5\xb6\x8b\x6b\x50\x78\x7a\x6a\x66\x43\x5a\x98\x3e\x3c\x3d\x03\x77\x76\x89\x85\x27\x5e\x91\x23\x55\xf0\x4b\x17\x28\x0f\x37\x82\xa6\xe1\xd3\x85\x74\xc3\x4c\x41\xd6\x4d\xe3\xc4\x51\x9a\x66\x09\xc7\x43\xc2\xa4\x24\x59\xbd\xa9\xa8\xc8\x60\x88\xfa\xdc\xac\xbb\xa4\x34\x9a\x40\xd4\xa7\x09\xaf\x9b\xe0\x31\x84\xe0\xa1\x37\x99\xb4\x8c\x56\x41\xf1\x50\x05\x5a\x7d\x1b\xe9\x32\xe1\x55\x0e\xc6\x2d\x4e\x58\x70\x05\xc3\x03\x3a\x2b\x31\x90\xed\xe0\x26\x94\xa6\x48\xe2\xd8\x3e\xb1\xf7\xba\x03\x7b\x6e\xbe\xe4\x89\xce\x15\xa3\x27\x74\x0e\x12\x3f\x13\xdf\x78\x17\x5c\x0b\x34\xdb\x97\x83\xda\x5e\xcc\x3a\xa8\x6e\x7c\xd1\xb0\xb6\xb2\xc5\x7b\xf6\x9d\x20\xc8\xcf\x1f\x17\x0f\x7e\xf0\x97\x0f\xc7\x90\xde\x92\xb3\x2d\x41\xb8\x97\xdd\xc0\xd2\x03\xd6\xbe\x18\x75\xfc\x76\xde\xac\xd2\xea\xfa\xca\xed\xe2\x2f\xfe\x87\x77\xd9\xca\x91\x8c\x30\xce\x24\x13\xd0\x86\xfa\xb0\x42\xd4\x65\xec\x77\x47\xed\x56\x6b\x2c\x66\xa4\x70\x37\x5e\x94\x8c\xda\xed\x21\x3e\xd4\x2e\xf0\x9c\x41\xbe\xf1\xf2\x60\x89\xfc\x70\xb2\xef\x2d\x4f\x4a\x1d\x3f\xca\x08\x41\xb9\x56\xf4\x01\x62\x47\x14\x3a\xe2\xde\xb7\x3f\x78\xcc\xd0\xe5\xe7\x1b\xd2\x05\xf3\xc7\xde\x71\x8f\x31\x56\x77\x67\x26\x4e\x0c\x2f\x29\x5e\x32\xa4\x05\xc6\x89\x2f\x14\x9d\xfd\xa5\x3e\xb1\xd6\xbe\xea\x53\xdb\x65\xdb\xa2\xe3\x5f\x19\x3f\x2b\x17\x16\xb6\xd6\xe3\x43\x61\x54\x88\x74\xa8\x74\x9f\xab\xe0\x43\xac\x48\xd7\x39\x1d\x0e\x9f\x35\x8c\x85\x42\xc0\x65\xb7\x5b\x01\x30\x6a\xac\x9a\x68\xc4\x69\xb3\x63\x98\x4e\xaf\xeb\x14\xc2\xd0\x0a\x9b\xcd\xa1\x4e\xc1\x6c\xec\x10\xcc\x84\x03\xe4\xc3\x7c\x48\xcf\x30\xef\x34\xa9\x81\xc4\x54\x44\x3e\xa9\x3c\xcc\x0f\xc5\xa8\xe6\xb0\x21\x72\xa8\x1f\x05\x93\x0e\x98\x7a\xae\x31\xdd\x3d\xf1\x80\xfd\xc0\x7c\x78\xd2\x78\x09\x1b\xe2\x15\x84\x0d\xf1\x66\x11\x82\x86\x18\x35\x0f\x1f\x24\x16\x4b\xfe\xce\xdf\xcf\xc7\xa1\x09\x95\xd0\x21\x44\xc6\xd3\x8c\x0f\xca\xa2\x43\x80\xde\x6f\xd1\xdd\x36\x7c\x6e\x2e\x6c\x66\xba\xd4\x61\xe3\x38\xab\x89\xc6\x30\x06\xea\x48\x37\xe5\xa1\xa5\x53\x66\x82\x12\xc3\x53\xd6\x02\x4f\x99\xd5\x61\x84\x02\x13\xd0\xc5\xd6\x12\x0c\x96\x05\x4d\x6e\xc8\xaf\x53\x04\x6a\x6a\x22\x59\x51\x64\x30\xd1\x32\x9d\xe1\x39\x50\xae\x47\x6b\x6f\x6f\x2d\x8f\x0c\xae\x2d\x1e\xb7\xb2\xca\x7c\x8d\xed\xda\x66\xf1\xc7\xb1\x57\xd8\xae\x18\xbc\xd6\x08\xd6\xe3\x9f\x2d\xdb\x60\x10\x8f\x6c\x1d\x3f\x69\x6c\x97\x38\x07\xec\xef\x02\x4d\x12\x97\x2c\xca\x2d\xa2\xdc\xaa\x64\xef\x83\xd8\xae\x74\xa5\x35\xc8\xf8\x19\x83\xd6\xa8\x31\x6a\xa8\x80\xcd\xcf\xfa\x5d\x5e\xa7\xcf\x87\xb1\x4e\x27\x52\x78\xa1\xb0\x93\x65\x8d\x8c\x99\x81\x81\xb8\xcf\xe7\x0f\x7a\xe1\x33\x43\xea\xcf\x25\xb8\xac\x7e\x4c\xcf\xe8\x71\x3d\xa1\xd7\x13\x0e\x73\xbf\x6e\xcf\x94\xdc\x9d\x5b\xa7\x02\xb8\xca\x7c\xa3\xce\xa8\x2a\x0e\x51\xa6\xad\xa7\xd2\xaa\xc6\x83\x43\xc8\x97\x65\x00\x69\x4a\x3e\xcb\x2f\x1c\x02\x09\x36\x94\xed\x06\xbd\x5a\x7c\xcb\xf1\x7d\xb5\xdc\x12\x9a\x02\x97\x77\xdd\x81\x1c\x83\x1b\x96\x7d\xe6\x10\x3f\x15\xbf\x2e\x7f\x58\xfc\x49\x69\x0a\x05\x77\x75\xdf\x81\xd4\xe6\x1d\xf2\xdf\xdd\xe2\xfc\x6d\x80\x95\x6b\xb1\x50\x1e\xf9\x1e\x18\x1f\x14\x42\x1d\xb3\x31\x3d\x34\x19\x0c\x07\x8a\xfd\x45\x6e\xde\xc3\x11\xd0\xd8\x73\x5c\x51\x11\xe6\xb7\x78\x3c\xd0\x45\xc4\xb0\xd2\x62\x8d\xd3\xe5\x6c\x15\x02\x44\x91\xcb\x65\x4c\xf8\x7c\x9e\x16\xc1\x47\x6b\x39\x07\x82\xc4\xa5\x51\xfb\xbc\x8c\x65\x95\x75\xc3\xb3\xe2\xe7\xbc\x71\xa5\x45\xab\x2e\xc3\x08\x9f\xb9\x81\x92\x4a\x4f\x01\xd4\x43\x72\xed\xa9\xcc\xff\x1e\x91\x17\x80\x0d\xc9\x58\xb9\xb5\x29\x0e\xd4\x46\x88\x1b\x12\xa9\xe5\xec\x2d\xe2\xce\xce\xcb\xb7\x8c\x4f\x0d\xad\x28\xaa\xb7\xbb\x4a\xea\xaf\x5d\xb1\xe5\x79\xf6\xa6\x2a\xd4\x74\x3a\x06\x78\x8b\xac\xde\x12\xd3\x97\x6e\x71\xfa\x75\x2f\x13\xe7\x95\x2c\x99\xd2\xd5\x73\xf0\xf6\x9b\x26\x68\x4d\x3f\x5c\xc4\x6f\x7b\x12\x0f\x74\xbd\xe9\x6c\x14\xff\x31\xb9\xd6\x1d\xe2\xcc\xc3\xf9\x9e\xdd\xdf\xc8\x7b\xa3\xae\xf7\x34\xf1\x2c\xf1\x1c\xb4\xff\x45\xd8\xbc\x74\x65\xd4\x4b\xd3\xc5\x41\x7b\x51\x91\x9e\x43\x2d\x8d\xc9\xe2\x22\xc4\x1c\x99\x68\x13\x4c\x8c\x3d\x88\x5a\xd3\x30\xad\x96\x6a\x11\xb4\xb4\xd7\x8b\x49\x1e\x3e\xa7\xc2\x0f\x90\xef\xe3\xf3\x2e\xa1\xad\x4a\xe0\x58\xa7\x84\x51\x54\x50\xe9\x37\xe7\xb3\x40\x20\x34\xa1\xe8\x2b\xc4\xe6\x9a\x09\x52\xb4\x60\x95\xf8\xb2\x61\xf1\x0c\x13\x98\xa1\x2f\x5b\xb0\xf6\xc2\x8b\x16\xbd\xf0\xdc\x2c\x27\xb5\x7a\xd2\xea\x21\x8d\x05\xf7\xec\x28\xaa\x59\xdf\x55\x1a\xf7\x16\x0f\xb3\xbf\x6a\x85\xf6\xcf\xd9\xd8\xe4\x6b\x38\xff\xbc\x4b\x6e\x6d\x26\x89\xad\x35\x17\x54\xad\xfd\xdc\x69\x04\x5f\x11\xe4\xda\x4b\xea\x87\xe8\xdd\xb9\xfb\x20\xe2\x84\x4d\x83\xee\x83\xa0\xdc\x15\xbd\xa7\x88\x53\x50\x6e\x1b\x94\x1c\x46\x89\xac\xc1\x45\xba\xdd\x98\xcd\x60\x0b\x05\x6d\x9c\xc5\xdb\x0a\x83\x7c\xce\x45\x92\x9c\x96\x83\xe7\x97\xc9\x76\x48\xa9\xf9\xfb\x54\x39\xf5\x94\xaa\x3b\x8a\xcf\x24\xf0\x90\x95\x87\xcf\x37\x97\xa3\x1b\x06\x5e\x39\x4f\x07\x66\x92\x43\x6e\x9a\xf0\x87\xed\x3b\xc5\xb3\xb7\x6f\x5b\x35\xb1\x06\x7f\x70\x54\x55\xc1\xbc\xc4\xfc\x92\xd6\xb1\x17\x35\x13\x13\x83\x83\xb7\x8d\x9d\xf2\xf0\xbe\x23\xe2\xdb\x07\x4b\x62\xf8\xec\xc5\x1b\xdb\x86\xf4\xbc\x16\xbe\xe6\xfb\x1c\x2e\x3e\x8a\x0f\x25\xbb\x61\x63\xc2\x61\x26\x12\x21\x09\xaf\xce\x49\x38\x8b\x92\x61\x9b\x2d\xe0\x08\xb4\x0b\x0e\x06\x61\x7e\x18\x34\x00\x8b\xe7\x80\xbb\x52\x03\x32\x11\xc8\x67\x50\xa1\x22\x50\x41\x52\x68\xff\x3b\xd3\xc4\x83\xa3\xc1\x02\x05\x98\xa2\x78\x2c\xf7\xbb\x64\x04\xc4\xff\xc8\xf0\x14\x17\x6c\xfa\x62\xf8\xc0\x64\x04\x00\xb3\xc0\xfd\xd7\x01\x75\xaa\x17\x2b\x4f\x3b\xdd\x06\x96\x30\x10\x3e\xbf\x96\x6e\x15\x8c\x46\x2d\xe7\xc2\x30\xae\x4d\x36\x7d\xd9\xfb\xc5\x5c\x37\x11\xc8\xac\x72\x26\xff\x90\xdd\x3c\x09\x38\xcf\x9f\x0f\x3d\x7d\x83\x28\xde\xdc\x74\x5f\x75\x85\x02\xc8\x3e\x63\x92\x0c\xc8\x4e\xbc\xf0\xc4\xdd\x8f\x8b\x1f\xed\xf3\xd8\x40\x50\x8d\xc3\x2e\xe9\x86\xa7\x7a\x0f\x13\x2b\xe0\x7c\x82\x58\x12\x2b\x49\x3b\x02\x6e\xb7\xb3\x90\x61\x12\x36\x1b\x19\xf2\x39\x39\x13\x09\x6d\x17\x52\xe6\xa8\x4b\xee\x04\x52\x78\xb9\x66\x76\xb9\x94\x9e\xe3\x33\x50\xf1\xda\x5c\x7b\x9c\x74\xad\x10\xa7\x2a\x95\xf2\x0b\x3f\xf0\x23\x44\xf8\xcc\xd4\x9a\xaf\x98\xaa\x5d\x79\xfe\xaa\x2b\xff\x72\xff\xa3\x1d\x65\xf1\x45\x25\xed\x6e\xf0\xec\x98\x99\xad\xe3\x3a\xa7\x9b\x66\x80\xb1\x08\x1b\xde\x63\x13\x3f\x39\x58\xdf\xfd\xfe\xe5\x75\x4b\xa6\x5e\xb8\x67\xfe\xa8\xd9\xd7\xac\x1d\x79\x49\x6d\x69\xbc\xa2\x7c\xf8\x38\x09\xc7\x7b\x34\xe9\x92\xb8\xd1\xcb\xa1\x65\x2a\x0f\x16\x16\x11\x3e\x9f\xc9\xe4\x84\xce\x79\x65\x84\x20\x2a\x2a\x79\x18\xba\xb5\x0a\x1e\xaf\x82\x0a\x59\x82\xf2\xfa\x85\xc1\x60\x1c\x8b\xff\x97\xbc\x7e\x56\x67\x67\x8b\x4b\xa9\xbe\x25\x13\x2a\x57\x03\x06\xad\x0d\x00\x9e\xe0\xfc\x2a\x0a\x7b\x7e\x9d\x84\xf8\x8b\x65\x54\xdc\x57\x9e\x4e\x34\x76\x89\x6f\x9b\x42\xb5\x37\xa5\xd5\x75\x13\xf6\xbc\xea\x88\xdf\xe2\x4d\x43\xbb\x9d\xe7\x7d\xc2\x02\xae\x66\xf8\x53\xe3\xa7\x81\x75\xf9\xd8\xe5\xbd\xa7\x29\x97\x84\x3d\x99\xc4\x26\xa7\x8b\xfd\x84\x27\x1a\x8d\x19\x0c\x3c\xcd\x11\x5c\x71\x89\x9b\x6f\x11\xdc\x0e\x33\x14\x9a\x31\x03\x6d\x01\x92\x37\xea\xf1\x84\xb0\x50\x7f\x79\x53\x79\x65\xc4\xa9\x2c\x52\x9f\xea\xe6\x22\x0f\x76\x4b\xc6\x6c\xff\x1d\x39\xad\xdc\xeb\x7f\x56\x0e\xc6\xfc\xe2\x63\x0a\x62\xfb\xb0\x81\x84\xbc\xfa\xf8\xa3\xe8\x68\xfc\x70\x8e\x95\xb0\xda\xf3\xa4\x43\xfb\xf0\xcf\xf0\x5c\xcc\x81\xfb\xd0\x80\x85\xb0\x86\x74\xd0\x46\x78\x9c\x3a\x9d\xd1\x63\x0c\x47\x34\x4e\xd4\xe6\x4c\x07\x02\x18\xb4\x4a\x0c\x0d\x0f\x08\x9b\xa3\x40\xec\x8b\x01\x2e\xdf\xee\xc9\x59\x38\x09\x89\x48\x39\x30\xb5\xe8\x34\xb3\x32\x10\x3b\x42\x1d\xfc\xfb\x90\x91\xab\x57\x78\x46\x81\x89\x3b\xc5\xd3\xc7\xe7\x1c\x29\x8f\x96\xdf\x35\xec\x7f\x46\x7d\x74\x6a\xee\x83\xcb\x9e\x7e\x85\x98\x37\x6d\x5c\xe7\x7a\xf3\xe2\xd5\x63\xe7\x8b\x5f\x1e\x15\x4f\xef\x1e\x56\xde\xea\x8e\x01\x9f\x75\xd7\x25\xe3\x2f\x19\xfb\x67\x49\x9f\x2a\x7d\x3a\x12\xb6\xdb\x88\x74\xd8\x63\xc4\x9c\x24\x45\x59\x31\x6b\x28\x4c\x42\xf3\x49\x92\x0e\x8b\xc3\xdf\x2a\x38\x38\x83\xd6\xa2\x6d\x93\xcb\xb8\x24\xde\x85\x01\x61\xcb\x65\xd8\xa8\x06\xf9\x5a\x32\xa1\x26\xeb\x00\x99\x12\x14\x7e\xf3\xcf\x77\xca\x64\x8c\x30\x1a\x3c\xfa\x04\x8c\x04\xb7\xdd\x85\x1b\x2f\xba\xa5\xd0\x3b\x72\xc3\xe3\x33\x76\xcf\x35\x8f\x3c\x2d\x05\x80\xc7\x0e\x1d\x12\xdf\xbf\x6f\x05\x98\x41\xef\x9a\x5f\x54\xf4\x17\x65\xae\x94\x17\xce\xb5\x14\xab\xc5\x56\xa5\xeb\x2b\x8d\x18\xe7\x8a\xc5\x02\x01\x6b\x19\x45\x15\x58\x91\x67\xef\x0f\x7b\xc2\x13\x05\xb2\xac\x55\x48\x14\xd8\x0a\x10\x2c\xac\x87\x84\x2a\xc0\x43\x14\x5b\x8a\xab\x5b\x85\x62\xc9\x35\x6f\xeb\x53\x8c\x26\xc3\x96\xcb\x4e\x4f\x3f\x34\x33\x5b\xdd\xef\x4b\xa6\xad\xad\x69\x00\xbc\x9a\x90\x12\xd5\xa4\x6b\x25\xc7\xe0\xf7\xe4\x05\xee\x42\x2f\x33\xd3\x3e\xb5\x68\x72\xb8\xc8\x75\xd9\xe4\xa9\xb3\xa8\xd1\xae\x9b\xff\xb1\xea\xf7\xd6\x20\x42\x69\x4b\x9d\x96\x35\xe1\x35\x83\xaa\x2b\x26\xaf\xee\x9c\x16\x75\x5b\xb6\xfe\xcf\xe5\xaa\x55\x51\xfa\x03\x88\x3a\x09\x0f\x73\xb1\x14\x17\x9f\x82\xff\x66\xe1\x3a\x25\x61\x5c\x5c\x46\xe8\x0b\x0b\x1d\x96\x98\x37\xec\x0d\x17\x97\xc4\x68\x0b\x6d\x69\x13\x68\x1a\x0b\xd0\xde\x80\x17\x37\x11\x5e\x6f\x20\x80\xdc\x24\x06\xd3\xb4\x09\xa4\xcc\x74\x94\xed\x8c\x90\x71\xc1\xd4\x0c\x40\xc8\x09\x4c\x49\x28\x84\xc8\xf4\xd4\x2a\x35\x45\x9a\x24\xba\x63\xe7\x73\x85\x7b\x99\x16\x63\x5a\xea\x61\xd7\x80\xa2\x79\xc7\x4a\x63\xcb\x36\xae\xb8\xb0\xed\x06\x6f\x92\x2d\xae\x5d\x3e\x68\x4c\xd3\xf0\x39\xf5\x55\xc3\x63\xab\x6f\x3f\xf0\xcc\xbc\x25\xa0\x71\xea\x97\xf6\xfa\xe2\x31\xa9\x55\x5d\x0b\x82\x96\x4b\x4d\xec\x92\x11\x43\x86\x94\x5e\xfc\x4d\x74\xc5\xdc\x69\xeb\xe3\x5a\xeb\x82\xf6\x3d\x87\xb1\x8c\x6c\xe4\xf3\x50\xb6\x34\x76\x61\x7a\x38\xe1\xd5\x0f\x1b\x16\x2e\x8c\x57\x57\x97\x95\x0d\x72\x58\x06\x23\x21\x87\x37\x96\x56\x26\x2b\x27\x0a\x48\xce\x41\xb5\x91\xda\x16\x21\x1e\x49\xd2\x91\x08\x9d\x24\xb0\xc0\x7f\x95\x16\x65\x36\x06\xda\x08\x92\xcc\x99\x8d\x90\xbb\x73\xfe\xef\xc2\xfb\x60\x38\x50\xdb\x7f\x6f\xfc\x7f\xae\x88\x3b\x40\xab\xf7\x88\xae\xb4\xe4\xca\xff\xb2\x44\x14\x5d\x68\x57\xed\x91\x70\x11\x27\x94\xe5\xd6\x0c\xc7\x6a\xe0\x7e\x58\x09\xd7\xcc\x09\xfd\xe6\xe1\xe9\x08\x51\xa8\x8f\x44\x38\xb8\x14\x74\x21\x59\x52\x1a\xa0\xe9\x71\x0c\x68\x60\x00\xc3\xb8\x34\x71\x0e\xe5\x8a\x5d\xc8\x52\xce\x96\xe2\x82\xd9\xb3\xa5\x46\xec\x1c\x86\x77\x46\x2b\xc9\xb7\x06\x09\x24\x6e\x46\xf8\x84\xfa\x91\x2b\xa1\x2b\xee\x7d\xf0\x95\x7d\x97\xae\xba\x66\x91\xb0\x60\x78\x11\x5f\xe4\xdf\xb8\xfc\x92\xf5\x43\xb6\xdf\x71\xd9\x12\x30\x72\xd6\x7b\xc7\x0e\x3d\xb6\xed\x1b\xfc\xe4\xee\xad\x73\x57\x0f\xae\x2e\x2c\xa5\xf4\xe4\xa5\x46\xb2\xba\xac\xa8\xf4\x87\x0b\x96\xcd\xbf\x96\xd5\xea\x66\x37\x5f\xfb\xd0\xe3\x87\x0f\x83\xc4\x1d\xe8\xd9\x8b\xc7\xc4\x99\xf8\x36\x09\x97\x44\x48\x17\xf7\xcb\xf7\x68\xdc\x2e\x77\x9b\xa0\x77\xb9\x50\xae\x07\xd1\xc6\x98\x71\x94\xec\x69\xcd\xb5\xc8\x33\x27\x2a\xcb\xfe\xaf\x74\x8f\x2a\xb3\x29\xe5\x4e\xd8\x0c\x8e\x0c\x94\xb3\x67\xad\x19\x9c\x31\x2f\x5b\xbb\x9d\xdb\x46\x16\x7e\xf2\x96\x92\xec\x19\x35\xc1\x1a\x78\x99\x7b\x99\x68\x96\xc0\x6c\x16\x77\xf3\x5f\x7e\x28\x25\x7b\x3a\xe7\x3c\x24\xe7\x7a\x50\x0f\x0e\x15\x86\x36\xaf\x08\xea\xad\xf9\xe9\xaa\xa4\x0b\xab\xac\x40\xa9\x5a\xd6\x68\xc3\x6c\x83\xea\x2a\x62\xb1\x82\x82\xd2\x76\xa1\x80\xe3\x02\xd0\xf1\x73\x03\x04\xac\xc2\x79\xf4\x0c\x0c\x4b\xf5\x80\xac\x82\x5a\x98\x51\x39\x83\x29\xa9\x89\xa6\x9f\x57\x98\xca\x51\xad\xb0\x8a\xfd\x53\x21\x58\x13\x79\x9d\x72\x70\x6b\x2a\xe9\x85\x98\xba\x61\xce\xb7\xe5\xdb\x5d\x63\xdb\x98\x51\x60\x51\x16\xd7\xfa\xa5\xf8\xcf\xff\xcc\xb6\xcb\x8d\x98\x51\x6b\x53\x1a\xea\x80\x56\xd5\x35\x07\x6a\x51\xbf\x9c\x6e\xba\x02\x78\x7d\xf6\xde\x37\x9e\x97\x9b\xe6\x2a\xe7\x2f\x96\xfa\xe9\x5e\xcc\x76\xce\x65\x7b\x92\xfe\x42\xbc\xc0\x68\x50\x4f\x92\x8c\x67\x48\xa0\x33\x1d\xc5\x9a\xd2\x51\x8e\x40\xbc\x00\xa6\x30\x11\x8e\xc5\xc3\xbe\x80\xaf\x45\x80\x16\x53\xab\x45\x55\x22\x66\x2d\x83\xb9\x55\xae\x71\x1f\x22\x13\x75\x7f\x24\x95\x61\xf9\xf1\xe3\x99\x1b\x2d\xa4\x90\x91\xf0\x0d\x4a\x46\x4f\x03\x0e\x3c\xf4\xf7\x9b\x01\x75\x53\x83\x30\x7a\x48\xa8\xa4\xc9\x58\x3a\xb4\x60\xde\x0d\x53\x53\x53\x4a\x4b\x83\x85\xb3\x4c\xe0\x71\x53\x5b\xd5\x31\xfb\x5f\x0e\x1d\x06\xce\xbd\x06\x2b\x67\x3a\xb7\xb3\xc0\x79\xe1\x7f\xae\x1f\xbf\x71\xb4\xeb\xdf\xce\xc6\x46\xa7\xf8\x7e\x1a\x6e\xaf\x06\x71\x14\x59\x0c\xf7\x24\x07\x3d\xe1\x19\xe9\x12\xbd\x81\x77\xb9\x0c\x0c\x8d\x63\x18\x4d\x6b\xe0\xaf\x19\x38\x9f\x9f\xb3\x5a\x0d\xb4\x89\x6e\x11\x58\x13\xcd\x60\x98\x4b\xcf\x51\x30\x50\xa1\xbc\x39\x90\xac\x06\x75\xc4\x9d\xbd\x0d\xcf\xa6\x18\x60\x98\x6d\xf3\x01\x2d\x05\xed\x4e\x6d\x06\x74\x49\x26\x03\x80\xea\x47\xcb\xe3\x96\xa1\x40\x6c\x1b\x14\x98\x31\xee\xce\xd1\x46\xf0\x67\xe3\xd2\xd9\x40\xe8\x34\x82\x94\x71\x52\xcf\x25\xc6\x21\x51\xc3\x61\xf1\x8e\xf7\xac\x36\xa3\x6f\xfe\xa3\xeb\x89\x4e\x38\x75\x77\xcf\xb7\x38\x0b\xbf\xda\xcf\x4e\xaf\xdf\x3e\x63\xb9\x16\xe9\x88\x10\xea\xbd\x86\x72\x38\x31\x3f\x36\x2d\x9d\x24\x28\x8f\xcf\x47\x19\x75\x4e\xbb\x5d\xa7\x03\x94\xc5\x4a\x59\x03\x41\x2b\xa5\xa5\xda\x04\xa3\xdd\xee\x23\x08\xcc\xa2\xa5\xf3\x1e\x86\xa2\x1f\xf3\x2e\x7e\xfb\x08\xc1\x27\xa0\x37\x8d\x82\x64\x3f\x80\x61\x64\x6d\x8a\x06\x92\xb6\xf0\x81\x18\x5f\x0b\x05\x39\x3c\x7e\xd0\xfd\x55\xe7\x5f\x62\x02\xb3\x6d\xb1\x31\x43\xae\x19\xf4\x8e\xe9\x8f\x35\x6d\xdd\x11\x9f\x78\xa5\x69\x85\xa5\xc5\xee\xbb\xef\x5f\xc7\xbf\xae\x68\x8c\x4f\x79\xac\xe9\xc8\x90\xc6\xd2\xba\x05\x37\x5d\xfb\xfe\x15\xf1\xf9\x5a\xcd\xac\x39\x2b\x65\x0c\x84\x71\xe2\x78\xc4\x4b\x89\xb9\x10\x06\x08\xd4\x0a\x76\x2b\x65\x32\x1a\x51\x41\x96\x55\xeb\xf6\x70\xf6\x16\x81\xa3\xb3\x85\x57\x9c\x51\xd7\x22\x18\x3d\x59\x70\xb6\xbe\xbd\x59\x79\xd9\xaa\x0c\x1c\x9b\x04\xb5\x3e\x30\xfa\xda\x67\xb3\x4c\xe2\x8d\xcb\x76\x7f\xdc\x17\x71\xed\xb7\xdf\x9c\x8d\xf8\xec\xe7\xf2\x20\xd6\x10\xdf\x02\x86\x91\x66\xa8\x13\x22\x08\xf5\x58\xe7\xd1\x68\x10\xdf\x02\xcb\x71\x11\xc6\xec\x33\x47\x63\x21\x12\x2e\x6d\x08\xf8\x1c\x2c\x03\xb7\x8d\x04\x35\x61\x70\xb6\x0b\x06\xa6\x4f\xbe\x34\x95\xec\x0b\x3b\xa6\x60\x43\x49\xa7\x1e\xcf\xd6\x84\x49\xd5\x28\xd5\x99\x6a\x31\x39\x53\xa5\x91\x8f\x78\x09\x7d\xeb\xbf\xe6\xae\xb3\x76\x5c\x60\x16\x2f\x5a\xc4\x29\xb5\x61\xc7\x23\xaf\x3f\xb1\x60\x18\x79\x04\x1e\xe7\x5e\xac\xea\x04\x62\x4b\xe8\xf9\x06\x0a\x52\x77\x41\x81\x54\x0e\x46\x3a\x5e\x7c\x89\x95\xe4\x80\x6b\xae\x87\x72\x94\xa0\x2c\xb6\x2e\xa6\xd1\xc4\xe3\x05\x8e\x60\x22\x58\x62\x4e\x98\x4b\xcb\x92\x48\x8c\x24\x48\x38\x14\xdc\x12\x4f\x4c\xa7\x0b\x1b\xc2\xf9\x82\xc8\x20\x20\x6a\x68\x7e\x19\x1d\x6e\x60\x49\xfa\x71\xea\xff\x17\x99\xd6\x45\x3e\x7e\x78\x7a\x7b\x01\x02\xba\xac\x99\xc2\xaf\xfe\x6f\xc2\x2d\x7f\xfe\x55\x84\x78\xb9\xf9\x42\x89\x65\x5f\x25\x22\xc2\xd1\x85\x7f\x95\x4b\xd8\xfd\x1e\x18\xa7\x95\x49\xd4\x91\x0c\xc7\x99\x68\x04\xa4\x4b\x40\x7d\xc5\xba\x26\x09\x2c\x96\xe5\x8f\x24\x0c\x72\x51\x5f\x3e\xbb\xd4\x00\xd9\xfa\x5c\xdf\x63\x36\x97\x96\xcd\xd1\xa3\x0c\xa2\x3a\x4f\xdf\x8e\x40\xfd\xc7\xee\xb4\xed\x1c\x8c\xea\x15\xc7\x5e\x67\xbb\xee\xda\x4c\x7a\x7e\x86\xb3\x11\xdc\xd5\x05\xc6\x38\x1b\xc5\x8e\x2e\xa2\x3d\x97\x97\x87\xe2\xb5\xf4\x9e\xc6\xc3\xc4\x21\xe8\x1b\x2e\x93\xfb\x61\x90\x21\x25\x0e\x41\xdd\xfb\xa3\x17\xf9\x53\xcf\x41\xd9\x6e\x80\xb2\x79\xe0\xa9\x2f\xe1\x2d\x4e\xa7\x59\x8f\x79\x3c\x06\x03\x42\x8c\xb3\xeb\xf5\xa0\x5d\xe0\x99\x76\x41\xc3\xeb\xe1\xff\x66\x18\x54\xc3\xf8\x0c\x33\x1b\x5a\x04\xb3\x5a\x2e\xe4\x40\x5b\x53\x49\xb5\x4d\x55\xe5\x45\x79\x64\x6f\x52\x30\xb0\x96\x76\xa1\x14\xe8\x47\xe0\x2b\x52\x24\xfa\x24\xe7\xf0\x70\xec\x92\x48\xf7\x8c\x89\x48\xbe\x0d\x76\x3a\x10\x74\x77\x45\x2e\x99\x3b\x59\xa2\x2e\xf8\x80\xb4\x46\x87\x5c\x7f\x15\x25\x96\xc3\xbd\x77\x97\x31\xda\x7a\xc3\x76\x00\xde\xcb\xe4\x47\x75\x32\x6f\x07\x66\x83\x27\x1e\xda\x55\x0b\xcf\xe9\x48\x9a\x86\x66\xd5\xa8\xc5\x08\xe8\xf6\x93\x5a\x78\xec\x09\x1d\xa7\x43\xf9\x2e\x0b\x0c\x2d\x39\x0b\x67\xd1\x5a\xad\x50\x13\x5b\xfb\x73\x2c\x64\xfa\xed\xfb\x49\x61\xcd\xc4\xd1\x59\xb2\x05\xb9\xf4\x5c\xe9\x3e\xe0\xa1\x25\x05\xf7\x5c\x49\x5f\x31\x01\x49\x30\x6b\xf0\x98\x95\xe3\xa6\x4a\x25\xa5\xd1\x90\xcf\x1b\xaa\xc3\xe7\xb4\x8b\x13\xe0\xec\x8d\xf8\xf8\xba\x31\x17\xe0\xe0\x5f\x50\x07\x58\xbd\x51\x7c\x3f\x5e\x83\xce\x8f\x4f\x1c\x2f\xc9\xe0\xc0\x4a\xe1\x36\x45\xe5\xc6\x66\x33\xc7\xdb\xe0\xa9\xb7\x49\x84\x0b\xad\x82\x41\xd5\x2d\x92\x2d\x81\x54\x00\x3e\xd5\xc8\xb5\x52\x60\x0f\x22\x15\x61\x8f\xbb\x01\x01\xd5\xde\xbc\x4f\xff\xa3\x34\x8f\xff\x18\x1f\x93\x91\x69\x77\x5e\x37\xa8\x8a\x82\x9b\xe5\xb7\xe2\x7a\x19\x33\x59\x1c\x4d\xde\x21\xf5\x7b\xac\x4e\x0f\xf1\xd9\xbd\x5e\x87\xc3\x15\x34\xeb\xc3\x61\x9a\x30\x3b\xfd\x4e\x7f\x3c\x61\x09\x06\xcd\x2d\x42\x30\xe8\x77\x06\xec\xb4\x1f\xae\x9b\x9f\xf6\xb8\x5a\x04\x0f\xe6\x74\xb4\x08\x4e\x87\xec\x45\x67\x50\xd2\xd4\x59\x08\x15\x5a\x9a\x3a\x6e\x90\x19\x12\xe4\x6d\x91\x73\xa1\xe3\x59\xd8\x2b\x69\x75\xd1\xee\x97\x91\xd3\x34\x24\x78\x51\xb8\x3b\x65\xd9\xb8\xfd\xf0\x91\xf3\xd7\xce\x31\x80\x0b\x6e\x1f\xb4\x9c\x1b\x22\xf1\x5b\x9c\x46\xb2\x4d\xc5\xff\xa4\x17\xcf\x07\xd1\x1d\xe2\xb7\xe2\xe8\xc2\xf8\x84\xe0\xdb\x2f\x5d\xd8\x5d\x0f\xfe\xcc\x32\x7b\x7a\x5e\x74\x36\x4a\x74\x2f\x81\x0a\x31\x59\x29\x7e\x73\xd7\x4f\x9b\x65\x2c\xcf\x2f\xa9\xb3\x12\xae\x57\x47\xba\x02\x2a\xe1\x98\x0f\xf1\xdb\xe8\x78\xc6\x6a\x65\x75\x61\x5b\xd8\x96\x2c\x4e\xc4\x5a\x84\x04\xcd\xfb\x7c\x66\x3c\x00\x2d\x85\x3b\x00\x15\x17\xdc\x3b\x0e\xab\x96\x96\xf8\x34\x33\x80\x70\xa9\xfc\x12\xca\x54\x36\x35\xa7\xb0\x40\xd8\x25\x47\x0b\x1a\x0d\x25\x0a\x90\xcd\x87\xec\x77\xa9\xd9\x21\x90\x11\x69\x8a\x74\x8c\x33\xcc\x07\xc6\x45\xdc\xd8\x8a\x4d\x21\x68\x4e\x6e\x14\xcc\xe2\x71\xa2\x69\xff\x02\x61\x21\xb8\xe6\x85\xe9\x5d\xb6\x39\xb2\x51\x79\x67\x6e\xdb\xa6\x5a\x3c\xd5\xf3\xd2\x9a\xc2\xb9\x5b\x67\xe2\x13\xcf\x1d\x71\x35\xde\x3b\xaf\x63\xc9\xec\x17\x57\x2c\x88\x75\x22\xb3\x0e\x7f\x24\xdb\x42\x45\xce\x85\xe9\x2a\x24\x67\x38\x23\x28\xc7\xfd\x9f\xa2\x7a\xfe\x6f\x51\xf3\x79\x1f\x7e\x57\x5a\xf6\xff\x4f\xda\x4f\xa7\x9b\xc4\xdd\x5d\xa3\xef\x98\xfb\x7f\x48\x2b\x19\xd3\x89\xb3\x67\xf4\x11\x17\xca\x9b\x80\xf2\x9e\x84\x3e\x64\x15\x92\x57\x7a\x9a\xb2\xbc\x95\x50\x74\x5d\x11\x14\x36\x5c\x5d\x53\x50\xd6\x2a\x24\x0b\x3c\x3e\x86\xe7\x71\xb3\xdb\xdc\x2e\x04\xdc\x8c\x03\xca\xeb\xa0\x75\x36\x47\x5f\x79\x53\xce\xac\x45\xca\x6e\xde\xcc\xc3\x55\x2a\xaf\x91\x4a\x53\x9b\xd5\x6c\x5f\x16\xff\x3b\xc6\x8a\x3c\x21\x4b\x2e\x9e\x81\x92\x97\x77\x47\x95\x22\xec\x26\xd5\x73\xb6\xae\x85\x36\x6b\x46\x2b\xb2\x59\xee\x41\xd3\xd8\xd5\x1c\xfe\x36\x5a\x83\x9e\xd7\x24\xd3\x7b\x45\x87\x5c\x89\x9d\x7d\xe2\x1d\x3d\xcb\x64\xc3\x75\xf5\x1a\x68\xb8\xa0\x6a\x7f\x0b\xda\x63\x1a\xae\x43\x0c\x9b\x9a\x2e\x71\x52\x1a\x8d\xdd\xc8\x46\x30\x2c\xe8\x63\x7d\xf1\x44\x24\xd8\x22\x44\x1c\x94\xd3\x89\xbb\xd1\xd3\x66\x64\x97\x48\x0e\x34\xb2\xd7\xca\x03\xfb\x42\x4a\x8e\x2d\x5b\x72\x9e\x2f\x99\xba\xfc\x5c\x72\x35\xe4\x22\xf3\x55\x91\x8f\x8e\x29\xb2\xd4\x4e\xb5\xef\xcb\xd5\x9b\x4f\x93\x9d\x0d\xb9\xb6\xfc\xaa\xe7\xfe\x8a\x24\xd8\xba\x8e\xd8\x9d\xa9\x31\x17\x39\xc9\xd7\x80\xcf\xb5\x08\xca\x73\x21\x94\x27\x81\x4d\x4c\x17\xc9\xd5\xf5\x50\x1c\x1f\x67\xd5\x5a\x0b\x0a\xbd\xc1\xa0\xab\x55\x08\x7a\xfe\xaf\x6a\xfa\x01\xf1\x59\x7f\xaf\x7c\xbe\x3f\x26\xf8\x80\x25\xf3\x6b\x8c\x59\x4d\x7b\xe3\x9d\xc6\xe5\x5c\xff\x3a\xf9\xb5\x19\x44\xf0\xeb\xaf\x2d\x6e\xc4\x3b\x2f\x90\xf2\x17\x6f\x40\xbf\x6f\xee\xff\xa3\xed\x3f\x00\xa3\xaa\xb2\xc7\x71\xfc\xde\x57\xa7\xbf\xe9\x3d\x99\x4c\x66\x26\x93\x5e\x66\x48\x42\x80\x90\x47\x20\x85\x22\x35\xa0\x43\x0b\x48\xa4\x8b\x20\x2a\x76\x04\x14\x3b\xc5\xc2\xa2\xb2\x62\xef\x8a\x20\x28\x8a\xa2\xae\xd8\x56\x5c\x75\xd7\xd5\x75\xed\x7d\x8b\xfb\x11\x75\xdd\xcf\x2a\xe4\xcd\xff\xdc\xfb\xde\xb4\x10\xfc\xfb\xfd\xfd\xbe\x3f\x25\x99\x99\x97\xb9\xed\xdc\x73\xcf\x3d\xfd\xc0\xb9\x74\x90\x48\x07\xbb\x8e\x94\x1e\x70\xd0\xda\x2b\x16\xde\xe9\xe2\x41\x6a\x20\xb7\x93\x8e\xb1\x49\x5a\xf1\x01\x97\x43\x54\x51\x53\x73\x4d\x19\xd4\x14\x50\x58\x77\x25\x1b\x24\x88\xd9\xb5\x0b\x8c\x78\x98\x71\xc1\xb6\x8b\x94\x91\x2b\x16\x18\x95\x97\x8d\xa7\x5e\x0e\x64\x73\x22\x5e\xc6\x4e\xf5\x8c\x1e\xed\x39\xf6\x08\xf3\x6a\xff\x56\x22\xcc\x30\xff\xf5\x8c\xee\x7f\x2b\x13\x53\x42\x74\x49\xdc\xcd\x6a\x2d\x8b\xf4\x51\x7e\x06\xbb\x07\xa4\x82\x0a\xb4\x41\x1e\x1b\x42\x66\xa7\xc9\xe5\x32\xc5\xa2\x51\xbf\xde\x8a\x04\x24\x54\x56\x15\x95\x4e\x4a\x15\x51\xa5\xad\x64\x0e\x99\x27\x99\x7b\xcd\x67\x98\x79\x13\x0b\x1c\x04\xeb\xf3\xc1\xa5\x32\x29\x15\x74\x99\xf4\x31\x3e\x46\x2a\x2e\xf3\x12\x1b\x9f\xa4\x96\x66\xca\xa6\x48\x2c\xf0\x33\xcb\x0a\xb7\x59\x62\xd3\x92\xcd\x12\x4a\x64\x5b\x2b\x02\xa9\x56\xcb\x55\xc9\x6a\x1e\x37\x59\x87\x9b\x12\xac\x79\x09\x44\x4a\x99\x12\x9c\xc0\x89\xb6\x19\x4c\x6b\xfd\x04\xbe\xf3\x2e\x4f\xe3\xa5\xe5\xe3\x86\x8e\x63\x2f\x1d\xda\x7b\xfd\x88\xce\x09\x72\xff\x15\x57\x29\x63\xb0\xa3\x67\x61\x47\xc5\x25\xe5\xed\x5b\x1f\xc6\xe7\xe1\x52\xec\x11\x94\x7f\x6f\x37\x28\x6f\x2d\x56\x5e\x5c\xa6\x3c\x6b\x7c\x44\xf9\x90\xc7\x8b\xd7\x6f\x30\x33\xef\x9a\x94\x7f\xab\x3c\x47\x55\xfa\x1b\xfe\x42\xf6\x25\xe0\x38\x68\xfd\x15\x31\x5e\x62\xb3\x59\x91\x35\xee\x8f\xfb\x6b\xeb\xac\xd6\x68\x55\x15\x3b\x31\x55\x65\x2d\xf1\x18\xa2\x86\xc9\xa9\xe2\xa8\x3b\xe3\x68\x95\x65\x01\xf3\x5c\xa0\x35\xc7\xcc\xfc\xd2\x31\xcd\x43\x28\xe6\x89\xf4\x43\xcc\x49\x8f\x59\x24\x57\xb5\xb6\x84\xe3\xce\xdb\xf7\xc8\xa3\xaf\xad\xe8\x6a\x19\x71\x7e\xc8\x60\xfd\x83\xd5\xd4\xdd\x33\xa6\x6f\x0d\x66\x57\xbc\x79\xed\xcb\x2d\xfc\xc8\xdf\xcc\xbb\xe3\x81\xbb\xf0\xf4\xa3\xb8\x0c\x37\x33\x81\x87\xf6\x6c\x54\xbe\xbc\x76\xe5\xd9\x2b\x7a\x5e\x19\x31\x7b\xf6\xd8\x03\x73\x7b\xbf\xbf\x7d\xc7\x77\x97\x3d\xd8\x3b\xe1\xe0\x93\xcf\x61\xeb\xf5\xdf\xd0\xb8\x4f\x52\xaf\xa4\x82\xfa\xfd\x86\x80\x6e\xac\x92\x5b\x7d\x66\x43\xb0\xc8\xca\xd9\x6c\x7a\x36\x1a\xf1\x70\x6e\x37\xc7\xe9\x4b\xf4\x66\x64\x46\x40\x43\x8a\xac\x45\xc0\xcb\xdb\x1c\x36\x10\x4c\x3c\xb0\xe2\xa0\x01\x84\x59\xd6\xe0\xd6\x73\x94\xa5\x0a\x0c\xf0\xc9\x54\x93\x7d\x1f\xe7\xfb\xad\x7a\xcf\x7b\x34\xcf\x54\xc4\x6b\x58\x4b\x38\x2b\x14\xd3\x94\x30\x1c\xe1\xae\xe0\x06\xe1\x87\x94\xc5\xd9\x28\x5f\xa1\xbc\xa1\x7c\x30\x6c\x81\x49\x29\x33\x2d\x1d\xf6\xf6\x9f\x70\x03\x2e\x4d\xce\x37\xe2\xbf\x1a\x97\x27\xf1\xfd\xc7\xf0\xdc\xa9\x1b\xaf\xbb\x8b\xf9\xe1\xd4\x49\x97\xe2\x46\xa6\xf2\x27\xe5\xa3\xa0\xf2\x18\x41\x6d\x3c\xc1\xf1\xfc\x93\x47\x71\x1c\xc4\x4c\x2a\xb6\x7f\x50\xd1\xff\xc9\xea\x1b\x1d\xcc\xcf\x81\x7f\x3b\xcf\xb8\xc5\xd5\x6f\x19\x45\xce\xe5\x67\xe9\xaf\x98\x2f\xd8\x07\x11\xcc\x53\xf6\x1b\x91\xc9\x64\x31\x9b\x1d\xbc\xdd\x66\x01\x5e\xd1\x05\x9c\x3e\xd2\x09\x3a\x81\xfa\xda\xb6\x01\x13\xd3\xa6\xe5\xf6\xcb\x1c\xbe\x58\x46\x57\x94\xbd\xf8\xf0\x29\x8d\xb7\x4c\xa3\x36\xff\x09\x67\x36\x2c\xc1\xe6\x6d\x67\x1b\x95\x2b\x5f\x5d\x72\xbe\x01\x4f\xb9\x72\xd2\x64\xa6\xe7\xd8\x23\x6a\x2d\x2e\x18\x97\x6d\x01\x1e\xcc\x86\x86\x0c\x32\x2e\xca\x1b\x97\xd8\xae\xfe\x4f\x07\x3e\x88\xcd\xff\x2c\x18\x98\x6b\xfa\xf9\xb0\x97\xe4\x2b\xfe\x4c\xe9\x64\xfd\xb0\xde\x62\xd4\x2e\x97\x48\x7e\x93\x29\x10\x10\x50\x30\x58\xe2\x0c\x05\x24\xbf\x24\x79\x5c\x1e\x97\xdd\x2d\xe8\xf5\xcc\xa4\x94\x3e\x97\x47\x96\xcc\xc1\x96\x6c\xcb\x64\x97\xcc\x08\x2e\x7c\xa1\xe7\x8a\xa3\x70\x52\x02\x53\xaa\x5a\x8f\x46\x2f\xba\xf1\x1a\xb6\xa6\x10\x2e\x7b\x2d\x7f\xa4\xd6\xa2\xab\xae\x71\xc4\x71\x32\x0f\x3e\xba\x6e\x4a\x2f\x3f\x50\x26\xb0\xd5\xec\x21\x80\x4f\x42\xf6\xf1\x0e\x0d\x42\x76\x2b\xc0\x47\xb4\x4a\xe6\x00\x00\x48\x47\xdd\x34\x28\x70\x72\xa1\xb1\xc9\x5c\x45\x48\xea\x92\xa1\x51\xf9\x02\x57\x8c\x27\x94\x1f\xbe\xa0\x2e\x18\x9f\x66\x5c\x30\x8e\xfe\xc4\xf3\x74\x5f\x90\x07\xe0\x43\x7c\x46\x88\x95\x39\x2a\x78\x3c\xe1\x22\x3b\x42\x16\xa3\xb1\x04\xde\xd8\xfd\x7e\x97\xd5\x67\x25\x73\xb0\x4a\xfc\x00\x18\x69\x90\xb2\x15\x18\xd2\x35\xa5\x54\xbe\xd5\xad\x39\xcb\x2e\x64\x26\x28\xe0\x40\x06\x4e\xca\x9f\x4d\xbf\x25\x33\xf3\xe4\xcd\x76\x8d\x06\x29\x62\x57\x63\xd7\x7a\xdb\x7f\x9f\x99\x74\x7f\x6f\xb7\xaa\xff\x58\x02\x87\xb9\x01\xe6\x2c\xa1\xb8\xec\x10\x75\x3a\x03\xdc\x2e\x56\x9b\x99\x23\xd1\xf8\x66\xab\x9e\x5c\x8a\xc9\xfc\xd2\xcc\x19\xe9\x3a\x4f\x7e\x36\x10\xf9\x79\xe8\x4c\xc7\x52\xe5\x87\xd3\x4a\x3f\x7b\xa6\x6f\x24\xf3\xc7\xd3\xbd\x57\x9f\xd5\x7f\x1f\x33\xf4\x77\xaf\x39\x60\x8c\x29\x20\xaf\xac\xa5\xf6\xa2\x46\xd9\xef\x32\x5a\x2c\x02\xcb\x7a\x7d\x46\x41\x2f\x4c\x4c\xe9\x03\x2e\x17\x42\xb6\x49\x39\xcb\x6f\x5d\x5b\x61\x6e\x25\xcd\xf8\x9b\xf1\x6d\x6e\xca\xa9\xcc\xb1\x7c\xd3\x3d\x86\xdb\xd5\xc3\x7d\xaf\xb1\xb6\x3c\x0e\x80\x28\xef\x60\x5f\xdc\x7a\x5d\xfd\xb0\x63\x2b\xc8\xc1\x65\xf7\x74\x96\x75\x4d\x20\x10\x20\x32\x39\x09\x94\x7a\x9e\xde\xa3\x41\xb4\x58\x6e\xc2\xb0\x1b\x8c\x8f\xf1\x7a\x59\x56\xaf\x43\x36\x9b\xd3\xa2\xb3\x14\x15\x5b\x7d\xf0\x6c\x52\xca\xe7\x13\x8c\x46\xef\xa4\x94\x11\x2e\x54\xa3\x64\xd3\xb1\x02\xd0\x68\xc1\x85\x28\x97\xa0\xd1\xe6\xfc\xac\x04\xc7\x87\x1e\x6b\xd9\x3b\xe1\xda\xc9\xdd\xae\x25\xb0\x0e\x87\x47\xc4\xd4\x57\x89\xc4\xd5\x2d\x79\x6a\xe8\x90\xd3\x4d\x4a\xcc\xb4\x60\x63\x9f\x09\xbf\x8d\x17\x7e\x73\xcf\x22\x93\xf2\xe9\x49\x7d\xc5\x23\xc3\x67\x5c\x84\xd7\x29\xef\xd1\x9b\xf6\x27\xf7\xe8\x7f\xff\x61\x82\xf2\x34\x70\x38\x0f\x4d\x1a\xa7\xdc\xb9\x84\xea\x18\x9e\x03\xbe\x60\x09\xac\x87\xd4\x0b\x5d\x26\x37\xdb\x7d\x36\x9b\xdf\xc1\xb2\x82\xdf\x6f\x32\x3a\x19\xc6\x25\x18\x85\x62\x90\xc1\x58\x9f\x9d\xd4\xb0\xb0\xdb\xf5\x16\xc6\x46\xf2\xd1\x93\xaa\x51\x7a\x3f\x20\xa0\x11\xe0\xef\xca\xcb\x6b\x65\xcb\x88\x60\x64\x5d\xc7\x15\x74\xcc\xea\x1c\xb0\x84\x89\xc2\xde\x4a\xea\xff\x67\x74\xdf\x98\xcd\xac\x89\x5b\x62\x3a\x43\xf9\xe8\xa4\xd1\xca\x30\xa5\xd2\xb4\x7c\xe3\x2c\x13\xfe\xd0\x74\xf6\x90\xa1\xb8\xfd\xe0\xe4\x39\xe1\x91\xc5\xe7\x9c\xcb\x3e\x04\x14\xf5\xe9\xe0\xea\x4e\xe5\xe5\xd1\x6e\xe6\x27\x4a\x60\xdf\xc3\xeb\xfa\x6f\xe8\x1c\xa9\xdc\x79\x1a\xcd\x5b\xdd\x49\x63\x1a\x1a\x49\x4c\x83\x60\xb3\xd5\x95\x96\x05\x4c\xa8\x14\x35\x35\x07\xea\xd8\x68\xb4\x7a\x62\xaa\xbc\x3c\x6a\x35\x1a\x25\x49\x37\x89\xc4\x34\x78\x89\xb3\x0a\x9b\x4d\x0d\xab\x61\x51\xb2\xee\xf8\xa8\x06\x2d\xa6\x21\x12\x2f\xb4\x66\x37\xff\x8a\x98\x86\xc3\xaf\x45\x03\x79\x06\xed\x11\xbf\x1c\xcb\xb0\xfd\x6e\x7c\xd9\xb0\xec\xd1\xc3\x3d\xbf\x10\xc6\x80\x95\xff\x00\xbd\xea\xa1\xbe\x1e\x43\xe5\x20\x63\x30\x18\x8d\x3e\xab\xd7\x1b\x2c\xb2\x00\x1b\x64\xb3\x59\x02\x2c\x8b\x68\x1a\x32\x8c\x0a\xd6\x86\xf3\x74\xd7\x38\xe7\xce\x31\x80\xcd\x1e\x89\x99\x7d\xb3\xc6\xc4\x65\x93\x2b\xd2\x3c\xc6\xf9\x4a\x01\x77\xfd\x62\xc9\x9f\xf8\x3b\x5c\x1f\x9d\xee\x5d\xbd\xe6\xe8\xe6\x0c\x47\xcd\xad\x7a\xe6\x00\xa5\x0d\xd9\x79\x45\xd0\x38\xb9\x4c\x6f\xb3\xd9\x5d\xae\x00\x07\x73\x89\xc6\x7c\x25\x24\x30\xd5\x17\xa0\xde\xa5\x06\x11\xdb\x19\x0c\x67\xc6\x85\x5d\xd9\xc8\x75\x2d\x4b\x6f\x6e\x9e\x19\xf0\x27\x89\xb2\x2a\xbf\x30\xb0\x98\x33\x9c\x64\x26\x3d\x61\xbd\x63\xfd\xfd\x25\x7f\x7a\x2a\x37\xef\x5d\x57\x3a\xae\x10\x73\x73\x1f\x3a\xcd\xb1\x98\xfd\xdd\x33\x07\xd4\xb9\x1f\x2b\x5e\x1c\x57\x67\x7f\xe9\x1a\x42\xd3\xf4\x80\x3f\x1b\x69\x6c\xdf\x08\xb9\x48\x24\x45\x0c\xbc\x76\xb3\xb9\x34\xe2\xf5\x6a\xbe\x11\xa2\xa6\x25\x29\x24\x39\x2a\x9b\x95\x07\xd3\x42\xc3\xa4\xc8\x0e\x44\x9a\x26\xe0\x3d\x34\xa2\xd3\x07\x94\x68\x75\xbe\xc3\xc3\x99\x46\xe6\x90\x4a\x79\x08\x35\xea\xbf\x20\xcf\xc1\x81\xb9\xac\x53\xf5\xe7\x95\xe1\xbe\x20\xf0\x0d\xa3\x2a\x34\x47\x4e\x44\x8b\x8b\x43\x21\x83\xdd\xec\x35\x1a\x19\x52\x84\xbe\xc2\xeb\xad\x0e\x94\x4d\x49\x19\x8b\x8b\xa2\x66\xbb\x10\x08\x00\xf5\x29\x9d\x9a\x72\x05\xad\x01\x35\x82\x14\x6b\x4a\x94\x0c\x97\xe8\x69\xa9\xca\xf3\x44\xb3\x65\x15\x51\x85\xe8\x21\x88\x6e\x4f\xa4\x2c\x53\x8b\x9e\x1a\x7d\x60\x3f\x70\x82\x64\x85\x24\xd8\x9e\x8f\x2e\x07\x02\x73\x8b\xb8\xd3\x0d\xc6\xb6\xab\x67\x5d\xb1\xfd\xa9\xcd\x8b\x67\xe8\x9e\x2c\xf9\x53\x7f\xcd\xed\x13\x47\xcf\x4d\x9d\xd6\x9a\xc5\x9d\x37\x6e\x5d\x33\x7d\x41\x5b\xb0\x2e\xb1\x6c\xfe\xaa\xed\xc9\x28\x57\xfc\xcc\x81\x9f\xaa\xb6\x56\xc9\xf5\x91\x0a\x5a\x1b\x37\xfd\x0d\xe3\xe7\xd6\x21\x3f\x89\x75\x71\xd9\xbd\x5e\x9b\x09\x6e\x19\x89\xb5\xd9\x02\xc1\xac\x2b\xa5\x60\xa3\x05\x76\x6c\x70\x8c\x07\x31\xb8\x25\xb3\x15\x4f\x48\xe6\xfc\xac\x9b\x00\xe0\x8e\xc4\x44\x48\x1c\x01\xbd\x17\x48\x49\x9d\xa1\xdb\x46\x0e\xa8\x4d\xd4\xc0\xb1\xfe\xce\x58\x0d\xa9\xa3\xa3\xf0\x34\x5a\x17\xf7\x4f\x2d\x4b\x24\xe9\xfd\xa7\x53\xba\xb5\xd8\xe3\x0e\xb9\xd4\x62\xb3\x19\x9d\x1e\x07\x5c\x16\x40\xfc\xfd\x01\x8b\xc7\xe9\x01\xba\x29\xdb\x9c\xd2\x71\x5c\x4d\x41\x4d\xa5\xac\xea\xf2\xb8\xfb\x3a\x57\x47\x09\x9b\xf2\x2f\xea\xec\xf4\xee\xb0\xbc\x99\xbb\xa1\xcf\xa0\xb3\x3b\xb6\xaa\x5b\x95\x1b\x5c\xe9\xbf\x71\x1d\xd4\x76\x19\x45\xe7\xca\xad\x9e\x88\xdb\x1d\x0c\x92\x18\x3b\x93\x37\x2c\x8a\x3e\x1f\x03\x94\xc1\x6f\xf2\xc7\xca\x7c\x52\x84\xb1\xda\x40\x24\x0f\x78\x6c\x36\xc1\xa5\xea\x27\xc4\x62\x7d\xf1\x94\x94\xde\xad\x5d\x5c\x05\x1e\xc5\xf9\xc1\x1b\x59\x42\x9f\x57\xc2\x3b\x2f\x7a\x03\xab\xfa\xcb\x4c\xfd\x98\xe6\x8c\xae\x39\x0c\x5c\x1a\x56\xeb\x95\x85\x05\xae\xc3\x31\x7b\x58\xb6\x7c\x8c\xc1\x3f\xd7\x31\xb7\x85\x68\x63\xc6\xe1\x93\xc6\x62\x43\x77\xff\x39\xc4\xe0\x61\x51\xf6\x96\x30\xce\xc5\xca\x2e\xb5\x7c\x8c\x6d\xfc\x8d\x8b\xf1\x48\x6f\xbb\xb2\x18\x6f\x57\x16\x2b\x87\xe6\x6f\x9e\x3e\xe5\x31\xba\x27\xa5\xe9\x6f\xb8\x53\xa8\xcf\xe6\x1a\x79\xb4\xc3\x2c\x09\xd6\x58\x30\x50\xe4\xb3\x06\xd8\x38\x1b\xaf\xac\x0a\x99\x03\x66\xcc\x9a\x2d\x11\x9d\xa4\x0b\xe9\xde\xd0\xb1\x0e\x5e\x67\x09\x58\x05\xeb\xc4\x54\x0c\x09\x56\x61\x8b\x70\x9b\xc0\x99\x58\x21\x68\x91\x90\x3b\xcf\xda\x74\x08\xc4\xc4\x84\x7a\xcd\x11\x27\x05\xf2\x32\xc7\x56\xa8\x6b\x54\x95\x35\x9a\x29\x90\x18\x70\x33\x05\x90\xf2\x92\xa1\x38\x32\x45\x03\x44\x52\x70\x10\x7f\xf2\xf9\xfb\x87\x0f\x5b\x3c\xe3\xc6\xb4\x37\x8f\x6f\xc5\x8f\x4e\xe8\x5d\xb9\x60\xd6\xba\x2b\x57\x97\xe2\x47\x4b\xc6\xfb\x46\x0f\x9d\xe8\x01\x16\x4d\xf9\xdc\x79\xd7\x5d\xbb\x5f\x2d\x1a\xce\xe8\x66\x60\x41\xf9\xbd\xf4\xec\xc6\x45\xcb\xf6\x3d\xba\x71\x38\x6e\x52\x7e\x9e\xa1\x63\x86\x37\xff\xfd\xbd\xaf\x54\x7e\x6c\x01\xc8\xd2\x07\x81\x76\x95\x02\x8f\x1d\xd6\x9b\x4c\x82\xdd\xc7\x96\xb0\x25\x91\xa8\xcf\x57\x54\xe4\x22\x69\x73\x74\x02\xad\x77\x20\xe5\xe2\xde\xf3\xdd\x11\x34\x71\x49\x55\x27\xf2\x79\x46\x27\x35\xb7\x89\x2d\x43\xd3\x32\xb9\xc4\xf1\xc3\x77\xdc\xa7\xeb\x99\x69\xc2\xcb\xce\xe2\xbb\x5a\x77\x3e\x55\x51\x1b\x0c\x36\x8e\x0f\x0f\x1d\x19\x5b\x7e\x9a\xf2\xb5\xf3\xe6\xeb\x82\xa3\xf0\x87\xde\xf6\xfe\x15\x81\xa2\xb6\x11\xb8\x12\xb3\xcb\x4e\xb1\xf5\x3e\xe7\xd2\x5f\xbd\x5d\x79\x5a\xd9\xa4\xfa\x57\x7c\x0a\x7c\xd5\xe9\xec\xf3\xc0\x57\x35\xca\x3e\x2b\x30\x07\x26\xc2\x4d\xb9\x78\x93\xc9\x89\x25\x2b\x02\xa1\x0f\x21\x83\x2b\x9b\xb9\x3d\x3f\x7f\x13\xe5\xef\xc2\x46\xd5\xf3\x05\x68\x14\xd1\x9d\xe0\x24\xb0\x48\x4c\xd3\x8d\xaf\x95\x94\x96\x27\x4c\x5f\xfb\xa7\xe1\x7d\x17\x1c\x6e\x35\x32\x9b\x94\x97\x12\xa7\x96\x94\xd5\x18\x47\x79\xca\x67\x5f\xc2\xdc\x7d\xec\x26\xaa\xd4\xc7\xe9\x2f\x10\xe2\xdb\xd8\xe7\xe0\x0c\x4f\x97\x2b\x8d\x06\xa0\x0b\xc0\xef\xc3\x29\x71\xb3\xa2\x5d\x92\xfc\x40\x2d\x45\xbf\xc3\xed\x36\x98\x5c\x2e\xde\x6c\xb0\xd2\xe2\x99\x76\x3e\x37\x21\x1a\xa9\x46\xfe\xcf\x4d\xcc\xd3\x92\xa7\x26\x69\x76\x86\x70\x76\x6a\x74\x76\x80\xfa\x11\x32\xe9\xdb\xe4\xa8\xe9\xc7\xd0\x68\x7c\xdd\x9a\x45\xb8\xfc\xb2\x07\x27\x1b\x95\x37\x2f\x56\x5e\xeb\x5b\x79\xb7\x33\x7a\x77\xa7\xc3\x38\xca\xdb\x92\x5a\xc5\xdc\xdd\xff\x15\xe3\x3f\x76\x33\xf0\x6e\xd7\xf5\x1f\x66\x86\x28\xef\xc4\xce\xcb\xc2\x8d\x1b\xc5\x2f\x04\xfa\xdf\x25\x47\x3c\x76\x3b\xdc\xf3\x06\x83\xdb\xe1\x28\x8d\x04\x10\x2a\xa5\x5a\x55\xb7\xdd\x23\x96\x50\x17\x49\xb1\x04\x26\x9c\x29\x0a\x91\x54\xd3\xf5\xe7\x91\x7a\x95\xce\xc7\x61\x8a\xf9\x65\x6b\x54\xf7\xf8\x3c\xf0\x86\xa6\xe0\x27\x06\xf8\x15\xbf\xd3\x6a\x54\xde\xda\xbe\xcf\x5f\x46\x81\xdd\x96\xda\xc0\x1c\xce\xf9\x12\x1f\xbb\x1f\xa6\xbd\x56\x79\xbb\x7a\x49\x88\x02\x9e\xce\x9b\xe4\x7d\xbb\x95\xf2\x9d\x29\xb9\xda\x4c\x32\x6e\x08\x3c\x2f\x5a\x1c\x0e\xb7\x49\x14\x5d\x6e\xa7\x60\x36\xb3\x7a\x87\xc5\x42\x4a\x05\x81\xb8\xa3\x97\x78\x94\x35\x6b\xe5\xc4\xfc\xbc\xd9\xe7\x5c\x2a\xb2\x72\x4f\x41\xb9\xa0\x80\x66\xb9\xc6\x7f\xbc\xc8\xd8\xff\xb3\xf1\x82\x86\x1d\x8b\x8c\xf8\x8f\xc6\xc9\x4b\xff\xd2\x6d\xc4\x31\xe3\x6c\xe5\xf5\x99\x54\x6a\x77\xe2\x2f\x3d\xed\xed\x1e\xe5\x6e\x3c\x8b\xbe\x16\x67\x62\x44\x3b\xd9\x14\xcc\x37\x02\xf8\x51\xe5\x0e\x87\x71\xd0\xc1\x1a\x8d\xd1\x98\x59\x8f\x71\x34\xa0\x7a\xf7\x04\x4d\x9c\x81\x03\x76\x58\x6f\x90\x18\x33\x36\x4f\x4c\x39\x0a\x99\x99\x81\xb1\xa2\xaa\x2c\xab\xb2\xf8\x15\x05\x15\x38\x32\xe1\xd8\x85\xcc\x02\x5e\xa9\xcc\x18\x90\xf9\x46\xad\x40\x73\x8a\x35\xef\x5e\xc8\x4b\x80\x43\xea\xd0\xac\x1b\xdb\x91\xbd\x1c\x80\xdf\x3f\x94\xbe\x80\x75\x68\xf7\xc1\x7c\xb9\xa1\xd8\xed\xe6\x74\x3a\x7d\x29\x42\x46\x87\x23\x56\xe6\xb2\xe9\xf5\x31\x5f\x70\x22\x88\x2e\x7a\xbb\xd3\x64\x07\xd0\x03\xcb\x26\x15\x1b\x5c\x7a\x17\x08\xbe\x1c\xe1\xf4\xd5\x28\xb5\x64\x41\x9d\x91\xaa\xc2\xfc\x42\xf6\x9c\xfd\x5a\xa8\xc2\x82\x18\x69\x2e\xcc\xe5\x43\x09\x87\x58\x2a\xaa\xec\x32\xcb\xac\x9e\x7b\x38\x56\x3a\xb7\x53\x39\x38\x60\x75\x15\xe3\x6f\x9d\xdf\x36\xee\x81\xbe\x05\xdb\x1b\x5b\xa3\x6f\xcc\x5d\x25\x77\x5c\x96\xb7\xba\x0d\x57\xf7\x08\x7b\x87\x24\x23\x95\x64\x7f\x48\xde\xde\xed\xb0\xae\x62\x34\x43\xae\xd2\x07\x02\x1e\x1f\x20\x90\xe4\xf1\x84\x4a\x5c\x2c\x1b\xb2\xf8\x7c\x66\xb2\x28\xe4\xf6\x5a\xdd\x40\xe3\x5d\x2e\xb7\x44\x8c\x48\x83\x94\x4c\xc9\xee\x4f\x96\xba\x68\xee\xba\x83\xd9\x8d\x32\xa5\x76\x04\xee\xd9\x41\xec\x45\xdd\x09\x56\x38\x91\x99\x88\x54\x46\xc9\x9a\x87\x60\x5f\xbe\xd4\xe6\x6f\x40\xf5\x24\xf3\x86\xd9\x6e\xac\x2d\x2d\xf5\x54\xb3\xc5\xc5\x80\x65\xd5\xd5\x0d\x89\x4a\x9d\xc7\xd3\x50\x13\xab\x8a\x4d\x4c\xf9\xf9\x29\xa9\x48\x6d\x6d\xe9\xc4\x54\x90\x35\xdb\x39\x7f\xad\xbf\xd6\x59\x55\x59\x59\x25\x39\xd1\xd4\x94\x93\xb0\x76\x6d\xda\xaa\x6c\xb4\xd6\x01\xe1\xe9\x32\x9e\x65\x05\xfb\xa4\x2d\x92\xe6\xf0\x72\x00\xcf\xac\x71\x6f\xd8\xa9\xb2\x77\x42\x96\xbb\x1b\x6c\xd1\xaf\x4f\x5a\x53\xd1\x31\x3b\x75\xda\x08\xe6\xf2\xf5\xc0\xe0\xe9\x4c\x1b\x1f\x53\xf9\x3b\xdb\x19\x67\x1d\x0f\x02\xe5\xf5\xf6\x89\xd5\x72\x7d\x69\x25\xbe\xe1\xe9\x3b\xa7\x2d\xa8\xaf\x9a\x4f\xf9\xbc\x31\x15\xeb\x2e\x2a\x04\x08\xa9\xdb\x03\xb4\x61\x1f\x4f\xea\xf6\x74\xcb\x11\x58\x76\xb1\x3f\x10\xb0\x72\x2c\x5b\x54\xec\xe7\x38\xec\xb4\x5a\x9d\x4e\xe3\xa4\x94\x13\x07\x58\x0c\x1c\x38\x3e\x51\xd0\x70\x2e\x69\x0b\x39\x5e\x03\x43\x9a\x33\x4e\xa2\x22\xeb\x61\x96\x92\xe4\x75\x33\x57\x6c\xbe\x71\xc2\xd8\x96\x53\xab\xc7\xa4\xea\x26\x1e\x9a\xfa\xcc\xab\x1f\x3c\x35\xe9\xde\x71\x7e\x86\x35\xdb\xbe\x78\x75\xe3\xb5\x35\xc5\xb7\x63\x43\x71\xe5\x93\x8f\x1e\x52\x3e\x68\x52\x64\x3f\xdc\xb3\xc0\xfd\xb1\x87\x61\x9e\x01\x90\x6d\xa2\x40\x6e\xdd\x2e\x17\xab\xd7\x93\x00\xec\x60\x11\x72\xb9\x04\x9f\x3b\xe0\x0b\x4c\x4a\xf9\x5c\x82\x85\xf8\xa7\x93\x22\xa1\x39\xe9\x52\x0d\xf3\xcc\xa5\x68\xc8\xaa\x46\x88\xec\x88\x72\x8e\xe1\x02\xf1\x1e\xf2\xa8\xe2\x3f\x96\x97\x9d\x85\x75\xff\x9a\xf1\xe5\xf0\xba\x94\x61\xd6\x69\x67\x5f\x31\xee\x0e\xfd\x4c\x35\xf5\x1e\x13\x8d\x3e\x75\x0d\x66\x70\xa0\xd6\xaf\xfc\xe7\xf6\xf1\xe9\xf7\x56\x5e\xe8\xc3\xfd\xfd\x24\xe9\x1e\xa5\x5f\x87\xd2\x9f\xb1\x73\xa8\xbd\x1d\x78\x54\xb7\x0b\x66\xeb\x72\xe9\x49\xa8\xb8\x3e\x18\x70\x93\x30\x3f\x32\x61\x2f\x12\xa8\x30\x26\x64\xe5\xe0\x4c\x5e\x05\x4d\xf3\x96\x57\x3c\x88\x08\xef\x28\xe7\x4b\x6f\xa7\xd1\x27\x5a\x52\x85\xc9\xcb\xce\x52\xfe\x7b\xdc\x34\x49\xa6\x64\x76\x09\x4c\x53\x51\x94\x2f\x6b\xfd\xd8\x70\xfb\x78\xa4\xce\x93\x61\xb3\xf3\xfc\x5a\xe9\x60\xf7\x00\xef\x12\x40\x95\xb2\xcb\x67\x30\x04\x8b\xec\x0c\x13\x14\xcd\x93\x53\xa2\x15\xb9\xf2\xeb\x33\x65\xcf\x28\x4c\x06\xa8\xa3\x1f\xd3\x4a\xe2\x22\x01\x99\x41\xe3\xb4\x88\x03\x24\x3e\x5b\x39\x73\xf5\xb3\x3f\x6e\x9d\x78\x63\x7d\xe5\xa2\xbe\x19\xb7\x6c\x98\x71\x41\x5f\x62\xfe\xf8\xa2\xd6\x17\x94\x0e\xbc\xec\x29\x7c\x07\x8e\x5f\x57\x11\x99\x1e\xbb\x4a\xf9\x5a\xd9\x78\xee\xca\xf5\xd6\x40\x67\x55\xb3\x9a\x97\x50\xab\xef\x8e\x8c\xc0\x15\x54\xa0\x61\x72\xd0\x81\x04\xa1\xd8\x54\x56\x5c\x56\x59\x05\x1b\x5d\xea\x2f\x85\x4b\xb5\x94\xf3\xbb\x49\x41\xed\x42\x77\x8b\x2c\x3b\xac\x56\xce\x76\x66\x8f\x92\xbb\xb9\xa0\x60\x3b\xce\x95\x75\xa7\xc1\x09\xec\xc6\xd4\x28\xd5\x8f\xe2\xaf\xb9\x5a\xed\x4a\x28\x53\xce\xfd\x1e\x8c\x37\xbd\xaa\xdc\xc9\xdc\x21\xcf\xa4\x4e\x18\x8b\xf3\xaa\xb4\xf7\xf7\x6a\x85\xdc\xe1\x85\x94\x75\xa7\x6b\x48\xbf\x05\xbf\xee\xa2\xfa\xaa\x00\xdc\x5d\xa7\xca\xc9\xa0\x27\x12\x31\xe9\xbd\x5e\x96\x71\x4a\x52\x09\xa3\xd7\x47\x63\xa6\xa0\x27\xe8\x99\x98\x32\x05\x83\xaa\x67\x2e\xe2\x23\x2c\x0f\x1c\x3f\x2f\x65\x83\xf2\xf3\x91\xb6\x37\x13\xbb\x4e\x70\xb7\xa5\x30\x3a\x39\x9b\x41\x5b\xf3\xc9\xa4\x11\x3b\x11\x92\x05\x8a\xa8\x75\x58\x4a\x3e\xab\x70\x9d\x69\x01\xd1\xe9\x5c\xf7\xd7\xe7\x37\x5c\x83\xfb\x97\x7f\xf3\x2c\xb6\xed\x9e\xda\x9a\x5c\x77\xcd\x0f\x6d\x73\xfb\xae\x6f\x24\x66\x21\x6f\xfb\xbc\x85\xa7\x5e\xe8\xd3\xb9\xee\x5b\x05\x04\x62\xc8\x06\xe5\xce\xd5\x78\xcc\x69\xf3\x2f\x50\x6d\x43\xff\x64\x67\xb2\x87\xa8\x5f\x69\xa7\x5c\x5e\x22\x51\xbf\x52\xb6\xa2\x42\x0a\xb2\x35\xb5\xb6\x50\x9b\x65\x92\x65\xad\x65\xb3\x65\xa7\x85\xb7\x58\x7c\xdd\x02\x16\xca\xac\xc8\x47\x75\xe8\xc9\x39\xc4\xb9\xb4\x25\x97\x4f\x27\x99\x29\x62\xab\xea\x04\xa9\xaa\x86\xdc\xb8\x34\x99\x0e\xf9\xa0\x71\xf1\xd4\xf5\x42\x73\x2b\xc7\x67\x11\xe7\xd2\xd5\x57\x2f\x4c\x9d\x26\x17\x3a\x97\x8e\x9e\xa3\x3a\x97\x7e\x48\x7c\x4b\x47\x24\x35\xdf\x52\x7e\xc8\xf1\xbe\xa5\xca\x7b\x3b\x33\x3e\x88\x7c\x03\xf7\x57\x54\x4b\x6a\x26\x96\xb0\x65\xf1\x78\xb5\xa5\xde\x5d\x53\xcd\x56\xd7\xd5\x9b\x9c\xc0\xf9\x98\xaa\xe3\x15\xf1\x89\xa9\x8a\x0a\xe0\x40\x83\x93\x52\x5e\x38\x06\xd1\xfc\x30\x9d\x9c\x2b\x62\x5e\xd4\x78\x32\x17\x8e\x9b\xf5\x48\xf4\x64\x14\x26\x44\x25\x25\xb2\xff\x7f\x9c\x13\x2f\x3e\x29\x7c\xff\x86\x8b\xc7\x57\xb5\xf3\x52\x7b\xe5\x35\xe1\xa1\xdd\xe6\x5f\x70\x53\xf4\x6c\xba\xb5\xf8\xdf\x57\x7b\xfc\x07\x95\x97\x06\x71\x56\xa4\xe7\xfa\xcf\xc0\xa7\x3e\x46\xf9\x8e\x55\xf2\x70\x0b\x36\x9b\x19\x46\x27\x4a\x08\x08\xbb\xd5\xed\x12\x5d\xc1\x22\x0b\x06\x11\xde\x12\xb4\x00\x06\x5a\x2c\xbc\xc1\x65\xb5\x9a\x75\xc4\xaa\x6a\x37\x48\x01\xb7\x5b\x64\x78\x06\x2e\x70\x3e\xc3\x4f\xa9\x0e\x5c\x39\x16\x30\x83\x95\x03\x5d\xe8\xb4\xec\x2f\x39\xed\x69\x5e\x16\x01\xfa\x8c\xf9\x97\x72\xeb\x88\x59\x46\xa5\x49\x35\x51\xbe\x66\x5c\xd0\x82\x4f\x6d\x51\xdf\xc1\x03\xa5\xd1\xb8\x00\x3f\xac\x3c\xac\xda\x2a\xe9\x8a\x7e\x47\x04\xce\x76\x6f\xbf\x8e\xfc\x26\x67\x4c\xb9\x44\xe9\xa4\x31\xd5\xa4\x6e\x53\x1c\xcd\x96\xeb\x83\xa5\xa5\xac\xc8\x71\xac\xcb\x66\x23\x8e\x5a\xe5\x15\xc0\x8c\x94\x87\x62\xd3\x52\x21\x24\xba\xad\xee\xc9\x29\xce\xea\x32\xd8\xa7\xa6\x0c\xc1\xac\x9f\x30\xf2\xe6\xbc\x00\x0a\xa8\x5b\xfe\xff\x5a\x39\xad\x4c\x01\x0a\xc0\xc8\xe1\x98\x05\x32\xa7\x5d\xdb\x79\x6e\x5b\xef\x90\x38\xea\xbb\x56\xbb\xce\xa9\xfd\xc7\x03\xe7\x5e\xfc\xc8\xc6\xcd\x1f\x4f\x5c\xe2\xd8\xdc\x31\x35\x89\xdf\xca\x78\x6f\xb1\xdd\xa5\xed\xc7\x7a\xce\xdf\x71\xd7\x69\xa7\xac\xbe\x4a\x79\x65\xee\xbc\xb6\x86\x68\xa5\x50\x9d\xf5\xe2\xc2\xe9\x1f\x94\x09\xec\xcb\xec\x83\x40\x3b\x7a\xe4\x6a\xa3\x4e\x87\x05\x44\x44\x22\x51\xb4\x08\x16\xab\x24\x48\x4e\xd5\x4b\x30\x60\x36\x21\x58\xad\xc5\x20\x09\x98\xc3\x13\x53\x5c\x8e\x47\x07\x19\xa8\xad\xaa\x20\x16\x37\x61\xcb\x1a\x01\xf4\x98\xec\x00\x43\x0b\x65\x6a\x46\x24\xa6\x57\xb9\x7d\x86\x51\xb9\xcf\x38\xfb\x87\x8f\x26\x1b\xf1\xb0\x7b\x96\x8f\xc1\xe6\x2f\x66\x9b\x94\xeb\xf1\xa3\xca\x7d\xc0\x8f\xbb\x3f\x61\xfc\x20\xee\x0f\xef\xc4\x6b\x7f\x3e\xaa\xfa\x63\x51\xdc\x62\x47\x02\x6e\x49\xc4\x36\x20\x81\x9c\xa8\xd7\xf3\x56\x9b\x64\x30\x19\x80\xa8\x49\x20\x56\x88\x00\xe5\x6c\xd6\xc9\xba\xb6\xc2\x58\x0b\x38\xfc\x9a\x19\x37\x83\x21\x78\xea\xf2\xad\x27\x9d\x3c\x7e\xc2\xb1\xcf\x0d\x04\x07\xf0\xdf\x8d\xeb\x16\x59\x1e\x54\x3e\xc9\xa0\x80\x16\x93\xcd\x47\x69\x5d\xff\x6a\x34\x53\xae\x0f\x17\x31\xe5\x71\x0f\xe7\x74\xb2\xac\x4d\x67\xb5\x16\x15\xd5\xd4\xc6\x3d\x1e\xbf\x3f\x3a\x05\xae\x06\x27\x48\xaf\xce\x00\x09\xb2\xd3\x03\x0f\x50\x99\x0b\xce\x4e\x1e\x97\xe4\xab\x25\x6b\xdf\xf2\x64\x02\xb4\x9b\x0b\x14\x9d\xf8\x04\xf9\xbd\xd4\x18\xed\xd1\x8b\xec\xe1\x3f\x3d\x99\xd3\xbd\x29\xfd\xb3\x8d\xca\xf5\x63\x1d\x9e\xc1\x82\xb5\xc5\xe5\xcf\x3e\xa9\x2a\xdf\x7e\x9e\xe9\xa1\x69\xbc\x06\x8d\xd7\xc6\xe9\xcf\x35\x7e\x2c\x4a\xea\x10\x9b\x02\x81\xb2\x50\x69\x71\x71\x24\xc2\x89\x3a\x1d\xac\x37\x56\x56\xca\x0b\xfc\xe4\x54\x48\x28\x26\x36\x43\x1d\xf6\x3a\x9d\x5e\x2f\xdc\x8c\x5e\x1c\x39\x11\x83\x46\x0b\x70\xd9\xf2\x75\x73\x79\x8a\x23\x8d\x5f\x23\x79\x4f\xb2\x49\x99\x0b\x58\x36\x1a\xe6\x2c\x6a\x6c\x5b\xe0\x53\xd7\xa7\x95\xc7\xb3\x6e\xa1\xaf\x5c\x5f\x05\x80\x7d\xbb\xf9\xfc\x6f\x07\xe1\xdf\x1e\x3a\xff\x66\xbf\xaa\x2b\xa9\xd2\x78\xb8\x08\x5a\x20\x27\xbc\x01\x8f\x27\x18\x0c\x3b\x78\x1e\x03\x34\xc3\xe1\xa8\x31\x16\x0c\x87\xc2\x93\x52\x81\x08\x8a\x4c\x4e\x79\x11\xe3\x41\xf0\xbf\x2e\xe4\xd2\x59\x89\x5f\xb8\x0e\xe7\xf8\xa4\xbc\x25\x15\x30\x4c\xb9\x52\xe9\x84\xc9\x4e\x36\x0f\xca\xde\xd1\x42\x72\xf4\x34\x44\xe4\x4f\x43\xc7\x33\x79\x95\x74\x35\x66\x75\xbd\xf8\xdc\x87\x06\xe1\xf5\xbe\x85\x25\x01\x13\x75\x33\xcd\xe3\xf7\x0d\xff\x3d\xd0\xa3\x62\xc0\xcd\x24\xba\x52\xee\x0a\x89\x09\xa7\xc3\x53\x53\xe3\x30\x97\x59\x71\x2c\x66\xb5\x3a\x6a\x8b\x1c\x22\x90\xdd\x21\x8d\xee\x3a\x67\x1d\x60\xa7\xa4\x7a\xfe\x95\x55\x18\x2b\x60\x61\x46\x6b\x4d\x2c\x86\x31\xc7\x95\x4e\x49\x71\x6e\x12\xba\xeb\xc9\x4b\xce\x93\x2b\xfd\x9d\xa3\x57\x68\x40\x9a\xb5\x64\x5e\x7c\x43\x36\xdb\x40\x38\x7e\x7c\x1a\x65\x36\x27\xed\x16\x66\x54\xe6\x55\x61\x83\x69\x16\x8f\x4b\x9f\x3c\x83\xa9\xcb\x8a\xbe\xe3\x8e\xbe\x50\x90\x4b\xb9\x11\xcf\x22\x12\xa4\xb8\x65\x40\xf2\x64\x25\xa4\xc9\xc3\x2f\xe2\x53\x73\xa1\x73\xf7\x33\x7e\x87\xd5\x86\xd4\x98\x48\xe1\x62\x80\xd9\x10\xd4\x8e\x6e\x95\x7b\x1a\x59\x47\x59\x59\xb5\xb5\x86\xad\xad\x95\x82\x89\x84\x7e\xc4\xf0\xe1\x26\x93\x54\xea\x72\x95\x4b\xac\x8d\xb5\x8d\x1e\x13\x77\x38\x48\xad\x21\x47\x83\xb5\xa1\x76\x62\xaa\xc1\xe5\x0b\x4d\x4e\xf9\x82\xf6\x72\x6b\x39\x31\xce\x6a\x81\x93\x6d\x24\x90\x70\xf8\x50\x34\x74\x4a\x2a\xa1\x06\xfd\xe4\xa0\x85\x0a\xb3\x70\x0f\x08\x28\x28\x00\x61\x42\x73\x5c\x48\x0c\x8c\x34\xcc\x81\x90\xca\xa0\x91\x13\xb9\x36\x9e\x38\x00\x31\x0b\xd1\x03\x19\x41\xf5\xf9\xe3\x05\xd9\x21\x4b\x7e\x29\x32\x31\x03\xdf\xac\x3c\x5b\x20\xe8\x5e\xd1\xff\xc8\x20\x01\x8b\x1c\xe0\xe8\x05\x14\x47\xcb\x00\xe2\xc3\xd0\x68\x74\xbb\xdc\x13\x67\x8b\x5b\x5b\x4b\x9d\x4e\x87\xdf\xd1\x62\x1d\x36\x4c\xd2\xd7\x9a\xa2\x35\x35\x00\xf6\x51\x7e\x7f\x23\x05\xfb\x98\x8e\x56\x47\xc4\x31\x31\x15\x2e\x8e\xb8\x3c\xc3\x27\xa6\x3c\xf6\x26\x6b\x53\x0e\xde\x7a\x49\x6c\x20\x10\x1f\x56\x53\x53\x89\x2a\xa7\xa4\xa2\x59\x98\xe7\xf2\x7c\xe4\xaa\xef\x10\xfa\xfb\xd2\x60\x10\xcf\xe9\xaf\x13\xb6\x3c\x6d\xd2\x60\x60\x4f\x66\xd2\xa1\x6b\x5a\x8e\xe3\x01\x4d\xcd\x25\x7c\x46\xd5\x71\x3c\xdc\x09\x26\x57\x4c\xbb\x69\x6e\xdb\xb8\x8c\x12\x64\xea\x40\x40\xb3\x5b\x3a\x87\x9d\xee\x4a\xe1\xcf\x55\x3d\xc8\x40\xb8\x03\x5e\x6f\xb9\xb8\xa7\x83\x6a\x47\x06\x00\x1a\xaf\x72\x5a\x14\x5d\xa5\xaa\x24\xc1\x68\x24\x00\xfe\x37\xdc\x3a\x34\x14\x2d\x92\x9b\xea\x12\x89\xc6\xc6\xea\x8a\x0a\x8f\x41\x62\x0d\x65\xa1\xb2\x50\xcb\xb0\x8a\x44\x5d\x62\x52\xaa\x46\xae\xae\x93\x3c\xac\x39\x12\x19\x4a\xbc\xf6\xcc\xae\x89\xa9\x6e\x2b\x6e\x21\x81\x5a\x66\x1a\xca\x3c\x67\x4e\x9e\xef\x72\xbe\x15\x23\x03\xc4\x04\xfd\x47\x6f\xd6\x84\x9a\x95\x40\xe3\x9e\x33\xdc\x27\xa5\x79\x6a\x6d\xcd\xb0\xea\xea\x96\xb3\x71\x10\xc1\x88\xf9\xf8\x94\x59\xde\x9a\x89\x0b\x27\xdd\xbf\x6b\xf9\x95\x55\xed\x66\x7b\x67\xcd\x39\xfe\xfa\x31\x53\xba\x63\xaf\xbd\xa6\xf4\xac\x58\x63\x3f\x25\x97\x4e\xd5\x39\xac\x66\x4e\xf7\x88\x50\x43\xe5\x90\x51\x1b\xa7\x6e\xb9\x96\xda\x45\x2f\x28\xaa\xab\xae\x4a\x4e\x9c\x3f\x72\xfb\x56\x62\xb1\xc1\x5f\xab\xf9\x55\x3d\xe7\x06\x6b\x47\xc0\x59\x1f\xa9\x4c\xe0\xde\x87\xbb\x3b\x04\x52\xdd\x0a\xb9\xc5\x12\x35\x9b\xe3\x71\xde\x48\x9c\xc4\x22\xa5\x88\x0b\x85\xac\xd6\x62\x57\x51\x11\xcf\x57\x56\x85\x02\x34\x82\xc0\x81\x75\x51\x4b\x94\x24\x8c\x35\x5a\xa4\xd2\x12\xa6\x04\x04\x51\xc6\x9d\xd3\xed\xa9\x30\xc8\x8b\xf1\x2f\xb8\xc6\xf3\x2e\x80\x58\xc6\xb7\x4f\x5d\xf0\x80\xbb\x3d\xec\x48\xc0\x5f\x28\x0c\xf0\x3b\xb3\xa6\xe5\x6c\x50\x0f\xba\x0b\x2c\x99\xca\x0f\xca\x0f\xb1\x40\xf8\xe2\x07\x66\x59\x1b\xa5\x08\x5d\xe2\x51\xb2\xc4\x8b\x33\xd6\xcc\x9f\x19\xa6\x58\xcf\xbc\xa5\xb0\x53\xcb\x1a\xeb\xa9\x1d\x68\x24\xdc\x09\xe5\xb0\xf7\x06\x24\xa3\x6b\xe5\xf1\x2d\x23\x86\x0e\x6d\x6b\x6b\x4a\x26\x75\x25\x25\xd6\x4a\x8b\xc5\xea\x61\xad\xf5\xb1\xfa\xd8\xa8\xf6\xe4\x88\x16\x92\x47\x5f\x28\x15\xa6\xa4\x4a\xa4\xd2\x50\x69\x5d\x29\xab\x67\x4b\x4b\x6b\x86\xca\x4d\x2d\x92\x05\x19\x6b\x8c\x53\x52\x95\xe5\x35\x6e\x27\x91\x46\xbc\x4e\x6b\x56\x05\x9e\x31\x05\x01\x34\xf2\xea\xee\x0f\x7e\xc2\x54\x14\x51\x41\x92\x0b\x73\x8f\x11\x1d\x54\xfc\xc4\x71\xf1\xd9\xf2\x4b\xf9\xe8\xc2\xde\x94\x09\x7e\x57\x86\x79\x3a\x2c\x7e\xe6\x44\xb1\xf2\xed\xd7\x0c\x1b\x60\xd5\x5b\xad\xc5\xc4\x1b\x4b\x6c\x63\x4e\x1e\x24\x70\xbe\xb6\x31\x07\xdb\xc5\x04\x98\x53\x28\xcf\x80\x94\x09\x82\x1f\xf0\xa7\x19\x5d\x2a\x77\x98\x0d\x16\x8b\x3e\x28\xea\x1c\x81\x80\x4e\xc7\x16\x17\x73\x5c\x95\xc0\xf3\xfa\x64\x53\x53\x19\x88\xa5\x43\x5b\x2a\xea\x27\xa5\xaa\x2b\x02\xf0\x17\x92\x27\x32\x55\x62\x35\x88\x41\x11\x30\x29\x28\xd9\xbc\x93\x52\x4e\x1b\xd6\x07\x88\x54\xd3\xa6\x05\xd9\xe5\xe7\xeb\xc9\xd6\xc1\x6f\xc9\x2a\x55\x33\xc0\x2b\x08\x74\x50\x1d\x69\x68\xe2\x97\x36\x26\x1f\xa3\x24\x1c\x3e\x71\xfc\x0a\xf7\xa8\xea\x5b\xba\xf5\xe3\x8f\x94\x1f\x3e\xba\xc3\x74\xbf\x27\xf6\xce\x1e\x0d\xc7\x40\x04\x2f\xc2\x7f\xa4\x86\x38\xdb\xea\xf0\x7b\x7b\x48\x92\x26\x8f\x23\x30\xe4\x24\xd7\x99\x6e\xb6\x89\xfa\x9b\x8e\x39\xaa\xe3\xfe\xdb\x11\x3f\xff\xa5\x3d\xae\x8f\x56\xba\x96\xad\xbd\x75\xd7\x2b\xa7\x2f\x24\x7e\xc1\xcf\xbd\x4e\xac\xe8\x1b\xcf\xa3\x01\x2d\xaa\xbf\x3f\xa1\x3b\x40\xeb\xcb\x49\xb6\x81\x78\x79\x79\x94\xd2\x9c\x48\x28\x12\xaa\xa8\x64\x3d\x11\x73\x59\x74\x62\xaa\x0c\x45\xca\x09\xb9\x09\xd8\xb0\x64\xc3\x26\xde\x66\x33\x13\xca\x63\xce\x9a\xd7\x01\x9f\xe6\xe4\x05\x4d\x14\xd0\x9b\xc4\xaf\xa4\x35\x94\x6c\xff\x12\x71\xe9\x9f\x4e\xdd\xfb\xff\xf9\x4b\x14\x85\x26\xe6\x26\x79\x8c\xe8\xba\x3c\x34\x3e\xc7\x4d\x6a\xc1\x21\x97\x24\xb1\x56\xab\xc9\x68\xd3\x63\x23\xf6\x78\xd5\x4b\xc9\xca\x1a\x59\x60\x9e\x74\x56\x1d\x63\x60\x75\x3a\xa3\x8b\xb1\x23\x3b\x3c\x90\x72\x49\x2a\xa8\xe8\x8a\x0a\xfd\x9e\x93\xb6\x64\x36\x75\x69\x86\x41\x52\xe7\xaf\x5e\xeb\xf8\x53\xa6\x29\xc7\x04\x1d\x7b\x88\xce\xfb\x55\xbc\x68\x32\x30\x3f\x0c\xfb\x50\x86\xd9\x21\x93\x3d\x7a\x23\x53\xef\xb0\x0a\xaa\x3d\xb8\x3a\xfd\x03\x77\x39\x3f\x1e\x39\x81\xf6\xdd\x27\xf7\x84\x4b\xca\x2b\x5c\xa1\xe2\x22\xb7\x3b\x54\xce\x06\xe3\xa5\xa5\x76\x93\xd1\xe1\x04\x09\x4a\x87\x81\x13\x66\xb0\xc1\xc1\x9a\x45\x33\xa9\xaa\x5c\x51\x11\x8f\x97\xc2\xb3\xd2\xd2\xa8\xbb\xbc\xbc\x28\xec\x74\xda\xed\x66\x46\x14\xcd\x66\x5e\x0a\xc3\xff\x26\x7f\x94\xc3\x0e\x87\xce\x44\x7d\x06\x49\x68\xa1\xc6\x13\x67\xcf\x7c\x5d\x41\x4a\x37\xf8\x9c\xa1\x0b\x9e\x3c\x37\x77\xcd\xd3\xbd\xd0\x78\x46\x8d\x37\x49\x58\x74\xc4\x08\x32\x85\x6a\xce\xe1\x8e\x7b\x82\x99\x15\x53\x9f\xea\x12\x5f\x17\x87\x28\x2f\x4d\x99\xf6\xfa\x94\x73\xab\x45\x3c\x54\x9c\xd4\xfd\xd6\x73\x53\x9f\xec\xd2\xbd\xae\x4b\xaa\x8f\xcf\xab\xd6\xe1\xa1\xba\x89\xdd\x6f\x31\xcd\xca\x4d\x78\x89\xad\xba\xda\xd2\xff\x04\x9e\xaf\xec\x64\x3a\xe1\xbd\x5d\xd9\x8e\x17\x31\x7f\x3e\xd1\x5f\xa8\xae\xfe\x7d\xd8\x77\x52\xd3\xdf\x84\x7c\x68\x88\xec\x45\x26\x93\xcf\xe7\x0f\x78\x0d\x46\x23\x88\x7c\x0e\xaf\xd9\xe3\x42\x06\xc1\x48\x52\x1d\xbe\x9e\x20\x3f\x54\x98\xcf\x78\x73\xd9\xd5\xe0\x32\x62\xfc\x55\x6b\xf5\xb3\x05\x1f\xde\x9d\xce\x84\xee\x5e\xe4\x3d\xdc\xdb\xdd\x33\x85\x9d\xff\x2f\xf8\x74\x6f\x9f\xf7\xf5\xde\xee\x69\x93\xd9\xf9\xec\xaa\x97\x45\xb3\xf3\x65\x7c\xf8\xe7\x17\xb4\x37\xaa\xfc\xfb\x32\x8d\x3f\x24\xbe\xea\x33\xe4\x6a\xe2\xa5\xee\xb1\x67\x02\x10\xed\x62\x79\x45\x91\xea\xad\x6e\x25\xde\xea\x12\x33\x25\x25\x9d\x38\x04\x31\x5f\x2e\xb6\xb7\x64\x63\x7e\x62\xc7\x45\x56\x50\xf7\x74\x12\x80\x90\xf3\x6d\x91\xb0\x80\x2f\x9c\x35\x6c\x7d\xc5\x52\x6c\xf8\xfc\x74\xb3\x72\xd5\xb2\xe9\xb7\x2d\x39\xed\x4c\x7b\xbb\x30\x81\xfa\xab\xcf\x48\x5d\x7f\x9d\x25\xe2\xfe\xcb\xfc\xf5\xa7\x32\x53\x7e\x3e\xea\x6b\x67\xfa\x4e\x9f\x05\x24\xe3\x34\x7c\x76\xa8\x64\x2e\xf1\x57\xbf\xe8\xb2\x96\xa9\x87\x56\xe7\xd6\x74\x1a\x8d\xab\x98\x2d\xd7\x99\x6c\x36\x01\xd5\xbb\x2b\xe3\x20\x53\x87\x03\xde\x7a\x6f\x63\x93\xbb\xb2\xd2\x51\xe3\x98\x92\xaa\x71\x87\xa3\xd1\xa2\x49\xa9\x68\xc0\x93\x71\xb0\xc8\x26\x59\xf8\xc5\xe4\x67\x5a\x02\x9e\x81\x4b\xc8\x06\x91\x0c\x4c\x8b\x96\xb7\xee\xe7\x3b\xb5\x05\xdd\xb0\xc9\x18\x71\x6b\x4b\x7e\xcc\xde\xa9\xb9\xe5\x6f\xdd\x2a\xd6\xa9\x4b\x1f\x6a\x60\xbe\x5e\x49\x56\xb6\xee\xfa\x16\xf9\xd0\xea\x0a\xba\xf4\x63\x86\x05\x15\xf4\xe1\x59\xeb\x8b\xdb\xb1\x45\x83\x41\x5b\xa3\x2a\x8f\x0e\x65\x12\xcc\x66\xfe\x72\x14\x40\x13\x64\x27\x72\xf8\x7c\x4e\xa7\xdb\xe5\x0a\x16\x19\x2d\x16\x1d\xcf\x17\xb9\xbd\xcf\xe0\x6a\xe4\xc2\x23\x91\x0e\x19\xf1\xc8\xbd\x0e\x64\xb5\x32\xfb\xf1\x08\xcd\x11\x35\xd9\xd6\x96\x1c\xa4\x48\x0b\x60\x9c\x76\x89\xc2\x0e\x46\xb2\x91\x23\x11\xa0\x27\x49\x56\xc0\x65\x73\x2f\x6f\xe9\xe6\x47\x76\xea\xfe\xd6\x6a\x69\x2e\x9b\xe7\x92\x6f\xbb\xb6\x59\x7c\x3f\x29\x72\xe8\xec\xd6\x61\x96\x0a\xe5\x76\x4b\x39\x9e\x31\xd6\x39\x6c\x46\x42\xb9\x85\x0d\x59\xca\x95\x7f\x34\xe4\xcd\xf5\x06\x90\x9d\x7b\x64\x8f\x2e\x10\x8c\xa8\xd1\xa4\x45\xd1\x98\xc3\xed\xb6\x9a\xcd\x31\x0e\x87\x9f\xc1\x35\xa8\x08\xa6\x6b\x45\x0e\x3c\x72\x1f\x89\x27\xf5\x1a\x32\xf3\x25\x44\xa2\x8d\x10\x8b\x01\x33\x2e\x0c\xc1\xcc\xe4\x7f\x1f\x38\x77\x7a\xd1\xe1\xef\xe2\x82\xe4\x1c\x11\x08\xe8\xe7\x5c\x91\x5b\x43\x6c\x3e\xac\xe1\x0c\xe7\x85\x2b\x5b\xa3\x3c\x33\x4a\xba\xe9\x86\x58\xc1\x42\x86\x4f\x1f\xa2\xdc\xc2\xac\x5e\x73\xae\x49\x8d\x93\xdf\x03\xc7\xef\x41\x7e\x23\xcc\x31\x88\x86\xcb\x56\x9b\xc7\x63\x66\xf4\x7a\x83\xc1\x62\x36\x17\x15\xfb\x9d\x07\x00\xe2\x06\x64\xc2\xc3\xf7\x88\x2c\xda\x8f\x5b\x41\xa6\x48\x64\x0a\x95\x17\xa8\x5a\x1d\x99\x0b\x36\x93\x77\xdf\x91\xa7\x91\x73\x37\xd5\x7a\xca\x2c\x92\xa9\x2d\x30\x7f\x9e\x80\xf9\x45\xce\x4b\xcf\x6a\x2e\x03\x7c\x8a\xc7\x9b\x70\x95\xf1\xf2\x2e\xfd\x4d\x4c\xc4\x59\xde\xbf\xef\xec\xf3\xd9\x74\xf9\x90\x21\xe5\x65\xcd\x4d\x19\x18\x0b\xdc\xd9\xc8\x86\x86\xca\xc0\x7c\x19\x55\x37\x64\xde\x61\x11\xad\x4f\xe1\xe1\xc8\x0c\x38\x40\x5d\x91\x73\x38\xa0\x02\x34\x4f\x70\xc1\x19\x96\x20\xbb\xe7\xb8\xac\x64\x6e\xbd\xdf\x1b\x09\xfb\xab\x47\x87\xdb\x6e\x9f\xd9\x29\x7c\xca\xfe\x4b\xee\x16\x7e\x3f\xb5\x6a\x88\x72\x33\x56\x2c\xe5\xf4\x0c\xfe\x9d\x89\xe0\x27\xb8\x85\x85\x63\x3b\x78\xbb\x45\xb0\x3d\x05\x5b\x0a\x10\xc9\x8c\xdd\x56\x30\x76\x36\x04\x1b\x40\x92\x61\x3b\xd4\xdc\xdb\x30\x8b\x57\x8f\x1b\x9a\x79\x50\x1b\x1a\x2f\x54\x18\x8b\x56\xeb\xeb\x1f\xb8\x02\xff\x05\xc6\x2e\x42\xa3\x64\x8b\xcf\x62\x32\xf9\xfd\x02\x0a\x04\x42\x8e\x62\xff\x7e\x3c\xfc\x71\x9f\xc5\xe2\x76\x3b\x6d\x30\xf2\x1e\x9e\xd1\xd3\x4d\x49\x26\xdb\xd4\x51\xdb\x32\x53\xc8\x22\x52\xfe\x49\x26\x59\x87\xf2\xa7\x24\xe0\xd1\x95\x3e\xa9\xa8\xcc\x53\xd1\x3a\xb3\x87\xf5\xe7\x66\x57\xd2\x76\xc7\x72\x3d\xde\x3b\x56\x1a\xb5\xd1\x34\x75\x7a\x64\x7f\x76\x92\xfd\xb7\xd6\xab\x77\x69\x39\xec\xcd\x0f\x30\x47\xe2\x0b\x3c\x4b\x8e\xda\xbc\x3e\x3b\xcb\x5a\x79\xab\xcf\x67\x34\x38\x18\xc6\xc9\x1b\xf8\xa2\x62\xd6\xeb\xb5\xd9\x74\x66\xc6\x6a\x35\x1a\x1d\x66\x98\xfb\x1e\x9f\x41\xb7\x1f\xc0\x97\x9b\x30\xb5\x58\xda\x07\xba\xff\xe6\x4c\xb3\x58\x62\x00\x89\xb2\x9e\xb2\x4c\xb2\x99\x3a\xca\x12\x99\x92\xf9\x41\x6c\x7f\x64\x86\x72\x44\xf9\x4a\x1c\x35\xb9\x59\x87\x8b\xc5\xae\x50\xe9\xf3\x67\xd6\x0f\x75\xc6\xec\x5d\xdd\xdc\xc2\x72\xcb\xef\x4a\xe6\x3d\x5d\x6e\xc6\xaf\x5a\xca\xcb\x2d\xbb\xbf\x56\xae\xa9\x8c\xbd\xd5\x0a\x78\x15\x61\xca\xd8\x99\x30\x77\x1f\x6a\x94\xa5\x8c\x87\x4b\xc0\xe4\x74\x4a\x1c\x40\x75\xf8\x5e\xb7\xc3\x61\xb4\xa8\x1b\x4b\xcf\x69\x32\x99\x9f\x30\x9a\x3a\x36\x92\x5c\x73\x84\xb3\xd4\xae\xe0\x64\x00\x27\x89\x89\x95\xf9\xbb\x2b\x2e\x5e\xef\x28\xff\xbe\x6b\xe4\xee\xc9\x8b\xea\xc5\xc7\x27\x3c\x39\x62\xf4\x02\xb3\x8b\x63\xdd\x01\x63\xdc\x56\xd2\x34\x5a\x59\x8a\x47\x2b\xcf\x30\x06\xa0\x24\x67\xe3\x69\xca\xc3\x8f\x79\x4e\xa2\x7b\xfe\x19\x2e\x67\xd6\xc3\x9c\x4a\x50\xab\xec\xb2\x7b\x3c\xc8\x6d\x70\x38\xc2\xa5\x7e\x84\x4a\xe1\x93\x58\xec\x70\x11\xf0\x49\x46\x31\xb7\xdf\x14\x46\x85\x99\xf3\xc8\x7e\x8b\x03\xb3\xe4\xc1\x3b\x47\x33\xcd\x1c\x02\x93\x66\xd6\x37\x28\x3f\x8d\x1a\x3f\xa9\x3a\x58\x1c\xf7\x45\x4d\x96\x60\xf4\x14\xf9\x92\x98\xb8\x6f\xf6\xf2\x78\xa9\x53\xbc\xca\xca\xc9\xcd\x27\x29\x53\x17\x4d\xab\x66\xf5\x5b\x27\x98\xa7\xaf\x60\x30\xcc\xf4\x92\xbd\x72\x75\xb1\x4b\x88\x9b\x69\x7c\x33\xf6\xb3\xb3\x19\x1b\xcd\x61\x6f\xa0\x9f\x57\xb2\xb3\xd9\xbf\xd3\xcf\x3c\x8d\x77\xfe\x1b\xf3\x35\xb3\x8c\x9f\x62\x17\x44\xb5\xe6\xfe\x47\xf0\x79\x3e\xfd\xfc\x05\xfd\x3e\x07\x9f\x2f\xe1\xa7\xc2\x67\xe2\xb4\x85\xf1\x74\xae\x91\x29\xe1\x5f\x43\x66\xe4\x97\x0d\xb0\x15\x06\x96\xb5\x48\x9c\x01\xd5\xfd\x21\x4b\x66\x54\x6f\xd2\x46\x95\xa0\x34\x26\x9a\xf0\x9b\xdd\xc9\x9e\x35\x6b\x7a\xea\xc7\xf3\x28\xd9\x3d\x79\x4d\x4f\xcf\x9a\xc9\x9d\xc7\xf5\x65\x64\x59\xe8\xce\x22\x19\xb8\x01\x7d\x81\x9c\xed\x52\x8d\x92\xae\x52\x01\xdf\x3d\xae\x81\xf4\x95\xec\xe6\xd1\x90\x2e\xb5\xaf\x6e\x42\x7f\x3a\x00\xc7\xaf\xe6\x6f\x02\x3c\x69\x95\x9d\xa2\xd3\x19\xf0\x78\xbd\x66\x8e\x65\xfd\x01\x0f\xc7\x61\xb3\x1e\x90\xa5\xe6\x31\x2f\xcb\x62\x15\xa5\x6d\xea\xa6\x1c\x6f\x80\xc7\x34\xa7\x78\x93\x6d\x48\xbe\xeb\x18\x2d\x23\x87\xdf\x52\xce\xd2\x2d\x6d\x6a\x7f\x74\x62\xdb\x98\x8a\xc6\xe0\x90\xab\x12\xf3\x57\x5c\xb8\xbc\xee\x34\x26\x51\x6d\xc5\x8d\x3a\x17\xf6\x6e\xa8\x99\xb7\xd3\xe1\x5b\xb0\x64\xfd\x9e\x62\xe5\x07\xab\x7a\x4f\xae\x87\x79\x3d\x08\xf3\xf2\xa3\x36\xd9\xed\x74\xb9\xfc\x36\x58\xa7\xdf\x1f\xd0\x07\x5d\x7e\xbf\x17\x39\x9d\x82\x17\x66\xb4\xc7\x62\x14\x60\x82\x14\x59\xf2\x3c\xb4\x0a\x72\xea\x64\x4d\x7b\x19\xa9\xc9\xe5\x0c\x69\xc6\x21\x1c\x6d\x39\xe9\xb6\x6b\x93\x17\x24\x82\x8d\xe2\x90\xb6\xce\x29\xbd\x72\x53\x9f\x0e\x66\xbb\x8c\xbd\xc0\xb1\x64\xce\x8e\xfb\xbd\xce\x9d\xf3\x6a\x6e\x5e\x77\xb5\x41\xa7\xbc\x66\xad\xae\xb6\xc2\x3e\x9f\x86\xee\xe1\x8a\xb8\xfb\x01\x0f\x42\x74\xdf\x6f\x82\xcf\x53\xe8\xe7\x30\x9d\xf7\x48\xf4\x1a\x37\x86\xbb\x14\x09\xa8\x54\xb6\x08\x3c\xc3\x00\x2f\xc9\x89\x3a\xa0\xf1\x18\xd5\x11\x5e\x91\xc2\x4d\x73\x6a\x8b\x45\xf4\x38\x82\x93\xdc\x98\xad\xca\x26\x65\xd3\x56\xfc\xe7\xd9\xaf\x31\xe9\x7e\xcc\x3e\x89\x8e\xef\x8b\xc1\x3c\x4f\x8c\x4d\xa2\x8e\x45\x3c\x73\x7c\x5f\xb4\x27\x3d\xe6\xc6\x28\x55\xb3\x95\xaa\xad\xf8\x4c\x7c\x26\x77\xe9\xb1\x2e\xf6\xc9\x7e\xcc\xa4\xd5\xfe\x56\x71\x73\x99\x34\x7f\x17\xb0\x16\x43\xe5\x52\x16\x78\x7b\x52\xef\x59\x6f\x60\xc4\xcd\x29\x1d\xb3\x65\x96\xb0\x56\xb7\x59\xc7\x10\x7f\xc9\x5d\xba\x37\x74\x9c\x0e\xd5\xcd\x59\x45\xbc\x4a\xf2\x47\x71\x10\xf7\x36\x80\x23\xbf\x4a\xc0\x66\x5a\x93\x5a\xf9\x86\x9b\x1b\xc6\x31\xe5\xfd\xf0\x1d\x77\xc0\x18\xf7\x72\x73\xd9\x46\x3a\xc6\x70\x39\x42\xc6\x20\xeb\x07\x71\x43\x60\x85\x2d\xb3\x58\x18\x69\x2d\xbb\x99\x65\x24\x36\xc4\xee\x62\xdf\x60\x39\x96\x0c\x92\x17\xe0\xaf\x0d\x93\x2d\x87\xcd\x36\xe6\x6a\x5f\xf3\x77\x65\x6a\x5d\xc3\x19\xb8\x8e\x9b\xc4\x20\x7e\x2b\x62\x51\x25\xf1\xd5\xc0\x1c\xcf\x22\x2c\xe3\x79\x98\x7d\x14\xbf\x89\x19\x09\x87\xf0\x2e\xcc\x02\xcc\xe7\xcc\x59\xf5\xba\xda\x37\xe1\x38\x6c\x49\x06\xad\x58\xc1\x4d\xc2\xed\x30\xd7\x75\xdc\x5a\x56\x02\xe1\x9c\x45\x65\xb2\x9b\x6c\x14\x0f\xb2\xbf\x15\xd5\xa3\xc9\x88\xbb\x04\x61\x89\xa8\x02\x48\xfb\x44\xa6\xbd\xa3\x39\x2c\xae\xf3\x33\x67\xf9\xb9\xb5\xdb\xb6\xa9\x79\x10\xfa\x01\xa6\x5f\xf0\x9b\x61\xff\xcf\xa1\x9f\xbf\x82\xcf\x6b\xe9\xe7\xd1\x14\xe6\xb7\x2b\x1d\x58\x4a\x5f\x0e\x63\x38\x1e\xa7\xd3\xc4\xb0\xe4\x82\x09\x61\x69\xc5\x0a\xf8\x92\x66\xeb\x3a\x59\xf9\x16\x7f\x99\xbe\x0c\xbe\xef\xd9\x47\xa6\xc4\xc0\xed\x3b\x7e\x77\x0a\x36\x5c\xb5\x19\x36\xd4\xb3\x30\x89\xfb\xc9\x24\x94\x6f\xe9\x24\x70\xfa\x35\xa5\x13\xf7\xa5\xd7\x00\x65\xb2\xed\xe3\x30\x16\x10\x1d\x02\x6b\x46\xb8\xe6\xb0\x43\xc4\x3a\xe5\x05\x11\xeb\xaf\x14\xe0\x9b\xa6\x98\xf2\x6d\x89\xea\x33\xa2\x74\xe1\x07\xd3\xe7\x42\x3b\x69\x2f\x8b\xb2\xcd\x12\x64\x0c\xe2\x03\x34\x42\x38\x84\x8b\x38\x65\xb5\xd2\x15\xc6\xd6\x18\x89\x54\x64\xd0\x66\xf8\xc5\xb2\x0f\x41\x1b\x23\x2a\x91\x2d\x2c\x42\x82\x28\x9a\xcc\x7a\xd1\xc5\x70\x34\xb6\x3b\x99\x4f\x83\x00\x53\x1a\x93\x6c\xa4\x11\xb6\x92\x61\x7b\x9a\x7a\x3e\xda\xf6\x11\xfc\x66\x2f\x7f\xe8\xa1\xd8\xb1\x9e\xd8\x43\x0f\xd1\x35\xe3\x18\xf3\xbe\xd6\xa7\xf3\x09\xc0\x70\x41\x54\xbb\xca\x02\x89\xf6\xa2\xb6\xa7\x4d\x09\x5c\x3f\x40\x29\x7c\x2f\xfe\xf6\xff\x88\x9e\x9e\x9c\xa1\xa7\x38\x9a\x4f\x4f\xd1\x2b\xd0\xd7\xf5\x99\xbe\x7e\x25\x3d\xf5\x66\xe8\x29\x8e\x16\xd0\xd3\xe5\xe8\x26\x86\x61\xdc\x48\x04\xe8\x98\x19\x41\xe0\x49\x92\x63\x1e\x36\x1e\x50\xe9\x70\xd2\x96\x0f\x9d\xe6\xc6\x64\x63\xd2\x95\x74\x2d\xbf\x74\xd3\xa5\x37\x6d\xff\xf2\xcb\xed\xc7\xb5\x07\xe8\x32\x3c\xaf\xd3\xc3\xd1\x07\xd6\xb4\xee\x70\xa2\xa0\x3d\x8e\xb8\x22\x8d\x91\xc6\x30\xc3\x40\x07\x78\x1b\xbe\x98\x76\x01\x7d\x9c\x87\x6e\xc6\x3f\x42\x1f\x46\x54\x2f\xbb\x0c\x0c\x03\x8d\x59\x92\xcb\xca\x64\x86\x8e\x0c\x82\xa0\x27\x1b\xad\xa5\xaa\x2c\xa8\x6d\x96\xed\x93\x4e\x0c\xff\xb8\x66\xd3\x1a\xf8\x87\x6d\xe4\xf7\x1a\x15\x3f\xfb\xf1\x28\x66\x15\x7e\x17\x70\x45\xda\xcb\x20\x8e\x9c\x90\x84\x86\x33\x8d\x61\x17\xcb\x9c\x85\x47\x01\x56\x62\xb4\x0f\xe8\x80\x8b\xbf\x1d\x60\x9a\x90\x8b\x8d\x64\x73\x8c\x3c\xe2\xb7\xcc\xd2\x6d\x46\x3b\x11\x23\x01\xf5\xac\x43\xcf\xa2\x8f\x11\xaf\x83\x1e\xe6\xc2\x19\xcb\xd1\x00\x9a\xc3\x01\x04\xb1\x24\xe1\xb4\x93\x16\x8c\x77\x9d\xbb\x5e\x38\x4f\xdc\xb6\xad\xf1\xbc\xd0\x01\x6e\xee\x45\xe7\xc6\x2a\x36\x6c\xb8\xf9\x7e\x15\x77\x92\xdc\x2a\x66\x21\xd0\x1b\x23\x36\xcb\x2f\x0b\x08\x01\x2a\xb2\xd7\xa6\x38\xfd\x18\x7d\x8f\xfe\x2c\xfd\x0d\xfa\xbb\xf4\x7b\xf5\x22\xa7\x1f\x42\x3f\x1e\xd2\xbf\xad\xff\x42\x2f\x92\xa7\x8c\x51\x8f\xf5\xfa\x1e\x33\x76\x9a\x31\x67\xc6\xff\x36\xe3\x43\x66\x7c\x97\x19\xdf\x60\xc6\x7d\x66\x3c\x24\xf3\x7c\x19\x3c\xdd\x4b\xff\x70\x96\x19\x8f\xa1\x4f\xd5\x27\xf0\xa5\x9e\x4c\xb3\xb3\xe8\xc7\x2a\xda\x60\x38\x74\xb0\xcc\x8c\x7b\xe9\xb7\xa1\x9b\xa3\x66\xfc\x76\xa6\x8d\xda\xfd\xa5\xb4\x81\x6c\xc6\x4c\xbd\x19\x97\x98\xb1\xd5\x8c\x3f\x31\xe3\x5d\x66\x7c\x89\x19\xab\x4f\xe6\x90\xff\x56\xad\x5a\xd5\xbb\x2a\xf3\xdf\x99\xe4\xbf\xb9\x73\x32\x7f\x50\x3f\x67\x1e\xd0\x47\x04\x88\x73\x56\x9d\x59\x95\x05\x61\x7e\x8e\x97\x64\xc6\x27\x80\x37\xe6\x92\xb8\x30\xe8\x67\x2e\xc2\xdc\x06\x7c\x84\x11\x79\xd0\x48\xb9\xcc\xa5\xd7\x4b\x2c\xeb\x23\x4e\x62\x82\xe9\xaa\x94\x40\x6a\x85\x02\x44\xed\x57\xa5\xc8\x76\xb5\xa1\x5e\xb4\x96\x30\x3f\x75\xc4\x3c\x60\x3d\x54\x55\x55\x95\x8f\x8b\x19\xf7\x27\x22\xc7\xe5\x25\x72\xc3\xaf\x9f\x7c\xe1\x05\xa7\x9c\x72\xc1\x05\xa7\xc4\x87\x0f\x8f\xc7\x87\x8f\xe0\x22\x17\xcc\x9c\x79\xde\x79\x33\x53\x17\xe2\xa1\xc3\xcb\xc9\xc3\xf2\xe1\xd4\x4f\x46\x99\x8a\xff\x80\x2c\x40\x7e\xab\x65\x97\x04\xa7\xd9\x66\x97\x84\x90\x50\x27\xb0\x7a\x56\x40\xa6\xeb\x53\x20\x99\x99\xd4\xd2\x7c\x34\x7b\x20\xd6\x2e\x0a\x35\xe0\x20\x49\xfc\x5c\x00\x5b\x3c\x02\xc6\xa7\x9f\xd5\xd5\x72\x69\x49\xe5\xe2\x21\xc3\x8a\x67\x2b\x53\x17\x2e\x18\x7d\x65\xbc\xe1\x9c\xa6\x55\xfe\x69\x8d\x64\x9c\xb9\x5c\x3b\xdb\xc2\xaf\x46\x2e\x74\xba\x3c\xce\xa1\xd3\xb9\x3d\x0e\x83\xc4\x85\xb8\x3a\x8e\xb5\xf0\x06\x6e\x6b\x4a\x32\x84\x0c\x8c\x9e\x25\x7a\x74\xc9\x2a\x95\x48\xf0\x18\x49\x5b\x53\xba\x10\xda\x45\xf0\xb6\x0e\x80\x40\x50\x98\xcf\xc0\x64\x17\xfa\x16\x48\x27\xb9\xc6\xce\x4c\x54\x21\x98\x9b\xdf\x6b\x7d\x9d\x06\x9b\xab\x01\x04\x59\x94\x56\x6d\x00\x11\x3b\xe1\x44\x28\xd3\x0a\x93\x66\xaa\xa6\xcf\x6b\x08\x97\x55\x3a\x16\x8c\xfe\x7d\x63\x4f\xed\x90\xa2\x58\xa5\x73\x41\xd9\x46\xae\xfd\x94\x9a\x21\x6d\x38\x54\x5f\x56\x93\x6c\xdd\xbe\x91\xec\xd5\x7d\x70\x9e\x5e\x02\x3c\x27\x74\x77\x88\x5c\xac\x17\x04\x96\x20\xbb\x8e\xe1\x99\x6b\x66\x19\xe1\xc6\xe1\x19\x89\x0f\xf1\xbb\xf8\x37\x78\x8e\x57\x6f\xee\xfc\xd8\x13\x72\x77\x39\x92\x22\x4e\xd2\xdf\xf7\x09\x07\x8f\x8a\xca\xfd\x8a\xf0\xcc\x31\x51\xb9\x8f\xde\xdf\x31\xe5\x63\xf5\x37\xa9\xe9\x82\x77\x30\xe7\xb3\x23\x00\x46\x09\xd9\x6d\xb2\x58\x58\x23\xcf\x3b\x04\x96\x75\x7b\xec\x76\xab\x15\x09\xbc\x11\xd6\xfb\x41\xe2\x90\xaa\xf4\x1b\xc8\x08\xaa\x09\x09\xdb\x72\x79\x0a\xa9\x97\xde\xd5\x33\x66\x8b\x1b\x5d\x93\x23\x01\xf7\x2c\xe7\x8c\x19\x1d\x75\xbe\xf5\x78\xc7\xfc\x53\xe2\x91\x51\x67\xc7\x6d\xce\x22\x92\x65\x70\x5e\xb4\xe7\x4c\x95\x4f\x59\xcb\x7c\xc0\xd6\xf1\xd7\xc2\x4a\x03\xb2\x89\x33\x99\x0d\x22\xe6\x38\xa3\x9e\x85\x75\x25\x0f\x27\x3c\x54\x90\x82\x9b\x8d\x11\xf5\x38\x0e\xf7\x9b\x1e\xb3\x75\xca\x77\x58\xea\x06\x31\xe9\x48\x37\xb6\x2a\x47\xc6\x62\x09\x5b\xf9\x31\xca\x77\xe4\xb3\x45\xf9\xae\x1b\xdb\xb0\x34\x56\x39\x02\x57\x3a\xe9\xff\x46\x5c\xcd\x6c\x02\x39\x24\x80\xda\x65\xbf\x99\x07\x99\x88\xd1\x19\x0c\x20\x24\x05\x8b\x3c\x0c\x53\x44\x9e\xe8\x03\x92\x8d\xc8\xdf\x7a\x22\x89\xb4\x65\xb2\x34\xe2\x7c\x25\x46\x86\x55\xd1\xb4\xef\x12\x26\x59\xd4\x98\x3a\x0c\x74\x2b\x23\x8a\x30\x57\xb3\x3d\xb7\x33\x7e\xc3\x75\x5e\x5d\xa5\x2b\x3a\x34\x24\x3e\x55\x12\x9c\x33\xc4\x6b\x14\xb9\x85\x82\xbf\xfa\x26\xe5\x2f\xf2\x73\x65\xa2\xbd\xe2\xb6\x21\x78\xd8\x33\xe6\xf8\xa5\xca\xdf\xf7\x2f\x2f\xb5\x7b\xb9\x38\xcc\xf1\x0c\x26\x81\xef\xe3\x2f\x87\x7b\x20\x26\x1b\x08\x13\xc5\xb2\x3a\x3d\x27\x10\x5d\x05\x70\x81\x94\x17\x2f\xbc\x6a\x89\xf2\x84\x88\xfe\xfe\x6e\xf1\x9b\x4d\xcd\xe2\xfb\xcc\x62\x4b\x39\x51\xe6\x50\x1e\x3f\xce\x70\xdc\x39\x28\x06\xb2\xa0\xad\x44\x70\x38\xca\xe2\x1e\x0b\x42\x71\x4b\x09\x5b\xe4\x03\x99\x6b\xc4\x1e\xa3\xa8\x09\xf9\x2a\x7b\xdf\x92\xef\x46\x9c\x71\x6f\xcc\x08\x5b\x8d\x43\xa8\x0a\x3e\x39\x20\xfc\x11\xe3\x7f\x9e\x7f\x7e\xd9\x6a\x5f\x30\xae\x2f\x1b\x93\x18\xd6\xde\x37\xe2\xb3\xd1\x33\xfd\x71\x9d\xb9\x21\x54\x53\x55\x22\x4f\x6e\x64\xbe\x9c\xb5\xc0\x69\xfa\xed\xa4\xa6\xc6\xb2\x9a\x58\xf3\xb4\xc6\x07\x1d\x5b\xdb\xad\xfe\x8a\xb0\x27\x1e\xad\x19\xaf\xc6\x19\x03\xcf\xff\x1c\xec\x4b\x04\x4d\x96\x43\xf6\x90\xad\xc4\x66\x46\x96\x88\x85\x33\x44\x4a\xdc\xc1\x60\x89\xa1\x24\x1a\xb3\x87\xcc\x88\xd3\xf9\x2c\x56\x90\x14\x1f\x2b\x89\x44\x34\x49\xbb\x8e\xce\xdb\xd3\x52\x50\xd2\x32\x3f\x9d\x3c\xa6\xa5\x8a\xd5\xe0\x91\x36\x4c\x36\xc9\x43\xbd\x85\x55\x19\x57\x22\xc5\xe0\x22\x78\xed\x82\x22\xbf\x4f\xbc\x4c\x3f\xf5\x81\xf3\x92\xc2\xde\x05\xad\xa1\x60\x58\xbc\xc4\x34\xed\xc2\x2b\x86\x88\xfb\x58\xfb\x54\x5f\xc4\x69\xe7\xe3\x7a\x5b\xf9\xe8\xcd\xff\x90\xe2\x2f\x24\x03\x11\xa7\x4d\x80\xcf\x35\x1d\x8b\x95\x7f\x9b\xe3\x2a\xee\x9e\x09\x6b\xb8\xe5\xff\x73\xb9\xc5\x39\x40\x6e\x29\x25\x72\xcb\x75\x27\x94\x5b\x60\x5e\xc0\x29\x32\xe7\xf3\x0f\x02\xfd\x28\x7a\x02\x04\x08\x1e\x24\x33\x66\x3f\x66\xf6\xa4\x80\x8c\xd4\x65\x23\x30\x1b\xea\xc3\xb6\x70\x63\xd8\x86\xff\xae\x3c\x8c\xbf\xe0\xfd\x5b\x7f\x9e\x9e\xd7\x56\x04\x3e\x19\xd8\x22\xc4\x8a\xa2\x4e\x4f\x9b\xef\x4d\x01\xbb\x46\x3a\x68\xa9\xcb\xbf\x0d\xd4\x4e\x92\x6a\x37\xd3\xb6\xb2\x87\xb7\xe2\x89\xd0\x13\xfa\xbf\xd0\x17\x73\xc3\x56\x66\xe3\xff\xa5\xbe\xf0\x44\x98\xda\x80\xbe\x78\xe0\xbb\xf4\x0c\x05\x10\x87\x40\xe8\x65\x76\xa7\x48\xbd\x6c\x94\x0d\xfc\x6c\xa8\x4f\xd2\x3e\xb6\x41\x07\x5b\x79\x3f\x6d\x0e\xed\x4f\x85\xf6\x63\xd9\x95\xd0\xde\x2b\xeb\x39\xca\x16\xb3\xc0\xbf\xd7\xbd\x9e\xcc\xb5\x83\x56\x61\xd7\xa9\x4b\xf0\xc5\xec\xca\x63\x3f\x2d\x29\x6c\x47\xf9\x3d\xe0\x13\x05\x86\xd1\xe9\x61\x78\x8e\x51\x79\xb4\x7c\x0a\x6e\x8b\xd0\x1e\x5e\x5b\x02\x5d\xe0\x0d\xca\x45\xec\x4a\xe5\xc2\x25\xc0\x93\xcd\x51\xc6\xe2\x7f\xa6\x37\x83\xcc\x45\x78\x46\x4d\xe6\xd2\x8b\x2c\xb9\xac\x13\x59\xf3\x04\x9d\x03\x9f\x11\xac\xf0\x3f\x73\x82\xd5\xaa\xac\x5c\xc5\xa0\x79\xec\x7f\x58\x3b\x3f\x0f\xf8\x3b\x11\xb8\x47\x83\xc8\x30\x40\x7b\x75\x7a\x2a\x86\xec\x4b\x31\x9c\xcc\xf1\x54\x20\xe1\x08\x50\xe0\xaa\x3b\x5c\x55\x70\xc7\x84\x45\x1e\x7e\x2e\x25\xe2\x49\xff\x62\x1f\x91\x94\x7e\xbf\x6d\xdb\xdb\x44\x4e\x01\xd9\xe8\x09\xe6\x6b\xf6\x23\xaa\x23\xf9\x1b\x52\x63\x70\x37\xe0\xfd\xe9\x2d\x30\x6f\x2a\x2b\x63\x0c\xd2\xad\xa8\x37\x00\x0c\xb4\x89\xe7\x8b\x84\x21\x38\xb3\x2e\x22\x09\x74\xdd\x74\xf3\xc8\xb5\x8f\x5e\xb2\x72\xe3\xc6\xc0\xf7\xdf\x07\x48\x3f\x0e\xe8\xe7\x77\x99\x7e\x72\x72\x2d\xd9\x82\xe3\xe5\x64\x07\x11\x46\x5c\x91\xb8\xe8\xb8\xe4\xd1\xb5\x23\x6f\xbe\x49\xd9\x40\xba\xd9\xb8\x11\xfa\x99\x01\xd2\xd1\x82\xf4\x8f\xd0\x4f\x50\x36\xc2\x16\x02\xb7\xac\x37\x70\x58\x47\xae\x9d\xbc\x55\xf2\x22\x69\x0f\xdd\xe0\x05\xea\x1c\xc6\xaa\x33\xa2\x6b\xea\x81\x3e\xe6\x67\xfa\x00\xe8\xf1\x64\x26\x22\x08\x96\x84\xfb\xcf\xf5\xe1\x81\x39\x88\x20\x17\xc5\x7b\xd4\xd1\x8d\xea\x64\x54\xbd\xa3\x01\xfa\x78\x34\xfd\x3f\x94\x2f\x2b\x96\x4d\x2a\x5f\xe6\xf5\xd9\x91\x49\xa0\x37\x60\x3e\xc4\x4f\xc0\x77\x7d\x38\x80\xed\x52\x3a\x07\x63\xbb\x60\x4f\xe6\xa0\x8f\xf1\x7f\x18\xab\x55\x44\xa3\xd3\x6b\x8e\xad\xa3\x79\x54\x0f\xa0\x8f\x99\x27\xe1\x59\x1c\x8d\x56\xfe\x7c\x6c\x1d\xf9\x1b\x1a\xa6\xfd\xed\x65\xf4\x27\xe6\x4b\xc6\x67\x15\x99\x9d\xe9\xd0\xb1\xb3\xe9\xb3\xd1\xca\x52\xa6\x38\x7d\x0b\x3c\xbb\x55\xf9\xf2\xe7\x72\xba\x86\x5d\x78\x2c\x73\x26\xbf\x91\xae\xa1\x52\x76\x4a\x2e\x97\x9e\xae\xc1\xb4\x65\x96\x1d\x58\x2b\x61\xcb\x2c\x34\x18\x06\xe5\xf3\x91\xf9\x6b\xc3\xd3\x3b\xe6\xcf\xeb\x84\x9f\x06\xed\x15\x8f\xa5\x2f\xf0\xc3\x7c\x97\x79\x47\xe4\x01\x3f\xfb\x21\x9c\xe3\x56\xf5\x1c\x82\xfc\x4f\x90\x00\xf3\x54\x76\xca\xf2\x8c\x61\x17\x48\x39\xd8\x8f\xe7\x7d\xb4\x9e\x6f\x5d\xff\x11\x2a\x6c\x07\x32\x20\x08\x5d\x44\x0c\x65\xc9\xb6\x65\xd0\x47\x95\x8e\xa8\xbc\x75\xfe\xfa\x8f\xf0\x3c\xf6\xc3\x8f\xd6\x13\x7e\x12\x64\xe8\x83\xe9\x7b\xb5\xf1\x18\x32\x1e\x93\xdf\x8c\xee\x35\x08\x79\xe1\xb9\xeb\x3f\x52\x6e\x4b\x0d\x68\x03\x63\x11\x3c\xc3\xd0\x28\x7f\x92\xaa\x42\x8d\x48\x61\xf8\xa0\x72\xdb\x47\xeb\x95\x2e\x98\x25\x4e\xef\x51\x3a\x99\xfb\xd2\xfb\xe1\x64\x96\x02\x8d\xa1\x1c\xa0\x0e\x91\x83\xf9\x58\x4a\x53\x09\x65\xd3\x94\x80\x38\x66\x83\x41\x1b\x93\xb6\x89\xdb\xf1\x4b\xdb\x01\xa1\xce\xfc\xf4\xd3\x4c\x2c\x26\xed\x07\xde\xf1\x28\xf0\x38\x25\x55\xb4\x93\x3d\x29\x44\x68\x8e\xd6\x05\xed\x00\x88\xcd\xc4\xed\xcc\x5c\x68\xfd\x94\xf2\xee\x56\xda\xf6\x31\xa5\x9b\x69\x4c\x7f\x8d\xf4\x40\x73\xad\xac\x4e\x87\x38\x51\x04\x1c\x37\xc0\x99\xd3\x67\x48\x56\x5e\xa5\xc4\x86\x7a\xb1\xb1\x19\xee\x2c\x57\xd8\x23\x9e\xf4\x70\x75\x0c\xff\x41\x49\xc4\xaa\x8f\xc5\x9f\x2e\x5a\xb6\x69\x79\x11\xc2\xfd\xff\xe5\x8f\xa4\xb7\x8a\x61\xaa\xbb\x00\xb0\x93\x35\x65\x75\x17\x2c\xd5\x5d\xbc\xa6\xa9\x2e\xf8\x23\x59\xd5\x05\xc2\x4a\x03\x7f\x04\x79\xb5\x76\x64\x09\xf9\xed\x30\xd5\x5e\x28\x0d\x9a\xfa\x82\x3f\x92\x51\x5f\xc0\xfc\xc7\x71\x73\xf1\x5f\xa8\x7e\x2a\x22\xbb\x45\x56\x60\x01\x11\xd7\x0a\x9b\x05\x86\x48\x1b\xbb\x84\x37\x04\x4e\xc8\x72\xcf\x44\x0f\xa2\xa9\xbb\x1e\x1f\x54\xdd\x05\xe7\x47\x93\x27\xac\x02\x73\x2b\xed\x7f\x1e\xb7\x16\xff\x0f\xd5\x29\x05\x76\x93\xfb\x63\xbc\x6c\x4c\xc1\xfd\x9b\xaf\x4e\xaa\x52\x75\x38\xb7\xe5\x29\x92\xb0\x72\x11\xbf\x8d\xb9\x45\xa8\x81\x76\x36\x68\x77\x00\x8f\x47\xc4\x45\x9b\x48\x3c\x64\x3d\x61\x51\xb9\x28\xc0\xb1\x01\x7e\xdb\x6f\x7e\xa3\xee\xe1\x6f\x60\x1d\xff\x4b\xe5\xeb\x30\xc8\xf8\x92\x80\x05\x1d\x11\x4c\xa8\x64\xbd\x0b\xbd\x81\x38\x2a\x92\x24\x0e\xcd\x49\x68\x44\x22\x2b\x4e\x6f\x3d\x81\x34\x8d\x91\x95\x5b\x85\x47\x13\x59\x1a\x35\xc9\x55\x44\x8c\x46\x7a\x59\x3f\x59\xbf\x52\xbf\x45\x7f\x9b\xfe\x51\xbd\x88\xf4\xf5\xf4\xe3\x73\xfa\x37\xf5\x9f\xe8\x45\xf2\x94\x91\x40\x8c\xa6\xab\x3a\xb3\x8a\x58\x5b\x73\x42\xa7\x75\x50\x99\x33\xbd\x8e\x5b\x8a\xff\xcc\xcf\xa4\x74\x21\x22\xbb\xec\x26\xd8\xbb\x4d\xf0\xa7\xc9\x68\x25\x62\xb7\xe4\x43\x89\x38\x1b\x15\x12\x84\x70\x3e\x41\x98\x5b\x3f\x76\x6c\x7d\x43\x67\xa7\xb2\xac\x7e\x6c\x77\x03\xbc\xe1\x96\x76\x25\x12\x1d\x63\x92\x89\xae\x71\x75\xf5\x5d\x5d\xf5\x89\x2e\x02\x57\x0f\xff\x6a\xfa\x15\xb1\x0a\xd9\x51\x54\x96\x2c\x92\x24\x08\xc8\x60\x70\xc0\xf1\xd6\x99\x25\x4a\x4c\xad\x2f\xa9\xf8\xaa\x9a\x16\x58\xea\xa9\x14\x87\x41\x88\xf2\xda\x15\x69\x1c\x89\x3f\x4e\x56\x76\x77\x86\x66\x2e\xfd\xd7\x94\x59\x2b\x3b\xea\x85\x75\xa1\x52\xef\x82\xe2\x1b\x87\x4f\x37\x26\xce\x65\x8b\xe9\x9a\xfe\xc2\x45\xf0\xc5\x9a\x1c\x1d\x92\x9d\x26\x55\x72\xb6\x0f\x90\x9a\x13\x87\xab\x12\x27\x26\xd8\x0f\xfe\x2a\x39\x99\x49\x9f\xc1\xcd\x65\xae\xd5\xe4\x40\xc0\x60\x1d\x0b\x50\x9b\x25\x0c\xb6\xf5\x19\x0c\xce\x89\x7d\x5b\x7f\x49\xec\x03\x9c\xda\x04\x7d\x07\x33\x67\x83\xc4\xe3\x6e\x99\x25\x0e\xa2\xae\xd5\xce\x46\x56\x47\xcb\x04\x07\xd7\xd1\xa2\x0d\xdc\x24\xf4\x1d\xd5\xd1\x96\xc8\x6e\x0c\xf3\x24\xfa\x59\xe6\x78\xfd\x2c\xc1\x1c\x60\x6d\xbe\xd3\x14\xb3\xf4\xfe\xb0\xc2\xdb\x3e\xda\x56\x44\x71\xd9\x27\xb0\xa4\x3d\x7f\x82\x0e\xb4\x19\x91\x4e\xc8\xcf\xc5\x2b\x56\x7c\xa5\xf6\xa5\x1c\xd4\xfa\x53\xce\x87\xf3\xb2\x93\xdf\x9c\x0f\xb7\x6b\x7e\x11\x6e\x94\xf6\x84\xe9\xef\xb1\xca\x0b\x02\x76\x5c\xcc\xe3\xa1\xf4\xcd\x5a\x1e\xfa\xa2\xa4\x28\x4b\x90\x18\xf5\x3c\x0a\x8f\xc0\x79\xf4\x01\xdf\x14\xf2\xd8\xae\x4d\x79\x3c\x06\xaa\xf2\x42\xba\xeb\x52\x83\x0c\x54\xa5\xba\xd3\xd5\x55\x0d\x3c\xa0\xf9\xe9\x79\xf3\x0f\xeb\xd7\x99\x13\x95\x3b\xb5\xf8\x89\xdc\xd9\xc2\xca\x13\x5c\x2f\x76\xf3\x77\x20\x09\x56\xe8\x45\xfa\xad\x29\x01\x76\xd0\x3c\x28\x75\x23\x83\x52\xbf\xb1\x08\x95\xe0\x48\xe2\xdc\xe0\x79\xeb\x84\xd3\x98\x99\x93\x27\xaf\x88\x9d\x16\x7a\x8a\xbf\x63\xed\x9a\x58\x79\xcf\xe8\xf6\xe9\x37\x3d\x40\x68\x43\x13\xd7\x84\x77\xf1\x3f\x21\x1b\xf4\xed\x63\xeb\xa4\xcd\x12\xf3\xa8\xf4\xa6\xc4\x48\x52\x48\xea\x95\xd6\x4a\x3b\xa5\x5d\x92\x20\xd1\xdd\x38\x4c\x09\x41\x33\x95\xb8\x54\xc7\xac\xd2\xb2\xa6\x43\xfb\xcc\xa9\x29\x81\x70\x60\x5c\xe7\xc8\xf1\xdc\x93\x17\xde\x55\xd2\xe1\x6e\xad\x72\x85\x4a\xa2\x81\xc4\xf0\xae\x81\xfd\x4b\x75\x04\xeb\x1e\x65\xdf\x54\x51\xaf\x97\x5d\xcb\xee\x04\x04\x14\xd8\x4c\xff\xa4\x56\x16\x95\xdf\x6a\x19\xf5\x34\xe1\x5d\xf9\x03\xf0\xe7\x0c\x1c\x80\xf2\x66\xe3\x61\x8c\xf3\x73\x63\xe8\x37\xeb\x99\x47\x81\x94\x01\x0d\x0b\xe9\x7b\xf5\x6b\xf5\x3b\xf5\xbb\xf4\x82\x3e\x7f\x0c\x55\x68\xcc\x08\x62\xf8\xfc\xd2\xb2\xca\xd0\x7a\xd3\xfa\xeb\x16\x4e\x69\x1e\xc5\xdf\x5a\x52\xeb\xf1\xc5\xbc\x1d\x91\x0e\xef\xc5\xf3\x67\xaf\xac\xa7\x63\x1c\xe4\x9a\x98\xa6\xcc\x18\xa8\x8e\xc0\xfe\x51\xe1\x4d\x75\x03\x7a\x85\xb5\xc2\x4e\xd8\x06\x41\xc8\x8e\xa1\x1a\xc9\x72\x4b\xc1\x4f\x35\x75\x1e\xda\x6b\x9a\x35\x19\x56\xd2\xc3\xff\x34\xaa\x9d\x2c\xc4\x33\xa2\xca\x15\x0c\x96\x06\x1a\x3a\xd4\xbb\xef\x76\xa5\x13\x0d\xa3\xfa\x7e\x3b\xe1\x1f\xae\x99\x45\x80\xc4\x10\xe0\x54\x65\x10\xb7\x74\x10\x7d\xbf\xd2\xa1\x74\xa1\x6a\xaa\xef\x1f\xa4\x9d\x76\x69\x76\x1c\xa7\xf3\xc7\xe9\x76\xa5\x03\x3d\x9b\x7e\x1f\x4e\xa2\xff\x71\x96\xe3\xb0\x28\xc2\xc5\xe6\xdc\x3d\x4b\x44\xd9\x2c\x2c\xe4\xf0\xa9\x7a\xe3\x67\x89\x26\x5b\xe9\xb8\x74\xd3\xa5\x68\x60\x5b\x9e\x61\x44\x8c\x45\xda\x16\xe7\xb7\x15\x09\x87\x04\x3c\xd9\x41\xd2\x36\xa6\x36\x85\xf9\x7e\xcc\xdd\x8d\xff\x2e\x8c\x82\xf9\x3a\xf6\x71\x78\x73\x0a\x71\xb4\x29\x61\x1c\xc9\x84\x1b\xa9\xa4\x3a\xbc\xff\x2e\xd6\xc0\xdd\xfd\xe3\xbd\x4a\x1f\x81\xff\x66\xf6\x1a\xe6\x62\xfe\x53\x64\x45\xba\xdd\x3a\x0b\xb0\x54\x44\x15\x9a\xc1\x12\x0a\xeb\x26\xbc\x39\x1c\x0f\x2f\x99\x32\x76\x7a\xfa\x88\xed\x5b\xee\xb7\xee\xa2\x50\x75\xb4\x7b\xe6\x8c\x8e\xed\x9f\x8e\x5a\x70\x0a\x99\xf3\x2d\x30\xe7\x85\x30\x67\x33\xb2\xec\x36\xa8\x63\x1a\x10\x39\xa7\x62\x81\x0d\xc0\x95\x31\x01\x1c\xc9\xb3\x00\x90\xf6\x8d\xb0\x3f\xaf\xa5\x5f\x80\x35\x5b\xf6\x82\x54\x03\xe7\x9d\xaa\xee\x89\x8a\x5c\xd5\xf8\xbf\x06\x4b\x54\x3a\xb7\x6b\xfa\xfa\x82\xef\x33\x82\x90\x31\x15\x00\xe7\xe8\x52\xd5\xf1\xe4\xfb\xad\xda\xd7\x29\x4c\x3b\xd1\xc1\xf4\xef\x80\x92\x39\x9f\x50\x35\xfa\xac\x3e\xab\xd1\x27\x3b\x91\xd3\xe1\x1f\x54\x55\xf8\xca\x33\xaa\x0a\x1f\x2b\x4f\x2a\x1f\xe3\xae\xf4\xd9\x40\x57\x75\xbb\x09\xbf\x97\xd4\xd8\x8b\x27\x03\xcc\xea\x80\xf2\x31\xd1\xdd\x2b\x77\x2b\x13\xf0\x70\x74\x03\xd0\x11\xe9\x71\x24\x5e\x9f\x62\x91\x89\x30\xb4\x04\xb9\xb2\x2e\xa6\x6d\x38\x0c\xa7\x63\x4f\x2e\xa3\x6c\x1c\x87\xc3\xa5\x47\x94\x09\x6a\xd2\xd8\xf7\x0f\x3c\xf3\x26\x9d\x2b\x3c\x61\xac\xd0\x97\x03\xd9\x9f\xb0\x22\x64\xbe\x3e\x05\xcb\xac\x3b\xac\x5d\x21\xaa\xf6\x36\x2c\xe6\xe5\x46\xc5\x2d\x3b\x1e\xe6\x63\x38\x1c\xcf\xe4\x41\x9d\xa1\x4c\xb8\xf1\x8a\xe0\xc8\xb7\xde\xcf\xa4\x3d\xa5\xfd\xba\x95\x33\xd0\xd8\xf4\x1d\x00\x03\xaf\x6c\x44\x82\x60\xd2\x23\xd6\xaa\x22\x73\x52\x63\x03\xc5\x3c\x3a\xfa\x8f\x0c\xed\xfc\xdf\x2c\xc1\x64\x94\x2a\x65\x0d\x5a\x9b\x5e\x44\xef\x6d\xfb\x13\x26\xe0\x83\x37\xa5\xec\x44\xc4\xd2\xae\x93\x13\xb0\x1e\xba\x81\x9c\x87\xb2\xe6\x78\xce\x83\xf4\x7f\x81\x32\x0e\x85\xd3\xdf\xd3\xfe\x5d\xbb\xed\x68\x7f\xfa\xb9\x7d\xc0\x19\x68\x62\x1c\xe1\x06\xd8\x13\x70\x03\x7b\x06\x8a\x6f\xe3\x06\xe3\x06\xc8\x19\x39\xa3\xff\xc7\xf4\xbf\x40\x26\xb0\x22\xd7\xde\x36\xe0\x02\xc9\x20\x8f\x19\x2d\xdd\xe4\x90\x1c\x9e\x03\x40\xc8\x60\xbd\x46\x60\x76\x8e\x98\xfc\xe2\x93\xe6\x87\x03\xa1\xc0\x49\xdd\x93\xdb\xd7\xdc\x1a\xec\x28\x9f\xe6\x2c\x2e\x89\x17\x35\xd0\xdc\xdd\xca\x68\x65\x32\xbc\xd6\x01\xbf\x64\x7b\x02\xf1\x64\xef\xcd\x26\xca\x27\x55\x51\x1d\x76\xa6\x38\x4d\x73\x92\x96\xaa\x16\x94\xbf\x4c\xee\x88\x35\xd7\xd7\xb5\x2e\x9d\x31\xab\x6a\x72\xea\x3e\x65\x72\xd1\x7c\x47\xa2\x72\xa2\xf8\xc2\x0a\xe3\x94\xd6\x05\x67\xd3\xbd\x6a\x53\xa6\xa2\x7f\x51\xdd\xbe\x79\x1f\x55\xe5\x53\x0c\xc8\x00\x38\x4f\x79\x5f\xf2\x8b\xba\xfb\xf4\xab\x70\x2e\x9b\xa9\x2d\x95\xd0\x2f\xbc\xa5\x80\x7e\x91\x8b\xbf\x39\x63\x49\xc5\x00\xfb\x4e\x7c\x59\xfa\x33\x18\xca\xf4\x18\x87\x18\x81\x2a\x02\x88\xf4\x0f\xc2\x9f\x2d\x6c\x7b\x57\x99\xfa\x08\x0b\x72\xf6\x8f\x3f\xe2\x1d\x40\x38\xb0\x72\x9d\xf2\x04\x5e\x91\x5e\x8f\xbc\xa8\x4a\xd6\x1b\x5c\x2e\x4e\x44\xc8\x6e\x01\x60\xca\x46\xbd\xd4\x6d\xb1\x12\x1b\x01\xc3\x11\xec\x3a\x54\x95\x48\x64\x85\x1b\x00\x46\x52\xdd\xb4\xa4\x5a\xd9\x8d\xb8\x20\xc1\x93\x3b\x81\x24\x74\x0d\xa1\x56\xc6\x85\xad\xad\x0b\x81\x36\x74\xfd\x34\x36\xd1\x30\x8e\x58\x20\xa7\x4c\x59\xd3\xd3\x30\x0e\xc6\xb4\x29\x63\xd1\x4e\xaa\xb7\xf1\xc9\x66\x91\x72\x72\xd4\xac\xc0\x50\x76\x51\x45\x42\x4f\x86\xcb\xda\x39\x98\xbe\x06\xf7\xef\x05\x1c\x6b\xa7\xba\x0f\x0f\x39\x07\xc4\xca\x2e\x86\x58\x4c\xcf\x81\x76\xc8\x32\x32\x4c\xff\xde\x9c\x10\xa3\x8c\xcb\xd9\xec\x95\x4e\xe8\xe3\x9e\xf4\xb5\x40\xef\x3c\x32\xa9\x8b\x8f\x91\x81\x5c\x57\x04\x68\xb0\xdc\x39\x19\x3c\xcd\x32\x28\xcf\xe5\x31\x25\xca\xb8\x02\x7b\x5c\xff\xc7\xd0\xd7\xc8\x34\xf1\x99\x2e\x95\xed\x66\x24\x60\x62\xbe\x21\xbc\x48\x76\x61\xd4\x7a\x44\xd2\x2c\x69\xc8\x99\xc7\x82\x3c\x5d\xc0\x82\xac\xce\xe7\x40\x48\xdf\xef\x2b\x8b\xd0\xe3\xe9\xed\xc8\x05\xb2\xa7\x93\x1a\x65\x90\x01\x6e\x31\xbb\x81\xd8\x6d\x42\x06\x6c\xc8\xda\xa6\xe8\x2f\x4a\xae\x06\x31\xba\x9c\x32\xa8\xcd\x45\x59\x34\xc0\xe6\x82\x95\x62\xe5\x08\x7a\x28\xbd\xf1\x38\x5a\x59\x4c\xad\xef\x47\x08\xad\xec\xf7\x29\xfd\xb8\x28\x7d\x43\xc1\x77\x00\xc7\xfa\x7d\x1c\xa7\xf4\x53\x61\x8d\xe9\xbf\x44\x69\xc0\x97\xd2\xef\x10\x6c\xe4\x39\xfa\xbd\xc3\x09\xf5\x9b\x3c\xf9\xf6\x25\x1c\x77\xf4\x98\xda\xe2\x30\x69\x84\x95\x57\x18\x17\xbe\x93\xed\x84\xb5\x96\xca\xb6\x81\x6b\x35\x50\x8d\x64\x6e\x9d\x8e\x41\xd7\x79\xe3\xa0\xeb\x64\x5c\xc7\xad\xf3\x1b\x66\x1e\x3e\x9f\xf9\x0f\x5d\x03\x35\xe8\x6a\xeb\xfc\x86\xac\x93\x99\x47\xef\x04\x89\xe9\x65\x6a\x07\xf9\x8e\x14\xe0\xb8\x00\xd3\x0b\x93\xc6\x4a\x49\xfa\x1b\xfc\x09\xfb\x10\x7c\xc7\xf0\x18\x43\x9c\xe6\xdb\xda\x1a\xea\xf9\x38\xf6\x28\xa7\x9f\xc4\xae\x3e\xc9\x49\x7e\x91\xf1\x0e\xc0\xf7\xe6\xf1\xd7\xd2\xef\xb1\x08\xab\xdf\x13\x23\x38\xb9\xff\x5a\xc6\x77\x8d\x13\xa4\xda\xfc\x3b\xd8\xf4\x98\xd1\xc0\xc2\xc9\x4b\xbe\x04\x63\x7a\x0a\x2c\xfa\xee\x8c\x41\xff\x48\xbe\x3d\xbf\xe0\xec\xf3\x0c\xd1\x0c\x24\x08\xb4\x79\x38\xf7\x44\x27\x82\x2f\x3b\xf6\x9f\x47\xf0\x23\xc5\x4a\x1f\xde\xf1\xe3\x8f\xc0\xbb\x37\xc3\x7d\xfa\x6a\xfa\x90\xb6\x3f\x22\x26\x7c\x26\xdd\x1f\x47\xd8\x16\x66\x1b\x23\xae\x57\x95\x15\xf8\xba\x2b\xd6\x43\xb7\x17\xa7\xd1\xfa\xf5\x64\x8c\xdf\x28\xbf\xc5\x4b\x80\x5e\xf8\xe1\xcc\xe8\x91\x95\x35\x99\x5c\x3a\x8f\x83\xb6\x03\xca\x40\x48\x0d\xa6\x68\x5d\x84\x23\x5a\x11\xca\x08\x75\xd3\xa4\x0a\x7d\xec\x31\xb7\x95\x37\x76\x4e\xee\x6c\xac\x18\x69\x9e\x6a\x59\x31\x6e\xd1\x88\x11\x8b\xba\x4f\xb7\x29\x9f\x45\xab\xbb\x93\x7e\x7f\xfd\xf8\xea\xe8\x98\xd9\x53\xa6\xa4\xba\x28\xfd\x8c\x70\xc5\xe8\x43\xfe\x5d\x6a\x0f\x33\x32\x3a\x1d\xaf\x17\x8d\x3c\x4f\x64\x9f\x24\x1d\xcb\xd6\x42\x19\x30\x31\x2e\xc6\x9b\xe3\xcd\x9e\x66\x8f\xf8\x61\xd7\xb6\x6d\x99\x7f\xdc\x69\xe4\xe5\x46\xf5\x03\xed\xef\x12\xce\x8c\x2e\x14\xea\xe0\x56\x4a\xca\xe5\x12\x6b\x0c\x79\xea\x3c\x6d\x9e\x5e\xcf\x5a\xcf\x66\xcf\x4e\xcf\xb3\x9e\x8f\x3d\xdf\x7a\x0c\x92\x27\x44\x1f\xed\xf4\xec\xf2\xa4\x3d\xa2\x87\xc8\x0d\x87\x88\x29\x85\xcd\xf1\xdd\xae\x1c\x8b\x7f\xc9\x90\x21\x25\x65\x25\x1b\xd6\x68\x2f\xdc\x5a\xd6\xe3\xf7\xd4\x24\x86\x45\xa6\x9c\x72\x66\xee\xad\x7a\x2f\x6e\xe3\x7f\xc3\xbc\x27\xfc\xac\xc1\x1b\x31\x3c\x97\x39\x0f\x9a\xfe\x58\x79\x8a\x60\xd5\xd1\xbf\x90\xdf\xc2\x82\xcc\x99\x48\xdf\x0d\x32\xd6\x48\x2a\xc3\x05\x65\x07\x91\xdf\x06\x93\xaa\x00\x10\x94\x03\xfe\x4c\xe3\x80\x33\xb2\x1a\x50\xb5\x18\xc8\xb7\xa6\x5f\xd1\x9e\x72\xc2\x31\x8d\x11\x26\x62\x32\x65\x84\x71\xfa\x7c\xae\x9d\x99\x4e\x6d\xc7\x23\xe4\x2a\xf5\x24\x22\xc3\x35\xb3\x06\x9a\x87\x77\x22\x6e\x10\xe3\x30\x31\x98\x93\xe3\x7a\x22\x53\x30\xee\xfa\x75\xa6\x60\x58\x87\xe6\x6b\x08\x77\xb4\x6e\xb7\x95\x55\x79\x5c\xb8\xe3\x1b\x47\x32\xc4\xea\xa8\x71\x14\xcc\xfc\x97\x9e\x19\x3a\xb5\xba\xa8\xa2\x6b\x66\x47\xcf\x22\x6e\xd3\x6f\xdf\x6b\x98\x2d\xb5\x4e\x28\x75\x87\xfd\x55\xd3\x46\x8d\x59\x8e\xd8\xf4\x7f\xb9\x1e\x66\x0f\xff\x37\xca\x9f\x14\xa1\x11\x8f\x09\x76\x93\x7d\x3f\x76\x3d\x9e\x42\x26\x93\xd7\x1b\x00\xc6\x57\x76\xcd\x02\xfe\xca\x3b\xcf\xcb\x3e\xea\x7d\xd3\xcb\x48\xde\x90\x77\x97\x97\xf5\x66\x15\x34\xde\x0c\xaf\x74\x22\x35\x8d\xa7\xd1\x91\x74\x61\xa6\xab\x46\x1e\x55\x5d\xdd\x36\xb2\xff\x3b\xed\xcd\x94\x55\xdf\x2b\x3f\x70\xa7\xca\x35\x35\x23\x5b\x6b\x6b\xdb\xc8\xab\x5c\x55\xdb\x66\x09\xe3\xd5\x31\x65\x2b\xc0\x3a\x01\xe7\xbf\x27\x7d\x1d\x9c\x7f\xc3\x1e\x3d\xa2\xba\x51\x42\xcf\x1b\x81\x47\x94\xb0\xca\x2d\x8c\xbe\x9a\x2b\xfa\x6d\x80\x2b\x0f\x15\x17\x77\x2b\x1d\xe7\xd7\xdc\x73\x43\x59\x5c\x9a\x50\xa7\xf2\x45\x17\x80\xec\x70\x19\xc8\x0e\x22\xf0\xb0\x02\xc8\x0e\x94\xab\x4e\xbc\x5e\x35\x90\x05\x00\xc9\x41\x65\x01\x80\x4e\x2b\x4a\x03\xc3\xfc\x22\x9d\x56\x06\xd0\x69\x26\x3d\x03\xe6\xf9\x00\xe5\x49\x44\xe0\x21\x79\x4c\xd8\x12\x4a\x3f\x34\x35\x82\xa6\x92\x18\x41\x55\x12\x84\x39\xa1\x2a\x09\x9c\xa5\x39\x3c\xac\x8f\x2a\xa8\x5f\x57\x15\x18\x20\xd3\xbc\x7a\x85\xf2\x1f\x7c\x1d\x10\x1b\x74\xb1\xba\x96\x4d\xec\x11\xbc\x84\xbf\x0d\x68\xcd\x62\x79\xac\x64\x37\x3b\x91\x73\x6b\x8a\x67\x44\x64\x16\xb7\xa6\xbc\x66\xab\x19\x99\xaf\x99\x65\x64\x09\xd2\x11\xec\xdb\x85\x9e\x45\x44\x14\x07\x9c\xfe\x36\x87\x8a\x99\xbf\x7c\x8b\xf4\x48\x0e\x45\x28\x83\x48\x7c\x16\x0e\x69\x25\xec\xd4\xb0\x2b\xf5\x37\xbd\x51\x80\x98\x64\xd1\x94\xd0\x94\x0c\xa2\xce\xaa\x29\xaf\x3d\xb7\xa9\xca\xa3\xa2\x6a\x7d\x6d\xdd\xb9\x43\x23\x5e\x0d\x59\xeb\x9d\x3d\xed\x0b\x4a\x08\xbe\x7a\x66\x8c\x5a\xe4\xa7\x18\xcb\x2a\x8f\xb0\x0f\xe2\xa9\xc2\x7f\x89\xc6\x0f\x66\x55\x27\xbb\x9d\x9c\xd1\x18\x0f\xd4\xc4\x37\xa5\xac\xc0\x6e\x84\x6b\x02\xe1\x4d\xa9\x40\x0d\x15\x0b\xa8\x48\x78\x28\x93\xf6\x24\x79\x28\xef\x72\x53\x4b\x60\xd0\xba\xbe\xf4\xc0\xe4\xb1\xf7\xb6\xbc\xf7\x17\x4c\x5f\xd9\x12\x2e\xf5\xeb\x97\x18\x97\xcd\x6f\x98\xd4\xd9\x1a\x74\x78\x24\xd3\x12\xe3\x12\xe5\xbe\xae\x64\xb2\x2b\xff\x87\x7b\xf2\x94\x9a\x9a\xce\x9b\x2f\x8b\x26\x6a\xcc\xc5\x1d\xdb\x37\xe2\x17\xc9\xf3\x21\x5d\x5d\xfd\x1f\x68\x6f\x34\x7a\xc5\xfe\x03\x5f\x24\x4c\x84\x73\x5f\x85\x2a\x64\xbb\xdd\xc0\x19\x62\xc5\x6e\x03\xfc\x8f\xca\xfd\x25\x12\xf1\x60\x3a\x94\xfc\x20\x71\x88\x06\x44\x59\x0f\x01\x4d\xb6\x1e\x3a\xd1\xa5\x3c\x38\x4b\xb2\x60\xd0\xb3\x3f\x63\xd0\xa7\xec\x3f\x0a\x28\x02\x4e\x1e\x77\x9f\xff\x8f\xd2\x8d\xed\xe9\xaf\x81\x07\xb3\x3f\xce\x1a\x0c\x3c\x32\x53\x13\x56\x42\xbd\x26\xe2\xcd\x11\x8f\x18\x27\x5a\xf9\x24\x5c\x16\xae\xd3\xaa\x63\x4f\xc7\xaa\x1f\x7e\x58\x7d\x51\xba\x8b\x96\x2f\x2f\x7a\x9a\xe8\xe7\x97\xc1\x8b\x2a\x6f\x36\x00\xae\xbe\x99\x7e\x0d\x10\xc7\xf9\x84\x88\x78\xcc\x71\xac\x8e\x5a\x36\xe1\xee\x21\xb7\x64\x1c\xe4\x4d\x91\x08\x86\x8f\x2d\xdf\x44\x5a\x3d\xad\x7c\x5f\xf6\xc7\x3f\x96\x41\xa7\xa4\xbd\xb7\x3f\x04\x40\xfc\x84\x7f\x5e\xd5\xf9\x02\x06\x0c\x47\x5d\x68\x1a\xa0\xe4\x32\xb4\x06\x6d\x00\x12\x7c\x0b\xba\x17\x3d\x06\xa8\xf9\x22\x7a\x0d\xbd\x85\xde\x45\xef\xa3\x8f\xd1\xe7\xe8\x6b\x74\x9f\x7c\x72\x38\xb0\xee\x99\x67\x2e\x78\x62\xca\x9c\x39\xe3\x4f\xde\xbd\x64\xc9\x83\x0b\xa8\x31\xec\xec\xbb\xef\x3e\x63\x67\x4b\x47\x47\xb2\xed\xa6\x6b\xaf\xbd\xfe\xf2\x9a\x78\xe0\x89\x93\x17\xb0\x3b\xdb\x2e\x8f\xc7\x2f\x6f\xdb\xc9\x2e\x38\xf9\x89\x80\xfe\xaf\xaf\xbc\xf3\xce\x9f\x7e\xff\xf6\xa7\x5f\x7e\xf6\xd5\xf3\x6f\xbc\xf1\xd5\x97\x6f\x73\x6f\xbe\xf7\xf2\x9f\x3e\x7c\xe1\xf5\xd7\x3f\x3a\xf4\x26\xb9\x39\x89\xd2\xb7\x2e\x99\x1f\xc1\x4b\x9d\x06\x68\xad\x4e\xf5\xbf\x6c\x9c\xc3\x2f\xff\x2a\x74\xb6\x8a\xe5\x3b\x5e\x9d\x00\x45\xf9\x5f\xf1\xfd\xfc\xe7\xf1\x13\x7c\x87\xfd\x15\x6d\xf9\x13\x7c\xa7\xe0\x39\xb5\x6b\xd9\x54\x8b\x53\x84\x52\x47\xc2\x2a\x25\xf9\x30\x7d\x1a\xa6\x6e\xaa\xf0\xa3\xe0\x62\xb7\xbb\x98\xfc\xb0\xdb\x32\xef\x94\xc6\xcc\xbb\xcc\x0f\x1e\x93\x79\xd7\x7f\x6e\xe6\x1d\x73\xc5\xf1\xcf\xfa\xb2\x9d\x4d\xce\xbc\xfb\x2f\xf9\x15\x72\x41\xaf\xb7\x91\xdf\xb4\xb7\xde\xcc\xbb\xfe\x07\x32\x7f\x65\x27\x0e\xf2\xec\x85\xbe\xb7\xf1\x50\xe5\x95\xb7\xfb\x8e\xae\x79\xbb\x8f\xbc\xeb\x7b\x9b\xe9\x50\x5e\x21\xef\xf0\x50\x66\x4c\x5f\xdf\xcf\x77\xf6\xf5\x31\x9f\x14\xce\xb5\x58\x19\xaf\xbd\x61\x1f\xd2\xde\xac\x1a\xf0\x8d\xfe\x4d\x03\x1e\x3c\xa0\xbe\x86\xf0\xd9\xea\xc8\xc5\xfd\x07\x33\x7d\x2c\xd4\xde\x68\xb3\x0b\x7d\xae\xbd\x2a\x4f\x68\x5f\xfd\x4c\x7b\x65\x17\xbe\xdd\xf7\x73\x5b\xdf\xdb\x5c\x0c\x26\xfd\x73\x1b\x1e\xfa\x76\x5f\x1f\xf7\x53\xdf\xb1\x0d\xea\x74\x55\x7d\x25\xcf\xa6\xb1\x9d\x7f\x04\x64\x3b\x62\x27\x14\x45\x0e\x63\xbd\x40\xd9\xbe\xc3\x39\x3b\x9f\x83\x58\x91\x1b\x93\x1e\x57\x49\x80\x58\xa3\xd9\xf4\x48\x6a\x8d\x26\xe7\xf6\x49\x4e\x40\x97\xf2\x3b\xe0\x0e\xf5\xca\x7a\xcd\xaf\x55\x75\x6b\xcd\xb5\x2e\xd0\x68\xe9\x33\x1a\x2d\xee\xad\x9c\x4a\x8b\x49\xaf\xe4\xe6\xe1\x37\x85\x0d\xb4\x4e\x9d\x2c\x47\xdc\x56\x2b\xcb\x9a\x83\x82\x59\xaf\xca\x75\x93\xe8\xbd\x92\x46\xbc\x9e\x05\x41\xd6\xe7\xb8\x36\xe5\xcb\x98\x76\xd5\xa2\x2b\xd6\x43\xd4\x45\xd4\xa6\xfa\x50\x0f\x90\xf9\xf2\x71\xf8\x1d\x22\xff\x19\xe6\xb7\x4f\x39\xb3\xe4\xb4\xd0\x81\x8e\x4c\xaa\x34\x61\x03\x91\x04\x47\xf7\x8c\x99\x76\xf3\xfd\xca\x39\x5a\x6a\x34\xa0\x73\x0f\xc0\xdd\xdb\x97\x56\x80\xae\x54\xca\x76\x03\x42\x02\xc7\x99\x80\x3d\x56\x99\x63\xbd\x48\x45\x7e\xea\xfa\x90\xb3\x49\x16\xb2\xc9\x7d\x79\x6c\xb2\x72\x4d\x21\x9b\x0c\xfd\xff\x43\xe9\x4c\xff\x2f\xb5\xe5\x03\xfc\x81\x8d\x13\x19\x46\x2f\x52\x3b\x6d\x5e\x7f\x2c\x75\x05\x70\x89\x1e\xbd\x6a\xc9\x57\x3a\x35\x53\x3e\x56\xbe\x82\xf6\x3f\x64\xda\x63\x9e\x07\xf1\x57\xaf\xc3\x5c\xe1\xfe\x61\x75\xf7\xc4\x88\xf2\x95\xea\x4d\xa0\x5c\x9a\x75\x27\x80\xbb\xc7\x0d\xb4\xf7\x4b\xda\x07\x89\xd2\xf2\x99\x8c\x56\xab\xde\x6c\x46\x58\x20\x4e\x12\x76\x49\xaf\xe3\xac\x46\x23\xa6\x9d\x92\x75\x5a\x3f\x38\x94\xc8\xb7\xbf\x6a\x16\xef\xcc\x18\xb1\x8c\xf3\x83\xe2\x56\x07\xc3\x25\x9a\x17\x84\x36\x68\xab\xe6\x0c\x41\xe9\xfe\x8f\x80\x3f\xcf\x65\xf0\x47\xf3\xb1\x56\x5d\xac\x73\xd0\x2c\x90\xc7\x56\x66\xe4\x31\xee\xad\x9c\x40\x86\xd1\xdf\xb9\x9b\xf0\xef\xf8\x33\x61\x9f\x6c\xbb\x59\xfd\x01\xec\x42\x29\xc4\x66\x6c\x9b\x79\xa9\xf3\xf0\xef\xe4\x9a\x6a\x59\xae\xae\x91\x79\x5e\x7d\x95\xe9\x3e\x1c\x00\x18\x2c\x4c\xbf\x02\x10\x68\x06\x08\xe8\x2d\xa2\x68\xd6\x0b\x3a\x9d\x24\x20\xd6\xca\xf3\x36\x81\x35\x72\x1c\x63\xa4\x1a\xd0\x6c\x49\x2d\x58\x7a\x5d\x26\x21\x01\x6c\x92\x27\xd2\xac\xee\x7a\x3c\x29\xc2\xc6\x7b\xc4\x54\xf4\xac\xc8\x96\xba\x9b\x6f\xae\xdb\x12\x39\x2b\xba\xa5\x6e\xc7\x8e\x3a\xe5\x8b\x5b\x6f\x3b\x67\x59\x75\xcd\xd2\xb3\x6e\xbd\x75\xd5\xe2\xea\xaa\xa5\xc4\xd1\x0e\xe0\xdf\x81\xdd\xe9\x6f\xb5\x9b\x2b\x2c\x5b\x6a\xec\x81\x80\x24\x84\xc3\xf1\xb8\x9e\x75\x49\x14\xc7\x12\xd9\xcb\x83\xe4\xf6\xa6\x04\x3b\x97\x39\xdd\x4d\xf3\xb2\xb9\xf9\x4c\xf6\x39\x72\xe3\x67\xd4\x7c\xf0\x04\xbb\x2f\x4c\x35\xa6\x8a\x8a\xe0\xd7\x85\xb9\x77\xca\x84\xf6\x9a\x9a\x76\xf2\xb3\x38\xf3\xe6\xab\xd4\x85\xb5\xe5\xe5\xb5\x17\xa6\x52\x17\xd6\x94\x97\xd7\x5c\x98\x52\x1f\x67\x7f\x60\xbf\xfe\xc0\x4d\xc2\x57\x0a\x67\xa8\x7a\x64\x9e\xa7\x7a\x64\xf5\xce\x6f\x8e\x38\x92\x62\x92\xbd\xb4\xed\xc7\x95\xdb\xe4\x1f\xcf\xe0\x26\xfd\x1e\xcf\xf8\xbd\xf2\x00\x8d\x1d\x58\xc3\x5b\xd2\x07\xe0\x6c\x3b\x65\x03\xd2\x6d\x25\x56\x67\x64\x24\x9e\x96\x87\xa8\x55\xa0\x34\x5a\x16\x4f\xba\xb9\x64\x22\x4a\xf8\x14\x8e\x59\xfe\xbc\xf2\xfe\x2e\xd3\xa2\x5a\x5c\xff\xc1\x07\xb8\xa1\x76\x91\x69\x97\xf2\x57\x65\xcd\xf4\x6d\xa9\xae\xa9\x53\xbb\x52\xdb\xa6\xd3\x78\x04\xae\x97\xb7\xf0\x77\x42\x9f\x75\x72\xc0\xc4\x01\x86\xf2\x48\x26\x7d\x0f\x26\x6f\x51\x3a\x91\xc8\x58\xee\x7f\xcd\x70\x5c\x6f\xfe\x70\x74\xbc\xfb\xb8\x07\xf8\xd6\x13\xf8\xa4\x37\x72\x1f\x73\xf7\xdd\x78\x23\x5d\xeb\x27\xdc\x03\x54\xf7\x4d\xbf\x47\xd9\xfb\x82\xef\x29\x9f\xd0\xef\xed\xe7\xe0\xe6\xe3\xfb\x90\x17\x8d\x96\x93\x2e\x9e\x54\x9f\x62\xcc\x76\x7d\x8e\xbb\xe6\x8f\xe3\xae\x77\x52\x51\x4f\xcc\xe7\xac\x0f\x25\x3f\x9c\x93\xa0\xe2\x5e\x2d\xa3\xd2\x3a\x86\x94\x0d\xce\xf0\x81\xcf\x2c\x3a\xf8\xc8\x8e\xce\xb9\xe7\x4b\x4b\x4c\xbd\xdb\x16\xc0\x87\x5b\x3b\x67\xc3\x07\xf7\x73\x5c\xb2\xb2\xa1\x52\x4e\x4e\xba\x6c\x7c\x45\xa2\x62\x64\x72\xfd\x0e\x54\x08\xd3\xb0\xec\xd2\x11\x2b\xb9\x69\x30\xa7\x5f\xaa\xad\xc3\x09\x8e\xe4\x77\x8d\x46\x4a\x39\x42\x61\xa3\xcc\xf2\xdf\xe1\x18\x81\xa2\xf2\xe6\x87\x1f\x29\x6f\xd5\x00\x14\x71\x19\x7f\xe7\xf4\x1b\x67\x76\x4d\x9d\xd6\x49\xa0\x88\xd3\xd3\x94\x6e\xf6\x2d\xea\xd7\x21\x3c\x0a\xc4\x44\xad\xfb\xd5\x18\x26\x1c\x22\x1b\xad\x8e\x1d\x6b\x62\x7f\xaf\xb1\x87\x9b\x34\xc6\x90\x49\x5b\x99\x18\x1e\xcf\x9d\x05\x72\x68\x11\xaa\x78\x1a\xd9\xf0\x08\xb8\x20\x2c\x78\xc4\x3e\x2f\xc7\xb9\xdd\xe2\x01\xdc\x96\xef\xab\x4a\x63\xc7\xda\x00\x19\x89\x3f\xa3\x76\x3e\xa8\x4a\xa4\x39\x99\xab\xae\x25\x1c\x19\xc5\xbf\xc9\x84\x53\x0d\x9d\xa9\xd4\xcd\xf3\xa6\x8f\x6a\x08\x2b\x0b\x6a\x03\x75\xc3\x87\xfb\xeb\x3b\x7a\x99\xc5\xce\xd2\xa9\x15\x4d\x0b\x17\x2e\xde\xbb\x28\xe0\x56\x6e\xec\x94\xa7\xe1\xa9\xce\x03\x74\x2e\xf5\x30\x17\x3f\xcc\xc5\x85\x8a\x51\xd1\x3e\xd6\xed\x36\x05\x1d\xc4\xb3\x55\x27\x98\xb2\x9e\xad\x76\x7a\x18\x30\xc9\x5b\xa9\xb9\x25\x67\x27\xe1\xe6\x33\x89\xc8\xb0\x7f\xdf\x66\xf6\xf4\xae\xa9\xfe\xda\x8b\x5b\x57\x2d\x99\xbe\x65\xf2\x29\x73\x94\x97\x3a\xe7\x7b\x6d\xe5\xdd\xec\x4f\x3d\x67\x19\x2b\x36\xb5\x94\x55\x0c\x59\x79\x6a\xdf\xee\xc5\x1d\xaf\x8b\xa9\x36\x9f\x6f\x0d\x19\xff\x0e\x26\x81\xfe\x48\xfd\x75\x1d\x28\xb0\xdb\x66\x3c\x88\xab\x01\xc3\x04\x3c\x3c\x0f\x04\x6d\x49\x75\xf5\xc4\x4f\x37\x9f\xa5\x3b\xa9\x4b\xfc\xe7\xcc\x66\xf1\xfd\x6b\x9b\x40\x78\x6f\x2c\x8b\x37\x11\xdf\x5d\xac\x48\xf1\x17\xe3\x8d\x8d\x71\xf8\x81\x7b\x20\xcd\x94\xe1\x0a\xee\x6c\x9a\x93\xc0\xb1\x9b\x71\x1e\x00\x60\xeb\x91\x99\x2e\xad\x4d\x0b\x74\xd7\x12\xd0\xc3\x9d\x9a\x5d\x16\x0c\xb0\x71\x7c\xd9\xd8\xda\x9a\x48\x59\x77\xe5\x3d\x8b\xcf\xeb\xd9\xd6\xbb\xf8\xbc\xa7\xd8\xfb\xb7\xce\xdc\x31\xad\x63\x7c\x6a\x9b\xf2\xce\xba\x65\xf3\xee\x99\xb3\x6e\xd9\xb6\xd7\x55\x9a\xef\x65\xa2\xf8\x0c\x1a\x37\x5a\xbe\xdb\xe9\xde\x8f\x87\xef\x23\x69\x05\x18\xcb\x33\x30\x12\x0d\x49\xa7\x6b\x6a\xcb\xed\x28\x1c\x1e\x35\xa4\x9e\x46\xff\x36\xe7\x8a\x18\x27\x59\x61\x74\x73\xbc\xd7\x25\xdf\x96\x1a\xa5\x7b\x9b\x9f\xbb\x71\xe8\x58\xdd\x70\x1a\xbf\xcd\xec\x1d\x36\x23\x81\xfb\x14\x56\x2a\x5f\x7a\x6e\xeb\x28\x53\x33\x1e\x2f\xc5\x95\x07\xc7\x92\xf1\x27\xc1\x3e\x4e\x80\x7d\xf4\x21\xcf\x1e\xc9\x24\x92\x2d\xf4\xb8\x10\xdd\x42\x12\x95\x9d\x31\xcb\xa8\xb2\x60\xd6\x31\xd6\x4d\x15\x02\xf1\xd3\x56\x9f\xb2\x23\x15\x5d\x12\x29\xaa\xd2\x97\x34\x8f\x5b\x3a\xbc\xba\x7b\x4a\x60\x29\x13\x5b\xd1\xb7\xf2\xa1\xf9\x16\xf3\xc3\x8b\xa2\xfb\x2e\x9b\xd0\xde\x52\x36\x07\xf6\x4b\x02\x78\x9e\x03\xfb\xe5\x42\xa5\xa8\x6a\xb7\x64\x3f\x08\x2b\x33\x02\x3c\xab\x51\x09\x12\x01\x85\x83\x0e\x87\xcf\xa7\x8d\xab\xa1\xae\xba\xd8\x2c\xda\xd2\x94\x9a\xac\x8a\xcc\xf1\xbc\xa4\x50\xc2\xcc\x31\xd3\x26\x5e\x3d\xbd\x23\xaa\x0b\xce\x03\x6e\x61\xd3\x70\xf1\x65\x2e\x3c\xb3\xa2\xcc\xeb\x69\xf3\x0f\x33\xd4\xbb\xdb\x52\x4c\xd9\x92\x39\x4b\x9f\x58\x6c\x1b\x77\xa7\x14\x3f\xf6\x91\x14\x3d\xb9\xa6\xe9\xd3\x6e\xb9\x2e\x8a\xc7\x19\x1c\xfb\x01\x06\x3a\x26\x81\x7b\x69\x8e\x80\xb2\xdd\xbf\x22\x21\x00\x4c\xea\x17\xa2\xff\x0d\xff\x4f\x82\xff\xb1\x72\x1e\xcc\xe1\x73\xc0\xb7\x72\x94\xd8\x1d\x29\xdb\x8f\x47\xca\xfa\x80\xe4\x76\x33\x26\x53\x91\xf7\x20\x60\x80\x1d\x39\xe1\xb7\x08\x87\x3e\x83\xdb\x2a\x4b\x40\x81\x84\x33\x33\x28\x98\x0b\x8d\xf3\xf7\x14\x4c\x15\x8f\xac\x8a\x4e\xd7\x8d\xb8\xad\xd5\x5c\x5d\x34\xde\xd9\x76\x5b\xaa\x51\x7c\x91\x99\x7e\x56\x5d\x3b\xee\x59\x33\xa4\x8d\xce\x7a\xa4\x99\xfd\x72\xd8\xb2\x7a\xe5\x11\x3c\x7d\x8c\x7f\xd8\xb4\x26\x65\x07\xee\x97\xca\x4f\x3b\xab\x59\x5e\x33\x7a\x84\x21\xae\xdc\x09\xf3\x9f\x3e\x46\xd5\x6b\xc2\x9c\x27\xd2\x58\xfa\x92\xdd\x96\x4c\xf8\xfc\x3e\x12\xc2\x2e\x6a\xf1\xf3\x49\x35\x88\x1d\x90\xe8\xb8\x98\xf9\x15\xbf\x22\x64\x9e\xf8\xce\xc1\xf9\x40\xdc\xe7\x80\x9f\x81\x7d\x26\x97\xcb\x2a\xd9\x0f\xd0\x33\x2e\x68\x27\xf1\x75\x95\x2d\xca\x51\x97\xa6\x82\x64\x46\xd7\x7a\xaa\xac\xe1\x93\x2b\x46\x75\xf3\xad\x1d\xc2\xf4\x9e\x93\xdd\x73\x0d\xbd\xcd\x7a\xe6\x0c\x6b\xa5\x3b\x30\xb2\xd5\x5a\x89\x27\xc4\xbd\x6b\xd7\xb6\x29\x6f\x34\x78\x5a\x55\xdb\x30\xe0\xe9\x74\x6e\x11\xc0\xdb\xb5\xc7\xaa\xa3\x83\x61\x24\x69\x83\x91\xad\xcf\x85\x3d\x03\x5b\x4d\x03\xb5\x6d\x33\xcf\x2b\x0f\xbb\xc4\xab\xa5\x06\xe5\xa7\xb1\x17\x44\x05\x6e\x91\xb2\xe6\x99\x61\x89\x22\x37\x1f\x97\x3c\xcd\x27\x29\x4b\x19\x23\x59\x0d\x4e\x3b\x00\x5e\x4b\xa9\xbf\x7d\x74\x77\x49\x84\xee\x71\xd6\xbf\x9e\x40\x4f\x47\xf6\x56\x75\xac\xa7\x30\xfb\x15\x3e\xf4\x15\xff\xef\x5c\xe8\x31\xea\xe7\x42\xcc\x17\xfc\x64\xc4\xa3\x0a\xd9\x4f\xdd\xa8\x89\xa2\x36\xdf\x95\x4a\xb6\x87\xd5\x2b\xb6\x2a\x17\x96\x49\x14\xb6\xfd\x19\x85\x6d\x28\xeb\xee\x07\x6b\x9c\xae\x8c\xc5\x23\xd2\xe7\x13\x5f\x47\xd9\x42\x82\x0b\x33\xdd\xa9\xb6\x28\x8d\xef\xe0\x45\x36\xdc\x8c\x49\xc0\xa3\xf2\x39\x87\xaf\xdd\x18\x56\x8e\xc4\x80\x41\x45\x18\x07\x95\x0e\x66\x24\xd5\x43\x16\xcb\x26\x13\x48\x00\x16\xc9\x68\xd4\x53\x8d\xe4\xa1\x04\x5c\x28\x79\x91\x48\xf9\xba\x49\x7c\xef\x09\x95\x93\xb4\xd6\x0d\x3b\x83\xd6\x3a\x6b\x90\xbd\x06\x97\xcb\xeb\x23\xfe\xbd\x92\xc3\x61\x9e\x9c\x72\x58\xd5\xe2\xc7\xee\x4c\xf1\xe3\x82\x74\xf5\x0d\xf5\x1e\x2d\x07\xa0\x76\x5d\x11\xd7\x91\x64\x89\xcd\x8a\x94\x9e\xed\x65\x96\x59\x57\x2f\xbc\x79\xfa\xd2\xa5\x57\x2d\xb2\x34\xdc\x3b\x1d\x3f\xa8\xbc\xe0\x2c\x8f\x9d\x54\x74\xfe\xb7\xb7\xac\x5a\x56\x74\x52\x69\xa5\xf2\x5b\xe5\x5d\x85\x94\x4f\x49\xa7\x51\x08\xe6\x70\x15\xfb\xa2\xb5\x8c\xbd\xf3\x7b\x64\x13\x99\x5b\xd0\x6d\xc7\xbe\x06\x18\xd9\xb0\x14\xc1\x3b\x23\x78\x73\x04\x2f\x8d\x60\x14\xc1\x11\x64\xa3\x21\x66\x8d\xb4\x5d\x66\xee\xf6\x32\x16\x1e\x90\x76\xe9\x51\xbf\xa6\x1d\xf2\x2b\x2f\x30\x51\xf6\x39\xab\x80\x8a\xa9\x6c\xfb\x05\xd7\xc3\x5c\xc8\xff\x0d\xe0\xd8\x28\xeb\x19\x56\xdd\x69\x46\x53\x39\x03\xb7\x38\x0f\xb1\x8f\xa2\x37\x33\xdc\x22\x9b\xf1\x09\xcc\xba\xc7\x3a\x1a\x1d\x61\x17\xfe\xe2\x02\x5c\xa4\x1c\xe4\x7a\x34\xb5\xf1\x71\x3a\xed\x53\x64\x6b\x51\xc0\xeb\x95\x58\xbd\xde\x25\x49\xc5\x9a\x82\x7b\x5f\x8a\xe8\xb7\xfd\x64\x30\xcf\x2c\xa2\xa1\x3a\x81\x86\x5b\x2b\xe9\x50\x97\x97\x58\x3f\x1b\xa0\xfc\x7f\x55\xdf\x0d\x70\x05\x91\x93\x67\xf8\x6e\x7b\x19\x8a\x12\xb8\xb2\x2d\xe9\xb3\xd3\x33\x50\xd1\x5e\xc6\xc5\x32\xee\xfd\xe9\xe7\xf6\x58\x2c\xdd\xfb\xd3\xe3\xf6\xba\xdd\x3c\x1f\xc3\x55\x55\x8d\xa8\xad\x91\xc0\xf5\x0d\x9c\x66\x02\xec\x78\xab\xa0\x1b\xbd\x88\xec\xcf\x11\xe8\xe7\xaf\xfc\x48\x6b\x1c\x28\xf7\xa7\x5a\x4f\x26\xe8\xa9\xe6\x31\x5c\xcc\xe2\xfd\xe9\x77\x65\x77\x28\x84\x71\x0c\x4d\x0a\x60\x14\xc0\xcf\x06\xf0\xca\x00\xae\x0b\xe0\x00\xb6\xd1\x40\xc2\x46\xb5\x67\xba\xd7\xfd\x20\xf2\xce\xa1\x7d\x55\xa1\x23\x5a\x5f\xbe\xbc\xbe\xfe\x4c\xfa\xe2\xb8\x18\x3a\xc2\xe0\x37\x18\xbc\x99\xc1\xf3\x18\xdc\xc6\x60\x86\xf6\x35\x67\x4e\x7e\x5f\x3f\x23\xc4\x75\xd2\xbe\xaa\x81\x51\x56\xfb\x72\x43\x5f\x8d\x8f\x61\x0b\xe9\xeb\x2f\x72\x50\x92\x44\x11\xe6\xc5\xe3\x3a\x1e\xbf\xc9\xe3\x37\x78\xbc\x8b\xc7\x9b\xe9\x47\x5e\xeb\xb1\x70\x7e\xd7\xa5\xbf\xe1\x77\xf2\x13\xac\x65\x28\x61\xa7\x3d\x2a\x8f\x40\x8f\xf1\xc7\x98\x12\x96\xd9\x9f\x6e\x92\x6d\xc5\xc5\x76\x7b\x0c\xa3\xb4\x1d\x3f\x6b\xc7\x93\xec\xd8\x4e\xbb\x69\xcc\xef\xe3\x45\x40\xbc\xdf\xd2\x79\x8d\xc0\x45\xea\xbc\x94\x4f\xa1\x17\xe7\x63\xd8\x43\xe1\xb5\xd7\xeb\xd5\xe9\x00\xe2\xa4\x09\x7c\x1f\x90\x4c\x70\x91\x31\xd9\x59\xb2\xfa\xed\x87\xd5\x55\xd4\xc0\xb7\x95\x0f\xe5\x60\x55\x15\x8c\x89\x7a\x75\xf8\x39\x1d\xbe\x44\x87\xcf\xd0\x61\x78\x5f\xa7\xc3\x21\x1d\xd6\x69\xab\x98\x93\x59\x05\xec\x5f\x79\xfa\x1b\xe6\x33\xfe\x6f\x70\x9e\x96\xc1\xe8\x02\x3b\xac\x1e\x21\xcb\xe3\x2c\x83\x8f\x94\xe2\x52\xf8\x7e\x23\x70\x7f\x28\x0f\x3f\x04\x82\x1f\xf0\xf9\x5f\xe9\x9f\x79\x03\xcd\x47\x11\x53\x69\x0a\xc0\xf7\x23\x90\x81\xac\x20\xb3\x44\x2c\x92\xc4\xb1\xac\x4d\xb4\x0b\x96\x79\x29\x49\x8f\xcd\x80\xff\x82\xc0\xf5\xa6\x04\x56\x62\x31\xdb\x9b\xc2\xf6\xc2\x94\xbd\x34\x43\x19\xce\xd5\xf5\xc8\xe4\x22\x61\x23\x2c\xc9\x5d\xc5\x7a\x98\x0d\xfd\x4b\xcc\x8f\xbe\x7a\xaf\x85\xe3\x9b\xa7\x39\x4a\x0e\xf7\xa5\x5e\x79\x6e\xac\x9f\x3b\x27\x30\x56\x59\x86\x3d\xa2\xf9\xe8\x16\x9a\x6f\x97\x49\x3f\x0d\xf3\xe8\xe1\xbb\xe1\x5c\xeb\xd0\x08\xd9\xc3\xb1\x82\x80\x75\x88\xe7\x0d\x22\x43\x94\x57\x1c\xc3\x03\x18\x74\xfb\xb1\x7b\x8f\x36\x09\x2d\xcb\x24\x91\xc3\x12\xd9\x1c\x1f\x49\xb5\x60\x4a\xd2\xa1\xc7\x61\x6e\xcc\xd1\x73\x25\xe6\xe8\xc1\x37\x15\xb9\xff\x1d\x66\xef\x64\xee\xbf\x47\x75\xec\xdb\xc7\xa6\xa9\xfb\xf7\x1d\x8c\xf7\x13\x85\x43\x39\xfd\x7c\x14\x3e\xef\xa2\x9f\x5b\x33\x7f\x17\x4e\xa7\x9f\xab\x50\x26\xe7\xff\xc7\xfc\x04\xa0\xe7\x41\x68\x31\x51\xae\x14\x63\x21\x1b\xf2\xd9\x7c\x15\x95\x91\xd6\x72\xcc\x96\x95\x63\x57\x39\x36\xc3\x3f\xae\xbc\xdc\x65\x70\x01\xb0\x5c\x9c\xc5\xd0\x9b\xb2\x38\x0a\x2a\x00\x90\x74\x75\x73\x7a\xe7\xe4\x0a\x01\xb4\x24\x06\x54\xdc\xb5\xe3\x12\x94\x9f\xfa\xdf\x41\x6b\x0a\x87\x81\xed\x49\x7a\xb8\x3d\xf7\x6d\xbf\xfc\xb3\xeb\xee\xba\xf1\xaa\x2f\x6e\xe8\xff\x56\xf9\x51\xd9\xfb\x36\x3e\xf7\xfb\x5d\xd8\xbe\xed\x1d\x65\x53\xb4\x76\xcc\xe4\x31\x82\xf2\x3e\x7d\x61\xc7\x1f\xfc\xeb\x8b\xca\xc6\x67\x9f\x7e\xe7\x10\x5e\xd3\x3f\x17\xd7\x7e\xff\x6f\xbc\xee\xb5\x2b\x7f\xba\xf5\x3b\xe5\xdc\x97\xd9\x92\x85\x4a\x5f\x5f\x1f\xde\xb1\x50\xa5\xcd\xb0\xc0\x93\xe9\x5a\xab\x33\x6b\xe7\x5f\xa1\x9f\x6b\x29\x8e\x5c\x01\xb0\x79\x0b\xf6\xc6\x82\x86\xcb\x41\x1d\xa9\x0e\x6d\x21\x95\x3c\xb1\x20\x48\x48\xc7\x59\xf4\x58\xe0\x84\xde\x94\x89\xb3\x67\x92\xb0\x27\x07\xab\xc4\xa4\xa6\xf5\xc6\x6a\x8d\xa3\x36\xcc\x1c\xe8\x7f\x7b\x8b\x49\x39\xdb\xb4\x82\x79\xfa\xe7\xdf\x5e\x68\xea\x7f\xd4\xb4\x83\x9b\x72\xcc\x11\x18\x3b\x36\xc0\x7d\x71\x34\x48\x5e\x61\x2e\x5f\x02\x2d\x99\x41\xe7\x52\xaf\xe2\x2f\x51\xd7\xd1\xcf\x0d\x74\x5f\x04\x98\x6b\x02\xf0\x57\xb5\x11\x2c\x90\x63\xc5\x56\x1d\x13\xb4\x0b\xb1\x68\x30\x14\x2a\x16\x42\x46\x9c\x36\xe2\x11\xc6\x09\x46\x86\x95\x8c\xd8\xcc\x1b\x8d\x70\xba\x81\x67\xf1\xc8\xfa\x54\xb1\xa3\x9e\x64\x2f\x35\xed\x4f\x1f\x79\xdc\x64\x66\x26\x98\x6c\x24\x37\x5b\x55\xb2\x6e\x4e\xb2\x2e\xb7\x5d\xbd\x73\xe6\x9c\x99\xd4\xb2\xd2\x79\x48\x48\x60\xde\x7e\x38\xb2\xa9\xda\xca\x22\xac\x9a\x2c\x1c\xe8\xb8\x3b\xc9\x6e\xa9\x19\xd3\x33\x86\x51\x56\x27\xe0\x45\xbc\x66\xd7\xca\x31\xd3\x4e\x65\xff\x77\xd8\x34\x6e\xf9\xc3\x3b\xbe\x99\xde\x3d\x6d\xf1\xd1\x7b\xda\xa7\x4e\xfe\x94\x35\x2d\x54\x26\x9f\x7b\x2e\x7e\x74\x21\x9e\x6a\xb9\x0b\x6f\x55\xce\xb8\xcb\x72\xec\x46\xeb\x93\xca\x18\xfc\xf4\x93\x56\x7a\xff\x69\xb5\x26\x60\xbd\x09\xba\x17\x1a\x5e\x82\xb4\xd8\x2d\xc7\xe0\xbc\xea\x75\x56\x9b\x8d\x65\x74\x80\x3c\x3a\x96\x07\xac\xe3\xad\xf3\x52\x3c\x6b\xb3\xe8\x19\xc4\xc0\xa6\x00\x03\xa8\xa6\xba\xd5\xaa\x8a\xe6\x67\x72\xd3\x0e\x6d\x24\x9b\x01\x5f\xcd\x86\x4f\x84\x13\xc9\xfc\xc8\xab\xf7\x58\xf8\x2d\x96\xdd\xaf\xde\x63\xec\xbf\xd4\xb8\xe7\x15\xc5\xfa\xca\x3d\x46\xd8\x9a\x73\xfc\x63\xc7\xfa\x8f\x5e\x45\xb7\x69\xd9\xd1\x1b\x03\x63\xd5\xf3\x94\x06\x1c\x39\x42\xf7\x85\xd6\xbe\x4b\x7f\x04\x9f\x3f\x84\x79\xba\x50\xaf\x5c\x05\xc2\xbd\x59\x6f\xb6\xb0\x46\xab\xd5\xc3\x1a\x8d\x6e\x06\x23\xb3\xd5\xcc\xe8\x79\xb3\xd9\x68\x91\x90\x84\xe6\xa5\x6c\x12\x6b\x32\xb2\x46\xe0\xb7\x3d\x8f\xa5\xf4\x46\x98\xf5\x21\xad\x54\xa8\xfa\x6a\x6b\xf1\xd1\xd4\xa1\x99\x3c\x52\x36\xcd\xfe\x02\xfb\xe1\x10\x71\x38\x11\xa5\xc0\x6f\x26\x69\x2b\x48\x2d\xee\x08\xe3\xfe\xda\xa0\x54\x60\xdf\x69\xd8\x17\x99\x31\x7b\xf9\xd1\xdf\xd9\x19\xaf\xf2\x07\x27\xfb\x43\xdb\x4c\x61\xe1\x13\xdc\x1b\x4a\xeb\x18\xa5\x5c\x2f\x3e\xad\x8c\x99\xcb\x44\x98\xd4\x02\xe5\xc1\xf7\x2c\x04\xde\x37\x02\x3e\x95\xd1\x75\x34\x53\xf8\x2f\x81\xcf\x97\xd0\xcf\x23\x28\xbe\x75\x02\xfc\xeb\x60\x5d\x44\xaf\x5a\x87\xae\x92\xab\x2b\x74\x62\x98\x2b\x29\xa9\xac\xb4\x5b\x6d\x7e\x2e\x10\xa8\xab\x73\xb3\x31\x93\x3b\xe6\x6e\xa8\x17\x6d\x7e\x5b\x6f\x2a\xec\xaf\xb0\x5b\xed\xbd\x29\x9d\xd5\x4f\xdc\xc2\x8a\xf5\xe6\x6e\xab\xac\x97\xba\xfd\x56\xbf\xb5\xa8\xa6\xb2\xae\xa6\xae\x37\x55\x63\x2f\x09\x14\x05\x7a\x53\x45\x6c\x3e\x7d\x25\x21\xa8\xde\xba\x3a\xd8\x35\xad\xcc\x7a\xde\xf6\x69\x35\x0b\x3d\x34\x3b\x3a\x45\x4b\x2d\xbd\xb3\x11\x53\xc1\x76\x38\x76\xb0\x54\x8e\x40\xe1\x64\xb3\x9a\x1d\x2a\xc1\xb9\x9c\x28\xac\xe6\x13\xc7\xec\x87\x37\xdc\x73\xd9\xca\x92\xd5\xe9\x1b\xee\xd9\x78\x46\xc5\xc5\x5b\xba\xde\x3b\x86\x6b\xb1\x75\x9d\xed\x1e\x33\xb3\xd8\xbc\xc7\xd6\xfa\x01\xc6\xca\x6b\xca\xb7\x6b\x9c\x77\x9b\xfa\xb7\x9b\x1e\xc3\xf2\xbb\xcf\x6d\xbd\xb7\xbf\x81\x79\xe3\xdd\xe7\xae\xbb\x87\x79\xe3\xd8\x1b\x1f\x3c\xff\x4f\x6c\x5c\x42\xb0\x61\xc9\xc7\x4f\xff\x53\xf9\xe1\x7c\x82\x12\x14\x17\x0e\x67\x61\x36\x9c\xf2\x6c\xeb\x00\x66\x9f\x03\xcc\xe2\xe8\x1c\x79\xb8\x4b\x00\x56\x44\xb2\xdb\x4d\x7a\x3d\x5f\x12\x0a\x45\xa2\xd1\x60\x3c\x10\x20\x69\x26\xca\x2b\x82\x2e\xc1\xd5\x9b\x8a\x0b\x82\x85\x8d\x04\xdc\x26\x8b\xa9\x37\x55\xe2\xb5\xb0\x88\x67\xf9\xde\x14\x6b\x47\x05\x55\xe7\x93\x5a\xa9\x9c\x5c\xbc\x7a\x26\xad\x7a\x36\x8e\x37\x99\x49\x25\xab\x22\xb6\x9a\xa6\x2f\x53\xb1\xce\xa3\x21\x3d\x4d\xeb\x47\x4a\x5c\x70\x61\xf6\xb4\xdd\xe6\xfe\x4b\xcd\x07\xba\x3e\x51\x8c\x35\x67\x9b\xf1\x0d\xb2\xf9\xa2\xd9\x2b\xd7\x9a\x19\xaf\xf9\xca\x95\x17\xef\xf2\x8f\xc3\x37\x98\xd7\x36\xc7\x95\x97\x94\x7f\xf5\x91\xd5\xe2\x6d\x4f\x3f\xd0\x09\xd7\xb1\x7f\xac\x72\x53\xc7\xf0\x25\x9b\x18\xe6\x22\x02\x8f\xfe\x0d\x0f\xdd\x88\x77\x8e\xf5\x2b\xaf\xbe\xf7\x26\x8d\x33\x84\xd5\xfd\x19\xee\x8e\x4a\x34\x4f\x4e\xe8\x58\xbb\x64\xb1\x08\x62\xb0\xa8\x28\x16\x2d\x2f\xf5\xf9\xa2\xa2\x9d\xab\xaa\x8e\x09\x42\x90\xf8\xc4\x33\x16\x16\xf8\x19\xb7\x1b\xf5\xa6\xdc\x5c\x91\xc5\x02\x7f\xd5\x52\x6d\xe5\x28\x92\x96\x80\x23\x97\x0a\x33\xf3\x8b\xf0\x97\xe4\x16\xf1\x10\x32\xe4\x01\x1c\x20\x59\xe5\xd5\x32\xed\xb0\xf5\xbc\xa8\xd5\x33\x70\x34\xd9\x49\x79\xad\xde\xf7\xff\x75\xe1\xaa\xda\xfe\x67\x6a\xda\x4b\x27\x3f\x3b\xda\xb8\xe7\xef\xcf\xe0\x79\x7f\xc3\x65\x78\x8c\xf2\x67\x45\x09\x35\xfd\x7e\xfa\xe4\x19\xd3\xfa\xef\xef\x7b\xf0\xc0\x5d\xdc\xe7\xca\x0f\x47\x36\xee\xf1\x2b\xcb\xf1\x99\x1b\xad\xcb\xc2\x5f\xdc\x72\x00\x7b\xae\xff\xe6\x4f\xff\x50\x5e\x89\x2e\xb3\x6e\x54\x36\xe1\x1b\xbc\x28\xfd\xf6\x23\x8f\xa3\xec\x7d\xb2\x5c\xb8\x0f\x78\xd2\x6a\xc2\x19\xa1\xa5\xe8\x6c\x3c\x11\x79\x64\x33\x83\x4d\x7c\x19\x83\x6f\x0b\xb8\x58\x3d\x61\x8d\x1a\x11\xf9\xc9\x9d\x33\xda\x66\x84\xda\x06\xef\xca\xb4\x71\x91\x36\x97\x47\x8b\x75\xb6\x01\x6d\x02\xe9\x7f\x72\x97\x53\x1e\x68\x81\xca\x81\xa1\x7f\xc0\x1f\x40\xa6\x60\x2a\x6c\x65\xcc\xb3\x15\x78\x57\x05\x1e\x5b\x51\x6d\x00\x5e\xae\x0a\xd8\x37\x68\xa8\xb6\xf3\x82\x2c\x32\x95\xb6\x5b\xa4\xb5\x7b\x07\xfe\xe0\x90\x8d\xb8\xde\x56\x86\x3f\xac\x4f\x96\xb1\x94\x71\xcb\x7c\xbf\x52\x19\xcf\x19\xe9\xf7\x97\xa8\xdf\xc7\x24\xee\xdc\x23\x5b\x70\x08\xbe\xbf\x36\x84\x3f\x09\x95\x7a\x49\x93\xbc\x31\x26\x02\x7f\xb6\x39\x8f\x3f\x6b\x01\x24\x08\xc9\x4e\xec\x20\x2d\x1c\x38\xe4\xc0\x92\x03\x5f\xed\x70\xb3\x56\x3a\x39\xb5\x25\xb4\xeb\x80\xb9\xfd\x9e\xb6\x5b\x43\xc7\x1a\x86\xbd\x74\x2c\x13\xb0\x76\xf0\x6f\x55\x75\x99\xe8\xa7\x60\x68\x44\x94\xc5\x23\x31\x2f\x14\x0e\xec\x4b\x44\xf7\x06\x18\x56\xcf\x59\xdd\x6e\xbf\xdf\xc0\x30\x3e\x9f\xcd\x6e\xaf\x0c\x1b\x0c\x15\x95\x36\xc9\xef\xb6\x72\xf1\xb8\x25\x6a\x29\x9a\x94\xb2\x58\xc5\xe8\xe4\x94\xe8\x66\x7c\x13\x53\x8c\x2b\xbf\xd0\x23\xa0\x98\x8f\xd8\xb8\xb5\xca\x9d\xb9\x83\x94\xad\x90\x1a\x13\xc3\x65\xf9\xf9\xfa\x49\xec\xae\x05\x8b\xc5\xd8\x53\xc0\xc5\x00\x85\xf9\xc9\xac\x7c\x19\x32\x8d\xdd\x71\xea\x8d\xbb\x2e\xfd\xd7\xb5\xef\xd6\xcf\xc6\x46\x5d\xec\xde\x94\x54\x55\xad\x7c\x3a\xae\x6d\xd4\xe9\x1d\x8d\x15\x5d\x57\x4d\xc0\xa3\x46\x9d\x7c\xf6\xea\x15\x2f\x3d\xb0\x0f\xfb\x77\x28\xe9\xaf\xcb\xcb\xbf\xdb\xb2\xf9\x77\xc3\xf0\x1f\x76\xdc\xb7\x4d\xf9\x61\xc3\xaa\x25\x37\xde\xdf\x0e\xfc\xe1\xf3\xca\x04\xce\xcc\xdf\x81\x9c\xf4\x14\xd5\x0b\x51\x36\xea\x0f\x87\x0d\xe5\xac\x81\xad\xaa\xf6\xfb\x24\xab\xd5\x6e\xb3\x55\xd9\x02\x70\xf1\xc7\xa2\x93\x52\xb1\x18\x32\x9b\x61\xa5\x66\x37\x72\x69\xd5\x8d\xf3\xd3\xe9\xab\x35\xa8\x33\xa5\xd9\x73\xe5\x6c\x49\xb2\xbd\x96\x4c\x78\x85\x44\x6a\x59\x39\xb9\x48\x69\x1c\x8e\x8c\xbd\xc9\x43\x72\x4e\xb3\xa4\x28\x0e\x95\xa1\xe3\x6a\xd5\x30\xe6\xc9\xdf\x3e\x71\xf7\x66\x7c\xfa\xc5\xca\xd1\xcf\x57\x8e\x9b\xaa\x7c\xff\x7d\xcd\xcf\xaf\x74\x8e\x6d\x0a\x6e\xf1\xce\xa8\x6d\x59\x39\xe6\x8c\xf9\xd6\xcb\xb6\x8c\xe0\xef\xb8\x65\xe3\xcd\xaf\x87\x0c\xde\x3b\xd6\xbc\xa3\xd4\x2b\xf5\xfc\x7c\x8c\xff\xdd\xd7\x75\xdf\x3d\xc7\xde\xb3\xfa\x67\xdd\x3e\x7f\xc3\x25\xc2\xa9\xcc\xfe\x5b\xe7\x2e\xa6\xf4\xd2\x48\x6a\x23\xd3\x9a\x75\xcd\x72\xc0\x61\xb5\x1a\xfc\x0c\xa3\xd3\x19\x0c\xa1\x12\x90\x4b\x48\x3d\x06\xc9\xcd\x9b\x5d\xfa\x00\x55\xb2\xb4\xe5\xd3\xbf\x6c\x0e\x00\xaa\xd4\x11\x18\x09\xc7\x9b\xec\xcd\x65\x24\xbb\x44\xd8\x6d\x0f\x60\x6d\xe6\xec\x24\xfe\x6a\xe5\x07\x3e\xee\xfc\xbe\xc2\x3a\xae\xc8\x3f\xb5\x36\x69\xc2\x4d\x9e\xaa\xd2\x9b\xab\xab\xe2\x0e\x13\xfb\x90\xa1\x6a\x7c\xbf\xe2\x58\xac\xbc\x3a\xc1\x58\x34\x0d\x1b\xbb\x3f\xc6\x6f\x6d\x73\x8f\x3a\x55\xf9\x1f\xe5\x15\x9c\x98\xb9\x32\x52\x5c\x2e\x8c\xa2\xf5\x96\xbe\x61\x3f\xe4\x7f\x03\x92\x76\x15\xa9\x6e\x53\xc1\x0a\x65\x3a\x20\xe7\x6e\x9d\x8e\x35\x07\xd9\x60\x75\x8d\xcf\x81\x8c\x8e\x49\x29\xa1\x6c\x62\x4a\x12\xb0\x0d\x78\x7a\x63\x89\x24\x19\x11\x2a\xc9\xab\x54\x44\x0b\xb3\x11\x41\x22\xbf\xd6\xb9\x3d\xb3\x1f\x2d\xb9\x14\xfb\xcd\x65\x05\x09\x9c\xb5\xf4\x11\xa4\x90\x54\x9c\x6e\x49\x9c\xe2\x1e\xde\xb6\xeb\xe5\xaf\xbe\xb8\xee\xf5\x83\x2b\xaf\x2a\x1b\xed\x71\x8e\xad\x18\x31\xbe\xeb\xcc\x99\x27\x5f\xfb\xbf\x57\x8e\x5f\xd5\x7e\xd1\x45\x57\x8c\x71\xbe\xf2\xf0\x13\xd8\x38\x7a\xc7\xe6\x0b\xaf\x2a\xfb\xf8\x4c\x8f\xb7\x7b\xdc\xff\x8f\xb3\xf7\x80\x8f\xa2\xdc\xfe\x87\xe7\x99\xb2\x75\x66\x77\x76\x76\x76\x67\x7b\x2f\xe9\x6d\x53\x08\x04\xb2\x84\x10\x12\x12\x52\xe8\x43\x4b\x22\xbd\x17\x29\x2a\x1d\x45\x8a\x20\x4a\x15\xb8\x0a\x22\x82\x28\x57\xc0\x86\x88\x05\x0b\xd8\xf5\x36\xfb\xb5\x5e\x6f\xf1\x5e\x7b\xb9\x16\xd8\xc9\xfb\x3c\x33\xbb\x9b\x4d\x40\x7f\xf7\xfd\x7f\xf4\x43\x76\x37\x21\xcc\x79\x9e\xf3\x9c\xf3\x3d\xe7\x39\xe7\x7b\xca\x96\x2e\x6c\x3f\x7f\xf5\x96\x6f\x6f\x98\x3c\xed\xb5\xc5\x87\xae\x8d\x49\x3f\x1e\x5a\xb0\x04\xee\x03\xb2\x13\x95\xc4\x79\xe8\xe7\xaf\x8a\x97\xd1\xf9\x7c\x4e\x3e\x41\x38\x22\x91\xa2\x62\x1f\x41\x14\xe7\xd8\x8c\x46\x1b\x9a\x23\xe3\x32\xe2\x34\xb4\xd9\x58\x30\xe8\x6e\x15\xa1\x43\xb3\x62\xda\x16\x11\x46\xa3\x14\x85\xc6\xb9\x94\xc8\xa5\xc5\xd5\x99\x80\x52\x91\xb3\xe7\x3c\x50\x59\xe7\x7a\x48\x36\x00\xef\x07\xd0\xb4\xa9\x54\x96\x3a\x95\x16\x4c\x8e\x9c\xc2\x23\x83\x0f\x14\xe6\xd4\x0a\xa6\xfa\x68\xfd\xb8\x42\xbf\xce\x36\x88\x6d\xe4\xeb\x1d\xf3\xf7\x0f\xab\xdd\xb2\xae\xb0\xe3\xc9\xe9\x87\x4f\x6c\xbb\x06\xaf\x1d\xf6\x2e\x71\x9e\x67\xdf\xbe\xda\x68\x1b\xdf\x56\x34\x82\xc1\x29\xfd\x72\xa6\xf8\x77\x43\x9b\x3a\x6a\x87\xd7\x6d\x5c\x3e\xe3\x16\xb3\xda\x31\x7b\xe0\xb2\x0d\x4a\xdd\x40\x81\xb4\x85\x78\x86\xda\x07\xf5\x4e\x8c\x9b\xad\x76\x3b\xa7\xe2\x30\x52\xa7\xf3\x31\xd0\x74\xf9\x58\x97\xe5\x51\x60\x8b\x6b\x75\x24\x0c\x09\xd5\x6d\xa2\x0a\x81\x19\x83\xc5\x5e\x3f\x5f\x85\x3a\xc5\xe0\xde\x6a\xe5\xa9\x27\xc9\x7d\x84\xe7\x4b\x21\xe3\x4e\x93\xdc\x27\xf3\x2f\xa5\x1c\x16\x2e\xa3\xca\x42\x15\x82\x46\x9e\xa3\x25\xb7\x19\x44\x15\xc5\x2c\x00\x05\x3b\x41\x21\x08\x27\xfe\x09\xbe\x7f\x4c\x90\x1e\x90\x9e\xed\x9c\xf0\xd5\xb9\xd3\xb6\xc1\xe3\x8b\x07\xdf\x7f\x08\x0c\xb9\x1e\xf8\x40\xfd\xd7\xda\x29\xfb\xbc\x0e\x51\x3a\x21\xe5\xdc\x14\x1f\xee\x18\xf4\xc4\xfc\x13\x95\xcd\xf6\x09\xe5\x25\x45\xe6\xc2\x43\xb2\x1c\xb2\xbd\x86\xfb\xe6\xc1\xe2\x71\xbf\x5e\xa7\x33\x11\x6e\xab\x60\x17\x6c\x84\xcd\xe7\x75\x42\x93\xe7\x34\x0a\x16\xbd\xd3\x6d\xc6\xcc\x6d\xca\xc8\x1d\x85\x15\xb8\x37\xcd\x76\x72\x57\xe4\xe9\xdc\xb8\x45\xed\x87\x1a\x98\x4e\x4c\xcb\x94\xdb\xea\x72\xa2\x74\xea\x22\x53\x07\x2b\x68\xa4\xff\x04\xcd\xe3\x2d\xe3\x15\xe6\xf4\x9d\x22\x03\x9a\x35\xfb\x89\xf3\x32\xf1\xf9\x5b\x9d\xd2\x97\xe3\xf2\xa7\x01\xff\x74\x1c\x9b\x57\xd0\x29\x93\xa4\xb7\xd9\x6b\x4e\xbc\x20\xe3\xc9\x61\x5d\x9f\x93\x04\x75\x1b\x8c\xad\x04\xcc\x87\xb5\xc4\x73\x6d\x9c\xc3\xa1\xf7\x99\x2d\x16\x08\x86\xfd\x01\xce\x06\x6d\x18\xd7\x9f\x1b\xc6\xc1\xb7\x1c\x87\x69\x34\xd0\xa8\x69\xac\x98\xf1\x32\xa3\x96\x31\xe7\x2a\x03\x0e\xa0\xc7\xd7\x01\x55\xd2\x5a\x0b\x01\x15\xe1\x97\xe9\x95\x92\x23\x7b\xcd\xf8\xae\x93\x4f\x4e\xdc\xf7\xf6\xcd\xf7\x9c\xba\x35\x71\x62\xca\x8a\x52\xb0\xc4\x33\x50\xda\x1f\xa8\x2c\x9d\x79\x4b\x31\x75\xdb\x2f\xff\xf8\xbd\xb4\x40\xfa\xfe\xfa\xaf\x3e\xfa\x37\xf8\xe5\xe7\x29\xbf\x48\x4f\x3e\xb2\x6c\xfd\xe6\xc4\xd8\x67\xaf\xbf\x6e\x25\x30\x82\x02\xf8\x08\xc8\xcf\x05\xa0\xad\xe2\xb0\xf2\xb8\x8b\xd5\xea\xf5\x2a\x82\x30\xf3\x46\x1e\xb0\x84\x32\x4c\xd8\xc8\x60\x4c\x72\x9c\xb0\x02\x6c\x81\xcc\xc3\x54\x99\xe2\xf0\xa6\xba\x51\x99\x3a\x45\xfa\xa3\x1e\xdb\xa9\x9e\x37\x81\x06\x73\x57\x50\xb5\x39\x65\xbe\xbe\x77\xf0\xe3\x47\x39\xf3\xf0\xf9\xb6\x9a\x44\x75\x59\x73\xb0\x3c\x56\xae\xe8\x2b\x8c\x31\xae\x82\xff\xb6\x09\xcd\xe6\x35\xe1\x6a\x12\x51\xdd\xe8\x71\x56\x6b\x34\xea\x74\xb4\x5e\x8f\x43\xf9\x68\xa3\x3c\x26\x96\x34\xc1\xcf\xd4\x24\x9a\x75\x2b\x8f\x0a\xc3\xd0\xa0\x7b\xae\xb2\xf2\x72\x6a\x6b\xae\x32\xad\xab\x50\x44\x20\x0f\xe4\x55\xa7\x28\xd6\xc9\xab\xf4\x0b\xa4\x3f\x7e\xdd\xc1\x48\x67\x9f\x5a\x53\x25\x7d\xb7\x7b\x82\x1e\xcc\x1d\x09\x7e\x26\x8e\x57\xb3\xd2\x37\x12\x6f\x6f\x00\xf7\xb6\x48\x77\x13\xc3\x6d\x35\x92\x1f\x7c\x08\xe3\xa0\xc7\xe0\x26\x8f\x85\x7e\x4b\x40\xf3\x15\x31\x81\x23\x49\x41\xa0\xcd\xb8\xd9\x0e\x70\x1b\x46\xe2\x1a\xa3\xa6\x55\xa4\x69\x23\x10\x2c\xcd\xa2\x80\x27\x9f\x2d\x65\x2e\x90\x95\x28\x91\x7d\x52\x92\xda\x1f\x45\xd1\xfe\x0a\x20\x5b\x89\x14\x3d\xb5\x60\x46\x86\x03\xcf\x92\x4e\x4b\xef\x69\xf0\x12\x96\xe9\xdf\xd7\x63\x2d\x1a\x6c\x6b\x19\x32\x73\x91\xe3\x77\xcc\x28\xfa\x6d\xbc\x2d\x71\x22\x97\x38\xb7\x64\xf6\x54\x7a\xc4\xe3\x96\xf5\x77\x5e\xca\x6d\x74\x0e\x84\xcf\x76\x4c\xe6\x07\x47\x7e\x66\x44\x3c\xc7\x66\xa5\x20\x62\xf0\x98\x74\x7a\x3d\x43\x7b\x68\xaf\xcf\xee\xd4\x99\x4c\x6a\x5e\x3d\x5c\xe4\xad\x2c\x03\x17\xd1\x02\x3c\xcd\xa2\x1e\x18\xb1\xde\xf3\xa9\xd2\x53\xbe\xd3\x07\x47\xa1\x7c\x4c\x92\x65\xa7\x18\xc2\xe5\xe1\x54\x51\x15\x7c\x01\x7d\x92\xb9\x91\x01\xeb\xa6\x59\xd1\xec\xee\x59\x40\x07\x4f\x8c\x74\x9a\xe8\xb3\xbd\x6f\x8b\x2f\xaf\x5e\xfa\x52\x13\x68\xb2\x6e\x26\x66\xd5\x24\x9e\xbf\x3a\xbb\x73\xdb\x28\x7c\xf8\xa5\x13\xf0\xc0\x0c\x5f\x58\xfc\xcb\x5b\xf9\x43\x80\x76\x05\xc1\xc8\x18\xcb\x0c\xed\xf3\x01\xe2\xf7\x30\xce\x90\xfb\x58\xb1\x2a\x69\x2b\xb1\x15\xfa\xa3\x18\x36\x2d\x6e\x2f\xf0\x99\x23\x2c\x69\xb6\x51\xb4\xe0\x72\xa9\x30\x1a\x2b\x2d\x13\x6c\xde\x48\xbd\x80\x72\x86\x4e\xc1\x53\x2f\xb8\xed\x36\xbb\x6d\xb8\x68\x8c\x44\x23\xd1\x36\xb1\x44\x1b\x89\x10\x2e\x3b\xa2\x34\xb0\x41\xc7\x7a\x01\x3a\xa5\x64\x59\x6b\xb2\xc2\x35\x73\x8a\x1c\x32\xd9\x25\x72\xd1\x86\x3a\x5a\xae\x58\xae\x6e\xd3\x5c\x0d\xa8\x0a\x7f\x89\xd2\xc7\x6a\x15\xca\x65\x33\x5e\x08\x94\x89\x7a\x02\x49\xc4\xef\x79\xc4\xb1\xbf\xb5\xe9\x0f\x67\xff\xfe\x01\x3e\x67\xc1\x3f\x9f\x01\xd2\x20\x01\x8c\x39\x37\x4c\x7d\xfc\x91\xba\x78\x4b\xb1\x4f\xf0\x31\x39\x0d\xf7\xdc\x5b\xda\x39\x03\xe0\x7d\x66\xef\x2b\x6f\xac\x99\x93\x9b\x67\xcc\xbd\x7f\xe7\xe1\xbf\x84\xd5\xbe\x35\x63\xaf\x3b\xe5\xd2\x0e\xba\x49\xb7\xc8\x7b\x70\xd1\xc8\x59\x3a\xcb\x76\xad\x21\xe7\x8e\x95\x45\x83\x8b\x84\x41\x68\x4d\x90\x4f\x7e\x8c\x38\x0f\xd7\x64\xb8\xbc\x26\x46\x68\x5f\x36\xc1\x3d\xf6\x61\x4d\xf1\xa8\x4e\xa3\x56\x1b\x69\x16\xda\x6a\xbb\x20\xb0\x66\x68\x5f\x04\x56\xad\x32\xf1\xa6\x16\x91\xe3\x78\xa3\xce\x82\x39\xbb\x27\x7f\x27\x87\xdf\xca\xf0\x28\x15\x6b\x28\x84\x5d\xdd\xa7\x36\x48\xa0\xf1\x36\x03\x00\x7c\x85\xc6\xdc\xa8\x83\xe9\x33\x4c\x68\xe7\xce\x56\xcf\x7e\x67\x5e\x75\xd1\x07\x9a\xa1\xf5\x59\x0b\xae\x19\xd5\xd0\x8f\x0c\x72\x17\x66\x51\xb5\xa1\x52\x21\x7f\x33\x3f\x7a\x1c\x3c\xd1\x9d\x52\xbf\xae\x35\xf9\xf1\xd5\x7b\xc1\x53\xeb\xbf\x98\x91\x38\x5a\x3c\x3c\x38\x28\xab\x14\xe5\x03\x5f\x85\x18\xe8\x1d\xe2\x69\xcc\x88\x39\xb0\xfe\x71\xaf\x99\xa6\x9d\x2e\xbb\x8d\x20\x49\x15\x45\x39\xb5\x96\x56\x51\xcb\x52\x4e\x3b\x8b\xb1\x2d\x22\x91\x31\x42\xa9\x3a\xb7\x07\xaa\x4b\x82\x07\x04\xe0\x52\x43\xc2\x54\xd1\x12\xae\x8c\x95\x8d\xb8\x15\x9c\xcf\x1b\x63\x6f\x95\xbe\x3f\x19\x7e\xf7\xdc\x53\x1f\xac\xff\xee\xf6\x6b\x6f\xde\x3b\xa8\xd1\xd5\x5c\xc5\x5b\x8c\x52\x15\xf1\xf7\x97\x2e\xbc\x77\xee\x6e\xe9\xe7\x9b\x67\x02\xf2\x6d\x20\xac\x3e\x20\x0d\x71\xa1\x35\xed\x2b\xdd\x44\xac\x84\xfe\xc5\x87\xf5\x8d\x3b\x31\x1d\x67\xb3\x31\x2a\x4e\xe5\x0f\x10\x46\xab\xd6\x0a\xed\xb3\xcf\x01\x1c\x10\x6e\x6b\x15\x4d\x42\x2e\x31\x63\x34\x85\xfc\x5c\xf2\xec\x4f\x05\xbd\x24\x9d\x5f\x34\x19\xa9\xa5\x66\x74\x40\x2b\x58\x33\x7a\xcd\x75\xf3\xce\xde\x6d\x1d\x36\x60\xcb\x89\x83\xb7\x01\x72\xcf\xe6\x1b\xb3\x1a\xcd\xf9\x23\x1b\xb6\x4d\x00\x37\x0d\xaa\xcb\xce\x5a\x31\x61\xe6\xa9\xd2\xc6\xac\xb6\x22\xd1\x9f\x7d\xdb\xaa\x7b\x40\xc1\xe9\xf0\xbf\xd7\xe6\xae\xfd\x18\xc5\x04\xfd\xe0\xbe\xaf\x21\x4b\x31\x3d\xe6\x46\x28\x52\x6b\xa7\xad\x2e\xf8\x7c\x46\x8f\x97\xa2\xed\x74\x8b\xe8\x74\xda\x8d\x66\xac\x45\x34\x5b\x7b\x4e\x3a\x56\x1e\x51\x49\x4b\x86\xd1\xf4\xd6\xa8\x52\x1e\x00\xd4\xca\xc8\x4e\xb8\xef\x2c\x96\x0d\x2a\x62\x6a\xf0\xa7\xd9\x3b\x8a\xa6\x1e\x18\xdb\x04\x5e\x00\xb3\xd6\x7f\xb9\xeb\x81\x57\x40\x11\x60\xc0\xd4\xd1\xc3\xfa\xb7\x80\xfc\x67\xef\xee\x58\xf2\xe6\xf6\x35\xb7\xe1\x3f\xa8\xb6\xde\xb3\xff\xe2\x86\x77\xce\x01\x00\x22\x1b\xbf\x96\xfd\x33\xd4\xd1\xa7\xa1\x4e\x5a\xb1\x86\x78\x98\x37\x18\x70\x1d\x4d\x6b\x28\x68\x7e\x04\x1b\xad\xd2\xaa\xa0\x6b\xd3\x00\x86\xd0\x68\xb4\x46\xb3\x09\x33\x65\x3a\x8f\xf4\x4c\x8c\x14\xb2\x48\x23\x5e\x2a\x20\xeb\xa3\xac\x85\xc8\x93\x24\x31\x13\x78\xfe\x9c\x7a\xf6\x29\xa8\x7b\xc4\x04\x4e\x7a\x7b\x16\x15\xf0\xe4\x97\xfb\xcb\x77\xf1\x27\x91\xf2\xc9\x2a\x57\x1a\xc9\x0e\x96\x17\x55\xca\x9c\xc6\xf0\xb9\x1e\x24\x9e\xc3\x5c\x58\x65\xdc\x65\xd5\x9a\xb5\x0c\xa3\x22\xcc\x0e\xc2\xe1\xf6\x08\xa9\xd1\xf8\x6c\x4b\x8f\xd1\xf8\x3d\x3c\x2e\xb2\xcf\xca\x58\x7c\x94\x71\xc1\x93\xdd\xa9\x9c\x0c\xb9\xe5\xb1\xb8\xe0\xe1\x03\x67\x0b\x8a\x97\xe8\xc1\xca\xaa\x90\x79\xf0\x80\xe9\x8b\x0a\x82\xd9\x1b\x6f\x97\xbe\xe6\x4f\xed\x19\xf9\xdd\x5b\xf6\x81\xd2\xfb\xaf\x5c\x57\x35\x7a\x3c\xa0\x3f\x9d\xf2\xb0\xbd\xc9\xf5\x87\xbd\xd2\x67\xd2\x73\x4a\x8c\xe7\x87\xb6\x7a\x3a\x8c\xf1\x9c\x58\x18\x6b\x8b\x67\x59\x7c\x5e\x95\x5a\x6d\xb7\x69\x35\x1a\x13\x1d\x0a\x11\x34\x11\x89\x6a\x9c\x36\x9f\xca\xd7\x2c\x6a\x55\x56\x93\x0b\x73\xb5\x88\xac\x0c\x40\x33\xc6\xa2\x77\x3f\x6f\x72\xd4\x81\x7c\x4e\x4a\x14\x9c\xc0\x62\x14\x11\x34\x23\x35\x44\x0c\x7c\x06\x20\x27\x12\xe0\xb1\x11\xd0\x51\x19\x00\xa0\x18\xc4\xc0\x6d\x7b\xa4\x8f\xa4\xbf\x0d\xdd\x38\xf4\xf4\x4b\x53\x5e\xda\x6a\x1d\x36\xb6\xa4\xb5\x6e\x96\xeb\x96\x31\xb1\x0a\xd3\xac\xf9\x1b\x06\x12\x17\x4e\x1e\x94\x5e\x97\x1e\x63\xa5\x89\xe0\xb0\xe1\xe5\xfb\xf7\xfe\x7c\x87\x79\x78\xe0\x66\xe9\xe2\xe8\x95\xeb\x19\xbc\xf5\x77\x5b\x66\x76\xb4\x27\x4e\x6a\xf7\x82\x82\xad\x0f\x40\xff\xc3\xcb\x67\xfc\x38\x8c\x1f\x9a\xe2\x61\x56\x6b\xd2\xd8\x31\x1b\xb0\x99\x34\xc0\x04\x18\xa7\xcb\xe5\xa3\x19\xc6\x0f\x8f\xb8\x96\xa4\x5c\xbc\xd5\x49\xd2\x94\x31\xc5\x34\x27\x54\x16\xa5\xf2\x80\xb1\xee\xd8\xad\x32\xc9\xd9\x46\x14\xa0\xb1\x20\xf0\xe1\xe5\x6e\x63\x15\x30\xa3\x49\x7a\x41\x68\x05\x20\xfa\xa9\x28\x37\x83\xb2\xd5\xda\xbe\x7d\xe9\x37\xcd\xfc\xf8\xfa\x95\x75\xa0\x58\xbd\x55\x3a\xbe\xdb\x50\xe4\xa7\xcf\x58\xec\x73\xf6\x1f\x93\xfe\xa8\x1a\xf0\x34\x98\x07\xee\xf6\xe7\xe9\x07\x1a\xea\xa5\x03\xb3\xde\x5c\x16\x7d\x52\xe2\x24\xba\x30\x44\x0d\x34\x4d\x05\xbb\x3f\x91\xde\xf4\x8f\x04\x56\x4c\xe1\x6d\x6a\xa2\xa6\x92\x7f\x80\x32\xcc\x8c\x97\x71\x16\x8b\x11\xee\x89\x56\xe3\x74\x40\x8c\xac\xd6\x68\x68\xaf\xc7\x83\xc3\xcd\xf1\xf9\x8d\x76\xa0\x25\xec\xb8\xd1\x64\x6c\x16\xbd\x26\xa3\xd3\xa6\x85\xc8\x4e\xa5\xb5\x6a\xe4\x28\x2e\x73\x8f\x52\x3c\x95\x95\xe9\x7b\xc3\x6e\x44\xa7\x4c\xb4\x01\x72\xb6\x2a\x08\x77\xab\x67\x46\x2b\x66\x8e\xc9\xd9\x2c\x6a\x2a\xdd\x3e\xde\x2f\x7d\xfe\x8f\xc6\x8d\x0d\xcf\x7c\xc0\x0c\x1e\x4b\x83\x69\x13\xf5\x93\x9b\x5e\xde\xf8\xf2\xac\xb5\x8e\xe9\xc4\xf1\x81\x76\x49\xfb\xe0\x19\xb8\x49\x87\x8e\x6e\x1f\xd0\x0c\x0e\xd8\x07\x26\xfe\x5a\x13\x1f\x3e\x85\x5c\x73\x71\xcd\x0d\x3b\xf0\xc1\x68\xfe\x61\xd7\xe7\xd4\x0a\xe2\x1c\x8c\x7d\x20\x6e\x89\xb8\xad\x04\x91\x47\xe7\x05\x08\xb7\x56\xcb\xba\xd9\xa2\xe2\xc2\x42\x07\xe3\x67\xad\xaa\x6c\x47\x76\xab\xc8\x3b\x52\x23\xaf\xe4\xd9\x9e\xca\xe5\x76\x65\x2a\x47\x9b\xe4\x5e\x57\xab\xd4\xa9\xf2\x45\xf9\x34\xc8\xc6\x24\x9a\x1a\x58\xca\xc1\x78\xc0\x90\x4c\x1d\x54\x94\x56\x03\x62\x16\x4b\xd7\x8f\xac\x9d\xb2\xac\x65\xb8\xe7\xd1\xd7\xe6\xfd\x61\xeb\xf3\x95\xd4\x80\x3d\x1d\x87\xee\x5d\x0f\xa8\xbb\x75\xd3\xd7\x37\x0e\xa9\xac\xba\xce\xab\x63\xf1\x8d\x13\x1a\xce\x4e\x6a\xff\xf6\xc9\x55\x77\x15\x8c\xf6\x7e\x7e\xfa\x77\xdf\xac\xbf\xaf\xbd\xe9\xc9\x33\x77\x60\x5d\xf7\x5a\x47\x67\xef\xfb\x7a\xce\x82\x25\xf3\x46\xbe\x50\x35\x01\xf9\xc6\x42\x78\x90\x0e\x51\xe3\xb8\x08\xf6\x1d\xca\xc9\x60\xb3\xee\xc3\x94\x0c\x93\xc6\x14\xc1\xc1\x7c\xc1\x44\xa8\xbb\x33\x4c\xc9\x5c\xcc\x83\xe8\xe7\x95\x5c\x0c\x36\x0b\x3b\x80\x25\xff\x86\x1b\xfd\x8d\x05\xe9\x64\x4c\x77\x4e\x4a\xf6\xbf\x28\x7f\x83\xfc\xaf\x9c\x2b\x8a\x28\xb9\x25\xdc\x09\xff\xca\x67\x4e\x0f\x2b\xf4\xc8\x2d\x29\xff\x46\x77\xbe\xa7\x12\x98\x93\xb9\x28\xf8\x4f\x80\xe7\xdd\x3e\xe5\x5f\x48\xff\xbc\xbc\x2f\xf2\xcf\x2f\x57\x7e\x1e\x77\x66\xe4\xae\x7e\x2c\x8a\xb9\xd9\xee\x9f\x87\x76\x63\x70\xd7\x97\x72\xde\xc4\x8c\x65\x63\xad\xf1\xac\x28\xcf\x73\x6a\xb7\x03\x06\x75\x6e\x23\x61\x24\x72\x72\x55\x1e\xb7\x07\xba\x2c\x8f\x07\x63\x18\x41\xce\x97\x04\xaf\x9c\x2f\xe9\x39\xab\x2b\xa9\x88\x19\x79\x12\x95\xdf\x67\x82\xba\xc8\x99\xbb\x77\x39\x64\x2a\x55\x26\x75\xc1\xf8\xe9\xc8\xf1\xb3\x07\x36\xe1\x0b\x16\x74\x49\x92\x74\xbd\x6e\xf6\xf0\x01\x55\x03\x17\xaf\x9b\xdd\xc9\x02\x63\x55\xdf\xaa\xba\x32\xdb\x12\x9a\x3a\x74\xdb\xf6\x5d\xaf\x78\x74\xb6\x5b\xd6\x7e\xf2\x5f\x10\x28\x28\xc7\xc7\x82\x37\x2f\x96\xd4\x56\xbf\xf2\xe0\x9c\xd5\x64\x07\x05\xc6\x4c\x9a\x3a\x70\xf7\xc6\xc4\xc2\x1a\x24\x17\x07\xfd\xdb\x5a\x6a\x2b\x16\x80\x51\xc0\xe4\x78\xcc\xe6\x51\xe5\xf1\x66\x73\x30\xe8\xc3\x00\xf0\x78\x8a\x68\x83\x01\x86\xa9\x85\x45\x98\x25\x17\x62\x05\x5f\xae\xd1\x19\x86\x3e\x0f\xd3\x6b\x21\x82\x35\x92\xec\x70\x91\xcc\x30\xe2\xe9\x01\x5b\x3d\x26\x77\x74\x4f\x1e\x95\x53\x42\x84\x0a\x0b\xca\x12\xa6\x22\x15\x78\xd0\x82\xdd\x37\xf8\x6a\xe8\x10\x4b\x83\xc9\xd4\xfb\x00\x40\x0a\xfd\x73\xa5\xb7\xbf\x90\xae\x51\x4f\x1c\xa7\x07\xab\x17\x93\x6b\x67\x2e\x0f\xc4\x07\x4e\x59\x76\xe6\xc0\xd6\xf5\xb6\xd1\xbc\xf4\x6c\x43\xff\xe1\x7d\x8a\x1a\x02\x14\xd1\x57\x3a\xf2\xad\x24\x01\x43\x56\x10\x67\x60\x80\x33\xaf\x60\xf9\xbe\x67\xc0\xdc\x95\xf3\x8f\x3c\x7d\xc3\x96\xba\x9b\x16\x81\x65\x8b\x6e\x98\x5d\x5b\xfb\x74\x72\x0e\x0c\xba\x47\xce\xa3\x9a\x30\x3f\x56\x1b\x77\x7a\x69\x1a\x67\x18\xbb\x85\xe3\x02\x41\x2f\x6b\x77\x10\x8c\x7c\xd3\xc0\xc2\x38\xf1\x51\x60\x7d\x10\x22\x23\x32\xa3\x1c\x44\x3e\x9b\xdd\xb4\xab\xc9\xf8\x56\x48\x4e\x7c\x56\xa1\x89\xf7\x72\x9a\x1c\x6e\x1e\x1e\x09\x56\xf8\x30\x13\xaf\xe6\x30\x6a\xc6\xa2\xe1\x39\xe3\x9d\x74\x61\xfe\xd8\xa7\xf7\x86\x07\xfd\x81\x49\x14\x30\xef\x36\x19\xe6\x3f\x7b\xad\x01\x94\x81\x2a\xea\x2a\xd0\x87\x6a\xaa\x96\xfe\x73\x6d\xbf\xdc\xe7\xa5\xbb\xdf\x90\x6e\x90\x13\xe3\x27\xdb\x5a\x0e\x01\x6a\xdb\x08\xe9\x03\xe9\x8b\xa2\x32\xd0\x08\x26\x75\x75\x75\xcd\xc1\x30\xb5\x83\x6a\x62\xa3\xc4\xf5\xd8\x97\xb2\xf6\x96\x48\xf3\xbb\xbe\xc4\xd4\x0f\x80\x30\x91\xbc\xd7\x96\xe5\x53\x7d\x07\xf5\xfb\xfa\x64\x1e\xf8\x23\xb0\x17\xd3\x3d\x84\x83\x02\x2a\x22\x1f\x33\x02\xf3\x41\x5f\xd8\x49\x5d\x0b\x75\xda\x0e\x31\xd8\xf8\x78\x19\xd0\x0a\x56\x80\xa9\x34\x1a\x9d\xdb\xc3\x99\x55\x7a\xbd\x81\x27\x1d\x06\x03\x09\xe3\x67\x4f\xab\xc8\xb1\x7a\xa8\xe1\x7a\xab\xce\xa9\x11\x50\xf0\x0c\xac\x10\xf6\x00\xe8\x1a\x5f\x4d\x6d\x7e\x4a\xd9\xbb\x6f\x56\x84\x18\xfc\x1f\xed\x3a\x52\x6d\x9c\x54\x27\x3d\x23\x34\x53\x4e\x50\x1a\x25\xca\x39\x0a\x39\x47\x15\x4e\x64\xb7\x3c\xf4\xe7\x9b\xa5\x4b\x87\x1b\x37\x36\x3e\xf8\x87\x6d\x00\xbb\xab\xe5\xa5\x43\x9b\xd7\xde\x97\x78\xb4\xb5\x66\xc3\xb5\x07\xa9\x6b\xa4\x46\xc3\x9f\x8f\xee\x92\xa4\xc3\xac\x34\x01\xdc\x65\xf8\xf3\x91\x5d\x80\xb8\xd3\x04\xce\x5c\xfa\xe9\x7d\xee\x52\x22\x1f\x64\x2f\xee\x5c\x66\xc2\xbf\xae\x94\xde\x53\xce\xab\xba\xeb\x73\x55\x01\xf4\x89\x36\x18\xc5\x88\xf1\x7c\xdc\x12\xb5\x19\xed\xf6\x58\x44\x45\xaa\x62\x36\xc2\xa2\xb5\x68\x4b\xcb\xbc\xf9\xe6\xfc\x56\x91\x35\xc7\x62\x04\x63\xb6\x46\x11\x01\x7b\x8b\x88\x13\xc6\x9e\x46\x98\xcb\x08\x6e\x95\x7b\xa2\x94\x37\x41\x25\x59\x41\x33\xc4\x49\x3d\xcc\x30\x54\xee\xf2\x0a\x2a\x69\xa6\x95\x7c\x8c\x5f\x95\x61\x92\x4f\x77\xb4\x0e\xa2\x3e\xe5\xa4\x8b\xc3\x87\x2e\xfc\xe3\x26\xc5\x1e\x4b\x0f\xed\xdc\x86\xbb\x64\x53\x5d\xdd\xd9\xaf\xa4\x52\x32\xce\x5f\x9b\xb4\xcc\x44\xed\x3d\x80\x9d\x51\x7e\x62\xf5\x2d\x7f\x5f\x0d\x4d\x32\x98\x72\x2c\xd1\xfc\xb8\x6c\xac\xa7\x5c\x98\xbf\x68\x5f\x69\xbd\xf4\xdd\xe1\x94\x6d\x86\x7a\x6d\x85\x7b\x8a\x72\x6d\x71\x6c\x71\xbc\x2a\x9f\x35\xe7\x84\x72\xdc\x6c\x85\x7e\xc0\x80\xfe\xfd\x2b\x70\x37\x21\x94\x08\x25\x03\x6b\xca\xf2\x39\x87\x39\x8f\xcb\xb3\x16\x19\x43\xd1\xa8\xaf\x4d\x8c\xb2\x56\x4b\x15\xc3\x54\xb6\x21\xc3\xa5\x46\xa1\x80\xb3\x87\xc2\x27\xbf\x70\xe9\xe0\xb4\xc7\x6a\xc8\x86\x2c\xc5\x3e\xdc\x4d\x50\xa2\x56\xe6\x39\x51\x30\xb4\x89\xa2\x68\xae\xbc\x2c\xdd\x74\xa2\x1c\xf5\x30\x6a\x24\x14\x20\x72\x57\x59\x94\x46\x3c\x02\xa2\xa5\x83\x63\xdb\x64\x4a\x93\xb2\x91\x3c\x04\x65\x9d\xa3\xad\xd2\x7f\x5c\x79\x9f\x92\xed\x6b\x38\x03\x28\x2a\xa9\x6c\xd5\xd5\xd9\x36\xb5\x5f\x35\xda\x05\x78\x36\xdf\xf4\x29\x39\x79\xad\x03\x5c\x05\x3f\x1d\x1c\x0b\x9d\x56\xc8\x4f\x36\x2e\x2b\x05\xb3\x17\x37\xaf\xba\x67\xb7\xd8\x30\xf7\xce\x11\x33\x86\x57\x0c\x6b\x68\xeb\xbf\x69\xef\xbc\xc5\xcd\xb7\x1f\x1d\xb3\xdb\xd7\x30\xfb\xd4\xc4\xbd\xfd\x76\xb7\xf5\x97\x3e\x78\xf1\x2d\x59\x57\x86\x42\xec\xb1\x15\xda\x02\x0b\x16\xc4\x06\xc6\xfd\xac\xd1\x68\xc1\x30\x42\x4f\xe8\x43\x61\xd6\x62\xb6\xb4\x8b\x66\xa7\xda\xde\x2e\xaa\x49\xcc\xd7\x2e\x1a\x95\x9b\x60\xec\xf2\xa1\xbc\x29\x7a\xca\x08\x9e\x59\x76\x90\xb4\x06\xbd\x4a\x13\xbe\x78\xf6\xa3\xe7\xc0\xe4\x7f\x1e\x01\xe0\xe6\x83\xd2\xa7\x4f\x54\x1d\x65\x12\xeb\x98\x93\xf8\x89\xdb\x36\x5e\xf7\xea\xba\x9d\x37\xae\x7c\xed\x06\x2a\x07\xb8\x5f\xfa\x16\xac\x7e\x7d\xd3\xcf\x77\xbc\x29\xed\x79\xcb\x23\x3d\x8a\xe6\x0f\x93\xfb\x9f\x7c\xf7\x05\x69\xfd\xd9\xc7\xdf\xbc\x00\x16\xa3\xdc\x31\xc4\x7e\x30\x4e\x85\x67\xd8\x87\xb2\x74\x9c\xc9\x04\x63\x3b\xb5\x41\x6d\xf0\x07\xf4\xf0\x7c\xea\x59\xd2\xdd\x2c\x9a\x48\x0b\x47\x00\xa2\x59\x04\xce\x74\x04\x90\x71\x54\xd3\x8f\x2e\x0f\x11\x91\xcf\x67\x72\x14\x3f\x7c\x78\x54\xd8\x9c\x7c\xee\x01\x00\xaf\x95\x3c\xf4\x8c\xf8\xd5\xd7\x6f\xb9\x78\xfb\xbd\xaf\x7c\xf2\x58\xff\xf9\xe3\x57\x56\x2f\x6f\x1c\xda\x37\x7e\x4d\x9d\xd4\x34\xd0\x06\xc6\x05\x2f\xdc\x7c\x08\xb0\xb7\xbf\xf9\xd0\x5f\xa4\xf3\x85\xd2\x21\x8e\xf8\xf4\x9b\xdb\xba\xb0\x9b\xae\x5e\xb9\xf3\x92\x6c\x77\x07\x4b\x53\xa8\xc9\x70\xad\x43\x58\x41\xdc\x62\x51\xfb\x19\xcc\xa3\xf6\x84\x23\x98\x45\xef\xd7\x43\x93\x6b\xd0\x93\xc9\xb4\x12\xd7\x1d\xe8\x29\xcb\x5a\x1a\x29\x04\xa9\xa5\x15\xe4\xbb\x69\x64\x59\xd1\xf0\x41\x22\xc9\xe1\x44\x2c\x9b\xbb\x64\xcf\x5f\xdf\x7f\x1d\xac\xf9\xe9\xdf\x5f\xc4\xc6\xa9\x96\xdc\xdf\x85\x49\xaf\x0f\xdb\xb1\x71\xe4\xcd\xd3\xfa\xfe\xe9\x4b\xd3\xd4\x96\x9d\x05\xcd\x39\xe5\xad\xc0\x7a\xe6\x7d\x30\xfc\x91\x41\xd2\x93\xcf\x8c\x93\x1e\x97\x3e\x9f\x76\xdb\xc2\x32\x7f\xbf\xc1\xa3\xfa\x2d\xb9\xb3\x6a\x4a\x44\xe1\x42\x1e\x2a\x5d\x4f\xdc\x4f\x16\xc3\x55\x8d\xc5\xad\xa4\xcd\xcb\x19\xf4\x36\x3d\xb4\x83\xa4\xc1\xe3\x72\x61\xad\xa2\xcb\x68\x50\xc2\x52\xd4\x5f\x75\xa1\xf7\xc3\x82\xe4\xe0\xff\x64\x64\x5a\x91\x4a\xcb\xa2\xa7\xef\x87\x82\x3e\xfc\xed\x85\xf7\x4f\xc9\x1b\x31\x69\xbc\xf8\xfa\x3b\xa6\x69\x2d\xf5\xad\x07\xae\xdf\x0f\xec\x0f\xcc\x68\xad\x1b\x40\xf4\x5d\xfa\xe5\xaa\x92\xda\x62\xa7\x73\xdc\xe0\x1b\xee\x2e\x6a\x8f\x34\x97\x66\x17\xf3\x59\x1b\x17\x9f\x06\x85\xf7\xae\xff\x11\xe2\x7d\x09\xc3\xa8\x52\xaa\x3f\x8c\x9f\x46\xc7\xf3\xac\xa4\xc5\x42\x51\x7a\x1d\x66\xd0\x19\x04\x1b\x20\xad\x64\x87\x68\xb5\x6a\x18\xc6\xd2\x21\x1a\x19\x46\xdf\x2e\x32\x04\xa5\xd3\xe8\xda\x45\x4d\x8f\xa2\xa3\xcb\x46\x22\xa7\xea\xeb\x64\x27\x1d\x8c\x66\xcc\xf4\x87\x8b\x2d\x57\x21\x91\xa1\x98\x08\xa4\x5d\x63\xde\xa5\x13\xe3\xe9\xc3\x2f\x1e\x65\xc8\x31\xf1\x49\xba\xe2\xae\x86\xcd\x13\xf1\x27\xa5\x7f\x1c\x97\x78\xb9\x9a\x61\xa9\xa3\x41\xda\xf3\x85\x5a\x9d\xf8\x0a\x3e\xeb\xfb\x50\x3f\xef\x82\x76\xd8\x8c\x62\x54\x56\xa5\xe2\x2d\x34\x00\x04\x8e\xf3\x26\x8c\x81\xd6\x96\x65\x18\x9c\xa2\x60\x1c\xad\xa6\x28\xa8\x9f\x94\x11\x47\x38\x3e\xe3\xf9\x62\x99\xc5\x7f\xc9\x4c\x44\x38\x99\x46\x84\x01\x3e\x7c\xaa\x98\x5c\x47\x02\x86\xcf\x91\x7e\xfc\xdb\x26\x9a\xe8\x28\xad\x07\x73\x8e\x35\x76\x7e\xd8\xbf\xbe\xa5\x1e\x9c\x4a\xec\xa7\x54\xb6\x1a\xe9\xdd\x93\x86\xc4\x1b\xf7\x4a\x35\xc7\xd1\xde\xba\x31\x8c\xec\x07\xd7\xcf\x8e\x95\xc4\x05\x95\x56\x8b\x09\x82\xd3\x6c\xb5\x32\x3a\x9d\xc3\xa9\xb3\x5a\x49\x96\x40\x25\x38\xd5\x5c\x26\xfd\x6f\xba\xca\x23\x9c\xac\xc0\xad\x30\xfb\xcd\xe5\xdd\xc5\xb7\x30\x72\x20\x06\x8c\x62\xbe\x23\x6a\xa6\x5f\xfa\xf4\x0f\x9e\x91\xe8\x95\x48\xb8\xde\xf7\xdd\x5e\xc7\x0c\xd5\x3a\xea\x8e\x02\x35\xce\x37\x65\x27\xdf\x7c\x94\x38\xdf\xac\xe0\x90\x12\x68\x69\x96\x42\xfc\x85\xd8\x7e\xad\xa8\x24\x88\x82\xe7\x17\x07\x14\xd0\x68\xd1\xb8\x19\xe8\x93\x2c\x19\x8f\xd2\xa3\xde\x04\xf8\x51\xcd\x0c\x88\x01\x07\x3e\x41\x7a\x72\xc5\xdb\x89\x43\x60\xe4\x0a\xa2\xf2\xd2\xf3\x78\x36\x21\x73\x71\x8d\x90\x06\x53\x13\xa9\x59\x10\xe3\x8c\x89\x87\xbd\x3e\x1f\xe6\x17\x6c\x36\x87\x9d\x77\xbb\x0d\x26\x93\xdf\x4e\xe8\x08\x5d\x20\xe8\xe6\xdb\x45\xb7\x9d\x63\x5c\x98\x57\xe5\x7d\x14\xb0\x0f\x8a\x7e\x3f\x62\xeb\x29\x4c\x5a\xfe\xc2\xb4\x91\xa8\x8c\xf5\x6a\xbd\x85\x8f\x80\xf2\x76\xc8\xd4\x71\xc8\x58\x44\xe5\xfb\xf0\x28\x02\xaa\x68\x7c\x5c\x45\x24\x4c\x04\xc1\xf4\x2d\x2b\xe8\x5b\x80\x6a\xeb\x27\x60\xf8\x83\x1f\x1d\x5a\x34\x77\x63\x7e\xce\x80\xe1\xd6\x8e\x4f\x46\x3b\x1f\xdc\x7c\x50\x7a\xaf\xe5\x20\xb9\xd3\xdc\xb6\x6f\x6c\xfd\xab\xd2\x86\xaf\xff\x9b\x78\xf1\x19\xef\x31\x70\xea\x89\xa5\x5f\x8d\xe1\x6f\x5c\x95\xf8\x18\xfc\xf3\xf6\x4f\x8b\x3f\xf4\x48\x35\xf2\x5a\xf1\x52\x9c\xf8\x8c\x64\x30\x07\x76\x55\xbc\xc4\xee\xe0\x2d\x36\x0c\xe3\x38\xb3\xd1\x6a\x75\x58\x48\x3d\xa9\x77\xba\x2c\xbc\xc3\x1e\xb7\x9a\x87\x8b\x18\x9a\xfd\x6a\x87\xa1\xa5\xd5\xce\x23\x73\x88\xb7\x89\x6a\x85\x46\x9a\x53\x1a\x8c\x73\xe5\xc6\xa7\x57\xd9\x57\x7b\x48\x97\x79\xf5\x27\x57\xf7\x96\x67\xc8\xd6\x1f\x50\xd1\x70\x24\x4a\x45\xf1\x8d\x2b\xfe\xb8\xfc\x38\x7f\xfa\xd1\x27\x80\x7e\xf3\xf1\x73\x63\x16\x4f\x91\x26\x95\x80\x17\x0d\x3e\x29\x5c\x8c\xbf\x7c\x7f\x60\xfe\x90\xdf\x49\x9f\x3c\xfb\xa2\xd4\xfe\x8f\xbc\x33\xa0\xea\x60\xf8\xdd\xa5\x5f\x4e\x1a\xf6\xe3\x52\x59\x86\x99\xd2\x60\x75\x15\xd4\xbd\x06\x6c\x57\x7c\x18\x8c\x73\xab\x99\x48\x30\xe8\xa1\x9c\x4e\x4f\x1e\x96\x9f\x1f\xf3\xe8\x4a\x74\x25\x43\x1b\x07\xf5\xeb\x14\x07\x0d\x2a\x57\x97\xd7\x77\x88\xd5\xe5\xae\x92\xfc\x7c\x26\xe8\xf1\x70\x8c\x91\x69\x17\x0b\x7d\x46\xc2\x41\x51\x82\x5a\xe8\x14\xd5\xe6\x3c\x0c\xcb\xc6\xb3\x3b\x45\xdc\x8c\xf5\x9c\x33\xd9\x5d\xdf\xa1\x48\xa4\x0c\xbb\x4d\x86\x21\xdd\x21\x48\xb7\x03\x4f\x4e\x79\x95\xdb\xe7\x52\x53\x94\x95\xca\x8e\x64\xf6\x39\x9a\xf9\x81\xd2\x6f\xa1\xbc\xc5\xd1\xdd\x6e\xd2\xb7\x2b\x13\x97\xd1\xed\x2e\x79\xee\x89\x99\x4d\xb3\xdd\xaf\xed\xbc\x76\x9d\xe1\xd0\x26\x06\xb7\x33\x33\xef\xd2\x8f\xb3\x2d\x2c\x24\xd4\xf7\x76\x30\xe0\x2b\x66\xc6\x5d\xba\xa2\x42\xcf\x64\xef\xb9\x0e\x06\x27\x99\x15\x7f\xcc\x97\x3e\xfe\x66\xeb\xda\x21\x9d\x05\x13\x57\x06\x26\x84\x2a\x0f\xd4\x6d\xbf\x71\xe8\x84\xc2\x0f\x5b\xa7\x0e\xc8\x9b\x35\x7f\x5e\x9f\x7a\x62\x3b\x2a\x0a\xb9\x34\xb9\xc6\x3b\xd9\x62\xc8\x0b\x47\x88\xe7\xe5\xf7\x9d\x45\x05\xf9\x15\x9c\x9e\xac\x95\x0b\xaa\x66\x4b\x89\x44\x6d\xc8\xdb\x5c\xf9\xb2\x2b\xdc\x56\x10\x94\x6b\xa8\xbe\x84\xe7\xe0\x22\xb4\x41\x03\xb0\x35\xf1\x41\x26\x9e\x8f\x19\xbc\x2e\x97\x43\xe5\x0c\x61\xe1\x70\xd4\xa9\x8f\xe8\x23\xd5\xf1\x8a\xc2\xe1\x62\x45\x45\x8e\x26\xa7\xaa\x45\x8c\xe5\xb8\xc2\x4e\x23\x6b\x40\x93\xcf\x1d\x2a\x95\x55\x63\x6d\x83\x70\x37\x84\x61\x7e\xc2\xdf\x26\x12\xd6\xcb\x57\x5a\x8e\x7c\x7e\x75\x81\x63\x19\xcb\x2b\xc7\xe9\x99\xeb\xab\xac\x2e\x4a\xfd\x66\xa6\xf9\x71\xec\x4a\x4b\xca\x91\xf3\xea\x0f\x4d\x11\xa7\x82\xad\xe7\xc7\xce\xe0\x26\x2d\x96\x53\xff\xf5\xc1\xf6\x46\xdd\x64\xa0\x9f\x66\x1d\x5a\xbc\xc2\x8f\x2e\x01\x0a\xa4\x0f\xbf\xbc\x7c\x21\x57\xdc\x7f\xcf\x55\xed\x33\x27\x5e\x98\x3f\x25\xdc\x81\x9b\x6d\xca\xa5\x40\xeb\x8a\x0a\x3c\x26\xbf\xda\x34\x1e\x5d\x0f\x48\x3f\x49\xdf\x66\x2c\x1f\xd0\x22\x9d\x1d\x05\xfd\xcd\x07\x54\x1b\x16\xc1\x3a\xe3\x25\x16\xca\x81\x45\x22\x4e\xa7\x9f\xa6\x7c\x94\x2f\x9a\xe5\x8f\x84\x22\xed\xa2\x03\xc3\x6c\xb8\x0d\xaa\x21\xae\x0d\xa5\x6b\xb0\xb4\x5c\x87\xc8\x68\xc9\xd4\x3d\x47\x12\x42\x16\xf6\xae\xc1\xe2\x2a\x53\x77\x46\xb2\x45\x51\x82\xc1\x50\xac\xe7\x3d\x6e\x72\xe8\x63\xaa\xb8\x8e\x58\xfe\xe1\x23\xcf\xbc\xbe\x16\xeb\xda\x53\x72\x8d\x3b\x57\xd4\x6a\x0b\xdc\x63\x16\x2f\x9a\xbf\xe0\xf4\xcc\x1d\x0c\x3e\xc7\x70\xf2\xa5\x24\xa0\x72\x4f\x38\x77\xea\x8e\x6f\xb7\x99\xf5\xd2\x5a\xc1\xf1\xd5\x99\xab\xaf\xed\x8b\x37\x21\x27\x75\xf1\x26\x04\xa6\xa0\x6c\x33\xa0\x2f\x58\x04\xe3\x7a\x0f\xb4\x91\x79\x66\x0a\xb3\x79\x3c\x76\xbb\x53\x47\x39\x28\x87\xd7\x07\xed\x8b\x15\xb7\xb6\x42\xa9\x34\x1e\x8f\xb3\x59\xf4\x58\xec\x98\xc6\x08\x51\x95\x5e\x03\x52\x63\xb9\xab\x33\x1d\xe9\xaf\x4b\xc4\x62\x19\x29\xe9\xa4\x3c\xb2\x8b\xc5\x5f\x59\xbe\xf7\xae\xdf\x03\xe3\x07\xe3\x3b\x8a\xeb\x19\xde\x5f\xda\x5e\xd9\x32\xaa\x71\xf2\x56\xa0\xfb\xf7\x78\xbd\xb4\x03\xb7\x35\x3f\x77\x06\x30\xa0\x39\xf8\xe9\x26\x61\xfb\xf7\x2b\x56\x2e\x0d\x10\xe1\x5f\x5e\xb5\xa1\x7e\xd3\x6b\xa1\x5e\x0f\x86\xb6\xa4\x14\xbb\x3a\x5e\x95\xe3\xce\xce\xf6\x78\x42\xda\xa0\xc5\x66\x2b\x29\x0c\x16\x96\x95\xbb\x73\x72\x9c\x79\xce\x4e\x31\x2f\xcf\x1f\xc9\x0e\x45\x42\xed\x62\x84\xf0\x04\xfd\x41\x88\x08\xa8\x4e\x91\x61\x30\x3f\x87\xc1\x1d\xd2\x62\xae\x24\xa0\x45\x7b\xd3\xa3\x6a\xae\xa7\x54\xdd\x17\x17\xc9\xb1\xd8\x97\x2b\xa8\x32\xf9\x1a\x59\xce\x6e\xf4\x00\xb7\x2c\x35\x23\x1b\x27\xf1\x87\x2f\x57\xcc\xc5\x9b\x83\x43\x99\x29\x63\x16\x9c\x9e\x71\x07\x93\xd8\xc8\x3c\xf0\xe2\xdd\x0c\xbe\x89\x79\xbc\xf1\x8b\xad\x67\x9e\xe4\x06\x42\xab\x20\x0d\xce\x50\xc9\xe7\x9f\x07\x87\x06\x97\xd5\xb4\xf4\x4d\x3c\x24\xa3\x8d\x25\xe8\x4f\x69\x64\xcb\xae\xad\x15\xb3\xa4\x2d\xf0\xf4\x2b\x75\xd0\xaf\x75\xfd\x97\xb8\x0d\xe2\xe2\x1c\xb8\x3a\x73\xe3\x7d\x34\x50\x43\x1c\x81\x60\x30\x1a\xf6\xf9\xa2\x31\x9e\x8f\x3a\xa2\x65\xe5\x16\xa1\x18\x06\xb2\xb1\xe2\x62\x6d\x80\x85\x9f\x7b\x3c\xb9\x2d\xa2\x87\xa5\xa9\x56\x91\xd6\x5a\xe4\x84\x79\xb2\xa6\x27\x96\x79\x47\x87\x7c\x71\x0f\xd4\x94\x41\x5e\x91\xba\x27\xe9\x26\x4c\x91\x1b\x4e\xcb\x92\x07\x5e\x61\xa0\xaa\x88\xa9\x94\x4b\x80\x14\xe3\x60\x45\x04\x1c\xed\x3f\xb3\x21\xc7\xe9\x8c\xf0\xad\xc2\xd4\xda\xac\xaa\xf2\x8a\xf0\xd4\xd9\xe0\xda\xeb\x26\xcd\x1b\xb9\xa3\xfd\x91\x45\x61\xfb\x58\x5f\x3c\xbe\xea\xcd\xb9\x4d\xd3\x2a\xfb\x4d\x99\xeb\xd1\x85\x2a\xfd\xc5\x83\x96\x2c\x08\xe5\x86\xfe\xf5\x86\xad\x76\x6a\x5b\xdd\xaa\xfa\x05\xb1\xf2\x71\x23\x67\xde\xbc\x5b\xda\x46\x4c\x1f\x59\x9d\x53\x59\xf3\x90\xec\x6f\x5a\xba\x3e\x27\xa7\x40\xbc\x9d\x8f\x0d\x8a\xfb\xbd\x26\x22\x9c\x93\xa3\x15\x08\xa1\xa0\x90\x72\x6b\xdd\x10\x3f\xf3\x74\xbb\xc8\x93\x59\x18\x16\x68\x17\x31\x73\x26\x40\x54\xf2\xc1\x99\x3b\x9f\xba\xae\xca\x03\xc9\xe6\x69\x54\xb4\xab\xec\xad\x81\x50\xa7\xd9\x13\xa3\x15\xb2\x74\x78\xf8\xef\xdf\xe8\x40\x1d\x18\xbc\x69\x96\x58\x31\x3f\x77\xd8\xf8\x3e\xe7\xef\x7a\xec\x9d\xca\x19\xfb\xff\xf2\x5f\xfd\x8c\x25\xcb\xee\x0d\xf6\xdb\x7b\xed\x7b\xfc\xce\x3b\x4b\xca\x16\x9c\x7e\xe5\xb6\x19\x33\x73\x7c\x8f\x82\xea\xdc\x7b\xb6\x4f\xdc\xb5\x62\xf6\xf4\x8e\x9a\xe8\xe4\x51\x9b\x3b\x06\xc4\x6a\x06\xac\x1e\xbd\x67\xac\x82\x95\xf6\x40\x59\xae\x82\x67\x35\x84\xf5\x8b\xbb\x5d\x46\x3c\xa0\xb1\xe0\x96\x70\x84\x74\x68\x1c\x98\x91\xe3\xf4\x2d\x22\x07\x30\x6f\xf7\xcd\xdb\x15\xa4\x40\x32\xa0\xec\x53\x4a\x84\x0c\x09\x52\xf7\x0c\x72\xce\xbe\x8f\xd4\x8e\xb8\x84\xfc\x6b\x87\x0d\xe9\x68\x1b\x52\x5f\x7c\x62\xcb\x23\x7f\xae\xbd\xf1\xd3\x1f\x54\x73\x17\x2f\xdb\xea\xa8\x7f\x9d\x07\x53\x8a\x22\x53\xce\x7f\xfe\xfb\x19\xb3\xf3\x8e\x00\x6b\xf0\xc1\xdb\xe7\x3e\xb4\x6b\xdb\xec\xa2\xac\x65\xb3\x72\xfb\x97\x54\x2a\x39\x88\x11\xd0\x6e\xde\x05\xd7\x3e\x80\x85\x31\x31\x6e\x57\x3b\x83\x34\xc9\x6b\xf8\x90\x2e\xec\xd7\xe8\x34\x91\x28\xc6\xf3\x02\xc1\x0a\xec\xa3\xc0\x1a\x37\x8b\x4e\x35\x1d\x24\x75\x5e\x81\xd4\x6b\x42\xba\x50\x87\xa8\x4b\xc2\x75\x39\x0d\x21\x54\x26\x4f\x62\xa6\x2c\x26\xa5\x60\x35\x39\x8a\x1e\xa8\x33\x6e\xb4\x91\x50\x30\xfc\x50\x4e\x26\xa1\x05\x7e\x8a\x33\x65\x95\x55\x5f\x57\x5f\x09\x9a\xf9\x8b\x27\x78\xdc\xd4\x12\xee\x13\x76\x87\x46\x8c\xe9\x3b\x65\x75\xc7\x92\x8e\x7c\xf3\xa4\x13\xcb\x17\x4c\xec\x9b\xe8\x23\x0d\xc7\xb7\x12\xff\x79\x87\x1b\xdb\x31\xec\xd2\xc1\x85\x0b\xf1\xb7\xdf\x9a\xda\x6c\x7c\x07\x0c\x71\x94\x2e\xea\xb0\xaf\x9b\xed\x90\xce\x48\x7f\x4f\x1c\x94\xe5\x8b\x43\xdb\xb9\x05\x9e\x31\x3f\xdc\x91\x51\xf1\x7c\x95\x23\xa0\x27\x39\x35\x17\xd4\x86\x7c\x6a\xad\x1a\x06\x75\x1c\x67\x21\x0c\x16\x43\x8b\xe8\x50\xe9\x03\xa4\xd6\x63\x61\x75\xea\xa0\x36\xd8\x2c\x6a\x2d\xff\x3f\x64\x33\x02\xb3\x2c\x5a\xf7\x76\x79\xf0\x94\x64\x80\xf0\x93\x1c\xe5\x2e\x9d\x39\x72\xea\x5b\x9a\x04\xa3\x01\x23\xc7\x46\x46\x58\xdd\x75\xf5\x25\x4d\xe2\x80\x8e\xd6\xda\x9c\x01\x03\xb6\xcc\xe8\x68\x28\x49\xdc\xf1\x29\x18\x89\xef\x3c\xc3\x5f\xbd\x39\xf1\x52\x41\x01\x78\xf5\xbb\x39\xcc\x19\xe0\xb4\x9a\x0a\xc7\xce\x1c\x33\x7a\xa4\x45\xfa\x54\x4a\x48\x2f\x42\x99\x26\x77\x7d\x4e\xbd\x4e\x3d\x05\xe3\xbe\x7c\x74\x9b\xef\xf2\xfb\xa9\xa8\x09\xa3\xb0\x82\xc2\x3c\x97\xcb\xe3\xc9\x69\x17\x3d\x1e\x82\xd1\xda\xdb\x45\x2d\xc3\xf0\x9d\x30\x80\x21\x08\x68\x59\x89\x64\x77\xc2\x05\x85\x12\xf0\x72\x97\x90\xa6\xaa\x61\x31\x94\xe0\x95\x83\x58\x25\xe9\x81\xc6\xe6\x2a\x1d\xea\xe5\x31\x1f\x29\xb7\x62\x73\x72\xc2\x57\xad\xa2\xf6\x48\x6b\xa4\x23\x89\x23\x2f\x80\xc5\xcf\x4d\x1d\x31\x3c\xd6\x7f\x99\x77\x42\x68\xea\xfe\x3e\xc3\x87\xb6\x94\xb5\xdf\x5f\xf5\xc4\x19\x18\x27\x70\x97\x0c\xb7\x6e\x3f\xfb\xf2\x8a\x95\xa7\x1f\x1d\x88\xb7\x4b\x7f\x91\xce\xe0\xc2\xa7\x60\xe5\xb7\x46\xe3\xd0\xfe\x2f\x0f\x34\x5b\xcd\x77\xef\x1f\xff\x57\x69\xe7\xb3\x27\x41\x08\x70\x3b\xb7\x76\x7e\xa6\x9c\xa5\x08\x3c\x4b\x4d\xa4\x17\xcb\x82\x71\x59\xc4\x27\x08\xb8\x8b\x8e\xe0\x91\xec\x9c\xa0\xa7\x45\x0c\x06\x31\x8d\xc6\xd8\x2a\x6a\x8c\x2a\x33\x74\x76\x2a\x23\x66\xef\xbe\xad\xbb\xd0\x33\xa1\x9d\x29\x1b\xa5\x08\xe6\x05\x29\xb1\x52\xde\x4e\x36\x0b\x49\x38\x0d\x8f\x1a\x09\xfe\x23\xf5\xfb\x1d\x08\xfc\x7e\xdc\xf0\x86\x79\x9e\xbe\x81\xb1\x57\x15\x34\x37\x17\x8e\xdb\xd4\x78\x72\xd4\xcc\x83\xe5\xa5\xcc\xc4\x45\xbf\x7b\x44\xfa\x9e\x07\x0b\xef\x03\xfa\xbd\x2a\x55\x5d\xe5\xb3\xf9\x0c\xbd\xf1\xf3\x4d\x17\x8f\x6c\x38\x62\x19\x12\xdb\xb1\xe6\xa1\x37\x64\x19\xca\x60\x80\xf4\x0f\xe8\xff\xb2\xb1\xe9\xf1\x52\x5e\x05\xe3\x60\xad\xd1\x48\x45\xbc\x5e\x67\xb6\xc3\x81\x2a\xa1\x73\x72\x1d\x16\xc1\xd2\x2e\x06\x68\xda\x9c\xad\x32\xab\x3a\x44\xa7\xd9\x4c\x08\x97\x15\x42\xa7\x4d\x7a\x06\x2e\xe9\x4e\x5d\xa7\xd3\xd8\xdd\x05\xd0\xaa\x14\x2d\xf5\x00\x00\xc3\xf9\x64\x59\x78\x46\x05\x56\x10\x57\x41\x00\xb2\x8b\x39\x75\xfb\xbc\x31\x8d\x85\x23\xc4\x01\x8b\xc7\xb4\xdb\x8f\xd2\xf8\x6c\xfa\x94\xa3\x63\xca\xdc\x1b\x56\xb9\x07\x57\x0d\x1b\x3b\x05\x61\x10\x62\x45\xc9\x80\xba\x7e\xe5\x15\x73\xaa\x62\x6d\x05\xdb\x90\x33\xdb\x56\x5f\x3d\x74\xe5\xa0\xf2\xdc\xa6\xc2\xec\x80\x2c\x67\x1d\x94\xb3\x85\x42\x9c\x9e\x75\xf1\x90\x56\xa5\xd3\x51\x06\x00\xe3\x66\x18\x38\xb3\x26\x1d\xd3\x2c\xea\x30\xa0\xd6\xa8\x5b\x44\x83\xc6\x88\x53\xdd\x95\xa8\xb1\x94\x2d\xef\x96\x26\x3d\xf9\x9b\x40\x62\x04\x2b\x62\x72\xc5\x76\x8c\xe8\xff\xed\x4e\x69\x1b\x3d\xfb\x86\x1f\xb9\x1f\x47\x81\x59\xf4\x94\xc1\xdf\x12\xb5\x97\x1e\xaf\xb1\xe1\xff\x9e\x01\x3e\xae\xb1\x49\xd7\xca\xcf\x61\x85\x3a\x83\x72\x8b\x31\x54\x39\x2a\xa8\xdc\x6e\xd6\x47\x10\x39\xc5\x6c\x8e\x2e\xac\x0b\x97\x96\x31\x2a\x6f\x16\x45\xf9\xbc\x3e\x6d\xd0\x28\x38\x1c\xe6\x36\xd1\xc1\x6a\x2d\xc5\x18\x96\xdf\x96\x71\xf5\x9c\x99\x4a\x34\x65\xe4\x12\x33\x96\xba\x24\xe5\x68\xfe\xa7\xd4\x21\x9f\xa6\xf6\xaa\x94\xb3\x85\x8e\x82\x4f\xc9\x8e\xd5\xe9\x6c\xa1\x7d\xd3\xa4\x74\xb6\x90\x98\xbe\xc2\x91\xfc\x74\x03\x2f\xe7\x08\xb7\x75\x34\xcc\xbb\xab\x35\x99\x23\xdc\xb2\x3b\x9d\x23\x9c\xfb\xa0\xb8\xb7\x9f\xf2\x99\x62\xcb\x2b\xa4\x3a\x92\x86\xb2\x7b\xb1\x3c\xac\x32\xee\x8e\x90\x16\x9f\xde\x65\x71\xe5\x17\xd8\x03\x2d\xa2\x9d\x55\x73\x98\xc1\x45\x64\x63\xd9\x2d\x19\xa2\x42\x99\x7a\xd4\xc2\x29\xd8\x40\x8d\x0a\x16\x70\x85\x83\xa7\x10\x55\xba\xb0\xc8\x18\xc8\x25\x15\x3d\x72\x6d\xe0\x5f\xd3\xee\x28\x26\x16\xec\x7f\x60\x59\x1f\x55\x1d\x35\x7e\xe6\xc2\x87\xee\xdb\x07\x8c\x8f\xdc\xfb\xca\x96\x8b\xd7\xa4\x93\x6e\x7c\xf3\xd0\xfa\x49\xad\x9c\x50\x34\x6a\x68\x30\x5f\xb0\x6b\x75\xe6\x97\x5e\x03\x1c\x38\xfe\xe7\x37\x1f\x3a\x24\x7d\x7d\x3b\xbe\xbe\x3b\xfb\x06\xb0\xfc\xae\xcf\x65\x4c\x64\xc7\x4a\xe3\x76\x41\xab\x75\xb2\x38\xee\x70\xea\x68\x15\xdd\x2a\xaa\x58\xab\x19\x33\xa7\x7d\x27\x7b\x41\xf9\xb3\xbb\xf2\x30\x7d\xbc\x11\x2e\xef\x46\xb1\xe5\x72\x75\xc0\x59\x69\xd1\x4e\x60\x3e\xd5\xbc\xab\x28\x67\xfa\x94\x05\x77\x8f\x5a\x3e\xa5\xa4\xb3\xd1\xdd\xff\x59\x1e\xcc\x7e\x00\xb8\x0f\x64\x07\x47\x85\xd7\x7c\xb2\x65\xc1\x3a\xd6\x59\x97\x2b\xf7\x83\x48\xdf\x4b\x4d\x78\x35\xb5\x95\x53\x61\xc3\xd2\x7d\x61\x28\x07\x0b\x6d\x0d\xf4\x27\xd5\x71\x1f\xb4\x49\x24\xef\x70\xd0\x24\x1d\x08\xfa\x2c\x1d\xa2\xcf\x87\x8a\xf6\xda\x45\x0d\x89\xb1\x49\xa8\x72\xb9\x21\xea\xae\x62\x08\x45\x32\x93\xb0\xd1\x92\x72\xae\xc2\x8f\x74\x45\xce\xc3\xe2\x10\x76\xaf\x3e\x22\x75\xdd\x9c\xca\xc1\xbe\x28\xdd\xf5\xe6\xf4\x53\xd7\x7b\x13\x15\xfa\x9d\xf8\xa8\xdb\x36\xee\xf9\xb8\x04\x3f\xcf\x6f\xfa\xf9\x8e\x64\x02\xf6\x6b\x69\xd9\xf3\xd3\x37\x00\xfc\x40\xc3\xb0\xc7\xdf\xc4\x7f\x7a\xf2\x5d\xe9\xef\x1f\x2a\x76\xd4\xdf\xf5\x05\xb1\x0c\xae\xa9\x0b\x7a\xc0\x62\x96\x70\x68\xb5\x1e\x23\xcf\x13\x84\xdb\x63\xe4\x5a\x45\xb9\x13\x01\xfd\xf1\xa1\xb1\xcb\x48\xca\xe5\xad\x2a\x65\xb5\x31\x21\x13\xa7\xa4\x2a\x0f\xbb\x3b\x6c\x53\x75\x6a\x94\x1c\x3b\xf8\x93\x8b\xae\x52\xfb\xd5\xfe\x6e\x98\x02\x4e\xbf\xfa\x22\x88\x02\xf7\xe8\xdb\x42\xcc\xa4\x4d\xab\xee\x0c\x81\x0a\x8b\xf4\xa2\x6a\xc1\x9c\xe5\x13\x98\xe2\x23\xe6\x87\x2f\x80\x00\xe8\x97\x13\x18\xe6\xde\x7e\xdb\x75\x85\x59\xcb\xe6\x39\x86\x06\x72\x60\xdc\xf0\x11\x7c\xe6\x72\xf8\xcc\x4e\x18\xcf\x55\x19\xb5\x84\x01\x1a\x45\xc2\xe5\xb6\x6b\xb5\x2e\x16\x9a\x7d\x23\xeb\x65\x5b\xd8\x76\x96\x4c\xbd\x98\xcf\x7e\xc8\x76\xb1\x6a\x9a\x60\x59\x15\x26\x3f\xbe\x15\x83\x51\x91\x5c\xf2\xd9\xfb\xf1\xd3\xe5\xb8\xc9\x3a\x0e\xa5\x22\xc2\x9f\xec\x9a\x36\xfb\x2b\xfc\xc9\x00\x01\x1a\x4a\x70\xf0\xd5\x17\xa5\x77\xa4\xbf\x29\x8f\x7f\x69\x88\xf4\xa2\x05\x54\xa4\x9e\x9e\x38\x7f\xfa\x39\xe9\x03\xe9\x3c\x7a\x7c\x90\x73\x5d\x41\x76\xf2\xf1\x93\x3d\x87\x0f\xc8\x7d\x31\x07\xe5\x3e\x09\x51\x6a\x22\x1e\x97\x75\xe9\x9c\x7c\xb7\x5b\x07\x75\x69\xa6\xdc\xeb\x15\x91\xe3\xff\x64\xef\x1b\x66\x83\xf2\x16\xd1\x38\x01\xf1\x10\xc6\x30\x1a\xc1\x66\xe3\x0c\x26\x8d\xc9\xee\x30\x69\xf5\xda\x76\xd1\x86\xe3\x7a\x06\x35\xe5\xe9\x09\x81\x23\x34\x2a\x4d\xbb\x68\x51\xf5\xe8\xc5\x4b\x8d\x8a\xcb\x2c\xf1\x49\xde\x06\xc9\x37\xb9\xf2\x88\x22\xd0\x1d\xfa\x98\x41\x77\x37\x18\x51\x94\x2f\xbd\x75\xf6\x04\x2d\x05\xe9\x53\x2f\x1e\x65\xc0\x17\x97\xc0\x73\xe0\x6d\x06\xbe\xa6\x13\xf3\xe9\x67\xcf\x02\x09\xdf\x78\xf1\x83\x54\x02\x35\x71\x11\xa7\xd2\xed\x61\x01\x28\x03\x26\x35\x51\x43\x88\xe3\x10\x49\x4e\x8f\x97\x59\x38\xce\x45\x18\x8c\x46\x8d\x89\x25\x49\xe8\xe7\xb4\x1a\x0c\xc2\x49\x7b\xa0\x55\x74\xdb\x9d\xa4\xc9\x62\xd0\xd2\xda\x66\x91\xb6\x40\x50\x8c\x6b\xa0\xf1\x6a\x16\x29\x3c\x75\xab\x65\x4a\x27\x2e\x52\x29\x8b\x74\x35\x95\x29\x96\x99\x09\xea\x2d\x00\x74\x1a\xd0\xc6\xa6\xe7\xbe\xa3\x70\xcf\x01\xde\x1d\x4f\x83\x31\xd7\x81\x76\xb0\x85\x16\x6f\x6c\xa3\xa5\x0a\xba\x63\xa9\x54\x59\x74\xc0\x5a\x58\x57\xd0\xd4\x51\x17\x19\xc8\x65\xf7\x37\xa8\x19\x3a\xda\x7e\x37\x31\x42\xa8\x49\x3c\x8d\x57\xd7\xd8\x12\x1a\x5b\x0d\xf4\x2d\x77\x24\x34\xf8\xd7\x37\xfc\x24\x3d\xfe\xfa\x53\xa3\xad\xcc\xed\x21\x13\x03\x4c\xf8\xbb\x30\x76\xdb\x91\xac\x59\x13\x20\x72\x16\xe3\x85\x7c\x30\xa4\x63\x0c\x06\xad\x9f\x20\xd5\xa4\xcf\xa7\x81\xb1\x5c\xd0\xe4\x6e\x15\x4d\xac\x5a\x4f\x43\xd0\x4f\xd2\x34\xa6\x75\xfa\x6d\x28\xe7\x97\x59\xc3\x96\xf2\xea\xb6\x64\x31\x5b\xb2\xde\x30\x75\x13\x2d\xdb\xe2\x98\x3a\x08\xb1\x25\x72\x84\xbf\x5a\xd7\xe6\xfd\xc1\xfc\x83\x47\xfa\xde\x33\xd6\x3c\x76\xf5\x15\xea\xdb\x4e\xce\x38\x7e\x7c\x06\xfe\xc7\x2b\x96\xb8\x21\x26\xef\xae\xff\x50\xf9\x54\x23\xe6\xc1\x0a\xe2\x82\x53\x6b\x26\xb4\x84\xd7\xa7\x36\xb6\x8b\x3a\xb5\xd9\x89\x61\x56\x68\xca\xc8\xee\x3b\x99\xb4\x19\x83\x8a\x84\x6e\x37\xe4\xcc\x9a\x39\x66\x41\x8b\x1d\xe2\x32\x82\xae\x10\xfe\x06\x70\x83\x7e\x7f\x90\x56\xff\xfc\xc9\x8f\x65\x23\xcb\xf7\x8e\xbc\x1b\xa8\xb7\x3f\x7a\x74\xf2\xf3\xfd\x86\x8d\xaa\x59\x08\x38\xaa\x51\x7a\xa7\x0b\xfb\x51\xda\xfc\x4a\x29\x68\x7b\x26\xb7\xf0\x51\xd0\xf2\xa7\xd7\xff\x55\x99\xf7\x57\x30\x32\x5c\x08\x55\x22\x79\x46\x10\x77\x1b\x56\x1b\xf7\x43\xb3\x64\x8c\x5a\x2c\x79\x5e\xa3\x31\x37\x8f\xd0\x6a\x69\xb3\xd9\xd9\x2e\x5a\xcd\x64\x94\xa6\x61\x64\x48\x9b\x33\x9f\x51\xce\xcb\x67\xd6\xa4\x2b\xf3\x99\x33\x88\xc4\xe0\xb3\xa7\xee\x69\x64\xcf\x4d\xa6\xbb\x59\x62\x84\x8a\x24\x5e\x4f\x31\xcb\x49\xaf\x4b\x7f\x93\xce\xff\x01\xac\xfb\x29\x25\x85\xf4\x33\x94\xe2\xaa\x0b\xfd\x91\x14\xd2\x97\xf8\xa1\x24\xdb\x5c\x42\x0b\xed\x1c\xf6\x5f\xb0\xec\x95\x52\xe9\x04\x12\x47\x3a\xa5\x88\x23\x1d\x0f\x17\xca\x33\xdb\x92\xeb\x8c\xe4\x69\x8d\xe7\x46\x55\x18\x66\xf1\x1a\x2d\x50\x1a\x6d\x3b\x31\x5f\x99\x63\x82\xd3\x04\x41\x98\x69\x45\x32\x73\x52\x32\xb2\xb7\x64\xc8\x8e\xc5\x32\xda\x27\x4a\x7a\x0d\xf3\xfd\xed\x7d\x01\x87\x53\xb2\x81\xe2\xdf\xde\x21\x7c\x57\x52\x36\xfc\xc7\xdf\xda\xaa\x54\x8f\xb5\xea\x7d\x2e\x82\x7a\xac\x4d\x6a\x6c\x10\xc8\x01\xcd\x98\xe6\x41\x18\xd5\x45\xe4\x02\x95\xf4\xcf\xdc\x93\xfe\x99\x59\x60\x56\xaa\xef\xcb\x85\xfa\xbe\x9e\xc9\x0d\xdb\x89\xcc\x1a\x1b\xd4\x4f\x08\x6d\xca\x2f\xd0\x2e\x96\x60\xb7\xc5\xc7\xd9\x70\x41\x80\x96\x31\xac\xc9\x2f\x2a\xf2\x41\x68\xa7\x31\x90\xb1\xd2\x60\x6e\x87\x88\x45\xd8\x08\xae\x23\x22\x91\xa0\x13\xc7\x1c\x58\xa7\x68\x63\x1d\x3e\x07\x7c\x09\x30\x07\xeb\x68\x75\x74\x38\x0e\x3a\x4e\x3a\x54\x5a\xc2\xe1\x30\xaa\x4c\x06\x83\x51\xd0\x1a\xb5\x1d\xa2\x91\x50\x4c\xa8\xaa\xc7\xad\x93\x29\x26\xab\x8e\xdc\xa8\xb2\x70\x51\xac\x47\x35\x62\xba\x3a\x96\xab\x44\x16\x28\x99\x64\x4a\x65\x92\x82\xa9\x16\x61\xe5\x2e\x2a\x95\x52\x92\xaf\xdd\xcd\x8a\x39\x52\x92\x4f\xa4\x76\xe1\xea\x79\xf7\xd0\x89\x55\xf4\x03\x2f\x0c\xd9\x5f\xd7\x38\xa6\x86\x5c\xd3\x7f\xac\xd6\xbc\xa6\x79\xf2\x90\x23\xb7\x9c\xff\xb3\xb1\x36\x9c\x78\xeb\xe8\xe8\xd8\x08\xb5\xa1\x7f\x64\x7b\xa0\xd3\x34\x0d\xff\xd2\x93\xd8\x29\x5b\xda\xf9\xfc\xcf\x60\x99\x74\xfb\xdf\xd5\x7a\x69\x6e\xff\xa3\xfb\x86\x8c\x92\x16\xbd\xff\x4f\x0f\xf0\xdc\x29\x38\x9e\xc2\x23\xf3\x73\xc7\x76\x26\xfb\xf2\xc8\x0f\xd0\x7e\x10\x75\xf2\x5a\x2f\x05\x87\xe0\x5a\x5b\x1e\x02\x26\x2a\x02\x1e\x05\xf9\x0f\x99\x78\xa0\x4e\x57\x0f\x01\xf9\xac\x8d\x92\x6b\x4d\xc6\xc7\x8b\xcd\x84\x57\xa7\x0b\x5a\x38\xb4\xda\x81\x20\x07\x91\x4d\x21\x07\x68\x0e\xa0\xb6\x04\x35\x86\x2c\x03\x4d\xab\x49\xcc\xd1\x2e\xc6\xe1\x3f\xec\x41\x40\xe7\x0a\xbd\x2f\xdd\x40\xa1\x1b\x29\xa4\x0e\x9d\x15\x9d\x3a\xa8\x91\x58\x37\x58\x90\x0f\x1e\x89\xef\x95\xfe\x21\x3d\xff\x1a\x58\xfd\xd3\xd4\x97\xf7\x95\x8d\x5c\x78\xd7\x4b\xd2\xbb\x25\xe0\x0b\xb3\xc4\x53\x0f\x1e\x5d\x70\xa2\x02\xea\xa5\xd4\xc5\xc3\x38\x91\x40\x07\x8d\xf7\xc1\x93\x36\x4e\xfa\xea\xb3\x79\x75\xb9\x7f\xfa\x7b\xff\x2c\x78\xd4\x46\x2a\xb5\x53\x61\x18\x07\xb8\x65\xff\x5a\x7e\xc5\xbe\xf7\xff\x87\xbe\xc5\xae\x4b\xf0\x77\x96\xcb\xbf\x23\x5f\xce\xdf\x9d\xed\xfa\x5c\xf5\x17\xa8\x9b\x01\x78\x9e\x17\xc7\x2b\x70\x00\x4c\x9c\x2d\x28\x08\xa1\x10\x16\xe0\x02\xda\xac\x2c\x97\x2b\x4f\x9b\x6b\x0b\x76\x88\x36\x1b\xef\xf3\x85\x20\x40\x84\xa7\xd9\xc7\x09\x1c\xcf\xb5\x8b\x3c\xe8\x10\x79\x42\x65\x78\x14\x38\x1f\x12\x75\x3a\x95\x39\x95\xad\x4d\xe5\x37\xd3\xb8\x51\x21\x5d\x30\x71\x19\x9d\x0b\xa9\xdb\x35\x42\x69\xf8\x40\xda\x85\x62\x72\x27\x50\x92\x99\x72\xff\x2f\x89\x18\x1a\xd0\x6b\xa8\x71\x7e\xe2\x4d\xe9\x87\xe6\x29\x47\xee\x9f\x93\x3f\xd6\x1e\x8c\xbb\x6d\x79\xa3\x1f\x5a\x34\xec\x28\x43\x5a\x98\xd3\xa3\x8b\x7f\x01\x98\xf4\x82\x74\x5c\xca\x62\xb6\x83\x0d\x93\xcc\x4f\x1d\x90\xbe\x21\x5f\x97\xde\x97\xb6\x4a\xb3\x1f\xb5\x09\x00\xcc\x0d\x83\x75\xe0\xf7\xc0\xef\x40\x69\x4c\xc7\xb1\x87\xff\xf8\x5c\x83\x03\x0f\x24\x3e\xdb\x76\xe0\x33\xb4\x0e\x7f\x85\xd8\xa5\x1d\xae\x83\x0f\x9e\xeb\x6d\xf1\x26\xca\x4f\x92\x81\x80\x97\xf5\xf9\x8c\x46\x21\x12\xd1\x7a\x4c\x6e\x37\xc7\xd9\x04\xad\x90\x93\xed\x73\x93\x36\x87\xad\x5d\xa4\xfc\x1d\x22\x6b\xf2\x98\x3a\x44\xaf\xc7\xe8\x81\x8a\x45\x79\x28\x0f\x03\x1c\x04\x67\x14\x2c\x42\xbb\xc8\x04\x3a\x44\x86\xb1\x70\xf2\x9a\x74\x17\xba\x54\x16\xca\x15\x93\xf2\x99\xcc\x4d\x35\x06\x67\x76\x74\xa4\x9b\x17\xd3\x19\xe0\xe4\x7a\x58\x93\xeb\x61\xf6\xf7\xc8\xfa\xfa\x9d\xe9\x05\x3a\xcb\xe0\xd3\xe1\x62\x8c\xfd\xe5\x27\xe9\x8f\xd2\xef\x13\x5d\xcc\xf6\x49\xd2\xe0\x49\x9b\x98\xc4\x41\x44\x6a\xc1\xe0\x9d\xcc\x8e\x31\xe0\xec\x98\xa7\x26\x0e\x3a\xb3\x5d\xfa\x81\xfc\x3e\xb9\x16\x7f\x7a\x16\xae\x85\x2d\xf1\x99\x5c\xf8\xa0\x24\x7a\x59\xf0\x75\xe2\x78\xe2\xb3\x9b\xee\x4a\xe6\x31\x50\x4f\x74\x40\xce\x01\xac\x8e\xd7\x07\x68\xbf\x9f\x61\xcc\x1c\xa5\xd1\x60\xd1\xa8\x83\xb3\x91\x39\xb9\xb4\x2e\xa4\xeb\x14\x03\x58\x08\x60\x21\x36\xd4\x1a\xea\x08\x1d\x0c\x9d\x0c\x41\x73\x15\x0a\xd9\x59\x97\xcd\x66\xf7\x9b\xed\xe6\x0e\xd1\x4e\x30\x14\x26\x57\x7d\x11\x6c\x26\xe6\xbb\xcc\x68\xa5\xc0\x9f\x90\x71\x17\x9b\x99\x1b\x50\x32\x1d\xbf\x65\xb4\x54\xd4\x0d\x77\x20\x9a\x86\xcd\x15\xe6\xfb\x3b\x57\xfd\x9a\xa9\xda\x77\xcb\x13\x8f\xab\x95\xee\xe8\x8a\x15\x91\x53\x3d\x2d\xd4\x7d\x6f\xc9\x16\x6a\xef\xed\xd6\xea\x14\xcf\x84\xea\x7d\x36\x82\x3a\x79\x90\x3d\xc2\x49\xc5\x1e\x39\x64\x7b\x64\x7b\xc8\xe1\x26\xd2\xd5\x8c\xf0\xe7\xbf\x43\xdc\x07\xea\x08\xb4\x5f\x2f\x26\xfd\xc9\x03\x60\x4f\x4f\x7f\x82\x6d\xea\xfa\x42\xd5\xa2\xe6\xe0\xcf\xfc\x05\xfd\x8c\x26\x81\x6b\xe0\xef\x44\xf5\x91\x21\xf8\x4b\xaf\x8f\xfa\x31\x6d\x46\x7d\x24\xe8\xfa\x4a\x6a\x52\xcd\xa6\x06\x40\xcc\x36\x22\x9e\x8b\xab\xa0\x1b\xb0\x18\x79\x9a\x61\xd4\x2a\x5e\x65\xb7\xf1\x46\x5a\xad\x55\xb7\x8b\x26\x2d\x61\x91\x49\x2e\x48\x06\x3a\x16\x92\xc3\x95\xaa\xdd\x8c\xb2\xdd\x58\xef\x7b\x6e\x19\xab\x85\x09\x25\x63\x91\x54\xac\xf4\x4d\x10\x31\xe8\xde\x76\x36\x71\xde\x70\xea\xc5\x63\x7a\x7c\xb5\xfe\x81\x17\xc0\xd7\x2f\x1c\xd1\xe3\xcb\x65\xd6\x05\x20\x35\x82\x87\x15\x92\x94\x06\xe7\xc5\x5d\xe4\x6c\xf9\xeb\x66\x47\xc3\x65\x7c\x2e\xf0\x9c\x7d\x09\x6d\xfa\x5f\x65\x9e\x05\xd4\xb5\x57\xe8\x24\x49\x03\x66\xb5\x58\x04\x41\xaf\x33\xe8\x7c\x5e\xcc\x0a\x9f\x17\x63\x34\xa8\xaa\x82\x65\x93\x65\x15\x1a\xa1\x43\x4c\x17\x56\xa4\xaf\xb8\x0a\x2f\x4f\x8e\x75\x77\x42\x75\x1b\x8f\x64\x05\x03\xd2\x0b\x3d\x48\xd2\x91\xe2\x83\xdb\x91\xb9\x78\x45\x7a\x3c\xf1\x02\x3c\x18\xb7\x1b\x88\x1f\x2b\x46\x18\x22\xf7\x8d\x59\x37\x63\xd2\xc0\xa7\x0e\xac\xd8\x88\x7f\x77\xec\xe1\x57\x5f\x48\x12\xbf\xec\xf8\x4a\x43\x27\x1e\x40\x96\x62\xd1\xb2\xcb\x39\x69\x52\x7e\x0a\xbd\x47\x7e\x0a\xca\x38\x55\x6a\xa4\x4e\xca\x33\x56\xad\xd8\xd8\x78\x21\x8c\x22\x4c\x18\x4d\xe8\x68\x1d\xa9\x21\x29\xca\x64\xb2\x69\x04\x93\x4c\x16\x60\xc0\x3a\x44\x03\x61\xd1\x38\x39\x9d\x4a\x87\x58\x6b\x3a\x14\x37\x9e\x8a\x1a\x72\x93\x45\x19\x99\xdd\xa5\xe9\x7b\x73\x1d\x50\xc3\xb8\x81\x08\x9a\x2b\xb0\xd4\x3e\xc1\xdd\xc3\xef\x2a\xfd\xd7\x9d\xb8\xf7\xc2\xa5\xf3\x7f\x1e\xeb\x7e\x1e\x2c\x9c\x76\x94\x26\x73\xe9\x53\x2f\xbd\xbe\x7d\x4c\x25\xb4\x87\x6f\x25\xce\x7c\x43\x76\x5e\x2c\x86\x5b\x96\x70\xe1\x34\x3e\x4b\x61\xc7\x70\x49\x04\x78\xf8\x72\x9e\x19\xa8\x6f\x37\x41\xbb\xb8\x59\xe6\x42\xb8\x21\x3e\xc4\x17\xc6\xa3\x44\xc4\xa6\xb7\xdb\x75\x5e\xd2\xe3\xa1\x28\x1d\x6d\x12\x38\x86\x33\xe9\x22\x51\x2a\xcc\x86\xd9\xec\xac\xb0\xcf\x63\x57\x7c\x03\xa9\xa7\x09\x9b\x37\x62\xd2\x30\x01\x27\x4f\x44\x75\x14\xcb\xb0\x70\x0f\x71\x46\x26\x08\x48\xc7\x7a\xa9\xbc\x74\x2c\x76\xa5\x72\xb7\x54\x2e\x2d\x25\x75\x58\xee\x6e\x4b\x5a\x3f\x54\x46\x05\x08\x59\xf6\x94\xca\x2a\xbe\x43\x0b\x54\x17\x19\xe9\xd6\x2f\xc7\x8d\xba\x85\x49\x3c\xcb\xec\x1b\x39\x40\x8a\x49\x57\x33\x4b\xf0\xa1\x3f\xdf\xc4\x80\x6d\xcc\x72\x30\x62\xd2\x66\x06\x2f\x66\x76\x4e\xc0\x89\xe9\x0c\xd8\xce\x6c\x90\xa6\x83\x68\x43\x03\xbe\xbc\x8f\xe4\x97\x6d\xc1\xc7\xa5\x89\x0d\x0d\x4e\xfc\x7b\xb0\x4e\x66\x48\xf8\x0f\x6e\x91\xbf\xfe\x80\xeb\xd1\x57\x69\x41\xc2\x81\xa5\x39\xce\x3e\x80\x78\x38\x0f\x9b\x12\x2f\xa5\x73\x72\xa2\x6c\xc8\xcd\x12\x16\x4b\x28\x54\x40\xe4\x47\x4d\xac\x09\xca\x9c\x6f\x02\x26\x93\x1f\xc3\xdc\x40\x4b\xb8\xdd\x7e\x3f\xf4\x1d\x7e\x12\x83\x91\x30\x0c\x2a\x65\xd8\xd1\xad\xd3\x4a\xaf\x61\x61\xba\xe7\x36\xed\x34\xb9\xca\xf4\xa5\x57\x12\x85\x21\x4d\x2e\x84\x0a\x9e\x22\xf4\x44\x16\x30\xc5\x85\x29\x0f\xad\x22\xc1\x90\xb6\x67\x87\x64\x8f\xd6\xb9\x97\xc6\xf6\xec\x9d\x75\xd5\xf5\xdc\x4d\x2b\xd6\xb5\xb6\xe5\xcf\xf3\x0d\x18\x5d\x3c\xef\xc6\xa1\x2f\x7c\xf4\xd4\x83\x5b\xf6\x48\x7f\xe2\xed\x3c\xc8\x7b\xdc\xea\xbb\x7b\xfb\xbc\x75\x6a\xcd\x34\xad\xfa\xae\xdd\x23\xc6\xf9\x2c\x87\x01\xef\x64\x7f\xb7\xed\xb6\x07\x1d\xa6\x03\x2b\x5f\x78\x17\xca\xfa\x5d\x92\xcb\xc5\x89\xad\x88\x0f\xd6\x09\x56\xab\xde\xa4\x67\xb5\x36\x8d\xc6\x6e\x27\x70\x16\x77\xbb\x8c\x36\xb0\x58\x7b\x83\x32\x2c\x95\xf0\x0a\x80\x11\x80\x81\xd4\x09\x5a\x1b\x89\xb1\x7a\x85\xee\x85\xa1\x08\xbb\xd5\x24\x73\xbd\xf0\x3d\xb8\x5e\x92\x1a\x01\x37\x1f\x51\x0e\xc9\xb4\x43\xbd\x0e\x76\xca\x01\x74\xf3\xbf\x28\x29\xe1\x74\xe0\xac\x16\xd4\x8c\xf1\x38\xba\xd6\x5c\xc9\x9c\xba\x15\x5f\xa0\x85\x1e\x6f\x2d\xf3\xc0\x8b\xf7\xe8\x13\xab\xf5\xa7\xf6\x24\xb6\x19\x8e\xea\x53\x0e\xee\xd2\x05\x42\x1d\xeb\xbe\xa1\x26\xc6\x5c\xfa\xb9\xd5\x31\x54\xc1\x48\x8a\xdd\xe6\x52\x76\x5b\x93\x00\xdf\xc9\xb8\x0a\x62\x60\x68\x93\x57\x47\xc0\xbd\x11\x1f\x66\xc8\xe0\x4f\x50\x78\x6e\x10\x07\x11\x66\xc7\xa6\xc6\x4b\xcc\x36\xce\x2e\xf0\x3c\xc3\xd1\x76\xbd\x1e\xd5\x1a\x71\x94\xd3\x61\x33\xdb\x69\x33\xad\x21\x38\x46\xaf\xd2\x40\xd3\x6c\xd4\x10\xbc\x92\x20\x17\x08\x2e\xa3\x14\x36\xcd\x15\x52\xd9\xf3\xaa\x26\xb5\x06\xa6\x4c\x2f\xd8\x53\xeb\xe1\x67\x40\x0d\xde\x78\x80\x4e\x2c\x95\x93\x1f\xf8\x12\xe6\xa8\x88\x17\x2d\x64\xc0\x69\xe6\x26\xc9\x09\xf6\xce\xa3\xa5\x55\xd2\xbd\x43\xa6\xa4\xd2\x1f\x50\x93\x09\x90\x90\xbf\x0e\x4d\xc4\x9d\x0d\xf8\x82\x7e\x50\x16\x88\x09\xa9\x53\x50\x16\x37\x36\x31\x1e\x75\xd8\xed\x7a\x9a\x26\x04\x94\xc5\x31\x99\xbc\x84\x87\x93\xc1\x8d\x85\x4b\x9a\x30\x3b\x32\x61\xa8\x7e\xdb\x79\x5a\xf4\x92\x20\xa5\xd2\x13\x33\x51\x60\xb7\x15\x4b\x65\xad\x62\x29\x8e\xbf\x5e\xa0\x2f\xe9\xce\x11\x24\x14\x7b\xa1\x3c\x42\xc9\xe1\xac\x61\x4e\x3d\xdf\x85\x50\x20\xdf\x0b\xd5\x39\x2e\xde\xe4\x1c\x8a\x48\x7e\x92\xa0\x4f\xd9\xcb\xde\x7c\x4c\x3d\x78\xb2\x7a\xf3\x15\x65\x7e\x9f\x18\x71\x39\x4f\x50\xef\x9c\x57\x6f\xfe\x1d\x88\x93\x64\x7f\x0e\xd7\xce\x85\x35\xc6\x39\x33\xe9\x72\xb9\x3d\x2a\xbd\xde\x43\x53\x4e\x27\x60\x59\x3b\x5c\xa6\x38\x2b\xf2\x3c\x6b\xd6\xab\x48\x17\x70\x41\x83\x08\x88\xcc\xd4\x57\xb2\x79\x21\x96\xc1\x47\xa5\xf4\xa6\xa2\xfd\x55\x4c\x9d\x92\x1a\x4a\xc5\x62\x60\x13\x83\x4f\x65\xee\x06\x3c\x38\xbd\x83\x01\x4f\x33\x87\x12\xef\x5e\x7f\xf4\xce\x89\x55\x73\x6d\xc1\x81\x1e\x43\xa5\x77\xcb\x3e\x69\x05\x02\x7a\x8e\xc4\x62\x7c\x0b\x5c\x26\xd7\xa5\xb7\xce\x9d\x1c\xee\x34\x01\x61\x89\xe0\x78\x99\x58\x8f\x11\xd8\x20\x28\xf3\xbe\x34\x47\xd0\xf6\x78\x1f\xad\x35\x9b\x22\x93\x2c\x41\x8c\x41\x66\x09\xc2\xc2\xe1\x42\x2b\x51\x54\x4c\x31\x1c\xd3\x2e\x66\x73\xa4\xc1\x61\x40\x5c\x41\x5c\x5c\xcb\xd4\xa3\x00\x15\xb7\x11\x32\x5f\x90\x1d\xbe\xe7\x1c\x9c\x23\xdf\xfd\xbf\x50\x05\xc9\x01\x69\x4f\xb6\x20\x85\x27\x29\xcd\x14\xa4\xcc\x9d\x90\x0b\x10\x4b\xca\xc3\x32\x51\x10\x62\x2f\xfe\x2d\xae\x20\xea\x9a\xf5\x0b\xea\x57\xae\xd9\x79\xe4\xe2\xdf\x6f\x9c\x3f\x64\x15\x7c\x01\x72\xe6\x2b\x7c\x41\xc7\x10\x5f\xd0\x0a\xe6\x01\xd3\xfc\x24\x5f\xd0\x31\xc4\x17\x74\x03\xfd\x20\xfe\x16\x62\x0b\x7a\xab\x13\x71\x05\xbd\x95\x38\x72\x65\xb2\xa0\xcb\xb9\x82\x20\x1e\x6b\x94\xf1\x98\x05\x6b\x89\x67\x03\x9e\x31\xf0\x06\x33\x3c\x2f\x2a\xca\x4c\x09\x56\xb3\x41\x39\xea\x2c\x3c\xea\xca\x55\x18\xdd\x21\x12\x1c\x90\x6b\x2f\x7f\x13\x8c\xc5\xd2\x97\x47\xbd\xa0\x18\x15\x68\x2f\xb8\x38\xee\x4a\x40\xec\xed\x24\x0c\x5b\x26\x5b\xb5\x9d\xe4\x1c\xf9\xeb\x26\xc5\x4f\x61\x4f\xc1\x3d\x2e\x82\x7b\xec\xc7\x26\xc5\x0b\xcd\x56\xab\x41\xef\x54\x51\x94\xcb\x85\xf9\xf5\xfe\x40\xd0\x69\xd7\xda\x3b\x45\x95\x56\xcb\x12\x7e\x97\xd9\xc0\xc2\xad\xf5\xb0\x97\xf3\x18\x5d\x89\xc6\xa8\x77\x3c\x97\x34\x4c\x4a\x81\x7e\xcf\x42\xb6\xe4\x3b\xf2\x1e\xa5\x68\xa8\x7e\xc0\x23\xc3\xa4\x55\x4c\xf9\x66\x1a\x6f\xa5\xef\xa8\x30\xcc\x14\x17\xae\x9a\x0b\x8d\xd6\x1a\xc3\x49\xf9\xc6\x0e\xec\x17\x22\xa0\xb5\x64\x3c\xe8\x2b\x47\x24\x2f\x8e\x8f\x4d\x9f\xe4\xc1\xe7\x28\xb4\x4d\xf2\xda\x63\x98\xb6\x54\xf6\x47\x93\xa1\xcd\xe5\x0d\x3c\x8c\xb6\x28\x8b\x15\xb3\x3a\xe5\x1d\x70\x52\x6e\x97\x33\xbd\x07\x36\xb4\x09\x34\xda\x80\x9e\x62\xf5\xa4\x68\xba\x12\x2c\xee\x29\x58\xcf\xfd\x48\x7e\x55\x9f\x3c\xca\xfc\x78\x77\xc6\xae\xbc\xf2\x7c\xea\xd5\x4b\xc9\xfd\x99\xd2\x1d\x5c\x5d\xdc\x4d\xce\xca\xfc\x9a\xd4\x23\x59\x16\x37\x36\x27\x5e\x01\x5c\x2e\xa7\x99\xe7\x0d\x0c\x43\x59\x2c\xd6\xb4\x38\x5e\xcf\x95\xc4\x71\x25\xc5\x01\xdd\x15\xbd\xbf\x2e\x91\x29\x23\xff\xfc\xab\x4a\xd6\x8d\xfb\xff\xd3\x5e\xf0\xd3\xad\xbf\x29\x56\x5a\xed\x7a\xa2\xff\xee\x28\x20\x59\x9f\x71\x38\x89\xf9\xc7\xc4\x0b\xad\x7a\x9d\x4e\x10\x30\x8b\xd3\x68\xb4\xa8\x08\xaf\x4f\x0f\x31\xbf\x5e\xaf\x36\x9b\x21\xcc\x97\xbb\x00\x38\x35\x02\xc3\x2a\xb5\x1a\xc2\x63\x75\xca\x6c\xa4\xd2\x0a\x69\xcc\x2f\xf4\x2c\xa5\x4e\x22\xa0\x2b\x66\x0e\x20\xe2\xbf\xe6\xbe\xb2\x35\x81\xa6\x31\x83\x88\x8b\x86\xbf\x8d\xee\x48\x26\x0b\x12\xef\x31\x27\xc1\xc6\x49\x35\x4f\x1d\xd8\xb6\x89\xfc\x33\xa3\x86\x21\x5f\xef\xe4\xc0\xd5\xa8\x9c\x14\x23\x10\x8f\x9f\xfa\x07\x99\xb7\xcf\x05\x51\xff\xec\x78\x45\xc0\x62\x71\xea\x29\x15\xa6\xd2\xbb\x4d\x2c\xeb\xf1\xb8\x9c\x7a\x67\x34\x62\x72\x77\x88\x26\x13\x63\xb7\x7b\x3a\x44\x0a\x73\xda\xa1\xe1\x23\xec\x1c\xab\x57\xb9\x18\x64\xeb\x99\x1e\xb6\x5e\x7e\xf1\x2b\x51\x4c\xac\xbb\x0a\x3b\x43\xef\xc2\xbd\x32\x23\xce\xb4\x80\xaa\x79\xca\xa1\x42\x5e\x7f\x35\x73\xea\xe7\x5d\x0c\x7e\x8a\xf9\xdb\xe8\xd1\xbf\x00\x52\x3a\x2f\xdd\x97\xf8\x3b\xfc\xd6\x53\xed\x7d\x9e\x39\xb8\x63\x53\x86\x26\x3a\x33\x92\x21\xe4\x52\x14\xf0\x6f\xff\x1d\x92\x58\x89\xd3\xee\x92\x79\x36\xed\x58\x53\x3c\x8b\x32\x91\x24\xc7\xb1\x46\xab\x56\x6b\x74\x3a\x28\x13\x94\x8e\x02\x0c\x83\x0a\x0f\x8d\x10\xd4\x71\x24\x0b\x20\xd0\x05\xdd\x36\xfe\xb2\x0b\xc3\xd4\x46\x99\x7f\x55\x84\x57\x95\x47\xee\x48\x3d\xf2\x7b\xf2\x23\xd7\xa0\x47\x4e\x67\x2a\x7a\x3d\x28\x80\x3e\xf8\x73\xf2\x22\xd5\x24\xf7\x55\x15\x7b\x78\x9d\x59\x10\x08\x1d\xe1\x0f\x58\xcd\x1d\x62\xa1\x15\xd0\x56\xa0\x27\xac\x56\x4c\xad\x46\x97\x99\x7a\xc0\x10\x48\xd3\x3c\x1e\x0c\x25\xfe\xd2\x37\x02\x85\xe9\xd4\x68\x8f\xb4\x5f\xf2\x36\xbf\x24\xe3\x92\xa0\x10\x24\xb3\xd1\x58\x85\x1f\xfe\x97\x2e\x6d\xc2\xef\x42\x49\xe8\x57\xa4\xf5\x3f\xdd\x7f\x7f\x47\xd9\xc8\xf2\xe5\x23\xff\x0c\xb2\x73\x24\x8f\x19\xbc\x4b\x9c\x3c\x76\x60\xe1\xa0\x51\x7d\x5f\xa6\x9a\x94\xfc\xf3\xa6\x97\xa3\x3c\x4a\x40\x97\x83\xac\xc4\xbc\xba\xbf\xbe\xd7\xf6\x10\x28\x2f\x47\x6b\xfe\x4d\xd7\xe7\x9a\x4a\x28\x8b\x17\xcb\xc7\x16\xc6\xfb\xfb\x5c\x51\x9e\x22\x55\x66\x8e\x53\xab\x19\x9a\x26\x5d\x44\x61\x81\x2d\x08\x8f\x3e\x89\x2a\x2c\x68\x33\x94\xcc\x6c\x36\xea\x94\x6a\x65\x23\xa1\xa6\x75\x10\x8f\xe9\x38\x2c\x27\xf3\xda\xb6\x47\x95\xa1\x32\xa6\xa6\xba\x47\x0a\xb8\xbb\xf1\x23\x50\x00\xca\x2a\x7a\xa5\x96\xca\x51\xa2\x53\xe9\x29\x33\xf7\xe8\xac\xa1\x1a\x0e\x7c\xb7\x9e\x92\x2e\x4d\xea\xa1\x76\x63\x00\x88\xbe\x00\x0a\x9e\x38\xf0\xfd\x0d\xe7\xa4\x93\x7f\x5b\xbf\x72\xf1\xb9\x65\x6b\x97\x2f\x3e\xb7\x92\xdf\xf0\xf3\xc1\xf9\x3d\x13\x4c\x8f\x01\xeb\x8e\x8d\xbf\x28\xfc\x9e\xed\xcf\xbc\xf9\xa2\x74\xe3\xd9\x67\x5f\x7f\x06\x2c\x53\xea\x0a\x9f\x83\x36\xe3\x34\xd4\x3f\x1e\x5a\xc4\x99\xf1\x72\x88\xa1\x28\x07\xc3\x98\x75\x94\x85\x24\xad\xbc\xd5\xac\xd6\x99\x75\x5e\x8f\x1e\xda\x7b\xaa\x43\xb4\x58\x4c\x6a\x13\xb4\x22\x26\x73\xbb\x68\x22\x78\x52\x87\x0c\x08\xae\xce\x40\xd5\xb9\x97\xb7\x86\xc6\x32\x28\x54\x52\x97\x2b\x61\x05\x7e\xca\x81\x25\xc4\x17\xa1\x6c\x60\x04\x7a\x19\x70\x20\xb1\xc9\xb7\x51\xad\xc9\xed\x23\x6f\x91\xae\x47\xd1\x24\xb8\xee\x35\x90\x0f\x26\xe0\x55\x50\xfc\x73\x1d\xc3\x9e\x39\x72\xeb\xba\x06\x14\x3a\x7e\x90\x78\x12\x46\x8e\x96\x8e\x77\x5f\x7d\x02\xc5\xd6\x78\x13\xee\xdd\xb6\x73\xe5\xea\x14\x97\xdb\x7f\x88\xd7\x89\xe7\x20\x7e\xa8\x95\xeb\x1d\x4a\xa0\xfe\xd6\x50\x8f\x61\x34\x96\x83\x78\x23\xdc\x2a\x15\x63\xc1\x42\x4c\x28\x37\x2f\x4b\xdb\x22\x66\x59\x59\xbb\xc5\xef\xc6\xfd\x78\x8b\xe8\x67\x2d\x20\x69\xe1\x65\xf4\x54\xdd\xc3\x64\x24\xc9\xe8\x53\x45\x0d\x14\x8b\x85\x2b\xe4\xf9\x71\xb8\x1a\xfe\x1f\x4b\xdf\xba\x05\x03\x38\x7e\x2a\x5d\xd6\x90\x58\x0b\x4f\x60\xee\xb5\xb3\xe7\xb0\x75\xf6\xf1\x07\x77\x9f\xde\xd3\xe2\x50\x97\x3e\xbe\xe8\xde\x57\xae\xff\x6a\xef\xfd\x6f\xe0\x0b\xd3\x55\x0d\x1c\xd8\x05\xde\x08\xd1\x9a\x48\x78\xe9\xba\x7a\x8e\xaf\xdd\x70\xeb\xa4\xf9\x6f\x3e\x74\x44\xfa\x7a\x2f\x3c\xf3\xa8\xae\x00\xf5\x11\xcf\x27\xce\xc3\x90\x0e\xd5\x3a\x8d\x8d\x17\xb0\x8c\xcf\x63\x36\xab\xec\x18\x16\x64\x54\x4c\x76\x0e\xeb\xf3\xf8\x3c\xcd\xa2\xd1\xe7\xf5\xe1\x34\xe1\xf3\xe9\x08\x5d\xa4\x59\xd4\xb1\x84\xb5\x45\x29\xf5\xee\x4d\x0d\x84\x55\xf6\x74\x5c\x8a\x90\xbc\x2a\xcd\xe4\x96\x0c\x74\xa9\x74\x03\xaf\x4a\xad\xaa\x48\x45\xc3\x44\xcd\x5f\x9f\x7a\xe2\xa5\x9b\x7f\xd9\xbe\xf3\xce\x1d\xeb\xe6\x5f\x9b\xf8\x67\xf3\xa0\x9a\xda\xf6\xe6\x48\x7f\x35\xbf\xe3\x70\x91\x6f\xd8\x06\xa0\xbd\x61\xef\xf3\x67\x8f\x03\xf3\x6d\xb3\x45\x71\x47\x8e\xe3\x5a\xed\xb2\x0d\xe2\xc8\x96\x19\x1a\x15\x95\xb3\x92\x5d\x33\xbb\xa0\xfa\x3d\x84\x9b\x4c\x5d\x9f\xe3\xe7\x89\x73\x58\x00\x1b\x1a\x0f\xbb\x55\x26\x81\x46\x23\xef\x43\x3c\xe1\x33\x60\x2e\x60\x24\x5c\x2e\x9f\xcf\xd1\x2a\xfa\x58\xbd\xde\x60\xd0\xb6\x8a\x06\x6b\xda\xa6\x64\x46\xf4\x95\x3d\xca\x53\x52\x23\xf7\x95\x71\x0e\xca\x75\x5e\xea\xc9\xd1\x85\x3d\x1a\x6b\x79\x7e\xe3\xe6\x8e\xea\xda\xbe\xf3\x97\xe4\xef\xfa\xc7\xda\xdd\x6b\x8f\xd5\x0e\xea\x5f\x32\x7a\x46\x51\xfc\xfe\xc9\x6b\x6f\xc6\xff\x31\x73\x63\x2c\x38\xb2\xad\xb6\x79\x6c\xdf\x7d\x9b\xe6\xcd\x58\x33\xc0\x3e\xbe\xa9\xb2\xa6\xb9\xef\xe0\xc6\x05\x50\xa7\x82\x70\x2f\x2e\x50\x5b\x21\x2e\xca\xc6\xfa\xc6\x3d\x2e\x9d\x8d\x08\x06\x4d\x36\x53\x4e\xae\xc5\xdb\x22\x5a\xac\x8c\xba\x45\x64\x30\x2c\x82\xae\x71\x8d\x3d\x9a\xec\x7a\x1a\xbd\x12\xab\x80\x0a\xe6\x92\x4f\x84\xda\x33\xc8\xe4\xe2\x13\x8a\x11\x28\x53\xfa\xa5\xf1\x60\x74\x82\x83\x1e\xbb\x59\xac\x1a\x60\xb6\x2f\x0d\xdd\xf7\xd3\x0d\x9b\xa4\xae\x7b\x7f\xff\xcc\xfa\x2f\x66\xd4\xf7\x6b\x58\x59\xdf\x50\x33\xe8\xba\x06\xe2\xb8\x60\xb9\xe6\xe9\xb9\xe6\x0e\xad\xe9\x98\x74\xe6\xd3\x37\xa5\x33\x27\xff\xf2\xf0\x01\xa0\xda\x9e\x58\x32\x6d\xce\x6e\xac\xeb\xe6\xc9\xf3\xf6\x24\x94\x33\x52\x04\x9f\xbf\x43\xe6\x84\xa9\x97\x71\x5e\x57\xd7\xe7\xea\xc5\x50\xb7\x06\x62\x2f\xc5\xaf\x8d\x31\x98\xde\x54\xc8\xb2\x45\x45\x86\x12\xa3\xb1\xd8\xcf\xe5\xe5\x15\xeb\x89\x3e\x51\x41\xa8\x19\xa4\xea\xd3\xa7\xa6\x7c\x40\x8b\x58\x59\x59\x6e\x2d\xb6\x14\x95\x14\x9a\x0a\x9b\x45\x43\xa1\xa9\xc5\xd4\x6e\xda\x66\x3a\x60\x3a\x61\x52\x19\x4d\x5e\xf9\xed\x7c\xf9\xed\x57\x26\x0d\x4d\x98\x4c\x96\xec\x48\x28\x9e\x1d\x6a\x15\xb3\xad\x16\x77\x8b\x68\xb7\x5b\x58\xd6\x68\x34\x62\x14\x30\x10\x14\x11\xd7\x10\xad\xa2\x46\x2e\xc2\x70\xd8\xd8\xd7\xe0\x86\x56\x57\xa7\xae\x39\xe4\x4f\x7a\xa4\xac\xe1\xc6\xcb\x51\x5c\x4f\xbe\xb4\x58\x66\x7f\xb6\x4c\x37\x04\x94\xcd\x4e\x75\x63\x9b\x63\x44\x4c\x29\xb5\x54\x6a\xf1\x7b\xa9\x47\x05\x62\x4f\x08\x66\x5e\xc2\x0d\x00\xe0\xd5\x81\xb1\xd1\x0b\xf2\x6e\x39\xb6\xe1\x06\xd5\xc1\xfa\x1f\xea\x0f\xe4\x7f\xba\x73\xc5\x75\x39\xb5\x82\xa1\xc2\xdd\x67\xde\xc0\x78\xa9\xfc\xcd\x8d\xd7\x53\x77\x0e\xf9\xef\x90\x3b\xf2\x3e\xda\x93\xf1\x4d\x7c\xe2\xbc\x55\x93\xaa\xf7\x1f\x7b\x38\x50\x03\x8e\x49\x63\xfe\xfc\x55\xbe\x24\xed\x71\xd8\x6e\xfa\xea\x56\xf9\xf3\xfb\x1e\xcc\xab\x90\x46\x80\xdf\xbf\xf6\x5d\x3e\xc0\xd1\xe7\x88\x07\xa5\xeb\x4f\xf0\x2c\xfc\x08\xf7\x21\x0b\x9b\x11\xaf\xe0\xb2\xb4\x61\x23\x41\x08\xe1\x70\x76\x8e\x47\xab\xcd\xce\x32\x73\x66\xae\x05\xba\x25\x97\x19\xa7\xe1\xc1\x0f\x18\x3d\xd0\xdb\x7a\x3c\x81\x80\xa3\x45\x0c\xb0\xa8\x9c\x45\xa7\x53\x59\xd3\x17\x44\x99\xe9\xae\xcb\x38\xe6\xd2\x69\x0e\xa5\x55\x3f\x98\x2c\x6b\x81\xa7\x3c\x17\xda\xb4\x92\x74\x4d\x71\x45\x3a\xe1\x85\x0b\x4d\x13\x3e\x3d\xdf\xfa\x50\x3c\x6b\xf5\x75\xed\xd3\x76\xcc\x33\xcf\x1f\x3b\x65\xe0\xe0\xa6\xda\xbe\x8d\x39\x33\xaf\xea\x7b\xfa\xf4\x35\xd3\xc1\x47\xec\xb4\xa1\xb7\x1c\x2e\x2f\x68\xad\x6a\x17\x77\x4d\x9f\x3c\xb9\x5f\x7d\xe9\xf4\x8f\x78\xfd\xb5\xb3\xa6\xaf\xe5\x65\xbd\x6b\xec\xfa\x17\xe2\x97\x82\x7a\x37\xb6\xfb\x3d\xf5\x1c\x1b\x41\xef\x51\x1e\x08\x7b\x3d\xc9\x5d\xe0\x37\x45\xc0\x35\x21\x8f\x45\x9d\x99\x9b\xc7\x72\xba\xba\xc8\x3e\x72\x0f\xde\xe4\x78\xb1\x86\x20\x70\x6d\x8a\xda\x4b\x4d\x92\x26\x5c\x8f\xf3\x16\xa3\xd1\x84\xd3\x06\xba\x59\xd4\x10\x30\xd6\x62\x49\xb3\xe1\x8a\x34\x5f\xa9\xe2\x97\x1e\x54\x55\x3d\xfc\xd5\x95\xd8\xbe\xa2\x15\x64\x1f\xfd\x24\xe9\xfd\x5f\x46\x33\xd2\x93\xcf\x2f\x2f\x4d\xf3\x7d\x6d\x9e\x41\x13\xc7\xab\x39\xe9\x3b\xc9\x6c\x6f\x00\xb7\x5f\x2d\xbd\x95\x64\xfc\xda\x6a\x42\xbc\x5a\x8f\xc1\xf3\xf6\x36\xf1\x2c\xb4\xdc\x75\xf1\xb0\xca\x6a\x65\x9c\x5e\x0c\x73\x39\x9d\x7e\xc6\xe7\x75\x35\x8b\x5e\x8b\x1d\x6f\x16\xed\xac\x8e\x6b\x15\xe7\x1b\x80\xc1\xa0\xb3\x2a\xc4\x79\x69\xb3\xd1\x33\xb7\xa3\xf4\x74\xa1\xee\x34\xa5\x09\x47\x69\x54\x86\xce\x48\xd1\x6f\xd4\x8b\xf1\x24\x9f\x1d\x17\x6b\x73\xdb\xca\x67\x8c\x91\x4b\x57\xb4\x5a\xc1\x16\x6b\x2a\xec\x77\xef\x9e\x15\x7f\xdc\xd5\xc1\x48\x37\x13\x93\xf4\xe5\xcb\xb6\x48\x3f\x9c\xdc\x84\x2a\x56\x3c\x93\x3e\xb8\xfb\x95\xe3\xce\x4b\x0f\xd8\xd0\xcc\x7b\xf4\xbc\x54\x1f\x99\x87\x65\x72\x3c\x66\x77\x38\xdc\x5a\x8d\xc6\xed\x66\x49\x12\x50\x5e\xe4\x8e\xfc\xac\x8f\xd2\x68\x1c\x2e\x07\x7c\x76\x97\xd1\x03\xd1\x13\x63\x6d\x45\xb0\xdc\x4a\x82\x66\x91\xb4\xf4\x60\x10\x4a\x01\x71\x53\x32\x45\x25\x64\x14\x56\x29\x21\x12\x7a\x62\x54\x95\xa3\xc6\xd3\xf2\x24\x7b\x30\xe4\xca\x1d\xaa\xcf\x2e\x91\x91\x8e\xde\x20\x55\x36\x5d\x9d\x57\x35\xbc\xbd\x5e\x29\xc6\xa1\xf4\xfa\x88\x58\x55\xb3\x94\x06\xb3\xc7\x81\x25\xc4\xf1\x4b\xf7\xdb\x6a\xf0\x2f\x2f\x49\x04\x79\x4e\xfa\xf9\xc3\x49\x4a\x21\xce\x57\xdf\x02\xb5\x7d\x60\x62\x0b\xbe\x18\xe9\x0f\x04\x81\x24\xea\xa5\x37\x62\xd3\xe3\x95\x58\x52\x75\x80\x46\xad\xc6\x71\x92\xd0\x13\x26\x56\x8b\xb5\x88\xc3\xb4\x13\xb5\x73\xb5\x04\xad\x75\x69\xa1\x1f\xd5\x6a\x55\x46\xc4\x18\x47\x18\x2d\x3a\x95\x8a\x6c\x16\x55\xc6\x2b\xd4\x59\x4c\xbc\x42\x74\xa1\x1c\x2f\x7f\x52\x77\xfc\xc9\x26\x99\xe7\xa5\xe7\x86\x4a\x3f\xec\x5c\x40\x83\xb5\x0d\xa0\xaa\x01\xe8\xe1\x4b\x69\x35\xb8\x5b\x1a\x2f\x6b\x4c\x27\x38\x80\xe4\xe8\xcd\xdb\x85\x38\x67\xe1\xb3\x1b\xe5\xf7\x6d\x72\xde\x6c\x9e\xd4\x44\x3c\x23\xbf\x97\xf3\x68\x98\x47\xc1\x07\xf0\x7d\x9d\xfc\x3e\x0a\xf1\xdd\x5b\xf2\xfb\x56\xf9\xe7\x63\x52\x1d\xb1\x43\x3e\x7b\x13\x14\x3c\x21\x35\x51\x8b\xa1\x0f\x43\x3c\xe9\xd5\xd8\x8a\xf8\x20\xb6\x3c\x2b\xea\xb4\x69\xb4\xda\xfe\x55\xc5\xb9\x56\x0b\xe9\xf7\x5b\xca\x89\xf8\xc0\xea\xfe\xcd\x62\x35\x66\xa5\xfb\xc2\x45\xe8\xcb\x5a\xb8\x18\x54\xd2\x98\x35\x37\xab\x59\xcc\x75\x6a\x61\xa4\xd6\x22\x86\xad\x1a\x95\x47\xd5\x2a\x7a\xd8\x1e\xb3\x00\x7a\xe1\xe3\x6e\x54\x2c\xf3\x0c\xc5\x92\x5f\x64\x50\x28\xb3\x0b\xa0\xcb\x46\x0f\x00\xa9\x3a\xeb\x0a\x73\x04\x10\x46\x90\x81\xab\xa2\xb2\x9e\x0c\x20\x2a\xba\x11\x0a\xa2\x6c\x26\x96\x0e\x5c\xd6\xb0\x2a\x36\x60\xb5\x7d\xa0\x74\x76\xe0\x35\xf5\xcb\xfc\x65\x81\xd5\x95\xe0\xe0\x60\x5e\x93\xdf\x39\x78\xd5\xf6\x75\xef\xdf\x34\x62\x60\xbf\x79\xb4\xb4\xa5\x1f\xa1\xd6\x6a\xa9\xf9\xd3\xe4\xcf\x46\x56\x0f\x5a\x41\x37\xed\xfc\x79\xf5\x45\x4f\xa2\xca\xcc\x11\xf6\x3d\xff\x5d\xf3\x23\x6b\xc0\x2f\xf8\xf0\x2c\x69\xe5\x44\x97\xe0\x3a\xb9\xef\x51\xe9\xb5\xc3\x66\xe9\x88\x6d\x20\x18\x6a\x88\x44\x23\xc6\xbe\xf0\x23\x50\x72\xd8\x0c\xae\xb7\x0d\x44\x6b\xfa\x4f\xb8\x90\xaf\xc9\x6b\x3a\x5e\xb6\x4f\x8d\xd2\x0c\xd2\x0f\xf5\xcb\x85\x0d\x8f\xe7\x38\x30\x4c\xe0\x19\x8d\x46\x6d\xa4\x29\x0a\x06\xdb\xbc\xda\xed\xb1\x0b\x50\x81\xec\x46\x23\x6e\xc2\xdb\x44\x93\xd5\xa0\x81\xde\xd3\x42\x63\x85\x19\x6b\x15\xcb\x2c\x01\x8d\xf5\xe8\xd7\x4d\x33\xe7\x41\x6d\xca\x1c\x90\xe5\x27\x54\x60\xd2\x88\x3e\x87\xfd\x33\x81\x6e\xe7\x5c\x46\x94\x3e\x7a\xee\xf7\x9a\xdd\x7f\xbd\x6a\x01\x33\x19\x75\xd6\x4d\xb7\xbc\xdd\xb9\xb7\x15\x6f\x42\x9c\x79\xd2\x0c\x70\xdb\xb1\xa7\x17\x75\xf2\xe3\xf1\x2c\x5b\x4d\xe2\x85\x79\xf2\x73\x07\xa1\x1c\x5f\xc3\xe7\x76\x60\xc3\xe2\x51\x1b\x86\x59\x38\x8a\xd6\xeb\x55\x2a\x8d\x9a\x53\x3b\x5d\x46\xf8\xac\xb4\xd1\x28\xe8\x11\x25\xa1\x4a\x30\xea\xe1\x53\xeb\xbb\x4b\xb3\x53\xdd\xcd\x57\x48\x55\x81\x0c\xb2\x3f\x73\x7a\x8c\x91\xf2\xc0\x33\xdb\xaa\x77\x84\xcb\xe4\x07\x96\x6e\x6c\x6b\xba\x67\xce\xf4\xf9\xda\x62\xf4\xb8\x31\x2b\xf8\x71\xd2\x4d\x22\x28\x44\xcf\x0b\x5e\xbf\x6a\xf2\x9c\xb9\xc2\x60\x60\x86\x87\xe3\xdf\x57\xa3\x35\xee\xfa\x97\x6a\x1a\x7c\xd6\x6c\xac\x3d\x5e\xe4\x86\xd8\x10\x8b\x46\xc3\x5c\x24\x22\x30\x2a\xb5\x5a\xab\x11\x34\x39\xb9\x11\x17\xb2\x4c\x6a\x97\x91\x63\xf0\x00\x1f\x68\x13\x8d\xbc\x55\xa9\x23\xcc\xa8\x27\x4f\x27\x08\x32\x80\x23\x57\x99\xea\x71\x4c\x2d\xb8\xd2\xce\x88\xb8\x0a\x33\xda\x49\xcb\xbb\xdb\x1d\x65\xe9\x54\xc4\x91\xf1\xd9\x93\x3b\x34\xd3\x15\x69\xee\x70\xec\xfb\xa4\x7d\x81\x7a\xf7\x5f\xa7\x2e\x52\x36\x60\x9a\x75\xfc\xa0\x43\xdc\x34\x40\x4f\xb3\xbe\xdd\x59\x77\x7d\x0e\x5e\x23\xd3\x17\x3e\xdf\x39\xea\x91\xb9\xd3\x98\x89\x78\x3e\xda\x89\xab\xb3\x3b\x8f\x35\xe0\x83\xe0\x0b\x2c\xa5\x4b\xaa\x4e\x28\x67\x01\x36\x37\x5e\xe1\x0f\x85\x3c\xd0\x58\x69\xb1\xbc\xbc\x1c\x6b\x6e\xae\x53\x63\x50\xab\x4d\x1a\x8d\xd6\xa9\x2d\x2c\xca\xf5\x21\xd8\xaf\xf1\x19\xad\x26\x22\x6a\x8b\xb6\x89\x66\x9b\x95\xd5\x21\x7a\x46\x43\x52\xb1\xae\x28\x6f\x46\xf2\x2d\x96\x6a\x9c\x55\xa4\xb6\x76\x8b\x9d\x56\xb4\xde\x92\x5b\xd3\xa2\x1f\x8e\x16\xe6\x5d\x35\x81\x9e\xde\xad\x7a\x8e\x7d\x9f\x8e\x59\xa8\xdd\xfd\xe1\xb4\x39\x29\xf1\xa3\x85\xf1\xa3\xe6\x19\x40\x07\xe5\x2f\x2a\x1e\xbc\xaa\x48\x59\x00\xa4\x8b\x27\x9e\x1f\x3b\xe9\x91\x79\x53\xbb\x17\xa1\xa8\xf8\x68\x63\x72\x15\x70\xd4\xdb\x41\x7c\x06\xd7\x40\xc0\x42\xd8\xd4\xb8\x83\xe6\x79\xab\xd5\x17\x08\x98\xb4\x4e\x42\x4b\x84\x23\x18\x94\x7b\x0d\x76\x0b\xfc\x41\x94\x17\x77\x3a\x3d\x10\xcd\x72\x10\x80\xc2\xb8\xdd\x64\xe2\x38\xa6\x45\xe4\x8c\x2a\xc4\xaa\x95\xd1\x46\x95\x86\x44\xb9\x3d\xd9\x51\x53\xbe\x28\x55\x1d\x87\x02\x86\x64\xd1\x83\xa0\x52\x97\x9b\x93\x90\x48\x2e\xd3\xc7\x6f\xbd\xe7\xe4\xc7\xaf\x3e\x70\x61\xd1\x6d\x37\x0d\x8d\x0f\x69\x8c\xe1\x79\x86\x69\xe5\xc3\x2c\xd5\x43\xdb\x1a\x73\xab\xf8\x26\x7c\xf0\xe6\xd5\x77\x9e\x38\xb1\x6f\xe1\xd7\x27\x74\x27\x80\x2f\xfb\x8e\x7b\x75\x92\x66\xfe\x82\x49\xd3\xe8\xd6\xc9\xb3\xaf\x45\xb6\xb7\x18\xfa\xd7\x16\x28\x17\x85\x59\x60\xf4\xbd\x30\xee\x57\x09\x16\x8b\xcd\xc6\xb9\xf4\x7a\x13\x6a\x9b\xc7\x28\x13\xe5\xf1\x6a\xac\xcd\x22\xa6\x61\x35\xb8\x99\xd0\x20\x01\x1d\x50\x40\x8d\x86\x37\xf0\x1c\xf4\xb1\xbc\xd1\x00\x61\x9f\xc1\x4a\x60\xd0\x37\x65\x30\x76\xa7\xd3\x5d\x19\xf4\xaf\xa9\x8d\x4e\x17\xa3\xa1\x8c\x97\xd9\x0f\x32\xe6\x42\x2b\x24\x46\x04\xdc\xd6\xb2\x52\xf2\xcc\x32\xbd\xb4\xec\x08\x60\x2e\xb5\x54\xe5\xde\xfb\xe8\x67\xff\x12\x5f\xa8\xbd\x65\x99\x11\xac\xf7\x16\x0d\xc9\x2f\x7e\x6c\x9c\xad\x86\x38\x2e\xed\xa4\xb6\xac\xbc\xfb\x3e\xbb\x99\xe8\x0b\x0f\x66\x2d\x2e\xcd\xd4\xbc\xff\x9c\x1c\x6f\x43\xd9\x88\xe9\xb2\x8f\x15\xb0\x31\x71\x07\x66\x32\x22\x6e\x7f\xbd\x95\xd2\x53\x36\x3b\xce\x42\x91\x70\x16\x87\x22\xe1\x48\x24\x33\x14\x09\xc7\x0d\x1a\x04\xd8\x0c\x46\x0d\x2f\x53\xd9\xf6\xa8\x87\xef\xcd\x62\xab\x78\xd5\x5f\x79\x72\x70\xc7\x95\x1e\x18\x8f\x5f\xf9\x59\x41\xd7\x8b\x5d\x5f\x10\x2e\x99\x17\x78\x6e\x3c\xee\xb4\xb9\x5c\x76\x93\x5e\xef\xf5\x51\x26\x93\xd7\x09\xf5\x86\x76\xba\x9c\x10\x02\x38\x9d\x1a\xa3\xd1\xd2\x2a\x72\x59\x06\x53\x3d\x67\xb4\x1a\x49\x2f\xb9\x8d\x24\x4c\x04\x19\xd7\x31\xf5\x24\xa9\xd1\x40\x27\xa8\x61\xd3\x69\x54\x14\xbf\xc4\x72\x33\x43\xed\x14\xec\x96\xef\x98\x65\x56\x8d\x8c\x8e\x43\xd9\xb5\x55\x28\x3d\x54\x4a\xca\x0b\x5c\x97\x53\xe9\xa8\x6b\x2c\xd9\xb0\xf0\xf1\x97\x6e\xfc\xef\xa1\x07\xae\xcf\xe9\xdb\x34\x6b\xc6\x01\xa7\xf4\xb8\x19\x0c\xc0\x47\x12\x57\xb9\x1c\x07\x81\xcd\xff\xec\xd9\x27\xa5\x6f\x6f\x9e\xd7\xe8\x0c\x3e\xb8\x7b\x7a\xd5\xc6\x1b\x95\xfe\x8e\x52\xa8\x5b\xb7\xc8\x33\xc1\x42\xd8\x94\x78\x85\x8d\xf7\x18\x28\x82\x51\xd1\x34\xb2\x8e\x1a\x82\x27\x22\x61\x13\xd4\x1c\x13\xcb\xa8\xa0\x84\x8c\x8b\x81\x12\x32\x8c\x3e\xc9\x84\xa5\xb1\x60\xfe\xee\x16\xa9\xcc\x7c\xc1\x6f\xa4\xb5\x22\xfd\x01\x0c\x9f\x14\x9c\x13\x2b\xbf\x62\x0f\x08\xb1\xf4\xc8\x05\xb0\x7a\xa8\xf4\xed\xee\xf1\x10\x30\x37\xac\xc8\x07\xce\x67\x8e\x5c\xd8\xfc\xd3\xd5\x57\xf7\x5b\xd6\x50\x5b\x5e\x75\xf5\x60\xfe\x8d\x87\x6d\x42\x0a\x05\x3d\xff\xcd\x1b\x0f\x1f\x92\xbe\xfa\x1d\xbe\xfe\x9b\xfd\x52\x62\xfd\xd5\x2b\x77\x5d\x44\x39\xab\xa7\xe1\xe1\x79\x8f\x38\x07\xf1\xbf\x1b\xbb\x2a\x5e\xac\xb7\xe9\xec\x76\x15\x6d\x32\x61\x3a\x9d\x5a\xcd\x63\x0c\xa6\x62\x55\xac\xd7\x63\xd2\xdb\xf4\xcd\xa2\xcd\xa6\x23\x58\xb5\x4e\x0d\x35\x4b\x67\x21\x9c\x30\x16\x67\xb1\x4c\x66\xaf\x1e\x9c\x21\xf2\xce\x94\x64\x56\xfc\xa3\x4c\xaa\x32\x76\x57\xf6\x5e\x72\x1a\x1f\x14\x00\xe5\x82\x0c\x25\x40\xb6\x7c\xf2\x4d\xed\xbf\x9b\x6f\x1d\xaf\x95\x6e\xad\xbd\xaa\x4b\x3a\x45\x8f\x04\xa0\xae\x15\x68\xc7\x0f\x1d\x52\xdb\xe6\x1b\x37\x15\xdf\xb1\x6f\x07\x6f\xb8\xf4\xb8\xad\x06\xac\x97\x96\x0f\x14\xc0\x88\xe0\x8a\xa6\x91\x9d\x60\x91\x76\x5a\x3a\x06\xa7\xb6\x71\x11\x14\x83\x9b\x54\xd8\xa0\x29\x18\xa6\x79\x10\x8f\x9a\x50\xe5\x52\xf2\xfb\x73\x65\x6e\x3a\xe5\xfb\xb3\x96\xca\x4c\x73\x04\x1e\x30\x45\x08\x7c\x79\x71\x2e\x87\x65\x54\x1e\x02\x2c\x0b\xe2\xc1\x8f\x21\x9e\xcb\x43\x75\x24\x38\xaf\x63\x98\x9c\xa8\xcd\x62\xb7\xf3\x5c\xc0\xe7\x26\x5d\x2e\xb3\x99\x8f\xf2\x05\xf9\x16\x9f\xdb\xd7\x22\xda\xdc\x6e\x57\x88\x0b\x04\x8c\x21\x63\x9b\x88\xca\xc9\x70\x2d\x11\x62\x5d\xf6\x66\xd1\x85\xf1\x16\xb3\xcc\x9c\xa4\x50\x27\xc9\x54\x13\x0a\x1f\x56\x8a\x69\xf3\xf2\xfb\xa9\x8c\x82\xf4\x74\xb2\x2c\xcd\x9f\x94\xc9\x91\x1d\xac\x90\xef\x13\xd5\x7e\x75\xd0\x08\xba\x2b\x5f\xc1\x29\xb1\x25\x5a\x2d\x98\x9d\xa5\xc3\x2c\x8b\xac\xad\x7d\xb6\xfa\x67\x49\xff\x7d\xfa\x16\xfe\x66\x01\x69\x4b\x16\xd6\xc5\x4b\xb9\xec\xb6\x3f\x4e\x9a\x65\x5a\x12\x7c\x53\x21\x47\xba\xf1\x5a\x7c\xcd\xe2\x2c\x99\x3c\x9b\x6c\x9c\xbe\xd6\x56\xf3\xde\xf4\x9f\xdb\x9e\x9b\x37\x35\xdc\x9e\x98\xfd\xec\x4b\xf0\x1c\x40\xbc\x4c\xd4\x50\xdb\xd0\xac\x68\x6c\x62\xbc\xdc\x00\x51\x3c\x4d\xe8\xb5\x3a\x1d\xa6\xd7\x13\x9c\x99\x36\x6c\x19\xbf\x8d\x3e\x40\xe3\x46\xda\x4b\x17\xd2\x4f\xd1\x1f\xd2\x94\x86\xa0\xf5\x16\x5c\xdb\x22\x22\xea\x51\x68\x57\x71\x63\xe6\xd5\x48\x8f\xb4\x75\x77\x0c\xa3\xf4\x17\x24\x29\x5c\x82\x40\x9e\x26\xf7\xe4\xb5\x34\xfe\x97\x58\xa3\x61\xe6\xa4\xf0\xce\xaf\x40\xc5\x73\xc0\x2d\x2d\x21\x86\x43\x7c\xfa\xd1\x11\xf3\xa5\xb3\xe4\xa4\x8c\xb9\x82\x29\xdc\x8e\xf9\xb0\xf5\xf1\x31\x66\xc2\xa3\xd3\x05\x94\x9a\x5a\x7f\xc0\xcc\xa7\xc2\x7d\xc2\x6c\x46\x25\xb5\x2d\x22\x7a\xda\x76\x7a\x3e\xbd\x9a\xa6\x0a\xe9\x6a\xba\x05\x4a\x70\x82\xee\xa2\x55\x8a\x14\xf3\xe1\xdb\xd7\xa1\x24\x6a\x96\x80\xe7\x9d\x75\xbb\x31\xcc\x91\xc1\x96\x9a\xcc\xc2\x2f\x5c\xd4\x8b\x21\xbc\x67\xf5\x6d\x20\xd9\x70\x84\xaa\x6f\xa3\x3d\x5b\x75\x94\x1e\xa9\x0d\xc7\x9f\xd8\x01\xf0\xdd\xf5\xc7\xca\x8a\xeb\x0d\xe5\x13\xc6\xdd\x16\x02\x01\xb3\xf4\x11\x35\x76\x54\xe3\xf2\xca\xbc\xe1\x2f\xf2\x8f\x1d\x3e\x03\x02\x07\x9d\x9c\xf4\xd1\x7d\x55\x27\xb6\x4f\x19\x90\xb5\x60\x45\x79\x56\x75\x83\x1c\xc7\x74\xfd\xd0\xf5\x39\xfe\x81\x1c\x97\x8c\x96\xe3\x14\x44\xee\x5b\x24\xf7\xbc\x34\x61\xff\x0f\x9c\x8c\xbd\xfa\xaf\x70\x39\x76\x35\xc2\x58\x3b\x04\x91\xd3\xf4\x78\xdf\x88\xd3\xe1\x88\x46\xb1\x50\x88\xce\xcb\xf3\xf9\x8a\xe8\x42\x77\x18\xba\x20\x37\xeb\x5e\xe3\xbe\xc5\x7d\xd0\x4d\x99\x09\xb7\xdb\x16\x08\x64\xb7\x88\x01\xab\x0d\x06\xaf\x36\x56\x6b\x6a\x15\x19\x46\xdb\x9d\x48\xe9\x95\x37\x4d\xd7\x0c\xf5\xb8\x1b\xfb\xd5\x68\x5c\xd6\x72\xd6\x1f\x88\x02\xd9\x49\x21\x18\x81\xef\xe0\x7e\x25\x38\xbf\xee\x68\x3c\xab\xe0\xce\xe3\x52\xfd\x99\x3b\xc1\x2a\xef\xe0\x50\x5e\xf3\x88\x61\xc4\xcc\xcb\x02\x75\x41\xda\x45\xde\xb4\x4a\x3a\x99\x07\xde\xc2\xa5\x59\x9a\x25\xb3\xc7\xce\x90\x6d\x7f\x39\x94\x7d\x25\xf4\xbd\x16\x18\xb9\x1f\x88\x97\x62\x08\x55\x98\x75\xbc\x8d\xd7\x6a\x19\xb7\x9b\xe2\xf4\x26\x13\x4d\x1b\x18\x8a\xf1\xfb\x04\x2b\x8e\xe0\x05\xae\xd3\xa3\x76\x73\x33\x97\xe9\x95\x3d\xc8\x2b\x73\x38\xa7\xb6\xf0\x26\x56\x61\x0f\xa1\x19\x8b\xcd\xa1\x86\x7e\x43\xab\x4e\x51\x7b\xca\xf5\x73\x4a\x49\x51\xba\xd4\xe0\x0a\x73\x89\x7a\xd4\xdc\x66\xb6\x6e\xa6\x17\xc6\x9c\x19\x23\xa7\x17\x89\xb8\x90\x53\x74\xec\x21\xa9\xf4\xcc\x9d\x75\xd2\x97\x28\x64\x9e\xaf\x47\x21\xb3\xa9\x01\x18\x72\xc3\x0d\xf9\xd1\xd1\xed\x23\xf1\x81\xc9\x55\xd8\xda\x1d\x3d\x2b\xfe\x7d\xf1\x9c\xc9\x93\x90\x4d\x84\x31\x33\x23\x73\x42\xae\x8c\x0f\x02\x3a\x8f\xd3\xeb\x75\xd8\x28\x02\x23\x03\x01\xbb\xdd\xc1\x9a\xcd\x8c\xce\xa1\x0b\x05\x9d\x04\x46\xb4\x88\x1e\x0c\x0b\xa8\x03\xde\x66\x31\x80\x39\xec\xac\x42\x70\x6e\xa3\x28\x8b\xda\x02\x4d\xa4\x9a\x55\xe3\x6a\xe8\x3f\x26\x66\x12\xa6\xc4\xd2\x8a\xd1\x4b\xe0\x4c\x8b\x28\x1b\xc3\x1e\xf6\x0e\xb9\x93\xcb\x4c\x22\xae\x56\xac\xdc\xbe\x0f\xa7\x2e\x32\xb5\x2f\x66\xa4\x55\x30\x6a\x50\xa6\x07\xa4\x0d\x21\xf9\x00\xb2\x71\xf2\x0c\x81\xcf\x6d\x35\x78\x65\x0f\xfb\x27\xe7\x08\x50\x7e\x0c\xf9\x14\xe2\x3f\x4a\xfd\x2c\xf6\x52\x32\x9f\xc6\x9b\x22\x60\x13\x2f\xe8\xb1\x1e\xdc\xa1\x4a\xfe\x0d\xf9\xa0\xb1\x4a\xfd\x2c\xaa\x62\x40\xf5\xb3\x5e\x53\xba\x1f\x03\xe5\x0d\x5e\x93\x73\x74\x13\xd0\x79\xd4\x24\x96\x28\xbf\x31\x07\xfe\xc6\x9f\xf3\xa3\xba\xee\xdf\x88\xc3\x98\x45\xe1\x8f\xb7\x43\xff\x3c\x29\x5e\x24\x60\x18\x0f\x63\x5f\x18\x02\x3b\x5c\x2e\x13\x0c\x81\x4d\x6a\x8f\xd7\xe5\x74\x58\xf9\x66\xd1\x6a\x44\xe3\xa0\x0d\x30\xb4\x34\x58\x95\x80\x12\x25\x56\x7a\x70\xc8\xcb\x9e\xa7\x9b\x9f\xd8\xd4\x2b\x4c\xc9\xe0\x91\xef\x11\x9c\x98\xe1\xa2\x82\x49\x19\x3c\xf2\x0f\x68\xf6\x7f\xdc\x1d\x8a\xfd\xab\x4c\xfa\xe8\xa6\xb7\x11\x89\x7c\x1b\x0a\x42\x4e\xbe\x90\x11\x82\x49\xff\x90\xa6\x82\x5a\xc5\x2e\xd7\x75\x7d\xae\xf9\x88\x6a\xc2\xfa\xa1\x7a\x0e\x63\x8e\xc3\xe9\xb4\xa8\xf8\x00\x8f\x15\x61\x45\x55\xfd\x95\x6e\x6c\x41\xa8\x24\xdd\x5c\x25\xd7\x2e\x96\x56\x9a\xc3\x7a\x52\xdf\x2e\x66\x6b\x34\xf9\x24\xa9\x0c\x68\xca\xa8\xe9\xb8\x12\xda\x90\xa3\x8e\x12\x79\x00\x46\x9a\x08\x2e\x05\x98\x52\x65\x1d\xb2\x21\xe1\xd2\x04\x0f\xc8\xa2\x60\xc9\x5b\x02\x18\x91\xf9\xb0\xba\x07\x41\xc3\x1b\x7f\x7c\xb1\xb8\x11\x74\x1e\x5c\xf5\xf2\xfc\xfb\x7e\xb7\x6e\x76\xed\x0e\x1a\xaf\xa1\x37\xd6\xc5\xd7\xcd\x79\x6d\x6b\xc3\x86\x1b\x76\x4f\xab\x1c\x92\x35\xf7\x9e\x6b\xbf\x07\x96\x97\xa5\xf5\x5f\x2d\x3f\x33\xe2\xe1\x77\xa4\x7f\x4a\x2f\xe2\xfa\x4b\xe0\xba\x97\x07\x48\xaf\xdc\x3f\xfe\x8c\x74\xfc\xc3\x0b\x1f\xe4\x82\x15\xbe\xda\x5a\x9f\xb4\xd8\x39\xf7\x19\x60\x3a\xfe\x87\xbf\x8c\xbf\x1f\x94\x46\x6c\xd2\xc7\x5d\xdf\x4b\x1b\xde\x30\x59\xa3\xc0\x87\xd6\xc5\xd9\xf5\x39\x79\x16\xee\x71\x14\xab\x8a\xbb\x8c\x16\x4b\x76\xc8\xeb\xd0\x60\x84\x97\xc8\xca\xd6\x47\x61\x30\x8e\xb9\x38\xca\x6f\xb4\xbb\xac\xca\x60\xe1\x5e\x55\x76\xdd\x49\xbf\x28\x4a\xba\x43\xbf\x62\x15\xcc\x19\xc3\x7f\xd1\xe0\x61\xf8\x7f\xf2\x7b\xbc\x60\xc6\x49\x86\x53\x03\xb5\x8a\xd0\x0f\x6d\xcb\x1e\x50\xad\xf9\x52\x3d\x5e\x5a\xda\x77\xb9\xf4\x71\x9f\xfd\xbc\x16\x7e\x6e\xa8\xc7\x17\x0d\x9e\xd0\x98\x15\xa9\x71\x8d\x2c\x91\xee\xdd\xd9\x74\xb4\x38\x6e\xc9\x37\x07\x27\xec\x48\x4c\xc5\x8d\x89\x6f\xf0\x97\x27\xf4\x8f\x65\xd7\xb8\x1a\xfa\x4b\xc7\x65\xff\xf0\x31\xb4\x09\x9f\xca\xfd\x18\xb9\xd8\xd5\xf1\x01\x41\x68\x0e\x49\x92\x54\x85\x42\x7e\x7b\x20\xe0\xb5\x65\x71\x36\x2e\x2f\xdf\x10\xec\x10\xd5\x5e\xaf\x8f\x71\xf8\x1c\x1d\x22\xe5\x33\xc0\xff\xac\xc0\x1a\xea\x10\xad\xb6\x76\xd1\xca\x91\x01\x10\xb8\xfc\x36\x1e\x59\x41\x53\x46\xff\x7d\x3a\x6c\x49\x92\x72\x29\x4c\x10\xa8\x9c\x2a\x5d\x48\x9f\x51\x46\x9d\xaa\xaf\xa8\x30\xa7\xee\xeb\x81\x41\xbe\xb0\xd7\x83\x1d\x65\x13\x48\xdf\x9e\x91\x86\x3e\x99\x57\xf7\xf7\x31\x63\x6f\xf7\xf6\x1d\x5f\x06\x76\xea\x33\x2f\xf1\xab\xa5\xd7\x1f\x54\x33\xd2\xb3\xca\x55\x3e\xf1\x2a\xa3\x7e\x10\x14\x57\x77\x57\x1e\xa0\x73\x9a\x03\xfd\x04\x03\xf7\xd0\x0d\x51\xd2\xfc\x78\x25\x26\x40\x1f\x68\x73\x98\x29\x4a\x9d\x95\x65\xf2\x9b\xec\xb4\x9d\xce\xcd\x8b\x84\xb4\xa1\x66\x51\xad\xd5\xda\xe5\x74\x8a\xcb\x68\xb7\x18\x3c\x28\xe4\x44\xc7\x9a\xe0\xdb\x44\xc2\x88\xf5\xe0\x8d\xba\x82\x31\xe4\x2a\x53\xf9\xab\xee\x46\x28\xb9\xe1\x5d\xa5\x4e\x99\x7f\xf9\xee\x25\x3d\x41\x05\x64\xc6\xd9\xe0\x91\xa2\xdd\xed\x9f\x1b\xc6\xe6\x35\x97\x1e\xd8\x2f\x2d\x3a\xfa\xf0\xab\x9d\x8d\x0b\x4a\x67\x4a\xdf\xed\x5e\xa2\x07\xcb\xc0\x73\xd5\xe5\x95\x83\x83\x11\xbe\x08\xff\xa4\x7d\x06\x91\x7d\xd3\x13\xba\x75\x1b\xa4\x93\x07\xb7\x7f\xfb\xb7\xa6\x11\x89\xe3\xc8\x21\x5c\xba\x73\xfe\x82\xe9\x13\x61\xd8\xbd\x6a\x9a\x1c\xef\x7d\x0d\xcf\xb4\x00\xcf\x74\x31\xc4\x5a\x75\xc1\x68\xa1\xc3\x11\x33\xab\x94\xdb\xff\x40\x34\xca\x13\x34\x51\x12\x13\xbc\xed\xa2\x53\x20\xc3\x32\xcb\x42\x20\x59\x04\xa0\x33\x26\x8b\x00\xc8\x54\x11\x00\x84\x29\x39\xbd\x89\x66\x7a\x16\x02\xc4\x7a\xe5\xf3\x32\x2f\x18\x62\x19\x9d\x4e\x30\x74\xca\xac\x08\x88\x71\x72\x93\xf4\xaf\x74\x3e\x51\xe3\x51\xe7\x13\xf5\x5e\xaf\x96\x93\xb7\xaa\xc0\x43\x20\xfe\x7f\x35\x43\xf5\xcf\xed\xd5\x81\xe2\x04\xf5\xbf\xd2\x1c\x05\x64\x2c\xd1\x26\xdf\x45\xad\x8a\x0f\x49\xc5\x8f\x6e\xde\xe5\xf7\x1b\x88\x28\xa1\xe1\x35\x7c\x76\x8e\xc9\xde\x22\x5a\x4c\xac\x57\x85\x62\x49\x97\x91\xf1\x32\x38\xfa\xe3\x43\xa6\x8b\x21\x51\x54\xa9\xd1\xa7\xa3\xca\x60\xeb\x95\xa2\xca\x85\xbd\x16\x89\xab\x8c\xa5\x49\xce\x53\xe0\x8a\x4a\x5e\xcf\x65\xc6\x97\xbd\xa0\xa9\x8c\x4c\x55\xc4\x86\x3b\x1f\xd2\x1c\x1f\x96\x84\x0a\x75\xf7\xc5\x80\xe1\x9e\xba\x3b\xfa\x40\x90\x5a\x3c\x66\xc4\x4a\x0f\x30\x98\xa5\xef\xa9\xbd\xfd\xa6\x36\xe6\xed\xe7\xcf\xdc\x3d\x30\x4f\x6a\x90\x41\xc3\xd5\x4f\xfe\xcb\x01\xe1\xeb\x89\x3e\xc7\x6e\x83\x50\xf5\xf3\x50\xdf\xea\xfd\xc8\x4e\x6c\xc4\x30\xca\x4f\xd5\x63\x2e\x68\x29\x96\xc5\xfb\xf9\x0d\x3e\xa3\x91\x77\x6b\x09\x92\xa4\xb5\x56\x8b\x17\xf3\xb9\x5c\x5a\x1f\x2f\xf0\x42\x30\xe4\xc6\x0c\x7e\x43\xbb\xe8\xf5\xfb\x39\x9f\x85\x14\x5c\x2e\xa3\x96\x24\x79\x23\x67\x6c\x17\x1d\x6a\xae\xbb\x1a\x5f\xb1\x7d\xc9\xf6\x6b\xe5\x93\x6e\xca\x08\x34\x61\xa1\xa4\x9b\xe1\x5d\x39\x2b\x08\x55\xa6\xbb\x71\xa2\x3d\xe7\xa5\x82\xf2\x0a\x3d\xb0\x12\xb9\xa5\x83\x0c\x45\x4d\xb4\x74\x23\x3d\xb2\x48\xd5\x4f\xfa\x69\x11\x2d\xed\x90\x47\xa8\x7e\xb1\x82\x4e\x7c\x46\xaf\x92\xfe\xd2\x67\xfd\xc8\xff\x2e\xc7\x87\x45\xa7\x8d\x90\xbe\x40\xfd\xca\xc0\xec\x77\x5f\x55\xae\x94\xe1\xa7\x06\xab\x82\x3d\xf3\xe3\xe0\xac\x54\x53\xaf\x60\x68\x68\x23\x73\x61\x9c\xed\xc4\xfc\xd8\x35\xf1\x2a\x97\xc9\xcf\x71\x82\x87\x51\x6b\x34\x46\xc6\x6e\x23\x7d\x84\x9f\x60\xfc\x82\x43\x70\x04\x82\x1e\xd2\xe4\x32\x35\x8b\x70\x35\x2c\x7e\x1b\xab\x61\x18\xce\x41\x10\x02\x67\xe1\x9a\x45\x60\xb1\xa0\x34\x71\xf5\xff\x26\x7c\x2c\xd6\x4b\x78\x64\x14\x09\x35\xb4\x89\x82\x3a\x58\x4d\x94\xa2\xec\x7f\x10\x49\x0f\x04\x60\x15\xca\x2b\x08\xd2\x27\x5d\xad\x2f\x6e\x70\xb5\x68\xed\x21\xfd\xb7\xfa\x02\x3b\xde\xe7\x58\x8e\xfe\x27\x7d\x23\xde\xb0\x1c\x70\x83\x13\xb5\x63\xb5\xb6\x9b\x86\x55\x3b\x01\xc5\x15\xc6\x6e\x75\x56\x57\x3b\x6f\xb5\x96\x65\x4b\x17\xd1\x2b\x62\xda\xa5\x7d\x4e\x30\xbb\xba\xac\xa8\x06\x70\x4a\x3d\xcc\xd7\x10\xf8\x84\xe0\x7e\xe7\x61\x25\xd8\xb9\x78\x67\xd0\x1a\x08\x08\x82\xdb\x55\x6c\x28\x82\xfb\x9e\xaf\xec\x7b\xc8\x12\xe6\xc3\x91\x42\xac\x28\x2f\x4f\x5b\xc4\xf3\xae\xa8\x2b\x1a\x2b\x2d\x0a\x93\x85\xc5\xc5\xc1\x7c\xcc\x60\xb0\x06\xad\x1d\x22\x1d\x84\x26\x23\x18\x74\x78\x03\x6e\xaf\x1b\x6a\x05\x11\xcd\xcb\x73\xf1\x46\xa3\x0b\x2a\x85\xe0\x72\xb8\xda\xc5\x1c\x4e\xed\x90\xb5\x22\x73\x65\xba\xdb\xd9\xd3\x95\x44\xb2\x6d\x4d\x2d\x5b\x6a\xb5\x32\x94\x85\xcb\x1c\x09\xd0\xf3\xda\xe9\x8a\x8a\xd3\xab\xf4\xa8\xa7\x22\xa9\x0a\xae\xa8\x48\x20\x57\xc2\x7b\x19\x1b\x3c\x0a\x46\xfe\x6f\xda\x85\x0b\x3d\x0d\x0e\xde\xde\x5b\xdb\x70\x6c\x1c\x86\xa9\x8e\x43\x5d\x0b\x43\x7f\xfc\x74\x7c\xba\xcf\x0e\x31\xba\xc3\xe5\x8c\x98\x72\xa1\xce\x65\x29\x3a\x67\xf3\x0b\x81\x40\x30\x07\xea\x24\xc1\xe4\x0a\x82\x33\xe4\x0c\xe5\xe5\xe7\x06\xd8\x9c\x48\xc4\x97\x45\x9a\x4c\x76\x1f\x34\x44\x72\xe1\x0b\xfa\xe3\x43\x5f\x97\x8f\x44\x15\x30\x16\x8f\xc7\xd5\x2c\x7a\x8c\x7a\xa7\x05\x29\x66\x28\x43\x31\xb1\xde\x5a\xd9\x93\xfc\x01\x05\xcb\xe8\x9b\x85\xb1\xff\x9f\x0b\x7f\x65\xa5\xed\x8e\x70\xba\xd5\x57\x75\xe7\xaf\xa8\xef\xbf\xa5\x8a\xb4\x0d\x03\x97\x80\xfd\xff\x54\x66\x30\x31\x65\xc9\xc0\x9d\x99\x6a\x8d\x77\xed\xc5\x30\xb5\x55\xae\x49\x0e\x61\x4b\xe3\x55\x21\x9b\xcd\x28\xe8\xf5\xba\x80\x8b\x24\x29\x4a\x17\x74\x38\x80\x8e\xf3\x71\xbe\x70\xc4\x69\x0b\xd9\x21\xb8\x21\xf5\x02\xc4\xb0\x01\x97\x20\x68\xec\x04\x60\x39\x1f\x45\x71\x3d\x18\x77\x93\x6b\x85\x8e\x70\x2c\x55\x09\x1b\xeb\x39\x08\x20\x9d\x4c\x50\x70\x7a\x36\x20\xf0\x28\x91\x2a\x59\x86\x5e\xbe\x1a\x1f\x80\x57\x40\x10\xa4\x06\x1e\xe0\xc5\xb5\x30\x34\xd2\x4a\xdb\xab\xfb\xbf\xd3\xb1\x9f\x49\x9c\x66\xee\xee\x98\x79\xdf\xa8\x53\xd2\x52\xe6\x9a\xbb\xa6\x1c\x79\x66\x9b\x74\xc2\x40\x3e\x64\x90\xa8\x77\xde\x29\xab\x9a\x9f\x60\xc1\xce\xc4\x44\x30\x18\x14\x72\x09\x99\x5f\x02\x0f\xe8\x6f\xbb\x43\x3a\xdb\xe0\xbc\xb8\xef\xf6\x46\x35\x4e\xb5\xb6\x26\x2e\x6a\x1e\x7e\xfb\x2b\x27\xfe\x09\xb8\x1b\x9d\xe9\xcd\xd0\x86\x0f\x86\x38\x27\x04\x61\xe9\xe6\x78\x93\x9d\xa6\xf5\x61\x0f\xba\x8c\xd3\x47\x5c\x2e\xa0\x0f\x06\xb3\xb2\xa3\x0e\x07\xcf\x67\xb9\x1d\x51\x67\xb4\x59\x44\x93\x70\x9a\xc5\xb0\xc7\x68\xf7\xda\x71\xf4\xc7\x87\xf6\x2e\x3b\x54\x25\xbb\x5d\xeb\x34\x02\xce\xc2\xeb\xf5\x41\x95\x56\x95\x41\xfb\x95\x5e\x0f\xd9\x99\x65\xac\x49\x6a\x28\x71\xa5\xa9\xf7\xba\xa0\x35\x89\x16\x80\xf4\xa2\x10\xc9\x35\x21\xe4\x35\xc1\xe5\x35\xa1\xfa\x4a\xaf\x15\x08\xc3\x1a\xfb\x4f\xd6\x4b\xe5\xfa\x79\xfd\x23\x95\xc5\x05\x87\xa5\xc7\xf4\x13\xe6\x0e\x9f\x79\xc3\xe2\x7f\xe8\x89\x03\x7a\xe9\xae\x99\x4b\x87\xe4\xc7\x86\x27\x5e\x02\x7e\xc9\xf1\xf7\x39\x30\xd0\x39\x6c\x1b\x34\xc8\x06\x26\x52\xb6\xdc\x1a\xe9\x4f\x35\xf6\xc3\x2b\x26\x65\x13\x60\x6a\x4d\x8d\xb4\x1f\x8f\x8c\xda\x74\xd8\x0e\x3e\x05\xb1\x94\xad\xd3\x0d\x85\x7a\x51\x00\x91\xd0\x7d\xf1\x31\x69\x5b\x17\x0e\x1b\x43\x16\xa8\x20\x85\xd9\xb2\x82\x14\x45\xa3\x50\x41\x38\x57\xbe\x2b\xbf\x24\xa6\x27\x65\xeb\x56\x98\x9d\xb6\x6f\x59\xe1\xe2\x62\xc5\xc6\x45\xbc\x04\x27\x08\xae\x7c\xf8\x77\x64\x03\xa7\x71\x70\x40\x6e\x3e\xed\x7d\xca\x92\xef\xba\x31\x52\x4f\x0d\xba\x4c\x87\x64\x25\xca\x3c\x5d\x97\x29\x53\x79\xef\x82\xca\x4c\xd5\xd2\xf5\xbf\xb2\x6a\xad\x5e\x92\x68\xe8\x65\xd4\x48\xad\x74\xf2\x7f\xd3\xb5\xf3\x63\x7a\x19\x35\xb2\xb7\xde\xa1\x3a\x03\xf5\x21\xa8\x77\xb9\x70\x85\x8f\xc5\xc7\xe7\x86\x72\x72\xc2\xe1\x68\xa4\x00\x80\x20\x66\xb3\x09\x79\x14\xba\x9e\x12\xf2\xa1\x35\x13\x7c\xbe\x88\x2e\xa2\x2b\x2c\xb2\x99\x42\xb9\xa1\x16\x31\x8f\x32\xe6\x7a\x73\x71\xf4\xc7\x87\xb9\x5d\xb9\x50\xf7\x72\x73\x2d\xd9\x64\x41\x41\x34\x1b\xea\x27\x9e\x6d\xf4\x30\x11\x8b\x4f\x10\x74\xb2\x21\xb3\xf4\x50\xc3\x58\xba\xce\x82\x4b\xa1\xab\xff\x73\x79\x7b\xdc\xaa\xa4\x35\x50\xed\xef\xad\xa0\x08\xb5\xa7\x8c\x58\x18\xf8\xc9\x89\x6f\x64\xea\xa0\xfe\x57\xb4\x75\x4f\x43\x48\xaa\x4a\x1b\x33\xe2\x65\xa4\xa9\xb8\x17\x34\x76\xab\x64\xcd\x95\x14\xf7\x6f\x13\xdc\x29\x8b\xa6\x86\x1a\x8b\x77\x3d\x2f\x0d\x26\xfe\xad\xfa\x16\x8b\x63\x0d\xd8\x96\x78\xbd\xbb\x5f\xbf\xb2\xda\x41\xf5\xf5\x03\x07\xf6\x19\xec\x1f\x6c\x8b\xe8\xcb\xca\x86\x36\x16\xc0\x95\x1d\xda\x50\x57\x5b\x77\xcb\xf8\xfa\xda\x92\xb8\x86\xed\x14\xfb\x04\xfc\x01\x3f\x04\xe9\x16\x77\x40\x03\xff\xb3\x14\x94\x94\x64\xb7\x8b\x30\xe2\x22\x3a\x44\x8b\x8b\x71\x65\xe4\x1b\x94\x14\x16\x5a\x22\x65\xc2\x9b\x5c\x76\x56\x92\xec\xab\x4a\x93\xca\xc8\xe9\x9c\x12\x53\x37\x51\x9c\xa0\x64\x45\xcb\x15\x8e\x57\x85\xda\x2b\x75\x7b\x88\x86\x9d\xfc\x66\xfb\x20\x2a\x51\x04\x28\xe0\x85\xf1\x50\xf8\x40\x4d\x51\xfe\xa4\x96\x9b\xd6\xc5\x16\x44\x83\x13\xf4\x93\xfa\x65\x8f\x69\xda\xb0\xe2\x9a\x5b\xcf\x9d\x07\xde\x5f\x6b\x2c\xfc\xe2\xd3\xc3\xcb\x89\x46\x95\xf4\xdd\x1b\x47\x54\x4d\x7f\x05\xfc\xeb\xf1\x9a\x60\x41\x5b\xd0\xf3\xf2\x80\x06\x77\xa4\x76\xdd\x8c\xe5\x7b\x39\x01\x78\x7e\xbd\xe5\xf0\xf8\x1f\xec\xa6\xd1\xea\x0e\xbf\xf4\x1e\x08\xfb\x0f\x1d\x82\xeb\xfc\x84\x54\x47\x94\x51\x87\xb1\x01\xd8\x10\x6c\x6d\x7c\x50\xcd\xc0\xba\xba\xea\xea\x41\xe5\xbe\x41\x3e\xa1\xaf\x2e\x16\xab\x6f\xc8\x13\x84\xfa\x21\xb5\x35\xb5\xb7\x8c\xaf\xab\x31\x21\x66\xbd\x72\xbf\xcf\x8f\x66\xb7\xf2\x6e\xbf\x06\xfe\xc7\xe7\x15\x15\x65\xb5\x88\x45\x2c\x4f\xb4\x88\xbc\x8b\xfe\xcd\x25\x4e\xe5\x46\xba\x8b\xd2\xe4\xf5\x4d\xa2\xff\xe4\xe2\x0e\xc0\x65\xba\x59\xb9\x62\x0f\xcf\x28\xe4\xfc\x95\x32\xb5\xe4\xe8\x19\xb5\x2a\xbd\xb0\x1b\x2a\x0b\xa2\xf5\xad\x13\xfb\x37\x37\x05\xea\x75\x75\x25\x91\x86\x11\x53\x06\x4e\x99\x7b\xcf\x81\xa9\x2d\x57\xac\x61\x6b\x9a\xf0\xc8\xc7\x77\xe2\xf7\x77\xaf\xea\x5f\xfa\x57\x67\x15\x65\xe5\x9c\xab\xe8\x17\xca\x09\x2d\x5d\x74\xed\x1d\x36\x76\xec\x98\xde\xd5\x6d\x2a\x76\xda\xd0\xf5\x5b\xbc\x02\xf5\x72\x7a\x35\x51\x0c\x35\x3c\x39\xe7\x3c\x82\xad\x89\x0f\x64\x8d\x46\x3d\x2d\x93\xfb\x39\x23\x32\xab\x9f\xc7\xeb\x0d\x52\x74\x00\x86\x9e\x59\x5e\x22\xe0\x48\xe6\x94\x88\x88\x8a\x57\xc1\x10\x94\xe7\x09\x83\xdc\xff\x77\x59\x97\x50\x66\x98\xdd\x7b\xe2\x62\xf7\x11\xef\x6e\xec\x8d\x65\x34\x39\x04\x03\xe8\x60\xa3\xb2\x2a\x0f\xe8\x07\x7e\x63\xe0\xb9\x76\xdf\xd9\xc9\x96\xc0\x70\x1a\x8c\x0e\xf3\x13\xc7\x30\xff\x1f\x6f\xff\x01\x1f\x47\x75\xfd\x8d\xc3\x73\xa7\xed\xce\xb6\xd9\x9d\xd9\xd9\xd9\x5e\xb5\x5a\xad\x56\xd2\x4a\x5a\x49\xab\xae\xb5\x2d\xc9\x72\x93\x64\x61\x8c\xd7\x4d\x72\x01\x57\x30\xc6\xd8\xe0\x86\x6d\x8a\x0d\x36\xa6\x63\x4a\xe8\x2d\x86\xf8\x07\x36\x18\x42\x0b\x81\x40\x08\x04\x53\x52\x80\x40\x42\x49\xe1\x49\x23\x24\x21\x09\xa1\x58\xa3\xf7\xde\x3b\xb3\x4d\x96\x81\xdf\xf3\xbc\x9f\x7f\x1c\xec\x91\x2d\xcd\xde\x7b\xcf\xb9\xe7\x9e\x73\xcf\x39\xdf\xef\xd7\x72\x9e\xcf\x39\xfc\x3c\xa8\x66\xa7\x29\x37\x1c\xfb\xde\xc4\x7c\xe7\x98\x13\x0b\xd7\x93\x2d\xcf\xd4\x23\x4e\x2c\x13\xe7\x74\xb9\xf4\x1e\xd6\xed\xd6\xe9\xf4\x70\x1d\x28\xbd\x89\x34\x91\xc1\x50\xc0\xc5\xab\x8c\x58\x27\x21\xc4\xd2\xa2\xc5\x6f\x98\xeb\xff\x2d\x1d\xd6\x0d\x97\xde\xf0\xf5\x74\x58\xd4\xc2\xe3\xf7\x60\x3a\xac\x12\x9c\xb7\x20\x3c\x45\x07\x32\x96\x98\xcb\x45\xc3\x10\xd0\x44\x9b\xea\x53\x35\xd6\xc7\x81\xe7\xe1\x6c\x5c\x42\xed\x88\x62\xb6\x26\x5e\x13\x27\xf4\xfa\x32\x0c\xfa\xe6\x1d\x07\xfa\xa6\x31\xfa\x7f\x3d\xee\x9b\xa8\x62\x14\xe7\x18\xe4\xd2\xac\xda\x2c\x80\x6e\x51\xd4\x2e\xc5\xa6\x13\x70\xe0\x52\xe7\x9e\xdb\x35\xbb\xbc\x29\xc3\x5f\xb7\xfb\xaa\xdf\xb7\x2e\xda\x71\xe3\xa5\x7b\xde\x6d\x1b\x9e\xba\x61\x63\xe7\xec\xf2\xe6\x66\x6e\x1c\x28\x1c\x59\x36\xa3\x22\x6c\x5d\x74\xca\xd3\x6f\x01\xfa\xaf\xf5\xa0\xed\x99\x77\xff\xfe\xcb\xfa\xe9\xf1\x30\x3f\x59\xab\x3d\x47\xdc\x1c\x66\xc2\x4f\x54\x13\x7d\x99\xf2\x32\x59\xa6\x7c\x81\x80\x81\x32\xd4\x24\x13\x96\xa1\x6c\xb9\x38\x94\x4d\x94\x27\xca\x09\x9d\x2e\x34\x90\xd5\x59\x09\xf7\x40\x29\x28\xdc\x49\x26\x59\x28\x34\x27\x59\x11\x83\x87\xe6\x71\x10\xd5\xfc\xb1\xae\x49\x45\x1e\x4e\x83\x03\x08\x2f\xf0\x56\xf4\x9b\x35\x52\x9f\xa8\x70\x96\xd5\xe8\xa7\xb7\xce\xb8\xc4\xd7\xd8\xbb\x7d\xca\xce\xb2\x3a\x5f\x18\xfd\x65\x79\x8d\xfd\xad\xa3\x2a\x6d\x07\x42\x0d\x04\xbb\x83\xd1\xa0\xb7\x3d\xb3\x61\xfb\x73\xb7\xb5\x13\x63\xff\x7c\x60\x6f\x5d\x20\x1a\x50\xf1\xac\xce\x1f\xfb\x2d\x7b\x0f\x94\x9f\x93\xe8\xc8\x38\xcd\x26\xbb\x9d\x14\x2d\x16\x17\xe9\xb6\x88\x56\x71\x38\x6b\xa5\xed\x66\xf1\x04\xd2\xa4\x54\x71\xa7\xad\x66\xa5\x8a\x08\x93\xa0\xc9\x51\x3b\x48\x51\x9a\x9e\xf9\x62\xe9\xb4\xda\x41\x96\xab\x74\xf5\x6d\x48\x8d\x7e\x67\xbd\xf2\x8b\x55\x26\x32\x62\xba\xea\xa7\x60\xef\xe4\x35\xbb\x98\x99\x01\xe5\xdf\xdf\xd1\x5b\x96\x2d\xf8\xea\x55\xfa\x73\xdc\x2f\x7d\x35\xf9\xe2\xf9\xe7\xd4\xe3\xb1\x89\xf8\x8e\xf5\x49\xc2\x8e\x10\x1a\xed\x04\xc3\x00\xa3\xd1\x41\x03\x20\x39\x38\x2b\xc2\x74\xb6\x52\x00\x55\x24\x32\x18\x23\x2c\x5f\xf6\x01\x5a\x0a\xed\x67\x70\x71\xf1\x2e\xc7\xf5\x73\x1a\x5c\x37\x1c\x1f\xf0\x1e\xeb\x30\x82\xaa\xeb\x01\xdd\x7d\xed\xf2\x39\xd3\x62\xd3\x5d\x52\xac\x7c\x6a\x4c\x69\xb2\x53\x2b\x9c\x93\x47\xcf\x01\xdf\xdf\xb8\x2e\xf0\xc1\x76\x6b\x32\x33\x2a\x8c\x8d\xa9\x6b\x84\xf0\x81\xe8\x28\xca\x0f\x90\x3f\xa3\x66\x83\x7e\xcc\xbd\xe4\x52\xb9\x97\x54\xce\x55\xfa\x29\x94\x43\xa0\xcb\xd5\xef\x21\xe3\x70\x0e\xe8\x7b\x82\xb6\x1c\x3f\xd3\x74\xa5\x97\x33\xc3\xb5\x36\x13\x3e\x78\x86\x9f\x91\x69\xac\x0d\x35\x36\xd6\xf9\x75\x84\xbb\xa1\xa2\xce\x5d\x27\xb4\xf8\xfd\xc2\xa4\xc9\x1d\x75\xa9\xba\xe1\x6c\x67\x8a\x6f\x0c\xd5\x0a\xd1\xea\x91\x6c\x3c\xea\x75\x50\xc3\x59\x07\x6d\x81\x21\x88\x45\x2c\x2e\x72\x21\x8a\xfc\x1d\x38\xf1\x54\x61\xfb\xd7\xe7\x16\x60\x1c\x51\x4d\x38\xc7\xa7\xa9\x36\xdb\x00\xbb\x0e\xe4\x21\xe0\xb0\xc2\xa1\xf5\x52\x09\xd1\x55\xb6\x40\xba\xec\x8a\xad\x1b\x7e\x70\xee\x9e\x6d\x1b\x9e\xd9\xac\x4c\xbe\xed\xb3\x4b\x9f\x02\x73\x7e\x73\xdb\x7f\xf7\xfc\x50\x79\x98\x79\x79\xb6\x32\x6d\xe4\xa2\x4b\x67\xa6\x3a\xea\x2a\xdb\xed\xae\xea\xf6\x2b\xd6\xbd\x05\x17\x36\x79\xe3\xa3\x9e\xa8\xcd\x5b\x6d\xfa\xa3\x9b\x9a\xf1\xcc\xbb\xaf\x2a\x97\x3d\xf9\xd4\xdb\x2f\x82\x4d\xa3\x8b\x2e\xfd\xe2\x76\xb4\xd9\xf6\x7e\x79\xcb\x3f\x94\xf3\x5f\xa2\x76\xcd\xbf\x70\xb4\xe1\xd6\xeb\x67\xe9\x4c\x9f\x5e\x20\xef\x7d\x8a\x3a\x0d\x2e\xfe\x2e\x50\x55\xb5\x2a\xe0\x0e\x39\xcc\x93\x64\x5c\x9f\xd9\xab\xab\x80\x7b\xce\x84\xf8\x4e\xd1\x9a\x11\x72\x5d\xb4\xda\x5f\x2f\x5b\xeb\x6b\x6a\xac\x4d\x1e\x4f\x17\x6b\xb5\x76\x76\xb5\xd6\xd4\xd6\xf4\x67\xdb\x6a\xf9\xfa\x6a\x29\x5c\x39\x90\x2d\x0f\x7b\xed\x24\x3c\x7b\xad\x66\x0e\x93\xb7\x8d\x5b\xb3\xae\x12\x58\x58\xb4\x6a\x28\x42\xb1\xe5\x89\x04\x4b\x70\x3b\x4b\xb6\xe7\x37\x2f\x18\xf9\xbd\x02\x85\xce\x5f\xf3\xbb\x95\xfe\xcf\x37\xae\x55\x51\x1b\x8c\x62\x2e\xde\xbf\xdf\xbc\x4e\x24\xb4\xc3\x77\xb0\xeb\x99\x03\x84\x0b\x5a\xe1\x6c\xa6\x3a\x44\x95\x19\x7c\x72\xdc\x5a\x5b\x1b\xf7\x95\xd1\x6c\xb5\xc8\x8a\xf5\x29\x9f\xbb\x36\x63\xad\x1d\xc9\x9a\x0d\x56\x3a\x1e\x2b\xcb\x20\xa0\x63\xb8\xc6\xf0\x44\x7d\x35\xa5\xd2\x67\xc0\x85\x79\x55\x7b\xca\x21\xa6\xc9\x85\x8c\x93\x86\x85\x4e\x60\xbe\x2f\xec\x6a\xc8\x0e\x9c\x87\x81\x1e\x1c\x3c\x63\x62\x1a\x37\x26\xde\x6b\x6a\xbe\x26\xc6\x92\x6f\xc5\x9a\xf5\x5f\x2a\x6f\xfe\x10\x9c\xfe\x77\xfb\xb4\x78\xac\x49\xaf\x80\xc4\x4f\x94\x5b\xff\x26\x4e\xfd\x7e\xb0\xde\x7c\xc9\xdb\x97\x5c\x71\xa1\x34\x25\xd2\xe9\xdb\xf9\xfa\xf6\x4b\x36\xd7\x8c\x24\x23\x5e\x50\xf6\xee\x6f\xc0\xca\xf7\xe5\xb2\xea\xea\x88\x57\xf9\xf5\x3b\xef\x2b\x57\xbe\xe9\x88\x24\xe9\xe3\x21\x8f\xef\x4d\xe5\xbe\xef\xde\xf7\x8a\xcb\x17\x6e\x2c\x7b\x1b\xcc\xb8\xe3\xd6\x57\x83\x1a\x36\x77\x70\xec\x0e\xfa\x3c\xda\x02\xe7\x9f\x40\xf3\x0f\x50\x21\x39\x6a\xf0\x5a\x2b\x2b\xbd\xd1\x10\xcd\x56\xc0\xf9\x57\x55\x57\xba\xbd\x19\x83\x77\x30\x6b\x85\x0b\x10\x8d\x84\x32\x54\x68\x10\xcd\xdf\x51\x3c\xff\xfc\xd3\x49\xe7\xaf\x31\x81\xaa\xf3\x57\x99\xc2\xf0\xfc\x31\xcd\xbe\x8c\x4e\x22\xd4\xb0\x12\x63\xc1\x6f\xe3\x93\xcc\xb7\x3c\xb8\xfb\xbf\x77\x5a\x32\x15\xf1\x2e\xf3\x1d\x0f\x5e\xfa\xf9\x9d\xe6\xce\xfb\xa7\x44\xb7\x7d\x77\x6e\xb4\x63\x4a\xf4\x82\x3b\x07\xca\x47\xea\xa2\xde\x17\x6f\xbb\xe6\xf8\xdd\x8e\x48\x4d\x4d\xd4\xf7\xf2\xcd\xd7\x1e\xbf\xcb\x51\x56\x4b\x9d\xdb\xdc\xa4\xbc\x7b\xe4\xe6\x96\x9a\x96\x24\x28\xfb\xc1\x7d\xf5\x08\x1a\x19\xe5\xe2\xb8\x6a\xdd\x46\x42\x20\x22\xc4\x42\xe2\xea\x4c\xfd\xdc\xa9\x0e\xbf\xdf\x25\x8a\x7a\x3d\x31\x69\x56\x55\x6a\x16\x41\x4d\x6d\x9d\xda\xba\x68\x71\x72\x68\xc6\xd0\x70\x36\x35\x30\x90\x9e\x41\x2f\x9c\x34\x29\x96\xed\xce\x42\x8b\xd2\x2d\x72\xba\xc7\xc1\x8c\x8c\x9c\x25\x38\x8e\x74\x90\xfc\x95\x59\x9e\x04\x12\x45\x86\x1c\xa1\xab\x16\x38\x28\x15\x28\xf6\x85\x42\x83\xe2\x0b\x85\xaa\x49\x35\xb2\x2a\x61\x79\x28\xa2\x4e\xcb\x25\xb3\x04\x74\x4a\x61\x5e\x67\x15\x00\x1b\xf1\x40\xa7\xa1\x77\x5a\x43\x6a\x38\x82\x6a\x43\xc9\x49\x32\x79\xa8\x95\xbb\x80\x33\x58\x94\x06\x6c\x4a\xd3\x35\x2d\x6f\xb5\x9c\xb1\x7a\x43\xaf\xdd\x15\x9a\xb1\xe9\xf4\x05\xb5\x2d\x33\x9c\x20\x71\xf5\x85\xdc\x76\xbb\xd3\x9e\xa9\x8f\x35\x28\xbf\x9e\x79\x6f\xdf\xfa\xb7\xaf\x19\x1c\x97\xe9\xdb\xfb\xbb\xed\x3f\x5a\x35\xf7\x93\x0d\xca\x7b\xca\x33\xa5\x49\xc2\xa3\x77\x2f\x7d\x6b\x16\x3b\x0f\xf8\xaa\xd3\xd5\x97\xc7\x6a\x62\x6d\x93\xea\xe6\x9f\x2f\xa7\xfc\x1d\xbc\x24\x39\xed\xd1\xba\xda\x2f\xb7\x4d\xee\x5c\xfb\x0c\x10\x0e\x17\xa5\x00\xff\xa9\x5c\xf6\x6e\xa2\x33\xd5\x04\x02\x80\x28\xc9\x1b\xfe\xe4\xbd\xbe\x66\x5c\x4f\x1e\x1f\xfb\x98\x4d\x32\x0a\xd1\x00\x63\x87\x79\xc4\xcd\x19\xb7\x8b\xa3\xf8\x19\xa7\x9c\xd2\xdf\xd7\x57\xc5\x53\x1d\x1d\x8d\xe5\x8d\x5c\x3d\x57\x9f\x9d\xdf\xd9\x8e\x64\xd1\x9c\x6d\xec\xec\x9c\x91\x4e\x77\x43\x59\xa4\x03\xe9\x64\x9a\x12\xa9\x74\x86\x33\xf5\xa5\xe7\xce\x98\x7b\xd5\x82\x19\xd6\x0a\xc9\x2c\xc1\x78\xd8\x66\x4b\x9a\xad\x01\x8a\x8a\x78\x59\xa8\xc0\x04\xeb\x20\x4a\x04\x93\xf7\x82\x31\x5a\x79\xb1\x04\x8b\x12\x0a\x82\x5c\xdc\x91\xcd\xa8\x2b\x9e\x2f\x21\xcf\xd3\x1d\xe6\x00\x98\x31\x41\x09\xca\xcf\xe7\x6b\xf4\xac\xc4\x37\x4a\x98\x2e\x3f\xf3\xb6\x8a\xee\xe7\x57\x1e\x7c\x64\xdb\x47\x57\xac\xd9\x5a\x37\x4d\x34\x25\xdc\xed\x23\x2d\xa7\x9c\xd6\x77\xad\x67\xb2\x6e\x45\xef\xd5\xf7\x9e\xd6\x90\x9c\x31\xad\x6e\xf7\xda\x9b\xef\x57\xfe\xcf\xe8\x69\xdf\x20\x57\xfb\xac\x29\xbd\xd3\x5f\x78\xe2\x31\x60\x3d\x50\xa6\xfc\xf5\x76\xd9\xbb\x4f\xf9\xc7\xc2\x8d\x97\x2d\x6f\x6d\x5f\x0a\xaa\xbe\x7a\x2d\x75\x3b\x90\xca\x7e\x72\x58\xf9\x93\xf2\x18\xfd\x9f\x09\x45\xe9\x12\xa1\x28\x55\x3c\x0d\xfd\x87\xec\x5b\xf0\x7c\xb6\xa1\xf3\x99\x7b\x96\xf1\x80\x9b\x50\x8e\xbf\xb7\x80\x91\x85\x73\xba\x4c\x07\xfc\x1e\x41\xfd\x1e\xf2\x1e\xb5\x0e\xa0\x5e\xab\x03\x40\xf9\x70\xe8\xc3\x23\x9c\x4d\x1f\x62\x96\x13\x29\x1f\x41\x38\x11\xff\x82\x3f\xe0\xf4\x79\x7c\x30\x5e\xf1\xa8\x58\xa0\x34\x21\x17\xfc\xdb\x54\x29\xb3\x5c\x2a\xb7\x5f\x18\xd5\x94\x8e\x83\xd5\x0c\x68\xe8\x24\xe4\xb4\x4f\x94\xbf\x8e\x83\xd2\x3c\x76\x64\x77\xbf\xda\x08\x6b\xf1\x82\xc8\xef\x4a\xf1\x33\x9f\xff\x84\x65\x94\xa5\x1a\x0f\x4a\x40\x99\x49\x9d\x8d\x6b\x3a\x7b\x33\x51\x86\x65\xad\x84\x9f\xf3\x07\x82\x48\x99\x08\x1b\xe0\x28\x9b\xcd\x6c\x45\xaa\xc4\x3a\x18\x02\x17\xcf\xe6\x99\xe4\xd4\x9e\x95\xe2\xba\x59\x75\x73\xab\x91\x53\xce\x7d\xc8\xe5\x9e\x72\xfd\x63\x24\xb1\xce\x84\xb8\xe4\x3a\x2f\xbe\xaa\xb8\x2a\x6a\x60\xff\xe0\x92\xb9\xed\x69\xe5\x76\x61\xd2\x24\x27\x18\x74\x1e\xbd\xac\x50\x13\xb5\xff\x9f\xfb\xd7\x6d\x17\xb5\xda\xaf\xfd\xcc\x7e\xdc\xcf\xd4\x60\xd0\xb1\x14\x4d\x1a\x09\x9b\xd5\x4c\x9b\x00\x20\x49\xc9\x68\x82\xf1\xa2\xcd\x46\x11\x56\x9d\xce\x6c\x20\x44\xc6\xc0\x73\x22\xc3\x73\x1c\xcf\x88\x34\x30\x89\x80\x40\x8c\x5a\x2a\x0d\x94\x5a\x5e\x5a\x04\xab\x90\x63\x43\xc6\x9c\xbb\x38\xf3\xcc\xa1\xcb\x67\x5d\x4c\x07\xff\xa3\x90\xa3\x2a\xa7\x63\x69\xe8\x08\x71\x3b\x95\x3f\x3c\xd9\xf8\xd4\x9a\x27\xd3\x4f\x7e\x71\x21\xb0\x3c\x91\x7e\x72\xcd\x13\x8d\xd4\x35\xe0\xab\xd1\xf7\xbb\x57\x77\xbf\x3e\x65\x65\xb7\x12\x22\xd9\xee\x95\xdd\xaf\x75\xaf\x26\xc0\x18\x4d\xfb\xc0\x8b\xcc\x4d\x84\x44\xe8\x8f\x10\x06\x22\x09\x57\x88\x92\xf3\x90\xa9\xa1\x58\x1e\x61\x54\x20\x7b\x6a\xeb\x7b\xa6\xa7\xc1\x69\xe4\xd4\xda\xda\x9e\xa9\xcd\xf4\xfd\x62\xaa\x77\x5a\x6d\xe3\x64\xa9\xae\xb7\xa7\xbe\xa1\x47\xc5\x98\x60\xe8\x61\xf0\x33\x66\x1b\x5c\x83\x96\x47\x45\x8e\xb3\x73\x06\x64\x1e\x5c\x59\x8e\xb3\x12\x56\xea\xca\xac\x75\x07\x71\x25\x41\xf2\x30\x76\x7c\x88\x78\x1d\x7a\xe2\x44\x72\xd1\xfa\x63\x45\xa8\x87\x58\x44\xda\xcd\x4b\x02\x34\xa6\xeb\xb5\x03\x0a\x6c\xb0\x64\x9a\x3d\xb5\xb3\xd6\xee\x59\xb4\x72\xf1\xd9\xed\xa7\x54\x9e\xb9\x96\xa6\x87\xa7\xb4\x88\x89\xce\xcb\xc1\xb4\x58\xf0\xf2\xab\xd5\x3a\x8f\xd9\x34\x01\x36\xb3\x34\x61\x25\x9c\x19\xce\xaa\xd7\x5b\x48\x52\x60\xe0\xa7\x1c\xcb\x71\xb5\xc1\xd7\x97\xe5\x48\x5d\xd5\xae\x52\x19\x9c\xa6\x7c\x39\xbb\x73\xf2\x69\xe1\xf2\x78\x70\x0b\x4d\x1c\x78\x7a\x60\x59\x77\x6b\x59\x35\xcf\x47\xbc\x5d\x73\x50\xee\x94\x6e\x02\x0f\x31\x5f\x10\x36\xf4\x4e\x93\x0e\x9a\x47\x4a\xe4\xa9\xdc\x3b\xf3\x1d\xaa\xf8\x22\x23\x7f\x44\x3c\xf4\xc2\xa3\xe6\xec\x6c\x4f\xc8\x33\xbd\xb7\x73\x06\xb3\x69\xdb\x3d\xc1\x1e\x47\x47\x42\x0a\x04\xcb\x3c\xf5\x6d\x53\xd1\x58\x47\x77\xd1\x4b\xc9\x3a\xe6\x62\x38\xd6\xd6\x4c\xc4\x48\x51\x36\x93\x71\x79\xd6\x64\x62\x29\x96\x18\xc8\xf2\x6c\x80\x25\xd9\x1d\xd4\x95\x2a\x46\xec\x43\x14\x45\xa1\xb5\x7a\x61\xd1\xb8\xc5\xa2\xc2\x79\x42\x17\x1d\x8a\x2a\xff\xf0\xbd\xe4\x73\x91\x5f\x3c\x36\xfc\xd4\x33\x2f\xac\x74\xfc\xec\x1f\x17\xed\x63\xca\x7e\x74\xcb\xee\xfa\xf6\xfa\xad\x8b\x53\x95\x68\x8d\xf4\xc7\x13\xca\x61\xea\x4d\xe6\x08\xf4\xdf\x51\xc7\x6b\x9a\xe8\x21\x4e\x21\x96\x10\xeb\x88\x3b\x32\x03\x8b\x07\x07\xe7\x4d\x77\x1a\x0c\x02\x5d\x13\x0c\x36\x94\x97\xd3\xd3\xa9\x33\xda\x27\x4f\x5e\x7b\xc6\x19\xeb\x67\xc7\x82\xd3\xa7\xcf\xf2\xf6\xf6\x46\x66\x9d\x39\xa5\xfd\x8c\x33\x56\x35\x2f\x5d\xda\xb5\x6a\xb8\xb1\x66\xde\xbc\x05\x95\x73\xe6\xd4\x2d\x98\xb5\x6a\xc1\x82\x55\xb3\x28\xa3\xe4\x12\x04\x8b\x04\x63\x47\xda\x08\xf5\x09\xda\x74\xfc\x9b\x4d\xd5\x6c\x4d\xa5\x93\xa9\x7c\x95\xfe\xf8\x47\x4d\x4e\x82\x5c\x82\xef\x82\xe7\x2a\x85\x59\x29\xa2\xca\x2e\xd2\x50\x4e\x95\x7c\x05\xbe\xe6\xdf\xc4\x6f\xfd\x9d\xa5\x5f\xa5\xfa\x06\xcf\x9b\x33\xe7\xbc\xc1\xde\xc6\xfc\x13\x39\x67\x82\xbf\x9c\x99\x7f\xfa\xb2\xb9\xb1\x57\x7d\xec\x4b\xe5\x9f\x8e\xe6\x9f\xde\xec\x4b\xcd\x39\xef\xbc\x39\xb5\x33\xd8\xa6\xdc\xd3\x97\x6f\xe4\x9e\xe8\x58\xee\x49\xd1\xe7\x9e\x46\x7f\x36\x33\x89\x9e\x52\x7d\x74\x2c\xf7\xa4\xe8\x73\x4f\x50\x96\xb5\xca\x72\xea\x0d\xac\xef\x21\xa2\x9e\x98\x42\x9c\x46\xac\x21\x76\x10\xd7\xa2\x1b\xaa\x9d\x97\xac\x1a\x59\xe0\x95\x25\x1b\x4b\x11\x84\x71\xea\xa9\xe7\xad\x5d\xbb\x7e\xfd\xa9\x46\xdb\x82\x4b\xd8\xa6\xda\x68\x74\x52\x53\xd3\x75\xd3\xba\xbb\x2f\xba\xba\xbc\x3a\x1c\x86\xbe\xc0\xf6\x75\xf3\x16\x5d\xdd\xb4\x6e\xd1\xa2\x75\x4d\x57\xd3\x54\xc0\x6e\x41\x1a\x9e\x3c\xa6\x19\x24\xeb\x31\xeb\xab\xd6\x63\x50\x90\xaf\xd6\x43\xa7\xb2\xb0\x9d\x8a\xfc\x4a\xb5\xf1\x22\x27\x2b\x44\x82\xd0\x58\x74\xa2\x52\x0d\x4d\x69\x89\x95\xec\x88\x62\x00\xe3\x15\xc3\x4d\x1d\x29\x2f\x5c\x03\xa2\x73\x3c\xa5\xdd\x10\xa2\xad\x89\x5b\x37\x74\x31\x8d\xd1\x47\xfd\x1e\x1c\xc2\xa4\x65\xed\x4e\x41\xfd\xbe\x28\x7a\xbb\x0a\x42\x0f\xff\x5a\x7b\xb7\x1d\x17\xe1\x6b\xa5\x87\xea\xe7\x9f\xbd\x7c\xdb\xf9\xe1\xca\x70\x3a\x91\x9a\xf4\x61\xe1\x91\x9a\x37\x6f\x4d\xb4\xab\xac\x51\x76\x48\xa1\x70\x79\xd5\xac\x2f\x57\x97\x7e\x4d\x7f\xb7\x73\x45\x5b\x75\x99\xc3\x61\xaf\x76\xfa\x6b\xa6\x1c\x6f\x2b\xf9\x92\x5a\xb4\xb1\x7b\xda\x59\x55\xbd\x31\x7b\x40\xac\x0e\x56\x4c\x3e\xfe\x7e\xe1\xeb\xa4\xbf\x62\xf2\xd1\xd2\x97\x31\x07\x4a\xbf\x1e\xfd\xd1\x84\x63\x52\x3e\x28\x7d\x2b\x15\x2e\xfd\x7a\xe5\x49\x87\x14\xa8\x9e\x82\xf2\x41\xff\x52\x66\x22\x3c\x36\x5c\x0f\x74\x73\x26\x1a\x0f\x57\x54\xf8\x78\x07\x27\x49\x06\x83\x95\xd7\xcb\x3a\x9d\xd3\xe9\x43\xc0\x63\x84\x8f\xf7\x25\xaa\xe2\xf1\x50\x34\xea\x47\x5c\x3f\xd1\x6c\x54\xc8\xe8\x65\xd9\xed\x16\x7c\x4e\xc9\x2a\x58\x87\xb3\x02\x85\x8a\xf1\x79\x04\x5a\xe2\xe0\x38\xc6\x2c\x50\xf8\xfa\x4e\xf3\xa0\x53\xf9\xd2\x49\x4d\x01\xd0\x35\x3b\xf6\xdd\x0a\x1c\xf1\xc5\x77\x7a\xa9\x42\x3f\x2e\xbe\xc3\x44\xf5\x51\x1a\x10\x5d\x68\x3c\x48\x1d\x50\xcb\x93\xd5\x56\x66\xfa\xa3\xe7\x95\x5f\x6e\xdf\xaa\xec\xc9\xc1\xd2\x8d\x5e\x38\x01\x70\x9d\x92\xe9\xdd\xd6\x3b\x34\xf8\xe2\xb6\x5d\x77\xd7\x7c\x1a\x5a\xee\x57\x58\x70\x34\x0f\x55\x77\x02\x90\x1d\x98\xb3\xe2\x82\xe8\x03\xd7\x6c\xb9\xbc\xe2\x61\x5c\xeb\xb8\x92\x0e\x31\x2f\xc0\xf8\xbc\x82\xd8\x92\xe9\xa4\x8d\x06\x83\x3d\x58\x6e\x36\x47\x82\x0e\x97\x4b\x92\xec\x1e\x41\x14\xed\x41\x7b\xbc\xd2\x68\xa4\x74\x3a\x62\x30\xab\x8b\x66\xa2\x91\xfe\x6c\x94\x17\x3c\x1e\xde\xc7\xcf\xce\x3a\x7d\x0e\xb7\xd4\x9f\x75\x4b\x62\xae\xf2\xf1\xc5\x42\x39\xd5\x44\x0b\x53\x92\xbc\xc9\x5f\x3f\x15\xcd\x9a\xca\x17\x45\x9e\xd8\x21\x48\x3e\x5a\x3c\xd7\x0f\xf3\xed\x82\x67\x9c\xd0\x2d\x48\x7f\x90\x9f\xe7\x57\x5f\xe4\x3a\x07\x95\xf2\x13\x1a\x07\x0b\x18\x36\x76\x5c\xef\xe9\x95\x18\x1a\x40\x25\x71\x38\x44\xab\xdd\xce\xbb\x39\x1e\x3a\x5e\x8c\x34\x92\xa5\x6d\x82\x0d\xa9\x8b\x3d\x0b\x04\x06\xfe\x32\xdb\x29\xb3\x23\x07\x6c\xa3\x21\x8e\x62\xd8\x5e\x0d\xb3\xb7\x08\x25\x41\x73\xdf\xe1\x3c\x11\xc2\x7d\x49\xb9\x5c\x3a\x55\xa8\x94\x23\xff\xc7\xf9\x81\xf4\x61\x6b\x71\x79\xdc\xa1\xfb\xa5\xfb\x9d\x0f\xa9\x85\x71\x4c\xc7\xee\x2d\xca\x63\x5a\x45\xdc\xbb\x5b\x76\x8f\xf6\xe5\x71\x78\x88\x25\xb8\xcf\x62\x3f\x74\x65\x30\x46\xbf\xcd\x22\x08\x46\xd6\x29\xdb\x69\x14\x5d\x1a\x49\x9f\xd1\x17\x29\x73\xd3\xfd\x59\x99\xb7\xf2\xe8\x5e\xc5\x0d\x7f\x05\x85\x20\x3c\x70\x83\x0e\x81\x20\xba\xba\xc6\x95\xfe\x15\x5f\x72\xe6\x6a\x80\x51\x8b\x2b\x6e\x70\x45\x16\x27\xda\x90\xc6\x83\x0f\xe1\x19\x15\xe1\xb1\xff\x71\xc7\x35\xa1\x76\x7b\xaf\xf2\xb8\x7f\xe5\x39\xc2\x39\xe5\x80\x2d\xdf\x2f\xec\x1f\xe9\xef\xbe\xef\xe0\x3b\xaf\x1c\xf9\xfe\xac\x0f\x5e\x30\x0d\x2e\x3b\x6b\xd3\xaf\xfb\x0e\x92\x4d\x2b\xdf\x7e\x7b\xe5\xe8\xdf\x0c\x7b\x2e\xbc\xfb\x7f\xee\x84\x72\xd0\x30\xf4\xa0\x4f\x16\x26\xb6\x65\x26\xc9\xa1\x30\xe5\x77\xb9\x44\xab\x8d\x32\x13\xe6\x32\x3f\xe1\xf3\x01\xa0\x63\xd9\x48\x99\x1c\x0a\xf9\xad\xa2\x48\x08\x02\xf4\x8f\x11\xbd\xae\xdf\x4f\x73\x9c\x6f\x24\x8b\x30\x6d\x39\x0a\xa8\x90\xb6\xc2\x78\x90\x21\x8d\x43\x35\x99\xdf\x9d\x39\x32\x59\xad\xb2\x5b\x6e\xa9\xd7\x68\xae\x0a\xb9\x58\x24\x29\x16\xf9\x9a\x6c\x44\x94\x91\x90\x70\xb5\x63\x3a\x46\x06\x67\xfe\xda\x38\xba\xc0\x78\xd7\x4f\x0f\x9a\x48\x51\x01\xcc\x86\x4d\x4b\x06\xb6\xae\xda\xbd\x69\x49\xcf\xc6\x73\x7b\x56\x0d\xac\x9c\xb9\x84\xb4\x28\x73\x73\x00\x8a\x47\x1f\xbe\xe8\xa5\xd6\x4d\xbd\xd7\xfb\xc0\xa9\x1b\xe7\x5f\x7e\xfe\x85\xa3\x0f\x56\x6d\xc2\x39\x6c\xad\xff\x19\x7a\x24\x55\xc4\x45\x99\x9e\xaa\x84\x8f\x0a\x96\x07\xa1\x0b\x0d\x0d\x10\x51\x5d\x53\x6e\x30\xcb\xd1\x28\xc2\x50\x16\xaa\xa3\xb2\x1c\x71\x45\x66\x67\x5d\x56\x49\xec\xcf\x4a\x3c\xae\xed\xf6\xf8\x12\x89\xb8\xd7\x1b\xd7\xc7\x07\xb2\x14\xcb\xea\x19\x46\x8f\x4b\xfe\x6d\x9a\xa9\x52\x67\xdb\x55\xc2\x8f\x5d\xe0\xef\xcd\x99\xa5\xa2\xa9\xdb\x49\x75\xb6\x61\xc4\x1b\x9b\x5f\x06\x5c\xe7\x08\xe4\x1c\xf6\x08\x85\x2f\xeb\x63\xd4\x8f\x2e\x3c\xf3\xf4\xfe\xf5\x73\x97\xce\xed\x61\x74\x15\x77\x98\x46\xff\x64\x5a\xf9\xd6\x32\x13\xc8\xb2\xdb\xaf\xd8\x78\x85\x32\x65\x71\x65\x4d\x47\x7d\xf7\xf2\xa5\xce\x29\xae\xd6\xfa\x35\xe4\x79\x47\x94\x37\x87\xb6\x74\x5f\x1a\x0b\xb5\xa6\xbe\x72\xc2\x80\x82\x7e\xd8\xd5\xbe\xf7\xee\xa3\x4a\xdd\x39\x33\x5e\x5a\xb9\x6a\xf3\x25\xa3\x6f\x3b\x9d\xd5\x17\xa9\x35\x8e\x50\x17\xfa\xd9\xab\xa0\xaf\xd6\x96\xf1\xc3\x08\x82\xa6\x28\x0b\xc7\xb3\xc6\x91\xac\x5e\xcf\xb2\x34\x02\xc1\x35\x51\x80\x1a\x86\x7b\xb1\xa4\x76\x31\x59\x84\x32\xa0\xd6\xb1\xe0\xee\xfb\x14\x05\xad\x09\xb9\x67\x74\x15\x4a\x95\x5b\xc8\xcc\xcf\x87\xdb\x95\xbd\x2f\x3d\xab\xe2\x91\x81\x53\x94\x29\x5f\x5d\xe5\xce\x73\x58\x95\xd1\x4f\x11\x1c\x51\x9f\x71\xea\xf4\x7a\x82\xe3\x0c\x8c\x91\x93\x48\xdd\x40\x96\xa6\x27\xe8\xa7\x29\xfe\xb8\xfc\x47\x45\x5e\xde\x6c\x02\xcf\x7c\x6f\x38\xad\xbc\x72\xdd\xdf\x51\xcb\x0c\xe0\x95\xbd\xc7\x9f\x42\x38\xb0\x2a\x06\x30\xe1\x24\x4e\xcf\x78\xec\x94\xd1\xe8\x76\x40\xd9\xca\xb2\x8e\xd6\xeb\x29\xca\xe5\x36\xe8\xe1\x89\xc3\xb0\x0c\x32\x34\x8e\xac\xc8\x9a\x59\x33\x80\x6e\xe9\x48\xd6\x40\xc9\x27\xcc\x57\xdb\xb1\x85\x0d\x5b\x82\x1e\x82\x91\x9a\x73\x46\x46\xed\xee\xa1\x70\xb5\x6e\x48\x87\x16\xe3\x22\xb4\x18\x4b\x1e\x90\xbe\x37\xf4\x5d\x0b\xcd\xa4\x4f\x11\x83\xc7\x96\x67\x67\x83\x85\x92\x72\xf7\x12\xb8\x30\x64\x62\x0b\xf8\x99\x67\x9a\xb2\x06\x06\x5b\x66\xa5\x71\xcb\xe8\x9b\xee\x62\x9c\x9b\x18\x42\x2c\x0e\x73\x76\xca\x4d\xbb\x5c\x32\xeb\x64\x18\xda\xcb\xc3\xb9\x39\xed\x74\x45\x3c\x1a\x18\xcc\xba\x65\x8a\xa5\x5d\x0c\xfc\x65\x8b\x5a\x6d\xa6\xc1\xac\x4d\xbb\xc5\xc5\x26\x12\x83\xf9\x16\x40\xbb\x51\x3d\x92\x56\x81\xa4\xc6\x14\x50\x05\x4f\x00\xbe\x81\xa1\x5e\x53\x29\xf4\xcd\x79\x9b\xcf\x19\xb8\xb4\x2e\x91\x47\xbf\xd9\x74\xeb\xd2\x81\x73\xba\x8a\xf1\x6f\x96\x5e\x5c\xb7\xa7\xfb\x4e\xe7\xe0\x14\x0d\x02\xe7\x8c\x2d\x1d\x1b\xbb\x2f\x6b\x38\x3d\x07\x82\xa3\x62\xf3\x2a\x3d\xcc\x6e\x8c\x59\x7e\x66\xc6\xc7\xc7\x2c\x96\x8a\x0a\x37\x0d\xe3\x0b\x3b\x65\xaf\x4c\xc8\x81\x91\xac\x47\xf6\xc6\x78\x3e\x6a\x8b\x22\xa9\xb8\xb2\x36\x1b\x60\x59\x0b\xd4\x44\x4d\x11\x2b\x26\x50\xc4\x12\xca\xb9\xd2\xf2\xd9\x92\x2a\xab\x62\xb9\x34\xa5\x82\x30\x6c\xc6\xe4\x3c\x62\x4a\x57\xe0\x9d\xcb\x09\xeb\xe5\x22\x41\xf5\x7c\xe7\x72\x40\x03\xbd\xb2\x42\xb9\x62\xf6\x0d\x6b\xab\x16\xd3\x83\x97\xbc\xfd\xd9\x15\x77\xac\xd9\xb8\x5e\x53\x6a\x4d\x70\xdb\xaa\x95\x7f\x29\x7f\x50\xae\x50\x96\x7b\x2b\x80\xf5\xca\xf9\x60\x2d\x48\x7f\xf4\x46\x70\x74\xab\x86\xf7\xd8\xa8\xf4\x52\xbf\xa2\x0e\x11\x11\x62\x38\x53\x17\xb6\x87\x42\x92\x24\xeb\x1d\x6e\x2b\xe5\xa0\xca\xa2\xf6\x70\x58\x20\x84\x81\x2c\xa2\x6d\x76\x85\x06\xb2\x1e\x17\xea\xfc\x77\xf1\x0e\x89\x35\x0f\x64\x39\xd6\xab\x51\xc9\x9e\x38\xe3\x09\x66\x8b\x52\xda\x68\x72\x1a\x94\x6b\x53\xa3\x35\x14\x46\xc4\xd4\x05\xdc\x6d\xaa\x89\xec\x7b\xf6\x0d\x78\xf2\xfd\x6e\xef\xbe\xfa\xa9\x7c\xdb\xdc\x6b\x9e\x50\x94\x40\x77\xcf\xdf\xaf\xdb\x6c\xa2\x3c\xf5\x33\x2c\xb6\xe5\xc1\xdb\xbb\x56\x83\xff\xb0\xbf\x78\x54\xf9\x4a\xf9\x43\x00\xb8\xef\x8f\xff\xf9\x31\x30\x59\xaf\x6c\xd1\xfa\xd2\x68\x5e\xb9\x55\xc4\x78\xd4\xca\x0c\x8c\x47\x1d\x87\xd1\xdd\x90\x89\x77\xd8\x8c\x56\xd9\xe0\x74\x72\x7e\xca\xe7\xa3\x69\x8e\x8c\xc6\xe0\x77\x95\x07\xca\xa3\x9c\xd5\xc6\xf0\x65\x7c\x59\x65\x22\xee\x29\x0b\x04\x7c\x4e\x9b\x43\x74\x0c\x67\x29\x83\xc1\x2f\x93\x46\x63\xd4\x2a\x5b\x75\x21\xb7\x48\x01\xb3\x50\x4e\xd3\x3c\xa7\xe3\x86\xb3\xba\xd2\x3a\xb2\x54\x01\x8a\x2f\xef\x21\xa6\x8a\xb3\xd9\x72\x4b\xb1\xdb\x33\x1e\xab\x3a\x14\xf9\x56\x50\xd5\x32\x15\x61\xeb\x1f\xf9\xdf\x62\x55\xff\xea\xd6\xe1\xff\x0d\x58\xb5\x47\x21\xd5\x3d\x31\xa6\xac\xc4\x58\x4a\xdd\xc4\x2d\x99\xc1\x7a\x9b\xd5\x9a\x4a\x59\x1a\x79\xbe\xa1\xc9\x4c\x18\xeb\x42\x42\xd2\x98\x6c\xab\x8c\xc5\xe4\x06\xb9\xa7\x97\x6d\x6b\xeb\xa9\x2a\x1b\xcc\x56\x55\xb5\xd4\x37\x99\x9b\xfa\xb3\x36\xb3\xb9\x92\xaf\x6c\x69\x99\x34\x90\x6d\x6f\x8f\xb7\x48\x0d\x12\xcf\x23\x67\x52\xef\xa3\xf2\x10\x49\x5a\x77\x01\x6a\xca\xec\x7a\x51\x83\x58\x29\xf4\x63\xa6\x9c\x05\x64\xa4\x96\x82\x1b\x5d\x50\xa7\xbc\x52\x7d\x4b\x74\x24\xe8\x48\xfe\xbf\x01\x24\x6d\x52\x3e\xfc\x45\x7b\xeb\xff\x0d\x48\xd2\xe8\x6f\xc1\x8d\xf6\x09\x80\x92\x90\xdd\x19\xc2\x98\xe0\xed\xa8\xaa\xd1\x98\x4e\xeb\x5b\x5b\x1b\xea\xdc\x35\xee\x98\xa3\xa1\x21\x50\x53\xd3\xd1\x19\x23\xcd\xe6\x8e\x3a\x8f\xdb\xe3\x1e\xce\x9a\x3c\xc0\x48\x79\x3c\xc6\x04\x43\xc4\x12\x89\xf0\x70\x36\x41\xa7\x8d\x46\x71\x38\x6b\x31\x8a\x44\x49\x61\x41\x9e\x1b\xa1\x00\x96\x54\xd4\xe7\xa7\xb5\x20\xa9\x37\x42\x85\x60\x31\xf6\xed\xf1\xc2\xb5\xdf\x81\x6f\xdd\x20\x3f\xb5\xb3\x6b\x5a\x53\xcd\xe3\xe7\x7c\x13\x7a\xf8\x5f\x7e\x5d\xdb\x7c\x40\x19\x6a\x3a\xd5\x37\xbb\xa7\x79\xb6\xc5\x10\xfe\x46\x24\xf1\x23\x3f\x77\xca\xa7\xb5\xad\xdf\x83\xf0\xa4\x94\x21\x8c\x27\xd5\x4c\xec\xc9\x4c\x27\xc2\x8d\xe1\x1a\x4a\x66\x59\x3b\xc7\x05\x28\x2a\xd6\xd8\xd8\xd2\x5a\x63\x71\xb9\x5a\x9a\x23\xe1\x48\x78\x20\x6b\x8a\x78\x23\x33\x23\x0b\x23\x6b\x23\x8c\x29\x12\xa9\x97\xf9\x1a\x60\xa6\x6a\x6a\xea\xeb\x2b\x07\xb2\xf5\x56\xd9\x3b\x90\x65\x65\x87\xc9\x06\xbf\x11\xf3\xcf\x17\x71\x61\x4f\x84\x32\x95\x5f\xb8\x42\xb8\x22\xe4\xe1\xa6\x74\x1a\xe8\x54\xf1\x22\x7e\x0b\xf8\xa9\xfb\x6e\x81\x6b\xb1\x43\x5b\xbc\x8e\xfa\xcb\x47\xbe\x1e\x8a\x6a\xcb\x6d\x12\x5e\x08\xbc\x76\x4d\xf3\xac\x72\xcf\xc4\xc0\x54\x60\xec\x9f\xca\x0c\x8c\x2d\x8e\x70\x6e\x1b\x79\x9a\x36\x70\xa4\xec\x82\xff\xe0\x84\x36\xcd\x21\x73\x94\xd7\xe7\xf1\x58\x29\x52\xa6\x75\x26\xde\xe6\x40\x44\x03\xc3\x59\xd1\x44\x39\x69\xcd\xa8\xa1\x13\x2c\x4f\x03\x0b\xff\x94\xb1\x4f\x8c\xad\x98\xdc\x52\x80\x97\xd0\x94\x27\x14\x01\xa5\xac\xd2\x45\x86\x8a\x9e\xb4\x5d\x79\x60\xea\xd0\xc9\x01\xc6\xf7\x40\xb3\x74\x76\x9b\x92\x3c\x09\xc0\x38\xb2\x42\x80\xa8\x84\xb1\x69\x33\xee\x03\xcd\x66\x6a\x72\xbd\x1b\x8c\x9d\xa0\x28\x5a\x92\x2c\x30\x2e\xd5\x53\x0e\x59\xb4\x58\x38\xd4\x9e\x61\x37\x33\x2c\xad\xb7\x1a\x79\x89\x26\xf5\x12\x01\x8d\x4a\xaa\x98\xcb\x76\x82\x29\xa8\x11\x0d\x0a\x31\x8b\xa1\xb1\xb0\xe5\xa5\xf5\x28\x9e\xbc\x69\x1c\x36\x16\xb8\x10\xa3\x66\x4d\x46\x41\x24\xb8\xa5\x04\x1d\x4b\x05\xcd\x2a\xc2\x77\x0f\x11\x37\x65\x66\x05\xcc\x16\x8b\xdf\x6f\xe5\x79\x9f\xcf\xeb\x95\xa1\xda\x85\x54\x98\x77\x0f\x92\x08\xe3\x08\x47\x3c\x42\xc0\x2b\x07\x1d\x21\xab\xd9\x66\x32\x85\xbc\x94\xc5\x0f\x7f\x51\x7a\x78\x5a\x61\xf0\x5e\x51\x4f\x39\x89\xd2\xba\x29\x5b\x29\xf4\xbb\x13\xbb\x52\x1a\xf2\x3f\x9c\xe0\x04\x30\x60\x42\x3e\x47\x9e\x2a\x65\x46\x51\xa5\x96\x86\xae\x46\x11\x2e\x3c\xa5\x83\x27\xf2\x78\x6c\xf8\x05\x7b\x93\x67\xb9\x41\x0a\x8a\xef\x7e\x28\xbe\x18\x58\xb2\xdb\xa4\x5c\xf0\x5c\xf0\xac\x4e\x79\x51\x11\x44\xfc\xe8\xbf\x2f\x00\xdc\x35\x40\xc6\x52\x3c\x65\x34\x0d\x1d\xeb\x5b\x1f\x07\xcb\x53\xd5\xc5\x98\x67\x6e\xe2\x8a\x4c\xaf\x68\x12\x04\xb3\xec\x70\x70\x46\x3b\xba\x9c\xe1\x10\xa2\x03\x05\x6d\x1d\x6f\xd1\xd1\xb4\x93\xb4\x90\x1e\xaf\x6c\x77\x8a\x7a\x23\x65\x24\x4d\xa4\xd3\x89\x6b\xa9\x4c\xa2\x28\x19\xe0\x2f\x8b\xdb\xc6\xd3\x3a\x9d\x05\x15\xbf\xdb\x52\x1a\x53\x0e\x9a\x64\xbe\x6a\x34\x57\xce\x5e\xb2\x14\x85\xce\x4b\x21\xc7\x24\xa6\x9e\x20\x79\x78\xb4\x48\x3a\xa7\x06\x5d\x20\xa5\x4b\x97\xa0\xa4\xdd\x1c\x98\x5f\x99\xcd\x2b\xc3\xfc\xc4\x7c\xf9\x47\x25\x58\x69\x5d\x87\x3f\x39\x25\xa7\x0f\x0b\x3e\xbd\xf8\x05\x8c\x97\x56\xd0\x85\x4b\x33\x49\x96\x33\x18\x98\xa0\xc7\xe3\x0e\xd9\x45\x2b\xcd\x43\x5f\x99\x09\x78\xbd\x92\x9b\x71\x87\x23\x01\xc1\x2d\x49\x3c\xde\x8f\x21\x7b\xd0\x23\xea\xf4\x3a\xf5\xa2\xc1\x6a\xf7\xc0\xa5\x91\x4d\x94\x77\x22\x35\x80\xb6\x0a\x9e\x84\x85\x46\x3d\xa2\xd8\xe9\x28\x6a\xe0\x15\x72\x47\x68\xa1\x7e\x2e\x9d\x03\x44\xd7\x45\x74\x13\xb2\x02\xdc\x70\x48\x3a\xe4\x53\xa5\xef\xbb\x45\xba\x25\x4e\x66\x4a\xa5\xaf\xfc\x4a\x15\x3d\x95\xdd\x72\x37\x12\xf8\xdd\x5b\xfe\x4e\x9a\x0a\x92\x27\xb7\x55\xab\xfe\xa5\x17\x61\x32\x61\x8c\xc9\x4b\x32\x3d\x50\xa8\x4e\xd1\x06\x43\x5b\x1a\x1a\x22\xa3\x51\x30\x08\x22\x6f\x32\x31\x06\xd1\xe0\xf5\x51\x92\x03\xe5\xb6\x1c\x0e\x9d\xdb\xed\xec\xcf\xba\x09\x04\x57\xc6\xf3\xf0\xdb\xad\x46\xda\xa8\x83\xb2\x67\x74\x4c\x7f\x56\xc7\x13\xe3\x19\x6b\x93\x45\xad\xed\x27\x76\x30\x63\xc4\x18\x5b\xfe\x06\x03\xa0\xdb\x0a\x3c\x63\x32\x0f\x8a\xa7\xad\x06\xf8\xec\xff\x88\x1f\x8d\x80\xe1\xb9\x46\x30\xcf\xb8\xf0\x5f\xef\x0f\x1a\x95\x17\xef\x5b\xdb\xad\xfc\xeb\xa9\x45\xe2\x42\xff\x42\x13\x38\x93\xde\xbb\x72\xf4\x1d\x30\x4f\x9e\x3c\xd9\xf1\xe1\xe8\xff\x71\x4e\x06\x3f\xee\x55\x76\xd1\xe1\x95\xf7\x63\xbc\x39\x62\x84\x20\x74\x14\xc6\xe6\xde\x98\x69\x43\xfb\xdd\xea\x43\x72\x36\xe6\x37\xbc\x3f\xe0\x11\x7c\x56\xaf\x6c\x95\x29\x93\xc3\x66\xe3\x4d\x3c\xdc\xe3\x30\xb8\xd5\x8d\x64\x4d\x13\xee\x74\x2c\xd3\x12\xbd\x1e\x8f\xf4\x57\xd8\xe3\x45\xc5\x91\x39\x80\xeb\x12\xc9\x52\x56\x55\xb2\x2f\xbd\x76\xc7\xa4\xa9\x0b\x26\x53\x7f\x85\xfb\xfa\x64\x52\x55\x69\x8d\xd0\x96\x3e\x51\xa8\x30\x06\x84\x71\xde\x65\x18\xcf\x68\x55\xa6\x91\x30\xcb\x32\x34\xcc\x16\xd6\x22\x59\x79\xa3\x5e\x0f\x58\x9e\x75\xba\x58\x80\x6b\xbb\x1c\x66\xc2\x84\x10\x1f\x24\x87\xc3\x8a\x9a\xa5\x71\x8b\x34\x34\xd1\xc5\xe8\x8e\x79\x39\x8e\x17\x5d\x2a\x27\xbc\x16\x9c\xf5\x2b\x95\x99\xd6\x65\x4a\xca\xe0\x74\x55\x5e\x5f\x7c\x02\xe5\xf5\xf4\xe1\x95\x9d\xca\xbf\x6e\x68\x5e\xed\x68\xeb\xab\x27\xcb\xc1\x6f\xc0\x79\x48\x58\x63\x0a\x03\x85\x75\xcf\x64\xe5\x36\x6a\x48\xb4\x7e\x07\x38\x35\x2e\x0e\x65\x06\xe6\x29\xf1\x11\xe7\x64\x5a\x04\xc6\x66\x63\x59\x93\xd1\x43\x10\x6e\xb7\x4b\xa4\x29\xca\x6e\x77\x19\x5d\xfe\x80\xcf\x23\x30\x23\x59\x41\xe0\x2c\x2e\xbb\xca\x65\xe1\xb0\x50\x6e\x96\x32\x72\x46\x18\xf4\x71\xc2\x09\x48\xdd\x5a\x9b\x34\x91\x97\x54\x91\xb7\x5f\xda\x62\x33\x9e\xa0\xab\xc0\xcf\x43\x5f\xab\xac\x35\x1f\x59\xac\x38\xc7\xe3\x26\xff\xe9\x34\x8d\xac\x04\x3a\xf6\xd3\xdd\xe3\x3b\x93\xc0\x3f\x34\x34\x75\x78\x80\x02\xa2\x09\x9e\x9f\x08\x27\xd0\x86\x70\xef\xe1\xa9\x69\xb3\x59\x2d\x0c\x8c\x61\x78\x6b\xee\x30\xb5\xea\x45\x81\xe7\x51\xdb\xa3\xd9\x4c\xe7\xbb\x1c\x69\x5b\x7f\x96\x44\xf0\x87\x2f\x16\xf7\x39\x16\x4d\x28\x55\xd4\xfe\x99\x0f\x63\xf0\x49\x5a\x02\x82\x40\xeb\xd0\x29\xfa\xd2\xf4\x13\xb0\x02\xd5\x13\xb4\x04\x2c\x50\xe3\x46\xd1\x3b\xa1\x3c\x02\x70\xff\x74\x70\x5e\x04\xd6\x48\x91\x1e\x83\xdb\x6d\x34\x4a\x16\x3b\x69\x0f\x86\xcc\xf6\x91\xac\x99\xe1\xbc\x23\x59\x9e\x83\xee\x30\xc7\x11\x8c\xc6\x17\xc3\x33\x94\xcf\x2d\x61\xbe\x18\xe7\x04\x7c\x31\xc5\xcd\x68\x89\x12\xaa\xd8\xa2\xae\xa7\x48\xa9\x24\x50\x0d\x4b\x22\x77\x15\x88\x24\xc5\x8f\x93\x03\x5d\x35\x79\xa1\xad\xef\xe7\x3f\xfe\xc9\x41\xf3\xe8\x8e\x9c\xb4\x4a\x85\xa1\x5c\xf6\x85\xf0\xd5\xb5\x48\x44\xaa\xa8\x08\x0d\xbf\x91\x99\x07\xe5\xe2\x80\x7e\x7f\xb7\x1e\xa8\xb8\x8d\x1c\x34\x7d\x06\x83\x68\x14\x28\x41\x76\xea\xc1\x40\x76\x40\x3f\xac\x27\x79\x7d\x40\x8f\x1e\xd6\xe9\x19\x13\xa5\xd7\x3b\x58\x87\x08\xf7\x91\x64\x80\x41\xb9\xc1\xac\x01\x39\x22\xdc\x2c\xcd\x52\x4c\x40\x5e\x3c\xd1\x44\x4b\xe0\x1c\xb5\xd8\x7b\x02\x54\x47\xb2\x11\xc6\xdc\xe1\x55\x76\xe1\xc2\xf1\xe0\x8e\x30\xd2\xd6\x1b\x47\x25\x64\xf6\xf0\x3e\xea\xd1\xdf\x02\xe5\x56\x45\x5c\x90\x89\xc4\x2b\x2b\x29\x92\x0b\xe9\xf5\xe1\x70\x85\x3d\xe6\x8d\xc1\xd3\xdc\x52\x5d\x63\x73\x8d\x64\x25\x9b\x37\x04\x7d\x76\x63\x00\x9d\x6d\x5e\x68\x07\x08\x46\x95\x1d\x13\x1f\xc9\x32\x54\x65\x2c\x8c\xc5\x17\x2d\x11\x5f\xa2\x14\x77\xe0\x84\x26\xdb\x54\x71\xc5\x74\x41\x80\x27\xbf\x4a\x29\x92\x26\x22\x25\x63\xae\xb2\x1c\x99\x7a\xf3\x95\x13\xdd\xa5\xac\xda\x7c\xf6\x7d\xc6\xd1\x8b\x8d\x0f\xbf\xa4\x58\x5f\xba\xcf\x98\x77\x54\xd7\xd7\x4d\x74\xa5\x52\x36\xba\x13\x5b\xce\x35\x5f\x5d\xef\x99\xa6\x9e\x7d\x35\x4a\x2f\xf3\x31\x8c\x5b\x6a\x89\xf3\x32\x9d\xe5\x81\x60\x30\x1c\x4a\x8a\x55\x55\x76\xbb\x5b\x0f\x8f\x00\xb8\xfa\x54\x5d\x7d\xa0\xbc\xdc\x1b\xf7\xce\xce\xc6\xad\xea\x45\x8b\x5c\x56\x16\xee\xcf\x96\xf1\x21\x49\xb6\xf7\x67\xe5\x71\x17\x2d\xe3\xf7\x63\xf1\x65\xcb\x09\xeb\x91\x9a\xf0\xce\x65\x3c\x70\x07\xba\xdc\xcd\x87\x27\x4d\xf4\x42\xf5\x02\xe6\xb2\xcb\xf3\x17\x30\xf1\x26\x0d\xc6\xa3\x75\x57\xe5\x6a\xe5\xb3\xeb\xb2\x66\xd0\xaf\x3f\xf5\x8e\x55\xcb\xce\x65\x23\x6d\x27\xde\xc5\x90\xca\x6b\x1a\xa8\xc7\xce\xe5\xa3\x0f\x52\xb3\x5d\x93\x1f\x3a\x73\xc1\xea\x11\x7b\xd3\xcb\x66\x94\xa7\xe8\x19\xfb\x98\xb9\x91\x99\x49\x24\x61\xd4\x9b\xcd\x54\xfb\xd2\x61\x2e\xda\x5a\x5b\x5b\x43\x25\x12\x51\x8b\xdd\x62\xef\xe8\xac\x48\x0d\x67\x2b\x2a\x8c\x82\xe0\x46\xec\x41\x74\x2b\x11\x34\x06\x87\xe1\x1a\xe0\x30\xb7\x88\xfd\xa8\x98\x37\x20\x3f\x77\xf4\x7b\x3d\xca\x53\xe4\xb2\x49\xac\x56\x93\x16\xca\xdd\x09\x20\x84\x7e\x47\x1b\x48\xa3\x42\x18\x42\x2d\x0a\xd5\xc9\x62\x43\xae\x14\x46\x6e\x12\xe8\x2d\x5b\xd7\x0b\xed\x77\x4d\xeb\x3c\xcb\xb7\xf8\x3b\xca\xef\x95\x5f\xfc\x12\x5c\x0d\xcc\xcf\x5d\x54\x73\x2a\xe3\x5d\x53\xa7\x7c\xa1\xbc\x74\x70\xbf\xec\x9d\x95\x05\xba\xdf\x3d\xf8\xfc\x43\x37\x4a\xce\xca\x58\xe3\x92\x96\x64\x6c\xe9\xca\x53\xaa\xd2\xf1\x94\x60\x09\x82\x20\x30\xfd\x17\x6c\x7c\xa9\x7a\x8c\xb8\x4e\xf2\x40\xbd\xba\xf7\xa9\xdf\x92\xc9\x67\xb7\xfd\x1d\x38\x0e\xdf\x71\x44\x79\x77\x1a\x49\x2e\x98\x3b\x6f\xdd\xf3\x17\x66\x0f\x44\x07\x80\x1d\xad\x8b\x6f\xec\x63\xea\x35\xa8\x2b\x09\xa2\x11\xad\x8b\xad\xaa\xd2\x2e\x27\xeb\xea\xa2\x41\x9f\x4f\xa6\x38\x8a\x6b\x4a\xbb\x53\x03\x59\xb7\xdb\x0e\x8f\x5a\xb8\xf7\x75\xd6\x64\xd8\x4e\xd8\x07\xb2\x95\x15\xb8\x7a\xba\xfe\xdb\xad\x4b\x1e\x15\x49\xab\xa5\xc6\xf5\x9e\x68\x25\x72\x75\x21\x72\x4a\x5b\xb9\x18\x2b\xa2\xc5\xc0\x6a\x02\x5e\xfd\xd5\xaf\x0e\x00\xe1\xe1\xfd\x0f\x55\x4d\xf6\x4c\x5f\x78\xe0\x47\xc3\xf3\xab\x6b\x1e\xbc\xe2\xcc\x3d\x4b\x06\xec\x72\x5f\xb7\xb9\x76\x73\xf3\xbc\xca\x86\xb8\xcb\xb2\x2c\x9e\x68\xb2\xbf\xf2\xec\x61\x60\xbe\xba\xe2\xb3\x4b\x93\xca\xdf\x7e\x7d\xe1\xf5\x6c\xec\xfc\x49\x57\x3d\xb8\x7d\xf5\xe2\x43\x09\xd2\xd6\x06\x3d\x20\x0f\xe8\x4a\xcc\x77\xac\x7c\x6c\xe1\x36\xb5\x1e\x6b\x08\xd7\x63\x25\x89\xf9\x99\x64\xb5\xd7\x5b\x19\x28\x0b\x10\x4e\x96\xad\xb3\x12\x44\x6d\x5d\x38\x36\x92\x0d\x7b\xaa\xbd\x84\x13\x06\xf1\x4e\xa7\xd7\x2b\x0e\x67\xbd\x22\x0d\xcf\x60\x9d\x0e\xe3\x93\x8c\xc3\x88\x4e\x75\x25\x8a\x8b\x82\xf3\xf7\xf2\x27\x25\x3f\xb6\x80\x09\x82\x78\xb2\xf7\x24\x0c\xc8\xa7\x7d\x7e\x71\x79\xf2\xa6\xad\x38\x74\xef\x98\xd9\xd2\xf2\xf3\x8f\x48\x71\x42\x0e\x64\x5f\x2d\xeb\x3c\xa5\xe1\xec\xcb\x61\xcc\x7e\xea\xac\x96\x39\xc6\x18\x90\x51\x9d\x94\x32\x84\x31\xb2\xaa\x10\x53\x86\xb5\xd2\xe5\x8a\x79\xe5\x90\x97\x80\x0e\x52\x75\x4d\xa0\x6c\x20\x1b\xf0\x38\x44\x97\x38\x98\xad\x74\x39\x68\x13\x34\x06\x1c\xe0\x68\x2b\xd1\xf5\xc2\xa2\xdc\x3d\x85\xf5\xc5\xae\x44\x51\xbb\x39\xae\x13\xcf\xcd\x6e\x5c\x41\x17\x42\x12\x38\x71\x6a\x35\xc0\x3f\xae\xba\x4b\x45\xbb\xba\xe1\x91\xf2\xfa\xdc\x95\xc4\xf4\x54\x6a\xcd\x6a\x30\xbd\xa4\xce\x0b\x23\x5f\x5d\x6c\x97\x87\x1a\xd7\x5d\x05\xe7\x34\xaf\x3f\x3d\x97\x8f\xfc\x0f\x92\xdf\xf5\xca\x0c\xc4\x6b\x05\x7d\xc1\xa9\x99\x88\x5d\x96\x05\x51\x84\xe6\x9f\x74\x1a\x5d\x0e\x8f\x89\xe3\x0c\x02\x6d\xa0\x51\xf2\x42\xc4\xb6\x9d\x18\x47\x3e\x8c\xdd\x59\x50\xb0\x58\x48\x58\xa9\x22\x10\x91\x1c\xbe\x08\x62\x2c\xfc\xae\xe9\xdd\x97\x3a\x9a\xf7\xf9\x11\x2b\xe7\xc0\xe4\x79\x66\xef\xf5\xb5\x6d\x2f\xbd\xb1\x7d\x7b\x03\x72\x57\x2d\x2c\xa2\xe1\xbc\xec\x0b\xd6\xf4\xd5\xb5\x1e\x85\x44\x24\x85\x80\x88\x29\x2b\x99\x5f\xe0\xf5\xde\x90\x69\x75\x8b\x76\xbb\x23\x08\x83\x30\x8b\x31\x5e\x55\x55\x51\x11\x85\x0e\x91\x51\x8a\x4a\xd1\xea\x9a\x04\x27\x8a\x41\xb7\x9b\xb1\xfa\xac\xb3\xb3\x61\x9f\xd5\xe9\xe8\xcf\x3a\x79\xa3\x24\x11\x15\xfd\x59\x22\x87\xb6\xda\x55\x5c\x4d\x8b\xaf\x28\x4b\xc0\x41\x0a\x95\x20\x1a\xf3\xbc\x66\x64\x71\x83\xe7\x44\xf6\x56\xd6\xf6\x1c\xce\x72\xd3\x7d\x67\x38\xfa\x22\xc3\x33\x0c\xcb\x94\xff\x9c\xe1\x98\x5e\xbb\xa5\x4c\x33\xb5\x7d\x54\xdf\x5d\xcb\xb3\xa7\x83\xfd\x3f\x9e\xb7\xd2\xbc\x0c\xa7\xb9\xb1\x71\x1d\xdc\x96\x1e\x7d\x15\x3f\x5d\x32\xac\x9a\xd9\x83\x4b\x87\x57\x2d\x7a\x71\xdd\x72\xf3\xa2\xd1\x5f\xe0\x3c\x37\xae\x89\x5c\x95\xe7\xa1\x6a\xc7\x67\x52\x5a\x99\x49\x4f\x81\xbe\x87\x9d\x38\x25\x13\x87\x3e\x20\x63\xb6\xdb\x09\x8b\x28\xa2\x6b\x09\x46\x72\x98\x29\x4e\xb4\x58\x74\x26\x0e\x06\x5f\x56\x8e\x1f\x5f\x5b\x98\xef\x83\x15\x5a\xf2\xc9\xd3\xc2\xaf\x7c\x91\x21\xa5\xb5\x8f\xa8\xb7\x29\xe0\xf3\x65\x26\x45\x30\xad\x5e\xf0\x83\x4e\x13\x78\xcf\x74\xee\x35\xa0\x79\xb5\x09\xa4\x4d\x53\x95\xe5\xca\x7d\x98\x79\x9e\x20\x0f\xc1\x3f\xdd\xa3\x7f\x22\xdd\xf0\x4f\xfb\x68\x56\x3d\x3f\xb5\xb1\xc3\x18\x72\x43\x26\x6a\x87\x7e\xaa\xc1\x62\xe1\x08\x8a\x96\xbc\x5e\xda\xe1\xf1\xd0\x28\xe7\xeb\xf7\x38\x1c\xbc\xdd\x66\x87\x71\x93\xd1\x64\x44\x9e\x85\x00\x45\x66\x83\xee\xad\xd3\x46\xd1\x25\xb7\xf5\x6a\xc4\x2c\xb4\x14\xb5\x37\x17\xb5\x10\x14\xdf\xcc\xab\x73\xc1\x69\x32\xd5\x5d\x48\x87\xd2\xa5\x73\xa2\x0c\xa0\x56\x52\x5e\x6f\x7a\xc3\x34\x5a\x63\x7a\xb7\x49\x79\x59\x02\xcd\xd4\x5f\xae\x41\x9c\x61\x4f\x3c\x0c\xd6\xde\x6e\x06\x2f\x99\xaf\x55\x6a\x48\xeb\x16\xe5\x35\x7c\xf5\x5e\xbf\xc5\x42\x3e\x8d\x6f\x49\x7e\x49\x56\xe1\x3f\xb1\x2f\x38\xf6\x98\x26\x0f\x2f\xb1\x2e\xd3\x0c\xe7\x88\x99\xf5\xc7\xcf\x51\x32\xda\xb4\x69\x42\xc5\xb4\xf1\x84\xc9\x08\xcd\x03\xd4\x5e\x8e\xd6\x41\x0f\x50\x57\x2a\x9e\x09\xa4\x34\xe1\xfc\xa2\x5f\x37\x3f\x72\x2a\x98\x27\x28\x07\x3b\x54\xc9\x75\x28\x77\xd9\xc0\x88\xf1\x44\xf9\xad\x5c\xa9\x4a\x10\xcc\x5f\xd9\x39\xa1\x0c\xc7\x8e\x41\xfb\xb0\x13\xc7\x58\x67\xc3\x18\xcb\x65\x73\xdb\x68\x23\x85\x62\x7e\xca\x8d\x23\x2d\xd1\x69\x70\xa2\x18\xcb\x29\x8a\x26\x9b\xc5\x36\x9c\x15\x5c\x46\x9a\xd6\x4b\x30\xc4\xa2\x28\x03\xa3\x87\x01\x31\xd0\x0b\x25\xd5\xd2\x39\x22\xd0\x13\xef\x3a\xd4\x7b\x9e\x96\x62\xe4\x0d\x0d\x33\xa2\x64\x76\xf8\x8a\x92\xfa\xab\x72\xae\xe9\xde\x7b\x95\x03\x37\x98\x94\x8c\xe9\x26\xf0\xea\x27\xd7\x60\x82\xbc\x2b\x41\xfb\x0d\x88\x1f\xef\x26\x65\x04\x50\x30\xc8\x82\xb2\xbb\x47\x59\xa8\xc2\x40\x90\xc3\xd8\x01\xbc\x1a\xac\xc3\x7f\xfa\x47\xd7\xb8\x73\xf9\x92\x3f\x2a\x2b\x11\x86\x36\x11\x23\x4e\xcd\x54\x96\xc5\x62\x52\xd8\x1e\xb1\x02\x18\x29\x47\x22\xae\x40\xa0\x22\x6e\x87\xd1\xa5\xc9\x54\x21\x85\xad\x80\x36\x78\x6d\x22\x1f\x21\x88\x72\x03\xbe\xa7\xb4\xa5\x54\x76\xd3\x7c\x56\xbe\x88\xd9\xc0\x96\x93\x16\x8c\x7a\x2d\xa8\x3f\x41\x17\xc1\xb9\xd0\x28\x6e\x8b\x2a\x42\x9c\x82\x93\x43\x76\x84\xdc\xf8\xcc\xbd\x65\x31\x5b\xa5\xe9\x3d\xeb\xa4\x3e\xe0\xfd\x29\x8c\x8d\x13\xf7\x9e\x51\x57\x97\x36\xbd\x29\xed\x7d\xe3\x0f\x67\x20\xfb\x01\x36\xed\x0d\x24\x42\x2e\x3f\x37\xc9\xec\x8f\x9c\xd2\xfe\x77\xb0\x1b\x41\x8e\x9f\x5a\x31\x29\xe0\x33\x4c\xb2\x7a\x66\x6c\x78\x50\x99\x64\x57\x0d\x08\x20\x1a\x60\x8c\xfc\x04\xbe\x53\x5e\x99\x69\x14\x2d\x76\xbb\x49\xaf\x43\x54\x63\xb8\x8e\xca\xa3\xf3\x78\x7d\x1e\x87\xd3\x01\x83\x2e\x8a\x37\x99\xcc\xa2\x4d\x6f\xd6\xc3\x10\x8d\xb2\x13\x3a\x46\x07\x3d\x7b\xb5\x6e\x2a\x8f\x32\xa7\x35\xd1\x97\x54\x53\x17\x19\xcf\x94\x56\x1f\xa5\xb1\x0b\xe7\xcf\x80\xf2\x58\x2e\x36\x66\xea\xa1\x48\x6a\xbe\x9a\x63\x3e\xf2\xd2\xe6\x76\x74\x8b\xb1\x13\x86\x60\x53\x36\xbc\x08\xfe\xf9\xd2\x0a\x33\xd9\x69\x3e\xbc\xcc\x8d\xac\x3f\xf2\xc3\x29\xb3\x7a\x24\x98\xa9\xaf\x6e\xa7\xd7\xe0\xb2\x6a\x38\x1f\xa0\x61\x9b\x87\x89\x91\x4c\x5d\x98\x62\xd9\xa0\xcf\xcd\x0b\x82\xc5\x62\xb6\x1b\xe1\x04\xdc\xe6\x48\x19\x11\x0c\x86\x28\x5f\xc8\x37\x90\x0d\xf1\xb2\x7e\x76\x16\xf1\xf3\xf5\x67\x45\x68\x54\x78\xa2\x2b\x39\xbe\x94\x22\x35\x41\x5d\x93\xe6\x7c\x47\x92\xa0\x08\x5e\x5b\x2d\x66\xca\xc3\x87\xab\xd7\x17\x5b\x66\x58\x3a\x87\xa4\x53\xd2\x3b\x2b\x8a\xaa\x98\x06\xef\x5c\xb6\xf4\x6c\xf3\x70\x4f\xdf\x8c\x14\xb9\x99\xbc\xfc\x3e\x83\xd2\x7c\x56\xcd\x92\x4b\x97\x14\x2a\x98\x56\xcc\xc7\x25\x4c\x82\xe1\x3e\x84\x66\x86\x79\xfb\xa0\x9c\x10\x6f\x5f\x04\xc9\x49\x72\x3a\xad\x66\xbd\x4f\xa7\xf3\xfb\x23\x58\x50\x11\x38\xad\x68\xc4\xaf\xd6\xb6\xf9\x3c\x46\xcf\x92\xac\xde\x68\x64\x82\x02\x75\x82\x9c\x8a\xa0\x6d\x72\xb7\x19\x13\x16\xb4\x15\xc9\xe9\x6b\x39\xfc\x5e\xdf\xb6\xbd\x41\xd9\xf2\xf5\x2c\x7e\x41\x45\x07\x1e\xfd\x26\x22\x3f\x40\x44\xe0\x1e\xfb\x07\xb6\x95\x4b\x33\x75\x66\xab\xd5\xa0\x73\x79\xbd\x4e\xa7\x2c\x01\x54\xad\x25\xeb\x64\x74\x1a\xf0\x12\x00\x02\x2d\xcc\x46\xa4\xb9\x26\x93\xa1\x3f\x0b\xa5\xe6\x2c\x1c\xe3\xe3\xf2\xf2\xc9\x93\x5c\xd1\xa0\xe3\xbb\x14\xe9\xbd\x44\x8e\xe4\xe4\x52\xa8\xf7\x3c\x08\x3c\xde\x5f\xa5\x60\xef\x55\x39\x14\x78\x75\x4b\x15\x71\x2c\x96\x13\xbb\x32\x93\x1d\x2e\x97\xcd\xe2\x31\x7a\xbd\x06\xbf\xde\xe7\xe3\x90\x83\x12\x84\x47\x71\x28\x44\x94\x5b\xca\x63\x15\xe5\x21\x87\x4d\x84\x66\xd1\xaf\x09\xcd\x00\xbf\xd3\x68\xa0\xa8\x88\x78\x22\xed\x62\xae\xd2\xf8\x04\xd9\xa5\x8a\x12\x01\x13\x37\x54\xa3\xad\x96\x1e\x27\x45\x59\x4c\x51\x4d\xe3\xb9\x18\xe7\x8f\x44\xcf\x8a\xc8\xc5\x82\xdc\xbf\xf8\xac\xe1\xa1\xd3\x4b\x09\x19\x83\xd6\xb7\x5e\x2e\x95\xe4\xbd\x5e\xd2\x31\xfa\x47\xc6\x59\xc4\xcb\x98\xc7\xeb\x0f\x13\x5b\x33\x5d\x50\x8f\x7d\x6e\x56\x60\x18\xe8\x40\x4a\x34\x0d\x83\x64\xce\xaa\x32\x5b\xb8\x8d\x91\x32\x41\x92\x64\xe4\x29\xcd\xce\xda\x65\x9a\x96\xed\x14\x1f\x08\xf8\xfa\xb3\x01\x4c\x6a\xc1\x4b\x86\x02\xe8\xa2\x40\xc8\x28\x2b\x92\x1c\xb7\x3d\x0b\x4b\x50\xcc\xaf\xa3\xa2\xfb\xb7\x01\x38\xd3\x3c\x44\xbe\xba\x16\xec\x38\x94\x7f\x7d\xc7\xfc\xa6\xea\x99\x52\x1e\xe9\xbf\xab\xd7\x3b\xdf\xde\x92\x29\x41\xfb\x07\x59\xe5\xe7\xa1\xd3\x53\x39\xc8\xff\x53\x6a\xef\x38\x5b\x28\x46\xfd\xd7\xb8\x28\x99\x11\x28\xfb\x20\xb1\x28\x93\x84\xb3\x32\x1b\x58\x37\xc3\x78\x3c\x44\xd0\x10\x0c\x87\x3c\x82\x39\xe8\x87\xd1\xae\x9b\x65\x9d\x7a\x27\x94\xb7\x9e\xb4\xfa\x05\x06\xc6\x87\xc3\x59\x92\x2a\x76\x63\xd4\xe9\x4d\x20\xe5\xdc\xac\xf2\xf7\x20\x36\x7b\x11\x86\x52\xe1\x0e\x04\x9c\x07\x25\x76\x01\x94\xe8\xf7\xf7\x82\x0b\x91\x34\x47\x0f\x17\x6d\xcb\x51\x28\x4b\xfa\x1d\x24\x4c\xe5\xf4\x0e\xe5\x70\xf3\xa9\xca\x8b\x2a\xf5\x3d\xde\x93\x2a\xf7\x3d\xf6\x2f\x35\x6c\x52\xe8\x5f\xce\x20\x34\xac\x7b\xf6\x59\x18\xcf\x95\x41\xaf\xbb\x3f\x13\xab\x08\x87\x1d\xbc\x31\x41\xfb\x8c\xbe\xea\x9a\xa0\xd5\x2c\x99\x47\xb2\x15\x92\xa4\x73\xbb\xa3\x70\x96\x34\xad\xd3\xc1\x99\xe9\xc4\x89\x30\x01\xc6\xd5\x90\xa0\xa0\x1e\x45\x6c\x38\xa0\x6f\x4c\xe7\xf3\xf7\x69\x44\x3d\x87\x82\x7a\x15\x61\x0e\x84\x49\x2a\xd4\xd4\x68\xa5\xa9\x37\xae\x6b\x9d\xdf\xf5\xe5\x1f\x95\x5f\x2b\x2f\x92\x0f\x0d\x4f\x6f\xc8\xc8\x96\xee\xc4\xc2\xc0\xeb\xa0\xfb\x15\x60\x07\x51\xcf\x71\x83\xe9\x51\x10\xbb\xe7\xe3\x1a\xf2\x59\x69\xf6\xe2\x1f\x29\xcf\x4c\x01\x12\x40\xb0\xe2\x20\x76\x93\xe4\x03\x3f\x05\xf1\x5b\x94\xbf\x28\xff\x5d\xb3\x61\x76\xcf\x43\x4f\xd0\x37\x28\xef\x2a\x5f\x5d\x70\x3a\x40\x58\x4f\xde\xb1\x8f\xe9\x41\x18\x57\x20\xec\x45\x38\xc7\x08\xcb\x7a\x25\xa1\xdc\x04\x83\x9b\xaa\x6a\x07\x2d\x7a\xc4\x81\x6c\xc4\xe3\xe1\x83\xc1\xf8\x00\x22\xfc\xe2\x79\xfd\x60\x96\x77\x7c\xab\x39\x02\xd4\x8d\x98\x83\x82\x53\x0d\x50\x5a\x9b\xa9\x9c\xc6\x25\xe2\xf9\xbc\x3c\x3d\x78\xf1\x17\xb7\x31\x8f\x4e\xbf\x20\x5d\x35\xef\xb5\xe1\x23\x4f\x92\x4f\x4f\xaf\xcd\xb8\xcc\x99\x84\x14\x38\xf0\xda\x59\x7b\xef\x1e\xfd\xcf\x96\x5b\xe3\xde\x9e\xf3\xc8\xcf\xe7\xdf\xb8\xd4\x64\xaf\xfd\xb8\x25\xda\x35\x7d\xf6\xc3\x87\xda\x6d\x40\xbc\x52\x74\x02\x70\xc9\xdb\x9b\xd7\x29\xf7\x99\x6f\x38\xbd\xb2\xf2\x98\x2a\x3b\xe5\x18\x96\x5d\x0c\x46\xe3\x8b\x33\xc9\x44\x34\xea\x12\x74\x7a\xbd\x81\xab\xa1\x39\x04\x1d\x59\x5b\x17\x11\xad\x4e\xeb\x48\x36\xe1\x74\x1a\x7c\xbe\x0a\x78\x94\x40\x07\xd4\x60\x80\x22\x34\x88\x1c\x91\x9c\x08\x4d\xb6\x04\xe4\x00\xc5\xab\x1a\xee\xa9\x2a\x4b\x54\xff\x53\x46\x20\xdc\xf5\x6f\x27\xce\x1f\xff\x3c\xb5\x2b\xa5\xfc\x5b\xf9\xc3\xb7\x93\x68\x93\x51\x79\x1f\x84\xcd\xc0\xf6\xf9\x37\x8b\x15\xc9\x55\x39\x86\xe5\x1a\x25\x6a\xd0\x09\xc3\xc3\xd3\xd2\x66\x23\xa4\x72\x96\x0d\x38\xa5\xb8\x09\x1e\x21\xc9\x5a\x17\xed\xf0\x3b\x06\xb2\xe5\x7e\x3f\x1f\x89\x54\x41\x41\x5b\x6d\x42\xa9\x84\x55\x4a\xb7\x93\xca\xb8\x40\x14\x3b\x4e\xd6\x68\x2d\x10\xb3\xe2\x37\x8b\x7b\xf2\xf7\x66\x37\xec\x4a\x1d\xb8\xf9\xdb\x48\xbc\x79\xb6\x49\x79\x17\x44\xcc\x47\x6e\x3d\x89\xdc\x11\x6b\x1a\xb4\xc3\xa7\xe1\x18\xb1\x0a\x7f\x8d\xb9\xfc\x31\xaf\xf9\x4f\x54\x3e\x2b\x72\x3b\xe8\x47\x7d\x74\xc9\x7c\xaf\x9d\xca\xb5\xc6\xbc\x00\xbf\xe7\x8f\xda\xf7\x2c\x54\x7b\xed\xa6\xe5\x7b\xed\xc6\xfe\xa9\x74\x33\x0f\x40\x5b\x57\x49\xec\xc8\x64\x44\x53\xbc\xd2\x54\x89\xf2\xdf\x5e\x96\x31\x0b\x42\x99\x83\x71\x24\xaa\x7c\x3e\x17\xe5\x0a\x8d\x64\x5d\xde\x4a\xe8\x1d\x8b\x15\x23\x59\x68\xfe\xf5\x82\xb9\xc0\x7d\x3e\x31\xb9\xb0\xad\xf4\x4e\x58\x5b\xef\x09\x32\x63\xb6\xd4\x09\x9c\xbc\x5a\x88\xa3\x5d\x8d\x16\x5d\x10\xd7\x80\x08\xfc\xfb\x71\xa9\x6f\xb2\x62\xbd\x19\xdc\x6d\xde\xa7\x44\x95\x77\x94\xcb\x95\x2b\x73\x37\xc4\x6f\xbd\x9e\xde\xb0\xa2\x72\x5d\x49\xfe\x5b\x4b\x96\xb5\xd3\xef\x7d\xa6\x5c\xa6\x6c\xd3\xae\x87\xbb\x40\xd7\x8e\xbb\xe7\x90\x43\xf8\xcc\xab\x52\x7a\x69\x02\x9e\x79\x41\xe4\xa7\xe9\x08\x97\x9b\x70\x07\x83\x1e\x8f\x8f\xf7\x02\x96\x95\x0d\x5e\x43\x28\xcc\x02\xe0\x43\x87\x1b\xf4\x57\x5d\x3a\xd7\x40\x56\xa7\xf3\x52\x01\xde\x2b\x99\xed\x03\x59\xab\x39\x5f\x73\x57\x7a\x0a\xd8\xc6\xa7\xce\x0a\x93\xe7\x4a\x27\x5c\x72\x17\xac\xa2\x95\x5e\x91\x4b\xa2\x29\xb7\x9f\x70\xfd\xdb\x83\x12\x6a\x28\xf9\x99\x4b\xa6\x29\x77\x8e\xbf\xf2\xad\x42\x79\x35\x2d\x17\xf0\x14\x8c\xf7\x8e\xe0\x1c\xce\xf2\x4c\x8d\xd7\x83\x28\x89\xa1\x84\xdd\x6e\x9b\xe8\x70\x08\x82\xcd\x16\xa2\x82\x82\x4b\x76\x0d\x67\x65\x41\xf2\x68\xd4\xf0\x9e\x3c\x35\xfc\x23\x59\x95\x16\xbe\x88\x14\xbe\x18\xab\xa2\x50\xb8\x9d\xdb\x43\x13\x51\xc3\x6b\xdd\x15\x27\x27\x87\x57\x7e\xb9\x7d\x9b\x72\xe7\xd7\xf1\xc3\x2b\x40\x8d\x21\x72\x14\xf1\x60\xec\x49\xe8\x7b\x22\xee\xb3\x10\xd1\x93\x29\xf3\x05\x83\x5e\xaf\x27\x04\x03\x20\x4f\xc4\x1c\x0e\x79\xfb\xb3\x21\x29\xe0\xe1\x0b\xf4\x67\x2a\xf5\x59\x2e\x52\x48\xe6\xa9\xcf\x8a\x6e\x4a\xbe\x96\xfa\x0c\x85\x0a\x5f\x4f\x7e\x86\x3d\xcd\x9f\x4e\x4c\x7f\xf6\x48\xce\xd5\x54\x73\x33\x38\xc7\x19\x25\xd6\x65\x5a\x3d\x16\xb7\x9b\xe7\x25\xca\xee\x35\xfb\x7c\x91\xb0\x1d\x7e\xb2\xc7\x32\x92\xe5\xd5\xd2\x32\x41\x0e\xfb\x54\xf4\x9e\x80\x4c\xf1\x76\xc1\x0e\x83\x71\x81\x80\xe1\x1c\x0d\x3d\x6e\x4d\x26\xb6\xf1\xfc\xde\xa5\xfc\x2c\xa9\xe2\x7a\xcf\xfc\xd6\xea\x04\xc2\x78\x78\x33\xed\x4f\x92\x20\xbb\x67\xee\x3d\x17\x6d\xa8\x9d\x6b\xf7\x2f\x9b\x5a\x71\xf2\x84\xe7\x63\x6d\xca\x21\xa5\xc7\x95\x40\x5b\x6a\xcd\x5f\xc0\xb5\xbf\x9f\x30\xf3\xf9\x99\xf2\x98\xf2\x2c\xce\xb1\xc1\x7d\x56\x83\xeb\x4d\xd6\x67\x32\x4e\x9b\x2c\x0b\x82\x9d\x15\x5d\xd0\xa5\x74\xbb\x01\xd4\x31\x8f\xd7\xcd\x3b\x6d\x03\xd9\x01\xe7\xb0\x93\xe4\x9d\x01\x27\x7a\x58\xe7\x64\x4c\x94\xd3\x09\x55\x15\x43\x7b\x8b\x12\xba\x86\xd5\xd1\x45\x65\xae\x85\xdc\xda\x89\xd9\xd0\xc2\xcc\x11\x6c\x4f\xbe\xbe\x10\x07\x0d\xb9\x74\x1b\x5d\x73\x73\x95\xa2\xfc\xe3\x62\xb4\xbf\xdc\x73\xaa\x96\x6c\x0a\xf7\x96\xe6\xdc\xa8\x43\xc7\xf7\x29\xff\x42\x5b\x4b\x90\xbf\xf7\x1c\xb8\xbc\x90\x73\x1b\x9f\xb3\xde\x96\xe9\xb2\xd1\x56\x2b\xc3\x18\x0d\x6e\x68\x46\x5d\x4e\x81\x22\x49\x51\xbd\x4f\xf1\x7a\x6c\x34\x94\xab\x4a\x21\xa4\x37\x3b\x45\xab\xd1\x6c\x1c\xce\x4a\x66\xca\xc5\x30\x24\xc6\x42\x24\xc6\xdd\xaa\x8c\x93\xe9\x37\x64\xaf\x43\x27\x4f\x5e\xc3\xed\x47\x8e\x7d\x7d\xee\x1a\xed\xc0\xad\x27\xcd\x5e\xef\x53\x2f\x70\x8b\xf3\xd7\xe7\x65\xba\x61\xbc\x67\x32\x19\x39\xc2\x66\x33\x18\x8c\xb9\xa4\xa9\x91\x12\x85\x93\xe5\x4a\x6d\xac\x0d\xc6\x06\x36\x89\x37\xf0\xc5\x79\x52\x6d\x3f\x9e\x98\x24\x9d\x28\xa7\x5d\xca\x7b\x87\x77\xe5\x89\xcc\x77\x78\x2b\xbe\x54\x92\xce\xce\x05\x7b\xc5\x71\xf9\x12\x8c\x19\x65\x36\xb8\x19\x0f\x4d\x42\xaf\x99\xf6\x78\x42\xd0\xe9\x2f\x8b\x06\x3d\x2a\x2a\xb3\xea\xf0\x13\x3e\x9e\x22\x3d\x21\x9a\xa0\x8b\xaf\xcb\x55\x6b\x3f\xde\xdd\xb7\xe5\x6e\x89\xb4\x90\x15\x7a\x10\xe9\xaf\x8b\xc6\x11\x15\xd6\x3b\xaf\x6d\x4f\x3f\xfd\x35\xc1\xf8\x4f\xbf\x6b\x56\x66\x00\xc5\xf3\x35\xc1\xf8\x57\xfb\x50\x22\xbb\x10\x8f\xfb\x11\x87\x99\x89\xe7\x39\xd6\xeb\x76\xdb\x09\xbf\x1f\x06\x6b\x0e\xd6\x11\x08\x7a\xfd\xb2\x5b\xee\xcf\xda\xa1\x87\x40\xd9\x66\x67\x29\xca\x88\xea\x9c\xd4\x32\x03\x0d\x44\xb9\xe4\x10\x2b\x3e\xc1\x71\x4b\x40\x2e\x18\x07\x27\x8b\xc5\x75\x48\x34\x69\xf2\xda\x89\xa3\x71\xb3\xf2\xa7\xac\xf2\xe1\x6f\xa6\x9f\x2c\x22\x47\xdc\x5d\xef\x3a\xf1\xbe\xfa\x48\x99\xa1\x9b\x0b\xe5\xe4\x46\xb5\x20\x0c\x6d\xb3\x49\x26\x2b\xa2\x96\x37\x9b\x64\xb7\xdb\xe1\x90\x04\x92\xa2\x24\x93\xe4\xf1\xba\x3c\x12\x96\x16\xc5\xb2\x02\x4f\x39\xa0\x1e\x62\x28\x6d\xc2\x20\xd8\x98\x12\xac\x48\x67\x11\x7a\xfe\xc4\xbd\x6f\xf9\xee\x37\xdc\x0c\x18\x31\x82\xfc\x7e\x12\x41\x6e\x2b\x51\xef\x98\x9e\x7f\x6a\x74\x57\xf5\x7b\x4f\x3d\x64\x52\x22\xd8\x2d\x01\x7f\xbb\x17\xfc\x86\x94\x73\x27\x19\x3c\xa7\xc2\x5f\x6d\xa1\x77\x7f\xf5\x7e\xce\x15\x39\x7e\x80\x5a\x8d\x18\xa5\xb5\x7d\x84\xce\x2e\xcc\x83\x19\x22\xd6\x66\xd2\x7e\x8e\x73\x7b\xf4\xba\x80\x27\x60\x63\x98\x20\xcb\x86\xf0\x05\x51\x28\x14\xb1\x85\x59\x8e\x0b\xfa\x7c\x9e\xfe\xac\x8f\xb7\xc8\x83\x59\xc1\x22\x05\xf4\x0e\x86\xe8\xcf\x32\x12\x95\xe3\x60\x2b\xd4\xcb\xa2\xf1\x97\x9e\x6a\x05\x5d\xcc\xdd\x0f\xa1\x8a\x10\x10\xa1\xc8\x3c\xe2\x4e\x31\x21\x66\x88\xbe\x1b\x6f\x9d\xc7\x31\x25\xe6\x60\xa6\x7b\x4e\xcb\x44\x94\x98\x20\xbc\x00\xef\x26\x95\x14\x53\xb9\xeb\xb7\x97\xb5\x8f\x27\xc5\x84\x71\x68\x35\x74\xe0\x9b\x70\x1c\x3a\x80\xfd\xd3\x03\x30\xce\x26\x91\x0f\x0b\x23\x51\xec\x9f\x82\x55\xd8\x87\x25\xdd\x05\xbc\x08\xc4\xb1\xfd\x11\xf2\x61\x11\xc7\x36\xe6\x6d\xbd\x9c\x28\x62\x2f\x2a\xbc\x87\x3d\x98\x7b\x0f\xb1\x1a\x2c\xc1\xd8\x51\x14\x19\xc8\x63\x47\x61\xae\x6e\xcc\xf5\xd2\xad\x7e\x0f\x71\x3f\xc6\x8e\xa2\xc8\x2a\x9b\xf6\x3d\x63\xc3\xd0\xa7\xae\xc5\x3e\xf6\xa5\xf8\xb3\xdd\x63\x7f\x65\x6e\xc6\xfc\x31\x07\xf1\xe7\xfc\x13\x5a\x84\x2f\xf0\x78\x2b\xb4\xf1\xae\x51\x7d\xee\x48\x61\xbc\x88\x4b\xe9\x37\x78\xbc\x7d\xda\x78\x2f\x52\xc7\x1b\xcf\x8f\x97\x98\xa6\xe2\xb9\x59\x59\x80\xf9\x35\x09\x19\xfe\xcc\x54\xea\xc7\x56\x96\xf4\x14\xfe\x9d\xfd\x97\x50\x8e\xfe\x1d\xcf\xe7\x41\x70\x13\x1e\x6b\x75\x7e\x3e\xe8\x67\xd6\xa0\xf9\xa0\x9f\x41\xdc\x35\xe7\xaa\xb3\xa9\xd6\x90\xb0\xf2\x31\x02\x5a\x17\x35\x46\x20\x56\x93\x7b\x35\x4c\xad\x86\xdc\x7b\xb4\x18\x61\x7e\x2e\x46\x80\xdf\xb3\x56\xc3\xd4\xea\xcf\xaf\xcb\xc7\xf0\xb3\xde\xc7\xef\x79\x49\x5b\xbb\xa3\xda\x7b\x5a\xf2\xef\xc1\x7c\xc2\xf8\x3d\x7f\x52\xc7\xa3\xbd\xa5\x31\x37\x1e\x54\x6b\x01\x63\xf2\xcd\xf8\x5e\x65\x76\x26\x4e\x48\x92\x4f\xa0\x28\x39\x10\x08\xfb\x38\x2e\x14\x0e\x3a\xfd\xce\x91\xac\x83\x20\xa0\x6f\x43\x10\xac\xcf\x4f\xb1\x08\xe5\x83\x15\xb5\x83\x3d\xe7\x4a\x97\x82\x4a\xa5\x72\x6c\xef\xb8\xda\x9b\x56\x43\x85\x7c\x89\x7c\x2c\x0d\x72\x59\x4a\x1d\xf9\xe8\xee\x03\xca\x6b\xca\x5f\x66\x3f\x3f\x35\x57\x08\xff\xdd\xfd\x56\x70\xcd\x85\xcb\xee\x0a\x76\x64\x1b\xa8\x15\x02\xf9\x76\xf4\xbe\xb3\x7e\xf6\x5b\x97\x5d\xab\x7b\xdf\x74\xa3\xe9\x54\xf0\xae\x59\x77\x2f\x88\x2c\xc1\xf6\xe7\x6a\xa5\x97\xba\x19\x63\x0b\xce\xc9\x54\xba\xcc\x66\x89\xf3\x7a\x79\x59\x0e\x86\x24\x8a\x0a\x5a\x5c\x08\xd0\xd7\xe5\x72\x10\x4e\x2b\x2a\xa4\x93\x1c\x3c\xc1\x0e\x16\xf9\x65\xe3\xd8\x39\x8a\xf9\x91\xd5\x29\x88\x05\x66\xe4\xf2\x04\x28\x1a\xba\x5a\xc9\x4e\x3f\x97\xbd\x27\xe5\xdb\xbc\xed\x9e\xc7\x57\x6f\x5e\x6c\x00\xe7\xde\xda\xbc\x16\x55\xd0\x51\x2c\xa7\x9c\x75\xfd\x95\xd7\x2a\x9f\x28\xbd\xf1\xf2\x59\xc1\xe7\x0f\x5d\x77\x45\x3b\x78\x1e\x97\xd0\xd5\x29\x09\xd7\xa3\x0f\xec\xfd\x40\xe5\xab\x1f\xfb\x17\x5c\xd7\x33\xd9\x65\x50\x46\x2f\x63\xfc\xb4\x7d\x24\xa3\xea\x6f\xa0\xa0\xbf\x2a\x4f\x8b\x64\x8d\x91\xfb\x88\x8f\xb0\x24\xe7\x21\x49\x3e\x41\x04\xc6\x9e\x7d\xd8\xeb\xed\x4b\xe4\xdf\x73\x30\xf7\x1e\xa8\x9f\x5f\x6a\xfa\x50\x91\xd7\x4f\xf5\x3d\xf3\xf3\x7c\x2f\xab\x89\x5f\x69\x1a\x51\x9e\xd3\x2b\x15\xd7\x10\xef\xdb\x7a\xed\x3d\x2f\x6a\xfb\xb6\x32\xff\x1e\x8c\x07\x88\xdf\x33\xa4\xbd\xe7\x4e\x6d\xdf\xc6\x0a\x98\x6f\x79\x7c\x44\x17\xb4\x9f\x33\x32\xb1\x20\x3c\xdc\xe8\x90\xdd\xed\x36\xd1\xa6\x70\x24\x28\x8d\x64\x4d\x41\xe8\x66\x05\x83\x84\x5e\xef\xc3\xc8\x88\xd6\x71\xc8\x88\x25\x4e\x72\xc1\x3c\x8e\xc7\x46\x8c\xd5\x37\x09\x69\xf5\xd2\x03\x05\xfc\xa4\x2e\x74\x02\x16\xe2\x5b\x2b\x8e\x5c\x14\x18\x4d\x1b\xaf\x23\x4f\xbd\xf1\xd2\x1b\x7e\x5b\x4f\xfe\x78\x1c\xfc\xe1\x8a\x3d\x80\xbc\x7d\xda\xac\xa7\xdf\x22\x3f\x7f\xe6\x5d\xe5\xa3\x0f\x88\x3c\xe7\xbe\x8a\x7b\xe8\x80\x7e\xe3\xac\x4c\xdc\x0b\x9d\x61\xca\x07\x9d\x62\x03\x65\x80\xce\x22\xa2\xe3\xf6\x7a\xbd\xa4\x89\xf2\x7a\x09\x1d\x0e\x39\xad\x84\x65\x1c\xf4\xe1\x49\x67\x51\x8c\xae\x16\x43\xe4\x7f\xea\x14\x30\xad\x41\x11\xdc\xe1\xee\x59\x7b\x3c\xca\xf5\xfa\xe9\xa0\x79\x7b\xef\x85\x61\xb0\xbc\x04\xe1\x70\xd9\x2b\x77\xb5\x4f\xda\xb0\x9d\x0c\xff\xf3\x91\xcb\x55\x4e\x9f\xbc\xfc\xe8\x9b\x4a\xe4\x47\x53\x35\x27\xca\x8f\xbe\xb9\x44\x7e\x34\x55\x99\xd7\x03\x02\xda\x85\xaf\xb0\x3e\xbd\xaf\xbd\xa7\x59\xd3\xa7\xbc\xbd\x53\xf9\x13\xb1\x7d\x51\x54\xfb\xc2\xab\xda\x94\x28\xd8\x3b\xe2\xb2\xb1\xbf\xb1\x03\x58\xbf\x7f\xa9\xea\x37\xf8\xa9\xaa\xdf\x41\xa6\x84\x63\xe8\x5a\x46\x12\x34\x8e\x21\x72\x5f\x16\xdf\x88\x94\xe7\xb8\xf0\xd4\x77\x1c\xcc\xbd\x03\x8e\xe5\x0b\x6d\x2c\xf1\xfc\x58\xd4\x77\xcc\xcf\xbd\x83\x58\x3d\x43\x1d\x4b\xf2\x84\xb1\x7c\x9a\x1f\xcb\xed\xe0\xc7\xe3\xf7\x08\x7e\xcf\x97\xcc\x3d\xf9\xb1\xdc\xde\xa0\xbe\xa7\xa6\xe8\x3d\x38\x0f\x81\xc7\xf3\x2b\x6d\x3c\x2f\x69\xef\x29\xac\x31\xbe\xa3\xc7\x6b\xf3\xb9\xb6\xc6\x0f\x68\x7b\x2d\xb7\x47\x50\x1f\xd3\x0c\xdc\xd3\x2a\x10\x93\x32\x61\xe8\x4e\x08\x70\xda\x3a\x9d\x68\xb4\xa3\xbe\x55\x93\x01\xb5\xb4\x1a\x26\x4a\x34\xa9\x26\x37\xdf\x3f\x5b\x9a\x54\x2a\xf4\x45\x82\x37\x72\x39\xa4\xe2\x06\xc8\x65\x5e\x85\x86\x41\x7a\x51\xaf\xa3\x5a\x9b\xac\xac\xd4\xfa\x53\xfb\x32\x65\x61\xd6\x62\xb3\x39\xbc\x26\xa8\xc8\x15\xf1\x50\x00\xb5\xa5\x7a\x59\x5b\xd4\x6a\x15\x1d\x46\xce\xc6\xc1\x38\xdd\x56\xa0\x01\x7b\x11\x55\x94\x17\xd7\x20\xab\x5c\xa3\x6a\x3f\x6a\xa1\x19\x55\x97\x6f\x25\x53\x11\x7c\x8b\xfb\x51\x2f\xdd\x3b\xd2\x85\x9b\x51\x6b\x12\xcb\x95\x0f\x7f\x50\x57\xb9\xeb\xc0\xae\xfb\xbb\xa7\x14\x37\xa4\xae\xba\x34\x15\x99\x33\x1b\x75\xa3\xd6\x78\x95\x2a\xb0\x4f\x77\xd9\x59\x2b\x77\x76\xba\x16\xcc\xcc\x75\xa4\x42\xd9\xfd\x0d\x9e\xad\xff\xc1\x72\xf9\x8d\x76\x6e\x3e\xa8\xe9\x7e\x7d\x5e\x2e\x98\x7b\x15\xcb\xe5\xb8\x26\xbb\xb9\xa5\xba\x0f\xe5\xa2\x28\xbd\x4c\x03\x8e\xfd\x37\x65\x5c\x0e\x11\xc6\xc0\xe1\x68\x28\x44\x00\x54\x94\x8e\x5c\x0d\x77\x2c\x6a\x97\xec\xa8\x66\x22\x94\x0d\x4b\x92\xd5\x85\x6e\xe2\xbc\x2e\x97\x3c\x9c\x75\x51\x84\x60\x15\x86\xb3\x56\x81\x31\x8d\x64\xf5\x4c\xbe\x00\x71\x7c\x83\x6b\xaa\xe8\x7a\x26\x55\x5a\x65\x80\xaf\xdd\x70\x2d\x99\x7a\xbd\xd1\x05\x42\xc5\xbd\xc8\xe9\x5c\x2f\x32\x78\xf3\xdd\x0a\xe7\xbd\xdb\x16\x4c\x8a\x4c\x75\xba\x92\xeb\x23\xce\xd1\xb7\x4c\xf7\x2c\x79\x4c\xfa\xfe\xd0\x77\xcd\xf4\x69\x99\xc5\x86\xba\xb1\x69\x7b\x67\x83\xb4\xa4\xbc\xbc\xdc\xf3\x87\x3d\x37\x46\xfe\xbc\xa5\xec\xf9\xcb\xa6\x79\xc8\xca\x2d\xe0\xe7\xee\x69\xca\x0d\x7f\xd3\xe9\x94\x96\x2d\x84\x26\xff\x5e\x2c\xff\x46\xc4\x08\x44\xb1\x04\xc7\xd5\x4a\x15\xd1\xca\x70\x25\x81\x6a\xf1\xc3\x44\x53\x9a\xa5\xa2\x15\x34\x13\x83\xbf\xaa\x4d\xa9\xea\xc1\x6c\x25\x17\x48\xa6\xac\x01\x13\xd4\x86\x80\x43\x74\x0f\x64\x1d\x62\x6e\xb6\x39\xe7\xa0\x25\xdf\x6a\x8d\x9b\x6d\x0a\xf9\x50\x4c\xf8\x91\x63\x39\x19\xd7\xb6\x4c\x95\x4c\xfd\xe4\x4d\xcc\x3b\x2f\x5d\x35\xb0\x2e\x11\xc7\x7a\x93\x72\x1e\x3c\x7f\x51\x57\x58\x5d\x07\xff\xea\x4b\x76\x1d\xd8\x72\xf7\x82\xc1\xc5\x93\x8a\x35\x68\xf9\x65\xa9\x47\x93\x3f\x74\x4d\xef\x46\x4a\xa4\x7c\xb0\xf7\x7a\xbc\x1e\x07\x53\x97\x9d\xb5\x7c\x57\xfb\x6d\xb5\x77\xa7\x56\x14\x9a\x9b\x51\xfd\x45\x0f\xae\xbf\xa8\x24\xce\xcc\xb4\xa0\x7a\x1f\x7b\xa5\x48\x10\xfe\x98\xd3\x29\xb2\x66\xc6\x62\x11\x19\x31\x51\xe5\x2d\x1b\xce\x06\xbc\x5e\xad\xf2\x67\x38\x6b\xb6\xb3\x95\x34\x65\xe5\x28\x54\xff\x33\x3e\xc5\x58\x7c\x65\x90\x67\x35\xc3\x0b\x92\xa3\x94\x28\xdc\xb8\x96\xd6\x5d\x00\x51\x85\x5b\xc4\x77\x23\x3a\xcd\x91\x8a\x51\x00\x9c\xbc\x04\xe3\xe5\x46\xf7\xa6\x3f\x5c\xb8\x7b\x6d\xed\x5c\x86\x9f\x54\x79\xea\xf9\x4d\xdf\x5b\x7e\x92\x52\x8c\xb1\x7d\x5b\x5a\xd6\xdc\x73\x7a\x19\xb0\xdf\x21\xbb\xb7\x2e\x9c\xba\x17\x1c\x55\xeb\x32\x7a\x70\x5d\x46\x03\xaa\x2f\xac\x43\xfc\xd3\x76\xa3\xd3\x49\x84\x18\xbf\xbf\xa9\x51\xb4\x5a\x99\xb8\xd1\xd8\x18\xab\x19\xc8\x56\xc6\xbc\xf6\x10\x4f\xd0\x9c\x47\x10\xa0\x8b\x25\xf0\x5c\xae\xac\x1a\xf7\xc0\xa5\xd4\x7e\xd4\x42\x13\x60\x4b\xaa\x30\x59\xf0\x4d\xb5\x19\xb2\x0a\x8e\x91\xbf\x7a\x85\xee\x23\xf8\xfe\xd7\x14\x6a\x9c\xb7\xe4\xfd\x47\xf7\x9c\x52\xd7\x67\xf6\xf7\xcc\x5d\x3b\xb9\xa6\xa4\x62\x63\xa8\x63\x82\x8a\x8d\x3f\x3e\xb3\xff\x99\x0f\x23\xc0\x71\x4f\x72\xed\xe0\xb4\x83\x0b\xb4\xda\x1b\xad\x7e\x2a\x4c\x5c\x94\x89\x1b\x74\x21\xab\xd1\xc8\x78\xc2\x32\x8c\xf6\xbc\x5e\x99\x85\xe1\xaa\x20\x33\x72\xa4\x4c\x16\x04\xa3\xd5\x0c\xbd\x16\x36\xec\xd1\x73\x7a\x15\x79\xc0\x69\x0b\x73\x1c\x65\x37\x53\xde\x50\x48\xd5\x82\x00\x35\xae\x0c\xa7\x25\xd9\x92\x2a\x22\x4a\x2c\x2a\x85\xc8\xe9\x43\x51\xf7\x6e\x5e\x23\x62\xa1\x74\xaa\x54\x2b\x90\x09\xc0\xff\x56\xa4\x09\x35\xca\x0f\x24\xe5\xaa\xf1\xea\xf0\x3c\xe8\x93\x94\xb5\x00\x5c\x6b\x1a\xfd\x8e\xe9\xde\x7b\x35\x55\xd8\xb4\x45\x53\x82\x9c\x32\x5c\xbd\x65\x74\x03\xce\x56\xde\xa3\xd5\xe6\xa8\xfc\xf6\x44\x02\xd5\x20\x25\x2a\x2a\x42\x02\x1f\x93\x79\xd9\xe8\xf1\x94\x41\x45\x08\x55\x55\x3b\x44\x11\xc6\x9c\x55\x89\x8a\xfe\x6c\x42\x92\xcb\xca\x6c\x31\xc2\x6a\xb3\x0e\x64\x6d\x36\xce\x2f\xa9\x60\x1b\x05\x6d\xd0\x9c\xec\x54\xae\x90\xa5\xa8\x6a\xa7\x00\x63\x90\xbf\x40\x2a\xd5\x0c\x6d\xee\xa5\xca\x91\xd2\x45\x50\x5b\x4b\x89\x42\xf0\xca\x5f\x85\x0f\x6f\x2e\x51\x8a\xc7\x47\x85\x5f\x3d\x31\xd7\xa8\xfc\x7c\x5c\xfd\xce\x1f\x56\x82\xf8\x38\x75\xb8\x79\xa5\x72\xbd\x34\x09\xe7\xf4\x60\xd0\xc3\xc8\x50\x07\xac\xd0\x7f\xed\xcb\x44\x1d\xb4\x5e\x80\xb3\xe2\x78\x0b\x6d\x71\x7b\x50\xe7\xe4\x48\x56\x27\xc2\xff\x74\xd0\x87\xe5\x5d\xc0\x55\x8c\x63\x90\xbb\x72\x1a\x77\x43\x86\x2a\xab\x90\x31\x2b\x0b\xa5\x72\xd7\x4a\x51\x51\x85\xa1\x4a\xd1\xf1\xd1\xf7\x3f\xff\x02\xf4\x82\xfa\xc1\x53\x5e\x30\x93\xb7\x9a\x8f\xbc\x7c\x9f\x92\x5a\x12\xbd\xe1\xc1\xb3\xd6\xde\xfb\x3f\xaf\xbc\x0f\x7e\x15\x52\x1b\x54\x02\x64\xf4\x91\x5b\x56\xac\xd3\xe2\xf0\x8f\x69\x17\x8e\xdd\xa7\xaa\x63\x1e\xfb\x98\x95\x71\x0e\xa1\x8a\x58\x99\x69\x0a\x9a\xfc\x81\x00\xc1\xc7\xad\xba\xf2\x72\xab\x13\x9e\x53\x56\x13\x20\x4c\x44\x75\x8d\x5a\xce\x62\xa9\x1c\xc9\x06\x2c\x01\x0b\x27\x50\x5c\x78\x38\xcb\x09\xb4\x67\x38\x4b\x17\xc1\x2c\xe3\x06\xc1\xe2\x89\x8c\x6b\x05\xd4\x24\x45\xe5\x0a\xc6\xe1\xdc\xac\xf9\xa9\xe5\x49\xe2\x81\x1d\x1a\x75\x8c\xc3\x0e\xa7\xca\xca\xb3\xbc\x1f\x1c\x5b\x7a\x55\xe3\x0d\x17\xbc\xff\x0b\xb2\xfb\xe2\x39\x3f\xc6\x73\xbd\xcf\x54\x9b\xee\x5a\x64\x9f\x79\xfc\xd4\xef\xce\xe9\x11\x75\xcd\x73\x2e\xbe\x8e\x7c\x47\xe9\xfd\xce\x8d\xfe\x78\xea\xfa\x3b\xa1\x97\x86\xaf\x68\x8e\x0f\x75\x57\x4f\xee\xd8\xb1\x1e\x3c\xa8\x2c\x38\xe6\xae\xeb\x8e\xd7\x83\xb6\x27\xd0\xbc\xc3\xf0\x4c\x3f\xc6\xec\x27\xca\x60\xcc\xb2\x32\xd3\x18\xd5\x59\xaa\x6c\x04\x1c\xb8\x6c\xb7\xdb\x7c\x36\x9d\x5f\xe7\x4f\x35\xf8\x7c\x61\x63\xd8\xd5\x9f\x0d\x3b\x44\x5b\x7f\x56\x24\x8c\xc9\x81\xac\xd1\x9a\x20\x88\x0a\xaa\x62\x76\x96\x72\x94\x72\xd9\x15\x79\xef\x27\x14\xab\x6a\xb2\x8c\xa2\x69\x63\x54\x48\x4c\xff\xa0\x79\x5e\xf9\x2b\x36\x7c\x80\x97\x03\x6d\x11\xd4\x9e\x7a\x72\x79\xd7\xff\xf4\xce\xbc\xa0\x77\xd7\x9f\xaf\xa8\xd8\x10\xa3\x8c\x35\x77\x98\xc0\x23\xaf\x72\x17\x4f\x9e\x2a\xb7\x00\x4b\x2c\xfc\xda\xeb\x07\x1f\x53\xee\x9c\xd2\x5c\xbe\xa6\x72\x89\xa7\xbf\xac\x67\xdb\xb4\xfb\x4f\x59\x3d\xfb\xc0\xb2\x23\xa0\xe6\x21\x9b\xd1\xbf\x18\x58\x9d\x93\xbe\xda\x59\x57\xb3\x61\xf0\x0c\x60\x7c\xf9\xc1\x9b\xb2\xc0\xb7\x76\xd3\x60\x1b\x59\x65\x73\x5d\xfd\x29\x3c\xc3\x37\xc1\x75\xf8\x14\xf3\xdb\x2d\xc8\x38\x13\x3a\x7b\xa8\x0e\xae\x4e\xa8\x4c\xc7\xd3\x1e\xe0\x01\xf5\xa9\x32\x2b\x6f\xe5\xd5\x06\x49\xa8\xd7\x56\xda\xe3\xf7\x3b\x86\xb3\x7e\x9a\xae\x29\x12\xbc\x2d\x47\xd5\xa0\x36\x73\xe7\x81\x18\x52\x45\x77\xbb\xa4\xca\xdb\x57\xdc\xf1\x1e\x29\xe6\x34\x57\x2b\xa8\xf3\x58\xee\xf4\x47\xc0\x3c\x2b\xad\x2c\x7c\xfd\x07\x7a\xd3\x92\x15\xe7\x49\x9b\x36\xed\x3a\x94\xda\x18\x9b\x75\x5a\xd3\x23\x8f\xbf\x7d\xec\x89\x5b\xae\xd9\xc5\x3a\x33\xed\xb3\x17\x49\x48\xe8\xca\xab\x3b\x77\x76\x56\x4c\x0f\xcc\x1b\xd6\xe9\x36\xeb\xb9\xbb\x2f\x3d\xe2\x75\xfe\x08\xd4\x25\xf6\xee\xbb\xf9\x65\x87\x78\xd1\x39\xe1\xe8\xa5\x55\x1d\x53\x36\x6d\x81\xf3\x9d\x0f\xe7\x3b\x0b\xc6\x67\x35\xc4\x29\x99\x44\xc2\x4c\x21\x1e\xc7\x98\xd9\x46\xfb\x19\x3f\x93\xac\x8d\x09\x36\xc1\x36\x90\xa5\x05\x5a\xe0\xfc\xa1\x10\x8c\xce\x42\x56\x8e\xe8\xcf\x72\x8e\x6f\x33\x53\x94\x6a\xcf\xcb\xb1\x06\xe0\x5e\x9f\x7c\x6b\x3a\xae\x74\x69\x2a\x50\x4e\xc8\x7e\x92\xda\xdf\xd2\x6a\x4d\x02\x4b\x59\xf0\xd9\x1f\x5d\x70\xeb\x70\xc0\xb5\xe0\xd4\xb3\xc4\x75\x4b\x36\x0f\xf6\x44\x86\x7d\xad\x33\x2a\xef\x5e\xff\xfd\x17\xcf\x5f\x01\xa6\xcc\x91\x7d\xf1\x96\xb6\xf9\x0b\xb1\x00\x1b\x36\x9c\xb3\x60\xf6\x8a\xb5\xf3\xdb\xfa\x7c\xf2\x8a\x0f\x03\x2a\x97\x84\x65\xe1\xdc\xb3\x06\x2a\x90\x4f\xb6\x09\xc6\x07\x02\x94\x67\x05\x31\x9c\x09\x04\x23\x91\x40\xc0\x5b\x4e\x10\x5e\x2f\xe7\x70\xb8\x68\x2b\x1d\xaf\x0c\x94\x97\x95\x43\x9f\x93\xa1\x19\x1a\x89\xd5\x9a\x65\x18\xb1\x4c\x08\x7b\xac\xa2\x68\x1c\xce\x8a\x74\xfe\x16\x1c\xdf\xd3\x20\xd6\x0d\x75\x33\xcb\xa5\x15\xc8\x18\x0e\xe2\x6b\x04\xc9\x52\xb9\xe0\xa2\x89\x1c\x9a\x48\x80\x97\x5c\x41\xd7\xe5\x62\x8d\x6a\x0e\x3c\x35\xa1\xec\xac\x17\xae\x92\xab\x95\x8f\x72\x35\x6b\x84\x7a\xff\x54\xa1\xdc\x42\xbe\x03\x65\x58\x06\xfd\x8c\x6a\x82\xa2\xca\xca\xc2\x34\xcb\x86\xc3\x16\x2e\x20\x79\x25\x6f\xb4\x3c\x60\xe0\x0c\xdc\x40\xd6\x60\xa0\x25\x97\x0b\xca\xd3\x65\xa5\xcb\xfa\xb3\xb4\x44\x6a\x37\xab\x85\xb3\xa5\x20\xc4\x96\x96\xd2\xe9\x45\xe1\xf0\x23\x5d\xe0\xe4\xac\x21\x0e\x89\x07\xe4\x3b\xd9\x0d\x99\xcd\x09\xdd\x84\x80\x02\x07\x75\x9e\x76\x65\x04\x2c\xff\x67\xe7\x85\xe3\xb9\x3f\xca\xae\x68\xf9\x8e\x7a\x5e\x3e\x05\xed\xef\xaf\xb0\xcf\xb8\x3a\x13\x17\x05\x21\x1c\x41\x77\x92\x96\x88\xc5\xad\x67\x31\xfd\x7e\x95\x3b\x51\x11\x89\x46\x50\x17\x86\x31\x1a\x85\x41\x5e\x94\x92\x03\x88\x23\xc2\x90\xf5\xc8\xa2\x91\x1a\xce\x1a\x4b\xa1\x73\x0b\x35\x77\x85\x48\xa1\x04\x33\x05\x31\xe1\x3a\xb4\x4b\x7d\x6d\x57\xaa\x09\xdc\xc8\x89\x09\x5e\x96\xce\xe0\x5d\x36\x33\xbf\x1b\x6f\xc3\x89\xdc\xb5\x27\xe6\x7a\xbf\x6b\x7a\x0a\xed\x31\x68\x69\xb5\xfd\x48\x6d\xd7\x52\xba\xe3\x93\xbe\xc7\x67\x77\xe3\xb9\x23\xde\xed\xd7\xa9\xe7\x89\x5a\x62\x6e\x26\x11\x2d\x2f\x8f\xe9\x64\x5f\x30\x48\xd4\xc8\x35\x7c\x45\x2c\x56\xcf\xd7\x95\x97\x27\xdc\x89\x30\x74\x14\x1c\x6e\xaa\x3f\xeb\xb6\x9a\xec\x83\x59\xab\xa9\x38\xdd\x9b\x33\xb8\x39\x7e\x85\x62\x25\xc5\x20\xaf\x31\x94\xf9\xb5\x50\xc5\x20\xf4\x6a\x47\xc0\x78\xb3\x0b\x57\x81\x62\xe5\xee\xc0\xa4\x6c\x77\xa2\x76\x6a\xef\x9c\xae\x5c\x1e\xb8\x7c\xc5\x94\xb6\x43\x07\xd2\x7f\x58\xb7\x49\x7f\x66\x61\xbf\x3e\x75\x44\x4f\x2d\xa6\x19\x32\xbd\xe9\xf2\x5b\xdf\xdb\xd7\x85\x53\xc2\xff\xfd\xcb\x6b\x0f\x58\xcc\xa3\xa7\x57\xa5\x36\x68\x9b\x75\xeb\x79\x4d\x09\x2d\x97\x38\xf6\xb1\xee\x3a\x28\xe7\x0a\xc4\x92\x63\x01\x66\x33\x49\xea\x75\x92\xd3\xc9\x13\x56\x6b\x39\x3c\x73\x43\xe5\xba\xa0\x2e\x18\xaf\x8c\xc0\x03\x35\x22\x5a\xc0\x48\x96\xb7\x40\x37\x01\x1d\xb6\x8c\x41\xb2\x9a\xf5\x28\xb2\x17\x0c\x14\xa9\x85\xf6\xc4\x09\xf9\x61\x64\x95\xb4\x6c\x62\xa2\x94\xed\x44\xad\xc2\x2b\x69\x49\x9c\x28\x9b\x98\x3f\x7e\xf3\x6a\x41\x7b\x4e\x9e\x58\xbc\xcf\x34\x4e\x31\xc8\xad\x13\x65\x18\xe1\x01\x5c\x55\xa2\x16\x95\x6a\xec\x18\x87\xb2\x7f\x00\xe7\xb3\x76\x65\xa6\xf9\xf5\x1e\xce\x60\x36\x73\x1e\x8f\x48\xea\x08\x96\x85\xb1\x0c\x29\x88\xa2\x64\x27\xed\x81\xa0\x93\xef\xcf\x3a\x1d\x1c\xaf\x23\x06\xb2\x03\xba\x61\x1d\xc9\xeb\x02\x3a\xf4\xb0\x4e\xc7\x98\x28\x51\x27\xea\x48\x86\x81\xea\xc1\xf0\xa4\x54\x8c\xad\x97\xcb\x1c\x77\x4d\xc4\xa6\x5a\xb4\x31\x90\x3b\x52\x48\x3c\x9e\xa0\x15\x4d\x69\x70\x41\x21\x09\x69\x9f\x06\x8c\xe7\x96\xea\x01\x25\x17\xa7\x23\x47\x97\x14\x4b\xdf\x5d\xbd\x53\xe5\x85\x66\x0e\x43\x9b\x1c\x24\x32\x99\x20\x4f\x38\x58\x0f\xe1\x09\x85\xb5\x5a\x6e\xa7\x9f\xf6\xc3\xe0\xdf\x2f\x22\x2e\x68\xb5\xd1\x6a\xfc\x3e\xce\x0f\x7f\x1c\xf3\x33\x9d\xa3\x5d\x50\xd1\x2c\x49\x3a\x14\x24\x7a\xdf\x04\xbb\xbf\xfa\xec\xa3\xf4\x1c\x70\xfe\x4b\xb7\x2b\xca\x95\xf7\x5e\xb3\x74\xe3\x4c\xff\x77\x4d\xe4\x5c\xd3\xa5\x69\xe5\x1d\xe5\x57\x2a\x91\xf3\x57\x60\xcb\x31\x0c\xc8\xfe\x94\xf2\xbd\xdf\xbc\xf0\xe1\xac\x07\x0f\x61\x22\xe7\xdf\xfd\x23\x57\xe3\x0c\xfd\x23\x9a\x80\x36\x36\x84\xc6\x2c\x50\x2e\xce\x4f\xf9\xc3\x11\xbf\xcb\x03\xfd\x21\x8f\x87\xc8\x75\xc6\x11\x52\xe1\xea\x32\x75\x92\x31\x8f\x6f\x84\xcb\x75\x4d\x75\xa9\x6d\xe6\x16\x00\x8e\xbc\xf4\x93\x6b\x00\x71\xfd\xe1\x83\xd5\x7d\xc6\xa9\x23\xc3\xb7\xcc\x1d\x98\x3e\x67\xa1\x83\x5f\x62\x02\xcf\x98\x86\xf5\x91\xdf\xd8\x9f\x7a\xe9\x10\x10\x6e\xec\x38\x7e\x4d\x66\xf7\x3f\xaf\xdf\x7e\xc9\x85\xdb\x4f\x41\x9d\x10\xd5\xaf\x3f\x89\xc7\x7a\x3d\x5c\xdf\x33\x71\xde\x77\x56\x26\xc6\x0b\x02\x11\x72\xba\x5c\x1e\xb7\x5b\x1f\x62\xe9\xb2\xa8\xcb\x05\x9d\x39\x09\xad\x30\xc7\xb2\x3a\x1e\xe8\xe0\xde\xd2\x51\x45\xb0\x48\x45\x5e\x9b\x5c\x62\x26\xc1\xf8\xd6\xa8\xa2\x1d\x92\xb3\x19\xe4\xa9\xe3\xfb\xa4\xee\x33\xf5\xb4\x0f\x2d\xc1\x1b\xc3\xf3\xcf\x5f\xbe\xfe\x23\x3d\xfd\x8b\x42\xc7\xd4\xf1\xf9\xdd\x55\x9d\x93\x37\x6e\x45\xdb\xe1\x86\x5b\x76\xec\xea\xac\x40\xbd\x53\xd0\x36\xec\x80\x6b\xdd\x46\x6c\xcc\xb4\xcb\x56\x9b\x4d\xf4\x41\xdb\x6f\xd4\xa7\xa1\xa7\x19\xa9\x49\x26\xeb\xf4\x11\xa1\x56\xa8\x6d\xef\x68\x48\xf4\x67\x1b\x1c\x3e\xab\x2c\x93\x66\xb7\x79\x76\x36\xe8\xb6\x26\x51\x61\x2b\x8e\x9a\xf4\x02\x6a\xf5\xcf\x4d\xa6\xd0\x3d\xe5\x2c\xee\x63\x2b\xe4\x43\x53\x85\xee\x29\xf0\xb5\xad\x53\xda\x89\xa7\x2b\x9a\x7d\xde\x62\x0a\x4d\xf4\xe1\xbe\xf0\xbc\x3e\xa3\xda\x4a\x95\x5c\x57\x9e\x6f\xa5\x9a\x7a\xf3\xb2\xec\xe9\xa0\xef\xd6\x65\xf3\x56\xda\x3a\x0d\xf5\x75\x0d\x0d\x36\xbc\x65\x9e\xfa\xc1\xf7\xbf\x67\x6c\x31\x92\x6f\x2e\x99\xb5\xad\x55\x6b\xab\xca\x75\xaf\x1e\x5c\x32\xb2\x6a\xd1\xe9\x4b\xd6\x2d\x8f\x0e\x2b\xf7\xa6\x9b\xeb\x9a\xe7\x8e\xc0\x8d\x74\xf8\x86\xcd\x9b\x93\x2d\xa0\x6a\x36\x8a\x5f\x18\xa8\x97\x29\x66\xa6\xc0\x02\xb5\xc6\x8b\x1b\xfb\x98\x4a\xc2\xb5\x8b\x11\x4b\x33\x29\x73\xd0\x1a\x94\x38\x9f\xd5\x1a\xe5\x28\x89\x93\x2a\xe2\xe6\x40\x38\x10\x1e\xc8\xf2\x81\x40\x80\x34\x51\x81\x00\x2b\x08\xe8\xd2\x49\xb0\x92\x24\xcb\x12\x08\xd1\x3d\x07\x2f\x98\xd7\xde\x3c\x96\x53\x71\x1a\x59\x83\x22\xca\xb7\xba\x42\xb3\xd0\x05\x0f\x17\x18\xbb\x60\x16\xb7\x98\x8a\x0c\x8c\xb1\xfe\xf1\x8d\xfc\xef\x36\xef\xae\x1a\x7a\x79\xe4\xd5\xa7\xaf\x5e\x0f\x7a\xe6\x82\xe7\x5a\x57\x2c\x4c\xf4\x99\x6a\x3a\x17\x2e\xd9\x79\x9a\x30\x7d\xd5\x99\xa7\xad\x5c\xdc\x35\x6d\xe8\xbc\x4d\x67\x1d\xe0\x59\xf7\x92\x1e\x20\x9a\xc4\x4f\xb7\xd7\xae\x3d\xe3\xbc\xd3\xd7\x2c\xee\xee\x54\x6b\xbb\x7a\x71\x6d\x57\x0c\x9e\x8d\x31\x67\x59\xc4\x18\x31\x99\x28\x5b\x28\x2c\x84\x6d\xb6\x38\x55\x21\xf9\x47\xb2\x2e\xc9\xab\x15\x75\x45\xbe\xae\xa8\xab\xf8\xda\x37\x67\xf7\xea\x27\xac\xe6\x62\x69\xd5\x03\xd0\x69\x99\xe3\x93\x55\x75\xbd\x13\x53\xfe\xfa\xce\xcc\x2b\xcb\x1b\xb3\xc0\x32\xb9\xb2\x7f\xbd\xe5\xd3\x93\x14\x77\xd5\xbe\xf7\x47\xc1\x04\x6a\x1f\x91\xdd\x6b\x87\x98\x25\xb9\x02\x2f\xf5\xec\x57\x66\xe2\x1a\xaf\x38\xd1\x99\x09\xc6\xa1\x87\xea\xf1\x54\x26\x42\x66\x33\xf4\x4f\x07\xb2\xe1\x80\xe7\x64\xf5\x5d\xa9\x44\x49\xc6\xed\x1b\x8a\xbb\x8a\xae\x05\x9b\xd2\x5f\x5b\xe4\x75\x28\xfc\x97\xc7\xe7\xcd\xae\xc8\xc8\xa2\xa7\x79\xc4\x3e\x71\xad\x57\xdd\x33\xaf\x0b\xbf\x3d\x47\xbc\x7c\x03\xca\x99\x28\x47\x51\xae\x0a\xc6\xd1\x0d\x6a\x8e\x19\xce\xe7\x18\xce\x31\xcf\xc1\x5f\xef\x1f\xfb\xad\xee\x7a\x9c\x83\x6e\xc5\x5f\x93\xd0\x46\x2d\xa2\x0e\xc1\xaf\xe7\xa3\xf9\x2b\x3b\x94\x1d\xf0\x0c\x7c\x85\xb0\x13\xa1\x8c\x68\x63\x2c\x16\xc3\x07\x00\x10\x20\x03\x06\xc1\x08\xa0\x81\x95\x48\x1e\x5b\xb4\xa8\x1e\x91\xa6\x42\xa3\x1f\x69\xca\xf9\xd8\x70\x5e\x08\x30\x07\xee\x47\xcf\xa5\xc6\xf6\x78\x54\xcf\xee\xd1\x5b\xfb\xfb\x6d\x97\xd8\xd6\x2b\x3b\xd2\x72\x75\x3c\x11\xab\x5b\x70\x9a\x71\xf1\x62\xfb\xb9\x32\xce\x47\x3d\xc6\x24\xc9\x1d\xec\xeb\x84\x91\x90\xa1\x7d\x0c\x66\xf8\x90\x24\x79\xae\xe4\x01\x8f\x88\x33\x78\x8a\x7b\x1c\x9c\x0e\x57\xf7\x58\x62\x51\x8e\xcd\xa7\x80\x2e\x4b\x15\x3d\x47\x8b\x9e\x81\xb5\x39\x1e\x6b\x69\xae\x88\x37\xcf\x6f\x8d\xa9\x0f\x40\xdf\x56\x8e\x9e\x62\xad\xcc\xfe\x78\x73\x73\xbc\xac\xb5\x05\xe8\xe2\xe9\xe6\x8a\x68\x6b\x4b\xb9\xf6\xa7\x2a\xf7\x9f\x31\xfd\x60\x23\x7b\x1c\x8e\xc7\x78\x84\x60\xf1\xa7\x1f\x43\x57\x37\x32\xfc\x15\x81\xe7\x58\x2c\x0d\x36\x3e\xb0\xff\xd0\xfe\x67\x0f\x1e\xda\x7f\xe8\x8a\x07\xd8\xe3\x73\xf3\xff\xc3\xf7\x15\x6f\x33\x49\xf0\x13\xf6\x3d\x3c\x1f\x7f\xc6\x26\xf1\x7c\x80\x4f\xf2\x0f\xf1\x3f\xe4\x5f\xe7\xd9\xc2\x7c\x16\xe1\x5e\xdd\xc2\x98\x8b\x9f\xdf\x6e\xae\x28\x6f\x6b\x2b\xaf\x68\x4e\xb6\x96\xc7\x5a\x9b\xe3\x15\xcd\x68\xd0\xe9\xca\x68\x4b\x2b\xb0\xc7\xd3\x69\x38\xfa\x56\xbc\x76\x4f\xc2\xb5\xbb\x5a\xfb\x2c\x0f\x51\x96\xb1\xbb\x78\xe7\xc9\x3f\xf0\x05\xeb\x0b\xa5\xeb\x57\xfc\x99\xa8\xeb\x01\xdc\x05\x17\x08\x2e\x92\xfa\xc1\xf8\x41\xf9\x73\xef\x95\x3d\xb9\x25\xc3\x9f\xde\x5c\x01\x1f\x94\x3f\x80\xab\x14\x7c\xa7\xac\x3c\xae\xac\x1b\xfb\x6c\xec\x41\xc2\x40\x58\x1e\xa5\x09\x06\x60\x9e\x01\x34\x3b\x5c\xcd\xac\xc3\x56\xf8\x61\xfa\x90\x6b\xff\x8d\xec\x90\x20\x5e\xb9\x6f\xc7\xf9\x65\x65\xb8\xc6\x86\xe9\x06\x8b\xd9\xa7\xe1\x2c\xac\xdf\xa7\x06\x01\x54\x2c\xa8\x5e\xc9\x45\xeb\x5f\x45\x8b\x0d\x17\x79\xf1\xdb\x77\xbd\xce\x12\x4f\x3f\xfd\x34\xfc\xde\x85\xcc\x64\xf0\x36\x7b\x35\x8c\xa7\xa2\x19\x3b\xeb\x62\x5d\x04\x6f\x02\x26\xf1\x21\x3f\x18\xf4\x83\x8c\x1f\xf8\xd1\x0f\x2e\x4a\xbd\x0a\xf5\xb1\x05\x9e\x46\xb5\x08\xea\xde\x2e\xeb\xb4\x5e\x76\x14\xca\x6a\xd7\xcb\x69\x75\xb6\x38\xf4\x35\xb9\xa3\xd5\x9d\x35\xf5\x6b\x66\x54\x76\x25\x7d\xc1\x32\xb7\x23\x51\xdd\x39\xb2\x72\x7a\x65\x7b\x75\x24\x10\x67\xe3\x95\xe1\x2a\x71\xbe\x6d\xb0\x79\xda\x1a\x77\x5d\x6b\x47\x34\x16\xad\x94\xe6\x57\xac\x1a\x5a\x2d\xd7\x64\x9a\xaa\xe0\x98\x7a\x99\x7e\xe2\x22\x16\x61\x2c\x27\x32\x41\x9a\xc7\x13\xaf\x25\x06\x89\x11\x62\x27\x71\x15\x71\x98\x78\x96\xf8\x90\xf8\x07\x61\xc8\x10\x6f\x40\xa5\xc0\x04\x0f\x68\x51\x28\xb4\x51\xd2\xf8\xb8\x12\xe8\x43\x4e\xb8\x28\x4c\x7f\x61\x55\xd0\xba\xcc\x83\xfb\xee\xa3\xb1\x3f\x12\x0c\xa1\x3f\x02\x68\xb8\x96\x68\x7b\x41\x13\xa1\xbb\xe3\xf0\x8d\xaf\x3f\xf3\xb6\xb2\xe3\xe8\x51\xe8\x54\x90\xca\x95\xca\x3a\x22\x3a\xf6\x29\x94\xbd\x40\x48\x19\x4e\x10\xf8\x8c\x05\x58\x38\x8a\x48\x22\x59\xb7\xc0\x55\x60\x8a\xb7\x07\x19\x4a\x43\x0b\xa3\x5c\x99\xdb\x19\xe0\x40\x4c\x79\xc0\xb5\x74\xa5\x71\x9d\xb6\x1d\x26\x2b\xcf\xed\x3b\x75\x58\xf5\xad\xf6\x30\xfd\x24\x0d\xe7\xc6\xa2\xb9\x51\x3c\x09\xc8\x6f\x98\xdb\xab\x58\x9d\x85\x90\x0e\x9e\xcd\x7b\x62\x60\xae\x73\xc5\x19\x7a\xb8\x8f\xba\xf6\xcd\x9f\xff\xff\xff\xf7\x91\x63\xe9\xfc\xfb\xcc\x44\x2a\x53\x66\xa0\x28\x0e\xbd\x54\xf7\x0d\x6f\xad\x3f\xa6\x19\x11\x4a\x7d\x73\x4a\xfd\xe3\x65\xed\x03\x9e\x2d\xfd\x20\xed\xd3\x08\x82\x56\x5e\x67\xa6\x93\xf7\xe8\xa2\x04\x62\xec\x48\x10\x69\x78\x22\x84\x1b\xe3\x9c\x2f\x09\x03\xf0\xa4\xd8\x25\x92\x62\x7c\xa7\x0f\x04\x7d\x19\xdf\xa0\x6f\xa7\xef\xb0\xef\x0d\xdf\x87\x3e\x9d\xef\xf1\xb1\x67\x1f\x71\xf9\xfb\x7c\x44\x32\xb1\x68\x7d\xea\x85\x45\x2a\xed\xaf\xea\x23\xe7\x05\x13\x83\xaa\x9e\xb7\x5d\x1a\xd6\x32\xfc\x5a\x03\xf2\x87\x4a\x5b\xfc\xac\x6c\x9d\x37\x6f\xeb\xd6\x79\x75\xb1\x39\xf3\xa7\xda\x47\x7f\x86\xbe\x92\xbb\xcf\x6c\x8b\x27\xe7\x6d\x05\x89\x54\x34\x9a\x42\xff\x91\xc9\xdc\x13\x3b\x84\xbe\x7b\xde\x56\x61\xea\x59\x9d\x65\xcd\xe8\x39\x95\xe8\x5f\x38\x55\xd8\x3a\x4f\xfd\xf7\xfc\x7f\xd8\x6e\xbd\x92\x9f\xa3\x87\xa8\xcd\x78\xc4\x24\xd5\x45\x91\x94\x6b\x27\x07\x82\x5c\x86\x1b\xe4\x76\x72\x87\xb9\x37\xb8\x0f\x39\x1d\xa7\x4d\x8c\xcb\x4f\x6c\xa2\x19\x9d\x64\xd4\x85\x71\x96\x8e\x2e\x37\x12\x30\xf6\x0c\xd3\x01\xce\x63\x6f\x26\x6c\x84\xf8\xa8\x99\xa6\x39\xe4\x35\x40\x03\xf6\x2a\x3a\x6a\xf0\x15\x3a\x3a\x31\x75\x11\xb5\x98\xb8\x09\xb5\x2e\xe9\x6d\x6b\x16\xd4\xd8\x85\xdd\x9d\x97\xc8\xc6\x48\x79\xb9\x9e\x65\x6f\x6e\x5a\xb9\xd4\xb0\x02\x2c\xda\x6a\x8c\xc2\xf0\x16\x28\x07\xe1\x9e\x1a\x82\x67\x99\x84\xce\x32\x1e\xfa\x58\x1f\xd8\x00\x61\xcb\xd8\x06\x6d\x23\x36\xda\x66\x00\x78\xcf\x2c\x52\xcf\x32\x26\xc5\xe6\x11\x21\xe0\x87\xa1\x23\x0d\x9a\x30\xe5\xb1\x3d\x06\x77\xb8\xe4\x38\x6b\x6c\xb5\x3b\xe4\x8a\x2a\xed\x38\x13\x36\xaa\x38\x52\xca\x8d\xca\xb5\xf0\xdc\x7c\x0f\xee\x5f\xcb\xa3\x14\x81\x55\x5d\xb5\x87\x32\x15\x4a\xa7\xd2\xf1\x36\xe5\x01\xe7\x2b\xa1\x88\xf2\xd8\xe5\xcf\x68\xf6\x73\x07\xd1\x5d\xba\xdf\x29\xbc\xdf\xc9\x07\x6f\xfc\xd9\x53\xb9\xfd\x0e\x94\x87\xe1\x7e\x4f\x42\x3b\xcb\x16\xbd\x17\x6f\x13\x59\xdd\xda\xc9\xa8\x72\x10\xed\xe7\xa1\xfc\x3e\x26\x47\xbf\x84\x3f\xf3\x13\xfc\x33\x66\x42\xce\x18\xd0\x3e\x41\x3f\x69\x86\x3f\x5a\xff\xaa\xb6\x17\x74\xea\x8f\x87\xd4\x3f\x2e\x83\x56\xc1\xb9\xfc\x0c\x23\xf8\x50\x7b\x50\x5f\x57\xb0\x0d\xca\x63\xca\x66\x22\x30\xf6\x39\xa1\x23\x4c\x47\x91\xcd\x66\xd0\xf4\xe0\x98\x19\x18\x2d\x45\x79\x40\x2b\x4f\x4a\x97\x6c\x00\x93\xc5\x8b\x94\x87\x5b\xce\xf6\xfc\x20\xbd\x4a\xc3\xd7\xfa\x14\x6e\xab\xe4\xff\xda\x5e\x8a\x05\x7b\x79\xf3\x44\xf6\x92\x44\x7b\x93\xb8\x6b\x02\xbd\x35\x83\xa0\x39\x63\x1e\x34\xef\x34\x1f\x36\xbf\x61\xfe\xd0\xac\x33\x6b\x7a\x6b\x2e\xd2\x5b\xf0\x35\x3b\x4f\x79\x7d\xe2\x0d\xa6\x2a\xee\xb8\xad\xa4\xae\xcd\xff\x87\x7a\x36\xf6\x67\xec\xa7\x3c\x06\xf5\x26\x9a\xf1\xd2\x04\xa8\xc5\x8e\xd9\x4e\x70\x15\x38\x0c\x9e\x05\x1f\x82\x7f\x00\x43\x06\xbc\x01\x48\x7c\xa8\x22\x0f\x06\x2b\x15\x48\x1e\x3e\x00\xb5\x8a\xe9\xc7\x5a\x85\xde\xf3\x3c\xdc\x6f\x73\xd8\x3d\xf0\x3d\xbe\x8c\x8d\x87\xc6\x9a\xda\x41\x3e\x44\x92\x83\x24\xc8\x20\x25\xc3\x07\x2b\x12\x30\xc0\xea\x0b\xe6\xb4\x28\x07\xa1\xfe\xb2\x7b\x54\x05\x06\x63\x5b\xa1\x8e\x3d\x3e\xd1\xf9\x2f\x17\xce\x7f\xab\x2a\xba\xe2\xf3\x5f\xa9\x63\x26\x13\x87\xfe\x17\x67\x3a\xf8\x36\x67\xba\xf2\xdb\xff\x97\x43\x1d\x63\xf0\xbf\xc7\xec\x00\x17\x41\x7d\x42\x3e\x15\xd4\x27\x2a\xc9\x77\xf1\x24\xcf\xed\x94\x40\x50\xca\x48\x83\xd2\x4e\xe9\xb0\xf4\x86\xf4\xa1\xa4\x93\x34\x7d\x92\x54\x7d\x3a\xa6\xea\x53\xb1\xe5\x2e\xf2\xae\xf4\x39\xed\x51\xde\x54\xcd\xe1\xbc\xad\xec\x50\xce\x04\xab\x5f\x6f\x55\xf5\xf9\x63\xa5\x6b\xec\xd7\x63\x9f\xe0\xcf\x97\x33\x26\xca\xca\x81\xc3\xdc\xb3\x1c\xc9\x49\x3c\x56\x9f\xf5\xf5\x27\x77\xe2\x94\x8f\x73\x7e\x5b\x32\xe7\xc9\x29\xb7\xa9\xde\x2d\xf2\xdd\x54\x27\x8e\x60\x14\x59\xe9\x22\xde\xd1\x3e\x23\x42\x24\x61\x5c\xef\xcb\x98\x29\x8e\x8b\x55\xb7\x84\x24\x4f\x4a\xa2\xe0\x47\xc9\x28\xb2\x3c\xf6\xed\x9d\x6e\xf9\x64\x63\x3a\x33\x37\xa6\xb9\xb9\x31\x01\x7d\xee\xe9\xa7\x39\xaf\xbc\x36\x3f\xde\x43\x9a\x8b\x09\x18\x6d\xbc\x65\xda\x9f\xaf\x68\x6e\x3a\x90\x72\x13\x41\x3e\xb0\x32\x02\xe7\xf2\x20\x9c\x0b\x85\x2d\x80\xf0\x18\x01\x80\xce\xec\x12\xd1\x5a\xa9\x47\x06\x93\x0e\xe9\x4e\x3a\xb8\x11\x17\xe8\x70\x06\x4f\x18\xc5\x33\xfb\xf7\xdf\x73\xc2\xc7\x51\xca\x74\xf8\x59\xf7\x68\xeb\x16\x80\xd2\xe1\xfc\x6e\xb7\xc7\x43\x69\xa2\x41\x1f\x87\xbd\x8b\x93\x7c\x18\x93\x8e\xc0\xa1\x44\x74\x33\x73\x5e\x7d\x32\xe7\x8c\x29\x87\xe4\x85\x4e\xd0\xe7\x5a\xe8\x40\xe2\x4a\xc7\x8b\xc4\xd5\x72\xd3\xc6\x7d\xfb\x36\xc2\x7d\x46\x28\xd7\x8e\x3d\x37\x36\x04\x3f\x5b\x7f\x04\x7b\x79\xa5\x62\x19\x23\x5a\xcb\xd5\xa0\x41\xf9\x14\xbd\x22\xd6\xdc\xaa\xea\xd3\x76\xe5\x00\xd1\x3b\x36\x07\x8f\xd9\x72\x54\xe2\x38\x44\xda\xa5\x45\xa6\x27\x11\xa5\xb2\x3d\x27\x32\xa0\xcf\x8d\x55\xf9\xb7\x26\x97\xb2\x7c\x00\x42\xc1\xb3\xae\x9f\x18\xc9\xeb\x91\xf0\x18\xc5\xa1\xe0\x8d\x57\xdf\x7f\xac\xfe\xdb\x29\x8e\xf2\x69\xee\xd3\xe6\x9f\xa8\x20\x27\x57\x07\x64\x43\x9e\x51\x3e\x27\x7c\x63\x17\x41\xd9\xeb\x8f\x50\x00\xaf\x09\x13\xd2\x85\x94\xb7\x41\xaf\x4b\x79\x72\xfb\x3e\xf5\xbc\xba\x08\xfa\xc9\x17\xc1\xf3\x4a\x7f\x84\x25\x55\x6e\x37\x4d\x10\x9f\x4b\x2b\x5c\x60\xae\x6b\xa9\x5d\xb9\x08\x2f\xb2\x8a\x89\x43\xff\x84\xf8\x9c\xb9\x04\xce\x49\x82\x7b\x82\xe7\x02\x5c\x17\x37\xcc\x3d\xc4\x31\xd0\xdf\x59\x54\xea\xbc\x95\xa7\x73\xe1\x25\x13\x55\x87\xd9\xa2\xbd\x83\xd9\x43\x7c\xce\xf6\xc2\x77\x88\x19\x23\x95\xf3\x9f\xe8\x89\xde\x90\x53\x01\xe6\x23\x4d\xde\x68\x5d\x27\x2b\x5b\x89\x5b\xc6\xfe\xad\xad\x6b\x20\x63\xe5\x82\x54\x2d\x3c\xd5\x28\x8f\x27\x13\x02\x21\xcd\x12\xd4\x0b\x2d\xf8\x7d\xba\xa2\xf7\xc5\x8a\xf5\xad\xe8\xf9\xd3\xdc\xe7\x1c\xcb\xaf\xf1\x4d\x39\xd1\xbe\xa2\x7d\xf2\x45\xda\xca\x1e\x28\x84\x98\x50\xef\x0e\x91\x23\xc4\x99\x54\x00\x8e\xc5\x74\x94\x7a\x83\x03\xda\x24\x8a\xa5\x39\x27\x17\xaf\x92\xcf\x68\x61\x2a\xfc\x39\x93\x72\x0f\xd4\x57\x55\x36\x44\x6e\xdd\x53\xba\x7f\xc7\xae\x88\x29\xf7\x7c\xf0\x01\x5e\xa7\xdf\xd3\x07\xa8\x0e\x66\xa6\xfa\x3d\x9a\x4e\xa3\x02\x10\x92\x6c\xf3\x8f\xbe\xc0\xcc\x84\x9b\x79\xec\x6d\xfa\x4b\x90\x86\xf2\xa0\xe0\x3a\x48\xc4\x0f\x29\x10\x80\x07\xfc\x3a\x6a\x07\xf5\x77\x8a\xa1\x32\x82\xd4\x47\xa9\xf6\x17\xbe\x1e\xfe\xa8\x15\x4c\x75\x2a\x8f\x33\x97\xec\x43\xef\x07\x71\x65\x84\xda\xaf\x7b\x1b\xbf\x1f\x39\x15\x49\x95\x30\x10\xc4\xc1\x03\x4f\x2a\x73\x95\x11\xee\xbc\xcf\x2e\x53\xe5\x65\x82\x32\x7f\x05\xce\xd1\x09\x65\x1e\xe0\xd6\x71\x3b\xa0\xc4\x5f\x87\x32\x7f\x1c\x9c\x41\x74\x9d\x5c\x68\xab\x73\x42\x2b\x96\x39\xd4\x45\x0e\xcf\xe5\x1b\x04\x8d\x70\xde\x7e\x0f\x3e\xa1\x9e\xc3\x72\xe6\x1f\x31\x09\x2c\xf1\x38\x58\x4a\x74\xd5\x27\xd5\x66\xc6\x3c\x12\x9b\x58\xf4\xfc\xfc\xd4\xe1\xe1\xa9\xdd\x4b\x86\xbb\xa6\x0e\x2f\xee\x9b\xb2\x6c\xc4\x37\xd2\xdb\x3b\xb2\xb4\xbb\x7b\x29\x79\xcd\x48\xef\xd4\xe1\xa5\xdd\x3d\xb8\x86\x9c\xe8\x67\x3e\x07\x16\xe8\x1f\x9c\x64\x3c\xfd\xb9\x4d\xc7\xce\xd5\x76\x18\xdc\x2b\xff\x56\xe6\x8f\x1d\x1d\x73\x9d\xcc\xc6\x28\xff\xce\x6f\xcb\xc7\x8b\x6c\x30\x20\x50\x4a\x7e\x21\xfd\x18\x51\x49\x44\x8f\xd0\xc2\x53\x60\x05\x91\x25\x68\x30\xfc\x48\xd4\x1f\xf2\xab\x5f\x85\xc0\x92\x7c\xcb\x3b\xa2\x46\x69\x68\x6a\x03\xb9\x4c\x17\x7c\x79\x02\x20\xaa\x43\x1e\xb0\xf8\xd2\x20\x24\x86\x70\x26\x3e\xdd\x49\xfe\x99\xec\x5d\x3c\xb3\x3c\xc0\x50\x66\x93\xc5\x36\x38\x35\xe2\x6b\x60\x38\x92\xd6\x0f\xda\x7d\xc0\x2e\x2b\x09\x91\xa5\xcb\x3b\x1a\x1d\xd4\xe6\x85\x8b\xda\x04\x97\x60\x9a\x92\xdc\xb8\x35\x19\xad\xbe\xbb\xb6\x75\xbd\xd7\x64\x55\x7e\xbf\x66\x20\x1d\xf2\xa4\xe6\xec\xd0\x6a\x7f\x6e\x51\xd6\x81\xe5\xd0\x57\xe1\xa0\x2e\x03\xbd\x0e\xe8\x54\x5d\x66\x22\xd0\xfb\xea\x82\x0e\x58\x08\xcc\xbc\x47\x4f\x5f\x4e\x26\xee\x74\x82\xc3\xef\xdd\x61\xb7\xdf\x81\xf5\x68\xec\x93\xb1\x8f\x98\x28\xfd\x34\x31\x9d\x48\x3e\xc2\xb4\xf7\xb5\x3f\x0e\x56\x67\xb8\x6c\xb5\xa3\x95\xa3\x83\x0d\x7d\x3f\x00\xc3\x44\x88\x08\xc2\x19\xda\x90\xf4\xba\x0a\x50\xe3\xa8\x0e\x50\xa7\x96\x49\xe8\x0a\xe5\x6e\xe5\x31\x80\x19\x17\x91\xdf\x09\x7d\xaa\x7a\x8d\x1e\x0e\xfa\xcf\xe5\x88\x8c\x38\x55\x2f\xd9\xfd\x40\x6c\x4a\xe7\xbe\xd2\xd9\x53\xd0\x03\x66\xa2\x8d\x56\x87\xa5\xfc\xee\xab\x2a\x7e\x57\xe7\xed\x1a\x0e\x5b\x58\xbe\x4b\x99\x3b\xbf\xfd\x94\x53\x92\xca\x3a\xcb\xea\x7a\xc9\x29\x9d\xbb\x25\xbe\xa6\xba\x6f\x81\xcb\x16\x9e\xfa\xe7\xdd\xb7\x0e\x06\x1a\x64\x96\x4e\x2f\xaa\xaa\xa7\xad\x0b\x07\xed\xe6\x25\x7b\x7a\x94\x7f\x77\x34\xb8\xfd\x2b\x4e\x0b\x65\x86\xc8\xb2\x49\xa7\xb6\x0e\x9d\x79\xe6\xd4\xd6\xae\x39\x2d\x8e\x86\xce\x19\xc9\x8d\xb7\xf5\xb8\x76\x35\xd5\x94\x9d\xde\xef\x74\xf7\x2e\x53\x7e\x76\x4d\x0f\xb5\xb6\x61\x4e\x83\x3e\x10\xa1\xea\xe0\x1a\xfc\x02\x1a\xa6\x2b\xe9\xa3\x70\xa6\xd1\x23\x0e\x83\x2a\x55\x07\x94\x71\x10\x7a\x89\xea\x57\xa0\x44\xc6\x71\x20\x86\x9a\x30\x39\x30\x4e\xd5\xe5\x66\x12\x52\x41\x16\xe1\x82\xa4\x28\xe1\xf8\x73\x5b\xc9\x64\x5d\x67\x45\x8b\xb2\xb9\x2b\x19\x4c\x49\x56\x3a\x06\x1e\x5e\x36\x6d\x46\x94\x4b\x3b\x9f\x06\xbe\xb9\xc0\xb6\xb3\x3a\xd4\xdd\xd2\xb6\x62\x8a\x25\xe0\x6e\x1d\x9a\xae\xf4\xcd\x15\xa7\x38\x54\x59\xde\x31\xf6\x09\xd9\x0b\x75\x2e\x49\xd4\x1c\x4d\xd4\xd8\x6b\x92\x93\x4c\x78\x14\x35\x70\x14\xe5\x50\x0e\x76\x82\xc3\x5f\xdb\xa1\x74\x8a\xa0\x32\xa1\xf2\xd5\x77\x01\xb5\xf3\x21\x9c\x1f\x56\x1b\x50\x0b\x03\xa0\xf6\x05\x80\x43\x93\x13\xf4\x28\x59\x5d\x48\xbc\xe3\xd6\x58\x4c\x1f\x4d\xdb\x87\x22\xcd\xbc\x8d\x6c\xf1\x0d\x4f\x95\xac\x83\x21\xb3\xcd\x1d\x37\x39\x18\x2a\xe6\xed\x59\xa3\xfc\x63\x35\xf0\xfd\xf6\xd7\xd5\x36\x6f\x60\xa4\x79\x43\xd6\x2a\x95\xc5\x13\xfe\xae\xc4\xdb\x4f\x2e\x3d\xb3\xba\xa9\x29\x3e\xab\xa1\xa7\x65\x5f\xf3\xbc\xb7\x81\x0f\xed\x95\xf5\x63\x7f\xa4\xde\x81\xeb\x18\x27\x7c\x4f\x10\x7e\xb0\xf4\x11\x3b\x0c\xce\xd4\x05\x34\xe3\xa1\xe2\x05\xc4\x4d\x1a\xda\xf0\x78\x80\x96\x4d\x42\xbb\x03\xc5\x09\xf0\x77\x32\x12\x46\xfb\xa3\x0b\x74\x92\xe9\xcf\xa6\xb5\x87\x1a\x44\x2b\x43\x45\xc9\xcb\xa6\xb3\x56\xa3\x23\xdd\x69\x32\x3a\x02\xc6\xc8\x7e\x9e\x67\xfc\xa1\x88\x23\xda\xd9\x42\x0d\xb5\x0e\xa4\x97\x75\x59\x79\xc1\x91\x69\x1c\x69\x27\xb9\xc5\x67\x2c\xff\xfc\x50\x7d\x79\x2f\xcf\xe9\x2a\xef\xff\xcd\x75\xe7\x2f\x56\xef\x00\x3c\x63\x7f\xa4\xfb\xe1\x9a\x56\x10\x5d\x44\xf4\x68\x67\xa7\x29\x50\xff\x38\x1e\xa1\x49\x1b\xa1\xa9\x30\x42\x54\xf2\x87\xfb\x7a\x4b\x65\xab\x8e\x0f\xae\x20\x0d\xc7\x98\x6e\x42\xc5\x6d\x69\xc6\xae\x63\x29\x75\xd4\x4d\x70\x57\x0b\x9d\x54\xaa\x1e\x84\xfa\x52\xa1\x06\x9b\x48\x07\xc9\x9f\xc4\xa2\xac\x8b\x71\x06\x82\x16\xc6\xc6\x37\x2e\xb1\x8b\x54\x8d\xa4\xd7\x4d\xea\x1b\x3d\xaa\xaf\xac\x76\x70\xc9\xf3\x23\x02\x69\x88\x59\x13\x36\xcf\xd4\xd3\x6c\x36\x6a\x68\x46\x5f\x72\x71\xb7\x35\x6a\x0f\x96\xb5\xec\x76\x5b\xc4\x8e\xc5\xb7\x4c\x5a\x7f\xe5\xd2\x74\xda\x66\xbd\x08\x24\xce\xdf\xb0\xa3\xfe\x55\x4e\x5f\xad\xbc\x77\x79\xfd\xe4\x0e\x99\xe3\x9b\x97\x03\x43\xba\xbe\x23\x89\xd6\x7e\xce\xd8\xbf\xc1\xe3\x70\x7e\x01\xc2\xf5\x43\xc2\x09\x15\xc5\x04\xff\xb6\x30\x2f\xa2\x74\xdd\x73\x6a\x81\xae\xee\x75\xd0\xfe\x35\x8a\x69\xa8\xcd\x0f\x37\x54\xc2\x27\x9e\x8e\xcc\x9d\xd4\xa8\xbf\x85\x75\xda\xd2\x56\x7e\x0f\x15\x0c\x53\x43\x99\x49\xd5\xab\x66\x09\x1e\x6f\xa2\x56\x6c\x3e\x7e\xad\xd3\x65\x8a\x1b\x28\xce\x1b\xe4\x55\x1b\xd9\x3d\xf6\x0f\xb2\x1b\xca\xbd\x8a\x70\x1d\xb5\xe9\x3c\x71\xcf\x53\x60\x35\xfc\xe4\x78\x7e\x45\x93\xb8\x6a\x18\xd9\x07\x6c\x2f\x48\x0b\xa5\x43\x52\xc6\xa9\x82\x74\xfe\x00\x80\xca\xe0\x40\xc3\x22\xbb\x83\x66\xce\x20\xba\xa3\x2d\x49\x9b\xdb\x6c\x0b\x6d\xf4\x19\xf4\x81\xb8\xc5\xde\x77\xc6\xd2\xb9\x33\xa3\xac\x81\x24\x79\xef\xc8\x8c\x1e\xea\x83\xc0\x19\x16\x79\xca\xf5\x0f\x28\x5f\x2c\xad\xab\xef\xa0\x4d\x1c\xdf\x79\xe8\x9a\xb7\x1e\x3a\xa3\x6b\x66\xcd\x4e\x3d\x6b\xb4\x1b\xf9\xc9\xea\xf8\x92\x50\xf6\xeb\xe1\xda\xb4\x11\xa1\x23\x31\x74\x0e\x1d\xf5\x72\x29\x29\xa5\xca\x5d\xca\x8d\x12\x09\x1e\x9d\x4d\x48\xb4\x50\xf9\x34\x86\xdc\xc2\xce\x56\x95\x54\x87\xa5\x0f\xb7\x19\x14\x3f\x99\x0e\xe1\xbf\x68\x31\xd0\x95\x51\x57\x24\x3b\xd5\x3a\xab\x79\x9a\x4f\x22\xcb\xc8\x1f\x57\x7a\x8d\x82\xce\x5e\x1f\xd2\xb1\x66\xa1\xfe\x34\x07\x4f\xe9\x23\x76\x8e\xf1\x34\x57\x8c\x7e\x34\xb3\xd3\xec\x10\xbd\x33\xa7\xba\xcc\x96\x69\x20\xf0\xc2\xc6\x73\x3a\xa6\xf6\x75\xde\x00\x17\xd7\xed\xf5\xd7\x9f\x53\x66\x0e\x5d\xf6\xc9\x63\x9b\x6b\x1a\xeb\x6c\x66\x61\x1e\x88\xef\x3b\x75\xfe\xdc\x8a\xe9\xd7\x5f\xfa\xfe\xa6\x81\xae\x30\x9c\xcb\x2e\x82\xa0\x77\xc0\xb5\x6e\x27\x06\x8e\x34\x56\x3f\x0e\x56\x66\xec\x59\xbe\x36\x50\x3b\x50\x3b\x5c\xfb\xc3\xda\xd7\x6b\x59\x03\x5d\x5b\x4b\x34\x3e\x0e\x46\x1e\x09\xe9\x1d\xfa\x49\x06\x2c\x0a\x68\xcd\xe0\x4a\x54\xe0\x09\x13\xd8\x96\xe5\x6b\xdc\x35\x0a\x95\xba\xda\x94\xc6\xa5\x99\xce\x6b\x89\x1d\xe7\xd5\x72\x97\x5f\xe5\x98\xb3\x17\x1a\xf7\x90\x96\xa9\x8c\x69\x54\x9e\x16\x40\xed\xb2\xe8\xdb\x26\xb7\xd7\x96\x35\x4a\x12\x57\xdd\xd9\xd3\xec\x13\x38\x3d\xef\x2e\x9b\x69\xb6\x78\xc8\xae\x3b\xb6\x77\xef\x9d\x3d\x6d\xe0\x92\xcd\x33\x47\xd6\x54\xcc\xb8\xaf\x7f\x79\xe7\x05\x7d\x17\x7f\xb8\xa6\xb1\xb3\x7c\x7e\xbb\x95\x31\x1a\xbd\x6d\xdd\xc9\x65\x16\xe9\xf2\xd9\x93\x87\x96\xef\xff\xec\xfe\x6b\xce\xdc\x1e\x7f\xf4\xad\xe1\x07\x6f\x1b\x7a\xf4\x25\xe5\x1e\x24\xbf\x75\xe0\x1d\xf0\x67\xfa\x61\xe8\x2f\x3a\x8f\x1a\xca\x22\x11\xa7\x2a\xb9\x88\x2a\x39\x6c\xf9\x40\x3d\x3e\x83\x28\x35\x35\xda\x49\xa9\x46\xb0\x20\x41\xd0\x3b\xa7\xd1\x5d\xd5\x76\xfa\x56\x9b\x51\x36\x4a\x8b\x3a\x7c\x81\xb4\x9c\x4a\x4d\x8d\x48\xac\x9f\x3e\xd3\xdd\xd9\x3c\xf9\xd1\x55\xc3\x3d\x69\x33\xcb\x70\x93\x3a\x5b\x12\x41\x7f\x66\xd6\xe0\x45\xd6\x80\x6a\x8f\x89\x95\xca\x7a\xea\x0e\xa8\x3f\x41\xb4\xb7\x64\xb0\x0c\x3a\x11\xea\xde\x32\x8e\xdb\x5b\xc5\xea\xa2\xa3\xd0\xa1\x8f\x2c\x85\x8a\x47\xf4\xe7\xde\xb6\x3e\x9f\x9d\x8e\x91\xd1\xc9\x8d\xe6\x9f\x73\x89\x40\xc0\xc8\xd3\xcf\xe9\x83\xe5\xd4\x9c\xb6\xfe\x29\x07\x04\x39\x98\x6e\x92\x67\x7c\x35\xa3\x22\xe0\x74\x59\x02\xf4\xa4\x36\x5d\xd8\x86\x7c\x54\xed\x6c\xf2\x10\xe1\x23\x36\x16\x8a\x13\x7d\xae\x0d\x7e\xae\x9b\xf0\xe0\x67\x77\x5e\x9c\x68\x15\x10\x11\x7a\xa8\x64\x28\x68\x5d\x48\x68\xeb\xc1\xab\x47\xf7\x1c\x55\xee\x99\xd1\xde\xeb\x87\xa3\x00\xbb\x56\xad\xad\xbe\xed\x82\xd1\x96\xad\xc0\x07\xe8\xcb\x0e\x76\x0c\x76\xdc\x28\x78\xdc\x9d\x57\xef\x79\x46\xe9\xbb\x13\x99\x73\x38\xef\xe5\x63\xbf\xa7\x76\xb0\x57\x13\x53\x88\xc0\x24\x03\x3c\x6d\x16\x13\x8d\xf0\xf4\x29\xd3\x26\x5f\x96\x3f\x7d\x72\xb3\x57\xd7\x3d\x56\x30\x32\xb2\x4a\x1f\x83\x6f\x0d\xd4\x91\xa8\xae\x90\x94\x67\xa0\x86\x9b\xa8\x11\xe1\x91\x7c\x32\xd8\x6a\xe1\x58\xaf\xd7\xe1\x12\x42\xe5\xcd\x70\xc4\x75\x99\xc6\x68\x72\x6d\xa8\x06\x1c\x6c\x9f\xec\xed\xa8\xef\x78\x7d\xed\x0a\x72\x52\x75\x75\xf4\x9a\x97\x2f\x5a\x5c\x6b\xab\x9c\x49\x0d\x25\xbb\xc3\x0b\x3b\x2b\x26\x35\x54\x0a\x22\xcf\x59\x1a\x9a\x16\xb4\x58\x4d\xb2\xc1\xea\x92\xad\xe9\x96\x0b\xcf\xf6\x39\x3d\xad\xb3\xaf\xfe\x6f\xba\xe7\xfc\xae\x8e\xfe\xba\x64\x67\xd2\x37\xef\xf0\xd9\xd3\x66\x9e\xd5\x57\x1b\xb6\xa0\xf3\xa0\x1b\xef\xa3\x87\x09\x27\x51\x4e\xc4\x1e\x09\x41\x91\x6a\x6b\x8b\x64\x2a\xc2\x63\x16\x3d\x8b\xc5\x5b\x45\x3b\x11\x9a\x4a\x0e\xfb\x90\xd8\x49\xe1\x32\x3c\x38\x87\x10\x34\x6b\x60\x6e\x5b\xfb\xf4\x90\x93\x8e\x90\xf2\xee\x25\x2b\x3b\x8f\xaf\x19\x72\x4a\xfe\xe9\xe4\xca\x48\xca\xd3\x38\x49\x59\x37\x7b\x8a\xcf\xa9\xa7\x86\xba\x07\xa6\xee\x36\x85\x9c\x23\x97\x9e\x39\xfa\xde\x7f\xc0\xef\x2f\xeb\xab\x9f\x3e\xfa\xb7\xb9\xff\xc9\x36\x65\x3c\x93\x97\xdd\xfc\x3f\xd3\xa0\xdc\xbf\x1c\xfb\x92\x1e\x82\x72\x6f\x22\xba\x1e\x4d\x48\x8d\xc9\x24\xda\xca\x2b\xe1\x98\x92\x60\x04\x3a\x2a\x32\xde\xd6\x21\xe8\xa4\x58\x1a\x1b\x9b\xd4\xfd\xd0\x58\xe4\xa4\xe4\xaa\x58\x5a\x54\xca\x51\xac\x81\x41\x68\xec\x91\x67\x90\x16\xd4\x5a\x83\xdc\x5c\xb4\xa3\x80\xf5\x21\xde\xc3\x2e\x10\xb4\xe1\x79\x51\x89\x44\xd8\x36\xb8\x73\x9b\x52\x76\x39\x23\x4a\x75\x3e\x7a\xee\xef\xcd\x2b\x56\x36\x87\x1d\x64\xb4\x3a\xd3\x63\x34\x92\xeb\x4e\x17\x17\x82\x55\x8b\xe7\x8e\x3e\xbc\x1a\x04\x04\xcf\xee\x1b\xcf\xdd\x76\xfc\x75\xb7\xe4\xf6\xc1\xdd\x2a\xca\xee\xf4\x86\xbe\x73\xed\x2e\x77\x6b\x8a\x8f\x55\x88\x3a\x5d\x76\x55\x83\x41\x89\x5e\xab\x7c\xe7\x41\x10\x40\xba\xa5\x57\x96\x83\x8f\xe1\xfc\x06\xd0\x9e\x4a\x83\xe5\x88\x6c\x21\xaf\xdb\x25\xe7\x95\xc6\x17\x2c\xa9\x87\x03\x2e\xff\x83\x0b\x8d\xfe\xaf\xc3\xf6\x98\xc2\xf7\xe6\xaa\xfa\xa5\xa1\x38\x54\x2d\x8c\xfc\xba\xba\x45\xf2\x47\x2c\x7a\xa3\xce\xe8\xd8\xd3\x1c\x63\x29\x3d\xa9\xb7\x38\x6c\x92\x57\x34\x33\x34\x2f\x3a\x64\x49\x30\x53\x14\x67\xe1\x02\x21\x9f\x8e\x73\x31\x2c\xc3\xb0\x26\x8b\x60\x3a\xc3\xc0\x5b\x6c\x26\x9d\xcd\x6a\x14\x83\xd4\x50\x6f\x5b\x62\x76\x57\x39\xab\xd7\x5b\x8c\x1c\x1f\x8b\x18\xfd\xb6\x6a\xb3\x3b\x58\xe1\x0e\x24\x6b\xea\x43\xd2\xa2\xed\xd7\x5e\x7f\xd5\x79\x73\x78\x8b\xc5\xac\x17\x45\x1b\xcd\x9a\x59\x9d\x8d\x77\xd4\x64\x16\x75\x93\xad\xe9\xbe\xda\x90\x8d\x73\x7b\x3d\x06\xa3\xa0\xfa\x75\x77\x41\xc5\xfb\xff\x31\xf6\x1d\xf0\x71\x54\xd7\xde\x73\x67\x66\x77\xb6\xcf\x6c\x99\x9d\xed\xbd\x6b\xd5\x76\x25\xad\xfa\x8e\x64\x49\x96\x2c\x4b\xb2\x6c\xc9\xd6\x4a\xb6\x5c\xe4\x22\xcb\xdd\xb8\x62\x6c\x6c\x9a\xb1\x0d\x18\x70\x4c\x31\x06\x0c\x06\x12\x08\x98\x66\x30\xa1\x06\x82\x09\x81\xd0\x92\x40\x0a\x79\x21\xa4\x17\x12\x20\xa4\x91\x58\xa3\xef\xde\x99\x6d\xb2\xcd\x7b\xdf\x4f\xc1\x48\xfb\x78\xd6\x39\xf7\x9e\x7b\xce\xff\x9c\x7b\xee\xff\xd4\x41\x3f\x52\x02\x71\xa6\xdb\x28\x6d\x9a\x1b\x6e\x21\x26\x23\x65\xb9\xcc\xa2\x18\x67\xa2\x97\x36\x30\x61\x48\x54\x87\x51\x69\x30\x25\x8e\x5b\xca\x47\xcb\xdc\xbe\xa1\xe3\x04\x01\x37\xf8\xa8\xc5\x2b\x04\x77\x02\x53\x50\xce\xe9\xb8\x96\x3a\x7b\x6d\x55\x97\x55\xad\xc4\x1b\x87\x5b\xe3\xc6\xc8\x40\xa9\x02\xf8\x83\x4f\x77\x02\xa7\xd9\xd6\xd0\xe8\x74\xa7\x9f\x74\xb5\xd5\xcc\x9c\x71\xaf\x42\x63\x75\x44\x4b\x42\x65\xab\x3e\xdc\xce\x5f\x6d\x43\xe7\xa2\x77\xea\xaf\x64\x0a\x9e\x0b\x07\x16\x46\x68\xd8\xfb\x9c\x68\x74\x66\x08\x95\x9c\x98\x2e\x0b\x95\x74\x05\xa8\x54\x52\x84\x93\x90\x4c\xe6\xec\xc1\x20\xb3\xc7\x1b\x55\x82\xbd\x52\x0b\x27\x60\x1a\xaa\xbd\x35\x2c\xa3\x24\x69\x13\x2e\xdf\xb3\xe1\x84\xf0\xd9\x43\x6f\xbf\xbc\x79\xcd\xfe\xef\x01\xe7\x9b\xbf\x9e\xd3\x43\xcc\x4d\xce\x4a\x8e\x77\x92\x0a\xaf\x4e\x75\xe6\xc5\x1f\x08\xd7\x9f\xfd\xde\xbb\x97\x7d\xba\xe4\xf0\x7b\xbf\xf8\xd1\xf3\xa3\x73\xd0\xfa\xbd\x0c\xcf\xec\x5c\xb8\x7e\x0b\x20\x2e\xee\xd1\x56\xb7\xc0\x28\x37\xf1\x44\xc6\xda\xf2\x0c\x5c\xc3\x05\xd1\x48\x54\x92\x2e\x52\x58\x43\xa9\x0f\x47\x3c\x02\x48\x44\xf1\x35\x42\x09\x98\x8e\x82\xa0\xe5\x8b\x4d\x51\xac\xb8\xd8\xc9\xfc\x8c\xf7\xd4\xf4\xff\x2c\x97\xe2\x48\x45\x50\x4e\x1a\x72\xf5\x96\x9b\x61\xcb\x4b\x1b\x54\x0d\x5c\x7d\x99\xb7\xdc\xc0\x51\xc1\x8e\xdd\x3b\x3d\x31\x7d\x53\xec\xdc\xb5\x97\x3e\xa4\x33\xea\x8d\x7a\x4f\x4d\x63\xda\x97\x34\xb2\x64\x65\xe5\x8c\x98\xc9\xc8\x51\x8a\x80\x83\x0d\x04\x2a\x2a\x9b\x81\xd3\x64\x1d\x18\xdf\x3e\x77\x9d\x45\x11\xad\x6a\x8a\x8e\x34\x9a\xbc\xa6\x75\xad\x7f\x6e\xb9\xa7\xa7\x76\xc0\x11\xb9\xb1\x0d\x38\x6d\xed\x9c\x7b\xc6\xcc\x9e\x68\xed\x60\x47\x55\x4b\x62\xb0\x9a\xb1\xbb\x8c\x25\xe1\xc0\xcc\xb8\xc1\x17\x8b\x2e\xbd\xba\xa5\x7c\x6e\x97\xe8\xa7\x9b\x60\x7c\xfa\x31\x5c\x17\x1e\x2b\x79\x3c\x56\x03\x17\xe5\x74\x26\x16\xd3\x58\x9f\x01\x63\x4f\x06\x2e\x86\x6f\x51\x77\xf1\x05\xf8\x56\xec\x00\xcf\xc6\xac\x50\x2e\x68\x79\xb3\xfd\x62\x12\x04\xa8\x4e\x89\x0f\xba\x72\xc7\x0d\xe0\xd5\x51\x7f\x85\x9e\x25\x43\xe0\x6f\x7c\xa7\x8b\x79\x93\x8a\x7b\x5d\x6a\x85\x9c\xfc\xb6\xc2\x13\x14\xee\xa8\xc9\x44\x9d\x3d\xfc\x7c\xbf\x09\x0f\x27\x07\x4c\x7a\xb5\x2a\xbc\x7d\x05\x31\xd0\xd2\x1a\xdb\xd0\x61\xb0\xba\xac\x55\xa9\xe8\xe8\x7f\xf7\x87\x3d\x56\x0b\xa9\x70\x92\xed\x28\xdc\xd9\x97\xfa\x4c\xf2\xfa\x74\xfd\x69\x63\xd8\xe9\x48\x95\xd2\xeb\x2e\xfb\x43\x2f\xda\xf7\xb7\xe0\xbe\x63\xd0\x57\x34\x60\xa9\xc7\x75\x50\xad\x89\xa7\x33\x3a\x5d\x7d\x65\x7d\x83\xa4\x59\x3d\x58\xfa\xa4\x22\x50\x19\x90\x7e\xaa\x2c\x32\xce\x6c\x4f\x1c\x32\x00\xe9\x09\x63\x4e\x1f\x69\x2f\xa1\x3e\xa8\xb1\x38\x17\x8a\xfc\x17\x2e\x08\x72\x84\x78\xe7\xd8\xe5\x7d\xf3\x47\x85\xf7\x42\xd5\x91\xc0\x81\x58\xbd\x89\x25\xe7\x2f\x42\xc5\x46\xa3\x29\xd3\xa3\xac\x8a\xf9\x13\x06\x14\x50\x8f\x6d\xb8\xa4\xe2\x1b\xdb\xcf\x7d\x02\x03\xea\x82\x1f\x2d\x1b\x9a\x63\x68\x34\x18\xd4\xfb\xc2\x1b\x7a\x0c\xe1\xba\x26\xab\xa3\x3e\xb2\xf1\x8d\xf6\x96\xb6\xf8\x9a\x0e\x18\x66\xeb\xaf\xfd\xda\xd3\x42\xf5\x2d\x62\x98\x85\xfb\x87\x0b\xbb\xc8\x25\x50\xbf\x56\xac\xf2\x09\x4c\x1b\x78\x11\x22\x8c\x3a\xe8\xe7\x91\x87\xaf\x83\xa6\x6d\x25\xb4\x84\x84\xa8\x8b\xb2\x28\xe9\xc1\x07\xba\x45\xc2\x52\xc5\x9e\x3c\x47\x85\x0e\x37\x0a\xcb\xa6\x54\x50\xd3\x26\x94\x74\x4b\xdd\xe2\xb9\xff\x96\x93\x6e\x87\x74\xf8\x7f\x96\x80\x35\x07\x86\xfa\x9d\x7a\xb2\xae\xb3\x3c\x6a\x0e\xd1\x72\x1d\xad\x2a\x11\xc2\x1f\xf5\x3b\xfc\x72\xd2\x38\x57\xc5\x1c\xf0\x65\xc2\x6c\xfd\x68\xb7\x4f\x87\x97\xd8\xba\xd2\x8d\x7d\xad\x3e\x30\xba\x15\xf4\x2e\xdb\x50\x79\x93\xce\xee\x32\xc5\xa3\xa5\xeb\x34\x6a\x61\xf5\xe4\xe9\x3b\xcf\x72\x72\x63\x9c\x51\x12\x9a\x97\x0f\x35\x44\x75\xfe\x0d\xa9\x03\x30\x20\x13\x7c\x79\xcb\xd8\x9e\xfd\x47\xc4\xbb\x32\xb8\x97\x51\x68\xab\xb3\xb1\xd6\xa7\xda\xc2\xdd\x35\x36\x5a\x52\xcd\x06\x15\x6d\x89\xd5\xc4\xa4\x9f\x6a\xe0\x4f\x33\x67\x77\xcf\x96\xb6\xb4\xbb\xc8\x2b\x16\x36\x56\x0c\x6d\xd5\x55\xe1\x60\xce\x39\x86\xb2\xca\x99\xa7\x1d\x6c\x17\x0e\xa3\x5a\x31\x9a\x3f\x0f\xd1\x72\xa2\x0f\x85\xdb\x3c\x64\x60\x84\x73\x3d\x11\xaa\xd2\xe7\x1b\x6d\xb7\xcb\x94\x72\x77\xf9\x4e\x83\xcb\x4c\x07\xcb\x07\x6a\x8f\xcd\x61\xca\x5c\x6d\x5e\x9d\xbc\xb2\x81\x4f\x86\x19\x85\x5a\x6b\x2a\x7f\x75\xf4\xf7\x51\x66\xd1\xb9\x5f\xed\x00\x56\x15\xa5\xfd\x55\x4b\xad\x87\xd3\x5f\xc2\x99\xd5\x57\xd7\x6c\x51\xc8\x83\xa6\x01\x4b\x90\x9f\xe9\x32\x87\x13\x15\x6d\xf3\x4e\x36\x54\x55\x34\x1f\x66\xdc\xb6\xca\x44\x60\xa7\x46\xf3\xd1\xb1\xf7\x42\x7e\xb3\xe7\x79\x60\x95\xee\x65\xfe\x0a\xf7\x5f\x03\xf7\x9f\x81\xa8\x3e\xf8\x24\x86\x35\xfa\x5a\x94\x10\x68\x29\xa0\x1d\x34\x62\x15\xe2\x12\x34\xe6\xc1\x96\x94\x9b\x26\x58\x02\x81\xdd\x6a\x14\xf0\xa4\x4d\x17\x13\x68\xa8\x70\x0e\x5a\xa5\xf3\xb0\xa4\xd8\xac\x81\x49\x7d\x4a\xe6\xf0\x06\xb4\x0c\xf9\x10\xae\xa9\x89\xe3\xc3\x2d\x1d\xee\xa0\x71\x78\xe9\x7b\x6d\x29\x7c\x46\x3c\x1e\xfa\xcd\xef\xe7\xb4\x19\xca\x3a\x85\x81\x1e\xde\x9f\x64\x58\x88\x57\x5f\x56\x9e\x73\x5b\x6c\x16\x83\xc9\x4b\x3c\xa3\x37\x78\x39\xf0\x90\xbb\x63\x68\xe3\xd7\x32\x3b\x9a\xae\x2c\xed\x0c\x56\x56\x34\x95\x3b\x6f\xbf\xe5\xe6\xe4\x25\x0b\x13\x5e\x6d\xba\x37\xb2\xa2\x13\x1a\x78\x16\x37\x4f\xfd\xbd\x18\x37\x2f\xfd\xff\xc4\xcd\x59\xc5\x2e\x44\xcd\x87\x71\xad\xa9\x4f\xad\x23\x77\x9f\x8f\x9a\xcf\xbd\xa3\xb5\xb1\x4d\x3a\x37\xfe\xa2\x88\x9a\xd1\xef\xbe\x09\xc3\x64\x1f\xc2\x35\x1d\xc6\x92\x67\x30\x57\xb2\x81\x9c\xd3\x31\x07\x7a\x8e\x27\x33\x51\x6d\x07\x8a\x17\xa9\x01\xeb\x80\x64\x5d\xd6\xa2\x78\x21\x4d\x03\x44\xa5\xc1\x70\x3e\xa8\x49\x65\x13\x4a\x4c\xfe\x08\xaf\x18\x1a\xf2\x22\x9b\xb9\xa2\xf3\xa6\x37\x71\xa8\x06\x90\xfd\x7f\x84\xff\x17\xb7\x44\x3a\x21\xb5\x28\x42\x57\x22\x46\x20\x99\xca\xdf\x1f\xad\xa7\xd5\xa4\xab\x77\xa8\xbc\x6a\x82\xdf\x3a\xef\xd5\xc9\xf5\x4e\x6f\x74\xf6\x2c\xaf\x06\x77\x26\xbb\x12\xf0\x00\x6a\xb5\x96\x51\x6b\xcb\xe1\x13\xb5\x6d\xa1\x5a\xbd\x1a\xe0\x46\x47\x79\x4d\xaa\x54\x4b\x39\x8d\x96\xe4\xdf\xf7\x81\x57\xaf\x5e\x36\xab\xbb\x82\xd8\x6a\x56\x18\x97\xc4\x7a\x52\xb4\xda\xae\xa0\xf5\xf3\x5a\x5a\x7b\x56\xf1\x27\x6f\x14\x1e\x00\x65\x6f\x1c\x79\xa1\xc5\xd2\xdf\xbe\x5b\xa7\x63\x2d\x04\x19\xaa\x09\x6d\xd5\x6a\x85\x87\x0f\xdc\xb2\xfc\xdd\x3f\xce\xd7\x8c\xf9\x87\x66\x28\x02\x1c\x2e\x23\xe2\x75\xe5\x1b\x48\xae\x5a\x38\xf6\xdd\x5f\x5e\x3b\xa7\xa7\x45\xc4\x28\x4f\x4c\x7d\x42\xae\x84\xf1\xbf\x16\x2b\x7b\x4a\xa6\x2a\x53\x2a\xb3\xf5\x30\x25\x74\xb2\xa6\x1a\x4f\x16\x6a\x7a\x8a\x9d\x2c\x26\xdd\xb8\xc0\x93\x96\x8d\xa1\x89\x54\xf8\xab\x1d\xaa\x14\x3d\x52\xd9\xfa\x99\x0e\x00\x3b\xad\xa7\xe7\x54\x0b\x7f\xb9\x72\xa1\x87\x20\xcd\x2b\x57\x9a\xbb\xf8\x50\x15\xa3\xa7\xbc\x78\x70\xf1\xe2\xf0\x35\x21\x73\xbb\x56\xa7\x8e\xcd\xaf\x9b\x2d\xec\x9b\xb7\x08\xc7\x43\xad\x30\x32\x70\x4f\x8c\x42\xcc\xc9\xa4\xbb\x76\x3e\x37\xd8\xd6\x1d\x5b\xd1\xaa\xf2\x5b\x4a\x56\x6c\x3c\x30\x39\xe6\x33\xfb\x55\x4a\xe7\x16\xf0\x9d\x55\x8b\x1a\x5a\x1e\x96\x38\x16\x06\xa0\x1d\xde\x4a\x3e\xcd\x84\x64\x32\x0c\x63\x28\x99\x0c\x7c\x24\x7e\xbe\x01\x7e\x7e\x9f\xf8\xb9\x32\xfb\xf9\x27\xd2\xe7\xe0\xa7\x04\xcc\x37\xf3\x9f\x2b\xf1\x6c\x9d\x03\x3f\x0c\x3e\x23\xd7\x61\x2c\xa6\x7e\x5c\xcd\x3e\x83\xd6\xe0\x2d\xf1\x2c\xc2\xc3\x47\x4a\x35\x37\x59\x12\xbc\x6f\xe7\x98\xce\xee\x35\x2e\xb6\x8d\xd1\x32\xe5\x6d\x8b\xa2\x6e\x72\x1d\xad\xf5\x58\x57\xaf\xbb\xd9\xab\x57\x58\xb8\xae\xb5\xb7\x77\x8a\xe7\x1e\xfd\x7d\x84\x57\xfc\xfb\x4a\x30\xfa\x49\xaf\xba\x44\xfa\x3b\x93\x6f\x25\x2e\xf8\x5b\xbd\xff\xe7\x2f\x01\xd7\xff\x7f\xfc\xde\x8b\xca\x31\x05\x51\x04\xd1\x43\x3c\x81\xd1\x98\x01\xb1\xb2\xe8\x75\xb4\xd6\xa0\x91\xcb\x18\x86\xd4\x50\x94\xd1\x44\x93\xa4\x51\xaf\xeb\xcd\xe8\xf5\x38\x23\xa3\x29\x8d\x86\xa4\x71\xba\x37\xa3\x42\x2d\xff\xd3\xdf\xc9\x16\xf5\x87\x1a\x24\x66\x81\x3a\xb1\xc9\x3f\x25\xbe\x88\x4d\x1a\xc5\x97\x0f\x61\x2f\x05\x08\xef\x21\xb5\xf0\x3d\xd5\x2c\xf0\x9b\x1f\x3f\xd6\xae\x12\x3a\xd5\x1b\x4a\x85\x33\x3b\xc0\xc6\xd7\x80\xbc\xb1\xb1\xce\x44\xac\x38\x77\x87\xb1\xbe\xd1\xf0\xbb\xdf\xe2\xf7\x09\x77\x88\x32\xf2\xf0\x3c\x97\x10\x0f\xc3\xec\x33\x8c\xdd\xcb\x2f\x09\xbb\xdc\x41\xa7\x03\x0b\x85\x1c\x2a\xbd\x52\x69\x30\x38\x1c\x01\x0b\x41\x44\xdd\x81\x40\x24\xe0\x70\xfb\xdc\xbd\x99\xb0\x0b\x8a\xa8\xef\xcd\xd0\x61\x77\xb8\x3c\x4c\x28\xfb\x54\x8b\x55\x38\xad\x72\xab\xd0\x37\x1b\x54\x32\x0d\x11\x56\x85\x55\xb8\x8f\xb5\xd8\x6c\x86\xde\x8c\x8d\x0d\x61\xe2\xd0\x73\x65\x6f\x86\x44\x93\xcf\x93\x25\xc5\x11\x47\x7c\x5b\x89\x5e\x35\x8c\x2e\x2a\x91\xe8\xc9\x24\x55\x93\xb9\x57\x96\x85\x17\xc0\xd2\xb3\x06\xd4\xc3\x2d\xcd\xd5\x4a\xa6\x92\x84\x3f\xec\x27\xb2\x93\x58\xbc\x69\xdc\x2b\xcd\x9b\x07\x46\x80\xeb\x47\xd5\xc4\xba\x78\xb7\x7c\xce\xa1\xa1\xfa\x67\xc2\xdd\xd5\xdd\xf8\x33\x4d\xa3\x0b\xb6\x27\x3a\xbb\x9b\xcf\x3d\xac\x3e\x14\x16\xde\xbd\x7f\x58\x2d\x3c\xa4\xde\x81\xaf\xee\x16\x9e\x45\x7d\xda\x5f\xde\x46\x09\xdf\x5a\x25\xbc\x3f\x21\x3c\x28\x23\x4e\x09\x9f\xb5\x5a\x7e\xfa\x53\x71\x34\x41\x12\x3c\x2c\x0c\x88\xbd\x93\x60\xea\xcf\xb2\x7d\xc4\x59\x4c\x81\xc5\xb1\x26\xc4\x0f\x60\x27\x2a\x95\x9e\xb2\x32\xcc\x54\x6b\xa2\x43\x74\xa8\x39\x5d\xea\xf1\x34\xf8\x1b\xfa\x33\x7e\xc6\xc6\xb9\xb8\x39\x19\x65\x65\x25\x56\x65\xc4\xfa\x32\x46\x63\xcc\xc5\xc4\x34\x55\x72\x8d\xbc\x2f\xa3\x29\x7a\x65\x99\x7b\x91\xa6\xcf\xcf\x67\x39\x7f\x22\x93\x3e\x59\x57\x27\xd2\x48\xe4\xde\x18\xe4\xda\xb5\x51\x52\x29\x36\x0f\x88\x54\x00\x9e\x5c\x53\xbb\x98\x23\x18\x39\xf1\xcd\x5a\x32\x91\xa3\x7f\xc5\xcd\xfb\x1e\xaa\x74\xcc\xbc\xc2\x9f\xdc\xdf\x7c\xdd\xdd\xd7\x7c\x79\x9f\x6c\x6c\x61\x72\x55\x26\xbe\xe0\xed\x25\xd8\x54\x67\xef\xbd\xa3\x7b\x8f\xdf\x2e\x7c\x7e\xa2\xe6\xd6\x6f\x13\x03\x5d\xd5\xab\x83\xdd\xfb\xe7\x75\xa4\xe3\xbb\xc0\x69\xfa\xd8\x92\x58\xec\x87\x5f\xfa\x02\x1b\x17\x65\x6e\x5b\xaa\x6b\xdb\xb4\xcb\xdf\x90\xee\x9a\xfb\xc4\xc2\x05\x67\xee\x7c\x58\x78\xff\x94\x1f\xbf\xbd\x75\xf7\xdf\x46\x82\xa1\xc3\x5f\xec\x59\xb3\x75\x3e\x5c\xa7\xa9\xf7\xe0\x1f\x0f\x42\x9b\xb2\xc0\x08\x15\xc1\xb6\xf1\xad\x5e\x47\x24\x02\x38\xce\xc9\x3a\x69\x95\x95\x20\x82\xac\x8a\x8d\xc6\x1c\x40\xa3\xd5\xf4\x66\xbc\x5c\x9f\x76\xb1\x16\xa7\xb5\x6e\x2d\xae\x21\xb4\x5a\x85\x5e\x1f\x81\x67\x82\x46\xff\x28\x9c\xbd\x19\x85\x0a\xfe\x83\xc8\xd7\xb3\xed\xdf\x79\xe2\xbd\xe4\xf9\xec\xb8\xb9\x29\x9d\xd2\xc0\x3f\xe0\x97\x8a\xf2\x45\x9c\x11\xd2\x8c\x67\x59\x15\x32\x9e\x44\x0d\x91\x94\xd2\x16\xe2\xf6\x05\x7d\x6b\x3f\x79\x49\x58\xa0\x19\x6b\x5a\xcc\x2c\xae\x1b\xd1\x80\x9b\x7f\xf6\xf2\xad\xc7\x85\x5f\x3d\x3e\xb7\x29\xb9\xef\xba\x2f\x66\x0d\x2d\x3e\x52\x0d\xce\x24\x46\x36\xed\x6e\x84\xf6\xb0\x68\x18\xb4\x58\x5a\x97\xac\xbc\x25\xfd\x3f\x57\x0a\x27\x2f\x01\x6d\xf8\xca\xd1\x5d\xa2\x8f\xff\xfb\xd4\x27\xc4\xf3\xd0\x3e\x9c\x58\x19\xcf\xd9\x94\x4a\xb7\x81\x20\x5c\x14\x3c\xe1\x6a\x8a\x81\x90\x84\xed\xcd\x3d\x2b\x61\x5e\x4d\xbf\x5a\x92\x37\xf4\xe9\xaf\x49\x52\xd3\x5e\x93\xa0\x3e\x1f\xf0\xed\x9f\xfd\xed\x4e\xe0\x7b\xf6\x6b\xcf\x85\xfb\x89\xf6\xed\xab\x9f\x5e\xbd\x6f\xf3\xdc\x4b\xec\xa9\x79\xe5\xf3\x5f\x37\xbd\xfe\xe4\x33\xc0\x78\xa4\xea\x9f\xf7\x24\x0f\x4f\x1e\xdb\x7d\x28\x64\xba\xef\x73\xb7\x1f\x9e\xeb\x77\xa6\x26\x49\x37\xdc\x03\x05\xfc\x95\xb5\xbc\x9b\x94\xc9\x4c\x46\x4c\x6d\x54\x73\x16\x91\x9b\x92\x44\xfc\x94\x7a\x23\x5c\x64\x39\xe2\x38\x2c\x5a\xde\xc2\x0b\x01\xb1\x37\x05\x0d\xcf\x49\x18\x08\x54\xbc\x20\xfd\x41\x69\x40\x1a\xc1\x5c\x7b\x55\xcd\x35\x97\x1e\x7e\xe9\x71\xf0\xed\xeb\x85\x7f\x9d\x16\xbe\x71\x4a\xb3\xec\x9a\x11\x0d\xde\xb3\xf7\xea\x49\x25\x09\x6c\x78\x83\x70\xd5\x83\x53\xd8\x41\xa2\xd5\x82\xff\x1b\x11\xbb\x16\xe4\xd1\x63\x2e\x6c\x27\x3f\x8b\xb3\x99\xcd\x76\xbb\x4e\x4d\xd3\x2a\x03\xae\xc2\xdd\x1e\x9b\x68\x0c\x5c\x5a\x8b\xac\x81\x40\xd6\x80\xbe\xd9\xa0\xbd\x5b\xfb\xa8\x96\x42\x76\x41\xe9\xf5\x6c\xde\x2e\x1c\x39\xbb\xa0\xc4\xe7\x51\x17\x98\xc6\xb4\xf1\x10\xc5\xe3\xbe\x8b\xf4\x90\x8c\x42\x52\x11\x0d\xf5\x84\x6a\xe2\x8b\x8b\x14\x6a\x80\xc6\xd0\x00\x95\x3a\x0e\x95\x6d\x78\x9c\x79\xbc\x01\x2a\x4c\x3c\x9c\x57\x0c\xf4\x0e\x83\x39\x96\x56\xe1\x9e\xbd\x57\x0b\x8f\x0d\x0b\x4f\x42\xb5\x91\x0d\xfc\x1a\xda\xfe\x33\xe2\x8c\x81\xad\x7c\x9b\x96\x90\xbc\x28\xe6\xb0\x10\x0e\xc2\xe9\x42\x7e\x33\x2d\x3a\x4a\x62\x9a\xc7\x54\xa9\x6c\xb8\x0d\xea\xc4\x65\x5d\x26\x72\x96\x32\x5c\x74\x9b\x74\xd6\x60\xb2\x6f\x05\xe0\x37\x17\x52\x4f\x16\xd8\xe9\xd1\x3d\xe9\x57\x3b\x48\xf0\xe3\x11\x35\x51\x29\x7a\xc5\x83\xf5\x7f\x12\xbd\xe2\x9f\x9a\x6e\xcc\x7a\xc5\x93\xea\x65\xe8\xbd\xd7\x85\x6e\x50\xe2\xe7\x12\x39\xd4\xd0\x5b\x00\xc4\xa1\x06\xf7\xf3\xf7\x82\x1b\x20\xee\x46\x0a\x33\x62\x0d\xbc\x4b\xa1\xd3\x51\x04\x49\x62\x14\x65\x62\xf5\xea\x79\x19\x3d\x25\x4e\x96\x61\x8b\x74\x10\xc5\x7f\xad\x64\xda\xdc\x1f\x49\x5e\x91\x35\x3f\x57\xb9\x84\x3e\xec\xa5\x31\x0d\xb8\xf6\x96\x85\x1a\xe1\xf2\xcf\x47\xd2\x2d\x43\x43\x7c\xcb\x30\x12\xed\xdc\x29\xb8\xdc\xcf\xb4\x0c\xcd\x9f\xd1\x92\x59\x88\xd6\xfa\x97\x53\x7f\x23\xaa\xa1\x0c\x46\xac\x82\xb7\x18\x55\xe2\x08\x22\x13\xab\x60\xe0\x81\x43\xbc\x83\xf9\xdf\x2d\x46\x9a\x57\x0b\xbf\xb9\x40\x6f\x8f\x7b\x7d\x05\x56\x41\x70\xfb\x56\x0d\x2e\xd3\x6c\x58\x5a\x27\xdc\x7a\x73\x7b\xa8\x5b\xa9\x28\xe5\xe2\xdd\x6a\x62\xae\xb5\xa5\xc5\x3a\xf9\x73\xe1\x55\xf7\x2f\xf6\xe8\x4c\x6d\x22\x9e\xc3\x62\x30\xdf\x1a\x15\xed\x79\x09\x5f\xa1\x51\x8b\xb3\x06\xd0\x10\x62\x95\x4a\x4d\x91\xa4\x1e\x57\xe3\x06\xa3\x9e\xc6\x35\x3a\x68\xd5\x4a\x46\x41\x30\x84\x5a\x47\xab\x59\x8a\xec\xcb\x50\x6c\x3e\xe5\x10\x37\x6f\x1a\xc5\x63\x32\xcf\xeb\x98\x7f\x61\x5f\x98\x30\x9c\x9b\x32\x4d\x8e\xaa\x37\x0a\xef\x7d\xb6\x44\x2b\x3c\xf7\xd2\xde\xc6\xfc\x88\xe9\x2f\x89\x87\xd3\x8c\xf0\xb9\x60\xb2\x76\x81\x87\xfa\x84\xfb\xb3\xe3\xa5\x3f\x42\x6b\xf5\x00\xb4\xcb\x66\x71\xe6\xea\x62\xbe\x5c\xa7\xd7\x6a\x0d\x06\x8a\x44\x63\x93\x39\x8b\x15\x3d\xc4\xec\xcd\xe8\x28\x5a\x2e\xd7\x93\x8c\x8c\xa1\x65\xf0\x0b\xa8\x68\x0e\x00\x68\x8e\x80\xcd\xf9\x2c\x31\x58\xeb\x0b\x23\x72\xa6\x51\x22\xe4\xcf\x58\x14\xa4\x71\x2a\xfb\x10\x13\x4f\xd1\xc8\xd7\x42\xf3\xc3\x3f\x3d\x77\x46\xbd\x2c\xba\x9a\x1d\x9f\x35\xa2\x06\x93\xea\xa3\xa5\x2f\x9a\x5e\xec\xb8\xe5\xb6\xee\xe1\xee\x56\xcb\x6f\x53\x5b\x6a\xc0\x09\x14\x6d\xff\x33\xb6\x79\x4c\xd8\xa2\x7b\x29\xff\x96\xb6\x56\xe4\xb4\xcb\xf0\xa5\x56\x85\x8d\x92\xbb\x6c\x2e\x06\x43\xce\x0c\x60\x98\x97\xf1\xc8\x14\x0a\xb7\xc3\x61\xeb\xcd\x38\x68\xad\x79\x0e\x04\x52\x5a\xd6\x45\x99\x01\x1a\x3d\xfa\x16\xba\x53\x2f\xbf\x90\x6b\x32\x39\x8d\x66\x12\xf5\x28\x22\xe3\xfb\x4a\x8e\x49\x59\xed\xd1\x8c\x56\xf8\xfa\xff\xce\x30\x49\x3c\x8c\x4c\xf3\x7f\xe1\x97\x84\xf6\xb2\x7b\xea\x0f\xe4\x32\xa8\x8b\x15\x71\xc0\x71\x18\x66\xd2\x6b\x64\x72\xb9\x82\xd2\x53\x36\xbb\xc4\x16\x2c\xd3\x68\xa0\x0c\xfd\x19\x9d\x59\x9c\x72\xcb\xca\x0b\x33\x29\xf2\x24\xe5\xc5\x3c\xc9\xd2\xa3\xe7\x02\x91\xe9\x79\x23\x27\x6e\x1c\xe1\x4f\xf8\x27\x24\x16\xd3\xbb\x14\x77\x7c\xbc\x62\xb3\x76\x0c\xd1\x9b\xae\x34\xff\x64\xe9\xe1\x41\xbc\x1f\xd1\x97\x3e\xf6\xfa\xba\x95\xc6\x85\x78\xc4\xd2\x3a\xf9\xfa\x25\x12\xa6\xcf\x72\xbd\x19\xe4\x98\xf8\x16\x6d\xea\x43\xf8\xf3\x49\x18\xd3\xec\x58\x39\xcf\x69\x2d\x16\xa7\x91\x20\x1c\x46\xb3\x19\xfa\x61\x33\x83\x21\x50\x27\xce\x0f\xcc\xcb\x39\x2d\xa8\xa1\xf6\x51\x71\x35\x0d\xd5\x8c\xf4\xd4\x5c\x9c\x27\x81\x93\xa0\x66\xe0\x5b\xbd\xe1\x79\x84\x69\xe5\xdc\x89\x07\x96\xfd\x71\x6b\xa6\xba\xbf\xfc\xdd\x9b\xc0\xb7\x6f\x13\x7e\x6b\xf2\x79\x3e\xbf\xcf\x14\x3a\x00\x54\xc7\x20\xb4\xbd\xe7\x9f\x55\xc2\x81\x33\xc2\x9f\x6f\x41\x3e\xe7\x37\x18\x20\x5e\x20\x1e\xc5\xb4\xe8\xd6\x86\xa7\x09\x96\x75\x38\x55\x3a\x9d\x03\xb3\xb0\x94\x9e\x16\xb9\x53\x0b\x40\x39\x5b\x9d\x0c\x05\xc4\xc2\xa2\x0b\x88\x5d\x29\xa4\x41\xcc\x2a\x03\x21\x7c\xf5\xd6\xcb\x8e\x0b\x53\xd7\xac\x3c\x78\xe4\x3f\x02\xf3\xe1\xa3\xf7\x02\xf6\xb6\xf7\x9f\xba\x57\xf8\xf4\x38\x90\xb7\xa5\xf9\x03\x0b\x16\xb5\xf2\xbb\xba\x80\xfd\xd1\x8f\x8e\x0b\xff\xbd\xe3\xa1\xd7\x0f\x7d\x89\x78\xca\x60\x5e\x73\x96\x78\x1e\xc6\xf7\x18\x6f\xb4\xa9\x30\x1d\x45\xb9\x59\xcc\x05\x81\xae\x46\x69\x36\x10\x8c\x28\x81\x64\x6a\x89\xfc\x7c\x70\x22\xf7\x7b\xa9\x70\x35\xa2\x6e\x42\xbd\x1d\xa8\xe8\xee\x06\x6c\xb8\x0c\x14\xc5\xef\x1b\x26\xef\xc8\xc5\x6f\xf0\x19\x8c\xf8\xc2\x2f\xf2\x11\xff\x99\x35\x57\xe7\x22\xfe\xf7\x20\xbe\xfa\xc9\xd4\xb3\x64\x8c\xf8\x14\xe6\x37\x2e\x88\xda\xbb\xf8\x88\xd5\x6d\xf1\x90\x7e\xbb\x9f\xc4\xec\xb4\x5a\xad\x65\x64\x38\x26\x8f\x44\x3d\x56\x73\x38\x2c\xc3\xb5\x0c\x49\xd1\x06\xd6\x4c\xa2\xd1\xd7\xd9\xa1\xf6\xb9\xf9\xe6\xf9\x99\xf6\xf0\x33\xd4\xec\x93\x42\x32\x66\xc5\xe5\xd8\xb0\xb8\x54\xc0\x4f\x89\xcd\x0f\x01\xa3\x88\x40\xe1\x7e\x9a\x9b\x2f\x7b\x76\xfd\x09\xb4\x64\x8d\xdb\xcf\x4c\xdc\x27\xae\xda\x3c\xb5\x06\xfc\x60\x1c\x2e\xe9\x33\x42\x6d\xa2\xea\xc8\x7f\x8e\xe2\xde\xbd\x63\x6b\xf6\xde\xb3\x14\xad\xdf\xa5\x8b\x56\x5e\x76\x7c\xf0\xd0\x97\x20\x00\x84\x0d\x9e\xb9\x70\x79\x85\x45\x60\x3f\x37\x33\x08\xd7\x18\xe2\xea\x52\x78\xce\x8f\x43\x1b\x73\x41\x5c\x5d\x0d\xfd\x69\xa2\x42\x8d\xd9\x18\xb7\x9b\x2c\x2d\xc5\x42\x26\xcc\x54\x93\xf2\xd9\x92\x8e\x64\x5f\x86\x2c\x85\xff\x90\x3a\x8b\xc3\xcc\x44\x0d\xd1\xbe\x8c\x81\x51\x51\x3a\x6a\x4e\x46\xc7\x4c\xaf\x63\x15\xc8\x8e\x8b\x18\x5b\xb2\x2f\xe9\x61\xd6\x24\x21\xe7\x1c\x70\x4e\x70\xd2\x90\x13\x14\x0b\xc4\x46\x43\x11\x7a\x19\xb2\xb0\x39\xc7\xc7\x55\x53\x7a\xd5\x3f\xef\x91\xc6\x27\x0c\xbe\xbe\xe8\xfb\xf3\x2e\x7f\x01\x0c\xeb\xe6\x0b\x03\xcf\xf6\xed\x7d\xf0\xc8\x31\x42\x51\xd5\x30\x7b\xf1\xcc\xf2\xba\x9e\xe5\x9d\x93\x7b\x6e\x8f\x3a\xda\x76\x7c\x6b\xf8\xb6\xa5\xda\x36\x34\x42\x61\xe6\xc0\xe5\x97\x0b\x0f\xf7\xcf\x12\xcc\x57\x5d\xb5\xf6\x9e\xc1\x79\x77\x80\x0d\xcb\xfb\xfb\x8f\x0b\xb7\x66\xe8\x5b\xc7\x62\xb1\x37\xc4\x9c\x95\x84\xe7\x6c\x36\x5c\x03\x3f\x5c\x83\xad\x7c\x93\xdc\xa1\x74\x18\xd8\x30\x5b\x62\xf1\xd3\x44\x58\xa9\xf4\x12\x34\x51\x5a\x26\x37\x18\x5c\x51\x17\x54\x9c\x76\xb9\x5d\x10\x2d\xbb\x5c\x98\x46\x13\x40\x09\x85\xc5\xda\x97\xb1\x60\x3c\xe6\xef\x43\x94\x26\xd0\x6d\xd8\x2c\xcc\xdb\x17\x70\x2f\x62\x75\xd3\x68\xfe\x11\xdd\x10\xe2\x1b\x4a\x88\x0f\x41\xa5\xa2\x4a\x6e\xe6\xa3\x58\x68\x10\x3b\xa7\x53\x62\xb9\x2f\xcb\xb5\x95\x10\x6f\xb8\x60\x92\x61\xbb\xfb\xc8\xc4\xa2\x59\x23\x7f\xf8\xc9\x63\x4f\x5f\xb6\xa9\xbe\xe3\xf4\x59\x7d\x73\xf9\xfc\xd6\xce\x19\x87\x17\x0c\x5f\xfa\x18\x71\x56\xb9\x62\xc9\xf0\xc1\xa0\x69\xbc\xe7\xb6\x7b\x76\x6c\x9f\xb8\xd1\xca\x0d\xb7\x6e\xbe\x44\xbb\x86\x9e\xdb\xba\x6e\xcd\xaa\x11\xf6\xdc\xbf\x36\xaf\xdd\xf3\xc1\x35\x88\xa3\x1b\xfc\x04\xe6\x0a\x67\xa1\xd0\x11\xde\xa0\x50\xe2\x3a\xa5\x0e\xca\xa9\xd4\xf0\x1a\x19\xd4\x2b\xa7\xca\x5b\x89\x3c\xd4\x81\x82\x66\xc9\x47\x28\x6f\x4d\x40\xda\xb9\x03\xf6\x19\xb5\xf3\xd6\x04\x84\x4f\xe3\x80\xf8\x39\x18\xa7\xc1\x4f\x8e\x0d\xf6\xcc\x3e\xf3\xde\x7f\xff\x26\x9c\x9a\x39\x20\xc6\xeb\x06\xb8\xbe\xa7\xc0\x4f\xa4\xdf\xa3\x92\x31\x98\x0c\xd3\x1b\x18\x8a\xe0\x09\x6d\x9f\x44\x7b\x73\xe1\xef\x91\x93\x22\x13\xb6\x37\xf7\x48\x98\x38\x55\x2a\x4c\x7e\x24\x1c\xa7\x81\xde\xc5\xd7\x64\xd6\xfb\xc1\x4f\x26\x3f\x05\x73\x3b\x06\xee\x9f\xdb\xd9\xf5\xda\x2b\xe2\x3e\xfa\x60\x9c\x3d\x21\xe2\x22\x33\xd6\xc6\xfb\x29\xa3\x5c\x6e\x32\x29\x15\x84\x4e\xa1\xe3\x2c\x72\x25\xe2\xae\xa6\x20\xec\xa6\x28\x85\x9a\x56\x98\xb2\xa9\x0d\x76\x01\x57\x52\x11\xb1\x41\x42\xbc\x9f\x22\xc4\x80\xea\x41\x29\x8d\x38\x6c\x19\x3c\xb1\x72\xd7\x9d\x55\x33\x85\xaf\xdf\xba\x42\x0d\xce\x80\x83\x13\x67\x0f\x5d\x5a\x71\x54\x0d\x5e\x3d\xb8\xfd\x7a\x61\xb3\xd0\x88\x62\xff\xaf\x57\xdf\x3d\x5f\xf8\xdc\x3a\x03\xf9\xce\x47\xa0\x5c\xdf\x25\xbe\x0d\xb1\x92\x13\x5b\xce\x57\x6b\xf4\x7a\xab\x96\x61\x4c\x98\x45\xad\x52\x59\xad\x94\x1c\x93\xbb\xdc\x3a\x88\x9c\x74\xac\x5e\xc3\x21\x24\x8e\xb8\x3d\x29\x98\xea\xb3\x84\x1d\x2e\x10\x34\x2f\xe4\xdf\x4a\xce\x7b\xc6\x3f\x2d\x28\x15\x46\x44\x17\x5e\x2c\x71\x62\x78\x15\x49\x53\x40\x19\x08\xa2\xbb\x46\x23\xda\xbb\x1d\xbf\xfa\xbc\xed\x4f\xbd\x37\x8d\x28\x85\x9b\xda\x96\x4d\x09\x8f\x6b\x06\x00\xe8\x98\x03\x94\x23\xb3\x66\xb6\xf5\x7b\x86\x57\xe0\x47\x8e\x1d\x31\xe9\xce\x3d\x6f\x69\x05\x57\x0b\xbb\x5a\x38\x30\xcf\x7f\xd9\xec\x81\xa5\x60\xb3\x72\xa5\x54\xe3\x29\x81\xfa\xbc\x0f\xd7\x19\xf1\x52\x2d\xe2\x2b\xb4\x2a\x15\x4b\xd1\x7a\xab\x55\xa7\x54\x32\x14\x43\xe0\x14\x6e\xb3\x4b\xd3\xbb\x74\x10\xc3\x28\x75\x3a\x12\x90\x16\xc4\x97\x02\xa0\x92\x80\x9e\x46\x4c\x9a\x2c\xe2\x97\x28\xca\x21\x73\x49\x10\x62\x51\x90\xb8\x34\x10\x24\x48\x1a\x09\xc9\x81\x37\x00\x7c\xb1\x1a\xac\xf9\xba\x30\xff\xeb\x4f\xfc\x65\x4f\x9f\x1a\xcc\xd8\xb2\xbd\xa6\x63\xdd\xf0\xa6\xae\x99\xab\x88\x89\xd6\x73\x03\x57\xec\x7c\x96\x07\x63\x26\x5e\xd8\x06\x2a\x84\x6d\xfb\x26\x9a\xdb\x61\x0c\x79\x13\xca\x7d\xbf\x88\x59\x9b\x79\x97\x1c\xe2\x65\x83\x56\xa3\x31\xb1\x10\x2d\xf2\x72\x9d\x51\xd7\x97\x31\xd2\x94\x46\xa5\x41\x0b\x5f\xec\xd3\xf2\xb6\x59\x98\x0e\x87\xc6\xb5\xe6\xc7\x8b\x4b\x33\xfb\x89\xfb\x13\xdd\xba\xb5\xbd\xf6\xab\x8e\xaa\x27\x9f\x56\x7f\xe3\x2a\x5b\xff\x86\xce\xee\x04\x4c\x5a\x7e\xf9\x80\x71\x92\x45\x30\x16\xff\xb3\x11\x8d\x7c\x03\xd8\x28\x3c\x0f\x6f\x40\x39\xec\x58\x0b\xef\x51\xeb\x74\x72\xc2\x68\x32\xd9\xac\x84\xd5\xe1\xb4\x9a\x4c\x68\x7a\x0a\x0c\xf0\x0a\x1a\x63\xa6\x71\x21\x14\xb3\xb4\x15\x38\x05\x64\x79\xdc\x41\x17\x06\xd6\x65\x01\x36\x38\x71\xdf\x5d\x8a\xb9\xc3\xd0\x46\xd5\xeb\xe6\x52\x37\xf5\x0d\xb3\x83\x6b\xd5\xa0\x56\x3d\x36\x98\x32\x5d\x7a\x8d\xb7\x11\x57\x22\xd8\x37\x79\xae\x34\xf1\xb5\xa5\x97\xe1\x36\x6e\xc6\x0c\xf3\xe4\x9f\x85\x53\xe2\x99\xed\x9e\xfa\x8c\xb8\x8e\x78\x1f\xee\x70\x0d\x6f\x95\x9b\x11\x40\xc2\x55\x3a\xb3\xce\x66\xe7\x20\x7e\x62\x25\x00\x85\xa2\x2e\x12\x04\xfe\x99\x98\xce\x6c\x2f\xdd\x63\x84\xc2\x41\xbd\x2c\xc5\xe9\xc3\xd9\xcb\x89\x20\x15\xd6\xcb\xcc\xf8\xf1\xa5\xd7\x0d\x09\x09\xfc\x2d\x6b\xeb\xa3\xaf\x4f\x2c\xa9\xc8\x08\x6b\xa1\xa9\x3d\xb5\x05\xd8\x47\xd2\x77\x85\xe6\x02\xd5\x65\x10\xf6\x3d\x01\x61\xd3\xd8\x16\xfd\x4c\x04\x9b\x7a\xc5\x9e\x15\x02\xf3\x4f\x7d\x46\x7e\x08\x65\x42\xfd\xb7\x88\x5f\xaa\x54\x6c\x8f\x77\x95\x39\x03\x01\x9b\xcd\x17\x0a\x95\x11\x44\x22\x59\x6a\x2e\xb7\x58\xa2\x98\x5c\x63\x90\xc3\x2f\x77\x3c\xca\x06\x9c\x2e\x97\xc7\x5d\x90\x35\x07\xa5\xc5\xaf\xf4\xf9\x54\x44\xc9\x2c\xe5\x72\xbe\x83\x97\x28\xfa\xfe\xab\x95\x3a\x5e\xd1\xd5\x55\x51\xd9\xd1\x51\x59\xd1\xd5\x59\x09\xff\x4d\xb8\x90\x92\x7a\xfc\xaf\x79\x25\xbb\xa1\x92\x1f\x6c\x01\xec\xcc\x44\xa2\xbd\x2d\x99\x98\x09\x56\xce\x2a\xaf\x98\x39\xb3\x22\x31\x53\x38\x86\x14\x1f\x02\xaa\x2b\x0a\x8a\xf7\x20\xc5\x07\xcc\xe2\x5e\x8c\x4e\x29\x89\xc7\xc9\x6f\xc1\xbc\x67\x25\x5f\x63\xa0\xc2\x72\xa7\x13\x67\x38\x0e\x71\xbe\xd8\xcc\xee\xb0\xbb\x24\x2e\xf1\x3b\x28\x0c\x11\x2c\x98\xf6\xf5\xf9\xf0\x4f\x7d\x53\x3e\xfc\x84\xef\x5d\x1f\xee\x13\xf9\x1f\x0c\x52\x8f\x7f\xb2\x7c\x11\xaa\xdd\xc0\x03\x56\x9e\x85\x1e\xf9\x19\xf3\x45\x4c\xf0\x88\x97\x00\x61\x25\xa4\xa7\x39\x59\xac\xb1\x14\xa5\xa6\x6f\xe6\xcb\x68\x9c\xad\x90\x06\xdf\x15\xc7\xd9\x0a\x1e\xfc\x23\x71\x9c\xed\xf8\xe8\x59\x91\x76\x61\x31\xd4\xfa\xbb\x5b\xca\xc5\xf9\xb8\xfd\x40\x35\x4f\x9c\x8f\xbb\x00\xa8\xf6\x41\x55\x9f\x21\x3a\x4f\x2e\x1f\x5a\x8e\x5f\xf7\xca\xc2\x71\x43\xf7\x16\x9d\xa4\xb0\xc4\xc1\x70\x94\x78\x04\x33\x61\x95\xbc\x45\xcf\x00\xa0\xc5\x0c\x10\x44\xc9\xb4\x5a\xb3\x09\x3a\x14\x95\x09\x06\x01\x73\x96\xae\x7f\x7a\x71\x16\x9a\x9d\x3d\x7b\x47\x24\x31\xf4\x51\x30\xbb\x08\xa7\x00\x7f\xf4\x4d\x8f\x4f\xef\x28\xd5\xfc\xde\x36\x4f\xe8\xde\xf5\xfd\x26\x35\xf1\xc8\xe4\x66\x50\x9f\x58\xe6\xb1\x79\xcd\xda\x16\x2e\xb2\x70\xef\xe4\x08\xb1\x0a\xd5\x4b\xc0\xd4\xbb\x10\x13\x95\x88\xf9\xc2\x1c\x3e\x62\xa0\x75\x5a\x23\x6b\xd2\xa8\x55\x66\xb3\xc6\x48\x93\x36\x44\x56\x62\xd7\x98\x4c\x7a\x1d\x2a\x88\x90\x7a\xda\x6c\x34\xaa\x75\x66\xc9\xbc\xf2\xb4\x0f\x39\x34\xcc\x4d\x4f\x1a\x40\x55\x39\xc8\x0b\x26\xca\x06\x13\x9d\x24\x92\x99\xdc\xc0\x07\x34\xff\x70\xcf\x10\xd6\x6f\x5f\x25\xfc\xe4\xea\x6f\xce\x51\x83\x8a\x3d\xa0\x7a\xf9\xc6\xfb\x4d\x01\x82\xea\x30\xa9\x5a\x2c\x75\x99\x4d\x93\x23\xb8\x6d\xf2\x77\xc4\x4a\x98\x35\xac\xc7\xab\x26\xbf\x0f\x62\xc1\x9d\x62\xae\xf0\x1a\x3c\x20\xac\xe8\xdb\x1a\x78\xa7\x01\xa6\xc2\xac\x46\x01\x33\x1d\x35\xa1\x24\x60\xa0\xe3\x95\x34\xd0\x60\xd0\xb3\x19\xd0\x2c\xc5\x57\x25\xdf\x66\x7b\x2b\x9f\x35\xe4\x36\xde\x5f\xcc\x2e\x9e\xad\x5d\xd4\x2b\x70\xb2\xa3\x66\xb5\xb5\xb1\xb3\x12\xff\x9a\x72\xf2\xdc\xbc\xda\xcb\x3c\x73\x3b\x67\x25\x08\x8f\xc8\x25\x5e\x73\xee\x37\x76\xd3\x13\xc2\x59\x28\xc3\xef\xe0\xbe\xcd\x17\xeb\x2f\xf3\xf9\x12\xa5\xdd\x6e\xb6\x68\xb5\x04\x6d\x36\xbb\x4c\x04\xe1\xd4\x59\x2c\xf0\xf7\x5b\x2c\x2c\xc6\x31\x2c\x8c\x03\x26\x96\x26\xe5\x88\x09\x3d\x57\x97\x7b\x2d\x7d\xf6\x22\x4c\xe8\xc9\x02\xe5\x9f\xc4\x31\x31\x9d\x09\xbd\x40\x84\xce\x9c\x9b\x77\x7b\x8c\x5e\x75\xe5\xee\x7d\x43\x3d\xed\x0c\xb0\xf7\x9c\xa8\xaf\x87\x12\x3f\x46\x0b\x3f\x9f\xd8\x68\x8a\xf9\xe7\xfa\x37\xaf\x6f\x6f\x5b\x00\x62\x7e\x28\xf4\xa0\xf0\xbe\x76\xe3\xa8\x90\xe5\xcc\xfa\x0f\x94\x3b\x06\x71\x50\x14\x1b\xe7\x1b\xec\x72\x22\xac\xb6\x58\x4a\x3c\x06\x82\x88\xc9\x1d\x76\x0f\xa6\x66\x37\x50\x97\x4b\x34\x41\x87\xa9\x97\xa8\x77\xa8\x8f\x28\xb9\x86\xa0\x28\x0c\x8d\x04\xe9\xcb\xb0\x4c\x18\xc3\x7c\x7d\x45\xf5\x45\xf1\x4f\xa9\x07\x71\x93\xa1\xce\x50\x97\x3c\x9b\x28\x5a\x65\x11\x59\x48\x6e\x3b\x8d\x5f\xc8\x76\x86\x08\x6c\x44\x37\x2e\x0e\x59\x03\x6b\x1e\x7b\xf9\xd0\x5e\xb6\x7f\xd1\xc6\xfb\xca\xc7\x1d\x7c\x77\xd9\x9d\xb7\x3d\xf6\xf2\xe1\xdd\xa6\xfe\x85\x9b\xef\xaf\x5c\x6b\x87\x1f\x5c\x6f\x5a\xbb\x64\xd9\xd5\xdc\x66\xb9\x7c\x62\xfe\x46\xa7\xe1\x24\x00\x89\xb5\x4b\x96\x5f\x6d\xde\x24\x97\xaf\x99\xbf\x01\x7e\x20\x4c\x25\xe0\x99\xb2\x40\x1d\x05\xa8\x63\x04\x9b\xc1\x7b\xdc\x06\x92\x64\xed\xac\x2a\x64\x57\xd9\xa3\x31\x0b\xe3\x36\xc0\x0f\x7c\xb4\x02\xda\x73\x50\x8d\x29\xcc\xe2\x7d\x4d\x11\x51\x66\x81\x36\x37\x7b\xca\xa0\xf8\xe5\x80\x9a\xc6\x86\x51\x98\x44\x2f\xce\x65\x17\x0b\x0f\x94\x9c\xa8\x5b\xb1\xa6\x2c\xd6\xdc\x72\xe5\x92\x39\x33\x03\x4d\x5a\x67\x9c\x5f\x36\x77\x59\xfa\x87\x0f\x5f\x71\xa4\x7d\xdb\x95\xf1\x79\xad\x71\x7f\x7d\x63\x70\xae\xa9\xa6\xbe\x06\xfe\x8f\xfb\xc1\x2e\x53\xc3\xc2\xab\x4f\xf6\x9c\x7c\x77\xef\xfa\x81\x3b\xbe\xb6\x6d\x70\x86\x69\xd7\x0f\xb8\x5c\xcd\x87\x08\x42\xdb\x52\x63\x15\x3c\xa7\x54\xa9\x30\xb5\x5a\x43\x68\xd5\x2c\xae\x84\x69\xc9\x85\xe5\xba\x42\xc5\x21\x5b\xe6\x92\x02\xb6\xff\xc5\x9d\x1a\xfc\x47\xc9\x6e\xdd\xea\xd1\xe0\xd7\x3e\x45\xd5\x25\x14\x9e\xcf\x3d\x27\xd9\xc1\x4d\xf0\x77\x1c\x82\x38\x4d\x87\x35\xf1\x4e\x8d\x9a\x24\x55\x84\x56\x4b\x33\x32\x95\x8a\x26\xd5\x8c\x56\x9a\x69\x0c\x11\x8c\x62\xfa\x25\xd1\x05\x3e\xa8\x78\x78\x71\xd2\xc8\x11\x7b\x05\xbf\x7a\xd5\x5a\xe1\xf9\x11\xb5\xf0\x73\x75\x37\xf8\xed\xf7\x1e\xeb\x48\xdb\xf1\xd1\xc9\x7b\xed\xe9\xb4\x9d\x58\x79\xee\x58\x76\xa6\xe6\x42\x0c\x23\x5b\xe0\x1e\x89\x75\x0a\x29\xc2\x8a\xd5\x0a\x4a\x0f\xa3\x2e\xc4\xab\x1c\x9b\xaf\x53\x30\xa8\x6a\xa4\xa2\x29\xf6\xab\xeb\x14\xf9\x2a\x4b\x31\x05\x4f\xf6\xfd\xac\x88\x0c\x6b\x88\x32\x14\x77\xb2\x0c\x3b\xbd\x62\xdc\xb1\x2e\xd8\xa2\x15\xf6\xac\x34\xe3\xef\xc3\xf0\x25\x91\xe8\xa0\xf0\x55\x75\xa5\x60\xb6\xb4\xe2\x75\x5b\xc4\x3a\x45\x16\x67\x1b\xe4\xb2\x5a\x71\xdd\x3e\x81\x72\xbf\x22\xce\x4f\xde\xc9\x37\x39\x9c\x4e\x8f\x35\x60\xb1\x04\x83\x84\xc1\x68\xc4\x71\xb9\xd7\xe3\x89\x8a\x03\x66\x50\x5a\x6c\xb1\x18\x8d\x22\x10\xb7\x1a\x08\xe8\xca\x03\x04\x81\x39\x59\x35\x1d\xc4\x31\x3c\x3b\xe7\x35\x7b\x69\x5d\x3c\xc7\x56\x9f\x05\x3e\x45\x2c\xd5\xd3\x46\x81\x4a\x93\xe7\x71\xa9\x43\x20\xcb\x80\x69\xce\x91\x80\x8a\x35\x1a\x74\xa8\xfc\x14\x47\xdd\xa6\xbe\x33\xfe\xcd\x6f\x51\x4e\x5e\x0d\xc2\xa5\x8a\x81\x74\x77\xbf\x1a\x3c\xa3\x1e\xee\x9e\xbd\xdf\x50\x0a\xc2\xea\x4e\xa7\xe7\xdf\x2f\xc7\x0f\xa9\x79\xdb\xbf\x6e\xbc\x32\x12\x3a\x61\x69\x15\x26\xcb\xfc\xb3\x97\x82\xaf\x23\xa0\x24\x64\x0e\x6f\x00\x44\xab\xe5\xc4\x37\xbe\xf5\x2f\x1b\x3f\x35\x85\x6a\x64\x88\x73\xc6\x20\x27\x3e\x11\x71\xb1\x13\x4f\x10\x8b\x64\xa3\xe2\x9d\x63\x0f\x6f\x85\xf1\x01\xba\x38\x99\x41\xcb\x68\x34\x14\xc5\x90\x10\xe5\xe9\xc4\xfb\xc6\x67\x40\xc5\x19\xf1\xca\x91\x56\xe1\xcf\x80\xe6\x2c\x30\xd1\x27\xa5\xe9\xbd\x59\x40\x92\xcd\x10\x93\xd2\x85\x0a\xe5\x3f\xef\xb2\x31\x09\xf4\x8a\x4f\x14\xcd\xe0\xa6\x1b\x6f\x6b\x51\x08\x67\x14\xf3\x82\xc2\x6f\xd7\x83\x96\xc7\xff\x82\x8f\xc6\xe3\x0c\xfe\xd9\x24\xc3\xc0\x7f\xbf\xf7\x1e\x3e\x26\x3c\x86\x72\x90\xbf\xe0\x09\xf2\x2e\xd9\x02\x98\xe3\x86\xb0\x43\x7c\x3a\xe4\x0c\xba\x5c\xfe\x80\xc3\x8e\x05\x83\x76\x2d\xa1\x57\xa1\x52\xb9\xdd\xee\x87\xe7\x24\xc2\x11\x44\xc4\x6f\x77\xb9\xbc\x66\xab\xd5\xeb\x0c\xe9\xc5\x4a\xf9\xe5\xaa\x97\x54\xef\xa8\x64\x21\x55\x48\x85\x1b\xbc\x50\xea\xd3\x41\xa5\x0c\x83\xe2\x97\x23\xf1\xf3\xb0\x6a\xd1\x34\x24\x91\x3f\x19\x86\xc2\x45\x62\xe1\x62\xf1\x22\x97\x8a\x94\x54\x33\x47\xae\xc3\x9b\xc6\xfd\x85\x3b\xc5\xf4\x20\x85\x3f\x12\x48\x91\x35\xab\x76\x54\x3d\xe4\xab\x2e\xa9\xc1\x1f\x4a\x1d\xd9\x9e\x68\x4c\x25\x27\x97\x52\x13\xc1\x7f\xdd\x3e\xac\x10\x26\xa9\x6e\xf0\xdf\x19\xc2\x9f\x64\x5e\x75\xc9\x5b\x57\x28\x85\x9f\x0e\xfd\x6b\x44\x78\x43\x75\xf4\xe3\x38\xf3\xee\xbb\x68\x35\x80\x01\xec\x13\x2e\x97\xb0\xa4\x1b\x2f\x23\x2a\xe0\x7a\x50\x30\x8b\xf1\x63\x0b\xf8\x80\xda\xeb\x75\x31\xb8\xdd\x1e\x44\xa5\x58\x86\x31\xb3\x6c\x20\xe8\xa2\x69\x44\x0b\x77\x39\x05\xbd\xbd\xd1\x2c\xb7\x40\x6d\x9f\x54\xb0\xac\x51\xda\x34\x69\xf6\x37\x7a\xd4\x57\x34\x51\x3f\x7f\x67\x5a\x00\xc1\x50\x35\x63\x36\x64\x11\x5c\x58\xba\xc6\x41\xd9\x64\x36\xdf\x07\xdf\x7e\xb1\xab\xa3\x3a\x51\xb2\x7c\xc9\xc2\xe1\xb6\xfa\xb5\xef\xbc\x4c\xad\xd9\xb1\x5c\x01\x96\x00\xff\xea\xa5\x23\xe3\xcf\x13\xe7\x4e\xd6\x35\x09\xbf\x17\xb6\x0c\x2d\xea\x9a\x2d\x3c\xdb\x41\xc2\xdd\x7d\x84\x89\x3f\x36\x6f\xa5\x4e\x39\x36\x67\xcf\x8e\xac\x2e\x73\xa0\x2e\xe8\x95\x6b\x18\x5b\xc3\x97\xd9\x59\x56\xe7\x34\x32\x8c\xcb\xa7\xd3\x45\xc3\xae\x50\xc8\xed\x56\xc8\x94\x4a\x92\x8c\x44\x5d\x30\x29\x0e\x33\x79\xad\xf0\x90\x52\x8d\xb4\xb2\x90\x20\x67\x8a\x79\xad\xf2\x10\xf1\xbc\xc3\x96\xa7\x8b\x47\xbb\x57\xb8\xcd\x41\x2a\x51\x70\x07\x51\x10\x0b\x8b\x15\x0b\x3f\x61\xcc\xaa\x0d\x1e\x45\x6a\xd5\xf6\x6a\x7b\x93\x59\xd5\x0e\x68\x33\xe9\xe7\x9f\x5d\xbe\x64\xd9\xb1\xda\x6b\x9e\x42\xfa\xe3\x65\x50\x33\xd0\xd2\x03\xdc\x50\xb9\x9d\x89\x9e\xaa\x05\x7b\x76\xb4\x0e\x2d\x5a\xeb\x12\xce\x82\x6b\xc9\xbb\xd1\x1a\xa0\x33\x16\xc6\x2b\x88\x43\xe2\xbe\xb1\x10\x1d\xd2\x04\x49\x1a\x0d\x06\x33\x07\xc3\x01\x67\x24\x58\xa8\xca\x13\x06\x19\x93\xd5\x24\x9d\x4c\x9e\x4f\xee\xc4\x88\x77\x6a\x35\x04\xf2\x82\x98\x3f\xbb\x19\xf8\xbb\x5f\x9a\xb7\xcd\xba\xf9\xc1\x5f\xbf\xf9\x43\xe1\x6f\xbf\x3d\xb7\x55\xdc\x00\x92\x00\x86\xc9\x65\xb2\x1f\xe3\xba\x6f\xde\xf3\x33\x61\x0a\x87\xcb\x7e\x8a\x8e\x8b\x7e\xba\x19\x9e\xf3\x56\x28\x83\x1d\x9b\xc7\x07\xf2\xf7\x4c\x76\xbb\xc3\x09\x8f\x8e\x53\x5f\x74\x5c\x54\x2a\xdc\x6e\x36\x58\xa1\x3c\x4f\x2a\x31\x59\xee\xb4\x24\xd0\x2a\x8b\x4b\x7c\xde\xb4\x17\xf1\x16\xe9\x7f\x39\x11\x00\x44\x56\x28\xf0\xed\x81\x1a\xa2\xe6\xe0\xbc\xaa\x6f\xf8\xab\xe3\xd5\xc4\x37\x52\xeb\x6f\x4f\x34\xd7\x24\x26\x97\x51\x13\x32\x3b\x13\x3f\xcf\xf2\x91\xbc\x41\x28\xef\x7e\x51\xde\x3e\xde\xc7\xaa\x01\xad\x80\xee\x88\xb1\x59\x01\x4c\x38\x95\x8b\x75\x1b\x74\x97\xeb\x5e\xd2\xbd\xa3\x93\xe9\x74\xc0\xca\xea\xcd\xc8\x1e\x6c\x72\x1c\x14\xd9\x43\x56\xda\xe9\xe3\x98\xd1\xbd\xb8\x17\x85\xff\x06\x68\x02\x50\xe2\x24\x97\x94\x72\x61\x89\x57\x1a\xff\x72\x32\xee\x48\x51\xa5\x77\xde\x56\xf3\x03\x3f\x3c\xb1\xc4\x0f\xaa\x76\x1f\xac\x8b\xa5\x02\xf8\x23\x8a\x89\x1d\xcb\xf1\xc4\xc7\x47\x55\xa0\x66\xe4\x5f\x43\x20\xac\xbc\xe2\xad\x38\x33\x39\x8f\x81\xb2\x8e\xe1\x21\xe2\xa4\x6c\x09\xb4\xe4\x06\xde\x44\x63\x26\x96\xb5\xcb\xd1\x9c\x4d\xaf\x8d\x65\x39\x8e\x34\x38\x9f\x01\xe9\x27\xd4\x0a\x12\xfa\xd0\x6c\x45\x55\x7c\xc6\x3d\x2d\x93\x41\x05\x10\xb1\xb8\x38\xed\x46\x37\x9d\x63\x25\xf3\xfb\x42\x63\x7b\xff\x74\xeb\x8d\xd7\x7b\x93\x60\xd6\xb6\xd1\x3b\x16\xac\x5b\xd0\xd3\x12\x5d\x4e\x81\x55\xd4\xdc\xb2\x47\x1e\x7c\xe0\x05\x62\xed\xd1\xdf\xec\x0a\x7e\x6b\x3c\xb5\xe1\xed\xab\xf6\xec\xb1\xfd\xc6\x18\x8d\x1a\x85\xff\xd4\x3c\x84\xd6\xd2\x00\xd7\xf2\x9f\xe2\x5a\xae\xe2\x4b\x54\x9c\xd9\xac\x56\xeb\x19\xc6\x69\x51\x2a\x14\x56\x2b\x81\xe3\x0e\xa7\x65\xb1\xf8\x20\xf5\x25\xf1\x41\xaa\x52\xc6\xa8\x15\x04\xa1\x85\x3e\xbf\xfc\x69\xab\x59\x8f\xe3\x26\x4c\x5c\x57\x91\x2a\x4f\x2a\x59\xc3\x7f\x72\xab\x5b\xec\x42\x72\x45\x28\xe3\x85\x63\xfa\xa8\xdc\x08\x3f\x83\x62\xf5\x4e\x78\xa0\x2e\x57\x4c\x54\x81\x60\x15\x54\x61\x9f\x62\xcd\x8e\x15\x0a\x01\x7e\x50\x27\x7c\x58\x07\x8d\x25\x51\x4a\x23\x77\x11\x67\x84\x0f\x40\x0c\xfd\x7b\x72\x1e\x5d\x5a\x4a\x83\x16\xe1\x25\xba\x14\xea\xc3\xe1\x09\x3c\x00\xf5\x51\x63\xa5\xbc\x46\x2d\x5e\xe3\x69\xb4\x6a\x08\x3d\x90\x15\x60\x32\x19\x51\xf0\x75\x45\x41\x18\xee\x7c\x11\xe3\x27\x80\xbf\x48\xd8\x97\x17\x05\x5f\x8f\x7e\x83\xf4\x5b\xc5\xf3\x52\x85\x87\xf1\x17\x65\x43\x30\x37\x29\xe1\x35\x46\x75\xf6\xae\x90\xd1\x28\xd1\x5e\xe6\x83\x08\x3a\x15\x17\xb9\x26\x9c\x06\x32\xc1\xd7\x57\x28\xc0\x16\xc5\xe8\x7c\xf3\x89\x2b\x87\x9a\xbc\x09\xdc\x58\x19\x4b\xab\x65\x0e\x51\x41\xdb\x15\xd7\x1b\xce\xac\x75\xd6\xd5\x89\x7c\xa0\x70\x9f\x1e\x82\x7a\x59\xb1\xb5\xbc\x85\x33\x99\x0c\x10\x78\x60\x5a\x18\xe3\x34\x56\xb5\x24\x01\xc4\x54\x50\x37\x9e\xb1\x6a\x2c\x46\x4d\x6e\x70\xad\x9c\x46\x8a\x9f\x36\x15\x6b\x9e\xc8\xc5\xe7\x1c\x3d\x7c\xfa\x42\x6f\x9f\xaf\x7a\x5c\x64\x58\x2d\x8c\xda\x7e\x82\x02\xdd\x6b\x28\xe1\x52\x6a\x02\x2d\xd2\x4e\xc5\xf2\x14\x18\x6e\x53\x60\x53\x8a\x79\xc2\x6f\x7e\x34\x87\xfa\xc3\xe3\xb5\xf8\x7a\xa4\x44\x76\xaf\x5e\x03\xf5\xe2\xbf\xa7\x84\x01\x26\x0e\xf6\x64\xf1\x61\x0c\xee\xd5\x9f\xa0\x4e\x0c\x56\xce\x6b\xe1\xd2\xaa\x55\x2a\xb9\xde\xc0\xa8\xd5\x5a\xb4\x59\x2a\x19\xe2\xde\xc9\x1d\x59\xfd\x34\xca\xcc\x6c\x2e\x57\xb4\x65\x3d\x6d\x9d\xd7\x6b\x3a\x12\xd5\x93\x5b\x25\x91\x6e\x50\xec\xc4\x37\x2b\x89\xaf\x7f\x91\x93\x01\xbd\x91\x86\x98\xe1\x14\xfc\x7d\x16\x6c\x29\xef\xd6\xe0\x04\xa1\xe4\x2c\x16\x3d\xc0\xb4\x5a\x85\x4e\x67\xd0\x2b\xf4\x56\x1b\x74\x7d\x6a\x0b\x8e\xeb\x50\x10\x79\x9a\x33\x10\x0a\x05\x2b\x7f\x0e\x0a\xa1\xc5\x80\x28\x4a\xd6\xc0\xd3\xf9\x12\x43\x71\xa1\x4f\xfc\x24\xc7\x19\x79\x91\x11\x7a\xe2\x8f\x38\x61\xbf\x6a\xd3\x6a\x4a\xf8\x95\x24\x67\x78\x0c\x26\x7b\x2d\x8a\x89\x9d\xd0\xe4\xb6\x51\x5b\x37\xc1\x25\x39\x33\x79\x75\x6e\xe9\x26\xbf\xc0\xb5\xa2\x27\x41\x3f\xef\x42\x6b\x56\x0a\xed\xe0\x47\x50\x07\x23\xc4\xd4\x9c\x41\x81\xd8\xf3\x8d\x14\xda\x7f\x1d\x34\x41\x19\x46\xd3\x0a\x5c\x8f\x56\x4f\xa9\xd3\x69\x90\xe0\x46\x8c\xca\x0a\x2e\x86\xf7\xe2\x2a\x49\xfe\x7f\x79\xdb\xf4\x83\x02\xf1\x2d\xfc\x76\xb5\x02\xb8\x14\x13\x57\xb6\x0b\xcf\xaf\xcb\x09\x4c\x01\x12\xc8\x90\x5b\x86\x52\x71\xf8\x1d\x93\xf7\xe4\x25\xfd\xbd\xb4\xa7\x6e\xb8\xc6\x40\xf4\x27\x4b\x78\xb7\xd2\x22\x79\x91\x9c\x5f\xc1\x19\x18\x52\x54\xaa\x22\x1f\xc2\xab\x94\x16\xcb\x85\x7e\x24\xa1\xcf\xbb\x92\x69\x3b\x5f\x28\x0b\x4f\x73\x24\x59\x82\xd7\xac\xf0\x88\x2c\xcf\xad\x5c\xb5\x63\x4c\x01\xf6\x50\x6b\x16\x80\xed\x32\xb8\xce\x7b\xa9\x35\x3b\x57\x50\xc2\x5e\xf9\x9a\x61\xe1\x80\x62\x39\x55\xe4\x48\x18\xf0\x9e\xbb\xe0\x49\x70\x20\x94\x57\xd0\x68\x84\x1f\xb6\x1c\xfa\xee\xeb\xa1\xef\x46\x77\x84\x61\x5e\x8d\x59\x2c\x4e\x4a\xaf\x77\x38\x09\xf6\x39\xe8\xad\x55\x98\x0e\xa4\xa5\x95\xcd\x8f\x69\xcb\x52\xb0\x64\x3d\x74\x33\x28\x7a\x77\x01\xd3\x48\xfc\x27\x0b\xfb\x3b\x77\xf5\x65\xe6\x74\x5d\xd6\x2f\x7c\x74\xcb\x0b\x5b\x3f\x38\x74\xcb\x0b\x3b\x7e\x40\xc6\x37\x5f\xb9\xed\xb7\x9b\x36\xed\xdd\xf2\xb1\xb0\xee\xe9\x9b\x0e\xff\x6e\xcf\xd3\x37\xdd\xf0\xe7\x4b\xa5\xda\xf4\x2c\x3c\x4c\x8c\xc8\x36\x61\x5e\x98\x31\x2e\xe6\xc3\x32\xab\xc2\xca\x7a\x71\xc6\x18\x34\x46\xb5\xda\x92\x78\x50\xa1\x70\xe3\x78\x5c\xc6\x30\xe1\xf0\x62\xc7\x06\xc7\xdd\x0e\xc2\xe1\xf0\x41\xeb\x4d\x9f\x86\x88\xcf\x0b\xd7\x34\x8e\xd6\xb4\x1c\x4a\x99\x05\x76\xc9\xe2\x21\x11\x92\xe1\xd6\xe5\x6e\x6d\xc8\xc2\xa5\x8d\x27\x77\x67\x13\xcc\xcd\x1b\x9a\x7e\x67\xd3\x05\x0c\x3b\x27\x46\xc6\xdf\x7f\x4b\x78\xfc\xf0\x9e\x59\x43\x60\x40\x35\xbf\x73\x66\xeb\xa2\xe5\x6b\x8f\x6f\xde\xfe\xc8\xef\x64\x9b\xe8\xbb\xe7\x5f\x66\x52\x65\xba\xae\xb8\xf6\x7b\x4b\x2f\xd7\xea\x06\x9a\x9f\x32\x36\xe9\x7a\xd3\x8d\xcd\x2b\x97\x8f\xb1\x93\x65\xab\xc7\xaf\xf8\xde\x41\xa4\x5f\x02\xda\x73\x54\xc4\x3f\x16\x6c\x84\x2f\x23\x58\xd6\x46\x29\xe4\x72\x64\xd7\x3a\xab\x4d\x51\x4e\xa5\xa9\x3e\x8a\x40\x7f\x1c\xa6\xee\xa6\x1e\xa5\x3e\xa2\x3e\xa5\xa6\x28\x18\xf0\x35\xb4\x3c\x6f\xe8\xe7\xe1\xd7\x4d\x17\xc4\x9e\xc2\xd5\x07\x55\xb0\x70\xa9\xc5\x1c\x9c\x5e\xb8\xfa\xba\x68\x5a\x53\x76\x15\x25\x4c\x50\x4b\xa1\x91\x80\xf4\xed\xc7\x9f\xbe\x8f\x78\x6c\xdd\xd2\x5b\x84\xe3\xad\x53\x58\xce\xc4\xd7\xaf\xbe\xea\x06\x71\x4f\x3a\xa1\xcc\x7d\x50\x66\x74\x67\xba\x80\x77\xb9\x30\xa7\x93\x65\x18\xa0\x05\x94\xdc\x84\xee\x42\xe4\x5a\xb7\x07\xba\x33\x97\x8b\x74\x52\x4a\xe4\x48\xf4\x00\xc8\xe5\x26\x32\x9f\x1b\xe5\x24\x4d\x9e\x5f\x00\x2f\x6a\x39\x3b\x4f\x4e\x4a\xf4\xba\xe1\x1c\xee\x06\x47\x13\xd0\x61\x5c\x4b\x8d\x21\x68\xdd\x72\xcf\x91\xe5\x4b\x77\x0e\x51\x9f\xed\xb6\x2e\x5f\xdf\xd5\x11\xab\x27\xf6\x0b\xbf\xcf\x49\xbd\x6a\xf9\xc2\xcb\xad\xc2\x07\xd0\xed\x0e\xb6\x2e\x1d\xea\x6d\x17\x4e\x8b\xe7\xf4\x3a\xa8\x43\x97\xe8\x47\x9a\x78\x13\xa3\xd7\x13\xb8\x02\x37\xa9\x58\xad\x46\xa3\x50\x28\x19\x92\x44\x72\x3f\x09\x8f\x65\xf6\x54\x66\xe3\xa5\xf4\x05\x92\x85\x39\xaf\xc6\xdc\x85\x41\x1e\xe4\x71\xd4\xad\xd4\x95\x3b\x82\xe9\xce\xd2\xaa\x30\x7e\x4b\xb8\x5a\xd1\x34\x2b\xb0\x63\x37\x3c\x70\x50\x9e\x07\x35\x47\x3f\xfe\xf8\xa8\x7a\x72\x88\x89\x43\x19\x4e\x41\xdb\x46\xd8\xc3\x01\x65\xd0\x93\x14\xe5\xb0\x5a\x9d\x2e\x8d\x56\x0b\x11\xb0\x4b\x09\x61\x5b\xfa\x69\x83\x96\x74\x38\x68\x90\xc5\x99\x92\xe7\x3d\xcf\x7e\x91\x0c\x17\xb9\x2c\xc8\x0f\x69\x3d\xa5\x00\x97\x28\x26\xda\xb4\x27\x96\xec\x32\xcc\x5b\x4d\x01\x83\x62\xb4\xdf\xf9\xd0\x4d\x37\x9d\x50\x74\xca\x4a\xe2\x71\x5a\xd8\x36\x27\x74\x62\xd5\x0a\xf0\x23\x1a\xfd\x50\x79\xec\xba\x2b\x77\x70\xcd\xe0\x7e\xb4\x46\xf7\xe0\x1e\xf2\xa7\x30\xce\x9b\xb0\x45\x7c\x80\x24\xd4\x5a\x0d\x0e\x30\x9d\x0e\x57\x13\x32\xda\x64\x32\xab\x64\x32\xd6\x8c\xc3\xbc\x97\x32\xd1\x34\x84\xc6\x7a\x0a\x85\x5a\x9d\x5a\x0d\xe0\x4e\xa7\x73\xf5\xd3\xbc\xb0\xe5\x45\x7e\xa2\xb8\x8c\x2a\xc5\x0a\xbf\x34\x87\xc6\x8e\x8a\xa7\x92\x06\xc1\xba\xd1\xbf\x35\x6e\xea\x55\x80\xb9\x8a\xa5\xfc\x5f\x1b\x47\x7e\xba\x4c\x01\x08\x45\x17\xee\x01\x93\x02\x81\x9f\x13\x5d\x97\x05\x7c\x2e\x68\xc0\x9f\xc5\xf8\x86\x63\x1d\x78\x10\xdf\x47\x6e\x81\xd9\xba\x13\x6b\xe7\x75\x16\xd2\x6a\xc5\x0c\x06\xb7\x51\xa5\x72\xb9\xf5\xcf\x81\x46\xe8\xc6\x74\xa0\xf1\x29\x0b\x49\x9a\xcd\xd4\x73\x50\x44\x98\x38\xe6\x83\x03\x92\x35\x3d\x6d\xe0\xa4\x14\xfe\xfd\xe1\x7c\x8b\x28\x44\xa0\xa9\x24\x90\x66\xf8\x8a\x17\xda\xa1\x16\xd9\xbb\xb8\x37\x53\xd9\x91\xc9\x1c\x5b\x32\xd8\x52\xe9\x15\xc6\xca\xec\xe5\x0d\x0d\xb6\x8a\xf6\xc5\xf8\xb8\xc9\x37\x37\x5a\xb3\x72\xe5\xf8\xe9\x55\x76\xb3\x70\xb4\x83\x9f\x07\xe6\x9a\x9e\x43\xe7\x67\x31\x5e\x8a\x1f\x23\x2f\x3b\x4f\x4e\x17\x12\xd4\x6d\x40\x41\x0b\xc9\xd9\x9c\x97\xb3\x11\x1d\x3a\xf8\x67\xb1\x9c\xc5\x79\x86\x54\x12\x4b\x72\x79\x3f\x2b\x32\xf4\x89\x8e\x98\x22\x90\xe3\x7a\x36\x2f\xe6\xd0\x9d\xa3\x48\x4c\x70\x67\x5e\x4c\xb2\xae\x58\x4c\xb0\x06\x8a\x29\x9c\x42\x62\x4e\x4d\xe5\xd6\xd3\x20\x97\x8d\x89\x39\xf6\x22\x3c\x4e\x3c\x08\xe5\x56\x60\x51\xac\x0e\x5b\xcd\xdb\x90\xd4\x25\x25\x65\x4a\x42\x57\x15\x08\x34\x58\x09\x9d\xae\xbe\x21\xe6\x72\xa5\x52\xde\x67\x40\x23\xaf\xb4\xb0\xac\x03\xd3\xeb\xd5\x0e\xf1\xa7\x32\x08\x2d\x2a\xe5\xf2\x88\xba\xc8\x0d\x40\x65\xb2\x6e\x20\x77\xbe\x0a\x65\xa1\x9c\x8d\x14\x77\xeb\xca\x73\xdc\xca\x85\x5e\xdd\x44\xb1\xde\xf9\x56\xdd\xec\xb5\x36\x38\xde\xb3\xd2\xa9\x8f\xf6\x99\x9b\x86\x86\x46\x4e\x7f\x8d\x68\xaa\x29\x6d\xf3\xda\xaa\x77\xd5\xdd\x11\xab\x5a\x9a\xec\x59\xb4\xe8\xe4\x68\x6f\x07\x5e\x5a\x69\x6d\xb5\x75\x4c\x94\x7b\xed\xb3\x88\x66\xd5\x70\x83\xd5\x7a\xe9\x4d\xb1\xf6\x9a\x79\x5b\x34\xd1\x8e\x4e\x1f\x17\x2a\xad\x58\xd3\x5c\xb6\x71\x21\x5c\x21\x70\x5f\xa4\xf5\x48\xb3\xc1\xfe\xe2\xb6\xce\xe6\x1a\xd1\x17\xee\xc2\x61\xfe\x23\xbb\x06\xe2\x6d\x17\x36\x83\x67\x61\xd6\xe8\x61\x65\x06\x03\x04\x9e\x3a\x9d\xdb\x23\x63\x59\x82\xb0\xbc\x08\x37\x8f\xc6\xf4\x30\x14\x29\x31\x4d\x36\x66\x9e\xa7\x6e\xc1\x4f\x4b\xdb\x26\xea\x40\xf9\xc2\x68\x63\x75\x80\x2a\x84\x50\xba\xcc\x1e\x6f\xac\xd7\x56\x30\x2d\x8b\x6e\x3d\xbc\xfe\xda\x14\xf5\xa1\xd3\xa3\xf2\x0c\x55\xce\x9c\xdf\x7f\x03\x71\x73\x67\x7a\x9e\xf0\xb4\x96\x79\xe1\xdf\x31\x82\xd0\x85\xef\x7f\xd4\x17\xaf\x5b\x33\x3a\x7e\x66\xb5\x14\x4b\x79\x3c\x84\x7f\x5d\xb6\x1f\xfa\x6d\x1f\xd6\xc3\x1b\x95\x4e\x07\x61\x34\xaa\xd5\x50\xd2\x80\x99\x20\xfc\x01\xda\xf0\x22\xdc\x1a\x35\xa6\x85\x92\x7a\x20\x6e\x6a\x7c\xca\x61\x34\x42\xdb\x14\x4f\x73\x22\x6b\x7a\xd3\xe2\xbd\xb4\x4d\x45\xac\x0d\x9c\x54\xb0\x93\x8e\x4d\xb8\x68\x52\x8d\xfc\xc7\x6d\xf3\x7a\x0f\x0d\xb6\x07\x14\x8e\x25\x14\x90\xdd\xd0\x40\x7d\x97\xf4\x0e\x47\x43\x16\x2e\x6d\xab\x57\x55\x98\xd3\x19\x3c\xb4\x7a\xd1\xc4\x99\x71\xfd\xac\x93\x74\xf8\xdc\x2f\xe8\xc0\x82\xd2\x9a\x8f\x3b\xf9\xf2\x00\x98\xa5\x32\x3e\x23\xca\xbf\x10\xda\x63\x07\x3c\xdf\x28\xee\xd4\xf1\x06\x33\x49\xd2\xb4\xdb\x63\x55\x62\x98\x87\x30\x9b\x35\x0e\x23\xb4\xb3\x27\x61\xf0\xd4\x48\xee\x27\x5f\x80\x03\xf9\xd8\x22\x3d\x02\x91\xd3\xe2\x00\x21\xae\xe8\x60\x9b\x65\xf9\xe6\xee\x8e\xa7\x0e\x13\xeb\x66\xce\xb5\x95\xed\x69\xda\xb4\x7a\xf0\xc6\x39\x43\x8b\x84\xd7\x3a\x96\x5a\xf4\x91\x4e\xe2\xcb\x81\x2d\xea\xe8\x0d\x75\xa1\x68\xd5\xc6\x65\xcb\x1f\x1f\x6f\x7f\x8b\xca\xa4\xad\xd6\xed\x48\xb6\x7e\x28\x5b\xc3\x79\xb2\x89\xa2\xb9\x3d\x70\x6d\x45\xd9\xd2\x59\xd9\x1a\x8b\x65\x3b\xaf\x83\x53\xb4\xed\xfc\x40\xba\xec\x73\xce\x60\xce\xfe\xfb\xb3\xa2\x95\x5f\xd6\xbc\x76\xbd\x28\x1a\xa8\x9f\xb5\x08\x89\x86\x9f\xc8\x8a\x16\x4b\xae\x59\x25\x8a\xa6\xcc\x34\x89\xa2\x41\x3f\x3e\x0b\xca\x56\x02\x65\x8b\xc0\x5d\xf7\xf8\x68\x5c\x15\x0a\x99\xdc\xee\x68\xcc\x86\xe3\x31\x2b\xc7\x39\x7c\x7a\xbd\x54\x35\x80\x07\xd8\x81\x72\x38\x8a\xc4\x44\x31\x13\x89\x74\x1e\x35\x5d\x50\xdb\x40\x98\xa2\xc0\x6d\x6e\xe6\xc4\xda\x86\x3c\x37\x9a\xb1\x88\x04\xbd\xaa\x06\x5c\x33\xd6\x6a\x8d\xea\x1c\x95\x25\x35\x5e\xba\xa3\x54\x53\x32\x77\x51\x59\x74\xb0\xc7\x31\xbe\x6f\xd5\x8a\xb9\xb3\x41\x30\x01\xbd\x8c\x79\x5f\x3b\x57\x53\xe9\x2f\x93\xa9\xba\x28\xfb\x92\x78\x59\x7d\x74\x64\xb0\xa3\x69\x90\x26\x75\xe9\x58\x87\xc4\xe5\x1e\x81\xf6\x5b\x4d\x5e\x02\xf5\xe8\xe2\x1d\xca\x50\x48\xe7\xb7\xb3\x5e\x6f\xcc\x4e\x10\xd1\x98\x5f\xa7\xa3\x23\x6a\xa6\x93\xa6\xed\x9c\x0b\xd9\x01\x29\x97\xe7\x0d\x17\x7a\x9b\xba\xf2\x92\x7c\x59\xaf\xd0\xc8\x3c\x6d\x18\x6f\x58\x2e\xce\x72\xe1\xa4\x3b\x9c\xc2\x38\x1e\x34\xca\xc5\x24\xff\xb4\x75\xdc\xa9\xe8\xea\xeb\xe9\xab\x1e\xf0\x3a\xb5\x4e\xeb\x40\xb0\x62\x21\x1f\xf6\x95\x58\x3b\xd6\x6f\xdf\x71\x2d\x58\x79\x07\x1e\x72\xdb\x2a\xdc\x1d\x4d\xb5\xac\xb2\x97\x52\x37\x47\x67\x3a\x66\xdf\x60\x4e\xd7\xad\x89\x93\xdc\xf0\xa2\xb5\xc8\x46\xbc\xa0\x04\xdf\x0d\xf7\x41\x8d\x85\xb1\x99\xbc\x59\xee\xf3\x78\x28\xca\xa0\xd7\x47\x2d\x98\x46\x13\x89\xca\x7d\x3e\x82\x08\xa2\xf5\x77\x5a\x21\xc2\x6e\x82\xde\x82\xce\xba\xfd\x0b\xbd\x63\x3e\x09\xc8\x9e\x31\xd1\x1f\xa2\x0b\x1b\x6e\x1a\xd3\x39\x7a\xec\x25\xfe\xfc\xfb\xb8\xd5\x54\x6f\xe7\x7d\xf1\x19\x8b\xee\x3a\xbd\x7f\xe2\xf0\x2a\xee\xe6\xab\x6b\xb6\xdb\xb4\x5e\x73\xa2\xbf\xae\x95\xd6\x6b\x7c\x23\x65\xed\xf3\x09\x79\x27\x1f\x0b\x80\x45\xf4\x53\xb7\x3d\xf4\x91\x75\xf2\xe5\xcb\xb6\xda\xf4\xb7\xf5\x25\x5a\xe6\x8f\x86\xa0\x27\x41\x3a\x54\x02\x3d\x58\x4a\xae\x14\x7b\x95\xcb\x79\x1a\xf5\x2a\xc3\xf4\x8b\x24\x08\x56\xaf\x26\x29\x14\xbc\x50\xb0\x6a\x10\xa5\x7e\xb5\xe8\x9a\x2c\x7b\x71\x93\x44\xae\x81\x2b\xea\x4f\x7e\x7a\x26\xf5\xe7\x61\xe8\xc5\xae\xaf\x09\x87\xaa\xab\x43\xe1\x1a\xb2\x42\x17\x11\x70\x3a\x7c\x36\x5c\x5d\x1d\x0e\xa3\xd9\x99\x58\x3b\x4c\x0a\x6f\x82\x7e\xcb\x88\x8d\xf2\x16\x4c\x6b\x34\x6a\x28\x4a\x27\xd7\x31\x34\x6d\x62\xd5\x0a\x05\xc4\x96\x2c\x63\x80\x48\x9f\x57\x69\x31\x0d\x85\x51\x84\x5a\x41\xa3\x12\x1d\x9a\x13\xf2\x8c\x28\x4b\x16\x70\xd6\x65\x03\xcd\x05\x19\x40\x0e\x74\xc2\x3c\x2a\x49\xe3\x22\xd4\x44\x57\x78\xf0\x27\xe0\xfc\x61\x15\xf5\x36\x95\xba\xf9\x9a\x0a\xea\xf9\xe5\x2d\xd1\x7b\xae\x87\xc2\x12\xcb\xde\xd1\x85\xc3\xba\x6b\x84\x17\x74\x11\xc0\xc4\x7e\x47\xb8\x75\x68\x4e\x43\x1a\x62\xca\x07\xc9\xad\xd0\x3e\x27\x78\xbb\x5d\x26\x97\xab\x28\xca\xa3\x0f\x61\x98\xdf\xe3\x89\x99\x69\x86\x41\x7b\x1d\xf3\x87\x50\x99\x42\x2d\x83\x96\x6a\x46\xf0\xc9\x29\xc6\x07\x03\x66\x82\x92\x52\x30\x4a\x34\x67\xe3\x43\x3e\x3f\x4d\x17\x95\x51\xf4\xd3\xb1\x5f\xe1\x3a\xc8\x9f\x9f\xcd\x20\x8a\x2d\x5e\x0c\x71\xb9\x8e\x07\xa8\x8f\xb1\x86\x20\x4b\x02\x83\x8a\xc6\x13\x4d\xda\xb8\xb3\xdb\x94\x3e\x91\xa9\xa6\xce\xe2\x83\x5b\xca\x5b\xc1\xc0\xf6\xaa\xb4\xac\xb9\x43\xf1\x87\x66\x2d\xf1\xdb\xfa\x35\x15\xc2\x29\x30\xd8\x66\xab\x9f\x57\x23\x1c\x07\x93\x74\x64\xc5\x96\x14\xbf\x7d\x46\xa3\x2a\x2c\x9c\x84\xea\x0e\xb6\x49\x35\x20\x10\xc7\xf7\x43\x5d\x7d\xd8\x6c\xde\xe4\xf2\x7a\x0d\x34\x1d\x50\x11\x24\xc9\xc9\x65\x32\x7f\xc0\x61\x61\x9f\x01\x4d\xa7\x09\x95\x0a\xd3\xbc\x00\xb5\x93\x63\x0a\xa8\x9d\x0c\xe9\x86\x54\xcb\xa6\xb7\x85\x16\x9c\x7c\xa3\x06\x98\xae\x81\xc4\xfe\x93\x2f\x18\x89\x0f\x2e\xc1\xa9\xe0\x52\x96\xbf\x7b\xa8\x5a\xf1\xba\x6c\xf4\x9a\xda\x2e\x9a\x67\xaf\x5c\x5d\x53\xc6\x85\x74\x1a\x3a\x6d\x6f\xd7\x92\xee\xc1\x2a\x49\xf0\xd5\x3b\x9a\x5b\x9c\xdd\xc2\x75\xdb\x76\xa8\xf7\xb7\x69\x6e\x07\x7b\xa1\x52\x52\x4e\x19\xc4\xb7\xc0\x73\xa8\xc1\xac\x62\x5e\xcb\x71\x76\x39\xc3\xd8\xec\xb8\x09\x81\x2d\x25\x8c\x7f\x17\xcb\x6b\x8b\xd2\x5a\xa2\x28\xad\x95\x83\xf7\xba\x43\x5d\x65\xa5\xfe\x50\x67\xec\x81\xf1\x9d\x03\xb7\x2c\x1e\xdf\xf9\x2c\xf1\x8d\x9b\x86\x8f\xcf\x6b\xef\xce\xdc\x22\x7c\xb0\x6f\xcd\x92\x07\x16\xed\x5b\x73\xcb\x5b\xe2\xba\xb5\xc3\xdf\xdd\x0a\x7f\xb7\x15\xd5\xe7\x2c\x2a\x95\xcd\x6e\x20\x08\x3b\xad\xa6\x50\x7c\xe0\x58\x36\xeb\x78\xf5\xd3\x8b\xdd\xc8\xd7\xe6\xa2\x41\xee\x64\x67\x27\x97\xd6\x80\x89\x15\x97\x0c\x1d\xcf\x04\x26\x7c\xce\x12\xa5\x27\x35\x6b\xa2\x21\xde\xd9\x6f\x9f\x20\xb7\xac\x5f\xbe\xf1\xe1\xa5\xb4\xe6\x91\x55\x81\xa7\xae\x9e\xdd\x5a\x17\x5a\x24\xf6\x9e\x10\xb3\xf1\x0d\xd0\x87\x32\x98\x9f\xd7\xe2\x3a\x1d\x2a\xa1\xa0\x26\x41\x59\x36\x30\xe5\x3a\xa3\xce\x6b\x0f\xf4\x4b\x64\x3b\x14\x78\x5a\xef\xf0\x95\xa7\xcc\x8f\x5a\x6f\x3d\xf8\x63\x25\x31\x7b\x49\x65\x69\xe9\xaa\xab\x6e\xbc\xf5\x8d\x98\xc4\xc1\x8b\x2d\x80\x3e\x7a\x9c\x98\x2d\xfd\xfd\x30\x43\xd0\x1b\x60\x26\x68\x60\x28\x2d\x21\x05\xe5\xb7\x12\xd3\xb4\xca\xbe\xb4\xcc\x91\xf1\xa6\xf0\x71\xeb\xb1\x6b\x3f\x50\x3e\x6a\xb0\x7b\x6a\x6a\x4c\xc4\xec\x23\x47\xde\x8c\x26\x56\xc5\xe3\x25\xdb\xb6\x48\xef\x00\x3f\x05\x31\x68\x77\x97\x60\x66\xcc\x8b\xf5\xf1\xac\x1c\x62\x18\x83\x41\xa1\xd0\x69\xb5\x3e\x0e\xf3\x3b\x0c\x06\x9b\xcd\x84\xce\x93\x0e\x63\xa0\xc5\x29\x30\x35\x34\x43\xa7\xdb\x2d\x2f\x4e\x49\xf2\xe8\x2b\xdb\x5b\x9c\x43\x31\x40\xc2\xce\x74\xbe\x70\x25\x19\x21\x55\x40\xd2\xf8\xfe\x39\xd7\x2d\xa8\x8e\x90\x10\xc3\x08\x2f\x51\xcd\xfb\x1a\xa9\x77\x88\x59\xf3\x67\x0e\xdc\x19\xb5\x45\x1b\x1b\xdc\xe1\xd6\x11\xe2\xa1\x89\x33\x2b\x4c\xe1\xc7\xe9\x70\x98\xc6\xdf\xa3\x03\xf3\x96\xad\xdb\xd6\xc9\xcf\x11\x4e\x3b\x9f\x16\xd7\x67\x31\x1e\x04\x8f\x90\xbf\x81\xfb\x5f\xc7\x1b\x0d\xac\x5e\x6f\xb1\xd0\x1a\x42\xa9\xb4\xd9\x35\x2c\xcb\xd0\xd0\x8d\x35\x3c\x81\xa3\xc1\x07\x69\xa9\x84\xfa\x56\xc1\xed\x17\xc5\xdd\xc2\x98\x11\xa3\x3f\x8d\x27\xd1\x35\x0d\xca\xff\x40\x3d\x57\xc2\x78\x17\x44\x5b\x3a\x65\x4d\xed\xf2\xc1\x81\x05\xe6\x51\xd5\xe2\x94\x12\xdf\xc8\xc4\xcc\xf6\xe6\x26\x26\x06\x66\x87\x2d\x97\x5f\x9e\x16\xde\xa9\xe4\x9a\xa4\xfd\xea\x86\xf8\xf5\x5e\xe8\xcf\xad\xd8\x2c\xde\x20\xde\x4e\xeb\xa1\x28\xe2\x5d\x35\x65\x37\xc1\x24\xb4\xe1\x29\xb1\x57\x4c\xf7\x02\x94\x08\x2d\x67\x33\x26\x47\x2e\xb5\x90\x8c\xe4\xbc\x69\x71\x42\x2a\x65\xa2\xa2\xb3\x2f\x6a\xa5\x4f\x12\xf2\xcf\x52\xe1\xc5\x2c\x7f\x22\xd3\xa2\xf8\x91\x78\x78\x15\x0d\xd0\xed\x34\xe9\xf0\xd3\xf5\xf3\x13\x60\xb9\x40\xd0\x91\x89\x1d\x4d\x2d\x9a\x14\xe8\xa6\xc3\xc2\x37\xbb\x24\x19\x07\x71\x1b\x7e\x2b\xb9\x09\xca\x98\xe6\xed\x26\x8a\xe3\x6c\x76\x51\x26\x35\x8c\x3e\xf6\xa2\xfe\x7f\xc9\x82\x91\x28\xaf\x8a\x37\xad\xa0\xa8\x82\x96\xed\x26\x92\xba\x9f\xaa\x65\x29\x8e\x0d\xe7\xc8\x50\xa9\x70\xb5\xcc\x8c\x53\x50\x02\xc9\x6d\x88\x12\x54\x0b\x4f\xd2\x61\x30\xd8\x85\xbf\x94\x0a\x2d\x29\x96\x98\x6a\x14\x25\x46\x72\x55\xe0\x21\xe2\x03\xb8\x76\x7e\x6c\x3d\xef\x74\x01\xb7\xdb\x63\xb3\x58\x38\x19\xba\xd8\x50\x7a\x3d\x9e\xa0\x8e\x61\xd4\x4a\x65\x20\xe8\xe6\x9e\x83\x4b\x86\x70\x75\x03\xaf\x76\x99\x4c\x40\x26\x83\x86\x4a\x88\x29\xa8\x17\xfe\x45\xa8\xc0\x30\xcd\xdf\xa7\x2f\xbc\x1e\x9f\xd6\xcf\x05\xd0\xa2\x86\x25\xe2\x26\xb4\xac\x14\x82\xb3\x61\xb4\xe0\xe2\x77\xe2\xc2\xe3\xef\x80\xbd\xb3\x96\xb3\x87\xe6\xee\x95\xa5\x6b\xa8\xdf\xb6\x91\x7c\xac\x01\xc8\x3a\x1f\x69\x23\xd3\x91\xd4\xbc\x47\x86\xab\x29\x3c\x51\xc5\x77\x75\x6d\xad\x04\xcb\xe1\x5a\xef\xf6\xcf\xb4\xea\xe2\xe0\x18\xfa\x86\x03\x1f\xa0\x08\x9c\xc7\x8e\x13\x50\x47\x03\x96\xe4\xf5\x3a\x00\x30\x0c\xc6\x31\xa3\x89\x54\xab\x4d\x8c\xc2\x80\xf4\x02\x10\xa5\xa4\xb3\xa5\xe1\x62\x88\x28\x9e\x6f\xa3\x48\x7a\x30\xad\x77\x8b\x1c\xde\x19\xf1\xb2\xd4\x21\xba\x52\xf8\xb2\x6b\x57\x40\x4e\xae\x14\xb6\xbf\x50\x9f\x70\x9a\x65\x61\x9a\x4b\xf5\x08\x13\xb8\x1a\x46\x53\xf4\xbb\xbb\xa0\x2f\xb9\x4b\xc4\x7b\x1d\xbc\x69\x7a\x8f\x0b\xfc\x89\x50\x58\xc4\xbc\xd2\x47\xd3\x8a\xa0\x5a\x8d\x8a\xe5\xe9\xe2\xbc\xb2\x78\x3a\x74\x6e\xfb\x51\x9b\x0b\x7a\x9b\xf2\x7f\x74\xb9\xe0\x91\x86\x16\x87\xb5\x2d\x99\x8c\x25\x22\x6c\x40\x61\xb0\x05\x6a\x6a\x53\xd1\xdd\xe3\xbd\x43\xe1\xf4\x90\x35\x11\xb1\x9b\xfc\x01\x73\x02\x02\xbe\x80\xa7\xce\xa9\xd5\xed\xee\xd2\xb8\x1a\xbb\x57\x96\x2e\xdb\xdd\xd3\x5a\x39\x34\x77\x6e\x22\xaa\xe9\xda\xad\x93\x72\x2e\x00\xca\xf0\xbb\x65\x37\x41\xec\x12\xc4\x5a\x79\xb3\xc6\xe7\x03\x0a\xb7\x4e\x67\x82\xb0\x25\x14\x56\xfb\x7c\x7e\xbf\xcc\xa1\x47\x67\xcb\x0c\xc3\x63\x29\xfc\xcf\x9b\xb2\x14\x96\x30\x39\x90\xf0\x6a\x51\xc4\x47\xb3\x28\x8c\xc5\x13\x06\xc5\xc6\xbd\x2c\x02\xc8\xc6\x84\x70\xaa\x19\x9c\x7a\xe4\xa8\xf5\x96\x03\xcb\x36\xac\x1e\x04\x47\x1e\x3b\x56\xe9\x00\xa6\xea\x8a\x04\xb3\xcc\x12\x9d\x39\x98\x6a\x56\x75\xf5\x82\x32\xa2\xf7\xfa\x6b\x87\x7a\x87\xae\x31\xca\xdd\x07\xaf\xbb\x4d\x85\xbf\x33\x38\x3c\x3a\xf9\xae\xfa\xe0\xaa\xba\x2e\xbc\x5e\xbe\x13\xcb\xc6\xf8\x52\x7c\x0d\xb9\x0a\xb3\xa1\xbb\x3b\x3d\xc9\x71\xb8\xcd\x66\x77\xc0\x43\xe7\xe0\xf4\x7a\x92\x04\x26\x18\xe3\x9f\xb0\xa9\x81\x84\xb1\x50\x2a\x7f\x41\x9e\x20\x56\xa7\x92\x66\x2e\x99\xaa\xc9\x0d\xd9\xa5\x08\x88\xa8\xc3\x35\xa9\x10\x1e\xae\xa2\xbe\x5b\xc6\xc8\x2e\x69\x0a\x51\x87\xe5\x83\xef\xb9\xbe\x66\xe1\x4a\xcc\x75\x26\x68\xa0\x9f\x7c\xfb\x95\x15\xc9\x00\x15\x56\xe8\x9a\xaf\x14\xbe\x3d\xf4\x1d\x85\xe1\xba\x0d\xb7\x02\x0f\x2f\xad\x29\xca\xb5\xee\x86\x78\xd0\x09\x71\x74\x9a\xe7\xcc\x41\x3f\x65\xb1\x68\xe1\xc1\x8a\x44\xfd\x4e\xad\x36\x1a\x34\xeb\x49\x60\x7f\x4e\xcc\x62\xf5\x39\xdb\x44\xe8\xaf\x90\x08\xe6\x9f\x94\x80\x5c\x02\x23\x11\x21\xe4\x06\x57\x49\xe8\x94\x03\xd9\x5e\x7d\x98\x78\xef\x0f\x2b\x9c\x15\xb1\xaa\x8e\x92\xb2\xaa\x81\x5b\x47\xd7\xed\xfc\x7b\xfa\xba\x0d\x6d\xc3\xc2\xfc\xee\xd4\xc0\x48\xaa\x8d\xfc\xd3\x2c\x5b\x2a\x5a\x3b\x33\x5e\xb1\x84\x5f\x7e\xdb\xdc\x55\x8b\x3e\x58\xd9\x36\x7f\x64\x9d\x71\x72\xfe\xc6\xab\xc6\xc7\x67\xc5\x1f\x10\xeb\xe9\x20\x4a\x38\xa1\x3d\x73\x50\xae\x41\xde\xe6\xe4\x1c\x18\x0c\xc1\xc0\x81\x61\xf0\x60\x91\x16\x93\xc9\xa7\x26\x49\xaf\xcf\x26\xd6\xaa\x14\x62\x02\x0e\xd5\xe1\xd0\x4d\xbe\x68\xd9\xd3\x7c\x43\xf1\xcd\xbd\x34\xb1\x4e\xd4\x26\x15\xc8\x3f\x33\xe0\xf2\xa6\x42\x19\x51\x4e\x49\x34\xe3\xe0\x8a\x59\xa5\xc2\xd4\xe9\x23\xca\xa6\x81\xd1\x26\xdd\x58\xcf\xd0\xc8\x77\xbe\x79\x36\xde\xc0\x35\x35\xcd\x8d\x83\xe8\x39\xe3\x5b\xc7\x5f\x53\xa5\x34\x6f\x6d\xdf\xab\x02\x0b\xe7\x2f\x5d\xbf\xe8\xfe\x77\x75\xe0\x85\xc1\xcb\x84\x07\xa8\x95\x6f\x48\x3d\x55\x7f\x87\xb8\xef\x5b\xd0\x1f\x38\xb1\x4e\xde\x69\xc1\x38\xc0\x29\x69\x05\xf4\x73\x1a\x8d\x5b\x01\x80\xcd\x6e\x77\xc1\xac\xc5\x42\xca\x58\x3b\xca\x60\xd4\xd0\xa8\xa5\x5c\x00\x1d\xc7\xa2\x64\xa0\xf0\xf0\x0d\x95\x7a\xa5\xee\x4e\x37\xa8\x49\xa1\x16\x33\xa3\x0b\x95\xdd\xe0\x49\x85\xb0\x23\x55\x03\x42\x73\x95\x11\x13\xb5\x53\xaf\x4d\x5e\x16\x7b\x52\x3e\xf3\xd5\x65\x32\x93\x93\x5a\xa5\x67\x66\x2c\x59\xfe\xb4\x6c\x3d\x21\x07\x2a\x07\x43\x84\xf5\xb5\xdf\x39\x3b\xd3\xbf\x5c\xf8\x1f\xe1\x35\xa3\x59\x1e\xd6\xd7\xfc\xfb\xc6\x47\x3d\x77\x4b\xef\x2d\x7f\x34\x35\x1b\x90\xf8\x3d\x0c\x45\x84\xb1\xc4\xa4\x4d\xfc\xec\x0b\xf8\xd9\xcb\xe0\x30\x43\xe1\x5b\xa7\x9e\xcb\x7e\xf6\xca\x54\x33\x6e\x05\x7b\xe1\x7f\x17\xc5\x1e\x42\x9f\x41\x7d\x7f\x3e\x95\x06\xe7\xc0\xe5\xd0\xff\x95\xf3\x0c\xc6\xd0\x3a\x00\x5d\x1f\x60\x08\xa3\xe4\xfe\xda\x45\xf7\xd7\x95\x75\x7f\xd9\x4e\x1f\x29\x08\xda\xc1\x05\xbe\xef\x96\xf3\x5c\x1f\xb8\x5c\xd8\x31\xdd\xf5\xa9\x44\xd7\x07\x65\x39\x28\x74\xe2\x11\xfc\x9b\x0c\x25\xdb\x3d\x75\x20\x2b\xdf\x77\x85\x99\x40\x00\xfb\xe0\x67\x7b\xa6\x8e\x88\xf2\x41\x3c\x24\xb4\xe0\x6e\x70\x3d\xdc\x8f\x12\x88\x28\x68\xa3\x5e\xef\xc2\xf1\x78\x69\x10\x22\x4b\x5b\xdc\xf8\x0c\x98\xf9\x84\x22\x22\x7f\x0e\x4a\x88\x02\x4d\x87\x18\x68\xea\xd2\xb9\x56\xcc\x42\x1f\x45\x96\x6d\x28\xec\x17\xf9\x42\x70\x96\xf2\x23\x42\x7f\x1c\x8d\x70\x93\x4d\xbf\xd1\x99\xf1\xf3\xee\x6b\x56\x5d\xe1\x25\x89\xe6\x45\x63\x3d\x01\x32\x46\x26\x5b\x2f\x5f\x91\x30\x35\x83\x94\xc3\x57\x91\x2c\xb1\x7b\xca\x6a\x4a\xc1\xf5\xef\x2d\x7f\x69\x64\x2c\x59\x5b\x0e\xd3\x9b\xea\x78\x85\x96\x96\x2b\x53\x9b\x06\xe6\xae\x05\xab\xee\xa8\x28\x5f\xfa\x69\x22\x16\xcb\xfc\x5c\xd2\xf3\x39\x61\x06\xbe\x05\x5c\x0f\x75\xda\x3b\xb5\x20\xab\xe7\x6a\xa1\x03\x2f\x43\xfb\x20\xdb\x37\xb5\x55\xd2\x13\xeb\x9e\xfa\x83\xec\x49\xe2\x2c\xd4\xb2\x0a\xdb\xcc\x37\x38\x3d\x1e\x5b\x5c\x1e\x0e\x87\xf4\xc1\x60\xa8\x5c\x13\xe2\xe0\xa1\xaa\xae\x89\x26\xfa\x32\x51\x26\x44\xc7\xc9\xbe\x4c\x3c\x6e\x92\x9e\x33\x32\x41\xbd\xde\x07\xd3\x44\x9f\xc9\xd7\x9f\xa1\x4d\xe6\x6c\xaf\x9f\x64\x87\x85\x17\x18\x45\x93\x20\x0d\x45\xa3\x5e\x93\x59\x0a\x7e\x14\x1f\xb2\x15\x76\x84\xbd\x3c\xe1\x3c\x00\x9b\x36\xa2\x19\xc5\x12\x90\x2b\x25\xc9\x9e\xbc\xea\xcb\xbb\xa4\x77\x4e\x43\x6f\x2f\x16\x7e\xd5\xb4\xec\x9e\x89\xc2\xd3\xc1\xa6\xca\x43\xe8\x4d\xe1\xdc\x8e\x83\x27\x27\xff\x71\xe9\x9d\x51\x47\xfb\x76\xfc\xdf\xc3\xb7\x2d\xd3\x98\x2a\xd0\x4b\xa7\x59\xfd\xbf\xb8\x72\x71\xd1\x93\xc2\xe8\xd2\x1b\x07\xf0\x7e\xeb\x06\xe1\x01\xed\xad\x2b\x62\xb1\xef\xc3\x35\x51\x4f\xfd\x91\xf8\x4e\x76\x46\xf5\x2a\x3e\x55\x62\xb7\xd2\x64\xdc\xac\xd3\xc5\xe3\x1a\x52\xab\x55\x12\x41\x2f\xe1\x4d\x56\x59\xf5\xfd\x19\xa5\xd5\xac\xd1\xc8\xfa\x33\x56\x8d\x55\xe3\xd2\xba\x22\xfd\x19\x17\x83\xc6\x90\x14\x1e\x24\x14\xe6\x62\xe6\xa6\xc8\xe7\x1f\xcf\xe4\xc6\x83\x8a\x18\x19\xbd\x44\x34\x86\xa5\x8c\x20\x0d\xbc\x14\x27\x4e\x53\x43\x35\x4a\x79\xae\x4a\x89\xcb\x8d\x52\xd2\x40\x48\xa4\x09\xe0\xe5\x75\xbf\x9e\x7f\xd6\x04\xd1\xd1\xb8\x7f\xfb\x30\x0d\x34\x21\x95\x92\xb5\xb1\xa6\xd5\xfe\x4b\xe7\xdb\xb8\xa6\x9b\xba\x77\xdc\x70\xe0\x8f\x6b\x66\xd4\x04\x16\x97\x2c\x35\xf5\xba\xdb\x2f\xed\xe4\x02\x7e\x32\x43\x06\xfa\x6e\xbe\x4a\x31\xf8\x3e\xce\x04\x1b\x6e\xdc\x2f\xbf\xbb\xa7\x7f\xc1\x93\x77\x3c\x26\xbc\xf5\x4d\x7c\xd9\xea\x9d\x3d\xcd\x93\x3f\x33\x3a\x6f\xfc\x5c\xb4\x0d\x34\xb3\xfc\x75\xb8\x0e\x61\xac\x1a\xdb\xcd\xb7\x79\x38\xaf\xd7\x5c\x56\xae\xd4\x98\x64\xc1\xa0\x9e\x65\x9d\x66\x73\x2a\x42\x10\x35\xa9\x80\xb7\x37\x13\x60\x3d\x96\xfe\x8c\xde\xe3\x34\x99\xd0\x80\x44\x93\xc7\x44\xb1\x98\x92\xa6\xa0\xe5\x50\x4c\x59\x30\x58\x82\x95\xf4\x4b\x8b\x52\x34\xba\x3b\x3b\xb6\x5c\x5a\x98\xdc\xfb\x96\xc2\x3d\x81\x58\xa9\x2e\xb4\x01\xa3\xe1\xdd\x88\xcf\xa9\x78\x95\x72\x8b\x84\x6e\xb5\xa0\xe9\x10\xd3\x66\x78\x03\xd3\xe6\x83\xfb\xfe\x78\xc3\xba\x16\x52\x66\x36\xc2\x65\x5a\xed\xdf\x3e\x44\x03\x26\x64\x92\x56\x69\x47\xe6\x1b\x63\x1a\xe1\x34\xd5\x70\x5b\x73\x5d\x19\x9a\xe3\x6d\x9a\xe7\x6e\xdb\xda\x66\x7a\xec\x18\x1a\xe2\xed\x28\x2d\xbf\x86\x08\xf4\xdd\x74\xb5\x62\xf0\x47\x04\x5c\xaa\xc3\xd7\xca\xcf\xcd\xb6\x36\xde\xd8\x37\x08\xb6\x89\x93\xbc\x43\x26\xc7\x0d\x7f\x93\xde\x9f\x0a\xb3\x89\x01\xd9\xbd\x58\x0c\x5b\xcb\x37\x44\xdc\x2e\x3b\x19\x0d\xda\x6c\xd1\x28\xa6\x50\x22\x83\x91\xc5\x62\x25\x86\x78\xc4\xdd\x9f\x91\x45\x82\x0a\x05\xd6\x9f\x89\x28\x22\x0a\x7b\xcc\xae\x74\xd9\x5d\x7d\x19\x8d\x9d\x66\xb8\xbe\x8c\x91\x01\xd9\x71\x7b\xc9\x22\xda\x91\x9c\xd1\x64\xdb\x74\xc5\x67\x91\xf9\xe2\x70\x7e\x21\xfc\xa8\x41\x3a\x3f\xe7\x53\x2e\x8e\xdb\x27\x38\xb4\x12\xe2\xda\x78\x8f\x19\xca\xe2\x86\x16\x6e\xdd\x70\xf0\x5e\xcd\x83\x5c\xf0\x83\x27\x46\xda\xc2\xbc\x86\xf5\x57\xb7\x5a\x9c\x6f\x1b\xde\x6e\x54\x29\xe3\xe5\x86\x16\xcb\xba\xe1\xab\x84\x2f\xc0\xcb\x44\x63\xea\xba\x83\x8a\xf7\xdb\xc3\x97\xbe\xf6\x04\xfb\x8b\x8d\xec\x9a\xcb\xef\x1a\x17\xbe\x89\x37\x54\x5f\x7f\x80\x9a\xd4\x60\xc4\xd4\x1f\x30\x4c\x8e\x66\x3f\x96\x62\xf5\xd8\x4c\xec\x5b\xfc\x62\x46\xad\xd7\xab\x14\x33\x59\x56\xa9\x54\xc9\x9a\x5a\x5b\xc9\xaa\x6a\x9c\xb0\xdb\x09\x82\xac\x8d\x97\x94\x94\x95\xf9\xc2\x91\x08\xa9\xf2\xa8\x3c\x9d\x5d\x4d\xd5\x0d\xbe\x14\x96\xea\xcf\x84\x75\x32\x78\xd2\xa8\x06\xaa\x3f\x13\x64\x1a\x30\xf8\x55\x62\x29\x89\xf4\x66\x54\x64\x09\x3b\xd3\xce\xb2\x15\x6d\x96\xb6\xfe\x8c\xd3\xc2\x18\xd1\x1b\xe3\xa2\xa9\x9a\xc9\x64\xfe\x48\xe9\x25\x7e\x0d\xb1\x03\x34\xfb\x4d\xde\xd3\x4c\x6f\xc5\xcb\x5a\x52\xbe\xa9\x52\x0a\x90\xbe\x30\xe1\x35\xa2\xbb\x45\xaf\x11\xae\xa4\x74\xc7\x97\x9d\xbe\x99\xad\x92\x20\x16\x43\xa9\x0b\x58\x8c\xf5\x88\x67\xcb\xdc\x00\x03\x90\x0c\x5a\x22\x21\x15\x86\xc8\xcc\xa6\x8d\x35\xc2\x3f\x3a\xae\x5f\xa2\xef\x15\xfe\x99\xb6\x69\x17\x84\x37\xd7\x8b\xa3\x38\x3b\xef\x5d\x9e\x59\x01\xae\x3f\x3b\x34\xee\x77\x68\x16\x04\xb6\x25\x50\xcf\x70\x52\x3f\x2c\x3e\xf2\x50\x5f\x37\xa6\x37\x99\xcf\xfd\x67\xd3\x46\x82\x92\x93\xb3\x12\x3b\xdc\xc0\xee\x10\xbe\x07\xae\x2e\x17\x66\x83\x35\x9c\x73\x57\x3f\xe8\x15\x5f\x88\xac\x5e\xf4\xda\x86\xe5\xd1\x67\x2d\x8e\x9d\xf3\x84\x5f\x5b\x5a\x81\x03\x80\x67\xd1\x5b\x92\xa6\xb2\x4d\x5b\x7a\x1c\x6c\x2c\xec\x51\x2f\xdd\x3f\x07\xc5\xac\x5f\x62\x18\xb9\x05\xee\x8b\x0f\xee\xcc\xd5\x7c\x9b\x49\xc7\xb2\xda\xa8\xda\x6a\xd5\x68\xf4\xda\x38\xcc\x3b\xfd\x7e\xc2\x43\x92\x18\x74\x54\x65\xe5\x3a\x75\x54\xdd\x9f\x31\x61\xd1\xa8\xd5\x1a\xb4\x07\xe1\x91\x8d\x2b\xe2\xfd\x19\x42\xa1\xa0\xec\x0c\x47\x6b\xb3\xdc\x08\xc5\x53\xc9\x8b\xfa\x8c\x2d\xe5\xc9\x62\xfe\x8a\xe2\xc5\x9e\xbe\xc2\xd9\xa3\x69\x84\xa8\x43\x5a\x64\x78\x5e\x8b\x1b\xac\x6b\x52\x41\x69\x08\x2a\x42\x29\xe4\x16\xd3\x60\x6b\x19\x5a\xa4\xea\x45\xb7\xb6\x77\x0a\xff\xe4\x5d\xba\x51\xd3\xbc\x96\x9a\x7c\xdb\x75\xc0\xa3\x13\x7e\x3f\x12\xdf\xb0\x50\xbb\xf8\x96\xf6\x20\x3e\xa3\x61\x77\xa9\x70\x0e\xae\x49\x5c\xc7\xdb\x85\x35\x60\xb3\xcd\xdb\xb0\x3b\x0e\x6a\xa4\x66\xec\xf8\xeb\x76\xef\xcd\x4b\x67\x6d\x8d\xe8\xd2\xf6\x37\xd0\xfa\xb8\xe0\x39\x7d\x05\xae\x4f\x10\xfa\xf5\x4d\x7c\x53\x08\xc3\x92\x55\x0e\x93\xd3\x69\x54\xc8\xe3\x25\xa4\xd7\xab\x33\x18\xac\x46\x63\xb2\xc4\xeb\x8d\xfa\xa3\x88\x20\xc7\xed\xec\xcd\xb8\x69\x07\x0b\x1d\x9b\xb2\x3f\xe3\xd0\x3b\xf4\xa4\xd1\x4e\x42\xef\x4e\x9a\x73\x2f\x22\xd1\x19\x2d\x0c\xc5\xc6\x92\x85\x3e\x88\x82\xd1\x65\x6b\x32\xd0\x81\x4b\x55\x90\xac\xd3\xa2\x81\x37\xe7\xcb\x0a\x6b\x22\x2b\xdc\x53\x35\x03\xe2\x95\x2b\x3e\x39\x32\xbf\x5d\x65\x32\xb0\x76\xb3\x71\xb5\x6f\xc7\x02\x85\xf0\x99\xc7\xe4\x42\xae\x6c\xe7\xd0\x03\x63\x1a\x90\x91\xef\xbe\x61\xeb\x0d\xc2\x97\x4d\x89\xb6\xe5\xcb\x2c\x33\xac\x9d\x3b\xdb\xf0\xed\x4f\x08\xef\x9f\xf2\x8e\x5d\x4a\xea\x03\x0d\xd7\x1d\x50\x24\x4f\x43\x37\x76\xe3\x7e\x8a\x78\xd0\xda\x78\xf0\xe4\xe9\xd7\x56\xef\xbc\x7a\xf2\xc7\x16\xcb\xf5\x9f\x8a\xbe\xeb\x69\x0c\x23\xe2\xe2\x9b\xde\x0d\x7c\x83\x9b\xf3\x78\xcc\x26\x8d\x1a\x23\x59\xbd\xdf\xcf\xb2\x0e\xb3\x39\x20\x0b\x3a\x44\x97\xee\x46\xee\xdd\x6d\x82\x5f\x66\x9f\xcf\xd3\x9b\xf1\xd1\x66\x56\x8d\x61\x0a\x42\xd1\x9f\x91\x8b\xef\xca\x73\x9e\x3d\x5d\x74\x3e\x4b\xce\x1b\x88\x5e\xe4\xd3\x81\x34\x2a\xd4\x1f\x46\x0e\x8b\xcb\xfb\xaa\x82\x57\x43\xcd\x42\x4f\xa7\xee\xec\xab\xf0\xd7\xa7\xe2\xdd\x1b\xab\x4c\xa6\x78\x19\xf4\x52\x1b\x87\x6a\x84\x2f\x7a\x4c\xd1\x72\x96\xb7\xac\x1f\x8e\x6d\x55\x83\xed\xf8\xaf\xd6\xec\x50\x09\x8f\x1e\x98\x3d\x6f\x13\xd1\x50\x7d\xc3\x01\xb9\xf0\x16\x38\x4d\x24\x79\xa8\xf5\x67\xe8\xa9\x12\xd4\xf3\x5f\x50\xcf\x4a\xf1\xfd\xf6\x10\x5f\x6a\xb0\xd9\xf4\x14\xcd\x68\x50\x03\x33\x4c\xb9\x5c\x6e\x0f\x07\x93\xdd\xfe\x8c\xcd\xd8\x9f\xd1\xd8\x68\xf8\xa5\x77\x38\x20\xd6\xc1\x1c\x0c\xe2\x9d\x49\x27\x2f\xd0\xa8\xa8\xbb\x22\x6b\xed\xb9\x94\xe7\x62\xba\xa4\x0c\x5e\xa8\xa9\x8a\x57\xb1\xa1\x15\x71\xd6\x14\x4e\x98\x5a\x2c\x1b\x86\x6b\x84\x8f\x7a\x0c\xa2\x1a\xeb\x86\x07\xc1\xf2\xe5\xcd\xf8\x0f\xd6\x59\xa6\xb6\x12\xc9\xa6\x1b\xae\xa5\xb2\x1a\xc0\xf0\x03\xc6\x8c\x59\xde\x1e\xf4\xf6\x26\x81\xcd\xe6\xc3\x66\xb9\x3c\x6c\x2b\x77\xb9\x74\x30\x85\x4c\x56\x59\xc2\x95\x3a\x1d\x5b\x16\x26\x1d\x84\x23\x00\x0d\x16\xc2\x76\x35\x3c\xbb\x84\xb9\x10\x4f\x0c\x18\x57\x37\xbd\xe3\x29\x07\x50\x4d\x45\xd3\xe7\x21\xac\x2e\x47\x63\x5d\x91\x2b\x0c\xa1\x19\xbb\x28\xa0\x64\xb9\x00\xdc\x00\xd5\x89\xa1\x33\x34\xe3\x4f\x7d\xff\xcd\x9e\xc7\x4b\xca\x5a\x69\x7e\xd3\xdc\x65\x03\x8d\x97\xa4\x7a\x8d\xb3\x42\x03\x34\xd8\xb9\xed\xc6\x92\x56\x2d\x3b\x37\x39\x7b\xe6\xac\xe6\x5d\x6d\x3d\xa6\xee\x28\x3c\xb8\xd1\xdb\xee\xf7\x1b\x81\xec\xaa\xe1\x05\x2d\xad\x35\x86\x40\xe9\xbd\x9d\x91\x2a\xe0\xf4\x7c\xbe\xde\x56\xd2\x96\x6a\xac\xd2\x87\x63\x0f\xcc\x8a\x4a\x39\xd0\xfe\xa9\x4f\xf0\xb5\xe4\x3e\x2c\x8e\xad\xe3\x1b\x1c\x6e\x4f\x84\x8c\x85\xec\xf6\x58\x4c\xc3\x9a\x09\xab\xd5\x40\x28\x95\xa5\x65\x66\xb7\xc3\xdd\x97\x89\x40\xc8\x69\x88\x84\x58\x56\x07\x83\x29\x1b\x61\xe5\x36\xde\xea\xa0\x71\x6c\xda\x6c\xe1\x74\xd2\xf6\x56\x71\x10\xcd\x6d\x1c\x2a\x5e\x4d\x0b\xa4\xc5\xe3\x85\x53\xb9\xb2\xac\x18\x55\xa5\x0a\xa0\x88\x29\x92\xb8\xc8\x65\x0d\x1e\xf6\xcd\xb6\x55\xde\xda\xb6\x7e\xbb\xdc\xc3\x68\x42\x31\xe3\x98\xef\x8a\xc5\xe1\x4b\xd4\x37\x1c\xba\x39\x74\x97\xe1\xae\x26\xbd\x26\x18\x33\x8d\xb5\xbe\xac\xab\x9e\xb0\x75\xf8\xcb\x57\x2f\x67\xab\xcf\x50\x55\xe9\x9b\x0e\x12\x3f\x69\x09\xbf\xff\xfe\xb8\xf0\x08\x95\x6c\x12\xfe\x48\xf5\x78\xaa\x2b\x8a\xdf\xa3\xc5\xb0\x09\x3e\x65\xf1\x99\xfd\xb8\x16\xd3\xe9\xa2\x10\x5b\xc5\xfd\x26\x05\x86\x95\x70\x34\x4b\xf7\x66\x3c\xd6\xfe\x8c\xc2\xe3\x54\xab\x49\xe8\xa9\xd5\x1e\x35\x66\x62\x69\xe0\xc7\xfc\xbd\x99\x28\x7a\x0d\x92\xc8\x73\x0a\x9c\xa7\x6e\xa1\x54\x97\x2c\x4a\x67\xfd\xd9\x7b\x2d\xbf\xd4\x7b\x51\x78\xca\x96\x35\x5d\xd4\xe8\x90\x7f\xd5\x26\x68\xe9\xca\x0a\x6e\x71\xf8\xba\x35\xb6\xc0\x9d\x85\x07\x6e\x53\x98\xa3\x0c\x7d\x7c\x08\x7e\x7c\x7b\xee\xad\x1b\x38\x40\xc6\x67\xde\x79\x85\xe6\x0b\xe9\xc9\x9b\xb0\x95\x28\x69\xbf\x6b\xaf\xe6\x13\xe9\xe5\x1b\xf2\xc1\x3f\x83\x3e\xf8\x0d\x68\xc7\x1a\x98\x71\xcc\xe5\xa3\x36\x4c\xab\x8d\x97\x86\xe4\x81\x00\x45\x99\x8c\xc6\xb8\x3c\x14\x22\xa2\x44\x7f\x26\x1a\xd5\x73\x9c\xa7\x2f\x63\xe7\x18\xbd\xb2\x2f\xa3\xb7\x5f\x64\xd4\x79\xde\xd3\xe6\x07\xcb\xc3\xad\xcc\x22\x64\x31\xa7\x0a\x4a\x1e\x57\x4a\xd7\x73\xb6\x5c\x40\xd4\xf8\xde\x96\x84\x7f\x71\xe9\x9a\x86\x8e\xae\x5d\x9d\x80\xba\xf6\xd3\x5b\x4f\x9e\x7b\x38\xf0\x8f\x8f\x16\x7d\xab\xc6\x5c\x1b\x08\x6c\x6e\x9f\x31\x9c\x32\x58\xb8\xa6\x5b\x3b\xb7\xde\x70\x6a\x62\x47\x47\xe3\xe4\xb3\xd6\x03\x7f\x3f\xf5\xa4\xf0\xf6\x83\x31\xe2\xc5\x37\x5f\x8b\xb8\x27\xaf\x0c\x96\x27\xc6\x56\x1d\xe9\xea\xcb\x9c\x16\xef\x20\x6a\x09\x8e\x1c\xc5\xec\xd8\x32\xde\x9b\xeb\x74\x2e\xee\x51\xb4\x88\x7d\xce\x6a\x44\x69\xa3\x93\x3d\x03\x1a\x78\xa5\xde\x6c\xb6\x5a\x71\xdc\x58\x68\x52\xcc\x76\x71\x65\xf3\xa4\xec\x55\xf6\xff\xd2\xa5\x88\x27\x8b\x9a\x14\xc5\xa7\x20\xed\xb2\xae\x79\xed\x32\x40\xcb\xba\x02\x1f\x07\xa4\x6f\xe0\xcf\xc2\xe7\xb2\xae\xf0\xc7\xe1\x76\x19\x5e\xeb\x52\x83\x1f\xa9\x5d\x2e\xf5\x9b\x6f\xa2\x3f\x85\x38\xfa\xf3\xc3\x0f\xd5\x2e\xb4\x3f\x7f\x10\x3a\x88\x4f\xc4\x37\x9d\x21\x6c\x1e\x1f\x85\xb8\x87\x22\x94\x7a\x3d\xb4\xc7\x70\x24\x40\x13\x44\xd8\xa0\x62\x54\xbd\x19\xaf\x5c\x41\x19\xe5\x46\x8c\x66\x68\xcc\x86\x1c\x65\x76\x7f\x72\x22\x16\xbd\x98\x34\x14\x5e\xdc\xe7\x78\xd4\x31\x34\x6e\xd8\x5b\xb0\x3a\xb1\x4c\x28\xf5\xa0\x95\x4b\x4d\x29\x60\xe4\xc1\x37\x80\xfa\xf3\x94\x0e\x0c\x08\x3f\x4c\x2d\x31\xd7\x77\x56\x12\x0a\xb5\xf0\xc2\xc6\xb5\x87\xfe\x73\xd9\xc2\x3d\x16\x23\xbd\xf7\xe6\x26\xa1\xe3\xb1\x23\x2f\x01\xbc\xb4\xa7\x0f\xa4\x59\x1d\x34\xb8\x16\xe1\xe7\x77\xdf\xfe\xd2\xd1\xcf\xae\x1e\xfb\xf7\x43\x33\xd6\xdb\xd9\xf2\x2f\xbe\xbe\x60\x4c\xf2\x2d\x7f\x9b\xfa\x44\xf6\x53\x98\xcb\xb4\x60\x8f\xf3\xcb\x12\xd5\xd5\xe5\xce\xc6\x86\x5a\x32\x95\x72\xb9\x82\xe5\x4d\x8e\xe6\x66\x3b\x46\xc8\xac\x64\x4b\x8b\xcd\x66\xd7\x9b\x4c\x3a\x7b\xb9\xba\x5c\xdd\x3a\x03\x23\x9a\x1c\x8d\xce\xd2\x98\xa2\x04\x6f\xe6\x9b\x7b\x33\x3c\x96\x68\xa8\x6d\xe8\xcb\xa4\xf8\xea\x5a\xba\xc4\x1c\xf0\x45\x7c\x73\x32\x11\xb3\x9d\x15\x39\x12\x59\xab\x4c\x66\x56\x98\xe1\x49\x65\xce\xcb\x73\xb2\x20\x2a\x29\x3d\x25\xcd\xb2\x64\xe9\xb9\xba\xf3\xf3\xe2\x02\x4e\x2d\xfc\x80\xca\xd2\x49\x90\xcf\x02\xb3\x6f\xd2\xf2\x03\xe3\x01\x95\x6d\x0d\xc8\xf6\x27\xa1\x12\x5b\xaa\x70\x7b\x21\x1a\x09\xe9\xba\x65\x87\xf0\x43\x37\xc3\x9f\x5e\xb6\x60\x3e\x33\x8a\x10\xd6\x3a\x43\x4d\x6a\x5b\xd9\x84\xf0\xcf\x0d\xc2\x09\xbc\x3a\x24\x39\xb5\xa5\xb5\xfe\x4b\xc7\x0c\x86\x85\x79\x77\xd6\x03\x96\x2d\x1a\x51\x83\x75\xe4\xd1\x6f\x08\x8f\x9e\x4e\x2d\x1c\x1f\x5d\xd1\x30\x3c\xf9\x17\x4b\x2b\x3e\xba\x30\x32\xb0\x63\xed\xe4\x29\x7c\xa7\xb0\xcd\xa0\xab\xae\x40\xce\x2e\x1c\x5e\x1f\x49\x95\x2d\x03\xff\x95\x3c\x5d\x3f\xb8\x0e\x37\x58\xa4\x39\x1c\x53\x93\xd0\xb8\x38\x68\x57\x34\x36\x9f\x2f\x55\x2b\x34\x1a\x0a\x23\x68\x9a\x24\x29\x8a\xd1\x13\x4a\x15\x3c\xe3\x18\xa2\x1b\xc3\x11\xd1\x18\xa5\x43\x8c\x54\x3a\x3a\x0f\x41\xa7\x71\x84\x24\x0b\x7e\x7c\x1a\xd4\x14\x73\x1e\x44\xe4\x20\xbd\xb2\x01\xc7\x76\x1b\xf6\x34\x6c\x57\x0b\xdb\xbb\xe1\x37\xb5\x48\x0b\xdc\x34\x2e\x9c\x82\x68\xf1\xe1\x71\xd0\x9c\x95\x0b\xcd\xb5\xc7\xc3\x50\x2e\x1b\x36\x2c\x71\x4e\x19\x8d\x4a\xb9\x4a\x65\x21\x08\xbb\x43\x4f\x29\xa8\x3e\x28\x87\xc2\xad\x80\x72\xc1\xcc\x4d\x23\xb1\x35\x70\x2c\xc6\xce\xc9\x27\xb3\x5f\x21\x5b\x31\xdd\x94\x2c\x4b\x32\x2d\x49\x86\x98\xdc\xf2\x9d\x32\x80\x1a\x5a\x4a\x84\x2f\x31\x6c\xa9\x5d\xa8\x01\xeb\x3a\x0f\x1b\x0e\xfb\x64\x6d\xb1\x6a\x4f\xfd\x5d\xa6\x91\x41\xda\xf3\xb1\x28\xaa\x30\x3e\xfe\x72\x75\xaf\xbf\x26\x89\x7a\xa3\x88\xa9\xf5\xc2\x6c\x92\x85\x3e\x14\xbd\x62\x2a\xc7\xf6\xf3\x5d\xfe\x48\x04\x8d\x1d\xad\x34\x1b\x39\xce\x50\x16\x08\xaa\x48\xbb\x1d\xb1\x67\x55\x94\xda\xed\x25\x4e\x98\x78\x3b\x99\x80\xcc\xc4\x9a\xfa\x32\x65\x38\xcd\xba\x59\xa8\x0d\xcb\x42\xef\xc4\xf5\x66\xac\x34\xa3\xed\xcd\x30\x76\x05\x74\xb6\x0a\x73\x9e\x04\xad\x58\xa7\x64\x76\x42\x4a\x91\xd3\xd5\x4f\x07\xb7\x59\x28\x81\x0c\x0e\xcd\xb2\x87\x89\x38\x95\xa5\x7c\x90\x34\x16\x91\x2d\x9a\x45\xe0\x25\x10\xc9\x91\x88\x92\xbc\xc4\x2b\xf2\x8c\x71\x28\x21\x7c\xf9\xd8\xfc\x76\x19\x15\x39\xa1\x99\xfc\x83\x66\xfc\xe0\x62\xe3\x68\x7d\x1e\xd7\x4e\xfe\x7d\xfe\x7e\x9b\xf0\x46\xb5\x65\x06\x70\x21\x84\x6b\x03\xe5\xf8\xf6\x64\xc5\xf8\xdb\x7f\xf3\xd6\x27\xff\x6b\x69\x69\xb1\x10\xd4\x38\x98\x21\xe2\xda\xc9\xe6\xef\x1c\x13\x7e\x68\xb1\x80\x73\x10\xe0\x7e\x4d\xac\x5f\x30\x59\xfe\x08\x54\xcf\xde\xc5\xf3\x8c\x9f\xa6\x43\x21\xb4\xbb\x84\xc5\xee\x70\x70\x3e\xbd\xd7\x6b\x30\x70\x04\x17\x89\x72\x06\x03\xad\x42\x9b\xeb\xb7\x8b\x7b\x6e\x61\x0a\x9b\x6e\xd2\xd0\x98\xab\x88\x61\x42\x7a\xb0\x9c\x5d\x95\xe9\x74\x13\x05\x7b\xd4\x7f\xf5\xf6\x17\x3d\x50\x81\xeb\x45\xe1\x61\x14\x68\x45\x72\x72\xc4\x43\x21\xd7\xaf\x30\x2c\x4f\x48\x5c\x14\x49\x30\x3b\x21\x11\x51\x24\x6f\x30\x5c\xaf\x4f\x7d\xd6\x37\xcc\x1a\x84\xa7\xf4\x32\xd3\xa5\xd7\xb8\xab\xd7\x8a\xa6\xd1\x6a\x11\x5e\x01\xcd\x88\x92\x42\x78\x79\x7c\xbd\x70\x6a\xc3\xd2\xcb\xb6\xac\xad\xb3\x7c\x0d\xf9\xf2\xa7\xa7\x3e\x21\xf7\x41\xfd\xa3\x58\x25\x76\x25\x3f\xa3\xd4\x6c\x0e\xaa\x0d\x5e\xab\xc1\x4a\x44\xec\xc1\x60\x22\xc9\x96\x97\x33\x14\x41\x24\x9c\x0c\xa3\xf7\x68\xf4\x9a\xfe\x4c\x59\x44\x26\x97\xf5\x65\x82\xac\xdc\x6a\x54\x19\x21\xc8\x57\xc9\xe1\x17\x66\xd3\xd3\x58\x6c\xda\x12\x88\xcc\x10\x92\x41\x14\x16\x22\x7f\x4b\x51\x68\xa5\xc8\xe6\xdc\xd2\xad\x15\x5a\x07\xb4\x0a\x22\xb8\x92\x9e\xa4\x13\x72\xca\x5b\x5d\x15\x36\x66\x1f\x1e\xa3\x26\x71\xb8\x28\x78\x10\xd9\x0a\x05\xc3\xc0\x0f\x7f\xfd\x77\xbc\xd3\xd0\x1d\xfb\xfd\x03\x2a\xee\xf9\x8e\xfa\xee\x34\xf8\xd5\xcc\xbb\x1a\xc0\x8f\xaf\x73\x82\x5f\xf9\xba\xcd\xb3\x1e\xe7\xf0\x13\xdf\xe8\x36\x74\x2e\x12\x5c\x9b\x0e\x7a\x84\x00\xb9\xdc\x74\xfc\x78\x64\x7c\xe7\x5d\x56\x9f\x6a\x25\x30\xc3\x84\xf9\x3b\xe6\x53\x1c\x70\x0a\x7f\x5a\xa9\xf2\xd9\x4e\x6c\x1b\x17\x4e\x2c\xdf\x71\x55\x7a\xd9\x88\x38\x17\x0a\x62\x11\x54\xe7\xf3\x61\x15\x30\x62\x27\x55\x51\x8a\x8a\xc5\x48\xaf\xd1\xea\x37\x12\x0c\xc1\x54\x26\x38\xb8\xef\x36\xce\x1e\x55\xa9\x42\xda\x50\x7f\x46\xcb\xc8\xa1\x47\x92\x63\x46\xaf\x17\xc3\x4a\xfb\x2e\x28\x67\xe5\xbe\x4f\x16\xea\x9d\x75\xd2\xc3\x8d\x9c\x19\x84\xa5\xaa\x66\xbe\xa2\x47\x83\xa2\x2e\x8c\x34\xb8\x58\x81\xef\xd7\x88\x37\x6f\xb6\x51\xaa\xe7\x5d\xb6\xd6\x1a\xbc\xf9\xc6\x8e\xbe\x08\xcf\x19\x6d\x5b\x4a\xe8\xf4\x73\xe7\x95\xf7\x64\x32\xae\x45\x98\xbb\x55\xac\xe9\x7d\x43\xf8\x70\xe4\xe0\x1b\x8f\x1a\x3e\xde\x6c\xfc\xf3\x02\xe3\xb4\xea\x1e\x8e\x59\xa0\x0f\xb1\x42\xdd\xfd\xd0\x36\xd6\xf3\x0d\x7a\xb7\x9b\x61\x68\x65\x49\x8c\xd0\x70\x5e\xaf\x46\x43\xd3\xc9\x00\x62\x09\xf1\x30\x10\x7b\xc2\x44\x10\x1e\x09\xd6\x2e\x7a\x65\x8c\x2a\x43\x25\xbd\x98\xd7\x1b\xc6\xc2\x17\x96\xf4\x24\x94\x36\xbd\x96\x97\xf7\x17\x05\x33\x90\x8a\x79\x12\x84\x81\x5e\x7b\xda\x2a\xf8\xbf\xba\x90\x47\xa8\xcb\x4e\x68\xc0\x93\x7f\x19\xe3\xa2\x37\xde\x90\x5d\x86\xed\x11\xfa\xa5\xaf\xaa\xe1\xb9\x46\x01\x63\x69\xf9\xcf\xeb\xd6\xed\x3f\x7c\x40\x5c\x87\x91\x8b\xd4\xef\x30\x0c\xda\xc1\x7c\xd9\xbd\x58\x04\x1b\xe7\x6b\x43\x66\xd6\x40\x42\xc0\x13\x0e\x13\x18\x49\x46\x82\x1c\xa7\x8c\x28\xa3\x31\x73\x08\x82\x51\x5f\x5f\xc6\x65\x37\xc3\x2f\x43\xc4\x8e\xb1\x06\xb6\x2f\x43\x18\x68\x4a\xd7\x97\x51\x51\x17\x2b\xde\x89\x20\x3c\x7f\x57\x9a\xf5\x08\xd9\xda\xdd\x45\x4b\x76\xde\xe9\x0b\xe1\x25\xbc\xbf\xb8\x68\xc1\x6e\x31\x78\xc3\xe9\x3d\x7e\xb0\xb0\x00\xc2\x77\xd6\x09\x5f\x10\x6d\xd3\x4a\x76\x93\xbf\x39\xf9\xfc\x0b\x92\xd2\x93\xd7\xe5\xb0\xb7\xac\x0d\xc6\x8d\x0a\xac\x09\xdb\xc2\x37\x55\xba\xb1\x54\x49\x34\x5a\x5b\x4b\x59\xac\x56\x39\xa7\x50\xd0\x72\x4c\xde\x9c\x4e\x95\x94\x54\x95\x55\x41\x6b\x87\xe1\x82\xd1\x52\x96\xbe\x8c\x96\xd2\x52\x64\x99\xd9\x11\xec\xcb\x78\x1c\x76\xb2\xbe\x2f\x43\x32\x58\x61\xa7\xf3\x49\x47\x49\x31\x31\x70\xb2\x48\xe7\x1c\xab\x99\x51\xda\x76\xa4\x67\xf1\x65\xb1\xb7\xd0\x5a\x27\x19\x7e\xae\xb9\x2e\x58\x68\xc2\xd3\x01\xa7\x08\xd0\x6b\xc0\x63\x3a\xcb\xac\xf5\x99\xac\xee\x35\x8d\x8c\xf0\xe1\x58\xe8\x9f\x3f\xbf\x18\x68\x07\x54\x0e\xe0\xcf\xba\xb4\x13\xa4\x9e\x04\x89\x07\x63\xc2\x0f\xfb\x0e\xdc\x37\x1b\x2d\xcb\x15\x1b\x27\x7f\xfc\xce\x2b\xd3\x41\xfc\x6b\x08\xe6\xe3\x1d\xd6\x83\x7f\x47\x76\xe1\x80\x76\xf1\x19\x3c\x23\x1e\xb8\x5a\xcd\x98\xcd\xe3\xb1\x52\x94\x5d\x6e\x77\x3a\x68\x8b\x45\xa1\xe4\x38\xd4\x22\xe7\x90\x7b\x7d\x62\x99\x08\xa3\x30\xab\x8d\x24\x1c\xac\x45\xd1\x0b\x0f\x8b\xb4\x7a\x76\x39\x20\x40\x6f\x86\xa0\x0b\x53\x49\xb2\x67\x04\x5a\xc1\x74\x12\x82\xc2\xfd\x5d\xae\x6b\x4e\x29\x36\xec\xa3\xae\xb9\xe9\xc7\x23\xc7\xb1\x09\xae\x02\x8b\xe7\xab\xc1\x90\x7a\xe1\x17\xbf\x98\x63\xf6\xdf\xbc\x67\x38\x6f\x0f\x8f\x3c\xb0\xb6\x4d\xf8\xe2\xcf\x08\x52\x80\xff\x82\x21\xae\xb5\xd5\xfc\xcb\xc9\xdf\x59\x76\xbf\xfa\x94\x64\x10\xe0\x6c\x87\xb0\x4f\x96\xcc\xd6\x46\xde\x15\x66\xe3\x35\x50\x4f\x13\x56\xcf\xbb\x4c\x00\xa3\x69\x3d\xc5\x30\xac\xd9\xa8\xef\xcd\x18\x31\x06\x83\xf8\x80\x95\x69\x20\x3e\x90\xd9\xb1\x82\x06\x25\x45\x7d\x66\x28\xf3\x3a\x5f\x4c\x51\xc4\x59\xdb\x91\x60\x99\xbe\x70\x56\xb0\x73\x9f\x20\x20\x36\x5c\x90\x44\x12\x02\x60\x61\x68\x9b\x3f\x86\xb6\x99\xc2\x76\xf2\x69\x91\x8b\x27\x4b\xd6\x13\xaa\xaa\x0a\x06\x7d\xd5\x18\xa6\x30\xf8\x0c\xbe\xda\xba\xea\x60\x6f\xa6\x9a\x8d\x55\xf6\x65\x4a\x63\x76\x27\xc3\x71\xb8\xd6\x86\xca\x53\x36\x86\x85\x01\x8b\xa5\x15\x06\xc4\x3a\x31\x8d\x0c\x2a\x59\xec\x92\xb2\x94\xd5\x85\x05\x4f\x26\xf3\x6f\xeb\xa4\x52\x24\x51\x0c\xaf\x2f\xa8\x08\x5f\xe0\xad\x8c\x35\xe4\xab\x62\x45\x77\x4c\xf8\xc7\x4a\x91\xb6\x27\xcb\x14\x51\x5c\x00\xd6\x2f\xde\x62\x09\x1e\xbe\xbc\xb0\x43\xff\x10\xb9\x23\xe6\x5c\x96\x9a\x7c\x0b\xaf\x13\x29\x81\x24\x16\x89\x5c\xc1\x37\xb8\x78\xf2\x13\xcb\xee\x57\xce\x48\xab\x84\x18\x25\x00\x16\x83\x3e\x9b\x86\x6b\x14\xc2\x56\xf0\xd5\x52\x6b\x0e\xeb\xf7\x9b\x4c\x7a\x3b\x9a\x3d\xae\xa7\xf4\x30\x45\x33\xa1\xab\x18\x2b\x04\x73\x0e\xab\xfd\xff\x64\xc1\x98\x46\x2a\xa6\x3f\x6f\x55\xbe\x92\x11\xe3\x7c\xf5\xf1\x73\x17\xa3\xc7\xb0\x84\x6e\xb8\x40\xdd\x0b\xa8\x32\x76\xbf\xfe\x78\x41\x41\xd1\x47\xad\xcf\xd6\x68\x03\x30\x2e\x4d\xf0\xb5\x7a\x82\x08\x62\x18\x84\x2a\x30\x32\x79\x3c\x0a\x8b\xc5\x61\xb7\x27\x62\x1e\x4f\xc4\x17\xe9\xcf\xf8\x18\x97\xa3\x37\xe3\xa2\xad\x76\x02\xda\x8b\x11\xc6\x25\xa3\x59\xae\xed\xcb\x28\xe5\x79\x3b\xcd\x97\x24\x2f\x5e\x9e\x2d\x02\xaf\xd0\x05\x17\xf9\xa4\x34\x9a\x0c\x83\xe2\x50\xf6\xad\xd4\xc5\x6a\xb3\xb3\x3b\x23\xed\x7f\xcd\xaa\xd8\xd8\x6f\x60\x17\xae\x83\x40\x56\x51\x2f\x1c\xd6\x8c\x7f\xf0\x55\xa5\xd9\xfd\x7f\x1b\xf9\x85\xb0\x1f\xe9\xbc\x7b\xfd\xb6\x72\x6f\xba\x4e\x38\xd3\x62\x21\x9f\x38\xbf\x32\x2b\xee\xb5\x58\x97\xf5\xa0\xbc\x44\x8d\x79\x3c\x1a\x88\xe8\x35\x1a\xa7\xd1\xe1\xf0\xca\x7c\xd9\xc2\x34\x3c\x93\x0e\x56\x0f\x3d\x34\x34\x81\x5c\x2d\x96\x9a\x56\x8b\x2d\x3a\xad\xd9\x22\x6c\x32\x1f\x8c\xa6\x95\x60\x29\x22\x79\x5e\xf0\x31\x9e\x5f\x7f\x5d\xf0\x0b\xa7\xf7\xf6\x9d\xc3\xe2\x59\xb6\x6f\x8b\x30\xc2\xbd\xb7\x4c\x2f\xbe\x0a\xa6\x93\x67\x5e\x91\xf6\x13\x51\xfb\x89\xbe\xe5\x1f\xd0\xb7\xfc\x02\xea\x51\x8b\x2d\xe0\xe3\x0a\xb3\x39\x11\x64\x08\x22\xea\xc2\x82\x58\x5d\x7d\xc2\x05\xf1\x50\x79\x6f\xa6\x24\xcc\xe0\x68\x03\xed\xbd\x19\xee\xfc\x1d\x4c\x16\x83\x2a\x2c\x77\xbf\x93\x9c\x56\xc2\x9c\xd6\xcb\x2a\x6d\x5d\x51\x49\x33\x54\x8e\x9a\xe5\xa7\x57\x33\xd1\x5d\x3c\xfe\x94\xb2\xc2\x7d\xc7\xce\xc2\x06\x1a\x17\x5e\x55\xa8\x6b\x56\xd7\xb6\x6e\x58\x58\x5c\xd2\x6c\x58\xbe\x78\x5e\x29\x88\x96\x84\x85\xbf\x3e\xfd\x1d\x69\x03\xd7\x06\x73\x95\xcd\x70\x8b\x27\xd4\xbc\x7f\x20\x5f\xd7\x0c\xb7\xd5\x56\xf7\x8c\xa2\x39\xdd\x9f\xc1\x7d\xbc\x04\x62\x8b\x38\x96\xe1\xcb\x22\x9a\x70\x18\xd7\x6a\xed\x06\x5b\xd4\x63\xf3\x94\x96\x61\x30\xd5\x20\xb0\x08\xdc\x46\x88\x3d\x22\x8c\xcb\x05\x23\xac\xcf\x05\xa4\xeb\x40\x7b\x71\xf9\x36\x7f\x83\x5c\x74\x7f\x9c\xbd\x43\x16\xef\xb1\xf2\xba\x7b\xa7\xb3\x0d\x19\x8b\x40\x06\x25\xe2\x0b\x5c\xdf\x91\xd7\x58\x2b\x7c\xdd\xe9\xfb\xe4\x4c\x76\x09\x52\xf3\x4d\x67\xfd\xbf\x7b\x62\x45\x73\x84\x57\x19\xc3\x2b\xe2\x47\xc1\x6f\xed\xde\xe3\xc2\xcf\x24\x65\x7b\xbe\xfe\xd2\xdb\xe8\xbb\x03\xdb\xc8\x85\xdf\x7d\xcd\xf8\xcb\x75\x96\xa9\x73\x4f\x1e\x7d\xfe\x05\x68\xab\x46\xa8\xe3\xdd\xc4\x23\x10\x4b\xf6\xf2\x11\x0f\xe2\x21\xe3\x30\xaf\x37\x10\x74\xeb\xf5\x32\xad\x36\xe8\xf7\x42\xe7\x03\x33\x5e\xc6\xc3\x40\x00\x61\xce\x82\xc9\xa2\x13\x6a\xc9\x11\x94\x15\xa5\x0d\xfa\x8b\x92\x94\x5d\x00\x90\xc2\x29\x30\xab\x98\xb3\xec\x06\x50\x65\xf5\x1f\x3f\xd0\xd6\x1f\x91\x8c\x54\x2b\x3c\x7c\x71\x12\xb3\xef\x1c\x7e\xe9\x59\xd1\x54\x67\x4a\x6c\x66\xc8\x56\x7f\x0f\xf5\x78\x1b\xe6\x4b\x09\xe4\x79\x68\x8c\x89\x25\x12\x3e\x7f\x65\xa5\xc9\x6b\xf4\xf9\x2c\x2e\x57\xb2\xca\xc8\xa0\x99\x95\xc9\x84\xaf\x37\x93\x60\xc3\xd0\xdf\xc4\xc2\x76\x93\x97\xc6\x48\xa5\xdd\x60\x80\x48\xd9\x40\x2b\x45\x17\x8b\xae\x22\xb9\xba\xbc\x7f\x3d\xbf\x2d\xbe\x6e\xda\x19\x14\xe7\xca\xa2\xc6\x1c\x94\x23\x06\x45\xa6\x33\x71\x5c\x93\xa4\x33\x0d\x2e\x88\xff\xe0\xcc\xfd\x81\xb0\x3e\xa6\xf9\x1f\xa6\xa5\x13\x38\xde\x80\x10\xa0\xe4\xfe\x95\x95\x95\x29\xcd\xfb\xec\xc1\x77\x7f\x33\x9f\x75\x9f\x28\xe8\xcf\xdc\x0b\xb6\x1d\x74\x97\x78\xad\x2e\x65\x8b\xd6\xe5\x9f\xd7\xf8\x29\xb8\xc6\xda\x22\x3c\x37\x18\x69\x71\x3b\x55\x2d\x8c\xbd\xfb\x92\x53\x42\x0b\x7b\xd9\x8b\xcf\x49\xe7\x56\xe2\x48\x83\xeb\x80\x6a\xd2\x1e\xac\x8f\x8f\xa8\x5c\x2e\xa7\x96\x65\xbd\x3e\xce\x88\xab\xd5\x5e\xb3\xce\xa4\x83\xa8\xc0\x44\x6b\x38\x35\xd7\x9b\x71\xaa\x59\xc9\x88\xed\x59\x82\xe5\x64\xd1\xf4\xb5\x5c\x2e\x98\xf3\x3b\x45\x96\x0a\xf7\xee\x22\x14\x6a\x10\xe9\xc7\x0b\xa2\x4f\xfe\xe8\xa2\x8c\x6a\x83\x15\x37\x0a\xb3\x25\x69\xcf\xe3\x56\x3b\xf8\xc1\x49\xa9\x6f\x01\xc6\xc9\x6b\x89\x57\xa1\x3d\x56\x60\x63\x7c\x32\x60\x8f\xb1\x25\x25\x7e\x15\x49\x32\x0c\x86\xf9\xed\xfe\xca\x84\x9f\x71\xc3\xfc\xcd\xcd\xc4\x58\x36\x6c\x81\x59\x8c\xc5\x6c\xc2\x10\xd5\x9a\x52\xab\x95\x43\xbc\x6b\x9f\x3e\x4b\xb1\x90\xdd\x5c\x10\x2a\x45\xad\x20\xf4\x11\x1b\x55\xc4\x1e\xc7\xec\x00\xa6\xfc\xf3\x46\x71\x64\x42\xf6\x79\x63\x0e\xca\x12\xa9\x75\x56\xf5\xa0\xcd\x96\xe6\xc3\x83\x33\xd7\xae\xa0\x55\xdf\x27\x1b\x8e\xf6\xec\x3e\x74\x33\x90\xdd\x79\x70\xd3\xdc\x9a\xc9\x39\xed\x55\x91\x65\xe1\xb1\xd2\xbe\x59\x7b\xba\x86\x3d\x47\xbb\x3c\x57\x18\x37\x7f\x6c\xd8\xbc\xb5\x79\xa0\xe1\xe0\xac\xc1\xd3\x27\x1e\x05\x25\xdf\x2c\x0d\x4e\x9e\x5c\xb5\x13\x26\x32\x49\xdf\xf5\x9f\x8b\xef\x0a\xb3\x7a\x1b\xe4\xb2\x47\xb3\xeb\xd0\x21\xb3\x40\xdf\x13\x85\xa8\x6a\x19\x5f\x15\x23\xdc\x56\xab\x39\x5c\x51\xa9\x22\x03\x01\xb5\x9a\x36\x13\xe6\xda\x3a\x97\xcf\x67\x87\x4e\xc7\x81\xf0\xaa\x5e\x0b\xa8\x2a\x94\xdc\x55\x84\xc3\xa5\x58\xe9\x85\xc9\x5d\x21\xa6\x16\x6a\xd2\x17\xc9\xeb\xcc\x9c\x78\xe1\x95\xf3\x3a\x45\x6b\xe3\xd1\xc3\xa5\xf9\x8a\xec\x2e\xb0\xd2\x69\x6c\x07\xab\x96\x37\x87\xa5\x7b\xb2\x37\x75\xed\x21\x67\x05\x1f\x6e\x1d\x17\xde\x57\x7b\xaa\x8f\xf2\x28\xc1\x8b\x2e\x35\xf6\x7b\x0b\x09\x9e\x56\x33\x01\xae\x17\x7d\xd1\x7f\xf7\xcc\xa9\xbe\xd4\xb2\xee\x97\x46\xc0\xd5\xf0\x4f\xb6\x8b\x49\x5e\x5f\x03\x1e\x96\x92\x3c\x1c\x2b\x83\x36\xfd\x0f\x91\xbb\x2e\x81\x8d\xf0\xe5\x31\xb9\xdc\x6f\x67\x69\x5a\xa3\x29\x85\x66\x92\xac\x8a\x91\xf0\x30\xc7\x3c\xe1\x70\x45\x5f\x26\xcc\xb8\xd4\x10\x6b\xcc\x81\xbe\xca\x64\xb1\xe8\xa1\xb7\xb2\x17\xd3\x9c\x16\xf5\x36\x9d\x77\x9d\x76\x41\x43\xd3\x85\x66\x21\xfd\xdb\x30\xad\x9d\x89\x18\xcd\xb7\x33\x45\xd4\x0b\x90\x55\x44\x06\x3b\xa0\x55\xe8\xb7\x6f\x7a\xfc\xd9\x9b\x3f\xdb\x77\xf1\x3e\xa6\x5f\x75\xf8\xf3\x46\x31\x9a\x7a\xe2\xe1\x87\x41\xe8\xc1\x42\x13\x93\x98\xd7\x42\x7b\x20\x5e\x87\x3a\xf3\xd8\x5a\x3e\x55\x6f\xd2\x34\x37\x9b\x08\x5b\x2a\xd5\xd2\x5a\xee\xf7\x47\x3d\x1e\x82\x68\xad\x37\x9a\x8d\xe6\x39\x19\xa3\x11\x4b\xb8\xab\xaa\x9c\x73\x32\x55\xe6\x48\x3c\x0e\xa3\x50\xdc\x8e\x21\xc2\x38\xc4\xd3\x9c\x28\xb8\x69\x51\x7d\x89\x77\x10\xf1\x34\x83\x64\xf1\xb3\x19\x83\x94\xe9\x89\x4f\x2a\xa6\x85\xda\x66\xbc\x01\x50\xa8\xaf\x3a\x5b\xa8\x3e\x7f\x55\x6a\x52\xd3\x5f\xb5\xe1\xa1\xf6\xbb\xcb\x63\x6d\x9c\xbe\x33\xdc\x39\x5c\xee\x55\x59\x66\x30\xdd\xa6\x4e\xdb\x86\x3b\x7a\xda\xae\xbb\xa2\x3c\xac\x9e\x6f\xcf\x2d\x91\xcc\xb2\x66\xd7\x7d\x8f\x1e\xde\x81\xb7\xf5\xfc\x8c\x38\x6b\x62\x7e\x72\x09\x6d\x19\xe9\xaf\x98\xa7\xc5\x65\xea\x5d\xda\xca\xe3\xb3\x66\x2f\x69\xfb\xa8\x23\xb0\x0f\xad\xd3\x25\xdb\xec\xcd\x37\x54\x5c\xbb\x6b\xfc\x46\x23\x65\x5b\xd3\xb2\x7d\x3f\x96\xcb\x7d\x08\x20\xe6\x1d\x9b\xf9\xb4\x8b\x20\xbc\x0c\x46\x98\x61\xce\x51\x5b\xa7\xb2\x96\x12\x66\x73\x2d\xe6\xf3\xfa\xbc\x7d\x19\xda\xe7\xf6\x7d\xe4\x23\x34\x84\xcf\x27\x2f\xad\xac\x8c\xf6\x65\x2a\x19\xc6\x68\x84\xa1\xdb\x08\x53\xc2\x39\x19\xab\x42\x2e\x52\x5b\x4e\x5f\x2c\x43\x31\xad\x35\x5c\x2e\x2e\xbb\x54\x5c\x96\xf6\x2a\x37\x41\xec\x02\x3b\x91\xa0\x8b\xf8\x6e\x4e\x7a\x2a\x82\x9e\xcd\xe5\xdb\x4e\x71\xef\xec\x85\xbf\x39\xbb\x60\x9e\xa3\xb0\x14\xba\xd0\xe5\x97\x2e\x5e\x79\x64\xbd\x71\xc3\xd0\xf2\x96\xf6\xd9\x6d\xf5\xdd\xb1\xd5\xcb\xea\xcf\x9c\xd9\xb1\x0a\xfc\x92\x59\x39\xeb\xc6\xfb\x9c\xf7\x47\xb3\xeb\x30\xb3\xeb\xc3\xc6\xc5\x99\xa3\xab\xc6\xc6\x1a\x3a\xab\x56\xfd\xd2\xa4\xde\x39\xb1\x6a\x9f\x09\x9e\x11\x03\xf4\x1f\x6b\xe1\x5a\x20\x86\x73\x98\xf1\x56\xa8\x31\xbf\x93\xe3\x42\x30\xc1\x28\x95\xc9\xc2\x7a\x4c\x5f\x93\x0a\x97\x22\x7e\x73\x23\x4d\xba\xc9\x8f\x48\xb8\x1a\x24\x19\xd3\xc5\x92\xf0\xec\x98\x1d\x30\x3d\x86\xe1\xdd\x5e\xc4\x76\x9e\x1f\x16\x74\xd1\x12\x79\x5d\x51\xd3\x6a\x36\xe1\x38\x9f\xf5\x5c\x9c\x85\x43\x9c\xb7\x38\x29\xa3\x58\x64\x0e\xe5\x5f\x2f\x1b\xf2\xac\xe7\x43\x6f\x2f\x7e\xfc\x59\xf2\xae\x0d\xd9\x53\x34\xbf\x1d\x9e\xa2\x21\x63\x52\xf8\xe3\xc9\x83\x27\x71\xf5\xf9\x9c\xe7\xb3\xfa\x9f\x78\x38\x1c\x9a\x3c\x54\x74\x90\xc0\x67\x6f\x0a\x1b\xc0\x70\x11\xe7\x79\x15\xc4\xaf\x0f\xc3\xdc\xd8\x02\x33\x92\x39\x7c\x0c\x7a\x50\x93\x05\xc3\x58\x13\xc9\x98\x98\xa0\x2a\xe4\xf0\xcd\xcb\x38\x30\x8e\x85\xc8\x95\xfe\x5f\x42\x48\x1e\x80\xd7\xe5\x5d\xc5\xc5\x03\x47\x4d\x4a\xcc\x9b\x89\x1c\x91\x2e\xd2\xb3\x7f\xbb\xbd\xd8\xe6\x8d\xe7\x6e\x41\x39\xf4\x9f\x46\xd2\x7c\x66\xa8\x85\x1f\x1e\xb6\xdc\xd9\x11\xdc\x9b\x35\xf1\xc6\x2d\x08\x79\x83\xce\x96\xa1\x0c\x9f\x1e\xc9\x48\x7e\x00\x40\x1b\xdf\x20\xf6\x78\xce\xe0\x7d\x51\x9b\x5e\xfd\xff\x78\x7b\xf3\xc0\xa8\xaa\xb3\x7f\xfc\x9c\xbb\xce\xbe\x6f\xc9\xcc\x64\x32\x99\xcc\x4c\x92\x49\x32\x49\x26\xc9\x24\x64\x1b\x48\xd8\xc2\x32\xec\x30\x40\x08\x28\x08\x22\xca\xa6\x60\xdd\x40\xc5\x0d\xab\xb8\xb4\x58\x51\x54\x10\x15\xab\x02\xee\xd8\x6a\xdd\x90\x6a\xc1\xe2\x6b\x6b\x6d\xc5\xad\xee\xad\x0b\xb8\xb4\x16\x31\x77\x7e\xe7\x9c\xbb\xcc\x9d\x99\x60\xdf\xf7\x8f\xdf\x17\x9d\x64\x72\xef\xe7\x3c\x67\x7b\xd6\x73\xef\x79\x8e\xbb\x82\x76\xd3\xb5\x75\x16\x87\x03\xf9\xda\x0e\x2f\x8f\x97\x39\x79\x57\x15\x00\xe1\x29\x62\x6a\x76\xd5\x5a\x45\x5e\xbe\xef\x84\xbc\x63\x0a\x1f\xe0\x54\xc8\xb5\x49\xd1\xe5\x96\xd5\x1a\x9e\x42\x8a\x7b\xf0\x99\x9b\x05\x61\xeb\xe8\x79\x25\x2a\x56\x4d\x8d\x33\xb5\xce\x4f\x5f\x37\x65\xee\xf4\x09\x17\xb6\xd7\x4e\x7b\x85\x7e\xe9\x37\xbb\x9e\x12\xde\xbd\xcb\xf4\xab\x28\x61\xd1\x35\xe7\x8f\x19\x0f\xcf\x7d\xa0\xf3\xba\xaf\xaf\x5b\x75\x51\x6b\x55\xcf\xf8\x69\xa2\xac\x3e\x8c\xfa\xb1\x06\xd9\xb3\x20\xee\x47\x79\x30\x68\xa3\x4c\x26\xbb\xc6\x66\xab\xf0\x84\x5c\x7e\xd4\x05\x17\xb4\xa2\x29\xb0\xf2\x7a\x3d\xd2\xe6\x7a\x79\x06\xe2\x92\x5b\x92\x1f\xff\x34\x36\xb8\x8b\x86\x3e\xa1\xf6\x96\x51\x44\x34\xc1\x92\x6b\x34\xef\xbe\xeb\xc9\xf2\x3f\xfd\x46\x5a\x87\x4b\xf6\x39\x0e\x8f\x9c\x57\x2d\xb5\x36\x38\xee\x62\xc6\xf4\xcc\x6f\x9d\xef\x9e\xed\x59\xbb\xfe\xe4\x79\xe2\xfe\x1f\x24\x4b\x9f\x93\xb5\xf7\x59\xa9\xba\x28\x00\x95\x41\x3d\x5e\x30\xe2\x7d\x28\x6c\xe7\x83\x7c\x8d\x35\x16\xa9\x9c\x9c\x89\x98\xcb\x5c\x5e\x14\x9b\x7b\x9d\xf2\x5c\x88\x27\x6a\x28\x9c\x33\x0c\xdb\xc8\x4e\x87\x72\xac\x46\xb1\xef\x51\x70\xcc\xc6\x02\xe5\x98\x8d\x2a\x95\x79\xd1\xfd\x65\xf8\x13\x37\x5e\xec\xcd\x39\x1b\x85\x87\x6f\xc0\xec\x57\x68\x0e\xf6\xa1\x7e\xd5\x81\x73\x52\x6d\x15\x35\x35\xa0\x16\x05\xe3\x26\x87\x1f\x80\xfa\x78\x95\xc6\xe1\xa8\x0f\xd6\xd6\x96\x4f\xce\xd4\xd6\xd2\xd5\xb1\x50\x75\x68\x72\xa6\xaa\xda\x6c\xb4\x5a\x75\xf8\x19\xbe\xbb\x94\x2e\x9d\x92\xe1\x68\xf9\x55\x61\x8f\xfa\xa8\xde\xfc\x7c\xb6\xb2\x49\x51\x65\x8c\x72\x60\xa1\x2f\xd6\x94\x52\x56\x02\x31\xcd\xad\xec\x4f\x32\xf4\x04\xe1\xdf\x1f\xd7\xae\x8e\xe5\x69\xc8\xf6\x5f\x8e\xbf\xfa\xf2\x4f\xe6\xe9\xe0\xe4\x5b\xda\x96\x7b\x70\xd6\xdb\xef\xb5\xc2\x2d\xd0\x08\xe3\x37\x3d\x6c\x32\xab\xf5\xa3\x37\x78\xfa\xdc\xc7\x3a\xe1\x48\xe2\x5d\x36\x0a\xf7\x35\x11\xff\x4a\xca\x2f\x81\xfc\xab\xc5\xe4\xef\x1e\x2a\x4c\x75\x32\xe7\x5a\x78\xba\x06\x1c\x07\xe2\x1e\x0a\x86\xa2\xa9\x0e\x66\x3d\xf2\x9d\x63\xc0\xfb\x78\xd4\x66\x63\x62\x1e\xbc\x1f\xc9\x00\x18\xf9\x8d\xfd\xf6\xb8\x92\x79\xcd\x25\x31\x1b\xf2\x19\x14\x81\x8f\x92\x57\x11\x23\xac\xbc\x13\xb1\x0c\x76\x67\xb6\xcd\x8d\x2d\x29\x27\xdb\x10\x6b\xa7\x24\x98\xde\x51\xbd\x53\x7f\x76\xc6\xd9\xed\x3e\x77\x97\xb7\xc1\x0c\x0d\xb1\xd6\x78\xdd\x88\x66\xbe\x95\xfa\x61\xe5\x9e\x85\x56\xdd\x43\x4b\x43\xe3\x2f\x4b\x57\x74\x37\xf7\xcf\xef\xa8\x49\xce\x18\x53\x3d\x29\xe8\x73\xfb\xfd\x51\x92\x7b\xa8\x97\x8a\x52\x6b\xd8\xed\x44\x9f\x2d\x49\x55\xb3\x1a\xe0\xd2\xb8\x38\xda\xed\x46\x11\x9a\x39\x1c\x71\xf8\xfd\x9c\x4e\x17\x09\xd8\x00\xeb\xe1\x3c\x2e\x8d\x9b\xb7\xb9\x6d\x6e\xba\xc4\x48\xb6\xaf\x73\x34\xc9\xfb\x73\xb0\x49\x7e\x04\x64\x13\x53\xfc\x14\x66\xff\xb1\xb5\xab\x33\x2f\xe0\x8d\xe0\xee\xa4\xbc\xad\x46\xdc\x00\x12\x89\xf2\x49\x7b\x93\xb8\x23\x9c\x3c\xfa\x5a\x10\x6f\x31\xcc\x9d\xf9\x8c\x71\xc3\x85\x3b\xef\xfd\xcb\x83\x37\x46\x5d\x7c\xfc\x7e\xe3\x88\x50\x57\x4d\x77\x45\x67\x15\x6b\xa8\xb2\x8e\xb4\xb7\x9f\xde\xdf\xbb\xfe\xd0\x2b\xef\xbe\x72\xfb\x01\x76\x56\xe7\x9c\x09\x43\x37\xcf\x79\x60\xc2\xe2\xf9\x7b\x26\xce\x47\x73\x21\xed\x61\xb7\x70\xec\x0a\x22\x7f\x1c\xac\xa5\x18\xf6\x46\xe0\x06\xfe\xa7\x80\x1b\x76\x3d\xea\xa4\x01\xd9\x56\x65\x02\x3c\xee\x03\x49\x5a\xd5\x73\xaa\x85\xf8\xd0\xe6\x45\x9a\x25\x26\xd7\xc6\xb3\x5a\xab\x3d\x11\xde\xe8\x0c\x54\x99\x6c\x17\xe9\x2f\xbc\x62\x07\x13\xa9\x71\x8f\x5f\xbf\xdc\x70\x45\xaf\x21\x35\x71\x41\xcf\x10\x47\xf4\x12\xe4\xe1\x1f\xc8\x7e\x9e\xf1\x29\x87\xd5\xe1\x74\x5a\x68\x50\x5a\xca\x30\x5a\x8b\xc5\xeb\xc3\xf9\xf8\xf6\xc3\x8e\xc7\x80\xc3\x41\x5b\xf7\xc3\xee\x47\x4c\x3a\x7e\x3f\xde\x8d\x24\x65\xfb\xca\xcb\x17\xa7\x7e\x9c\x4d\x72\xb1\xaa\xc2\x3e\xf9\xe9\x21\x6c\x9e\xc9\x67\xf4\xce\xeb\xce\xea\x0a\x79\x22\x9c\xc9\xd1\xe9\x35\xad\xd1\xaf\x49\xcf\xe1\xe1\x68\x3e\x45\xad\xa9\xf6\x74\x9e\xbf\x4e\x7f\xd5\x28\xd3\xad\xd3\xba\xe1\xb3\xa6\xaa\x2a\x13\xe1\x4b\x00\x6b\xa8\x4b\x98\xf3\x80\x0f\x69\xa4\xd9\x29\x7b\x45\xc0\x40\xeb\x91\x46\x2a\x2d\x29\x89\x55\x51\x56\x6b\x4d\xcc\x83\xb7\x24\x56\xb8\xdd\xe1\xb0\x73\x3f\xec\x7c\x3c\x60\x30\xf8\xfd\x66\x3c\xeb\x1a\x1a\x90\xf6\x36\x35\x29\x3b\x13\x13\xea\xdc\x6e\xea\x6c\x15\xca\xd1\x44\x3d\xd2\x0e\x54\x29\xb9\x0b\x8a\xec\x68\xd4\x07\x69\xd7\xab\xd3\xb1\x73\xc2\x6c\x1f\xd2\x16\x5d\x25\x13\x67\x3b\x75\xc1\x33\x5a\x76\x4f\xba\x62\xf6\x8a\x80\x6d\xd7\x62\xe7\x91\xc6\x96\xf1\x01\x6d\x6d\x45\xe7\x42\x58\xe3\xdc\x79\xba\xd1\x32\xb8\x7a\x44\x59\xe4\xb7\xcb\x9f\x5f\x96\x6a\x1a\x7a\xe5\xfc\xeb\xe1\xb8\xf6\x87\x13\x91\x51\x5d\x6f\x5d\xb2\x9c\xcc\x73\x2f\x6c\xa4\xb6\xa2\xb1\x77\xe3\xfd\xd2\xc0\xe2\x72\xe1\x2c\xee\xb6\x12\x9d\xc1\xc0\x33\x8c\xa7\xc4\xee\x7a\x06\xb5\xdd\x4a\xb6\x80\x6b\xd1\x2c\x58\x70\x9e\x1d\x39\x8d\x05\xea\x50\x4f\xc1\x96\x40\x25\x2a\x27\x9c\xaa\xda\x05\x28\x6d\xba\x84\xbf\xd8\x38\xf9\x72\xb6\xbb\x85\xff\xb8\x8f\x1e\x55\xdf\x38\xed\xa1\x2b\x93\xfc\xa7\x11\x6a\x69\x6a\xbd\xdd\x27\xee\xf7\x0b\x8e\x77\xc0\xbf\x0d\x01\x73\xf4\x6f\x64\xdc\xcb\xa8\x26\xb8\x81\xbd\x02\x98\x51\x84\x3c\x25\xe5\x70\x59\x2c\x24\xc3\xa8\x11\x18\x0c\x10\x32\x8c\xcf\x5f\x62\xc7\x3b\xec\xb5\x80\xe3\xf0\x3b\xb7\x5a\xbd\xb8\xf5\x8f\x91\xb6\xab\xdb\xc4\x0c\xf4\x3d\x45\x2f\x3c\x88\xa2\xc5\xe3\x36\x21\xce\xc0\xfb\xeb\xf9\x04\x9f\xe7\x36\x54\x84\x3a\x35\x9f\xd7\xcd\xd6\xcf\x0e\x25\xf9\x4f\x6a\xa7\xe8\x1f\x68\xa9\x8a\x36\x37\x47\xab\x5a\xe8\xba\x97\x4c\x55\x27\xbb\x0f\x9a\xa3\x3f\x76\xc3\xa1\xca\x24\xce\x0e\xd0\x86\xc7\xf2\x67\x54\x14\x5e\x83\xc6\xd2\x0a\xc2\x29\x9d\x46\xa7\x63\x29\xca\x66\x67\x79\xdc\x22\x03\xba\xdf\x43\x76\xb9\xa8\x72\x1b\xda\xf3\x87\x88\x37\xc1\x1f\x2e\x65\x46\xf5\xf2\xdf\x4e\xa0\x63\xae\x72\x8d\x63\x12\x15\x5d\xee\x72\xc0\x75\x68\x58\xa6\xfb\xea\x34\x8d\x06\xa7\xe8\x8f\x44\xd1\x98\xec\x46\xf5\xe8\x71\x3d\xc8\x1e\xe2\x1c\xd5\x46\x4e\x9b\x9f\xe4\x40\x5d\x8f\x2a\x0b\xdb\x53\x49\x1e\x06\xf8\x8e\xa9\x49\x9c\x38\x6e\x04\xd3\x88\xf7\x03\x0b\x49\x89\xcd\xc5\x9c\xa3\x70\x23\xb3\x04\x8d\x77\xe0\x49\xc4\xb9\x7a\x3d\x6f\x30\xe1\x0e\x30\x4a\xbe\x3a\x32\xa4\x09\xf1\x85\x11\x3c\x7e\x76\x69\xfc\x60\xcb\x04\xfd\x84\xca\x71\xfc\xe7\x75\x13\x74\x13\x2b\x92\xfc\x5b\xf4\xaa\xee\x43\xa6\x28\x22\xf9\x2c\xd9\x3c\x44\x67\x57\xc1\x18\x7c\x9c\xbd\x0a\x8d\x8f\x1f\x44\x40\x3a\xe5\xb0\x79\x3c\xe5\x95\x1c\x57\x6e\x36\xe1\x24\x83\xe5\xe5\xd1\x2a\x27\xd9\x1e\x47\xb6\xa4\x3e\x06\x82\x41\x33\xe9\x54\x19\xa0\x89\xc0\xf7\x14\xec\x42\x55\xdb\x74\x69\xcf\x36\xb6\xda\x1d\x50\x7a\x4b\x44\x7d\xde\x1c\x6c\x4a\x8a\xe1\x14\xf4\x97\xfe\xf2\xac\xb1\x13\x97\x4d\x9d\x99\x59\xc8\x43\xcb\xe9\xa3\x8d\xd3\x92\x95\x55\xad\x2d\xd5\x95\x49\xa1\xef\x34\xd7\xcc\xea\x86\x32\xf8\xf9\x9c\x65\xed\x89\xd1\x73\xe0\xf7\xce\xe8\xd0\xab\xe3\xe9\x91\x55\x2d\x6d\x61\x34\xcf\x3f\x46\xd7\x44\x03\xd8\x7d\x45\xe3\x34\x15\xc6\xe1\x9d\x24\x67\x4d\x75\x4a\x8f\x33\xfd\x59\x8c\x46\x97\x9b\xa4\x7b\x78\x84\xa3\x75\x8a\x86\x52\x67\x9a\xb4\x8b\xe9\x41\x73\xfe\x1e\xd9\x7a\xfc\x43\x99\xc3\x6a\x0e\x47\x3d\x89\xd6\x05\xcb\xb8\x1b\x5b\xf9\x4f\xee\xe0\xe1\xc1\xfa\xa8\xbe\xef\x4a\xfd\xbc\xd9\x5e\xe4\xca\x22\x3e\xbb\x2c\x44\x72\xf8\xc1\x3a\x54\xe7\x15\xc0\x05\x92\x29\x13\x34\x9b\x5d\x00\xd8\x79\x9b\xcd\xed\xb1\x3b\xf1\xa8\xa1\x36\x20\xf5\x68\xd0\xb0\x4a\xe5\x05\x23\x45\xf2\x46\xe5\x2b\x45\x71\x3b\x39\xb4\x75\x9a\x9c\xf3\xa7\xc7\xea\xdd\x51\x93\xde\xd2\xe7\xd5\xfe\x49\xd3\x7d\x39\x6a\x09\xb5\xcc\x34\x61\xed\x4a\xfd\x95\x7d\xfa\x9f\x27\xab\x4c\xd4\xa7\xd2\xde\x5b\x9c\xcb\x33\x43\x78\xa4\x2e\x65\x34\x03\xa0\xd3\x6a\x2d\xac\xd5\xac\xd3\x19\xf0\x2e\x71\xc4\x29\x4a\x5e\x5c\x6b\x42\x9d\x20\x1d\x2a\xf9\x65\x25\x4d\xac\x59\x31\xa3\xa1\xb9\xae\x6e\xe8\x73\xc2\x90\xb0\x8b\xcf\x50\xab\x34\x4b\x1f\xaa\x32\xc1\xdf\x63\xbe\x24\x79\x50\x61\x1d\xfd\x14\x73\x2e\xf2\x97\x56\xa6\x22\x48\x2b\x55\x87\xf1\x4a\xb7\xcb\xe1\xa0\x7c\xb1\xea\xea\x78\xb0\xd4\xeb\xf5\xfb\x7c\xf5\x71\x4b\x69\x69\x38\x18\x34\x79\x3c\xd1\x10\xde\x66\xef\x47\x83\xd5\x01\x1c\xc0\x87\x46\x84\x57\x29\x60\xc2\x44\x71\x25\xf9\x97\x3a\x7d\x85\x2d\xef\x51\xa2\x7a\x55\x38\x69\xc7\x87\xdd\xf3\x4e\x9c\x01\x82\x7c\xcb\x65\x82\x70\x93\xb3\xac\x91\x7a\xa6\x66\xb4\xd5\x7b\x22\x68\xf4\xbc\x6d\xe6\x89\x74\x4f\x4d\x07\x33\xfe\xa1\xd1\x74\x77\x55\x72\xc6\x43\x73\x9b\xf9\xa3\x70\x63\xff\x12\xe7\xb5\x53\x2e\x65\x27\xd9\x6f\x84\x75\x78\x44\xfb\x66\xc0\x7d\xa1\xb1\x25\xc6\x3a\x61\x31\xbc\x22\x34\xd6\x2d\x54\xc1\x21\x73\xb4\x91\xec\x7c\x16\x26\xad\xba\x04\xf5\x7d\x0c\x8c\xd3\x5f\x22\x39\xc7\xfb\xb8\x03\x65\x10\x80\xff\xd5\x4e\x6e\x6d\x19\x84\xbe\xbc\x7d\xdc\x5d\xf2\x3e\x6e\x6b\xe2\xbf\xee\xe2\x16\xb5\xb7\xfd\x7f\xb1\x8f\x7b\x4f\x52\xdc\xc7\xbd\x01\xef\xe3\xfe\x64\x34\x93\x8a\xb5\x43\x0e\x75\x1a\xef\xe3\x9e\xf1\xd0\x35\x2d\x3c\x92\x90\x56\xd4\x9d\x73\x9b\xe0\x19\x48\x83\x5d\x88\x3a\xab\x8f\xc3\xdb\xf1\x17\x37\xfc\xeb\x8f\x02\x66\x26\x98\x5d\x07\xeb\xa8\x5b\xd1\xfc\x56\x80\xa9\x29\x37\x28\x2f\xa7\xfc\xfe\x4a\x9e\x43\x51\xa2\xc1\xe9\x0c\x55\xa2\x2f\x0c\xe3\xc5\xdb\x4e\x9d\xc8\x09\xe9\x78\xc4\x6a\xd4\xe1\xed\x9b\xe5\xb9\xcd\xe9\x05\x19\xab\x12\x79\x2f\x67\x4b\xb3\x95\xbf\xa2\x2f\xcd\x9c\xf8\x2c\x0e\xde\x31\x9a\x1e\x55\x9b\x98\x63\xbf\xf1\x6c\x69\xfe\xca\x9b\x4c\x8b\xc8\x84\x4d\xb8\x9c\xed\x49\xf2\x48\x1d\x5e\x81\x4c\x92\x60\x5a\x75\x09\x9e\xb5\xf4\x78\xaa\x0a\xcf\xd2\x3a\x87\x4f\xd8\x46\xd4\x1a\x3e\xdb\x1a\xf5\xe1\x28\xea\x43\x04\xf7\x81\xe6\xf9\x4a\xbf\xc7\x53\xe5\xd0\x1b\x0c\x16\xb3\x39\x5a\xa5\x77\x38\xb4\x5a\x17\x66\x4a\x0b\xe2\x66\x6c\x0a\xcc\x88\x29\x43\xe5\xf9\x4c\x69\x2d\xe2\x47\x79\xc5\x97\x68\x0a\xb1\x23\x58\xdb\xaa\x9a\xcf\x39\x15\x85\x42\xcd\x5b\xb0\x8c\x1d\x8f\xbb\xd2\xdf\xc4\x7f\x30\x57\xee\xc0\x14\x1e\x2b\x97\x48\xc4\x93\x80\x75\x03\xb3\x03\x5e\x78\x3b\xee\xcb\x3c\x93\xc4\x6b\xb8\x17\xed\xa1\x72\x51\xd9\x88\x31\xe2\xfb\xc8\x27\x7f\x1f\xc9\xb6\x17\x4c\x4a\x39\x0d\x0c\xcb\xea\x75\x3a\xbf\xc9\x68\xf4\xda\x69\x00\x7c\x7e\x8f\xc3\x8a\xb9\x8a\x01\x06\xd8\xfd\x84\x8e\x65\x81\x91\xa7\xa4\x6d\xd6\x62\xf6\x14\x55\xfe\x94\x84\xfa\x59\x28\x6e\x37\xce\xa0\x97\xc0\xe9\x4c\x69\x59\x0b\x89\xc7\x30\x3e\x81\x8c\xc5\xef\x9b\x3a\xf9\xa7\xf9\x8e\xb9\xf3\x7f\x34\x85\x66\x8d\x2b\x0b\x38\x4b\xb5\x3a\x6d\xb0\xb5\x94\x89\x9b\xaa\x84\x87\x61\x09\xb6\x50\x02\x0d\x1f\x98\xfc\xfb\xbb\x1d\x73\x4b\xf4\xdb\x7e\x09\x68\xd0\x8f\x7c\xd6\xc5\x24\x5f\x8a\x13\x09\x7c\x32\x65\x2f\xb1\xdb\x79\xbe\x2c\x60\xf1\xf9\x90\xac\x58\x11\xef\xb8\xf4\x98\x77\x8c\xc8\x1d\xe8\x51\x6c\x97\x7a\x93\xa9\xbc\xe2\xa8\xe4\xdb\xc2\x2f\xd9\x85\xf0\xb8\xda\x51\x00\x9b\x40\xfe\x16\xb5\x78\xf2\xcd\x4b\x56\x2e\x99\x74\xc3\x92\xbf\x0a\x07\x9b\x5b\x1d\xf7\x9b\x4b\xd7\xc6\x9b\xec\xf7\x6b\xe9\x5f\xaf\x7a\xf8\xf4\xa5\x8b\x57\xef\x3b\x6d\xe8\xab\x73\x56\xcc\xa9\x8d\xc5\xe0\x5f\x16\x2e\x68\xaf\x9e\x2f\xe6\x7d\xf7\xc1\x5a\xba\x97\x9d\x81\xe2\x84\x00\x79\xde\xec\xd7\x05\x4a\xcc\x8c\xc5\xa2\xa5\xcb\x23\x2e\xc6\xe9\x44\xde\xad\x16\xf8\x0c\x86\x68\x08\x54\x61\xab\x11\x7f\x2c\x52\x52\xe2\x42\x0e\x63\xe7\x63\xe5\x81\x00\x36\x20\x3d\x8f\x22\x88\xe4\xea\x5a\x13\xb9\xac\x85\x3d\xaa\xb3\x07\x73\x6f\x12\x8a\x79\x42\x38\x31\x47\x08\x55\x49\x56\x03\xc9\xeb\x0f\x65\x50\x4c\xd3\xe5\x26\x0f\x45\x22\x51\xba\xf7\xd9\x47\x42\x9d\xbc\xf0\x57\xbe\x27\x24\x7c\xff\xd4\x93\x81\x0e\x1e\x56\xf1\xa9\xc0\x35\x97\x0a\xdd\xb3\x4f\xaf\xeb\xdc\x33\x67\x51\xbc\x83\xde\xb2\xfd\x31\x27\xd1\xc1\xbf\x77\x1f\xba\xfd\x49\xeb\x5e\xfc\x75\xaf\x71\x55\xb7\x66\xcf\xcf\x93\xbd\x06\xca\xb1\xeb\xb2\xb6\x3e\x93\x68\x93\xea\xe1\x49\xe4\x17\xb7\x22\xdf\xdd\xd5\x8c\xa7\xa9\xad\x9e\xa6\x39\xae\xc2\xe1\x48\xb6\x55\x98\xdc\x7a\xae\x16\x3b\xc1\x01\x9c\x04\xb9\xf3\x91\x44\x43\x8e\xeb\xe5\xcd\xef\x6a\x5d\x24\xbe\x0a\x61\x97\x96\x13\xdc\x72\xc6\xbc\xa8\x94\x0e\x21\xff\x09\x24\x5e\xfb\x8b\xc1\x5c\x40\xfb\xd1\xe0\x19\x54\xb8\x4a\x6b\xee\x8a\xb6\x77\xb5\x75\x8c\x6f\xbf\x62\xd9\xd8\xf9\x25\x55\xbc\x71\x44\x59\x7d\x73\x57\x72\x4c\xd7\xe6\x8b\xf4\x86\x84\x45\x94\x86\xfa\x05\x33\xcd\xfe\xd7\xd3\xb6\x40\x4b\x75\x20\xe8\xf0\xf4\x37\x0e\xae\xb1\xde\x38\xca\xe2\xa9\x09\x97\x57\xd8\xdc\x7d\x2d\xcb\x7f\xd6\xef\x9e\x25\x4a\x05\xcc\x9e\x81\xe4\xdb\xc6\xde\x84\xe2\x93\x78\xca\x54\xc2\x22\x8f\xcb\xa1\xb7\xdb\xbd\x3e\x1a\xa0\x4e\xd5\x3d\x42\x12\x4c\x2b\x01\x89\xa2\x87\xc4\xbc\xf5\x91\x62\x05\x24\x86\x4b\xf0\xcf\xbc\xce\xd3\xe9\x5d\x67\xbf\xe9\x9c\x24\xd1\x3c\x56\xa4\x79\xd6\xe1\xb0\xa4\xd2\xc3\x82\x91\xe6\x5b\x87\x16\xaf\xbe\x58\x52\x39\xdb\xcf\x5f\x67\xb8\x52\xd4\x35\x0b\x91\x56\x3d\xc6\x7c\x8a\xf4\xe5\xf8\x94\xdb\x55\xe2\x74\x7a\x03\x3a\x9d\xd7\x6b\xb7\x50\x26\x53\xa8\xd2\x82\x14\xa7\xdd\x85\x6d\x81\x1f\x67\xf4\x2b\x30\x7d\x05\x39\x5b\x14\x75\x6f\xcf\x35\x8e\x27\x3a\x5f\x79\xfb\xd9\x29\xf9\xa5\x2f\x25\x91\x6b\x60\xd4\x5b\x7d\x09\xa7\xd9\x74\x13\x3d\x72\x3c\x3f\x6f\xfe\x5c\xd7\x3a\xfd\xba\x51\xf1\x8a\x3a\xb3\xf3\x6c\x18\xc7\x2d\x1d\xb3\x06\x9e\x53\x0e\xd7\x46\xdd\x1b\x37\x76\x0b\x3f\xd7\xb7\xe9\x66\x9c\x7f\x29\x39\xc7\x8d\x0a\x51\x0f\x12\x9d\x12\x02\xeb\x53\xb5\x65\x01\x07\xcd\x22\x1b\x56\x02\x20\xf4\x78\xc2\xe5\x28\xde\xa8\xa8\xc0\xc7\x44\x63\x4b\xe6\x34\x9b\xad\xe5\xc8\xb9\x2f\xb1\x1b\x8d\x8c\xdb\x8a\x83\xaa\x32\x96\xf5\xf9\x88\x31\xcb\xf9\xf5\xa2\x25\x13\x5d\x51\x99\x7b\x86\x3b\x41\xa0\x5d\x8e\xad\x88\xab\xdf\x22\x46\x25\x8a\xc3\x2f\xb9\xfd\x2c\xf6\x84\x10\x1f\x51\xcb\x43\xcd\xfc\x5b\x1b\xfb\x37\xb9\xdb\xf4\x6d\x15\x2d\xdc\xc7\xb1\x87\x2a\x1a\xb8\xf7\x63\x49\xbd\x70\x57\x7d\xa3\xff\x21\x2b\xdd\xf4\x07\x53\x55\x63\x6a\xbd\xed\xca\x9e\xdf\x99\xa3\xdf\xe1\x4f\xcf\xd3\x8e\xdd\x8b\xcd\xe3\xc9\xdc\x94\x53\x51\xea\x0d\x64\xaf\xab\xc0\xcc\x54\x05\x6f\x0a\x95\x9a\x4a\x69\x9f\x3b\x12\xa9\xb1\x19\x70\x2a\xb8\x32\x83\xc1\x58\x6a\x36\x87\x90\x70\x04\x34\x1a\xaf\xf1\xb7\xc4\x43\x91\xe3\x82\x44\xbe\x43\xab\x8a\x0e\x73\x2b\x01\xd2\x2a\xbf\x9c\xd7\x55\x39\xb3\x31\x42\x52\xf9\xcb\x2f\x80\x3a\x38\x38\xe2\x9a\x1b\x6f\xd8\xc4\x9b\x16\x74\x86\xea\xc2\x30\x18\xeb\x9b\xb8\x6e\xf6\xfc\x68\x9d\x15\x06\x1d\x75\xc6\xd1\xd3\x4c\x70\xde\xf2\x17\xa9\xe8\x19\x0b\x96\x5d\x63\x77\x72\x5d\xf7\x3e\xa0\xff\x59\xe6\xa2\xd5\x4b\xe3\xfd\x9a\x07\xee\xed\xe2\x9c\xa6\x65\xfd\x17\xfd\x1c\xf7\x67\x00\xf5\xe7\x4d\xd4\x1f\x9c\xdf\xc6\x6d\xb5\xd9\x3c\x6e\xb7\x57\x6b\x30\x30\x14\x55\xea\x75\xdb\x6c\x5a\x86\x71\x70\xe2\x92\x80\xba\x13\xd6\xa2\x88\x10\xb7\xbc\x25\x59\x74\x76\x1c\x36\x05\x1c\x1c\xfb\x4f\xa6\xad\x93\x87\x4d\xfc\xb8\x36\x66\x59\xdf\x24\x43\xfb\x38\xfe\x08\x3f\xb2\x3d\x42\x45\xef\xaa\x83\x5d\x24\x3c\x79\xd1\xee\x5a\xd4\x3d\x06\xf6\x22\xe5\x62\x14\x9e\xfd\x03\x19\xeb\xb3\x51\xdb\x6e\x22\x79\xbe\x3a\x52\x56\x0f\x67\x2d\x2b\xab\xd4\xea\xf5\x1c\x4e\x17\xe9\x76\x78\x7f\xa7\xe4\xf6\x32\x2a\x6d\x53\xa7\x7d\x17\x99\x43\xb1\xae\xb2\x8f\x23\x2d\xbd\xe6\x52\xec\x99\x28\xd8\xb8\x70\x31\xd7\xd8\xca\x7f\x3c\x86\xee\x1f\x75\x4e\x67\xcc\xeb\xf6\x87\xeb\x4a\x5a\x47\x8c\x19\xd7\x38\x78\x05\x15\x9d\x37\xa7\x2c\x02\xed\xc8\xbd\x39\x2f\xd8\xbf\xf8\xfe\x89\x23\xe2\x86\x59\x37\xd9\xa6\x4d\xea\xbd\x7f\x43\x9f\xf4\x0c\x09\xf9\xca\x6d\xcc\x5a\x60\x03\xcd\x29\xb3\xd9\x04\xa1\x1e\x58\x2c\x38\x4d\x8d\x1d\x9a\x70\x06\x32\x2d\x62\x68\x8b\xec\xce\xf4\xe4\x1f\x46\x45\x4e\x00\x24\xbb\xa6\xc4\xc7\xdb\x49\x72\x32\x0b\xbc\x44\xc9\xd6\x00\x79\x9c\xad\x01\xb9\x28\xd7\xa8\xb2\x35\xc0\xad\x43\xff\xc2\x9e\x09\xcc\xfe\x1b\xd5\x1d\x41\x72\x67\x05\x89\x94\xc9\x42\x69\xb5\x76\x3d\x0f\x6c\x3a\x9a\xe6\x35\x78\x45\x05\xea\xf5\xe6\xdc\xbe\x19\xe5\x54\x5b\xb2\x87\x06\x55\x4d\x27\x15\x46\x93\x1c\x77\x1d\x0b\x67\xa7\xa6\xfb\x43\x31\x3f\x0a\xe3\x84\xfb\x33\x53\x12\xad\xb5\xad\x54\x93\x17\x7e\xe0\x1c\xd8\xed\x17\xca\x7d\x97\xfd\x99\xf4\xd9\x80\xf4\xe5\xd5\xa8\xde\x20\x5e\xcf\xf1\x97\xd8\xcc\x34\xf2\x1d\x1c\x5a\xaf\xcd\x5b\x11\xf2\x21\xb9\x2f\xc5\xb5\xdb\xfd\xfe\xa0\x0d\xaf\xe7\x68\x70\x8a\x2f\xf5\x7a\x4e\xc2\x5a\x78\x60\x1c\x09\xd5\x0b\x57\xcb\x83\x05\xed\xa3\x02\x75\x7c\x13\x56\xef\x6e\x1c\x49\xe9\x84\xe7\x58\x38\xa7\xa0\xb5\x34\x97\x0d\x95\xcf\x14\x23\xab\xd2\x76\x55\xbb\xc5\xb5\x47\x74\x81\xba\x02\xb5\xbb\x14\x71\xd5\xac\x94\xc7\x0f\x80\x15\x3f\xf3\x36\xb0\x41\x37\x8a\x9b\x58\xa4\x5f\xcd\x1a\x8d\xc1\x88\x37\x1e\x19\xfc\x9c\xc5\xc2\x7a\x1d\x48\x7e\x29\x96\x8c\xe1\xc1\x9c\x09\xcb\xeb\x82\x35\xdf\x25\xc5\x6b\x93\x21\x75\xcb\xe5\x87\x52\xa1\x64\x05\x4f\x84\x19\x36\xd4\x35\x5a\x5d\xef\x32\x79\xad\xaf\x6f\xbb\x62\x54\x73\xcb\xc2\x89\x4d\xb3\x07\x36\xc7\xdb\xa8\xa6\x29\x35\x11\xa5\xf9\x13\x67\x35\x47\x46\xf4\xed\x5c\x51\x5e\x56\x2f\xfa\x70\xdf\xc3\x18\xb5\x10\xc9\xad\x1f\xf4\xa6\x4a\x3c\x46\x23\x1a\x7a\xaf\xd9\xe5\x42\x6a\x97\x2e\x33\x19\x3d\x1e\xa7\x1b\xb1\xa0\x13\x4b\x2e\x97\x17\x1d\x90\xb5\x12\xa8\x5e\xc9\x29\xc8\x44\x89\x0f\x43\x53\xb2\x4a\xd3\x44\xd5\x3c\x98\x3c\xcd\xa7\xe9\x9d\x33\xb8\x7a\x62\x67\x1b\xf7\xde\x02\xb1\xc5\xaf\xb1\xc7\x67\xcc\x7d\x19\xc6\x4a\xdc\xf5\xf6\xcb\x57\x4c\x9e\x58\x09\x4d\xa4\xa9\x9f\x5a\x56\x4c\xbd\x76\x0f\xf1\x8f\x4e\xc7\x39\x94\xd8\x9f\xa3\x98\xc5\x8e\xec\x02\xf2\xdd\xdc\x38\x39\xad\xcf\x6f\x2e\x2d\x05\x00\xbf\x96\xc8\x38\x74\x38\xa8\x35\xfc\x17\xdf\x0d\xef\x50\xb3\x92\x07\xc2\xb2\xeb\xa6\x78\x6e\x77\x2c\xbc\xfb\xac\x57\x17\xde\xbd\xec\x35\x61\x7b\x62\x52\xf9\xf3\xee\xa7\x13\x63\x03\xcf\x3b\x99\xcb\xee\x12\xde\xda\x0a\xf9\x7b\xa0\xf7\xce\x1f\xff\xb2\xef\x9e\xeb\x27\x5d\x40\x7d\xb9\xe7\x9e\x4d\x13\x36\x91\x35\x8a\x5a\x66\x2c\xfc\x0f\x7b\x94\x9c\xfd\xe8\x07\x0b\x53\xe6\x52\xbf\xdf\x4c\x6b\xb5\xc8\x2e\x95\x95\x92\xd4\x9d\xce\x27\x32\x5c\xca\x63\x30\x20\xe6\x75\xa6\x2a\x32\x66\x43\xdc\xb0\xc1\xb0\xc5\x70\xa7\xe1\x59\xc3\x7b\x86\xac\x41\x63\x36\x04\x0c\x3d\x86\x41\xc3\x5e\xc3\x11\xc3\x31\x03\x6f\x00\xf1\x81\xd5\x31\x60\xf1\x1c\x28\x3d\xac\x3e\x07\x4f\xda\xd4\xac\x3a\xf4\x91\x55\x7d\x4f\xd0\x2d\x09\xbb\x13\x5e\x57\x97\x1a\x59\x5b\xdb\xd3\x3d\xf4\x9e\xf4\xe5\xe3\xa3\xdf\xf4\xb0\x74\xaa\xae\xae\xbb\xab\xbe\xbe\xe7\x69\xfc\x25\x15\xab\xef\x81\x2b\xc3\xc2\x75\xc1\x61\xdb\xef\xf5\x78\x68\xb3\xd3\xa9\x45\x73\xff\xff\x43\xfb\xe9\x53\xb4\x3f\xd8\x62\x4f\x38\xe9\x33\xeb\xba\x7b\x6a\x6b\x47\xa6\xe0\xef\x71\x33\xd1\x17\xe1\xac\x9e\x6f\x8e\xb2\x74\x4f\x7d\x7d\x57\x4f\x6d\x5d\xea\xe9\x9e\xfa\xda\x1e\xfc\x25\x08\xd7\x86\x85\x1b\xf1\xfb\x5e\x43\xc2\x98\xec\x93\xd9\x27\x51\xbc\xdf\x90\x72\x6a\x22\x11\x1b\xf0\xf9\x5c\x41\xa3\xd1\x15\xa3\x69\x97\xab\xde\x81\x8c\x51\xfc\x70\x8e\x4b\xad\xaa\x50\x89\xc6\x5e\x62\x37\xd5\xd2\x8c\xf3\xc3\xe0\xdf\xc8\xf5\x6a\x91\xf5\xb8\xd3\x51\x46\x89\xbf\xdd\x13\xa6\xcd\xb3\x7b\xec\x26\x9b\xc9\x86\x78\xce\x55\x5f\xd5\x58\xdd\x86\xfe\x36\xdb\xcc\xce\x12\x67\x5a\x18\x43\x45\xc3\x76\x97\x59\xc7\xf1\x5a\xbd\xdd\x6a\x71\xd9\x4c\x5a\xa3\xb5\xd3\x19\x0e\xd9\x4b\x6c\x46\x74\xd1\x68\xb7\x59\x5d\x16\x03\x67\x67\xb1\xac\x09\x1f\x33\x33\xe1\x61\xf6\x52\x64\xc8\x7b\x52\x51\x14\xe8\x39\x81\xc3\x81\x47\x90\xd2\xd2\x38\x1b\xe8\x96\xcc\x06\x92\x20\x9f\xc6\xa7\xfa\xed\x45\x96\xed\x18\xcf\xf2\xe2\x88\x7a\x2c\x07\x06\x17\x0c\xc8\xf9\xe0\xf0\xf6\x67\xc4\xb8\x72\xde\x41\xfc\x1c\x90\xea\x80\xf0\xf1\x35\xf1\xc5\xbd\xe3\x06\x6a\x9e\xe2\xe7\x33\xe7\x55\xcf\x3a\x7d\xfd\x84\xa5\x8c\x10\xad\x6b\x08\xbf\x16\x6b\xbc\x36\xd6\x12\x23\x6d\x78\x9a\x79\x1e\xf6\xb1\x6f\x20\x69\x0e\xa6\x8c\x66\x2e\xc0\xc5\x39\x5a\x4b\x73\x14\x45\xef\x87\x13\x1e\xce\x50\x20\x2e\xd7\x86\x15\x50\xb0\x25\x98\x4c\xc0\xbe\xfb\x85\x20\xbc\xfe\xd9\x0e\xf6\xc1\xcf\x37\xdd\x90\x47\xa3\xe4\x61\x88\x34\xda\x84\x94\x2e\x83\x9f\x52\xc7\x19\x9a\x81\x20\xfe\xea\x40\x0c\x9f\xc2\x13\x6d\x49\xb8\x83\xb0\x4f\x08\xde\xdf\xf1\x3b\xb8\x85\x79\xfe\xf3\xea\xc2\xb2\xf8\xf0\x21\x52\x96\x0d\xb0\x71\x96\x66\x95\xb2\xa1\x28\xaa\xd8\x0d\xfb\x3a\x9e\x15\xd6\xc0\xf7\xee\x67\x9e\xbf\x61\xd3\xe7\x05\x65\x31\x77\x92\xb2\x62\x17\x38\x1a\xc4\x0f\x88\xf5\x22\xd7\x2d\x89\xeb\x5d\xfd\xbb\x8e\xfb\xe1\x7b\xec\xd4\x1b\xaa\xc5\xb2\xcf\xa2\xb2\x6f\x02\x2d\x88\xa5\x5c\xac\x46\x43\x6d\xc9\x90\x6d\x47\x5a\x5a\x43\xa7\x68\x7e\x4b\x06\x22\x0a\x07\xc5\x43\x9f\xf1\x5b\x04\xf8\x79\x3a\x69\x09\x8b\xfb\x11\xc6\x8d\xb9\x4d\x38\xf1\x40\xc7\x6d\x90\x7f\x80\x79\xfe\xbc\xf5\x5f\x56\xa3\x4f\x21\x5d\x0d\xc7\x61\xba\xa8\x49\x88\x2e\x07\x53\x10\xd1\xc5\x23\x52\x4c\x97\x0f\xe3\x66\xb2\x78\x70\x1f\x10\x4e\xdc\xd6\xf1\x00\xe4\x6f\x43\xe3\xfb\xe5\xfa\xf3\xaa\xd1\x07\xe9\x65\x83\x30\x06\xfc\x2b\x7b\x14\xf1\x4a\x30\x65\xb2\xda\xed\x8c\xde\x62\x31\xe9\x00\xcf\xb3\x8c\x78\x6e\x6a\xd3\x61\x62\x7c\xf1\xf3\x2d\x77\x37\xc4\x6f\x7d\x88\x9b\xfb\xe5\xb4\x8f\xd5\xb5\x8b\xaa\xdc\xc1\x1a\xb7\xbb\xd7\x5d\xd9\xc1\x09\x7f\xe3\x3a\x9a\x93\xdc\x07\x17\x57\xc7\x7f\x3b\xce\xa1\xff\xb3\x2e\x1c\xd6\xc1\xb0\x2e\x42\x6c\xc0\xcf\xe8\x2c\xb8\x92\xdd\x03\x34\xc0\xf2\x38\x4d\xa1\x2a\x50\x93\x0f\x4b\xbb\x08\x42\xd1\x96\x64\xc2\xc9\xbb\xaf\xf4\x7e\xf3\x8d\xf7\xca\x2b\xe9\xec\xc6\x7d\x1b\xba\xb7\xdd\x8a\x6d\xa0\x70\xbd\x30\x06\xae\xc9\xfe\x0b\x95\xb3\x02\x7f\xca\xc0\xb1\xd0\x60\xd5\x41\xc6\x6c\xd6\x30\x98\x40\xdc\xd6\x8e\x53\x65\x8a\xc9\xfe\xf0\x28\x3a\xf9\x10\x74\x63\x6a\x88\xa8\x70\xfd\x95\x84\x24\x5c\x7b\xeb\xb6\xee\x0d\xfb\x36\x0a\x9b\xc4\xdf\xb0\x5f\xbc\x8e\x73\x28\x6d\x15\xfa\x59\x8a\x1d\x67\x8b\x80\x4a\x00\x2c\x3c\xf5\x29\xb5\x5d\x7a\xf7\xaa\x9f\x3e\x42\x1f\x40\xd7\xfb\xa4\xeb\x73\x48\xce\xa5\x2f\xb3\x3f\xb0\x3a\xee\x1b\x74\x3d\x8c\x5f\xd1\xa6\x6e\x83\xbb\xe0\x64\xa0\x79\x94\xae\x67\x23\x20\xd6\x42\xca\x7a\x49\xbe\xa1\x5d\x08\x33\x9a\x94\xbd\x0d\xce\x10\xcb\x0a\x2b\x59\x1d\xdb\x25\x96\x45\xd7\x3f\xa6\xb6\x88\x78\x61\x25\xde\xb7\xa4\xe0\x3f\x86\xaf\x49\xf8\x63\x79\xf8\x2d\xf0\x41\x09\x7f\x2c\x0f\xbf\x05\x3f\xad\xc4\x79\xe8\x85\x29\xec\x99\xdc\x3b\xe8\x3a\x1a\x73\x4b\x14\xac\x83\xdf\xc1\xc9\x56\x1e\x5c\x00\x8f\xa0\xb1\xd4\x3c\x0a\x2b\x73\x6d\x2c\x13\xa6\xd0\x07\xd9\x2d\x08\x3b\x46\xc4\x82\x0f\x30\x2d\x70\x01\xb8\x81\xd4\xfd\x75\xf6\x47\xf6\x16\xd2\xcf\xa8\xd4\xcf\xfd\xa4\x9f\x54\x30\x47\x03\xe7\x13\x2a\x21\xfd\x1c\x8b\xca\x72\xd4\x6d\xf7\x89\xb9\xaa\xbe\x46\xfd\xbc\x85\xb4\x3b\x2a\xf5\xf3\x29\x69\x4c\x57\xe2\x3d\x4a\x12\x1e\xf7\xf3\xcf\x12\xfe\x58\x1e\x7e\x0b\x7c\x5f\xc2\x1f\xcb\xc3\x4b\xfd\xcc\x7e\x3d\xf4\xaf\x3c\xfc\x67\x34\x14\xf1\x43\xff\xca\xc3\x7f\x46\xcd\x92\xe8\xf7\xe7\xe1\x8f\xd1\x41\x79\x8e\xf3\xf0\xc7\x28\xa9\xef\x00\x30\x27\xf8\x20\xba\x5e\x85\xfb\xae\x7d\x81\x46\x74\x80\xee\x31\x0a\x86\x49\xe7\x5b\x50\xd9\x86\xec\x17\xf4\x1d\xdc\x79\x08\x33\x0e\x8f\x1f\x75\x2d\xd8\x92\xfd\x10\x8d\x5f\x2f\x18\x04\x9f\x0c\x43\xe3\xc5\x53\xd0\xd8\x31\x0c\x8d\x75\xe0\x19\x91\x06\x6a\xdf\x09\xd2\xee\x2a\xa9\xdd\x2e\xd2\x6e\x0d\xe2\xcd\x85\xf4\x4b\x52\x39\xdc\xee\x19\x52\x3f\x97\xe6\xe1\xbf\xa1\x3e\x22\xd7\xff\x2d\x2c\xcd\xc3\x7f\x43\x79\x25\xfc\x14\xe6\x04\x77\xcc\x22\xe2\xa3\x88\x4f\x7e\x45\xe6\x7a\x1b\x5c\x21\xce\x75\x3c\x37\xd7\x0d\x88\x5f\xb6\xb3\x3b\xe4\xb6\x22\x3e\x79\x81\xd0\xda\x06\xae\x26\xb4\x04\x00\xd8\x66\xc2\x2f\xd5\x12\xbf\xac\x23\x34\x60\x45\x8e\x06\xde\x97\x35\x83\xc7\xed\x1b\x2f\x62\xc0\xdb\xf0\x56\x8c\x09\x52\x0a\x66\x4c\xf6\x0b\x76\x1f\x77\x3a\xc2\xd4\x10\xcc\xb5\x94\x46\xa4\x93\xe3\x5d\x31\xe7\x00\xeb\x44\x98\x7e\x11\x03\x1e\x23\xfc\x4d\xc5\xad\x0a\x06\x8d\x3f\x77\x36\x69\x4f\x4c\xac\x8b\x62\x45\x3a\xe1\x5c\x7b\x50\xaf\x19\x23\xf7\x23\xc2\x4c\x90\xda\xdc\x07\xe7\x10\x0c\x95\xa3\x23\xac\xe4\xce\x26\x63\x1a\x93\x78\xf9\x03\xb1\x2c\xe2\x65\x23\xe1\x9d\x09\xd2\x75\x93\xaa\xde\xdd\x72\xbd\x60\x39\x05\x50\xbd\x78\xde\xab\x94\x79\xc7\xf5\x86\xb8\x6f\xe5\x7a\xc1\x72\x58\x8b\xc6\x81\x60\x28\x09\x83\xe7\x46\x55\x2f\x07\x2e\x38\x53\x94\xad\x47\xd1\x9c\xe5\xea\x45\xd7\x3f\x97\x65\xae\x3f\xaf\x9d\xc7\xe9\x72\xa9\x9d\xfd\x79\xed\x3c\x4e\x35\x10\xfc\x06\xc4\x13\xb3\x09\xbe\x56\xe4\x09\xb8\x8b\x5c\x6f\x17\x96\x52\x0d\x04\x3f\x51\xba\xbe\x80\x5c\xff\x02\x39\x73\xb3\xf9\x72\x11\x8f\xf8\x39\x4e\xa1\xc0\x00\x18\x90\x2e\x87\x1e\xb1\x63\xe2\x98\xc6\x91\xd2\x3e\xc9\xdd\x8c\x70\xdf\xa2\xf2\x11\xb0\x7c\xdf\xb3\x56\xcc\xd1\x6e\xc8\x00\xd3\x93\x14\xb4\xa5\xac\xf6\x71\x36\x60\x8d\xb5\x28\xf3\xc4\xbe\x4c\x74\x56\x3d\x19\x8b\x75\xf0\x9f\xe2\x3c\x05\x72\xf3\xe4\x43\x75\x1f\xe7\xa3\x08\x33\x59\xc4\x80\x3f\x23\x4e\x45\x98\x92\xbc\x79\x62\x5f\x26\xfd\xa9\x97\xe6\xe3\x35\xb1\x2c\xd2\xad\xc7\x49\x7f\x26\x4b\x3a\x47\xd2\x21\xc2\xf1\x3c\xfc\xb7\x74\x8d\x84\x3f\x9e\x87\xff\x96\x9a\x2c\xd3\x67\xae\x22\xf8\xb8\x44\x7f\x05\xb9\xfe\x83\xb0\x12\xef\xb5\x42\xd7\xd3\xe2\x75\xf0\x51\x0e\x4f\xf8\x38\x2e\xca\x36\x1c\x8b\x75\xb1\x58\x0e\xb7\xdd\x9a\xe3\x67\x44\x83\x76\x70\x0f\x49\x34\xb0\x1e\x60\xe1\xaf\xac\x12\x2d\x8c\xd5\xa8\xfb\x79\x3c\xaf\x1d\xdf\x52\xbf\x21\xd7\x97\x0b\xc7\xf3\xda\xf1\x2d\x9c\x28\xf3\x45\x1e\xfe\x98\xa4\x13\xba\x84\xfe\x3c\xfc\x31\x78\x0d\xb9\xfe\x31\x00\xfc\x2c\x32\x1f\x0d\xe2\x58\x53\x0f\x89\xf3\x51\x96\x9b\x0f\xa4\x45\xd9\x37\x89\xed\x98\x22\x61\x46\x88\xed\x6c\xc8\xc9\x9f\x48\xe7\x1b\x99\x0e\x92\xbf\x39\x45\xfa\x40\xa4\xb3\x4b\xa6\x83\xe4\xef\x8f\x22\x9d\x66\x15\x1d\x61\x25\x3f\x8b\xb4\xbf\x41\x1a\xf7\xef\xc4\xb2\x68\xbe\xdf\x24\x3a\x6d\x8a\x74\xfd\x33\xd1\x66\x22\xf9\x63\x48\xbd\x8d\x12\xcd\x43\x62\xbd\xfe\x5c\xbd\x68\xa6\x19\x33\xa9\x77\xaa\xa4\x87\xfe\x21\xd6\x1b\xca\xd5\x8b\x6c\x35\xc7\x90\x7a\x1b\x25\xfa\xbf\x16\xcb\xa2\x79\x35\x93\x7a\xa7\x4a\xd7\x19\x09\x7f\x3c\x0f\xff\x2d\xf5\xb9\x84\x3f\x9e\x87\xff\x96\x9a\x2b\xe1\xfb\xf3\xf0\xc7\xe8\x80\x84\xef\xcf\xc3\x1f\xa3\xee\x22\xd7\xfb\x91\x5e\xbc\x8e\xd8\x93\x26\x22\x7f\x07\xe8\x87\x89\x3d\xa1\xa9\xa8\xa2\x57\xca\x91\x3d\xf9\x27\xf7\x21\xc2\x4c\x23\x7c\x74\x07\x78\x38\xfb\x12\x91\x29\x0a\x79\x20\x48\xbf\x1c\xf1\x42\x2f\xb0\x0e\xb4\x28\xf4\xca\x15\x7a\x2f\xd1\xf8\x05\x5a\xc3\xe3\x8c\x42\x50\x1c\x2b\x4c\xf3\x2d\xee\x4a\x15\xcd\xed\x84\xe6\x72\xf0\x21\x8a\x86\x63\x29\x1f\x43\x6f\x69\x84\x8d\x29\x60\x1f\xd7\x48\x3d\xe7\x85\x1b\xbd\x70\x95\x17\x02\x2f\x94\xea\x5a\x8d\xfe\xb5\x58\x63\x03\x98\xdc\x70\xfd\x78\x81\x7e\x74\xd8\x7e\xfc\x86\x5b\xa7\xd4\x79\x2d\x78\x40\xb2\xad\x97\x82\x4f\x87\xa1\xf1\xe2\xff\x81\xc6\x3a\xf0\x0a\xa6\x81\xad\x11\x73\x9c\xf0\x79\x42\xd2\x3b\xa7\x8b\x36\x2f\xa7\x77\xc4\xbd\x6b\x84\xcf\xa7\x4b\x7a\xe7\x0d\xd1\xce\xd4\xe4\xf8\x44\xa4\xf3\x8d\x4c\x07\xf1\xdb\x46\x91\x4e\xa8\x90\xce\x2e\x99\x0e\xe2\xb7\x27\x44\x3a\xf5\x39\x3a\x43\x48\x16\x34\x84\x4e\x8b\x44\x67\x9b\x48\xa7\x2a\x8f\x6f\xe9\x5a\x42\x67\x26\xc2\x20\x7f\x6b\x0a\xe1\x5a\x2f\xa1\x82\x69\x20\x99\xd0\x10\x9e\x6a\x91\x78\xf3\x3e\x42\xfb\x3b\xa4\x5f\x6a\x09\x4f\xcd\x94\x74\xd4\xbb\x62\x9d\x18\x4f\x74\x54\x0b\x19\x23\x82\xc7\xf6\x14\xde\x50\xe8\xd3\x12\x1a\x33\x88\xcd\x9d\x29\x62\x31\x0d\xe4\xf3\x5d\x3b\x1a\x48\xb4\x8e\xe7\xd5\xfd\x2d\xf5\x1f\x72\x7d\x0f\xd2\xa7\xea\xba\xbf\x85\xc4\xc7\x02\x61\xe4\x3b\xfa\x49\x7f\x5b\xa5\xfe\x9a\x44\x39\x6d\xc9\xd5\xf9\xaf\xec\x17\xd4\xbb\xa4\xbf\xb3\xc4\xfe\x86\x48\x7f\x9b\xa4\xfe\x82\x30\x92\x45\x3f\x3b\x51\xa4\x41\xfa\x6b\x15\xcb\x21\x9d\xfc\x2e\xa9\x73\x96\xa4\xf3\x17\x2b\x75\x8e\x25\x3c\x4f\xea\xd4\x1e\xa4\x8e\x4b\x3e\x59\x97\xcc\x37\xb8\x4e\xba\x86\xbd\x5d\xaa\x13\x61\xe0\x9f\x84\x8b\x08\x66\x84\x55\xe6\x2d\x4c\xa7\x5a\x45\xe7\xf7\xd4\x57\x12\x9d\x78\x1e\x9d\x5a\xf6\x3b\x85\xce\xef\xe1\xd7\xc2\x9f\x09\xa6\x36\x47\x07\xb7\x5f\x1e\x03\x34\xa6\x64\x0c\xac\x52\x3f\x0a\xc7\x02\xf7\x49\x1e\x0b\x4b\x04\x8f\x85\xdc\x33\xd2\xb7\x5f\x22\xfe\x89\x10\x5a\x49\x69\x3c\x67\x14\xd9\xd1\x6e\x9c\x8f\x8b\x9b\x8f\x30\xb3\xc5\xb8\x04\x71\xdd\x7e\x5c\x16\xf1\x41\x84\xcc\x5d\x52\x1a\xc7\x6e\x11\x8f\xea\x5c\xc1\x5c\xaa\xe0\x3f\x86\x8d\x62\x5d\x68\xae\xd5\xf8\x6f\xa9\xeb\x49\x1b\x6f\x41\x36\x48\x8d\xff\x16\xfe\x8c\xe0\x37\x21\xff\x5b\x8d\x3f\x26\xda\xe6\xec\x0a\x64\x83\xd4\xf8\x63\x70\x3f\xc1\xdf\x27\xac\xe7\x02\x04\xdf\x46\xae\x7f\x22\xf9\x32\x13\x84\xf5\x4c\x03\xfd\x20\xba\x3e\x47\xbc\x8e\x8f\xba\x24\xf8\xa5\x79\xf8\x6f\x24\x5b\x3e\x01\xf9\xc3\x6a\xfc\x37\xd4\x66\x09\xdf\x9f\x87\x3f\x46\x4f\x93\xf0\xfd\x79\xf8\x63\xd4\x93\x22\x3e\xfb\x25\x17\x20\xfa\xa6\x4d\xd2\xbd\xdf\x4a\xf3\x1d\x51\xf4\xcd\x84\xec\x67\xcc\x48\xa2\x7b\xe7\x48\x7a\xf2\xad\xec\x4b\x58\xdf\xc0\x01\x38\x43\xa1\x51\xae\xd0\x78\x99\x3e\x42\xf4\x2d\xf2\x9f\xda\xd4\xfa\x16\xd3\x69\xe0\x4c\x32\x1d\xa4\x67\x4f\x80\xc7\x88\x8f\x7b\x34\x7b\x04\x04\x52\x76\xfa\xae\x26\x78\x43\x13\x6c\xa2\xe0\x91\x52\x58\x9a\xd2\x5a\xc6\x95\x22\x6f\x6a\x75\x4b\x8b\x75\x60\x40\xd2\xb1\xe7\x67\xff\xce\xfe\x9d\x7b\x1e\xd1\x68\x27\xbc\x70\x07\xbc\x4b\xe4\x05\x73\x8e\x17\xec\x88\x3f\x1f\x63\xd7\x22\x4c\x86\xc8\xd6\x1d\x17\x12\x8e\x73\xca\xb2\x75\x3e\xe2\x89\xbf\x93\x31\x6a\x97\x78\xe2\x02\xb1\x1c\xd2\x03\x77\xd2\x0f\x89\xe5\x08\x4f\x5c\x47\xae\x5f\x97\xfd\x3b\xff\x4b\xa2\x4f\x47\x10\x5d\xd9\x4b\xec\xbd\xf3\x31\xe8\x64\x23\x70\x7f\xf6\x87\xc7\x5c\x25\x9c\x2d\x0c\x51\xed\xe8\x7f\xac\x4f\x90\x0e\x4f\x13\xdd\x3a\xf7\x1b\x82\x27\x2f\x0c\xd9\x53\x7a\x58\x6a\x8d\xc0\x2e\x6f\x99\x85\x97\xd1\xc3\xd2\x5f\x47\x3d\x82\xe8\x63\x3c\xae\xe0\x46\xa7\x27\x47\x1d\x0c\x47\x7f\x1d\x8e\x9d\x15\xfa\x27\x4b\xfd\xc3\xd2\xdf\xad\xd0\x5f\x4e\x5d\x86\xe8\xbb\x53\x46\x0a\x57\x40\xc1\xee\xca\x32\xb1\x06\x5c\x24\xaf\x8e\xb9\x4a\x1d\xcb\xe1\x24\x74\x83\x94\x41\x95\x50\xf0\xfc\xea\x90\x58\x4b\xae\x8c\x54\xcf\x37\x72\x3d\xc8\x2f\xda\x5d\xe4\x5f\x51\x88\xee\x00\x91\xf5\xb9\x92\x2c\x2f\x2b\xf4\x4f\xc0\x75\xc8\x2f\xfa\x25\x99\x9f\x11\xe2\x3c\xd0\x37\x89\x65\xd1\xbc\x0d\x10\x1e\x9e\x2b\xcd\x1b\x99\x9f\xec\x61\xa4\x1f\x36\x92\x7a\x3b\x24\x9a\x37\x16\xc6\x43\xd9\x4f\x91\x7d\xf9\x23\xa9\x77\x9e\x64\xa7\x76\x8b\xf5\xaa\xe2\x2a\x91\xce\x6e\x99\x0e\xea\xf3\x55\x85\xf1\x8d\x44\x67\xae\x4c\x07\xf1\xf0\x2f\x24\x79\x69\x52\x74\xdf\x99\x4a\x7b\x3a\xa5\xf6\x5c\x5a\x38\x0e\xd9\x84\x30\x86\xbe\x99\xb4\x67\xbe\xd4\x9e\xcb\xc4\xf6\xd4\xe6\xda\x73\x12\xd9\xdf\xbd\x84\x4e\x17\xc1\x5c\x0d\xeb\x45\x3a\xbe\x1c\x1d\x9c\x93\xaf\x83\xd0\x19\x20\xbc\x7e\x75\x27\xa1\xe2\x93\xed\xe6\x49\xa4\x87\xf7\x92\xb1\xec\x92\xc6\x4c\x5c\x37\x38\x88\x78\xdd\x49\xc6\x72\x40\xe2\xf5\xf3\xc4\x3a\x91\x4f\xa7\xc6\x7f\x8b\xa4\x53\xc4\x1f\xcf\xc3\x7f\x0b\xef\x97\x62\xb0\xe3\x79\x31\xd8\xb7\xd4\x7c\x45\x1f\x7f\xc4\x7e\x22\xeb\x3f\xb0\x1c\x79\xaf\x3f\x57\xe6\xff\x90\x32\xff\xb7\xc3\x84\x34\x7e\xa5\xf2\xf8\x49\x63\x73\x48\x1a\x1b\x8e\xba\x7d\xb5\x88\x10\x59\x44\x5e\x9f\xf9\x9c\x3e\x42\x30\x7d\x84\xce\x46\xf0\x49\xa1\xff\x22\xc5\xe4\x9d\xb6\x08\x1c\x29\x8d\xf1\xeb\xf9\xb1\x15\xde\x47\x9b\xfd\x17\xbb\x8b\x9d\x4a\xf2\xa9\x78\x28\x7d\x88\x2e\x77\xba\x5c\xa5\x25\xe6\xf2\x72\x6d\xa4\x24\x52\x5d\x13\x32\xe8\x0d\xfa\xfd\xd0\x95\xf2\x65\xcc\x06\xa8\xa7\x0d\x06\x3f\xf0\xdb\x16\x66\xfc\x8c\xbb\x64\x30\xe3\xb6\x01\x6e\x61\x06\xd8\x87\xcb\x45\x25\x6e\xa4\xca\x7f\x32\x25\xa5\xcf\x8e\x26\xa5\xb7\x2d\x82\x49\xf9\x94\x42\x9e\xec\xde\x6f\x05\xc1\x26\xe5\x00\x5a\x86\xee\x7e\x62\x99\x65\xec\x19\x9d\xbf\x7a\x5c\xd8\xe6\xb8\xf7\xa9\x0b\x16\x9d\x7f\x5f\x60\x87\x50\x6f\xdc\xb7\x29\x06\x27\x43\xdd\x17\xd0\xf8\xe8\x2f\x6e\xfe\xb5\xf0\x94\x3e\x39\xe0\x36\xdf\xb3\xe9\xdb\xf3\x77\x5c\x35\xef\xcc\xbb\xf7\xfc\x78\x4e\x7f\x29\xf5\xcf\x13\x50\x77\xcf\xf5\x97\x3d\xe1\x33\xdf\x7b\xc5\xd3\xef\x89\x32\xbd\x15\xc9\x8f\x7a\x3d\xf0\x63\xaa\x4b\x5e\xbb\xca\x5b\x0f\xfc\x18\x7e\x2a\xe2\x11\x1f\x53\xdc\xeb\x22\x1e\xe9\xf5\x1f\xe8\x29\xa2\xdf\xe6\x57\xaf\x93\xe1\x79\x58\x2a\xcf\x83\xf6\x07\x6a\x7b\xf6\xc3\x02\x3f\x12\xd3\xa9\xe1\x4b\x14\x3a\x3f\xd2\x31\x22\x57\xb4\xb4\xe0\xd6\x22\xd2\x61\x96\xe6\xe6\x53\xfb\x23\xb5\x4c\xf2\x7b\xeb\x15\xbe\x20\xed\x51\xd1\x19\xa2\xeb\x86\xa3\xa3\xe6\x0b\xed\x10\x75\xda\x29\xe8\x94\x2a\x74\x04\x85\x8e\x37\xaf\x3d\x65\xec\x61\x85\x8e\xa0\xd0\xa9\x2a\xa0\xe3\x56\xe8\x64\x11\x9d\x68\x31\x1d\xd4\x9e\xe3\x0a\x9d\xec\x70\x74\xf0\xbc\x10\x39\xaf\x24\xf6\xf5\x6a\x78\xb6\xe4\x2b\x75\x89\x3c\xed\x55\x8d\x37\x9e\x2b\x22\xef\x7d\x22\x16\x3c\x57\x3c\x67\xb9\x31\xd2\x01\xa5\x6f\x25\xa7\x1a\x23\x1d\x50\xc6\x3a\x72\xaa\xb1\xd6\xc1\xff\x05\x1d\x78\x4a\x3a\xca\x58\xeb\x28\x85\x4e\xa4\x80\x8e\x32\xd6\x3a\x4a\xa1\x93\x28\xa0\x53\xae\xd0\xa1\x11\x9d\x06\x82\xa9\x3e\xd5\x58\xeb\x68\x85\x4e\x6b\xc1\x58\x1f\x53\xc6\x7a\x1b\x5c\x99\x3f\xd6\xf6\xc2\xb1\xbe\xdc\x22\x8f\xf5\x36\x70\x63\xf6\x03\xd5\x58\xe3\x75\x10\xf5\x9a\xe4\xc7\x08\x21\xae\x27\xae\xcc\x5b\x93\xfc\x18\xbe\x94\x5b\x7b\x25\xf2\x54\x25\xc9\xd3\x34\x51\x9f\x47\x54\x6b\x91\xc8\x77\x59\xc8\x6e\x12\xcb\x12\x79\x3a\x4d\x6c\x57\x6d\xde\xfa\x1f\xa2\xf3\xbc\x4c\x07\xf9\x40\x57\x14\xda\x05\x42\xe7\x08\xf1\x81\xc6\x89\x18\xb0\x55\xa4\x53\x91\x47\x87\xad\x25\x73\x5c\x25\xc9\x65\x9d\x64\xef\x6a\xd4\xeb\xb8\x92\x5c\x8e\x2b\x90\xcb\x06\x65\x4c\xc5\xf5\xe0\x1c\x9d\xa1\xe1\xe9\xd0\x17\xab\xe8\x0c\x9d\x92\x4e\xa9\x42\x47\x50\xe8\x54\xe6\xb5\xa7\x92\xf0\xca\x38\x49\x2e\x65\x3a\x35\x05\x74\xba\x15\x3a\xd9\xe1\xe9\xd0\x0f\x13\x5e\x19\x27\xc9\xe5\x30\x74\xf0\xfc\x12\xb9\xac\x92\xe4\xf2\x1a\x89\x57\xb6\x15\x3d\x73\xc0\x73\x7e\x23\x91\xcb\x71\x92\x5c\xde\x94\x37\xf7\x64\x8d\x91\xcc\x7d\xad\x34\xaf\x93\xc4\x39\x73\xe5\x68\xe0\xf5\xc5\xb1\xec\x19\x16\xb2\xbe\x88\x31\x70\x4b\xf6\x03\xe0\x48\x99\x7d\x29\xbb\x7d\x9c\x2f\x65\xb1\xa0\x1f\x06\xc3\xb8\x58\x2c\x26\xd2\x44\x75\xaa\xd7\x39\x3f\x86\xe2\xfa\x4b\x16\xc5\x36\xea\x75\xce\x8f\xf1\x1a\x10\x5e\x5b\x40\xbc\x7f\x1d\x89\x29\x9b\x24\x7e\x15\x9f\x07\x95\x23\x3a\xbf\x21\xfc\x3a\x4d\xa2\xf3\x42\x6e\x3d\x83\xb4\xb9\x49\xe2\xd7\x1b\x8a\xe2\x76\xb2\x16\x41\xf8\x75\x9a\xd4\xaf\x9d\x22\x9f\x85\x73\x76\x18\xd3\xb9\x85\xf0\x47\x93\xc4\x67\xbf\x92\x74\x40\xad\x7a\x4d\x83\x39\x97\xf0\xc7\x34\x89\xcf\xce\x93\xe6\xa3\x5a\xf1\xab\xc4\xb5\x91\x1c\x9d\xa1\xe1\xe9\xa0\xf6\xe4\xe8\x0c\x9d\x92\x4e\xa9\x42\x47\x50\xe8\x44\xf2\xda\xd3\x48\xf8\x6c\x9a\xc4\x67\x32\x9d\x50\x01\x1d\xb7\x42\x27\x8b\xe8\x44\x8b\xe9\xd0\xbf\x23\x7c\x36\x4d\xe2\xb3\x61\xe8\xe0\x79\x21\x7c\xd6\x24\xf1\xd9\x2b\x12\x9f\x6d\x17\xc7\x52\xc5\x67\x64\xae\x08\x9f\x4d\x93\xf8\xec\xfe\xc2\x39\xe3\xae\xc2\xb1\x04\x3c\x4d\x5a\xfb\xf9\x5c\x9c\xb3\x96\xbc\x39\x63\xf6\xe1\xf8\x01\x9e\x4e\x7c\xb3\x75\xe0\xaf\xc3\x96\xed\x85\x17\xfd\x97\xb2\x1c\xe8\x3d\x0b\xa8\xca\xbe\x2e\x97\xcd\xf1\xca\x88\xc2\xb2\x9b\xe4\x7a\x45\x5e\x51\xca\x3e\x2f\x97\x45\xfa\xec\x55\xb1\x6c\x43\x61\xd9\xb5\x72\x59\xa4\xcf\x76\xca\x3c\xcd\x5d\xc5\xbe\x2a\x96\xcd\xe7\x69\x66\x1f\x73\xb5\x82\x97\xc7\xe7\x3e\x84\x57\xc7\xc7\x1f\x53\x7f\x93\xe2\xe3\x95\x79\xf1\xf1\xc7\x94\x36\x17\x1f\x13\x19\x68\x93\xfa\x75\x58\x94\xdb\x68\xae\x6d\x24\xae\x25\x32\x30\x47\x92\x81\x7b\x25\xfd\x90\x93\x01\x4c\xe7\x19\x32\xb6\xab\xa5\x18\xaf\x5c\xa4\xd3\x94\x47\x87\x1d\x4b\xc6\x76\x8d\x34\x2f\x3f\x0c\x5b\xb6\x17\xde\xf1\x5f\xcb\xf6\x82\x67\x55\x65\x5f\x97\xcb\xe6\xda\xdf\x5a\x58\x76\x93\x5c\x56\x6c\xbf\x52\xf6\x79\xb9\x2c\x9a\x97\x0f\xc4\xb2\x75\x85\x65\xd7\xca\x65\xd1\xbc\xfc\x43\x19\xe7\x67\xc8\xbc\xac\x2e\x1c\x67\x76\x2c\x99\x97\x35\x79\xe3\x2c\xc6\x4c\xef\xc8\x31\x13\xea\xe3\x68\x55\x0c\x4c\xbb\x4a\x34\xd6\xbc\x18\x58\x8c\x11\xb6\xc8\x31\x02\xe8\x75\x88\x11\x30\x92\x2a\x78\x7a\x65\x54\x07\x72\xf1\x38\x38\x13\xd5\xb9\x91\xcc\x79\xa7\x54\xe7\x84\x1c\x0d\x32\xe7\xf3\xa5\xeb\x7b\x55\x6d\x79\x5d\x6e\x0b\x1a\xb3\x70\xe1\x7a\x93\x54\xff\x26\x39\x7e\x43\x63\x16\x14\xe7\xbc\x2e\x37\xe7\x22\x9d\xe7\x95\x38\xf0\x0e\x78\x8b\x48\xc7\x99\x4f\xe7\x49\x62\xa7\xc5\x58\xe7\x8e\x4b\x54\xd1\x70\x16\x3f\x6f\xff\x9c\xb9\x8a\xdd\x66\x8b\xd0\x84\x8f\xf9\x9b\xa4\xe7\xe1\x79\xd7\xad\x3c\x7f\x18\x1c\x10\x75\x45\xb5\x55\xf5\xac\x1e\x63\xee\x55\xca\xee\x90\xf8\x29\xef\x3a\x2a\xbb\x07\xbc\x2c\xe9\xa4\xb8\xa2\x93\x0a\x31\x3b\x21\x23\x61\xba\x4e\x89\xd9\x0b\x4e\x0c\x4f\x87\xdb\xa3\x60\xee\x56\xea\x9a\x7c\x4a\xcc\x3e\x05\x93\xca\xf7\xff\xd8\x19\xb2\xff\xc7\xdf\x94\x1d\x97\xfd\x0d\xe0\x1f\xa1\x7c\x0c\xe8\x91\x78\xa2\x10\x73\x38\x1b\x17\x31\x9e\x1c\x06\x45\xed\xec\x19\xec\x42\x64\x63\x2b\x17\x63\xcc\x8e\x2c\x8f\x30\xda\x47\x69\xaa\x02\x83\xc8\xfa\xcd\xe5\x05\x98\x3d\x0a\x26\xa0\x60\x12\xa4\xae\x85\x4a\x5d\x3b\x87\xa1\x33\xb5\x00\xb3\x57\x18\x2a\xa2\x23\xc6\x58\xd7\x2a\x98\xbb\xb3\x03\xd9\x77\x08\x26\x71\x4a\xcc\xbe\x6c\xbb\x84\x89\xcb\x18\xfc\xbe\x02\xdd\x4e\xf8\x61\xa9\x38\x3e\xe0\x77\x22\x3f\x76\x5b\x55\xb1\x5a\x3e\xe6\x30\xf6\x51\xf2\x9f\x6d\x11\xcc\x04\x32\xa7\x22\x66\x07\xd8\x28\xc5\xe7\x7d\xd6\x9c\x9f\x9d\x8f\xd9\xa3\x60\x5a\xf3\x30\x0f\xa8\x30\x3b\xc1\x3d\xc3\xd2\x79\x5c\x85\xd9\xab\x60\x72\x74\x46\xa1\xbe\x3f\xcf\x8e\xb3\x44\x91\x0f\xf6\xb2\x34\xf3\xc9\xec\x1e\x34\xab\x30\x4c\x66\x55\x92\xb3\x7c\xcc\xe1\x6c\x83\x88\x09\xca\x98\x91\x00\xf0\x53\xd9\x19\x18\x83\xdf\x76\xb1\x72\xfc\x8e\x2f\xf7\xa0\x31\xa4\x60\x4c\x19\xc3\x33\x8b\x30\x7b\x24\x4c\x95\x82\x29\x29\xc2\xec\x2c\xa2\x53\x5c\xd7\xde\x22\x3a\x35\xc2\x04\x46\x4f\xe6\xe2\x4c\x69\xbe\xb2\x45\xfa\xa3\x10\x73\x18\x02\x11\x13\x28\xc4\xdc\xab\x60\x88\x8c\x93\x31\x54\x62\xa7\x22\xcc\x1e\x05\x13\xce\xc3\x54\xa9\x30\x3b\x61\xc5\xb0\x74\x1c\x2a\xcc\x5e\x49\x27\x14\xd2\x19\x49\x64\xf9\x4c\x49\xde\x7f\x28\x9a\xf7\x42\xcc\x3e\x05\x93\x9b\x77\xe4\xe1\xf2\x2d\x64\x4e\x63\xca\xbc\x97\x17\xcf\x7b\x01\xa6\x78\xde\xf1\x63\x95\x8d\x64\x2e\x62\x94\x5d\x9c\xf7\x23\x85\xf3\x35\xa1\x08\xb3\xe7\x48\xc1\x7c\xe1\xb5\xb8\x02\xcc\xce\x22\x3a\xc5\x75\xed\x2d\xa4\x03\x56\x61\x0c\x77\xad\x0a\x73\xf7\xd0\x3b\x04\xd3\xf9\x13\x98\x7d\x12\xa6\x4d\xc1\x4c\xce\x7e\x41\xc5\x08\x6f\x9c\x45\x10\x37\x7d\x4e\x38\x23\x28\xdb\x0d\x7c\xbf\x4a\x75\xff\xf0\xd7\xe4\xbe\x5d\xbe\x6f\x47\xf7\x37\x93\xb9\x14\xef\xef\x78\x56\x9c\x81\xa8\x6a\x8d\xad\xa3\x00\xb3\x47\xc2\x94\xa8\x30\xb5\x48\x86\x39\x15\x66\x27\x28\xa6\x83\xda\x42\x5b\x54\x98\xbd\xa0\x98\x0e\xc6\x34\x13\x9e\x10\x31\x77\x7f\x29\x62\xda\x7e\x02\xb3\x4f\xc2\xd4\xa8\x30\x88\x6f\x98\x00\xe1\x89\xda\x42\xbe\x71\xaa\xf8\xa6\x00\xa3\xf0\x8d\x55\xa5\x2f\xd8\xbd\x64\x2e\x6b\x0b\xf4\x85\x57\xad\x2f\x0a\x30\xb2\xbe\xf0\xa8\xf5\x45\x01\x66\x67\x11\x9d\xe2\xba\xf6\x16\xd1\x59\x85\x31\x84\x27\x64\x8c\xcc\x37\xb5\x3f\x81\x91\xf9\x26\xc7\x7f\x62\x7c\xb4\x4d\x8e\x47\x90\xde\xd9\x5b\xe4\x37\x14\x62\x0e\x83\x47\xa5\x75\xa8\x42\xcc\xbd\x0a\x66\x07\x78\xad\xc8\xf6\x17\x62\xf6\x80\xa7\x24\x4c\x30\x0f\xf3\x57\x15\x66\x27\x78\x7d\x58\x3a\x1f\xa8\x30\x7b\x15\x4c\x8e\x0e\x8a\xe7\xb9\x99\xec\x44\xd4\xf7\x26\x65\xde\xc3\x64\x4e\xa9\xa8\x3c\xa7\xe7\x14\x61\x0e\x67\x5b\x44\x4c\x48\x99\xf7\xec\x17\xfc\xc7\x64\x2e\x9a\xf2\xe6\x9d\xa6\xea\x72\xf3\x5e\x84\xd9\x23\x61\x6a\x72\xf3\x8e\x30\x7e\x11\x83\x9f\x0a\x2b\xf3\xae\xa6\x33\xb2\x08\xb3\xb7\x88\xce\x68\xd4\xf7\x47\x89\x1c\xaf\x97\xe6\xeb\x55\xd1\x06\xc4\x72\x73\x51\x88\x39\x0c\x7e\x2f\x62\xfc\x85\x98\x7b\x15\xcc\x0e\x1c\x1f\x10\xe9\x69\x54\xc6\xb0\x10\xb3\x07\x5c\x07\xf2\x56\xde\x25\xcc\x07\x2a\xcc\x4e\xf0\xf6\xb0\x74\xfe\xa4\xc2\xec\x05\x2f\x0e\x47\x87\x29\x23\xb2\xbc\x5e\xb2\x13\x6f\x4a\x98\x51\x79\x18\xb3\x0a\x23\xfb\x85\x94\xf4\x12\x8d\xf4\xac\x85\xbb\x8f\xc8\x72\x27\x8c\xe6\xcb\x72\xa9\x3c\xa7\x55\xc8\x4e\xfc\x89\x8c\x73\x27\x35\x5d\x9c\xaf\x07\x45\xf9\x0a\x2a\xe3\x0c\x8a\x30\x7b\x8b\x30\x8b\x30\x86\xc8\x97\x8c\xd9\xf7\x95\x28\x5f\x8d\x0a\x26\x96\xfd\x82\xbd\x88\xcc\xc5\x85\xe2\x7c\xc1\x6d\x45\x7e\x58\x21\xe6\x30\xdc\x5e\xe4\x87\x89\x98\x7b\x15\xcc\x0e\xcc\x21\x05\x76\xb4\x10\xb3\x07\x5e\x5b\x6c\x47\x0b\x30\x3b\xe1\xdb\xff\x95\xce\x5e\xf8\xd8\xf0\x74\xc8\x5c\x88\x98\xbb\xf1\x3b\x75\x04\x33\xf3\x94\x98\x7d\x0a\x66\xac\x82\xe1\xd0\x7c\x6d\xc7\x32\x48\xcf\x93\xe5\x54\x38\x29\xce\x57\xb3\x3c\x5f\x75\x45\x98\xc3\xc2\x77\x22\xa6\x41\xc6\x20\xbd\xaa\xa9\xc3\xf3\x45\xcf\x93\xe5\xf4\x25\x71\xbe\x46\xa8\xf5\x6a\x01\x66\x8f\x84\x49\x2a\x76\xfd\x15\x34\xa7\x4b\x44\x8c\x2c\xa7\xdb\x0b\xe8\xe0\xf5\xc4\x02\xcc\xde\xed\x05\x74\xb0\x66\xe2\x97\x60\xde\x50\x30\x77\xbf\x27\xf2\xc6\x84\x9f\xc0\xec\x93\x30\x63\x15\x8c\x18\x53\xed\x52\x62\xa1\xe7\xc0\x35\x85\xef\xd3\x14\x61\x0e\x41\x43\x11\x46\xf4\xf5\x77\x49\xbe\x35\xc7\x3f\x37\x57\x7c\xeb\x42\xb6\xff\xf8\xfe\x58\xe5\x3e\xa2\x01\xa4\xf7\xa8\x5b\x0a\x7d\xcb\x5d\x8a\x9f\xf6\x1c\x91\xe3\xfc\x75\x8d\x42\xcc\x21\xd8\x5a\x84\xc1\xbe\x48\x05\xc1\x88\x76\xfb\xb9\x07\x09\xc2\xa3\xf6\x55\xae\x53\xdd\x3f\xe4\xcc\xbf\x2f\xda\x11\x69\xcd\x0b\x97\x9f\x49\x7a\x5b\x3e\xfc\x7d\xdc\x97\xbf\x02\x15\x42\xa5\xff\x76\x49\xba\x04\xd1\x38\x97\xd4\x51\x21\xd3\xc8\xbf\x8f\x69\xfc\x1b\xa8\x10\x2a\x99\xdc\xa5\xf0\xf7\x73\xb0\xb7\x68\xcc\x0a\x31\x87\xf0\xfb\xde\x05\x18\xaf\x30\x5a\x15\xd3\x47\x91\x4e\x7f\x19\xc7\xe7\x34\x2f\xbe\xe3\x53\x74\xff\x30\xf8\xcd\x30\xf7\xef\x55\xee\xef\x00\x9f\xfd\xe4\xfd\x3d\x78\xcd\xe0\x27\xee\xef\x84\xda\x9f\xbc\xbf\x17\xbc\x5f\x7c\x5f\x8e\xd7\xd1\xfd\xbb\xf1\xb3\xd7\x9f\xb8\xbf\x2f\xff\x7e\x76\xab\x30\x3a\x17\xa7\xe3\xfe\x67\x57\x65\x7f\x63\xc5\xf7\xf1\xb3\x8e\x82\x98\xbe\x00\x7b\x38\x3b\x3b\x1f\xab\x8a\xed\x57\x22\xac\x12\xb7\xe3\x71\xc9\x7a\x25\xec\xd3\x08\x90\x1f\x9b\xdf\x52\x80\xdd\x53\x84\xcd\xc5\xe8\x63\x49\x1b\x16\x2a\x6d\xd8\xa9\x60\xe7\x14\xd1\x5d\x52\x80\xdd\x9b\xb5\x16\x60\x55\xb1\x3f\xc6\xca\x71\x3d\x1e\x47\x1c\xfb\x2b\x7d\x2b\x58\x03\x28\xc0\x92\x35\x80\x3c\x6c\x5c\x15\x5b\x8e\xce\xc5\x8d\x84\xbf\x7e\x10\xc7\x1f\x32\x60\xb8\xfb\x24\xae\x2c\xba\x7f\xaf\x72\x7f\x07\x8e\x4d\x7f\xe2\xfe\x1e\x99\x7f\x54\xf7\xab\x54\xf7\x49\x2c\x59\x70\xbf\x49\x75\x7f\xef\x30\xf7\x95\xf8\x90\xf0\x57\x71\xfb\xd5\xf7\xf7\x15\xdc\x8f\x09\xa3\xd5\x71\x21\xe1\x30\x14\x03\xe0\xd1\xa2\x5f\x21\x5c\xa3\x8a\x21\x8b\xb0\xc4\x7f\x50\x63\x73\xb1\xa4\x30\x5a\x1d\xdf\x59\x22\x38\x96\xc4\x48\xd6\x41\xe6\x20\x2f\xa6\x2c\xc2\xee\x29\xc0\xaa\x62\xcb\x22\xec\xce\x53\xd2\x2d\x6e\xc3\xde\x53\xd1\x05\xab\x30\x36\x17\x47\x22\x2c\x8a\x19\xf2\xb0\x9d\x3f\x81\xdd\x57\x80\xcd\xc5\x9e\x68\x7c\x73\xfe\x0b\x1e\x5d\x78\x97\x24\xdf\x5f\x81\xe1\xee\x1f\x86\xb7\x0c\x73\xff\x5e\xe5\xfe\x0e\xfc\x7e\xf6\x4f\xdc\xdf\x03\xcf\xfa\xc9\xfb\x3b\xe1\x9b\x3f\x79\x7f\x2f\xdc\x5b\x7c\x5f\xf6\x53\x30\x7f\x61\x3f\xe5\x27\xee\xef\x2b\xb8\xcf\x09\xa3\xd5\xfe\x09\x1e\x01\xec\xc3\x10\x9e\x79\x44\xe4\x99\x9c\x2f\x53\x84\x25\xbe\x8c\x1a\x9b\xf3\x69\xd0\x1c\xa8\xfc\x15\xcc\x5f\x2f\x89\x73\xdb\x2b\xcd\x81\xca\xb7\x29\xc2\xee\x29\xc0\xaa\x7c\x1c\xc4\xe3\x2a\xff\x05\xf3\xd7\x76\x82\x65\x2e\x2c\xa4\x9b\xfd\xba\x08\xbb\xb7\x00\xab\xf2\x79\x30\x36\xe7\xcf\x60\xfe\x7a\xef\x9d\x3c\xec\x84\x9f\xc0\xee\xcb\xc3\x42\xaa\xd0\x07\xda\x21\xfb\x37\xd4\x36\xe9\xdd\xa8\xe2\xb5\x6d\xa7\x82\xb9\x16\x3f\x07\xcb\x7f\x4e\x2e\xd9\xb1\x5d\x8a\x1d\x7a\x0e\x5c\x5f\x6c\xa7\xe8\x83\xf2\xfa\x78\x81\xfd\xcb\x95\x3b\x04\xf9\xfc\xfb\xa4\xee\xb5\x4a\xdd\x77\x80\x5f\x17\xb7\x8f\xd0\x58\x2b\xd3\x40\x98\x47\xf3\x6d\x20\x59\xd3\x3d\x26\xaf\xe9\x52\xdb\xe0\x99\xe2\x33\xaf\xdc\xfb\x07\x12\xe6\x74\x05\x73\x2d\x9c\x2f\x62\x5c\x05\x18\xf9\x9d\x1e\xec\x93\x20\xdb\xb4\x0b\xdb\x45\x27\x5d\xb0\x2e\x9e\xc3\x1c\xca\xf6\x16\x63\x88\xdd\x52\xde\x0d\x92\xec\x0a\x84\x7a\xc6\x45\xa5\xd8\x6d\xc0\x0a\x22\x29\xa7\x89\x65\x81\xc1\x60\xb3\x6b\xcd\xa6\x80\xa9\xc7\x34\x68\xda\x60\x62\x4d\x20\x3e\x70\x58\x95\x00\x0f\x8a\x5b\x82\xc5\x9d\xf6\x6c\xb2\x1b\xc2\x87\x7c\x41\x5f\x79\x67\x55\xfd\x08\xe1\x90\x71\x42\x3f\xf3\x8c\xc9\xe6\x0c\x78\x4b\x9b\xcb\x47\xb4\xfc\x71\xec\x18\xa7\xb4\x8f\xfe\xb0\x30\x1a\x7c\x9d\xbd\x09\x18\x41\x69\xca\x60\xe0\x29\xca\x24\x26\xf5\xf6\x81\x9e\x57\xa5\x53\x09\x48\x12\x3f\x9c\x94\x80\x64\x4a\x71\x73\x9d\xab\x98\x8a\xdb\xcb\xfd\xbe\x86\xd2\x79\xc2\xe8\xa5\xe1\xe7\x9f\xd0\x47\x3d\x7d\xed\xff\xef\xda\x0c\xa6\x32\xe3\xe9\x10\x7b\x01\x70\x83\xda\x94\xc3\xa9\xd1\x78\x4a\x1c\x7a\x3d\x73\x63\x46\x0f\x52\xc0\x72\x63\x46\x03\x40\xfc\x80\xb8\x73\x55\x3c\x43\x93\x54\x48\x92\x9d\xe5\x4e\xb4\x75\x89\x69\x88\xf1\x49\xb6\x54\xe9\xac\x85\x8d\xc1\x40\x79\xe9\xb2\xd0\xe5\xa7\xb5\xcc\xa8\x6f\xf6\x93\x93\xb4\xa3\x1b\x99\xf1\x73\xea\x2a\xd3\xb7\x5c\xdd\x10\xa9\xb3\x56\x76\x6c\xdb\x84\xf7\xf4\x0f\x30\x53\x69\x64\x03\xc9\xde\xf3\x38\x98\x90\x0a\xd7\x95\x97\x4b\x7b\xe7\x1b\x1b\x3c\x55\x37\x66\xca\x3d\x1e\xae\x36\x14\xf2\xdd\x98\x09\x81\x94\x8d\x03\xdc\xf5\x19\x14\x25\xc4\xc9\xe9\xbb\xa8\x49\x87\x49\x93\x6c\xed\xa8\x85\x79\x99\x3a\xf2\xb7\xc9\x07\x55\xdf\x4f\xd9\xec\x48\xc3\xf8\xf1\x0d\x8d\x63\xc6\x08\x1b\x1a\xc6\x8f\x6b\x44\x5f\x60\xe3\xa9\x3a\x32\x75\x6c\x53\xd3\xe8\xbe\x44\xd3\xd8\xfe\x78\xc3\xd8\xb1\x0d\x4d\x63\x61\x6d\x61\xd7\x14\xff\x62\x97\x6c\xdf\x45\xbb\x6e\x91\xe2\x0f\xf9\x3e\x7e\x5f\x81\xdc\x2f\xf4\x4b\x8a\xcb\x1d\x82\xa3\x95\x58\x65\x3a\x91\xc9\x33\xa5\xe7\x71\xa5\xc3\xac\xa7\x8f\xce\x61\xb0\xdc\x62\x8c\xaa\x8e\x4b\x50\x6c\x1a\x66\xbb\xf1\xda\x3e\xac\x95\x24\x6e\x42\x76\x1b\xd6\xe3\x01\x5a\xd2\xe3\x7d\x45\x98\x43\x45\x18\x44\x87\xbf\x95\x60\x62\x3f\x45\xa7\x00\x53\x44\x07\xeb\x6b\xf5\xde\x38\x64\x55\x70\x72\x31\x0a\xcc\x60\x4c\xd4\x21\xf6\x5e\xc0\x02\x17\x68\x4e\xf9\x38\x9b\x4d\xaf\x77\x40\x9a\x76\x38\xdc\x1e\xca\x0c\xcc\x8e\x80\xa3\xc7\x31\xe8\xd8\xe0\x40\xf6\x3d\x3e\x70\xf0\xed\x03\xf9\x47\xe0\xe1\x6c\x28\xc9\xa0\x95\x0f\xe7\x4b\x46\x2b\xf5\xb3\xfd\x3c\xa4\x39\xa1\xdd\x1f\xf2\x57\x74\xc6\x1a\xbb\x84\xa7\x8d\xdb\x99\x4a\x38\x36\x2c\x3c\x1e\xdc\x66\xb6\x3b\x91\x3c\x26\x83\xdd\xc9\xbf\x4c\xea\x8f\x91\x76\xd4\x32\x26\xbc\x3e\x9c\xdf\x0e\xf0\x7f\x69\x47\x12\x27\x49\x8e\x16\xb4\x03\x5e\xc5\x5d\x00\xb2\xbc\xf0\xe7\xa1\xfc\x86\x04\xe1\x84\xb0\xf0\x54\x51\x43\x28\xb0\x96\xfe\x8c\x1e\x8b\xe4\xc5\x05\xa2\x60\x56\xaa\xd1\x8d\x24\xc3\x17\x0e\x3b\x1c\x1a\x4d\x55\xb5\x24\xac\x61\xbb\x28\xbd\xe5\xb1\x30\x7c\x20\x7c\x28\xfc\x79\x98\x0e\xa7\x74\xd6\x71\xe6\x30\xa4\xc2\x20\x3e\x38\x10\x1b\x58\x7d\xa0\x48\x6e\x54\x59\x9f\x8b\x04\x84\x1c\x50\xcd\x16\x0e\x61\xd7\xec\xc1\xa6\x40\x20\xe4\x39\x33\x7a\xf9\xc2\xe6\x89\xe5\x63\x83\x81\x0a\xf4\xfd\x52\xe1\x47\xa4\x73\x02\x23\x6a\xea\x3b\x84\x43\x86\xad\xec\xc5\xb3\xeb\x23\x93\x6e\xbf\x3c\x56\xd2\x13\x1d\xbf\x6d\xd3\x57\xa2\x02\x4a\x04\x3b\x9a\x91\x02\xaa\x01\x4a\x5c\x7d\x8c\xd8\x49\x12\x37\x53\xdb\xde\xca\x5f\xe3\x9f\x88\xee\xbf\x45\x6c\xa4\x78\xff\xda\x43\xe4\xbe\x4b\x1d\x77\xdf\xcd\xfd\x55\xbc\x8f\xf7\x33\x3e\xf8\x2c\xe1\xc3\x3d\xb0\x99\xec\x67\xb4\xe3\xfd\x8c\x76\x65\x3f\x23\xc1\xef\x2a\xc2\x1f\x02\xb5\xa7\xc0\xe3\x98\xba\x9c\xc8\x92\x58\xff\x1d\x9f\xe6\xb7\x8f\xdc\xe7\xce\xcc\xa7\x47\xdd\x91\xfd\x14\xc5\xde\xee\x94\x89\x82\xfb\xec\x30\x65\xcf\x91\x5d\xbd\x5a\xf4\x51\xf0\xbb\x54\x1b\x89\xed\xac\x95\xfc\x83\xb3\xc4\xe7\xea\x86\x9c\x5d\xc4\x98\x4b\x89\xed\xac\x95\xfc\x83\x35\x45\xfb\x04\x90\x0c\x32\x97\x13\xf9\xaa\x2d\x94\x41\xb3\x4a\x06\x99\x4f\x25\xcc\x0d\xf9\x32\x28\x62\x10\x6f\x5d\xa4\xc8\x9a\x1b\x34\xa5\xbc\x6e\xb3\x59\x8b\x25\x4d\xab\xf5\x94\x50\x06\x80\xd3\x19\xf4\x70\x83\xdc\x06\x8e\xe5\xd4\x2c\x5e\x20\x69\xac\x94\x77\x0d\x9f\x23\x20\x26\x91\x93\x65\x6d\xd7\xcf\xce\x5d\xd4\xd7\xd0\x3a\xb9\xca\xdd\x99\x92\x45\xcd\x15\x58\x36\x69\xfa\xea\xba\xc8\xe8\xb0\xdd\x6d\x2d\xa9\x76\xc8\x32\x8f\x9f\xb3\xa8\xdb\x01\xfe\x2f\xed\x20\x92\xc6\x17\xb5\x03\xde\x28\xc9\xda\xed\x79\x0d\x11\x45\xad\xb8\x21\xf9\xb2\x36\x23\xd5\x10\xad\x0c\xe0\xa3\x08\xd4\xa2\xe6\x96\x44\xcd\x17\x73\xc3\x07\xdc\x87\xdc\x9f\xbb\x69\x37\x11\x35\x37\xa4\xdc\xff\x45\xd4\x4e\x2d\x69\x74\xa4\x70\x04\x4f\x21\x6a\x77\xbe\x3f\x77\x54\x6d\x6b\x6f\xad\xa7\xbd\xb3\x40\xce\x84\xb3\x5a\x6f\x9e\x72\x56\x4d\xe5\xe8\x80\xc3\x65\x29\x89\xd8\x55\x6b\x47\x3b\xe4\xb5\x23\x6a\xdb\x85\xaa\xd5\x75\xe5\xbe\x53\x5e\x3b\xc2\x7b\xdd\x45\xbb\x52\xb8\xfe\x44\x64\x67\x3d\x10\xf7\xbe\x6c\xcd\x12\x69\x03\x9b\x25\xe9\xf1\x63\x36\xf7\x13\xe9\xf9\x09\xfc\x21\x08\x87\xc3\x67\x5f\x15\x26\xd2\x7f\x23\x31\xd7\x5a\xe9\x39\xc1\x9b\x85\x3e\x69\x11\xe6\x30\x78\xab\xe8\xb9\x0e\xae\xf7\xcf\x44\x66\xd7\x4b\xbe\xed\x6d\xc3\x3d\x4b\x60\x34\x44\x6e\xf3\xda\x86\xb0\x47\x14\xc9\xf5\xc3\x94\x3f\xd7\x44\x22\xb9\xaa\x77\x62\x8e\x29\xef\xc4\x6c\x83\x57\x16\xbe\x13\x23\x61\x4e\x57\x30\xf2\x9e\x3d\x69\x37\x36\xe9\xcb\x6f\x91\x8d\x1d\x47\xe4\xb2\x53\x5a\x23\x7e\x4e\xb8\x5a\x94\x4b\x8f\x6c\x1b\xcf\x28\xc2\x1c\x12\xce\xce\xc7\x90\xba\xf6\x93\xf8\x3f\x51\xf0\x2c\x50\x5c\xa8\xc1\xbe\xd6\x7c\x66\x01\xed\x62\xff\x20\xe5\xf9\x19\x93\xb2\x78\x4b\x4a\xe4\x3c\x45\x01\xec\x5a\xe1\xec\x3e\x0e\xec\x5e\x79\x37\x78\xb6\x20\xb3\xe6\x09\x78\xf6\x7a\x8e\x78\x18\x0f\xce\x3e\xf3\x6a\x7b\x5c\x7d\xd4\xf6\x70\xd9\x88\xd4\x6e\x96\x9b\xc6\x09\xd2\xa8\x07\xe4\x6c\x44\x5f\x4b\x5f\xf6\x5c\xca\x1f\xd5\x71\xcc\x0a\x39\x1f\x91\x9c\x8e\xc8\x24\x2a\x84\xe2\x76\xb6\xa0\x76\x7a\x3c\x85\xed\x7c\x9c\x34\x13\x35\xec\xff\xda\xac\xa4\x3d\xc1\xd3\xc5\xcd\x1a\xcd\xad\x38\xca\xff\x6b\x98\x66\x89\xea\x81\xc4\x10\x09\xa6\x8d\xea\x62\x77\x21\xbd\xd4\x9c\x0a\x33\x10\x72\x3c\x6d\x46\x4e\x6b\x1a\xac\x04\x1b\x90\xa8\x70\x66\x10\x00\x3d\x60\x10\xfd\xb1\x17\x71\xd0\x31\x80\x1d\x67\x34\x6e\x8a\xbf\x8c\xf4\xa3\x9d\x87\x9f\xef\xe7\x41\x96\xe1\x98\x36\xb1\xc3\x4a\x9c\xbf\x4b\x8e\xd3\xc5\xf8\x1c\xfb\x89\x78\xaf\x92\x7c\x9f\x7e\x4e\xba\x5f\xb8\x3e\x50\x5c\xee\x90\x94\x9b\x43\x5c\xc3\x5d\x2b\xaf\xe1\x22\x1f\x70\x5b\xf1\xf3\x19\x42\x63\xad\x4c\x43\xc4\xa8\xea\xb8\x84\x3c\xdb\x9b\xa8\x3c\xdb\xcb\xd9\x16\x2a\x28\xf3\x5e\xf1\x33\xcb\x43\xd9\x64\x01\xe6\x12\xf2\xec\x61\xa2\xf2\xcc\x40\x65\xa3\xea\x15\x3a\x45\xcf\x4b\x64\x3a\x39\x8c\x1d\xb5\xf7\x0d\xfc\xee\x2f\xc2\x88\xed\xfc\x92\xc4\x30\x27\xd0\xdc\x9c\x4f\xe6\x26\x99\xaa\xa2\x11\x21\x1e\xd0\x37\xcc\xfb\x5f\x4c\x4f\x4c\x9e\x1e\x3b\x31\x1b\x27\x24\x1b\xc1\xb4\xc9\x13\x0f\x61\x3b\x8a\xc3\x92\x28\x0e\x33\xe3\x38\xcc\xac\xd1\x18\x29\xca\x62\x65\x73\xe4\x58\x50\x18\x87\xe5\x2b\x70\x37\x55\xf2\xfe\xbc\x51\xb5\x2d\x48\x51\xaf\x63\x5c\x39\xc5\x6c\x8e\x57\x92\x98\xf1\x2f\xc2\x31\x50\xc3\xa2\x06\x03\xeb\xe3\x90\xa2\x18\x0a\xd1\x8b\x4b\x19\x9e\xec\xd6\x90\xb5\x66\x06\xcb\x9f\xf8\x8c\xf3\x60\x6c\x39\xc2\xbe\xcf\x5e\x09\x4c\xa0\x21\xe5\x36\xe8\xf0\x4e\x7a\x08\xcd\x46\x8d\x9e\x35\x51\x2c\x4f\xd3\x50\xcb\x43\x54\x1a\x67\x3e\x23\x27\x1e\xc9\x47\x83\x93\x1c\x3e\x56\x3e\x9a\x8c\x26\xdd\x49\x37\xef\xe6\xa3\x35\x33\x36\x24\xef\xbf\x5f\xfa\x7f\x83\x70\x8c\xcd\x6c\x4c\xee\xbe\xaf\xed\xd7\xbf\x6e\xbb\x6f\x77\x72\x23\xae\xeb\x4d\xe1\x18\x7c\x14\xd5\xa5\x43\x56\xd8\xa5\xa1\x69\xa0\xa5\x50\xd3\x58\x96\xd3\x33\xc8\xbe\x42\x9e\xd3\x21\x03\x1c\x97\x8e\x5d\xc6\x69\x00\xf3\xfc\x5d\x54\x57\x08\x35\x3e\x18\x4d\xc2\x47\xdf\x4b\x6e\xfa\xcf\x34\xd8\xbf\x29\xc9\xdc\x7f\x34\x79\xf1\x0f\x67\xb3\x1f\x5c\xdc\x46\x62\x4f\x61\x22\xea\x4f\x15\xa9\x03\xe7\xee\x62\x18\x4e\x8b\x33\xc1\x02\xa8\xa7\xb5\x2c\xfa\x0f\x92\xde\xa8\xaa\x68\xca\xd5\x80\xfa\x13\x42\xfd\x40\xbd\x09\x56\x4d\xfb\xcf\xa6\xe4\x7b\xa8\x16\xd8\x8f\x3a\x72\xf3\xc5\xc9\xa3\xef\xb4\x5d\x4c\xf4\xeb\x7b\x70\x2b\x7d\x92\x0a\xdb\x38\xfe\x5d\x32\xd6\xd2\xdf\x68\xac\x5d\x29\x1d\x64\x29\x86\xa6\x9e\xca\xd0\xcf\x00\xe9\xc8\x40\xd4\x6e\x67\xb0\x85\x3e\x79\xf2\x23\x2a\xbc\x65\x0b\xc2\xff\x1d\x6e\xe5\x87\xfe\x1b\x9e\x1f\xfa\xfe\x94\x78\x00\x9f\xca\x80\x53\xe0\x11\x3f\x5f\x8e\x1c\x8d\x91\xec\x75\x16\x0e\x5e\x4e\xda\xfb\xf5\xd0\x33\x8c\x35\xbb\xd6\x16\x05\xa3\xc0\x66\xe1\x2d\x0b\x8f\x7f\x03\x31\x4e\xff\x8c\xfa\x94\x3a\x8b\x9d\x0a\x6c\xa0\x2c\x65\xa2\x8d\x46\xc4\xc0\x76\x07\x6d\xd9\x9d\xa1\x19\xd0\x13\x53\x27\xef\x6f\x6e\x4d\x3a\x71\xde\x32\xe4\x53\x88\x27\x13\x7c\x76\xf0\x99\xb6\x69\xb5\xfe\x9a\x31\x73\x47\xcf\x58\x4a\xff\x7a\xfb\xdf\x1a\xe7\x9b\xbb\x26\x56\xb8\x82\x25\xb5\xd3\x47\xf6\xad\x10\xe9\xbf\x8b\xe8\x2f\x2a\xa4\x6f\xa1\x77\x67\x2c\x05\xf4\xa1\x83\xe3\x5b\x70\xb6\xb4\x48\x54\xe2\x74\x6a\x91\x58\x41\xf5\x58\x5c\x01\x73\x7d\xae\x82\xd2\x98\x54\x01\x04\x21\xe1\x45\x78\x2f\xac\x43\xf4\x2b\x52\x56\x44\x1c\x55\x41\xe8\xcf\xb3\x5b\xee\x9f\x67\x01\xf1\x98\xba\x8e\x70\x51\x1d\xf0\x5e\x75\x1d\xcb\x87\xa9\x02\xc9\x2a\x83\xfa\xb0\x91\x9d\x06\xac\xa0\x3c\x65\xd4\xd3\xb4\xc6\x6c\xb6\xd9\x81\x61\x77\x06\xec\x87\x86\x82\x5e\xa8\x3c\x2c\xd1\x5b\x84\xdf\x77\x4f\x38\xad\xb5\x6e\xde\x24\xdb\x9d\x7b\xae\x62\xa7\x75\x36\x2f\xa8\x2f\xa9\x0f\x24\x07\x3c\x03\x75\x8f\x5f\xfa\xb3\x2d\xd8\x27\x7c\x81\xfa\x94\xfe\x07\x19\xa3\x30\x68\x4d\x79\x5d\xe5\xe5\x5e\xbb\x1d\x88\x83\x15\x89\xba\x42\xbb\x33\x2e\x46\x99\x12\xd5\x89\xcd\xaa\xc4\xa6\xc5\xb3\x13\x2e\xba\xf2\x82\x7a\xbe\xe0\xae\x9f\x9e\xbd\xd9\x45\xd3\x49\x81\x27\x51\x3b\xdf\x3d\x65\x3b\x43\xae\xdd\x99\x10\xa3\x4c\xed\xf0\xed\x2c\x9e\x65\xb6\xe8\x0a\xfd\xae\x7a\x4e\x84\xf9\x3f\xcd\x05\xb3\x87\x9b\x33\x0a\x30\xc2\x8b\x74\x8c\xf0\x45\x18\x8c\x48\xe1\x86\x96\x8b\xdc\x81\x5a\x4d\xda\x3a\x2f\x12\x42\x0c\x82\x18\x25\x22\x33\x8a\x8a\x55\x14\x7d\x50\xcc\x31\xc3\xb4\x37\x76\xea\xf6\x16\x71\x54\x51\x73\x91\xbc\x22\x19\x64\x4a\xd8\x69\x96\x08\xff\xc9\x47\xd8\xd6\x7e\x02\x6f\x25\xbc\xbd\x38\x6b\x61\x2a\xd9\xeb\x80\x11\x74\xa5\xca\xf5\x40\xab\x65\x69\x8d\xc6\x64\xe6\x75\x8c\x91\xe1\x0c\x2c\xc7\x3e\x9f\xd1\x73\x1a\xee\x85\x79\x1a\x40\xbd\x26\x1d\x37\x25\x9d\x59\xaa\x4a\x43\x8f\x0f\x20\x0f\xd9\x93\x6c\x92\xb5\x27\xe8\x30\x1f\xa6\x76\x09\x9f\x8f\x9a\xb4\x42\x58\x50\x03\x37\x33\x5f\x5d\x0d\x77\xd6\x08\xeb\xa8\xff\xfc\xe8\xa1\x3f\xbb\x6b\xd4\x17\x29\x78\xad\x70\x5e\xea\x0b\xf1\xcc\xdf\xf7\x50\xfd\x61\x54\x7f\x09\x38\x3f\x95\xb2\x9a\xcd\x26\x0f\x96\x05\xca\xc5\xf3\x28\x6e\xd2\x9b\x4c\xa5\x5e\xbb\xce\x62\x64\x0c\x36\xbd\x41\xff\x7c\xc6\x6a\x35\x98\x0c\x2f\x64\x4c\xc0\xcd\x01\x9a\x61\x58\x8f\x87\x65\x50\x0b\x4b\x18\x8a\x79\x21\x83\xdb\x27\x37\xcf\x13\xb7\x8a\xa7\xa6\x93\x43\xbd\xf2\xda\xab\xfa\x5f\x1a\x7f\x3a\x64\x47\x2d\xc7\x26\x46\xe9\x00\xb6\x34\x61\x1e\xfe\x93\xfa\xea\x4a\x61\x10\x75\xa2\xed\xa2\xae\xb3\x49\x6f\xb8\xaf\x36\x93\xde\x74\x6c\x48\xad\x42\x5f\x6e\x17\xce\x85\x3f\x4f\x7d\xd5\xb7\xf5\x91\xc7\xb6\xe6\x7a\xb6\xf5\xb1\x47\xb6\xf6\x7d\x05\xc4\x1c\xd6\x37\x52\x9b\xe9\xdf\x22\x9f\xd0\x97\x32\x22\x1b\x61\x30\x9a\x39\xc8\xe1\xf4\xce\xc8\xf6\xbe\x3a\x90\x5b\x93\x54\x2d\xf4\x9d\xb7\xe6\xee\xbb\xd7\xa0\x0f\xbc\x71\xc7\xb9\xe7\xee\xc0\x1f\xcc\x6f\x34\x58\x94\xfd\x90\xb7\xc2\x38\xf1\x2f\x43\xf8\xfc\x75\xec\x59\xd2\x5e\x6f\x90\x0e\x56\x86\x3d\x65\xb7\xcd\xf3\xb8\x0c\xb6\xdb\xe6\x19\x5c\x80\xbb\x6d\x1e\x39\x8f\x53\x7d\xfc\x7a\xbb\x94\x4b\xb4\x49\x3a\x7d\x73\x18\x27\x33\x6f\xb9\x91\x1f\xbd\x68\xe1\x18\xf4\xa1\x56\x14\x7e\xf1\x93\x9f\xc3\x7c\x64\xdb\xcb\xfc\x0f\xf2\x2d\x3c\x29\x2d\x0b\x91\x5b\x80\x66\x8a\xc2\x96\x5d\xca\x63\x29\xba\x06\x41\x67\xcd\x74\xf8\x36\x73\x19\x36\xa9\x69\x6c\x4f\x27\x21\x7b\x5a\x4d\xca\x39\x9f\xa4\x01\xb2\xa7\xc8\x00\x81\x78\x22\x2e\x2f\x3d\xc3\x96\x20\x2a\x26\x4c\x82\x6f\x4f\x67\x2e\x4b\xff\x50\xc6\xde\x2c\xae\x5b\xdb\x50\xb9\xaf\xd8\xcb\x01\x8f\x74\xbf\x01\x50\x14\x62\x5f\xc8\xb2\x34\x4f\x13\xf3\x1b\x97\x6d\xaf\x68\x75\x71\xc5\x5f\x1d\x98\x71\x00\xbe\x4d\xff\xcf\xc9\x32\xe6\x03\xf8\x48\x1e\x0d\x3d\xa8\x4d\xd9\x75\x2c\xf2\x68\x10\x21\xda\x80\xe8\xe8\x74\xb4\x16\xa7\x66\x8c\x8b\x19\x59\x15\x67\x21\x8f\xa2\x33\x28\x53\x15\xce\x83\xd7\xca\x94\xd3\xc2\xe7\xf9\xb4\xeb\x53\x0e\xc8\x71\x1a\x46\xaf\xd7\x68\xb5\x06\x5e\xaf\x07\x80\xd1\xd2\x38\x1b\x62\x5c\x21\xae\xe2\x4a\x1a\x51\x25\x7d\x46\xff\x7d\x85\xf9\x0a\xbe\x8d\xea\x60\x02\xd0\x99\x16\x26\xe3\x2a\xc4\x78\x4e\xfa\x67\xe1\xf8\xbf\xe0\xa7\x59\xa0\x3e\xfb\x31\xff\x5b\x64\x47\x68\xe4\xf5\xf9\x50\xfc\xdf\x0c\x52\x60\x12\xe5\x4c\x65\x29\xba\xde\x5f\x55\x31\xb2\x63\x6c\x0b\x80\x2e\xc6\xa2\x83\x34\xa3\xf3\x57\xb4\x74\x68\xd2\x93\xbb\xfb\x9f\xc8\xb4\x77\x3f\x39\xaf\xbd\x17\xfd\x2e\x09\x37\x3e\x91\x29\x0f\x3f\x39\xaf\xbc\xe6\x89\x0c\x28\x2f\xd1\xd8\x9e\xc8\x18\x35\x4f\xce\x33\x96\x3c\x91\xa1\x8c\xcc\xaf\xd2\xf0\x9a\x34\xbc\x20\x0d\xcf\x4a\xc3\x19\x69\x38\x3a\x0d\x5b\xd3\x30\x92\x86\xee\x34\xfc\x4f\x1a\x7e\x9a\x86\x6f\xa6\xe1\xfe\x34\xdc\x95\x86\xbf\x4c\xc3\x2b\xd3\xf0\xdc\x34\x5c\x92\x86\xb3\xd3\xb0\x2d\x0d\xab\xd3\xb0\x34\x0d\x35\x69\xb8\xf4\x44\x1a\x7e\x9c\x86\x6f\xa4\xe1\xc1\x34\x7c\x32\x0d\xb7\xa6\xe1\x55\x69\xb8\x3e\x0d\xe7\xa4\xe1\xf8\x34\x1c\x91\x86\xa1\x34\x74\xa4\x21\x9b\x86\xff\x4e\xc3\x4f\xd2\xf0\x65\x02\x53\xea\x3e\x83\x50\x44\x15\x47\x09\x39\x44\xed\x1f\x69\xf8\x56\x7e\xc5\xeb\xf3\x6b\x4d\x5d\xac\x4f\xc3\xe4\xc9\x34\xfc\x48\x55\xef\xad\x69\xb8\x39\x0d\xcf\x4f\xc3\x33\xd3\x70\x6e\x1a\x4e\x48\xc3\xce\x34\x04\x4c\x1a\x7e\x47\x6a\x7d\x25\x0d\x7f\x9b\x86\x0f\x11\xdc\xb5\x69\x78\x71\x1a\x2e\x4e\xc3\x59\x69\xd8\x9e\x86\x31\x52\xeb\xe7\x69\xf8\x4e\x1a\x1e\x49\x43\xf8\x6c\x1a\x3e\x90\x86\xbf\x48\xc3\x4d\x64\x64\xe6\xa5\x61\x9a\x80\x02\x69\x68\x4e\x43\x9e\x1a\x5c\x30\xa0\xfc\x1b\xc4\x3f\x56\xab\xfe\xad\x19\x5c\xa3\xfa\xa7\x42\x16\xe2\xd6\x9c\x1a\x97\x03\xe2\x03\xf3\x62\xe2\x39\x86\xe4\x97\x68\x73\xdc\x05\xa7\xf6\x93\x53\x0d\x43\x30\xc1\x3a\x78\x2a\x58\x21\x39\x2a\xb9\xb4\xe0\xf8\xa4\x5d\xf9\x00\xb6\xfc\xeb\xe1\x53\x15\x38\xb0\x95\xd9\x7d\xcb\xd0\x06\x5d\xb7\xf0\xda\xd0\xcb\x0f\x5e\x72\xb9\xd0\x3f\xa6\x71\x4a\x6d\x45\x4d\xe3\x84\x18\xfd\xd9\xab\x0f\x14\x5e\x63\xa6\x0f\x87\x74\xb0\x67\x7c\x5b\x3f\x42\xb8\xeb\x5f\x47\xbe\xbf\x40\xb8\x7d\xc3\xf2\xa7\x26\x8f\x1e\xbf\xe2\xe0\xd0\xe7\x47\x4e\xe4\x5f\xd9\x5e\x0c\x12\x7d\xc1\xfb\xe8\xf9\xf0\x2d\xb6\x0b\xf1\x7f\x30\x65\x41\x7e\x15\x45\xd3\x0c\x0b\x68\x0b\x4d\xd1\xe8\x5a\x8f\xac\x71\x45\x45\x14\xa4\x43\x7f\x85\xd4\xa1\x65\x6c\x97\x10\x40\xf6\xfc\x30\x3d\x9f\xbe\x8b\x94\xe5\x41\x63\xca\xc3\xa0\x88\x81\xe7\x45\x1a\x1a\x2d\x2f\x12\x61\x30\x95\xa6\x57\x07\x9a\x0a\xac\x89\x48\x0d\xa2\xcf\x10\xa6\x08\x5f\x97\xe9\xc2\xbf\x23\xda\x34\xf8\x37\x3d\x9f\x39\x53\xa2\xad\x07\xd5\x29\x3b\xcb\x43\x5a\xaf\xd5\x22\x4d\x65\x40\xfe\x1e\xaf\x01\x0c\x8d\xf3\x82\xbf\xda\xd4\xa4\x9a\x2d\x7c\x8e\x10\xa2\x2a\x7d\xa8\xae\xaf\xee\x9e\x21\x1c\x42\x3f\xa8\x2b\xd0\x0f\x99\x3a\xa9\x01\xf7\x7d\x15\xe8\xa7\x06\xe9\xe9\x00\x59\x90\x94\x83\x46\xed\x66\x59\x0d\xcf\xb1\x48\x97\x7d\x99\xa1\x20\xfa\xec\x87\x9a\xd4\x37\x97\x69\xe0\xb9\x1a\xb8\x58\x03\xa7\x69\x60\x9f\x06\x36\x6b\x60\xb9\x06\x3a\x34\x90\xd1\xc0\xef\x34\xf0\x23\x0d\xfc\xb3\x06\x1e\xd0\xc0\x47\x34\x10\xde\xa5\x81\x37\x68\xe0\x46\x0d\x5c\x45\x0a\xcc\x90\x0b\xc4\x08\x7a\x99\x08\x47\xd8\xc7\x34\xf0\x01\x0d\xfc\x85\x06\x6e\x22\xb8\x29\x32\xce\xab\x81\x7a\x19\xb0\x4b\x03\xaf\x25\x17\x2b\x55\x55\x89\xd7\xcf\x92\x49\x9b\x35\x30\x99\xd5\xc0\xcf\x35\xf0\xa8\x06\x1e\xd2\xc0\x0d\xe4\xde\x3c\x0d\x9c\x40\x0a\x88\x17\xcf\x25\x57\xfa\xe4\x56\x20\x2a\xaf\xa9\xea\xf8\x05\x01\xf4\x91\x6a\x2c\x1a\x48\x01\x0d\xe4\x17\x88\x22\x97\x2f\x27\x45\x62\x34\x9c\x90\x15\x4a\xad\x4a\xca\x4a\x90\x60\xe1\x23\x8e\xd5\x8e\x79\x02\xda\x43\x30\x09\x4f\x2e\x16\x4e\x5e\xb4\x58\x10\x0c\xf4\x74\xe1\x42\xe1\x22\x78\xba\x78\x66\x3c\xf0\xa3\xf9\xd1\xd3\x33\xd0\xfc\x0c\x90\xf9\x01\xc3\xcd\xcf\xfb\xb7\x69\xe0\x75\x1a\x78\x21\xe9\xfa\x80\x06\x4e\xd2\xc0\x2e\x0d\xac\x23\x83\xa9\xd5\xc0\x93\xf2\xf0\xbc\xaa\x81\xbf\x25\xc3\xbe\x1d\x4d\xd4\x16\x52\x60\x25\x19\x19\x34\xe2\x4b\x4f\xaa\x06\xf1\xb7\x32\x31\x74\x2f\xad\x81\x3d\x64\x68\xc4\xa2\xe2\xc8\xc6\x64\xaa\x87\xe4\xeb\x77\x92\x41\xec\x90\xd9\x22\xa9\x9e\xe8\x4d\x32\xfb\xcc\x20\x4d\x12\x99\xe5\x5a\x52\x47\xb3\xaa\x79\x47\x34\xf0\x59\x0d\xbc\x8d\x54\xdc\x41\xea\xf0\x92\xf9\xcd\x57\x85\x03\xf9\x43\xbe\xe0\x54\x37\xe4\x5b\x83\x45\x5a\x71\xb8\x79\x48\x86\x20\x9d\x80\xfc\xa5\x8b\x21\x73\xe1\x62\x08\x0d\xfd\xf0\x0a\x78\x85\x70\xfb\x28\x6c\x2f\x6f\xcf\x7e\xc8\xfc\x0f\xdb\x65\x89\x00\x06\xaf\xd4\x00\x86\xc2\x0f\x73\x82\x68\x3e\x28\x08\xb6\xf0\x70\x03\x0f\x57\xf2\xb0\x87\x87\x71\xbc\x54\x60\x25\xb5\xb5\x90\x04\x4a\x30\x7b\x80\x63\xa8\x4f\xb8\x19\x48\x86\x9d\x29\x2d\x60\x21\x03\xa9\xdf\x64\x90\x97\xa2\x84\xc8\xc8\x60\x53\x9f\xfc\xf8\x2e\x5d\xc1\x31\x53\x90\x4f\x83\x5c\x14\xea\x35\x22\xf3\xbe\x94\x01\x29\x11\x96\xc4\x79\x1c\xf0\x20\x3f\x5a\xc9\xea\xdd\xd8\x10\x83\x30\xf1\xcd\x85\xf4\x4b\xe7\xb3\x38\x05\x02\x6a\xd7\x1d\xd9\x27\xa8\x3d\xec\xaf\x24\x3f\x2f\x0e\x06\x52\x89\xba\x68\x94\x0e\x7a\xbd\x34\x72\xf8\x90\x13\xd9\xd0\x88\xfc\xbc\x4c\x99\xe7\xb6\x8c\xa1\xcc\x50\x06\x6a\x90\xbf\x87\x33\x26\x81\x06\x40\x6b\x69\x50\x53\x53\x79\x5b\xa6\x06\x8a\x87\x2a\x1f\x90\x33\xa1\xb4\x7b\xe2\xea\x40\x35\x67\x05\xd4\xce\x20\xfd\xbf\xf8\x0e\xfb\x24\x87\x8f\x93\x7e\x43\xe9\xb7\xec\x30\xf6\xcb\xee\x20\xbc\x4a\xf9\x76\x75\xf1\xb5\x7c\xff\xcd\x8c\xfc\xd9\x52\xc6\x6c\x36\xb2\x3a\x8d\xce\x00\x0d\x46\xa3\x45\x6f\x36\x6b\x70\x16\x55\x9e\x26\x5e\x92\x55\xf4\x93\x54\x8e\x52\xce\x57\x4a\x58\x43\x2d\x41\x67\xc8\x9a\x70\x8a\xfe\xd2\x01\xe4\x8c\x1d\x38\x20\xfb\x4b\xc8\x15\x93\x3c\x26\x4a\xa9\x8f\x46\xa3\xdb\x90\x72\x42\x9e\xd7\x6a\x75\xc8\xdf\xd4\xe9\x0c\x1a\x06\xb1\x04\xab\x43\xd3\x94\xef\x92\x59\xf3\x7c\x32\xda\x2a\x3a\x65\xdb\xe1\x08\xe1\xe0\x54\xec\x94\xe1\x3a\x84\xed\xf0\x11\xc9\x2d\x83\x59\x0b\xaa\xe3\x38\xaa\x03\xfb\xb2\x48\xab\x43\xc8\xe1\x24\xda\x92\x2b\xdb\x44\x1c\x47\x3a\x48\xd7\xcc\x38\x08\xdf\x3f\x28\x1c\x63\x23\xf0\x1c\xe1\x26\xa0\x94\xdb\x0c\x38\xec\xcb\x72\x98\xbd\x10\x7f\x32\x14\x4b\x15\xf9\xb2\xb8\x05\x5e\x88\x28\x1c\x3f\x2e\xf9\x9b\x4f\x09\x63\x71\x4c\x9a\xb5\x22\x1a\xc7\xd8\x2b\x11\x0d\x1d\x68\x4e\xb9\x11\xb3\xf0\x2c\x8b\x88\xeb\x39\x4a\xc7\x6b\x75\xe8\x3f\xa8\x61\xa4\x95\x36\x71\x71\x2a\x51\xe4\xd5\xe2\xa5\xa9\x64\x94\x77\xd7\xcc\x78\xe9\xd8\xb1\x97\x66\x5c\x72\xc9\x25\xa8\x95\xec\xe3\xef\xbc\xf3\xf8\xe3\xab\x57\xaf\xca\x9f\x37\x23\xf6\x6b\x19\xa3\x51\xaf\xd1\xe9\xf4\x7a\x13\x3e\xd1\x1a\xcd\x99\x3e\xe7\xd7\xe6\x8f\xa2\x3c\x57\xea\x99\xf2\x28\x13\x25\xdc\x2e\xcf\x13\x30\x51\x0e\x0a\x0b\x84\x0e\x71\xc6\xdc\x54\x23\x8d\x6c\x24\x47\x71\x94\x06\x8d\x26\xcf\x5b\x0d\x0c\x63\xb1\xa2\x48\x9b\xfe\x24\x63\xd0\xb0\xef\x1b\x8f\x1b\x29\xb3\x31\x60\xa4\x8c\x46\x4a\xcf\x73\x6f\x43\xea\x1d\xf1\x08\x45\xd4\x80\x81\xd5\x28\x44\xcd\x2d\xb4\x4b\x47\xe5\x34\x25\xac\xd2\x51\x39\x21\x7c\xb8\x46\x82\x4e\xf0\x34\x4c\x24\x5b\x29\xd6\xb7\xc3\x27\xfc\xda\x06\xff\x70\xfd\xc0\x14\xd7\x2f\x85\xbf\xfd\xbd\xca\x40\x3d\x7a\xe7\x9d\xa7\x51\x55\x43\x5f\x5f\x08\x3f\x10\x6e\xfd\xb0\x97\xe8\xf2\x06\xca\x40\xad\x47\xed\x2b\x05\xd3\x52\xd5\x9e\x92\x12\xa7\xdd\xe1\xd0\xb8\xcc\x38\x71\xbf\xc6\xeb\x73\x58\x81\xf5\x23\x24\x92\x4e\xce\xe9\xf9\x34\xe3\x7c\x9b\x33\x7e\x94\xd1\x6a\xb9\xf7\x50\xab\xe2\xaa\x2c\x45\x72\xb3\x12\xca\x41\x0f\xaa\x15\x1e\x4e\x39\x47\x89\x64\xf7\xc7\x67\x15\x07\xf9\x56\x38\xff\xbc\xcb\x7f\x73\xdf\x82\x25\xde\x91\x9a\x50\xdf\xee\xb5\x23\x63\xbd\xe3\xe0\x1e\x8f\x70\x6f\xb0\x81\x1e\x5a\xbb\xf8\x8a\x5f\x7a\x5e\x5c\xef\x3f\x74\x93\x07\xde\x73\xdd\x0b\xe4\x4c\xc1\xe5\x94\x87\xc2\xfe\x90\x06\x79\x34\x6e\x16\x05\x20\x5a\x1d\x92\x27\x1d\xfb\x0e\x43\x69\x28\xcd\xa7\x19\xe4\x25\xbc\x4d\x5a\x45\x5a\x24\xa9\x25\x9b\x9c\x3c\x1d\x9f\xda\x81\x9c\x9a\xdf\x8d\xac\xa6\x9a\x75\x42\xff\x3e\x78\x54\xd8\xc5\xf4\x9d\x18\x35\xe4\xa7\x7e\x25\xc6\xa4\xf5\x94\x8e\xda\xc8\x8e\x01\x4e\x50\x8e\xf4\xd0\xe2\x54\xd2\x48\x01\x97\xc5\x12\xd4\xe9\x62\xb5\x11\x96\xf5\x02\x50\x4b\x19\x3d\x55\x9e\xaa\x8f\x32\x06\x8f\xcf\x33\xd1\x33\xdf\xb3\xc2\xc3\x6a\x69\x8f\xc7\xce\xdb\xcb\x3e\xca\xd8\xdf\xe5\x2b\x3f\xca\xf0\xef\x81\xe1\xb2\x37\xb5\xe7\x9d\x14\x9c\x90\x4f\xec\x73\xe0\xf4\x4c\x16\x31\x58\x4d\xca\x8f\x4b\x59\x87\x7c\xfc\x3d\x47\x3b\xa4\x41\xe3\xa8\x8d\x3b\x5a\xbb\x85\x3f\xac\xdc\x78\xc6\x9c\x58\xf3\xf5\x3f\x5f\xbe\x52\xd8\x93\x6a\xee\x2c\x0f\xb7\xb4\x0e\xd6\x35\x5c\x39\xbf\xaf\x97\xb9\xf5\xc1\x7a\xfb\xf4\x2e\xe1\xab\x15\x83\xa7\x9f\x6b\xb7\x65\x5a\x97\x5f\x34\xb8\x67\xc6\xca\xb9\xb5\xe1\xa5\x42\x79\x6b\xc3\x3b\x67\x5e\x80\xcf\xe7\xa6\xdc\xd4\xe3\xcc\x5c\x50\x02\xde\x4b\x6d\x37\xb0\x28\x88\xe3\xdd\x0e\x07\xb2\x1e\xd6\x52\xaf\xd9\x1b\xf7\xf6\x78\x07\xbd\x2b\xbd\x5b\xbc\x77\x7a\x9f\xf5\x6a\xb2\x5e\x38\xc5\xbb\xd1\xbb\xcf\x4b\xc7\xbd\xd0\x8c\xee\xad\x44\xd7\x8f\x78\xb3\x5e\x6e\x46\x00\x61\xd3\x08\xbb\x01\x61\xf7\x22\xec\x7b\x5e\xed\x11\xef\x31\x74\x8b\xf6\xa6\xfa\x26\x8d\x5b\xe5\xbd\xcb\x4b\x05\x10\x82\x8a\x23\xd0\x16\x04\x38\xe6\x65\x81\x17\x1a\x69\x03\x6f\xd2\x6b\x3e\xca\x20\xf9\x32\xb2\x7e\x16\x45\x61\x2c\x65\xa2\x3e\xce\x98\x4d\xd0\x40\x9b\xdc\x29\xe4\xa5\xba\xdd\x8e\x8f\x32\xee\x77\xc4\x05\x10\x7c\x7e\x85\x98\xad\x1f\xfd\x81\x7e\x59\xc9\x1a\x08\x1a\x4f\x88\x6d\xef\xea\xd5\xb1\xd5\xc8\x9c\x62\xf3\x6a\xb5\xa9\x93\x63\x91\x17\xb1\x48\x2a\x2c\xe5\xe4\x3d\xa2\xfb\xf1\x49\x7c\xad\x14\x6c\xae\x9c\xe7\x4c\xed\x99\xd3\xa2\x79\x93\x5d\x78\x55\x7b\x3f\xdf\x39\x46\xf3\x7d\xb7\x91\xfe\xc3\x88\x99\x09\xe1\x36\x28\x98\xa3\x67\x9e\xdf\x39\x4a\xd7\x24\x3c\x64\xaa\x82\xb3\xfa\xc8\x3b\x00\xd9\x1e\x2a\x0a\xaf\xb7\xf0\x74\x18\xbc\x3d\x54\x4a\xe2\x55\x2a\xdb\x03\xbf\x20\xd7\x22\xe0\x75\xf1\x5a\xf6\x68\x36\x45\xb1\x70\x0b\xba\x56\x25\xe3\xb2\xdf\x64\x27\x52\xe3\xe1\x46\x0b\x4f\xdd\x93\xbd\x46\xba\x26\xa0\xb2\x9f\xe1\xb2\xec\xf2\xec\x43\xf8\x1a\x9a\x9b\x91\x38\xd7\x0c\x7b\x29\xb2\x92\x37\xa7\xd2\xb1\xa0\xc6\xed\x6e\xb4\xd0\x65\x61\xbf\x3f\x12\xb1\x03\x87\x23\x1e\xc7\xd6\xb2\x02\x84\xcb\xc2\x83\x99\xa0\xdd\x5c\x16\x28\xa3\x0c\x74\x59\x99\xab\xae\x2e\x3e\x98\x89\xd5\xd5\x45\x06\x33\x75\x0e\xce\x38\x98\xd1\x9a\x39\xa8\xa5\x39\x97\x7f\x30\xe3\x71\xb9\x1c\x83\x19\x97\x59\x5a\x4e\x02\x84\x21\x95\x13\xee\x73\x3c\x2a\xea\x15\x22\xc1\xb6\xc2\xe3\xb8\xc4\xd3\xdd\xf0\xb2\x8e\x05\x04\xf1\x61\x6e\xc9\x88\x74\x96\x9b\x9d\x1c\x60\x95\x8c\xc4\x90\x93\x92\x44\x5e\x7d\x34\x44\x93\xb3\x7e\x70\x02\x32\xf8\xef\x23\x9f\xc0\x6e\x58\xb9\x63\x5f\x55\x3f\x33\x73\xf5\x93\xbf\x5b\x3c\xa7\x73\x83\x9e\xae\xa9\x9d\xc8\x8e\xb9\x6d\x79\xdb\x1f\xab\xc7\x25\xc7\xd1\x7f\xec\xb8\x66\x5f\x4f\xef\xc4\xae\x1f\x77\xeb\xaf\x80\xbb\x5f\x7d\x1a\x7a\x61\x4b\xc3\xc9\x6b\x47\x0a\x27\x2f\xfb\x85\x1e\xce\xb4\x75\x9d\xb8\x5e\x27\xbc\xb4\x4c\x38\x74\x96\xf0\xa8\x7e\x97\x70\xbc\xcb\x8e\xe4\x74\x4c\xf6\x42\xf6\x4c\xf6\x15\x10\x03\x4d\xa0\x0d\xdc\x9e\x9a\xe5\x6c\x4b\xf0\x8c\xc6\xa1\xd1\xb2\x2d\xad\x2e\xc6\xcd\x30\xb4\xc3\xee\xf6\x78\x4a\xca\xed\xb6\x78\x90\xa2\xeb\x75\x5a\x83\xb1\xca\xeb\x35\xb6\x8f\x28\x6f\x6d\x6d\x6b\x8b\x5b\xe3\x0b\x33\x25\x2e\x97\xd3\xe9\xb1\xfb\xac\x4c\x7d\x22\xd1\xd2\x12\x0c\x86\x40\x08\x8d\x1c\xad\xe3\x91\x91\xa1\xa8\x2a\x9c\x88\x4d\x7e\xd2\x71\x90\xbc\xe9\x26\x7e\x47\xb1\xe8\xc1\x26\xf2\x4d\xb9\x26\x6a\x3d\x9b\x12\x96\x8a\xdf\xe4\xfc\x6c\x78\x7c\xf0\x0f\x2c\xdc\xb6\xca\x0e\x88\xb8\xd1\x8d\x3e\x2e\x37\x1d\x6a\x89\x44\xa1\x8b\x9c\x1a\x9d\xa0\x91\x5d\x75\xb8\xa1\x09\x52\x76\x97\x1b\x46\xa2\xd4\x1d\x7d\x13\x7a\xa6\x8f\x6b\xa9\x9f\x3b\xfd\xec\xb3\x57\xbe\x06\x2f\xfb\x4f\x68\xe4\xf4\x51\xab\xc6\x4e\x9f\x38\x67\x72\xcb\x8c\xea\xa6\xa1\x97\xbb\x66\x9c\x76\xb0\x6b\xd2\xcc\x51\xab\x85\xaf\x84\x41\x3f\x7c\xef\x97\x9f\x6e\xec\xf3\xd7\x51\x8d\xcd\x23\x1c\xfa\x8b\x7e\x6e\x74\xef\xfb\xd3\xb8\x4f\xb7\xfe\x1b\xae\x3f\x7c\xf1\x46\xed\x35\x37\x1b\xad\xc2\xde\x17\x02\xce\x93\x0f\x7b\xdb\x6b\xdf\x16\x1e\x0c\xc7\xa9\xb2\xf3\x32\xf4\xdd\xf6\xdf\x09\xcf\x0b\x9e\x86\x10\x93\x32\xd0\x84\x07\x71\x5e\xf9\x33\xd9\x89\xa0\x1e\x2c\x4f\xb9\x2d\xac\xdf\xdf\x10\x05\xfa\x7a\xda\x60\x88\xd5\xd4\xb8\xdd\xf1\x06\xbd\x86\xd6\xec\x87\x96\x94\x2b\xc3\x01\x9a\xae\xab\x8b\x21\x9e\xf3\xa2\x81\x2b\xf3\x32\x86\x1a\x47\xcd\x7e\xe8\x7a\x34\x63\x71\xd8\x95\x93\xee\x09\xcb\x89\x4b\x97\x39\xd3\x25\x6a\x40\x77\x42\x3e\xb2\x0a\x92\xa3\xf5\x68\x7c\x6a\x06\x4f\x4b\xa3\x11\x2a\x07\x56\x34\x5e\xe4\x7a\x0b\x3e\x3c\x90\xa1\x64\x8e\xa3\x1f\x49\x6e\x4f\x37\x84\x46\x24\x6b\x27\xac\x6a\xee\xb8\x61\xda\xe8\x99\x23\xd0\x20\x5c\x26\x7c\x28\xbc\x84\x07\xea\x83\xef\x5b\x66\xb4\xde\x3a\xe3\x1e\xe1\xc4\x4d\xe7\x2c\x5f\x72\x9e\x1e\xae\xa7\x46\x9e\x75\xbe\x4e\xd8\x7b\xcd\xc4\xe9\xc2\x83\xbe\xae\x47\x85\x37\xc2\x71\x18\x85\x00\x0f\x4e\x33\x1a\x96\x58\x7c\xbf\xf0\xf0\xeb\x77\xfc\xb5\x86\x1a\xeb\x19\x85\xfc\x81\xa3\x48\x0e\x71\x7c\x1b\x00\xcf\xa5\xce\x73\x3b\xec\x06\x46\xaf\xf7\x78\x9c\x66\x16\x96\x51\x94\xd7\xef\x2f\x67\x83\x66\x6b\xc0\x1a\xb7\x22\x0f\xd5\x6a\xb5\x1b\xec\xe7\x66\x80\xc9\x62\x2a\x37\xa1\xbf\x4d\x26\x83\xbb\x0c\x96\xad\xcd\x38\x20\x3e\x4e\x26\x6e\x48\x1b\x18\xb3\xa1\x07\xfd\xda\x60\xd8\x4b\x8e\xea\x39\x66\xd0\xe8\x69\xe4\x15\x42\xc6\xe3\xf7\xfa\xd7\x66\xbc\x1e\x46\x7f\x6e\xc6\xcc\x43\x33\xcd\xf3\xc8\x45\x5a\x9b\x61\x38\x20\xad\xf6\x8a\xa7\x94\x90\x3f\x6c\xc4\xeb\x45\x17\x56\xcb\x9c\x27\xd9\x16\x09\x27\x1f\xd8\x8b\x70\xaa\xe3\xf3\xec\xe4\xf0\x74\x5a\x14\xd1\x20\x11\xd1\x20\x2f\x1e\x00\x1d\xec\xa1\x42\x81\x3b\x6e\xb9\xcf\x48\xef\x4d\x2d\xd0\x2d\xbc\xfc\x67\x8b\xa0\xbd\x2d\x33\x3a\xc3\x09\x5f\x06\x3f\xb1\x7d\x52\xfe\x88\x71\x68\x93\xf1\xee\xf2\x3b\xe0\x46\x7a\x6e\xe9\x78\xe1\x96\x2f\x4d\x43\x47\x7f\x2e\x9c\x7f\xfd\xd3\x67\x3c\xe1\x1d\x3f\xde\xfb\x84\xe8\x3b\xe1\xbc\x92\x14\xe2\x97\x2a\x70\x5f\x6a\xb0\x2a\x14\xa2\x4b\x4b\x6b\xc2\x91\x0a\xa0\x37\x99\x6d\x8c\x43\xa7\x03\xa0\xa2\xc2\x81\x82\x77\x87\xa3\xa6\x5a\x0f\x22\x60\x6d\xc6\x14\x31\x87\x2b\xc2\x6b\x33\xb6\x8a\xf2\xc8\x94\xc8\xc2\x08\x6d\xae\x08\x54\xf4\x54\xa4\x2b\x18\x2d\x1d\xa9\x88\x54\xb0\x6e\x77\x60\x6d\xc6\xec\x0b\xf8\x28\x2d\xed\xf3\xb9\x71\x54\xc9\x52\xeb\x32\xac\x07\x48\x36\x15\x99\x78\x75\x24\x80\x0d\x81\x3c\x26\xf9\xce\x91\x22\x8d\x92\x22\x13\x97\xa7\x39\xe4\x7b\x20\xfd\xd4\x0d\x5b\xa2\xa1\x64\x02\x7f\x90\xf1\xad\x0c\x36\x61\x89\x24\xef\x02\x39\xd1\x7d\x77\x82\x87\x07\xf9\x5d\xd4\x39\xe1\x1f\x6f\x71\x2e\xc8\xcc\xa5\x8e\xd8\xee\xae\x3c\xdb\x86\x22\x4e\x0b\xe4\xba\x2e\x3e\xaf\x75\xb6\x76\x52\xe6\xb2\xcd\xd0\x67\x13\x4e\x70\xc7\x6c\x14\xff\xc8\xe6\x43\x17\x8e\xeb\xbd\x71\x5a\xd9\x92\x33\x96\x54\x45\xdf\xf9\x87\xd9\x27\x1c\x79\xa1\xe5\xc3\x57\xd1\x9f\xe4\xec\x6f\xe1\x3b\xf6\x4d\xe6\x0e\x14\xd6\x6c\x4d\x4d\x2a\x45\x0e\x96\x53\xab\xd3\xb9\x9c\x78\x55\xa6\xbc\xdc\xa4\x41\xe6\x30\x58\x51\x51\x55\x0f\x40\xcc\xe4\xac\x72\x56\x35\x36\xd5\x23\xc9\xaa\x77\x84\xc2\x61\x3f\x53\x5e\x5e\xca\xda\xed\xa5\xa5\x94\xc5\x6f\x59\x94\xf1\xd3\x41\x8f\xc7\x85\x34\x3b\xed\x74\xe8\xb5\x1a\x07\xe8\x79\x35\xd1\x43\xe2\xa3\x83\x3d\xa2\x0e\x57\xfd\xa7\xac\x97\xdb\xda\x13\x05\x6b\x66\xea\x73\x93\x25\x73\x69\xa6\xe8\x10\x1d\x82\xf6\xd6\x16\xd1\x76\x06\x89\x7e\x17\x5f\x8c\xb2\x27\x68\xe9\x71\x3a\x3e\x90\xdc\xde\xca\x1c\x18\x97\x18\x35\x8f\x3f\xfd\xf8\xed\xab\xa0\x6b\xa4\xab\xbf\xe1\x82\xca\xe5\xc2\xbf\x7f\x91\x31\xc2\x71\xf4\xb8\x9d\x8b\x27\x2e\x32\xfe\x75\xd5\xd6\x89\x99\x39\xcb\xac\x83\xe7\x1a\x85\x4b\xce\x70\x51\x6f\x2c\x1a\xbf\xdd\x3f\xf4\xaa\xf0\x1d\x7c\x07\x2e\x3b\xb7\x6a\xd1\x15\x83\x43\x7b\xe8\xa9\x25\xa3\x76\x9f\x36\x38\xb9\x1f\xae\xce\x82\xe8\xca\xc5\xe1\xc1\xa1\x2f\x3c\xa3\xa8\xf6\x73\x51\xf4\x22\xe6\xa8\x47\x72\x18\x06\xd5\xf8\x5c\x29\x90\x00\x7f\x48\xad\x8b\x57\x45\x69\x86\x6a\x70\xd7\xd5\x34\x31\x2e\x4f\x6d\xac\x91\x49\x94\x04\x2a\x42\x80\x41\xc2\x99\x28\x81\x25\x65\x4c\xa4\xba\x9e\x69\x60\x09\x03\xda\x75\x0d\x2c\x6b\x77\xd1\xba\x32\x5d\x4b\x73\x59\x89\xdd\x69\x1f\xcc\x00\xa6\x89\x36\x18\x0d\x83\x99\x50\xa4\x86\x36\x56\x54\xd7\xd1\x16\xab\x65\x30\xe3\x0e\xd4\xd3\x56\xb3\x15\xea\x69\xa3\xd5\x68\xd5\x34\x78\x9d\x34\x0e\xdf\x06\x33\x1a\x5b\x82\xb2\x61\x17\x5c\x52\x68\x62\xb0\x81\x25\xce\x8d\xd9\xcd\x9d\x90\x7f\x2b\x06\xb4\x1d\x5d\x91\x19\xcf\x2d\x2f\xac\xc9\x7f\x89\xbf\xf0\x9b\x28\x21\x14\x38\x89\x47\x04\xe1\x83\x2d\xd1\x07\x8f\xb6\x3d\x28\x9d\xb7\x88\x85\x34\xc1\x87\x83\xd1\x10\x8b\x6e\x86\x13\x51\x18\x72\x33\xcf\xcf\x5c\xfb\xa5\xb0\x70\xf4\x5e\x83\x10\x32\x3c\xdc\xf7\x84\xf5\xc9\xf2\x27\x6d\x4f\x8e\xbc\xcf\x08\x1f\xfe\x08\x96\x8e\xdc\x6b\x84\xef\x18\x1f\x1e\xf9\x84\xed\x89\xf2\x27\x6c\x3f\xf2\x70\x20\xf3\x21\x95\x59\x50\xfe\xa6\x60\xbb\xeb\x3c\x6a\x59\xa9\x1d\x7e\x22\x94\xa2\xcf\x25\x58\x7c\xe1\x65\x4b\xf6\x2f\x81\x6b\x90\x60\xc7\xf0\xcf\xf1\xa5\xc2\xf5\xe8\xc2\x92\xfd\xfb\xf7\x2f\x39\x3e\x74\x7d\x94\xc4\x5f\x87\xb2\x5f\xf0\x17\xa0\xf1\x9f\x01\x06\xc0\x8b\xa9\x15\xcd\xc1\xc6\xca\xca\x81\x99\xe1\x70\xac\x31\xd3\xdd\x96\xec\xe8\x68\xf1\x05\xdc\xfa\x69\xd3\x02\x19\xba\x86\xa2\x26\x5a\x6b\xac\x0b\x06\x81\x06\x89\x2e\x8d\x54\x19\x4d\x83\x40\x47\x5b\xc7\xda\x4c\x4b\xdb\xcc\x4a\xa4\xde\x66\x22\xd7\x0f\xb4\xcd\x9c\xd9\x06\xe8\xba\x9a\xba\x81\x73\x33\x75\xb1\xb5\x99\x3a\x2e\x5c\x53\x55\xb3\x36\x53\xe5\x19\x39\xde\x31\x7e\x6d\xa6\xa1\x2f\xd5\x47\xf5\xf5\x95\x38\x4a\xf0\xf2\x61\x5c\x54\x6e\xd2\xb8\xe3\x78\x1f\xb8\xb1\xbc\xcb\x6a\x2f\x4f\x0b\xca\xb9\x51\x95\x01\x97\x3e\xd8\x84\xe3\xcb\xc4\xd9\x56\x1f\x44\xeb\xc6\xe7\x8a\xe1\xc7\xbc\x51\xf9\x54\xf7\x50\x92\x8b\x49\xa7\xed\xe3\x39\x20\x0e\x23\x8f\xf7\x08\xe0\x13\x55\x95\x33\x9b\xe5\xc3\x6d\xeb\x21\x79\x9e\xc9\xca\x07\xec\x71\xb7\x2e\xbd\xa0\x72\x94\xcd\x98\x0a\x35\x74\xcd\x3f\x67\x62\xf5\x23\xf7\xf5\x5e\x1f\x9d\xb2\x76\xc9\x19\xfc\xc8\x25\xfc\x15\x6f\xaf\x9a\xb0\xce\x28\x98\x8d\x03\xaf\x2c\x32\xc0\x3b\xbf\xf9\x74\x4c\xcf\xec\x3b\x97\x87\x37\x5b\x37\x8f\xe4\x7c\xee\xda\xd6\x92\x51\x76\x77\x6f\xa2\x6d\x8c\x27\x36\x7e\xcf\xbd\x27\xf7\x07\x6e\xbd\xe5\xf4\xc1\x4a\xea\xa0\xff\xd5\x29\xa5\x15\x75\x55\x89\x8a\x58\x72\x7c\xfd\x45\x17\xfb\x9d\x4d\x93\x67\x7a\xe3\x70\x75\xf4\x74\x61\x16\x9e\x44\x66\x5d\xe9\xf8\xdb\xef\x1d\x7c\x6e\xb4\xfe\xe8\x1b\x0b\x84\xeb\x22\x9e\x6a\x9f\x79\xf3\xa4\xfa\xea\x86\x46\x67\xa0\xc4\xdb\x75\xf5\xea\x4b\xfa\xf7\x3d\x7b\xd6\xcf\xb0\xaf\x1a\xcf\x7e\xa1\xb9\x82\xac\x15\xb5\x34\xe1\x9c\x5e\xb3\x58\x7c\x08\x11\x07\x62\x38\xcf\x32\x9a\x63\xbc\x67\x2d\x8e\x24\xac\x15\xb4\x83\xa3\xa9\x8b\xda\x6b\xe3\x3e\xc6\x9b\xf4\x3a\x6d\x56\x13\x63\x74\x19\x93\xba\x46\x6d\x53\x53\x22\xd1\x80\x4c\x57\xc0\x90\x2c\x8f\x55\xb5\x32\xcd\x81\x40\x99\xb6\x99\x67\x68\xc0\x44\x35\x9a\x60\x4d\x75\x0b\xd3\x5c\x51\x11\x8d\x36\x97\xf9\xeb\xeb\xda\x92\x2e\xed\x88\x8e\x32\xaf\xb7\xc2\x85\x95\x55\x7b\xab\x9e\x37\x5b\xcc\x83\x99\x86\xda\x2a\xc6\x82\x42\x34\xda\xee\x40\xb2\x58\xee\x03\x8e\xb8\x03\x5a\x1c\x16\x87\xb1\xd2\x43\x37\x27\x93\x5a\x23\xf6\x1d\x12\xe2\x29\xb1\x48\xce\x06\xac\x52\xc8\x2b\xcd\xa8\xfc\x5d\xd6\x74\xd2\xfa\x32\x9a\xf6\x26\xab\xec\x81\x29\xfe\x17\x09\xb6\xa4\xef\x72\x90\x8c\xe5\x0a\xe9\x77\xac\xe8\xb0\x04\x26\x83\xd8\x00\xd0\x44\xe6\x90\xec\x25\x64\xf9\x43\x01\x34\x11\x3c\x37\x32\x10\x10\x7d\x4d\x86\xb8\xd3\x1e\xb7\xbd\x3e\x0b\x6a\x6c\xc2\xd1\xe3\x0b\x16\x1e\xfd\xd7\x92\x49\xc2\x43\x36\xd8\xe4\xfd\xde\xf6\x97\xd6\xcb\x8c\x54\xb3\x71\x67\x03\x34\xef\x5f\x3c\x06\x7a\x76\xed\x32\xc2\x7d\xc6\x0b\x86\x3e\x39\x63\xda\x5b\x43\x3b\x17\xcd\xf9\x9f\x13\xbf\x0a\x95\xc1\x33\x7c\x55\x43\x97\xfb\x2a\xe9\x65\x48\xce\x86\x4e\x52\x2c\xfe\x48\x32\x88\xa5\x0f\x5e\x2a\x6c\x10\xbf\x0f\xad\xde\x8f\xff\x09\xbb\x7a\x46\x8c\x20\xcf\xe6\xab\xb3\xef\x31\xdb\x98\xeb\x40\x05\xe8\x05\x5d\x29\x9d\xaf\x57\xaf\xef\xad\xab\x83\xbd\xdd\x23\x8d\xf0\x34\x74\xad\x15\x9e\x09\x32\xa0\x17\x0e\x22\x3b\x63\x27\xdf\x21\x5c\x94\x7b\x62\x8a\xc6\x20\x6e\x6d\x8f\x5b\x0e\x34\x36\x54\x4b\x07\xa7\x76\x53\x89\x26\x27\xe1\xe9\x0e\xd8\xd4\x6a\xb3\x27\xb1\x8e\x77\x72\x94\x09\xd2\xa2\x8a\x37\x51\xa1\x8a\x16\xbb\xc8\xd9\x28\xf4\x34\x43\x72\xc0\x5d\x29\x4c\xd2\xa3\x84\x73\x3a\xe2\x9a\x59\xb4\x6b\x8a\xc5\xd0\xc7\xf9\x2a\xde\x9c\xba\x3c\xed\xe5\xe8\x69\x76\x3b\xdf\x3b\x69\xd5\x75\x1d\xcd\xdc\x2c\xa6\xbb\x46\x6b\x1d\xc5\x95\x94\xff\x6d\xf6\xb9\x53\x78\x96\x9b\x69\xb2\x18\x6f\x79\x24\x52\xa5\x6b\x81\x5f\xd9\xdc\x5d\x3a\xe1\x72\xaf\xc5\xad\xbb\x1d\xce\x87\x6c\x83\xbd\xa7\x74\x8b\xb0\xf8\xdf\xef\xd1\x3f\x54\xd6\x7b\xaa\x84\x92\x92\x64\x89\x11\x5e\x14\xb0\xda\x74\x87\x84\xd3\x7e\xd1\xe0\xea\xf6\xc2\x24\xd5\x8b\x73\x81\xd1\xd9\xe7\x84\x0f\x99\x45\xec\x75\xf8\x79\x08\xe2\xd5\xab\x53\xe3\x2b\x9c\xee\x52\x06\x05\xa2\x65\xda\x78\x3c\xc0\x20\xb7\xbd\xac\xac\xb1\x1a\x98\xcd\x0d\x8d\x8c\xa7\xc4\x93\xce\x04\x4a\x4a\xec\x7e\xbf\x77\x72\xc6\x0f\x2a\xc2\xf6\x70\x3a\xe3\xb4\x5b\xe2\x5a\x6d\xad\xa1\x76\x2a\x1a\x23\xf4\x31\xb8\x34\xec\xe4\x8c\xc6\x29\x0e\xd6\x81\x98\xa4\x52\x64\xe7\x55\x0a\x8f\xf2\xdf\x6d\x14\x7d\xac\x26\x99\xd3\xf0\x81\xab\x41\xde\x8e\xf5\x46\x54\x3a\x90\x1c\x9f\x6a\xe9\x6e\x95\x8e\x2b\xc6\xee\x16\xc4\x3a\x87\xbc\xe4\x82\xdf\x2e\x4e\x79\x18\x50\x52\xf3\xe8\xe9\x06\xe1\x31\xbe\xe3\x57\xe3\xd7\x6c\xbe\xf4\x1f\xd7\x9f\x3d\x92\x33\xbd\x6e\xfb\x93\x6b\x87\x01\x3e\x1a\x5d\x62\x13\x06\x1c\xd3\x03\x7d\xe7\xf5\x75\x34\x06\x57\x54\x0b\x1f\x6e\xd9\xc2\x2e\xfb\x51\x57\xd2\x79\x43\x7a\xe6\xbe\x6d\x0f\xc3\xfa\xbd\xbe\x71\xf3\x96\x5e\xe6\x19\x79\x74\xa9\xf0\x89\xc3\x77\xfd\x37\x1b\x96\x5e\x38\x75\x84\xe8\x8f\xfd\x2b\xfb\x05\x93\x24\xfe\xfb\xaf\x53\x4b\x1d\xee\x52\xda\xef\xaf\xf3\x39\x9d\x06\x48\x73\xc8\x5b\x8f\x37\x84\x0d\x86\x06\x37\xfa\x8e\x1c\x54\xce\x5f\x07\xeb\xd6\x66\x4a\x21\x7e\x9b\xfb\x18\x47\x6b\xe3\x10\xe2\x1d\x4f\x34\x07\x51\xf8\x58\x55\x15\x5c\x9b\x19\xac\x84\xa0\x12\x85\x92\x95\x95\x55\x25\x5a\xeb\xda\x4c\xb9\xa9\xc1\x94\x32\xd1\x53\x4c\x0b\x4d\xab\x4c\xcf\x99\x5e\x33\xb1\x26\x93\x96\xc7\x6b\x2e\xe4\x64\x44\xd1\x31\xcb\xf3\xcc\x56\x2f\xc8\xf7\xcd\xe4\x35\x19\xb7\xbc\xd9\xc1\x8d\x17\x67\x12\x64\xb4\xb0\xb7\xaf\x38\x61\x58\x48\x4d\x10\xff\xe4\x25\xcd\x4b\x63\x45\xdd\x85\x84\x91\x3f\x47\x6f\x3e\xc7\xba\x2e\x0d\x2b\xdf\x3e\x7d\xf3\xf4\xfa\x0c\x35\x7e\xd9\xda\xdd\x0d\xd0\x67\x15\xfe\xce\x5b\x29\x18\xb0\x09\x1f\x31\x2b\xe6\x6e\x98\xd9\x9e\x69\x7b\xf0\xa1\x57\xdf\x80\xeb\xa8\x69\x53\x52\x4b\xa0\xf6\x47\x8b\x55\xf8\x70\xeb\xc8\xb7\x0e\x2c\x71\x0e\xfa\x96\x0c\xec\xb8\x7d\xca\x3d\xc2\x5f\x9a\xfe\xf9\x51\x69\x89\x38\x76\xe4\x8c\x25\xa4\x0b\x2b\xc0\xe5\xa9\x51\x5a\x4e\xa7\x63\x3d\x5e\x5f\xb9\xdb\xed\xb2\x54\x98\xcd\xe8\x5e\xc0\xe7\xb3\xba\x58\x57\xa8\x32\x60\x73\xeb\x34\x2e\xab\xd5\xac\x33\x20\x07\x21\xe8\xe5\x35\x3c\xf2\xc7\x2c\x1a\x0d\x6d\x37\xd0\x3e\xc0\xd2\xec\x60\x86\xb6\x89\x4e\x3c\xe6\x26\xb2\x76\x48\xfe\x50\xd4\x16\x5e\x9f\x52\xe5\xf3\xb6\x8a\x7e\xbb\xe4\x95\x11\x6b\x15\x56\x7c\x03\xc9\x23\x80\xa2\x62\x72\xa3\x21\xc1\x47\x0b\xc2\x10\x0f\xdf\x78\xc4\x30\xb4\xce\xf0\xf0\xdc\x03\xb6\x03\x03\xf7\x19\xa9\xf3\x8c\xf7\xcd\xa3\x52\xab\x8d\xf0\x7e\xe3\xb5\x42\xb4\x01\x3e\x6c\x13\x6e\x06\xd9\x2b\x0d\xc2\x25\xc2\x07\xad\x8d\x8b\xb1\xc9\xa0\xe8\x25\x94\x89\x68\x99\xef\x28\x03\xd1\x3c\xd3\x17\x2d\x19\x1a\xf2\x8e\xa7\x96\xe2\x77\x1b\xc5\xf3\x31\x88\xcf\x75\x43\x6a\x22\x0a\x45\x4b\x19\x9b\x4d\xef\xf5\x52\xe1\xca\x20\x43\xd3\x5a\xfc\x32\x90\xb7\xbc\xac\x1c\xf9\x4b\x95\x9e\x50\xa8\xc2\x4e\x39\x10\xd3\x94\x06\x4b\x2a\x4a\x3c\xae\xb0\x13\x38\x1d\x15\xc0\xe3\x70\x78\x40\x05\xa3\x2b\xb3\x19\xb4\x5a\x9d\x8d\xd1\x31\x0b\x33\x3a\x5a\x1c\x0d\xd1\x27\x45\x62\x83\xcc\x78\x3c\xa7\x9e\xf3\x7f\xaa\xc4\x8d\x28\xee\x84\x74\x14\x38\x1e\x0d\x7c\xae\x62\x08\x3f\x9e\x44\xf1\x34\xb2\xd6\x49\x33\x95\x34\xcb\x46\x9b\xef\xa1\x20\x70\x1c\x9f\xda\xd5\x76\x6d\xd9\x84\xd9\xa3\x98\xf4\xa8\x39\x46\xdf\x2f\x1b\x3a\xda\xbf\x72\x90\xff\xa6\xbf\x66\x18\xaa\x37\xbc\xd5\xf9\xb5\xe3\x6b\x07\xd5\xb1\x6a\x11\xfc\xbd\x89\x3b\x01\xd7\x0b\xd7\x9c\xe0\x0c\xc2\xd3\x0b\x57\x2d\x5c\x83\x3e\x42\x35\x71\x8f\x66\x2d\x5a\xb5\x68\x0d\x60\xc1\x3c\xe1\x4c\xcd\x41\xf6\xcf\x00\xe7\xec\x1c\x03\xa6\x81\xf9\xe0\x96\xd4\x94\x39\x5a\x7a\xfa\x74\x13\xd2\x2e\x9d\x76\xfb\x48\x97\x69\x52\x6d\x6d\x3c\x9e\x68\x68\x0f\x8d\x8d\x46\x43\x0d\x26\x2d\x3b\xb0\xa0\xb5\x7f\x61\xa6\xb5\x66\xca\x60\xa6\xc6\x66\xef\x0c\x74\x0e\x66\x7c\xa9\x92\xc0\x74\x7a\x26\x30\xcc\x1c\xcc\x98\x46\xf6\x1a\xb8\x79\xc8\x16\x72\x36\xd0\x8b\x1c\x52\x87\xa8\x7e\x0e\xe2\x50\x99\x74\x5f\x14\x9f\x44\xe9\xab\x92\x1a\x22\x21\x74\xee\x49\xaa\xec\xb4\x27\x54\x4f\x3f\x1a\x1b\x82\xc8\x95\x91\x14\x10\xd6\x3f\xc9\x6e\x2a\x89\xe4\xa7\xa5\x35\xdc\x0d\x93\x6e\x8e\xc7\xee\x0e\xc5\x90\x27\xe1\x51\x1e\x49\x97\x74\xa0\xbd\x0b\x36\x23\x0f\x88\xe2\x29\x1e\xeb\x26\x1b\x6c\x96\x96\x76\xd0\x1f\xac\xf2\x95\x3e\x7b\xd6\x75\xfd\xdd\x9b\x07\x67\x2d\xbb\xf8\xf4\xa6\xc6\x86\x48\x6a\x7a\xeb\xca\x37\xa6\xbe\x06\x2b\xba\xd7\xcf\x5e\xd6\x32\x6b\xeb\xd1\xf3\x1e\x14\xde\x67\xee\x7f\xf9\xde\xe9\xdd\xd1\xf2\x84\xf0\x61\xa2\xfe\xec\xe8\xc3\xbf\xb8\xf5\xc5\x93\xd9\x4d\xe7\xb5\x2e\x6c\xef\xe9\x38\x63\xf5\xe9\xbb\x16\x53\x27\x13\x35\xf5\x23\x9a\x63\x75\xed\x27\x0e\xd6\xb7\x56\xb5\x37\x56\xce\x6a\x6e\xeb\x68\x9c\xde\x3b\x7e\xb6\xfe\xe4\xd3\x7f\x7c\x62\xb4\xa1\xa7\xea\xec\x01\xae\x7b\x76\xb2\xb9\x6e\xa5\x79\xdb\x89\xdb\x9e\x11\x1e\x7c\x02\x76\x6c\xd9\x57\xf2\xcc\x8d\x0b\x4e\x7b\x04\x3e\xb1\xed\xaa\xdb\x61\xf8\xa5\xef\x1d\xb3\x84\xef\x7f\x10\xfe\x7e\x71\xfa\x0e\x58\x2d\x7c\x97\x59\xbc\x6c\xe6\x9c\x65\x2b\x78\x7b\xa5\x2f\x14\x24\xef\xb2\x65\xcf\x17\xc6\xd1\x27\x91\x0e\xd4\xa2\x98\x61\x4d\x6a\x84\x8f\x0f\xb0\x6c\x83\xa5\xde\x56\x1f\x00\x1e\x4f\xc0\x16\x66\x1a\x9b\x0c\x46\x63\xa3\x59\xa7\x0b\x19\x43\x35\x0b\x33\x91\x90\xcf\xd2\xa0\x37\xf1\xbe\x06\xa3\xcf\x69\x32\x19\x9d\x4e\x6a\x61\xc6\xc9\x18\x6d\xe4\x1d\x31\x62\x02\x6c\xed\xf2\xde\xac\x1e\x79\xd1\x4c\xd6\x65\xb2\xd3\x81\x83\x6e\xd1\xcd\x6c\x16\x1d\xcc\x6e\x08\x69\x1e\x45\x53\x49\x4a\x7e\xde\x84\xe6\xc3\x65\xc3\xbf\x94\xe5\x70\xfc\xc6\x41\x94\xde\x38\x73\xcc\xc4\xf0\xdc\x65\x43\x77\x6c\xbe\xf3\x62\x78\xd3\x95\xcb\x57\xfc\xed\x99\x15\x67\xb5\x2d\xba\x20\x9e\x5a\xf9\xfb\x0b\x17\xf4\x47\x53\x6e\xbb\xb7\x7e\x42\xac\x9a\x59\x7b\xf6\xe6\x8b\x2e\xbe\xfb\xb2\x7f\x9e\xbc\x08\x76\xbc\x43\xd5\x09\xaf\x6d\x87\xe3\x5f\x78\xf1\xa3\x55\x73\xbb\x6f\xdd\xf7\xe4\x3d\xc2\x3b\x17\x5f\xf3\xd2\x99\xee\xb7\xd7\xd8\xfb\x37\x2f\xde\x8e\xdf\x33\x67\xf0\x5b\x35\xec\x34\x24\xcf\x41\x80\x33\x94\x35\x82\xc7\x52\xcb\xeb\x6b\xc2\xd1\x68\x99\xd7\x59\x52\x92\xe0\x75\x7a\x13\x63\x36\x73\xa0\x36\x56\x19\xaa\xe3\x1a\x1b\x21\xe4\xb8\x44\x53\x2d\x58\x98\x89\x95\x69\xb4\x9a\xc1\x4c\xa5\x57\x1b\xf2\x90\x70\xa9\xce\x69\x5c\x58\x0b\x81\xd1\x62\x2c\x37\xd2\x5a\xa0\x45\x4e\xbe\x36\xa5\x37\x8d\xab\xd5\x1a\x8d\xda\x5a\x9a\xb1\x5a\x1b\x17\x66\xac\xc8\xc5\xb3\xd2\x90\x63\xb8\xc1\x0c\x23\x69\xc0\x3c\xdf\x3d\x86\x6c\x02\x89\xd7\x65\x55\x28\xeb\x45\x29\x68\x27\xc3\x29\x8d\xa9\xe4\xf2\xe1\x58\x29\x2f\x4e\x4a\x12\xef\x1c\x45\xe8\x21\xb7\x03\x3b\xe7\x1c\x13\x82\x48\x29\xb6\xb6\xc0\x26\x6c\x8a\x83\xc8\x67\xa1\xca\x27\x1e\xd5\x0f\xcd\xd3\xef\x5c\x7f\xd0\x76\xd0\xf9\x92\xed\xa5\xd2\xdd\x06\xca\xfe\xce\x37\xa1\xb5\xb6\xa9\xd0\x30\xc6\x36\xbb\x43\x38\xf1\x1a\xf4\x09\xbb\x9d\x70\x91\x41\xd8\xff\xdb\xd9\xc2\x93\x9e\xa9\xb0\xb9\xe1\xbe\xd1\x94\x49\xf4\xad\xa9\xbb\x96\x5c\xb0\xe4\xa6\xd2\xf1\x97\xaf\x59\x62\x18\xd1\xbc\x64\xcd\x26\xf8\xc6\x05\x0d\x1d\xc2\xee\xab\xaf\x86\x87\xaf\x14\xdf\x99\x1c\x93\x5d\xcc\xee\x63\x0f\x81\x00\x1a\xdb\x0b\x52\x23\x4b\xcd\x26\x9e\x63\xbd\xfe\x50\x25\xc3\xb0\xbe\x72\xab\xcd\xe6\xe6\xbc\x5e\xd6\xe7\x03\x5a\xad\xc7\x0d\xdc\x55\xd5\xe6\x90\x3f\xb4\x30\xe3\xb6\x39\x6c\x83\x19\x87\x83\xf1\xa5\x4a\xfd\x76\x53\x25\x53\x89\xf4\x23\xcf\x32\x0c\x8e\xe4\xe5\x65\xb3\xd2\x57\x91\xd1\x50\xa2\x1c\x25\xba\xc9\xd9\x0b\xd1\xdd\x25\xd6\xb3\xd9\x56\x89\xc3\x14\x6c\x3a\x93\x91\x28\xdd\x2a\x1f\xd9\xcf\xe0\x03\xbf\x2b\x41\x18\x2f\x9b\x99\x20\x35\xe6\xf7\x70\xc5\xe7\xee\x33\xdc\x7f\xfe\x5b\x72\x06\x5c\xf7\xec\x1f\x57\xce\xe9\xdb\x60\xa0\xea\x0d\x57\x4f\x12\x86\xbe\xf3\x9c\xe1\x11\xfe\x23\xbc\x0d\x93\xd7\x5e\x7c\x68\xf3\x1b\xe7\x52\xfa\x6f\xe0\x9a\xd7\xf4\x97\x6e\xa4\x47\x08\x87\xf7\xcc\x66\x4e\xae\x46\x9c\x7c\x51\x79\x5f\x5f\xb9\x30\x71\x1a\x7f\xcd\x35\x3a\xe8\xfb\xe8\x91\xbf\x3a\x99\xcb\xbc\x07\x85\x03\xd8\x37\xdb\x4a\xec\xc6\x38\x34\x16\x21\xa4\x2b\xf7\xa6\x96\x96\x85\x2a\xc2\x4c\x65\x20\xc0\x98\x6d\x76\x17\xe3\x36\x99\x2a\x0d\x5a\x0d\xea\xa4\xd1\xe8\x2f\x0f\x46\x98\x4a\x9f\xcf\xed\xae\x64\xe8\x68\x55\x99\x8b\xe3\x11\xb7\x84\xec\x7c\x85\x4d\xa7\x47\xf6\x34\x6c\xd6\x1f\xd7\xc3\x80\x3e\xae\xa7\x52\xfc\x14\x7e\x23\x7f\x03\xcf\x98\x79\xa8\xa1\x79\x3d\xaf\xa7\x2a\x8d\x8c\xdb\xe7\x63\x02\x54\x60\x30\x53\x4a\x02\x73\x89\x91\x3c\x3d\x4a\x64\x3e\x50\xcc\x60\xc3\x04\x0a\xaa\x65\xda\xb0\xc2\x5e\x28\x20\x80\x28\x08\x40\xac\x85\x18\xcb\x4e\xd8\x0e\x85\xe9\x30\x1a\xe4\xf1\x73\xf8\x7a\x93\xb0\xce\xb4\xf4\xe9\x47\x6d\x6f\x8e\x14\x86\x6c\x30\x0a\x13\xc7\xcf\x83\xa5\xb6\xef\x4a\x0e\xda\xee\x1a\x77\xb6\x69\xe8\xa8\x69\x73\x97\x50\xb5\x9f\xba\xc8\x25\xbc\xdc\x0d\xa3\x8f\x7d\x3d\x1e\xdb\x92\x85\x88\x93\xa8\xd4\xd0\x73\xe8\x97\x70\x17\xb1\x2e\xf3\x84\x7b\xe0\x2b\xeb\xd6\x51\x8d\xc2\xaf\x91\xcd\x35\x21\x9f\x6d\x0b\xd2\x57\xcd\xe0\x17\xa9\x39\xc1\x32\x5f\x09\xe3\xae\xac\xb4\x36\xc5\xf4\x6e\x37\xcf\x50\xcd\x4d\x5c\x4b\x6b\x10\xc1\x06\x33\x65\xd0\xc7\x72\xc8\xb7\x28\xe1\x2a\xe3\x50\x4f\x4e\x5b\x5e\xc9\x6d\xe0\x98\xbd\xf0\x3d\x78\x0c\xd2\x0d\x10\x22\xff\x40\x83\xc4\x0f\x72\x8e\x58\x3c\x1e\x19\xcc\xc4\xed\x56\x87\xc3\x88\xb8\x8d\x51\x64\x51\xbd\x96\x88\x07\xaa\x9d\x70\x55\xde\xf2\x99\x7a\xd1\x02\x6f\xca\x40\xee\x19\x1a\x17\xf1\x68\x6e\x6c\x7e\xa5\x85\x20\x2c\x7a\xa2\x9b\x86\x77\xd1\x93\x75\x5b\xc9\x00\x25\x4d\xd6\x33\x47\xfe\x4c\xf8\xde\x06\xbf\xdd\xba\xba\xfb\x83\xab\xfe\x3f\xde\xfe\x03\x30\x8a\xe3\x7a\x1c\xc7\xe7\xcd\xb6\xbb\xdb\xeb\xa7\x6b\xea\xa7\x93\x74\x6a\xa8\x9d\x0a\x42\x80\x0e\x0c\x42\x74\x51\x8c\x39\x40\x15\xd1\x6d\x7a\xef\xb8\x24\xb8\x80\x90\x71\x2f\x98\xd8\x89\x2b\x18\x1b\x0c\x06\x3b\x31\x2e\xc4\x0e\xb1\x31\x8e\x1d\x8c\x71\xc3\x2d\xf1\xc7\x25\x01\x97\x38\x36\xd2\xad\xfe\x33\xb3\x7b\xa7\x93\xc0\x49\x3e\xdf\x7c\xfe\x3f\xe9\x6e\x6e\x77\x76\xf6\xcd\x9b\x37\x6f\xde\xbc\x37\xe5\xcd\xf2\xb1\xe1\xfe\x6f\x3e\xfa\xf2\xbb\xf9\xb3\xed\xbb\xa7\x1e\x80\x0e\x5b\x64\x5e\xeb\xa4\x0b\x8d\x07\x8b\x27\x4d\xad\x99\xf1\xed\xaa\x37\x3f\x4b\x86\x6f\x67\x4d\xac\x99\x55\x7e\xd9\xc4\xaa\x5b\x46\x1d\x86\x9a\xfc\x07\x6f\xbf\x72\xca\xac\x49\x83\x67\x15\x2e\x1d\x73\x70\x78\xe1\x69\xe5\x8e\xf4\xc0\xe1\x47\x67\xd4\xc5\xda\xdd\x3c\xd2\xee\x52\x09\xa7\xb5\x84\x82\xc9\x0e\xbb\x81\xd7\xeb\x53\x88\x92\xef\x97\x78\x9d\x2e\x35\x95\xf3\x18\x8d\x39\x69\x1c\x61\x2e\xbb\x5f\x22\x2d\xce\x64\xd0\x85\x24\xde\x91\x81\x32\x9a\xc3\xa9\xc9\x1e\x75\x68\x5f\xeb\x5c\x13\x4f\x5c\x3c\xa5\x6a\xd3\xf4\x0e\x75\x08\x3f\x13\x95\xc7\xb5\xb0\x72\x62\xf8\x73\x83\x41\x2d\x2c\x21\x06\xa7\xb5\x2e\xbc\x45\xf9\x46\xf9\xf3\x1f\x60\xe9\x77\xa4\x89\x3d\xf3\x76\xf9\xe4\xb2\x5b\x26\xbc\xde\x72\xa0\x62\xec\xe5\x43\xc3\xe7\x97\x79\x66\x7f\xd9\xfe\x8b\x57\xb7\xbf\xbb\xda\xa1\x83\xcc\x0b\xa4\x6d\x9d\x90\x36\x6f\xd6\xe5\x2b\xfb\x5e\xcc\x2b\xc4\x9d\x8b\xf9\x01\x81\xf7\x95\x3d\x29\x45\xe2\x0d\xf8\xc1\x43\x9f\x7a\xf8\xab\x13\x5f\x54\xfe\xc0\xe6\x89\x52\xb9\x9b\xf1\x75\xe2\x93\xc4\x62\x37\x29\xeb\xa0\x81\xad\xa9\xb8\xa1\xfb\x2f\xe2\x90\xd8\xba\xc8\x2a\x78\x3b\xd4\xcd\x01\xef\xb7\x1a\x52\xf2\x0c\x2e\x3e\x2f\xe8\xe7\xfd\xd5\x03\xaa\xaa\xd2\xd3\x2b\x0e\x85\x03\xe9\x4f\x4f\x0f\x14\x1d\x0a\xa3\x02\x30\x72\x05\x05\x38\xc0\xd3\xc5\x8f\x3a\xd3\xd3\xd3\xe9\x62\x48\xa4\xf3\xb6\x55\xc3\xe4\x6a\x18\x56\x0d\x15\xd5\x90\x5d\x0d\xc4\x20\xe4\xab\xe1\x87\x6a\xf8\x6b\x35\xbc\x5c\x0d\x4f\x55\xc3\x83\xd5\x70\x4b\x35\xfc\xa2\x1a\x56\x56\xc3\x14\x96\x2c\xb3\x1a\x12\xaa\x41\xac\x86\xf9\xb1\x74\xd7\xb2\xc7\x6d\x2c\x45\x2d\x4b\xa4\xaf\x86\x2f\xaa\xe1\xcf\xec\xe9\x21\xf6\x74\x64\xf4\xcd\x58\x06\x87\xa2\xd0\xaf\x8d\x42\x8f\xbd\x3b\xe0\x4c\x35\x1c\xaf\x86\x67\xab\xe1\xb1\x6a\xb8\xbb\x1a\x6e\xac\x86\x75\xd5\x70\x55\x35\x84\x19\xa0\xaa\x6a\xc8\xad\x06\x6f\x35\xc8\xd5\xd0\x59\x0d\xa1\x51\x5f\x55\xc3\x07\xec\x8d\x23\xd5\xf0\x08\x7b\xe3\x7a\xf6\xc6\x82\x6a\x68\xa8\x06\xa8\xae\x86\xa4\x68\x62\x92\xf4\xbd\x6a\x78\x95\x01\xdf\x57\x0d\xf7\x55\x03\x6e\xaf\x86\xf1\xd5\x90\x56\x0d\x88\x24\xef\xbd\x36\xa7\xe9\x3f\x5a\xb4\x78\x89\x24\x97\x5c\xfb\xd8\xb3\xa0\x51\x1d\xc3\xce\x8f\x2e\xf0\x8e\x9a\x02\xd1\xe9\x73\xca\x78\x7e\x22\x89\xe8\x0a\xc5\x74\x5b\x99\xfd\xa2\x25\x8d\x5a\x4b\x53\x07\x67\x25\x66\x33\xc5\x2c\x4c\x68\xa6\xeb\x17\xfb\xcb\x43\x95\xdf\x29\xdf\x9d\x7a\xfa\x17\x37\x2a\x19\x13\xab\x66\x94\xe5\x14\x57\x4d\x2d\x55\x26\x0e\xb8\x73\xe4\x35\x37\x2d\x7c\x61\x69\xf1\x86\xa2\xac\x0a\x43\xfe\x65\x03\xe6\x0f\xba\xac\xa6\x6a\x3a\x5d\xaf\xd8\xb5\xa2\x60\xa8\x72\x13\x70\xef\x82\xb8\x45\xb9\xf6\xfa\xa5\xc7\x27\x8f\x1e\xb7\xe2\x14\xbc\x54\x5e\xb3\x6d\xed\x8d\xef\xac\xb1\x5b\xdf\xd9\xd2\x6f\xfe\x81\x2b\x27\x37\xe4\xa6\x92\x76\xa8\xeb\xfe\x9a\xcb\x15\x26\x11\x99\x9f\x8b\xe6\x84\xfa\x9b\x03\xc4\x42\xcb\xe4\xf4\x7a\xb7\x37\x39\x85\x4f\xe0\x12\xf2\xf3\xbc\x89\xcb\xc2\x5e\xaf\xdb\x2d\x66\x8a\xcb\xc2\xc9\x99\x99\x48\xb6\xc9\xcb\xc2\x16\x13\x31\x29\x4d\x26\x9b\x17\xa5\x2f\x0b\x23\x49\xd5\x7e\x7b\xc6\xf4\xa3\x06\xb7\x3a\xd3\xab\x0e\xa7\x06\xd9\x90\x6a\x74\x39\x01\xb6\x80\xc8\x1c\x77\x04\xa3\x0a\x6f\xa5\x28\x55\x32\x8d\xd6\xcd\xa6\x90\xec\x84\x4a\x78\x69\xb8\xf1\xd3\xe7\xf3\x75\x8b\xb7\xd6\x0e\x2f\xb9\x77\xfd\x82\x15\x42\xc6\x84\xb5\xa6\x85\x0d\x33\xbc\xf7\x5e\x5d\x31\xc2\x35\x76\xfb\x63\x85\xc2\xa4\x2b\x9b\x5f\x51\x0e\x4d\xfd\x3e\x3f\xa3\xfd\xd4\x1d\xf7\x2d\x5d\xec\x2c\x7e\x31\x29\x6d\x64\x72\x1a\xd6\xef\xbc\x63\x4c\xdb\x7a\x65\x44\x2d\x24\x3f\x1e\x1a\x49\xf4\x28\x7a\x4e\x2b\x10\x3d\xca\x81\xdc\x44\x97\x2a\x44\x77\x85\xc2\x3a\xbd\xde\x6e\x31\x3b\x24\x84\xdc\xa2\x90\x9e\x95\xe4\x2c\x28\xc8\x12\xcc\x7c\x51\xb1\x27\x23\x25\x97\x4e\x6a\x14\x65\x70\x96\xdc\xb4\x5c\xac\xe7\x32\x72\x33\x72\x6d\x09\x6e\xbb\x80\x2c\x54\x43\xca\xd4\x95\xe9\x30\xd6\xd9\xd9\x91\xf7\xd8\xc6\xe9\xcd\x46\x73\x53\xb8\xc0\x31\xd0\x81\x1d\xa2\x91\xf6\x69\xc1\x86\xe8\x68\xb3\x6a\x50\x47\xed\xc8\xaa\xe8\x74\x87\x2d\x4e\x4e\xc7\x4c\x01\x6d\xc5\x85\xda\xfb\xfb\xe3\xc6\x32\x81\x2e\xb8\x80\x52\x75\x5c\x9f\xa8\xa6\x31\xce\x71\x26\x88\x7c\xb9\x3a\x6e\xfc\xde\x0a\x65\xf6\x23\xfb\x4c\x4a\xa6\xe9\x89\xe3\x0f\x99\xe0\x6e\x18\xf1\x17\xec\x75\x46\x3e\x87\x41\xb5\x33\x26\x5d\x36\xed\xb2\x59\x1b\x2e\xbf\xa3\x69\xd6\x86\x67\xf9\x77\xa9\xd9\xd8\x99\xcd\x67\x74\x0d\x8d\x0e\x42\x76\x3d\xab\x6c\x5e\x0d\x25\x2f\x5d\xbb\xee\x85\x1b\x56\xd5\x6e\x5a\xd8\xf2\x9b\x86\x4d\x0b\x6f\x7f\x8d\xc8\xaa\xa9\xdd\x5f\x0b\xcf\x11\x59\x45\x77\xea\xe5\x10\x1b\xea\xda\xd0\x84\x7e\xba\xac\x94\x14\x7b\xba\xb7\x1c\x21\xaf\x5d\xc7\x57\x0d\x48\xb1\x5b\xed\xc7\xc3\x59\xc9\xc7\xc3\x99\x0e\xa7\xe3\x78\x18\x59\xad\x56\x9c\x96\x05\x35\x59\xe3\xb3\xce\x51\xc7\x09\xd6\x84\x3a\xe4\xb4\x3a\x09\xb5\xac\x59\x4e\x67\x96\x95\xe3\x8d\xc6\xdc\x3f\x84\x8d\x3c\x5f\xf2\x87\x30\xef\xe8\x59\x6f\xd1\x33\x3e\xdc\xb0\x44\x1d\x23\x8e\xeb\xd1\x7a\x4c\x25\x20\x96\x90\x3f\x23\x13\x97\xb3\x09\x46\xde\x0e\xe5\x95\xb6\x40\x39\x1d\xf1\xb5\xfa\xfc\x4e\xb7\xd3\x41\x87\xbd\x88\x8a\x55\xc1\xb1\x59\x47\x3b\x1f\x2c\xcd\x24\x2c\x85\x33\x85\xe7\x0e\x2a\x47\x9f\x7b\x46\x79\xfe\xf0\xb3\x30\xe8\x99\x67\x21\x74\xa4\x2b\x6b\xcc\x64\x68\xbc\x67\xb7\xf2\xc1\xb2\xc6\x2d\x93\x57\x3b\xdc\x0b\xa7\x3d\xf5\x2b\xe5\xcb\x5f\xfd\x0a\x9c\xf7\xef\x06\xf7\x03\xbb\x95\xaf\xf0\xae\x23\xca\x4b\xbf\x3d\x0c\xa1\x67\x7e\x07\x43\x0e\x1d\x56\x5e\x88\x1c\x19\x60\xc5\xb7\x58\x2b\xd7\x2e\x55\x94\xbf\x59\x07\xe0\xca\x69\x23\x95\x87\x27\xe3\x84\xfb\x95\xbf\xfe\xfa\x01\xe5\x2f\xe4\xdd\xe4\xfb\xef\x07\xef\x6f\x68\x5f\x77\x33\x4e\x94\xbe\x15\x6a\x88\x8d\xd8\x0f\x1d\x0a\x5d\xe5\xf3\x78\x52\x52\x02\xd8\x5f\x50\x10\xb0\xe3\x00\x2e\x2a\xcc\x70\xf7\xe3\x0c\x88\x1a\xda\xd9\xa9\x36\xce\xc0\x1d\x0f\xfb\xd3\x0d\xef\x17\x04\x52\x3c\x76\x8c\xf0\xf1\x70\x5e\x92\x0b\x7d\x70\xb4\x08\xf6\x15\xc1\x7d\xec\xd3\x5e\x04\x9b\x8a\x60\x51\x11\x34\x15\xc1\xf8\x22\x28\x2a\x82\xb4\x22\xb0\x14\x41\x55\x77\x11\x9c\x8b\xa6\x6b\x67\x0f\xd8\xba\x0a\x26\xc7\x62\xb2\x8d\x76\x9c\xa5\xda\x10\x2c\x63\x4f\xf5\x9a\xb6\x55\x6d\x8a\x03\xaa\x62\xd3\xe0\x55\x1a\xb5\x09\x75\x55\xbb\x9d\xae\x6b\x0b\x50\xd2\xba\x9d\x3e\x3f\x0b\x55\xc2\x27\x81\xcf\x29\x69\xb7\x90\xb5\x39\x2d\x7f\x70\x99\x75\x04\xfe\xeb\x08\xeb\x88\x69\xa9\x9b\xf1\x2b\x3e\xe5\xcb\x39\xca\x3b\x73\xe6\xc0\xf8\xb7\xdf\x85\xa1\x73\xe6\x28\x8b\xaf\xc4\x89\x03\xad\xf8\x56\xde\x70\xeb\xe7\x9f\xdf\x6a\x8a\x5c\x69\x1d\x88\xaf\x8b\xbc\x62\x1d\x48\x22\xb7\x59\x07\x2a\x36\x38\x37\xd0\x1a\x59\xc6\xee\x47\xa9\xeb\x55\xab\x89\x7e\xfa\x15\xd1\xb1\xa8\xa4\x2a\x17\xcd\x16\x4e\x4a\x4a\xce\xe4\x88\x76\xc0\x05\x38\xbd\x3d\xe0\xf3\xd8\x3d\x79\xf9\x7e\x7b\xa6\x98\x44\xcc\xa1\xa6\xb0\xc5\x22\x39\x9d\x44\xe3\x72\xf2\xc9\x66\xb3\xe4\x33\x18\x24\xda\x2a\x35\x0b\x30\x7e\xc5\x53\x30\x7e\x1c\x47\x1d\xc3\x70\xab\x83\x5a\xa0\x2d\x91\xf0\x71\xc4\xd2\xab\x86\x40\x36\x51\x23\x90\x2f\x1d\x39\x13\x90\x05\xb4\x55\x12\x0e\x26\xcf\x39\xc7\x73\x27\x6e\xdb\xee\x8e\xb4\xbb\xa7\x0c\xaa\xdf\x7f\x95\x70\x5e\xf9\x1e\xd6\x42\x03\xcc\x80\x75\xca\xf7\xe7\x85\xab\xf6\xd7\x0f\x9a\x42\x9f\xb6\xdf\xfa\x1a\xff\xf9\x3b\x7f\x7c\xf2\x75\x97\x52\x0f\x9b\x37\x5b\xe7\x65\x00\xfa\xe3\x8f\x60\x51\xbe\xfd\xe9\x8f\xdd\x28\x63\x9e\x75\xb3\xb2\x19\x9e\x70\x9d\x7c\xe2\xf8\x19\xa6\x27\x4d\xed\xfe\x90\x5f\xcf\xd7\x11\x89\x95\x86\xea\x43\xb9\x69\x56\xab\x07\x91\x82\x49\xe9\x3e\xb7\x3b\xc1\x9a\x66\x5d\x15\xb6\xa4\xa5\xa5\x61\x99\x4b\x4b\x93\x39\x39\x79\x55\x58\xe6\x12\x56\x85\x39\x2f\x8a\x8e\x38\xc4\xaf\x5f\x52\x3b\x29\x66\x80\xb0\xb5\x75\x59\x4c\xf4\x62\x75\xb4\x93\x58\xb5\x3e\x1b\x9b\x18\xa9\xe4\x6c\x74\xb0\x53\xb2\xf1\x83\x9b\xdf\xbb\x63\xd7\xf9\xeb\x6e\xfa\x7e\xe7\x9d\xdf\xfe\xa2\xeb\xf7\xe5\xbf\x9e\x70\xed\xc1\x89\x2d\xc1\x07\xa6\x1c\x58\xf1\xdd\x9d\xeb\x3b\x40\xba\xf7\x31\x40\x37\xdc\xa0\x44\x1e\x56\xee\xe9\x3f\x6c\xee\xd5\x30\x1a\x9c\xe5\x43\x56\x28\x5f\x32\x1d\xc7\xd7\xfd\x47\xf1\x7f\x84\xb9\x44\xc7\x71\x20\x17\x1a\x8c\x6e\x0a\x0d\x77\xda\x75\x36\x97\xd5\xa0\x4f\x48\xd0\x59\x65\x87\x4c\x97\xcf\xe9\x4a\xdd\x59\x59\xfd\x31\xc7\xe5\xa5\xf5\xd7\xf5\xaf\x09\x25\xe8\xed\xce\xa2\x02\xd9\x6a\x75\x38\x74\x3a\xb3\x58\x9a\x96\x53\xad\x77\xe6\x88\x62\x8e\x53\xcf\xe3\x64\x37\x54\x93\x5a\x3c\x16\x0c\x1e\xd3\xc6\x9f\xe2\xa7\x40\xb5\xb5\x1e\x5a\x5d\x06\x7b\x8f\xb4\xd8\xe2\xe7\xd6\xd5\x9e\x19\x24\x7f\x0d\x90\x0e\x9a\xc9\x58\x66\x1e\xf8\x7a\x26\x87\xb2\x03\xda\x52\x2e\xad\x67\x66\x9c\x40\xcf\xe1\x63\x13\x4e\x38\x65\x25\xff\xe0\xf2\x0b\xd3\xa5\xef\xa5\x1a\xb8\x7f\xef\x9d\x03\x24\xe5\x2e\xa9\x39\xa0\xbc\xba\x08\xa6\xbc\x04\x02\x1e\x50\xce\x27\x34\xf4\x6f\x99\x3d\xf2\xaa\x19\xd3\xf6\xdc\xb5\x6c\x6e\x46\xb9\x54\x3e\xe9\xf2\xa9\x63\xe7\x4f\x6b\xf8\xdd\xfd\x43\x6e\xc9\xaf\x10\x76\x75\xfd\xb3\xa0\xc0\x8a\xff\x1e\xb1\x5b\xc9\xef\x1b\x6f\xe0\x15\xca\xbd\x91\x15\x5b\x92\x73\xa6\xd5\xe6\x55\x66\xa5\xb5\xd6\x6d\xbe\x29\xf1\xe8\xa2\x82\xda\xaa\x40\x59\x66\xda\xcc\xba\x8e\x5f\x79\xed\xa4\x0d\xf4\x27\x86\xda\x5b\xdc\x1e\xc2\x0f\xe3\x42\xb9\x26\xce\x66\x20\x1d\x18\x91\x99\x9c\xdb\xe3\xa5\x36\xe9\xb8\xb0\x55\x26\x5f\x2b\x97\x40\x2c\xfb\x71\x61\x9e\xe3\xd0\xb8\x30\xe7\x8c\xad\x1c\xaa\xa1\x16\x69\x2f\x73\x54\x25\x88\x3a\x54\x49\x97\xb4\x54\x13\x1b\x8a\x58\x4d\x41\xb7\x36\x64\x89\x3f\x9c\x2e\x47\x0c\x05\xa3\xc5\x09\x8d\xeb\x06\x3c\x1e\x18\x5d\x3e\x1a\x3f\x3e\xe8\x7a\x19\xfe\x29\xcf\x9c\xe6\x19\xfa\xd3\x1d\x12\x8c\x98\x03\xf9\xf3\xe1\x0a\xcf\xd0\xa1\x1e\x75\x0f\xd0\xe5\xdd\xdf\x0b\xdf\x08\x97\x59\x03\x52\x04\xd7\x31\x4f\x2e\xeb\x0c\x74\xbe\x6a\x05\xb7\x24\xf2\x25\xf5\x81\xc7\x9e\xd7\xb2\xe7\x93\xd9\xf3\xe5\x42\xef\xe7\xff\x10\x9e\xd5\xde\x6f\x54\xdf\xff\x04\xd9\x24\x9d\x8e\xab\x8e\x7c\x85\xc6\x84\x4a\x78\x0e\xbb\xbc\x24\xd8\xed\x85\x4d\x5e\x18\xef\x85\x22\x2f\xa4\x79\xc1\x0b\x67\xf5\x30\x5e\x0f\x35\x7a\xd0\xa3\x4d\x08\x76\x23\x58\x84\xd8\x8c\x0a\x5d\x37\xbd\x84\x9e\x1a\xdb\x50\x1e\x5b\x42\x4d\xbd\xcb\xa9\x7b\xf7\x73\x59\x7e\xb5\xb1\xfc\x02\x6a\x4e\x36\x11\xd1\xb3\x99\x16\x87\xc6\x70\x18\x64\x2f\xdf\x5d\x02\xe7\x4a\xe0\x6c\x09\x9c\x2c\x81\xa3\x25\xb0\xaf\x04\xee\x2b\x81\xf6\x12\xd8\x54\x02\x8b\x4a\xa0\xa9\x04\xc6\x97\x40\x4d\x09\x94\x00\x41\xcc\x0c\x9b\xcc\x30\xde\x0c\x45\x66\x48\x33\x83\x99\x62\xd3\x83\xca\x92\x1e\x24\x6c\xbd\x14\xcc\x38\x9c\x86\x31\x9c\x06\x5d\x8c\x93\x4e\x4c\x40\x68\x68\x28\x4f\xc5\xa9\x32\x64\x4a\xa8\xab\xfc\x5f\xe5\x98\xaf\xe6\xd2\x4d\xcf\xf3\xe9\xc9\xa3\xa2\x57\x1e\xd2\x20\x44\xa4\x4d\x99\x9a\xc7\xa6\x72\x58\x54\x0e\xe5\x97\xca\x24\x0d\xc1\x59\x04\x6a\x56\x35\x08\x2c\x1a\xa9\xfb\x16\xb1\xa7\x5c\xdd\x5f\x13\x7d\x73\x0a\xf7\x7b\xbb\xc8\xb1\xf3\x36\xe1\x7e\xd4\x26\x36\xe2\x61\xc8\x84\x32\x42\x66\x99\x08\x78\x3d\xc6\x26\x41\x30\x5b\x4c\x46\x54\x74\xa2\xaf\x33\x0a\x97\xdb\x9f\x1d\x28\xaf\xa8\x0c\x12\x9b\xd5\x89\xb7\x54\x0d\xae\xdb\xd4\xde\xbe\xa9\x6e\x70\x15\xf7\x01\xe4\x5e\x76\xf5\xad\x23\x33\x47\xde\x7a\xf5\x65\x53\x08\x5c\x6b\xf7\x4b\xf8\x3c\xbf\x89\xc0\xcd\x09\xd9\xf4\xb2\x8c\x11\x32\x5b\x62\xf0\x09\xe8\x60\x91\x3a\x7b\x11\xb7\x5d\x42\x94\x28\x68\x97\xdb\x99\x1d\xb0\xf9\xe1\x54\x0f\x3c\x6e\x77\x4f\x4e\x5d\xfe\x3e\x78\x67\x86\x2c\x48\x96\x29\x5c\x41\x30\x99\xcc\x16\xa3\x29\x86\xb8\xad\x07\xf3\xec\x00\x05\x2c\x4a\x7e\x62\x86\x97\x0b\x9b\xe2\xe1\xc1\xa6\x38\xcc\x51\x2f\xdc\xb3\x43\x56\x82\x38\x41\xdf\x4c\xf3\xc0\x7a\xbd\x48\xa9\x52\x5a\x14\xec\x8d\x79\x56\x45\x25\x05\x4d\x48\xe3\x72\xdb\x82\x38\xbf\x07\xde\xfd\xf1\x24\x8a\xc7\x9b\x7a\x04\x72\xb9\x8d\x46\x9b\xd3\x6c\xb6\xd9\x08\x70\x91\x42\x17\x3d\x5e\x24\xc7\xa1\xcf\xf6\x67\xda\x2e\x4d\xff\xb8\x12\xc5\xd7\x04\x56\x7a\xae\xe3\xea\x24\x76\x11\x57\x3e\x37\x0a\x85\x52\xb0\xd3\xe9\xd6\x9b\xcd\x46\xa3\x9b\x88\x30\x12\x98\x9d\x4e\xbb\xa0\x55\x14\x5b\xf9\xce\xf2\xb6\xf6\x2a\x74\x9c\x16\x18\x5f\x67\x71\x54\x88\xab\xbd\xd8\x45\x7c\x2d\x46\x70\xcf\x35\xed\x67\x09\x4e\x75\x0c\x27\x0e\x25\x11\x09\xe3\x17\x91\xd7\x9b\x64\x02\xbb\xdd\x6a\x4d\x4a\x4a\x4e\x21\x81\xcb\xee\xf5\xba\x38\xe4\xd2\x5b\x78\x5e\x6f\x12\x45\x7d\x0f\x6e\x1f\x7c\x78\xc2\xd6\x8b\x9d\x62\xdd\x0e\xdd\xce\xe0\x73\xfa\x1c\x3f\x87\xa5\x15\x3e\x52\xd2\x7f\x7f\x31\xaa\x73\xeb\xf9\xa9\x3f\x87\x2c\x26\xb2\xe1\x2f\xdc\x6e\xe1\xf7\x28\x19\xe5\xa1\x7d\xa1\x65\x99\xba\x14\x0b\xa9\x42\xe4\xd6\x71\xf9\x05\xae\x84\xc4\x84\x89\x61\x4b\x22\xb1\xce\x12\x8d\xe9\xa4\x2b\x30\x5a\x02\x82\xeb\x64\x01\xec\x2b\x80\xf6\x02\x58\x54\x00\x1f\x15\x40\x53\x01\x84\x0a\x20\xbd\x00\x50\xf4\x56\xbd\xee\x4f\xae\x6a\xa2\x37\x9b\xd8\x83\x9a\xde\xd7\x69\xec\x56\xd7\x18\xb3\x87\x63\x56\x72\xcc\x72\x46\x35\x27\x6a\xa2\x8b\x54\x7b\x69\xee\x9a\xda\x6e\x00\x31\x36\xc3\xea\x72\x07\x2b\xa9\x2d\x2c\x05\x2a\xc9\x9d\x9d\x63\xeb\x3a\xb0\x6a\x01\xdb\xb9\xdd\x75\xed\xc7\xd7\xdf\xf1\xf0\x4d\xef\x6f\x6d\x68\xcf\xe0\xf9\x5b\xb7\x2f\x58\x93\x39\x6f\xfc\xb8\xa7\x8f\x2d\xb3\xaf\x19\x37\xfd\xb6\x96\xb9\xe1\x09\x3b\x17\x73\x8f\x3e\xaa\xfc\x42\xf9\xdb\xf6\x67\xf7\xdc\x0d\x85\xb7\xcf\x9c\xb4\xfc\xd3\x6f\x27\xfb\x6e\xf3\x2b\x5f\x45\xde\x9a\xb1\xe6\x06\xe5\xef\x37\xae\xbf\x61\x1b\xf3\xeb\x87\x91\x95\x28\x25\xa7\x84\x3a\x24\x20\x1d\xe1\x7e\x8f\x24\xf0\x9c\x4e\x24\x36\x9c\xc0\x19\xf4\x3a\x9e\xe3\x25\x01\x8b\x22\xa8\x4a\x62\x90\x2e\xd7\xef\x8d\x7a\x2e\x91\x81\x3e\xc8\xf2\x01\x7f\xaa\xb3\x1a\x5e\x83\x0c\x38\xdd\xf9\x12\xfe\x46\xd9\xdc\xc2\x7f\xde\xe9\x75\xf1\x74\x5b\x03\x9a\xaa\x8c\x11\x87\x30\x1b\xf3\x93\xd0\x3d\x36\x6c\xd6\x63\x7d\x82\x53\xc7\x09\x5c\x53\x58\xb0\x36\x87\x05\x62\x27\xda\x38\xa2\xd5\x37\x85\x8d\x28\xe9\x09\x27\xec\x76\xc2\x0e\x27\x2c\x76\x42\xb3\x13\x42\x4e\x28\x76\x42\xba\x13\xce\x3b\xe1\x23\x27\xbc\x11\x7d\xba\x99\x3d\x55\x1f\x59\x59\xfc\xf3\x2c\x92\xbc\x55\x1f\x8d\x44\x4e\xa8\x3a\xcb\x1e\x3c\x11\x07\x8e\x00\x3a\xc9\x62\x76\xb3\x18\x02\xf4\x28\xbb\x26\xaf\xf5\xd9\xd4\xd4\x77\xdb\x59\xdc\x30\x08\xb1\x17\xd8\xda\x28\x4f\x4d\xbc\xe6\xc0\xf6\x66\xa8\xaa\x7f\x4c\xef\xf7\x91\xdf\xa9\x7b\xf6\x08\x5f\xec\xdd\x1b\x59\xb0\x27\xf2\xf9\x1e\x65\xcc\xa8\x44\x91\x4d\xc6\xfd\x74\x3a\x71\x14\xb9\x4e\xfb\xe9\xe3\xc4\x51\x94\x4e\x33\x94\x31\x42\x15\xa1\x93\x13\x3d\x19\x5a\xe2\x34\x99\x30\x20\xa3\x51\xb6\xea\x64\x9d\xcb\x6d\x72\x9a\x9d\xcd\x61\x23\x20\xce\x60\x35\x73\x32\x36\x18\x70\x6b\x58\x67\x48\xda\xe1\x86\xcd\x6e\xa8\x77\x43\xba\x1b\xda\xdd\xd0\xe4\x86\x62\x37\x20\x37\xbc\xe1\x86\x1a\x37\x58\xdc\x30\xe0\x23\x76\xb3\xdb\x0d\x8b\xdd\x70\xd6\x0d\xfb\xdc\x70\xf1\x3b\xe4\x05\x5d\x2f\x7b\x28\x66\x1d\xa9\x85\x0d\x46\x17\x28\x12\x53\x28\xae\xbc\xaa\xd6\x5c\xaa\xba\x1e\x01\x5f\x69\x66\xa5\x83\x28\xff\xe5\x7a\xb6\x11\x9c\xe8\x87\x3e\xae\x4d\x01\xd8\x48\x74\x21\xdf\xd8\x29\x8e\xce\x0a\x3c\x28\x72\x9e\x9f\x35\x65\xf0\x6f\x76\x2a\x0f\xe3\x5f\xce\x89\x14\xeb\x25\x48\x8f\xbc\xb6\x80\xcb\xc5\xe7\xaf\x52\xb6\xfd\xd3\xa2\xda\x34\xf7\xe3\x66\x7e\x1a\x3e\xa7\xfa\x39\xe1\x10\x61\x22\xd8\x1b\x46\x07\x34\x0f\x1b\x55\xaa\x9f\x13\x7e\x5a\x57\x1d\x3e\x47\xfd\x9c\x44\xf7\x70\x59\x45\x29\xc2\xde\x9f\x0b\xdd\xf0\x14\x37\x9a\xee\xcd\x0a\x19\xd8\x7e\x7e\xb6\xd9\x1e\x15\xe5\x5f\x72\x2b\xbf\x39\xba\x47\xaa\xbb\x67\x8f\x3c\x1a\xd1\xfd\x2d\xbf\x52\x9c\x4c\x5a\x45\x7a\xc8\x82\xf5\x3a\x03\xcf\xed\x0b\xf3\x3c\x48\x22\xb8\xe8\xba\x00\x36\x8b\x41\x97\xa6\x32\xad\x99\x58\x80\x7a\x08\xe2\x6b\x16\x28\xa7\x1f\x06\xa2\x1f\xc2\xb1\x69\x66\x6e\x50\x7d\x24\x4d\x38\x44\x7d\x02\xa0\x57\x85\xb5\xdc\x69\xa2\xef\x67\xa0\x42\x74\x2e\xf4\xeb\x5c\x7f\xa2\x9c\x4e\x3b\x95\x62\x77\xb6\x39\xa5\x40\x48\xf4\xdb\x78\x0e\xe9\xea\x75\x58\x97\x60\x31\x83\xde\x7c\x5f\x31\x6c\x2a\x86\x45\xc5\xd0\x54\x0c\xe3\x8b\xa1\xa6\x18\x8a\x8a\xe1\x5c\x31\x1c\x2d\x06\xf2\xa8\xfd\x52\x4f\xd3\x8a\xc1\x52\x0c\x67\x8b\x61\x1f\x4b\xa3\x26\xe8\xf3\xb4\xfa\x28\x7b\x59\x7d\x8d\xc4\xa2\xb8\x44\x6a\xbc\x9a\x94\xc4\xf7\x88\xb3\x4b\x6f\xfb\xeb\xdd\x1e\x50\x51\x63\x43\xf0\xfd\x86\x52\x77\xd5\x89\x52\xd2\x2d\xc5\xd8\xa3\xaa\x94\xb9\xfa\xf0\x67\x70\x3d\x33\xb8\x2e\x37\x1b\xa1\xc9\xca\xa0\x27\x78\xab\x56\x05\x68\x6b\xd7\xd8\xec\xec\xda\x03\x5b\xdf\xdc\x16\xfa\x75\xc3\xf6\x27\xf6\xdf\x34\x6f\xff\x90\xd0\xbd\xf3\xb6\x3f\xa6\xbc\x5b\x7f\x5d\x68\xe0\x75\x53\x9a\xd7\xac\x8d\x7c\x56\x75\xdd\xb4\x86\x55\x2b\x66\x4e\xf8\x05\x1e\xf7\x9b\x0f\x41\xb7\xe9\x9a\x3f\xef\x7b\xe4\xdd\xcd\x57\x6f\xd8\x74\x7a\xe1\x4d\xdb\xb7\x6d\xdf\xbd\x61\xf5\x6e\xe5\xeb\x9b\xda\x7f\xb5\x7e\xe3\xdd\xdb\x98\xee\x70\x07\x42\x62\x33\xff\x8a\xba\xd7\x0b\xd3\x1d\xc3\xb4\x17\x8d\x2a\x52\x74\xed\x14\x75\x10\x00\x77\x34\xf2\xf3\x3b\xfb\xf3\xaf\x74\xde\xde\xa8\xfa\x7b\x71\x75\x2b\xfc\xa3\xbc\x8e\xc8\xad\x8f\x42\x29\xb2\xc1\xe0\x40\x28\xc1\x49\xe4\x0a\xcf\x84\xc8\x9f\x9d\x9f\x39\x31\x11\x23\x93\x9d\xe0\x3c\xdc\xfd\x7c\xc8\xbe\x72\x4d\x1d\x11\x2f\x09\xce\x4c\x67\x99\x93\x23\xb2\x67\x11\x8d\x3e\xb0\x60\x61\x1d\x7b\x3c\xb2\x79\x5e\x5d\x3d\x7d\x5c\xe6\x1c\xe6\xe4\xbe\x67\x82\x07\xa7\x3b\x8b\x9d\xcf\x3b\xdf\x70\xf2\x74\x18\xa8\xde\xb9\xd8\xb9\xd9\x29\x54\x21\x67\x3a\xbb\x7a\x82\x3c\xf8\xc8\x79\xde\xa9\xa3\x8f\x9a\x59\x3a\xe1\xbc\x9a\xd9\x81\xf1\x93\x54\xa8\x9e\x61\x75\x75\x27\xa9\x58\x6b\x26\xc9\xb9\x34\x26\xf3\x74\x16\xaa\x2b\x14\x95\x16\x9d\x00\x56\x6b\xf9\xf9\x0d\x6c\x33\x49\x13\xad\xae\xfc\x7c\x1a\x97\xaf\xd6\x63\x74\xde\x8d\xf0\xb0\x8d\x8d\x9b\x11\x53\xce\xe6\xb7\xa9\x73\xe5\x36\x70\x2d\xff\xd3\xd5\xd7\xbc\xb5\x6a\xce\xb1\xdd\xf7\x3f\x8f\x31\xba\xed\xdc\x75\xd7\x7e\x7b\x8b\x82\x30\x7e\xee\xb3\x4f\x5e\x54\xd4\xb5\x25\x8f\x44\xde\xc3\x7b\x09\x97\x07\xe0\xc7\x10\x25\x50\x4e\x6e\x62\xe6\xde\xb0\x8f\xe2\xd6\x6d\x77\xd5\xf9\x7c\x69\x89\x4d\x89\xb8\x28\xb1\x26\x71\x51\xe2\xbe\x44\xde\x92\x38\x3e\x71\x53\x62\x7b\xe2\xd1\xc4\xee\x44\xd1\xc0\x25\x8a\x96\x7d\x61\x63\xc8\xe1\xaa\x33\x1a\xc5\xa5\xb9\xd0\x9a\x0b\x13\x73\x61\x68\x2e\x94\xe6\x42\x46\x2e\xd8\x73\x01\xe7\xc2\xb7\xb9\xf0\x49\x2e\xfc\x39\x17\x8e\xe5\xc2\x53\xb9\x70\x7f\x2e\xdc\x9c\x0b\x57\xe7\x02\x49\xdf\x96\x0b\x93\x73\x61\x18\x4b\x9f\x99\x0b\x09\xb9\xc0\xe7\xc2\xbc\x1f\x72\xe1\xb3\x5c\x78\x33\x17\x5e\xcc\x05\x78\x22\x17\x76\xe7\xc2\x8e\x5c\xd8\x9c\x0b\xcb\x73\xa1\x39\x17\xea\xd9\x1b\xa4\xeb\x4a\xcf\x05\x6b\x2e\xa0\x5c\x38\x9f\x0b\x1f\xe5\xc2\x1b\xd1\x1c\x7e\x9d\x0b\xb7\xb0\xf4\x8b\x59\x7a\x35\x87\x32\x96\x5e\xcd\xe1\x7b\x86\xce\xf3\xb9\x14\xb8\x9a\xf8\x5a\x06\x5c\x4d\x19\x45\x24\x34\x13\xaa\xbe\x67\xa8\xa8\xb8\x2f\x8f\xe2\x9b\xc9\xf2\x55\xe1\xc4\x9e\xaa\x78\xe2\x1d\xd1\x8c\x43\x3f\x83\xe2\xf3\x51\xb4\xea\x59\x9a\xbe\x8d\xb2\xe9\x3f\x1a\xae\xbf\xe4\xc8\x7f\xd3\x25\x3c\x16\xf4\xbc\x41\x55\xbb\x7c\x4d\x85\x59\xb2\x34\x18\xdb\xa7\x4a\x7a\x3c\x2b\x5b\x77\x47\x34\x39\x0b\xf8\x19\xeb\x38\x12\x30\x5b\x69\x47\x14\x3a\xea\xff\x98\x36\xeb\xf2\xd7\xcd\xd2\xcc\xdd\xb5\xde\xb0\xc5\x6e\x75\xd6\x56\x95\xd7\xf2\x92\x5e\x9c\x75\x77\x6d\xca\x44\x23\xef\xe4\x13\x86\x0f\x28\xaf\x85\x0b\x60\x04\xdb\xfc\xdf\xad\x4e\x30\xea\x87\x0e\xa9\xbd\x77\x7d\xe4\xaf\x23\x95\xe7\x94\xbf\x2c\xfc\xed\x52\xb7\x41\x67\x6a\x72\x0f\xbf\x77\x9d\x7a\x3e\x2a\xf8\xf8\x2b\xf8\x21\xd6\x00\x6a\xe9\xfe\x07\x3a\x6b\x93\xe8\x6f\x77\x08\x75\x85\x82\x95\xa1\x99\x33\xeb\x2a\x43\x2d\x2d\x24\x68\x6a\x22\x41\x43\x03\x09\xa6\x4f\x27\xc1\xb4\x69\x24\x08\x87\x49\x30\x75\x2a\x09\xa6\x4c\x21\xc1\xe4\xc9\x75\x95\x94\x55\x87\xd7\xd5\x91\xbb\x41\x83\x48\x50\x5d\x4d\x82\xd2\x52\x12\x14\x17\x93\xa0\xb0\x90\x04\x05\x05\x24\x08\x04\x48\x90\x95\x45\x02\xbf\x9f\x04\x3e\x1f\x09\xd2\xd2\x48\x90\x9a\x4a\x82\xe4\x64\x06\xe9\x40\x52\x92\xfa\xeb\xf5\xaa\xbf\x6e\xb7\xfa\xeb\x74\xaa\xbf\x66\xb3\x9a\x63\xa6\xd1\x58\x07\xe8\x0d\x03\x3c\x6f\x80\x27\x0c\xb0\xdb\x00\x3b\x0c\xb0\xd9\x00\x8b\x0d\xd0\x6c\x80\x7a\x03\x84\x0c\x60\x80\x38\x53\xb8\xbc\x3c\xff\x5f\xfe\xd1\x7d\x84\xe8\x26\x3e\x83\x3f\x46\xe4\xd5\x8a\xd0\x28\x93\x81\xd8\xea\xd8\x86\x13\x9c\xbc\xd5\x66\xdd\x1b\x76\x38\xa0\xd9\xf6\xbc\x0d\x23\xdb\x66\xdb\x0e\x1b\xb7\xd9\x06\x16\xdb\x78\x1b\xd6\x73\x36\x83\x41\x67\x34\x19\xf7\x86\x85\x66\xd3\xf3\x26\x8c\x4c\x9b\x4d\x3b\x4c\xdc\x66\x13\x58\x4c\x35\xa6\xf1\x26\x8e\x98\x6e\x0d\xb4\xc6\xd5\xc1\x7a\x75\x9c\x9e\xdc\x06\x8b\x7a\x0f\x99\xb0\xe5\x0c\x41\xa7\x8f\x23\xa2\x94\xf3\x3b\x48\x8f\xe8\xf0\x91\x2f\x2f\x1c\x79\x5b\x79\xf9\x19\xf8\x3e\xf2\xf0\xe1\x3b\x0f\xbf\x02\xf9\xcf\x28\x49\x78\xe4\x11\xfe\x98\xf2\x63\xbb\xf2\xc3\x0e\xe5\x27\x90\x76\x80\xa1\x1d\x74\xa4\x9f\x9c\x0d\x12\x9f\xca\xd7\x69\xfe\x17\x86\x86\xb2\xa8\x73\x1a\x03\xd1\x46\x8d\x26\x83\x2c\x73\x62\xb7\x04\xcd\xd2\x62\x09\x5b\xa4\x34\xa9\x88\xba\xe7\x43\x1c\xe8\x38\xda\xf7\x9c\x20\x28\x36\xd0\x95\x05\x27\x7a\x39\x3c\xa2\x7a\x42\xf4\xcb\xa7\x76\xd5\x71\x87\xd5\x2f\xdc\xd6\xde\x8e\xf7\xb7\xb7\x2b\x0f\xb5\xb7\x13\x1d\x78\x3e\xd1\x81\x33\xf8\xf7\xd8\x7e\xdc\xd1\xa1\x7e\x3a\x2c\xea\x79\x10\xc1\x28\xeb\x0d\x7b\xc3\x7a\x0f\x8f\xcd\x61\x91\x37\xd7\x88\x9b\xc4\xa3\x62\xb7\xc8\x8b\xe9\x84\xd6\x7c\x31\x5f\x4f\xd4\xe3\x03\xc8\x5b\xd3\x10\x0c\x26\x9e\x68\xc8\x8f\x77\xe2\xa3\x66\xef\x20\x19\xeb\x21\x05\xfb\xca\xe7\x73\x87\x23\x80\xbb\x89\xc6\xb2\x77\x1a\xfc\xb9\x5d\xd9\xae\x6c\x6b\xaf\xdb\xb1\x43\xcb\x3b\x93\xe4\xcd\xa9\x79\x83\xa8\xc7\xbc\x4e\xaf\x33\xca\x98\xdb\x1b\xc6\x1e\x51\xa7\xe6\xcd\x6f\xe2\x8f\xf2\xdd\x3c\xcf\xa7\x1b\xf4\x48\x2c\x16\xeb\x45\x4e\xfc\x97\x79\x67\x51\xe5\x93\x6a\x62\xe0\xe4\x33\x48\xbe\x1c\x8a\x20\xee\xf0\x8e\x1d\x3b\xea\xda\x61\x19\x2c\x6d\x57\x0a\xa6\x31\xfd\xff\x4e\x92\x7f\x90\xdf\x82\x78\xa4\xa7\x96\xb5\x8e\xc8\x79\x91\xa7\x6a\xbb\x41\x26\x46\x00\xe9\x46\x4e\x5c\x34\xe2\x10\xb4\xe9\xc1\x96\xe5\x23\xe1\x9d\x70\x02\x4e\x74\x1d\xc2\x17\x94\x6b\x94\x6b\xf0\x3a\x2c\x46\x2e\x44\xae\x9b\x88\x45\x78\x54\x99\x42\x68\x34\x1b\xbd\xca\xa7\xe1\xf3\xa4\xdf\xcd\x08\x59\x98\xc3\x20\x89\xc3\x21\x01\x13\x56\xa3\xca\x1c\xf3\xfa\xde\xd3\x09\x3b\xe9\x9e\x6d\x3e\xad\xeb\xd4\x76\x7c\x7e\x87\xb2\x00\x67\xd1\xfe\x05\x67\x44\xee\xe2\xde\x14\x1f\x25\x3a\x71\x72\x48\xd6\xb1\x5e\xd9\x6d\x93\x05\xba\x3b\xfa\x44\xcc\x24\x27\x6f\x93\x5e\x4b\xd3\xe7\xfc\x19\x81\x6c\x3a\x36\x29\x89\x4e\x7c\x70\xe7\xc3\x1b\x6b\x46\x07\xb3\x52\x4d\xd6\x6c\x9f\x35\x53\x2f\x46\xee\x92\xa6\x1c\xfb\xa1\xa6\x38\xa7\xcc\xa0\xcb\x0b\x04\xfc\xf3\x28\x44\x21\x72\x17\x3e\x48\xf2\x48\x40\xa7\x43\x65\x3a\x9c\x90\xe0\x74\x21\x17\x7c\xef\x82\x8f\x5c\x70\x8b\xeb\x29\xd7\x9f\x5d\xdc\x66\x17\x2c\x77\x41\xb3\x0b\x12\x5c\x99\xae\x32\xd7\x64\x17\x4f\x52\x2c\x3a\x46\x1e\x7d\xe6\xe2\x5c\xb4\x41\x5b\x48\x47\xff\x84\x0b\x7e\xed\x82\xa7\x5c\xc7\x5c\x98\xc6\x1d\x68\x9e\x59\xc7\x9e\x99\xc3\x8d\x75\x3b\x5c\xd0\xe6\x5a\xee\xba\x56\x4b\x3e\x64\xd4\xb8\xba\xdd\x2e\xa0\x1b\x71\x5d\xe9\xae\xc5\xae\x1d\x2e\xa1\xfa\x9c\x0b\x8a\x5d\x21\xd7\x6e\xd7\xf3\xae\x37\x5c\x02\x72\x15\xbb\x9a\x49\xfc\x13\xe4\xf6\x23\x97\x44\x93\x9c\x77\x71\x4d\x2e\xb0\xba\x80\x50\x00\x31\x0a\x50\xf9\xcf\xe6\x32\x9a\x1a\xf2\x97\x2c\xc9\xcf\xa7\x3d\x7c\x9c\xdd\x12\xdd\x25\x4c\x34\x9c\x04\x31\xb6\x84\x4e\xf5\x06\x5c\x8e\x33\x76\x3e\x70\x6d\xf5\xb8\xd2\x4c\x5f\xa2\x21\x2d\xcd\x9a\xe2\x16\x1f\xfd\xf1\xe1\x97\xfe\x31\xa8\x28\x50\x6e\xe5\x73\xb3\x82\x9b\x68\xff\xfe\x03\xce\x12\x0e\x62\xaa\xc5\xde\x79\x90\x13\x10\x0f\xe8\x30\xe0\x50\x6b\x18\xba\xce\x09\x70\x54\x80\x7d\x02\x6c\x12\xa0\x46\x00\x8b\x00\x8b\xcf\xb1\x1b\x72\xb5\x43\x80\x74\x01\x9e\x10\x20\x24\x80\x95\x54\x96\x00\xd5\xe7\x05\x78\x9e\x45\x6d\x16\xa0\x9e\x3d\x28\x62\x49\xbb\x05\x38\x29\x40\xbb\x00\x4d\x02\xa4\x09\x70\x2e\x0a\xb2\xa1\x8f\x7f\x09\xcd\xa0\xee\xe9\xa2\x7a\xdc\x1e\x72\xc4\xdc\x32\x08\x47\x71\x56\x47\x07\xd3\xdb\x9e\x8f\xec\xc4\x13\xa4\x3a\x66\x3f\xe8\x99\x73\x19\x4e\x41\x17\xa8\x43\x87\xa8\xfa\x1f\xb4\xf9\xe1\xf9\x8e\x0e\xa9\xee\x87\xd1\x84\xc7\xb6\x45\x76\xb2\x32\x52\x3e\x35\x50\xff\x9e\x20\x09\x0a\x69\x2d\x80\xf7\x87\x51\x97\x3a\x0b\xa7\x6d\x43\xa3\x0e\x24\x28\xa3\xe2\x6d\x5c\x4e\x64\x5e\x07\x3e\xd4\xd1\xb9\x90\xe9\x41\x3f\x44\x76\x72\xa9\x51\x18\x02\xc6\x12\x88\xbc\x82\x05\x06\x03\xf7\x85\xc1\x31\xa7\x51\x06\x2e\xa7\x83\xe0\x7c\xe1\x03\xfe\x66\xa6\x4b\xe1\x6d\x94\xd6\x12\xb5\xc5\xd3\x9e\xa6\x6a\x2a\x2f\x31\x00\x4f\x51\x00\x17\xd8\x9a\xbd\x18\x12\x4c\x63\xc5\xdb\x3a\xf0\xed\x5d\xef\x48\x75\x9d\x0b\x3b\xb4\xba\xe2\x52\xd9\xfb\x04\x07\x4c\x7d\x64\x89\xdc\x85\x7f\x85\x43\xd0\x66\xc0\xb7\x53\x1c\xf8\x9b\x2f\x7c\xa0\xe1\x40\x69\x41\x60\x48\x28\x37\x64\x24\xe2\x17\x21\x1d\xaf\x97\x94\x3e\x88\xf4\x00\xea\xc1\x86\x12\x85\xe0\x43\xa8\xc2\x10\x8a\xa7\x8b\x06\xcf\x4c\xbd\x44\xf0\x7a\xa4\x13\x15\x82\x97\xd4\x0b\xaf\x78\x78\x2a\x6a\x7e\x86\x9c\x8a\xdd\x0f\xa3\x35\x1a\x51\x78\xac\xae\x24\x54\x10\xb2\xf0\x92\x84\x38\x8e\x01\xa4\xae\xc8\x18\x40\xe8\x8a\xae\x08\xea\xd9\x27\xaf\xb2\x08\xa3\xb9\x70\x94\x56\x1b\xe1\x94\xce\x85\x04\xa4\xc6\xdf\x0c\x3f\x02\x8f\xd4\x1b\x92\x24\x02\x8f\xbb\x40\x8b\xfe\xaf\xe1\xd9\x68\xa9\x19\xfd\x6e\x67\x38\xd2\x4a\xd0\xf0\x23\xf0\x64\x54\x19\x4a\x10\x74\x3a\x2c\xcb\x04\xa4\x09\x19\x0d\xa4\xcc\x3a\x19\xcb\x04\xe8\x81\xb0\x40\x8b\xad\x2d\x89\x8b\xdf\xcf\x1f\x0f\xda\xa7\x51\x80\x91\x34\x9a\x03\xc3\x9a\xae\x05\xfd\x01\x96\x08\x07\xb9\xf9\xac\xaf\x2c\x24\x5c\x4b\xd1\xe6\x79\x9d\xc0\xb3\x7a\x12\x22\x51\xec\x3b\xa3\x93\xc8\x3d\xbe\x4c\x28\x2d\x40\x6d\x32\x17\x86\x90\x66\x73\xa6\xa3\x43\xb9\x83\x35\x1d\x84\xe1\x0c\xa9\xaf\x37\x25\xb5\x0f\x4e\x0f\x99\x49\xd3\xe5\x11\xe9\x90\x24\x8e\x50\x98\x54\x7d\x69\x4d\xfc\x58\x07\x6b\x47\xf4\x4b\x40\xc0\x5c\xb5\x3d\xe9\x0f\xf6\xb4\x29\x82\x9f\x1e\x55\x11\xfb\x59\x14\x65\x52\xf7\xb4\x53\xd1\x2b\xbc\xc4\x50\xe4\x23\xd1\x16\xd6\x19\xbf\xa5\xa3\x67\x28\x53\x6d\x6a\xce\xb8\xe6\xc6\x28\xc1\xcd\xef\x38\xdd\xd1\x95\x41\xdb\xf9\x19\x8d\x17\xf4\xa8\x5f\xc8\x44\x3a\x4e\x41\x2f\x18\x40\x26\xbd\xb7\x48\x00\x1f\x0c\xeb\xbb\x78\x9d\x12\xdd\xe0\xc6\xd8\x2b\x8a\xb6\x53\xf3\xd9\x66\x13\x0e\x2a\x29\x04\x1c\x6b\xc6\x94\xbe\x82\x5f\xa3\x01\xc3\x5d\x20\xb5\x58\x1d\x32\x63\x9d\xce\xc4\x21\xbd\x88\x44\x23\xc9\x85\x80\x7e\x3a\x2c\x46\xe4\x1e\x09\xa1\xe1\x1f\xec\x71\xe1\x17\x87\x3f\x21\x8e\x1a\x9e\xe1\xde\xef\x3a\x48\xa8\x84\x97\x93\x2c\x49\x21\x2e\x3c\xc3\x2f\x52\xcb\xa1\xb6\x91\x28\xad\x98\x8f\x5a\x83\xcc\x13\x62\xe9\x14\x91\x63\xb4\x12\x3b\xb1\x5e\x6d\x2d\x91\x38\x5a\x41\xfc\x64\x34\xa9\xd4\x72\xd5\x17\x9d\x81\x92\x89\x88\x16\x58\x42\x4a\x76\x21\x97\xfb\x30\xd6\x0e\xdf\x64\xb4\x2a\x0c\x59\xf5\xa2\x80\x45\x2c\x23\x03\x21\x90\x78\x71\xc3\xe9\x45\x2c\x2e\xea\xe0\x8e\xc8\xab\xf7\x29\xad\x54\x89\xa5\x32\x22\x56\xe1\xf6\xd0\x4a\x27\x53\xa7\x2d\x46\x13\xaf\xd7\x1b\x0d\x2a\xad\x0c\x11\x2c\x29\x8c\x2f\xf7\x87\x85\x38\x5a\x69\xe8\x47\xeb\x84\x7a\xe9\x2b\x07\x1a\xf8\xb8\x37\x3b\xba\x0e\xe2\xe5\x1d\x4a\x0a\x5e\xce\xcd\xbf\x90\x2b\xd4\xb2\x72\x74\x30\xf9\x44\xf9\x9e\xf0\xa7\x9e\xb4\x2f\x13\xe1\x2b\xbd\x9e\xd0\x4a\xa7\x93\x59\xc5\x10\x4a\x45\xa2\x92\xaa\x33\x26\xa9\xf2\x7b\x53\x4a\x95\x56\xce\xa8\xfc\xa4\x6c\x45\x65\x68\x57\x06\x29\x9c\x6a\xf7\x9f\xd1\x64\x82\x1e\xe5\x11\x9d\x43\xc0\x7a\x41\x6f\xe0\xc9\x05\x01\x7c\x28\x8c\x75\x5d\x48\xbc\xc0\x5c\x97\xe4\xf7\x62\x2a\xb5\xcd\x92\x6b\x6e\x48\x07\x7c\xda\x95\xd9\x71\x9a\xc9\x41\xc1\x4f\x24\x21\xe1\x29\x0d\xef\x28\x4f\x09\x3a\x59\x90\x89\x5e\xcb\xf3\x26\x9d\xcc\x30\xd6\x75\x32\xd4\x0f\x92\x4a\x16\xd5\xa6\xd6\x0b\xf9\x5e\xd9\x68\xe1\x99\x0e\x6e\x74\x57\x26\x69\x79\xf0\x69\xe4\x26\xa9\xee\xc2\x33\x1d\xc2\x69\x52\x0e\x56\xdf\xb0\x84\xc9\x5d\xc6\x53\x44\x85\x66\x74\x22\x3c\x25\x5d\xf8\xdf\xf3\x54\x50\xe5\x29\x22\x8b\x18\x4f\x71\x1f\x5e\xc8\x45\xd1\xfe\xe6\x4d\x96\x07\xe1\x29\x4e\x24\xdd\x0d\x92\xc1\xa0\xe3\x2f\x90\xfc\xa0\x47\xba\x5f\xcc\x53\xa0\x42\xa5\xb4\x7a\x93\xe0\xff\xa9\xca\x56\x1a\x53\x31\xd9\xc6\xe0\x6a\xb4\x92\x89\x8e\xaf\x23\x3c\xa5\x07\x88\xf1\x54\x27\x2f\x5e\x88\xe6\x11\xf9\x59\x9e\x62\xd9\xf8\x82\x2a\x4f\x75\x65\x72\xa3\x3b\x14\xa9\x23\x72\x13\x7c\x4a\xca\x21\xd4\x76\xaa\x32\xaf\xa7\xcf\x93\xd1\xe0\x90\x55\xc4\xd4\x49\x0e\xe1\x60\xd2\xea\x65\xe5\x5f\xb1\x55\x1f\x7a\xf5\x62\xad\x58\x67\xa8\x75\x88\x8c\xbb\x68\x6b\x8f\xc9\x17\xd6\xe7\xc8\x28\x18\x72\x10\x4d\x5b\x14\x25\x59\x32\xf2\x26\x49\x56\x90\xae\x6f\x97\x1d\x8c\x27\x5e\x7c\x7f\x4b\x45\x2f\x63\x36\x22\x51\xa8\x04\xd7\xfa\x5d\x26\x81\x11\xb1\x8d\xa2\xf9\x10\xe1\x85\x2c\x68\x44\xc8\x66\x16\x45\x1b\x02\xa3\x4e\x67\xd1\x83\xde\x6a\x33\x5a\x58\x99\x8c\x9d\x4c\x24\x87\xf4\x44\x26\x1b\xf0\x05\x3d\x30\xa1\x19\xac\xe9\x63\x54\xc4\x72\xf7\xdb\x82\x0e\xb5\x7b\x52\xb5\x90\xf9\x1d\x1d\xa7\x99\x54\x63\x6c\x18\xd9\xa9\x3f\x48\x18\xb1\x2b\x43\x7f\x90\xb1\x62\x9c\x0e\x40\xe9\x6b\xa7\xf4\x25\xc2\xc1\x44\x98\x91\xf4\x89\xf1\xec\x28\x5f\xc4\x8e\x7d\xe9\xdb\xc3\x90\xfe\x18\x4b\x46\x79\xf2\x87\xd1\x44\xd2\x69\xf2\x48\xa3\x6d\x49\xc8\x4e\xe4\x9c\x41\x16\x65\xd2\xff\xca\xa2\xa2\xbb\x48\xeb\xe8\x45\xda\x38\xcd\x83\x52\xd6\x40\xf8\x92\xf5\x6a\x31\x0d\x44\xf0\x53\xc2\x72\xb1\x3c\x54\xba\xd6\x86\x6c\x22\x29\x12\x31\xd8\x64\xce\x6a\x93\x4c\x26\xab\xc5\xc8\x98\xd4\x12\xe1\x64\x25\xda\x17\x75\x22\x9e\x09\x8d\x4b\x71\x6a\x7c\x5f\x4a\x6d\x66\x55\x08\x0e\x61\xdd\x32\xe5\xd6\x0e\x26\x09\xd5\xce\x95\x30\xad\x26\x0b\xb1\xaa\x6b\x10\xd9\x4b\xcb\x1a\x62\xda\x10\x75\x53\xc8\x51\x37\xcc\x46\xbd\x4e\xad\x52\x7d\x67\xbc\x6e\x14\x89\x36\xc7\x38\x85\xa0\x8f\x86\xa4\x69\x06\x84\x6b\x23\xf3\x84\xa3\x84\xb8\xa4\x2a\xb9\x0f\x29\x1d\x7a\xe9\x5f\x32\x2a\x0b\x39\x74\x32\x4f\xf9\x96\x23\xe4\x15\x0d\x8a\xee\x22\x1d\x4c\x6b\xf7\xb6\x5e\xbd\x49\xac\xf3\x25\xb9\xa8\xbd\xaf\xa6\x8d\x69\xba\x0d\x17\x2b\x17\x6d\xff\x16\x34\x32\x64\x37\xe9\x74\x36\x22\x86\x45\x2c\x5a\x6d\x66\x8e\xb3\x5a\xcc\x4c\x14\x5b\x3a\xf5\x1c\xcf\xb1\x4b\x91\x8f\xc8\x1a\xdf\x46\x97\x83\xc7\x53\x38\xc6\xb9\x84\xb0\x41\xb5\xed\x10\xfb\x98\x70\x2e\x25\xac\xca\xbc\x78\xf9\x85\x21\xa4\x5e\x3f\xa4\xe5\x15\x4e\x93\xd2\x6a\x3a\x96\xc6\x4b\x84\xbe\x92\x2c\x9b\x04\x3a\x18\x81\x74\xba\x1e\xfa\x46\xe2\x75\xc5\xce\xbe\xf4\xed\x39\xf9\x28\xaa\xd6\x31\xfa\x32\xb5\x4e\x53\xbe\xb8\x0f\x49\x3b\xd1\x14\xb0\x1e\x7d\x94\xd1\x57\x2d\xb3\x91\xb2\xaf\xc4\x5d\xd0\x5f\xa4\x93\x5e\x92\xbe\x5a\x79\x49\x2e\x4c\xb0\xc2\xa7\x31\xd1\xca\xcc\x04\x4a\xdf\xb8\xbe\x88\xd1\x97\xb7\x58\x6c\x44\x37\x15\x64\xc1\x6a\xd3\x1b\x8d\x56\x93\x91\x11\xd5\x14\x21\x1d\x9f\x5e\xed\xf5\x0c\x9d\x3d\xbd\xde\xcf\xd2\x37\xd6\x37\x95\xfb\x68\x31\x99\x6c\x8a\xdc\xa4\x71\xb1\x92\x22\x1c\x65\x82\x90\x5f\x44\x98\x98\x08\xe2\x0e\x14\xa7\x2f\x3b\xd0\x94\x50\xa2\x49\x6f\x25\xf2\xd7\xe1\x48\x70\xca\x16\x8b\x93\x48\x88\x04\x3b\x91\x10\x46\x9e\x69\x0f\x4f\x87\xf5\x42\xa7\x55\x65\xb1\x03\x61\x13\xe5\xe5\x98\x2f\x96\x78\x45\x3a\xa6\x4c\xf7\x95\x19\x31\xd1\x1c\x93\x1d\x31\x01\xad\xc9\x10\x4d\x4a\x33\x95\xa9\x17\x6e\x23\x43\x5e\xbb\x5e\x6f\x31\x12\xa3\xca\xa1\x33\xea\x12\x78\xa7\x29\x01\x59\x49\x8d\x98\xcc\x26\x86\x9a\x1d\x9b\xbb\xa8\xf0\x66\x1e\xcd\x2e\xae\x9a\x60\x7c\x33\xef\x69\x01\x5a\x37\x18\x95\xe1\xa7\x09\x3b\xd2\x3a\xd3\xe4\xb8\x5a\x69\xac\xee\x98\xcf\xc1\x18\x3e\xb4\xde\x6c\xc8\x8d\x5a\x43\x89\xbc\xd9\x4c\x0f\xd4\x73\xeb\xb0\xc5\x22\x18\x75\x46\x8f\xd7\xa9\xd7\x7b\x04\xa7\xcb\x49\xd9\x53\x0e\x63\x57\x27\xb2\x5f\xb0\x44\xab\xd1\x68\x88\xd8\xa4\xf8\x66\xa2\x5d\xc4\x55\x66\xfc\xfa\xb0\x28\xba\x5c\x7c\xc3\x09\x6a\xd2\x89\x56\xed\xe9\xb8\x06\xa4\x55\x33\xab\xe2\x0b\xcf\xa8\x0d\x89\xc9\x2b\x36\x27\x87\xf0\x55\xc2\x63\x4c\x66\xda\x0f\x51\xb7\x8c\xf8\x02\xa0\xa2\x9a\x98\x53\x46\x9b\x4f\x78\xec\xc2\xe5\xc2\x63\xf8\x2a\xfe\x3d\x35\x3d\x29\x2b\xb9\xeb\x49\x4f\x5b\x77\xd1\x45\xe9\x23\x3b\xf9\x77\x7b\xd2\x33\xf8\x8e\xa7\x35\xf8\x4a\xd4\x85\x63\xef\x17\xf4\x07\xb5\xf4\xf8\xed\x4b\xa6\xa7\x53\x7a\x34\x3d\x7e\x3b\x92\x47\xbe\x6a\x7a\x7c\x2a\x0e\x3e\xf0\x48\xb8\x38\x3d\x81\x1d\x4b\x9f\x87\xe6\x44\xfe\x21\x3c\x26\x3e\xa0\x8d\x65\x5a\xd8\xfa\xea\x24\xb6\x8b\x28\xea\x91\xa0\x12\x55\xa3\x1a\x74\x19\x1a\x81\x46\xa3\xf1\x68\x12\xba\x02\x4d\x47\x4d\x68\x26\x9a\x83\x16\xa0\x45\x68\x19\x5a\x85\xd6\xa1\x4d\xe8\x1a\xf4\x4b\x44\xcf\x4a\xda\x89\x6e\x47\x77\xa3\xfb\xd0\x03\xe8\x21\x84\x1c\x41\xa7\x3f\x4b\xfb\x0a\x71\xd7\xd2\x7f\x10\xef\xfe\x2f\xd2\xc3\xbf\xb8\xb6\x5d\xe2\x3b\x67\xee\x5c\xd8\x45\xbe\xbb\xe7\xcc\x89\x74\x90\xdf\xfb\xd4\xef\xc9\x39\x73\x94\xe6\xb9\x73\x95\xd6\xb9\x73\x79\x13\xf9\x6d\x51\xbf\x27\x7b\x52\x9f\xbc\x64\xec\xcf\xc0\x38\xd9\x13\xdb\xf5\x62\xcf\x75\xe7\x77\x3d\x6f\xd2\xdf\x9e\x3f\x21\xa3\x95\xfe\xb5\x34\xf7\xfc\xcd\xbc\xf8\xba\x85\xfe\xb5\x36\xd2\xbf\x56\x76\xad\x46\x4b\x7f\x63\x2f\x83\x9f\xdd\x29\x67\x5b\x95\xb3\xcd\xca\x07\xe4\xd3\xa2\x7c\xd8\x22\xfd\xbd\x19\x4d\x26\xbc\xf5\xff\xbf\xba\x7f\x0c\xed\x43\x07\xd0\xd3\xe8\x59\x74\x14\xbd\x84\x5e\x41\xf4\x4c\xfa\xb7\xd0\x69\xf4\x1e\x3a\x8b\x3e\x45\x9f\xa3\xaf\xd0\x39\xf4\x1d\xfa\x27\x31\x4a\xbb\x81\x03\x09\x64\xb0\x80\x03\xdc\x90\x04\x69\xe0\x87\x00\xe4\x43\x11\x04\xa1\x12\xaa\xa1\x06\x2e\x83\x11\x30\x1a\xc6\xab\xfc\x54\x79\x89\xaf\xf0\xff\x41\x7c\x56\x9f\xb8\x28\x2f\x06\x2e\xf1\x95\x7e\x06\x8e\xfb\x7f\x99\x1e\xfe\x97\xf1\x0e\x0d\x96\xfb\xdf\xfc\xda\xb4\xb4\x73\x18\x53\x92\xcf\x1b\xec\x43\x2e\x3a\x6f\x22\x4c\xad\x7e\xd4\xd8\x39\x73\xba\xa6\xfd\x17\xa9\x60\x57\x7c\x9a\x17\xe7\xcc\xe1\x7e\xd3\x3b\x11\xf9\xcc\xb9\x08\xd8\x9c\xff\x20\x4d\xe7\x77\xff\x09\x0e\xea\xab\x73\x7e\x2e\xa4\xbf\x5a\x2b\x6b\xbd\xa8\xad\x35\xff\x4c\xbb\xfb\xd9\xf8\x96\x9e\x3f\xb5\x3d\x36\xc6\xb5\xca\x96\xb8\xb6\xd9\xab\x85\xb6\xc6\xb7\xd3\xe6\x68\x6b\x6d\xd1\x80\x93\x2f\x01\x46\x6f\x49\x72\x92\x08\x91\xd6\x48\xfb\x90\x53\xa4\xdd\x8e\x44\x63\xd1\x04\x74\x39\x0a\xa3\x06\xd4\x82\x66\xa1\x79\xe8\x2a\xb4\x04\xad\x40\x6b\xd0\x06\xb4\x05\x5d\x87\xae\x47\xdb\x50\x07\xba\x15\xdd\x89\xee\x45\xbf\x42\xbf\x41\x8f\xa0\xbd\xe8\x49\x74\x10\x1d\x41\xbf\x43\x2f\xa0\xdf\xa3\xe3\xe8\x04\xfa\x13\x3a\x85\xce\xa0\x0f\xd0\xc7\xe8\x2f\xe8\x0b\xf4\x37\xf4\x0d\xfa\x07\xfa\x09\x45\x00\x40\x00\x3d\x98\xc0\x06\x4e\xf0\x42\x0a\x5d\x3c\x05\xb9\xd0\x0f\x4a\xa0\x1c\xaa\x60\x10\x0c\x81\xe1\x30\x12\xc6\xc2\x04\xd2\xe9\x10\xe5\xa0\xdc\x7f\x89\x6f\xd0\xf9\x73\x5f\xbf\x93\x58\x11\x17\x7f\xa1\x4f\x42\x37\x89\x0b\xc4\x7d\xa5\x3e\xcf\x05\x12\x57\x19\x7f\x4f\xbe\x3e\xf2\x95\xca\xfd\xce\x2c\xf2\xeb\x20\xbf\xfe\xb8\x6f\xdf\xf7\xff\xed\xf3\x3e\xf9\x43\xdf\xfb\x3e\x78\x46\xdf\x97\x34\xbc\x28\x3e\x6e\x02\xd7\xdd\x07\xbe\xa3\xef\xbd\xf6\x7e\xf4\x57\x38\x75\x21\x7f\x7e\xcf\xdf\x02\xfa\x4f\xff\xa2\xbf\xd1\xbf\x0b\xb7\xf6\x44\xbd\x4d\x3e\xf3\xe7\x9f\x22\x1f\x2d\x2e\xf2\xe5\x7c\xed\x61\xd7\xa3\x0b\xa0\x66\xc1\xa9\x05\xf0\xd8\x82\x1e\x30\x71\xb0\x7a\xdf\xc7\x00\x61\x17\xbb\x39\xc5\x3e\xf8\x2b\x9a\x22\x96\xc1\x02\x0a\x5b\x99\x42\x9e\x9c\x8a\xbe\x1d\xfb\xa5\x69\x16\xb0\x97\x22\x3b\x21\xa3\x85\x7e\xfc\xcd\xe0\x6b\x65\x9f\x5e\xad\xe7\x85\x58\xa7\x44\x3e\x8d\x24\x14\xe7\x47\x1f\x3d\xdf\xb7\x41\x3e\x1f\xbd\x78\x29\xbe\x9d\x5c\xd4\xde\x7a\xa2\x62\xa9\xc4\x13\xd1\x36\x16\x6d\xe9\x24\x57\x2d\x8b\x96\x18\x68\x15\xec\x0b\x31\x60\x2a\xa0\x1e\x00\xec\x65\x75\xdd\xd7\x3a\xb4\x82\x9f\xc6\x4f\x66\x67\x95\x71\x98\x17\x38\x76\x56\x99\xba\xe4\xcb\x41\x34\xac\x75\xdc\xd9\x2e\x1f\x3f\xb9\xcb\x87\x30\xa2\x1e\x8c\x4f\xf2\xc7\x59\x1f\x9b\x1a\x32\xd2\xa3\x87\x01\xe9\x89\x09\x4a\xde\x2a\x3a\xf1\xc1\x89\xf8\x15\x79\xe4\x55\x87\xcd\x67\x13\xf9\xe3\x9d\x95\x63\xf8\x12\xfa\xc3\x6f\xe8\x3c\xc9\x97\x90\x57\xae\x82\x4d\x78\x1e\xb7\x8e\xe5\x89\x39\x5e\x00\xac\xad\x0c\x8a\x6a\x81\xf3\x14\x1e\xba\x60\x13\x31\xb9\xd8\x7c\x69\x4f\x7a\x96\xaf\x88\x05\x0e\xd3\x93\x07\x40\xc4\x7d\xf3\x05\xcd\x13\xb5\x0a\x62\x8c\x72\x0f\x85\xa2\xd4\x43\x9b\x72\x8f\x5a\x5e\xf2\xa7\x43\x78\xae\x7a\x36\x1b\x12\x78\x0e\x7a\xca\x4b\xde\xf3\xe9\xd0\x8f\xe4\x71\xe4\x0e\x3a\x26\xb9\x0b\x21\x71\x0c\xff\x38\xc1\xc0\x76\x10\x11\x44\x21\x8e\x36\x3e\x3d\x79\x8e\xa7\xe2\x29\xfc\xe3\x9d\x13\x49\xda\x8e\xee\xbf\x88\xd3\xf8\x3d\x6a\x5a\xe0\xb4\x33\xdf\xd4\xb4\x7a\x0c\x1d\x8c\x00\x7b\x22\xbb\x22\x77\xab\xe3\x9d\xbb\x48\xfa\x31\xfc\x4e\x96\x1e\xa3\xde\xb0\xf5\x58\x1c\x13\x79\x34\xf2\x30\xbf\xb3\x73\x22\xc9\x9e\xa5\x8f\x87\xdf\x37\x3d\x11\x6c\xe2\x34\x0a\xbe\xb3\x0a\xcf\x22\x29\x92\x99\x1f\xc5\xdd\xc4\x66\xd1\xc3\xf0\xd0\x27\x08\x74\x3c\x27\xea\x44\xac\x17\x04\x59\xc2\xd8\x20\x8b\x3c\xe8\xd0\x48\x19\x72\x65\xd0\xcb\xf0\x93\x0c\xc7\x65\x98\xc7\xae\xe7\xfe\x55\x86\x3b\x65\x58\xc3\xee\xc3\x32\x90\x44\xd5\x32\x78\xd9\xb3\x1f\x64\xf8\xb3\x0c\x2f\xcb\x70\x48\x86\x07\x65\xb8\x4d\x86\x95\x51\x10\xe4\xfd\x47\x64\x98\x22\x43\x85\x0c\xa2\x0c\x95\x24\xe9\xdb\xd1\x14\x6d\x32\x4c\x94\x61\x98\x0c\x65\x32\x64\xca\x90\xc0\x52\x7c\x2b\x03\x7c\x24\xc3\x1b\x32\x3c\x2f\xc3\x13\x32\xfc\x5a\x86\x1d\x32\x5c\x2b\xc3\x72\xf6\xc2\xe4\xe8\x0b\x24\xf5\xab\x32\x3c\x26\xc3\xdd\x32\xdc\x28\xc3\x3a\x19\x16\xc9\x80\xc7\xcb\x50\x23\x43\x11\xdd\xd8\x0f\x16\x99\x1e\x64\x40\xff\x9a\x2e\xb1\xdc\xa6\xe9\x62\x5f\xf9\x17\xaf\xc3\x89\xae\x1b\x46\x45\xda\x54\x4b\x74\xc5\x7c\x6c\x66\xdf\xe7\xd7\x43\x50\xcf\xe3\xca\x89\x4a\x25\x1c\x9f\x08\xaf\x2a\x66\x65\x17\xb4\x42\x33\x3e\x89\xff\x14\x29\xc1\xe5\x91\x57\x23\x2f\xe2\xc1\x84\xf6\x0f\xa1\xfb\xf9\x42\x3e\x97\xed\x51\x24\xbc\x6a\x45\x1e\x1d\xd2\xa5\xfb\x12\x8c\xc9\x3c\xe1\xd5\xf7\x7b\xb5\x91\xe8\xf2\x2f\xe6\xc4\xa3\x10\x2a\x13\xe8\xda\x3c\xba\x8b\x4b\x75\xf1\xf4\xd0\xea\x3f\xad\x59\xfb\xe6\x9a\x35\x7f\x5a\xb7\xf6\x8d\xd5\x53\x5a\x1f\x9a\xd9\xfa\x48\x5b\xeb\x63\xad\x2d\x8f\xb4\xe2\x36\x1a\xff\x16\x79\xb4\x7a\xf5\x1b\x6b\x5b\x1f\x69\x69\x7e\xb4\x95\x3c\x69\x7d\x84\x1d\x79\x83\x5a\xd1\x14\xbe\x89\x9f\x48\x5a\x8b\x85\xed\xd7\x0a\x10\xfd\xb7\x92\xe8\xbe\x23\x88\xde\x7b\x05\xd1\x79\xe7\x10\x7d\x77\x15\xd1\x75\xdf\x08\x2d\x48\xae\x9f\x3b\x77\xf2\x95\xfd\x57\xaf\x1e\xb8\x3e\x67\xf1\xe2\x82\xe5\xe9\xcd\xcd\x99\x6d\xba\xba\x3a\xe3\x18\x14\x0a\xf1\xc3\xac\xc5\xc5\x09\x65\x65\xc3\xc6\xb4\x2d\x5f\x7f\xa5\xe4\x99\x3a\xc3\x33\x63\xcb\xe6\x51\x4b\x97\x8e\x5b\x39\x74\xed\xda\xda\x8d\xa5\xf3\xe7\x57\x2c\x4c\x9c\x36\x2d\xb5\xd1\x3e\x71\xa2\x6b\x0a\x1e\x30\x40\x1c\x6c\xc8\xcb\x33\x17\xae\xdc\xb8\xb0\x71\xca\xe0\xc2\xc2\xc1\x53\x1a\x17\x6e\x5c\x29\xcd\xce\x9e\xdd\x9a\x91\xcd\xd6\xa9\xdb\x34\x77\x3d\xcc\x63\x4f\xdc\xfa\xf4\x9f\x09\xb4\x35\x8d\xee\xaa\xff\x20\x31\x5b\xf6\x48\x8f\x66\x09\x96\x06\xb4\x5f\x87\xf6\xeb\xd6\x7e\xa3\xcf\xa5\x3e\xf7\x7d\x7f\xfb\x3e\xef\x7b\x9f\xd5\x07\x7e\x34\x3f\xee\x9d\xb2\xfe\xfd\xcb\x6e\xa1\xc1\x3f\x2b\xcb\x2b\xcb\x33\xe9\x95\x52\x59\x41\xfe\xf6\x56\x96\x97\x57\xe2\x89\x34\x8c\x24\xd2\x08\x7c\x4d\x2c\x6d\xe4\xf1\xb2\xfe\x15\x15\x2c\x31\xfc\x81\x3e\x53\x66\xd0\xf0\x9f\x34\xf1\x2d\xf4\x8a\xbb\x8d\x04\x05\xe4\x4e\x79\xab\xb2\xb2\xfc\x53\x72\x03\x3b\xc9\xc5\x34\x0a\x6c\x15\x09\xe0\x48\x45\xb0\x2a\x32\x8c\x5c\xdd\x59\x56\xd6\x1f\x27\x6b\x89\x14\x8e\x5c\x7c\x46\x5f\x3b\xd5\xbf\xac\x7f\x1e\xb9\x50\x65\xe0\x7e\x74\x3d\xef\xe7\x2e\x20\x13\x9d\xab\x37\xf0\x66\x8b\x64\xd1\xce\xdd\x8a\x0a\x14\xc6\x95\xc8\x9f\x81\xe8\xd6\x5e\x3c\x7f\xe1\x99\xa5\x8a\xf2\xf4\x21\x45\x59\x74\x9a\xbb\xb0\xfc\xdd\xf9\x4f\x2b\x0a\x70\x87\xae\x3c\xb5\x4a\x95\xcf\xb9\x44\xde\xec\xe1\xaf\x61\xfb\xeb\x08\xcf\xf3\x60\xc4\x18\x12\x9c\x56\xa0\x27\x72\xf6\x96\xcf\x41\x22\x63\xa1\x0f\x9f\xe7\xf2\xd7\x74\xf1\x2b\x5f\x5d\xb5\xf2\xc4\xca\x95\xaf\x91\x70\x05\x7f\x4d\xe7\x06\x3c\x64\xe5\x6b\x2b\xc9\x35\x89\x5c\xf5\x1a\x81\x1c\x9f\x87\x9f\x9e\x47\xc5\x27\x24\x80\x31\x39\x99\xe4\x94\x99\x65\xf5\x90\x36\x46\x4b\xf0\xc1\x07\xaf\x5b\x3f\x78\xbd\xcf\x94\x20\xcb\xb3\x4f\x5b\x0b\x5c\x02\x87\x09\xad\x8f\xb6\xb4\x90\x86\xc4\xc2\xb1\x17\x23\x14\x7b\x46\xc2\x78\xe4\x18\x0d\x96\xc1\x75\x78\x26\xb7\x82\xd0\xd4\x4b\x69\x90\x20\x99\x49\xf3\x4b\x4c\x72\x73\x36\x43\xdf\x76\xcf\x16\xe7\x46\xf7\xf4\xb9\xa4\x38\x2f\x49\x78\xe6\xed\x2d\xc3\x16\x0f\xdb\x39\x6b\xce\x88\x51\x63\x66\xd7\xd6\xce\x6e\x1d\x35\xb6\x09\x6f\x58\xb0\x6d\xc8\xd2\xe1\x73\x3a\x46\x8d\x98\x53\x3b\x7b\x76\xed\x88\x59\xf3\x90\x00\x4f\x92\xfe\x60\x0d\xe9\x0f\x64\xe4\x41\x99\xa8\x18\x0d\x40\x8b\x42\x21\x87\x38\xc0\x9b\x56\x91\x9f\x65\x44\x28\x2b\x4d\xe4\xab\x07\xe6\x24\x67\x14\x66\x94\x97\xcc\x2d\x81\x70\x09\x8c\x28\x01\x6f\x09\x94\x04\xfb\x5b\x32\x9a\x32\x16\x65\x70\xba\xfe\x21\xbd\xb9\x2e\xa3\x7f\x46\x7f\x8e\x9e\x0c\xae\x77\xd1\x5e\xfc\x7d\xba\xa4\x8b\x34\xd1\xfc\xc6\x06\xeb\x89\x20\x15\x8c\x14\x69\x75\x7d\x71\x6c\x0f\x82\x56\x0c\x24\x65\xa0\x00\xdb\x87\x2a\x95\xa1\x00\x5d\xfc\x93\x80\xdc\xa5\x08\x7a\x96\xbd\xd0\x13\xfb\x62\xd7\xd4\x3d\x75\xa5\x9b\xae\x15\x12\xd7\x28\x77\x74\x45\x94\xbb\x80\x88\x50\x4c\xfe\x5b\xa7\x29\xaf\xbf\xf3\xee\xed\x77\x42\xe9\x3b\x67\xa0\x38\x32\xbd\x30\x3d\xbd\x5f\xbf\xf4\xf4\x42\x78\xab\x20\x3d\xbd\xa8\x28\x3d\xbd\x20\xf2\xe5\x98\x9d\x1d\x63\x06\xb7\x1e\x39\xd2\x8a\xeb\x14\xd2\xad\xc3\xec\xc8\x05\x98\xaf\xdc\xfa\xd3\x19\x28\x85\xbb\xee\x3c\xf3\x8e\xf2\x3a\x40\x19\x4c\x49\x2f\x8c\xbe\xcc\x7e\x95\xa3\xd7\x5f\xef\x7f\xe6\x19\x36\x96\x07\x7f\x22\x34\xbb\x93\xd1\x8c\x9e\x1f\xd2\x0f\xb5\x85\xaa\x32\x8d\xf6\x9c\x54\x8f\xdd\x23\x12\xe5\xa6\xb0\xc8\xe7\xb4\x24\x59\x72\xfb\xcd\xed\x07\xe1\x7e\x30\xba\x1f\x0c\xea\x07\xfd\xf2\xb3\x2d\x96\x34\x4b\x93\x65\x91\x85\xd7\x8d\xcf\x6e\xca\xc6\x96\x6c\x4b\xb6\x9e\x90\xea\x35\xe6\x52\x92\x90\xe9\xf5\x1e\x32\xbd\x5e\x1a\xf5\x90\xdb\xb3\x40\x2f\x8e\x4c\x42\x5c\x5d\x67\xc5\x5d\x33\xca\x04\x18\x65\xee\xec\x43\x99\x08\xba\x04\x31\x1e\xa7\x74\x18\x3c\xa6\x63\xe7\x98\xde\xc4\x58\x1b\x57\x72\xfa\xab\xbc\xff\xcc\x33\xfe\xeb\xaf\xa7\xf3\x5f\xb5\xdd\xcb\x44\x33\x5f\x8d\xf2\x48\x4f\x30\x30\x94\x59\xe8\x2f\x37\xf8\x0d\xfd\xab\x4a\x36\x7b\xdf\xf0\x7e\xe4\xe5\x36\x79\xa1\x98\x6d\x5f\xf4\xe6\x5b\xf2\x6a\xf2\xc6\xe7\x71\xba\x3c\xb6\xc8\xef\x7d\x5a\xb6\x5e\xdc\x1b\x74\xa6\x02\x3d\x72\xd6\x45\x2d\x70\x91\x9e\x3c\x6b\xc6\x92\x93\xfa\x1f\x97\x02\x95\xd9\x01\x7f\x79\xb0\x82\x1e\x4a\x5b\x51\xe9\xd6\x8a\x57\x49\x97\x9b\x73\xd7\x0f\x1d\x3a\x73\xe0\x33\xfd\x0e\x4f\x11\x4f\x9f\xb6\x8d\x3e\x5c\x72\x28\x73\xd4\xe0\xf2\xa1\x6b\xda\x7e\x9b\x7f\x68\x9c\xf5\xf4\x69\x63\xfd\x53\x39\xbf\x5b\xb8\x24\xed\xc6\x17\x5e\xba\xfe\xc6\xe6\x99\xc7\xf8\xea\x33\x62\xa0\xdf\xa1\x7e\x87\x97\x2c\x1f\xbc\xa1\x99\x24\x4a\xcc\xb3\xea\xce\x9c\xb1\x8d\x7c\xaa\xdf\xe1\xb6\x0d\x83\x37\x37\x11\x08\x63\x4d\x83\x5e\xde\xba\xf5\x58\x4b\xcb\x0d\x5b\x5f\xa6\x65\x7c\x17\xd5\xf3\xd9\xfc\x16\xd2\x22\x02\x68\x54\x28\x90\xe2\xb2\x9b\xcd\x4e\xba\xd6\x2f\xd3\x26\xf3\x72\x4e\xae\xdd\x69\x41\x1e\xab\xa7\xde\xc3\x79\xd2\xcd\x08\x6d\x46\x58\x87\xbc\x12\x65\xfa\xc6\x86\xd2\x13\x45\x0d\xc1\xd8\x2a\xfa\xd8\xd2\x90\x52\xda\xab\x14\x62\xad\xad\x52\x27\xae\xda\x70\x36\x9d\x33\x8a\x3a\xc9\xa8\x64\x2e\x5c\xf1\xfb\x63\x16\x0c\x7b\x7c\xe9\xca\x49\x53\x76\xcc\x07\xd4\x8d\x46\x11\x21\x89\xfd\xfd\x67\x54\xad\x9b\x78\x45\xf5\xa0\xaa\x06\x3c\x54\x1e\xb3\x76\xf4\xc6\xdf\x4c\x99\xb4\xf6\xaa\xfb\x4d\x0f\xd6\x2a\x17\x40\xac\xc5\x1d\xe5\x4d\x55\x53\xd6\x0c\x1e\x34\x79\x40\x53\x19\x2d\xc3\x04\x74\x81\xdf\x47\xca\x50\x80\xfa\xa3\x61\x21\x7f\x71\x5a\x81\x2f\xe0\xb6\xd9\x2a\x78\x5f\xc0\x57\x35\xa0\x20\x2d\x2f\x88\x32\x37\x67\xe2\xcc\x7e\x44\x5d\x92\x2d\x79\xa0\x56\xd3\x6b\x0d\x5a\xc3\x8d\xdf\x73\x4c\xbd\x88\xb1\x1d\x7f\xd4\x89\x4e\x05\x73\x11\x46\x77\x37\x39\x69\x3b\x4d\x83\x04\x0b\x50\x39\x28\x69\x07\x94\x6a\x3b\x8c\xa3\x1c\x49\x6b\xac\x7b\x67\xbe\x4e\x14\x75\xbe\x61\xd5\x53\x73\x33\x4d\x56\xd1\x6a\xe4\x79\xb3\x23\x2b\xd3\xf4\xb7\xc9\xfb\x96\x2f\xdf\xfb\xc8\xda\x11\x93\xee\x0a\xaf\xdf\x78\x45\x78\xed\x7a\x1e\xe5\xe7\x0b\x26\x9d\x9e\xe7\x6d\x26\xa3\x39\x69\x60\xeb\xb8\x60\xba\x5e\x14\x87\x4c\x2b\xfd\xfb\x84\xab\x36\x3c\xfe\xc0\xda\xd5\x8f\xe6\xa7\xaf\x0d\x37\xad\xdc\x30\xf5\x8a\xf5\xd1\x3d\xf4\xbc\xc0\x9f\x44\x3e\x54\x16\x4a\x46\xb2\xec\xb6\x59\xdd\x9c\x98\x2c\x26\x67\xf8\xf5\xde\x90\x4e\xae\xf3\xda\xc6\x13\x55\x85\xaa\xd1\x0d\x44\x1a\x69\xaa\x80\xea\xd1\x8b\xf6\x50\x84\x07\xc9\x87\xad\x3c\x4c\xc5\x69\xe0\xab\x24\xc2\x7c\x90\xb6\xa3\xab\xa2\x92\x74\x5a\xe9\xde\xe6\xdb\xb7\xd5\xe2\xab\xaf\xb8\x77\x26\x37\xfe\x81\x6b\x75\x5d\xff\x23\xae\xdf\x73\xc5\xb4\x47\xc3\x57\x87\x67\xde\x78\x2d\x7f\xb2\xf9\x91\x1b\x37\x5e\x3b\xa2\x79\xf3\xd1\xfb\x1e\x6c\xd4\x67\x65\xb5\xec\xe9\x30\x1f\xdd\x3c\x23\xbc\x75\xe2\xaa\x67\x28\x7e\x03\x11\x31\x0e\xf8\x57\x50\x19\xaa\x09\xf9\x8a\x74\x80\x74\x9e\x54\x21\xc7\x92\x63\x29\xcf\xa9\xc8\xcc\xd7\x15\x25\xa4\xf3\x32\xd1\x3e\xed\xb2\x5d\x86\xa4\xd8\x99\xc6\x0d\xd4\x25\x54\x74\x7a\x93\x21\x4b\xb7\x6b\x55\x0e\xe6\xca\x03\x6a\xbf\x43\x91\x2b\x75\xc7\x8e\x2f\x75\x26\x48\x15\x95\x51\xd6\x62\xfd\x52\x2a\xe7\xe6\x6b\xbb\x0e\xe9\x7e\xb9\xaa\xa9\x1c\x57\xed\x0f\x8f\xdd\x52\x7b\x73\xc3\xe0\xb6\x6c\x9b\x7c\xff\x92\xe5\xbb\x87\x4f\xb6\xba\x02\xf3\x86\x8d\xbc\x67\x79\xff\x95\x4d\x83\x84\x92\xab\x36\x2d\xf5\x27\x55\xac\xbe\x75\x4c\xd1\xea\x95\x63\x36\x8e\x5d\xb6\x0b\x82\x43\x72\xb2\xb2\xd7\xdc\xb6\x7b\xc1\x94\xd6\x1c\x4e\x37\x6e\xcc\xf2\xe5\xbf\x29\x99\x38\x6f\xe3\x9d\xab\xcb\x9d\x8c\xee\xb3\xbb\xbf\x20\xf6\xde\x1a\xd2\x46\x12\x43\x06\x64\x72\x48\x92\xc3\x9b\x68\x88\x19\x13\x9a\xb7\x98\x42\x28\x82\xe8\x01\x22\xee\xa8\x73\x0f\xc9\x0c\xb8\xd5\x35\xfd\x89\x69\xa3\x2b\x6e\x9c\x75\x45\x7b\x76\xc6\xf6\xa9\x2d\xed\x53\x17\xdd\xb4\xc5\x3d\xe5\xd0\xd7\xeb\xda\xb6\x0c\x5d\x70\xfd\xd2\xd5\xab\x56\x6c\x6d\x9d\xf2\xdc\xf5\x07\x4e\x91\xbc\x86\x76\x7f\xce\xbd\x49\x68\x68\x44\x69\x21\x7a\xfc\x8d\x81\x33\x70\x26\xf3\x68\x03\x18\x90\xb7\xa8\x21\x9a\x9f\xba\xa1\x93\x9e\x5c\x2a\x65\xe3\xec\x40\x05\xc2\x52\x1d\xe8\xd7\x0e\x53\x5e\x9f\x94\x75\xe4\x96\xcb\x97\x13\x63\xea\x95\x0d\xca\xed\xd7\xd7\x2a\xf3\x6e\x19\x01\xc2\xd1\xd9\xd7\x43\x58\xd5\x63\x8e\xa1\x14\xae\x9a\xb4\x15\x2f\x2a\x0c\x39\xb1\xd9\xec\x35\x08\x42\x82\xd7\x9b\x98\x64\xd2\xe9\x8a\xc8\x73\xb7\x8d\xb4\xed\xd7\x1a\xaa\x8a\xaa\x7a\x1d\xef\xc4\x64\x18\xa5\xb8\xe4\x67\xdb\xeb\xe3\x97\x69\xc2\x17\x63\xee\xbc\xaa\xb1\xa8\x6a\x69\x68\xe7\x82\xaa\x01\x1b\xc6\x15\x14\xf2\x5b\xda\x5e\xd8\xf9\xe8\x6d\x6b\x36\xaf\x5e\xbd\x4b\x56\xc4\x75\xb7\x57\x14\x8e\x5d\xee\xd0\xf6\x6a\x9e\xe2\xcf\xf1\xbf\x24\xf6\x56\x3a\x6a\x0e\x95\xa5\x58\x2c\xce\xc4\x54\xc9\x68\x44\x89\xc8\x97\x61\x4e\x99\x92\x02\x97\xa5\x40\x8a\x29\xb5\x22\x15\xb2\x52\xa9\xd6\xc3\xa5\x82\x2e\x35\x39\x3d\x69\x6a\x12\x24\xa5\x25\x7b\xec\x06\x9e\xad\xf5\x2d\x0a\x06\x59\xf7\x11\x75\x36\xc6\x3a\x93\xa8\xc4\xed\xe9\x6e\xe3\x1c\x32\xda\x84\x18\xd2\x6e\x72\x97\x05\x59\xe5\x02\x7f\xae\x62\xdd\xc8\xaa\xaa\xb5\xe3\x8a\xf3\x22\xef\x5e\xbf\xac\x6a\xc0\xfa\xf1\xfd\xfa\xe1\x67\x22\x3b\x70\x76\xe4\x5d\x18\x36\x6e\xc9\xe4\x8a\xa2\x09\x8b\xec\xf0\xfc\xad\xca\xca\x15\x77\x97\xf7\x1b\xb3\x9a\x73\xe0\xf3\xfb\x95\x39\xb7\xae\xb8\x43\xf5\x75\xb8\xa7\xbb\x3f\x3f\x45\x78\x8d\x8d\x9b\xdf\x15\x9a\xca\xa5\xa6\x58\x79\x0b\x6f\x11\xf5\x06\x13\x6f\x36\xf3\x82\x2d\x39\x0d\xf3\x60\xb7\x27\xb8\x3d\x49\xbc\x83\xe8\x5b\x0e\xc1\x91\xee\xd3\xa7\xa6\x79\x78\xaf\x4e\x07\x22\x87\x93\xf8\x44\x29\xd1\x6b\xb2\xda\x12\x78\xa7\xd1\x68\x48\x49\x76\xf3\x2e\xd9\xe5\x94\xbc\xb2\xd9\xe9\x34\xcb\x5e\x49\x10\x1c\x02\x6d\x2c\x9a\x15\x60\xeb\x71\xa7\xac\x5d\xf6\xf6\xfc\xd1\xe3\x61\x2d\x76\x49\x8d\x31\x87\xc0\xf9\x1d\x12\xf3\xd2\x09\x8e\xa0\x94\xe5\x08\x72\xd4\x73\x27\xfd\x0a\x5c\x16\x7e\x60\x63\xa9\x72\xb8\x7a\x63\xe9\xfb\x81\xf7\xc7\x7e\x10\xf8\xa0\x7c\x63\x01\x8c\x18\xb0\xb1\xe4\xc3\xc0\x07\xf4\xd6\xa1\x1c\x1e\x0b\x23\xc0\x7b\xb3\xf2\x24\x24\x4d\x7f\x6f\x3a\x3c\x4d\x83\xe2\xae\x9b\xa1\x56\xf9\x5b\xe3\x7b\x8d\xca\xa8\x19\xef\x36\xe2\xa6\x9b\x95\x51\x3b\x54\x3f\xae\xfc\x2f\x85\x41\xa4\x86\xb7\x84\x46\x32\x1f\xa6\x49\x49\x76\xe6\xa7\x3a\x3d\x5d\xa7\xb3\xdb\xcd\xbe\x8c\xf4\xa4\x94\xa4\xa6\xb0\x94\xe0\x4c\x68\x0a\xf3\x4e\xce\xe3\xf5\x34\x85\x91\xb7\xc6\x39\xde\xb9\xc9\xc9\x59\xbc\x20\x73\x4e\xaf\xd3\x6b\x4d\xe1\x74\x76\xb3\xd5\x6a\x6f\x0a\x5b\xed\x51\x07\xa6\xd4\x0f\x42\xd5\xc5\xa7\x0e\xf4\xda\xde\x18\xf5\x62\x48\x07\x37\x98\x0b\x5b\x1f\x47\x7d\x63\x38\xd8\xc1\x28\xf1\xee\xde\x2d\x80\x1b\xe0\x06\xbb\xb2\x32\x9d\x85\x97\x2d\x69\xfe\x26\x7b\xc5\xe4\x70\xe7\x4b\xc6\x27\x87\x1d\xb4\x51\x3f\xee\x87\x86\x3c\x68\xc2\xb7\x9b\xfe\xc8\xcd\x9b\x75\x64\x96\x72\xad\x49\x02\xb7\xb2\x80\xf9\x6f\x3f\x32\x0b\x96\x50\x57\x3c\xac\x5d\xf5\x23\xcc\x50\x21\x6c\x23\x5a\xd2\xfa\xd0\x48\xa3\xc5\x4a\x75\x6d\x19\x71\xbc\xc4\xbb\xdd\x3a\x9d\x2c\x7b\xbc\x92\xc9\x6c\x1a\x1f\xe6\xcd\x9c\xcd\x6e\x1b\x1f\x46\x76\x8b\x3d\xcd\x5e\x63\x3f\x67\xef\xb6\x0b\x36\xce\x1e\xd2\x5b\xea\xcc\x76\xb3\x5d\x76\xb9\x12\xc6\x85\x5d\x48\xd6\x8d\x0b\xcb\xce\xb8\x93\x8c\xd8\x99\x6b\x4d\x8d\x97\x3c\x69\x21\xae\xb8\xaa\xdb\x7a\x3f\x3b\x23\x20\xae\x9c\xf0\x66\x9b\x7d\x96\x69\x96\xa3\x6d\xca\x2a\x59\x59\x35\x9b\x5c\x98\x48\xc4\xe4\xe9\x32\x5c\xc5\x4d\x9d\x3b\x6a\xae\x92\xec\x19\x8a\x07\x93\x0b\x78\xcf\x33\x94\x9d\xc1\xae\xd6\xa1\x9d\x98\xa0\xc4\x3c\x96\xf0\xae\xee\xb7\x23\x0f\x12\x7e\xef\x26\xf1\xe7\x49\xdd\x26\x90\x5e\x68\x51\x28\xd5\x63\xb3\xf9\x0d\x92\x2c\x8b\x44\x55\x4b\xe1\x93\x93\xa9\xff\x4a\x7f\x86\x0f\x35\x87\xd3\x75\x74\xe9\x81\x2b\x94\x14\x4e\xd1\xfb\xc8\x3f\x6f\x32\x25\x37\x87\x4d\x72\x53\xd8\x74\x69\xff\x94\xac\x84\xd1\xba\xec\x55\xb0\x98\x1a\x15\xe7\x86\x92\xba\xa0\xe4\x9d\x09\xa4\x8b\xd7\xfc\xbf\xb3\x53\x35\x62\x6e\x27\xb7\xbe\xe8\x7a\xb1\x80\xba\x9c\x54\x40\x50\xde\x56\xbe\x28\xb8\x73\xdf\x8a\xe5\xc3\xf3\x8e\xba\x8e\xe6\x46\x1d\x4c\x72\xfc\xba\x7f\x26\x8e\x7c\x6a\xff\x99\xf3\x0b\x8f\xdc\xb7\xfa\xea\xaf\xd6\x7d\xcd\xfc\xfd\x28\xb5\x82\x8e\x94\x8f\xd8\x4b\x68\x56\xa8\xdc\x9f\x6a\x4c\x4d\xca\xe7\x79\xa7\x3d\x23\x2d\x2d\x90\x64\x4f\xea\x57\x98\x8a\xa8\x7b\xce\x82\x82\x0c\x77\x46\x5a\x53\x38\xc3\xee\xce\x6f\x0e\xbb\x9d\x4d\x61\x37\x27\x5b\x2c\x52\x73\xd8\x92\xdc\x53\xac\x8b\x8f\xe7\x8a\xb3\xca\x59\xb9\xd8\x41\x04\x16\x48\x88\x1d\x43\xa3\x39\xc3\x27\xe5\x4b\x67\x1d\x08\x75\x70\xc2\x45\x0b\xc9\xe1\x9c\x49\x90\xcf\xd7\x0f\xcc\x1b\xed\x1e\x14\x2e\x5f\x70\xff\xb3\xc7\xe4\x33\x0f\x99\xb0\x1b\xc4\xae\x47\x76\x1f\xdf\x69\x54\x16\xbf\x91\xf7\xeb\x67\xd6\xac\x18\xde\x8a\xfb\x2b\x05\x3f\x14\xd6\xd5\x25\xba\x0f\x28\x6f\xa4\xee\xbd\x7f\x40\x35\xff\x46\xe2\xc8\x07\xf7\xdc\xf3\x46\xbe\x62\x4d\x1a\x89\xfb\x2f\x7c\xe0\xe6\xab\x97\x46\x4e\x23\xae\xfb\x7b\xe5\x3a\xee\x7d\xa1\x90\x88\x60\x3f\xd1\x75\x37\x84\x6a\x52\x72\x93\x02\x49\x81\x1c\x77\x42\x42\x6a\x6a\x8e\x2c\x99\x79\x3e\x27\x07\x25\x9a\x13\xf3\x0b\xbc\xd6\x9c\xd4\xd4\x74\x7b\xfa\xf8\xb0\xc7\x4d\x1e\x3b\xed\xd6\x00\xcf\xa7\x64\x4a\x99\x13\xc2\x7a\x59\x72\xc5\x3c\x96\xd0\xd5\x43\x2f\xc7\x1c\x43\xbe\xcc\x8a\x7c\xb1\xbf\x9e\xf8\x65\x19\xa5\xb6\x98\xd7\x65\xd2\xef\x93\xa2\xfa\x1d\xea\x89\x3d\x44\x74\x93\x76\xeb\xae\x0c\xd2\xf3\x79\x98\x97\x35\x07\x6d\xca\xe0\xe2\x2a\xaf\xd2\x29\xbf\xe1\xab\x6f\x1d\xcb\x3f\x7b\xd5\xb1\x51\x53\x6e\x06\xe1\xde\x92\xa2\xe7\x17\xbf\x5a\x31\xb1\x22\x52\x6f\x83\xda\x8c\xcc\x51\x1b\x47\xae\xc9\x69\x0d\x8c\x51\xde\xb5\x4f\x4b\x1f\x70\xc3\xa8\xcb\x89\x95\xb0\x36\xed\xbe\xab\xf7\x41\xfe\x63\x22\x2c\x56\xd6\xd9\xb3\x22\x0f\x8c\x2a\xc1\x4b\x0c\xdb\xbe\x51\x76\xd5\x57\xc3\x81\xc8\x09\x99\xc9\xf5\xc9\x84\x26\xbb\x09\x4d\x52\x09\x9f\xcf\x0d\x95\x7b\xbc\x5e\xbf\xcb\x97\x96\xc8\x3b\x9d\xc9\xc9\xd4\xbb\x0d\x67\x32\x11\xad\xcb\x60\xc8\xb0\xfa\x5c\xbe\xf1\xe1\xc4\xb4\x34\xd1\x93\x10\x72\xb8\x2c\xb2\x4e\x67\x10\x45\x54\x1f\x16\x5d\xda\xa9\x89\x41\xea\xb4\x36\xf1\xc4\xcb\x31\x37\x8f\x3d\xeb\xa8\x09\x0f\x04\x63\xee\x56\x49\xe1\x89\xad\xc7\x9c\xd3\x72\x7e\x50\x8f\x44\xa8\xc1\x41\x29\xe8\x08\x52\x77\x6b\x2e\x47\xa5\x1f\xf6\x64\x8c\x49\x2c\xb9\x7d\x58\x7d\xc5\x47\x0b\x41\xe7\xb5\xcf\x58\x26\x6f\xbf\xf1\xe6\xec\xab\x3f\x5a\x1c\x79\xc9\x5e\x6e\xde\x3c\x75\x7e\x62\xad\xbf\x28\x49\xd9\x08\xaf\xe4\x0f\x2d\x6c\x85\xce\x21\x81\x53\xa7\xe0\xea\xae\xac\x2b\x3d\xe5\xc5\xa0\xbc\xaf\xf9\xd9\x56\x46\x8b\x57\x11\x1e\x4f\x41\x4b\x43\x55\x89\x7a\x9d\x2e\x29\x89\xc3\x76\xa7\xd3\x66\xb3\x7a\x0d\x1e\x8f\x2c\x5b\xb1\x35\x35\x2d\x21\x49\x9f\xd8\x1c\xd6\xeb\x91\x60\x95\xd5\x4d\xf0\x26\x81\x4b\xf2\xd8\xd8\x06\x78\x17\xb2\xab\x5b\xcb\x55\x37\x54\x9a\x17\x2a\x3b\x65\x74\x14\xab\xe1\xb8\x03\xac\x7a\x4e\x5c\xf3\xab\x1e\xd1\x48\xb7\x13\x3d\x69\xc3\x4d\xcf\x01\x20\xb1\xf4\x34\x0e\x0b\x73\x7e\x86\x37\x99\x9e\xbc\x02\xfe\xe7\x0a\x72\xb5\xc5\xb4\xff\xf8\xc9\xf5\x1b\xca\x94\xd5\xa6\x27\x1b\x15\x4f\xe3\x43\xa6\x51\x89\xfc\x0a\xda\x7e\x15\x2b\x9c\xa7\xbf\x9d\x37\xa6\x2b\x12\x1c\x1c\x95\x88\xdd\x91\x2f\x12\x47\x11\x59\x9c\xa3\xdc\xc3\x17\x10\x59\x9c\x82\xa6\x87\x8a\x90\x33\x29\xc9\xe5\xf2\xb8\x4d\x56\xab\xa0\x37\x1a\x75\x3a\xc1\x2d\xa4\xa6\x25\x7a\xc6\x85\x13\x91\xec\x76\x9a\x88\x9c\x35\x39\x89\x9e\x67\xc7\xf6\x09\x61\x6c\xed\xe9\x65\x98\x4b\xe8\x3e\x6b\xa5\xe3\x0b\x02\xb1\xe3\x58\xe8\x49\x06\xbd\xcf\x6c\xe1\x24\x78\xea\xae\xcf\x5a\x56\xda\x9a\x76\x86\x97\x85\xee\x9f\xed\x9a\x5e\xb3\x2b\x7b\xbe\xf2\xc3\x97\x54\xe0\x4e\x4e\xe7\xe0\xd8\x82\x19\x65\x0d\x91\xbf\xa5\x2a\xcd\xd0\x86\xab\x96\xe7\xb4\xdc\x34\x35\xf2\xb8\x10\xf4\x0c\x55\x4a\x76\x47\xeb\x88\xf9\x42\x4f\x42\xcb\x43\x03\x12\x1d\x0e\xbb\x31\x89\x9e\xf2\x2d\x0a\x4e\x8f\xc7\x9b\x90\x60\xb2\x0b\xf6\xe4\x94\x84\x90\xd7\xee\x4e\x4a\x32\x26\x3a\x8c\x0e\xd2\x53\x9a\x4c\xf4\x78\xfd\xa6\xb0\x45\xc7\xf5\xf6\x81\xee\xa9\x89\x73\x7c\xce\x0a\xe3\xa9\xa9\x49\x3c\xd1\xc7\xeb\x61\x30\xe6\x04\x3d\xe6\xfc\x3c\xde\xf1\xb9\x1e\x58\x41\x21\xe6\xf5\xfc\xf8\x45\x1e\xcf\xa1\x65\xf5\x86\x0d\x65\x13\x95\x77\x1a\xda\xa2\x9e\xe9\xe2\x1d\x9d\x47\x2a\x93\x14\x0c\x07\xf1\xfa\x7e\xaa\x2e\x9a\xac\xdc\xc3\x9d\x27\xf5\xe4\x44\xb3\x43\x65\xc8\x42\xb4\x1d\x49\x22\x26\x93\x9d\xae\xed\x32\x51\xe5\xc8\x26\xba\xdc\xd4\x2f\x52\x02\xb2\x20\xb3\x84\x24\x4e\xb6\x39\x75\x21\x93\x53\x24\x38\x11\x41\x63\x89\x96\x2e\xf1\x44\xcd\xcb\x5a\xc1\x7a\x6d\x2f\x53\x4b\xa5\x3a\x42\x61\x93\x04\xac\x24\xd8\xc1\x0a\xc2\x69\x75\x05\xd7\x42\xd3\x14\x19\xa6\xca\x33\xbe\xfb\xb0\x7e\xea\xbc\x51\x03\x1e\xbc\x72\x98\xf2\xdd\x57\x33\x8c\x70\x15\x74\xc2\x54\xf7\xd0\xa1\xae\x8f\x22\x7f\xf5\x28\xd3\xa0\x0d\x7e\x5f\xab\x6c\xa1\xb5\xa4\x9d\xbd\xa4\x8c\xe6\xf7\x91\x3a\xb2\xa2\x50\x28\xdd\x4c\xaa\x47\xa7\xb3\xd9\x0d\xa2\xc5\x62\xb3\x1a\x2c\x06\x52\x0f\x76\x53\x92\x9e\xd0\xab\x39\x4c\xf8\xa2\x67\x1f\x45\x4c\x06\xc4\x6d\xa6\x80\xa8\x63\x75\x89\x1e\xfb\xcc\xf9\x2a\xb9\x91\xcf\xcf\xbc\x3f\x7d\x58\xb8\x9a\xdb\xeb\xe8\x3a\x8e\x8f\x6c\xd9\x50\x16\xb1\x24\xf0\x6f\x99\xa4\xb7\x60\xc2\xfc\xce\x5b\x23\x9f\xc2\xc1\xa5\x04\x87\x97\x09\x0d\x9d\xdc\x1e\x82\xc3\x90\x50\x3a\x26\x3c\x6e\x32\xd9\xec\x16\x99\xe3\x6c\x66\xd1\x28\x12\x1d\x42\x36\x12\x75\x94\xb3\x8c\x0b\x03\x15\xcc\x2f\x6b\xec\x50\x74\x69\x24\x48\xc6\xf1\x98\xe0\xe0\xbc\x51\x4a\xad\x0e\xf3\xb5\x15\xf3\xbc\x03\xeb\x4a\xf0\x2d\xfa\x48\x17\x6c\x55\xee\x81\xb6\x52\x2e\xdd\x61\xbd\x1b\x3c\x15\x5d\x9f\xb1\xb1\xbc\xd1\xdd\x5f\x0b\x7f\x11\xc6\x20\x99\x48\xcc\xd1\xa1\x00\xef\x20\xb2\x31\x29\xd1\x91\x98\x96\x9e\x4a\x14\xbd\x54\x7b\x22\x67\xa0\x8e\x28\x11\xe9\x27\x79\xba\x74\xcf\x2a\x11\x9d\xce\x11\xd7\xda\xb4\xdf\xde\x2b\x79\xa9\x07\x04\x5e\xf5\x29\x52\xe9\xc8\xa6\x7b\x75\xd5\x53\xc9\x7c\xa5\xee\x2c\xaa\x0c\x70\xfb\x77\x2b\xdd\xed\x0f\xdd\x7d\xdb\xe6\x67\x9a\xaf\x18\x3e\x71\xfe\x50\xe5\x13\xe5\xe4\x3b\xb0\x1d\xc4\x1b\xaf\x84\xca\xf7\xfe\x64\x52\xb2\xf8\x4f\x8f\x28\x8f\xbd\xf7\xc7\x0f\x46\xf0\xc9\xfd\x3a\xc7\xa5\x13\xf9\x9a\x08\xe6\x08\xac\x78\x39\xd3\xd9\x19\x48\x1a\x49\xf9\xd0\xd1\xfd\x35\xff\x0e\xf7\x7b\xe4\x40\xe5\xa1\x24\xab\x05\x40\x42\x36\x5b\x82\xe4\x74\xd8\xc6\x85\x1d\x16\xb0\xba\x04\x63\x7d\x58\x2f\x58\x11\xf3\x8d\xa2\x2d\x8b\xb5\x47\xfd\x4a\x10\x1c\x1d\xea\x01\x6a\xaa\xaf\x31\x89\x90\x31\x50\x09\xa3\x6e\x05\xf7\xf8\xed\x73\x27\x8f\x0c\x8c\xf2\x3a\x03\x57\x8c\x50\xfc\xeb\x5e\x1b\x24\x73\x7b\x23\x4b\xe1\xc5\x4d\xb3\xd2\xce\x6e\xb0\x2e\x8a\x48\xdc\x1c\x8d\x97\xd0\xb6\xee\x8f\x75\x33\x08\xfd\xd2\x50\x4b\xc8\x03\xc8\x6c\x32\x62\x9e\x93\x65\x6c\xe6\x9c\x82\xd3\x47\x8c\xb4\x74\x9f\x23\x89\xea\x53\xee\xb0\xdb\xc1\x63\xa3\x51\xe2\x0d\x82\x44\xda\xb8\xc4\x13\xce\x03\x3e\x7a\x6a\x8b\xaa\x67\x50\x1f\x9e\x35\x3d\x6a\x54\xdc\x31\x48\xcc\xad\x8d\x9f\x63\x38\xd2\x23\x57\x20\x48\x90\xc7\xea\xe9\x6f\xea\xb0\xae\xc4\x3f\xd7\xb8\x4b\x59\x38\xeb\xb7\xea\xa1\x2a\xf3\x61\x5b\xdb\x1d\x60\x2e\x5b\xf2\x8b\x39\x2d\x23\x8b\xea\x25\x7d\x9e\xb7\x64\xc8\x50\x5f\x1a\x57\xdf\xf5\x04\xff\x13\x6d\xd8\x5d\x6f\x72\x83\xba\x9e\xc3\xb3\x57\xde\x38\x38\x4d\xf9\xfe\x6e\x9d\x39\x7b\xf2\x30\x56\x26\xdc\xfd\xb5\x78\x07\xa1\x6b\x22\xba\x22\x54\x20\x1b\x88\xb0\x34\x9a\x4d\x0e\x87\xd1\x45\x7a\x1b\x8b\x25\x09\x27\x1b\x13\x12\xcc\x36\x1b\xe1\x4d\x9b\xc5\xe5\x70\xc8\x66\x17\x92\xea\xc3\x3c\xe1\x65\xd2\xb5\x30\x1f\xad\x3d\xce\xfe\x82\x51\x92\xf7\x2a\x09\xc4\x13\x5d\x2d\x13\x29\x51\x12\x29\x91\xd0\xa9\x51\x7e\xf8\x10\x65\xe0\xaa\x39\xca\x3b\xd7\x3d\x56\x2f\x43\xf1\x46\x28\x6f\x5b\xdc\x55\x3c\xbd\x95\xfb\x3d\xad\x82\x85\x11\x11\x27\x46\xfe\xca\xcd\xf6\x0c\x8d\x2c\xc4\x65\x91\xd7\xe0\x95\x29\x33\xf3\x69\xff\x7f\xb6\xfb\x6b\xee\x77\xdc\xb3\x48\x8f\x72\xd1\xd4\x50\xbe\x6c\x33\x18\xbc\x18\xe5\x26\x0a\xee\x44\xb7\x2d\x35\x3b\x3b\x1f\x99\x6c\xb6\xbc\x7c\xd9\xe2\xc5\x16\x6c\x48\xf0\x5b\x12\x24\x22\xa7\xac\x89\x06\x57\x74\xf5\x74\x4c\xb9\xe9\xb1\xa3\xed\xb1\x5e\x91\xd6\x11\xb5\x4f\xdd\x74\x38\x9d\xb4\x38\x19\xa4\x40\x45\x65\xcf\x08\x47\x12\xa8\xe3\xec\x81\xca\x20\xbd\x05\xb8\xde\x92\x5f\x9c\x9d\x96\x55\x77\xf5\xef\x93\xe6\xb4\x38\xee\xfa\xe5\xe5\x57\xec\x1b\xff\x4a\x7a\x86\x2d\xb9\x9f\xf1\xf3\xc4\x49\xca\x68\x0e\x07\x2a\xd2\xc7\xa4\x15\x96\x75\xbd\x08\xef\x4c\x6b\xcc\x29\xaa\x1f\xb2\xb6\x63\xc4\xc0\x25\x9b\x95\x8f\xa0\xb4\xb4\x35\x3d\xd1\xe7\x32\x0d\x71\xe7\xcc\xd8\x1c\x99\xce\x64\x97\x82\x90\x30\x8d\xf9\xba\x19\x1f\xca\x35\x83\xc9\x84\xb1\x4e\x92\x6c\x09\x4e\x33\x11\x57\x16\x33\x31\xc0\xcc\x66\xc1\x60\xd2\x19\x74\x4d\x61\x03\x87\x25\x81\xb4\x57\xc1\x1e\xef\xc4\x9a\x71\x59\xaf\xb3\x9f\xb4\x7e\xd1\xc7\xc5\x77\x1e\xec\xd0\x3b\xfe\xc9\xc8\xb6\xc6\x77\x4d\x91\x09\xa6\x5f\x1f\x7f\xc8\x88\x7f\x6b\xfc\x6c\x2a\x5e\x36\x28\x3c\x3e\x8c\xd7\x45\xbe\x88\x75\x15\xa4\x4b\x7f\x54\x19\xa8\xca\xd6\x13\x08\x71\xf7\x71\x7b\x09\x7e\x0d\xa1\x0a\x13\x32\x1a\x49\xab\x14\x45\x6b\x82\xd3\x44\x54\xcc\xf1\xa6\x26\xf5\x90\x5e\x7a\xb1\xc8\x24\x18\x89\x36\x46\xa4\x8a\xa4\x27\x75\x40\xcf\xde\xe4\x49\xef\xc0\x3b\x2f\x85\xec\x92\x8b\xb0\x8d\x21\x9b\x15\x45\x36\x00\xd7\x0c\xba\x5e\x56\xf4\x72\xeb\x2f\xa6\xc9\xf0\xa3\xdc\x31\x00\x36\x5e\x36\x7a\xd4\x68\x3d\x3c\xa5\x3c\x48\x3d\xe5\xe1\x1f\x3d\x43\x61\xa8\x47\x79\xf6\x01\xa5\x81\xd8\x44\xc8\xd7\xfd\x77\x7e\x0e\xf7\x32\xf2\xa0\x0c\x54\x13\x4a\x23\x1d\x73\x8a\x8b\xd8\xee\x7a\x1f\xa7\xe7\xfc\x99\x26\x6b\x8a\x53\x74\x8e\xa7\xfa\xa0\x97\xd8\x7d\xd6\xa8\x4d\x87\x7a\x54\xe1\xe8\x32\xe0\x52\xd5\xbf\xae\x15\xf9\x54\x07\xb1\x54\x1b\x54\x4f\x5d\xd4\x1c\xeb\x0e\x06\x7b\x79\x19\x37\xa4\xfd\x76\xe5\x45\xe5\xa5\x77\xbf\x69\xfb\xe3\x36\xd7\xd8\xa9\xa5\xf5\xb5\xf3\x93\x77\x5c\x11\xac\xb4\xcd\x5f\xf4\xcb\x21\xdc\xcb\x4f\xec\x26\x4f\x0f\xbd\xfe\xec\x9d\x3f\xed\x72\x4c\xcc\xd8\xae\x74\x4e\xd9\x70\x9d\x09\xd7\xdf\x73\xd3\xbc\xe6\xa6\xc8\x13\xfa\x3b\xa1\x70\xdb\x7e\x26\xb3\x4b\xd1\x5a\xbc\x86\xbb\x9a\xad\x11\xa8\x23\x32\x1b\x21\xba\x74\x5b\x07\xf8\x08\x91\x2a\x47\xc2\xa4\xe7\x92\x88\x1a\x21\x1e\x09\x13\x15\x50\xc0\x7a\xa2\x03\xa2\x23\x61\x0e\x15\xc5\x1c\x44\xf5\x1c\x05\xde\xb3\x6b\x8f\x6e\xe5\xb6\x91\x2f\x5e\x13\x39\x82\x47\xd0\x2f\xfe\x93\xf2\xfe\x93\x90\xa9\x24\xb3\x1f\xd2\xb6\x8a\xf9\xfb\xd1\x49\x29\x8f\xf9\xcf\xf6\x85\x2c\x1c\xa9\x5a\x93\xc9\xca\x1b\xb6\x53\xc7\x35\x74\x42\xa5\x4a\x3b\x06\x5d\x9d\xf2\xa5\xbb\x47\x4a\x7b\x86\x5c\xc7\x6f\xde\xf2\x70\x70\xd8\xf0\xd2\xe2\xda\x11\x52\x5e\x64\x35\x3c\x5b\x5b\x54\x5a\x5b\x5b\x5c\x52\xcb\xf4\xf6\xd1\xfc\x8f\xb0\x5a\xca\x62\xb0\xd3\x42\x66\x02\xdb\x44\x94\x0a\x03\xbf\x3d\x8c\x0c\x18\x15\xbd\x7f\x4c\x83\xcc\x9a\x9f\x9b\xb4\xaf\x78\x0f\x3b\x29\xd3\x95\x8a\xe9\x0b\x8b\x6b\x6b\x4b\x4a\x86\xd5\x4a\xec\xee\x2f\xb5\xc5\xa5\xc3\x69\x66\x08\x2b\xbf\x15\x6e\x82\x61\x52\x7e\x14\x6f\x9e\x9e\xae\x88\xb1\xd5\x24\x6d\x27\x36\x2d\x01\x1e\x7c\x2d\x5f\x5b\x4a\xad\xed\xde\x2b\xcf\x8a\x9f\xca\x19\x46\x91\x1d\x51\x5c\xcc\x90\x15\x4d\x5b\xb6\x3c\x5c\x42\x72\x22\xc5\x20\xfc\xae\x7c\xc6\x5f\x0e\xc9\xc2\xdb\x48\x40\x95\x21\x03\xd0\xcd\xbd\x9c\x10\x12\xd0\x61\x18\x1d\x4a\x08\x6f\x12\xda\x85\xfb\x04\xce\x22\xa4\x09\xfb\x84\x93\xc2\x39\x41\x10\x10\x3b\xf1\x27\xd1\x63\x7d\x8d\x65\x59\xca\x76\x11\x05\x6d\x3e\xe5\x33\x78\xa8\x23\xf2\x07\xfe\x93\xef\x15\xba\x2f\x1a\x75\x71\x5f\xf0\x92\xb4\x92\xc8\xb1\x8c\x90\x99\x60\x2b\x70\x9c\x41\x06\x41\xe0\xa8\x43\x02\xf5\x24\xf0\x38\x2f\x7a\xea\x28\x3d\x04\x81\x97\x94\x4f\x4e\x2a\x9f\xc0\xf4\xb1\x30\x53\xf8\x3a\x12\xc1\xdc\x24\xa8\xa4\x2e\xd1\x2f\x82\xa9\x97\x24\x9e\x6e\x04\xd4\xf1\x3c\x96\xf0\xc5\x30\xf5\xe0\x07\x75\x59\x3b\x81\x79\xef\x58\xe5\x37\x90\x7a\x12\x52\x05\x9f\xf2\x07\xa8\x9c\x84\xb9\x48\x44\x9d\x0b\xfc\x98\x33\xe2\x8f\xa5\x74\xb6\x0e\xb5\x20\xa4\x37\x9a\x4c\x88\x34\x77\x9b\xfe\x70\xf7\xf9\x90\x5e\x6f\xac\xd3\x5b\x2c\x9c\x49\x43\xb9\x2a\x3f\x1e\xe7\x38\x12\x73\x44\x77\xc2\x05\xcd\xb5\xb5\x4d\x0d\x75\x23\x9a\x3e\x80\x9b\x3f\x7c\x8a\xdb\x4f\x5d\x25\xd5\x36\xb7\x70\xb9\x91\x5f\x92\x7c\x76\x90\x7c\x76\x68\xf9\xe4\x84\x1c\x16\xb3\x59\x44\xc8\x6a\xe3\xac\x24\x0f\xce\x68\xd4\x5b\xf4\xff\x26\x0f\xba\xae\x1c\xef\x68\xae\xad\x6b\x68\xaa\x1d\xde\xa2\x7c\xf8\x94\xb2\x50\x5c\x3b\xbc\xa5\x65\x78\x6d\x73\xb3\xf2\x7b\x96\xc7\x5c\xa8\xc2\x73\x85\xb1\xff\x65\x1e\x73\x7b\xe5\xc1\x3f\x14\x9f\x07\x28\xb7\xf1\x53\x60\xa8\x70\x82\xd4\x41\x28\x64\xc2\x74\xcf\xaa\x28\x49\x06\x10\xf4\x02\x65\x19\x57\x58\x2f\x6d\xe2\xda\x89\x04\xe5\x2c\x5c\x1a\xb7\x8f\x3b\xc9\x9d\xa3\xcd\x97\x9e\x60\xfe\x5a\x8f\xea\xa7\x31\xaa\xb6\x00\xce\xe6\x83\xa1\xe7\x3a\xee\xee\xc0\x7b\x84\x81\x7f\xfd\xeb\x5f\x61\x15\xe5\xcb\xdb\x48\x30\x94\x5c\xea\x51\x7e\xc8\xa4\xa3\xc7\xbf\xf3\x40\xf7\xce\x01\x4f\xf2\x39\x10\x16\xe9\x5a\xa0\x13\xa5\x7d\x41\xe6\x82\x4d\x5b\x43\x07\x43\x23\x93\x09\xcc\x73\xb0\x8a\x80\x24\x72\xbd\x59\x19\x09\x7f\xeb\x6e\x47\x3a\x94\x17\x72\x92\x7e\x45\xa2\x07\xe5\xeb\xe9\x5e\x76\x51\xa2\xa8\x62\x8a\x64\xf0\x44\x43\x69\xac\x25\xd1\xbd\x11\x95\x44\x4d\x21\x1d\xbd\xb0\x5b\x04\xe3\xa9\x07\xc5\x31\xef\x2b\x5f\x2b\x23\x7d\x90\xa5\xbc\xe7\xbb\xff\x7e\x75\x2e\x19\x5d\x8b\x0b\xb8\xbf\xb3\x79\xca\xb2\x50\x92\xd3\x42\x37\xa8\x7a\xbc\x76\xe3\x8e\xe9\x74\xa0\x8d\x48\x2f\x3b\x0a\x21\x71\x07\x73\xaf\xc5\xda\x4d\xb4\xeb\x8a\xfa\x61\x8c\x13\x04\x8e\x78\xa1\xe0\xa9\x6d\xa2\xb5\xd0\x9c\xa3\x72\x55\xf3\xb5\x94\x9d\xa8\xf7\x2d\x9c\xca\x18\x6b\xf8\xf0\x16\x92\x7f\x22\xdc\x82\xcf\x70\xbf\x65\xb2\x74\x60\xc8\x40\xe4\xa8\x9e\xba\xa7\xc3\x1c\xad\x0e\x53\x18\x61\x2b\xb9\x23\xe5\x0d\x49\x22\x89\xd9\x1f\x96\xac\x9a\x67\x89\xd7\x19\x1e\x3d\xf2\x33\xea\x07\x04\x9f\x89\x0c\xc1\x47\xc9\x37\x63\xfb\x76\xb8\x6b\xfb\x76\xd2\xee\xee\x83\x46\x7c\x25\xe9\xb3\x39\x94\xf0\x34\x50\x77\x01\x98\x08\x8a\x9a\x13\x31\xff\x36\x3e\xf0\x9f\x85\x6d\xca\xc7\x8f\x0b\x83\xba\xe8\x81\x15\x6f\xe2\x8d\x78\x41\x7c\x7a\xae\x4f\x7a\xce\xff\x21\x6c\xfb\x92\x98\x30\x91\x21\xb4\x5d\x6f\x88\xfc\x03\x3a\xbb\x0f\x93\x2e\x2a\x3f\xe4\x14\xcd\x66\x42\x41\x9b\x5d\x12\x09\xd9\x6e\x0d\x87\x50\xbd\x3a\xb1\xd4\xcb\x1d\x06\x73\xc9\xa4\x4e\x74\xb0\x09\x3d\x3a\xe9\x07\x8b\x06\xd6\xff\xfe\x88\x69\x6f\x52\x5a\xd2\xd8\xba\xfa\xa1\xab\x76\x25\x0f\xcf\x99\x94\x90\x9a\x1e\x48\x29\xd1\xfa\xf6\x3f\x28\xf5\x70\x5d\xf7\x0b\x24\x9f\xba\x90\xd9\x80\x75\x3a\x6c\x36\xdb\xec\xb2\xe1\x96\xb0\xcc\x1c\x54\x99\xac\x75\x16\x99\x9e\x3f\x42\xfa\x4f\x19\x09\x3b\xc3\x88\x44\x3f\x45\x62\x89\x35\x5c\x13\xf5\xed\x93\x1f\xab\x3c\x2a\xca\x1d\x19\x81\x4a\x75\x0e\x2e\x50\xc9\xfc\xfc\x36\xd4\x0f\xcf\xaa\x2c\x2e\x1a\x34\xff\x17\xf5\xe1\x87\x95\xfa\x94\x16\x47\x69\xde\x38\xe9\x72\x79\xc2\xa0\x99\x2b\x54\xfb\x7a\x0c\x9f\x2e\xdc\x4f\xd7\x7d\x51\x5b\x97\xd0\xc2\x47\x47\x5b\xec\x3e\xd5\x9b\x7f\xa1\x6a\x06\xf9\xb8\x1b\x66\xca\xca\x8d\xb7\x28\x1f\x7c\xa4\x7c\xf7\xd1\x76\xe3\xad\xe6\x31\xf0\x58\xe8\xf6\xa4\xdc\x90\xc3\x3c\xa4\xa0\x71\x76\x92\x13\x17\x4f\xf3\x0c\xe5\x86\x75\xea\xf8\x1f\x87\x07\x26\xc0\xaf\xbc\xf2\x97\x4b\xad\xa9\x6b\xef\x5c\xa1\xe5\xb1\x92\xe4\xe1\x45\x88\xc2\x66\x36\x42\x90\x8d\xcc\x66\xd3\x73\x3c\xe8\x30\xad\xef\x4f\x04\xa8\xdd\xf7\xe5\xa1\xf2\xdf\x9d\xf8\x8a\x64\x75\xd3\xc7\x43\x26\x5f\x57\x90\x78\xd4\x7e\x94\x64\xc8\x0d\x1b\x1e\x98\xf5\xc2\x6b\xce\x0b\x27\x3c\x43\x05\x73\xf6\x3f\x76\xce\xed\xd4\x51\xbf\x42\x8b\xd0\xd7\xf0\x05\xbf\xdf\x9e\x2d\x90\x86\x63\x93\xf8\xef\xd1\x2b\xca\x4d\x28\x29\x64\x83\xfa\x00\x84\x02\xb0\x9b\x85\xc5\x01\x08\xa8\xce\x73\x97\x94\xab\x74\x5f\x24\xec\xc7\x6e\xf1\x53\x64\x46\x8e\x90\x5e\x92\x09\x35\x31\x92\x49\x7b\xa3\xcd\x8d\x30\x9e\x3a\x57\x52\x19\x94\xe8\x61\x22\x95\xd8\xed\x7e\xed\x8e\xbb\x6f\x16\x9f\xe7\x57\x0d\x9b\x61\x14\x3f\xbd\xf1\xc1\x1b\x56\x17\xf5\x5b\x13\x1e\xab\xfa\x09\x5e\x84\x2e\x90\x5e\x60\xbf\x35\xc0\x9f\xc3\x13\x49\x27\xc8\x70\xb1\x4a\x82\x1e\xb3\xe7\xa4\x76\x11\x3f\x91\x3f\x64\x17\x89\xd2\x48\xef\xff\xde\xfd\x17\x21\x8b\xff\x2d\xb9\x57\xdf\x5f\xd2\xfd\x39\x77\x86\x7f\x8a\xdc\x73\xec\x3e\xa9\xfb\x73\x7e\x1c\x4b\xcf\xb3\xf4\x7b\x88\xfe\xd7\xce\x9e\xcb\xec\x79\x5b\xf7\xa7\xdc\x26\xb1\x83\xdc\x1b\x55\x1f\xbb\x04\xfe\x26\x42\x03\x51\x30\xb1\xfb\xb9\xdd\xdf\x73\xbb\xd9\xfb\x1e\xf6\xfe\x7e\x62\xd3\xcd\x66\xcf\xd5\xf1\xf9\x1a\xf8\x96\x0f\xf2\x73\x49\xeb\xf4\x1c\x10\x31\xe0\xc3\xb0\x60\x7f\x98\x0a\xb1\x26\x54\x73\x8c\x8a\x2f\xda\xfb\x11\xeb\x21\xc8\xf9\x78\x63\x57\x30\x00\xab\x46\xbd\x37\x0a\xd6\xc1\xb7\xef\xc1\xdd\xca\x2c\x15\xe7\x0e\x22\xa6\x8c\xc2\xab\x84\xee\x5e\x5a\x56\xfe\x27\x21\x21\x1a\x2f\xbc\x17\x1f\x8f\x4e\x5c\x22\x7d\x80\xff\x9e\xab\xe9\xbe\xfb\x67\xdf\x0b\x90\xf7\x3e\x66\xef\xb3\x74\x94\x66\xca\x8f\x8c\x66\xd9\x94\x66\x24\xfe\x1c\x3e\xac\xd2\x52\xb9\xa6\x57\xfc\xf9\x68\xbc\x46\xe3\x68\xfc\xf7\x78\x72\xe4\x7d\x12\xff\x96\x46\xcb\x6c\x01\xd4\x78\x38\xcc\xe0\xef\xee\xfe\x3b\xae\x25\x34\xcb\x16\xb0\x1a\x8f\x9e\xa0\xf1\xb1\xba\xc9\xa6\x75\xc3\xd2\xaf\xe9\x0e\xc7\xd5\x51\x36\xad\x23\x06\xbf\x9c\xc6\x77\x9f\xe8\x26\x10\x59\xbc\xa0\xc1\xf1\xb1\xf8\xc7\xbb\xcf\xe3\x61\x0c\x8e\xa8\xc5\x63\x06\x67\x0b\xab\x3b\x1a\xaf\x53\xf9\x17\x37\x2a\x9d\xc8\x1d\xb2\x40\xcd\x60\x18\x1c\x4a\x70\xd5\x0d\x0e\x19\x2d\x75\x83\x91\x2d\x3f\x9f\xf1\x2e\x81\x75\x12\xce\xf4\xf0\xbc\x55\xe4\xbf\xf7\xab\x75\x32\x57\x59\xc2\xea\x3d\x5b\x30\x68\xb8\xde\xc8\xf2\xde\x13\x2b\xb3\xac\xc5\xab\x65\x8b\xf2\x51\x36\xe5\x23\x16\x7f\x57\xf7\x31\x92\xfe\x42\xf7\x05\xc2\xaf\x34\xbd\x59\x2b\xdb\x4e\x46\x23\xd2\xbb\xe0\x2a\x06\xdf\xaa\x95\x61\x0b\x83\x33\x8e\xe8\xfc\x95\x0c\x1f\x9b\x56\x86\x51\xdd\xeb\x91\xf9\x69\xac\x3a\xf4\x2f\xa2\x2d\x8f\xfa\x69\x1e\x44\xf0\x3b\xcd\xde\x77\x68\x70\xdb\xba\x47\x52\x9a\x51\x27\xeb\x2c\xbf\x04\x2d\x7e\x4f\xf7\x7a\x12\xff\x2d\x89\xcf\x65\xe9\x5d\x5a\x7e\x27\x94\x73\xac\xce\xd7\xf1\x46\x96\xde\xad\xa5\x77\x77\x1f\x89\xe3\xfb\x6c\xca\xf7\x3d\xe5\x57\x79\x8b\xa5\xf7\xf6\xe2\xa9\x68\xbb\xc8\xa6\xed\x82\xc1\x99\xc2\xd2\x4f\xa6\x75\x28\x5c\x17\xab\xc3\x6f\xd0\xc3\x8c\xee\x8c\x77\x58\xbc\xca\x3b\xff\x84\xdf\xf6\xb4\x4f\x16\x2f\x6b\xf1\x1d\x2c\x9e\x95\x8b\xc5\x27\x68\xf1\x7f\x57\x7d\x5d\x12\xde\x0c\x88\x1d\x68\x32\xaa\x7e\x6a\x48\xd6\xc8\x14\xd3\x10\x3d\x34\xa2\x91\xd0\x8a\x52\xd0\x44\x98\x8f\xc2\x28\x05\x9a\x0e\x04\x06\x05\x07\x3d\xcb\xee\x82\xb4\x61\xc6\x8e\xdf\xab\xa9\x51\x67\x07\x1c\x65\xd1\x6e\x86\x1d\x98\x2a\x25\xa8\x4e\xdd\x25\xed\x24\x55\xea\xe3\x3d\x0d\x2a\xd8\x51\xff\x5a\x82\x60\xa5\xda\x3d\x69\x63\x1b\x0e\xba\x00\x82\x09\xba\x40\x76\x00\x88\x7d\x9d\x91\x3d\xb7\xc1\xe8\x49\xf6\x64\xf5\x77\x25\xe0\x92\x50\x79\x72\xde\x5a\x5f\xe1\x9c\xb4\x24\xbd\xae\xaa\xb0\x63\xc7\xae\x40\x20\xad\xcc\x2d\xf2\xfd\x67\x14\x94\x26\x7b\xad\x2e\xb3\xff\x81\x9d\xa5\x1f\x14\x65\xc0\x65\x97\x27\x1a\xf5\x9c\x71\x68\xe4\x63\x77\x76\x71\x59\x06\xf7\xc5\xa1\x1d\x76\xaf\xd5\x62\x4f\x49\x0b\x4e\x1b\x64\x35\xba\x0d\x56\xaf\xdb\x5e\x58\x7c\xc3\xea\x14\x97\xcd\x9f\xb5\x72\xf0\x6f\xef\x1a\x89\x83\x03\xca\x26\x97\xe9\xd2\xfc\x5c\x49\x41\x66\x4b\x20\xc1\xd4\xbc\xad\x5e\xf9\xae\xff\x00\x6f\x76\x78\x8c\xc5\x3c\x28\x8c\x9f\x4b\xb1\xe3\x42\x42\xab\x88\x85\x3f\x8a\xe6\x8b\xa5\x44\x2d\xf2\x1e\xd4\x0b\x82\x41\x8f\x98\xca\xa0\x27\x4a\xff\x6b\x51\x5f\x42\x0e\x7f\x06\x2f\xf9\x2b\x32\x7d\xc1\x09\x7c\x97\xf2\xec\xc2\xf6\xbb\xe0\x5e\x30\x7a\x84\x07\x16\xac\x79\xee\x20\xa1\xf7\x97\xfc\x51\xee\x03\x06\x23\xe5\x69\x9d\xcc\xeb\xf5\x06\xd0\x31\x28\xd0\x03\x45\x9d\xd6\x4f\xe7\xdd\xfe\xec\x4c\x9f\x1f\x38\x0f\x18\xa1\x79\x4a\xfb\x10\xe5\xe3\x6e\xc4\x8b\xa5\x07\x9f\x5b\x75\x15\xad\xbb\xc8\x1e\xfe\x18\x3a\x2d\xbc\xcb\x7c\x5a\xd3\x3d\xce\x66\x64\xea\x08\x23\xa4\x93\x65\xae\x23\x2c\xeb\x88\x02\x18\x9b\xe4\xd2\x90\xd3\xa8\xed\x67\x5d\xde\xd3\x33\x1e\xae\x9d\xb1\x68\x70\xf2\x3d\xd5\xdf\x1f\x5e\xfd\x1a\xff\x8d\x3b\xd7\x11\x08\xde\x72\x35\xf3\x21\x8e\x8e\xf0\xcf\x70\x7f\x11\xde\x50\x35\x65\x9d\xc5\x62\x45\x16\x0a\x9b\xd3\x19\x43\x46\x02\xdd\xa8\x69\x6b\x27\x6c\x55\x3d\xd0\xd5\x65\x88\x95\x41\xd5\x75\xdf\x3b\x8d\x8f\x0c\x9f\xb1\x68\x88\x7b\x57\xd1\xaa\x43\xbf\x1c\xf7\xd0\x64\xe1\x37\x9e\x3c\x47\x5e\xf1\x95\x0b\x6a\x32\x9c\xea\xda\x5e\xb6\x7e\x5d\x78\x81\xae\xed\x26\x65\xa0\x3b\x52\x53\x90\x8f\x9d\x6a\x5e\x84\x86\x68\xeb\x7b\xe7\xa3\x95\xe8\xc7\xd0\x66\x29\x2d\xcd\x2e\xa6\xa6\xda\x65\x70\x3a\xed\x4b\x66\x79\xf2\x16\x34\x8f\x1d\x75\x79\x43\x43\x6d\xfd\xa8\xa9\x43\xcb\x82\x9c\x63\x40\x4d\x8d\x63\x60\x70\xe8\xa8\xda\xe6\xbc\x59\x86\x7c\x03\xb2\xdb\x57\x67\x24\x16\x16\xe6\x5b\x02\x81\x7c\x73\x76\xb6\x3f\x29\x3f\x7f\x95\xec\x2f\x74\x15\x34\x54\x2e\x5f\x5e\x5b\xdc\x3a\xe3\x72\x48\x5a\x38\x77\xee\x88\x81\x93\x27\x0f\x1a\x51\xd0\x5a\x76\x79\xd2\x88\x11\x49\x97\x97\xb5\x16\x88\xc9\x39\xe9\x09\x85\x85\x81\x34\x47\xbe\x31\xd3\x22\x71\x5e\xaf\x55\xc7\x27\x93\xce\x58\x3b\x75\xef\xe5\xd2\xd8\x65\x6c\xfd\xaf\x36\x8c\x54\x14\x9d\x89\x50\x4d\x64\xeb\x31\x55\x59\x0e\xf6\x9e\xa4\x50\xe7\xff\xe3\x67\x2e\x6c\xd1\x33\x5f\x83\x71\x7b\x67\x55\x0b\xa0\xdc\x5f\xee\x13\xe8\x76\x68\xbf\x2d\x48\xdd\x51\x50\x63\xb2\x9c\xee\x77\xa1\x56\x41\x5c\xbc\xe0\xa3\x8a\x3d\xd1\x95\xa9\x9a\x45\xf5\x2d\x9b\xbf\x9c\xfa\xec\x22\x86\x2e\x3d\xb1\x25\x9d\x36\xb5\x54\xe0\xb4\xf3\x5b\xdc\xda\x2f\x58\x7d\x51\x8d\x3a\x7e\xe9\xa6\x0e\xb5\x9d\x85\xcb\x22\x2f\x28\xbf\x83\xcb\x70\x4d\x5b\x5b\xe7\xd5\xf4\x8a\xdf\xa8\xfc\xee\x6c\xdb\x4f\x97\x9d\x6d\x53\xaf\xe1\xb2\x0b\x0f\xb4\xb5\x71\xa9\xf4\x8a\xa6\x6d\x3b\x2b\xa0\x86\x26\xe7\x02\x63\x5e\x71\x69\x41\xe3\x1f\xdb\x94\xf6\xbb\xdb\x9f\xd8\x0e\xa9\x63\xc7\xcd\x9c\x7d\x6f\x78\x4a\x7a\xfa\xbe\xa2\x59\xb3\xca\x06\xbd\xa0\x84\x94\x33\xb7\xde\x7c\xf3\x6d\xb7\xdc\xbc\x24\x3c\xa3\xf9\x8a\x69\x33\x1a\xc2\xfc\xc6\xb3\x6d\x6d\x6d\x5d\x1b\xe1\x32\x78\xaf\xed\x42\x4d\xdb\x59\x3e\x91\x20\x40\x2e\xe0\x3d\xb8\xac\x6b\x63\x1b\xc9\xf1\xec\xa7\x4d\xab\xec\xa3\x87\x5d\xd6\x04\x9f\x4c\x8b\xbc\x72\xf5\xfa\x6f\xae\x5c\xc3\xe5\x1f\x1b\x36\xdb\x26\x2f\x00\xff\xd0\x2a\x45\xf9\x6c\xf8\x28\xe5\x5d\xb8\x4c\x99\x76\xe2\xcc\xa9\xe3\xc7\x4f\x3d\x76\xe7\x5d\x8f\x3e\x7e\xdf\xed\xac\x2f\xb2\x10\xd9\x7a\x3d\xb7\xc7\x26\x72\x4b\x09\xcb\xdd\x11\xda\x90\x11\xda\xb4\xa9\x2e\x23\xb4\x61\x03\x09\xd6\xad\x23\xc1\xca\x95\x24\x58\xbe\x9c\x04\x4b\x97\x92\x60\xc1\x02\x12\xcc\x9b\x47\x82\x39\x73\x48\xd0\xdc\x4c\x82\xc6\x46\x12\xcc\x98\x41\x82\xcb\x2f\x27\xc1\xa4\x49\x24\x18\x33\x86\x04\xa3\x46\x91\xa0\xae\x8e\x04\x43\x86\x90\xa0\xa6\x86\x04\x15\x15\x24\x28\x2b\x23\x41\x7e\x3e\x09\x72\x73\x49\x90\x9e\x4e\x02\xa7\xb3\xee\xe7\x3d\x30\xd2\x76\xb7\x82\x9f\xc9\x85\x85\x63\xc8\x88\xca\x43\x29\xbc\x6c\x30\x98\x4d\xb2\x8c\x38\x89\x23\x16\xd2\x7d\x12\xa8\xae\x0b\x8f\x4a\xbc\x4e\xa2\x6b\xe5\x96\x04\xe3\xce\x20\xd1\x46\x5e\x2b\xd4\xb9\x4a\xc2\x09\x2e\xe8\xae\x5d\x5f\x3b\xb1\xfe\xe5\xf5\x5b\x1e\x28\xfc\xd6\xc7\x9f\x9d\xb3\x31\xeb\xd1\x9b\xd7\xde\x94\xb3\x5f\x1d\x2f\x98\xc7\x0d\xc6\x89\xc2\x44\xd2\xf2\x72\x43\x26\x03\xc7\x89\x16\x8b\xdd\xc1\xec\x8a\xc3\xe0\xdd\x1f\x46\x7c\x1f\x27\x7b\xb6\xe8\x39\x53\xc4\xaa\x60\xc3\xa0\xcc\xac\xd8\x34\x62\xf2\x99\x77\x2c\xcd\xcb\xd2\x03\xe9\x13\x85\x89\x13\x6a\xaf\x7b\xa9\xbc\xde\x33\xad\xc8\xeb\xcf\xc8\x4b\xaf\x0e\xd1\x7c\x0e\xf1\xcd\xb8\x4c\xf4\x93\x7c\xfa\x85\xdc\x24\x13\x92\x95\x96\xcf\xad\x61\xba\xb7\x60\x1f\xe2\x2e\x69\xc1\xa8\x5e\x96\x2b\x25\xba\x34\x91\x9d\x4a\x0f\x43\x07\xd6\xbf\x7c\xd8\x34\xe5\x0a\x62\xc3\x8c\xe1\x9b\x55\x23\xc6\x39\x30\x8f\x58\x31\x39\xc9\x45\x83\x69\x5d\xff\x95\x6f\xc4\x9b\x84\x76\xab\x48\xf7\xe3\xfd\x07\xf7\x11\x72\xff\x19\xbb\x5f\xf9\xef\xef\x89\xdd\xed\x16\x8e\x77\xff\x41\xca\x47\x76\x7a\x46\x81\xd9\x62\x11\x45\x64\x30\x38\x04\x8e\xd3\x99\x2c\x74\xa4\xa9\xd4\xfa\x72\xbc\xc1\xcd\xa9\x9e\xd8\xe9\x52\x45\xba\xde\xd2\x5f\x3e\x18\xce\x06\xf3\xea\x6a\xd3\xa6\xcd\xff\xdb\x84\xe9\x8b\x87\x17\x8b\x5b\xd2\x32\x3c\x33\x53\x6f\xad\xbe\x5c\x2e\x5d\xcd\xa5\x32\xb9\x6e\x13\x8e\x2b\x2f\xfe\xe7\x79\xc0\xc5\x79\x28\x49\xff\x3a\x13\xe8\x9a\x4a\xf2\xd0\xff\x57\x79\x44\x5a\xff\x65\x1e\x84\x76\x8d\xfc\x50\xae\x4a\x58\x66\x15\xf1\x2e\x74\xa9\xfb\x83\x7c\x23\xe7\x14\x7e\x45\xee\xef\x52\x6d\x0f\x42\xeb\x6e\xe1\xd7\xe4\x7e\x2b\xb3\x8b\x2c\xca\xf1\xee\x97\xba\x57\xb0\xfd\x4d\x88\xd8\xc9\x88\x8e\xe5\xc5\x7c\xf6\x05\x9d\xdf\x3c\xa5\x1c\xdf\xb3\x07\xfd\x47\xf5\xf8\x6f\xf8\x20\x5a\xaf\x76\x11\xbf\x7a\xa9\xfb\x7f\x5b\x96\xff\xf2\xbe\xab\x5b\x39\x1e\x39\xd0\xbd\xc2\x2a\xe9\x4d\x91\xf3\x88\x95\xa9\xeb\x46\x12\x57\xa3\xc5\xad\x57\xe3\x3a\xbf\x52\x8e\x77\xdd\xa7\xc6\x75\xbd\xaf\xa5\x3b\x49\xd2\x5d\xa3\xa5\x7b\x5e\x4b\xf7\x20\x49\x37\x4d\x4b\x77\xbb\x1a\xd7\x37\xcf\xc8\x55\xca\x71\xc5\xa7\xa6\x51\x1a\xd5\x34\xca\xb5\x84\xe6\xfd\xd5\xb8\xee\x15\x5a\xdc\x1f\x49\xdc\x46\x12\x27\xea\x4d\xcf\xd2\xfc\x7e\x22\xf9\xed\xd5\xf2\xfb\x52\x4d\x13\x59\x4b\x60\x15\x6a\xb0\x16\x68\x71\xb3\x49\x5c\xa2\x16\x77\x85\x86\xeb\x2e\xf2\xee\x44\xed\xdd\x76\x2d\x9d\x9f\xc4\x9d\xd6\xd2\x25\x68\xe9\x06\x10\xfc\xff\xae\xa5\xcb\xbf\x34\xfe\xff\xbb\x7b\x22\x87\x8a\x48\xf0\x09\xb7\x87\xd8\x9a\x39\xa1\x04\x89\x28\xc4\x84\xdb\xf5\x22\x3f\x2e\x2c\x5a\xe2\x17\xc8\xf4\x1a\x7d\xa2\xa3\x02\x74\x32\x7a\x0c\x5d\x9f\x75\x1b\x5d\x26\x40\xc7\x15\x26\x7a\x86\x22\x4e\x79\x5d\xd8\x01\xd3\x24\x1f\x1b\x77\x4e\xa2\xde\x4f\x25\x93\xc3\x84\x89\x5e\x9f\x6c\x70\xb9\x10\xb6\xf2\xac\x21\xd1\xbe\x9c\xb5\x24\x6d\x59\x51\xa5\x4f\xe2\xe2\xc6\xb1\x7c\x71\xd7\xca\xeb\x5e\xbc\xcc\xfb\xab\xac\x81\x55\x39\xb9\x15\x95\xca\x5d\x81\x01\x55\x39\x39\x95\x03\xc4\xdb\x6e\xbc\x51\xb9\x50\x99\x97\x53\x59\x99\x13\x18\x30\x20\x10\xe8\x5f\x99\x93\xc7\xf6\xbf\x70\xdd\x1c\x3f\x18\x52\x84\xf3\x6c\x7c\x2d\x05\xe5\x85\xec\x49\x1e\x8f\x85\xd3\xeb\x9d\x16\x4b\xaa\x27\x49\xb4\xdb\x8d\xd4\x95\x77\xa9\x8d\x20\x12\x1d\xba\x57\x5b\xb4\xe3\x67\x70\xa8\xc1\x41\x0b\xec\x8a\xa2\xb0\x4b\x43\x61\xa4\x78\xf5\x4b\xd2\x39\x7e\x70\x5f\x24\x3e\xf3\xed\xcd\x7a\x84\xe0\xa1\xfc\xc4\x87\xa0\x51\xe8\x66\x78\xa4\xa3\x01\xa1\x54\x27\xc5\x22\xcd\xc2\x79\x52\x52\x7c\x69\x49\x49\xf6\x14\x8b\x27\xcd\x53\xe4\xe1\x3c\xf1\x38\x35\x94\xda\xaa\xb4\x26\x1d\x5d\x6b\xf3\x73\x78\x81\x24\xf8\xe9\xe1\xd0\x95\xbb\xfb\xe2\x06\x6f\x89\xdd\xe8\xd1\x83\xe2\x88\xd7\x09\x12\x7d\x11\x84\xa3\xbe\x3f\xfd\xc9\xb7\x61\x03\xa5\x95\xc0\x87\x50\xb7\x40\xfd\xc9\xda\x54\x5a\x61\x41\x70\xea\x2d\x96\x24\xa7\x33\xd5\xe8\xf1\x20\xce\x2e\xf6\xae\xb1\x28\xad\x38\x9a\xb1\xe4\xfe\x19\xcc\xbc\xbf\x93\x5e\x1a\x26\x2e\xec\x8b\x96\x90\xf1\x48\xd6\x5e\xdf\x27\x17\x55\x1b\x56\x4e\x09\xab\xa0\x45\x2a\x67\x7c\x93\x1f\x72\x1a\x78\x1e\x53\x43\x1f\xa3\xf6\x30\x36\x85\xd8\xb4\x85\xa0\x75\xbd\xbd\x67\x2e\x08\xeb\x08\x3d\x6e\x6a\xb3\x95\x53\x94\x5d\x94\xf2\xf1\x55\xfd\xc7\x8d\xad\xac\x19\x2d\x3e\x7a\xe3\x8d\x4f\xf4\x1f\x3d\xae\xa2\x62\xcc\x68\x62\x1e\x2b\xb7\x0b\xdb\xa1\x89\xe5\x93\x88\x26\x86\x64\xec\xf5\x22\x93\x29\xd9\x63\xb5\xea\x89\xc5\x71\x28\x6c\xb5\xd2\x7c\xd5\x71\x50\x0b\x4e\xc3\x58\xe6\x30\x1f\xe2\x9d\xcc\x1c\x31\x52\xe6\x8d\x1f\x90\x8d\x2d\x96\x8b\x4d\x00\xa9\x9c\x5c\x88\xe9\xf2\x1a\x66\x51\xa4\x62\x3a\x40\x15\x14\x95\xb7\x28\x5e\xdf\xf4\x1b\x5e\x55\x92\x18\x28\xb6\x37\xa5\xaf\x9e\x52\x48\xaf\xb3\x4b\x6d\x4d\x83\x28\x92\xca\x67\xc9\xbe\xe4\xec\xe0\xca\x05\xa4\x1f\xcf\x2a\xfe\x98\xb6\xcd\xdd\xa4\x82\x9e\x16\xb6\xa8\x5e\x84\x25\x00\x9e\x79\x10\x96\x24\xd0\xf1\xcc\x59\x6f\xf0\x58\x9f\x93\x85\x7c\x7e\x1b\x53\x80\x6d\x41\xee\xe9\xad\xca\xaf\x95\x13\x30\x0b\xf2\xb6\x72\xf7\xc2\x8c\xad\xca\xdb\x90\xf7\x7f\x00\x73\x87\xf2\x31\x83\x89\x4f\xe1\xcc\xad\xca\x70\x78\xf6\xff\x00\xe6\x2f\x94\xaf\x60\x11\xa4\x6f\x85\xfb\xb8\x69\x5b\x23\xd3\xf0\x83\xf1\x30\x75\x74\xde\x06\x44\x91\x68\x43\x7a\x03\x61\x78\xba\x33\x56\x83\x18\x0f\x2f\x0e\xdc\x26\xe5\x5b\x06\x8e\xff\x69\x6b\xd7\x30\xee\xb7\x04\xd6\xd8\x78\x58\x74\x67\x2d\x81\xc4\x71\x20\x60\x1d\x83\x15\x8c\x9b\x05\x62\xb8\xe9\xa1\x52\x0f\x0c\xd6\x61\x65\xf6\x0c\x18\x0c\x75\x5b\xf9\x57\x94\xd7\xe0\xba\x16\xe5\xcf\x50\xa6\xea\x89\x13\x63\x65\x26\xba\x42\xb4\xcc\x9c\x28\x82\xa0\x67\x40\xfb\xcc\x2c\xf9\xa8\x6d\x52\x49\xbd\x0f\x50\xb0\xb7\x28\xed\xad\x30\x02\xca\xb6\x72\x0f\xc1\xa2\x16\xe5\x30\x4c\x64\x30\xa3\x78\x4a\x14\xa6\x00\x74\x66\x4d\xa7\x27\xed\x11\x78\x49\x83\x79\x11\x15\x2b\xd5\x42\x47\x52\x9b\xf0\x35\x5b\xf1\x28\xfc\x5a\x63\xe4\x6e\xbc\x34\x0e\x56\x2f\xfc\x58\x9d\x08\x97\x86\x55\x4e\x4a\x0d\x0e\x5b\xb4\xd8\x93\xe0\xc0\xfb\x5b\xbf\xc6\xbf\x81\xeb\x16\x28\x73\x95\x22\x6e\x1e\x81\x59\x1b\xa3\x63\x7a\xc8\x14\x57\x27\x7c\x14\x62\x3c\xbc\x38\x70\x0f\x29\x8b\xa7\xc1\xe3\x1f\x6f\xe5\x7e\x05\x6b\x67\x2b\xf3\x23\xf7\x70\x17\x58\x79\x09\x3c\xbc\xf8\x52\xe5\x15\xf9\x7f\x55\x5e\xbc\x78\xab\xd2\x38\x8d\x54\x0a\x61\xec\xcd\x6d\xca\x3b\x90\x43\x60\x95\x5f\xba\x8e\x25\x2c\xfc\xbb\x3a\x7e\x4a\x99\xb8\x80\x54\x06\xa9\xe3\x35\x91\xb7\xf1\x67\xe3\x22\x67\xb1\x4f\xad\xe3\xf2\x18\x0d\x0b\x43\x09\x51\x1a\x8a\x74\x22\x88\xe8\x84\x3d\x84\x2c\xb2\xf7\x5e\x3b\xd1\x03\xdf\xd6\x93\x41\x0b\x14\x92\xf2\x2b\x4f\xe2\xcf\x46\x47\x0e\x40\x3f\xa0\xfe\xce\xc7\xff\x1c\x0f\xf5\x80\xfe\x79\x1e\x7a\x58\x59\xbd\x1c\xda\x40\xb7\x15\xdf\x8d\x77\xd5\x45\xee\xa7\xa7\xb7\xa9\x6b\xbb\xff\x77\xf5\x4e\x31\x05\xb7\x0a\x73\x97\xd2\xbc\x12\x6e\xf9\x71\x2b\x98\x61\x26\xfe\x63\x6d\xa4\xf6\x27\xee\x00\x81\x59\xa7\xc1\x14\x59\xbd\xf3\x74\xef\xbb\x8e\x54\xba\xc0\x5d\xaa\xde\x63\x2c\xe9\x5d\x45\x2a\x4a\x18\x34\xac\xf3\x4e\x7e\x0e\x8a\xad\x3b\xff\x7f\xac\xef\xe1\xcb\x48\x05\xe1\x29\xf8\xd3\x3a\x56\x3d\x80\x32\x63\xf5\x1d\x93\x39\x3f\x5f\xe3\xb6\x8b\xdb\xf5\xa0\xf5\x6a\x9d\x7b\xbb\x3e\xe0\xc3\xa5\x5d\x1f\x70\x7e\x15\xc7\xac\x4b\xc9\x32\x0a\x57\xf7\x6f\xe0\x96\x33\xc0\x2f\x2a\x65\x1b\x61\x2a\x6d\xd9\xf7\x45\xae\xe3\x73\xca\xbb\xfe\x07\xcf\xde\xdf\x1b\xee\x7f\xc5\x4b\x07\x94\xcb\xd6\xc1\x32\x48\x26\xb4\x50\x9e\xe4\xeb\x4a\xbb\x36\x80\x1d\x2f\x21\xf0\x03\xff\x0d\x2f\xdd\xaa\xcc\x5c\x03\xd7\x80\x71\x2b\x4c\xe0\x94\xd2\xae\xa9\xdc\xc3\x51\xdd\xf0\x12\x32\x38\xae\xc1\x17\x5d\xd4\xe2\xdd\x51\x01\x52\xb7\x09\xf6\xfe\x79\x2b\x8c\xe0\xb9\xca\xae\x84\xb7\xf9\x17\x35\x1a\x68\xf5\x4f\xf8\x28\x5a\xff\xf1\xb5\xdf\x4b\x1e\xc5\xea\x7e\xd0\x3a\x52\x51\xdf\xf1\x33\xb4\x5a\x02\xa2\xa7\x44\xf1\x8a\x95\x95\xe0\x85\xe9\x0a\x10\xd0\x4e\x4b\xab\xfa\xf9\x9a\xaf\xd8\x00\x63\xa9\xf0\x38\xdd\x95\x2b\x4c\x28\xee\xca\xe5\x4e\x53\x98\xee\x4b\xd1\x8f\xc0\x14\xf4\xff\x12\x66\xb9\x06\xb4\x78\x23\x84\x61\xc8\x56\x6e\x45\xd7\x8d\xc2\xf8\xa2\x2e\x37\x77\xe5\x66\x95\x9f\x2a\xfe\xdf\xe0\x46\xc9\x38\x7e\x13\x8c\x83\x82\xad\xb8\x3d\xb2\x44\x98\xd4\xaf\xf3\x53\x7c\x15\x3c\xd9\x07\x2e\xd1\xd9\xe2\xdb\xb9\xa0\xa7\xdc\x4a\x8d\xc2\x8b\x4f\x1e\xd4\x5a\x7b\x56\x0c\xfa\x46\x58\x0e\xd2\x56\xe8\xaf\xfc\x81\x42\x5f\x77\x81\xbb\x89\xc2\x2e\x8e\xf5\x43\x89\xd4\xef\x3a\xad\x25\x91\xf5\xbb\xc1\x38\x19\x9a\x0b\x04\x52\x90\x42\x52\xf2\x95\x71\x5b\x60\xe7\x57\x5b\x85\x49\x85\x9d\x74\x46\x89\xc2\xc8\xd5\xea\x3a\x4e\x66\x48\xba\x7f\x29\x33\x68\x55\x0f\xd9\x02\x83\x29\x18\xb5\x56\x50\x9c\x8c\x94\xe8\x59\x05\x02\x45\x85\xae\xbb\x11\x7b\x33\xa0\xc6\xcf\x01\xf0\xd1\x72\xbd\xa6\x1c\x6c\x21\xe5\xfa\x9e\xff\x49\x39\xdc\x02\x8b\x54\x38\x63\xfa\xd0\x8b\x9d\xc6\x20\x61\x4c\xa0\xe9\x34\x70\x14\xde\x25\xe8\x15\x88\xd6\xc6\xd3\xca\x0b\xd3\xe1\x6e\xca\x3a\x37\x43\xb9\xf2\xde\x6c\x58\x43\x74\x82\xb2\xff\x1b\xd8\x77\x28\xef\x5e\xce\x60\xe3\x5c\xbc\x45\xf9\x61\x2e\xac\x89\xbc\x80\x6b\x2e\x0d\x5b\x36\xfc\x7b\xd8\xe5\x20\xc4\x60\x5f\xab\x7c\x3d\x89\xc1\xfe\x82\xdb\x4b\x21\x77\xbd\xc5\xf5\x63\x34\x69\x8c\x6f\xdf\xe2\x25\x25\x68\x55\x5c\x9f\x19\x07\x72\x9b\xf2\xdd\x04\x02\xb2\x62\x2b\x7f\xfd\xe7\x84\x0e\x5d\x83\xb8\x97\xfe\x7f\xac\x5d\x07\x7c\x15\xc5\xf6\x9e\xb6\xb3\xbb\x29\x84\x90\x10\x3a\x24\x74\x44\x08\xb9\xbb\x37\x21\x14\x49\x07\xa4\x4a\x0f\x10\x20\xa4\x90\x40\x92\x1b\x52\xa8\x0a\xd8\xe3\x43\xc5\x82\x3e\x7b\xc1\xde\x00\xb1\x77\x29\x56\x40\xa4\xd9\x10\x15\x10\x01\x1b\x82\x88\x2d\xd9\xfc\xcf\xce\x3d\x09\x37\x21\xe8\x7b\xbe\xbf\xfe\xf8\x76\xb2\xe5\x9c\x33\x67\x66\xe7\xfb\x66\xef\xbd\xb3\xfe\x58\xb1\xcd\xc1\x9e\xa6\xfa\xa4\x6e\x80\x41\x26\x9b\x1c\x2f\xc2\xa1\xc1\x54\xab\x6f\x9a\x41\xef\xaa\x12\x9b\x9c\xfd\x85\x74\x71\x43\xed\x07\x7d\xc7\xcf\xe5\x02\x58\x02\xe5\x5a\x63\x26\xd7\x5d\xe9\xe7\x46\x55\xeb\x94\xd2\x09\x74\x60\x95\xd8\x72\xa0\x8a\x46\x35\xd0\xa5\x3d\x93\xc2\xeb\xee\x11\x9d\xb9\xaf\xab\xa2\x26\xc5\xef\xb5\x9c\x35\xda\x06\x48\xc9\x3b\x41\x35\xbb\xc4\xcd\x0a\xe9\x12\x08\xd3\x7d\x89\x6c\x43\xbd\x1b\x70\x4f\x0b\xbd\xa1\xd5\x73\xd9\xbc\xc7\xd9\x4d\x97\xd3\xe6\x55\xd4\xcb\xd6\x56\xd5\x9c\xe4\x5d\x1b\xda\x54\x63\x9a\x7f\xac\x0d\x32\xb9\x74\x9b\xb9\x69\x9b\xae\x49\xd4\x57\x4f\x39\x5b\xe8\x3d\x27\xaa\xf8\xa1\xaa\x9a\x21\x75\xf7\xcd\xd8\x7a\x7b\xf5\x75\x77\x5b\x57\xe3\x01\x79\x4c\x8c\x3d\x37\x43\xbe\xe4\x14\xcc\xa2\x1d\x69\x76\x95\x58\x54\xb3\x97\xde\x3f\xdb\xd9\xc7\x26\x35\xbc\x8f\xfa\x25\xb5\x3c\xc3\x63\xba\xfb\x6d\x2d\xd7\xb8\x59\xff\x5b\xd9\xbf\x61\xb2\x17\x9d\xbc\x59\x74\xa0\x7b\x37\xad\x77\x5e\xa2\x77\xcd\x72\xde\x02\x42\x6e\x5e\xa7\x0b\xcf\xe6\x60\x2e\x35\x19\x68\xfe\xdc\x6c\x96\xef\x3c\x3d\x9b\x9e\x47\xb3\x40\x19\xd1\x05\xd3\x9d\xe7\x41\x19\x9d\x89\x5b\x77\x6d\xfa\xb9\xc7\x04\x4a\xd7\xdc\xd7\xcf\xd5\x25\xf8\x9c\xea\xba\xc3\x0c\x76\x65\x15\xed\xc1\xbe\xce\xa9\x59\xca\x6f\x6b\x30\x9e\x34\xe4\xc6\xc0\xe6\x3a\x97\x1a\x86\x8a\x4f\xa3\xeb\x3f\xa9\x62\xe5\xf4\x8e\x1c\x67\xbc\x93\x23\xa6\x05\xdc\x3b\x3a\xde\x3b\x7e\x6e\x6c\x10\x5d\xd3\xca\x28\x37\x8b\x0e\xa9\x62\xb9\xf4\xae\x3c\x67\x23\x9b\xd6\x88\xb7\xff\x69\xdb\x0f\xad\x04\xfb\x13\xaa\x44\x87\xea\xc3\x3c\x3b\xa3\xe6\x76\x3e\xc4\xb5\x9b\xf8\xbf\xb7\x7d\x1d\x5f\x8e\x5b\x40\xfb\x2b\x05\x5f\x33\x9f\x0f\x1d\x5a\x73\x3f\x5b\xf5\x9c\xbf\xdf\x0e\x09\xf0\x11\x15\xe8\x83\x43\x63\x31\x18\x4c\xfc\x4e\xd4\xa7\x4c\x7f\xd9\xbf\x36\x39\xa3\x17\xd2\x2c\x57\x29\x95\x3b\x0f\xf2\x29\x83\x6b\x26\xd2\xfe\xee\x5b\xa2\x1b\xf8\xf8\x47\xfd\xeb\x01\xa7\x78\x21\xcc\x30\x83\xaa\xe8\x24\xde\x66\x70\x8d\x87\x3f\x10\x60\xf3\xbf\xe8\x0f\xad\xea\xa6\x07\xd3\x17\xd2\x3b\xbe\x84\x01\x81\x0f\x18\x5c\xfd\xc5\x56\xbf\x56\x1a\x52\xdf\x1f\xea\xfb\xab\xd2\xca\x7f\xdb\x5f\xdd\x3e\x31\x79\x21\xf5\x54\xd1\x3e\x3c\x65\x70\xcd\xe3\xbc\x77\x03\xbd\xd0\x40\x2f\xbb\x03\xa1\xa1\xbe\x16\x67\x59\x4d\xf4\xb1\x40\xd5\x34\xe6\x12\x6a\xd7\xa9\x26\xb3\x5f\xf5\xfc\xba\x71\xc6\xdb\xe4\xdc\xdf\x1d\x0a\xff\xc6\x6e\x5d\x4f\x18\x7d\x09\x1d\x54\xa7\x9c\xcc\xb8\xea\x69\x4a\x39\x9d\x43\xdf\xb8\x3d\xad\xb1\xe5\xbf\x1a\x61\x02\xd5\x53\x70\x9f\xea\xde\x4a\x3d\xfd\x4f\xb6\x9b\xd6\x4e\x41\x7d\xfe\xdc\x82\xda\x29\xbe\x7e\x9c\xe9\x98\x14\xe2\xd7\x4e\xdc\xfd\x65\xad\x52\x4f\x67\x18\xb0\x81\x7e\xea\xe7\x1a\xbb\xf3\xab\x2a\xd7\xce\x45\xa8\x9f\xbc\x81\x5c\x5a\xaf\x9f\xa0\xff\xcb\x26\xfb\x53\x7d\xd3\x8f\x5a\x0e\x93\x0f\x30\x54\xbd\x84\x7f\x48\x1a\x8c\x7b\x6e\x3c\xf4\x1c\x02\xaa\x91\x82\x3a\xe0\x3c\xe1\xa3\x0b\x5d\x05\x55\xb3\x79\x04\x5b\xd2\x70\xdc\x3f\x3f\x29\xa2\x4e\xe3\x80\xde\x94\x8d\x84\x48\x53\x8a\xb3\x5e\x36\xec\x72\x5e\xf6\xd5\x29\xa8\x8e\x4e\x08\x98\x56\x0a\xea\xff\xcd\xfe\xd3\xce\x3e\x5f\x9d\x8a\x1a\xef\x24\x81\x7d\xa5\xa2\x1a\xda\xf7\xf7\x53\xbf\x46\x3b\x4b\x45\x35\x7a\x22\x52\x6f\xf9\x4e\xe7\x84\x0f\x35\x54\xa5\x33\x03\x0c\xfb\x45\x54\x23\x1e\xf8\x7b\x0d\x15\x60\xf2\x1e\xe7\x47\x1f\x7d\xca\xd5\x50\xe3\x9c\xb9\xae\x45\x57\x44\xf9\xbf\x7f\xf2\x0f\x75\xd4\x71\x1f\x5d\x51\x25\x96\x39\x83\x46\x35\x6c\x33\xe9\x5f\xb5\xe9\x5c\x56\xea\x6d\xb8\x54\x37\x6f\x34\x3b\x54\x25\x76\xd4\x7c\x58\xe0\xb7\x91\xd1\x48\x43\x69\xfe\xb1\x52\xc0\xff\x01\x83\x65\xe3\x36\x51\x3d\xc9\x5f\xcd\xd7\x9d\x57\x66\xd3\xb9\x74\x39\xc8\x13\xe7\xb6\xe9\x74\x35\x28\xb3\x86\xed\xe1\x9f\x0f\x63\x7b\x73\xbd\xb1\xe9\x16\x89\x9e\xff\x44\x93\xb3\x4b\xeb\x35\x39\x4b\xff\x0b\xfb\x52\x6f\x64\xbf\x49\xa6\x3a\x5b\x97\xd3\x36\xf5\xba\x9c\x8f\x69\xd0\xee\x30\x86\xc0\x78\x8f\xe3\xa9\x9f\x65\x8d\x06\xd6\x1b\xdc\xa7\xbc\xde\x74\xe1\xe1\x39\x30\x93\x2f\xad\x82\x01\xe0\xeb\xe9\x74\x53\xf5\x83\xa2\x6b\x03\x1d\x00\xf9\xf6\xb7\xbd\x1a\xf7\x75\xb7\x53\xe1\xad\xdf\xc4\x73\x92\x1e\x30\x9e\xba\x5d\x60\x63\x16\x48\x69\xfe\x9e\xb3\x31\x8f\xde\x75\xba\xa1\xae\x0c\x18\xf7\x05\x33\xb4\xfa\x28\x63\x5b\x34\x56\xab\xbc\x4e\x51\x1f\x71\xa6\xd0\x49\x34\xb1\x4a\x4c\x75\x92\xab\xdc\x07\x4c\x81\xda\xd7\x7f\x9f\xfa\xb5\xaf\x06\x77\xaa\x19\xa0\x7f\x9b\xe2\x7f\xbd\x5e\x03\x9f\x74\x72\x68\x3e\xed\x55\xc5\x6f\x77\xaa\xe8\x00\xda\x95\x9c\x4b\xab\x33\xbd\xb1\xaa\x3e\xb7\xae\xbe\xdb\xd9\x43\x73\x60\xb0\xa7\x5d\xe9\xc2\x2a\xe7\x2d\x7e\xfb\x39\x75\xb5\x19\xf4\x77\xba\x9a\xd6\x3d\x62\x7b\x8f\x5e\x43\x25\xe8\xc8\x2a\x47\x88\xa9\xca\xde\xa4\x7a\x7b\xf5\xcf\x71\xdc\x3b\x9e\x69\x46\xa3\x96\x0f\x6f\x72\xee\xad\xf9\xf9\xf4\x4d\x67\xce\x4c\xa8\xd6\xfc\x2a\xd1\xb5\x26\x9c\xae\x9c\xe1\x70\xf7\xfd\xc8\x93\xeb\x73\xe0\x69\xa8\x7d\x98\x66\x36\x12\x58\xe1\x7f\xab\xb0\x4a\x67\xd0\x16\xb4\xa0\x8a\xaf\xa8\x79\x8d\x5e\x3e\xc3\xf9\x8d\x2d\x39\xe1\xc6\x9f\xf9\xff\xa7\xdf\xcb\xa6\x81\x24\x18\x5a\xc5\x8a\x60\x10\xbf\x2c\xdf\xd9\x4b\x3d\xcc\x9f\xa3\xc9\xff\x9b\xbe\xba\xcd\xb9\x61\x36\x1d\x41\x7b\x83\xbe\xa2\x45\xd3\x9d\x37\x95\xbe\x9a\x54\x3f\x96\x05\xf0\xa1\x4b\x87\x8d\x99\xb5\xd1\x53\xc8\x1e\x33\xd9\x92\x2a\xf6\xe6\x8c\x9a\x7b\xc4\x5b\x6e\x6c\xd3\xff\x17\x5d\x55\x91\x45\x63\xab\xa0\xd2\x2b\xf3\x9c\x5d\x7c\xa5\xaa\x6b\xff\xc0\xfe\xe5\x9f\xab\xfa\x6f\xae\x00\x21\xd1\x22\xb1\xe9\x27\xcf\xef\x3b\x43\x7c\xb4\x37\x4c\x54\xf8\xe6\xea\xc1\xec\xd3\x11\x4e\x1b\x91\xe6\xda\x4c\x68\xea\x1e\x83\x16\x32\x1b\x09\x94\x26\x7b\xd8\x99\x1e\x30\xd6\x07\xb3\xa0\x99\x55\xbc\x4f\xf5\x6e\xd7\x78\x08\x2f\x38\xe6\xbf\x27\x12\xfe\x3f\xb4\x15\x58\x1f\x42\x2f\xac\x62\x43\x80\x62\x3f\x1d\x51\x73\x8c\x8d\x60\xbd\xdc\x7c\xd4\xd6\x34\x71\x1f\x6b\xd0\xbb\x4c\xe9\xfe\x5e\x4a\x99\x4e\x8c\x8d\x3d\xa7\xe5\x97\x5c\xcb\x53\x61\xd2\x4d\x33\x9d\x07\xd9\xe7\x23\x6a\x5e\xa6\xc9\x7c\x76\x83\x5c\xff\x77\xda\xea\x22\x1f\xbd\xee\xcf\x2a\x37\xc6\x5c\xd4\x56\xfd\x9b\xd2\x56\x7f\xd3\x97\x58\xe9\x35\xae\xa5\x64\x65\xe8\x90\x50\xdc\x38\xf4\xbf\xd0\x56\x5d\x50\x5b\xfd\xe8\x2c\x5f\x0c\x84\xb2\x57\xfc\x5e\x9d\xe5\xe1\xfe\x78\xd2\xff\x3f\xb4\xcf\xd7\xce\x53\x4b\xe9\xdd\x74\x54\x15\x5f\x44\x5b\x54\x6f\x03\xdb\xce\xd3\xee\x3a\xf4\xff\x5f\xf6\x3f\x70\x36\x2f\xa5\x6b\x5c\xa6\xcd\xa1\x27\x6a\x58\x1c\xff\xa3\xe6\x88\xfb\xb9\x7e\xbd\xfd\x2b\xfe\x7b\xfb\x81\x0a\xeb\x39\xe7\x73\xbf\xfd\xbb\x79\x65\x4d\x9a\x87\x57\x57\xdf\xc7\xb3\x48\x83\xf8\xd5\x7c\xb6\x8e\x6b\xa5\xd6\x48\x66\x9d\xf5\xf9\x53\xbd\xe9\x27\x9d\xc3\x7e\xd3\xbc\xa6\x26\x13\x12\x53\xf7\xcc\x37\xfd\x1f\xea\xac\x4f\xc0\xda\x35\xa2\x7d\xcd\x00\xd5\x80\xd4\xfd\x8e\xf8\x19\x0d\xe8\xaf\x3f\x70\xac\x08\x78\x60\xd5\x88\x09\xdd\xd0\xdc\xc8\xbe\x74\x1e\x5d\x48\x67\xd3\x91\x55\x62\xd3\xd6\x9a\x99\x83\xd9\x4b\xd4\x1b\x68\xef\xbf\xd3\x5c\x5d\xea\x35\xd7\x31\xe7\xe9\x05\xb4\x8c\x0e\x02\xc9\x55\x53\x3e\x98\x7d\xa2\x24\x57\x83\xf9\xfb\xff\xa4\xb9\x76\x39\x6b\x17\xd0\xb5\x6e\x4f\xc8\xa4\xd7\xd6\xcc\x1f\xca\x87\x3a\x13\xd8\xf0\xff\xcd\x7e\x60\x4f\x58\xef\x7c\xe8\xb7\xff\x1c\xfb\xb1\xe6\x59\x30\x5f\x13\xcd\x2f\x76\xe3\x1f\xd0\xa4\xe6\x92\x5a\x23\xe6\x75\xad\x9f\xa3\x27\x3c\xea\x7c\x52\x09\x9a\x1b\x7a\xc2\xcd\x35\x5b\x32\xf8\xb0\xea\x5b\x84\x5e\x9f\x9b\xb3\x75\x97\xfb\xce\xd1\xff\x4c\x77\xbd\xbb\x90\xae\xab\xe2\x2f\xd5\xdc\x3b\x98\x8f\xba\xd7\xb5\x77\x63\x7d\xac\x38\x36\x34\xdd\x23\xfc\x7a\xab\xae\x3f\x7c\xe2\xdc\x32\x0d\x48\x6f\x58\x95\x98\xe6\xe4\x38\xb7\xe5\xd0\x89\xac\x3c\xc0\x96\xe2\x2c\xae\xeb\x4c\x4a\x18\xf9\xdc\x55\xa3\x35\x5d\x6b\x8a\xb3\x4c\x15\x57\x78\x17\x1e\x5b\xf3\xda\x34\x76\x4f\x55\x15\xff\xbc\x66\x49\x0e\x3b\x74\xf8\x8f\xe5\x81\xb1\xfd\x63\x4d\xff\x95\xb3\x7f\x1a\x1d\x46\x27\x81\x32\x72\x5e\xc9\xa1\x73\xf1\xb3\xc7\x1b\xff\x87\xfe\x15\x20\x8c\x5f\xad\xf5\x27\x81\xa6\xd0\x38\xe7\x50\x0e\x5d\xe4\x6c\xe3\x57\x34\xcc\x69\x03\xcd\xed\x6f\x7e\x89\x63\xf7\xd9\x91\x53\xfd\xcc\x9c\xeb\x8b\x19\xca\x34\x1b\xf9\x7b\x3e\x5d\x54\xb3\x5b\x5c\x42\xce\xa5\xb9\xff\x93\xb6\x0f\x3f\xa3\xb9\xd9\x6a\xa5\xb9\x59\xef\xc6\x9a\xb3\x5e\x73\x37\xf9\x04\xbb\xb1\xe2\xde\xe7\x8c\xa4\xe3\xe8\xe0\x2a\xfe\x71\x0d\xcc\x98\x1e\x68\xfc\xbc\xb9\x81\xe6\xae\x53\x04\x7f\xa1\xb9\x79\xbd\x98\x3d\xee\xcc\xa2\xa3\xdd\xe7\x2c\x5d\x1d\x4f\x15\x2b\x81\x81\xe6\x7f\xb1\x1b\x20\x92\x3f\x72\xee\xa4\x9d\x60\x1a\xc3\x6e\x76\x36\x57\xd1\xab\x59\xfb\x26\x74\xb7\xe1\xaa\x2b\xdd\x0c\xa2\x8c\x49\x61\xc8\x26\x72\x80\x06\x61\x10\x7b\x03\xbf\x61\x02\xea\xaf\xca\xf9\x4e\xbc\xe8\x76\xd9\x06\xf3\xad\x80\x79\x8c\x4a\x69\x9d\x62\x39\x7b\x9c\x3d\xa3\xb7\xd5\x33\x57\x42\xe1\x46\xd8\x55\xdd\x97\x2e\xce\xff\x4e\x5c\xd7\x60\x8e\x18\xa8\x55\x9a\x50\x59\x67\x5b\xf5\x9e\x31\x1b\x42\x2f\xae\xe2\x13\xab\x9f\x00\xb3\xbf\xf2\x4f\x36\x36\xf1\x2c\xe3\xbf\xd4\x6f\x01\x8f\x89\x3b\xd0\x79\x4a\x61\x81\x6d\xe7\x0f\xb6\x9c\xf5\x6a\xf2\xb3\xac\x7f\xa4\xdf\xc0\xfa\x10\x3a\x1c\xd4\x2c\xa8\x77\xb0\xbe\x8f\x7a\xf9\x4d\x0d\x3e\x6f\xfb\x4f\x34\x96\x1a\x0f\x9c\x38\x67\xce\x0c\xba\x90\x06\x57\xd1\x05\x85\xce\x63\xe2\x77\xfc\xdc\xee\x1f\x68\xac\x2a\xd7\xd2\x40\x65\xe7\x2b\xff\x73\xd0\x86\x9f\x45\x2a\x8d\xc5\x65\xe3\xcf\x22\x03\xf4\xd5\x77\x4e\xf1\xa5\x74\x83\xab\xaf\xfe\xd4\xfb\x6a\xe3\x1b\x7d\x56\x1a\x30\xde\xa9\xef\x44\xd4\x9b\x6a\xe2\x93\xd2\x6e\x67\x68\xe3\x77\xe7\xda\x65\xf4\x69\x97\x36\xae\xfd\xe3\xcf\xa5\x7d\xb4\xf1\xce\xbb\xb4\x7f\xe3\xcf\x77\xff\x1b\xdb\x01\x94\xf4\xb9\xf3\xf8\x72\x65\x9b\x5d\x48\x7f\xf8\xf3\x7d\x30\x5e\xb3\x97\xf9\x9f\xd9\xb6\xfa\x27\xb6\x03\x99\x74\xb3\xf3\xc0\x32\xfa\x21\xd8\xfe\x96\x37\xaf\x36\x63\xb5\x31\xd5\xfb\x78\x37\x7f\xdc\x1d\x1a\x3d\xaf\x56\xf7\x93\xee\x3e\xc0\xc0\xbb\xc9\x3a\x17\x87\xbe\xe8\x3c\x73\x09\x7d\x1f\x9f\x05\xf7\xd3\x2e\x3a\xf3\x59\xed\x99\xcf\x7c\x15\xe7\xf9\xf5\x14\x93\xbc\x41\x6b\x35\xfe\xec\xef\x52\xfa\x86\xb2\xa4\x1a\x2b\xf0\xb3\x0b\xf5\x06\x0a\xbf\x96\x62\x86\x68\xca\x46\xbd\x8e\xda\xe3\x8c\x5f\x4e\x5f\x74\x79\x73\xd3\x47\xd5\x91\x09\x82\x53\x77\x9d\x82\xb3\xbe\x13\xa1\xd5\x7d\x27\xc2\xac\xef\x84\xe7\xd4\x50\xa7\x9c\xbc\xc5\xf4\x39\x3a\x1e\x34\x54\x75\x07\x8f\x48\xac\xd3\x50\xdd\x9a\xfa\xac\x57\x71\x5c\xa0\xd9\xb3\x9f\x54\x34\x50\xea\xd7\x2d\xa5\xaf\x81\x52\x67\xf3\x41\xa9\x5f\xe2\x11\xc3\x9c\xa7\xd9\xa4\x7f\x6e\x3b\xb0\xc5\x3f\x76\xee\x5e\x46\x3f\xa6\x56\xd5\xdb\x6c\x6e\xf5\x87\x5e\x91\x54\x73\xa9\x3b\x51\x6d\xf4\x7d\x99\x00\xed\x04\xcc\xc9\x03\x2c\x9f\xb3\xcd\x5f\xba\x98\x6e\x76\xdb\xbc\x4b\xf5\x7e\x8f\xc8\xac\xde\x2f\xda\xd4\xe7\xa3\xc1\x77\x7a\xea\xb8\x93\xea\x75\x66\xcf\xa9\x99\x5e\x5c\x4a\x37\xc3\x6c\xa5\xba\xca\x23\xde\x5c\x45\x1a\x7c\xcf\xe8\x3f\xeb\x3f\xee\xfc\xfe\x86\x85\xec\x48\x95\x98\xf3\xe7\xed\x69\xda\xe0\xa6\xbe\xff\x54\xf7\x59\xfc\x99\x04\x9e\xf5\x5c\xaa\xbe\x9a\xbf\x39\x45\x0b\xe8\x7d\x74\x76\x15\x7f\xe6\xf7\x9a\x8c\x0c\xf6\x3e\xcd\xa1\xcd\x9a\xf8\x9e\xd6\xdf\xf7\xa3\x00\xad\xf4\x9b\x73\x57\x05\xad\xa2\x53\x40\x2b\xd5\xe4\x0d\x63\xfb\x50\x2b\x79\xff\xf7\x7e\xb4\xcb\xb9\x77\x1e\xe8\xe4\x91\x55\x34\x9a\xf6\xa9\x79\x66\x04\xfb\xda\x79\x9a\xdf\xdf\xe0\xbb\x70\x81\x6d\xdd\xe8\xa1\xc4\x5f\xb5\xb5\xdf\x2c\x8b\xa9\xf9\x72\x34\xfb\xba\xe6\x23\xb1\xb8\xe9\xef\x6f\xfd\x47\x6d\xed\x1f\xd6\x5f\x2c\xa7\xaf\x28\x83\xc3\xd8\x21\xd5\xd7\x33\xfe\x8b\xfb\xbc\x5e\x1f\x1f\x70\xc6\x4d\xa5\x37\xd0\xcc\x2a\x98\x7c\xde\xe5\xcc\xcd\xa7\x4b\x54\x7d\x1b\x7f\xd7\xf1\xef\xdb\x5c\x59\x54\x1c\xfe\xb9\x33\x6a\x3c\xbd\xc3\xed\xd9\x85\x4e\xac\x53\x30\x8f\x5e\xc9\x1e\xfa\xbe\x89\xef\x62\xfe\x87\x75\x75\xbb\xe4\x25\x33\xd9\xc1\x2a\x56\x56\x73\xe7\x0c\xb6\x8d\xb9\x6b\xfc\x35\xfe\xae\xe8\x7f\xd5\x7f\xb6\x39\x2f\xcd\xa6\xf3\x69\x11\xe8\x21\xe7\xd9\x6c\x5a\xae\x44\x61\xe0\x77\x5a\xff\x59\x1b\x6f\x9a\xae\x6a\x0d\xf4\xbf\x27\x9b\x5e\xe9\x6c\x13\xef\x90\x26\xbf\x93\xf9\xdf\xb4\xf1\x54\xba\xa6\x8a\xf6\x74\x3e\xc9\xa5\x2b\xf8\xdd\xa4\xd1\x77\x78\xcf\x7c\xe6\x68\x68\x50\x8a\xdd\x62\x9d\xa5\xac\x68\x9d\x0a\x86\x09\xc6\x8d\xb4\x19\xbd\xb4\x8a\xbf\x5a\x9d\x56\x05\x82\xe2\x1c\xdf\x31\x56\x4f\x46\x03\xac\x35\xa5\x52\xbd\xf5\x06\x9b\xbb\x1f\x42\x74\xaf\xfe\xac\x4a\xf4\xfa\x90\x9c\xf3\x7b\xcb\xff\x89\x4d\x7f\x12\x0f\x3a\xab\x68\x7b\x5a\x5e\xc5\xd2\x6a\x5e\xad\x62\x3f\x33\xf9\xff\x60\xd3\x55\xd3\x16\x9d\x5e\x45\xcf\x73\x3e\xaa\xa2\xd3\x21\x8d\x84\x3a\xb1\x62\x08\xdd\x09\xc3\x5b\x28\xe9\x90\x14\x26\x0c\xe3\x8d\x50\x1a\x9a\x64\x86\x0c\x0b\x0d\x72\x5f\x90\x64\x59\xdb\x7b\x67\x79\x94\x88\xd6\xbb\xf4\xe8\x82\xff\xc0\xe2\xce\x09\x49\x71\xaf\xc4\xa9\x7f\x13\xf8\x1a\xad\xf5\xa7\xb9\xf0\xdf\xa7\xdd\xfc\xbf\x1b\xc1\xdf\xd4\xb5\x90\x86\xbb\xa8\x0d\x73\x1e\xd4\x56\x51\x8f\x1e\xa3\x7e\x77\xda\xc3\xfd\xb4\x88\x1a\x86\x94\x41\x84\xbb\xef\x92\x8e\xdc\x30\x4d\x77\x7f\x06\x50\xff\x5d\x77\xfc\xb9\x84\xfa\x09\x80\x96\x10\xa3\xb3\x67\xf4\x4d\xe9\x9a\x33\xb2\x1d\x2b\x6f\x27\xc7\xbb\xdf\xf1\xdf\x72\xeb\xad\x4d\xd9\x75\x1f\xb7\xfe\xad\x5d\x3e\x84\x5a\x61\xd4\xb5\x9b\xa9\x5d\xb6\x59\xff\xc1\x79\xc4\x6f\xd7\xfd\x5d\x45\x9d\xdd\x5b\x35\x1f\x4d\x06\xbb\x51\xa4\x3d\xf1\x24\xb5\x69\xdb\xaa\x55\x4b\xd3\xec\xd0\x52\x0b\x49\x0a\x6e\x36\x2c\x24\x24\xbc\x55\x6c\x5b\xda\x36\xdc\x24\x6e\xca\xb7\xa8\x9f\x54\xf4\xb6\xb6\x28\x1f\xfe\xd0\x9b\xfa\x8e\x7e\x37\xe5\x77\x42\xfd\x77\xf4\x3b\x55\x4e\xa9\xff\x8e\x7e\xbc\x73\x8f\xfb\x73\x8f\x1f\x35\x9f\xfa\x9a\xfe\xfc\x7c\xf5\x35\xfd\x8f\xeb\x7f\xeb\xf1\x38\xc4\x33\x41\x8f\x26\x2d\x49\x0c\x8c\x93\x83\x93\xda\xb7\xe9\xd4\xa9\x77\xb7\x6e\x91\xa6\xd9\x37\xaa\x73\xe7\xf6\x91\x5a\x70\x70\xf3\x9e\xed\x49\xfb\x5b\x32\x9b\xfb\x83\x72\xeb\xac\xd6\xbe\xdb\xa2\xa6\x57\x18\x99\xd5\x20\xb8\xf8\x33\xb1\xf5\x38\xc7\x0f\x2d\x0a\x20\x5a\x0f\x44\x0b\x11\x3e\xd7\x27\xa3\x2e\xd8\xa2\xb3\x7e\x78\xe1\x0f\xfb\x63\x7f\xd4\x27\x9a\xfa\xdd\x0c\x73\x36\x6a\xcf\xd0\xc9\x6a\xbd\xa1\x70\xd2\x2d\xa9\x79\x88\x5a\x97\xa6\x05\x91\x21\x49\x21\xcd\xae\x9d\x56\xf7\xf3\xe6\x33\x3f\x9a\x81\x96\x0a\x88\xa4\x55\x82\xbb\x0e\xe3\xb6\xd8\xb4\xf4\xbe\xb1\xa9\xc9\xdd\xe4\xeb\x30\x19\x71\x56\xc9\x81\xa9\xfd\xfa\xa5\x24\xc7\xf5\x4b\xad\x8a\xa1\xcd\xba\x39\xa7\xc1\xcf\x47\xda\x25\x74\x20\xf8\x31\x48\x24\xe9\x97\xd4\xa6\x45\x48\x08\x21\x42\xb4\x34\xc3\x92\x9a\x85\x0f\x0b\x73\x7b\x76\x18\x71\x3f\xf1\x72\xfb\x76\xb8\xb5\xad\x77\x6f\x4f\xe0\x0f\x3e\xea\x7e\xf3\xa2\x07\xfe\x10\x66\xa0\xff\xe7\x2e\x23\x3f\xf8\xfd\x38\x06\x20\x7d\xfe\x1f\xb9\xd8\x75\xfe\xd5\x6f\x83\x9c\x27\xa0\x3f\x26\xaa\x3a\xba\xef\x0f\xf5\x26\x45\xf8\x7f\x17\xd4\xb6\x6d\xeb\xd6\xed\x49\x48\x48\x8b\x16\xb2\xb5\x54\x1d\xb3\x4d\xeb\xba\x8e\x59\xd7\x3c\x2d\xce\xb4\x4f\xd3\x6d\xa1\x43\x8f\x3d\xeb\x57\x42\x5f\xa8\xbe\x3b\xab\x71\xc6\x77\xaa\x7e\x4c\x6b\xdd\x85\x9c\xbb\xf0\x27\x49\x18\x19\x99\xd4\x5d\x87\x9b\x9b\x87\x85\xb8\x8b\xa7\x72\xde\x3c\x3c\x4c\x93\xda\x98\xcc\x10\x29\x79\x50\x90\x31\x3a\x33\xa8\xf1\x2f\xb2\xd4\x5a\x83\x0d\xd6\xd6\xf6\x2f\xd0\x86\x4b\x13\x47\xe0\x7a\xda\xdc\xd2\xbb\xd0\x8b\xdc\xdf\x6a\x5d\x78\x53\xf8\xcd\x03\xdc\xdf\x6b\x5d\x78\x55\x8b\xab\xa6\xb6\x4e\xa1\x0f\x14\xd0\xa1\xad\x53\x9c\x99\x05\xb8\xae\xc9\x77\xe2\x6a\xf9\x59\x8b\xee\x3c\xc7\x5d\xe3\x43\xbf\x9f\x0e\xa7\x76\x73\x9d\xad\x24\x9f\xd7\x1e\xc2\xe3\x2b\x03\x8e\xaf\xa1\x57\x9e\x75\x3c\xf0\xfa\xb5\x34\xe6\x2f\x8f\xaf\xa3\xe3\xcf\x3e\xae\x5f\x58\x77\x9c\xdd\x01\xfb\xdf\x6a\xae\xab\x38\x1e\xac\xf3\xdf\xc4\x71\x37\x8e\x07\xff\xe2\x7a\x37\x8e\xbf\x3a\xee\xc6\xe1\x1e\x8f\xaf\xfd\x9e\xed\x51\xf1\xcd\x83\xe3\xdd\xd9\xca\xe7\x0e\xb9\xde\x89\xe9\x7e\x47\xc1\x7f\x9c\x67\x9c\x75\x7c\x0d\x49\x3a\x73\xbc\x89\xeb\xd7\x36\xb8\xbe\xcf\x59\xc7\xd7\x91\x0e\x78\x7c\x34\x5c\xff\x83\x1e\x5f\x7f\xfc\x8e\xe7\x54\xed\x49\x67\x7a\x43\xdd\x71\x3e\xe9\xac\xe3\x6b\xc8\xd8\x33\xc7\xd9\x67\x67\x1d\x5f\x4b\xc2\x02\xae\xef\x7f\xd6\xf1\x75\xa4\x27\x1e\x4f\x87\xe3\x2f\xab\xf8\x16\xfa\xdb\x9f\x1c\xc7\xf6\xb9\x55\xb5\x0f\x1c\x17\x66\xc0\xf1\x35\x94\x37\x3e\xce\x9f\x09\x38\xbe\x96\x7c\x76\xd6\xf1\xda\x80\xe3\xeb\xce\xb6\xcf\x5f\x51\xed\xb3\x10\xdb\xe7\x56\x7f\xfb\x93\x9f\x54\xfb\xb8\xfe\xdb\x36\x71\x7c\x0d\x8d\xac\x3b\xce\x9f\x69\xe2\xf8\x5a\xf2\x4d\xfd\xf5\x41\x4d\x1c\x5f\x47\xfe\x50\xc7\x55\xfe\xe5\xae\xba\xfc\x90\xb9\xcf\x3d\x1d\xae\x9b\x9b\xe8\x2b\xb5\x4f\x93\xde\x49\xed\x05\x5f\xd7\x9b\x2e\xef\x4d\x93\x7a\xd3\xe8\xde\xb4\x77\x92\x19\x3e\xac\x37\xa3\x11\x49\xcd\x22\x86\x45\x90\xf0\xde\x5e\x6f\x78\x6f\xf7\x05\x0f\x5e\x2f\x39\xa7\xad\xcd\xff\xd8\xd6\x41\xf9\x66\x43\x5b\x41\x94\xbe\x42\x7e\x71\x57\x71\x09\xbc\x8c\x9c\xfb\x7c\x72\xce\xf3\xdd\xbc\xed\x50\xb1\xaa\xbc\x90\xb9\x90\x17\x55\x73\x76\x77\x7d\xb4\x5e\xba\xdc\x4b\x93\xbc\x34\xda\x4b\xbd\x6e\xb4\x5e\x46\x3b\xb8\x66\x3a\x34\x8c\xf6\x2f\xed\x6d\xfe\x1f\xec\x6d\x51\xf5\x69\x60\x2f\x88\xb2\xbb\xb1\x46\x01\x97\xfe\xc5\xf9\xe4\x1c\xe7\xc3\xdd\xc7\xa3\xf5\x9e\x2d\xba\xbb\x4f\xd6\xc2\x75\xb2\x80\x0c\xa2\xb7\x93\x56\x49\xa1\xec\xbe\x28\x7a\x43\x14\x8d\xa2\x2b\x42\x68\x08\x09\xcf\xf2\xba\x0b\xe5\x28\x9d\x5c\xfb\x93\x93\xa6\x6d\xd7\x86\x92\xee\xee\xba\xdd\xed\x9a\x87\x87\xb7\x62\x51\x66\x48\x48\xd7\x98\xa8\x98\x1e\x3d\x9b\xb7\x6b\xd7\xac\x63\xb3\xec\xcc\x8e\xa2\x4d\xab\x99\x99\x6d\x78\x78\x54\x64\xd4\xcc\xcc\xc8\x16\x44\x9f\x95\xc9\x41\xb0\xf8\x97\x8c\x3d\xb3\x62\x0c\xd2\x4c\x8b\x80\x25\xf7\x2d\xf5\x60\x8b\x76\xee\x11\xe1\x7f\xb1\x8f\x7f\xcd\x6e\xfd\xcc\x72\xa5\x3a\xbe\xb6\x45\xe7\xcd\x28\xef\x7f\xcb\xa4\x7e\x99\x5a\x97\x21\x8b\xba\xbc\xdc\xe2\xa9\x5b\x3e\xdf\xb0\x36\xb8\x66\x71\xe8\xba\xf7\x1e\x0e\xa5\x6f\x19\x57\xec\x2f\xdc\xf0\x62\xcb\x7b\x7a\x1e\x76\xd2\x3a\xd2\x16\x0f\xc5\x6c\x11\xdd\x66\x75\x7d\xa4\xa0\x3a\xa8\xdd\x70\xff\xf2\xe4\x4b\xd2\x92\xae\xbc\x29\xe6\xca\xea\x65\x07\x0f\xfa\xeb\xf6\x83\x93\x21\x05\xe8\xcd\x18\x92\x93\xe4\x69\x19\x13\x19\xe9\xae\xe5\x1d\x1d\xd5\xaa\x55\x87\xe0\xf6\x5a\xfb\x2e\x9d\x5b\xc6\xc4\xb4\xed\xa4\x91\x0e\x9d\x3a\xcc\xcc\x8c\x62\x9d\x78\xab\xf6\x6d\xdb\xcf\xcc\x6c\xdb\xc2\x08\x9f\x99\x19\x62\xb4\xc7\xa5\x87\x71\xf5\x66\x5c\xcd\xbb\x4e\xf5\x26\x86\xd7\x2d\x05\x62\xd5\xad\x6a\xea\x5f\x7b\x95\x01\x93\xba\x95\x55\x4b\x75\x0c\xa1\x67\xd6\x3a\x8d\xa1\xe2\xbd\x75\xa1\x74\x7f\xe8\xd3\xc7\x92\x9c\x7f\x9d\x7f\x79\xc7\xbe\x23\x8c\xb0\xd4\xce\xc5\xd7\x45\x44\xd5\x7c\xfb\xdc\xba\x10\xa7\x8b\x5a\xde\x9b\x3e\x4d\x9f\x11\x9f\xb9\x6b\xfc\xfe\xb1\xdd\xb9\x37\x22\x88\x8a\xdb\x43\x5b\x2c\x9a\x77\x89\x18\x5e\x1d\x52\xb7\x6a\x6b\xf5\x65\x4a\xf7\x3f\x5a\xfb\xbd\x6a\xbb\x1e\x64\x56\x52\x5c\x98\xd0\xb4\xf6\xc1\x41\x20\x8b\x5b\x45\x06\x45\xf6\xec\xa5\x05\x19\x41\x33\x33\x0d\xa3\x6d\x68\xdb\x98\x99\x99\x1d\xda\x46\x88\xb0\x30\x16\xce\xb2\x33\xc3\x85\xff\x85\x10\x24\xa0\xc9\xd4\x62\xe5\x4d\xbf\x33\x01\x1b\xb0\x51\xa3\xd5\xad\xc3\xce\x48\x4c\x5d\xd3\x5e\x40\xa1\x71\xc5\xc3\x2f\xdc\xf7\xde\x85\x8f\x04\xd7\x7c\x18\x3c\x7b\x96\x6a\xb6\x13\x9f\xbe\xf6\x54\xf0\xb0\x04\xe7\x51\xe7\x85\x9d\xd7\x9f\x3f\x34\x74\xe6\x65\x97\x3f\x31\x27\x3a\xdd\x10\xfc\x8d\x02\x27\xab\x4d\x72\x72\x1b\xd6\x19\xda\xee\x8a\xeb\xae\xed\x93\xe2\xcc\x71\x3e\x74\x4e\xf7\xa4\xe1\xb7\x27\x4e\x7b\xfd\x45\xba\xb2\xaf\x5f\xcf\xed\x24\xe9\xa4\x9a\x5f\xa1\xde\x21\x17\xfd\x42\x08\x89\x90\xb2\x4d\x58\xd0\x2b\x34\x19\x54\xaa\xa0\xa9\xee\xe2\xbf\xf8\xd3\x55\x0f\x88\x9a\x48\x26\xdd\xb7\x1c\xb6\x80\x10\xfd\x0b\x9f\xb0\x96\xee\xe2\x6a\x2d\xaa\x27\xdf\x52\xba\x63\xf2\xea\x92\x5d\x77\x77\xec\xee\x49\xef\x9f\x1a\x9f\x16\xcf\x56\x56\x39\x7b\x6e\x72\xae\xa7\x9d\x6f\x3c\x3e\x76\xfc\x15\xce\xb6\xb1\xf7\x5d\x4f\x63\x55\xdf\x09\x21\xe3\xc9\x01\xbe\x9c\x04\x91\xd8\xa4\xd0\x20\x98\xf0\x49\xf7\xa5\xa4\x3a\x97\xe6\x8b\x34\xf9\x19\x90\x75\x20\xfb\x53\xc0\xb3\xfb\x9e\x01\xf7\x21\x70\xdd\x62\x30\x71\xfd\x12\xfc\x59\xd2\x41\x84\x4f\xfe\x57\x88\x93\x10\x72\x5d\xde\x4d\xc1\x7f\x4e\x7d\xb0\x59\x6a\x6a\x33\x36\xa8\x57\xca\x55\xae\x7d\x67\x2f\x19\x4f\xe3\xf9\x65\x50\xa3\x5e\x49\x21\xad\x65\x44\x44\xab\x50\x4a\xdb\x84\x9a\xcd\xdd\x6a\xb5\x22\x54\x19\x77\x57\x63\xa6\x67\x1a\x21\x21\x26\xe1\x02\xe6\xb5\xd5\x42\x76\x5d\x12\xfc\x4d\xd0\x8c\xea\x31\xbb\x1d\x16\xf9\xe8\xdd\x63\xfb\xf4\xf1\x9e\xd7\xf7\x82\x98\x05\x17\x2d\x58\x3e\xfa\xa6\xbd\x74\xde\xf8\xb2\xcb\xef\x5b\x3d\xdc\x4e\xee\x54\xf1\x66\xbb\xfc\xc9\x17\x5e\x79\xc5\x8d\xe0\xf7\x23\x92\x41\xfb\x80\xdf\xae\x64\x48\x52\x54\xa7\x90\x10\xd6\xbc\x43\x07\xb3\x73\xe7\x56\x8c\x75\x83\xbf\x42\x43\x5b\x45\xb4\x85\x0a\x6e\x00\xd1\xfa\xa2\x9b\x59\x8f\x07\x62\x50\x62\xac\x4e\x2c\xab\xee\xee\x2e\xff\xd7\xa3\xb3\x2b\x5f\xa1\xe1\xbd\x76\x2c\x1d\x42\xe3\x1b\x05\xa6\xab\x55\xa2\xc6\x96\xce\x6d\x97\x6c\xf6\x4e\x7a\xc6\x97\xd6\x6c\xc8\x15\xfd\x7a\xdb\xe7\xc7\x5e\xd0\xb9\x28\x73\xfe\x55\xef\x8f\x9f\xf8\x52\x46\xbb\xad\x57\xb4\x79\xad\xdc\x94\xe3\x85\xfe\x70\x9c\xb7\xdd\xc2\x8d\xed\x66\x8c\x7d\xa9\x4b\xf0\xe4\x8c\x85\x37\xab\xb9\x11\x28\x02\xc2\x17\x43\x1b\x84\x91\x01\x49\xad\x78\x68\x30\x67\xee\xcf\xb6\xf4\x10\x21\x9a\x83\xd2\x36\x20\xfc\x60\xf9\x32\x4d\x22\xcc\x4d\x97\x6a\x08\xcb\x3a\xf3\x03\x6f\xcb\xfd\xe5\x39\xa4\x4d\xef\x02\x99\x83\x09\xb9\x05\x73\x7f\x2b\x21\xfe\xba\xf6\xf7\xb7\x77\x1e\x6f\x41\xdf\xbf\x3e\x6b\x6c\xd4\x2d\xce\xa7\x07\x7a\x86\x1c\xbf\xf7\xde\xd9\xac\x67\xcd\x89\xa5\xf4\xa0\x73\xfb\xa1\x54\xc8\xd3\x7e\x32\x8c\x76\x05\xdf\x6d\x49\x62\x52\x44\x9b\xc8\x48\x23\x2a\x8c\x73\xc3\x68\x17\x19\x1e\x0e\xa3\x48\xeb\x96\x2f\xd2\xa4\x0d\xa1\xa6\x54\x49\xb2\xfc\x7d\xa0\xce\x33\xde\x39\xd0\x15\xf1\xc7\xdc\xf5\x79\x82\x7b\xc8\x5d\xe4\x1d\x6e\x1f\xb3\xf2\xf2\x97\x1f\x99\x91\xd7\x2e\xd9\xe8\x92\xf6\x68\x79\x72\xef\xd4\x61\x74\x6d\x6b\xe7\xe1\x98\x58\x96\x58\x9e\x7b\xe5\x2d\xad\x37\x2f\xec\xb0\xf5\xa6\xd6\xf4\xa1\xeb\x36\x85\xf9\xef\x81\xef\x55\xbb\xb9\xef\x8c\xeb\x42\x06\x26\xb5\x0c\x6f\xd3\x86\x77\x34\xa3\xa2\x38\xef\xda\x39\x3c\x3c\x3a\x3a\x22\xa2\x59\xb0\xee\x76\x9d\x76\xd0\xb9\xdc\x76\x73\x9b\x2d\xf6\x8c\xe6\xaf\x8f\xa9\x87\x7f\x95\xe3\xfa\x95\xd3\x25\xde\xca\x92\x47\xaa\xa5\x1c\x21\x44\xd9\xab\x6c\x71\xd1\xab\x45\xd3\x2f\xea\x3c\x48\x76\xe9\x3d\x7c\x7e\x87\x91\xc3\x67\xe4\xad\xd9\x3a\xc9\x3b\x60\x7a\xf7\x01\x66\xc6\xcd\x57\xdf\x50\xb3\xba\xdd\xeb\x0b\x3a\xdc\x75\x75\x8f\xa2\x19\xd7\x3c\x4c\xf5\x8d\x17\xcf\xba\xbc\x15\xae\xcf\xdf\x9b\x4c\xa0\x77\x42\xde\x0c\x98\x79\x99\xee\x07\x8f\x54\x4a\x37\x4d\x29\x1b\x0c\x77\x01\xc0\x24\x95\xad\x80\xa5\x37\x39\xb4\x8d\x4e\xbb\xd0\x98\x4b\x93\x7b\x31\x3b\xc8\xb9\x70\x3d\xdd\xe7\x3c\xc8\x56\xfc\x9e\x52\xd3\x81\xdd\xe6\x9f\xeb\xec\xc3\x3e\xdb\x92\x44\x93\xf3\xc8\xc4\xa4\x6e\x4c\x8b\x8a\x0a\x6d\xde\xbd\x79\x50\x77\x0d\xea\xab\x69\x31\x41\x41\xbd\x59\x68\x68\xcf\x9e\x33\x5b\xfb\x5a\x2f\x6f\xcd\x5b\xb7\xd6\x3b\x46\xb8\xd9\xe8\x4a\x74\x1c\x1f\xa0\x7d\xb2\xfc\x1f\x32\xd0\xba\x64\xf8\x3f\x0e\x74\x3f\x64\x57\xcb\x82\xbb\x1d\x16\xd7\x4c\x4a\xa8\x7b\xa7\x98\xe6\x4f\x8a\x9b\x27\x1e\x89\x4d\x28\x69\x9f\xfb\xe3\x2f\x70\xde\xf7\xad\xc8\x9f\xd2\xdb\xbe\xfe\xda\xb9\x3e\x67\x6d\x92\x3d\x28\xba\x9b\x37\x7e\x66\x9f\x7e\x57\x4d\x4f\x4b\x65\x7b\x9f\xec\x1b\x31\x7e\xb0\xf3\x63\xd1\xcc\x9c\x8a\x88\x16\x99\xf1\x73\x2f\x9e\xb9\x76\x82\x6f\xea\xf9\xdd\xe6\x38\xd1\xf1\xfd\xf6\x17\x2e\xf1\xb7\xe9\x61\xa8\x57\x4f\xbe\x42\xbd\x19\x33\x31\x29\xd2\x6d\x53\xde\x09\x1a\xb5\x5b\x97\xf0\xf0\x98\x18\x68\xd2\x20\x68\xd2\x54\x77\xb9\x4c\xa8\xca\x59\x4d\xda\xa0\x97\xa9\x37\x98\xf8\xbb\x59\x7c\x02\x2e\x6a\x1b\x81\xcb\x3e\xa9\x17\xff\x95\x5e\x5e\xf8\x52\x51\xce\x38\x68\xd2\x9e\x71\xc3\x4a\xda\x0d\x1f\x31\xbd\xe8\x9e\x9d\xb1\xbd\xe2\x2e\x98\xd2\x37\xd1\xe0\x2b\xee\xbe\xec\xe6\xdf\x57\xb5\x7d\x7d\x41\xfb\x5b\xaa\x3a\x97\xe6\x2d\x7f\xc8\x39\x94\x5b\x71\x71\xce\xa5\x51\x03\xdc\x36\xdd\x22\x05\x3b\x22\xdd\x77\x6f\xb7\x4c\x32\x61\x68\x12\x94\xad\xce\xa4\xa4\x7e\x71\x30\xf7\xb9\x0f\x3b\xe2\xfe\xaa\x51\x8a\xb1\xa0\x43\x7a\xd3\x95\x6c\x16\x4b\x6c\x21\xd5\x3a\x60\xb4\xb6\x5c\xcc\x24\x2f\x6a\x57\x90\x16\x24\x3e\x29\xba\x99\xe6\xae\x1a\x18\x61\x04\x07\x37\x57\x0b\x13\xb0\xe5\x41\xab\x82\x58\x58\x50\xa7\xa0\x75\x41\x3b\x82\x44\x90\xbb\x5e\xee\x96\x2c\x4f\x40\x4b\x41\x27\xc1\x3e\x0a\xa3\x8b\x1a\x68\xa0\x93\x5e\x37\x6c\xe2\x45\x93\x73\x72\x9a\xa7\x18\x3d\x32\x07\x0f\xb1\x34\x5f\xcb\xfe\x56\xe2\x30\x23\x6e\x86\x1e\x36\xc0\xf2\xdf\x33\xb5\xaf\xc2\x74\x7c\x82\x36\x8c\x68\xd0\x1b\xfb\x27\xb5\x14\xfe\x9f\x91\x6a\x41\xa6\xee\xae\x14\xeb\x7e\xd9\x93\xea\x2f\xd2\xa8\xa7\xfd\x75\x01\x76\x6f\x1d\x1b\xf0\xa2\x98\x16\x75\x9f\x0f\xba\x0b\xe1\x9a\x34\x46\xa4\xfd\xb9\x28\x8c\xfd\xf9\xfa\x87\x4e\x52\xcd\x47\xec\xd9\xb1\xe2\xb7\x3f\x0d\xbe\xa7\x7a\xbc\xbf\x2d\xd7\x8b\x99\xb4\x56\xdb\x0a\xbe\x9a\x91\xa4\xa4\x6e\xa6\x11\x1a\x1a\x14\x24\xa0\xf3\x87\x85\x1a\x86\xa0\xee\x1b\x4c\xa9\x5c\x1e\xb2\x2a\x84\x85\x85\x74\x0a\x59\x17\xb2\x23\x44\x84\xa8\xa5\x81\xb7\xf4\xf6\xd4\x2d\x93\xe1\xa9\x7f\xb9\x81\xe5\x8e\xa3\x5a\x42\x37\xcb\xbd\x4b\x35\x3a\xe5\x11\xf1\x43\x0a\xad\x39\x24\x69\xf8\x6d\xcf\xcb\xd8\xcf\x9c\xef\xb4\xad\x51\xeb\x83\xd6\xc7\xd4\xd4\xc4\x3c\xf0\x80\xf2\x7f\x01\xf8\x6f\x89\xfe\x53\x92\xba\x87\x00\x57\x99\x66\x68\x28\xcc\xbf\xc3\xf4\xe0\x60\xa6\xb9\x01\x68\xe6\x72\xb9\x4a\xb2\x30\xd9\x49\xae\x93\x3b\xa4\x90\x8d\x03\xb0\xce\xac\xfe\xab\xbb\x0f\x27\x68\x0f\xad\x8b\x0a\xe2\x43\x9a\xb2\x4e\x3c\x42\x7f\x01\xcf\x43\x24\x6d\x7e\xdb\x0b\x52\x0b\x0b\x5a\x1f\xe5\xac\x7e\xe0\x01\x37\x06\xac\xff\xab\xda\x36\xc8\x74\x7b\x32\x3a\xe9\xfc\x08\xd3\x6c\xd5\xac\x19\xa9\x5b\x6c\xb8\x83\xce\x98\x6c\x1b\x11\x9c\x64\x86\x0e\x0b\x26\x4d\x45\xb1\xa7\xf7\x16\xff\x18\x1a\xf0\x84\xa2\xee\x33\xf5\xfa\x3c\x34\xea\x06\xee\xb2\x45\xce\x7a\x7f\x52\xe2\x20\x34\xba\x37\x39\x71\xc8\x90\x8b\xd2\x83\x3d\xb2\xe3\x90\xa8\xa8\xee\x1e\x31\xd3\x9f\x21\x3a\x3d\xbc\x4f\xf7\xbe\xf1\xbc\x53\x9a\x16\x7c\x7e\xb3\xc8\x66\x10\xef\x1b\x22\x99\x0e\xd7\x7e\x72\x9f\xdb\x93\xfc\xa4\xe4\x0e\x2d\x5a\xd4\x07\xdb\xc9\x6c\xb3\x3a\xb3\x85\x69\xb2\xf6\x91\x91\xcd\x56\x67\x86\x45\x76\x8a\x8c\x8d\xe4\x91\x3a\x23\x61\x32\x56\xba\xc1\xdf\x0b\xd5\x87\xf0\x87\xc8\x99\xaa\x0a\xc7\xa5\xee\xaf\xc4\x76\xcf\x96\xac\xfa\xe7\x61\xbd\x1b\x56\x05\xea\x01\x8a\xc0\xad\x87\xde\x4d\x3d\x17\x83\x5a\x04\x3c\x17\x73\xde\xd0\xbe\x78\xf3\x76\xad\xdf\x07\xbf\xd3\xa5\xbd\x53\x07\xc4\x77\xcc\x68\x15\x1a\x1b\x7b\xdf\x79\x69\x03\x13\x3a\xf4\x8c\x6b\x1e\xdb\x57\x24\xc7\x6c\xdc\x18\xb3\x74\xe9\x89\x4e\xdd\x3b\x25\x74\x5a\x0f\xd8\x35\x6e\x9d\xbf\xef\x1d\x11\x23\xa0\xa5\xdc\xb6\x6f\x49\x2e\x4a\xb2\xa9\x10\x11\x90\xff\xa8\x16\xc1\xc1\x61\x54\x86\xdd\x9c\x29\xee\xa5\x94\xba\xa9\xa7\x67\x55\xc0\x1f\xbe\x54\xe1\xef\xe9\x9d\xb5\x3d\xe0\xcd\x0f\xf5\x4f\x47\x55\x67\x54\x0b\xa4\x24\x58\x4a\xd5\x26\x58\xcd\xe8\xe0\x47\xc4\xf7\x29\x2c\x61\xd1\xb5\xda\x30\x2d\x7f\xe2\xf8\x8b\xdb\x5e\xd8\xea\x61\xd5\x29\xb7\xcc\xcb\x8c\x6a\x33\x60\xc8\x05\x03\x2b\x96\x37\x11\x1b\xf4\xc7\xfa\xd8\x34\x37\x36\x76\xaf\x46\x35\x37\x36\xed\x1f\xc5\xa6\xba\x29\x6f\x14\xdb\x28\x96\xb2\x56\x3c\xdc\xb6\x61\x6c\xaa\xbf\xae\x08\x08\xae\x2e\xb6\x6d\x30\x2e\x75\x26\x93\x93\xe2\x61\x58\x82\xc1\x29\x3a\xda\x88\x8a\xea\xd2\xa9\x75\xeb\xf6\x2c\xa2\xfd\xcd\x99\xcd\x4d\xe6\x46\xc7\xc2\x22\x62\x23\x96\x47\xac\x8a\xb8\x37\x42\x0b\x8b\xe8\x14\x31\x24\x62\x5d\xc4\x8e\x88\xe3\x11\x32\xc2\x1f\xdd\x16\xab\x41\x74\x67\x9e\xb1\x35\x31\x74\x45\x34\x0a\x77\xdc\xe0\xb8\x01\x03\x86\x27\x19\x7d\xf5\x76\xf1\x5d\x3b\x59\xfd\x1b\xc6\xfd\x4a\x78\xf7\xe8\xde\x1e\xb7\xeb\x06\x45\xb7\x0f\x73\x1a\xa4\x17\xea\xf0\xb5\x18\x49\x87\x41\x3f\x6e\x09\xba\x20\x2f\x29\xb9\x73\x9b\x36\x91\xa6\xd9\x95\x34\x5f\x9d\x69\x04\x13\x12\x1c\xd3\x36\xa2\x6d\x44\xc7\xe0\xa8\x8e\x37\x67\x06\x6b\xab\x33\x83\xdd\x27\x93\xc1\xee\x93\xc9\xe0\xb0\xa8\xe5\x51\xab\xa2\xee\x8d\x12\x61\x51\x9d\xa2\x86\x44\xad\x8b\xda\x11\x75\x3c\x4a\x46\xa9\xe1\xd7\x5d\xb1\xae\xee\x45\x03\x5b\xc2\xdd\x2f\x78\x04\xbe\x1b\xa0\x89\xde\xab\xa9\x45\x8c\xb1\x46\x72\xf1\x99\x0e\x7c\xff\x79\x69\x03\xb0\x03\x3b\x1f\x94\x5f\xce\xe3\xf5\x82\x89\x93\x16\x47\xc5\x9f\xaf\x79\x02\xfb\xf1\x37\x33\xc6\x76\x89\xb5\xec\xbe\x3b\xd5\x7a\xa6\x2f\x35\x58\x2f\xb6\xbb\x38\x71\x99\x7f\x95\xd5\x5b\x6b\xb7\x34\x71\x5c\xba\xc7\x9b\x5c\x97\xf6\x27\x98\xd3\x85\x34\xb1\xff\x28\x1b\xcc\x7e\x54\xfb\x87\xb8\xeb\xa3\xb6\xe8\x6e\xfc\xa2\xf6\x1f\x63\xf3\xd1\xce\xe8\x06\xfb\x7f\x64\x57\xe2\xfe\x35\x0d\xf6\xff\xc0\xae\x26\x21\x67\xaf\x93\xdc\xf4\x9a\xc0\x44\xd6\xac\x70\x92\xe8\xa0\xda\x1f\xf1\xbd\xce\xb1\x64\x20\x19\x02\xb3\x8b\xd6\xdc\x34\x07\xf5\x68\xde\x87\xae\xef\xf3\x66\x1f\xd6\x27\xa6\x5d\x3b\xab\x65\x58\xd8\xe0\x44\x4b\xad\x4b\xe9\x97\x29\xdb\xb2\xe6\x7b\x3c\x9e\x58\x35\x11\x3b\xb3\x46\x10\x0f\x28\x77\x0b\x28\x07\xae\x23\x14\x11\x50\xa6\x11\x16\xaf\xf9\x6c\x40\xf7\x1e\x89\xfd\x7b\xf6\xec\x3f\xb5\x7f\x4f\x7f\x81\x1a\xf5\xa5\xb7\xea\x4a\xb1\x75\x67\x39\xc7\x32\x56\xa5\x3b\x4f\xf6\x4a\xe8\xdf\xb3\xeb\x80\x01\x54\xeb\xd5\xbf\x7f\x2f\x28\x74\xc5\xed\x56\xdc\xd2\x48\x3c\xc3\xf9\x9a\xde\xe0\x94\xba\xe3\x92\xa8\x79\x03\xea\xdb\x05\xea\xeb\x5f\x43\xab\x13\x89\x49\x0a\xe7\x84\xb4\xd7\x9b\x87\xd2\xf5\xa1\x6f\x86\xb2\xd0\x0e\x6d\x22\xdc\x4a\x6e\x71\x6b\x97\xe8\xd6\x4e\x03\x71\xfc\x97\xd1\x7f\x42\x33\xda\x38\x2f\xb3\xca\xa6\xe3\xf4\xae\x5c\xf3\x57\xf1\xbc\x80\xf1\xe8\x24\x02\xa2\xe9\x42\x3a\x25\x35\xa7\x34\x3a\xb8\x79\x38\x5d\x1f\xfe\x66\x38\x0b\x8f\xe9\xd0\x2a\x20\x1c\x97\x78\x5c\x71\xda\x45\xff\xab\x88\x1c\xb3\xe5\x9c\x36\x74\x52\x9b\xd9\x91\xf4\xee\x73\x24\x6f\x6b\xe5\xca\x95\x95\x7d\xce\x19\x18\x23\x2d\x6b\x0f\xf2\x63\xda\xbf\xc9\xf9\xee\xdb\x7c\xa9\x5a\x06\x5d\x97\x1d\x59\xab\x8e\x5c\x6f\xc6\xbb\xc0\xed\x96\x70\x01\x4f\xe8\xcb\x01\xdd\xd7\xdc\x52\xe9\x4e\xb6\x59\x42\x7c\xf7\x1e\xcd\x38\xbf\x3d\x22\xa9\xcf\x90\xf1\x21\x41\x51\x9e\xa1\x3d\x63\x53\xbb\x8a\xf0\x56\x85\xab\x9f\xcf\xcd\xb9\x63\x56\x4c\xab\xf0\x8b\x4a\xaf\x1e\xda\xf2\xbc\x76\x46\x50\x48\xda\xbc\x1b\xa7\x8d\xb8\x3a\xa4\xe6\xc2\xae\x03\x47\xf5\x18\x36\x28\x2e\xac\x4d\xfc\xec\xf6\x03\x13\xfb\x69\x21\xe1\xed\x86\xf5\xef\x33\x7a\xc4\xa8\xde\x9e\x9c\x92\x15\x63\x7c\x8f\x95\x0f\xec\x5f\xbc\xa6\x70\x42\xd5\xbc\x8b\x3a\xb4\x49\x1f\x3b\x35\x76\xd0\x9c\x11\xbd\x93\x43\xaa\x2f\x78\x62\xcd\x79\x63\xca\x86\x55\xbc\x3d\x31\x32\x75\xe6\x42\xf5\xee\xa9\xa3\xf2\x6e\xad\x25\xb4\x6d\x1f\x50\x73\xae\x86\x8f\xf4\x3f\x02\x50\x6f\xa2\x51\x12\xb4\x47\x9d\x0e\x75\x9f\xdd\x2b\x1d\x1a\xef\x1e\x96\x87\xdb\x6a\xf7\xb4\xad\xe9\x32\xad\x57\xce\x2c\x63\x0e\x0d\x5a\x5d\x1c\xea\xdc\xd3\xf6\x8e\x83\x33\x4b\xf5\x5b\x3f\xcf\x2b\x0b\xcd\xa9\x08\xa5\x97\xe5\x47\x4d\x4b\x5d\xd3\x22\x9f\x86\xe4\x47\x89\xe5\xb7\xde\x5a\x9d\x99\x9d\x71\xf9\x79\x2c\xa5\x7a\x5d\x9b\x94\x75\xef\x64\x4f\x7c\xbe\x38\x3f\x34\x8b\xf5\x69\x9d\x52\xf3\x6e\x79\xaf\xec\xc7\x86\xb3\x54\x28\x10\xff\x3b\xb1\x8e\x8a\x4c\x15\x57\x87\x33\x71\xc5\x07\x86\x55\x1f\xd1\xe1\xb6\x7c\x6a\xdb\x9a\x4e\xd3\x92\xee\xeb\x32\x17\xc3\x30\xee\x3c\x70\x26\x02\x74\xbc\x6a\x22\xbb\xc8\xf5\xbb\xfe\xdd\xe2\xfc\x88\xe9\xac\xa7\x72\x4a\xfc\x9f\x32\x93\x88\xcf\x09\xe5\xa3\xe0\xb6\x37\xf5\x0f\xc0\x67\xd7\xda\x67\x01\x07\xd4\xee\x03\x1c\xe4\x22\x1f\xe8\xee\xe1\xc9\xaa\x9c\xa6\xca\x43\x15\x8e\x56\x38\x59\xed\xcf\x02\x8c\x24\x91\xb5\xab\x60\x1e\xc0\x15\x26\x28\x4c\xac\x2d\x00\x1c\x50\x9b\x06\x38\x48\xed\xc9\x54\x7b\xa6\x2a\x9c\xee\xa2\xfe\x35\x60\x2f\xb8\x6a\x1f\x60\x98\xf3\x1b\x60\xb8\xc2\xae\x70\x55\x2c\xec\x7f\x16\x30\x01\x8e\xc6\x82\x35\xb7\x3c\x40\xe1\x20\x85\xd3\x5d\x04\x0b\xab\x88\xa5\xce\xb4\x94\x05\x4b\x59\xb0\xc0\x42\x01\xf1\xc2\x55\xfb\x00\x07\x28\x1c\xa4\x70\x3a\x60\x02\x09\x03\xfb\x09\xa4\xb9\xc2\x70\x85\x1d\xe0\xfc\x04\xd2\x51\x61\x57\xb0\x99\x40\x3c\xea\xcc\x34\x75\x34\x43\xe1\x30\x85\x23\xc1\x57\x02\x19\xa7\xca\x13\x55\x79\x92\x2a\x4f\x51\xe5\xa9\x0a\xdd\xd8\x12\x55\xbd\x12\x55\x54\x89\xe0\x6b\x15\x60\xb8\x2a\xbb\xbe\x12\x95\xaf\x44\x15\x67\x22\x78\xe9\x00\x38\x4c\xe1\x48\x75\xe6\x38\x55\x9e\xa8\xca\x53\x14\xba\x19\x1b\xa0\x6c\x0e\x80\xf8\xdd\x72\x73\xf0\x32\x00\xe2\x77\xcb\x1d\xe0\x9c\x01\x60\xd3\xc5\xae\x6a\x4f\x9a\xc2\x61\x0a\x47\xaa\x33\xc7\xa9\xf2\x44\x85\x53\xd4\x99\xd3\x01\x07\xa9\xec\x0d\x52\x39\x19\xa4\x72\x32\x48\xd9\x1c\x04\x36\xdd\x72\x47\x85\x5d\xd5\x9e\x34\x55\x76\xe3\x1c\xa4\xe2\x1c\xa4\xe2\x1c\x44\xc6\xab\xa3\x13\x54\x79\x8a\x3a\x27\x13\x70\x38\x19\x0e\xd1\x0e\xd7\xbf\x26\xf3\xc9\x44\xb0\xbf\x0a\x30\xdc\x45\xd8\x33\x92\x64\xc2\x9e\x67\x01\xc3\x01\xa7\xaa\xf2\x54\x55\x9e\xae\xca\xd3\xdd\x32\x1f\xe8\xf6\x28\x3e\x90\x8f\xa8\xdd\x0e\x38\x4e\xe1\xa4\xda\x29\x80\x93\x6b\x53\x00\xa7\xa8\x3d\x59\xaa\x9c\x57\xbb\x01\xd0\x57\x5b\x00\xb8\xb8\xf6\x55\x9e\x04\xe7\xdc\x06\x98\x05\x98\xcc\x53\xc9\x5d\x80\x90\x13\xc0\xa1\x0a\x47\x2b\x9c\x51\x9b\x01\x38\xab\x76\x2b\x60\xb6\xc2\x1c\xb5\x27\x5f\x61\xa1\xda\x33\x4f\x61\x91\xc2\x12\x85\xf3\xd5\xd1\x4a\x85\x8b\x14\x2e\x03\x4c\x01\x8f\x6b\x78\x9a\x8a\x39\x4d\xc5\x9c\xa6\x62\x4e\x53\x31\xa7\xa9\x98\xd3\x54\xcc\x69\x2a\xe6\x34\x15\x73\x9a\x8a\x39\x4d\xc5\x9c\xe6\xde\x11\x3c\xc3\x6d\x65\xc0\x30\xe7\x0f\xc0\x70\x17\x55\xfc\x19\x3c\xcd\xd9\x0e\x38\xd4\x39\x05\x38\x5a\x95\xe7\x41\x96\x86\x2a\x8f\x43\xc1\xe3\xa7\x80\xe3\x14\x4e\xaa\xad\x04\x74\x3d\x0e\x55\xbe\x46\x40\xdd\x1f\x06\x1c\x0a\x47\x47\x40\xdd\xdd\xb2\x9b\x9f\x11\x2a\x3f\xa3\xe0\xda\x87\x01\xc7\x29\x9c\x02\x31\x8c\x82\xcc\x6c\x04\xcc\x51\x98\xaf\xb0\x40\xe1\x5c\x85\xa5\x0a\xe7\x2b\xac\x54\xb8\x48\xe1\x52\x85\xcb\x14\xae\x00\x1c\xad\x62\x1b\xad\xb2\x31\x5a\x65\x63\xb4\xca\xc6\x68\x15\xdb\x68\x15\xdb\x38\x18\x67\x1e\x06\x4c\x53\xe8\x46\x38\x4e\x45\x38\x4e\x45\x38\x4e\x45\x38\xc1\xed\xa5\x80\x6e\x4e\x26\xa8\x9c\x4c\x80\x6c\x7c\x0c\x38\xb4\x36\x04\x70\x34\x94\x27\xf2\x05\x70\xd5\x24\xe8\x3f\x19\x80\xcd\x15\x86\x2b\x84\x3b\x0e\xb0\xa3\x8b\x90\xc9\xcd\x80\x69\xb5\x33\x00\x87\xd6\xe6\x02\x8e\x80\x6c\x4f\x02\x8f\xee\x9e\x71\xaa\x3c\x45\xe1\x34\x85\x6e\x0f\x99\xc4\x67\x2a\xcc\x51\x98\xaf\x70\x8e\xc2\x42\x88\x6a\x92\x6a\x85\x49\xd0\x37\x5c\x9c\xaf\xf6\x57\x2a\x5c\xa8\xf6\x2c\x52\xe5\xc5\xaa\xbc\x44\xe1\xc5\x24\x1f\xf0\x12\x55\x5e\xa6\x8e\x2e\x87\xf2\x64\x15\xf9\x64\x15\xf9\x64\x15\xf9\x64\x88\xdc\xc5\x8e\x2e\xaa\x3e\x30\x59\xf5\xe1\xc9\x10\xf9\x4a\xc0\x11\xb5\xfb\x01\x47\xab\x3d\xe3\x54\xd9\xed\x5d\x93\x55\xcc\x93\x55\xaf\x9e\xac\x7a\xf5\x64\x15\xf9\x64\xe8\x6f\x95\x80\xf9\xaa\x5c\xa8\xf6\xcf\x53\x58\xa4\xb0\x44\xe1\x7c\x75\xb4\x52\xe1\x22\x85\x6e\x84\x53\x54\xeb\x4c\x81\x16\xa9\x04\xcc\x02\x9c\x0a\x5e\x56\x02\xe6\x28\xcc\x57\x38\x17\xda\x6e\x2a\x58\x70\xcb\x95\x0a\x17\x29\x5c\xaa\x70\x99\xc2\x15\x80\xd3\xd4\x9d\x32\x0d\xec\xac\xe1\x59\xaa\x5e\x59\xaa\x5e\x59\xaa\x5e\x59\xaa\x5e\x59\xaa\x5e\x59\xaa\x5e\x59\xaa\x5e\x59\xaa\x5e\x59\xaa\x5e\x59\xaa\x5e\x59\xaa\x5e\x59\xaa\x46\x59\xaa\x46\x59\xaa\x46\x59\xaa\x46\x59\xaa\x46\x59\xaa\x46\x59\xaa\x46\x59\xaa\x46\x59\xaa\x46\xf9\xbc\x18\xda\x37\x9f\x97\x81\xfe\xcd\x87\x9e\xe3\xe2\x62\xe8\xb1\x05\xe0\xe5\x0e\xc0\x59\xb5\xef\x00\xe6\xa8\x72\x5e\xed\xe3\x80\xf9\x0a\x0b\xd5\xfe\xb9\xaa\x3c\x4f\x95\x8b\x14\xfa\xd4\x9e\xf9\xea\xfc\x32\xc8\x43\x01\x78\x74\xcb\x0b\x6a\x27\x01\x2e\x52\xe5\xa5\x0a\x97\x29\x5c\x01\x58\x04\xbe\x3e\x05\xcc\x51\x98\xaf\xb0\x40\x61\xa9\xc2\xf9\x0a\x2b\x14\x56\x2a\x5c\xa4\x70\xa9\xc2\x65\x0a\x57\x00\x16\xf3\xd9\xb5\x07\x00\xf3\xa1\x46\xc5\x60\xe1\x47\xc0\xd2\xda\x23\x80\x15\xb5\x7b\x01\x2b\xd5\xfe\x85\xea\x9c\x4b\x14\x2e\x07\x2c\x05\xef\xdb\x01\x73\x14\xe6\x2b\x2c\x50\x58\xaa\x70\xbe\xc2\x0a\x85\x95\x0a\x17\x29\x5c\x06\x38\x5f\x65\x6f\xbe\xca\xde\x7c\x95\xbd\xf9\x2a\x7b\x65\x70\xd5\x21\x5e\xae\xca\x0b\xc0\xfe\x21\xc0\x1c\x85\xf9\x0a\xe7\x2b\xac\x50\x58\xa9\x70\x91\xc2\xa5\x0a\x97\x29\x5c\x01\xb8\x48\xd9\x5f\xa4\x2c\x2f\x52\xd6\x16\xab\x11\x69\xb1\x1a\x91\x16\xab\x11\x69\x31\x44\x7b\x00\x70\xbe\x2a\x57\xa8\x72\xa5\x2a\x2f\x52\xe5\xa5\xaa\xbc\x4c\xa1\x3b\x16\x2d\x55\xd1\x2e\x55\x36\x97\x2a\x9b\xcb\x94\x97\x65\x6a\xff\x32\xb5\x7f\x99\xda\xbf\x42\xed\x59\xa1\xf6\xac\x50\x7b\x9e\x85\x7b\x73\x39\x60\x78\x6d\x3e\x60\x07\x62\xf1\x97\x61\xac\x36\xf8\x2b\x80\x23\xf9\x46\xfe\x16\xe9\x00\xf8\x6e\xed\x61\xc0\x1d\x30\xaa\x6f\xe4\x1f\x42\x96\x36\xf2\x5d\x0a\x77\xab\x3d\x7b\xc0\xc2\x46\xbe\x17\x46\xb3\x8d\xfc\x13\x55\xfe\x02\xfa\xc0\x46\x7e\x00\xa2\xdd\xc8\x0f\x2a\xfc\x46\xe1\x71\x85\x27\x15\x9e\x02\x5e\xd8\xc8\x7f\x51\x65\xc7\x45\xf0\x18\xc7\x37\xf1\x8d\xb5\xef\x01\xbe\x45\xda\x00\xbe\x4b\x46\x02\xee\xa9\x5d\x0b\xb8\x57\xed\xff\x08\x22\xd9\x04\x5e\xdc\xf2\x3e\xe8\x9f\x9b\xc0\xd7\x21\xc0\xc3\xea\xfc\x53\xd0\x37\x36\x09\x42\x62\xf9\x66\xb0\xb3\x01\xf0\xad\xda\x9b\x01\xdf\x01\x0b\x9b\xa1\x16\x2f\x03\xee\xa8\xbd\x0f\x70\x97\xc2\xdd\x70\x57\x6e\x06\xfb\xe3\x00\xf7\xd6\x2e\x04\xfc\x08\xea\xb5\x19\xec\x5f\x09\xb8\xaf\xf6\x1e\xc0\xaf\xd4\x99\xae\xfd\xcd\xfc\x07\xf0\xbe\x99\xff\xac\xca\xa7\xc1\xef\x66\xfe\x9b\x5b\x06\x8f\x6d\xf8\x16\x95\xc9\x2d\x2a\x93\x5b\x54\x26\xb7\x40\x0c\x50\x86\x18\x5c\x7c\x97\xf4\x00\xdc\x56\x5b\x0e\xb8\x1d\xbc\x6c\x81\x48\x0e\x03\x7e\xa5\xf0\x80\xda\x73\x08\x62\xde\xc2\x0f\x43\xdb\x6d\x81\x8c\x6d\x06\x3c\x06\x77\xc1\x16\xfe\x3d\xd4\x62\x0b\x78\x5f\x0b\xf8\xa3\xda\x7f\xbc\xf6\x56\xc0\x13\x90\x81\x2d\x50\xeb\x47\x01\xab\xd5\x39\x35\x90\xf9\x2d\xbc\xb6\x76\x29\xdf\x22\x08\x9c\xff\x16\xd4\xeb\x53\xc0\x53\x10\xcf\xdb\x90\x81\x43\xfc\x1d\xf0\x7b\x33\xe0\x2e\x85\x7b\x20\x27\xef\x40\x7d\x5d\x3c\x0e\x91\xbc\x03\xd6\x20\x53\x7c\x37\xd4\xe8\x5d\x38\x7a\x18\xf0\x13\xb0\xf9\x2e\x64\xa0\x1d\xdf\xaa\xb2\xb7\x55\x65\x6f\xab\x3a\xba\x15\xec\x4f\x07\xfc\x42\x95\xbf\x81\x5a\x6c\x05\x3b\x1b\x00\x4f\xaa\xb2\x1b\xdb\x56\x68\xdf\xed\x7c\x1b\xc4\xd0\x83\x6f\x87\xf3\xb7\x03\x1e\x80\x48\xb6\xc3\xf9\x2e\x1e\x57\x78\x12\x70\x07\x64\xec\x1e\xc0\xb7\xe0\x9c\x1d\xd0\x6a\x1b\x00\xb7\xa9\xf2\x9e\xda\x6b\x00\xf7\x42\x54\x3b\xa0\x8d\xee\x00\xfc\x44\x1d\xfd\x4a\xe1\x11\xb0\xbc\x83\x9f\x06\xdc\x09\xad\x30\x12\x30\xbc\xd6\x02\x74\x5b\x61\x27\xd8\x84\x3d\x60\xd3\x0b\xf8\x0e\xe4\x6d\x27\xe4\xe1\x55\xc0\x6d\xb5\xb3\x00\xdd\xb6\xd8\xa9\xda\x62\x27\x78\xf1\x01\xba\x3d\x6d\x27\x78\x59\x0e\xf8\x55\xed\x93\x80\x07\xc0\xcb\x4e\x68\x97\xe7\x01\xbf\x51\x78\xdc\x45\xc8\xf0\x76\xbe\x4b\xf5\xb4\x5d\x7c\x1b\xc4\xb6\x4b\xe5\x64\x97\xea\xa5\xbb\x20\x42\x17\x0f\x90\x66\x80\x07\x15\x7e\xa3\xf0\x88\xc2\xa3\x0a\x8f\x2b\x3c\xa9\xf0\x67\xb8\xd7\x76\xf1\x5f\x54\xd9\x01\xdc\x0d\x75\xb9\x03\x30\x1c\x22\xd9\x0d\x75\x19\x09\xd8\x11\xbc\xec\x26\xc5\x50\xaf\xdd\xe4\x12\x17\xc1\x3b\x1c\x85\xfb\xc5\x2d\xbb\x91\xef\xe6\x5f\xb8\xd7\x42\xcc\xcf\x03\x1e\x52\xf8\x8d\xc2\x63\xb5\x3b\x00\xbf\x53\xe5\xef\x15\xfe\xa0\xf0\xb8\xc2\x9f\xd4\xd1\x13\x50\xa3\xdd\xd0\x16\xee\x9e\x53\x6a\xcf\x69\x85\x7f\x28\xac\x56\xfb\x6b\x14\xd6\xba\x08\x19\x80\xb6\x81\x38\x6f\x03\x74\xe3\xdc\xa3\x72\xbe\x07\x22\x6c\x03\xe8\x46\xb8\x47\xdd\x05\x7b\x20\xff\x6b\x01\xb7\x41\xcf\xdc\x03\xd9\x7e\x0f\x70\x2f\xf4\xc0\x3d\x90\x61\x17\x0f\x42\xae\xf6\x40\xb4\xf7\x01\x7e\x0d\xb5\xde\x03\xd9\x76\xf7\x7c\xa3\xf6\x1c\x51\x7b\x8e\xc2\x78\xb5\x07\x6a\x71\x00\xf0\x5b\x75\xf4\x3b\x88\x76\x0f\xd4\xc5\x3d\xfa\x83\xc2\x1f\xd5\x9e\xe3\xea\xaa\x9f\xe0\xee\xd8\x03\x35\x72\xfd\x9e\x54\x7b\x4e\xd7\xee\x06\xfc\x55\x5d\xfb\xbb\xc2\x3f\x14\xd6\xba\x67\x42\x5d\xee\xe3\x7b\x21\xda\x3b\x00\xdf\x52\xe5\x6d\x70\x74\x2f\xf4\x90\x53\x80\x3b\xa0\x46\x7b\x61\xc4\x70\xf7\xec\xa9\x9d\x0d\xe8\xde\x35\x7b\xd5\xfd\xbb\x17\x62\x38\xc0\x3f\x82\x7a\xdd\x06\xb8\x0b\xfa\xc3\x47\xaa\x9f\x7f\x04\x91\x7c\xcc\xf7\xc1\x39\xfb\xf8\x3e\x35\xae\xee\x07\xfb\x2f\x03\xbe\x05\x57\xed\x87\xde\xf8\x0e\xe0\xbb\xaa\xbc\x1d\xce\xdc\x0f\x16\xb6\x03\xee\x52\xe5\xdd\x60\x6d\x3f\xf4\xa5\xb5\x80\x9f\xd4\xb6\x03\xfc\x02\x2c\xef\x57\x1e\xf7\x2b\x6b\x5f\x80\x85\xc3\x80\xef\x42\x9e\xbf\x50\xd1\x7e\x01\xe7\x6f\x00\xfc\x4a\x95\x0f\x43\x8f\xfa\x02\xfa\x9b\x8b\xdf\xd7\x9e\x04\xfc\x01\xee\xb2\x2f\xdc\x67\xff\xfc\x4b\x88\xe4\x3a\x40\x37\x92\x2f\xc1\xce\x76\xc0\x6d\x0a\x77\xa8\x3d\xbb\x15\x7e\x04\x31\x7c\x09\xde\xdd\xfd\x87\xa1\x5f\x7d\xa9\x7a\xef\x01\xe8\x1b\x87\x01\x7f\x03\x3c\x08\xad\xe3\xe2\x51\x85\xdf\xc3\x99\x07\xc1\xcb\x06\xc0\xe3\x6a\xcf\x49\x85\xa7\x14\xfe\xa2\xf0\x34\xd4\xee\x20\x5e\xfb\xa7\x3a\xdf\x71\xcb\xea\x6e\x3a\x04\xfd\xf6\x24\xa0\xdb\x1f\x0e\x41\x1f\xf8\x14\xf0\x1b\x18\xd5\x0f\x29\xfb\x87\x94\xcd\x43\xca\xe6\x21\xb0\xe6\x9e\xf9\xa7\x5b\x86\x6b\x0f\xf3\xaf\xa1\x07\x02\x42\x0c\x87\xf9\x61\xe5\xf1\xb0\x3a\x7a\x58\xd9\xff\x06\x2c\xbb\x78\x50\xe1\x61\xf0\xf5\x0d\x44\xee\xe2\x51\xb5\xe7\x7b\x55\xfe\x41\xe1\x71\xb5\xe7\xa4\xc2\x9f\x15\xfe\xa2\xf6\x9f\x56\x65\x37\xf2\x23\xca\xda\x11\x65\xed\x08\x44\xe8\xe2\x51\x85\xc7\xe1\xcc\x23\x6a\xf4\x3b\x82\x67\xba\x31\x1c\x55\xfd\xf9\xa8\xca\xd5\x51\x75\xe6\x51\xe5\xf1\xa8\xf2\x78\x54\x79\x3c\xaa\x3c\x1e\x85\xc8\x4f\x02\xfe\xa6\xca\xee\xb5\xdf\x91\x62\xb8\x5f\xbe\x53\x1c\xf1\x1d\x78\x74\xd1\x65\x87\xef\x94\x9d\xef\xf8\xf7\xa4\x17\xa0\x3b\xea\x7e\x07\x16\x5c\xfc\x59\xed\xff\x45\x9d\xf9\x9b\x2a\xbb\x19\xf8\x5e\xe5\xe4\x7b\xb5\xe7\xb8\x8a\xe7\xb8\xca\xc0\x71\x65\xe7\xb8\x8a\xe7\xb8\x6a\xbb\xe3\x70\xe6\xc7\x80\xa7\x15\xfe\x06\x6a\xf3\xb8\xb2\x70\x5c\xe5\xf9\x84\xba\xf6\x84\xba\xf6\x84\xba\xf6\x04\x5c\xbb\x01\xd0\xbd\x07\x4f\x28\xef\x27\x94\xaf\x13\xca\xc2\x09\xe5\xf1\x84\xb2\x70\x42\x59\x38\x09\x75\x01\x86\x50\xd9\x3b\xa9\xb2\x77\x52\x65\xe6\xa4\xb2\x76\x52\xe5\xf0\xa4\xca\xc3\x49\x55\x8b\x93\x2a\xf3\x27\x95\x9d\x93\x2a\x27\x3f\x93\x30\xe8\xf3\x3f\x93\x70\xb8\x2b\x7f\x56\xf1\xfc\xac\xec\xfc\x0c\xe3\xaa\xbb\xe7\xb8\x2a\x9f\x82\x6b\x7f\x56\xec\x7c\x4a\x8d\xa5\xa7\xd4\x18\x75\x0a\x66\x1f\xd0\x3f\x60\xf6\xb1\x81\x9f\x82\x6b\xff\x00\x74\xeb\x72\x4a\x79\x3f\x05\x75\x79\x0f\xf0\x07\xb5\xe7\x84\xda\xe3\x7a\x3f\x05\x91\x1f\xe0\xbf\xa8\x2c\xfd\xa2\xb2\xf4\x0b\xd8\xdf\x0a\xe8\x46\xf5\x8b\xaa\xd7\x69\xd5\x2b\x4e\xab\x36\x3a\xad\xac\x9d\x56\x75\x39\xad\xfa\xc3\x69\x55\x97\xd3\xea\xfc\xd3\xaa\xe7\x9f\x56\x39\xf9\x15\x62\x69\xc3\x21\x0a\x32\x84\xd7\xc0\xd1\x0d\xdc\x51\x99\x71\x54\xbd\x1c\x15\x9b\xa3\xac\x39\xca\xbb\xa3\xbc\x3b\xaa\x8e\x8e\xea\x33\x8e\xca\xb9\xa3\xee\x2f\x47\xe5\xdc\x51\x77\x53\xad\xb2\x53\xab\x72\x5b\xab\xae\xad\x55\xd7\xd6\xaa\x6b\x6b\xd5\xb5\xb5\x70\xfe\x3b\x80\xbf\xa9\x32\xc4\x23\xc2\xdc\x5c\x01\x42\xae\x00\x3b\xa8\x3d\x90\x2b\x40\x18\xd5\x01\x2f\x01\x4c\x86\x73\xb6\x03\x86\xc3\xfe\x64\x77\xcc\x07\x2c\x56\x08\x63\xbe\x7e\x48\x3f\x54\x5b\xa0\x7f\x0d\x73\x5b\x17\x27\x29\x9c\x5c\xfb\xac\xfe\xb5\xfb\x1c\x40\x3f\xcc\x9f\xa9\x6d\x03\xf8\xaa\xc2\xdd\x0a\x3f\x71\x6e\x03\xdc\x57\x3b\x52\x3f\xa6\x8e\x1e\x53\x47\x8f\xa9\xa3\xc7\x60\xfc\x21\x80\xfb\x6a\xef\x20\x84\x74\xa4\x25\xee\x33\x3e\xf5\xdf\x24\xb2\x16\xcb\x94\x34\xa7\x3d\xb0\xcc\x48\x30\x1d\x8b\x65\x4e\xda\xd1\xd5\x58\x16\xa4\x3d\xfd\x16\xcb\x1a\x69\xc6\xba\x61\x59\x92\xb6\x6c\x2e\x96\x75\xb2\x84\x2f\xc5\xb2\x41\x22\x45\x34\x96\x4d\xd2\x4c\x8c\xc7\x72\x10\x2d\xd1\x93\xb0\x1c\x4c\xda\x1b\xc7\xb0\x1c\x42\xfa\x9a\xb9\x58\x0e\x25\x5e\xb3\x16\xcb\xcd\x48\xdb\xa0\x79\x10\x09\x15\x26\xfc\xf5\xa4\x8a\xca\x2d\x53\x12\x4d\x35\x2c\x33\x12\x45\xfb\x63\x99\x93\x78\x3a\x1d\xcb\x82\xf4\xa7\xeb\xb1\xac\x91\xf6\x4c\xc7\xb2\x24\x36\xb3\xb1\xac\x93\x53\xec\x4a\x2c\x1b\xa4\x27\xe8\x20\x7f\xd9\x24\xed\x85\x17\xcb\x41\xec\x73\x31\x1b\xcb\xc1\xa4\xbf\xb1\x0e\xcb\x21\x64\xba\x29\xb1\x1c\x4a\xe6\x9a\x37\x63\xb9\x19\xb1\x83\xbc\x24\x8d\x14\x92\x39\xf0\xaf\x02\xfe\x2d\x21\x79\x24\x97\x44\xc3\xbf\x6c\xf8\x3b\x1b\x4a\x39\xc4\x47\x4a\xc9\x62\x52\xa6\xce\x2a\x80\xbd\xd1\xa4\x27\xec\xed\x05\x5b\x0f\xe9\x47\xe2\xe0\x5f\x34\x19\x0a\x67\xf9\xe0\x78\x11\x5c\x1f\x4d\x52\xa1\x5c\x06\x57\xb9\x98\xad\xec\xfa\x48\x09\xe9\x4b\x82\xd4\x91\xbf\xb6\xe6\x81\xd2\x38\x8c\x62\x98\xba\xfa\x7c\x28\x0d\x87\xeb\x73\xc0\x02\x49\x2b\x9c\x53\x58\x51\xb8\x24\x2f\x37\x3a\x37\xbb\x22\x3b\x3a\xc7\x57\xba\xb8\xac\x70\x4e\x41\x45\x74\xcf\x9c\x5e\xd1\x9e\x7e\x71\xfd\xa2\x87\xfa\x7c\x73\x8a\xf2\xa2\x53\x7d\x65\xa5\xbe\xb2\xec\x8a\x42\x5f\x49\xdf\xa0\xd4\xc6\xa7\x79\xa2\xc7\x81\x89\x61\xd9\x15\xe7\x47\x0f\x2f\xc9\x01\xbb\x23\x21\xa0\xd9\xe0\x36\x30\xe0\x68\x32\x5e\xed\x29\x24\xf9\x70\x42\xe1\xec\x3c\xbf\xb9\xe8\xf1\x79\x65\x85\xb0\x27\x05\x4e\x2a\x52\x71\x0e\x57\xb9\x2a\x82\x13\x73\x60\xb7\xaf\x28\x37\x7a\x78\x45\x76\x51\x21\xfc\x91\x4c\xca\x61\x5f\x1e\x18\xcb\x55\xa6\xa2\x49\x1f\xf8\xf7\xb7\xce\x92\xcb\x73\xf2\x4a\x72\xf3\xca\xa2\xfb\x44\x9f\xed\xf7\xef\xae\x8e\x3e\x57\x64\x8d\x4d\x45\x37\x08\x75\x92\x32\x50\x5e\x6f\xd0\x03\xe9\xee\x07\xff\xf7\x85\x46\x21\x93\xf2\xca\xca\xdd\xeb\x3c\x7d\xfb\xf5\xeb\x1b\xd7\x74\x0c\x67\x22\xe8\x53\x1f\xc1\x39\xfc\x2b\xf7\x7d\x5c\xf7\x75\xde\x9b\xae\x54\x21\xc4\x13\xad\xba\x61\x85\x3a\xe2\x26\xb1\x18\xb6\x65\x64\x1e\xec\xf3\xa9\xca\x9e\xbb\xb3\x44\xc3\x79\x79\xaa\x6b\x97\xc3\x91\x3c\xf5\x57\xae\xb2\xea\xda\x9e\x08\x67\x8c\x57\x67\x8d\x55\x57\xba\x8d\x54\xa1\xbc\x95\xa8\xb3\x26\x34\xe1\x71\x0c\x78\xcc\x57\x95\xc9\x0b\x38\x33\x47\xd9\x76\x2b\xea\xb7\xec\x83\x72\x01\x36\xf7\x5c\x52\xa9\x92\x52\x0e\x67\xba\xd7\xd5\xd5\xad\xdc\xed\xcc\x01\x0d\x52\x58\x1e\x9d\x1d\x5d\x51\x96\x9d\x9b\x57\x9c\x5d\x36\x2f\xda\x97\xdf\xb0\x83\x46\x97\xe5\xcd\x29\x2c\xaf\xc8\x2b\x83\x9d\x85\x25\xd1\x13\xfb\x8e\xef\x1b\x3d\x36\xbb\x22\xaf\xa4\x22\x3a\xbb\x24\x37\x7a\x42\xfd\x85\x63\xf2\xf3\x0b\x73\xf2\xd4\xce\x9c\xbc\xb2\x8a\x6c\x38\xd9\x57\x51\x00\x3d\x69\x6e\x65\x59\x61\x79\x6e\x61\x8e\xeb\xad\xbc\x6f\x53\x3d\xb3\xe9\xbb\xf6\x4c\x5f\x0c\xb8\xa3\x08\x64\xce\xcd\xd8\x02\x95\x87\x51\xea\x74\xf7\xef\x72\xff\x25\xe3\x2b\xf2\x16\xe4\x45\x8f\xca\xae\xa8\xc8\x2b\x77\x4f\x4e\x81\x13\xca\x31\xf9\xfe\x86\x9d\xa0\x52\xe5\x83\xbd\x6e\x83\x2d\x84\x74\xb9\xc9\x29\x50\xe5\x6c\xd5\xe8\xb9\xca\x9c\x3b\x4a\x94\xe0\x95\xb3\x61\xdc\x88\xfe\x4b\xc7\xd1\x78\x6d\x36\x76\x9e\x12\xe5\x63\x01\xd6\xc6\xbd\xe6\x7c\xec\x14\xf9\x0a\xcb\x95\xdf\x12\xf0\x11\xad\xe2\xab\xbb\x7f\x02\x7d\x47\xab\xc6\xcc\x56\x5d\xc3\xdf\x1d\x8b\xe1\x68\x85\x3a\x37\x47\xf5\xed\x22\x15\x97\x3b\x4e\x16\x43\xf6\xfc\xbe\x66\xe3\x48\xb8\x50\x8d\xab\x05\x58\xe3\x62\x65\x37\x9a\x8c\x86\xed\x42\xd5\x75\x7d\xaa\x73\x95\xc4\x74\x56\x1d\xf1\x4c\x56\xfc\x9d\x3b\x1f\x6f\xc9\x68\x75\x6d\x29\x94\x7d\xaa\x16\x75\x79\xec\xa3\xda\xd0\xad\x49\x9e\x8a\xd4\x2d\x65\xab\xb1\x7b\x36\x5c\x51\xa4\x7c\xfb\x63\x2b\x50\x5d\x38\x5b\x75\xc0\x3c\xec\x90\x15\xaa\x06\xe5\x01\x1d\xd9\xdf\x6d\xa3\x55\x2d\x5c\xeb\xe9\xaa\xf3\xba\x23\x76\x1e\xe6\x74\x32\x8c\xf4\x23\x9b\xb4\xe8\xcf\x60\xe0\x0d\x54\xae\xc6\x80\x05\x58\xe7\x3a\xdb\x25\x2a\xda\xdc\xfa\x3a\xfa\xb3\xed\x9e\x55\x84\x9e\xfc\x35\x2e\x52\x8c\x32\xaf\xbe\x7d\xf2\x55\xbf\xf4\x67\x34\x57\x59\xeb\x73\x8e\x9c\xe7\xab\xdc\x54\xa0\x57\x9f\x8a\x28\x17\xfe\xf7\xb7\xb8\xbf\x6f\xf9\xe0\xda\x4a\xd5\x1e\xfe\x9b\xde\xdf\xeb\x2b\xce\xca\x5c\xb6\xca\xaf\x0f\xaf\x2b\x85\x23\xae\x2f\x7f\x2c\xc5\xfe\x9b\x38\x25\xbb\x1c\x6e\x4a\xb8\x85\x27\x14\x96\xf8\xca\xcf\x8f\x5e\x58\x50\x98\x53\x10\xbd\x30\xbb\x3c\x3a\x37\xaf\xbc\x70\x4e\x09\x1c\x9c\xbd\x38\xba\xe1\x2d\x11\x0d\x47\xb3\xe1\xa6\x2f\x29\xf1\x2d\x80\x1b\x6a\x41\xde\xf9\x70\x83\xe7\x97\xe5\x95\x17\x14\x96\xcc\x89\x2e\x57\x83\xb3\xff\xea\xe8\x8a\x82\xec\x0a\x77\x74\x28\xce\xab\x28\x2b\xcc\xc9\x2e\x2a\x5a\x0c\xa4\x57\x5c\x0a\x57\xcd\x06\x96\x5b\x58\x58\x51\x00\x8e\x8b\xf3\xca\xa3\x47\xe7\x2d\x8c\x1e\xe7\x2b\xce\x2e\x79\xbc\xaf\x3f\x14\x18\x44\xf2\x61\xd8\x8e\x2e\x2c\x2e\x2d\xf3\x2d\x50\x31\xf6\x29\xcf\x29\xcb\xcb\x2b\x01\x67\xd9\xb9\xd9\xb3\x0b\x8b\x0a\x2b\xc0\x5a\x41\x76\x59\x76\x0e\x0c\x2d\x30\xbe\x14\xe6\x94\xab\xa1\x03\x46\x8c\xe8\xd2\xec\x92\x3e\xe9\x95\x65\xbe\xd2\x3c\x88\x74\xf2\xd0\x91\x67\x4e\x84\x00\xfd\xc3\x4e\xb9\xaf\x68\x01\x78\x76\xcf\x2e\xc9\xcb\xcb\x75\x3d\x42\xd8\x0b\xf2\x8a\xe0\x22\x70\x5c\xe4\xf3\xcd\x73\xeb\x93\xef\x2b\x83\x40\x73\x2b\x0a\xfa\x04\x44\x9e\xef\x2b\xa9\x80\x4b\x7d\xd1\xd9\xb9\xb9\x50\x71\xc8\x96\x2f\xa7\xb2\xd8\x1d\xd0\x60\x90\xa9\xa8\x0b\x2e\x3b\xa7\xcc\x07\xc7\x4a\x8b\xb2\x2b\xc0\x4a\xb1\x3b\x70\x15\xa8\x5b\xbe\x94\x0c\x20\xb1\xf0\xff\x42\xf5\x7f\x5f\x75\xe3\x07\x0e\x67\x39\x38\x98\xf5\xc5\x4e\x12\x0b\x17\x56\x54\x94\x0e\x88\x8d\x5d\xb8\x70\x61\xdf\x6c\x1c\xd3\x72\x60\x48\xeb\x0b\x41\xc5\xfe\x73\xb3\x6e\x3f\x29\x55\x3d\x3a\x70\xbc\x2a\x53\x7d\xc3\xb5\x59\x0c\x7d\xe6\x2f\x5d\x57\x2c\x2e\xcd\xc3\x9e\x52\x56\xde\xb7\xa0\xa2\xb8\xc8\xcf\x86\x7e\xb7\x75\xc3\x66\x65\xc0\x40\x5d\x77\x2b\x8d\x07\xa6\x1b\xa9\x58\xa9\x14\x07\x80\x0c\xec\xfa\xd1\x8d\x2c\xb8\xc3\x5e\x63\x7e\x8f\xf3\x33\xfb\x48\xa0\x8b\x12\xb7\x07\x57\xaa\x41\xde\x6d\xcb\xf1\xc3\x47\x46\x8f\x29\x85\x6e\x92\x01\x6d\x14\x8d\x27\x9c\x1f\x5d\xa7\x01\xe2\x5c\x01\xd0\x30\x5d\xfe\x61\xa8\x10\xfe\xae\x50\x15\x2f\x57\x37\x51\x5f\x95\xac\x39\x70\x7c\x0c\x44\x36\xb2\x3e\x0d\xd0\x09\x0b\x4b\x2b\xca\xfb\x96\x17\x16\xf5\xf5\x95\xcd\x89\x1d\x93\xe1\x2e\x9f\x44\x48\xed\xf1\xc7\xdf\xac\x8d\x21\x9b\x49\x13\xff\x05\x45\x28\xfd\xcf\x40\xb9\x0a\xd0\xc8\x12\xf4\xb0\x01\xda\x37\x08\x74\x6e\x08\x68\xda\x66\x30\x53\x6c\x0e\xf3\xc4\x16\x24\x82\x44\x92\x96\x24\x8a\xb4\x22\xad\x49\x1b\xd2\x96\xb4\x23\xed\x61\xe6\xd2\x91\x74\x82\x2a\xc7\x90\xce\xa4\x0b\xe9\x4a\xba\x91\xee\xa4\x07\xe8\xce\x5e\xe4\x3c\xd2\x1b\x92\xd3\x07\x42\x8d\x45\xf5\x69\x11\x9b\x78\x49\x3c\x49\x20\xfd\x49\x22\x54\x6f\x20\x19\x44\x06\x93\x0b\xc8\x10\x92\x04\x9c\x99\x02\x2c\x99\x06\xe3\x62\x06\x8c\x83\xc3\x20\xfd\x17\x92\x11\x50\xb1\x51\x30\xa2\x8f\x01\x19\x71\x11\x8c\xe8\xe3\x61\x14\x9f\x08\xc9\x9e\x4c\xa6\x90\x4c\x32\x95\x4c\x23\xd3\x49\x16\x99\x41\x66\x92\x59\x24\x9b\x32\xf2\x00\xb9\x82\x5c\x49\x5e\x23\xb7\x92\xa3\xe4\x2a\x72\x3d\x59\x49\xee\x26\x8f\x91\x07\x29\x27\xff\xa2\x82\x5c\x4e\x6e\x26\x27\xc9\xcf\xe4\x3a\x98\x33\x54\x51\x49\xbe\x20\x27\xc8\x3d\xe4\x71\xf2\x0b\x39\x45\x4e\x93\x35\xe4\x29\xf2\x1e\x79\x07\xe6\x43\xb3\x21\xe1\x37\x40\x87\xd8\x0a\x8d\xfa\x2e\x79\x9f\xec\x20\xdb\xc8\x76\xf2\x01\x39\x06\x63\xd3\x6e\xf2\x21\xd9\x49\xd6\x41\xe2\x7f\x22\x37\x92\x8f\xc8\x1e\xb2\x17\x9a\xeb\x3b\xf2\x03\xb9\x06\xe4\x48\x21\x8c\xa9\x6e\x9f\x2c\x21\xf7\x41\xf3\xcc\x57\xac\x52\x0e\xdd\xab\x02\xc6\xe0\x85\xe4\x5b\xb2\x08\xe6\x00\x8b\xc9\x52\x98\xe1\x5d\x4c\x5e\x24\xf7\x93\xe5\x64\x19\x59\x41\x2e\x25\xdf\x93\x1f\xc9\xcb\x54\xa7\x06\x35\x69\x10\x0d\xa6\x21\xa4\x86\x38\x34\x94\x36\xa3\x61\xb4\x39\xa9\xa5\x84\x86\xd3\x16\x34\x82\x52\x1a\x49\x5b\xd2\x28\xda\x8a\xb6\xa6\x6d\x68\x5b\xda\x8e\xb6\xa7\x1d\x68\x47\xda\x89\xfc\x46\x7e\xa7\xd1\x34\x86\x76\xa6\x5d\x68\x57\xda\x8d\x76\xa7\x3d\x68\x4f\xda\x8b\x9e\x47\x7b\xd3\xf3\x69\x1f\xda\x97\xc6\x92\x3f\xc8\xc7\xb4\x1f\x8d\xa3\x1e\x6a\x51\x9b\x7a\x69\x3c\x4d\xa0\xfd\x69\x22\x1d\x40\x07\xd2\x41\x74\x30\xbd\x80\x1c\x24\x87\xe8\x10\x9a\x44\x93\x69\x0a\x4d\xa5\x69\x34\x9d\x66\xb8\xaf\xe1\xa1\xc3\xe9\x85\x74\x04\x1d\x49\x47\x91\xf5\xe4\x69\x3a\x9a\x8e\xa1\x63\xe9\x45\x74\x1c\x1d\x4f\x27\xd0\x89\x74\x12\x9d\x4c\xfe\x24\xd5\xe4\x6b\x72\x98\x4e\xa1\x99\x74\x2a\x9d\x46\xa7\xd3\x2c\x3a\x83\xce\xa4\xb3\x68\x36\x9d\x4d\x73\x68\x2e\xcd\xa3\xf9\x74\x0e\x2d\xa0\x85\x74\x2e\x9d\x47\x8b\x68\x31\x79\x85\x96\x50\x1f\x2d\xa5\xf3\xc9\x37\xe4\x08\x2d\xa3\xe5\xb4\x82\x56\xd2\x05\x74\x21\x5d\x44\x17\xd3\x25\x74\x29\xbd\x98\x5e\x42\x97\xd1\xe5\x74\x05\xbd\x94\x5e\x46\x2f\xa7\x57\x90\x87\xe9\x95\xf4\x2a\x7a\x35\xad\xa2\xd7\xd0\x7f\xd1\x95\xf4\x5a\x7a\x1d\xbd\x9e\xae\xa2\x37\xd0\x1b\xe9\x4d\xf4\x66\xba\x9a\xde\x42\x6f\xa5\xff\xa6\xb7\xd1\xdb\xe9\x1d\xf4\x4e\x7a\x17\xbd\x9b\xde\x43\xef\xa5\xf7\xd1\xfb\xe9\x1a\xfa\x00\x7d\x90\x3e\x44\x1f\xa6\x8f\xd0\x47\xe9\x63\xf4\x71\xfa\x04\x7d\x92\x3e\x45\xd7\xd2\x75\x74\x3d\x7d\x9a\x6e\xa0\xcf\xd0\x67\xe9\x73\xf4\x79\xfa\x02\x7d\x91\xbe\x44\x5f\xa6\xaf\xd0\x57\xe9\x6b\xf4\x75\xfa\x06\x7d\x93\x6e\xa4\x9b\xe8\x66\xba\x85\xbe\x45\xdf\xa6\xef\xd0\x77\xe9\x7b\xf4\x7d\xba\x95\x6e\xa3\xdb\xe9\x07\x74\x07\xfd\x90\xee\xa4\xbb\xe8\x6e\xba\x87\xee\xa5\x1f\xd1\x8f\xe9\x27\xf4\x53\xfa\x19\xdd\x47\x3f\xa7\xfb\xe9\x17\xf4\x4b\xfa\x15\x3d\x40\x0f\xd2\x43\xf4\x6b\x7a\x98\x7e\x43\x8f\xd0\xa3\xf4\x18\xfd\x96\x7e\x47\xbf\xa7\x3f\xd0\x1f\xe9\x71\xfa\x13\x3d\x41\x4f\xd2\x9f\xe9\x29\xfa\x0b\x3d\x4d\x7f\xa5\xbf\xd1\xdf\xe9\x1f\xf4\x4f\x5a\x4d\x6b\xa8\x43\x6b\x19\x61\x94\x31\xc6\xdd\x97\x63\x30\xc9\x74\x66\x30\x93\x05\xb1\x60\x16\xc2\x42\x59\x33\x16\xc6\x9a\xb3\x70\xd6\x82\x45\xb0\x48\xd6\x92\x45\xb1\x56\xac\x35\x6b\xc3\xda\xb2\x76\xac\x3d\xeb\xc0\x3a\xb2\x4e\x2c\x9a\xc5\xb0\xce\xac\x0b\xeb\xca\xba\xb1\xee\xac\x07\xeb\xc9\x7a\xb1\xf3\x58\x6f\x76\x3e\xeb\xc3\xfa\xb2\x58\xd6\x8f\xc5\x31\x0f\xb3\x98\xcd\xbc\x2c\x9e\x25\xb0\xfe\x2c\x91\x0d\x60\x03\xd9\x20\x36\x98\x5d\xc0\x86\xb0\x24\x96\xcc\x52\x58\x2a\x4b\x63\xe9\x2c\x83\x0d\x65\xc3\xd8\x70\x76\x21\x1b\xc1\x46\xb2\x51\x6c\x34\x1b\xc3\xc6\xb2\x8b\xd8\x38\x36\x9e\x4d\x60\x13\xd9\x24\x36\x99\x4d\x61\x99\x6c\x2a\x9b\xc6\xa6\xb3\x2c\x36\x83\xcd\x64\xb3\x58\x36\x9b\xcd\x72\x58\x2e\xcb\x63\xf9\x6c\x0e\x2b\x60\x85\x6c\x2e\x9b\xc7\x8a\x58\x31\x2b\x61\x3e\x56\xca\xe6\xb3\x32\x56\xce\x2a\x58\x25\x5b\xc0\x16\xb2\x45\x6c\x31\x5b\xc2\x96\xb2\x8b\xd9\x25\x6c\x19\x5b\xce\x56\xb0\x4b\xd9\x65\xec\x72\x76\x05\xbb\x92\x5d\xc5\xae\x66\x55\xec\x1a\xf6\x2f\xb6\x92\x5d\xcb\xae\x63\xd7\xb3\x55\xec\x06\x76\x23\xbb\x89\xdd\xcc\x56\xb3\x5b\xd8\xad\xec\xdf\xec\x36\x76\x3b\xbb\x83\xdd\xc9\xee\x62\x77\xb3\x7b\xd8\xbd\xec\x3e\x76\x3f\x5b\xc3\x1e\x60\x0f\xb2\x87\xd8\xc3\xec\x11\xf6\x28\x7b\x8c\x3d\xce\x9e\x60\x4f\xb2\xa7\xd8\x5a\xb6\x8e\xad\x67\x4f\xb3\x0d\xec\x19\xf6\x2c\x7b\x8e\x3d\xcf\x5e\x20\x9f\x90\x03\xec\x45\xf2\x19\x7b\x89\xbd\xcc\x5e\x61\xaf\xb2\xd7\xd8\xeb\xec\x0d\xf6\x26\xdb\xc8\x36\xb1\xcd\x6c\x0b\x7b\x8b\xbd\x4d\xf6\x91\xcf\xc9\x7e\xf2\x15\xf9\x94\x7c\xc9\xde\x61\xef\xb2\xf7\xd8\xfb\x6c\x2b\xdb\xc6\xb6\xb3\x0f\xd8\x0e\xf6\x21\xdb\xc9\x76\xb1\xdd\x6c\x0f\xdb\xcb\x3e\x62\x1f\xb3\x4f\xd8\xa7\xec\x33\xb6\x8f\x7d\xce\xf6\xb3\x2f\xd8\x97\xec\x2b\x76\x80\x1d\x64\x87\xd8\xd7\xec\x30\xfb\x86\x1d\x61\x47\xd9\x31\xf6\x2d\xfb\x8e\x7d\xcf\x7e\x60\x3f\xb2\xe3\xec\x27\x76\x82\x9d\x64\x3f\xb3\x53\xec\x17\x76\x9a\xfd\xca\x7e\x63\xbf\xb3\x3f\xd8\x9f\xac\x9a\xd5\x30\x87\xd5\x72\xc2\x29\x67\x9c\x73\xc1\x35\x2e\xb9\xce\x0d\x6e\xf2\x20\x1e\xcc\x43\x78\x28\x6f\xc6\xc3\x78\x73\x1e\xce\x5b\xf0\x08\x1e\xc9\x5b\xf2\x28\xde\x8a\xb7\xe6\x6d\x78\x5b\xde\x8e\xb7\xe7\x1d\x78\x47\xde\x89\x47\xf3\x18\xde\x99\x77\xe1\x5d\x79\x37\xde\x9d\xf7\xe0\x3d\x79\x2f\x7e\x1e\xef\xcd\xcf\xe7\x7d\x78\x5f\x1e\xcb\xfb\xf1\x38\xee\xe1\x16\xb7\xb9\x97\xc7\xf3\x04\xde\x9f\x27\xf2\x01\x7c\x20\x1f\xc4\x07\xf3\x0b\xf8\x10\x9e\xc4\x93\x79\x0a\x4f\xe5\x69\x3c\xdd\xfd\xe6\x09\x1f\xc6\x87\xf3\x0b\xf9\x08\x3e\x92\x8f\xe2\xa3\xf9\x18\x3e\x96\x5f\xc4\xc7\xf1\xf1\x7c\x02\x9f\xc8\x27\xb9\xdf\x3f\xe0\x99\x7c\x2a\x9f\xc6\xa7\xbb\x9f\xd6\xf3\x99\x7c\x16\xcf\xe6\xb3\x79\x0e\xcf\xe5\x79\x3c\x9f\xcf\x71\x3f\x3f\xe7\x73\xf9\x3c\x5e\xc4\x8b\xc9\xa3\xbc\x84\xfb\xdc\xcf\x99\x79\x19\x2f\xe7\x15\xbc\x92\x2f\xe0\x0b\xdd\x4f\x7b\xf9\x12\xbe\x94\x5f\xcc\x2f\xe1\xcb\xf8\x72\xbe\x82\xdc\xcb\x2f\xe5\x97\xf1\xcb\xf9\x15\xfc\x4a\x7e\x15\xbf\x9a\x57\xf1\x6b\xf8\xbf\xf8\x4a\x7e\x2d\xbf\x8e\x5f\xcf\x57\xf1\x1b\xf8\x8d\xfc\x26\xf2\x6f\x7e\x33\x5f\xcd\x6f\x21\x77\xf2\x5b\xf9\xbf\xf9\x6d\xfc\x76\x7e\x07\xbf\x93\xdf\xc5\xef\xe6\xf7\xf0\x7b\xf9\x7d\xfc\x7e\xbe\x86\x3f\xc0\x1f\xe4\x0f\xf1\x87\xf9\x23\xfc\x51\xfe\x18\x7f\x9c\x3f\xc1\x9f\xe4\x4f\xf1\xb5\x7c\x1d\x5f\xcf\x9f\xe6\x1b\xf8\x33\xfc\x59\xfe\x1c\x7f\x9e\xbf\xc0\x5f\xe4\x2f\xf1\x97\xf9\x2b\xfc\x55\xfe\x1a\x7f\x9d\xbf\xc1\xdf\xe4\x1b\xf9\x26\xee\x7e\xa2\xf8\x16\x7f\x9b\xbf\xc3\xdf\xe5\xef\xf1\xf7\xf9\x56\xbe\x8d\x6f\xe7\x1f\xf0\x1d\xfc\x43\xbe\x93\xef\xe2\xee\xa7\x26\x7b\xf9\x47\xfc\x63\xfe\x09\xff\x94\x7f\xc6\xf7\xf1\xcf\xdd\x4f\x23\xf8\x97\xfc\x2b\x7e\x80\x1f\xe4\x87\xf8\xd7\xdc\x7d\x32\x7e\x84\x1f\xe5\xc7\xf8\xb7\xee\x33\x69\xfe\x03\xff\x91\x1f\xe7\x3f\xf1\x13\xfc\xa4\xfb\x24\x96\xff\xc2\x4f\xf3\x5f\xf9\x6f\xfc\x77\xfe\x07\xff\x93\x57\xf3\x1a\xee\xf0\x5a\x41\x04\x15\x4c\x70\x21\x84\x26\xa4\xd0\x85\x21\x4c\x11\x24\x82\x45\x88\x08\x15\xcd\x44\x98\x68\x2e\xc2\x45\x0b\x11\x21\x22\x45\x4b\x11\x25\x5a\x89\xd6\xa2\x8d\x68\x2b\xda\x89\xf6\xa2\x83\xe8\x28\x3a\x89\x68\x11\x23\x3a\x8b\x2e\xa2\xab\xe8\x26\xba\x8b\x1e\xa2\xa7\xe8\x25\xce\x13\xbd\xc5\xf9\xa2\x8f\xe8\x2b\x62\x45\x3f\x11\x27\x3c\xc2\x12\xb6\xf0\x8a\x78\x91\x20\xfa\x8b\x44\x31\x40\x0c\x14\x83\xc4\x60\x71\x81\x18\x22\x92\x44\xb2\x48\x11\xa9\x22\x4d\xa4\x8b\x0c\x31\x54\x0c\x13\xc3\xc5\x85\x62\x84\x18\x29\x46\x89\xd1\x62\x8c\x18\x2b\x2e\x12\xe3\xc4\x78\x31\x41\x4c\x14\x93\xc4\x64\x31\x45\x64\x8a\xa9\x62\x9a\x98\x2e\xb2\xc4\x0c\x31\x53\xcc\x12\xd9\x62\xb6\xc8\x11\xb9\x22\x4f\xe4\x8b\x39\xa2\x40\x14\x8a\xb9\x62\x9e\x28\x12\xc5\xa2\x44\xf8\x44\xa9\x98\x2f\xca\x44\xb9\xa8\x10\x95\x62\x81\x58\x28\x16\x89\xc5\x62\x89\x58\x2a\x2e\x16\x97\x88\x65\x62\xb9\x58\x21\x2e\x15\x97\x89\xcb\xc5\x15\xe2\x4a\x71\x95\xb8\x5a\x54\x89\x6b\xc4\xbf\xc4\x4a\x71\xad\xb8\x4e\x5c\x2f\x56\x89\x1b\xc4\x8d\xe2\x26\x71\xb3\x58\x2d\x6e\x11\xb7\x8a\x7f\x8b\xdb\xc4\xed\xe2\x0e\x71\xa7\xb8\x4b\xdc\x2d\xee\x11\xf7\x8a\xfb\xc4\xfd\x62\x8d\x78\x40\x3c\x28\x1e\x12\x0f\x8b\x47\xc4\xa3\xe2\x31\xf1\xb8\x78\x42\x3c\x29\x9e\x12\x6b\xc5\x3a\xb1\x5e\x3c\x2d\x36\x88\x67\xc4\xb3\xe2\x39\xf1\xbc\x78\x41\xbc\x28\x5e\x12\x2f\x8b\x57\xc4\xab\xe2\x35\xf1\xba\x78\x43\xbc\x29\x36\x8a\x4d\x62\xb3\xd8\x22\xde\x12\x6f\x8b\x77\xc4\xbb\xe2\x3d\xf1\xbe\xd8\x2a\xb6\x89\xed\xe2\x03\xb1\x43\x7c\x28\x76\x8a\x5d\x62\xb7\xd8\x23\xf6\x8a\x8f\xc4\xc7\xe2\x13\xf1\xa9\xf8\x4c\xec\x13\x9f\x8b\xfd\xe2\x0b\xf1\xa5\xf8\x4a\x1c\x10\x07\xc5\x21\xf1\xb5\x38\x2c\xbe\x11\x47\xc4\x51\x71\x4c\x7c\x2b\xbe\x13\xdf\x8b\x1f\xc4\x8f\xe2\xb8\xf8\x49\x9c\x10\x27\xc5\xcf\xe2\x94\xf8\x45\x9c\x16\xbf\x8a\xdf\xc4\xef\xe2\x0f\xf1\xa7\xa8\x16\x35\xc2\x11\xb5\x1a\xd1\xa8\xbb\x7c\xb3\x26\x34\x4d\x93\x9a\xae\x19\x9a\xa9\x05\x69\xc1\x5a\x88\x16\xaa\x35\xd3\xc2\xb4\xe6\x5a\xb8\xd6\x42\x8b\xd0\x22\xb5\x96\x5a\x94\xd6\x4a\x6b\xad\xb5\xd1\xda\x6a\xed\xb4\xf6\x5a\x07\xad\xa3\xd6\x49\x8b\xd6\x62\xb4\xce\x5a\x17\xad\xab\xd6\x4d\xeb\xae\xf5\xd0\x7a\x6a\xbd\xb4\xf3\xb4\xde\xda\xf9\x5a\x1f\xad\xaf\x16\xab\xf5\xd3\xe2\x34\x8f\x66\x69\xb6\xe6\xd5\xe2\xb5\x04\xad\xbf\x96\xa8\x0d\xd0\x06\x6a\x83\xb4\xc1\xda\x05\xda\x10\x2d\x49\x4b\xd6\x52\xb4\x54\x2d\x4d\x4b\xd7\x32\xb4\xa1\xda\x30\x6d\xb8\x76\xa1\x36\x42\x1b\xa9\x8d\xd2\x46\x6b\x63\xb4\xb1\xda\x45\xda\x38\x6d\xbc\x36\x41\x9b\xa8\x4d\xd2\x26\x6b\x53\xb4\x4c\x6d\xaa\x36\x4d\x9b\xae\x65\x69\x33\xb4\x99\xda\x2c\x2d\x5b\x9b\xad\xe5\x68\xb9\x5a\x9e\x96\xaf\xcd\xd1\x0a\xb4\x42\x6d\xae\x36\x4f\x2b\xd2\x8a\xb5\x12\xcd\xa7\x95\x6a\xf3\xb5\x32\xad\x5c\xab\xd0\x2a\xb5\x05\xda\x42\x6d\x91\xb6\x58\x5b\xa2\x2d\xd5\x2e\xd6\x2e\xd1\x96\x69\xcb\xb5\x15\xda\xa5\xda\x65\xda\xe5\xda\x15\xda\x95\xda\x55\xda\xd5\x5a\x95\x76\x8d\xf6\x2f\x6d\xa5\x76\xad\x76\x9d\x76\xbd\xb6\x4a\xbb\x41\xbb\x51\xbb\x49\xbb\x59\x5b\xad\xdd\xa2\xdd\xaa\xfd\x5b\xbb\x4d\xbb\x5d\xbb\x43\xbb\x53\xbb\x4b\xbb\x5b\xbb\x47\xbb\x57\xbb\x4f\xbb\x5f\x5b\xa3\x3d\xa0\x3d\xa8\x3d\xa4\x3d\xac\x3d\xa2\x3d\xaa\x3d\xa6\x3d\xae\x3d\xa1\x3d\xa9\x3d\xa5\xad\xd5\xd6\x69\xeb\xb5\xa7\xb5\x0d\xda\x33\xda\xb3\xda\x73\xda\xf3\xda\x0b\xda\x8b\xda\x4b\xda\xcb\xda\x2b\xda\xab\xda\x6b\xda\xeb\xda\x1b\xda\x9b\xda\x46\x6d\x93\xb6\x59\xdb\xa2\xbd\xa5\xbd\xad\xbd\xa3\xbd\xab\xbd\xa7\xbd\xaf\x6d\xd5\xb6\x69\xdb\xb5\x0f\xb4\x1d\xda\x87\xda\x4e\x6d\x97\xb6\x5b\xdb\xa3\xed\xd5\x3e\xd2\x3e\xd6\x3e\xd1\x3e\xd5\x3e\xd3\xf6\x69\x9f\x6b\xfb\xb5\x2f\xb4\x2f\xb5\xaf\xb4\x03\xda\x41\xed\x90\xf6\xb5\x76\x58\xfb\x46\x3b\xa2\x1d\xd5\x8e\x69\xdf\x6a\xdf\x69\xdf\x6b\x3f\x68\x3f\x6a\xc7\xb5\x9f\xb4\x13\xda\x49\xed\x67\xed\x94\xf6\x8b\x76\x5a\xfb\x55\xfb\x4d\xfb\x5d\xfb\x43\xfb\x53\xab\xd6\x6a\x34\x47\xab\x95\x44\x52\xc9\xa4\xbb\x3c\xac\x26\xa5\xd4\xa5\x21\x4d\x19\x24\x83\x65\x88\x0c\x95\xcd\x64\x98\x6c\x2e\xc3\x65\x0b\x19\x21\x23\x65\x4b\x19\x25\x5b\xc9\xd6\xb2\x8d\x6c\x2b\xdb\xc9\xf6\xb2\x83\xec\x28\x3b\xc9\x68\x19\x23\x3b\xcb\x2e\xb2\xab\xec\x26\xbb\xcb\x1e\xb2\xa7\xec\x25\xcf\x93\xbd\xe5\xf9\xb2\x8f\xec\x2b\x63\x65\x3f\x19\x27\x3d\xd2\x92\xb6\xf4\xca\x78\x99\x20\xfb\xcb\x44\x39\x40\x0e\x94\x83\xe4\x60\x79\x81\x1c\x22\x93\x64\xb2\x4c\x91\xa9\x32\x4d\xa6\xcb\x0c\x39\x54\x0e\x93\xc3\xe5\x85\x72\x84\x1c\x29\x47\xc9\xd1\x72\x8c\x1c\x2b\x2f\x92\xe3\xe4\x78\x39\x41\x4e\x94\x93\xe4\x64\x39\x45\x66\xca\xa9\x72\x9a\x9c\x2e\xb3\xe4\x0c\x39\x53\xce\x92\xd9\x72\xb6\xcc\x91\xb9\x32\x4f\xe6\xcb\x39\xb2\x40\x16\xca\xb9\x72\x9e\x2c\x92\xc5\xb2\x44\xfa\x64\xa9\x9c\x2f\xcb\x64\xb9\xac\x90\x95\x72\x81\x5c\x28\x17\xc9\xc5\x72\x89\x5c\x2a\x2f\x96\x97\xc8\x65\x72\xb9\x5c\x21\x2f\x95\x97\xc9\xcb\xe5\x15\xf2\x4a\x79\x95\xbc\x5a\x56\xc9\x6b\xe4\xbf\xe4\x4a\x79\xad\xbc\x4e\x5e\x2f\x57\xc9\x1b\xe4\x8d\xf2\x26\x79\xb3\x5c\x2d\x6f\x91\xb7\xca\x7f\xcb\xdb\xe4\xed\xf2\x0e\x79\xa7\xbc\x4b\xde\x2d\xef\x91\xf7\xca\xfb\xe4\xfd\x72\x8d\x7c\x40\x3e\x28\x1f\x92\x0f\xcb\x47\xe4\xa3\xf2\x31\xf9\xb8\x7c\x42\x3e\x29\x9f\x92\x6b\xe5\x3a\xb9\x5e\x3e\x2d\x37\xc8\x67\xe4\xb3\xf2\x39\xf9\xbc\x7c\x41\xbe\x28\x5f\x92\x2f\xcb\x57\xe4\xab\xf2\x35\xf9\xba\x7c\x43\xbe\x29\x37\xca\x4d\x72\xb3\xdc\x22\xdf\x92\x6f\xcb\x77\xe4\xbb\xf2\x3d\xf9\xbe\xdc\x2a\xb7\xc9\xed\xf2\x03\xb9\x43\x7e\x28\x77\xca\x5d\x72\xb7\xdc\x23\xf7\xca\x8f\xe4\xc7\xf2\x13\xf9\xa9\xfc\x4c\xee\x93\x9f\xcb\xfd\xf2\x0b\xf9\xa5\xfc\x4a\x1e\x90\x07\xe5\x21\xf9\xb5\x3c\x2c\xbf\x91\x47\xe4\x51\x79\x4c\x7e\x2b\xbf\x93\xdf\xcb\x1f\xe4\x8f\xf2\xb8\xfc\x49\x9e\x90\x27\xe5\xcf\xf2\x94\xfc\x45\x9e\x96\xbf\xca\xdf\xe4\xef\xf2\x0f\xf9\xa7\xac\x96\x35\xd2\x91\xb5\x3a\xd1\xa9\xee\x2e\x4c\x27\x74\x4d\x97\xba\xae\x1b\xba\xa9\x07\xe9\xc1\x7a\x88\x1e\xaa\x37\xd3\xc3\xf4\xe6\x7a\xb8\xde\x42\x8f\xd0\x23\xf5\x96\x7a\x94\xde\x4a\x6f\xad\xb7\xd1\xdb\xea\xed\xf4\xf6\x7a\x07\xbd\xa3\xde\x49\x8f\xd6\x63\xf4\xce\x7a\x17\xbd\xab\xde\x4d\xef\xae\xf7\xd0\x7b\xea\xbd\xf4\xf3\xf4\xde\xfa\xf9\x7a\x1f\xbd\xaf\x1e\xab\xf7\xd3\xe3\x74\x8f\x6e\xe9\xb6\xee\xd5\xe3\xf5\x04\xbd\xbf\x9e\xa8\x0f\xd0\x07\xea\x83\xf4\xc1\xfa\x05\xfa\x10\x3d\x49\x4f\xd6\x53\xf4\x54\x3d\x4d\x4f\xd7\x33\xf4\xa1\xfa\x30\x7d\xb8\x7e\xa1\x3e\x42\x1f\xa9\x8f\xd2\x47\xeb\x63\xf4\xb1\xfa\x45\xfa\x38\x7d\xbc\x3e\x41\x9f\xa8\x4f\xd2\x27\xeb\x53\xf4\x4c\x7d\xaa\x3e\x4d\x9f\xae\x67\xe9\x33\xf4\x99\xfa\x2c\x3d\x5b\x9f\xad\xe7\xe8\xb9\x7a\x9e\x9e\xaf\xcf\xd1\x0b\xf4\x42\x7d\xae\x3e\x4f\x2f\xd2\x8b\xf5\x12\xdd\xa7\x97\xea\xf3\xf5\x32\xbd\x5c\xaf\xd0\x2b\xf5\x05\xfa\x42\x7d\x91\xbe\x58\x5f\xa2\x2f\xd5\x2f\xd6\x2f\xd1\x97\xe9\xcb\xf5\x15\xfa\xa5\xfa\x65\xfa\xe5\xfa\x15\xfa\x95\xfa\x55\xfa\xd5\x7a\x95\x7e\x8d\xfe\x2f\x7d\xa5\x7e\xad\x7e\x9d\x7e\xbd\xbe\x4a\xbf\x41\xbf\x51\xbf\x49\xbf\x59\x5f\xad\xdf\xa2\xdf\xaa\xff\x5b\xbf\x4d\xbf\x5d\xbf\x43\xbf\x53\xbf\x4b\xbf\x5b\xbf\x47\xbf\x57\xbf\x4f\xbf\x5f\x5f\xa3\x3f\xa0\x3f\xa8\x3f\xa4\x3f\xac\x3f\xa2\x3f\xaa\x3f\xa6\x3f\xae\x3f\xa1\x3f\xa9\x3f\xa5\xaf\xd5\xd7\xe9\xeb\xf5\xa7\xf5\x0d\xfa\x33\xfa\xb3\xfa\x73\xfa\xf3\xfa\x0b\xfa\x8b\xfa\x4b\xfa\xcb\xfa\x2b\xfa\xab\xfa\x6b\xfa\xeb\xfa\x1b\xfa\x9b\xfa\x46\x7d\x93\xbe\x59\xdf\xa2\xbf\xa5\xbf\xad\xbf\xa3\xbf\xab\xbf\xa7\xbf\xaf\x6f\xd5\xb7\xe9\xdb\xf5\x0f\xf4\x1d\xfa\x87\xfa\x4e\x7d\x97\xbe\x5b\xdf\xa3\xef\xd5\x3f\xd2\x3f\xd6\x3f\xd1\x3f\xd5\x3f\xd3\xf7\xe9\x9f\xeb\xfb\xf5\x2f\xf4\x2f\xf5\xaf\xf4\x03\xfa\x41\xfd\x90\xfe\xb5\x7e\x58\xff\x46\x3f\xa2\x1f\xd5\x8f\xe9\xdf\xea\xdf\xe9\xdf\xeb\x3f\xe8\x3f\xea\xc7\xf5\x9f\xf4\x13\xfa\x49\xfd\x67\xfd\x94\xfe\x8b\x7e\x5a\xff\x55\xff\x4d\xff\x5d\xff\x43\xff\x53\xaf\xd6\x6b\x74\x47\xaf\x35\x08\xd9\x40\x9e\x31\xa8\xc1\x0c\x4e\x9e\x27\x2f\x90\x2d\x86\x20\xcf\x92\xe7\xc8\x5b\x86\x46\x2e\x23\x9b\xc8\xd5\xe4\x09\x43\x1a\xba\x61\x18\xa6\x11\x64\x04\x93\xb7\x8d\x10\x23\xd4\x68\x46\x5e\x27\x6f\x18\x61\x46\x73\xf2\xaa\x11\x6e\xb4\x30\x22\x8c\x48\xa3\xa5\x11\x65\xb4\x32\x5a\x1b\x6d\x8c\xb6\x46\x3b\xa3\xbd\xd1\xc1\xe8\x68\x74\x32\xa2\x8d\x18\xa3\xb3\xd1\xc5\xe8\x4a\x7e\x35\xba\x19\xdd\x8d\x1e\x46\x4f\xa3\x97\x71\x9e\xd1\xdb\x38\xdf\xe8\x63\xf4\x35\x62\x8d\x7e\x46\x9c\xe1\x31\x2c\xc3\x36\xbc\x46\xbc\x91\x60\xf4\x37\x12\x8d\x01\xc6\x40\x72\xad\x31\xc8\x18\x6c\x5c\x60\x0c\x31\x92\x8c\x64\x23\xc5\x48\x35\xd2\x8c\x74\x23\xc3\x18\x6a\x0c\x33\x86\x1b\x17\x1a\x23\x8c\x91\xc6\x28\x72\x9b\x31\x9a\xdc\x41\x6e\x27\xc7\x8d\x31\x64\x33\x79\x88\xdc\x64\x8c\x35\x2e\x22\x77\x91\x47\xc8\x2a\x63\x1c\x59\x4d\x6e\x31\xc6\x1b\x13\x8c\x89\xc6\x24\x63\xb2\x31\xc5\xc8\x34\xa6\x1a\xd3\x8c\xe9\x46\x96\x31\xc3\x98\x69\xcc\x32\xb2\x8d\xd9\x46\x8e\x91\x6b\xe4\x19\xf9\xc6\x1c\xa3\xc0\x28\x34\xe6\x1a\xf3\x8c\x22\xa3\xd8\x28\x31\x7c\x46\xa9\x31\xdf\x28\x33\xca\x8d\x0a\xa3\xd2\x58\x60\x2c\x34\x16\x19\x8b\x8d\x25\xc6\x52\xe3\x62\xe3\x12\x63\x99\xb1\xdc\x58\x61\x5c\x6a\x5c\x66\x5c\x6e\x5c\x61\x5c\x69\x5c\x65\x5c\x6d\x54\x19\xd7\x18\xff\x32\x56\x1a\xd7\x1a\xd7\x19\xd7\x1b\xab\xc8\x4b\xc6\x0d\xc6\x8d\xc6\x4d\xc6\xcd\xc6\x6a\xe3\x16\xe3\x56\xe3\xdf\xc6\x6d\xc6\xed\xc6\x1d\xc6\x9d\xc6\x5d\xc6\xdd\xc6\x3d\xc6\xbd\xc6\x7d\xc6\xfd\xc6\x1a\xe3\x01\xe3\x41\xe3\x21\xe3\x61\xe3\x11\xe3\x51\xe3\x31\xe3\x71\xe3\x09\xe3\x49\xe3\x29\x63\xad\xb1\xce\x58\x6f\x3c\x6d\x6c\x30\x9e\x31\x9e\x35\x9e\x33\x9e\x37\x5e\x30\x5e\x34\x5e\x32\x5e\x36\x5e\x31\x5e\x35\x5e\x33\x5e\x37\xde\x30\xde\x34\x36\x1a\x9b\x8c\xcd\xc6\x16\xe3\x2d\xe3\x6d\xe3\x1d\xe3\x5d\xe3\x3d\xf2\x26\xd9\x68\xbc\x6f\x6c\x35\xb6\x19\xdb\x8d\x0f\x8c\x1d\xc6\x87\xc6\x4e\x63\x97\xb1\xdb\xd8\x63\xec\x35\x3e\x32\x3e\x36\x3e\x31\x3e\x35\x3e\x33\xf6\x19\x9f\x1b\xfb\x8d\x2f\x8c\x2f\x8d\xaf\x8c\x03\xc6\x41\xe3\x90\xf1\xb5\x71\xd8\xf8\xc6\x38\x62\x1c\x35\x8e\x19\xdf\x1a\xdf\x19\xdf\x1b\x3f\x18\x3f\x1a\xc7\x8d\x9f\x8c\x13\xc6\x49\xe3\x67\xe3\x94\xf1\x8b\x71\xda\xf8\xd5\xf8\xcd\xf8\xdd\xf8\xc3\xf8\xd3\xa8\x36\x6a\x0c\xc7\xa8\x35\x89\x49\x4d\x66\x72\x53\x98\x9a\x29\x4d\xdd\x34\x4c\xd3\x0c\x32\x83\xcd\x10\x33\xd4\x6c\x66\x86\x99\xcd\xcd\x70\xb3\x85\x19\x61\x46\x9a\x2d\xcd\x28\xb3\x95\xd9\xda\x6c\x63\xb6\x35\xdb\x99\xed\xcd\x0e\x66\x47\xb3\x93\x19\x6d\xc6\x98\x9d\xcd\x2e\x66\x57\xb3\x9b\xd9\xdd\xec\x61\xf6\x34\x7b\x99\xe7\x99\xbd\xcd\xf3\xcd\x3e\x66\x5f\x33\xd6\xec\x67\xc6\x99\x1e\xd3\x32\x6d\xd3\x6b\xc6\x9b\x09\x66\x7f\x33\xd1\x1c\x60\x0e\x34\x07\x99\x83\xcd\x0b\xcc\x21\x66\x92\x99\x6c\xa6\x98\xa9\x66\x9a\x99\x6e\x66\x98\x43\xcd\x61\xe6\x70\xf3\x42\x73\x84\x39\xd2\x1c\x65\x8e\x36\xc7\x98\x63\xcd\x8b\xcc\x71\xe6\x78\x73\x82\x39\xd1\x9c\x64\x4e\x36\xa7\x98\x99\xe6\x54\x73\x9a\x39\xdd\xcc\x32\x67\x98\x33\xcd\x59\x66\xb6\x39\xdb\xcc\x31\x73\xcd\x3c\x33\xdf\x9c\x63\x16\x98\x85\xe6\x5c\x73\x9e\x59\x64\x16\x9b\x25\xa6\xcf\x2c\x35\xe7\x9b\x65\x66\xb9\x59\x61\x56\x9a\x0b\xcc\x85\xe6\x22\x73\xb1\xb9\xc4\x5c\x6a\x5e\x6c\x5e\x62\x2e\x33\x97\x9b\x2b\xcc\x4b\xcd\xcb\xcc\xcb\xcd\x2b\xcc\x2b\xcd\xab\xcc\xab\xcd\x2a\xf3\x1a\xf3\x5f\xe6\x4a\xf3\x5a\xf3\x3a\xf3\x7a\x73\x95\x79\x83\x79\xa3\x79\x93\x79\xb3\xb9\xda\xbc\xc5\xbc\xd5\xfc\xb7\x79\x9b\x79\xbb\x79\x87\x79\xa7\x79\x97\x79\xb7\x79\x8f\x79\xaf\x79\x9f\x79\xbf\xb9\xc6\x7c\xc0\x7c\xd0\x7c\xc8\x7c\xd8\x7c\xc4\x7c\xd4\x7c\xcc\x7c\xdc\x7c\xc2\x7c\xd2\x7c\xca\x5c\x6b\xae\x33\xd7\x9b\x4f\x9b\x1b\xcc\x67\xcc\x67\xcd\xe7\xcc\xe7\xcd\x17\xcc\x17\xcd\x97\xcc\x97\xcd\x57\xcc\x57\xcd\xd7\xcc\xd7\xcd\x37\xcc\x37\xcd\x8d\xe6\x26\x73\xb3\xb9\xc5\x7c\xcb\x7c\xdb\x7c\xc7\x7c\xd7\x7c\xcf\x7c\xdf\xdc\x6a\x6e\x33\xb7\x9b\x1f\x98\x3b\xcc\x0f\xcd\x9d\xe6\x2e\x73\xb7\xb9\xc7\xdc\x6b\x7e\x64\x7e\x6c\x7e\x62\x7e\x6a\x7e\x66\xee\x33\x3f\x37\xf7\x9b\x5f\x98\x5f\x9a\x5f\x99\x07\xcc\x83\xe6\x21\xf3\x6b\xf3\xb0\xf9\x8d\x79\xc4\x3c\x6a\x1e\x33\xbf\x35\xbf\x33\xbf\x37\x7f\x30\x7f\x34\x8f\x9b\x3f\x99\x27\xcc\x93\xe6\xcf\xe6\x29\xf3\x17\xf3\xb4\xf9\xab\xf9\x9b\xf9\xbb\xf9\x87\xf9\xa7\x59\x6d\xd6\x98\x8e\x59\x1b\x44\x82\x68\x10\x0b\xe2\x41\x22\x48\x0b\x92\x41\x7a\x90\x11\x64\x06\x05\x05\x05\x07\x85\x04\x85\x06\x35\x0b\x0a\x0b\x6a\x1e\x14\x1e\xd4\x22\x28\x22\x28\x52\xaf\x2c\x29\xec\xd7\x2f\xb9\x1f\x6e\xd3\x4c\xdf\x82\xbc\xb2\xf2\x1c\x5f\x59\x1e\x2f\xae\x8c\x93\xc5\x85\xb9\xb9\xbe\x0a\x3d\xb9\xd8\x7d\xb0\x5c\xa2\x67\xfb\xb7\x32\x79\x76\x59\xde\x82\x3c\x99\xad\x36\x7a\xb2\x6f\x8e\xaf\x24\x6f\x9e\x9e\xed\xdf\x06\xa7\xe6\x14\x96\xe5\x54\x16\xe7\x17\xe5\x2d\x0a\xce\x39\x53\x0e\x4a\x05\x53\xd9\x39\x39\x79\x25\x15\x41\x39\xf5\x45\x99\x96\x93\xed\x9a\xcc\xf5\x6f\xd2\xc0\x7e\x76\x85\x9e\x8e\x0e\xf3\xd0\x61\xba\xdf\x61\x9e\xda\x04\xa5\x9f\x31\x94\x57\x5f\xd4\xd3\x31\x8c\x3c\xff\x56\xa6\xfb\x2d\xe6\xa9\x4d\xf0\xd0\x80\xa0\xe6\x04\x04\x35\xf4\x8c\xad\x39\xf5\xc5\x90\xa1\x39\xbe\xe2\xe2\x6c\xfc\x63\x4e\xc0\x1f\xc1\xc3\x02\xec\x14\x9c\x29\x8b\x61\xb3\xb3\xcb\x44\x01\x80\x1c\x5e\x51\x58\x94\x9b\x27\x0b\xd5\x46\x1f\x8e\x35\x29\xc4\x9a\x0c\xf7\xd7\xa4\xd0\x9f\xba\xe1\x18\x73\xa1\x7f\xcb\x86\x5f\xc8\x0a\xe7\x06\x5f\x18\xe0\x63\xee\x99\x72\xc8\x88\xc0\xa8\xe6\x35\xf8\x63\x8e\xfb\x39\x45\x51\x76\x49\x6e\x61\x8e\x1c\x99\x9d\x53\x59\x91\x27\x8b\xd4\x26\x64\x64\xe0\x79\x45\x01\x7f\xc8\x91\xfe\x04\x15\xa9\x8d\x18\x09\xb5\x17\x45\x00\x72\xb4\xff\xfa\x12\xff\xf5\xa3\x03\xaf\x2f\x09\xbc\x7e\xb4\xff\xfa\x12\x7f\x82\x4b\xb2\x4b\x7d\xe5\x15\x65\xbe\xd2\x82\x3c\x9e\x5e\x32\x87\xe7\x95\xcc\xd1\xc7\x60\xe5\x7d\x58\xf9\x31\xfe\xca\xfb\xd4\x26\x74\x4c\x41\x65\xc9\x9c\xec\xb2\xca\xe2\xa2\xec\xca\x8a\x50\x5f\xe0\x5f\x72\x9c\x3f\x86\x32\x7f\x0c\xe3\x02\x63\x28\x0b\x8c\x61\x9c\x3f\x86\x32\xff\x66\xbc\xff\xaa\x72\xb5\x09\x1e\x1f\x90\xc6\xf2\x80\x34\x4e\x08\xb4\x56\x11\x68\x6d\x82\xdf\x4c\x85\x3f\x23\x13\xdc\x26\xad\x70\x9b\x74\xa2\xbf\x49\x2b\xfd\x4d\x3a\x11\x6b\x55\x89\xb5\x9a\xe8\xaf\x55\xa5\xda\x68\x13\xcb\x0a\x4b\xe6\x68\x95\x2e\x86\x4e\x6c\x50\xc3\xca\xc0\xbf\xf4\x89\xd8\xf4\x95\x78\xd7\x4c\x0e\x88\x76\x61\x40\x39\x33\xa0\xbc\xf8\x4c\x59\x4e\xf5\xd7\x75\x89\xda\x04\x4d\x3d\xd3\x8d\x97\xd4\x17\xb5\x22\x5f\xc9\x9c\x72\x75\x6b\xc7\xf5\xef\x87\xdb\x38\xdc\x7a\x70\x6b\xe1\xd6\xc6\xad\x17\xb7\xf1\xb8\x4d\xc0\x6d\x7f\xdc\x26\xe2\x36\x19\xb7\x29\xb8\x4d\xc5\x6d\x1a\x6e\xd3\x71\x9b\xe1\xdf\x26\xa2\xff\x44\xf4\x9f\x88\x7e\x13\xd1\x6f\x22\xfa\x4d\x44\xbf\x89\xe8\x37\x11\xfd\x26\xa2\xdf\x44\xf4\x9b\x88\x7e\x13\xd1\x6f\x22\xfa\x4d\x44\xbf\x89\x19\xda\x98\x02\x5f\x19\x4c\x37\x5d\xf4\xef\x4b\xc6\x3a\x27\xa3\xef\x64\xf4\x9d\x8c\xbe\x93\xd1\x77\x32\xfa\x4e\x46\xdf\xc9\xe8\x3b\x19\x7d\x27\xa3\xef\x64\xf4\x9d\x8c\xbe\x93\xd3\xb5\x89\xca\x67\xe5\x19\x9f\x29\x58\xdf\x14\xf4\x9d\x82\xbe\x53\xd0\x77\x0a\xfa\x4e\x41\xdf\x29\xe8\x3b\x05\x7d\xa7\xa0\xef\x14\xf4\x9d\x82\xbe\x53\xd0\x77\x0a\xfa\x4e\xc1\x7a\xa7\x60\xbe\x53\x31\xdf\xa9\xe8\x3f\x15\xfd\xa7\xa2\xff\x54\xf4\x9f\x8a\xfe\x53\xd1\x7f\x2a\xfa\x4f\x45\xff\xa9\xe8\x3f\x15\xfd\xa7\xa2\xff\x54\xf4\x9f\x8a\xfe\x53\xd1\x7f\x2a\xfa\x4f\x43\xff\x69\xe8\x3f\x0d\xfd\xa7\xa1\xff\x34\xf4\x9f\x86\xfe\xd3\xd0\x7f\x1a\xfa\x4f\x43\xff\x69\xe8\x3f\x0d\xfd\xa7\xa1\xff\x34\xf4\x9f\x86\xfe\xd3\xd0\x7f\x1a\xfa\x4f\x47\xff\xe9\xe8\x3f\x1d\xfd\xa7\xa3\xff\x74\xf4\x9f\x8e\xfe\xd3\xd1\x7f\x3a\xfa\x4f\x47\xff\xe9\xe8\x3f\x1d\xfd\xa7\xa3\xff\x74\xf4\x9f\x8e\xfe\xd3\xd1\x7f\x3a\xfa\xcf\x40\xff\x19\xe8\x3f\x03\xfd\x67\xa0\xff\x0c\xf4\x9f\x81\xfe\x33\xd0\x7f\x06\xfa\xcf\x40\xff\x19\x89\x41\xc9\xee\x58\xe2\xbf\xcd\xb3\xeb\x8b\x7a\x72\xba\x7f\x9b\x9d\xe7\x1f\xed\xc6\x94\x17\x65\x97\x17\xf8\xcb\xbe\x33\x65\x65\xc5\xd3\xaf\x1f\x6e\xe3\x70\xeb\xc1\xad\x85\x5b\x1b\xb7\x5e\xdc\xc6\xe3\x36\x01\xb7\xfd\x71\x9b\x88\xdb\x64\xdc\xa6\xe0\x36\x15\xb7\x69\xb8\x4d\xc7\xad\x3f\x1b\x9e\x38\xf4\x1f\x87\xfe\xe3\xd0\x7f\x1c\xfa\x8f\x43\xff\x71\xe8\x3f\x0e\xfd\xc7\x25\x84\x8c\x0f\x1c\xad\xcb\x03\xfe\xc0\x33\x30\x92\x38\x8c\x24\x0e\x23\x89\xc3\x48\xe2\x30\x92\x38\x8c\xc4\x83\x91\x78\x30\x12\x0f\x46\xe2\xc1\x48\x3c\x18\x89\x07\x23\xf1\x60\x24\x1e\xcc\x84\x07\x33\xe1\xc1\x4c\x78\xd0\xbf\x07\xfd\x7b\xd0\xbf\x07\xfd\x7b\xd0\xbf\x07\xfd\x5b\xe8\xdf\x42\xff\x16\xfa\xb7\xd0\xbf\x85\xfe\x2d\xf4\x6f\xc5\x9b\x73\xfb\xc2\x88\x5e\x94\x57\x5e\x8e\x7b\x30\x02\x0b\x23\xb0\x30\x02\x0b\x23\xb0\x30\x02\x0b\x23\xb0\x30\x02\x0b\x23\xb0\x31\x02\x1b\x23\xb0\x31\x02\x1b\x23\xb0\x31\x02\x1b\x23\xb0\x31\x03\x36\x66\xc0\x46\xff\x36\xfa\xb7\xd1\xbf\x8d\xfe\x6d\xf4\x6f\xa3\x7f\x1b\xfd\xdb\xe8\xdf\x8b\xfe\xbd\xe8\xdf\x8b\xfe\xbd\xe8\xdf\x8b\xfe\xbd\xe8\xdf\x8b\xfe\xbd\xe8\xdf\x8b\xfe\xbd\xe8\xdf\x8b\xfe\xbd\xe8\xdf\x8b\xfe\xbd\xe8\xdf\x8b\xfe\xbd\xe8\x3f\x1e\xfd\xc7\xa3\xff\x78\xf4\x1f\x8f\xfe\xe3\xd1\x7f\x3c\xfa\x8f\x47\xff\xf1\xe8\x3f\x1e\xfd\xc7\xa3\xff\x78\xf4\x1f\x8f\xfe\xe3\xd1\x7f\x3c\xfa\x8f\x47\xff\xf1\xe8\x3f\x01\xfd\x27\xa0\xff\x04\xf4\x9f\x80\xfe\x13\xd0\x7f\x02\xfa\x4f\x40\xff\x09\xe8\x3f\x01\xfd\x27\xa0\xff\x04\xf4\x9f\x80\xfe\x13\xd0\x7f\x02\xfa\x4f\x40\xff\x09\xe8\x1f\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x07\x95\x80\x27\x11\xfd\xa3\x22\xf0\xa0\x22\xf0\xa0\x22\xf0\xa0\x22\xf0\xa0\x22\xf0\xa0\x22\xf0\xa0\x22\xf0\xa0\x22\xf0\xa0\x22\xf0\xa0\x22\xf0\xa0\x22\xf0\xa0\x22\xf0\x24\xa2\x7f\x9c\xec\x78\x92\xd1\x3f\xaa\x02\x0f\xaa\x02\x0f\xaa\x02\x0f\xaa\x02\x0f\xaa\x02\x0f\xaa\x02\x0f\xaa\x02\x0f\xaa\x02\x0f\xaa\x02\x0f\xaa\x02\x0f\xaa\x02\x0f\xaa\x02\x4f\x32\xfa\x4f\x46\xff\x29\xe8\x1f\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x81\x07\x95\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x15\x80\x07\x19\xdd\x83\x8c\xee\x41\x46\xf7\x20\xa3\x7b\x90\xd1\x3d\xc8\xe8\x1e\x64\x74\x0f\x32\xba\x07\x19\xdd\x83\x8c\xee\x41\x46\xf7\x20\xa3\x7b\x90\xd1\x3d\xc8\xe8\x1e\x64\x74\x0f\x32\xba\x07\x19\xdd\x83\x8c\xee\x41\x46\xf7\x20\xa3\x7b\x90\xd1\x3d\xc8\xe8\x1e\x64\x74\x0f\x32\xba\x07\x19\xdd\x83\x8c\xee\x41\x46\xf7\x64\xa0\xff\x0c\xf4\x9f\x81\xfe\x33\xd0\x7f\x06\xfa\xcf\x40\xff\x19\x19\xe6\x9c\xb2\xec\x05\x79\x40\x7d\xb3\x4d\xc5\xe9\x6e\x49\x1d\xb3\xfa\x79\x4c\x35\x27\x09\xd8\x63\xe3\xd6\x8b\xdb\x78\xdc\x26\xe0\xb6\x7f\x68\x81\xcf\x37\x2f\x7b\xb6\x6f\x41\xe0\x55\xc9\xb8\x4d\xc1\x6d\x2a\x6e\xd3\x70\x9b\x8e\x5b\x7f\x2e\x2c\xe4\x73\x0b\xf9\xdc\x42\x3e\xb7\x90\xcf\x2d\xe4\x73\x0b\xf9\xdc\x42\x3e\xb7\xe2\x30\x8a\xb8\xfe\xb8\x4d\xc4\x2d\xfa\x47\x16\xb7\x90\xc5\x2d\x64\x71\x0b\x59\xdc\x42\x16\xb7\x90\xc5\x2d\x64\x71\xcb\xe3\x09\x01\x8e\x9c\x9d\x57\xe4\x5b\x78\xa6\x52\x48\xe5\x16\x52\xb9\x85\x54\x6e\x21\x95\x5b\x48\xe5\x16\x52\xb9\x85\x54\x6e\x21\x95\x5b\x48\xe5\x16\x52\xb9\x85\x54\x6e\x21\x95\x5b\x48\xe5\x16\x52\xb9\x85\x54\x6e\x21\x95\x5b\x48\xe5\x16\x52\xb9\x65\xa1\x7f\x0b\xfd\x23\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x91\x5b\x48\xe4\x16\x12\xb9\x85\x44\x6e\x21\x51\x5b\x48\xd4\x16\x12\xb1\x85\x44\x6c\x21\x11\x5b\x48\xc4\x56\x42\xba\x56\xe1\x2b\xf1\x95\x87\xe6\x16\xe6\x95\xe5\x95\x17\x96\xab\xbf\x82\x92\x8b\x4a\x0b\xb2\x55\xd1\xcc\x2e\xf1\x55\xe4\x15\xe5\x15\x66\x87\xa4\x97\x96\x17\xc2\xec\x5d\xed\x36\xd2\x2b\xf0\xf8\x70\x1f\x96\x42\xc6\x14\x17\xba\xcf\x1e\xfc\x7f\x4c\x0c\x38\x39\x68\x4c\x71\xde\x1c\xff\x49\xe1\x85\x70\x7a\x03\x5f\x9a\xf2\x25\x52\xf2\x2a\xb2\xb5\xa1\xd9\xa0\xa4\x75\xf4\x23\xa6\xc2\x2e\x0e\x7e\xb4\x09\x05\x50\x12\xae\x23\x6d\x44\x76\x69\x69\xb6\x1c\x99\x5d\x3c\x3b\x37\x9b\x8d\xaa\x64\xa3\x2b\xd9\x94\x42\x1d\x3d\xb3\xb1\x85\x7c\x5c\x81\x4f\x1b\x5f\x38\xa7\x38\x9b\x4f\xc8\xae\xd4\x31\x0a\x3e\xb6\xa0\x90\xa7\xc2\xbf\xb1\xe5\x85\x21\xc3\x03\x22\x08\xc3\x13\xea\xfe\x0e\xca\xae\xaf\x78\x48\x5e\x60\x75\xf3\xea\xaa\x5b\x58\x57\xdd\xc8\xca\x86\x97\xfa\x2b\xa3\xae\x17\xb3\xdd\xca\xcc\x71\x2b\xa3\xe5\xe6\x15\x55\x64\xeb\x68\x4b\x2c\x71\xab\xe4\x1e\xac\x50\x55\x72\x8d\x69\xf3\x54\x95\x8a\xfc\x55\x2a\xa9\x64\x8b\x0a\x75\x9f\xbf\x3e\xbc\xac\xc0\x27\xcb\xdd\xca\xc4\x69\x6a\xc3\x2b\xa0\x4e\xe8\x97\x97\x42\x7d\x72\xe0\x1f\xfc\xa9\xf9\xdc\x04\x87\x04\xe6\x36\xac\x51\x78\x21\xbe\xc0\xd6\xa9\x0c\x6c\x1d\x5f\x7d\xeb\xf8\xfb\x04\x92\xa4\x85\x24\x69\x21\x49\x5a\x48\x92\x16\x92\xa4\x85\x24\x69\x21\x49\x5a\x48\x92\x16\x4e\x93\x2d\x9c\x26\x5b\x38\x4d\xb6\x70\x9a\x6c\xe1\x34\xd9\xc2\x69\xb2\x85\xa4\x6a\x21\xa9\x5a\x48\xaa\x16\x92\xaa\x85\xa4\x6a\x21\xa9\x5a\x48\xaa\x16\x92\xaa\x85\xa4\x6a\x21\xa9\x5a\x48\xaa\x16\x92\xaa\x85\xa4\x6a\x21\xa9\x5a\x48\xaa\x16\x92\xaa\x85\xa4\x6a\x21\xa9\x5a\x48\xaa\x16\x92\xaa\x85\xa4\x6a\x21\xa9\x5a\x48\xaa\x16\x92\xaa\x85\xa4\x6a\x21\xa9\x5a\x48\xaa\x16\x92\xaa\x85\xa4\x6a\x21\xa9\x5a\x48\xaa\x16\x92\xaa\x85\xa4\x6a\x65\xf8\xfd\xdb\x38\x31\xb6\x71\x62\x6c\xe3\xc4\xd8\xc6\x89\xb1\x8d\x74\x6a\x23\x9d\xda\x48\xa7\x36\xd2\xa9\x8d\x13\x63\x1b\x27\xc6\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x4e\x87\x6d\x9c\x0e\xdb\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x1c\x6b\x23\xc7\xda\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x1c\x6c\x23\x07\xdb\xc8\xc1\x36\x72\xb0\x8d\x93\x61\x1b\x27\xc3\x36\x4e\x86\x6d\x9c\x0c\xdb\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x93\x61\x1b\x27\xc3\x36\x4e\x86\x6d\x9c\x0c\xdb\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x93\x61\x1b\x27\xc3\x36\x4e\x86\x6d\x9c\x0c\xdb\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x93\x61\x1b\x27\xc3\x36\x4e\x86\x6d\x9c\x0c\xdb\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x93\x61\x1b\x27\xc3\x36\x4e\x86\x6d\x9c\x0c\xdb\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x93\x61\x1b\x27\xc3\x36\x4e\x86\x6d\x9c\x0c\xdb\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x93\x61\x1b\x27\xc3\x36\x4e\x86\x6d\x9c\x0c\xdb\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x93\x61\x1b\x27\xc3\x36\x4e\x86\x6d\x9c\x0c\xdb\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x93\x61\x1b\x27\xc3\x36\x4e\x86\x6d\x9c\x0c\xdb\x38\x19\xb6\x71\x32\x6c\xe3\x64\xd8\xc6\xc9\xb0\x8d\x8f\xc9\x6d\x7c\x4c\x6e\xe3\xe4\xd8\xc6\xc7\xe4\x36\x4e\x92\x6d\x9c\x24\xdb\x38\x49\xb6\x71\x92\x6c\xe3\x24\xd9\xc6\x49\xb2\x8d\xfc\x6f\x23\xff\xdb\xc8\xff\x36\xf2\xbf\x8d\xfc\x6f\x23\xff\xdb\xc8\xff\x36\xf2\xbf\x9d\xd6\xdf\xcc\xce\x2f\x2c\x8c\xeb\xd7\xbf\x6e\x64\x42\x05\x60\xa3\x02\xb0\x51\x01\xd8\xa8\x00\x6c\x54\x00\x36\x2a\x00\x1b\x15\x80\x8d\x0a\xc0\x46\x05\x60\xa3\x02\xb0\x51\x01\xd8\xa8\x00\x6c\x54\x00\x36\x2a\x00\x1b\x15\x80\x8d\x0a\xc0\x46\x05\x60\xa3\x02\xb0\x51\x01\xd8\xa8\x00\x6c\x54\x00\x36\x2a\x00\x1b\x15\x80\x8d\x0a\xc0\x46\x05\x60\xa3\x02\xb0\x51\x01\xd8\xa8\x00\x6c\x54\x00\x36\x2a\x00\x1b\x15\x80\x8d\x0a\xc0\x46\x05\x60\xa3\x02\xb0\x51\x01\xd8\xa8\x00\x6c\x54\x00\x36\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x2a\x00\x2f\x32\xba\x17\x19\xdd\x8b\x8c\xee\x45\x46\xf7\xe2\xc8\xe1\xc5\x91\xc3\x8b\x23\x87\x17\x47\x0e\x2f\x8e\x1c\x5e\x1c\x39\xbc\x38\x72\x78\x71\xe4\xf0\xe2\xc8\xe1\xc5\x91\xe3\xff\xd8\x7b\x1b\x30\xab\x8a\x33\x4f\xbc\xce\xa9\x73\x6f\xdf\x7b\xfb\x83\x06\x3b\x0e\x10\x40\x82\x3c\x19\x27\x0f\x4f\xfe\xf4\xed\xbe\x5f\x86\x38\xf6\x47\x55\x94\x10\xf5\x4f\x00\x91\x10\xb5\xa1\x6f\x73\x5b\x9b\xee\xa6\x3f\xf8\x30\x46\x59\xd7\x71\x13\x31\x91\x98\x8c\xeb\xb2\xae\xcb\xba\xae\x22\x71\x19\x87\x61\xdd\x8c\xc3\x66\x24\x31\x8a\x86\x56\x07\x01\x21\x10\x47\x40\x10\x0d\x0a\x62\x83\xc8\x90\xbe\xfb\x56\x9d\xdf\xbd\xa7\xee\xe9\xdb\xd8\xe8\x98\x4d\xf6\xd9\xa7\x9f\xaa\x7a\xab\xce\x5b\xef\xef\xad\xb7\xea\x9c\xf7\xad\x73\xce\xed\x13\xc3\x95\x23\x86\x2b\x47\x2c\x95\xc3\x81\xde\xb8\x72\xc4\x70\xe5\x88\xe1\xca\x11\xc3\x95\x23\x86\x2b\x47\x0c\x57\x8e\x18\xae\x1c\x31\x5c\x39\x62\xb8\x72\xc4\x70\xe5\x88\xe1\xca\x11\xc3\x95\x23\x86\x2b\x47\x0c\x57\x8e\x18\xae\x1c\x31\x5c\x39\x62\x75\x32\xd0\x9d\x49\x2f\x6d\x8a\xd0\xde\xa1\xa9\xa5\x3b\xbd\xa8\xa3\xcd\x25\x3b\x29\xcb\x94\x6a\x72\x49\xd3\xe2\xa6\x9e\xee\x40\xa6\xb5\xab\x75\x49\xa0\xa7\x9b\xa2\xf2\x80\x66\x0c\x68\x9e\x60\xee\x70\x07\x6d\x04\x5c\xa1\xf5\x75\xc1\x25\xbd\x0b\x7a\x7b\xba\x83\xcd\x4d\x8b\xd2\xdd\x99\xc0\xe2\x74\x4f\x7a\x51\x60\x71\xd3\x92\xa6\x16\xa7\xab\xa9\x25\x4d\x3d\xbb\xd3\x4b\x4a\xd4\x0f\x0e\xd5\x23\xf2\x6e\x5d\x84\xba\x3b\x08\xb5\xbb\x77\x49\xb8\xb7\xb3\x33\xdd\x75\x83\x6a\x6a\xeb\x58\x96\xee\x52\xef\x4c\x68\xb9\x0d\xf1\x52\x17\x6c\x09\x01\xb7\x3b\x4d\x6d\xe9\x16\x4e\x1b\x96\xc0\xa2\xd6\xc5\xe9\xb6\x40\x33\xd5\x7b\xec\x4c\x9a\x2f\x6d\x5a\x1a\xb8\xa5\x69\x45\x6b\x3b\xa7\xad\x0a\xef\xa1\xb4\xa2\xa3\x39\xd4\xd2\xda\xde\xd4\x76\x73\x53\x0b\xa7\x14\x20\x55\xd3\x68\x5a\x9c\x5e\xcc\x29\xb9\x95\xf6\xde\x76\x4e\x29\xd8\x4d\xc7\x6f\xce\x38\x4a\x48\x89\x3e\xd0\x99\xb6\x3b\xd3\x11\x4d\xf6\x74\xd3\x56\x25\xa0\x73\xbe\xa4\x83\x06\x44\x23\x74\xd4\x50\x68\x8f\xb3\x34\x48\xe0\x4b\xdd\x82\x40\x83\x94\x54\xb1\x48\xed\x64\x32\x61\x2a\xba\x33\x24\x53\x9b\xa9\xba\xd1\x3d\x57\xa8\xac\x46\x19\x45\x59\x83\xb2\x16\x65\x0c\x65\x1c\x65\x02\x65\x12\x65\x0a\x65\x1d\xca\x7a\x94\x0d\x28\x1b\x51\x0a\x94\xd2\x2d\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\x7e\x35\xf0\xab\x81\x5f\x0d\xfc\x6a\xe0\x57\x03\xbf\x1a\xf8\xd5\xc0\xaf\x06\x7e\x35\xf0\xa3\xc0\x8f\x02\x3f\x0a\xfc\x28\xf0\xa3\xc0\x8f\x02\x3f\x0a\xfc\x28\xf0\xa3\xc0\x8f\x02\x3f\x0a\xfc\x28\xf0\xa3\xc0\x8f\x02\x3f\x0a\xfc\x28\xf0\x6b\x80\x5f\x03\xfc\x1a\xe0\xd7\x00\xbf\x06\xf8\x35\xc0\xaf\x01\x7e\x0d\xf0\x6b\x80\x5f\x03\xfc\x1a\xe0\xd7\x00\xbf\x06\xf8\x35\xc0\xaf\x01\x7e\x0d\xf0\x6b\x81\x5f\x0b\xfc\x5a\xe0\xd7\x02\xbf\x16\xf8\xb5\xc0\xaf\x05\x7e\x2d\xf0\x6b\x81\x5f\x0b\xfc\x5a\xe0\xd7\x02\xbf\x16\xf8\xb5\xc0\xaf\x05\x7e\x2d\xf0\x63\xc0\x8f\x01\x3f\x06\xfc\x18\xf0\x63\xc0\x8f\x01\x3f\x06\xfc\x18\xf0\x63\xc0\x8f\x01\x3f\x06\xfc\x18\xf0\x63\xc0\x8f\x01\x3f\x06\xfc\x18\xf0\xe3\xc0\x8f\x03\x3f\x0e\xfc\x38\xf0\xe3\xc0\x8f\x03\x3f\x0e\xfc\x38\xf0\xe3\xc0\x8f\x03\x3f\x0e\xfc\x38\xf0\xe3\xc0\x8f\x03\x3f\x0e\xfc\x38\xf0\x13\xc0\x4f\x00\x3f\x01\xfc\x04\xf0\x13\xc0\x4f\x00\x3f\x01\xfc\x04\xf0\x13\xc0\x4f\x00\x3f\x01\xfc\x04\xf0\x13\xc0\x4f\x00\x3f\x01\xfc\x04\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x93\xc0\x4f\x02\x3f\x09\xfc\x24\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\x53\xc0\x4f\x01\x3f\x05\xfc\x14\xf0\xeb\x80\x5f\x07\xfc\x3a\xe0\xd7\x01\xbf\x0e\xf8\x75\xc0\xaf\x03\x7e\x1d\xf0\xeb\x80\x5f\x07\xfc\x3a\xe0\xd7\x01\xbf\x0e\xf8\x75\xc0\xaf\x03\x7e\x1d\xf0\xeb\x81\x5f\x0f\xfc\x7a\xe0\xd7\x03\xbf\x1e\xf8\xf5\xc0\xaf\x07\x7e\x3d\xf0\xeb\x81\x5f\x0f\xfc\x7a\xe0\xd7\x03\xbf\x1e\xf8\xf5\xc0\xaf\x07\x7e\x3d\xf0\x1b\x80\xdf\x00\xfc\x06\xe0\x37\x00\xbf\x01\xf8\x0d\xc0\x6f\x00\x7e\x03\xf0\x1b\x80\xdf\x00\xfc\x06\xe0\x4b\xe0\xb8\x31\x59\xb5\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x44\x42\x06\xaf\xd5\xcf\x3a\x83\xcb\xdc\xe2\x5a\xf7\x25\xc7\x65\xba\x08\x5f\x9b\xbb\xc1\x1e\x5e\x96\xa3\xdc\x7e\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x04\xfc\x8c\x80\x9f\x11\xf0\x33\x02\x7e\x46\xc0\xcf\x08\xf8\x19\x01\x3f\x23\xe0\x67\x44\x4a\x84\xeb\x72\xcf\x2b\xc3\x4d\x39\x2a\x52\x97\x7f\x32\x1b\x69\xca\x93\x95\x75\xde\x4b\x9f\xda\x0c\x95\x4d\xfe\x06\x83\x43\x9b\xcd\xe4\xd0\x0d\x55\x06\x47\x5e\x70\x55\x53\x91\x46\x53\x96\x7e\xb2\x6c\xca\xd2\x0d\x17\x18\x1c\x39\xcd\x2f\x68\x1a\xdc\x56\xea\xbe\x24\xee\xbe\x90\xd6\x64\xd0\x6e\xbb\xd6\x0b\xed\x9a\x1e\xe1\xb6\xe7\x35\x19\xd1\x54\x58\x47\x3f\xad\x03\xfa\x69\xba\xc2\x6d\xcf\xc1\x56\x34\x15\x54\xc3\x22\x4f\xe5\xdb\x22\xc2\xb3\xb3\x27\x3f\x28\xdc\x97\x7c\x5d\xa9\x95\xc2\x6f\xe4\xb4\xbf\x41\xf8\xad\x9e\xf6\x5b\x5d\x14\xb3\x7a\xba\x98\xd5\x85\xdf\xea\x69\xbf\xd5\x45\x11\xab\xa7\x07\xb7\x45\xae\xf4\xc6\xd6\x9a\x27\xc3\x57\xe6\xad\xd0\x9a\xa7\xae\xce\x53\x1d\xf9\xde\x57\x7b\xbd\x3b\x3c\xed\xae\xf6\x0f\xbd\xc3\xdf\x70\xb5\xdf\x16\x1d\x7e\x5b\x5c\x5d\xcc\x16\x1d\xc5\x6c\x71\xb5\xdf\x16\x1d\x7e\x5b\x5c\x5d\xc4\x16\x1d\x45\x6c\xa1\x5f\x00\x76\x5f\x9c\xec\xf0\x48\xdd\xaa\x95\x72\x5b\x35\x59\xa1\x5b\xf3\x4a\x54\x74\x14\x54\xdd\x3e\x1a\xdc\xed\xa3\xc9\x72\xdd\x9a\x43\x2b\xef\x30\x6b\xe1\xd9\x79\xaa\x37\xaf\xcf\x6c\x4f\x60\xaf\x47\xce\xf6\x54\xeb\xf5\xc8\xd9\x9e\x96\xbd\x9e\x96\xb3\x0b\xb5\xec\x2d\xd4\x72\xb6\xa7\x65\xaf\xa7\xe5\xec\x02\x2d\x7b\xcd\x5a\xf0\x3a\xf7\x32\xbb\x42\x17\xe1\xeb\xf2\x3a\xaf\xc8\xeb\x7c\x9d\x27\x7e\x85\x77\xae\x5c\xe7\x9e\x2b\x2b\xdc\x17\xe2\xd5\x35\x4d\x22\x66\x93\x88\xd9\x24\x62\x36\x89\x98\x4d\x22\x66\x93\x88\xd9\x24\x62\x36\x89\x98\x4d\x22\x66\x93\x88\xd9\x24\x62\x36\x89\x98\x4d\x22\x66\x93\x88\xd9\x24\x62\x36\x89\x98\x4d\x22\x66\x93\x88\xd9\x24\x62\x36\x89\x98\x4d\x22\x66\x93\x88\xd9\x24\x62\x34\x89\x18\x4d\x22\x46\x93\x88\xd1\x24\x62\x34\x89\x18\x4d\x22\x26\x93\x88\xc9\x24\x62\x32\x89\x98\x4c\x22\x26\x93\x88\xc9\x24\x62\x32\x89\x98\x4c\x22\x26\x93\x88\xc9\x24\x62\x32\x89\x98\x4c\x22\x26\x93\xd1\x1c\x1e\xc6\x87\x98\x4c\x22\x26\x93\x88\xc9\x24\x62\x32\x89\x98\x4c\x22\x26\x93\x88\xc9\x24\x62\x32\x89\x98\x4c\x22\x26\x93\x88\xc9\x24\x62\x32\x89\x98\x4c\x22\x26\x93\x88\xc9\x24\x62\x32\x89\x98\x4c\x22\x26\x93\x88\xc9\x24\x62\x32\x89\x98\x4c\x22\x26\x93\x88\xc9\x24\x62\x30\x89\x18\x4c\x22\x06\x93\x88\xc1\x24\x62\x30\x89\x18\x4c\x22\xe6\x92\x88\xb9\x24\x62\x2e\x89\x98\x4b\x22\xe6\x92\x88\xb9\x24\x62\x2e\x89\x98\x4b\x22\xd6\x92\x88\xb1\x64\x2c\x27\x17\xfa\x23\xa6\x92\x88\xa9\x24\x62\x2a\x89\x98\x4a\x22\xa6\x92\x88\xa9\x24\x62\x2a\x89\x98\x4a\x22\xa6\x92\x88\xa9\x24\x62\x2a\x89\x98\x4a\x22\xa6\x92\x88\xa9\x24\x62\x2a\x89\x98\x4a\x22\xa6\x92\x88\xa9\x24\x62\x2a\x89\x98\x4a\x22\xa6\x92\x88\xa9\x24\x62\x2a\x89\x98\x4a\x22\xa6\x92\x88\xa9\x24\x62\x2a\x89\x98\x4a\x22\xa6\x92\x88\xa9\x24\xf6\xea\x12\x7b\x75\x89\xbd\xba\xc4\x5e\x5d\x62\xaf\x2e\xb1\x57\x97\x88\xa1\x24\x62\x28\x89\x18\x4a\x22\x86\x92\x88\xa1\x24\x62\x28\x89\x18\x4a\x26\x73\x78\x18\x2f\x62\x28\x89\x18\x4a\x22\x86\x92\x88\xa1\x24\x62\x28\x89\x18\x4a\x22\x86\x92\x88\xa1\x24\x62\x28\x89\x18\x4a\x22\x86\x92\x88\xa1\x24\x62\x28\x89\xbd\xba\xc4\x5e\x5d\x62\xaf\x2e\xb1\x57\x97\xd8\xab\x4b\xec\xd5\x25\xf6\xea\x12\x7b\x75\x89\xbd\xba\xc4\x5e\x5d\x62\xaf\x2e\xb1\x57\x97\xd8\xab\x4b\xec\xd5\x25\xf6\xea\x12\x7b\x75\x89\xbd\xba\xc4\x5e\x5d\x62\xaf\x2e\xb1\x57\x97\xd8\xab\x4b\xec\xd5\x25\xf6\xea\x12\x7b\x75\x89\xbd\xba\xc4\x1e\x5d\x62\x8f\x2e\xb1\x47\x97\xd8\xa3\x4b\xec\xd1\x25\xf6\xe8\x12\x7b\x74\x89\x3d\xba\xc4\x1e\x5d\x62\x8f\x2e\xb1\x47\x97\xd8\xa3\x4b\xec\xd1\x25\xf6\xe8\x12\x7b\x74\x89\xbd\xb9\xc4\xde\x5c\x62\x6f\x2e\xb1\x37\x97\xd8\x9b\xcb\x06\xe0\x36\x00\xb7\x01\xb8\x0d\xc0\x6d\x00\x6e\x23\x70\x1b\x81\xdb\x08\xdc\x46\xe0\x36\x02\xaf\x11\x78\x8d\xc0\x6b\x04\x5e\x23\xf0\x1a\x81\xd7\x08\x9c\x46\xe0\x34\x02\x47\x00\x47\x00\x47\x00\x47\x00\x47\x60\x7c\x02\xf3\x2a\x80\x2b\x80\x2b\x80\x2b\x80\x2b\x80\x2b\x80\x2b\x30\x4e\x01\x7c\x01\x7c\x01\x7c\x09\x3c\x09\x3c\x09\x3c\x09\x1c\x09\x1c\x09\x1c\x09\x1c\x09\x1c\x09\x1c\x09\x1c\x09\x1c\xf7\x1e\x48\x74\xaa\xeb\x47\xa9\xac\x46\x19\x45\x59\x83\xb2\x16\x65\x0c\x65\x1c\x65\x02\x65\x12\x65\x0a\x65\x1d\xca\x7a\x94\x0d\x28\x1b\x51\xe6\x70\xa5\x5b\x56\x03\xaf\x1a\xf2\xab\xe3\xe5\xfa\x5f\xdd\xe9\x1f\x85\x36\x2f\x68\x2b\x5f\xd2\xdb\xa1\xfe\xb1\xaa\xfa\x9d\x68\xba\x19\x3c\xe8\x1b\x05\x56\x14\x58\x51\x60\x45\x81\x15\x05\x56\x54\x06\x17\xb7\xb6\xeb\x9f\xea\xa5\x17\x76\xb4\x43\x4a\x4d\x6d\x38\xbd\x7c\x61\x5b\xd3\x62\x42\x09\x77\x35\x35\xab\x7f\xdf\x98\x5e\xee\x1e\x8b\xa1\x67\x1c\x08\x71\x20\xc4\x81\x10\x07\x42\x3c\xc7\x27\xcb\x5a\x3a\x7a\xbb\xba\x7b\x3b\xd3\x5d\xad\x1d\x5d\x65\x2d\xad\x4b\xd3\xb9\x4a\x79\x37\x29\xdf\x9e\xaf\xa5\xd5\x3f\x3a\xce\xd5\xc2\xf9\x76\x57\x4e\x0a\xb3\x91\xc2\x6c\xa4\x60\x9d\x14\x66\x23\x85\xd9\xa8\x03\x5f\x1d\xf8\xea\xa2\x4e\x5b\x6b\x57\x13\x2a\x30\x65\x5d\x3c\xd8\x99\xee\x4e\xf7\xe4\x9a\x31\x53\x75\xa9\x60\x77\x26\xbd\x24\xdd\xe6\x34\x77\xb4\x2f\x72\xd4\x3f\x91\xc4\x01\x0c\xaa\x0e\x83\xaa\x83\x99\xeb\x01\x56\x0f\xb0\x7a\x28\x55\x0f\xa5\xea\xa1\x54\x3d\x70\xdd\x47\xac\xd1\x6a\x2c\x99\x6a\x37\x24\xa2\x32\x8e\x32\xc1\xaf\xce\x2c\x0e\xa7\xbb\x7b\x5a\x17\x37\xf5\x60\x52\xab\x5d\xc7\x4c\xa5\x08\x75\xb4\xa7\x7b\x32\xad\x5d\xcd\xe1\x9e\x65\x1d\x9a\xe8\x0e\x53\x93\x36\x5c\xa6\xac\x27\xd3\x95\x06\xdd\x5d\xaa\xec\x0c\xba\x4c\x9b\x19\x15\x57\x54\xb2\x36\xdc\xd4\xd5\xd5\xb1\xac\x2d\xdd\xd2\x53\xa2\xa9\xde\xce\x88\x2e\xf5\x7f\x9b\x76\x0f\x36\x77\x2c\x6b\x77\xa9\x05\x04\x16\x06\x5b\x73\x7b\x59\x9e\x5a\xd0\xad\x63\xce\x28\x7e\xa6\x14\x8d\x56\xc7\x22\x1d\x5d\x3d\x19\xf5\x4b\xca\xa6\xb6\xb2\xd6\xf6\x1e\xb5\x36\xf5\xbf\xee\x2d\x4d\x2f\xe9\x6d\x5d\x4a\xeb\xa8\x7d\x61\x3a\x90\xe9\xe8\xed\x4e\x97\xd3\xd2\x6d\xeb\x58\xa4\x16\x57\x7b\x47\x4f\x44\x31\x53\xf4\xdb\xd6\xd3\x99\x27\x17\xe8\x87\x77\x51\x3c\x19\x8e\xe2\x89\x70\x14\x4f\x72\xa3\x78\x62\x4b\x65\x2d\xca\x24\x4a\x1c\x8f\xa2\x1d\xab\x3f\x56\x83\x7a\x0d\xea\x31\xf4\x77\x23\x1d\x2a\x21\xdf\x8d\x74\xa8\x04\xbf\x1b\xe9\x50\x19\x47\x99\x40\x09\x3c\x37\xe2\xa1\xb2\x0e\x65\x3d\xca\x1c\x4e\x23\x4a\x81\xd2\x5d\x3e\xb1\x38\xf0\xe3\xc0\x8f\x03\x3f\x0e\xfc\x38\xf0\xe3\xc0\x8f\x03\x3f\x0e\xfc\x38\xf0\xe3\xc0\xc7\x39\x19\xc3\x39\x19\x53\xe7\x64\xe7\x82\xb6\x8e\x85\x37\x97\xd0\x5c\xa9\x32\xe0\xd6\xda\x5a\xdc\xb2\xab\x07\xf5\x9e\xee\x4c\x53\x73\x3a\xa0\xf3\x92\xe6\x9b\x75\x19\x6e\x69\x6d\x6b\xa3\x0b\x4d\x87\x7b\xe6\xe3\xf9\x72\x14\xcf\x87\xa9\xac\x8f\xb8\x1c\x5d\x34\xc3\x25\x3d\x5d\xad\x4d\x8b\x7a\x3b\xdd\xb2\x0b\xf5\xe6\x76\xb7\x6c\x6b\x09\xaa\x5d\x61\x9b\xbb\x5a\x62\x0d\xb0\x4b\x83\x0c\xb7\xb6\x2f\x5d\xd0\x4b\x42\x7a\x14\xe5\xf2\x44\x3a\x3a\xd3\xed\x68\xec\x5e\xdc\x4a\x4b\xb4\x69\x61\x9a\xd6\xd2\xd2\x7c\x85\x77\xf7\xb6\x07\x5b\xd2\x8b\x69\x35\x39\x2a\x0b\x74\x77\x92\xbe\xce\xc2\xb6\xde\x05\x81\x4c\xba\x89\xd0\x9b\x5b\x9b\x16\xd3\xe5\xac\x74\x71\x6f\x37\xd6\x57\xba\xc2\xa0\xe9\xba\xa6\x35\x88\xbb\x31\x61\xb4\x01\x33\xd1\x80\x99\x68\xc0\x4c\x34\x60\x26\x1a\x30\x13\x0d\x98\x89\x06\xcc\x44\x03\x66\xa2\x01\x33\xd1\x80\x99\x68\xc0\x4c\x34\x60\x26\x1a\x70\x75\x6c\xc0\xd5\xb1\x21\x01\x9c\x04\x70\x12\xc0\x49\x00\x27\x01\x9c\x04\x70\xdc\xd8\x33\x8a\xfb\xda\x75\x89\x7c\x99\x44\x99\x42\x59\x87\xb2\x1e\x65\x03\xca\x46\x94\x02\xa5\x74\x4b\x77\x2f\x45\x65\xb5\x5b\x26\x21\x2f\x09\x79\x49\xc8\x4b\x42\x9e\x1b\x6b\x4a\xf8\x3e\x09\xdf\x47\xa1\x55\x23\x4a\x51\xe6\x3e\xb7\xbe\x41\x3f\xe0\x1f\x41\xa7\x73\x9a\x36\xd2\xea\x3f\x05\xab\x07\xe2\x21\xf5\xdc\x7d\x59\x2b\xad\x2d\xfd\xc4\x5d\x51\xc1\x4c\x5a\x15\x25\x37\x37\xb9\x07\xf4\xe3\x75\x45\x95\xe5\x1e\xb1\xab\x4a\x48\x3d\x04\xd7\x7c\x3d\x4d\x4b\xf5\x51\x92\x7c\x43\x67\x5b\x6f\xb7\xfa\xff\xb3\xa5\xea\x11\x3a\xde\x08\x88\x68\x5a\x93\x23\x75\x93\x7e\x8d\x00\x07\x2b\x8d\x16\xdd\x10\x56\x0a\x69\x55\x23\x8a\x72\x5f\x11\xd0\x8d\x8b\x9b\x3a\x5b\x97\x84\x17\xa4\x7b\x5c\xf6\x52\xfd\xa2\x00\x68\xad\xbc\x4b\x87\x32\x69\x97\x08\x2f\x6d\x5a\x8a\xc3\xfa\x05\x02\xb4\xf6\xe4\x18\xc3\x64\x14\x97\xaa\xc8\xbd\x4e\x80\x03\x79\xaa\x54\x8f\x1d\xad\x34\x70\x50\xed\xbd\x10\x56\xe6\xbe\x5a\xe0\x56\xca\xf1\x6e\x01\xd4\xc8\x11\xa5\xfa\xe5\x02\xf4\x5c\xd2\x01\xc9\x11\x65\x3e\x90\x9e\x09\xc2\x3d\x39\x95\x43\xa4\xbc\xfb\x12\x06\x0d\x58\xbd\x65\xa1\xa6\x43\x95\xe4\x26\x55\xa1\x2d\xa2\xb5\xd3\xd3\x8c\xc7\x22\x12\x8f\x45\x24\x1e\x8b\x48\x3c\x16\x91\x14\x52\x39\xed\x74\x02\xf3\xce\xd6\xea\xf2\x85\x2b\xba\xe8\x2a\xd1\xba\x50\xdf\x0d\xac\xd4\x3f\xe8\x37\x7e\x3b\x3a\xd2\xa0\xbb\xd4\x5b\xe6\xe9\x88\xbe\x05\xf2\x65\x9a\xdf\x6a\x8f\x8c\x7a\x64\x4d\x44\xdf\x97\x71\x19\xf2\x64\xd4\x23\x6b\x2a\xf2\xb7\x47\x34\x53\x61\x35\x5a\x58\xad\x89\xe8\x3b\x27\xae\xb4\x3c\x19\x8d\x68\x6d\x75\xeb\x08\xef\x7e\x96\xae\x97\xe7\xee\xc8\xf8\x34\xa8\xf5\xc8\x98\xa7\x6d\xad\x47\xc6\x0a\x91\x6b\x0b\xab\x31\x0f\xdd\xd0\xa9\xd6\x23\x0d\x86\xb8\x47\x26\x3c\x32\x59\xa0\x59\xb4\xa0\x56\x53\x50\xab\x2d\xa8\xc5\x0a\x6a\x86\xec\x54\xc1\x81\x44\x41\xad\x10\x2c\x55\x51\x60\x94\xa9\x85\xd5\xea\xc2\x6a\xb4\xb0\x5a\x53\x58\xad\x2d\xac\xc6\x4a\xbd\xf9\x99\x6a\xd0\xd5\x06\x1d\x35\x68\x3d\x50\xf5\x13\xdd\x56\x77\xf2\x68\x39\xaa\x9f\x5a\xa9\x9f\x63\x7d\x79\x61\x53\xa7\x51\xaf\xf6\xd5\x1b\x7c\xf5\xa9\x46\x3d\xe1\xeb\x5f\x53\x50\x8f\x8a\x18\x52\xdc\x57\x4f\xf8\xea\x49\x5f\x3d\x65\xd4\xe3\xaa\xf4\xd5\xe3\xbe\x7a\xc2\x57\x4f\xfa\xea\xa9\x52\xa3\x6e\x1c\x4b\xf8\x64\x27\x8a\x1c\x4f\xf8\xea\x49\x5f\xdd\x94\x6d\xf2\x26\x7d\xb2\x93\x3e\xd9\xc9\x22\xfc\x49\x5f\xdd\x94\x6d\x1e\x4b\xf9\x64\xa7\x7c\xb2\x53\x3e\xd9\xa9\x22\xfd\x4d\xd9\x39\x7b\xc7\x73\x73\xe0\xab\xc7\x7d\xf5\x84\xaf\x9e\xf4\xd5\x73\xb2\xe3\x3e\x59\xc5\xea\x09\x5f\x3d\xe9\xab\x9b\xba\x25\x7c\xfd\x13\x3e\xdd\x12\x3e\x79\x09\x9f\xbc\x84\x4f\x37\x93\x37\xe9\x93\x9d\xf4\xc9\x4e\x16\xe1\x4f\xfa\xea\xa6\x6c\xf3\x58\xca\x27\x3b\xe5\x93\x9d\xf2\xc9\x4e\x15\xe9\x6f\xca\xce\xd9\x24\xe1\x9b\xaf\x84\x6f\xbe\x12\xbe\xf9\x4a\xf8\xe6\x2b\xe1\x9b\xaf\x84\x4f\x56\xbc\x48\x3d\xee\xab\x27\x7c\xf5\xa4\xaf\x6e\xca\x36\xfb\xfa\xb1\x8a\x1d\x4f\xfa\xea\xe6\xb8\x93\xbe\xfe\x49\x5f\xff\xa4\x4f\xb7\xa4\x4f\x5e\xd2\xa7\x9b\x79\x2c\xe5\x93\x9d\xf2\xc9\x4e\xf9\x64\xa7\x8a\xf4\x37\x65\xe7\xf4\x4e\xfa\xe6\x2b\xe9\x9b\xaf\xa4\x6f\xbe\x92\xbe\xf9\x4a\xfa\xe6\x2b\xe9\x93\x15\x2f\x52\x8f\xfb\xea\x09\x5f\x3d\xe9\xab\x9b\xb2\xcd\xbe\x09\x9f\xec\x44\x91\xe3\x09\x5f\x3d\xe9\xab\x9b\xb2\x4d\x5e\xff\x38\xfc\xd8\xc5\xf8\x4d\x9b\xa6\x7c\xfd\x53\xbe\xfe\x29\x5f\xff\x94\x4f\xb7\x94\x4f\xb7\x9c\xec\x94\x6f\xbe\x52\xbe\xf9\x4a\xf9\xe6\x2b\xe5\x9b\xaf\x94\x6f\xbe\x52\x3e\x59\xf1\x22\xf5\xb8\xaf\x9e\xf0\xd5\x93\xbe\xba\x29\xdb\xec\x9b\xf0\xc9\x4e\x14\x39\x9e\xf0\xd5\x93\xbe\xba\x29\xdb\xe4\x4d\xfa\x64\x27\x7d\xb2\x93\x45\xf8\x93\xbe\xba\x29\xdb\x3c\xe6\xb7\x91\x7f\x5c\x7e\x5d\xdc\xfe\xb9\x68\xfa\x86\x8e\x1e\xf5\xd9\xa4\xb0\x1b\xa7\x52\x2b\x22\x93\x5a\x5f\xe4\x52\xeb\x8b\x74\x6a\x8a\xd4\x93\x46\xbd\x5a\x45\x3b\x46\xbd\xc1\x57\xaf\xcd\xf1\x97\x2d\x68\xea\x6a\xcd\xfd\x3f\x94\x0b\xf4\xc1\xfa\x6a\x97\xa1\x5a\x09\x9d\x5a\xa4\xad\xda\xd7\x56\x5b\x84\xaf\xd6\xc7\x17\x2f\x22\x2f\x5e\x44\x5e\xbc\x88\xbc\xb8\x4f\x5e\xaa\x88\x7e\xa9\x22\xfa\xa5\x8a\xe8\x97\x2a\xa2\x5f\xaa\x88\x7e\xa9\x22\xfa\xa5\x8a\xe8\x97\x1a\xac\x5f\x43\x6c\xb0\x7e\x05\x6d\x7e\xbe\xda\x22\x7c\x7e\x79\xf1\x22\xf2\xe2\x45\xe4\xc5\x8b\xc8\x2b\x66\xbf\x64\x6e\x91\x15\x69\xf3\xf3\xc5\x8b\xf0\xc5\x7d\xb8\x3e\x79\x05\x6d\x7e\xbe\x78\x11\x3e\x2d\x4f\xfd\xcf\x81\x9e\x74\x73\xab\xde\x81\x85\x44\xfb\x22\x1d\xfc\xe7\x88\x68\x8e\xa8\x09\xdd\x92\xee\xea\x50\x54\x49\x47\xbb\xde\x2f\x94\xf4\x2c\xd3\xf5\xb0\xbe\x77\xaa\xa8\x90\xba\x5b\xed\x12\xad\xee\xce\xac\xa4\xbb\x55\xef\xfc\xc2\xfa\x36\xaa\xa6\xf4\xbd\x54\xcd\xd4\xde\xea\x0a\x2a\xcd\xdf\x26\xff\xb2\xbe\x5d\x36\x15\xf7\x8c\x49\xbb\x54\xc9\xec\xab\xae\x54\xb7\x48\x47\xf8\x5e\xd6\x18\xe1\x7b\x35\xa3\xa2\xf0\x25\x8c\x11\xbe\xb7\x2d\x22\xde\xab\x3b\x11\xef\x6d\x9d\x70\xfe\xe5\x9c\x88\xf7\x2a\x4e\xa5\xde\xab\xeb\x1d\x3d\x76\xfd\x5e\x43\xfe\xf6\x83\x7b\xb3\xa3\x3c\x57\xd5\xbf\xe5\xb8\x20\xbf\xd1\xf7\x7e\xd4\x51\x91\x6f\xf3\x55\xf5\xef\x39\x2a\x8d\x5b\x3c\xba\x55\xdf\x48\xc1\xcd\x08\x65\x80\x18\x9d\x8a\xb1\xfa\x46\xd0\x51\x83\xae\x51\xb4\xf3\xcd\x1b\xea\x05\x65\xb3\x54\x76\x8d\x70\xbf\x8a\x19\x62\x36\x1b\xc9\xac\x6c\x56\x7d\xef\x51\x7f\xa3\x92\xb1\xe5\x6c\xa5\xfe\x7a\xe6\x48\xc6\x9c\xad\xcc\x72\x5e\x70\x4e\x32\xee\x9c\x72\x4e\x11\xfd\xa1\xf3\x21\xd1\xa7\x9d\xd3\x44\x7f\xe4\xfc\x9e\xe8\x01\x67\x80\xe8\xac\x43\x12\x02\x2c\x44\xfc\xa1\x17\x42\x2f\x30\x1e\x7a\x31\xd4\x4f\xf4\xc9\xd0\x49\x66\x87\x4e\x45\x4a\x98\x15\x09\x45\x22\xcc\x56\xff\x91\x93\xe8\xf2\xc8\x08\xc6\x23\x95\x91\x51\x84\xea\x68\x34\xa6\xf1\x73\x29\xc2\x16\xb0\xfb\x99\x43\x97\xdb\x36\x36\x76\x51\x57\xfa\x66\x16\xcd\xa4\x17\x74\xb1\xcb\xda\x9a\x7a\xda\xd5\x87\x82\x98\xfd\x8d\xaf\x37\x4e\x64\x95\xdf\x9c\x59\x4f\x39\x63\x59\xf5\x95\x4d\xae\x65\xb9\x34\xcb\xd3\xb6\xfe\x2a\x50\xc1\x91\x85\x0b\x17\x77\xb2\xb1\x3a\x9f\xd8\xdc\xd6\xba\x88\x5d\xd2\xd6\xb1\x50\x7d\x8e\x88\xe5\xf5\x51\xdf\x11\x52\xb5\x9c\x46\x41\xb2\xcd\x85\x6c\x02\xfb\x22\x71\xc5\xd1\x3a\x95\x78\x15\x87\x44\x39\x87\xb8\xa8\xb4\x47\x6b\x19\x96\x3d\xd3\x6d\x2f\xf9\x39\x49\xab\x64\x81\x48\x25\x7b\x97\x4d\x8f\x8c\x8a\x90\xc5\x59\x80\x1f\xd0\x5f\x4b\x38\xce\x3f\xa0\x9a\xb2\x43\x48\x61\x2b\x7b\x05\xca\x54\xaf\x00\x49\xb0\x1e\x64\x63\x58\x92\xd5\xd3\x88\xe7\xb0\x1b\xd9\x4d\xac\x87\xdd\xc6\xbe\xc7\xd6\xb0\x47\xd8\x06\xf6\x0c\xfb\x0d\x7b\x93\x18\x23\x56\x95\x35\xc1\xba\xc4\x8a\x5a\xd3\x2c\x69\x5d\x63\xdd\xa7\xe4\x44\xca\x99\x4d\xf3\xa6\xa8\x8a\x3c\x35\x22\x4f\x95\x11\xd5\xaf\xf1\xf6\xe5\xa9\xdf\xe6\xa9\xd7\xf3\xd4\x3f\x6b\xca\xa6\x71\x95\x85\xde\x27\xfa\xfd\xd0\x1b\xf9\x63\xfb\xf3\xd4\x01\x83\xeb\xa0\xa2\x69\x1d\xd8\xce\x51\xbd\xbe\x2a\x58\x15\xcd\xbe\xed\x1c\x89\x04\x29\x3f\x1e\x7a\x33\xdf\xeb\x90\xa6\x14\x4f\x25\xbb\x30\xe2\xd0\x5a\xea\x77\xde\x8f\x04\x34\xca\xe1\x3c\xd7\x5b\x79\xea\x48\x9e\x7a\x3b\x4f\xbd\x93\xa7\x7e\x97\xa7\x8e\xe6\xa9\x77\xf3\xd4\x7b\x9a\x2a\x21\xa4\xd1\xfa\x7b\xa2\x53\x69\x0e\xa7\x85\x76\x13\xe6\x19\xd2\x76\xb7\xc6\x3e\x13\x7a\x8d\xca\x8f\xa8\xfe\x9a\xae\x7f\x14\x3a\xa6\xc7\xb2\x8b\xf2\x33\xa1\x9d\x94\x7f\xa4\x65\x1d\xc7\x68\x4b\x9c\xb7\x9d\xdf\xa9\x4f\xc8\x06\x82\xb4\xf6\x43\x34\x6b\x91\x40\x45\xa0\x82\xe9\xaf\x15\xb0\x4a\xf5\xb5\x02\x36\x2a\x70\x61\x60\x2c\xab\xd2\x6b\xc9\xa6\x72\x12\x49\x98\xa2\x57\x4f\x40\xad\x01\xfd\xdd\x83\xd2\x40\x55\x60\xbc\x5a\xbd\xfa\x3b\x09\x1f\xaa\x95\x47\xed\xe3\x19\x0b\xfd\x20\xf4\x03\x36\x21\xb4\x2d\xf4\x2a\xbb\x88\xd6\xc3\x4d\xd4\xa7\xd2\x9a\x64\xd7\x72\xe9\xcc\x65\xe3\xd8\xa5\xb4\x2e\xa6\xb3\x99\x6c\x1e\x9d\x2b\x37\xb1\x2e\x76\x0b\xbb\x83\xdd\xcd\xee\xa3\xd5\xf1\x30\x5b\xcf\x36\xb2\xa7\xd9\x2f\xd8\x8b\x6c\x3b\xad\x92\x03\xec\x1d\x76\x82\x9d\xa1\xb5\x12\xb4\xca\xc2\x57\x31\x6e\xff\xd4\xfe\x69\xf8\x1b\xba\x5c\x1f\x9e\xa1\xcb\xc7\xc3\x5f\xd7\xe5\xba\xf0\x74\x5d\x3e\x16\xbe\x82\xca\xf5\xc4\xf7\x35\x5d\xae\x0f\x4b\x5d\x3e\x1e\x16\xba\x5c\x17\x6e\xd4\xe5\x63\xe1\x7a\x2a\x1f\x27\xbe\x3a\x5d\xae\x0f\x5f\xae\xcb\xc7\xc3\x7f\xa9\xcb\x75\xe1\xcb\x74\xf9\x58\x78\x1a\x95\xeb\x88\xef\x2b\xba\x5c\x1f\xbe\x54\x97\x8f\x87\x53\xba\x5c\x17\x4e\xea\xf2\xb1\x70\x82\xca\xc7\x88\x2f\xae\xcb\xf5\xe1\x98\x2e\x1f\x0f\xd7\xea\x72\x5d\xf8\x4a\x66\x53\xeb\xd5\x94\xff\x34\xfc\x55\xca\xd7\x85\x1b\x28\x7f\xfc\x53\x58\xe4\x26\x58\xa4\x15\x16\xc9\xc0\x22\x8b\x60\x91\x16\x58\xa4\x19\x16\x59\x08\x8b\x2c\x80\x45\x9a\x60\x91\x1b\x61\x91\xeb\x61\x91\x6f\xc3\x22\xf3\x61\x91\x6f\xc1\x22\xf3\x60\x91\xeb\x60\x91\xb9\xb0\xc8\xb5\xb0\xc8\x1c\x58\x62\x16\x2c\xf1\x4d\x58\x62\x26\x2c\xf1\xff\xc3\x12\xd7\xe8\xf2\xb1\xf0\xcd\xda\x16\x37\x28\x2b\x84\x67\x53\xfe\x58\x38\xad\x6c\xf4\x29\x2c\x72\x17\x2c\xf2\x57\xb0\xc8\x9d\xb0\xc8\xbf\x85\x45\xee\x80\x45\x56\xc2\x22\xb7\xc3\x22\xb7\xc1\x22\xdf\x85\x45\x6e\x85\x45\xbe\x03\x8b\xdc\x02\x8b\xac\x80\x25\x96\xc3\x12\x4b\x61\x89\x5e\x58\xa2\x07\x96\xe8\xc6\xda\xe8\x82\x45\x3a\x61\x91\x0e\x58\xa4\x1d\x16\x59\x0c\x8b\xb4\xc1\x22\xff\x46\xaf\x91\x7f\xa7\xed\xb2\x44\x5b\x64\x99\x5a\x29\x9f\xc2\x22\x0f\xc3\x22\xff\x05\x16\x59\x0b\x8b\xfc\x67\x58\xe4\x21\x58\xe4\x3f\xc1\x22\x0f\xc2\x12\xff\x11\x96\x58\x03\x4b\x3c\x00\x4b\xfc\x7b\x58\xe2\x7e\xac\x8d\xbf\x86\x45\x7e\x02\x8b\xdc\x07\x8b\xfc\x08\x16\x59\x0d\x8b\xdc\x0b\x8b\xfc\x10\x16\xb9\x07\x16\x59\x05\x8b\xdc\x0d\x8b\x7c\x1f\x16\xf9\x1e\x2c\xf2\x1f\xf4\xea\xf8\xaf\xda\x22\x3f\xd0\x16\xf9\xf1\xa7\xb4\xc8\x3f\xc2\x12\x3f\x87\x25\xfe\x17\x2c\xb1\x19\x96\x78\x1a\x96\xf8\x7b\xac\x8d\x9f\xc1\x22\xff\x13\x16\x79\x0a\x16\xd9\x04\x8b\xfc\x1d\x2c\xb2\x11\x16\xf9\x5b\x58\xe4\x49\x58\x64\x03\x2c\xf2\xdf\x61\x91\x27\x60\x91\x9f\xc2\x22\xeb\x61\x91\x75\xb0\xc8\x63\xb0\xc8\xa3\xb0\xc8\x7f\x83\x45\x1e\x81\x45\xfe\x87\xb6\xc8\x3f\xe8\x95\xf2\xb8\xb6\xc8\xdf\x68\x8b\x50\xbc\xa0\xfa\x6b\x0f\x3f\x5d\x5d\x73\xe9\xaa\x3d\x85\xfc\xc5\xe5\xf0\x70\xbf\xd1\x7e\x6c\x0f\xe5\xc7\xb4\x3f\x38\x41\xd4\x87\x9a\xfa\x20\x4f\xf5\xe7\xa9\x17\xc1\x67\x5e\xeb\x73\x31\xce\x2c\x76\x4f\x41\x8c\xf3\x45\x1d\xe3\x44\x75\x8c\x73\x59\xd1\x58\xa6\x90\xb6\x0a\xda\xed\x9b\x29\x3c\x64\x15\x6a\xb7\x4a\x9e\x46\x7f\x0b\x9d\xf2\xca\x8f\xfd\x2a\xe2\x18\x56\xcb\xa6\xb1\x46\x8a\x31\x66\xb1\xf9\xfa\x2b\xa8\x2b\xd9\x0f\xd9\x83\x14\x63\x3c\xc1\x36\xd1\xcc\xbf\xc3\xfa\xd9\x59\xcb\xb1\xca\x28\xce\x18\x67\x4d\xb6\xa6\x58\xb5\x6e\x5c\x63\x85\x74\xcc\x62\xf1\x75\x54\xa7\x08\x8f\xef\x70\xdb\xf9\x19\xb7\x74\x5e\x74\xcb\xc8\xdd\x6e\x6c\x53\xf9\xd4\xc8\xd0\xc8\x79\x23\x9f\x70\x6b\x23\x8f\x8f\xca\x8c\x7a\xe7\x82\x36\xb7\x76\xc1\xae\xaa\x4b\xaa\x6e\xa9\xda\xe6\xd6\x3e\x57\xf9\xb9\xfb\x2e\x8c\x5c\x78\x8f\xdb\xff\xc2\x53\x6e\x39\x66\x83\x5b\x8e\x9b\xa7\xb9\x42\x17\x05\x2f\xea\xb9\xe8\xa5\x89\x97\x4c\xbc\x63\xe2\xbe\x2f\xc4\xbf\xb0\x5a\xb7\x96\x7f\x61\xdb\x17\xce\x4e\x9a\x32\x69\xfe\xa4\x7b\x26\x6d\x9e\x74\xf4\xe2\x71\x17\xcf\xb8\xf8\xd6\x8b\x9f\xb8\x78\xdf\xe4\x32\x7d\xdc\x9e\x3c\x6e\xf2\x74\xb2\x07\xd1\x93\xdb\xb5\x0d\xad\x9a\xcd\xae\xdc\x9a\x67\xdd\x32\xde\xe9\x96\x97\x22\xbe\xfb\x6a\x9b\xcb\x57\x37\x05\x65\xad\x8e\x29\xad\xba\x6b\x68\xa5\xdc\x6f\x93\x14\xfb\x41\xb2\xe6\x0c\x3a\x63\xd6\xb2\x47\xc9\x6a\x1b\xd9\xcf\xd8\xcf\xd9\xb3\x64\xbb\x57\xd8\x2e\xb6\x8f\xce\x9b\x23\xec\x3d\xb2\x22\xce\x1c\x6b\x94\x35\x9a\x22\xb6\xc9\xd6\x97\xac\xa9\x56\x9c\xa2\xb6\x7a\xeb\x0a\xeb\x2a\x6b\x96\x35\xcf\xba\xd1\x6a\xb1\xda\xac\x2e\x6b\xb9\x75\x9b\x75\xa7\x75\xb7\xb5\xda\xba\xdf\x7a\xd0\x7a\xd8\x5a\x67\x6d\xb0\x36\x59\x4f\x5b\xcf\x58\xcf\x59\xdb\xac\xed\xd6\x6e\xeb\x75\xeb\x4d\xeb\x1d\xeb\xb8\x75\xca\x3a\x6b\xdb\x76\xc8\xae\xb0\xab\xec\xb1\xf6\x44\xfb\x8b\xf6\x14\x3b\x6a\x27\xed\xcb\xec\x46\x7b\xba\x7d\x8d\x3d\xc7\x9e\x4f\xba\x36\x07\xa2\x94\x4f\xd3\xf9\x5a\x9d\x4f\xd0\xb9\xdb\x7e\xdc\xa0\xef\xd0\xf9\x35\x06\xff\x04\x8f\xce\x26\x0d\x09\xd3\x8c\x7c\xb9\x21\xa1\xd9\x90\x60\xb6\x9b\x9c\x55\x46\xcb\x1d\x7e\x14\xe4\xcd\x83\xe8\x09\xfe\xf6\x02\x7d\xaa\x0c\x69\xee\xd1\x03\x83\xe8\xe6\x41\xf9\x60\x1d\x4c\xac\xe5\xc3\xb0\x86\x29\x61\xf0\xd8\x07\xeb\x6f\xf0\x67\x8f\x0e\x1a\xb5\x6e\x1f\x78\x86\x62\x47\xe4\xe8\xa5\x72\xba\xfe\x14\x44\x86\x2f\xd2\xd5\xe5\x22\x1d\x1f\x4e\x0c\xed\xa4\x6b\xce\x25\x11\x87\x62\xed\x2b\xf4\xb9\xf7\x3e\x73\x77\x2d\xa4\x8d\xf3\xa4\xde\xdd\x8d\x66\x6a\x9f\xe1\x5e\x7b\x46\x82\x87\xf6\x45\x24\x91\xae\x22\x81\x20\xc5\xa9\x01\xf5\x3d\x2d\x36\x56\x4b\x1c\x47\x1c\xe3\x68\xc7\x63\xd1\xd5\xaf\x4c\x5f\x69\x2c\x7b\xae\xd6\xc7\x22\x6c\xd5\xfb\xa3\x3c\xc2\xfd\x6a\xaf\xc2\x9e\x63\x0f\x51\xbe\x8d\xb8\x47\xd1\x2e\x69\x0a\x8b\xd2\xce\xe5\x32\xba\xae\x4c\x67\xd7\xd0\xee\x65\x3e\x79\x97\x8c\xfe\xf4\xec\x2d\x74\x7d\xb9\x8b\xae\x7c\x24\xcf\x9e\x4a\xf9\x4a\x95\x67\x8f\x6a\x7a\xae\x3d\x97\xe8\x97\x14\x4d\x17\xb4\xa9\x9a\x7e\x33\x97\xbb\x47\xed\x71\x16\xe9\x62\xdd\xaa\xf9\xa7\xaa\xdc\x7a\x44\xe7\x1b\xec\x36\x9d\xab\xf6\x36\x9d\x9f\xb6\xfa\x73\x39\x45\xe2\x25\x81\xf2\xc0\x88\xc0\xa8\xc0\xe7\xdc\xef\x86\x91\x0d\xbd\x6f\x93\xa8\x2f\x93\xec\xa4\x48\x5f\x8d\xab\x3f\x3f\x2e\x66\x6f\xa4\xfa\x29\xe7\x25\xda\x93\x8d\x53\x67\x38\xed\xb1\x92\xd6\x65\x56\xa3\x35\x9d\xf6\x59\x73\xac\xf9\xd6\x02\x2b\x63\xb5\x5b\x3d\xd6\x2d\xd6\x4a\xeb\x2e\xeb\x1e\xeb\x3e\xeb\x01\xeb\x21\xeb\x11\x6b\xbd\xf5\xa4\xf5\x94\xb5\xd9\xfa\x85\xb5\xd5\x7a\xc9\xda\x61\xfd\xc6\x7a\xc3\x3a\x6c\x1d\xb5\x4e\x58\xa7\xad\x01\xdb\xb1\x23\x76\xa5\x7d\xa1\x3d\xce\x9e\x64\x5f\x62\x7f\xd9\xae\xb5\x2f\xb5\x2f\xb7\xa5\x3d\xc3\x9e\x49\x63\xbc\xde\x6e\xb6\x6f\xb2\x3b\xed\xa5\xf6\xad\xf6\x1d\xf6\xf7\xec\x1f\xda\x3f\xb1\xd7\xd8\x6b\xed\x47\xed\x27\xec\x8d\xf6\xcf\xec\x9f\xdb\xcf\xda\x2f\xda\xaf\xd8\xbb\xec\x7d\xf6\x01\xfb\x88\xfd\x9e\xdd\x6f\x9f\xe1\x8c\x07\x79\x19\x1f\xc5\x47\xf3\x09\x7c\x32\xff\x12\x9f\xca\xe3\x7c\x1a\xaf\xe7\x57\xf0\xab\xf8\x2c\x3e\x8f\xdf\xc8\x5b\x78\x1b\xef\xe2\xcb\xf9\x6d\xfc\x4e\x7e\x37\x5f\xcd\xef\xe7\x0f\xf2\x87\xf9\x3a\xbe\x81\x6f\xe2\x4f\xf3\x67\xf8\x73\x7c\x1b\xdf\xce\x77\xf3\xd7\x69\x5f\xfa\x0e\xed\x4b\x4f\xf1\xb3\x8e\xed\x84\x9c\x0a\xa7\xca\x19\xeb\x4c\x74\xbe\xe8\x4c\x71\xa2\x4e\xd2\xb9\xcc\x69\x74\xa6\x3b\xd7\x38\x73\x9c\xf9\xce\x02\x27\xe3\xb4\x3b\x3d\xce\x2d\xce\x4a\xe7\x2e\xe7\x1e\xe7\x3e\xe7\x01\xe7\x21\xe7\x11\x67\xbd\xf3\xa4\xf3\x94\xb3\x99\xac\xff\x13\xb5\x7a\xed\xb9\xc1\x0c\xcd\xcd\xcf\x14\x6d\xfd\x4c\xd3\xb3\x34\x3d\x4b\xd3\xdb\x34\xbd\x4d\xd1\xf6\x54\xcd\x3f\x55\xd1\x6c\x9f\x5e\xf9\xfb\x34\xcf\xe5\x9a\xe7\x72\xcd\x33\xd7\x93\x69\xd2\xb8\x8e\x1d\xf7\xcb\x2c\x90\x1f\xd2\xfc\x21\x4d\xaf\x2c\x2e\xc7\x72\x34\xbf\xe3\xd7\xd3\xd4\xad\x80\x36\x65\x8e\x33\xe8\xa1\x78\x8c\xf6\x02\xdd\x4e\xeb\xf6\xd3\x83\xf4\x19\x62\x2c\x05\x7d\x87\xe0\x2f\xb0\xff\x10\x76\x1e\x8e\x7d\x86\xc2\x2a\xd0\x79\x38\xb4\xa1\xcf\x50\xf4\x67\xb1\x4e\xce\x7b\x6d\x98\xf6\x1c\x6a\x0d\x0c\x35\xef\x9f\x62\xae\x69\x2c\xc7\xf3\x63\xd9\x16\xd8\x97\xb7\xc3\x06\x4d\x3f\x02\xf9\xfb\x8a\x62\x19\xf4\x10\x63\x1c\xbe\x07\x19\x99\xff\xfe\xa3\xfa\xfa\xe3\x0e\xfd\xd5\xc7\x3d\xce\x1b\xfa\x1b\x8f\x6f\x39\x1f\x3a\x67\x43\x2f\xa8\x3b\x84\x4c\x32\xa6\xef\xc7\xcd\xa4\x34\x97\xd2\xf5\x94\x9a\x29\xdd\x44\xa9\x93\xd2\x52\x4a\xb7\x52\xba\x83\xd2\xf7\x28\xfd\x90\xd2\x4f\x28\xad\x51\x7e\x9b\xca\x47\xa9\x3c\x1c\x98\xa6\xae\xb6\x01\x49\xf9\x7a\x45\xd3\x19\xe8\xb5\xb8\xf9\x5a\x95\x67\x1f\xd4\xf4\x34\x4d\x3f\x6b\xf0\x4c\x03\xe7\x34\xed\x29\x97\x2b\xda\x39\xaa\x5b\xce\xe8\x7c\x6d\xfe\x3a\xfe\xe5\xff\x77\x1d\xff\x64\xd7\x71\x7d\x47\x53\xcd\x30\xad\x48\x23\x9f\xa2\xf3\x59\xfa\xe8\x3a\x4d\xaf\xd6\xf4\x54\x2f\xb7\xe2\x46\x3e\xda\xcb\x5d\x69\x83\x73\x8a\x98\xf3\xb9\x2b\xad\x48\x3e\xcb\xc0\x5d\x69\xe4\x73\x3d\x3a\x7b\xa3\x97\x0f\x89\x6b\xea\xb9\xcd\xc8\xfb\xbd\xdc\xde\xec\x6f\x19\xdc\xce\x27\x1a\xed\x73\xfd\x9a\x20\x1f\xe7\xe5\x83\xa5\x0d\xee\x5b\xd0\x6e\xd8\x7f\x48\x3b\x0f\xc3\x3e\x05\x7a\x0e\xb6\xdb\xb0\x73\xcb\xbd\xc3\x3d\x37\xfb\x52\x9e\x5e\xa0\xe8\xcf\x7a\x9d\x14\xac\x8d\x47\x8c\x7c\xa8\xb1\x1b\xb3\x30\x94\xcc\xa1\xe6\x7d\xf0\x5c\xbb\xf9\x70\xe6\xba\x60\x2c\xa6\x1d\x4c\x3d\x4d\x94\x59\x43\xe4\x26\xbf\x37\xde\xe1\x5f\xc7\xc7\x3a\x2f\x38\x2f\x39\xaf\x16\x7c\xad\xf7\x40\x91\xef\xf3\x7e\xe0\x9c\x74\x7e\xef\x64\xdd\xaf\xa5\xb1\xb1\x6c\x38\x57\x70\x86\x2b\x38\xa3\x3d\xaf\xfa\x82\x23\x63\x6a\x8c\x3f\xa7\xf4\x2c\xa5\x17\x29\xbd\x42\x69\x17\x25\x35\x5f\x07\x48\x9b\x23\x54\xbe\x47\x49\x8d\xf9\x8c\x9a\x48\x3a\x3f\x77\xb3\x2a\x75\x35\x57\x63\xa3\x7c\x42\xbe\xe5\x80\xa6\x73\xb9\x66\x66\x2e\xbf\xc7\xf3\x82\xa6\x5f\xd5\xf9\x51\x83\xce\x49\x63\xf9\x96\x57\x41\x7b\x28\x06\x8f\xbb\x9e\xf2\x9c\xb9\x9c\xeb\x3d\x90\xa5\x90\x58\x54\xe3\x8f\xa2\xdc\x76\x3e\x24\xdf\x37\xc4\x5d\x7a\x56\x71\x2e\xbf\x49\x12\x6d\x92\x38\x4d\xcb\x64\x3e\x89\x1f\xd7\xb7\x38\xe2\xc7\xe8\xa8\x57\x06\xd3\x6b\xc2\xd2\x6b\xe2\x0b\x9f\xb5\x8e\x45\x10\x95\x8e\xd3\xa1\xe3\x8d\x5a\xe2\x05\x94\x8f\x39\x8f\x95\x99\x5b\x97\x43\x59\x3d\x52\x4c\xd6\x1f\x00\x77\xc4\xc7\xf4\xfb\x57\xd5\xa0\xe8\x5c\xfe\x9f\xd7\x60\x28\xdb\xdb\xfa\xbe\xa2\xb7\x8a\xaa\x3e\x76\xf5\x9c\xfb\xdc\x52\x23\xa9\xc5\x48\xa6\x0f\x53\xe2\x50\xf3\xe6\xe2\x7c\x4a\x1d\x87\x58\xe9\x9f\x40\xc7\xa2\x76\xf5\x74\x9c\xce\xda\x0c\x1d\x3f\xf7\x09\xe7\xef\xe3\xd7\xca\x50\x76\x57\x1a\x2c\xf8\x57\xd1\xa0\xf8\x5a\x39\x17\xee\x1f\x6c\xe4\x45\x67\xf3\x0f\x30\xf2\x62\x73\x8f\xbb\xca\x6b\xff\xc8\xef\x2a\x63\x4f\xad\x77\x97\x53\x34\xbd\xd5\xbd\x73\xe2\xdd\x95\xc5\xbd\x94\x29\x1e\xa7\xcb\x63\xe6\xd9\x27\xfd\x12\x20\xc7\xe8\x05\x99\x2e\x3d\xda\x2f\x0d\x47\xb7\x0e\xd2\xc7\xbd\x33\xbc\x69\x90\xcc\xad\xe7\x92\x30\x58\x9f\x02\xfd\xa7\x0d\x41\x0f\xca\xcf\x6d\x93\x73\x5b\xa3\x08\xae\x39\xf6\x73\x8f\x7a\x82\x31\xf6\xb5\xde\xd1\x6c\xa5\x97\x1b\x88\xc3\x8f\x25\xb9\xf3\x4f\xce\x7e\xe7\xb0\x7e\x9b\xa1\x42\x5f\xdb\x18\x45\x8a\x85\xfb\x74\x9d\x63\xfd\x3e\xf4\xc7\xbd\x7e\x9d\x19\xfa\x7e\xc9\x66\x6d\xb9\x35\x2a\xe7\x13\x75\x7e\xa7\x67\x4b\x6b\xb5\xd7\xc2\xcf\x7a\xed\xbc\xcc\xcb\x5d\x09\xee\x51\xbe\xc3\xe8\x9b\x31\xfa\xde\x69\xc8\x37\x50\xf8\x7c\x9d\x5f\xa1\xe5\xbc\xa9\xf2\xc0\x34\x4f\x4e\xee\x2e\x91\x97\xf3\x23\x1e\xae\xa9\xbf\x2b\xcd\x95\x60\xea\xe3\xb6\xb8\xd2\x82\xa3\x3d\xf9\x26\xed\xca\x31\xf3\x02\x9b\x94\x0d\x61\x13\xc3\x1a\x2e\xbf\x99\xc3\x0e\xa6\x05\x0c\x8b\x9d\x7b\xd4\x90\x5f\x66\xe8\x3f\x71\x90\x7c\x4f\xda\xf0\xd7\xaf\xed\xec\x74\x76\xeb\x77\xcd\x22\x4c\x3d\x19\xcd\xdd\x37\x5a\xfb\xa7\xb3\x66\xf9\x11\xbd\xc7\xfc\x7b\x9d\xbb\x3b\xd9\xb5\x7a\x4f\xaa\xf7\xdd\xd6\x9f\x69\x3f\x75\x5c\xb7\x3c\xa1\xf3\xbf\xd1\x2d\x9b\x34\xbd\x43\xf3\x6f\xf1\x76\xb2\x8e\x7e\x8f\x8d\x3f\xa3\xfb\xea\x27\xde\xd6\x5f\xeb\x16\x77\x9f\x3b\x5f\xe7\x1a\x91\xd7\x1a\x7b\xde\xac\xb1\xe7\x7d\x45\xcb\x49\x1a\xf2\x7f\xab\xf3\x23\xc6\x7e\xd9\xa0\x1d\x6e\xe8\xfc\x7d\x4d\xbf\xe6\xd7\xc7\x95\xe9\x4a\x73\x25\x0f\xce\xf9\x59\x7f\x5e\x60\x13\x77\x14\x77\x6a\x9d\x2d\xc3\x26\xe7\xb4\x06\xd7\x9a\x58\xae\x6e\x7f\xeb\x1f\xbb\xbb\xeb\x1f\x6a\xd4\x2e\x0a\x74\xd8\xe2\xf5\x2a\xb8\x6f\xb0\x23\x9f\x9f\xcf\x9a\xdd\xee\x1c\x2a\x58\xb3\x8c\x5d\xa2\x77\xbb\x11\xec\xd4\x2e\x33\xe2\x93\x0b\xf3\x3d\x3e\x3e\xe6\xb1\xd8\x85\x01\x3b\xc0\x03\x81\x40\x30\x10\x0e\x94\x05\x2a\x03\xa3\x43\x7d\xfa\x59\x98\xfa\x22\xbf\xfa\x1e\xff\xc1\xd0\xe1\xd0\x91\xd0\x7b\xa1\xf7\xd5\x57\xd5\x09\x8d\xd3\x9e\x78\x32\xfb\x92\xea\x59\x04\xcf\xd2\x77\x5c\x2d\xe7\xc8\x67\x20\xf9\xe4\x67\x2c\xf9\xe8\x67\x26\xf9\xdd\xcf\x4c\xf2\xb1\xcf\x4c\xf2\xf1\x4f\x20\x59\xad\xc4\x49\x43\xac\x44\x57\xee\xf9\x4b\x74\x35\xcd\x49\xfc\x33\xca\x83\x3a\x8a\x76\x23\xe8\x93\x05\xf3\x37\x5c\xfe\xbd\x98\x95\xf3\x93\x3f\x7c\x7e\x57\xfe\x7b\xc3\xe6\xdf\x7e\x9e\xfc\x2f\x61\xee\x87\xcb\x7f\x04\x33\x3a\x5c\xfe\xa3\xe7\xc9\xff\xd2\x79\xf2\x6f\x3f\x4f\xfe\xbd\xe7\xc9\xbf\xef\x3c\xf9\x4f\x1a\xfc\x93\xe8\xca\x6a\xd3\xca\x1d\x87\x1e\xa3\x0d\x89\xbf\x65\xb9\xb7\x2a\xac\xc0\xa8\x61\x72\xf7\x83\xdb\xaa\xb8\x4b\xbf\xa9\xd5\xc2\x76\xe9\xb8\x61\x8a\x75\x99\x35\xdf\x6a\xb7\x56\x5a\xcf\xd9\xcc\xbe\xd4\x5e\x6e\xdf\x61\xaf\xd6\x7f\x6b\xec\x67\xed\x97\x78\x15\x1f\xcb\xaf\xe0\x37\xf1\x3b\xf9\x1a\xbe\x9b\x9f\x70\xca\xf4\x33\x9b\xf5\x81\xaa\xc0\xa4\xc0\x8c\xc0\x9c\xc0\xba\xc0\xd3\x41\x27\x18\x0f\xce\x0f\xac\x0b\xde\x15\xbc\x27\x78\x5f\x70\x73\xf0\xc5\xe0\x69\xaa\x9d\x2e\x09\x96\x54\x95\x8c\x2d\x99\x58\xd2\x5e\xb2\xb6\xe4\xbd\xd0\xac\xd0\xf5\xa1\xe6\xd0\x6d\xa1\xd5\xa1\xa7\x43\xcf\x84\x76\x85\x9d\xf0\xcc\xf0\xea\x88\x1d\xb9\x27\xf2\x54\x64\x6b\x64\x7b\x69\xa8\x34\x5a\x3a\xbf\xb4\xa5\xf4\xc1\xd2\xe7\x4a\x5f\x29\x7d\xbd\xac\xaa\x2c\x5e\x76\x63\xe9\xfc\xb2\xfb\xca\x36\x97\xbd\x53\x3e\xba\xfc\xd2\xf2\xb6\xf2\x3b\xca\xd7\x95\x6f\x28\xdf\x54\xfe\x74\xf9\xd1\x8a\x51\x15\x53\x2a\xea\x2b\xae\xa8\x98\x57\xd1\x49\xfe\x67\x72\x76\x13\xbb\x34\xbb\x97\x4d\xcb\xee\xe5\x5f\xc9\x6e\xe2\x75\x54\x36\x52\xf9\x35\x4a\x57\x51\xba\x96\xea\xdf\xce\xaa\x19\xac\xca\xde\xcb\xc2\x8c\x53\x9e\xa0\x94\xca\x66\xa8\x5f\x23\xf5\xbb\x97\x5d\x47\xf4\x3c\x4a\xf3\xb3\x99\x92\x37\xa9\x74\x88\x6b\x2f\x1b\x31\x70\x9a\x8d\xa4\x34\x99\xb8\x4a\xa8\x65\x13\xf5\xdb\x4b\xfd\x14\xde\x26\xea\xb7\x89\xf8\x37\x11\xff\xbd\x9a\x7f\x93\xc1\xaf\x24\xa4\x88\x17\x7a\x11\xdf\x5e\x36\x92\x8d\x20\x39\x95\x94\x46\x52\x1a\x4f\x3c\x13\x28\x4d\xa6\xde\x51\x3a\xda\x48\x6d\x92\xd2\x15\x94\x66\x90\xac\x99\x54\xce\xa6\x72\x0e\x95\x73\xa9\x9c\xe7\xa2\xd1\x8e\x27\xa7\x59\x25\xf5\x54\x68\x9e\xa4\x0c\x49\x19\x4f\x12\xc6\x93\x84\x7b\x49\xc2\x78\x92\x70\x2f\xf5\xbe\x57\x8d\x2b\xd7\x93\xa8\x4a\x92\x33\x92\xca\xf1\x74\x64\x02\x25\xb7\x67\x86\x7a\x66\x80\x9d\xa1\x9e\x19\xf4\xbc\x97\x8d\x70\x47\x97\xd7\x5e\xf5\x6c\xa4\x9e\x8d\xe8\xd9\x58\x80\xf9\x4d\x6a\x9b\x45\xe5\x5c\x6a\xbf\x8e\x92\xcd\xae\xcc\xee\x2d\x79\x93\x2d\xa1\xf5\x3a\x42\xe9\x9c\xbd\x97\x6a\x33\xa8\x7d\x84\xd6\x63\x93\x8a\x21\xb2\xf7\xf2\xaf\x67\xfb\xf8\x4c\x4a\x73\xb2\x73\x69\xce\xea\xf9\x5c\xa2\xbf\x4d\x65\x3a\xbb\x91\x77\x64\x33\x7c\x45\x76\x33\xb3\xe9\xc8\x03\xd4\xfa\x00\x1b\xc9\x1b\xd8\x83\x34\xcf\x19\x9a\xe7\x0c\xcd\x73\x86\x5f\x9f\x95\xfc\xc6\xec\xaf\x79\x13\xa5\x85\x44\xb7\x50\x6a\x25\xfa\x66\x4a\x6d\x94\xda\x29\x2d\xa1\xb6\x5e\x4a\xcb\x29\xdd\x96\xa5\x78\x9b\xe4\x3d\xcc\x4a\x87\x8b\xaf\xd7\x46\x08\x33\x70\x86\xac\x7f\xc6\xd5\x62\xa0\x8f\x7f\x6d\xa0\x9f\x5f\x45\xe5\xcd\x34\x9e\x20\xe4\xed\x21\x79\x7b\x48\x5e\xaf\x96\x47\xb2\x58\x80\x34\x7e\x94\x34\xde\x43\x1a\x3f\x9a\x1f\xcb\x08\xe2\x7d\x94\x78\x1f\x25\x4c\x35\x8e\x2d\xa4\xff\x16\xd2\x7f\x0b\xcf\x50\xba\x89\x52\x27\xa5\x25\x94\x7a\x29\x2d\xa7\xf4\x1d\x4a\xb7\x51\x5a\x99\xdd\x92\x47\x2b\xd4\x5e\xa1\x05\xe9\x7c\x78\xb4\x28\x62\x10\xeb\xd5\x1d\x43\xe3\xc0\x6b\xc4\x51\x46\xfa\xbf\x46\x16\x59\x9a\x7d\x94\x5d\x44\x73\x23\x69\xb6\x25\xcd\x8f\xcc\xad\x30\x1a\xeb\x2f\x49\xda\xf5\xc4\xdb\x4c\x78\x7b\x49\xe2\xf5\x84\xb9\x97\xb4\xde\xcb\xbf\x45\x49\xcd\xc0\x0d\x94\x72\xd6\x5f\xa4\x67\x60\x93\xb2\x09\x59\x7f\x53\xde\xfa\xcb\x88\x56\x33\xb0\x82\xca\x5b\x28\xdd\xca\x5a\xf8\x77\xa9\xa4\x19\xe1\xb7\x93\x5e\x63\x7d\xe8\x92\xd0\xa5\x31\xdf\xab\x08\xfd\xb7\x7a\xce\x67\x52\xa9\xe6\xc9\x3f\xf7\x69\xb2\xf9\x70\xe6\x9f\x6b\xeb\x5c\x4b\xdc\xdf\xce\xf6\xb2\x08\xc9\x59\x45\xfd\x57\x51\xdf\x55\x64\xf7\x3d\xc4\xbf\x8a\xf8\x57\x11\xff\x2a\xb2\xf9\x2a\xea\xb3\x8a\x6c\xbe\x4a\xaf\xc3\x87\xa9\xcf\xc3\xac\xea\xbc\xf4\x1a\x8e\x4e\x0e\x5f\x4c\xb6\xec\xca\x1e\xa4\x99\x38\x48\x36\xda\xc2\x46\x91\x9c\x35\x24\xe7\x79\x92\xb1\x86\xc6\xb6\x9e\xe4\xac\x27\x39\xcf\x93\x8e\xeb\x49\xd6\xf3\x24\xeb\x79\x5a\xa3\xeb\x49\xd6\x1a\xea\xb9\x87\xe4\xad\xa1\xde\x73\x48\xe6\x1a\xd2\x7b\x0d\xc9\x5d\x43\x7a\xaf\x61\x65\x24\x69\x0f\x49\xd9\x43\x12\xf6\xd0\xea\xda\x43\x2b\x4b\x8d\x72\x0f\xef\xd1\xbd\xf6\x50\x8f\x3d\xd4\x63\x0f\xf5\xd8\x43\x3d\xf6\xb0\x30\x5f\x90\xdd\x4f\xdc\x7b\x89\xfb\x3d\xe2\x7e\x8b\x38\x77\x12\xe7\x5e\x9a\xc5\xfd\x34\x6b\xfb\x69\xc6\xf6\x6b\xcb\xf5\x91\xdc\x3e\xe2\xec\x23\xce\x3e\xe2\xec\x23\xb9\x7d\xc4\xdd\x47\xdc\x7d\x24\xb7\x8f\x64\xf6\xd1\xfa\x5a\x92\x3d\x48\xb9\x1a\x97\xea\x75\x90\x7a\x1d\xa4\x5e\x07\x55\x3b\x71\x1f\x24\xee\x83\xc4\x7d\x90\xb4\x38\x48\x3d\x0e\x92\x16\x07\x69\x9e\x94\x4d\x72\xf6\x28\xf5\x9d\x23\xfb\xf5\xb9\xd1\x43\xa5\x7b\x7e\xec\x2f\x38\x3f\x78\x81\x2d\xd5\x35\xe8\x76\x5a\x57\x2d\x6c\x3c\xab\x61\x16\x9d\xd1\x21\x9d\xcf\x60\x17\xf0\x5f\xb1\xf1\x7c\x6b\xf6\x10\x7f\x99\xce\xf8\x57\x48\xdf\xed\x94\x5e\x25\x7a\x47\xf6\x76\xbe\x93\xce\x9c\xdd\x54\xbe\x4e\x96\xdc\x4f\x08\x07\x28\x1d\xa6\x74\x8c\xd2\x09\x4a\xfd\xd9\xcd\xfc\x24\x95\x03\xd9\xfd\x24\xad\x9a\x2c\xbd\x25\xfb\x02\x49\x1c\xc3\xb7\xb2\x19\x24\x61\x03\x49\x78\x81\xef\x22\xe9\xbb\xa9\xdc\x4b\xf3\xf5\x3a\x69\x74\x88\x8e\xf7\x67\xdf\x22\xb7\xfc\xff\x11\xfe\x16\xc2\xfa\x55\xf6\xc7\xfc\x79\xe2\xde\x9a\x7d\x9a\xf4\x58\x4b\x3a\xac\x25\x1d\x56\x91\x84\x99\x24\x61\x19\x49\xe8\x23\x09\x7f\x45\x12\x1e\xe2\x6f\xd0\x31\x25\xe1\x5d\x92\xfa\x01\x95\xa7\x48\xe2\x69\x36\x86\xa4\x8d\xa1\x3f\x63\x9c\x24\xb9\x85\x24\xb7\x90\x2e\x7f\xce\xb7\x65\xbb\x79\x1f\x49\x79\x99\x7a\xbd\x41\x69\x3f\xd1\x07\x09\xf9\x10\x59\xf8\x70\xf6\x97\xfc\x6d\x9a\xf9\xa3\xa4\xc5\xbb\xa4\xc5\x7b\x54\x3f\x96\xbd\x9f\xbf\x4f\xfa\xf6\x67\xd7\xf1\xb3\xd4\xfe\x7b\xb2\x40\x36\xfb\x1d\x87\x65\x37\xd0\x79\xb0\x93\xb8\xfb\x95\x25\x49\xe3\x83\x74\xc5\x79\x99\x38\xb6\x53\xda\x41\xfa\xef\xa6\x74\x8c\x10\xfa\xb3\xbf\xa4\x55\xfd\x2a\x69\xb8\x43\x8f\x7f\x0d\x69\xfd\x79\x9a\xfd\xdc\xf8\x54\xeb\xce\xec\x7c\xb2\xc8\x21\xd2\xa0\x8f\xfa\x6c\x24\x9b\xf6\x69\xc4\x01\xbd\x66\xfa\xd9\x9f\xd3\xb5\x73\x27\xb5\xed\xa7\x31\x1e\xa6\x74\x8c\xd2\x09\x42\x2c\xa5\xb1\x3d\x44\x63\xeb\x23\xab\x6d\xa4\xb1\xf5\x91\xb4\xef\xf3\x9d\x84\xb5\x8b\x70\x76\x53\xdb\x1b\x94\xde\xa2\x71\x9f\x22\x19\x17\x90\x55\x66\x90\x55\x6a\x60\x95\x19\xd4\x33\x46\x3d\xef\x27\xed\x37\x53\xef\x1b\xf3\x96\xd9\x91\xed\xc0\x8c\xdd\x4e\x12\x9e\x20\x5c\x65\xa1\xa7\x08\xfb\x29\xc2\x7e\x8a\x46\xdf\x47\xd7\x6d\x35\x63\xdb\x30\x2e\x77\x6e\xc9\x9e\xac\x82\x1f\xa0\x74\x98\xd2\x5b\x94\x8e\x50\x3a\x46\xe9\x04\xa5\x0f\x68\x85\x9d\xa4\x72\x80\xbc\xf1\x38\xd2\x65\x0d\xe9\x72\x3b\xe9\x32\x83\x76\x44\x63\xd8\x62\xb2\xe3\x77\xb5\x5e\xb7\xd3\xca\xa9\xd1\xf8\xaf\x13\xf7\x7e\xc2\x3c\x08\xec\xb7\xb3\x2f\xf3\xdf\x51\x79\x94\xd2\xbb\xae\x2e\xfc\x38\xb5\xbd\x4f\x7a\x9f\x20\xba\x9f\xe8\x53\x94\xce\x50\x3a\x4b\xf5\xdf\x53\xca\x6a\x7d\x5f\xa6\x58\x71\x84\xf2\x9c\x1a\xb1\x86\xd0\xc6\x00\x4d\xad\x8d\x0d\x34\xfa\xef\xd0\xc8\x5f\x20\xd4\x1f\xd3\x88\x7f\x4c\x2b\xfc\x10\xa1\xae\xe5\x6f\xaa\xf9\xd2\x33\xb3\x96\xbf\x45\xf4\x11\x3a\xaf\xde\xa6\x95\xfe\x0e\xb5\xfd\x8e\x50\x8f\x52\xdb\xbb\x94\xde\xd3\x33\xb7\x96\xb4\x79\x9e\xb4\xd9\x40\xda\xac\x25\x4d\x5e\xe5\x1f\x12\xdf\x47\x94\xce\x50\xca\x66\x9f\x27\x4d\xd6\xd2\xdc\x6f\xa1\x1e\xbf\x22\x8e\x6d\xd4\xda\x97\xed\xe7\x2f\x93\x15\x5f\xd5\x76\x5f\xa0\xd7\x8d\x5a\x99\x47\xe9\xca\xe2\x90\x4e\x0f\xd0\x2a\xd9\xa8\x67\xff\x58\xf6\x35\x5a\x73\x6f\xa8\x78\x82\xce\xdb\x72\x92\xf2\x34\x49\x39\x44\x33\xf8\xbc\x3e\x73\xfb\xb2\xaf\x11\xbf\x3a\x73\x5f\x23\x69\x0f\xd0\x9c\x6c\x20\x69\x9f\xa7\x95\xa5\xd6\xc1\x21\xdd\x2b\x42\xdc\x87\xe8\x4c\xa8\xd1\xd8\xbb\xdc\x23\xb4\x22\xc7\xd3\x6c\x8d\x27\xcc\x13\x34\x9a\x83\x74\x0e\x8d\xd7\x5a\xfe\x00\xf2\xfb\xf4\xda\x52\x2b\xe3\x55\xdd\x4b\x5d\x0d\xfa\xa8\x97\x9e\x63\xd2\xa9\x9f\x5a\x4f\x67\x0f\x91\x4e\x6f\x11\x75\x44\x6b\xdf\x47\x92\x36\xea\x33\xe0\x84\x3e\x0b\x0e\xd1\x15\xe2\x10\xd9\xe4\x35\xc5\xc9\xff\x85\x8e\x0f\x64\x0f\xe9\x95\x14\xa1\x39\x3e\xa1\x2d\x7e\x88\xce\xa7\xc3\x74\x95\x55\x12\x72\x3d\x4f\xd2\xb1\x7f\xd1\x9c\xea\x1e\xcc\x48\x2d\xfb\x10\x5d\xd7\xfa\xb5\x94\x43\x4a\x0a\xe1\xee\x27\xca\x95\xd0\x47\x3a\xf4\x19\x3a\xf4\xe5\x25\x7d\xa0\xa5\xf5\x91\x0e\xae\xb6\xa1\x7c\xaf\xc3\xd0\xfa\x98\x5e\x47\x7d\xd0\xf0\x10\x69\xa6\xe6\xbe\x70\x4c\x7d\xc6\x98\x4e\xe4\x39\xcb\xd8\x62\x5a\x3d\xea\x6a\x72\x80\x92\xba\x92\xe8\x1e\xec\x2f\x70\x3e\x6f\xcc\xa3\x9f\x86\xce\x39\xd9\x7d\x05\xf6\xea\x27\xfb\xb8\x36\xfa\x35\xec\x73\x88\xce\xf2\x42\xce\x8d\x7a\xc5\x7d\x00\xab\xe6\x2c\xea\x71\xef\xa7\xbe\xb9\x51\xbd\x65\x8c\x4c\xe9\x6b\x8c\x5f\xeb\x1d\xa2\xf8\xb6\x86\xa2\xf3\x31\x58\xe5\xc4\x4d\xb4\x7b\xdd\xea\xd3\xd7\xd2\x32\xef\x4c\x25\xfe\x09\xfa\x4a\x70\xc6\xd0\xe6\x05\x6d\x93\xf7\xb5\x26\x4a\x83\xfd\x74\xad\xf2\x46\xf3\x6b\x85\xa4\xf5\x0a\xc3\xda\x7d\x05\x96\x3e\x99\xb7\xb6\x5e\x0f\xfa\x6a\x37\x46\xe7\x7f\x49\xf9\xe9\xec\x46\xf2\x25\xee\xbc\x0e\xb6\x55\xe1\xbc\x6a\x4b\xe8\xf5\x14\xd6\x3d\xde\x2a\xc2\x79\x8a\xce\x94\x9c\xfd\x83\xfe\x71\xe1\x9a\x30\x86\x05\xe8\x48\x1f\x1d\xd9\x88\x2b\x85\xbe\x2e\x91\x9f\x3c\x88\xbd\x51\x86\xf6\x25\x19\x76\xad\xde\xfd\x64\x68\xb4\x7f\x97\x1d\xc3\x37\x67\xd5\x19\x3c\x86\xef\x1e\x78\x80\xbc\xd3\x0c\x7f\x6b\x96\x51\xab\x7a\xdf\xb2\x85\x7c\x70\x15\xed\x8a\xff\x82\x7c\x5e\x0d\x8b\xb1\x04\x4b\xb1\x4b\xd9\x34\x76\x25\x9b\xcd\xae\x63\xf3\xd8\x7c\xfe\x15\x7e\x39\xaf\xe3\xf5\xbc\x91\x4b\xfe\x35\xfe\x75\xfe\x0d\x7e\x15\x9f\xc9\x67\xf1\xd9\x7c\x0e\xbf\x96\xcf\xe5\xf3\xf8\xb7\xf8\xb7\x79\x0b\xcf\xf0\x36\xbe\x98\x77\xf2\x25\xbc\x8b\x77\xf3\xa5\x7c\x39\x5f\xc1\xbf\xc3\x6f\xe3\x2b\xf5\x3b\x88\xff\xc0\xb7\xf0\x5f\xf0\x5f\xf2\x67\xf9\xaf\xf8\x73\x9c\xae\x0f\xfc\xd7\x7c\x1b\xa7\x73\x98\xff\x13\xdf\xce\x5f\xe5\x3b\xf8\x4e\xbe\x8b\xef\xe5\xbf\xe5\xaf\xf3\x7f\xe6\xe4\xd1\xf9\x41\xfd\x5b\xe8\xc3\x9c\xce\x3e\xfe\x3b\x7e\x94\x1f\xe3\xef\xf3\x13\xfc\x03\xde\xcf\x4f\xf2\x53\xfc\x43\x7e\x86\xff\x9e\x0f\xf0\xac\x33\xc2\xa9\x2b\x39\x58\xf2\x66\xc9\xa1\x92\xb7\x69\x3c\x11\xb2\xd6\x18\xca\xb1\x33\xff\xd3\xb8\x83\xef\xdc\xe8\x3d\xbf\xb0\x76\x19\xcf\x83\x76\x78\x2d\xee\x5b\xc3\xee\x13\x16\x67\xf2\x20\x4e\x37\x8f\x18\x4f\x9d\xdc\x67\x31\x8f\x18\x9c\x3b\x8c\xa3\xb7\x18\xf9\xd9\x41\xcf\xa4\xf4\x53\x98\xc0\x3d\xc6\xd1\xcb\x8c\xfc\x4e\x7f\x2f\xe8\x6f\xe8\x0c\xba\xcc\xe0\xbc\xc2\xa3\x83\xab\x3d\xf9\x26\xed\xca\x31\xf3\xe1\xd8\x64\x48\x6b\x18\xe8\x05\x16\x30\xc7\x7e\xce\x51\xc3\xe6\xf3\x07\x8d\xdd\x7c\x6e\xe5\x21\x9e\xcf\x1d\x7c\xf7\x7d\x11\xe3\x0e\x3e\xde\x4d\x5e\x9b\x5f\xb3\xdb\xfe\xb8\xd7\xac\xfb\x56\x27\xde\x60\x9c\x65\x3c\x09\xd2\xef\x6d\xb2\xad\x5e\x5e\xf0\xae\xa6\xdb\xae\x9f\xa7\xe0\x0d\x46\xf7\x4d\xd1\x95\x5e\x6e\xbe\x1d\x6a\xbe\x91\x0b\x69\xee\xbb\xb2\x8f\x78\x88\xee\x5b\x9a\x45\xde\x47\x1d\xe2\x4d\x5a\xf3\xed\x59\x53\xe7\x22\xfa\x0c\xe3\xad\x57\xf7\x89\x92\x9b\x0f\x69\x93\xb9\xc5\x6d\x72\x6e\x6b\x98\x6f\xa5\x16\x8c\xdd\x1c\xf5\xe6\xe2\x16\x36\xdf\x2c\x45\x2f\xc7\xcb\x81\xab\xde\x70\x1c\xfe\x9a\xfd\x24\xef\xb8\x8c\xd1\x77\x38\x19\x6b\xa3\xd4\xc5\xd4\xff\x11\x61\xec\x36\x4a\xca\x5a\x77\x53\x52\xfa\xdd\x4f\xe9\x41\x4a\x0f\x53\x52\x6f\x01\x6f\xa0\xa4\x9e\xc6\x3d\x4d\xe9\x19\x4a\xcf\x51\x52\x63\xdd\x4e\x69\x37\xa5\xd7\x29\xbd\x49\xe9\x1d\x4a\xea\x09\xde\x29\x66\x0d\x3c\xa1\xde\xcf\x1c\xe8\xd4\xf9\x03\x46\xfe\xc4\xb0\xf3\x1d\x46\x9e\x6b\x67\x46\xee\x1e\xf5\x5a\x3a\x3d\x9e\xec\x93\x06\x8f\x91\xe3\x3c\x7e\xea\x8f\xfc\x3c\xd6\xbf\x34\xc1\xef\x6b\xf4\xb5\xd8\xfd\x6d\x88\x7b\xed\xc3\xd3\xfd\x5b\x75\xcb\x5c\x2f\x47\xfb\x36\x83\xff\xf4\x20\x9e\xcb\x0d\x99\xfd\x5e\x8e\xdf\xa4\x8c\x33\xda\xdf\x30\x10\x0d\x69\x38\xfa\x88\x3f\x87\xfc\x6d\x83\xe8\x41\x12\x06\x73\x0e\x7e\x7f\x62\xb0\xe6\xe7\x6b\x93\x73\x5b\xc3\x95\x80\x5f\xfd\x18\x63\x07\x3d\x84\xce\xf8\x7d\xa8\xf9\xee\x93\xe3\xd7\xd9\x40\x1c\xfe\x79\x7c\xee\x37\x0f\xd5\x3b\x3c\x97\x52\xba\x9c\x9d\xef\xef\x78\xd4\x48\x2e\xd1\xb6\x90\x7a\xcc\x97\xe8\x91\x5c\xa2\xd7\x81\xd4\xef\x7d\x4c\xd3\xb9\xcc\xb7\xf4\xeb\x7c\x34\xd6\x8a\x34\x72\xd7\x6a\xcb\xff\x64\x7c\xe1\x5c\xe3\x0a\x3e\xda\xef\x69\xcc\xeb\x3e\xfc\x81\x79\x45\x76\xaf\xe6\x19\xc3\xe7\x19\x57\x79\x6d\xef\xdc\x6f\x1b\x06\xff\xce\x64\xb5\xc7\x63\xd2\xee\xaf\x29\x0a\x7e\x5b\xf2\x0b\x7f\x5e\xe0\x0b\x07\x7b\xcd\x41\xfa\x0c\x96\x39\x38\x37\x7f\x7d\x31\x7c\x9b\x9c\xdb\x1a\xe0\xdf\x57\x7c\xec\xe7\x1e\x35\x6c\xbe\xda\x90\xb9\xda\x90\x3c\xc5\x67\xd5\xff\x2b\x7c\x21\x9d\x23\x55\xb9\x98\x82\xec\x72\xb1\xd1\xe2\xe6\x13\x0a\xe3\x0e\xca\x3d\x9e\x7b\xd4\x51\x9a\x09\x97\xc7\xcb\xd7\x16\xf0\x17\x6f\xd9\x5a\x60\xdf\x09\x7a\xd6\xf3\xb9\xfa\xdf\x0a\xd6\xad\xcc\x7b\x77\x45\xa1\x05\x07\xca\x06\x3a\x07\xe6\x0f\xdc\x49\x7f\x3b\x8a\x3c\x89\xd5\xbf\x2c\xa7\xbf\x32\xf5\xf4\xd4\x72\x06\xce\xe2\x69\x2a\xd3\xa8\xca\x14\x5f\x7d\xf8\x65\x55\xfe\xe3\xe7\x9b\x8e\xeb\xfa\x8f\x06\x7e\xf4\xbf\x03\x00\x00\xff\xff\x8f\xcc\x42\x29\x74\xa9\x05\x00") + +func liberationserifBolditalicTtfBytes() ([]byte, error) { + return bindataRead( + _liberationserifBolditalicTtf, + "LiberationSerif-BoldItalic.ttf", + ) +} + +func liberationserifBolditalicTtf() (*asset, error) { + bytes, err := liberationserifBolditalicTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationSerif-BoldItalic.ttf", size: 371060, mode: os.FileMode(420), modTime: time.Unix(1459927770, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationserifItalicTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xfd\x79\x60\x14\x55\xf6\xc7\x0d\x9f\x5b\x55\xdd\x59\x08\x64\x85\x20\x01\xba\x93\x10\x76\x08\x10\xb6\xb0\xa5\x09\x49\x08\x7b\x80\x04\x12\xd6\x00\x01\xc2\xbe\x0b\x82\x60\x54\x14\x44\x10\x54\x54\xdc\x51\x19\x65\x44\x25\x30\xe8\xe0\x8e\x8a\xe3\x2e\x2e\xa0\xa2\x22\xc8\x16\x51\x1c\x51\x01\x1d\x81\xae\xf7\x73\xab\xbb\x31\xa0\xce\xfc\xde\xe7\x7d\xff\x7b\x32\x1e\x6e\xd5\xbd\xe7\x9e\xe5\x7b\xce\x5d\x4e\x77\x60\x44\x89\x48\x3c\x7f\x58\xd2\x26\x2f\xaf\x70\xc0\xf0\xef\xcc\x3a\xe2\xda\x7c\x9e\xde\xfa\xbd\x73\x72\xf3\x96\x99\xf3\x33\xc5\x35\x6a\x07\xef\x2b\x7b\x17\x0c\x1a\xda\xfe\xde\x67\x6f\x11\xd7\x24\xaf\x48\xf6\xe7\xbd\x87\x16\x65\x27\x7d\x70\xf3\x3b\xe2\x1a\xdd\x4d\x24\xfc\xf0\xa0\xa1\xe9\xed\xcc\x5f\x5f\x7f\x53\x44\xed\x84\xbf\x74\xc2\x8c\x71\xb3\xeb\x2d\xea\xf1\x9a\x48\xf3\x45\x22\xee\xbc\x09\x57\xce\xf7\x96\x25\xf7\x5d\x22\xd2\x3d\x4a\xc4\xf8\x68\xd2\xec\xc9\x33\x96\x8d\x7b\x26\x56\xa4\xcd\x2e\x91\xb0\x1d\x93\xc7\xcd\x9b\x2d\x49\x12\x81\xbe\x4d\xcc\x8f\x99\x3c\xfd\xaa\x49\x99\x73\x5f\xb3\x44\xca\x73\xc4\x9a\xb1\xab\x7c\xe2\xb8\x32\xe9\xb7\x1c\xdb\x14\xfa\xa4\x63\x39\x1d\x35\x6f\x8a\x3a\xcb\xfb\x7c\xde\x1b\x95\xcf\x98\xbf\xa8\xe6\x77\xcd\x8f\x22\xbb\xae\x48\xd3\xd2\x69\x13\xe7\xce\xdc\xff\xc9\x2b\x7e\xb1\x3e\x41\x46\x7c\xc1\xf4\x59\x13\xc6\xd5\xad\x7c\xba\x42\x24\xeb\x10\xe3\x65\x33\xc6\x2d\x9a\x5d\x2b\xd9\xca\x63\xfe\x06\xe6\x7b\x67\x8e\x9b\x31\x31\xfa\xdd\xfd\x05\x62\x9d\x28\x14\xa9\xf1\xf6\xec\x59\xf3\xe6\x77\xde\xff\x65\xb4\x58\x67\xf0\x77\xf2\xb5\xb3\xe7\x4e\x9c\x1d\xef\x5a\x1e\x2d\xd2\x19\x7d\xd6\x9d\x0e\x76\x86\xc8\xdb\xad\x86\x47\x8c\x8d\xee\x76\xc6\xf0\x84\x8b\xfe\x79\xf7\xf6\x06\x7d\x42\xed\xb9\x47\x2f\xdc\x1e\xd9\x2f\x6c\x3f\x7c\x7a\x50\x39\x0c\xfc\x19\x96\xec\xcf\x95\xe1\x91\x5d\xce\x3d\xfa\x9f\x73\x91\xfd\xa4\x4c\x1a\x48\xb5\x9f\xc8\xba\x9a\x27\xb2\xae\x1a\x22\x85\x72\x93\xb8\x99\x1d\x23\xe9\x32\x4a\xc4\xec\x61\x64\x12\x2b\x25\xa6\xd5\x57\xad\x13\x97\x88\xeb\x1e\x57\x86\xb4\x54\x69\x4e\xdb\xdf\xdc\x28\x93\x8c\x38\xe5\x32\x0c\x97\xe9\xb2\x5c\x11\xa6\x75\x48\x22\xed\x02\x59\x64\x23\x36\x59\xcb\x6e\xdb\x73\x68\x2f\xe6\x7b\xed\xf3\xae\x5b\xfc\x79\x2a\x23\x2c\x59\x3d\x5f\x2a\xea\xe5\x83\xbf\x20\xfd\x09\x57\x77\x8d\x84\xd4\x72\x67\x06\x2c\x31\x42\xf4\xb8\x3c\x60\x8e\x52\x2e\x80\x8c\x85\xea\xba\x1f\x97\x05\xf0\x0c\x57\xcf\xc8\x19\xc6\xf2\x8d\xc7\xed\x07\xe9\x7f\xdd\x35\x49\x4e\xc0\x9f\x43\x5f\x7f\xda\x22\x23\xd3\x7e\x98\xfe\x41\x50\x1f\x48\x59\x62\x5f\xa0\xd5\x72\xbc\xd0\x50\x68\x11\xd4\x02\xea\xc6\x9c\x9b\xa0\xb1\xc8\xf8\x46\xcb\xd1\x2d\xae\xa6\x86\x8d\x82\xe7\x88\xbd\xce\x3a\x22\xf1\xae\x61\x32\xd7\xf5\x86\x7d\x82\xf7\x6f\xa0\x33\xae\x37\x64\x0e\xef\xdf\xa2\xff\x57\x73\x8d\x78\x5c\xc3\xe8\x9f\x67\x7f\xe3\x7e\xdc\xfe\x86\xe7\x1f\x19\x9f\x1c\xe2\xd3\xad\xb6\xdd\x9a\x27\x37\xf2\xfe\x02\xf2\xa6\xe1\xc7\x0a\xfa\x5f\xa0\x6f\x01\x74\x85\xd9\x40\xae\x04\xe1\x07\xcc\x06\xf6\x1e\xb3\x54\xf2\xb1\xf7\x94\xf1\xb8\x4a\x67\x5e\x77\xa8\x3f\x3a\xb2\x68\x7b\xe8\x16\xbe\xc4\x80\x4f\xd2\x97\xe7\xb9\xf8\x9a\x46\x7f\x57\x9e\x67\x20\xbf\x6f\xd0\x67\xe6\xd9\x2b\x69\x73\x90\x3d\x14\xba\x82\xf1\x11\xbc\x4f\x82\xb7\x3e\xfe\xb4\x35\xd7\xd8\x55\x50\x11\x3a\x4f\x98\x19\x92\x66\x64\xa8\x1a\xb4\x8d\xac\x42\x29\xd4\xd8\x33\x47\xcf\xbf\x1b\xaa\x07\x4d\x81\xc6\x6a\x1e\xda\x6c\xf0\x7a\xcf\x9d\x80\xcd\x1d\x64\x14\xef\xb3\xc0\xec\x6b\x8d\xbd\xee\xe3\xfd\x36\xe4\x6c\xb2\xca\xe0\x9f\x24\x6d\xa1\x66\x8c\xfd\x6a\xdd\x27\x49\x56\xba\x5c\x85\xec\xbf\xf1\x3e\x97\xfe\x5c\x63\x89\xcc\x85\xbf\xa6\x5b\x24\x3f\x48\x0b\x79\x2f\x0e\xe0\xfe\x47\x0a\x6b\x60\xcf\xd4\xb1\x08\xc6\xe1\x22\xe9\x38\x54\x27\x1d\xab\x50\x1c\xfe\x40\x93\x54\x23\x1d\x3b\x1d\x8b\xea\xe4\xc4\xc2\x89\x95\xfd\x46\x10\xf7\x3f\x10\xba\xb3\x74\x0c\x2e\x27\x8d\x7d\x90\x7a\x41\xe3\xe1\xcd\xfc\x3d\x0e\x97\x51\x99\xcc\x47\xc7\x31\x1d\x8b\xea\xa4\x63\x41\xff\x6c\xa7\xd5\xfe\x6a\xde\xcb\x5a\xed\xbb\xd6\xf7\x97\xad\xce\xd1\xaf\xa4\x87\xd3\x92\x2f\x1a\x1b\x27\x77\xfe\x47\xeb\xe4\x29\x39\xf5\xd7\xad\xfd\xad\x5e\x33\xc1\xb6\xaf\x83\xb3\xf6\x35\xd0\x16\x04\xdb\x19\xc1\xd6\x0c\xbd\xbb\xc5\xfe\xd5\x52\x8e\x6d\x1e\x9d\xa7\x7a\x9d\xe8\x5c\xd5\xa4\xd7\x8b\xe6\x09\xb6\x3e\xa7\x3d\x11\x7c\xbf\x43\xfa\x05\xfb\x4d\x1d\x47\x8d\xe5\xe5\xad\xf5\x80\x84\xbb\x6e\x23\x77\xbf\xa0\x4f\xaf\x37\x8d\xcf\x65\x6d\xd8\x1a\xe2\x3d\xcc\xc1\xef\x8c\x5e\x07\xc1\xd6\x7b\xf1\x9d\x75\xa9\xd7\xc6\x5f\xb6\xac\x59\x6c\x10\xa7\x3d\xc1\x7e\xa2\xdb\x2e\xd2\xd0\xc9\x17\x62\xf6\x7f\x6d\xf5\x7a\xd7\x6b\x4e\xe7\x98\x13\xdf\x8b\xeb\x9e\x38\x5d\xd6\x06\xd7\x77\x7f\x57\x3f\xe2\xb7\x93\xfc\xe6\x99\xf6\x3b\xa7\x6f\x98\xa4\x57\x8f\xb5\xbb\xbb\xe6\x01\x3b\xbd\x37\xec\x94\x0c\xf6\x96\x46\xae\xb5\x32\xd5\x3c\x2b\x1d\xad\x23\xfe\x3d\xf4\xef\x73\xf6\xaa\x47\xd8\x73\x6a\x39\xfb\x85\x13\xa3\x50\x1c\x78\xef\x66\x2e\xb4\xdf\x77\xe7\x4a\xb1\x6b\x98\xff\x23\xf3\xd7\x00\x96\x0e\x7e\xb9\xe0\x37\x89\xe7\x72\xf0\x1c\x80\x1e\xbd\x9f\x1c\xb1\x4f\x23\x33\x05\x6c\x1a\x59\xaf\xd8\xe7\x8d\x14\x09\x23\xae\xbf\x61\x7b\x3b\x67\x7f\x01\x1f\x77\x38\x3e\x8f\xc6\xf7\xb7\x64\xbd\x6b\x16\xcf\xf7\xe3\x6b\x1d\xc7\xe7\x80\x9f\x43\xd9\xb3\x87\x4a\x24\xfa\x1b\x81\xc5\x61\x9d\x5f\xe6\x76\xf1\x98\xb1\xf6\xdb\xc6\x9d\xec\x11\xad\xed\x6b\xd4\x3d\x72\x9f\x91\x25\x2b\x95\x5f\x6a\xea\x33\x20\xb2\x8b\x7d\x22\xfc\xa8\x7d\x22\xac\x81\xf4\x08\x17\xf6\xd9\x27\xc0\x65\xae\xcc\x08\x3f\x6e\xff\x18\xb6\xd6\xfe\x91\x33\xa1\x4f\x68\x8d\x84\x72\xaf\x5a\x2e\xfc\x9f\x62\x84\x3d\xad\x2f\x5f\x6f\xc1\xfd\xe6\x8f\xeb\x23\x88\xdf\xe5\xf9\x86\x6f\xdb\xf0\x69\xb9\xce\xf5\xea\x36\x87\xe6\x85\xad\x67\xfd\xbc\x61\xdf\x77\x31\x87\xff\xa0\x47\xaf\x2f\xf6\x86\x3f\xae\xff\x4b\xd6\x6b\xc0\x47\xfb\xaa\xa0\xaf\x45\x7f\xb0\x23\x90\xdf\xe9\xa1\x3c\xbf\xdc\xd7\xcb\xf2\x7b\x84\xf5\x93\x7d\xd4\x4c\xb6\x1f\x0f\xad\x6f\x57\x9e\xd3\xf6\xb0\x8e\x49\x13\x6b\xb0\x4c\xbc\x18\xbb\xcb\xec\xf9\xab\x75\x77\xd1\x8e\x40\xbe\x97\x60\xeb\xdf\xb4\xbf\xb4\x2f\x69\x6c\xdc\x2e\x49\x27\x4f\x5a\x68\x79\xce\x7e\xae\xcf\x99\x79\xce\x19\xfa\xba\xb6\xcb\x39\x93\x8e\xc9\x28\x73\x29\xe7\x8e\x3e\x7f\xdf\x60\xed\xed\xb3\xc7\x05\xf4\xda\xa7\x2f\xee\x27\x8f\x3b\x73\x43\xfe\x36\x41\x5f\x0b\xe7\x4c\xbb\x49\x8a\x82\xfb\xed\x80\xe0\xf9\x59\x97\xfe\x63\x8e\x4f\x81\x73\x34\x02\x4a\xb7\x5e\x94\x74\xb3\x89\x34\x33\x3d\x8c\x4d\xb6\x8f\x99\x2f\x4b\x6f\x23\xd3\xff\x38\x3c\x09\x9a\xcc\x33\xd2\xdd\xdc\x23\xf5\xcd\xc7\x9c\x3d\x5d\xe3\xd6\x37\x78\xee\x86\x43\x57\x19\x8d\xed\xdf\x68\x9b\x41\xd9\x50\x89\x35\xcd\xc9\xbb\x49\x41\x82\xd7\x7f\xca\x89\x73\xb4\x3d\xcd\xc1\x65\x02\xf4\x28\xbe\x0c\x93\x8e\xd8\x6b\x56\x23\x17\xd4\xdd\x38\x28\x9b\xa1\x75\xe6\x2d\x92\x6f\x7e\x22\x53\xc0\xe1\x82\xd1\xcf\x0e\x77\xc8\xb2\xbf\xa0\xd5\x7e\x9f\x45\x57\x53\xe4\xa5\x5a\xcd\xa4\xb5\xf9\x9d\x94\xe3\x4b\x0d\x70\x4c\xd4\xad\xe9\x62\x6d\x69\xfc\x34\x91\x8b\xd0\x9d\x66\x5f\xfb\x80\xd9\x57\x0a\x68\xdf\x07\x9b\x1a\x3a\x3e\xe6\x6c\xc9\xc5\xdf\x1e\xda\x47\xab\x2e\x67\x71\xa6\x5d\x07\xde\x93\x66\x43\xc9\x71\xee\x0d\xc1\x39\xee\x28\xe9\xe1\x1e\x05\x45\x82\xdd\x12\x19\x61\xde\x21\x23\x5c\x0d\xa0\x3d\xec\x53\xa3\xd8\xaf\xeb\x41\x0d\xa4\xd0\xdc\xcf\x1d\xab\xaf\xfd\x8b\x26\x23\x57\x16\x6b\x52\x83\xed\x77\xd4\x1b\x52\x01\xc5\x6b\x32\x7a\xcb\x35\xf8\x39\xc7\x88\xb4\xf7\xeb\x3b\x9c\xbe\xdb\x71\xcf\x69\x0d\xb5\x85\x7a\x40\x73\xa0\xb1\x46\x2b\x72\xa5\x95\x2c\xe7\x5e\xf1\x18\xe7\x75\x27\xda\x7d\xd0\x27\xec\x05\x4f\x41\x3b\xe1\x69\xa8\xf7\x05\x68\x16\xf4\x60\xf0\x3d\x16\xba\x1f\x9a\x09\x3e\x93\x8d\x4c\x15\xc6\xf3\x8f\x41\xda\x51\x8d\x34\xdf\x41\xe6\x4c\x83\xf4\xfe\xb2\x18\x5a\x02\x0d\x65\x3d\xfd\xdb\xac\x25\xe9\xc6\x70\x99\xa8\x12\x65\x86\xaa\x24\xd6\xd9\xdc\x2b\xb1\xc5\x8c\x91\x3b\x2f\x27\xe6\x8c\x0f\x90\x5e\x8b\xf2\x21\xf9\xf7\x21\x6d\xd3\x20\xcd\x0d\x52\x32\xb4\x06\x9e\x7d\xb4\x91\xb4\x83\x69\x3f\x45\x77\x83\x00\x49\x3f\x4d\x66\x6b\xfb\x45\x4d\x3c\x27\x88\xf8\x35\xe5\x72\x0d\x7b\x0a\xa2\x76\xb1\x67\xf0\x3e\x86\xe7\x83\x6c\x23\xd3\x68\xdf\xe3\x3d\x91\xe7\x9a\x3c\x0f\x85\x74\xed\xd3\x0e\xbe\x97\xe9\xdf\x44\xfb\x35\xed\x17\xf4\x4d\xad\x46\x87\xe9\x67\x8e\xff\x1b\xe8\x44\x90\x7e\x0d\xc8\xb2\x33\x78\xa6\xa6\xf1\x9f\x0c\xb6\x2f\x42\x8f\xd1\xff\x1d\xd4\x9c\x67\xe4\xda\x35\x82\x3a\xa2\x03\x72\xec\x52\xfa\x1b\x43\xcd\xa0\x57\xa0\x1b\xa0\x57\xa1\xdb\xa1\xa5\xd0\x7d\x22\x17\x0e\x40\xef\xc2\x4b\x15\x60\x77\xa0\x6f\x21\x44\x5d\xe3\xdf\xc3\x3b\xb2\xfc\xa9\x41\x9d\xad\x79\x5f\x0d\x9d\x86\xa8\xa3\xec\x91\xe8\xfa\x17\x2d\x32\x65\x22\x84\x7d\x76\x9f\x80\xbd\x17\xde\xa1\xfd\x3e\x60\xa7\x4d\x5d\x65\xdf\x0d\x51\xeb\xf9\xef\x09\xf8\x76\xc1\xc3\xfb\xbf\x45\x57\x97\x62\x53\x07\xfa\x9f\xa3\xad\x1f\x20\x7f\x4e\xa0\x5f\x81\xa3\x4d\xeb\xd7\xb8\xb4\xe5\x59\xe3\x87\xed\xf2\x04\xcf\x1a\xbf\x7f\x42\xe8\xb1\xc1\xd6\x2e\x87\xae\x61\x4c\xfb\x3d\x0e\x9a\x1d\xd0\x67\x63\x97\x3d\x16\x19\x47\x69\xa9\xe5\x6c\x2d\x73\x92\xb6\x9d\xb8\xea\xdc\xb8\x0e\x9a\x6f\xde\x2a\x75\xa0\xee\xba\xd5\x75\x86\xbe\x0b\x43\x19\x7a\xef\xa3\xfd\xcd\x35\xcb\xfe\xd9\x3d\x8c\x3d\xad\x13\x05\xca\x1b\x12\xed\xca\xa7\x86\xd8\xe3\xdc\x7d\xfa\x86\xea\x0f\x6b\x8d\xfd\x83\xb5\x9d\x7a\x41\xdf\x77\xd9\x8b\x83\xf7\xd7\xc9\xa1\xb3\x5c\xef\x8d\x17\x6b\x8f\x06\x92\x1c\x38\xc3\x99\xa3\xef\xb3\x9c\xd3\x7a\x9f\xd7\x7b\xb1\x3b\x91\xbd\x9c\xba\xc3\xb5\x51\xd6\x71\x3e\xb7\xd4\xf3\x9d\xbb\x48\x06\xf6\x35\x91\x96\xfa\xfc\xd7\xfb\x9a\xf9\x84\x8c\x74\xfa\xce\xdb\x07\xe9\x4f\xe3\x6e\xd1\xcd\x19\xef\x2e\xd9\x9a\xc7\xfc\xb7\x94\x39\x7c\x9f\x92\xb7\xdc\x1f\x2c\xcb\xf6\xeb\xba\xc2\x9c\x21\x79\xce\xbe\x6b\xb0\x0f\x7d\x6a\xbf\x6b\x66\x21\xe3\x27\xf6\xb5\x03\xd2\xca\x91\x39\x83\xf7\x1b\xec\x51\xd6\xaf\xb2\x98\x7d\x30\x07\x19\xb9\xf4\x8f\xd3\x73\xf4\xb8\xeb\x0e\xf6\x9d\xf3\xd2\xd7\xfc\x9e\xe7\x44\xec\x8d\xb3\x4f\xeb\xd6\x6a\xc4\xbd\xe7\x51\x30\xbb\x46\x72\x2e\x9e\x31\xc3\xd8\x4b\x6e\x91\x4e\xce\xde\xff\x34\x7b\x4f\x8a\x0c\x30\xef\x93\x2b\x5d\xf7\x73\x5f\x6a\x25\x09\xce\x9d\xe6\x0d\xa9\x65\xfd\x4d\x7a\x5b\x4d\x64\xb2\xbb\x8d\xfd\xa9\xb9\xcc\x7e\x99\xbd\xb7\x15\xb4\xd6\x3a\xcb\x1d\xa6\x9d\xb4\x76\xdd\x2b\xa3\x9d\x7d\x3e\x85\xbd\xfc\x19\xb0\x42\x87\x15\x8d\xbd\xc4\xcc\x39\x63\xf4\x5e\x99\xc9\x78\xa6\xd4\x09\xd6\x07\xb3\xd1\x3d\x47\xe3\x6d\xbd\x6b\x8f\xc7\xcf\xb9\xbc\xd7\xd3\x7d\xba\x0d\xd5\x24\xee\x52\xb9\x85\xb8\xfd\xcb\x35\xc2\x39\xa3\xea\x86\x6a\x13\x7d\x76\x85\x4d\xb3\xdf\x0e\x1b\x63\x7f\xeb\x2e\x93\x1b\x5c\x05\xc4\x4d\xd7\x2b\xe3\xe5\x69\xe7\xfc\xd5\x31\xd7\xf7\xbe\x60\xdc\x5d\x89\x76\xa9\x96\x17\x56\x68\xbf\xc3\xbd\x4e\x1c\x5e\x4d\x7a\x1e\x72\x9c\xb8\x07\xf3\x21\x14\x73\xe7\x4c\xd5\xf5\x26\x32\xdd\xb3\xa8\xa9\x74\xcc\xf5\x9c\xeb\xe5\x50\x78\x31\xf7\x12\x88\x7b\x5d\x6f\xf7\x6f\xdc\x2b\xb9\x5b\x52\x7f\xb7\x0e\xcf\xa6\x2f\xdb\x7e\xce\x89\x9f\x9b\x7d\xfe\x2a\x6a\x1b\x8f\x34\xb3\xa2\xf0\x9d\xb3\x3e\x6c\x4e\xf0\x9c\x0c\xd5\x2b\x2f\x71\x8f\x5f\x6a\x6f\x74\x25\x71\x66\xff\x2a\xb9\xc1\xf3\xb6\x8f\xbe\x27\x06\xef\x06\x7d\xf5\x59\xec\x7a\x4a\x3a\xe9\x5a\xd3\x99\xf3\xa1\x64\x72\x8e\x14\x6a\x22\x26\x99\xae\x69\xf0\x6c\x82\x56\x70\xa7\xda\x84\xbc\x9d\xf6\xee\x8b\x75\xd5\x3e\xfa\x2d\xf2\x63\x29\xcf\x81\xfa\x75\xae\xae\xad\x9c\x98\xcc\x42\xef\x76\x47\x67\x5f\x6d\xc7\xef\xf5\x93\x14\x46\xd4\x01\x87\x44\x19\xc8\x79\x91\x0b\x0e\x7d\xc2\xb6\xe3\x57\x19\xe7\xf2\xed\xf6\xbb\xd6\x30\xfb\x60\x78\x13\x70\xf7\x51\x9b\xec\xb7\xdf\x73\xd5\xb1\x9f\x8b\xb8\x96\x3b\x5a\x82\xcc\x30\xcf\xda\xe3\xf0\x6f\x1f\x6b\xa3\x82\xfc\xec\x75\x31\xcf\x46\xc9\x34\x6b\x0e\x35\x73\xb0\x0d\x3f\x20\x93\xc3\x92\xa4\xbb\x3b\x5b\xca\xa9\x69\x73\xd1\x57\xee\xbe\x52\xf2\x82\x7a\xb7\x07\xef\xe7\x7d\x8c\x6e\xf6\x16\xf6\x86\xca\xc0\xbe\x24\x73\x03\x7b\xb0\xde\x23\xcf\xb7\x80\xda\x04\x6b\xb4\x49\x1a\x7f\x8d\x41\x30\xb7\x56\xb2\x3e\x4e\x18\x37\xe0\xdb\x1a\xfb\x7b\x8d\x3f\x36\x9e\x24\xcf\xeb\xeb\xf8\x3b\x31\x20\x07\x74\x1c\x74\xfc\xb5\xef\x7f\x68\x6d\xfb\x36\xab\xb3\x3d\x49\xe7\x84\x8e\x8b\xfb\x27\x72\xea\x37\xc9\x0d\x4f\x21\x47\x56\x48\x4b\xec\x7b\x1a\xfb\x9a\x85\xea\x88\xe0\xe7\x12\x7d\x9d\x7d\x40\x58\xbf\xf3\x9c\xf5\x58\x43\xe7\x8c\x8e\x1b\x63\x1f\x5b\xdd\xf1\x9f\xdc\xd1\xf1\xfb\xbd\x75\x6a\x93\xbe\xee\xe5\xe2\xb1\xc6\x8a\x3b\xd4\xea\x1c\x0f\xd9\x8a\x4d\x55\xd8\x94\xab\xf3\xd4\xc9\x95\x80\x4d\x4d\x43\xb6\x85\x64\x39\x39\x4c\x1e\x39\xf5\xe0\x5f\xdc\xc1\x2f\xde\x39\x75\x7d\xc3\xdd\x2d\xd4\x5e\x8e\x0b\x2d\xb5\x85\xbd\x3f\x84\xef\xef\xed\x5f\xdc\x55\xc9\x7d\x27\xff\xc6\x6b\x5c\xec\x92\x60\x5b\x74\xf1\x3d\x68\xa3\x5e\x8b\x3a\x1e\x7a\xcd\xe8\xbc\x0d\xbd\x87\x70\xba\xd8\xee\x94\xa5\xfa\x8e\xe9\x9e\x22\x4b\x5d\x0f\xd3\x76\x92\x77\x5c\xad\x58\x8f\x4d\x65\x2d\xfc\x23\xc2\xba\xd8\x6f\xbb\x1a\xdb\x1b\x75\x2d\xe0\x5a\x07\x06\x6f\x10\x87\x33\xd2\xdb\x35\x53\x6e\x0c\x1b\x41\x3e\x9f\x95\x54\x72\xbe\xd9\xef\x98\x39\xb5\x43\x4e\xa8\x86\x0c\x9c\xef\xf2\x13\xe7\x8c\x9f\x56\xd3\x29\x1a\xce\x59\xfd\x69\x9e\x7d\x2d\x34\x2b\xd0\xfa\x5f\xa0\xef\xd6\x00\xd9\xc3\x78\x3f\xc6\xf3\x2b\x81\xb3\xd1\xff\x61\x30\x37\x0f\x06\xe6\xfa\x3b\x05\x9e\x25\x26\xc0\xa7\xc7\xf5\xb3\xcd\x1d\xc2\x5e\xcb\xfb\xb0\xc0\x27\x73\x76\x12\xcf\x65\xd0\x92\x00\xd9\xfa\xfc\xde\x1e\x94\xb7\x3f\x40\x52\x1a\x20\x7d\x0f\xb0\xf5\x39\xdf\x96\xbb\xd2\x79\xda\x53\xd6\xb5\x6a\x60\x68\x9c\x58\x6b\x99\x0b\xe8\xbf\xc2\xb8\x47\x38\x97\xed\x1d\xd6\x7b\xdc\xfd\xbf\xb0\x3f\x36\x36\xf1\x9c\x4c\x3e\x56\x72\x46\x44\xc9\x02\xa3\xab\x94\x59\x2f\xb0\x2f\xef\xa3\x2e\xbc\x02\x1c\xff\x4d\x5d\x71\xc2\x7e\x85\xdc\xba\xde\xf2\x4b\xb1\xf5\x92\xd4\x32\x22\xa5\x89\x71\x0f\xf3\xd6\xc8\x54\x6b\x85\xfd\xa9\x95\xc6\x9c\xb6\xf6\xd7\x56\x0b\xee\xc9\x6d\xc5\x6d\xe5\x4b\xb8\x9e\x47\xcd\xf0\x84\xf5\xb5\xbd\xc7\x91\x71\x16\x59\x27\x64\xad\xda\xcf\x1d\x3a\x12\x6a\x63\x0f\xb3\x6e\xb5\x87\x81\x73\x6b\xb3\x97\xd4\x36\xef\x27\x0f\x63\x59\x8b\xb1\xd4\x02\x1e\xce\x3e\xf2\x0b\xbb\xd3\xcd\x30\xee\xec\x5b\x38\xab\xda\xb1\xdf\xbe\x6b\xbf\x6e\xd5\x70\xf6\xc4\xee\xe6\x9b\xf6\xcf\x56\x73\xee\xe6\x9a\xee\x92\x14\x47\xce\x0d\x12\x8d\xae\x1c\xa8\xbb\x99\xc7\x7e\xf6\x03\x7b\x5c\x27\xea\x94\x48\xce\x95\x93\x72\x1d\x7b\xca\x30\xd7\x52\x6a\xa1\x1f\xe4\x0e\x73\x8c\xd4\xb7\x1e\xb0\xf7\x9b\x9d\xd8\x03\x3e\xe4\x3e\xd8\x51\x1a\x58\x93\xa8\x8d\x5b\x31\xbf\xad\x3d\xc3\x32\x39\x7b\xb5\x8c\xb3\x32\xc8\x7c\xd8\xde\x68\x16\x4a\xb4\xb5\xde\x3e\x67\x8e\xe4\x0c\x1b\x01\x7d\x02\x5f\x4f\x87\xca\xd9\x53\xee\x34\xbe\x40\x4e\xa2\x0c\x30\x9e\x95\x89\x9c\xc3\x03\xcd\x76\x60\xb8\x92\xf1\x27\x90\xf3\x33\xed\x7b\xb2\xce\xd8\x4e\x9d\xe1\xe1\x1c\x5f\x02\x25\xca\xc3\xa6\x5f\x5e\xb3\x6e\x96\x47\xcc\x36\xb2\x10\xaa\x70\xda\xa6\xdc\xa9\x9b\x48\x85\xb1\x44\x16\x82\xff\x22\x68\xa6\x3a\x2a\xd3\xa0\x6c\xa3\x8f\x0c\x55\x39\xdc\xe9\x7d\xe0\x39\x4c\x96\x19\xcd\xa1\x3e\xf0\x25\x10\xe3\x3e\xdc\xab\xf5\x73\x2f\x89\x54\xc5\xb2\xd2\x28\x96\xb5\xc6\xcd\x72\xa3\x39\x97\xb6\xbb\x4c\x30\xc0\xdd\xc8\x93\x1e\xea\x33\xda\xae\x72\xa5\x31\x07\xde\x26\xf6\x29\xe4\xb9\xd4\xaf\xf6\xcf\x46\xb1\xed\x37\xba\xdb\x1f\x19\x79\xf6\x93\xea\x33\xfb\x53\xda\xbd\xc6\x1c\xfb\x38\x3c\x63\xa9\x3f\x34\xe6\xb5\xf5\x5a\xe3\x4c\xa8\x64\x9d\xeb\xfd\xf3\x17\x28\x8d\xda\xe7\x7e\xe3\x20\x77\xaa\x06\x52\x93\xb1\xdb\x9d\xda\x55\x7f\x9e\x5c\xcc\x1d\xe5\x75\xd6\xdd\x3d\xf6\x0b\xd4\x6e\xff\x21\x96\xa9\xce\x9e\x7b\x52\xda\x5a\xcd\x9c\x9a\xb7\xbf\x23\xef\x13\xce\x92\xe7\x45\x05\x3f\x23\x91\xdf\x3f\x57\x85\xb7\x81\x9d\xeb\x9c\x47\x1f\xda\xe1\xce\x9d\x47\x7f\x8e\x1a\x90\x1f\xfa\x8c\xcf\xf9\x9c\x36\x58\x57\xee\xd0\x9f\x2b\xe8\xb3\x0b\xbe\x1f\xa8\xdf\x5a\x04\xcf\xaa\xd5\xe0\xba\xc3\xa8\x27\x4f\x40\x57\x1a\x43\x64\x33\x58\x5e\xa9\xca\x64\x3d\x34\xc3\x58\x29\xb7\x61\xeb\x6b\xe0\x70\x33\xb4\x07\xba\x2e\x40\xf6\x6f\xb4\xcf\x43\x37\xaa\xd7\x65\xab\xd9\x42\xb6\x43\xaf\x19\xcd\xed\x23\xe0\xbe\x1d\x6a\x05\xde\x5b\x88\xd3\xa3\x6a\x8f\x2c\x57\x65\xf6\x8f\xe0\x7e\x3d\xb2\xee\x35\xc6\xcb\xc3\xb4\x7b\xa1\xdd\x60\xbf\x46\xfd\x20\x8b\x34\x19\x49\x4e\xdb\x8d\x79\xdc\x7f\xed\x5b\x20\x7d\x07\xbe\x0a\xe2\x9c\xb2\xd3\xff\x82\xda\x05\xf7\x91\x9c\xdf\xf7\x6b\xee\x2b\x1a\xbf\x4b\xdb\xe6\x97\x7c\x36\x29\xbf\x7f\x36\xf9\x17\x6d\xe7\xbf\xf8\x8c\xb2\x76\xb0\x75\x57\xeb\x3f\x03\xae\x49\x97\x7d\x46\xd9\xf7\xcf\x5b\xfb\xd9\x6a\x9f\x5d\x56\x90\x13\x3d\x2e\x7e\x4e\x14\xfa\x2c\xe7\xb2\x36\xf8\xf9\x63\x8b\x4b\x5b\xfb\xba\x60\x3b\x26\x70\xef\xe2\xfc\xbb\xac\xfd\xab\xcf\x2b\x83\x6d\xde\xff\xfc\xcc\x24\x78\x0f\xa8\xde\x56\xfb\xec\x32\xfa\xd2\xd6\x7e\xc1\xfa\x5f\x9f\x61\x5e\xfe\x59\xcf\x25\xad\xf6\xc7\xf9\x0e\xe1\x9a\xcb\x3e\x23\x6a\x13\x6c\x7d\x7f\xf8\xec\xe8\x88\x4c\xd3\x79\x1f\x6a\x43\xe7\xd2\xff\x6a\x83\xe7\xe3\x77\x17\xdb\xe0\x67\x43\x7f\xf1\x39\xe8\x17\xc1\xcf\x59\x46\x04\xbf\xab\x28\x71\x3e\xdb\xcb\x94\x44\xd7\x55\xce\xfd\xfa\x4f\x3f\x1f\xff\xff\x63\xfb\x7f\xfa\xdc\xfc\xaf\xda\xcb\x3e\x0f\xef\xf1\xbf\x62\xfe\x5f\xdb\xdc\xff\x53\x7b\xe9\xe7\xcd\xc1\xcf\x60\xff\x57\x5b\xfd\xf3\xe8\x3f\x6d\xa9\x01\xff\x2b\x05\xbf\x97\x71\xf5\xb6\x8f\x42\xa7\x79\xae\xa8\xfe\x7d\x8d\x53\x33\xfe\x09\xb9\xb6\x50\xc3\x6e\x91\xae\xee\x4f\xc5\x80\x9a\x84\x5a\xa7\xb6\xfc\x2f\xe4\x5e\x2b\x57\x40\x5d\xc3\x9e\x17\x03\x6a\x52\xad\xcd\xd3\xe4\x7c\x26\x17\xa0\x74\xa8\x10\x9a\x14\x7c\x5f\xe4\xd4\xab\x73\xc9\xad\xb9\xac\xed\x07\xc4\x80\x9a\x54\x6b\x73\xa1\x1c\xeb\x2f\xbe\xf7\x41\xe7\x3c\xe8\x0e\x74\x34\x86\xfa\xba\x7f\xb6\x2f\xb8\x7f\x96\x14\x5d\xb3\xfe\x37\x72\x75\x15\xe5\x7e\x47\x0a\xa0\x41\x50\x1f\x5d\xf3\xfe\x37\x72\xdf\x2a\xab\xa1\xa7\xc2\x5e\x94\x1e\xd0\x04\xf7\x19\xdb\xef\x3e\x23\x29\x50\x4f\x28\x3b\x84\xfb\x45\x2c\x83\xb8\x84\xfc\x0e\xd9\x7b\x51\x7f\x50\xee\xff\xcf\x71\xfc\x95\x3b\xcf\x7f\xa1\xff\x12\x97\x0c\xa8\xdd\xff\x33\xbf\x1d\xdf\x2f\xf1\xfb\xbf\xd9\x5e\x9d\x8c\xc7\x95\xfe\x5c\x6e\x3e\x6d\x17\xda\x42\xe8\x6f\x97\xd9\xdc\xc7\xb1\x3b\x5a\x1e\x85\x86\x13\xcb\x47\xa1\xa2\xc0\x77\xba\xf2\x71\x90\xde\x0f\xe2\x3a\x30\x50\x77\x3a\xe4\x73\xea\xd0\x50\x2d\xff\x89\x6c\x82\x86\xa1\xc7\x1b\x20\x39\xfb\x87\x3c\xd0\x9f\x83\x68\x0a\xbe\x07\xbf\xfb\x59\xe0\x36\xa5\x12\xea\xa7\xd7\x01\x73\xdd\x41\xea\xf1\xa7\xf8\xfc\x2c\x9f\xb1\xb6\xeb\x80\xc5\x17\xae\xb7\xa8\xef\x9d\xcf\x6e\xf4\xe7\x48\x2a\x4a\xdf\x6b\xc2\x03\x1f\x6a\x39\xad\xb1\x25\xf0\xdd\xb9\x2a\x0a\xf4\x39\xcf\xba\x02\xdd\x12\xfa\x9e\xdf\xfe\x04\xf2\x42\x9f\x72\x7e\x73\xdf\xb1\x7f\xd2\x44\x9d\xf5\x53\x38\xad\xfe\xde\x25\xf8\xfd\x73\xf0\x73\x59\xd9\xac\xed\xb2\xe6\xa9\x96\x90\xfe\x0e\x6b\x28\xad\xfe\x1c\x7d\x05\x64\x1a\xef\xc9\xca\xb0\x06\xce\xfd\x5d\xcb\x1b\x40\x1b\x17\x22\xad\x17\x9b\xba\xaa\x5d\x72\xc4\x2c\x92\x1f\xcd\x51\x5a\x96\xf3\x99\xed\x10\xeb\x0e\xfd\xf9\xad\xbd\x5b\x0d\xf3\xeb\xcf\xca\xe6\x57\x9b\x17\x13\xa4\x58\xfd\x6e\x4c\x92\x58\x28\x0d\x5a\x06\x75\xa4\x36\x1e\x68\x0c\xe7\x6e\x78\x85\x7d\xda\xe8\x43\x9b\x67\xbf\xac\x9f\xb9\x3f\x2f\xe2\xac\x98\x1d\xf8\x3e\xc1\xfe\x0a\xdb\xea\x85\xce\xe3\xb0\xef\xec\xaa\xf0\x39\xd2\x80\xb3\xc8\x6b\x1d\xa0\x96\xab\x67\x9f\xd7\xe7\x62\xe0\x7b\x7b\xb9\x11\x1b\x9b\x31\xe7\xa5\x6a\xdf\xd9\xaf\xd3\x77\x49\x2d\x0b\x1b\x9a\xb8\xb7\xc8\x63\xd8\xdf\x3c\xec\x66\xfb\x75\xfd\x1d\x77\xd8\xa7\xb2\xcc\x9d\x46\xed\xf1\x9e\x14\x87\xd5\xa2\x16\xf0\x48\x9c\x5b\xa8\xb5\x85\xf3\x2e\xf0\x3d\x76\xf7\x60\x7b\xb3\xfe\xdc\x2f\x5c\xd4\xc3\x96\xa8\x98\xcb\x5b\x4d\xe6\x69\xd6\xe7\x31\x69\xed\xbe\x53\xe6\xba\x76\xc8\x28\xfd\x3b\x08\x0e\x26\x22\x7f\xb3\xca\x24\x83\xbe\xcc\xb0\x7d\x6a\x83\xeb\x0d\x55\xcf\x68\x6b\xdf\x41\x5f\xb1\xa5\x3f\xcf\x80\x8f\x76\x9c\x43\xef\xc9\x3d\xce\xfb\x3e\x23\xc5\xda\xa7\x5c\xae\x2d\xf6\x59\xeb\x7b\xb5\xcb\xb5\xc5\x58\xa3\x9f\xff\xd8\x5e\x4e\x6a\x7f\x60\x4c\xb7\x9a\xaa\x8f\xfd\x7f\xdb\xff\x7f\x21\xee\xd4\x97\x90\xb1\x8f\x76\xb2\xf3\xbc\x8f\xbc\xdd\x27\x4b\x20\xb7\xf1\x09\x67\x28\xa4\xf3\x3a\xec\x3b\xf5\x00\x74\x6b\xa8\x05\xb7\x70\x78\x1e\xb3\x5e\x91\xf1\xb4\xdb\xa1\x66\x9a\xe0\x9f\x17\xde\x42\x6d\x0b\x9f\xa6\x3e\x0c\x2b\x52\x79\x6e\x51\x9f\x43\x83\x2d\x1f\x77\x3b\x9f\x74\xb3\x76\x71\xee\xd5\x66\x4f\x11\xd9\xed\x76\x62\x60\x1f\x08\xde\xf1\xba\x38\xdf\x41\xe9\x7b\xd7\x11\x59\xe5\xe4\x76\xa6\x9d\x7f\xf1\x1e\x79\xf1\x5e\x18\xb8\xa7\xb8\x5e\x22\xcf\xe6\x07\xee\x3f\xee\x89\xfa\x8e\x22\x2e\x6a\xc1\x33\x66\x2e\xf1\x9c\xa1\xbf\x87\x94\xda\xe4\xce\x23\xd0\x4b\xc1\x3b\xf3\x70\xe2\x6d\x68\x62\x3d\xad\x82\x2a\xf4\x1a\xa3\x3f\x42\xd7\xdf\xac\x85\x29\xfa\x7b\x01\xb3\xbb\x4c\x54\xcf\xc8\xe7\xea\x19\x55\x0b\xbd\xfa\xbb\xe0\x44\xfa\xdb\xe9\xef\x12\x82\x6b\x37\x36\xd8\xd6\xd3\xad\xae\x87\x69\x6f\xd6\x75\xac\x53\xf7\x52\x43\x87\x6a\xe7\xea\x35\xb2\xae\x77\x75\xdd\x6b\x5d\x23\xc5\xba\x06\xae\x4e\xce\x9c\x20\xfd\xb1\xfe\xb6\xcf\x1a\x5d\xc1\x20\x50\x7b\xbb\x2f\xa9\xbd\x75\xdd\x1d\xaa\xb9\x43\xf5\xf6\x9f\xd4\xda\xba\x86\xd7\x72\xf5\x3c\x87\xe7\x19\xb9\x5e\xe4\xc2\xdb\x84\xf5\xab\xc0\x77\x04\xf2\x75\x78\x70\x77\x22\x9f\x3b\xe0\xb3\xae\x7b\xda\x41\x1d\xd9\xbd\xd2\x7f\x27\xf9\xf5\x77\xd2\xdf\x7f\x5c\x00\x8b\xf3\xc5\x81\xef\x48\x1c\x3a\x18\xf8\xce\x44\x7f\x47\x11\xe2\x0b\xcd\xd5\xfc\x9a\x2e\xf2\x5e\x46\xe7\x6d\xe8\x66\x91\x73\xdf\xd1\xee\xa1\x7d\x34\xd0\x7f\x41\x7f\xf7\xb2\x1c\xc2\xde\xf3\xff\xe1\x7d\x31\x34\x89\xe7\x07\x68\x53\x69\xbb\x5c\x2e\x4b\xdf\xfd\xb0\x21\x37\xf8\x79\x4c\x58\x20\xc6\xce\x7b\xb4\x35\x5c\x36\x5e\x46\x03\xa0\x21\xc1\x56\x53\x9e\x19\x23\x79\xb4\x1d\x82\x34\x08\x6a\x05\xe5\xd3\xaf\xdb\x46\x50\x5a\x90\x9a\x40\xe9\xf4\xeb\xe7\x06\x50\x22\xd4\x31\x48\x6d\xe8\x6f\x16\x9c\xdf\xbf\x1a\x8d\xa1\xbf\xff\x9f\xd8\x51\x10\x1c\xcf\x0b\xf1\x06\xf9\xd2\xa1\x4c\x28\x2b\x44\xf4\x67\x05\x75\x74\xa8\xa6\xaf\x23\xfd\x1d\x2e\xd3\x15\x92\x53\x7e\xb9\xec\x6a\xf2\x2f\xb7\x63\x18\x34\x1c\x2a\x09\xb6\xc3\xe0\x1b\x45\xdb\x19\xea\x14\x24\xfd\xdc\x99\x7e\xdd\xf6\x86\x72\xab\x13\xfd\xba\xbd\x36\x48\x99\x41\xea\x42\xbf\x6e\x6f\xbd\x9c\xfe\xc2\x8e\xcb\xfd\x18\x04\x9f\xc6\xb2\x4d\x35\x9f\x35\xde\x0d\x82\x38\xa7\x07\xe3\x11\x8a\x4d\xa3\x60\x5c\xf2\x83\xf1\x1b\x14\x8a\x69\x30\x8e\x79\xd5\x62\xee\xc4\x3f\x18\xf7\x4b\xec\x20\xef\xf4\x67\x0f\xe4\xa5\xbd\x3b\x48\x3b\x83\xdf\x57\xcd\x0b\x9e\xe7\xaf\xe9\xfb\xee\xff\xba\xe3\xc1\xd3\xfb\x32\xba\xaa\x3a\xfd\xaf\xbb\x2c\x3c\x53\xab\xd3\x9f\x8c\xcf\x75\xdd\x16\xfc\x0e\xea\x36\x19\x12\xf8\x7e\x51\x7f\x5e\xa8\xf3\xdf\xcf\xda\xf2\x3f\x04\xbd\x17\xf8\xbe\x4f\xdf\x3f\xf4\xf7\x93\xfe\xaf\xf5\x1d\x40\xff\xee\x18\x7d\x87\xf5\x77\x5c\xb4\x91\xf4\x6f\x08\xb4\xfa\xf3\x45\xbb\x5f\x35\xca\x67\xdf\x51\x0e\xe9\x7d\x48\xef\x69\xec\x25\x21\x72\xf6\x24\xf6\x30\xd6\xe5\x8f\x90\x5e\xab\xff\x31\x5f\x97\x58\xe7\xfb\x06\xea\x22\xfd\x6b\x6d\x41\xaa\x1f\xf8\xad\x48\xab\x1b\x6f\xca\x79\xb7\x2c\xaf\xfe\xb5\x3a\xfd\x6b\x92\x5c\x9c\x96\x99\xb3\xcc\x05\xe6\x32\x73\x95\xb9\xda\x7c\xc8\x7c\xdf\x15\xef\x6a\xe0\x7a\xc3\xf5\xad\xeb\x74\x83\xb7\x1b\xde\xdb\xf0\x81\x86\xff\xf1\xd4\xf6\x34\xf0\xe4\x7a\x06\x78\x86\x7b\x4a\x3c\x23\x3d\xa3\x3d\x4b\x3d\x3b\x3c\xbb\x3d\x1f\x7b\xbe\xf0\xfc\xe0\x39\xed\xf1\x7b\xa3\xbd\x29\xde\xc6\xde\x36\xde\xf6\xde\x2e\xde\x6e\xde\x1e\xde\x1c\xef\x18\xef\x2c\xef\x02\xef\x22\xef\x35\xde\xf5\xde\xa7\xbd\xa7\x92\x5d\xc9\xf1\xc9\x89\xc9\x29\xc9\x8d\x93\x5b\x27\x0f\x4c\x2e\x4c\x1e\x93\xbc\x3c\xf9\x8e\xe4\xcd\x29\x46\x8a\x3b\x25\x3a\x25\x2e\xa5\x76\x4a\xbd\x14\x4f\x4a\xb3\x94\x16\x29\xf9\x29\xe3\x52\x26\xa6\x1a\xa9\x31\xa9\xc9\x69\x5c\x85\xd2\xa2\xd2\x62\xd2\x12\xd2\xea\xa6\xd5\x4f\x6b\x94\xd6\x32\xad\x7d\x5a\xb7\xb4\xe9\x69\x15\x69\xcb\xd3\x56\xa6\xad\x4e\xbb\x3d\xed\xa1\xb4\x27\xd2\xb6\xa7\x3d\x97\xf6\x42\xda\xee\xb4\x77\xd3\xf6\xa4\xed\x4f\x3b\xde\xb8\x5b\x63\x5f\xe3\xec\xc6\xa5\x8d\x27\x34\x9e\xd4\x78\x5a\xe3\x59\x2d\x67\xb4\x5c\xd8\x3a\xf1\xb1\xe4\xc7\x56\x9f\x32\x4e\xb9\x4e\xd5\x3a\x67\x9c\xeb\x78\xae\xdb\xb9\x1e\xe7\x7a\x9e\xcb\x39\x37\xc8\x9f\x6a\x9f\xb7\x6d\xe7\x77\x32\x37\x9a\xf3\xcd\xc5\xe6\x72\x50\xb8\xc5\x7c\xc4\xfc\xc0\x55\xcf\x75\xab\xeb\x03\xd7\xa9\x06\xd2\xc0\x0f\x0a\x1b\x3d\xe2\xa9\xeb\xf1\x7a\xf2\x3d\x05\x41\x14\xc6\x7a\x2a\x3c\xcf\x78\xfe\xe5\xf9\xc4\x73\xc0\xf3\x93\xe7\xac\x57\xbc\x71\xa0\xd0\xdc\xdb\xce\x9b\x79\x11\x85\xa9\xde\xf9\xde\x85\xa0\xb0\xce\xbb\x31\x88\x42\x9d\x20\x0a\x03\x92\x87\x26\x8f\x04\x85\x75\x17\x51\x88\x05\x85\x2b\x52\x1a\x06\x51\x28\x4d\x29\x73\x50\xf0\xfe\x05\x0a\x05\x17\x51\x58\x97\xb6\x31\xed\xf1\x8b\x28\xbc\x0d\x0a\x9f\x81\x42\x97\x8b\x28\x4c\x6c\x3c\x15\x14\x4a\x5b\xce\x01\x85\xc4\xc7\x56\x9e\x52\xa7\xac\x53\x91\xe7\xd4\xb9\x06\xe7\x3a\x83\x82\xef\x5c\xaf\x73\x79\x7e\xaf\x46\xc1\x3e\x62\xbf\x6a\xbf\x64\x3f\x67\x3f\x6d\xef\xb0\xff\x61\x6f\xb7\xb7\xd9\x5b\xec\xce\x76\x1b\xbb\xc5\x37\xde\xaa\xef\xab\xbe\xab\xfa\xb6\xea\x68\xd5\xe1\xaa\x43\x55\x5f\x55\x7d\x59\xf5\x45\xd5\xe7\x55\xfb\xab\x3e\xab\xfa\xa4\x6a\x5f\xd5\xde\xaa\x8f\xaa\x3e\xac\xda\x53\xf5\x7e\xd5\x7b\x55\xef\x54\xbd\x59\xf5\x7a\xd5\xee\xaa\x5d\x55\x2f\x57\xbd\x54\xf5\x6c\xd5\xc6\xaa\x3b\xaa\x6e\xad\x5a\x57\xb5\xaa\x6a\x71\xd5\xac\xaa\x0e\x55\xc9\x55\x09\x55\x71\x55\xe1\x55\xae\xe3\xfe\xe3\x87\x8e\x7f\x79\xfc\x93\xe3\xdb\x8e\x3f\x7a\x7c\xfd\xf1\xae\xc7\x3b\x1f\x6f\x73\x3c\xfd\x78\xab\xe3\xcd\x8f\x37\x39\xde\xf0\x78\x83\xe3\xea\xd8\xb7\xc7\xbe\x39\xd6\xff\x58\xd6\xb1\x36\x47\x86\x1c\x19\x7c\x24\xff\x48\xee\x91\xec\x23\x59\x47\xba\x1d\xe9\x70\xa4\xf5\x91\x26\x47\xbc\x47\x6a\x1e\xfe\xed\xf0\x2f\x87\x4f\x1f\xfe\xf1\xf0\xbf\x0f\x1f\x3e\xfc\xf9\xe1\x7d\x87\xdf\x3f\xfc\xde\xe1\x7f\x1d\x7e\xe5\xf0\xcb\x87\xff\x79\x78\xcb\xe1\xe2\xc3\x45\x87\x0b\x0f\x77\x3a\xdc\xe1\x70\xfb\xc3\x6d\x0f\xb7\xfe\xb2\xc7\x97\x5d\x3f\xbf\x6f\xdc\xfd\xe3\x3a\xd5\x7d\xad\xee\xab\x75\x5f\xaa\xf9\x5a\xcd\xca\x9a\x5b\x6b\x3e\x55\xf3\xc9\x9a\x4f\xd4\xdc\x12\xf9\x45\x84\x19\xfc\xfd\xe1\xff\xb7\xff\xb8\x8d\x48\xdd\x28\xf9\x03\x1e\xca\x29\xb2\xf4\x8f\xf1\x3f\x64\x04\x66\x9a\xec\x2f\x2e\x71\xb3\xcf\x84\x4b\x84\x44\x4a\x0d\x89\x92\x9a\x52\x4b\xa2\x25\x46\x62\x25\x4e\xe2\x25\x81\xbb\x63\x1d\x49\x94\xba\xec\x65\xf5\x24\x89\xdd\xa9\x81\x34\x14\x0f\xeb\x31\x59\x52\x24\x55\x1a\x49\x9a\x34\x96\x26\xd2\x54\x9a\x49\x73\x69\x21\x2d\xa5\x95\xb4\x96\x74\x69\x23\x6d\xa5\x9d\x64\x48\x7b\xe9\xc0\xcd\xa9\x93\x74\x16\x6e\xb5\xd2\x55\xba\x49\x77\xe9\x21\x59\xe2\x93\x9e\x92\x2d\xbd\xa8\xd6\x72\x25\x4f\x7a\x4b\xbe\xf4\x91\xbe\xd2\x8f\xdd\x77\x80\x0c\x94\x41\x52\x20\x83\xd9\xb9\x87\x4a\xa1\x14\xc9\x30\x19\x2e\xc5\x52\x22\x23\x64\xa4\x8c\x92\xd1\x32\x46\xc6\x4a\xa9\x8c\xc3\xfe\x1b\x65\x85\xdc\xc4\x89\x74\xbb\x6c\x90\x07\xe4\x11\x79\x58\x36\xc9\xa3\xf2\x37\x79\x4c\xfe\x4e\x95\xc9\x9d\x4f\x9e\x94\xad\xdc\xc2\x2a\x65\x9b\xfc\x43\x9e\x96\x1d\xf2\x8c\xec\x94\x7f\xca\x0b\xf2\xbc\xbc\x28\x2f\x85\x7d\xc7\x4d\xb6\x4c\x26\xca\x94\xb0\xef\x65\x91\x3c\x24\xb3\x65\x5a\x78\x73\xb9\x52\xa6\x86\xf7\x95\x95\x72\x4f\x78\x2e\x37\xf8\xfe\xe1\x03\x64\xb2\x2c\x0c\xef\x1e\xee\x0b\xcf\x32\xe7\x86\xe7\xcb\x74\xb9\xda\x1c\x29\x9b\xe5\x39\xb9\x56\x26\xc8\xcc\xf0\x1c\x55\x18\xde\x27\xbc\x07\x37\xad\xa5\x61\xff\x96\xf1\x72\x9d\xdc\x20\x77\xa9\x04\x55\x3b\xec\xab\xb0\x83\x61\x55\x61\xdf\x84\x1d\x09\x3b\x2a\xcf\x86\xdf\x2c\xaf\xa8\x2e\x61\x17\xc2\x93\xc2\xfe\x13\xf6\x5b\xf8\xee\xf0\xd7\xc3\x4e\xca\x55\x61\xc7\xc2\x4e\x84\x9d\x91\xe5\xb2\x9a\x9b\xe8\x1a\x59\xc5\x1d\x7a\x9d\xdc\x2a\xb7\xc8\x1d\x72\x27\x1e\xae\x97\xfb\xe4\x7e\xb9\x57\x7e\x36\x56\x1a\x0f\xc8\x1c\xe3\x1e\xe3\x5e\xe3\x3e\x59\x6c\x3c\x68\xdc\x6f\xdc\x24\xe2\xeb\x3d\x72\x44\x49\x71\x51\xe1\xd0\x21\x83\x0b\x06\x0d\x1c\xd0\xbf\x5f\xdf\x3e\xf9\xbd\xf3\x72\x73\x7a\x65\xf7\xf4\x65\xf5\xe8\xde\xad\x6b\x97\xcc\xce\x9d\x3a\x76\x68\xdb\x26\xbd\x75\xab\x96\x4d\x9b\x34\x4e\x6b\x94\x9a\x92\xec\xa9\x9b\x10\x1b\x13\x5d\xab\x66\x8d\xc8\x88\xf0\x30\xb7\xcb\x32\x0d\x25\x2d\xbd\x95\xaa\x34\xb7\xd2\x4c\xf3\xc6\xe6\x8d\x4b\xcd\x4d\x1d\x97\xdf\xaa\xa5\x37\xb7\x6e\x79\x4e\xab\x96\xb9\xa9\x79\xa5\x95\xde\x71\xde\x4a\x1a\xab\x71\x6a\x7e\xbe\xd3\x95\x3a\xae\xd2\x5b\xea\xad\x6c\x4c\x33\xae\x5a\x77\x69\xa5\x0f\xce\x49\x97\x71\xfa\x02\x9c\xbe\x8b\x9c\x2a\xc6\xdb\x4d\xba\x69\x15\xa9\xde\xca\xf7\x72\x52\xbd\x3b\xd5\x88\xc1\xc5\x3c\xaf\xc9\x49\x2d\xf1\x56\x7e\xef\x3c\x0f\x70\x9e\xad\xc6\xce\x4b\x4d\x5e\x92\x93\x99\xe1\x58\xa5\xad\xf5\xe6\x56\xe6\x5d\x59\xbe\x2a\xb7\x14\x1b\xd5\xb6\x1a\x91\xbd\x52\x7b\x4d\x8c\x6c\xd5\x52\xb6\x45\xd6\xe0\xb1\x06\x4f\x95\x4d\x53\x67\x6f\x53\x4d\x7b\x28\xe7\xc1\x68\x9a\xdb\x65\x9b\x21\xe1\x35\xb5\x5a\x3c\xcd\x1d\x57\x56\x59\x30\xb8\x38\x37\x27\x29\x39\xb9\xa4\x55\xcb\x3e\x95\xb5\x52\x73\x9c\x21\xe9\xe5\x88\xac\x74\xf7\xaa\x0c\x73\x44\x7a\xa7\x68\xd3\xe5\x66\xef\xb6\x96\xbb\x56\xad\xde\x19\x23\xe3\x4b\x5b\x44\x95\xa5\x96\x8d\x1b\x55\x5c\x69\x8e\x63\xee\x2a\x33\x77\xd5\xaa\x15\x95\xb1\x2d\x2a\x9b\xa5\xe6\x54\x36\x5b\x7c\xb4\x2e\x9e\x4f\xac\x6c\x99\x9a\x93\x5b\xd9\x42\x4b\xed\x37\xe4\xa2\x9e\x7e\xbf\xab\x54\x95\xae\x34\x8e\x90\x55\x67\x04\x77\x52\xbf\x3f\x79\x69\xcf\xb8\x60\x8f\x3b\x2d\xe6\x8c\xe8\xc7\x4a\xa3\x57\xa5\x1a\x52\x9c\xac\x7f\x92\xf2\xc0\x7a\xd5\xaa\xbc\x54\x6f\xde\xaa\xd2\x55\xe3\x76\xda\x15\xe3\x53\xbd\x31\xa9\xab\xb6\x45\x45\xad\x9a\x9d\x0b\xdc\x52\x50\x8c\x88\x9d\xf6\x73\x37\x27\x55\xe6\xad\x2e\xa9\x8c\x29\x2d\x57\x5d\x4a\x82\xae\xe7\x0d\xe9\x57\x19\x3f\x78\x64\x71\xa5\x91\x96\xe7\x2d\x1f\x47\x0f\xff\x65\xa5\x26\x77\x4e\x4a\x8e\xbd\xc8\x53\xf0\x57\xc3\x02\x2c\x80\x03\xc2\xc9\xc9\x1a\x86\x9b\x77\xfa\x64\x3c\x2f\x95\x15\x83\x8b\x03\xef\x5e\x19\x9f\xb4\x5d\x7c\xe9\x2d\x4a\x2a\x8d\x52\x3d\xb2\x2b\x34\x52\xbb\x48\x8f\x54\x84\x46\x2e\x4e\x2f\x4d\x25\xb6\xfd\x86\x16\xaf\xaa\xb4\xd2\xfa\x94\xa5\xe6\x82\xf8\xcd\xe3\x2a\x2b\xc6\x93\x5d\x53\x75\x60\x52\x63\x2a\x6b\x9d\x4d\x4a\x4e\x5d\x15\x17\xeb\xcd\x4c\x2f\x71\x78\xbd\x58\xd5\xa7\x6c\x8a\xb7\xd2\xd5\x18\x90\x98\x55\x7d\x02\x79\xa3\xa7\xac\x8a\x71\x5e\x6a\x9d\x0d\x34\xdf\x27\xa1\xa0\x71\x6c\x9c\x37\x33\x15\x31\x5a\x4e\x6e\x6a\x6e\x69\xf0\xbf\x2b\xcb\xeb\x22\xc0\x0b\xd0\xf9\x2d\x02\x89\x50\x58\x5c\xe9\xcb\xe1\xc1\x37\x2e\x18\xb1\xdc\x6d\x6d\xd2\x99\x31\xae\x94\x80\x4d\xc9\x71\x82\x59\x99\x9e\x3a\xbb\x32\x21\x35\xfb\x62\x74\xb5\x59\xb9\x53\x86\x16\x3b\x53\x82\xd3\x2a\x13\x7a\x55\x4a\xe9\x84\xe0\xac\xca\xf4\x5c\x67\x5d\x79\x73\x57\x95\xe6\x04\x4c\xd0\xb2\x52\x07\x17\x3f\x2b\x19\xf6\xa1\x6d\xed\xbd\x49\xff\xd0\x5b\x67\x49\x8e\x66\xae\xd3\x8b\x2c\x6b\x9c\xbb\xaa\xb8\x6c\x52\xa5\xa7\x34\xa9\x8c\x75\x37\xc9\x5b\x9c\x94\x5c\xe9\x2b\x21\xc2\x25\xa9\xc5\x13\x4b\x74\xda\x81\x50\xb3\x43\x49\x4e\x72\x94\x38\xb9\x52\x58\xdc\x6f\x68\x6a\xbf\xc1\x23\x8a\x3b\x07\x0d\x09\x0c\x68\x71\x56\x5a\xee\x65\x62\x52\x8b\x93\x02\x62\x48\xc0\xca\xf0\xb4\x70\x6f\xb1\x91\x64\x96\xc0\x18\x43\x87\x37\x8f\x87\xd4\xec\x6e\xfc\x59\x19\x96\x16\x0e\xc5\x00\xb8\xd3\xab\x13\x37\xbb\x9b\xb7\x58\x25\x49\x88\x1b\x33\x2a\x9b\x79\x73\x27\xe6\x04\xf9\xf4\xfb\x25\x42\x5d\x3a\x9d\x7a\xe5\x87\xa4\xb9\xf5\x2b\x72\x7a\xe5\x27\x25\x97\x24\x07\x7e\x5a\xb5\x34\x18\xf6\x06\x15\x33\x23\x5c\x83\x9a\x1f\x1a\x62\x9b\x62\x20\x9c\xfc\xec\x95\xef\x74\x69\x2c\xeb\xea\xa4\xf7\x16\xa7\x4e\x4c\x2d\x49\x2d\xf7\x56\xfa\x0a\x8a\xb5\x6f\x1a\x1e\x07\xe5\x20\x18\x0e\xe6\xc1\x58\x15\x5e\xf2\x56\x0d\x2c\x60\x92\x64\x86\x43\x2f\x1a\xcc\xca\xbc\x16\x49\xd5\xc1\xad\xec\xed\xbc\x5f\x7c\xcd\xbf\x6c\xb8\x4f\x68\xd8\xbb\x2a\x3c\xb5\xdf\xd0\x55\x5a\x78\x6a\x50\xa0\x60\x79\x9f\x4a\xd1\x29\xec\xeb\x1c\x9b\xe4\xec\x05\x7a\x41\xa7\xb2\xf7\x7a\x63\x58\xd2\xce\x82\x5e\xb5\xcd\xe7\xd3\x8b\xb9\xbc\x8b\x16\x92\xda\xa7\x6c\x55\xea\xd0\xe2\x6e\x0e\x37\xfb\xc9\xd2\xa4\xc5\x5a\x57\x9c\xf4\x53\xfd\x0a\xb3\x5b\xb5\x64\x6b\xcb\xde\x96\xaa\x56\x0e\xde\xe6\x53\x2b\x87\x8e\x28\x7e\x36\x86\x5b\xf3\xca\xc2\xe2\xed\x86\x32\x7a\x95\x66\x97\x6c\x6b\xc4\x58\xf1\xb3\x5e\x0e\x0d\xa7\xd7\xd0\xbd\xba\x53\xbf\x78\xf5\x8b\x96\x34\x84\x97\x70\x87\x3f\xe9\x59\x9f\x48\x85\x33\x6a\x39\x1d\xce\xfb\x84\x9d\x4a\x9c\xbe\xf0\x50\x9f\x92\x09\x3b\x8d\x40\x5f\x4c\x40\x51\x63\x47\x91\x8f\x3b\xc8\x84\x9d\x56\x60\xc4\x17\xe2\xb6\xe8\x0b\x0f\xf4\x55\x38\x7d\xce\xcf\x36\xd1\x90\xf9\x22\x5d\xbe\x70\x5f\x84\x2f\xca\xa8\x69\x24\x6d\x53\xba\x6b\x3b\x3d\xcf\x71\x57\x89\x50\xf2\x8f\x28\x55\x53\x25\x6d\x63\xd6\x10\xa7\x7b\xa7\xaa\xd8\x16\xe1\x4b\x0a\x70\x54\xc0\xe1\x0b\x58\xb8\xb2\xe8\x77\xd5\x45\x23\x8a\xff\xc1\x8d\x46\x25\x39\x7f\xa2\x28\x5b\xff\x90\x2e\x75\xcb\x09\x36\xc7\x4a\xae\xb7\x4c\x27\xca\xd5\x25\xe5\xab\x4a\x4b\xf4\x62\x93\x3a\x84\x86\xff\x54\xa5\x4a\xed\x41\x98\x52\x7b\x60\x88\x3b\xaa\x32\x32\x75\x62\x76\x65\x8d\xd4\x6c\xdd\x9f\xa5\xfb\xb3\x02\xfd\x6e\xdd\x1f\x46\x8a\xaa\x3a\x8a\xe9\x15\xc4\xbe\xa0\x52\xe9\x0c\x18\x59\x9c\xcc\x92\xf4\xd6\x7b\x2b\x69\x55\xcc\xf7\x3a\x52\x25\x6c\x2a\xab\x62\x8e\xb5\xea\x59\x2a\x3e\x35\x51\x94\x2a\x57\x93\xb9\x61\x79\x54\xa9\x0c\x54\x63\xa5\x48\xf5\x94\xee\xca\x47\x0b\xa6\x2a\x9b\xb6\x17\xef\xba\x6d\xad\xba\x4b\x05\x7c\xdd\xe9\xef\xc1\x3b\x77\x28\xd5\x95\x7b\x51\x34\x7f\xa6\x43\x59\xd0\x35\x90\x05\x05\x38\xda\xc0\x91\x4e\x9b\x1e\x7c\x6f\xc5\x7b\x4b\xda\x96\xc1\xf7\x2c\xde\x75\xdb\x97\xf7\x7c\xda\xde\xc1\x36\x8f\xfe\x5c\xda\xdc\xe0\x7b\x1f\xde\x69\xa5\x40\x85\x11\xe7\x74\xe7\xcf\xad\xca\xf2\xc5\xaa\x0f\x2e\xa8\x97\x2f\xa8\x98\x0b\x6a\xd6\x39\xe5\x3b\xa7\x7e\xdd\xa9\xa2\x7d\x71\xcd\x3c\xbf\x24\xd9\x9e\xb3\x05\x4d\x3d\x67\x0a\xba\x79\x7e\x3c\xd5\xcd\xf3\xac\x8a\x57\x71\xbe\x8e\xdd\x3c\xff\xfe\xbe\x9b\xe7\x64\x6f\xdb\xf3\x4d\x41\x33\x4f\x15\x74\xfc\x68\x37\xcf\xb1\x82\x0e\x9e\xa3\xd0\xd7\x3b\x32\x3c\x87\x76\xd4\xf3\x7c\x7b\x22\xc3\x73\xf0\x40\x86\xe7\x2b\x33\xc3\x23\x27\x54\xc4\x4e\x7b\x97\xaf\xdb\x89\x1a\x31\x79\x27\x94\x59\x24\x07\xf0\xfb\x40\x9b\x03\x05\x07\x2a\x0e\x54\x1e\x70\x85\x1f\xa0\xef\x4b\x18\x3f\x2b\xa8\xef\xf9\x14\xfa\x04\xda\x57\x60\x7b\xde\x7a\xb3\xbb\xe7\xcd\x41\xdd\x3c\xaf\x0d\x6a\x86\xf6\x1a\x98\x55\xab\x99\x27\xfd\x55\x95\xf5\xea\xda\x57\x8d\x97\xd1\xbc\x53\xd5\xdc\xde\x3b\x8e\x26\xea\x9f\x0f\xd9\x9e\x97\xc6\x34\xf3\x44\xef\x54\x91\xbe\x08\xf5\xfc\x93\xed\x3d\xcf\x3d\x69\x7b\xb4\xda\x8c\x67\x1b\x35\xcd\x7b\xb6\xa0\x91\x27\xeb\x9f\xea\x19\x26\xbd\xbc\x43\x45\x6f\x1d\xbb\x75\xd6\xd6\x07\xb7\x5a\xb3\x9f\xaa\x78\x6a\xdd\x53\xa6\xf7\xa9\x36\x4f\xf9\x9e\xfa\xe0\xa9\x43\x4f\x9d\x7a\xca\xfd\x24\x3c\x2f\xa8\x58\xe0\x8a\x01\xb6\x98\xed\x49\xdd\x50\x50\xcb\xd7\xba\x99\x59\x14\xfd\x88\x4a\x7f\x58\xad\x7d\x58\xd9\x0f\xab\xd2\x87\x67\x3f\x5c\xf1\xb0\xf9\xf7\x38\xdb\xb3\xd9\xb4\x3d\x1b\x33\xe2\x8a\xee\x63\xe6\xbd\x43\xbb\x79\x36\xf5\xed\xe6\x68\xae\xfd\x50\x72\xa3\xbc\x07\x1f\xda\xfa\x90\x71\x0f\x56\xde\xdd\xd7\xf6\xdc\xc9\xc8\x0b\xaa\x81\x4a\xe4\x8a\xed\x51\x75\xff\x31\xb4\x99\x27\xeb\x39\xde\x06\xa9\x44\x5f\x5f\xe3\x8e\xf5\xdd\x3c\xd1\xeb\xaf\x59\x6f\x44\xdc\x5e\xd0\xdd\x73\x1b\x74\x2b\x28\xac\x5b\xdd\xdd\xb3\x76\x4d\x33\xcf\x2d\x6b\xba\x7b\x64\x8d\xea\xea\x59\xa3\x56\xa3\x64\xc5\x75\xcd\x3c\xcb\xaf\xeb\xe6\xa9\xb8\x6e\xdd\x75\xc6\x95\x0b\xba\x79\x64\x81\x9a\x3f\xaf\xb9\x67\x9e\x83\x4b\x6d\x5f\xd2\xec\x66\x9e\x59\x33\x5b\x78\x66\xf6\x6e\xee\xa9\x57\x23\xa9\xe8\x8a\x8c\xba\x45\x61\x19\x66\x91\x1b\x63\x5f\x50\xf5\x54\x82\x63\xc2\x15\xff\x18\x9b\xe1\xf1\xed\x54\x09\xdb\x1b\x35\xc9\xc3\xe6\x7f\x8c\x6b\xd1\x46\xb7\xbe\xa8\x71\x1e\x36\xb1\xb1\x3e\xcf\x58\x2d\x8f\x8e\x3b\x47\xd7\x6b\x98\x37\xaa\xb7\xd7\x33\x72\x44\x1b\xcf\x88\xde\xcd\x3c\x09\x2a\xae\x28\x1e\xaf\x5d\x44\xcf\x42\x70\xb4\xe9\x31\xb3\xcc\x41\xe6\x2c\x73\xad\xf9\xb2\x19\x16\x3e\x64\x70\xba\x67\x30\x93\x0f\x15\x9c\x2a\x30\xa2\x07\x79\x06\xa5\x0f\x32\xfb\xf5\xce\xf0\xf4\x05\x8b\x3e\xbd\xbb\x79\xf2\x7b\x77\xf6\x44\xf7\xf6\xf4\x4e\xef\xbd\xa7\xf7\xc1\xde\x3f\xf4\x76\x3f\xd8\x1b\x64\x92\x8a\xea\xe7\x27\x15\xd5\xc9\xa8\x5d\x14\xab\xa2\x8b\x62\x32\xa2\x8b\xb8\xd1\x16\xa9\x0c\x29\x4a\x8f\xb6\xa3\x8d\xe8\xe8\xb1\xd1\xd7\x44\x9b\xd1\x94\x1d\x46\x45\x1d\xe5\x52\x3b\xd5\xba\x6d\x85\x43\x5b\xb4\xe8\xb7\x33\xcc\xe6\x26\x14\x51\x30\xb2\x52\xad\xac\x4c\x1b\xaa\xff\xf4\x0d\x1e\x51\xe9\x5e\x59\x29\x45\x23\x46\x16\x6f\x53\xea\x96\x92\x1b\xd6\xac\x91\xec\x06\xfd\x2a\xdb\x0d\x2d\xae\x2c\x6d\x50\xd2\xaf\xb2\x8c\x07\x9f\x7e\xa8\xe0\x21\xa6\xc1\xb6\x3a\x92\x5d\x32\x6f\xde\xfc\x16\x81\x1f\x35\x6f\x81\x6e\x64\x01\x1d\x63\xe6\x39\x3d\xce\x7b\x8b\xdf\x7f\x54\xe0\x7d\x01\xbc\xfa\x61\x41\x80\xcd\x61\x9f\x17\x18\x9d\x17\x9a\x80\xdc\x05\xce\x28\x8d\x9a\x27\x2d\x9c\xe7\x79\x01\x01\xa8\x54\xbf\xcb\x1d\x33\x4f\x8b\x71\x44\xa9\xd0\x6c\x67\x38\xc8\x33\x4f\xff\x28\xa8\xba\x25\xf3\x2e\x3e\xd4\x15\x71\xad\xa1\xd6\xcb\x77\x75\xa7\xfa\x9b\xe5\xea\xee\xea\x7f\x69\xc1\x68\x3e\x41\x05\xa8\x7f\xbf\xfd\xa4\x7e\x0b\xfd\xe9\x3f\xe2\xef\x6f\xff\xf6\xff\xb4\x90\xfd\xb3\x9f\xd0\xa7\xef\xd4\x71\x5b\xa9\xeb\xf6\xeb\xdf\xbd\x77\x7e\xf2\xa8\x09\xa7\xc8\x52\xd9\x7f\x09\xfb\x2b\xf2\x26\x7c\x0b\x19\x2b\xa0\x3e\x7c\xfc\x2f\xc5\x3e\x41\xdd\x37\xc2\x79\x2a\xa0\x76\xbc\x4e\x7b\xf2\xa7\x3f\xef\x50\xab\x7e\x0a\xcf\xbd\xb2\xe3\x62\xdf\x5b\xb2\x84\xda\x6e\x0d\x9a\x0b\xb0\xa2\x58\xb5\x63\x9f\xfc\x49\xb6\xcb\x54\xf9\x5c\x5e\xe7\x69\x40\x80\xcd\x3e\x42\xad\xb6\xd7\xa8\xe5\xfc\x26\x24\x3f\xce\xdf\x25\x9e\xe4\x3c\x4e\x92\x5d\xc6\x17\x17\xe5\x6d\x30\x36\x4a\x5f\xe3\x28\x4f\x77\x33\x52\xe0\xf4\x65\x4b\xb6\x9a\x2f\xf7\xa9\x07\xd1\x70\xcb\x45\x8f\xbb\xfd\xc1\xbe\xa5\xd4\xbb\x42\x65\x5c\x4e\x95\xba\x22\xa8\x27\xfb\xfc\xe7\xae\x21\x46\xa4\x2c\x63\xe6\x74\x3a\xba\x50\x31\xe7\x50\xb3\xce\xbe\xf0\xa1\xa9\xeb\xfc\xbf\xab\x6b\xd4\xcd\xb4\x95\x54\xc6\x81\x9f\x61\xd2\xda\xdf\xdf\xff\x6f\x91\xb0\x7c\x73\xaa\xf1\x8c\x61\x5c\xb8\x5d\xf4\x6f\x67\x4e\x86\xc6\x29\x10\x36\xd6\x98\x3d\x35\xa3\x91\x6e\xc7\xe0\xd5\x6e\x69\x63\x8b\x7f\xb2\xbf\x58\xbd\xa5\x3e\x01\xbd\x3c\xf9\x46\xcd\x05\xa1\x99\xb2\xc6\x7f\x9f\x4c\x55\x7f\x8d\x3b\x3f\xec\xdd\x35\x55\x33\x33\x4d\x22\xfe\x6c\xd4\x68\x2f\xd1\xfe\xdf\x8c\x76\xf6\x69\xb3\x91\x44\x4a\x91\x7d\x2a\xd4\x67\xf7\xb3\x7f\x36\xc7\xfd\x37\xc9\xbf\xff\xb8\x6f\xb5\x66\x88\xfe\x94\xf6\x98\x7f\x89\xbf\xcc\x35\xd0\xd5\x82\x6a\x7f\xf3\x5f\x71\xeb\xbf\xef\x6e\x26\x88\x58\xef\x82\xde\x69\x72\x6e\x91\x48\x8d\xf9\x22\x51\xc4\xa2\xe6\x0b\xce\x5f\xaf\x90\xe8\x32\x68\xb7\x48\x8c\x17\x2a\x84\x98\x13\xf3\x81\x48\x2c\xcf\xb1\x3b\x45\xe2\x68\xe3\xf3\xa1\xcf\x44\x12\xee\x13\xa9\x3d\x0a\x82\xbf\x0e\x5a\x13\xcb\xa1\x2f\x45\xea\x12\x8d\xba\xf8\x73\xc5\x6c\x88\xb6\x1e\x7d\xf5\xd7\x89\x34\x60\x6e\x43\xc8\xc3\x15\xcd\xf3\x04\xd7\xb4\xd5\x22\xc9\x8c\xa7\xa0\x3b\x75\x93\x48\x23\x74\x36\xda\x28\x92\x86\xce\xc6\xe4\x40\x13\x0b\xe2\xbd\x69\x7b\x91\x66\xcb\x45\x9a\x17\x8b\xb4\xe0\xb9\x65\x14\x84\xbe\x56\xbc\xb7\x6e\x23\xd2\x06\x99\x6d\x5b\x8a\x64\xe0\x5b\x06\x73\x3b\xb0\x98\x3a\xf8\x44\x3a\xe1\x57\x27\xe4\x76\xda\x2b\x92\xf9\x26\x09\x82\xaf\x5d\x91\xdb\x15\x9d\xdd\xc0\xa0\x7b\x85\x48\x0f\x7c\xc9\x6a\x04\xe1\x8f\x0f\xbb\x7b\x22\x33\xbb\x29\x84\x6d\xbd\x90\x95\x93\x03\xc1\x9b\xbb\x9e\xc4\x84\x37\x0f\x59\xbd\xe9\xcf\x47\x7e\xfe\x37\x22\x7d\x56\x8a\xf4\x65\x5e\x3f\xf8\xfa\x33\xaf\xff\x21\x91\x01\x95\x10\x79\x3e\x90\xb5\x34\x08\x8c\x07\xc1\x33\x18\xfe\x21\xe8\x1e\xca\x8e\x53\x88\x0f\x45\xe0\x56\x04\xdf\x30\xb0\x2d\x41\xff\x48\xf4\x8e\xfc\x55\x64\x14\x7e\x8e\xa2\x6f\x14\x72\xc6\x62\xc3\xd8\x5d\x22\xa5\xc8\x2e\xe5\x7d\x3c\x32\x26\x9c\x17\x99\x08\xcf\x24\x9e\x27\x21\x7f\x12\xd8\x4f\xe6\x79\x32\x7e\x96\x83\x5f\x39\x32\xcb\x91\x33\x05\x3c\xa6\x5c\x2d\x32\x0d\x9c\xa6\xe1\xdb\x74\x30\x99\xde\x19\xc2\xd6\xe9\xf4\xcd\x00\x8f\x59\xf0\xcc\x02\xbb\x59\xc8\x9b\x85\xac\x59\xf8\x33\xbb\x3e\xc4\x1e\x38\x9b\xb9\xb3\x89\xd1\x6c\xf4\xce\x61\xfe\x5c\xe6\xcf\x65\xfe\x5c\x62\x3c\x17\xff\xe7\xbe\x19\xf8\xfa\x63\x1e\x73\xe7\x83\xe3\x7c\xf4\xce\x87\x77\x01\xb1\x5d\xc0\xfc\x05\xcc\xbf\x92\x76\xa1\x26\xf2\x60\x21\x73\x16\xe2\xcb\x42\x76\xd0\x45\xc4\x69\x11\x58\x5c\xc5\xd8\x55\xc4\xe4\x2a\xc6\xae\x62\xec\x2a\xf4\x2f\x66\xfe\x62\xf4\x2c\x06\x9f\xc5\xc8\x5d\x8c\xad\x4b\xc8\xb3\x25\xf8\xb9\x84\xf1\xab\x19\xbf\x9a\xf1\xab\x4b\x21\x70\x5d\x8a\x0f\xcb\xb0\x6d\x19\x79\xb0\x0c\x0c\x97\x31\x67\x19\x73\x96\x81\x61\x05\x39\x7e\x2d\xfe\x5c\x8b\x9e\x6b\xd1\x73\x2d\x18\x5d\x4b\x2c\xaf\xa5\xff\x3a\xe2\x70\x1d\xf1\xbc\x0e\xdb\xae\x23\xc7\xae\xa3\xff\x3a\xb0\xbd\x9e\x58\x5c\x0f\x26\xd7\x63\xff\xf5\xf8\x7f\x3d\xbe\x5f\x8f\xde\xe5\xe4\xcc\x0d\xe0\x7b\x03\xb1\xb8\x01\x59\x37\x60\xf3\x0d\x60\x70\x03\xfd\x37\x22\xeb\x46\x62\x70\x23\xb2\x6e\xa4\xff\x46\xfa\x6f\xa4\x7f\x05\xfc\x2b\xd0\xb1\x82\x1c\x58\x81\x8e\x15\xf4\xaf\xa0\x7f\x25\xfd\x2b\xc9\xcd\x9b\xe8\x5b\x45\x5e\xad\xc2\xb7\x55\xe8\xb8\x19\x39\x37\x83\xcb\xcd\xf0\xdf\x8c\xcf\x37\xd3\xbf\x9a\x5c\x5f\x4d\xdf\x6a\x72\x61\x35\xb6\xac\xc1\xcf\x35\xac\xd1\x5b\xe8\xbb\x05\x3b\x6f\x21\x9e\x6b\xc9\xbb\xb5\xf8\xbe\x16\x3c\xd6\x22\x73\x2d\xeb\x74\x2d\xf2\xd6\x81\xf3\x3a\xf0\x59\x07\x96\xb7\x92\x73\xb7\xa2\xff\x56\x72\xe3\x36\xf4\xdf\x86\x5d\xb7\x81\xe1\x6d\xac\xcb\xdb\xe0\xbf\x0d\xdf\xd7\xb3\xde\xd6\x13\xc3\x3b\xc0\xf8\x0e\x30\xbe\x83\x58\xdf\x81\x7d\x77\x30\xef\x0e\xec\xbe\x8b\x79\x1b\xd0\xbf\x81\x79\x1b\xd0\xb5\x01\x5d\x1b\x98\xbb\x01\x3c\xef\xc6\xf6\xbb\x91\x79\x37\x18\xdc\x4d\xff\xdd\xd8\x7e\x37\xb1\xbe\x07\x1b\xee\x01\xb3\x7b\x90\x75\x0f\xb1\xb9\x87\x3c\xbb\x87\xb5\x71\x2f\x3a\xee\xc5\x96\xfb\xf0\xe9\x7e\xe2\x77\x3f\x72\xef\x47\xee\xfd\xc8\xbd\x1f\x99\xf7\x63\xc7\x03\xcc\x7d\x00\x3f\x1f\x40\xe6\x03\xe0\xfa\x00\x39\xf6\x00\xeb\x4f\xff\x93\x13\x0f\xe2\xd7\x83\xf8\xf5\x20\x32\x1f\x44\xe6\x83\xc8\xdc\x08\x56\x1b\xe1\xdf\x88\x9c\x8d\xf8\xb5\x91\xfe\x87\xf0\xfb\x61\xfa\x1f\xc6\xc6\x47\x98\xf7\x08\xbe\x6c\x2a\xd6\xbf\xda\x01\x61\xe7\xa3\x60\xfd\x18\x73\x1e\x23\x47\x1e\x03\x83\xcd\xcc\xf9\x3b\x36\x3c\x0e\xae\x5b\xd0\xb1\x05\x1f\x9e\xc0\x9e\x27\xc9\x87\xa7\x18\xdf\x0a\x0e\x95\xe4\xea\x36\xe6\x6e\xc3\x9e\xed\xf8\xfc\x0f\x6c\xff\x07\xbe\xec\x40\xd6\xd3\xf8\xfa\x8c\x26\xf4\xfd\x93\x98\xfd\x93\x38\xee\xa4\xff\x59\xf8\x9e\xc3\x8e\xe7\xc0\xe5\x79\x64\xbd\x80\xfc\x17\xd1\xf9\x12\x3e\xbe\x44\xae\xbe\x84\xbf\x2f\x93\x9f\xbb\x18\x7b\x05\xbe\x57\xe8\x7b\x95\xb5\xf5\x1a\x7c\xbb\x89\xf3\xeb\xe4\xd7\xbf\xe0\xfd\x17\x78\xbd\x81\x6f\x6f\xe2\xfb\x5b\xc4\xe3\x2d\xfc\x7e\x9b\x7c\x7f\x87\xf7\x77\xd1\xfb\x1e\x73\xdf\x63\xbf\x7d\x1f\x59\x7b\xf0\x7d\x0f\xfc\x1f\xe0\xeb\x07\xe8\xff\x00\xec\x3e\x80\xff\x43\xb0\xff\x10\x9b\x3f\x24\x07\x3f\x24\x2e\x1f\x82\xe1\x87\xe0\xfb\x21\xfe\x7c\x08\x3e\x1f\x62\xcb\x47\xcc\xf9\x88\xbc\xfa\x08\x1b\x3f\xc2\x86\x8f\xd0\xf9\x11\xd8\x7c\x84\xbc\x8f\xc0\xe1\x63\xd6\xc9\xc7\xe4\xe1\xc7\xf8\xf8\x31\xeb\xe4\x63\x64\xef\x65\xad\xed\xc5\x86\xbd\xf8\xbb\x8f\xb9\xfb\x90\xbf\x8f\x79\xfb\x98\xb7\x8f\x7c\xfc\x04\xdb\x3e\x41\xef\xa7\xe4\xca\x67\xf0\x7e\x86\x4f\x9f\x21\xe3\x33\xf0\xfe\x0c\x19\xfb\xf1\xf7\x73\xe6\x7c\xce\xfa\xfa\x1c\x7b\x3e\xe7\x5c\xf8\x1c\x5b\xf4\x15\xe2\x0b\xe6\x7c\xc1\xdc\x2f\xf0\xe3\x0b\xec\xf9\x02\xb9\x5f\x32\xef\x00\x7d\x07\xc0\xe7\x00\x73\x0e\x80\xf5\x01\xec\xfb\x8a\x7c\xfa\x8a\xfe\xaf\xc8\x83\xaf\xe0\xf9\x0a\xd9\x5f\x81\xe7\x57\xc4\xe4\x20\x72\x0e\x12\xef\x83\x8c\x1d\x44\xdf\x41\xb0\x3b\xc8\xda\x3f\x48\x5c\x0f\x81\xef\x21\xf2\xfe\x10\x58\x1e\x02\x93\x43\x60\x78\x08\x3c\x0e\x91\x03\x5f\x83\xd9\xd7\xe0\xf9\x35\xb9\xf3\x35\x31\xfa\x9a\xf8\x7f\x4d\x2c\xbf\xfe\xc6\xf9\x6b\x9d\x72\x18\xb9\x87\xd1\x79\x18\xfb\x8e\xe0\xe7\x11\x6c\x3f\x82\xed\x47\xc1\xf1\x28\x36\x1d\xa7\x3d\x8e\xfe\x2a\x70\xfa\x06\x7c\x4e\xe0\xff\x09\xfc\x3f\x81\xff\xdf\x62\xe3\x77\xd8\xf2\x1d\x76\x7e\x87\xae\x93\xe8\x3a\x09\xee\x27\xc9\xfb\x93\xac\xbf\x93\xe4\xdf\x49\xfa\xbf\xa7\xff\x7b\x70\xfd\x9e\x18\xfe\x1b\x7b\x7f\x40\xff\x29\x6c\xfa\x11\xde\x9f\xe0\xfd\x99\x58\x9c\x46\xd6\x69\xb0\x3b\x43\x1c\xce\xe2\xe7\x2f\x39\xc1\x5f\xc3\xc0\xcf\xff\xf0\xfe\x1b\xef\xe7\x98\x73\x8e\xf6\x3c\xfc\x17\x2a\x03\x7f\x9f\xc4\xee\xa6\xff\x75\x18\xe8\x3c\x35\xf0\x67\xa2\x8c\xe5\xa2\xcc\xf9\xa2\xac\xd9\xa2\x5c\x39\xd0\xaf\xa2\xdc\x4f\x88\x0a\x5b\x24\x2a\xdc\x82\x4e\x8b\x8a\xf8\x52\x54\xe4\x4e\x51\x35\xca\x45\x45\xd5\x15\x55\xb3\xa9\xa8\x5a\x31\x10\x32\x62\x90\x17\x5b\x1f\xfa\x40\x54\x1c\x7c\xf1\x3b\x44\x25\xc0\x57\xbb\x0d\x74\x52\x54\x9d\xf5\xa2\x12\x8b\x45\xd5\xa5\xea\xaf\x8b\xac\x2b\x90\x79\xc5\x74\x51\xf5\x90\x53\xef\x4d\x51\x49\xf9\xa2\xea\x37\x12\xd5\x80\xfe\x06\xf0\x37\x84\xc7\xb3\x5b\x94\x97\x79\xc9\x8c\x25\x33\x37\x05\x79\xa9\x9d\x45\x35\x42\x66\x23\x6c\x4b\x43\x7f\xda\xbb\xa2\x1a\x33\xde\x18\x1b\x9a\x8c\x82\x90\xd5\x14\x9b\x9b\xc1\xd7\x9c\xf1\xe6\xd8\xd1\x02\x9f\x5a\xe2\x6b\x4b\x64\xb6\x5a\x2d\xaa\x75\x4b\x51\xe9\xd8\x9d\xce\x7b\x9b\x4d\xa2\xda\x62\x77\x5b\x74\xb5\xc3\xff\x0c\x9e\x33\xd0\xdf\x1e\x3f\x3a\x54\x88\xea\xb8\x41\x54\x27\x6c\xee\x74\x54\x54\xe7\x95\xa2\x32\x91\x99\xc9\x78\x17\xe4\x76\x65\xbc\x1b\x3e\x74\x03\xab\xee\xd8\xd1\x83\xe7\x1e\x60\x99\xf5\x82\x28\x1f\x7a\xb8\x5b\xa8\x6c\x6c\xee\x55\x29\x2a\x37\x4a\x54\x5e\xb8\xa8\xde\xf8\x9b\x4f\x5f\x1f\xfc\xea\x5b\x2a\xaa\x1f\xd7\xb4\xfe\xed\x21\xe6\x0d\xd8\x2c\x6a\x20\xfa\x06\xf1\x3e\xe8\x94\xa8\x02\xf4\x0d\x66\x7c\x30\xfe\x0c\x61\xde\x10\x74\x0c\xc5\xc6\x42\x6c\x2c\xc4\x87\x42\x30\x2f\xec\x0f\xe1\x77\x21\xba\x0b\x89\x4d\x11\xf8\x15\x21\x63\x18\x76\x0e\x03\x83\x61\x60\x33\x6c\x1d\x44\x4c\x86\xc3\x3f\xfc\x3e\x08\x39\xc5\xcc\x2f\x01\x93\x11\xe8\x1a\x51\x06\xc1\x33\x02\xec\x46\xa2\x6f\x24\x73\x46\x5e\x0d\xf1\x3e\x2a\x01\xc2\x8f\x51\xcc\x1b\x85\x4d\xa3\xd1\x3d\x9a\x5c\x19\x8d\xcf\x63\xb0\x6b\x0c\x58\x8c\xe5\x7d\x1c\xba\xc7\x23\x73\x3c\xcf\x13\xc8\x9f\x09\xc8\x2b\x43\x7f\x19\x18\x73\x7f\x51\x13\x77\x89\x9a\x04\x06\x93\x90\x35\x09\xcc\x27\x81\xe7\x64\x64\x4d\x06\x03\xee\x32\x6a\xf2\x37\x10\x32\xcb\xb1\xa7\x9c\x78\x71\xaf\x51\xe5\xe8\x9b\x82\x6f\x53\x90\x35\x85\xf1\xa9\xd8\x3f\x15\x8c\xa6\x82\xef\x54\xe4\x4e\x43\xdf\x34\xe6\x4f\xc3\x5f\xee\x3c\x6a\x3a\xf2\xa7\xc3\x3f\x1d\xdc\xa6\x13\x9f\xe9\xcc\x9f\x81\x3f\x33\xc8\xab\x19\xf8\x34\x03\xcc\x67\xe0\xfb\x4c\xb0\x99\x09\x8e\x33\x79\x9e\x05\xae\xdc\x89\xd4\x2c\x7c\x99\x45\x4e\xcd\x22\x8f\x66\x83\xe5\x6c\xfc\x99\xcd\xf3\x1c\x62\x3f\x07\xfb\xe7\x80\xc5\x1c\x74\xce\x05\xb3\xb9\x05\x10\xb1\x9f\x0b\xff\x5c\x74\xcc\x43\xde\x3c\xfc\x9a\x87\xde\x79\xf8\x39\x0f\xdf\xe6\x63\xdb\x7c\x30\xe4\x9e\xa4\x16\x10\xf7\x05\xd8\xb9\x00\x3f\x17\x20\xe3\x4a\xfc\xb8\x92\xf7\x2b\xf1\x6b\x21\xf6\x2d\x04\xaf\x85\xcc\x5d\x88\x0f\x8b\x90\xb5\x08\x3b\x17\xa1\x7f\x11\x31\xbb\x0a\x7d\x57\x31\x76\x15\xba\xae\x22\x27\xaf\x02\xa3\xc5\xe0\xb6\x18\x9b\x17\x63\xd7\x62\xf8\x96\xe0\xdf\x12\xe4\x2d\x41\xfe\x12\x64\x5c\x4d\x0e\x5c\xcd\x1a\xb9\x1a\xf9\x57\xef\x15\xb5\x14\xdf\x97\x22\x73\x29\x3e\x2c\xc5\x27\xee\x4e\x8a\xbb\x93\x5a\x76\x48\xd4\x35\xe4\x69\x05\xfa\x2b\x18\xaf\x80\x77\x39\x18\x2e\xc7\xbe\xe5\xe0\xb3\x9c\xf1\x1b\xd0\x75\x03\x39\x76\x03\xbe\xdc\xc0\xf8\x8d\x8c\xdf\x08\xff\x8d\xc8\x5e\x81\x9c\x15\xe4\xce\x0a\x7c\x5c\x89\xce\x95\xf8\xcc\x3d\x47\xad\xc4\xa6\x9b\xe0\xbb\x09\xec\x6e\x02\x8f\x55\xf0\xaf\xda\x28\xba\x38\x53\x37\x13\xdb\x9b\xf1\x6b\x35\x18\xaf\x06\xa7\x35\xc8\x59\x03\x86\xb7\x60\xff\x2d\xc4\x75\x2d\xf3\xd7\xc1\xbf\x0e\xbe\x75\xc8\xb9\x15\x19\xb7\xa2\xfb\x56\xfd\x8c\xfd\xb7\xe1\xdf\xed\xe4\xe2\xed\xcc\xbd\x1d\x2c\xd7\x63\xeb\x7a\x70\x58\x4f\x2c\xb9\xc7\xa8\x3b\xb1\xe5\x4e\xec\xbe\x0b\xcc\xef\x22\xb6\x77\x81\xe7\x5d\xe4\xc2\x06\x70\xe4\x2e\xa3\x36\x20\x6f\x03\x3a\xee\xe6\xf9\x6e\x9e\xef\xa1\xff\x1e\x70\xe3\x9e\xa2\xee\x61\x0f\xb8\x17\x7b\xef\x05\xe7\xfb\xd0\x7f\x1f\x31\xbe\x1f\x6c\xef\x27\x27\xef\xc7\xa6\x07\xb0\xf5\x01\xfc\xe0\xfe\xa1\x36\x12\x8f\x8d\xe8\x79\x88\xf5\xf1\x10\x36\x3c\x04\x0e\x0f\x81\xe5\x43\xf8\xf0\x10\xb9\xfa\x30\x3e\x3d\xc2\xf8\x26\xfa\xfe\x46\x6e\x3d\xca\xf8\x63\xac\x87\xcd\xe0\xc4\x9d\x43\xfd\x1d\x99\x7f\xc7\x97\xc7\x91\xb9\x85\xe7\x2d\xc8\x7f\x02\x3f\x9f\x80\xff\x49\xb0\x78\x0a\xbe\xa7\xf0\x65\x2b\xd8\x6f\xc5\xcf\x4a\xf8\xb6\x21\x63\x3b\x7b\xc7\x3f\xb0\x7b\x07\xbe\xed\xd0\x2d\xef\x3b\x18\xdb\x01\x3e\xcf\x60\xf3\x3f\xd1\xb1\x13\x79\x3b\x99\xf3\x2c\x3c\xcf\x62\x1b\xf7\x10\xf5\x1c\xef\x2f\xc0\xff\x02\xf1\x7f\x11\x7f\x5f\x02\x83\x97\xb0\xf1\x65\xd6\xce\x2e\xb0\xd8\xc5\xfc\x57\xc0\xec\x15\xfc\x7f\x15\x39\xaf\xf1\xbe\x1b\x3f\x5e\xc7\x9f\x7f\x81\xc3\x1b\xd8\xf5\x26\x79\xf8\x16\x79\xf3\x36\x38\xbf\x83\x7d\xef\x30\xfe\x2e\xf4\x1e\xbc\xef\x33\xbe\x87\xfe\x0f\xd0\xf9\x01\x7b\xc2\x87\xc8\xe0\x9e\xa1\x3e\xc4\xb6\x8f\xb0\x87\x7b\x84\xfa\x08\xde\x8f\xc8\xdf\x8f\xe9\xdb\x8b\x9c\x7d\x60\xbf\x0f\x8c\x3e\x81\xef\x13\x7c\xfd\x84\xe7\x4f\x91\xfb\x29\x3e\x7c\x86\x5f\x9f\x61\xdb\x7e\x30\xd9\x8f\xec\xfd\xc4\x7c\x3f\x71\xd9\x0f\xcf\xe7\xf8\xf0\x25\x71\x39\x80\x3f\x07\xd0\x73\x80\xdc\x3d\x40\xec\xbe\x42\xee\x57\xc4\xe7\x20\x73\x0e\x32\xe7\x20\x73\x38\xdb\xd5\x21\x72\xed\x6b\x9e\x0f\x93\x27\x47\xd0\x7b\x04\x3f\x8e\xd2\x77\x0c\xbb\x8e\x81\xfb\x31\xd6\xd2\x31\xb0\x3d\x46\xce\x1f\x83\xe7\x18\xf2\x8e\x81\xd1\x71\x64\x70\x7e\xab\x2a\x72\xed\x1b\xde\x4f\x20\x9f\xb3\x5b\x7d\x87\x0e\xce\x6a\xf5\x3d\xe3\xff\x66\x6d\xfd\xc0\x1a\x39\x45\xee\xff\x88\xef\x3f\x92\x6f\x3f\x62\xdf\x4f\xd0\xcf\xcc\x3d\xcd\x9c\xd3\xf0\x9f\xc5\xd6\x5f\xc0\xf9\x17\xdd\xe2\xdb\xaf\xf0\xff\x0a\x26\xff\x21\x17\x7e\x43\xff\x6f\xe8\xff\x0d\xfd\xbf\xa1\xff\x37\xf4\xff\x86\xbe\xdf\x18\x3b\x87\x9c\xf3\xc4\xef\x3c\xbe\x5f\x60\xcc\x0f\x26\xf6\x2e\x31\x64\xb9\x18\xaa\x54\x0c\x23\x0a\x3a\x2a\x86\xb9\x5b\x0c\x6b\x1d\x54\x09\x7d\x26\x86\xeb\xbc\x18\xee\x72\x31\xc2\xfa\x43\xa3\xa0\xe9\xd0\x7a\x68\x93\x18\xe1\x50\x04\xcf\x91\xab\xa1\x1d\xd0\x5e\xe8\x57\x31\x6a\x7c\x20\x46\x14\x6d\xcd\x17\xc4\xa8\x85\x9c\x68\x78\x62\xde\x14\x23\x96\xf7\x38\xe6\xc4\xa3\x33\x01\x9e\x3a\x02\x9d\x16\x23\x11\x9d\x57\xa0\x9f\x33\xdc\x48\x62\xac\x01\xcf\x9c\xdd\x46\xc3\xcd\x62\x50\xef\x1b\x5e\xfa\x92\xeb\x43\xf7\x41\xd8\x9c\x8c\x9d\xa9\x09\x62\x70\x7e\x1b\x69\xf4\xa7\xa1\xab\xc9\x06\x31\x9a\x79\xa1\x1c\x08\x3b\x9b\x87\x43\xcc\x6d\x51\x0c\xe9\x16\x3f\x5a\xfa\x20\x64\xb5\xfc\x52\x8c\xd6\xb3\xc5\x68\xd3\x4d\x8c\xb6\x8c\xb7\x83\x3f\x23\x06\xc2\x8e\xf6\xe8\xec\x80\xcd\x1d\x91\xdd\x71\xa3\x18\x9d\x0a\xc4\xe8\xdc\x52\x8c\x4c\xa8\x0b\xf6\x76\x6d\x2f\x46\xb7\x95\x62\x74\x47\x5f\x0f\xf8\xb2\x2a\xc4\xf0\x31\xd6\x13\xdd\x3d\xbf\x11\x23\x1b\xd9\xbd\xd0\x97\x03\x26\xb9\xe8\xcb\xc3\xce\x3c\xf8\x7a\x83\x01\xb5\xbf\xd1\x07\x1c\x39\xaf\x8d\x7e\xc8\xe8\x4f\xdf\x80\x45\x62\x0c\xc4\xe6\x81\xf8\x34\xe8\x10\x74\x4a\x8c\x02\xfa\x07\x63\xd3\x90\xa6\x62\x0c\x05\x8b\xa1\xc4\xa1\x10\x19\x45\xd8\x33\x0c\xfb\x87\x23\xa7\x18\xdb\x4b\x18\x2f\xc1\xf7\x11\xf8\x3a\x02\xff\x46\x32\x7f\x14\x36\x8c\x46\xd6\x68\x70\x1d\x03\x9e\x63\xe0\x1b\x8b\x0f\xa5\x9d\xc5\x18\x87\xac\x71\xf8\x38\x9e\x58\x4d\x28\x13\xa3\x0c\x39\x65\xf0\x4e\xa4\x6f\xd2\xd5\x62\x4c\xc6\xb6\x72\xfc\x28\xc7\xf7\xf2\x42\x08\xdb\xca\xc1\xbc\x1c\xcc\xcb\x89\x57\x39\xf2\xa7\x58\x10\x7a\xa7\x20\x6f\x4a\x3e\x44\x3e\x70\xae\x1a\x53\x90\x39\x05\x3b\xa7\x60\xc7\x54\x64\x4c\x05\x87\xa9\xc4\x70\x1a\xb8\x4e\x03\xb3\x69\xe0\x3c\x0d\x1d\xd3\xf0\x61\x1a\xfa\xa6\x83\xcf\x0c\xf4\xcf\xc0\x8e\x19\x60\x31\x03\xcc\x66\xa0\x63\x06\x76\xcf\xc4\xce\x99\xd8\x30\x13\x1b\x66\x62\xc3\x4c\xe4\xcf\x44\xfe\x4c\xe4\xcf\x82\x7f\x36\x31\x9f\xcd\xdc\xd9\x3c\xcf\x81\x67\x2e\xb1\x9c\x87\xec\xf9\xf3\xc5\x58\x40\x7b\x25\xf9\xba\x10\xdc\x17\x36\x12\x63\x11\xb6\x70\xf6\x19\x8b\xb1\x7b\x31\xbe\x2e\xc1\x97\xab\xb1\x61\x29\xfa\x97\x31\xff\x1a\xe6\x57\x60\x63\xc5\xbb\x62\x5c\x4b\x2c\xaf\x03\xaf\xeb\xc1\xfe\x7a\xfc\x5a\x8e\x7f\xd4\xee\xc6\x0d\x60\x7a\x03\x38\xdf\x08\xce\xd4\xec\xc6\x8d\xf8\xcf\xb9\x65\xac\x40\x3e\xe7\x96\xb1\x02\xbb\x57\x22\x67\x25\x32\x57\x62\xe7\x4d\xc4\xf3\x26\x64\xdd\x44\xcc\x56\x61\x07\xe7\x96\xb1\x0a\x3f\x56\xc1\x77\x33\x79\xb3\x1a\x39\xab\x99\xb7\x1a\x9d\xab\xc1\x8b\xda\xdc\x58\x83\xce\x35\xac\x8d\x35\xe0\x76\x0b\x3a\x6e\x01\x93\x5b\xc8\x85\xb5\xe8\xa0\x46\x37\xd6\xa2\x6f\x1d\x7e\xaf\xc3\xc7\x75\xc4\xe1\x56\xd6\xd2\x6d\x60\xc0\x39\x66\xdc\x0e\x5e\xb7\xe3\xf3\xed\xc8\x5a\x0f\xff\x7a\x64\xad\x47\x0f\x67\x99\x71\x07\xcf\xd4\xe2\xc6\x1d\x3b\x21\x64\xdf\x09\xef\x9d\xc4\xee\x4e\x30\xbb\x13\x7d\x77\x91\xd3\x77\x11\x9f\xbb\x98\xcf\xf5\xdf\xd8\xc0\xd8\xdd\x9a\x88\xd1\x3d\x60\x79\x2f\xf6\x53\x6f\x1b\xf7\xa1\x97\x7a\xdb\xb8\x1f\x1f\x1e\x40\xee\x83\xf8\xf4\x20\x6b\x7a\x23\x18\x3d\x84\x5d\x0f\xf1\xfc\x30\xd8\x3e\x82\xbe\x47\x88\xe1\x26\xf4\xff\x8d\xdc\xa1\x4e\x36\x1e\x43\xf6\x66\xf0\xf9\x3b\x7e\x3c\x8e\xec\xc7\x89\xf5\x16\x62\x41\x7d\x6c\x3c\x81\xbc\x27\xc0\xf7\x49\x74\x3f\x09\xcf\x93\xd8\xf8\x14\x7a\xb7\x62\x73\x25\x7c\xdb\xc0\x61\x3b\xf2\xb7\x23\xeb\x1f\xe4\xf1\x0e\x9e\x77\xb0\xde\x76\xb0\x4e\x9f\xc6\xb6\xa7\xf1\xf7\x69\x6c\x7d\x9a\xbd\xe7\x69\x64\x3e\x8d\xee\x67\x98\xf3\x4f\xfc\xa4\x86\x36\x76\x62\xf7\xb3\xac\x99\xe7\x88\xe7\x73\xe8\x7a\x1e\x5f\x9f\xc7\xd6\x17\x88\x15\x75\xb4\xf1\x22\xfa\x5e\x22\x56\x2f\x13\xe7\x5d\xe0\xbe\x0b\x0c\xa9\xa3\x8d\x57\xd0\xf3\x0a\x7a\x5e\x61\xfc\x55\xe2\xf8\x1a\x78\xbd\x86\xdf\xbb\xf1\x9b\xba\xda\xd8\x4d\xfc\x5e\xc7\x9e\xd7\x59\xcb\xaf\xa3\xf3\x5f\xf8\xf0\x06\xf6\x72\xb6\x19\x6f\x31\xff\x2d\xf2\xe0\x6d\x78\x38\xdf\x8c\x77\xc0\xe5\x5d\xe4\xbf\x4b\x0c\xdf\x03\xaf\xf7\x18\x7b\x9f\x79\xef\xa3\x6b\x0f\x71\xfc\x80\x9c\xfb\x10\xdd\x1f\xe2\xd3\x47\xe0\xf7\x11\xf1\xfd\x18\x0c\xa8\x8b\x8d\xbd\xf0\xee\xc3\x4e\xea\x60\x83\x73\xcd\xf8\x14\x7f\x3e\x43\xd6\x67\x60\xb7\x1f\xfd\x9f\x93\xbb\x9f\x23\xff\x0b\xfa\xbf\x80\xe7\x4b\xe6\x1d\x40\xc6\x57\xf4\x53\xc3\x1a\x07\x89\xd9\x41\xec\x38\x08\xcf\x21\x78\x0e\xa1\xf3\x6b\xfa\x0f\x83\xdb\x11\x30\x3f\x82\x5f\x47\xc9\xe7\xa3\xcc\xe5\xcc\x32\x8e\x93\x53\xc7\x89\x77\x15\x7a\xbf\x81\xe7\x1b\x30\x3c\xc1\xf8\x09\xda\x6f\x91\xfb\x2d\x63\xd4\x9b\xc6\x49\x64\x7e\x8f\xcd\xff\x26\x9e\x3f\x40\xa7\xb0\xe5\x47\xfc\xf8\x89\x9c\xfa\x19\xbc\x4e\x83\xd5\x19\x9e\xcf\xe2\xe7\x2f\xc4\xfd\x57\x70\xfb\x0f\xd8\xff\x86\x3d\x9c\x47\xc6\x39\xb0\xb8\x80\x8d\x17\x90\xe5\x67\xdc\x2e\x13\x53\x0a\xc5\x54\xeb\xc4\x34\x56\x8a\x69\x2e\x17\xd3\xea\x2f\xa6\x8b\x96\xf3\xc7\x74\x9f\x16\x33\xbc\x3e\xf4\xab\x98\x91\x51\xd0\x9b\x62\xd6\xd8\x2d\x66\xd4\x2e\x31\x6b\xae\x16\xb3\xd6\x06\x31\xa3\x4b\xc5\x8c\x61\x4e\xac\x4f\xcc\xb8\x7c\x31\xe3\x69\x13\x66\x8b\x59\x7b\xa3\x98\x75\x9e\x10\x33\x91\xe7\xba\x9d\xc5\xbc\x22\x06\x42\x4e\xbd\x53\x62\x26\xa1\xab\xbe\x05\x7d\x20\x66\x03\xf8\x1a\x62\x43\xc3\x43\x62\x7a\xe8\xf7\x22\xc3\xcb\x73\x32\x36\x24\xa3\x3f\x85\xb1\x94\xa3\x62\xa6\x22\xab\x91\x17\xba\x4f\xcc\x34\x81\xce\x8b\xd9\xf8\x33\x31\x9b\xac\x17\xb3\x69\x01\xc4\x7b\x33\xe6\x37\x47\x5f\x0b\xec\x69\xf1\xa5\x98\x2d\x91\xdd\x0a\x3f\x5a\xe7\x40\xbc\xa7\x23\xb3\x0d\x7a\xdb\xd0\xb6\xed\x26\x66\xbb\x70\x68\xb3\x98\x19\x8c\x67\xbc\x20\x66\xfb\xf6\x10\x6d\x07\x7c\xee\x80\xde\x0e\xf8\xd8\x01\x7f\x3b\x20\xbb\x23\x76\x75\x04\xa7\x8e\xd8\xd6\x09\x5f\x3a\x21\xb7\x53\x05\x04\x06\x9d\x98\xd3\x69\x2f\x74\x52\xcc\xce\xc8\xef\xcc\xfc\xce\xc8\xea\x0c\x36\x9d\xe1\xe9\xbc\x09\x82\xa7\x33\x36\x64\xa2\x33\x13\x3f\x32\xc1\x24\x13\xbb\x33\x91\x93\x09\x4f\x26\x72\x32\xe1\xc9\xc4\xd7\x2e\xf0\x74\x69\x03\xa1\xb3\x0b\x32\xba\x2c\x82\xd0\x4d\xdd\x6a\x76\x41\x4f\x17\x70\xec\xca\xfc\xae\xa3\x20\xe6\x76\x45\x7e\x57\x62\xd3\x15\xdb\xba\x32\xd6\x0d\xfd\xdd\x88\x43\x77\xe6\xf6\x80\xa7\xc7\x7c\x08\x5f\x7a\xc0\xd7\x03\x1d\x3d\xd0\x91\x85\x0f\x59\xd8\x98\x55\x0c\x81\x59\x16\xd8\x65\x81\x57\xd6\x4e\x88\xb8\x64\x7d\x23\xa6\x0f\x3b\x7c\x4d\x21\x64\xf9\xe0\xf3\xc1\xe7\x83\xcf\x47\x2c\x7c\xf0\xf8\x88\x4f\xcf\xba\x10\xb6\xf6\xc4\xd6\x9e\xd3\x21\xec\xec\x09\xa6\x3d\xc9\x91\x9e\xc4\xa7\x27\xf1\xce\x46\x4e\x36\x3e\x67\x83\x73\x36\x39\x97\x8d\x2d\xd9\x8c\x65\x83\x6b\x2f\xe6\xf6\x02\xeb\x5e\xc8\xe5\x0c\x37\x7b\x21\xb7\x17\x72\x73\x90\x9b\x43\x8c\x72\xb0\x3f\x07\xfb\x39\xdb\xcd\x1c\xc6\x73\xde\x85\xb0\x3f\x87\xb9\xb9\xc8\xe4\xbc\x37\x73\xb1\x2d\x17\xdb\x72\xc9\x85\x5c\xec\xcf\x05\xe7\x3c\x72\x24\x8f\xf1\x3c\xc6\xf3\xd0\x99\x77\x35\xc4\x78\x1e\x32\xf2\x88\x69\x9e\xe6\x41\x4f\x6f\xf2\xba\x77\x23\x08\x5d\xbd\xb1\xa3\x37\x3e\xf4\x26\x3f\x7a\x93\x67\xbd\xf1\xa1\x37\x98\xe6\x63\x7f\x3e\xb1\xca\xc7\x8e\x7c\xe2\x94\x5f\x09\x81\x77\x3e\x58\xf7\x41\x47\x1f\xc6\xfa\x10\xa3\x3e\xc8\xee\x43\x7c\xfa\xd0\xdf\x97\x18\xf4\x05\xdf\xbe\xe4\x62\x5f\x6c\xeb\x0b\x2e\x7d\x89\x5f\x5f\xc6\xfb\x32\xde\x0f\xfc\xfb\x31\xde\x0f\x9d\xfd\xd0\xd9\x0f\x9d\xfd\xd0\xd9\x0f\x9e\x7e\xf8\xd8\x0f\x1f\xfb\xa3\xb7\x3f\xf2\xfb\x83\x5b\x7f\xf2\x64\x00\xed\x00\xf0\x18\x80\x1d\x03\xb0\x63\x00\xb1\x1c\x80\x7d\x03\xc9\xb9\x81\xc4\x69\x20\xba\x06\xa2\x6b\x20\x7e\x0e\x04\x87\x81\xf8\x38\x08\x19\x83\x18\x1b\xc4\xd8\x20\xc6\x06\x31\x36\x88\xb1\x41\x8c\x15\x80\x51\x01\xbe\x17\x10\xbb\x02\x64\x72\x07\x32\x0b\xf0\xa1\x00\x7c\x0a\x88\xff\x60\xb0\x19\x4c\x7c\x06\x63\xe3\x60\xfc\x1b\x8c\x7d\x83\xc1\x64\x30\xb6\x0d\x41\xee\x90\x96\x10\xbe\x0f\x61\xee\x10\x72\x67\x08\x63\x43\x18\x1b\xca\xd8\x50\xec\x1e\x4a\x8e\x0e\x65\x7c\x28\xb6\x0f\x25\x7e\x43\xc1\x6d\x28\xfe\x0f\xc5\xff\x42\xf0\x29\x24\x36\x85\xc4\xa6\x90\xd8\x17\xa2\xb7\x90\xd8\x17\x12\xd7\x22\xc6\x8a\x18\x2b\x22\xae\x45\xc4\xad\x08\xbb\x8a\xb0\xb9\x88\xf1\x22\x62\x36\x0c\xbb\x86\x61\xf7\x30\x62\x36\x0c\xdb\x86\x81\xdf\x30\xf0\x1d\x06\x76\xc3\xc8\xab\x61\xe4\xdc\xf0\x04\x08\xfb\x86\xa3\x7f\x38\xfa\x87\xa3\x7f\x38\xf9\x3f\x1c\xcc\x86\x63\x43\x31\x98\x15\x83\x4b\x31\x7a\x8a\xd1\x53\x8c\x9e\x62\x7c\x28\xc6\xf7\x62\x7c\x2f\x41\x47\x09\xbe\x97\x20\xbf\x04\xdf\x4b\xf0\xbd\x04\xff\x4a\xf0\x8f\xbb\x9f\x39\x02\xd9\x23\xc0\x74\x04\x98\x8e\xc0\xbe\x11\xd8\x37\x02\x4c\x47\x82\xe9\x48\x6c\x1b\x09\xa6\x23\xb1\x6b\x24\x76\x8d\xc4\xae\x91\xd8\x35\x12\xdf\x46\x81\xcb\x28\xe2\x38\x8a\xb1\x51\xcc\x1b\x85\x3d\xa3\x90\x39\x1a\x99\xa3\x91\x39\x1a\x7b\x47\x83\xe7\x68\xe2\x3b\x9a\xb1\xd1\xc4\x77\x0c\xb6\x8e\xc1\xd6\x31\xe8\x1b\xc3\xd8\x18\x6c\x19\x83\x9d\x63\xd8\x6f\xc6\xe2\xe7\x58\x70\x18\x4b\x5e\x8c\xc5\x87\xb1\xf8\x30\x96\xb1\xb1\xf8\x50\x8a\x0f\xa5\xf8\x50\x8a\x0f\xa5\xf8\x50\xca\xbc\x52\xc6\x4a\x99\x37\x8e\x79\xe3\x98\x37\x0e\xfc\xc7\x81\xcd\x38\x62\x33\x0e\x5c\xc6\x11\x9b\xf1\xe0\x3f\x1e\x5c\xc6\x33\x36\x9e\xd8\x8c\x27\x36\xe3\x19\x1b\x8f\xfd\x13\xf0\x6d\x02\x76\x4c\xc0\xfe\x09\xf8\x36\x01\xdf\x26\xe0\xdb\x04\xc6\xca\xf0\xad\x0c\xdf\xca\xc0\xbb\x0c\x99\x65\x8c\x95\x81\xc9\x44\xec\x9f\x88\xfd\x13\x99\x37\x11\xbc\x26\xe2\xf7\x44\xf0\x9a\xc8\xd8\x24\xf0\x9a\x84\xcc\x49\xe0\x35\x09\x99\x93\x18\x9b\x84\xdf\x93\xc0\x64\x32\xf6\x4f\x66\x8d\x4c\xc6\xb7\xc9\xec\x73\x93\x89\xdf\x64\xd6\xdd\x64\xec\x2f\x67\xfd\x94\x33\xc6\x9d\xd9\x2c\x07\x93\x72\xf0\x2a\x67\x5e\x39\x32\xa7\x20\x73\x0a\x32\xb9\x2b\x9b\x53\xb0\x65\x0a\x3e\x4c\x61\x4f\x9a\xc2\xdc\x29\xe0\x32\x15\xac\xa7\x62\xcf\x54\xc6\xa7\x32\x77\x2a\xb8\x4c\x65\x6c\x2a\xb9\x35\x0d\x1f\xa6\x61\xe7\x34\xf0\x9a\x86\x3e\xee\xcd\xe6\x34\x6c\x99\x8e\x0f\xd3\x19\x9b\x0e\x2e\xd3\xb1\x67\x3a\x58\x4f\x47\xe7\x74\xc6\xa7\x93\x6f\x33\x18\x9b\x41\xec\x66\x60\xe7\x0c\xb0\x9c\x41\xdc\x66\x62\x23\x77\x6a\x73\x26\xfd\x33\xf1\x9b\x3b\xb5\x39\x93\xb1\x99\xe4\xf1\x4c\xe6\xcc\x62\x7c\x16\x31\x98\x85\x8d\xb3\x90\x35\x0b\x1b\x66\x81\xff\x6c\x6c\x9b\x4d\x4e\xce\xc6\xee\xd9\x60\x3f\x1b\xfe\xd9\xf0\xcf\xc1\xee\x39\x8c\xcd\xc1\xbe\x39\x60\x35\x07\x79\x73\xc0\x78\x0e\xf8\xcf\x61\xde\x5c\xe4\x71\x2f\x37\xe7\xb2\x7f\xcc\x23\x86\xf3\xc8\xa7\xf9\x60\x31\x1f\xdb\xe6\xb3\x16\xe7\x23\x73\x3e\x76\xcf\xc7\xdf\xf9\xe4\xf2\x7c\xfc\x5a\x80\xcc\x05\xf0\x2d\x20\x6e\x0b\xe8\xbb\x12\x7b\xae\x04\xdf\x85\x60\xbf\x90\xfe\x85\xe0\xbb\x90\x39\x0b\x99\xb3\x90\xf1\x85\xcc\x59\xc4\x9c\x45\x8c\x2d\xc2\xaf\x45\xe8\xba\x0a\x1c\xaf\x42\xff\x62\xf6\xec\xc5\xe8\x59\x0c\x3e\x8b\xc1\x61\x31\xf8\x2d\xc6\xa7\xc5\xc8\x5b\x42\xbe\x2d\x61\x6c\x09\x63\x4b\x18\x5b\xc2\xd8\x12\xc6\xae\xe6\xfd\x6a\x7c\x5b\x0a\x4e\x4b\x91\xb7\x14\x2c\x96\xe2\xf7\x52\xfc\x5e\x8a\xec\xa5\x8c\x2d\x63\xee\x32\xe6\x2e\x83\x77\x19\xf1\x5a\x86\xcf\xd7\xc4\xfc\x3f\x20\x7c\xbb\x86\x3c\xa8\xc0\xb7\x0a\xf0\xab\xc0\xaf\x0a\xe2\x51\x81\x4f\xd7\x62\xfb\xb5\x60\x7b\x2d\xf1\xbd\x96\x35\x74\x1d\xb8\x5d\x87\xbe\xeb\xc8\xd3\xeb\x39\x47\x97\xe3\xf3\x72\x6c\xba\x81\x9c\xbb\x01\xbb\x6f\x04\x8b\x1b\xc9\xf9\x15\xf8\xb1\x82\x9c\x5b\x89\x8d\x2b\xc1\x97\x5a\xc4\xbc\x89\xe7\x9b\xc8\xbf\xd5\xc4\x69\x35\xfb\xfa\x6a\x72\x61\x0d\xf2\xd6\x30\xbe\x06\x19\x6b\xc8\x99\x35\xe4\xda\x2d\xf0\xdc\xc2\xd8\x5a\xfc\x5e\xcb\xbc\xb5\xe0\xb4\x0e\x1c\xd6\x91\x0b\xeb\xc0\xf3\x56\xda\xdb\x88\xcb\x6d\xd8\x7c\x3b\x72\xd6\x63\xdb\x7a\x62\x7d\x07\x31\xbe\x83\x79\x77\x62\xe7\x5d\xe0\xb2\x81\x18\xdd\x8d\xdc\x7b\xb0\xf5\x5e\x64\xdc\x8f\xae\x07\x90\xfd\x20\x73\x1e\x82\xf7\x21\xf0\x7c\x18\x79\x9b\xb0\xeb\x6f\xc4\xed\x51\xf0\x7f\x0c\xdf\x37\x33\x46\x6d\x60\x6e\x21\x7e\x4f\x10\xdf\x27\x91\xf1\x14\xb9\x56\xc9\xdc\x6d\xe4\xcc\x36\x7c\xfd\x07\xfe\xed\x60\x4d\x3e\x4d\x2c\x9e\x61\xed\x3c\x0b\x26\xcf\x41\xcf\x83\xd5\x0b\xcc\x7f\x11\x79\x2f\xe2\xd7\x8b\xe8\x7a\x11\xbf\x5e\x02\xdb\x97\xb0\xe7\x25\xf6\x8b\x97\xc0\xf5\x65\xe4\xbf\xcc\xfc\x97\x99\xbb\x0b\x5f\x76\x81\xdb\x2b\xf8\xfb\x0a\xf6\xbc\x0a\x8e\xaf\xe1\xef\x6b\xf8\xbe\x1b\x19\xbb\xb1\x73\x37\x3e\xef\xc6\xb7\xd7\xd1\xfd\x86\x26\xe2\xf4\x16\x76\xbf\x83\xce\xf7\xc8\xe9\xf7\xb0\xef\x7d\x70\x78\x1f\x7b\xf6\x30\x67\x0f\x3e\xef\x21\x47\x3e\x40\xe7\x87\xac\xd9\x8f\xb0\x87\xfb\xbc\xf9\x11\xd8\x7c\x84\xfe\x8f\xf1\xe5\x63\x72\xea\x63\xf8\xf6\x12\xc3\xbd\xcc\xd9\x0b\x9e\xfb\xc8\x87\x7d\xf4\xef\x23\xfe\x9f\x20\xff\x13\xf4\x7c\x42\x1c\x3f\x45\xf6\xa7\xd8\xf0\x19\xbc\x9f\xd1\xf7\x19\xf6\xee\xc7\xc6\xfd\xf8\xb0\x1f\x6c\x3f\x47\xf6\xe7\xe8\xfe\x02\xdb\xbe\x60\xbf\xf9\x12\x1c\xbe\x64\xaf\x3b\x80\x8c\x03\xd8\x7f\x00\x9e\xaf\xc8\xd1\xaf\xf0\xf7\x20\xf1\x3f\x48\xbc\xa8\x01\xcc\xaf\xd9\x3f\xbe\x46\xd6\xd7\xd8\x7a\x18\x6c\x0f\x83\xc1\x61\xe2\x70\x18\xfd\x47\xc1\xfd\x1b\xf6\xda\xef\xb0\xf7\x24\x76\x9d\xc4\xc6\x93\xc8\x3a\x09\x86\xdf\x13\xcb\xef\xf1\xe9\x7b\xf4\x7e\x8f\x9e\xef\xf1\xe3\x07\x70\xfc\x01\xec\x7e\x84\x7e\x22\x6f\x7f\x22\x96\x3f\x83\xcd\xcf\x8c\x9f\x46\xc7\x19\xec\x3a\x8b\xff\xbf\x20\xf3\x57\x6c\xf8\x15\x9b\xfe\x43\x6c\x7e\xc3\x8f\xdf\xd8\x33\xce\xa1\xe3\x1c\x18\x9f\xc7\x8f\x0b\x60\xe1\x87\xcf\xee\x2c\x96\x84\x8b\xfe\x1b\x7d\x96\x41\x6b\x1c\x85\x4e\x8b\x65\x6e\x82\x76\x88\x65\x95\x41\xdf\x88\xe5\x9a\x2d\x96\xbb\x11\xd4\x5e\xac\x30\x0b\xda\x25\x56\xf8\x46\xb1\x22\xf2\xa1\xbd\x62\x45\xae\x84\x68\x6b\xd4\x87\xca\xa1\x4a\xe8\x4b\xb1\xa2\x5a\x42\x57\x43\x9f\x89\x55\x13\x5d\x35\x37\x40\x1f\x88\x55\x0b\x19\xb5\xfa\x43\x2f\x88\x15\xcd\x73\x34\x72\xa3\xd1\x15\xe3\x85\xde\x15\x2b\xb6\x1b\xb4\x53\xac\x38\xec\x8a\x2b\x86\x56\x43\xf0\xc6\x61\x5b\x7c\x5d\x68\x3a\x44\x5f\xfc\x7d\xd0\x13\x10\x63\xf1\xcc\x8b\x47\x67\xfc\x49\xe8\xbc\x58\x09\x51\x10\xf6\x24\x94\x42\x8b\xa0\x75\x10\x76\x25\xa0\x3f\x01\x9f\x6a\x23\xbb\x36\xb2\x6a\xb7\x81\xf0\xa3\x36\x32\x6b\xc3\x53\x1b\xbf\x6b\x63\x6f\x1d\xc6\xeb\xe0\x73\x1d\xc6\xea\x20\xa3\xce\x72\x08\x7d\x75\x18\xaf\x83\x9e\x44\xc6\x13\x19\x4f\x64\x2c\x11\xf9\x89\x8c\x25\x32\x96\xc8\xdc\xc4\x53\x62\xd5\x05\xcf\xba\xf8\x43\x1d\x64\x5d\x91\x03\x81\xc3\x15\x8c\xd7\xc3\xdf\x7a\xf8\x54\x7f\x57\x80\x1a\xac\x17\xab\x21\x7d\x0d\xc1\xad\x21\x3e\x34\x44\x76\x43\x7c\x68\x88\x0f\x1e\x7c\xf0\xe0\x83\x07\x1c\x3d\xe8\xf0\xec\x16\xcb\x1b\x03\x21\xd7\x8b\xdd\x5e\x1f\x54\x00\x11\x1f\x6f\x05\x84\xfd\x5e\xe2\xe2\xc5\x4f\x2f\xb2\xbd\xf8\x4a\x5d\x65\x79\xb1\x27\x19\x7b\x93\x99\x9b\xcc\xdc\x64\xe6\x26\x63\x53\x32\x76\x24\xe3\x77\x32\x73\x93\xb1\x23\x99\xb8\x27\x83\x7b\x32\x76\x24\x63\x47\x32\xf3\x52\xb0\x2d\x05\x9c\x52\xb0\x21\x05\x7d\xd4\x66\x56\x0a\xb1\x4a\x99\x0f\x81\x49\x0a\xf3\xa8\xd5\xac\x54\xec\x48\xc5\xbe\x46\xc4\xb5\x11\xba\xd3\xf0\x3f\x0d\xb9\x69\xe4\x45\xe3\xa6\x10\xfe\x37\x7e\x53\xac\x26\xf8\xd3\x04\x7b\x9b\x10\xb3\xa6\xd8\xd3\x14\xfc\x9a\x12\xc3\x66\xd8\xd7\x8c\xe7\x66\x60\xd4\x9c\xb9\xcd\x91\xd7\x1c\x4c\x9b\x13\x73\x6a\x3b\xab\x05\x3c\x2d\xe1\x69\x49\x7f\x4b\xf2\xa8\x25\x18\xb5\xc2\x87\x56\xf0\xb4\xfa\x55\xac\xd6\xe4\x4c\x6b\xec\x69\x8d\xed\xe9\xe8\xa3\xee\xb3\xd2\xf1\xbd\x0d\xbe\xb6\x01\xbb\x36\xd8\xd4\x16\x3f\xda\xe2\x6f\x5b\x74\xb7\x4b\x80\xe8\x6f\x07\x7f\x06\x36\x65\xd0\x9f\x81\xef\xed\xb1\xa9\x3d\xbe\xb5\x27\x8e\x1d\xf0\xb9\x03\x76\x77\x80\xa7\x23\xb1\xee\xc8\x73\x47\xfa\x3b\x91\xaf\x9d\x78\xee\x84\xbf\x9d\x89\x51\x67\xe6\x76\x86\x27\x13\x9e\x4c\x64\x66\xa2\xab\x0b\xb8\x75\x19\x05\xa1\xab\x2b\xf2\xbb\x22\xb3\x2b\xfc\xdd\xd0\xdb\x0d\xfe\x6e\x3c\x77\xe7\xb9\x3b\x58\x74\x07\xa3\x1e\xe4\x09\xf5\x9a\xd5\x83\xe7\x2c\xe4\x64\x21\x27\x0b\x5d\x3e\x74\xf9\x88\xab\x8f\xe7\x9e\xc4\xae\x27\x79\xd2\x13\x1c\xb3\xf1\x31\x9b\x75\x97\x8d\x8f\xbd\x78\xee\x05\x3f\x75\x94\x95\x83\xbf\x39\xf0\xe7\x80\x4f\x2e\x98\xe4\xc2\x93\xcb\xdc\x3c\xfa\xf3\xe8\xcf\x23\xf7\x7b\xa3\xab\x37\xfd\xd4\x39\x56\x3e\x3c\xf9\xe8\xcd\xe7\xb9\x0f\xfd\x7d\xc0\xb6\x0f\x98\xf7\xa5\xbf\x2f\x18\xf6\x45\x57\x3f\xec\xe9\x47\x2c\xfb\x91\x13\xfd\x91\xd3\x1f\x5f\xfa\xe3\xe3\x00\xec\x1f\x80\xfd\x03\xf0\x7d\x20\x3c\xd4\x21\xd6\x40\xe2\x47\xfd\x61\x0d\xc2\x77\x6a\x0e\xab\x00\x3c\x0b\x78\x2e\xd8\x0c\x91\xd3\x83\x59\x4f\xd4\x14\xd6\x60\x74\x0c\x21\x9f\x86\xa0\x7b\x08\xba\x87\xe2\xe7\x50\x6c\x1a\x8a\x0f\x43\x79\xa7\x56\xb0\x0a\xc9\xcf\x42\x6c\x2f\x82\xa7\x88\x1c\x1b\x46\xec\x87\x61\xcf\x70\x64\x0c\xc7\x9e\xe1\xc8\x1f\x4e\x8e\x72\xa7\xb7\x8a\xe9\x2b\x06\x9b\x62\x64\x14\xa3\xab\x18\x5b\x4b\xd0\x5d\x42\x8e\x70\x97\xb7\x4a\xf0\xab\x04\xfe\x12\xe4\x95\x90\x2f\xdc\xe5\xad\x11\xe4\x1b\xf7\x78\x6b\x04\x32\x47\x80\xcb\x48\xec\x1e\x89\x2c\xee\xf1\xd6\x48\x74\x8e\xc4\x96\x51\xd8\x31\x0a\xb9\xa3\xc8\xbf\x51\xe8\x1a\x0d\x2e\xa3\xd1\x31\x9a\x35\x36\x86\xb9\x63\xc1\xa2\x14\x39\xa5\xc8\xe0\x7e\x6d\x8d\xc3\xae\xf1\xe4\xd9\x78\x74\x8e\x27\x06\x13\x68\x27\x90\x03\x65\xac\x9b\x32\x7c\x98\x88\x4d\x13\x89\x23\x77\x62\x6b\x22\xbc\x13\xd1\x31\x89\x77\xee\xc0\xd6\x64\xe6\x4f\x26\xaf\x26\xc3\x57\x4e\x8e\x70\xa7\xb5\xa6\x60\xe7\x14\x7c\x98\x02\x86\x53\xd0\x35\x05\xbb\xa6\xb0\x4e\xa7\x20\x73\x0a\xb8\x4f\x81\x77\x2a\xb1\xe0\xfe\x6a\x4d\xc3\x87\xe9\xf8\xce\x9d\xd4\x9a\xa1\xbf\x73\x78\xc0\x3e\x62\x14\xb8\xba\x4b\x0d\x89\x56\xa3\x7d\xbf\xd4\x8a\x8e\xae\x19\x15\x25\x6e\x77\x6c\x4c\x74\x74\x44\xd4\x66\x33\xe2\xde\x91\xe6\xc6\xae\xb1\x2a\x3d\x56\x25\xc5\xaa\xa3\xb1\x6a\x6f\xac\xba\x37\x56\xdd\x1c\xab\xa6\xc5\xaa\x91\xb1\x8a\xa1\x1a\xb1\x6a\xc6\x77\xb1\xea\x79\xa7\x97\xae\x7e\xb1\xaa\x7d\x88\x6f\x5a\xa8\x07\xbe\x46\xb1\x2a\x21\x56\x7d\x10\xab\x76\xc5\xaa\xca\x58\xb5\x29\x56\xad\x8f\x55\xcb\x63\xd5\xfc\x58\x55\x16\xab\x0a\x63\x55\x8e\x33\xd1\x1b\xab\x62\x62\x95\xc4\xaa\xcc\x53\x21\x85\xbb\x63\xd5\x8e\xd0\x04\xb8\x4b\xab\x71\xc3\x67\xc0\x77\xa8\x9a\xe0\x8d\xb1\x6a\x5d\xac\xaa\x88\x55\xb3\x63\x95\xaf\x9a\xbc\x00\x5b\x65\x68\x08\x29\x05\xb1\xca\x13\xab\xa2\x63\xd5\xe8\xd0\xcf\x9c\xea\x3f\x63\xe7\x56\xff\x19\x33\xfa\x92\x9f\x10\xd3\x65\x83\xf4\x48\x56\x0b\xa9\x9b\x15\x97\x99\x1e\x1b\xa7\x32\x63\x33\x32\x9c\xff\xda\xb6\x49\x4b\x70\xa7\xa6\x34\xee\xd0\xbe\x63\x46\xbb\x3a\x66\x86\x99\xaa\xd6\xe5\xb6\x6f\x9f\x9b\x97\x91\x91\x57\xef\xf3\x63\x63\x46\xb5\xcd\xcf\x6f\x9b\x91\x97\x67\x3d\x75\x3e\x5f\xc4\x50\x2e\x73\x94\x39\x81\xb8\x98\x12\xa6\x06\xfb\xbe\x77\x87\x85\x59\x86\xa9\x7f\x27\xd6\x65\x59\x11\xe1\x61\x86\x25\x9b\x97\x44\xa8\x3e\x11\x2a\x33\x42\x35\x8b\x50\x49\x11\x2a\x22\x42\xbd\x15\xa1\x9e\x8d\x50\x5b\x22\xd4\xbd\x11\x6a\x4d\x84\x52\x5d\x23\x54\x0b\x67\x2c\x3a\x42\x4d\x79\x27\x42\x3d\xef\x0c\x3e\x18\xa1\xd6\x46\x28\x66\x4f\x8b\x50\x23\x43\x1c\x5f\x54\x1b\x0d\xf4\x0f\x72\xfa\x2d\x67\xe8\xe2\xdc\x7b\x43\xa3\xfd\x22\x54\x96\x33\x37\xc1\xe1\xc9\x3c\x5d\x8d\x69\x79\x88\x23\x3d\x42\x19\x31\x11\xea\x54\x84\x7a\x39\x42\x6d\x8d\x50\xd7\x38\x52\x99\x27\x4e\xcf\xc6\x08\xb5\xce\xe9\x9c\x15\xa1\xc6\x86\x86\xbc\x11\x7f\x88\xc6\xdc\xb1\x7f\x1a\x83\x39\x97\x86\xe0\xe2\xf8\xd8\x6a\xa3\x92\xd5\xee\xbd\x76\xd5\xe3\x10\xeb\xc4\x42\x69\xfc\x21\xe3\x81\xd7\x6f\xef\xeb\xbf\x8b\x3f\x5c\xdd\xfd\x1e\xf5\xb5\xdf\xa3\xff\xfe\x71\x2c\x8b\xca\x0b\xf6\x49\xe2\x51\xbd\x7c\x1f\xb8\xeb\x7b\xe2\xad\xb8\xb0\xb0\x70\x23\xa9\x5e\xa2\x55\xc7\x34\xad\x88\xa8\x9a\x31\x56\x6c\x78\x6c\x9c\xab\x41\xc3\x04\xab\xb6\x55\xbb\x4e\x9c\x55\x2b\xdc\x8a\xac\xa3\xff\xaf\x9f\xea\x46\x7a\x93\xdd\x2e\x23\x22\x2a\xe2\xc9\x92\x06\xf5\x93\xa2\x3c\x0d\xeb\xd5\x8c\xa9\xf9\x64\x49\x62\x42\x7c\x4c\x74\x8c\x27\xc6\x88\x8a\x8a\x89\x8a\x31\xeb\xd4\x8e\x8b\xdd\x6c\x86\x59\xe1\x7f\x7f\x39\x59\x6d\x4d\x56\x0f\x26\xab\xb5\xc9\xea\x9a\x64\x35\x2b\x59\x65\x25\x2b\x4f\xb2\xb2\x93\xd5\xc1\x64\xb5\x27\x59\x5d\x64\x18\x5b\x6d\xe8\x87\xd0\xe8\x35\xd5\xfa\xa3\x93\x55\xe6\x83\xd5\xba\x02\xcf\xa5\xc9\xca\xe7\x48\xa9\x70\x9e\x83\xe0\x5c\x8a\xe7\x1f\xc0\x94\xac\x8c\x8c\x0c\x4d\x71\x99\x99\xe9\xe9\x63\x46\x83\x5e\x46\x8b\x58\xc9\x70\x70\x0c\x3d\x01\x2c\x7f\x64\xc6\x65\xc6\x26\x82\x70\x6c\xdc\x9f\xfd\x09\xda\x61\xc9\x66\x6a\xbc\xa6\xd4\x4e\x19\x50\x72\x7c\x86\xa9\x29\x23\x2c\xd5\x6c\xa6\x18\xf8\x2c\xce\x7f\xfe\xee\xf2\xbb\xfd\x6f\x6f\x98\x72\xf7\x96\xd8\x5d\xb3\x7f\x8b\x53\x51\xeb\xcb\x6f\x57\x1d\xd6\x97\xaf\xdf\x14\xf7\xcc\x2c\xff\x78\xd5\x61\x96\xff\x1d\x23\x6a\xb2\x7f\xa4\xfa\x9b\xa6\xc9\x2a\x63\xb2\xba\xcb\x3f\x45\xd3\x64\xff\x7b\x2a\x43\xff\x8d\xf0\xba\x76\x99\x79\xd0\xf5\x8e\x34\x92\x96\x92\x21\x4b\x7c\x79\xad\xea\x36\x6b\xe3\xb6\x22\xd3\xea\x47\xd6\x6f\x14\xd7\x28\xae\x7d\x07\x69\x13\xd3\xc6\x88\x70\xb5\x6a\x53\xd7\xdd\x2c\xcd\x9d\x52\xb3\xb9\x2b\xc5\x35\xaf\x24\x39\xc5\xe7\x49\x61\x87\x10\xa3\x96\x29\x92\x72\x45\x62\xdb\x9a\x6d\xe7\x95\x78\x12\x54\x42\x42\x4c\xad\x9a\x61\x92\xf5\x5e\x46\x46\xfa\x68\xed\x72\xdd\xac\x8c\xf4\xb1\x1a\x8b\x7a\x31\xef\xe9\x77\xed\x9f\x7e\x07\x87\x4c\x70\xc0\x63\x3a\xda\xb5\x6d\x13\x9f\x91\xd8\x50\x25\xc6\xb7\x36\x58\xee\x59\x2a\x23\xac\x4e\xa2\x99\xda\xa4\x71\x13\xb3\xa1\x51\x3b\xc1\x1d\xad\x52\x3b\x35\x6e\xa2\xda\xb7\x56\x4d\xcc\x1e\x4a\x25\xd4\x49\x8c\xaf\xa5\xfa\xf7\x54\x69\xb7\x0c\x9d\x74\xe3\x8c\xac\x2f\xf7\x26\x0e\x49\x5c\x7b\x63\xdb\x9e\xae\x1e\xb3\x8a\x6e\x9d\x93\xf3\xdd\x89\xba\x43\xea\x7e\xbd\xc6\x38\xdc\xa8\x77\x9f\xb1\x2b\x56\xfb\x97\xf6\x2b\x1e\x34\x7f\x99\x9a\xf7\x72\x07\x9f\x61\xf4\xec\x35\x6a\xde\xc0\x27\x9f\x73\x57\x54\x98\x29\xfe\x13\x5b\xda\x45\xfa\x1b\x0c\x1c\xbf\x68\xc0\x6b\x07\x6b\xad\x5a\x69\x95\xa8\x76\x6d\xfb\x75\x4f\xbb\x70\x22\xf6\x21\xb3\x66\xf7\xb1\xad\x59\x73\xd7\xb0\x81\xc8\x02\xfb\x98\xbb\x83\x6b\x08\x88\x45\x4b\x03\x69\x26\x9d\xd4\x1e\x9f\x9d\x28\x2a\x26\xaa\xad\x97\x4d\xc6\x1b\xa5\x2c\x77\xf3\xc6\xee\xc6\x9d\x33\x1b\xb5\x7a\xa6\xa4\x61\xa3\x7f\x8e\x6c\xd8\xfe\x99\x12\x69\xb8\xd1\xaa\xf7\x4c\x49\xa4\xf5\xcf\x91\x91\xf1\xcf\x94\x18\x91\x5f\x4d\xcc\x54\x85\x99\x2a\x27\x53\x75\xc8\x54\x69\x99\xaa\x4e\xa6\x72\x67\xaa\x33\x99\xea\x78\xa6\xfa\x24\x53\xbd\x91\xa9\xee\xca\x54\x45\x99\xaa\x57\xa6\x92\x36\x99\x2a\x25\x53\x25\x38\x1c\x53\x7f\xca\x54\x47\x33\xd5\xde\x4c\xf5\xaf\x4c\xf5\xf7\x4c\x75\x67\xa6\xba\x31\x53\x4d\x71\x84\x65\x67\xaa\x00\x6b\x5c\xa6\xb2\x32\xd5\xd9\x6a\x9c\x77\x3b\x6c\x57\x66\xaa\x12\x47\x67\xbb\x4b\xd9\x02\x3c\x3b\x32\xd5\xa3\x21\x69\xb0\xf5\xc9\x54\xed\x33\x55\xa3\x10\x5b\xe6\xe9\x90\x6d\xbb\x33\xd5\x33\x99\xea\x26\x47\x1c\x4c\x99\x99\xca\xd7\xb7\x45\x35\x69\x01\xae\x8b\x02\x61\x9c\xe4\x30\x1a\x99\x0a\xe3\xd5\x21\x47\x1f\x42\x36\x65\xaa\xf5\x8e\xdd\x5d\x33\x15\xf3\x3d\x99\x2a\x1a\xa6\xb1\xbf\xef\x51\x63\xab\x9d\x28\x7f\x7d\x98\x5c\x72\xea\xcc\xfd\xe3\xa9\x33\xf6\x52\x3e\x96\xa6\xfe\x6b\x34\x75\x9d\x26\x90\x7b\x19\x81\xe5\xe6\xfc\x8f\xfc\x73\xb1\xbb\x71\xf0\xb5\xef\xa1\x32\xbc\xb1\x09\x61\x86\xd9\xbe\x71\x6a\x4a\x2d\x55\x3b\xa1\x4e\x46\x3b\x52\x8e\x91\x4e\x71\xc9\x8c\xd4\x52\xf1\x97\x8e\xf4\x98\x69\x6d\x9e\x75\x6e\x83\xff\xec\xd8\xad\xcb\x55\xad\x1a\xbd\xfa\xf7\xe8\x33\x70\x7c\x66\x97\xbc\x01\xe5\x5d\x8d\x34\xff\x99\x1a\x3d\x55\x6f\x55\x73\xdc\xd6\x45\x59\x74\x77\x76\xba\x13\x5c\x93\x2e\x34\x50\xee\x8a\x13\xf3\xfd\x17\xd2\xbb\xfb\x57\xab\x33\x05\x85\xd3\x4e\x0d\xef\x3f\x64\xda\x91\x73\x07\x95\xab\x75\xb6\x9a\xe5\x3f\xbf\xec\xe4\x95\xea\xf4\xe0\xa2\xa9\x3f\x17\xe9\x7e\xbd\x56\x87\xdb\x27\xdd\x6d\xc9\xc1\xc6\xd2\x46\xff\xbb\x3a\x3e\xbb\xf9\x15\xb5\x5c\x56\x7b\xab\x6d\x74\x67\x91\xa8\xb6\x6d\xbd\xd1\x71\x71\xf1\x6d\x9a\x34\xf0\xba\xaf\x08\x0b\x8b\xba\x22\xaa\x47\x56\x54\x58\x44\x58\x41\x49\x44\x04\xdd\xb5\x5c\x4d\x1a\x58\xed\xc3\x53\xeb\xa4\x76\x2d\x28\x49\xfd\xaa\x4e\xab\x82\x92\x3a\x75\xe2\xa2\x0b\x4a\xe2\x6a\xcf\xcb\x52\x13\xb2\xd4\x90\x2c\x95\xcd\xba\xcb\x52\xa9\x59\x2a\x3e\x4b\x59\x59\xea\x74\x96\x3a\x9a\xa5\xf6\x66\xa9\xdd\x59\xea\xe9\x2c\xb5\x29\x4b\xdd\x9e\xa5\xae\xcf\x52\xf3\xb3\xd4\xc4\x2c\x35\x34\x4b\x89\x2f\x4b\xb5\xcb\x52\x29\x59\x2a\x8e\x97\x2c\x35\xe5\xa7\x2c\x75\x28\x4b\x7d\x94\xa5\x76\x65\xa9\xca\x2c\xb5\x31\x4b\xad\xcb\x52\xd7\x65\xa9\xb9\x59\xaa\x34\x4b\x15\x38\x1a\x98\xe0\x75\x26\x18\x59\xea\x22\x3f\x1a\x76\x38\xfc\xb7\x65\xa9\xe5\x59\xea\xca\x2c\x35\xde\xb1\x28\x27\x4b\xb1\x19\x34\x72\xf8\xab\x5b\xf4\x6a\x96\xda\x9e\xe5\xbb\x55\xdb\x74\xa7\x33\x63\xae\x33\xa3\xd0\x61\x0f\xf0\x66\xfe\xe4\x30\x7f\x12\x12\xbe\x29\x24\x3c\x60\x4c\x40\x78\x7b\x47\x78\x42\x96\x72\x67\xa9\xb3\x59\xea\x78\xc8\x5d\xf8\x1f\x75\x44\x63\xbc\x9a\x8d\xad\xcc\xc0\xd9\x36\x8e\xed\x78\x7a\xca\x31\x1c\x17\x1f\xcc\x52\x63\xb3\xd4\xa0\x2c\xe5\xc9\x52\xd1\x59\xea\x92\xec\x1c\xcb\xff\xfe\x34\x41\xff\xf2\x62\xf4\xdf\xd9\xc7\xfe\xc9\x8c\xc0\xc5\xc9\xa1\xd8\x38\x21\xa1\x33\xeb\xa6\x07\x76\x59\x27\xc5\x63\x43\x39\x1e\x77\xf1\x85\xb3\x85\x1c\x0e\x53\x1d\x3b\x35\xe9\x94\x1c\xad\x8c\x30\x0f\x67\x4d\x93\x5a\xca\xb9\x68\xf5\x50\x9d\x5a\x2b\xe7\xbe\xd5\x50\xa9\x60\x8a\x77\xec\xa4\xf7\xdb\x1e\xec\xcb\xa4\xbd\xdb\x2a\x1d\xb0\xe2\x69\x55\x7c\x7b\xe3\x9b\xf4\xdd\x69\xdd\x55\x7f\xdf\xfc\x70\xa4\x7f\xf3\x9c\x05\x7b\x2b\x0e\x9c\x1a\xf4\xe8\xfd\x3d\x5a\xbf\xff\xf4\xcc\xfb\x8b\x2e\x3c\x77\xe3\xc2\x3b\x6e\x2c\x7b\x71\x90\xff\xa6\xee\x19\xd7\x8d\x6f\x5f\x56\x34\x65\x92\x35\xb0\x60\x6e\x51\x4f\xff\xcc\x7f\x3d\x99\xd4\xa1\x43\x92\xff\x87\x67\x5e\xad\xdb\xf1\xa6\xe1\x79\xcf\x3d\x35\xea\xae\x05\x9d\x4b\x96\x65\xdf\xbe\xbd\xe7\x42\x7f\xed\xcc\xbf\x5f\x79\xed\xfa\x41\x7d\xcd\xc2\xac\x85\xd9\x6d\xb3\x4b\xb2\x46\x95\xcd\xd5\xff\x7e\x89\xfe\xff\xec\xf9\xc8\xb9\xdb\xbd\xec\xbb\x21\x74\xab\x33\x65\x73\x96\x4b\xa5\xbb\xd4\x0f\x2e\x75\xd0\xa5\xf6\xb8\xd4\xcb\x2e\x35\xd6\xa5\x06\xb9\x14\xfd\xd1\x2e\x35\xc3\x76\xc6\xb6\xba\xd4\x83\x2e\xb5\xd6\xa5\x4a\x5d\xca\xe3\x0c\xd8\x0e\xf7\x35\x0e\x5f\xba\xd3\x79\x2a\xc4\x33\xd6\x61\xe8\x12\x10\x16\x18\xde\x1a\x92\x1a\x13\x52\x52\xe1\xfa\xe3\x95\xe0\xd2\xd0\x55\xbb\xdd\x72\x18\x5e\xbc\x4e\x05\xef\x51\x35\x83\xd7\x27\xfd\xd7\x93\x24\xdf\xdf\xdf\x8c\x77\xad\x91\x18\xd5\xd4\xf7\x71\x0d\x43\x57\x12\x71\x35\xa2\xce\x94\xd4\x10\xd3\x38\x53\x62\xfe\x32\x3f\x4e\x95\xc5\xa9\xc2\x38\xe5\x8b\x53\xed\xe3\x54\xa3\x38\x95\x10\xa7\x4e\xc7\xa9\xa3\x71\x6a\x7d\x9c\x5a\xee\x8c\x16\xc4\xa9\x9c\xd0\xa8\xc4\xa9\x29\xa7\x9c\xe1\x1d\x71\x6a\x93\xc3\x54\x18\x1a\xb6\x9c\xfe\xbd\xa1\xa1\x8b\x12\x63\xe2\x94\xc1\x3c\xa6\x1d\x8a\x53\xbb\xe2\x54\x65\x9c\x1a\x14\xa7\xda\xc4\x29\xaf\x33\xc6\x50\xe6\x29\x67\x60\x5d\x9c\x9a\x1d\xa7\x4a\x43\xbd\x1f\xc4\xa9\x07\xe3\x54\x85\xd3\x79\xc8\x79\x0d\x4c\xae\x70\xe6\x7b\xe2\x54\x74\xdc\x25\x8b\xe2\x0f\xf9\xff\x27\x6b\x64\xcc\x1f\xd2\x5c\x42\x19\xee\xa0\x08\x88\x9d\x62\x12\xc3\x1a\x93\x91\xf5\x48\xe3\xb0\x5a\x2a\x52\x9d\x3b\x14\xbd\xe7\xe9\x91\x7f\xf3\xbf\x17\x7d\xc3\x8e\x2b\x47\x5c\xef\x7f\x72\x5d\xe1\x55\xaa\xfd\x97\x95\xea\x2e\xd5\xf2\xeb\xb2\xc2\xbc\x7d\xfe\xc3\xfe\x04\x51\xf6\x83\xfe\xfe\xc6\x34\xb0\x8e\x95\xdf\x7c\x95\x11\x40\x5d\xb3\x66\x5c\x7c\x64\xc4\x99\x92\x48\x22\x71\xa6\x44\x7e\x69\x1f\xaf\x1a\xc5\xab\x84\x78\x25\xf1\xea\x74\xbc\x3a\x1a\xaf\xf6\xc6\xab\x1d\xf1\x6a\x53\xbc\xca\x71\x86\x62\xe2\x41\x2a\x5e\xcd\x38\x15\xaf\x0e\xc5\xab\x5d\xf1\xaa\x32\x5e\xcd\x8e\x57\xa5\xf1\xaa\xc0\x19\x64\xec\x94\xd3\xbf\x2e\xd4\x4f\xcf\x07\x21\xce\x8d\xf1\xaa\xc2\xe9\x8f\x8e\x57\xdd\x7f\x70\x7a\xd7\xc6\xab\xb1\xf1\x6a\x50\xbc\xca\x8a\x57\xe9\x21\x11\x4c\x78\x30\x5e\xcd\x72\x74\x6c\x75\xe6\xc0\x10\x44\xe4\x0f\x40\xfd\x01\xbf\xb1\xd5\xf1\xbb\x04\xbc\x58\x8d\x9e\xd9\xa9\x87\xaa\xc7\x32\x6f\xdc\xa4\x53\x9d\xb8\xda\x09\x91\xca\x1a\x17\x7d\xfd\xb6\xf9\xa5\xb3\xe6\x44\xef\xdd\x3e\xf2\x51\x5b\xfc\xfd\x0b\x73\x3f\x52\x71\xea\xdb\x47\x9e\xfa\x3e\xbf\x70\x99\xff\x83\x2f\x1e\xf3\x4f\xf2\xef\x39\xe2\xfc\x75\x3a\x79\xdd\x18\x68\xda\xac\xc5\x58\xa9\xed\x8b\x30\xe3\xe3\xda\xd4\x54\x35\xcd\xcd\x92\xb5\xdb\xb9\xd4\x71\x93\xeb\xe4\xa2\x58\x4b\x4b\xac\xa9\xc2\xd2\xe2\x53\xe3\x5d\x4d\xd2\x5e\xf7\xa9\xae\x2d\xee\x4b\x57\xdd\x7d\xfe\x1d\xaa\xbf\xcf\xff\x5a\xfa\x7d\x2d\xfc\x74\xe6\x5b\xcd\xd6\xbe\xaa\x7a\xfb\x9f\x7d\x69\xcd\xf8\x71\x6b\x5e\xf0\x3f\xaf\xf2\x5f\x5b\x3b\x41\xeb\x38\x21\xef\x58\x0f\x5b\x37\x50\x63\xb7\xf2\xd5\x8e\x94\x88\x08\x97\x49\xac\xa2\x0c\x31\xdd\xe6\x93\x25\x11\x61\xee\xad\xfa\xb2\xed\x5c\xa9\x43\x59\xe1\xb8\xa6\x62\x53\x63\x93\x3b\x24\xe3\x68\x72\x6d\xe3\x57\xfd\x77\x18\x37\x4f\x56\x8f\x1b\x0b\xfc\xc3\xd4\xe3\x93\xd4\xe3\xfe\x61\x93\x02\x3e\xe4\xf8\x5f\x57\xd7\xc8\xc7\x12\x23\xa9\x3e\xfd\x6f\xa8\x9a\x35\x6a\xc4\xc5\x9a\xd6\x7d\x25\xb5\xcc\x47\x46\xd6\x7a\x18\xcc\x42\xd9\x16\x97\xe9\xd4\xa1\x61\x1d\x3a\x76\x68\xef\x5c\x4e\xa9\x45\xd5\x35\x8f\xde\xf1\x5c\x93\xf4\x26\x39\x1d\xba\xe7\x37\xbf\xfe\x9f\x2d\x06\x74\x9d\x51\xbf\x7e\x83\x16\xcd\x3b\x66\x8e\x40\x76\x7f\x75\xa7\x51\x6a\xa4\xeb\xdb\xb5\x2f\x82\xb2\xd4\x52\xf2\x6c\x89\xda\xa9\x22\x25\x10\x05\x0d\x51\x87\xe4\xda\xfd\x8d\x04\x75\xe7\xdd\x77\x07\xec\x29\xb2\x8f\xa8\xde\xb2\x0f\x7f\xeb\xfa\x6a\xe8\xb4\x8c\x0a\x7c\x8c\x20\xa1\xc0\x5d\x5a\x0c\xab\xde\xa1\x42\x38\x54\x04\x93\xdb\x0f\xdb\x27\x8d\x7d\xae\x3c\xf4\xd6\xf7\x45\xb1\x47\xba\x44\x29\x8b\xaa\xb7\x8e\x64\x65\xc5\xaa\x8b\x85\x5c\x22\x17\x9d\x98\x99\xc6\x1b\xd3\x13\x5c\xfa\xef\xc8\x1a\x32\xc8\x3e\x69\x1e\xe7\x5e\x51\x43\xae\x90\xa6\xbe\x84\x78\x23\x2a\xdc\x08\xaf\x97\xe4\xae\x35\xaf\xc4\x1d\x26\x75\xe6\x95\xd0\xff\x7b\x0e\x65\x06\xa4\xb8\xb8\x10\xc5\x75\xd4\x57\x25\xc3\x1d\x1f\xa3\xef\x43\x46\xe0\xb4\x88\x53\x8f\xf8\x9f\x58\x77\x6e\xbb\x1a\x71\xeb\xb9\x03\x2f\x0e\xab\x18\x33\x60\xec\xf0\x85\x1b\xe7\x24\xa8\x47\xbe\x53\x55\x3f\xfa\x27\x1e\xf1\xd7\xf8\xd9\x3c\xad\x52\xe6\x9f\xf0\x4f\xdf\xb9\xe6\xd6\xcf\x0d\x97\xf6\xbf\x0f\x21\x68\xe4\xca\x97\x48\x49\xf7\xd5\x61\x2d\xba\x5d\xae\xa8\x1a\xee\x88\x30\x2e\x30\x2e\x4c\x9c\x57\x62\xd4\xd5\x50\x04\xca\x09\x0e\xb3\xdf\xf7\xd3\x34\x57\x58\x72\xa7\xb4\x78\x57\xa7\xb4\x0c\xa3\x8e\xaa\x15\x79\x21\x3d\x52\x25\xbe\xe2\x3f\x14\xa9\x9e\x6a\x5f\xa0\x4f\x1a\x2b\x6f\x5c\x87\xaf\xb4\x0e\xce\x0c\xf3\x63\x57\x7f\x6a\xd4\x6c\x5f\x4a\x52\x58\xed\xe8\xda\x4a\x35\xa8\x57\x5f\x45\xc7\x46\x1b\x11\x66\x34\xb7\xa7\xc8\x79\x25\x71\x61\x46\x3d\x55\xef\xca\x12\x75\x51\x9f\xf3\xa7\x53\xc2\x28\x92\x21\x56\x03\x80\xda\x66\x2a\x4b\x85\xce\x44\xaa\x93\x78\x1d\x95\xda\x1c\xac\xd1\x2a\xd9\xec\x70\xfe\xdd\x7a\x7b\xbf\xfc\x76\xce\xfc\xd9\x9d\xae\x6a\xe6\xcb\x6e\xf5\xf2\xb2\xe7\xde\xbc\xfa\xc2\xa1\xbd\xc6\xe3\xb7\xdf\x7b\xef\xc1\x33\xb7\x4c\x1b\xef\xa9\xb3\x49\x19\x2d\x36\xdc\x74\xfd\x4f\x55\xf7\x6f\xc0\x36\xfb\x02\x31\x78\x16\xdb\x5a\xc8\x74\x5f\x97\xa8\x66\x8d\x9b\xc5\xa4\xc6\x98\x09\x09\xa9\xa9\xf5\x5b\x99\x66\xcb\xc6\x54\xc1\xd1\xf3\x4a\x5a\xc6\xa8\x18\xfd\x37\x54\xeb\xc7\xd4\xc7\xe0\xfa\xf5\xbd\xde\xc4\x79\x25\xde\x30\x89\x98\x57\x52\x6a\x29\xcb\xd2\x71\x6a\x47\xd5\x25\xd5\x8d\x8e\xcb\xd4\x75\x58\x9c\x64\xea\x14\x88\x0b\x5c\x0a\x82\x85\x17\x51\x4c\x69\xdc\xc4\x29\xbc\x08\x5c\x87\xf6\x69\x4d\xf0\x49\xfd\xee\x13\x57\x61\xed\x94\x3b\xac\x21\x37\x01\x4b\x4d\x2c\xf9\x57\x9f\xb4\xec\xa8\xe4\x3b\x7b\x3c\xfb\x94\xff\xe7\x79\xb5\x6e\x5d\xb3\xa2\x7c\x56\xc7\x05\x2d\xf1\x70\xd2\xb2\x41\xcf\x7e\xb8\xf5\x9f\xeb\x1e\xf0\x7f\x9e\x90\x92\xa4\xea\xbd\x70\x45\xfa\xbd\x5b\x7e\x4a\x08\x1f\x12\x11\x71\xfb\xad\x33\x67\x35\x4c\xc4\xdd\xa4\x98\xbb\x57\xdd\xf1\x42\xbd\xda\xf7\x2c\xfc\xd7\x71\x27\xef\x08\xbc\xf9\x91\x2b\x87\x98\xd7\x92\xbe\xbe\x34\xb3\x66\x0d\x0e\xbf\xf0\xb0\x30\xa5\xdc\x46\x94\x65\xe1\x62\x4c\xb4\x58\x51\xd6\x82\x92\x70\x57\x54\x94\xaa\xe1\x76\xeb\xa0\x64\x11\x84\xf4\xc0\xd2\x27\x0b\x02\xd7\x1b\xfe\x0b\x54\x92\x7a\x6d\x29\x5d\x38\x77\x52\xba\x56\x36\x55\x72\xbc\xf1\x53\xa7\x87\x3b\x5d\x78\x3a\xc1\xf8\x61\xe3\xc6\xb7\xeb\xbc\x7b\xe1\x6f\xea\xc3\xb1\xaa\xbd\xff\x5d\xd5\x7e\x91\xb9\xe1\xfc\xdc\xeb\xcc\xf2\x0b\xf5\x8c\x06\xe2\xfc\xbf\x44\x9f\x34\x5f\x63\x5f\xab\x2f\xa5\xbe\x6e\xf5\x92\x92\x12\xeb\xc4\x9a\x75\xcd\x3a\xe1\x56\x83\x86\x12\x3f\xaf\x24\x5a\x3c\x32\x4b\x1e\x94\xad\xb2\x47\x0e\xca\x0f\x12\x1e\x45\xe5\xeb\x4e\x4c\x24\x59\x12\xdd\x7a\xb1\x44\x47\xec\x89\x30\x22\x22\xdc\x44\x21\x23\x14\x05\x70\x77\xc2\xd0\xa2\xba\xad\xd8\xa8\x71\xb5\x92\x53\x7e\x07\x3f\x26\x39\x25\x0c\xbb\x29\xfb\x3b\xaa\x6f\xdf\xfb\xd8\x7f\xcc\x7f\xe6\xc9\xbb\x1a\x67\x47\x35\xaa\xe8\xb2\x75\xbb\xff\xfc\xf4\xd1\xa5\x0b\x8c\xcd\x49\x17\xb6\xf7\x9b\x6b\xc6\x6c\x79\xf0\xe8\xd9\x16\x80\x9c\xe8\x79\x6e\xb7\xd8\x75\x8d\xbb\xef\xf6\x17\xd6\x15\x07\xd3\xa1\xf8\x70\x96\x3c\xaa\x27\x4d\xa4\xa7\x2f\x25\x36\x29\xc9\x4c\x4e\x8c\x48\x34\xcd\xa6\xcd\x12\x1a\xcd\x2f\x49\x48\x08\x93\x30\x4c\x8d\x8c\x0c\x0b\x93\x86\xbf\xaf\xec\x8c\xf4\xa0\xa9\xbf\xdb\x19\x4c\x8f\x0e\xed\xe3\x1a\x65\xb4\x4b\x0c\xa3\x16\x4f\x4d\x31\xcc\x60\x4a\xd4\xd2\x35\xb8\x93\x33\xf4\x86\xb9\xd5\x81\xe7\x3e\x78\x44\x35\xdb\x71\xd3\x3d\xcd\xb2\x6b\x94\x8c\xbc\xef\x48\x9b\xfe\x5b\xf2\x1f\x79\x7a\xf6\x27\xfe\x3b\x67\x4f\x5b\xb1\x7e\xdc\xe4\x79\x5b\x62\x12\xce\x7e\xf9\x1f\xf5\xc8\x4f\x1d\xaa\x56\x77\xf3\xef\xf5\x9f\x6d\xd5\xfe\xe1\x5b\x36\x7c\xb7\x5c\x6d\xdd\xbc\xf3\xf8\x9b\x33\x66\xf4\x98\x1b\xd8\x07\x17\x89\x58\x79\xc4\x20\x5c\x3a\xf9\x92\x94\xe9\x72\xbb\x23\x22\xc3\x4c\x33\xd2\x55\xd7\x32\xd8\x95\xae\x2c\x61\x4f\x53\xca\x70\x07\x20\x76\x6c\x0e\xee\x6d\x71\x4e\xfc\x81\x56\xa3\xa8\x52\x55\xb2\x8a\xfb\xff\x50\xf6\x26\x80\x51\x54\x49\xe3\xf8\xab\x3e\xa6\xbb\xe7\xea\x9e\xfb\xcc\x4c\x26\x93\x49\x48\x26\x21\x21\x93\x90\x10\x84\x34\xc8\x11\x03\x92\x10\x11\x68\xae\x44\x44\xe4\x90\x1b\x61\x15\x15\x14\x14\x10\x51\x54\x3c\x38\x84\x88\x88\x28\x08\xa8\xa8\x78\xa3\xe2\xae\xae\xb2\xe0\xbd\xdf\xba\x0a\xee\xb2\x2a\x9e\xec\x2e\xfa\x73\x81\x74\xfe\xaf\x5f\xf7\x4c\x26\x01\xf7\xfb\x7f\x1e\x99\x99\xee\x7a\xd5\xef\xa8\x57\xd7\xab\xaa\x1e\x58\x43\xf7\xb7\x9f\x7b\x77\x0d\x9d\xd3\xfe\x0a\x83\xa0\xdf\xa5\x67\x25\x66\xbb\xf6\x1c\x1a\x25\xf1\x3c\x9d\xc4\x3c\xcf\x4d\xac\xf9\x49\x72\xaf\xb0\xc5\x6f\xb2\x61\xe1\x82\x0a\x25\xc9\x12\x8b\x61\x66\x58\x9c\xb4\xd1\x91\x60\x24\x88\x17\x36\x02\x16\x3a\x12\xe1\x5d\xae\xfc\x05\x8a\x8b\xe3\x3d\x0b\x14\xbe\x93\x25\x76\xae\x30\xea\xd3\x27\xa3\x77\x77\xda\x97\x9a\xc2\x4d\xb6\x10\x5e\xe2\x82\x2a\x29\xa1\x2b\xd8\xb9\xa0\xcd\x5e\x1c\xf3\x4f\x30\xa6\xd1\x84\xf9\x27\x7d\xf2\x8e\x45\xa3\x27\xab\x96\x37\x5f\x86\x4a\xf9\xf2\x93\x7f\x85\x71\xed\x87\xb7\x6c\xfc\xb3\xfa\x7b\x18\xb6\x7c\xed\x98\x09\xb7\xde\x3a\x86\x19\x74\xe7\xe1\xbc\xc8\x9a\xa9\x6a\xe5\x23\xf7\xc3\x90\x09\xe1\xc5\xe3\x0f\x1f\x3d\x73\x72\xff\xd1\xcf\xd4\x95\x5f\x51\xcf\x3f\xf9\xe8\x15\x13\x1f\xd9\x33\x71\x32\xa1\x85\x8b\xf0\x18\x8f\x11\x7e\xd7\x03\xd5\xc9\xb1\x3c\xbf\x33\x1c\xa6\x69\xbf\x40\x17\x15\x7b\x12\x0b\x15\x8f\x07\xd3\x02\xe6\x2a\x66\x2e\x80\xa2\x98\x14\x38\x83\x14\x2e\x48\x09\x84\x60\x29\x26\x9e\x57\x58\xad\x53\xac\xd3\x95\x31\x19\x20\xdd\xfb\x54\x45\x75\x6f\xea\xf2\x57\x0e\xef\x50\xbf\xde\xf9\xec\xca\xc2\x81\x96\xbc\xe9\x7d\x1e\xfe\x4b\x8f\xe6\x27\x06\xb7\x1d\x98\xff\x09\x4c\x9b\x3b\x73\xd5\xbd\x73\x26\xaf\xbe\xd3\xce\x0e\xff\xd7\xf1\x0e\x75\xdc\xc9\xde\x9f\xdf\xe1\x8e\x42\x39\x70\xe5\x15\xfb\xb7\xdc\xfd\xc5\x22\x75\xe4\xce\x03\x1f\xbd\x72\xd3\x75\xfd\xe6\x6b\xfd\x5f\xdd\xf1\x77\x8a\xa7\x0f\xe2\xa5\xf0\x69\x72\xc9\xea\x74\x62\xc1\x18\xf0\x7b\xc4\x4d\xe3\x3d\x52\x46\x3c\x66\x29\x86\xdd\xa5\xa4\x2b\x5b\x62\x2e\x49\x4b\xcc\xb5\xdd\x45\x27\x75\x20\x2d\x43\x29\xd4\xa2\xbe\x45\xe5\x91\x67\x86\x51\x95\x1c\x76\x5a\xad\x3e\xfc\x50\xd1\xe7\xcb\x89\x88\xd2\x66\x25\x28\x3e\x32\x3e\xb8\x4d\xa0\x37\x8d\x17\x24\xe3\xd9\x9d\x0f\x37\xe8\x2f\xdb\x67\xdd\x4d\x6f\xa0\xf2\xd2\xcf\x5e\xd5\xa9\x40\xd0\x43\x8d\xc7\x9f\xdb\xd7\x4d\x95\xc0\xfb\xe1\x1b\xf4\x22\xf3\x30\x73\x3f\x32\xa1\x71\x72\x35\x65\x62\xc0\x04\x3c\xc7\x50\x76\xc5\xc4\xd8\x4d\xb9\x08\xda\x98\xa3\x0c\x55\xce\xc8\x4c\x2b\x33\x97\x59\xc7\x1c\x64\x4c\x88\x29\x67\x9a\xf0\xcf\x65\xf8\xe7\x3e\xe6\x38\xc3\x33\x07\x3a\x0e\xee\xef\xd1\xab\x9e\xd9\x8b\x02\x75\xc9\x89\xf3\xe6\xa7\x52\xc1\xc3\xc9\x6c\x59\xee\xaa\x02\x8f\x00\x9e\x6f\xe8\x17\xce\x7d\x4a\x17\x51\x77\x55\xc0\xc7\x57\xab\xd7\xa9\xd7\x5d\xad\xf3\x94\x93\xb0\x93\xd9\x86\x15\x3c\x1a\x93\xc8\x58\xb9\x96\xa3\x18\xa0\x80\x17\x4c\xdc\x93\x4a\xae\x09\x4e\x99\x60\xaf\x09\x24\x13\x20\x93\x6c\x6a\x32\x1d\x37\x31\x56\xbc\x8d\x28\x7c\x8f\x6e\xa2\x29\x91\x3e\xa6\xfd\x39\x42\x77\xd0\x34\x8d\xca\xf0\xd3\xf1\xa4\x69\xdb\x45\x53\x58\xb3\xfb\x00\x9e\x58\x95\xf6\x3f\xb3\xed\xdc\x50\xdc\x8f\xa1\x94\x7d\xea\x54\xd8\x38\x75\xea\x6f\xcd\x01\xc5\xd8\x15\x44\xd9\x51\xae\x89\x6d\xa3\x8e\x52\x54\x39\x25\x63\xa5\x6b\x2e\xb5\x8e\x3a\x88\xb9\x03\xfe\xd9\x84\x7f\x2e\xc3\x3f\xf7\x51\xc7\x31\xe7\x30\xe6\x80\xfa\xcd\x39\xa8\xae\x12\xa0\x4a\x9b\x83\x22\x3c\x07\x2f\xbc\x78\x35\xac\x84\x95\x57\xab\xc9\x0a\x44\x41\xbc\xe3\xef\xf4\x4f\x78\x1f\x79\x50\x0c\xdd\x28\x0f\x37\x39\x3d\x14\xe6\x42\x5e\xaf\x2d\xec\x0c\x63\x9e\xe8\xd9\xac\x98\x44\x0a\x44\x2a\x4a\xd5\x51\x8d\xd4\x52\xea\x2e\x6a\x2b\xc5\x09\x34\xc8\x39\x89\x7a\x90\x25\x6f\x3d\x85\xe7\x4b\x8a\x06\xa2\x9b\xc6\x07\xda\x90\x0d\x04\xda\x66\x93\x24\x7e\xb3\x22\x31\xa8\x53\x50\xeb\xac\x04\x6f\xbc\xb2\x64\x52\x9b\x9f\x3e\xe9\xde\x69\x4a\x47\xca\x10\x1b\x71\x57\xb5\x26\xa0\x75\xf9\x5c\xad\xa9\x5f\x12\xcb\xd1\xd9\x64\xfe\x4b\x53\x6c\xfd\x82\x39\x7f\xb8\x68\x69\x7e\xc5\xc0\xe8\xd6\x36\x98\xad\xde\xd8\x57\x1a\x9c\xd2\xa8\xae\x62\x08\x4c\x82\x11\x39\xde\x6d\x1b\x3f\x2f\x09\x6f\x57\x07\xaa\x9f\xa9\x9b\x2e\xb3\xb5\x9f\xd1\xc9\x6f\x30\x59\xeb\xdf\xa9\x4b\x4c\xed\xec\x28\xd4\x0f\xd5\xa3\x0f\xe4\xdb\x7a\x73\x17\x87\x13\x3d\x7a\xd4\xf7\x77\x7b\xcb\xec\x76\xe4\x0d\x73\xec\x25\x0d\xfd\x02\x74\x5e\xdd\x27\x8a\x77\x70\x60\xf0\x9f\x15\x67\xf2\x53\xc5\xe9\x0c\x88\x79\xd1\x3c\x4a\x0c\x44\x03\x94\x44\xe7\x05\xf2\x02\x16\xda\x52\xf1\xb1\x62\x61\xe8\xda\x8f\x15\x5a\x6c\x80\x8e\x06\x38\xda\x00\x07\x1b\x60\x5f\x03\xb4\x35\x40\x59\x03\x9c\x6a\x80\xe3\xe4\x62\x4b\x03\x48\x0d\x80\x1a\x40\x5e\xd7\x00\xad\x0d\xd0\xd4\x00\x3f\x35\xc0\xb1\x06\xc0\x3f\x97\x35\x00\x6e\x6c\x98\x32\x69\x7b\xc7\x30\x77\x50\x59\x86\x01\x6b\xb3\x86\xe7\x6c\xa2\x03\xcb\x31\x6d\x42\x75\x7d\x27\x23\x71\x3b\x0f\x31\x58\x13\x66\x61\xf9\x54\x95\xe4\x44\xb1\x5c\xe4\x20\x1c\xad\xaa\xb2\x3a\xcd\xca\xe8\xbe\x50\xe1\xa3\x4d\x86\x22\x5b\x55\x89\x62\x79\x0c\xe5\x70\x3b\x19\xe2\x05\x29\xcc\x33\x61\x1d\x57\xfb\xca\xbe\xb2\x56\xfd\x72\xc7\x97\xea\xe3\x2f\x9d\x85\x97\xc0\x0e\x4d\x30\xef\x0d\xf5\xb9\x67\x06\xf0\x63\x76\x5e\x5c\xdf\xd8\x6f\xce\x63\x6d\xb7\xe4\x17\x94\xcf\xf7\x25\x12\x0b\x0f\xce\x55\xdf\x56\x7f\x3c\xa9\xae\xf9\x74\x13\x14\xbc\xbd\xfe\x3f\xb7\xaa\x7f\xeb\x75\xcb\xde\xe9\x4d\x35\xf7\xf6\x3b\x30\xbb\xe5\x15\x18\xfb\x17\x08\xc3\x7b\x40\xa9\xaf\xaa\x5f\xbc\xaa\x3e\xf5\xc7\x54\xc5\xb0\x31\xca\xac\xf1\x8b\xff\xbe\x6f\x49\xa9\xa9\xfd\xc7\xd9\x72\x22\xf0\x08\xe4\x6d\x3c\x07\xfe\xbf\xab\x97\xa9\x67\xdf\x54\x8f\xee\xba\xb4\x85\xde\xcd\x28\xea\xaf\xf7\xdd\xd7\xbf\x12\xaf\x59\xc7\x3a\x2c\x33\xbf\xc5\xba\xb3\x88\x9c\x68\x8e\xdc\xdf\x61\x17\x45\xc6\xc4\x3a\x6d\x92\xd5\xca\x71\x12\x43\xbb\xdc\x36\xbb\xc3\xde\xaa\x38\x1d\x0e\x4a\x32\xb1\x8c\x68\xc5\x1c\x84\x69\x51\xcc\x94\xf3\x94\x1b\x8e\xbb\xe1\xa8\x1b\x0e\xba\x61\x9f\x1b\xda\xdc\x86\xb1\xae\xb9\x4b\xc9\x71\x05\x96\x07\x44\xdf\xca\x56\xb7\xb0\x96\x55\x51\x81\x3f\x35\x65\x2b\xc1\xc5\xea\x00\x52\x2e\x9f\xf6\x49\xc7\x68\x01\xcb\x5d\xde\xac\xde\x63\x9e\x4b\x3d\xf1\xda\x99\x1b\x2d\x6a\xc2\x72\x97\xdc\x7e\xea\x30\xd5\xac\xee\x84\x0f\xab\x34\x75\xfc\xd7\xb3\xbc\xa6\x96\xc3\x72\xf5\x46\x66\x5a\xfb\xb5\xba\x3c\x76\x75\x9c\x61\x9e\x23\x72\xdf\x89\x12\xe8\x26\x79\x28\xed\xf3\x7a\x3d\xd6\x58\x2c\x12\xe2\x25\x8e\x73\x38\x3c\x1e\x57\xc8\x55\x58\x10\x91\x78\x5e\x6a\x55\x10\x5f\xce\xb7\xf2\xeb\x78\x26\x48\xf3\xbc\x3f\xdf\xef\x6d\x51\xfc\x5c\xab\xe2\xa7\x1d\x0e\xc1\x25\xb4\x2a\x2e\x4f\x8b\xe2\x72\xce\x2d\x84\x89\xc4\x92\xd3\xb6\x58\x9d\xe6\xfe\xc5\xa6\x43\x46\x56\x67\x36\x3f\xd1\x1b\x9d\xe9\xef\x15\x9a\xb0\xd3\x24\x72\x12\x68\x57\xfa\x8b\x97\xad\x03\x57\x61\xb5\xe6\xff\x35\xb4\xe1\x58\x82\x5a\xfa\xc6\xa3\xb7\xdc\xb7\x65\xec\x9d\x07\xf7\x3f\xf5\xd8\x8b\x53\x36\xa8\x1e\xf3\xad\xef\xef\x34\x53\x85\xf0\xe2\x53\x5b\x36\x3d\xa1\x7e\xae\x7e\xa1\xde\x4c\xfd\xeb\x96\x47\xa6\x4d\x51\xc5\xf6\xc9\xf7\x3d\xb9\xea\xfa\xf6\x37\x4c\xa3\xf0\x0c\x6c\x09\x56\xa9\x5f\xad\x3d\xe0\xb1\x6d\x5d\xfe\xe9\x3b\x26\xa2\xf7\xcc\xef\xf8\x81\x9d\x8e\x79\x4c\x04\x8d\x92\x7b\x61\xdd\xd3\x22\x08\xb9\x2e\x9a\x8e\xe6\x72\x62\x8b\x32\xc7\x72\xc4\x72\xcc\x42\x23\x0b\x08\x16\x0b\xc7\xa0\xa0\x14\xcc\x0d\xd2\x36\x3a\x18\x44\x08\x8f\x1c\xb9\xb2\xd9\x48\xaa\x0c\x6f\x84\x8c\xb5\x6f\x48\x45\x36\x17\x19\x8a\x1c\x1d\xaf\xea\x89\xa9\x9d\x31\xac\xb5\x3a\xac\x27\x9b\x18\xea\x25\xf5\x07\xf5\x8f\x47\xe0\xc6\x9f\x3f\xfc\x7b\xe9\x80\xfe\xfb\x5a\x9f\x55\xbf\xdc\xfa\xfe\xeb\xf3\xff\x32\xa8\x7e\x40\xbf\x05\xea\xff\x73\x41\xae\xfa\x2b\xdc\x70\x38\xa5\x7e\xb6\x27\x59\xf6\xba\xba\xe5\x6f\x9f\x7e\x39\xa8\xea\x1d\xf5\xad\xe2\x32\x4c\x7f\x27\x3b\xce\xb1\x3b\xc9\xda\xf9\xd0\x45\x72\x1e\xb2\xd2\x1e\x0f\xe3\xb6\xba\x03\x7e\x1f\x5e\x06\x1f\xdd\x8a\xff\x77\xba\x5b\x14\xa7\x09\xd3\xa0\x73\x6e\x40\x5f\x94\x8c\xec\x4c\x0b\x4f\x3c\xef\x52\x2c\x4e\x7b\x53\x58\xac\x19\x7b\x33\x11\x27\xd3\xce\x7c\xd2\xde\xbe\xed\xbd\xb6\x69\x50\x00\x17\xab\xb5\x70\x31\x5c\xfe\x8e\x7a\xc7\x2f\x6a\x74\x97\xb0\xef\xe8\x63\x02\xed\x80\x0f\xce\x2e\xe1\x61\x26\x7d\x03\xd6\x9a\x7f\xf9\x49\x5d\xff\x3a\xa3\x4f\x32\xb6\xab\xbe\xc1\x7b\xe3\x0d\x72\x2e\x79\xa3\x5c\x6f\x76\x08\x4e\x67\x48\x40\x28\x44\xfb\x6c\x21\x26\x9c\xe3\x72\x06\x9c\xad\x8a\xe8\x30\x3b\x5a\x15\xeb\x31\x33\xb4\x98\xe7\x98\xa9\x52\x33\xd0\xc8\x2c\x99\x29\x81\x35\x9b\x03\x54\x20\xd4\xa2\x78\x03\x4e\x0a\x53\x15\x4b\x61\x05\x41\xa1\x68\x7d\xba\xb3\x95\xa5\x16\xe2\x73\x99\x97\xd2\x99\x4f\x96\x65\xa2\x6f\x17\x3c\x34\x4c\x3c\x74\xbc\x5a\xa3\xa5\x58\x75\x8a\x8e\x17\xc6\xe8\x58\xae\x36\xf9\xda\xf6\x99\xbf\xd3\x4c\xff\xd8\x67\xa0\x69\xd6\x47\x9f\x4d\x84\x19\x17\xc9\x97\xc8\x94\x7a\xff\x15\xc0\x03\xba\xfc\xaa\x81\xcd\x67\x3f\x30\xef\x65\x7e\xc4\x24\xf3\xda\xff\xd8\xdb\x4f\xb7\xa9\x53\xb6\xb5\x7f\x2e\xfd\xaa\x6e\xa9\x0a\xe1\xf1\xfd\x8c\xc7\x77\x1a\x8f\xcf\x07\x16\x79\x8f\xc7\xed\x36\xe1\x2e\x3b\x90\x24\x01\x70\x26\x93\x3f\xe0\x45\x0e\x84\x77\x43\x8b\x63\x8e\x83\x2a\x75\xe0\x71\x39\x24\x07\x1e\x17\xde\x25\x8c\xa0\x6d\x23\x2b\x16\x46\x56\xab\x20\x70\x2d\x0a\x16\x58\x26\xc6\xd4\xa2\x30\x4e\x29\x00\x28\x00\x7d\x4e\x05\xe0\x78\x00\x8e\x06\xe0\x60\x00\xf6\x05\xa0\x2d\x00\xeb\x02\xb0\x2c\x00\x78\x01\x5b\x03\xd0\x14\x00\x39\x00\xe5\x01\xc8\x0d\x80\xde\xe0\xff\x0a\xff\xff\xc3\xe9\x7d\x9e\x09\xde\x65\xba\xd3\x33\xdd\xa7\xd3\x00\x24\x7a\xb7\x66\x02\x12\x7e\xe4\x32\x26\x3d\x1e\x33\x26\x1d\x5e\x9d\xf0\x99\xb9\xfd\x0d\xf3\x36\xbc\x4f\x99\x5c\x3c\xe3\xd7\x7c\xac\xfe\xfb\x4a\x78\xa5\x6f\xbf\xfa\x7e\x34\x35\xae\xfd\x17\xe2\x2f\xd8\x62\xcc\xf5\xfb\xda\x5c\xe3\xbd\x39\xaf\xe3\x47\x76\x13\xde\x9b\x31\xac\xfd\x94\x3b\xe9\x68\x24\xe2\x0f\xe0\xfd\x19\xa0\xe9\xbc\x78\x24\x10\x0a\xb4\x28\xa1\x10\xe2\x38\x7b\x8b\x22\x5a\xe6\x58\x96\x5a\x68\x91\x26\xdb\xd4\x63\x6c\x4d\x64\x1c\x81\x66\x14\xeb\xae\x96\x6b\xf7\xfd\x89\xfb\x9b\xd9\x9e\xd5\x2e\xe2\xa4\xa7\xed\x40\x3d\xad\xfe\xa4\x1e\x3d\x0a\x37\xfc\xf2\xf5\x9f\x53\x17\xd3\x4b\x3f\x7c\x4a\x3d\xbe\xed\xf0\x01\x65\x7f\x5d\xdd\x63\x02\xfc\x24\xac\x1a\xf6\xc0\x69\x27\x44\xd5\xb3\x70\xfd\x7b\x17\xa9\xc7\x77\x4c\x7d\x4d\x6d\xfb\xea\xe8\xc9\x54\x0f\xb8\x22\xd8\xbb\x77\x50\x9d\x50\xdb\x53\xf3\x33\x7c\x8b\x4d\xd6\x38\xd9\x0f\xcb\xe4\x41\x3e\xb3\xd7\xe2\x75\x38\x2c\x92\x5f\x08\xf0\x01\xac\x6b\xd3\x94\x44\xe5\x84\x7d\x7e\xc1\xdf\xaa\x98\x45\xa1\x4e\x68\x14\x68\x0b\x2d\x08\x88\x95\x2c\x3c\xcd\xd2\x2d\x8a\x8d\xa5\x03\x5e\x07\x85\xa8\x16\xc5\x8d\x9c\x73\x73\xb4\xbd\x5c\x91\x11\x15\xe9\x23\x6e\x7d\x89\x52\xd9\x07\x11\xc6\x4e\xd0\x47\x4c\xb6\x84\xbe\xb7\xb5\xd1\xc5\x8c\x4f\x7d\xd1\x62\xf8\xd3\xcb\xef\x3b\xb2\x83\xa7\x02\xfc\x33\x13\xa8\xc5\x13\xc8\xb7\xa7\x8f\xec\x10\xda\xbf\xe1\x9f\xbe\xb2\x7d\xf5\x95\x3b\x78\x7d\x99\xaa\x82\xed\xff\xa4\x44\xed\xf3\xec\x64\x6d\xe9\xa8\xaa\xf6\x77\x43\x55\xda\x38\x7f\xc5\x82\xf1\x0c\x89\xd1\x19\x2c\xe7\xe3\xad\xc0\x62\xce\x89\x10\xcb\x5a\x6d\x16\x13\x8f\xa9\x9c\xa7\x11\x4b\xb3\x2d\x0a\xed\x14\x6d\x40\x2d\xb3\xc1\xc4\x96\x79\xd9\xd4\xd6\xc9\x3f\xf5\x05\x4a\x64\x08\x4a\x04\x98\xb7\x83\x6f\x3f\x99\xee\xe1\xd3\x4d\x69\xa2\xa9\x0a\xea\x36\x6c\x14\xdb\x5d\x9f\xe3\x67\xbb\x50\xa5\x1c\x74\x61\xb5\x95\x65\x2d\x16\xb7\x87\xd7\x98\x8c\x95\x77\x69\xfe\xac\x4e\x2e\x62\xd8\xde\xd0\xc7\x99\x39\x20\xd0\x27\x83\xc2\xd6\x62\xda\xd8\xaa\xa6\x16\x3f\x26\x50\x8c\xf0\xd0\x3d\x4d\xea\x73\x83\x6f\x2a\x2a\x1e\xc0\xda\x2e\x2b\xbe\x23\xa6\xb1\x85\xaa\xe0\xb9\x37\xd4\x8b\x42\xae\x6f\xd6\x78\xa3\xaf\x6a\xcf\xd7\x78\x1e\xbb\x07\x3f\x3f\x80\xd6\xca\x4d\x0e\x49\x12\x69\x9e\x12\xbc\x82\xd9\xe5\xf1\xd0\x94\xc5\x6c\x66\x44\x1f\x25\x52\xc1\x10\xe5\xf3\x48\x4e\x09\xcf\x81\x17\x6b\xa4\x01\x27\x8d\x6f\xd8\xb0\xb4\xe1\x6c\xce\xb6\x10\xac\x0b\xc1\xb2\x10\xcc\x0d\x41\x6b\x08\x9a\x42\x80\x8d\xf1\xf2\x10\xe4\x86\x3a\x77\x6d\x5a\x45\xc0\x03\xc0\x86\x6e\x67\x70\x03\x31\xc3\x2b\xb4\x3f\xc6\xa6\x74\x66\x54\x7c\x11\x04\xc0\xf3\x08\x1c\x9d\x35\x9b\x34\x1e\x2f\xbb\xc7\xbc\xb9\xfd\x23\x78\xed\x36\xb3\x7a\x58\xbd\xea\xae\xb1\x2f\x9b\xdb\x3f\x32\xef\xd5\x84\x69\xc0\xbc\x6f\x32\xb5\x63\xb1\x99\xed\x57\x15\x54\xfb\xb4\x17\x85\xaa\xa8\x3d\xd7\xaa\xbe\xce\x29\x6f\xff\x80\xea\x89\x39\xbd\x31\x6e\xc6\x49\x2a\x1a\x4e\x96\x0b\x19\x16\x8f\x54\xb0\x89\x22\x42\x02\x2b\x38\x24\xd1\x6c\x35\xb7\x28\x56\x9a\x13\x5a\x94\x36\x06\x10\x23\x61\x2b\x8a\x66\x48\x21\x4b\x97\xb7\x9e\x61\x38\x0e\x73\x4a\xce\x99\x16\xa5\x44\x07\x4f\x7b\xd2\xb2\x89\x38\x4d\x10\x78\x55\x5c\x84\x7d\x1b\x44\x71\xe5\x27\xaf\xce\x9c\x33\x60\xf4\xb9\x12\xbd\xe3\x17\x99\x3f\x1c\xed\x06\x9f\xba\xb4\x0b\x6d\x68\x7d\xe4\x78\xdc\x47\x3f\xba\x5a\xae\x32\x0b\x82\x16\xa1\x64\xe3\xfd\x76\x9f\xcf\xe9\x14\x1d\xbc\x23\x10\x74\x08\x16\xdc\x45\xbf\xdd\x4a\x59\x68\x9f\x93\xe6\x4d\x7c\x8b\xe2\xf9\xd0\x06\x2b\x6c\x60\xc3\x36\x96\x93\x04\x99\x18\xa2\x46\xd7\xcf\x52\xd9\x1b\x4d\x97\xf9\x64\x05\x52\x15\x5a\x47\x63\x71\x0b\x64\xa6\xdb\x05\x9d\xfb\x8c\x7a\x3f\xfe\xf5\x2b\xfb\xcc\x6a\x0d\xe9\x30\xdc\xf4\x27\x6a\x34\xdc\x63\xde\x87\xbf\xb7\x1f\x37\x1f\x78\x85\xb9\xf9\xec\x91\xf4\x34\x9f\x03\xba\x23\xbd\xc7\x98\x5e\xda\x38\xfe\x89\x69\xec\x59\x42\xe3\x43\xe5\x38\x2f\x08\xa2\xdd\xa5\x39\x6d\xed\xac\xdb\xc3\x22\xd1\x89\xc9\x88\xa7\x9c\xb4\x60\xb7\x62\xae\xe8\xe2\xac\xee\xb4\xb7\xde\x9f\xed\xb5\xcf\x74\x37\x8b\xec\xe3\x59\xbc\x1b\x98\x7b\xf6\x99\xe1\x1d\xf3\xbe\x63\x57\xa8\xd1\x3f\x74\x76\x75\x05\xdc\xa5\x53\xfe\x59\x27\xf3\xdc\xd9\x8d\x99\x5e\xba\x74\x7b\xf5\xea\x8e\xef\xd9\x07\x30\xbf\xb6\xa1\x1c\x54\x22\xfb\xf0\x9a\x06\x9d\xc1\x48\xd4\x8b\xd9\x97\x97\xb1\x63\x2a\xb0\xbb\xe6\x46\x89\x12\xd2\xcd\xa7\xad\x3b\x32\x32\x7e\xec\xbc\x7c\xc3\xfb\xc5\x10\xdf\x07\x73\xe4\xf0\xce\xfb\xfe\xf3\xd0\x3b\x3b\xee\x6b\xdf\xda\xfe\xf6\xc3\x6a\xc7\x9d\x6f\xc3\xb8\x2f\x1e\x06\xb8\xf3\x1d\xf5\x31\x5a\x7e\xfb\xf4\xbb\xea\x6d\x07\x7f\x7f\xea\x1d\xb8\xbe\x7d\xda\xca\x5f\x36\xfc\x13\x56\x7e\xb0\xf2\xe7\x8d\x3f\xa8\xf3\x8f\x60\x1d\x49\x93\xd3\x7b\xf1\x7c\x71\x78\xe5\x4f\xcb\x8f\x4a\xa2\x68\xe7\x78\x93\x49\x10\xec\x94\xc7\xee\x09\x04\x39\x1e\xeb\x21\x1c\x88\x5c\x94\x6b\xe4\x5a\x38\x6c\x43\x73\xb2\x2b\x50\xcf\x71\x56\x87\x03\x4f\xa6\x03\xab\x4e\x0e\x63\x3a\xad\x4e\x29\x08\x28\x88\x05\x74\x10\x8e\x07\xe1\x68\x10\x0e\x06\x61\x5f\x10\xda\x82\xb0\x2e\x08\xcb\x82\x30\x37\x08\xad\x41\x68\x0a\x82\x1c\x84\xf2\x20\xe4\x06\x41\x6f\xf0\x7f\x85\xff\xbf\x08\xe8\xb4\x6c\xc3\xbb\x26\xcb\xac\x4f\x4b\x65\x6d\x6e\x73\x1d\x44\x93\xce\xda\xfb\xba\x0f\x94\x9a\x02\x2b\xee\xbe\x67\xfd\x5c\xa9\x31\x23\x9a\xa9\xc0\x9f\xbf\xc5\xc6\xe9\x29\x6a\x1a\x5c\x75\xd7\xca\xf6\x5b\xc7\xa9\x03\xd3\x6b\xfc\xcc\x3e\xad\x2c\x15\x85\xe6\xa9\xfb\xd9\x87\xf1\x1a\x87\x51\x31\xa6\xc0\x82\x7c\x47\x4e\x4e\xc0\x8a\x35\x50\x3e\x59\x12\x28\xc4\x73\x14\x70\x79\x34\xfd\xc6\x83\xf5\x1b\x0f\x93\x8b\xb5\x1a\x66\x6e\x89\xb1\xe4\x44\x14\x1b\xba\x9b\x11\x83\xa4\xab\xfd\xae\xac\xc5\xe6\x22\x54\x4a\x3b\x59\xc4\x76\x61\x19\xf4\xa4\xba\x52\xc6\xbc\xf4\xc2\xdf\xd9\x81\x76\x5d\x3e\x7c\x64\xc5\x65\xd6\xc0\xf2\xb2\xa9\xb7\x5f\x11\x69\x6b\x5f\xc3\x4c\xeb\x24\x13\x8a\x32\xa8\xe0\xf7\xea\xb6\xaf\x8a\x6e\x1c\x1e\x67\x06\x9a\x43\xd3\xb7\x96\xc3\xea\x7f\xc3\xa7\x59\x04\x43\xe8\x96\xd0\xc8\xeb\x98\x46\xdc\x78\x54\x0b\x64\x39\x8c\x42\x21\x4d\x8d\x13\x25\xc9\xef\xb7\x99\x6c\x39\x11\x31\xac\xdd\xc2\x84\x12\x8e\x86\xeb\xc2\x8d\x61\xc6\x43\x87\xc3\x8c\x20\x84\x5a\x15\x5d\x83\x93\x34\x15\x0e\xeb\x7b\x8c\x73\x6e\x04\x26\x76\x72\xe8\x64\xb6\x9b\x12\xa5\x9c\x7d\xba\x30\xb4\x54\xc6\x71\x9e\xbd\x34\x12\xab\x19\x75\x74\xa1\x66\x02\x61\xb5\x1c\x5e\x1e\xf7\x8c\xb9\xfd\x5b\x7d\x7d\xdc\x9f\x7d\xa5\x6e\xfb\xfb\xbd\x66\xf5\xbd\x5f\x12\xcf\xbd\xa5\xfe\x6d\xfd\x55\xd4\x70\x95\x49\xaf\xd1\x8e\xad\xea\xa1\x51\xed\xdf\x60\x56\x3d\x7c\xdc\x93\x5b\xff\xd9\xfe\x26\x96\x89\x7e\xc3\x17\x59\x8a\x2e\x93\x4b\x80\x2f\x8c\x3a\x0a\x1d\xa5\x7e\x6f\xa9\xb7\x67\x59\x94\x77\x17\x17\x63\x51\xac\xbd\xf8\x9d\x44\x93\x15\xbb\xdc\x61\xfc\xd3\x07\x3e\x9f\x9b\xc9\xf8\xd2\x53\xe7\x39\x59\x0d\xda\x4a\xc7\x8e\x11\x77\x74\x4f\x13\xf1\x83\x68\xb1\x63\x9a\x99\xa3\x99\xf2\xbe\x08\x8d\xe9\x0c\x2f\x64\xe1\xf0\x01\x10\xdb\xaa\x6c\x7f\xaa\xbc\xe9\xaa\x19\x57\x35\x95\xff\xeb\xcb\xdd\x0f\xf6\x1a\xc0\xe6\xce\x6f\xb8\x75\xdd\x38\x65\xd5\xef\x46\xf6\x52\xff\xad\xde\xf4\xce\x40\x58\xf0\x5a\xc5\xe0\x4d\x6b\x7a\x37\xc9\xbd\xab\xeb\x2e\xbb\xe6\x92\xa7\x5f\x29\x50\x4f\xee\x0a\xe6\xdf\x72\x6d\xdd\xb4\xd2\xa1\x0d\xa3\xae\x19\xf2\xa7\xbf\xa6\x8a\x75\x59\x7f\x1b\x5e\xb3\xef\x09\x1f\x6c\x96\x8b\xad\x66\xb3\x84\x6d\x6c\x8e\xe7\x69\x8a\x72\x7b\x30\x3d\xce\xc5\x92\x17\x5b\xa8\x82\x44\x0b\xd8\x0c\xc2\xa6\x0a\xd1\x9c\x90\xb3\x8b\xaa\xa1\xab\xb6\xa9\x2c\x3f\xa2\xc1\x12\x53\x78\x31\xe2\x79\xda\x49\x4c\xda\x76\xf0\x71\xfb\xcc\xff\x73\x24\xf5\x87\x16\xf9\xe2\x1a\xa6\x67\xcd\x20\xf3\xb8\xf7\x7a\x1d\x79\xdf\x8c\xe7\xfd\x01\xf7\xfb\xd0\x57\x7d\xeb\x7d\xe7\xd9\x99\x9a\x06\xa4\xf5\xed\xe5\x8e\xef\x4d\xbd\xc9\x79\xc6\x30\x39\xe1\x74\xbb\x7d\x3e\x2b\xe6\x3b\xd6\x30\x66\xd4\x34\x6b\xd5\xe2\x30\x31\xab\xd6\xb8\x0b\x85\x59\x4b\x00\x77\xcf\x95\xf1\x00\x67\x09\xf3\x54\xaa\xab\xe0\x33\xf8\xb4\xe6\x48\xc1\xec\x31\xad\xa0\x9a\x3c\x52\x4c\x73\x8c\xb8\xf6\x6a\x61\x21\x4f\xad\xed\xa1\xbe\xf7\xfd\xc9\xd3\xe6\xbb\xb0\xda\xe2\xc7\x3f\xcd\x50\xf2\xda\x3f\x73\x0c\x75\xe5\xd8\x3f\xce\xbd\xf2\x4c\x75\x05\x5d\x44\x7e\x7d\xd6\xbb\x5c\xfd\xcf\xab\xbb\x70\x7f\x67\x76\x7c\x49\xec\x48\x3b\xba\x47\x9e\x48\x33\x8c\xc5\xc2\x52\xac\x28\x59\x29\x4a\xb2\x9a\x29\x96\xc3\x34\x62\xe7\xb0\x3e\xca\xb8\xb0\x7d\x83\x24\xcc\x00\x25\x38\x2e\xc1\x51\x09\x0e\x4a\xb0\x4f\x82\x36\x09\xd6\x49\xb0\x4c\x82\xb9\x12\xb4\x4a\xd0\xa4\x9d\x96\x75\x5e\x91\x25\xc8\x25\x57\xf0\xdf\xee\x27\xe6\x69\x66\xa6\x45\x6f\x1a\x83\x4f\x9f\x29\x38\x3b\x95\x17\x88\xeb\x63\x77\x69\x1a\xcb\x4e\xf3\xf2\xf6\xa2\x94\xfa\x3f\x4b\xcd\xf0\x83\xf9\xf1\xbf\x50\x81\x07\x2d\x9a\x8e\x72\xe6\xdf\xac\x8d\x0c\xab\x94\xfe\x30\x68\xac\xc3\xca\x8e\x2f\xb9\xc1\xda\xbe\xd6\x62\x06\xb5\x71\x59\x6d\x36\xcd\x83\x68\xb7\x63\x11\xcf\x8a\xd8\x68\x63\x59\xcc\x74\x44\x33\x19\xa2\xcd\x6a\xb7\x68\xc7\x5f\x0e\x4e\x8b\x72\x61\x5c\x53\xbc\xd0\xe4\x85\x41\x5e\xa8\xf4\x82\xdb\x0b\xc8\x0b\xa7\xbd\x70\xdc\x0b\x1f\x79\xe1\x90\x17\xf6\x7b\x61\xbb\x17\xd6\x7b\x61\x85\x17\xe6\x7a\x01\x03\xcb\x04\x32\xdf\x0b\x8c\x17\x66\x60\xd0\x13\x5e\x38\x9a\x06\x6d\x23\xa0\xcb\xbc\xb0\x90\x80\x8e\x22\xa0\xb9\x04\x2f\x43\xf0\x9e\x48\x43\xea\x18\x75\x98\x41\x59\x77\xb7\x93\xeb\x0b\xb3\x1e\xa3\xb7\xad\x3d\xbf\x31\x06\x1a\x9f\x05\xa1\x03\xc8\x17\x77\xeb\x8c\xde\xef\xd6\x74\x67\x30\xb8\x44\x06\x49\x1d\xf4\xc2\x3e\x2f\xac\x23\xf7\x9a\xc8\xf3\x70\x47\xa3\x5e\x10\xbd\x9d\xc1\xce\x2d\xbf\x2d\xa1\xce\x0f\x22\x39\x5f\x82\x5d\x30\x0a\xcb\x08\xe2\x25\x87\x37\x9d\x1b\xc1\xa1\x29\x53\x59\x01\x83\x86\xd9\x86\xf9\x62\x9c\x36\x88\x22\xe5\xd2\xc9\x83\x99\x53\x77\x8f\x3a\x69\xc0\x9b\xf3\x04\xf8\x50\x78\xf8\x0e\x78\xa2\xe7\x03\xf0\xc8\xa3\x02\xdc\x2e\x5c\x17\xa5\x6f\x39\x77\x93\x41\x20\x63\xe9\x0d\xe7\xae\xa2\x9f\x20\xaa\x21\x68\xef\x9f\x63\x13\xc4\x2e\x9b\x2e\x57\x7a\x30\xa9\xb8\xed\x9c\x68\x32\x61\xaa\xb3\x79\x43\xa1\x1c\xde\x66\x0b\xe7\x84\xbc\x6e\xb2\x5d\x3d\x88\xb3\x23\xbb\xc5\xef\xc0\xca\x21\xd8\x2c\x36\x2c\xdd\x2c\xce\x6c\x8f\x9d\xc1\x18\xb3\x7b\xef\xc8\xb2\x90\xb1\x6e\xa8\xf3\x7b\xc3\x6b\xa7\xab\x87\x40\x67\x88\x5b\x0b\x0b\xfb\xe9\xa7\xf5\xe6\xf6\x0e\xf3\xf6\xbd\xea\x82\x6d\x66\x75\x98\xf9\x01\x38\xfe\xde\xbd\x1a\xad\xaf\xbb\x03\xea\x56\x98\x61\x83\xf9\x41\xea\x9f\xed\x2d\xc4\x93\x77\x56\x65\x89\xf5\x35\x89\x92\xb5\xe1\xa8\x57\xc3\x06\x5d\xe3\x05\x74\x2d\x1e\x57\x11\xa1\xfd\xbb\xe5\x0e\xd1\x6e\x77\xb9\xc9\xd9\x3e\xe7\x72\x79\xcd\x9a\x7b\xd2\xe3\x75\xd9\xb5\x28\xc5\x16\xc5\xe4\xb6\xd1\xb4\x24\xa4\xed\x32\xf7\x52\x2f\xcc\xf4\x42\x5f\x2f\x24\xbd\x60\xf1\xc2\x59\x2f\xfc\xe4\x85\x77\xbd\xb0\xcb\x0b\x9b\xbc\xb0\x84\xdc\xc5\xf4\x35\x8c\xc0\x60\x80\xe9\x67\xc9\xed\x97\x08\xc4\x1a\x02\x81\x6f\x84\x48\xcb\xef\xc8\x2d\xfd\xa2\xde\xa6\x2e\x7d\x5d\xdf\x46\xfb\xce\xdb\x46\x98\xe8\xcb\xb3\xf6\x46\x1f\x7d\xd3\x51\x47\xd3\x54\x39\x37\x8b\x30\x75\x40\x4c\xb4\xa7\x08\x90\x0e\xb0\xec\x3c\x18\xd9\x83\x41\x8e\x79\x41\xa7\xec\x36\x72\xbf\x3c\x4d\xcd\x17\xa4\xe2\x96\xf3\x68\x74\x62\x77\xa0\x49\xdd\xef\x65\xcc\xca\x2e\x56\x59\xc6\x02\xcf\x8a\xe8\x37\x6c\xda\x2e\xeb\x0e\xd4\x15\xef\x9b\xdb\xef\x33\xff\xcf\x88\xaf\xee\x35\x53\x71\xf3\x1b\x2f\xc3\x6a\xac\x83\xef\x37\x3f\xa0\xf6\x20\x86\x2e\xbc\x48\x9d\x20\x76\xd7\x5a\x6a\x01\xf9\xcc\x23\x3c\x2e\x80\xe5\xe0\x0a\xbc\xce\x4e\xd4\x57\x8e\x08\x4e\x27\x2b\xd2\x2e\xc4\x71\x6e\xa7\xe0\xc0\xd6\x8c\xdd\xee\x70\xf2\x48\x33\xb0\x58\x8e\x36\x28\x55\x37\x7c\x91\xce\x69\xd3\x91\x89\x86\xb4\xe3\x80\xf8\x3e\xb0\x79\x55\x4d\xaf\x79\xfb\xd7\x96\x41\x83\x6b\xe8\xe9\xd2\xb9\x07\x4e\x2d\xfe\x7f\x25\xd3\x86\x4c\x3c\x97\x72\x30\x5f\xbb\x3f\x84\x7e\xa3\xcf\xce\xf2\x99\x01\xa9\x6b\x26\x69\x7d\x58\xa4\xfe\x48\x4f\x67\xd7\x22\x0e\x06\xca\x27\x18\x96\x45\x26\x8a\xd2\xde\x26\xc2\x03\xf3\xb3\xa2\x05\x0c\xfe\xac\xa0\x5f\xb3\xf3\x3b\x3a\x04\xf8\x2e\x9d\xc6\x91\x49\xd1\xd0\x01\xa2\x04\xe0\x1a\xea\x98\x00\x47\xce\xcb\xb7\x28\x4b\xdf\x3f\x2e\xc0\x31\x92\xa5\x71\x17\x81\x69\xc9\xba\x8b\x48\x0e\x87\xde\xfc\xb5\x74\x02\x49\x5d\xba\x61\xdf\x0e\x72\xa9\x25\x9d\xbe\x81\xaf\x1e\x15\x60\x59\xd6\x93\xca\xd3\x58\x3a\xc8\x63\xf0\xdd\x7d\xe9\x67\x94\x93\x26\xe8\xfc\xa4\x8f\xee\x89\x35\x17\xe4\x7c\x2d\xdd\x29\xa6\xfb\x19\xaa\x71\x26\x08\x31\x8e\x05\x96\x5b\x04\x49\x78\x9b\x57\x8f\xa8\xa7\x21\x8f\x57\x7f\x34\x6d\x2d\x2b\x3a\xe3\x28\xd2\x5e\x6d\x8b\xb6\x74\x7c\x0f\x9f\xa4\xe3\x8d\xb4\xd7\x8a\x51\x5a\x4c\xa6\x17\x31\x5a\xbc\x51\xd6\xe9\x62\xca\x15\xdf\x32\xf9\x93\xab\xd8\x21\x67\x76\x10\x1b\xf8\x88\xfa\x23\xf5\x3a\x59\xa7\xe3\x72\x07\x67\xc2\xca\x08\xd6\x7e\x69\x5a\x4b\xd1\xf9\x59\xe1\x7e\x35\xd1\x3f\x2b\x26\x84\x57\xa2\x9f\x00\xa5\x02\x84\x05\xb0\x0a\x70\x4e\x80\x1f\x04\xf8\x2b\xc9\x98\x79\x59\x80\xdd\x24\xad\x66\x8d\x00\x37\xe0\x45\x12\x60\x82\x00\xc3\x05\xb8\x88\xac\x9c\x0e\x7f\xcd\x99\xf4\xda\xbe\x27\xc0\x8b\x02\x3c\x41\x1a\xdc\x81\xa7\xad\xdb\x5a\x96\x92\x79\xb6\x91\x79\xfe\x81\x34\x38\x2c\xc0\x2b\x64\x51\x1f\x22\x19\x41\x18\x7e\x16\xa1\x8d\x4b\xb3\x56\x17\xc3\xb7\x13\xf8\x63\x04\x1e\xd3\xcf\x93\x04\x5e\x5b\xe4\x0c\x25\xe1\xce\x58\x70\xaf\x70\x37\x3e\x12\xe0\x50\x56\x3a\xd0\x9a\xce\x54\x22\x59\xe9\x42\x73\x16\xd2\x6b\x9d\x6a\x32\xb9\x45\xd4\x5d\xbf\x4d\x81\x1d\x9a\xef\xaf\x93\xc6\x96\xa6\x61\xca\x2e\x40\x1d\xe9\x50\xcb\x0b\x4b\xc1\x96\xf3\x68\xa6\x2b\xf4\x85\x13\x8a\xb2\xd9\xce\x05\xa8\x88\xae\x4e\x40\x02\x1b\xf2\xbd\x78\x28\x03\xab\x7a\x8c\x87\xb7\xd5\x8f\xd5\x1f\xcb\x8a\xd8\x9f\x8a\xca\xfe\x73\x85\xae\x1f\xd5\xc3\xad\xf4\xfb\x98\x77\x98\x50\x52\x76\x61\x95\x87\xa1\x58\x93\x89\xe7\xb0\x0e\xcd\x53\x26\x06\xed\xd4\x13\x92\xb2\x82\x3c\xf4\x48\xbf\x14\xc4\x05\xac\x92\x9d\xee\x05\xbb\xaf\x56\xb7\xa9\xdb\xa6\xb2\xfd\xce\xd5\x6b\xc7\xb7\x1a\x8d\x9d\x52\x7f\x65\xa4\x8e\x49\x98\x36\x3d\xb2\x40\xb1\xda\xfb\x55\x5f\xc4\x3c\x00\x73\x1c\xd0\x3b\x56\x15\xf3\x48\x4c\xae\xfa\xeb\x54\x2d\x20\x10\xa0\x8c\x99\x44\x6d\x61\xef\x42\x2c\x1c\x96\x3b\x18\xcd\xec\x42\xf4\xfa\xf1\x02\xe6\x6b\x8f\xa3\x77\x10\x23\xa0\x25\x1c\xcc\xe4\x60\x3c\x07\xc3\x38\xe8\xc7\x41\x29\x07\x01\x0e\x2c\x1c\x9c\xe5\xe0\x3b\x0e\x3e\xe7\xe0\x5d\x0e\x5e\xe2\xe0\x49\x0e\x36\x71\xb0\x86\x83\x1b\x09\xbc\x42\xe0\xfb\x72\x90\xe4\x20\x87\x03\xad\xc1\x74\xdc\xe2\x27\x0e\x8e\x71\x70\x84\x83\xd7\x38\xd8\xcb\xc1\x56\x0e\xee\xe2\x60\x29\x07\x73\x38\x68\x49\xb7\x28\xe3\x20\xaa\x39\x04\x8c\x27\x7c\x76\x1e\xfc\x92\xae\xf0\xf8\x09\x21\x02\xdf\x41\x80\xf5\xee\xec\x4a\x77\x27\xd3\xfd\x46\x02\x1c\x22\x7d\xef\xa3\xa3\xc6\x70\xdb\x39\x58\xcf\xc1\x42\x0e\x5a\x39\x18\x25\x8f\xe4\x60\x10\x07\x95\x1c\x48\x1c\xe0\x5d\x4a\x9d\xc2\x3b\x95\x83\xa3\x1c\x1c\xe4\x60\x1f\x07\x6d\x1c\xac\xe3\x60\x19\x07\x73\x09\x7c\x13\x07\x32\x81\xd3\xc1\xb2\x01\x9a\xd2\x63\xb8\x00\x47\x9a\xd7\x2d\x59\xf0\xff\x1c\x12\xdf\xf2\x1b\x92\x11\x95\x4d\x9a\x98\x09\x9a\x14\xa0\x3a\xe5\xe2\xa8\xc9\xea\x61\xd3\xbb\x5b\x58\x66\x12\x58\x13\xea\xa9\x98\xee\x27\xea\xd7\xf1\x1d\xfd\x0c\x7d\x08\x39\x50\x04\x0d\x95\xf3\x03\x42\x84\xa1\xb1\xf9\xe9\x74\x08\x8e\x68\xae\x24\xd9\x3c\x4d\x8a\x4d\x62\xc2\xa6\x70\xb3\x62\xf2\xd2\xa8\x51\xa1\x3d\x69\x2a\x27\xb6\x1b\xfe\x76\x9e\x17\x4b\x93\xa9\xd5\xfa\x71\x3c\x71\xe7\x57\xa7\x38\x62\x87\xea\xae\x83\x6a\xda\x33\x8f\x57\xff\x9e\xf3\xf8\x1d\xd7\xdd\xbb\x01\xd0\xfd\xd7\xcd\x2c\xed\xfd\x52\xe1\xa0\x8a\x29\x8f\xb5\x8e\x1d\x3e\xef\xb6\x21\x81\xd2\xcd\x4f\x3d\xbd\x79\x2f\xf4\xda\x55\x9c\xb7\x38\xe4\x79\xa0\x03\xad\x99\xb9\x6c\x8d\xd6\xd7\xe1\xd8\x7e\x7e\x03\xf3\x4c\x17\xca\x45\xe3\xe4\x54\xae\x89\x76\x6b\x31\xca\xc8\x15\xb4\xba\xac\xb1\x3c\xc9\xdb\xa4\x48\x5e\x53\x8e\x90\xd3\xac\x60\x63\x53\xeb\x2b\x6a\xca\x03\x39\x0f\xca\xf3\x40\xca\x03\x94\x07\x5d\x76\xa9\x6e\x7b\x76\xf5\x6a\xa6\x0c\xe3\x8e\x36\x71\x46\x94\x17\x45\xac\xe6\x6a\xe3\x30\x5c\xf3\x80\x70\xd0\xeb\x56\x1e\x4a\x1a\x1c\xde\xa6\xc7\x87\xde\x78\xff\x7d\xea\x99\x4d\x63\x1f\xaf\xdb\x5d\x7b\xf5\xd4\x27\xaf\x9c\x38\xa2\xef\xea\xfe\x6c\xbd\xbf\x54\x1d\x3a\xbf\xb1\xb9\xf5\x99\x4d\xbb\xd5\x23\x7b\x4a\x0b\x93\xe5\x0f\xa0\x8e\x3b\xe6\x2e\x19\xd1\x4f\xdb\xeb\x75\x78\x1c\x8b\xe9\xb7\x50\x10\x8f\xa2\xc6\x6b\x42\x36\x93\x2d\x14\x36\x3b\x9b\x94\x35\xe2\x26\xf1\x3b\xf1\xac\xc8\x20\x11\x04\x51\x34\x4b\x62\x30\x1a\x2c\xd3\x4f\x39\x69\xda\x3f\x52\xa1\xbd\x6d\x61\x38\x1a\x86\x65\x61\x4c\x4d\xf3\x2e\x7c\xe2\x69\x48\x9c\x84\x71\x9e\xaf\xad\x80\x9e\x46\x46\xf2\x75\x24\x6d\x01\x4c\x23\xff\x38\xfe\xe1\x7d\x77\x00\x7d\xe7\xd0\xb6\xca\xd2\x6a\xa9\x6e\x7a\xeb\x63\x53\xfe\x74\xd7\xa6\x3b\x87\x8d\x79\x71\xfb\x1e\x88\xee\x89\x78\xd5\x33\x7b\xea\xee\x54\x1f\xec\x40\x53\x74\x3a\xe9\xdf\xf1\x1d\xd6\x26\xd6\x22\x37\xca\x43\xd3\xe4\xda\xb0\x28\xe6\xc7\xf3\x48\x50\xb2\xc9\xc4\x62\x2e\xc5\xb2\xf9\x2e\x7f\x93\xe2\x92\xcc\x51\x6b\xb4\x59\xb1\x7a\x05\x53\xa3\x22\x78\x18\xaa\x51\x61\xd0\x91\x7c\x78\x2d\x1f\xf6\xe6\x43\x5d\x3e\x64\xad\x40\xd6\x2a\x40\x2a\x7b\x0d\x32\x47\x58\xbd\xc9\xe9\x55\x37\x72\xca\xa2\xa5\xde\xd5\xb4\xc8\xc8\x1b\x79\x18\x74\xca\xa0\xa9\x25\xeb\xee\x05\xb4\x61\x52\x79\xbc\xa1\x6a\xd2\xf6\x29\x63\x87\xd5\x2c\xef\x47\x3f\x59\x0e\x33\xfd\xa5\x67\x5e\xd0\x28\xeb\x85\x0d\xbb\xa0\x74\xef\x52\x5f\x70\xbd\x7a\x0e\xd3\xd5\x25\x03\xf1\xd8\xb4\xf5\x68\xc1\xeb\xe1\x43\x31\xed\xa4\xc4\x8f\xed\xce\x90\x05\xef\x88\xbc\x38\xed\xc7\x44\x44\xdb\x3d\x9e\x48\x93\xe2\x91\xcc\x76\x3b\x37\x52\xb1\x7b\x8f\xc6\x21\xeb\x9c\x24\x13\x28\x96\x7d\x88\xeb\x66\x58\x4e\xef\xa0\x2f\xbd\x0e\x24\x32\xc5\x88\x2c\xb5\x03\xdd\xa2\xee\x53\xff\xc1\xcc\x9c\x3e\xee\xc1\x81\x39\x13\x0e\x4f\xd8\xb6\x77\xed\x99\xd5\x4b\xee\x6b\x7f\xe8\xf7\x3f\xf6\xab\x1d\xb2\xa2\x95\xfa\x75\xd5\x41\xd7\x25\x4b\x6f\xee\x57\x58\x3c\x62\xd4\xb3\x8f\x3f\x06\xb1\x67\xe6\xa9\xab\xc4\xcd\xf3\x6a\xea\xe7\x1f\xc4\x34\xe4\x53\x87\xd3\x09\x76\x1b\xee\xf3\xf5\x72\x81\xc7\x62\xf1\x61\x9b\x82\xa5\x00\x02\x7e\xca\xe7\xf6\x35\x29\xac\x5b\x14\xa4\x26\xa5\xdc\x26\xdb\x9a\x6c\x47\x6d\xc7\x6d\xac\x4d\x73\xf3\xe7\x47\x62\xf5\x36\x2c\xb8\x51\x68\x6b\x00\xc4\x00\x74\x90\xff\x8e\x05\x60\x69\x00\xe6\x04\xa0\x85\x1c\x50\x1a\xac\x44\xcb\xe5\xd4\xf4\xd3\x89\x19\x7f\x48\x56\x94\x39\x71\xab\xbb\xe2\xae\x78\x1d\xa5\x6d\x14\x23\x36\xd2\x24\x42\x8a\x8b\xbf\xb2\xe3\xcb\x6d\xfc\x13\xd6\x1e\xaf\x3c\x7c\x69\xff\x78\x2f\x57\x4e\x75\xbf\x21\x91\x9c\xf7\xed\xef\xab\xc3\x59\x6b\xaf\xc2\x81\xc7\xde\x77\x1d\x9a\xef\x99\xfe\xf0\xe6\x51\x78\xee\x01\x8f\xe3\x10\xe6\x3f\x22\x2a\x41\x23\xe4\xa2\x7c\x9b\xb7\x44\xa2\x19\x26\x92\xe3\xcd\x29\xed\x19\x2b\x1a\xa9\x40\x02\x2c\x74\x22\x11\x0b\x05\x85\x26\x25\x28\x49\x9a\x97\x49\x71\x79\x51\x16\x03\x4a\x7b\xc5\xd2\x2b\x60\x84\xc1\x27\x34\xf5\xb9\x27\x6d\xa4\xa9\x75\xdb\x0f\xe4\x97\x76\xb4\xa4\x27\xf7\x6c\xab\x59\x3d\x60\xb6\xbf\x20\x51\x1c\x9a\xb2\x7b\xb2\x02\x83\xeb\x9f\x1a\xba\xf4\x9e\x0d\xc0\x6e\xb8\xe8\xf5\x61\x3b\x13\x9f\x7e\x30\xf6\xe5\x3e\xce\xd2\xfc\x91\x0f\x5e\xbf\xce\x3f\xad\x61\x00\x35\xc3\x64\x36\xd1\xf7\xab\x77\x5d\xb3\xb4\xa6\x71\xea\x33\x9b\xf6\x62\x92\xf2\x39\xcf\x0d\xfc\xf0\xd5\xa2\xc8\x89\x9b\x1a\x97\xde\xa1\xcb\xf4\x06\x84\xe8\x5d\x78\xcf\x84\xd1\x48\xb9\x28\xc8\xd2\xa1\x50\x18\x73\xab\xb0\xc3\xed\xb6\x5b\x2c\x91\x70\x4e\xd8\xe3\xb0\x37\x2a\x0e\x0f\xeb\xe3\x7d\xcd\x0a\x6f\xb0\xac\xf3\xd8\x2b\xa4\xb2\x2c\x96\x2e\x4c\x2a\xcd\xa3\x4c\xda\x16\x71\x19\x11\x94\x1c\x1d\x87\xea\x45\x3c\xe4\xce\x90\x9a\x9e\x1f\x7b\xd5\x54\x7e\xfa\x72\x5e\xfd\x70\xaa\xaf\xbc\x72\xd8\x9e\x9a\x39\x8f\x6a\xcc\xa9\x7d\xf7\xf0\xe9\x73\x66\x4d\xb5\xd7\xb6\x6f\xf2\x97\x52\x43\x96\x16\x96\xd6\xdc\x38\xbe\x7d\xa5\xb6\xcf\xb5\x44\xa3\xb3\xec\x70\x6c\xa7\xb8\x50\x83\x5c\xcc\xdb\xed\x34\x87\xcd\x1a\x9a\x76\x7b\x1c\x96\xcb\x14\x07\x63\x62\x1a\x15\x93\xa8\x4b\x82\x32\x0f\x44\x3d\x20\x7a\x60\xab\x07\x26\x76\xdb\xd7\x5d\x75\x20\x4d\x24\x90\xb3\x97\xec\x30\xad\xfc\x87\x78\xf5\x85\x0d\x37\xf3\x90\xec\x2f\x97\x96\xc8\x72\x49\xa9\x8c\xb9\x3f\x3d\x35\x50\x0a\x29\xfd\xa7\x4c\x7c\xc2\x09\x75\x38\xc5\xe1\x3e\x39\x50\x0e\x5a\x25\x8f\x75\xfa\xfd\x66\xbb\x28\x5a\x28\xb3\x39\x12\x0d\x79\x2e\x53\x42\x8c\xcd\xd2\xa8\xd8\x44\xc4\x35\x29\xfd\xe9\x11\xf4\x24\x5a\x8b\xb3\x0b\x1d\x8f\xc2\xd1\x28\x1c\x8c\xc2\xbe\x28\xb4\x45\x61\x5d\x14\x96\x45\x61\x6e\x14\x5a\xa3\xd0\x14\x05\x39\x0a\xe5\x51\xc8\x8d\xc2\xd2\x28\xcc\x21\x3f\xbb\x0b\xdc\xce\x38\xf2\xec\xbc\x9b\x8c\x56\x97\x97\xa1\x1e\xc2\xa4\xb4\x68\xe0\xce\xb1\xf5\x1d\xd9\x18\x2b\x13\x43\x25\x03\x86\xf9\x9f\x58\xcd\x43\x6a\x4f\xfe\xe3\xf0\x7c\x7a\x90\xea\xf0\xc8\x4b\xb3\x43\xcb\x6e\xa7\x0f\x06\x4a\xcf\x95\xfe\xf1\x4d\xd3\xbd\xe9\xd1\x02\xea\x6b\xd0\x8c\x4b\xcb\x43\x66\x1c\x34\xed\x74\x22\x97\x64\x71\x59\xdc\x1e\xd6\x6c\x16\xad\x56\x8f\x68\x6d\x54\x44\xd1\xc1\x48\x16\x86\x73\x79\x9c\x9a\xc3\xac\x51\xe1\x44\xcc\x83\xf1\x9a\x50\xe8\x88\x07\x96\x7a\x60\x8e\x07\x5a\x3c\xd0\xe8\x81\x3a\x4f\x26\x9a\x29\x3b\x8c\xa0\x0e\x1b\x9b\x29\x43\x11\xcc\x9c\x4a\x67\x79\xc1\xb5\x11\x19\xc6\xb0\x0b\xef\x6d\x5a\x23\xaa\xe4\x4a\x1e\x7a\xed\x86\xdd\x93\x78\xc8\xe7\x47\xaa\x7f\xf9\xf7\x64\xfe\xfb\xbf\xac\xef\xbf\x43\xa3\xa8\x73\x35\xb0\x35\x54\x5a\xea\x53\xbf\x6e\xff\xd9\x57\x0a\xc7\xd6\xa8\xbb\xf5\x3d\x30\x0b\x2f\xa0\x55\xb3\x73\x50\xad\x9c\xcb\x32\x8c\x46\x4d\x34\xcd\x0b\x84\x8c\x10\xe9\xb2\x47\xb7\xf1\xb0\x0a\x3f\xf1\xbc\x44\x9d\xae\xd4\x03\x51\x8d\x62\x7e\xd0\x28\x06\x13\x8a\xf6\xdc\xf4\x3e\x63\xe7\x61\xfe\xdd\x13\x5d\x27\x0f\xf0\x22\x9f\x2f\xe4\xf7\x5b\xf3\xad\xa2\x28\x98\x8a\x7a\xe4\xc5\xe3\x89\x7c\x53\x7e\x79\x99\x5c\x0e\x62\x39\xe6\x25\x45\x91\x92\x48\xb3\x52\x22\x15\x26\x1a\x95\x42\x31\xdf\xe3\xf7\x58\x85\x46\xc5\xea\x41\x4e\xda\xd9\xac\xd0\x52\x36\x67\xa9\xcb\xec\x45\x20\xa1\x75\xce\x6c\x0e\xd3\xe9\x4a\xd0\xf6\xe3\x05\xb6\xa2\x1d\xf0\xb4\x75\xf9\x8e\xc7\xa0\xef\x59\x7a\xfa\xa0\xdd\x8d\xa3\xae\x10\xa6\x2e\x17\xd4\x0f\xaf\xf6\x15\x97\x96\x5c\x7f\xa5\xf9\xca\x1d\x53\x03\x25\x65\x25\xcb\x26\x0b\x57\xee\xd8\x80\x77\xb0\x37\x3c\x64\xcf\xa5\x63\xaf\xa0\xbe\xbd\xe2\xfa\x99\x57\x79\x87\xb6\xef\x09\xe0\xcd\x7a\x5d\x69\x69\xf5\xa8\xe5\x7d\xda\x0f\x52\x43\x96\xc7\x4b\xab\x95\xa5\x35\xed\x07\xb5\x2d\xf3\xc6\x95\xbf\x9b\x63\xe4\x90\xec\xc2\x73\x11\x42\xc3\xe4\xc2\x00\x42\x5e\x97\xcd\x6a\xe2\x38\x81\x77\xf1\x39\xe1\x80\xb7\x51\x09\x78\x6c\x26\x5a\xa2\x9b\x15\x49\x22\xe3\x16\x39\xac\xd0\x65\x86\x99\xa5\x12\x75\x0e\x33\x7d\x28\xd8\x65\x04\x99\xa1\x52\xff\x2e\xaf\x6c\xd8\xdb\x67\xb6\xde\xe5\xd0\xa8\xfd\x63\x3a\x79\x0e\xf5\x7d\x69\xcd\x4d\x13\xdb\x6f\xa7\xaf\x0e\x94\x1e\xbc\xe6\x9a\x2c\x96\xa3\xeb\x9e\xdf\xd3\x6f\xe2\xbe\xda\x70\x6f\x4b\x64\x1f\x72\x70\x7e\x87\x3f\x9c\xe3\x31\x6b\xc2\xd6\x4e\x37\x61\x51\xdb\x96\x73\xa1\x33\x4a\x97\x9e\x75\x6c\x4c\xac\x2b\x23\x5e\xb1\xb6\x66\xfa\x61\xfa\xa4\xf1\x8f\xb6\x4e\x9f\x3c\xfe\x91\x49\xaf\xee\x78\xfb\xf6\x9f\x37\x68\x7f\x60\xd4\xca\xbb\xee\x69\xbf\xfb\x76\xfc\x47\x65\x3e\x7e\xf6\x61\x70\x6e\xc6\x7f\xd5\x1f\x37\x13\xfe\xb2\x0a\xcb\xa0\x37\x88\xfc\xcf\x47\x4d\x72\x71\xbe\x5f\x2b\xa4\xce\x73\x11\x07\xe7\x48\x14\x78\x82\xb8\x37\x5e\x6b\xcc\x1e\x6b\x56\xec\x92\x85\x6f\x54\x2c\x22\xe6\x46\x5c\xa3\xc2\x86\xb2\x49\xa5\xbb\x3e\xa9\x2b\x32\xbd\xca\xab\xb3\x0e\xfb\xb8\xde\x59\x2a\x65\xb6\x46\x79\xd2\x52\xde\xc6\xab\x03\xf9\xeb\x3e\xbb\x9a\x07\xc1\xb5\x17\xab\xc6\xf7\xab\xea\x03\x3d\xaf\x84\xfe\x33\xae\x7c\x78\xb2\x32\xac\x6a\x5d\x0d\x35\x4e\xfd\xce\x5f\x56\xe6\x67\x3e\x0c\x94\x3e\x88\x35\xe4\x7d\xea\xfb\xbb\x6d\xf3\xcb\xef\x01\x6e\xf5\x9c\x1b\xb0\x62\x49\xa1\x41\x78\x1c\x47\xf1\x38\xac\x58\x3f\x1e\x24\xc7\xa3\x74\x24\x12\x0e\x85\x98\xa0\xd9\x15\x74\xe5\xc5\x22\xa1\x46\x25\x12\xf2\x99\x9a\x14\x1f\x96\x34\x12\x96\xa2\x92\xb7\xeb\x00\xb2\xbb\xde\x29\x41\xd3\x79\xde\xb1\xae\x02\x94\xac\x3d\x3c\x52\xbf\xa6\xec\xba\xa9\x53\xaf\x7c\x78\xfc\x78\x18\x79\xe9\x13\x0d\xab\xef\x5e\x07\xec\xa3\x43\x0e\xd7\x9d\xbc\x8e\x57\x3f\x1f\x2c\xcd\xec\x11\xa5\x76\x85\xee\xee\xb8\x7b\xe1\xef\x6a\x07\x3f\xb1\xf3\x79\x48\x3e\x1a\x12\xcf\xfc\xea\x2f\x83\x1b\xc7\x90\xbd\x7b\x19\xa6\xd7\x38\xee\xb3\x03\x5b\x1f\x41\xd1\xce\x0b\x82\xc5\x6c\x76\x52\x2e\x9d\xa3\x9b\x3d\x22\x8b\xd8\x66\x85\x84\x28\x98\x05\x6b\x3d\xc3\x20\xa9\xc3\x45\x02\x6e\xf4\x28\x57\xbc\x47\x93\x9d\x12\x92\xec\x44\xa2\x8c\x64\x53\x2b\xf5\x51\x45\x4e\x49\xb2\xa0\x69\xd7\xd0\x99\x84\x48\x3d\xd1\x61\x2f\xd0\x6f\xf1\xbf\x2c\xbd\x7e\x4a\xfb\x83\xda\xde\xf9\x68\xde\x0d\xc4\x7f\xd7\xf1\x3d\x75\x0c\xf7\x25\x81\xe5\x75\x89\x0d\xe5\xba\x90\xcb\xcf\xb2\xfe\x82\x42\x5b\x2e\xed\xf5\xe6\x34\x29\x28\x00\x56\x26\x10\xf0\x4a\xb4\xa5\x49\x89\x99\xee\x36\x3d\x6c\xa2\x4d\x26\xda\xfb\xdb\xe7\x73\x9d\x47\xbf\x9a\x70\x48\x87\xb2\x68\x59\x87\x46\x8a\x71\x5a\x71\x22\x67\x74\x40\xed\x3f\xf8\xe6\xed\x77\x16\x95\x3a\x82\x2d\x17\x7d\x36\x71\xfa\x55\x93\x9f\xde\x32\x6f\x53\xa2\xcc\x5e\x77\x75\xf3\xe4\x51\xd7\x4e\x6b\x05\xf7\x03\x77\xf7\xff\xdb\xea\x70\xc9\x33\x7d\x27\xa4\x7a\x2d\x6e\x5a\x71\x77\xfc\xfd\x6b\x6a\x86\x35\xf6\x6e\xbe\xa8\xf7\x0d\x64\x3e\xc7\xe1\x31\x4c\x66\x6e\xc6\x36\xfb\xe5\x72\x4f\x93\xc7\xa3\xe9\x85\x0e\x11\xeb\x1b\xa1\xa0\x9d\x28\x86\x2e\x97\xc3\x2d\xb2\x2c\xcf\xd3\x23\x15\xde\x1b\x0d\x81\x18\x82\x9f\x42\xb0\x34\x04\x7a\x9a\xae\x21\x1f\x52\xa9\xb2\x6c\x8d\x2f\xa3\xf2\x25\x88\x09\xe7\x33\x24\x9d\xa6\xfe\xa5\x38\xad\x1e\x87\x09\xf8\xd2\xf8\x25\x8d\x9e\x25\x37\x35\x8e\xb7\x4c\x5b\xc2\xdf\xba\x5a\x4e\x7c\x2a\x7d\x7a\x85\x73\x4f\x69\x69\xa4\x6c\x4c\xeb\xe8\x9c\x46\xaa\xa1\xb4\xf0\xe3\x8f\x47\xb5\x7f\x36\x01\xf7\x73\x6a\xc7\x37\xf4\x73\xf4\x6e\xbc\xf3\x2f\x91\x0b\x0c\x16\x45\xd8\x15\xef\xca\x09\xfb\x31\x9f\xf2\x8b\x36\x9d\x4d\x79\x75\xf6\xcc\x89\x59\x6c\xaa\x0b\x97\xca\xac\x7c\xc2\x08\x17\x4b\x11\x8b\xc1\x20\x57\xdd\x84\x30\x81\x55\xd7\x7f\x34\x02\x50\xbf\x0d\x5d\xb6\x1f\x6b\x46\x96\xa9\x73\x78\x08\x4c\xf5\xbd\xae\xa9\x3f\xd4\xef\xce\x6d\x0c\x94\xbe\x3e\x73\xf6\xac\xa9\xe2\xa5\x54\x13\x56\x92\x5e\xba\x09\xf7\x33\x8c\x79\xd4\x5a\xdc\x4f\x27\x1a\x2d\x57\x22\xb3\xc5\x22\x49\x9c\x68\xe5\xac\x6e\x97\x68\xb7\x63\x49\xcc\xd8\x45\x59\x6a\x92\x28\xb7\x94\x2f\x55\x4a\xf4\x32\x09\x16\x4a\x20\x59\xbc\x4b\xdd\xd0\xe2\x86\x3a\x12\x4b\x8c\xc9\x43\x9b\xdb\xba\xec\x10\x15\x67\xfa\xd8\x16\xb4\x0c\xd4\x14\xe6\x0a\x9c\x7e\x8a\x12\x82\xde\xd4\x4f\xc5\x7e\xfe\xd5\xe0\x65\xaa\x72\xc9\x2b\xf3\xb0\x6c\xbc\xfb\x3f\x32\x5d\x98\x28\xe1\x4a\x7d\x3d\xc6\xae\x68\x1f\x4f\x5f\x1f\x28\x6d\xcf\x87\xfb\xa7\x69\xeb\xdd\xab\xe3\x7b\x76\x28\xee\x9f\x1f\xad\x94\xbd\xa2\x17\x90\xd5\x62\xa6\x18\x5a\xe0\x59\x56\xa0\xac\x5e\x36\x18\x08\x1e\xe8\x58\x26\xbb\xcb\x6b\xeb\xdd\x24\xa0\xe1\xa3\xe0\x89\xe0\xe9\x20\x7d\x30\x08\x41\x6d\x53\xd9\x72\x8b\xea\xa5\x20\x50\xf8\x4e\x84\x26\x57\xdc\xbe\x70\xbd\x55\xa0\xcc\x0c\x72\xf1\x3c\x56\x2d\x78\xac\xec\x61\x0a\xaf\x20\x13\x8f\xd5\x06\x48\x92\xc8\xc3\xa4\x36\xa4\x64\x3a\xb7\x3e\xd5\x59\xaf\x28\x7d\x1e\x94\x72\x41\x0a\x0f\xa6\x2a\x33\x3e\x7a\xc5\xc0\x1b\xd4\x37\x86\xec\x9a\xca\xff\xbc\x1c\xaa\x86\x5d\xff\x56\x1f\x7d\x98\x6e\x6a\x66\xfb\x7d\x64\x50\xfd\x28\xa5\xfd\x11\xb8\x75\xfe\x30\x7d\xb0\x83\x1e\xd4\xe3\x85\xbe\xc6\x3c\xe2\x26\x3c\xc6\x04\x9a\x20\x97\x8b\x39\xf6\x88\x3d\xcf\x1c\xb3\xc4\x22\x96\x88\xc9\x15\x0c\x16\x14\x22\x93\xa9\x20\xcf\x9c\x23\x32\xb6\x58\x2c\x82\xf5\xd2\x98\xc7\x67\xd3\xf9\xc7\x52\x3d\xf8\x59\xf7\xb4\x1b\xc5\x01\xb2\x7c\x68\xc6\x51\x90\x11\x8b\x57\xed\xc6\x9b\x51\xa3\x98\xea\x04\xe9\x3e\xc9\x32\x30\x3a\x2f\x92\x73\x22\x9a\xb3\xc3\x9d\xc5\xfc\x0b\x52\x5d\x03\x38\x76\xcf\xe4\x7f\xbd\xfb\x06\xb9\xd2\x59\xc4\x3f\xe5\xb9\xfd\x93\x83\x0b\xf9\x0e\xf4\xd8\xae\xea\xd4\xa8\xb0\xa5\xd4\x16\x09\x37\x0f\x52\x61\x4d\xa0\x54\xdd\xb8\xa8\xdf\x90\x80\x59\xb4\x97\x4a\xa1\xbe\xcb\xdf\x51\xeb\x3d\xa5\xb0\x6e\x7b\xd5\x60\x6d\x5c\x97\xab\x43\xe8\x3b\xf1\xb8\xa2\xd8\x86\x1b\xe2\xc3\x46\xa6\x98\x93\x43\x51\x56\x88\x44\x72\x63\xac\xd5\x1a\x13\x8f\x52\xc7\x29\x6a\x3b\xb5\x9f\x3a\x44\xd1\x12\x05\x34\xa2\x40\x62\xa8\x9c\x9c\x5c\x57\x50\xb3\x43\x23\xde\x9e\x5e\xda\x8a\x59\x93\x2b\x8c\xf0\xb8\x31\xa5\xe0\x3d\x52\x51\x91\xc5\x88\xb4\xad\x9c\xd2\x03\x45\x27\xa6\xba\x7a\x0f\x33\x3e\xee\x58\x97\x45\x02\x3b\x15\x4f\x6b\xb6\xae\x6a\xba\xb0\x12\x93\xdf\x77\xb2\x41\x8f\x0b\xe7\xdf\x7a\xcb\xf0\x91\x83\x12\xa5\x52\xa0\xcf\xca\xfb\x4b\x9f\x9f\x4b\xef\xd6\x08\x71\xee\x48\x7d\xbd\x1a\xd7\xb6\x5f\xf5\xc6\xb6\xe1\xce\x77\x5b\x7d\x60\x6f\xa6\xc7\x05\xf0\x18\x4f\xe2\xb5\xa3\xf0\x18\x5d\x68\xb6\x5c\xcd\x3b\x91\xa6\xb5\xbb\x3d\x56\x6c\x07\xb9\x2d\x02\x25\x50\x98\xa9\xf2\xad\xfc\x5c\x7e\x19\xcf\x9c\xe2\x61\x2b\xbf\x97\xa7\x10\x0f\x56\x2d\x5e\x40\xc4\xc4\x8c\xac\x4d\x8a\x03\x53\xe5\x73\x2e\x6f\xbd\xc3\x81\x3c\x06\xdf\x27\x29\x6f\x64\x8c\x98\x0a\x33\x89\x9d\x86\xdf\x40\x57\x61\xe3\xd5\x60\x64\x88\xe8\x27\x29\x5a\x9c\xb1\x4f\xa0\x2a\xef\xab\x99\xe1\xaf\x2e\x2b\xa5\xa6\xf0\xed\x7f\x7a\xab\x66\x46\x7c\x78\x59\x7d\x29\x5d\xe6\x92\x56\x9e\xe9\x75\xee\xe3\x80\xf7\x5e\xed\x1d\xb1\x78\x5f\x25\xd4\x1f\xe9\x18\xd6\x5b\x8b\xb0\x55\xda\xa3\x87\x2b\x6c\x49\xf8\x73\x73\x45\x9a\xb7\xf0\x2e\x3a\x59\x1c\xb6\x5a\xac\x96\x5f\x14\xab\xd5\x55\x54\xd4\xe3\x17\xa5\xe8\x57\x97\xfb\x17\xc5\x85\xba\xa4\xc3\x65\xe7\x5f\xa4\x52\x46\x0a\x0b\xde\xef\x7a\xc4\x80\x3e\xe5\x98\x59\xf5\x87\xbe\xc0\x11\xe5\x0a\xab\x88\x1e\x2d\xac\x9e\xd3\x92\x2f\xf0\x45\x98\x33\xeb\x1a\xbe\x92\x1b\x3d\x89\xff\xb4\xa8\x32\xf0\xd0\xf2\x95\x7c\xff\xf1\xad\xae\xbe\x8e\x65\xe3\x87\x34\xb3\x7d\xf9\xdb\xfb\xf3\xea\x8f\xf3\xa6\xc4\x7b\x42\x61\x3c\x7f\xe4\x48\xb6\x94\xf9\x06\x0a\xd6\x3e\x58\x36\x6b\x86\xfa\xdc\xa4\xdb\x5d\xb4\x63\xea\x88\x68\x40\x7d\xba\x38\x7e\xbb\xf6\x4e\x74\x8b\x3a\x04\xe6\xe1\xf1\xe0\xbd\x2c\x0b\xd8\xc8\x64\x58\xcd\x14\x35\x0e\x29\x48\xbf\x30\x39\x80\x65\xaa\x3a\x84\x1b\xfa\xeb\x0b\xba\xee\x9e\x9f\x3d\x07\x5e\x54\x10\x48\x24\x1c\xac\xd9\x14\x8b\x99\x10\x5d\x9c\x34\xc7\xf2\x62\x79\xbf\x28\xb1\x98\x17\x79\x3d\xbf\x28\x5e\xdc\xe2\x17\x05\xfd\xfa\x5b\x73\xe0\xec\x53\xa1\x25\x4c\xe8\x34\x57\x4d\xf8\x74\x7f\xa8\xae\xc2\x62\x50\x9f\x8c\x24\xe0\x8b\xc6\xe0\xbd\x3e\x4e\xd3\x97\x31\x07\xcf\x37\xc6\x7c\xd3\xa4\xc1\x97\x31\x7d\xf9\x01\x97\xf4\xe7\x57\xfd\x99\xaf\x34\x4d\x1a\xcd\xcf\xbd\xc9\x55\x19\x78\xf8\x26\xf5\x47\x3c\x62\x18\xd1\xba\xca\x43\x4b\xd3\x1a\x2b\xa1\xa1\x24\x36\x78\x70\xd9\xfb\x05\x3d\xd5\xbf\x14\x44\xc7\x5c\x4a\x97\x32\xbf\x9b\xaf\xfe\xcf\x9a\x4d\x78\x3c\xa3\xe0\x17\xa6\x92\x1e\x81\x65\xe3\x1c\xd9\xcd\x0b\x1e\xaf\xe0\x0d\x86\xbc\x56\xd6\xfa\xa4\xc2\xca\xc1\x1e\xf5\xac\xc6\xfe\xaa\xb0\x96\xc1\xb2\x4e\x01\x73\xfc\x27\x15\xd1\x19\x75\xd6\x39\x1b\x9d\x8c\xe8\xdc\xeb\x3c\xe6\xa4\xb5\xdf\x65\xce\x16\xe7\x1c\xe7\x56\xe7\x11\x7c\xa1\xc3\x29\x38\xe5\xb2\x8a\x7a\x27\x2a\xd3\x12\xaa\xd2\x91\x2c\xc9\x64\x97\x80\x49\x6d\xd1\xf5\x48\x1c\x2e\x4e\x74\x67\x3d\x50\xa7\x3a\x65\xa7\xe8\xc2\x19\x6b\x1a\xae\x28\xb8\x74\x84\xed\x2a\xe7\xad\x8b\x6a\x16\x0f\x1b\x7d\x59\x7c\xf0\x08\xd7\xd5\x0e\x79\x06\xfc\x72\x5d\x5d\x9f\x59\x2b\x5e\x7a\xa8\xb6\xae\xbe\xd7\xf4\xd5\xb7\xdc\x3e\x1c\x75\x74\x20\xe3\x1f\x09\x2f\x01\xf1\xcb\xad\x52\xaf\xa6\x6a\xe9\xd7\x49\x1d\xbe\x25\x72\x31\xb6\x8b\xad\x56\x1b\x29\xe9\xa0\x55\xe2\x9b\x23\x2e\x15\xf7\x8a\xaf\x89\x1d\xa2\xc9\x41\x8b\x72\x7e\x71\xbd\x28\x5b\xc5\x7a\x51\xa4\x6d\x07\x40\x92\xbf\x24\x09\x84\x52\xa6\x4c\xdf\x59\x52\x38\x6f\x17\xa9\xc0\x97\x29\xbf\x97\xd4\x2b\xf5\xe1\x7b\xef\x92\x62\x7d\x7a\x15\xbf\x61\xe4\xc6\x12\x52\xa9\xaf\xc5\x01\x8d\x5d\xcb\xf4\x9d\x5f\x75\x4f\x26\x55\xf7\xf2\x49\x4d\x3d\xe6\xb7\x6a\xf4\x75\x2b\xea\x97\x9f\x2e\xbf\x47\xe9\x65\xfa\xb2\x6b\xf4\x35\x11\x94\xe5\xa4\x4c\x1f\x4a\xd7\xf1\xcb\xae\xd1\x57\x46\x6a\xf4\x5d\xc0\x93\xde\x72\xa1\x4a\x49\xdd\x1c\xe8\xe7\xdd\x9a\x97\x55\x9e\x8f\xa4\xa6\x75\x8f\x8d\x86\x4a\x5d\xb7\xd7\x14\x23\x57\xdc\x95\x82\xfa\xec\x2a\x7d\x74\xbd\x91\xde\x78\xb6\x99\x3e\x40\xd6\x6d\x03\xe6\x8b\xda\x79\x4f\x10\xeb\xea\xb7\xca\xc3\x90\xd3\x16\xc9\x31\x31\xac\xdd\x4e\xfb\x7d\x12\x23\x32\x0c\x2b\xb2\xce\x90\xe0\x14\xb0\xe2\xee\x93\x7c\x0b\x14\xd1\x1d\x75\x97\xb9\x69\x33\xed\x76\xdb\xa4\x1c\x3f\xed\x5f\xa8\x34\x06\x5b\x82\x73\x82\x74\x30\xa8\x19\x74\x12\xcd\x8a\x76\x8c\xc1\x8f\xb5\x8d\x3a\xbd\xf8\x9a\x23\x5d\x7e\x0c\x7f\xc9\xc4\xbd\x75\x89\x1b\xd3\xaa\x8e\x65\x2a\xe2\x68\x79\xfb\x71\x52\xfa\xc6\xd9\xa5\xf8\x18\x96\x87\x6e\x9f\xcb\x44\xd1\xad\x83\xb7\x35\xc6\x9a\x73\x1f\xdc\xb1\xfc\xc4\x8a\x68\x73\xe4\xae\x99\xa5\xd5\x52\xcd\x84\xb5\x4b\x57\xaa\x7c\xdb\x9a\xe5\x3b\x61\x7c\xff\xcb\xac\xaf\xbe\x60\x7a\x71\xcb\x4e\xf0\xec\x92\xf6\xec\xe6\x93\xea\x99\x3d\x35\xa6\x73\x5f\x98\x95\xcd\xc7\xc3\xb4\x2f\x5f\xfd\x90\xf0\x95\x20\x66\x3f\xc0\x0e\xc7\xf2\x7c\xaa\xdc\x3b\x37\x2f\x8f\xb3\x0a\x1c\xed\xa2\xb0\xe2\x17\xb6\xdb\x0b\x13\x14\x55\x90\x6b\xb6\x98\x17\x28\x39\x16\x0b\xe5\x70\x04\x16\x28\xc8\x33\xd7\x43\x09\xb4\xc7\xc1\xd1\x09\x2a\xb1\x28\xbb\x0e\x42\x67\x4a\x41\xaa\xf3\x20\x5d\xd7\xad\x1c\x99\xdc\x63\x92\xa0\xa5\x49\xf3\xc2\x78\x75\xaa\xa0\x5b\x70\x9c\x2f\xc6\xc5\x4c\x84\xdf\x2c\x09\x9d\x7b\xd1\x3d\x61\xfc\x78\xff\x36\x71\x69\xa0\xfd\xfb\xdb\xef\x2d\x1d\xc0\xe5\x5e\x55\x71\xcf\x43\x0c\x78\x45\xf5\x0c\x6d\xb1\x5f\x79\xe5\xc6\x8d\xd7\x0e\x1d\x74\xd7\x88\xde\x93\x9b\x5b\xc6\x7e\x71\x2a\xa9\x7e\xfb\x92\x27\xe7\xb3\x3f\xde\xd1\x3c\x6d\xe0\x98\x75\x0d\x78\x5d\xa7\x03\x43\xef\x62\x86\x60\xbd\xb6\x08\x6d\x92\xfd\x61\x14\xb7\x23\x7b\x71\xb2\x32\x39\x28\x39\x25\xb9\x22\xb9\x3d\x79\x28\x79\x22\xc9\x25\x35\x4e\x53\x3e\x7e\x4a\x7d\x6e\x12\xdc\x49\x40\x49\x18\x46\xa1\x64\x6e\x52\x4e\xb6\x26\x97\x25\xdb\x92\x07\x93\xdc\xc1\xe4\xf1\x64\xd6\x35\x56\xa0\xb5\x46\xcf\x54\x37\xd4\x93\xc6\x01\x57\xb0\x9e\x2b\x58\xa8\xc5\xcb\x0a\x34\xe7\xf1\xe4\x2e\xd4\x02\x3d\xd7\x79\xc0\xa3\x25\x98\x62\x4a\x95\x0e\x69\x53\x03\x7a\x1e\xa5\x7e\xe0\x9d\x9c\xd8\x69\x8f\xb8\x2a\xab\x0b\xab\x7d\xda\x44\x54\xfb\x38\x4d\xf0\xfb\xb8\x42\xcd\x42\xe1\x0a\xab\x0b\xaa\xdd\x46\x20\x21\x31\xfd\x56\x34\xcd\x6c\x98\x76\xcd\x2d\xb7\x5c\x73\x4d\xfd\xac\xe6\xe6\x59\xf5\xd7\x5c\xbd\xf2\xd6\xe9\x33\xea\x67\x36\xb5\x36\xae\x1a\xf1\xbb\xbd\x7b\xae\xbb\x74\xe5\x48\x6a\xfb\x6d\x57\xcf\x6c\x20\xb7\x67\xcd\x5e\x7a\xcb\x35\xda\xed\xa6\x99\xf5\x33\xa6\xdf\x7a\xe9\xaa\xa6\xdd\xd7\x5d\xb7\x67\xc4\xed\x78\xdd\x5b\xf0\xba\xdf\x81\x69\x3e\x1f\x3d\x22\x8f\xb5\x3b\x6c\x36\x5e\x34\x9b\xf9\x68\x3c\x4e\xe7\x12\xa7\x10\xef\x0c\x44\x22\xce\x82\x44\x24\xe0\x73\xba\x9d\x0b\x14\xad\x16\xe2\x02\x25\xdf\xea\x77\xd8\xe3\x36\x5b\x9e\xdd\x61\x5f\xa0\x44\x1d\xa2\x35\x6a\xa5\x44\x2b\x58\x68\x87\x2c\xd8\xea\xad\x0e\xab\xc3\x14\x72\xd3\x5a\x90\xf8\x02\xc5\xe4\xec\x0c\xfd\xd0\xb6\x00\x19\xbd\x11\x05\x64\x28\x3f\xe9\xf4\x24\x3d\x26\xa4\x22\x5b\x1b\xca\xfc\xdb\x47\xaf\x3e\xc8\x69\x96\x3b\x15\xab\x8e\x55\x17\x6a\xb9\x33\x5d\x62\x44\x52\x9c\x16\xf2\x37\x41\x54\x4f\xf6\x78\x4c\x68\xff\x46\x78\xaa\x87\x7a\x52\x04\x9f\xcf\xa4\xfe\x6c\xff\x6a\x43\x8b\x00\x7b\x84\x55\xab\x61\xfa\x22\x01\xc6\x09\xb3\xd4\xd5\xdf\xd8\xd5\x9f\x1d\x7e\x58\xdd\xfc\xb5\x16\x40\xf2\x75\xf3\xcd\xf1\x66\x6a\x0e\x89\x1d\xb9\x83\x5a\x48\x3e\xef\x6e\xce\x21\xaf\xb7\xa7\xb2\x64\x35\x87\x8a\x64\xb7\x89\xa2\x58\x00\x81\xc7\xdc\x41\x61\xc2\x80\xec\x5a\x11\x8f\xba\xc3\xdd\x93\xbe\x35\x01\x4e\xeb\x42\x7c\xea\x54\x3a\x46\x5d\xd3\xbe\xfe\x6c\x82\x9a\xdd\x7e\x0f\xe1\x37\x03\x3b\x10\xbd\x93\x9d\x85\x2a\x91\x8c\x26\xcb\xc5\xfd\x2b\xfa\xa2\xbe\xee\xc2\x20\xb2\x97\x55\x55\xd9\x6b\x7c\x41\xb7\x89\x8d\xb2\xd1\x01\x03\x2b\xfa\xfb\x6a\x0a\x6b\xfa\xdb\x35\x35\x33\x7f\xb3\x12\xcb\x39\x00\xf6\x67\x29\xcb\x66\x85\xa3\x0e\x80\xa8\x85\xad\xa0\x4e\x55\x9a\x4c\x29\x31\x73\xb3\x82\xc2\x88\xf6\x95\x90\xb2\x32\x37\x7a\x67\xec\xdd\xea\xf3\xac\xde\x08\xf8\x48\x71\x43\x2e\x02\x34\x86\x22\x9e\x06\x5f\x7f\xa0\x25\x75\xca\xa5\x7b\xaa\x8b\x4a\x5d\x91\xdf\xf5\x5f\x74\xdd\x55\xd7\xce\x9d\xb9\x65\x43\xcb\xc8\xa7\x1f\x5d\xf8\x50\x7e\xa9\x7d\xc0\xac\x31\x53\x7b\x0c\x9d\x3d\xfe\xb2\x9e\x3b\x37\x5e\x35\x3a\x34\x64\xec\xc2\x3b\x46\x0e\x5e\xbd\x74\xb0\xfa\x52\xc4\xff\xd5\xea\x48\xf1\xf4\x16\x79\xe6\xc0\xba\xd5\xa3\xaf\xdf\xea\xad\x5c\xdc\x70\xc7\x56\xcd\x48\x1e\x79\x79\x8f\x7e\x55\x7d\xca\x2f\x6d\xa9\xbd\x79\xbb\xa7\xee\x16\x78\xa7\xf7\xe8\x9e\xa6\x59\x8a\x7c\x79\x8c\xbd\x0a\xcf\xcf\x61\x66\x06\xf5\x2b\x9b\xd2\xf2\xec\x29\x46\xee\xc0\x12\xd4\xea\x74\x06\xfc\x1e\x81\x16\xee\x50\xc4\x9d\xf4\xdb\x58\x8b\x95\xab\x07\xd6\x17\xd2\x43\x69\xca\x4f\x63\x6e\xf1\x00\x4d\xf1\xf4\x4e\xfa\x57\x9a\x16\x68\xd9\xe2\xa8\xa7\xa7\x05\xa0\x26\x00\x3d\x02\xe0\x0f\x00\x13\x80\x7f\x07\xe0\xef\x01\xf8\x28\x00\x87\x02\xb0\x3f\x00\x8f\x06\xe0\xde\x00\x2c\x0f\xc0\x82\x00\x5c\x19\x80\xcb\x02\x30\x28\x00\x95\x01\xc8\x0f\x80\x27\x00\x6c\x00\xa6\xff\x1c\x80\xaf\x02\xf0\x61\x00\xde\x24\x0d\x1e\x21\x0d\x50\x26\x79\xac\x39\x00\x03\x03\x50\x41\x5a\xe8\xc9\x63\xff\x0a\xc0\xdf\x48\xb2\xd9\x1b\x01\x78\x9a\x24\x9b\xdd\x13\x80\x5b\x02\x30\x3f\x00\x53\xd2\xc9\x66\x18\x3e\x2f\x00\xce\x00\x50\x69\xf8\x4c\x8f\x76\x10\xf8\x65\x04\x7e\x32\xc1\x3f\x84\xf4\x08\xc3\xcb\xbf\x73\x93\x31\xf4\x39\x4d\xfa\xf4\x01\x79\x04\x6e\xb2\x3d\x00\xeb\x03\x70\x5b\x00\x16\x05\x60\x6a\x00\x46\xa5\x07\x51\x90\x7e\x44\x67\x02\xdc\xa1\x74\x83\x15\x01\x58\x98\xee\x4d\x65\x3a\xf5\x0d\xe3\xc6\xa8\x4f\x90\xc7\x53\x99\xe4\xb8\xa8\x7e\xf6\xd4\x72\xde\xd1\x77\xcb\xf9\x27\xdf\xbf\x71\xf0\x7d\xde\x51\x79\xcb\x7f\x8f\xd8\x28\x4b\x6a\xec\x71\x7e\x72\x7e\xd7\x44\xba\xae\x25\x0c\xd8\xac\xef\xd4\xaf\x35\xc5\xc5\xb5\xb5\xc5\xc5\x35\xea\xe6\x9a\xe2\xa2\x8b\xfa\x17\x16\xd7\x30\x47\x8a\xfb\xe2\x4f\xed\x6a\xdf\x8b\x8a\xf0\xa7\x9e\xcf\xbb\x08\xdb\xe6\x7f\x65\x9b\x91\x56\x34\xa5\x06\x6e\x94\xab\x24\x54\x1e\xf7\xf3\x7c\xef\xa2\x38\x62\xfb\xd4\x0a\xb5\x20\xd4\xf6\xa9\xfd\x4f\x2d\x3d\xf7\x3f\xb5\xb0\xa3\xf6\xab\x5a\xaa\x08\xff\xa6\x9c\xb5\xc0\xd4\xc2\x89\xda\xd3\xb5\xd4\x07\xb5\x50\xab\x99\xef\x7d\xc6\x4c\xa8\x9f\x5e\x0b\x03\x6b\x21\xbf\xb6\x92\x40\x98\x6a\xe1\x93\x5a\xd8\x56\xfb\x74\x2d\xb5\xbe\x16\xe6\xd7\xde\x52\x4b\x8d\xaa\x9d\x52\x4b\x55\xd4\x0e\xac\xa5\xdc\xb5\xf9\xb5\x14\x55\x0b\xb2\xde\xda\x8b\x35\xc8\xd3\xb5\x70\xb0\xf6\x68\xed\xf1\x5a\x7a\x7f\x2d\xac\xab\x6d\xab\xa5\x6a\x35\x71\xd2\xb3\xa2\x9e\x80\x24\x8a\x4a\xeb\x4f\xe8\x20\xd4\xf6\xda\xfd\xb5\xd4\xba\x5a\x98\x52\xbb\xb0\x76\x45\x2d\xdd\x54\x0b\xeb\x6b\xb7\xd7\x1e\xaa\xa5\x6b\x89\xc3\x20\x10\xa9\x5f\x56\x0b\x14\xaa\x05\xb3\x7e\x65\x88\xd5\x51\x5f\x50\xfa\x8e\xd2\xb3\x18\x8a\x8b\x0b\x62\x55\xbd\xaa\x06\x54\xd1\x50\xe5\xa8\x8a\x55\xdd\x5d\xf5\x70\x15\x6b\xa3\xab\xaa\x72\x73\x2b\xde\x51\x50\x81\x54\x40\x89\xb9\xd1\x5c\x2c\xcb\x0b\x72\x0b\x72\x19\xab\xd5\xfd\xb6\x62\x6d\x63\xc2\x6f\x2b\x0c\x93\x65\x38\xa4\x53\xd9\x33\xc7\xdb\x98\x85\x97\x69\xc2\xcc\xf0\x3c\xe8\x4b\x9c\x4c\x6a\xeb\x9a\x6c\x99\xd4\x65\x45\x93\xc6\xda\x6b\x8d\x9c\x9d\xb5\x3b\x8c\xbc\x06\xa7\xee\x7d\xcd\xa7\xaa\x49\x42\x7b\xbe\xb3\xaa\x92\xca\xd7\x52\x0d\xc1\x58\xdf\x28\x18\x9c\x49\x8a\x55\x68\x4a\x90\x69\xd1\x4b\xd0\xef\xc5\x97\x40\x7e\xe1\x59\xf5\xb5\x57\x5f\x54\x0f\x1e\x18\xf2\x18\x44\x77\x3c\x06\xb9\x3b\x9f\x50\xff\xf6\xd8\x63\xea\xf1\x47\xa9\x1b\xdf\xfc\xfc\xc3\x23\x0b\x36\x30\xbd\x5c\xcd\x8b\xee\x5d\x06\xb6\xb5\x0d\xde\x5e\xcc\x0d\xd4\x96\x57\x60\xc0\x73\x07\xd4\xd7\x5f\x79\x41\x7d\xf3\xe5\x03\x20\xbf\xf8\x98\x7a\xec\xd1\x47\x71\xc3\x9d\x90\xb7\x1d\x7f\x6f\x7f\xf5\xe3\xd7\xdf\xff\x28\xf2\xd2\xf4\xd4\x13\x2f\xab\x8f\x5c\xb4\xf8\x0f\x85\x98\x0f\x4d\xa0\x3a\xa8\xdb\x30\xcd\x38\xb1\x71\x36\x50\xce\xf3\x0b\x61\x97\x48\xd3\x4e\x24\xa0\x9c\x88\xcd\x73\x42\x71\xda\xbe\x08\x07\x4d\xc1\x7f\x28\xa6\x93\x34\x3a\xa1\xd0\x27\xb3\x8f\x0b\x53\xdd\x7c\xf7\x98\x8a\x31\xa7\x35\xce\xce\xc9\x31\xad\x36\x24\x9d\xf1\x6a\x09\x75\x89\xd1\xc2\xdb\xd6\x51\xd3\x86\x8c\x1d\xb3\x6d\xfa\x80\x8b\x4d\xb9\x91\xdb\x4b\x7a\x5f\x3e\x73\x5c\xbf\xa1\xf4\x20\xb1\xb0\x41\x59\x7c\xc5\xcc\x27\xaf\x0c\xd2\xce\xc6\xd0\xd3\x2b\xd7\x14\xeb\x71\x00\x73\x50\x03\xfd\x2f\x7a\x14\x32\x21\x1b\xaa\x97\x63\x82\xd5\xca\xf3\x22\x0d\x40\xb1\xac\xd9\x2e\x5a\x18\x8a\xf9\x61\x3c\x87\xe1\x7e\x1c\x6f\xb3\x0a\x26\x16\x0b\x0d\x27\x0a\x90\xfc\xac\xec\xbc\xe0\x4c\x49\x07\x43\x79\x4e\x81\x2b\x0e\xd5\xc6\x07\x15\xea\xa7\x1e\x7c\xbe\x9f\xfa\xb9\x85\xee\xdb\x4f\x7d\xed\x40\x3f\xf5\xaf\x16\x7a\x94\x7a\xad\x7a\x33\x4c\x19\x08\x53\x8c\x2f\x58\x08\x7e\x89\xde\x65\x36\x52\x9f\x21\x16\x95\xc8\x5e\x1a\x7f\x98\x38\x91\x6a\xa1\x28\xab\xc6\xab\x11\xfd\xa4\x82\xf6\x6a\xb3\x13\xf4\x4b\x87\x33\xc5\x76\x33\xe5\xd1\x98\x8d\x57\x9f\xdb\x43\x7d\xd6\x7e\x0a\x9e\x98\x8a\xed\x2a\xa3\x5e\x19\xb6\xab\x24\x3c\x4e\xa6\xcb\xde\xad\x42\xfd\xe1\x6f\x72\x87\x84\x7a\x24\x12\x05\x55\xe5\xe5\xa5\x7d\xf3\x62\xb1\x82\xca\x5e\xbd\x4a\x4b\x7b\x17\xf4\x46\x7e\x3f\x8f\xf8\x3a\xb9\xb0\xb6\xa8\xf6\x1d\xa5\xbc\x6f\x6e\xdf\xdc\x77\x94\x5e\xb1\x82\xfc\x82\x77\x94\xca\x7c\x54\x24\x15\x51\x02\xca\xc7\xd6\xf4\xb2\xfc\x53\xf9\xb4\x93\x2e\xea\x9b\x9f\xdf\xb7\x88\xee\x4a\xfc\xbf\x93\x61\xba\x0c\x3d\x64\xf0\xcb\xc0\xcb\x70\x40\x86\x55\xe4\xca\x50\x19\x6a\xd2\xd7\x39\x7c\xe5\x1b\x19\xde\x96\xe1\x59\x19\x76\xc8\x70\xbf\x0c\xb7\xc9\xb0\x58\x86\xab\x64\x18\x2d\xc3\x10\x19\xaa\x09\xe8\x19\x19\xbe\x93\xe1\xaf\x32\xa0\xa7\x65\xd8\x4e\xe0\x56\xc8\x30\x5f\x06\x68\x95\x61\x94\x0c\x95\x32\x58\x64\x38\x2b\xc3\x09\x19\xde\x95\xe1\x25\x19\x76\xc9\xb0\x46\x86\x39\x32\x50\x2d\x32\x94\xcb\x10\x95\x41\x94\xb1\x8d\x26\xc3\x31\x19\x8e\xc8\xf0\x9a\x0c\x4b\x65\x79\x88\x06\xd1\x24\x43\x1d\x01\xe8\x48\xdf\x6c\x93\xe1\x2e\xed\xbe\x86\x1d\xdf\x2a\x23\xb7\x7e\x92\xe1\x28\x69\xb7\x57\x86\xad\x32\x34\x12\xb4\x65\x04\xed\x05\x78\x76\x57\xb6\x9e\x1d\x84\xd7\x32\x2f\xfd\xf7\x82\xdc\xbf\x6b\xd4\x1d\x56\x49\x30\xe3\x20\xfc\x42\xab\xb5\x4c\x94\x3c\xc2\x4f\xba\x14\x03\xed\x12\xee\xd3\xc5\x13\xf6\xbf\xb0\x08\xd6\xe1\xf3\xc4\xaa\xaa\x1d\x85\x55\x31\xbd\x22\x98\xcb\xe7\x89\xd3\xd5\x9a\xeb\x02\x5b\x1b\xbd\xff\x77\x46\x01\xea\x7c\x75\x47\xeb\x34\x68\xd8\xbc\x75\xdc\xd8\x8f\x47\x1d\xfe\xc7\x9e\xd1\x0b\xea\x2e\x9e\x31\xfe\x7f\xe5\x14\x1f\xaa\xc7\x1c\xc9\xa4\x83\xda\x27\x15\x2d\x98\x71\xe9\xdc\xb0\x7a\xd8\x91\x84\x89\x27\x95\x4b\xd4\xfd\x0d\x78\x1f\xdc\xc3\xee\x66\x9e\x35\x99\x89\x6f\xc7\x0c\x0c\xde\x08\xf4\x8b\x0a\xfe\x6b\x9c\x8c\x60\x8a\x8f\x55\xc5\x98\x67\xcf\x7e\xce\xc4\xd9\xdd\x93\xf4\x7d\xbc\x9d\xfa\x07\xed\xc0\xf4\x6d\xc7\xd6\x58\xa9\xec\xf3\xe0\x5d\x8c\x50\x38\xc4\x58\xed\x56\xe7\x93\x8a\x95\x61\xfc\x4f\xa6\x79\xb2\x74\x28\x99\xad\x67\xba\x08\x27\xd1\x1c\x55\xc4\xc3\x5e\xdd\x59\x03\xcb\xb4\xbd\xf9\xee\xcb\x2e\x5b\x37\xea\xf2\x75\xcd\xb7\xec\x9f\xba\xe4\xf2\xb1\xd7\x5d\x37\xf6\xf2\x25\x4c\x08\x5f\xc2\xff\x8d\xba\x7b\xe4\xfe\x5b\x94\xeb\xae\x1f\xab\x5c\x7f\x9d\xde\x07\xcd\x1e\xf0\x93\xfa\x86\x22\x6a\x91\xab\x6c\x66\x3b\x6b\x16\x58\x13\x12\x04\x5a\x7b\x91\x80\x5d\x7c\x52\xb1\x3f\x4e\x6b\x75\x7e\x38\x3b\xe2\x9a\x38\xbc\xb1\x39\x93\x6c\x54\x3f\xac\x33\x35\x9a\x28\xad\x02\xa2\x9e\x62\x6d\x6c\xf2\xe4\xf9\xc1\x07\x06\x8b\xc9\xaa\x89\xe8\xc0\xcb\x48\xcd\x4e\xd7\x45\x3c\x37\x34\xbb\x32\x62\xfb\x3f\xb5\x60\x48\x40\xbd\x28\x1f\x75\x33\x3b\x04\xf9\xc1\x2a\x3f\x67\xb5\xd9\xc0\x64\xf2\xbb\x5c\x41\x1f\x40\x20\xa8\x55\xae\x11\xbe\x52\xa4\xbf\x52\x3e\xf0\x7d\xa3\xc0\xe7\xc3\x82\xd0\x37\x08\xc9\x20\xec\x0a\xc2\xa6\x20\x2c\x09\xc2\xcc\x20\x8c\x0f\x82\x25\x08\xd7\x9c\x0d\xc2\x77\x41\x78\x29\x7d\x6f\x4d\xfa\x76\x4b\x10\xa8\xc6\x20\x44\x83\x20\x92\xac\xc4\xd7\x82\xb0\x34\x08\xf8\xca\xb1\x20\xec\x0d\xc2\x56\xf2\x73\x0e\x81\xc3\x17\xeb\x08\x58\xed\x4f\xe4\xf6\xbe\xf4\x25\x29\x0d\x81\xbf\x97\x11\x5c\x28\x08\x47\x48\xe3\xd6\x20\x74\xf3\x66\x74\x8d\x88\xce\x0e\x66\xcd\xaa\x29\xd3\x35\x4a\x20\xbb\x80\x86\xe1\xbd\x8c\x55\x1b\x05\xff\xf4\xda\x3b\x64\x23\x88\x10\xa3\xe2\xaa\x5d\xfc\xe0\xfe\x86\x9a\xea\xfe\xb5\x05\xd5\xd1\x79\x23\x17\xde\xb4\xfa\xc1\x27\x61\x39\xe5\x6b\xdd\xb0\xfe\xde\xe6\xca\xc1\xb1\xc9\xbb\x43\x53\xc7\x5c\xf1\xc2\xac\xa5\xba\x6f\xb1\x88\x32\x53\xcb\xf0\xfc\x16\xc2\x40\xf9\x2f\xfe\x40\x9e\x3d\x9a\xb0\x58\xec\x01\x9a\x72\xb9\xa2\x0c\x45\x15\xf5\xc8\x13\xed\xa2\xfd\x2b\xa5\x51\x6c\x11\xe7\x88\xb4\x55\x0c\xeb\xf5\x09\xc3\x28\x10\x08\x87\x3d\x5f\x29\xe1\xbf\x22\xfe\x2b\x05\xd1\x80\xc5\x23\xfa\x5c\x2c\x82\xa3\x45\x30\xa7\x08\x5a\x8a\xa0\xb1\x08\x72\x8b\x40\x2a\xc2\x0f\x81\x59\xa7\x8a\x60\x69\xfa\x46\x79\xfa\xc6\xf1\x22\xd8\x5b\x04\x5b\xd3\xd7\xf5\x8b\xb8\xfd\xdc\x22\x28\x4b\xb7\xec\xfb\x53\x1a\x68\x29\x41\x59\x47\x6e\x9c\x22\x8d\x0f\x16\xc1\xbe\x22\x68\x23\x17\x71\x83\x28\x69\x80\xe1\x8f\x10\xf8\xbb\x48\x13\x99\x3c\xef\x37\x38\x5d\x76\xb1\xdc\xee\xce\x26\x12\x77\x32\x29\xab\x80\xa1\x43\xaf\xd7\xd2\x59\xb0\xc5\x91\xea\x99\xa9\x93\x6f\xf8\x94\xb3\x4c\xad\x32\xd0\x7d\x1d\x5d\x96\x88\xd4\x6b\x31\x01\x3d\x77\x46\xb0\x9a\x73\x5f\x92\xb8\xfa\xea\x35\x97\x5b\xc7\xd4\x8f\xb9\x7e\x40\x6f\xbc\x5c\x33\x46\x2f\x58\x3d\x7f\x5e\xcb\xe4\x17\x28\x73\xe8\xc5\xb9\x36\xf7\xa4\x29\x4b\x2c\xa6\x01\x0c\x3d\x7a\xc2\x35\x39\x53\x77\x87\x26\x35\x8d\x9b\xe7\xb0\x8c\x19\xb2\xf8\x5e\x7d\xed\x7e\x65\x26\x51\xbf\x27\x71\xc2\x93\xe5\x0e\x1a\x21\x0e\xcb\xf9\xf5\xe3\x2d\x6c\x88\xdd\xc5\xbe\xcb\x32\x02\xab\xc7\xe3\x26\xd3\x21\xb6\x67\x49\x24\xee\x2e\x12\xb3\x9b\x89\x1f\xce\x8e\xd6\x9d\xf1\x59\x1a\x42\x0f\xd4\x9d\x49\x20\xf4\x7b\x7a\x00\xaf\x1e\xbd\x3b\xfe\x3c\xbc\xdf\x91\x86\x99\x56\xfa\xf5\x5a\x3d\x54\x58\x8f\xc0\x5d\x91\x09\xe9\x25\x21\xba\xe5\x1c\xe4\x73\xe0\x26\xb1\xba\xa7\x39\x38\xc1\xc1\x47\x1c\x1c\xe2\x60\x7f\x3a\xfe\x57\x0f\xe9\x9d\x92\x86\xd7\x81\x19\x02\xfc\x19\x81\xdc\xc7\x01\xd5\x46\xe0\x96\x72\x10\x7d\x8a\xcb\x98\x2c\xdd\x6d\x90\x0b\x1b\x2c\xbf\x21\xf4\xba\x1a\x25\x59\xc1\xbb\xae\x6a\x57\x8a\x83\x5f\xd9\xd3\x1f\x9b\xd4\x39\xcc\xa4\x18\x48\x09\xf5\xb4\xbe\x0e\x21\x75\x38\x03\xf4\x6e\x94\x83\x46\xc9\x25\x0e\x13\x23\x8a\x16\xce\x9a\xe3\xc3\x0a\x49\x30\x60\x0d\x44\xa2\x39\xc1\x46\x25\xc7\xe3\x17\xf5\x88\x21\x53\x08\xb9\x29\x77\xb3\xc2\x50\xde\x4c\xf6\x89\x1e\xe4\xd2\x3d\xe2\x23\x7d\x9c\xaa\xf9\x83\x28\xac\x3f\xf6\x76\xea\x21\x4e\x5c\xf6\xf9\x2a\x75\x64\xdd\xfc\x19\x91\x5e\xf5\x4f\xf1\x79\xc3\xbd\x6b\x57\xf2\x50\xb1\x80\x19\x2e\x97\xdf\xdc\x73\xf9\x23\x1b\x6f\xe5\xd5\x6f\x6f\x58\x37\x42\xfd\xfa\xe3\xd2\xa1\x20\xdc\x40\xc7\x02\xa5\xed\x0b\x7b\x0e\xbe\x74\x60\x8a\xfa\x54\x3b\x65\xc5\x7d\xbf\x4e\x55\xe9\x33\xa4\x4e\x41\x5f\x19\x73\x42\x16\xf3\x72\xbb\xd9\x6e\x96\x1c\x1c\x67\xb2\x21\xc6\xc6\x6c\x56\x6c\x3b\x4d\x40\x7c\x0e\x87\x8c\xfa\x03\x7d\x74\x8e\x94\xca\x3a\x55\xc7\x5c\x1d\xff\xeb\xd2\x95\xf7\x98\x87\xde\x3c\xe9\x89\x49\xd4\xfb\x3f\x1e\xff\x00\x8e\x30\xff\x3a\x63\x65\x4f\x9f\xb1\xd2\xd5\x1f\xbe\xf4\xfc\x9b\x55\x58\xc7\x7b\x94\x2a\x85\x07\xe8\xa8\xd3\xc4\x5f\xac\xd7\x1b\x52\x2f\xa7\xec\x28\x84\x5c\xa8\x46\x0e\x49\x0e\x87\x68\xb7\xb3\xa4\x40\x06\x16\x6d\x8e\x7b\x14\xbb\x9d\x16\x69\xfe\x6e\x85\x26\x45\xb6\xb4\xaa\x49\x99\xb0\xa4\x4c\x9d\x0a\x56\x3f\xd6\x37\x44\x20\xde\x85\x78\xa3\x51\xf6\xbb\x56\xd5\xf7\xf3\x95\xf7\xea\x37\x7c\xd0\x80\x41\xa3\x63\x4d\x63\x3e\x9a\x7c\xad\x67\x98\x54\xdd\xa7\xa4\xaf\x69\x43\x33\xdf\xac\x3d\x7b\x30\x96\x2f\x3d\xd8\x81\x46\xad\x57\x2d\x43\x87\x33\xd1\x2c\x6b\xb1\x0a\x7f\xd5\x92\xbf\xb0\x66\xff\x79\x9a\x17\x67\xce\xe0\x8d\x48\x23\x3d\x9c\x84\xab\x4e\xa4\x60\xc5\x76\x41\x2d\xe0\x1f\x9b\xbd\x8b\x07\xa8\xa7\x46\xdb\x7b\xf5\xb2\x53\xf3\x6a\xcb\x6e\xd3\xe5\xeb\x7c\x9a\xa2\xda\x48\x4d\x5b\x3f\x2a\x96\x3d\x82\xd7\x1b\xc4\x1c\x34\x10\x74\xa1\xaf\x14\xd7\x17\x56\xd3\x57\x8a\xf5\xdb\xf3\xe2\xad\x34\x6e\x62\x14\xff\xc2\x23\xa2\xd3\x96\x83\xc6\x44\x60\xcf\x88\x39\x7d\xab\x9a\xe6\xf4\xbd\xfb\xaa\x1b\x2f\x7f\xb0\xe5\xaa\x1b\x5f\x62\x03\xfb\x96\x8f\x1c\xfb\xf4\x4d\x97\x8f\x69\x3f\xb9\x74\xf6\x15\x8f\x4e\x5c\x3a\xfb\x81\xf7\xc8\xb3\x6d\xd8\x4e\x58\x67\xd8\x09\xc3\xe5\xb8\x99\xd7\x2c\x05\x1a\x58\xe0\x29\x96\x67\xed\x22\x63\x11\x2c\x3f\x8c\x47\x9c\xc0\x69\x96\x82\xf6\xde\x93\x03\xe0\xfa\x0d\x4b\xc1\xe0\x73\x7a\x69\xc1\x44\x1c\xe8\x14\x68\xc5\x2d\xc9\xc7\x89\x7e\x30\xe0\x40\x3f\x88\x5b\xce\xbd\xd5\x0f\x06\xbe\xd0\x0f\xf2\x2d\x0d\x70\x07\xdc\xa4\x6e\x1e\xa8\x6e\x36\xbe\x68\xe7\x26\xf5\x78\x5d\x5f\x64\x07\x4a\x85\x5c\x3b\xf5\x30\x42\x52\x01\x5a\x42\x23\x07\xc7\xb3\x74\x5e\xfb\xb7\x28\x5f\xf6\xd0\x94\xe4\xa4\x29\x2c\xef\xfd\x68\x19\x82\x26\xad\xfc\x12\x20\x07\xde\x92\x55\x8e\x89\x55\x55\xa8\x0e\xff\x9f\xc6\xf3\xb6\x81\x67\x46\x27\x1e\xb4\x90\x1e\x8a\xf1\x48\xcf\x63\x2c\xa8\x55\x2b\xcf\x89\x5b\xe1\x46\xa4\xcd\x62\xdc\xe6\x25\x76\x48\xd6\xb3\xaf\x1d\xa1\x3f\x3b\x8e\xdb\x94\xc8\x41\x9a\x2a\xd5\x9e\xdd\x13\x7a\xc2\x32\x13\xcc\x35\x81\x6c\x02\x13\xd2\x3b\x50\xd5\xad\x0f\x78\x6e\xc7\xaa\x63\xe9\x7c\xfa\x75\xad\x16\x1f\xbc\x2a\x97\x84\xbd\x5e\x93\x53\xcb\xa5\xb5\x39\x9d\xb6\xbc\xb8\x89\xe2\xb5\x72\x7c\x32\xb5\x8f\xc2\x17\xcb\x01\xeb\xec\xc0\xc8\xb0\x0f\x4e\x01\x0d\x9a\xbd\x1e\x4b\xf6\xac\x17\x21\x8a\xe9\x94\x26\x45\xf9\x02\xa4\x28\x1f\x29\xc6\x27\x58\x01\xaf\x93\x74\x00\x1c\xf2\x3f\x7a\xc7\xa1\x20\x0e\xa6\x38\xfc\x12\x87\xaf\xe2\xf0\x51\x1c\x0e\xc5\xe1\xb9\x38\xec\x88\xc3\xfd\x71\xb8\x2d\x0e\x8b\xe2\x30\x25\x0e\xa3\xe3\x30\x24\x0d\x39\x4b\x07\xdd\x10\x87\xa9\x71\x18\x15\x87\x41\x71\xa8\x8c\x43\x5e\x1c\xc0\x1d\x07\x14\x87\xd3\x71\x38\x1e\x87\xa3\x71\x38\x18\x87\xfd\x71\xd8\x4e\x10\x60\xa0\xdc\x38\x48\x69\x80\x13\x71\x78\x89\xdc\x5a\x1f\x87\x15\x71\x58\x48\x60\x70\x73\x26\x0e\x7d\xf5\x7b\xf8\xea\xf8\x38\x0c\x8b\x43\x5d\x1c\x92\x71\x08\x65\xb5\xc4\xb7\xe6\xc6\xa1\x95\x3c\x5c\x26\x0f\xcf\x27\x2d\xf1\x53\x29\xfd\xb1\xfb\xe2\xd0\x16\x87\x16\x72\x1b\x37\x33\xd8\xee\x05\x5f\xb7\x71\xc1\xec\xd9\x79\xbf\x9d\x04\x44\xd4\xa7\x54\x46\x74\x77\xfa\x31\x92\x13\xe7\x65\x57\x5b\x4b\xc7\x2a\x19\x85\xf0\x39\xcd\xe7\xa9\x1f\x50\x73\xa6\x78\xae\x43\x4a\x54\xbb\xb2\x0e\x93\xa8\x91\x4d\xb1\xf5\x0b\x67\xff\xa1\xef\x92\x22\x52\xcc\x50\xbd\x07\x96\x77\x16\x33\xa4\x86\xa8\x4f\xe7\xf8\x1e\xde\xf8\x79\x71\x64\xbb\x3a\x10\x12\x30\xb5\xd9\x46\x99\xd2\xc5\x0c\x3b\x3a\xf4\xba\x78\xa6\xcf\x9d\x05\x28\x1f\x69\x74\x7a\x31\xde\x82\x23\x90\x4b\xb6\x50\x2e\xb6\x80\xda\xe3\xf6\x51\x7c\x02\x92\x55\x28\xa9\x91\xd6\x05\xe0\x17\xc1\x4b\x18\xde\xb3\x9f\x80\x1f\x80\x89\xfb\x5d\xde\xce\x16\x19\xf8\x2f\xd2\xf0\xd4\x2a\xa8\xc9\xc2\xff\xbe\xeb\xc2\xf8\x0f\x67\xe0\xb7\xc0\x24\x98\x86\x7c\xb2\x9d\xc0\x2f\xcb\x81\x7f\xe7\x14\x91\x26\x13\xbb\xb7\xb9\x39\xd3\xa7\x19\x98\xa2\x47\xa0\xa8\xec\xa2\x29\x2f\x5b\x40\x53\xcb\x12\x20\x27\xe0\xe7\x84\x4b\x6f\xa8\x6d\x95\x24\xd9\x2a\x88\x36\xda\xde\x89\xad\x9c\x1c\x54\x8c\xd6\xc8\x97\x86\x2d\x56\xab\x03\x45\x9c\x39\xe6\x90\x90\xef\xf1\x84\x22\xb4\x43\x60\x1c\x4c\xb2\xc4\x1f\x6b\x51\xfc\xfe\x1e\x66\x4b\xd8\xd2\xaa\xe4\x84\xc3\xa2\x93\x0e\x85\x7a\x30\x56\x7c\x57\x74\xb4\x28\x26\xd1\x79\xaa\x04\x8e\x97\xc0\xd1\x12\x38\x58\x02\xfb\x4a\xa0\xad\xe4\x02\x85\x02\x49\x15\x3d\xe3\x2c\x2a\xd5\x99\x17\xe0\xcc\x14\x0d\xec\x3c\x5f\x20\x16\xa4\x51\x32\x50\xcf\x3e\x36\xbc\xe3\x5e\x01\x62\xae\x74\x3d\xd9\xbe\x50\xd1\x9b\xfe\xb2\xba\xf4\x54\x67\x1d\xc1\x95\x7a\x6d\xc1\xf5\x05\xa5\x8b\x47\x8d\x5a\xac\xfe\x4b\xab\x2a\x78\x71\x7d\x2a\x55\x3f\xb8\x17\x5b\x3e\x8c\x7d\xb3\xcf\x84\xe0\xd9\x8b\xd2\xe5\x05\x49\x41\x8a\x3f\x85\x47\xa7\x46\x2d\x5e\xac\x3e\xdc\x7e\x2d\x7d\x7f\xaa\xbe\x3e\x55\x71\xc9\x10\xbd\xde\xc6\x6c\x84\x4c\xe7\xb0\x1c\x8e\xa3\x02\xf4\x89\xbc\x38\x12\x8d\x5a\x04\x9e\xcf\x07\x2a\x81\x0a\x0a\xe2\xce\x80\xc3\x11\x0c\xc6\xbd\x9e\xb8\x87\xb3\x58\x7a\x60\x6d\x80\x2b\x44\x90\x0f\xad\x4a\x22\xdf\x17\x70\x06\x5a\x15\x37\x39\x0d\xc7\xfc\x0b\x68\xe4\x94\x9c\x94\xc0\x6a\x6f\x4c\x8a\x99\x0b\x78\x33\xdf\xa2\x68\x35\xe5\xb4\x62\x9f\x36\x9b\x99\x46\x91\xd6\xc8\xdc\x08\x16\xa9\x91\x48\x2c\x16\x6c\x55\x62\x31\x36\xae\x05\x52\xb6\x28\xac\x71\x68\x63\xcc\x58\x76\x4a\x8b\x71\x90\x9e\xde\x49\x2d\x13\x0d\xbb\xde\xd1\x79\xda\x97\xa9\xe4\x9d\x49\xef\xd6\xfe\xa4\x67\x9a\xd8\x2c\x46\x72\xf7\x7f\x2b\x3f\x17\x73\xd1\x51\x75\x8a\xfa\xc3\x06\x41\x9d\x2d\x2c\xa7\xc7\xb6\x09\xcc\x80\xff\x5a\x8d\x4e\x3d\x09\x33\x17\xc3\x87\xc6\x04\xef\x70\x5e\xa0\x34\x1d\x7c\x4e\x6d\xd3\xf8\x3f\xd6\x33\xb4\xba\x86\x98\x7e\x0b\x08\xfd\x5e\x0f\x13\xf1\xdc\xdb\x5f\x40\xd0\xb1\x6f\x7f\x7e\x94\x16\xb4\x1d\x82\xe9\x9c\xd4\xe9\x23\x7b\xaf\x87\xbe\x57\x51\xbb\xbe\x97\x20\xcc\x16\xc0\x9d\x39\xb9\x01\xba\xcb\x5e\xea\x0e\xbf\x08\x1e\x24\x7b\x95\x80\x1f\x80\xbc\xfd\xe1\x68\x67\x8b\x0c\xfc\x17\x69\x78\xbc\x57\xc7\x60\x78\xbc\xf7\x48\x03\x39\x0c\x7f\x0e\xeb\x8f\x98\xd8\xfd\x19\x6d\x99\x67\xcc\xc0\xfb\x7b\x16\x6e\x63\xa3\x20\x8a\x37\x2c\xbc\xd5\x33\xac\x3f\x23\xbd\xe7\x70\x1b\x52\x77\x8c\xf4\xab\x44\x1f\x47\xc7\x69\x63\x1c\x56\xfc\x9c\x2b\x6c\x92\x3e\xe2\xcc\x33\x30\x3c\xdd\x9a\x05\xbf\x08\x6d\xd4\xc7\x61\x25\xe3\x40\xfb\xad\x62\x67\x0b\x03\x3e\x49\xc6\x51\xa2\x8f\x03\x95\x66\xe1\xbf\xdd\x7a\x21\xfc\x05\x64\x0c\x3a\xfe\x19\x58\xd2\x1a\x63\x10\xb5\x31\x3c\x10\xb1\xea\x2d\x32\x7c\xa3\xb3\x9e\xa3\x13\x45\xd1\x32\xf9\xb2\xa0\xcf\x1b\x0a\x49\xa2\xd5\xe2\xa2\x2d\x74\x6e\xcc\x1a\xf4\x05\x5b\xb0\x4e\xed\x8b\xfa\xea\x7c\x8d\xbe\x39\xbe\xa5\x3e\x93\x48\xbe\x2e\xf5\xed\xf5\xbd\xe6\x3b\xe6\xfb\xc9\xc7\x5b\x68\x9f\x9c\x5f\x54\xef\xf3\x09\x4e\xa7\xb7\x55\xd1\xaa\x8c\x39\x69\x52\xa7\xc6\xd2\xa2\x08\xce\xac\xfa\x8f\xe9\xaa\x41\xf3\xba\x6a\x3d\x19\x4d\xbc\x4b\x29\x48\xed\x5d\x68\x85\xd5\xa4\x4c\xa4\x56\x29\x5d\x2b\x15\x49\x4b\x5d\xea\x41\xb6\xee\x17\xf7\x5f\xf1\x98\xc0\x50\xed\xed\xdb\x5a\x60\xb1\xa8\xae\x9e\xa4\xd7\x8d\x64\xfb\x65\x15\x87\xa4\x12\xcd\x54\x61\xb0\xaa\xfd\x23\xf8\xa0\xfd\x44\x73\xfb\x49\x1e\x66\xe2\xb9\x22\x35\xad\x08\x7f\xee\x65\xf0\xe7\x03\x98\x3f\x6b\x73\xeb\xc6\x73\xfb\x7c\xa4\xd8\xda\x85\x06\xf5\x3a\x53\x64\xed\x2a\x0c\xf9\xb2\xc7\xe0\xff\x11\x3c\xb5\xf7\x45\xf3\x9c\xc1\xff\x0a\xbf\x88\x1a\xae\xcb\x97\x08\x91\x2f\x25\xfb\x23\xb1\xce\x16\x19\xf8\x2f\xd2\xf0\x98\x66\x0f\x65\xe1\xdf\x14\xb9\x30\xfe\xc3\x19\xf8\x2d\xf0\xa9\xde\x7f\x02\xff\x44\x8f\xca\x0b\xc2\xb7\x65\xfa\x33\x03\x9e\xc6\xb4\x11\x92\x25\x9a\x8a\x69\xb2\x25\xb7\x1c\xee\x2b\x8f\x90\x46\x59\x72\x05\x30\x0f\xe4\x99\xab\x98\x06\xac\x5b\x0f\x90\x8b\x4c\x56\x5b\x1b\x7d\x14\x6b\x90\x74\x39\x2d\xd3\xad\xf4\x5c\xac\xfa\x1e\xa4\x39\x84\x7f\x36\xe1\x9f\xcb\xf0\xcf\x7d\xf4\x71\x9a\xa7\x8d\x0a\xcc\x74\xba\x02\xb3\xfe\xae\x10\x01\x0a\x05\xa8\x16\xc0\x27\x00\x47\x1d\x52\x1f\x1b\x0a\x63\xd5\x9d\x0d\x30\x1a\xc6\x0d\xc5\xac\x7d\xec\x50\xaa\x55\xdd\x59\x0f\xe3\x60\x74\x83\xf6\xb3\x5e\xdd\xa9\xee\xa8\xd7\x64\xdb\xb7\x1d\xef\x98\x4c\xec\x1c\xac\x07\x46\x51\x11\x9a\x29\xd7\xfa\xe3\x81\x3c\x26\xd7\xeb\x15\x9d\xb9\x0c\xc7\xb1\x94\x4d\x72\x9a\x92\xc5\x96\x02\x4c\xaa\x7e\x2d\xfd\xd1\x63\x0a\xe4\xf9\xe3\x0c\xc5\x4a\x36\x06\xd9\x73\x05\x5b\xbd\xdd\xc2\xa0\x70\x8b\x82\x3b\x76\xfc\x59\xfc\x93\xd6\x6a\x35\x56\x18\xef\x08\xc3\x32\x8b\xbc\xa5\x2e\x53\xb7\x5f\xf7\x03\x69\x6f\xe6\x63\xf3\x0a\xb1\x5d\x98\x95\xdf\x49\xa2\xda\xa1\xb2\x10\x88\x13\xc2\xc9\xba\x7d\xa0\xa7\xe9\x51\x0f\x7c\xff\xd0\x93\x8b\xbf\x9b\xad\x55\x8b\xfa\x66\xd3\xe3\x0b\x4e\x5c\xfb\x8e\xfa\x18\x8c\x4b\x9c\x3b\x5c\x7e\xff\x15\xf7\xb5\x6f\x3d\xd7\x1a\xa3\x2b\x7a\x3d\xd0\x7a\xdf\x7f\x1e\x72\xdf\xfe\xe4\x77\x6b\xde\xd4\x8a\x45\xdd\xf6\xf8\x89\x3b\xff\xa0\x15\x0d\xa3\x47\x5d\x3b\xe9\xdc\x7b\xc3\x2e\x7b\x07\xae\x5f\x3b\x7f\x0c\xdd\x6b\x58\xf3\xbb\xea\x6d\x64\xdd\x48\x5d\x1f\x42\x47\x35\x06\xdd\x4d\xd7\x79\x46\x8e\xc6\x33\x3a\x3e\xc5\x74\x24\x65\xf1\xbe\xf3\xe0\x17\x51\xfd\x0c\x9e\xa1\x35\x78\x24\x27\x57\xea\x4a\xd7\x3a\xfc\x17\x69\x78\x4c\x77\xdf\x64\xc1\x0f\xce\x89\x5d\x10\xbe\x2d\x83\x7f\x06\x9c\xc6\x74\x84\x75\x14\x0a\x72\x35\x1e\x33\xb7\x0c\x9a\xca\x60\x62\x59\x0e\x69\x97\xa5\xa3\xe0\xb6\xa4\x3e\x08\xe9\xdb\x45\x06\x1f\xbf\xcd\x78\x96\x07\x3f\xeb\x7e\x8f\x9f\x77\x74\x3e\xcb\xa8\x91\x75\x33\xa9\xa3\x16\xd6\x72\x31\xb5\x22\xc1\x22\x67\x0a\x33\x52\x00\xf3\x28\xc9\x43\x59\x3c\x96\x9c\x48\xc8\xab\x15\x04\x16\xb9\x56\x25\x6c\x6a\xc5\xac\x2a\x4a\xfc\x67\x61\x31\xec\xf2\xd3\x92\x47\xaf\x0d\x9c\xb6\x30\x49\xa8\x04\xf1\x9e\x9e\x57\xe8\xaf\xb3\x7e\xbf\x51\xbb\xcc\x78\x6b\x43\x9c\xeb\x2c\x5f\x48\x51\xbd\xf5\xf2\x65\x50\xa2\xd7\x2c\x7b\x27\x66\x94\x31\xdb\x64\xa6\xac\xe6\x7d\xb9\x30\x55\xaf\x61\x46\x7d\xac\x95\x2e\x7b\xb9\xb3\x70\xe1\x33\x24\xbe\xf7\x0f\xa4\x2e\xd6\x36\x54\x89\x26\xcb\x55\xd6\x50\x7e\x22\x51\x84\xb0\xea\x55\xe6\x31\x99\xa2\x65\x3d\xca\xaa\x7a\x7b\x50\xaf\x1c\xa6\x44\x28\xc9\x6b\x52\x4a\xa0\xa0\x47\xa3\x52\xe0\x11\x9c\x4d\xca\xfb\x36\xe8\x6f\x03\x9b\x4d\xd0\x03\xf0\x27\x76\x7b\x0b\x58\x67\x80\xb8\xa6\x71\x57\x54\xa4\x4b\xd3\x6b\xe1\x77\xba\x6e\xdd\x3d\x40\x41\x4a\x18\x2f\x73\x20\x25\x0d\x0d\xb3\x97\xb3\x53\xd4\x23\x7d\x06\xcb\xfd\x5f\xdc\xd5\xff\xd6\x48\x5e\xa9\xd9\xd9\x98\x1a\x3d\xb9\x5f\x5d\x5d\x7f\x28\x13\x87\x0f\x3f\x94\x7c\x53\xfd\x13\x77\xf7\xde\xbc\x4f\x9e\xb9\x7f\x9d\xb4\x62\x46\x7f\x9a\xab\x56\x6a\x2a\x17\x36\x3c\xfa\x72\xd0\x73\x70\x52\xb8\x60\xd1\x94\xbe\xad\xa9\x8a\xd9\x83\xc1\x57\x73\xf9\x45\x93\x86\x9f\x3b\xfb\x44\x69\x80\x3e\xf6\xf2\xeb\xab\xee\x1b\x32\xce\x5e\x3a\x06\xaf\x3f\xc9\xc1\x66\xef\xc2\xeb\x3f\x08\xaf\xbf\x09\x5d\x8c\x95\x32\xcb\x73\xd4\x84\xdc\xb8\xa0\x2f\xbc\x01\xf3\x41\x06\x46\xa3\x11\x2b\x22\x50\xff\x8e\xe6\x19\x50\x08\x65\x70\xad\x4b\xc3\x61\xd9\xb8\x4b\x87\x5b\x1d\x8d\x77\x87\x3b\xc3\x5e\x95\x81\xdb\x82\x8e\x6a\x61\x85\xb2\x99\x6a\x2a\x82\x27\x8a\xaa\x08\xec\xc4\xaa\x2c\x9c\xa9\xcc\xb3\x67\xa0\xa7\x30\xac\xed\x79\x9a\xda\xd4\x2b\xaa\x23\xad\xea\x84\x7b\x3b\x83\x73\x33\x3a\x64\xc0\x6d\x4f\x64\xe0\x10\x8d\xea\x3a\xbe\x63\x7b\xd0\x6f\xa1\x18\x96\x31\xb5\x68\x82\x5c\x56\x63\x32\x49\x85\x39\x45\x85\xb4\xb7\xa2\xc2\x82\xca\xbc\xc8\x7b\x51\x5f\xa6\xa6\x51\x61\x18\x5b\xb0\x2a\x19\x4c\x36\x29\xd1\xa0\x94\x27\xf1\x36\x7e\xa4\xe2\x32\xdb\x90\xf1\xea\x93\x54\x26\x2d\x35\x2b\x03\xd7\xe0\x51\x99\x53\x7c\x3b\x70\xfa\x69\x27\xc9\x59\x28\xec\x92\xc4\x42\xb2\x10\x2b\x7a\x63\x46\x26\x55\xa7\x6b\xdb\x19\xa9\x4e\xfd\x81\xed\x71\xeb\xd9\x87\xf8\x17\xae\xbb\x23\xe7\xc5\x27\xae\xbe\xa1\xb8\x69\xe7\xe0\x19\x2b\xd7\xa3\x8e\x07\xfb\xff\xae\x68\xe2\x5d\x0b\x96\x9d\x6b\xe9\x39\xbf\x92\xdf\xad\x8c\x19\xff\xf0\xe4\x66\xba\x77\xaf\xf2\xf1\x2b\x63\xbb\x5e\xa0\xe9\xf1\x1b\xaf\xb2\xf6\xae\xfb\x68\x4a\xf1\xb6\x11\xca\x88\x71\x2f\x3d\xb0\x1b\xca\x77\x25\x23\x0d\xd3\xdb\xad\xfd\x2b\x6a\x12\x50\xf8\xe9\xc0\x36\xf5\xdc\x2d\xb3\xaf\xa3\xb6\x54\xf5\xfb\xf3\x21\xc7\x16\x3c\x6f\x75\xea\xe5\x5a\x3e\x38\x9e\xb7\x21\x64\xfd\xaf\x8f\x1b\xda\xe1\xaa\xfd\xb9\x21\x93\x4d\x5f\x34\x0d\x4e\xcb\x53\x26\x34\x50\xaf\xd3\x49\x1d\x59\xd9\xd1\xf1\x02\x07\x4a\xd3\x89\x06\xf3\x69\x06\x46\xa3\x13\x87\xae\x6b\x52\x10\xdb\x9f\x97\xd0\x01\x0d\xb8\x35\x84\x4e\xea\x0d\x3a\x59\xab\xd3\xc9\xfa\xbc\x34\xb6\xcc\x33\x1f\x22\x6b\x5f\x6f\xac\xfd\xa3\xc6\x9a\x1e\xa8\xcc\xd3\x01\xc9\x73\x67\xe1\x8d\xfc\x2d\x79\xee\xbf\x0d\x9d\x6f\x38\xc1\x07\x11\xc1\x4a\x43\x27\x3e\x2d\x1f\xf0\xfd\x0c\x9c\x09\x2d\xb2\x10\xa8\x8f\xb1\xb6\x04\xe9\x31\x5c\x8c\x61\xee\x25\x7d\x23\x30\xd4\xaa\xfb\x08\xcc\x68\xde\xda\x09\x33\x19\xc3\xac\x25\xfd\xd2\xf1\xcc\xb8\x4f\xeb\x15\x05\x57\x06\x79\x1d\x48\xe7\x95\xa8\x4f\xc7\xd7\xf4\x17\xec\x76\x12\x8f\x37\x55\xee\x93\x6b\xb2\x16\x16\xa2\x80\xd7\xee\x60\x44\x9f\x0f\x21\x97\x68\x62\x8a\x93\x76\x47\xc0\xab\xfd\x76\x8b\xa2\x16\x66\x89\x19\xa5\x1b\x59\xcd\x61\x73\xb8\x49\x31\x8b\x74\xbc\x49\xd1\x52\x7c\x3a\xc3\x9a\xeb\x30\xab\xec\x53\xe6\x48\x95\x39\x7d\x99\x02\xfb\x59\xa1\x06\x20\xa1\x58\x3a\x25\xcd\x57\x50\xc8\xd6\x81\x56\x3f\xc0\x97\x10\xc1\xeb\x64\x3b\xdf\x99\xa9\x79\xd7\x5e\x53\xbf\xe9\x40\x8f\xfd\x61\xcd\xbf\x1f\xb8\x7a\x6c\xce\x34\xf5\x45\xc7\x59\x65\xb6\x7d\xf7\x62\x28\x70\x7c\xd2\x32\x5d\xfd\xdd\xd8\x07\xc7\xcd\x9c\x34\x76\xd3\xb8\xe9\xd4\x3d\xea\x0b\xea\xe6\x3f\xee\xda\x00\xec\xdd\xe5\x7f\xbc\x76\x77\xeb\xf2\x86\xfc\x11\x25\xca\xe6\x49\x0b\x2e\x53\xff\xe8\xb8\xf9\xeb\xdb\x96\xaf\x5d\xfe\xf7\xe5\xab\xd6\xea\x73\x7c\x09\x79\xa7\x90\xb6\xb7\x47\x1a\x7b\x7b\xa7\xbe\x16\xcb\x0a\x2a\x78\x5f\x36\x0f\xd0\xde\xf5\xa3\xad\x45\xb3\x4e\x4f\x97\x11\x0a\xe8\x93\x93\xeb\xf0\x77\xf2\x9d\xef\xe9\xbf\x66\x60\x34\x7a\xf2\xea\x74\xf2\x73\x38\x6a\x40\x65\xe1\x5a\x97\x86\xc3\xf4\x74\x9f\x0e\x37\x33\x9c\xdb\x1d\xee\x24\xe9\x5b\xb3\xd1\xb7\xd7\x74\xb8\xbb\x0b\x2a\xce\xc7\x97\xca\x3c\x77\x06\xda\x61\xd0\xdd\xaa\x9e\x61\x1d\x90\xf0\x92\x85\xe8\x1d\xa6\x94\x59\x49\xde\x8f\x12\x42\x0d\x72\x11\x66\x8b\x4e\x93\x29\x18\x08\x06\x72\xc2\x1e\x71\x8f\x82\x3c\xb2\xa7\xc9\xd3\xea\x61\x04\xda\x43\x0b\x7b\x14\x0f\xb6\xea\x83\x4f\x2a\xa1\xbd\xfa\xd9\xe6\xef\x53\xe9\x6a\x98\x5d\x9c\x33\x5d\xe3\x7f\x1c\xd9\x59\xcb\xda\xe1\xe1\xbe\x9a\x1e\x45\x35\x35\x45\x3d\x6a\xd2\x9f\x70\xe3\xb9\xa1\x4c\xa1\xf6\x1b\xff\x7f\xee\x2f\xc6\x17\xb8\x7d\xea\x54\xac\xa7\xfd\xa3\x63\x37\x13\xa0\x55\xac\xa7\x45\x50\x21\x1a\x2d\xf7\x8a\xe5\xe4\x85\x99\x60\x34\x2a\x3a\x83\x19\x3d\xad\xa8\x47\x2c\xec\xcd\xb7\x78\x1b\x15\x43\x3d\xb3\x48\x28\x1f\x53\x1e\xf2\xb6\x15\xe9\x05\xa6\x51\xba\x9e\x95\x91\x5e\xf6\x5b\x2a\x59\xef\x4e\x95\xcc\x44\x13\x7a\xf3\x41\x81\x0b\xeb\x66\xfa\xab\x5a\x77\xad\x9a\xb0\x78\xe6\xe3\x23\x6f\xff\x79\xc3\xed\x13\xaf\x9d\xf6\x68\xe3\xed\x3f\xc3\xf8\x87\xc6\x59\xe1\x64\xe5\x44\x8b\x1a\xa8\x9c\x3e\x7e\xcb\x04\x77\xfd\xaa\x83\x33\xda\xb4\x2c\xc9\x61\x2b\x5e\x99\xb6\x45\x4b\x94\xa4\xef\xbc\xe3\x3f\xf7\x0e\xaa\xa4\x7a\x4e\x56\x3f\xaa\xc3\x46\xc3\xf8\xb5\xa7\xc9\x3a\x91\x3c\x2e\x42\x1f\x63\x75\x1a\xaa\x21\x52\x04\x5a\x72\x40\xca\xc9\x75\xe9\x9e\x1c\x03\xee\x95\x0c\x9c\x66\xe3\xfd\x3f\x9d\x26\xdf\x0e\x47\x5d\x7c\xe7\xba\xeb\xf8\xd6\xa5\xe1\x30\x1d\xdd\xae\xc3\x35\x87\x73\xcf\x87\x4b\x65\xf0\xcd\x40\x1b\x91\xce\x01\x66\xf7\x0c\xeb\x80\xc4\x56\x24\x39\x36\xe4\xb9\x13\x8c\xe7\x1e\x30\x6c\x6f\x48\xec\xcf\x8d\x7b\xac\x04\x25\xd5\x31\x57\xcb\x01\x65\xd7\x6a\x39\xa0\xb0\x43\xee\x88\xb0\x6c\x41\x22\xdf\xef\xb3\x22\xbb\xdd\xed\x72\x25\xbc\xee\x46\xc5\x8b\xec\x2e\x87\xab\x51\x71\x84\x84\x60\x93\x82\x95\x8e\x18\x15\x6b\x56\x28\x69\x61\x01\x4c\x2e\x00\x68\xc2\x26\x74\x01\x96\x1e\x90\x5f\x00\x52\x01\xa0\x02\x38\x5d\x00\xc7\x0b\xe0\x68\x01\x1c\x2c\x80\x7d\x05\xd0\x56\x00\xeb\x0a\xf0\x1e\x04\xdc\xa0\xb5\x00\x46\x9d\x07\x3f\xfd\x14\x69\xf0\x11\x69\xb0\xbf\x00\xb6\x17\xc0\xfa\x02\x58\x41\x1a\x4c\x21\xd0\xb9\x05\xe0\x2e\x00\x86\xa0\x3e\x41\x20\x0f\x9d\x07\x86\xf1\x0e\x22\x78\x75\x60\x94\x06\xd6\xc1\x96\x9d\x07\x86\xb1\xf5\x39\x91\x46\x31\x85\xfc\x3e\x21\x17\x12\xcc\xd9\x68\x07\x91\x2b\x78\x0c\x94\x3e\x08\xbd\x37\xc6\xd9\x57\xb6\xeb\xf4\xbc\xe3\xac\xdf\x38\x11\xfb\xad\x18\xbe\x96\xac\x53\xe8\x6e\x15\x42\x52\xc6\x31\x48\xba\x3a\x48\x56\x36\xad\x91\x65\x4b\x7c\x3c\x5d\x6a\xb5\x5c\xf9\xfc\x9d\xcb\x36\x3e\xa8\x9e\x6e\x2b\x9f\x1c\xb0\x54\x90\x2c\xdb\x25\x50\x76\x2b\x0f\x65\xdf\x5d\x34\x63\xe6\xae\x19\x93\x9a\x7b\xaf\xaf\xa3\xdd\x4f\x69\xa5\x5a\xde\xdf\x67\xe7\x8d\x2c\x5b\xd3\xb3\xfe\xd2\x33\x5f\x94\xdf\x0d\xfc\xea\xd9\x37\x0e\xaf\x43\x9d\xb4\x94\x32\x68\x09\xcb\x9c\x99\x3a\xc5\xfd\xb5\x22\x57\xa7\xa3\x2e\xfe\xca\x41\x19\x1f\xe7\x1a\xb8\x24\xcb\x27\xfa\x83\xcb\xd3\xd5\x27\x4a\xf4\xa6\x8f\x98\x5f\x32\x7a\xd3\x1a\xb4\x57\xe7\x89\x0f\x46\x63\x59\x3a\x9b\x81\xf7\xad\x0c\xde\x8d\xd0\x37\x0b\xaf\xea\x8d\x5e\x00\xef\xcb\xec\xe2\x0c\xde\x8d\x68\x93\x8e\xf7\x91\xbc\x64\x17\xbc\xea\x2c\xed\xdd\x29\x19\xbc\x0f\x51\x4f\x6b\x7b\x09\xeb\x0c\x1d\x7b\xf6\x87\xc3\x1c\x97\x30\x64\x81\x3a\x4b\xab\x15\x94\xc1\xf7\x10\x2c\xc2\x70\xe6\xe7\x28\x47\x61\x21\x4d\x27\x88\x5e\x41\xde\xe1\x41\x6c\x99\x02\xc3\xce\x1a\xa1\xdb\x65\x51\xe2\xcb\xa9\xdb\x1f\xcd\xcb\xf6\xe5\x10\xfd\xe2\xf7\x64\x7f\x0e\x31\xe4\x0b\x4a\xef\x4f\x66\x7f\x28\xa2\x6b\x3f\x19\xbc\x5f\xa4\xf1\x62\x7b\xec\x45\xc3\x46\xd2\x10\x6f\x8b\xc6\xbb\xfa\x7c\x08\xde\xcd\x84\x8f\x0c\x31\xf8\xc8\x16\x5d\xbf\xd5\xea\xb7\x6f\x08\x45\x09\x62\x43\xbf\xd5\x71\x6f\xcc\xe0\xde\x04\x7f\x33\x70\xe7\x61\xdc\xef\x25\xa2\x17\xc0\xbd\x98\xf8\xf3\x74\xdc\x9b\xd0\xd3\x3a\x8f\xda\x13\xcb\xa8\x6b\xe8\x02\x7d\x5e\x0d\x69\x3f\x58\x3e\xc6\xfb\x75\x41\xde\x05\xf0\x7e\x9a\xd5\xe7\xd5\xe8\x4f\x3a\xde\x0f\xf3\x22\x59\x78\x75\xdf\x14\xc1\x5b\x68\xe0\x4d\xfb\x5c\xb0\x6d\x4a\xfd\x3e\x1a\x72\x5a\xbb\xe0\xed\x8f\xf5\xed\x16\x76\xad\x54\x80\x86\x6a\xf0\x02\x4d\x9f\x45\x4d\xc8\x89\x75\xfd\x14\xa2\x56\x94\x97\xb3\x2c\x01\xaf\xab\x4a\xe3\x66\xfb\x39\x4d\xe8\x9e\x4c\xdd\x9f\x91\x98\x2f\xe6\xa0\x24\x5a\x22\xd7\x25\xfc\x9c\xd3\x69\xb1\x9b\xcd\xa2\x5f\x2c\x29\x75\x25\x23\xc9\xb0\x87\xb6\xdb\x19\x93\xc5\xc2\x32\x6c\x13\xd6\xd8\x85\x70\x38\xd6\xa4\xa0\xb0\xe4\xe9\xd1\xac\x78\xbc\x4e\xb1\x51\x71\x9a\xcd\x82\xc0\x35\x2a\x02\x4a\xa7\x17\x97\xa5\x4d\xb5\x54\xf6\xfb\x20\x32\xf1\xe3\x8e\xac\x2c\x95\xb4\x52\x55\x07\x55\x24\x10\xbf\x3a\x46\xf2\x8d\xff\x7b\x4d\x20\x8b\x5d\xfd\xb3\x08\x3d\xc2\x5a\x65\xa0\x1e\x0b\xc5\x85\x2f\xfc\xb7\xea\x40\xcd\x97\x33\xa3\x36\xfb\x4b\xbf\x1c\x75\xf6\xc7\x0b\x57\x08\xea\xf4\x83\x0e\xca\xf8\x4e\xd7\x40\x73\x96\x6f\xf6\x8b\x70\xa4\xab\x6f\x96\xac\xe5\x76\xb2\xa7\x89\xae\x4e\xad\x59\xaa\x6b\x39\x79\xf9\x19\x5d\xdd\xc0\xf9\x56\x06\xe7\x46\xe8\x9f\x85\xf3\x64\xb4\xc7\x05\x70\xae\x21\xfb\x59\xc7\xb9\x71\x06\xc1\xb9\x29\xd1\xb3\x3b\xce\x8d\x19\x9c\x9b\xe0\xca\xac\x7d\xf2\x8f\xbc\xf0\x05\x70\xb6\x10\x5a\xae\x37\x68\xf9\x41\x9d\x47\xb4\xf5\xc8\xcb\xb2\x03\x3a\xbe\xc1\x3c\xe2\x0d\x4c\x17\x69\xbc\x0f\x69\xaf\x8b\xd4\x78\x04\x74\xcc\xdd\x9f\x48\xf8\xfd\x06\x8f\xa8\xc3\x3c\xa2\x85\xd8\x32\x3a\xbe\x87\xd0\x27\x86\xfd\xd1\x51\xbc\x3f\x99\xb4\x58\xba\xf8\xba\x3b\x7d\xd1\xab\x61\x82\xd1\xcf\x98\xb6\x37\xe2\xd1\x0b\xf4\xf3\xc1\x2c\x7b\x65\x35\xba\xcb\xe8\x67\x51\x22\xdb\x5e\x21\xef\x29\x21\x78\x8b\xbb\xf1\x09\x6d\x2f\xdf\x9e\x57\x40\x87\xbb\xe0\x25\xf5\x87\x08\xde\x06\x83\x4f\x6c\xd3\xf1\xde\x57\xda\x2b\x3f\xa7\x3b\xde\xb7\x32\x78\x37\xc2\x27\x59\x78\x8f\x26\x7a\x5e\x00\xef\xdb\x64\xad\x1a\x0c\xde\xfb\x98\x8e\xf7\x50\x79\x9f\xf3\xf1\x6e\xcc\xe0\xed\xe4\x3d\x09\x8c\xf7\x99\x1e\x79\x17\xec\xef\xf0\x0c\xde\x34\xef\xa1\x1e\x4b\x95\x76\xc1\xab\x0e\xd7\xde\xd7\x92\xc6\xcb\xff\x1e\x4e\xa7\xcf\x1c\x36\xee\x4f\x18\x58\x33\xf8\x8e\xa4\xf1\x09\x0c\xc5\xeb\xf8\x3e\x2e\x2d\xcf\xc2\xa7\xbf\x33\x85\xcc\x6b\xb2\xdb\xbc\x6a\xb4\xba\x3a\x9c\x8b\xec\x5d\xfa\xa9\xbd\xc3\x92\xe5\x24\x0c\x3f\xac\xa7\x0e\xcf\xc1\x32\x0c\x6f\x86\x1c\x0a\xf6\xe7\xc4\xc2\x22\x01\x97\xbe\xa8\xd4\x7d\x5a\xe9\x77\xb2\xc4\x31\x4f\xfb\x83\x3c\xc7\x56\x50\x98\xcb\xc4\xcc\x56\x6b\x2c\x46\x9b\x28\x9e\xe3\x28\x7b\x22\x3f\xca\x44\x24\x51\x8c\x44\xfc\x1e\xb7\x3b\x40\x05\x90\xd3\x59\x84\x7a\x84\x9d\x0e\x3a\xe1\xa7\x0b\x6c\x05\x2d\x8a\xc7\x6e\xb2\x45\x73\x0b\x73\x5b\x95\xfc\x42\xd1\x16\xb5\x95\xd9\xb6\xda\x18\x41\x2c\xac\x2b\x6c\x2c\xa4\x2d\xb4\xad\xd0\x56\x28\x20\xb7\xa8\xd7\xda\x15\xe8\x58\x24\xd0\xa5\x14\x79\xca\x08\x7c\x4b\x65\x9d\x38\x4d\xca\x1c\x38\xa5\x32\x87\x7c\x99\x97\x6d\x66\x71\x28\xc3\xfe\x4b\x9f\xf0\x11\x95\xdc\xf0\xd6\x93\x77\xcc\x53\x31\xfd\xc3\xe0\x5d\xc6\x2b\x5e\x00\x73\x33\x2f\xbf\x6f\xc3\x6e\xfb\x93\x85\xfa\xab\x5e\x0a\xa9\xc5\xfa\xb7\xa7\x0b\x77\xd9\x77\x6f\xc8\x7e\xdd\x0b\x35\xbc\xb0\x7d\x75\x61\x55\x88\x9e\xd5\x7c\x4c\x73\x9e\x1d\xd3\xff\x36\x9f\xbb\xb7\xf3\xb5\x2f\xd4\xb1\x2f\xbe\x40\xd9\xb5\xa7\xf2\xd1\x8d\xf2\xa0\x40\x38\x5c\x90\x67\xb3\xf0\x5c\x3c\xae\x95\xe0\x41\x42\xbe\xd7\x95\xef\x4a\x14\xe4\x7b\x8c\x8a\x30\x51\x29\xda\xac\x20\x8b\xcd\x92\x63\xa1\x04\x86\xb7\x60\xbb\x83\xe7\x39\x49\x62\xfc\x16\xa9\x9e\x63\x1a\x15\x8e\xe4\x36\x27\x49\xfe\x23\xb6\x98\x5a\xd2\xd3\xd2\xa5\x02\xa0\x91\xe2\x5b\x91\x0e\x56\xd1\xab\xd9\xea\x13\x40\x98\xf6\x6f\xd6\xab\xb2\x2d\xb1\xdf\x10\xd2\x6a\x56\x15\xfd\x8f\xf8\xe7\xd4\x05\xeb\x56\x31\xe3\x9a\x35\x26\xdd\xac\x1e\xbb\x70\xed\x2a\xe3\x9c\x67\xaa\xe9\x99\xcc\xb9\xd0\x16\x74\x51\xd6\xb9\xd0\x7d\xde\xee\xf2\x56\xf3\x33\xfc\x8b\xd8\xa2\xba\x9f\x61\xcb\xdb\x44\xda\xde\xe6\x8c\x64\xfc\x0c\x04\xe7\x65\x84\xef\x97\x18\xba\x59\xcf\x2c\x9c\xf7\x5b\xed\xdd\x70\x36\x61\x9c\x9f\x12\xbe\xaf\xe3\x5c\xf3\x34\xc1\xb9\x94\x37\x77\xc7\xf9\x56\x06\xe7\x46\x54\x41\xce\xb3\xdd\x04\x67\xab\x08\x4d\x22\xc8\x22\xbc\x20\xfa\x09\x72\x2d\xfe\x03\x75\xf5\x9f\x2c\xce\xe0\xdf\xb8\x8f\xe0\xdf\x64\x71\x67\xe1\x57\x67\x69\xef\xfd\x31\xf0\x9b\xa8\x87\x3e\x37\x38\xf5\xc7\xfb\x3d\x1e\x84\x12\x69\x5c\xb4\x3a\x4b\xab\xf5\x85\xf5\x82\xe1\x3a\xdc\x6a\x84\x4a\x65\x6f\xa1\x1c\x0a\xd5\x17\xca\xc1\x20\xfe\x13\x08\xe0\x3f\x4e\x67\x3d\x15\xd6\x22\x47\x04\xab\xbd\xde\xa5\xbd\x3f\x35\x91\x4c\x56\x25\xf1\x3f\xd9\xe7\x7d\x1b\x33\xe3\xd9\x84\x06\x18\x73\x24\xe2\xf1\x6c\x75\x5a\xb3\xe7\x48\xaf\x09\x05\x2f\xd3\xbb\x11\xa7\xbd\xd1\x54\xaf\x2e\x66\x14\x84\x12\xbb\x56\x98\xcc\x7a\xa3\x69\x97\x0a\x50\x1b\x8c\x0a\x50\x5a\xed\x16\xed\xf9\x1d\xdf\x9b\x9a\xd8\x7e\x52\xfa\x7c\xaf\x94\x5a\x80\x9f\x53\xf1\x02\x8a\x75\x1c\x7c\x06\x77\x3e\xa6\x65\xba\xd8\xed\xe4\x53\x76\xd8\x6c\xf5\x70\xc4\x0a\x7b\xad\xd0\x6a\x05\xd9\x0a\x56\xd0\x22\x6c\x26\x6a\xe3\x21\x67\xb5\xc3\xe9\x23\x99\x39\xe1\xd0\xa5\x80\x89\x02\x5d\xf4\x02\x4a\x69\xd5\xf3\x70\x5b\x9a\xfa\xc9\x0b\xaf\x79\x61\xaf\x17\xb6\x92\xea\xd5\x65\xe9\x8a\xec\x5e\x40\x5a\x05\x2f\x2d\xf2\x87\x04\xed\x90\x7f\xaa\xaa\x92\x64\xae\xa3\x1d\xdf\x33\x41\xc2\x3f\x4b\x0d\xfe\x19\x36\xce\x5e\xb5\x73\xb5\x72\x37\x9c\x76\xfb\x2d\xd9\x67\xaf\x46\xdd\xb3\xad\xec\x3a\xc4\xa3\x20\x5a\x24\xe3\x27\x73\x1c\x62\x7c\x7e\xbf\xdb\xe2\x42\xae\x10\xc3\x84\x51\x18\x6c\x34\x31\x4d\x49\xb1\xbf\x49\x56\xb0\x5b\x23\xd6\x9e\xd6\x3d\xd6\x57\xad\xac\x55\x7b\xa9\x59\x88\xe2\xd6\x2a\x3c\xb5\x7e\xbc\x49\xe4\xa3\xfc\x5e\xfe\x08\xcf\xf0\xa8\x6c\x62\x2a\x99\x29\x12\xa1\xbf\xdf\x07\xc8\x8e\x36\xea\x5b\x65\x2a\x5b\xe9\xd1\x87\x2e\x2e\x5e\xc8\x9e\x5f\xee\xac\x91\xfd\xee\xe3\x35\x6c\xd9\x9f\xd4\x7f\xfd\xf1\xfc\x62\x67\x5a\xa0\xa2\x43\xfd\x29\xf6\xfc\xf3\xff\xf9\xb1\x6b\xb1\x33\xa2\x4b\x0c\xd7\xde\xcd\x84\xe7\xa2\x27\x56\xc9\x35\xd9\xf4\x3d\x99\xa3\xbe\x78\xee\x31\xcf\xc2\xd7\x47\xe8\xd7\xd1\xdf\x09\xbd\x90\x9a\x68\xa4\x86\xc4\x0c\xb9\x36\x5d\x13\xcd\x62\x65\xcd\x66\xab\x8b\x76\x7b\xdc\x16\xa0\x2c\x60\xa7\x33\x25\xd1\x48\xbc\xa3\x27\x53\x18\xcd\xa8\x8c\x26\x66\x6a\xdb\x64\x18\x17\x29\x83\xa6\x17\xf6\xca\xbc\xaa\x2e\x65\x94\x40\x73\x5d\xa0\x04\xda\x27\x5a\x05\xb4\x31\xe7\x57\x40\xa3\xaf\xf6\x97\xaa\x81\xf3\x2b\xa0\x19\x7a\x8e\x93\xd8\x43\x65\x86\xff\x61\x9f\xb1\x37\x24\xbc\xee\xf7\x48\x2e\x8e\xed\xc2\x3f\xf0\xde\xa0\x1d\x9c\x88\xe1\x1b\x0d\xf8\x61\x86\xdc\xb4\x99\xe0\x07\xde\x42\x73\x59\x72\x53\x9f\x4b\xed\x7d\x4f\x3a\x7e\x32\x97\x97\x13\x3c\x32\xa6\x1d\x2b\x99\xcb\x46\xad\x5a\x00\xff\x7b\x7b\xe7\x79\xfe\xbd\x69\x78\x62\x0b\xe0\x4f\xe4\x7e\x06\x72\xb5\xe0\xb0\xb3\xfb\x73\x72\x6c\xf9\x86\x35\x90\xe9\xcf\x0c\x62\x3b\x34\xea\xf0\x94\x49\xb7\x1d\xc0\x8f\x60\x95\xc7\xc3\x71\x9d\xb6\x83\xf1\xee\xa9\x74\x5f\xb0\x2e\x73\x7d\xfb\x6b\x18\xc7\x30\x4c\xcc\xff\xd0\x71\x7c\xa1\xf3\x87\x87\xdb\x5f\x23\x73\xd0\x62\x87\xad\x98\x92\xec\x60\x27\x9b\x50\xe7\x0f\x99\x77\x58\x69\xb5\x2d\xfb\x3a\xec\x36\x97\xd3\x69\x43\x34\xe3\xf1\xf9\x18\x06\x04\xd1\x66\xf3\x0b\x24\x43\xb8\x45\xb1\x3b\x68\xc4\x88\x80\xff\xc5\xfc\xcf\xc2\xb4\x2a\xda\x8b\x00\x4e\xf1\xd0\xc4\xb7\xf2\x14\x6f\xd4\x0d\xe1\x79\xf2\x66\x00\xad\x42\x43\x52\x4f\xe1\xef\x53\x56\x66\x14\x86\x37\x4a\x47\x39\xfb\x74\x46\x8f\xa4\x4b\xe0\x25\x38\x96\xee\x7c\xbf\x15\x97\x79\xc7\xd5\x27\x30\xca\xa1\xee\x9e\xdc\xf9\xa6\xab\xc6\xf7\xa4\xc3\xf3\xf4\xb7\x5d\x51\xc7\x9f\x99\xf4\x4c\xfb\x47\xc6\x3b\xaf\xe0\x8d\x6b\x5a\xff\x3f\xd2\xde\x04\x3c\x8a\x22\xfd\x1f\xef\xea\x63\x7a\xee\xe9\xb9\xef\xfb\x4a\x32\x99\x5c\x43\x32\x04\x08\x19\xee\x9b\x1c\x06\xa4\xb9\x12\x0e\xe5\x56\x01\x05\xf1\x42\x45\x14\x04\x14\x44\x94\x43\x11\x50\x39\xbc\x00\x05\x74\xd5\xc5\x13\x3c\x59\x44\x74\x75\xd7\x5d\xd7\x73\x77\x55\x74\xd5\x75\x5d\x05\xd2\xf9\x57\x55\x77\xcf\xf4\x24\xb8\xbf\xef\xf3\xfc\xf5\x01\x63\xd2\xa9\xa9\xb7\xba\xea\xbd\xea\x7d\x3f\x9f\x79\xe4\xf5\x12\xf1\x15\x40\x88\x0d\xe4\x4c\x68\x93\x4d\x08\x0f\xd2\xa0\xd7\xc3\xbd\x49\xd0\xb4\x4e\xa3\x06\x2c\x6b\xe6\xe0\xbb\x25\x68\x0d\x80\xff\x1a\x59\x84\x2c\x64\x04\xd8\xf0\xda\xbb\xf5\xc5\x89\x39\xe7\x42\x41\xa8\x6c\x67\xb3\x22\xa7\x95\x3c\x51\xb0\xfe\x3d\xee\xbd\x69\x48\x59\x4e\x3e\xce\x1d\xbf\x09\x29\x4c\xf2\xed\x85\x53\x17\x76\x7e\xe8\x4e\x93\xc6\xd9\x1d\xb3\xc8\x8f\x5c\xe9\xfc\x7d\xff\x5f\xe5\xfb\x7e\x18\x7f\xff\x4b\xda\x9f\x48\x2f\x9d\xb3\x39\xbb\xdd\xf7\xa3\xdc\xf2\x4b\x38\x5e\x6f\x91\xf6\xe7\x39\x31\x46\xfd\xc4\x17\x54\xe4\x96\xbb\x7e\x80\x67\xfc\x30\xde\x0b\xd5\x92\xff\xb9\x45\xf6\x3f\x3f\x3b\xe4\xb4\x19\x55\x92\xff\x39\x02\x9d\x79\x1c\x2f\xb4\x48\x67\xfe\x3b\xf1\xf7\xf1\xbc\x3e\xce\xd7\x21\xac\x06\x0f\x4b\xf3\x72\xc3\x79\x3d\xe9\xbd\xd0\xbc\xc4\xd8\xb9\xa5\x38\x76\x3e\x14\x55\xce\x0b\xea\x52\x82\x1e\xc1\xb4\x72\x49\xf8\xdc\x76\xf4\x24\xfb\x85\xf0\x01\xfc\x51\x22\xe7\x06\x4d\x3e\x00\x35\xaa\x0f\xd5\x7f\x7e\x42\x80\x17\xc5\x12\x50\xa9\x0a\x74\xca\x42\xa4\xd3\x45\x8e\xb5\xaf\xba\xce\x30\x7d\x99\x61\xd0\xb3\xbe\x3e\x17\x0e\x06\x02\xfe\x88\x33\x1c\x76\xbb\x5c\x94\x5f\x67\x36\x97\x26\xfc\x09\x6f\xb9\xa9\x1c\xb8\x29\x6f\xca\x69\x8b\xd9\x9e\x01\xee\x9c\x9f\x8f\xc4\xe8\x70\x38\x14\x0a\xb4\xf3\x21\xca\xe5\xf7\xfa\xdb\x79\xaf\x85\xd0\x74\xa0\x1e\x1b\x2b\x06\xb5\x51\xa4\xba\x44\x00\x2e\x69\x7b\xe2\xce\x35\xe9\x22\x53\x64\x34\xcb\x57\x3f\x33\x0a\x72\x3c\x6b\x7f\x4a\x76\xa7\x0a\x70\x73\xb1\x4c\xc8\x6c\x63\x29\x92\xea\xaf\xe0\xcb\xbb\x82\x52\xab\xe8\x59\x33\x2e\xfa\xf0\x8a\x23\xab\x35\x82\x4a\x83\xc8\xce\xc0\x3c\x27\x70\x1d\x05\xfd\x6c\x4d\xcd\x36\x89\x45\x8f\xbc\xdc\x9a\x86\x61\x39\x3f\xb9\xa1\xf7\xb9\x3c\x25\xe4\xda\x7b\x84\x7f\x0e\xbf\x5a\x18\x20\xf4\x43\xeb\x82\xde\xdd\x16\xea\x18\xf4\x31\x67\xe6\xb2\x41\x57\x20\xe0\x76\x7b\x59\x8f\xc9\x62\xa1\xa0\xc1\x8a\x27\x4c\x89\xca\x44\x53\xe2\x64\x82\xd6\x50\x41\x97\x3d\x62\x6f\xe5\x23\x1c\x06\xa1\x33\x79\xec\x6e\x46\xdf\xcc\xab\xd5\x08\x42\x2f\x83\xab\xab\x15\x10\x84\xa0\x9b\xc8\x35\xf2\x89\x44\xa2\x84\x15\x76\xa8\xe0\x40\x2a\x80\x15\xb7\xb8\x17\x0c\x12\xbe\x29\x58\xa4\xa5\xce\x9e\xf0\x84\xe4\x8f\xb1\xdb\x3b\x37\x09\x8b\x45\xcb\x44\xee\xb8\xdd\x57\x0c\x53\x98\xaf\x0b\x19\x9c\xaf\x23\x59\x03\x0e\x2a\xea\x4e\x36\x06\x42\xdd\xea\x48\xd0\x7d\xc5\x5b\xd8\xef\x6b\x95\xfc\xc4\xdd\x62\x1c\x75\x9b\x2f\xa0\xbc\xd7\x10\xc7\x3d\x96\x1f\x77\x2b\x78\x5c\x31\xee\x13\xe1\xb2\x0b\x8c\xfb\x0a\xf6\xf7\x5a\x25\x5f\x71\xa7\x74\x4f\x1b\x0a\x82\x9d\xc1\x12\x3c\xb6\x94\xc7\x12\xc7\xfe\x31\x3f\xf6\x03\xa0\x0b\xfb\x18\x06\x0a\x0d\x4e\x91\x7f\x0c\x24\xc5\xd1\x15\xb5\x07\x70\x7c\x7a\x28\xf3\x50\x7e\xfc\x07\x88\x33\xd2\x3d\xcb\xcb\xbe\x78\xfe\x9e\x05\xf1\xc9\x9d\x65\xe7\x33\x83\x89\x10\xf4\xb1\xb6\xe4\xc6\x97\x51\x9c\xd3\x64\x72\xb9\x62\x51\x9b\xd5\xe7\xf7\x6b\x34\xd6\x28\x45\xa7\x2b\xec\x4e\xce\xd9\xc1\x5b\x4c\x5c\x23\xd7\xc4\xc1\x88\x8b\xe3\x82\x6a\x22\x8c\x68\xad\x82\x84\xaf\xc3\x77\x85\x8f\x32\x51\x3e\x5f\x30\xe8\xea\xe0\x83\x16\x16\x46\x6c\x2c\xab\x56\x9b\x3a\x60\xe8\x01\x74\x3a\x35\x25\xe2\xe8\x89\xd4\x83\x84\x82\xf1\xd4\x9c\xa9\x2c\x90\x77\xf5\xe0\x96\xcd\x13\x9f\xa2\x13\x21\x52\x88\x32\xbf\x51\xe8\xa7\x4a\xd6\x60\x40\x43\x9c\x2a\x22\x6f\xee\x14\x3e\x7b\x11\xb4\x7f\x0a\x34\xe4\xf9\xdf\xac\xf5\x3b\xff\xfe\xd8\x67\x16\x8e\x7e\x7b\xe0\x75\x9b\x7e\xbd\xff\x19\x15\xb0\xfc\xfc\x0d\xb8\xf1\x03\xb6\x7b\xb1\x9f\x6a\x98\x83\x5e\xe7\x42\x5c\x66\xa7\xbe\x24\xd0\xbd\x14\x5c\x57\xe9\x8e\xbb\x92\xe8\x4d\x5c\x92\xeb\x95\xa6\x42\x9a\x44\x95\xc3\x91\x48\x50\x99\x8c\xcf\x44\x99\xea\xfb\x58\xab\x9a\x78\xab\x35\xc0\x06\xdc\x2d\xbc\x37\xe0\xa8\x2b\x65\x4b\x9b\xf9\x90\x86\xd0\xb3\x1c\x11\x69\xe6\x09\xe9\xd2\x11\x09\xa7\x80\x30\x2b\x42\x9b\x96\xeb\xe2\x25\xe9\xe5\xeb\x1f\x29\xce\x82\x26\x44\xba\x6e\xc4\xb7\xdf\x49\x28\xbe\x9c\x18\xc7\x57\xdd\x12\x84\xa6\x0a\x8c\x5b\xb9\xf1\x86\xcf\xef\xdc\x39\xb2\xea\xfe\xf6\xb9\xd7\x5c\xfb\x8f\xed\x40\xdf\xda\xb4\x6c\xad\xff\xd0\xde\x23\xb5\xcb\x0f\x8c\x5c\xcb\x0f\xe9\x3f\x6a\xcd\x45\x39\x92\x7d\x70\x6f\x45\xb4\x65\x8d\xed\xc8\xee\x03\x20\xb1\x67\xc3\xc0\xa6\xe9\x13\xdb\xef\x9f\x61\x60\x3b\x4a\x2e\x6d\x9b\x59\xb6\xeb\xde\x7b\x5b\xf7\x02\xf7\x7d\x73\x16\x3f\x2e\x7c\xb6\x69\xd6\x22\xb0\x9d\xbb\xe7\xfa\x7e\x0d\x5f\x60\x7d\x8e\x79\xdd\xb0\x9d\xa9\x95\xec\xcc\x01\xb1\xee\xcb\x8f\xeb\xbe\x7a\x1d\xf2\x87\x68\xb3\x22\x2f\x8c\x70\x21\x57\x60\x3b\x33\x4e\xb2\x33\xbf\x17\xf5\xf9\xa7\x16\xbb\x96\x2c\xd8\x99\xff\x40\xff\xe7\x25\x6c\x67\x6a\x25\xff\xe7\x01\xbc\xaf\x43\x50\x37\x45\xb1\x5d\x19\x27\xfa\x3f\xdf\x11\x8a\x79\x7c\x2c\xcf\x03\xda\x95\x91\x62\xec\x45\x46\x50\xfd\x71\x0c\x74\xc4\x40\x73\x0c\x9c\x8c\x89\xd3\x29\x8a\xbd\xd0\x9c\x2e\xc6\x36\x66\x1c\x8e\x97\x56\x8f\xc5\x33\x5a\xec\x96\x67\x04\x9f\x41\x1c\x6f\xe7\xb0\x9c\x75\x92\x9c\xb5\x62\xfe\xbb\x02\xe7\xbf\x5d\x87\x2a\xaa\xd3\x0e\x85\x9c\x6e\xf8\x7c\x13\x96\x73\xbc\x24\xe7\x6a\x51\xce\x33\x89\x52\x46\xa1\x37\x30\x77\x1c\x9e\x77\x9d\x94\xa7\x7a\x4f\xb2\x87\x68\xe0\x27\x2a\x6a\x0a\xa3\x12\xf2\xb8\x15\x78\xae\xe3\xc5\x3b\xf4\x2a\x3c\xea\xed\x89\x32\x26\x7f\xb7\xeb\x12\xc6\x21\x3e\x3a\x69\x4c\x15\x71\xcd\x40\xc9\x42\xdf\x76\x28\x53\x21\x8d\x87\xc7\x12\xc6\x21\x5c\x4c\x79\x2c\xe2\x9a\x2f\xa4\xe7\xf6\x1e\x4a\x25\xe4\x49\x4a\x73\xec\x52\xcc\x71\x35\xf1\xb3\x34\xc7\x0c\x9c\xe3\x47\xb5\xd5\x17\x98\xe3\x34\xc5\x1c\x57\x4f\xc0\x73\x7c\x3e\x5d\x5a\x98\xe3\xad\xc2\x38\xc4\x2d\x07\x9f\xc9\xa2\xf7\x4b\x5c\x43\xdc\x8c\x7f\x97\x80\x73\x9a\x4e\xdf\x04\x7d\xca\x8b\xc5\x39\xdd\x41\x10\x9e\x9c\xad\x12\x85\xad\x95\x28\x6c\xad\xcc\x39\x9d\xf0\x2f\x8e\x1b\x2e\x06\xaa\x68\x2c\xc4\x53\x87\xe7\x97\x95\xde\x7d\x56\xe1\x53\x4c\xf5\x3a\xd5\xda\xa2\xf9\x35\xc1\xf9\xdd\x85\xfd\xd6\x8b\xff\x23\xfa\xbe\x15\xd0\xf7\xe5\x9e\x06\x65\xd0\x35\x28\x03\x65\xf9\x1e\x0f\x05\x07\x9e\x97\xb8\x25\x37\xd4\x61\xb7\xbb\x6c\x36\xb7\x9b\xd4\xe9\xf5\x24\x4d\xa9\x28\x96\x25\x49\x1f\x67\x34\xfa\x39\x42\x7f\x85\x9e\x44\x7c\xd3\x06\x1b\x6b\xc0\x6c\xed\x2a\x0a\xb1\x59\xa9\x38\x15\x59\x42\xa9\x54\xa4\x81\x72\x77\xe3\xc7\x13\xdb\xff\x0a\x4d\x31\x32\x55\x9e\x0c\x75\x54\xd4\xd1\x2c\xa9\x02\xc4\x9a\x17\xce\x86\xbb\x31\xe7\xa1\x7a\x51\xcc\x9e\xd7\x21\xbc\x60\x02\x03\x3a\x8a\x39\xf4\x3a\xc0\x60\x93\xf0\xfb\x69\x88\x49\x0f\xd5\x86\x86\x64\x32\xbd\xce\xcf\x5a\x3b\x3f\x92\xf9\xf4\x02\x12\xbe\x28\xc2\x2c\x1c\x60\xb3\x18\xcd\x66\x9d\xd3\xe1\xf1\x04\xbc\xf0\xed\x18\x74\xba\x90\x4f\xe5\x72\x85\x4d\xe1\xe5\xe1\x07\xc2\xfb\xc3\x34\x47\x19\x02\xde\x40\x33\xcf\x79\xbd\x4e\xca\xec\x71\x7a\x9a\x79\x87\xc3\xe6\x34\x21\xf0\x51\x86\x51\x3b\x24\xeb\x5f\x40\x1b\x95\x71\x9c\xa4\x78\x54\x6c\xd0\x56\x22\x2e\x17\x80\x3e\x65\x10\x52\x5c\x10\x9b\xc7\x21\x85\x7f\x48\xa0\x29\x97\xa1\x48\x33\x4b\x4d\x4b\xab\xf3\x68\xa4\xd5\x27\x4d\x27\x6b\x64\x40\xd2\xfe\xc0\xdc\x06\xac\x18\x92\x54\xf8\xb6\x4d\xf8\x9a\x50\xd4\xf1\x3d\x95\xaf\xfb\xdb\x0e\x3e\x51\xd4\xfd\xd5\x27\x33\xdd\xea\xfe\xd0\x3d\xf4\x9f\x71\x0e\x69\x82\x94\x73\x3a\x20\x9e\xdf\x2b\x13\x35\xca\xfb\x6a\x71\xdc\xc1\xf9\x71\xd7\x80\x8f\x15\xe3\x0e\xf5\x07\x2f\x30\xee\x11\xec\x4f\x4c\x90\xfc\x89\x0d\xe2\xb8\x33\x7d\x81\x9e\xe3\x1e\xcb\x8f\xbb\x15\xfc\x41\x31\xee\xb8\x50\xe9\x85\xc6\xc5\xfe\xc4\x04\xc9\x9f\xb8\x59\x9a\x6f\xb0\xa4\xc7\xb8\xac\x23\x3f\xee\x7d\xe0\xcf\xa2\x2f\x21\xd5\x33\xd6\x47\xc5\x4a\x46\xa5\x2f\x21\x8e\xfd\x7a\x7e\xec\xfb\x70\x4d\x11\xba\x21\xbd\x38\xa2\xb8\x93\x97\xe6\xfc\x63\x7e\xec\x07\xc8\x9c\x3c\x36\xb2\x06\xe0\x7e\x7f\xe2\x42\x63\xd3\xe3\xb0\x9f\x32\x41\xf2\x53\xce\x49\x63\xbf\xe2\x8b\x2b\xc7\x16\x16\x20\xbe\x47\x71\x6c\x0e\xdd\x51\x3e\x29\xfe\xbe\xb0\x00\xe1\xcd\xe6\x7f\xff\x7e\xb0\x1a\xdf\x5d\x02\x2e\x16\xd3\xeb\xc5\xbb\x4b\xcc\x51\x88\xf5\x43\x1f\x51\xc7\x92\xa3\x14\x75\x98\x7d\xed\x6e\x95\xa5\x68\x2d\x31\xf6\x2a\xd6\x5f\x13\xa5\x9c\xce\x4c\x71\x2d\x6f\x70\xfb\x55\x8e\xc2\x5a\x8a\xf5\x9d\x1f\xcb\xf5\x9d\xf0\xb9\xa1\x8a\x71\xc7\xd8\xdd\xca\xfa\xce\xfc\x3d\xf3\x7a\xf9\x9e\x99\x5c\x25\xe9\xc5\x50\x4c\x2a\x57\xc8\x8f\xb9\x23\x5f\x33\x3a\x17\xa4\xe4\x9a\x76\x17\x5a\xc3\xfe\x49\xbb\xda\xdc\x6d\x0d\x31\x3f\x19\xb6\x4d\x0d\x92\x6d\x1a\x2d\xcd\xc3\x0a\xe7\xf1\x17\xab\xc3\xcc\x16\xcd\x03\x61\x77\x8e\xc2\xb6\x69\x8a\x64\x9b\x56\x8a\xf2\x7d\x67\x73\x12\xda\x82\x7c\xe2\xb8\x5b\xe5\x71\x61\xdc\xef\x94\xc6\x75\xc0\x71\x77\xb8\xad\x17\x18\x97\xc4\x76\x67\x0a\x96\x6f\x9b\x58\x03\xb6\xc0\x63\x93\x46\xcd\x8f\xf9\x71\x7e\xcc\xd5\x20\x29\x8d\x09\xc5\x03\xbf\xf3\x5c\x68\xae\xf5\x78\xcd\xc4\x31\x57\x8b\xf6\x6e\x9b\x37\x3f\xd3\x02\x67\x86\x89\x68\xcc\x41\x77\x95\x56\x31\x0c\xa7\xd3\x99\x4d\xe6\x4a\x73\xa3\x99\xb2\x52\xe6\x9c\x81\x43\xec\x18\x1a\xa2\x99\xd7\x00\x14\x9b\x48\x2e\x28\x06\x9e\x29\xc0\xbd\xe3\x16\x49\x16\xea\xd5\x3c\xf3\x05\x39\xb7\xff\x70\xaf\xf0\xd3\xee\x73\x89\x97\x24\xce\x0b\xa6\xf5\x8a\xad\x67\x69\x66\xf7\x5f\x4f\x23\xb2\x0b\x9c\xcf\xcb\xf3\xd7\x78\x89\x12\xa2\x35\x57\xae\xa5\x7d\x3e\xaf\x33\xc2\x71\x8c\x93\x2a\x2d\xb3\x41\x35\x69\x73\x68\xe3\x86\x78\x2b\xcf\xba\x3d\xee\x66\x9e\xf6\x78\x48\x03\x27\xa2\xfa\xe7\xc1\x07\xf3\x66\x40\xcc\x8f\x16\xd0\x77\x45\xd0\x7e\x16\xfe\x0b\xbd\xbe\x22\xee\x1a\xa4\x20\xa9\x9e\xfc\x35\x09\x50\x65\x12\x4e\x45\x6c\xac\x92\xc5\xe6\xd9\xf5\xc6\x0d\xfe\x3e\xb3\x2e\x79\x7c\x66\x9e\xc9\xe6\xd3\xb6\x37\x3b\xbc\x05\x2a\x1b\xda\xd5\x76\xee\x85\xaa\x7b\x00\x21\xd1\xd9\x40\x5f\xb7\x7f\xd7\x59\x26\x80\xb9\xd6\xa3\x30\x3a\xb8\x38\x57\xa1\xd6\x94\x47\x22\xa4\xdf\x9e\x34\x99\xec\xa8\x25\x28\x5d\x61\x29\x0f\x97\x87\x3b\xf8\xf2\x72\xb7\xde\x1d\xe9\xe0\xdd\x96\x14\xad\xa7\x3b\x78\x8d\x9e\x42\x76\xae\x31\xd3\x9d\x4c\x25\x8f\x9c\x5a\x40\x70\x10\x89\x60\x11\xa2\xab\xb5\x2e\x13\x86\x81\xad\xd8\xd4\x4e\x87\xd3\xa0\x46\x04\x10\xa5\x1c\x56\xf9\xab\x6b\xb5\x2b\x4f\xd6\x35\xcd\x8d\x0c\x1b\x54\x37\xa7\x83\x4c\x82\x67\x0f\x6e\xdf\xf6\x88\xf0\x57\xe1\x63\xe1\x26\xb0\xfc\xc5\x43\x07\xf7\x3c\x3b\xf3\x78\xdb\xcb\x0f\xdf\xbc\x69\xfb\x04\x18\xd9\x6e\xac\xe8\xb3\x0c\x68\xab\x85\xbf\xaf\x7b\xc6\x6e\x78\x60\xc5\x07\x6f\xa8\xda\x36\x3d\xbe\xea\x9a\xce\x97\x55\xe4\xf6\x9b\x1f\x9c\x3d\x53\x30\xe5\x73\x67\x77\xa0\xbb\x71\xea\xe5\xfc\xfb\xfc\x01\xf3\x98\xc7\x89\xc1\xb9\x98\x96\x8d\xc5\x9c\x50\x2b\x42\xbd\xe3\xa4\x12\x49\x17\xdb\xcc\x93\x2e\xca\xe6\xc6\xef\x35\x64\x08\xb5\xf2\x86\x22\x72\x81\x4c\xaa\x38\x8a\x41\xe4\xc3\x08\x94\x10\x4e\xbf\x1b\xfb\x90\x17\x14\x5e\x1e\xe5\xa0\x7e\x08\x0d\x08\x94\x6e\x6f\xb9\xa7\xa2\x98\x81\xe8\xf3\xb9\xf2\x6b\x9b\xdb\x87\x69\x10\x3a\xb7\xa8\xf5\xc2\xb7\x4a\x16\x22\xba\xf3\xac\x20\xbf\xb8\xce\x27\xaa\x70\x8e\xf9\x1b\x28\xd3\x38\xdc\x87\xed\x24\x7a\xe7\xfc\x00\xda\x73\x3b\xc3\xe8\x0c\x94\xc6\xad\x71\x01\xae\x83\x07\x40\x63\xa2\x34\xe6\x0e\xb1\x63\x45\x42\xc0\x44\xbe\x87\xb2\xe2\x91\xc2\x93\xa5\x4b\x01\x4e\x3c\xc4\x75\x62\x4d\x75\x98\x1c\x38\xeb\xf4\xeb\x7f\x13\xbe\x12\x3e\xeb\x7c\x4b\xbb\xff\x9e\x3d\x7a\x30\xb3\xf7\xcc\xed\x1f\x1e\x14\x3e\x65\x1a\x3a\x1f\x3b\xf8\xc0\x1f\xde\xaa\xad\xa0\x1a\xf7\x34\x1e\xee\x6c\xed\x7c\xeb\xae\xfd\x3f\x29\xce\x88\x1e\x46\x4e\x70\x3e\x2e\xbb\x4e\xc7\xd1\x81\x80\x85\xa3\x22\x51\x17\xeb\x65\x5b\x79\x2f\x67\x23\x0c\xf0\x84\x1a\xa4\xf0\xa8\xb1\x5b\x3c\x28\xe2\xd6\x17\x96\xcb\x89\x8e\x00\x9c\x54\x46\xb9\xaa\x60\x4b\x61\xad\x26\xc2\xb5\xdb\xbd\x40\x03\x42\x35\x0a\x4a\xa7\xbe\x8a\x85\x6a\x4a\x27\xa9\xdd\x4f\x56\xbf\xaa\xe4\x74\x42\xfa\xa4\xb2\xeb\x5b\x26\xc1\x8c\x26\x02\x44\x26\xe7\x61\x48\xbd\xd7\x6b\x23\xa9\x60\x88\xb2\x11\x2e\x97\xa9\x9d\x77\xd1\x84\x1a\xfa\x71\x56\x65\x02\x2f\x3f\x4f\x5c\xb0\x67\xcd\xd8\x51\xf2\x26\x26\x4d\x16\x6f\xed\x58\x26\x44\xe0\x19\x7e\x79\xfa\xf3\xf4\x80\xc6\x27\xa6\x1d\x06\xc1\x07\x4e\xbd\xb4\xe8\xcf\x83\x87\x0f\x68\x58\x0c\x34\x0b\x81\x15\xd4\x9d\x14\x56\x58\x33\x20\xfe\x44\xaa\xf2\x25\x30\xfd\xb3\x0f\x3e\x1d\x5c\xfb\x06\xe8\x5b\x56\x29\x7c\x22\xfc\x22\xdc\x72\x02\xf7\xb6\x77\x7d\xcb\x1a\x54\x73\xe1\x79\x1c\x95\x4b\x5a\xc2\x49\x9d\x46\xe3\x09\x53\x69\xb2\xbc\xbc\xa2\x8c\x81\x6f\xb5\x2c\x9e\x0c\xc4\xe3\xc6\x76\x5e\x1b\xa7\xdd\x81\x80\xbd\x9d\x0f\x58\x8b\x90\xb2\xeb\x5d\xdc\xab\x35\xa9\x02\x31\xa5\x74\x9b\x27\xe1\xd8\x52\xd1\x5a\xf4\x05\x2d\x95\x5c\xa0\xe0\x5a\x45\x47\x43\x84\x54\x8e\x81\x15\xa3\xea\xb3\x81\x8c\x69\x60\xd9\x90\x89\xc6\x2c\x96\x43\xf8\xb4\x20\x87\xf0\xdf\x85\xc2\xb7\xc2\x9b\x27\xc1\xf5\xff\x39\xb4\x2b\xb4\xfb\xaa\x1b\x46\x31\x13\xd6\x38\x3d\x1d\x53\x85\xed\x48\x28\x61\xbb\x28\x94\x70\xac\xac\x12\x84\x84\x5f\xc0\x75\x27\x82\x9b\x1f\x0e\x88\xdc\x59\xf4\x49\xfa\x25\x22\x81\xe4\xe2\xbc\x61\x2d\xcb\xda\xbd\x54\x32\x91\x28\x89\xd1\xcd\x70\xb3\xc6\x82\x61\x57\x30\xa8\x87\x0a\x3c\xc8\xd9\x5c\x2e\x4b\x0b\xef\x72\xf4\x94\x4b\xb1\x83\x65\xb9\xa4\x17\xa0\xa0\xc9\x72\x2a\x6a\xc5\x45\x89\xe8\x47\xab\x9d\xfe\x9a\xc6\x51\x9e\x84\xcc\x99\xb5\xee\xfe\x40\xcb\x6b\x53\x45\x2e\xad\x09\x0b\x12\xb7\x2f\x1e\xd3\x9f\xfa\xf4\x5a\xfb\x95\xf7\xfc\x45\xa6\xcf\x2a\x93\x39\xb5\xdc\x6b\x57\x5b\x15\xf5\x3b\x45\x35\x36\xe7\x55\x66\x78\x06\xd5\x70\x27\xf5\xcb\x85\xe8\x00\xe1\x70\x04\x4c\x70\x27\xa9\x02\xbe\x40\x3b\xef\x85\x8a\xd2\xeb\xb3\x50\x1a\x8b\xa6\x83\x37\x59\x14\xdc\xa1\xa9\xa2\xad\x8f\x2a\x8f\xc3\x51\xdc\x10\x06\x14\x8a\xb2\xd0\x3a\xc6\x34\x76\x76\xee\x7a\x5b\x6c\x05\x3b\xbf\xb5\xa0\x1e\xfb\x15\x75\x8f\x51\x66\xf0\xee\xb9\x6b\xd5\x60\x1e\x15\x91\xd4\x62\xa1\x67\x4c\xb4\x63\x39\xa8\x33\xba\xe0\x7c\x35\x30\x0a\x18\x91\x2b\x21\xac\x8c\xcb\xa5\xd7\x07\xac\x54\x48\xab\x0d\xeb\xdd\x41\x77\x07\xef\x50\xc1\x3f\x0e\x2e\x10\xa4\x38\x43\x3b\xcf\x51\x1d\x3c\x27\x37\xbc\x65\x30\x84\xae\xd4\xbd\xa9\x54\x22\xa8\xd7\xd5\x8a\x56\x1f\x88\xa9\x6c\xb4\xf6\xb1\x70\x46\x56\xfa\x80\x5d\xbf\xf9\xee\x19\x5b\xd7\x3c\xd2\x4c\xfd\xa2\x79\xe8\x9d\x3d\x9a\xce\xf7\xde\xfb\x04\x78\x81\xe5\x8d\x89\x27\x5b\x1e\x89\x4e\x19\x30\x08\x94\xcc\x9f\x4e\xd6\x8e\xd9\x40\xad\xad\xf5\x9e\x9b\xee\xa9\xdd\xba\xf1\xdd\xaf\x81\x60\x60\xdf\x02\xb5\x72\x2d\x13\xf5\x5f\x38\x6f\x03\xdc\x3d\x2d\xb9\x14\xeb\xb2\x12\xa1\x90\xd1\x18\x77\x51\xc9\x92\x78\x22\x11\x6a\xe6\x13\x84\x35\x60\xf1\xf9\xa8\x66\xde\xc7\xd9\xb5\xf9\xfa\x25\x7b\x11\xb1\x11\xca\xc3\x17\x2b\x1d\x71\xfe\x45\x35\x48\xa0\x7b\x85\x52\x9d\x14\x8b\x91\xbf\xc8\xc5\x47\xf5\x37\x37\x80\xf9\x9f\x15\x57\x26\x0d\xa3\x2b\x97\x09\xed\x75\x83\xd2\xd4\x90\x42\x01\x12\x3d\xf2\x9c\xa6\x50\x99\xe4\xac\x06\x1a\xdb\x16\x40\x89\xef\x22\x23\x0c\xa3\x5e\xa6\x8e\x13\x11\xa2\x8a\x18\x93\x2b\x49\xf9\x92\x15\x15\x6e\x15\x95\xb4\xe8\x83\x41\x0b\x45\x55\xbb\xdd\x35\xbe\x54\x8a\xa3\x29\xb8\xa7\xa2\x30\xfa\xe2\x08\x0d\xaa\xce\x52\x62\x66\x99\x8b\xdf\x84\x0c\xe1\x09\x90\xde\x2c\x70\xca\x83\x64\x01\x09\x82\x64\x45\xf8\x27\xab\x58\xcd\x1e\x14\x13\x49\x60\x48\x9f\xcd\xb9\x74\x96\x0b\xf2\xa9\x4b\xe6\x05\xfb\x5f\x76\xe2\x86\x7f\xde\x7d\xcf\x81\xf7\xde\xbd\x38\xd7\xb1\x77\xff\xb8\x15\x63\x86\x0c\x8f\x3c\xb8\x6e\xba\x30\xcc\xe7\x02\xaa\xc7\x23\x81\x89\xa3\x22\x7d\x73\x17\xef\xf8\x7c\xeb\x4f\xab\x0e\x3f\xf0\xba\xf0\x55\x6e\xcc\xfc\x3e\xe3\x6e\x18\xca\x54\xce\x79\xef\x9a\x29\xab\xfa\xfa\x1a\xbe\x7d\x6d\xd9\x6a\x1c\x73\xc6\xa0\xaf\xdb\x88\x63\xeb\xa9\xb9\x0c\x0d\x8c\x3a\x35\xc7\xb9\xdd\x3a\x3b\xa0\x7d\x4e\xa7\x5f\xab\x36\xa9\x3b\x78\x83\xc9\x04\x1c\x0e\x37\x0c\xa5\xe1\xb6\x83\x7b\x8f\x02\x9e\x76\x1e\xc0\x5d\x48\x02\x4c\x0b\x2d\xe7\x13\xbb\x83\x05\x2b\xc4\xae\xae\x2a\x05\x50\x60\x07\xfc\x3b\xcc\x46\xe1\x57\xf9\xf0\x19\xed\x47\xfa\xa2\x73\xa7\x52\x03\x8d\xcd\x44\x17\x50\x77\x08\xf7\xf4\xcd\x0d\xcf\x51\x60\xee\x94\x8f\x3e\xb8\x62\xe8\xc0\xde\xd4\x77\x9a\x03\xa7\xf6\x80\xe9\xbf\x70\x64\x74\x17\xb8\x6f\x07\xa9\x37\xfe\x09\x0c\xa8\xf5\x9c\x9b\xee\x85\xef\x68\x2e\x8c\x13\xa6\x42\x3b\xe1\x86\x6f\x69\x44\x2e\xe1\xf3\xb8\x9d\x6a\x4d\x04\x10\x1c\xa7\x71\x52\xd1\x98\xdb\x03\x8d\xab\xc1\xed\xb6\x19\x6c\xc1\x76\xde\x66\x35\xd0\xed\xbc\x81\x2e\xc2\x51\xb7\xd4\xa7\x14\x48\xf2\x52\x53\x68\x36\x6f\x34\xd0\x6b\x21\x44\x67\x01\x6a\x60\x18\x18\xe3\x4d\x48\x58\xe9\x0d\xcc\xe1\x5d\x0b\x1f\x1d\xd3\x30\xb0\xcf\x96\x97\xe6\xfd\x0c\x2c\xcf\x0b\x07\x3f\xfe\x97\xf0\x85\xfb\x05\xee\xd0\xfd\x2f\x02\x6d\x1d\xf9\xd5\xc5\xef\x7e\x5d\x99\x7a\x02\xc4\x43\x56\xe1\x9f\xc2\x0f\xc2\x55\x7f\x00\x91\x9f\xae\x9f\x3b\xb1\x79\xf8\xbb\x5f\xc0\xb7\xca\xe1\xf5\xaf\x83\x36\xf9\xdf\xcc\x18\xe8\xb5\x8e\xca\x95\xf8\xe0\x71\xd7\x6b\xb5\x51\x27\xc9\x10\xaa\xd2\x32\xd2\xe9\x72\x39\x51\xe3\xbc\x3a\x92\x48\x40\x65\x95\xb0\xaa\xb9\x76\x5e\xaf\xa6\x25\xa8\x58\x4c\x1a\x71\x01\x9f\xae\xba\xca\xca\xc5\x51\xbf\x7b\x4c\x89\xc5\x8c\xf6\x92\x09\x14\x00\x11\x28\x74\x80\xea\xc0\xe6\x25\xab\x00\xf8\xee\xee\x1d\x15\x03\xe9\xd0\x92\xda\x3b\x6f\x9f\xdf\x71\x87\x69\xfd\xa1\x5d\xff\xed\x7d\x57\x72\xf4\xc0\x86\x27\x8e\x1c\xfd\x14\x54\x82\xa9\xd5\xe6\x8d\xf3\x9f\x79\x2d\x25\x08\x0f\x39\x82\x1b\x1e\x99\x31\x4b\xa5\x69\x55\x6b\x0f\x3f\xf6\x69\xc8\xf1\xbc\xf0\xf7\xd4\xa3\x38\x7f\x21\x9c\x14\x86\xd0\x3f\xc1\xbd\x14\x40\x7e\xaa\xca\x68\xf4\x68\x74\x1e\xca\x42\x06\x02\x21\xbb\xc5\x12\xd4\x19\x54\x86\x0e\x5e\xad\x52\x71\x7e\xbf\xb7\x9d\xf7\x23\x4b\xe9\xa7\x38\x57\x07\x6f\xe5\x7c\x79\xf0\xdb\x1e\x80\xd3\xc5\x8d\x72\xd1\x6c\x22\x1a\xce\x67\x9e\xa5\x1b\x0b\xf1\x92\x06\x7a\xe8\xf4\x73\x03\x55\xf3\xdf\x17\xfe\x3d\x03\xfc\xbe\x6f\xc3\xf0\x06\x4a\x18\x34\xa7\x59\x38\xbc\xf2\xd2\xb2\x01\x8c\xbe\xb5\x7c\x6d\xf8\xfc\x5e\x0d\x1d\xa6\xce\xff\xc9\xd8\x79\x0a\xa7\x97\xf7\x0b\xfd\x2a\xfe\xb9\xc6\x1e\x3a\xca\x6c\x92\xb9\xf4\xdf\x17\x3e\xa7\x0e\x30\xad\x84\x0b\x94\xe5\xe2\x4e\x9b\xd5\xe5\xb2\x6b\x19\x1a\x10\x5a\xc2\xe3\x06\x4e\x9b\x73\x31\x4f\xdb\x6c\x84\x5a\x6d\x5a\xcc\x13\x7a\x4e\x4f\x3a\xf4\xa8\x00\x22\x10\x1e\x8e\xfe\x9b\xbb\x5f\x6f\x1a\xae\xd7\xab\x59\xc2\x73\xa3\x07\x5c\x81\x91\xc2\x72\x1e\x50\xe5\x01\x21\x0c\x1f\xf6\xbd\x07\x7c\xe2\x01\x2f\x62\x94\xb1\x1d\x1e\xa0\x7c\x46\x7c\x40\xfc\xa9\xf8\x23\xf8\xfd\x66\xf9\x47\x1c\xfe\x69\x5f\xf1\xf7\xc5\x5f\x16\x7f\x53\x1c\x5a\xfc\x7e\xfe\xd7\xba\x0d\x77\x23\xfe\x0e\xe1\x01\x45\x65\xe3\xff\x2f\x24\x0e\xfc\x8f\x48\x52\x98\xea\x86\x03\x2e\x25\xc8\xc5\x9b\x5d\x74\x5c\xbc\xa0\x98\xaa\x10\xa1\x9d\xa3\x84\xd1\xfb\x8f\xee\xd4\xee\x29\xf1\xfd\x6e\xf5\xa4\x46\xb6\xd2\x1f\xcc\xa6\xfb\x25\xdd\x89\x5f\xcd\xbf\x1c\x84\x8b\xfc\x51\x4d\xe4\x9f\x3b\x9e\xb1\x1e\xe9\x70\x56\x4f\x5d\xf5\x41\xdb\xf9\xb8\xb8\xfe\x0b\xbb\xbe\x63\xdd\xd0\xb7\xaa\x20\xa6\xe4\xaa\x5c\xa9\x60\xcc\x42\x9a\x4c\xb1\x14\x55\x09\x9d\x91\x2a\xe8\x80\xc0\x53\x4c\x12\xe1\x70\x09\x51\x02\xf7\x50\x89\x95\x81\x5b\x4a\xc3\x10\x84\xad\x9d\x37\x23\x5e\xe8\x1a\x8c\xa9\x57\xd3\xed\x78\x2b\x49\xc0\x65\x8b\x28\xb9\x1d\xac\x78\x3c\x58\x94\xc5\x2b\xf8\x5c\x59\xf1\x3e\x1a\xb1\x24\x88\x7e\x17\xf5\xd4\xef\xf6\x05\x77\x2f\xb9\x61\x54\x0a\xfb\x5d\x6b\x22\xb9\x41\xd4\xf2\xd3\x07\x85\x4f\x76\x9d\x78\xe6\xe2\xa7\x06\x36\xee\x41\x1c\x6b\xab\x46\x6d\xfc\x71\x95\xf0\x2f\xe1\x9d\x77\xc0\x75\xcc\xe8\xf8\xd6\x7d\x81\x9f\xa0\xdf\x75\x54\xd8\xba\xfb\xd2\x17\x84\x1d\x7f\x7f\xe7\xab\x9a\x52\x30\xcd\x53\x57\xe7\x11\x26\xd7\x57\x82\xa0\x70\x0e\x5c\xf3\x36\xb2\x33\xf3\x84\x21\xb8\x1f\x1e\xf5\xb0\xf0\xb9\x0a\xb3\xde\xa7\xb6\x50\x3a\x07\x63\x25\x49\x46\xa7\xd6\x33\x41\x82\x08\x91\x56\xab\xde\x6c\x34\xb7\xf3\x6e\x1d\xfc\x19\xc5\xda\x8d\x14\xeb\x6f\xe7\x59\x5f\xe1\x1e\xc3\x9c\x29\x80\x71\x2b\xb5\xaf\x2c\xb1\x09\x00\x8b\x9d\x65\x92\xfd\x41\x16\xe4\xe1\xb6\x11\x70\x3b\x0c\x6a\x9d\x59\x66\xaf\x76\x45\xe7\x86\xc1\x94\xb0\xae\xc1\x7b\xd1\x38\xe1\xeb\xe5\x88\x8b\x7f\xdf\x9f\x49\xf7\x66\x9d\x10\xf3\x96\x0e\x60\xad\x57\x33\x0d\x50\xeb\x3e\x2a\x9c\x3a\x3a\x59\xe7\x9f\x7b\x6c\x33\x7d\x0c\xdd\xbe\x9f\x4f\x53\xa7\x3d\xb5\xbf\x2e\xe2\xe6\x2e\x1d\x7a\x6f\x8c\x65\x51\x7d\x1c\xd4\xc9\xc7\x61\x9c\x51\x46\x8c\xcf\x55\x44\x42\x5e\xaf\x2f\x09\xdf\x90\x49\xa5\xd1\x98\x7c\x54\xaa\x3c\xe2\x8c\x39\x5b\xf9\x18\x17\xf4\x37\xf1\x41\xc2\x67\xd7\x43\x97\x40\xef\x50\xab\x10\x1d\x4e\xc1\x19\xc8\xdf\x59\x2a\x3d\x01\x39\x06\xc1\x39\x4a\x5c\x45\x42\x86\x0b\x9c\x1f\x85\xfb\x4a\x4a\x62\x03\x63\x29\xaa\xe1\xa2\xe6\xdd\xf1\xb9\xab\xd5\xa0\xe6\xea\x6a\xe1\xf0\xfd\x3b\x99\x7a\x67\x55\xaf\x11\x0f\xf5\xb9\xfc\xe1\x6f\x51\x51\xdc\x84\xc8\x83\x4f\x5e\x72\xa9\xab\xee\xe3\xe1\x93\xde\x25\x79\x77\xba\x73\x9c\xf0\xcd\xc2\xb9\x41\x2f\x18\x82\xaa\xdf\x96\xb5\x77\xde\x86\x19\x67\xad\x4f\x7d\xb8\xe0\xd2\xd4\x2d\xc2\x9b\x72\x9d\x18\xaa\xff\x50\xa1\xba\x0d\x02\x88\x35\x5a\xf0\xfd\x59\xa1\x0e\x4f\x40\xb5\xae\x61\x18\xca\x60\xb0\x53\x36\x93\x56\xaf\x6d\xe7\xad\xac\x9a\x85\x7e\x9a\x5a\x4d\xc1\x88\x9c\xa1\x98\x76\x9e\x52\xe6\x9f\x0b\xc9\xe7\x3c\x87\x4c\x46\xc1\x9e\x2f\x42\x12\xa0\xcd\x08\x4f\x14\x58\xb8\x5b\xdd\xf9\x95\xfa\xc0\xec\x77\x4c\x27\x79\xb1\x94\x91\x7f\xdf\xf4\x1e\x26\xce\x27\x2f\x6a\x05\xbf\xa2\x37\x22\xb0\xad\xf9\x5a\x0f\xe6\x7b\xa6\x85\x88\x12\xb3\x72\x59\xbf\xc7\x03\x5f\x8d\xd1\x68\x65\xf5\x3a\x35\x50\x69\x54\x6a\xbd\x95\x31\xd3\x74\xdc\x1c\x73\x85\x3a\x78\x9f\x8b\x46\x1d\x38\xd0\x3a\x12\x94\xd9\xa2\xb3\xa8\x00\x05\xe0\x44\x29\x79\xa2\x8d\xca\x8b\x32\x71\xa2\xca\x14\x82\xd4\x36\xa2\x11\x37\x96\x06\x81\x82\x00\xf9\xb6\xbc\x3f\x59\x38\x67\x2a\x16\xbc\x42\x81\xa5\x5a\xb0\x45\xbb\xa1\xf3\x3d\xf0\xc2\x3a\x8d\x70\x4c\xb8\xe4\xab\x51\xcf\x6b\x3b\xdf\xd3\xee\xbf\xcb\x75\xd5\xd3\x33\xe6\x8d\x4b\x0d\x54\x19\xfb\x44\xfb\x4f\x34\x93\x4b\xc8\xab\xb1\x44\xf5\x9d\xa5\xde\x5a\xf2\x89\xdf\x0b\xed\x48\x52\xaa\xe1\xb6\xd7\xaf\x82\x67\xcb\xe1\xed\x98\x9a\xaf\x61\x62\x76\x11\x7e\x62\x52\xae\xca\xa8\xd3\xb9\x6c\x36\x9a\x66\xbc\x24\xf0\xd9\x3d\x1e\x1f\xc9\xd0\x01\x97\x2b\xe8\xb1\x3b\xed\x4d\x3c\x69\xa3\x28\xc6\x89\x2b\xba\x10\x55\x2b\x60\xec\x98\xd2\x01\x27\xca\x0b\x65\x2b\x17\x94\x2d\x8c\xcb\x94\xac\x4a\x46\x56\xb6\x50\xc4\x44\x2d\xc3\xd5\x4a\x4f\x25\x4e\x6c\x1c\xdb\x3f\x56\xed\xf2\x57\xe7\x46\xb8\x17\x29\xcb\x99\x70\xd9\x12\xf5\xe3\xfb\x1f\x59\x4f\x5c\x6b\x5f\x72\x77\xe7\xf5\x8a\x9a\x26\x51\xf7\xf5\x83\xfb\x68\x00\xae\x61\xe9\x9f\x0b\x1a\x49\x12\xee\x23\xce\x0c\xe0\xee\x69\xe6\x8d\x6a\x35\xa3\xd7\x6b\x9b\x78\x3d\xc1\x90\x4d\x3c\x63\x2f\x72\x61\x7a\xe0\x6b\xe3\x3a\x58\x79\xeb\x50\x19\x32\xf3\xc8\x5c\x54\xae\xb2\x64\x8f\x71\xcf\x1c\x54\xae\x72\xd5\x23\xe4\xce\xce\x87\xdd\x69\x72\x67\x1b\x79\x91\x2b\xdd\x39\x1b\xef\x97\x3f\xc0\x75\x1c\x0c\xd7\x31\x08\xed\x77\x95\x4a\xcf\x80\x00\x20\xfc\x7a\x03\xe7\x34\x6a\xc2\x1a\x6d\xc8\x64\x54\xe9\x39\x03\xe1\x47\x55\x19\x06\xbd\x91\xd1\x7a\x1c\x0e\x8f\xc7\xda\xc2\x7b\x00\xa3\xc5\xeb\x28\x63\x2a\x16\xad\x1e\x5c\x2f\x73\xde\x7e\x5b\x1d\xa8\xdc\x0b\x25\xf8\xa0\x0e\x82\x7a\x08\xed\x09\x19\x4a\xd1\x99\x65\xc9\x61\xdb\x0c\xe3\xd4\xaf\x4e\x0b\x8f\x17\x3e\x7a\x5c\x4d\x26\xcd\xc2\x95\x36\x30\xcf\x9c\xab\x8e\x06\xab\xaa\xed\x4d\xc3\x26\x4d\xf1\x7e\x64\xa3\xaf\x3c\x1f\x1c\x03\xe7\xfe\xc9\xc8\x2d\x02\x95\xa2\xd6\x2d\x14\x9e\x59\x04\xd2\xf3\x78\xfd\x45\x7b\xed\x53\xaf\x3d\xbc\x08\xaf\xe5\x84\xae\xcf\x55\xb3\x99\x7e\xd0\x73\xbf\x34\x17\x66\xaa\xaa\x08\xa7\xd7\x6b\x33\xc7\x74\x61\x73\xb8\x9a\x20\x6a\x18\x9d\xce\x58\x15\x71\x38\xa0\xdd\x70\x50\x46\xff\x33\xc0\x73\x88\x37\x5a\xd5\x29\xf8\x45\x4e\xc3\xab\xad\x34\xdc\xfc\xb4\x45\x11\x9a\xc8\x05\x14\x16\xd9\xa5\xaf\xcf\x23\x4d\xc9\x79\x9a\x02\x31\x9a\x14\xdc\xca\xd5\x7c\xc8\xe3\x82\x4a\xd7\x9a\xa1\x8c\x94\xfc\xb5\x6a\xf6\xdf\xae\xd3\x08\x6f\x86\x5b\xde\x9e\x70\xe9\x15\x4d\xaf\x4f\x9a\x7e\x85\x77\xd3\x0d\x1a\x30\xe8\x61\x2d\x37\xb3\xd7\x3d\x73\x75\x3b\x5e\x7c\x90\xd6\x6a\x54\x73\xeb\x36\xcf\xd3\xee\x64\xfa\x9d\xb3\x79\x6b\x3f\x5d\xbc\xe6\xc6\x1b\x16\xad\xbd\x76\xc9\x80\xb5\xd4\x68\x4f\xed\xf9\x19\x35\xd7\x5a\xaf\x9c\x7b\x57\x23\x75\xcf\xf9\x19\xae\xfa\xda\xb4\xe1\xca\xcb\x36\xf4\xa3\xee\x11\x7d\xb1\x77\xa1\x4d\x39\x0c\x75\x92\x8f\x18\x9c\x8b\x30\x76\x0f\x69\x27\xf5\x04\x11\xd0\xfb\xe1\x57\x2e\x7b\x3b\xef\x63\x5c\x94\x06\x9a\x13\x78\x0a\x7c\x6e\x24\x69\x26\x7f\x5d\x24\xda\x90\x42\x19\xb6\x64\x3c\xa8\x28\xe8\xc6\xec\x8b\x6b\xa1\xe0\x5f\xcc\x61\xed\x81\xbf\x4d\x13\x82\x7f\x8d\xfe\x6e\x63\xf9\x55\xde\xd2\xa1\xb1\x50\xbf\x31\x33\xdd\xdf\xef\xd5\x82\x5b\xc0\x9d\xbb\x0e\x68\xb1\xe1\xb0\xd0\x47\xce\xf9\x5e\x7e\x4b\xaf\xfa\xfa\x5e\xfb\x0d\x6b\x99\x26\x28\x81\x95\xda\x2e\xfb\x5d\x23\x84\x51\xb8\xde\xc5\x8d\xf6\xbe\x81\x65\xd5\x4e\x91\xb0\xce\xe3\x75\x7a\x25\xb2\x3a\x4e\xa7\x41\x04\x91\x6a\x7b\x11\x59\x9d\x92\xab\xee\x37\xe9\x34\x31\x57\x28\x22\xd3\x1c\xb5\xbf\x77\x51\xb5\x8a\xfb\xc9\xdd\x87\x30\x93\xe6\x8d\x93\x14\x4c\x9a\xb1\xdb\xcf\xb3\xd4\xb9\xe5\xf9\xba\x0f\x66\xb4\x45\x45\x6f\x21\xc4\x5a\x8d\x33\xaa\x25\xcc\xd3\xb8\xf6\x60\x58\x2e\x56\x4a\xeb\x7c\xbe\x48\x80\x0e\x54\x59\x8d\x6e\x77\xb5\xce\xd7\xce\xeb\x74\xd0\x3d\x8c\xc3\x7d\x05\xfd\xf4\xf2\x42\x8e\xea\xd5\x7c\x02\x16\x64\xe4\x42\xa3\x8c\x9c\xad\x8a\x49\x91\x2c\xed\x44\xd1\x5e\x05\x59\x2b\x83\x94\xc9\xe0\x1f\x89\x42\xf8\x6b\x21\xef\xdd\x29\x74\xdd\x81\x40\x3f\x1e\x03\x86\x81\xfd\x1b\x22\x25\x91\xe1\xd9\xfa\x31\x2b\x97\xf8\x30\xfc\xc7\x89\xbd\x9b\x7e\xbd\xff\x8d\xdd\x9b\x3a\x1f\xb0\xdd\xf6\xf3\x16\x04\xf9\xb1\xed\xf6\xc0\xe0\x80\xc3\xe7\x8b\x87\xea\x07\x0f\x1e\x3d\xfe\x89\xbe\x6d\x53\x45\x00\x90\xd7\x7f\x42\x55\x15\xc7\xbf\x7f\x03\x5c\x23\x71\x86\xd2\xbb\xe9\x75\xf0\xfc\xa7\x91\x6c\x21\x0d\xb4\x65\x49\x52\x43\x56\x38\x2d\x7e\x7f\x25\x47\x34\xc1\x77\xa0\x32\x18\xca\x9a\x79\x8f\x81\x53\xc1\x88\x57\xe5\xf8\x7f\xca\x06\x70\xab\x6c\x81\xa5\xdb\x59\x57\x24\x1f\x28\x62\x1b\xa5\x9e\x34\x4b\xa4\xa2\x5b\xae\xd8\x9b\x5e\x2c\x09\x76\xcb\xf9\xb7\x30\xef\xe8\xec\x19\x93\x1e\x9c\x4a\xbe\xd4\x38\x0c\xf5\xcc\x8a\x44\xa3\x97\x4c\xed\x3d\x28\x2f\x18\xff\xa8\x30\x69\xd5\x1d\x77\x75\x6e\x58\x03\xff\xc2\xef\x4a\x18\xc2\xd6\xc0\xd8\xd0\x01\x2d\xe0\xd0\x5c\x22\x6c\x64\xbd\x2a\x87\xc3\x6b\xa4\x62\x71\x3b\xdb\xc1\xdb\x29\x0b\xf4\xa0\x2c\xb4\x16\xc6\x58\x5a\xab\x64\x99\x7d\x45\xfd\x91\x84\xf2\x26\xc0\x9c\x07\x88\x84\xfa\x15\xa1\x58\xcb\x58\x07\x99\x30\x90\xc8\x3c\xb1\xff\xa8\x52\x89\xa4\x25\xc0\xff\xd3\x29\xe1\xef\xff\x78\x48\x38\x7f\xc7\x5b\xe0\xda\x73\x73\x7e\x37\x82\x0c\x9e\xbb\xba\xed\xd9\xea\xe3\x87\x67\x1c\x11\xbe\xbe\xef\x35\x61\x13\xb2\x66\xaa\xb1\xe7\x66\x4c\xbc\xf5\xa7\xfb\x7e\x02\x37\xbf\x67\x3a\x47\x97\x7a\xe9\xa9\xee\x63\xc2\xa6\x3f\xbf\xfd\x25\x7e\x27\xc2\x28\xa6\x02\x9e\x0b\x3b\xdc\x71\x03\x73\xb1\xa0\x86\x74\x03\x8b\xc5\xad\xa1\x22\x51\x33\xd9\xcc\x9b\x4d\x06\x2f\x34\x65\x9c\xca\x81\xdf\x86\xb5\x89\x27\xbc\xdd\xb5\x56\xd1\xfc\xad\x51\x94\x4c\xcc\x17\xb3\xc0\xb9\xa3\x56\x89\x1a\x2f\x90\xa9\x48\xa9\x4d\x5f\xdc\x36\xa8\x4c\xf8\xf9\xdd\x87\x5f\xbb\xe3\xec\xd6\x8a\xa5\x4b\x7b\x81\xe5\x7f\x9f\xa1\xee\xb4\x9d\x1f\x3e\x68\x5b\xf3\xb4\xdd\xed\x97\xc2\x19\xe9\x85\x5b\xbe\xef\x7a\xef\xf0\x76\x60\xdb\xae\x37\x9c\xfd\x87\xab\x12\xfc\x08\xee\x07\xd7\x05\xd7\x9e\xdf\xb6\x72\xbd\x98\x0f\x82\xbe\x87\x0b\xe3\xa8\x04\x89\xe1\xb9\x04\x6b\x30\x58\x48\x44\x42\x43\x85\xc2\x2a\xab\xcf\xda\xc1\xb3\x7a\xf8\x87\xe5\x7c\x6e\xb7\x8f\x32\x58\x38\x4b\xbb\x98\xc5\x12\x5d\x0c\x8c\xcb\x9b\xea\x96\x7c\x56\xe0\xa4\x20\x90\x14\xc9\xbb\x28\x64\xe3\x6a\x1c\xe4\x09\x70\xcb\xfa\x8d\x77\x5f\x41\x7e\x87\x91\x52\x9a\x44\xa4\x14\xc5\x65\x85\xfb\xc3\xaf\xc9\xd9\xe0\x92\xf5\xb7\x76\xae\x04\x8b\x3e\x39\x23\x0c\xc4\xc5\x77\xd2\x15\xc5\x53\x79\xbe\x5a\x68\x03\xc3\x30\x02\xe1\x73\x95\x4e\x5b\x09\x74\x5d\x8d\x94\xbe\x4a\x5f\x19\xf1\x6b\xfc\xa9\x60\xaa\x95\x0f\x72\x16\x77\x33\x6f\xb7\x5b\x80\x51\x83\x09\x34\xbd\x6c\x8c\x8e\x35\xf3\xb4\xa3\x08\xe2\x59\x52\xa8\x92\x4f\xa1\x70\x99\x50\x3e\xae\xa8\xb3\xb6\x9b\x53\x81\x5b\xe1\x95\x97\x4a\xd4\xcb\x22\x63\xad\x5b\xa6\xb2\xfd\x29\xf1\xfc\x43\xc8\xcd\xb0\xfa\xeb\x06\x0c\x77\x67\x1f\xbf\x63\xd9\xc6\xce\x46\x05\x9d\xed\x52\x4c\x60\xab\x91\xfa\x6d\x99\xf6\x3f\x7d\x80\x6e\xca\x96\x6e\x14\xde\x3e\xf8\x64\xe7\x04\x05\xaf\x6d\xd7\x4f\x5d\x41\xfa\x67\xfc\x9e\x42\xc4\x9c\x5c\xef\x00\x11\x0a\xc1\x00\xd7\x6d\x36\x12\xd0\x42\x1a\xdc\xb4\xd3\x64\x8a\x38\xc3\x41\x8f\xcf\x03\x6d\x85\x95\x86\x2f\x2e\x44\x75\xf0\x74\x88\x0e\x39\x7d\x94\xcd\xed\x74\xa3\x42\x61\x27\x7c\x73\xc7\x6b\x14\x78\x37\xa9\x6e\x3e\xad\xb2\x9e\x0c\x03\xc5\xf4\x82\xef\x0f\x0a\x48\x41\x25\xc0\x31\xd8\x5b\x8c\x52\x0a\xd0\x1b\xea\x73\xe1\x93\xc3\x97\xbc\xf8\xd4\x6b\xe7\xfe\xfc\x0f\xe1\x21\xe0\x5b\xa7\x15\x5e\x10\xfe\xf6\x43\xf6\xb8\xa6\xf3\x7d\xcd\x43\xa7\xf6\x6a\xc8\xde\x9a\x77\x6c\x54\xe5\x8f\x9d\xaf\x3c\x0a\xce\xec\xd9\x2e\x1c\x1b\xd7\xf9\x06\xf4\x10\xe7\x09\xc7\xf3\x00\x38\x5e\x44\xb7\x4e\x44\xa0\x4e\xd3\x42\x1d\x50\x4a\x8c\xcc\xc5\x63\x09\x93\x39\x40\x51\xe6\x04\x55\xa6\x75\x3a\x53\x01\x2d\x61\x33\x9b\x6d\x36\x43\x3b\x6f\xa3\x13\x09\x02\x57\xd3\x59\x8b\x4b\xd9\x2b\xb1\x0d\x04\x85\x24\x44\xbe\x18\xac\x4e\x81\xd6\x6d\x95\xd5\xb5\x51\x91\xb4\x37\x02\x70\xf0\xc5\x93\xbf\xff\xc7\x1f\x57\x0d\xb9\x65\xd9\xa6\x2b\x1b\x07\x54\x1f\xdb\xf5\xfc\xe9\xc3\xdf\x1e\x7a\xa0\x79\xe5\x35\xfc\xd1\xaa\x41\x03\xb2\x13\xbf\xb0\x3d\xb2\xf3\xc9\x8f\x06\xf7\x1f\x3d\x6f\x74\xeb\x94\x91\x0f\x01\x67\x6a\xf3\xed\x3b\x8e\x0f\xa9\x1d\xb7\x62\xc2\x9c\x2b\x87\x55\x1d\x86\x1e\x42\x42\xcc\xd3\x75\x9d\x21\xcf\x42\x3d\x50\x4e\x0c\xc8\x85\x35\xce\x10\x41\x98\x13\x4e\xba\x22\x1d\xd2\x94\xd9\x12\x89\xb2\xb2\x48\x33\x5f\xe6\x40\xc2\xe8\x9b\x79\x1b\x77\x21\x19\x0a\xa9\xec\x6c\xaf\xfe\xaa\xfc\xad\x88\x84\x62\x6d\xc4\x40\x2e\x08\x27\x13\xdb\xf8\x58\x4d\xeb\xec\xcb\x66\xb7\xd6\x0c\x1b\x9e\x69\xf7\x37\x54\xc6\x76\xcc\xba\xe9\x8e\x9a\x96\x59\x0b\x66\xb5\xd4\xec\xbb\xfa\xe2\xe1\xe9\xd2\xcc\xe3\xc3\x36\xdd\xff\xde\x45\x97\x0d\x4f\x85\x43\x95\x23\xfa\xf4\x1e\xe8\x72\x2e\x38\x11\xbc\x7a\x56\xd3\xac\x41\xa5\xe1\x50\xaf\xa6\xc6\x5b\x07\xaf\xf8\x87\xc5\xbf\x04\xe5\xe4\xcf\x13\x04\xbd\x13\xdf\xed\x8d\xc3\xba\x81\x15\x46\x83\xf3\xcc\x66\x42\x07\x23\xc4\xa1\xb9\xb8\xc6\x19\xb1\x98\x28\x7f\x89\xdf\xe4\xa4\x53\xe5\x84\xad\x99\xb7\x10\x44\xcc\xe3\x51\x41\x3b\x03\xf4\xf0\x5c\x95\x94\xe8\xe5\x5a\x56\x85\xc7\x5b\x94\x20\xb6\xca\x30\xf9\x70\xf9\xad\xa2\xef\x55\x80\x95\x90\x98\x0f\x45\xf1\x54\x2f\xf4\x9e\xd4\xa7\xa2\xdf\xf8\xfa\x43\x4b\x97\x19\x5e\xce\xf6\x1b\xd9\xb1\x61\xda\xac\x45\x86\xe3\xc6\xf1\x99\x78\x45\x65\x74\x3c\xdd\xda\x56\x5f\xde\x70\x71\x5d\xaa\xff\xaf\x67\x57\xdd\xd4\x30\x8c\x1e\x11\x9a\x39\xa2\xfd\xf6\xf5\xcb\xfb\x0d\x3b\xb7\x63\x6c\xdd\xad\xbe\x05\xaf\x59\xa0\xaf\x7c\x56\x18\x8d\x6b\x75\x4a\x60\xcc\x51\x91\x88\xc2\x08\xdd\x63\x57\x79\x54\xfa\x58\xac\xcc\xa4\xd7\x97\xfa\x13\xd1\x44\x33\x1f\xce\x85\xa2\x26\x86\xb1\xdb\xa9\x16\xde\xee\xd0\x9a\x51\xd0\xa1\x55\x88\x22\x16\x23\x7b\x4e\x28\x93\x5d\x05\xb6\xf8\x42\x31\x0e\x7e\x27\xb2\xdb\xd5\x08\x7e\x93\x20\xd8\x1a\xdb\xb7\xa6\x50\x9d\x6b\x0c\x94\x5c\x88\x2f\x78\xee\x1b\xaf\x8a\xb5\xb9\x63\xd8\x22\xe6\xe0\xa9\x78\x9f\xd5\x48\xb5\x56\x0e\xa2\x21\x17\xa0\x18\xce\xce\xd8\x9d\x7a\x8d\xc6\x25\xc3\x5a\x99\x1c\x6a\x47\x07\xaf\x63\x18\xb1\xa2\x34\x53\xd0\x77\x52\xcd\x54\x9e\x95\x51\x56\xcb\x52\x7d\x94\x78\xba\xc1\xbd\x4d\x73\xa2\x48\x17\x1f\xa5\xa6\x88\x95\x51\x27\x4f\x69\x3b\x37\x69\xff\x74\x92\xfe\xb2\xb2\x2f\xbe\x11\x39\x76\xca\x72\x6e\x1e\x3e\xc5\x9b\x44\xce\x65\x8a\x84\xfa\x38\x41\x8c\xcd\x95\xea\xd4\x46\x63\xc8\xa3\xb1\x79\xa8\x24\x59\xb8\x95\x02\x56\xab\xd3\x69\x6e\xe1\x9d\x0e\xbf\x0e\xb5\xd7\x85\xd4\x26\xa2\x31\x53\x5c\xf0\x5d\x59\x7c\xdb\xa6\xbc\x96\xc2\x0b\x28\x15\x72\xe6\x79\x8d\xe5\x7c\x16\xf9\x31\xd6\xb1\x43\x3d\x5e\xbc\x80\x78\x95\x33\x57\x8f\x15\xd7\xf5\x26\x03\x56\xc3\xf4\x5b\x8b\xec\x8b\xef\xbd\x0f\x2d\x61\x12\x2d\x70\x2c\x23\xad\x6b\x62\x18\xd4\xbb\xa8\x7e\x4d\x18\x85\xd7\x34\x08\x65\x48\xfa\x02\x2a\x8d\xc6\xed\x30\x98\x4c\x8e\x00\x15\xa2\xa0\xd2\x21\x03\x81\xa0\x0a\xdf\xec\x04\x29\xa3\xd1\x62\xd1\x75\xf0\x16\x6f\xd1\x09\x46\x65\x69\x19\xa5\x12\xca\xc7\x1c\xe2\xda\x16\x36\x77\x34\x82\xf2\xbe\x59\x29\xb9\x4e\x9f\x11\xd7\xf8\xac\x6a\xe1\xc4\xea\xec\xc0\x54\xdb\x4d\x17\xdd\x34\x42\xff\x91\x58\x9a\xc6\x34\xa0\xa5\x3e\x7b\x4d\xd4\x7f\x43\xf5\x9a\x9f\x02\xa3\xd7\xcd\xad\x1f\x4e\x7f\x88\x0a\xd3\xd0\x3e\x40\x75\x44\xaf\x41\x3f\x37\x4d\x8c\xcb\x25\x22\xf1\xb8\xdf\x63\x05\x20\x45\x78\x88\x0a\x0d\x6d\x32\x55\xa6\x22\xfe\x20\x74\x9e\x80\x15\xfe\x01\xce\xb4\x3e\x48\x39\x93\xcf\x00\xf7\x93\xbc\x53\x76\x77\xf3\x57\x51\x99\xee\x4e\xa1\x34\xf5\x62\x4f\x17\x71\x04\x4a\x8e\x89\x9c\x7c\xc3\x3c\x41\x38\xca\x60\x6e\xcf\x76\x5c\x2b\x79\x83\x1d\xf7\xaf\x1c\x5f\x22\xbc\x7d\xe6\x9b\x1f\xb5\x77\xee\xd1\x90\x2e\xcd\xc1\x75\x5a\x50\xfe\xc2\x0f\xfe\x3b\xf6\x6b\xa0\x48\x6f\xb8\x2f\xae\xce\x7b\x84\x23\xee\x9d\x53\x22\x38\xbf\x3c\xff\xfc\xa1\x6c\x0d\x55\x8a\xb3\x55\x1f\xd5\x55\x09\xbf\x1e\x7d\x14\xfd\x1f\xde\xef\xa8\xf6\xe9\x33\xe8\xf3\x96\x13\x53\x73\xd5\x65\xd0\xdf\x8d\x05\x58\xd6\xad\x8e\xa9\xd3\x9c\xce\xe1\xa8\xd0\x40\x43\x1f\xd0\x04\x34\xfe\xd2\xd2\x64\x13\x6f\x2d\x35\x85\x61\x24\x12\x76\x88\xe8\xef\x05\xda\xec\xbc\x0f\x8c\xba\x48\x7a\x78\xc1\x19\xb3\x92\x40\x9b\x2d\xf6\x80\xd9\xff\x45\xa8\x1d\x3d\x22\x49\x7d\x64\xcf\xec\xdf\xe4\xd6\x3e\x36\x60\x5c\x5e\xe2\xd9\x6f\xd4\x76\xee\xef\x41\xb5\x0d\xe5\xbc\xbb\xeb\x07\xe6\x1f\x70\x0f\x96\x11\x1d\xb9\x1a\xca\x62\x64\xfd\xb1\x50\xa4\xc4\xed\x8e\xc4\x58\x0b\x93\xd2\xa9\xd5\xe5\xda\x48\x24\x6a\xf4\x47\xfd\xd3\x78\x55\xdc\x07\xe3\x17\x93\xcf\xe7\x80\x47\xc3\x41\xc0\x50\xc6\x92\xcf\x32\x56\x16\xd5\x4a\x66\x8a\x2d\xa3\xb8\x2b\xe3\x35\x16\xe8\xa6\x25\x51\x65\x64\x12\xee\x4e\x7c\x9f\x85\x59\x5f\x6a\x7b\x11\x8d\x40\xae\x9a\x14\xcb\xc4\x0f\x7d\xde\x79\xcb\xb2\x30\x59\x99\x1c\x18\x6a\x7e\x61\xb8\x7a\xe7\x2b\x8f\x08\xc7\x4f\x76\x0a\x9f\x02\xfb\x7f\x7c\x7d\xdf\x1c\xd7\x3a\x70\x0c\x59\x79\xf1\x2b\x6f\x1f\x18\x00\xe2\x80\x7e\xe0\x85\x00\xb8\x58\x38\xb2\x9e\xbb\xbc\xe4\xe7\xbd\xcf\x0b\x5f\xde\xf3\xc3\x1f\x3b\xc1\xf0\xe4\xe5\xdc\x7a\x30\x52\xd8\xe7\x17\xfe\xf1\xd3\x91\x63\xd2\xde\x65\xa6\x31\x2d\x50\x37\x5f\x94\x8b\xeb\x8c\x46\x15\xe5\xf5\x5b\x1d\x8e\x44\x34\xea\xa7\xa8\xd2\x32\xbf\x3f\x14\x72\x41\x3f\x86\xd6\xa9\xd4\xaa\x76\x1e\x2a\x32\x0e\x6f\xdd\x42\x35\x41\x11\x4b\x87\xb3\x10\x5d\x16\x8c\x7f\xf7\x3d\x5a\x87\x38\x21\x14\xe6\x14\x6d\x66\x72\x4f\xf1\x1e\x7d\xf1\x5f\xfe\xcb\x55\x97\x06\x1b\xed\x7d\x47\xa7\xda\xe7\x2d\xee\xd0\xcd\x82\xfb\xd8\xd6\x73\x6f\x92\x57\xc7\x02\xd7\x05\xac\xf0\x4c\xce\xbc\xa4\x74\x68\xe7\xa1\x2f\xcf\x43\x99\x50\x4d\xda\xd3\xd0\x8f\x41\x7c\x04\x46\x87\xd9\xa9\xe1\xcc\x5c\x80\xf4\xfb\x83\x5e\x1a\x35\xc1\x78\x78\x82\xf0\x52\x66\x87\xd5\xd1\xce\xc3\x9f\x69\x0c\x56\x4a\x6b\x32\x98\xa0\xcf\xa6\x04\x22\x94\xfb\x8a\xf3\xea\xb0\xbe\xf8\x92\x1e\x1e\x42\x59\x51\xcb\x84\x8c\x58\x0b\x32\x6b\x07\xaa\xbc\x75\x55\x7d\x72\x51\xe1\xf6\x26\x51\x5f\x8f\xfd\xfb\x46\x2d\x19\xd5\xbe\xfc\x3c\x18\xdc\xb8\x75\xd6\xb8\xd1\x74\x9f\xcd\x36\x5f\x63\x6d\xe7\xb3\x42\x0e\xa3\x23\x3f\x4b\x7e\x81\x99\x17\xd7\x91\xcc\x25\xb3\xbc\x62\x3e\x72\x9c\x30\x94\xf9\x9c\x59\x07\x7d\xeb\x21\xb9\x68\x00\x25\x47\x49\x97\xdd\x1e\x65\x48\x32\x82\x48\xb7\x1d\x0e\x2b\x61\x0a\x04\x08\x83\x89\x60\x5b\x78\x0a\x5d\xa4\xd6\x88\x45\x31\xe6\x4c\x7e\xca\xf9\x3a\x5c\x38\x69\x4a\x49\xa6\x9d\x0d\x4b\x93\x95\xdd\x68\x60\x24\x1d\x98\x4f\xdb\xd3\x1b\xf3\x69\xab\x01\xb1\x81\xac\x19\xb1\x67\xce\xc5\xfd\x62\x95\x36\x5f\xf9\x90\x39\x55\x9d\xfc\x82\x5b\x57\x0a\x43\x0b\xa4\xda\xe9\xce\x18\x75\xfc\xfa\x6b\xac\x7f\xb8\xdc\xd6\xda\x76\x6e\xc1\x73\x0f\x37\xa3\xfd\x84\xeb\xe5\x30\x9f\xec\x25\xb9\x5a\xd4\x55\x66\x30\x9b\xdd\xac\xc6\xee\x74\x1a\x35\xc0\xcd\x78\x75\x3a\x9f\xc7\xec\x36\xc3\x08\x06\x90\x00\x2e\x39\x49\xba\xb5\x0e\x87\xdb\xa2\xa7\xb5\xa8\x0e\x4b\xa3\xc5\xa6\x52\x19\xda\x14\xe5\x7c\x8b\xd3\x65\x22\x11\x4c\x58\x3e\x27\x2c\x08\x43\xe7\x58\xa2\x86\x08\x67\xc1\x69\xe1\x2f\x26\xd0\x06\x96\xbd\xfe\x4b\xfb\xe0\x21\xbd\xa9\x39\x9c\x70\x1b\x88\x98\x84\x27\x84\xa6\xef\x97\xfe\xb7\x7c\xf6\xd0\x29\xe7\x33\x66\x72\x4b\x1b\x38\x6b\x3b\x0d\x1a\xc6\x0b\xaa\xb6\xce\xe7\x9c\x5a\x40\x08\x6b\xa6\x8a\xef\x40\xe6\x0c\xc7\xb2\xb0\x1a\x9b\xc3\x43\x51\xd0\xd3\x77\x68\x60\xb8\xe6\x83\x72\xb9\x5c\x5e\xb7\xd9\x05\x3d\x15\x0e\x0a\x0e\xfd\x15\x00\x5c\x5a\xbb\xdd\x65\xd7\x53\x5a\xaa\x19\xc9\x62\xfa\x9f\xb2\x74\xf3\xf6\x51\x93\x6b\xd8\x9a\xe7\x0a\xa7\x32\x6c\x98\xc2\x96\x0a\x89\x92\x36\x01\xf2\x9f\x0a\xca\xf0\x0f\x4c\x82\x70\xee\xd8\x35\xa3\x46\x57\x0e\xef\x9c\xa9\x01\x16\xf0\x6c\x1b\x18\x8b\xc9\xc3\x85\x8d\x6d\xc2\x3d\x95\x1b\x85\xef\xd2\x60\x1d\x94\xe1\x01\x61\x08\xdd\x04\xdf\x47\x98\x68\xce\x95\xda\x9d\x5e\x4e\x1f\xb0\xb8\xdd\x01\xce\x49\x47\x55\x14\x15\xf1\x58\x5c\x96\x0e\xde\xcb\x71\x84\xcb\xe9\x74\x51\x84\xa6\x1d\x75\x82\xf9\xe4\x4e\x30\xc5\xac\xbb\x6b\x2f\xf9\x62\x9e\x45\x37\x8a\x04\x8e\x35\xb3\x85\x17\x21\xea\x31\x50\x32\xe3\xd4\xb8\xcc\x20\x6d\x74\xd3\xac\xbf\x03\xfa\x77\x87\x2f\x37\x90\xdc\xa3\x9f\xf1\x83\xe0\xcb\xa8\x36\x75\x7e\xfd\xc1\xe7\x8f\x0a\x2f\x09\x43\x22\x01\xd0\xf7\x8d\x92\x7e\xa0\x1e\xf8\x8e\x3c\x3f\x96\x6c\xb4\xbf\x0b\x1a\x5a\x3b\x9f\x33\xfd\xeb\xcd\xd7\x85\x53\xbb\xe0\xd2\x6a\xa1\x0c\x37\x61\x9f\xa0\x29\x57\x62\xa7\x4c\xac\x8a\xf3\xfa\xfd\x1c\x4b\xd1\x21\xe8\x6e\x85\x55\x66\x33\x81\xbb\x77\x50\xeb\x8e\xcf\x47\x10\xae\x76\xb1\xb2\xa0\xe0\xcf\x88\x7e\xf0\x85\x44\x88\xd5\x72\x44\x1c\xc8\x80\xdc\x80\x8d\xa2\x3a\x95\x7c\x29\x11\x09\xbe\x17\x7e\x05\xe3\x41\x4a\x38\x62\xa2\xaa\x7b\x0f\x61\xdb\x3e\x79\x14\x0c\x31\x5e\x2e\x9c\x13\xbe\xde\xb3\xad\x63\x7f\xa6\x61\x50\xbf\x77\x84\x21\x67\xfe\x08\x3d\xab\x59\x36\x72\x48\xab\xf0\xca\xbb\xf6\xce\x97\xc6\x0a\xaf\x08\x7f\x79\xea\xa9\xfa\xd4\x1b\xc2\xb1\x9c\x98\xb3\x8b\x09\x43\xa8\xc7\xe1\x5e\x0a\xa0\x7b\x0f\x07\xc5\xb1\x2a\xb3\xdf\x0c\x25\x08\x42\x09\x42\x2a\x8b\x05\x4a\xc0\x35\xf3\x5a\xad\xda\x84\x24\x70\xb7\xfc\x5f\x24\x90\x48\xdc\xeb\xb2\x08\xbe\x01\xdf\x19\x84\x31\x85\xbb\x74\x2f\xe7\x54\x81\x47\x9f\x7b\xfb\x0f\xaf\x0b\xdf\xaa\x49\xa1\xbc\x92\xb5\xcc\xaa\x15\x3e\x04\x2a\x75\x6c\xff\x6b\xd7\x2c\x19\x7d\xe3\x44\xff\x11\x61\xc8\x89\xc3\x47\xfe\x55\x01\x3e\xad\x3e\x7b\x1b\x67\x15\x2a\xd3\x7f\x7e\x6e\xed\xfa\x40\x45\xe5\x4a\x71\xff\x7f\x06\xe7\x7c\x14\xce\x39\x85\xb0\x31\xad\x76\xb7\x41\xe3\xf3\x95\x19\xec\x34\x65\x72\x3a\xd3\x51\x8a\x2a\x77\x99\x1c\x26\xe8\x43\xaa\xdc\x2a\x83\x81\x70\xd8\xed\x0e\x53\x69\x29\x41\xc4\xbb\x4d\x1e\x6d\xa1\xfa\x8c\xf9\x82\xd7\xd4\x0a\x21\x70\x66\x0b\x6d\xa2\x70\x9e\x2e\x5f\xac\xee\x60\xf3\x59\x61\x28\xd1\x8c\xd7\x9e\xfd\xf3\x07\x57\x2f\x5a\xbe\x74\xa8\x1a\xdc\x26\x7c\xd1\x7b\xbe\x23\x5b\x59\x4e\x0a\x1a\x61\xc1\xca\xdb\x87\xac\xba\xef\xbe\xbb\xcf\xd4\x77\xb4\xb5\xfa\x5f\x15\x86\x6c\xb8\x69\xc7\x73\x0e\xfd\xf0\xb1\x8d\xd9\x34\x68\x12\x8f\xc6\xc3\xa6\xc9\x23\x06\x8f\xcf\x58\x2c\xb7\xaf\x7a\x9e\xf3\x95\x55\xde\x29\xbe\x1b\x00\xcf\xf9\x69\x68\x2f\xa2\xc4\x84\x5c\x2a\x02\xcc\x56\x9d\xdb\xed\xf3\x46\x03\x1a\x95\x95\x05\xda\x58\x3c\x80\x2f\xa5\xbc\x6a\x35\x70\x58\xa1\x6d\x34\x42\x23\x4f\x93\x11\x10\x79\x06\x78\x9e\xe4\x81\xa5\x3b\x57\x55\x7d\x65\xf7\xd6\x30\x54\xd1\x81\xc8\x90\xb2\x50\x59\xd5\x29\x6a\xec\x44\xf3\x07\x9d\x6a\x74\x09\x1c\xa6\x6a\xcf\xbf\xed\x79\xf5\xc0\x3b\x0d\x42\x3f\x13\xf8\xb6\xf5\xca\x2b\xb2\xcb\x4a\x73\x03\xd3\x2f\xdc\xf0\xec\xeb\x33\xa6\x99\xee\x1a\xf8\xe1\xc1\x17\xc8\x47\x36\xde\x79\xfd\xc1\xb1\xad\x77\x3e\x36\x7f\x5a\xd0\xf1\x10\x20\x53\x9b\x57\xef\xbb\xab\x75\xcc\x81\xeb\x11\xaf\x31\xea\xed\xe7\x30\x76\x49\x7b\xae\x86\x21\x7d\x66\xaf\x45\x17\x0e\x5b\xcc\x56\x92\x89\x41\xe3\x11\x37\x1b\x03\x70\xee\xd0\x6a\xd8\x6c\xde\x25\xa8\x01\x02\xb5\x2e\xdb\x28\x54\x1d\x48\x51\xdd\xda\x3f\x2b\x95\x80\x48\x3d\xce\x0d\xae\x19\x74\x16\xd8\x99\x59\xf1\x26\x51\xf4\xb0\x45\xb1\x68\x30\xf7\xe8\xba\xe4\x40\x7d\x62\x59\xdd\x5b\x4f\x2c\x9a\x3f\x79\x6c\xc7\xec\xbd\x1a\x6a\xcc\xa0\x81\xaa\x05\xef\xef\x1c\x35\x67\xee\xbe\x67\x85\x8f\x6d\x29\xe0\x79\xde\x15\x78\xf6\xf8\x55\xab\x5c\xe4\x48\x4f\xad\x70\xe3\x9f\x8c\x42\x9b\xeb\xa9\x6d\x5f\xfe\x80\xf6\xdf\x9b\x30\x9e\x09\xc3\xfd\x17\x26\xa6\xe7\x32\x1e\x93\x9b\xd3\x06\x83\x9c\xc9\x4c\x93\xf0\x35\x60\x4b\x68\xd4\xfb\x60\x08\x0f\x0f\x8c\xc5\xe2\x6e\xe5\xa1\x38\x16\xae\x85\xb7\x40\x93\xd8\x8c\x04\x72\xfc\x6f\x81\xba\xed\x42\x67\x3e\x68\x44\xee\x89\x2c\x10\x76\xca\x24\xef\xf3\xfb\xcd\x77\x94\xa6\xcd\x83\x56\xae\xd9\xf6\xe1\xd8\x31\x43\x06\xac\xd7\x93\x9d\x7d\x07\x82\xf9\xef\xcf\x4a\x8d\x9b\x78\xdf\x63\x3f\xdb\xfa\x7f\xb6\x7a\xf8\x0d\x2b\x1f\xe1\xc0\xa2\x48\x4e\x38\xfc\x84\xf1\xdf\xe6\x15\x4b\x1e\x7a\x12\xf1\x23\x75\x9d\x21\xe7\xc3\xf8\x37\x46\x04\x73\x9c\xd5\xdb\xcc\x43\xd7\x83\xd0\xa8\x34\x70\x96\x2a\xb3\xa2\x8a\x0e\x5a\x00\x39\x4c\x45\x67\x18\xc1\x03\x73\xe1\x48\x11\x38\x30\x3c\x29\xef\xe7\x83\x54\xae\x7e\x78\x2e\x27\x3c\x79\xdb\x75\xf1\x2a\x93\x6b\x5c\xdd\xa8\x49\x0d\x43\x6f\xa1\x26\xe0\x10\x75\x86\xb3\x7e\xfa\xc0\x7e\xcb\xc7\x08\xff\x86\xb3\xf2\x95\x8f\x1d\x99\xbd\x64\xe0\xb5\x1b\x22\x22\x9e\xc3\x72\x61\x34\xf5\x2d\x75\x8c\xe0\xa0\x65\xcb\xe5\x42\x66\x35\xdc\xff\x36\x03\x65\x00\x3e\xe0\xe5\xcc\x76\xb5\x53\xeb\x6c\xe1\xb5\x9c\x88\x84\x01\xbc\x45\x57\x08\x85\x0b\x1d\xe9\x7e\xd9\x2a\x37\xf9\x8a\xab\x44\x30\xd9\x18\x21\xa5\xe2\x1e\x14\xfe\xa2\xbe\xf9\x2f\xcb\xd5\x20\x15\xdb\x7f\xea\xaa\x15\xc2\x4d\xc2\x22\x03\x54\x94\x99\xb6\x61\x0d\x77\x5c\x25\x8c\x4e\xbb\xe9\xf7\xdc\xe9\x37\x3e\xdb\x76\xa3\x20\xac\x5e\x3e\x6c\x3e\x18\x7f\x6a\xf2\xbc\x31\x97\x89\x67\xf2\x3e\xf8\xb7\x80\xb9\xa7\x6d\x4f\x23\x0c\x36\x06\xd7\x4f\x9d\x90\xd9\xa8\x32\x51\x73\x46\x98\x3e\x1d\x3e\x40\x90\xc4\x2a\xf8\x0b\x4f\x4b\x3c\xd5\xc1\x9c\x81\x66\x00\xc1\x10\x6a\x0d\xa9\x02\x88\xd1\x21\x73\xa2\x26\x0f\xc9\x8b\x6e\x26\xcd\x19\x0a\xfe\x01\x4f\x4f\x9f\x7e\x02\x0d\x70\x76\x31\xfc\x4d\x40\x18\xe0\x18\x3f\xc0\xaf\xac\xc8\xc6\x68\x18\x8b\x91\x24\x75\x2c\xc5\xc1\x95\x61\x28\x9b\xdd\xac\xd1\x42\xcb\x68\xd4\x02\x46\xc5\xb4\xf3\x16\x95\x16\xfe\xab\x47\x37\xd3\xc7\x45\x7e\x7b\x05\x15\x44\x3e\xd5\x92\x8f\xde\x30\x35\x54\x6d\xa6\x16\xfe\x41\x3f\xb0\x47\xed\x19\xf0\xc3\x4b\xd3\x5f\x82\xff\xa0\xbf\xc0\x7f\x05\x0d\xf8\x6f\xdb\x91\x36\xb2\x77\xe7\xeb\x6d\x47\xba\xba\x88\xed\x5d\x9f\x93\xcd\xb8\x2e\x93\x96\xeb\x34\xb5\xa3\x54\x1f\x73\x18\x67\x8d\x4b\x12\x0d\xcc\x6b\x62\x2f\x82\xea\x3b\x30\x96\x50\x3f\x45\x55\x33\x09\x42\xec\x7d\x43\xcf\x6a\x00\xb3\x3e\xff\xec\x14\xf4\x2c\x07\x9f\x65\x7e\x91\x31\xd8\xd8\x3e\xf8\xe7\xc3\xc4\x9f\xd3\x84\xf8\x73\xba\x5a\xac\x2d\xef\x3a\xa3\x16\x31\x4c\x30\x76\x02\x91\xa6\x17\xcb\xf8\x0e\xaa\x1b\x30\x1e\x89\xf8\xfd\x31\xf4\x52\x11\x97\x41\x18\x4d\x0f\x96\x71\x19\xd0\xf7\xc9\x06\xb1\x6f\xbe\xeb\x8c\x26\x83\xc7\xa9\x16\xc7\x61\xc6\xcb\xfd\xf8\xec\x34\x3c\x8e\xf8\xfd\x31\xcc\x44\xb1\x6f\x1e\x8e\xaf\xc3\xdf\x6f\x91\xc6\xa7\x0b\x58\x83\x6c\x49\x1e\x13\x70\x35\x58\x04\x36\x43\x99\x49\x77\x5e\x66\x8c\x2f\xf8\x7b\x05\xd6\xf4\x6a\xe2\x10\x14\x0a\x3e\x13\x37\xe7\xd7\x05\x61\xdd\xf0\x78\x9c\x72\xe9\x99\x66\x3c\x0e\xb0\x14\xc6\x41\xb5\x0a\xaf\x2a\xf0\x7e\x57\x3f\x87\x46\x01\x46\x3c\x8a\x7c\xbf\x85\xc7\xa8\x91\xe6\xf2\xb5\x38\x97\x98\x72\x2e\x67\xa8\xd7\x14\xf8\xb3\xab\x89\xa3\xe2\x5c\x22\xf9\xb9\x48\x3d\x4d\x25\xf9\xbe\x23\x84\xc7\x87\xe7\x12\x2d\x8c\xd3\x1d\x7f\x74\x35\xf1\x08\x1e\x07\xf4\x18\x27\x2c\x8f\xa3\xc9\x50\x23\xe0\x33\xfa\xc3\x14\x09\xaa\xf0\x48\xb5\x85\xb1\x4e\x32\x8f\x8a\x63\xc1\x15\x9e\x7b\xf5\xb3\xb8\x93\xeb\x11\xe2\x30\x11\xc8\xe9\xa8\x60\x2d\x30\xd5\x82\x5a\x12\x04\x51\x7d\x96\xce\x38\x3c\x48\x98\x53\xb5\x12\xce\x40\xcf\x1e\x2c\x4d\x2f\xaa\x0c\x24\xc4\xcf\xe9\xdd\xed\x73\x68\xa0\xda\xa7\xfc\x1c\x0e\x75\xf7\xf4\x05\x9e\x0b\x8e\x53\x4b\xdd\x21\x8f\x53\xde\x7d\xbe\xaf\xaa\xb6\x77\x9b\xef\x6a\xe2\x39\x60\x24\x12\x39\x33\x75\x67\x2d\xa8\xac\x05\xbf\x3d\xeb\xdf\x9a\x77\x1d\xb5\x57\xfe\xbc\x9a\xee\x9f\x77\x44\xf5\x48\xf1\xe7\x11\x83\x88\x52\xa8\xfb\xcc\x4f\x76\xff\x00\xb1\xde\xb5\x02\xbe\xe7\xb1\x50\x87\xba\x88\x08\xd1\x98\x8b\xf8\x08\xc6\x62\xa1\xdd\x7a\x82\x89\xc6\x68\x37\x42\x0c\x77\x98\x1c\x41\xd4\x65\xa8\x33\x99\xd4\x2d\xbc\xa9\xd0\x71\x51\x68\x9d\x2e\xe4\x98\xeb\x62\x8d\xd2\x5d\x6c\x52\x2e\x6d\x45\x89\x4b\x90\x07\x69\xae\xd8\x02\xbc\x4f\xd3\xf3\xe6\x4c\xdc\x3c\xd0\x3f\xf9\xc4\xe4\x5d\xfb\xd7\x9d\x5d\x7d\xed\x26\x72\xc6\xf1\xef\x1a\xfa\x0c\xbd\xa5\xe3\x77\xfc\xbd\xed\xfa\x11\xcb\x6f\x6a\x48\x96\x8d\x6d\x3b\xbc\x6f\x8f\xf0\xb7\xa7\x16\x82\xab\x8d\xf7\x2f\xac\x1f\xb6\xe8\x45\xc5\x39\x0a\xcb\xe7\x48\x93\x21\x9f\xc6\x7b\x85\xa6\xc8\x84\x72\x2d\xd0\x59\xfa\x11\xef\x95\xc1\x58\x3f\xcc\x25\x1e\xec\x12\x77\xcb\x09\x71\xb7\xd0\xc1\x2c\x30\x41\x8f\x93\x22\x7b\xee\x96\x0b\x7c\x4e\x96\x44\xd8\xfa\xda\x43\x14\xe9\x11\x3f\x46\xfa\x8c\x2e\xe6\x5b\xf9\x33\x10\x76\x5c\xd7\x0b\xf8\x33\xfe\x4c\xfc\x97\x30\x1d\x24\x23\x78\x64\x6e\x78\x04\x8d\x2c\xd6\xaa\x63\x7e\x20\x55\x15\xfc\x9d\x55\x62\x1f\x22\xf9\x3d\xe8\x83\xce\x55\x59\xe1\xcc\x60\x3c\x77\xdc\xab\xb8\x57\xea\x6d\xbc\x08\x9f\x19\xaa\xbf\x74\x66\xc4\x9a\x39\x84\x47\x47\x94\x22\x1f\xc9\x67\xa0\x54\xaa\x44\x14\xb9\x13\x31\x03\x5d\x96\x52\xc5\xe2\x31\xe8\x0b\xc5\xc9\x64\x69\xb2\x9d\x8f\x97\xc6\x4b\xb5\x30\xca\x6b\xe7\xed\x76\x33\xad\x0d\xe2\x9b\x4f\x31\xb7\x53\xa9\x48\x60\xf5\xd4\xfc\x72\x19\x00\x02\x59\x63\xf3\x65\x71\xb8\xbe\x54\x59\x38\xd7\x08\x44\x20\x49\x66\x9b\x66\x95\x67\x85\x69\x45\xa4\x50\x11\xf7\xf3\x3f\x3e\xcc\x14\x15\xcd\x39\x84\x7f\x9b\x80\xc1\xb3\x47\x43\x8e\xac\xf3\xac\x6f\x7b\x31\x5f\x13\xd7\x4f\xf8\xa4\x50\x31\x77\x7d\xdb\x7a\x4f\x9d\xb8\x3f\x31\x9e\x1e\xf5\x2a\x7c\x0b\x35\xc4\xcc\x5c\x6d\x95\xd6\xe6\x74\x92\xb1\x52\xb3\x99\x8e\x11\x5a\xa6\x57\xc8\xef\xcf\x38\x71\xd4\x6a\x03\xc0\xc3\x7a\x22\x2d\xd0\x2f\xf4\x78\x8d\xe5\xcd\xbc\x91\x2b\x61\x59\xd4\xfc\xe5\x28\x6a\x12\xaa\xec\x51\x6d\x5a\x9c\x5f\x65\xb2\xd0\x11\x28\x42\xb5\xa7\x54\xa2\x6b\x5b\x28\x83\xc8\x52\x28\x36\x47\x75\x2c\x78\x63\x03\xc6\x08\xc6\x98\x92\xc3\x0f\x0e\x5b\x7e\xd7\x16\xc0\x6c\xe9\xf7\xd2\xa8\xbd\x3a\xe3\x46\xe3\xee\xec\xb1\xcd\x13\x9e\xaf\xb7\xa4\x63\x2d\x9b\xf7\x0e\xdb\xda\x67\x4d\xc3\x65\xfd\xfb\x56\xce\x7c\x6c\x3a\xff\x49\xdb\x80\x6f\x9a\x2e\x7d\x6a\xdb\x7e\x54\x7f\x6e\x39\x3f\xb0\x7f\xaa\x6d\xe1\x8c\xd2\xc0\x17\x37\x34\x2d\x01\xc3\xc7\xf4\x27\xe7\x72\x9a\x7b\x84\x3b\xe7\x2f\x27\x2e\x88\xc1\xb8\x9a\x74\x62\x7b\x09\x4a\x0a\x7b\x06\xad\xd3\x8f\x0a\xdc\xc5\xd5\xc4\x57\xa2\xbe\xce\x14\x6c\x07\xaa\x0d\x7b\x02\x8f\x53\x21\xe9\xeb\x7b\xc4\x71\x42\x85\x71\x50\x5d\xd5\x9f\x58\x56\xc4\x8c\xc2\xe3\xbc\x03\x96\xa2\x67\x3c\xa4\xb4\xf7\xd0\x1d\xfb\x02\x54\x1f\x81\x31\x4c\x47\xe4\x4a\xe2\x5a\x17\xe3\x60\x03\x30\xf6\x63\x19\x2d\x53\x9e\x26\xd2\x80\xa3\x8c\x61\xe8\x67\xd0\xa4\xb7\x83\x27\x59\xb6\x04\x46\x1a\xac\x55\xac\xf7\xe5\x5e\x2d\x00\x64\x15\xc7\xb0\xe2\x15\x47\x36\x21\xed\x32\x1a\x97\x41\xb0\x52\x9a\xbe\xb8\x1c\x82\xba\xb5\xb9\x63\xf2\x9c\xc9\xff\x10\x3e\x45\x25\x11\x3b\x01\xb8\xe3\x49\xe1\xcd\x37\x72\xfd\xeb\x2b\x52\x80\x2f\x14\x43\x08\xdb\xab\xa7\x8d\x9b\xd7\x6e\x04\xb1\xcf\x51\x4d\xc4\x6d\xff\xd9\xfa\x37\xe1\x96\x3f\x9b\xf9\x69\x75\x7d\x2d\xf4\x9c\xa2\x4a\x08\xf1\xde\x7d\x01\xf5\x0a\xd4\x85\x3e\xb8\xce\x50\x2e\xbf\xd6\xc9\xd8\xd9\x18\x8c\xca\x91\x5c\xa9\x72\xa2\x1c\x58\x29\x63\x12\xed\x2c\xd2\xd3\x8c\xe4\x0a\x35\xf3\x76\xd6\xf1\x7f\x94\x0b\x25\xe9\x2d\xf9\xc4\xb7\x2c\x56\x51\x2d\x04\xb9\x05\x89\x35\x65\xd3\x7e\x5c\x11\xb1\xe8\xdd\x95\x03\x90\x44\xc2\xcc\x42\x29\x84\x28\x51\x87\xf1\xdd\xbd\xa8\x14\xe2\xfd\xc3\x77\x75\x3d\x6c\x9d\x38\x1d\x8a\x43\x5e\xaf\x28\x83\x40\x36\x1e\xbd\x23\xd4\x1f\x0d\x1e\x53\xe0\xad\xc0\xfd\x50\xa9\xb0\xf1\x50\x5e\x8c\xb1\x02\x1e\x57\x60\xac\xc0\x67\x2a\x0a\x7b\xe6\xa0\x30\x84\x9e\x86\x7c\x36\xb0\xcc\x22\xee\x19\x47\xf7\xbd\xd7\x75\x0b\x8c\xaf\x37\xa1\xbd\x47\xb6\x49\x7b\xe6\x66\xd1\xc6\xc7\x0a\xe3\x20\xec\xb5\x4f\xd1\x33\xe0\x57\xd1\x27\xf9\x10\x3f\xe1\x92\x7c\x12\xd1\x37\xc4\x7e\x56\x12\xfb\x4d\xd8\x37\x14\xbf\xaf\x7e\x43\xf1\xfd\x29\xe2\xf7\xb1\xff\x47\xca\x18\xbc\xe8\xfb\xb4\xf2\xac\xfc\x55\x3e\x2b\x12\x5e\x32\xfc\xa4\x64\xf1\x59\x79\x15\xf7\xe1\x8e\x94\xfa\x70\x9f\x14\xe5\xae\xc9\xeb\xd7\xae\xaf\xbb\xce\xb0\xed\x30\x06\x2d\x25\x66\xe5\xea\xa0\x13\xcd\xda\xdd\x6e\x53\x32\x14\x0e\x27\x59\x8a\x49\x31\x65\x71\x1f\x54\xac\x56\x23\xe8\xe0\x8d\x21\x63\x88\xd1\xda\x39\x03\x66\x68\xb3\x68\xa9\x62\x12\x36\x97\x4c\x66\x27\x61\x60\x8a\x21\x48\x21\x05\xa8\xc8\x00\x2a\x6e\xc3\x01\x15\xce\x97\x23\x17\x68\x62\x91\x0e\xae\x6d\x04\x74\x3f\x8c\x5f\xd9\xf9\xb5\xfa\xc0\x49\x11\xe5\x72\x32\xb9\x74\xf2\x6e\x0d\xe9\x52\x3f\xb9\x8f\xa6\xc1\xa8\x8b\x26\xdf\x6c\x59\xbc\x67\x89\xfb\x8f\x4f\x09\x4f\x50\x24\xb9\x12\x21\x59\xca\x14\x31\x9d\x3f\x90\x26\x9c\x79\xee\xc7\x0d\x36\x8c\x1e\x78\xfd\x1c\x72\x4d\xe7\x9c\x0d\x9b\xff\x92\x72\xe1\x98\xea\x3e\xe8\x07\xef\x82\x67\x9b\x83\x1e\xc1\xc8\x5c\x12\xc7\x54\x56\x14\x53\x79\x80\x9b\x33\x77\xf0\x9c\x55\xed\xd0\x3a\xa6\xf1\x5a\x5a\x45\xb7\xf3\x2a\x0a\x50\xed\x3c\x50\x96\x9f\x14\xe0\xc5\x95\xd1\x15\x90\xb0\xc4\xc5\xe8\x8a\x83\xd1\x15\x4a\xb5\xc1\xf8\x14\xb0\xc2\x26\xcd\x7e\x10\xd8\xad\x01\xf3\xa2\x8f\xbd\x7c\xdb\x7a\xa1\x45\x68\x37\x93\x8b\x26\xb6\xac\xba\x57\x18\x5d\xeb\x55\xb5\x7a\x6a\x5f\xfb\xe3\xf3\x0f\x09\xbb\x3a\x85\xad\xd3\xa0\x2d\x1a\x77\xd9\xf5\x1b\x2f\x80\xb3\x35\x08\xcc\x13\xdf\xb3\xc2\x9f\x1e\x81\x6b\x44\x65\x6c\x2d\x91\x8f\x01\x3e\x11\x96\xf7\x9c\x68\xe3\xff\x04\x7f\x7e\x9b\xd4\xbf\x7d\x9a\x1c\x49\xe8\x8e\x50\x37\xa6\x52\x76\x7b\x11\xb7\x0b\xad\x67\xcb\xf2\xbe\xc4\x12\x30\x14\x6c\xcb\xf3\xb1\x38\x73\x26\x72\x41\x30\x98\x4a\xc5\x69\xea\xa1\x54\x5c\xe2\x65\x29\xb6\xf7\x7f\x95\xed\x3d\xb1\x84\xba\x52\xc4\x69\x49\x22\x9c\x16\x32\x70\x28\x59\xc6\xe8\x8a\xf0\xbb\xa1\xed\xc7\x73\xde\x2b\xcd\xe9\x19\xdc\x23\x4e\x7d\xde\xb7\xbf\x43\x81\x1f\x8c\xb9\xaa\xf0\xb8\x5b\xa5\xe7\x24\x2c\x6c\x0a\x3a\x12\xd4\x47\x65\x69\xda\x54\xd4\xcf\x8d\x39\x13\xf0\xb8\xcf\x4a\xcf\x33\xe2\xb8\x5f\x96\xa4\xa4\x47\x15\x98\xe8\x79\xbe\x4a\xf2\x14\xf9\x37\x38\x2e\xf2\x7b\x02\x45\x7e\xcf\x2b\x05\xee\x1c\xf8\x4c\xab\xe4\x1b\x95\x99\xa5\x67\x7a\x60\xab\x9f\xa6\xa2\xa2\xfe\x09\x16\xc7\x3b\x4f\x29\xf0\xd4\x4f\x93\xeb\xc4\x73\x98\x2a\xb2\x59\x4a\x4e\x3e\xf8\x59\x7f\xc0\xf3\x21\xa5\x03\x2d\x73\xaf\xac\x2b\x70\xb4\xc0\x67\x7c\xd2\x7c\xd2\xf9\xf9\x74\xc7\x86\x3e\x0d\x7d\xff\xee\x36\x14\x8d\xb3\x36\x8f\x07\x8d\xe6\x73\x79\x0f\x7d\x88\xea\xbe\xbb\x0a\xdc\x7a\xe4\x29\x70\x87\x34\x1f\xa7\x3c\x9f\xae\x65\xf0\x99\xa1\x05\xee\x16\xf2\x14\xf1\x3e\x9e\x0f\x09\xac\xf9\xf9\x88\x1c\x7a\x05\xcc\xd2\xd3\xa4\x46\x9c\x8f\xab\x30\x9f\x71\x70\x9c\x7b\xf3\xd8\xa4\xf0\x19\x6c\xa8\xe0\x33\xb6\x42\xec\xd4\x8d\xff\x8d\x3c\x45\x95\x48\xef\xab\x54\xf1\xbe\x94\xbc\x24\x68\x7d\x82\xd2\xfa\x24\xe5\xf9\xf4\xc0\xd1\x3a\x4d\xad\x13\xdf\x57\x59\x71\x4c\xa8\xc4\xce\x3a\x4d\x2e\x13\xd7\xa7\xa4\xb0\x3e\xdd\x70\x89\xe0\x67\xdd\x27\xcd\xa7\x24\x3f\x1f\x18\x79\x53\xd1\x02\x16\x11\x5c\xc3\x35\xd2\xfa\xf8\xf3\xeb\x23\x8e\x73\x2c\x3f\xce\x69\x4a\x2b\xce\xa7\xb4\x30\x9f\x8b\xf0\x38\x4b\xf3\xe3\x9c\x26\x55\xe2\xfa\x04\xba\xc5\x96\x05\x9e\x32\xb8\x3e\xcd\xd2\xfb\x2a\xcc\xa7\x98\x73\x03\xcd\x39\x2a\xcd\xa7\xb0\x3e\xdd\x71\x41\x4e\x53\xcf\x88\xef\xab\xb4\x7b\xac\x5b\xc0\x02\x39\x4d\xde\x24\xce\xa7\xb0\x3e\x84\x0b\xda\x9e\x3c\x46\x10\xc7\x92\xff\x24\x5e\x91\x30\x81\x46\x17\x30\x81\xf0\xf7\x6f\x12\x31\x76\xa0\x3e\x56\xe0\xf5\xa8\x8f\x43\x65\x8b\xbe\x3f\x51\xac\x45\xb1\x60\xbc\x1e\x84\xc7\x34\x48\xcc\x75\x7f\x01\xed\xf5\xed\x38\x07\x3c\x2a\x97\xb0\x3b\x75\x61\x35\x61\xf6\xfb\x89\xb0\xc1\xc9\x50\x71\x2a\x16\xd6\xe9\x3c\x06\x03\xe5\x71\x3a\x3d\x1e\x6b\x3b\xef\xa1\x69\x54\xfd\x98\x51\xe4\x7c\x2d\x3d\xfb\x17\xab\xab\xe2\x48\x63\x97\x03\x9c\xba\x53\xb1\xf0\xab\xda\x5e\x61\x45\x0d\x94\x11\x5d\xf8\xd2\xa9\xce\xe7\x3a\x05\x23\xa8\x05\xd7\x1f\x5a\x32\xff\x81\x37\x8d\xa0\x19\x8c\x17\x3e\xbb\x67\x6b\x6e\x60\xc5\xa7\x4f\xfd\xf4\xf9\xa5\x4f\xcd\xd9\x70\xd7\x0f\xc2\x27\xc2\xbd\xd1\xd6\xd2\x6d\x3f\x3e\x37\xef\x66\x5d\x99\xa3\xb5\xe2\xc7\xb7\xce\x0d\x7b\x08\x90\x0d\xf7\x6e\xbb\xe4\xe8\xe6\xb2\xe0\xc3\x50\x86\x47\x84\x21\xe4\x57\xd0\x0f\x0b\xa1\x8a\x54\x8d\x2e\x68\xf3\x3b\x69\xb3\xd9\x69\x23\x74\x8c\x3b\xe2\x0e\xdb\x82\x70\xfb\x1a\x3d\x6e\x9f\x0e\xdd\xf3\x22\x77\xac\x90\xa4\x47\x29\xfa\x0b\xcc\x5f\x66\xf0\x57\x29\xeb\xb6\x50\x5a\x92\xc1\xb2\x24\x55\xf7\xea\x5e\x79\x77\x6b\xcd\xb8\xd0\x88\x6c\xe5\x86\xeb\x36\x3f\xb0\xe9\x8e\x79\x0b\x3b\xd5\x3a\x90\x04\x86\x8d\x4d\x42\x2e\x71\x6c\xe3\xef\x42\xa6\xdd\x40\x15\xbc\xec\xc6\xa5\xaf\x8d\xf4\xdd\x3c\x55\xe8\x3f\x3a\x57\xf5\xc1\x0b\x4f\x96\xb8\x64\x2c\x6f\xe8\x00\xcb\x58\xde\xab\xc1\xbf\xc0\x1d\x38\xc7\x51\xd8\x1b\xd0\xd3\xa0\xdd\xf8\x99\x51\xd2\x33\x9c\xf8\x4c\x94\x2c\xf8\x1c\xf0\x5d\xff\x04\xdf\x5d\x84\x98\x94\xb3\xba\x8c\x46\x2b\xcd\xb2\x91\x80\x35\x60\x8e\x99\xa3\x2e\xad\x57\x8b\x0a\xd5\xdd\xbc\x97\x96\x2a\xd8\x71\xeb\x86\xd9\x02\xe3\x30\x68\x89\x49\x6f\x71\x1d\xa2\xa2\x0a\xd1\x6c\x29\x2e\x96\xc6\x4e\x46\x5d\x0f\x74\x43\x4a\x06\x93\x66\x29\x7a\x2f\x86\xc9\x7e\x27\x30\x68\xcc\xfc\x9f\x46\x6e\xcc\xbb\x1a\x60\x7e\xf5\x65\xdf\x5f\xbf\x7c\xad\xd6\x7d\x52\xb8\x09\x79\x14\x3b\x9f\xe8\xdf\x6f\xf4\xc3\x8b\xce\x1f\x91\xfd\x0b\xe1\xab\x3b\x36\xaf\xb9\x26\x30\x61\xcb\x39\x04\xdd\x82\xb0\x2c\xa0\x4c\x4e\x66\x1d\xee\xa7\xed\x4b\x2c\xce\x35\xda\xaa\xcb\xaa\x75\x65\x7e\xb3\xc3\x11\x75\x91\x64\x1d\xe3\x67\xfa\xe9\x74\x0d\x61\x54\x39\xc5\xb9\xd2\x9e\x74\x2b\x6f\x76\xb4\xf0\xea\x5e\xf0\xbf\x6a\xb3\xda\xe8\x71\xd8\xbc\xc6\x7a\xf8\x92\xbd\x34\xd9\xc4\xd3\x84\xa2\x59\x48\xaa\x3a\xec\xee\x71\x64\xe4\xa6\x4e\xb3\x54\x77\x88\x0b\x2c\x40\x81\x01\x1a\xee\xe0\x28\x0c\x5a\xad\xbf\x45\x77\x00\xc4\x02\x3f\xd4\x32\x49\x99\xe8\x1c\xe2\x3c\x10\xfe\x53\x1e\x9c\x3b\xfb\xd6\xd9\x97\x2c\x30\xf5\x2b\x1b\xd1\xeb\x6a\x32\xdb\x93\xfb\x00\xb5\x1f\xc7\xfa\x64\xaa\x2a\xa8\x59\xe9\x3e\xd4\xe3\x55\x60\x9e\x2b\x7d\x36\xaa\x9b\x32\x72\xc2\x15\xe3\x06\xf6\x6e\xdf\x3e\xcb\x06\xb2\x3d\xc9\x10\x04\x22\x99\xd2\x97\x5f\x55\x83\xe2\x8f\x64\xd7\x19\x7a\x3f\x33\x1b\x5a\xcc\x4a\x62\x72\x2e\x93\xe6\xac\xee\x98\x8a\x8e\xf8\xfd\x8e\x12\x4d\x84\xa2\x34\x0e\x8e\xae\xaa\x0e\xa6\xa0\xdb\x65\xb5\x1a\x82\x41\xb7\x21\x46\xe4\x34\x06\x68\xab\x3c\x6e\xca\x10\x47\xb5\x9a\x52\x58\x0f\x83\xdc\x8c\x7c\x96\x8b\x40\x31\xf0\xa1\x80\x4b\x82\x09\xfb\x70\x91\x86\x4a\x2c\xd2\xa8\xc3\xe1\x49\x2c\x2b\x93\x67\xc3\x33\x21\xa2\x80\x44\x43\x66\x9b\x83\xea\xfb\xec\xb3\xaf\xee\xdf\xb4\xe7\x2e\xe1\xcc\xd1\xaf\x85\xce\xef\x8e\x2d\x5d\x05\xf4\xef\x19\xd6\x2e\xff\xee\x91\xc7\x9e\x15\xfe\xfb\xf2\x5b\x3b\xd6\x0b\x97\xed\x60\x66\xeb\xb7\xaf\x5e\x73\x3c\xc6\xdd\xbb\xe4\xc6\xd7\xae\x78\x78\xf3\xee\xbf\xd8\x9d\xab\x67\xde\x73\x54\xd5\xec\x5c\xb3\xec\x0f\x87\x1f\x39\x18\x3d\x57\x7a\xf8\xc0\xe5\xd7\x0a\x7b\x96\x2e\xc7\xf1\xd6\x25\x50\xde\x2c\xb3\x01\xea\x2a\xd4\x6b\x5d\x9a\x62\xb5\x5c\xd8\x4b\xbb\xac\x56\x7d\x8c\x70\x05\x02\x84\x9e\xa5\xab\x6b\xc2\x5a\x3b\x0c\xb9\xb4\x76\x3b\xed\x33\x11\x74\x5a\xaa\xb8\x95\x0a\x53\xea\xbb\x63\x17\xca\x02\xda\xe4\x08\x3e\x8b\xef\xe4\x9c\x79\xb1\x10\x75\x98\x28\x3b\xdb\x4b\x2a\x7f\x46\x01\x18\xf5\xc9\xca\xff\x6c\x7e\xe8\xd8\xb3\xdb\x0e\xef\x5b\x16\x1a\x38\xee\xe8\xcd\xdb\xdd\xb6\xf4\xbe\xed\x37\xb4\x5f\x7a\x60\xc6\xb4\x89\x3b\xa7\x1c\x9b\xbc\x63\x12\xa9\xbe\xe7\xd7\x75\x2f\x3f\xbc\x1f\xd8\xea\xab\x9f\xbc\xec\xb5\xb2\x44\xf6\xb1\x96\x17\x0e\xac\xee\xdb\xe1\x49\x0e\xde\x75\xe5\x4b\x91\xd2\xfd\x2d\x4b\xd7\xdc\xfa\xf7\xdb\x7e\xb9\xf9\x53\x31\xf7\xef\x86\xba\xf8\x16\x8c\xe3\x02\x75\xb1\xd5\xa1\xd3\x11\x0c\xeb\x30\x99\x58\x82\xf2\x90\x1a\x8d\xd7\xe2\xd3\x92\x6a\x12\x55\x44\xab\x29\xa0\x23\x74\x4a\x8c\x32\xf9\xba\xbd\xdb\x95\x15\xda\xcf\x19\xc5\xf5\x74\x58\x3c\xb0\x49\x31\x82\x74\x9b\xa9\x69\xf9\x1a\x81\xf3\xf7\x82\x5d\x9b\xf7\xdc\xfd\x8a\x6f\xda\xac\x9b\x16\x4c\xa5\x57\xe3\xda\x80\x73\x0b\xa6\x4c\x6a\xba\x6f\x7e\x7d\xbf\x85\x8d\xc3\xc4\x3e\xb6\xaf\x84\x0e\xa9\x36\x60\x44\x2e\xae\x52\xdb\x9c\x7a\x27\x47\x6a\xb5\x9c\x9a\xf2\xe9\x09\xc2\xab\x23\x35\x24\x02\x16\xd5\x98\x80\x9e\xd0\x37\xf3\x56\xc2\x4e\x34\x1e\x57\xce\xb1\x68\x86\x62\xd7\x54\x34\x0b\xf2\xd7\xff\xb2\x4e\x91\xa6\xe8\xd4\x90\xbd\x14\xd7\xff\x7f\x38\xb0\x69\xeb\x8d\xcf\x7b\x67\x34\xaf\xb8\x3e\x4d\x55\xe2\xcb\xcd\xf3\xef\x4f\x1a\x37\x66\xcd\xec\x6c\xff\x69\x7d\x06\x8f\x56\xfa\xa4\x5b\xf3\xbe\xe4\x36\x30\x4b\xf4\x05\x1c\xdd\x7d\xc9\xd1\x79\x5f\x72\x1b\xb2\xab\xca\x7c\x35\xea\x8d\x13\xc6\x21\xce\x0d\x78\xba\x56\xe7\x46\xf8\xe3\xf1\x68\x20\x10\xd2\x11\x44\xda\xc8\xd0\x96\x92\x92\x32\xb7\xc3\x51\x16\xb2\xd0\x5c\x35\x57\x15\x0e\xc7\xfc\xb1\x0e\x3e\x14\xf2\xfb\x39\xbb\xdd\xd7\xc1\x3b\x9d\x76\x3b\xd4\xb6\x76\x2a\x8e\xcb\xd6\x29\x74\xd5\xc8\x95\x73\x65\x65\x1c\x86\x42\x36\x67\x60\xf8\xaf\xbc\x3d\x95\x93\x4c\x12\xfd\xb6\xd2\x20\xe5\xdf\x66\x0d\x4e\x37\x21\x95\x04\xf7\xa4\xbc\x39\x65\x65\x7c\x41\xb8\x4d\xb8\x6b\xc9\xe7\xee\x5e\x31\xbc\xc1\x59\x55\xdd\x30\x7a\xf0\x80\xde\x82\x5d\xbb\xff\xd4\x5e\x2d\xf5\xdd\x6f\xc2\x6d\x0a\x36\x47\xcb\xf8\xf7\x2e\x5d\x68\x1f\xc5\x65\xeb\xcb\xfb\xaa\x6e\x90\xf4\x74\x37\xbc\xcd\xac\xba\x55\xcc\x81\x20\xee\xc4\x76\x68\x7b\x53\xd0\xef\x1a\x9f\xab\x2c\x0f\xf8\x2d\x3a\xa2\xd2\xed\x8e\x13\xa5\x46\xc6\xc2\xd6\x65\xfd\xe5\x4d\x3c\x5c\x1c\x7f\x89\x83\x52\x37\xf3\x54\x49\x49\xb8\x85\x37\x95\x38\x1c\x35\x18\x0c\x41\x02\xe2\xc1\xe9\x90\x42\x6a\x51\x01\x26\x73\x01\x91\x15\x89\x11\x15\x6d\x02\xd2\xa5\x3f\xba\x4a\x0e\x00\x50\xc8\x8d\xd4\x29\x04\xaf\xbe\xe9\x36\x9c\x38\xde\x22\x7c\x29\x67\x93\xf9\xd7\x26\x18\x5b\xc6\x0b\xc7\xa5\x4c\xb2\x42\xe4\xcb\x6d\x07\xef\xde\x03\xc2\x4f\x2d\x9c\x5c\xc8\x2e\x8f\x6a\xa3\xa2\xea\x56\x72\x81\xe9\x3e\x29\xb5\x9c\xf7\xa5\x71\xce\xb7\x46\xba\x87\x48\xc9\xb9\xe5\xea\xe2\xdc\xf2\x19\xea\x1b\xe6\x5d\xd1\x0f\xc6\xb9\xe5\x8d\x52\xde\xf7\x38\xf1\x97\x0b\xe5\x96\xb9\xa2\xdc\x72\x8f\xcf\xe9\x8d\x3f\x07\xf9\xc8\x91\x22\x9f\xfd\x47\xe6\x5f\xf2\x67\x90\xdb\x89\x7d\xd2\x67\x9c\x20\x7e\x25\xdc\x30\xe6\x0c\xf9\xc0\x9d\x3e\xe0\xa3\x6a\x73\x1a\xfd\xf0\x5a\x34\xbe\x79\xca\x22\x05\xc7\xf3\xd6\xbc\x2f\xbf\x0d\x1c\x17\xcf\x4b\xb8\xbb\x2f\x5f\x99\xf7\xe5\xb7\x11\x8f\x76\x7d\x8e\xe3\xb3\x6e\xb1\x85\x62\x9e\x59\x2a\x2b\xcd\x33\x5e\x34\xcf\x1f\x70\x0e\xbc\x55\xca\x81\x3f\x2c\xcd\xf3\xed\xdf\xca\x81\x4b\x58\x6b\x83\xf3\xf8\x6d\x6b\x40\xa6\x7b\xec\xd3\xc5\x0b\x43\xa9\x47\xe9\x0f\xb9\x04\x31\x99\x46\xfe\xf0\x1a\xe2\xd6\xae\xcf\x60\xe8\xf5\x30\xf4\x7b\xa3\xd0\x9f\xb0\x43\xef\xb0\x29\x57\xa6\xa6\xb4\x5a\xaf\xc1\x61\x35\x58\x55\x11\x55\x98\x52\xb7\xf0\x9c\xbb\x15\x1e\x4d\x8a\x23\xa4\xd6\x49\x95\x97\x08\x34\xe7\x3b\x64\x0a\xb8\xdf\x29\x65\x8e\x42\x4a\x52\xe4\x7d\x03\xa0\xf0\x18\xb2\x05\x77\x00\xd4\x4e\x5d\x68\xce\x25\x47\x64\x96\x31\x80\x46\x3d\x95\xc2\x2f\xc9\xe4\xdc\x59\xb7\x06\xfa\x64\xea\x4a\xa9\xd9\xe9\x3e\xc2\xe8\xa6\xe1\xfd\xf9\x1d\x97\x24\x98\x53\xd0\xf8\xc7\xb4\xc8\xf8\xef\x81\x06\x3e\x7d\x65\x0d\x3c\x5b\x23\xa0\x2f\x94\x82\x67\xab\x94\xe8\x45\xcc\xcd\xd5\xa3\x8e\xb7\x44\x98\x20\x2a\xad\xd6\x98\x9a\xaa\x2d\xf3\x7a\xeb\x62\xde\x70\xa2\x85\x77\x41\x27\x28\xec\x0a\xbb\x02\xea\x00\x3c\x55\x81\xff\xdd\x0b\xa7\x10\x88\x50\xda\x0b\x45\x02\xff\x42\xdd\x71\x2a\xaa\xa7\x43\x54\x67\x2d\x88\x7a\xa1\xc6\x39\xf5\x8a\x38\x92\x76\xb6\xb8\x08\xd5\xd7\x92\x37\x39\xdf\xe9\x93\xa9\x29\x47\x0e\x4f\x8f\x7e\x3a\x53\x43\xa7\x0e\xcb\x8f\x56\x64\xfb\x2c\x2b\xf9\xd9\xf2\xf3\x15\xc9\x94\xae\xe2\x4a\xe4\xeb\x74\x1d\x95\x70\x2f\xbd\x44\x02\x75\xfd\x87\x55\x1a\x8d\xc7\x4e\x11\x84\xcb\x67\x32\x95\xb8\x92\x2e\x87\xdd\xd3\xc2\xeb\x83\xad\xbc\x5d\x6f\xd7\x5b\x54\x96\x58\x33\x6f\x91\x8a\x0d\x68\x4a\x85\x0a\xd2\x4e\xfc\xa6\xfc\x66\x09\xe5\x52\xba\xd8\xcf\x97\xcc\xf7\x90\x98\x29\xc8\x5b\xa8\x46\x98\x94\x88\x23\x21\x27\x2f\xb2\x34\x96\x20\x57\x0f\xcc\xee\x93\xa9\xa8\xa0\x2f\x85\x4e\x9d\x58\x93\xd0\xf9\x2b\x96\x6b\xcc\x88\xbe\x93\x76\x5c\xe2\xb8\x52\x7a\xbd\xd0\xbe\xc4\x85\xd1\xe0\x2d\x68\x4b\xcd\x44\x79\xce\x01\x63\x13\x2b\x43\x92\x16\x83\xae\x89\x37\xc8\xa5\x1c\xde\x42\x29\x87\x8c\x36\xaa\x28\x69\xcc\x53\x41\xf4\xed\x49\x00\x21\x8c\x56\xd2\x3e\xbc\xf1\x2a\xf2\xad\x2b\xbb\xbe\x61\xfe\x08\xcf\x42\x00\x6a\xeb\x7a\x62\x7a\xae\x97\x9a\x09\x06\x6d\x70\x35\x32\xf1\x8c\x3b\x6e\x74\x1b\xfb\xf4\xf5\x57\x36\xf3\x7e\xce\x56\xe7\xa8\x6b\xe5\x1d\x0e\x4b\x18\xad\xa2\xba\x44\x57\xd2\xca\xeb\xb8\x22\x87\xda\xdc\x9d\x1f\x30\x4f\x5a\x9d\x47\x0c\x95\x5d\xe9\x62\x34\xb5\x64\xc1\x8d\xb6\x2a\xfb\x97\x92\xc5\x14\x62\x84\xe8\x48\x8f\x56\x40\xac\xfd\xfd\x8a\xbb\xaf\x93\x9c\xe8\x8b\x0a\x10\x79\xeb\x14\xfe\xb4\xe4\x45\x2b\x71\xc2\xd6\xac\x15\x5d\xe8\xf3\x7b\xf2\x98\x79\xab\x94\xd4\x62\x68\x5d\x52\xc2\x68\xe6\x33\x78\xce\x90\x5f\xd9\x80\xfa\xe0\xab\x61\xa4\x91\x64\xd9\x6c\x45\x05\x97\xf5\x73\xfe\xfe\x8d\xe1\x0c\x0c\x37\x1c\xae\x3e\x9e\x3e\xad\xbc\x87\x73\x9a\x6c\x65\xa8\x83\x46\x1b\x33\xc4\x5a\x79\x83\x83\x25\x71\xbf\xf5\x05\x22\xaa\xdf\x58\x1d\xb1\x6f\x43\x8a\xa5\xfa\x83\xac\x12\xe8\x2a\xc3\x2a\x68\x15\xe3\x52\xcf\x20\xbe\x36\x0a\x17\xb5\x7b\x69\xe4\x3e\xaf\x58\xc2\x3a\xf6\xd1\xe1\xb7\xaf\xbf\x13\xd0\x7b\x26\xef\x18\x63\x45\x8d\x5e\x62\x2b\x98\x30\x7b\xf8\x9a\xca\x65\x97\x5e\x3a\x63\xe7\xa4\x49\xe0\x8c\xa2\xf5\x4b\xea\xf9\x3a\xf6\x7e\xff\xbe\x83\xf7\xed\x7b\x1a\x94\xed\x76\x6f\x3e\xf8\xe4\x7d\xb8\x21\x6c\x51\x49\x90\x7c\xd4\xbb\xa1\x6b\xc3\x95\x57\x17\x7a\xc0\xe8\xae\xf5\x5d\x9b\x19\x92\x59\x8c\x59\x5e\x03\x70\xa5\xd6\xe6\xc6\xea\xfc\x01\xab\x93\x21\xb4\x6a\xaf\x27\x1a\x61\x80\x46\xa3\xd5\xc6\x2d\x3e\x97\x3b\xc8\xd8\xcc\x66\xbd\x8d\xd1\x33\x71\x8a\x00\x80\xa2\x62\x7a\xb3\x99\xb1\x39\x61\x14\x6a\x0d\xba\x83\x1d\x7c\x20\xe2\x54\xeb\xbc\x7e\xda\xed\x86\x6e\xa2\xd3\xa2\x71\xa9\x68\x0a\xa3\x10\x1e\x6f\x3c\x81\xbc\x74\x67\xbd\xa5\x3e\x5f\x31\x9a\x31\x77\x6f\x7b\x29\xf2\x8c\x30\xd1\x93\x33\x9a\x8d\x42\x25\x9c\xf1\x42\xc3\x60\xc5\x8b\x4a\x85\x81\x93\x8d\x6a\xd0\xff\x27\x59\x06\x7e\x8a\xb5\x7c\xc6\xf8\x3b\xb5\x57\x90\x8f\xbc\x90\xf9\x75\x86\xf0\xf4\xa1\xeb\x75\x42\x5c\x77\x67\x4e\x78\x58\x78\x7a\xac\xf6\x3a\xb2\x45\xd8\x7b\x05\x08\x0f\xac\x7a\xa7\x8b\x58\x69\x00\x9f\xcf\x9e\x0d\xdd\x9e\x5f\x84\x4e\x50\x21\x2c\x3c\x3f\x1f\x17\x2b\xaf\x10\x16\x9a\x6a\xe9\x67\x3a\xaf\x02\x53\x85\x5d\xe7\xcf\x4f\x3c\xe7\xa0\x81\x84\x2b\xb9\xa8\x6b\x05\x33\x87\x79\x93\x08\x13\x65\xc4\xfc\x5c\x5f\xad\xa1\xd4\x6a\x2b\x09\x93\x50\x76\xb2\xc4\x6a\x60\x68\x9d\x5e\x6f\x4c\xd0\x6e\x2f\xed\x4d\x99\x8d\xc6\x72\xf4\xf3\x12\x1b\x19\x56\xab\x3d\xc1\xa0\xa3\x9d\x07\x41\xab\x3a\xd2\xce\x73\x3a\x04\xda\x83\xf9\x70\x51\xa3\x00\x81\xd5\xb2\xa2\x5f\xc6\x9c\xe9\x51\x45\xcf\x40\xaf\xcf\x2c\x6e\x9b\x6c\x86\x75\x52\xd1\xda\x04\x66\x99\x95\xf1\xe0\x22\x49\x80\x6f\x5d\x9d\x20\x01\xec\x93\x56\x9f\x42\x70\x6f\x33\x17\x4f\x9e\x76\xc9\x6d\xe9\x01\x89\xda\xce\xe4\x8c\x5d\x05\x38\xb8\xa7\x6e\x26\x93\x08\x22\x6e\x3c\xf9\x52\xeb\xf5\x27\xd7\x83\x52\x04\xfa\xa6\xbf\xfd\x1e\xaf\xf0\xd1\x13\x5e\xdb\xb9\xe7\xc7\x4a\x70\x70\xfd\xe9\x53\x08\x1e\xee\xa5\x85\x74\xcc\x0a\x6d\xf3\x16\x78\x80\x4e\xe1\x9a\x9d\x99\x44\x31\x77\x48\x6b\x2e\x65\xb2\x5a\xd5\x30\xfc\x22\x38\x5a\x45\x93\x6e\xd2\x65\xd4\xe8\x34\xa8\x8c\x88\x55\x21\x66\x7c\x96\xd4\x51\x56\x9c\x8c\x70\x92\x96\x7c\x39\xd8\x6f\x54\x3e\x8b\x96\x89\x2a\x46\xbb\x08\xe3\x52\xe1\xac\x95\xb6\x60\x22\x90\x59\x47\x4d\x47\x27\x89\x44\x20\x93\xc0\x48\x93\x70\xe4\x52\x44\x12\x02\x6e\x42\x5c\x20\xe4\x88\x36\x12\xe0\xfb\x8c\xae\xb6\xce\xdf\xdb\x80\x13\xda\x94\x63\x5d\x2f\xd2\x02\xb3\x0d\xc6\x32\x41\x62\x79\x6e\xb0\x4a\xed\xb3\xd9\x28\xb7\xda\x0d\xe0\x5b\xd2\x6b\xfd\x1e\x8a\xd0\xe9\xf4\x01\x8b\xc1\x62\x25\x69\xa0\xd7\x87\xe1\x0b\x0d\x89\xed\x8c\x01\x8b\xdf\x4a\x7a\x54\x1a\xb8\x7b\x39\x18\xec\xf8\x68\x0d\xdd\xc1\x1b\x74\x1a\x0a\xbf\x40\xb9\xf1\xa1\xf1\x55\x05\x5c\x44\xf7\x8d\x9b\x31\x17\xf5\x40\x3b\xa3\x40\x46\xbb\x82\xaf\x12\x7a\xf1\xd9\x64\xbe\x1f\x2a\x4a\x81\x44\xc9\x0c\x32\xb5\x48\x6c\xca\xa1\xee\x1c\x3b\x63\x6c\xbf\xde\x83\xb5\x7e\xe1\xb2\xa5\x62\xa5\xfd\x40\xb0\xbc\xba\x01\x78\x2f\xce\x91\x0f\x90\xab\x50\x7b\xce\xd4\xa9\xc2\xb1\x53\x8c\xe0\xee\xc4\x60\x18\x60\x29\x15\x10\x1e\x02\x17\x33\x72\x9c\x89\x73\x87\xd0\x06\x74\xe4\x6a\x4a\xd9\x5e\x31\xb3\xc3\x63\xf6\x24\x2a\x0c\x64\x7d\xbd\xa1\x57\x82\xee\xd3\xb7\x82\x35\x67\xb3\xb8\x73\x2a\xcb\xb9\xdd\x7e\xbf\xa3\x95\xf7\x7b\xcd\xe5\xcd\x7c\x32\x69\x76\x74\xef\x4d\xab\xec\x06\xad\x98\xdf\xaf\x35\xf9\x0e\x2a\xbb\x4c\xfa\x9f\x02\x01\xd4\xd3\x99\x95\xda\x90\x92\x08\xd6\x4c\x2e\xf4\x43\xce\x3d\xf2\xed\x51\xcf\x31\xf9\x6c\xa5\xb1\x71\x56\xeb\xf4\xb6\xab\x66\x77\xbc\xf0\xaa\xc9\xe6\xf2\xa5\x4a\x2a\xfa\xe8\xd2\x91\x60\xe5\xc8\xd9\x8d\x01\x4b\x6d\x22\x51\x53\x9a\x36\x7b\xda\xfb\x7d\x34\x65\xce\x25\xd3\x9f\xdc\x7e\xd9\x76\xf2\xd4\xfc\xde\xa3\x9a\xea\x5a\xfb\xd5\x5d\xd7\xb2\x79\x7d\xe9\x8c\x71\xf5\x15\xae\x97\x74\xf5\xf3\x97\x0c\x6d\xd5\x6a\x9d\xa8\x1a\xf0\xa9\xbe\x93\x33\xd5\x4b\x9b\x6f\xd9\x10\x95\xea\xdc\x85\xd1\x38\x96\x8d\xa0\xda\x37\x7f\x90\x85\x01\xb7\x3b\x1c\x0c\xc7\x08\xa7\x33\x1a\xf1\x84\x3c\xcd\x7c\x30\x18\x32\x39\x89\x66\xde\x69\xd7\x6a\x8d\x46\xb6\x95\x37\x2a\x9a\xae\x88\xe2\x90\x56\x64\x60\x93\x2a\x5b\x02\xa4\x58\xbb\x28\x09\x4a\x62\x58\x51\x45\x98\xfb\x7a\xdd\xa8\x9a\x88\xa9\x3a\x2e\xc9\xd4\xaf\xb5\x6f\x22\x66\x1f\x9a\x7d\xa8\x28\xdc\x6d\x26\xd3\x6d\xb7\x34\xf4\x41\x62\x04\xea\x2f\xba\x71\xc4\x00\x39\xe6\x85\xef\x70\x32\xe2\xf7\x63\x76\x41\x6d\x3c\x38\x17\x66\xf5\x0e\x97\xde\xe5\x33\x53\x94\x5f\x65\x30\x68\xad\x4e\x27\x61\x25\xa0\xb6\xa5\x59\xbd\x56\xdf\xce\x6b\x7b\x96\xea\x9a\xbb\xb7\xe2\x89\xb0\x72\xd2\x8e\x43\x35\xc9\x5c\x1e\xdb\x8c\x9c\x75\xf2\xe4\x8f\x67\x5a\xc4\x86\xf5\x49\xfc\x73\x6f\xfc\x6b\xf0\xa6\x81\xb9\x81\x15\xcd\xa7\x98\x5d\x07\x1f\xfb\x40\xf8\xbc\xb7\x90\xc5\xe0\x32\xb4\xd6\xfe\xcd\x07\xc0\x5d\x1e\x7f\x18\x90\xe1\xa4\xb8\xd7\xe6\x40\xfd\x90\x83\x7b\xcd\x89\x2a\x2e\xed\xa4\xca\x62\x21\xf5\x94\xcb\x6d\x83\xce\x8d\x49\x87\x6a\x84\x9a\x79\x13\x67\x27\x09\x68\x40\x51\xaa\xa0\xe7\x34\x0b\xe5\x42\x08\x80\x36\x1b\x43\x69\xd9\x7c\x0f\x0d\xc7\xc0\x19\xcf\x51\x3f\x54\xdf\x0f\xd0\x27\x2e\x9f\x94\x1b\x98\xbe\x7f\xc3\xc1\x17\x84\xc7\x6b\xee\x57\xa7\xdd\xa0\x51\x57\xf5\xd3\xef\xab\x1f\x12\x52\xb7\x5e\x23\x9c\xed\x10\xfe\xe1\x4e\x8b\xf6\xde\xda\x75\x96\x3e\x82\xfb\x17\x63\x44\x9a\x58\x9c\x1b\x50\x42\x78\x54\xe9\x60\x84\x2a\x2f\x8f\x46\x2d\x06\x43\x88\x52\x11\x4c\x65\x45\xc4\xc4\x99\xda\xf9\x20\x47\x05\xd2\xe9\x40\x07\xcf\xa5\xb9\xb4\xd6\x66\x2b\xef\xe0\xc5\xf2\x61\x9d\x45\x1b\xed\xe0\xb5\x06\x69\x7d\x45\x73\xaf\x0c\x62\x89\xfa\xa2\x02\x99\x8c\x12\xa3\x2c\x0f\x9e\x1b\x87\xde\xa6\xa4\xd0\x42\x79\x1c\x5d\x04\x23\x5c\xc0\xd2\xa5\x8f\x14\xc0\x73\xdf\xd7\xae\x2c\xdb\x63\xda\xb3\x19\x6a\xb9\x24\x78\xb6\xf3\x20\x86\xd2\xad\x00\x17\x9b\x84\x7d\x49\x19\x50\x97\x8e\xe6\x61\x74\x6b\xbd\xdf\xb5\x51\x93\x3d\xb5\xe7\x9c\x08\x4f\x57\x38\xdb\xf6\x45\x01\x51\x97\x44\xf8\xfa\x08\xab\x1b\xda\xf3\x12\xe2\xd2\x5c\x24\xa1\x09\xaa\x83\x5e\x35\x45\x79\xe3\x5a\x9d\x8e\xf3\x72\xa5\x65\x09\x1b\x7c\x85\xed\xbc\x59\x03\x60\xac\xe5\x0a\xa3\x2e\x22\x23\xef\xb2\x42\x53\x45\x31\x54\x3b\x6f\x60\x64\x30\xcc\x4c\xa1\xc2\x4b\x06\x07\x91\x5d\x9e\x42\x6e\x15\xb1\x7a\x15\x74\x77\x01\xb1\x88\x95\x9a\xfa\xa0\xaf\x83\x3a\xa5\x1a\x41\x98\x55\x35\x99\x1e\x9d\x28\xb6\x45\x4d\x24\xbf\x9f\xb8\x5f\x03\xde\x80\x5f\x3d\x6e\x7a\x3c\x26\xf6\xf5\x31\xa9\xbb\x70\x43\x5f\xbc\xd3\x1c\xd7\x92\xf7\xb5\x01\x01\x63\x00\x91\xf2\x7f\xdb\x4e\xa2\x8e\x3e\x57\xf6\x07\xe1\x35\xe1\xd7\xdf\x3f\xf6\xc1\xe9\x5e\x30\x46\x9c\x06\xcf\xcc\xeb\xcc\x70\x8b\x8a\x1a\x8b\xf6\x41\xd7\x3f\xbb\x56\xd0\x2f\x43\xbb\x1d\x21\x92\xd0\x72\x1f\xcc\x4d\xd3\xa9\x54\x6a\xb5\x11\x6e\xcd\x50\xd8\x6c\x0d\x46\xe2\x34\x13\xd3\x97\x1a\x4a\xca\x92\x46\xa3\xd7\xee\x72\x38\x9d\x2e\x6f\x49\x69\x8c\x8e\x58\xc3\x84\xae\xdc\xed\x4e\x19\x4a\xe8\x38\x9d\x34\x06\x92\x1d\xbc\x5e\x5b\x16\x2d\xeb\xe0\x59\x26\x1a\xb5\x87\x02\x01\x5f\x3b\x4f\x92\x01\xca\xed\x85\xc6\xcd\x6d\xb1\xb8\x2d\x76\x63\x07\x6f\x97\x5b\xe4\x2a\xb9\xe3\x92\xf6\x40\x0c\xf8\xc8\xe2\x89\x6b\x26\xe1\x41\x82\x6e\xdd\xf0\xdd\xff\x95\xb5\x0c\xc0\x56\x22\x83\x72\x3e\xb5\x51\xc0\xca\x49\x1f\xec\x0c\xa1\xd5\x85\xca\x07\x3a\x40\xc9\x28\x95\x8d\xd2\x2f\xd7\x0f\x54\x95\x0b\x07\xe7\xa3\x7c\xcf\x16\xe1\x63\x4b\x9e\x5e\xe5\x8b\x96\x49\xcd\x47\xc4\xac\x50\x7a\xd2\xb4\xc9\x9d\x8b\x77\x80\xe6\x67\x3e\xda\xbc\xf3\x2a\xa6\x41\x78\xe1\x4f\x74\xa7\x80\x92\x3e\xc2\x80\x99\x28\xeb\x73\xfd\xf5\x62\x36\x68\xdd\xba\xce\xad\xa4\x9a\x3e\xbf\xe3\x2c\x81\xa0\x48\x7f\x12\x76\x53\x0f\x32\x46\x68\x45\x4b\x88\x0a\x18\xab\x5e\x95\x1b\x52\xc9\x71\x1e\x43\xb5\xd5\x16\x64\x09\x7d\x69\x88\xa6\xc9\x54\x79\x24\xaa\x65\x75\x00\xfa\x42\x75\xd0\x8e\xd6\x86\x2a\x9a\x78\x6b\x79\xca\x46\x06\x55\xfe\x68\x75\x4d\x84\x0e\x85\xd4\xc8\xd0\xb4\xf0\xc0\xef\x50\xc7\x9b\x79\x9d\x9a\x43\x99\xc3\xbc\x33\x04\x77\x16\xf4\x0b\x91\x3d\x05\x19\x65\xf2\x36\x9f\xc3\xb5\x46\xad\x32\x62\x85\x35\x43\x89\x19\x6b\x4a\xce\x0d\x41\x57\x88\x92\x5d\x69\xd6\xe6\xcc\xaa\x58\xd0\x2b\x49\xf5\x07\x23\xc7\xbf\x7e\xfd\xba\xb3\xab\x63\x65\x07\xc6\x3f\xdf\xa7\xff\xeb\x8f\x3f\xda\xab\x45\x2a\x35\x6c\x69\xa4\x3b\xc6\xbf\xe8\x09\x0e\xbd\xa5\x23\xe8\xbb\xbe\x69\x28\x78\x5e\xb3\x6a\xc4\x70\x61\x37\x58\xce\xbf\x8d\xb2\x43\x2c\x68\x16\xb6\x78\x27\xd5\xcf\x7a\xb8\x4c\xf8\x5d\x12\x17\x20\x3a\xc1\x9f\x58\x17\xb8\xc2\xb0\xe8\xc5\x1f\xa7\xf4\xf9\xc1\x40\x83\x49\x7e\x97\x70\xae\x74\x3e\x21\xf6\x28\x50\x7f\xc5\xfd\x61\x6d\xb9\x72\x9b\x59\x63\x30\x90\x6e\xad\xda\x4d\x98\x19\xaf\x4a\xe5\xd3\xe3\x63\x06\x4f\x99\x89\x31\x21\x02\x1f\x8b\xc9\x2a\x9e\x30\x86\x52\x66\x78\x2f\x00\x9d\x29\xc7\xec\x4a\x04\x30\xb6\x08\xf3\x10\x4c\x37\x3d\x86\x8e\x12\xad\xb9\x7f\xe2\x66\xd3\xe6\xd2\x66\xe1\xc8\xad\x08\xed\xd0\xd0\x56\xba\x36\x3c\x5c\x71\x76\xda\xce\x60\xa8\x43\x67\xe0\x28\xb8\x8f\x90\xf9\x0f\x23\x18\x37\x33\x4e\x4c\xce\x55\x41\xfb\x48\xba\x3c\x21\x75\xc8\x45\xd0\x49\x2b\xc7\x25\xb4\xb8\x90\x8e\x05\xc0\xc8\x18\xed\xcd\xbc\xd9\x6c\xf4\x46\xfd\x17\xf1\x51\x86\xa1\x60\x38\x24\xe2\xb4\x89\x65\x4e\xff\xb3\x8a\x2e\xaf\x15\xd0\xdc\x29\x65\x1b\x3b\x9c\xbc\xad\xd0\xa2\x5f\x6e\xda\xd9\x80\xa2\xdb\x91\x3b\x4d\x3b\xc7\x15\x75\xb1\x4f\x05\x7d\x72\xe9\xf2\x5c\xae\x3c\x9d\x43\x0d\x61\x13\xdc\x69\x61\x7a\x9b\x10\x94\x9b\xd8\x49\x1b\x15\x17\x7f\x9a\x13\xfd\x75\x61\x14\xf3\x31\x94\xcb\x40\x54\x22\xcb\x4f\xdb\x2a\x8c\x5a\x6d\xc8\x6f\xf3\x57\xc5\x93\xc9\x6a\x84\x94\x00\x15\x7b\x99\xd7\x47\xb9\x08\x84\x22\x6d\x64\x39\x84\xcd\x66\x25\x7a\x04\x76\x95\x45\x1d\x92\xe2\x8b\x90\xcb\x1c\xb3\xd6\x0a\xd2\x2a\xf5\x5a\x8b\x75\x81\xd9\x0c\x10\xab\xb8\x14\x5d\xd8\xd4\xad\x0f\x0a\x3f\x6c\x7b\x69\xf7\xd3\x9b\x9f\xbc\x78\x78\x53\x6a\xd5\xd1\xed\xe7\xd7\x1e\x07\xf3\xce\x0c\xbc\x79\xda\xd6\x52\xa1\xcb\xd0\xbb\x5e\x6a\xca\x6e\x5e\x31\x92\x3e\xff\x96\xb0\xe9\xe4\x9b\xdf\xdc\x4c\x9d\x8b\x58\x34\xe7\x26\xcd\xbd\xf5\xa7\xcd\xff\x06\x2b\xdf\xb7\x7a\x02\x67\x47\x0c\xcb\xa6\xfb\xa0\x16\xed\x41\xd7\x8c\x1f\x25\xd6\xa6\x8d\xa6\x7e\x86\x76\xd7\x48\x94\x23\x19\x0d\x2e\x1b\x1d\x0c\xc6\xc2\xae\x70\xba\xa4\xac\xac\x22\x64\xf2\x69\x10\xc6\xae\x0d\xda\x40\xd4\x54\x59\x5a\x6a\x32\x25\xa0\x25\xf6\xf6\xe4\x68\x6c\xec\x29\x63\x5c\x41\xfe\x05\x85\xc5\x7d\x4c\x59\x55\x34\x64\x96\xe0\x7b\xa0\x42\x2a\x74\x9b\x83\x4d\x0d\x97\x0f\xa8\xb6\xb7\x0e\x9b\xb2\xa1\x85\x6c\x5a\x72\x5d\xd9\x9a\xfb\x84\x6f\x6f\xf8\x64\xdd\xd8\x79\x36\xdb\x9e\x83\x36\x11\x51\x61\xdc\xd8\x4c\x2d\x70\x5e\xdd\x3a\xeb\xea\xb5\xc2\x0f\xbb\xbe\xe9\x14\x56\x5c\xd7\xfe\xf2\x8d\xa0\xf9\x79\x90\xda\x35\x64\xc0\x82\xf3\xbe\xcb\x7a\x8b\xa0\x0a\x78\x5f\xe2\xbb\x7e\x8c\xfb\x1e\x22\x66\xe7\xea\x43\xd0\xa7\x70\x72\x3a\x93\xde\xa7\xd1\xe8\x75\x4e\x82\xb1\x47\xec\x61\x8b\xd3\xee\x6c\xe7\x75\xc0\x0c\xf7\x68\x07\x1f\x42\x28\x6e\x16\x13\xf4\x85\x4c\x16\x06\x46\xa0\xf9\xa3\x25\x5f\x0e\xca\x51\x87\xe5\x42\xf0\x6e\xca\x3d\x8a\x9d\x0e\x14\x63\x52\x32\x18\x49\x1c\x43\xad\x47\xa9\x71\xdc\xee\x59\xd0\x2c\xdb\x3e\xfa\xbb\xb0\xeb\xf3\x8d\x5a\xe1\xed\x9f\x4f\x4d\x7c\x4a\xdb\xf9\xb5\x76\xd7\x44\xb0\xe0\xc8\x31\xe1\xb3\xbb\x2f\x21\x47\x4f\x24\x87\x7b\x6a\x77\x3f\x20\xbc\xda\xd6\xf9\x4f\x6f\x2d\x39\x5a\xa0\xb1\x7f\x7e\x7e\xe2\xe3\x0f\xfc\xd0\xf9\x0a\x9c\x6b\x12\xd5\x28\x60\x8c\xab\x8b\x72\x29\x27\x54\x13\x16\xa3\xd6\xc8\x51\x1e\x86\x24\xbd\x7a\xce\xcc\x35\xf3\x1a\x78\xce\xec\x76\x6b\x13\x6f\x37\x19\xed\x30\xfe\x66\x5a\x79\x9a\xe0\x50\x1f\xac\x08\xc2\x77\xe1\x93\x26\x25\x64\x70\xeb\xab\x8c\x68\x10\x95\x43\x29\x16\x3a\x79\xef\xd5\xf8\xcb\x53\x89\xe6\x47\x87\x59\xde\x33\xbd\x37\x72\xf7\xa8\xa5\xa6\xa5\x8d\x4b\xd4\xc0\x1e\x6c\x79\x96\x3a\xa6\xfe\x79\xf9\x35\x33\x67\xb7\x09\x6d\xe0\xb1\x36\x70\xa9\x3b\xfd\xde\xb2\x2b\xe1\x1e\x4b\xa1\xbc\x2c\x7c\x0f\x7e\xf8\x1e\xae\xce\x0d\xb6\x04\x03\x21\x33\xc3\x59\xad\x6e\x9f\x9f\x82\x2f\x87\x81\x6e\x82\x4e\xcb\x32\x2a\x97\x47\xed\x08\x3b\x22\x2e\x9d\xce\xca\x19\xb8\x76\x3e\xe4\x53\x6b\xd4\xed\xbc\xdb\x1c\xf0\xab\x28\x8d\x86\xb2\x1b\x7a\x60\x1e\x8a\x69\x80\xbc\x59\xec\x01\x58\x09\xff\x9b\x11\x63\x7f\x09\x02\x91\x0a\x67\xc3\x95\x00\x69\x40\x67\x9e\xe9\x39\x0c\x92\xd6\x30\x39\x4d\x6a\x46\xbe\x53\x78\xdb\x04\x74\x0d\x62\x4b\x72\x5f\xb0\xee\xfa\x03\x5a\x70\x48\x7b\xef\x8d\x67\x4d\xc2\xdf\x84\x8f\x03\x1f\x0a\x2f\x36\x8b\x5d\xc9\xe0\xcd\xb6\xe3\x48\x23\x1e\x17\xff\x6e\x13\xfa\xcd\x03\x3c\xda\x77\x88\x17\xe4\x6d\x18\x2f\x20\x6f\xe1\x8a\x5c\x3f\xb6\xac\xa4\x54\xcd\x68\x55\x5a\xa7\xcd\x65\x76\x25\x54\x14\x41\x91\xc9\x84\x59\x65\x0f\xd8\xcb\xc3\x81\x40\xaa\x4c\x2a\x34\x86\x0a\x92\x29\x71\x25\x12\x29\x5f\xb4\x05\x46\x14\x3e\x9f\x11\xe9\xc6\x8c\x7c\x67\x57\x99\xc9\x14\x3c\x80\x1e\x91\x62\xbd\x2c\x27\xdc\x7f\x48\x3e\x6b\x58\xbc\x04\xc9\xe0\x5b\x32\x04\xf7\x68\x24\xa3\x8a\x1e\x67\x2f\x74\x9e\x8c\xcf\x66\x50\x27\x73\x03\x18\x51\x57\xe6\x52\x1f\xf5\x24\xfa\xed\x30\xbe\x2a\x1c\x5e\x7c\xcb\xcd\xa3\x0b\xcd\xce\x8b\xbe\x38\x26\xfc\x97\x8c\xb5\x7d\x07\x95\xe5\xdb\x33\x47\xc5\xcb\xd9\xb4\xb3\x24\xb6\x60\x66\x5b\xe7\xbb\xaf\xec\x18\x23\xb5\x3b\x93\x2e\xe1\x31\xd0\x86\xf4\xc9\x38\x68\xbf\x2e\xc5\x35\x16\xa5\x88\x3b\x23\xac\x75\x38\x28\x5f\x20\x66\x32\x05\x28\xaa\x2c\x55\x9a\xd0\x27\x5a\x78\x6b\x18\xf1\xa9\x11\x7a\x4e\xc4\xe9\x0c\x10\x84\x5b\x62\x51\xcb\x2b\x93\x0b\x40\x36\xe1\x8d\xc9\xe4\x91\x0d\x9c\x52\xd6\xd5\x24\x37\x01\xd4\x61\x35\x42\x89\x9e\x3f\xb4\xdb\x6d\x2b\xae\x63\xe7\x2d\x54\x03\x92\xbc\x63\xcd\xc2\x6b\xbe\xfd\x6c\xb9\x9b\xae\x1e\x58\xba\x30\x9e\xed\x1d\x7b\xe4\x91\xab\x40\xec\xd6\x7e\x97\xd6\xd9\x26\x4e\x0f\xf7\x27\xdb\xdd\xe9\x29\x4b\x2e\xbf\xec\xc1\x43\x0c\xbd\xbe\xcc\xd2\x38\xc4\x6b\xbb\xea\x44\x14\x7c\x46\xb3\xbf\xdc\x1a\x75\x89\x58\x66\xd4\x01\x28\x93\x19\x4a\x35\x24\x17\x75\xb3\x01\xca\x64\xe2\x58\x2e\x1c\x31\xc1\xa3\xa5\x83\x26\x4d\xc7\x51\x5e\xc6\xdb\xc2\x33\x0e\xd2\xdc\xc4\x93\xf6\x1e\xcd\xff\x8d\x4a\x37\x17\xe5\xf4\xc2\xc5\x8a\x50\x97\xaf\x43\x16\x19\x13\xa9\x5b\xd5\xc2\x2f\x00\xa9\xc0\x1b\x3f\xbd\x1d\xab\xc0\x6d\x63\xa0\x6a\x5c\xdf\xfa\x30\xd6\x92\xe9\xf4\x7c\xa8\xf5\x0e\x81\xf4\x5e\xa4\xf5\xb6\x92\x2d\xb3\xae\x5e\x23\xfc\xf0\xe0\x37\x50\x3b\x9a\xae\xc4\xb6\x6b\x0c\x9c\xf3\x8b\x85\x39\x23\x34\x10\xce\x0d\x0d\x54\x38\xc2\xd9\xa5\x39\x3b\xa4\x39\x73\x00\xce\x19\x98\xfe\xc7\x9c\x25\x8a\x61\x54\x65\x19\x32\x8b\xad\x17\x49\x36\xea\x15\xaf\xd4\x2c\xe2\x7a\x53\xaa\xa5\x6a\xe8\x2c\xae\xb9\x0f\x58\x97\x7f\xba\xa6\xe7\x94\xa9\x5b\xe0\x9c\x85\x03\xcf\x0b\xa7\x77\xc0\x39\x53\x97\x76\xee\x87\x73\x06\x26\x34\x67\xe1\xab\xab\x89\x02\xef\x0a\xc2\xde\x2c\x83\x73\x8e\xd9\x02\x01\x4a\xaf\x89\x79\x3c\x1a\x8a\x4a\x95\xdb\x92\xce\x64\x2b\xef\xe4\x58\x23\x6a\x03\x66\x01\x11\x52\x30\xef\x55\xf6\x00\x78\x95\x12\x5f\xa8\x05\x5b\xd9\xc9\x6f\x02\x8a\x24\x73\xbc\x88\x6c\x65\xed\x84\x7d\x8d\x7b\x4a\x8e\x4a\xbc\x30\xd9\x01\x43\x3d\x36\x8b\x4d\x4e\x2a\x0b\xa7\x0a\x99\x64\x5b\x3a\x49\x3d\xf9\xb7\x53\x08\x05\x6b\xf1\xbd\x57\x5e\x33\x4c\x4e\x21\x2f\x2f\xb0\xad\x00\xcc\xb1\xd6\x0c\xd7\xdf\x43\xf4\xca\x79\x39\x83\x43\xa5\x22\x0c\x94\xd7\xa7\xb5\x34\xf3\x46\xa3\xd6\xe1\xf1\x50\x94\xab\x85\xa7\xb8\xe2\x26\xe6\x7c\x0c\x6b\x2d\x66\x86\x11\xdd\x1c\x0b\x0a\xb6\xd9\xd5\x22\x91\x81\xd0\x79\xc7\xb0\x1d\xbd\xd2\x88\xe0\xa0\x7d\xdf\x8c\x3f\xac\xbb\x9f\x8a\x62\x06\x03\xe1\xd3\x27\x02\x0e\xa0\x7a\xa2\xf1\x0e\x40\xc0\xf9\xcc\x84\xfa\xe8\xcb\xae\xc7\xa9\xa5\x70\x2e\x5a\xe8\x75\xb7\xe7\xaa\x19\xab\x35\x11\x88\x12\xee\xb4\x3b\x9a\xa0\xc3\x55\xe1\x4a\x2b\x13\x0d\x30\x01\x4a\xed\xa0\x50\x32\xdf\x57\x56\x51\x51\x56\x06\x57\xb9\x8c\xf3\xa9\x5b\xf8\xb0\x0f\x2e\xf2\xab\x85\x3c\x0e\x46\x53\x13\x13\x39\x99\x0b\x55\x74\xe1\xea\x5b\x9c\xd3\xb0\x8a\x30\x10\x7e\x20\x5f\x0d\xa1\xa4\x3e\x1b\x15\x4b\x42\xa4\x16\x08\xf2\xc5\x56\xfe\xfe\x6b\x1c\xf3\x9b\xae\xba\xee\x22\x91\xaa\x61\xe0\x6e\xfe\x8a\xeb\xde\xdd\xf7\xfb\xc9\xd9\xd8\x88\xf4\x48\xa3\x09\x31\x36\x0c\xdc\x57\x95\xfe\xa8\xac\x17\x3f\x68\xc4\x58\xf0\x15\x26\x6c\x30\xd7\xd5\x4f\x9f\xb4\xe8\xde\xcb\xc7\xf1\x6b\x2e\x0b\xb7\xc7\x10\x6f\x43\xc8\x26\x9c\x15\xf3\xac\xa8\x36\x88\x61\xd6\x41\xbf\xad\x02\x7a\xd1\x69\xd6\x95\x08\x18\xcc\x65\xe5\xe5\x66\x17\x55\x19\x8d\x56\x45\x42\x4d\x7c\x84\x10\xc9\x03\xac\x5a\x91\x3e\xa0\xbc\xdc\x68\x2c\x69\x2e\x4a\xdb\x28\x6e\x2e\x14\xe9\xc5\x4c\x4f\x0a\x01\xab\xe4\xd7\x28\x28\x04\xd0\x35\x5f\xc1\xb5\x29\xa2\x12\x38\xb4\xe4\xba\x6a\x05\x8d\x80\x58\x06\x74\x56\xf6\x6f\x94\x74\x02\x9d\xfc\x8a\xeb\xa6\x7d\x2f\xb3\x09\x88\x75\x3f\x7d\x0b\x0e\x0e\xe6\x49\x60\x4a\xe0\x79\x31\x40\xdf\x6d\x6c\xae\x94\x0d\xc6\x1d\x06\x77\xd0\x9d\xe6\x10\x79\x08\xde\x68\x65\x20\x0a\xc5\x8c\x72\x1e\xad\x0f\x8a\xe9\x73\xb8\x1d\x4d\xbc\xdb\xde\xfd\x6a\xa6\x18\xc2\xe3\x02\x12\x02\x19\x4d\xae\x1b\x57\x42\xa3\x88\x92\x51\x24\x1f\xb9\x4c\x02\xac\x3d\xd2\x8d\x31\x81\x64\x30\x9e\xad\x52\x42\xea\x24\x42\xaf\x3d\x27\x28\x48\x13\xfc\x25\xef\x7f\x64\x85\xb2\x69\xe0\xf9\xb9\x08\xef\xd9\x30\x31\x20\x17\xa1\xbc\x6e\xb5\x4a\xa7\xf3\x5a\xa8\x48\x54\xe5\x6e\xe2\x55\x2a\x53\x30\x08\x8d\x66\x90\x33\xc1\x50\xd0\x6a\x35\x39\xba\x81\x7a\x29\x71\xf8\x31\x82\x14\x4a\x2d\x22\x93\x08\x24\xfd\x95\x15\xf3\x6e\x31\x89\x2c\x01\x7c\xd2\x34\xfd\xd9\x83\xba\x59\xc0\xbe\xe2\xdf\x3b\x3b\x76\x64\x22\x99\xb5\x7d\xd7\x1d\xf5\x77\xfe\x7b\xc2\x8e\x4b\x1f\x79\x8b\x5a\x7a\x49\xeb\xf4\xab\x0c\xb9\xbe\xab\x36\x0b\x87\xf6\x08\xbf\x6e\xe8\x57\x53\xef\x8b\x3e\xb1\x2d\xf2\xfd\x98\x1b\x47\xfc\x0d\xbd\x8b\x4a\xc4\x0f\x29\xf5\xbb\x0d\x40\xfd\x6e\x6e\x86\xb6\x58\xf4\xd0\x49\xc3\xfd\x6e\x3a\x53\xa1\xe3\x2d\xdf\xef\xf6\x5b\xbc\x01\xff\xa7\x8e\xb7\xca\xff\x3f\x1d\x6f\x78\xbe\x8c\x43\xaa\xc7\x98\x9b\x83\x9e\x78\xb2\xaa\xca\xc2\xc6\x5c\x2e\xd6\x40\xd1\x75\x81\x40\xd6\xef\x0f\x7b\xc2\xcd\xbc\x1d\xaa\xdf\x72\x4e\xd3\xc2\x27\xab\xd8\xaa\x66\xde\xc2\xb2\x04\xa7\xd7\x73\x1c\x51\xae\x54\xbf\x0a\xec\x0e\x2c\x4f\x7d\x8f\xf2\x94\x82\x42\x46\x0b\x1e\xcf\x4b\x16\x72\x62\xdc\x02\xd1\xee\xc9\x98\x59\x59\xd6\x09\xc5\x45\x24\xa8\x59\xb1\x11\xaa\xf1\xda\x4d\x8b\x3e\x03\x4e\xf7\xd3\x92\xb4\x80\x6e\xa8\xa8\xb0\x8e\x77\x4c\x4c\xf1\x25\x11\xff\x2d\x23\xc7\x4d\x61\x7b\x51\xeb\xce\x2e\x6e\x5d\x3f\x83\xfe\xe9\xed\x06\xdb\xc2\xc9\x63\xd7\xac\xbb\xe1\x45\x2c\xfc\xc7\x8e\x80\x47\x7f\x43\x72\x69\xae\x5f\x72\xf4\xb4\x8e\x8b\xe3\x51\x57\x2d\x5a\x8d\x31\xeb\x01\xb8\x71\xe9\x33\xd3\xeb\x87\xe1\xfc\x63\x29\x7c\x7f\x31\xb8\x1e\x95\xc4\xa4\x5c\x4d\x29\xe3\xd5\xdb\x2d\x16\x22\xa2\xd6\x33\xaa\xaa\x6a\x75\x22\x10\x48\x34\xf1\xfa\x80\x2f\x40\xea\xa9\x40\x80\xe4\x38\x57\x33\xdc\x74\x1c\x57\x59\x49\x92\xe5\x2d\x3c\xe9\xe8\x89\x45\xd1\x2e\x01\xdd\x17\xc1\x1c\xc4\xa5\x28\xb5\x11\x20\x1d\xa8\x04\x8d\xc7\xfb\xb3\x3f\xe8\x8b\x00\x2a\x92\xb2\x47\x93\x25\x5f\xdc\xf5\xd6\xc6\x7b\x37\x2f\x05\xcd\x43\xe7\xfe\x6e\xde\xca\xcb\x62\x55\x71\x7b\x6b\x72\xf2\x92\xea\x8a\xd0\x0a\x8b\xdb\xec\xe9\xbd\xfa\xa2\xf6\xd9\x17\x0f\xbb\x66\xd8\xf2\x8d\x4b\x2f\x5b\xf0\xa0\x9b\xf5\x4e\xc8\x35\x5d\x37\x34\xf6\xea\x42\xb3\xeb\xb2\xa9\x35\xa3\xcc\x34\xdb\x61\x70\x2e\x6e\x1d\x33\xa1\xb4\x4a\xcc\x65\x7f\xd9\x75\x06\xd7\xc0\xa6\x89\x99\xb9\x7a\x9b\x83\x88\x1a\xfd\xfe\x68\x50\xe5\x60\x4a\x2a\x4b\x2a\x42\x3a\x4a\x07\x43\x72\xbd\xce\xa7\x1b\xad\x9b\xac\x9b\xaf\x63\xf4\x94\x4e\x97\xf0\x24\x52\x2d\x7c\x69\x69\xc2\x81\x30\x9a\xcd\xcd\xbc\x87\xfb\x1f\xe2\x76\x23\x8b\x41\x85\xbd\x29\x90\x45\xca\x5e\x66\xb1\x45\x59\x59\x69\x4f\x9b\xc4\x8a\x41\xb9\x6c\x07\x74\xf6\xaa\xd9\x35\x22\x64\x0e\x85\x0f\x18\x47\x8c\x1b\xdf\x9a\x6a\xf7\xd5\x67\x13\x7d\xae\x1c\xb9\x67\xef\xa7\x60\xec\xe4\xf7\x5f\xdf\x77\x6b\xf0\xda\x8d\xf3\x97\x03\x5f\x03\x6f\xd5\x77\xc0\x20\x6a\xe1\xe8\x91\x63\xfc\x96\xf9\x6f\xeb\xad\x4b\xe7\x3e\x31\x9c\xb5\xcd\x19\x7e\xcf\x8e\x8e\x7e\xbd\xa7\xcb\xb2\xd2\x2b\xa1\xac\x83\x88\xeb\x72\x43\x32\x7e\x23\x51\x5f\x15\x8d\xd6\x1b\xeb\x54\x0e\x55\xff\xb2\xb2\x21\xfd\x07\xd7\x51\x50\xaa\x74\x3a\x54\x13\xd2\x79\x2e\x20\x78\x3f\x4f\xbf\x01\x2d\x7c\x63\x63\x3f\x07\x92\x1a\x0a\xcf\xe5\x79\x30\xbb\x8b\x2d\xee\x71\xb8\xe3\xeb\xbb\xa1\x54\xfe\xbf\xd6\x40\xde\xfe\x8e\xe2\xfd\xaf\xfa\xbf\xae\xcc\xae\xbd\x8c\x23\x62\x1f\xef\x28\x4d\x47\x06\x95\x97\x04\xae\x1a\x39\x72\x0a\x5b\x9a\x3c\xf0\xff\x5a\xad\x45\x97\x68\xbc\x51\xfd\x0d\x25\xfd\x7b\xa7\x1a\x3c\x4d\x17\x5f\x74\x71\x4d\xd4\x7a\x6d\xef\xa2\xf5\x23\x89\x61\xf0\x4c\xdc\x82\x63\xcc\x34\x31\x3e\x57\x43\x97\x69\x63\x4e\xbf\x3f\x16\xe2\xca\x98\x8a\xca\xb0\xcd\x60\x33\xc0\x25\xb3\xf9\x6c\xa3\x6d\x93\x6d\xf3\x6d\x70\xc9\x6c\xb6\xa4\x27\xc9\xb6\xf2\x49\x87\x87\x68\x15\xb7\x49\x41\xc7\x5d\xf0\x40\x80\x88\xbc\xd7\x51\xb4\x82\x56\x05\x73\x38\xa1\xff\x91\xbc\x7b\x69\x19\x70\xca\x8e\x1c\x76\xd5\xcb\x97\x3f\xb0\xfe\xba\x8d\x0b\x26\xcd\x1c\xe0\x30\x3b\x02\xcb\x6e\x58\xb5\x78\xf8\x8a\xfb\x6e\xb8\x02\x0c\x9b\x7c\xe2\xc1\x83\xef\x6c\x3c\x47\xc5\xa7\x3c\xb6\xec\xe6\x4d\x13\x47\xd5\x8f\x52\x69\xe8\x0e\x9d\xa1\x2d\xd7\x7f\xd0\x8e\xab\xa7\xcf\x5c\x6f\x67\x8d\xb3\x87\xaf\x7c\xec\xfd\xa7\x1f\x02\x96\x7b\x31\xae\xf5\x23\xc2\x24\x72\x36\xae\x51\x1c\x97\x2b\xa3\x58\xd6\x69\xa5\xad\x76\x4a\x47\x10\x3e\x23\x34\x35\xa4\xcb\x03\x4f\x39\xe5\xb0\x23\x38\x5c\xbb\x5d\xe3\x31\x69\xe0\x2e\xd0\xeb\x35\xcf\x00\xb3\xbc\x0f\x7e\x13\xb2\x28\x23\x03\x5d\x77\x4b\xb3\x35\x02\x31\x94\x26\x67\x6b\xee\xbf\x6e\x8f\x69\x0f\x5b\x94\x65\x4b\xbc\x68\x7a\xf1\xba\x3d\x1a\xea\xb1\x5a\x4f\x67\x63\x5b\xa9\x9c\x66\xfb\x53\x1b\xf9\x92\x47\xea\xab\xb6\x09\x43\xb0\xcd\x2f\x21\xb2\x28\xd7\x66\xd2\xd7\x79\xd2\xf6\x48\x44\xa5\xf2\xe8\xa9\xde\xc9\x64\x7d\x49\x49\x3c\x0e\x4d\x7e\x1c\xa0\x12\x9f\x70\x80\x73\x95\xb6\xf0\x0e\x97\x03\xf9\x9d\x06\x83\xd6\x97\xdf\xc0\xf9\xbf\x7e\x4b\x53\x03\xc9\xe4\xe3\x3c\x9b\x0c\x66\x82\xf0\x22\x0b\x51\x8b\xa8\xbf\x40\x71\x96\x87\x3e\x8d\xcc\xff\x70\xf7\x2b\x89\x5f\xdf\x59\xbc\xb1\x32\x6b\x08\x77\xa4\x6e\x5e\x17\xb6\x15\x62\x99\x70\xfc\xcd\x7b\xc7\xf6\x8f\x9d\xdf\x20\x27\x7c\xd6\xb7\xd2\x2f\x5f\x6b\x5f\xbc\xf1\xdc\xfe\x3f\x7e\x12\x04\xaa\xdd\x76\xcf\xde\xa3\x0b\xf3\xf1\xcd\xa1\x13\x9f\x59\x4f\x9c\x5b\x8b\x43\x9b\xa9\x52\x9c\x93\x5f\x0b\x1c\x97\xf9\xa0\x15\x1b\x95\x4b\x96\xe9\x9d\x4e\x77\x8c\x63\x48\x92\x73\x53\xe9\x72\x97\xc9\x06\x43\x04\xa7\x8d\x33\xc2\x90\x53\x6f\x74\x10\x6a\x5c\x2a\x53\xc0\x6e\xca\xff\xd5\x83\xde\xef\xb7\x04\x46\x9d\x72\xd6\xe2\x40\x0d\x78\x2e\x2c\xa4\x6d\xcf\x9e\xc4\xaf\x1f\x2b\xe2\x1f\x61\x48\x4f\xd1\x16\x9c\x6f\xfa\xe3\x27\x74\x6b\x71\xf0\x06\x70\xbc\xf9\x10\xe6\x24\x1f\x9a\x8b\x59\x29\x77\xc0\xa0\xd5\xc2\xf0\x39\x12\x0d\xb8\xbd\xd0\x97\xf0\x7a\x09\x96\xe5\x60\x00\xa7\x63\x39\x02\x3a\x74\x8a\x28\x48\x01\xe1\xa2\x3c\x65\x4c\xa1\xe9\x98\x8d\x66\x91\xb9\x91\x73\x8f\x72\x2f\x20\x78\xee\xe0\x09\x68\x10\x77\x36\xde\xd3\x98\xe8\x4f\x85\x3a\x32\x07\xde\x5f\x38\x6f\xe2\xe8\x8a\xcb\xd5\x60\xa1\x7a\x72\xb6\x79\x87\xed\xe8\xbe\xe7\x81\x7f\x8b\xdb\xfd\xe5\xaa\x50\x44\x78\xef\x97\xb5\x1b\xcb\x00\xed\x49\xa7\xdd\xc2\x1b\xde\x04\x7c\x17\x3e\x61\x08\x1d\x83\x67\xc9\x01\xa3\xb7\x71\xb9\x72\xdf\xff\xc7\xdd\x7b\xc7\x47\x55\xa5\x0d\xc0\xe7\xdc\x3a\xfd\x4e\xef\x93\x99\xc9\x24\x33\xa9\x24\x64\x12\x42\x20\x90\x11\x08\x84\x1e\x20\x94\x11\x48\x10\x42\xef\xbd\x37\x41\x5d\x15\x16\x54\x44\xb1\x57\x70\x95\x55\x41\x01\x7b\x6f\xaf\x88\x65\x17\xb7\xe8\xee\xe2\xba\xeb\xea\xee\xba\xab\xbb\x96\x55\x20\x77\xbe\xe7\x9c\x7b\xa7\x25\xa0\xfb\xfe\xbe\xf7\x8f\xef\xf7\xa1\x4c\xe3\xde\x73\x9f\xf3\x9c\xe7\x3c\xed\x3c\x45\xf0\x6a\xcd\xc8\xc5\x5a\xc0\xfc\x47\x5a\x81\x2f\xb0\xdb\x83\x5a\x2f\x32\x7b\xcd\xbc\xc1\xa2\x93\x0c\xd2\x58\x60\x49\x12\x1f\x68\x4d\xf2\xe9\xae\x23\xea\x69\xd0\x05\xed\x0a\x2a\x3b\xad\x01\xac\x74\x1c\x61\x33\x1d\x47\x48\xbf\x04\x9a\x3a\xe2\xc2\x9f\xb4\x60\xf9\x27\x7d\x1d\x63\x16\x9d\x9e\xaa\xc1\xc7\x35\xb7\xdc\x80\xaf\xd8\xab\xc1\xd3\x34\xed\x5d\x6f\xe8\x1d\xcb\x24\xdb\x52\x50\xdc\x9c\x4e\x7d\x60\xd4\x43\xc7\xd8\x29\x9e\xca\x4a\x5f\xd7\x66\xe6\x0a\x78\x77\x9c\xab\x4b\xcc\x69\x7f\x72\xa4\xa8\xd0\xd4\x4c\xc0\xfd\x9f\x60\x1e\x0e\xe4\x23\xf3\x70\x0a\x46\x9d\x57\x23\x21\x37\x50\x8e\x46\x27\xf0\x7e\xbb\xd5\x1a\xd0\x78\x91\xe4\x95\x78\x83\x5d\x47\x42\x01\x2d\x30\x0f\x17\xcc\xc3\x99\x33\x8f\xdc\x69\x74\x0f\xc6\xc0\x4e\x3a\x8f\x3e\xf5\x51\x32\x0f\x50\x4a\xeb\xe3\x60\x95\x62\x57\x7d\x6d\x4c\x60\x8a\x87\x63\x79\xde\x25\xf5\x8f\xf7\xdf\x3c\x5b\x83\x8d\x53\xfa\x5c\x71\xe8\xa8\x66\xe1\x8b\x72\xd2\x76\x4f\x70\x09\xfe\xee\xeb\xf7\xfd\x7e\x7d\xe0\xb1\xaf\x1f\xc5\x82\xa7\xf2\xc4\x81\xbb\x1f\xa9\x74\xbe\xde\x75\x9f\x28\x6e\xdd\x71\x0b\xad\x3f\x29\x8f\x22\xbd\x73\x81\xc4\xc1\xe2\xb7\xd8\xed\x26\x3d\xcf\xfa\x7c\x7e\xbd\x3f\x50\xe0\x93\xcc\xa6\xb1\x49\xb3\xa4\x71\x8d\x4f\xf2\x60\xe8\xa1\xb1\x49\xd6\x97\x8d\xaa\x6d\x52\xb7\x41\x36\x6a\x31\x5d\xa0\xdc\x56\x9f\xd7\x80\x20\x2d\xa9\x6c\x71\xe6\xdd\x35\x1a\xf9\xa3\xb1\x91\xf1\xc7\x92\xb3\x67\x5b\x66\x90\x2a\x92\x73\x9d\x55\xb5\x23\x1e\x69\x58\x7a\x50\xbe\xce\x5d\x89\x5f\x78\x7c\xfe\xd2\x45\x73\x0a\xdb\x99\x4a\x77\x65\xd7\x53\x2b\xe3\x15\x7d\x37\x4d\x63\xd6\x11\x38\x47\xa8\x3d\x36\xa2\xa4\x9a\xb7\x5f\xaf\x07\x5d\x8b\x2b\x2c\xb4\x1a\xd8\x58\x89\x5f\x0c\x8a\xa4\x28\xb6\xd9\x45\x15\x2c\x6c\x70\xe0\xe2\xb1\x49\xac\x9a\x2c\x17\x37\xf4\x4b\x71\x6e\xd7\x96\xbc\xda\x7d\x4c\x36\x34\xd1\xc5\xde\x2b\xff\x72\x8e\x4b\x29\x88\x79\xff\x91\xe8\x5b\x39\xfd\x35\x1a\xc4\xd6\x13\x53\x66\xcf\xd1\xcc\xdf\xc1\x0c\x5d\x5f\x49\xaa\x61\x76\x5d\x95\xed\xb0\x21\xbf\x14\x98\xbf\x74\xf1\x1c\x53\xff\xae\xdb\xdc\x54\x5f\x1c\x01\xb8\x3e\x00\x73\xa8\x26\x1d\xea\x8a\xed\x76\x07\xcf\x14\xf8\x8c\xe5\xe5\x3e\xc6\xc1\xf5\xae\x29\x36\x97\x98\xc7\x27\x4b\xcc\x9e\x10\x29\xbf\xe4\xc1\x0e\x47\xf7\x40\xbd\x8b\x4d\x45\x11\x8a\xd9\x83\x8d\x1f\x9d\x15\xe1\xd0\xf8\x99\xec\x19\xc7\x9a\x1f\x9c\x9e\x67\x51\x36\xe4\x8f\xb9\xeb\xa2\xf3\x2c\xdf\xd1\x75\x23\x89\x05\x64\x90\x06\x5e\x48\xef\x4c\x09\x40\x87\x99\x4a\x2c\xab\x13\xcc\x4e\xe4\x14\x34\x9c\x3f\xe0\xb1\x4d\x48\x7a\x8c\x8c\x46\x4b\x4e\xe7\xb5\x5a\xc1\xa8\x04\x25\x0a\xa0\x4a\x09\x17\xe8\x2a\xa2\x04\x6f\xe7\xf5\xe2\x13\xf3\xbb\x8b\xd8\x72\x8e\x71\x98\xa8\xf4\x78\x13\xe9\x34\x32\xf2\x98\x74\xac\x89\x44\xc5\x8e\xbc\x3a\x7d\x7a\xc3\xa0\x36\xf9\x16\x4f\xa5\xea\x65\x96\xdb\x98\x33\x99\x73\x9b\x54\x0a\xad\x4f\x7d\x8e\xbb\xd8\xc3\x56\x81\x5d\x48\xf5\xc0\xb3\x30\x87\x4a\xd8\x17\x7a\x14\x4f\x78\x10\xcf\xb3\x5a\xad\x91\x35\x90\x8a\x9d\xc4\xfd\xc8\x23\xba\x1b\xf2\x82\x0a\xb2\xed\x73\x32\x8e\x63\x85\xd9\x84\x97\x68\xe4\x95\x9a\xf5\xbb\x97\x69\xf0\x6e\xcd\xda\xa1\xc0\x3f\x3c\x6c\x88\xbc\x52\x1b\x02\x9e\x33\x96\xf6\x0d\x1e\x91\x28\x72\x71\x9c\x55\x34\x89\x7e\x84\x02\x56\x0d\xeb\xd2\xb8\x7c\x26\xf8\x4f\x54\x3c\xf2\x48\xe4\xc6\x26\xc5\x5c\x14\x91\x58\x80\x5c\xde\x97\xad\xa6\x29\x44\x62\x14\x47\x74\xd9\x23\xb0\xea\x2e\x8a\x2a\xc2\xbe\x99\xb1\x65\xfb\x1c\xd3\x09\x8e\xd6\xfb\x5c\xe1\x72\x73\x95\xa5\x73\xb8\x6d\x06\x41\xd5\x46\xbf\x2b\xe1\x67\x3d\x2f\x32\x5d\x9f\x7b\x2a\x99\xe3\xd6\xb2\x3e\xd3\xe6\x30\x4c\x08\x76\xe2\x25\xb6\x76\xb2\xae\x83\xe0\xa5\x00\x60\xb5\x82\x76\x37\x3e\x51\x66\xd3\x5a\x18\xc6\x69\xe0\xad\xbc\x96\xf5\xfa\x30\x68\xc8\xad\x49\x8b\xd3\x65\x70\xc2\x7f\xbc\x24\x81\xa2\x27\xf5\x6c\x16\x43\x60\x26\x00\xe7\x06\x2f\xa4\x49\x58\x59\x57\x25\x4c\x47\x39\xb3\x2b\x06\x03\xa7\x1e\x24\xa7\xf9\xee\x56\x02\xf1\xd4\x01\xc3\xd7\x0c\x4f\x12\x58\xf7\xdc\x2d\xaf\x89\x06\xfc\xb1\xbe\x8c\x51\x6e\x00\x68\xf5\x78\x6c\xff\xb1\x0b\xf0\xf7\xee\xca\xf3\xef\x0d\x0e\xc4\xf0\x3d\xfd\x00\xb7\x49\x79\x14\xe9\x93\x84\xec\xa8\x36\xe1\xd5\x1a\x0c\x02\x6b\xb6\xb2\x56\x87\xd2\xea\x09\x81\xad\x86\x4c\x6a\x34\x76\xda\x7d\x93\xe7\x70\xc5\x19\x16\x96\xe3\x97\xc1\x23\xd7\x6c\x0a\x7f\x44\xe3\xad\x65\x9b\xea\x80\x91\x47\xed\xd8\x94\x38\xce\x8b\xc4\xd7\xb2\xb0\x7f\xda\xd7\x82\xd1\x62\x9a\x73\xb3\x1b\x15\x81\xd6\xd5\xdb\x6f\xb7\xbb\x82\x06\x4d\x38\x6c\x60\x5c\x5c\x31\x58\x50\xd1\xa0\xc1\xe0\xf2\xfb\x25\xd8\xed\x92\xd7\x3d\x36\xe9\x45\x2e\xfb\xd8\xa4\xcb\x81\xf8\x71\x79\x3a\x47\x5e\x77\xca\x9e\xe2\x41\xd9\xfa\xaa\x36\x9c\x29\xf5\x47\x31\x49\x50\x18\x16\x31\x67\xb1\x0b\x1c\x7e\xf9\xbd\xad\x95\x0b\x8e\x3e\xfe\x8b\x2b\x36\x8c\xd4\xe0\x03\xf2\x9f\xfb\x2e\x74\xf7\x59\x4c\x90\xfa\x0f\x32\x99\x36\xe6\x2d\xad\x3c\x14\xf7\xdd\x23\x9f\x97\x9b\xaf\xa8\x1e\x7d\xf2\xd1\x7d\xf7\xf4\xc6\xa7\x6c\xe6\xab\xba\xf6\x79\x2a\x69\x0b\xaa\x60\xad\x5c\xd8\x5b\x3e\x7d\xc3\x5f\xb6\xaa\x75\x8b\xf9\x0d\xb0\x3f\x2a\x88\xb7\x4c\x12\x0c\x5a\x37\x72\xc4\xc2\xe1\xc2\x42\x87\x56\xe0\x2a\x7b\x45\x23\x63\x93\x51\x47\xd8\x29\x29\x71\xe2\x31\xd0\x8f\x2d\xac\x65\x7c\xb2\x8c\xec\x99\xf4\xa1\x8b\xea\x49\xca\x6b\x11\x91\x16\xdc\xdd\x25\x48\xba\x83\x4d\xce\xc7\x4c\xdd\x62\x66\x6a\xcb\x43\xa3\x26\x5e\x96\x16\x28\x93\x2a\x36\xcc\xd2\xcd\x3a\x38\xc7\x33\xb5\x62\x0b\xf9\x70\x80\x54\x2e\xf6\x0f\xfb\xf9\xe8\x29\x97\xbd\x34\x67\xd5\xfc\x39\xd1\x69\x4c\x2f\x45\xbc\x74\xb6\xed\x68\x60\x12\x5d\x4f\xed\x88\x74\x4e\xda\x51\xcf\x24\xce\x03\x7f\x78\xa9\x73\xcd\x62\x45\x2e\xd2\xf9\x55\xa2\x29\x89\x2a\x49\x80\xd9\x95\x44\xe9\xf4\x04\xb6\x57\x55\x89\xbf\xdc\x3f\x3e\x59\xee\xa4\xb3\xf4\x65\x66\x89\xe8\x14\xd9\xfc\x1a\x2f\x17\xec\x23\xf6\xbf\x99\xa3\xed\xbf\x9a\xe4\x5f\xd6\x6b\xe4\xdf\x4f\xf6\x8d\x38\x3c\xe2\x47\x67\x49\xfb\x65\xfc\xed\xea\x39\xcb\x17\x2b\x32\x89\x9f\x0e\x7a\x63\x1f\x52\xbb\x27\x1a\x0a\x85\x2b\xec\x1e\x9e\xd1\x19\x8d\x75\x35\x35\x8c\x27\xcc\xd5\xf7\xad\x88\x46\xcd\xbe\x52\xdf\xf8\x64\x55\xa9\xb9\xa8\x70\x6c\xb2\x48\x72\x86\x7b\x88\xa6\x78\xae\x3e\x16\xef\x51\xb5\xf8\xc2\x12\x8a\xd4\xdc\x8e\x28\xa5\x8b\x95\x8f\xd9\x9c\x80\x8c\xa0\x62\xd8\xcb\x73\xe5\x54\x59\x65\xc5\xfa\x4e\x75\xde\xdb\x2e\x53\x16\x17\x3b\xfd\x43\x1f\x86\xc5\x1d\x76\x78\xd4\xc4\x19\xae\x85\x83\xf3\x64\x55\x7d\xdb\xe5\xfd\xba\x5e\x60\x86\xc2\xe4\xa7\x6c\x6d\xe8\x7a\x81\x05\xde\xff\xd2\xac\x75\x4b\x16\xcf\x5e\xb3\x60\x4e\xcd\xd6\xae\x1b\xe5\x95\xd4\xae\xfb\x12\x64\xf3\x43\x80\x87\x18\x89\x2d\xe5\xbc\xde\x98\xd9\x66\xd3\xc5\x74\xa5\x85\xc1\x60\x49\xa0\xa8\x95\xa4\x5f\xf9\xcc\xc0\xd2\xcc\x0e\xce\x29\x3a\xc7\x27\x45\xa5\x79\xbb\xf4\x83\x7e\xd1\xf4\x0e\xcd\x4f\x76\x20\x6b\x9a\x11\xd1\x79\x21\x09\x1f\xe7\xe4\x37\xcc\xdf\xa1\x51\xf5\x8e\x47\xfa\xae\xce\x8b\x48\xc8\xa4\x35\x98\xfa\x75\xdd\xea\xae\x64\x86\x92\x4e\x71\xdb\xa6\x76\xcd\x4a\xc7\x24\x28\xfd\x8c\x46\x71\x3a\x98\x4f\x09\xad\x51\x2b\x49\x66\x56\xa3\x09\xf9\x60\x21\x8b\xa2\xd1\x32\x87\xde\xad\x1f\x9f\x74\x9b\x6d\x16\x50\xa9\x25\xb3\x83\xf4\x9e\x28\xcc\x63\x85\x79\x39\xbb\xf1\x6e\x49\xbb\x84\x68\x7d\x38\xbf\xe3\x5d\x56\xb5\xc8\xf2\x4a\x76\xc2\x9a\x4d\xd5\x23\x5d\x17\xe8\x7a\xb4\x44\x65\x9d\x93\x08\xeb\x1c\x8b\x19\xfc\xa0\x3a\x87\x6c\xce\x06\xa8\x13\x3b\x33\xcc\x14\xa7\x16\xa6\x3e\xe7\x86\xc0\x7e\xf4\x81\xd5\x56\xec\xd6\x9b\x1d\x7a\x07\x63\xb3\x05\x44\x86\xf1\x4b\x2e\x87\xc3\x6c\xd6\x13\x3d\xc2\x6d\x55\x8b\x37\xe7\x54\xaa\x8c\xa7\x83\x66\x9b\xba\x07\x7b\xf7\xae\x16\x09\xee\x89\xd1\x66\xf5\x61\xb5\x99\x54\x98\x76\x9a\x12\x19\xa1\xaa\xba\x4f\xa4\xc2\x6c\x31\xf6\x6d\xef\xd5\x6b\xb9\x06\xd7\xe1\xb1\xb3\xd7\x6a\x70\x52\xb3\xf1\xc0\x65\xf2\xe2\xe2\xa6\x5d\xf6\xf0\x95\x15\x16\x94\xc2\x7a\xa2\x58\x77\x6d\x62\x06\x12\x91\x7e\xfe\x16\xd6\xf1\x9e\x7c\xd7\x77\xd9\xbc\x26\xf6\x55\xab\xc0\xdd\xa2\xd4\xf4\x49\x9d\xe7\xcb\xd9\x23\x28\x88\xca\xd0\xd5\x89\xb1\x25\x9c\xc5\xe3\x09\xbb\xac\x56\xbb\x9f\x5a\x6b\xf6\x30\xc7\x97\x57\x38\xdc\x16\x77\x6b\xd2\x6e\xb0\xf8\x2d\xa3\x2c\xd3\x2c\x8b\x2c\xbc\x81\xb5\x58\xb0\x96\xb4\x8c\xd3\x6b\x25\x4d\x11\xc8\x2e\x58\x2b\x8d\x39\x1c\xc2\x21\x50\x73\x9d\x05\x08\x79\x5b\xbb\x07\x38\xaa\xed\x98\xb3\x6e\x94\xee\xe5\x53\xb3\xc4\x19\x16\x55\x4b\xcf\x45\x0a\xde\x92\xa0\x40\x1a\xf5\x15\x8b\xa8\x95\x92\x8b\xb3\x59\x02\xcc\xa1\x57\xde\xfc\xdd\xf5\xd8\xf8\xc8\x2b\xf8\x77\xe5\xf5\xcc\x80\x6b\xaf\x6c\xfc\x4d\x55\x7d\x6d\x5f\xcd\x6f\x06\xde\xbf\x65\xf2\xa8\xfa\xfe\x5d\x03\x92\xbb\xc2\xf5\x2b\x9e\x9c\xbd\x99\x7b\xf5\xd8\x7d\x58\xb8\x8e\xff\xf7\x4d\x1a\xf9\xe7\x4b\xe4\xf7\x96\xc9\x77\x68\x0f\xcb\xdf\x0d\xe5\x59\x27\xff\x93\xaf\x6f\xda\xb2\x47\x89\x11\xe4\x27\x53\x5f\x51\x15\x1a\x94\x08\xeb\x8a\x0a\x5c\x12\x5b\x51\x21\x15\xb1\xd5\xbd\xad\xd6\x70\x49\x09\xc8\xe9\x12\x73\x01\x32\x84\x0d\xe3\x92\xde\xb0\x33\x2d\x39\x32\x1a\x62\xbe\x62\x58\x5c\x93\xf5\x28\x90\xdd\x54\x0b\xd0\x9b\x18\xd1\x4e\xbb\xc4\x47\x72\xf2\x20\x94\x12\xb8\xec\x0d\xdb\xf7\xbe\x7c\xe2\xfe\x6f\x77\xdd\x3a\xf4\x27\x25\x3a\xed\x41\x93\xbf\x54\x97\x9c\x32\x63\x83\x53\x53\x7f\x7d\xe7\xf5\xb7\x1e\xc3\x13\x3f\xfe\xd9\x37\x5b\x16\xbd\x36\xf9\x3f\xaf\x3c\x79\xfc\x2a\xf9\x9b\x7b\xcf\xae\xe8\x7c\xa3\xb1\x76\xec\xa5\x6b\x3c\xd3\x57\x2d\x9c\x79\xe9\xec\xc9\x2f\x3d\x74\x02\x7b\x6f\x5d\xf1\xde\x9e\xfd\x5f\x5c\x4e\x62\x3f\xfb\xc0\x9e\x0b\x52\x5d\x2e\x02\x2b\x7c\x59\x22\xee\x17\x62\xb0\xc4\x41\x1d\x53\x64\xb7\x33\x02\x5b\x5e\xa1\x50\xa9\x11\x45\x43\x3a\xd0\xf2\x2d\x3a\x73\x2c\xc8\x06\x5b\x93\x6e\xd6\xe9\x51\xc2\x54\x7d\x79\x85\x7a\xdc\xb9\x6d\x24\x7a\x56\xc1\xb4\x81\x8a\xa9\x24\x2c\xa6\x8d\x72\x5a\x22\x9a\x9e\xb9\x60\x98\xb6\xcd\xc4\x14\x93\x48\x34\x66\xbf\xe6\xbe\x81\xfb\x1f\xdf\xf6\xd9\xde\x21\xb7\x69\xf0\xa7\x9a\x83\xcd\x07\x1e\xbf\xf2\xe3\xeb\x07\x80\xf4\x9f\x9f\x1c\x7b\xfd\x84\xeb\x26\x31\xd7\x3c\x74\xdd\xe4\xeb\x27\x90\xfa\xa1\x78\x9a\xfe\x17\x0f\xdc\x81\x0d\x77\x6a\xf0\x0e\x42\xd1\xf2\x66\xfd\x2f\x1f\xbc\x53\xfe\xd7\x01\xad\x7c\xd0\x53\xc9\x6a\xb7\x5c\x6b\x60\x6b\x8d\x37\xfe\x73\xc3\x79\xdf\xf9\x93\xe6\x9b\xff\x0d\xbc\x86\x4d\x7d\xca\xfc\x92\xe6\x1a\xd5\x27\x7c\x46\x1d\x6f\xb1\x20\x1d\xb2\xda\x2c\x12\x6f\xd4\x18\xc7\x27\xf5\x1a\x27\x87\xc7\x26\x39\x47\x8e\xb1\x9b\x77\x50\x9c\xdb\xbc\x8e\xf0\x42\x22\x21\x98\x5f\x12\xb1\xfd\xf7\xe0\xb8\xa7\x26\xa6\x83\x47\x16\xb2\x87\x89\x80\x3e\xbd\x7e\x15\x0d\x19\x61\xe6\x21\xe5\xd9\x6c\x09\xe0\x9c\x3e\x9b\x3c\x19\x76\x12\x30\x0c\x9b\x05\xd1\x47\xf3\xdd\x9e\x1d\x4f\x47\x1d\x59\x7f\xe0\xd9\x6c\xc9\x3f\xbb\x3f\xfb\x05\x7e\xf7\xd9\x27\xb3\xcf\xe6\x86\xd3\x67\x83\xcc\xf0\xc3\xbc\x03\xa4\x27\x0e\x9d\xb7\xc3\xea\xf1\xf9\xac\x3a\xb6\x20\x68\x91\xd2\xcf\xf7\x21\xe4\x6a\xcd\x5d\xd9\x7c\xff\x51\x2e\x53\xb5\xe5\x42\x91\x1b\xe8\xc4\xcc\x5e\xb3\xa9\xa1\xf5\x78\x1b\x05\x67\xcc\x03\x23\x17\xdf\xff\x48\xae\xf2\x39\x0a\xd7\xac\x5c\x0a\x80\xad\x9e\xcf\xcc\x3b\x1f\x5a\x34\x30\x13\xcf\x84\x11\x0f\x30\x46\xe8\x99\x7e\x5d\xc2\x27\x91\x3c\x1a\x2b\xcf\x30\x36\xc5\xe8\xd2\xf9\x24\x1a\xe3\xc3\xe6\xc7\xf8\xa4\xd3\xc1\x2c\x39\x51\x3d\x59\x36\x9f\x8d\xe6\x79\xf2\xe0\xa7\xf9\x51\x3c\xe7\xfe\xcc\x7b\x95\x00\x1e\xfa\xec\x01\xea\xb3\x43\x24\x9f\xdb\xa7\xd1\xb8\xec\x06\x93\xdd\x14\x66\x42\xa1\x42\x1f\x53\xc0\x8c\x4f\xa2\x02\xb3\xc7\x35\x36\xe9\x91\x4c\x16\x8b\x0e\xf6\x83\x2f\x4f\x73\xca\x17\x3f\xd9\x46\x01\x34\x70\x20\xa7\xe3\x48\x5a\x85\x12\x95\x83\xc5\xff\x50\xd8\xd6\xa4\x25\xcc\xc0\x35\x9b\x42\x7b\x54\x30\x61\x39\x99\xd7\x01\xce\xae\x19\xaa\x64\xd9\xb1\x69\xd8\xc3\x6c\x54\x59\x57\x05\xe6\x07\x60\x23\xbb\x00\x66\x09\x45\x12\x16\x09\x21\xb3\x56\x10\x2c\x9c\xbe\x35\x29\x72\x66\xc2\x63\xd3\xed\x47\x15\x3b\x2f\xde\xad\x73\xd6\x03\xed\x25\xcf\xdc\xa3\x06\x03\x0c\x1e\xea\x5e\xcc\x38\x94\x33\xff\x8d\x7b\xba\x6e\x54\xc6\xdf\x0b\x82\xa0\x01\xc6\xb7\xa2\x8a\x84\x03\xb1\xac\x55\x12\xb5\x92\xd6\x6e\x03\xf3\x84\x6f\x4d\x1a\x94\x67\xa8\xdb\x3d\x67\xda\x61\x45\x4d\xca\x6d\xf0\x80\xc3\x73\xd5\x39\x76\xd4\xad\xd9\x14\x9c\xc0\x0c\xcf\x99\x94\x5c\x05\xfc\xb5\x05\xe6\xd2\x4a\xf7\xa5\x17\xb4\x80\x0a\x17\xc6\x8c\xd9\x68\x05\x43\xd6\xc0\x70\x3e\xbf\xa2\xcd\x18\x5c\x88\x26\x21\xb8\x18\x9e\x77\xb6\x26\x95\xe8\x4a\x86\x02\x91\x3d\x15\x45\x0d\xf9\x7d\xdc\xd4\x00\x61\x35\x66\xcd\x2e\x88\x36\xd2\x55\xd3\x46\x23\xca\x69\x6a\xea\xd0\x43\x07\xd6\x69\xf0\x4d\xf7\xdc\xba\x69\xc3\x81\x79\x9a\x6f\x7e\xf6\xc9\x8c\x99\xc3\x06\x8d\xdc\xb1\x19\xef\x93\x17\x11\x0d\x6c\xd9\xea\x05\x7b\xc3\xf2\x4d\xce\x4a\xbc\x0f\x57\x4c\x1a\x2a\x5f\x4d\xca\xc4\x92\x78\x7e\x4e\x0b\xf0\xda\xc0\xf8\xb9\x34\x51\x6d\xf2\xfb\x45\x17\x0b\x7a\x18\x0b\xa6\x6f\xc0\x62\x29\x30\xdb\x88\x3b\x0a\x11\x9b\x98\x1c\x54\x8b\x3a\x52\xe6\x6c\x6c\x52\x27\x89\xfe\xd6\x1c\xcb\x98\xba\xd2\x72\xe0\xee\x1e\x6e\xa0\x1e\x0f\x64\x82\xc4\x71\x1c\x8c\xf4\x74\x40\x3c\xb3\x6e\xc4\x8c\xf7\x4f\xca\x9f\x1e\xd8\xa0\xc5\x0f\x6b\xf6\xf6\x5f\x8d\xfb\x7e\xa9\x5d\xda\xf5\xcb\xed\x57\x5f\xd6\x39\x72\x10\x4e\x99\x96\x8c\xba\xe9\x2e\x32\x85\x4a\xaf\xfc\x18\xde\x57\xe9\x3c\xff\xe9\xba\xa5\x97\x8c\x95\xaf\x06\x1d\xa5\x4b\xcd\x7d\xa9\x05\xe8\xab\xc4\x2a\xb7\xb7\xd4\xc8\xd4\xd6\x1a\xbd\x55\x5c\x1f\x7b\x28\x54\x57\x2a\x9a\x6b\x6a\x38\x60\x05\xa8\xc6\xec\xf5\x06\x02\x80\x6e\xd0\x29\x63\xad\xc9\xc2\x42\xf3\x45\x13\x5f\x7a\x5a\x7b\xdd\xb2\x5e\x48\x80\x44\xfe\x66\xb0\xfd\x58\xca\x4b\xfd\x60\x7f\x76\x73\x34\xff\x50\xa6\x8b\xe1\xfa\x21\x2a\x49\x2d\xc1\x13\xba\x65\xb9\xe0\x94\x06\xf6\x77\x98\xca\xbb\xea\x84\x9b\xf1\xf9\x02\x66\xa3\xd1\xef\xa1\x33\xf4\x20\x3d\x0d\x26\xd0\xfb\x72\x8f\xbf\x70\xf7\x59\x74\xd3\x7f\x95\xdd\xc4\xc8\x64\xfb\x34\x0d\xf5\xbd\x5a\xf4\x60\x8e\xda\xfb\x5c\x8c\xc4\xd9\x70\xc7\x57\x38\x96\xde\x7a\xee\xe0\x9b\x2f\x2b\xba\x2e\x57\x0f\x3b\x2c\x07\x16\x52\x6b\xa8\x44\xab\xd1\x07\xbc\x3e\xc1\x12\x89\x14\x5b\x8a\xf4\x3e\x3f\x90\x8b\x06\x2c\xed\x70\x98\xc2\x16\x46\x12\xa0\xde\x6a\x95\x7c\x3d\x8e\xe6\xf2\x7b\xc6\xe5\x80\xa9\x56\x1d\xcd\x69\x82\x45\xdc\x4f\xf9\xe0\xde\x77\x44\x3a\x62\xcd\x03\xd9\xf7\x37\xe9\x6f\xfb\x72\xc0\x3e\xdf\xd1\x36\x3b\x0d\xf8\xcd\x6d\xec\x48\x02\x3a\xc0\xfe\x61\xea\x73\x7c\x96\xbf\x96\xfa\xee\x0b\x03\x41\xa7\xdd\xe3\xd1\x08\x6c\x90\x8d\x18\x4c\xa6\x42\x93\xca\x1b\x11\xa9\x34\xe4\xcb\x89\x79\xab\xea\x19\x27\x1c\xcf\x6d\x11\x43\x35\xf4\x7c\x96\x91\xe3\xc6\x18\x0c\xaa\xf9\xf8\x1c\xfe\x11\x9a\x99\x16\x28\x76\x45\x23\xff\x65\x86\x9b\x5c\x72\xac\xeb\x17\x59\xb7\x06\x62\x52\x41\xb9\x99\x6d\xa6\xb9\xbe\xa4\xc3\x4d\x79\x91\xdb\x24\x6a\xf5\x5a\x37\x6b\x63\x0a\x0a\xca\x82\x36\x5b\xa9\x49\xeb\x8c\x8e\x4f\x6a\x9d\x4e\x83\xdf\x0f\x28\xf7\x23\x33\x68\xac\x66\xbf\x21\x5b\xf6\x3c\x7b\xe2\x9f\x5f\x37\x3e\x9f\x38\x44\xa7\x23\x12\x8d\x65\xdc\x7b\x2e\x05\xe1\x34\x84\x8c\x14\x7d\x15\xd8\x42\x15\xf5\xbf\xd6\x8e\x1b\xae\x2b\x9d\xfc\x74\x6b\xfb\xbe\x45\x35\xc5\x0a\xa5\x9c\x8f\x97\x14\xaf\x8f\x44\x6b\x07\x8c\x57\x69\x66\x40\xb4\xf3\x96\x29\x7d\x6f\x6a\x6d\x9e\xb6\x45\xcf\xd5\x02\xee\xbf\x9f\x1a\x88\xdd\xa9\x6f\xa0\xfe\xbe\x6f\x61\x0d\x64\x6e\x3b\x70\xca\xa6\x44\xc8\xed\x40\xc8\x6a\x10\x0c\x4e\xbf\xd3\xe7\x22\x5c\xd1\x25\x49\x2e\x9e\xd5\xda\xb5\xec\xb8\xa4\xd6\x4e\x83\x9b\x68\x3a\x85\xbb\x4a\x6d\xb7\x94\x89\x61\x56\x53\xdc\x33\x11\x18\x02\x1b\x97\x98\x48\x3d\xa1\x96\x3e\xb8\x35\xbf\x7f\x57\xa6\x2f\x1a\xfb\x7c\xb6\x6f\x57\xd7\x71\x9a\xd8\xcd\x14\x77\x50\x79\x51\xa2\xf6\x79\xf3\xa2\x61\x89\x88\x17\x98\xb4\xcb\x6e\xd1\xea\x2d\xb0\xaf\x90\xdf\xce\x78\x19\x50\x1e\x13\x2e\xaf\x44\xca\x4f\x89\x79\xb1\x48\x39\x6d\xdd\xd2\xf2\x53\x85\x4f\xe9\x37\x96\x2f\x3e\x69\x5e\x3a\x33\xd3\xfc\xeb\x7b\xd2\x64\xd0\x04\x34\xb1\x5b\x81\x91\x3d\xdc\x76\x7e\x59\xae\xc4\x74\x13\x10\x95\xb3\x8f\x48\xea\x33\xf6\x43\x7a\x7e\x10\x05\x8d\xb7\x46\x0c\x04\x18\x4f\x91\x4d\xab\x35\xe9\x3c\xba\x58\x89\x2d\xe4\x0c\x91\xf8\xb0\x62\x13\x0d\x57\xd5\x8b\x18\x5b\x79\xab\x34\x36\x69\x75\x68\xa5\x9c\x48\xfe\xa6\x6e\x09\x3e\xee\x5c\x11\x98\xe3\x32\x49\x07\xf3\x87\x41\x3b\x8a\x2b\x7e\xe0\x4c\xeb\xaa\x7a\x57\xba\x02\xb0\x10\x91\xe6\x37\x12\x37\xc9\x08\x7c\xd5\x88\x83\x23\x96\x4a\x4b\x13\xd9\xe6\x55\x62\x70\x1b\x75\x76\xbb\xe4\xf5\xc5\xf8\x78\x1b\x9e\xee\xae\x94\xdb\xf1\x3d\x72\x7b\x9b\xbc\x57\x6d\x5c\x65\xec\x7b\xfc\x1b\xe2\xe4\xbe\xfc\x3d\x45\x66\xf7\x02\xdb\xb3\x8e\xf6\xec\xe8\x48\xd4\xd8\x58\x9d\x41\x34\x15\x05\x3c\x25\x25\x01\x93\x81\xe5\x49\x38\x6e\x65\xc8\x60\x30\x46\x34\x46\xcd\xf8\xa4\x5f\x12\x60\x7a\xc5\x82\x80\x02\x60\x8a\x3a\x72\x02\x5e\xf2\x7b\x57\x5d\xf8\x9c\x47\x39\x74\x53\x9b\x54\x91\xf4\x7b\x46\x71\x05\xd5\xd1\x7e\x56\x62\xb6\x9f\x95\xc0\xe1\xc7\x9e\x38\xf5\xf7\x47\xcc\x4d\xd7\x54\xf7\xab\xef\x87\xef\x1d\x34\xf9\x9a\x31\x7f\x5c\xfc\xe8\x65\x33\xa7\xb9\xf1\x3d\x81\x7a\x67\xcd\x15\x03\xb9\x2d\xfb\xf7\xca\xb2\xfd\xde\xfd\x0f\x60\x14\xae\xd3\xcd\xf9\x3e\x85\x0c\x6b\x9e\x9c\xf5\xab\x65\xcf\x2e\x9c\xb6\xd2\x88\xd1\xf7\x73\x74\x75\xd6\xbb\x36\x5d\xf1\xeb\x75\x30\xc7\x79\x60\xab\xde\x09\xb2\xab\x10\x0d\x4e\x44\xa8\xaf\xd4\xed\xb5\x05\x83\x5e\x96\x8d\x14\xa9\xb2\x4a\x0d\xbd\xa5\x4e\x53\x67\x7e\x95\xcd\x7c\x07\x5e\x6e\x8f\x2a\xd5\x99\x95\xe9\x54\x49\x78\x91\x85\xb4\xb1\x99\xbb\xe9\x72\xfd\x2c\xb2\x48\x2b\x75\xbb\xc6\x3c\xb0\xa6\xa9\x25\x51\x1d\x1d\xd4\xbb\xa8\x79\xf4\x7f\x76\xcb\xff\xb6\xcf\x9e\x7e\x49\x03\xd3\xe4\xae\xec\x5a\xda\x10\xd9\x31\xeb\xee\x0f\xaf\x98\xbd\xcc\xb1\xf1\x94\x4d\xfe\xfc\x4d\xf9\xa5\x67\xc9\x9a\xe8\x41\xb7\xd9\xc4\xbe\x00\x7a\x54\xaf\x84\x1b\x89\x7a\x9d\x59\x32\x18\xcc\x22\x6b\xb3\x4b\x86\xb1\x49\xc9\x61\xd6\x99\x79\xaa\xae\x35\x75\x3b\x3e\xa8\xb7\x93\x03\x4d\x02\x1e\x8e\x93\x58\x7b\x30\xdf\x7f\x46\x23\x99\x27\xe0\x43\xc3\x9f\x5d\xae\x4d\xa1\xeb\xbe\x4f\x5c\xa1\x84\x2c\x4f\xd9\xc9\xdc\x7f\xfe\x4a\x4f\x25\xf3\x3b\x79\xc1\x3c\x85\x16\x5c\x08\xf1\x95\xf0\x5c\x37\x1a\x95\x88\x49\x4e\x8c\x0c\x7a\x1d\xc3\xb1\x5a\x0d\xcf\x6b\x19\x83\x93\xf7\x78\xb5\x06\xc6\xa0\xd7\x23\xbb\x43\xc3\x03\xba\x1c\x8a\x6e\x9d\x0e\x50\x6e\xc8\x4d\x3b\xcc\x3d\x36\x8b\xdb\x28\x38\x11\x16\x47\xf4\x34\x95\x23\x0d\xe4\x07\x83\x36\xe1\x81\x43\x1f\x9a\xa3\xf9\x66\x87\x7c\x72\xe4\x86\x57\x1b\x14\x60\xd9\x17\xba\x6e\x64\x16\x52\xe0\x5e\xee\x3a\xc4\x4c\x97\x37\xae\x50\xe3\xac\x87\xdc\xac\xe2\x87\x1b\xc2\xcf\x41\x41\x52\xb7\x8e\x37\x04\x18\x09\x17\x14\x48\x06\x16\x78\x9b\x23\xcc\x04\x02\x36\x9d\xda\xf2\x4a\xe7\xc0\x05\xd9\xd3\xb2\x57\x6a\xaa\x2e\xe0\x67\x56\x8f\xcb\xf2\x01\x4b\xb7\xd5\x87\x75\x65\x41\x01\x64\x67\x03\xe6\xfe\x9e\x50\x51\xb9\x2b\x3f\x20\xfc\xc4\x32\x82\xc2\x65\xe3\x14\x08\xc7\xee\x66\x6e\x55\xe3\xc0\xe5\x7f\x8f\x3f\x7f\xd0\x43\xfa\x11\xc1\x7a\x2e\x83\x3d\x66\x27\xfe\x37\x83\x88\x78\xbb\x51\x30\xd9\x6c\x02\x2f\x72\x0e\x8b\xc5\x69\x03\xf6\x66\xd0\xc2\xca\x1a\x81\xa3\xb2\x66\xad\x44\x82\xfa\x73\x4f\x60\xe2\x6a\x3a\x74\xdc\x12\xef\x19\x97\x50\x9c\xdb\x53\xcc\xa7\x9e\x01\xe3\x1d\xbb\x35\x72\x83\x66\x5f\xdd\x1d\x0b\x34\xf8\x80\x66\xf3\x9a\xff\xac\xd2\xe0\xe1\x9a\x25\xf2\xf3\xf4\x88\x06\x97\xe2\xb3\x4e\xa2\xe5\xad\xc7\x57\xbb\x2b\x2b\x9d\xb2\x21\x93\xd7\x3b\x9f\xe6\xf5\xce\x48\xd4\x18\x4c\x5e\xd6\xe1\xd2\x98\xcd\x2e\xd6\xc4\x09\xa1\x50\x91\x55\x10\x22\x16\xd0\xe7\x89\xea\x23\x49\xa2\x55\xb0\x12\xd5\x5a\x70\x84\x42\xc0\xae\xf3\x1c\x6c\xd9\x1e\x56\x17\x4a\xe2\xce\x39\x7f\x08\xe7\x17\xb0\xa2\xd9\xf7\x59\xbb\xf0\xe8\x9a\x4d\x0e\xd9\xde\xad\x90\x15\xed\x61\x35\xc9\x93\x63\x20\xd6\x6f\xc9\x96\xb4\xaa\xba\x41\x3e\xde\x31\x4c\x11\xe7\x4c\xea\xaf\xa9\xe5\x6c\x1d\xf5\xab\x15\xa3\x85\x89\x7a\x1b\x8f\x82\x7c\xd0\x1a\x89\xb8\x0d\x26\x98\x17\x6b\x62\x05\xb7\x3b\x06\xd3\x8a\x3a\xfc\xa4\xe5\xb0\x20\x65\xa7\x17\x54\xe6\xc7\x22\x72\x6e\x17\x7f\x4d\x65\xdc\xea\x84\xac\x99\x76\xdc\x79\xd3\xca\x78\xde\xc2\x34\xaa\x37\xbf\x3a\x97\x55\x0d\xf9\xb5\x81\xec\x57\xce\x33\x70\x7d\xac\xb4\xa5\xb0\xe8\x7c\xb7\x09\x8e\x7b\xfa\xf9\xe1\xc9\x3b\xf7\xac\x6d\xd8\x3d\xfc\xd0\xb4\x39\xbd\xfa\x4d\x9c\xd4\x90\x9d\x1f\xd6\x8e\x4f\x74\xcc\xc3\xda\xa9\xed\xfd\x6a\x82\xbd\xc8\x9a\xd1\x9a\xd0\xd4\x4e\x1f\x99\x88\x5a\xed\x6e\x83\xc6\xeb\x35\xd8\x59\xc6\xe4\x74\x06\x99\x02\x97\xe4\x90\x40\x8a\x1a\x0c\xb0\x65\xa5\xee\x87\x2f\xf1\xbc\x56\x5d\x79\xcd\x6d\x6c\x17\x38\x76\xa1\xf3\xa0\xe7\x2d\xa7\x2f\x70\xdc\x52\x55\xc1\x9c\xbb\xc8\x29\xcb\xd9\xec\xe1\x0a\x93\xda\xaf\xc2\x1b\x43\x71\xb4\x36\xd1\xe4\xf5\x87\xec\xe5\x46\xa6\xd8\x1c\x89\xc4\x8a\x8d\x76\xbf\x20\x3a\x0b\x0a\xea\x7a\x8b\x62\x6d\xd0\x15\x70\xb5\x26\x43\x76\xbb\x2e\xe0\xf7\x07\x24\xa6\xbc\xd8\x58\x6e\x44\x3a\x5d\x2f\x52\xa4\x8e\x2b\x19\x97\xe4\xfc\x28\x4f\xe7\xa2\xc0\xf7\x6c\x41\x66\xe9\x29\x89\x70\x8e\xde\xa5\x86\xa0\xf5\xec\x23\x25\x3a\x5d\x24\x5f\x2b\x1d\x8b\xc8\x54\x70\xba\xdd\x6f\x5f\x7b\xcf\xcf\xb7\x2d\x3b\x3a\x30\x64\xbe\x6a\x5d\x8f\xa9\xdf\x7c\xd7\x41\x33\x96\x47\xcc\xf9\x69\x9f\xfe\x77\xb6\x4d\x5c\x36\x57\x1e\xd5\xab\x60\xc2\xba\xb9\xed\x57\x4c\x1b\x3b\x70\x7e\x9f\x9d\x77\x67\x91\xe1\x7e\xe8\xda\x7f\xef\xed\x3b\xf4\xb2\x9a\xf8\xd8\x49\x63\x06\xd6\x0f\x23\xeb\xf8\x7b\xe0\x11\xab\xf8\x87\x60\x4a\xa3\x12\x51\xa3\xe4\x65\x3d\x1c\xc7\x4a\xac\xc6\xe1\x08\x60\xb0\x3b\x38\x6c\x95\x24\xab\x15\x6c\x75\x2b\xf6\xb2\x98\x6d\x55\xb8\xda\x05\x93\xd3\x2d\xf1\xfc\x3e\x52\xb6\x7a\x35\xa8\x3f\xa7\x23\x31\x16\x59\x17\xd3\x42\xf2\x7b\xa6\x0d\xbf\xfd\xd9\x39\x33\xb6\xce\xab\x19\x14\x3c\x70\xfc\xe0\x4b\x0b\x5e\x58\x33\xe1\xbd\x3a\x1f\x63\xd4\x39\xb1\xe3\xd4\xc6\xcd\x2d\xf7\xc9\x83\x9e\x3b\xb4\xf7\xd3\x7d\x36\xb9\xc4\x47\x14\x1d\x80\xf3\x59\x80\x93\xe8\x6c\x45\xa2\x5d\x6f\xd6\x59\x2c\x66\x3b\xeb\x63\xbc\x5e\xbf\x45\xa7\x33\xb9\xdd\xd4\x0e\x71\x63\xbd\xd9\x64\x86\xbd\xe4\xe8\x96\x87\xd9\x5d\x37\x48\x6b\xc4\x8c\xc3\x1c\x4c\x17\x6e\xc8\xc4\x82\xb2\x7b\x07\x09\xe3\xb6\xef\x38\x71\x6a\xd8\x34\x25\x19\x69\xc2\x86\x2b\xb7\x7f\x7a\xcd\x93\xbb\xb8\x85\xf7\x0f\x93\xff\xf5\xa2\xdc\x15\xd0\x75\x7d\x45\xb3\x8f\x7e\x1d\x78\x76\xcf\xfe\xef\x77\x0d\x24\xb8\x7c\x1b\xe4\x7d\x7f\xfe\x26\x05\x46\x8b\xce\xac\x17\xed\x76\xbd\x8e\xf5\x03\x8c\x3e\x80\xd1\x6d\x54\x61\x74\x12\x97\x65\x6b\xd2\x88\x7e\x14\x46\x96\x5a\x46\xd6\x3a\x73\x15\xce\xf1\x46\x52\xa3\x89\xcf\x01\x91\x59\x98\x05\x11\x57\xdc\x3f\x0c\x4b\x2f\x62\x36\xa0\x63\x8c\x04\x44\xb9\x14\x40\xbc\xe9\xfb\x6b\x07\x52\x59\xab\x07\x5e\xbb\x0b\x74\x92\x20\xea\x9b\xf0\x07\x10\x32\xe9\xf5\x7c\x08\xc4\x97\xd5\x4b\x22\x2b\xad\x66\x8e\xd3\x68\x98\x71\x49\x4d\x3e\x57\xcd\x3b\x09\x77\x99\x73\xda\xea\x82\x7d\xc9\xd0\x0c\x82\xb4\x7d\x21\x3c\xf3\xf6\xee\xdb\x0b\x68\x6e\x44\xa0\xc6\x7f\xc7\x1f\x37\x91\xa4\x01\x92\x1d\xb1\xed\xa5\xc8\x40\xcb\xa8\x14\xea\x2c\x23\xf9\x11\xcd\x87\x70\xc1\x5d\xff\xda\x46\x92\x05\x1e\x6e\xfa\xfb\x49\xf9\xae\x0e\x25\xd7\x9f\xd6\x24\xa3\xb9\x9e\x01\x54\x8a\x1a\x12\x01\xd1\x8a\xbc\xde\x82\x22\x2b\x57\x56\x1e\x0b\xc7\xc2\x4e\x93\x13\x88\xd0\xc9\x99\xc0\x7e\x33\x39\xbb\x1f\x82\x67\x13\x37\xf2\xfb\x09\xe0\x4c\x63\x7f\xa5\xeb\x00\x9b\x13\xdf\xc0\xbd\x93\x6d\x28\xd0\xf5\xc6\xdd\x72\xea\xa7\xe9\x9e\x03\xff\x23\x1f\x32\xa6\x23\x1d\xd8\x44\x4e\x3b\x81\xae\x79\x57\x7d\x7b\x40\xed\x38\xf0\x0f\x79\xc5\x3b\xcc\xa3\xd9\x74\x55\x98\x43\x33\xbc\xd4\x03\xaf\x91\x40\xb3\x09\xa1\xf6\x44\xbd\x9b\x14\x78\x30\xfa\x05\xc1\xa8\x45\x5c\xb8\x50\xe7\x76\xba\x41\xf9\x33\xb8\xfd\xee\x51\xee\x69\xee\x45\x6e\xde\xc0\xba\xdd\x88\x65\x43\xc0\xf9\x31\x48\x60\x89\x7a\x37\xd3\xce\x97\x8b\xc7\x6d\x2a\xee\x32\x52\x8a\x80\x86\x68\x92\x5c\xc7\x70\x3d\xe1\x9e\xe5\x98\xb5\xa5\xd9\x68\xf3\x81\xf5\x1a\x7c\x23\xae\xdb\xb2\x1a\x2f\xd9\x26\xcf\xc3\x2b\x96\xbf\xb7\x7a\xe0\xe8\xf9\x0b\xe6\x8e\x98\x38\x83\x38\x5d\x5e\x9b\xbd\xd5\x2e\xcc\xef\x90\x3f\x9a\x30\x63\xe1\x1d\xf2\x4d\xf8\xc9\x59\x4b\x1b\x9b\xd4\xbc\x86\xcf\xd9\x75\xf4\x2c\xa1\x82\xf4\xf4\x76\x05\x74\x11\xae\xac\xcc\x1c\x8a\x04\xf8\xca\x5e\x21\xa3\xdd\x68\x07\xdd\xc1\xe8\x8d\xd1\x50\x53\x33\x0d\x35\x75\xe6\x45\x9b\x5c\x20\xf0\x3a\xdd\x0c\x41\xc9\x03\x20\x61\xd6\x55\x4a\x2c\xbd\x4b\x0d\xc8\x8e\xaa\x89\x00\x0e\x33\xc2\x1b\xd7\xbd\x36\xe7\x81\x5d\x2b\xf7\x2f\xed\x5c\x5f\xe8\xb4\x38\x9b\x66\xae\xd8\xb5\x72\xe2\xb5\x77\x5e\x39\x0f\xdf\x7d\xd9\xe1\xf9\x0f\xbe\x25\x7f\xb4\xab\xfd\xc1\x15\x57\xdd\xdc\x36\xb8\xff\x30\xad\x7e\x06\xa7\xd5\x5e\x3a\xb8\x69\xc4\x5d\xdb\x97\x75\xec\x71\x88\x25\xbb\x47\x5e\x3b\xe1\x4f\x27\xe4\xb3\xf2\xeb\x4a\x2c\x1f\xf7\x01\xf7\x22\xaa\x24\xd1\x9a\xe6\x42\xa7\xaf\x44\x27\x8a\xbe\x42\xb6\x17\x53\x59\x59\x55\x4e\xf7\x65\x79\xd4\x07\xeb\x32\x36\xe9\x76\x07\xa3\x51\x23\xa9\x8a\x19\x35\x07\x6d\x63\x93\xc1\x0b\xc5\xf5\xb9\xcd\x54\xad\xcb\xcd\xd7\xcc\x31\xb3\x09\xc7\xbb\x50\x78\x5f\x36\x65\x83\xf2\x19\xee\x78\x6f\x57\xa0\xa6\x69\x84\x37\x78\xc1\x58\xbf\x76\x25\x16\xb0\xa3\x3d\x7a\xcd\xca\xd1\x03\xd9\x3f\x6e\x74\xac\xbc\xe9\xc9\x0b\x84\xfd\x29\x21\x81\xae\x6b\xae\xb6\x29\xfa\x34\xa1\xbf\x97\x29\xfd\x01\x1f\x22\x55\xe8\x78\x49\x42\x1a\x64\xb6\x48\x92\x51\x20\xf1\xa7\x9c\x3e\x5d\x6a\x2e\xd7\x91\x9f\x59\x35\x94\x77\x92\x90\xf1\xe7\x93\xe6\xbf\xaa\xa5\xc8\xbe\x7c\xfd\x52\x8d\xfc\x69\xb3\xbc\x72\xd4\xc1\x5b\x57\x6a\x70\x60\x14\xde\x35\x94\x3d\x7c\xfe\x80\xbb\x12\x3f\x22\x8f\x63\xe7\x82\x01\x38\x19\xff\x0c\xb1\x29\xa7\xdc\xcc\x88\xb0\x9f\x2d\x20\x61\x62\x68\x52\xa2\x92\x50\xba\xd1\x5f\x88\x0b\x8d\x6c\xa9\x55\xab\x2d\x29\x0e\x4e\x48\x16\x9b\x59\x8f\x81\xe4\x1e\x82\x8d\x64\x56\x02\xe4\x04\x30\xf3\x04\xff\x45\x62\x97\xba\xab\xd1\x7c\xba\x7f\x0b\x50\x50\x7f\xca\x29\xd5\x2a\x93\xb0\x14\xb9\x19\xe9\xd8\x72\xad\xb4\x3b\x78\xc7\x9a\x29\x1d\xbb\x97\x25\x7f\x4e\x72\xd3\xbb\x0e\x96\x17\x25\x26\xe8\xa6\x0e\x1b\xc1\xec\x4f\x6f\xf5\xd9\x6d\x5b\x77\x8c\x6f\x4a\x2e\x62\x4f\x7a\x2a\xcf\x55\x86\x63\xb3\xc7\x0d\xe4\x7f\x95\xdd\xe0\x38\xf5\x39\xf0\xd0\x69\xd4\xa7\x3a\x2a\x51\x22\xe8\xcd\x46\x8b\x81\xb7\x01\xee\x0d\x46\x3d\xe7\xd0\xda\xad\xbc\x85\xd5\xda\x24\x49\x2f\x68\xc1\xb8\xd3\x2a\x38\xf6\xe5\x1e\x6a\xa7\x4b\x45\x75\x53\x0f\x28\x92\x31\x95\x45\x18\xf4\xea\xb8\xad\xde\xc6\x4e\xfb\xec\x2a\x8d\xfc\xce\x7d\x72\x5b\xbb\x46\xfe\x9d\x66\x1c\x8e\x7e\x35\x53\xf3\xf9\x07\xfb\x06\xb2\x87\xcf\x7e\xe2\xae\x64\x6f\x95\x2f\xf3\x55\x56\xba\xb0\x87\xd1\xbb\x2a\xe5\xf0\xb5\xb8\x0d\xd6\x7f\x08\x6c\x5e\x72\x76\x64\xa4\x71\x56\x22\xcb\x8b\xbc\x49\x52\xfc\xba\x1c\x27\xea\x24\x11\x65\x5d\xbb\x34\x8b\x2c\xc7\x33\x0e\xc6\x9c\xda\xcc\x55\x21\xda\xef\x2f\xdf\x32\x66\x74\x53\xa2\xeb\x08\x71\x3e\x1f\xd3\xdc\x34\xc1\xf0\x92\x7c\x86\xfa\x6a\x3d\x94\x47\x0c\x91\x47\xf1\x43\xf9\xdd\xc0\xe7\x2a\x51\x6b\xa2\xac\xdc\x5e\xa4\xf7\xf9\x44\xbb\xd8\x8b\x09\x85\xaa\x0a\xe8\xbe\x2a\x40\xee\x18\x28\x83\x66\x53\xd8\x12\x26\xd5\x9f\xf5\x00\x87\xde\xf7\x23\x87\xfc\x79\x4e\x2b\x1a\x00\xd9\x27\xaf\xec\x9a\x12\xf4\x8c\x73\xeb\xad\xf1\x11\xd5\x73\x25\x9f\x27\x81\x1b\xcd\x66\x47\xa6\xce\x5a\x62\x99\xa8\xf8\xaf\xa6\x67\x2b\xac\x29\x1e\xac\xb3\x33\xdc\x55\x78\xf3\xe4\x91\xe9\xc2\x6a\xa6\xe8\x99\xf7\x6c\x67\xff\x95\x2d\xaa\x96\xa3\x23\x45\x88\x37\xa6\xa0\xb0\x50\x64\x83\xac\x8d\xe7\xb0\xc1\xe3\x29\xc6\x45\x61\x5e\xe0\x5b\x93\x05\x42\x40\xa3\x71\x0a\x82\xd2\x7a\x13\x94\x5f\x27\x2e\xbc\x98\xbe\xa4\xd4\x60\xef\xa1\x02\xa7\x15\x27\x52\x5f\xa6\x09\x5f\x40\x77\xa2\x59\xe0\xa2\xaa\x3f\x15\x7e\x20\xfd\xb6\xa2\x87\x0e\x55\xf8\x5b\xe9\xb7\x85\xa0\x47\xbd\xd8\xf6\x5d\x0f\x45\xea\xe5\xb6\x17\x7d\x94\x3f\xa4\x75\xa9\x42\x92\x85\x28\xfa\xf5\x92\xe4\xb6\x1b\xec\x7e\x27\x17\x61\x0a\x0b\x8b\x4c\x4e\xe2\x9e\xd3\xbb\x3c\x3a\x5d\xc8\xe5\xb2\x86\x42\x74\x11\x43\x58\x22\x69\x98\x49\x6b\x77\xc5\xca\xdd\x7d\x36\x3d\xd9\x21\xd5\xb1\x44\x0a\x3b\xd0\x36\x99\x5e\xfd\x05\x54\xad\x8a\x0f\x08\xe8\x3a\x75\x6e\x1f\x14\xf6\x54\xb9\xbe\x83\x09\xd4\x91\xb9\xbd\x94\x56\xba\x58\x9a\x7b\xf7\x09\xf5\x97\x97\xa2\x6a\xb4\x24\xd1\x3f\x22\xf9\x98\xea\x6a\x87\xb6\x94\x17\xcb\x10\x12\x4b\x25\xae\x77\x0d\x2e\xf7\x95\x03\x3b\x11\xb4\x3e\x89\x9e\x8d\x21\x5b\xb0\x35\x69\x33\xeb\xa2\x86\xe8\xf8\xa4\xc1\x59\x4d\x8b\x20\x6b\xbb\x9f\xf6\x67\x4b\x0d\x74\x77\xc7\x64\xe8\x33\x6d\x3d\x86\x7b\xa4\x1d\xb2\x62\xb7\xcc\x3d\x1a\x41\xc6\x7f\x92\x36\x25\x5b\xce\x7f\x1f\xe8\x9e\x7e\x38\xe9\x44\x6e\xfe\xde\x16\x6a\x9d\xb5\xb3\x87\x15\xfb\xf2\x9f\xb7\xe5\x65\x20\xca\xc1\xb9\xd9\xfc\x3d\x66\x3e\x09\x2a\xfb\x42\xc9\xb9\x6c\x16\x36\x02\x3e\x7a\xa3\x26\xb4\x35\xd1\xdc\x50\xdc\xdb\xef\x2f\x0f\x36\xd9\x19\xd0\xec\x18\x7d\x53\x31\x9f\x70\x22\x74\x09\x76\xf5\x06\x0d\x83\xb1\xdb\x83\xbd\xa5\xaa\xca\xb1\xc9\x2a\x54\x5a\xd7\x9a\x2c\x35\x87\x1a\x0b\x1b\xc7\x27\x0b\x9d\x41\x3f\x88\x3d\x87\xc6\x38\x8e\xf4\x2a\xce\x24\x2b\x74\x2b\x24\x99\x93\x77\x91\xaf\xb7\x66\x56\x5f\xb5\xdb\x22\x17\x09\xa6\xfb\x31\xa4\x09\x1b\xd3\x96\xdd\xbd\x17\xb0\xfc\x96\x74\xcb\x6b\xbc\x00\x0e\xd9\xc3\x19\x13\xb0\x47\xfc\xdd\x0f\xa0\x13\x21\x0e\xe8\x6a\xb9\xe0\x06\x3c\x6a\x51\x2f\xd4\x88\x06\xa3\x2b\x12\xc3\xfb\x38\x8b\x0b\x07\x0f\xf6\x9b\x1b\x75\x12\x1b\x1d\x10\x89\x44\x25\x63\xa3\x53\x18\x22\x96\x97\x37\x17\x0d\x2c\x1c\xd8\x9a\x2c\x01\xbe\x5a\x52\x62\x2e\x94\x42\x05\x63\x93\x21\xe4\xad\x21\x29\x5a\x96\x06\x5b\xc3\xf8\xa4\xcd\x39\x98\x2d\x36\x17\x83\xf0\xd5\x99\x73\x2d\xfb\x9e\xa4\xd6\x13\x9d\xb9\x04\x97\xb5\xe2\xa9\xad\x7f\x01\x14\xe6\x1a\xfd\xdd\xb3\x47\x15\x1a\xbc\x4c\x35\xf1\xe5\xdd\xd4\x11\x20\x1f\xe8\x89\x44\xa6\x4f\xd6\x23\x20\x9b\x2e\x40\x95\x69\x57\x80\xfc\x1f\xe2\x28\xe8\x8e\xcb\x8c\xc7\x20\x37\xc9\x34\x4d\xa4\x0c\xba\x14\x74\xb1\x31\xdc\x76\xe0\x3f\xb5\xa0\x1d\xf7\xae\x01\x23\xdc\xa8\x13\xab\x02\xa5\xc8\xed\x70\xa0\x80\xc8\xd5\xf5\x29\x0d\xb0\x36\x1b\x35\x49\x6c\x66\x7d\x8d\x19\x30\x69\x4a\x18\xcd\x12\x1b\x6b\x55\x62\x01\x89\xc0\xf0\x9e\xca\x63\x44\xf9\x8a\x71\xda\x31\x4f\x0e\x25\x95\x5a\x05\xd4\x1d\x1f\xee\x93\x3d\x5a\x56\x8e\xfb\x78\x40\x4e\x38\x73\xb0\x57\x1f\x21\x75\x18\x9f\x7f\x45\x5e\x94\x3d\x4e\xc0\xae\xe6\xa9\x4b\x6f\x2f\xce\x9e\xf6\x9d\xff\x63\x65\x04\xb7\xd2\xe3\xbd\xba\xc3\xb3\xad\xd8\x7e\xf3\x5e\x72\xca\xc0\x8c\x20\x2e\x7c\x4f\x24\x7b\xda\xf7\x6e\x65\xa5\x7a\xba\x37\xf7\x92\xae\x57\x2e\x23\xfb\xf3\x52\x79\x14\xb7\x1a\xe8\x4a\xc9\xf7\xec\x6b\x36\xc6\x8b\x2a\x2a\xc2\x05\xbe\xde\x8e\xe2\x62\x50\x48\x8d\x6c\x1f\xa6\xbc\xbc\xbe\x94\xf2\xdc\x52\x54\x10\x2f\x8a\xb7\x26\x23\x89\x70\x91\xe4\xae\x1a\x97\x74\x3b\xbb\x9f\x00\xf6\x40\x44\xbe\x6a\x14\xef\x2e\x49\xd9\xfc\x03\x37\x55\x35\x52\x4b\xe8\xd6\xe7\x1c\x05\xd9\x08\x22\xc6\x5f\xf0\xd0\xd0\x36\x79\x52\x16\x39\xef\x6a\x15\xc1\x7a\x43\x65\xa4\x31\x7e\xc5\x7b\x97\x59\xbb\x1f\x26\x2e\x2d\xcd\xe2\xa6\x37\xc8\xd6\x73\xb5\x95\x95\x66\xe6\xeb\xae\x0f\xdb\xa9\xfe\x00\xb4\xc0\x87\x81\x16\x1a\x40\x6b\xbd\x22\x31\x2c\x1a\x29\x2d\x0d\x05\xbc\xf6\xaa\x84\xa6\x9f\xc9\xa4\x11\xab\x7a\x7b\x05\x60\x01\x7d\x87\x55\xd9\x13\x1a\xfd\x80\xf1\x49\xbb\x46\xaf\x77\xd5\x35\x34\xd4\xd5\x81\x6c\xad\x33\x07\xa2\x91\x68\x6b\xb2\x30\x11\x8a\x48\xae\x8a\x71\x49\x97\xd3\x32\x78\x5c\xd2\x92\xe3\x49\xcf\x20\x27\x2b\x7d\x1b\x1a\xd4\xe3\x82\x0b\xed\x32\x35\xe1\x2a\x3f\x5d\x3e\x1a\x4b\x6b\x97\xd9\x62\xc3\xe9\x0c\x8c\x4c\x46\x8f\x5a\x3a\x42\xc9\xb9\xe7\x9e\x55\xb2\xe8\x07\x1f\x9c\xb2\x64\xcb\xe9\x43\x1d\x7b\xfb\x8c\xde\x38\x66\xc2\xb4\xbc\x13\xaa\xca\x48\xd9\x8c\xb0\x37\x9d\x57\x7f\xcd\xf8\xe4\xc8\x1b\xeb\x5c\x0b\x47\xaf\xde\xc4\x5c\x4b\x73\xeb\x03\x8d\x4d\xb3\x26\xaf\x3c\x50\xdb\xd2\x52\xdb\x31\x39\x8d\xc2\x36\x40\x5c\xac\xb2\xb2\x36\x76\xc9\xa5\xe9\x64\x7b\xb9\xb5\xac\xb6\x77\xe5\xa0\xe6\x31\xd4\x97\x0e\xfa\xd8\x03\xfc\x3d\x80\xcf\xcd\x89\x41\x15\x65\x65\xb5\x35\xb5\x5e\xaf\x4f\xaf\xa5\x47\xfe\x48\xeb\x63\x83\xfd\x6b\x0a\x0a\x22\xc1\x60\xbf\x5a\x67\xbd\x73\x7c\xb2\xde\x1c\x0a\xd4\x04\x80\xc6\x6a\xa4\x58\xaf\xd6\x64\x59\x59\x0c\x07\x7d\x3e\x87\x00\xf6\x8f\x56\x2b\x64\xe8\xac\x29\x93\xaf\x96\x1f\x9b\x9f\xf1\x44\x66\xf4\x58\x35\x5a\x1f\xdb\xbb\x9f\x43\xe7\xc4\x36\x12\x43\x02\x10\x99\x5f\x10\x42\x0d\x77\xe4\x1f\xf0\x2c\xce\x0b\xcd\x5c\x9b\x0e\x76\xbc\x49\x7e\xe4\x8f\x07\xff\x78\x8f\xe6\x41\x43\x36\x20\x64\xc0\xd0\x82\x00\xfe\x87\x12\x01\xc9\xfc\x5b\x49\x97\x48\x47\xaa\x5e\xe3\x57\xc3\x1f\xa7\x9c\xfd\x9a\x37\xf4\x8e\x0d\x52\xe2\x46\xe6\xdf\x7d\xdb\xf3\x8b\x16\x91\x38\xdd\xc5\xc0\x87\x06\xc0\x5e\x2c\x21\xdd\x29\xf4\x42\xc4\x69\x46\x05\x3e\x1f\x72\x0a\x5c\x69\x99\x39\xc2\x7a\xd4\xac\x11\xb3\x56\x04\x35\x1e\x09\x0e\xd6\x94\xe5\x3e\x79\xfd\x35\xbb\x87\x71\xd0\x08\x02\x25\x56\x9c\x4c\x3e\x37\x6a\x20\x8f\xf7\x70\xd6\xe7\x5f\xd9\xb2\x4e\x3e\x4d\xc3\xc5\x5f\xf7\xcd\x3b\x99\x09\x19\xc8\xe1\x36\x84\xbd\xd8\x49\xb4\xf8\xb9\xeb\xaf\x9a\x9e\x0d\x16\xc8\x72\x19\xba\x8f\x16\x83\x4e\xf7\x05\xcc\xc5\x84\x1c\xa4\xaf\x9b\xc4\xb3\xc8\x21\x72\x26\x13\x32\xf0\x9c\xcb\xe9\x10\xc9\x49\xa6\xc1\x60\x72\x08\x66\xce\xdc\x9a\xe4\x24\x1a\x69\x9b\x57\x1c\x3a\x5e\x75\xa1\xfc\x81\xb4\x48\x51\xd4\x1c\x55\x84\xe0\x4b\x95\xf8\xf6\xfa\xac\x36\x73\x8e\x39\x48\x24\x43\xdf\xe9\x4a\x5c\xbb\xaa\xb3\xb0\xd3\x6c\xe6\x9f\x74\x7d\x09\xf0\xb5\xa5\xfe\xce\x0d\xa5\x75\x66\xab\xd0\x8d\x89\x91\x1a\x9e\x0f\x05\x38\x56\xab\xf5\xfb\xc2\x7a\x1d\xc3\x44\x0a\xbd\x18\xac\x3f\x8f\xbb\xa8\xb4\xc8\x1b\x0e\xf0\xd5\x95\x92\xc3\x01\x74\xde\x3b\x5c\x54\xe4\xf1\x16\x16\xfa\x83\x7e\x0f\xa3\xd3\x71\x56\x5e\xf4\xc0\x7f\xb8\x2c\x10\x64\x39\xa7\xd6\x60\xc0\x24\xca\xc3\x12\x07\xfa\x8c\x5b\x95\x1e\xd7\xd4\xbd\x4c\xe9\xb0\x2a\x9e\x39\x13\xcc\xd2\x69\x1e\x63\xcc\x3d\x2e\xe2\x23\x7a\x1c\x21\x66\x97\x8f\x14\x26\x26\x1d\x52\x68\xd1\x1e\x31\x76\x91\xdf\x99\x7d\x15\x6d\xbf\xa9\x5a\xd5\x2c\xdc\x9f\x7c\x2f\x3e\xe1\x8a\x58\x25\xbf\xdd\xda\xb0\xfe\x02\xbf\x39\xf0\x7d\xf2\x34\x66\xaa\xa5\x40\x2e\xc4\x37\xc9\x73\xb0\x38\xbe\x57\x95\xb1\x40\xf2\x55\xcd\xe9\xba\xe8\xbf\xd0\x98\x80\x2e\x50\x44\x0a\x01\x67\x06\xe4\x21\x6b\xea\xd0\x68\xdc\x7a\xbd\xc1\x25\x31\x8c\xc7\x60\xf0\xb9\xbc\xb6\x2a\x77\x93\x9b\x71\xbb\x4d\x2e\x07\x0e\xe9\xaa\x75\x80\x20\x41\x4f\x2a\x3c\xc6\xab\xa6\xc7\x95\x57\xd5\xbe\x48\xef\x4b\x55\x16\xd4\x93\xea\xa6\x4a\xf1\x5a\x36\xef\xcb\x6f\x86\x70\xc1\x43\xb3\xad\x6f\x75\x8c\x19\x3c\x82\x6d\xf8\x7c\x08\x1b\x3c\xd4\x69\x3d\xd5\x31\x9a\x7c\x63\x0f\x7c\x22\x1a\xed\x9f\xe0\xfb\xce\xbe\xac\x7e\x20\xb6\xf0\x7f\x40\x9e\x21\x1a\xe3\x3d\x21\x51\x16\x08\x87\x2d\x06\x81\x8b\xc5\x00\xe4\x52\x87\xcb\x55\x12\x93\x68\x23\x2a\xa2\x07\x09\x11\x6d\x84\xc4\x2f\xf4\xb4\x86\x55\x3f\x63\x37\xeb\x2f\xc7\x24\x4e\x1b\x7e\x4d\x3d\xa2\x2f\xd4\x7a\x05\x36\x0e\x7d\x4a\xb2\xe0\x66\x4b\x63\x4f\x5c\x3a\x7b\x8e\x3b\x96\x13\x84\x11\x2e\xed\x1c\xf9\x70\xdf\x65\x8a\xbd\xcc\x54\x8c\x9a\xb7\x6a\xe9\xbc\xd2\x9d\xbf\xcf\x1c\xbd\x37\x1f\xf9\x7d\xaf\xf9\x9b\xa7\x92\x8c\xb8\xf4\x7c\x5a\x60\x3e\x71\x34\x3d\x51\x15\x2a\x2a\xb2\x4b\xda\xb2\xb2\x5e\xe5\x52\xb9\x17\xa1\x3a\xb7\xd7\x5b\x5b\x26\xa5\xe3\x8c\xcc\x5a\xd5\x7e\x60\xab\x89\xb4\x66\x7d\x79\xf1\x46\x79\xd3\xb2\xe4\x36\x69\x52\xa8\x4d\x0d\x13\xe8\xf3\xe3\x93\xcb\x1c\x4e\x71\x2d\x91\x89\x4d\xab\x37\x45\x1d\x17\x9d\xe5\xfd\x8f\xd2\xdf\x3e\x7c\xdd\xba\x6d\x6b\xe5\x17\xd3\x2f\x3a\xd7\xf3\x7e\xfa\x1b\xf0\xc0\x0d\x4c\x0d\xb3\x9d\xbf\x0a\x28\x6c\x50\xc2\x2e\xb0\x6e\xb7\x47\xb2\x5a\x0d\x3a\x8f\xce\x6b\x34\xfa\x0c\x92\xe4\x79\x02\x0f\x7c\x4c\xb0\xdb\x35\x4f\xe1\x46\xc4\xe0\x0a\x72\xfc\x0b\xdb\x4d\xdd\x57\xb9\x41\xec\x0a\xb7\x00\x60\x49\x41\x74\x07\x89\x97\x55\xf3\x10\x08\xcb\xc7\xda\x61\xfc\xe1\x5a\xc6\x36\x7b\xc9\x06\xbe\x69\x0c\x77\x6c\x80\xa9\xb1\x7c\x5e\xd1\xe0\x59\xfc\x74\xc9\x27\xff\xc6\xd8\x71\xf9\xd6\x5e\xf2\x0d\x26\x1f\x9e\x3e\xca\xdd\x38\xac\x9f\xbc\x93\xda\xa9\x0a\x6c\x37\x80\x9e\x38\x32\xe1\xf2\xe9\x74\x7a\xbb\x05\x73\x5c\x38\x18\xb4\xe8\xd9\x08\x58\xaa\x3e\x41\x08\x3c\x81\x1b\x8f\x3a\xad\xd2\x13\xb8\xf2\xb1\x30\xc6\x7a\x80\x56\xe1\x07\xf1\x2c\x8c\x79\xe2\x89\x90\x7f\x16\xac\xfc\x50\xc3\x0c\xe4\xcc\xe6\x0c\x80\x0b\x5d\x1b\xa6\xf4\x8e\x38\x03\x26\x9b\xbf\xb4\xcc\xe4\x32\x2b\x13\x60\x6a\xf0\xf4\xa9\x5a\x0a\x29\xd3\xbe\x6d\x87\x7e\xe3\x08\xc3\xa8\x09\xdb\x5b\x95\x59\xd0\xbd\x7b\x12\x57\xe0\x2b\xf8\x19\xc8\x8c\xfc\xa8\x3e\x61\x92\x74\x3a\x17\x63\xb1\x14\xf0\x0c\x13\xb0\x7b\x9f\xc6\xd5\x48\x8f\x8c\xb8\xff\x51\x91\x45\x4f\xe0\x01\xa8\xa9\xa6\x86\x14\x18\xcb\xa3\x15\xe5\x34\x2c\xdb\x38\x00\x30\x9b\x9b\x96\x57\x5e\x5b\x61\x0b\x68\x2d\x9e\x58\x85\x79\xce\x04\xfe\x89\x79\xe5\x27\xa2\x3e\x6f\x2c\xe6\xf5\x45\x71\x85\x75\xf9\x20\xcb\xf0\xc9\x4c\x42\xf2\x75\x1d\xfb\x82\xfd\x37\xfd\x39\x16\xa3\x38\xdd\x06\x38\xad\xe6\x56\x23\x0b\xaa\x4d\x18\xb2\xb1\xab\x7a\xe3\x53\xb8\x3f\xd2\xe1\x81\x8f\x4b\x3c\x4f\x60\x6a\x24\x30\x51\xbe\xfa\x03\xa1\xab\x71\x12\xba\x8a\x82\x16\x9f\xc7\x55\x35\xaf\xec\x92\x59\xd3\x86\xf1\x07\x6d\xd5\xcb\x40\xc1\xbd\x61\xd4\xf0\x46\xf9\xa7\x8c\x4e\xf2\x6d\x6d\x19\x4a\x9e\x6b\x63\x22\xf8\x65\x6e\x0e\x3c\x37\x9e\x20\x51\xbd\x34\xa4\xd8\x66\x79\x02\xf7\x7f\xdc\x6c\x34\xea\x35\x4f\xe3\x26\xb8\x8a\xa3\xcb\xd7\x44\x96\x8b\x6e\x9c\x06\xb5\x8b\x0e\xe1\x03\x91\xbc\x78\x62\xfc\x32\x79\x98\xb5\x7a\x59\x3c\x60\xf5\x7a\xc9\xe3\x13\xdc\x9c\xae\x6f\xe9\xf3\xe8\xd3\xf1\x0a\x3a\x5f\x1b\xac\xc3\x17\xf0\xdc\x02\xd4\x3f\x01\x8a\xb3\x60\xb5\xda\xf4\xb6\xa0\xd7\xef\x0f\x59\xe1\xd9\x8f\x59\x4c\xa4\x8e\x40\xd3\x51\x9f\x3b\xbb\x0e\xf1\x78\x53\x7e\xba\x89\x7a\x6c\xdc\xa7\xfe\x62\xa1\xc4\x78\xfb\xa0\xb1\x1a\x6f\xf5\x62\x05\x96\x5e\xf3\xca\x06\xcd\x9a\x6f\xa8\x2d\x70\xf9\x02\x8e\x38\xae\x18\xde\x6a\x6e\xbc\xa5\x79\x30\x40\xd5\x32\x00\xaf\xe8\xfa\x79\x73\x78\x9c\x65\xd0\x3a\xbd\x12\xeb\xb3\x15\xd6\xe3\x30\xc0\x47\xe2\x33\x27\x24\x8a\x7b\xc4\x67\xda\xcc\x66\x9d\x51\xa3\xd1\x21\x9f\xc9\xef\x33\x99\x7c\x7e\x56\xd4\x91\xa5\x12\x09\xa6\x9a\x80\xb6\xab\xaa\xaa\x32\x81\xd7\x96\x9e\x75\xa0\xb0\x5a\xc6\xdb\xa6\xd4\xd8\xab\xcf\x89\xcb\x14\xf1\xd3\xe5\xfd\xb7\xad\xff\xd9\xb4\xe1\x3c\x66\xf8\x49\x45\xc3\x9e\xde\x2b\x0c\x92\x8f\x0e\x9b\xd2\xaf\xb1\xb2\x84\x9d\xad\x19\xd4\x6b\xea\x0c\xb2\x82\x3e\xf3\xeb\xff\xf6\x19\xe5\xa2\xc1\x2d\xd1\xea\x3f\xd2\xde\xe4\x4c\x94\xdd\x0a\x30\x93\x78\x0d\xbf\x86\x07\x31\x0e\x22\x9c\x88\x6f\x46\xcb\x73\x1e\xc9\xe9\xf4\x12\x51\x6d\xe3\x45\xb2\xba\x06\xad\x16\x73\x80\x62\xa4\xac\x6a\x3c\x6e\xcd\x3b\xe7\xca\x65\xf6\x39\x82\x16\x36\x66\x2c\x5d\x36\x4f\x64\x96\x95\x8c\x78\xbe\x6c\xce\x40\xfe\x86\xb1\x4f\x56\x0e\x1f\xdd\xca\x79\x4d\xfc\x0a\x73\x0d\x13\xc5\x2b\xe5\xdd\x8c\x13\x38\xc8\x14\x3c\x4f\xbe\x71\xff\x9d\x51\x97\x97\xf3\x99\x9d\xd1\x76\x85\x97\xff\x16\x97\x32\x33\x39\x12\xaf\xd1\x94\x70\xe1\x02\x89\x09\x14\x04\x1c\xbc\xc1\x10\x06\x33\x33\xc4\x48\x52\xc0\xeb\xb4\x3d\x8d\x7b\x81\x8d\x8f\x00\xa3\x4d\x64\xe9\x1b\xb2\x87\x99\xd9\x14\x1d\xd8\x89\x71\x5b\x7d\xb6\x8e\x1f\x68\xb6\xd9\x1a\x7e\x4d\x98\x8d\x75\xdc\x32\x79\x77\xd4\x63\xe2\x00\xa8\x7f\x0c\x1f\x3d\xaa\x57\x75\x99\xcb\xa7\x35\x87\xc7\x5d\xea\x5b\x3c\x84\x9b\x23\x0f\xff\xaa\xb9\x8a\x40\x66\xf4\x54\x4c\x91\x97\xad\x9f\x5e\xa9\x5f\xdf\x60\xba\xa7\x37\xc3\x4a\x4a\xbf\x9c\x6f\xd8\x69\xf8\x17\xb4\x26\xbf\x8e\x7c\xc7\x3c\x3b\x8d\x9d\x45\xbf\xf3\xf4\x7b\x2f\x76\x08\x33\x9f\x1f\x6f\x15\xc4\x3f\xd1\xef\xbd\xe1\xfb\x22\xfa\xfd\xcf\xf4\xfb\x40\xf8\x7e\x19\xfd\xfe\x17\x32\x6f\xbc\x9c\xab\x63\x1a\xf9\x93\xc8\x88\xbc\x09\x1d\x12\x75\xac\xc8\x4a\x26\x4e\x87\xaa\xde\xce\x71\xf3\x12\x6b\xa5\x4e\xb1\x6f\xea\x6a\xfa\xe0\xcf\x5b\xe2\x6d\x6b\xd7\xb6\x55\x8f\xe4\x51\xbc\xa5\x75\x6d\x5b\xdb\xda\x56\xb2\x6f\x71\x07\x8c\x55\x96\x1e\x0b\x94\x0b\x91\x15\x25\x93\x8e\xeb\x36\x16\x98\x42\x0e\x85\x31\x39\x0a\x05\xfc\xc8\x88\xde\x64\xac\x78\x0b\x8f\x6a\x87\x29\x63\xb5\xd0\xfc\x29\xa0\xf5\x65\xfc\x01\xe4\x45\x7d\x13\x0e\xa3\xe4\x61\x25\xd6\xa7\x71\x38\xfc\x1e\xd6\xcd\xb1\x1c\x96\xf4\xd6\xa7\x70\x25\x3c\x93\x50\x76\x3c\x9e\x97\xba\x9f\x79\x52\xba\xdc\x79\xbe\x6f\x94\xa4\x67\xe0\x67\xe4\xdd\xc2\xe5\xf5\x15\xed\x2b\x06\x36\x8c\x6d\x2c\x88\x59\xa7\x2e\xe9\x5c\x75\xed\x92\x9a\xcd\x4c\x4d\xc8\x8c\xfb\x0b\xc6\xfb\x37\x8d\x18\x59\x3e\xf3\xe6\x92\x15\xb3\x2f\x3f\x62\x95\x3f\x31\x53\xfe\xb0\x13\x60\xba\x1e\x60\xf2\x10\x98\xc8\xb9\xb2\xdd\xec\x65\x3c\x1e\x9f\xde\x6c\xd1\x99\x75\x26\x0e\xb9\x08\x4c\xa6\x1f\x84\x29\xad\xd2\xe7\x1d\x24\xd3\x10\xe1\xb5\x31\xae\x7a\xcc\xd8\xc5\x1b\xcb\xea\x37\x0b\x04\xba\x9a\x11\xad\x0f\x6e\x5f\xda\xc6\xfd\x76\x56\xd9\xbd\x2b\x6f\xb5\x0a\xf2\xab\xe6\x10\x00\xe7\xb3\xac\x98\x78\xed\x93\x51\x42\x0b\x87\xd0\xf3\xdc\x0c\xee\x56\xb3\x80\x82\xcf\xf3\xb0\xb6\xf5\xe8\x29\xee\x4b\x6e\x3f\x7c\x0f\x8f\x25\xf0\xbe\x8f\x4e\x72\x47\xb8\x9d\x48\x40\x05\x09\x03\x20\x0d\x71\x48\xd4\x30\x02\x7c\xa8\x8a\x9f\xaa\xc9\x59\x93\xe2\x88\x16\x47\x70\x9c\x3b\x32\x57\x5e\x2f\xaf\x9f\x8b\xdf\xaf\x39\xc9\x96\x9e\xff\x35\xfb\xa4\x72\x46\xf4\x2b\x18\xe7\x68\x7a\x1c\x8e\x15\x10\x2c\xad\x86\x45\x3c\xd3\x7d\x1c\x3a\x0a\x6c\xe1\xa3\x72\x79\x8d\x5c\x3e\x17\x5f\x85\xaf\xe2\x76\x9e\x1f\xc6\x3e\x09\x63\x95\x2a\x63\x3d\xcc\xb5\x33\x32\xbf\x17\x69\x50\x4d\x22\xc0\x32\xa2\xc8\x71\x60\x6a\xea\x18\x71\x77\x52\xc3\xec\x9b\x2a\x48\x9a\xa0\xe6\x11\xcd\x3b\x1a\x4e\x83\x40\x25\x2d\xa7\x29\xc1\x6a\x0f\x1f\x12\x7e\x08\x9b\x0b\x64\x0a\xff\x30\xff\xf7\xf7\xaf\xe5\xab\xde\x96\xff\xcd\xb5\x87\xb1\x45\xfe\x22\x7c\xe2\x84\x32\xfe\x13\x5c\x3b\xab\xa5\xe3\xd7\x25\x0a\x04\x9e\xb4\x28\x11\x45\x9d\x96\x01\xe0\x61\x74\xbc\x3b\x29\x09\x41\xe1\x11\xe1\x1d\x81\x13\xe0\x01\xe9\x7a\x95\x39\x8f\x70\x15\xc7\x41\x60\xb1\xf5\xff\x7a\x1b\x9b\x1a\xe1\x31\xbb\x78\x7e\xef\x89\x13\x61\xf9\x0b\x6c\x21\x4d\x22\x0a\xb8\xb1\x78\x17\x7f\x1d\xa9\x34\x7f\x1c\xbe\x72\x3c\x0b\xd8\x3c\xa5\x0c\x41\x96\xd7\x12\xc7\xbb\x96\x2c\x81\x8b\x06\x29\xf0\xdc\xc1\x5d\xcd\x16\x73\xdf\x92\x93\xde\x44\x0d\x43\x0a\xfb\x23\xfc\xd3\xa4\x04\x7c\xe6\x4e\xc4\x56\xa1\xb1\xa8\x03\x6d\x45\xcf\xa3\x2f\x90\x20\xc1\x07\x06\x25\xea\x1b\x5b\x50\xc2\xea\x86\x17\xbd\x09\x76\x02\x69\x6a\x39\x7d\xf9\x8a\xf2\xf4\x13\x48\x45\xc7\x3b\x6c\xcc\x2a\x1b\x77\xf5\x62\xa2\x93\x2d\x05\x7c\x0e\xe0\xf7\xc0\xee\x7f\x37\xb1\xb2\x43\xc4\x23\x45\xfc\x90\x78\x52\x64\xc4\xc4\xfa\x4d\x2d\x77\x8a\x58\x4c\x2c\x5c\xd6\x22\x89\x78\x81\x4f\x1c\x29\x2e\x14\xaf\x15\x6f\x15\xc9\xbf\x7f\x28\x6a\x24\x72\xf1\x54\x71\x23\xfc\xf6\x90\xf8\xb4\x28\xe8\x45\x9f\x7a\xc1\x49\x51\xe8\xf7\xa1\xf8\x77\x32\x48\xcb\xa8\x96\xbd\xe2\x5d\x22\xb3\x4a\xdc\x29\x32\x33\x44\xdc\x26\xe2\x6a\x31\x21\x32\x76\xb1\x48\x64\x40\xb0\x88\x4f\xa4\x5e\x48\x58\x0a\x4b\x5a\x96\x89\xdb\x44\xa6\x4d\xec\x14\x99\x84\xfa\xab\xc7\xed\x6b\xf9\x50\xc4\xaf\x88\xf8\x51\x11\x33\xdb\xc8\x28\x41\x71\xab\xc8\xb0\x30\xa9\x53\x78\xfa\xf4\x8e\xe9\xd3\xa7\x97\x2f\x5f\xbe\xbc\x7c\x85\xf2\xa7\x7c\x45\x3b\x4c\x14\x5e\xca\xe1\xbf\xe5\xcb\x95\xd5\x16\xf1\x52\xfe\xeb\xf7\x05\x79\x29\x59\x67\x73\xb1\xfc\x35\xc1\xe9\x9d\x30\x67\x13\x9d\xf3\x17\x89\xfb\xc5\x6d\x9b\xb7\xb5\x18\x45\xdc\x25\xe2\xbf\x82\x94\xa2\x73\x63\x7f\x2e\x62\x32\x11\x66\xb3\x88\xa7\xc2\xa4\x98\xd1\x22\xee\x2f\xe2\x52\x11\x93\x49\x32\x8b\xce\x89\xf8\x1f\x22\xc6\xe4\x52\x46\xdc\xd6\x3e\xb7\x85\xfe\x7c\x46\xfc\x42\x4c\x89\x2c\x41\xc6\x49\x60\x5d\xdb\xc6\x4d\x6c\x01\x6c\x56\x89\x4d\x04\x11\x23\x46\xb7\xbc\x23\x9e\x21\x9f\x06\x0e\x6d\x09\x92\x81\x70\xe3\xd3\x04\xbd\xf5\xfd\x5a\x56\x89\xfb\xc4\xfb\x44\x16\xd0\x53\x2b\x0e\x11\xdb\x40\x4f\x13\xcd\x22\x43\xd0\xd3\x2a\x7e\x24\x7e\x09\x63\x91\xbe\x67\x81\x92\x16\x8a\x17\x9d\xc5\x0e\x0b\x12\xcc\x20\x82\xac\x6f\x47\x1a\x01\x64\xf2\x80\x92\xe5\xb0\xe2\x2b\x3a\x08\x32\xb2\x7f\x96\x97\x93\x0d\x56\x0f\x1b\x00\xff\x42\x3e\x25\x9c\xbc\x83\xe7\xda\xb1\xa1\x58\xfe\x32\x4c\x78\x6f\x81\xdc\x8c\x77\xa5\xae\x4a\xd3\x25\xcf\x61\xf6\x02\x74\x09\x17\xa9\x74\x69\x91\xbf\x62\x6e\x4e\xcd\x80\xeb\x2d\xc7\x10\x03\x54\x49\x36\x33\xdd\xca\x0a\x8d\x59\x08\x8d\xc9\x5f\x51\x1a\xbb\x9d\xe4\xf1\xa7\x36\x03\xbe\x6d\xc7\x39\x8c\x05\x11\xe5\x8e\xad\xc2\xf4\xae\x02\x93\x3c\x2a\x03\x13\x5a\x02\xf7\x35\xaa\xf7\xc1\x64\xbb\xdd\xa7\x2c\xef\x12\x65\x79\xe5\x51\xe9\xe5\x05\x40\xe6\xc2\xcd\x9f\xb0\x87\xe1\x3e\x3d\x72\x82\x54\x12\x58\x91\x33\x18\x45\x12\xab\xac\x84\x6d\xd0\x20\xea\x58\x1d\xa9\x8d\x0f\x82\x15\x7f\xd2\xd6\xa7\xed\x0f\x77\xfd\x01\x5e\xd9\xab\x0e\x1f\x2e\x3e\xdf\x56\x7c\xf8\x30\xc1\x89\xc8\x7c\xa8\x8e\x63\x3d\x8e\x58\x30\x36\xc8\x08\x19\x94\xd0\x11\x94\x7b\xe9\x6d\x0a\x5e\xfe\x85\x92\xf8\x19\xfc\x85\x22\xc3\x74\x54\x86\x99\xa4\x1f\x91\x87\x8b\xd2\xf2\x10\x17\xe5\xca\xc3\xfc\xb1\x90\xa8\x07\xd9\x0a\xca\xfd\x0f\xcb\xc3\x4b\xd2\xf2\x10\x17\xe5\xc9\xc3\xc7\xd1\xc3\xf8\x5b\x50\x9c\x44\x14\x4a\x18\x05\x58\x5c\x8c\x34\x5a\x81\x61\x78\x60\x3f\x6f\x51\x3b\x20\xcb\xcd\xc3\x75\xf1\xba\x38\x68\x93\xdf\xca\xcf\x2d\xed\x5c\xfa\xf0\x92\x4f\x3e\x51\xe6\x96\x37\x06\x03\xaa\x3b\x0f\x63\x60\x9e\x07\x82\xad\x7a\xab\x26\x6f\x0c\x1c\x71\x44\xea\x22\x75\x61\xfc\x2d\x8c\x80\x07\xe1\x1b\x3e\xf9\x64\x89\x3a\xc6\x51\xfc\x2d\x96\x61\x65\x4a\x12\x16\x1d\x3c\x5f\x64\xc9\x38\x06\x23\x8c\xa3\x03\x96\x1a\xcf\x85\x25\x6f\x2c\x15\x26\x18\x8f\x0c\x19\x5e\xba\x74\xc9\xd2\xa5\x2a\x2d\xe2\x49\xcc\xcd\xf8\xe5\x0c\x2d\x62\xd8\x18\x35\xdd\x69\x11\x4f\xa2\xb4\x78\x86\xeb\x60\xc3\xfc\x5a\x64\x42\xbd\x13\x7e\x56\x32\xeb\x25\x2e\xc8\x31\x5a\x96\x43\x09\xa4\xd9\x43\x19\xeb\x23\xe8\x1d\x90\x74\x84\xbb\x23\xaf\xdb\x7c\xaa\xa3\x7d\x3a\x1d\x4c\xd1\xcc\x95\x74\xe3\x3e\xf5\x71\x13\xc6\xef\xad\xda\xc2\x8d\xe0\x66\xb7\x4d\xda\xec\x1d\xe1\x7b\x84\xeb\x58\xb3\xa0\xef\x25\x23\x46\x26\x2e\xdf\x0f\xb4\xb3\x90\x5b\xc9\x0c\xe1\x47\xc1\x3c\x87\x25\xe2\x48\x10\x0c\x46\x56\xbb\x37\xf9\x08\xfb\x0e\x9b\x62\x59\x36\xd1\x6f\x50\x4b\x82\x6d\x65\x97\xb1\x6c\x10\x04\x00\x5b\xcd\xee\x65\x5f\x60\x39\x09\xfe\x91\x61\x13\x7a\x4b\x0b\x60\x94\xb0\x6d\xd8\xc5\x19\xce\x9d\x1b\x5c\xc0\x0c\x49\x07\x10\x70\x99\x2a\x28\x0c\x36\x72\x35\xcc\xbd\xfc\x1b\xf0\x4c\x17\x58\x5c\x61\xc1\xed\xd1\x4a\xd7\x25\xb5\xa4\xa7\xa3\x96\x65\x1d\xd7\x25\xdf\x65\xb1\x04\x0f\x6c\x62\x3b\xd8\xad\x2c\xac\x5f\x15\xf0\x0b\x5a\x86\xbf\x5c\x9d\x60\xce\x23\xc4\x74\xe4\x0c\x69\xe0\x77\x2f\x21\x24\x85\x98\xe2\xf1\x96\x11\xbd\xab\x47\x72\x5d\xca\x0f\x84\xd4\x5a\xe2\xb5\xc3\x86\x12\x1b\x5a\x5e\x0c\xd4\x6a\xa6\xb9\x8a\x21\x2d\xe8\xe8\x3c\x6f\xb5\x69\x18\xe9\x86\x64\x88\x59\xc6\x3c\xca\xbc\xc0\xbc\xcb\xf0\xd5\xcc\x36\x78\x63\x81\x5d\x00\x47\x42\x34\x07\xb8\x21\x6d\xd2\xa7\xdd\x14\x71\xb5\x40\x5c\x3d\xfe\xa2\x75\xc6\xb4\xf9\x43\x06\x2e\x2e\xab\x1e\xd8\xd0\xab\x5c\xbe\xa3\xf7\x65\x13\x9b\x36\xc6\xab\x56\x34\xf4\xe9\xaf\xd4\xe8\xd8\x08\xeb\x59\xc6\xcf\x06\xfb\x60\x58\xa2\xd4\xe1\x74\x82\x91\xe9\xf1\x3a\x8c\x46\x1e\x24\xb5\x31\x68\xac\x02\xb4\xb3\x46\x58\x5b\xeb\xee\xa4\x36\x6f\x71\x6b\x32\xab\x9b\x95\xe1\xaa\xfd\xd5\x8b\xa1\x05\x0d\x48\xdd\x95\x9a\x02\x46\x5d\x6d\xa6\xb1\x7a\x78\x53\xff\x70\xa8\x34\x60\xab\x0d\xad\x4e\x56\x8f\x68\xea\x1f\x2a\xeb\xeb\x82\xcf\x5c\x47\x79\x5d\xb9\xab\xa4\xef\xd6\x95\xf0\x5e\x3d\x74\xf3\x2a\xc2\x83\x26\x80\x1e\x71\x29\x7f\x1f\xe1\x41\xf8\x6c\x22\xa5\x15\x04\xe0\x60\x46\x83\x46\xc3\x60\x46\xaf\xe1\xdd\xfc\x03\xfc\x1b\x3c\xa7\xe5\xd7\x1b\xf1\x02\x23\xbe\xd4\x88\x87\x1b\x71\x3f\x23\x2e\x37\x62\x8f\x11\xeb\x8c\xf8\x7b\x23\xfe\xcc\x88\x7f\x6b\xc4\xff\x63\xc4\x4f\x1a\xf1\xcf\x8c\xf8\x66\x23\xfe\x89\x11\xc3\xf5\xf3\x8d\x78\x0a\xbd\xbe\xc1\x88\x4b\x8d\xd8\x67\xc4\x1a\xf8\xf1\x3b\x23\xfe\x6b\xfe\x0d\x07\x8c\xf8\xea\xf4\x0d\x49\x7a\x43\x5f\x7a\x03\x3c\x40\x6b\xc4\xdf\xd1\x07\xfc\x86\x5e\xff\x84\x11\x3f\x90\xbe\x7e\x9d\x11\xcf\xa3\x0f\x68\x49\x3f\xc0\x4d\xaf\x3f\x9b\x06\xe8\x0d\x7a\xbd\x02\xcd\x3a\x7a\x19\x0c\x5b\x42\x2f\x03\x38\x1a\x32\xe3\xc2\x45\xf7\x1b\xf1\x8d\x46\x7c\xa5\x11\x27\x96\xae\x36\xe2\x59\x46\x8c\xc6\x1b\xf1\x20\x23\xae\x31\xe2\x42\x23\xb6\x1a\x31\x63\xc4\x5f\x1b\xf1\xc7\x46\xfc\x0b\x23\x7e\xc5\x88\x1f\x37\xe2\xfb\x8c\xf8\x7a\x23\xde\x66\xc4\xcb\x8c\x78\xa6\x11\xc3\xf5\x38\x61\xc4\xd5\x46\x1c\x32\x62\xb3\x11\x73\xf4\x86\x8f\x8c\xf8\xb4\x11\x3f\x4a\xaf\xde\x47\xaf\x66\xe0\xf2\x19\x46\xdc\x6a\xc4\x41\x23\x96\x8c\x98\x4a\xbc\x8e\xb4\xe4\x23\x7f\x3a\x96\x67\xff\x28\x0a\x43\xc7\x8a\xf4\x9f\x5c\x31\xa9\x5e\xde\xe3\xea\x15\x17\xb9\x3a\xe7\x06\x54\xd5\x3e\x3d\x7e\x4a\xe1\x16\x99\x84\x17\x22\xa4\xc2\xf4\x75\x82\xf0\xa7\x17\x04\xf9\x01\x6c\xa3\xef\x3f\x23\x1a\x49\x71\xb1\x7c\x46\x79\x25\x36\xe4\x3f\xf1\x31\x46\xc7\xd6\x21\x3b\x2a\x4b\xd8\x4c\x7a\xde\xc6\x83\xd0\x71\x0a\x0e\x51\x10\x78\xbd\xd5\x4c\xb8\x5a\x4d\x55\xbc\x21\xd7\xd5\x94\x8e\x32\x17\x69\xaf\x40\xa5\xa6\x2a\xbc\xe1\xd0\xc4\xe9\xe2\x55\x96\xb1\xe5\x6e\xcb\x24\xe7\xa5\xc9\xd1\x25\x1d\xf8\x58\xc7\x94\xe2\x48\x53\x32\xe6\xb4\x3b\x0d\x3b\x6b\xe6\xac\x2c\xf8\x39\xdd\x3f\x55\xcc\xef\x98\x33\xfc\x6e\xe0\x19\xd6\x63\x3a\x8e\x88\x49\x34\xa0\x2a\x23\x9a\x19\x51\x8b\x63\x20\xa0\xb5\x98\x39\x23\xff\x0b\x4b\x2d\xf2\x97\xf2\x97\x2d\xd8\x2c\x7f\x39\x1c\x4b\xd8\xcc\x0f\x91\xff\x45\xbe\x9b\xe4\x7f\xb5\x60\x0b\x96\x86\xcb\x5f\x62\x49\xf1\x35\xcc\xc6\x25\xcc\xbb\x60\x0f\x93\x9a\x6a\x53\x12\x31\x93\xd6\xcb\xbb\x35\x12\x72\x32\x66\x87\x83\x41\x1a\x5e\x2b\xf8\x6d\xb6\x80\xc6\x8d\x24\x87\xd9\x6c\x32\x49\x6e\x96\xb3\x6a\xf5\x4f\x83\x6d\xec\x43\x1c\xd8\xc9\xd4\x33\x93\x1b\xd3\xdc\xbd\x38\x5c\xa6\xac\x5a\xb6\x3a\x1c\xc9\x0c\x20\x3e\x87\x5a\x5a\x1c\x6e\x6d\xf9\xc7\x85\xb6\xfa\xf8\xb6\x3e\x3c\x16\xb8\xe9\x53\xfe\x36\x99\x7f\x8f\xef\x2b\x3f\x64\x1b\xa4\xd3\x33\xab\x5f\x9e\xef\x15\xad\x4d\x4b\x26\x30\x0c\xf1\x39\xc8\x5b\xf0\x0e\x78\x37\x76\x85\x5a\x47\x2d\xa8\xe1\x68\xed\x1f\xa6\x06\xcf\xe1\xaf\x02\x59\x57\x0c\xb2\x97\x65\x35\x9c\x28\x6a\x39\xe1\x69\x5c\x41\xc2\x2e\x55\xd7\x51\x4e\x26\x31\xc9\xfd\x20\x5e\xaa\xdf\xb4\x73\xaf\xee\x19\xc3\x3f\xc6\x4c\x93\x7c\x6c\xb9\xe4\xa3\x75\xc3\x98\x28\xfe\x9a\x5b\x8d\x22\xa8\x7f\xc2\x61\x40\x05\x56\x0d\x30\x46\xc4\x16\x79\x5d\xae\x62\x43\x01\xeb\x77\x3b\x88\x67\x51\x27\xb0\xaa\xeb\x42\x35\xfe\xba\xc7\x10\x2b\x95\x41\xe3\x17\x3e\xe5\x51\x0e\x79\xf0\x07\x2b\xd6\x4c\x9c\xe0\xf1\xe9\x4a\x07\xef\xac\x4f\x34\xf6\x9f\x3f\x63\x40\xa7\xd3\xaf\x8d\x35\x2e\xea\x33\xa8\xb1\x91\xf9\xcd\xd4\xc9\xc5\x3f\x19\x5f\xb1\xa8\xa8\xbe\x20\xd0\x52\x3d\x66\x8a\x63\x73\xa2\x70\x5a\xa8\xb6\x30\x38\x92\xd2\xc2\x10\xb0\x4f\x17\xc2\x9a\x45\xd0\xf0\x84\x0f\xd4\x26\x6d\xc8\x67\x32\x85\x04\xb6\xc8\x6f\x71\xbb\x8b\xc9\xb7\x90\x89\x73\xe8\x0c\xc4\x99\xe5\x0f\x06\xb9\x1c\x07\x68\xae\xb1\x1a\xcf\x2d\x84\x6a\xb3\x2b\xf9\x26\x4d\xb8\x0a\xf4\x3c\x57\x8e\x67\x43\x22\xed\x18\x23\x31\xd1\x84\x1f\xf0\x70\x4b\x75\xe3\xef\x9b\x9b\xe0\x6e\x9c\x3c\xb2\xd9\xad\xe7\x17\x18\xc6\x6f\x5f\x39\x94\x3f\x30\x7b\x4e\xd4\xcb\x74\x9a\x45\x9f\xc6\x5a\x30\xfa\xe6\x7f\x48\xbe\x5f\x0f\x1b\xec\xd3\x69\x39\x9f\xd6\x52\x34\x66\x9d\xfc\x9d\xd1\xf7\xe5\xcc\x68\xec\xff\x7b\xb6\x35\xc0\xb3\x1f\x36\xc1\x06\xfe\x21\xe0\xff\x81\x13\xa0\xe0\xf0\x82\xc8\x32\x4f\x60\xe6\x68\x92\x68\xed\x55\xaa\x50\x27\x79\x14\x96\x70\x5d\xd8\x82\xff\x2a\xff\x1c\xff\x99\xf7\x5e\x77\x76\x62\xce\xbd\x22\x8a\x26\x40\xdd\x43\x60\x81\x6a\xb4\xf4\xf6\xc7\x93\xc0\x11\xc8\x00\x0d\x99\x21\x2c\x99\x41\xe2\xca\x30\x13\xae\x63\xdf\xba\x0e\x8f\x81\x91\xd0\xff\xc1\x58\xcc\xbe\xeb\x98\x2b\xff\x8f\xc6\xc2\x63\x00\xb4\x6e\x63\xf1\xa0\x4b\x82\x75\x4d\x10\xc4\x21\x0c\x43\x1d\x49\x12\xa3\x35\xa3\x18\x90\xa8\x63\x3a\xc6\x7e\x18\xe0\x3a\xde\x4b\x6f\x87\xfb\x67\xc2\xfd\xc3\xd9\x65\x70\xbf\x3b\xa1\xe5\xa8\x75\x00\x3a\x05\x98\x07\xf1\xec\x7d\x70\x57\xd8\x31\x73\x3e\xde\xc2\x2e\x3b\xff\xfd\xfc\xfc\xfb\xa8\x0e\x0b\xe6\x3d\xa8\xc0\x1a\x2d\x3c\x9e\x03\x85\xe4\x54\x43\x55\xae\x22\x60\xb3\x44\xe8\x08\x27\xe7\xc3\x10\x78\x87\xbc\x99\x5d\x26\x6f\x9a\x0f\x7c\x7a\xbd\x3c\x02\xbf\x99\xda\x84\x34\x44\x2f\x67\xb1\x0e\x38\x03\x8c\x43\xd8\xf3\xa9\x1a\xf5\xa4\xa2\x77\xb5\x98\x76\x04\x8c\xc9\x38\x02\x76\x66\xfc\x00\x0c\x7a\x8f\xd3\xb3\x5b\x40\x3f\x04\x0b\x01\x46\xd1\x0b\x88\x63\x35\x8c\x16\x31\x3c\xa8\xf7\xf1\xb7\x6a\x94\x88\x4d\x45\x7d\xe5\xe1\xef\x7f\x88\x0a\xdb\x35\xc7\xce\xac\xb2\x73\x67\x16\x2f\x3e\xbd\x78\x71\x2a\x85\xde\x63\x87\xb0\x3f\xe3\xc7\x9b\x05\xf1\xb3\xbb\x94\x5c\xd3\x3d\xf8\x48\x6a\x27\xc0\xe5\x38\x01\x9c\x5b\x47\x18\x5f\xd6\xc5\x42\x09\xbc\x0e\xb6\x60\xdc\x81\xeb\x6f\xdc\x10\xbb\xfd\x8e\x98\xbc\xe7\x03\xdf\x0d\x37\xf8\xba\xdf\xcb\xc2\xbd\x60\x20\x08\x79\xf7\xc6\x44\x6a\x2c\x39\xf0\x35\x77\xdc\x1e\xdb\x70\xe3\x06\x79\x0f\xdc\xf9\xc1\x07\x24\x5f\x62\x05\x98\x85\x73\x53\x6f\xc3\xbd\xee\x84\x4e\xc3\xc1\x53\x59\x9d\x16\xb4\xac\xaa\xb7\xd4\x13\x5e\x72\x3b\xdc\xec\x10\xe1\xf6\x51\x1f\x90\x67\xca\xcd\x1b\x14\x10\x50\xf7\xfb\x39\x2c\xb2\x98\xd5\xea\xc8\xe3\xb3\xf7\xdb\xe0\xe1\x04\x78\xc7\x6e\x02\xf0\x07\x72\x73\x8c\x42\xa1\xc8\x9a\x30\xdc\x7f\x22\xf5\x21\xd5\x7b\x0b\x12\x06\xab\x60\x40\x02\x72\x7b\x1c\xac\xa4\x55\x90\x99\xb5\x4b\xf8\x8b\x68\xb8\xf8\x44\x0f\x0d\xf7\xcb\xee\x0a\x2e\xa5\x9f\xdd\xe8\x35\x7c\x1e\xff\x07\xe8\xce\x72\x0c\x73\x40\x74\x48\x35\x49\x49\xbb\x19\xc5\x92\x7d\x41\xb1\x64\x5f\x53\x0d\x59\x26\xf5\x3e\x7a\x8d\x79\x9e\xde\xa3\xa7\x1e\x30\x11\xeb\x40\xc3\x33\x68\xe8\x96\x51\x69\x46\xa5\x1a\x65\x88\xb0\x32\x90\x28\xbf\x2d\x9c\xde\xc7\xe3\x66\x18\xf0\xfd\x7d\xe9\x01\xd3\xf6\x31\x83\x74\xe8\x75\xd6\xc2\x18\xe9\xb8\xfe\x84\x81\x38\xd6\x0c\x5a\xad\x31\x6f\x5c\x9a\x06\x0f\xac\x2c\xa3\x85\xe8\xf2\xb5\x90\xd7\xf3\x94\x10\x9c\x1a\x27\x6f\x67\x50\xea\x2a\x05\x93\x0e\xad\x47\xeb\xb6\x68\x11\xb2\xf3\x06\x62\x9a\xc5\x41\x01\x51\x08\x3c\xad\x26\x0b\xdd\xb4\x64\x6c\xa5\x5a\x72\x79\x1f\x77\x6d\x68\xcd\x94\xac\x92\xbc\x4a\xde\x0e\xca\x71\x55\x8b\xaa\x23\x6f\x5a\x4d\xfc\x8f\xbf\xc6\xf7\x31\x93\xf8\xed\x66\x11\x05\xd0\x18\xfc\x22\xf5\x27\x07\xd8\x73\x4c\x07\x3f\x40\xdd\xd7\xf0\x0b\xa0\x18\xf3\xd4\xbe\x54\x56\x91\xf8\x65\x1d\x60\x11\xe2\x00\x1e\x74\x7a\x09\x3f\x60\xc9\xe9\x9e\xf7\x61\xc2\x9b\x04\x96\xd8\xb6\xa7\x72\xee\xa3\x16\x29\xd3\xb1\xe4\x34\x1e\xc4\x9e\x3b\xad\xd8\xa3\x23\x81\x76\x76\xc3\x7c\xe9\x7d\xb0\x87\xc1\xca\x67\xba\xdd\xe7\x02\xbb\xd3\x11\x1e\xb9\xe4\xb4\xfc\xdc\x7a\xb8\xab\xdb\x3d\xc4\x92\x86\x7b\x7a\xc0\x48\xec\x55\xbc\x5b\x7e\xee\xf4\x12\xb9\x59\x81\x31\xf5\xac\xdc\xcc\xdc\x99\x3a\x01\x3b\xde\x9f\xd0\x73\x82\x00\xf7\xe6\xb8\x41\x01\x8d\x16\x7a\x2f\x6b\x81\xc7\xd5\xc5\x2d\x83\x77\xe2\x0f\x76\xc2\xa3\x56\x7c\xf3\x8d\xfc\x53\xe5\xfe\x61\xcc\x9d\x30\x12\x0f\x7b\x94\x03\xca\x03\x93\x82\xa1\x90\xd2\x5b\xe9\x8d\xc0\xae\x06\xef\x64\xda\xe5\x61\xf8\x49\xf9\x95\xcd\x00\x9a\x5d\x9e\xcb\xec\x4f\xbd\x81\xb4\x28\x92\x00\x44\x0b\xa4\xb7\x1f\xcb\xe9\xf4\x48\x84\x79\x02\xc8\xb9\xf9\xac\x54\x8b\x81\x8d\x0a\xc2\xcf\x71\x5b\x2c\xb4\x67\x4f\x28\x86\xcf\xca\x7f\x59\x64\xbb\x3d\x76\xbb\x6d\x21\xed\xe1\x2b\xdb\xf9\x2f\x53\x3b\xc4\x30\x31\xfd\x8f\x50\xda\x87\xc7\x52\x6a\x7d\x52\xa1\x7a\xfe\xcb\x8c\xff\x46\x6e\xe6\xbf\x44\xb6\xfc\x6b\x31\xa5\x41\xf8\x17\xea\xb5\xe1\xbf\x54\xbd\x36\xb9\x7e\x5d\xf3\x71\x51\x02\x0e\x80\x28\xfb\x99\x5e\xf3\x63\x5e\x5b\xa0\x23\xd5\x06\x34\x0b\xcc\x1d\x14\xcf\x8b\xb9\xd5\xf8\x2b\xee\x63\xe0\xad\x9a\x23\xd4\x17\x00\x30\x02\x0f\xbd\xc1\xc6\xac\xb4\x71\xab\x17\x2f\x26\xb0\xb5\xf3\x0f\x31\xab\x04\x77\xee\x35\x18\xae\x91\xdb\x6d\x1c\x6b\xe3\x1f\xea\xe6\x2b\xb0\x25\xb4\x7a\x89\x0f\xf2\x0c\xaf\x21\xd7\xbe\x42\xc0\xfa\xef\xbd\x01\x28\xcf\x1f\xa0\x39\xa2\x65\x15\x5c\xfc\x88\x41\x4f\x79\xdb\x29\x6e\x01\xf3\x1d\x1f\xa7\xbc\xcd\xf0\x98\x43\x2b\xb1\x94\x5a\xf2\xef\xce\xe5\x6a\xcc\x77\x7d\xcb\xca\xfa\xf5\x2f\x2d\xeb\x2b\xdf\xd6\xb7\xac\xb4\x71\x60\xac\xac\x2f\xf7\x4e\x59\xff\x81\xb1\xf2\x86\x7e\x65\x65\xfd\x1b\x4b\xcb\xfa\xf5\xa3\xbc\x4c\x76\xf1\xff\x93\x7a\x43\x2c\x47\x56\x18\x99\xd5\x18\x25\xca\x2c\x01\x57\x4a\x01\x04\x72\x3e\x6d\x17\x44\x47\xa4\x6e\x20\x3e\x13\x2f\x6b\x19\x1a\xbc\x74\xc1\x3f\xc6\x4d\x5d\xd6\x5c\x2d\x6c\x0f\x16\xba\x67\x15\xdc\xd8\x7f\xa2\xbe\x66\x1d\x5b\x40\xe0\xcc\xf3\x3d\x18\x1e\x93\xb4\x0e\x56\x1d\xed\xff\x95\x4f\x21\xcf\x8e\x06\xca\xd0\x10\xca\x50\xb8\x5b\x9a\x32\xfe\x4b\xeb\x2a\xdf\xb7\x6f\x3e\xce\x48\xf0\x03\xce\xd2\xd8\x0f\xba\xed\xe1\xd2\x1a\x6e\x2c\xba\x8b\xfa\xed\x81\x96\x31\x5d\x3f\x1b\xa8\x07\x77\x65\x7d\xf5\x4c\xea\x79\xf8\x68\xa3\xd7\x88\x80\x03\x85\xff\xd0\xb5\x22\x57\x92\xbf\x95\x4b\x96\xfc\x45\xb9\x41\x7e\x8e\xde\xc4\xc8\xf7\x71\xed\x78\x39\xf5\x45\xeb\x09\x95\x69\x88\x7f\x86\xc9\x99\xa2\x36\x57\x20\xd4\xa9\x3e\xd2\x85\xf9\xfe\xdb\xf4\x8e\x23\x30\xfc\x91\xeb\x60\x22\x82\x1d\x68\xd6\x8b\x3c\x09\x9d\xd5\x0a\x26\x96\x9e\xd3\x50\xb2\x35\xbf\x52\x63\x7e\xcb\xd2\x50\x45\x4e\xfb\xf3\x68\x37\xf7\xac\xff\x17\x2b\x09\x19\x77\xb6\x4d\xdc\xe2\x1b\xe1\x3f\xe2\xca\x90\x65\xc7\xca\x45\x0d\x83\x86\x0f\x1f\xb4\xe3\x46\xdc\x92\xa1\x50\x2c\x7f\xc8\x75\xe0\x40\x7a\x8f\x68\x88\x87\x85\x41\x06\x60\x2c\x71\xba\x47\x6c\x35\x4e\x87\x18\xa1\x91\xc1\x44\x50\x54\xac\xde\x94\x33\x36\xbf\x76\xcd\x7c\x75\x48\x65\x7d\x16\x70\x33\xf0\x74\xfe\x1d\x64\x26\x38\x36\x01\x73\x82\x01\x6a\xfb\xd4\x3b\x80\x62\x0a\x18\x25\x38\x72\xc1\xca\x6d\x5b\xfc\x85\xfe\x3e\xb1\x78\x13\x77\x66\xd2\xaa\x68\x53\x34\xee\x70\x3a\x0b\x0b\xa3\x15\x83\x7b\x8e\x61\x62\xe9\x18\xa4\xa1\x6e\x1d\xd8\x1d\xbd\x18\x35\x33\x67\x7a\x76\x10\xbe\xb5\xc7\x20\x17\x83\x43\x49\x8c\x20\x1d\xd3\x1d\xbd\xf0\x82\x81\xb5\xb1\x3e\x30\xc6\x96\xed\x2b\xf8\xd6\xc6\xc1\x15\xd1\xc2\x42\xa7\xd3\x11\x8f\x36\xc5\xd4\xda\x59\x1f\xc3\x18\xef\xff\x08\x1c\xef\xff\x30\x1c\x29\x97\x3c\x0a\x5d\x49\xfd\xdf\x9a\x23\x48\xe1\x19\x36\x4a\x08\x23\x7a\xf8\xca\xe5\xcf\xe0\xda\xe3\xf9\xd7\xaa\xbc\xf6\xb3\x6e\x1e\x72\x2c\xff\x55\x6e\x46\x8d\x29\x62\xdb\x9a\x1e\x67\x39\x50\xb8\x14\xd5\x97\x6a\x59\xd4\xcf\xda\xb8\xe4\x93\x4f\x40\x6c\x2d\xed\x5c\x4a\xf9\x44\xee\xf5\x58\x00\xba\xce\x5e\xef\x00\xaa\x76\xc4\x1b\x3f\x59\xb2\xe4\x13\xf9\xf1\xa5\x78\xd0\x52\x72\xfd\x77\xdc\xcb\xf8\x03\x61\x13\xc0\xa2\x3b\xca\x10\x67\x1b\xe5\x57\x8a\xa1\x33\xa9\xeb\x1e\xe6\x63\xf8\xf7\xc6\xcd\x32\xc9\x09\x46\xa7\xd8\x07\x18\x0d\x7f\xfc\x87\xf0\xc4\x68\x0e\xde\xf8\x54\xac\x2a\x36\xb8\x4f\xc3\x28\xde\xb8\xe3\x44\xf9\xe8\xfe\x8b\xfd\xfe\x40\x79\x59\x9f\x86\x36\x8a\xa7\xb8\xdc\x9c\x92\x41\xff\x33\xc2\x18\xd4\xd5\x0e\xda\x77\x9e\x57\x7c\x73\xda\x29\xfe\x65\xae\x4f\x5c\xfe\x16\xe6\xd5\x37\x75\x33\x9d\x17\xd8\x01\xaa\x08\x27\xf3\x52\x3d\xe0\x7d\xa9\x03\x1c\xe4\x37\xf1\x80\x63\xf9\x73\xb8\xbe\x97\x7a\x3d\xe6\x79\x56\x54\x5c\xe7\xa4\x41\xbb\xe2\xed\xee\x45\x9d\xdd\xbf\x52\x7d\xdd\xea\xf8\xd7\xc1\xce\xa6\xd7\xa7\xdd\xdb\x0a\xde\xd2\x1e\xed\xbe\x8a\x43\x1b\xb0\xa7\x3a\xb4\xb1\xfc\xac\xfc\x15\x1e\x4c\xcf\x56\x60\x2d\x89\x76\xa0\xca\xa6\x67\x89\x00\x53\xce\x54\xe4\x43\xb0\xde\x2f\xa0\x7d\x48\x82\xb1\xf5\xa2\x48\xb0\xfc\x56\x0d\x91\x62\xf5\xdd\xea\x1c\xbd\x10\xce\x8b\x70\x2d\xdb\xf7\x74\x3a\x6a\xf5\x9f\x04\x77\x7f\x07\x22\xba\x01\xc6\xb1\xc2\x38\x66\xb3\x01\x91\x39\xd5\xd4\xa8\x2c\xa2\x96\xf6\x28\xcf\x84\x9e\xfc\x6e\xf5\x26\xa1\xe4\x50\x71\xb6\xf6\xe7\xb6\xad\xae\xc6\x6f\xdf\xca\xa9\x2d\x84\x53\x65\xf2\xcf\x11\x9b\xba\x92\xca\x39\x56\x4b\xe9\xd0\x95\xc3\x5d\xd8\x34\x3f\xf9\x34\xc3\x43\x18\xf9\x79\xf9\x7e\xf4\xb7\xd4\x92\xb4\xec\x60\x1d\x5a\x95\x6f\xba\x2e\x22\xe3\xfe\xd6\x53\xc4\x7d\xdb\x43\xc2\x31\x29\x3d\xe0\xff\x6e\xd5\x2e\x00\xd9\x99\x36\x07\xf2\xc7\xcd\x95\x49\x77\xff\x37\x46\x00\xc8\x02\xc0\x99\x35\xf5\x74\x2e\x7f\xe0\xbb\xef\x6d\x6b\xe7\xa6\x75\x85\x65\x85\xf5\xe5\xf1\x4b\xde\x9a\xb2\xb0\xb8\xa9\xa8\xce\xe5\x74\x84\x61\x6b\x8f\x56\xf0\x24\xc9\x13\x11\xc9\x84\xb7\x01\x64\x1a\xd6\x62\xce\x85\x2c\x93\xc1\x42\xa2\x9e\x0a\xf0\x43\xfb\x76\xb4\x0c\x70\x55\xf7\x1e\x30\x6a\xc8\x25\x43\x26\x85\xc7\x4d\x3a\x3d\x67\xb9\x63\xa4\xb9\xbe\xa1\xa2\xbf\x70\x60\xbc\x66\xbc\xca\x2b\x16\xa3\x5d\xd4\xf7\xae\x3b\x2a\x81\x21\x59\x45\x46\xb3\xf5\x70\xa8\xef\xfa\x11\x7f\x7a\x6a\x06\xec\xa5\xb7\xe9\x39\x20\xe8\x45\x0a\x1f\x61\x61\x8f\xd7\xe4\x9c\xfd\xc9\x51\x79\x28\xd6\xa4\x9e\xa0\x52\x8e\x43\x8c\x90\x96\x72\x75\xa0\x98\x5b\xc2\x96\x9d\x72\x74\x27\xf3\xb1\x3c\xf4\x9b\x6f\xf0\x0a\x50\x5c\xb1\x5c\x2a\x9f\xc0\x7c\xea\x72\xe4\x46\xd1\xc7\x45\x84\xac\x26\x72\x8c\x69\xd4\x4a\x2d\x26\xa7\x59\x47\xcf\x5f\x38\x72\x58\x1f\x8f\xbf\x52\x5e\x43\xf7\x1f\x0f\xb3\x8f\x2b\x1d\x62\xe2\x4a\x85\x34\x32\x0f\xf8\x45\xfe\x1a\x36\xf0\xb0\x5a\x7a\x4a\x36\x67\xc0\x80\x39\xb0\x52\xc3\xbe\x1f\x5e\xd3\x7b\x04\x39\x41\x1b\x37\x6e\x6d\x5b\xef\x11\xf0\xbc\x17\xe5\x21\xb0\x3e\x6b\x40\xce\xbb\x12\x06\xd0\xce\xc1\x38\x57\x04\x13\x71\xfb\x53\xa9\xca\xa7\xc5\xbd\x7c\x36\x23\xef\xaf\xc9\x8a\x7b\x18\xe3\x0a\x79\x08\x7a\x3f\x3d\x06\x22\x63\x88\x8a\x68\x26\x90\xd2\x31\x70\x5a\x2d\x95\xaf\xc8\xe8\xa5\xf2\x90\x6c\x34\x01\x96\x5f\x92\xa7\x62\x2e\xb5\x12\x64\xa3\x27\x61\x02\x09\x6c\x06\x10\x54\x35\x92\x8c\x42\x25\x24\x9b\x2f\x89\x47\xe5\x29\x91\xf2\xd4\x1c\x25\x12\xcb\x37\xc8\x43\x01\xa6\x76\x65\x3c\x03\xe2\xcd\x44\x1f\xcd\xce\x8c\x8e\x27\xe6\x4b\xdc\x40\xee\x78\x8f\xde\x93\xa7\x93\xca\x9b\xe5\x2d\xb8\x02\x6c\x7e\x17\x0a\x26\xac\xc4\xcc\x33\xa3\x10\x2c\xbc\x9d\x97\x0c\x41\x03\x63\xa0\x30\xfe\x7e\xfa\x2b\x34\x3a\xf0\x42\xc6\xde\xc0\x8b\xd9\x7a\x5b\xba\xd9\x7a\xf0\xac\xdb\x52\x16\x1c\x49\x6d\xc9\xe5\x69\xc4\xaf\x21\xdf\x46\x1c\x1b\x5f\x50\x9d\xbc\xeb\xf7\x70\xcd\x1f\xbb\x5d\x03\x34\xd5\xf5\x7b\x8e\xa3\x57\xc0\x9e\xee\x7a\x0b\xc8\xf0\x5d\x7a\x0d\x58\x51\xa0\xb9\x13\x52\xd2\x1b\xcd\x2d\x88\x23\x81\x19\x84\x16\xa7\x13\x32\x82\xe5\x81\x3b\x8b\xc9\xdd\x6f\x71\xdc\xb9\xf3\x1c\x27\x37\x2f\x5e\xfc\x16\x7d\x4e\x2a\xcc\x94\xe3\x77\xd9\xde\x30\x6f\x4f\xc2\xa8\xcc\xb6\xca\xc0\x1a\x08\x06\xaa\x5e\x89\xff\x1e\x30\x79\xb1\x19\x7f\x7c\x91\x19\x33\xe5\xdd\x67\x4c\x9e\x53\xc7\xac\xc2\xcf\x30\x7f\xec\x6e\x87\x9c\x24\x53\x66\x56\x29\x76\xc8\x5a\x66\x15\xb3\x31\xff\x1a\x02\xb9\xbc\x96\xe3\x94\x4b\xe0\x9a\x50\xea\x73\xfc\x11\x7b\x98\x5e\xc3\x28\x76\x14\x1f\xc3\xb0\xe3\x47\xb3\x2b\x47\xdb\xc9\x8b\xb2\x2f\xdf\x81\xeb\x46\xf3\xbb\x73\x75\x54\x31\x82\xe3\xa7\x3a\x19\xff\x4c\x3b\x7f\x37\x85\xa9\x06\xf6\x77\x97\x2a\x2b\xe9\x51\x32\x5c\x93\x77\x1a\x3d\x21\x7d\x18\xfd\x65\xee\x59\xb4\x1c\xc9\xd9\xf3\x19\x9b\x95\x48\x75\xc5\x56\x95\x23\x3b\xf1\xef\x77\xc2\x35\x8a\xb1\xca\x50\x59\x39\x88\xf2\x91\x1c\x5d\x98\xf0\x24\x3e\x6c\x09\xd7\x47\x1c\x71\xf9\x73\x3c\x49\x7e\xf0\xb3\x0d\x1b\xd6\xcb\xcf\xfd\x61\x03\x85\xbf\x97\x7c\x3b\x46\xc0\x27\xbc\xb0\xe7\xb4\xac\xc1\xe0\xb2\xd9\x48\x2e\x39\x75\x3c\xa8\x82\x93\x12\x76\x00\x2c\xf9\xda\x4c\x6b\x84\x1a\xda\x15\xd6\xf5\xb0\xb1\xa9\xa4\x6e\x68\xeb\xd0\xba\xd2\x81\xc6\xf1\xa6\x25\x23\xe6\x36\x36\xce\x6d\x59\x6c\x91\x3f\x2e\xaa\x68\x89\x7b\xbd\xd5\x23\x2b\x8a\x86\x4c\x1b\x37\x2e\x39\x4c\x59\x9b\x5d\x5c\x01\x1e\xca\xff\x1a\x64\x83\xf8\x28\x8f\x06\x54\x91\x03\xfd\x98\x18\xab\x8f\xd5\xbb\xc0\xfe\xc5\x43\x87\xed\xdf\x9f\xfe\x9f\x9b\x4d\xde\x6e\x54\xbe\x90\x7b\xbf\xe6\xfc\xe8\x35\x21\x84\x1c\x08\xb1\x19\x9e\x9f\xd5\x52\x0d\xf3\x42\xd1\xd0\xec\x85\xca\x2b\xb7\x41\x88\xbb\x2a\x6b\xfa\x45\x86\xb6\xb5\x67\x3e\x81\x6c\x72\xf3\x0f\xb1\x7e\xe1\xcf\x2a\x7e\x38\x81\xae\x3d\xb5\xbe\x54\xba\xfd\x4c\x21\x5b\x62\x8a\xbe\xa5\xd0\x41\x6a\x2a\xd7\x8e\xde\xa4\xb6\x42\xc6\x9e\x56\xf4\xc1\x9f\xf6\x88\xe7\x40\xaf\x81\x3d\xbd\xaf\xdb\xb5\x54\x1f\x7c\xad\x47\x3c\x4c\xea\x0a\xb0\x19\x6a\xf9\xd9\xb0\x1f\xcc\xc7\xec\x7c\x66\x1f\x90\x6d\x70\x11\x2f\xcf\xd0\x8b\xec\x03\x7a\x14\xda\x7d\x1f\xa0\xd9\x5c\x1c\x4f\xe1\xef\xf9\x41\x5d\x78\x4a\x8e\x2e\x1c\xe9\xa1\x0b\xb3\x28\x0e\xf3\x59\xc3\xbf\x44\x65\x79\x00\x59\x8f\x6b\x1d\x0e\x9f\xc4\xba\x09\x71\x28\xba\xe8\xc5\xec\x61\x17\x99\x35\xcb\xac\xa9\x89\x16\xd7\xd5\x15\x47\x6b\xe4\x65\xf1\xe2\x68\x5d\x5d\xb4\xa8\xd6\xc7\xcf\x3b\x21\x7c\xca\x3d\x13\xad\xeb\x53\x1c\x8b\xd7\x46\x8b\xfb\xd4\x45\xa3\xb5\xf1\x2b\xc2\x78\x70\xb1\xfc\x22\xe0\x65\x38\xd0\x70\x53\xea\x7a\x80\xdb\xf4\xb8\x51\xaf\x27\xba\xd1\xa9\x1a\xf3\x6b\x0a\xd3\xae\xa5\x3d\x7c\xec\x4a\x79\x92\xf6\xca\x0a\x36\xb2\x2a\xcc\x15\xf8\xab\x5d\x45\x2d\x72\x73\x55\xd4\x1c\x38\x79\xbc\x24\xe4\xae\x76\x85\x94\xbd\xf9\x1d\xf7\x0e\xe8\xc4\x97\xd0\xd5\x66\x04\x4e\x71\xd0\x29\x7b\x9d\xc8\x4c\xd8\x0b\x44\x68\x72\xef\xa8\x42\x93\xf2\xba\x93\xc0\xeb\xde\x51\x79\x9d\xe1\x31\x8c\x48\xc8\x99\x62\x53\xa7\x79\xdb\xc9\x6e\xbc\x8d\x91\xff\x01\x30\x5f\x92\xd9\x77\x3c\x16\xd2\xfe\x02\x56\xb5\x41\xef\xa7\x36\x28\x11\xe6\xaa\x0d\x9a\xd6\x53\xaf\xa2\xfa\x3a\x75\xb6\x9d\x4a\xdb\x02\xe1\xbe\xc4\x59\x26\x37\xff\xa1\x93\xd0\xc9\x36\xe0\x49\x55\xfc\x2e\xd2\x7b\x2b\x61\x13\xb4\x5a\x06\x14\x5b\xaf\xc3\x8c\xbc\x6e\x06\xfe\xf3\x19\x88\x59\xd0\x40\x5b\x9a\x10\x31\x9e\x3d\xa4\x53\xa9\x06\xe4\x38\x6c\xb0\x68\xf6\x6c\x1d\x76\x1a\x2e\xab\x8b\x54\xf4\xb3\x01\xe9\x24\xfb\xf6\x1f\x3d\x76\x42\x5d\x51\xfa\x80\xbd\x6f\xff\x51\xad\xdc\x5f\x4b\x6b\x07\x6d\x5a\x5d\x32\xbf\xf7\x8a\x52\x7a\xc0\x5e\x32\xbf\x1a\xb4\xcb\x03\x9c\x91\x69\x11\x6e\x06\x4a\x88\xa0\x2a\x54\x90\x30\xc1\x46\xb4\x68\x79\x43\xcc\x60\x09\x73\x95\x3e\x20\xb0\xdc\xb4\xf0\x0b\x52\xb0\x98\x43\x21\xb9\xd6\x2f\xbe\xf4\x22\x94\x7d\x63\x1c\x28\xa6\xb6\xa8\xb8\x76\x62\xfa\x03\xf7\x6e\x3e\xad\x2f\x2c\xaa\x8d\x17\x17\xd7\xd6\xe2\x63\xea\x07\x6a\x8f\xaf\xe3\x1c\xcc\x44\x21\x02\xba\x4f\x6f\x54\x9c\x30\x3b\x78\xa3\xd1\xaa\x45\xe5\xe5\x9e\x5e\x05\xd1\x68\xa1\x87\xd0\x2f\xe5\x6d\xe6\xd7\x6a\x08\xd2\x2e\x1e\x7f\xc0\x5e\xf8\x67\x3c\xaf\x7a\x78\x22\x37\x2c\x21\xd1\x3f\x54\xd1\xcf\x0a\x10\xff\x24\x27\x5e\x61\xcd\x64\xfa\x0f\x4a\xbc\x02\x1f\xc8\x89\x57\xe8\x93\xd8\xb4\x5a\xfe\xae\x7b\x00\x03\x96\x6f\x91\xe7\xa2\x7d\xa9\x37\xc0\xbe\xb0\x1e\x67\x75\x3a\x1e\x19\x35\x94\xf8\x1a\xd4\x7e\x08\x11\xd5\x53\x18\x07\x86\xe9\xe0\x43\xb1\xbf\x29\xfe\x42\xf2\x26\xcf\xb5\x2d\x52\x7d\x86\x0b\xe1\x4d\xa1\xff\xcf\x80\xc6\x86\xa6\x4e\x20\x2d\xb2\x9f\x10\x19\xac\xc1\x18\x51\x42\x83\x99\x53\xea\xac\x13\x89\xc9\x22\xc6\x1c\xb7\x2e\xb0\xdd\x16\xbd\xcd\xb6\x40\x6e\x4e\x0f\x09\xf7\xbb\xbb\x82\x80\xcc\x8f\xf8\x17\xe9\xfe\x27\xab\xde\x1f\x0d\x43\x13\x50\x07\x5a\x88\xd6\xa2\x1d\x68\x0f\xba\x15\x1d\x42\x8f\xa1\xe7\xd1\xab\xe8\x24\x7a\x0f\xfd\x1a\x7d\x88\xce\xa0\x3f\xa1\x4f\xd1\x03\x89\xc9\x61\xdf\xf6\x67\x9f\xdd\x78\x62\xdc\xf4\xe9\x23\x27\x1f\x99\x3f\xff\xa1\x59\x0e\xad\x56\x62\x57\xdf\x7f\xff\xd2\x3b\x1b\x9a\x9b\xe3\x4d\x07\x76\xef\xbe\xe1\xaa\xca\x98\xef\xc4\xe4\x59\xec\x9d\x4d\x57\xc5\x62\x57\x35\xdd\xc9\xce\x9a\x7c\xc2\xa7\xfd\xe0\x8d\x5f\xfd\xea\x97\x6f\x9e\xfe\xe3\x27\x1f\xff\xe5\xc5\x77\xde\xf9\xcb\x27\xa7\xb9\x77\x7f\xfb\xfa\x2f\x7f\xff\xf2\xa9\x53\x7f\x78\xe5\x5d\x2a\x97\x2c\x74\xf9\xba\x1d\x4c\xc7\x69\xa4\xbc\xf2\x27\x9d\x11\xf5\x23\x2f\x24\x26\xac\x4f\x26\x05\xb4\x38\xe7\x73\xee\xef\x96\x9c\xcf\xfc\x7f\x71\x7d\xee\xef\xb1\x8b\x5c\xc3\xfe\x17\xf7\xf2\x17\xb9\x26\xef\x77\xca\x2f\x2c\x8a\xdf\x3b\x42\x99\x5a\x98\xf8\x06\xf8\x30\xfd\x35\x4c\x43\x08\xe1\xaf\x8c\x0b\x9c\xce\x02\xf2\x97\xdd\x9f\xfe\x24\xd7\xa5\x3f\xa5\xff\xe2\x21\xe9\x4f\x5d\xeb\xd2\x9f\x98\x9f\xf4\xfc\xad\x33\x33\x58\x6b\xfa\xd3\x77\xe4\x25\xe8\x80\x51\xef\x22\xaf\x74\xb4\x8e\xf4\xa7\xae\x07\xd3\xff\xca\x8e\xb9\xc0\x6f\x2f\x77\x9e\xc6\x7d\xe5\x37\x4e\x77\x9e\x5b\x7b\xba\x93\x7c\xea\x3c\xcd\x34\xcb\x6f\x90\x4f\xb8\x2f\x33\xa4\xb3\xf3\xec\xbd\x9d\x9d\xcc\x47\xf9\xb0\x16\xc8\x23\xd5\x0f\xec\x61\xf5\xc3\xf2\x6e\x57\x74\xfd\xb4\xdb\x0f\x0f\x2a\xef\x41\xbc\x5a\x79\x72\x41\xd7\x73\xe9\x31\xe6\xa8\x1f\x54\xe8\x82\x7f\x52\xdf\xe5\x13\xea\xa5\x1f\xab\xef\xec\x9c\xd3\x9d\x67\x9b\x3a\x4f\x73\xc5\x00\xf4\xd9\x26\xdc\xf7\x74\x67\x27\xf7\x7d\xe7\xf9\x1d\x0a\xb8\x8a\x9e\xf3\x4f\xce\x82\xfe\xc4\xdf\x02\x6a\x14\xe8\x97\x3c\x95\xbd\x6c\xdc\xe5\x20\x87\x79\x31\xab\x8f\x9e\xc5\xf1\xb7\x90\xb3\xb8\x3b\x6e\xa7\xb2\x9a\x03\x21\xf3\x0e\x7f\x5b\xae\x7e\x68\xcb\xf3\xa5\xb4\xa5\x7d\x29\xdc\x7b\x59\x67\x0a\x93\x7a\x19\x74\x08\x5e\x70\xc0\xfe\xf4\x02\xc7\xb0\xb8\xdd\x76\x03\x71\x73\xc7\x5f\xa9\xe9\x11\xbc\xc6\xe6\x9b\x28\xb8\x39\xed\x13\xa8\xc9\x33\x56\xb8\x93\xaa\x8b\x00\x07\x72\xcd\x16\xe0\x25\x4f\x01\x2f\x59\x95\x92\x73\x74\x37\x5b\x8e\xee\xb6\x2a\x47\x75\x93\x77\xe5\xa9\x6e\x80\x0f\x3f\xdc\x6b\xa1\x67\x8d\x9a\x23\x24\x46\x1c\xf0\xe1\x12\x5d\x8e\x08\x39\x9f\xb4\x28\x27\x9a\xc9\xdb\xef\x20\x07\x9c\xa8\xc7\xf5\x34\x56\x12\xf4\xe5\x34\xfe\xfe\xac\xe0\xaf\x26\x83\x3e\x90\xbf\x43\xe0\xfa\xbf\xd1\xeb\x2d\x44\x8b\x15\x10\x32\xe9\x44\x86\xd1\x01\x2a\xaa\xe2\xe6\xb7\x6a\x88\xaa\xc2\xd2\x83\xd4\x48\x4c\xc4\xe9\x91\xee\x54\x86\x90\x9f\x51\x46\x94\xf7\x28\xef\xb8\x49\x1d\x3a\x7f\x5d\x54\x1f\x97\x2d\x4f\x6f\xdf\x9a\xd6\xdb\xb9\xf7\xb2\x8a\x3b\xc6\x67\xb8\x9f\x33\x7b\xf9\xf6\x8b\x9e\x3b\xec\x4d\x8b\x33\x9e\xcf\x8a\x2d\x98\x37\x27\x8f\x42\x77\xa7\x5e\x86\x59\x68\x8e\x18\xe1\x3e\xd0\x05\xc5\x7a\x57\x2c\x0e\x2f\x22\xb0\x69\x57\xa4\x1e\x10\x7e\x3e\x74\x87\x73\x8c\xeb\x8e\xd0\xc1\x83\xa1\x3b\x5c\x63\x9c\x77\x84\xee\x7b\xbd\xe5\xb2\x7b\xef\xed\x18\xd6\xbb\x7a\x58\xfb\x3d\xf7\xcd\x6c\xe9\x4d\x74\x37\x19\x78\x39\x1e\x0a\x36\x87\x0d\x4c\xd5\x72\xb0\x35\x8d\xa5\x2e\x97\x31\x12\x08\x88\xbc\xc4\x5a\x8c\x44\xac\x64\x35\x06\xf5\x88\x36\xa7\x68\x34\x55\xe8\x72\x9c\x34\xf5\xe9\xd6\xb1\xa4\xe0\xd2\xd0\xb5\x6d\x44\xd1\x27\x33\x57\xde\xe5\x05\x43\xeb\x14\xd7\x4d\xeb\xf0\x9a\xea\x91\x2d\xf1\xba\xa1\x5f\xb6\xad\x1d\x3f\x9e\x20\x84\x38\x08\xc8\x4f\xb5\xc3\x86\xd6\xd5\x0c\x27\xd7\x8d\xa2\x34\xdf\x9b\x9b\x85\x9f\x10\xa6\x52\xbf\x1e\xc3\xf3\xd4\x97\xa6\xf8\x37\xeb\x23\xa0\x3c\xc6\xd9\x4f\x9b\xbe\x99\xb5\x04\xfe\x72\xb3\xde\xc4\xbd\xde\x94\x7f\x01\xf8\x79\x02\x2c\xb4\x73\xa9\x3d\x20\x1f\x0d\x8f\x69\x90\x9e\x4f\x6b\x66\x85\x45\xd1\x58\xdc\xc9\xc5\x6b\x8a\x88\x74\xe6\x98\xe4\x1b\xf2\x6f\x0f\xe9\x47\x94\xe3\xda\xef\xbe\xc7\xb5\xe5\x23\xf4\x87\xe4\xdf\xca\x6b\x9b\xb7\xb6\x0d\x6e\x69\x19\xdc\xb6\xb5\x99\x3c\xff\x25\xae\x43\xe0\xf9\xb5\x30\xd6\x85\xcf\x99\xf2\x87\x64\x67\x5d\x60\x48\xae\x23\x77\x48\x18\xf3\x30\xf7\x2e\x7f\x2d\x3f\x00\xf4\x40\xd3\x31\x3d\xc6\x8a\x7d\xd1\x31\x5d\xf1\xd2\x1c\xe6\xce\x70\xef\x2a\xb6\xf0\x7d\xf2\xd7\xdc\x8e\xd4\x65\xb9\x36\x37\xb1\x40\xa6\x71\x67\xe4\xaf\x15\x9b\x1b\xa7\x4e\x70\xed\x7c\x98\xef\xbc\xa0\xbd\x5c\x43\x1c\x2a\x35\x17\x53\xb3\xd8\x67\xe7\xbe\xf1\xf4\x83\x23\x2e\xdb\x6e\xad\xb5\x3c\x75\xcb\xdc\xd7\xd5\xcf\xb6\x27\xb8\x76\x50\x35\x2e\xe9\xb3\xec\x72\x78\x4b\xf4\x59\xbe\x8d\x3e\xe7\x24\xd7\xc1\x9b\xd2\x78\xe8\x71\x96\x80\x6b\x38\xa7\x2b\x12\x2d\x8a\x14\x72\xe4\x29\x45\xcc\xa2\x37\x71\xec\x90\x6e\x44\xb9\xfc\xd6\xf7\xff\x91\xdf\xaa\x00\x3c\xe0\x18\xbf\x76\xe8\xd6\x09\x39\x78\x48\x4d\x90\xe7\xb2\xef\xd1\xf3\x4f\xe1\x51\x60\x67\x4a\x96\x79\x5d\x98\x68\x2d\xec\xa0\x50\xec\xbc\x8e\xfd\x56\x55\x59\x3a\x55\x65\x85\x49\xcd\x63\xca\xf1\x46\x6e\x03\xd0\x7e\x01\x2a\x38\xea\x30\x1b\x9f\xc0\x8d\x8f\x71\x7e\xbf\xf0\x14\x6e\x52\x62\xbf\xd4\xa8\x27\xda\x2e\x33\xa2\xd6\x45\x51\x34\xda\x38\x2d\x2b\x93\x89\x5f\xf5\x0f\xe1\x1f\xb2\xce\x9e\xd8\x32\x25\x79\xeb\xd4\x96\x4b\x7c\xa1\x65\xae\x92\xe0\x80\x59\xfd\xea\x2a\x2f\x69\x63\x66\x4a\xbe\xf6\x85\x0b\xdb\xe7\x1e\x5b\xe0\x71\xb4\x98\x8d\x53\x6f\x99\x90\x18\xdd\x46\x9e\xbf\x95\xa9\xc0\x1d\xdc\x46\xe4\x04\x0c\x04\x8e\xb1\xb0\x59\x02\x76\x12\x21\xa6\x15\x8c\x99\x08\xb1\x74\xe5\x03\x81\xda\x20\xd9\x36\xd2\x4a\x5d\x83\x74\xe1\x3b\xdc\xf1\xce\xfd\xcc\xd6\x3e\x53\x4b\x2c\x55\xdb\xfa\xcd\x9d\x35\x79\xdf\xf8\xd1\x93\xe4\xeb\x56\x5f\x57\x1c\x69\x5a\xc4\xa1\xb6\xe5\xfa\x8a\x5b\x8a\x5d\x9e\xb2\xfa\x65\x33\x3b\x8f\xce\x1d\x7a\x46\x6c\x6f\x2e\x2c\xbf\x9e\x9e\x3b\x4a\x4c\x03\x3a\xc7\xcf\x85\x3d\x61\x43\x8e\xa3\x7a\x8b\x40\x42\xf3\x32\x91\x6f\xaf\xd4\x64\x23\xde\xea\x73\xd8\xc9\x86\x76\xee\xd5\x69\xa3\xf9\xc7\x8a\xa3\x3e\x5f\x94\xfc\x65\x66\x49\x3e\x92\xd7\xf7\x44\x36\x2f\x94\x49\x5d\x06\xf3\xdb\x02\xf3\xd3\x01\x45\xd9\x8e\x68\xac\x4f\xe3\x46\xa0\x3f\x3d\x9d\x5a\x13\x21\x40\x75\x87\xc3\x04\x6c\x99\x39\x01\x9b\xeb\xd3\xd4\xd0\xb6\x75\xc3\xc4\x4d\x2b\x3a\xd7\x8e\xbf\x61\xda\xec\xb5\xc7\x59\x6e\xdc\xa4\xe7\xae\x7e\xe0\x79\xf9\xce\xed\x0b\x67\x1c\x9c\xbe\x75\xf1\xfe\x53\x64\xcd\x97\x31\x65\x78\x31\xb7\x08\x74\x6e\xff\x11\xc1\x41\xa2\xd5\x0c\x0c\x63\x22\x8b\xa7\xcf\x2e\x1e\x79\x8c\x9a\xf2\xac\xae\x21\x29\xb9\x41\x53\x5f\x2b\x1a\x2b\xe7\x15\x0e\xea\x9c\x36\x8c\x3f\x64\xe9\x5c\xba\x41\x1c\x30\x98\xff\xd9\x00\x13\x73\x78\xc0\x88\xbe\x78\x23\xc9\xfb\x5c\x75\xf9\x16\x4d\x6f\x3c\xd3\xe4\x93\xef\x1d\x0e\xcf\x5b\x07\xf3\x99\x03\xf3\xf1\x22\xd7\x51\xab\x49\x47\x96\xca\xeb\xce\x09\xe6\x83\x75\xca\x5d\x1d\x35\x62\x8f\xd0\x08\x21\x91\xc2\xca\xf5\xfd\xda\x17\x25\x6f\x6a\x8b\xce\x2c\xf4\x85\xb5\x25\x03\x1a\xe6\xf6\xdb\xd4\xd6\xce\xec\x2e\xab\x5f\xd2\xb9\xe8\xe1\x59\x56\xe3\xed\xf3\xa2\x93\x6f\xbe\xf4\x96\x46\x82\xbb\xd9\x40\x9b\x3f\xa3\x3d\x11\x43\x28\x76\xc4\x65\x23\xa4\xa9\x2b\x28\x30\x3c\x07\x4f\x13\x90\x16\xe6\xc7\x20\x0e\x57\x52\x4c\xa6\x27\x8a\x9b\x68\xb2\x74\x37\x52\x8d\xe6\x90\xa9\x53\x2c\x9c\xce\xbf\xb4\x37\x43\xac\x07\xa6\x35\x7a\x2a\x6b\xfb\x11\x42\x1d\x36\x86\x5b\x5c\xfd\x9a\xe4\x3b\xff\x3e\x25\xd7\x19\xf3\x1e\x9f\x37\xaa\x60\xda\x6d\xe3\x28\xad\xe2\x54\x07\xd3\x17\xcf\x01\x78\x3c\x28\xf4\x58\xcf\x14\xee\xca\x6c\x0a\x37\xe0\xfb\xa2\x19\xdb\xd6\x8b\x24\x6c\xcf\xba\x58\xc2\x36\x96\xff\x0c\xcf\x3d\x0f\x38\x2f\x43\xd1\x13\xa8\xb8\xd8\xe2\xf3\xb1\x25\xe4\x99\x11\xdc\xff\xa8\xd3\x10\x52\x42\x13\x69\xa9\x86\x74\x34\x57\x4e\xff\xb6\xdc\xac\xec\xec\x27\x25\xc7\x18\x2e\x7a\xa5\x72\x4e\x45\xbc\x1f\x3f\x70\xac\xf0\xf8\x40\x63\x6d\xf9\x0a\x4d\xff\xce\x01\x52\x9f\x8a\xd5\x62\x7f\x85\x26\xca\xe7\xf5\xaa\xeb\xc7\x7e\x37\xb0\x39\x31\xc0\x58\x2a\xdf\x22\x01\x64\x13\xa5\xc6\xe5\x35\xf2\x41\x3c\x7d\x8c\xb3\x71\x45\x6f\xf9\x20\xa1\xf9\x55\x8d\xc3\xa8\x7d\x9d\xba\x19\x60\x6d\x01\x58\x2d\xc8\xff\x34\xc9\xc4\xbe\x60\xee\xf3\x85\xf2\x9d\xb1\xbb\x67\xbe\xf3\xc6\x1e\xf9\xce\xa9\x33\x40\x7f\x2e\xee\x73\x58\x83\xc0\x31\x93\xcb\x65\xb5\x00\xb7\xe8\x7f\x94\x67\x35\x19\x12\x3c\xa5\xa0\x80\x2e\xb6\x4b\xe8\x51\x5e\x66\x98\xcf\x51\x52\x6b\x18\x3e\x2a\x1e\xe7\x2e\x19\xc1\xb7\x8e\x8f\x3a\xb7\xeb\xb6\xf7\xd3\x33\x77\xf9\x7c\x56\x7f\xed\x80\x6a\x73\x14\x2f\xf4\xb9\xb6\x6d\xab\x91\x8f\xd7\xc3\xf3\xe6\xc0\xf3\xd6\xc0\xfe\xb2\xc2\xee\xe5\x4c\x84\x31\x98\x73\x76\x2f\xce\xa6\xae\x46\x94\xca\x82\x7d\xb0\x9b\x64\xd1\x4a\xbd\xe5\x8a\xe5\x43\xf8\x5b\x26\xdf\x18\xe3\xfc\x24\x47\x55\x72\xd5\xb6\xca\x0b\x68\x52\xed\xf0\xaf\x2e\x51\x64\xcd\x54\xc0\xd5\xe5\x30\x76\x04\x15\x26\xb4\xe9\x90\x53\x03\x79\x46\x30\x93\xb1\x9d\x89\xd8\x64\xff\x8b\xe0\xd2\x4b\x7e\x30\xb8\x74\xc1\x8f\x07\x97\x62\xbc\x9f\x6b\x67\x7e\xc3\xdf\xfb\xff\xc7\x1c\x39\xe5\x8c\x18\xef\xe7\xe7\xbd\x2f\xc8\xe7\x88\x53\xb0\xa8\x58\xfe\x08\xf4\x87\xcb\x41\x67\x7b\x25\x75\x4d\xae\xff\x90\x87\x05\xad\xc7\xf8\x15\x72\x2d\xe6\xd7\x84\xe5\xdf\x15\xe3\x10\xd1\x35\x56\xc1\xb5\x0b\xa8\x9f\x4c\x77\x54\xf5\x92\x65\xcf\x0f\x33\x3e\xb2\x53\x3f\xe6\x23\x43\xce\xd4\xe7\x6c\x1b\xfb\x2a\xf2\xa1\xca\x84\x4b\x42\xc8\x29\xb2\xfe\x80\xc3\xe3\xb1\x8e\x4b\x7a\xcc\x9c\x7e\x5c\x52\xc3\xd1\x1e\x72\xf9\x4d\x0b\x88\x14\x64\xa8\x85\x5b\x4f\x8e\x51\xd2\xa2\x4f\xed\xe0\xc1\xb6\xed\xfc\xfb\x75\x33\x1e\xae\xee\x15\xdf\x32\x71\xd6\x2d\xd3\x16\x74\x4e\xdc\x93\x28\x1a\xf7\x7a\xfb\xbd\x0f\x33\x03\xee\x96\xff\x71\xfb\xf4\xe6\xb2\xb2\x7e\x97\x7f\xff\x93\xed\x57\x24\x2a\xe3\x23\x27\xbf\x99\xee\xfb\xb7\x91\x7d\xd5\x1a\x65\xef\x45\xc8\x22\x32\xb7\xa2\x7e\xe7\xbf\x01\xbd\xd5\x8e\xb7\x15\xe1\x65\x45\xb8\xb5\x08\x0f\x29\xc2\xa1\x22\x8c\x8a\x70\x11\xb2\x28\x49\x00\xa4\x57\x3f\xdc\xab\xce\x01\xee\xad\x53\xee\x4d\xdd\xf5\x5f\xdf\xdb\x21\xbf\xca\x14\xb2\x2f\x98\x05\x54\x40\xf1\xf1\x1d\xd0\x5d\x3f\x4a\x77\x7f\x4f\xac\x83\x45\x10\x85\xff\x43\xe2\x53\x92\x17\x09\xf1\x6d\x13\xf7\x8a\x4c\xa7\xb8\x4a\x64\x5a\x45\x3c\x44\xc4\x21\xb1\x5a\x64\x38\xd1\x2e\x32\x5f\xe6\x10\xdf\x0c\x71\x99\xc8\x90\xec\x44\xa6\x5a\xfd\x35\x06\xc4\x77\x52\xc4\x8f\x8b\xf8\x2e\x20\xbe\x65\x64\x14\x49\x5c\x2a\x32\x3a\x96\x67\x6e\x4c\x12\x35\xf6\x11\xfe\x1d\x9e\x23\x67\x5d\xe5\xb8\xa3\x3d\x87\x1a\x97\x5f\x90\x1a\xd5\x6a\x4e\x8a\x9b\xfa\xbb\x6e\x14\xd9\xd3\x07\x3c\x33\x61\x34\x58\x91\xe0\x13\xdc\x56\xae\x20\x18\xf0\x3e\x81\x5d\x27\x92\x81\x80\xa4\x75\x48\x20\xf3\xdd\x89\xa2\x24\xfb\x88\xf4\x8e\xc4\x48\x89\xfa\x41\x2d\x21\x29\x21\x31\x41\x09\x23\x69\xaf\xc4\x3c\x22\xa5\xc8\xcf\x5a\x4b\x8b\x94\x49\xb3\x4a\x37\x99\xac\x2a\xcf\x2d\xec\xfc\xbf\xf4\x29\x17\xc7\xb3\x3e\x65\xe2\x4b\xae\x8d\xaa\xef\x3b\x15\x9f\x72\x2a\x95\xda\x8b\x10\xf7\x37\x7e\xb8\x39\x8a\x8a\x80\x3e\x04\xb6\xe1\x8a\x83\xa8\xd7\xe3\x8c\x83\x65\x9c\x80\xd3\x63\x7a\x73\x0b\x72\xe2\x27\x52\xfa\x84\xd1\xe9\xe4\xf9\x62\x50\xdb\x13\x36\x77\x0b\xc2\x96\xf2\xba\x3a\x40\x53\x1d\x6a\xaa\xa3\xb4\x72\x96\xa9\xc4\x9f\xb3\x41\xb3\xa0\x19\x3c\x11\xbe\xa7\xbe\x42\x88\x1f\xc3\x0f\x34\xc7\x50\x09\xda\x45\x28\x8f\x6d\x90\xcf\xa5\x6e\x45\xa5\xc7\x71\x01\x8b\xb7\x05\x61\xcc\x33\x09\x73\x30\x88\x71\x31\x7a\xde\x8b\xf7\x78\x71\xc8\x8b\xbd\x98\x10\x20\x8c\xab\x0c\x4b\xc6\xf9\x1a\x21\xe1\x28\x1d\xa7\x1c\xed\x51\xc7\x39\x4f\xc6\x79\x8c\x8c\xf3\x44\xea\x77\x09\x5b\x30\xc8\x71\xc5\xe8\x5d\x84\xdf\x41\xf8\x79\x84\xb7\x92\x40\x2a\x4a\xc8\x75\xe5\x99\x71\xc8\x86\x66\xaf\xa2\xe3\x54\xa0\xdd\xca\x38\x29\x8d\x02\x8f\x09\xe0\x91\xe8\x50\x66\x49\x12\xc5\x62\xf4\x08\xc2\x7b\x10\xb0\x12\x75\x9c\x5c\x78\x90\xa4\xd4\xe8\x06\x7c\xd5\xa8\xa3\xb8\x60\x94\xd8\xe3\x4c\x88\x65\x0a\x00\x63\x47\x61\x15\x9f\x48\x3d\x90\xd0\x17\x14\x58\xad\x80\x2e\x02\x8d\x65\x3a\xe0\x2a\x0b\x4b\xea\x33\xc0\x8d\x4c\x61\x69\x44\xef\xab\x73\xfa\x32\x75\x2b\xde\xf1\x24\xf2\xa7\x5e\x78\x6c\xdb\xb6\x16\x3f\xa1\x67\xdb\xe6\xcd\x2d\xfe\xc4\xc6\x8d\xf0\xb2\x6e\x1d\xbc\xac\x59\xa3\xfc\xae\x5d\xb5\x0a\xbe\xad\x58\xa1\x7c\x33\x2d\x5f\x0e\xdf\x96\x2e\x85\x97\x45\x8b\xe8\x4f\x8f\xcd\x9b\xa7\x5e\x38\x7b\x36\xfc\x3a\x6b\x96\xf2\x2d\x36\x73\x26\x7c\x9b\x31\x03\x5e\x3a\x3a\xe0\xe5\xd2\x4b\xe1\x65\xf2\x64\x78\x99\x34\x09\x5e\xda\xda\xe0\x65\xc4\x08\x65\x84\x96\x16\x75\x84\xe6\x66\xf8\x75\xf0\x60\xf5\x51\x83\x06\xc1\xb7\x44\x02\x5e\x06\x0e\x54\x2f\x68\x6c\x84\x6f\xfd\xfa\xa9\x17\x34\x34\xc0\xb7\xfa\x7a\x78\xa9\xad\x55\x46\xaa\xae\x56\xfe\xa9\xb0\xb2\x12\x7e\x2d\x2f\x87\x97\xb2\x32\x78\x29\x29\x81\x97\x60\x10\x5e\x0a\x0a\xe0\xc5\xef\x57\xc7\xf3\x78\xe0\x9b\xd5\xaa\xdc\x6c\x36\xab\xbf\x1a\x8d\xf0\xab\x5e\x4f\xbf\x1d\xd7\xe9\x5a\xb0\x8b\xac\xfd\x47\x09\xa7\xdb\xad\xd1\x14\xa3\x77\xec\xf8\x11\x3b\xbe\xd3\x8e\x9b\xec\xb8\xca\x8e\xed\x0a\x1b\x53\x96\x1f\x97\xff\xaf\xfe\xa4\xd7\x67\x2b\x59\x63\x76\x6a\x76\x75\x90\xfd\x31\x5c\x49\x9e\xda\xf7\xf1\xf2\x72\xb2\xb4\x59\xda\x1f\x91\xfa\x9c\xd9\xcd\xbf\x04\x3c\x76\x21\xdd\x43\xfd\x5c\x08\x99\x13\x5a\x96\xc1\xd5\x31\x87\x59\x20\x97\xd6\xd5\x65\xf6\x5a\x8b\x55\x20\x7b\x0d\xee\xb3\xa5\xce\x72\xc7\x69\xad\x8b\x62\xaa\x6b\x7c\x01\xff\xfe\x36\xd8\xc8\x66\xd2\xdf\xd0\x24\x49\x2c\xcf\x71\x2c\x8b\x35\xa2\x68\xc5\x16\xc1\x34\x83\x54\xa5\x13\xb8\x8e\xa4\xc0\x92\xb0\xc3\x8e\x24\xb6\xe7\x97\xd7\x4d\xf7\xc7\xb0\xe6\x24\xab\xd2\x66\x04\xa4\x90\x59\x84\x25\xb5\xae\x58\x17\x53\xda\xf5\x9a\xf6\x91\xf7\x0e\xe9\xd8\xaf\x6a\x2e\x31\x86\x9e\x6f\x90\xdf\x7d\xb3\xce\xcb\xdd\xe1\xab\x93\xb7\x82\xf5\x68\x3c\x37\xcf\x4b\xf4\xfa\x67\x00\x96\x36\xbe\x85\xc8\x5b\xd4\x2f\xe1\x64\x05\xc4\x0b\xbc\x4e\x64\xb0\x96\x11\xc0\xe6\xe7\x34\x3c\xe1\xba\xd8\x73\x34\x89\xad\x0a\x14\xb4\xb6\x33\x4d\x13\x02\x05\x32\xad\x11\x95\x62\xd2\x16\x47\x8b\xc3\xdc\x90\x73\xeb\x24\xe6\xdc\x73\xef\xca\xd7\x74\xad\x61\xa3\xad\xdc\x77\xe7\x34\xdc\xbc\x73\xc7\x54\x7c\x73\x2f\x51\x3c\x94\x50\xbc\x78\xe0\xfb\x4e\xfa\x7d\x00\xdd\x2f\x7f\x03\x1e\x10\xa1\xdf\xcb\x51\x6e\x9d\x7c\x3d\x5c\x59\x8a\xc6\x27\x8c\xb6\x02\x43\x34\xaa\x61\x0a\xb8\xb2\x72\x1e\x74\x58\x7b\x22\x94\xac\xe2\x3b\xf8\x33\x3c\x9b\xe2\xb1\x81\xc7\x7a\x96\xe7\x0b\xbd\x85\x52\x47\xb2\x90\xf3\x3a\x3b\x92\x5e\x5b\x5e\x71\x6d\x22\x0b\x96\xe7\xf1\x59\xd0\xc8\xe3\xae\x30\x6d\x5b\x5b\xfc\x83\xc5\xf4\x99\xa6\xfe\x89\x71\x09\x16\x2f\x50\xde\xa2\x3f\x50\x4e\x9f\x99\xf9\x53\x7c\xdb\xae\x5d\x72\xe7\x4f\xff\xf0\x03\xe5\xf4\xc9\x7c\xbf\x83\x05\x38\x4b\xe7\x5b\x41\xe9\x82\xd0\xe3\xc3\x40\x17\x1e\xb4\x2a\x11\x00\x93\x37\x4a\x73\x33\x9c\x5a\x87\x43\xaf\xd3\x99\x25\x91\x73\x31\x0c\x27\xb1\x46\x9f\x8f\x6c\x96\x80\x2f\xd2\x62\xf4\xba\x1c\x8c\xd9\x6a\xee\x48\x6a\x9d\x46\x8f\x95\xd5\x71\x92\x11\x66\x2f\x1a\xad\xd9\x9e\xb7\x64\xb1\xe8\x47\x92\x76\x54\x9e\x4d\x66\xa3\x19\x53\xa4\xae\x1f\x89\xff\x47\x80\x1b\x2c\x61\x2d\xa9\x42\x4d\xfa\x57\xd0\x34\x24\xa5\xa2\x3b\xd8\x70\xfc\xc3\xba\xdb\xba\x4e\xe3\xe7\xaf\xd4\xc9\xa7\xe4\xd9\x7b\xa6\x3c\xa3\xeb\x3a\xad\x7b\xe4\xbd\x07\x74\x8c\x47\xf7\xe8\x4c\xe6\xe0\x5a\x1d\x3f\xa0\xce\x2b\x37\x74\x95\xfa\xea\x98\x87\x57\xcb\x2e\x52\xc2\x98\xbb\xc3\x5b\x57\xe7\xed\xfa\x05\xd3\xcb\x5b\xa7\xe8\xd8\x97\xc1\x7a\xbf\x01\xb4\x66\x42\x83\x13\x45\x40\x67\x26\x8d\x89\x67\x25\x73\x95\xb9\xc9\xcc\x48\x66\xac\x65\x4d\xac\x28\x70\x46\x0d\xe9\xd1\xd3\x91\xd4\xb3\x99\x49\x28\xb3\x20\xb2\x7c\x79\x1a\xfe\xde\xd5\xf5\x4a\x11\x71\xda\x8c\xa9\x09\xb3\x1b\x1e\xd6\xc9\x83\x75\xfb\x99\xd7\x9f\xbb\xe3\x3e\x5d\xd7\xdb\xba\xa7\x16\xb5\x52\x28\x80\xfe\xe8\xfb\xf4\x0c\x4f\x16\x35\x14\xe7\xd5\xf4\xfb\xbf\x00\xe7\xc7\xe8\x77\xea\x33\x44\x61\xf8\xee\xa0\xf5\xe8\xdc\xb0\x7b\x37\x24\xbc\x01\xbf\xdf\xeb\x8b\x14\x16\x86\xc2\x36\x2e\xec\xb3\x08\x42\x71\x54\x8a\x62\x0f\x5b\xe0\x21\x04\x58\x9a\xbc\xad\xe0\x70\x01\x93\x2a\xc0\x6f\x16\x60\xa9\x00\x28\x10\xe4\x81\x60\xb7\x58\xac\x56\xe3\x65\x49\x2b\xcb\x89\xa2\x20\x18\x2e\x4b\x0a\xea\xe6\xb1\xa4\x0b\x4b\x2a\x9d\x6e\x08\x45\x02\x49\x92\x99\xe5\xd4\xf0\x52\xb2\xe1\x43\x4a\x85\x72\xda\x94\xd1\x96\x2e\x64\x07\x06\x7c\x2e\xd1\x32\x3f\xc3\x68\x62\xfb\xa0\x69\xe7\xce\xd4\x0d\xb2\x47\xff\x39\xe9\x7f\x7e\xbd\x6c\xc2\xa0\x89\xec\xb3\x95\x83\x1c\x8b\x4f\xcb\x3f\xe9\x9f\x68\x4d\x70\xf8\xae\x7e\xf0\xc6\x3e\x68\x7e\x46\xbe\x06\xaf\x79\x46\xd4\xb2\x5f\x99\x6e\xc7\x23\xe5\x63\xb7\x9b\xba\x5e\x4d\x93\x2a\xdd\x8f\xea\x7e\x03\x5c\xd4\xa4\xf9\x94\x50\x0e\xb8\xb0\x91\x5e\xe0\x66\x8b\x85\x01\x2e\xc5\x98\xb4\x5a\x49\xd0\x30\x1a\xbb\x43\xc3\xf2\xc0\x9c\x78\xf3\x8c\x24\xcf\x5a\x4c\x5a\x06\x31\x1d\x49\x03\xb2\xab\x1d\x61\x69\xe5\xdf\xdc\x6e\x6c\x79\x19\x94\x91\x0c\x79\x29\xa4\x16\x86\x77\x8b\xf6\xd1\x77\x0f\xe9\xf8\x56\xdd\x91\x77\x0f\x6a\xbb\x3e\xd3\x1e\x7d\xbb\xeb\xea\xb7\x0f\x6a\xd3\x94\x74\x6e\x26\x5d\xc7\x1b\xce\x2d\xf6\xa9\xf2\xf5\x1b\xa0\xa7\x47\xe8\xda\xc5\x29\xbc\xe7\xe1\xfb\xdd\x00\xaf\x03\x8d\x4c\xc4\x2c\x92\xd1\xa0\x91\x60\xcb\xe8\x74\x4e\x84\x0d\x2c\xe3\xb0\x58\x8c\x0e\x93\x63\x46\xd2\xc4\xea\x19\x11\xd4\x45\xe6\xb2\xa4\x2e\xcd\x59\xab\x2c\x71\x95\xb9\x55\x59\xd4\xc2\xf5\xca\xe9\x9a\x5a\x00\xbb\x48\xa9\x80\xad\xc5\x84\xc3\xd6\x47\x23\x61\xe6\x23\x51\x96\xce\xcf\xc1\xb1\x22\x40\xff\xf9\x88\x89\x29\x96\xff\xc7\xcc\x1e\x68\x1a\x84\x17\xbd\x22\x7f\xca\xfc\xa6\xa4\xeb\xac\x56\x04\x8c\x8f\x60\x1a\x99\x79\x63\xe5\xe7\x7f\x6b\x52\xf4\x8a\x2b\x01\xc6\xcf\x29\xcc\xf5\xf4\xfb\x6a\xa0\xb7\x52\xfa\xbd\x91\xd2\xdf\x6c\xf8\xfe\x31\xcc\x41\x44\x12\xaa\x44\x8f\x27\x86\xe8\xec\xfe\x82\x82\x58\x50\x14\x4a\x4a\x2a\xbd\x1e\x8f\xdb\x2c\x99\x2a\x99\x48\xa4\xd2\xce\xf6\xaa\x3a\x53\x85\x51\x55\xa2\x6a\x46\xd5\xb2\x2a\xce\xc0\x92\x40\xa4\x8e\xa4\x3b\x18\x33\x9b\x80\x21\x88\x26\x14\x34\x07\x43\x41\x56\xcf\x06\x09\xbb\x88\x38\x3c\x2d\xa6\x84\xcd\x05\x2f\xa0\xba\x04\x4d\x41\x93\xaf\xbc\xa4\xb2\xbc\xb2\x23\x59\x6e\x2d\xf0\xf8\x3c\x1d\x49\x1f\x9b\x2b\x66\x08\x5f\x70\x57\x91\x32\x2e\x84\x38\x55\x35\x95\xbc\x52\x95\x3a\xd3\x28\x2b\xb3\xae\xf1\x6c\x3d\xcd\x90\x85\x94\xde\xd2\xc3\xbb\xdd\xd9\x1f\xdb\x58\xaa\xbf\xa2\x70\xbc\x5e\xa9\xcf\x45\xbc\x21\x28\xac\x14\x4a\xc7\xec\x7e\xbc\xf3\xce\x9b\xc3\x57\xec\x93\x37\xdd\x79\x73\xd9\x95\xfb\x06\x9d\xf9\x37\x2e\xc2\xce\x4d\x8e\x43\x3a\xc6\xa4\x3b\xe2\xe8\xfb\xe7\x6f\xe4\x5f\xc9\x9f\xad\x70\x03\x49\xfc\x5b\x7b\x14\x57\xe0\x87\xee\x79\xb0\x4b\xcb\xfc\x47\x9e\x78\xcf\x83\xcc\x7f\xce\x3f\xfd\xde\x5b\x5f\x63\x66\x33\x21\x90\xcd\x1f\xbc\xf8\x95\x7c\xee\xa7\x84\x4a\x14\xfa\x00\xd9\xc6\x17\x53\xdc\xf6\xa7\x76\x0d\xc8\x65\xa1\x1f\xe0\x36\x86\x7e\x92\x18\x52\x14\x0c\x86\x42\x11\x17\x68\xbb\x1e\x9f\x2f\xe6\x07\x85\xd7\x21\xb0\xbc\x64\xb5\x6a\x8d\x06\x83\x96\xd7\xfe\x3f\xbc\xbd\x77\x80\x14\x55\xd6\x37\x7c\x6f\xdd\xea\xee\xea\x58\xd5\x5d\x9d\x73\x9c\x9e\xd4\x93\x7a\x02\x03\x03\xd3\x33\xa4\x01\x06\x26\x00\x42\x91\x66\x48\x43\x90\x9c\x91\xa8\x18\x10\x45\x82\x08\x22\x4a\x52\xc0\xc0\x0a\x2a\x28\xa6\x55\x54\x14\x23\xe6\xb0\xee\x1a\x56\xdd\x35\xa0\xfb\xba\xea\xae\xab\x74\xf1\xdd\x5b\xd5\xdd\xd3\x3d\xe2\x3e\xef\xf3\xfd\xf1\x2e\xeb\x9d\xee\x99\x66\xa8\x7b\xef\xb9\xe7\xfc\xce\xb9\xe7\xfc\x4e\x7e\x20\x14\x2a\x70\x5b\x94\x96\x0e\x21\xaa\x54\x1a\x50\xc8\x65\xd5\x19\x74\x1d\x82\xdf\x6e\x40\xb2\x82\x42\xe6\xac\xd6\xcc\xb2\x82\x35\xe5\xf4\x02\xcd\xea\xe5\x6f\x94\x97\x27\xe7\x14\x64\x75\x18\xcb\x69\x7b\x67\xb5\xa5\x8e\x06\x89\x12\x92\xaf\x4a\x3a\x40\x7d\xf1\xa0\x26\xf9\x91\xe6\xb1\x61\x1f\xbe\xa7\x8d\x2f\xd3\xc0\xde\x8d\x9a\x55\xd7\xac\x78\x50\x43\x05\x35\x8f\xad\xb8\xeb\xa1\xc0\x50\xd8\x5b\xb3\xb6\x4f\x81\xf8\xb5\xf8\xb3\xa4\xf6\xe0\xbd\x0f\x9c\x1c\x54\x05\x79\x67\x95\xb8\xbb\x57\xcd\x96\x9b\x20\x75\x48\xd2\xc6\xe3\x0f\x9c\x80\xfb\xb0\xaa\x3e\xf9\xd7\x17\x64\xdf\xb7\x58\xc6\x40\xa0\x10\x5c\x9e\xe8\xc5\x20\xd6\x60\x50\xaa\xdc\x1e\x4f\x24\xac\x0a\x9b\x42\x0e\x93\xa3\x28\xbf\xd8\x0a\x3a\x04\x2b\x1d\x51\xb2\x58\xba\xdc\xac\x21\xe1\xc1\x7a\x7b\xb2\x10\x78\x5d\x0d\x59\x35\x54\xab\xc3\x8c\x49\xa6\xe3\x94\x7b\xc5\x3b\xed\xdc\x6b\x15\x69\x31\x82\xf2\x1a\xe4\xf0\x42\xca\x51\x7b\x0a\xcb\x86\x4d\x52\x6f\x58\x44\x24\xaa\x7c\xc9\xd8\x62\xc9\x60\xd3\x44\xac\xbc\xd4\x1e\x00\x75\x7c\x96\xbc\x66\x45\x20\xf9\x46\xb4\xd1\xdf\xfa\x54\x13\xb3\xef\xcc\xbd\xb0\xf7\xb9\x24\xf4\x89\xdf\xfc\xe4\xee\xf3\xd2\xe8\xf6\xc6\xe1\xc9\x37\xc6\x3c\xfb\xca\x71\xfa\x82\xf8\xa1\x78\x61\xef\xd3\x5e\xf1\x1e\x38\x74\x2b\x37\x3f\xfa\xd3\xbd\x4f\x40\xd7\xce\xef\xdf\x4d\x8a\xa7\xa2\xf3\xb9\xad\xe2\xc3\x70\x8c\x07\x3a\x7e\x7c\xf8\x4c\xca\xf6\xa2\x3c\xe5\x7e\x53\x1e\x59\x01\xa3\x0a\xcc\x06\x25\x70\x2e\xb0\x25\xf4\x14\x64\x15\x79\x14\xdc\xe5\xd5\x21\xb5\x84\xe8\x00\xf9\xaf\xfb\xac\x4a\x7f\xa7\x4e\xfe\x3b\x18\x68\xa5\xfe\x8e\x9d\xfc\x9d\x7e\x51\x0b\x63\xec\xf1\x77\xfa\x5e\xfc\x86\x1e\xad\xb8\x13\x63\xc6\xa9\x32\xc6\x84\x76\xfc\x03\xed\xc3\xd4\xcc\x58\x99\xd6\x2a\xa1\x4b\xe9\x73\xc5\xd8\x7f\x8f\x48\x9f\x9b\x21\x7f\x0e\x7c\x25\x7d\x0e\x7e\x50\x52\x1e\x46\xdd\x9f\x1b\x22\x0e\x43\x77\x4a\x9f\x9b\x95\xfa\x7d\x8d\xf2\xe7\xbe\x08\x84\x19\xbe\xfb\x73\x2b\x31\x56\xed\x92\x3e\x27\x63\xd5\x5a\x3c\x4d\x7b\x82\x83\x9d\x16\xd8\x6a\x81\x09\x0b\xdc\x64\xb1\x4b\x90\x95\x00\x68\xfc\xf9\xf1\xf8\xdf\x9f\x27\x61\xdb\xe5\xd2\xef\xed\x0d\xfe\x05\xd2\xe8\xb6\x2b\xe6\x42\x76\x19\xdd\x4a\x31\x7a\x69\x4e\xe8\x79\xec\x0b\x17\x63\x0b\xd9\x3f\xa2\x75\xf2\x5e\xad\x37\x66\xf5\x28\x28\x7c\x8a\xac\xd6\x12\x0b\xeb\x2c\x02\x3c\xc7\xfb\xf9\x04\x4f\xab\x11\xcf\x17\x29\x14\xa0\x88\x2b\xa2\x74\x74\x51\x11\x97\xcf\x05\x5a\x05\x8e\x63\xf2\xdb\x04\xc6\x4a\x79\x5a\x04\xca\x92\xdd\x15\x12\x43\x35\x07\x31\x8c\x92\x52\x2e\x95\x94\x4f\x7d\x9a\xdf\x36\x9e\xdd\xa3\x29\x42\x2e\x73\xd3\xac\xd5\xa4\x43\x13\x6f\x23\xe9\xe2\x06\xd2\xe9\xd2\x86\xb2\xe1\x1c\x56\x33\xa7\x99\x77\x8c\x6e\xd4\x76\x60\xc1\xba\x9d\x89\x2b\x4f\xcc\xf9\x22\x0a\x0d\xeb\xee\x60\xf2\xe6\x6e\x60\x42\xee\x27\x5b\x46\x4e\xba\x76\xc4\xf0\x81\x23\x77\x8e\x85\xb1\x58\xc9\xb6\x7e\xbb\x56\x3d\x7f\xef\xe2\xf3\x0f\x8c\x17\xff\xe3\xf1\x9e\xcf\x2f\xbe\xfb\x83\xdb\x9e\x6a\xa4\xc0\xe1\x1d\x3b\xc4\xb7\xaf\x98\xb7\x7e\xef\x99\x36\xb9\xe6\xe5\x63\xb1\x19\xfd\x47\x71\x10\xdb\x9b\x42\xd0\x95\xa8\x0c\x68\x34\x28\xac\x52\x19\xf3\x11\x32\x15\xb3\xc5\x18\xcf\xb8\x9c\xd8\x6a\xf2\x26\x53\x91\xd1\xa5\x8a\x84\x23\xe1\x56\x21\x12\x01\x5e\xbd\xb7\x55\xd0\x5b\x81\xb5\x55\xc0\xe7\xef\x37\xad\x84\xec\x59\x93\x95\x60\x41\x6d\x37\xd0\x27\xb1\x5a\xab\xd4\x06\x89\x30\x1e\xd2\x24\xf6\x84\x42\xbc\xa9\xda\x46\xf2\x73\x90\x94\xcc\x2b\x45\x22\xa5\x58\x14\xf5\xe8\x8e\xa3\x87\xb6\xc0\xb9\x6b\x2f\x82\x0f\x46\x5c\x57\x38\xf2\xd0\x3f\x63\x7f\x7b\xa9\x73\xde\x08\xf7\xb6\xd0\xca\xc4\xcd\x47\xaf\x5f\x61\xd8\x7b\xef\x65\x8a\x83\x7b\xae\xbd\xed\x55\x9f\xc6\x7e\x70\xf9\x7b\x49\xaf\x4d\x2c\x52\x4c\x86\xd4\x0f\xad\xed\xa7\xf6\x5d\x78\xc9\xe4\x79\xed\x91\x35\xab\x95\x23\xa8\x17\xfe\x30\x71\x16\xd1\x15\x11\x3c\xdf\x51\xe8\x28\xf0\x82\x7e\x09\x2f\xed\xb2\xf2\xbc\xdd\x45\x01\x17\xf0\x31\x2c\xeb\xa7\x21\xef\xb2\xd8\x5c\xa4\x29\xa4\x0e\xb2\xa9\x70\x99\x74\x5f\x94\xcb\x79\x6b\x92\xaa\x8b\xe3\x26\x3e\xce\x77\x87\x4d\x95\x2a\x92\x2b\x0d\x09\xa5\x42\x1e\x15\x8d\x30\x6f\xb6\x96\x31\xef\x4d\x09\xf1\xcc\x93\x8a\x5e\xa3\xc4\x17\xe8\x32\xeb\x1d\x05\xba\xa1\x61\xd7\xb8\x62\xb4\x2e\x26\xde\x27\x76\xc2\x2d\x0f\x24\xbc\x61\x65\x4c\xe3\xcb\xbb\x7a\x47\xf2\xed\x91\xe2\x87\x43\xb5\x9e\x7e\xe2\xf8\xaf\xe1\x77\xdb\x24\x19\xad\xc3\xf2\xfc\x96\x62\x97\x74\xf3\xdb\x95\xa8\x51\xe6\x31\xe1\xb0\xdb\xad\x2f\x40\x56\x06\x31\xc5\x7a\x7d\x8c\x8d\xf9\x62\xa5\x31\xa4\x46\x0e\xa5\x32\xaf\x45\x00\x4a\x8c\x11\x94\x4a\x2d\xd0\xf2\xad\x02\xab\x85\xc0\x9f\xd5\x82\x35\xbb\x3b\x95\x6c\x00\x8d\x99\x96\x84\xc6\x4c\x0d\xad\xdc\x84\xb5\x26\x2f\x43\x8f\x90\xee\x6f\x67\x93\x1b\x9a\x45\xa5\x18\x61\x54\x12\x4a\x78\xd7\x91\xd3\x5f\x7e\xb5\xfd\x89\xa3\xf3\xae\x0a\x95\xda\xac\xad\xb1\x31\x73\x06\x2f\x9a\x34\x76\xf5\xfb\x57\x5d\x76\xd5\xb0\xad\x07\x1f\x99\x6e\x7e\xfa\xee\xc7\x21\x37\xf8\xf6\x2d\x6b\xae\xcf\x7b\x7e\xae\xcd\x3e\x72\x64\xd5\xb2\x85\x9d\x4f\x2d\xde\xfc\xaf\xab\x5b\x2e\x7f\x6f\xe9\xa9\x8d\x95\xe2\x77\xc7\xd7\x6e\x90\x75\x38\xd1\x1d\xe8\x0c\xc6\x0b\x53\x13\xac\x23\xac\x2b\x32\xe5\x17\x85\xe9\x12\x1f\x42\xa5\x24\x54\x91\x88\x68\xd9\x26\xaf\xd7\x1d\x70\xb7\x09\xf9\xac\x95\xb5\xe2\x1d\x62\xdd\x2c\x85\x11\x03\x0b\x02\x56\xa0\x6e\x15\xf0\xf1\xe4\xd2\xad\x0b\x4d\xb5\x99\x36\x5c\xd9\xee\x66\x06\x77\x43\xf9\x26\x29\x33\x39\xa9\xc1\x55\x30\x9a\xbe\xd3\x49\x87\xf9\xeb\xa1\xc4\x62\x40\xe5\x25\xb6\x95\x84\xcb\x3c\xe6\x91\xb1\xce\x25\x35\xa1\x15\xb5\x71\xae\x32\x78\x67\xdb\xa8\x29\x63\x76\x5f\xef\x3f\x72\x6e\xc7\x81\x2d\x2b\xa8\xc6\x11\xe7\xd0\x19\x33\xf7\xdc\x62\xd6\xde\x35\xae\x6a\xac\xde\x34\x43\x6f\x5f\xd0\x32\xea\xb2\xce\xb2\x5b\x37\xae\x9a\xb9\x95\x57\xb9\xe6\xf4\x5f\x7a\x8d\x6c\xaf\x1a\xc5\xfd\xe8\xb8\xe2\x36\x8c\xd3\xa7\x24\x82\x2c\xb0\x62\x74\xae\x04\x74\x50\xa3\x09\xf9\x79\x48\xf3\x66\x9e\xd2\xb9\x7c\x10\xf8\xa0\x81\xe6\x7d\x6a\x8c\xd1\x5d\x09\x8b\x52\xd5\x26\xac\x57\x42\xa5\x52\x33\x48\x01\x69\x45\xa5\x82\x52\xa8\xf1\xc9\x8b\x63\x8b\x15\x27\x6c\x4b\x64\xce\xb5\x04\xd5\x10\x60\xd3\xcd\xf7\x41\x32\x1d\x4c\x20\x52\xa5\xa8\x0a\xd7\xd8\x0c\xc8\x62\xc6\x6a\x45\x62\x1a\x55\x45\xab\x65\x22\x8c\xc6\x1d\xb0\x12\xe6\x27\xdf\x81\x9f\x3d\xc2\x7e\xfd\xee\x2e\xa1\x6c\xca\x8c\x99\xb3\x76\x1c\xb4\x3e\x32\x61\xfc\x91\x5b\x60\xe2\x2a\x18\x81\x63\x7f\x51\xb5\x2d\xf2\x39\x07\xfd\xed\x9f\x1f\x7d\x25\xd4\x0c\xaf\x76\x3a\xc7\x37\xcd\xd8\x5a\x59\x33\x68\x51\xbc\xb7\x29\xb8\x5b\x9a\x93\xa4\xd3\xf1\xfe\xf9\xc1\x84\x04\xc1\x2e\x4e\x5e\xaf\x53\xaa\x54\x6a\x86\x67\x82\x81\x2d\xc1\x73\x41\x6a\x41\x10\xb2\xc1\xd2\x60\x4b\xb0\x23\x88\xf5\xa9\xcb\xa5\x47\x1c\x6a\xc7\x3a\x34\xdd\xe2\x2a\xd3\xab\x91\x98\x5d\x09\xa0\x4d\xec\x6e\x2d\x9d\xf6\x28\x60\x86\x9b\x1e\xc3\x0b\x55\xea\x5a\x4a\x85\xb0\x3c\xaa\x42\x58\x6e\xf9\x6a\x2a\x59\x55\x39\xf4\x44\xed\xbc\xc3\xbb\x97\x31\xd0\xea\x6a\x7b\x74\x5c\xd7\x6c\xc7\x58\xce\xc6\x1c\x0b\xf1\x13\x6c\xd4\xf9\x58\xaf\xb5\x13\x93\x9b\xd0\x0c\x47\xec\xe9\x59\xf3\xe7\x4d\x0f\x6f\x12\xe1\x64\xf1\xbb\x71\xb1\x2e\x18\x98\x41\xe9\xd7\x49\xf8\x75\x1a\x96\xc5\x3f\x2a\x6e\x05\x7a\x7c\x78\xbc\xa0\x31\x11\xe2\xbd\x26\x1b\xed\xb0\x38\x34\x16\xa4\x41\x3e\xbf\xc9\x46\x5a\xa8\x03\x97\xca\xd5\x2a\xa8\xac\x52\x4f\xe0\xdf\x28\xc1\x34\x0b\x97\xdc\x4a\x5d\x7a\x4a\x4a\x6a\x70\x51\x63\x52\x10\x4d\x17\xa8\xae\xe2\xa0\xd2\xc2\xc5\x2b\x4c\x3c\xb5\x6e\xcf\x5d\x9e\x95\xe2\xcc\x5b\x76\xf9\x56\xc0\x35\x2d\xf3\x47\x16\xc0\x93\x5e\xd1\x1b\xbc\x6e\xd9\x81\x5a\xc5\xad\x3f\x7c\x76\xe5\x9d\xc9\x11\x5f\x7f\x78\xf3\xbd\xd4\xbd\xad\x2b\xfe\x75\xfe\xf4\x6a\xe8\x49\x8e\x78\xed\x7a\xf1\x02\x74\xc2\x06\xb2\xf6\xd8\x4e\xc2\xa4\xd4\x3f\xb6\x3a\xe1\x32\x71\x2c\xab\x53\x02\xa0\xd3\x59\xac\x46\xb6\x45\x30\x92\xcb\x32\xa9\x77\x77\x76\xf3\xf4\x14\x71\x54\x8a\x68\x24\x22\x4b\x7d\xa6\x79\x82\x04\xe2\x60\x61\xc4\x53\x97\xb0\x94\xce\x1d\x38\xb8\x4d\x7b\x39\x21\x92\x5f\x60\xba\x3f\xdd\xab\xdb\xdb\x46\x8d\x76\xc4\x92\xd7\x4d\x94\xea\xc0\xf1\xa2\x7d\x8b\xff\x7d\x23\x10\x12\x25\x0a\x2d\xa5\x35\xe2\x7f\xdd\xa0\xd7\x9b\x28\xb5\x52\x49\x41\x9a\xa6\x28\x9e\x36\x90\x7e\x61\x5a\xa0\x51\xd0\x4a\xc8\xb1\x7a\x8b\xdc\x73\x2b\x45\xd2\x9f\xee\x60\x9b\xa1\x74\x35\x66\x78\xd0\xe3\x72\xc9\xbc\x1a\x12\x76\x1a\xa9\x4b\x70\x6a\xf7\x61\x03\xfc\xcf\x43\xcc\x74\xf1\xf4\x37\xf3\x99\x5f\x5e\xdb\x53\x7f\x78\x37\x69\x70\x06\xcf\xc0\xbf\xc7\x6c\xe2\xa7\xc9\x5f\x6d\x31\xf8\xd6\x5c\xf1\x36\xd2\xe3\x8c\xf4\x7c\xc4\xcf\x38\x00\xdb\x39\x17\x68\x4f\x14\x3b\xb4\x76\xbb\x91\xd3\xe9\x8c\x34\xf2\xb0\x1e\x9f\x87\xd2\x60\x0c\xed\x36\x5a\xec\xac\x8d\xb3\x58\x58\x1a\x1a\x11\x8d\xbd\x5e\xd0\x26\xa8\x60\x7a\xd1\xb0\x40\x92\xeb\xc0\x94\x2d\x98\x34\x31\x9b\xa8\x05\xa6\x29\x4e\xf1\xe9\xe2\x89\x66\x41\x78\x87\xf1\x77\x20\x3e\x5f\x70\x62\xc8\x57\x56\x6e\x69\x19\x3c\x60\x74\x25\x7f\x87\x7e\x34\xf3\xdc\x64\x7e\x84\x55\xfc\xf0\x0f\x0c\x15\x75\x18\x13\x8a\x01\xba\x91\x77\x5b\x2a\x17\xaf\xba\xc0\x0f\x73\xc5\xa8\x4f\x8a\xb7\xe4\x8b\xa8\x08\x6d\x3e\x7a\x45\x97\xe4\x0f\x8a\xe2\x50\xf4\x34\x5e\x5b\x3b\x18\x91\x88\x72\x1a\xad\x16\x23\x7b\xa7\x9d\x86\x36\x9b\xdd\xee\xb0\xbb\x34\x46\xa3\x55\x6b\x36\xab\xda\x05\xb3\x95\xd3\xb7\x08\x9c\x05\x68\x89\xe1\xca\x69\x7b\x6a\xaf\xcf\xd0\xcb\xa7\x17\x95\x50\xe5\x66\x5a\x63\x48\xd7\xf8\x72\x33\x71\x6c\x8b\xbf\xbf\xab\xd3\x91\xa8\xea\x77\x43\xdf\x0d\xe4\x0c\x89\x5f\x9b\x3a\x17\x0f\x1a\xd6\xab\xed\x30\x3a\x9a\x7c\xfb\x9a\x82\xd2\xc6\xca\x42\xea\xdb\x0b\xb7\x39\x62\xd7\x4e\xac\x2b\x12\x2b\x08\x4e\x73\xe3\xf3\xb2\x19\x1d\xc5\x3e\x8a\x20\xe9\x82\x41\xe2\x2e\x34\x07\xdb\xad\x2a\x70\x6b\xc2\x55\xa6\x0b\xf3\x4a\x60\xf3\x78\x0a\x01\x47\xf3\x76\x1d\x53\x5d\xc3\x45\x63\xd1\x58\xab\x50\x79\xea\xe2\xcf\x89\x12\x9b\xb7\xa9\xa2\x72\x4a\x25\x65\x57\xe7\xab\x7b\xa9\xd1\x0c\x35\x6c\x52\xc3\x6a\x35\xac\x54\xa3\x11\x51\xc8\x46\xa1\x16\x45\xa3\xc8\xe3\xb0\xd9\xcb\xeb\x9a\x6c\xa7\x2e\x7e\x99\x30\x14\x94\x35\xd9\x1c\x5e\x3c\xfd\x36\xc1\x01\x10\x56\x8f\x44\x75\xe0\x4d\x32\xd5\x16\x15\xd9\xb9\xe7\x8d\x92\xf2\x9f\x88\x75\x07\x09\x4c\x4c\x2c\xba\x54\x37\x46\x45\x96\x06\xec\x56\xf4\xf5\x50\x51\x13\xc0\x0b\xa2\x32\xd0\x19\xab\x20\x19\x05\xbc\xaf\x56\xa4\x23\x5a\xb1\x63\xfc\xd3\x8f\x7c\xfe\x29\x35\xfb\xf2\x4f\xce\x42\xb1\xc9\x08\x7b\x4f\xe9\x2a\x53\xcd\x98\x32\xae\x21\x3a\x62\xc0\xd4\x6a\x3f\xef\xdf\xfd\xc0\x9d\xbd\x66\x6f\x7e\xbf\x5f\x4a\x41\x56\x99\xf2\xee\xdc\x7c\xe8\x9d\x3c\x95\x6f\x9d\x70\xc5\x29\x1f\xf2\x4d\x43\xaa\x2e\x73\xb0\xbc\x71\x7c\xed\xa8\x45\x3a\xed\x6c\x7d\xc9\xe1\x8d\xfd\x2f\xeb\x1d\xa8\x4c\xdd\x9d\x3d\x8b\xce\xe0\x75\x94\xea\xd2\x80\xf6\xe2\x79\xba\x3c\xd5\x6f\xb9\x92\x37\x72\x9c\xdb\xee\xd0\x61\x7b\xe7\xf7\x3b\xcc\x28\xa4\xf4\x7a\xc3\x7e\xce\xe9\x71\x62\xf5\xe3\xe6\xdc\x7e\x37\xd2\x21\xd2\x09\xd7\x6c\x51\x28\xd4\x3d\x0e\x7c\x7d\x3c\x6d\xf8\x7b\xf6\xfe\x8a\x5f\x4a\x03\x60\x97\x0d\x29\x55\x21\x8c\xc1\x6a\xf8\x90\x8a\xb4\xbc\x0d\x61\x15\xfb\x53\x38\xa3\x0f\xb8\x29\xe2\x5f\xe7\xf5\xad\x7a\x84\x19\xd1\x14\x5e\x7a\xed\xa0\xda\xde\xe8\x31\xf6\x89\x4e\x63\x46\x3d\x94\x8c\xa7\x62\x62\x9f\xe4\xce\x58\xff\x8d\x9b\xe1\x5b\xeb\xdf\x1e\x95\xfc\x70\xb4\x8c\x37\x5f\xc1\xf8\x6b\x37\x3a\x4d\xea\xb0\xc0\xd0\x44\x9e\x49\xab\xa5\x5d\xac\x0b\xe3\x4c\xbb\x8d\x42\x24\x88\xec\xb4\x53\x14\x03\x18\x0b\x06\xd6\x1c\xed\x02\x6c\x37\x84\xa9\xcf\x6e\xbe\x9a\x83\x2d\x09\x6e\x89\xa6\x58\xe2\x49\xa8\x53\x19\xad\x90\xbb\xb2\x69\xa1\x15\x1e\xbd\x62\x41\xdb\xa1\xe3\x81\x3f\x1d\xb9\xef\xf5\x2b\xfe\xba\x63\xc7\xfd\x0b\xa6\x3c\x13\x1f\xb9\xd0\x5c\x28\x56\xa3\x2f\x9e\x7d\xf5\xcf\x4f\x1d\xc1\xfe\x76\x2b\x74\x7f\x70\xe3\x3e\xf1\x33\x31\x56\x46\x7a\x50\x62\xfb\x3c\x18\xdb\xb2\x00\xa8\x4f\x58\x00\xaf\x57\xa9\xb4\x3c\x0a\x3a\x1c\x21\x9a\xb3\x69\x6c\x18\x1c\x3a\x31\x22\x79\x44\xad\x6b\x72\x3a\x6d\x9c\x46\x96\xbf\x78\x69\x51\xea\xb8\xe5\x18\xdf\xdf\xda\xdb\x54\x13\xa8\x74\x1e\xcb\xaf\x39\xf6\x76\x17\x44\x6b\xe7\x6f\x88\xd4\x98\x2b\xc6\xb7\xec\xef\x84\x13\x7e\x6b\x6c\x97\xdf\x0a\x0b\x9f\x8d\xbc\x7e\x65\xd1\xbe\xff\xa4\xfc\x98\xf3\x74\x9c\xf6\x03\x2d\xf6\x64\x6a\x12\x2e\xb5\x95\xc6\xe8\xc8\xeb\x71\xbb\x7d\x3a\xa5\x43\xd9\x2a\xb8\x5c\x0e\x23\x0f\x5a\x05\x3e\xab\x39\x26\xe8\x41\xde\x24\x37\xfb\x8c\x4a\x5d\x30\xa1\xca\x2a\x37\xae\xcd\xab\xe2\x40\x01\xac\x89\xab\xe0\xc3\xa3\xaf\x1d\x11\x7f\xf3\xbb\xd9\xf0\x15\x38\xff\x8a\x8f\x36\xde\x77\x16\x16\x43\x16\x56\x37\xd7\x56\xf6\xd9\xf0\xe3\x35\x77\xaf\xbc\x08\xbe\xbc\xf9\x20\xf2\xa8\xb6\x9d\xbc\xed\x97\x1b\xde\x7b\x18\xaa\x61\xe1\x92\xb3\x44\x7e\x63\x58\x9e\x5d\x58\x7e\x6d\x60\x74\xc2\x6b\x31\x1a\x0c\x40\xab\xb5\x2b\x78\xde\xc1\x3a\x4a\x1d\xf5\x8e\xf9\x0e\x8c\x03\x2c\xac\x09\x6f\xb1\x91\x40\x3c\x56\x6b\x68\x32\x1a\x4d\x46\x9a\x92\x3a\xdb\x5a\xb3\x1a\xd8\x65\x41\xd6\x78\xb7\x0a\x8b\x98\x73\xac\x96\x2c\xa9\xc4\x72\x6d\x6a\x2c\x1f\xea\x28\x9b\x33\xb8\xa9\x4d\x3b\xf3\x3e\x2c\x9d\xd4\x09\x56\xfc\x7e\xb2\xe9\xfe\x71\xe1\x92\xfc\x6a\xb9\xcd\x91\x24\x93\x1d\x32\x1e\x93\xfc\x46\xf4\x1c\x70\x82\x86\x44\x50\xea\xff\x6f\x36\x1a\xed\xc8\xee\x72\xb3\xee\x63\x6e\x0a\x3f\x64\xba\xfd\x3f\x9b\xdb\xfe\x5f\x8e\x79\xd6\x76\x07\xa3\xb3\xba\xff\xa7\xd4\x2b\x89\x23\x91\xcb\x75\x0b\x47\xc1\x5b\x6e\x3e\xc2\x8f\x18\xce\xfc\x7b\x9a\x71\x42\x3b\x0c\x15\x46\xbc\x93\x97\x88\xe6\x13\x3b\x46\x4e\x83\xab\x1c\x31\x91\x1a\xdd\x38\x6d\x21\x65\x99\x7b\xdc\xde\xcb\xfd\xfc\x16\xf1\x2b\xf1\xb8\xb4\xbf\x62\x33\x5d\x85\xfd\x54\x27\x08\x83\xb6\x44\x51\x10\xf9\xbc\x2a\x95\xdd\xc6\x58\x74\x3a\x06\x5b\xa9\xbc\x08\x9b\x87\x0f\x8f\xcf\xa6\xb6\xb5\x08\x4a\xb5\x95\x71\x19\x5d\x00\xc3\x12\x4e\xc2\xc2\xf2\xfa\xd5\x67\x42\x5e\xdd\x11\xaf\x34\x9c\x92\xfa\xb7\x2a\xf0\xd1\x91\x1b\xfd\xe1\xd5\xa4\x2c\x9c\x0d\x1f\x24\x1b\x41\x59\xd5\x26\xfc\xf4\xa8\xe0\xaa\x4d\xe2\x77\xe2\x3f\x87\xce\x1e\x7a\xec\xa9\xd9\xa7\x57\x9b\xda\x16\x35\xbe\x30\xc7\xb5\x6e\x52\xcd\x00\x7e\xce\x91\xc7\x6b\xd1\xf3\xc7\x0e\x88\x6f\x8a\xa7\x8c\xe2\x44\x78\x97\xe1\xcc\x89\x7d\xbf\xec\x36\xd6\x7b\xb6\x7e\x73\xf5\x45\x10\xa1\xa6\xed\xde\xd2\x36\x73\x7e\x72\xaf\x16\xd6\x43\xf3\x82\xcb\xe5\x18\xfa\x04\xac\x03\x8e\x61\xb9\x08\x81\x8d\x89\x66\x3b\xeb\xd2\xeb\x75\x40\xed\xd1\x6a\x75\x4a\x48\x5b\x38\x9e\xe6\xdd\x3a\x5d\xc4\xe3\x72\xbb\xc3\x66\x0e\x1b\x36\xf3\x34\x35\x54\xaa\x21\x0d\xae\x06\x94\x5a\xcb\x42\xd6\x8e\xed\xb3\x9d\x05\x6a\x5a\xe1\xc1\x30\x52\xab\xd3\x69\x59\x05\x6c\x17\x08\xc3\xac\x2c\xe2\x24\x6b\x0a\x4f\x35\x05\x87\x27\xa6\xfb\x6d\xc5\x8d\xdd\xae\x77\xe6\xb5\xec\xf7\x40\x54\x42\xf2\xbc\xac\x36\xde\x44\xca\xb6\x21\xef\x25\xd9\x89\xd8\x35\x55\x52\x44\x0f\x2a\xe0\xd4\x6d\x9a\xea\x5a\xe6\x11\xde\x3c\xf7\x95\x15\x4f\xa9\x56\x89\x0f\x1f\x31\x14\x07\x98\xdd\x66\xe7\x9a\xbe\xe2\xc0\x27\x95\x9e\x11\x42\x47\x87\x00\x07\xc3\x4f\x02\xc5\xda\x98\xa1\x09\xaf\x45\xf9\xd9\xe8\x21\x31\x98\x3c\x57\x1a\x56\xc4\x4c\xd3\xe0\xbb\x63\xc5\x35\x0b\x03\xf9\xf3\xd6\x6e\xdc\xb8\x5e\xe2\xfb\x6c\x56\x58\xe8\xd7\x31\xbe\xbc\x3c\x51\x63\x32\x1a\x21\x6f\x36\x93\x7c\x19\xbb\xd6\x60\x60\x14\xd8\xb8\xbb\x5d\x0a\x97\xcf\xcf\xfa\x21\x6b\xc2\x1b\x6c\x72\x49\x6d\x41\xed\x1a\xd6\x6c\xa4\x8c\xad\x82\x97\xb2\xca\x6a\x27\x75\x44\x32\x18\x05\x4e\xcc\xed\x60\x92\xd5\x72\x40\xee\xa9\xd1\x43\x3e\xb1\xed\x27\x5a\x9e\x84\xe8\x28\x05\xc5\xce\x1e\xfa\x87\xb3\x86\x21\x58\x46\x27\xea\xd7\x4d\x3f\x37\xfb\xdc\x86\x7b\x9d\x33\x20\x60\x3a\xc6\x37\x8a\x4d\x62\x33\x3c\xb8\xef\xa6\x7a\x01\x3e\x84\x91\xdf\x9f\x47\x94\x09\x4b\xe9\x1d\xbf\xce\x41\x3b\xb7\x53\x03\x63\x8e\x64\x52\xdc\x42\xe8\x7c\x06\x5c\x3c\xaf\x68\x46\x4f\x83\x52\x30\x38\x11\x89\x7a\xed\x34\x5d\x8c\x31\x8a\xbe\x38\xe4\x55\x94\x95\x83\x72\x68\x47\xa5\xa5\x2e\x43\x90\xb3\xab\x0a\x5c\x05\x6d\x82\xd9\x65\xcd\xb9\xe5\x29\xcd\x16\xd3\x54\x9e\xa6\x81\x52\x99\x33\x45\xdd\x44\x99\x52\x24\x68\x90\x6e\x24\x6b\xaa\xae\xb1\xd1\x28\xd5\x83\xa5\xb2\x1e\xa2\x46\x83\xbb\x40\x23\x0c\xbd\x6a\xcb\x82\x89\xf6\xc3\xcf\x7c\xfb\xd2\xc4\x2b\x6c\xaa\xba\xed\x93\xb7\xef\x59\xf5\xf3\x5e\x95\xf8\x79\x9d\x6e\xcf\xa0\x8d\xf9\x1a\x35\xd5\xd9\x32\x6e\x99\x63\xe2\x92\x0b\x67\x6f\x78\x20\xda\xe8\xfe\xf2\xc4\x4f\xe2\x07\x1d\x13\x67\x8d\x7c\xe6\xbe\xfd\x90\xfe\x83\xb5\x71\xba\xf8\xd0\xf0\xf8\x2f\x8b\xa6\x9d\xad\xab\x24\x18\x67\xe0\xc5\xf3\xd4\x02\x45\x3c\x15\x8b\x52\x81\xd9\x17\x49\x23\x1a\xfd\x23\x14\xf4\x65\xee\x4d\xc9\xe7\x26\x63\x5d\xb2\x44\xfa\xdc\x72\x25\x30\x2a\xc1\xec\x7e\xf2\xa7\xaa\x33\xf1\xa7\x74\x4c\x0d\xdb\x7a\x12\xdb\x22\xb6\x5e\x8a\x81\x0d\x97\x63\x6a\x7f\x73\xfb\x8c\xf6\xee\x18\x98\x1c\xd3\xba\x33\x13\xd3\xaa\x05\x5f\xcb\xb1\xb2\xbd\x2e\x2f\xca\xfa\x9c\xb4\xee\x8a\x3b\xb9\x3c\xb4\x2a\xf5\xfb\x92\x58\x9c\xf6\x26\x2e\xd6\x24\xd6\xaf\x6f\xaa\x49\xac\x5b\x87\x87\xb5\x6b\xf1\xb0\x66\x0d\x1e\x56\xaf\xc6\xc3\xaa\x55\x78\xb8\xe2\x0a\x3c\xac\x5c\x89\x87\x15\x2b\xf0\xb0\x7c\x39\x1e\x96\x2d\xc3\xc3\xd2\xa5\x78\x58\xb2\x04\x0f\x8b\x17\xe3\x61\xe1\x42\x3c\x2c\x58\x80\x87\xf9\xf3\xf1\x30\x6f\x1e\x1e\xe6\xce\xc5\xc3\x9c\x39\x78\xb8\xfc\x72\x3c\xcc\x9e\x8d\x87\x59\xb3\xf0\x30\x63\x06\x1e\xba\xba\xf0\x30\x7d\x3a\x1e\xa6\x4d\xc3\xc3\xd4\xa9\x78\x98\x32\x05\x0f\x9d\x9d\x78\xe8\xe8\xc0\xc3\xc4\x89\x78\x98\x30\x01\x0f\xe3\xc6\xe1\x41\x10\xf0\x30\x76\x2c\x1e\x2e\xbb\x0c\x0f\xa3\x47\xe3\x61\xe4\x48\x3c\xb4\xb7\xe3\xa1\xa5\x05\x0f\x23\x46\xe0\xa1\xb9\x19\x0f\xc3\x86\xe1\x61\xc8\x10\x3c\x34\x35\xe1\x61\xe0\x40\x3c\x0c\x18\x80\x87\xc6\x46\x3c\x34\x34\xe0\xa1\x5f\xbf\xa6\x44\xdf\x9a\x44\x9f\x3e\xf8\x75\xef\xde\x78\xe8\xd5\x0b\x0f\x35\x35\x78\xa8\xac\xc4\x43\x79\x39\x1e\x62\x31\x3c\x14\x16\xe2\x21\x1a\xc5\x43\x28\x84\x07\xbf\x1f\x0f\x0e\x47\x53\x0d\xb1\x4b\x66\xbb\x1d\xbf\xb3\x5a\xf1\xc0\xb2\x4d\xf0\xb5\xb2\xb8\x57\x8a\x90\xfe\xef\x2e\xeb\x2f\x79\x81\x4f\x91\xfb\x78\x94\xc4\x7e\x89\x11\x44\xc9\x89\xe1\x2c\x74\x38\x1c\x50\x5a\xe8\x7c\xb5\xdb\x5d\x10\x50\x29\x55\xd8\x86\xab\x54\x26\x87\x43\xd7\x2a\x38\xa0\x09\x5b\x72\xd3\xa5\x7a\x77\xe7\x44\x37\x64\x7b\x1e\xa9\x09\x1b\x53\x01\x44\x4e\x11\xa4\x8c\x72\xfb\x3b\xb9\x3f\xad\x1c\xcc\x81\x3f\x0f\x5b\x33\x50\xbc\xa8\x87\xfd\x87\xb7\xae\x78\x75\x03\x54\xbf\xf9\xe7\x63\x30\xfa\xd0\x86\x23\xed\xdb\x5b\xa8\x25\x2b\x16\xbe\x32\x60\xea\x43\x0b\x7f\x54\x8f\xd0\xc0\xa5\x97\xcd\xf8\x5c\x1c\xfb\xaa\x38\x6c\x2c\x34\x42\xd5\x0f\xf0\x91\x1f\xf7\xad\x9e\x7c\x64\x09\xa7\xb1\xdf\xbe\x7e\xdd\x7b\xab\xf0\x3c\xb0\x9c\xd2\x83\x15\x9b\xf1\x2c\x2a\xc1\xf8\x44\x69\x38\x3f\x5f\xe5\xf4\x78\x6c\xe6\x12\xec\x95\x56\x61\x04\x55\x2d\x35\x74\x65\xf5\xe1\x8a\x70\xab\xa0\xa9\xa8\x30\xd2\x46\x3f\xb6\xfb\x56\xba\xb0\x55\xa0\xc1\x25\xfa\x47\xd7\xf7\x6c\x33\x9c\x2e\xf5\x4a\xe7\xa2\xca\xe9\x97\x74\xa8\x87\x42\x23\xfe\x8c\x54\x6a\x95\x4a\xd1\xed\x03\xfb\x41\xaa\xa4\x7d\xeb\xc8\xa9\x33\x34\xe6\x5e\x6c\xaf\xc6\x62\xf1\x87\xff\x93\x65\x88\x0f\x1d\x88\x0e\x2a\x5f\x79\x15\xec\x18\x59\xdc\x56\x36\x62\x7c\xdc\xa3\xa2\x0b\xa7\x1e\x1a\x3f\x6f\x4e\xe5\xd8\x55\xa3\xc4\x8d\xc9\x7f\x9f\xd8\x31\x49\xe8\x36\xd0\x47\x3f\x86\x37\xcc\x85\x60\xf5\xe0\x55\x43\x06\x0e\xbc\x47\xe6\xb4\x58\x2a\xdd\xbf\x36\x63\x7b\xd6\x90\x08\x18\x78\xab\xdf\xcf\x3b\x51\x58\x41\x51\x11\xbf\xd1\x85\x0c\xbc\x91\xef\x10\xf0\xd4\x98\x4e\x01\x21\x40\xa7\x63\x54\xf2\x2c\x4d\xb5\x3d\x23\x53\xa4\x45\xbf\x9c\x07\x4f\xa5\x2f\xb1\xb1\xea\xa3\xf2\x42\x35\x7e\x60\xc4\xb8\xcb\x54\xad\xa0\x67\x35\x45\xfb\xb8\xf4\xc5\xe5\x75\xb7\x6c\x5f\x17\xad\x7b\x5d\x9d\xbc\x45\xfd\xa7\x61\xfc\xbc\x17\x56\xab\xa1\x09\xd6\x51\x8a\xca\xc7\x3e\x55\x34\x47\xc5\x5f\xe7\xc7\xcb\x67\xbc\x29\x3e\xfd\x81\x78\x4c\xbe\x50\x59\x34\xf9\x2e\xa8\xda\x5a\x25\xbe\x26\x9e\x2f\x28\x7a\x16\xf6\x3e\x9a\xc9\x5b\x3a\xae\x68\xe6\xa2\x68\x03\xf8\x35\x2b\x6f\x49\xf5\x20\x8c\x22\x92\x38\x92\xba\x37\x38\xa9\xbc\x12\xeb\xa1\x0d\xa9\x7b\x83\x56\x38\x02\x68\x4e\x50\x30\xae\xc8\x93\xae\x0a\x10\x28\xc5\x76\xfd\x47\x2c\x03\x3c\xf6\xb2\x43\xa0\x39\x11\x35\xd3\x7e\x2d\xcf\xdb\x18\xe0\xc6\xd8\x8f\x46\xe1\x88\x1a\xf8\xec\x8c\xbd\x55\xd0\x32\x9c\xdf\x06\x49\x18\x05\x5a\xc1\x6f\xec\x58\x7d\xc6\x59\xeb\x06\x2a\x12\x40\x31\x49\xbe\xaa\x64\x02\x94\x2a\x2d\x24\xb7\x4c\x06\x2a\x82\xcd\x02\xea\x47\xc1\xde\x43\x6f\x7d\xf2\xea\x6f\xb7\xb5\xcf\x6b\xbf\xe3\xd4\x35\xe7\xb7\x0d\x7d\x71\xe2\x65\xdb\x2f\xdb\x35\x96\xea\xea\x1c\xb5\x6d\xcc\xae\x31\xd8\x7a\x1d\xa0\xdf\xbf\x6f\x1f\x34\xec\x55\xc0\x17\xc5\x1a\xf5\x3b\xf7\xec\x13\xff\xcf\x1d\xb4\xd8\x81\x98\x35\xdb\x54\xa8\x46\xb3\xe3\xa7\x55\x57\xdf\xa4\xbc\xf0\xa2\xfe\x96\xef\x24\x5f\x05\xc4\xb1\x4e\xbd\x43\xf2\xbd\xcb\xc1\xa8\x44\xcc\x61\x2c\x31\xc7\xa8\x22\x1a\xd0\x54\x50\x13\x30\x1b\x6d\xea\x8a\xb8\xcd\x1e\x08\x18\xec\x25\x94\xc5\x6e\x69\x15\xec\x6c\xbe\xd6\x65\x70\xb5\x09\x2a\x43\x96\x55\x93\xbd\x2e\x93\xdc\x80\xb9\x47\x03\x42\x55\xc8\xda\xd3\x9c\xd5\x10\x18\xcb\xa7\xad\x19\xc6\x22\x69\xe3\x17\x0d\x18\x28\xc5\x1d\xec\x4b\x1b\x53\x26\x6d\xdb\x94\xed\x7b\xd6\xaf\xb9\x69\x70\x6d\x9f\x4d\xb2\x45\x3b\xac\xd6\x0f\x26\x76\x6f\x53\xf2\x67\x61\x45\x3f\x74\x74\xd4\xaa\x77\x24\x9b\x36\x73\xd4\x33\xf7\x1d\x82\xaa\x91\xeb\xdf\x4e\xee\x97\x0d\x5a\x65\xcb\x49\x62\xf8\xde\x9d\x51\x7e\xc7\xfb\xc4\x66\x63\x8c\x49\xfc\x9d\x06\x70\x7d\xa2\xc9\x57\x5e\xee\x54\x2b\x95\xbc\xd3\xe9\x2e\x09\xf2\x75\xb5\x56\x6b\x55\x55\x0d\x0b\x40\x4d\x5d\xd0\x9d\xaf\x6c\xec\x5f\x5b\x81\xbf\xd3\xd0\xc0\x55\xb1\x3e\x5b\x79\x79\x7e\xbe\xab\xa8\x28\xdc\x2e\x14\x71\x2e\x0b\xd7\xaf\x5d\xe0\xac\xb4\x96\x28\x2c\x3a\xa7\xf3\x69\xfa\x64\x13\x5c\x52\x9f\xea\xab\x1d\xcf\x59\x8b\xac\x98\x4f\x6a\x69\x7a\x74\x40\x55\xc9\x29\xb1\x0a\x52\xc4\x1b\xc5\x2f\x88\x86\xcb\xd4\xcc\x48\xea\x20\xd2\x8f\xe4\x31\x9b\x59\x98\xc2\x02\xf4\xe0\x9a\x1c\xf6\x1e\xbd\xb3\x65\x98\xca\x2e\xde\xcd\x14\xd8\xef\xa6\x27\x4c\xf3\xaa\xa6\xd4\x0d\xd7\xd5\xd8\xaf\x1e\xdd\x32\x4c\xeb\x80\xa3\x35\x65\xe6\xbb\xe9\x67\x8c\xec\x54\xfc\x5d\x68\x10\x5f\x4e\x33\xfd\x0c\x41\x73\xe6\x06\x47\xde\xf0\x66\xe9\x8e\xb2\x41\x5d\x77\x0e\xba\x6f\x90\x77\xd7\xe8\xfe\xd7\xef\x9e\x3b\xaf\x68\xc6\x0d\xaf\xd5\xff\x21\x32\xe8\xad\xed\x53\xc6\xd4\xee\x1e\xdd\x5f\x96\x99\x19\x18\xd7\x91\x7c\x1f\x0b\x3e\x01\xfd\x12\x01\x8f\xda\xa2\xb4\x1a\x8d\x4a\x35\x16\x7e\x8b\xbf\x43\x50\x5a\x78\xbd\xa3\x43\xd0\xd3\xa9\xeb\x57\x17\xc8\x6e\xad\x5e\x94\xb5\x26\x52\x7d\x0c\x39\xfc\x79\x54\x76\x12\x8f\x0a\xe6\xe4\xf8\x50\xf7\xc9\x9d\xb8\xfb\xbe\xfa\x43\x3a\x7d\xe7\x41\xf1\x95\x97\xe0\x97\xdd\xc9\x3d\xe2\xed\xd2\xd9\x17\xfc\x30\xf0\x4a\x2a\x79\xe7\x2f\xe2\x95\xef\xf1\xa8\x35\x2b\xb5\x07\xa4\x7c\x0d\x12\x7f\x00\x26\xe0\x07\xbd\x13\x3e\x5e\x69\x44\x4e\xbd\x1e\x29\x51\x20\x68\xb4\xb6\x0a\xc8\x68\xd5\x78\xb0\xf2\xe6\x28\x53\x8b\x40\xb9\xb2\x7a\xb7\xf6\x78\x6e\x55\x20\x75\x5a\x53\xde\xb8\x74\x54\x33\xd9\xc5\x58\xaf\x8d\x67\xc4\x47\x87\x5d\xbd\x73\xd3\x4f\xbb\x0f\x9f\x5d\xfc\xe6\x86\xbe\x6f\xcc\x9a\x34\xfe\x50\xe7\xcc\xa9\xe3\xef\x9c\x24\xae\x8c\xc1\xbb\x5d\xaf\xde\x76\x00\x9a\x6e\x7f\xe7\xe4\xf6\x8b\xe0\x90\x49\xdc\x4f\x3d\xb3\xf1\xa6\xed\xc9\x6d\x37\xe0\x81\xe8\xdb\x75\xe2\x3c\xc5\x2c\x49\xdf\x56\x26\x1c\xc0\xac\x57\x2a\x35\x66\x14\xf6\x38\x9d\x11\x23\x52\xdb\xed\x78\x99\x5d\x2e\x3b\x9d\x12\x40\xee\xb9\xda\x9e\x2a\x36\x75\x9b\x21\xa5\x39\x57\x55\x62\xe0\x9f\x5e\x62\xac\x7a\xab\x88\xea\xa5\x29\x38\xfa\xe4\x1f\xbf\x39\x76\xec\x39\xae\x6b\x5e\xdd\xd2\xb3\xaf\x7f\xf3\x0a\x5c\xf6\xcf\x37\xbe\x88\x35\xd4\x1f\xeb\x3c\x2a\xfe\x63\x0f\xb5\x60\xf3\x73\xfd\x46\x6c\xba\x6c\xf1\x9e\x9a\x06\xdf\xb8\xc1\x79\xb5\xd5\xfd\x12\xd0\x7c\xf2\xcf\x70\xca\xb3\x71\xf1\xc3\xfb\x8b\x4a\xef\x13\x5f\x93\x7d\xcb\x1a\x71\x17\xda\x48\xdb\xf1\x8a\xe2\x67\xa5\xed\x26\xad\x96\xb5\xa3\x80\xc7\xe7\x0b\x32\x16\x83\xdb\xeb\x76\x63\x8b\xee\x66\x53\x52\x70\x89\x67\x0d\xa6\xc2\x4f\x59\x0f\x9c\x8e\x22\xf4\x21\xde\x39\xb5\x6b\xf5\x93\x4b\x4a\xa7\xad\xea\x9a\x72\xef\x1f\xb8\x99\x97\xb7\x8f\x7c\x70\xef\x01\xe8\x3d\x3e\x69\x58\x6d\x25\x1a\xbb\xfc\x1f\x57\x27\x46\x56\xbb\x6c\x93\x86\xcd\xb8\xa3\xb4\x36\xdc\xd6\x58\x59\x6d\x0c\xed\xdb\x70\x37\xf4\xec\x9f\xf3\xb4\xec\x8b\x91\xfc\x93\x1f\xa5\x7c\x93\xd1\x89\x22\x95\x5e\x6f\xd2\x32\x26\x86\x43\x00\xd8\x38\xab\x92\x87\x90\xb7\x60\xe3\xa5\xd2\x91\x7c\x3e\x95\x8a\xb3\x20\xbd\x89\x33\x75\x08\x9c\x09\x64\xec\x57\x69\xca\x3f\x27\x57\x9d\x99\xa4\xbe\xac\x73\x2c\xa5\x9a\xa0\x00\x3e\xb6\x81\x4c\x4e\x16\xfd\x63\x6d\xa3\x72\xce\x3b\xe2\x0f\x53\x29\x47\x71\x5f\x24\xf6\x9f\xf0\xa1\x26\xf9\x8c\xe6\xe0\x1b\x77\x6b\x14\x7d\x49\xa2\x49\xf2\x8d\x0b\x07\x93\xff\x4a\xa7\x60\xe1\xe7\x4c\x4a\xb2\x79\x14\xdb\x16\x6c\x57\xf4\x1a\x0d\x79\x44\x8b\x8a\x65\x39\xce\xac\x35\xa8\x0c\x58\x2c\xf1\xe3\xf1\x50\xc9\x63\xbc\xc4\x1b\x5b\x04\x9e\xe5\xa4\xb0\x60\x2a\x0d\x24\x3b\xa5\xc1\x18\xcf\x72\x2e\xc8\xe3\x15\x41\x14\x97\x52\x91\x42\x52\x64\x19\x3d\x5b\xd3\xa8\x9c\xf5\xfe\x75\xd3\xff\x56\xd7\x77\x48\x5f\xf4\xb7\x05\x87\xff\x76\x15\x83\x8e\x8a\x67\xf0\x63\x9d\xdd\x2f\xce\x3e\x98\x5c\xaf\x70\x3a\x62\xf2\xfe\x62\xd4\x4e\x43\xa9\x5f\x2a\xde\x5f\xa3\xd9\xac\x53\x2b\x18\x06\x58\xd4\x16\xbb\x43\x7d\xa3\x19\x9a\xcd\x34\x8b\x68\x13\x69\x01\x57\x4b\xda\x7c\xa6\xf2\x88\xba\x33\xa4\x48\x15\x46\x94\x04\xdc\x78\xb9\x63\xa9\xcd\xac\x42\x01\x7c\xe4\xec\x43\x98\xd3\xa8\x71\xdd\x85\x7f\xef\xab\x1b\xa2\xc2\xaf\x16\x20\xf5\xfd\x7d\xae\x19\x6a\x88\x05\x87\x1e\x82\x8d\x70\xf7\x9e\x72\xf2\x7a\xc8\x21\xf1\x73\x31\xb1\x1b\x3f\xc7\x32\x00\x50\x1b\xb6\xbd\x2a\x10\x4e\x60\x8f\x1e\x3f\x13\x64\xd4\x0a\xc2\xc9\x0a\x90\x45\xfe\xe7\x73\x7a\x8c\x04\x48\x2e\x16\x8c\x83\x8b\x54\xbb\xf8\xf1\xa4\x9f\x93\x47\x61\xe5\x24\xea\xab\xa4\x8d\x5a\x89\x88\x1f\x0a\x9a\xc5\x81\x8a\xcb\x14\xb3\x41\x10\xd4\x25\xbc\x2a\x26\x08\x68\x97\x0b\x9b\x72\xc0\xe8\x14\xa1\xb0\xcd\x8d\x2d\x84\x97\x84\xc8\xb5\x2c\xd6\x16\xf5\xcf\x55\xd4\x12\xdd\x4e\x6a\x71\x7a\x58\xb8\x00\x8f\xb5\x32\x15\xc1\xeb\x4a\x22\x60\x44\x8b\x99\x2c\x66\x0d\xc4\xaf\x49\x80\x4e\x2a\xd8\xa1\xaa\x2f\x0b\x7c\xbc\xfb\x21\xf1\xca\xf1\xd3\xc6\xed\xdc\xee\xdc\x0a\x95\x9b\x3f\x86\x2d\x8f\x4e\x7f\x68\x76\xed\xaa\xeb\x4a\xf2\xa7\x5d\xe7\x9a\x0e\xff\xfe\xc4\x8f\x76\x18\xe3\x93\x49\x0a\xb0\x13\x86\x8c\x6d\x7a\x49\xbc\xfe\xbb\xbb\xc5\x9b\xc4\x3b\xd7\xf9\x9e\x81\x8f\xbd\xba\x20\x39\x7a\xd7\x9e\xe4\xb3\x40\xe2\x6c\x6d\x44\x9f\xd1\x06\xe0\x06\x4d\x89\x7c\xa7\xcd\x8c\xc5\x04\x1f\x39\xab\x5b\xa1\xf0\x78\xcd\xb6\x36\xc1\x89\xcf\x9b\xc5\xe0\x72\x9a\xf1\x1f\x03\x45\xa9\xda\x04\x9a\x4a\xdd\xf4\x92\xd3\x47\x18\x38\x48\x18\x39\x35\x0d\xf9\xf6\x26\x4d\xe9\x49\x9e\x9d\x22\x8f\xde\x17\x46\x15\x51\x88\x15\x07\x8c\x52\x67\x6f\xba\xb8\x69\x33\x77\xe2\xe5\x13\x50\xb3\xfd\xa9\x4d\x25\x53\x97\x43\xd1\x1b\x84\x3f\x6b\xf2\xb8\xe4\x7f\x42\xd4\x47\x67\x83\x7d\x5a\x6e\x13\xdf\x3f\xfd\x47\xd1\x75\x38\x70\x33\x5c\x75\xd4\x9f\x77\x61\x0c\x64\x1a\xe6\x39\xc4\xef\xc7\xe0\xe7\x1d\x2b\x0e\x52\xce\xc4\xf2\x33\x08\x2c\x4b\x44\xf4\xae\xa8\x6b\xd0\x20\x10\x2b\x2f\x2f\x8c\xf6\x0e\xd4\x44\x6b\x06\x03\xd0\x34\xa8\x57\x71\x71\x61\x87\x50\x8c\x5c\x81\x40\x43\x3c\x1c\x3f\x05\x9d\x8f\x08\xde\x30\xaf\x77\x1b\xd5\xa7\xa0\x23\xa1\x11\x8c\x46\x9a\xb6\x75\x0a\xb4\x3b\x1d\xef\x95\xef\x54\x64\xe0\x91\x41\x20\x30\x37\xf8\x21\x9b\xdb\x8c\xa1\x4d\x95\x94\xd7\xc8\x55\x76\x32\xa7\x16\x2f\x63\x92\x4c\x50\x98\x5c\x0b\xc9\x95\x77\x24\x64\x10\x47\xe4\x3e\x51\x7e\xad\x9c\x79\x3e\xef\xfb\xe3\x9b\x76\xb4\x2c\xad\x1b\xb8\x22\x1c\x0b\xf6\xda\x5c\xd7\xb4\xb1\x79\xc4\x92\xba\x8e\x19\x96\x41\x6d\xaf\x8c\xed\x5a\xd0\x72\x76\xfc\x94\x05\xae\x5b\xd6\xaa\x61\xff\x43\x1a\x6e\x5a\xe5\xce\xd9\xda\xfd\x4f\xdf\x49\x6b\xd4\xca\xd9\xd5\xb7\x5e\xae\x39\xa0\xe8\xfb\xcb\xab\x7f\xfa\x7a\x40\xc8\x3f\xb0\xf1\xb4\xc7\x97\x5f\x14\x8b\x4e\x5b\x08\x17\x2e\xbe\x61\xfd\xda\x45\x37\xae\x5a\xd6\x70\x23\x6a\x76\x56\x5d\x98\x5a\xb1\x8a\x5f\x32\x7b\x7b\x3d\xda\x79\x61\xaa\xbd\xb6\x2a\xa6\x5f\x32\x6f\x5b\x1d\x22\xbc\x42\xc0\x80\xe5\xf5\x0a\xac\x1f\x1a\x48\x0e\x50\x71\x69\x69\x41\x5e\x2f\x7f\x95\xde\xe9\x6c\x68\x00\xa0\x2a\x0f\x35\xf6\x6f\xa8\x66\x8b\x0a\x5a\x84\x22\xd6\xe9\xf7\xd7\x95\x87\xca\xdb\x05\x4f\xc8\x8a\xd7\x50\xd3\x26\xad\x1f\xb6\x6f\xbf\xbf\x7e\xc4\xc6\x75\x0b\x76\x6d\x76\xdf\x5b\x69\x71\xa4\xd5\x4b\x2d\xde\x7f\x59\x3b\x65\xf7\xd2\x65\x5e\x2a\xae\x38\x1a\xfa\xcb\xd1\x3e\x2b\x06\x0f\x59\x51\x77\x68\x58\x2c\xd0\x7b\x63\xed\xe6\x1b\x9b\x67\xd6\x4c\x5e\x60\xad\x1f\x7a\x74\xe8\xd8\xc9\x4d\xf7\x35\x8f\x9e\x6c\xec\x9c\xcf\x40\xc7\x0c\xeb\x65\xc5\x57\x4c\xd5\x4c\x3d\xdc\xe5\x18\x5f\xbc\x16\xbf\x40\x47\x2f\x94\x9c\x7e\x3b\x18\x0e\x07\x6f\x7c\xc2\xeb\x1d\x55\x92\x37\x75\x01\x1c\xd3\xb5\x70\xee\xdc\xae\x25\xb3\xba\xf2\x26\x50\x25\xf6\x58\xf2\xb1\xc5\xf1\x69\xa3\x36\xd4\x52\x89\xe4\x63\x1b\x42\xd3\x2e\xdb\x50\x43\x25\xc8\x7a\x61\xc9\x52\x50\xd8\x86\x46\xc0\xa4\x84\x95\xe7\x38\xbb\xd7\xae\xa1\xbd\xde\x90\x26\x84\xb1\xa8\xd7\xeb\x47\x2e\x92\x31\x9d\xb0\x0a\xf8\xdc\x43\x03\x49\x39\x34\x1a\x0d\x74\x58\xce\xe5\x36\x65\x85\x66\xd3\x3e\x9b\xb4\x46\x39\xed\x87\x64\x0d\x2b\x25\x75\x67\x95\x70\x66\x75\xd6\x26\xed\xeb\x53\x09\x94\xb4\x25\xf9\xb6\xe6\xb9\x71\xb3\xee\x6f\xbd\xf7\xd1\x39\xe7\xe6\x4d\x6e\x2f\x6c\xa0\xbd\x89\xce\x99\x4b\x57\x6d\xdf\x32\x6b\xb1\x1a\x7e\xae\x39\xfe\xc6\xdd\x18\xc5\x5c\x2c\xcf\xbf\x77\xef\x96\xef\xb6\x05\xbe\xbf\xa1\xfc\xb5\xc7\xae\x5a\x5b\x4d\x0d\x4d\xe5\x55\xe2\x39\xcd\xc0\xea\xee\x17\xec\x4b\x87\x41\x6b\x22\xdf\x6c\x34\x3a\xfd\x4e\xad\x12\xf8\xfd\x01\x6d\x20\x92\xe7\x07\x6e\xa6\x5d\x50\x62\x83\xcb\xb2\x78\xb3\x79\x16\x82\x60\x8b\x00\x2c\xb9\xe9\x11\xd2\x3c\x32\x93\xe8\x9e\x05\xd6\x63\x28\x55\x00\x6a\xaa\xce\x0a\xdf\x5b\xba\xeb\x60\xa9\xf1\x83\x11\xa3\xd5\x2a\x1e\xde\xb4\x63\xf3\xc6\x6f\xd6\x8f\xe8\x17\x2e\xb7\x7b\xca\x13\xd7\xb4\x3e\xd4\x70\x6b\xf1\xb5\x87\xbf\xbd\x83\x81\xbb\x0c\xc5\x65\xa5\xc6\xf5\x47\xef\x3f\x06\x0b\xef\xe7\x5f\x5d\x65\xd9\xfd\xf3\xb6\xff\x53\xe8\x43\xf4\x2f\x8f\xa6\xec\xc9\xc5\xf7\x24\xbd\xdb\x17\x7b\x1c\xf3\x12\x5c\xb1\xdf\x1f\x71\xe0\x2d\xd2\xc7\xf5\x15\xc5\x9e\x12\x0f\xd9\x11\x87\x50\x52\x12\xca\x2f\xca\xcb\xcf\xeb\x10\xf2\x91\x3f\x12\x8a\x74\x08\x21\x93\xde\xcd\xa5\x94\x01\xc7\xd1\xb4\xe5\x37\xca\x20\x27\x27\xd2\x9e\xb9\x03\xc8\x36\xd4\x18\x5c\x66\xe9\x81\xea\xb4\x24\x9b\x08\x42\xc2\xd2\x9d\x93\x4f\x2d\x5d\x75\x2a\x2e\xbb\x47\x7c\xeb\xd4\xda\x95\xf5\xb3\xfb\x0e\x5e\x13\x8a\x05\x17\x6d\xd8\xb1\x7a\xe0\xe4\xca\x95\xaf\x2d\x12\xee\x9a\x3f\x7f\xe3\x4c\xec\x96\x9e\x66\x8e\x9f\x3b\xcc\x50\x8d\xea\x0f\xc7\x3f\xf2\xc4\x9a\x67\x66\xc3\x31\x7f\x15\x77\xbf\x38\x20\x18\x18\xd4\x70\xba\x6e\x64\x69\xe4\x3e\x58\xfc\xc8\xea\xe7\xe6\x54\x26\x8f\x65\x65\x5b\xff\x6b\xda\xba\xcf\xa5\xbb\xa2\xa7\x48\x2c\x0d\xbd\x0e\x0a\x40\x1c\x4c\x49\x54\x97\x47\x8b\x83\x94\xca\xaf\x56\xa8\x55\xc1\xa8\xc2\x5a\x65\xad\xb4\x9b\xda\x84\x42\xec\x7d\x04\x8b\x55\x54\x31\x55\x68\xc7\x7f\x80\xd5\xa2\x77\xb7\x0b\x7a\x2b\xcd\x81\x92\x36\x81\x84\xc1\x33\x6d\xe0\xe5\xc6\xe3\xf2\x94\x8b\x8a\x7e\xdb\x82\xb5\xc2\x56\x5d\x63\x53\xaa\x24\xcc\xda\xbd\x14\x64\x25\x52\xe8\x35\xcd\xac\xc0\x57\xd4\xa4\x44\x18\x3e\xfa\xec\xec\x42\xff\x80\x70\xef\x8a\xf5\x1f\xad\xed\x68\x2a\x2c\x30\xf9\x0a\xec\x0d\xd5\xd7\x34\x0c\x18\x30\x70\xc0\x95\xcd\xcc\xf6\x7b\x17\xad\x7b\xaa\xfe\xc0\xb2\xde\x77\x4d\x5a\xdd\x8a\xce\xac\xec\x37\xc8\x33\x6e\xf4\x94\xf5\xb7\x8b\x17\x76\x0e\xce\xf7\x96\x37\x7d\xd1\xaf\x7e\xde\x93\xcb\x7a\x57\x2c\x9b\x26\x2c\xbc\x55\xbc\xbf\x63\x6b\x6b\x5d\xac\x3a\x75\x77\x42\x7b\xf0\xf9\x2c\x02\xc3\x12\x79\x1e\x64\xe0\x42\xf9\x6a\xab\x35\x9f\x43\x74\x71\x4c\xe1\x72\xa9\x01\x3e\xb3\x3c\xaf\xeb\x10\x78\x3a\x0f\x00\x0c\x79\x01\x9f\x5b\x60\x91\x8e\x6e\xe7\x5e\x7b\x4a\xca\xa8\x18\x56\xa7\xfb\x72\xf2\x29\x6a\x5e\x48\x2b\x52\xd1\x13\x82\x42\xa4\xef\xc0\x77\x5e\x7f\x5f\x0d\x87\xc1\x96\x6d\x0b\xe7\x6c\x98\xd6\xaf\x31\x76\xfb\x83\x4f\xbc\x88\xb7\xfc\x0b\xf1\x7d\xe6\xaa\x2d\x7b\x1e\x72\x96\xad\xda\xf0\xb9\x79\xff\xde\x68\x6c\xc1\xc9\x57\x77\x2e\x59\x5b\x79\x17\xa4\x0a\x8f\x1e\x98\x7e\x74\xc7\x96\xb9\x79\xde\x79\xf3\x6f\x5a\xda\xbf\xa2\xb6\xef\xba\xd1\xbb\xc7\x92\xf9\x6c\xc1\x7b\xf9\x2f\x7c\x36\x83\x60\x70\x22\x0c\xb4\x56\xbb\xd1\xeb\x55\xd8\xb5\x74\x28\xac\x0f\x06\x8d\x8c\xcb\x6e\x77\xb9\xcc\xad\x82\x0b\xd2\x4c\xee\xed\xcf\xef\xcc\x06\x6f\x17\x97\x7d\x63\x99\x35\xa7\x74\xaf\x51\x5a\x01\xfb\x5f\xb8\x6e\x9d\xa9\xee\xd1\xf9\xc7\x4e\xaa\xa0\x19\xba\xd7\xcc\x9e\x36\x67\x42\xdf\xf2\xc8\xf6\x2b\x4f\xbe\xb4\x51\xfc\x51\xfc\x1c\x0a\xe2\xaf\xe1\xda\x40\xc5\x43\xf7\x87\xaa\x67\x3d\xfe\xd7\x7b\x56\x5d\x55\x32\xff\x35\xdf\x13\x7b\x77\x7e\xf9\xcc\x15\xb2\x3f\x17\xc6\x7a\x72\x1e\xde\x87\x3c\x2c\x85\x53\x13\x91\x7c\xad\xc5\x16\x65\x7d\xca\x02\xb5\x5a\xc9\xda\xb4\x8a\x42\x18\x89\x14\xb1\x51\xa5\x2f\xea\xd3\x3a\x81\xcd\xe6\x44\xbc\x93\xc7\x07\xf1\xa4\x10\x72\xd2\xda\x7c\xa9\xe8\x44\x6b\xca\xe8\x18\x90\x49\xb5\x92\xbe\xe6\x74\xa9\x49\xcd\x2a\x2a\x4d\xc2\x6a\x22\x37\xf2\xd5\xb0\x46\x92\xc2\xd4\x46\x79\x29\x9b\x6c\x62\x10\x29\x52\xb9\x60\xcf\xaf\x9d\x7f\x63\xe7\xc8\x43\x93\x98\x5f\xef\x67\x36\x43\xe7\x81\x91\x25\xfd\x2a\xe3\x65\x63\x1b\xca\xa6\x2d\x1d\xb3\xb8\xad\xb7\x77\x5c\xfb\x5d\xd3\xc7\x4f\x2c\x4f\x4e\x12\x47\x50\xb7\xd0\xae\xfb\xdd\x2f\x5c\xfb\x27\x71\xc0\xdb\x25\x25\xc7\xe0\xd5\x7f\xf9\x7c\xed\x40\xf7\xfd\xd0\xe6\xac\x18\x7b\xc5\x90\x95\xf3\xa7\x3b\xc5\xaf\xc4\x53\xc9\x3b\xa4\x39\x97\x60\x4c\xbb\x0c\xfb\x81\x21\x3c\xeb\x89\x89\x32\xb3\x35\xa2\x0d\x1b\x3c\xaa\x3c\xec\x02\x18\xb4\x56\x8c\x7c\x82\xc1\x7c\x43\x58\xe5\x09\x7b\xb4\x0e\x60\xb5\x3a\x90\xc9\x61\x6a\x15\xfc\x0e\x4e\x1b\x69\x15\xb4\x96\xff\xed\x6c\x95\x2c\x94\x67\xcb\xa3\xd4\x64\xa5\x1d\xf4\x41\x49\x09\xa9\x20\x0a\xd0\x21\xde\x5f\x55\x33\xb9\x7c\xfb\xc6\xc1\xca\xe4\x58\xe5\x9a\x17\x66\xda\xab\x4b\x0a\xf2\xfa\x94\x86\x1b\xc7\x2e\xbd\xbe\xb0\xf8\x86\x05\x47\xc6\xd6\x85\x93\xb7\xbe\x03\x13\xd4\x97\xf3\x6d\x7d\x06\xbe\x26\xde\x71\x7b\x20\x70\x07\x34\x41\xef\x80\x3a\xdb\xfc\x97\xf8\x05\x0b\x16\x3f\xb1\x8b\x7f\x49\xdc\x2e\xbe\x2b\xef\xeb\xc4\x8b\xe7\x15\x2f\x2a\x9e\xc2\xfb\x5b\x09\xc6\x25\xb8\x0a\x03\x53\x5c\x6c\x31\x58\x82\x55\xc1\xea\x80\xd7\x2b\x15\xe6\xb0\x82\xd7\xc9\x44\xb4\x58\xbf\x6a\xb5\x26\xa7\x53\x41\xf4\xab\x5a\x70\x7e\x64\x2a\xed\x10\x4c\x7c\x8f\x20\x6c\x3a\xb3\xbc\xa7\x56\x4d\x51\x7b\x90\x6d\xa3\x89\xff\x1e\xf2\x03\x23\x36\x21\x61\x59\xa9\x48\x1c\xc1\x0a\xfc\x73\x83\xec\xd0\xe3\x9f\xe5\xd1\x8f\x26\x84\xd6\xcb\xea\x6e\xfa\x69\xe0\x15\xe2\x8a\xef\xa1\xe9\x41\xf1\xd4\x9b\xe2\xf7\xe2\xb9\xd5\x7f\x83\xf9\x5b\x06\x8d\x1a\xd9\xb7\x63\xbd\x27\x16\x5e\x2c\xea\x57\xfd\xba\xc0\xab\x57\x3c\x75\xf2\x67\xa8\x7c\x90\x7e\x88\xb7\xf2\xe7\x1e\x69\x6b\x3d\x7f\xee\x94\xf8\xcd\x4e\x0c\xef\xd1\xbd\xb0\xec\xcb\xab\x59\x76\x44\xed\x2b\x89\xff\x8c\x6b\x5d\x30\x7c\x48\xe4\xad\xf7\x48\xd5\xe2\x91\x3f\x90\xf3\x48\xee\x8d\x2b\x68\x1f\x28\x06\xc3\x13\xf9\x61\xbb\xd7\x5b\x60\x47\x05\x48\x1f\xd3\x97\xe4\x05\x5a\x85\xbc\x3c\xa0\x52\x73\x6d\x02\xf6\xf9\xf0\xa1\xd4\xa9\x58\x72\xa7\x98\x95\x4a\x08\xe2\x99\x89\x67\xcd\xd7\x94\x49\x20\x0c\xc7\x7d\x50\x9e\x1c\xd6\xa3\xdd\x64\x09\xf2\x11\x95\xb0\xb4\xac\x62\xde\x7c\xe2\x83\x6d\x90\xda\xd7\xd1\xd5\x34\xc7\x13\x0b\xb6\x8c\xaa\x1d\x32\xa4\xd7\xdc\x7b\xa6\x2e\x5f\x7c\xcd\x9d\x4b\xe6\x8c\xec\x6f\x98\x7e\xfd\xad\x0f\xac\xfa\xb3\xf9\xd5\x53\xb7\x43\xd5\xad\x4a\xe5\xa0\xda\xd3\xc5\x26\xe3\xb5\xff\xd9\xb2\xfe\xfa\xbb\xaf\x9b\x36\x93\xaf\x2e\xbe\xe3\xda\x19\xc7\xa6\x12\xbb\xf9\x0b\xb6\xfd\x5b\xa4\xbc\xf8\x31\x89\xe2\x88\x56\xeb\xe5\x38\xa7\x0a\x80\x02\xb3\xd3\x99\x1f\xf6\x05\x7c\x1d\x02\xb2\xa9\x4d\x1e\xec\xbb\x46\x6c\x1e\x8f\x21\x80\xb4\x52\x85\x81\x21\xdb\x91\xad\x8d\xe7\xee\x63\x3c\xeb\xba\x59\xa6\x5d\x94\xfc\xef\xa2\x74\xc1\x07\xe9\x1c\x65\x53\x49\x99\x23\xd8\x17\x4f\x15\x06\xa0\x2d\xcb\x96\xda\x06\xd7\x1d\xec\x77\xe7\x61\x26\xf9\x15\x73\xfc\xce\xba\xb3\x4d\xfe\x61\x23\xd6\xad\xb8\xc1\x87\x2d\xa1\x83\x79\xd0\xb7\xf9\x0c\x7a\x34\xb1\xb8\x21\x56\xdc\x54\xd4\x71\xa1\x93\x18\x3e\xb4\x7f\x59\x4b\x7d\x34\x3e\xbb\x71\xd8\xb0\x13\xc4\x04\x9e\x00\xe9\x5a\x10\xea\x07\xec\xd3\xb1\xa0\x6f\xc2\xab\x87\x90\xa1\x95\x34\x65\x30\x18\x29\x4e\x4d\x7a\xf6\x60\x4f\x57\xaf\x62\x29\xba\x3b\xf9\x38\x1d\x3e\x85\xd9\x37\x9d\x04\xa5\x4a\xe5\x29\x35\x01\xe9\x9a\x2f\xa0\x82\x7f\xda\x25\x3e\xca\x1c\xba\x41\xfc\x17\x0b\x35\xa3\x61\x11\xb3\xa9\x09\x6a\x58\x34\xf6\xc2\xdd\x31\x7c\x96\x47\xc1\x4f\x63\x0e\x71\xfa\x28\xd9\xbf\x1d\x40\xe2\xfa\x58\x17\x54\x82\xb9\x89\x5a\x85\xcd\x86\x1f\xc9\xcc\x94\x04\x7d\xe5\xe5\x2e\x97\x27\xdf\x13\x64\x28\x83\xb2\xaa\xda\x67\x2f\xaf\x50\xd8\xca\x6d\x45\xc6\xfc\x7c\x39\x1e\x68\x75\xb1\xf8\x49\x8d\x9a\x76\xc1\xc8\x41\x4b\x2a\x41\x87\x64\xa2\x64\xeb\xf3\xf8\xef\x84\x01\x09\xe0\x22\x51\xbe\x7a\x58\xfd\x3f\x45\xf9\xe2\xe9\xeb\x7f\x12\x1a\x84\xb5\x24\xb2\x67\x65\x7f\x3f\xb2\x57\x63\xbb\x4a\x48\x87\x01\x49\x38\x6f\xcd\xd8\xde\xbf\x13\xce\xbb\x7a\x6f\x3a\xee\x27\xe9\x8b\x98\x38\x10\xbd\x89\xd7\x21\x08\xca\x48\x5c\xaf\x90\x05\x21\x95\xca\x01\x50\x79\x85\xd9\xb7\x4c\x30\x6b\x5d\x6e\x43\x4c\x1b\xc3\xea\xcf\x4a\xe7\x61\x57\x82\x03\xf5\xd9\x31\xfe\xee\x00\x19\x29\xfa\xe2\x52\x37\x31\x72\xe5\x7d\x48\x4e\xaf\x45\x12\xaf\x57\x29\x2c\xa1\x60\x65\xf7\x89\xe9\x07\x63\xd7\x42\x78\xec\xc8\xd9\x4d\x3f\xef\x9a\xb3\xc5\xa2\x62\xe7\xdc\x39\xe6\x6a\xa1\x04\x55\x68\xa6\x4c\x59\x7a\xfd\x8e\x46\xea\xa7\x99\xd3\xc7\x1f\x9c\x34\xab\x73\xdc\x5d\x93\xaf\x87\x0c\x5c\xf2\xf4\xfb\x0f\x1e\x14\xff\x71\xfb\xdc\xce\x65\xf5\xf3\x27\x9a\x34\xa6\x70\xbf\xea\x98\xd5\xa5\xd6\xe8\x67\xbe\x4a\xdd\x7c\xfd\xd6\x9b\x93\x37\x5f\xb7\x65\xbb\x28\xef\x6d\xaa\x56\x1f\x38\x09\x67\x80\x01\xa8\x2c\x00\xb9\xdc\x66\xbb\xdd\xd8\x26\xd8\xad\xb4\x86\x70\x06\x70\x97\xe2\x0c\xe0\xe5\xd0\x9e\x4d\x95\x75\xb2\x53\x96\xb8\xef\xd5\xdf\x6c\x9b\x78\x6f\x4d\xc9\xf2\x2d\xb9\x84\x01\x70\xc9\x01\xc8\xdf\x31\x66\x58\xe1\xb4\x5c\xbe\x80\x8b\x11\xb1\x99\x52\x49\xf5\x5a\xc3\x73\xeb\xb7\xe8\xdd\x39\xcf\xe8\x05\xf5\x89\x80\x49\x0f\x1c\x06\x80\x7c\x2a\x95\x5f\xcf\x61\xe9\xd7\xd3\x76\xb7\xdb\xd2\x26\xb8\x2f\xf1\xb4\xa6\x8c\x76\x4a\x35\xfb\xcb\x7e\x6a\xa5\x2a\xa0\x0a\x28\x7f\xe7\xc9\x17\xdf\x1b\x85\xbd\x0c\xe2\x0b\xca\x4b\x3e\xff\x03\x07\x5b\xe3\xb1\xcc\x0c\x72\xb8\x17\xa4\x67\x04\x1a\x1b\xf2\x79\x11\xc7\xf9\x21\x68\x15\x20\x34\xeb\xcd\x2e\xbc\x9e\x66\xab\x5a\xaf\x57\xb6\x09\x7a\x2e\xe3\x3b\x65\xab\xd0\x78\x2a\xd4\x50\x13\xa8\xc9\x66\x60\xb0\x64\xb3\x33\x54\xd7\x40\xc1\x00\x6b\x14\x59\x8f\xd5\xcd\xcf\xb0\xec\x68\x04\x3e\xd6\x3a\x3c\xfd\x60\x7f\xcc\xf0\x33\x3c\x76\x34\x53\x67\x76\xa5\x54\x47\xb4\x5f\x7a\xbf\x40\x6c\x46\xcf\x28\x36\xe3\xf7\x4f\x4b\x73\x58\x88\xd7\x9d\xc4\x54\x3d\xa0\x32\xe1\xe4\x91\xc3\x85\x5c\x5e\x9d\x5a\xed\x53\xb1\xd8\xfc\xa9\x68\x27\x00\xd6\x6c\x8c\x19\x2f\xca\x4d\x21\x52\xf8\x41\xcf\x10\x6a\xba\x6c\x01\x3b\xbb\xd4\x4b\xe2\x97\xe2\x53\xaf\xc1\xd5\x3f\xbf\xf5\x59\xac\xa1\xfe\xfe\xc9\xa7\xc4\x4f\x6f\xff\xd3\x2b\x93\x9f\x1a\xd1\xaf\xa1\xcf\x4f\x66\x18\x4c\xfe\x04\x57\xbf\x2e\x47\x4e\x9f\x11\x0f\x7c\xfe\xfe\x67\xa5\x45\xf7\x8b\x1f\xc6\xe5\x7a\x52\x52\xeb\x08\xec\x60\x72\xa2\x0c\x3f\x10\xa3\xb7\x23\xc4\xd8\x0d\x46\xc6\xc8\xb2\x4e\xa5\xc3\x6e\x30\x68\x21\x5e\x59\xad\x51\xad\x55\x77\x08\x94\x16\xd9\x4c\x88\x51\x32\x1d\x82\x45\x99\x53\x7b\x99\xf2\x7d\x52\x1a\x46\xd2\x90\xe9\x50\x9c\x29\xd3\xc4\x0e\x76\x7b\x39\x18\x62\x65\x2a\xfb\x50\xaf\x90\xf8\xe0\x93\xc7\x35\x62\x2f\xa9\x62\x14\xb6\xc0\x66\xaa\x1f\x1c\x4f\x7c\x52\x4d\xf2\x13\xcd\xa9\x27\xa9\xde\xd4\xe0\x5f\xcf\xa5\x7d\x98\xe4\x93\x54\xff\x4c\xad\x5f\xb9\xac\xcb\xa7\x88\xc3\xe9\xbf\xa3\xa3\x78\x7d\x85\x44\x8c\xb5\x3a\xac\x46\x87\x41\xab\xa5\x38\xa3\xd1\xa7\xa2\x28\x2f\x6b\xb7\x5a\x4c\x2d\x82\xc5\x62\x75\x38\x38\xbd\x5e\xdb\x22\xe8\x59\xa0\x6a\x13\x10\xb9\x1d\xab\x48\xcb\x74\x56\x34\xa2\x87\x79\x92\x6c\x2f\x22\xf7\x25\x92\xa4\x90\x6e\x8e\x01\x1e\x4a\x79\x9d\x3c\x0c\x69\x21\x65\x80\xbd\xca\xaa\x43\xc5\x9c\x51\x5f\x3e\x65\xf0\xa1\x4d\x0c\xec\x35\x0d\x1e\x7f\x6a\xfb\x7c\x46\xfc\xfb\xf5\x62\x74\xc8\x82\x1d\x43\x5b\x3a\xc4\xe1\x81\x6b\x8b\x8d\x9f\xc3\x08\x75\xd8\x11\x4b\x3a\xa8\xbf\x5f\xd8\x6d\x8f\x21\xd7\x85\x37\x50\x69\x72\x93\xf8\xe2\x8b\x63\xb1\x4f\xb6\x28\x95\xbf\x67\xc5\x9a\xb0\x39\x91\xef\x47\x2a\x95\x8e\x71\xf2\x3c\xcd\x20\x4d\x58\x13\xe2\x3c\x6d\xd8\x03\x55\x6a\xb4\x9a\x56\x01\x69\xb5\x80\x71\x01\x5b\x37\x72\x20\x41\xc8\xac\xcb\xdd\x74\x36\x92\x74\x3c\x15\xc1\x28\x39\x94\xd8\xf5\x0c\xd5\xc4\x2f\x95\xc9\xe7\x85\x24\x95\x2f\x08\xcb\x58\xf1\x75\xff\x21\xff\x15\xec\x15\x57\xf6\x48\xea\x2b\x9b\x6e\x2e\x7c\x7a\xd4\xc3\x0f\x8f\xa2\x3e\xfc\x6d\x62\x9f\xd9\x2d\xc9\xb9\x13\xcb\x79\x9e\x24\xe7\xbd\x13\x1e\x05\x65\x32\xeb\x9c\x4e\x33\x85\xbc\x3e\xb3\xd9\x66\xc3\xb2\x6e\xa3\x01\x96\x1d\x84\x88\xa8\x67\xdd\xd3\x96\xe6\xb8\x1e\xf8\x59\xf9\xb8\x85\xac\x74\x58\x7e\x3a\xa5\x8c\xd0\xfd\x80\x40\x3c\xf8\xfa\xbb\x9f\x48\x52\xfe\x38\x0c\xdd\xfb\xe9\xf3\xb2\x94\xff\xfb\x0d\x68\x87\x0d\xaf\x8b\x6b\xcd\x71\x18\xc1\x62\x7e\x06\xce\x7d\xf3\xe5\xef\xb1\x98\xc3\x48\x5c\xfc\xf4\x5f\xbf\x88\xeb\x5e\x97\xf4\x5f\xea\x1c\x9a\xf2\xd0\xbd\x32\x07\x0a\x9c\x98\x7c\x03\xf0\x09\x2d\x5c\x10\x80\x65\x01\x08\x02\x30\x20\x51\x9f\xa4\xf2\x3e\x52\xf3\xc1\x9f\xbf\x3f\xc5\xb7\xb2\xfd\xbf\x7d\x5e\xae\x5f\x57\xfe\xc5\x94\x47\xea\xd7\x8d\x2a\xd0\x1f\x24\xe1\x08\xc0\x3c\x04\x03\xd2\x35\x6e\xd6\x67\x9e\xcd\x7c\x66\x36\xdc\x01\xb7\x02\xc7\xc3\x14\xf4\x91\x12\xb1\x53\x30\x70\xa2\xc4\xed\x40\x59\x55\x62\x10\xdc\x24\x36\x2b\x76\xe3\x73\x5a\x01\x36\x27\x22\x7a\x83\x81\x31\x71\x9c\x94\xd2\xa9\x66\x62\x65\x65\x7e\x8f\x27\xc2\xa0\x78\x65\xa8\xa8\x13\x63\xcb\x90\xcb\x8e\xc5\x9a\xc0\xe9\x88\x00\x5c\x9c\x8b\x72\xb9\x58\x7c\x58\x0d\x0b\x0c\x94\x1a\x19\x0c\xac\x4d\xcd\xaa\x3b\x05\x16\xc9\xe7\x58\x69\xca\x29\xe9\x94\xd3\x9c\x88\xc0\x97\x4e\xcc\x0a\x42\xc1\xec\xca\xe3\x78\x56\xbe\x40\x26\x72\x11\x4a\xd7\x1f\xd7\x48\xe4\x02\x58\xc2\xfc\x46\xb3\x2a\x73\xcd\x48\x76\xb3\x46\x2a\xe7\x41\x3f\x6f\xbb\x6e\xe9\x5e\x75\xf2\x1f\xea\x07\xcf\xc5\xdf\xeb\xa8\xef\x5f\x43\x2f\xa9\x19\xa0\xf6\x9e\x5e\x53\x3e\x6c\xd4\x43\x8d\x70\xb2\x6e\x82\xff\x95\xbb\xb6\x0f\x2b\x6a\x54\x1a\x1a\x0b\x6f\x0c\xcc\xd3\x2d\x42\xb4\x2b\x39\x43\x3a\xee\xbb\xcc\x6f\xc0\x3e\xe2\x99\x37\x54\x5a\x51\x70\x85\xc4\x37\xfb\xf4\x4f\x5e\x78\xfc\x8c\xf7\xc7\x1b\x6c\xce\x3f\x52\xf3\xfa\x55\x8f\x9d\x2d\xef\xc3\xf3\x78\x8d\x0f\xa9\x74\x78\xdf\x06\xbd\x47\xd6\x78\x19\x9c\x04\xd7\x00\xcb\x09\x68\x54\xe4\xe1\x15\x56\x9d\x30\x9a\xa1\x4a\x4a\xef\x29\x92\xd6\x77\xd1\xc5\x6f\x25\xfd\x1c\xc4\x38\xac\xde\xeb\xf3\xa9\x4d\x36\x1b\x42\x7c\x48\xab\x56\x87\x4d\x96\x4e\x41\x67\xaa\x33\x35\x9b\x90\x16\x99\x4c\x2a\x40\x94\xf6\x7c\x2d\x04\x5a\xa8\xc6\x87\x50\x45\x03\x67\x87\x90\xf0\xb6\x7a\x3b\xbd\x08\xfb\x36\x92\x64\x4f\x94\x33\xe5\x48\x8a\x5c\x76\x65\x50\x8f\x92\xcf\x4b\x28\x76\x90\x65\x3a\x25\xe5\x4e\x53\x8f\x8b\xdf\x8a\x2f\x9d\x83\x6b\x7e\x22\xda\xbd\xdf\xf1\xce\x4f\xc4\xc7\xab\xa9\x52\x36\xf9\x86\xfa\x8d\xd3\x8b\xfe\x34\xa0\xa9\xa1\xef\x62\xf1\xdf\x3c\xf4\x8b\x3f\xc3\xd5\xaf\xca\x5a\x5e\xfc\xf8\xc2\xb8\x81\x43\xde\xfb\x74\x40\xd5\x8b\xe2\x99\xc2\x52\x59\x96\xed\xd8\x8e\x7e\x2c\x61\x81\x6a\xf0\x1b\x6e\x81\x4c\xbd\xe3\x91\x9c\x7a\xc7\x25\xff\x43\xbd\xa3\x0f\xff\xce\xbf\x48\xbf\x23\x26\xc5\x94\x5e\xba\x78\x5e\xb2\x27\x01\xec\xcf\xdf\x98\xe8\xab\xd7\xe9\x3c\x2e\xb7\x2f\x10\x08\x82\x50\x48\xab\x89\xd2\xb4\xc6\x8d\xf8\x22\x50\xe4\x2f\x6a\x2d\xc2\xab\xc9\x17\x06\xdc\x5e\x37\xb6\x7c\xc1\x4e\x01\x6f\x43\x08\x01\xe0\x0d\x79\x75\x9d\x82\x17\x19\xed\xa7\xa0\x13\x3b\x89\x66\xb3\x91\x67\x42\x9d\x02\xa3\xc1\xff\x11\x59\x4d\xa5\xd9\xe6\x70\x36\x14\xa5\x7c\x8a\xec\x24\xcc\x74\x3d\x79\x0a\xa4\x4b\x0a\x8f\x96\xc2\xa5\x01\xa4\x81\xdd\x0d\x6b\x4d\x92\x36\x67\xa1\x56\xae\x8d\x0b\xd0\x4f\x1f\x38\xfb\x31\x76\xd7\xff\x9a\x4c\x6a\x8e\x9d\x13\xa7\xb6\x77\xdd\x7e\x77\xd7\x84\xb8\x2f\xe6\xb5\x55\x8c\x7f\x62\x61\xdb\x11\x35\xad\xd1\xdc\x71\xf9\xb4\x39\xef\x3f\x20\x7e\x4a\x7d\xf5\xc0\xbe\xd7\x5e\xae\x2a\xa1\xd7\x8b\x2f\x8a\xeb\xc5\x2b\x1e\x2b\xfd\x40\x88\xc0\x9d\xf0\x0f\xb0\x0a\x7b\x1a\xae\xe4\xc1\xe4\xcb\xdb\x8f\xfd\x28\xe7\x66\x13\xee\x8a\x5f\xf1\xda\xf8\xf1\xb9\xbf\x35\xd1\xaa\x66\x18\x95\x56\xaf\x37\x40\x8a\x52\xf1\x16\x4b\xc0\x1a\x0c\xfa\x8d\x1c\xc7\x02\x7f\x9e\xd3\xe9\x57\x21\x45\x21\x28\x2c\x2b\xa4\xf4\x48\x51\x10\xc0\x3e\x4a\xa7\x60\x65\x59\x8d\x3f\xe8\xc5\x4b\xe5\x35\x59\x38\x3d\xa3\xc1\xa7\xd7\xa4\x41\x18\xdf\xa9\x3a\x04\x85\x29\x0b\x3b\xa4\x4a\xeb\x53\x30\x2d\x7e\x89\xc5\x49\x09\x60\xcf\xaf\xe4\xe6\x2a\x27\x12\x19\x48\x7d\xed\x5e\x3d\xf2\x9a\x2c\x13\xfa\x28\xf9\xf5\x34\x6c\x9f\xbf\xcc\xb0\x3c\x4c\xa4\xac\x1d\x7b\x34\xf0\x3f\x9a\x3b\xc6\x67\xad\x20\x8c\xa6\x56\xea\x9a\xe4\xcb\x59\x51\xc8\xef\x29\x03\x79\x97\xbc\x20\xaf\x1f\x55\x9c\x5e\x28\x08\xae\x01\x40\xf1\x22\x5e\xa7\x42\xb0\x35\xe1\xd2\x69\x34\x51\x13\x76\x7b\x28\x15\xc3\x20\xca\xeb\x70\x04\xac\x94\xb5\xa8\xd8\x14\x36\x87\x89\x86\x2b\x13\x80\x99\x33\xfb\xcd\x48\x8d\xcc\x66\xb5\xc3\xeb\xf6\x76\x08\x6e\x93\x0e\x30\x0b\x18\xac\xec\x18\x46\x6d\xc4\x3f\xe9\x14\xd4\x28\x5f\xe2\x1e\x00\x97\x54\x76\x99\x95\xca\xea\xb8\x5e\x9b\x4d\x81\x9d\x52\x79\xe5\x65\xf1\xdf\x2a\xba\x6a\x59\xcf\x65\x32\x89\xe4\x02\x2a\x9b\xea\x6f\x9a\x07\xce\xc5\xdf\xed\x48\xf4\xef\x45\x2f\xe9\x35\x40\x13\x78\xb7\xab\x7c\xe8\xcb\x2b\xa0\xa0\x6f\xd8\xa1\x11\x39\xcd\xed\x09\xfd\xfc\x95\x8d\xb7\x14\x2d\x7b\x48\xd3\x43\xad\xf5\x13\x5f\x28\x1f\x2d\x6e\x27\xab\x04\xe7\x8d\x0e\xcd\x9e\x6e\x52\x13\xe5\xd7\xcd\x17\x74\x3f\xb1\x2f\xe8\x65\x20\xeb\x35\x11\xdb\x17\xac\xd7\x9c\x92\x5e\x33\x9d\x70\x7a\xf4\x20\xad\xd7\xf0\xe7\xbf\xc2\x32\x17\x91\x3e\xff\xa2\x6c\x8f\xe0\xb2\x9e\xf6\x08\x9c\xbc\x78\x5e\x59\xad\xbc\x88\x3f\xf3\x36\xf9\x8c\x9a\x82\xbf\xe0\xcf\x10\x1b\x97\x87\x7f\xe9\xb2\xfc\x20\xaf\xce\x68\x4a\x82\xb5\xbe\x16\x3b\x95\x11\xe9\x4e\x76\x61\xc2\xab\xc4\x6b\xac\x96\x58\x1f\x2c\x56\x8d\xd1\xc8\xe9\xb4\x5a\x03\xc7\x59\x29\x04\x1c\xc0\x6e\x3d\x05\x8d\x09\x07\xa7\x95\x69\x20\xf4\x0a\x64\x94\x76\xc1\x0c\x00\x36\x40\xe9\xbd\xe8\x21\xb5\xdd\x3e\x45\x4f\xaf\x35\x97\x14\x22\xd0\x4d\x0e\x81\x42\xbc\x95\x10\x43\xa8\x29\x87\xfa\x81\xd7\xa8\xe5\xaf\xe1\x57\x76\xf5\x03\xf8\x1b\xc9\xd3\x37\x35\xa0\x0c\x3b\xc4\x1c\x7a\x47\x9a\x25\x42\xec\x84\xfb\x41\x4f\x1e\x1e\x7c\x46\x89\x6d\xbe\x49\xba\xaf\xf7\x80\xa5\x89\x84\xd5\x02\x6c\x36\x0d\x9e\x93\x86\x33\x18\x5c\xb4\x86\x66\x7c\x8c\x17\x58\x33\xca\x4a\x6f\xd3\x63\xe3\x00\x38\x8e\xc3\xd2\xc6\x11\x64\x89\xa7\x89\x18\x1b\x51\x57\x1d\xdd\xea\x2a\x93\x3e\xdc\xc3\x16\x74\xa7\x12\xa7\xa5\x2c\x57\x51\x49\x64\x3d\x51\x22\x66\x69\xe5\x04\xdf\x7f\x2b\x75\xb4\x5e\xc6\xe7\x6e\x8f\x06\xfd\xa1\xb0\xc1\x52\xb0\xb7\xed\xcc\xac\x69\x7b\xb3\xf4\x91\x4c\xe2\xf3\xf2\xcb\x8c\x2e\x79\xb7\x7c\xb0\x7a\x72\x0c\xe1\xb9\xa7\x38\x86\x4c\x4a\x34\x48\x9a\x7b\xa7\xd8\xa9\x58\x22\xf5\x29\xb5\x81\x49\x89\xb0\x42\x63\xa0\xf4\x16\xb3\x19\xf0\x3c\x07\x4d\x26\xbd\x06\x31\x0e\xc6\x6e\xd2\xb3\xfa\x0e\x81\xa5\x08\x80\xb0\x32\x64\x7f\x75\xbc\x46\x89\x27\xab\x54\x74\xca\x58\x22\xb5\x9f\xf5\x45\x99\x78\x9d\xad\x36\x93\x6a\x96\xbe\x97\xe7\x03\x1a\x88\x37\x2f\xc4\xd7\x54\x9b\xd2\x1b\x89\x42\x08\x15\xbf\x22\x6e\xad\xf9\x7e\xcf\xaa\x7b\x1a\x1a\xf7\x3d\xf0\x73\xe5\x11\x35\xfa\x11\x6f\xe4\xf1\x69\x0d\xf6\x71\xf4\xf5\xe2\xd9\xe4\xce\xbf\x8f\xc3\x5b\xf7\x67\xf3\xaf\xd4\xe5\xb0\x97\xbc\x99\x66\x31\x2c\xef\x65\x0e\x77\x10\xe1\xec\xc5\xbe\xcd\x5e\x29\x66\x75\x73\xa2\x25\x60\xe6\x83\x41\x83\x1e\x44\xfd\x51\x88\x94\x2e\xa5\x42\xc7\xa8\x5c\x6e\x8b\xd3\xe9\x56\x29\x68\x64\xb7\x17\xa0\x7c\x3f\x74\x61\xa0\x09\x8d\x48\x89\xbd\xca\x00\x3e\x37\x5c\xd0\xad\x88\x46\xa2\x1d\x82\x8f\x8a\x98\x9c\x16\x5e\xa7\x32\x70\x06\x8c\x61\xd5\x1c\x02\x19\x42\x87\x78\x0e\xb9\x83\x94\x15\xdf\xed\x02\x65\x33\xe9\xa4\xd7\x21\xbd\xcf\x51\x88\x35\x86\x5a\xb6\x3d\x59\x44\x3a\x81\x1e\x14\x3b\x68\xec\x3a\xd1\x27\xbe\xa5\x59\x4d\x15\x8b\x1f\x5d\xad\x81\x82\x66\x2c\xdc\x31\x7f\xbd\x06\x9e\xd4\x6c\x9c\x4f\x5d\xde\xaa\x81\x9d\x9a\x1b\xc5\x81\x30\xba\x54\x23\xfe\x5d\xfc\xf5\x89\x11\x58\xbd\xd4\x68\x36\x52\xda\x5b\x93\x13\xab\x5c\xd4\x5f\xe1\x13\x92\xbe\xbd\x8e\x5a\x29\x7d\xbd\x89\x5a\x44\xbe\x8a\x8d\x49\xbf\xab\x8a\xba\x6f\xbf\x38\x30\x45\x86\x01\xb1\x4c\x9c\x47\x2f\x29\x86\x61\xcb\xdd\x95\xe8\xa3\x8d\x9a\x03\x81\x68\x98\x75\x29\xa8\x22\xaa\x30\xcc\xb1\x1c\x06\x3d\xa5\x1c\xe4\x38\x2f\x20\xa0\x72\x81\x6b\xbd\x4b\xaa\x33\xf5\x7a\xb1\xe7\xea\x95\x60\x3d\xa1\xa2\x42\x59\xf8\x27\x23\xf6\x29\x34\x99\xca\xa4\xcd\x64\xdf\x48\x38\xdf\x96\xae\x49\x2f\xc5\x12\x9f\x4a\x3b\xeb\xbe\x39\x51\xaa\xa4\x32\x76\xd8\x76\xec\x60\xa4\x51\x13\xd8\xdc\xfb\xee\xe3\xeb\x17\x6d\x36\x6c\xdb\x71\xeb\xe9\xaa\xf5\xf9\xfd\x1a\x63\x77\x6d\x7d\xf4\x8d\x27\x4f\xdc\xb8\x53\xfc\xab\xb9\x08\x3a\x9f\xb0\xfa\x8f\xee\x5b\x7c\x9d\x8a\x69\x57\xab\xef\xb9\xf5\xb4\xcf\x7a\x17\xa4\x0a\x6e\xdf\x72\xcb\x43\x4e\xe3\x81\xb5\x2f\x7e\x20\xeb\x2f\x49\x27\x62\xb9\x70\x81\xd9\x89\x6a\xac\xbf\x1c\x0e\x49\x7f\x59\x65\xed\xc5\x51\x1c\x30\x18\x3c\xc0\xad\xb1\xa9\xed\x34\x95\xa5\xbc\xb0\x53\x99\x52\x5f\xa6\x2c\x02\x9b\xd4\xd6\xa7\x19\x61\x72\x6a\xbe\x2f\xa9\xb8\xe4\x50\x66\xda\xf7\x85\x2a\x9b\xca\x96\x31\xa1\x47\x10\xaf\xc5\xaf\xec\xb2\xeb\xfb\xa5\xe6\xf8\xbd\x17\xce\xeb\xef\xd6\xa4\x35\xd8\x85\x61\x68\x65\x5d\x37\xd1\x0d\x7a\xe9\xc2\x2a\xbc\x7d\xdd\x7a\xfe\x62\x5a\xcf\x63\x1d\xfe\x72\x4a\x87\x87\xb1\x0e\x3f\x99\xe7\x07\x86\x1c\x1d\xde\xcd\x23\xb5\x22\xd1\x97\xf0\x48\x29\x08\xf4\x90\xb9\xa4\x34\xbc\xc4\x26\xd5\x4d\x26\x85\x37\xfc\x7f\xcd\x22\x65\xcc\xb9\xfd\x4b\xc1\xde\x4c\x3c\xe3\xff\x09\x97\x14\xc6\xa2\x8a\xb3\x78\x8e\x6e\x30\x31\x51\xe0\xb0\xdb\x75\x1a\x2d\xde\x63\x1b\x87\xb7\xd8\x60\xf0\x52\x1e\xa3\xd5\x8c\x45\xd7\x6c\xe2\xb4\x92\xda\xb6\x77\x62\xd5\x0d\x54\x18\x75\x9e\xc8\x75\x50\xb3\x00\x43\x4e\xe4\x37\x0d\x2d\x6d\x3d\x91\x64\x86\xb0\x08\xc3\x4c\x21\x17\x39\x72\xb2\x59\xfa\x52\xfd\xc0\x39\x71\x1e\x41\x96\xe6\x1c\xc0\x98\x61\x30\x4a\xa1\xc9\x4b\xf2\x51\xe5\x70\xa0\xf5\xe4\x64\x92\xf5\x3a\xe1\x64\xc2\x7a\x7d\xe4\x6f\x39\x90\xf0\xe7\x53\xbe\x0e\x7e\x9f\xf7\x5b\xbe\x21\xac\x07\x24\x3c\x80\xd7\xcd\x03\x56\x27\xe2\x88\xa6\x81\xc7\xad\x53\xa8\x94\x4a\xad\x56\xe1\xe1\x69\xaf\x5a\xed\x53\xe8\xae\xd6\xc1\xe5\x3a\x38\x4a\x07\xfb\xeb\x60\xa5\x0e\x52\x3a\x93\x0e\x5b\x40\xb7\xce\x01\x39\x07\xc1\xed\x1c\xc6\xed\x1c\xaf\x55\xd2\x1e\xe8\xc1\x86\x10\xa2\xec\x58\x91\x9c\xd5\x20\xd5\x0f\x91\xff\x19\xe3\x39\x77\xc5\x69\x1b\xc1\xcb\xaa\x50\xd6\x8f\x06\x29\x8b\x37\xe5\x47\x56\xd7\xc0\x57\xd4\x94\x4e\x7d\x37\x74\xc2\x4f\x37\xa9\xe1\x8d\xea\xab\x93\x4f\xdf\x76\xcb\x96\x91\xe5\x82\x23\x10\xf3\xeb\xe3\xee\xa6\x3d\x93\xc5\x3d\x0a\x86\x08\x44\x2f\xea\xac\x74\x74\x4e\xff\x79\xef\x10\xa7\xf1\xfb\xc9\x36\xe7\xba\x4d\x68\x3e\xa9\x43\x5f\x8e\xd7\x69\x40\x86\x47\xe9\xc1\x44\x83\xc4\xa3\x54\xd0\x4d\xa4\x54\x94\xc3\xa4\x44\x68\x94\x16\x94\x62\xa7\xe5\xff\x21\x89\x52\x36\x87\x52\x37\x12\xfd\xff\xc7\xa2\xf4\x33\x61\x51\x1a\x70\xcd\x69\xc2\xa2\x34\xfc\xda\x1d\xd3\x65\x16\xa5\x7d\x84\x45\xc9\xae\x79\xc0\x32\x5e\x66\x51\xba\xc5\x2e\x13\x6b\xfd\xdf\xb2\x28\xfd\x96\x43\xe9\xe2\x57\x18\x1f\x86\x25\x0c\x75\x79\xa2\x8a\x78\x38\x06\x15\xf1\x75\xb0\x82\xb1\x50\x10\xb2\x24\xb1\xd0\xa2\xe0\x79\x9b\xc2\x9a\xe5\xc5\x00\xd9\x8b\x31\x74\x62\x4f\x06\x61\x58\x91\x4e\x2e\xcc\x28\xd8\x1c\xed\x7a\x09\x05\x1b\x21\xf8\xe1\x37\x8e\x0b\x7d\x1b\xc6\x0e\xc1\x5f\xbb\x2e\x01\x0f\x5b\x25\xe0\xd0\x13\x1c\x62\xf9\xff\x04\xcf\xe7\x53\xc9\x4f\x5b\x9b\xc0\x1b\xeb\xf3\x62\xab\xe6\xb4\xd3\x0e\x87\x97\x35\x1a\xb1\x47\x6b\x56\x7b\xd5\xee\x80\x3b\x68\xb7\x5a\x95\xc4\x07\xf1\x09\xac\xd5\x67\xc5\xe2\x6f\xb5\x1a\x90\xd7\x61\x94\x38\xa0\x5c\x06\xe4\xeb\x99\xcd\x93\xc5\x00\x95\xf6\x34\x7e\x9b\x35\x96\xe5\x8b\x49\x18\x50\xd9\x9d\xe1\x44\x78\x9e\x24\x62\xf6\x4c\x5a\xcf\x8f\x24\xad\xa7\xed\xd4\x1d\x27\x1e\x35\xf6\xdb\xa1\xa1\x68\xcd\xf1\x7a\xc3\xb7\xab\x0f\x2d\x4a\xdb\x90\x2a\x17\x7c\x49\x38\xb8\x27\x21\xc0\x31\x92\xd5\xdf\x37\xa2\xcf\xcb\x55\xd4\xfa\x4c\x4e\x0f\xb1\x1b\xcc\x09\xc9\x16\x6e\x49\x8c\x30\x9b\x78\xde\x61\xc7\xf0\xdd\x68\x94\x30\x6f\x37\xb6\xa7\x34\x76\x64\x05\x56\x0f\xeb\x81\xc0\xc3\x79\xfc\x9e\x56\x0f\xad\x45\xc0\x6d\xe7\xd3\xf6\xd1\x42\xd0\xbd\x9a\xe0\x7a\x47\x8e\xa7\x95\xcb\x7e\x15\x4f\xf9\xa1\x0b\x73\xcd\x43\xee\x1f\x39\x60\xf9\x5b\xa4\xdf\x8d\xf8\x6d\x59\xdb\x19\x4a\x6d\xe7\x6b\x54\x38\x8d\xfb\xbb\x0d\x66\x06\xf2\x67\x41\xff\xb4\x8c\x4a\xf3\xf6\x80\xbb\x13\x13\xba\x65\x14\x5b\x3e\xab\x95\x25\xa6\xd0\x61\xb3\xdb\x3d\x58\x5c\x01\xf0\x78\x58\xec\x8c\xbb\x5c\x3e\xe0\x83\x5d\xa5\xbe\x16\x1f\x05\xb0\x54\x94\xf9\x12\xbe\xad\x3e\x85\x1a\x29\xbc\x1e\x7b\x5a\x8e\x9d\x58\x90\xad\x06\x22\xc4\x29\x71\xce\x88\xf2\xef\xaf\x84\x4c\x14\x93\xbd\x16\x97\x5c\x94\xdf\x13\xf0\xf4\x57\x55\x21\x11\xf4\x9f\xdf\xfd\xaf\x2b\x73\x69\x91\xcf\x88\x3e\xa0\xa4\xbc\xb5\x3a\xbc\x2e\x66\x6c\x35\x2f\x4f\xd4\x99\xcc\x66\x0b\xb0\x5a\xb5\x1a\x27\x4d\x6b\x38\xe4\xf1\x02\x4b\xc6\xf7\x31\x5a\x8d\x66\xbc\xcf\xdc\x02\xd9\xf7\x31\x1a\xb5\x9d\x82\x11\x31\xd6\xff\x1b\xdf\x27\x73\x5d\x77\xa9\xf0\x4c\x88\x96\x1c\xec\xee\x88\x0c\xf5\x4c\x96\xd3\x73\x2e\x2e\x7e\x37\x0c\x7b\xd5\xe8\x4a\xcd\x87\x3d\x9d\x9e\x5b\x69\x0e\xfb\xd1\xdd\x61\x17\x74\xf1\x1b\x6c\x3b\xc7\x4a\x3c\xaa\x84\xab\x71\x77\xa2\x1d\x6b\x78\x7c\xa4\xc3\x58\xbb\x87\x35\x56\xa4\x50\x18\x95\x26\x13\x87\x77\x19\xfb\xac\x61\x14\x34\x04\xf3\x0c\x11\xf9\x3e\x3b\x80\xd2\xd1\x04\xa5\xb1\x93\x70\xff\x84\x90\x52\x49\x99\x0c\xa6\x4e\xc1\xc0\xe1\xff\x4c\x0a\xbc\x5c\x1d\x02\xd5\xad\xcc\xb3\x26\x98\xb9\x9b\xcc\x42\x0d\x59\x68\xa8\xa7\xb8\xcb\xad\x3f\x2e\x19\x66\x81\x59\xd8\x08\x2e\xdd\xa3\xa1\x6c\x9a\xc7\xc7\x67\x2d\x07\x8c\xca\x6b\x80\x26\xc9\x80\xf1\x0d\xf9\xe8\xd3\xdf\x5e\x22\xba\x92\x3c\xdd\x0d\x94\xb0\xbf\x87\xd7\x86\x1e\x9d\x5a\x9b\xce\x44\xdc\xaa\xc9\x5e\x0e\x0d\xe7\x34\x18\x1c\xff\x3f\xa6\x9e\x93\xa1\x61\xec\xb6\x55\xbf\x3b\xc1\xff\x32\xa9\x4b\xce\x42\xc2\x28\x25\x18\xf3\xe8\x15\xcd\xc0\x87\x9f\xbc\xda\x66\x51\x31\x5e\x48\x61\x54\xe7\x63\x2c\xb4\x3f\x00\xbd\x9d\x02\x84\x5a\x97\xc9\xd5\x21\xb4\x5a\x3b\xad\x94\xd5\x6a\xe2\xe7\x33\x10\x30\x90\xc4\x84\xb4\x5a\xba\x43\xd0\xd2\x59\xcc\x23\x13\xeb\xe3\xa5\x13\xb3\xc8\x65\x6c\xdd\x46\x86\x44\xc4\x6a\xb8\x40\x30\x7d\x03\x61\xe4\x28\x89\x54\x2b\xe5\xb8\x00\x3e\x40\x69\xa9\x4a\x4a\x5c\xf8\xe4\x9d\x7d\x1b\x7b\xff\xf4\x24\xf4\xc2\xb2\x17\xc4\x1b\xff\xb3\xf8\x85\x85\x15\x0d\x54\xf1\x91\x95\xff\x84\x65\x91\xe4\x73\xd4\xc7\x43\xe0\xdb\xe3\xa4\xdb\x88\xcf\xc4\x0b\x17\x81\xb8\xf1\x05\x4f\x10\xf6\x39\x5b\x50\x07\x2b\xa0\x53\x8e\x0f\x7e\x75\xf1\x3c\x63\xc2\x73\xf2\x83\x12\xb0\x34\xd1\x8f\x35\x18\xf4\x46\x9e\x37\xab\x18\x46\x9f\x6f\x51\xd2\x01\x8f\x87\xd6\x23\x6d\x99\xb6\xd4\x11\xee\x10\x1c\xb4\x59\xd5\x49\x40\x96\x9e\x97\x9c\x52\x0e\x31\x7a\x2d\xf6\xcc\xb5\x26\x50\x94\xba\x49\xcc\x15\x42\xe9\xc2\x16\xf4\xb8\x1a\x8a\xe7\x06\xff\x14\x41\x92\x6d\x51\xd3\x23\x04\x58\x4d\xe2\xd3\x52\x55\x18\x9d\x5b\x1d\xa3\xa8\x3a\xf0\xd3\x95\x8c\xb8\x7f\xaa\x84\x68\xd3\x8a\x67\x22\x9c\x94\x7f\x06\xe6\x3f\x78\xe0\xc7\xab\x9e\x12\x1f\x86\x0d\x4f\xee\xdf\xfa\xe5\x96\x87\x0f\x6c\xfd\x66\xbb\xf9\x9a\x1f\xf6\xf6\x4f\xe4\x86\x01\x1f\x87\x8e\xdd\xf8\xdb\xdf\x89\x8b\xcf\xa1\xa1\x6f\xff\xf3\x79\x71\xc7\x99\x37\x7e\x78\x16\xce\xc7\xeb\x81\xd1\xaf\x62\xbf\x84\x23\xbc\x60\x4d\x62\xa0\x82\x76\x32\x58\x1f\x79\xb1\x86\x36\x70\x2c\x5e\x1d\x86\x46\x94\x4e\xe7\xa7\x7c\x0a\x60\xf1\x62\xbd\xc4\x7a\x7d\xde\x7a\x6f\x8b\x97\xb6\x20\xaf\x57\x47\xeb\xb0\x26\xd2\xe1\x95\xd1\x21\x33\x4b\x53\x78\xcb\x4d\x90\x32\x65\xfc\xf6\x1e\x42\x0b\x2e\xe5\xb4\x64\xd6\x45\x4d\x5c\x75\x89\xc3\x24\x5c\x00\xd3\xf8\xde\x95\x62\xb7\xea\x03\xa9\xdb\x44\x41\x7c\x41\xb3\x15\xde\x38\x6d\x11\xf4\x43\x1f\x35\x06\x9f\xc3\x3d\x9a\xe4\x3b\x9a\x73\xe3\x96\x9e\x79\xef\xb1\x9d\x37\x9f\xa5\x9a\x93\x27\xb0\x37\x6e\x2d\x38\xb9\xe2\x85\xc7\xd2\x30\x1f\x5e\xa0\x76\xdd\x72\xeb\xb5\x9b\x64\x0e\x40\xf4\x10\x7a\x0e\x63\xa8\x01\x52\x3e\xc4\xb8\x8b\xe7\xe9\xbe\x8a\xc7\x80\x1e\xcb\xc2\xc0\x44\x04\x18\x54\xf9\xf9\x01\x03\x2a\xb5\x5a\xcb\x40\x19\x46\x7a\xc5\xa8\x55\x28\xb6\x1a\x5d\xd6\x48\x40\x13\xd1\xb4\x0a\x11\xce\x0a\x53\x76\x46\x02\x94\xf5\x45\x69\x0a\xb2\xac\xb2\x9c\xac\x1a\x21\x15\x07\x22\xfd\xa8\x9a\xb8\x01\xa9\x0c\xb4\x2a\x9e\x7d\x1b\x0e\xd1\xb4\xb1\x63\x6e\x1f\x37\x75\xe2\x98\x3d\x63\xee\x81\x95\xd0\x73\x74\xf2\x00\xb6\xc2\xd8\x6f\xc6\x2d\xb3\xda\x16\xb6\x54\x17\x44\x55\x15\xa7\xe7\x1e\x7c\xfa\xea\x7f\xdc\xbc\xef\x09\x38\xea\xba\x2d\x3b\x7e\xde\xb1\x69\xcb\x2d\xbf\xf4\x81\xb7\xc1\x7f\x06\x79\xb3\xcf\x31\x62\x5c\xb9\x4d\xa7\xf6\x57\x36\x2f\xb9\x67\xdc\xe2\xf7\x1e\x22\xf9\x12\x3f\x10\xbc\x5d\x7f\xf1\x3c\x1a\x8d\x5e\xc0\xc8\xc0\x83\x3d\x8f\x6b\x13\x5e\x27\xa7\xf7\xba\x79\x5e\x69\x07\x01\xbd\x1e\x28\x51\x34\x9f\xcd\x3f\x97\xff\x71\xfe\x3f\xf2\x69\x6c\x51\x08\x17\x4d\x9c\xcf\x6f\xe2\x9c\x58\x0f\xbb\x5b\x84\x52\xbc\xb9\x14\xd9\xe3\x16\x6f\x87\x77\xbe\x77\x9f\xf7\x98\xf7\x1f\x5e\x46\x87\xf7\x5a\x63\xd1\x90\xaa\x57\x0e\x59\x5a\x05\x64\xed\xc9\xe7\xbc\x50\xf6\x36\x8a\xb2\xf1\xb4\xb4\xbd\x32\x33\x81\xb9\x3b\xed\x38\x15\x6f\x50\x70\x72\x9e\xa6\x52\xa5\xac\x49\xb7\x6c\x40\x79\x5f\x3c\xb6\xef\x9e\x2b\xbf\xda\x72\xe5\xed\xbb\xb7\x2d\xbf\x3a\xf9\xd2\xf1\x69\x4b\x3f\xeb\x33\x4d\xc5\xbe\xf5\xf6\x80\x9a\x19\xf7\x42\xd3\x95\x87\x4e\xde\xf3\x47\xe8\xdf\xb7\x60\xc2\xb8\x8d\x85\xfc\x12\xa7\xf8\xcf\x59\x63\x8f\xb9\x35\xca\xd0\x14\xe3\x35\x33\x7a\x35\x7d\x84\x75\x56\xc1\xc5\xf3\xd4\xf7\xe8\x69\x10\x02\xb3\x12\x09\xa5\xc9\x01\x80\x1e\x59\x7d\x26\x65\x38\xc2\x46\x7c\x91\xd2\x08\xd2\x3a\xac\x50\x63\x85\x3a\x2b\x0a\xb0\xc0\xcb\x79\xfd\x5e\x84\x01\xa5\x37\x40\x58\xd9\x02\x9c\x2e\xa1\x63\x9b\x74\x3a\x96\x55\xb7\x61\xc0\x99\x49\x3f\xce\x89\xb2\xd4\x62\x5d\x06\xbb\xa7\x29\x67\x55\x75\xe7\x90\xa4\x5b\xec\xa4\xa7\x25\xa7\x8a\x51\xdf\x6f\x3a\xb8\x6d\xdc\xd8\xc1\x43\xef\xaa\xf4\xee\xfb\xf3\xfa\x5b\x7a\xaf\xdd\xba\x74\xdc\xc8\x01\x2b\x57\x05\x6f\x78\x7e\xfd\x66\xea\xfc\xf4\x6b\xaa\xcb\x85\xb6\xd6\xe1\xd5\x79\x85\xb7\x5d\xb7\x60\xc0\xc4\x61\x65\xf9\x93\x5a\x07\xd4\x8f\x2a\xde\x3a\x3b\xcd\x91\x82\x9e\x97\xfa\xec\x44\x41\x5d\xc2\xef\xb5\x46\x38\x0e\x69\xac\x74\x7e\x01\xf6\xa2\xf9\x00\x21\x47\xd1\x29\x5b\x05\x1d\x04\x84\x4b\x87\xed\x41\xe4\x98\xcd\xb5\x5d\x61\xb5\xe5\x49\xf9\x7c\xd2\x73\x99\x2c\x1c\x48\xed\x8d\xad\x3b\x61\x87\xd0\x16\x8e\x68\x58\xe0\xb2\x3f\x7b\xbb\xad\xce\xc9\xd5\x8d\xda\xfb\xfd\x95\x58\xa7\x1e\x7a\x71\xe3\x0f\x37\x8c\x3f\x30\x61\xde\x64\x61\xff\xa4\x59\xe8\x68\x55\xfe\x79\x70\x91\x51\x34\x9b\x8f\x88\x67\x5f\x17\x77\x89\xcb\x3f\x78\xf8\x76\x48\x6f\x6b\xdf\xf8\xdd\xa6\xeb\x6f\xbe\xee\x9b\x1b\x6e\xda\x26\xf9\xbe\x44\x26\x3b\x24\x4e\xa0\x26\xc9\xae\xe0\x3d\x52\xb5\xa3\xe7\x41\x03\xf8\x38\xb1\x12\x54\xc4\x54\x0a\x45\x5d\x81\x56\x53\x58\x58\xac\x66\x8a\xf2\x75\x79\x79\xae\x80\xd1\xe8\x2a\xaa\xab\x50\x34\xf6\x67\xfb\xfb\xfa\x53\x7a\x54\xd6\xab\x55\x60\xe3\x50\x87\xe2\xf1\x32\x6b\x41\x31\x53\xdc\x22\x68\x3f\x66\xfe\xc1\x50\x2c\xe3\x63\x5a\x98\x0e\x66\x3e\xb3\x8f\x39\x86\xbf\x81\x65\x15\x03\xea\x22\x8b\x9f\x6c\xa4\xdf\x1f\x0e\x7b\xdb\x84\xb0\x95\x25\x17\xf8\x26\xa8\x33\x99\x58\x4e\xcd\x82\x06\xe8\x40\x0d\xc4\x8f\xc4\x3b\xdd\xd4\xd0\x80\x50\x7d\x9b\x80\xb8\xcc\x6e\x13\x9a\x2c\x6c\xac\xb2\x20\x06\x96\x00\x99\x8e\x6f\x61\x1a\x61\x4a\x1a\x2d\x57\xda\xe3\x99\xc0\x63\x06\x71\xf0\xa9\x1b\x5a\x42\x51\x11\x4f\x57\x0e\x48\x39\xd9\x94\x25\xc3\x56\x84\x1d\xcc\x1a\x52\xb5\x15\xca\xbe\xc6\xad\x96\x2f\xe5\x55\x3b\x87\xef\x1f\x0c\x29\xe5\xdd\x83\x0e\x0c\x3e\x59\x72\xfe\xa6\x8d\x1d\x81\x1a\xbb\xb1\x3e\x6f\xd8\xc6\xe1\x63\x06\x5c\xbe\xd4\x3b\xe0\xf0\x50\x51\x54\x9d\x18\x7a\xe7\xb0\x23\x25\xe7\xb7\xa4\x7f\x3a\xf4\xba\x96\xf6\x21\x97\x2f\x45\xe1\xb6\x36\xf1\x70\xbf\x0a\x78\x5c\x6c\x7d\xed\x42\xfc\xb9\x05\x0e\xff\xad\xe2\xaf\xbb\x97\x2f\x9f\x56\x38\x6c\x0c\x1c\x17\xef\x2b\x0e\x85\x0f\xa7\x7e\xb0\x0b\xa2\xdb\x17\xac\x9d\x26\xe1\xf6\x2f\xf0\x19\xfa\x0a\x9d\x01\xf9\x60\x45\x62\x88\x01\x59\x23\x11\x04\x8c\x5e\x05\x53\xc8\x16\x42\x2d\x62\x0a\xf2\x79\x8e\xe7\xb0\xac\xf1\x6e\xbe\x99\x9f\xc0\xcf\xe1\x15\x3a\x9e\x0f\x2a\x59\x49\x5d\x20\x2b\x3e\x4d\xc1\xa0\xa3\x55\x08\x72\x4a\x6d\x9b\xa0\x4e\xe8\xf8\x26\xb5\x5a\x69\x95\x6a\x19\x7f\x13\xb1\x9c\x94\x09\x59\x76\xe4\x1c\x29\xa9\x56\x90\x2c\x87\x9c\x72\x59\x04\x6b\x32\x4d\xff\x48\x72\x6d\x26\x97\x8e\x32\x34\x8f\x79\xf7\x85\x7b\xae\xf5\xad\xba\x79\xc9\xf2\x07\x57\xb0\x2b\x67\x2d\xbb\xac\x3d\x6f\x62\xa8\xb6\x26\xaf\xf7\x92\xa1\x87\xef\x59\x34\x13\x7e\x62\x9c\xde\x74\xcb\x81\xce\xba\x5e\xb3\xa6\xee\x1b\x39\x73\xe6\xd0\xe1\x0e\xeb\x9c\x57\x74\xfc\x8a\x59\x5d\x1b\x2c\x92\x7c\x76\x5d\xfc\x12\x3d\x2c\x71\x7f\x8d\xcd\xbc\xff\x46\xf1\x80\x29\x8f\xbc\x27\x71\x3e\x70\xb3\xcc\x57\xb1\x2c\xcf\xcf\x33\x29\xbe\x0a\x2c\xc7\xd8\x13\x47\x2f\x4b\xf5\x7c\x8b\x13\xfd\x68\x23\x42\x26\x13\x8f\x61\x1d\xcf\x6a\x75\x4a\x85\x42\xa3\xd1\xf1\xc8\xcc\x30\x16\x56\xd7\x22\xb0\x2c\x6b\x84\x7a\x85\x91\xe6\xb4\x34\x76\x80\x4c\x1a\x85\x4a\xd1\x22\xa8\x58\xec\xf5\x81\x16\x81\x62\x73\x33\xc5\xeb\xe5\x10\x77\xbc\xb4\xa8\x67\xd0\x46\xfe\x23\x29\x55\xe9\xe2\x22\x1d\xd9\x4e\x71\xca\xbd\x4b\xe8\xe3\xc6\xc0\xe7\x2e\x63\x60\x98\x69\x13\x4f\xff\x6b\x0a\x73\xfe\xf3\xad\x8d\x87\x09\x81\x9c\xe8\x80\xfb\x5c\xb1\x98\x4d\x7c\x4f\x54\xd8\x62\xf0\xbd\x45\xe2\x1e\xbc\xd7\xfb\x2f\x7e\x8b\xaa\xd0\xb3\x18\xe3\x0d\x4a\x44\x5c\x1a\xb3\xc5\x82\x51\x29\x15\x60\x03\x18\xc5\x51\x7e\xb3\xb1\x45\x30\x5b\x0c\xf8\xf4\x18\x38\x29\x95\x07\x91\x34\x98\x8a\xd2\x6e\xe5\x92\xda\xb7\xee\x6c\x61\x4b\x26\x81\x87\x27\x5c\xb0\x36\x29\x7d\x47\x36\x87\x06\x54\x56\x16\x2a\x36\x9a\xd8\xe2\x96\xc9\xf9\xe3\xae\x5c\x39\xbb\x5d\xca\xdd\xd9\x65\x2f\xef\xd3\xd6\x27\x1a\xad\x6f\x9a\xc8\x07\xae\x2d\xe1\x8e\xc3\x31\x5b\x76\x36\xd8\xa4\xc4\x9d\x59\x9a\x9a\xf9\x37\x6c\xf9\xe8\xd6\x56\x22\x97\x67\xb0\xbd\x96\xf3\x8f\xe6\x24\xfa\x38\x35\x1a\x87\x41\x6b\xb7\xb1\x18\xaa\x60\xbf\x88\xd5\x22\xca\xc7\xfa\x7c\xbe\x52\x1f\xc2\x4f\xee\x95\x33\x91\x1c\xd6\x74\x22\x12\x6b\xb7\x83\x9c\x19\x48\x0b\x9d\x22\x1b\x8f\x67\xcd\x24\x37\x07\x23\x13\x7a\xbc\x54\x4a\x12\xc2\xd2\x07\x8b\x52\x29\x49\x65\x93\x9a\x1b\x7f\x9b\x92\x54\x5e\xdf\x3e\xd5\x4c\x32\x92\x3e\x86\x85\x50\xd5\x33\x23\xe9\x3d\xf1\xcb\x8f\xa6\xc8\xb2\x34\x10\xcb\xd2\x51\x3c\x37\x16\x8c\x4f\x94\xa7\x68\x27\x59\x83\x82\xa6\x01\x64\x20\x67\x64\x8d\x1d\xc6\xf9\xe4\x9a\x55\x4f\x32\x66\xf5\x90\xd5\xca\x94\x93\x34\x6c\x11\x18\xda\xd2\x33\x67\xb0\x9b\xd4\x29\x9e\xb9\x15\x92\xee\x43\xa4\x27\x0f\xc8\xe4\x83\xd8\xab\x45\x47\xa5\x47\x1d\x28\x6e\x6a\x3e\xbc\x87\xc8\x4e\x33\x5c\x3a\x08\x1d\x25\x4f\x08\x8f\x89\x6d\x92\xd8\x8c\x81\xf7\xf4\xe4\x75\x23\xfc\xc7\xf8\x79\xef\x93\xde\xb7\x49\xf1\xcf\x8d\x24\x17\x4f\x7a\x3f\x32\xa3\xf3\x97\x4b\xef\x07\xc9\x3d\x3b\x30\xce\x5c\x28\xbd\x6f\x95\x3e\x3f\x5a\x1c\x84\x6e\x92\xce\xdc\x04\x89\xaf\xb2\x46\x6c\x56\x2c\xc7\xf6\x4d\x07\x2a\x40\x3f\x70\x4d\xa2\x49\xe3\xe8\x17\xaf\xc8\x0b\xe9\xf5\x7e\x1f\x8f\x28\xae\xb6\xa8\x88\x73\xa0\xfa\x04\x48\x40\x23\xaa\xa8\x2a\xad\x6a\x15\x4a\xad\x79\x75\xf9\x75\xad\x42\x3e\x17\xf4\xb7\x08\x41\xe8\x53\x7a\xf0\xe2\x78\x38\x1e\xef\x70\xab\x60\x95\xb9\x04\x5d\x3d\x31\xba\xbd\xc7\xfb\x4b\x44\x00\xd3\x17\xd1\x91\x8a\x1a\x3e\xa3\xac\x89\x8f\xc8\x57\xd7\x64\x18\x7b\xb0\x68\xcb\x05\x71\xaa\xea\xec\x24\x47\x6b\xb7\xea\x86\x1b\x3b\xbb\xae\xf0\xb6\xe7\x8d\xdb\x2d\x08\x70\xcc\x72\x46\xfc\xbc\x51\x67\x68\x58\x53\xbf\x7e\xdb\xb5\xdf\xef\x1c\xd7\x67\xc8\x35\x0c\x2c\x6e\x56\xea\xe6\x6f\x5c\xbd\x6d\xd3\x97\x1b\x0b\xa7\x5a\xb9\x86\xe1\xc2\x6d\x82\x30\xa2\x7d\xea\xc0\x26\xea\x49\xb3\x73\x97\xf8\xf3\xcd\x8b\xb6\x88\x23\xec\xa5\x70\xcd\xa0\xea\xf2\xfc\x13\x7b\x4f\xc2\xe2\xc3\x76\xb8\x07\xef\xca\xe0\xe2\x68\xe3\xc3\x3b\x1f\x12\x5f\x3b\x6c\xe5\x84\xb2\x5b\x20\x75\xc3\x9a\xad\x7d\xf1\xba\xfe\x1d\x2f\xe6\x5a\x69\x5d\xc7\x4b\x72\xd5\x25\xce\x24\xba\x0d\x9f\x99\x89\x89\x12\x17\x00\x76\x0b\x09\x3a\x69\xf4\x6a\x22\x5e\x58\xca\x18\x0b\xe3\xf5\x39\xed\x58\x17\x39\x59\x16\x99\x50\xbb\x60\xb2\x1a\xb0\x68\x19\x2c\xba\x53\x90\xcb\xe1\x33\x8d\x77\x53\x82\xe6\x5e\xdb\x1b\xd3\xe4\x7b\x72\x15\x19\x31\x65\x35\x3d\x78\x38\x75\x65\x95\xc3\xee\xef\x35\xff\xf0\xee\x65\x4b\x9f\x7d\xe2\xa0\x6b\xe4\x89\xb1\xd3\xbb\xb4\x5d\xa4\x20\xb0\xcb\x76\x3a\xd6\x6b\xcd\x78\x6a\xc5\x85\xdb\x1c\x62\x1f\x78\xeb\xe9\xcb\xe7\xcd\xed\x62\x87\x53\xad\xf6\x58\xf2\xf1\xb5\xd2\x1c\x6a\x49\x2f\x21\x3c\x07\x27\x18\x95\x28\xc4\xc7\xd8\x62\x4a\x1d\x10\x13\xe3\x72\x2b\xf5\x7a\xd6\xc6\xe2\xe7\x66\x59\x9b\xce\x66\xc1\x13\xb1\xb1\x3a\x3c\x01\x5d\x8f\xaa\xb8\x34\xf1\x5e\x26\xed\xa0\xbb\x00\x32\x9b\x41\x92\x57\xe6\x3c\x37\x27\x3d\x77\x9d\xc4\x22\xf9\xc9\xe8\xbb\x4f\x4c\xef\xd2\x54\x92\xa7\x8e\xdb\xe0\x17\xe4\xb1\xe1\x28\x42\x23\x09\xbf\xf8\x00\x3f\xf3\x08\x58\x84\x37\xe6\x63\xf9\x99\x47\x5d\xfc\xbb\xe2\x34\x7e\xe6\x52\xe2\x55\xe9\x38\x4e\xad\x74\x3b\x1c\xc0\x6e\xb7\x15\x16\x84\xc2\xe1\xbc\x48\xc4\xa6\x44\x65\xe5\xfb\xca\xa1\xaf\xbc\xa3\x9c\x02\xe5\x50\x83\x0a\x7d\x31\x5f\xbb\x10\xb3\x16\xe4\xb5\x08\x05\x96\xb0\x3d\x75\xc4\x01\x8f\xf8\x76\x19\x72\x67\x84\x36\x4b\x8a\x25\x96\xd9\x85\x19\xbd\x95\xb5\x33\xf2\xbe\xe4\x6c\x44\x06\xe0\xd5\x64\xa8\x33\xe5\xd7\x69\xee\xcc\x3c\x6a\x5d\xeb\xb3\x2d\xa3\xa6\x68\xa7\x6f\x50\xc3\xd8\x0c\xa5\xa9\xb4\xbc\x7c\xf3\x0c\x35\x29\xd7\x2c\x8f\xc7\xb7\x4d\x67\xa6\x1c\x91\x08\x35\xdd\x83\x1f\x1f\x3d\x69\xe6\x33\x93\xaf\xb8\x7c\x3a\xdf\x46\x0d\xc3\x8a\xed\x31\xef\x4a\x36\x56\x33\x6e\x7d\xb5\x5c\xa5\x19\xab\xe9\x58\x5d\x45\x25\xc8\xea\x3c\xd3\xb9\x6a\xbe\xbc\x26\xe2\x4c\x69\x4d\xca\xc1\x8d\x89\xe6\xec\x35\x29\xc8\xcf\x8f\x46\xf3\xf2\x22\xc5\x45\x78\x6d\x0a\xa5\xb5\xa9\x88\xfb\xe2\x1d\x71\x0a\xcf\x4f\x83\x8a\xb1\x52\x6f\xc7\xc7\xbd\x08\x2f\x4c\x91\xa5\xc0\xf5\x3f\x2d\x4d\xee\xda\xf4\x58\x9a\x9c\x00\xe0\xff\x6a\x89\xba\xe5\x3a\x77\x91\x18\xee\x52\x8b\x44\xe4\xfc\x12\xab\x54\xb0\x40\x7f\xc9\x55\x22\xa2\x2f\x2f\x14\x05\x6a\xb1\xee\xfc\x1a\xaf\x13\x29\x9b\x24\x95\x2d\x1a\xa7\xd3\xe2\x60\x7c\x1c\xc7\x58\x14\x74\x5e\x54\x13\xd4\x07\xb1\x49\xd3\x2b\x3d\x26\x0f\xa1\x52\x52\x3a\x08\x71\xb4\x92\x05\xb9\x19\x5b\x59\xe9\xee\xa9\x19\x93\x4c\x42\xe9\xda\x37\x60\x53\xaa\xe4\x0a\x33\x2e\x90\x72\x56\xa4\x9e\xab\xb2\xde\x52\xc2\x21\xae\x70\xeb\xd0\x9a\x52\xca\xc3\xec\xa8\xcb\x13\x3a\x0f\x1e\x15\x5b\x8f\x9d\xec\x3d\x77\x5e\xd7\x8c\xce\xef\xaf\x58\xdb\x7f\x9a\x03\x09\x50\x7d\x0c\xea\x6c\x7f\xba\x59\xa9\xbf\x7e\x95\x78\xf2\xbe\xbd\xad\x07\xff\x70\x4d\xf2\xa3\x2b\xd6\xfe\x6d\xe6\x34\xc7\x18\xac\xcf\x87\x5e\x3c\xaf\x08\xe0\x39\x28\x80\x05\xf8\x41\x57\xa2\xda\x61\x51\x3a\x9d\x26\xa3\xd6\x47\x43\xa8\x00\xc0\x67\x44\x81\x20\x1b\xc4\x78\x52\x69\x65\xac\xd8\x88\x31\x66\x8f\x19\xdb\x6c\x85\x99\x35\xe0\x59\x19\xac\xc4\xb2\xd1\x96\x5c\x82\x8e\xf4\xb4\x7a\xf4\x69\xe9\x61\xde\x60\x56\xd3\x7b\xb2\xa5\x3c\xc9\x15\xc2\xf6\xdb\x5f\x55\xa9\x08\x6c\xdf\xc0\x88\x6f\xed\xbe\xf0\xfe\xec\xc9\x07\x8f\x7e\xf4\x45\xcb\x9f\x4b\x77\x5e\xc7\xc0\xf2\x72\x6e\x0a\x37\x90\x9f\x57\x0a\x0d\xb2\xf1\x43\x47\xc5\x75\xdc\xf5\xab\xf6\x1d\x75\x99\xd0\x08\x7c\xa8\x07\x31\xb4\xb8\x44\x6d\xfa\xf2\x65\xc9\x17\x23\x7c\x57\x33\x24\x5b\xed\x04\x23\x12\xf9\x0e\x05\xcf\x02\xb3\x59\xa7\x55\x68\xdd\x2e\xe0\xc6\xbe\x05\xe0\x28\x0e\xa3\x3a\xca\x60\x33\x60\xec\x67\x60\x19\x0c\xa0\x98\x9e\x94\x57\xe9\x69\x64\xa9\x23\x3c\x83\xdf\x7f\x76\x38\xe2\xf7\x9e\x99\x2a\xfa\xbd\x67\x85\x18\x35\x9d\x47\x75\x18\xcb\x7b\x30\x96\x6f\x76\x43\x84\x38\xce\x83\xdd\x46\x2f\xc6\x4a\xf8\x64\x41\x37\x71\x19\xdd\xb0\x19\x4e\x80\x73\xa0\x42\x87\x20\xd4\xf3\xbc\xa3\x4d\xb0\x25\x1c\xde\x26\x5b\x42\x67\x6a\xb2\xd9\x78\x2b\xab\xf1\x69\x4a\x35\xeb\x34\xb4\x16\x61\xd3\x21\x41\x10\x2e\x87\x53\x98\xdc\xac\x75\x07\x7a\x72\x4c\x2a\x06\xaa\x81\x1e\xa5\x9a\x92\xc7\x29\x9b\xca\x9a\xc0\x8f\x70\x07\x7d\xf9\xf4\xce\xf6\x81\x35\x25\x87\xe6\xdf\xfb\x8c\xf8\x4d\x72\xec\xde\x78\x70\xc9\xce\xcd\x47\x1d\x62\x17\x65\xb0\x16\xdc\xb0\xb7\xec\x30\x54\xfa\xce\x3e\x26\x7e\x21\x3e\xd7\x27\x5e\x5b\xff\xc8\x71\xbc\x07\x7d\xb0\x7c\xcd\xc0\xf3\xb2\x82\x30\x98\x99\xa8\xc3\x8b\xaf\x54\x32\x2a\x9b\x9e\x46\x5e\x9e\xc7\x50\x38\x92\x27\x77\x37\xd0\x29\xf0\xc3\xea\x3c\xba\xe1\xba\x89\xba\xb9\x3a\x3c\x43\x9d\x4e\x03\x08\x0d\xa1\x86\x55\x59\x24\x5f\x39\x87\x99\x35\x2b\xb2\xdc\x83\xbf\x29\x9e\x2a\x3d\xad\x09\xa5\xd0\x53\xbc\x3a\x5d\x01\x93\x1b\xf5\x41\x2d\x87\xcf\x52\x0f\x63\x3c\x45\x36\xa9\xf9\xa1\x02\xe8\x79\xee\xf0\xd9\x4d\x3f\x89\xf7\x48\x04\x31\xb3\xa6\x8c\xbf\x73\x92\xf9\x9d\x93\xb5\x69\x74\x75\xf6\x97\x77\x4e\x1e\x10\xbf\xbb\x1d\xce\xbc\x6e\xcb\xf6\xe4\xb6\x4d\x5b\x08\x3f\x0c\x75\xf1\x39\x6c\xf3\x26\xa1\xa7\x81\x1a\xef\xdc\xb4\x44\x95\x51\xcf\x29\xcc\x1a\xad\x1a\x00\x97\xd3\x69\xe6\x90\x01\xef\x5f\xa9\x8f\xa4\x1a\x7b\x8d\x5a\xb5\xb6\x55\x50\xab\x39\x9b\x8d\x6a\x15\x6c\x9c\x8b\x33\x60\xe1\xd3\x6b\x0c\x96\x74\x1c\x2e\x57\x25\xe4\xe2\xdc\x78\x46\x35\xe4\xa5\x23\x6d\x88\x0f\xc1\x50\x2a\x14\x27\x55\x9b\x90\xc2\xf0\x7b\xfb\x0e\x5b\xbc\x7c\xe6\xc4\xf9\x6d\x0d\x3b\xc4\x8f\x3f\x63\x46\x41\x76\xc8\x84\x0f\x9e\x2f\x7b\xb4\x79\xdb\x06\x06\x8d\x31\xcc\x99\x3a\xb2\x43\x74\xc3\x1d\xe2\x9c\x98\x0d\xce\xb3\xad\x6b\xdb\x7c\x1b\xa7\xbb\x70\xc0\x1e\xcb\xf8\xff\x8a\x2d\xd8\x9f\x6a\x22\x3d\x30\x40\xff\x7a\x00\x98\x87\xa8\xa8\x91\x64\xc7\xa5\x7e\x7e\x07\xe1\x1b\x94\x7e\x4e\x72\x62\x0f\x49\xbc\x84\x88\x3a\x55\x19\x34\x82\x14\xe3\x20\x04\x43\x49\xde\x3e\xc6\x88\x31\xb0\x35\xd1\x8e\xd7\xc1\x12\x0a\x78\x3d\xbc\xd9\xec\xb0\x5a\xb0\x54\x16\x17\x14\xf8\x28\x0b\x5d\x52\xca\x96\x96\x96\x9e\x23\x77\xc8\x01\xab\xc3\xda\x2a\x78\x59\x87\xcf\x81\x57\xca\xe1\x70\xe7\x85\xb8\x3c\xae\x5d\xc8\xe3\x9c\x76\x2d\xd7\xe4\x76\xb6\x08\x6e\x60\xb1\x00\x55\x2b\x71\x0b\x5c\x69\xc7\x06\x8b\x43\x51\x56\x3c\x97\x38\x62\x97\x50\x3a\xdd\x40\x51\x4e\xd1\x4e\xd3\x3c\xd5\x74\xe7\x27\x12\x7b\x21\x5d\x13\x93\x74\x63\xd4\xcd\xf4\x4e\xc1\xc7\xbb\x29\x9d\x96\xdb\x64\x68\x74\xe8\x99\x1b\xb8\x4d\xee\x65\x0c\xf4\x17\x40\x25\x27\xfe\x5a\xc1\xb5\x3e\x82\x41\x12\xb7\xac\xbf\xd8\x2c\xb3\x38\x51\xfb\xd7\x45\x09\xe6\x48\x5e\x47\x8f\x1e\xb9\xdf\x1e\xfb\x62\xa4\xf8\x79\xf3\xac\xf9\x73\xbb\x02\x13\x93\xd3\xc5\xc5\x72\x4d\x28\xf1\x23\xc6\x28\xb6\x00\x2d\x30\x82\x60\x82\x53\x6b\x34\x40\xcb\xea\xb4\x3a\x13\x42\x3c\xcb\xc3\x89\x39\xd7\xbb\x29\x27\x32\x14\x25\xf4\x31\x21\xb9\x17\xec\x5f\x56\x32\xd4\x83\xa5\x35\x86\x99\xe3\xbb\x76\x1e\x86\x03\x14\x3f\xbe\xa3\x14\xe7\xa3\x2e\x47\x4c\xfc\xf1\x30\x7f\xe1\x08\x69\xc8\xc9\x45\xc4\x1f\xc9\x7e\xa4\x30\x3e\xf0\x82\x75\x89\x76\xbb\xc5\xe9\x54\x02\xbd\xde\xaa\x44\x12\xe5\x67\x21\xb2\xd8\xb1\x72\xb1\xb8\x2d\xcd\x96\x09\x96\x39\x16\x7c\xf4\x2c\x16\x0d\xd2\x98\x5a\x85\x16\x43\x87\x81\x62\x0d\x3e\xc3\x3a\xc3\x16\xc3\xc7\x86\x7f\x18\x94\x1a\x64\x30\x68\x38\xe4\x6e\x13\xe4\xb8\x23\xf2\x7a\x91\x14\x30\xe8\x4e\xf1\x5e\xf8\x3b\x0a\x46\x66\xd1\x4d\xc3\xf2\xb0\x24\xaf\x32\x3b\x83\x9c\xe4\x4d\x2a\xac\x91\xb2\xed\xa5\xf1\x07\x8e\xdf\x08\xd1\x4d\x83\xf7\x57\xc6\x6a\xb8\xfa\x59\x8b\x9e\x88\xc2\x71\xac\x78\x58\xf5\xda\x96\x3d\x37\x0d\x1b\xf3\xd8\x5d\xf7\x43\xdf\xfd\x5e\xab\xf8\xcb\xfd\xf5\xcf\xed\x6f\x2d\x6d\xb8\x08\xa6\xc9\xbd\xf1\x2e\x9e\xa7\x3e\x96\xfc\x96\xcb\xe4\xbc\x0e\x3c\xf1\x5f\xa5\xbc\x8e\x66\xe9\x3d\x76\xdf\xa8\xcd\x92\xec\xfe\x20\xc9\xf6\xec\x5b\x64\xae\xcc\xa9\x4e\x06\xc1\x6e\xae\xcc\xdc\x1a\x31\x7c\xbe\xf7\x63\xfd\x15\xc7\x7e\xb7\x1a\xfb\x3b\x33\x13\xbd\x38\x7f\x34\x0f\x43\x5a\x4d\x05\x55\x5c\x5c\xe1\x47\xb6\x4a\xb6\xb2\xb4\x12\x0b\xad\x2d\x1e\xa5\x0b\x68\x8c\x07\x0b\xc2\x18\x4a\x12\x9f\x27\xac\x6b\x15\xc2\x9c\x05\x2f\x95\xdd\x6e\xb1\x66\x33\x94\xfd\xce\x21\xcf\xb2\x2e\x91\x0a\x92\xf9\x45\x0c\x0a\x4a\x7b\xe4\xa1\xb4\x73\xdb\x0f\xa6\xfc\xf5\x2c\x0b\x84\x36\x5d\xf8\xb9\xb0\xd7\x20\xe3\x8c\x1d\xee\xea\x86\x71\x8d\x79\x45\x03\x47\x74\x35\x57\x61\x1f\x9e\xe3\x2d\xa1\xde\x83\x47\xc6\xa6\xdd\xb8\x76\xc6\x84\xfe\xed\xe3\x0e\x1e\x7d\xfd\xdd\x96\x8f\x8a\xeb\xbf\x7c\x99\x11\x17\x30\x3c\x2a\xd4\xd4\x2e\xbe\x86\xb8\xed\x81\x6b\xa3\xb6\xe6\x07\xa1\x7a\xf3\xae\x46\x9b\xb8\x41\x27\x9b\x29\x49\x4e\xf1\xfc\x97\x4b\xbc\xca\x01\xb0\x2a\x31\xc8\x62\x36\xb0\xac\x91\xf3\x42\xe0\xf3\xd9\xac\x7a\x9d\x53\xa9\xd4\x71\x28\x18\x02\xa1\xb2\x50\x22\xd4\x1a\xa2\x59\x64\x31\xb4\x0a\x96\x04\xef\x69\xb2\x58\x10\x72\xb7\xe0\x23\x6b\xb7\xf1\x29\x9a\x24\x8b\x1a\xcb\x9a\xba\x5b\x93\xa7\x4b\xe7\xa4\xd0\x5d\x51\x0f\x17\xaf\x87\x47\x9c\x6d\x71\x33\x9e\xb1\x0b\x76\x2f\xd5\xd3\xdd\x13\x6c\x12\x97\x67\x1c\xe5\xeb\x87\x9d\xb8\xf0\xef\x22\xb2\x3a\x18\x2d\xa4\xa7\x06\x77\x76\x7b\xcd\x17\x6e\x4e\x2d\x87\xa4\xbb\x88\xbf\x8c\x75\x57\x18\x9f\x95\x81\x6a\xbd\xc3\xed\xb6\xf2\xfa\xa0\x96\x51\x85\x42\x61\xd2\x76\x12\x84\x79\xec\x15\x84\x2d\x0e\x8c\x85\x1c\x16\xbd\x8f\xc3\x88\x17\x68\xf5\x5a\x8f\x96\x52\xd3\x0c\x56\xf0\x88\x61\x54\x1c\x47\x13\xc5\xa5\xc2\x02\xa1\x92\xf8\x26\x8b\x52\xf5\x48\x20\x93\xd6\x22\x8b\x42\x8f\x5e\x6f\xf1\xf4\x8c\x25\xb2\x9c\x4b\x29\x25\xa5\x84\x9c\xba\x35\x17\xd4\x5d\x52\x1b\x31\xb3\x08\x7c\xea\x4a\xab\xac\x1e\x7a\xc8\xd0\x3b\x89\x5d\x53\x6a\x50\x5a\x4d\x91\xf3\x21\xc5\xc8\x88\xee\x47\xdf\xc8\xb9\xd4\xe0\x11\x39\x96\x76\xb3\xd9\x96\x89\xa5\xa5\x63\x70\x92\x8d\x18\x2b\xdb\x88\x5e\x40\xca\xa0\x4e\xd9\x08\x29\x5e\x70\x4e\x8a\xc9\x4d\x20\x3f\x57\x53\xcb\xa5\xdf\xf2\xef\xc2\xb0\x45\x27\xff\x16\x8a\xf8\x17\x92\xaf\x8b\x80\x0f\x23\xce\x2a\x40\x51\x9c\x87\xa6\x9d\x36\xce\x28\xf5\x1c\xb0\xe9\xfc\x01\xa2\xf3\xb5\x6e\xd6\xa8\x22\xed\x06\x58\xfc\xb9\x52\x80\xd4\x08\x80\x74\xe7\x01\xaa\xdb\xe9\x8d\xaf\x4e\xdf\x5a\x65\xb9\xbe\xdd\xc2\x93\xe2\x6c\xc7\x02\x83\x7e\xd3\x81\x20\xcb\x81\x4c\xe6\x3f\xbb\x7c\x4d\xc6\xf9\xc5\x9e\x53\xda\xf7\xdd\xc0\xc0\x58\x97\xad\x48\xbc\x19\xf6\x87\xd6\x8c\x07\x1c\xfb\x8d\xfb\x4b\x38\x61\x2e\x9e\x67\xbe\x54\x34\xe3\xb5\x9c\x91\xa8\x8a\x15\x1a\xcd\x85\xe6\xb8\x36\x1e\x46\xbd\xb5\x0e\x47\x6f\x5f\x98\xae\xeb\x6b\x28\xcb\x2f\xeb\x10\xf8\xe2\xe2\x7c\xd4\x1b\xf4\xee\x10\x00\x08\x58\xf3\x69\x9f\xaa\x3a\x50\xdd\x21\x78\x02\x7c\x2e\x3f\x71\x3a\x2d\x3f\xde\xd3\x45\x30\x75\x53\x6b\xb1\x10\xfd\xb6\x36\xac\xc2\x24\xdf\xcc\x46\x95\x32\x05\x80\x5c\x52\x53\x23\x95\xd4\x18\x53\xab\x10\x45\xfb\x49\x16\x84\x10\xbd\x67\xf4\x3d\xd0\xbc\x7b\xef\xe6\xf6\xdb\xfb\x56\xf7\xaf\x38\x73\xf6\xf3\x1f\x9f\x15\xb7\xfe\xf0\xf8\xab\x9f\x3c\x2e\xfe\x24\xbe\xf5\x07\x38\xe8\xed\xe7\x1f\x8e\x0f\xa4\x62\x37\x8c\xfc\x5e\xfc\xf7\xf3\x0f\xb7\x9f\x2a\x13\x8e\x50\xcf\x57\x3b\x45\x95\xab\xe0\x29\x38\xe5\xef\x6f\xff\xbd\xaa\xfc\x30\xf4\xd7\x89\x5f\x5f\x04\xe2\x45\x71\xc3\x2b\x75\x75\xb0\x08\x32\xdf\xc1\xc5\xaf\xd4\x89\x9f\x1c\x2e\xaf\x12\xe7\x88\x3b\xff\xf4\x4d\x81\x0b\xfe\xc7\x29\xaf\xd3\x08\xac\x53\x22\x78\xff\xf3\x40\xff\x44\xc0\xc2\xe9\xed\x7e\xad\x4b\x13\x0a\xb9\xec\x1c\x1d\x05\x4a\x65\x7e\xc8\xee\xd0\xda\xb5\x7a\x0f\x32\xb1\x1a\xbd\x55\x6a\x25\x1f\xbf\x04\xb1\x43\xda\xa4\x57\xa6\xda\xd8\xc3\x10\xc2\xff\x27\xf9\x41\x71\x0c\x90\x6c\x3c\xcc\xbc\x74\xc1\x7e\x90\xbe\xba\x1f\x73\x8e\xb9\x4c\x5c\xdb\x77\x85\x78\xa0\xef\x6d\x66\xe6\x01\xa5\x61\x32\x54\xdb\x98\x87\x94\x86\x71\x7b\x2b\xe3\x28\x32\xd0\x12\xb3\xe4\x0d\xd9\x95\x1c\x4f\x15\x26\xdf\xa5\x5e\x1e\x3d\x3c\xbf\xa8\xce\xdd\xd2\x57\xac\x83\x07\x2f\x6f\x4a\xbd\x6e\x83\x7a\xe1\xfa\x94\xfd\x56\x54\x48\xf9\x72\xf9\xe0\xf2\x44\x6f\xaf\x9f\x63\x20\x0c\x3a\x75\x6a\x85\xd9\xac\x76\xfa\xe9\x82\xc2\xfc\x50\x24\xd4\x21\x70\xa0\x53\xd0\xfa\xfd\x01\xd6\x1d\x70\x77\x0a\x4c\x80\xc3\x7f\xec\x11\x64\x77\x76\x08\x76\xd8\x29\xd8\xd3\x99\x21\x32\x5f\x4c\xbc\x7b\xcb\x7b\xec\x79\x26\x08\x92\xae\x38\x09\xa4\xd9\xe4\xb2\x72\x45\xe4\x62\x0c\x39\xa5\x96\xba\x5b\x4e\x1b\x18\x06\x9f\xeb\x35\x40\x33\xee\x95\x3e\xbd\xb3\x72\x0a\x1e\xd0\x8b\xa4\x18\x03\x3e\x67\x7a\x4b\x43\xcd\x51\x7f\x48\x6d\x91\xb2\x09\xe0\x7f\xc4\x33\x6f\x98\xc4\x47\xe5\x0c\x12\xf4\x19\x29\xc4\x98\x9e\x4a\x89\xc6\x73\x1e\x82\xf7\xcd\x2a\xe1\x88\x42\x30\x21\x51\xee\xb6\x5a\x6d\x3e\x83\x09\x86\xd5\x6a\x68\xb0\xd1\x45\xc5\x6e\x93\xd7\xd4\x26\x78\xf1\x2e\x2a\xa3\x2d\x82\x52\xa9\x75\x92\x80\x95\x93\xb5\x59\xb4\x41\x52\xad\x9e\x0b\xe0\xb3\xaf\xe3\x61\x0f\xaa\x0e\x1b\xb6\x79\xb9\x7e\x6f\xc8\x9f\x6e\xc4\x53\x1d\xc8\xf6\x81\xd1\xfb\xcc\xa0\x6b\x8a\x6f\x6a\xbb\xf3\xbe\x94\xef\xab\x17\xbf\xde\x95\xee\xc8\xb3\x15\xf6\xdf\x26\xb9\xc2\x7d\xe6\x38\xd0\x19\xdb\xf0\x57\xe7\xf0\x1b\x57\xa7\xbd\xe0\xcf\xa4\xd6\x3c\xc5\x4f\xbd\x9f\x5c\x94\x76\x87\x49\x2e\xd4\xc5\x6f\x55\x8f\xe1\x33\x5c\x01\x36\x25\x9a\x79\x95\x4a\x17\x8c\x46\xcd\x28\x56\x5a\x1a\x42\x3a\x5a\xe3\x76\x38\x2a\x35\x71\x9b\xaf\x43\x70\x3a\x6d\x74\x44\xc9\x2b\x3b\x85\xa0\x8e\xaf\xe3\x9b\x79\x52\xc0\xc5\x6b\xd8\x54\x49\x00\xad\xd2\x69\x74\x1d\x82\xc6\x54\x5a\x0a\x40\x61\x56\x35\x73\x69\xcf\x34\x84\x34\x6c\x95\x53\x41\x53\x9c\x86\xb6\x5c\x22\x62\xa9\x30\xae\x67\x26\x82\x09\x04\xfe\x4b\xa1\x9c\x42\x47\x0a\xe5\x54\xe2\x85\x9e\xf9\x08\x54\x3f\x78\x02\xf6\x4e\xd5\x46\xa7\xab\xe7\x5e\x67\x7a\x54\xcf\x0d\xaa\xcc\xcd\x4c\x80\x61\x38\xa4\xbb\x9a\x6e\x50\x53\x56\x35\x1d\x04\x73\xb1\x5c\x2c\xc1\x72\x51\x04\xe6\x24\x7a\x87\x5c\x2e\xaf\x4a\xa7\x0b\xdb\x8c\x8c\xcd\x4b\x17\x53\x45\x45\xb1\x7c\x1a\xbb\x6f\x20\x9f\xd3\x38\x43\xd8\x91\xc3\x96\xd4\x1b\x08\xf8\x5a\x84\x00\xeb\x75\xb5\x08\x5e\x0b\x67\x36\x1b\xda\x04\xb3\x15\xe4\xc4\x7d\xb3\xe9\x99\xe3\xd9\x3d\xb5\xba\xa5\xa4\x27\x7c\xcc\x10\xf4\x84\x24\x2b\x29\x39\x7f\x04\x2b\x59\x6d\x8a\xc1\xb9\x58\x72\xf3\x1d\xde\xb6\x17\x26\x1d\x38\xae\xfe\xac\xff\x1d\x8c\xf8\xe8\x6e\xd2\x71\xa8\xe9\x6f\xa1\xbd\x6f\xcf\x6b\xbc\xa7\x8c\xba\xa1\x1b\x5b\x16\x12\xc8\x59\xdf\x47\xbc\xca\x11\x93\xb0\xf5\xcc\x75\xcf\xcf\xf1\x9b\x49\x6f\x11\x7c\xfe\xf3\x14\x4d\xd8\xeb\x0b\x91\x6a\x71\x9f\xc5\xe2\x0c\x18\x18\x63\xc8\x4b\xd3\x1e\x8f\xd1\x89\x22\xf6\x30\xd6\x04\x21\x5f\xc0\x67\xf7\xba\x68\x83\x5a\x6d\x21\x26\xce\x62\xb7\x74\x08\x3a\xca\xde\x9d\x7a\x21\x4f\x26\xd5\x22\x3a\x9e\xd2\x70\x3d\x8a\xf6\x48\xeb\x3e\x92\xb4\x6a\x80\xd9\xa5\x55\x51\x98\x6e\xe8\xab\x86\x56\x5b\x75\x8d\x22\x4f\x2b\x46\xb4\x5b\x3a\xfa\x4e\x36\x55\x4c\x66\xc4\xad\xcc\xac\x72\x75\xac\x4c\xfc\xf6\x3a\x8d\xb8\x5d\xb3\x80\xba\xf7\xa9\x5f\xc4\x2e\xf1\x9b\x2b\xad\x8d\xbb\xab\xf0\xc6\x52\x3a\xe7\xea\xe9\xe2\x17\x8e\x58\xcc\x01\xcd\xbd\x83\x8d\x23\xcc\x29\x0a\x4c\xa9\xff\x74\xf2\x9f\x03\x56\x5e\xdd\x4f\xea\xd9\x07\x00\xcd\xa1\x13\xd8\xeb\x0a\x80\xe9\x89\xb8\x87\xe7\xed\x3e\xbd\x8a\x0b\xb8\x69\xda\xe5\xe2\xec\x28\x64\x0d\x2a\x4c\xa6\x80\xc7\xe7\xb1\x62\xc7\xad\x9d\xd0\x6e\x33\x0c\xef\xa2\x69\xde\xca\x63\x13\x4e\x59\x33\xde\x6d\x7a\xa6\xe9\x4e\x41\xff\x7d\xae\xd8\x92\x91\xe9\x51\x24\xf7\x00\xa5\x27\x0a\x11\x99\x28\xcd\xa9\xc5\x5b\xd4\xcd\x4d\xcd\x56\x4f\x7f\x46\x7c\x83\x19\xe4\x51\x86\x9e\x19\xa8\x16\x3f\x55\xcf\x84\xdf\xdc\xf5\xb4\xf8\xd8\xfd\x23\xd8\x8a\x8e\x18\x99\xd9\xf8\xfa\xd5\xfb\xc9\x14\xf7\x07\xa3\x83\x4b\xc5\x03\xe4\x25\x9a\x77\x61\x3b\xf5\x89\xf8\x7c\xed\x98\x8e\x4a\xb9\x0e\x51\x75\x04\xef\x63\x0c\xc4\xc1\xb6\xc4\xd0\x02\x8f\x27\x58\x6a\xb1\x14\x3a\xcb\xf1\x66\xc6\x4b\x68\x3a\x16\x33\x3a\x83\xb4\xbf\xca\x5f\x5e\x59\x52\x44\x9b\x15\xee\x02\xac\xc6\xe3\xa5\x05\x05\xfe\x88\xac\xe0\x23\xc8\x69\xb1\x04\xf1\x06\x07\x63\x78\xeb\x83\xfe\x20\x56\xec\x3a\xca\x2f\xed\x70\xf6\x16\xa7\x27\x9f\xa6\x08\xcd\x32\xf4\xb0\xa2\x87\x07\x90\x11\xf1\xff\xb6\xef\x3d\xd4\x41\x46\x0e\x54\x47\xfe\x9b\x1c\x40\x77\xf2\xa3\x89\x39\x2a\x61\x2a\xd5\x08\x27\xfd\xdf\x09\x07\x65\x4a\x7e\x97\xa5\x15\x5e\xa3\x6e\xcc\x12\x16\x0a\xcc\x05\x40\x49\x64\x25\x8a\x57\xf3\x86\xc4\x60\xa2\x09\x0a\x78\x3e\x6c\x2f\x52\x19\xb0\x0e\xa0\xa3\x51\x83\xdd\x8b\xfd\xfe\x22\x6f\x7e\x84\xc5\x42\x13\x2b\x28\x08\x11\x85\xd0\xad\x0f\xec\x3c\xef\xc2\xe2\xe3\x8a\x62\xe1\x22\xba\xc1\xaa\xa5\xbc\x96\xcc\x42\xe6\xae\x63\x16\x17\x52\xfa\x00\xe5\x64\x52\xfe\x66\x15\x7f\x2b\x51\x52\x17\xe5\x40\xea\x8a\x2d\x2d\x5d\xca\xdf\x97\xae\xd7\xc5\x44\x43\x46\x5d\x0c\x85\x1f\xfd\xe3\x7f\x14\x36\xb8\x44\xbc\x31\xa5\x39\x26\xc1\x7b\xb3\x04\x4f\xf2\x2d\x5f\xc5\xeb\x75\x10\x63\x88\x30\x5e\xb1\xa9\x89\x88\xd1\x1c\x75\x2a\xb5\x30\x94\xe7\x76\x87\xbc\x11\x87\xd6\x69\x66\x4c\x05\xa6\x7c\x85\xce\x81\x2d\x49\xc4\xeb\x70\xa8\x5d\xae\x28\xc9\xb1\x36\x08\x2e\x04\x4d\x26\xa5\x56\xad\xed\x10\xd4\xdd\x29\xd5\xe9\xa6\x45\xf1\x9c\x62\xb3\x6e\xb3\x5a\x40\x3a\x8f\x84\x52\x73\x27\x84\xa4\x78\x35\xfa\x51\x35\x10\x1b\x55\xe8\xa5\x7c\x94\x1a\x06\x94\xbb\xc5\xe7\xeb\x43\xd7\x2c\xef\x7a\x40\x9d\xfc\x48\xfd\x78\xd7\xa8\xab\x16\xed\x9a\xfe\xff\xf1\xf6\xe7\xf1\x51\x15\x59\xff\x38\x7e\xeb\xae\xbd\xdf\xdb\xfb\xbe\xa7\xbb\xd3\xe9\x74\x3a\x49\x27\xe9\x84\x25\x69\x96\x84\x00\x81\x2c\x84\xa5\x51\x48\xd8\x37\x01\x51\x59\x5c\x10\x70\x47\x44\x45\x5c\x10\x37\x54\x1e\x60\x14\x15\x10\x15\xf7\x7d\x1d\x15\x1d\x75\x1c\xc7\x99\x71\x7c\x66\x7c\x74\x66\x70\x19\x47\x67\x93\xdc\xfc\xaa\xea\xde\x5e\x93\xa8\xdf\xcf\x1f\x3f\xf2\x82\xdc\xa6\xfb\xde\xae\x53\xe7\x54\xd5\x39\x55\xe7\xbc\xdf\xe2\x2b\xca\x2d\xf7\x5c\x7d\xf5\xff\x6c\x10\x8f\xe9\xe8\xb5\x3a\x91\x5a\x73\x65\xff\x98\xe9\xe7\x0f\x4c\x07\x8f\x0f\x24\x40\xeb\x91\xdb\x06\x9e\x45\xf6\x40\x8e\x03\xcd\x97\x89\xa7\x1e\xaf\x77\xfc\xfd\xe4\xf6\x71\x0c\xc9\x77\x75\x0d\x7c\xc3\xb5\xde\xf8\xf4\xdf\x1d\xe4\x0b\xe0\x23\x49\xe6\x27\xe0\x7c\xf2\x67\xe8\xfb\x79\x89\x00\xc2\x39\xd7\xf0\x01\x33\x9c\xc1\xad\xc0\xe3\xb1\xda\x7d\x26\xce\xcc\x2b\xb4\x65\xda\x20\xa3\x30\x29\x3a\x33\x3e\xbb\xc9\xa4\xb5\x58\xa0\xef\x60\xe1\x39\xa0\xc5\x96\x90\x5b\x19\x46\x12\xd2\x8f\x12\x37\x10\x41\x13\xe2\x1e\x08\x62\x01\xa9\x02\x01\xe9\xdf\x7d\x57\x65\x5a\x3c\x6b\xfa\x81\xe9\x0b\xcf\x9b\xb8\xf9\x7b\xc5\x99\xab\xe7\xae\xd8\xd6\xff\xb9\x86\x6a\xd4\x88\xf7\xcc\x5a\xd7\x11\x4a\xce\x86\xab\x5d\x58\xf4\x7d\xb6\x72\x19\x23\xb6\x82\x27\x99\x19\x17\x7f\x16\xb7\xdf\x7b\xe5\x82\x2a\x06\x2c\x1d\x3f\x5e\xdc\xcb\x34\xac\xd8\x78\xaf\x1d\xfc\x07\x24\x71\x9e\x22\x41\x28\x03\x18\x8b\xa0\x9e\xb8\x2a\x1d\x88\x38\x9d\x3e\x83\xb9\x3e\xca\x69\xc8\xda\xba\x58\xac\x36\x9e\x2c\xd7\xd8\xa3\x66\x9f\xca\x93\xf2\x34\x24\x8d\x15\x15\xf5\x12\x14\x41\x05\xa5\x65\x1d\x11\x47\x7f\x26\x1e\x89\x78\x82\x61\x7f\xd0\xdf\x97\x09\x52\x4e\x0d\xe7\xf3\xf8\xa0\xdb\xe0\x31\x90\x46\x03\x76\x7c\x0b\xeb\x97\xf3\xd8\xc2\xd9\x11\x30\x44\xfe\x9c\xc1\x0f\xd1\x34\x30\x34\x83\x52\x17\x22\xab\x79\x00\x3b\x46\x19\x50\x8e\xa0\xfa\x7f\x4c\x9f\x14\x1c\x68\x2b\xf1\x23\xa8\x93\xe2\xc3\x05\xc6\x30\xf0\x2a\xb2\x85\xfa\xfa\xe1\xac\x01\xac\x58\x3e\xc5\x59\x5a\xef\x9c\xb3\x0d\xf2\x10\x34\x0d\x3c\x77\x40\x67\xee\x30\xf4\xa6\x91\x17\x31\xc6\x6d\xd3\x0a\x31\x2f\xa7\xa8\xf0\x93\xe5\xe5\xfe\x60\xd4\xa3\xf0\x0a\x36\x65\x65\xdc\x17\xeb\xca\xf8\x78\x25\x6b\x72\x9b\xe0\xc4\x11\x75\xba\xdd\x36\xa7\xd3\xde\x99\x71\xf2\x36\x73\x67\xc6\x66\x56\x90\x3a\xd9\x4c\xf2\x4e\x84\xa1\xa9\xa0\xcf\x4a\x00\xa0\x30\x2b\x6e\x91\xc1\x80\x6c\x37\x49\xf3\x02\x55\xd0\x45\x1c\xab\x90\x8c\xe7\x60\xa7\x6c\x3c\x77\x4f\xad\x12\xd9\x71\x97\x29\xc4\x5f\x49\x73\x02\xf9\xc9\x9f\x0a\x2c\x49\x6c\x47\x86\x14\x8f\x17\x9b\xd2\x37\x0b\x82\x05\x93\x42\x7f\xce\xa4\xc0\x1f\x91\x45\x21\x9b\x5a\x20\xb6\x52\x5f\xb3\x9f\x10\x93\x88\x2e\xe2\xb2\x74\x7b\xaa\x29\xda\x5a\xdb\x32\xb5\xa5\xd5\x30\xbe\x2b\xde\xa4\xe8\xe1\xbc\xde\xee\xc9\xd3\xa7\x4f\xe9\x1a\x33\xbe\x2a\x5e\x15\xef\xcb\x54\x55\xd1\x63\x9a\x9a\xc6\x8c\xa9\xeb\xcb\x8c\xa1\x5d\xaa\xfe\x8c\xcb\xc5\x5b\x67\x64\x78\xde\xe4\xa2\x03\xfd\x19\xda\x40\x84\x0b\xb2\x60\xf3\x88\x01\x05\x80\x23\x4d\x32\xb8\xaa\x80\xe0\x95\x4b\xe0\xf3\x70\x6d\x62\x0e\x46\xb5\x21\x25\x21\x1b\x05\x31\x6f\x04\x29\x05\xd1\x32\xc2\xdc\x4f\x14\x2e\x52\xd6\x50\x12\x45\x69\x29\x70\x43\xf5\xd8\xe6\xb2\x69\x8b\x26\x8e\x8d\x2d\x6c\xbb\x6a\x7d\xd5\x82\x50\x20\xae\x9e\x37\x3a\xb5\x60\xc5\xe6\x9e\xb3\x2f\x3f\x71\x59\x4d\xcf\xd4\xc4\xa6\xbb\x46\xa8\x6d\xfc\xf7\xfb\xa7\x40\x65\x23\x2b\xfe\xeb\x83\xfb\x58\x93\x4a\xb5\x61\xf6\xf8\x59\xe5\x95\x33\xbc\xee\xe7\xc7\x4e\xa9\x48\x56\x9c\xbf\x72\xdb\x83\x1a\xcd\x13\xbb\xce\xbd\x8a\x1d\xb6\xee\xf1\xf9\x4f\xd9\x7f\x3c\xf6\x98\x5f\xfc\x1a\xe8\xfd\xa8\xaf\x3f\x80\x7d\xfd\x06\xb3\x8b\x50\xc0\xbe\xde\x9f\xee\xb7\xda\x95\x11\xbd\xcf\x17\x19\x1d\xe4\x34\x76\x6e\x12\x45\xf5\xd4\x4c\x9a\xd4\xdd\x5a\xd7\x95\x69\x75\x35\xa5\xbb\x33\x4d\x4d\x63\x5d\x65\x5a\x8d\x56\x83\xb2\x3b\xdc\xda\x69\xda\x79\xda\xd5\x5a\x46\x43\x69\xb5\x55\xee\xaa\xa9\x9d\x99\x2a\x73\xc5\xf4\xce\x4c\x85\x05\xc0\x95\x90\x25\x95\x14\xcb\xba\x15\x76\xbb\x1b\x59\xab\x5b\x20\x15\x04\xa6\x4b\xcc\xf5\xb9\x54\x6f\x5f\x0c\xde\x20\x71\x1a\x27\xf3\xe9\xc9\xc9\xc2\x44\x5c\x14\x1b\x65\x3b\x71\xc4\x64\x2b\x3e\x97\x95\x95\xd3\x1a\xde\x32\xcc\xeb\x4c\x82\xc7\x45\x2a\x03\x17\xe4\x7b\x13\x78\x51\x62\xd6\xca\xf5\xb3\x7a\x62\x7d\x2e\x29\x31\xeb\xe0\xa1\x8d\x8b\x40\xc7\xec\x03\xf7\x46\x1b\xc6\x78\xa6\x2c\x4d\xd7\x55\x4c\xeb\x9e\xdb\x38\x7b\xa2\x3f\xae\x9a\x92\xac\x9c\xd6\x39\xab\xfe\x64\xf7\x95\x93\x92\xd3\x83\x67\xae\x66\x76\x65\xfb\xf5\x87\x1d\x77\xcd\x58\xb6\x62\xca\x34\xb7\x01\xe5\x6f\x6d\x5c\xb9\x6a\x8b\x89\xd5\x2f\x69\xbf\x61\xbf\x46\xb3\x6d\x6e\x6b\x6b\x2c\x19\x8b\x3c\xd5\xd4\x1c\x8a\x87\xde\x9f\xb3\xbd\x43\xbf\x15\xef\x09\xc0\x7f\xd9\x33\xe0\x3c\x1a\x24\xe6\xa7\x6b\xb4\x2a\x1b\x41\xe8\x19\x97\xd7\xcb\xa8\xa8\x32\xb7\x3b\xe4\x55\x59\xad\x06\x93\x01\xce\x91\xac\x1e\x95\x9b\xe9\xf5\x94\x89\x72\x69\xb2\xc4\xf2\x05\x4b\x60\x16\xf6\x27\xeb\x19\x14\x41\xff\x14\x31\xc8\x47\x28\x74\x6e\x87\x58\x34\xa5\xd9\x30\x4b\x4d\xc5\xd2\x7e\x8a\x93\xe6\xc0\xa9\xeb\xae\x18\xbf\x7a\x83\x12\x8c\x9a\xec\x9a\x34\x7a\xd3\x21\x25\xa9\x53\x1e\xd9\x74\xd7\x93\x9e\xc9\x60\x94\x12\xb1\xc7\x7f\x21\xfe\x57\x66\x8f\xbf\xeb\x7f\xc1\xb9\x8e\x7a\x31\xbd\xff\x5a\x32\xcb\x1c\x0f\x0e\x3e\x20\x51\xc7\x7f\xfa\x1a\x94\x6f\x82\xd8\xc1\xf8\x30\x17\x74\x47\x3a\xa2\x46\x7b\x8d\x02\xb0\x3a\x1c\x40\x41\x79\x6d\x36\x9f\x55\xcf\x3b\x14\xd2\x69\x97\x51\x20\x85\x21\x9c\x5b\xb2\x74\x43\xa5\x41\x24\x5b\x55\xa4\x2c\x0a\x59\xc4\xb0\xc5\x06\x49\xcf\x81\x29\x33\xe7\x57\xf3\xac\xf9\x1c\x05\x30\x9b\x15\x7a\x5f\xe0\xb6\x03\xb7\x6d\xbe\x29\x38\x13\xf8\x14\x5b\x5a\xab\xbe\xf8\x35\x22\x2a\x49\xae\xbe\x6f\x03\x78\xdc\x1e\x1f\xf8\xfe\xf5\x35\x55\xd4\xd9\xa7\xaf\x07\x2f\xbe\x0e\xfe\x14\xb7\x8b\x1b\x44\xf1\x4b\x9c\xf3\x23\xd7\x54\x12\x70\x1e\x21\x1a\x88\x19\x69\x8d\x91\x88\xf9\xd8\x64\x2c\x99\x6a\x74\x2a\x4f\x00\xd3\x63\x19\xd6\xe9\x34\x5a\x2c\x3a\x84\x64\xa9\xcf\x58\x2c\x11\x18\x2e\xf7\x65\x12\x74\x84\xea\xcb\x44\x86\xa2\x57\x4a\x5b\x5a\xf9\x8d\x3a\x39\xb5\x83\x30\x16\xa0\x83\xb3\x85\x00\xd7\xb2\x8d\x93\x20\x50\x16\x2e\x24\xa8\x00\x89\xd7\x0f\xbc\x08\xa2\xf5\xe9\x5b\x1a\xcf\x3b\xaf\xa5\x3b\x9c\xda\x5c\xa6\xb6\x8f\xbf\x61\xd4\xb9\xeb\x9b\xbb\xc3\xf5\x5b\x03\xcc\x5b\x87\x2e\x7a\xff\x2e\x50\x79\xb7\x38\x78\x6d\x96\xb2\xe2\x75\xf1\x20\xf8\xd7\x2b\xdf\x80\xc9\x40\x57\xd3\x3c\xb5\x3c\x10\x76\x4c\xdb\x5b\x37\x6a\x4a\x34\x10\xb1\x95\xd7\xbf\xf6\xdd\xd5\xe2\xbf\x4e\x5f\x7a\xe5\x3f\x6f\x95\xd9\x2b\xbe\x14\xcf\x39\x89\xfb\x40\xce\xab\x22\x04\x18\x07\x25\x88\x76\xe8\xad\x11\x21\x17\x5b\x19\xaa\xac\xae\xb1\x29\xd0\x1e\xbf\xd1\xa8\xed\xce\x18\x8d\x81\x68\xd4\xdb\x95\x89\x0a\x01\xaa\x2b\x13\x18\x7a\x94\x9c\xe7\xeb\x95\x04\x37\x4a\x53\x2a\x1c\xab\x08\xbb\x13\x4a\x8d\xa1\x57\x61\x2c\x2b\x8b\x6c\x2c\x48\xc7\x26\xd9\x2f\x57\xcc\x5f\xf7\x64\x59\x57\x43\x75\xc7\xf8\x96\x40\x4d\x4a\x65\x9d\x51\x57\x3d\x75\x7c\x73\xb0\xae\x96\x59\xbe\xe8\xac\xe3\x97\xa0\xf3\xcb\x5b\xd1\x3f\xa0\xf7\xaa\x6b\x3f\xf8\x45\x83\x2f\xe4\xb3\x8f\xd9\x56\xe7\x0d\x79\xed\xa3\x82\x3b\xae\x7d\x79\x60\xd4\x07\x8f\x48\x64\x17\xe8\x24\x13\x8f\xbb\x55\x83\x9f\xb2\x19\xa8\x5b\xd8\xd4\xb4\x9a\x57\x09\x2a\x2b\x69\xb1\xd8\x4c\x34\x72\x53\x0c\x30\x6a\x37\xc1\x68\x4b\xa3\xe2\x35\x3c\x8c\x5b\x69\xa5\x31\x9f\x56\x5f\x10\x95\x37\x35\x15\x86\xe3\x20\x28\x25\x3b\x1a\x01\xd6\x20\x5b\x35\x9e\x75\xd5\x4f\x5c\x97\x1a\xb8\x2d\x29\x7e\xb4\x45\x05\xbe\x54\xfd\xe2\xb7\xe0\xc4\xd4\xe3\x9b\x66\x76\xd0\xa3\xf6\x98\x16\x2d\xf8\xe1\x59\x46\x8b\xab\x52\xe3\x54\x70\xc7\xa5\x4e\x69\x8f\xd0\x35\x78\x8a\x7e\x06\xf6\xb7\x89\xa8\x4a\x5b\xb5\x2a\x95\xce\x4c\x9a\x4c\x16\x03\xde\x49\x30\x08\x3a\xa5\x86\x47\xc7\x08\x70\xb8\x8f\xdc\x0c\x3c\x28\xa4\x46\xd0\xb7\xd5\xd8\xdc\x81\x78\x5b\x48\xb4\x4d\x7e\x7a\x9d\x12\x10\xbb\xc0\xac\xd6\x2d\x99\x69\xed\xe4\x67\x17\x1a\x52\xa3\x4f\x9f\xa2\x2e\x80\x03\xa0\x8c\xac\x5c\x3b\xd7\x22\xed\x73\xe3\x7e\x61\xff\x60\x08\xd3\x21\x8c\x75\xf5\x2e\x15\x04\x9d\x98\x83\x28\x20\x71\x10\x49\x5c\xb4\xf4\x33\x68\x2f\x1c\xc1\x22\xa3\xcf\x90\x06\x78\x33\xfa\x8c\x4f\x9f\xe5\x29\x5a\x26\xb6\xe1\x3d\x61\x2d\xe1\x22\xc6\x10\x2b\xd2\x6e\x4e\x5f\x5f\x4b\xd8\x3d\xa3\x2b\xbd\xa3\x46\x8d\xb6\xd7\xea\x99\xb1\xd0\x64\x9a\xd1\xab\xe6\xea\x14\xea\x75\x5b\x26\x99\xac\x76\xb9\x47\xf7\x65\xc2\x6e\xde\x8c\xaa\x09\x69\x9d\xaa\x2f\xa3\x2b\x5c\xbf\x0b\xd8\x35\x93\xa5\x2c\xab\xd9\x5d\xd1\xc2\xe2\x14\x10\x90\x91\x95\xe4\xca\x15\xbf\x13\xe4\xc9\xe4\x39\x5c\x50\x2c\x9f\x8b\x1a\x53\x54\x84\x5e\xff\xd0\xed\xd7\xfe\x79\xfb\xfd\x7b\xaf\xf9\xec\xfa\x81\x7f\x7d\x29\x7e\x71\x02\xb4\xbd\xb7\xf7\x6f\x5b\x1f\x15\x9f\x22\xa7\xc2\xbe\xfb\x5b\xba\xc2\xa6\x78\xc6\x31\x43\x3c\x6f\xe3\xb6\x4b\xa6\x76\x4f\x0c\xc5\x05\x47\xe3\x95\x37\xc7\x1f\x3b\x9b\x4a\xbf\xfb\xb7\x57\xc5\x2b\x5e\x3a\xf9\xf9\xb3\x60\xc3\xc0\x06\x10\xfe\xe6\x9f\xe0\xaa\x37\x2f\xfd\xfe\xce\xef\xc4\xf5\xbf\xa4\x9e\x1b\x28\x03\x37\x9f\xdd\x1d\xaa\xe4\xe2\xd6\xf2\xce\x9d\x03\x4b\xde\xb8\x6d\xaa\xe1\x97\xfd\x56\xa0\xeb\xa1\xe6\xda\x09\x69\x9c\x89\x6d\x5c\x18\xea\x5d\x43\x38\x88\x51\xc4\x92\x74\x03\x21\x24\xab\x39\xab\xab\xa9\xc2\xdd\xd8\xd8\x64\xad\x16\x98\xd1\xbe\x48\x64\x0c\x7a\x35\xa6\xaa\xbe\x3b\x53\x53\x53\xe5\x72\x36\x75\x66\xca\x9c\xbc\x49\xd9\x95\x31\x09\x5a\x38\xf0\xb4\x96\xff\x4f\x7d\x65\x94\xf3\x02\x04\x74\xd6\x56\x3c\xe2\x7e\xa2\xa7\xbe\xec\x9b\x7f\xc6\xbe\x33\x9e\x9f\x7b\xe7\xdc\xe3\xfb\x9f\xbb\xe2\xef\xb7\xa0\x7f\xc0\x8d\x3f\xda\x45\x68\x68\xee\xfa\xcf\xcd\xc0\x7e\xc3\x69\x91\x7a\xef\xb1\x7b\x81\x61\x2f\xfc\x57\xfc\x6a\xef\x4f\x75\x0f\x49\x2c\x1f\x3c\xc4\x0a\xcc\x0d\x84\x9d\x48\xa2\x9d\x73\x07\x11\xd1\x12\xda\xba\xfa\xa0\xdb\xea\xee\xcf\xf8\x7c\x70\xee\xb5\x1a\x2b\xaa\xe9\xea\xbe\x4c\x3c\xce\xa9\x68\xc4\x4a\xf3\x96\x9c\x41\xdb\x92\x74\xc8\x97\x05\xc4\x1c\x46\x68\x12\x32\x09\x83\x05\xa3\xc9\x71\x12\xc3\x40\x98\x48\x99\x2c\x56\xe9\x8d\x66\x80\xc9\x33\xa4\x37\x74\x80\x5c\xfe\x38\x98\xfe\xb1\x3a\x15\x0c\x36\xaa\x3f\x03\x96\xe7\xc5\x13\x1f\x6a\x1a\x82\xc1\x94\xfa\x7f\xc5\x3f\xbf\x76\xe8\x06\x5d\xd2\xe7\xab\xd7\x5d\xff\x8f\x5b\xee\xdb\xa9\xad\xf7\x05\xea\xb5\xbb\xbe\xdd\x43\x92\x9f\x83\x2d\x1f\x2b\xbc\xe5\x51\x9f\x41\xfc\xf8\x77\x5f\x88\xe7\xbf\xab\xf4\x44\x22\x5e\x1d\x88\xbc\x7f\xfc\xaf\x66\x67\x20\xe8\xe2\x4e\x82\x73\x1f\x79\xe4\x94\xc5\x15\x08\xb9\x99\xb7\xc4\x1d\xf8\xdc\xf1\x10\x3d\x9b\x56\x42\x59\x6b\x89\x74\xda\x2b\xc9\x9a\xac\x83\x52\x5a\xd3\x56\x77\x57\xc6\x6a\x89\x26\xe8\x44\x57\xa6\xb2\x12\x4a\x2a\x14\x4a\x1a\x23\x1c\x36\x01\xbe\x2a\x16\xb4\x21\xc7\x36\x81\x59\x82\xb2\x54\x0a\x05\x82\x92\xf5\x75\x59\x31\xc9\xd6\x8b\xff\x74\x03\x92\xab\x41\x73\xdb\x13\x57\xfc\x71\x27\xbc\x0c\xa4\x34\x77\x9c\x38\x32\xbb\x4b\x5b\xef\xf7\x37\x68\x67\xdd\x3a\xeb\x80\x24\xf7\xec\x9b\x67\x81\x0d\x7b\x81\xe2\x6e\x95\x17\x46\x72\x8a\x5f\x3d\xb4\x4f\xfc\x6e\x8f\x12\x5f\xbf\x77\xcd\xe6\x6b\xd4\xee\xb2\x90\x5b\xbd\xe7\xdb\xab\xff\xe3\xf6\x84\x23\x1e\xf5\x4d\xdf\x41\x1b\x5f\x3e\x78\x4a\xf1\x17\x6e\x03\x3a\xf9\x27\xe6\x10\x37\xa7\x9d\x75\x35\x1d\x9d\x6e\x03\x63\xe8\x34\xd7\xf0\x6c\xd3\xa4\xa6\xd8\xa4\x99\x33\xc3\x31\x2a\x33\xb7\x25\x8c\xf0\x03\xf4\x99\x96\x96\xf2\xc4\x94\x86\x44\x43\x5f\x66\x7a\x32\x99\xa0\x39\x69\x17\x80\x4e\x98\x6d\x3e\x8a\x48\xf0\x3c\x41\x68\xd0\x07\x75\x19\xa2\x27\x41\x4f\x18\x53\x3e\x06\x7a\x4a\xe5\xd9\xd3\x24\xa8\xfc\x97\xb2\x3e\xa7\xb5\x49\x90\xaf\x93\xf9\x42\xb8\x7c\x54\x54\xe8\x67\x22\x97\x1e\xba\x8c\x01\x99\x70\xa2\x19\x18\x4d\x28\x1b\xad\xbe\xae\x8a\x94\xf2\x4d\x28\xd8\x55\xe8\x80\x29\x87\xd9\x86\x80\xea\xb3\xe7\x4b\xc9\x82\x53\x29\x14\x08\xa0\x4e\xc6\x36\xc6\x34\xcf\x3b\xff\xfc\x79\x69\x53\xfd\x39\x9b\xc6\xf4\xc7\xaf\x69\x98\xe2\xb8\xf1\x93\x73\x2f\x52\x5d\x60\x77\xdb\x47\xc5\x42\xd5\xcc\xa6\x47\x1a\xff\xe7\x1b\xf1\x4b\xf1\x97\x8f\x81\xe9\xef\x9c\x78\x34\x39\x81\xec\xbf\xfd\x5b\xf1\xf3\x93\x2f\x2c\x7a\x64\xc1\xf8\xd1\xb7\x2e\xbd\x0f\x58\xee\x3f\xb0\x67\xf7\xa5\x8d\x13\x92\x9b\xf6\x2c\xff\x0c\x70\xef\x8a\xdb\xb9\x0d\xbd\x33\xc1\x9a\xb6\x40\x70\xc7\x65\x37\x8a\xaf\x9f\xb1\x3c\xd8\x18\xaa\x16\x0c\x06\xbb\x2d\x52\x95\xfc\xcf\x96\xce\xf6\x5b\x40\xe0\xf4\xf7\xe0\xe2\x93\xe8\x3c\x6a\xa9\xb8\x50\xbc\xf5\x83\x3f\x2f\x39\xfb\xbc\x05\x2f\x81\xb5\x6f\xbf\x7b\x6a\xe9\x01\xe0\x2b\xb3\x89\x9f\x7c\x7f\x5a\xbc\xf8\x4d\x3c\x07\xb5\x0d\x9e\x62\x13\x2c\x03\x23\xfa\x49\x50\x3f\x57\xa7\xa7\x0a\xda\x19\xed\xd1\xca\xd1\x95\xed\x53\xb5\xad\xac\xa5\xcc\xc2\x95\xd5\xd6\x92\x1c\xd4\xcf\xa8\xb1\xdd\x99\x51\xea\x59\xd3\xa7\x52\xea\x86\xd6\xd6\x86\x86\xf1\x3d\x99\x06\xb5\x8b\xec\x86\x11\x18\xad\x0e\x1b\xd5\xc6\xae\x4c\x8c\xe7\x13\x6a\xc1\x67\xa7\xed\xdd\x19\x82\xb6\xe4\x75\x92\x2c\x54\x01\x62\x84\x29\xd6\xd1\x70\x3a\x61\x02\x91\x62\x5e\x08\xa4\x1a\x79\x8e\xcf\x66\x07\xa0\x59\xac\x30\x1a\x80\x73\xd8\x4f\x6a\x92\x76\x7c\x38\xf1\xe2\x4f\xef\x39\x71\xc1\x6f\xb7\xae\xba\x28\x96\xd2\x9b\x27\x86\xb7\xdd\xb6\xfe\x9c\xcc\x3d\x81\x46\xf5\xc5\x73\xd7\x1c\x9c\x7b\x4b\x55\x93\xbb\x35\x15\xab\x5b\xd5\x7e\xc3\xdd\xd7\x7c\x27\xfe\xdf\x8f\xaa\xd0\xb4\x7f\xff\x5b\x8f\x1c\x06\x86\x5b\xbd\xdf\xde\x60\x76\x88\xff\xfa\xe4\x9e\x5d\xf3\x5b\xdb\xe6\x5d\xf6\xd7\x5d\xc0\x65\xb3\xde\xf0\xad\xc6\xf8\xe6\xc3\x87\xc4\xbf\xdc\xc6\xda\x47\xd6\x5a\x16\xcb\x43\xf1\x05\xbb\x03\xae\xaf\x7a\x5c\xdf\xf1\x32\xd3\x25\xe1\x75\xb5\xe6\xf1\xba\x8e\x41\xdf\x74\x3b\xe3\x15\xc2\xb4\x61\x31\x21\xc0\xcf\x50\x67\x0e\xfe\x2f\xc2\x30\x84\xfe\xf6\x4a\x8c\xbd\x99\x86\x33\xa5\x0a\xb0\x2a\xd6\x63\x14\x04\xaf\xce\xd2\x87\xd9\x45\x38\xa2\x2f\xc3\x19\x01\x4b\xc3\x70\x82\x2e\x66\x46\x4b\x94\xe0\xcd\x86\xe4\x4d\x93\xb2\x02\x4b\xcf\xc1\xce\x5a\xa9\xfe\x49\x12\x86\xc9\x18\x71\x50\xfc\xc3\xdb\x08\x99\xf0\xb3\xaa\xf1\xa0\xe5\x48\xff\x23\xe2\xa7\x77\xbc\xf7\xdb\x4a\xf1\x6c\x1c\x22\x74\xab\x80\xfb\x1f\xff\x05\x9b\xdf\xce\x42\xcf\xee\xfb\xd3\x6f\x3e\xd1\x62\x5f\x67\xb2\xd8\x41\x2d\xc7\xb9\x7f\xe9\x74\x00\xb5\xd5\xa4\xd7\xb3\x2a\xca\x03\x1b\xdb\x95\x31\x18\x74\x02\x47\x74\x67\x38\x0b\x6a\x6c\xe7\x30\x8d\x2d\x44\x0b\xcd\xb6\x35\xc7\x89\x26\x27\xd9\xe0\x6c\x59\x2b\x39\xb6\xeb\x0e\x85\x68\x57\xec\x6f\xbe\xf9\xc0\x95\x3f\xec\x48\xef\xaf\x8a\xa7\x84\xb1\x8b\xce\xb8\x7b\xfe\x65\xdb\x66\x88\x2d\x78\xc7\xf2\x4c\xd5\xc3\x77\x1d\x01\xae\x87\xfc\x46\x94\x63\xb3\x4b\xbc\x69\xcd\xa5\x6a\x02\x0c\xde\x3f\x78\x8a\xfc\x01\xf3\x2d\xce\x4e\xd7\x30\x0a\x52\x0d\x34\x06\xde\x48\xf1\x1a\xb5\x42\xab\x54\x70\x7a\xbd\x99\x33\xa1\xff\xa2\x75\x04\x7a\x97\x56\xc1\x0b\xb8\x04\xa9\x08\x1d\x2d\x70\x70\x26\x7a\xcb\xda\x94\x80\x7f\xb0\x35\xe7\xe1\x81\x8a\x28\x31\x22\x9c\x95\x8b\x60\xef\xd1\x9a\x82\x7f\x41\x12\x58\xc9\xf5\xcf\xac\x7b\xa6\xf2\x19\xf1\xbb\x45\xc0\xf5\x74\xe5\xd3\xeb\xe0\x5f\xa0\x5c\x28\x7e\xf1\x0c\xf9\x9b\xd6\xdf\xb4\xce\x6c\x1d\x38\x4d\x06\xe1\x2f\x74\x09\x4e\x0f\x7c\xd6\x8a\x7d\x47\xf1\x08\x3d\x0a\x4c\x63\xce\x21\xcc\x84\xee\xb8\x59\xa9\xd4\xc1\x29\xf2\x4d\x18\x16\xd6\x54\x53\x72\x7d\x63\x43\xd2\x2f\x19\x3e\x8a\x92\xfd\xdb\x1b\x2b\xa2\x63\xc6\x34\x82\x45\xa3\x2a\x2a\x1a\x9b\x1a\xc5\xdb\xe8\xbb\x2a\x46\x8f\x89\x56\x8c\x52\x57\x8c\x1a\x05\xdf\xc2\xcf\xdc\x4b\xf7\x81\xa5\xcc\x46\x38\x67\x0b\x8f\xa8\x35\x1a\x06\x51\x50\xbe\x59\x8b\x9f\x6a\xac\x35\x06\xb1\xcb\xc9\xc6\x40\x7d\xaa\x16\x0e\xbc\xed\xef\x2b\xa7\xb8\x2e\xf6\x77\x36\xac\xdd\x30\x6f\xf9\xbc\xb5\x8d\x73\x98\x8d\xe2\x17\x3b\x82\x81\xb6\x35\x60\x66\x25\xc6\xe3\x22\xce\xa1\xa7\x83\x29\xcc\x3b\x30\x9e\x50\x1c\xe5\x00\x7c\x16\xe2\xb2\xcb\x66\xf2\x41\x4f\x03\x29\x0c\xb4\xa9\xfb\x56\xa6\xeb\x2b\x9a\x1a\xcb\xcc\xf4\x35\xcd\x89\xb3\xa7\xb7\x76\xd5\x04\x9b\xad\xbc\x59\xa8\x46\xcf\x58\x49\xf7\x83\x79\xcc\x49\xfc\x0c\x2c\xa4\x54\xe2\x58\x5f\x30\xb2\xc1\xbc\x73\xb7\x5e\xec\x0a\xb8\x1a\x22\xc9\x16\xa6\x6b\xd6\x79\xe1\x96\x70\xd2\x6c\xb1\x04\x02\xe1\xca\x09\x58\xae\xcb\xe9\x85\x94\x99\xb9\x00\x3e\xc3\x9a\x56\x43\xc1\x08\x9e\xf3\x72\x24\x47\x13\x89\xb7\xe6\xd5\x62\xbd\x50\x59\x4c\x74\x86\x4e\x9a\x03\xa1\x2a\xa0\x99\xb7\x9c\xdd\xcf\x3c\xfc\xd8\x66\xc0\x00\xfa\xb6\x23\xe2\xb7\x87\x76\x30\xc9\x95\xcb\x6e\xba\xb4\xab\x6b\x59\xff\xe8\x10\xd2\x81\xe2\x74\x4c\x3c\x42\x7d\xc0\x1c\x85\x7e\xaf\x93\x88\x12\x29\xa2\x95\x98\x41\x2c\x20\xd6\x12\xcb\xd3\xf5\x04\xd7\x1d\xf1\x4d\x71\xb5\xb5\x05\xa7\xad\x9e\x30\x66\x69\xe3\xc2\x85\x2d\x2b\xfa\xea\xab\xe6\x54\xf4\xf6\xd6\x9c\x61\x37\x70\x53\xa6\x2d\x5d\x31\xe7\x0c\x83\xe1\x8c\x39\x2b\x96\x4e\x9b\xc2\x29\xd4\x3a\x33\xad\x26\x12\x70\xbe\x34\x48\x46\x84\x0d\x29\x59\x98\xdf\x37\xe4\x02\xd5\x37\xb1\xe6\xa0\xd4\x9b\xc1\xba\x30\x55\xf4\x0a\xfc\xc8\x7b\xc6\x9f\xfd\xc9\xe2\x57\xc9\xf6\xae\x8d\xbd\xbd\x1b\xbb\xda\xea\x73\x57\x64\xef\x30\xff\xd9\x91\xbb\xfa\x6f\x63\x7d\x9b\x74\xd9\x9e\xcc\x5d\x1d\xcf\x5d\x7d\xd0\x9e\xec\xdd\xb8\xb1\xb7\x7a\x2a\xdb\x90\xbd\xfa\xef\x3b\xd9\x2b\x3a\x92\xbd\x12\x15\xd9\xab\x81\x77\x3b\x12\xe8\x2a\xd9\x4e\x47\xb2\x57\xa2\x22\x7b\x05\x75\x52\x2d\x2e\xa6\xde\x61\x69\x1c\xc3\xd6\x12\x13\x88\xd9\xc4\x2a\x62\x0b\xb1\x9b\x68\x4c\xfb\x26\xeb\xae\x9a\xb8\x2b\xde\x14\x68\xd8\xbc\xc8\xbb\x76\xde\xbc\xb5\xde\x45\x9b\x1b\x02\x4d\xf1\x5d\x13\xaf\xd2\x4d\xd6\x51\x26\x68\x5c\x89\x82\xce\x97\xfe\xd4\x54\x5b\x4b\xac\x8d\xaa\x6b\x48\x99\x59\xb3\xc9\x43\x4a\x89\x5a\xa8\x86\x15\x0d\x8d\xec\x36\x21\x03\x3d\x86\xa4\xbc\x1b\x85\xc6\x1e\xc0\xa6\x1e\x91\x63\x5d\xe9\x33\x00\x9f\xe0\x5a\xe5\xcd\x46\xe9\x73\x21\xbc\xc3\xc8\xc9\xbb\x59\xf2\xb3\x0b\xcb\x0e\xa5\x3d\x48\xcb\xd9\x8b\x2f\xda\x14\xa8\x08\xa4\x62\xc9\x71\x7f\xcc\x5f\x52\x73\xe6\xac\x0a\xb5\x94\xd5\x5b\x2d\x66\x3f\xb4\xfb\x69\xff\x5d\x59\xfc\x9a\x3e\xd8\xbc\x6c\x74\xbc\xcc\x62\x31\xc5\x6d\x9e\xaa\x09\xa7\x47\x17\xbd\xa4\xe6\xad\x9f\x38\x79\x4d\x65\x5b\xc4\xe4\x35\xc6\x7d\xe5\xe3\x4f\xff\x21\xff\x3a\xe1\x29\x1f\x7f\xbc\xf8\x61\xcc\xcd\xc5\xaf\x07\x5e\x18\xb6\x4d\xe2\x27\xc5\x4f\xa5\x02\xc5\xaf\x97\x8f\xd8\x24\x6f\x7c\x02\x3e\x77\x40\xb8\x93\xec\x20\x5c\x33\x62\xc4\x96\xf4\x38\xbb\x56\x6b\x40\xe9\x69\x6a\xa7\x93\x24\x29\x03\x25\xc4\x85\xca\x68\xd4\x8c\xcb\x03\xfd\xe1\xb0\xa7\x3f\x13\x36\x3b\x6d\x24\x66\x58\x74\xa8\xed\x1a\x5a\x70\x9b\x29\xad\x8a\xc2\x0c\x8b\x0a\xc1\xc0\x4a\xf9\x54\x79\x58\x2a\xa8\x6d\xf9\x5a\x78\x05\x7b\x27\x28\x73\xad\x29\x31\xcc\x81\x03\x9c\x74\x64\xc0\xc2\x2c\x84\x9b\xbf\x08\xde\x2d\x82\x61\xef\xc9\xa0\x0f\x21\xcb\xb3\x21\xd5\x91\x77\x11\x38\x8b\x78\x47\x16\xcf\xad\x00\x34\x55\x42\x7c\x9b\xd6\x7b\x55\x47\xba\x69\xf5\xb5\xf3\xc5\x7f\xd5\x1e\x34\xce\x45\xf0\x66\x32\xb0\x61\x0e\xe5\xad\x04\x03\xee\xbd\xa5\xdb\x5d\xe7\x6d\x9a\xf4\xad\x6b\x66\x06\xe5\xa9\xa0\x5a\xaa\xbf\xe1\xb9\x27\x46\xac\x4b\x8f\xf2\x06\x02\x2e\x3b\xaf\xd3\xc5\x8c\xd1\x68\x45\x45\xcc\x4e\x55\xc6\xa3\xbc\x5a\xed\xe1\x29\xd8\x39\x94\x42\x01\x17\x57\x85\x07\x15\xd5\x7b\x78\x63\xc8\x12\xea\xc9\x58\x2c\x86\x58\x67\xc6\x60\x16\x4a\x2b\xab\x50\x47\x14\xf6\x46\x4b\xc9\x79\x82\xec\x38\x17\xc8\x0b\x86\x29\xb2\x32\xe7\xf2\xd0\xc8\x4b\x8b\x45\x05\x0b\x86\x56\x5d\xc9\x39\x69\x7b\xe9\x17\xf2\x42\xfe\xb0\x6a\x68\x05\x56\xb9\x9c\x9b\xb6\x47\x3a\x43\xc8\xe2\x99\x20\xec\x9a\xae\x74\x54\xaf\xb5\x58\x54\xac\x83\x60\x09\xda\x43\xbb\xf5\xe6\xfe\x8c\xa0\x50\x2a\xfa\x33\x5a\xa5\x1e\xfe\xd0\x6a\xca\x02\x9d\x0b\x7c\x54\x90\xe3\x91\xc8\xe5\x23\x15\xa2\x98\x64\xb7\xeb\xe4\x84\xa3\x54\x32\x95\xc4\xdc\xd8\x70\xf0\x85\xe4\xcc\x24\x7a\x66\x36\xcb\xe8\xf8\xfd\xc2\x61\xc7\xf3\x8e\xf7\x84\xf7\x5a\xde\x7b\xed\x93\x81\x0d\x52\x42\x12\xb8\x15\xe1\x97\x50\x7f\x9d\x7b\xf3\xcd\x73\xc5\xdb\x8f\xce\xce\xe2\x98\xc8\xf5\x1a\xd0\xc7\x40\x95\x28\x68\x87\x4d\xeb\x70\xa8\x58\x2f\x6c\xb3\x3f\x60\xb4\x74\xe2\x16\xc3\xd8\x5e\x69\x84\x3f\x94\x9a\xa0\xdc\x79\x80\x83\xa2\xd6\x16\x30\xaa\x25\xb3\x98\x06\x91\x82\xb6\xa2\x99\x22\x94\xaf\xd7\xa0\x96\xfd\xe1\xb3\x05\xef\x96\x3f\x7b\x03\x7f\x43\xf9\x81\xf2\xf7\xf9\xf7\x17\xac\x5c\x70\xef\xfd\xe2\x99\xa8\x6c\x43\x7f\x76\x02\xe8\x40\xea\xae\xc3\x6e\x81\x4e\xcf\xf8\xf4\xd3\x19\x03\xbf\x12\xae\x6a\x41\x85\x1b\x0a\x23\x2a\xdc\x20\xb3\x78\x72\xb0\x9f\xfd\xc4\xda\xf4\x18\x03\x6f\x75\xd8\x1d\xbc\x40\x6b\xfd\x7e\x00\x58\x97\x96\xd5\xd2\x41\x3a\x40\xf8\xfb\x33\xe8\x2d\x3d\x0d\xdf\xa4\x94\xf0\x1e\xa5\xd2\xd7\x9f\x51\x72\x7d\x19\x25\x25\x3b\xa1\x86\x52\x00\x19\x38\xce\x24\xb6\x80\x12\x18\x99\x7c\xf1\x75\xfe\x34\x0f\x4f\xa4\xd0\x7d\x62\x83\x91\x5a\xe4\x3c\xa1\x39\x31\x06\xc7\xdf\xd1\xce\x1c\xd9\x29\x69\xff\xcd\x5f\x8f\xf6\xb6\xf5\x5f\x70\xc2\x72\xfb\xbc\x95\xad\x2b\xdb\xae\xdf\x7d\xe3\xd9\xa4\x4e\x1c\x9f\x1d\x4e\x0f\x1f\xf9\x7e\xe3\x92\x31\xeb\xeb\xe6\x36\x5d\x32\x7a\xeb\xac\x5b\xaf\xbf\x62\xe0\x72\xc9\x96\xe4\x9a\x51\xb8\x92\x57\x12\x9b\xd2\x69\x5f\xd0\x6a\x32\x9b\xa0\xff\xeb\xd2\xbb\x34\x24\xc9\x85\xf5\x9c\x9e\xa9\x62\xe2\x16\xc6\x6a\xf2\x05\x03\x41\x13\x65\xd7\xd9\x3d\x5d\x19\xbb\x45\x13\xd5\x45\x7b\x32\x3a\x41\xae\xe3\x20\x19\xb2\x33\xc3\x38\x89\x61\xea\x3b\x0d\x44\x8e\xf0\xb0\x50\xd6\x02\x61\x53\x05\xc8\x88\xd9\x52\x4e\x49\x62\xa8\x5d\x54\xa2\x0f\xa5\xce\x02\x54\x70\x7f\x51\x57\xef\x53\x88\xe3\x15\xe7\x7f\xbc\x4c\x01\x94\xc6\x07\xae\x3d\x7f\xf7\xfa\xa5\xe7\x4d\xd8\x74\xf1\x75\x55\x8b\x40\xf3\xca\xc5\x33\x16\x4e\xc8\x34\xb4\x64\xa6\xd6\x5f\xdf\x48\xce\x15\xff\x66\x4b\x24\x6c\xf4\x7b\xf6\xf8\x9e\xa3\xc7\x6e\xbf\x4d\xfc\xfa\xcc\x6b\x46\xed\x9a\xae\x3d\xa7\xba\x63\x53\xd3\x59\x9d\x1f\xae\x5a\x7b\xd1\xf4\xb1\x59\xac\x4c\xba\x81\xbd\x1e\xce\x2b\x13\xd2\x41\x9a\x61\xd4\x2a\x95\x82\x02\x04\x49\xf2\x0a\x1d\x46\x4d\xa4\x11\xd4\x8e\x96\x62\x54\x39\xd0\xa7\x6c\xfa\x52\xf6\x24\x27\x59\xc0\xf1\x03\x27\x80\xfc\x79\x2c\x35\x73\xdf\xb8\xd1\x62\xe3\x3b\xbf\x54\x0d\xbc\x8c\xe7\x43\x66\x2c\x98\x21\xce\xfa\x61\x05\x9a\xe6\x10\x80\xad\x54\x7b\x4c\xbe\x4d\x1f\x24\x94\x30\x4e\x08\x51\x34\x8d\x8a\xd7\x95\x04\x00\x6a\x5e\x9d\x50\x77\xaa\xfb\xd4\xb4\x92\x52\xc0\x10\x41\x41\xa1\x5d\x52\x05\xcf\x20\x2e\x9c\x64\x36\xb1\x3a\xa9\x2f\xfc\x72\xf4\xdd\x38\x9f\x8e\xbc\x25\x15\x11\x7f\x7b\xf3\x81\x3d\xe7\x2b\xc0\xf3\xf4\x41\xf1\xd8\xe9\x83\xe8\x68\x12\xc9\xfb\x25\xc6\x03\x46\xd8\xc6\x99\x74\xdc\xc0\x71\x16\x8a\x32\x02\x9d\x5a\x6d\x57\x32\x00\xd8\xf4\x18\xe5\xcb\xcc\x20\xac\x5b\x03\x0b\x0d\x1d\xa8\x28\x4b\x09\xca\x1b\x1e\x97\xf9\xf3\x18\x90\x75\xd1\xf2\x7c\x41\xd9\x79\x44\x2a\x70\xa0\x90\xd1\xa2\x7c\x67\x2b\x59\x8e\xfa\x61\xf9\x61\xe1\x70\xe6\x90\x8a\xd6\xd7\x8e\xd3\x2e\x78\x5f\x9c\x03\x2e\x12\xc4\xcb\x96\xff\xb2\xde\x41\x76\xce\x05\xdf\x3b\xeb\xc5\x2d\xc0\x6a\x12\xf5\x73\x07\x8e\x3a\x0a\x30\x45\xa2\xc4\xbc\x74\x8a\x28\x37\x03\x83\x89\xa5\x6d\xb6\x32\x9a\xe7\xbd\xaa\x32\xba\x22\x56\x6e\xee\x84\x8d\x83\x13\xbd\xa9\x1c\x10\x4a\xd8\x75\xe5\x26\x0f\xeb\xd7\xf8\x9d\xdd\x19\xbf\x45\xc3\x75\x67\x34\x42\x7e\xc7\xde\x8a\x90\x08\xd1\x9f\x58\x71\x30\x8e\x8e\xe0\x8a\x20\x43\xd0\xf9\x26\x34\xc4\x61\x90\x45\x22\x60\xcc\xb2\x99\xed\x32\x7a\xc8\xb6\x6b\x2e\xbb\x63\x51\xeb\xaa\x85\x93\xe6\x4c\x6a\xdd\x37\x16\x83\x8b\x34\xac\xbf\x64\x3e\x79\xdf\x9e\xe0\xec\xc9\x12\x82\xc8\xca\x45\x97\x36\xec\x8a\xdc\x1e\x9e\x31\xa5\x6b\x5a\x4d\x0c\x01\x8c\x8c\x3b\x73\x72\x7c\x07\xd2\xc5\x29\xb1\x03\xe1\x13\xc3\x15\x6d\x6d\xda\xad\x0e\x87\x63\x76\x8b\x57\x60\x29\x4a\xb0\xc4\xe8\x68\x3c\x5a\x19\x8e\x45\x63\x7d\x19\x75\x40\x1b\x40\x7b\x43\xce\x8c\x56\x4b\x46\x0d\x46\x57\x7f\xc6\x6a\x35\x3a\x49\x55\x7f\x86\x61\xc8\x22\x9c\xaa\x44\xfe\x20\x58\x4e\x35\x1e\x21\xa1\x02\x60\xcd\x64\xf1\xbd\x6b\x11\x10\x89\x3f\x0f\x3f\x69\xd0\xe7\x40\xbe\x51\x52\xd2\xc6\x43\x2a\xea\x7b\x89\xc0\xe0\xf5\xee\xeb\x0e\xbe\xf1\x91\xb8\x5d\x7c\x72\xf6\xcb\x89\xd8\x78\xd6\xb6\xb3\xe5\x8b\xef\x2e\xbd\xa8\xf9\xae\xd4\xd9\x12\xe1\x01\x02\xb4\x92\x60\xbe\x9b\x33\xe2\x97\x83\xe2\x0e\x71\xb6\xc7\xf4\xdd\x0e\x47\x0c\x9c\x0f\x96\x3e\xfb\x92\xcf\x3c\xb0\x2d\x9b\x7b\x0a\x08\x97\xd8\x4a\xad\xa0\x0e\x13\x21\x54\x77\xcf\xfa\x7c\x7e\x93\x9e\x0c\xd9\xd5\xea\x90\xde\x4f\x87\x23\xac\x4b\xe1\xea\xc9\x28\x14\xfe\xb2\xb2\x40\x67\xa6\x8c\x41\x64\x38\x65\xbc\xdf\xcc\xe3\x00\x9a\x77\x65\xcb\x2f\xa4\xa1\x38\x7c\xd9\x65\xf6\xf0\x20\x96\x2d\x35\xc0\xc4\x8c\x46\x09\xcc\x34\x9f\x5d\x8d\x7a\x83\x4e\x69\xcf\x9a\x73\xcf\xbc\x47\x76\x5f\xbd\x77\xfb\xbf\x6e\x5b\x77\x51\x22\xa5\x6d\xe9\xbd\xfd\xc1\xd9\x73\xc6\xdf\x55\x57\x71\x70\xef\x26\x05\xf9\x67\x72\xdf\x01\xe3\xc0\x57\x0f\x1e\xb9\xf3\x09\xf1\xcb\x9b\xbc\x80\x3d\x90\x00\x9a\xaf\x56\x6f\x9e\x99\xfa\x52\x1a\x5d\x18\x93\x59\xec\xc7\x98\xcc\x51\xe2\x86\xf4\x74\x3f\xc7\x39\x34\x8c\x46\x47\x19\xcb\x8d\xbc\xc1\x6e\x2a\x87\x4b\x2c\x11\x88\x44\x88\xa8\xc9\x6c\x60\x85\x50\x28\x26\x54\x44\x02\x3e\xa7\xc9\x6e\xb1\xf7\x65\x58\xad\xdf\xc1\xe8\xca\x8d\x46\x9d\x43\x4b\xab\xca\xdc\x16\x8a\x16\x0c\x51\x83\x86\x53\xc1\x25\x85\x54\xc1\x01\xf8\x4a\xce\x95\x6b\x49\x16\x52\xe1\x15\x20\xee\xe9\x4b\x31\x2b\xf2\x60\xe3\x68\x27\x21\x48\x05\xf3\x70\xb4\x3f\x82\xcf\xcc\x31\xd0\x9f\xdb\x94\x47\x5b\x9e\xfe\xf3\x30\x9a\xc3\x63\x90\x4b\x97\x43\x5d\x06\x4f\xfe\x24\x46\x33\xc6\xa4\x11\x97\x63\x4c\x9a\x09\xc4\x35\xe9\xa9\x44\x5d\x82\x69\x56\x57\x56\x2a\xe2\xe5\x1a\x67\x59\xc0\x8f\xe0\x68\xe2\xcd\x75\xcc\xc4\xd6\x32\x4f\xb0\xb6\x76\x54\x57\xa6\xd6\xe2\xab\x8f\x25\xb8\x44\x67\x46\xcd\xd5\x73\xc6\x09\x13\x8c\x5c\x3d\xad\x8c\x9b\xc3\x9e\xee\x4c\xd8\xa2\xe4\xad\xe3\xa8\x71\xdd\x19\x9e\x12\x72\xfb\x72\x92\x3f\x21\xef\x56\x64\xf3\xb1\x25\xcf\x4f\x3f\x6c\x86\x59\xf2\xe7\x01\xc8\x20\x5a\xea\x9f\x80\x90\x99\x7a\x77\xfb\x8f\x40\xc8\xec\x79\xf1\xed\xd9\x5d\xc3\x83\xc8\xa0\xf7\xa9\xb2\xe9\xbd\x23\x80\xc8\x0c\xfc\x16\x1c\xaf\x1e\x06\x47\x06\xbe\x27\x61\x5d\x8b\xab\x31\xd6\x75\x23\xaa\x70\xe2\x35\xc1\x90\xa2\xc1\x5c\xe3\x89\xc5\x6a\xaa\x1a\xec\x21\x52\xa3\x68\x1a\x55\xe5\xb0\xdb\x1d\x7d\x19\xbb\xbd\xae\x9c\x80\xd3\x3d\x51\x57\x07\xc3\x06\xad\x56\x55\x67\x0c\x85\xca\xcb\x7d\x7d\x99\xf2\x1c\x82\x1c\xda\xd8\x94\xb7\x33\x0b\xea\xf9\x4b\x07\x9a\x31\x17\xba\x45\xc2\x3f\x13\xf7\x1a\x93\xa5\xb2\xdf\xf6\xb7\x3b\xc2\xd5\xe3\xa7\xef\x5e\xd4\x1b\x1a\xaf\xf2\x5d\x33\x66\x24\x0c\xec\xc1\xaf\xa7\x5d\x21\xae\xae\x69\x32\xcc\x98\xb8\x5d\xaf\xb6\x00\xc7\x53\x66\xff\xe1\xbb\x46\x4a\x0b\x79\xfa\x43\xed\xb8\x15\x67\x5c\x28\x8d\xcb\xcf\xc4\xd5\x18\x57\xa7\x91\xd8\x98\x9e\xe8\x0f\x2a\x1a\x8c\x35\xce\x8a\x8a\x9a\x78\x83\x25\x48\x72\xda\x51\xda\xa6\x2a\x9b\xd9\x66\xee\xca\x68\x6c\x2e\x5b\x87\xed\x4c\xdb\x59\x36\x46\x43\xd9\x6c\x75\x11\x02\x4e\x3c\xb0\x6f\x84\xee\x8c\x4e\xa7\xae\xb3\x04\x83\x91\x08\xf4\x83\x22\xc2\x48\x7d\xd3\x37\x7f\x08\x10\x78\x69\xf7\x84\x23\xe1\x9f\xc2\xd6\x91\xd3\x3d\x70\xf7\xdc\x23\x77\x4f\xe3\xc4\x8e\x69\xde\x0b\x77\x9f\xb5\x65\xa4\x8c\x8e\xe7\x8e\xe7\xba\xa7\xa5\xc7\x64\xa9\x1f\xd3\xb8\x70\xe5\xb0\x59\x1b\xd7\xdd\xa9\x90\x7a\x06\x0c\x7e\x21\xf6\x63\x9c\x6c\x27\xd1\x97\xae\x45\x94\x39\x84\x55\x30\x3b\xed\x36\x9b\xd9\x6a\x01\x0a\x96\x35\x1a\xdd\xac\xcb\x2c\xe8\x30\x3b\x16\xe0\x59\x83\x1a\x86\x85\x98\x57\xc7\xc1\x1a\x10\x06\xaa\x3c\x29\x8d\x80\x8e\x5d\x60\x1e\xc3\xe0\x60\x4b\x50\xf0\x08\x16\xff\xcf\xc3\xc3\x60\x83\xfd\x18\x28\xfb\x99\x1b\xe0\x6c\x34\x2c\x10\xb6\x84\x92\x2d\x21\xe4\x4b\xb8\x40\x30\x4e\x44\xb8\x40\x66\xa2\x3b\x1d\xa3\x4d\x26\xb3\x5e\xc3\xa8\x04\x1d\xb4\x6b\x8d\xda\x60\x66\x2d\x0a\x85\x55\xaf\xe9\xcc\xe8\x69\x03\xc9\x9b\xcd\x2a\x04\xf4\xd8\x99\xe1\x24\x0a\x77\x49\x8e\x57\xa0\x1c\xc9\xd8\x50\x96\x86\x52\xd4\x1f\x34\xe4\x87\xc7\xfd\x81\x01\xdf\xa6\x61\x91\x7f\x50\x84\x27\x81\xff\x14\x61\x94\xfb\x88\x73\xd3\x63\x9d\x2e\xa5\xca\xa5\xf2\xd8\x3d\x24\x47\xa3\xc8\xdf\x40\xd1\x24\xda\xd6\x09\x08\x7e\x8f\x1c\xe4\xbb\x29\xbb\x5a\xc1\x38\x55\xf0\x47\xf0\xc1\x50\x9f\xc6\x91\xbe\x60\xe0\x0c\xf2\x11\xbe\xac\x05\xbc\xaf\x33\x44\x15\xd9\x48\x23\x57\x67\x94\x85\x27\x87\x82\x14\x6b\x06\xd7\xa2\x96\xa0\x94\x1f\x18\x3b\x63\xfa\xb5\x25\x1a\xba\xae\x6a\xb6\x0f\x1c\x2b\x02\x2b\x1f\x27\x1e\x05\x4f\x9e\x57\xac\xa7\x0d\x00\x3c\x08\x96\x60\xd0\x72\x09\xb7\xe9\x7e\x8c\x27\xb2\x28\x5d\xcf\x72\x66\x0b\x67\x51\xd2\x34\x9c\x89\x8c\x82\x52\xa7\x13\x78\x07\xed\x74\x19\x85\xce\x8c\xd1\xa1\xe0\x69\xab\x89\x61\x2d\xf0\x87\x74\x98\x75\x4a\xac\x29\x75\xa1\xa6\xb2\xa2\xea\x93\x25\x49\x80\x39\x19\xb1\xc6\x5a\x40\x92\x4b\x15\x62\x35\x21\x79\x83\xbf\x46\x25\xe2\xb3\x2f\xf6\xcf\x36\xbe\x3e\x5f\xd2\xdc\x6f\xff\xb1\x50\x71\xea\x81\xd8\x8c\xd4\x05\xcd\xb2\xea\x36\xbd\xbe\xe4\x45\xac\xbc\xcf\x07\xbe\xb7\xc6\xc1\x45\xff\x00\x63\xd6\x89\x87\x8b\x74\xe7\x87\xf3\x49\xda\xe3\x50\xa9\x8c\x3c\x47\x7b\x49\x92\xa6\xa0\x8f\xae\x25\x88\xa0\x36\x40\x7a\xbd\x76\x93\xc5\x04\xf5\xa6\x37\xe8\xfb\x33\x0e\x83\x47\xa1\xa4\xfc\x06\x83\xd6\x6f\xa1\x54\x18\x5d\x5e\x6b\xe0\xe8\xbe\x0c\x67\x28\xc4\xc9\x41\x45\x62\x7a\x49\x26\x22\x97\x6b\x3e\x64\x5d\x2f\xd4\x5f\x8e\xa0\x2a\x95\xc5\xc5\x86\x42\x8e\x88\x32\x7f\xe7\x61\xfe\x81\xa0\xa4\xc0\xe0\x0b\xfc\x8b\x89\x11\xd0\xe6\xa9\xcd\x73\x5f\x45\xea\x7b\x75\xae\xf8\x0f\x09\x71\x5e\xc6\xdc\x82\xb1\xbc\x13\xae\x29\x4d\x36\x93\x4a\xc5\xab\xa1\xad\x62\x99\xd5\x8c\x8b\x20\xdc\xa4\x1d\xe5\x6d\x5a\xb5\x3a\x6d\x57\xc6\xa4\xd3\x19\x14\x36\x18\xd4\x3b\x79\x03\xd4\xa7\x81\x50\x9b\x71\xed\xa4\xb9\x90\x50\x1b\x45\xc3\xc5\xb1\xc4\x50\x21\x73\x00\x5b\x59\x01\x29\x59\x3e\xea\x97\x85\x30\x5b\xcf\x6c\xd6\x6d\x2e\x43\x43\xb1\xe6\x3b\xdd\x77\xab\xd1\x70\xa4\x0e\x17\x01\x6e\xd1\x55\x5d\x6f\x40\xa5\xfe\xbd\x6b\xe0\x16\x34\x24\xa1\x0e\x6f\x90\x75\xe8\x21\x56\xa6\x9b\x9c\x98\x10\xc0\x25\x6b\xd0\x67\xb2\x58\xbc\xa4\xcb\xe5\xb0\xc2\x25\xd2\x09\xf5\xa6\xf5\x58\x2d\x16\xab\x15\xea\xd1\xfa\x23\xca\x93\x8f\xfb\xb2\x3b\x6d\xfa\x21\xa4\xc5\xc3\xa9\x4d\xc6\x05\xf9\x31\x6a\x80\x77\xaa\x67\x9f\x70\xa5\x27\xa6\xa8\xb2\x1f\xe1\x07\xb8\x49\xc3\x22\x70\xe0\x2c\x45\x00\x18\x5c\x2a\x63\xa4\x59\x89\x59\xe9\x2a\xa8\x2e\xa8\x2d\xb3\xac\x2d\x3b\xaf\xd7\xdb\x48\xb3\x59\x6b\x80\xaa\x52\x98\xa0\x9a\xac\x06\xbd\xde\xc0\x97\x28\x29\xf9\x93\xb2\x14\x68\x47\xa6\x0d\x1a\xa2\x99\x3d\xc1\x33\xd6\x4e\x4e\x55\x83\x6f\x67\x0f\xa3\x15\x2a\x63\x3c\x00\x34\xd2\x2c\x99\xe5\xde\x09\x62\xdc\xea\x45\xe9\xa4\xd2\xe9\x24\x0d\x7a\x18\x11\x08\x82\x1e\x06\x39\x3a\x9d\x97\xf0\x28\x1d\xfd\x19\x18\xe6\x31\x05\xbc\x15\x4e\x9b\xc4\x5b\x61\xc1\xc4\x15\xaf\x14\x73\x36\x26\xb3\x07\xe2\x43\x66\xc2\xe1\xd9\x76\xe4\x3d\x4f\x14\xc5\x5b\x24\xf6\x79\xbb\xe2\xe1\x33\xc9\x8d\x67\x4a\xec\xbb\x27\xf1\x46\xe7\xed\x8a\x63\x8b\x06\xb6\x2f\x3a\xa0\x28\x48\x7f\xe6\x0b\xd8\x5a\xa0\xcf\x5b\x8f\xb2\xa3\x65\x7c\x31\xb8\x26\x21\x7c\x31\x3d\x5c\x93\x2a\x74\x0a\x85\x12\x65\x92\x0a\x7a\x3d\xa1\xa4\x0c\x46\x81\xd7\x71\x5d\xd0\xb7\x60\x34\x1a\x55\x67\x46\xc3\x2b\xcd\x14\xc3\xc0\x99\x8e\x91\x74\x20\xbc\x92\x2f\xae\x93\x8a\x8b\x8b\x25\x08\xe1\x75\xa8\x00\x56\x2c\x49\x39\xd0\x02\xb4\xa7\x18\x57\xec\xfe\x89\xd2\xe2\x53\x00\x2c\x26\x73\x1d\x11\x04\x57\x8b\xd7\xa0\xd5\xe9\x94\x4b\x10\xcc\x3a\x8f\x87\x33\x73\x46\x8a\x20\x02\x46\x3f\xe7\x21\x49\x8f\xcf\xd3\x97\xf1\x51\x2e\x1e\xe5\x20\x1b\x6d\x4e\x8b\xcd\xd2\x97\xb1\x51\x82\x56\x61\x36\x9a\x61\x78\x6a\x2c\xa4\xc9\x2c\x3c\xfd\xce\x8d\x86\x6c\x05\x5c\x21\x2f\x1c\xc8\x86\x9f\x05\x55\x1b\x45\xca\xe0\x6a\x53\x13\x55\x9e\xa3\xb3\xea\xdf\x42\x78\xfd\xd9\xfe\x1e\xf8\x6b\x89\x4e\x98\xb1\x38\xdc\xfc\x61\x15\xae\x65\xa9\x2f\x49\x49\xe7\x1d\xf2\x1e\x0b\xfd\x19\xf6\x09\xe0\x38\x30\x6a\xb5\x3a\xb5\xd9\xcc\x42\x01\x59\x1d\x65\xb1\x9a\xd9\xae\x0c\x49\x9a\x79\xa3\xa6\x2b\x63\x34\xaa\xf4\x7a\x1e\x7a\x07\xbc\xce\xac\xe2\x3a\x33\x2a\x73\x49\x79\xe3\x90\xd3\xd9\x9c\x30\x38\xc6\x2c\x06\x78\xa3\x3f\xab\x46\x31\x25\x7f\xd9\x70\x30\x6f\x18\xd1\xe1\x54\x31\xd4\x9b\x64\xff\x1d\xdc\x3f\xa0\x3e\xaa\x88\xb5\x69\x8b\xd3\xc7\x52\x11\x9b\x51\x53\x59\x69\xa4\x7c\xb4\xa7\xda\x93\x88\xf0\x51\x1e\x6d\x06\xf8\x33\xd1\xa8\x27\x18\x76\x64\x8b\x0c\x6c\x46\x5c\x64\x60\xf1\x18\x10\x42\x3d\x4d\xe7\x11\x35\x8a\x54\x93\x1d\x0b\xc4\x70\x69\xa7\x23\x6d\x00\x94\x28\x47\xde\x2f\x60\x52\x23\x6c\x01\xbc\x3d\xb0\xfd\x6d\xa8\xb2\xbf\xa0\xba\x02\x15\xd3\xa5\x3a\xd2\x23\xef\x19\x74\x0c\xb7\x13\x40\xef\xfe\x61\x75\x5e\x65\x62\x7d\x76\xd7\x00\x8d\x9b\x4a\xb1\x95\xb9\x02\xfa\xec\x0d\xd0\x36\x47\x57\x95\x97\x47\x79\x0d\xe2\x56\x77\x9a\x58\xd6\xa9\x89\xd2\xa9\xc6\xaa\xb2\x9a\xb2\x9e\x0c\x61\xa5\xac\x3d\x19\x8a\xf2\xd4\x08\x95\x15\x9d\x99\x4a\x3e\x6a\x96\x8a\x10\x55\x7a\x94\xd1\xad\x72\x15\x02\x35\xb4\x94\x6e\x8e\x14\x81\x61\xcb\x3d\x51\x80\x16\x5c\xba\x59\x50\x5c\xaa\x8f\x37\x2e\x73\x65\xfc\xa9\xe6\x07\xa7\x5d\x72\x63\xe1\xee\x41\x77\x4f\xf3\x4d\xd5\xee\x5c\xdd\xfe\x43\x8d\xd9\x2a\xd6\xde\xe3\xb3\x97\x2c\x55\x80\xb6\xa9\x8b\x1f\xdc\x57\xbc\x9b\xd0\xdb\x78\x28\x5b\xc7\xbf\xf5\x0c\x5c\xce\x1a\x7f\xee\xac\xb3\x56\x2f\xe5\xc7\xe2\xfd\xf4\x47\x06\x4f\x31\xe7\x30\x1d\x44\x35\x31\x06\x5a\xc8\xa8\xc4\x28\x45\x60\x54\xa0\x26\x54\x53\xe9\xd6\xa6\x42\x16\x23\x65\x0c\x69\xe9\xb1\x95\x95\xcd\x89\x40\x34\xd9\x97\x09\x44\xa3\xd0\xa2\xed\x7d\x19\xb3\x59\x4f\xab\x50\x15\x8a\x71\x14\xcb\x12\x7d\x19\xd6\x38\x24\xe3\x00\x19\x78\xd3\x70\xfb\x45\xf9\xa4\x09\xb9\x1c\x13\xed\xcf\x66\xf3\x26\xe4\x90\x58\xa6\xeb\x4d\xe5\x72\x14\xd0\x4e\xae\xc5\x58\x97\xcd\x52\x68\x30\xd0\x93\x56\xae\xd0\xd7\xde\xd4\xdd\xd5\xb6\x7c\xe5\xe7\xe2\xdf\x5f\x01\xeb\xfe\x7c\xef\x25\xd1\x71\x4a\xff\xd2\xa6\xfb\xc5\x7f\x5e\x7f\xdf\x1d\x95\xc1\xfa\xd6\xf5\xaf\xac\xbd\x6e\xdf\xd1\xfb\x1d\x1b\xd7\x8c\xe9\xab\x4b\x84\xce\xda\x3c\x26\xd2\xe8\x08\xd9\xed\xa0\xec\xbf\x7f\x03\x17\x7d\x1c\xf8\xe2\x7a\xc1\xf1\xac\x78\xf7\xe7\x1f\xfe\x99\xa9\x7a\x78\xeb\x0d\xc4\xe0\x0d\x4f\xec\x7f\x54\xfc\xcb\x6c\x8e\x6c\xfe\x61\xdb\x7b\x9b\xe6\x3e\x10\x1e\x03\x0c\xb8\x9f\xa2\x83\xa7\xa8\x55\xd0\x76\x2a\x61\xc4\xb7\x34\xdd\x60\xa0\xe2\x36\x8d\x32\x50\x1d\xb3\x54\x5b\x92\xb6\xa4\xd7\xab\x8c\xd8\x28\xa6\x69\x54\x75\x34\x1a\xec\xca\x44\x2d\xae\x86\x2e\x38\xbb\x11\x1c\xa7\xeb\xca\xa8\xd5\x9c\x40\x58\x0a\xf8\xea\x13\x05\xc3\xbf\xd0\x66\x8a\x98\x90\xf2\xd4\xf5\xb8\x53\xb2\xf9\x19\xa3\x41\x58\x4e\xcc\xc7\x5b\x8a\x68\xd7\x00\x59\x15\x6b\xc4\x49\x6a\x92\x21\x81\xab\x0e\x3d\x76\x2d\x00\xd7\x1d\xdc\x18\x4d\x19\xc7\xad\x5a\x70\xff\x82\x0d\xe7\xb0\xb3\x3a\x2e\x9b\xb2\xf4\x82\x15\xf3\x0c\xc6\x89\x8d\xda\xc9\xcb\x27\x36\x4d\x08\xfb\x5d\x93\xa6\xc5\x2a\x52\xad\xa6\x47\x7f\x71\x0c\xb8\xef\x8f\x7e\x71\xd5\xe8\xdd\x03\xbb\xaf\xb8\xa1\x6b\x67\xdf\x5d\x73\x2f\x59\xba\xe8\x48\x23\xa9\xab\xab\x30\x9b\x41\xed\xb8\x85\x96\xd8\xbd\xcb\xc6\x4c\xbd\x56\xca\x4b\x10\x57\x63\xee\xcf\x04\x31\x23\x5d\xa9\x8c\x06\x6d\xbc\x3e\x6c\xd6\xdb\xcc\xee\x28\x53\x4d\x26\x12\x35\x71\x06\x86\x76\x20\x4e\x3b\x7d\xfd\x19\xa7\x25\x6c\x11\x04\x8b\x45\x03\x27\x93\x5c\x7d\xb3\x3e\x09\xc3\x5b\xa2\xa4\x66\x37\xbf\xbf\x36\x94\xb0\x99\x8e\x01\x4b\x11\x86\x2c\x0c\x79\x49\xb9\x73\x98\x31\xa8\x4a\xf9\x11\xf1\xd3\xbb\xb2\xf5\xc9\x0b\xc5\xef\xb6\x70\xd3\xae\x58\x28\xc7\xb9\xa3\x9b\x4e\xbc\x27\xb1\x81\x52\xdf\x3d\x18\x4b\x3c\x2f\xde\xf9\xbf\x72\x69\x72\x59\x3d\x0a\x5b\x71\x80\x3b\x61\xa6\xae\x02\x08\x27\x31\x23\x28\xc6\xc3\x11\x57\x63\x3c\x9c\x28\xd1\x91\x8e\x86\xcc\x06\x4a\x60\xbc\x50\xa1\x0c\xa5\x32\xb3\x15\x31\xbb\xbf\x2b\xe3\xf1\xd8\x05\x05\xf2\x76\xa8\x68\x94\xa2\x22\xdd\x19\x03\x95\xcb\xdc\x4a\xe4\xe5\x2b\x9c\xdb\x31\xb8\x0d\x57\x2c\x49\x04\x9b\x78\x59\x51\x1a\x8e\x84\x73\x33\xee\x68\x4f\x67\x4e\x88\x75\x4b\x57\x21\xc8\x9b\xf1\xbf\xa8\xc6\x90\x37\xfd\x07\x17\xbf\xbd\xf3\x8e\x6b\x9b\xe7\x28\x27\x64\x25\xb8\x28\xec\xbf\x7f\x2b\x42\xbe\xf1\x99\x50\x56\xce\xb5\xe2\x1e\x8c\x7b\x03\x65\xb9\x42\xec\x47\x7c\x45\x70\xbd\x9a\x96\x2e\xd3\x1b\x15\x1c\xc7\xb2\x5a\xa3\xd6\x02\xfd\x35\x2b\x30\x1a\x4d\x0c\x6f\x82\x8b\xb1\x89\x62\x65\x40\x7c\xa5\x7c\xa6\xa9\x2f\xe4\x7d\x4c\x0e\xe5\x62\x05\x12\xba\x40\xd6\xc5\x91\x1d\x36\xfa\x38\x82\x12\xa8\x39\xf9\xee\x42\xe8\xd8\x74\xa9\x3e\x3a\x99\x7c\x15\x93\x3a\x56\xd1\xe4\xbb\x06\xb8\xae\x8a\x31\xcc\xa8\x81\x19\x1c\x25\x7f\x66\x8a\xb8\x1c\xe1\x89\x42\x7b\x5a\x96\x4e\x86\x79\xde\x28\x08\xb4\xcf\xe1\x70\x02\x8a\xa2\x69\x8e\xab\x74\x56\x56\xd7\x84\x7d\x3e\x95\x39\x68\xee\xc9\x44\x83\x82\x74\x0e\x2b\x38\xcd\x74\x02\xe1\xca\x15\xe2\x7c\xb4\xe4\x97\x28\x7d\x3e\x8d\x35\xfb\x63\x28\xd8\xb8\x84\x4e\x4e\x43\x16\xdb\x9d\xc2\xd7\xd9\xcb\xfc\x1c\x9c\x9b\x89\x99\x75\xd0\x05\x7a\x62\x99\xb5\x22\x5e\x79\xfe\x62\x15\x02\x07\x3c\xa3\x72\xeb\x02\x78\x81\x67\x5f\x57\xdb\x83\xd3\xe6\x2c\x98\x74\xb8\x63\x66\xbf\x72\x69\x1c\xf9\x45\x64\xdb\xf9\xf1\x78\xaa\xf7\x92\x51\x03\xcf\x91\x6d\x97\x06\x17\xcf\xd9\xd2\x34\xf0\x1c\xda\xd4\x7d\x61\xd1\xa6\x35\xab\x97\x6c\x58\xb9\xd4\x32\x69\xe0\x41\x94\x9b\xb6\x1e\xc6\x0c\x51\xcc\x05\x84\x73\x88\x88\x36\xb1\x83\x6e\x82\xbe\x85\x09\xa1\x05\x12\x82\x02\xf0\x24\xc7\xf1\x02\x65\x66\x18\x0b\x50\xf0\x94\xc6\x20\x70\x24\x74\x4b\xa1\xe0\x06\x5e\xa7\xc4\xe8\x98\xce\x21\x84\x39\xd6\xa6\xe2\xf5\x18\x9d\x24\xc9\x1b\x0d\x59\x0a\x71\x24\x25\x98\x7e\x3f\x38\x07\x47\xab\xf3\xc4\xb6\xc9\x97\x28\xc4\x7e\xc5\xf9\xdd\xef\x2c\x53\x82\x35\x0a\x6a\xf9\xc0\x22\xf2\x56\x14\xac\x9e\xfe\xab\x38\x0e\x1d\x7e\x81\xa7\x29\x8b\x3d\x0e\xe3\x1c\x62\x81\xd4\x66\x18\x73\x2f\x48\x27\x8d\x3a\x9a\x20\x4c\x4a\xad\xd9\xe1\x00\xd0\x13\x62\x9c\x36\x9b\x0b\x86\xd7\x46\xc1\xd8\x97\xa1\xd4\x1a\x75\x1f\x22\x1c\xd5\x68\x38\xab\x40\xd1\x4a\x4e\x29\x47\x38\xb9\xd0\x54\x2e\xbc\xcb\xef\x2e\x14\x31\x2d\x20\xf4\x12\x2e\xeb\x2e\xf8\xa1\x17\x24\x57\x0d\x48\xe8\x15\x47\xc0\x5a\x5e\xdc\x95\x7e\x57\x35\x70\x93\xea\xa3\xb4\xb8\x8d\x07\x17\xfd\x79\xb7\x8a\x0c\xaa\x5e\x78\x0a\x6c\x3f\xa2\x02\xc7\x55\xb7\x90\x42\xaf\x78\x23\xde\x3a\x3e\xab\x97\xfc\x03\xf6\xe2\x76\x92\xe7\xca\xbc\x45\x6a\xb9\xaf\xb1\x1c\x06\x2d\xe5\x70\x18\x15\x1a\x93\xdd\x4e\x68\xb4\x2a\xc6\x69\xb5\xba\x8c\x2a\xde\x6e\xd2\x1a\x78\x43\x27\xe2\x92\x75\xa8\x55\x6a\xe8\xdb\xa9\xcc\x0a\x8a\xa5\x3a\x33\x6c\x71\xb7\x17\x86\x07\xc3\xc8\x11\x1a\x51\x0c\x40\x6d\xe2\xc5\x7b\x47\x4b\xbd\x3f\x5e\xbc\x43\x07\x16\x9d\xc4\x2a\x58\x96\x57\xce\xa4\xde\x5e\x71\x37\x56\xc2\xea\x5e\xca\x00\xb5\x60\xcd\x69\xe7\x94\xe4\x77\x3f\x25\xf6\x23\x4e\x29\x18\xe7\xac\x4e\x37\x29\x48\x80\xc8\xf9\x08\x40\xdb\x54\x36\xb7\x8a\xe7\x95\x56\x37\xed\xd4\x3a\xbd\x5a\x8f\xdb\xa6\xb7\x18\xa1\xc3\x6d\x25\x94\x02\x21\x68\x1d\x46\x8a\x57\x00\x95\x16\xf1\x51\xd2\xda\xe2\x68\x47\x1e\xeb\xc3\x6d\xfc\xe4\x01\x01\xf1\xc6\x15\x1a\xfe\x94\x5c\x72\x5e\xac\xa2\xaf\xbf\xbe\x05\xc5\x37\x8f\xab\xf6\x3f\x24\x9e\x7b\x8f\x4a\x9c\xaa\xba\x05\xfc\xf1\xcd\xdd\xa8\xc2\xe3\xfa\x6b\x40\xcb\x65\x2a\x70\xab\x6a\x0f\xf9\xf7\x81\x3e\x39\xcc\x01\x3f\x88\x0c\xf6\xbc\xe7\x93\x69\xec\xc0\x2d\x03\xb7\x4a\x54\x3b\x50\xc6\xcf\x61\xdc\x73\x31\xd4\x57\x84\x68\x4f\x97\xe9\xd4\x41\xaf\xa7\x8c\x27\x8c\x46\x87\xc3\xe3\x56\xa9\x99\x28\x82\x85\x29\x53\xf1\x6e\x95\x9b\xb6\x6a\xf9\xa0\x1f\x21\x4e\xbe\x92\x6c\x19\x06\x16\x26\x7f\xb4\x98\x32\xc1\xc5\x15\xa5\x5d\xa4\x42\xb0\xe1\x49\xa3\x04\xf4\x2f\x65\xf2\xf3\xb9\x4d\x39\x1d\xb8\xb6\x42\xf1\xb8\x30\x69\x3c\xd0\x1f\x5e\xa5\xf8\xf7\xae\x8b\xd2\x75\xe5\x46\xc5\x51\xf3\xd5\xbf\x7e\xf6\x7c\x38\x31\x5c\x7f\xf0\xfe\x54\xb2\xd7\xa5\x8e\x6b\x3d\xde\x59\x63\x45\xb0\xc3\x1e\x17\xf7\x6e\x18\xdb\x66\x17\xf4\x6c\x5c\x70\x8e\xb9\xe4\x75\xb1\xdd\x8c\xc3\xa5\xeb\xf7\xd7\x4b\xf9\x87\xc4\x7b\x62\x3f\xa7\xc3\x7b\x05\x2b\xd2\x49\xb3\xc1\xe0\xd2\xe9\x04\x87\xca\x45\xa2\x04\x1d\x44\x1f\x25\x50\x5e\x82\xf0\x99\x60\x58\xe7\xb2\x9b\x49\x8d\x1e\x51\x3c\xeb\x29\x07\x25\x1f\x1b\xb3\xf9\x29\x3a\x6f\x79\xf9\x79\xba\xb4\xde\x57\x02\x38\x2a\xcc\xc1\x29\x21\xe5\xc5\x11\x92\x4e\x62\x0e\xc5\xec\x5f\x27\xcd\x57\xc0\x59\x3b\x45\xad\x42\x51\xd3\xa5\x2d\xc6\xb7\x30\x0d\x58\x51\x9e\x4d\x01\x09\xef\x0f\xeb\x11\x23\x92\x74\x06\xb7\x9c\x66\xf1\x19\xdc\x39\xe9\x26\x83\xc9\x6e\xb1\x84\x10\xe5\xa5\xa0\xe5\x42\x21\x02\x0a\x86\x08\xa2\xb4\x26\x2a\x1c\x09\xf1\x36\x93\xc9\xec\x14\xcc\x42\x57\xc6\xcc\x73\x7e\x95\xbf\x27\xa3\xb2\xb0\x00\x0e\x2c\x33\x3d\x24\xa9\x26\xbb\x08\x95\x06\xac\x92\x9f\x6d\xc8\x27\x3b\x14\xe7\xd2\x64\x85\x84\xeb\x6a\x3e\xa7\x86\x66\xf7\x6e\x2c\xc8\xa1\x59\x3c\x2b\x39\x39\x55\x4d\x6e\x80\xc1\x55\xe5\xec\x39\x72\x2e\x0d\x75\xf8\xf4\x1e\x6b\x3e\x81\xa6\x87\x1c\x8b\xb7\x15\x60\x90\x25\xea\xb2\x69\x34\x58\x8f\x7f\x84\xe3\x0e\x71\x9f\x05\x88\x95\x69\xab\xcd\xe9\x34\x0a\x6a\x9f\x4f\xd6\xa2\x40\x06\x09\xa2\xcc\xad\x45\x01\x96\x23\xa3\x76\xbb\x15\x66\x9f\xbc\xf5\x1a\x30\x53\xc3\xa8\xb2\x78\x8b\xa1\x34\xa7\x23\x99\x9f\xcc\x0b\x14\x39\x02\xdd\x19\xf3\x29\xa2\x36\x42\x63\x6f\xd7\x08\x84\x67\x92\x2e\xe5\xe5\x78\x04\xd6\x33\xc9\x56\x9b\xe0\xb8\x43\x98\xcd\x2e\x22\x93\x8e\x09\x46\xa3\x56\x05\x95\xe8\x72\x39\x19\xb8\x46\xab\x9c\x6e\x8f\x83\xb7\x70\x3d\x19\xc6\x62\xa1\x79\x5e\x8b\xf0\xf1\x69\x57\xc9\xba\x9c\x83\x6a\xc9\xe3\x99\x95\x88\x24\xad\xc8\xec\xf0\x39\x50\xd4\x62\xa8\xaf\xc3\x45\x90\xcd\x59\x2c\x67\xbc\xdc\x16\x63\x36\x97\x67\xc1\x9c\x89\x02\x6e\xba\x08\x71\x6e\xba\xcc\xe7\xd7\x68\xfd\x5a\xa5\xc3\xe1\x76\x9b\x0d\xca\x50\x88\x34\x90\xe5\x04\x11\x0d\x39\x48\xb3\xd5\xdc\x97\x29\x0b\x78\xbd\xb8\x3e\xd1\x94\xd1\x7a\x7d\x3e\xaf\x96\x62\x23\xd6\x21\xac\xff\x72\x86\x29\x56\x54\xc1\xb2\xd5\xd4\x54\x68\x8f\xf9\x3d\x71\x79\xd6\xc7\xa7\x31\xa5\xaa\xb2\x42\xd9\x1a\xf2\xda\x52\x61\x72\xba\x0b\xce\x0f\xcf\x0d\x71\x85\xfa\x7a\x75\xf6\xdc\xd9\x6b\xb6\xe4\x55\x86\x96\xb3\x37\x46\x5b\x7e\xfb\xab\x62\x95\x3d\xc9\x83\xbf\x88\x36\x55\x54\x56\x5c\x1e\x6b\xbb\x8c\x58\x93\x4e\x79\xbc\x0a\xa5\x57\xc9\x98\x99\xb2\x32\xc2\x6c\xb3\x19\x78\x82\x0f\x87\x82\x0c\x43\x97\xf1\x9c\xca\xad\xea\xce\xf8\xdc\x6e\x8f\x12\xfe\xd0\x26\x84\xdd\x6b\xe2\x8b\x40\x7b\x31\x1e\x0b\x5c\x80\x0c\x4d\x59\x68\x3a\x43\x11\x00\x77\xc9\x51\x80\x84\xbe\x8d\x44\x2e\xd5\xe8\x68\x8c\x4c\x89\x0a\x50\xa9\x2b\x25\x20\xee\xb9\x0b\x9c\xbd\xa6\x40\x59\xa1\x6a\x75\xda\xea\xde\x58\xd3\x62\xdf\x18\x38\x0c\x31\x24\xf7\xfa\xd4\xde\xf5\x8a\x62\x15\x93\x40\xff\xad\x77\x51\x3d\xe8\xcd\x9d\x7d\xd0\x5f\xe0\x71\x78\x66\xda\x68\xd3\x68\xf4\x14\xcb\xfa\x3d\x7a\x0f\x5f\xc6\x07\x6d\x4a\x54\x82\x8a\xaa\xe6\x9c\x4e\xde\x24\x15\x09\x9b\x28\xbf\x86\x42\x50\xfc\x19\xc0\x0f\xbf\xe1\xa4\x2f\x66\x1b\x94\x24\xc3\xa9\x28\x92\xdf\x58\x7c\xc6\x91\x03\x04\xb5\xd2\x9f\x0c\x9c\x56\x1e\x6d\x53\xad\xd9\xd4\xff\xcb\x73\xa4\xb4\x7f\x04\x88\x50\xa9\x7c\xb9\x73\xe9\xbb\x13\x7e\x71\xaf\x6e\xd2\x8d\xf5\x0e\x70\xdd\xa8\xea\xfe\x33\xe3\x03\x9b\xb2\xa9\x3b\xf5\x4e\xb1\x25\x18\xbf\xf4\xda\xe6\xe9\xe2\xd9\x0e\x09\x63\x1f\x61\x0c\x42\xbf\x70\x2a\x8e\x3f\xbd\x83\xa7\xd8\x59\x30\xe6\x2a\x23\xe2\x50\xc2\x04\x4b\x95\x9b\x4c\xca\xa0\xc3\x15\x13\x04\x57\x90\xa2\xab\x12\x46\x82\xa6\x09\x05\xd1\x9f\x29\x57\x28\x7c\x5a\xa7\xd3\xe7\xb3\xf6\x65\x7c\x46\x6d\x08\xe5\x1c\x11\x25\x85\xfc\xc9\xdc\x56\x5a\x11\x7a\x98\x74\xac\x88\xb7\x6d\xa0\xa2\x10\x8d\x95\x8f\x86\x32\xf9\xb9\x5c\x24\x86\x28\x4e\x08\x7d\x0a\x04\x08\x0a\x23\x01\x3f\x5e\x3b\xd3\x18\x1b\x6f\x0e\x35\xcf\xf1\xbc\x0b\xc6\x3f\x05\x00\xd0\x84\x7e\x38\x45\xbd\xfc\x4a\xff\xdb\xad\x13\xd2\xa3\x76\x7c\xb1\x41\xfc\x5e\xfc\x13\x49\xfe\xe5\x0d\xf1\x8f\x15\x54\xbb\xed\x20\xd9\x69\x50\x7f\x7f\xab\xf7\x0d\x50\xf7\x3f\xff\xfc\xbf\xbb\x2e\x99\xf9\xd9\xaf\xc7\x8d\x7a\x4d\x7c\xa9\x26\x0a\x5c\x80\x19\x4f\x3e\x20\x3e\x27\x7e\x79\xf9\xc5\xff\x73\x3f\x92\x99\x1d\x3c\x45\xd7\xc0\xb8\xa0\x8c\xa8\x22\xe6\xa4\xe3\x2c\x15\x32\x9b\x95\x81\x72\x28\x71\x80\xa2\x13\xd5\x26\x49\xe2\xce\x4c\x48\xa1\xf0\x42\x89\xbd\x5e\x5b\x77\xc6\x6b\xd1\xc6\x64\x48\xe3\x9f\x90\xb8\x44\x5e\x6b\x32\x9b\x71\x4c\xf3\x32\x8a\x7c\x16\x2b\x4a\x3a\x6e\xc6\xa1\xc2\x3e\x28\x6f\x64\xbc\xb9\xac\xa5\xc9\x75\xfb\xaf\xcf\xbd\xf0\xa6\x5b\xc5\xcf\x1e\xa3\x57\xad\x98\xbb\x67\xbc\xfb\xcc\xb7\xce\xbc\xe7\x21\xfa\xf1\x57\xbe\x1a\x3b\xaa\xed\xb2\x7e\x70\x87\x41\xfd\xf1\xad\x1e\x72\xfb\x9f\x36\xaf\x3b\x33\x73\x4b\x9f\x66\xf2\x96\x6d\x63\x23\x15\xd3\x7b\x1f\xf9\x45\xac\xbc\x85\xbf\x7d\x5d\xd3\xa4\x73\x9e\x43\x7a\x15\x1f\xc7\x7a\x0d\xc3\xe8\x67\x45\xba\x81\xa5\x2a\xa0\x5e\x43\xde\x80\xc3\x15\x47\x72\x86\x28\xa6\xba\x26\xa7\xda\x0a\x85\x42\xeb\x0f\xa4\xbd\x01\xa7\x33\x10\x80\xea\x0d\x18\xb5\x91\x21\xea\x4d\x3a\x84\xb7\x46\x50\xf1\xcf\x54\x32\xde\x89\x0a\x13\xf5\x3f\x5b\xcd\xbf\x7e\xa9\xe1\xdc\x86\x1f\xc4\x7f\xfd\xb4\x9e\x3b\x55\xe2\x9b\xa0\x4e\x05\x5c\xff\x2d\xd5\xb5\xf8\x38\xd6\x75\x84\xa8\x41\x3b\xf5\xd0\xbe\xa1\xae\x61\x3f\xc4\xe4\x5e\xa8\x4d\xe6\xd4\x0d\x0d\x5c\x1b\xf0\x7b\xd3\x79\x8d\x57\x95\x6a\x1c\x76\x41\xf2\xe7\x99\xf9\xf0\x6a\x47\x1d\x80\xe2\xf2\x9f\xa7\xf9\x49\x8f\xcd\x6d\x38\x37\x75\xe5\xe5\x3f\xa5\xfc\xb1\x73\x54\xe2\x1b\xa0\xd1\xf0\xe8\xae\x02\x13\x18\x1c\x1c\xfc\x37\xec\x80\xff\xe2\x18\xb0\x12\xe3\xcb\x62\x1e\x76\xcc\x4d\xfd\xaa\xc4\x59\x43\x5e\x29\xd5\x34\x55\xe7\x6b\x9a\x30\xef\x12\xc2\xd0\xa4\x3e\x97\x3f\x33\x8f\xc0\x28\x9b\x53\xf4\xd2\x67\xb0\xbf\xdc\xc9\x6c\x87\x73\x62\x25\xb1\x39\x1d\x0e\x3b\x1c\xde\x48\xa5\x56\xa5\x32\x7a\x8d\x0c\x53\x49\xd8\xbc\x8c\xbb\xa2\xa2\xca\x1d\xaf\x8c\x44\x42\xbe\x80\x0f\xc6\x69\x16\xd2\x82\xa6\x49\x7b\xc6\x1e\x26\x49\x77\x34\x40\x39\xbc\x6e\x6f\x5f\xc6\x6d\x50\x08\x7d\x19\xb5\x5a\xe1\xcc\xa3\xd2\x67\xc3\x37\xe9\x88\x7e\x98\x63\x45\x43\xe1\x3e\x81\x8c\x14\xee\x47\xe9\x2c\x5c\x7e\x43\x98\x07\xc3\x1c\xe0\x93\xf7\x5f\x3a\xe5\xb1\x17\xc4\xc7\xc5\xa7\xf6\x3f\x5c\x3e\x91\x8a\x5d\x30\xe1\x4f\xbf\xb9\xf4\xea\x75\x8b\xaf\x9e\xf6\xa4\x72\xe0\x3d\xe5\xd1\x77\x0f\x21\x70\x99\x23\xe7\x90\x77\x5f\xa4\x04\x7b\x95\x77\x91\x6f\xd5\xfc\xe9\x8f\xe2\x36\x71\x77\xf2\xf4\xe5\xb1\x04\xa8\x03\x7d\xf7\x1f\xb6\xaf\x12\xa7\x16\xec\xdb\x5f\x4c\x5e\x92\x8d\x21\x88\x56\xb1\x93\xfa\x00\xfb\xa7\xcb\xd3\x29\xaf\xdd\xee\xf0\x85\x60\x9f\x18\x1c\x06\x86\x09\x11\x56\x07\x13\x0e\x06\x61\x77\xf8\x9c\x6e\x67\x67\x86\x30\x93\xe6\xee\x8c\xcd\x4b\x92\x8e\x80\x9b\x77\x98\x15\x7c\x57\x51\x37\x94\xf4\x80\xbe\xc0\xf5\x1e\x4e\xfc\x92\xcd\x5f\xcc\xe6\x9f\xcf\x00\x20\xe9\x9a\xea\xeb\x76\x8a\x03\x7f\x3e\xff\x5a\xb4\xd9\xbb\x68\xc7\xcd\x4b\x96\xc4\x27\x2e\x18\x2f\x6d\xf2\xe7\xf2\x01\x48\xbd\xe6\xa1\x47\xc4\xdf\x8b\x8f\x4b\x3b\xbc\x8a\xef\xf6\x5c\xa3\x9d\x26\xde\x56\x98\x1a\x20\x71\x79\x43\xbf\xf4\x35\x1c\x5f\x2c\x4a\x9b\x18\xb3\x1b\xba\x6b\x4e\xda\x61\x76\x68\x6c\x36\x1f\xaf\xd1\x78\x3d\xd0\x39\x4b\xab\x1d\x0c\x76\x7c\xac\x94\x4a\x8f\x6a\x43\xb5\x68\x7b\xdb\xe8\x2c\xa5\xe1\xcd\xe9\x1c\xbe\xc8\xa1\x8d\x0c\x5d\x16\x31\x7d\x77\x70\x28\xb7\x37\x15\xa4\x3d\xe2\x81\x1c\x81\xf7\x52\x4c\xf0\x6d\xab\x29\x24\xf8\x5e\x3c\xae\x80\xc3\x7b\x08\xc1\xb7\x18\x93\xd6\xf8\x7d\xd0\x0f\x45\xfc\x46\x7e\xa2\x23\x5d\x0e\x5d\x50\xbf\x9f\xf1\xf9\x82\x56\x83\x21\x60\x34\x06\x3c\x5c\x57\xc6\xc3\xc0\xbf\x82\x60\xed\xce\x08\x16\xda\x8f\x7d\x50\x67\xd6\x03\xcd\x11\x93\x27\xe4\x8d\xac\x3c\xda\x07\x76\x3d\x87\x80\x28\x67\x39\x8f\x28\x03\x74\x3e\xff\xa7\x80\xd8\xa8\x6d\x08\xf3\x11\x76\x42\xb3\xfc\x46\xb7\x76\x16\x11\x1f\xe1\x33\x98\x56\x7c\x06\x59\x06\x67\xf8\x94\xcf\x64\xb2\xab\x15\x86\x40\x80\x24\x15\x76\x0a\x2a\x2b\x6c\x0d\xf9\x8c\xa8\x36\xdb\xea\x0a\x78\x49\x87\xcb\x01\x1d\x51\x17\x65\xb2\x5b\xed\x50\x31\x06\x56\xd7\x97\x51\x2a\x59\x57\xc9\xd0\xfb\xc9\x93\x48\xe4\x79\x92\x85\x23\xce\x59\x0a\x06\x07\x7f\xb3\x41\xc5\xb1\xc7\x46\x89\x47\xc5\x7f\xde\xf0\x88\x34\xd6\x1e\xff\x5d\x72\xea\x48\x07\x63\x50\x17\x7f\x13\x9f\x10\x8f\x49\x03\xcd\x05\xc2\xe0\xc1\x61\x8e\xc7\xe0\x18\x2b\x17\x5b\xf1\xf9\xa4\x1d\x9d\x4f\x2a\x59\x2b\x3a\x08\xb6\xdb\x09\xc2\xc0\x52\x0e\xa7\x9d\xb7\xc2\x88\xcf\x6a\x35\x98\xcd\xc6\x4e\x18\xf9\x19\xcc\xb4\xba\x2b\xc3\x71\x74\x3e\x01\xf3\xc7\xce\x27\x11\xd2\x5d\x6e\x20\x41\xdf\xb9\x90\xff\xe8\x96\xf2\xc1\x67\xe5\xd1\xb3\xe1\x36\xcf\xb8\x52\x22\xa4\x8b\xbe\xf8\x01\x0f\x9a\x17\x9f\x03\xb7\x14\x1c\x92\x15\x9e\x11\x2f\x4f\x27\x51\xae\x0c\xaa\x90\x91\x42\x38\x03\x29\x78\x05\x8f\x1d\x46\xdf\x76\xbb\x90\xab\x8e\xf9\x89\xba\x98\x52\xe5\x94\x84\x70\xa5\x11\xdc\xf0\x7a\x39\x79\x00\x05\x6f\x07\x7e\xe4\xa0\xb2\x20\x7c\x1b\xf6\xa0\xb2\xe4\xac\x78\x4e\x3a\xc6\xe9\xf5\x72\x0c\xce\x2b\x95\x2a\x42\x65\x34\xe8\x79\x5e\xd1\x05\x23\x36\x56\xa6\xd6\x52\x99\x87\x44\xe0\x25\xea\x18\x46\x16\xaa\xf4\xcc\x18\x51\x51\xa1\x41\x33\x0c\x17\xd5\xd0\x53\xe3\xc2\x18\x7a\x79\xda\x82\x63\x68\x85\x52\xa9\xc6\x81\x34\x0c\xa1\xcb\xbc\x6e\x29\x84\xd6\x67\xdc\x6e\xb6\x30\x82\x56\xc0\x46\x3e\x46\xa9\x58\x55\x61\x78\x56\xd2\xfd\x05\x60\x06\xf2\xa4\x5c\x18\x98\xc1\x16\xa7\x7e\x3c\x82\x56\x89\xbb\x1f\x1d\x37\xfe\x47\x23\xe8\x7a\xb1\x1f\x7c\x30\x72\x04\x9d\x8f\x9f\xdd\x44\x4f\xda\x4f\x33\x8c\xd3\xe9\xd2\x9b\x4c\x3a\xb5\x4b\xed\xf5\x38\x79\xab\xa2\x27\xc3\x5a\xad\xa4\x20\xe8\x3a\x33\x02\x8f\x7a\xfe\x11\xd2\xdd\x99\x21\x4b\x0e\x8b\x0b\x83\xe7\x82\xde\x0f\x71\x41\x2a\xe8\x04\x23\x46\xce\x8a\x23\x2b\x5e\x7c\x6a\xf8\xd0\x39\x2e\x2e\xff\xb1\xd8\x19\xe5\xf2\x71\x0a\xbc\xcf\xbb\x24\x5d\x6b\xd2\xeb\xd5\x88\xe8\xd8\xe1\xb0\x70\x76\xbb\x59\xa0\x74\x56\xab\x4b\xe7\xb4\xeb\x8d\x30\x86\xe2\x54\x2a\x8b\x91\x72\xa8\x59\xcc\xf0\x6f\xa6\x75\x06\xa5\x41\x0e\xff\x73\x04\xde\xa8\x9c\x5d\x9f\xcf\xf1\x97\xb3\xe1\x4a\xf6\x00\xa4\xfa\xb0\xa0\x3a\xcf\xe2\x6c\xc4\xf8\xd5\x6c\x48\xaa\x07\x3b\xf1\xf4\xc0\xec\xe0\xe7\x4f\x1f\x51\x89\x8d\x38\x6f\x0c\x5c\xfc\x36\x39\x0b\xdc\x00\x35\x55\x2f\x9f\x2b\xd4\xfc\xb0\x85\xde\xf6\xc3\xc9\xec\x68\x38\x0d\xa8\x41\xa4\x25\xcc\x39\x27\x2e\xc7\x9c\x73\x5e\x62\x41\xba\xc6\xa9\xb0\x41\x69\xbc\x5e\x37\xe3\xf1\xb8\x6c\x94\xdf\xc4\xf3\x3e\x46\xa1\x70\xcb\x78\xc4\x5a\x13\x5c\x44\x04\xad\xd9\xc5\x59\x68\xef\x90\x53\x86\x82\x25\xb1\x70\x63\x31\x27\x4d\x76\x51\x91\x79\xe5\x0a\x81\xf9\x65\xd6\x39\xfa\x25\x34\x40\x64\x5e\xb9\x19\x8b\xdb\x65\xe6\xb9\xe0\xb8\xa9\xab\x73\xcc\x73\xd2\xb2\x22\xb3\xcb\x7d\xfe\x87\x05\x88\x7b\x6e\xf5\x97\xe0\xd1\x2c\xf5\x1c\xf2\x03\x57\x43\xdf\x51\x83\xe3\xc4\x4e\xec\x3b\x5e\x8f\xea\x31\x90\xef\x08\x57\x1b\xec\x17\x82\x5e\xec\x3b\x92\xce\xbc\xef\x38\x76\xf0\x6f\x74\x1d\xc6\x5f\x9f\x28\x73\x22\xfe\x8e\x28\x60\xf1\x28\x78\xce\xb6\xec\x73\x88\x95\x60\x16\x7c\x8e\xea\x38\x45\xe6\xb1\x6d\x30\x07\x2f\xe6\x4b\x98\x28\x73\x7d\x3c\x88\xb1\x6d\x28\xb2\x4a\x2f\x7f\x66\x70\x0d\x41\xb0\xa7\xb1\x6f\x7b\x95\xcc\x25\xf7\x37\xa6\x1c\x73\x30\x1c\xc2\xdf\x83\xe2\xf6\x17\x70\x7b\xcb\xe5\xf6\xf6\x48\xbe\x6e\x59\xbe\xbd\x88\x9b\xe2\x4b\xdc\xde\x76\xb9\xbd\x37\x49\xed\xad\xc8\xb5\x97\x58\x39\x78\x8a\x99\xcf\x74\x08\x2c\xc0\x1c\x76\x44\x02\xde\xd3\x49\xbd\x2c\xb0\xd0\x03\xc8\xbd\x8f\xe4\x41\xef\x63\x79\x76\xc8\xf2\xd4\xe6\xe4\xc1\xf7\x20\x79\xd0\x3d\x88\xff\xa1\x5b\x92\xa6\x56\x46\xea\xc9\xfb\xe6\xdb\xb2\xbe\x39\xb1\x92\xbc\x10\x3f\x87\x04\xa9\xdc\x73\x24\xdf\x3c\x99\xf5\xcd\xe1\x67\x66\xc8\x98\x3f\xdd\xd9\x7e\x81\xcf\x3a\x45\xbd\x81\x9f\xf3\x9a\xdc\x77\x0f\xcb\xcf\x69\xca\x3e\x07\x71\x77\x52\x24\x7e\xce\x17\x52\x7b\x54\xd2\x53\x1a\xb3\xed\x81\x73\x8b\x0a\xc6\xc8\x16\x9c\x6f\xd3\x95\x8e\x6a\x94\x4e\xb7\x85\x30\x52\x14\xe1\x56\xd2\x7e\x9b\xd7\x1b\xf0\xd9\x3c\xb6\x7e\xe8\xd9\x5b\x38\x8f\xdb\xed\xa1\x38\xbe\x2f\xa3\x52\xa1\x5a\xfb\xa4\x9c\x7c\x92\x8b\x8d\x87\x39\x88\xc5\x29\xc3\x34\x5e\x6d\x39\x19\x38\x02\x25\x18\x03\x79\xef\x98\x23\x17\xde\xfc\xc0\x2e\x71\xe0\xce\x5f\xdd\x92\x9c\xa0\x72\x9e\x3f\x6f\xc5\xc1\x33\xff\xb9\x84\x07\xd7\x6d\xf8\x34\x33\xa1\x35\x45\x01\x1d\x15\x12\x1e\xdc\xbe\xfd\xf3\x4b\xd2\x60\xf4\xeb\xe5\x63\x56\x3c\xbf\xf5\xbf\xdd\xe0\x84\xf9\x57\x60\xac\xc4\x33\xf8\x11\xf4\x13\xfe\x4a\x1d\x86\x3a\xea\x9d\x89\x5e\xff\x05\xda\x4a\x88\x9d\x08\xe5\x7d\x1d\x63\x25\xed\x00\xcf\x49\xb6\xe0\xcd\xdb\x02\xe6\x16\xa0\xff\x99\xe5\xf3\x24\x77\x10\xbb\xa4\xb8\xc7\x9b\xb7\x5d\xe9\x39\xdb\xb2\xcf\x81\xba\x7e\x5c\xee\xdb\x58\x4e\x47\x12\x47\x41\x32\xfb\x1c\xd8\xff\x7b\x65\x1d\xc5\x72\x3a\xc2\x98\x66\x78\x0c\xd4\xca\xcf\x79\x40\xb6\x99\x78\xc1\x18\x38\x45\xbd\x88\x9f\xd3\x23\x3f\xe7\x80\x3c\x06\x62\x79\x7c\x27\x19\x1b\x8d\x87\x1e\x51\x90\x98\x9a\x8e\xfa\x6d\x02\x1d\x70\x58\x35\xb4\xa6\x2c\xe4\xb7\xf5\x65\x34\xfe\x31\xfe\x0e\x3f\x62\xb9\xf1\x13\x70\x0a\x82\x5e\x05\x4d\x18\x0b\x49\xc9\x0b\x32\xc1\x73\x64\x10\x12\x89\x51\x09\xd8\x99\x04\xe5\x94\xf2\xb3\x40\x3e\xda\xf4\x37\x90\xb7\x94\x40\x9b\x0d\x3c\xf1\xfa\x81\x8b\x3f\xda\x1f\x38\xbd\x55\x43\xed\x43\xe8\x67\x37\x97\x53\x9b\x59\x53\x31\xa0\x19\xa9\x7e\xe5\x9b\x9d\xc0\x78\x70\x1a\x60\x5e\xfb\xee\x9a\xef\xf6\x25\x0b\xf0\xcd\xb4\x84\x05\xc6\x15\x93\xd3\x11\xb7\x59\x47\x79\xac\x26\x15\xa5\xf2\xfa\xdc\x28\xd9\xdd\xed\x72\x93\x1a\xca\xed\x26\x38\x0e\xa1\x78\x0b\x84\x3e\x9f\xf6\xf0\x63\x52\x14\xc1\x29\x49\x8b\x97\x9f\x0d\x49\x59\x31\x7e\x70\x7f\x0e\xb3\x0c\x11\x2f\x9d\xf3\x4c\x60\xe0\x2b\x8e\x8c\x2c\x5f\xb4\xea\x91\x10\xa9\x35\x15\xc2\x95\x81\xe5\x57\x5d\xfb\xdb\x07\x12\xaf\xed\xb8\xf6\xc5\xdb\x88\x2c\x3e\x88\xa4\x43\xfa\xd6\x22\x1d\xd2\x54\x72\xa8\x0e\xe9\xbd\x45\x3a\xa4\xa9\xdc\x3c\x26\xf1\xe7\x63\x9b\xfa\x83\xfc\x1c\xa7\x6c\x53\x89\xdc\x73\x30\x3f\x17\x1e\xaf\xa2\x34\x5e\x3d\x92\x45\xc5\xf3\xf3\x07\xca\xb7\x61\x1b\xb0\x8d\xbf\x2f\xdb\xf8\x27\x92\x8d\xfb\x73\x36\x3e\x98\x11\xdb\x90\x8d\x0b\x61\xe2\x4c\x9a\x10\x64\x1b\xcf\xdd\xbb\x2d\x7b\x2f\x9c\x57\x0c\x72\x1b\x72\xf6\x28\x71\x71\x62\x7b\x3c\x53\x6a\xc3\x2a\xa9\x0d\x89\x21\x6d\xf8\x36\xd7\x86\xbb\xc8\x56\xf9\x39\xd1\xdc\x73\x60\x1b\xe8\x38\xb3\x3f\xd7\x86\xbb\x88\xf7\xf0\xbd\x78\x3f\x1d\xb7\xe1\x37\x72\x3f\xdc\x2e\xdf\x5b\x9d\xeb\x07\xbc\xef\x8c\xfb\xe1\xdf\x52\x1b\xe6\x4b\x6d\xa8\xc8\xcf\x5b\x83\x5f\x8b\xfd\xb8\x56\x0d\xfa\x6d\x69\xaf\x82\x57\x29\x79\xa5\x16\x71\x77\x68\x8d\x9c\x60\x80\x3e\x04\x69\xa0\x14\x38\x2d\x56\xad\xcd\x16\x2a\xc9\x9e\x75\x71\xf6\x1f\x4e\x96\xa3\xa4\xcc\x3f\xd9\x7d\x88\xa4\xe8\xb7\x6b\xc7\x69\x7d\xcf\x36\x89\xef\xbc\xb9\x08\xba\x0d\xdb\x94\x0f\xbd\x7b\x10\x7a\x6b\xa8\x12\x90\xd3\xfe\xb0\xdc\x81\x5d\x05\xa9\x62\x52\xae\x17\xc2\x35\x81\xe5\xc4\xa8\xb4\xc7\x43\x18\x78\xe8\x8e\x95\xf1\x5a\x82\xa9\x88\xb2\x1e\x53\x30\x1c\xf6\x77\x67\xc2\x82\x5e\xa3\x44\xf8\xf3\x6f\x25\x5f\x91\x49\x69\x9a\x8a\x50\x55\x4a\x88\xc3\x39\x2a\x7b\x9a\x31\x12\x7b\x38\x2a\xf0\x9b\xd6\x73\xf6\x8b\x8f\x56\xd5\x6c\xbd\x69\xd4\x85\xbb\xd7\xcd\xcf\x15\x01\xe6\x29\xc4\x6b\x62\x15\xed\x21\xb1\x13\x5c\xa3\x40\x44\xe2\x53\x6a\x22\xf3\xbb\x65\x22\x71\xa8\xa3\xbf\xc1\xb5\x68\x0e\xd6\xc5\xef\x64\x7b\x98\x2d\xdb\x76\x5d\x4e\x17\x98\xbb\x0f\xeb\xe2\xb4\xac\xaf\x5e\xd9\xb6\xab\x65\x6d\x20\x5d\x48\x75\x83\x11\x94\xb7\x6c\x31\xba\x38\xb5\x3a\xe8\x55\x78\x8d\x7e\xba\x9c\x8c\x44\xa2\x2a\x7f\xc0\xdf\x9f\xe1\x02\x01\x77\x38\x5c\xd6\x97\x09\xb3\xa8\x82\x35\x4c\xa9\xe5\xcd\x21\x01\x4e\x60\x26\x93\x50\xba\x39\x94\x2b\xa2\x2b\x59\x5d\x72\x1e\xb8\xac\x35\xe9\x7c\x5f\x02\xd5\x92\x69\xb7\x5a\x80\x3f\x5f\xf0\x49\xdf\x2e\xa9\x52\xae\xeb\x7c\x23\xe8\xdc\xba\xca\x3f\xcf\x82\x29\xb7\xd2\x53\x2d\x46\xd1\xa7\x94\x4a\x40\x0f\xaa\xa8\x7f\x50\x4f\x21\x0d\x4b\xc5\x9e\xaf\xdc\x74\xad\x59\xf9\xe4\x1a\xe7\xe6\x2d\xcb\x73\xb5\xa0\x84\xac\xef\x0e\x8a\x80\xfa\x46\xb5\x3b\x2d\x15\x91\x48\xb5\xc5\x68\x17\xec\xf5\xd5\x3e\xb2\x91\xa9\x67\x04\x93\xe0\x53\x11\xf5\x6c\xd3\x28\x0b\xfc\x6c\x57\xc6\x08\x40\xad\xd6\xeb\xad\xad\x75\x75\x67\x6a\x2d\x65\x95\x5d\x99\xf2\xf2\x32\xa7\x4a\xab\x55\x74\xe7\xa9\xf3\x0a\x65\x2f\x58\x53\x4b\x12\xbb\xd0\x6f\x7c\x12\x6b\x4c\xf9\x87\x94\x87\x26\x39\x7f\xde\x7e\xa8\x92\x0e\x91\xdd\xfb\x54\x92\x07\x4b\xbb\x27\xe5\x0c\xa5\x65\xd2\x4d\xbc\x78\x74\x63\xb7\x64\x4d\x35\xb6\x6d\xab\xb3\x5d\xd3\x32\xc5\xe6\xbc\xf0\x96\xad\x37\xcd\xe8\x06\xcf\xf5\xfa\x67\x4d\x91\x8b\x47\xdb\x96\x57\xf4\xc6\x7a\xbb\xb0\x61\x89\x7f\xb9\xee\x46\xdc\x43\x1b\xae\xb8\x63\xf2\x95\x67\xf7\x2c\x09\xe3\x3c\x82\x0e\x9c\x47\x10\x25\xce\x4f\xa7\x79\x8d\xc6\x4a\xd9\x48\xbb\x3d\xe4\xb3\xd2\xde\xb0\x27\x12\x21\x49\xda\xe7\x81\xa1\x3a\x11\x73\x55\x90\x3e\x5f\x24\x14\x08\x41\x8b\xa0\xbc\x36\xda\x15\x0d\x50\x1e\xbb\xcb\xde\x97\x71\x19\x54\x86\x7e\xb4\x93\x34\x64\xbf\x50\xae\x22\x29\xdd\x29\xc4\x9d\x53\x8b\x2e\x72\xe7\xd4\xc0\x08\xfb\xa4\xa8\x00\x0e\x21\xb2\x0f\x49\x31\x60\x42\xaa\x3d\xe2\x59\x2f\xd4\x9f\xfd\xec\xf2\x2d\x53\x63\xe3\x59\xdd\xf8\x8a\xf9\xe7\xc5\x8f\x0e\x9f\x6a\x80\x73\xdc\xa9\x81\x3f\xde\xb4\xf4\xbc\x63\x8b\x3d\xdf\xed\xb0\x3a\x36\x2d\xeb\xb8\x04\x9c\x1e\x2e\xe3\x40\xde\x3f\xed\xc0\xf9\x06\x49\x22\x93\xae\x0a\x78\x15\x0c\xa3\x35\x69\x09\x4f\xd0\x11\x89\x08\x35\xa6\xaa\x2a\xc2\x4b\xd5\x9b\x1c\x8e\xba\x60\x8d\x47\xa0\x6d\x31\x3f\x6f\x33\x53\xaa\xae\x0c\xcb\x52\x85\x5b\x84\x32\x90\x11\x06\x35\x6a\x6a\xca\xca\x9b\x3d\xb2\x66\x4c\xf9\x2d\x33\x2c\x23\x9e\x44\x7e\x34\x29\xc1\x42\x7e\xfe\xeb\xff\xe9\x6d\x0a\x26\x14\xae\xa6\xb9\x1b\x62\xd7\xdf\x9f\x4a\x96\x66\x27\x44\x4c\x38\x3b\x61\xeb\xe4\xa9\x77\xbf\x66\x78\x75\xb5\xeb\xfc\xbe\xb9\x2b\x40\x66\x7f\x7d\xab\x67\x98\x2c\x05\xbd\x90\xcd\x52\xf8\xf8\x5e\x29\x97\x04\xce\xf1\x21\x5c\x8b\x72\x59\x7a\x92\xc7\x64\xa5\x8c\x5e\x2f\xa9\xe1\xdc\x36\x96\xd2\x52\x3a\x52\x67\x34\x9a\x6d\x1c\x4d\xb2\x84\x9e\x08\xea\x03\xa4\xcd\xe6\x75\x3b\xa0\xd3\xc2\x9a\x2d\xe6\xfe\x0c\xa5\xd5\x7b\x1c\x16\x8b\xde\xef\xa0\x38\xa3\x51\xa3\xd3\xeb\xa0\xcb\xa9\xcf\x1d\xb1\xe9\x73\x79\x3f\x85\x99\x3f\x25\x16\x61\x2d\x80\x31\x90\xcc\x01\xce\x12\x46\xac\xfc\xac\x0d\x14\x65\xd1\x60\x33\xd8\x08\x36\x08\xe2\x7d\xef\xdf\xa8\x1a\x18\x2c\xcc\x36\xf9\x48\xbc\x48\x00\xf3\x1f\x2a\xb5\x03\x38\x45\xdc\x8f\x0f\x52\xb3\x09\x27\x33\xe7\x82\xaf\x4b\xf5\x2f\xf1\x2f\x13\x31\x62\x61\xba\xde\x6a\x02\x15\x46\xc1\x46\xb9\x34\xae\x70\x94\xa4\xd8\x60\x30\x52\x61\xd2\x33\x71\x56\xa3\xa9\x8c\xea\x0d\xd0\xd1\x09\x93\x2a\x9b\xc5\x60\x50\xf9\x2c\xbc\xca\x0c\x2a\x3a\x33\x20\x57\xf6\x50\x28\x70\xde\x1a\xac\x4d\x05\xd8\x05\x51\x50\xa2\x7a\x49\xc2\x52\xed\x27\xb9\xa0\xd1\x4a\x4d\x19\x24\x0e\xe6\xd5\x4e\x88\x7f\xe6\x01\x71\x6d\x91\xee\x1f\xfa\x90\xff\xf8\xf0\x79\x38\xe1\x24\xa7\xf3\xaf\x7a\xc1\xa4\x52\xa5\xef\xef\x15\x37\x9a\x09\x92\xd8\x0c\x75\x3e\x06\xea\x5c\x49\x38\x89\xf6\x74\x98\xb0\x32\x6a\xb5\x60\x15\x5c\x3a\x9d\xdb\x09\x27\x7c\xa7\xd3\xa4\x35\xe9\xd1\xb1\x69\x7f\xc6\x64\x10\xd4\x18\xca\x80\x2a\x45\xa3\x28\xde\xed\xc2\x90\xbd\xa3\x51\xaa\x89\x2e\x57\x0f\x0c\x95\x27\xad\x89\x49\x30\x71\xe7\x6d\x37\x2e\xda\xbb\xe9\x81\x7e\x32\x71\xc6\x3b\x4a\xb2\x5e\xb9\xff\x9d\x83\xca\x81\xf7\x7f\xfb\xdb\xdd\xff\xdc\x0f\x52\xeb\x97\x93\xf5\x53\xf7\x81\x56\x92\x46\xda\xf9\x61\xa1\xa3\xfe\xb6\xbb\xcf\x7f\x73\x39\xf6\x41\x9a\x61\xfc\xca\xe0\x98\x77\x12\x3e\x1b\xdd\x0c\xfd\x99\x19\xd8\x5e\x13\x88\x5f\x93\x0d\x97\x3b\xc2\x8e\x80\x3f\xa0\x89\x19\x0c\x56\x3f\x41\x58\x35\x54\x75\x8d\x74\xec\x2b\x54\xf6\x67\x10\xbf\x92\xd2\x44\xb1\x65\xca\xb2\xfe\x8c\xd2\x48\xbb\xfb\x33\xb4\xb1\xb0\xea\x06\xd7\x81\x95\x92\x2b\x15\x9f\x6f\xe3\xa9\x49\x3e\x1e\x6c\x06\xa3\x41\x7e\xf3\x48\xda\x79\x01\x68\x13\x09\xef\x2a\x21\xe9\xd9\x19\x63\xa3\xef\xbf\xb2\x67\xc1\xe4\x6b\x67\x9d\xfc\x14\x8a\xf7\x88\x2c\xf0\xbd\xea\xf6\xf1\x2b\x36\x38\xc7\xfd\x70\xec\xf4\xa5\x6b\xbc\x7c\xd5\x15\xa8\x37\x3e\x12\x8f\x7c\xf2\xcc\xf4\x70\xf9\xd1\xbb\xa0\xbc\x92\xf8\xa7\xfb\xda\x22\x33\x27\x5e\x77\x0b\x58\x2d\xce\xff\x7b\x59\xfd\xcc\xa6\x0c\x50\x4e\xdd\x87\x65\x87\x7d\xc1\x9c\xc7\xec\x24\x02\x44\x0d\xd1\x9f\x4e\x72\x89\x84\xd3\x19\xa8\xa8\xd0\x06\xcd\x66\x5b\x80\x20\x6c\x5a\xaa\x36\x89\x98\xb4\xad\x44\x20\x40\xeb\xf5\xe1\xae\x8c\x5e\xe0\xe2\xaa\x38\x4a\xb6\xa1\x3d\x5d\x19\xda\x42\x94\x80\x6c\x34\x61\xfe\xa1\x12\xc1\x65\xb9\xb9\x2c\xc6\x67\x8e\xa1\xd1\x5a\xb4\xe5\x84\x99\x46\xf3\x05\xcd\xcd\x80\x39\xcf\xe3\x7b\xf1\xf1\x9d\x3b\x55\x4b\xee\x69\xbb\xf0\xfa\xdd\x80\xb8\x75\xfe\x24\x3a\xbd\x57\x01\x26\xbe\xac\x6c\x9b\x3a\x7f\x8d\x35\x28\x56\x04\xa7\xd4\xcf\xdf\xbf\x78\xce\xd4\x4d\xdb\x69\x12\x9c\xbe\xef\xf1\x07\x16\x2f\x3e\x6b\xde\xe3\xb7\xde\x0f\xe2\x0f\x59\xab\xc1\x2a\x5b\xfc\x87\xc3\xc9\x58\x77\xd7\x96\x2d\x2f\x81\xc9\x56\xc7\x8d\xe2\xe9\x1d\xab\xb6\xde\x58\x6b\x96\xd6\xf2\x5f\x42\xdd\xfb\x99\xa9\x44\x25\x31\x33\x1d\x77\x79\xb4\x31\x4b\x19\xb4\x8d\xb2\x58\x44\xef\x61\xe3\x55\x11\x03\x1c\x99\x08\x37\x85\x36\x28\xfd\x1e\x8f\xdf\x0f\x97\x27\x3f\xad\x24\x90\xde\x4b\x4e\x88\x91\xca\x87\x94\x21\xa3\x1c\x75\xbc\x8f\x86\x24\xae\x02\x91\x2a\x90\x2d\x3e\x0e\x97\x56\x1f\x93\x56\x03\x3d\x7e\xee\x72\xe7\xb8\xe7\xc7\x46\xdf\x7e\xf6\xfc\x9b\xba\x05\xd3\x86\xab\x77\xea\x76\xdd\x79\x6c\xd3\xea\x6c\xd5\xf1\xf3\x5f\x3e\x7d\x7c\xfe\x59\xa3\x05\x6f\xdb\xf5\x37\x43\x5d\x1e\xf9\xf8\x85\xf6\xeb\x77\xdd\x77\x99\x42\xd1\xa3\x54\x3d\xb0\x7b\xfe\x22\xa9\xde\xf8\xde\xab\x6e\x7a\xd8\xa1\x99\xb4\x7d\x3b\x86\xd6\x46\xf9\xd6\x30\xc6\xff\x1d\x8c\xbb\xe2\x48\x46\x8b\x8d\x0b\x09\xde\x38\x41\x78\x43\x01\xb5\x8d\xad\x4a\x04\xd4\x1a\x8d\xba\x2b\x13\xd7\xc4\x35\xb4\xcb\x66\x73\xb9\x8c\x5d\x19\x97\x40\x47\x4b\x74\xfb\x23\x32\x82\x1c\xd4\xe9\xc8\xe5\xc3\x16\x2b\x82\x9c\x86\x0a\xa6\x7f\x87\x34\xba\xe3\x2a\x87\xa5\x7d\xd6\xb0\x75\xc3\x57\x9b\x75\x9e\xba\x38\x52\x2d\x56\xe6\xba\xdd\x1b\x7b\x87\xd4\x0c\xdb\x1f\x5e\xdb\x16\x82\x0a\x95\xe4\xbb\x4e\xec\xa7\x9e\x85\x3a\x8c\x40\x0b\xae\xb6\xda\x19\x85\x22\x84\xf3\xc4\x42\x7a\xaf\x37\xa4\xb1\xd3\xe5\xd1\x00\x82\xd3\x47\xd5\xe4\x2e\xc6\x6e\x77\xb9\x4c\xd0\xc9\xa0\x19\xa2\x2f\xc3\x18\xa8\x92\x54\xb1\x3c\x4f\xc1\x90\x4c\xb1\x6c\x79\x93\x94\xed\x1b\x1e\x51\x93\x00\xa5\x71\xd8\xd1\xf6\xfb\x83\xf5\xea\xcb\x6f\x86\x3a\xbc\xeb\x91\x8b\x57\x65\x75\xf8\xe2\xd7\x1f\xbe\xb0\xef\xa0\xb2\x0b\xef\xbc\x83\x44\x73\xe3\xca\x73\x95\x92\xfe\x66\xad\x92\xf4\xb7\xff\xca\x9d\x8f\xbb\x4c\x97\x2c\x1a\x9f\x80\xb2\xcd\x15\xcf\x23\xff\x83\xf3\xc8\x17\xa4\x6b\x2c\x68\xcb\x31\x1a\x0d\xd3\x1c\x17\x16\xbc\xde\x30\x54\x20\x53\x11\x0b\x6a\xd4\x48\x81\x9a\x62\xf5\x0d\xc9\xa0\xfa\x19\xc2\x21\xd9\x52\x12\xac\xcf\x8f\x97\x81\x93\xff\x59\x30\xce\x79\x4b\x85\x62\x7e\xd7\xf0\xa5\xdf\x3d\xb4\xaf\x41\x6c\x06\xd7\x7c\x1d\x37\x8f\x6f\x1f\xa2\x3d\xdd\x9c\xb1\xf6\xe8\xc3\xd2\x99\xdc\x1b\x83\xa7\x38\x1b\x9c\x7b\x11\xdb\x9b\x9f\xb3\x52\x2c\xeb\x75\x85\x23\x11\x97\x95\xaa\xd4\xeb\x74\xb1\x70\x98\xb0\xbb\x38\xab\xdd\xda\x97\xb1\x53\x1a\x23\x3a\x64\x54\x67\x78\x5e\x63\x24\x02\xfd\xb9\xfd\x8d\xc2\xdd\x54\xb4\x6b\x3f\x0c\x81\x1f\x23\x6d\xd1\x8f\x70\xc4\x58\xb0\xe1\xad\x03\x8c\xe1\xde\x37\xf8\x5b\x47\x3a\x6b\xbc\x57\xbd\x74\xc6\xb2\x0b\xf1\x28\x7d\xdf\x74\xf5\xc6\xf1\xbd\x54\xff\xb0\xc7\x8e\xa7\xe7\xb7\x45\xda\xbb\xf1\x94\x0b\xa7\x63\xf9\xfc\x11\x8e\xc3\xcf\xa8\x17\xe1\x38\x9c\x9e\x8e\x68\x05\x81\x88\xb1\x5c\x8c\x4b\x04\xdc\xee\x2a\x8f\xa7\x8a\x65\x9d\xd1\xa8\x01\xe1\xba\x3b\x03\xdd\x19\xa7\x45\x4d\xe6\xf9\xec\x0a\xf6\x3f\xf4\xc9\x44\x61\x26\xbd\xa4\x38\x93\x94\x79\x81\xc6\xa1\x0f\xc9\x39\xe2\x61\x24\x4b\xbe\x78\xe3\x8c\x8c\x3d\x78\xc0\x13\x7c\xf0\x01\xf1\x23\xcd\xdc\x1f\x39\x96\x5c\xa1\xfc\xf8\xee\xb5\xd7\xbd\x74\xdf\xab\x77\xfd\x65\xc2\x34\x92\x1e\xe6\x74\x72\x60\x67\x12\xd7\x88\x41\x1d\x9e\x8b\x7d\xfe\x85\xe9\x3a\x93\xdd\xc0\x07\x02\x44\x84\x53\x28\x22\x76\xca\x1a\xb3\x56\x44\x02\x5e\x7c\x2a\x89\x4e\x29\x39\x1f\xe7\xb3\x16\x1c\x4f\x6a\xa0\x3f\xa0\x31\x96\xd4\x1b\x67\x57\xcf\x52\x6a\x05\x59\xd6\xbc\xaa\x82\x59\xad\x96\x1e\x80\x49\x1c\x0b\x4f\xe6\x55\xf5\x26\xd4\x69\x7c\xf8\x83\x30\x54\x45\x79\xaf\xfa\x93\xbc\xb2\x90\x56\x01\x39\xf4\x40\x0c\x2b\x15\x9f\x89\xc1\x98\x78\x0e\xe6\x59\x98\x91\xae\x34\x5b\x5c\x84\x4a\xa5\x53\x2b\x48\x92\xa2\xd4\x16\xca\xe7\x75\x40\x5f\xce\x61\x51\xf1\x0a\xd0\x95\x31\x2b\x50\xb6\x37\x4b\x77\x66\x58\x9e\x32\x13\x2d\xf9\x4c\xb8\xec\xd1\xcc\x50\xf6\xc5\xc2\xda\xc9\x3c\xdf\x9e\xac\xdb\x06\xf2\x81\xe2\x42\xca\x15\xaa\xb6\xa9\x05\x1a\xe5\x0a\x0f\xc7\x06\xae\xaf\x8b\x77\x77\xc9\x3a\xf4\x76\x49\x6b\xc1\x97\xcc\xff\x31\x1d\x70\xbd\x6f\x4b\x97\x99\x0d\x04\xe3\xd2\x68\xe0\x2c\x58\x16\x44\xc8\x03\x7d\x19\x92\x54\x0a\x72\x40\x4e\x2b\x61\x78\xae\x34\x96\xd6\x1c\x15\x7b\x35\x12\x74\x0f\x4f\xb2\x74\x21\x48\x73\x51\x01\x4e\x8a\xde\x7a\x50\x49\xd2\xca\x3b\x42\x51\xf1\xc5\xff\x22\xc6\x40\xa9\x98\x26\x9e\x2f\xbb\x39\xfc\xb4\x9f\xbc\x1a\x75\xf0\xc9\x4f\xbe\x06\x3e\x11\x17\xd1\x60\x04\x5b\xa9\xd6\xe6\xf0\x71\x69\x9e\x9f\x34\x78\x8a\x42\x78\xfd\x7e\xd4\x76\x23\x65\xf7\x68\x55\x2a\x0f\x45\x05\x82\x1e\x5c\xe7\xed\x74\x12\x1c\x27\xa0\x89\x70\xa4\x7a\xa9\xd2\xb6\x33\x79\x9e\x68\x4e\xc2\xdb\x95\xda\xdc\x22\x09\x05\xdd\xce\x97\x0f\xff\xea\x7a\x00\xee\xee\xb8\xb7\x29\xdc\x4c\xb9\xd6\x37\x1c\xf9\x60\xe3\xd2\x67\xab\x34\x13\x14\x20\xa1\x68\xe3\x7c\x1f\x99\x9e\x3f\xf0\x14\x70\xdf\xea\xb2\x7c\x76\x95\x2b\x2c\xbe\xff\xef\x4b\xf6\x88\x13\xec\x95\x71\x7b\xf9\x63\x0f\x49\x6d\xbe\x02\xda\x4a\x02\xfb\x96\xd3\xd2\x11\xb3\xd5\x4b\x10\x06\xde\x65\x87\x83\xc3\xce\x5b\xe9\x40\xd0\x69\xb5\xda\xbc\x06\x1b\x8c\x77\x39\x4e\x63\xa3\x0a\x87\x43\x21\x39\xeb\xd0\xfc\xa3\x61\x86\x41\x3e\x25\x1b\x55\xd5\xb0\xe4\xc6\x22\xf3\xd7\xed\xc9\xd6\xd1\x60\xaa\xce\x9a\x3b\x75\x45\x26\x3f\xa9\x93\x5a\x2c\xa7\x63\x1b\x4e\x6f\xeb\x91\xea\x6a\xe0\xb8\x8e\xc3\xfe\x46\x9c\x02\x0d\xb5\x4e\xa7\xd7\xe5\xd2\x55\x86\xa1\xfb\x66\x34\x12\x8d\x50\x84\xc6\x08\x35\xb6\xb9\xb6\xb2\xd2\xe2\x4f\xf8\x7b\xa0\x00\x91\xfa\x84\x50\x51\xde\x99\xa9\xe0\x5d\x11\xb3\x86\x82\x9a\xc8\x6a\x40\xfa\x57\x96\xa8\x48\x20\x79\xf1\xc9\x57\xd6\x94\xd8\x7b\xca\xf0\x73\xab\x6c\x38\x8a\x65\x74\x45\x63\x41\x57\xaf\xf9\xc9\x82\x1b\x6b\x95\xea\xe3\xdc\x10\x49\x75\x82\x48\x8f\xed\xc7\x0b\x6f\x6a\xb7\x88\xff\xae\x93\xf6\x86\x83\xd0\x1e\xff\xc8\x4c\x13\x58\xd0\xf3\x25\x21\x61\x83\x51\x65\xf2\x5a\xdd\x18\x64\x1c\x6a\x93\x5e\x4f\x78\x14\x6a\x86\xad\x88\x29\xdc\x3e\xb7\x4f\xda\xe1\xee\x70\x9f\xe9\x3e\xcb\xcd\xa0\x7d\x6e\x92\xe7\xad\xa8\xcc\x97\x17\xa2\x51\x92\x0c\x77\x67\x48\x4b\x1e\xc7\x25\x51\x8a\xe0\x52\x04\xc2\x2c\xef\xe8\xb4\x64\xeb\xf9\x72\x60\x40\x38\x49\x96\x07\xb9\xbd\x20\xf2\xb9\x7b\x3e\xd8\x7e\xcb\x75\x5b\xc1\xcd\xab\x1e\x5d\x7d\xf9\x9a\xb2\xea\x90\xb9\x27\x32\xff\xbc\x99\xd3\x56\xf1\x2b\xb7\x5e\xbe\x7c\xf6\xa4\x0b\x26\x6d\xd9\x7d\xc1\xaa\xe5\xbb\x5c\x5c\xf2\x9a\x9e\xad\x93\xca\x5e\x5a\xa7\xb7\x9d\xb7\xb0\x7d\x0a\x9c\x04\x97\xcc\x9d\x36\x27\x5a\x2d\xe5\x03\x75\xe0\x7c\xa0\x20\x31\x37\xed\x53\x71\x7a\xbf\x40\x92\x7e\x8e\xb2\x41\x2f\xcb\x69\xb3\x95\x91\x52\xe1\xaf\xbe\x3f\x13\xa4\x2c\x6e\x29\x17\xc8\x6e\xb7\x18\x19\x6d\x7f\x46\xa1\x60\x9c\xf9\x03\xa3\x5c\x22\xcd\x70\xbc\x43\x28\xe9\xc4\x9f\xdb\xb3\x19\x76\xbd\x66\x5e\x53\x1e\xfd\xb8\x4b\x7c\xf4\x8a\xa5\x15\xe3\x18\x6d\x6f\xf4\x1a\xff\x7f\x86\x5b\xab\xf1\xd9\x7a\x40\x1c\x53\xf5\xc5\x0e\xab\xe7\x19\xe6\xd2\x61\x16\x69\x39\x27\xa8\x03\xe7\x04\x45\x89\x89\xe9\x00\x43\xaa\xc3\x64\x38\xe6\xb6\xd9\x2a\xec\xf6\x8a\x32\x2d\x62\x57\xb7\xb8\xbb\x33\x16\x0b\xc1\x75\x65\x28\x2a\x5f\xc5\x5c\xe0\x52\x15\xe1\x78\x17\x72\xff\x8f\xb8\x08\xc3\x79\x25\x95\x27\xfd\x3f\xf8\x23\x4b\xf0\x01\xff\x7d\x59\xc6\x7f\xea\xc5\xe1\xd2\x83\xe2\xaf\xbc\x2a\xd9\xe2\x3a\xf1\x38\x73\x37\xe6\x94\xaf\xc3\xaf\x27\x42\xb9\xde\xc1\xe7\xa4\xbd\xf8\xf5\x95\x83\x9f\x72\xad\xf8\x1c\x75\x14\x7e\x5d\x03\xe7\xa5\x49\xd4\x61\xf8\x7a\x2e\xc6\x68\xde\x2f\x6e\x21\x62\x83\xbf\x44\xb8\x98\x69\xa5\x81\xe5\x79\x35\x01\x00\x38\x31\xf8\xdc\x71\x0d\xdf\x0e\xf4\x44\xe2\xcd\xd8\xbc\xda\x26\x89\x4f\x26\x58\xe4\x19\xa2\xb1\x0a\x87\x9f\x73\x89\xd6\x1f\xaa\xad\x51\x29\x16\xab\x4c\x33\x26\x08\x4b\xf4\x6b\xc5\x2d\x1d\x2a\x9f\xbb\xaa\x21\x51\x33\x7f\x96\x72\xfe\x7c\xc3\x39\x2e\x82\x22\xbe\x65\xa6\x93\xeb\xd9\xa7\x08\x35\x61\x85\xb6\x54\x9e\xb6\x98\x95\x4a\x9e\xa7\xc0\x43\xd4\xd7\xd4\x20\x45\x51\x69\xa5\xb6\x9d\x72\xfa\x4f\x80\x25\xd0\x64\xe0\x77\xae\xab\xad\x95\xd8\x15\xf2\xd4\xec\xa9\x82\x6b\xae\xe0\xfa\xdb\xb8\x2f\x18\x8f\x07\x7d\xf1\xcf\xaa\x7c\x81\xaa\xaa\x80\xaf\x6a\x2f\xba\xa8\xf6\xf9\xaa\xd8\xb5\xbe\x78\x5c\xfa\x4f\xe9\xf7\x43\xe8\x1a\xbe\x87\x6d\x40\x64\xa6\x83\x75\xec\x69\xd8\x26\xf5\x51\x82\xc5\x5f\x8d\xa1\xb2\xad\x1c\x5a\x16\x22\xf0\x07\xac\xbb\x6f\xe7\xe1\x9d\xcf\x6d\x3c\xbc\xf3\xf0\xb5\xf7\xb1\xa7\x67\xe5\xfe\xe0\x18\x1a\xdd\xff\xb2\x2c\x93\x2f\xad\x57\x52\x69\x83\xbd\x1d\x4b\xb2\x89\x02\x14\x6f\x96\x85\x99\x17\x8b\xd5\x22\xd2\x94\xe1\x5b\x0f\x42\xb0\xb1\xd5\x89\xa0\xaf\x2a\x02\x5b\x5c\x9d\xf0\x07\xaa\xd8\xd5\x81\x78\x1c\x8a\x81\x5a\x8b\xfe\xaf\x0a\xf6\xdf\x37\xb0\xff\x76\xc8\xdf\xe5\x24\xc2\x69\x93\x9d\xb2\xfd\xd8\x17\xbe\x24\xbc\x34\xf2\x77\x72\x70\xf9\x00\xa7\xe0\x57\x54\x57\xfb\x02\xf1\x50\xb6\xff\x3e\x9c\xb0\x76\x62\xfe\xbb\xf1\x9b\x55\x55\x55\x60\x8d\x78\x83\x84\x7d\xfe\x7b\x68\x2b\x8a\xc1\x07\x61\x1b\x34\x0f\x33\xec\x56\x82\x48\x38\xde\x84\x92\x71\xd8\x59\xe1\xf0\x62\xf4\x20\xbb\x28\x63\xba\xf4\x46\xb6\xc7\xe9\x1b\xdf\xbe\x72\xf3\x3a\x9f\x1f\xce\x8f\x6e\x66\x0e\xe8\x60\x0f\x41\x29\xd4\x47\x29\x80\x1b\xf9\x16\xea\x67\xd8\xbf\x1d\x0f\x6e\x3b\xc4\x12\x87\x0e\x1d\x42\xfa\xd8\xc6\x74\x81\x8f\xd9\x4b\xe1\x9a\x19\x4e\xf3\x84\x5a\xef\x52\xc3\x1f\x46\xed\x62\xb7\x5a\xac\x92\x68\x8e\x37\x9b\x9a\x6a\x25\x3c\x56\x19\x0e\xb7\xbe\x2e\x92\xca\x52\xf7\xcb\xd3\xa0\x95\x93\x21\x9b\xe1\x64\x02\x46\x7b\x93\xb1\x50\x6f\xdf\xa4\xfa\x8e\x48\x24\xe2\x29\x7c\xc1\xec\xad\xad\xae\x37\xb6\xf8\x17\x4f\x5e\xd4\x30\xb9\x2d\x50\xf4\x42\xf2\xdb\xd7\x32\xd3\x89\xbd\xec\x66\x28\xaf\xf6\x18\x14\x17\x37\xc1\x01\x2d\x44\x4a\xe4\x4f\xe1\xc5\x27\xc4\x2e\x9c\x6b\xba\xe4\x26\x8e\x99\xee\xf4\xa5\x27\xaf\xba\xf8\xec\xa0\x07\xdf\xbb\x0d\xf6\xd5\x67\x83\x9f\x13\x0c\xa1\x7f\x34\x0d\xba\x00\x09\xe8\x13\x60\x01\x34\xb0\x79\x68\x20\xa1\xec\xba\x7d\x57\xee\x39\x79\xd3\x87\xe2\x96\xe3\xc7\x9f\x20\x48\xf1\x29\xf8\xf9\xe8\xe0\xb7\xf0\xbb\xf4\x44\x20\xad\xd6\xeb\xf9\xad\xba\xeb\x75\xfb\x74\x94\x0e\x8e\xc5\x47\xcc\xb6\x76\x9d\x92\x22\x12\x49\x3c\x1a\x13\xd0\x83\x29\xd0\x66\x88\xf4\xa7\x6a\x53\xe2\x53\x55\x3e\x7f\x02\x59\x3f\x58\x5d\x2e\xbe\x60\x3a\x69\x99\x2f\x59\x53\x55\x95\xf8\xee\xca\x97\xd1\x3a\xb5\x0b\xda\xeb\xbf\xa1\x3c\x0c\xc1\x3f\x4c\x91\x39\x81\xa0\x0a\x8d\x06\x3f\x17\xe0\x76\x95\x83\x16\xf3\x49\x0b\xfc\x54\x62\xd5\x4b\x45\x9f\x37\x3e\x46\xf1\xa4\x97\x24\x49\xe9\x9e\x37\xe7\x8d\x70\x0f\x39\x38\x0b\x5e\x7d\x05\xef\x61\x11\x2b\x51\x5a\xa3\x52\x2a\xe5\x3b\x39\xe9\xd6\x5a\x78\xaf\x34\xb2\xd1\xed\x2c\xe7\x97\x7e\x5d\x89\x1e\xb3\xf2\x6c\xb5\xb8\xb0\x1c\x34\x9b\xe0\x05\x7e\xe0\x82\x45\xf8\x1f\x82\xa0\xc5\xcf\x98\x2e\x72\x17\xf4\xef\x10\x5f\x7f\x8c\x48\x11\xa1\xb4\xa9\x3e\x1a\x15\x12\x2a\x55\x30\x61\x69\xb1\x74\x5a\xee\xb2\xd0\x16\x42\x80\x5d\xf4\x12\xfe\x82\xdc\xb4\x0c\xad\x2c\x9c\x03\xe4\xf7\x07\x72\xd7\x18\xdf\x35\x55\x97\xe7\x1e\x0c\x15\x5c\x83\x77\x93\x75\x4b\x27\x2c\x34\xaf\xeb\xe9\x5e\xbb\x66\xe0\xf2\xee\x73\xd0\x85\x67\x6c\xcf\x68\x5f\xd5\xa8\x70\x78\x54\x63\x79\x79\x23\x19\xcd\x5e\x31\x3b\x9d\x73\x7a\x7b\xc2\xb5\xdd\xeb\xce\xe9\xea\x5a\xb7\x66\x06\xfa\x3d\x26\x31\xa9\xad\x5d\xff\x72\x79\x23\xfa\x40\xee\x2f\x9c\x33\x9e\xcf\xc9\xe1\x24\xac\x69\xad\x31\xa1\x6a\x51\x75\xaa\xee\x52\xd1\x2a\x3b\x1c\x4f\xb5\x2f\xa1\x9e\x2d\x6d\x75\x6a\xa4\x96\xe9\x86\x6f\x42\xf6\x6b\x91\x1d\x7e\x05\x3b\x72\x3d\xbb\x17\x5a\x95\x0d\xce\x13\x34\xad\xe4\xa1\x62\x15\x59\x2d\x62\x8e\x01\x69\x1b\x27\xc2\x05\x8d\x70\x42\x97\x36\xe3\xd6\x2b\x84\x55\xb3\x02\x16\xc3\xe2\xd1\x8b\x6d\x6c\xb0\x3a\xae\x56\xb0\x7b\x6b\xe7\x2c\x55\x2d\x05\x1d\x57\x6b\xe2\xa9\x5a\x69\x3e\x78\x17\xda\xec\x1c\xbc\x76\x78\x1f\x63\x79\x83\x81\xd0\x03\x3d\xb2\x56\xb8\x72\xe8\x55\x40\xb2\x56\xf8\x0d\xc8\xe1\x4e\x16\x05\x34\x68\x01\x81\xe2\x89\x9f\x16\xac\x1d\x9d\x93\xf4\x8b\x85\x35\xf5\x13\x0d\x3e\x4f\x02\x2e\x1d\xf3\x66\xa9\xe6\xcf\x17\xce\x75\x63\xce\x05\x71\x3f\x11\x1f\xfc\x3d\xb4\x43\xdd\x23\x14\x41\x02\x12\xf6\x14\x36\x41\x2b\xe5\x4f\x25\x53\xf1\x94\xf8\x84\xf1\xa3\x50\x50\x7c\x75\xe5\x49\xdc\xae\x4f\x60\xbb\x26\xe2\xb1\x67\x7c\x4c\x1a\x7b\x5b\xe1\xe0\x5b\x88\x6c\x1d\x8e\x3e\x0a\x8f\x3e\x12\x8e\xbe\x9b\xe5\xd1\x97\x9d\xdb\x26\xc2\xb9\x8d\x81\x73\x1b\x1a\x1b\xf2\xdc\x66\xc5\x63\x6b\x62\xb9\xf8\x3c\x34\xf2\x1e\x3c\x90\x48\x31\x05\x3f\x7b\x12\x7f\x56\x4d\x98\x1e\xa3\x60\xec\xa4\xd8\xca\xb0\x50\x5e\x78\x0b\xb6\x6d\xe9\xae\x20\xfe\xf7\xa4\x74\xef\x4b\x05\x8f\x90\xc7\x23\x6e\x67\x70\xf0\xdf\x04\x07\xbf\x93\x04\x2c\x83\x7a\x0c\x0d\x2c\x06\xc6\x21\x21\x1e\xd0\xe2\xc7\xfa\x5d\x97\x83\x08\xbf\x5b\x3c\x96\xec\xb5\x7f\x94\xec\x92\xf1\x4a\x05\xa8\xd3\xd1\x78\x5e\xe2\xd1\x3c\xac\x2e\x18\xc7\x05\x33\xd3\xab\xec\x92\x39\xe6\x4b\x6e\x64\xd1\xcc\x34\xae\x1d\xce\x4c\x70\x2e\x26\xe1\x38\x9a\x45\x5c\x59\x68\x7f\x6c\x0b\xdb\xc9\xde\xc5\xd2\x6c\xde\xfe\xa8\x1f\x19\x25\x73\x86\x1b\x0b\xcc\xce\xe1\xac\xfe\xff\x9f\x36\x82\xfb\x64\x3d\xfb\x28\xd6\x79\x27\xdd\x47\x93\xf4\x56\x20\xf7\xcb\x3c\x8c\xbd\x0a\x75\x0e\x12\x58\xe9\xcc\x74\xac\x74\x30\xf8\x31\xbc\x67\x0e\x7b\x25\x9a\xa3\x1f\x41\xc3\x82\x22\xb3\x0b\x28\xda\xaa\x47\xa6\x05\xe6\x48\xb6\xc5\x5e\x29\x19\x17\x18\xbc\x0e\xca\xf3\x04\x5e\x03\x55\xc7\xe4\x25\x10\xea\xbb\x60\x05\xa4\xa5\x15\x90\xcb\xae\x80\xd2\x7a\x20\xce\x62\xba\x88\x23\xff\x5f\xd6\x36\xe3\x4f\xae\x6d\xc2\xff\xdb\xd2\x06\x47\x0f\x73\x1d\xb8\x94\x33\x60\x5f\x42\xf3\xb0\x99\xe2\x95\xb2\xe5\xe9\x0b\xbd\x2d\x93\x25\xb7\x15\x78\x6e\x57\xd7\xd9\x6b\x7a\x7a\xd6\x2d\x6c\x8c\x96\x37\x8e\x0a\x47\x46\xb1\x3d\x5d\x67\xaf\xeb\xec\x3e\xe7\x9c\x6e\x49\xd7\x4d\x18\xcb\xdb\x29\x6e\x19\xfc\x74\xf0\x2b\xfc\xdc\xc0\x71\x7e\xa3\x19\x98\xa1\xaa\x1f\x86\x3e\x0a\xfa\xfd\x08\x74\x53\xcc\xf2\x22\x16\x43\x66\xc6\x8d\xe0\x9d\x3c\x93\x90\xbc\xb7\x44\x24\x0e\x5d\x35\xb8\x84\xc5\x17\x4a\xde\x5c\xce\x27\x21\x18\x71\x31\xd4\xc3\x33\xf2\x77\x05\x89\x04\x31\x9a\x48\x3e\x96\x74\x3a\x9b\x36\xfa\x81\x5f\xfe\x52\xf4\x3b\xad\x81\xdf\xea\x8f\x9b\x95\x7c\x44\x09\xfd\xf8\x84\x15\x85\x9e\xf8\xfb\xf1\x40\x65\x7e\x86\x7b\x19\x1a\xe1\xff\xc5\xc5\x59\x77\xf3\xff\xe0\x05\x76\x9a\x72\x7e\x27\x58\x97\xfd\xaf\x68\xd6\xa9\xeb\x87\xed\x97\x3f\x5f\x55\xe8\x89\x7e\x2d\xff\x5f\xde\xd7\x13\x2f\x84\xb2\xed\x87\xb2\x51\x78\x94\x96\x3f\x06\x3d\x72\xe3\x46\x3b\xb0\xcb\x72\xd9\xe5\xce\xb4\x6b\xb9\x6c\x67\xe2\x79\x9c\x81\x91\xf1\x48\x42\x88\x17\x1a\x40\x9b\x61\x02\x6a\x08\xfa\x96\x9c\xab\x79\xcf\xea\xd5\x69\x7f\x42\xea\xdc\x6c\x03\x10\x4f\x55\xae\x0d\x1c\x61\x84\x2b\x6e\x4d\x5a\x43\x6c\x65\xd1\x4e\x97\x75\xa3\x1b\xb8\xe5\x86\xb8\xe5\x86\xb8\xf5\xea\x82\x86\xe8\x93\x68\x48\x80\x54\x10\x36\x27\x38\x72\x83\x3e\x30\xad\x41\x4d\x5a\x61\x7a\x6e\x48\xa3\xc4\x53\xe7\xac\x5e\x7d\xce\xb1\x61\xda\x05\x06\x83\xe2\xfe\xc1\x17\x07\xc7\x43\xbd\x2b\x8e\x62\x63\x82\xd3\x55\xc1\x63\x7f\x9f\x7d\x98\xf8\xad\x7c\x3b\x9c\xf3\x8e\xc1\xf5\x23\x35\x38\x11\xdb\x0a\x66\xed\xe1\xd1\x8d\x92\x83\x30\x82\x01\x88\xc7\xb2\x8d\xf9\x22\x2e\xb9\x55\x71\xf1\x3b\xb9\x21\x01\xd9\xaf\xc2\xfd\x84\xe6\xb7\xde\x9c\x1d\x46\xd3\x1a\x27\xe1\x07\xfb\xfc\x7f\xf4\x7f\xe3\xa7\xb0\x01\x2a\x91\x01\x16\x7c\x27\x8e\x6d\x7e\x9e\xe5\x89\xef\x66\x2d\x26\x17\xd9\xdc\x9a\xf5\xd5\x87\x35\x27\x38\x3c\xd0\x5c\xf3\xd1\xa0\x1d\xc6\x79\x97\x42\xfb\xd1\x1c\xa7\x38\x18\xce\x11\x89\x79\xc8\x3e\xfc\x9c\x5f\x3c\x05\x5a\x0d\xe2\x13\x9b\x57\xe2\xcf\xc1\x7e\x41\x9f\xe3\x08\xe1\x11\xac\x5e\x9a\xc8\xaa\x8f\x92\xd5\xf7\x96\x79\xad\x11\xde\xb1\xca\x20\xee\x5f\xbf\x72\xe5\x7a\x69\xfd\xe9\x67\x74\x80\x60\xd0\x1c\x28\x3c\x46\x6d\x55\x02\xaf\x12\xc0\x19\x64\xde\xbc\x92\x78\xad\x3f\xdb\x85\xcc\x7c\x34\x6e\x51\xe3\xd0\xbd\x07\x00\xc1\xb6\x61\xfd\x51\x4a\xac\xbf\xe1\xef\xf9\x67\xf6\x1e\x4a\xdc\x0d\xfb\x78\xdd\xe0\x37\x72\x1f\x07\xd3\x26\x33\xcf\x3b\x9d\xd5\xfe\xb4\x7f\xab\xff\x7a\xff\x3e\x3f\xe3\xdf\x8a\x4d\x01\x4e\xf5\xb5\x52\x26\x48\x61\xef\x5a\x47\xb8\x16\x77\x67\x3b\xf0\xce\xec\x97\xee\xcb\x0d\x56\xb9\x67\x27\xcb\x8d\x68\x2f\xb2\xc1\x93\xe4\x3a\x62\x2d\xa5\x43\x71\xd0\x71\x8a\x90\x84\x2f\xb1\xc3\x1a\x7c\x1b\xfc\x4b\x3e\x23\xe9\x0b\xe1\x3c\xd6\x40\xdb\x7d\x19\xeb\x45\x71\x14\x4e\xc3\x89\xb7\x50\x3f\x27\xb9\x93\x91\xd5\x21\x71\xff\x27\x9f\xe0\xbe\x3d\x4d\x3f\x4a\xf5\x30\x1d\xd2\x67\x24\xfb\x46\x49\x0c\xc0\x4a\x8e\x76\x0e\xbc\xcc\x74\xdc\x0c\x9f\xf3\x0d\xfd\x6f\xd0\xc1\x2c\x84\x6f\x1b\xd3\x2a\xc2\x4b\xb5\x50\xa4\x02\xc6\x7f\x59\x15\xc0\x8f\xd3\xa0\xdd\x2c\x3e\xce\x2c\x5c\x89\x9e\x09\xa6\x8b\xfd\xd4\x2e\xee\x43\x1c\x7f\x21\x0f\x7e\x11\x8e\xbf\x94\x20\x09\xdf\x02\xf7\xdd\x2a\xce\x12\xfb\x95\x1b\xff\xb9\x5d\xd6\x6d\x0c\xea\xf6\x97\x38\x26\xa6\x94\x27\xc0\x52\xb8\x32\x8d\xa4\xa2\x0b\xb3\x2a\xfa\x7f\xd2\x2b\x49\xcc\x1a\xfc\x13\xf8\x80\x7a\x1e\xeb\x95\x7f\x98\x87\x8b\x03\xf6\xd2\x92\x09\xbc\x1f\x98\xa5\xd3\xaa\xb5\x18\x0b\xae\x41\xfb\xe4\xea\xda\x49\x6d\xc9\x9a\xf6\x9d\xad\x75\x0d\x13\x26\xd5\xd6\xb5\x9e\x59\x3b\xa9\xbd\x26\xd9\xd6\x4a\x9e\xa8\x69\x6f\x4b\xc2\x17\xa8\x3d\xeb\x59\x2b\x30\x41\x7f\x60\x84\xf6\xac\xaf\xf6\xf9\xab\x12\xb0\x1d\xec\x52\x29\x08\x46\xfa\xb1\x8b\x2b\x07\x4f\x0c\x2a\x46\x9a\x5b\x3e\xcf\xae\x4b\xe2\x09\x79\x3d\x82\xdf\x33\x11\x2e\x7c\xe7\xd3\x8f\x12\x11\x22\x70\x54\xeb\x1c\xa7\x02\xcb\x88\x0c\xa1\x05\x7d\xf0\xad\x30\xbe\x06\x28\xea\xc3\xdb\x46\x28\x57\x03\xa7\x68\x20\xf4\xfe\xba\x86\xd1\x88\xcc\x25\x7b\xc0\x16\x03\x01\x0e\xe5\x01\xa2\x58\x3a\xe9\x27\xe3\x62\xdc\x62\x72\xcd\xaf\x65\xc9\x71\x0b\x3a\xc2\x1e\x86\xe6\x14\x3a\xfb\xf4\xf1\xf1\x5e\x8d\x82\xa6\xd5\xd3\xec\x6e\xe0\xef\xed\xb0\xd6\x54\x5e\xff\xda\xb7\x73\x57\xb7\x1b\xec\x06\xcd\x98\x8a\xd6\x19\xb3\xaa\xee\xdc\x37\xf9\xee\x3a\xad\x19\xca\x72\x5c\xdc\x02\x36\x0e\xde\x49\x28\xe1\x8c\x47\x03\x8e\x53\xe2\xa1\x0d\x47\x36\x13\xc4\x4c\xf4\x70\x78\x83\xc5\xc7\x55\xf4\x6a\x3a\x7e\xcc\x08\x8e\xbc\xb5\xcf\x64\xda\xb7\x0a\x36\xda\x3e\xf8\x19\xfd\x15\xfd\x14\x31\x85\x48\x3c\xd6\x1c\x22\xec\x34\x5f\x53\xfd\x04\x14\xc1\x07\x16\x3e\x6c\x21\x79\xe8\x21\x2d\x3f\x96\x69\xe5\x4f\x40\x09\x73\xa8\xe6\x49\x29\xdd\xa6\x21\x25\xa7\x68\xd4\x9a\x39\x53\x52\x72\x42\x71\x26\x6e\x36\x27\x0b\xfa\x33\x78\x7b\x12\x51\x38\x71\x7e\xe9\xa4\x11\xd3\x3b\x41\x7f\x37\x7b\x27\x62\x92\x7b\xf9\x96\xfb\x6a\xea\x83\xb5\x7a\x96\x8e\x9d\x19\xaf\x8d\xfa\xdd\xa9\x7f\x64\x4e\xc7\x03\xf5\x6a\xed\x5c\xb1\x6f\xde\x99\xc1\x68\x30\x22\xbe\xaa\x5a\x69\x0c\x1a\x6d\xc6\x73\x96\xa5\xd7\x06\x7d\xd5\x3a\x65\xf3\x68\xf2\x9e\xc7\xd6\x54\x54\x7b\x27\x56\x2b\x42\x6e\x2a\x59\x31\xaa\x2e\xf4\xd5\x75\xe2\xfe\xd1\xb5\xc1\x89\xf5\x56\xff\x66\x72\x5c\xd3\xc5\xd3\x12\x33\xba\x66\x24\x46\xb7\xb7\x38\x02\x96\xc6\x09\xdd\xd5\x8b\x8f\xa7\x23\x7b\x93\xcd\xe1\xa9\x75\xa6\xd0\x59\xd3\xf1\xd8\x7e\x0f\x4e\xea\x3b\xe9\xe3\xd0\x4f\x0b\x1d\xb5\xa8\x9e\xc4\x2a\xb4\x80\xbe\x87\x7d\x30\xec\x78\xb2\x40\xa1\x52\xda\x03\x52\x69\xca\x2f\x81\xac\xfb\x65\xe6\x73\x33\x56\x21\x92\x5e\x05\xd5\xc9\x25\x29\xc3\xe9\xe7\x7b\xc9\xde\xfa\xb9\x91\x26\xb1\x7f\xa5\x27\xce\xab\xe8\x08\x38\xb2\xa4\x3b\x3a\xce\x68\x9e\x74\xe8\xd1\x85\xe0\x83\xb5\xf5\x91\x33\x83\x53\x92\x06\x0d\xef\x18\x33\xbd\x5c\xfc\x8d\xf8\x46\x55\xed\x24\xa4\xc3\xc1\xaf\xc8\x2e\x68\x5b\x09\xa2\xea\x38\xad\xf0\x7a\x4d\xe3\x34\xb8\x05\x5e\xd8\xf9\x0a\x38\xef\xa0\x6b\x05\x6c\x0d\x81\x46\x4d\xfe\xac\x50\xe2\xd4\x8f\xa0\x24\xee\x14\xde\x90\x94\x4e\x76\x03\x39\xdd\x8c\x06\xd2\x89\x75\x96\x4d\x0b\x7c\xa8\xa0\xdd\xf1\xb2\x6d\x46\xf1\x6f\x3d\x37\x4f\xbf\xc8\x5e\xaf\x0d\xd7\x7b\x7a\x5d\x55\x3a\x15\xd9\x14\x99\xdf\x6c\x16\xba\x4c\x36\x53\xc2\xe0\x79\x76\x6e\xd5\x9b\xb1\x47\x0f\xec\x00\xf1\x89\xd6\x50\x59\x4f\xf9\xd4\x26\xc1\x5c\x16\x89\x79\x5a\x62\x1f\x3e\x55\xb3\xac\x7f\x86\xbb\xf9\x2c\x3c\x87\xac\x1f\xfc\x9c\xfa\x10\xf6\x61\x84\x70\x3f\x4e\x78\xa0\xe1\x98\x09\x0d\x21\x75\x9e\x06\xd9\x8d\xd4\x79\xb8\x96\x1a\x0f\x6a\xb9\xc7\xdc\x78\xf7\x1a\x0d\x02\x12\x6d\x9e\xd6\xa7\xa0\x5d\x18\x1a\x52\x9f\xb4\xc4\xc6\x39\x55\x6c\x84\xdc\x35\x85\xd4\x50\xac\xa2\x6d\xaa\xd5\x61\x37\xc5\x56\x6a\x75\x74\xd4\xe5\x2d\x6f\x9b\x41\x9d\xa8\x4e\xd4\xae\x12\x6c\x9c\xad\x51\xa3\x99\xa8\x53\x93\xfc\xe3\xbf\x17\x7f\xb8\x35\x56\x3e\x8e\xd7\x75\xdf\xfd\x0c\xa0\x8e\x75\x62\xae\x19\x14\x13\xd2\x4b\xf1\x58\x6d\x26\x42\xc7\xc7\x8e\x55\xbb\x6a\xe0\x84\xf3\x30\x72\x84\xa5\xd6\xa9\xf3\xad\x43\x87\x16\x28\x12\xcf\x1b\xb4\xbf\x16\xe5\x51\xe1\x41\x4a\x72\x98\xe8\x1e\x0d\x64\x3c\x9a\x81\x89\x63\x79\xcc\xdf\x5b\xdf\x80\x5a\x2d\x8d\x6b\x10\x5d\xec\xa9\xd4\x69\xd8\x10\xf9\xfb\x71\xac\x8a\x71\x54\x04\x49\x95\x5b\xe9\x5f\x65\xe4\x69\x4b\x4c\x2f\x70\x9a\xea\xb1\x03\xd7\x99\xbd\xa6\x98\xa6\x7a\xb1\xc5\x00\x94\x15\xbc\xc2\x1f\xf2\x2e\x35\x0b\xd4\x89\x65\xde\xd6\xa4\x2e\x64\xa9\xf6\x1b\x9a\x3c\xbc\x63\xd1\x52\xf1\xea\x07\xea\xeb\xa7\xf1\x42\xea\xfb\x27\x9f\x0e\xb6\x2d\x1f\x2b\x3e\xaf\x72\x36\x5e\xf1\xdf\x29\x0d\xf5\x56\x4e\xdb\xbc\xb0\xfe\xeb\x51\xf1\x76\x42\xee\xfb\xef\xc0\x8b\x50\x46\x3f\x61\x3e\xe6\xd4\xd3\x92\x5c\x7a\x2c\x17\x61\x4b\x60\xee\xe6\x18\x28\xe8\x77\x8b\x64\x0c\x1c\x25\x49\x64\x6c\x00\xed\x65\xe1\x68\x43\x45\x8b\x5d\x45\x0b\xd6\xf6\xd6\x31\xca\xdb\xe8\xba\x32\xb5\x8a\xde\xa9\xa4\xb6\x84\x8d\xb5\x89\xea\xd5\x06\x8d\x56\x69\x0e\x27\xf9\x86\xd3\x3b\x6c\xb5\x2e\x95\x97\x72\x49\xfb\x01\xc4\xe2\xc1\x6f\xc8\x5e\xa8\xf7\x28\x61\x3f\xee\x25\xcc\x6a\x73\x69\xaf\x16\xf7\x28\xfc\x66\x09\xd1\x4e\x22\x38\xa4\xa4\x4e\xad\x43\x1d\xd8\x4c\x82\x0b\x0f\x05\x92\x5a\x2d\x13\x39\x77\xb3\x83\x67\x59\xaf\xb5\x62\x8a\x51\x19\x36\x71\xe5\x6b\x8c\x6a\xae\xc2\xa9\x75\x86\xc6\x52\x0f\x2e\x8e\xb7\x25\x54\x6e\xdf\xb2\xe0\x2c\xd6\xbb\xea\xbc\x3a\xf1\xd0\xbd\x91\xd6\x76\x0d\xa7\x9b\x71\xe7\x9c\x53\x87\xd7\xe2\x36\x21\x9d\x6f\x87\xfd\x31\x8a\xf0\x1e\x4d\x28\xe0\xb4\xf5\x30\x61\xf0\x1a\x9e\xcc\x8d\xa3\xac\xba\x61\xcb\xe4\x4d\x7b\xd4\x82\x94\x11\x6a\x35\x58\x38\x9d\x41\xed\xcb\xca\xd7\xd1\xf8\x33\x28\x3d\x9b\x4c\x81\xf7\xa6\xb5\x3b\x4c\xb6\xf8\x62\xbb\x8a\x71\x39\xc6\xeb\xcf\x98\x15\x6d\x4e\xfa\x63\x5a\x0d\x19\x22\x3f\x4b\xd2\x1a\xd6\xdc\xea\x52\xd0\x82\xb9\x7e\xa2\x5e\xab\xd6\x44\x0c\x46\x67\xaa\x9c\x3a\xd1\x71\xe8\xd4\x89\x1b\x7b\xbb\xb5\x9c\xaa\x7e\x17\x38\x32\xff\xda\xee\x86\xa4\xa7\x3d\x61\x72\x3a\x82\xf1\xf1\x3e\xfd\xa8\x7d\xdf\x5c\xf1\xf4\x84\xd6\x4a\x5e\xe5\x70\xfe\xfb\x81\xe3\x37\x2d\x41\xeb\xcc\xed\x04\x41\xef\x86\x7d\xdb\x44\xcc\x3e\x5a\x5e\x7b\x02\x2c\x3b\x96\x29\x77\x49\x62\x94\x83\xbe\xb4\xb9\x4f\xb1\x56\x41\x52\xbc\xc2\xab\x48\x28\x28\x25\xad\x50\x98\x34\xa6\x26\x79\x39\x32\xc1\x39\x42\x43\x30\xf2\x00\xec\x2f\x2d\xab\xe8\x9b\xd7\x12\x83\x33\x59\x48\xc6\x16\xe5\x22\xf2\xa2\xa4\x03\x08\xc4\x21\x01\x50\x26\x7a\x56\x6b\x3c\x28\x52\x9b\x04\xaa\x49\xcd\x7f\xb7\x69\x7c\xef\xbd\x2b\x9a\x2e\x7b\x37\xb3\x60\x45\x6c\xc6\xde\x01\xbf\xc0\x30\x96\xaa\x71\xe7\x7a\x13\x06\x35\x45\x85\xa7\xaf\xf3\x68\x19\xc6\x29\x04\x26\xc7\xcd\x9a\x47\xc1\x92\x4f\xe7\xcc\xbf\xe3\xfe\xe0\x3f\xfe\xf5\xc0\x2d\xb3\x9f\xfb\x58\x7c\x76\xf1\x92\xb5\x17\xad\xb8\xe5\xd2\x6d\x7d\xe5\x6d\x09\x41\x2d\xb8\xfa\x3c\x0b\x58\xf7\xd6\x97\x17\x75\xdd\xbb\x40\xca\xf3\x21\x23\xe0\x9f\xf4\x31\x22\x40\x98\x8f\x6a\xa1\xff\xb2\xec\xe1\x8c\x35\xa8\xc5\x4b\x90\xa1\x29\x26\xcf\x23\xd9\xa9\x57\xb2\x67\xa4\xc8\x70\x7d\x83\x9c\x41\x2f\x36\x34\xf9\x2b\x05\x0d\xed\x9b\x72\xc6\x58\x4f\xe3\xaa\xb5\x3a\x95\x85\xf2\xcf\x3f\x23\x00\x55\x51\x51\xef\xef\xa8\x12\xe0\xcc\x9b\x6a\x2f\xbf\x66\xe9\xd2\x49\x21\x8d\xca\xda\xb2\x69\x42\xd4\x85\xc6\x92\xb8\x8e\xda\x0f\x6d\x27\x48\xd8\x9f\x25\xec\xd0\x6d\xd2\xc2\xd6\x64\xd7\x77\xdc\x89\xc5\x73\x98\x45\x9a\xf6\xe1\x58\x82\x13\x3f\xfa\x7e\x69\xea\x0d\x7e\x36\xbe\x6a\xac\x13\x0d\x27\xd2\xdb\xd1\xa2\xf9\x1d\xa5\x6e\x30\x6b\x59\x9a\x7e\x4b\x13\x08\x53\x27\x92\xb5\x95\xd2\x88\xaa\xa8\x71\x35\xff\xe0\xe5\x4d\xd5\x46\x5a\xe1\xa6\x2f\x6f\xa9\x71\xf0\x70\x0d\x78\x1e\xae\x47\xfb\xa1\xde\x3d\xd0\xbf\xb0\xaa\x65\x85\x5a\xe1\xf7\x23\xc7\x0e\x5d\x13\x05\xfe\x05\x5c\xd4\xe1\x7c\xdf\x20\xad\x46\x45\x73\x2b\xc6\x41\x6d\x99\x01\xde\x9a\xb1\x34\x72\x41\xcf\x79\xe2\xb6\xa6\xaa\x89\x16\x35\x5c\x88\x6e\xbb\x66\xe9\xed\x97\x3e\x5a\x3b\xe1\x9d\xaf\x2e\xec\xad\x4b\x56\x2f\x41\x8b\xd0\xb6\xc7\xdf\x11\xd3\xf7\x4a\x63\xfa\xd2\xc1\x3f\x51\x37\xb3\xbb\x88\x34\xe1\x1d\xa7\x22\xaa\xe1\x4a\xe3\x97\x3b\xc1\x0f\x1b\x61\x00\xf3\xe5\x95\x47\xee\x09\x39\xe9\x14\x61\x60\xc8\x23\xc7\x9a\x65\x1c\x95\x7b\x87\x44\xeb\x8e\xd5\x94\xcb\x81\x4c\x35\x53\xd0\x0b\x00\xc1\xbf\x8c\x8e\x75\xf9\x75\x76\x97\x60\xf6\xd5\xc1\x85\x67\x62\x4f\x72\x66\x75\x30\x01\x9e\xe9\x99\x38\xfa\xe2\x27\x7f\x47\xba\xaa\xac\x21\xcf\xf8\xf3\x6e\xba\x60\x55\x85\xd3\x50\x33\x99\x3a\xe1\x4f\xee\xb9\x32\xe5\xd3\xea\xcd\x3a\x85\xdf\xe4\x4f\x57\xab\x0c\x66\xc1\x1c\xb1\xb4\x6d\x58\x91\x72\xdb\x5a\xcf\xd8\x2e\x0e\xee\x5a\xbc\xf1\xff\xc7\xd9\x7b\xc0\xc7\x55\x1d\x7b\xc0\xf7\xdc\xbe\xf5\x6e\xb9\xdb\x7b\x5f\x69\xb5\x5a\x49\x2b\x69\xd5\xb5\x92\x9b\x6c\xcb\xd2\x4a\x96\xcb\xda\x72\x95\x5c\xe4\xde\x70\xc7\x15\x8c\xb1\xc1\x14\x17\x6c\x53\x42\xb5\x4d\x30\xcd\x36\xc4\x60\x42\x08\x35\x2f\x09\x2f\x8f\x40\x42\x08\x2f\xc9\x4b\x48\x21\x09\xe9\x2f\x81\x80\x75\xfd\x9d\x73\xef\xdd\x26\x93\x7c\xef\xfb\x7e\xfc\xb0\x25\x61\xbc\x33\x73\x66\xfe\x53\xce\x9c\x99\x99\xd5\xde\x6a\x67\x85\xb3\x6e\xc7\xea\x81\x09\xd9\x69\xb7\x4e\xac\x88\x70\xd0\x0f\xcc\x16\x6d\xe9\x02\x66\x87\x9e\x20\x72\x31\xa0\x34\x2b\x65\xb9\x42\x47\x8f\x91\x58\x44\xfc\x9a\xcc\xcb\x15\x02\x04\x6a\x49\xc5\x09\x9f\xb1\x8d\x48\x95\x82\x82\x1b\x10\xc8\xfb\x43\xfa\x7d\x5a\x80\x13\xe4\xd1\x85\x1d\x57\x97\x0e\xba\x78\xff\x80\xb7\xa3\xc5\x5b\xa1\x55\x42\xf4\xf7\x2c\x58\x16\xff\x55\x22\xed\xa8\x6f\x16\x26\x0e\xb6\x25\x23\xc4\xde\xc5\xa3\x7f\x14\xfe\x86\xbb\x1e\x98\xd0\x31\xe8\x48\x36\xb8\x26\xc4\x95\x3e\x7b\xf9\xa2\xab\xef\x1d\x05\xf3\x0f\x24\x5b\x9c\xfd\x3b\x84\x5f\x08\xbf\x95\xe4\xaf\xbd\xf6\x39\xf4\x59\x97\xb0\x4e\xac\xe1\xb9\x1a\x47\x53\x47\x93\x42\xd4\xff\xa6\x98\xfb\x65\x91\xcc\x18\x24\xb9\x03\xeb\x44\x78\x60\xe8\x10\x6f\x18\x92\xf2\x3d\xa5\x74\x8d\xdc\x28\xb5\x22\xca\x7b\x60\x20\x8d\xf0\x2c\xa0\x03\x68\x85\x9e\xcb\x20\x6a\x4a\x04\x45\x60\xc5\x88\x0c\x8f\x47\x3c\x15\x79\x78\xae\x2f\x45\x74\x86\x03\x96\x48\xf3\x4d\xdb\x97\xfc\xe8\xc9\x7d\x21\x4a\x67\x28\xb3\xe0\xe1\x27\x6f\x50\x07\xab\xea\xe3\x26\x47\x14\x3a\xdc\xb2\xe0\x01\x5a\x7f\xc7\x74\xa5\xd2\xe1\x76\xaa\xbe\x7a\x79\x4e\xcf\xe8\x95\x9e\xcb\xe6\x70\x3b\x60\x56\xdd\x74\x64\xff\x6f\x85\x67\xde\xb5\x9b\xcc\x4a\xd5\x47\xe0\xe4\x2d\x86\x98\x3f\x44\xe0\xa6\x44\x2c\x38\x3e\xae\x76\xb9\x57\x9a\x4d\xcd\xa1\x9d\xf3\xc3\x80\x24\xf0\xbf\xfd\xf4\x90\x70\xd7\xd7\x2e\x4b\x7c\x47\x84\x61\xf0\xbf\x90\xef\x0a\x64\x7b\x18\x18\xc6\x9c\x18\x27\x32\xec\x2c\xb6\xbd\x3c\x56\x8b\x2b\x4c\x72\x2a\xcf\xcb\x30\xe0\x92\xde\xd6\x40\x7b\x24\x12\xac\xd6\x5c\xb1\x4e\x1b\x70\x35\xd4\x46\xc6\xd5\xa5\xed\x6a\xda\xb7\xa3\xaa\xd2\x5c\x61\xab\xd6\x1e\x27\x54\xfc\x1c\x61\x98\x66\xa3\xe3\xfe\x8a\x6f\xcb\xac\x2f\x9f\xea\xb5\x27\x1a\xca\x56\x69\x15\x4a\xad\xd5\x13\x62\x2c\xb3\x9b\x02\x0b\xfb\xaf\x76\xa8\xf5\xfc\x54\x29\xff\xbb\x04\x83\x89\x76\x88\x0b\x65\xd0\x26\xdd\x46\x59\x77\xdc\xa2\xee\x50\x63\x74\x47\x4c\x64\xa0\x0c\x7d\x35\x75\x11\x31\xf6\x2f\x21\x34\x17\x8a\xa1\x48\xcc\x62\x06\x1f\xb4\x98\x85\x78\x3f\x08\x45\x48\x53\xd0\xd9\x3a\xc1\xd7\xd8\xd0\x66\xd5\x50\x2d\xdd\x13\xea\x52\xf3\x79\xc7\x5b\x81\x9b\x3d\xcf\x47\x82\x9b\xe2\x15\x9b\x66\x5e\x48\xb4\xc7\xeb\xc3\x37\xe8\x5c\xce\x70\x55\xe5\xe1\xbf\x9f\x98\x3c\x75\x19\xd4\xeb\x15\xd7\xfe\x48\x76\x8b\x7a\x1d\x85\x7a\xed\x80\x98\x2f\xd3\x86\xa2\x2e\x1e\x1a\xac\xe4\x0c\x16\x97\xe8\x75\x81\x96\x9c\x81\x92\x52\x93\x6e\x2a\x29\xb7\xe3\x4a\xba\x03\xaa\x3b\x93\x9d\x30\x0e\xf3\xea\x71\xf5\xa1\xe5\x67\x85\xdf\x3f\xf1\xea\x0b\xfb\x57\xaf\x5e\xbb\xe5\xc8\xad\x27\x7f\xba\xa5\x7b\x0d\x71\x39\x5c\x53\xb1\x59\xe9\xd1\x6a\x4f\x7f\xf8\x8e\x70\xe8\xb5\xf7\xdf\x3f\x04\x82\x6b\x16\x09\x9f\x1f\x3a\x74\xc7\x5d\x80\x7c\x70\xeb\x3c\x51\x76\xef\x43\xdb\x5b\x08\x65\xd7\x87\x55\x5c\x54\x57\xb7\x56\x8b\x9e\xcc\xda\x8a\x1c\x73\x1f\x0c\x5a\x25\x8f\x16\x2e\x84\xd8\x49\x89\xcc\x10\xca\x15\x24\x38\x2f\x09\x5f\x24\x8d\xc5\xa5\xcd\xad\x28\xde\x15\xb7\xfe\xa0\x3f\x5a\x64\xa7\x72\xbc\x2b\x4e\xc9\x15\x25\x2d\xb6\x32\xfe\xd9\xa1\x9b\x3c\xcf\xc8\x35\xf2\x0d\xc9\xb4\x59\x4d\x97\xb5\x6c\xd2\x5c\x61\xcb\xc3\x57\x6f\x19\xf8\x4e\xc2\xe3\x09\xb4\x8d\x6b\xf1\xd5\xc0\x58\xbd\xae\xa1\xb3\xd2\xa7\x56\xda\x0c\xfe\xb0\xc7\x57\x1b\x7d\xbe\x6c\xe2\xdc\x5f\x7e\xbb\x3c\xa2\x8d\x25\xaa\x2a\xd7\xf3\x56\xca\x3a\xcf\xea\x15\x6a\x5f\x8d\x4f\x32\xb9\x96\xb7\x3c\xbf\xa6\x26\xb9\x6c\xd9\xd4\xf1\x2b\x47\xaa\x2b\x23\x93\x12\x3a\x9b\x37\x54\x16\x9a\x43\x70\xe3\xeb\xe2\xb7\xdc\x9e\x6a\xbe\x79\xaa\x14\x27\x09\x5b\x88\x0f\xa1\x6e\xb7\x60\xb5\xcf\xa9\xad\xd5\x34\x6d\x84\x59\xd5\xa5\x2c\x5d\x13\x85\xe2\x18\xba\x88\xb9\xa2\xae\xbc\x67\xcf\xc9\x41\x0f\x3d\x9d\x6c\xcf\xb9\x16\x0f\x39\x2d\xad\x13\xcb\xf3\x8c\x94\x60\xd5\xa7\xc4\x5f\x73\xf0\x24\x7b\x23\xf8\xa7\xa0\xc1\x1b\xd1\x1f\x04\xe7\x3a\x36\x86\x9a\x27\x26\xd3\x76\x46\x89\x47\x5b\x26\xf2\x5a\xbd\xd6\xb4\x62\x53\x68\x68\x82\x5d\x49\x06\xc0\xe8\x40\x97\xf6\x07\x64\x8f\x8e\x65\xf0\x77\xc8\x48\x23\xf4\x8f\x27\xe2\x46\x3e\x52\x57\x7d\x50\xab\x72\x79\xdc\x65\x2e\xef\xa4\x6d\x1f\x6f\x1a\xac\xdc\x60\xb0\x39\x6b\xc7\x55\xf5\x7d\xd1\x63\x6c\xa4\xd5\x0a\x35\x79\x6f\x75\x2c\x80\xce\xf7\xe7\xd0\x5f\x7d\x02\x75\xb0\x15\xeb\x7c\xce\x09\x15\xd9\xe4\x87\xbc\xa5\x15\x59\x93\xa9\x89\xe4\x2a\x9b\x2a\x65\x8d\x6c\xfa\x52\x6b\x29\xcc\x50\x93\x39\x15\xf1\xc7\x57\x53\x80\x58\x91\x71\xb1\x17\x15\x45\xab\x52\xbc\x92\x9b\xda\x98\x0a\x14\x74\x19\xf1\x4e\x7c\x72\xcf\xc1\x51\xbe\x1f\x7c\xbe\x6a\xdb\x7a\x5f\x67\x9f\xf0\xd7\xce\xe5\xae\xfa\xea\x0a\x6b\x8b\x5d\x8b\x47\x9a\x2b\xc2\x14\xad\xd1\x68\x35\xab\x87\x3d\x8d\x89\x71\x36\x16\xfa\xc2\x07\xf6\xaf\x27\xfa\xff\x47\x68\x7b\xe6\xf9\x75\xa0\xf6\x81\x29\xfd\xc1\xe8\x91\x84\x4e\x6f\x28\x0b\x24\x56\x1b\xad\x16\xde\x61\xe2\x0d\xd5\x9e\xb5\xbf\x58\x50\x51\x55\xb3\x4a\xeb\xb1\xee\x42\x67\x19\x10\x76\x90\x1b\xe1\x59\x4e\xc2\x42\x17\x26\xa8\x02\xf0\xfc\x2e\x99\x2a\x61\x42\x21\xea\x75\x93\xaa\x90\x27\x8b\xef\x03\x4a\xec\xad\x58\x2d\x19\x1a\x83\xe1\xaf\x94\x43\xb4\x02\xe4\x67\x6a\xf3\x4e\xd4\x05\x72\x30\xa1\x25\x98\x7a\x8c\xb8\xb1\xbc\x6a\x8a\x5d\x4d\xd6\x27\xd3\xcd\x01\xad\xd2\xae\x35\xa7\xb6\x0a\xe7\x86\x7b\x3b\x2a\x0c\x31\x32\x5a\xcb\xa8\x8f\xf2\x6d\x4d\xe5\xa0\xa5\xa5\xdc\x53\xc9\xb1\x75\xf1\x86\xc6\xd8\x9c\x7a\x8f\x8d\x18\x06\x7b\x88\xe7\x6b\xca\xab\xd7\x6b\x6d\xde\x60\x8d\x37\x4b\x1a\xca\x66\x09\x6f\x6f\x1a\x5c\x7b\xcb\xaa\xcf\xcc\x11\x8f\x4e\x41\xb4\xaf\x3d\xb1\xa4\xdd\xe2\x26\x88\x8a\x40\xa8\xb7\x5e\xc7\xc6\x12\xe5\xb5\x9d\x87\x97\xcc\xbd\xaf\x73\x27\x98\x07\x79\xa5\xa1\xed\xb6\x42\xdb\x9d\x86\xa5\xd2\xaa\xc9\xd3\xc6\x47\xba\xeb\xd2\x5c\x79\x5d\xb9\xc8\xab\xbb\xee\x65\xc8\x6b\x37\x36\x4d\x3c\xd3\xee\xdc\x99\x26\x73\xed\xb9\x8d\x52\x57\x7c\x2e\x3a\x10\x91\xb0\x10\x61\xf3\x79\x5b\x46\x71\x94\x05\x45\x9c\xd7\xc9\x49\x8e\x38\x19\x37\x21\x96\x0f\xf0\x13\xde\x99\x17\xd7\x34\x6a\x63\x8a\x4c\x5b\xdc\x13\xd3\xaa\x98\x50\xed\xf6\x70\xa4\x6d\xd6\xd0\x53\x73\x3a\xeb\x50\xc0\x55\x97\xae\x6f\xf1\x69\x69\x95\xc6\xe4\xbe\xf5\x2b\x93\x9f\xed\xa8\x34\x76\x5f\x7d\xb7\xff\x79\x23\xdf\x7b\x74\xce\xe4\x88\x3d\x75\x87\x5b\x1d\x8a\x96\x7b\x07\xea\xd5\x5a\x1d\x65\xed\xf1\xee\xd8\x19\x88\x4d\x9b\x78\xe2\xa5\xf6\x40\x75\xc5\x2e\xb5\xcf\x19\x2f\xf3\xcd\x54\xab\xf7\xbd\x77\xe3\x3d\x8d\x55\x6e\x13\xfb\xd5\xe7\x21\xc6\xb2\xf0\xbc\x7d\x50\xbf\x63\x58\x3b\x16\xba\xd8\xd0\xa0\x76\x75\x28\x20\xa2\x56\xc0\xe8\x50\x2d\x07\x46\xea\x9c\x87\x6a\x97\x73\xc8\x12\x84\x15\xdb\xc4\xc5\x34\x17\x46\x41\xf2\x08\x11\xc9\x81\x41\x0d\x07\x28\x05\x93\xbd\xaf\x09\xe5\x64\x60\x62\x47\x4d\x87\x45\x49\x73\x4e\x3c\xd0\x31\xd1\x55\x66\x3d\xf2\xc0\xb6\xe5\x78\x43\x79\xc0\xf7\x9d\x69\xf7\x35\xdc\x62\x4e\x35\x5d\xfd\xa7\x9a\xfc\x2a\xae\x70\x1b\x78\x35\x43\xb0\xe4\x57\x89\x48\x9c\xb8\x5c\x57\x93\x18\xd6\xb9\x54\x1a\x77\x67\x76\xff\xa3\xf3\x0e\x4d\x4f\x2f\xa9\x2e\xab\x4e\xc7\x5d\xc7\x6f\xab\x9d\x19\x9e\xfb\xdf\xe3\xe3\x86\xcf\x5f\x33\x78\x88\x97\x74\x9c\x45\xad\x65\xe0\xff\x7d\xb5\xd5\x12\xf5\xc8\xf9\xa3\x18\xf3\xba\x61\xfe\xa8\x70\x1b\xaf\xe4\x7d\x5b\x2e\x7f\x84\x67\x51\x48\x16\x4b\x22\x4d\x68\x75\x84\xad\xbb\x9d\xbd\x8f\xe6\xdb\x35\x2a\xf2\x08\xeb\x0f\x0b\x58\x7b\xbc\xc5\xa9\x24\x23\xe4\xea\xf2\xea\xf1\x57\x6f\xb3\xd8\xeb\x50\xbe\x18\x0a\x84\x0c\x35\xf1\x9a\xd5\x06\x9b\x1b\x7d\xe6\x79\x0c\xa3\x90\xaf\x9f\x8b\xd5\x3c\x8f\x19\xfd\x44\xeb\x64\xe8\x0f\x96\x5f\xcc\x56\x2a\x27\x23\xbf\x90\xb5\x34\x5a\x24\x3a\x1a\x8b\xfc\x02\x52\x2c\x0b\x72\x60\xf9\x4f\xf7\x80\x82\x39\xa1\x07\xec\xa9\xfa\xeb\xa3\x51\xe9\xcf\x88\x41\x81\x0f\x6d\x14\x97\xb7\xe2\x8b\x67\x53\xa2\x65\xd0\x4d\xa4\x30\xc2\x30\x67\xaa\x5d\x89\x37\x56\x2f\x08\xeb\x28\x9e\x0f\xd8\x85\x6f\xde\x09\x2e\x4c\x9f\xbc\xff\xc6\x8e\x74\xc4\xe2\xf5\x04\x53\x1c\x0c\x7e\x52\x99\xec\xa6\x96\x6d\xb3\xde\x18\x5d\x48\x86\xab\x92\x65\xe3\x5c\x34\x5e\xe3\x1f\x57\x19\xd4\x50\xa4\xd9\x10\x89\x99\x4c\xc3\x00\xa6\xf4\xea\xee\xba\xb5\x4a\x43\x80\xa6\x54\xe3\xfd\x43\xa4\x39\x26\x70\x3f\x5d\x7d\xe3\x87\x3b\xda\xa6\x38\x39\x9e\x55\xf9\xfd\xd1\xae\x2a\xb5\xd2\xa7\xe4\xf8\x96\xea\xc3\x5b\x5a\x9e\x3d\x2d\x9c\xc1\xb1\x4b\xdf\x6a\x53\x56\x87\x93\x4b\x95\xbc\x4b\x1f\x08\xfa\x17\x91\xe6\x39\x2f\x1f\x7b\xed\xde\xfb\xc1\xa3\x52\x1d\xfa\xda\x27\xe4\x36\xa8\x8b\x8d\x58\xf5\x0b\xa8\x08\x74\x51\xe5\x8d\x79\xaf\xe4\xc2\xc2\x8b\x06\x8b\xd9\x92\x2b\x60\x15\x4a\x56\x72\xed\x85\x12\x63\x27\xa9\x70\x85\xfc\xbc\xe4\x14\x03\xa9\x64\x4d\xaa\x56\xf4\xfe\x25\x7e\x44\x44\x5c\x88\x4e\x24\xb1\x8d\x53\x07\x46\x3a\xa6\x08\xb3\x97\x8e\x18\xf4\x35\x41\x61\x60\xd0\x43\xea\x37\x6c\x0e\xac\x6d\x77\x2a\xe9\x20\x5e\xb9\x68\x4e\xd8\xaa\x0f\xab\x9d\xee\x50\x2b\xaf\x56\x79\xe6\xe0\x55\xbb\x7b\xda\x97\x0a\xd7\x0e\x75\xcc\x9a\xcd\x73\x5b\x5a\x9f\xb7\x29\x66\x75\x9d\x03\x8e\x5d\x23\x89\xc5\x30\xea\x2d\x1b\x5a\xec\x7a\x65\xc9\xbb\x13\x77\xaf\xae\xf0\x8a\xfd\x69\xb2\xfe\xe9\xc2\x14\x85\x61\x3a\x86\xa2\xc0\xcf\xc5\x9f\xdf\x01\x7f\x7e\x5e\xfc\xb9\x42\xfe\xf9\x6f\xa5\x9f\xe3\x11\xe2\x2d\xf2\x42\xfe\xe7\x0a\xf0\x8e\xe8\x63\x97\xe3\x77\xc0\xf8\x71\x35\x66\xc2\x54\xcf\xaa\x4c\x22\x0c\xa3\x9e\x23\x84\x30\x5a\x52\x2c\x86\xa1\x00\x18\xbd\x27\xfb\xc0\x61\xd1\x75\x4d\x5d\xe9\x36\x05\xf4\xac\xe5\x42\x42\x65\x32\x93\xab\x39\x8d\xd7\x36\xb2\xfa\x6e\x9f\x89\x55\x7a\x80\x7b\xba\xde\x2c\xd6\x8f\xe0\xdf\x49\x84\xe0\xdf\xc9\x63\xe5\x18\x07\x85\xcd\x97\x4b\xf0\xfe\x76\x4d\xe9\xdf\xdc\x46\x26\x03\xd7\x7f\x10\xa1\xcc\x7f\x90\x4e\x5d\x33\x65\xb8\xdc\xf3\x8f\x7f\xf7\xc9\x8c\xb1\x7b\xd3\x63\x53\xbe\x84\x10\xfc\xda\x4c\xe8\x63\x17\x10\x97\x30\x0e\x33\x60\x99\x74\x39\x4d\xe9\xb4\x7a\x9d\x41\x43\xa9\x39\x8e\x54\x33\x24\x83\xc3\xec\x1f\x37\xea\xb5\x99\xac\x5e\x8f\xeb\x28\x4e\xcd\xe1\x5c\x6f\x56\x89\x06\x03\x25\x0b\xd5\xad\xdc\xfc\xaf\xc6\xa2\xd1\xdc\xe2\x2e\x64\xf4\x4c\x32\x29\xbd\x9a\x8c\xf8\x18\x40\xf8\xce\x28\x84\x17\x14\xcb\xc1\xfb\x8f\x9e\x5f\xaf\x10\x56\x29\x37\x95\x09\x8f\xec\x05\xfb\x7f\x08\xfc\xf1\x78\xdc\x46\xac\xb9\x7a\xb7\x0d\xfe\xfe\x8f\x7f\xe0\xff\x23\xac\xc0\x64\xfa\xc8\xe3\xc4\x79\x98\x37\x87\xb1\xbb\xd2\x19\x10\x0e\xa1\xd7\x9f\x2a\x9c\x09\x1a\x30\x9b\xd5\x68\x34\xb9\x3c\x1e\x93\x8d\x21\x29\x95\x2a\x4a\x45\xdc\x76\x9f\x3d\x93\xf5\x05\x7a\xb3\x3e\x53\x18\x64\xb2\x06\x5b\x26\x6b\xe1\x0d\x61\xf8\x0f\xa5\xd4\xe8\xd1\xf2\x94\x90\x52\xda\xf2\x2c\xee\x78\x36\x15\x82\x05\x39\x60\x40\x6d\xf5\x90\xf6\xd8\x98\x16\xd3\xa2\xa1\x24\xc9\xe2\x67\xa1\x01\x69\x8d\x3c\xea\xf5\x66\xa4\x9e\xe9\x64\x2a\x49\x04\x22\x68\xd3\x38\x1a\x63\x09\xff\x9b\x03\x00\xf0\x53\xe1\xc2\x12\x56\xf8\x0e\x3b\x8c\x8f\x1b\x61\xf1\xbf\xc4\xda\xc1\xe0\x86\x9d\x2d\x6f\x27\xda\xea\xdb\xe8\xff\x6c\xbb\xf7\xe6\x81\x49\xed\x4d\xa3\x41\x76\x55\xf3\x78\xe1\x77\x20\xfd\x85\x15\xc9\x22\xc4\xc7\xff\x7a\x0f\x2b\x3c\xb9\x46\x78\x67\x9d\xf0\x80\xe2\xbc\xf0\x59\xdc\x06\xa6\x82\x03\xc2\x76\x78\x64\x58\xe5\xb5\xdf\x53\x16\xe2\x0d\xcc\x8f\xd5\x60\xcd\xe8\xc5\xa1\xbb\xbc\x51\x4f\x47\xcb\xa3\xc9\xaa\x24\x56\x65\xb1\xa8\x31\xa2\xa5\xb5\xa2\xde\x5b\x9f\xc9\x92\x8d\xbd\x59\xb7\x57\x4f\x92\x5a\x87\xd7\xcc\x07\xfa\xb3\xbc\x4e\xa5\xd5\xb2\x7d\x59\xad\xae\x64\x61\x0a\x1a\x24\x08\x23\xc3\xd2\x0e\x77\x43\x6e\x48\x06\x3c\xcd\x5a\xc9\xb7\x88\x75\x1d\xb1\x6f\xa0\x68\xa7\x4c\x58\x5c\x70\x0d\xfc\x68\xbd\xa3\x8e\xc9\x45\xfa\xf2\x1c\x0d\x2d\xa8\x3c\xf0\xd9\x57\xd8\x17\xa6\xed\x69\x70\xbd\xf8\xd5\x65\x3b\xcb\x33\xe7\x26\xac\xb8\xe5\xd8\xb5\x93\xed\x9b\xcb\x17\xdc\xbe\x71\x0f\xf1\x50\xe5\x86\x5a\xf6\x7c\x76\xd6\xdc\x87\x16\xf7\x5f\xfd\x76\x75\xd5\xdc\x03\xfe\x27\x5e\x78\x72\xce\x7d\xc3\xea\xfa\xf6\xf7\x5a\xa2\xe5\x0f\xf7\x64\x7b\xe6\x5c\xb9\xe7\xbc\xf0\x5f\x4f\xc4\xdc\x53\x96\xe3\x7f\x6f\xab\x69\x08\x09\x1f\x7e\xd0\xf9\x20\x20\xf7\xad\xd9\x36\xba\xb8\xbe\xe5\x87\x6f\xea\x1f\x80\x72\x31\x41\xe1\xcc\x11\x77\x17\x38\xb1\x10\x7a\x8d\x88\xf3\x98\xcb\xe5\x74\xaa\x18\x2b\xe9\xd3\xeb\x49\x46\x41\x86\x31\x2c\xe2\xc0\x15\x4a\x45\x26\xeb\xe2\x95\x4a\x46\xab\x0d\x65\xb2\x5a\x75\x6f\x56\xcb\x31\xce\x4c\x7e\x51\x58\x7e\x76\x80\x1c\x76\x8c\x59\xe4\x86\x24\x83\xfa\x9d\x02\x90\xdf\xb2\xfc\xa4\x00\x2f\x42\x3e\x20\x6d\xc1\x24\x8c\x52\xd3\x03\xfc\x6a\x8e\x76\xd1\x44\x61\xb9\x70\xbe\x67\x97\x76\x57\xeb\x36\x16\x1c\x07\x75\x53\x26\x08\x7f\xdd\xb0\xfe\x9d\x4d\xed\xd3\x46\x56\x2c\x9b\x32\x63\x21\xae\xce\x34\x0e\x0b\x3f\x07\x2f\x65\xc0\x1c\x5b\xfc\xcd\xa9\x1b\x5c\xc2\xa4\x85\x2b\xbe\x22\xdc\x03\x5e\x18\x5a\xdb\xd2\x8e\x70\x08\xcd\x08\x79\x01\x9e\xb9\x0b\xab\x4d\xdb\xad\x76\x03\x61\x27\xdc\x6a\x85\xc2\xc3\x68\xd1\xda\x58\x9d\x0d\xc3\x4c\xbd\xd2\x8b\x85\x5c\xba\x53\xd2\x57\x5c\xbc\xcb\xa5\x2e\x57\x70\xcb\xf7\xc8\x80\x9f\xbe\xf1\xdf\xc7\x80\xe6\x89\xc3\x8f\x85\x5a\x07\x6e\xdc\xf2\xd2\xf2\xdd\xbb\x7a\xf6\x47\x9a\x9b\x2b\x7b\x2f\xf0\xdf\xbe\xfc\x0c\x30\x1c\x0f\xff\xfe\x48\xc3\x2d\x9f\x9e\x3e\x7a\x3a\x60\xbf\xf7\x6f\x66\xab\x54\x07\x9f\x70\x6d\x94\x78\x0f\xca\x5b\x01\x25\x1e\x4f\x5b\x29\x3d\xa6\xd1\x6b\x4c\x66\x71\x7c\x33\x99\xc9\xf2\x9c\x9e\x81\xd0\x51\x24\x52\x90\x6f\x73\x16\x25\x23\xf6\xa1\x49\x93\x39\x43\x68\xbd\xb8\xef\x81\xf3\xb3\x0e\xce\xee\x7c\xfd\x3b\xc2\x2f\x7e\xf9\x07\xe1\xdb\xc2\x67\xc2\xd3\x27\xb7\xb1\x78\xe4\xbe\x93\x57\x3f\xa3\xfe\x8c\xaf\x79\xe3\x25\x41\x10\xde\x23\xe4\xe5\xc4\x38\xc6\xcb\x9f\xaf\x85\xe7\xdd\x9d\x2e\xe3\xad\x56\x5c\xc3\x29\x14\x26\x0d\x46\xba\xdc\x16\x71\x78\x02\x0f\x80\x86\xd2\x40\x5c\xd0\x98\x28\x63\x26\x4b\x11\xd0\xf0\x39\x48\x50\xc9\x50\xf0\x31\x6b\x93\xd0\x78\x84\xa4\xbc\xb0\x5e\x24\x2d\x24\x52\x8b\xb6\xf4\x21\x8a\x79\xe9\x18\xef\xc9\x91\x38\x0d\xbf\x03\xd2\xdd\xfc\x89\xf6\x93\x76\x44\xbb\x7c\x88\x32\xad\xe0\xa5\x95\xf7\x9d\x14\x9e\xcd\x08\xf7\x50\x7f\x16\xfd\x49\x27\xd4\xd1\x1a\x71\x36\xe1\xc6\x74\x5a\x0f\x13\x07\xad\x8a\xa6\x49\x95\xd1\x88\x41\xa9\x5a\xed\x24\xe9\x50\x19\x32\x59\x9d\x46\xad\x72\xaa\xba\x55\x83\xaa\x55\x2a\x4a\x4d\xa8\x54\x18\x21\xbe\xec\x27\x08\xd0\x9b\x25\x38\x0b\x86\x41\x66\x30\x53\xb1\x33\x2e\xd4\x61\x93\xd7\x0f\x6e\xcf\x3d\xa0\x15\xd9\xfa\x52\xb0\xea\x3c\x0d\x25\xfd\x96\x0c\x4e\xff\x59\x59\x0c\x4e\x48\xde\x63\xd0\x48\xec\x19\x47\xf3\xa1\xd0\x0e\x5a\x03\x8d\xe6\x43\xa1\x8b\x68\x61\x21\xb8\x0c\x79\x43\xbd\x1e\x55\x69\x8b\x96\x25\x19\x96\xe1\x4d\x7a\x15\x23\x2d\xe1\x43\x0b\x2f\xd1\xbe\x4b\xb9\xb0\xa4\x7b\xb3\xa6\x58\x25\xd0\x93\x25\x34\x12\xaf\xb8\xa7\x99\xbe\x9f\x05\x93\x4e\xed\x65\x85\x1f\xb4\xa5\xe3\x15\xe9\x74\x45\x3c\x8d\xa8\x41\x43\xb9\x85\xb7\xa5\xef\xd3\x52\x9d\x87\xb8\xf6\x57\x7c\x22\xfc\x6c\x1d\x56\x91\x36\xab\x58\x8c\x60\x09\xbd\x81\xd6\x64\xd0\xf0\x4a\x73\xf1\x07\x4b\x3b\x71\x4a\x3e\x15\x2f\x4c\x40\x48\x81\xe3\xb7\xb3\xa0\x7e\x6d\xe3\xa7\x4b\xda\x83\x29\xa5\x25\x59\x5e\xa7\x46\x9f\x38\x7a\xb3\xf0\x4d\xfb\xb7\xb7\x3b\x6a\xc7\xa3\xde\x78\x78\x86\xef\xa1\xb9\x51\xc4\xef\x15\xe2\x2c\x19\xc8\xfc\xbb\xe2\x3e\xb6\xee\x74\x54\xad\xd3\x51\xc0\x68\x32\x69\xa0\x7e\x5b\x54\x34\xda\x75\xaf\x86\x0e\x87\xd4\x10\xf0\x1f\xc0\x72\x50\x23\x75\x19\xe9\x69\x7e\xe1\xb1\x77\x6e\x27\x61\x89\x16\x42\x64\x61\x0a\x3b\x4c\xe1\xbf\xe2\x49\xe1\x47\x47\x9f\x6d\x3f\xa6\x3d\xd6\xbd\x95\x05\xcf\xb1\xf7\x34\x7f\xa4\xfd\xa8\x63\xdf\xae\x9e\x69\xed\x60\xb8\x27\xd3\x03\x2e\x20\x1f\x2a\x3c\xb5\x35\xb3\x55\xb8\x43\xfd\xaa\x74\x4e\x6f\xc0\xf8\xee\x37\x22\xbd\x7f\x28\xcc\xb0\x42\xdf\xa3\x0a\x66\x6e\xfe\x90\xd8\xeb\x2f\xbe\xdb\xb9\xf6\x37\xf8\xfd\x61\x11\x6b\xea\xd2\x76\xbd\x51\x6d\x37\xda\x3d\x14\x8e\xbb\x8d\x16\x0b\xf4\xff\x16\x1d\x06\x9d\x28\x81\xb0\xa6\x26\x9f\x6d\x8f\x01\x9b\xdc\x0b\x0c\xf9\x7d\x6b\xd1\x13\x50\x9c\x04\x65\x0f\x1f\x0b\x37\x53\xde\x4d\xe9\x7d\xaf\xaf\xb8\x73\xcf\xcd\xab\x6a\x5a\xe3\x07\x76\xb5\xbf\xf9\xf1\x09\xe1\x13\xbe\xf2\x6f\xf7\xda\x03\x47\xfe\x71\xec\xf6\x07\x1b\x8e\xfc\xde\xae\xfe\xcf\x67\x2f\x08\x9f\x1c\x43\xba\x15\xc5\x58\x12\x10\x47\x30\x0d\xe6\xc0\xca\xd2\xbc\xd2\x44\x68\x4d\x5a\xa7\xcb\xca\x74\x65\xad\x7a\x3d\xd6\x95\xc3\x19\x71\x6f\x31\x28\x6c\xf8\x92\xf2\x21\x54\xae\x71\x03\xb1\x17\x20\x28\xc5\xf9\xa4\x19\x3f\x75\xf0\xc8\xdd\xa3\x77\x1d\x86\xbf\x80\xab\xd2\xf8\x26\x69\x94\xd3\xe5\x91\xf9\x73\x1f\x5b\xb8\x7c\x68\xee\x23\xf3\x5f\xce\x4f\x7e\x12\xe7\x8a\x62\x06\x91\x06\x17\xd4\x6e\xab\x09\xd3\x32\x8c\xd2\x8e\x91\x6e\x8f\x5d\xa5\x50\xf5\x65\x15\x84\xa1\x0b\xda\xa6\x94\xe0\x48\xbb\xb8\x73\xc7\x29\xf7\x0c\x90\x06\x18\xcc\x45\xea\x92\x05\x9a\xcc\x1e\x60\x82\x69\x45\xf4\x4b\x41\x16\xfc\x01\xa2\xb2\xf0\xb7\xaf\x1e\x3a\x7b\x1d\x2a\x8b\xbd\x55\x98\xff\xda\x33\xe4\x26\xe2\x97\x50\xef\xdc\x58\x04\xeb\x4b\x57\xb9\x7c\x4e\x3f\x19\x34\x9b\x55\x41\x8c\x22\x49\x0c\xd7\x69\x54\x5a\x26\x5a\x46\xe1\x4e\xbf\xcb\xa7\xd1\xb1\x06\xc6\xe0\xe9\xca\x72\x06\x8e\xb1\x77\x65\x49\xc6\x24\x17\x79\x45\xec\xb0\x94\xbc\xe9\x95\x22\x1c\x9e\xb1\x98\x22\xb2\xcc\x52\x91\x3a\x8b\x28\x37\x8a\x17\xdf\xd6\x00\x3a\x04\xd3\x23\x91\x15\xb2\xb6\xeb\xe0\x2b\x2b\x1e\x44\x12\x9c\x7a\xd3\xd7\x57\xdc\x87\x84\x78\x75\xc3\x6d\xff\x3c\x3a\xae\x6e\xf4\xfb\x8b\x41\x45\x6b\x0a\xaf\x98\x7b\xfb\xff\x82\xcd\xb7\xce\xdd\xb2\xf2\xf1\x3e\x28\xd1\x43\xf3\x6e\x58\xfe\x58\xef\xa1\xbf\x83\xb9\xf7\xcf\x51\x83\xdf\xd6\xcd\x57\x09\xb6\xda\x91\xb9\x0f\x0c\x62\x52\x7c\xf3\x09\x65\x13\xdf\xe9\x25\xb0\x06\x6c\x49\x3a\x65\xac\xaa\x0a\x27\xe3\x49\x2e\x4e\x10\x5e\x85\x93\xa3\x1a\x9b\x8c\x55\xbd\x59\x85\xda\xeb\x36\x1a\xd5\x0e\xb7\xdb\xda\x97\x75\xeb\xd4\xf5\xe8\xc1\x18\x53\x06\xbd\xb8\x19\xf3\x43\x78\xd4\x15\xbd\x7d\x95\xf5\x14\x15\x85\xd0\x20\x8c\xd8\x98\x20\x47\xca\x47\xa5\x05\x79\x85\x1b\x85\xdc\x5e\x3c\x14\xf0\x58\xea\x2d\xfe\xe2\x3a\x66\xfe\x7d\x14\x09\x6e\x3e\xba\xeb\xa3\x3b\x1e\x9a\x52\xf5\xd0\xdc\x15\xdb\xb7\x7d\xfc\x15\x4d\x7f\x2f\x8a\x75\x2e\x9d\x7b\xbe\x6e\xef\x53\x53\x6e\xcb\x4e\x68\x9b\x76\x5b\x26\x3d\xfa\xcf\x07\x9f\xa8\x0c\x4c\x87\x66\xf5\xfc\x99\x67\x84\x1f\x9f\xbd\x6b\x5c\xcf\xa2\xb9\xf3\xef\x1f\xd6\x74\xf4\x2c\x1d\x40\x51\xce\x3d\xf7\xf4\x9f\x13\x7e\x73\xdf\xc8\xc6\x4b\xc0\x7e\xf7\xb2\x0d\xc2\x62\xee\xc4\xae\x96\xd6\x4f\x90\xee\x73\xd0\x1e\x7b\xa0\x3c\x42\x58\x25\x36\x3f\x1d\x8e\x73\x21\xab\xdf\xe9\x34\x45\x59\x34\xc3\xd7\xc4\x91\x89\x2a\xca\xe0\x89\xc1\x88\xd7\xe3\x51\x63\xea\x30\x12\x83\xcd\x2a\xf5\x8c\xf1\x5d\x56\x6b\x28\x84\x44\x51\xa3\x87\xc8\x97\x6c\x2f\x59\x8c\x57\x7c\xe0\xb2\x18\xc8\xdc\x13\xf4\x7c\x35\x4c\xaa\xb2\xe4\x67\x4b\xa1\x44\x98\xa8\x11\x25\x03\x05\x16\x07\xbe\xf5\x1b\x67\x2d\x5d\xfe\xc6\xc1\xc7\x5f\xbc\x67\x4f\x77\xe6\xcd\xb3\x9a\xa1\xfe\x9e\x89\xc3\xeb\x9a\xc7\x3d\x7a\x75\xce\xe2\x51\xe2\x0d\xd5\x77\xb3\x37\x05\x4c\x6b\x27\x67\x6f\xef\xbd\x61\x64\xe5\x03\x0e\xd3\x60\xdb\x8a\x03\x74\x9f\x6e\x7a\x77\xe7\xc4\x4d\x37\xd4\xa5\x35\x57\xbf\xf5\xab\x71\x03\xbf\x3c\x89\xee\x58\xc1\x8f\xc4\xf9\x6e\x06\x2c\x9c\x86\x64\xaa\x19\x8c\x31\xf2\x4a\x8c\x24\x39\x18\xc8\xea\x64\xf3\x2e\xf6\x19\x46\x79\x76\x3a\x93\x7b\x51\xc4\x8c\x37\xde\xf5\xd1\xa1\x33\xdf\x62\x2e\xaa\x96\x0f\x6d\x7e\xd9\x0d\x7e\x74\xfb\x2f\x76\xfd\xe0\xb9\xc6\xf2\x89\xe9\xc3\x47\x7e\x73\x59\x8e\xa3\x5e\x02\x3f\x92\x3e\x03\xd7\xb1\x0a\x9d\xc2\xc8\xb3\x06\x8d\x86\x82\x31\x82\xf9\xcb\x3e\x23\xf7\xb8\x3b\x89\x8a\x15\xc8\x10\x3e\x55\x8e\xcc\xbf\xe1\x55\xf7\x45\xd3\xdd\x1f\xdd\x02\x3f\x0a\xfc\x28\x3d\xfe\xe0\x91\x5f\x3e\x7f\xe4\xa3\x1d\x3f\x78\x2e\xda\x84\xe2\x22\xa8\xc4\x75\xd0\x1f\xb0\x98\x05\x4b\xa7\xfd\xa4\x1e\x33\x9b\x95\x7a\xa5\xcd\x8a\x99\xa0\x5a\x62\x4a\x69\xd6\x2d\x9b\x41\xf3\x6e\xcd\x85\xad\x9c\x85\x29\x26\x85\x29\xb7\xf0\x44\x72\x81\xa4\xd1\x27\xc7\x24\xa8\xcb\x87\xb0\x80\x86\xe6\x9b\x0f\x2e\x58\x99\x24\x84\x6f\x9c\x82\xe1\xc8\xed\xa7\x1f\x7a\xe7\xca\xee\x24\x8c\x18\x37\xed\x1c\x9c\x75\xf5\x51\xe4\xb4\xf6\x6c\x7d\xf0\x09\xe1\x27\x36\x31\x97\x7a\x1d\xd2\x34\x9f\x78\x05\xc6\x6a\x2e\x6c\x6e\xba\x4a\xa3\xa3\x78\xb5\x5e\x85\xc6\xa9\xea\x79\x1d\xa9\xf5\x68\xdd\x7a\x56\xcd\xaa\x33\x59\x96\x55\x5a\x2c\x38\x4c\x9d\x74\x5a\x1d\x0c\x8b\x4d\x4a\x47\x11\x85\x85\xa8\xe9\xcb\x76\xc2\x8b\xe4\x86\x73\x4f\x08\x09\x63\x00\x35\x08\x01\xb9\x34\x62\xb6\x40\xef\x8e\x7f\xb5\x75\xea\xc6\x2d\xcb\xe7\xad\xed\xeb\x38\x26\xfc\xec\x23\x76\x00\x70\x93\x07\x3f\x78\xb3\xea\x85\xee\xbb\xf6\xb3\xc4\x2c\xed\xaa\xa1\xe9\x0b\x04\x27\x38\x26\xac\x8a\x5b\xc0\x1a\xcb\xee\xbe\xdb\x4f\xeb\xd4\x57\x1f\xb2\x4a\xf1\x5e\x0c\x9e\xdd\x5c\x51\xae\x4e\x6c\x4e\x3a\x01\x69\x57\x90\x9c\x85\x87\x99\x20\xcf\x11\x2e\x85\xc2\x6d\xb4\x02\x2b\xcc\xfc\xac\x56\xb5\xd3\x69\xef\xcd\x3a\x39\x33\x8f\x36\x67\xa9\xe9\xc2\x53\xd2\xff\x0b\x0b\x22\x07\x08\xe2\x88\xfc\x04\x35\x71\x12\x0e\x8a\x9e\xf0\xf9\x6b\x37\xdf\xff\xd0\xdc\x0e\xd0\xf9\xf8\xf3\xb7\x3e\xfa\xe8\xe4\x6d\x13\x8e\x74\xb3\x1f\x1d\x3d\xd6\xbe\x99\x05\xdf\xba\x7b\xe5\x4d\x5a\x62\xd6\xd5\x41\xe7\xc6\x95\x93\x6f\xcc\xea\x21\x07\x71\x61\x15\x98\x66\x8f\x4b\x31\xca\x32\x78\x06\x87\x20\xfd\x46\x6c\x42\x3a\xa0\x33\x30\x6a\x5a\xa3\x51\x1b\x08\x9e\x80\xc1\x3b\x6e\x30\x18\x69\xad\x11\xe6\xda\x46\x8e\x51\x2b\xd5\xb2\xd0\x8b\xb6\x0f\xe9\xc7\x8c\xc8\x2c\x59\xd3\x9a\xdf\xa8\x44\x1c\xaa\x4a\x69\x06\xa7\x38\x0f\xef\x63\x85\x71\xec\xf1\xc3\x8e\x69\x0b\x26\xa7\xaa\xe4\xfd\xac\x7f\x40\xc1\x01\x61\x44\xab\x84\x10\x3d\xfb\x60\x5c\xb0\x54\xdc\xab\xd3\x9e\xf6\xc0\xb4\x90\x26\x78\x1b\x61\x73\x59\x2c\x6e\x1b\xcf\x4b\xa1\x8b\x99\xe5\x30\x5d\x5f\xe1\x29\x74\xd1\xb4\xa4\xe2\x01\x02\xd4\x75\x13\x8c\xeb\x73\xdf\xc1\xec\xe2\x17\xcf\x9e\x53\x2d\x58\xcf\x82\xbb\xd8\xed\xf3\x94\x57\x6e\xb9\xd7\xb8\x78\x0b\x0b\xfa\xd8\xed\x8b\x9c\xef\xf3\xbb\xd7\x57\xb7\xe0\x2e\x44\xd7\xe8\x1f\x9b\x22\x67\x77\x6e\xc0\x2b\xc4\x6f\x7e\x7c\xf6\x49\x51\x66\x33\x31\x3f\x69\x27\x36\x40\xaf\xdf\x91\xf6\x98\x19\xab\x86\x56\xa8\x08\x9d\x4e\x45\x5b\x49\xa7\x4b\xa1\x56\x43\x1f\xcc\x9a\x6d\x36\xcc\x62\x34\xba\x20\x6d\x30\x63\x83\x40\xf7\xba\xfc\x72\xa7\x64\xf3\x84\x1c\x0d\x84\x23\xa1\x3a\x2a\x65\xd1\x47\xe4\xea\x7f\x38\xc4\x44\xf4\x94\x99\xe8\x40\x93\x87\x47\x0f\x22\xbb\x91\x76\x2e\x4d\x1b\x7d\xc6\x1a\xc7\x27\xec\xfa\x96\xb4\x91\x09\xbd\xfc\x15\x7e\x27\xef\x6c\x5a\x8a\x26\x19\x2f\xb5\x40\x5f\x15\xc3\xfc\x54\x58\xa4\x2f\x82\x25\xb1\x19\xe9\x98\x27\x16\x0b\x55\x97\x10\x5a\x4d\xd5\xd6\x39\xfd\xd1\x4a\xd2\x58\x4a\x6f\xdd\x75\xf4\x96\xfa\xe0\xc2\xc8\x82\x7f\x43\x37\xc8\x5f\xdf\xd4\xd6\x1b\x8b\xbe\x26\xa7\xfd\x0b\x7e\x76\x5f\x1d\x29\x6f\x6e\x8b\xc4\x1a\x9b\xca\xcb\x9b\x5b\xca\xca\x9b\x9a\xfe\x0d\x83\xf8\xba\x86\xf2\xf2\xa6\xc6\x58\x79\x83\x70\x5f\x43\x79\x59\x4b\x5b\xa4\xbc\x41\xd2\xe5\xe3\xd7\x7a\xc9\x39\xe4\x66\x2c\x8e\x0d\xa4\xcb\xfc\x16\x85\x0a\x33\x47\x7d\xc1\xb0\xcb\x60\x88\x11\x44\xd8\x67\x56\x51\x95\x89\x60\x24\xe2\xf7\x63\x16\x0b\x74\x41\x01\x0d\x4d\x2b\x95\x95\x22\xc7\x88\x5f\xb1\xbf\xbb\xf8\x90\x8a\x06\x89\x24\xf3\xb3\x5f\xf3\x5c\x4a\x2d\x7e\x00\x89\x00\x7e\x9d\xfb\x32\x2f\x0d\x62\x77\x6e\xa5\xa1\x2d\x2e\xaf\x3e\xdc\xdf\x28\xbf\xc0\x9e\xb9\x3f\x55\x78\x81\x0d\x66\xc9\x5b\x12\xf7\x2b\x40\x5c\x5c\xa7\xb8\x7d\x48\x7e\xdd\xbd\x6b\x48\x7a\xdd\x2d\xfc\x4e\x7a\xdd\x0d\xe3\x62\x27\xc4\x9b\xdb\xc5\x38\x39\x2b\xcd\x8b\x85\xf6\xf2\x27\xf1\xfb\x39\xe7\xe4\x39\xaf\x04\x2e\x7e\x2f\xdd\x49\x7e\x1d\xfe\x79\x5a\x9c\xb3\x2d\xbe\xd5\xe7\x1c\x10\x5f\x1d\x16\x82\xd2\xdb\x6c\x1e\xca\x6d\x37\x58\x61\x66\xe7\xe0\x38\xc2\x0a\x45\xc2\x11\x6c\x1f\xcc\xe7\xcc\xb9\x10\x6c\xcc\x20\xdc\x52\x3b\x2f\xd9\x3c\x2a\x4d\xc0\x15\x1f\xcf\xfa\x18\x28\x27\xfc\xfe\x4f\xde\x78\xfc\x80\x67\xc7\xd1\xf5\x47\xd6\x8f\xb8\x59\x10\x1f\x98\x79\x32\x9c\x4a\x54\xe0\xfb\x14\xc2\xd7\xd6\xec\x00\xd5\x77\x3c\xbf\xb0\xa5\xe1\x86\xa5\xd3\x17\xc7\x41\xaf\x51\x77\xcb\xe7\xd5\xc2\x63\x9a\x7d\xe8\x0c\x5d\x90\x5e\xab\x18\x57\x2c\x4a\x57\x53\x76\x1b\x6d\xa7\x95\x2e\x17\xc1\xe9\x7d\x01\xe8\x03\x02\x7a\x82\x0c\x47\xa4\x1f\x63\xbc\x5e\xcf\xf3\x68\x0b\xbe\x2e\x10\xc0\x30\x4f\xa6\x50\x6a\x48\x14\x8d\xf7\xb9\xce\xe8\xf4\xa5\x05\x88\x50\x7e\xe2\x0d\xa2\x5e\xca\xf3\x28\x0e\x88\x80\x81\x2a\x11\x34\x38\x70\xfe\xeb\x20\xc8\xd7\xae\x58\xbf\x64\xde\xc8\x40\xba\x33\x7e\xec\xae\x87\xbf\x29\xfc\x37\x5f\xfb\xe1\x9b\x4b\xd0\xb7\x27\xf8\x4d\xc3\xdf\x0d\xac\xa7\x54\x83\x73\x3b\xc7\x57\x3f\x2a\xc4\xb6\x2c\x42\xdf\x5a\x9e\x38\x80\xbe\x41\x3c\x79\x20\x4f\x7f\x16\xdf\xd0\xb7\xa7\x7d\x1a\x65\x28\x12\x71\x78\x48\xa3\x49\xc9\x94\xc7\xe0\xef\x46\xd6\xaa\x0b\x70\x68\x8f\x46\x18\xe6\xd4\x2c\x92\x7e\x32\x51\xb4\x50\x2a\x59\x14\xb2\x43\x8a\x13\xf2\x93\x36\x29\x39\x84\x6e\x20\xff\x9e\x49\x0b\x18\x31\xc1\x11\xa9\x26\x1a\x97\x6c\x8b\xd9\xeb\xdb\x0f\xce\x9b\x35\x31\x90\xe0\x5d\xb1\xd4\xb4\xa9\xe3\xef\x79\xf6\xee\xd5\xc7\xda\xd7\xee\xd5\x07\xb2\xe3\x52\xfe\xa6\x44\xa0\x9f\x9f\xd2\x53\xd5\x3c\x71\x92\xf5\x8d\xb5\xbc\xbd\xb9\xef\x7b\x4f\x9f\xfe\xe6\x5d\xeb\xa6\xdc\x76\x68\xab\x77\x7c\x27\xbf\xf6\xdb\x46\xc9\xae\x50\x6e\xd9\x06\x75\x48\x85\x45\xd3\x26\x9a\x61\xd4\xb8\x4a\xa5\x11\xab\x96\x30\x40\x01\x4a\x0e\x05\xed\x50\x65\x62\xf9\x25\x12\xe2\xa3\x24\xe4\x05\xa4\xa1\x1f\x56\xb4\xa2\xfb\xc8\xc9\x33\xa7\xb7\xb2\xf8\x7f\xe1\x0f\x42\xd0\x3f\x2b\xd7\x4b\xc0\xb5\xd5\xf0\xef\xee\x26\x2e\x61\x5a\x2c\x95\xb6\x63\x94\x86\xa5\x58\x42\xa9\xd4\x11\x9c\x96\xe6\xe0\x37\x10\xcd\x7a\xb3\x2a\xc2\x54\xb4\x8d\x2a\x59\x52\xdb\xad\xae\x4a\x59\x8a\xab\xba\xc4\x8c\x4d\x0a\xe1\x49\xc5\x5a\xf0\xbb\x53\xab\xb7\x28\x84\x79\x8a\xdd\x13\x27\xda\x8a\x4a\xb9\xf8\xdb\xd2\xdb\xf2\xc9\x68\x97\x14\x9a\x85\x8d\x49\xb3\xb1\xe5\xf8\xc8\x40\x53\xe2\xdb\x2e\x34\x39\x9c\xdc\x00\x79\x0e\x63\x2b\xd2\x75\x0e\x0c\xe3\x29\xca\xc3\x19\x0c\x6a\x85\xc7\xaf\xf0\x47\xbc\xde\xa8\x87\x0b\xd3\x3c\xf4\x46\x0e\x9e\x27\xb4\x76\x93\xc9\xaf\x46\x25\x3b\x8b\x96\x93\x68\x26\x4c\xa5\x0b\x48\xf5\xf9\xfd\x75\x98\xbc\x31\xa4\xe0\xab\x0a\x83\x22\x24\xaf\x29\x45\xb7\xe8\x55\x97\xb8\x0f\x2d\xb7\x4c\x2b\x65\x4c\xa2\xf9\x1d\x0c\xee\x1a\x61\x85\x5d\xec\xc6\xea\xaf\xdc\x4d\x46\x07\x58\x21\xae\x3a\xd9\xbb\x94\x05\xdb\xd8\xd5\xbd\xc3\x6b\xf8\xda\x51\x76\x5e\xc4\xfe\xc6\x0b\x22\xd7\xc0\x44\xee\x5c\x6e\x2c\xfb\xb5\xbd\xe2\x8b\xce\xc8\x29\x25\x78\x55\xcc\xc4\xdb\xa8\x35\xab\x41\xa4\xc2\xfe\x93\xd3\x77\x90\x08\x33\x1e\xbc\xf6\x07\x34\x2f\x00\xe6\xe2\x9f\x88\x31\x0d\x87\x27\x89\xf1\xd4\x3c\xb1\x06\x3f\x21\xed\xd4\x18\x74\x7a\x2d\xaa\xb4\x8b\x05\x78\x23\xcf\xa8\xd5\x24\xa7\xe5\xc4\xfa\xfb\x15\x50\x85\x29\x31\x1c\xb4\x61\xed\x49\xa9\x62\x9b\xab\x46\x82\x42\xed\x1d\x06\xac\x4c\x60\x6c\xe1\xfd\xcf\xf4\x87\xf4\x38\x70\x6a\xc3\x89\xa9\x8c\xf0\x11\x33\x33\x22\xbc\xbe\x03\x0c\xff\x27\xb0\xe2\xd3\xbd\x5e\x1d\xfe\xf9\x28\xad\x83\xbf\x7f\xfc\x31\xfe\x28\xaa\x2f\xe3\xd7\xbe\xc0\x93\xe4\x5e\x6a\xa6\x58\x77\xdf\x98\x4e\x84\xf2\xd5\xf6\x70\x10\x10\xb8\x56\xab\x52\x79\x4c\x36\x32\x8a\x53\x54\x24\xc0\xe0\x20\x68\xb3\xf0\x06\xdc\x17\x34\x04\x0d\x4a\xb7\xdd\x77\x19\xb4\x5d\x0c\xeb\x35\xca\x17\x41\x02\xa3\x10\xb1\xd0\xc6\x20\xbd\xd2\x5c\x1e\x43\x7e\x4a\x7d\xc9\x3e\xcc\xe2\x0a\xbb\x5c\x59\x0f\x8c\xad\xac\x33\xf9\x62\x95\xa8\x7b\x49\x23\x5e\xfd\xe9\x63\x83\x34\x7a\xd0\x0e\x16\xd2\xf8\x6d\xfe\x28\x59\x75\xe7\x4d\xa9\x0f\x82\xe1\x8a\x30\xf8\xa0\xe9\x81\x3b\x5b\x5a\x23\xd5\xa3\xbb\xe9\x91\xb3\x1f\x4c\x22\xa6\x7e\x8c\x58\xc4\xff\x43\xe5\x79\x05\x06\x46\x6f\x2e\xfc\xc7\x22\xe1\xb2\xe2\xf8\x7b\x5e\x1d\x04\xd0\xa3\x28\xe7\x9c\x87\x27\x88\x20\xe4\x99\xc5\xf4\x58\x10\x9b\x9c\x76\xb0\x10\xf1\xd4\x5e\xc2\x6e\xf7\xba\x78\x32\x14\x86\x00\x18\x74\xe9\x74\x2c\x6b\x51\x04\xbf\x0e\xb9\x62\x30\x0b\xe4\xcf\x20\xf1\x27\x9e\x46\xd2\x70\x3d\xfe\xc9\x4f\xcb\x11\x07\xc6\xdc\x17\x72\x4d\xc7\x9b\x4b\xb4\xe8\x40\x04\xbc\xb3\x79\xd1\xb4\x39\x0b\xea\x66\x6c\x5c\x35\xb2\x64\x6d\xcb\x77\xe8\xcc\x8d\xc3\x34\x98\x02\xd8\x91\x05\x83\x4b\x9f\x7c\xfa\x57\xc4\xa7\x3d\x8b\xda\x9b\x85\xf7\x85\x35\xd9\xe5\xfd\x93\x85\x73\xf5\x90\x95\xd7\x75\x9e\xc7\x07\xd6\x68\x98\x85\x3d\xfb\xb6\x92\x52\x3d\x00\xf1\x30\x0d\xf2\x60\xc1\xbc\x10\xff\x66\xa6\xcd\x1a\xa5\xaa\xac\xcc\xeb\xc5\xcd\x0e\x2e\xc8\xaa\x58\xce\x8c\x51\xe5\x31\x1e\x1e\x50\x5a\xed\xd1\x60\x58\x99\x12\x00\xca\x6b\x35\x5e\x81\x5c\x44\xe1\x59\x25\x44\xc5\x12\x79\x11\x63\x8f\xf6\x31\x63\x63\xc4\xaa\xb7\x31\x5f\xec\x66\x92\xa8\x00\x8e\xe8\x0f\xa0\x9b\x8e\xeb\x18\xdd\xa1\xbc\xa1\x5e\x62\x63\xfd\x69\xe5\x8d\xb3\x21\x1f\x7b\xe8\x4c\xdb\x3b\x12\x8f\x8f\x4b\x1c\x13\xdf\xac\x07\x55\x90\x93\x3d\xf5\xf5\x55\xcb\x21\x23\xf0\x40\xe6\x0b\x8f\x4a\x5c\x82\x23\x12\xd7\x52\xcf\x35\x5e\x4d\x3c\x27\x9e\x8f\x19\xab\x4c\xab\x48\x23\xa6\x36\xaa\x2d\x56\x9e\x30\x23\x3d\xd3\x83\xb6\x0b\x46\x52\x77\x59\xb4\x8d\x24\xd2\xb8\xe2\x1a\x9f\xce\x17\xc8\xd7\x9a\x79\x2c\x10\x0a\x88\x27\x40\x34\x08\xdf\x59\xb4\xbd\x6b\xe6\x85\x57\x84\x3f\xbf\xf6\x6d\xe1\xb3\x5f\x08\xff\xb3\x8c\x1e\xb9\x71\x98\x22\x15\xc0\x32\x3a\x95\xfc\x10\xe7\x1f\x7f\xf0\xc7\x82\x80\x4b\xc2\x46\xd8\x0c\x6d\xb5\x02\xd2\xe0\xc0\xba\xd3\x2e\xa5\xc1\xe0\xd0\x41\x6c\x36\x59\x68\x82\xb0\x68\x1c\x30\x1c\xd5\x73\x6a\xa5\x12\x77\x98\x0d\x36\x64\x03\x0a\x0a\xc3\x2f\x8b\x32\x15\xd5\x3f\x27\xd6\xb1\x83\xd3\xa4\x1a\xe4\xbf\x52\x73\x50\xb5\x84\xc6\xe7\x06\x22\x44\xd5\x9d\xfb\x1b\xa0\x6a\xc7\x22\x48\xb5\xef\x6a\x69\x89\x22\xd5\x5e\x4e\x45\x74\x63\x15\x5a\xbc\xb3\x4c\x12\x9b\x45\x3a\x33\x69\x0f\x09\x8c\x26\x85\x56\xab\x66\x75\x3a\x9b\x4d\x6d\x02\xa4\xd3\x62\x71\xa9\x55\xf0\x47\xc0\x66\xd2\x99\x21\x85\x17\xed\xd0\x88\x65\xd1\x15\x53\x7a\xfd\x1e\x57\xf4\x86\x48\x5a\xdb\x66\x0c\xa0\x3b\x5e\x4b\x52\xca\x3a\xa4\xd1\x9a\xf8\x6f\x47\x77\xdb\xa2\x6c\xfd\xd1\x07\x9a\x10\xa5\x61\xfc\x83\x86\xfd\x77\x25\xcb\xa3\x7e\x7c\x0e\x35\xb2\x6b\x18\x4f\xbe\x77\x5c\x01\xba\x16\xfd\x63\x21\x68\x62\xf7\xbd\xe2\xd1\x8d\xb6\xe8\x24\x9f\x77\x02\x8f\x12\x4f\x51\x0b\x30\x1f\x56\x97\x36\xd8\xdc\x06\xc2\x4d\xf8\x55\x0a\x45\xc0\x6d\xb3\x39\x1c\x2a\x06\xe1\x9e\x09\xfe\xb9\x76\xac\xbd\xa6\x3d\x29\x46\x8e\x63\x87\xa6\x14\x66\xd8\xa4\x4a\x2e\x37\x72\x63\x98\xfe\xf4\xc8\xf3\x3b\x3f\x3a\x76\x78\xaf\x27\x8a\x77\xef\x5a\xf9\xe4\xc2\x1d\x6b\x1a\x57\xf9\xc3\xc3\x14\x28\xa3\xfb\xe2\x53\x8f\xe1\xd1\xf3\x27\x8f\x7f\xb4\x23\x78\x7e\xa8\x75\xd3\xbb\x07\x6f\x3c\xec\x33\xbf\x8b\xe0\xe2\x0b\x97\x5f\xf4\x9b\xbf\x85\xf2\x7c\x44\x94\x67\x5f\xda\xab\xb0\xd9\x70\x8b\x4a\xa5\xc3\xc5\xd9\xa4\x36\xb3\x1e\xb7\x2a\x74\x2a\x96\xc0\x31\x82\x52\x28\x34\x10\xa5\x13\x18\x0f\xff\xaf\x36\x99\x5a\x43\x63\x11\xe6\x25\xc7\x14\xe6\xab\xab\x88\xeb\xe6\x8e\xc9\x5b\x9a\xe1\xef\x16\x6a\x64\xe7\x10\x09\x3a\xa9\x95\x29\xb0\x3d\x25\x7e\xb5\x62\xe7\x10\x25\x7c\x83\x5c\xd9\x2c\x1c\x68\x1e\x22\xf1\xa4\xa4\x9b\x1e\x9d\xf0\x3a\x68\x41\xbf\x43\x99\x42\xc2\x41\xbf\xf0\x94\xce\x2b\xca\x76\x1a\x9e\xc4\xed\x90\x76\x15\x16\x4b\xab\x30\x8a\x52\xa8\x15\x1a\x15\x4d\xb3\xe8\xdc\xe1\xb7\x84\x74\xee\xfa\x64\x7b\x3e\xab\x13\x25\x5a\x34\x10\x0d\x24\x86\x48\xe1\x1b\x88\x14\x0a\x74\x90\x2b\xf1\x21\x11\x49\xc5\x4f\x85\x7f\xff\x12\x3c\x82\x3f\x0c\xff\x7e\x03\x56\x86\xfe\x7e\x8d\x92\x52\xf2\x46\x28\x8f\xcb\xa0\xfd\x42\xde\x00\x6a\xc6\x18\xa4\xc4\x28\x5e\x98\xae\x9c\x02\xdf\x85\x87\x51\x47\xcd\x9f\x95\x78\x6b\x5a\xda\x16\x21\xd8\x1a\xeb\x0c\x23\xd2\x6e\xc8\x1a\x27\xfc\xc5\x79\x78\x40\xab\x5f\x8f\xf8\xe9\x81\x67\xf1\x1a\xfc\x3c\x1b\xd6\x9b\x76\x98\x95\x30\x20\x22\x2d\x38\x4e\x12\x2c\x47\xd9\x1d\xb8\xc5\x62\xd2\xe9\x14\x66\x8d\xcd\x00\x3f\xf8\x6b\x4a\x8e\xd3\x90\x0c\xa3\xc9\xf1\xa8\x87\xb1\x9e\x38\x1f\x2e\xef\x37\x4b\x90\x9a\x03\xd0\xf0\x99\x00\xc1\x8c\xdd\x0a\x47\xbc\x46\xcf\x13\x2e\x00\x75\x86\xfe\xda\xa7\x33\xea\xd6\xd3\xc2\x45\x7a\xf9\xae\x25\x34\xe8\xa4\x57\x34\x81\x13\x5d\x34\x35\x13\x52\xf9\x27\x61\x9a\xce\x0b\xee\x9d\x28\x7c\x58\x90\x0f\xfc\x9f\x7a\x20\x72\x60\x12\x76\xe0\xaf\x42\xba\x39\x2c\x9e\x56\x63\x0a\xa8\x2b\x94\x4e\xcf\x29\x95\x6a\x74\x10\x0a\x12\x63\x0a\x06\xa8\x2f\x91\x55\x1e\x0a\xe4\xd3\x88\xec\x19\x99\xdc\x19\x49\x8e\x3e\x27\xd1\x30\x8b\xde\x8d\x2f\x53\x9d\xfb\x4d\xfe\x48\xa4\xcf\x22\x0f\xc2\xcf\xb2\x42\x3f\x66\x27\x58\xab\x5e\xaf\x61\x09\x9b\x5d\xaf\x50\xa8\x2c\x06\x82\x65\x69\x95\x15\xc7\xb5\x2a\xf8\xc9\x97\x34\x00\x98\x68\xf9\xa3\x91\x12\xe4\x2e\x8b\x72\x17\xdd\xf9\x68\xb8\x78\x27\x4e\xd2\x08\x92\x79\x45\xc5\x71\xd3\xa1\x0d\x2b\x68\xe1\x4f\x22\x3d\xbf\xda\x01\x96\xfe\x05\xa1\x28\x2d\xbc\x48\xaf\x5d\x0f\x99\xbe\x38\x7a\x63\x4e\x20\xa3\xf7\xe2\x4b\x72\x2a\x8a\xef\x97\x6c\x7f\x32\x3c\xcf\xaf\x43\x5a\x8d\xd8\x94\x34\x6f\x50\x28\xb4\x0c\x86\x51\x5a\x8a\x27\x08\x13\x85\x71\x1c\xab\x47\x07\x89\xf0\xcb\x08\x63\xe1\x17\x21\xa1\x38\xd2\xa8\x76\xf9\xd4\xda\x93\xb9\x48\xa2\xc4\xa8\x64\x05\x0b\x14\xf6\xfb\x25\x8d\x04\xb7\x82\x06\x06\x7a\xe4\x40\x93\xf0\x3f\x5b\x46\x10\xbd\x23\x37\x2e\xa1\x7f\xfb\x27\x49\xc9\x46\xd5\xf8\xf7\x47\xe7\xe7\x09\x3d\x93\x3b\x33\x12\x13\xed\x7e\x46\xda\x53\x6a\xf7\x16\xa5\x12\x7e\xcd\x12\x04\x85\x10\x00\xd7\x50\x48\x98\x0a\xab\x95\xc7\x44\x61\xa2\x7c\x1e\x1a\x7f\x91\xdd\x97\x16\x4d\xe4\xd2\x62\x41\xc9\x52\xc5\xb6\x8f\x26\x07\x8d\x17\x85\x08\x3a\xe8\x91\x61\xf0\x3e\xb3\x44\xfc\x0a\x49\xf5\x1b\xf4\x8a\x25\x42\x94\x19\xa6\x0b\xb6\x3f\xfa\x16\x6e\x0a\x16\x8c\x1f\x9f\x30\xfa\xcb\x32\x68\xfd\x38\x76\x27\x1e\x21\x9e\x80\xb8\x8a\xee\x4c\x42\x69\x25\x66\x65\xf4\x56\xbd\xcb\x49\x98\xa4\x48\x52\x8b\x10\x15\xe9\x5b\xc9\xbd\x6c\x1e\x3e\xdb\x40\x1e\x57\xa5\x47\x1c\xc9\x9d\x43\x73\x4e\xcc\xdb\x36\x94\x3d\xb1\x48\x38\x7f\xfc\xc5\x4d\xdf\x3f\x70\xfc\xc5\x1d\xdf\x25\x43\xdb\xef\xdc\xf1\x8b\x0d\x5b\xee\xd8\xfc\x4b\x61\xe3\xa5\xdb\x6e\xff\xed\xbe\x4b\xb7\xdd\xf9\xe7\xad\xc8\x67\x8f\xc0\xcf\xf7\x52\xeb\x60\x1c\x59\x89\x4d\x4f\x47\x02\x56\x9f\xd3\x87\x57\x70\x4e\x53\x84\x65\x29\x83\x89\xa3\x12\x38\x5e\x65\xb3\x5a\x61\x4a\x59\xee\xa6\x60\xc0\xef\x76\x63\x41\x68\x10\x88\xac\xd7\x1b\x13\x86\x62\xdf\x33\xc6\x19\x49\x17\xf0\xe6\x7f\x57\xac\x96\xe7\x99\xcb\xb3\x07\x20\x4b\x78\xc7\xcf\x6e\x18\x99\xbd\x64\xd6\x99\xf5\x47\x4e\xdf\xb5\x69\xfc\x8c\x07\xf7\xb0\xb3\xbb\xee\x58\xb8\x6a\xed\x57\x36\xee\x58\x38\xf3\x2f\x8b\xa8\x75\xba\x73\x7d\x5b\xcd\xca\x6c\xd7\xb4\x2d\xe3\x86\xe7\x0c\xdf\xa4\xd6\x64\xda\x66\x6f\x22\xab\xb4\xb3\x26\xec\x18\x19\x59\x61\x1a\xb5\xaf\x5a\x31\x6e\xf2\xf7\xba\xa6\x42\xde\xa6\x42\xbd\xf5\x42\xdd\x60\xa0\x95\xd5\xa7\x79\x06\x6a\xae\xd6\x86\x9b\x4c\x76\x85\x96\xd5\x42\x55\xe5\x68\x3d\x0a\x4c\xd4\x72\x00\x2c\x47\xeb\xf9\xac\x4d\x0a\x0d\xe5\x80\xb0\x80\x37\x52\x01\x07\x7c\xf3\xe3\x99\xb3\xb3\xe3\x94\x89\xfd\xb4\x70\x8e\x5e\x24\x42\xcd\xfe\x43\x4f\x3d\x4a\x3c\xfa\xc3\x99\x19\xe1\xa6\x7a\xe1\xef\x39\x45\x5d\xbd\xec\xc0\x11\xe9\x2e\x1e\xd1\x13\x83\xf4\xa0\xde\x87\x9e\xb4\xdd\x09\x00\xcd\x73\x46\x9d\x55\xa3\xd1\x71\x34\xe9\x72\x73\x68\x63\x36\xe9\x60\x14\xc8\x9e\x74\x46\x23\x09\x68\x9a\x2c\x00\xa3\x3e\x17\xf8\x19\xc6\x8e\x76\x95\xb7\x29\x17\xe8\x63\x8c\x08\x24\x23\x72\x9f\x03\x18\xac\x5f\x49\x0b\xaf\x48\x54\xb6\xdf\x7c\xf0\xfb\x07\x67\xd3\x97\x8f\x99\x57\x6e\x7d\x22\xdb\x42\x1c\x15\xfe\x2b\x47\xe9\x92\x79\x2f\xd7\x08\xdf\x80\x08\xb9\xb0\x7e\xe9\xa2\x3b\x05\x71\xef\xda\xc3\x90\xe6\x09\xa2\xed\x37\xa7\x8d\x34\xab\xc7\x59\x9c\xd7\x28\x95\x26\x35\xcb\x2a\x74\x24\x89\x48\xbd\xa8\x17\x67\x05\xb5\x89\xf7\x17\xed\x45\xca\x50\xf0\xfe\xc6\x5c\xed\x33\x1f\x45\x59\x98\x2b\xf4\xbe\x9d\xee\x35\x9d\x11\x18\x7b\xec\xf5\x97\xd1\x4d\x9b\x5d\x3b\x6f\x94\x2c\xe6\x15\xf5\x8d\x2f\xbd\x74\xa3\x6a\xb4\x43\xf6\x8f\xaf\xe1\x11\x52\x09\x69\x70\x62\x8d\x69\x9e\xb7\x58\x38\x35\x46\xa9\x29\x17\x41\xb8\x79\x84\x3f\xb8\x1e\xf9\x73\x1b\xa6\x90\x6d\x65\xac\x13\x2f\x86\x9b\xfc\x20\xc5\x92\x32\x28\x31\x38\x42\x03\x3d\xb5\x62\xc0\xf6\xb5\x23\xb7\xdf\x45\xcf\x84\x7e\xae\x83\x5a\x31\x83\xbe\xb4\xe1\x6e\x9d\xec\xe0\xbc\x07\x4f\xae\x5b\xe5\x08\x82\x5f\x89\xdf\xb9\x7d\xce\x07\x36\x2c\x45\xb4\x3d\x82\x7b\xc9\x27\xc5\x33\x9d\x9a\xf6\x70\xbc\x92\xa2\x54\xb8\x96\x87\x96\x63\x30\xf3\x1c\xa7\xc4\xd5\x30\xdc\xa4\x28\x06\xe6\x63\x80\xbc\x02\x09\xd4\x63\x4c\x2e\x86\xd7\x97\xfe\x03\x8a\x06\xbd\x23\x24\x0f\xe4\x66\xd7\x27\xd1\x48\x3c\x08\xe6\xf8\xe7\xe1\x59\x5f\x44\x36\x8d\xa7\x80\x95\x5a\x34\x80\x5d\x73\xce\xf9\x62\x88\xfe\x84\xee\xc2\xbd\xb8\x7d\xf4\xd7\x04\x23\xc2\xcb\xf7\xf0\xe8\xe8\xfb\x78\x8d\xe4\x66\xa0\xce\x6d\xc1\xc3\xf8\xad\xe4\x26\xf8\xb9\x2e\x2c\x95\xd6\x58\x15\xa4\xc1\xa0\x57\xe8\xdd\x1e\x93\x0e\xfa\xdc\x96\x8b\xa4\xc3\x41\x23\xba\x60\x6e\x22\x27\xad\x12\x62\x97\x5c\x6f\xa0\x98\x8d\xce\x37\xf0\x5a\x60\x00\x9c\xbb\x1b\x85\x61\x01\x1e\x1b\x47\x3e\xa1\x5f\x32\xd0\x35\x7b\xf6\xbd\x73\xbb\x3a\x1c\xde\x75\x96\x88\x77\xf0\xc6\xba\xf8\x84\x5e\x7c\x1e\xe7\x98\xb7\x62\xe5\xbc\xe5\x17\x57\xda\x4c\x5d\x3a\xcd\xeb\xfb\xd3\xd3\x06\x24\x5b\xd8\x83\x07\xf1\xbb\xc8\x0d\xd0\xd7\x3a\xb1\xd6\xb4\x5a\x47\xa8\xd5\x5a\x33\xa3\x65\x5c\x6e\x2d\x4a\x75\x8c\x98\x12\xb4\x5f\x24\xac\x56\x18\xab\xb5\xc0\x3f\x04\x40\x73\x9e\xb8\xe2\x0d\x83\x52\x23\x88\x49\x7a\x09\x22\x0e\x36\x72\x00\xf9\x0a\x4c\xec\x93\x3f\x45\x3d\x30\x30\xf8\xd8\xa3\xfb\x16\x3a\xd4\xc3\xf3\x2a\xab\x63\xb3\x96\x0f\x75\x76\x9b\x4c\xe4\x54\x47\xc7\xb4\xff\x38\xff\x41\xa6\x03\x57\x08\xf7\xb7\x75\xbd\x76\xfc\xb6\xb6\x6d\x3b\x24\x79\x45\xf0\x5b\xc8\x1b\x72\x74\x99\x19\x91\x32\x46\xeb\x72\x6b\xae\x40\x1a\x10\x5d\x2d\x32\x5d\xed\xf0\x0f\xe1\x45\x42\x2b\xd0\x25\x49\x4d\x12\x9a\x58\x8d\x82\x22\x53\x01\x79\xb2\x8e\x38\xf3\x1c\x5f\x43\x7e\x05\x0c\xcc\x7b\xf4\xcc\x9e\x05\x90\xb2\xc1\x44\x75\xf9\xcc\x91\xa1\x8e\x69\x41\x0a\xef\x41\x94\x9d\xf9\x59\xa6\x63\xf4\x53\x30\xd4\xd6\xf5\xca\xc9\xdb\xda\xbe\xd5\x21\xe5\x8e\x6b\xf0\x30\x31\x1f\xd2\xe6\x81\x58\x5d\x0f\xfd\x9d\x37\x81\x85\x1d\x7e\x1d\x15\x0c\xea\x1c\x0a\x8c\x4a\x55\x98\x4c\x0d\xd1\xea\x6a\x17\x51\xab\xab\x75\x10\x1a\x9b\x0b\xd1\xe8\x85\x09\x70\xcb\x05\x05\x8a\xb0\x5a\xc4\xc4\x2b\xd9\x5e\xb4\xc2\xeb\xba\x85\x5e\xc6\x5c\xb7\xb6\xfc\x34\xd0\x92\xab\xa5\x41\xe1\x4a\x1d\x64\x68\x10\x20\x63\x96\xfb\x06\x00\x2f\xf5\x8f\xad\x79\xe6\x18\xb9\xa6\x6b\x86\xbe\x73\x49\x65\x4b\xb7\x6d\xc5\x40\x3a\x33\xfb\xd4\xdc\xc9\xad\x0d\x33\x26\x74\xe3\x15\xf5\x93\xa9\x65\x50\x0c\x8b\x9a\x6b\x05\x73\x53\x6d\xc6\x3a\xbc\x01\xbf\x77\x60\xb3\xda\x1f\xdc\xdd\x62\x4b\x95\xc7\x53\x4b\xd6\x67\x97\x3f\xb7\xac\x22\xde\x0e\xde\x18\xc7\x07\x9f\xbc\x29\xba\xf0\xfe\x69\x93\xc6\x09\x6b\xc7\x6f\xdd\xa5\x58\x20\xea\x4a\x04\xbf\x9b\x3a\x00\x75\xd8\x89\x74\x98\x26\xa0\x0a\xeb\x5d\xd0\xd1\xbb\x79\x0e\x7a\xa2\x8b\xb4\xdd\xce\x22\x35\x81\xe7\x07\x2a\xf2\xc7\x51\x84\xe3\x92\xfd\xa3\xa5\xd5\x45\xdc\xa4\xf2\x33\x6f\x18\xa0\xc8\x50\x97\xe2\x5a\xc5\xc8\xac\x29\x73\xb2\xf7\xcd\x5f\x9b\x59\x16\x68\x9d\xbf\x2f\x95\xe8\x9a\x4e\xcd\xd3\x3a\x84\xcf\xfa\x02\x2b\xa1\x12\x3f\x37\x52\x63\x77\xbd\x76\xd3\xf8\xc9\xd3\x65\xbb\x7a\x11\xd2\xc4\x43\x01\x8f\x4b\x73\x0e\x8e\xf3\x51\x26\x25\x86\xe3\x14\xe5\xb7\x18\x91\x65\x29\xdd\x6e\xf5\xcb\xf0\x00\x68\x08\x4c\x30\x24\xc2\x48\x99\xb6\x22\xea\xf4\xd2\x0e\x4a\x51\x5b\xda\x45\x0a\xc7\x58\x5a\xc1\xd3\xa7\xf0\x08\xe3\x1f\x24\x5f\xbd\x23\x67\x6c\xd9\x53\x73\x5b\x6c\xf1\xda\xa6\x45\xcd\x75\x15\x93\x7a\xc8\x65\x55\x6f\x6a\x1d\x57\xdf\x17\xed\x6d\xe1\xb2\x4b\xcb\xbb\xdd\x73\xef\xcf\x88\xd6\x86\x63\x5b\xa1\xfc\x66\x41\xbd\x41\x3d\x08\xc9\xb4\xce\x4c\x72\x9c\xc2\x63\xc3\x30\x2f\x61\x36\xab\x9d\x88\xd8\x0b\x2c\x2d\xfb\x74\xb9\x4e\x52\x80\x6f\xa9\xb6\xcd\x89\xcb\x0a\x2c\xf9\x7b\x77\x28\x46\x2a\x37\x18\x1d\x9f\xf5\x9d\x73\xf8\xee\xfe\xa5\x86\xba\x9d\x0d\xcb\x86\x66\x1d\xeb\x9b\x36\x53\xb8\x7b\xc7\xa1\x60\xa0\x7d\x15\xf1\x79\xdf\x46\x75\xec\x34\x22\x74\xdd\xe2\xa1\x0b\xcb\x26\xfe\x4c\xb1\xa0\xd3\x1f\xbb\x5b\xc2\x80\x35\x90\xae\x69\x90\x2e\x33\xd4\x68\x48\x97\x1d\xc3\x94\x5e\x0b\xa9\xd3\xc1\xbc\xca\xa2\x71\xf1\x28\x3d\x51\xd0\x05\xbd\xcd\xd3\x95\x94\x2f\xc2\x8d\x68\x9a\x40\x6d\xe9\x33\x56\x74\x1d\x91\xcb\x2d\xd7\x7c\xe7\x2c\xb1\xbb\x7e\x6e\x54\xdf\xb0\xa3\x7e\xe9\xf0\xac\x63\xfd\xd3\x66\x80\x35\x3b\x0f\x85\x20\x61\xf8\xc3\xfd\x1b\x55\xb1\xd3\x21\x8b\x2d\x51\xb3\x6e\xf1\xf0\xd3\x23\x05\xca\x00\xb6\x12\xd2\x55\x0b\xe9\x8a\x61\xed\x69\x6b\x88\xb4\xa9\x30\x37\xa3\x22\xa9\x0a\xa3\x4e\x17\x67\xfc\x7e\x87\x03\x37\x1b\xb4\x48\x6a\xb1\x28\x9e\x97\x9a\xa8\x6a\x86\xc6\x62\x8b\x82\x92\x93\x00\x20\x55\x27\x5f\xb0\x16\x0d\x70\xb5\xd4\x37\x43\x84\x48\x14\x66\xb8\x82\xcf\x16\x6f\xbb\x30\x77\x52\x79\xe2\xf0\x50\x7f\xda\xec\x32\xab\xaa\xec\x8d\x13\x1a\x27\x46\x38\x15\x57\xd3\x99\x4c\x35\xa7\xea\xa7\xba\xf0\xdd\xb3\x6f\x4d\x0f\x6b\x49\x6d\x75\xbc\x6b\xae\xf9\x86\xf1\x0a\x6e\x5c\xaa\x83\x67\x9a\x08\x8a\x9b\x50\x55\x91\xf2\xf3\x52\xff\x1a\xa4\x5f\x07\xe9\x8f\x40\x9f\x6d\xc6\x5c\x2e\x1b\xa5\xf7\x53\x51\x95\xc5\x52\x66\x27\x60\x6a\xc1\x87\x02\x5e\x24\x5b\xbd\x86\xcf\xcb\xf6\x3a\xea\xc5\x38\x33\x22\x16\x10\xd0\x39\x17\xdf\x06\x30\x26\xf9\xe2\x47\x32\x21\xb0\x3f\x60\xbf\xdd\xa8\x34\x1e\x28\xab\x1b\xae\x4b\xf8\x7d\x96\xe9\x9d\xc3\xc3\xb7\x54\xd7\xed\xd9\xba\x24\x63\xe8\x9a\xd3\xd1\x8d\xff\x24\x52\xcf\x32\x4d\xac\x6a\x5c\xd5\x1c\x67\xc7\x76\x63\x57\xfb\xf2\x18\xa9\x49\x97\xcd\x59\xd8\x14\xf0\x35\x43\x3d\x98\x0e\x2a\xf1\xa3\xd0\x47\xa9\xb0\x30\xf4\xf0\x9c\xdf\xa3\x30\x78\x0c\x11\x35\x44\xd9\x68\xd0\xeb\xbc\x02\x5a\xa1\x0d\x99\xa1\xb8\xd5\x18\x97\x17\x77\x7b\xb2\x58\x17\xa4\x50\x0d\x7a\x75\xf9\x66\x3b\x55\xa4\xa8\xa5\x7b\x92\x52\xa0\x7b\xd2\x40\xa7\xdd\x57\x3e\xb8\xb7\xfa\xad\xc8\x9a\x58\xf7\xec\xb9\x0f\xcc\xed\xde\x3a\x6c\xda\xb3\xa7\x7e\x75\x50\xe9\x30\x57\xcf\x39\x6e\xc3\xd7\x0f\x80\x0d\xb4\xe2\x8d\xfd\x2d\x7d\xfe\x78\x7a\xc5\x7c\x68\xfa\xd6\xd1\x57\x77\x6e\xb2\x1a\x6e\xed\x4e\x3c\x28\xea\xee\x7a\xd0\x0c\xe6\x91\xcb\xc4\x3e\xba\x78\x5a\x2b\xf7\xd1\xc1\x8c\x48\xa5\x27\x19\xe4\xc1\x10\x18\x49\x3e\xeb\xf5\x9a\xa2\x60\x04\x6a\xad\x6c\xe7\x25\x63\x4d\x17\x50\x6f\x0c\x4e\xa3\x2e\x86\xc2\x0e\x7b\x24\x62\x77\x84\xc9\x56\xce\x31\xfa\x29\xe7\xb8\xec\x08\x87\x1d\xf0\x5f\xe9\xbd\x3f\x4c\xd5\x6e\x82\x98\x63\xc4\xba\xd2\x36\xe8\xc7\x8d\x9c\x9a\x82\xd9\xa9\x4a\x67\xa4\x78\x96\x35\xa9\x39\x0e\x7e\xb6\x11\xd5\xb5\x50\xc8\xf1\x22\xfc\x78\x11\x0f\x45\xc0\x91\x32\xea\x31\x21\xba\x0c\x8b\x21\x14\x5e\xe0\x62\xc8\x08\x4f\x19\x50\x7d\xd4\xd7\x96\x01\xac\x81\x7a\x8a\xac\x7e\xe6\xee\x26\xf2\xc8\xbe\x6c\x68\x18\x01\xe1\xe8\x4b\xff\xd4\x39\x1c\xda\x73\xc2\x5b\x5a\x07\xf0\x4c\xff\x2e\xa2\x69\x17\x8c\x0f\x8f\x41\x5d\x43\x77\x8c\x4e\xcc\x6a\x75\xda\x6c\xea\xa8\xdf\x1f\x50\x1b\xe8\x00\x5d\xa9\x54\x26\xb0\x68\x94\x77\xbb\x89\xd8\x8b\x50\xd5\xc2\xa0\xf9\x92\x42\xad\xb6\x05\x0a\xd9\xac\x9c\x1d\x16\xe2\x35\x91\xb0\xfc\x0d\x00\xc8\x0d\x4d\x41\x12\x33\xa2\xe7\xc3\xc8\xdc\x73\x53\xa2\x69\x69\x48\x74\x52\x1a\x12\x8d\xcf\x8b\x2f\xad\x48\x36\x32\xcd\x3d\xd4\xa5\x56\x9c\x22\x89\xda\xd8\x46\xa6\x79\xa8\x95\x4b\x55\x6c\x62\x9a\x87\x07\x27\x51\x67\xf5\xe5\xcb\x2b\xeb\x9a\x88\xbf\xb6\x4d\x48\xb7\xea\xea\x85\x27\x38\x07\x98\xa7\x71\x39\x2c\x4c\xcb\xc6\x2a\xe1\x2c\x98\xd7\x63\x6a\x59\x5f\x23\x9c\xc5\x15\x9c\x63\x53\x73\x57\x27\xe2\x0f\xea\xe6\x76\xc8\x9f\x0f\x9b\x90\xe6\x95\x0c\xc3\xb9\xad\x56\x9b\xcd\xcf\x19\x0c\x04\x16\x70\xf3\xbc\xf7\x25\xc8\x97\x13\x8a\xda\x06\xda\x2e\xa8\x59\x98\x63\xb6\x4a\xe5\x4d\xb9\x58\x23\xde\x1a\x37\xe6\x78\x12\xfb\xb5\x88\xa2\x6d\x4e\xa9\x31\x8c\x40\x95\xc0\xb7\x73\x9d\x65\x8f\x25\x2b\x8c\x4e\x85\xce\x11\xad\xd0\x4e\xd2\xb6\x54\x8c\xf8\x3b\x87\xe6\x4e\x24\xcf\xea\x16\xaf\xdb\x4e\x7c\x6a\xed\x13\x8e\xfc\xd1\xb0\xae\x53\x37\xad\x1f\x1c\xed\x33\xb4\x4e\x4b\x09\xb7\xe0\x4a\xce\xb1\x71\x2f\x86\xe5\x62\x98\xa3\x90\x66\x15\x0c\x8a\x51\x4e\xc9\x71\x76\xda\x6c\x76\xb0\x46\xe4\x24\x09\x98\xef\xc8\x39\x65\xe1\x7a\xca\x98\x8f\x99\xb4\xc0\x58\x92\x51\xfe\x4f\x5b\xe3\xc0\xee\xed\xf5\x8b\x1a\x37\x0c\x6f\x19\x38\x3a\x07\xfd\x82\x5f\xeb\x9b\xf9\xf2\xc1\x73\x33\x4f\x0a\xdf\xdb\xbb\x72\xd1\x63\x83\xe2\x2f\xe2\x5c\x20\xf8\xb9\x3d\xf0\x73\xed\x58\x0c\x46\x74\x1a\x98\xd2\x9a\x69\xda\x69\xd0\x2a\x11\xda\xd8\xad\x44\x01\x6d\x0a\xee\x05\x35\x08\x15\x61\x77\xfe\x1a\x4f\x0c\x41\x1e\xad\xde\x9a\x9a\xbf\x2a\x7b\x72\x7a\x64\xc8\xeb\xf0\x29\xc3\x6d\x8d\x4b\x9b\x77\xcc\x98\x4f\xf2\xf1\xda\x35\xc3\x2b\x9f\x1c\x36\xaa\xef\x5f\x1e\x9e\x79\x62\xf0\x74\x8b\x68\x1f\x3b\x88\x1e\x91\x6f\x1d\xe6\x83\x9f\x8f\x61\x7a\x15\x4d\x1b\x14\x98\x46\xfe\x60\xc9\x0e\x73\x1c\xe7\x26\x8a\x07\xe4\x03\xd8\xa1\x7f\xfa\xc6\xe1\x2d\xe4\x2a\x66\xfb\xc4\x0d\x06\xa2\x67\xef\x99\xbd\x2b\x3d\x4e\x5f\xe2\xdc\xad\xd2\x6c\x09\x24\xd3\x3b\x88\x1e\xe9\xef\xc6\xa1\xa5\xb1\x0a\x85\x81\xd5\x51\xb9\x54\xb8\xe4\xef\x2e\xb4\x23\x89\x30\x94\xfa\x35\xdd\xd6\xd8\xb5\x51\xbf\xca\xf8\xd4\x4e\xf8\x11\x44\x4f\xb8\xac\x6f\xe6\x6d\x2b\xf6\x3d\xb6\x77\x65\x33\x3a\x2f\x25\xd4\xb1\xbb\x45\x3f\x18\x40\xb1\x84\x45\x8d\xe3\x0c\x13\x74\xe9\xf5\x21\xb5\xd7\x8b\x1c\xcd\x73\x36\x93\x89\x62\xa1\x18\x9b\x2f\xc2\xff\x22\xeb\x98\x5e\x76\x89\xed\xa5\x39\x2b\xfa\x7c\xae\x50\x06\x2a\x8e\x78\xcc\xf9\x66\x4f\x9a\xf9\xa9\xc2\xb1\x90\x12\xfe\x4e\x75\xdd\xd4\x46\x3d\xa0\x5a\x3e\x63\xf2\xac\x39\xa7\xe7\x76\x9a\xc2\xed\x2d\x43\xa9\xba\xb8\x77\x20\x88\xd7\x8e\x3b\xa5\x75\x3a\xb5\xf8\x2f\x39\xc7\x5c\x14\xc3\x5f\x5e\xda\xed\x9a\x77\xaa\x6f\xdc\x94\x78\x18\xca\xe3\x20\x1e\x01\xdf\x20\x7f\x0d\x35\xac\x2e\xad\xe7\x91\xac\x29\x95\xc9\x6e\x72\x68\x2d\x16\x83\x1e\xfa\x95\xe6\x0b\x14\xda\xbd\x2d\xa3\xf5\xdb\x63\x2c\x5c\xd6\xb8\x94\x25\xd7\x15\x11\x68\xc7\x93\xe8\xae\x82\xa0\xff\xec\x30\x95\x57\x6b\x26\x77\x27\x93\x64\xc7\x14\xaa\xb7\x3f\x62\xde\xa3\xd8\xdb\xa4\xc2\xef\x75\x38\x0c\xce\xda\xd6\x2a\x5d\x39\x58\xea\xb0\xec\xd9\x53\x23\x7c\x2d\x25\xce\x8b\x08\xe1\x87\xc9\xa5\x30\xc3\x6f\x48\x73\x66\x0c\xd3\xe9\x18\x9b\x9a\xa6\x19\xc6\x4e\x9b\x90\xbc\xa0\x2c\xb5\x2f\x42\x32\x54\x52\x92\x5f\x14\x7a\xe5\x1b\xae\x8d\xbc\x3c\x65\xdf\x92\x8f\xd8\x45\x8c\xa6\xff\xd6\x1c\x5b\x1a\x1e\x37\x04\x81\xe3\x8c\x6e\x78\xcd\x76\xaa\x7d\x1c\x75\xae\x55\x83\x9f\x6d\x9d\xd4\x04\x76\x20\x74\xde\xb4\x6f\x17\x1b\x01\x2b\x61\x88\xf8\xe8\x00\xda\x03\x80\x4f\xc2\xdf\x22\xc7\x61\x0e\xac\x2d\xed\x82\x4a\xa0\x86\x67\xa6\xa4\x4c\x84\x13\xd7\x6a\x5d\xac\x0a\x6a\xa3\x82\x31\x9a\xcd\x18\x8f\x46\xd7\x16\xf7\x94\x94\x44\xe1\xb9\xaa\x83\xd4\x3d\x61\x8a\xc0\xd3\x93\x7a\x2c\xea\x28\x37\x81\x4f\x68\x99\xd4\x24\x1c\x10\x01\x6a\xdf\x2e\x85\x47\x38\xc2\xd9\xc1\x20\x82\x30\xfc\x89\x96\xf2\x65\xa1\x71\x12\x4c\x0c\xad\xdd\x4e\xa6\x3b\xc9\xc7\x45\x18\x94\xe7\x6a\x84\x88\xd3\x50\x4e\x65\xd8\x6c\x18\x13\x98\x4c\x36\x18\xfa\x85\x3c\x1e\x2f\x74\x1a\x34\x5d\xee\xf5\xc6\x7c\x41\xe4\x38\x3c\x26\x85\x0a\x8a\x2d\xad\xc0\x42\x21\x87\x43\xaf\x8f\x12\xf2\x19\xe6\x0b\x10\xb2\x00\x0b\x85\x9f\x02\x56\xe7\x2a\x3c\x92\xf4\x4c\x39\xb1\x16\xbe\x42\x02\x46\x7f\x08\x5c\xa9\x5c\x56\x9e\x6c\x22\x3a\x44\x81\x26\x63\xeb\x15\xcd\xc3\x6d\x5c\x2a\xb6\x41\x29\xc2\xf4\x19\x5d\xe5\xd2\x8a\xb5\xf8\xd9\x74\x67\x7b\xab\xd2\x05\x6e\x80\xf2\x7d\x64\x80\x6b\x59\x5b\x0b\xb2\xc2\x23\x10\xa2\xd7\xd4\x81\xac\x28\xfe\x74\xa7\xc8\xdb\x10\xb4\xcd\x0d\x90\x37\x54\xdf\x56\x73\x6a\x9d\xda\x88\x31\x0c\xaf\x26\xb5\x28\x63\xd3\xc1\xa3\xcf\xd5\x05\x8a\x50\x07\xe4\xd6\xa5\x41\xe4\x95\x56\xa8\xd5\xe3\xbc\x5d\x4b\x6d\xe0\xaa\x85\xd8\x86\x71\xd4\xe9\x99\x27\xc2\xa4\xd9\x62\x27\x1d\x9c\xa5\xae\x47\x58\x81\x9b\x38\x87\x30\xe5\x6f\x6d\xd2\x7b\xb3\x30\x7e\x11\xda\x6b\x18\xeb\x4c\xf3\x6a\x85\x3f\x18\xb4\x39\x09\xbd\x51\xc1\x44\xa2\xf0\x77\x3d\x63\x86\x26\x9b\x56\x78\xb5\x5a\x26\xa0\x54\xa2\xaa\x71\xb1\x04\xc7\xb6\x30\x00\x7f\x69\x07\x43\x7d\xd1\x30\xe0\xa2\xfe\x05\x7c\xfc\xea\x6a\xce\x17\xee\x6b\xaf\x8e\x98\x9d\x2a\x9d\xb3\x66\x5c\x62\xce\xea\x9e\x29\xb3\xa6\xac\x56\xd9\x52\x65\x76\x53\xd0\x69\x2e\xc7\xc3\x83\xae\x60\x79\x4c\xb3\x75\x9c\xba\xac\x79\xe7\xfa\xe9\x37\x64\x27\x37\x6c\x1d\xe2\xab\x3d\xea\x71\xdb\x55\x68\x0f\x18\xc4\x99\x8b\xd4\x51\x98\xb3\x20\xca\xf5\x36\x9d\x4e\xef\x56\xa2\x57\xfe\x64\x24\x48\x10\x51\x3d\xc4\x95\xe7\x19\x9f\xcf\xeb\x75\x68\x50\xe6\x88\xee\x73\xe2\xd2\x0d\x09\x12\x5b\xfb\x75\xad\x6d\xc5\xeb\x82\x20\xfd\xd0\x85\xb5\x01\x0b\xf2\x65\x92\x33\x89\x48\x4f\x32\xc1\xff\xce\x5a\xbe\x3c\x03\x5a\xfa\x4e\xef\x5d\xd8\x58\x33\x74\x97\xe3\xd0\xb6\xfe\x5e\xfb\xac\xba\xde\xd9\xcb\x4e\xb3\x0b\x96\xd6\x50\x47\xe7\xf6\x2f\xd8\xc9\xd1\x9a\xc1\x9e\xbd\xf7\x78\x85\xdf\x10\x8d\xa7\xef\xae\x5a\x77\x87\xc0\x3b\x77\xae\xbe\x9b\x4e\xe0\x9b\x97\xa7\xe4\xf7\x03\xcb\x21\xfd\x19\x78\xce\x0e\x14\xd7\xe2\x0e\xde\x6c\xd3\x93\xa4\xd9\x41\x38\x59\x74\xcb\x43\xea\xf5\xc0\x84\x82\x45\x55\xae\x5a\x20\x89\xba\x78\xab\xa8\xfc\x70\xc4\x6c\x49\xa6\x44\x02\x93\x62\x68\x81\x06\xd0\xc2\x0c\x02\xa6\x58\xcb\xa9\x5d\x09\x17\xb5\xb7\xd9\x47\xad\x27\x6a\x7e\x82\xdb\x75\xf3\x6d\x6c\xd4\x16\x6a\x26\xa7\x3a\xde\xbc\xf6\xa7\x15\x61\x8f\xda\x41\x1b\x3c\x43\xc2\xe6\xb2\x27\x1b\x68\x7d\xf4\xb6\x34\xe8\xfc\x0f\xc9\xe7\x6e\x86\x3a\x78\x1f\x75\x1b\xe6\x12\xbb\x5a\xac\x11\xc2\x14\xa4\xfd\xac\x1f\x66\xa6\x04\x51\x0e\x7d\x61\x8c\x0e\x06\x0d\x9c\xea\x0a\x0c\xc8\xdc\xf9\x7b\x32\x24\xd8\xe2\x2b\x76\x31\x46\xcb\xbd\x22\x96\xf5\x00\xa5\x0c\x72\x54\x6b\x11\x81\x3c\x22\x82\x78\x44\xcc\x1b\x40\xcf\x92\x8d\x47\x0e\xce\x5a\xb7\x7c\xc2\x14\x93\x53\xe3\x6c\xad\x4d\x97\x8f\x5f\x33\x69\x6f\x7f\x6d\x4f\xc5\xcc\xa1\x55\xad\x78\x64\xe3\x92\x8d\x0f\x47\xe7\xcf\x98\xda\x6f\xd9\xdc\xe1\xac\xae\xf1\x4e\x1c\xbf\x6e\xef\xf4\x3b\x07\x12\xe9\x3d\x93\xd6\x65\xbc\x67\x96\x4d\xed\x45\xf1\x02\x94\xeb\xfb\xe4\x66\xf1\x4e\xba\x3b\xcd\x3b\xa1\xf1\xb0\x1c\xeb\x31\x78\x08\x83\x4a\xe5\x23\x08\x3f\x87\x9c\xd0\x25\x27\xcf\xd3\x8a\xaf\x43\xd2\x59\x28\x64\x2b\x64\xa2\x05\x31\x21\x5f\x4a\x14\x61\x42\x01\xe4\x73\x1a\x22\x4e\xf7\xad\x47\xe9\x23\xea\xdf\x90\x95\x04\x71\x81\xa7\x26\x65\x1f\x7d\xb8\x22\x1d\xff\xf0\xb6\xf5\xaa\xae\x19\x5b\xd3\xfa\x69\x29\x5f\x58\xdb\xb1\x74\x0d\xb9\x79\xf1\xf2\x4b\x6f\x2a\xbe\xf8\xc2\xf8\xa3\x3b\xaf\x70\x21\xfb\xd3\x3b\x4e\x99\xc1\x9a\x79\x33\xaa\x1b\xbb\x84\xa3\xcc\x37\x1e\xdb\x8f\x66\x23\x42\xba\x6f\x81\xfa\xe0\xc2\xfa\xd3\x7e\x9b\xce\xa1\xc6\x14\x2a\x95\x9a\x06\xa4\x99\x27\x79\xa7\x5a\xed\x71\x38\x9d\x6e\xde\x6c\x56\x60\x3a\x1b\x49\x39\x25\xdd\xa0\x64\xdd\xb0\xe4\x6b\xbd\xfa\xe2\x4a\xa1\xbe\xb1\x51\x2e\x5c\x13\x95\x40\xdc\xe9\x60\xa9\x47\x8d\x27\x1c\x30\xba\x51\x1d\x2c\x1c\x21\xd0\xd3\x59\x10\x99\xc5\x78\xfd\xd4\x1a\x56\xdb\x39\x7f\x78\x23\xd9\x70\x4f\xc7\xb0\xc2\xce\x53\x83\x4a\xfd\xd4\xa3\xd3\xd7\x13\xf8\xa7\x00\xbd\x7a\x74\x50\xe5\xd7\x0e\x9e\xb1\x4c\xfd\x60\x9e\xf0\x8c\xcb\x44\x38\x14\x6d\xc0\xf6\xde\x6d\x3c\xd2\x17\xea\x5a\x37\xf6\x17\x7c\xab\x98\x3f\x40\xd4\xc2\x08\x56\x4b\x68\x79\x94\x3d\xd0\x57\xc0\x04\xb1\x1c\xd7\x95\xcb\x1e\x0a\xb5\x7f\x0f\x4c\x19\x11\xba\xa6\x8a\xa6\x24\xae\x9b\x4f\xbd\x3e\x38\x8d\xbc\x14\x8a\x38\xec\xe1\xb0\xdd\x11\x39\xc4\x39\x90\x7f\xb8\x2c\x65\x12\x61\x4c\x7e\x2f\xd2\x0d\x1e\x06\x47\x30\x3d\x56\x93\x56\x53\x38\x6e\x54\x72\x0a\x85\x52\x69\xd0\xbc\x08\x3f\x4d\x09\xba\x2e\x72\x14\x89\x5d\x06\x13\xd1\xbd\x08\x3c\xd4\x62\x1f\x89\xce\x11\x69\x61\x71\xb8\x0d\x36\xba\xf5\x76\xbb\x25\xb1\xbc\x3c\x8d\x3c\xce\x19\x43\xd5\x3a\x70\x84\x3a\xda\x3d\xb9\x45\xb8\x03\x7d\xf8\xee\xc9\x13\xa4\xcf\x15\xae\xb5\x81\xcf\xc1\x6e\xa8\x2f\x8d\x69\xad\xe4\x98\xcd\x18\x4c\xa4\x6d\xc8\x3d\x4f\x10\xdd\xf3\x15\x30\x19\x63\x21\x4a\x77\x95\x96\x6e\x92\x35\x39\x07\x6d\xf9\x57\x0e\x7a\xf1\x97\x3a\xe8\xf4\xbf\xf0\xcf\xd7\xbe\x7f\x2d\x0d\x7e\x0e\x69\x31\xc0\x8c\x8d\xe3\xd4\x68\x93\x90\x9a\xd0\xf0\x1a\xa3\xe8\x2a\x26\x88\xae\x62\x72\xc1\x55\x14\xb2\xf8\xeb\x7d\x05\xd8\x3f\xc6\x57\x80\xc4\x97\xf9\x0a\xfc\xda\x93\xc2\x24\xdc\x8f\x9f\x17\x31\x77\x7c\xda\xe0\x56\x42\xa4\x85\x90\x4b\xea\xa3\x08\x7e\xf5\x11\x08\xba\x93\x0a\xa0\x3b\x59\x04\xdd\x29\x63\x41\x57\x5f\x4c\xcc\xff\x11\x75\x87\xfe\x3d\xea\xe2\xe7\xff\x2f\xa8\x0b\xae\xbd\x2f\x4c\x02\xdf\x80\x32\x43\x31\x8d\x55\xc2\x5c\x0a\xc2\x2d\x65\x76\x90\xd0\xee\x9c\x39\xd4\x9d\x24\xa2\xee\x84\x12\xd4\x2d\xdd\xce\x46\xfc\x1b\xd8\x2d\xfb\x17\xb0\x0b\x86\xff\x0d\xec\xe2\xd7\xde\x13\xc6\xe1\x38\xd4\x69\x37\x16\xc3\x12\x69\xce\x43\x5b\xe8\x78\x48\x8b\x61\x15\xda\x68\xd4\xa6\x44\xd2\xf4\x43\x33\x9a\x88\x88\x7a\x3d\x67\xec\x39\xff\xcf\xd4\x1a\x8a\xb2\x8e\x80\x08\xaf\x6e\xdc\x04\x0d\x3c\x01\x2a\x01\x28\x4c\x41\x6f\x03\x15\xcf\x3e\x2c\xe6\x3e\xe3\xfb\x35\xa4\xa2\x73\xe1\x8d\xcd\x4e\xdc\xad\x5e\x37\xe1\x86\x79\xe0\x8d\xf6\x96\x59\xdb\xd2\x8d\xa9\xc5\x8d\x8b\xff\x00\x08\x31\x0f\x1a\xd7\xd0\x19\xeb\x6c\x54\x6a\xcd\x11\xaf\xc3\xaa\xa4\x55\xfb\xc1\xcb\xfd\x33\xbf\x79\xa0\x6f\xe6\xec\x93\x62\x8f\xff\xaf\xa1\x3e\x4c\x04\x77\x88\x58\x3b\x25\x6d\x14\xb1\x96\xe5\x0c\x1e\x0f\x84\x59\x84\xb6\x08\x6a\x27\xe6\xa0\x16\xda\x05\x94\x2c\x82\xda\x89\x63\xa0\x56\x0a\xf6\xff\x3f\x20\x2d\x38\xf3\xaf\x90\x16\xdc\xf1\xff\x86\xb4\x48\x0f\x16\x40\x3d\xf8\x07\xd4\x03\x17\xa4\xda\x43\x43\x84\x45\x78\xab\xc0\x54\x4e\x95\x5a\xcd\x93\x84\x08\xb5\x12\xce\x9a\x9d\x92\x3a\x50\x92\x3a\x94\x2c\x37\x96\x48\x2e\xb4\x2a\xfe\x5b\x8c\x3d\xf1\x6f\x21\x56\xf7\xef\x11\x16\x61\xec\xd2\x6b\x1f\x53\x6f\x11\x6f\x60\x95\x58\x03\xb6\x2e\xdd\x9a\x20\x0d\x11\x32\x52\xe3\xf6\xf9\x1c\xd6\x68\x59\x0d\x86\xa9\xcb\xac\x64\x63\x53\x79\x5d\x45\x5d\x26\x9b\x20\x7b\xb3\x86\x44\x82\xab\xd0\x45\x39\x97\xa3\x37\xeb\xd2\x99\x82\xfd\x59\x93\x59\xc5\x71\x6c\x5f\x96\x33\x17\xbf\xc4\xce\xcd\xfb\x18\xfb\x16\x3b\x59\x7c\xe5\x05\x78\x9a\xe4\xe4\xf7\xd5\x96\x92\x95\xa8\x25\xdb\x50\x21\xac\x89\x29\x5a\xae\xe9\x56\x0b\xa8\xb7\x4e\x09\xbf\xfa\x1a\xb9\x72\x64\xce\xc9\x4e\xd7\xe0\xdb\x83\xb7\x3f\x6a\x99\xfb\xd6\xbc\x42\xbf\xb7\xdc\x09\xae\xd9\x7b\xfb\x8e\xe3\xa3\xf7\xbf\xf9\xc7\xd6\xa6\x89\x37\x2d\xc4\x3f\xcb\xde\xb3\x40\x3d\x79\xf7\xde\xd6\x48\x79\xcf\xc0\x4d\x37\xec\xdb\x81\xba\xc9\xf1\x8c\x35\x3e\x7a\x65\x57\x14\xb5\x99\xe3\x5b\x27\x2e\x58\x2f\x1c\xe4\xee\x5b\xdf\x38\x69\xc3\x2b\xa2\x7c\x4c\xd7\x3e\x21\x5e\xa5\x6e\x87\x11\x4b\x3d\x36\x2b\x9d\xa8\x52\x7a\x49\xbc\xbc\xdc\xa5\xb7\xea\x23\x4a\xb2\x21\x65\xc5\xc2\x0e\x07\x1f\xc0\x48\xc6\xe3\x71\xf5\x66\x3d\x98\xb6\x22\x93\xd5\x9a\x49\x98\xa8\xf5\x67\x99\x92\xb7\xe9\xf2\xe3\xb4\xa4\xbe\xa8\x55\x5c\x56\x4c\x7f\x84\x66\xf2\xef\x0a\x91\x14\x8c\x62\xfe\x19\x80\x3f\xb3\xa0\x1b\x75\x26\x97\x29\x83\xfc\xf8\x29\xf8\x9f\xc1\x0f\xdd\x4e\x8b\x39\xf3\xf8\xa4\x1b\x4f\x1c\x17\x3e\xbf\x77\xf6\xe3\xed\x2f\x85\xbd\xb1\x7a\x6b\xad\x77\xf3\x6c\x0f\x77\x33\x0b\x2a\xca\x1a\xa2\xe5\x0d\x96\x5a\xef\x26\xe1\x5b\x4d\xcb\x96\x3c\x39\x3c\xaf\xa7\xf9\xd6\x36\xe2\xaf\xca\xd3\xbd\xfd\x0b\x2f\xde\x7b\x5e\xf8\xde\x53\xf1\x08\xe9\x77\x24\xba\x76\x6f\x24\xa6\x5b\xe3\x7f\x49\x54\x4d\xdc\x79\xc3\xd5\x6d\x55\x27\x00\x76\xdb\xba\x1d\x3d\xad\xd2\x5e\x5c\xf2\x75\xc8\x7f\x0c\x6b\xc4\x86\xd3\xf5\x15\x7a\xda\xe3\x01\xfe\xa4\x4a\x65\xf3\x13\x65\x4d\x65\xcd\x36\x2c\xea\x74\x9a\x42\x18\xc9\xf9\x7c\x9e\xde\xac\x0f\xe3\x12\x99\x2c\xa7\xa3\xeb\xd9\xfa\xfe\x2c\x6b\x1e\x3b\xa1\xe0\x3a\x51\x94\x2e\x36\x14\xab\x6d\xe8\x9a\x56\x2e\xf0\x8b\x2f\xbd\xc5\x85\x74\x92\x34\x6a\x44\x71\x10\x39\x71\x50\x45\x4b\x72\xeb\x53\xc4\x0f\xed\x67\xd7\xb3\xc2\x47\xae\xc7\x6f\xcb\xad\xc8\xb5\xd8\xaa\x1c\xb2\x44\xbc\x1e\x3d\x5a\x97\x9b\x08\xb8\x73\x22\xc9\xed\xcb\x6d\xdc\xd7\x4a\xfc\x15\xbf\xda\x6f\x8b\xdf\xf7\xac\xbc\x2e\xf7\x01\xde\x8d\x84\xa2\x99\x67\x8d\x0b\x9f\x59\x91\x54\x9e\xcc\x6d\xcc\x9d\x2c\xe6\x53\xd7\x9e\x11\xba\x89\x10\xf5\x30\x96\xc0\xe6\xa6\xab\x23\x01\x82\xe0\x75\x64\x30\x4e\x19\x48\x4a\xe5\xb2\xdb\xab\x55\x55\xfa\x70\x20\x9c\xc9\xaa\x20\xd0\x6a\x99\x32\x8c\x24\xf9\x00\x67\xf5\x64\xb2\x4e\xa7\x15\x90\x0e\x94\x66\x4b\x7b\xc0\x64\xe6\xc7\x36\xcc\x27\xe5\x24\x57\xf4\x5d\xe1\x02\xfb\xa8\x08\x90\xdb\x72\x26\xad\x9e\xca\x3d\xe7\x16\xd5\x63\xbd\xc5\x74\xf0\xcc\xa9\xaa\x80\xcc\xb3\xca\x57\xf9\x30\xfb\x55\x75\xf4\xa5\x87\xa7\xb5\x05\xaa\x8d\xae\x54\xeb\x44\xb7\xeb\x1d\xed\x3b\x6d\xf1\x90\x24\x04\x30\x40\x5f\xfd\x2b\xb1\x36\x88\x98\x85\x31\x61\x75\xa4\xf3\x67\xef\x18\x5f\xdf\x60\x1a\x79\xe8\xbe\x01\xe1\xde\x20\x62\x1c\x23\xae\xfd\x1d\xc3\xa8\xff\x82\x18\x51\x85\xb5\x61\x53\xb0\xdd\xe9\x71\x2d\x98\xd5\xda\x61\xb3\x19\x26\xc7\xdc\xee\xb0\xc7\x50\x5b\xcb\xd1\x1e\x3a\xa0\x56\x77\x07\xa6\x62\xb1\x58\x6a\x42\xe5\x84\xfe\x2c\x51\xa9\x0b\x98\x54\xed\xed\x1d\x2d\x76\x8b\x89\xf6\x94\x95\x45\x7a\xb3\x65\x9c\xcd\x63\x32\x70\x10\x45\x4c\xf9\x85\x78\x79\x55\x28\x7d\x95\x53\x5c\xe9\x94\x5c\x92\x3e\x27\x93\x5c\xb9\x93\x81\x3c\xd3\x62\xd3\x81\x91\x91\x9c\x3c\x54\x07\xf8\xab\x28\xab\x54\x61\x31\x5e\x01\x36\x50\x44\x10\xaa\xb1\xe4\xb6\xe7\xa5\x88\x11\xf1\x19\x85\xd2\x37\xcd\x55\x1b\x39\x54\xbd\x5f\x21\xbc\xdb\x60\xb1\xee\x7c\xb0\xe5\xcc\xf8\x39\x8f\x4d\xeb\x39\x33\x65\x9a\xbb\x56\x3b\x23\xd3\x5c\xd8\x95\x07\x3c\x21\x79\x97\x9e\x76\xf6\xc3\xa3\x13\x77\x3d\xe6\x9b\x1b\xdf\xbb\x50\x61\xc1\x7f\x87\x5e\x6e\x58\x7b\x5e\xf2\x36\x1c\x4c\x0b\x1f\xd9\xe2\xa0\x19\x84\x84\x87\xc0\x2d\xd6\xb0\xd0\x0c\xce\x79\x9a\x1a\x56\x07\x40\xaf\xf4\x78\x43\x98\xff\xf6\x74\x8b\xb8\x5c\x2f\x63\x09\x1e\x8e\xbc\x68\x1b\x9e\xbb\x3b\x05\xa0\xdf\xfb\x14\xc3\x48\x95\xf8\x8e\xa1\x16\x1b\x4a\xd7\x7a\xc2\x61\x87\x21\xae\x0e\x85\x18\x18\x8d\x59\x48\x4b\x3d\x59\x47\x7a\xcc\xf1\x78\x4d\xd0\x43\xba\x95\x6e\x08\xc0\x6e\x93\xba\x8c\x2b\xeb\x87\xf6\x26\xcd\x03\xc1\x4c\xc5\x5b\x6e\xc7\x98\x59\x41\xa2\xb9\xdb\xd7\xe4\x75\xa2\x32\xf1\x84\xa8\x48\x92\x54\x2b\x89\x08\x01\xe4\x0d\x67\x6e\xc2\xd2\x06\x26\x4f\xeb\xf6\xd4\xea\x07\x27\xa5\x90\x40\x1c\x03\x97\x66\x2d\x59\x5a\x35\x35\x50\xcb\x2f\xec\x8c\xef\x67\xa1\xec\x1a\x16\xcc\x1e\xa8\xec\xc1\x49\x08\xbf\x4f\x37\x28\x1b\x16\xcc\x9a\x51\x19\x56\x80\xe7\xdc\x93\x27\x6d\x77\x81\x66\x5b\xfc\x95\x55\xab\x56\x2f\xf5\x09\x7f\xb1\xf7\xf6\x6d\xb1\x09\x5f\x58\xe3\xa0\x9d\xf5\x47\x82\x0a\x18\xa3\x7c\x12\x6f\xd8\x33\xb7\x59\xfc\xee\xc7\x13\xa0\x2c\x42\xd0\xbe\x5e\x85\xb2\x48\x60\x2d\xd8\x92\x74\x5d\x55\xc4\x06\x4d\x8c\xad\x77\xbb\xe3\x2c\xc1\xb5\x71\xad\x1c\x56\x61\xc0\x0c\xb4\xdf\x5f\x93\xc9\xfa\xcd\xb6\x46\x47\x63\x7f\xd6\xa1\x13\x37\x74\x73\x2c\x41\x13\xbd\x59\xda\x51\x8a\xbe\xf9\xbd\xdc\xff\x02\x78\x8c\xfe\x88\x38\x08\x05\x2f\x36\x37\x24\x99\xfa\x22\x60\xa6\xf3\x50\x4c\x14\x43\xf1\xaf\x79\xbb\xf2\x41\x56\xe8\x64\xb7\x39\x12\x39\xe3\xb3\x98\x1e\x5b\xc6\x02\x85\xf1\xc9\x23\xdb\x8e\x9e\x10\x84\x7b\x2a\x87\x6c\x94\xa1\x26\x20\x19\x5e\x7b\xdb\x8a\xa1\x87\x16\x67\xa7\xd6\xdd\xd9\x20\xbc\xc1\xa0\x81\x2d\xd6\xd3\x01\xd1\x0a\x89\x87\x6c\xf1\x93\xcf\x5e\xb8\xef\x19\xe1\x9d\xf3\x1a\x45\xf3\xa2\x30\x32\x42\x70\xa6\xea\x6e\xc0\xdc\xba\x76\x27\xc4\x64\x70\xed\x7e\x98\xf9\x04\xc4\xb7\x21\xfd\xe9\x32\x9f\x89\x20\x74\x24\x19\x41\xb0\x13\x53\x95\x9b\x5c\x56\x57\x3f\x42\x19\x9d\x0a\x0b\x6b\x31\x2d\x69\x34\xea\x7b\xb3\x46\x8e\x2c\x2c\x5d\x95\x8d\x2d\x51\x8c\x39\x8d\x05\xf3\xba\x0e\x72\x72\xda\x21\xe5\x37\x1c\xc8\xa3\xcd\x7c\x83\xad\xe9\xcc\xd4\xca\xb0\xcc\x30\x6f\x4f\x42\xbd\x30\x79\xfa\x5e\x9c\x51\xe3\xaa\x88\x85\x33\x4f\x4c\xb2\xe4\x81\xa6\x8b\x12\x2e\x82\xa7\x42\x88\x45\x06\x78\x6c\xf1\xf7\xb6\x6d\x62\xff\xb1\x7b\xfb\xf0\x5e\x09\x64\x44\x4c\xfd\x5f\xc8\x17\x9a\x07\x83\x2a\x2f\x5e\xb7\xc8\x56\x50\x65\x35\x99\xa2\xaa\x88\x0a\x0b\x48\xcc\xd8\x33\x59\x8b\xc5\xa8\x13\xd9\x91\x37\x43\x16\x69\x78\xb2\x28\xda\x1b\xcb\x47\x29\x6c\xe6\x99\x78\xce\x62\x6a\x3e\xd3\x9d\x87\x4c\xde\x1e\x7b\xe1\xa4\x8c\x96\xe3\x26\x5a\x8b\x18\xa0\x85\x0b\xe0\x69\x11\x29\x99\xd7\x5f\x44\x20\xb9\xe3\x8e\x9b\x72\xc4\x03\x4c\x03\xe3\x04\x27\xa4\xbd\x1e\xbd\x4a\x0d\xfa\x34\x58\xa2\xce\x68\x2f\x73\xb2\x94\x85\x72\xda\xeb\x30\x1f\x93\x4c\x25\x1b\x2c\x75\x35\xf6\x3a\x3b\xe1\xf1\x40\xcf\x10\x08\x78\x74\x84\x2a\x93\xa5\xa5\xc7\x53\x89\xa2\x0d\xad\x63\x15\xb4\xe8\x2a\x8a\xa7\x0b\xcd\xa6\xe2\xee\xed\x1c\x83\xd7\x55\x42\xdc\x44\xaa\x46\x04\x48\x33\x7e\xe9\x1b\xaf\x1f\x3a\x52\x16\xd7\xdb\x17\xb4\x7c\xd8\x33\x65\xfa\xb8\x28\xe2\xd5\x36\x2e\x6e\xbc\xf0\xc0\x9a\x07\x42\x09\x6d\xfb\xb2\xfe\xc5\xb6\xda\xc1\xdb\x2c\x88\xd5\xb2\xac\x1d\xf0\x27\xef\x6c\xfb\xc5\xad\xce\x8a\x8b\xf5\xb3\x83\x31\x78\x66\x0b\x86\x2d\xe5\xc9\x9b\xee\x0a\xbc\xb3\xaa\x61\x6a\xaf\x27\x99\xa8\x9d\x42\x56\x4d\xfc\x4a\x7d\x0d\x3c\xb3\xa3\xd7\x3e\xc1\x17\x93\x7b\xb1\x6a\x18\x1d\x55\x94\x85\x48\xd2\xef\xd6\x25\x94\x3a\xc2\x16\x0e\x27\x6d\x35\x9e\x68\x28\x9a\xc9\xda\xb0\x4a\x27\xe6\xd4\x04\xd2\xfe\x10\x4c\xa8\x35\x1a\xa6\x4f\x7a\xa2\x2c\xef\xf7\xb4\xbf\x2d\x07\x84\x63\x46\x15\x15\x14\x52\xee\xa2\xb1\xe4\xdb\xe3\xc6\x78\x44\xa9\x2c\x9e\x3f\xd2\x01\x87\xd5\x16\x0f\x4c\xee\x35\x25\xb7\xf6\xf4\xce\xa5\x83\xe5\x7e\xf9\x70\xf5\x7c\x62\x07\x7b\xf3\xad\xe9\xd0\xfb\xba\xf7\xdb\xeb\x82\xf2\xc9\xf6\xb3\x87\x7d\xf1\xb8\x3b\x11\x4c\x2e\x9c\x69\x69\xfc\xae\x07\x1d\x31\x05\xa8\x78\xe4\x07\x3f\x18\x10\x1e\x28\x2b\xe8\xa7\xfc\x4e\x0e\x2b\x87\x88\x54\xeb\x74\xd3\xac\xda\xa2\xb4\x5a\xfd\xb8\x97\xf0\xb2\x51\xb7\x81\xaa\x20\x94\xca\x98\xcf\xe6\xb1\x65\xb2\x06\x2c\x62\xc2\x4c\x4a\x8f\xdb\xed\xe1\x54\x84\x92\xc8\x64\x19\x06\x3d\x84\x95\xac\x4e\x7e\x27\x57\xca\x34\xe2\x19\xfe\xac\x46\x5f\xbc\x44\x33\x37\x82\x29\x05\x4a\x58\xce\x3f\x9b\xcb\xf3\xfc\x93\xca\xc8\x2b\x6f\x6c\x9f\xda\x9d\xe8\x1a\x1d\x56\x00\x6b\xc0\x2d\xb3\x5c\x19\x7d\xf3\x78\xc3\x0a\x6b\x2a\x11\xc7\x87\x59\xe1\x97\x1e\x9f\xcc\x74\xaf\x59\xf8\x7d\xe2\xa8\xf0\xc7\x38\x38\x6e\x45\x0c\x5b\x80\x5b\x7a\x53\x07\x83\x67\x89\x61\x1c\xc3\x20\x06\xbf\x46\xbc\x8e\x69\x20\xc7\x53\xd2\x61\x2d\x1a\xea\xc2\x87\xfc\x7e\xde\x41\xc4\x2a\x82\xc1\x88\x27\xd2\x97\xd5\x62\x7a\xac\x3f\xab\xd7\x5b\x3d\x3a\x2b\x93\xc9\x5a\x1d\x25\x4b\x7b\x73\x4f\xea\x4a\x1b\x94\x51\xbe\x95\x9f\xaa\x41\x95\x06\xbe\x52\x43\x8d\xac\xc5\x0c\xee\x6f\xb8\xb5\x63\xcd\xd4\x66\xff\xf0\xf9\xc5\x59\xe1\x4a\xd7\xb3\x93\x76\xdf\x7d\x4a\xf8\xe2\x54\xcb\x37\xa7\x9e\x0b\xbd\xff\xfd\xd9\x2f\x35\x1a\xe2\xc1\xbe\x93\xdb\xef\xb4\x82\x73\x53\x3a\x46\x4f\x18\xe9\x13\xc2\x1d\xab\x76\x37\xf4\x2e\xbd\x78\xef\xd3\xc2\xbb\x4f\x5b\x0c\xc4\xcb\xef\xbe\x5c\xe6\xfe\xe5\xae\xde\xdd\xb7\x89\x76\xea\xc4\x1b\xf0\x27\xc8\xf9\x30\x57\x9f\x92\xf6\x97\xf6\xc2\xea\x71\xdc\x66\x36\x5b\x79\x85\x82\xc6\x78\xd4\x0a\x4f\x68\x68\x69\x47\x0d\x7a\x5c\x67\x40\x8d\x9c\x35\xfa\x31\xaf\x86\x0b\xad\x7b\xe2\xfd\xb0\x2f\x25\x76\xa1\xa1\x22\x4c\x3b\xee\x83\xee\xc4\x49\x4e\x9e\x31\x81\xfc\x09\x39\x39\x0c\x88\xf0\x04\xf2\xbf\xc9\xae\x19\xe3\xe1\xaf\x93\xcb\x84\xd1\xb2\x09\x24\xde\x60\x56\x81\x5f\x29\xcd\x66\xe5\x07\x1f\xa0\x5f\x05\x87\xca\x6c\x56\x7d\xfc\xb1\x4a\x9c\xaf\x76\xed\x77\xc2\x78\xe2\x0a\xd4\x37\x3b\x44\xc4\x6c\x3a\xa1\xd5\xf1\x41\xc6\xc7\xfa\x2c\x4a\x83\xc1\xc2\xea\xc8\xa8\x83\x20\x22\x46\x95\x1e\x82\x08\x13\xec\xcd\xc2\x1c\x59\xcf\x30\x98\x4e\xcf\x61\xee\x4c\x16\x3d\x86\xce\x4d\xc4\x42\xb1\x53\xac\x44\xcf\x92\x63\x2b\xa9\x68\x05\x47\x0a\xf8\xf2\x7a\x25\x95\x51\x73\x6d\x62\xa8\x03\x03\xf4\x3e\xf8\xc6\xfe\x3f\x3d\x30\x49\x01\x06\x85\x73\x0d\x2b\xad\xf5\x89\x0a\xfc\x4f\x0a\xe1\xd4\xed\x4b\xf6\x7c\x24\x5c\x59\x3d\xef\xe0\x83\x7d\xd6\xef\x7e\x5d\x18\x7f\xf1\xd4\x81\xef\xdd\x6c\x1a\xaa\x03\x13\x24\x7d\xba\xfc\xe6\xed\x97\x0f\xfe\xec\x46\x30\x65\xe3\xc1\x9f\x5c\x3c\xb1\xc1\x1f\xfb\x6f\xd1\x96\x5e\xba\xf6\x09\xf5\x26\xcc\x2b\xd2\xd8\xf3\xe9\xe1\x54\xb5\x5a\x5d\xa9\xb1\x68\xf0\x68\x2c\x16\xf2\xf9\x3d\x15\xf1\x1a\x32\xe9\x4e\xd6\x69\x39\x27\xe9\xaa\xc5\x29\xaa\xb5\xb5\xd6\x0f\x55\x06\x74\xba\xdc\xee\x8e\xba\x9a\x64\xb2\xa9\x2a\xc5\x36\xb1\xfd\xd9\x26\x5d\x55\x65\x6f\xb6\x0a\xf3\xc7\xa2\xb1\x4c\x36\xae\xad\xe0\x3c\x4e\xda\x1d\x4e\x87\xa2\x9c\xdb\x64\xb6\xdb\xf9\xbe\xac\xdd\xa4\x31\xa5\xd1\xac\xb7\xb7\xdb\xdb\x73\x0b\x3a\x20\xe4\x48\x93\x6a\xac\xa5\x83\x56\x1b\x1b\xc7\x6e\xe3\x15\x6b\xa0\x79\x38\x2a\xf2\x93\x21\x18\x20\xe5\xa6\x35\x40\x47\x03\x8a\x31\x0a\xf5\x84\xa0\x45\xd4\x39\x64\x12\x7b\x4e\x89\x54\x12\xe4\xd3\x3c\x9a\xa0\xde\x84\x11\x53\x2e\x53\x7d\xec\x56\xc1\xc7\xe4\x20\x6b\x5d\x59\xdf\xd2\x33\xba\xa1\x3c\x52\x4d\x07\x3f\xed\x86\x8e\xd5\x5b\xfd\xc4\xb0\xf0\xa3\x90\x2a\xf3\xb5\xd9\x4b\x96\xb2\x23\xf1\x38\x3e\x71\x77\x44\x7c\x1c\x7d\x0b\xa1\x19\xfd\x38\xc9\x4b\x18\x36\x77\xee\x0b\x95\xb3\xf1\xb8\x84\x5e\x31\xdc\x0c\x9e\x86\x39\xcc\x5f\xbe\x21\x3c\xf7\xe3\xd8\xc8\xda\xd5\x4b\xb5\xcd\xa3\xf7\x21\xf9\xff\x13\x2a\x58\x85\xf8\x86\xbf\x37\x5d\xa6\x35\x18\x18\x82\x22\x38\x42\x05\x54\x26\xc0\x6b\x58\x14\x4e\xea\x29\x9a\x82\xb9\x2c\x4d\x03\x25\x47\x18\x80\xa1\xb7\x64\xd8\x8f\xf4\x2a\x71\x2c\x62\x4b\xe3\x7e\xda\xf3\xa3\xc4\x38\x69\xdc\x94\x05\x1c\x10\x36\xb2\xdb\x3a\x1e\xe4\x1e\x6c\x5d\xc7\x82\xdb\xd9\x2d\xad\xf7\x73\xf7\x77\xac\x89\xdb\xc0\xba\x01\x30\x28\x3e\x30\x7c\x74\x40\xb8\xd3\x26\xdd\x61\x04\xa0\x4f\xc1\xc5\xf7\xfc\xd3\xd2\x51\x0d\xad\x54\xda\x08\x27\x6b\x74\xa2\x69\x58\x4a\x71\x1a\x16\x03\x13\x61\xca\x60\x30\x9b\x75\x68\x27\x71\x7e\x18\x56\x61\x17\x71\xfe\x0d\xb2\x9c\x69\x27\x73\x5d\x90\xe2\x41\x40\x92\x98\xeb\x5c\x4a\x80\x3b\xd4\xb6\x97\x05\xb1\x29\x90\x48\x8b\x21\xe4\x6a\x49\x9b\xaa\x56\x4d\x98\xd4\xa7\x76\x81\xe7\x45\x1a\x85\xf9\x03\xfb\xe7\x45\x73\x8e\xc2\x3d\x13\xf5\xb8\x10\xd7\x0e\x42\x8c\xbc\x0a\xfd\xbe\x07\xda\x68\x02\x5b\x97\x6e\x09\xe9\xf5\x09\x6d\xa5\x97\x81\xd0\xe2\x76\x63\x5a\x8e\xac\x76\x3a\xab\x9c\xb6\xde\xac\xd3\x11\xd6\x8b\xd4\x57\x22\xc3\xa2\x78\x7f\x26\xcb\x9b\x99\x72\x45\x79\x7f\x56\xa1\xbb\x8e\x87\xf6\xd2\xc9\x6d\xe8\x7b\x50\x90\x72\x3e\x84\x97\x59\x92\x63\x54\xa4\x6c\xb4\x88\xa3\x72\x2f\xb6\x43\x72\x10\xbe\x90\x1c\xc5\xfb\x02\xdc\xa6\xb6\x7c\x54\xca\x76\x72\xe3\x53\xc2\x87\x2f\xc2\xc8\x54\x55\x25\x85\xaf\x47\x56\xb4\xad\xb8\xe1\xf9\xa8\xd0\x01\xbe\x2f\x06\xa7\x3e\xf0\x75\x99\x7d\x14\x93\x36\xd6\x0e\x7c\xef\x0b\x8d\x62\x8e\xf0\x7b\x14\xb0\x12\x01\xe1\xb9\xaa\xb7\x9f\x3a\x8b\xa2\xd2\x8b\xc8\x5f\x54\xcb\x73\x18\xdc\x58\x14\x5b\x9a\xae\x0b\xf8\xcd\x66\x80\x39\x22\x41\x9e\x57\x32\x1a\x95\xc6\xe1\x22\x6d\x65\xb6\x72\x87\xd1\x68\xd6\xea\xb4\xbd\xd9\x20\xa6\x52\x43\xec\x72\xf2\x6a\x35\x69\xd5\x71\xa4\xa7\x2f\x4b\x9a\x0b\xa8\x25\x73\x5e\x3c\xa9\x21\x7f\x96\x85\xe0\xa0\x68\xda\x71\x5e\xe5\x7c\x79\xd5\x03\xe8\xf1\x94\x38\x26\x99\x38\x69\x72\xbe\xff\xd4\xb3\xe7\x08\xc7\x66\x6e\x73\xab\x34\xc4\xa1\x15\xfc\xbe\x55\x9a\xe0\xd0\x7a\x03\x37\xfa\x3f\xb7\xdc\x6b\x34\x0b\x26\x33\x05\x9e\xdf\x7c\xf6\xc9\xdd\xeb\x2d\xd1\x7b\xf3\xba\x59\xd0\xd1\x13\x3b\x37\xec\xdc\x55\xee\x38\x2b\xe2\x33\xe4\x17\xcd\x47\xa9\xc4\xea\xb0\xa3\xe9\x6e\xb3\xd6\x14\x76\x7b\x4c\x1e\x7d\x20\x50\x83\x61\xf6\x0a\xbd\xd1\x56\x5b\xab\xa4\x69\x63\x45\x9c\xf4\xb2\xde\x14\x5b\xef\x37\x1a\xf9\x30\xc7\x73\xfd\xd9\x24\xc6\x2a\xd8\x4c\xb6\xc2\xa6\x70\x9b\x35\xe6\xde\x6c\x44\xa3\x81\x7e\x87\xf0\xf0\x1c\x91\xc8\x64\x09\xf3\x18\xf0\x16\x07\x67\x14\xe4\x21\xed\xc2\x2f\xb1\x3b\x39\x91\xa9\xd1\x17\x87\xf2\xa2\x2e\xd4\x21\xc9\xa0\xf5\xd4\x72\x73\x39\x21\x2e\xc2\xa9\x85\xbe\xd6\xc7\x88\x2f\xae\x19\x37\x70\x01\x46\x14\x16\xd4\x24\x9e\xf8\x20\x22\xbc\xff\xc3\xcb\x6f\x13\x93\xb8\xa9\x65\xff\x75\x58\xd7\x7e\xa8\xaa\x29\xd5\x04\x1e\xe9\x5c\x74\x77\x00\x1f\x8f\x2f\x1e\xb4\x82\x87\x5d\x29\x73\xcd\xcd\x6d\xe4\xae\x13\xa0\x9b\x1b\x3d\xb5\xf7\xf5\xe8\xe8\xd7\x28\x30\xeb\x91\x6f\x3d\x72\xa2\x66\x60\xe7\x13\xce\x3a\xe5\xd2\x7f\x5e\xc3\xb8\x5b\x47\x42\x83\x1b\x35\x00\xfb\xe7\x52\x65\x9d\xe1\xc1\x9d\x4a\xd5\x80\xf0\xf3\x53\x07\x26\xff\x10\xe9\x4a\x37\xca\xef\x20\xfe\x07\x61\xe4\x38\x27\x5d\x15\xc3\x8c\x84\x46\xe9\x71\x86\x42\x56\xab\x92\xc0\xc8\x64\x8d\xa7\xd2\x5f\xd9\x9f\x35\x12\x26\xbf\xce\x01\xad\xc7\x81\x99\x22\x99\xac\xc9\xcc\x70\x99\xac\x8a\x71\x14\xc6\xfa\xcb\xe1\xc6\x75\x73\xc7\xf2\x01\x33\x53\xd2\xdb\x06\xf5\x41\x9c\xf4\x28\xd5\x17\xe5\x02\x41\x71\x2a\x47\xbc\x3a\x9c\xad\xb1\xee\x5d\xed\x9b\x67\x16\x37\x93\xb7\x4f\xb1\x3a\x77\x1c\x9f\xfd\x78\xfb\xaf\x50\x45\x6d\x8a\x5e\x2a\xb8\x8d\xd6\x17\x0a\x6a\xf8\x96\x3b\x84\x41\xe1\xe7\x77\x1c\x33\x29\xae\xac\x71\x6c\x3e\xf0\x70\x4f\x3c\x42\xb1\x10\x75\x27\x6d\x40\x75\xb6\xd1\x6c\x49\x3d\x4d\xe8\x26\x29\xc8\x77\x00\xf2\x3d\x3f\x5d\x63\xe0\xf9\xa0\xcf\xa7\x56\xc4\x6c\x0a\x1b\x56\x83\x25\x03\xbe\xde\x6c\x00\x73\x41\x56\x5d\x3a\xbe\xd2\x0c\x25\x60\x36\x1b\x01\x4c\xe0\x4c\xb4\x36\x93\x55\x2a\xe9\xfc\x06\xf9\xb1\x15\xb5\x42\x4c\x52\x93\xcb\x80\x20\x06\x8c\x61\x3d\x50\x5c\x57\x43\x35\x56\x63\x49\x05\x8d\xa4\xfe\xbc\xde\x5f\xc4\x7b\x7a\xaa\xd9\xf8\x5a\x51\x39\x8d\x4c\x9f\x66\x53\x45\x65\x33\xea\xf6\xcf\x5f\xb0\xbd\x2c\x33\x7e\xe3\xee\xe5\xf9\xfa\x59\x15\x58\x69\x8d\x8f\x5e\x1e\x53\x33\x9b\x21\xd7\xcc\xc2\x58\x5f\xba\xdc\x68\x36\x93\x00\xb8\x34\x4a\x65\xd4\xeb\x72\x45\xec\x10\x0e\xdd\x6e\x3b\x04\x2c\xa3\x39\x93\x25\x8d\xe2\x70\x03\xb5\x9a\x05\x98\xa9\x50\x2c\xcb\xc5\xce\xb1\x9c\x97\x2e\x34\x56\x24\xbf\xbc\x32\x36\x86\xff\xa1\xe3\x5f\x5a\x0f\x7b\xda\xb1\x67\x65\x31\xcf\xc4\xec\x92\x4a\xd8\x55\xcb\xf1\x23\x39\x16\x91\xee\x02\xa1\x9b\xca\xc0\xb8\x38\x81\xb5\x62\x5b\xd3\xed\x0e\x6b\x73\xc4\x57\x5b\x5b\xa9\x64\x18\x3d\xa6\xaf\xac\x8c\x58\x89\x36\x1d\x86\xb5\x93\xe2\x14\x22\x32\xa1\x87\xfc\x24\xc8\x44\x30\x16\x4b\x65\xb2\x31\x9d\xaf\x2a\x58\xd5\x9f\x0d\x9a\x4d\xae\xbe\xac\xcd\x66\x2a\x1c\x68\x51\x85\x02\xc2\xab\xe4\xc9\x62\x25\xd7\x02\x25\xa9\x20\x53\xda\x0c\x26\x1a\x76\x09\xb3\x32\x32\xa2\xb3\x36\x5b\x08\x64\xdd\xe2\x69\x8b\x97\xe2\x54\xc6\x5a\x74\xce\x65\x8d\x15\x66\xe1\x9e\xa1\xd2\x88\x3a\x22\x45\xdb\x80\x42\xd1\x76\x4a\x30\x35\x1d\x6e\x5d\xd3\xd2\x9a\x40\x91\x38\xbe\xf8\x56\xf9\xd0\x13\x23\x9b\x46\xbf\x93\x8f\xb0\x7f\x2f\xc6\xdd\x48\x01\x0c\xc2\x5b\x02\x3d\xad\x0d\x5f\xa1\x53\x88\x11\xb9\xe8\xd7\x9b\xe1\xf9\x3f\x01\x75\xdf\x8f\xad\x48\x37\x39\xbc\x50\x5e\xbc\x5e\xef\xb7\xf3\xbc\xc9\x64\xf0\xf9\xbd\x94\x3b\xe0\x0e\x7a\x1d\xe8\x66\xc1\x60\x87\x86\xef\xe2\xac\x10\x19\xad\x98\xc9\xa4\xf7\xc3\x70\xc4\x24\xcb\xb3\xc4\x02\x24\xeb\x97\xa7\x0e\x96\x64\xcc\xb9\x8b\xd1\xd0\x75\x36\x40\x30\xf2\x8c\x09\xe9\xbd\x0b\x30\x12\x7b\xc7\x2a\xfd\xdd\x3f\x3e\xd6\x76\xe6\xcf\xb7\xb0\xa0\xfa\x3c\x38\x3f\x9f\x05\x41\xb6\x4f\xf8\xf1\xdf\xe2\x45\xaa\x0e\x7e\x76\x58\x38\x4f\x75\x59\xe3\x57\x1b\xc0\x57\x1c\xf1\xb8\x45\xf8\xcd\xe8\xdf\x21\x8f\x30\x67\xc2\xd5\x90\x47\x33\xd6\x94\x76\xeb\xcc\x66\xbd\x92\xd1\x33\x56\x8b\x38\x4b\x14\xd3\x9b\xff\x15\x1f\xa5\xb3\xb2\xae\xa7\x59\xa2\xf7\xa5\xb1\x74\xfe\xe1\x0f\x28\x64\xf9\x43\x31\x61\x88\xa6\xcf\x5f\x10\xe5\x3d\x05\xea\xe9\x7a\x18\x9b\xb4\xc0\xb8\xa4\x89\xd7\x63\xe1\x70\x79\x44\x1f\x71\x54\x3b\xdc\x6e\x3a\x55\x5d\x5d\x43\xd7\xb4\xb5\x62\xa9\x94\xaf\xa2\xa9\xa2\x3f\x4b\x34\xe9\xea\x92\xbd\xd9\x3a\x5d\xa4\xc6\xe4\x50\x40\xc0\x35\x69\xa1\x21\x1a\x0c\xda\x12\x3a\x93\xa5\xe3\x93\x0a\x44\x97\x14\x6c\x4b\x7b\x52\xaf\xe3\xa5\x5e\x2e\xc7\xe6\x7b\x54\xa5\x2f\xf3\x55\x48\xb9\x2c\xab\x58\xba\x7f\x2c\xbf\xef\x89\xb3\x6e\xb6\x0d\xcb\xb3\x6e\xf6\x2c\x92\x66\xdd\xe4\xaa\xb3\x52\x15\x56\x9c\x9f\x53\x24\x11\x79\x92\xce\xbe\x26\x79\x92\xce\xec\xdd\x8d\x85\x49\x3a\xe2\xdb\x4d\xa4\x97\x50\x4e\xe5\xd8\xcc\x74\xa5\xcf\xe1\x70\xc2\x33\xe3\xf9\x48\x84\x71\xc2\x3c\xd7\x67\x09\x5a\xa0\xb9\xea\xc4\xeb\x1d\xce\x69\xd2\x97\xff\x5b\x5d\x1c\x3b\x8f\xee\x5f\x9d\x67\x51\xea\x50\x54\x7d\xa5\x09\xe2\x89\xb1\x3c\x4b\x49\xc2\xd3\x0d\x6b\x24\x4e\xa5\xb2\x2b\x8c\xff\x4b\x38\x44\x99\xc0\x9e\xb9\xa3\x87\x88\x65\x72\x95\x55\xdb\x34\x7a\x2f\x8a\x51\x0e\xca\x75\xd4\x08\x56\x8b\xa2\xd3\x28\xea\x9b\x74\xd9\x03\xc6\x4a\xbd\xde\x68\x67\x48\xaa\x9e\xaa\x0b\x18\x8d\xa1\x50\x79\x26\x1b\x32\x5b\x3c\x99\xac\xc3\x61\x71\xa9\xab\xb5\xd5\xfd\x59\xad\x5c\x55\x66\x70\xf1\x16\xe7\x4b\xca\xa9\x05\xe0\xfa\x92\x7a\x95\x38\x3b\xbb\xf0\xe4\x2e\x17\xa2\x7e\xa9\x37\x2e\x76\xc0\xbf\x55\x55\x1d\x65\x85\x5e\x76\xdb\x87\xf9\x40\x75\xe5\xf8\x52\x87\x1c\x3a\xfa\x8d\xca\x21\x50\x28\xa1\xe2\x72\x44\x4a\xbe\x2b\xc5\xa9\xef\x3e\x25\x6c\xcb\xbb\xe3\x1f\xee\xd3\x6c\x28\x54\x4f\x91\x1f\x9a\x00\x65\x82\xea\xa7\x5e\xac\x27\x1d\xa5\xec\x76\x8b\x45\x8d\x7b\xbd\x7e\x4e\xad\xf6\x39\x70\x37\xde\x9f\x05\xc0\xad\xb3\x59\x7a\xb3\x36\xce\x6c\x52\x40\xf8\xd6\x68\x14\xf9\x93\xce\x0f\x5f\xcd\x17\x4f\x8b\x5e\x42\x4a\x0d\x20\x5f\x66\xbc\x52\x05\x15\xff\x54\x2c\x8b\xde\x3c\xe6\x88\xbb\x4f\x15\x0a\xa7\xf8\x5b\xbb\xb7\x0f\x8f\x32\x85\xc3\x45\x9a\x8a\xaa\xa5\x52\x6e\x64\x83\xf8\xf2\x33\xb1\xce\x38\x98\xae\xb6\x99\xab\x83\x6a\x85\x01\x77\x63\x15\x65\x65\x18\xae\x08\x9a\xe9\x54\x83\xbb\x1a\xaa\x6e\x65\x26\x5b\x5e\x1e\xd1\xf1\x4e\x54\x2e\xe5\xcd\x63\x83\x87\x31\xe5\xc6\x2f\x99\xe5\xf0\xa5\x07\x55\x54\x79\x8c\x14\xbd\xd6\xc8\xb5\x5e\xb9\x01\x7e\x49\x97\x2c\x3d\x2a\xeb\x82\x33\xf9\xda\xe3\xbc\x91\x25\x8b\x8b\x4a\x8e\x03\x37\x2c\x5f\x08\xf8\x8a\x99\xc2\x4f\xf2\x67\x75\x6b\x9d\x54\x77\x6c\x1e\x4c\x56\x6f\xc9\xe4\x2a\x8e\xf5\xfd\x2d\xf5\x3b\xe1\xb9\xb1\xf0\xdc\x7c\x10\x5b\x2b\xa1\xff\xa8\x37\xea\x6c\x0a\x9d\xa2\x92\x75\x38\xa2\x51\x2f\x5e\x59\x59\x15\xf0\x7a\x13\x1a\x13\x9a\xf1\xae\x61\xd1\xa0\x64\x56\xc3\xba\x2b\x2a\xc8\x0c\x3c\xcd\x0a\xcc\x1d\xca\x64\x7d\x3e\xb7\x63\x6c\xa5\x75\x8c\xa3\x2d\x1c\x66\xa1\x08\x27\x97\xa2\x08\xdf\x58\x23\xf6\x95\xb6\x24\x1a\xa5\x13\x16\x50\x5c\xd1\x3e\xd1\x71\x12\x5c\x0e\x15\x1f\xf3\x34\x9e\x13\x1e\xf1\x04\xbf\x7a\xb8\xaf\x57\xfc\x41\xc7\x54\xeb\xcb\x91\x97\x1f\x9a\xd6\x46\x3e\xbf\xc1\xb4\xf6\xde\xab\x8f\xbf\x2b\x4b\x61\xd7\xae\x39\x17\xbf\xfd\x9a\x1b\x7e\xb5\xe7\x10\x99\x82\x51\x88\x54\xb7\x82\xbc\xdf\x2e\xce\x90\x1f\x48\x57\x04\xf4\x66\xb3\xc9\x66\x32\x28\x19\x1d\x66\xf3\x7a\x31\xc6\x40\x06\x43\x2e\x5e\x74\x32\x9c\x3e\x90\xc9\x9a\xf5\xe6\xb1\x08\x95\xfc\x72\x74\x32\x34\xca\xd5\x8c\xb1\xcc\xa1\x97\x95\x0e\x20\x0e\x6c\x93\xfa\x7a\x00\x41\x04\x4b\x19\xd2\x0a\xcf\x7c\x7d\xbd\x02\x60\x77\xfd\x33\x5d\x6e\x65\x5f\xb6\x4f\x17\x0e\xb7\xbc\x9d\xe7\x62\x80\xd8\x6e\x8b\x8f\x06\xc1\x89\xe5\xd9\x50\x05\x13\xb7\x44\x67\xdf\x34\xfa\x84\x68\x7f\xbf\x81\xbc\xec\x82\xbc\xd4\x62\x23\xe9\x46\xad\xaa\x2c\x5c\x95\x70\x57\xbb\x30\xbb\x92\xa3\x8d\x46\xbb\xdd\x1d\x56\x91\xf5\x18\x4d\xd7\x55\xb9\x7b\xb3\x55\xa6\x40\x2c\x93\x8d\x44\x02\x0e\xce\xa5\xac\x26\x49\x8b\x34\x74\x32\x77\x9f\x81\xa1\xd8\xa8\x00\x44\x5f\xd2\x43\x21\x2b\x74\x8a\x47\x4d\x13\x28\x4f\x0c\x49\xed\x49\xd2\x2a\x0c\x91\x35\x0e\x18\xaf\xf7\x52\x04\xfc\xc9\x91\x72\xf6\x05\xdd\xa4\x4e\xa0\x3f\xbf\x92\xfd\xec\xae\x9d\xe9\xda\xa8\x91\x7d\xd6\x74\xe8\x87\xaf\x6c\x1a\x0b\xd2\x67\xce\x3e\x91\x4a\x0e\x38\x55\x71\x8d\xdb\x33\xb3\x55\x00\x87\x6d\x71\xe1\xf4\xe6\xd6\x89\x36\x9d\x9e\x8e\xeb\x1c\x2d\xfb\xfe\x43\xe8\x32\x15\x87\x0f\x77\x3e\x5a\x37\x41\xac\x29\x43\x59\xa0\x5a\x87\x0f\xfa\x9e\xb8\xdb\xab\xd7\x5a\x18\x3b\x86\x31\x5a\x2f\x19\xc0\xad\x56\x3f\x70\xf8\x1c\x99\xac\xd7\xeb\xe3\x68\xda\x6a\xc5\x33\x59\xab\x49\x65\xcc\x64\x39\x4e\x55\x1a\x37\x26\x8a\x21\xa9\xf4\xf5\x0a\x23\xb5\xc7\x8e\x35\x67\x5f\x7e\xfa\x1a\x81\xb3\xa3\xff\x29\xd6\x8e\xa7\x8c\xe1\x6a\xf4\x8c\x02\xaf\x95\xcb\xc7\xc4\xf9\xea\xab\x3f\x48\x1c\x15\xe6\x15\x98\x88\x13\x09\x54\xe3\x13\x6b\xc5\xad\x30\xaf\x19\x84\x31\xb1\x1f\x46\xc5\xd9\x74\x65\xb9\x4e\xa1\x52\x05\x02\x56\x9d\xb5\xca\x87\x61\xd5\x16\x8e\x0f\xa3\xa1\x6b\x50\x3e\xf1\xfe\xac\xc6\xac\xb4\xa1\xb9\x90\x7e\x3f\x41\x40\x8f\x43\x38\x0a\x23\xd8\x4a\x92\x9a\xe2\xf7\xd1\x12\x33\x14\x43\xe7\xb3\xfd\xe2\x0e\x81\x24\x61\xd1\x02\x8b\x38\x7d\x0d\x14\x65\x34\x29\x72\x30\xd0\x3a\x6e\xd1\x6c\xda\xf5\x2a\xcc\x62\xb6\x1d\x3d\x05\xb0\x13\xdb\x56\xc6\xeb\x1f\x58\x6f\xb2\x12\xb3\x23\x9e\xa4\xf0\x9d\xc8\xf8\x9a\xe1\xb3\x0b\x67\x77\xaf\x3f\xf0\xe1\x5b\x86\xf9\x73\xad\x6d\x8f\xdd\x07\x1d\xc8\xd3\xa0\xfa\x89\x72\xff\xd5\x43\xb6\xcd\x77\xb9\x57\xe9\xb7\x92\x5e\x87\xe9\x9e\x6b\x18\xcc\x64\x0e\x17\x78\x45\x7b\x0b\xd0\xad\x47\x9c\x66\xd9\x00\x8a\x61\xd5\x35\x6e\xaf\x37\xc9\x73\x3a\xc8\xaa\x4e\xc7\x56\x28\x2b\xfa\xb2\x4a\x33\x63\x46\x23\xc3\x3d\x1e\x0c\x83\x58\x8c\xfd\x5f\x58\x4d\x16\xf5\xb7\x22\x36\xbd\xfa\x5a\x83\x38\x78\xb4\x98\x4d\x34\x64\x4e\x7a\x59\x28\x77\x8e\xd7\x13\x2f\x20\x46\x9f\x04\x87\xef\x13\xfe\xb0\xe7\xe7\x87\x7a\x56\xf2\xfc\xd9\x7b\x73\x8c\x26\x02\xad\xc2\x77\xfb\x27\xcd\xbb\xb3\xff\xb1\xd6\xb5\x1d\xd5\x26\xa1\x5b\xe4\x75\xd5\x1e\x90\xb9\x04\xe2\xe7\x26\x74\xac\xbe\x7a\x5a\x66\xf6\x2d\x03\x39\x75\xd9\xd6\xc3\xc2\x5f\x1e\xf9\x7d\xb2\x0e\x70\x9b\xa4\x3e\x21\x98\xb7\x52\x51\x98\xbb\x69\xb0\x06\x94\xb7\x32\xb1\x30\xaa\x4a\x99\x9c\x6e\xb7\x29\x46\x34\xea\x1a\x1a\x9a\xea\x0d\x48\x2f\xeb\x41\x82\xc8\x64\x13\xba\xb0\x32\xaa\xec\xcf\x46\xcd\x2e\x97\x4f\x5c\x67\xe1\x28\x1d\xb3\x97\xf7\xa2\x45\xfa\x9a\x67\xbd\x24\x27\xcd\xe3\x6f\x61\xba\x9e\xf4\x3c\xbd\xe8\xfc\xdb\x81\x84\xbd\x9f\x15\xe5\xa6\xf8\xb6\x6a\xab\xab\x3a\x3d\xd9\xf6\x5d\x7e\x66\x32\x54\x99\x08\xcc\x68\xdf\xbc\xb3\xba\x90\xcb\xe2\x54\xf8\xed\xa3\x3d\x6d\xc4\x84\x42\x92\x4a\x7c\x6f\x87\x69\xf3\xb1\x2f\xf6\xac\x69\x38\xe0\x5c\xfd\x96\x61\xff\xce\x45\x7f\xce\x25\xb4\xae\xe8\x0f\x3e\x34\x22\x39\xb4\x43\x7b\xfd\xb1\x78\xf7\x9a\x44\x37\x7d\xe5\x76\xad\xc2\x17\x37\x99\x7c\x5a\xa2\x36\x8a\x61\x75\xe5\x50\xb1\xcb\xcb\x55\x06\x43\x15\x8c\x9d\x75\x5e\xaf\x4a\x05\xb3\x3c\x95\xb9\xac\x8c\x20\xc2\xa5\x9a\x9e\xfb\x4d\x1e\xe1\x3a\xf6\x79\x43\x41\xd3\x65\x3e\xe5\x76\xf7\x42\xbf\x14\x2e\x0b\xa4\xd0\xde\x40\xfc\x58\xd2\xf6\xb2\xe3\x07\x1f\x7e\xfa\xf6\xcf\x6f\xdd\x71\xbc\xa8\x4b\xaa\x96\x41\x7a\x30\xda\x27\x37\x43\x49\xda\xde\xfe\xf1\xec\xe7\x1e\x3f\x0b\x7c\x17\xd7\x0f\x16\x7a\xa3\x84\xff\x9e\xe4\x80\x7a\x80\x7f\xad\xd0\x07\x05\xb0\x32\xc8\xf7\x2d\x90\xef\x0e\xec\x86\x74\x3a\xa1\xf2\x19\xe8\x7a\x87\xd5\x5a\x1f\xd5\x1a\x54\x74\x67\x6b\x7b\xfb\x38\x6d\xb0\x22\x58\xd1\x9b\x55\x07\x9d\x41\x5c\x4d\x04\x83\xac\xd9\xec\xce\x64\xed\x76\xb3\xae\xae\x8e\x65\x6b\xfa\xb2\xac\xb9\xad\x0d\xc3\x9a\x4b\x8d\xa0\x80\x5d\xb9\xa9\xff\xf9\x69\xb6\x63\x60\xac\x58\x18\x10\xbe\x72\x3b\x8c\x8a\x5e\x8b\xa2\x5d\x1e\xe8\xbd\xa8\x3f\x92\x7f\x2f\x9a\x17\x12\x7a\x1d\xf0\xcb\x45\xb3\x99\xd0\xe6\x23\x47\xef\x39\xb9\x05\x64\x26\xae\x78\x61\xe5\xcd\x6b\x82\x55\x21\x53\x7f\x64\x70\x73\x75\xa5\x77\xbf\xc1\xa6\xb7\x37\xdc\x3a\x7d\xc1\xf2\x59\x93\xb6\x4f\xf2\x54\xaa\x72\x66\x83\x2c\x25\xfd\xde\x84\x2d\x6b\x56\x3f\x62\x63\x1c\xb3\xd3\xbd\x3b\x27\x06\x5f\x5f\xaf\xb7\xae\x99\x5f\x33\x55\x4f\x32\x0b\x35\x96\x8d\xfd\xd3\x66\x97\x55\x55\x0a\xd7\x32\x61\xd1\x7e\xc4\x9d\x88\x30\x4e\xfb\x2d\x94\x57\x3b\xb6\x33\x3d\xc9\xeb\x6f\x6e\x55\x27\xec\x65\x65\x89\x58\xab\xc1\xcf\x30\x1d\x29\x82\x48\x57\x58\x38\x34\x86\x5e\x6d\x71\x5a\xba\x2d\x83\x96\x55\x16\x4a\x4d\x58\x2c\x35\xe1\x1a\x45\x5f\x96\x61\x6a\xcc\x7e\x7f\x38\xec\xca\x64\xc3\xba\x96\x16\x0c\x6b\xfc\xff\x29\x36\xa3\x2c\xae\xdc\xc4\x6b\x3a\x06\x52\xd2\xd6\x93\x3a\xb9\x24\x9c\x9f\x68\x5f\x68\x97\x95\xa6\x8e\x88\x42\x5b\x0d\x65\x56\xee\xd9\x71\x74\xd5\xee\xda\x9a\x87\x27\x7b\xf5\x5e\xdf\x33\xda\xc9\x33\x66\xf6\xc7\x16\x38\x1b\x53\xe1\xa6\x4d\x53\xce\x9e\xfb\x39\xe8\x19\xfc\xc1\xb7\x36\xac\x74\x29\x8b\x24\x66\x4b\xff\xb1\xa5\x61\xf1\x8a\xd6\xac\x51\xbd\x50\x89\xf3\xeb\xbb\xa7\x4c\x73\x19\x56\x7d\x57\x6d\xdc\xb2\xe2\xa9\x2e\x86\x1f\xe9\x3a\xf1\x60\xd5\xa3\x53\x72\xe2\x82\x76\x55\x09\x31\x35\x06\xe5\x15\xc7\x52\xa8\xdf\xa3\x5a\x57\x69\xf2\xd3\x0a\x45\x34\x14\xf2\x3b\x75\x64\x43\x05\x14\x81\xb2\x92\xaf\xec\xcd\x06\x79\x5e\xe3\xf0\x78\xac\x7d\x59\x8f\x4e\x53\x8b\x86\x5d\xc7\xe3\x04\x51\xfe\xa5\x6e\x24\x3f\x3d\x71\xcc\x03\x87\x12\x5f\x92\x32\x06\x68\x4c\x52\xab\x60\x3b\x28\x5d\xf9\xcb\x24\x73\xb0\x03\xf2\xd3\x64\xc8\x98\x68\x65\xca\x95\x54\x4c\xf8\xf0\x59\x68\x63\xc0\x51\xd4\x89\xf8\xf0\xd3\xd4\xa2\x65\x56\xd1\xb7\x1c\x2f\x36\xb5\x8a\x36\x7c\xe9\x3b\xc2\xc7\xc5\x76\xd6\x33\xf0\xdc\xe3\xbe\x9a\xd1\x4b\x37\xb5\x20\x6b\x7b\x46\x7b\xbf\x64\x6d\x38\xb6\x01\xea\xce\x3d\x54\x37\x66\xc5\x82\xe8\x06\x44\xc1\x71\x4a\x9b\x47\xe9\x09\x59\x30\x2c\xec\x77\x4e\xcf\xfa\xe5\x18\x48\x89\xb6\x18\x99\xac\x56\x82\x30\x5d\xcf\xbe\xb4\x42\xa0\xc4\x83\x96\xf8\x4f\xb1\xa2\x90\x77\x27\x44\x51\xb3\x3c\x7e\x8f\xc8\x20\xe3\xfa\xc3\x29\x54\x5d\x38\x75\xbf\xec\x43\x56\xe7\x56\x57\x88\x0c\xd9\x3a\x1e\x92\x57\x58\x48\x6e\x83\x7a\xb1\x78\x8f\xc5\xb5\x3f\x41\xbc\xc8\x88\x39\x75\x57\x3a\x1c\x8e\x6a\x6d\xb6\xa8\x91\xa8\x80\x0e\x3f\xe6\x42\x0b\x40\x68\x97\x59\xbe\xbe\xd1\x45\x22\x18\x16\xbc\x5e\xbd\xc7\x7a\x87\x9c\x2e\x1b\xa5\x00\xc6\x50\xa7\xcb\xcf\x5f\x90\x2e\x8f\x8b\xd5\xf6\x1c\x44\xc1\x4c\x4a\xd7\x3e\xb2\xe0\xf1\xa1\xff\xbc\xfd\x7e\x77\xdf\x5b\xf3\x1f\x7a\xe6\x36\x61\xf4\xc8\x82\xa5\x76\x45\xb1\x61\xb7\x83\x6f\x3f\xd5\x7e\x04\x86\x05\x00\x1b\x2e\x9f\x3a\xeb\xc5\x47\x9f\x12\x7e\xfe\x94\xed\xee\x5e\xa7\xa4\x99\xe0\x5a\x4c\xce\x39\x62\xa8\xd7\xc6\x68\x62\x43\xa6\x90\x03\x8f\xc5\xe2\x9c\xc3\x51\xe1\x76\x57\x94\x89\xf9\x45\x19\xc6\xf3\x56\xab\x1e\x5d\x7f\xab\xfc\x19\x88\xf7\xc5\x97\x51\xb9\x3b\xff\x44\x51\x86\x31\x36\xb7\x90\x46\x47\x94\x3a\xb8\x1c\xa7\x63\x13\x8b\x9d\x30\x87\xf0\x96\x7b\x65\x2e\xd0\x41\xa5\xe5\x7c\xe2\x86\xa2\x7c\x62\x74\xe2\xb7\x5f\x63\xce\xb7\x8b\x6c\xa0\xc3\x02\x4b\x51\x3e\x81\xdf\x93\xcb\x27\x96\x42\x7b\x1b\x81\x71\x67\x05\xb6\x20\x5d\xad\x50\x2a\x7d\x3e\xbf\xc5\x6e\xe7\xf5\x7e\x7d\x3c\x86\x61\x95\x3e\x79\xe4\xb8\xca\xa5\x75\xf5\x67\xb5\x66\x65\x00\xa9\x5a\x45\x05\x41\x94\xfd\x9f\x02\xb6\xe4\x97\xc7\x6c\xff\xa2\xbb\xb7\xa0\x87\xff\x0f\x6b\x7f\x02\x1f\x55\x75\x3d\x0e\xe0\xf7\xbe\x6d\xf6\x7d\xdf\x33\x99\xcc\x4c\xf6\x49\x32\x49\x26\x10\x92\x0c\x21\x40\xc2\x4e\x80\xc0\x00\x21\x20\x9b\xe0\xc6\x26\x22\x0a\x88\x45\x51\x51\xa0\xe0\x56\x40\x51\x50\xdc\x81\x8a\x82\x56\x45\x6a\xc1\x56\xc1\x5a\xab\xd6\xb6\xae\x75\xab\xb5\x2a\x6a\xd5\x5a\x35\x6f\xfe\xf7\xde\xb7\xcc\x9b\x49\xf0\xfb\xff\xfd\x3f\x7f\x30\x66\x98\x77\xee\xb9\xe7\xde\x7b\xf6\xf7\xde\x39\xcc\x12\x91\xf7\x9e\xce\x2f\xe0\x2c\x97\x76\x16\x79\x51\x62\x41\xb1\x24\x74\xfe\x43\xbc\x32\x4f\xa2\xf3\xbb\x11\x9d\x1f\xae\x65\x9c\x40\xb1\x46\xaa\x44\xe5\x74\x57\x54\x99\xfd\xfa\x90\xd5\xeb\x0d\xf9\xab\xdc\x2a\x8e\xae\xa5\x6b\xfc\x66\x73\xb1\xa7\x98\xa8\xdd\x62\xa7\xcf\xe6\xb1\xe1\xd2\xeb\x1e\x53\x25\x52\x3a\x65\x79\x8c\x99\x7b\x7a\x43\xba\x3b\x37\xe8\x53\x3a\x05\x4a\xb7\xb0\xd0\xf1\x00\x25\x3b\x52\x54\xb2\x83\x17\x3e\xfe\xec\xd4\x60\xba\xb5\xb0\x0e\xf2\xdc\x6d\x47\x15\x0a\x95\x02\x8f\x51\x25\xd4\xf3\xcc\x4a\x60\x02\x01\x30\x54\x51\x3b\x26\x18\x52\xd4\x8e\x41\x16\x9c\xc5\xef\x9c\x93\x77\xc1\xce\x55\x38\x46\x35\x78\xe1\x18\xdc\x34\xf0\x25\x16\x17\x68\xb9\xf7\x5e\xb1\x74\x4c\x5d\xf9\x8c\xf3\xe7\x47\xdb\x4b\x8b\xd5\xcc\x38\xdf\xf0\xf1\x2f\x3e\xf2\xd7\x49\xc3\x29\x2d\xbf\xa7\xb5\xf3\xb9\x5b\x6f\x0a\x16\x3d\x9f\xc6\xbd\x0d\xa9\x18\xb5\x8b\xb9\x14\x78\x70\x9d\x3d\x07\xc7\x01\xaf\x49\xaf\xf7\xe1\xd7\x9f\x87\x3d\xea\x71\xd1\xf2\xdb\xb0\x79\xef\x21\x2a\x2b\x15\x08\xf9\x06\x61\xf7\x52\x54\x4f\xd5\xe5\x43\xe7\x5c\x98\xb9\x6d\xea\x94\xe9\xc2\xcb\xcf\x8b\x87\x5e\x31\x6d\x0e\xb5\xb9\x3c\x75\xf1\x82\x0b\x0f\xce\x0f\xdd\x71\x7e\x6c\xfa\xed\x33\xc9\xbb\xcf\xf8\xfd\x33\x40\xe6\x56\x23\xad\xd4\x95\x0e\x99\x8b\x7c\x16\x86\x41\x5e\xbc\xd3\x59\x1c\xa4\x2b\xb4\x65\x65\x95\x94\x05\xb9\xfa\x8c\xcd\xe6\xd1\x6b\x62\x98\xa2\x20\xe7\x51\x16\xaf\x48\xe0\x87\x01\xf2\xca\xbd\x92\x37\x5f\x90\x22\xc2\xbb\x62\x13\x08\x0b\x40\xb9\x66\x41\x9c\x53\x45\xc8\x3b\x6a\xe2\x53\x2d\x54\xe5\xa2\x39\x63\x02\xf3\x46\x8d\xa9\xd3\x94\xb6\x20\x52\xbb\x2f\xe9\xea\x58\xb7\x68\x65\x63\xcc\x5c\xe9\xab\xb4\xa0\x55\xc4\xce\x2b\xf6\x51\x8f\x0f\x69\x9c\x9a\x80\x31\x42\xb9\xb6\xbd\x35\xd9\x31\x6b\x44\x5b\x79\x4f\xba\x22\x85\x16\x64\x35\xdc\x21\xf8\xe3\xf7\x53\x11\xea\xaf\xec\xcd\x88\x39\x4b\xc1\x84\xb4\x2d\xc4\xc5\xf4\x00\x78\x9c\x46\x8b\xcd\xc4\xa9\xcb\x5c\xae\x72\xd7\x13\xb0\x2a\x6d\xf4\x6b\xb5\xb4\xd3\x63\x31\x32\x76\x93\x89\xb6\xe3\x37\xeb\xf0\xeb\x1e\x6d\xc2\x3b\x28\xb8\x5d\x0f\x8e\xff\xdb\x94\xb7\x96\xc5\x87\xcc\xe4\xea\x2a\x71\x55\x1b\x44\x61\x23\x8a\x3e\xb0\x83\xa0\x92\xdf\xf8\x40\x8c\x4d\x9d\xba\x6f\xd7\x82\x35\x93\x77\xce\x6e\x69\xb4\xb4\x9d\xd4\xde\xd6\xd4\xa6\xbe\x70\xc4\x61\xed\xc6\xa6\xf4\xbf\x27\x5f\x9a\x1e\x52\xdf\x9b\x6a\xa3\x9f\xf9\xdd\x1b\x6b\x17\xcd\xdc\x93\x09\x5c\xd6\xb5\x78\xc8\xc4\x2a\x47\x22\x90\xec\x6d\x1a\x99\x7c\x4a\xfd\xe0\xfa\x89\xd3\x26\x6c\x9e\x3c\x79\x9a\x90\xd7\x5a\x8d\xf8\x62\x24\xa9\xc7\xd1\x96\x76\x9b\xad\x20\x18\xf4\xb2\xd6\x08\x5b\xaa\x77\xbb\xcb\xbc\x14\xa5\xd1\x38\x62\x25\x61\xfc\x8e\xbc\xd5\xe8\x50\x56\xe4\x48\x0c\xac\x27\x52\x2f\x7a\x39\x03\x8a\x72\xe4\x3c\x1c\x5c\x94\x03\x1e\x6b\x69\xee\xb6\x69\x6d\x75\x53\x4b\x53\x0b\xeb\x13\x11\x52\x94\x63\xe1\x66\x58\xdb\xb0\x61\xcd\xa2\x49\xd6\x31\x33\x6e\xa2\xde\x9a\xe0\x56\x0d\x51\xe9\xda\x6b\x66\x09\x35\x39\x96\x48\x35\x39\x4a\x8a\x31\xcd\x37\xc3\x4a\x6a\x09\xbb\x13\xb8\xc0\xb0\xb4\xcd\x0e\x00\x0b\x21\xed\xa0\xdd\x46\x9d\xce\x43\xb9\x5c\x2c\x79\xc3\xdb\x6c\xd0\xfc\x06\x56\x21\x09\x6b\x21\xf5\xd3\xda\xe4\xe7\x9b\x73\xfb\x6d\x8b\x0c\x7a\xef\xea\xbf\xf3\x37\xcf\x63\x16\xa9\xbd\x97\xcc\xab\x89\x38\x02\x7a\x4b\xb8\x3c\x6e\xb6\xac\x53\xaf\x87\x95\xb4\x3a\xe0\x2a\xbd\x66\xbd\x6e\xf5\x48\xfd\xb8\x29\x73\xea\xc8\xfe\x5d\x04\xcb\xa8\x47\x98\x45\xc0\x8b\x6b\xfe\xda\x2d\x1a\xbd\x9e\xf2\xd2\x6a\xb5\xd7\x42\xfb\x38\xce\x8f\x78\x43\x03\x21\xeb\xb2\x9a\x9e\x80\xd5\x47\x70\xb9\xbf\x27\xc8\x2b\x7e\x72\xb9\xb4\x64\xe1\x13\xb1\x64\x27\x95\x0f\x71\xa8\x14\x65\x2e\x91\x3b\xa4\xd5\xac\x1d\xb3\x90\xc3\xa5\x2e\xc7\x2c\xd0\x2c\x50\xc9\xe5\x2e\x3d\xdd\x0e\x2f\xd5\x9b\x84\x07\x70\xc1\x34\x7e\x66\x32\x2a\x16\xbd\x5c\x21\xd6\x77\xdb\x01\x4b\xa9\xa7\x89\xfc\xc7\xc0\xe8\xb4\xc9\xab\xb3\xdb\x8b\x4c\x2c\x65\xa2\x9c\x71\x67\xa9\x03\xbf\x8c\x1c\xc0\xc5\x98\x8e\xe8\x8a\x8b\x0d\xb8\x6e\x91\x8a\xa6\x01\xa2\x19\xb4\xd5\x25\xea\x24\x0d\x95\x7f\xab\x93\x3c\x27\xa7\xcc\x52\x4a\xd5\xa4\x90\x55\xb5\x29\xeb\x49\xc1\xc4\xb8\xc9\xfe\xb0\x3a\xd1\x34\x61\xaa\x43\x8f\xd4\xd6\x81\xab\xb0\xda\x5a\xe0\xbc\xed\x5a\xb1\xe6\x55\x94\x85\xa5\xb6\x3b\x16\xf8\x17\xac\xec\x18\xff\x22\x29\x2f\xf5\xc2\xfa\xeb\xa9\xdb\x71\xe9\xab\x9b\x5a\xff\xd0\x21\xd4\x59\x43\x67\x7e\x02\xed\xb3\x07\x0c\x4f\x5b\x59\x1a\xdb\x09\x5c\xe1\x5b\xe3\xf5\x78\x7c\x6e\xbd\x11\xbf\x4e\xcf\xda\xed\x2a\xa9\x5c\x58\x8b\xa2\x5c\x98\xf8\xf6\x67\x2e\x3d\x8e\xdf\xe3\xb1\xe5\xbd\xac\x27\xbd\x05\x4e\x35\x8e\x66\x1f\xa9\x71\x2c\x58\x76\x39\x93\x1e\xc1\x3e\xd0\x6a\x68\xae\x5a\x52\xdc\xbe\x00\xf6\x98\x7c\xd0\x70\xe1\xc6\xf5\xaa\x08\x5c\x4e\xde\xf8\x36\x0f\x1b\xd7\x08\xaf\x40\xfb\xba\x85\xaa\x83\x7f\x62\xe7\x22\x7d\xef\x03\x23\xd3\x66\x13\x7e\x83\xce\xec\xe4\xd4\x8c\x1f\x80\x80\x0d\x69\xb1\x9a\xb4\x86\x52\xab\x4d\x1a\x0d\xa7\x23\x55\xba\x68\xc0\xe5\x2a\x70\x2b\xde\x4f\xcd\xa9\x01\x15\x29\x5f\x8d\x1f\xe5\xc1\x4f\xb5\xd1\x36\x85\x8b\x08\xff\xa4\xb9\x30\x36\x87\x39\x55\x75\x21\xfa\x3d\x9e\x3d\x52\xd5\x4d\x2a\xb0\xa0\x1f\x7a\x61\xdd\x1b\x88\x48\x88\xff\xcf\x67\xe1\x93\xe4\x05\x4b\xec\xe2\xa1\xbd\x7b\x99\x8a\xc1\x63\x68\xef\xf0\xdb\x9c\x3a\x0b\x00\x48\x50\xec\x1c\xe7\x30\x17\x54\x42\x50\x6c\x14\x56\x46\x79\x35\x10\xc8\x2e\xc1\x21\x4e\x4b\xa4\x54\xdf\x3e\xb2\xaa\x9a\xee\x18\xcf\x3c\x36\x42\x47\xed\x12\x2b\x1f\x18\x82\x70\x3d\x9a\x78\x53\x0d\xe9\x0b\x82\xf6\xe4\x35\x34\x9f\x54\x33\x16\x1d\x93\x58\x33\xb6\xf9\xe7\x6b\xc6\x46\xc4\xe7\xf9\x20\x4c\xb6\x33\x67\xd9\xae\xa9\x23\xd8\x2f\xd8\xd1\xd4\x6c\xe4\xf4\x99\xe0\x7b\xf8\xff\x40\x89\x1f\xd7\xfc\xf4\x93\x67\xa8\xd4\x06\x93\x81\x66\x19\xbb\x4e\xe7\x30\xa8\xd5\x5a\x0b\xcb\x92\xe7\xa7\xf0\x84\x56\x9a\x86\xf2\x84\x92\xc8\x0d\x10\x3b\xec\x13\xb6\x51\xe2\x96\x9b\x28\x2c\x77\x2e\xb8\xec\x0b\xb6\x33\x3e\x57\x33\x37\x3a\x02\x11\xd3\x59\x32\x47\x33\x27\xde\x4e\xd5\xf9\x4c\x6f\xd7\xbd\x82\x69\x79\xa5\xee\x6d\x13\x79\x16\xe9\x07\x58\x0a\x9f\x41\x3c\x60\x21\x5d\x3c\xba\xd2\x36\x1a\x00\xb7\x01\x16\x1b\x68\x8d\xdf\x5f\x66\x45\xd1\x54\x28\x8a\x18\xe1\x18\xed\xf1\x00\xbd\x9e\x33\x63\x36\x70\x20\x36\xa8\xce\xbd\x92\xa8\x2c\xfd\x90\xe3\x04\x44\x86\xe4\xb9\x35\x93\x9d\x11\x73\x10\x48\xb6\xa0\x92\x2b\xca\xa7\x68\xa6\xda\xe6\x8e\x6a\x68\x9a\x3c\xaa\xf1\xfc\x29\xec\x13\xfc\x6d\x5e\x67\x71\x8d\x3e\x55\x5e\x05\x6f\x92\xaa\xf6\xc0\x6f\xeb\xc6\x4d\xac\x8d\xd5\xb7\x53\xa3\x4d\xbe\x7e\x9f\xdd\x55\xd7\x1c\xa5\xaf\xca\xb1\x09\xda\x57\x64\xa6\xe0\x09\x76\x33\xb0\xe3\x1a\x29\x48\x93\x71\x28\xc0\x31\x5b\xad\x4e\x74\x70\x95\x8f\x5a\x8c\x80\xd4\xf6\xa8\xab\x6b\x93\x5f\xf2\xcb\x65\x08\x52\x39\x39\x12\x72\x64\xe3\xdb\x27\xd9\x37\x4f\x60\x8f\xec\xd2\xd7\x07\x5d\x3e\xbf\xa3\x06\x56\x76\x4d\x2a\x5e\x41\x33\x26\xdf\x4f\xd7\x0f\x2f\x9e\x6c\x69\x5f\xa3\xc3\x73\x5e\x2b\xcf\x59\x97\x36\x18\xed\x76\x93\x9a\x35\xb1\x36\x87\xcd\x69\xfd\x0d\x32\x9a\x26\xd8\xfa\xa8\x96\xa3\xe5\xc2\x35\x79\x4f\x80\x62\x51\xe1\x94\xdd\x15\xc8\x0b\xc0\x34\xdc\x6e\x2f\x5a\x17\x69\xb4\xfb\x35\x16\xaf\x27\xe2\x71\x6d\xdb\x86\xc8\xd8\x4a\x8d\x5f\x71\xc8\xba\xbc\xdd\x12\x6a\x5b\x43\x57\x20\x1a\x5e\x47\x73\x1f\xa2\xea\xa8\x26\xc4\x47\x06\xbc\x5e\xa0\x52\x19\x69\x96\x35\x61\xfe\xc1\x82\x91\x2b\xa9\x9b\x57\xc4\x24\x57\x51\x57\xac\xa7\xeb\x9b\x30\xa2\xa9\x3a\x16\xe7\xef\x9c\xdd\xc9\x40\x15\x3b\x8b\x5a\xa0\x5a\xf5\x08\xae\x78\x83\x99\x15\x82\x47\x91\xd9\x38\x8e\xf4\x6e\x12\xcc\x4d\x17\xb1\x74\x99\xcd\xe6\xb2\xd3\x76\x6d\x71\x20\x10\x0c\xd6\x27\xb4\x06\x43\x5d\x22\xd1\x50\x16\x89\x98\x3c\x9e\xca\xd8\x33\xc8\xc0\x86\x11\x73\xd8\x41\x10\x2d\x5c\x45\xcb\x3b\x9e\x5f\x8b\x48\xae\xb2\xab\x74\xfa\x95\xea\x58\x59\xb9\x67\x90\x62\x44\x0e\x29\xca\xa6\x39\xea\xee\xfa\x4a\xbc\x53\x9e\xb2\x2a\xc3\x68\x43\x7d\xc5\x0a\x75\xf3\x82\x16\x53\x63\xe5\xa5\x52\x51\xa2\x0a\x5c\x94\x08\xd7\x2e\x1a\x6a\x4c\x57\xc0\x4a\xbc\x85\xdd\x13\xe0\xce\x69\x26\x5c\x8c\xe8\x00\xec\x9d\xe0\x1c\xb6\xa2\x96\x3f\x80\x17\xbc\x6a\xd8\xe8\xf6\xe1\xb8\x7a\x51\xb8\x8b\xbf\xe9\xac\xa0\xb3\xe9\x97\xd1\xfe\x96\x83\x69\x69\x97\xc7\x89\x4b\x7b\xe8\x63\x25\x52\x61\x8f\x8a\xa2\xa2\x4a\x5c\xd8\xa3\x45\x2a\xec\x71\x34\x06\x7c\x16\x4b\x59\xae\xaa\x07\xa9\xfb\x3c\xa0\xa6\xc7\xff\x63\x51\x0f\x9b\x50\xd5\xe3\xcb\xd2\x45\x75\x42\x55\x0f\xa4\xd5\x93\x65\x2b\xb4\xc3\x70\xf1\xa5\xf2\x15\xba\x61\xf3\x6f\xe8\x62\x0f\xd5\x38\xca\x17\x27\x2e\xa1\x0e\x0c\xe9\x6a\x6b\xd1\xfa\xe1\x65\xa2\x92\xbf\x30\x05\x67\xf2\xfb\xd1\x1a\x2f\x6a\x84\x33\x7f\xfa\xca\x18\x80\xa6\xa5\xcd\xa3\x70\x9c\xfd\x01\xb2\x47\x4f\xa2\x73\x2d\x46\x5e\xa0\x93\x41\x9e\xac\xc1\x6c\xd6\xaa\x8b\xd5\x5e\x9d\xae\x24\xe0\xf5\x46\x42\x3e\x37\x7e\xa7\x5f\x0b\x0c\xb0\xf5\x08\x63\xb5\x72\xd8\xdf\xa7\x14\xfe\x7e\x32\xff\x05\xff\x5c\xc2\x4d\x2c\x8c\xe3\x50\x11\xea\xa5\xe3\x53\xd6\x65\x82\x46\xf2\x52\xf9\x25\x6b\xd9\xb6\x09\xcc\xe3\x2d\xc6\x61\xd5\x4b\xc2\xa3\x2a\xf6\xe7\x4e\x12\x57\xe8\x5a\x75\xf5\x86\x6a\x7e\xa7\xd1\x07\x7b\x67\x69\x86\x4d\x68\xe0\x2f\x39\x2b\x9c\x9d\xc0\x93\xd4\xd7\x88\xf6\x28\xae\x1b\x65\x37\x1a\x4d\xc8\x61\x09\xb8\x4d\xee\x58\x38\x12\x89\xdb\xb5\x5a\x27\xae\x1b\x65\x45\xb4\x62\xf1\x2b\x0e\xc9\x5c\xd8\xa6\x90\x84\x3c\x92\x05\x0d\x30\xa0\x5a\x14\xbe\xaf\xae\xc8\x03\x5e\xd3\x3e\x29\x50\x45\x88\x6d\x17\x5f\x8b\x47\x2b\x18\xa7\xd4\x0f\xf5\xb7\x81\xec\x38\x37\xa6\xf6\x5a\x4a\x47\x96\xa0\x09\xf3\x1d\xb2\xb6\xc0\xf2\x54\x45\xc5\x68\x07\xf1\xb7\x90\xf7\xed\x34\x99\xac\x2a\xca\x65\xd0\xda\xb5\x14\xed\xb3\x5a\xfd\x46\x27\x2e\xf1\x6c\x41\xbc\x84\x0b\x9c\x6a\x5d\x7a\x2c\xc9\x44\x8e\xda\x04\x39\x22\x14\xb7\xe5\x9b\x5c\x29\x78\x24\x6f\xfb\x26\xeb\x6c\xd8\x04\x88\x65\x4d\x69\x72\x3b\x6a\x69\x30\xe4\xf0\x6a\xb4\x9a\x74\x83\xbf\x83\x7d\xf2\x85\x96\x4e\xf6\x65\xb6\x6b\xf6\xd0\xaf\x9d\x91\x69\x54\xcc\x3e\xc9\xa3\x83\x43\xee\x40\xc6\x6f\x3d\x9c\x81\xa5\xbe\xff\x3b\xf8\xb7\x75\x2f\xe2\x7e\xc2\x0f\x21\xdf\xfa\x0f\x68\x9f\xf5\x48\xa0\x7d\xf8\x2d\x70\xaf\x81\xa6\xfd\x0e\x9b\x56\x1b\xb0\x7b\xbd\x2e\x15\x2e\x79\x65\xce\x2b\x4c\x0f\x65\xfe\x56\x54\xa5\xc7\x31\x4d\xdc\x2e\x3d\x50\x8a\xb7\x38\x0c\xaf\x5d\x70\x59\xf7\xce\xd9\x0b\x2f\x3b\xca\xb7\x0d\x19\xb9\xdc\xce\x3f\x07\x47\xaf\x1d\x7e\x81\x0b\x36\x53\xb1\x8d\x17\xcc\x3d\xd0\xbb\xe1\xa2\x5b\x5f\xfa\xeb\xe4\x9e\x5f\x9c\x3f\xfb\xfe\x55\x73\x70\x7d\xce\x03\xe8\xcc\xb3\x48\xcf\x7a\x41\x11\xf2\x00\xe7\xa5\x63\x25\x66\xb7\x3b\xa0\xa1\x28\x5f\x38\x6c\x43\xae\x6a\xdc\x66\x2b\xc5\xe5\xc4\x4b\x02\x01\x17\x1d\x09\x06\xcd\x1a\x1a\xfd\x45\xfb\x57\x79\xc4\x4d\x4a\xe8\xb6\x08\x25\x74\x71\x13\x8e\x5c\x36\xcf\xa2\xb0\xe0\x96\x5c\xe5\x6f\xf2\x68\x3e\x45\xee\x54\x8b\x35\xf4\x85\x22\xcb\xb8\xf6\x13\x6d\x77\xd9\x8c\x30\x5a\x1f\xa7\x5b\xe1\x7b\xec\x79\xd1\x99\x17\x3e\x72\x75\xd9\x1c\x16\x96\xb0\xf3\xcb\x7b\x2f\x18\xb7\x25\x53\x32\x87\xfd\x66\xe1\xf4\x09\x17\xc3\x6b\x17\x4f\xef\xbe\x10\x56\x22\x43\xcb\x6d\x58\x78\xcb\x1f\xb8\x7f\xe1\xdd\xfd\x97\x6a\xdd\xe2\xde\xbb\xe7\xb2\x7f\x42\xce\xce\xab\xb7\x5a\xe0\x67\xba\xdf\x84\x6e\x37\xf1\x36\xd3\xd3\x02\x7f\x6c\x42\xeb\x6c\x23\xfa\xb6\x2b\xed\xb6\x85\x4a\x8a\xb9\x6a\x97\xa7\x54\xaf\xf7\x54\x17\x87\xd8\x7a\x2a\x99\x6c\x60\x60\x2d\x0e\x31\xdd\x0e\x3f\x5a\xd4\xa3\xb1\xe2\x5c\xdd\xbe\x5c\x1d\x9e\xc2\x86\x6e\x71\xa1\x02\xb4\x4b\x8a\x63\x0a\x53\x46\x82\x64\x2a\x6f\xcf\x53\x65\x7e\x4d\x7c\xd8\x85\x8d\xed\xc3\x86\xad\x58\x1d\x2e\xb5\xd4\x07\x9d\x7e\xc4\xe5\x65\xed\x13\xb5\x45\x3e\x6d\xd9\x88\x4d\xa9\xf4\xb0\xe6\x25\x73\x5b\x16\xd0\x1f\xa4\x8b\x67\x17\xd5\x17\x87\xc6\xd6\xce\x9a\xae\x9a\x15\x25\xbc\xde\x35\xc9\x35\xfe\xc1\xee\xca\x0b\x4b\x52\xc1\x40\x67\xcd\x84\x19\x0e\x92\xdb\xfb\x0a\xad\x6d\x31\x3a\x43\x1f\xa8\x4d\x9b\xd4\x0e\x87\x81\xf2\xf9\x02\x66\x83\xc1\xcf\x40\x0f\x36\xd1\x56\x5c\x93\xbd\x45\x59\xc6\xcc\x92\x54\x36\xf9\xc9\xa5\xbc\x0a\xee\x9d\x77\x07\x75\xf6\x50\x59\xa9\x69\xb5\x6b\xc9\xc4\xba\x6a\x62\x39\x4b\xab\x0c\x2b\x5c\x2b\xe6\x55\xc7\x58\xae\xc3\x30\x6e\x6a\xff\x82\xab\x2e\xc1\xfa\x63\x42\x37\xb5\x79\xf3\x3a\xbd\xb0\xd7\xbf\x40\xb6\xfb\x1b\xe6\x63\xe2\xf3\xb8\x8c\x3a\x14\x9b\x85\x3c\xc8\xb1\xf4\xe8\xe8\xd2\x48\xa4\xcc\x1f\x8d\x16\x85\x8a\x05\x1f\xd3\x89\x23\x48\xb3\x5e\x93\x23\x4f\x51\x77\x2b\x3f\xf6\x11\xfc\xce\x7c\xc3\x3e\xb0\x12\x17\x8c\xfa\x1c\xf1\x7a\xbd\xae\x62\xbf\x48\xaf\x37\xe2\xb5\x59\x3c\xc9\x3a\x26\xdd\xc5\x4e\xec\x8e\x39\x37\x6a\xaf\x1a\x2a\xba\xa7\x6d\x44\xf3\x05\x47\x5c\xc4\xb4\xd4\x98\xa2\xf0\x22\xa1\x42\xd7\xd1\x14\x89\x8b\x76\x53\x25\xd4\x5f\x48\x5c\x51\x0c\x66\xa6\x5d\x2a\xaf\x97\x72\x15\xd9\x34\x1a\x23\xd2\x1e\x80\x8e\xe8\xf5\x25\x36\x74\x6e\x88\xfc\xb4\x2e\x6c\x04\x40\xa7\x42\xe1\x9c\xc9\x8a\x3c\x83\x47\x35\x52\x30\x27\xb9\xf2\x78\x11\x6d\xca\x45\x25\x2d\xca\xe7\xc5\x49\x93\x20\xdc\xa0\x23\x29\x38\xf8\x42\x00\x92\x22\x05\x44\xda\x60\x84\xdb\xad\x69\x2b\x41\xd6\xa9\xea\xdf\x95\x0b\x2a\xdb\x35\xed\x71\x6c\x7d\x91\x86\x74\x8d\x1f\x56\x75\x7e\xb1\xf1\xdf\x4e\x7a\x48\xdd\x9f\x8d\xbe\x1f\x7f\xfc\x11\xb9\x9d\xb8\x7a\x88\x6d\xd3\xce\x96\x31\x4d\x13\x36\x09\x67\xb1\x0f\xe9\x45\x3d\x5a\x47\x29\x92\xed\x32\x95\xb1\xd8\x67\xf4\x69\x43\x21\xbf\x95\xd6\xea\x5d\xb1\x98\x9e\xa6\xcb\xfc\xfe\xf2\xa0\x5e\x6f\x28\x0e\xa9\xd5\x06\x2f\x36\xc0\x11\x1f\x09\x48\xec\xf9\x25\x7f\x14\xa2\x3d\xb0\x66\xba\xf2\x9e\x90\xf4\x60\x73\x32\x57\x2d\x1d\xdf\xe6\x96\x9f\x6d\x46\x92\x02\xb7\x2c\xbb\xfc\xba\x8b\x35\xb1\x91\xe5\x91\x70\xe4\xc7\xf8\xc4\xc5\x9b\xe7\x5f\xdd\xd0\x62\xfc\xd1\x12\x36\x54\x0d\x8f\xd2\x13\x66\x1c\xa7\x62\xe7\xcd\x9c\xff\x2b\x67\x11\xd7\x72\xcb\x2e\xdd\xd6\xbe\xab\xb6\x2f\xa8\x1d\xab\xde\x75\x4b\x0b\x57\xa4\x9b\x3b\xe6\x8a\x3b\x85\xb5\xbd\x86\xd6\x56\x4e\x74\x7e\x73\xda\x81\x5c\x26\x96\xb2\xba\x28\x97\xcf\xe1\xf0\xbb\xb4\x5a\x2b\xcb\xe2\xb0\x0f\x19\xab\xdc\x3a\x0a\xdf\x16\x12\xa9\x16\x3d\x05\xa9\xb6\x76\x4a\xfc\x87\x11\xc2\xfb\x5e\xa6\x5a\x3b\xd8\x2f\x99\x31\x29\x6e\xd9\xdd\xee\xe6\xd1\xcc\x69\xb6\xab\xd9\xba\x91\x8a\x6d\x37\xb8\xe0\x79\x58\xef\xf0\xcf\x85\x7c\x0b\xb6\xc2\x09\xe4\xf3\xd1\x45\xa4\xbe\xf6\x49\xa4\xdf\x1f\x25\xf5\x17\x5b\xd3\x76\x97\xc7\xa3\xb1\x5a\x83\x1a\x9d\x0e\xb9\xcd\xc5\xc1\x60\xc4\xe3\xf0\x63\x7f\x4e\x8d\x48\x33\x48\xa4\x0d\x08\x47\x45\xe1\xcc\xb9\xd0\x2a\x44\x58\x2b\xa5\xec\x71\x46\x5e\x08\xea\x1d\x39\x45\xd5\x8c\xb8\x63\x24\x37\xb5\x68\xc6\xa4\xa6\x9a\x62\x9f\xbb\x34\xe0\x28\xad\xb9\x79\xe6\x5e\x2a\xd6\x34\x2c\x1a\x85\x19\xe4\xb2\xac\x4e\x4d\x8c\xf6\xdc\xb4\x78\x64\xb3\xa1\xeb\x0a\xdd\x81\x0d\xc7\x2f\x14\xf6\xef\x26\xe4\xe7\xde\xc1\xac\x00\x56\x30\x24\x6d\xd5\x69\xcd\x66\x40\x2a\xcc\xe8\x55\x06\x9b\xc1\x6e\xc6\x29\xc0\x23\xc8\x23\x63\x15\x61\x99\xc2\xcd\x16\xad\x91\xcd\xee\x14\x1e\xe4\x40\x6e\x15\xa9\xc6\xa9\xe2\xfe\x2d\x96\x99\xa9\x5c\xde\xc1\xee\x9a\x7e\x4b\x9c\xba\x5a\x28\x33\x53\x3f\x09\xde\xda\xff\x29\xd2\xcf\xc7\xfe\x33\x9c\xcc\xbf\x06\xcd\x3f\x15\x9d\x9f\x05\xb4\xa4\xed\x46\x33\xab\x42\xb6\x5c\x65\xa6\xad\x94\x46\x63\xd3\xd2\xb4\x0a\x07\x86\x8f\x41\x9d\xce\xa4\x6c\x7e\x90\x97\xaf\x11\x4d\x74\x4a\x7a\x96\x5e\x7c\xb6\x42\xb5\x86\x83\xdd\x99\x29\x81\xb0\xdf\x07\x2f\x61\xf9\x43\xab\xbb\xaa\xaa\xfd\x15\x28\x44\x83\xff\x72\x4c\xbe\x35\xc0\x7b\xfc\x33\xee\xc1\xf3\x23\xbd\xb9\x03\xcd\x1f\x06\xe3\xd2\x2e\xb5\x89\x75\xea\x0c\x16\x8e\x33\x38\x4d\x4c\x71\x20\x14\x8a\x98\x51\x78\x8a\x13\x08\x8f\xa9\x2c\x16\xd2\xcc\xe2\xd1\xa0\x2f\xe7\x79\x27\x07\x25\x26\x77\x6a\xe1\x01\x44\x29\x5c\x9e\x92\xf6\x89\x7a\xfe\x6f\x83\x10\x99\x34\x25\x43\xd8\x20\x24\xb1\xdb\x53\x34\x5e\x41\xf0\xf3\xc3\xe2\x82\xbb\x43\x21\xba\xdf\xa2\x56\x12\xbe\x8f\x80\x19\xe9\x30\x6b\x05\x01\x26\x6c\x09\xbb\x2c\x9c\xce\xa0\x36\x99\x0c\x1c\x5d\xe2\x72\x45\x7d\x76\x3b\x67\x94\xd6\x70\x34\x80\x16\x41\x03\xb1\x25\xc7\xf3\x82\x4a\x12\x8e\x71\x60\xd2\x5c\x68\xd2\x4c\x72\xa5\x11\xe5\x2a\xa4\x3c\x6a\xaa\x58\x25\x88\x35\x1c\xee\x71\x55\xea\x83\xb7\xe5\x2f\xa4\x76\xf9\xf2\xaa\x86\xde\x4c\xe7\xf8\x9e\x05\xa9\x56\x3f\x55\x17\xad\x0d\xa5\xe4\x85\xec\xad\x8b\xa5\xd2\x7b\x2f\x89\x04\xad\x7e\xc2\x03\xc3\x60\x29\xf5\x30\xa9\x8f\xd6\x9e\xf6\x58\x6c\x7a\x97\xda\xe3\x71\xd9\x28\xc6\x6f\x74\x38\x02\xc8\x8f\xb3\xbb\xf4\x7a\x9b\x58\x9b\x51\x4c\x3c\xc9\xcd\x7a\x06\x36\x2e\xcd\xeb\x66\x28\x57\xef\x27\xfd\x1c\x20\xbb\x7e\xac\x2f\xbd\xf4\xc2\xf5\x13\xc6\x56\xb1\xdf\x3e\x88\xc9\xf5\xc2\x17\x59\xfe\xbf\x4f\x3d\x03\x4b\x27\x05\xaa\xd7\x2e\x99\x3e\x3f\x00\x1d\x88\xca\x10\xff\x0f\xdf\xd1\x6b\x1f\x10\xea\x97\x3f\x87\x64\xf9\x14\x7b\x13\x12\x55\x27\xa9\x44\x6d\x09\xda\xed\x16\x8f\x47\xab\xa5\x43\x74\x91\xcb\x62\xf1\x91\xd4\x92\x31\x57\x76\x2e\xa1\x70\x7c\xea\xe4\x32\x37\x94\xf4\xd4\x00\x2e\x6e\x13\xc6\x04\x4a\xd1\x08\xc5\xf6\xcd\x9b\xba\xf3\xfc\xd9\x33\xba\xb7\xf6\xb5\x4f\x8d\x41\xce\x5a\xf6\xbd\x63\xf2\xa8\x79\x11\xf6\xa6\x1d\xd7\x6d\xe4\x4f\xdf\xb6\x6d\xe3\x66\xd8\x74\x7b\xcd\x2d\xaf\xad\xed\x98\x34\x8b\x3f\x6f\xed\xd4\x3d\xf7\xfd\x8e\xd0\x96\xdd\xca\xf4\x51\x0d\xec\x73\x40\x07\x5c\x20\x00\xec\xc7\x68\x07\xed\xd0\xf8\xdc\x26\x90\x48\x9e\xa9\xc3\x0e\x59\x2e\x77\x8c\x8f\x8e\x55\x7c\x76\xd1\xa9\xa4\x4d\x45\x35\xd4\x45\xa3\xf5\xf5\xd1\x68\x1d\xaf\x45\x9f\x1a\x1a\xd0\xa7\x83\xb7\xab\x9e\xb2\x71\xec\x62\xf2\xaf\xfa\xfa\x57\xc5\xdf\x1b\x60\x6b\x94\x3f\x1e\x26\xf3\x3e\x8c\xe6\xad\x50\xcc\x0b\xf0\x9b\xff\x3e\xb7\x5e\x31\xaf\xad\x38\x57\x11\x90\x55\x7c\x8e\xe2\xda\x31\x90\x8e\xd6\x91\x89\xe1\x03\xe4\x43\x43\x03\x7f\x11\xbb\xf6\x75\x8e\xff\x17\x6b\x68\x10\x08\x6a\x38\x28\x7d\x80\x61\x38\x3c\xca\xff\x0e\xfb\x39\x97\xf3\x23\x41\x53\xf6\x41\x50\x06\xcc\x8f\xdb\x2c\x36\x0b\x3a\x92\xc4\x19\x71\x3e\xec\x13\x23\xf5\x18\xc7\xa2\x27\xd6\x82\x17\xab\x88\x52\x0e\xbb\x4b\xfa\x0d\xaf\x73\x07\xdd\x56\x6b\x2c\x1a\x74\x06\xb4\xd5\x55\x45\xe5\x9e\x80\xc7\x66\xf3\x86\xbc\x63\xf8\x91\xcc\x50\xbb\xdb\x62\xd0\xa8\x50\xec\xe0\xf3\xb8\x4d\x76\x4d\xb1\x23\xe0\xb5\xfb\x1d\x66\x8d\xca\x6c\x46\xe1\xb9\xd5\xa4\xf5\xb0\xc4\xdf\xaa\x60\xfa\x60\x3f\x7b\x19\xb2\x90\xae\xb4\xce\x06\xa1\x49\x1f\xd2\x53\x7a\x23\x7e\x39\xf5\x64\x2f\x62\x00\x92\x80\x90\x5e\x84\x4a\x25\x89\x47\xd5\xd8\x0c\x61\xff\xf9\x17\xac\x6f\x5f\x98\x9c\xdc\xa3\xee\x64\x56\x86\x46\x8e\x5c\xf5\xcb\x5e\x56\x03\xa9\x29\x15\x65\x0b\xa7\x0f\x2b\xda\x12\x28\x13\xeb\x8f\x25\x98\xd3\x70\x3f\x7b\x1a\x70\xc0\x96\xd6\xe2\x52\x1e\x09\x14\x2f\xd1\x14\x41\x8f\x71\x87\x1b\xc2\xa9\x24\xdc\x7f\x0f\x5f\x03\xaf\x3b\x5e\xcd\x1e\xfa\x70\xd9\xf6\x81\xe3\x58\x13\x13\x62\x12\x0c\xcd\x40\x90\x78\xa9\x17\xd3\x14\x8e\x37\x24\x5d\x61\xb8\x9f\xaf\xb9\xa7\xfa\x38\xbc\x8e\x39\xfd\xa1\x7f\x90\x71\xb4\x89\x0d\xb1\x09\x96\x66\xc9\xb8\x3a\xe2\x21\xa2\x09\x5d\x70\x7f\xf5\x71\x7e\x0d\xfc\xd3\x3d\xcc\xe9\xed\xcb\x3e\x1c\x38\x0e\xca\x84\x82\xc4\x49\x32\x2e\xac\x8a\x34\xa4\xf0\x7c\x6b\x8e\x57\xdf\x03\xff\xc4\xce\xda\xee\xcf\x1f\xa7\x01\x81\xb4\x09\x27\x41\xc5\x91\x2a\x9a\x46\x93\x22\xb9\x41\xe3\x45\xdf\x94\xc5\x34\x47\xf1\xe4\x7b\xf8\x1f\xee\xa9\xde\x03\x39\x34\xff\xea\xd5\x1f\xfa\xd1\x4f\x01\x2e\x4f\xda\xa0\xa6\x64\x54\x78\xd9\xc9\x24\x5a\x00\xa6\x44\x15\xc5\xa4\xb0\xc2\xa6\xfd\xb0\x07\x51\xc3\xed\xc1\xfb\xb6\x7a\xb5\x1f\xfd\x10\x3c\x75\x88\xb7\x9e\xca\xbe\x89\xbc\x05\x67\x5a\x63\x64\x59\x0d\x03\x80\x81\xbc\x20\x5e\x77\x86\xe8\x16\x97\x50\x6f\xc1\x04\xc5\x30\xf6\x97\x41\xbd\xdb\xe5\x98\xde\x13\x5b\xd0\x32\x96\x39\x68\x99\x16\x65\xae\x19\xb9\xe6\xef\x70\xba\xd5\x7f\xf1\x06\x84\xef\x0b\xc6\x02\x3e\x60\x77\x01\x35\x50\xff\x5a\xcd\x20\x3e\xc5\x0d\x14\x5d\x8e\x48\xbc\x21\x95\xfc\x60\xe7\x4e\xdf\xdf\xff\xee\x63\x57\xde\x71\x67\x7c\xed\x2d\x6b\xb1\xbf\xc9\x77\xa0\xf9\x3f\xcd\xfe\x91\xf4\x09\x74\xa5\x35\x2c\x84\x46\x2d\x72\x18\xb4\x68\x15\x89\xa4\xf9\x4c\x5d\x82\xdc\x98\xc0\xbb\x91\x4a\x3a\xa2\x49\x97\x03\xaf\x28\xbe\xec\x96\xb5\x71\x84\xa4\x7f\x26\xc6\xb7\x73\x27\xbf\x0d\xff\xdf\xb7\x10\x21\x8d\xdf\x79\x07\xe9\x2d\xbb\x1d\x31\xf6\xa7\x6c\xa7\x35\x06\x4a\x00\x30\xab\xa8\x7f\x52\x90\xf4\xca\x6c\xe1\x47\xd2\x47\xe8\x93\xe8\xfb\x0e\xe1\x7b\xf8\x1e\xf9\xde\x96\xfd\x81\x39\xca\xed\x42\xdf\x47\x01\xb0\xa8\xa8\xdd\xb0\x03\x4e\x00\xea\x23\x74\x19\x1b\x03\x15\x0d\x04\x66\x9c\x50\x83\x09\xc1\x8c\x24\x63\x77\x83\x3f\x09\x63\xf9\x47\x98\xa3\x6c\x8b\x30\x16\x7d\xff\x11\x75\xa9\x00\xcf\x3f\x92\x07\xff\x11\xfc\x50\x9c\xcb\x92\x07\xbf\x0d\xec\x06\x41\xf4\x7d\x79\xd6\xa2\x80\xe7\xa8\x6d\x9e\x20\x81\x5f\xc1\x4f\x63\x97\x70\x6f\xa3\xef\x63\xe8\xfb\x38\x58\x0b\x7b\x31\x8d\x60\x35\x55\x46\x68\xa4\x9a\x72\x34\xb6\xf1\xd3\xe8\xe7\xd9\x6d\x08\x76\x14\x82\x8d\x81\xb5\x11\x34\x03\x58\x0d\xb1\x84\x91\x1e\xbb\xd9\x9f\xd8\xfb\xc9\x3a\xe3\xe2\x3a\x1f\x10\x70\xf8\x72\x38\x70\xad\x25\x96\xd0\x31\x9a\xd0\xb1\x7b\xfc\x7f\x85\xb1\xfc\x23\xec\xfd\x6c\x8b\x39\x8e\x56\x78\x1f\x1a\xcd\x61\x1c\x80\x7d\x74\x59\x14\x11\x84\xc7\xa1\x7d\x40\xe3\xf0\x75\xf8\x0c\xb9\x8e\xc6\x03\x6b\x5a\xff\x72\x0d\x7c\xb6\x06\x1e\xaa\x81\x6d\x35\x70\x39\xfa\x43\xe8\xb0\x60\x5c\x02\x1d\x64\x0f\xfe\x40\xf6\xa0\x15\xed\x8d\x72\xee\x6d\x23\x82\xe2\xdc\x43\xf2\xe0\x3f\x81\x07\xb3\x9f\x93\x39\x87\x28\xe0\xf1\xf7\x5a\xfc\x3d\x82\xef\xc8\x83\x3f\x4b\xad\x26\x6b\x6b\xe2\x3b\xf2\xe0\xcf\xc2\x23\x04\xff\x27\x00\x30\xcf\xa9\xc2\xe8\xfb\x52\xbc\x2f\x9a\xdf\x53\xf8\x41\x77\xed\x63\x14\x0c\x91\x8d\x69\xc0\x7b\x8b\xce\x7f\x17\xb7\x1c\xc1\x74\xe2\xbd\xa5\xb6\x5c\xfa\x3e\x3a\x85\x11\xe0\x0e\xf0\x3e\xde\xc1\x62\x0b\x06\x1c\x04\xd7\x1f\xce\x81\xeb\xa1\x01\xb8\x56\x83\x8f\x0a\x71\x21\x7a\x9f\x23\xeb\x28\x15\xd7\x51\x43\xd6\xe1\xe0\x3b\xe8\x3e\xfa\x94\x38\x1e\xaf\x63\xbb\xb0\x0e\x7e\x7d\x1e\xfc\xd7\x54\x29\x81\xe7\xf8\xf5\x79\xf0\x5f\xc3\xeb\x45\xf8\x69\xcc\x73\x1c\xfa\x1e\x7e\x4a\xf8\x61\x17\x1c\x4b\xf8\x01\xd6\xe4\xf3\xd4\x2f\xd9\xcb\x10\xcc\xbf\xf1\xa9\x52\xbb\x96\x01\x4c\x63\xa3\x44\xe3\xb7\x68\xbd\xdf\x10\x9e\x2a\x13\x79\x6a\x8e\x80\x43\xc1\x53\x3e\x7e\x1c\x5d\xc6\x9d\x40\x1c\xd9\xc5\x10\x18\x70\x12\xae\x02\xb1\xb4\x6f\x6f\x14\xa2\x20\x34\x4b\xfe\x7b\x37\x0a\x37\x44\xe1\x25\x51\xd8\x17\x85\x69\xc4\x54\xe4\xcf\xf2\x15\x2b\xd0\xf8\xe5\xd9\x2f\xd8\xdd\x5c\x07\x9a\xa3\x9c\xcc\xb1\x05\x7e\x21\xcc\x11\xcd\xcd\x01\xd1\x1c\x7f\x63\xbe\x43\x30\x63\x04\x18\xf0\x18\x20\x94\xd6\x58\x24\x98\x2c\x5a\x25\x17\x21\xb4\x56\x88\xb4\x9e\x16\xf0\x84\x72\x78\xc6\xe0\xfe\xba\x04\x66\xac\x08\xd3\x29\xc0\x14\x51\x39\x3c\xfc\x23\x5c\x84\xec\x73\x85\x28\xf3\x7f\x14\xc6\x22\x99\x7f\x88\xf0\xd7\x58\x51\xe6\xbf\x52\xcc\xdb\x2b\xcd\x0b\x96\xc2\x63\xb0\x9c\xf0\x44\x85\xcc\x13\x78\xde\xaf\xb8\x8d\xd2\xbc\x60\x29\xf8\x1f\x9a\x17\xc3\x54\x92\x89\x1b\x90\x7e\xfd\x94\x9f\x86\xe7\x05\x09\x70\x75\x7a\xa4\xa7\xac\xcc\x6a\xaa\x44\xd1\x43\x25\x4b\xe3\xbb\x5e\x45\xd6\x22\x73\x30\x58\x0b\x6a\xa1\x99\x36\xd7\x78\x4a\xe7\x66\x3c\x1e\xb3\xa3\xc8\xe7\xb6\x39\x6c\x7d\x99\x80\x83\x36\x56\x56\x9a\xcb\x62\x61\xab\xd9\xda\x97\xa1\xd5\xe8\xa7\xc4\x6c\xc5\x15\xd1\x2b\x84\x06\xc5\xd8\x77\x93\xde\xaa\x12\x0a\x11\xe0\x47\x9f\xfa\xe6\xf4\xe6\xa2\x5d\x8b\xd2\xe3\x67\xf3\x1a\x69\xc7\x53\x91\x9f\x69\xbe\x18\x41\x21\x30\x7c\xe0\xe6\x5f\x74\xb6\xb8\x6a\x6a\x5b\xc6\x75\x0c\x6f\x7a\x43\x7d\xf8\xe5\x03\x6a\xca\xa3\x3e\x32\x9b\xba\x6c\x36\xf9\xf4\xe8\xcb\x07\x34\xfd\x9f\xa8\x1f\x9d\xdf\x7f\xfd\xfc\x03\xea\x4f\x9c\x93\x7b\x5e\x5b\xb4\xdc\x31\xd6\x9c\x1a\x52\xd9\xcc\xad\x6f\xf0\x31\x77\x7a\x1b\x1a\xbc\xfd\x5f\x51\x26\xfc\xfb\xc7\xf3\x7c\x0d\x0d\x3e\xaa\xa1\xff\xb4\xaf\x21\xa5\xee\x26\xf6\xec\x49\xc4\xab\xf8\xdd\xbe\x1a\xb0\x30\xdd\xe8\xb4\xa3\xf5\x56\x99\x74\xa0\x38\x1a\x0d\xf9\xfd\xc0\x64\x66\xd8\x3a\xb6\xb6\x38\x34\x31\x53\xec\x70\x96\x7a\x4a\xbb\x33\x1e\x33\xa9\x4b\x04\x8c\x55\x55\x66\x5a\x3d\x29\x43\x9b\x91\xf1\x3b\x29\xbe\xdc\x9c\xf7\x1a\x7c\x41\x86\x54\x7a\x3e\xb6\x70\x0b\xc8\x23\x45\x2a\xc5\x6b\x67\xca\xf2\x0c\x78\x0f\xa6\x29\xf7\x20\xf2\x39\xae\xa8\x30\xa3\x98\x14\x53\xd0\x2e\xfe\x85\xa2\x16\x43\x45\xc1\xea\xf1\x0b\x75\xbc\xed\x08\x29\x9e\xd0\xd9\xff\x80\x5b\x51\x77\x01\x2f\x9e\xf0\xe4\xac\x3c\x9e\xfc\x92\xda\x2a\xf2\xe4\xac\x3c\x9e\xfc\x12\x3e\x41\x78\xf2\x2a\x7e\x3d\xf5\x03\x81\xaf\x14\x75\x02\x4d\xbe\x6f\xe5\xd7\xc3\x1f\xd9\x71\xe8\xfb\x71\xc2\xf7\xe0\xb7\xe4\xfb\xef\x11\x7f\x1a\x55\x2e\x01\x1e\xe9\xb5\x7a\xb8\x05\xc6\x81\xfe\x71\x9a\x82\x71\x81\x89\x05\xf9\xb9\x08\x19\xf6\x7e\x6e\x05\x82\xfb\x0f\xb1\x41\x4b\xef\x7a\x86\xe8\xb6\x14\xf8\x80\x70\xb3\xce\x22\x70\xb3\xa8\x77\xd9\x83\xc4\xb6\x55\x0b\x36\x0d\xfe\x75\x80\x3c\x36\xa3\x79\xdf\x55\x15\x23\x98\x09\x22\x8c\x07\xee\xc4\x30\x9e\x9c\x3c\x7e\x82\x6c\xd3\x41\xb2\x96\x6a\x51\x1e\x05\xbb\xde\x2c\xcb\xe3\x04\xf1\x7b\x4e\x80\x47\xf6\x47\x09\xbf\x0d\xd6\x10\xfb\xd3\x8c\x6c\x70\x0e\x1e\xd9\x9f\x44\x50\xc2\xcf\x58\x09\x7c\x42\xc4\xd3\x4e\xf0\x57\xf0\x8f\xe0\xf7\x2c\xd1\xf7\x13\x45\x79\x87\x32\x7c\x0f\xd1\x57\x18\x3e\x2e\xc0\x9b\xb1\xde\xaa\x85\x13\x84\x71\xb4\x91\xbb\x4e\x1c\x17\x17\xc6\xe1\xeb\xd9\x7f\xc1\x1d\x02\x7d\x79\xf3\x6d\x03\xd7\x63\xfa\xb2\x57\x67\x2d\x79\xf3\x6d\xcb\x2e\x27\xdf\x63\x3b\xa1\x84\x3f\x4b\xb5\x11\x3a\xe6\xf0\x1d\x79\xf0\x67\xc1\xdf\xa4\x7d\x57\xa9\xc9\xbe\xd7\x88\xbe\xc4\x04\x61\xdf\x83\x79\x7a\x90\x5d\x4e\x7c\x89\x49\xe2\xbe\xbf\x4f\xf4\x29\xac\xcf\xe9\x53\x01\xcf\x2e\x09\x0f\xb5\x9b\x2a\x12\xf0\xf8\x0b\xf1\x8c\x93\xf0\x20\x7d\xba\x5b\xc0\x53\x67\x51\x9e\x9f\x4a\x4d\xe8\xaf\x11\xf7\xf7\x5f\x92\x3e\xc5\xef\x8e\x0a\x63\xc9\xf7\x02\xfd\x48\xab\xb2\x8f\x93\x79\x6b\x45\x9c\x0f\x0b\xf3\xba\x72\xf3\x92\x3e\xe9\x64\xde\xc9\x02\x0c\xb8\x5f\x98\x37\x94\x9b\xf7\x2b\x84\xff\x71\x32\x6f\xad\x88\x7f\xb7\x30\x16\xf3\x0d\x99\x77\xb2\x78\xae\xfd\x02\x3c\xe2\x1b\x25\xfc\x36\xf0\x2f\xc2\x37\x5d\x98\x6f\x64\x78\xc4\x37\x6d\x41\x11\x7f\x47\x1e\xfc\x59\xaa\x97\xe0\x1f\x85\xec\xb7\x12\xff\x59\x48\x64\x0c\x2c\xce\x7e\xc6\xde\x46\x7c\x87\x3a\x22\x63\x2f\x50\x37\x10\xdf\x81\xa6\xaa\x64\x3b\xd1\x92\xfd\x8c\x71\x72\xaf\x20\x98\x6e\xc2\x3b\x77\x82\x87\xb3\x2f\x11\x2f\x6f\x12\x6c\x1f\x04\xc7\x8b\x14\xb2\xf5\x48\x4e\x19\x19\x89\xb0\x3f\x08\x0f\xfd\x3a\x37\x41\x81\xe7\xa1\xec\x4b\xc4\xee\xbc\x06\x7d\xa0\xf4\x18\x75\xd8\x0f\x6b\xfc\xd0\xff\x44\xf6\x44\xda\x64\xf7\x74\xfa\x2d\x31\x86\x0e\x35\x41\x53\x13\x6c\x02\x96\xde\xde\x86\x86\x8a\x8a\xe5\xcb\x1b\x06\xa5\xfb\xf7\xd4\x75\x22\xdd\x61\x25\xdd\xf4\xef\xb8\xd5\xf2\x7c\x5b\xc0\xae\xac\xe0\x41\xdd\x02\xfe\x09\x2c\xbf\xa6\xf0\x4c\x8f\xdb\xc3\x78\x22\x50\x81\x0e\x68\x10\xbc\x7f\x20\x6b\x19\x88\xf7\x4f\x79\x78\x77\x13\xbc\xab\xa1\xf6\x5c\x78\x89\xcf\x72\x88\x7b\x07\x8d\x49\x8a\xbc\xdd\x07\x27\x62\x5f\x21\xc7\xff\xc2\x3b\xab\x84\xff\xa7\x08\x30\xe0\x13\xc1\x9f\x28\xcf\xf1\x8f\x80\x67\x97\x84\x47\x8e\x1b\x28\x7f\x21\x9e\x71\x12\x1e\xc4\x61\x27\x04\x3c\xa5\xf9\x78\x7e\x4b\xf0\x34\x88\x78\x04\x79\xa4\x8a\x72\xfc\x3c\x05\xd7\xdb\x23\x78\xa6\x11\x3f\x6c\xf7\x70\xc2\xcd\x0e\xd9\x0f\x43\x3a\xe7\xb7\x84\xd7\x1a\x44\x5e\x7e\x8c\x8c\x33\x21\x5e\x8e\x10\x5e\x9b\x26\x7c\x8f\xbc\x4c\x20\xc1\x13\x1d\xd5\x20\xea\xa8\xc7\x44\x1d\xd5\x42\x74\x14\x1e\x57\x4f\xfc\xa9\x69\xc2\x75\x3c\x0e\xf1\xf6\x16\x93\x10\x4b\x7c\x8b\x74\x94\x72\xbe\x6d\xe0\x61\xa2\x8b\x9e\x46\xb2\x90\x9b\x0f\xc9\xc2\x43\x42\x1c\xe3\x46\xe7\xf4\x2e\x59\x63\xa3\xb8\x0f\x1f\x09\x32\x5b\x9b\x5b\xa3\x27\xfb\x19\xf5\x2e\x59\x63\x8f\xb0\xc6\x91\x64\x8d\x65\xe2\x1a\x81\x1b\xd1\x24\x5c\x6f\x14\xe5\x52\xf0\xbb\x3c\x48\x0f\xbf\x4b\xe6\xec\x11\xbf\x5f\x2a\xcd\xc9\x0c\x55\x15\x49\x73\x6a\x4e\x23\xdb\x37\x89\x58\xa1\xa4\xcc\x3f\x68\x4e\x7a\x23\xbb\x47\x9c\x13\xc1\x80\x2c\x7f\x46\xf0\xcd\x2c\x12\x0c\xa6\xfd\x9f\x2a\xbd\x8c\xe7\x0c\x7c\x50\xf4\xe9\xeb\xf3\xf0\x4c\x63\x3f\x92\xf1\x9c\x81\x6e\xfe\x6f\x82\xff\x96\xc3\x83\xe9\x97\xf6\x80\xe8\xfd\x3f\x8a\xb1\xe4\x47\x64\xcf\xc9\x3a\xa4\xf5\x93\xeb\x4b\x85\x18\x6c\x24\xd9\x73\x70\x2d\xe2\x93\xcf\xc8\xf8\x94\xc8\x27\xf1\x01\x7a\x6f\x26\xae\x85\xc7\xd1\x08\x66\xba\x80\x3b\xfb\x19\x38\x86\xc7\xa2\xf3\xfe\x8c\x9c\x57\x4a\xe4\x8f\x0a\x01\x1e\xcd\x79\x1e\xb3\x51\x86\xff\x08\x8e\x12\xe6\x42\xe7\x9b\x83\x47\xe7\x78\xa9\xa0\xd3\xb0\x0d\x52\xc2\x8b\x36\x08\xc5\xa9\x1d\x79\xf8\xcf\xc2\xcf\x09\xfc\x06\x64\x83\x94\xf0\x67\xc1\x0f\x04\xff\xd3\xfc\xbd\x5c\x23\x81\x6f\x22\xdf\x7f\x2c\xfa\x2b\x8b\xf8\x7b\xe9\xa3\xf4\xc3\xe8\xfb\x19\xc2\xf7\x82\xbf\x82\xe0\xd7\xe7\xc1\x7f\x4d\xdd\x48\xbe\xaf\x41\xb1\x8d\x12\xfe\x6b\x21\xa6\x43\xf0\x1d\x79\xf0\x67\xa9\x9b\xc9\xf7\x69\xa4\x7b\x95\xf0\x67\xe1\x53\x02\x7c\xf6\x33\xae\x91\xe8\x9a\x26\x51\xf7\x3e\x26\x9e\x71\xa5\x7c\xc6\x8b\xb2\x9f\x20\x9d\xf9\x77\x71\xac\xa0\x33\xff\x88\x75\x2f\xf8\x1a\x8e\x1d\x04\xc7\x4b\xd4\xe3\x44\xf7\xd2\x32\x12\xe1\x8c\x30\x9e\xdf\xb0\xdf\xc8\x78\xb6\x80\x9d\xd9\x3f\x12\xdd\xfb\x1c\xf2\xb6\x4a\xd2\x66\x9a\x0a\x45\xa0\x29\x02\x23\x69\x8d\xa9\x33\x42\x94\xf0\x11\xab\xbb\xd3\x0f\x2c\x15\x0d\x16\xac\x76\x05\x3c\x17\x64\xff\x81\xe2\xf9\x47\x11\x9e\x21\x84\x1f\xee\x84\x37\xc1\xf1\x98\x1f\x4c\x39\x7e\xf0\x23\xbe\x7c\x96\x5d\x88\x60\x32\x02\x0c\xd2\xb7\x44\xaa\x6c\xb2\xfe\x01\x17\x08\xb1\xbd\x80\x87\xf0\xc6\x32\x61\x2c\xe2\xd7\x9b\xc8\x5e\x65\x44\xde\x10\x74\xca\xe6\xec\x3f\x54\x23\x89\xff\x30\x94\xe8\xc6\x11\xf0\x6b\xc4\x87\x8e\xc7\xa0\x83\x8d\xc1\x27\xb2\xff\x79\xcc\xe9\xe1\xac\x51\x88\xb0\x0b\x7a\xbc\x16\xe9\xf1\xd1\x44\x97\xce\x14\xe1\xf1\x03\x0c\xba\xa3\xb0\xc1\x1b\xe0\x9c\x04\x70\x50\xbc\xab\xd1\x8a\x26\x00\x5b\x5a\x47\x10\xdf\xe6\x70\xe7\xb0\x82\xc1\xf0\xae\xc6\x99\x07\x8c\xf7\x3d\x8f\x7f\x20\xde\x8d\x32\xde\xa5\x54\x1b\xc2\xeb\x4a\x1b\x28\xe8\x66\x63\x14\x6c\x8e\x3b\x04\xcc\x0d\x82\x6b\x9a\xc3\x9d\x94\x71\x2f\x85\xc8\x93\x01\x86\x63\x14\x5c\x56\xe1\x11\x90\x37\xe4\x70\xef\x92\x70\x23\x1f\x68\xae\x20\x93\xee\xdc\x19\x08\xb8\xc6\x49\xb8\x90\xdc\xae\x13\xce\xc0\x9f\x3b\x83\xcd\xc8\x07\x1a\x49\xce\x60\xa8\xb0\xd7\xf4\x3c\x61\x2c\x3a\x9b\xd1\xe4\x0c\x66\x8a\x67\xf3\x10\x91\xab\xa7\x91\x0f\x14\x25\xf3\x36\x8b\x38\x2f\x2e\xf4\x9d\xb3\x28\x62\xa7\xaf\x66\xc7\x21\x2f\x7c\x16\x43\xf4\xe9\x06\x9c\xb1\xd9\x90\xc4\x29\xa4\x1c\x8e\x8d\x12\x0e\xb4\xc6\x39\x62\xcc\x29\xc7\xa5\x22\x8e\xa4\x84\x03\x2c\x5d\x43\x70\xb4\x89\x38\xc0\xa5\xe8\x9f\x65\x84\x8e\x61\x22\x1d\xa3\x0a\xd7\x9f\xcd\xf0\xa3\xe8\x1d\x84\x8e\xd9\x8c\xa0\xef\xae\x16\xf4\x36\xd2\x67\x9b\x88\x1d\x6e\x21\x63\xaf\x83\xd1\xc2\xdc\x01\xa9\x77\x59\xce\x6e\x47\x30\xbd\xc4\x26\x5c\x57\xa9\xd8\x39\x41\x67\x32\x9b\xc8\xbe\xb5\x88\xfb\x53\x23\xe5\xab\xf0\x3b\xcd\xc2\x38\xc2\xbb\x97\x89\x36\xc6\x92\x07\xbf\x0d\x5c\x43\xec\xd6\x9b\xc8\x6e\xe5\xe0\x91\xbe\x7b\x51\xb0\x5b\x63\xe4\x98\x60\xac\xf0\x7d\x7b\x50\xd6\xb3\x7f\x66\x4f\x4a\x7a\x0d\x2c\xcd\xfe\x1d\xfc\x52\x3e\xeb\x17\xe5\xb3\xde\x03\x67\xe0\xce\x61\x68\x4f\xfd\x92\x1d\x10\xf7\xe3\x45\x71\x3f\x38\x6a\xcf\xc5\x94\xe8\x93\xfd\x9b\x3e\xc2\x9e\xb6\x92\xfc\x24\x1a\x7b\x15\xb8\x4f\xf0\x15\xca\x72\x7c\xe2\x42\xfe\x44\x9c\x7b\xcd\x1a\x83\xc3\x45\x3b\xfa\x01\xbc\x8e\xc8\xb3\x18\x0f\xa1\x38\xf8\x93\xec\xb7\xec\x64\x76\x32\x28\xc7\xd5\xe2\x5d\x5e\x4d\xa9\xb9\xb8\xb8\x34\xaa\xa7\xbd\x9c\xbb\xd2\x5d\x11\x35\xe8\x0d\xfa\xb9\x19\x83\x01\x84\x42\xb6\xb9\x99\x10\xe3\xf6\xf6\x65\xdc\x56\xc0\xcd\xcd\x30\xc0\x06\xda\xea\x14\xf5\x60\x84\xf7\x42\xc5\xb7\xfa\x14\x37\x9d\x58\xfc\x16\xb7\xd4\x97\x35\x55\x27\x07\xb9\x38\xe0\x6f\x85\x25\x62\x6d\x6c\x7c\xdf\x9b\xa1\x2b\xa7\xdf\x56\xeb\x59\xb9\xe9\xc1\x43\x8f\x3d\x64\x7a\xe0\xc8\x4d\x2b\x76\xbd\x1d\xbe\x95\xdf\xa9\xf9\xf5\xc6\xe0\x41\xa8\xda\xfb\xe7\x4f\x8f\xdd\xbe\xf3\x51\xfe\x23\x5d\xc8\x3b\xb2\xe4\xc1\x7b\xd6\x5c\x3e\xf3\x8e\x5d\x0b\x56\x7d\xf8\xdb\x9f\x0e\xa2\xe8\xfe\xad\x87\xbf\xdf\x78\xe7\x0d\x37\x3e\xe1\x30\xec\x5f\xf7\xf2\xbb\x62\x6e\xf7\x91\xbc\xdc\xee\x47\xd4\x5c\x31\xb7\xfb\x48\x5e\x6e\xf7\x23\xf8\x17\x01\x1e\xf1\xd8\xa7\xdc\x9f\x05\x78\xa4\x93\xb3\xd4\xbb\x82\x6f\x15\xc9\xc9\xa7\xb0\xef\x8b\xa4\x7d\x47\x30\xb6\x2c\xc9\xc4\x25\x72\x3e\x1a\xc2\xc3\xa6\x54\x1e\x09\x8f\x16\x52\xef\x10\x59\xc9\xf7\x45\xff\xcd\xac\xc9\x9d\x1f\x82\x09\x49\xfe\xbb\x7c\xf6\x84\x1e\x05\x1e\x8a\xfa\xdd\x60\x78\x94\x7c\x80\x60\xec\xe7\xc0\xe3\x95\xf1\xd0\x32\x9e\xea\x3c\x7a\x2c\xec\x19\x19\x0f\x0d\x7f\x14\xf1\x0c\x2d\xc0\xe3\x92\xf1\x30\x08\x4f\x9c\xc0\xf8\xf2\xe8\x79\x9b\xfd\x52\xc6\xc3\x60\x19\x23\x30\xf1\x1c\x1e\x7c\x2e\x44\x96\x4b\x44\x7f\x72\xae\x28\xd3\x4d\x42\x2e\x5d\x11\xd3\x93\xb3\x22\x32\xdd\x21\xfa\x39\x0f\x93\x33\xbb\x0e\x3c\x94\x3b\x33\xc5\x1e\xb1\xd4\x4b\xe2\xda\x3c\xe7\xdc\x23\x96\x8a\x88\x34\x45\xcf\xb9\xd7\xdc\xff\x17\x78\xb8\x73\xe2\xc9\xed\xb5\x4a\xc6\x63\x2b\xc0\x93\xdb\x6b\x95\x8c\x27\x54\x80\xa7\x48\xc6\xa3\x46\x78\x6a\x08\x4c\x59\x1e\x9e\x97\x15\x7b\xad\x96\xf1\x34\x14\xec\xf5\x29\x79\xaf\x77\xc1\x11\x70\x82\x45\x94\x05\xcc\xb7\xb6\xc2\xbd\xce\x88\x7b\x1d\xa3\x76\xad\x7b\x5f\x92\x0e\x39\x57\xa1\xcc\x19\x7f\x44\xed\x10\xf3\xbe\x8f\xe4\xe5\x8c\x3f\x82\x5f\xe7\x72\xe5\x44\x9e\x4a\x45\x59\xd9\x2a\xe8\xec\x4a\x45\xce\x18\xf9\x1c\x7d\xec\x26\x61\x2c\x86\x81\xdf\x08\x74\xd5\xe5\xe5\x0e\x10\x9e\x23\x12\x1e\x64\xe9\x9b\x07\xe4\x0e\x30\x9e\x23\xc4\x77\xe9\x14\x7d\x97\xeb\x05\x3c\xc5\x79\x78\x58\x2b\x39\xe3\x52\x51\xe6\x9e\x14\x6d\x58\xb9\x32\xdf\xce\xac\x25\x67\xdc\x29\xc2\x84\xc5\x3d\xad\x91\xf7\x54\xc8\xdb\xe7\xf0\x50\x83\xe3\xa1\xb7\x2b\xf0\x50\xe7\xc0\xf3\x3c\xe1\x95\x52\x51\x2e\x0f\x8b\x78\x52\x79\xf4\xa4\x08\xaf\x74\x8a\x30\x12\x9e\x96\x02\x7a\x5a\x65\x3c\x8c\x4c\x4f\x49\x1e\x3d\x27\x09\xaf\x74\x8a\x30\x2e\x11\x4f\x79\x0e\x0f\x3e\x5f\x22\x97\xa5\x84\x57\xae\x83\x01\x91\x57\x76\x08\x3e\x48\xb1\x32\xd7\xff\x08\x7d\x3b\x91\xcb\x4e\x01\x16\xec\xca\x3b\xfb\xef\x01\xa0\x7e\x20\x67\x5f\x29\x9e\xeb\x5d\x03\xce\x0c\xe7\xff\x86\x12\x5d\xfa\x1f\x11\x46\xd0\xa5\xd0\x9d\x3b\xb3\xef\x51\xcc\xa1\xcc\x3d\x7e\x04\xa7\x03\xf1\x1e\x52\x5e\xee\xf1\x23\x68\x17\xf2\x0b\xc8\x07\xba\x8d\x7c\x5f\x27\xf2\xe8\x87\x32\x6f\xff\x8e\xf0\x68\xb7\xf8\x3d\xc8\xe5\x23\x08\x9d\x42\xde\x20\x4b\x0f\x15\x74\x7e\xb5\x52\xe7\x7f\x46\xff\x8e\xf0\x68\xb7\xc8\xc7\x1e\x81\xb7\x2a\x73\xb6\x56\xc8\x3f\x78\x24\x3c\x5a\xdc\x6a\x4c\x90\xfb\xca\xbc\x7c\xcc\x8d\x84\x27\xba\x45\xde\x4a\x16\x9e\xc1\x00\x3c\x14\x9d\x18\x0c\x0f\xa2\x27\x87\x87\x3a\x27\x1e\xaf\x8c\x87\x96\xe9\x19\x92\x47\x4f\x17\xe1\xad\x6e\x91\xb7\x24\x3c\xa9\x02\x3c\x2e\x19\x0f\x43\x07\x44\x9d\x1f\xcb\xa3\xe7\x2f\x84\xb7\xba\x45\xde\x2a\x13\xf1\x94\xe4\xf0\xe0\x73\x21\xbc\x55\x27\xea\xfc\x0f\x45\x9d\x7f\x93\xa0\xf3\x13\xf9\x7a\xe8\x77\x84\xb7\xba\x45\xde\x7a\xa0\xf0\xcc\xb8\xd5\xd8\xf7\x87\xe7\x89\xbe\xfc\x1b\xc2\x99\x35\xe4\x9d\x19\x73\x00\xfb\xfb\x70\x3e\xf1\xb9\x56\x83\xef\x07\x1d\x3b\x02\x5e\xf2\x7f\x8e\x1d\x21\xfa\xa0\xc2\xd8\x3f\x4b\x63\x11\xaf\x64\x84\xb1\x6d\x85\x63\x37\x49\x63\x11\xaf\xf8\x14\x63\x8f\x48\x63\x91\x0e\x3b\x2e\x8c\xad\x29\x1c\xbb\x50\x1a\x8b\x74\xd8\x3e\x89\xa7\xb9\xd5\xec\x31\x61\x6c\x3e\x4f\x33\x07\x98\x9b\x64\x78\x69\x7f\x9e\x46\xf0\xca\x78\xf6\x23\xea\x03\x31\x5e\x7e\x24\x2f\x9e\xfd\x88\xd2\xe4\xe2\x59\x22\x03\x4d\xe2\xba\x04\x3b\x0c\xab\x72\xb4\xe1\x38\xf4\x28\x91\x81\x19\xa2\xac\x7e\x25\xe8\x04\x85\x0c\x60\x3c\xbf\x27\x7b\xbb\x5c\x8c\xc9\x3c\x02\x9e\x64\x1e\x1e\xe6\x7d\xb2\xb7\x2b\x84\x73\x81\xea\x41\xc7\x8e\x80\x2b\xff\x8f\xb1\x1c\x18\xd1\x03\x14\x63\xff\x2c\x8d\xcd\xd1\xdf\x52\x38\x76\x93\x34\xaf\x40\xbf\x3c\xf6\x88\x34\x16\x9d\xcb\x9b\xc2\xd8\xea\xc2\xb1\x0b\xa5\xb1\xe8\x5c\x1e\x94\xf7\xf9\xf7\xe4\x5c\x96\x17\xee\x33\xf3\x3e\x39\x97\x15\x79\xfb\x2c\xc4\x3f\x6f\x4b\xf1\x0f\xe2\xab\xb3\x8a\x98\x95\x73\x7a\xd4\x16\x65\xcc\x9a\x9d\x86\x7c\xff\xad\x24\x66\x9d\x4d\xee\x92\x8f\x50\x93\x88\x75\x5d\xb8\xc4\xa1\x27\x80\x18\x27\x92\xab\x32\x72\xd6\xc3\xc4\xb9\x46\xe4\xc6\x92\xb3\x9e\x2d\x7e\xff\xbe\x82\x86\x3f\x4b\x34\x20\xfe\x7c\xbd\xf0\xfe\xa8\x38\xef\x26\x71\x5e\xbc\x57\x6f\x0a\x67\x9d\xbb\x3f\x2a\xe2\x39\x22\xc7\x72\x77\xc2\x31\x02\x1e\x47\x3e\x9e\x27\x89\x4d\x9e\x2d\xda\xe4\x6d\x02\x9e\x22\x8b\xd2\x9f\x66\xa6\xb1\xfb\xac\x31\x7a\x3e\x86\x51\xed\x00\x77\x09\xba\x35\x59\x08\xb3\x5d\x86\x39\x03\x83\x02\x4c\xf3\xb9\x61\xee\x06\xbf\x12\x75\x50\xd2\xa2\xf4\x71\x73\x30\x9c\xea\xe0\x4a\x01\xa2\x39\x77\x9f\x69\x00\x9e\x7d\x60\x77\xa1\xdd\x1e\x80\xe7\xd0\xb9\xf0\x70\xdb\x64\x3c\xfb\xc1\x63\x83\xd3\xa3\x80\x39\x0c\x6e\x14\x61\xa6\xe4\xfb\x81\x6c\x97\xe4\x07\xaa\x76\x64\xeb\xb2\xf7\x01\xd5\xa3\x94\x8d\x01\x6d\x22\x9f\xe4\xc3\x70\xaa\x33\x7b\x9f\xc4\x10\x4e\x02\x81\xae\x23\x6d\xc1\x4e\x60\x67\xa3\x18\xb2\x64\x01\xd9\x9b\xac\x25\x7b\x06\x68\x8e\xd0\x02\x12\x02\xf3\x4d\x01\xcc\x41\xfe\x5f\x22\x8c\x53\x86\xb9\x8a\xcc\x33\x5b\xa6\x65\x1f\xff\x88\x08\x13\x96\x61\xb6\x17\xc0\x1c\xe2\xaf\x19\x80\x47\x88\xb3\x5a\x64\x98\xfd\xfc\x7f\xb2\x07\x0b\xe8\x29\x84\x39\xcc\x9f\x16\x61\xaa\x25\x18\x50\x89\xec\x4e\x94\xf0\xce\x62\x91\x77\x6e\x2c\xbc\xef\x24\xc2\x6c\x97\x61\xce\x80\x37\x04\x98\x61\xf9\x30\xc3\x64\x18\x4e\x75\x77\x4a\xcc\xd8\x2a\xce\xb3\x10\xe6\xa0\x49\x80\x19\x56\x00\x73\x9b\x02\x66\x5f\x9f\x00\x53\x5b\x00\x73\xbb\x02\xe6\x50\x6a\x20\x1e\xe4\x5d\xb0\x37\xb0\x6d\xe6\x38\xf2\xc3\xfe\x20\xac\x8c\x3f\x96\xbd\x03\x9d\x29\xf4\x8b\x67\x8a\xb3\x30\x05\x30\x67\xb2\x89\xec\x21\x0c\x13\x92\x60\x90\x39\xe0\x8e\xb2\xdd\x18\x06\x7b\xd5\xe4\xe4\x13\xd9\xe7\xd0\x2e\x52\x02\x22\x31\x7f\x15\x1f\x00\x77\x30\xab\x12\xe1\x42\x0a\xb8\x81\xf8\xf6\xc9\xf8\xca\x7f\x16\xdf\xa1\x41\xf1\x75\xf1\x63\xe9\xfd\xe4\xfc\x96\xe4\xc9\x3e\x8c\xe7\xce\x46\x80\xd9\x2e\xc3\x9c\x81\x6e\x01\x26\x71\x6e\x98\xbb\xc1\x66\x31\x1f\x2b\xc7\x9c\x05\x30\xe8\xfc\xc4\xb3\x49\x28\xf6\x1d\xc3\xfc\x45\x81\x67\x1f\xb8\x53\xc4\x53\x92\x87\xe7\x0d\x05\x9e\x43\xab\x07\xc5\xc3\x04\x88\x5c\x2f\x11\x65\xff\xae\xc1\xe8\x51\xc0\x70\xaa\xc3\x6b\x04\x88\xd1\xf9\x7c\xc0\xfd\x9b\x6d\x45\xfb\x58\xa1\xe0\x83\x3d\x85\x7c\x50\x00\x83\xf9\xe0\x60\x21\x1f\xa8\x5d\xe4\x3c\x2a\xfe\x2f\x3e\x28\x80\x3b\x27\x1f\x14\xc0\x9d\x93\x0f\x0a\xe0\x06\xe7\x83\x51\x18\x8e\x6b\x51\xc0\xed\xcf\xae\x21\xd2\x9e\x4f\xdf\x40\xb8\xc3\xd9\x49\x22\x5c\x93\x02\xee\xf2\xec\x67\x94\x9d\xf0\xd5\x05\x64\x6f\x77\xdc\x47\x38\xc6\x27\xe5\x01\xf1\x75\x0b\x39\x43\xe1\xfa\x99\x22\x72\x3d\x22\x5d\x4f\xa0\xeb\xf3\xe4\xeb\x78\xb7\x66\x8b\xe7\xe7\x93\xcf\x6f\x6a\x01\xcc\xc1\x6c\xbd\x08\x13\xb1\xe4\xee\x01\x7c\x46\x9d\x56\xcc\xb3\x6f\xa7\x00\xe1\x56\x9c\x31\xa6\xe5\x8c\x02\xcf\xa1\xec\x05\x03\xf0\xac\x41\x3a\x23\x4e\x78\x45\xc0\xb3\xff\xc1\x3c\x6a\x24\x3c\x74\xa9\x02\xe6\xf0\x2f\x04\x98\xe6\x7c\x7e\xa2\x9f\x23\xbc\x52\x59\xc8\x4f\x7a\x05\x3f\x15\xc0\xc8\xfc\x64\x52\xf0\x13\xf3\x05\x39\xd7\xca\x01\xfc\xa4\xcf\x3f\xff\x02\xb8\x1c\x3f\x99\xf2\xf9\xa9\x00\x2e\xc7\x4f\xde\x9f\xc5\x77\x68\x50\x7c\x23\x31\x1c\xe1\x93\x4a\x99\x9f\x2e\x13\xf9\x44\x49\x5f\xc7\x00\xb8\xc3\xd9\x09\x22\x5c\x5c\x01\x27\xc4\x5b\xfb\xa4\xf8\x06\xe9\xa9\x5b\x0b\x73\x0b\x22\xcc\x76\x19\xe6\x0c\x34\x16\xde\x03\x2e\x80\x41\x76\x66\xbd\x60\xed\x8b\xf3\xfc\x86\x7c\x98\x83\x43\xf3\x22\xbb\x41\x61\xf6\x6d\xc8\xcb\x1e\x0d\x0a\x73\x68\xc6\x40\x3c\x2b\x91\xef\xdb\xc7\x8e\x43\xeb\xaf\x93\xf8\x01\x79\x06\x98\x1f\xa8\xa0\x74\xd6\xb7\x14\xc0\x20\x69\xb9\x1e\x73\x83\x60\xf2\x85\xfd\x89\x65\x3f\x53\x6d\x21\xe7\x52\x27\xf3\xc3\x14\x72\x2e\xb4\x80\x48\x84\x1b\x33\x00\xee\x60\xb6\x5c\x84\x0b\xe7\xe0\xb2\xfd\x68\xce\xdf\x89\x70\x95\x22\x3f\x48\x70\x95\x0a\x7c\xc5\x03\xe0\x0e\x65\xa9\x81\xf8\xc0\x2c\xb4\x17\x17\x13\x7d\x70\x99\xa0\x0f\x16\x10\x79\x0f\x4b\xf2\x2e\x5c\xdf\x2e\x5e\xc7\x3e\xc2\xab\x40\x71\x37\x59\x81\x63\xbb\x8c\xe3\xee\x61\x82\x7c\x85\x15\xfb\x59\x08\x73\xf0\x5d\x01\xa6\xac\x00\xe6\x21\x05\xcc\xbe\x95\x02\x4c\xb0\x00\xe6\x26\x05\xcc\xa1\xca\xc1\xf1\x7c\x49\xe4\x5d\x80\xd9\xbf\x72\x70\x7a\xfe\xa1\x80\x39\x2c\xd2\x3c\x5c\x01\x03\x91\x1f\xf1\x15\x91\xf7\x61\x92\xbc\xf3\xdf\x0a\xf2\xee\x96\x78\x60\x12\x00\xaa\x8d\x64\x9f\x87\x51\x33\xc4\x73\xab\x11\xe5\xce\xad\xd8\xe7\x89\x03\xe0\x0e\xc9\x72\xac\x84\xeb\xc2\x70\x44\xee\x24\xb8\xc3\x88\x5f\x04\xb9\xab\x51\xca\x67\xf6\x33\x76\x1c\x39\xb7\x2b\x04\xee\x84\xe7\x0b\xe7\xd2\x98\x3b\x17\x01\x66\xbb\x0c\x73\x46\x7a\xf6\xa8\xf5\xdc\x30\x77\xc3\x0e\x51\xc7\x36\xca\x3a\xb6\x10\xe6\x20\xf8\x46\x84\x69\x3d\x27\xcc\x3e\xb8\x45\x84\x49\x9e\x13\xe6\x10\x6c\x1c\x1c\x0f\x39\x17\x01\x66\x3f\x5c\x33\x38\x3d\x0a\x98\xc3\x70\x92\x08\xd3\x23\xc3\x20\x6f\x97\x1b\x8d\x65\x93\x9e\x25\xcb\x6f\xb9\xa0\xcf\x2b\xa4\xb3\x3b\x58\x00\x83\xe4\x77\x1f\x39\xdd\xea\x9c\xfc\xb6\xa2\xf3\x58\x89\xcf\x8d\x9e\x25\xcb\xef\x05\xe2\xb9\x55\x28\xce\x63\xfe\x00\xb8\x83\xd9\x11\x22\x5c\xb5\x42\x7e\x79\x34\xe7\x43\x22\x9c\x24\xbf\x15\x22\xdc\x10\xa5\xfc\x0e\x80\x93\xe4\x37\x0f\x1f\x18\x8e\xe1\x30\xbf\xc8\x70\xfb\xb3\x2b\x45\x7e\x51\xd2\xd7\x3e\x00\xee\x70\x76\x9c\x08\x37\x2a\x4f\x9f\xe3\xf8\x6d\xbf\x1c\x77\x9d\x00\x37\x17\xe6\x9c\x07\xc0\x9c\x86\x25\x03\x60\x84\xd8\x62\xbf\x1c\x5b\x9c\x00\x57\x09\xbc\x97\xcc\x87\x19\xa2\x80\x39\x0d\xb2\x03\x60\x04\xdf\x74\xbf\xec\x2f\x9e\x00\x4f\x0b\x30\xb1\x73\xc3\x9c\x86\xa9\x01\x30\xc8\x07\x80\xfd\x04\x46\xf0\x01\x4e\x3c\x4b\x20\xbc\x4a\xbf\x67\x8d\xe2\xfa\xe9\xd6\xfc\xeb\x82\xcd\xd8\x2f\xdb\xb0\x13\x92\x9d\x0b\x17\xda\xb0\x1c\x8c\xbc\x2f\xe1\x42\x5d\xb9\x5f\xd6\x3b\x27\x96\x28\xa2\xfe\x01\xd7\xf1\x9e\xfc\x30\x20\x2f\x20\xc8\xd1\x7e\x99\xff\x4f\xc0\x6b\x05\x98\x86\x73\xc3\x9c\xa6\x8c\x03\x60\x5a\xf8\x91\xb9\xfc\x82\x39\x8e\x6c\xf7\x36\x9c\x0f\xa1\xeb\xb1\x4f\x2e\x5f\xdf\x2e\x5f\x3f\x03\x55\x3f\x7b\xfd\x6e\xfc\x64\xcd\x39\xaf\xc7\x54\x07\xe7\xc8\x57\x07\x1d\x4f\xf2\x09\x3f\x33\xfe\xd0\xd8\x41\xc6\x4b\x39\x02\x34\x7e\x3f\xce\x09\x16\x8e\x97\xaf\xc7\x54\x87\x2f\xcf\x1b\x2f\xbe\xdf\xd2\x25\xdd\xff\xa1\xeb\x45\xc9\x90\xf2\x08\x74\x89\x22\x8f\x30\x28\xac\x94\x4f\xa0\xe3\x72\x3e\x81\x1f\x99\xcb\x15\x10\xb8\xed\x40\x99\x57\x60\x04\xa4\x42\x5e\xe1\x1c\xb0\x52\x7e\x81\xa1\xe3\xb9\xfc\x02\x99\x7f\xf6\x00\x5a\xa5\x3c\x03\x43\xd7\xe5\xf2\x03\xe7\x80\x95\xf2\x0d\x4a\xbc\x04\x56\xca\x25\x28\x60\xa5\xbc\x83\x92\xde\x73\xc1\x4a\xf9\x07\x86\x6e\x93\xf3\x0f\x09\x7e\x64\x2e\x7e\x25\xbc\x75\x17\xce\x4b\xd2\xf5\x4f\x09\x67\x27\x5c\xdf\x2e\x5f\x27\xb1\xeb\xcf\x5c\x17\x78\xeb\x5c\xd7\x63\x38\x66\x15\xae\x8a\xd7\xfe\xa2\x18\x4b\x62\xd5\x82\xb1\x6f\x28\xc6\xa2\x38\x55\x39\x36\x17\x7b\x12\x9e\x1a\x40\xb7\xe2\x7a\x0c\xc7\xa6\xf2\x58\x0f\x3f\x52\x19\x6f\xe2\x55\xe3\x18\xc2\x82\x78\x8e\xba\x12\x0d\xcf\x8b\x4d\x07\xc0\x92\x58\x42\x09\x9b\x8b\x51\xf9\x91\xca\x58\x11\xef\x06\xf6\x1d\x30\x2c\x8d\x5f\x35\x1d\x10\xab\x0e\x80\x27\xb1\x45\x1e\x7c\x5e\xcc\x3a\x00\x7e\xdf\x00\xfc\xe5\x3f\x8b\xff\xd0\xcf\xe2\x4f\x62\xf8\x5c\x6c\x8a\x77\x35\xbb\x50\x58\xeb\xa0\xf4\xd7\x0d\x80\x3f\x9c\x1d\x56\x00\x9f\x52\xfa\x42\x48\x8e\x64\x5f\x08\xef\x3a\xf6\x85\xb0\xa4\xc3\x7b\x14\xd7\xb7\xcb\xd7\x89\x1f\xf4\x33\xd7\xef\x86\x23\x7e\xf6\xfa\x41\xf0\xed\xcf\x5e\xdf\x07\x6f\xfc\xd9\xeb\xc4\xef\x29\xbc\x2e\xf9\x33\x78\x77\xf0\x33\x36\x3f\x73\x9d\xf8\x3b\x8a\xeb\x37\x22\x5e\x52\xf8\x31\x58\x32\xf1\x9b\x5a\x0a\x9f\x87\x1a\x26\xfb\x3c\xe7\x80\x95\x7c\x1f\xaa\x4d\xe1\xfb\xf0\x23\x95\x3e\x0d\x86\xa5\xf7\xe5\xfb\x40\xf4\x30\xa5\x0f\x74\x4e\x78\xd9\x17\x92\x34\x84\xe0\x0b\x21\x5a\x14\x3e\x0e\xa1\xe5\xef\xf9\x3e\x11\x3d\xe6\xff\x77\x78\x30\x1c\xc3\xe7\x7c\x1e\x05\xbc\xec\x23\xe5\xd1\xdf\x7e\x4e\x78\xd9\x57\xa2\xa7\x0f\xf0\x95\x2e\x93\xfc\x20\x6a\x97\xe8\x9b\x88\x8f\x97\xe4\x60\xf0\xf3\xbf\x22\xcc\x16\x09\xa6\xa6\xd0\x0e\xef\x97\xed\x18\xf1\xb9\x0a\xed\x18\xfd\xbc\x78\xbd\xd0\x3e\xe6\xc6\x11\x7f\x43\x79\x9d\xd0\xb7\x50\x9e\xfb\x4e\x31\x76\xcb\xa3\x8f\xe0\x58\x28\xe1\x10\x60\x72\x38\xc4\x5c\xf3\x29\x29\xd7\x4c\xed\x12\x9f\x2f\x50\x3c\x1b\x21\xc2\x74\xc8\x30\x5b\x60\x97\x00\xe3\x2c\x80\x91\x9e\x37\xc2\x3e\x4b\x76\x56\xf6\x5e\xcc\x6f\x8e\xc2\x5c\x7d\xa7\x9c\xab\x3f\x7d\xf5\x3d\x39\x88\x81\xef\xa3\x22\xfe\xc7\xf9\x4e\x08\xcf\x63\x92\xd4\x45\xec\x3e\x60\x06\x25\x69\x27\x6d\xe4\x68\x8b\x15\x1c\xe6\xc8\x4b\xc5\x6d\x5c\x1f\xb7\x81\x63\x39\x90\xe8\xed\x3d\x43\xba\xa5\x88\x2f\xd5\x73\x2a\xfc\xaa\x77\x35\xd5\x50\xdf\x48\xd1\xd5\xc3\xd6\xec\xd4\x5d\xe7\x0f\xfb\x53\xec\xbe\xf6\xfa\xde\x65\x95\x6d\x65\x8d\x36\xbb\xdd\xef\xab\x4c\xe2\x3a\x03\xab\xf8\x91\x70\x69\x76\x07\xc2\x1f\x4e\x9b\x34\x34\x6d\xb4\x58\x0d\x00\xe0\x7e\xdf\xb8\x33\xef\x4b\x62\x23\x16\xa1\xbe\xad\x4d\xac\xdd\x63\x82\x76\xa1\x25\xe9\x4b\x55\x95\x74\x64\x55\x98\x09\xfa\x6b\x5c\x25\x9d\xfc\xc8\x44\xcc\x1c\x38\x7d\xb4\xb4\xc8\x5d\xe3\x2a\x42\xb4\x0f\x45\xb4\x8f\x24\xb4\xdb\x8e\x89\xa4\x23\x62\xcf\x45\x2a\x7c\xf3\x67\x49\xc5\xb9\x37\xa6\x8f\xa6\xd9\x85\x66\x8e\xba\xf3\x6f\xb8\x06\xc1\xbd\xcc\x52\x7a\x16\xb7\x81\xbc\x6f\x9f\x00\xa3\xd2\xa5\x7a\x2b\x07\x40\xd8\x4a\xd7\x54\x55\xd5\x56\x06\x4c\x25\xa1\x92\x44\x09\x5d\x52\x52\x16\x36\xb9\x43\xee\x84\x7b\xaf\x9b\x71\x3b\x34\x1a\x13\x2d\x74\x4b\x3e\xd9\x5b\x57\x57\x97\xe8\x4d\x2a\xeb\x3c\x9c\xbb\x32\x40\xb4\xb8\x9a\x92\x5b\x5b\x07\x29\xb1\x9f\x35\xf5\xa7\xa6\xf2\xf2\xa1\xcd\x65\xe5\x4d\xfc\x9e\xa6\xf2\xb2\x61\xad\xf1\xf2\x26\x08\x6b\xba\xda\x9a\xc3\x62\x63\xeb\x9a\x31\x6d\xcd\x45\x42\x33\x6b\xe6\xe5\xf2\xe6\xd6\x78\xc5\x90\xa1\xe5\xe5\xcd\xc3\xca\xca\x87\x0e\xbd\xaa\xa2\xa1\x02\x37\xb5\x46\xbf\x48\x33\x6b\xd9\xf6\xef\x97\x6d\xf4\x09\xf0\x9b\x81\xbe\x01\x7e\x9e\x81\x5c\x2f\xf4\x19\x72\xe3\x4e\xe3\x67\x51\x15\xd7\x71\xde\x99\x25\xb2\xb0\x44\x94\x17\xf1\xde\x9e\xc2\x7f\xc7\xf6\x9f\x93\x60\x88\xbc\xbc\x95\x87\xe3\x00\x00\xec\x17\xc4\xae\x97\x8a\xde\xd1\x89\xec\xf9\xd9\xdd\xc4\x9e\xd3\xa2\x0e\x9e\x3e\x00\xe6\x74\xb6\xaf\x00\x06\xe1\x51\x4d\x14\xfc\x83\x73\xe2\x99\x36\x00\xe6\x74\xb6\x37\x1f\x26\xfb\x29\xd2\x69\x8a\xf7\xd9\x90\xcc\x1c\x01\xb8\x46\xd1\xab\x4c\x98\x66\xd9\xed\x88\xef\x9c\xa0\x2c\xed\xb6\x22\xde\x63\x5c\x0e\x87\xdb\x06\x2c\x05\x72\x93\x3c\x53\x27\x1e\xfe\x20\xfc\x48\x4a\x41\xc0\xab\xca\x1a\x2f\xbd\x4d\x77\x3d\xe2\xca\x76\xb8\xe6\x56\xd5\x53\x16\x8e\xdd\x3e\x34\x79\xde\xca\xaa\x1c\x73\xf2\xf7\xc1\xa2\x28\xff\x56\x58\x9a\xbb\x29\x37\xb7\x05\xe8\x68\xc6\x65\xb7\xbb\x6d\x46\x8b\x89\x0e\xd1\x6d\x74\x1f\xbd\x81\x66\xe9\xc2\xb9\x95\x13\x23\x66\xb3\xe1\x72\x10\x34\x7c\x77\xf5\xad\xc2\xcc\x35\x65\x8d\x45\xdc\x9a\xa7\xb8\x9f\xd8\xc8\xdc\x4b\x15\x33\x0f\xe5\xff\x11\x86\x25\x51\xfe\x3d\xb2\xee\x3f\xa2\xb9\xd7\x71\xdb\xd0\xdc\xa5\x20\x99\x0e\xa0\x65\x7b\x99\xb2\x58\xac\x3c\xea\x0c\x04\x8a\xbd\x16\x50\xb0\xf8\xd7\x4e\x60\xfe\x97\xd9\x7f\xe0\x0e\xb8\x06\x65\x79\xf8\x7d\x6e\x47\x7e\x7f\x0e\x4e\x1f\xb0\x45\xaa\x02\x4e\x97\x73\xe0\x7f\x22\x36\x86\xc4\xa5\xd4\xae\x43\x79\xef\xab\x80\x09\xe8\xfa\xeb\xc4\xbe\x08\xd7\xb7\x1c\x06\xb9\xa7\x84\xd0\xf5\xf3\xd0\xf5\x7b\xd9\x2d\x72\x0e\xfd\x78\x76\x76\xf6\x05\xe1\x59\x7a\x21\x5a\x17\x73\x5d\x85\x70\xcf\x9e\x03\x2e\x8d\xe0\xce\x12\xfe\x17\xe6\xbb\xf3\x54\x3e\x3d\x2b\x48\xae\xbd\x59\x8e\xa3\x6f\x7d\xe9\x69\x01\x8b\x78\x9b\xa8\x41\x7c\x07\x72\x0a\xb1\x29\x95\xa2\xdd\xac\x13\xee\x8f\xeb\x73\xf6\x02\xc3\x4c\x25\x36\xa5\x52\xb4\x9b\x09\x01\x46\xf1\x4c\x3e\xf2\x7e\x98\x18\x2b\xe4\xa8\x25\x19\x59\x94\xdd\x45\xf2\xf1\x92\x8c\xf4\x10\x98\x56\x05\xcc\xe9\xec\x1c\x41\x46\x04\x18\x40\xc1\x22\xc4\x13\x55\x0a\x59\xe0\x0c\x40\x90\x05\xda\x62\x32\x86\x8c\x6d\xc6\x3e\xe3\x06\x23\x6b\x2c\xe4\x47\xb1\x2e\x09\x29\x55\xe5\x52\x55\x43\x56\x10\x86\xa2\x69\xcd\xb1\xc4\x88\x32\xdf\xf9\xba\x39\xbd\xf0\x4f\x44\x1a\x98\xf7\xc7\xcf\x8b\x86\x5b\x7d\x66\x9f\xad\xb6\xb8\x2d\x38\xbd\x4f\x96\x05\x32\xf7\x3c\x85\x2c\x90\xb9\xb1\x2c\xfc\x3f\xce\x2d\x08\x43\xde\xdc\x2a\xee\xf2\xa7\x54\x3f\x0d\x98\x5b\x12\x06\x0a\x7c\x87\xe6\xbe\x17\xc9\x82\x4b\x90\x85\x60\xd4\xad\x61\xca\x1c\x8e\x72\x3b\xab\xd7\x5b\x34\xc0\x67\x8a\x85\x62\x6d\xb1\xbe\xd8\x06\xfc\x38\xd3\x60\xb2\x30\x28\xef\xb3\x85\xb4\x51\xc7\xce\x21\x01\xfc\x0e\x05\xb9\xec\xf5\xf9\xec\x7f\x5f\x3e\xd9\x52\xee\x64\x03\x91\x85\xcb\x04\x59\x98\x93\x7f\xef\x0a\x5f\xdf\x44\x64\x41\xb8\xbe\xa5\x8f\x5c\x0f\xe6\xe7\x56\xb6\xc8\xb9\x97\xe3\x45\x22\x87\x37\xc9\xbc\x39\x00\xe6\x59\xd3\x00\x98\xec\x19\x7e\x1c\xfd\x2b\x12\x6f\xac\x04\xca\x7b\xeb\x54\x2e\x47\x23\xc2\x6c\x97\x61\xce\x40\x0a\x14\xbc\xaf\x46\xe6\x7a\x9c\xc8\xd2\x65\xa2\xbd\xd9\x02\x14\x2b\x92\x61\xbe\x20\xf2\x24\xe4\x83\x6e\x05\x3b\xb3\xa2\x44\x95\x2b\xe5\x52\x78\xe6\xe4\x94\xfc\xcc\xc9\xae\x81\xcf\x9c\x88\x30\x1d\x32\x8c\xe4\xa7\x29\xdf\xb1\x40\xea\x83\x7b\x92\xc8\xd4\x30\x31\x1b\x71\x22\xbb\x42\x90\x29\xb7\x24\x53\x63\x07\xc0\x9c\xce\x4e\x29\x80\xc1\xf7\xe0\x2f\x23\x72\x97\x2c\xb8\x57\x46\x09\x31\x30\xa0\x21\xc7\xcc\xa1\xbb\xe4\x5a\x40\x35\x69\xb7\xde\x1a\xf0\x58\xe9\x20\x72\x50\x42\x1a\x87\xc3\x64\xf2\xd1\xd8\x29\xa1\xdc\x98\xfb\x5f\x2a\xa8\xda\xf4\x7f\xd5\x27\xa2\xbb\xea\x62\xb8\xfe\x50\xac\x8e\x5f\x96\x8c\xc6\x1a\x1a\x62\x25\xf5\xab\xef\x51\x3d\x15\xe2\x98\xa7\x63\x0d\x8d\xd1\x78\xb2\x3e\x16\x6d\x6c\x88\xc5\xea\x93\xd7\xc0\xb6\x28\xff\x0c\xa9\x4f\x34\x18\x4d\x3e\xf7\xff\x1f\x68\x22\xf2\x39\x18\x4d\x3e\xf6\xfc\x63\xdc\x3f\x07\xd2\x14\x86\x23\xa2\xfc\x6f\x89\x7f\xdb\xca\xcc\xa1\x2c\xec\x7e\xc0\x02\x7f\xda\xc8\x20\xb9\x36\xd1\x90\x36\x81\x10\xbe\x39\x98\xe8\x7d\xa9\x97\x38\x9f\xb8\x47\x34\xd1\x3f\xaf\x09\x2a\x67\x8e\xa8\x63\xe4\xf8\x73\xbf\x1c\x3f\x9e\x20\xef\xc3\x15\xc4\x97\xf4\x09\xf1\x7a\x61\xdc\x9a\x1b\x77\x9a\xb2\xe6\x5f\x27\x39\xc6\x85\x52\x8e\x91\xba\x13\x0a\xcf\x15\x2b\x9f\x85\x12\x70\x2c\x94\x70\x08\x30\x0a\x1c\x7f\x25\xf7\xa9\xc6\xc9\xf7\xa9\x38\xd5\x89\x5d\xbb\xc9\x3d\x34\x5a\x8e\x43\x9d\xf8\x39\x4b\xe9\xb9\x55\xc2\x6d\xc1\x6c\x21\xcc\x9b\x24\x5f\x3e\x4e\xce\x6f\x23\x3c\x77\x10\x2d\x5f\x2d\xc3\xe0\xf7\x43\xd9\x0d\x18\x0f\x8a\x7d\x09\x1e\xbe\x3f\x5b\x00\x03\x2a\x11\xbd\x32\x0c\xa1\xf3\x20\x3e\x03\xf0\x3d\x3a\x83\xa1\xd2\x19\x00\x9a\x53\x0d\x7e\x06\xc4\x29\x81\xdf\xb3\xe7\xbf\xce\xf1\x3f\x32\x73\x24\x5d\x0b\xa1\x9e\x09\xc3\xaf\x88\x9e\x2f\x4a\xdb\x90\x92\x47\x8e\x3e\x5d\xa0\xe0\x65\xa7\xbf\x50\x81\x42\xbd\x42\x4f\x16\xea\x73\x00\xb3\x7f\xe1\xcf\x82\x72\x56\x85\xbc\x7d\xcb\xe3\x90\xa2\x18\x4c\x92\xd0\xa1\x06\x11\x64\x89\x58\xca\xa7\xb2\xaa\xff\x7d\xc2\xb9\xf1\x3b\x2d\x45\x08\xf6\x3d\xf6\x5a\x60\x44\xbc\xed\xd2\x6b\xd1\xae\x31\x10\x9a\x0c\x6a\x1d\x6b\xa4\x58\x5c\x44\x49\xa3\x82\x68\x74\x52\xe8\x28\x21\x56\x8f\x15\xcb\xaf\x46\x2c\xaa\x78\x2a\x9e\x72\xa5\x5c\x2a\x97\x2a\x5e\x3e\x75\x43\xea\x81\x07\xc4\xff\x36\xf0\x67\xd9\xcc\x55\xa9\xfb\xef\x6b\x7a\xf0\xc1\xa6\xfb\xee\x4f\x5d\x85\xe7\x7a\x83\x3f\x0b\x8f\xa0\xb9\xb4\xa0\x2e\xed\x54\xd3\x34\xd0\x50\x88\x34\x96\xe5\x74\x8c\x0a\xa2\xbf\x9c\x16\xb9\x58\x09\xab\x50\xfe\x15\xcd\x54\x97\x57\x20\x15\xcd\x15\x41\xc4\x87\xe3\x29\x78\xe4\xdd\xd4\xa6\xef\xbb\xe1\x98\x4d\x29\xe6\x81\x37\x53\xeb\x7e\xb8\x88\x7d\x7f\x5d\x13\x4e\xe2\x42\x7e\x1c\x5a\x4f\x29\x99\xa3\x26\xed\x50\x33\x0c\x87\xe2\x33\x8e\x03\x50\x47\x6b\x58\xf4\x17\x92\xd5\x28\xa6\xa8\x53\xb4\x76\x41\xe8\xd1\x3a\xd0\x6a\xc2\xa5\xdd\xdf\x6f\x4a\xbd\x8b\x66\x81\x63\xd0\x42\x76\xae\x4b\xbd\xf9\x76\xd3\x3a\xc2\x33\x5f\xc3\x07\x19\x23\x65\xb6\x72\xaa\x77\xf0\x7c\xd2\xbf\xd1\x5e\xbb\xd3\x1a\xc0\x52\x0c\x4d\xfd\x26\x43\x3f\x01\xb5\x40\x6c\x59\x89\x28\x77\x84\x1b\x18\xe3\x8f\x1f\x52\x66\x5c\xd2\x51\x18\xa3\x8a\xff\xdf\x63\x54\xf1\xef\x4f\x2b\xc7\xa8\x15\xf3\xd0\xe7\x18\xa3\x36\xfe\x57\x9c\x07\xf1\xee\x75\x68\xe0\x31\xf6\x26\x33\x07\x7f\x41\x68\xff\xb2\xff\x6b\xc6\x9c\x9d\x63\x8d\xe3\xbb\x3f\xfc\x0f\x66\x0e\x90\xde\xed\x88\xdd\x3b\xa8\x25\x6c\x37\xe2\xc5\x48\xda\xca\xe9\x74\x80\x70\xa3\x71\xff\x2c\x9a\xd9\x93\xa1\x91\x76\xae\x90\x5a\x58\x5b\x05\x76\x4c\x39\x38\x87\x3d\x48\x91\x3a\xb5\x31\x58\x7d\xe0\x96\xdf\xc4\x13\xf1\x8e\x86\x96\x4e\xfa\xf3\x5f\x1c\xab\x18\xdf\x7c\x91\xdf\x1f\xa8\x28\x6f\x1c\x32\x93\x9c\x09\xac\x45\xf8\x2f\x14\xf1\xdb\x38\x84\x5e\x47\xe3\x09\x10\x72\x23\xbd\x7f\x96\x51\x9a\xc0\x85\xbb\x7a\x0a\x7e\x7d\x83\xc2\xaf\xa7\x2e\xcc\xe1\x67\x1e\x18\x04\x3f\xb8\x9f\x3f\x05\x3f\x00\xaf\x8a\xf4\x23\xea\x75\x3a\x05\xfa\x7d\x12\xfd\xa4\xec\x71\x6d\x4d\xb4\x00\x3f\xfc\x20\x87\xbf\xbc\x00\x3d\xd2\xb5\x88\xf6\x79\x88\x76\x13\xc6\xad\xa5\x69\xb5\xc1\x60\xb6\xe8\xb4\x7b\x32\x40\xb7\x3f\x03\x18\x05\x6e\xb9\x3e\x9f\x28\xa7\x58\xd3\xc3\xfe\xaa\xd4\xac\x9a\x8a\x9b\xac\x9f\x5c\xc0\x76\xd7\x96\x65\x4a\xec\xe5\xc5\xd3\x93\xe3\xc7\xfe\xfe\xa2\x6d\xc8\xd7\xab\xa4\x3b\x18\x86\xec\x4b\x18\xb4\xa5\x43\x2e\x8b\xdd\xef\xb7\x58\xe8\xe2\x08\x39\x83\x48\xc8\x88\xcf\xc0\xc1\xe0\x95\xd8\xf1\x31\x90\x22\x32\xb9\x96\x67\x43\xa4\xfa\x31\x83\x9d\x4a\xb4\xe0\xdf\xd4\x0b\xb9\x55\xf2\xf3\xcf\x7d\x62\x13\x07\x6c\x30\x85\xcf\x8f\xd1\x28\xe8\xf4\x5b\xfc\x76\x3b\xda\x67\x1d\x3e\xc7\xe2\x88\x44\x21\xde\xed\x90\x31\x8f\x4e\xa9\xdf\x90\x75\x48\x1d\x29\x77\x33\xf0\x74\xd9\x9f\x39\x6d\x78\xc7\xb9\x4f\x7e\x10\x3a\xc1\x14\xfe\x14\x5d\x41\xf8\x20\x0c\x9a\xd3\x01\xc2\x09\x2e\x0b\xda\x55\x9d\xbf\x90\xca\x7d\x03\xa9\x14\x6a\x62\x0f\xc6\x21\x85\x34\xc2\xad\x83\xd3\x58\xfe\x7f\x91\x88\xf6\x12\xf1\x13\xc3\x89\x7b\x89\x2c\x87\xdd\x17\xa2\xb5\x46\xae\x38\xe2\xd7\x59\x30\x37\xd5\x9d\xac\x53\xa6\x7a\x64\x95\x8f\x26\x0e\x17\x7e\x21\x33\xd7\x95\x17\x5e\x00\xff\x97\xfb\xcc\x76\xd7\x94\x4b\x9c\x56\xba\x7d\xe6\x45\xdb\x0a\xfe\x49\x64\x66\x73\xd6\xcc\x94\x90\x5a\x94\x53\xd2\xe5\xc8\x48\xa0\xad\xd2\x6a\x55\x2a\x03\xcb\x68\xd4\x6a\x86\xa6\x8d\x26\xad\x8a\x31\x30\x9c\x9e\xe5\xd8\xdf\x66\x74\x9c\x9a\x7b\x6e\x96\x1a\x50\x4f\x40\x9d\xd8\x9b\x57\xec\xcf\x2b\x77\x1c\x4e\xe6\xca\xfa\xd6\xd6\x68\x60\xc4\x96\x62\x53\xac\x2d\x49\x47\x55\x51\xea\x76\x3e\x5b\x7d\xc1\x2c\x7e\x86\x0f\xfe\x2a\xb8\x67\x0d\xbc\xcf\xc7\x9f\x4f\xeb\x7f\x62\xe8\x9f\xee\x4a\xec\xa9\x80\x7b\xf9\x79\x15\x7b\x12\x88\x26\x1a\xd1\x14\x45\x34\x79\xc0\xb6\x74\x83\xc5\x6c\xc6\xd5\x3b\x9d\x76\x87\x43\xab\xd1\x70\x9c\x1e\x11\x45\xa9\x55\x2a\xca\x04\x80\x81\x72\x52\x5e\x9f\xc7\xec\xb4\x31\x2e\x8b\xdb\xe5\xfe\x6d\xc6\xea\x72\xb8\x9e\x9b\xe5\x40\xe4\xa5\xed\xb4\x9e\xd3\x30\xac\x8e\x61\x99\xdf\x66\xb4\xac\x8a\x7d\x6e\x96\x0a\x00\x25\xcd\xee\x82\x05\x28\x0a\xcd\x4b\xd5\xc5\x2d\x82\xf1\xc9\x75\xcb\x89\xe7\x96\x83\xad\x1d\xfa\x45\x47\x6c\xe8\x2b\xb8\x63\x69\x3c\x7f\x65\xf1\x4b\x2a\xfb\xe0\xfd\x3e\x7e\xb1\x77\xcf\x2a\x7e\xa6\x17\xde\x0e\x7f\xf9\xcc\x71\xc5\x42\xef\x3a\xfe\xcc\x5e\xf4\x2f\x7e\x2e\xbc\x0b\x2f\x1b\xad\xfb\x3a\xf8\x28\x75\x09\xbd\x0b\xf9\x98\xa6\xc7\x38\xbd\x41\x43\x83\xc4\x4b\x98\xac\x7c\xf7\x91\xba\x64\xeb\xa2\x85\x5b\xb7\x2e\x5c\xb4\x95\x3a\xb0\x68\xeb\xd6\x45\xe8\x07\x59\x83\x8e\xec\x07\xdc\x0e\xf0\x3a\xf1\x4f\x23\x60\x68\x3a\xa8\xb7\x5a\x39\x77\x30\x08\x38\x2e\x5a\xe2\x0b\xef\x9e\xe5\xbb\xcb\xe4\xd8\x3d\xcb\x74\x17\xad\xd9\x3d\x8b\xbe\x0b\xb4\x29\xde\x42\xc5\x6a\xab\x4e\x2a\xde\x1d\x3d\x87\xa7\xaa\xfc\x0c\x1b\x47\xd6\xd7\x8f\x1c\x95\x4c\x8e\xa2\x0e\x0e\xfc\x34\xbb\xb6\xb3\xb3\x36\x39\x6a\x54\xb2\xe0\x37\x90\x6d\x3f\xf3\x0a\xf2\x97\xdc\xa4\x22\x21\x45\x71\x00\x97\xa1\x4c\x48\x45\xc4\x05\xd7\x24\xec\x28\x9f\x02\xdf\x62\xae\xc6\x26\x7d\x22\xb6\xe7\xe3\x91\x3d\x2f\x23\xe3\x1c\xc7\x68\x80\xec\x39\x03\x70\x35\x46\xc1\x9d\xc1\x27\xd3\x10\x46\xc3\xf8\xf1\xf0\xad\x29\xcc\xd5\x13\x7f\x08\xb2\x3b\x89\x4d\xc8\x5a\xd1\xb8\x2f\xd8\x5f\x00\x15\x08\xa6\xf5\x80\xa2\x58\x5a\x0d\x59\x96\x56\xd1\xc4\xfc\x27\x24\xdb\x2f\x58\x7d\x3c\xf1\x17\x27\xa7\x9e\x84\x6f\xd1\xaf\xfc\x18\x64\xde\x87\x8f\xe6\xe1\xd0\x81\xca\xb4\x4d\xcb\x22\x8f\x0a\x21\xa2\xf5\x08\x8f\x56\x4b\x6b\x70\x71\x4a\xe2\x17\x25\x73\xce\x4a\x1e\x46\x47\x58\xc2\xca\x5f\x0a\xb7\x48\x98\x27\xf2\xff\xce\xc7\x5d\x9d\xb6\x43\x8e\x53\x33\x3a\x9d\x5a\xa3\xd1\xab\xb0\xea\x67\x34\x48\xdd\xa3\x45\xca\xc8\x15\x3d\x04\x68\x84\x95\xac\x19\xfd\xfd\x02\x6e\x41\xa8\xdf\x42\x73\x30\x21\xe8\x98\xc8\x4f\xc0\x53\x08\x7e\xab\xf8\xc7\xcc\xa9\xf0\x1b\x89\x2a\xd0\x9c\xfd\x40\xf5\x1b\xa4\x77\xf4\xc0\x0b\x82\xa0\x02\x0c\x01\xa3\xc0\x54\x2a\x91\xce\xfa\xfc\x7e\x3b\x95\x0c\x1b\xd4\x81\x60\xb0\x72\xc2\xb0\xb0\x9a\x1a\x16\x8f\x53\xa3\xdb\xa9\xf6\x69\x3d\xe9\x31\x47\x33\x43\xd3\xc7\x66\x0d\x9d\x8c\x7e\xdf\x15\x4d\x1c\xcd\x84\xa2\xc7\x66\x85\x1a\x8f\x66\x7c\xa1\xbb\x80\xeb\x68\x86\x03\xc7\x66\x05\x38\xce\x8c\x3e\xbd\xb3\xa2\x07\xce\xed\x81\x93\x7b\x60\x7b\x0f\xac\xeb\x81\x91\x1e\x68\xef\x81\x54\x0f\xfc\x4f\x0f\xfc\xa0\x07\xbe\xd6\x03\x4f\xf5\xc0\xa3\x3d\xf0\x9e\x1e\x78\x4b\x0f\xbc\xb6\x07\x5e\xd6\x03\xe7\xf5\xc0\xe9\x3d\x30\xdd\x33\xa9\x87\xaa\xed\x81\xc5\x3d\xd0\xd6\x03\x99\x1e\xb8\xe4\xeb\x1e\xf8\x61\x0f\x7c\xbd\x07\x3e\xdf\x03\x8f\x29\xe0\xa7\xf4\xc0\xe1\x3d\x50\x09\xfa\xad\x84\xfc\x64\x0f\x7c\xbc\x07\x1e\xe8\x81\xb7\xf5\xc0\x6b\x08\xf0\x8c\x1e\xd8\xa1\xa0\x84\x25\xc0\x1f\x2b\x28\xb9\x0f\x03\xa7\xb7\x60\xf0\xd5\x3d\x70\x71\x0f\xec\xea\x81\xa9\x1e\x18\x93\x70\x0f\x11\xe0\xdf\x50\xc0\x5f\x27\x61\xee\xec\x81\xe5\x04\x0e\x80\x1e\x88\xc8\x7d\x9f\xe0\x45\xe4\x3e\x4a\x56\x78\x6b\x0f\x5c\xd0\x03\x7b\x7a\x60\x63\x0f\xe4\x7a\xe0\x97\x0a\x80\x7d\x3d\xf0\x66\xb2\x9e\x25\x04\x60\x54\x0f\x2c\xeb\x81\xbe\x1e\x68\xe8\x81\xb0\xaf\x57\xf9\x67\x79\xee\xcf\x8a\xbe\x15\x8a\x3f\x73\x7a\x7b\xcf\x05\x48\x80\x57\xfc\x1c\xb0\x0c\x2d\xaa\x44\xa1\x7f\x3c\xf9\x55\xa1\xf0\xf3\x90\x52\xc0\x1f\x72\xfe\xb1\x5c\xdf\x1c\x27\x77\x70\x09\x5c\x5b\xbd\xd8\xab\x8f\xd4\xcf\x87\x11\x98\xfc\x99\xab\xe7\xbe\xb2\xa6\xbf\xe7\xde\x2b\x3f\xaf\x9d\x75\xcd\x9a\xda\xa6\xd1\x53\x6a\x1a\xda\xda\xc6\x27\xf9\x85\xcb\x98\xfb\x97\xf1\x9d\x83\x5c\x82\x9f\x0e\xf2\x25\x75\xfb\x7f\xd7\xbe\xbb\xf4\xf3\xa9\xcf\xae\x6b\x81\xff\xe8\x1a\x35\xe7\x9d\x9e\x31\x63\xe7\xbd\xf5\xe3\x1f\xd9\x45\x3f\xfc\x72\xb0\x2b\xfc\xda\xc1\xbe\x25\x76\xf1\x03\x7a\x36\xfc\x1b\xdb\x82\x34\x6b\x20\xad\xa7\x50\x8c\x02\x20\x03\x59\x1a\xdc\x0f\xda\x5e\xca\x15\x63\xc6\x1d\x7a\xe8\x08\xb4\x9f\x7a\x78\x0c\xdb\xc2\xe3\xa0\xef\x2b\x7a\x36\x7d\x3e\x19\xa7\x02\x89\xb4\x83\x53\xa9\x58\x86\x81\x6a\x01\x03\x0a\xa2\x28\x06\xa3\xa8\x7b\xa9\x4e\xee\x99\xa0\xe8\x83\x85\x71\xa1\x1f\x6a\x3f\xc2\xc7\x1f\x16\x91\xc2\x7f\xf0\x21\x41\x96\xef\x47\xb8\x8f\xb3\x2d\xe6\x62\xd5\x77\xa7\x80\x39\xa2\xfa\x0e\xbc\x86\x24\x9b\x56\x7d\x07\x3f\x22\x34\x5f\x02\xc6\x50\x33\xe8\xa9\x80\x03\x55\x69\x3b\x45\xb3\x90\x85\x2a\x35\xc7\xa2\xc8\xef\xf3\x59\x14\xf8\x62\x16\xb2\xda\x56\xe0\x69\x13\x0a\x12\x0a\x27\x8c\x1c\x32\x3c\x2f\xb4\x45\x60\x8a\xf2\xb5\xf0\x27\x8e\xb5\xf0\x6f\xeb\xe8\xa9\xfc\xa5\xfc\x46\xb8\xa0\x5d\xf0\xab\xbb\x11\xde\x61\x12\x5e\x1a\x52\x08\x71\x21\x5e\x5b\x01\x5e\xe2\x3f\xa5\x22\x90\x4e\x42\xd5\xb6\x16\xd8\xfe\x64\x0b\x2c\xd1\x8d\x81\x37\xc2\xf5\xfc\x9e\x76\xbc\x96\x3b\xb3\x1f\x30\x2d\x68\x2d\x31\xe4\xed\xe0\x77\xda\x18\x5c\xcf\x06\xe9\xc3\x93\x1c\x43\x7d\xcc\x4d\x45\xfb\xe7\xc0\xf1\x0d\xda\x74\x14\xdf\x20\x4d\x2f\x07\x37\x48\xe9\x51\x1f\xff\xf4\x0e\x5d\xcc\x31\x93\x90\x5d\xb8\x15\xe9\xe2\xe3\x64\xbf\x6d\xc7\xd0\x8a\x19\xea\x7e\xf0\x00\x10\x9a\x37\x21\xe8\x30\xda\x4f\xfe\xa7\x45\xf4\xc9\x05\x08\x04\xfd\x61\xc0\xaa\xec\x07\x54\x03\x7b\x81\x68\x27\x13\xe8\x8c\x3c\x80\x2b\x29\x77\x63\x7b\x19\x2c\xe7\x98\x9a\x5a\x4d\xbc\xca\x17\x36\x71\x0e\xda\x06\xda\x4e\x2a\x1c\x1b\xe1\xbc\x95\xe6\x51\xd9\x2d\x8d\x3e\xc7\x67\xb8\x48\x32\x8b\x2f\x4b\x1f\x46\x4a\x1f\x46\x17\x5a\x4c\x66\xbe\xf8\x81\x1f\x23\x7d\x68\x93\x8d\x67\xce\x56\x98\x90\x7d\xf7\x32\x26\x93\x81\xd5\xaa\xb5\x7a\xa8\x47\xa1\x88\xce\x64\x52\xa3\xe5\x19\x50\xa4\xce\x90\x72\xc7\x09\x45\xc7\xbf\x64\x9e\xdd\x48\x5a\x22\x0d\x61\x47\xc4\x92\x74\x08\xb6\xe3\x24\x32\x4c\x27\x4f\x4a\xb6\x03\x99\x25\xd1\x7a\x50\xf2\x7c\x34\xda\x2d\x14\x45\x43\x95\x4a\xa3\xd1\x22\xdb\xab\xd5\xea\x51\x44\x8d\x22\x76\x2d\xcd\x16\x98\x27\x4b\x9e\x7d\xa2\x2d\x82\x81\xba\x03\x0e\xe5\x9f\x9f\x8c\x0d\x14\x9e\x83\xbf\x03\x3e\x2a\x9a\x28\x98\x35\xa3\x39\xbe\x44\x73\x60\xbb\xce\xd0\x48\x44\x38\x5c\x65\x59\x34\xeb\x75\xc4\x88\xd2\x61\xba\x7c\xea\xf3\xf0\xbd\xe7\x51\x08\x1e\x83\x17\xf3\x3b\x80\x3c\xee\x06\xc4\x93\xc8\xae\x73\x98\x4d\x10\x0f\x31\x14\x4b\x0d\xb0\xeb\x98\x02\x1f\x44\x18\xbe\xfc\x52\xb4\xbd\x4f\xf2\xb8\x76\x2e\x95\xb5\x20\x1c\x67\xd9\x6b\x11\x0e\x2d\xa8\x4f\xbb\x34\x34\xad\x62\x59\x84\x5c\xc7\x51\x5a\x95\x46\x8b\xfe\x42\x35\x23\x66\x3d\x84\x44\x41\x72\x80\x85\xc7\x69\x82\x54\x5c\xe5\x2a\x9f\x7a\xea\xec\xd9\x53\x53\xd7\xaf\x5f\x8f\xa8\x64\x1f\x7f\xfb\xed\xc7\x1f\x5f\xbe\x7c\x59\xbe\x0f\x62\xc0\x36\x9e\x31\x18\x74\x6a\xad\x56\xa7\x33\x6a\x0c\x06\x14\x9a\x30\xba\x9c\x8d\xcf\xdf\x45\xe9\xac\x94\x27\xe5\x96\x0f\x8a\xdf\x23\x9d\x13\xb0\x50\x2e\xea\x76\x16\x37\x80\x32\x82\xd9\xe9\x3a\xda\xa8\xd3\x51\x40\x8d\x8e\x8b\xe3\x20\x65\x60\x28\x46\x63\xd2\x98\x11\x73\x30\xff\xcc\xa8\x59\x93\x21\x64\x48\x18\x68\x43\xda\x6c\xef\x34\x18\xd0\x5a\xdf\x82\x6f\xe3\x46\x51\x68\xfe\x8a\xde\xa4\x1c\x56\xe6\xba\x59\x08\x1f\xad\x24\x93\xa8\x8a\xe0\x1e\x04\x49\x3a\xa9\x42\x9a\x2a\x4c\xe9\xfd\x5b\xfd\xfc\x4e\x2b\xfc\xea\x82\xb9\x97\xdb\x7e\x4d\xf1\xf7\x43\x17\x75\x74\xef\xde\x79\x54\xac\xff\xbd\xc5\xf0\x7d\xfe\x1a\x41\x7f\x44\x29\x3d\x75\x39\xa2\xcf\x0f\x26\xa5\xcb\x3d\x5e\xaf\xd3\x41\x9b\xcd\x0e\x35\x1d\x70\xb9\x82\x0e\x2b\xb0\x7e\x9c\x01\xc0\xc9\x39\x3d\xff\xcc\x38\xdf\xe2\x8c\x1f\x67\xe6\x6a\x20\xf2\xf4\xdf\xc5\x85\xb2\x7b\xf3\x0a\xa5\x80\x81\x9d\xf4\xa4\x2e\xac\x62\xd7\x4a\x52\xa5\x3d\x62\x0b\xab\xc2\xaa\x54\x23\x9c\x74\xed\xc6\xc7\x0e\x2e\x5d\xe4\x1a\xa2\x72\x4e\xf4\xff\xf1\x8e\x21\x0d\x9d\xa3\xe0\x53\x0e\xfe\x86\x52\x4f\x8a\xfe\x66\xe9\x9c\x1b\x6e\xf5\x1f\x5d\x66\xb4\xfd\x65\x9b\x11\xfe\x6a\xd9\x27\xac\x16\xd3\xba\x9e\x72\x53\x2f\x22\x5a\xd5\xa0\x21\xed\x63\x91\x43\xa6\x51\xe1\x36\x8b\x6f\x33\x6a\x8a\x52\x7f\x92\xe9\x83\x97\x40\x0a\x79\xad\x6f\x09\xc4\x11\xc2\x14\x3d\xea\x30\x4b\xe0\xe6\x00\x68\x73\x8e\x36\x95\x52\x25\x3a\xbe\x68\x1e\x7c\x85\xff\x25\x33\xfd\xe3\xf6\xfe\x00\x29\x57\x85\xa4\xa9\x91\xd2\x50\xb7\xb2\xa3\x81\x0d\x04\x40\x0c\x2c\x4e\x37\x53\x41\x6b\xb0\x38\x48\x6b\x18\x17\x17\x35\xf9\xb5\x5a\x93\x9e\xe6\xd8\x78\x18\x80\x52\x5a\x1f\xf4\x06\xbd\x1f\x67\xf4\x41\x7f\xb0\x32\x48\x1b\xe8\x60\x50\x6d\xb5\x46\x3e\xce\x58\xdf\x52\xdb\x3f\xce\xa8\xdf\x05\xca\x52\x32\x52\x8f\xf8\x82\x26\xf1\x00\x7d\x2f\x44\xdc\x41\xe8\x30\x87\x71\x27\x18\xb1\x75\x10\x14\x4b\xcb\x38\xec\x36\xa1\xe3\xaf\xc3\x4e\xdd\xda\x33\x36\xd5\xc6\x3f\xfb\xcd\x89\xf2\xd4\x2d\x5b\xdf\xe1\xef\x99\x35\xa5\xad\xf5\xd0\xf1\x31\x93\xcf\xbf\x95\xb9\xb7\x67\xad\xc3\x3a\xb5\x85\xff\xec\xe9\x53\x8d\x96\xd1\xa9\xb5\xeb\xfb\xb9\xc5\x17\x37\xb7\xbe\xbc\x01\xde\xd6\x3b\x6b\xf1\x13\x8b\xd1\xfe\x4d\x40\xbc\xb8\x81\x99\x89\xb4\xeb\xf9\xe9\x46\x1d\x52\x15\xc8\x5d\xe6\x4c\x56\x2b\x70\x38\x6c\x9c\xcd\xed\x61\x74\x9c\x81\x65\x39\xce\xe1\xb0\x7e\x98\x71\xbc\xad\x55\x7d\x98\xd1\x6a\x0d\x06\xea\xa3\xcc\x21\x03\x34\xa4\x35\x86\x4e\x03\x52\xf6\xbd\x42\x33\x66\xa9\x44\xac\x05\x77\xd6\xc6\x6c\x28\xe5\x11\x24\x4f\x44\xe0\x4a\x7c\xe6\xf9\x9d\xc0\x48\x37\x33\xf8\x5e\x79\xd7\xf8\xf6\xed\x99\x51\xaa\x57\xcd\xe7\x5d\x70\x39\xd7\x3c\x51\xfd\x8f\x16\x03\xfd\xd7\xb2\x15\xfc\x75\xf0\x7f\xa6\xaa\x55\x57\xaf\x31\x27\xf8\x43\xc6\x2a\xd8\xdb\x41\xf4\xc1\x7f\xb2\x6d\x14\x07\xb7\x02\x0b\xf2\x8c\x53\x69\x03\x63\xb5\x5a\x2c\x45\x1e\x8d\x26\xe4\x30\x1b\x9e\x80\xa3\x8e\x30\x7e\x3f\xf7\x14\xec\x22\xf7\x03\x3a\xf3\x9b\x7e\x26\x25\x7f\x80\x15\xbb\xed\x48\xbd\x75\x11\x4d\xd5\x50\xf6\x73\x52\xf0\xbe\x0e\xf6\x21\xeb\xc2\x69\x9d\x33\x32\xbb\x67\x75\x0e\xf7\x15\x2d\x73\x95\x86\x5a\xe6\x0f\x6d\xa8\x1a\x3e\xf5\x06\x93\x6f\xce\x05\x17\xcc\x59\xfc\xf8\x52\x8f\xa3\xd3\x6c\x98\xb5\x6b\x4a\x7a\xfc\x54\x4c\xd7\x37\xd9\x36\xf8\x1a\xa2\xcb\x09\x42\x20\x99\x36\x7b\x91\xa0\x87\x5d\x8c\xd9\x5c\x44\xbb\x5c\x86\x80\x1d\x91\xf6\xa8\x86\x43\x14\x76\xe5\x1a\x04\x49\xdd\xbd\xa4\x9b\x0f\xe4\xb1\x93\x46\xfc\xdc\x89\x4c\x9a\x93\x25\x0d\x7e\x71\x7f\xc7\xd7\x5e\xbe\x97\xda\xd0\x38\xab\xd4\x92\xb8\x6a\xe8\xe2\xf9\xd3\x6f\xee\x1e\xdf\xc3\xff\xf2\xd2\x5f\x46\x23\x6d\x17\x42\xdb\xd4\xe5\xba\xca\x5d\x51\x97\xa7\x3c\xb5\xec\xbc\x05\x8f\x2e\x1e\xf5\xae\x6a\xce\xc8\xe2\x8a\x1d\xe2\x7e\x99\x11\x5d\x5a\x74\xda\xd1\xb4\x16\x9d\xa9\x07\x18\x8d\x6e\xb5\xf5\x29\x38\x0a\x1b\x0d\x42\x50\x9b\xb2\x9f\x61\x2a\xd7\x5a\xda\xa6\x6c\x39\x36\xbb\x6d\xc8\xd4\x0d\x6b\xa7\x5d\xb9\x42\x6a\x35\xe6\x9a\xdc\x73\xfc\xfa\xfb\x9f\xe5\xf7\xca\x1d\xc6\x90\x1e\x7d\x36\x3b\x0e\x7e\x0c\xaf\x42\x76\x7b\x42\x3a\xe4\x2b\x72\x03\x8d\x91\xb3\x58\xdc\x21\xbf\x41\xab\xf5\xbb\xe9\x28\x8a\x75\x4b\x8c\x3e\x4d\x11\xc3\x38\xf4\x4f\xc0\x91\x47\xfc\xa1\x10\xf3\x04\x39\x29\x7c\x4e\x58\x1c\xf2\xfb\xaa\x10\x8e\xc2\x1c\xe4\xb2\x0b\xfd\x66\xda\x60\x02\x22\x45\x92\x12\xdb\x0b\x91\x76\xc2\xb8\x01\x4d\x1c\x37\x5e\xf0\x30\x97\x68\xbb\xef\x59\x9c\x66\x6e\x99\x3e\x76\xa4\x5b\xc7\x2e\xd5\x77\x6f\x5c\x39\x8a\xfd\xd5\xc2\x45\x31\xef\xd5\x66\x95\x4f\x6d\x0d\x8e\xbf\xfd\x73\x93\xef\x8d\xd1\x23\x7c\x5a\x0d\xe3\xd3\x58\x4a\x26\xac\xe1\xbf\x37\xf8\xbe\x3c\x2f\x16\x07\xd2\x39\xbe\x0a\x6f\x92\xce\x11\x1d\xa1\xd6\x1c\xf6\x02\x20\x9f\x63\x97\x70\x8e\xa3\x0a\xce\x51\xe8\x80\x57\x5b\xa3\xc2\x8d\x90\x48\x53\x36\xa9\x27\x3e\x39\xce\xa8\xc8\x5c\x8d\xfa\xd3\xf7\xd1\xe4\x18\x9b\xae\x68\x5c\xb4\x00\x1f\xe3\x34\x78\xf1\x95\x37\xe0\x63\x1c\xd5\xbd\x52\x57\x81\x4f\x31\x51\x87\x4e\xf1\xd0\x92\x51\xef\x6a\xfa\xda\xf1\x29\x92\x9e\x39\xc8\x0a\xfd\x83\xdd\x08\x92\x60\x7d\x7a\x84\x8d\x29\x2e\x2f\x77\x25\x0d\xda\xd2\x48\x24\x5a\x95\x08\xfa\x7c\x89\xa8\x36\xc9\x70\xf5\x0d\xe5\xc9\xda\x64\x5f\x06\x94\x15\x97\xf5\x65\xe2\x25\xae\xe2\xb0\xdb\xeb\xee\xcb\xf8\xbd\xc5\xe8\xaf\xa9\xba\xd6\xaa\xd7\xab\x4d\xea\xbe\x0c\xbe\x7d\x2e\xf5\x52\x17\xed\xa6\x20\xc3\x49\x65\xa6\x2d\xbf\x9f\xba\x94\x5e\x11\x1a\x9a\x94\x90\x2e\xc9\x0d\x52\x78\x40\xda\x91\x86\x91\x58\xc5\x2a\x90\x3f\x99\x42\x0e\x72\x3c\x42\x93\xae\x37\xb8\x1e\x16\x95\xf4\x9d\x7c\x6b\x07\x34\xff\xfa\xe6\xfb\x62\x2d\x33\x2f\xbd\xe2\xd4\x45\xd7\xaf\xb3\x0d\xbf\x5c\x4d\xbd\x52\xd1\x06\x67\xaf\xb8\x76\xd8\x5f\xab\x5b\x1b\x5b\xb9\xbf\xb6\xde\x7b\xcd\xd4\xd1\x6d\x43\xfb\x19\xf5\xd5\xf0\xfe\x97\x8f\xfe\x1a\x9a\x6e\x2e\xf9\x7c\x6b\xd3\xb5\xff\xb9\xe3\xc6\xfd\xf0\x52\x4f\xd5\xd7\xb7\xa9\xf9\x47\x2e\xe6\x5f\x59\xc6\xdf\xa9\x79\x98\xff\xbe\xca\x23\xe8\xea\x65\xd9\x2b\xd8\xc5\xec\x0b\xa0\x0c\xd4\x80\x46\xb0\x3b\x3d\xcd\xec\x34\x34\xe8\x6b\x35\x55\x55\xb5\x0d\x4e\xc6\x6e\xb7\x50\x95\x65\x75\xf1\xfa\x12\x97\xab\xbe\xae\x92\x29\xf7\x97\x33\xfe\x20\x13\x4c\x59\x2c\x4d\x20\x5a\x5c\x59\x57\xef\x62\x3c\x55\xc5\x9e\xbe\x4c\x49\xbc\x8c\x32\x1b\xf4\x2a\x75\x71\x30\x58\x6c\x43\x63\x69\x6b\x95\xba\xaa\x2f\x63\xb5\x1a\xb5\x6a\x06\xb4\x3d\x5f\x27\x34\x9c\xc7\x59\xa9\x64\x02\xdb\x38\xf1\x5f\xe6\xe7\xeb\xf2\x5a\x24\xe5\x6d\x5c\x5e\xc1\x70\xb4\x41\x16\xb4\x79\xcd\x88\x85\x55\x58\xef\xb8\x68\xb4\x87\x71\x28\xf4\x4c\x4e\xd2\x1c\x43\xda\xbb\xa7\x62\x71\xda\xee\x42\x6e\x16\xa5\x81\x4e\x17\x8c\x41\xcf\xa4\xe5\x2f\xbe\x0c\xd7\x7d\xeb\x4c\x4f\x6a\x5f\x39\x7a\xd2\xb8\x9b\xab\x86\xc7\x93\xfd\x07\x87\x8e\x58\xf1\xf7\x8e\xce\xe1\x2d\x2b\xf9\xff\x2e\x1f\x3b\x6e\xf8\xa4\xae\xc6\xaa\xb6\x51\x54\xe8\x31\xfe\x9f\xb7\x53\x8f\xf5\xff\x2e\x9e\xa4\x26\x57\x5f\xf3\xd6\x36\x18\xfd\x1e\x5e\xf9\xd2\xba\xab\x34\xd7\xef\x0c\xf0\x6f\x1e\xf4\xda\x7f\x5c\x67\xec\x68\x78\x81\x3f\x55\x9e\x30\x6c\xd8\x66\x71\xc1\x53\x0f\x5f\xc2\x84\x98\x53\xfc\x7e\xaa\xe4\xc7\xfb\x4a\xdc\xcc\xd5\x7a\xc2\x73\x2b\xb2\x9f\xb3\x4b\xd8\x71\xa0\x1a\x2c\x4f\xfb\x8a\x43\x21\x9f\x5e\xaf\xb1\xd1\xbe\x58\xcc\x59\x56\x51\xe1\xa4\xe9\x84\x46\x53\xe3\x2b\x0e\x14\x3f\x01\xed\xe9\x40\xc6\xe3\xea\xcb\x78\xc2\x81\x00\x50\xa9\x4c\x7d\xc8\x60\xa8\x18\x67\x0c\xc4\xfa\x32\x28\x5c\xc5\x15\xd5\x06\xb4\xec\x4f\x56\x14\x38\x0b\x8a\x50\x0b\xed\x54\x11\x10\xb9\x0c\xed\x10\xd6\xce\x0c\x85\x1b\xee\x11\x2e\x6b\x14\x3a\x74\x1b\xa1\x8a\x6e\x85\xc2\xb6\x51\x4f\xf1\x9f\xf3\x64\x8b\x5e\xfd\xa0\x6a\x78\xdb\xc1\x79\x8f\xf3\xff\xd8\xbb\x7e\xfd\xc5\xab\xd5\xd0\x11\xda\x7b\x57\x24\x50\x59\x11\x1b\xb1\xbd\xad\x63\xd9\xcb\x23\x85\xfd\xb2\xc1\x22\x1e\xef\x4a\x12\x6d\x48\x45\xe2\xb7\xfc\x9d\xef\xdf\xf3\x46\x29\xb5\xc2\x53\xf5\xda\xe7\xea\xef\x36\x68\xd7\xce\xe4\x2f\xa3\xda\x85\x3d\x22\xfe\xe1\x3b\x48\xfe\x86\x23\x9f\x23\x04\x4e\xa5\xd7\x52\x7e\xad\xd5\x1a\x36\x22\x87\x5e\x8b\x7c\x4f\x0f\xe3\x76\xe3\x34\x53\x58\x5d\xa4\x63\x20\xb3\x32\x63\x84\xa6\x60\x28\x48\xe9\x90\x23\x00\x3c\x60\x55\x06\xf8\xcc\x3e\xca\xe7\xf3\x98\x20\x34\x79\x42\x9e\x36\xcf\x44\xcf\x25\x9e\x0d\x1e\xce\x44\x3e\x6e\xf0\x1c\xf2\x3c\xeb\x79\xd7\x73\xd6\xa3\xd6\xd1\x9e\x74\x49\xbc\x13\x7a\xa0\x47\x8d\x94\xe6\xaa\x0c\xe2\x5d\x8b\x69\x65\xc6\xc2\xe1\x28\x62\x65\x46\xed\x06\x72\x39\x76\x62\x7b\x89\x23\xe1\x4e\x24\x2a\x90\xf7\xb0\xbc\xd7\x42\xdc\x1d\x7c\x81\x94\xac\x17\xb7\x57\x6c\x0c\xeb\x1a\x22\x2a\x29\x8b\xe8\x26\x62\xff\x0b\x97\xa7\xc7\x5d\x8e\x49\xd1\x76\x41\x78\xc3\x44\x78\xe1\x03\xa5\xd0\x6a\xe2\xbf\x88\xff\x5e\xdb\xff\x17\xed\xbe\xf8\xc3\xa6\x87\x77\xdf\xaf\xa5\x37\x0d\x69\xe7\x2e\x7c\x7d\xf9\x3c\x78\x51\x73\x4b\x67\x0b\x4d\x2d\xf8\xb0\xfb\x1d\x5c\x83\xfe\x9d\x6e\xfa\x62\x6f\x03\xff\xec\xdf\x8c\xfd\x6f\xde\xc5\x2f\xd8\x27\xf8\x94\x48\x6d\xa2\x78\x7c\x1c\x92\xcb\x9d\xe9\x69\x91\x58\x8c\x2b\x0e\x05\x83\xe6\x32\x8a\x32\x1b\x75\x9c\x86\x73\x94\x3b\x2a\x62\x2a\xb5\x6a\x65\x26\xa2\x2e\xd6\x1b\xf4\x2b\x33\x21\x83\xe0\xf9\xf6\x19\x2e\x31\xb0\x1a\xe4\x1e\x5b\x69\xb5\x41\x6d\xa0\x6c\x36\xdf\xca\x0c\x70\x2d\x73\x51\x1a\xa4\x86\x6d\x2a\x1a\xe1\x28\x5b\x9d\xa1\xc8\x76\x10\xf7\x2e\x99\xf3\xab\xd0\x76\xa0\xcf\xf2\x06\x24\x07\x70\x99\x14\x25\xe2\xd2\xfc\xb8\xd3\x55\x32\x16\xc7\xff\x13\xfa\x34\xa2\xb5\x63\x6e\xe3\x1c\x2e\xbc\x3f\xa4\xe1\xb2\x8a\xbe\xc2\xf7\xd3\x6f\xec\x53\x0e\x38\xde\x34\xfd\x91\x35\xef\x37\x6d\xf0\xf4\x7f\x76\xc3\xce\xaa\xe1\xaa\xa2\x85\x75\x3b\xee\x60\xa0\xd3\xc4\xff\xc0\x7d\x67\xfa\xc6\xd2\xd7\xb7\x6b\xd7\xa5\xe9\x2b\xaf\xea\xae\xee\xe8\xee\x9b\xf1\xce\x97\x15\xfc\xa7\x4f\x39\x02\x6f\xbe\x78\x63\xf7\x8a\xee\x71\x9b\x46\xe3\x3d\x19\xc3\x7f\xc3\x2e\x67\xee\x44\x7a\x7c\x43\x3a\x5c\x56\x6e\xb6\x94\x5b\x58\x7f\xa9\xc1\x60\x35\x1a\xa9\x62\xbf\x3f\x40\xb1\x6c\xb2\x26\x50\x53\xdf\x50\xac\x76\x45\x5d\x4f\x40\x0f\x92\x2c\x7d\xa9\xd5\x54\x6a\x32\x56\x95\x45\xcd\x45\xc1\xbe\x4c\x91\x29\x60\x37\x1b\xed\x14\x52\xf4\x94\x5d\xf0\x2d\x9f\x6f\x13\x7e\x89\x27\x9c\x54\x46\xf9\xca\x6c\xb9\x45\xd1\xb5\x2f\x9a\xab\xcc\x8f\x1b\x9b\xa6\x90\x43\x6c\x25\x66\x1f\xaf\x98\x94\xf1\x17\xaa\xf8\xbb\x6c\x49\x5a\xec\xe2\x44\xb3\xcb\x35\xfc\xab\x8b\x5d\xe5\x55\xc5\xe7\x55\xce\x9f\x7f\x20\xc8\x67\x27\xc1\x55\x4d\xdc\xac\xca\xab\xe6\x69\xe7\x1f\xf8\x15\x92\x36\xa7\x7f\xd4\xc1\xf1\x3d\x73\xe9\xef\x27\xed\x1a\x3b\x6a\xda\x5c\xcd\xa2\xaa\x2a\x6a\xd4\xe5\x55\x55\xa9\x21\xd5\x0f\xf5\x3f\xf7\x08\x3f\x9a\x5a\x07\x47\x54\xea\x17\xcc\xd8\x30\xa4\xff\x04\xbd\xc8\x53\xf5\xdc\xfc\x35\x4b\x16\xc3\x07\xf8\xff\xd6\x2c\x5d\xe4\x1c\xdd\x7f\x10\xb0\x42\x6d\x73\x24\x6b\x51\xc4\x39\x55\x48\xa7\x27\xc1\x83\xe9\x99\x55\xba\xd2\x04\x53\x5d\x59\x1d\x8a\x07\xca\x93\x4c\x5d\x2c\xa6\x0d\x85\x38\xaa\xa4\xae\xd2\x6f\x30\x78\x9d\xd6\x12\x6b\xb1\xd9\xdc\x50\x5c\x1f\x2a\x29\x2e\xe9\xcb\x24\x83\x5e\xb4\xd7\x7d\x99\xf2\x98\x0b\x56\x95\x39\x19\x96\xe9\xcb\x54\xdb\x74\x38\xdb\xc2\x6a\x8a\xad\xb5\x7e\xab\xd5\xa0\xd2\xa8\xfa\x32\x35\x26\x0d\x8d\x2d\x39\xd9\x30\x37\x69\xbf\x2d\x34\x34\x95\x9a\x40\xc8\x9f\xe4\x7b\x79\x62\x7f\xde\xa4\xe2\x47\xe4\x2d\xf2\x60\x15\xee\xec\x28\x4a\x94\x2d\xac\x68\xdb\x8f\xdb\x54\x46\xe8\xb0\xd8\x11\x22\x15\x8e\x47\x58\x04\x18\x4d\xd2\x30\x15\x69\x31\x1d\x2d\x39\x6a\x3c\x3a\xfa\x7e\x2d\xdc\x74\x1c\x56\x8d\x3a\xac\x85\x2f\x68\x0f\x8f\x7e\xc6\xf8\x4c\xc9\x33\xa6\x67\xa6\xcf\x7b\x9e\x5f\xdc\x75\x58\xcb\x37\x69\x0f\x75\xad\x81\x4b\xbb\xbf\xa1\xe0\x0d\x25\x59\x7e\xce\xf3\xd7\x53\x4e\xff\x2c\x78\xb6\xfb\x4c\x37\xdc\x86\xc4\xaf\x18\xff\xbf\xc1\xcb\x2f\x47\x5f\xf0\x16\x78\x96\x9f\x87\x65\x13\xee\xed\x3e\x73\x06\x41\x4c\xff\x69\xd7\x5e\x92\x5f\xc9\xfe\x33\xfb\x99\x6a\x31\xda\x5f\x15\xd2\x66\x9d\x20\x03\xde\x49\x6f\x54\x75\x71\xdc\x98\x31\x93\x26\xf6\x50\x6e\x9b\xd3\xa9\x35\xa4\xeb\x2a\x47\xa5\x46\xd5\xd9\x23\x01\x03\x35\x51\x33\x7e\xd6\xf8\x99\x95\xa3\xea\xd2\x4c\x43\x91\xc1\x69\x73\xae\x44\x16\xd1\x6c\xb3\x35\x34\xb4\x20\xa9\x6c\x82\x06\xba\xa9\xa9\x41\xd5\xb5\x2a\x63\x52\x41\x93\x2a\xa4\x9a\xa8\xea\x53\x31\x7a\x5a\x95\xb6\x79\x3a\x1b\x54\x0d\xaa\xee\xf1\xdd\x93\x56\x66\xba\xb9\x55\xe8\x67\xcc\xc4\xf1\x13\x57\x66\xc6\xbb\x8b\xca\x56\x66\x4a\x4a\x8a\x3c\x7e\xbf\x57\xed\x5d\x95\x51\x7b\x72\xfe\x48\x42\xd1\x74\x22\x4f\xc1\xad\x90\x75\x9b\xf0\x21\x99\x14\xc2\x4d\xd1\x69\x54\xca\x77\x7e\xec\x51\x64\xc1\x7d\xe1\x68\x9c\xd8\x4c\xe5\x7a\x86\xaa\xc4\x87\xbc\xc3\xb8\x8e\xa7\x10\x99\x36\x2a\x3b\xb6\xaa\x24\x4d\x20\xf5\x79\x95\xba\x79\xa0\x33\xc5\xd2\xc0\x84\xe1\xeb\x70\xe3\x2f\x77\x78\x97\x51\xd7\x6f\xe6\xc6\xf4\x72\x0b\x36\xb7\x15\xdd\x6b\xb8\xb7\x8b\x69\xaf\x68\xb0\x44\x36\xc0\xc7\x5a\xef\x0b\x47\xab\xec\xf6\x09\x0d\x5d\x63\xc7\x4d\x99\x38\xf9\xce\xeb\x67\x6f\x88\x24\x9c\xe6\x91\x15\x4d\xa3\xda\x16\x74\x4f\xde\xfd\xc3\xe7\x13\xef\xd7\xf4\xf3\x9a\xfd\x7f\xda\xa9\x81\x57\xff\xf5\x53\xfe\x4d\xfe\x4b\xea\x7c\xb8\x70\xdb\xe6\xfe\x6b\xfa\x37\xdd\x1c\x8a\xc1\xfd\x91\xf8\xb1\x63\x63\xf8\x85\x95\xd3\xcd\x49\x57\x89\xd7\xf8\xf2\xc5\xfe\xd2\x11\x2d\x15\xad\xa1\x40\x4f\xeb\xd2\x15\xa1\xdf\x5d\xe4\xf4\x0c\x4d\x14\xd5\x56\x44\x66\xb6\x5e\xba\x81\x2a\xe6\xdb\xf1\x81\xe3\x26\x21\x47\x0e\xbf\xf7\x19\xc9\x47\x06\xb2\x9f\xa9\x75\x24\x87\xd7\x50\x8a\x73\x78\x3d\x6c\x25\xe2\x01\x0e\x14\xe1\x9a\xbd\x88\x07\xf0\x3b\x4c\x09\x24\x61\x8d\x60\x08\xb8\x3b\x9d\xf1\x3a\x12\x96\x21\x86\x9a\xaa\xda\xd2\x06\xae\x9c\x0a\xc7\x62\x14\x57\x5f\x1a\x0a\x06\xfc\x55\x29\x83\xc5\x61\x1c\x5a\x52\xd2\x1c\x0b\x87\x03\x0e\xaf\xcb\xdb\x97\x19\xd2\xa8\xe5\x8c\x26\x23\x92\xa2\xca\x52\xda\x84\x4e\x83\xb2\xda\xac\xc8\xef\x0c\xf9\x6c\x45\x26\x68\xb2\x99\x6c\xfa\x88\x8b\xae\x4f\xa5\xd4\x7a\x1b\x10\x3b\x27\x12\xf9\xea\xcd\x89\x15\x11\x21\xe9\xb3\xdc\x85\x65\x80\x53\x20\x39\x9f\x48\x90\x90\x5e\xa6\x23\xe4\x6f\x18\x4b\x11\x32\x57\x44\xc8\x90\xb0\x25\x65\x81\x83\xc9\x54\x98\x25\x3f\xf1\x08\x92\x2f\x36\x15\xe1\x3e\x36\xfe\x67\x0e\xac\x32\xf1\x4f\x7f\xdd\xd6\xf3\xaf\x6f\x87\x4f\xe4\x1f\x33\xc1\x9a\xd0\xe7\xc6\x57\x87\x2d\xd7\xc0\x57\x35\x77\x37\x23\xcf\xbe\xba\x0d\x76\x1e\xb9\x57\x03\x6f\xd0\x5c\xfe\x04\x7f\xd5\xae\x59\xfc\xbf\xfa\x8f\xee\x9a\xc3\x7f\x0a\x9d\x47\xc3\x8d\xb0\x75\xdc\xf9\xfd\x8f\x4c\x58\x4c\xf7\x21\xf1\xea\xff\x9a\x32\xe2\x1f\x51\xf4\xb0\xd0\xc1\xab\xf8\xab\xa4\xcf\xfc\xfb\x67\xf0\x1f\x3e\xf5\xd0\x03\xa4\x9f\x20\x05\x86\x64\xdf\x65\x1e\x65\x6e\x02\xb8\x37\x4f\x4b\x5a\x1b\x6c\xd4\x6a\x1b\xdb\xdb\x61\x63\xcd\x70\x03\x3c\x0f\xed\x7e\x1c\x9e\x8f\x24\xb1\x11\xf6\x21\xbd\x65\x27\x9f\x21\x9c\x97\xbb\x03\x88\xfb\x35\x5a\xd0\x7f\x68\x0f\xca\xc4\xee\xa0\xad\x14\x69\x0a\x8e\xf9\x33\x19\xae\x6b\x85\xd6\x14\xf9\xc6\x6e\xa4\x54\x14\x44\x4a\x9c\x32\x89\xfd\xd0\xbd\x50\x60\x58\xdc\xeb\xd7\x04\x71\x97\x59\x5b\x0a\xa9\x7d\x7a\x06\xbf\x31\xd5\xa4\x99\x49\xdb\x87\xeb\xd5\xcc\x54\xce\x5b\x02\xa9\xfa\x31\x33\x86\x1a\x74\xea\x51\x36\xa3\xc1\xee\x50\xb5\xf7\x3f\xd8\x32\x71\x76\x9b\x4e\xa5\x1e\xa3\xd7\xd2\x81\xfd\xb7\xc3\x1d\xd5\x95\xea\x99\xb4\xc9\xe5\x75\xe8\xb4\x33\xd4\xde\x48\x79\x8d\x71\x18\x05\xac\x9e\x66\x75\x98\x8f\x94\xd8\x3c\xfa\xa9\xdf\xc0\x11\x97\x2f\xae\x19\xe3\x2d\x5e\x75\xf5\xfa\x2a\xfe\x06\xea\xa6\xde\x6f\xf9\xad\xdb\x1b\xfd\xed\x66\x1d\xbc\x91\xb2\xbe\x1e\x49\x44\xab\x78\xca\xe6\xb2\xbb\x6d\x06\xf8\xe3\x50\xa7\x01\xd0\xd9\x9f\xf8\xef\x99\xc9\xec\x4d\xc8\x93\x0f\x23\x5e\x5c\x97\x6e\x2f\xf3\x27\x9c\x8c\x4e\x87\x6c\xa2\xda\x4f\x03\xb3\x99\xaa\x05\x35\x56\xb5\x46\x3d\x29\x63\xd2\x68\x0c\x4c\x91\xcb\xe5\x2c\x2a\x8a\x4e\xca\x14\x99\x01\x9c\x9c\x01\x1e\x4f\x65\x77\xc6\xe3\x74\xda\x26\x66\x9c\x0e\x83\x6e\x62\xc6\x00\x14\xf7\x4e\x81\xdb\x7c\x52\x91\x7f\xc1\x37\x4b\x12\x39\x6d\xae\x68\xcd\x2b\xa4\xf3\x90\xd9\xa3\x1b\x53\x0d\x88\xb7\x52\xd8\x04\x62\x4d\x81\xc4\x5e\x4c\x17\x10\x87\x94\x68\x05\x4a\x08\xe7\x52\x8c\x9d\x7e\xda\xfe\x00\x67\xe3\xff\x6a\x82\xa5\xfe\x5d\x6a\xd8\x51\xba\xca\xb4\xea\xc9\xe5\x6a\xfe\x83\xc0\x03\x37\x5e\xb1\x7d\x27\x04\xbf\x9a\x53\x13\x19\xd3\x30\xe7\x9e\x05\x33\xc6\x0e\xb9\xba\x85\xff\x7e\xd1\x22\xe6\xf1\xce\x3e\x66\xea\x1e\x77\xd5\x3f\xa6\xfe\xf8\x85\xa7\x6a\xcf\xaf\x9f\xfc\xd5\x43\xb0\xea\xd0\x06\x97\xf7\x66\xfe\xa7\x2d\x17\x5c\xd5\x45\x9e\xf5\x21\xb5\xfb\x27\x11\xff\xfb\xb9\xf4\xfa\x50\x51\x91\xd9\x41\x73\x26\xab\x9d\x76\xab\xdc\xe5\x95\x80\xe6\xaa\x62\xb1\x44\x8d\x8a\xe3\x6a\x5c\xa5\x65\xa5\x2b\x33\xf6\x32\x6b\x55\x75\xd5\xca\x8c\xa9\xda\x54\xd6\x57\x46\x85\xca\x26\x96\x3d\x5b\xf6\x72\xd9\xd9\xb2\x6c\x19\xb7\xb7\x0c\x9a\xaa\x43\xd5\x89\x6a\x7a\x5b\xf5\xde\x6a\x4a\xf8\xdc\x57\x7d\x09\xfa\xc7\xa1\xea\x67\xab\xcf\x56\x6b\x34\x74\x59\x75\x59\x35\x12\x2b\xe4\x6a\x85\x42\x11\x0f\x8d\xfc\x31\x8b\x1a\x22\x27\x4c\xad\xa6\x55\x24\x95\x46\x12\x7d\xc9\x84\xd2\xcd\x5a\xbe\x02\xfd\x57\xe8\x69\x09\x3e\x3c\x79\x04\x0d\x6f\xae\xf0\x74\xa5\xcd\x0a\xb0\x33\x81\x82\x1b\xb2\x7f\x58\x8c\xc9\xff\x54\x76\x39\xf8\xc1\x5b\x8c\x6d\x27\x76\xca\x9e\x9b\x00\xab\x5f\x1d\xb3\x63\x7e\x59\x07\x13\xbb\x68\xd8\xb6\xa7\x87\xc1\x39\x46\xfe\x0e\x9b\x0e\x2e\x30\xf1\xfb\x98\x0d\xcb\xbb\x37\x95\x35\x8c\x68\xb8\xfb\xd8\x0b\xef\x50\xcb\x4c\x4b\xb4\xf6\xa5\x46\xba\x05\x1a\x20\xe5\x08\xfe\x74\x4d\x45\xe2\xcd\x0f\x27\x4f\xe8\xe9\x5e\x78\xf0\xc1\x61\x65\x7b\xf9\x2f\xda\xfe\xfb\x66\x53\x77\x66\xec\x64\x52\x17\x1a\xf7\xdb\x41\x7a\x2f\x02\x56\xa5\xdb\x4c\x76\x83\x9e\x66\x98\x70\x28\xe4\xd6\xa9\xc3\x14\x4b\xa9\xdd\x76\x27\x67\x05\x20\x6a\x2d\xa1\xc2\xe1\xa0\xc7\x87\xa2\x42\x83\xca\xe9\x72\xf6\x65\x42\x8c\xcb\x65\x8d\xf8\x68\x93\xdd\x6a\xc7\x21\xa1\x5a\x67\x05\x6d\x2f\x89\x86\x4a\x68\xf8\x4c\xd4\x97\xe0\x7a\x49\xfb\x90\xcb\x63\x88\xcf\x98\xa2\x18\x00\x7b\x96\x10\xf1\x14\x8c\xa8\x44\x8b\x22\xfa\x0b\x48\x71\xa5\x60\x3c\xc5\x1e\xd4\xee\xe9\x7f\xad\x15\xfe\xd7\xc8\x77\xc1\x89\xd7\x6a\xf9\x97\xf8\x1b\x96\x8f\x98\xf1\xb4\xb6\xff\x35\xed\xa1\xb9\xa7\x8c\xa7\xe6\xdf\xaf\xa5\x3c\xda\xc3\xe7\xd1\xd4\xfe\xcb\xb4\x6c\x0b\x52\x38\x43\x16\x76\xf7\xbf\xe7\x6b\xa0\x96\xa5\x78\x17\xe9\x09\x55\xd4\x4d\x55\x92\x56\x51\xaf\x41\xaa\xc2\xdb\x20\xf8\xe3\xa4\x77\x02\x59\xfb\x95\xe9\x0e\xa3\x39\x4c\x05\x38\x8f\xd6\x1b\xd4\x72\x94\x9a\x31\xab\x4b\x1c\x56\x6b\xd4\x6e\x36\x5b\xdc\x7a\x8b\x7e\x6e\x86\x65\x38\x5a\xa3\x2e\x0a\x68\x55\xa1\xa0\xdf\xe3\xf3\x7a\x3d\x41\x55\x40\x4d\x33\x6a\x60\xa1\xc3\x14\xa0\xfa\x32\xc0\x2a\x45\x23\x83\xe8\x6a\x29\x25\x38\x48\x9f\xdc\x24\x5a\xb1\xaa\x8d\x52\xe1\x85\x93\xbe\x8a\x52\xe8\x91\x32\x51\x29\xd2\x33\xeb\xb0\xf6\x6f\xa3\xff\x67\xfa\xde\xfb\x3f\xe3\xff\xba\x93\xbf\xef\x4b\x8f\x68\x62\xaa\x9b\x3a\xb4\x33\xcf\xd4\x8e\xf8\xce\xf8\x9d\x17\xfd\xf4\xbc\xa2\x45\x9e\xcd\xce\x05\xdd\x0b\xb6\x2f\xe8\x5e\x08\x5f\xb6\xbf\x02\x9b\xf9\x53\xaf\x58\xf9\xcd\xf3\xc9\x57\x0b\x78\x8f\x0f\xad\x9a\x05\x65\xfc\x12\xd5\x17\xec\x1f\x11\xad\x43\xc1\x28\xd0\x03\xfa\xc0\xde\x74\xd7\xf8\x88\x6b\x7a\x64\xfa\xd4\xd9\xb3\x03\xa3\xe3\xc9\xaa\xe1\x6a\xb5\x41\x33\x35\xd5\x0c\x40\x4a\x53\x15\x2f\x0f\xa8\xe6\xce\x1b\x9d\xac\x2a\x8f\x9b\x5b\xe7\x66\x32\x45\xd3\x23\xae\xf1\xc9\x78\x8d\x39\x32\xbe\xc8\x6b\x2e\x32\x17\xd5\x78\xe7\xcc\xf1\x5a\x6d\x93\xfa\x32\x36\xbb\xfa\x09\x68\x3e\xc6\x76\xd0\x1d\x7d\x19\x5a\xde\x8c\x36\x41\x4a\xcc\x27\x89\x27\x29\xe6\xaf\x72\x9b\x42\x98\x01\xe6\xc5\x22\x96\x3c\xbf\x9c\x3c\x47\x12\xa7\xc9\xa3\xf9\x42\x43\x76\x27\x2c\xae\x86\x71\x31\x2d\x28\x3c\x91\x8c\x74\x3a\x72\xd3\x1b\x1a\xa3\xa9\xc6\x94\x0b\xe7\x8c\xad\x0e\x3b\xc5\x40\xe2\xcd\x0b\x9a\x09\x62\x3b\xa0\x22\x5e\x8d\xb5\xa1\x9e\x82\xc2\x95\x64\x9d\xea\x8b\x43\x5b\x2f\xec\x69\x8a\x05\x8f\xf8\xea\x34\xcb\x4b\x76\xaf\xbf\xfa\xfe\x1f\xeb\x47\xcd\xbd\xb8\x2d\xb6\x61\xdc\x8c\xde\x85\x93\x62\x3d\x81\xa2\x96\xcd\x33\xb6\xfc\xbb\xf1\x69\x58\x13\x1b\xbf\xb1\x66\xcc\xa4\xdb\x3f\xbc\x72\x2f\xff\x2d\xbd\x75\x5a\xe7\xb8\xd9\x33\x46\x77\xf5\xfe\x98\xad\xec\x6a\xad\x1b\x99\x1c\xb2\x79\xca\xa5\xa7\xd6\x3e\xd7\xbf\x38\xdd\x55\xd1\xb2\xe8\x12\xd8\xb8\xf5\xe1\xf1\x3c\x7f\x77\xcb\x90\x3b\x63\xf0\xe4\x2d\x37\xec\xe2\x27\x7b\x9b\xea\x5a\x47\x8d\xed\x6a\x9d\xe4\xb0\xdc\x09\x27\xc1\x0d\x0b\xd5\x09\xff\xd0\x29\x54\x74\x7c\xb7\x7b\xc4\x12\x66\x07\xff\xdd\xbd\xc7\xf9\xc3\xc7\x60\x70\xde\xf2\x55\x73\xe6\xad\x5a\xc3\x18\x46\x3c\xfc\xec\x4b\xfc\x5f\x97\x55\xa5\x1f\x80\xad\x07\xdf\x81\x86\x1f\xcf\xc6\x62\x15\xd3\x00\x95\x3d\xce\x8f\x61\x9c\x48\x17\x46\x51\x3c\xb0\x2a\xdd\x0a\x99\xa0\x0f\xb0\x95\x9a\x28\x97\xb0\x45\x90\xe6\xe7\x34\xac\x8f\x51\xd1\x31\xb3\xb9\x8e\xae\xf5\x14\xf5\x65\xfc\x88\x67\xa3\x1c\x64\x6c\x09\x8e\x4e\x18\x18\x86\x36\x18\xca\xe6\x66\x0c\x0c\x6d\x65\x49\x3a\xa2\x2d\x67\x0f\xac\xe2\x59\x10\xd5\x26\xdc\xda\x19\xc0\xd0\xb5\x35\xac\x0e\x05\x48\x3e\x18\xa3\xe4\x8c\x28\xa5\x72\x5a\xe5\x1b\x1b\x42\xce\x34\x2e\x9f\x80\xcb\x0a\x67\x5f\xff\x4a\x07\xec\xdb\x7c\xac\xb2\x71\xc6\xee\xbe\xb9\x17\x5c\x7d\x4f\x65\xeb\x1b\x07\x26\xb4\x96\xd4\xba\x03\xb5\x33\x7a\xc7\xc2\x51\xcd\x8d\xd3\x7a\x23\xae\x7f\xb9\x60\x13\xff\x2e\xfc\x84\x3f\x0d\x8d\xd7\x41\x53\xdf\xa5\x4f\x2d\x3c\xbf\xb7\x9b\x3f\xfb\xe5\x2e\xfe\x6f\xd7\x1e\xfd\xdc\xf6\xd2\x15\x8e\xbd\x3b\xfe\xf0\x15\xf5\x51\x6b\xd7\x8e\x6b\x26\xbe\xd2\x09\x2f\xc4\x3e\x3c\x7e\x1e\xda\x80\x64\x39\x0c\x4a\x51\x8c\x54\x07\x1e\x4a\x2f\xac\x42\x51\x64\xcc\x59\xe3\x4d\xf8\x2a\xd4\xb5\xe1\x12\x8a\xa3\xc2\x6a\x1f\x0a\x8d\xdc\x76\xad\x19\x80\x7a\x73\xb2\x0a\x89\x75\xa5\xda\x6e\xc7\x19\x7c\x07\x52\x62\x31\xd6\x11\xa5\xdc\x1e\x37\x72\xe0\xc2\x9e\x49\x55\x73\xab\x28\xe0\x31\x7b\x50\x8c\x5d\xe5\xf0\x78\x1c\x55\xb4\x39\x10\x48\xcc\xcd\x04\x7c\x7d\x99\x00\x6d\x20\x3d\xf3\xcc\x32\x97\x57\x88\xa9\xaf\x04\x31\x03\xd8\xa1\x13\x99\x3b\x59\x01\x2a\xc8\xbf\xe0\xc0\x54\x58\xce\x8b\x73\xd9\xb1\x65\xe5\x98\x0a\x98\x53\x81\x58\xf5\xa7\x88\x73\xed\x52\x35\xc4\x91\x92\x6c\x84\x45\xe4\x46\x8d\x2a\x1c\x63\x0d\xc6\xc9\xd0\xd0\x61\xec\x4e\xf1\xdf\x9d\x7e\x61\xe2\x9b\xda\xfe\xe7\xb4\xfb\xae\x44\xba\xd0\x73\xca\xf8\x7c\x08\xeb\xc3\x27\xdf\x0d\x3e\x05\xf9\xa0\x1b\x7e\xa9\xe3\xaf\x84\x9a\xa9\x7c\x20\x00\x99\x9b\x03\xf0\x54\x2d\xd3\xda\x6d\x6d\x6e\xeb\xbe\x72\x93\xe0\x1e\x53\xc7\xbb\x6f\xec\x3e\xec\x6d\xb8\x7a\xdd\x72\xb3\xe9\xc6\x14\xff\xca\x81\x03\xd4\x15\xf7\xde\x8b\x7c\xb4\xe5\xd9\x05\xec\x6e\xf6\x34\x28\x42\x7b\x7a\x65\xba\x5d\xab\xd3\xe8\xa3\x36\x7b\x49\x11\x85\x7c\x31\xaa\xc4\xa6\xd7\x71\x96\x70\x98\x75\x07\x2c\x46\x63\x80\xa5\xcb\xca\x6d\x51\x4d\x14\xed\x0d\x49\xb1\x7a\xbd\x94\xc6\x6c\xd6\x6b\xd3\x1a\xc6\x5e\x42\xa1\x10\xb4\x08\x52\x88\xcf\x5e\x4a\x0a\xdb\xe5\x7d\x29\x89\x33\x86\x43\x12\x83\xa5\x57\x0b\x36\x49\x48\x13\x92\xf4\x17\xee\x1a\xee\x74\xd1\x24\x21\x88\xb5\x81\x60\x24\x18\x15\xc4\xa9\x30\x8e\xa1\xa8\x67\xbb\xdd\x3c\xff\xe9\x09\x38\xef\x23\x57\xb7\xeb\x2f\xaf\x26\x47\xd0\x97\x9f\x7e\xbd\x7b\x77\x53\xdb\x7d\x1a\x78\x56\x73\xdd\xd8\x2c\xf8\x84\x9f\xff\xf8\xbd\xaf\xef\xcb\x82\x9b\xf6\x6c\xd1\xc3\xe0\xd7\x5f\xc2\xe5\x7f\xd6\x6f\xdc\xc0\x34\xf1\xef\x1d\x38\x8f\xf9\x71\x04\x5b\x5b\x02\xe7\x79\x1b\x1b\xbd\xfc\xec\x05\x34\xa5\x3e\xf5\x91\x81\x79\xc2\xfa\x02\x7f\x18\xf9\x65\xb8\xde\x7f\x3d\xdb\x89\xa2\xc4\x08\xf2\x5b\x6f\x4f\xf7\x78\x82\xee\x50\x84\x8e\x95\x44\x4b\xb8\xa8\xa6\x58\xef\x32\x3b\x2d\x46\x8b\x59\xaf\xe1\xe8\x10\x03\x82\x3a\xbf\x56\x5b\xea\x8f\x5b\x82\x41\xa7\xc7\x8f\x0c\xa7\xdb\x4c\x62\xf0\x22\x03\x8c\xe8\x49\x04\x5e\xa2\x61\x01\x34\xc3\x1a\x98\xc6\xcf\x69\x40\x56\x65\xf7\x5b\x63\x2a\x86\xdc\x80\x90\xe3\x02\x99\x8d\x7e\xc6\x98\x4a\x2e\x86\xb0\x5b\x38\xe2\x46\xee\x1a\x4c\xe2\x5b\x8a\x2e\xc4\x56\x36\xc2\x52\xca\x58\x3b\x8c\xd3\x5b\xc6\x17\xa6\xf3\xfd\x28\xde\x83\xa9\x67\x57\xc0\x89\x46\xfe\xe5\xa2\x6f\x8c\x7f\xe9\x5c\xa7\xe3\xa3\xba\x6d\xed\xfd\x1f\xff\x76\xb3\x96\xdf\xa1\x5d\x76\x72\x2f\x7c\x2f\xc0\xef\xac\x80\xc9\x09\xf0\x78\xf7\xfe\x6e\x6a\x44\xff\x33\xe8\x17\xbf\x83\xc4\xd2\x17\x4b\xbf\xd1\x57\xf0\x08\xf2\x27\xfe\x8b\x7c\xb4\x26\xa4\x97\x1a\xc1\xe1\xf4\x79\xe1\x60\x49\x30\x5c\x12\x6c\xa4\x58\x35\xa3\xad\xd7\x7a\x2a\xab\xcd\x56\x1f\xfa\x86\x89\x7b\xe2\xf5\x5c\xbd\xb5\xba\xd8\xc3\xf9\x01\x68\xf2\xa7\xd4\xfe\x80\xbf\x2f\xc3\x06\xa8\x70\x49\xb8\x2f\xd3\x58\xa2\x75\x06\xe2\x91\x5a\xfc\x46\x2f\x15\x28\x09\x94\x38\x0d\x55\x81\x2a\x4a\x4b\x57\xd5\xd6\x96\xf7\x65\x6a\x19\x8b\xc5\xe9\x34\xf4\x65\x9c\x36\x39\x4c\xc6\xbf\x90\xe0\x59\x89\x23\xd6\x6b\x21\x0f\x18\x0f\xe2\x87\x49\x79\x09\x05\xa7\x21\xad\x67\xde\xcc\x9e\x20\x62\xc8\x99\x20\xf6\xc3\x1c\xb2\x0f\x26\x35\xaf\x46\xa2\x88\xf8\x0d\x6d\x9b\x78\xff\x09\x9b\x69\xf1\xcd\x06\xa6\xc9\xf8\xe4\xac\xb7\x2e\xa0\x5a\x8d\xfd\x35\x4b\xaf\x59\x9b\x39\x5e\x33\x62\x78\x6a\xe6\x87\x4b\x4e\xbc\x1c\x9d\x64\x5c\x55\x77\xfd\x78\xfe\x6e\x23\xd5\x7d\xf5\xc2\x4d\x97\xdf\xb2\xaa\x6d\x78\xed\xa9\x7d\x4f\xbf\xda\x41\x8f\xe8\x4e\xa7\x23\xdd\xdd\xdb\x97\xac\x1a\x5d\xf3\x38\xff\x62\x38\xf6\xe0\xdd\xcb\xa7\x76\xb7\x8c\xf5\x75\xd7\x5c\x31\xab\xbb\x77\xcc\x3d\xd0\x55\x71\xfb\x0d\x37\xce\x22\xb1\xd2\x0a\x24\x87\x4b\x90\x1c\x06\x90\xb6\x5f\x91\x6e\xfe\xff\xf0\xf6\x1f\x80\x51\x55\xd9\xe3\x38\x7e\xcf\xbd\xaf\x4c\xef\x25\x93\x36\x99\x4c\x92\x21\x6d\x12\x32\x99\x84\x04\x21\x43\x0b\x11\x02\x84\x22\x30\x08\x24\x04\x08\x4d\x04\xa5\x48\x91\x62\x5d\x5c\x74\x11\xb1\x61\x41\xd7\x5e\x50\x6c\x08\xea\xae\x15\x70\x59\x61\x59\x57\x11\x3b\x2a\xea\x16\xeb\xee\xba\x16\x92\x79\xf9\xdf\x7b\xdf\x9b\xc9\x24\x80\xee\xe7\xf3\xf9\xfe\x7f\x90\x99\x79\xe5\xdc\x73\xcf\x3d\xf7\x9c\x73\xcf\x6d\xe7\x32\x3d\xcc\x77\xba\x02\x39\x5c\x0f\x03\x5c\x0f\x73\xed\x96\x5c\xd1\xeb\x13\x7d\x45\x16\x4b\xc8\x99\xaf\xcf\xa7\xb6\x49\xd3\xbe\x00\xa6\x1c\xcd\xc1\x19\x19\x9a\x02\x6a\x73\x1b\x9a\x0e\xf6\x99\x3b\xff\xaf\xb4\x2f\xca\xb5\x4f\x65\x4f\x8f\xea\xed\x67\xaa\xf7\xd9\x4b\x30\xfb\xaf\x54\xf5\xf6\xbd\x55\x3e\x64\xcd\x8b\x6f\xcd\x39\xc8\x86\xe3\xe7\x7f\xbf\x58\x99\xf1\xc4\xa3\x47\xef\x53\x94\x6b\x6e\xfb\xb5\x05\x72\xff\xf9\x2d\x2c\x7b\xdd\x78\xc9\x06\x52\xa9\xbc\xf7\xe8\x24\xa9\x73\x38\x19\x1a\x39\xa8\xec\x2f\xaa\x20\x58\xbf\xff\x13\xab\xb0\xc7\x76\x50\x79\x44\xdd\xe7\x12\x22\x0f\xe3\x59\xd2\x2d\xb4\xa7\x6e\x56\xda\xf9\x01\x33\x02\xba\xbf\xfb\x33\x29\x2a\x4e\xa0\xfd\x23\x2b\xe5\xc9\x00\x78\x31\xf6\x6e\xa4\x00\x41\x6e\x89\x57\xc2\xc4\x66\x32\x11\xa9\x04\x0a\xa4\xba\xfa\xd5\xf5\x30\xbf\x1e\xce\xae\x8f\xd7\xe3\xfa\x7a\x28\xae\x87\x8c\x7a\xd0\xd7\xd3\x5e\x16\xfc\xa3\x1e\xde\xaf\x87\xd7\xea\x61\x67\xfd\xef\xea\xf1\xad\xf5\x70\x75\x3d\xac\x63\xa0\x30\x80\x03\x66\xd6\x83\xae\x1e\x16\xfc\x58\x0f\xef\xd6\xff\xa3\x1e\x27\x01\x6f\xa9\x87\xcd\xf5\x70\x71\x3d\x2c\x62\x88\x7c\xf5\xf8\xa7\x7a\x78\xbb\x1e\x0e\xd6\xc3\xb3\xf5\xf0\x70\x3d\xdc\x56\x0f\xbf\xae\x87\xb5\xf5\x30\xbd\xfe\xbc\x7a\x8c\x6a\xea\x81\x02\x7c\x51\x0f\xcf\xd4\x1f\xac\x7f\xa7\x9e\x50\x88\xfa\x17\x1b\x86\x36\x8d\xab\x6f\xad\xc7\x45\xf5\x20\xd4\x43\xdd\xc1\xfa\xbf\xd7\xe3\xe7\xea\xe1\xc1\x7a\xa0\x64\x5c\xc3\x50\xaf\xad\xc7\x83\xea\xc7\xd4\xcf\xa8\x27\x15\x34\x01\x3b\x6c\x6f\x51\x51\x49\xd3\xed\x3c\x6f\x5a\xa4\xd1\xf5\xe7\xd6\x2f\xaa\x27\x0d\xf5\x50\x5a\x0f\x39\x1c\xcb\x7d\xf5\x9f\xd7\x7f\x5f\x4f\xb6\x27\x41\x06\xaa\x20\xe5\xf5\x90\x55\x0f\x66\x4a\x2b\x18\x9c\x9f\xc7\x05\xc3\x9e\x73\x85\x4c\xfa\xeb\x1b\x30\x20\x1a\x88\x7e\x16\xef\x17\xd8\x73\x6e\xbf\x8a\xcf\xe3\x95\x65\xb1\x32\x5c\x56\xd6\xaf\x1f\xfe\x10\xf9\xd8\xba\x8a\x0a\x36\x70\x5e\x9a\xd4\xac\xd2\x52\x68\x9d\xd9\x77\x05\x5e\x69\xfa\x1a\xbd\x52\xfe\xa6\xf5\xd4\x55\x7c\x33\x4f\xb7\x7a\xef\x74\x12\x06\x11\x36\x2a\x55\xeb\x08\xe4\xd9\x5d\x16\xe8\xb3\xcc\x2e\x6d\x02\x98\x8d\x42\x69\xef\x58\x6f\x13\x06\x9f\x2f\x3c\xb0\x44\x79\x46\xf9\x8f\x71\x08\x8c\x04\xf3\xac\x5d\xab\x1a\xce\x1e\xdb\x3e\xa0\xbe\x71\xcc\xfc\x81\x89\x92\x41\x77\x35\xae\xba\x6c\xc9\x8b\xf3\x97\x74\x14\x96\x1b\x4b\x9a\x86\x2e\x1f\x7a\x4d\xf8\xc2\xa8\x4b\xec\x38\xb9\x0d\xc4\xf0\x50\x58\xa2\x74\xad\xff\x72\x25\x7c\x37\xfe\x9c\x85\xff\x3e\xa7\x79\xc2\xa2\x13\x70\x75\x75\x6c\xe3\xf2\xf5\xaf\xad\x28\x78\x65\x6d\xd9\xec\x9d\x1d\x0f\x15\x05\xa9\xfe\x95\x74\x7f\x49\x46\x8b\x13\xa9\xdd\xef\x87\xce\x8b\x0d\x30\x53\x15\x23\x05\x41\x49\xaf\xcf\xc9\xf6\x79\x5d\xc4\x55\x52\xec\xcb\x5c\x16\xf7\xf9\xbc\x5e\xa9\x40\x5a\x16\xcf\x2e\x28\x40\x46\xbb\x71\x79\xdc\x6a\x06\x3d\xf5\xb3\xec\x3e\x94\xb7\x2c\x8e\x64\xa4\x79\xc2\xc9\x91\xf9\x8c\x8a\x54\xaf\x20\xb9\x76\x31\x92\x36\x86\x9a\x5c\x29\x82\xad\xc0\x1d\x55\xb6\x1f\x55\xf5\x78\x6b\xd9\x9e\x6d\xe6\x0a\x7b\xd9\xf9\x3a\xdc\x9d\xbd\x71\x72\xeb\xa7\x2f\x94\xea\x96\x6e\x6a\x1c\xd1\xff\xf6\x8b\x17\xad\x10\xf3\xc7\xaf\x31\x9f\x3f\x63\xba\xef\xd6\x0d\x35\xc3\x5d\x63\x7e\xf3\xb0\x38\x71\x7e\xc7\xab\xca\xde\xa9\xdf\x95\xe6\x6f\x39\x7a\xf3\x1d\x17\x2e\x75\x57\xbe\x9c\xe5\x3f\x3b\xdb\x8f\xf5\xdb\xaf\x6b\x9e\xb7\x5a\x19\xd9\x08\xd9\x8f\x5e\xc5\xc7\x43\xf7\x23\x24\xd7\xf3\xf5\x69\x6c\xbd\x59\x25\xba\x2e\x36\xcc\x63\x32\x99\xcd\x4e\x87\xd7\x28\x08\x06\x59\x9f\x45\x42\x01\x08\x87\x43\x7a\x87\x60\xab\xb2\xf5\xcf\xa5\xcd\x7b\x29\x6d\xf3\x73\xd9\xd1\x64\xb9\xa5\xb9\xa5\xc8\xad\x17\xf8\x11\xc3\x26\xc9\xad\x79\x4a\x04\xb1\xb1\x7b\x53\x9c\x90\xa5\xde\x8d\x5e\xec\x35\xf2\x83\x86\x23\x33\xa8\x05\xd2\xba\x8c\xc9\x41\x7a\x75\x7c\xb3\xb4\xd7\x01\xbb\x3d\x4c\x49\x4e\x56\xb0\x51\x2f\xb5\xf5\x0f\xa6\x8d\x43\xea\x21\xe9\xee\x53\x2b\x4d\xd2\x67\xeb\x85\x3f\x62\x9f\x23\xf1\xd7\x90\x3a\x94\x7c\x7c\x4a\xe2\x1f\xaf\xaa\x23\xc8\xaf\x3f\x60\x80\xab\xe1\x49\x3c\x75\xec\x92\x81\xd1\x96\x25\x03\xb7\xce\x5d\x77\xce\xcd\xad\x73\xd7\x3d\xd7\xd1\x21\x7c\xcd\x4f\x15\x76\x08\x4f\x77\xde\x92\x1c\x48\xec\xf2\xc3\x7d\x8f\x5d\x36\x7e\xea\x13\xeb\xcf\x99\x92\xf8\xfb\x86\xf3\x67\xdd\x3b\x63\xc3\xf9\x37\x1d\xe2\x76\x69\x65\xf7\x97\xe2\xfb\x7c\xbf\x8d\x9f\x72\xad\x0e\xb5\xc7\x6a\x6c\xa8\x26\x10\x28\xea\x5f\x9e\xa1\xd3\x95\x17\x21\xa1\x7e\x60\xa0\xa8\xa0\xe8\x60\xbc\x26\xef\x60\x3c\x1a\x2a\x0e\x1d\x8c\x17\xd4\x14\x17\xd7\x14\x10\x93\x60\x72\xfd\x21\x6e\x72\x0a\xd9\x7f\x88\x0b\x42\xcf\x02\x19\xd5\xa3\x54\x17\xbb\x9e\x3a\x09\x4d\xdb\x7a\x3e\x04\x23\xf0\xde\x4e\x30\xbf\x00\xd7\xba\x1c\x42\xa4\xaa\x80\x89\x44\x01\x9b\x23\x14\xed\x5e\x77\x20\x5a\x6b\x0f\x45\x03\xea\xaa\xa3\x5a\x36\xf4\x6b\xa7\x0c\x5a\xf9\x1c\x0c\x7a\xf6\x39\x88\x3d\xb3\x5b\x79\xe1\xf9\x67\x95\x17\xf7\x36\xde\x0f\xfe\xfb\xee\x87\xbc\x07\x1e\x52\x3e\xb9\xff\x7e\xe5\xa3\x7b\x71\xf6\x85\xca\x7d\x6d\xf3\x61\xd4\x6d\x77\xfc\xf6\x96\x47\x27\x2f\x6b\x18\xb6\xf0\x5c\xbc\xe3\xf7\x30\xe4\xe9\xbd\xca\x4b\xbf\x7f\x46\x79\xe5\x77\x7b\x21\xf6\xec\xfd\xca\xf1\x7b\xef\xa5\xa9\x1e\x80\xfc\x7b\xe8\xf5\x1b\xca\x71\x3b\x25\x15\x3f\x66\x2b\x5e\xb6\x70\xd9\xaa\xbf\xc7\xcf\x56\x9e\x1a\x45\x75\x68\x3d\xf6\xc9\xbf\xa5\x32\xe5\x44\x65\xf0\x59\xac\xdb\x1d\x08\x64\x17\xe5\x66\x65\x65\xe7\x51\xad\xc9\x36\x19\x1d\x76\x3b\x60\x6c\xcc\x26\xba\xe2\xfc\xd2\xd2\xb0\xac\x2b\x08\x85\x8a\x74\x45\xe5\xe1\xc2\x1c\x1b\xd1\x93\x83\xf1\xac\x00\x98\x02\x60\xc6\x81\x32\x0f\xd1\xa3\xd2\xa2\x6c\xaf\x9d\x76\xba\x0f\xc6\x8b\x33\xdd\x67\xa3\x05\xe8\x19\x74\x10\x09\x12\xf5\xa6\x50\x7e\x9e\xfe\x01\x29\x0c\x6f\x85\xe1\x40\x18\x26\x87\xa1\x38\x0c\x9e\x30\x18\xc3\xb0\x20\x11\x86\xaf\xc2\xf0\x5e\x18\x0e\x86\xe1\x41\x7a\x1f\x86\xc6\x30\x14\x85\x41\x08\xc3\xf7\x61\xf8\x9c\x27\x78\x3a\x0c\x57\x86\x61\x65\x18\xe2\x61\x18\x1e\x86\x9a\x30\x14\xf0\xf4\x14\xe6\x3b\x0e\xf3\x4e\x18\x5e\xe3\xc9\x6f\x0d\xc3\x35\x61\x58\x1b\x86\x45\x61\x98\x11\x86\xd1\x61\xa8\xe3\x99\x65\x85\xc1\x4c\xaf\x7f\x0a\xc3\x17\x3c\xb3\xc3\x61\x78\x26\x0c\x0f\x87\xe1\xc6\x30\x5c\xce\x13\x50\xa2\x62\x23\x69\xd6\xb4\x13\x0b\x36\x8e\xba\x33\x09\x7c\x24\x0c\x2f\x84\x61\x57\x18\xf0\x1d\x61\xd8\x10\x86\xd6\x30\x8c\x0b\x43\x43\x18\xfc\x61\xb0\x86\xe1\x9b\x30\x1c\x0f\xc3\xc6\x30\xb4\x85\xa1\x25\x0c\x15\x61\xe8\x65\x58\x5b\x93\xd6\xf7\xbf\x5e\x71\xdd\x17\xe8\x02\xa6\x93\xfb\xe8\x4d\x55\x55\x95\x36\x06\xcd\x95\x90\xd9\xff\xe4\x29\xe0\x50\x97\x26\x81\x91\xde\x47\x60\x47\xd2\x66\xac\x81\x8a\x1d\x77\x94\xd8\xca\xcd\x10\x93\x3a\x2a\x8a\x41\xe8\x11\x48\x27\x44\xdc\xb2\x76\x0b\xd9\x1b\xfc\xd7\x55\xd9\x8b\xf1\xfe\x62\x5b\xd9\xed\x39\x1b\xf0\xf1\x6c\xe5\xc4\x62\xe5\xc4\xfc\xf9\x60\xf9\x0e\x74\x4a\x47\x87\x72\xcf\x79\xd8\x57\x6a\xc3\x3b\x4d\xeb\x0e\x1c\x58\x67\x48\x4c\xb6\x95\xe2\xdb\x13\x3b\x6c\xa5\xf4\x19\x15\xb6\xc4\x33\x78\x64\xb1\x2d\xd1\xc2\xef\xdb\xd4\xf1\x9d\xcb\xa8\xbf\xfe\x5b\x3e\xdf\x7a\x61\x6c\x70\x28\x60\xb5\x58\x24\x39\x2b\x3b\xbb\x20\x28\x07\x33\xf4\xc4\x91\xe1\x28\x2d\x29\x90\xac\x52\x6b\x3c\xcb\x6a\x75\xcb\x6e\xea\x9b\xbb\x85\x6c\x8b\x6c\x99\x15\xcf\xb3\xe9\xf3\xf4\x4b\xf5\x1b\xf5\x7f\xd6\x8b\x7a\x7d\x50\xe6\xb6\xaa\x62\x46\x24\x39\xd9\x9c\x66\xbd\x53\x1b\xb0\xea\x7a\xa6\x59\xaa\xd8\x02\x65\xb5\xdb\xeb\x0c\x10\xda\x19\x1e\x08\x21\xda\x51\xb6\xa1\x40\x1e\xb2\xbb\x90\x15\xb4\x95\x20\x4e\xee\x4d\x12\xc7\x27\xef\xef\x7d\x30\x2b\xf1\xaa\x73\x68\x5d\xcb\xa1\x26\xc3\xb1\x6e\x68\x86\x61\xf4\x7f\x73\x37\x7a\xcb\xd0\x74\xa8\xa5\x6e\xa8\x33\xf1\x6a\xd6\x43\x7b\xde\x17\xba\x4e\xfc\xf8\xea\xd7\x6e\xe5\x41\x18\x75\xad\x6d\x6e\x00\x72\xdf\xa0\xdd\x87\x2c\xe5\x33\xe5\xdb\x37\x94\x4f\x02\x73\x6d\xd7\x2a\x4f\xc3\x14\xf7\xd7\xaf\xfe\xf4\x09\xf7\x1b\xa7\x76\x7f\x28\x5c\x2c\x34\x51\x2b\xee\x47\x6d\xb1\x1a\xbf\xcd\x26\x67\x20\xab\x6c\xcd\x0b\xa0\x00\x18\x89\xd7\xeb\xb2\xf9\x6d\xcb\xe2\x66\x7f\x8e\xbf\xdc\x3f\xc3\xbf\xd8\xbf\xce\x2f\x19\x89\xdf\x6f\x24\xc6\xec\x65\x71\x23\x71\x2d\x8b\x13\x1f\xb7\x45\x15\x7d\x16\xeb\x65\x54\x30\x97\xc0\xde\x53\x68\x6a\x91\x79\xeb\x84\xa9\x9f\xc8\xfc\x62\x87\x3b\x60\xe7\x63\x2d\xb5\xc4\xce\xc6\x37\x65\xbb\x30\xb8\xed\xbd\x9b\x77\x7c\x7b\xc5\xd5\xdf\x6d\xbb\xf9\xbb\x2b\xba\xf6\x47\xef\x19\x7f\xf9\xee\x09\xb3\x22\x77\x4f\x7e\x72\xc5\xbf\xb7\x5f\xbc\x15\xe4\xdb\x1f\x06\xf4\xeb\x6b\x14\xe5\x3e\xe5\xb6\x01\xc3\xe7\x5f\x0a\xa3\xc1\x1d\x1d\xb2\x42\xf9\x07\xb7\xad\xa4\xfb\x35\xe9\x55\x71\x3e\x5b\x33\x8d\x3c\x68\x10\xba\x24\x36\x82\x1a\x3d\x8f\x5d\xb4\x39\x9d\x3a\xaa\xf7\x46\xdf\xa0\xaa\x42\xff\x00\x4c\xca\x4b\x4a\xc8\x80\xc2\x41\x46\xd0\xe9\x06\x37\xd0\x97\x46\x9d\xce\x22\x55\xf4\x2b\x2d\xed\xe7\x70\x4b\xfd\xdc\xee\x7e\x12\xd1\x67\x0f\xa4\xde\xf0\x40\x87\x0b\xeb\x65\x75\xd9\x12\x73\x8a\xa9\x24\x57\xa8\x0b\x66\x2b\xd2\x66\xcd\xfa\xae\xfa\x49\xba\xc8\x9a\xd3\x22\x07\x1b\x80\x76\xb4\x78\x03\x44\xbb\xe8\xb4\x93\x45\x85\xfa\x74\x53\x67\x45\xe9\x33\x67\xc1\xfc\x10\xd6\x2f\x14\xee\x5b\x74\xb2\x5a\x7a\x4f\x1a\x06\xdb\x97\xdd\x38\x5a\x56\x4e\xc8\x93\x43\xca\x2b\x6b\x61\xee\x11\xf0\xe1\xb6\x90\x6b\x7a\x5d\x47\x47\xd3\xac\x29\x13\x6e\xbc\x74\xd1\xd4\xdc\x10\x09\x4f\x6e\x99\x7c\xf6\xac\xc9\x13\x6f\xdb\x71\xe3\xe4\xa8\x78\x7b\xd7\xdf\xf2\xf2\x6c\xb8\x33\x21\xda\xe8\xef\xdf\xfe\x86\xef\x55\x56\x27\x66\x2d\xcb\x29\x69\x1d\x5f\xd9\x54\x59\xd2\x31\xfc\xfc\x25\xde\x07\xe6\x15\x8e\x6d\x2c\x1b\x5e\x59\x3a\x77\xd8\x45\x57\xa9\x7b\x8c\x91\x03\x21\xb2\x89\xec\xa4\x32\x31\x37\x16\x71\x59\xad\x76\xbb\xc5\x60\x90\x2d\x1e\x0f\x91\x49\x06\x80\xcf\x61\x77\xb9\xac\x2d\x71\x97\x4b\x46\xb2\xb9\x25\xae\xd3\xc9\xb2\x30\x2e\x2e\xbb\x89\x07\x79\x5a\xe2\xb4\x69\x3b\x75\xc1\x85\xba\xca\xb5\x6f\x2f\x22\x39\x7a\xa7\x9d\xfa\x5f\x1b\x71\xb3\x45\x51\x54\xf5\x9c\x11\x6f\xc4\x19\x82\x47\xe1\x5d\xdd\xa5\xd7\xac\xd1\x25\x2a\x4a\x1a\xa6\x5f\x70\xe5\x59\x6f\x97\x0f\x8e\x0e\x96\xde\x8e\x3d\x41\x76\x96\xfb\xba\x3e\xe2\x8b\x9b\x60\xe2\xf9\x50\xb1\x14\xe6\x05\xd4\xbd\x04\x23\xba\x7f\x14\xbf\x10\x87\xda\x8a\x90\xba\x87\x3f\x81\x27\xb1\xbd\xef\x68\x05\x59\x94\xf8\x9a\xed\xa1\xb7\xfa\x52\x7b\xdf\xfb\x73\xd8\x46\x0a\xbb\xfc\xf4\xb0\x39\x3d\xb0\x4d\xdd\x5f\x89\x07\x54\xbc\x44\x85\x3d\x8f\xc1\xea\x74\xa4\x32\xf1\x29\xca\x8e\x59\x05\x82\xbd\x3e\xfa\xb5\xd6\x0b\x15\x5e\xf0\xf2\xa3\xae\xa3\x2c\x76\x5a\x32\x2e\x1a\x4b\xdf\x68\x0b\xa9\x29\x52\x18\x24\xb4\xc2\x85\x50\x41\xcc\x85\x01\xe9\x7c\x64\x4e\x3f\xe8\x47\xaf\xd6\x22\x60\x1b\x06\x55\x24\xf6\x19\x69\x78\x54\x3a\x06\xd9\x8a\x74\x52\x10\x25\xb1\xd9\x65\x15\x1b\xc3\x43\x30\x14\xfa\x84\x39\x23\x60\x04\x50\x62\x0a\xa1\xa2\x10\x0a\x4f\x83\x67\x33\xc5\x73\x13\xc7\x43\xf5\x9d\x51\x03\xff\xd1\xca\x03\xb4\x3c\x33\x63\x0d\x04\x0b\x6e\x56\x9e\xc7\xdc\xb0\xc5\x0d\x6b\xdd\x50\xe1\x06\xab\x1b\xdc\x70\xdc\x08\x47\x8c\xf0\x82\x11\xee\x30\xc2\x66\x23\xac\x35\xc2\x38\x23\x0c\x34\x82\xdf\x08\x56\x23\x3b\xa1\x35\xe6\xc8\x68\xe2\x27\xce\xf6\xb4\x27\xda\x75\x92\x23\x6a\x8c\x03\x32\x89\xec\x77\x48\x24\xca\xf7\x50\xdf\x85\xe6\x48\x33\xf1\x70\x64\x46\x39\x31\x33\x32\xea\xb1\x09\x1b\x45\xc1\x62\x35\x9b\xd4\xcd\x82\xa9\x50\x5c\x1e\x6f\xb0\x28\x14\xad\xa9\x8d\x48\x72\xc0\x8d\x2f\xa9\x1b\xdc\xb4\x61\xcb\x96\x0d\x4d\x83\xeb\xc8\x07\x50\x3c\xec\xd2\x1b\xce\x2e\x38\xfb\x86\x4b\xd9\x69\x40\xb4\xe1\xec\x7e\x05\x7f\x2b\x6c\xa0\x38\x0b\x63\x76\x11\x49\x46\xbd\x11\x61\x8a\x93\xa1\x37\x8b\x14\xef\xbe\xaa\xba\xba\x74\xdc\x6c\x1b\x6c\x6d\xc4\xe3\x75\x17\x85\xec\x41\x38\xda\x83\x8d\xdc\xd9\x93\x4f\x57\xf0\x14\x7a\xf5\xd8\x88\x44\x84\xcd\x14\xb7\xc9\xdc\x87\xde\xa2\x10\x43\x28\xc9\xc1\x9a\xda\x40\x54\xdc\x90\x8e\x07\x36\xfc\x0c\xbd\x92\x91\x62\xa4\x94\x72\x7a\xb1\x5e\xa2\x7c\xf8\xa0\x0f\xbd\x85\x6c\x0b\xb4\xcc\xd8\xe1\xf1\xda\x23\xb8\xb4\x07\xdb\x5d\xe9\x6c\xe9\xc5\x5f\x2f\x0a\xc5\x9c\x46\xa4\xc7\x6e\x8b\xd7\xe4\x30\x59\x30\x92\xa4\x0c\x1f\x32\xa6\x53\x7d\x1a\x4e\xa7\x95\x22\x9d\xe7\x58\xe9\xb9\x4e\xe3\x7e\xea\x42\xdd\x1f\x9f\x2c\x97\x17\x0d\x8a\xe5\x48\x76\xbb\x49\x74\x38\xbc\x7a\x0b\x76\xbb\xbd\x26\x8b\xe0\xcb\x30\x79\x2d\x6e\x07\xa3\x89\xd6\x09\x2b\x62\xef\x72\xa6\x51\x94\x5e\x3f\x69\x65\x4f\xab\xa9\xd4\x45\x7a\x8d\x25\x70\xcf\x35\xdb\xa3\x6c\xeb\x6e\xe2\xf4\x10\x94\x85\x46\xc6\xf2\x0d\x6e\xb7\x4d\xef\xf1\x64\x99\xc1\x29\xa1\x0c\xa7\x2d\x2b\x43\xc8\xce\xb1\x65\x39\x7c\x1e\x82\x3c\x56\xc1\x2c\xe9\x51\xc5\x21\x46\xd6\x87\x87\x6d\x87\x7a\x28\x4b\x9f\x89\xa0\x96\x3e\xe0\x0e\x38\xcf\x44\x9f\x0d\x3e\x52\xf2\xf6\x9f\x4a\xe4\xfc\x16\x61\xea\x99\xc8\xa4\x95\x3f\xbc\xfb\x33\x72\xa7\xb8\x1f\x65\xa3\x12\x4a\x67\x51\x0e\x35\xc4\xa8\x40\xa7\xf3\x22\x52\x56\xea\xf1\xb8\x2a\xbd\xb9\x4d\xae\x58\x26\x58\xf3\x4c\x79\x2d\x71\x93\x55\x0c\x8d\x8b\x8b\x9e\x64\xbf\x40\x1d\xbd\x29\x65\x23\xa8\x3d\x33\x27\x6c\xa6\xc4\x00\xda\xbc\x2c\x9f\x15\x89\xb0\x69\xed\x7c\x39\x54\x4b\xef\x1c\x24\x7d\x9a\xd6\x41\xee\x6c\xda\x72\xf0\xe2\x9b\x1f\xb8\xfa\xfd\x4d\x33\xb6\xe4\x0b\xc2\x0d\xbf\x59\xb4\xba\x60\xc1\xb8\xb1\x7b\xf6\x2d\x73\xac\x1e\x7b\xee\x8d\xb3\xe6\xc7\xc7\x6f\x5b\x4a\x1e\x7a\x48\xb9\x52\xf9\xea\x37\xcf\xed\xbc\x15\xc2\x37\xcd\x9e\xb8\xfc\xc4\xbf\x26\x05\x6e\x0c\x2a\x5f\x24\xde\x98\xbe\xfa\xd7\xca\xd7\x9b\x2f\xfe\xf5\x35\x90\xc9\xcb\x13\xa6\x8d\xf4\x5e\xb1\x89\xaa\x0a\xdb\x85\xe0\x23\x92\x24\x8b\x32\x16\xb1\x41\x2f\x09\x44\xd0\x89\x58\x06\xb9\x2d\x0e\xda\x78\x39\x5f\x5b\x94\xf2\x25\x55\x7f\xb1\x18\xa2\x10\xd1\xe3\x80\xb0\xb7\x73\x25\x7c\xf0\x3c\x7c\x93\xb8\x52\x59\x4a\x8a\x5a\x84\x1f\x3b\x75\xc2\xf4\xce\x97\xd4\xf6\xeb\x42\xa5\x59\x2a\xe2\xfd\x88\xb3\x62\x7e\x3b\xb6\xe8\xb1\xde\xe5\xd6\x11\x91\xb4\xc6\x45\x5b\x5b\x5c\x24\x76\xfa\x88\xcd\xc6\x99\xa8\x00\x34\x54\x25\x33\x2b\xed\xb5\xa5\x9f\xf6\x9b\x54\x17\x34\xe5\x7f\x06\xe8\xef\x85\x3b\x77\x8a\x4f\xed\xdc\x99\xf8\xdb\xce\x44\xe1\x4e\xa5\x39\x9a\x25\x4d\x60\xfd\xbf\x9f\x1e\x65\x7d\x3f\x69\xe4\x4f\xcf\x64\x69\xf3\x86\xd3\x95\x66\xb1\x90\xd2\xe0\x43\x4d\xb1\x42\x40\x56\x3b\x72\x9a\xc4\xac\x4c\xbb\xc3\xe7\xf0\xd1\x32\x22\x9b\xcd\xe1\x76\xb3\x90\x28\xd8\x82\x67\xc5\x8d\x46\x4b\x16\x4a\xad\xf3\x64\x0b\x65\xeb\x7c\x7c\x72\x94\x1d\xa1\xab\xd6\x1f\x8b\x7f\x01\x81\xaa\xc1\x02\xf7\x0a\xa3\x7a\xbe\x31\x98\xba\x0c\x01\xd2\x90\x78\x03\x7e\x5f\x3c\x6b\x76\xeb\x98\x01\x06\xea\x06\x76\x8e\xc2\x43\x13\x5f\x08\xe3\x87\x96\x2c\xfb\x4a\x39\x0f\x8f\x0e\x75\xfd\x05\x30\xe5\x2f\xfe\x54\x69\x1f\x45\x46\x13\xf3\x38\xe5\xb7\x3f\x58\x18\x8d\x7f\xc7\x2b\x84\xbb\xf0\x7b\x54\x0f\x3c\x31\x03\x46\x82\x48\xf0\x23\x71\xb2\x0b\xa9\x7b\xa7\xeb\xb4\xc8\x1e\x77\x75\x8d\xc4\xef\x75\x74\x74\x77\x27\xf7\xa4\xd9\x24\x39\xc1\xcb\x78\x2f\x2e\x87\x9b\x88\x9f\x1a\x8f\xcc\x98\x81\xda\x11\x93\x99\x6f\xc2\xd6\x82\x76\xf0\xed\xd7\xbd\xb7\x78\xc3\x4d\x7c\x9f\x58\x75\xf5\x08\x7c\x9f\xb6\x81\x9a\xe1\x89\x74\xff\x4b\x68\x97\x26\x51\xa9\x28\x8a\xd1\x06\x41\x47\x74\x7a\x83\x40\x1e\xa1\x9d\x5c\x90\x25\xf0\x30\xc6\xf0\x59\x00\x6d\x67\x1f\x77\xab\x68\x8f\x41\x0f\x11\xbc\x64\x91\x72\xec\x01\xb0\x02\x86\x7d\xd3\x2c\x64\x50\x4b\xc2\x2f\x3e\xcd\xd7\x37\xd7\xa1\xd7\xc4\x35\xe4\x18\xf5\x03\xf3\x51\x18\x96\xc6\xba\xf3\x32\xed\x62\x50\x40\xc5\x46\x64\xac\xac\xf0\x16\x59\x8a\x1e\x89\x63\x3b\x98\x45\x30\x11\x31\x33\x68\x17\x74\x2e\x4b\x4e\x99\xae\x8c\x32\x40\xaf\x03\x8b\xee\xb9\x4a\x78\xb0\x12\x6e\xad\x84\xcd\x95\xb0\xb6\x12\x16\x55\xc2\xb9\x95\x30\xba\x12\x06\x56\x42\x69\x25\x64\x55\x82\xb9\x12\xa0\xbb\x12\xbe\xa9\x84\xf7\x2a\xe1\xb5\x4a\xa0\x09\x1e\xae\x84\x3b\x92\x09\x96\x24\x13\x34\x54\x42\x05\x4f\x60\xad\x64\xf0\x5f\xf4\x86\xef\x93\xc1\xb8\x64\x06\xfe\x4a\xc0\x34\x41\x9d\x9a\xc3\x0b\x95\xb0\xab\x12\xb6\x54\xc2\x86\x4a\x68\xe5\x50\x2a\x56\x7f\x12\xeb\x11\x9e\xf3\x12\xfe\x56\x7d\xa5\x3e\xdf\xc0\x81\x19\xd8\xe3\x95\xd0\xab\x67\xd7\xbb\xf7\xd7\xfa\xf3\x3b\x6e\x2f\xe8\xd5\x59\x44\x15\x33\xb5\x5e\x4e\x45\x24\xad\xdf\x97\xdc\x20\xe9\xe5\x5b\x2f\x59\xad\x93\xf4\xe9\x57\x3e\xc8\x52\x98\x2f\xc9\x49\xcf\x17\x92\x2b\xc5\xe8\xad\xb8\xe6\xd9\xcd\x6f\x6d\x1b\xfa\x60\xdb\xd6\x3d\x7b\xb6\x2e\xd9\xdb\x30\xf4\xae\xf3\xb6\x3e\xa1\xbc\x3e\x71\xf3\xd0\xc1\x9b\xe3\xb3\x37\x6c\x4c\xbc\x35\x70\xf3\x8c\xb6\x75\xab\xe7\x4f\xba\x1a\x8f\xbd\xef\x03\xd0\x6d\xb8\xec\x8d\xc7\x1e\x78\xef\xf2\xf5\xeb\x36\xbc\xb9\xe8\xea\xdf\x5c\xf3\x9b\x3b\xd6\xaf\xd9\xa1\x7c\x79\xf5\x96\x3b\xd7\xad\xbf\xf5\x1a\xd6\xe6\xdc\x8c\x90\xd4\x26\xbc\xca\xf7\xdf\x61\x51\x14\x24\x99\xb5\x2e\x87\x53\x71\x4b\xa9\x23\x4a\x2d\x36\xdc\x3c\x53\x58\xd8\x39\x40\x78\xb5\xf3\xa6\x99\x6a\x5b\x95\xd9\xad\x08\x8f\x0a\x3a\xe4\x84\x39\xb1\x39\x46\x83\x13\x19\x90\xdb\x35\xc9\x3d\xc7\xbd\xdc\x4d\x1a\xdd\x50\xed\x06\x87\x3b\xdf\x4d\x7d\x23\xf8\x97\x1b\xde\x74\x7f\xea\xc6\x2f\xbb\xe1\x1e\xf7\x53\x6e\x7c\xa3\x1b\x18\xd4\xe5\x6e\x32\xd9\x0d\xc3\xdd\x50\xe4\xae\x61\x70\x2e\x37\x5e\xf0\x96\xfb\x73\xf7\xf7\x6e\x42\x21\x9f\x72\xc3\x5d\x6e\xb8\xdc\x7d\xbd\x1b\xaf\x74\x43\x3b\xf5\xa7\xf6\x76\x6f\x8c\xf9\xcf\x9d\xd9\xe4\x70\x43\x1a\xd2\x03\x6e\x78\x42\x85\xbb\xc7\x4d\x28\x4c\x2c\x66\x6d\x6e\x69\x72\xb9\x0b\xdc\x18\x73\x28\x9e\xae\x7c\xc8\xc8\x26\x8a\x86\x91\x87\x87\x72\xe2\xf2\xdd\xe0\x72\x03\x05\xa9\xfb\xce\x0d\x9f\xb0\xfc\xf6\xb9\xdf\x74\x13\x9a\xa7\x9a\xc2\x5a\x56\xa5\x62\x41\x6e\xf8\x96\x63\x79\x31\x46\x7b\xde\x4d\xd7\xba\x81\x91\x8e\x5b\x68\xe2\x8f\xdc\xdf\xba\x31\x7f\xe3\xc8\xcc\x69\x7a\xc1\x0d\x77\xba\xc1\xef\x6e\x75\x63\xab\x48\xbd\xbb\x8a\xaa\x8a\xc3\xc0\xc7\x73\xd9\x50\x42\x29\x15\xa4\xd2\xd6\xf4\x21\x84\xd2\x19\xec\xa9\x2a\x62\xa5\xa7\x0e\x2f\x68\xa3\xbb\x49\x1b\x2b\xda\xf9\xe8\x1b\xed\xf1\xd8\x83\x76\x75\x1e\xd8\x0e\x99\xcb\x5f\xbf\xf4\xb2\x37\x2e\x9a\xb7\xef\xce\xbb\x5e\xc4\x18\xdd\xf8\xcd\x15\x97\xff\xeb\x7a\x05\x61\xfc\xfc\xa7\x9f\xbc\xac\xa8\x7b\x0f\x6f\x48\xbc\x87\xb7\x53\x5d\x0f\xc1\xa1\x98\xc5\x89\x50\x8e\x3e\xa7\x9f\xbe\x38\xb3\x60\x7c\x3c\xc0\x28\xef\x76\x78\x9a\x02\x01\x7f\x66\x6b\x26\xae\xc8\x6c\xc8\x5c\x92\xb9\x2b\x53\xb0\x66\x8e\xcb\xdc\x90\xb9\x25\xf3\x85\xcc\xee\x4c\xc9\x40\x32\x25\xeb\xf8\xb8\x29\xe6\xf4\x34\x99\x4c\xd2\xca\x62\x98\x53\x0c\x93\x8a\x61\x78\x31\x54\x17\x43\x41\x31\x78\x8a\x41\x2a\x86\xef\x8b\xe1\xf3\x62\x78\xab\x18\xf6\x15\xc3\x53\xc5\x70\x4f\x31\xdc\x58\x0c\x57\x16\x03\x85\xef\x28\x86\xc9\xc5\xd0\x58\x0c\x35\xc5\x50\xc4\xe1\x85\x62\x58\x90\x4a\x70\xa0\x18\xae\x2f\x86\x4b\x8b\x01\x96\x16\x43\x5b\x31\xb4\x24\x71\xe7\x15\x83\x8d\xc3\x7e\x57\x0c\x9f\x16\xc3\x9f\x39\xee\xc7\x8a\xe1\x4e\x9e\xe0\xf2\x62\x58\xce\x69\xa1\xc0\x95\x1c\xd8\x95\x06\xfc\x66\x92\x10\x15\x92\x62\xc6\x2a\xea\x58\x31\xa0\x62\xa8\xfb\xb6\x18\x3e\xe2\x28\x63\x67\xbd\x58\x0c\xd7\x26\x51\xd0\xfc\x8e\xf3\x0c\x96\x26\x81\x2b\x39\x7c\x0a\xfc\xc5\x24\x89\x31\x0e\xdc\xc7\x0c\xf4\x1a\x00\x6a\xfd\x85\x5d\xf9\xad\xbf\xb4\x2d\xbf\x82\x0d\xe7\xa2\x0c\x75\x25\x14\x1f\xda\x85\x9e\x01\x21\xa7\x8d\xaf\xd1\xa3\x2e\x94\x15\x82\x5c\x1c\x9c\x2e\x4c\x2c\x98\xda\x91\x50\x74\x30\x50\xe7\x8a\x19\x8f\x67\x2d\xf2\xec\x3b\x1b\x7d\x71\xab\xc3\xe6\x6e\xac\x8b\x36\x0a\xb2\x5e\x9a\x7b\x6b\x63\xce\x04\x93\xe0\x16\x5c\x23\xea\xa3\x8d\x70\x12\x4c\x60\x5f\xf8\xfb\x55\x2e\x93\x7e\xe8\x90\xc6\xdb\x2f\x4e\x7c\x7e\xb6\xf2\xbc\xf2\xd9\xf9\xbf\xbb\xd0\x6b\xd0\x99\x5b\xbd\x23\x6e\x5f\xab\x8e\x7f\x40\xb9\x30\x40\xf0\xd3\x76\x3a\x02\xc1\x58\x66\xbe\x4e\x17\xd4\x57\xb8\xdd\x95\x1e\xbd\xa7\x3a\x5a\x59\xe4\xa7\xcd\x84\x3f\x96\xd9\xaf\xc9\xcf\xa4\xaa\x40\x6f\x6a\xf2\xfb\xcb\x82\x99\x65\x99\x8f\xc4\x51\xd9\x9d\x65\x7f\x2e\xfb\xb6\x4c\x30\x93\x32\x8f\x49\x34\x3d\x12\x17\x19\xa0\xc8\x00\x37\x52\x40\x51\x74\xe8\x69\x57\xfa\x11\x4a\xa5\xdf\x51\xe1\xb8\xc3\x71\xc4\x21\xea\x1d\x2f\x44\x61\x57\x14\xb6\x44\x61\x49\x14\xc6\x45\xa1\x22\x0a\xfe\x28\x58\xa3\xd0\x1d\x85\x6f\x92\xcf\x8f\x47\x81\x82\xdd\x11\x85\x0d\x51\x68\xe5\x60\x0d\x1c\x92\x82\xd5\x51\xa0\x23\x51\x78\x8c\xbf\x68\xe0\x89\xbb\x93\x09\x28\xde\xa5\x51\x68\x89\x42\x65\x14\x7a\x98\xde\xab\x2e\xd2\x2b\x8a\x99\xf1\xd4\xdc\x42\x69\xaf\x75\xc2\x3d\x8f\xd2\xd7\xc3\xab\x3e\x78\xbe\xba\xc2\x57\x0d\x82\xe9\x51\x97\x00\xd7\x46\x2c\x98\x9c\xf1\x45\xe9\xc2\xcd\xa3\x66\x15\x8d\x19\x6b\x9e\xeb\xb8\x62\x65\xed\xaa\xd1\x93\x27\x06\x47\x8c\x75\xce\xb3\xc7\x16\x4e\x38\xe3\x1b\xfc\xea\xea\x86\xba\xc5\x97\x3f\x77\x7b\x7d\x43\x53\xff\x05\x57\x5d\xfa\xeb\x66\xa5\xa3\xef\x13\xee\x83\x2c\x46\x57\x0b\x45\xc2\x3e\xea\xeb\x2d\x8a\x8d\xc0\x92\x53\x6f\x35\x4a\x2e\xb7\xc3\x81\x6c\x56\x1b\x6d\xcb\xf3\xac\xf0\xad\x15\x76\x59\xc1\x66\xa5\x4e\x58\xcc\xda\x62\xfd\xc8\x2a\x98\x88\x55\xaf\x97\x8d\x26\x23\x75\x31\xf2\x4c\x2d\x26\x6c\x35\x1d\x67\x5f\x47\x4c\xdd\x26\x42\xfb\x59\x4c\x2e\xd5\xc5\xed\xea\x7a\xbd\x0b\x7a\xee\x93\xc1\x8b\x22\xee\x00\xa1\xed\x07\x09\x3a\xa9\x23\xe2\x0c\xd0\x4f\x84\xd4\x7f\xa9\x1c\x3e\x86\x0d\x89\x47\x0f\xac\x3d\xf0\x25\x44\x8e\x25\xbe\xc7\xe3\x0f\xac\x23\x0f\x74\x28\x87\x3a\x94\x4f\x21\xbb\x03\xaa\x3b\x20\x9b\xfa\x26\x7f\x87\xb1\xc2\x5d\x02\xe6\xb1\x14\x8c\xa8\x3e\xe6\x17\xf5\x20\x19\x30\x06\x93\xd9\x60\x34\x12\x89\x2d\x08\xaf\x90\x89\x4c\x21\x62\x04\xeb\x08\xab\xa9\xc3\x15\x33\x0e\x53\x27\xe8\x70\x4f\x85\x68\x11\xd1\x92\x1f\xe6\xa7\x91\x67\xd4\x0f\x3c\xd5\xd1\x81\xc7\x76\x74\x28\xef\x74\x74\x50\x19\x9f\x45\xfd\xee\x4c\xe1\x46\xbe\x1f\x3c\x1e\xab\xd5\x49\x7a\xc0\x92\x00\x12\x98\x8c\x7a\xc3\x23\x71\xfd\x83\x02\xb6\xc4\x25\xc1\x52\x29\xb5\x49\x2f\x4a\xe4\x31\x09\xa4\x3c\x04\x2d\x42\x9b\x70\xad\x40\xfc\x42\x85\x30\x8e\xba\x8f\xbb\x90\xaf\x61\xc6\x8c\x48\x24\xf3\xf0\x8c\x0b\x4a\x53\x01\x76\xd2\xfa\x8b\x4e\x4a\x86\x1e\x72\x70\x20\x3a\x8b\xd2\x70\x8c\x14\x53\xbf\x71\x4b\x15\x1c\x9d\xa7\xac\x56\x56\xcf\x9b\xc4\xe3\xbc\xa9\xb4\x64\xff\x1c\x2d\xb4\x83\x1e\x47\xd8\x52\x89\xda\xd0\x8b\x88\x3c\x46\xab\x38\x4f\x12\x5b\x70\x1b\xbe\x16\x13\x3f\xae\xc0\xe3\x30\xc1\xbf\x48\x4b\x2d\xf3\x8f\x81\xb6\x9c\x81\xe8\x6c\x4a\xc8\x31\xf2\x0c\xee\x1a\xf9\xec\x3c\xf8\x15\xfc\x6a\x9e\x52\x5a\x95\x38\xc6\xf9\x72\x0b\xa5\xa5\x5a\xb8\x04\x09\x48\x8f\xfa\xc5\xec\x58\xa7\x13\x25\x49\x10\xe9\xbd\xd1\x80\x75\x22\x6d\xeb\x0e\xa7\x18\x9e\xb2\x50\x11\xbb\x1e\xec\x85\x01\xfa\x7d\x0b\x1c\x86\xc3\x5d\x4f\xe3\x93\xca\x65\xca\x65\x78\x2d\x96\x12\x27\x13\x57\x4c\xc0\x12\x3c\xa4\x4c\xe6\xb2\xf9\x77\xf4\x1a\xf7\xaf\x99\x0f\x82\x68\xf7\x43\x96\x10\xe9\xe5\x83\xf0\x28\x3a\xd0\x32\x8f\x92\xb7\x42\x99\x8c\x6d\x1d\xbc\x6d\xc3\xf9\x89\x5b\xc8\x5f\xa4\x87\x90\x9b\xfb\xd5\x00\x3a\xda\xbd\x37\x8a\x6c\xc3\xfe\xe1\xb4\xc4\xb4\xbd\xd4\xb6\x98\x04\xf3\x43\x45\x6c\xf0\x50\x96\xdc\x78\xf7\xb6\x07\xd6\x37\x8c\x8e\x14\xe6\x9a\x6d\x45\x01\x5b\x81\x5e\x4a\xdc\x22\x4f\xde\xf7\x7d\x43\x65\xbf\x6a\x83\xae\x24\x14\x0a\x2e\x50\xfd\x1c\x31\x71\x0b\xde\x4d\xf3\x70\xa1\x0f\x63\x0f\xba\x30\xd6\x79\xdc\x2d\x1e\xb0\x7a\xfc\x1e\xfc\xad\x07\xee\xf0\xec\xf2\xe0\x36\xcf\x46\x0f\xf6\x7b\x2a\x3c\xe3\x58\x47\x18\x16\xbe\xe0\x39\xe2\xc1\x1b\x3d\x77\x7a\xf0\x38\xcf\x12\x0f\xce\xf3\x54\x7a\xf0\x11\xcf\x71\x0f\xbe\xd6\xf3\x98\x07\xb7\x7a\x36\x78\x70\xa5\x27\xe6\xc1\xc7\x3d\xdf\x78\xba\x3d\xe4\x45\x0f\x2c\xf1\x6c\xf1\xe0\x18\x43\x4b\x3d\x59\x0f\xfc\xd9\xf3\x91\x07\x6f\xf0\xdc\xe1\xc1\xc9\xac\x3e\xf2\x7c\xeb\xc1\xbb\x3c\x90\xca\x0a\xd3\x8c\x68\xfe\xbb\x3c\x2f\x78\xf0\x52\xcf\xb5\x1e\x5c\xe1\x69\xf0\xb4\x7a\x88\xcd\x03\x94\x05\x88\xb3\x20\xcd\x91\x4d\x6b\x6a\x92\xb7\xc9\x3b\xbb\x23\xe5\xe8\xf5\xf4\x40\xbc\x1e\x75\xd1\x19\xce\xdf\x76\xf7\xe5\x03\xc7\x56\x15\x04\x32\x0d\x7e\xbf\x2d\xc7\x2b\x3d\xf4\xe3\x03\xaf\xfc\x67\x50\x45\x28\x6a\x13\x8a\x0b\x23\x1b\xb8\x8f\xf1\x3d\x2e\x14\x77\xe3\xa7\x69\xa5\x6d\xdf\x4d\xa8\x58\x00\xda\x0b\x38\xd6\x1e\x87\xae\x6f\x44\x78\x41\x84\x5d\x22\x6c\x10\xa1\x41\x04\xab\x08\x4b\xbf\xe1\x37\xf4\xea\x5a\x11\xf2\x44\x78\x4c\x84\x98\x08\x36\x5a\x6b\x22\x0c\xfc\x56\x84\x17\xf9\xa3\x8d\x22\xb4\xf0\x17\x15\x1c\xb4\x5b\x84\x23\x22\x6c\x11\xa1\x55\x04\xbf\x08\xdf\x24\x51\xf6\x2a\x5e\xb2\x4c\xe9\xa6\xbc\x27\x28\x22\xa1\x1d\x54\x83\xf8\x02\x2e\xdc\xba\x95\xd7\xeb\x8b\x89\x6d\x78\xbc\xdc\xc4\xfb\x74\x7a\x4c\x08\xed\xd4\x29\xe8\x24\x8b\x1c\x92\xec\x8f\x45\xec\x41\x78\x71\xeb\x56\xb9\xe9\xfb\xd1\x54\xd6\xae\x49\x6c\xe3\x65\x14\x51\x7e\xcc\x40\xa8\xd3\x0c\xb2\xa8\x20\xda\x87\xc3\x4f\xc4\x51\x97\x3a\x98\xa0\x6d\x88\x63\x03\xb5\x6e\xda\xe9\xc4\xd7\x90\x7e\x89\x05\x5b\xf1\xd3\x5b\x3b\xcf\x57\xf9\x94\xd8\x46\x72\x93\x38\x44\x4c\xbb\xf1\x92\xa0\x60\x91\xe3\xc0\x7d\x71\x10\x1e\xdc\xc9\x40\xfa\x6d\xa5\x34\x9f\xfc\x40\xb8\x4e\x95\xf9\x6b\x18\xaf\x65\x36\x36\xe0\x67\xfe\xba\x24\xc8\x1c\xc1\x53\x0c\xc1\x49\x1e\x92\x2d\x45\x04\xf7\xdc\xf1\x35\x5b\xf1\x4d\x5d\x6f\xcb\x4d\x9d\xe7\x6f\xd5\xea\x8a\xe4\xf2\xf4\x94\x06\xcc\x62\x59\x49\xe4\xe4\xcf\xd1\x10\xb1\x1b\xf0\x4d\x8c\x06\xe1\xba\x93\x1f\x68\x34\x30\x5e\x50\x1c\x32\x2a\x8e\x99\x44\x00\x84\x74\x82\x5e\x56\xfa\x10\xd2\x83\xa8\x87\x1a\xc6\x14\x4a\x0f\xe5\x0a\x27\x28\x9d\x2f\x1a\x3e\x0b\x8b\x60\x22\xe8\x91\x4e\x52\x28\x5d\x72\x2f\xba\xd2\xf1\xa9\xa4\x05\x39\x71\x2a\x75\xdf\x8f\xd6\x78\xc4\xf0\xf1\xba\x92\x51\x59\xcc\x2a\xc8\x32\x22\x84\x23\x64\x21\xc3\x38\x42\xe8\x4a\x0e\xbd\xa7\xfb\x54\x4c\x44\x38\xcf\xc5\x17\x58\xb5\x51\x49\xe9\x3c\x9f\xa2\xd4\xe4\x9b\xd3\x47\xf1\xd1\x7a\x43\xb2\x4c\xf1\x91\x93\xac\xe8\x3f\x8f\xcf\xce\x4a\xcd\xf9\x77\x13\xa7\x91\x55\x82\x46\x1f\xc5\x67\x44\xb5\x31\x97\xa8\xd3\x61\xa3\x91\xa2\x34\x23\x93\x81\x96\x59\x67\xc4\x46\x8a\xf4\xc9\xb8\xc8\x8a\xad\xcd\x92\xa5\xe1\x8d\xa4\xa3\x0e\x68\x1c\xe0\x2c\x4d\xe6\xc0\xa9\x66\xfb\xcd\xbf\x87\x0b\xc4\xdd\x64\x21\x6f\x3f\xc3\x54\x6a\x19\xd9\x82\xa0\x13\x05\x5e\x4f\x62\x22\x49\x7d\x67\x72\x2c\x0c\x52\x0d\x03\xe3\x05\xa8\x2a\x73\x72\x08\x55\x9b\x77\xb6\x6e\x55\x6e\xe6\xaa\x83\x30\xbc\x43\xeb\xeb\x2f\x5c\x77\x64\x94\x17\xb3\x50\xd5\x15\x90\xa0\xd3\xcb\x84\x72\xf8\x24\x5b\xff\x9a\x3e\x3a\xc4\xf5\x88\x7d\x28\x0a\x98\xaf\xea\x93\x7e\x77\x8f\x4e\x51\xfa\xf4\xa8\x2e\x66\xc5\x92\x64\x94\x59\x94\x24\x83\x51\xaf\x08\x32\x27\x51\x48\x24\x35\xac\x33\x7d\xbb\x0a\xa4\x8f\xbe\x52\x26\xb8\xd3\xd4\x8d\x73\x82\x2c\xdc\x7a\x6c\x6b\x57\x3e\xd3\xf3\x77\x34\x59\xd0\xa3\xf2\x98\x59\xd2\x63\x51\x2f\x1a\xc0\x88\x25\xbd\x44\x11\xef\x8e\xeb\xbb\x04\x9d\xc2\x16\x09\xa6\x36\xb4\x26\xc9\x76\x6b\xb1\xd5\xec\xe2\x6e\x25\x87\xa2\xe3\x6a\xcc\xf8\x2b\x06\x35\x1e\x70\xda\x45\x5a\x8b\x03\x63\x16\xda\x26\x9a\x09\xd2\x4b\x48\x32\xd1\x5c\x28\xea\x3d\x71\x29\x61\xec\xb1\x10\x1a\xfd\x91\x53\x5a\x60\xd5\x54\x68\xdf\xef\x90\xf7\xbb\x76\x53\x2e\xe1\xe5\x34\x4b\x5a\x88\x93\xcf\x0a\x4b\xd4\x72\xa8\x3a\x92\xe4\x15\x8f\x65\x6b\x30\x0a\x94\x59\x3a\x45\x22\x9c\x57\x52\x27\xd6\xab\xda\x92\x48\xe3\x15\xa4\xcf\x1f\xd1\x4a\x8d\xaa\x31\xe3\x0c\x8c\x4d\xd4\xb4\xc0\x05\xb4\x64\x27\x8b\xc9\x87\x29\x3d\xfc\x0b\xe7\x55\x38\x66\xd3\x4b\x22\x96\xb0\x11\x19\x28\x83\xa4\x53\x15\xa7\x17\xb3\x48\x32\x10\x1d\xb5\x57\xef\x33\x5e\xa9\x16\x4b\x15\x44\xac\xe2\xed\xe1\x95\xce\xc8\x02\x0a\x99\xcc\x82\x5e\x6f\x32\xa8\xbc\x32\x24\xb0\xac\x70\xb9\x7c\x22\x2e\xa6\xf1\xaa\x67\x4f\x64\xca\x0f\x88\x02\xfb\x0a\x90\xbf\x6c\xed\xda\x8d\x97\x6f\x55\x72\xf0\x72\xb2\xf0\x64\xb1\xd8\xc8\xcb\xb1\x95\xdb\x27\x26\xf7\x54\x3e\xf5\x2c\x8a\x07\x95\x2b\xbd\x9e\xf2\x4a\xa7\x33\xf2\x8a\xa1\x9c\x4a\x24\x2d\x55\x67\xca\x52\x95\xf6\xe6\x94\x6a\xad\xdc\x49\xfb\xc9\xc4\x8a\xd9\xd0\xae\x7c\x5a\x38\xd5\x2f\x78\x47\xb3\x09\x7a\x54\x12\x33\xea\x44\xac\x17\xf5\x06\x81\x5e\x50\xc4\x4f\xc7\xb1\xae\x0b\x49\x27\xf9\xda\xd3\xd2\x5e\x42\xa5\xea\x2c\xbd\x26\x43\xb6\xc2\x89\xae\x82\xad\xc7\xb8\x1d\x14\x83\xd4\x12\x52\x99\xd2\xe8\x4e\xca\x94\xa8\x33\x8a\x46\xea\xeb\x0a\x82\x59\x67\xe4\x14\xeb\x3a\x39\xe9\xbb\x69\x25\x4b\xaa\xaa\xf5\x22\xbe\x57\x36\xda\xf7\x3b\x5b\xc9\xe8\xae\x02\xaa\x79\x70\x22\x71\xb5\xdc\x74\xf2\xd9\xad\xe2\x31\x5a\x0e\x5e\xdf\x70\x01\xb7\xbb\x5c\xa6\x24\x8c\x39\x9f\xa8\x4c\xc9\x27\xff\xe7\x32\x15\x51\x65\x8a\xda\x22\x2e\x53\xe4\xc3\x93\xc5\x49\xdf\x80\xdb\x0a\x2e\x53\x44\xa2\xcd\x0d\x32\x82\x41\x27\x9c\xa4\xf9\x41\x8f\x75\x3f\x55\xa6\x40\xc5\xca\x78\xf5\x17\x4a\xff\x09\x55\xac\x34\xa1\xe2\xb6\x8d\xe3\xd5\x78\x65\xa4\xde\xbf\x8e\xca\x94\x1e\x20\x25\x53\x9d\x82\x74\x32\x99\x47\xe2\x8c\x32\xc5\xb3\x09\x44\x54\x99\xea\x2a\x20\xa3\xb7\x2a\xf2\xd6\xc4\xd5\x70\x82\x96\x43\x6c\xec\x54\x6d\x5e\x4f\x9b\x67\x44\x83\x63\x36\x09\xb3\x00\x4e\x54\x82\xa9\xd6\x1b\x95\x9f\x13\xab\x3e\xfc\xea\x25\x5a\xa9\xc6\x50\x6b\x10\xb9\x74\x31\x6d\x4f\xd9\x17\xde\xe6\x18\x51\x24\xe6\x34\x50\x93\x25\xc9\x46\xd9\x24\x98\x65\xa3\x82\x74\x7d\x9b\xec\x48\x3a\xf3\xd2\xdb\x5b\x66\x7a\xb9\xb0\x51\x8b\xc2\x2c\xb8\xd6\xee\x72\x0b\xcc\xe2\xd8\x24\xf3\xa1\xc6\x0b\x59\xd1\xc8\x98\xdd\x22\x49\x76\x04\x26\x9d\xce\xaa\x07\xbd\xcd\x6e\xb2\xf2\x32\x99\x3a\xb9\x49\x8e\xe9\xa9\x4d\x36\xe0\x93\x7a\xe0\x46\x33\xd2\x90\xde\xa9\x48\x9f\x81\x0a\xda\x23\x4e\xb5\x79\x52\xbd\x90\x85\x5b\xb7\x1e\xe3\x56\x8d\x8b\x61\x62\x9b\x7e\x37\x15\xc4\xae\x7c\xfd\x6e\x2e\x8a\x69\x3e\x00\xe3\xaf\x83\xf1\x97\x1a\x07\x33\x15\x46\xda\x26\xa6\x8b\xa3\xf1\x14\x71\xec\xcb\xdf\x1e\x81\x0c\xa6\x44\x32\x29\x93\xdf\x8f\xa6\x96\x4e\xb3\x47\x1a\x6f\xfb\xc7\x1c\xd4\xce\x19\x8c\x92\x91\xb6\xbf\x46\x49\xd1\x9d\xe2\x75\xf4\x62\x6d\x9a\xe7\xc1\x38\x6b\xa0\x72\xc9\x5b\xb5\x94\x07\x22\x06\x19\x63\x49\x2a\x0f\x95\xaf\x8d\x31\xbb\x44\x8b\x64\xc4\xc4\x48\x6c\x76\xd9\x6c\xb6\x59\x4d\x5c\x48\xad\x09\x62\x54\x92\x6d\x51\x27\x12\xb8\xd1\x38\x9d\xa4\xa6\xb7\xa5\xac\x1b\xad\x1a\xc1\x21\xbc\x59\x66\xd2\xba\x95\x5b\x42\xb5\x71\xa5\x42\xab\xd9\x42\xac\xfa\x1a\xd4\xf6\xb2\xb2\xc6\xb8\x37\x64\x32\x1b\x09\x31\xeb\x28\x6b\xf5\x3a\xb5\x4a\xf5\x9d\xe9\xbe\x51\xa2\x67\xb3\x51\xef\x18\x85\x3d\x1e\x92\xe6\x19\x50\xa9\x4d\x2c\x10\x5f\xa0\xcc\xa5\x55\x49\x3e\x64\x7c\xe8\xe5\x7f\x19\x51\x75\xcc\xa9\x33\x0a\x4c\x6e\x09\x65\xaf\x64\x50\x74\xa7\xf8\x60\x9a\xde\xdb\x7b\xb5\x26\xa9\xc6\x97\xe6\xa2\xb6\xbe\x9a\x37\xa6\xf9\x36\x24\x55\x2e\xa6\xff\x56\x74\x76\xcc\x61\xd6\xe9\xec\xd4\x0c\x4b\x58\xb2\xd9\x2d\x84\xd8\xac\x16\x6e\x8a\xad\x9d\x7a\x22\x10\x7e\x29\x09\x09\xa3\x26\xb7\xc9\x75\x17\xe9\x1c\x4e\x49\x2e\x65\x6c\x44\xd5\x1d\xda\x2d\xa6\x92\xcb\x18\xab\x0a\x2f\x5e\x7e\x72\x08\xad\xd7\x0f\x59\x79\xc5\x63\xb4\xb4\x9a\x8f\xa5\xc9\x12\xe5\xaf\x6c\x34\x9a\xa9\x87\x68\x32\x23\x9d\xae\x87\xbf\x89\x74\x5f\xb1\xb3\x2f\x7f\x7b\x76\x1b\x24\xdd\x3a\xce\x5f\xee\xd6\x69\xce\x17\xf9\x90\xea\x89\xe6\x80\xf5\xf8\xa3\x9c\xbf\x6a\x99\x4d\x4c\x7c\x65\x72\x52\x7f\x8a\x4f\x7a\x5a\xfe\x6a\xe5\xa5\xb9\x70\xc3\x0a\x27\x52\xa6\x95\x77\x13\x18\x7f\xd3\xda\x22\xce\x5f\xc1\x6a\xb5\x53\xdf\x54\x34\x8a\x36\xbb\xde\x64\xb2\x99\x4d\x9c\xa9\xe6\x04\x6d\xf8\xf4\x6a\xab\x67\xe8\xec\x69\xf5\xce\xc8\xdf\x54\xdb\x14\x0d\xb0\x62\x72\xdb\x94\xb8\x5a\x93\x62\x25\x47\x7c\x81\x1b\x42\x61\x09\x15\x62\x6a\x88\xb7\xa2\x34\x7f\xd9\x89\x26\xc7\x32\xcd\x7a\x1b\xb5\xbf\x4e\xa7\xcb\x6d\xb4\x5a\xdd\xd4\x42\xb8\x1c\xd4\x42\xb0\x4d\x20\x5c\xa1\xf4\x62\xa7\x4d\x15\xb1\x27\xe3\x66\x26\xcb\x1a\x2d\xbd\x1d\xe9\x94\x33\xdd\xd7\x66\xa4\x4c\x73\xca\x76\xa4\x0c\xb4\x66\x43\x34\x2b\xcd\x5d\xa6\x5e\xb4\x9d\x1d\xf3\x39\xf4\x7a\xab\x89\x76\xaa\x9c\x3a\x93\xce\x25\xb8\xcd\x2e\x64\xa3\x35\x62\xb6\x98\x39\x69\x0e\x6c\xe9\x62\xc6\x9b\x31\x28\x72\x6a\xd5\x44\xd2\xd5\xbc\x47\x03\xb4\x66\x30\x69\xc3\x8f\x51\x71\x64\x75\xa6\xd9\x71\xb5\xd2\x78\xdd\xa9\xf1\x17\x92\xf4\xb0\x7a\xb3\x23\x2f\x6a\x8f\x65\x0a\x16\x8b\xcf\x65\x34\x7a\x75\xd8\x6a\x15\x4d\x3a\x53\x86\xcf\xad\xd7\x67\x88\x6e\x8f\x9b\x89\xa7\x31\x8e\x3d\x9d\xc8\x71\xd2\x9a\xac\x46\x93\x21\x61\x97\xd3\xd5\x44\xbb\x48\x0f\x50\x61\x8f\xa4\x45\x94\x54\xc9\x25\xe9\x8a\x13\xd1\xac\x13\xab\xda\x63\x69\x0a\xa4\x55\x33\xaf\xe2\x93\xcf\xaa\x8a\xc4\xed\x15\x1f\x07\x42\x78\xb1\xf8\x30\xb7\x99\x8e\xa7\x59\xe8\x4f\x7c\x12\x50\x45\x43\x2a\xf0\xa7\x3d\x20\x3e\x7c\xf2\x1c\xf1\x61\xbc\x58\x78\x4f\x85\xa7\x65\xa5\x77\x3d\xf0\x4c\xbb\x2b\x4e\x81\x4f\x6c\x13\xde\xed\x81\xe7\xf8\x9d\x7b\x34\xfc\x4a\x4f\xac\xd0\xf4\x04\xfa\xdd\x1a\x3c\x7e\xeb\xb4\xf0\x3c\x82\x3d\x85\xc7\x6f\x25\x4a\xe8\x47\x85\xc7\x47\xd3\xf0\x83\x80\xc4\x53\xe1\x29\xee\x14\x7c\x09\x9a\x97\xf8\x8f\xf8\xb0\x74\xb7\x36\xbe\x69\xa5\x32\xe4\x45\x59\x7c\x47\x54\x32\x72\x42\x2d\x1a\x88\x1a\xd0\x30\x34\x12\x8d\x46\xe3\xd0\x44\x34\x05\x9d\x8b\x5a\xd1\x6c\x34\x0f\x2d\x42\x4b\xd0\x32\x74\x11\x5a\x8b\x36\xa0\xcb\xd0\xaf\xd0\x66\xb4\x05\x6d\x43\x37\xa1\x5b\xd1\x1d\xe8\x6e\x74\x3f\x42\xce\x88\x3b\x58\xa8\x7d\xc4\xb4\x6b\xf9\xbf\x78\xee\xfd\x3f\xc0\xc3\xcf\x5c\xdb\x4f\xf3\x99\x37\x7f\x3e\xec\xa0\x9f\x3b\xe7\xcd\x4b\x6c\xa5\xbf\x77\xa8\x9f\x23\xf3\xe6\x29\x6d\xf3\xe7\x2b\xed\xf3\xe7\x0b\x66\xfa\x3b\x4b\xfd\x1c\xe9\x81\x3e\x72\xda\xa7\x67\xc0\x71\xa4\xe7\x69\xd7\xcb\x3d\xd7\x9d\xff\xee\x49\xc9\x7e\x7b\xfe\x89\xf9\xed\xec\xdf\xac\xb6\x9e\x7f\xb3\x4f\xbd\x9e\xc5\xfe\xb5\xcf\x64\xff\xda\xf9\xb5\xfa\x58\xfe\x8a\x27\x86\x20\xbf\x53\x8e\xb7\x2b\xc7\xdb\x94\x0f\xe8\xdf\x2c\xe5\xc3\x59\xf2\xd7\x6d\x68\x12\x95\xad\xff\xff\xd5\xfd\xc3\x68\x17\x7a\x12\xed\x41\xcf\xa1\x17\xd0\x2b\xe8\x55\xf4\x1a\x3a\x82\xde\x40\xc7\xd0\x7b\xe8\x38\x3a\x81\xfe\x8a\xbe\x40\xdf\xa0\x7f\xa3\x1f\x68\xa7\xb4\x1b\x08\xc8\x60\x04\x2b\x38\xc1\x0b\x59\xe0\x87\x20\x84\xa0\x14\x2a\x20\x02\xb5\x30\x10\x1a\x60\x18\x8c\x84\xd1\x30\x4e\x95\xa7\xda\xd3\x7c\xc4\xff\x0f\x9e\x17\xf6\x79\x96\x94\xc5\xd0\x69\x3e\xf2\x19\xf0\x78\xff\x87\xf0\xf0\x3f\x7c\xee\xd4\x70\x79\x7f\xe1\xd7\xae\xc1\xce\xe3\x42\x49\xff\xfe\xcc\xff\xe8\x45\xe7\xd5\x54\xa8\xd5\x3f\xf5\xe9\xbc\x79\x5d\xd3\xfe\x0f\x50\xb0\x23\x1d\xe6\xe5\x79\xf3\xc8\xbd\xbd\x81\xe8\xdf\xbc\x53\x90\xcd\xfb\x2f\x60\x3a\xff\xfd\xdf\xd0\xa0\x26\x9d\x77\xa6\x6f\xf6\xab\x69\x59\xfb\x29\xba\xd6\x76\x06\xbd\x3b\xe3\xf3\x59\x3d\xff\x54\x7d\x9c\x99\xa6\x95\xb3\xd2\x74\xb3\x97\x86\xb6\xa7\xeb\x69\x5b\x52\x5b\x67\x69\xc8\xe9\x87\x22\x63\xb7\x14\x9c\x02\x21\xaa\x8d\xac\x0d\x39\x4a\xf5\xf6\x6c\x34\x06\x8d\x47\xe7\xa0\x38\x9a\x81\x66\xa1\xb9\x68\x01\x5a\x8c\x2e\x40\x2b\xd0\x6a\xb4\x0e\x5d\x82\xae\x40\x57\xa1\x6b\xd0\x56\x74\x03\xda\x8e\x6e\x47\xbf\x45\xf7\xa2\x07\xd1\x23\xe8\x71\xb4\x1b\x3d\x83\x7e\x8f\x5e\x42\xfb\xd1\x41\x74\x18\xbd\x8e\x8e\xa2\x77\xd0\x07\xe8\x63\xf4\x19\xfa\x3b\xfa\x0a\xfd\x13\xfd\x07\xfd\x84\x12\x00\x20\x82\x1e\xcc\x60\x07\x37\xf8\x20\x07\x02\x50\x08\xc5\x50\x0e\xfd\x21\x0a\x75\x30\x08\x86\xc0\x08\x38\x1b\xc6\x00\x0b\x3a\x41\x9d\x83\x68\xf0\x34\x9f\x88\xfb\x4c\x9f\xa0\x9b\xf6\x22\x4e\xfd\x40\x1f\x40\x2f\x7d\x16\x4a\xfb\xc8\x7d\xde\x8b\xf4\x59\x6d\xfa\x3d\xfd\x04\xe8\x47\x8e\x06\xdd\x85\xf4\xd7\x49\x7f\x83\x69\x9f\xbe\xe9\x7f\xf1\x7d\x9f\xfc\xa1\xef\x7d\x1f\x3a\x93\xe9\x65\x8d\x2e\x46\x8f\x97\xe2\xf5\xf6\xc1\xef\xec\x7b\xaf\xa5\x4f\xfe\x8a\x47\x4f\x96\x2e\xec\xf9\xb7\x88\xfd\x67\xff\x92\xbf\xc9\x7f\x27\x6f\xe8\x79\xf4\x16\xfd\x5b\xb8\xf0\x28\xfd\xd3\x9e\x25\xfe\xb1\x50\x7b\xd9\xf5\xd0\x22\x68\x58\x74\x74\x11\x3c\xbc\xa8\x07\x4d\x1a\xae\xde\xf7\x29\x44\xd8\xc3\x6f\x8e\xf2\x3f\xfc\x05\x83\x48\x65\xb0\x88\xe1\x56\x26\xd3\x37\x47\x93\xa9\x53\xbf\x0c\x66\x11\x4f\x94\xd8\x06\xf9\xb3\xd8\x5f\xb0\x0d\x02\xed\xfc\xaf\x97\xf6\xbc\x94\x6a\x94\xe8\xdf\x4c\xfa\x2d\x2d\x4c\xbe\x7a\xb1\xaf\x42\xbe\x98\xbc\x78\x25\x5d\x4f\x4e\xd1\xb7\x9e\x47\x29\x28\xe9\x70\x52\xc7\x92\x9a\x4e\x73\xd5\xb2\x98\x95\x42\xad\xa2\x7d\x29\x85\x4c\x45\xd4\x83\x80\x27\x56\xd7\x0b\xae\x45\x2b\x84\x69\xc2\x24\x7e\xa6\x19\xc1\x82\x48\xf8\x99\x66\xda\x21\x6b\xd4\xc3\x5a\x4b\x8e\x77\x05\x84\x49\x5d\x01\x84\x11\x8b\xae\x7d\x44\x38\xc8\xdb\xd8\xdc\x98\x49\x40\x32\x20\xd0\xe9\xa9\x67\xc6\xa6\x17\x3f\x38\x9c\xbe\x86\x91\x26\x75\xda\x03\x76\x49\x38\xd8\x59\xdb\x2c\xf4\x67\x3f\xc2\xba\xce\x23\x42\x7f\x36\x77\x0e\x1b\xf0\x02\xb2\x96\xe7\x89\x89\x20\x02\x4e\xce\x4e\x6a\x5e\xe0\x02\x45\x80\x2e\xd8\x40\xbb\x5c\x7c\xee\xb6\x07\x9e\xe7\x2b\x12\x09\x13\xac\xd7\xc9\x20\xe1\xbe\xf9\x82\x16\x25\x5d\x45\xd1\xac\xdc\xc6\xb0\x28\x2d\x30\x47\xb9\x4d\x2d\x2f\xfd\xa7\x43\x78\xbe\x7a\x86\x1b\x12\x05\x02\x3d\xe5\xa5\xe9\x02\x3a\xf4\x23\x7d\x9d\xb8\x99\x8d\x49\xee\x40\x48\x6a\x16\x1e\x65\x11\xc1\x77\x23\x4a\x28\xa4\xf1\x26\xa0\xa7\xef\xf1\x54\x3c\x59\x78\xb4\x73\x02\x85\xdd\xda\xfd\x99\x34\x4d\xd8\xa9\xc2\x02\xd1\xce\x86\x53\x61\xf5\x18\xb6\x72\x06\xec\x4c\xec\x48\xdc\xaa\x8e\x77\xee\xa0\xf0\xcd\xc2\x36\x0e\x8f\x51\x6f\xdc\x7a\x2c\x35\x27\x1e\x4a\x3c\x20\x6c\xeb\x9c\x20\x3c\xaa\xc2\xa7\xe3\xef\x0b\x4f\x0d\x9b\x34\x8d\xa1\xef\xac\xc3\x73\x29\x84\x8e\x76\x38\xbf\x16\xef\xa4\x7d\x16\x3d\x4c\x8c\xfd\x4b\xcf\x17\xbb\x1a\x0d\x58\xd4\xcb\x02\x48\x04\x74\xe0\x5e\x6e\x84\x39\x46\x88\x19\xa1\xda\x08\x05\x46\xf8\xce\x08\x9f\x1a\x61\x9f\x11\x1e\x33\xc2\x9d\x46\xb8\xde\x08\x97\x1b\xa1\xcd\x08\x93\x8c\x30\xdc\x08\x79\x46\x70\x19\x41\x30\xc2\x82\x37\x39\x90\xfa\xfa\x5c\xfe\x8e\x26\x46\xc9\xf4\x6f\xf2\xf4\xf7\x70\x80\xa5\x3c\x83\x49\x1c\xc0\x95\x7c\x7b\x4f\x32\x2d\xcd\xbe\x85\x27\xa7\xd9\xdb\x8c\xb4\xfe\x8d\x50\xf7\xad\x11\x5e\xe4\x08\x36\xf2\xd4\xe3\x8c\x50\xc9\x57\xf6\xd3\xe7\x1f\x19\xe1\xcf\x9c\xb0\x6b\x39\x55\x34\x69\x05\x4f\xf7\x0d\x7f\xbe\x8b\x6f\x09\x58\x62\x84\xd6\x64\x92\x53\x96\x0a\x9d\x76\xc5\xe1\x69\x16\x11\x9d\x66\x4f\xb0\x1a\xf1\xc0\x5b\x97\x26\x64\x81\xa0\x1e\x22\x7a\x01\x07\x27\x28\xb5\x70\x70\x02\xbc\xa6\x58\x94\x1d\xd0\x0e\x6d\xf8\x08\x7e\x3d\xd1\x1f\x47\x13\xaf\x25\x5e\xc6\x83\xb9\xec\xde\x8f\xee\x12\xc2\x42\x31\xdf\x77\x49\x65\xd7\x86\x32\x74\x48\x97\x17\x70\x99\xb2\x05\x2a\xbb\xef\xf7\xd2\x99\xe4\x92\x34\x1e\x86\x38\x0c\xb5\x2e\xb6\x96\x85\x6d\xc3\x52\x23\x5e\xdf\xbf\xea\xf5\xd5\x6b\xfe\xb2\x7a\xf5\xeb\x6b\xd7\xfc\x79\xd5\xe4\xf6\xfb\x67\xb7\x3f\x38\xa7\xfd\xe1\xf6\x59\x0f\xb6\xe3\x39\xec\xf9\x1b\xf4\xd5\xaa\x55\x7f\x5e\xd3\xfe\xe0\xac\xb6\x87\xda\xe9\x9b\x76\x1e\xcf\xcc\x86\xda\xd1\x64\xa1\x55\x98\x40\xb5\xc7\xca\xf7\x5b\x85\xa8\x3f\x5c\x4b\x7d\xe1\x91\xd4\x0f\x9e\x42\x7d\xe0\x79\xd4\xff\xbd\x88\xfa\xbe\x8f\xc7\x66\x4d\x3a\xef\xac\x8b\x5b\xe6\x0f\x58\x55\xb6\xbc\xdf\xd2\x82\x39\x79\x6d\xa6\x66\x5d\x93\x30\xdc\x55\x8d\x62\xb6\xca\x8c\xca\xec\x58\xf5\xf0\xa6\xe6\xb6\x39\x4b\x97\xaf\x9a\x7f\xf1\xd4\xf3\xa6\x3b\x36\x5e\x32\xea\xc2\x0b\xc7\xae\x1c\xba\x66\x4d\xe3\xfa\xaa\x85\x0b\x6b\xce\xcf\x9c\x36\x2d\x77\xa6\x63\xc2\x04\xcf\x64\x5c\x5f\x2f\x0d\x36\x94\x94\x58\xc2\xe1\xc1\x93\x67\x9e\xbf\x7e\xa5\x5c\xd4\xd1\x9e\x5f\xc4\x96\x61\xa5\x6d\xcc\xfb\xd9\xaf\xd3\xee\x6f\x8a\xf4\x5a\x99\xef\x0a\xe6\x47\xab\x23\x55\x21\xed\xd7\xa9\xfd\x7a\xb5\xdf\xe4\x7b\xb9\xcf\x7d\xdf\xdf\xbe\xef\xfb\xde\x17\xf6\xc1\x9f\xcc\x8f\xbc\x5d\x3d\x60\x40\xf5\xf5\xec\xeb\x87\xda\x68\x6d\xb4\x80\x5d\x29\xb5\x35\xf4\xdf\x23\xb5\xd1\x68\x2d\x9e\xc0\xbe\x13\x99\xec\x01\xbe\x2c\x05\x9b\x78\xb4\x7a\x40\x4d\x0d\x07\x86\x3f\xb0\x77\xca\x74\xf6\xfd\x03\x03\xbe\x9e\x5d\x91\x1b\xe9\x57\x19\xbd\x53\xde\xa8\xad\x8d\x9e\xa0\x37\xb0\x8d\x5e\x4c\x63\xc8\x2e\xa2\x5f\xf0\x4c\x4d\xa4\x2e\x31\x9c\x5e\x6d\xaf\xae\x1e\x80\xb3\x35\x20\x85\xd0\x8b\x4f\x59\xb2\xa3\x03\xaa\x07\x94\xd0\x0b\x6e\xf3\x9e\x40\x57\x09\x41\x72\x12\x99\xd9\xdc\xbc\x41\xb0\x58\x65\x2b\xb3\x84\x15\x33\x52\x46\x97\x4b\x1d\x0a\xe6\x23\xb6\x29\x19\x2f\x3c\xff\x9d\x0b\x15\x65\xcf\xd3\x8a\xb2\xe4\x18\x39\xb9\xfc\xdd\x85\x7b\x14\x05\xc8\xd3\xe7\x1d\xbd\x48\xb5\xc7\xc5\xb4\x1d\xd8\x29\x5c\xc6\xf7\xbb\xb1\x76\x00\x4c\x18\x83\xcb\x6d\x03\x1d\xea\x6b\x8f\x23\xd4\xa6\x42\x1f\x39\x2e\x16\x2e\xeb\x12\x56\xbe\x76\xd1\xca\xc3\x2b\x57\x1e\xa2\xdf\x2b\x84\xcb\x3a\xd7\xe1\x21\x2b\x0f\xad\xa4\xd7\xf4\xe1\x45\x87\x28\xe6\xf4\x3c\x82\xec\x9c\x28\xc1\xe5\x02\x53\x76\x36\xcd\xa9\xa0\xd0\x96\x41\x75\x88\x95\xe0\x83\x0f\xfe\x64\xfb\xe0\x4f\x7d\xa6\x00\x79\x9e\x7d\x74\x29\x74\x1a\x1a\xc6\xb7\x3f\x34\x6b\x16\x55\x14\xfe\x3d\xe6\x54\x82\x52\xef\xe8\x77\x3a\x71\x9c\x07\xcb\xe0\x0a\x3c\x9b\xac\xa0\x3c\xf5\x31\x1e\x58\x10\xdb\x94\x96\x95\xe9\x25\x76\x43\x5f\xbd\xe6\x6b\x92\x93\xdb\xed\x3c\x72\x5a\xdc\x27\x3c\xfb\xa6\x59\xc3\x97\x0e\xdf\x36\x77\xde\xc8\x51\xcd\x1d\x8d\x8d\x1d\xed\xa3\xc6\xb4\xe2\x75\x8b\xae\x19\x72\xe1\x88\x79\x5b\x47\x8d\x9c\xd7\xd8\xd1\xd1\x38\x72\xee\x02\x24\xc2\xe3\xd4\xfe\xaf\xa6\xf6\xdf\x88\x32\x50\x01\xaa\x44\xf5\x68\x49\x2c\xe6\x94\xea\x7d\xfe\x9a\xd2\x42\x13\x42\x85\x7e\x49\x18\x78\x56\xbf\xec\xfc\x70\x7e\xb4\xff\xfc\xfe\x10\xef\x0f\x23\xfb\x83\xaf\x3f\xf4\x8f\x0c\xb0\xe6\xb7\xe6\x2f\xc9\x27\xba\x01\x31\xbd\xa5\x29\x7f\x40\xfe\x00\x62\x65\x93\x11\x1e\xd6\x6a\xbf\xcf\x96\x77\xd5\x55\x54\x94\xce\x9c\x61\x3b\x1c\x61\x56\x8f\x11\x6d\x3b\x5c\xd5\x73\x00\x5d\x72\x14\xcd\x85\xe4\x7c\x14\xaa\x66\x1b\x45\xe5\x6a\x14\x62\xcb\x7e\x5c\xc8\x5b\x85\xce\x74\x16\x2f\x8b\x94\x5d\xeb\x65\xab\x84\xa4\xd5\xca\xcd\x5d\x09\xe5\x16\xa0\x46\x12\xd3\xff\xed\xd3\x94\x3f\xbd\xfd\xee\x4d\xdb\xa1\xea\xed\x77\xa0\x32\x71\x6e\x38\x2f\xaf\xbc\x3c\x2f\x2f\x0c\x6f\x94\xe5\xe5\x55\x54\xe4\xe5\x95\x25\xfe\xd1\xbc\x6d\x6b\xf3\xe0\xf6\x67\x9e\x69\xc7\x4d\x0a\x6d\xc6\xa1\x23\x71\x12\x16\x2a\x37\xfc\xf4\x0e\x54\xc1\x2d\xdb\xdf\x79\x5b\xf9\x13\x40\x35\x4c\xce\x0b\x27\x13\xf3\x5f\xe5\x85\xab\xae\x0a\x3e\xfb\x2c\x1f\xbb\x83\xd7\x29\xcf\xb6\x73\x9e\xb1\x58\x01\xe5\x68\x4e\xac\xae\xc0\xe4\xe8\x97\x9b\xe1\xc8\x90\xa8\x33\x13\xae\x08\xb8\xad\x59\xd6\xe2\xf2\xf9\xe5\x10\x2f\x87\xd1\xe5\x30\xa8\x1c\xca\x4b\x8b\xac\x56\xbf\xb5\xd5\xba\xc4\x2a\xe8\xc6\x15\xb5\x16\x61\x6b\x91\xb5\x88\x1d\x1d\x77\x88\x47\xbd\xa1\x6c\xfa\x53\x0f\x9b\xfe\x54\x95\xdc\x1c\xd0\xb3\x36\x2e\x8d\x4d\x62\x5a\x5d\x17\xa6\xc7\xfb\x62\x9c\x09\x71\xce\x6c\xef\xc3\x99\x04\x3a\x0d\x33\x1e\x65\x7c\x18\xdc\xbc\x75\x5b\x73\x6f\x66\xac\x49\x2b\x39\xfb\x55\xde\x7f\xf6\xd9\xe0\x55\x57\xb1\xf9\xae\xc6\xee\x65\x92\x45\x18\x88\x4a\xa8\xa5\x3f\x2b\x56\x10\x0e\x46\x0d\x41\xc3\x80\xba\xfe\x1b\x7d\x7f\xf6\x7d\xe4\x23\x1b\x7c\x50\xe9\x83\x0a\x1f\xf8\x4a\xad\x25\x0d\x25\xe3\x4a\x88\xae\x84\x2f\xf7\x7b\x9f\x95\xad\x97\xf4\xb2\x3d\xa3\xec\x28\x5a\x0f\xeb\x71\x4b\xec\x44\x5a\x0b\x96\xdd\x2c\xd0\x8a\x1c\xaa\x2d\x0a\x05\xa3\x91\x1a\x76\x58\x6d\x4d\xad\x57\x2b\x1e\x0f\xf7\x4f\xae\x1a\x3a\x74\xf6\x59\xcf\x96\xef\x9d\x2c\x1d\x3b\x66\x1f\xbd\xb7\xff\xd3\x05\xa3\x06\x47\x87\xae\x9e\xf3\xbb\xd2\xa7\xc7\xda\x8e\x1d\x33\xb5\x3c\xd5\xef\xf7\xe7\x5f\xe0\xdf\xfc\xd2\x2b\x57\x6d\x6e\x9b\xbd\x4f\x18\xf8\x8e\x14\x2a\x7f\xba\x7c\xef\x05\xcb\x07\xaf\x6b\xa3\x40\x99\x25\x36\xdd\x3b\xef\xd8\xcf\x7e\xaa\x7c\xef\x9c\x75\x83\x37\xb6\x52\x0c\x63\xcc\x83\x0e\x6c\xda\xb4\x6f\xd6\xac\x5f\x6f\x3a\xc0\xca\xf8\x2e\x6a\x11\x8a\x84\x4b\xa8\x46\x84\xd0\xa8\x58\x28\xc7\xe3\xb0\x58\xdc\xb4\xe2\x0b\x0a\xec\x46\xc1\xd8\xaf\xd8\xe1\xb6\xa2\x0c\x5b\x46\x4b\x06\xc9\xc8\xb3\x20\xb4\x11\x61\x1d\xf2\xc9\x4c\xe8\x67\xce\xa8\x3a\xcc\xce\x95\xae\x4a\x4d\xb5\x69\x4b\x41\xf8\xee\x68\xed\x3c\x4a\x2f\x5b\xe3\x26\x6b\xc3\xd7\x6c\x8e\x28\x75\xea\x04\x3b\xb3\x12\xf0\xfb\xcd\x8b\x86\x3f\x7a\xe1\xca\x89\x93\xaf\x5d\x08\xa8\x1b\x8d\xa2\x46\x12\x07\x07\x4c\xaf\x5b\x3b\x61\xca\xc0\x41\x75\x33\xf0\x50\x63\xf3\x9a\xd1\xeb\xef\x9d\x3c\x71\xcd\xe2\xbb\xcc\xf7\x35\x2a\x27\x41\x6a\xc4\x5b\xa3\xad\x75\x93\x57\x0f\x1e\x34\xa9\xbe\xb5\x9a\x95\x61\x3c\x3a\x29\xec\xa2\x65\x28\x43\x03\xd0\xf0\x58\xb0\xd2\x5f\x16\x08\x79\xed\xf6\x1a\x21\x10\x0a\xd4\xd5\x97\xf9\x4b\x22\xa8\x60\x63\x01\x2e\x28\xa7\xae\x8f\xd1\x5a\x02\x6a\x35\x1d\x9a\xa1\x29\x6e\x2a\x36\x87\x3a\x94\xac\x6e\xfc\x63\x41\x81\x6a\x78\x98\x33\xb6\xbb\xca\xcd\xf4\xd4\x0f\x2e\x2b\x8f\x4c\x27\xab\x0b\xf7\xb4\x65\x69\x72\x7a\x48\x8a\xee\x6d\xa5\x3a\x49\xd2\x05\x86\x0f\x9c\x5a\x5c\x60\xb6\x49\x36\x93\x20\x58\x9c\x85\x05\xe6\xaf\x26\xed\x5a\xbe\xfc\x91\x07\xd7\x8c\x9c\x78\x4b\xfc\xe2\xf5\x53\xe2\x6b\x2e\x16\x50\x69\xa9\x68\xa6\xae\xbf\x60\x37\x9b\x2c\x59\x67\xb5\x8f\x8d\xe4\xe9\x25\x69\xc8\xb4\xaa\xaf\xc7\x2f\x5e\xf7\xe8\xdd\x6b\x56\x3d\x54\x9a\xb7\x26\xde\xba\x72\xdd\xd4\x29\x17\xf3\x36\x68\x20\xad\x17\x51\x38\x82\x02\xa8\x3a\x96\x8d\x8c\x46\xaf\xdd\xe6\x25\x52\xb6\x94\x9d\x1f\xd4\xfb\x62\x3a\x63\x93\xcf\x3e\x8e\xba\x22\xfc\x94\x67\x6a\x8d\x92\xc7\x69\xa9\x91\xd0\x69\xa9\xa8\x0c\xd2\x3f\xbe\xe6\x30\x17\xfb\x21\x50\x4b\x8d\xf9\x20\x6d\x47\x59\x4d\x2d\x6d\xb4\xf2\x7c\x6d\x37\x5d\xd3\x88\x2f\x9d\x72\xfb\x6c\x32\xee\xee\xcb\x75\x5d\x7f\x93\x2e\xde\x39\x65\xda\x43\xf1\x4b\xe3\xb3\x37\x5f\x2e\x1c\x69\x7b\x70\xf3\xfa\xcb\x47\xb6\x6d\x7c\xe1\x8e\xfb\x66\xea\x0b\x0b\x67\xed\xdc\x6a\x79\x61\xe3\xf4\xf8\xa6\x09\x17\x3d\xcb\xe8\x3b\x0b\xd1\xce\x80\xf0\x2a\xaa\x46\x0d\xb1\x40\x05\x8b\xa5\x99\x91\x2b\xf6\xb3\xf6\xb3\x46\xfb\xd5\x14\x94\xea\x2a\x5c\x79\x82\xd1\x6f\x04\x87\xd1\x61\x84\xac\xd4\x59\xc7\x33\xd8\xae\x93\xe4\x74\xa6\x16\x36\xb2\x18\x6a\x07\x93\x68\x48\x6d\x77\x18\x71\x55\x5e\x5e\x25\x5a\x48\xa6\x9a\xda\xa4\x68\xf1\x76\x29\x97\x78\x85\xc6\xae\xa7\x75\xbf\xba\xa8\x35\x8a\xeb\x9e\x88\x8f\xb9\xa4\xf1\xba\x19\x83\xe7\x14\xd9\x8d\x77\x5d\xb0\xfc\xce\x11\x93\x6c\x9e\xd0\x82\xe1\x67\xdf\xb6\x7c\xc0\xca\xd6\x41\x62\xff\xc5\x1b\x2e\x0c\x66\xd5\xac\xba\xa1\xb9\x62\xd5\xca\xe6\xf5\x63\x96\xed\x80\xc8\x90\x7e\x85\x45\xab\x6f\xbc\x73\xd1\xe4\xf6\x7e\x44\x37\xb6\x79\xf9\xf2\x7b\xfb\x4f\x58\xb0\x7e\xfb\xaa\xa8\x9b\xf3\xbd\xa3\xfb\xef\xb4\x7f\xb7\x9a\xea\x08\x5b\xd3\x69\x76\xca\xb2\xd3\x97\x69\x48\x75\x1e\xd4\x00\xf3\x62\x18\x2a\x40\x6b\xa1\xb4\x1d\x33\x4c\xf4\x2d\x80\xdb\x3d\xe7\x3e\x36\x6d\x74\xcd\xe6\xb9\x53\xb6\x14\xe5\xff\x66\xea\xac\x2d\x53\x97\x5c\x7d\x89\x77\xf2\xd3\x5f\xae\x9d\x73\xc9\xd0\x45\x57\x5d\xb8\xea\xa2\x15\x9b\xda\x27\x3f\x7f\xd5\x93\x47\x69\x5e\x43\xbb\xff\x4a\xfe\x42\x79\x68\x42\xfe\x18\x3b\x8a\xc9\x40\x0c\xc4\x6c\x19\x6d\x00\x03\xf2\x55\xcc\x48\xe6\xa7\xee\xf1\x44\x5e\x09\xc9\x45\xb8\x28\x54\x83\xb0\xdc\x04\xfa\x35\xc3\x95\x3f\x4d\x2c\x7c\xe6\xfa\x73\x96\xd3\xce\xd3\xab\xeb\x94\x9b\xae\x6a\x54\x16\x5c\x3f\x12\xc4\x17\x3a\xae\x82\xb8\xda\x77\xdb\x87\x72\xc8\x40\xaa\x2b\x3e\x14\x8e\xb9\xb1\xc5\xe2\x33\x88\xa2\xcb\xe7\xcb\xcc\x32\xeb\x74\x6c\xdb\xb2\xd7\x4e\x75\xfb\xd0\x8c\xba\x8a\xba\xd4\xd1\xc1\x29\x1b\xc6\x38\x2e\x07\xf9\xce\xf7\xf4\x75\x99\xf0\xf7\xe6\xed\x8b\x67\x56\xd4\x5d\x18\xdb\xb6\xa8\xae\x7e\xdd\xd8\xb2\xb0\x70\xc9\x9c\x97\xb6\x3d\x74\xe3\xea\x8d\xab\x56\xed\x30\x2a\xd2\xda\x9b\x6a\xc2\x63\x96\x3b\x91\xba\x7f\xf3\xa8\xf0\x8d\xf0\x2b\x94\x8d\xf2\x50\x5b\xac\x3a\xc7\x6a\x75\x67\xe6\xca\x26\x76\xf4\x63\x20\xdf\x92\x33\x39\x07\x86\xe5\x40\x8e\x39\xb7\x26\x17\x0a\x73\x99\xd7\x43\x72\x41\x97\x9b\x9d\x97\x35\x35\x0b\xb2\xfc\xd9\x19\x0e\x83\xc0\x97\xf6\x56\x44\x22\xbc\xf9\x98\xa9\xb6\x23\x11\xde\x98\xa4\x1d\xc5\xa3\x35\xb7\x3d\xbb\x98\xbc\x76\x31\x45\xb4\x97\xde\x15\x42\x61\x54\x14\xbe\xa9\x59\x7b\x76\x5d\xdd\x9a\xb1\x95\x25\x89\x77\xaf\x5a\x56\x57\x7f\xf1\xb8\xf2\x72\xfc\x6c\xe2\x5a\x5c\x94\x78\x17\x86\x8f\xbd\x60\x52\x4d\xc5\xf8\x25\x0e\x78\xf1\x06\x65\xe5\x8a\x5b\xa3\xe5\xcd\xab\x88\x13\x7f\xfb\x84\x32\xef\x86\x15\x37\x73\x1f\xa6\xfb\x83\xee\x01\xc2\x44\xf1\x10\x1f\x27\xbf\x20\x36\xc4\xe7\x74\x65\x64\x63\xb0\xda\x72\x0d\x92\x68\xb4\xc8\x6e\x77\x40\xce\xc3\xfe\xac\x8c\x4c\x5f\xb6\xdd\xeb\xf2\xb8\xdd\x2e\xbb\x2f\xc3\x2f\x81\x43\xd6\x49\x7a\x92\x6b\x34\x19\xcc\x39\x36\x9b\xd9\x94\xab\xd7\x49\xa2\x85\x2f\x14\xae\xe8\x13\x3f\xa9\xef\x7d\x2a\xd4\x19\xeb\x45\x39\x45\x12\x74\xca\x3c\xc2\x28\xb0\x23\x60\xe9\x87\xc5\x14\xa5\x1f\xfa\xa6\x10\xef\x6c\x1b\xa0\xdc\x34\xb8\x6d\xc0\xdb\xd9\x6f\x4f\xa5\x9f\xfa\xb6\x08\xcc\x1f\xd4\x56\xc3\x6e\x8f\x65\x1f\x33\x2b\x37\xc7\x61\x01\x0c\xba\x53\xb9\x15\x06\xc7\xef\x88\xc3\x7f\xd8\xd7\x48\xe5\xa3\x3b\x61\xba\xf2\x1a\xbd\x56\x8c\xf4\x0b\x2f\xbe\x53\x31\xde\xa9\xc6\x92\x15\x1c\xfc\x4c\x88\x05\xb1\x1a\xaf\x33\x2b\xcb\xa4\x13\x72\x91\x80\x70\x00\xe7\x39\xcc\x56\x73\x6b\x3c\x53\x92\xa5\xd6\x38\x6d\xe7\x0c\x46\x43\x6b\xdc\x69\x94\xe9\x7f\x6c\x25\x59\x02\x16\x5a\xe3\x7e\x3f\x76\xa8\x1b\x25\x79\x0c\xd5\xf4\x63\x58\xd2\x0f\x8f\x4e\x2e\x2e\xd0\x5c\x01\x92\x16\x2d\x51\x8b\x07\x18\xe0\x71\x74\x03\x84\xda\x66\xa7\xe0\x98\xdc\x55\x66\xd8\x75\xf6\x1e\xeb\x9e\x82\x3d\x96\x3d\x23\x1f\x30\xe0\xb3\x0c\x6f\x8c\x84\xab\x2d\xca\xf2\x02\xb8\xda\xaa\x2c\x6f\x7a\xeb\xf9\x45\x4b\xe0\x12\x65\x83\x1a\x1a\x7e\x42\x7a\xd0\xf8\x79\x2e\xf0\xaa\x7a\x51\x4f\x2b\x73\x88\x78\x0d\x8f\x9b\x90\xeb\x25\xb2\xec\xb0\x18\x4c\x36\x83\x20\x50\xad\xf7\x61\x9b\xdd\x36\x2e\x2e\x99\xcc\xa6\x71\x71\x62\x66\x9b\x44\x3c\x7a\x76\x52\x19\x6d\x64\x0c\x6e\xb7\x73\x5c\xdc\x8d\x0c\xf2\xb8\xb8\xc1\xdd\xeb\xe4\x2b\x16\x7d\xad\x77\xc9\xbc\x3d\xd3\xbb\xa0\x85\xc8\xf7\xca\x81\xf4\xd2\x11\x3c\xc4\xbc\x83\xfd\x9f\x71\xbb\x4e\x79\x66\xc1\x6d\x66\xfe\x7f\xc6\x25\x3a\x28\x5d\x40\xea\x47\x8d\x1a\x95\xf8\x87\xaf\x1c\x4f\xa7\x17\xd8\x92\x51\x9e\x78\x04\xa1\xb4\x7a\x29\x42\x13\x63\x65\x9e\xfc\x7c\xab\x50\x88\x50\xb6\x60\x14\x70\x3f\x1c\x72\xdb\x1c\xb6\xd6\xb8\xd1\x9f\x65\xf1\x5b\xb0\x83\x14\x15\x61\x9c\xdf\x16\x67\xf5\xc1\x6a\x23\x19\x04\x2c\xed\x1c\x85\x53\x8e\x33\xe3\x35\x50\x94\xdc\x1e\xe2\xd5\x2a\xc1\xa3\x6e\x11\x01\x16\xbb\x35\xad\x22\x3a\x02\xbe\xd2\x9a\x8c\xea\xbc\x95\x53\x1d\x13\xd4\xba\x98\x13\x2e\x2c\x19\xe0\xad\xce\x5b\x3e\x2d\xc3\x3d\xbe\xa7\x2e\xf0\x50\x67\x45\xd3\x86\x65\x00\x47\x78\xdc\xde\x43\x85\x95\x8d\x17\xaf\x90\x94\x1a\x5e\x23\x98\xc5\xfb\x14\x76\xd1\x32\xb9\xa8\x9d\x98\x19\xab\xce\xcb\xb6\x58\xb0\xd3\xab\xd7\xe7\x38\x91\x60\xcf\xb7\x07\x2c\x4e\xbb\x93\xc5\x5a\x6c\x8b\xfb\x79\xd4\xc5\x6c\xc8\xa3\xff\x45\xbb\x43\xcc\x62\xbb\x84\x5b\xe9\x87\x95\x0e\xf5\x12\xb4\xbe\x27\xb0\xa8\x55\xe1\x54\x59\xaf\xc6\xb8\x0f\x6a\xc1\xa6\x92\x41\xf4\x59\x1d\x2d\x32\xef\x8f\xb2\x90\x9b\x6a\xc4\xfa\x64\x34\xce\x2d\xd4\x75\xbe\xfc\xda\x6d\xd7\x47\xfe\x66\xfe\x5b\x25\xb9\x78\x14\xf4\x53\xc3\xd0\xab\x51\x37\x49\x99\xf2\x25\xcc\xbd\xf6\x4a\xe5\xc4\x28\xe5\x4b\xda\x24\xff\x5a\x19\x2d\xbc\xc4\xcf\x20\xe8\x87\x96\xc6\xce\x72\xba\xdd\x06\xab\xd5\x24\x49\xd9\x7e\x63\xc8\xd0\x8f\x14\x16\xf6\x0b\xf9\x85\xe2\x92\x90\x6c\x92\x4d\x6d\x71\x59\x36\x04\x02\xfe\xd6\x78\x40\x6a\x8b\x07\x88\xcb\x95\x91\x61\x6f\x8b\x67\x64\x19\xfa\xb5\xc6\x0d\x8e\xb4\x5d\xe2\x15\xda\x91\x01\x5a\xa4\x8e\x5e\xbd\xfd\x48\xd2\x25\x63\x7d\x53\x6a\xb4\x69\xd1\x80\x87\x92\xe7\xd1\xc6\x58\xac\x3f\xad\x4b\x55\xab\x95\xde\x26\x3a\xf1\xfc\xa7\xf7\x2b\x9f\x5c\x3f\x17\xff\xc7\xa0\x1c\xfa\xfe\xf5\xcb\xa5\x0b\xa6\xf5\xaf\x1d\x5a\x3a\xe9\x92\x89\x97\x9c\x6d\x7a\x9f\xf2\xc0\xf5\xde\xe7\xca\x5d\x27\xf0\x7d\x8f\xdc\xf1\xcf\xc4\x2b\x89\x2d\x51\xdc\x9c\x70\x06\x73\xd6\xf7\xdf\xfc\x5d\x6e\xf3\x35\x0b\xeb\x9a\x84\xe3\x99\xd1\xfb\xee\x50\xf6\x4d\x4a\xfc\x4d\x3d\xab\x88\x28\x57\x90\x7d\x62\x98\xda\xc7\x02\x54\x4a\xfb\x5b\x0d\x79\x62\x16\x0e\xe5\x07\x8b\x8c\x16\x6f\x61\xa1\xc3\xc4\x4e\x02\x29\xca\xc7\xa2\x5c\x8e\x00\xca\xbc\xc5\xbe\xe2\x09\x71\xa3\x25\x58\x94\x1f\xc2\x59\x3a\xda\x31\x4c\x46\x39\xb7\x5b\xf5\xd9\x2d\x71\xbd\x2d\x79\xfe\x07\xff\xb6\xb3\x13\x89\xd0\x29\x21\x97\x7b\xba\xb1\xce\xa0\x93\x95\x90\x87\x31\xa7\x96\xd1\xe3\xad\x8d\x24\xa3\x9b\x87\x80\xef\x96\xf7\x42\x91\x97\x9f\x47\x54\x7b\x76\xe3\x1f\x87\x8e\xdd\x0e\xe8\x46\x7f\xd5\x0b\x4d\x07\x4a\xfa\x95\xd7\xec\xd0\xa2\x9a\x07\xf2\x60\xe2\x9c\xfb\xdb\xc2\xb0\xd2\xbb\x36\xa4\xac\xcb\x2b\xba\xe0\x4a\xe5\x0a\xb8\x3c\xb8\x7d\xf9\x2e\xe8\xff\xb0\x08\x4b\x94\x2b\x0d\xb6\xfc\xae\x5f\xb3\xc8\xe6\x3a\x72\xe9\x4d\xdd\x68\xf3\x92\x18\x3e\x2c\x54\x7a\x13\x39\xf6\xcd\x6a\x3b\xd1\x44\xf9\xb0\x98\xf2\x21\x97\x7a\x6f\x0b\x63\x03\x72\x8c\xd9\x26\x1f\x42\x1e\x9b\xcb\x26\x92\xec\x4c\xbf\x85\x98\xb3\xb2\xb2\xb3\x83\x94\x1f\xf9\xce\x80\x2f\xd0\x12\xf7\xe7\x58\x8c\x82\x3e\xcb\x1b\xf3\xf8\xac\x66\x16\xa5\x88\x8c\x8f\xeb\x3d\xda\x3a\x1d\xdb\xbe\x86\x48\xe6\xe1\x03\x8e\xb4\xf2\xdb\xb5\x46\xc1\x9e\x1c\x17\xe2\x5e\x49\x21\xf7\xb5\xbd\xaa\x9a\x06\x81\x35\x7e\xda\x89\x10\xce\x08\x48\xb5\xce\x20\xe8\xca\x83\x67\x8f\x73\x47\x56\x8d\x9d\x51\xf6\x9f\x46\xc8\x15\x8c\xf3\xd7\xea\xae\xb8\x2a\x56\xf8\xec\x47\x4d\x89\x87\x6d\x95\xef\x6f\x7f\xb4\xbc\x3c\xb7\xa2\x20\xd2\xa0\x4c\x83\xaf\x5c\xd9\x39\xe3\xf0\xa8\xf2\xd0\xd1\xa3\x70\x69\xa7\x32\x36\x01\xeb\x58\x0c\xc7\x7f\x28\x6d\x52\x50\x1c\xe4\x90\x84\x89\x48\x3d\xf3\x65\x3e\xd9\x49\x6d\x69\x2e\xdb\x3f\xef\x76\x5a\x2c\x6c\x89\x57\x6e\x96\x35\xcb\x9f\xe7\x36\x64\x18\x26\xc4\x33\xa8\x4d\x1a\x17\x77\x20\xab\x5b\xc8\x1d\x47\x6d\x11\xb5\x9b\x07\xf8\xba\xb9\xd4\xe1\x7a\xbd\x56\xef\xb1\x70\x19\x6c\xb7\x56\xf2\xf8\x16\xed\xb8\x16\x22\x27\xbd\x2c\x42\x76\xae\x78\xe5\x77\xcf\x76\x78\x2b\xab\x47\x3f\x3a\x60\xc9\xbd\x5f\xad\xd4\x41\xde\x42\x5b\xcb\x9e\xa9\x73\x3b\x74\x0b\xca\x95\x81\x70\x33\x6e\xdc\x10\x2a\x1f\xb0\xee\xdc\xc4\xaf\xc4\x26\x6a\x38\x77\x36\x2f\x58\xb2\xb8\xc3\x52\x9f\xb8\x95\xd2\xff\x37\xa5\x8d\xc5\x48\xb7\x49\xc2\x68\xd5\xcf\xa6\xf4\x3f\x4c\xe9\x77\xa3\xc9\xb1\x0a\x27\xd6\xeb\x04\x07\x0b\x8f\x67\x20\x02\x16\x11\xf5\xba\xb0\x93\xd9\x7c\x83\xc3\x48\xcc\x6e\xab\xcd\x32\x2e\x6e\x43\xb2\xd9\xad\x17\xc6\xc5\xf5\xee\x74\xf9\x4c\xab\x9e\xf4\xc3\x3a\xd4\xa8\xe8\x4e\x2f\x2b\x12\x49\x96\x05\x42\xb5\xe4\x61\xdd\x78\xe5\xdd\x7f\xb7\xd3\xa2\xac\x7a\xf7\xfa\xc1\xf7\x7d\xfb\x2b\x1d\xf4\xdf\x09\x3b\x67\xea\xc8\xce\x72\xaf\xf2\xd7\xc4\x7f\xbc\xac\x24\x70\x7c\xb3\xb2\x93\x15\xa2\x6b\x00\xdc\x91\x45\xd5\x06\xf9\x94\x36\xe1\x72\x6a\x5b\xac\x68\x48\x2c\x60\x21\x3a\x03\x30\xbf\x91\x45\xca\xb4\x9b\x25\x23\x35\x21\x06\x83\x91\x08\x16\x62\x69\x8d\x03\x8b\xdb\x7d\xa0\xe7\x68\xaa\x3e\xd4\xb1\xb5\x66\x24\x50\x0b\x5a\x9c\x72\x19\x02\xe4\xb7\x43\xf2\xbb\xde\xb3\x93\x59\x7f\xf8\xb1\x75\xf8\x88\x01\x64\x81\xad\xeb\x26\xa2\x67\x07\xc4\xcf\x14\xae\x72\xbd\x01\x83\x26\x77\x2e\x66\x6d\xd0\xdf\x29\xcf\x30\xd9\x89\x6c\x68\x58\x2c\x5f\x4f\xfb\x01\x66\xab\x55\x40\xc4\x81\x65\xd9\x0e\x06\x9b\xa1\x25\x6e\xb5\xda\xac\x3a\x2c\xe3\x96\xb8\x28\xbb\x4f\x43\x44\x24\x9d\x0a\x96\x33\x25\x80\x51\x22\x51\x52\x6a\x09\xd6\x25\xfe\x04\x7f\x59\xff\xca\xef\x12\x6f\xea\x71\xf5\x0d\x03\x16\x66\xd4\x56\x94\x93\x9d\xfd\xbb\x8e\x2a\x19\x70\x73\x39\xa9\x70\xda\x7e\x75\x92\xc7\x52\xfd\x4a\xbc\x48\x6c\x46\x66\xaa\x67\x0d\xb1\x3c\xc1\x6b\x37\x18\xf2\xbc\x79\xf9\x41\x3f\xc9\xa2\xcd\x44\x96\x60\x97\x9d\x32\x75\x4d\x9c\xb6\x80\x16\xde\xb9\xe7\xf4\x15\x6d\x21\x7f\x0f\x15\xea\x21\x5c\xac\x75\x0b\x63\x50\xcd\x46\xd2\x9c\x70\x53\x42\xae\xbc\x5b\xf9\xe7\xad\x2f\xdd\xb7\xe7\xe6\x27\xa6\x34\x8d\x83\x3d\x7a\x65\x99\x61\xd3\xf3\x3b\xba\xae\x3e\x00\x8b\xbe\x1c\x7a\xe9\xac\x5b\x8a\x3f\x10\xba\x5e\x53\x6e\x38\xf2\xc7\x2f\x2e\x25\x9d\xf9\x0e\x7d\x67\x5d\x74\xca\xc2\x2b\xbf\xbb\xf9\xdf\x70\xc5\x51\x67\x66\x6e\xa7\x93\xc7\xf3\xc9\xee\xfe\x52\x78\x9e\xec\xa7\xf2\x57\xc4\xe5\xef\x57\xdd\x1f\xcb\xdf\xd3\x32\xe4\xa0\xd9\x31\x9f\x4e\xef\x71\xb9\x0d\x46\x93\xd3\x63\x70\x12\x47\x8e\xc3\x6c\xce\xc5\x39\x39\xfe\x2c\x81\xc5\x5b\xf4\xc6\x21\x4b\x30\xb8\x5c\x26\xab\xd9\x61\x75\xb4\xc6\xad\x82\xc7\xe9\xd4\xa7\x4e\x1f\x51\x55\x89\xb9\x22\x0d\x5a\x80\x6a\x47\x2a\x3e\x6e\xaa\xf9\x03\x35\x78\x95\x4c\x6b\x9e\xfe\xa9\x67\x8b\x40\xc4\x09\x6c\x2f\xaf\x57\x7e\x6d\xa8\x94\x55\xd3\x30\x3d\x94\xe8\x6e\xb8\x4e\x99\x39\xe4\x15\xf5\xf0\x90\xab\xe1\xa1\xf0\x4d\x30\xa5\x78\xf6\xe2\xf1\xe7\x34\x0b\xf5\x37\xbb\x26\x9f\xd3\x79\x1f\xb9\xb4\x6b\xbd\x68\x66\xad\x79\xd7\x54\xb2\xbd\x6b\x2e\xc1\x33\x2f\xac\xc9\xa2\xe5\xe9\xdf\xfd\xa5\xb4\x8c\xec\xa7\x6d\xc0\xa4\x58\xa9\x4e\xef\x72\x3a\x68\x79\xec\x2e\x83\x9d\xd8\xb0\xcd\x6c\xce\xc6\x59\x59\x39\x3e\xa1\x25\x0e\xe0\xb3\x19\x1c\x0e\x93\xd5\xea\xb2\xdb\xf5\x26\x8f\x56\x0a\x76\xd6\x40\x2a\x56\xf9\x7f\x51\x00\x4a\x7b\x24\x4b\x25\x5f\x6a\xe9\x9f\x91\x93\x5f\x3d\x75\x80\xb2\x71\xe8\xc5\xca\xcb\x8d\x0f\x77\xe8\xfe\x73\x19\x44\x47\xaf\xf9\xae\xff\xf4\xd9\xe3\xc6\x8e\xc4\x9f\xad\x75\x4c\xef\x48\x9c\x85\x17\x25\x6e\x20\x6b\x7c\xe5\x89\x41\x38\x9e\xb8\x1b\x3e\x6e\x3d\xbf\xca\xa3\x8e\x51\x8a\xdd\x5f\x92\x6b\xc8\x73\xd4\xe7\x2d\x41\xe7\xc4\xca\x0a\x1d\x02\xf1\x38\x3c\xbe\x7c\x77\x5e\x9e\x41\x64\x26\xdc\xa4\x23\xa5\x65\x39\xd6\x7c\xb7\x41\x14\xac\xb2\x2c\x58\xad\xfd\xa8\xac\xdb\x3c\x82\x47\xdd\xc2\xa1\x06\x5d\xf7\xd6\x35\xf4\x0c\x06\x46\xd2\xe2\xc9\xb1\x4e\x0a\xa3\x5c\x92\x43\x35\xb5\xa9\x1e\xae\x24\x67\x41\xf2\xc0\x47\xd1\xe5\x4d\x1e\x8a\x49\xae\x99\xa8\xc4\xcf\x5e\x18\x3f\xdf\xb5\x74\xba\x6b\xdd\xcc\x11\x23\xe6\x8e\x1f\xf5\x53\xac\x24\x43\xf7\x7c\x66\x62\xbf\xa9\xff\x20\x4f\x66\x41\x11\x59\x3c\xf5\xf2\xc4\xb9\xf0\x9f\xfe\x55\x8d\xfd\xab\x26\x0d\xbd\xf0\xea\x11\xb5\x23\xd6\x0e\x54\xae\x86\x1b\x17\x4e\x29\x2c\x93\xcb\xbd\x37\xd7\xd6\xf4\x1b\x53\xe6\x2d\x1c\xc4\x7d\x47\xe6\x67\xfd\x85\xc7\x5b\x99\x1a\x2b\xc3\x76\xbb\xc3\xe1\xb4\x09\x82\x5e\x2f\x3b\x9d\x6e\xd9\xe5\xb0\xd9\x48\x5b\x1c\x6c\x36\xd9\x64\x35\x98\xa8\x4b\x6f\x22\x82\x5e\xd6\xb7\xc6\x65\x47\x7a\xa0\x30\x55\xc6\x7a\x1f\x87\x91\xbe\x7c\x35\x14\xe8\x09\xe1\x69\xe5\x47\xae\x09\x57\xc5\x70\x62\xc3\x9c\x77\xf5\xcc\x93\x7a\xfd\x01\x3d\xf6\xe9\x1f\x9b\x81\x2f\x19\x18\x83\x13\x77\x25\x5e\x4b\x06\xe3\xa4\x7e\xe1\x3f\xef\x54\xfd\xf3\xe1\xd4\x99\x18\x49\xed\x0b\x5b\xf7\x59\x80\x8c\x46\x6a\x90\x0d\x18\x53\x23\x67\xa6\xae\x81\xc9\x60\x80\x16\x6a\xe5\x88\xa4\x17\x24\x6a\x86\x25\x2b\x71\xf3\x7d\x67\x1a\x69\x69\xf1\xcb\x7a\x11\x16\x50\x8d\xaf\x55\x3b\x05\x0e\xbf\xa5\xb4\x8f\xb9\xff\x96\x0b\x75\xb0\x45\x77\xd1\x20\xb8\xa3\xba\x7c\x64\x39\xec\x51\xce\x66\xc7\x76\x95\xfb\x94\x7b\x6e\x51\x16\x71\x99\x18\xd4\xfd\xb5\x10\x25\x07\x68\x5f\x81\xd9\x18\x7f\xb6\xcb\x65\x71\xf8\x1d\x7a\x3f\xd1\x93\xfc\xa0\xc5\x6c\xcb\x76\x49\xae\x96\xb8\xe4\x41\x19\x2d\x71\x64\x4b\x37\x31\x91\xf4\x1d\xa9\x75\xc9\x10\xb0\x36\xda\xf5\xe5\xa1\x4c\x69\x43\x8d\xdd\x36\x6f\x4f\xe4\x57\xea\x83\x92\xe2\x4b\x7f\xad\xbc\xa9\x1c\xfb\xc3\x7b\x0b\x5e\x5a\xe7\x18\xb7\x7c\xe8\xab\xe7\x65\x6d\x98\x59\x3b\xdc\x79\xde\xfd\xcf\x0d\x20\x07\x76\xfd\x56\xd9\xa7\x3c\xf5\xda\xf3\x3b\x4e\x6e\x77\x34\xe4\x6c\xf9\xe2\x8a\x6e\x54\x88\xe7\x6c\xdf\x32\x7e\xfe\x92\xc4\x0e\x23\x34\x80\x6b\xe9\x22\x46\xb3\x1b\xdd\x8d\x6f\x20\x53\xf9\xfc\x6f\x56\xcc\x84\x25\xb6\xeb\x4a\x8f\x24\x2c\xa8\xa7\x53\xd7\x69\xbb\xa3\x9d\xb5\xd4\xf6\xd2\xcf\x68\x2f\x8e\x64\x24\x6e\xce\xc0\xb4\x7f\xff\xfa\x65\x20\x5c\x96\xf8\x13\xfb\xe6\xbe\xcc\xdd\xc2\x4e\xa8\x90\xf3\x78\x7c\x66\xcb\x53\x02\x18\x80\x8d\x82\x1f\xb0\xed\xa3\xc9\x29\x1b\x49\x55\xcf\xf8\xd8\xcb\x8b\x61\xf1\x13\xe5\xb1\x58\x79\x59\x2c\x26\xe7\x25\xae\x86\xfb\x07\x57\xd0\xcb\xb2\xf2\x18\x3b\xe3\x40\x94\xe0\x0d\x39\x8b\xe3\x31\x3d\x29\x20\x03\x66\xc1\x9a\xd8\xe8\xa1\x97\x36\x87\xf9\x3d\xda\x00\x57\x8e\x51\x86\x8f\x69\x2b\x8b\x0d\x29\x2b\x6b\x88\xc9\x56\x76\xf7\x0d\x43\xc2\xf0\xaa\xfe\x55\x85\x78\x23\xdc\x2d\x07\x34\x9a\x64\x42\xcc\x0c\x59\xc4\x76\x40\xdd\x69\x9d\x7e\x44\x3a\xdc\xcd\xe8\xe0\x24\x51\x14\x12\x59\x9c\xa2\x90\xea\xc3\x14\xa1\x15\xd6\xd2\xfe\xbc\x88\x0c\x4f\x10\xc4\x8e\x12\x3f\xc4\xce\x0d\x8f\x46\xec\x81\x07\xe1\xfe\x75\x89\xf7\x85\xb7\xbf\x53\xb6\xa9\xf3\xc9\x58\x90\xc9\xeb\xf2\x4a\xa4\x67\x3b\xce\x30\x61\xdb\x84\x0d\x46\x10\x45\xc2\xb6\x7d\xab\x27\x7e\xa7\xe2\xff\xa8\xe3\x9f\x10\x01\xf2\xba\xf2\xc9\x36\xe5\x13\x38\xd7\x0e\xb3\x25\x43\x22\x81\x89\x17\xce\x51\x1e\x3a\x05\x9f\x4e\x44\x22\xa1\xf8\x74\x82\x40\x1b\xcd\xbe\xf8\xf4\x10\x04\x75\x71\x30\xc5\x77\xbb\x5d\xb9\x17\x72\xb7\x41\xae\x38\x43\x79\x08\xce\xf1\x62\x92\x48\xb0\xb1\x96\x5f\x93\x0e\x42\x34\x9e\xe4\xc7\x2c\x02\x55\x10\x1b\xd8\xcd\xc4\xcc\x16\xd8\x25\x87\xdf\x98\x5a\x24\x77\xdb\x92\xa0\x37\x8d\x4f\xb8\xf8\xdd\xfb\x66\xae\x4b\x9e\x07\x2f\x07\x12\xbb\x7f\x48\x1e\xfc\x8e\x61\x23\xe9\xc0\x3f\xa5\x70\x5b\x81\xf9\x1b\x82\x60\xa7\xd2\x25\x53\xfc\xe9\xc8\x1d\xea\xa6\x7b\xea\x7d\xa6\xe3\x2e\x9a\x59\xf2\x2e\xac\x4e\x22\x17\x1f\x4f\xec\x26\x43\x53\xc7\xca\x53\xfc\x61\xb8\x0e\xdf\x2f\x8e\xf9\xdf\xe2\x87\x37\x66\x16\xa7\xe1\x27\x1f\xf4\xc6\x0f\xdd\x7a\x61\x01\xfc\x96\xd6\xb3\x1e\xd9\x76\xd3\x2a\xd3\xcb\x84\x55\x75\x95\x6a\xaf\xd4\x05\x40\xf6\x00\xfc\xf6\x9b\x75\xbb\xd6\xe1\x9b\xc5\x71\x9f\x7f\xfe\x39\xcc\xa6\xe9\x14\x36\x1b\x78\x84\x5e\xb2\x74\x12\xa1\x95\x03\xfc\x68\xfb\xc3\x54\x6a\x23\xec\x54\x74\xbe\x80\xe7\x48\x62\x3e\x4d\xf7\x0d\xcc\xa6\xc9\x68\x5e\x0b\x94\x66\x78\xa6\x7b\x3d\xd2\xb1\xf1\x43\x99\xca\x39\x4d\x2d\xf1\x0c\x0f\x27\xcf\x51\x65\x07\x31\x39\x23\x4e\x39\x18\x12\x6f\x12\xbf\x38\xba\x59\xac\xf8\x93\xf2\x2f\xa5\x39\x00\x76\xe5\x9b\xc0\x9e\x3d\x6a\x5b\x74\x0c\x3d\x8e\x43\xe4\x25\x3e\x17\x93\x17\x33\x23\x93\xc3\x21\x65\xf8\xdc\xc4\x4d\xf4\x56\x6d\x6e\x25\xe9\x38\xf7\x8e\xdd\x94\x7e\xf8\x3f\x0e\x25\x99\x32\x33\xc5\x9d\x26\x8d\x33\x89\x5d\x3d\x2c\xa2\xf9\xcd\x85\x07\xc8\x7a\xf2\x00\xb7\x19\x99\x31\x23\x35\x16\xb4\xc0\x2c\xde\x17\x56\x79\x05\xec\xb0\x57\x7e\xb4\x66\x2d\xfb\x50\x7b\x95\x18\xe2\x20\x32\xfb\xc6\x96\x8e\x0e\xb8\x85\xc7\x0d\x00\xf4\x2e\x5c\x8b\x65\x1e\x6f\xda\xf9\x34\xb0\x6d\xcd\x90\xdc\x4a\x9f\x14\x3b\x18\xba\xff\xc4\x28\x71\x50\x17\xef\x3f\x80\x05\xef\x49\xc1\x13\x01\x40\x24\xc9\xe3\xf7\x1d\x75\x29\xf8\x5d\x14\x3e\xb1\x86\xe3\xf7\x2a\xcd\x64\xbb\x78\x17\xf5\x2f\xce\x8d\xf5\xcf\x72\x21\x24\x62\xe0\x47\xba\xbb\xcd\x46\x30\x66\xe7\xf8\x3c\xe3\xe2\x3e\x37\xce\x72\x65\x51\xdf\xd3\x65\xd5\xdb\x5a\xe2\x31\x16\x3a\xc2\x64\xd2\x03\x8b\x22\x96\x3c\xd3\xbd\x27\xfc\x6b\x2a\x4e\x43\xda\x48\x14\xed\x7f\xd0\x9e\x53\x5a\x90\x72\x76\x98\x00\x1f\xbf\x09\xfc\xfe\xbe\x8f\xef\xd2\x3d\x64\x2a\x7e\xef\xf0\xec\xf1\xc1\xa1\xbe\xa2\xd1\xd3\xe6\x07\xb2\xe0\x8d\xed\x6c\x0c\xe7\x46\x6a\xbc\x9b\x45\x53\xff\xd0\xd0\x4f\xfe\xe4\xdc\x77\xa1\x7b\xcd\xb5\xb7\x75\xdd\xe2\x2b\xa7\xa6\x38\x45\xfb\x51\x4a\x7b\x36\x1a\x1d\x0b\xb1\x13\x56\x5d\x76\x1b\x11\x04\x94\x6d\xcb\xce\xc9\xf5\xc9\x2d\x71\x1f\x58\xb3\xec\x16\xa3\xa5\x25\xee\x32\x5a\x09\x1a\x17\x27\x5a\x1f\x23\x92\xda\xb1\x91\x1e\xe7\x43\xeb\x2e\x31\xb2\xa2\x2a\x8d\xfc\x20\x46\x4e\x3a\x0f\xce\x82\x3f\x67\x54\x7d\x51\x34\x7a\xfa\xa2\xbc\xac\xd7\x2d\xaf\x7f\xac\xd2\xee\x5f\xbc\xfb\xfa\xf2\x47\x1c\x8d\xbe\x72\xf1\x2c\x70\x5f\xfc\x9b\xdb\x26\x9d\xfc\x8e\x53\x7d\xff\xee\x49\x6c\x6f\x39\xa3\xb5\x8a\xca\x71\x61\xf7\x73\xb4\x49\xab\x8d\xb9\x09\x6d\x84\xed\x0e\x22\x5c\x17\xb7\x12\x3f\xa9\x20\xc4\x44\x2c\xe4\x39\xf0\xa2\x38\xb2\x74\xbf\xf8\xa4\xd1\xd2\x64\x41\x2c\x58\x8c\x1a\x52\x16\x54\xa1\x14\x5d\x2c\xcc\x5e\xb4\x5a\x9b\x1d\xf2\x40\xe1\x8a\xf5\xeb\xb3\xf3\xb3\x6b\x42\x91\x86\x7d\x53\x2f\x2c\x6a\x28\x8a\xb8\x3d\x9e\xfc\xfc\xa2\xb2\x61\x3c\x16\xdc\x39\xd8\xd2\x7d\x10\xd9\xd1\xe0\x98\xcb\x22\xd2\x0c\x45\xd1\xe1\x24\xba\xad\x71\x44\xc0\x49\xac\x64\x2f\x78\x77\xc7\xad\x16\x4a\xc2\x5e\x9a\xa5\xd5\xd1\x64\x65\x59\xa6\xe7\xa9\xce\x7c\x88\xea\xa9\x35\xda\x24\x4d\xa8\x36\x17\xb0\x65\xcb\xa6\xa6\x41\xde\xca\xfe\x83\x9a\x87\x0f\x59\xdd\x32\xe5\xcd\xf6\x15\xee\xd1\xb6\xda\xba\xb2\x81\xd2\x48\xdd\x04\xda\x9e\xbc\xa5\x4c\x41\x25\x72\x48\xdb\x4f\x6c\xa6\xb6\x58\x94\x24\x9d\x4c\x4d\xb1\xc4\x06\xfe\x93\xc6\x47\x75\xe1\x9c\xd4\xb8\xb3\x4f\xc9\xa4\x49\x93\xe4\x50\xd7\x00\xf2\x87\x93\x3f\xb2\x6f\xaa\xfb\x76\x8a\xe7\x1b\x8a\xc7\xc8\xe7\xdf\x41\x66\x9b\xc8\x00\x63\x13\xb5\x1c\xa2\x9e\x6d\x53\xaf\xa0\x36\xa7\x22\x39\xaa\x1b\xe9\xd9\x75\x13\xb1\xf3\xc0\xca\xd4\xa4\x7c\xb3\x7f\x3f\x7c\xb8\x7f\xbf\x32\x65\x8c\xae\x66\xcc\x98\x1f\xfe\x38\x86\xd9\x2f\x46\xdf\xe7\x14\xaf\xc0\xe2\x53\x30\x47\x48\x14\x88\xa6\x24\x2a\x49\x32\xa5\xe7\xf3\xdf\x4d\x92\x56\xdd\xf3\xe3\x65\xba\x3f\x73\x9b\x97\xa9\x95\x49\xa0\x7a\x25\x50\x22\x44\x75\x81\x15\x68\xf2\x4d\x13\x84\x4a\x26\xfd\x4e\x0e\xfd\x50\x29\xaf\xbb\x47\xcb\xe3\x5b\x0a\x2f\xa2\x8c\x98\x1e\x03\x08\x82\x04\x02\x4b\x12\xe9\xc9\x86\xd2\x17\xb0\x97\x1c\x50\x28\x2d\x3f\x6c\x18\x47\x33\xa2\xfd\x99\x2d\x50\x04\xdf\x0b\x4f\x38\x8a\x44\x3d\x8b\x4b\x2a\x7c\x87\x8e\x28\xbb\x91\xe1\x29\x68\x2b\x82\x22\xc4\x42\x99\x42\xf7\x66\xf1\x59\x1c\x94\x4e\xd0\xba\x75\xc7\x0c\x3a\x2b\x82\x1c\x5a\xe1\x16\x66\x13\xf7\xcf\x98\xc1\x5c\x80\xe4\xc9\x1c\x11\x6d\x76\xad\x16\x07\x33\x9e\xbb\x6d\xf3\x0e\xe9\x4e\x61\xc8\xd8\x96\x45\x06\xe9\xc4\x96\x5b\x36\x2e\xcd\xca\x75\xe6\x8d\x8e\x2d\x9a\x88\xd4\x7c\x2b\xc9\xab\xc2\x13\x36\x9e\xaf\x2d\x44\xf9\xfb\x3a\xfd\x95\x85\x6f\xf0\x58\xec\xa5\xfd\xfc\x63\xd4\xd7\x6d\x13\x9e\x76\x48\xa2\x83\xc3\xfb\xba\x3f\x13\xbe\x16\x7e\x47\xef\xd5\x38\xb1\x2b\xba\xff\x4a\x8e\x09\x4f\xd1\x7b\xc2\xef\x87\x77\xff\x55\xe8\xe0\xf0\x02\x3f\xab\xe2\x25\xea\x83\xde\xc3\xdf\x1b\xf9\xfb\xcb\xba\x4f\x90\x1b\xa5\xad\xf4\xde\xc4\xef\xa9\x4a\x0b\xdb\x68\xb9\x25\xd1\xac\xe1\xfb\x8e\xc2\xb3\xf4\x19\x3c\xfd\x11\xda\xcf\x5b\xcd\xdf\x67\x72\x7d\x9a\x8a\xb1\xd0\x28\xcc\xa7\x12\x96\xf1\xa4\x84\x01\xef\x85\x79\x4f\xc4\x81\x76\xec\x5a\x51\xc3\x3e\xa6\xdd\xcc\x6f\xa8\x65\xe1\x69\x02\x42\x61\x57\x24\x00\xbf\x6a\x7e\xb6\x19\xae\xc6\xf8\x59\xd8\xa9\x4c\x52\x69\xde\x89\x90\x24\x89\xaf\x51\x5e\xfb\x78\x59\x7f\x12\xa5\xe4\x73\xf1\xbb\xf4\xe7\xe8\xe3\xd3\xc0\x87\x84\xef\xc8\xe4\xee\x87\xcf\x98\x2e\xa4\xa6\xa3\xef\x39\x1c\xe7\x99\x8f\xf3\xac\x88\xf1\x8c\xf3\x76\xad\xca\x4b\xe5\x9e\x5e\xcf\xbf\x4d\x3e\xd7\x78\x9c\x7c\xfe\x1d\xae\x4b\x7c\x4a\x79\xf1\x06\xe5\xe5\x35\x94\x97\x45\x22\xa8\xcf\x61\x07\xc3\xdf\xfd\x54\xf7\xd7\xb8\x85\xf2\xac\x88\x09\x27\x7b\x8e\xf6\xf2\x7c\x93\x75\x53\xc4\xea\x86\xc9\x14\x2c\xec\x9e\xcb\x64\xca\x5a\x0a\xa5\x4c\xa6\xd2\xea\xab\x88\xd5\x17\x83\xc1\x51\x0e\x83\xad\x43\x61\xa8\x0a\xd3\xfd\x7d\xf7\x77\xf0\x0a\x87\x11\x35\xd9\x0c\x69\x78\x0a\xa1\x50\x83\xf9\x47\xf7\xb7\x78\x12\xcf\x4b\xd2\x60\xb2\x34\x98\x72\x28\xd7\xf2\xba\x8d\xd7\x35\x83\xd1\x69\x79\x35\x2b\x9d\xc8\xb2\x07\xae\x1d\x04\xd6\x41\x30\x88\xc7\xff\xa5\x70\x12\x0e\xa5\xe9\x82\x24\x7c\x57\x3b\x8d\x63\x4a\x6a\x02\x97\x13\xe5\x02\x2e\x27\x45\xa2\x41\x2b\xdb\x15\x5a\x7e\x21\x08\x69\x34\x25\x65\xaf\x88\xc9\x1e\xe7\xd7\x4b\x9c\x2f\x49\x19\x2c\x62\x32\xc8\xd3\x5e\xd2\xfd\x21\x4f\x3b\x1c\x86\x6b\xb4\x5a\xba\x4f\x52\xbe\xb0\xb4\x16\xad\x0e\x6e\x54\x79\x4d\x1b\xf9\x06\x9e\xaf\x4d\xe3\xf5\x66\x8e\x73\x21\xed\xdf\x34\x73\x9a\xed\x5a\xd9\xc6\x76\x5f\x4a\xcb\x86\xfd\x65\x60\x2d\x83\xb2\x64\xd9\xe6\x28\x17\x91\xf7\x38\x5e\xa7\x06\xd7\xd2\x3d\x86\xe7\x1d\x83\x98\x46\x37\x95\x1e\xf2\x25\xc7\xe5\xd2\x60\x2e\xea\x5e\xc3\x61\x86\xc0\x10\x8d\x3e\xb6\x26\x76\x10\xa7\xc3\xa3\x95\xc1\xa7\x5c\x89\xfc\x31\x27\xb4\x8e\x07\xeb\x78\x18\x0f\xb1\xf1\x50\x39\x1e\xf2\xe8\x25\x0b\x46\x1c\xe5\x04\xa8\xf2\xaf\x53\xd6\x0a\x01\x8e\xdf\xab\x95\xcd\xdb\xfd\x66\x9a\xee\x15\x31\xdd\xe3\x38\x37\x6b\x3c\xcd\x87\x7c\x2d\x5f\x2e\xeb\x9c\x7e\x5f\xba\x8c\xa7\xf4\xb4\x88\xe9\x29\xa7\x79\xa6\x96\x56\xad\xd8\xa8\x8a\x1f\x8e\x8a\x8f\xaa\x72\x44\xd3\xfe\x13\x1d\xe5\x3a\xce\xe5\x5a\x6c\x4f\xc9\xf5\x0f\x70\x4f\x8f\xed\xe0\xcf\x8d\xda\xf3\xad\xfc\x39\xe7\x0f\x7f\xee\xd2\x9e\x1f\xe1\xb6\xe1\x32\xaa\x37\xc7\xa4\xad\xa8\x19\x45\x9f\x8c\xf5\x0b\x8c\xdc\x0b\xed\x4f\x0e\x2a\x89\x96\xec\x85\xf9\x4f\xc5\xa3\x81\x40\xf3\xef\x61\x1e\x6d\x6a\x03\xd4\x56\xd8\x61\xa6\xd6\xd9\x4d\xcd\xac\x51\xc3\x9c\xaf\xce\xe9\xb3\xf6\x4e\x3b\x26\x83\xf6\xe7\x79\x78\x72\x7e\xde\x88\x67\x20\x54\xe5\x62\xaf\xb3\xa6\x36\x3f\xf5\x36\x52\xcb\x67\xd7\xf9\x60\x8a\xd3\xa3\x2e\xfb\x62\xa7\xf5\xef\x1f\x5a\x1a\x0c\x58\x2c\x39\x15\x79\xd5\x16\x03\x1e\xd5\xaf\xa8\x28\xb4\xb8\xa4\xaa\xce\x66\xd0\x3b\xbc\x1f\xdc\x79\xd7\xdc\x60\x84\x0a\x76\xe9\xf4\xb2\xaa\x62\x7f\x6e\xed\x3f\xcf\x55\xca\x83\xd5\x26\x9d\x38\x25\xb1\x97\xec\x9d\x37\x71\xfd\xc0\xda\x3c\xd6\x47\xcf\x28\x0b\xc4\x2a\x0d\x0e\x87\xdb\xec\xf5\x64\x46\xaa\xaf\x8d\xe7\xfb\x32\x4b\xeb\xfd\xca\xeb\xbf\x9f\x3f\xcd\x3f\xa2\x42\x57\x98\x43\xfa\x97\x0d\x29\x2f\xfc\xd7\x56\xe5\xee\xc1\x65\xc1\xe1\xfd\xa5\xfe\x17\x91\x42\xc6\x8b\xc4\x1f\x85\x17\xd0\x67\x52\x15\xf5\x9a\x0d\x4f\x20\x3d\x0f\x34\xcc\xdc\xb1\x7c\x41\x0e\xd6\x14\x04\x22\x9f\x09\x5f\x28\x7b\x66\x5e\xb1\x0a\xd6\x83\x39\x43\xdc\xb3\xf2\xd2\xe7\x77\xab\xfe\xca\x87\xc2\x0b\xe4\x27\x2d\x9d\x0e\x92\xe9\x22\x79\x82\x37\x58\x54\x50\x0a\x1f\x66\x80\x09\x36\xac\xba\x62\xa6\xb2\xe7\x0b\x41\xaa\xda\xfd\xfc\xa5\x2b\x79\xba\xc4\x07\xc2\x3e\xf4\xb1\xf8\x67\xb6\x2e\x2d\x66\xa6\xa6\x9c\x58\x8d\x7e\x63\x85\x91\x18\x75\xd4\x6d\x9d\x51\x45\xfb\x61\x14\x8d\xba\x06\x4e\x8d\x98\xe6\xfd\xb8\xed\xb1\xc6\x73\x2f\x18\xec\xb8\x2e\xef\xfd\x67\x2f\x3a\x26\x74\x7a\x8b\xbd\xe1\xaa\x2d\xeb\xb4\x78\xb2\x1f\x0b\xfb\xc8\xe7\x14\x9f\x85\xf6\xbc\x2d\x16\x86\x4f\x0b\x12\x46\x8c\xac\x0f\x30\xc3\xae\x62\x4c\x45\x5d\x63\x01\xf3\x3e\x9e\xf5\xf8\x88\xcb\x2f\x75\x5d\xef\x5b\xfc\xc4\x9a\xb1\x8f\x4c\x15\x6f\xcd\x28\xa9\x1e\xd6\x71\x41\x34\xdf\xad\xae\x47\xe5\x6b\xb0\xc5\x97\xd8\xfa\x64\x4a\x27\xdb\x55\x99\x83\x02\xfc\x04\xf1\x0a\x34\x44\x5b\x93\xba\x10\xad\x44\x3f\xc6\x36\xca\x7e\xbf\x43\xca\xcd\x75\x18\xc1\xed\x76\x5c\x30\x37\xa3\x64\x51\xdb\x98\x51\xe7\xcc\x98\xd1\xd8\x32\x6a\xea\xd0\xea\x08\x71\xd6\x37\x34\x38\xcf\x8a\x0c\x1d\xd5\xd8\x56\x32\xd7\x50\x6a\x40\x0e\xc7\xaa\xfc\xcc\x70\xb8\xd4\x1a\x0a\x95\x5a\x8a\x8a\x82\x59\xa5\xa5\x17\x19\x83\x61\x4f\xd9\x8c\xda\xe5\xcb\x1b\x2b\xdb\xa7\x9f\x03\x59\xe7\xcf\x9f\x3f\xf2\xac\x49\x93\x06\x8d\x2c\x6b\xaf\x3e\x27\x6b\xe4\xc8\xac\x73\xaa\xdb\xcb\xa4\xec\x7e\x79\xae\x70\x38\xe4\x77\x96\x9a\x0a\xac\x32\xf1\xf9\x6c\x3a\x21\x9b\x96\x51\x3b\xf6\xe6\x40\x55\xea\x52\x8d\xc6\xcf\x03\xf2\xab\x93\xdc\xc9\xb1\x7e\xd5\x0b\xb2\xed\xab\x52\xfd\x92\xb4\xe9\x1c\xf5\xeb\x94\x79\x9e\xf4\x31\x9d\x5e\xa3\x4e\x51\xea\x40\x89\x6c\x4b\x2f\x75\xa2\x58\x48\x05\xfa\xa1\xbd\x33\x50\x7b\x76\x69\xcf\x45\xde\x6f\x2b\xcc\xe7\x8e\x21\x73\x11\xa9\xe7\xc5\x02\x4f\x15\xba\x24\x76\x94\x4a\x1e\x1b\x8e\xcb\x05\xa2\x1d\xac\xe2\xd5\x7e\xc1\x16\x48\x76\xa9\xd2\x97\x23\xea\xd0\x9c\xe3\x30\x2c\xf1\x92\xf2\x7b\x18\x86\x1b\xe6\xcc\xe9\xbc\x94\x5d\x09\xeb\x95\xdf\x1f\x9f\xf3\xd3\xb0\xe3\x73\xd4\x6b\x18\x76\xf2\xee\x39\x73\x48\x2e\xbb\x62\xb0\x73\x8e\x8b\x68\x46\xab\x7b\x91\xa9\xa4\xb2\xaa\x6c\xe6\x1f\xe7\x28\x5b\x6e\xdd\xf2\xd8\x6f\x20\x77\xcc\xd8\xd9\x1d\xb7\xc7\x27\xe7\xe5\xed\xaa\x98\x3b\xb7\x7a\xd0\x4b\x4a\x4c\x79\xe7\x86\xeb\xae\xbb\xf1\xfa\xeb\x2e\x88\x4f\x6f\x9b\x32\x6d\xfa\x8c\xb8\xb0\xfe\xf8\x9c\x39\x73\xba\xd6\xc3\x30\x78\x6f\xce\xc9\x86\x39\xc7\x85\x4c\x4a\x00\xbd\x80\xf7\x60\x58\xd7\xfa\x39\x34\xc7\xe3\x27\x5a\x2f\x72\x8c\x1e\x3e\xac\x15\x3e\x99\x96\x78\xf5\xd2\x8b\xff\x79\xde\x6a\x52\xba\x6f\x78\x87\xdd\xb8\x08\x82\x43\xeb\x14\xe5\xd3\x11\xa3\x94\x77\x61\x98\x32\xed\xf0\x3b\x47\x0f\x1e\x3c\xfa\xf0\xf6\x5b\x1e\x7a\xf4\x8e\x9b\xb8\xec\x46\xa9\x2d\x64\xe3\x6e\xf9\x6c\xb5\x86\xd3\x6e\xb3\x65\x67\xf8\x4c\x56\x2b\xca\xcb\xf3\xb9\x48\x90\x8a\x55\x41\x9e\x2d\x33\x27\xb3\x25\xce\x7a\x2c\x79\xd9\xb4\x17\x90\x9d\x9d\x63\x75\xb9\xc5\x3e\x33\x56\x15\x0d\xc9\x93\x91\xb4\xa1\xb8\xf4\x05\xcc\x5a\xa7\xa5\x67\xae\x8a\x1f\xf8\x1c\x60\x67\x82\xd6\xb2\x63\x00\x83\xf4\x37\x40\xbb\x31\x12\x31\x16\xe4\x9c\x15\x73\x57\x2c\x1e\x31\x72\xbc\xad\x5d\xf9\xfe\xfc\x41\xd1\x3d\xba\xb1\x4d\x05\x2b\xae\x6c\xac\xab\x27\xf7\x59\x7f\xd7\x66\xd7\xa6\xab\xda\x26\x87\xcf\xc5\xe5\xca\xc0\xc4\x8d\xe5\xc3\x36\x5d\x03\x6f\x6c\x7c\x73\x52\xe2\xbd\x73\x54\x7d\xdc\x2c\xb4\x93\xa9\xe2\xe3\x54\x6f\xea\x62\x7e\xa3\x81\x08\x6c\x3d\xaf\x91\xf6\xae\x40\x4f\x88\x4e\x87\xb6\xc5\xad\x3a\xbf\x6e\x97\xee\x88\x4e\xa0\x1a\x3f\x83\x9f\xa8\x4c\x49\xaf\xab\x48\x5f\xd2\x47\x55\xd5\x4b\x55\x35\x8f\x09\x0d\x7c\x3b\x69\x53\x73\xac\x6e\xf1\x6f\x66\x2a\x3f\x54\xdd\xef\x9c\x26\xbc\xdc\x71\x55\xf6\xf2\x55\x23\xff\x95\x7d\x4e\x9c\xf5\x9b\xc8\x36\x98\x43\xfb\xb3\x0e\x94\x1f\x33\x99\xd9\x6a\x5c\x17\xeb\x37\xd9\x68\xff\x25\xe7\x89\x73\x6d\x7c\xa2\x3a\x35\x0e\x00\xac\x8b\x34\x18\xa7\xf5\x91\xe6\x6c\xb9\x7b\x58\x4b\x51\x4e\x30\xa7\xb6\xb4\x6a\xa8\xf0\xe8\xe2\xab\x0a\x1b\xac\x25\x95\x21\xbb\x2f\x3b\xe4\x2f\x2a\x1e\xab\x96\xa9\x46\x68\x83\x62\xf1\x08\xb5\x0c\x25\x31\x13\x32\x12\xe2\xb0\xb3\x3c\x2c\xac\x8f\x14\x33\x9e\x6b\xb5\xf8\x2d\xbb\x2c\x47\x2c\x82\x85\x15\xa8\x34\x39\xd8\x57\xcd\x22\x9d\xbb\x5d\xb9\x58\x1d\xb0\xab\xe9\xe9\x8d\x09\xc7\xfb\x74\xc7\xba\xbb\xa1\x42\x98\x89\x77\x88\x5b\x6c\x12\xdb\x73\xf6\xcb\xf7\xe8\x47\x7a\x7f\x80\xdf\xaf\xfc\xe5\x7b\x04\x8a\x57\x3c\xd8\xfd\x07\xb9\x94\xf2\xc9\xf4\x24\xd1\x99\xad\x7c\x94\x81\xf6\x85\xd4\x28\xe7\x6c\x19\x1e\x5b\x4b\x18\x8c\x0e\x86\xe3\x91\x92\xa6\x46\xff\xb4\x85\x5f\x8d\x3f\x77\xe9\x88\x4a\xe9\x12\x7f\x7e\xc6\xec\xdc\x1b\x06\x9e\x63\xac\x5a\x45\x72\xb9\x0d\xb7\x8b\x07\x95\x97\x4f\xc5\x05\xa7\xe2\x52\xb2\x7e\x1e\x19\x74\x4d\xa5\xb8\xf4\xff\x15\xae\x44\xfb\xcf\xe2\xa2\x65\x5e\x2b\xb4\x92\x12\x71\xae\x4d\xc2\x3b\xd0\xe9\xee\x8f\xd3\xfb\x80\x78\x11\xbd\xbf\x85\xdf\x3f\x4a\x79\xa4\x88\xd7\xd2\xfb\x4d\xbc\x0f\x67\x55\x0e\x76\xbf\xd2\xbd\x82\xf6\x4b\x75\x8f\x23\xb6\x75\x87\xf7\x15\xdd\xff\x7c\x4a\x39\xb8\x73\xe7\x2f\xf3\xfc\x97\xea\x2c\x59\x07\x0e\x09\xbf\x76\xba\xfb\x5f\xa4\xff\xff\x78\xdf\xd5\xad\x1c\x4c\x3c\xd9\xbd\xc2\x26\xeb\x1d\x89\x6f\x11\xf7\xf1\xba\x36\xd3\x67\x0d\xda\xb3\x8b\xd5\x67\x9d\x5f\x28\x07\xbb\xee\x50\x9f\x75\xbd\xaf\xc1\x1d\xa1\x70\x97\x69\x70\x2f\x6a\x70\xf7\x51\xb8\x69\x1a\xdc\x4d\xea\xb3\xbe\x79\x26\x16\x2b\x07\x95\x80\x0a\xa3\xcc\x54\x61\x94\xcb\x29\x9f\x07\xa8\xcf\x28\xb7\xd5\x67\x7f\xa4\xcf\xd6\xd3\x67\x92\xde\xf1\x1c\xcb\xef\x27\x9a\xdf\x23\x5a\x7e\xff\x50\x61\x12\x6b\x28\xae\xb0\x86\x6b\x91\xf6\xac\x83\x3e\xcb\xd4\x9e\x4d\xd1\x68\xdd\x41\xd3\x4e\xd0\xd2\x6e\xd1\xe0\x82\xf4\xd9\x31\x0d\xce\xa5\xc1\xd5\x53\xfa\xbf\xd6\xe0\x4a\x4f\x4f\xff\xff\xec\x9e\xc7\x5d\x45\xf0\x3b\x6a\xd3\x65\xd4\x2f\xe6\x42\x44\xa0\x9e\x88\x4e\xaf\xcd\x9b\xa4\x0d\x30\x95\xa6\x99\x3b\x3e\xa0\x14\xaa\x0d\x80\x9f\x8d\x1e\x6d\x67\xeb\x91\x1a\x7d\xe5\x6c\x62\x04\x91\xee\x11\xe2\x6d\xf0\x9a\x36\x16\x9c\x85\x1c\x4f\x9b\x7d\x3e\x84\x9d\x32\x57\x13\xee\xda\x10\x36\xc7\x72\x86\x15\xee\xcf\x39\xf1\x32\xe7\x94\xaa\xc2\xc2\xea\xea\xc2\xc2\x2a\xe5\x15\x7a\x15\x8d\xd2\x2b\xe9\xa9\xc5\x8b\x9f\xe7\x97\xec\x85\xfa\x4b\xf3\xba\x44\x18\x02\x97\x89\xdf\x52\xbf\xc7\x4e\x3d\x1e\xd7\x1e\xb7\x9e\x3a\x40\x24\x8b\xeb\x24\x1b\x94\x61\x8e\x14\x5b\xdb\x22\xca\x3d\x11\x36\x8b\x0a\xd3\xae\xc7\x0a\xbf\x7a\x48\x50\xbe\xf9\x2a\x99\x23\x0c\x4a\xe6\x28\x5a\xbc\xaf\x65\xfe\x61\x59\x5a\x7e\xec\x97\xe6\x29\xd3\x3c\x87\xd1\x3c\xf9\xb8\x2b\xca\x89\x99\xf4\xee\x5c\x9f\x9b\xfe\xcf\xcc\xb0\xaa\xc3\xc6\xea\x12\x23\x3e\x20\x72\x86\x62\x12\x6f\x6d\xc4\x0a\xc1\x50\xed\x0f\xa7\x16\x75\xed\x91\x1f\x07\x89\x1f\xbc\x78\x8b\x28\xdc\xda\xa7\xc0\x50\xb9\x76\x6d\xe0\xa5\x97\x02\x7c\x2d\x4d\xb7\x5e\x18\x82\x7e\x48\x2b\xbb\x35\x8b\xb2\x9b\x50\x0e\xa4\x95\x9d\x9d\xcd\x2c\x7b\xcf\x40\x84\xe9\x90\xf0\xd0\x10\xe1\xd0\xa9\x14\x88\x96\x3f\x64\xbe\xe6\x5d\xd6\x97\xdd\x08\xd3\xba\xbd\x11\x0e\x69\x75\x6b\x7a\xd2\x8c\xb0\xcc\x0f\xd4\x38\xb5\x4e\x69\x3d\x2e\x77\x7e\x91\x9a\x55\xa1\xb5\xf7\x84\x7a\x19\xe3\xf3\x33\x56\xf1\x5a\x0d\x4f\x16\xe5\xa0\x25\x43\x6f\x8b\x19\xed\x4d\x36\x1b\x46\x6e\xb3\xc0\x3c\xc4\x7d\x54\x54\x4a\x23\xaa\xb0\xc8\x24\x3f\x8c\x55\xf7\x9a\xa2\xce\xc5\xda\x52\x33\x9e\xc5\x97\x15\xa3\x87\x9e\x15\xc8\x2d\xf6\x39\x22\x15\x8f\x57\x34\x0f\x39\x2b\xaf\xac\xc6\x56\x9d\x75\x3e\xcb\x51\x79\xdf\x5f\xe4\xb7\x67\x96\x3e\x46\x7f\x0a\x2b\xa7\x4f\xa4\xb2\x7e\x27\x65\xdc\x1e\xf1\x12\x2a\x24\x45\x31\x9b\x0c\x6c\xfc\xca\x60\xc4\xb2\x0c\x3a\x81\x2f\xb6\x8c\xec\x53\x67\x94\x21\x39\x1d\x1b\x08\xda\xb9\x73\x68\x8f\x90\x3d\x9b\x94\x7b\x94\xc3\x30\x17\x4a\x36\x91\xdb\x61\xfa\x26\xe5\x2d\x28\x41\xff\x77\x9c\xd7\x2a\x1f\x73\x9c\xf8\x28\x2e\xd8\xa4\x8c\x80\xe7\xfe\x1f\xe0\xbc\x52\xf9\x02\x96\x40\xde\x26\xb8\x83\x4c\xdb\x94\x98\x86\xef\x4b\xc7\xa9\x63\xb3\x3f\x20\x49\x04\x21\xbd\x41\x02\x99\xed\x7c\xd4\x30\xa6\xe3\x4b\x43\xb7\x41\xf9\x17\x47\x27\xfc\xb4\xa9\x6b\x38\xf9\x1d\xc5\x35\x26\x1d\x17\xdb\x39\x49\x31\x11\x02\x22\xd6\x71\x5c\x11\x6d\x76\x4a\x1d\xe6\xa5\xb4\xe9\xa1\x56\x0f\x1c\xd7\x5e\xa5\x63\x3a\x0c\x86\xa6\x4d\xc2\xab\xca\x21\xb8\x62\x96\xf2\x26\x54\xab\x3e\xcb\x84\x54\x99\x0b\x62\xd6\x64\x99\x89\x24\x81\xa8\xe7\x48\xd3\x70\x6a\x25\x0e\x40\x2d\xdb\x5d\xce\xd0\x5e\xaf\x6c\x69\x87\x91\x50\xbd\x89\xdc\x0f\x4b\x66\x29\x7b\x61\x02\xc7\x99\xa4\x53\x66\x38\x45\x00\x5a\x66\x9d\x1e\x8b\x22\x08\xb2\x86\xf3\x14\x2e\xd6\xaa\x85\x4e\xe4\xb6\xe2\xcb\x36\xe1\x51\xf8\xd0\xcc\xc4\xad\xf8\xc2\x34\x5c\xbd\xe8\xe3\x75\x22\x9e\x1e\x57\x94\x96\x1a\x9c\xf6\x64\xb1\x27\xc2\x93\xef\x6f\xfa\x12\xdf\x0b\x57\x2c\x52\xe6\x2b\x15\x64\x01\xc5\xd9\x98\xe2\x63\x5e\xcc\x9c\x56\x27\x42\x12\x63\x3a\xbe\x34\x74\xf7\x2b\x4b\xa7\xc1\xa3\x1f\x6f\x22\xbf\x85\x35\x1d\xca\xc2\xc4\x6d\xe4\x24\x2f\x2f\xc5\x87\x97\x9e\xae\xbc\x92\xf0\x73\xe5\xc5\x4b\x37\x29\x33\xa7\xd1\x4a\xa1\x82\xbd\x71\x8e\xf2\x36\xf4\x63\xbe\xfe\xe9\xeb\x58\xc6\xe2\x2f\xd5\xf1\x53\xca\x84\x45\xb4\x32\x68\x1d\xaf\x4e\xbc\x85\x3f\x1d\x9b\x38\x8e\x03\x6a\x1d\x47\x53\x3c\x0c\xc7\x5c\x49\x1e\x4a\x84\x72\x51\xa4\xa8\x53\x8c\xac\xd0\x7a\x71\xbd\x28\xe5\xf8\xed\x3d\x19\xcc\x82\x30\x2d\xbf\xf2\x38\xfe\x74\x74\xe2\x49\x28\x87\x3c\x8a\x7f\xdc\x99\x64\xa8\x07\xf5\x99\x65\xe8\x01\x65\xd5\x72\x98\x03\xba\x4d\xf8\x56\xbc\xa3\x29\x71\x17\x9e\xc9\x69\x2e\xff\x9f\xd6\x3b\xa3\x14\xbc\x2a\xce\x1d\x4a\xdb\x4a\xb8\xfe\xc7\x4d\x60\x81\xd9\xf8\x8f\x8d\x89\xc6\x9f\xc8\x93\x14\x67\x93\x86\x53\xe2\xf5\x2e\xb0\xbd\xcd\x3a\x5a\xe9\xea\xd4\x56\xdf\x7a\x4f\x89\xa4\xef\x22\x5a\x51\xe2\xa0\xe1\x9d\xdb\x85\x79\x28\x49\xdb\xff\xb6\xbe\x47\x2c\xa3\x15\x84\x27\xe3\x13\x4d\xbc\x7a\x00\x15\xa4\xea\x3b\x65\x73\xce\x5c\xe3\xf6\x53\xf5\x7a\xd0\xc5\x6a\x9d\xfb\xba\x3e\x10\xe2\x55\x5d\x1f\x90\xa0\x4a\x63\xe1\xe9\x6c\x19\xc3\xab\xfb\x05\xbc\x51\x8e\xf8\x65\xa5\x7a\x3d\x4c\x65\x9a\x7d\x47\xe2\x0a\xa1\x5f\xb4\xeb\x6f\xb8\xe3\x89\xde\x78\xff\x4f\xb2\xf4\xa4\x32\x6c\x2d\x2c\x83\x6c\xca\x0b\xe5\x71\xa1\xa9\xaa\x6b\x1d\x38\xf0\x05\x14\x7f\xe8\xff\x22\x4b\x37\x28\xb3\x57\xc3\x65\x60\xda\x04\xe3\x89\x52\xd5\x35\x95\x3c\xc0\x79\x51\x71\x5a\x1b\x9c\xa6\xf0\x15\xa7\x68\xbc\x37\x69\x40\x9a\x36\xc0\x23\x6f\x6e\x82\x91\x02\xa9\xed\x72\xbd\x25\xbc\xac\xf1\x40\xab\x7f\x2a\x47\xc9\xfa\x4f\xaf\xfd\x5e\xf6\x28\x55\xf7\x83\xd6\xd2\x8a\xfa\xb7\x30\x5d\xab\x25\xa0\xfe\x43\x92\xae\x54\x59\x29\x5d\x18\x64\x2e\x91\x6c\x7f\x71\x5d\xdd\x99\x6b\xbe\x66\x1d\x8c\x61\xc6\xe3\x58\x57\xb1\x38\xbe\xb2\xab\x98\x1c\xe3\x73\x99\xa7\xe3\x1f\xc5\x29\xea\x7f\x16\x67\x54\x43\x5a\xb9\x1e\xe2\x30\x64\x13\x59\xd1\xb5\x59\x1c\x57\xd1\xe5\x25\xe7\x6d\xd4\xfa\xb6\xff\x3b\xbc\x49\x36\x8e\xdb\x00\x63\xa1\x6c\x13\xde\x92\xb8\x40\x9c\x58\xde\x79\x02\x2f\x86\xc7\xfb\xe0\x2d\x89\x39\xd2\xf5\x5c\xd4\x33\x69\xe5\x13\xfb\x67\xd2\xf6\xc2\x14\xf6\xf5\xb0\x1c\xe4\x4d\x30\x40\xf9\x03\xc3\xbe\xf6\x24\xb9\x9a\xe1\xae\x4c\xb5\x43\x99\x2c\xae\x36\xab\x25\x89\xb7\xbb\x91\x34\x1b\x5a\x0c\x14\x53\x84\x61\x52\x4a\x95\xb1\x97\xc0\xb6\x2f\x36\x89\x13\xc3\x9d\x6c\xb6\x86\xe1\x28\xd6\xea\x3a\xcd\x66\xc8\xba\x9f\xb5\x19\xac\xaa\x87\x5c\x02\x83\x19\x1a\xb5\x56\x50\x9a\x8d\x94\x51\x76\x8c\x05\x62\x67\x7b\xce\x80\x48\xbd\x05\x50\x93\xe7\x10\x04\x58\xb9\x0e\x29\xbb\x67\xd1\x72\x7d\x27\xfc\xa4\xec\x9d\x05\x4b\x54\x3c\xcd\x7d\xf8\x25\x32\x7e\xc9\x18\x53\x6c\x3a\x0d\x1d\xc3\x77\x1a\x7e\x85\x92\xb5\xb1\x47\x79\xe9\x5c\xb8\x95\x89\xce\x75\x10\x55\xde\xeb\x80\xd5\xd4\x27\xa8\xfe\x7f\x83\xfb\x66\xe5\xdd\x73\x38\x6e\x5c\x8c\x2f\x51\xbe\x9f\x0f\xab\x13\x2f\xe1\x86\xd3\xe3\x36\x1a\x7e\x19\x77\x14\xc4\x14\xee\xcb\x95\x2f\x27\x72\xdc\x7f\x27\x8f\x30\xcc\x5d\x6f\x90\x72\xce\x93\x99\xe9\xfa\x2d\x9d\xd6\x82\xd6\xa5\xb5\x99\x69\x28\xaf\x51\xfe\x3d\x9e\xa2\xac\xd9\x24\x5c\xf5\x57\xca\x87\xae\x41\xe4\x15\x95\x56\xad\xce\x29\x3e\x91\xcb\xa4\xac\xa3\x08\xb1\x74\x5a\x7b\x61\xa7\x15\xc6\x6b\xfd\xe5\x99\x70\xdb\x26\xe1\x65\xe5\x83\x05\xb0\xba\xb7\xef\x47\x65\x47\x6d\xcb\x05\xda\x4a\x68\xee\x5a\xdf\x96\x5c\x66\xae\x1f\xa3\xaa\x5b\x59\x0a\x93\x60\xe0\x26\x61\xdf\xc7\x9b\xc0\xd3\xcb\x2f\xed\x17\xb3\x27\x75\x44\xc6\x02\x6b\x72\xf4\xea\x22\xa2\x8a\xba\x53\xac\x6d\x9a\x2b\x79\x2b\xf5\x9a\x59\xc3\x8d\x17\xc0\x1a\x4a\x26\x3b\xa6\xb3\xb7\xbf\x9b\xa6\xd3\x82\xdc\x1b\xeb\x99\x70\xee\x50\xde\x80\x0d\x60\xdb\x04\x51\xfc\xe8\xa6\xc4\xbf\x48\x41\x6f\x9c\xdc\xa6\xa9\xb6\xd6\xa0\x27\x12\xab\xe6\xd3\xe3\x64\x28\x35\xff\xea\x11\x65\x1f\xec\xf8\xe7\x26\x72\x62\x53\xa2\x21\xa9\x37\x2d\x29\x7c\xa9\xb2\xb3\xda\x15\x49\x1a\x1f\x59\xb7\xeb\x4c\x76\xf2\x19\x65\x7e\x1b\xe4\xc2\xac\x4d\xc2\xaa\xc4\x51\xf8\x6d\xbb\xf2\x1e\x9e\xdc\x5b\x8f\x2a\x63\xee\x9e\x76\x8c\x4a\xa4\xc8\x91\xeb\x53\x8b\xb3\x7e\xa1\x25\xdb\xab\xcc\x6d\x83\x81\x4c\x9b\x1e\x53\x9e\x81\xdb\xda\x94\xfd\xb4\x41\xb6\x25\xfd\xc2\x53\xdb\x60\x22\x89\x52\x3a\xfa\x33\xb7\x66\x1d\xca\xe3\xed\x50\x02\x33\xa8\x67\x04\x2b\xa7\x2b\x4f\x53\xcf\xa8\x87\x6e\x99\xe1\x54\xdb\x1e\xbd\x8e\x1d\xd0\x25\x24\xd7\x93\x9d\xaa\x9f\x29\x57\x26\x67\x26\xbe\x62\x13\x84\xf0\xa7\xb3\x13\x6b\xc9\xcd\xbd\xec\xc9\xff\x8f\xb5\xeb\x00\x8c\xa2\xe8\xfe\x3b\x6d\x4b\x12\x02\x21\x14\x43\x0d\x1d\x84\x24\x64\x77\x2f\x85\x22\xa4\x5c\xe8\x45\x5a\xe8\x70\x24\x97\x02\x49\x2e\xa4\x50\x15\xb0\xc7\xcf\xde\x11\x7b\xf9\xec\x82\x62\xef\x22\x28\x16\x10\xa5\x28\x8a\xa0\x80\x34\x41\x11\x04\x14\x24\x77\xff\xb7\x73\x2f\xe1\x12\x82\x7e\x9f\xdf\x5f\xcc\x9b\xb9\xdd\x9d\xf7\x7b\xef\xcd\xec\xfc\xde\xec\xdd\xcd\xd5\xe5\xc6\xd0\xee\xba\x50\x36\x0c\x8e\x4f\x21\x2f\x6c\xaf\xa2\xe5\x64\x45\x8e\x7f\xac\x3f\x87\x4f\x09\xb9\x77\x34\xbc\x77\x82\xdc\x58\xc7\xba\x86\x33\xa3\xdc\x69\x64\x40\x15\xcd\x25\xf7\x7b\xfd\x6b\xe8\x94\x7a\xbc\xfd\x4f\xfb\x7e\x50\x25\xe8\x1f\x57\xc5\xdb\x9e\xdd\xc7\x3c\x59\xd5\xf7\xb2\x01\x8e\xde\xd4\xff\xbd\xef\x6b\xf8\x72\xcc\x3c\x92\x22\x33\xf8\xea\xb9\x6c\xd0\xa0\xea\x47\xe8\x2d\xf8\xbe\xd7\x80\x10\x8c\x16\xa1\x18\x0c\x3a\x8b\xc2\x64\x12\x04\xa9\xfd\x3d\xe4\x0b\x8e\xaf\x0f\xfc\x23\xe7\x93\x69\x4e\xa6\x54\xee\x7f\x9c\x4d\xec\x5f\x3d\x9e\xa4\xd0\xc1\xf5\x30\xfe\xd1\xf8\x7a\xcc\x5f\x3c\x1f\x56\x98\x61\x55\x64\x02\x8b\xe9\x5f\x6d\xb2\xc7\x42\x74\xfe\x17\xe3\xa1\x65\xcd\xf2\x60\xea\x7c\xb2\xe2\x7b\x98\x10\x58\x9f\xfe\x67\x77\x7d\x16\xcc\x95\x06\xd4\x8e\x87\xda\xf1\x2a\x73\xe5\xbf\x1d\xaf\xce\x98\xc8\x9e\x4f\xcc\x2a\x12\xc7\xd2\xfb\x57\x3f\xc3\x7a\xd6\xc9\x17\xea\xe4\xcb\xce\x44\xa8\xab\x32\x5b\xb0\x1a\x18\x63\xa1\x59\xd3\xa8\xcb\x89\x5d\x93\x35\x19\xbd\xcf\xce\xad\x99\x67\x5c\x0d\xae\xfd\x9d\xa9\xf0\x6f\xf4\xd6\x8c\x84\x91\x97\x93\x7e\x35\x99\x93\x91\x78\x76\x8a\xcc\x9c\x2e\x90\xdf\x38\x23\xad\xbe\xe6\xbf\x9a\x61\x42\xb3\xa7\xf0\xb8\xb3\x3d\x65\xf6\xf4\x3f\xe9\x6e\x38\x77\x0a\x8b\xfb\x73\x1d\xe6\x4e\x49\xb5\xf3\x8c\xb3\x53\x95\xcc\x9d\x18\xe3\x5a\x30\x7b\x3a\xc7\x80\x75\xf2\xa7\xde\x8e\xb2\xfb\x7e\xa8\x72\xf4\x5c\x8a\xf9\x93\x2b\x94\x4b\x6b\xf3\x27\x18\xff\x6a\x83\xe3\xa9\xb6\xeb\x47\x2c\x85\xc5\x07\x28\x3a\xbb\x88\x7d\xa1\xd4\x99\xf7\x1c\x7b\xc8\x05\x12\xa8\x7a\x19\xd4\x6e\xff\xb3\x3e\x32\xdf\xc9\xa0\xaa\xd7\x0e\xa3\x8b\xea\xce\xfb\xbd\x06\x46\xd7\xe4\x38\x90\x6f\xaa\xf5\x12\x91\x86\x32\xce\xda\xb4\x61\xb3\xff\x4d\x5f\x4d\x06\xd5\xce\x1f\x01\xaa\x65\x06\xf5\xff\xa6\xff\x45\xff\x0e\x5f\x4d\x16\x35\xd6\x3f\x10\xf4\xcb\x2c\xaa\xae\xfe\xe0\x38\x0d\xe6\x68\xe7\x65\x51\xf5\x9e\x88\xd4\x6a\xbe\xcf\x7f\xcc\x87\x39\x54\xa5\x7f\x3a\x28\x0e\x26\x51\xf5\x78\xe0\xef\x73\xa8\x10\x95\x0f\xfa\x7f\xf1\x91\xe7\x9d\x1c\x6a\x8c\x7f\xb6\xa3\xd1\x49\xa2\xa4\xad\x05\xff\x30\x8f\x3a\xea\x23\xcb\xaa\xf8\x12\x7f\xbf\x11\x75\xfb\x4c\x0d\xee\xd2\x73\x21\x2d\xb5\x3a\x1c\xaa\x9b\x33\x92\xee\xad\xe2\x9b\xaa\xbf\x28\x08\xea\xc8\xaa\x97\x43\x89\xe0\x5c\xc9\xe1\x5f\xc8\x64\x59\xbf\x4f\xe4\x48\x0a\xba\xf9\xae\xff\xad\x59\x64\x36\x59\x0a\xe9\x89\x7f\xf9\x54\x72\x27\x69\x51\xaf\x3f\x82\xeb\x61\xec\x6f\xa6\xd5\x57\xdd\x34\xd5\xfc\x4f\x72\x72\x7a\x45\x6d\x4e\x4e\xdd\x7f\xa1\x5f\xd5\xea\xe9\x6f\x90\xa9\xce\xcf\xcb\x49\x4c\x6d\x5e\xce\x46\xd5\xe9\x77\x98\x43\x60\xbe\xc7\xf9\x34\xc8\xb2\x7a\x1d\xed\x75\xee\x53\x56\xab\xba\x70\x5f\x3e\xac\xe4\x4b\xab\x60\x02\xf8\x71\x2a\xf9\xe0\xec\xe3\xbc\x73\x9d\x3c\x00\xe2\x1d\xec\x7b\x39\xef\x6b\xac\xf6\x83\xef\x0d\xdc\x03\x10\x6e\x97\x1c\x02\x6b\xa6\x41\x2a\xcd\x3e\xf1\xaf\xf1\x92\xfb\x4f\xd5\xcd\x2b\x43\xe6\x7d\x4e\x75\x51\x6b\x25\xfc\x5f\x4f\x1b\xab\xc9\xa8\x0f\xf8\x27\x92\x09\x24\xb5\x8a\x4f\xf6\xa7\x55\x39\x0f\x98\x42\x73\xdf\xe0\x7d\x1a\xcc\x7d\x05\xdc\xa9\x46\x48\xfe\xdb\x10\xff\x6b\xb5\x39\xf0\x71\x7f\x0e\xc9\x23\x3d\xaa\xd8\xbd\xfe\x2a\xd2\x87\x74\x56\x2e\x94\xab\x53\xad\x7e\x56\x7d\xe1\xbc\xfa\x01\xff\x56\x92\x03\x93\x3d\xe9\x4c\xe6\x57\xf9\x3f\x64\xf7\x5e\x30\xaf\x36\xc2\xfe\x2e\xaf\x26\x35\x8f\xd8\x3e\x21\xd7\x13\x15\xf2\xc8\x2a\x3f\xe7\x93\xa5\xbe\x09\xb5\xfa\x6a\x9f\xe3\x38\x77\x3c\x15\x7a\xbd\x9e\x8f\x6a\x70\xed\x2d\x82\x7c\xfa\xbe\x3f\x7f\x06\xb8\x35\xb7\x8a\x77\xae\x8e\x22\x37\x4c\xf7\x33\x0f\xe8\xce\xae\x8d\x81\x59\x37\xf7\xa1\xc2\xa8\x97\x60\x45\xfd\x6d\x86\x55\x3a\x9d\x34\x25\x05\x55\x6c\x59\xf5\x3b\xe4\xaa\xe9\xfe\x3f\xe8\xa2\x63\x8e\xfd\x93\xfe\xff\xf2\xf7\xb2\x29\x90\x12\x0c\xaa\xa2\x45\x30\x89\x5f\x99\xe7\xdf\x46\x4c\x1a\x8c\x51\xf6\xff\x96\x5f\x2d\xf7\xdf\x3a\x8b\x0c\x23\x3d\x21\xbf\x22\x45\x53\xfd\xef\xcb\xfc\x6a\x42\xed\x5c\x16\xc2\x87\x0e\x1d\xd6\x67\xd6\x7a\x4f\x21\xbb\xcd\xa0\x8b\xaa\xe8\xfb\xd3\xab\x1f\xe4\x1f\x3a\xb6\x4d\xfd\x5f\xf2\xaa\x8a\x69\x24\xa1\x0a\x9c\xbe\xc1\xeb\xdf\xcc\x6e\x90\xbe\xa6\x84\x8e\xaf\xe0\x5a\x35\x78\x73\x85\x24\x12\x4d\x53\x1b\x7e\xf2\xfc\xa9\x7f\x80\x8f\xf4\x84\x85\x0a\x5b\x7b\xb6\x3f\xfd\x66\x98\x3f\x86\x67\x3a\x3a\x93\x1b\xba\xc7\xa0\x87\x8c\x7a\x09\x4a\x83\x23\xec\xdc\x08\x18\xed\x83\x55\xd0\x8c\x2a\x16\x77\x76\x8b\xa3\x3c\x82\x15\x1c\x0a\xde\x13\xc9\xff\x1f\xb9\x15\x68\x1f\x40\x86\x56\xd1\x01\x40\xb1\xdf\x0c\xab\x3e\x44\x87\xd1\x1e\x4e\x3c\x02\xd5\x0d\xdc\xc7\x02\x46\x97\xa1\x3a\x5f\x9d\x90\xaa\xf1\xcb\x1e\x0d\x6a\x7e\xc3\xd1\x3c\x19\x16\xdd\x64\x92\xff\x71\xfa\xdd\xb0\xea\x37\x49\x1a\x9b\x55\x27\xd6\xff\x5d\x6e\x75\xa9\x8f\xdc\xf4\x67\x95\x63\x63\x2e\xe6\x56\x29\x0d\xe5\x56\x7f\x33\x96\x68\xe9\xf5\x8e\xa6\x34\xa9\x68\x2f\x97\xdc\x38\xe8\xbf\xc8\xad\x3a\x61\x6e\xf5\x8b\x7f\xe9\x42\x20\x94\x6d\xfc\xf4\xd9\x69\x26\x0b\xda\xe3\xfe\xff\xc8\x7d\x7e\xf4\x3f\xbf\x98\x3c\x40\x46\x54\xb1\x05\xa4\xe9\xd9\x0d\xa0\xdb\xff\xa2\xb3\xcf\xf8\xff\x97\xfe\xcf\xfd\x6b\x17\x93\x47\x1d\xa6\xcd\x21\xc7\xaa\x69\x22\x3b\x53\x7d\x80\xc6\x84\xe8\xbf\xfa\xbf\xd7\x1f\x9a\x61\xbd\xe2\xff\x2e\xa8\xff\x01\x56\x59\x9d\x69\xb2\xb3\x67\x1f\x66\xd3\x94\x3a\xf6\xcb\xf5\x6c\x0d\xd7\xaa\xa2\x5e\x9a\x75\xde\xfb\x4f\xb5\xaa\x9f\xf3\xef\x0b\xaa\x66\xd5\xd5\x93\x20\x30\x35\xcf\x7c\xdd\xff\x30\xcf\xda\x0e\xda\xae\xe7\x6d\xaa\xfb\xc8\x0e\x24\xca\x15\xa1\x39\x60\xd0\x7f\xe0\x58\x1e\xf2\xc0\xaa\x1e\x13\x3a\xa6\x39\x96\x7d\xef\x7f\x6a\x3e\x99\x45\x86\x57\xf1\x0f\x3e\xab\x9e\xd1\x9f\xbe\x41\x5c\xa1\xfa\xfe\xbb\x9c\xab\x53\x6d\xce\x75\xc8\xff\xe2\x3c\x52\x46\xfa\x41\xca\x55\x5d\xde\x9f\x6e\x97\x29\x57\x9d\xf5\xfb\xff\x94\x73\x6d\xf6\xaf\x9c\x47\x56\x3a\x23\x61\x12\xb9\xb1\x7a\xee\x20\x36\xc8\x3f\x8e\x0e\xf9\xdf\xf4\x87\x8e\x84\x17\xfc\x5f\x04\xf5\xbf\x42\x7f\xa9\x7e\x19\xd4\x57\xc7\xb2\xcb\x70\x9f\x9b\x06\x72\x2e\x55\xd4\x63\x5e\x47\xfb\x05\x46\xc2\x53\xfe\xed\x95\x90\x73\xc3\x48\xb8\xa3\x7a\x5d\x16\x1b\x7c\xf6\x2e\xae\xd5\xc6\xe6\xfc\xbc\xcb\xf9\x4d\xc9\xff\x2c\xef\xfa\x78\x3e\x59\x55\xc5\xde\xa8\x7e\xa8\x3f\x1b\xf1\x90\xa3\xef\xb6\x5a\x5b\x71\x6e\x68\x78\x44\x04\xf3\xad\x9a\xf1\xb0\xdd\x7f\xd7\x14\x20\xbd\xc1\x55\x7c\x8a\x3f\xc7\xbf\x3c\x87\x8c\xa7\xe5\x21\xba\x24\x67\x31\x4d\xa3\xaa\x0a\x33\x9f\xf3\x6d\x33\xa1\x89\x86\x38\xcb\x90\x76\x45\x75\x62\x09\xd5\xef\x4c\xa1\x0f\x56\x55\xb1\xef\xaa\x17\xe5\xd0\xbd\xfb\xce\x2c\x0d\xb5\xed\x1f\xe7\xf4\x3f\xf8\x77\x4e\x21\x83\xc9\x04\xc8\x8c\xfc\x6f\xe5\x90\xd9\xf8\xde\xe3\x6d\xff\xc3\xf8\x0a\x49\x8c\xdf\x0e\x04\x83\x40\xd2\x49\xa2\x7f\x6f\x0e\x59\xe0\xdf\xc0\xae\xae\x1b\xd3\x3a\x39\x77\xb0\xfb\x55\x9c\xbb\xcf\xb7\x9c\x68\xe7\xd6\x5c\xbb\xa6\x4b\xd5\x74\xf8\xe9\x3c\xb2\xa0\x7a\x0b\xbf\x5c\xb9\x50\xce\xfd\x9f\xf4\x7d\xd4\xb9\x9c\x9b\xde\x29\x73\x6e\xda\xb3\x7e\xce\x59\x9b\x73\x37\xf8\x04\xbb\x7e\xc6\xbd\xc3\x3f\x9c\x8c\x21\xfd\xab\xd8\xd7\xd5\xb0\x62\x7a\xac\xfe\xf3\xe6\x3a\x39\x77\x4d\x46\xf0\x17\x39\x37\xab\x4d\x66\x8f\xfa\x67\x92\x91\xce\x73\x96\xce\x7e\xb3\x8a\x96\xc0\x44\xf3\xbf\xe8\x0d\x49\x92\xbf\xf2\xdf\x47\xda\xc3\x32\x86\xde\xe1\x5f\x5b\x45\xae\xa3\x6d\x1a\xc8\xbb\x9d\xaf\x9a\xc2\x02\x21\x8c\x50\xaa\x72\x5d\x6d\x20\x06\xa8\x10\x26\xb1\xf7\xf0\x13\x26\x90\xfd\x55\xf9\x0f\xf3\xd7\xcf\x2c\xad\xf7\xbc\x35\x64\x1d\x23\x43\x5a\x93\xb1\x9c\x3f\xcf\x9e\xcb\xb7\xe5\x33\x57\x85\xc0\x8d\xb0\xf9\x6c\x3c\x59\x98\x77\x98\xdf\x54\x67\x8d\x18\x9a\xab\x34\x90\x65\x9d\xaf\xd5\x75\x4e\x6d\x04\xb9\xac\x8a\x8d\x3f\xfb\x2c\xa8\xfd\x9d\x6d\x5f\xd3\xc0\xb3\x8c\xff\x32\x7f\x0b\x79\x4c\xdc\x96\xcc\x91\x19\x16\xe8\xf6\x9f\xa1\x4b\x69\x8f\x06\xdf\xcb\xfa\x47\xf9\x1b\x68\x1f\x40\x86\x40\x36\x0b\xd9\x3b\x68\xdf\x41\x5c\xec\xf6\x3a\xef\xb7\xfd\x27\x39\x96\x9c\x0f\xfc\x89\xfe\xfc\xe9\x64\x3e\x09\xaf\x22\xf3\x0a\xfd\x4f\xf3\xd3\xf8\xbe\xdd\x3f\xc8\xb1\xaa\x1c\x4d\x7d\xa5\x9e\x1f\x82\xcf\x41\xeb\xbe\x17\x29\x73\x2c\xa6\xd6\x7f\x2f\x32\x24\xbf\x3a\xec\x2f\xbe\x82\xac\x76\xf2\xab\x3f\xb5\x78\x31\xb6\xde\x7b\xa5\x21\xf3\x9d\xfc\x4c\x44\xad\xaa\x06\xde\x29\xed\x72\x8e\x36\x4e\xfb\x6f\x5c\x42\x5e\x74\x68\xe3\xc6\x33\x7f\x2e\x8e\x13\x63\xfd\x1f\x93\x94\xfa\xef\xef\xfe\x37\xba\x43\x28\xe9\x3b\xff\x33\x4b\xa5\x6e\x3a\x94\xfc\xfc\xe7\xa7\xa0\xbc\x7a\x1b\x0d\x3e\xb3\x6d\xf9\x4f\x74\x87\x32\xe9\x5a\xff\x63\x4b\xc8\x17\xa0\xfb\x27\xd6\xe4\xac\x91\x20\x46\x9d\xdd\x21\xbf\x96\x52\xe7\x3d\xf4\xe0\xf3\x6a\x79\x3f\x69\xce\x03\x0c\xbc\x9b\xac\x0b\x71\xe8\xeb\xfe\x97\x2e\x27\x9f\xe2\xb3\xe0\xde\xe2\xd2\x73\xef\xd5\x9e\x7b\xcf\x57\x72\x5e\x30\x9f\xa2\x2a\xab\xd3\x5b\xf5\xdf\xfb\xbb\x82\xbc\x27\x35\xc9\xce\x0a\x7d\xef\x02\x74\xd4\xe4\x52\x54\xe7\x0d\xe9\xa8\xcd\xa3\xb6\xfa\xc7\x2e\x25\xaf\x3b\xbc\xf9\xc1\x57\x67\x9b\x25\x73\x46\x06\x29\x0d\x7c\x26\x42\xd4\x7c\x26\xc2\xa8\x1d\x84\x17\xcc\xa1\x4e\xf8\xbd\x0b\xc9\x2b\x64\x2c\xe4\x50\x67\xdb\x9a\x3c\xb5\x26\x87\xea\xd2\xd0\x7b\xbd\x92\xe3\x42\xd5\x9e\xff\xa4\xa2\x4e\xa6\x7e\xd3\x62\xf2\x0e\x64\xea\x74\x2e\x64\xea\x97\x9b\x7c\xb0\xff\x45\x3a\xe1\x9f\xeb\x0e\xed\xf1\xaf\xfd\x0f\x2c\x21\x5f\x13\xab\xea\x23\x3a\xfb\xec\x17\x2e\x3e\xb0\xfa\x0a\x67\xa1\x5a\xef\xf3\x32\x21\xb9\x13\x30\x27\x0b\xd1\x7c\xc1\x3e\x7f\xe3\x32\xb2\xd6\xe9\xf3\x4e\x67\x77\x9a\x7c\xd2\xd9\x9d\x3c\xa6\x36\x1e\x75\x3e\xd3\x53\xc3\x9d\x44\xab\x51\x7b\xc1\x9c\xe9\xf5\xc5\x64\x2d\xac\x56\xce\x56\x99\xfc\xfd\x5b\x94\x3a\x9f\x33\xfa\xcf\xc6\x8f\xb3\xbe\xbf\x75\x3e\x3d\x50\xc5\xf3\xff\xbc\x37\x53\xf4\x6f\xe8\xf3\x4f\x35\xef\xc5\x9f\x0b\xe0\x79\xcf\xa5\x6a\xdd\xfc\xc3\x5f\x34\x8f\x3c\x4c\x66\x55\xb1\x97\x4e\x57\x67\x65\xd1\x4f\x49\x0e\x89\x6c\xe0\x73\x5a\x7f\x3f\x8e\x42\x72\xa5\x3f\xfc\xf7\x57\x90\x2a\x32\x11\x72\xa5\x6a\xef\x60\xba\x03\x73\x25\xd7\xff\x3e\x8e\x36\xfb\x1f\x9a\x03\x79\xf2\xf0\x2a\x12\x4b\xe2\xaa\x5f\x1a\x46\x7f\xf4\xbf\xc8\x1e\xa9\xf3\x59\xb8\xd0\xbe\xae\xf7\x50\xe2\xaf\xfa\x3a\xa8\x96\x76\xa8\xfe\x7e\x24\xfd\xb1\xfa\x2b\xbe\xb0\xe1\xcf\x6f\xfd\x47\x7d\x1d\x9c\xd6\x5f\x2f\x27\x6f\x49\x85\x83\xe9\x5e\x39\xd6\xb3\xfe\x8b\xfb\xbc\x36\x3f\xde\xed\x1f\x33\x99\xdc\x4a\x26\x55\xc1\xe2\xf3\x7e\xff\xec\x3c\xb2\x48\xfa\x5b\xff\xb3\x8e\x7f\xdf\xe7\x52\xa3\xe4\xf0\xef\xfc\x23\xc6\x92\x15\xce\xc8\x2e\xf4\x27\xf8\x0b\xe6\x90\x6b\xe8\xbf\x8f\x34\xf0\x59\xcc\xff\xd0\x57\x67\x48\x5e\x3e\x83\xee\xa9\xa2\x65\xd5\xf7\x4d\xa7\x1b\xe8\x50\xe5\xfc\xcf\x8a\xfe\x57\xe3\x67\x83\xff\x8d\x59\x64\x2e\x29\x82\x7c\xc8\xff\xb2\x87\x94\xcb\xa4\x30\xf4\x33\xad\xff\xac\x8f\x3f\x98\x2a\xbd\x06\xfa\xdf\xea\x21\xd7\xf8\x37\xf0\xf5\x4a\x83\x9f\xc9\xfc\x6f\xfa\x78\x32\x79\xb4\x8a\x74\xf7\x6f\xcf\x25\xcb\xd8\x03\x4a\xbd\xcf\xf0\x9e\x7b\xcf\x51\x17\x50\x4b\x58\x67\x9d\x97\x59\x91\x9a\x2c\x18\x16\x18\xb7\x91\x48\x72\x45\x15\x7b\xfb\x6c\x66\x15\x24\x14\x17\xf8\x8c\xb1\x7c\x32\x1a\xa2\xad\xa1\x2c\xd5\x55\xab\xb0\x89\xf3\x26\x44\xd7\xb3\xdf\x56\xf1\x1e\x5f\x28\x17\xfc\xdc\xf2\x7f\xa2\x33\x18\xc4\x3d\xfe\x5b\x48\x1b\x52\x5e\x45\x33\xab\xdf\xae\xa2\xbf\x39\x9b\x2b\xfc\xcf\x3a\x9d\x6c\xda\x22\x53\xab\xc8\xc5\xfe\xaf\xaa\xc8\x54\x08\xa3\x42\xfc\x43\x79\x11\xd9\x0a\xd3\x5b\x23\xa5\xe9\xab\xb0\xfc\x8b\x30\x84\xec\xe1\x8d\xb8\xe3\x4b\xb7\x4e\x5a\xf0\x2f\xb9\x83\x46\xa6\x24\xb5\x7b\x2b\xd3\x05\x7f\x49\x49\x1a\xbb\x4a\xe3\x45\x25\xf0\xdf\x73\x5d\xba\x38\xdf\xa5\xc0\xef\x8e\x35\x55\x0d\x2a\x3f\xd7\xbe\x4e\x3c\x44\x87\xc9\xcf\xb5\x1b\x4a\xe4\xcb\x2a\x21\x86\xe2\x58\xe8\xec\x3b\xe4\x7c\x90\xbd\x9b\xa3\xd2\xea\xe7\x7c\x70\xfd\x6d\x9a\xbe\x8a\x3f\x29\x1e\x2a\x2e\xfe\x28\xec\x85\x16\xe7\xb7\xd5\xe5\xa0\x0e\x69\xcb\x9c\x2f\x0c\x24\xcb\xb6\x07\x9f\xe4\x3f\xa7\x53\xa7\x2d\xb9\xb2\xc5\x0b\x61\xd0\xf6\x75\x71\x2b\x9d\x0e\x6d\x5b\x28\x6d\x94\x4e\x03\xa3\x5b\x37\x0b\x67\x03\x8d\xa8\xc1\x8c\x5d\x34\xd0\x88\x18\x7c\x91\xae\x34\x96\x1f\xaa\xef\xe9\xec\x41\x6b\x39\x0a\xe5\x6f\x39\xd0\xda\x4d\x5b\x9d\xcf\xd7\x6b\x44\x22\x0c\x6e\xb6\x78\x6c\xaf\x51\x83\x07\xb4\xed\xd1\xb7\x91\xdd\x6c\xd1\xb8\x5e\xa3\x06\x0d\x6c\x3b\xa1\x35\x59\x10\x04\xbd\x6b\xd4\xcc\x98\xb6\x31\xdd\x3b\x8c\x9a\x01\xc5\x50\x72\xa3\x83\xcf\x42\xf0\x3b\x2a\xf1\x4a\x8f\x81\x2d\x7a\xc5\x3a\xc0\xb1\x8d\xbb\xb6\xaa\x35\x05\x8d\x08\x9a\x60\x36\xd9\xd0\xd3\xbc\x90\x1d\x17\xf8\xbe\xc2\x85\x2c\x53\x6a\xbe\xa2\x40\xfa\xd7\xd4\xea\x9b\x69\xd6\xff\x1a\x87\xf3\x7b\x13\x62\x16\xbd\x52\xfd\x42\x7e\x7f\xa2\xe9\xab\x86\xd1\x58\xa1\xce\x0e\x18\x66\x42\x93\x0d\xa9\x09\xce\xd6\x57\xd1\x96\x46\x42\xbf\xc0\xf1\x92\x7a\x62\x9b\xe6\xf7\xa5\x58\x9d\x3b\xdb\x56\x97\xce\x96\x98\xd5\x81\x34\xe9\xe2\x3f\x41\x5a\x74\xb6\x9c\x63\xf2\x73\xec\xa0\x42\x5c\x47\xfb\x6b\x11\x70\x8f\x36\x53\x3a\x0c\x6c\x1a\xd1\x74\xa0\xd1\x68\x70\x53\x95\xea\x4e\xa9\xeb\x44\x55\x82\x7b\x01\x07\x23\x10\x5d\xf3\x4d\x90\xd0\x3d\xa9\xfa\x6f\x3a\x9d\x22\x76\xae\x59\x21\xc8\x15\x35\x60\x6a\x61\xf0\xbb\x1f\xc3\x42\xb0\x58\x60\xad\xb8\x9f\x0e\x85\xb8\x87\xcb\xef\xda\xc4\x0c\x8c\x88\x66\x2c\xc6\x70\x80\x8c\x46\x11\xce\x17\x41\x7a\x9a\x66\xfd\xef\xa1\x10\x67\x30\x85\xbc\x3e\x52\x13\x19\xff\xd7\xce\xe0\x8a\xac\x79\xa9\xae\xc7\x60\xf9\x5f\x80\x81\xd6\xb3\x36\x72\x98\x53\xd2\x48\xb9\xff\x5a\xda\xc0\x8e\x0a\x8b\xd0\x1a\x69\x4c\xf0\x26\x51\x8d\x85\x2a\x46\x4f\x8a\x50\x55\x16\x16\xa6\x8f\x9a\x14\x56\xff\x1b\x44\x4a\xed\xce\x70\x35\xdb\xdf\xe1\x97\x89\x6a\x36\x3c\xb6\xb4\x4e\xc1\x2f\x15\x8d\xb8\xa1\xf1\x0d\xfd\x9d\x2f\x16\x0d\x7d\xb8\xf1\xc3\x59\x31\x71\xe4\xd5\x71\x64\x6a\x4c\x9c\x7f\xfa\x38\xe7\xbe\xeb\x1f\x38\xcc\xc7\xab\x6f\x34\xed\xca\x72\x9c\x7d\x29\xe8\x0d\xca\x86\xc0\x9e\x28\x4d\x7b\x44\xd9\x4f\x7a\x28\xd1\x2f\xd3\xd1\x71\x24\xce\xd9\x05\x26\xfc\xa2\xc1\x71\x4a\x54\xcf\xb9\xb8\x3f\xc0\x85\xda\x3d\xaa\xfc\xfa\x8f\xda\xad\x54\x5e\xfe\x47\xed\x56\x29\x1f\xff\x7d\x3b\x2d\xb6\xb6\xdd\x0a\x65\x7d\xe0\x9b\x26\x8e\x7f\x27\xc9\xad\xe7\x9f\x07\xfb\xcf\x90\x5b\x9b\x68\xc1\xeb\x1a\x38\xbf\x12\xf0\xfe\xea\xfc\x2a\x65\x73\x9d\xf3\x83\x02\x47\xe8\x26\x69\xf7\x1c\x38\xdf\x95\xde\xf0\xf4\x37\x4e\x74\x03\x9f\x4a\xab\xc9\xe8\xe6\xa4\x39\x5a\xdd\x3c\x68\x75\xb0\x0d\x8b\x38\xaf\xcd\xa3\x81\xad\x7f\xdd\x86\x7e\x7e\x5e\x9b\x95\x81\xe5\x7f\x83\xd3\xe8\xbc\x36\xab\x02\xcf\xfd\x45\x9b\x85\x80\xf3\xbd\xf4\x37\xd8\x66\xc5\x93\xdb\x9d\x68\x06\xbe\x25\xb7\x2a\x78\x9e\x35\x3d\xef\xfc\xa3\xa1\xe7\xe9\x0f\xe7\x9d\x5f\x19\x78\x29\xa4\x7d\xb3\xda\xf3\x10\x4f\xe7\x8c\xf3\xad\xcd\x27\xb7\xcb\xf3\x53\xe0\xfc\x52\x69\xf3\xfc\xa0\xcd\x93\x65\x3c\x95\xb9\x68\x73\x6b\xd2\x1a\x6d\x6e\x5d\x6b\xb3\xd3\xe6\xdd\xf3\xda\xac\x52\xa6\xfd\x4d\x9b\xf3\x71\x56\x2a\x23\xff\xa6\xcd\xaa\x06\x70\xfe\xae\xcd\x4d\xd2\xdf\x60\x9b\x15\x13\x65\x3c\x95\x2a\x8c\x87\x73\xfe\xd3\xf3\xce\x3f\xaa\xdc\x1e\x72\xfe\xfc\xf6\x2b\x95\x99\x21\xe7\x3f\x3a\xef\xfc\x2a\xc5\x8b\xe7\x67\x43\x7f\x9c\xd0\x3a\xd4\xf4\x87\x32\xfb\x81\x97\x9c\xbb\x2b\xb0\x49\x59\x1f\xa5\x29\x19\x81\x4d\xe4\x76\xa5\xcd\xc0\x30\x16\x37\xd0\x08\x1b\x1c\x47\xc9\x45\xd2\x83\x46\x83\x2f\x02\x0f\x5c\x2e\xf8\xfb\x5b\x1d\xf3\x94\x98\xff\x54\x87\xba\x2e\x54\x47\x94\x16\xa6\x92\x42\xe5\x34\xac\x42\x9a\x71\xb6\x2a\x8e\xdc\x12\x47\x06\xc0\x5d\xee\xf0\x61\x03\x5a\x9c\x0d\x4c\x5c\xe7\x7c\x3a\x4f\x97\xf8\x47\xba\x9c\xf8\x3d\x2a\x7d\x9b\x1f\xd4\x35\x42\xfa\xa6\x5c\x1e\x8c\x8f\x72\x25\xfa\x96\xe4\xf8\x96\x44\x49\x3b\xd4\xd4\x2e\xc4\xb7\xbf\xd6\x31\x0f\x66\x94\xff\x4c\xc7\xbd\xd2\xa7\x5a\x1d\x4e\x7c\x68\x64\xad\x4f\xa9\xe4\x96\x54\x32\x20\x95\xa4\x3a\x3e\xa5\x9e\xaf\xa5\xae\x4f\xe7\xeb\x12\xff\x48\x57\x19\x90\x67\xac\xd6\xb5\x69\x57\xe7\xc9\x9f\xf4\x66\x32\xb9\xc7\xd9\xaf\xa7\xb7\x4e\x62\x75\xa2\x07\xb7\x94\x21\x81\x83\xfe\x4c\x91\x2b\x06\x29\x5d\x95\x9c\x81\x2d\x21\x67\x0f\x6b\xd3\xb4\x69\xcb\xb0\x46\x8d\xba\x74\x6c\xd9\xb1\x79\xf7\xe6\xdd\xda\x34\x6e\xdf\xd8\xd9\x79\x37\x66\x52\x7b\xde\xea\xa2\x19\x93\x5a\xb1\xa6\x2d\x9b\xb7\x9c\x31\xa9\x79\x53\x45\x9f\x39\x89\x31\x48\xc7\x06\x98\x09\x75\x37\x15\xae\xf3\xcb\x06\xd6\xb9\x5d\x2b\x9c\x1d\x86\x9d\xef\x6b\x3a\xbb\x4e\x24\x3b\x9b\x5b\x43\x2a\x74\x6e\xa3\x54\x2d\xa9\x73\xf0\xd7\x4e\x18\x65\xcd\xaf\xcd\xbb\x38\x4d\x34\x1a\xd7\xe3\xc6\x0e\xeb\xf5\xad\x6f\x9c\x7e\xf5\x49\xa3\xfa\x80\xf1\xe2\x97\x4f\x19\x64\x4e\x8b\x25\xa4\x5d\xfe\x23\xf7\x34\x7a\x6a\xb4\x3f\x33\xfe\xe0\x0d\x2d\xdb\xbd\xcb\xa7\x77\xef\xf5\x61\xe5\x9f\xa7\x6a\xb6\x51\xbd\x71\xe0\x84\x25\x55\xf6\xc8\xb3\x43\xfc\xfd\x1c\x2e\x0f\x1c\xf3\xbb\xc5\x2b\x90\x0b\x77\x50\xbc\x03\xad\x70\x5d\x6f\xda\xb6\x59\xb3\x98\xa6\xed\xdb\xd3\x18\xc8\x65\x3a\xb5\xec\xd8\xb4\x5d\xbb\x96\x6d\xda\xd3\x56\x6d\x5a\xcd\x98\xd4\x21\xba\x0d\x6b\x16\xd3\x32\x66\xc6\xa4\x96\x4d\xd5\xc8\x99\x93\x0c\x43\x6d\x23\x7f\xc4\xe1\xdc\x9e\xa6\xc1\xdf\x8d\x0f\x7e\x9a\x42\xee\x0b\x76\xee\x87\xc4\xd0\xcb\xc6\x84\xc9\x1d\xc8\xd1\xd7\xa4\x01\x84\x9c\xf3\xd3\x11\xe2\x95\xb0\x17\x0e\xc4\xee\x79\x62\xe9\xb0\x9e\xe9\x6a\x64\xfa\xc5\xf9\xcb\xa3\x9b\xfb\x3b\xaf\x7f\x21\xcc\x9f\x12\xb6\xea\xcb\xa7\xc2\xc8\xd5\xe4\x96\x47\x5f\x08\x13\xfd\x5d\xad\xce\x7c\xff\xc6\xa6\x76\x27\x6e\x68\xd9\xea\xda\xb9\x0b\xf9\xb3\x7f\xae\xa8\x71\xf2\x6c\x34\x03\x19\xfc\x5e\x61\xe0\x88\xc8\x81\x3e\xec\xa6\xcc\x1a\xd8\x2d\xb6\x6d\x13\x55\x0d\xef\xa2\x28\x17\x35\x6f\x1e\xde\x96\x75\xef\xa1\x86\x1b\xe1\x33\xc0\x8f\xd6\x91\xad\x3b\xce\x98\xd4\xae\x5d\xeb\xe8\x26\x2c\x9a\x39\x7d\x6a\x4c\x8a\xe6\x91\x11\x33\x26\x45\xb2\x3a\x7b\xb6\x26\xd4\x6e\xb1\x5f\x9b\xc5\x58\x21\xfb\x8c\xc8\x5d\x00\xea\x76\x5b\x6c\x94\xd3\x6b\x4a\x07\xc7\x63\x4d\x6e\x5e\x16\x9d\xc4\x1f\xf4\xfa\xde\x38\x3d\x2c\xd8\x71\x79\xb5\x1d\x47\x52\x1a\x0d\xb6\xfc\x8f\xfb\x37\xaf\x7a\xbd\x47\x26\x9f\xbc\xf2\xdb\x9f\xe3\x06\xe9\x3c\x72\xa6\xa7\xd2\x3f\xd6\x71\x8d\xa6\xc9\xfe\xf3\x9f\x49\x1a\xee\xcf\x87\x25\xd8\x7e\xeb\xec\x35\x93\x0f\x57\x93\xdb\xbb\xcb\xdc\xd3\x7f\x48\x71\x93\x1e\xec\x2a\xf9\x9b\x66\xd1\x2f\x46\xaa\x6f\x91\x34\xa5\x39\x04\x21\x03\x86\xe1\x00\x30\xaf\x5b\xc7\x28\xbb\xa9\xdc\xa2\x80\xaa\xd1\x30\xc0\xd4\xe0\x8e\xd6\x49\x4d\x2f\xf9\x66\xe2\xbd\x65\x3b\x27\x2f\x2f\x98\xde\x7f\x6c\x5a\xcf\x84\x8c\x71\x97\xb8\x89\x72\x17\x69\x7b\xe3\x99\x5b\xfd\x3b\x6e\xa1\x53\x1f\x5e\xe2\xff\xba\x72\xd0\xc4\xeb\x88\x7c\x8e\x1a\x68\xad\x4c\x50\xfc\xec\x0a\x25\x4c\x89\x59\xad\x31\xe3\x75\x92\xf6\x92\x22\x04\x84\x2d\x1d\x46\x83\xdc\xa4\x39\xb1\x77\x72\x30\x08\x5a\x72\x17\x6b\xf2\xe3\x86\xbf\xab\xfe\x64\xc9\xb3\xb0\xaa\x19\x7c\x57\x64\x62\x62\x24\x9d\xdb\x27\xe1\x5a\x99\x4b\x06\x34\x65\x02\xc9\x66\xd7\x80\xc5\xad\x5f\x6a\xd4\xc8\x68\xe2\x28\xa3\x2d\x5b\x92\x5a\x65\x90\x2d\x83\xb6\x0e\xc9\xce\x36\x18\x5d\xe5\x5e\xe4\xc9\xf8\x05\xee\xc6\xa4\xc3\x69\x7f\x64\xe3\xcd\x77\x0f\x4d\x49\xbe\xa4\x4f\xd7\xe4\xf6\x73\x2f\xad\x58\x72\xfd\xf2\xe7\xc9\x55\x13\x66\xde\x7b\xe7\x1d\x63\x6c\x77\x87\x59\xcf\xb5\xce\xcb\xf6\xbc\x51\x2c\xdf\xf3\xf0\x07\x94\x21\x64\x02\x60\x75\x53\x3a\xbc\xd6\x31\x32\xb2\x71\xe3\x98\xe6\x6d\x00\x6f\xb5\xce\x94\xd7\x65\x90\x20\x4a\x56\x6a\x70\x9b\xc0\x6e\xe7\x46\xa8\xcb\x4e\x20\x03\x88\xb3\x7d\x52\x1d\x78\xcd\xd9\x3f\x49\xed\x56\x3a\xbb\x55\xb2\xd6\x6c\x48\x97\xfc\xfc\x1b\xc6\x47\x64\x0f\xce\x5e\x94\x96\x04\xa6\xcc\x9e\x50\x7e\x7d\xd9\xdc\x19\xb3\xde\x18\xd2\xfa\xcd\xd2\x46\xcd\xa6\xe7\x2e\x0e\x57\xd3\x38\x9b\x30\xb5\xa8\x6d\xde\x73\xad\xa7\x8f\x9e\x3c\x37\x2a\x3c\x3b\x6b\xfe\x1d\xb2\xdf\x1e\x51\xc6\x93\xee\x6c\x31\xc4\x33\x12\xd6\x0c\x61\xce\x6e\xbc\xa2\x51\x23\x1a\xa1\xbe\x49\x06\x2a\xd4\x09\xc4\x00\xf9\xfe\x4e\x70\x81\x9b\xec\x6c\x80\x92\x0c\xeb\x7a\x4b\x63\x9d\x48\x87\xfb\xdb\xdc\xdc\xc6\x7f\x47\x53\x72\x6c\xce\xcc\x85\xd1\x2f\x52\xff\x53\xa4\xe5\x89\x87\x1e\xf2\xd0\xae\xd5\x3f\xe4\x93\x3d\xfe\x6b\xc0\xef\x8d\x30\x2e\xba\xb2\x45\x4a\x2b\xa5\xed\x2b\x51\x8a\xa2\x5e\xd4\xfc\x75\x32\x70\x75\x23\x43\x95\x5e\x5b\x56\x50\x3b\xac\xc7\xf0\x7b\xf1\x8e\xe7\x30\x2e\xe4\x1c\xe4\xec\xfc\x0e\xe3\xb8\xd9\xb5\x57\x3c\xff\x94\x6f\xd6\x45\xc9\x7a\xc2\xd8\x77\xaf\xcb\x4c\x48\x1f\x4c\x5e\x6d\xe6\xbf\xbb\x7b\x57\x9a\x58\x34\xf3\xfa\x7b\xda\xbe\x5a\xd9\xea\xeb\x1b\x1b\x91\xfb\x4a\x77\xeb\xc1\xb1\x78\x44\xc9\x22\xbd\xd9\x32\xf9\xeb\x7a\xed\x5f\x8b\xea\xd0\x21\x3a\x3a\x32\x5c\x73\x46\x64\x9b\xda\x11\x69\x39\x4f\x54\xe4\xb8\xc4\x5d\xa9\x6a\x36\xd3\xd4\x30\xc4\x0c\x7f\x4b\x0b\xec\x50\x5b\x57\x5e\x9d\xff\x6a\xf1\x98\x82\x98\x64\xad\x67\xbf\x11\x0b\x3b\x4f\x9c\x38\x7b\xf6\x43\xa7\xfa\xb8\xb2\x46\xe5\xba\xc7\x18\x59\x77\x54\xdd\x7b\xe6\xc6\x2e\x77\x4f\x6e\x73\xcf\x3d\xbd\xbd\x13\x6f\x5c\x49\x34\x8f\xf7\x8a\xb2\x79\xed\xfb\xc2\x18\x8b\x55\xc6\x91\x22\xb6\x10\xd6\x64\x2d\xdf\x50\x54\x92\xfe\x32\x87\x85\x18\x85\x18\xe0\xa6\xe2\xe0\xb9\xb3\xa7\x0c\x81\x68\x3e\x95\xd2\x9d\x76\x0e\xf7\xc7\x7a\xc8\x97\xfe\xdb\xe8\x1d\xfb\xd3\xab\xdb\xd2\x57\x80\x2e\xfc\x3b\x20\x86\x7d\xe1\xde\x8a\x56\xda\x02\x1f\x74\x1c\x68\xb0\x88\x56\x11\xed\xda\xe9\x9d\x9a\x3a\x3e\x35\x53\x74\x19\x4a\x19\xc9\xd4\xe0\x5c\x10\x1c\x21\x4d\x3a\x74\x74\xd9\xc9\xf8\x5b\x50\xf2\xb7\x37\xc0\xc1\xe6\xcd\xa2\x83\x6e\x35\x6f\x46\xfa\x4e\x18\x96\x3c\xc0\xff\xde\x89\xf7\x2f\x4e\xbe\xf9\xae\x5d\xfe\xc7\xa7\x8c\x1d\x70\xc9\xaa\x77\x87\x5e\x5a\x70\x37\xdd\x3d\x61\x51\xf3\xa6\xe3\xfa\xfb\x8f\xbc\xfd\x91\x2b\x6a\x50\x72\xc5\xd5\xd5\x6a\x7e\x49\xdf\x4b\x36\x2d\x25\xf7\x4c\x9b\x92\xff\x7a\xbe\x13\xe7\xdd\x10\xe7\x2e\xf5\xe2\x1c\x06\x71\xce\x90\x71\x4e\xab\x13\xe7\x68\x13\x37\xf2\xc2\x0e\x4e\x4a\xc6\x75\x60\x34\x6e\x5a\xe4\xfc\xc0\x59\xaf\xd0\x38\x8f\x5c\xd4\xb1\x6e\x9c\xd9\xb2\xda\x40\x3f\x70\x9b\x0c\xb4\xff\x74\x4d\xa0\xe5\xfd\xbc\x4e\xe5\x74\xbf\x1a\xfc\xfd\x63\x45\x10\x4e\xe5\x57\xe7\x48\xed\x9b\x92\x74\xff\xd9\x5d\xac\xa3\xca\x47\x03\x0f\x0f\x27\x77\xd3\x99\x34\xa1\xa9\x2a\xf7\xb0\x22\x81\x3d\x7c\x06\xe9\x26\xae\x86\x18\x87\xad\x66\x7a\x13\x67\x73\x01\x67\x5f\x9a\x9a\x9d\x55\x82\xf7\x7c\xa7\x01\x24\xe9\x9e\x8e\xad\x07\x58\xea\xe0\xf1\x97\x66\xe7\xe4\x34\x49\xd7\xbb\x4d\x12\xd1\x2d\x5a\x36\xbe\xa4\x79\x72\xef\x7e\x43\xf4\xc4\xe9\x5a\x63\xb9\x8e\x0a\xbc\xad\x28\x7c\x9c\x80\xd5\x37\x1b\x24\x9f\xcf\x84\xf1\x19\x74\x92\xf8\x0c\xd6\xfc\x91\xce\xce\x14\xba\xce\x88\x1a\x71\x6e\x67\x8a\xe0\x13\x10\x01\x33\x96\x33\x0e\x05\x59\xed\x3c\xf3\x20\xd5\x7b\x55\x12\xb5\xfc\x55\xd5\xfe\xd6\x7f\x58\x7c\xd6\xe2\x85\xb0\x17\x3a\x54\x57\x77\x78\xec\x31\x88\xfd\x72\xb0\xd7\x57\xab\x4f\x0b\x0f\xa7\xc2\x50\x43\x76\xba\x90\xcf\x7b\xc0\xa3\x4e\x52\xe5\x3c\xe2\x3c\xf3\x21\xbf\x81\x9e\xfe\x2a\x69\xb2\xfc\x35\x55\x34\x0e\x7b\xa1\x85\xff\xce\xc7\x1e\x73\x34\xa2\x7d\x2d\xc4\x06\xa5\x29\xac\xe6\x9b\xbd\xd6\xaa\x79\xf3\x26\x06\x8d\x8e\x91\x0a\xd1\xc2\x3a\x51\x90\xf7\x05\xa9\x35\xb7\x5d\x5a\xea\x80\x01\x23\x07\x87\x9b\x6a\xbb\x01\x17\x77\x37\xab\x0f\x86\xd8\xfd\x56\x54\x7c\xd7\x38\x17\x6f\x9f\x29\xc2\x7b\x75\x8c\xf4\x6f\x47\x17\x00\xb3\x13\x4f\x23\xcf\x8b\x5f\x9d\xe7\xc6\x4a\xeb\x81\xe1\x31\x4d\x0d\x8d\xd2\x36\x91\xcd\x14\xb5\x16\xf7\x03\x67\x1b\x6e\x36\x80\x48\x1c\xad\x8b\x7c\x4c\x03\x16\x9c\xdb\x8d\x41\xdd\x29\x76\xbd\x7f\xaf\xb0\x3e\x3f\x4d\x96\xf4\xcc\xe8\x93\xd4\x2e\xab\x65\xa3\x84\x84\x87\x2f\xce\xec\x9b\xdc\xb6\x7b\x62\x93\x84\x78\x9e\xe6\x3c\xbc\x58\xbc\xf8\x58\xfb\xae\xed\x93\xdb\x3b\x3b\x32\x74\x4e\x5c\x25\xe7\x89\xc0\x30\x3e\x8c\xdc\x20\x63\xd8\x4c\x69\x3f\xb0\x71\x54\x18\x87\x7f\x91\x91\xc4\x79\x8a\xe1\x3c\x2c\xd9\xd0\xd3\xc9\x21\x9c\xcf\x20\x38\xdb\xb5\x39\x1d\xd4\x12\x86\x6c\xb2\x55\xb3\x41\x1a\x79\xe4\x49\x7e\x24\x9d\xf6\x9c\x7f\x05\x1b\x2a\xf2\xc6\x8f\xbd\xac\xd5\xd0\x16\x2f\xc8\x7e\x5a\x57\xe8\xe9\xd1\x67\xc0\x25\x7d\x4b\xaf\x6a\x10\x87\xc2\xbf\xc8\x48\xe1\xe0\x88\xfa\x38\xb2\xe3\x58\x5d\x9c\x17\x69\xfa\x4a\xfe\x44\xd7\xba\x38\xb2\x03\x97\x9d\x03\xaa\xc1\xd9\xe0\xcc\xe4\x0e\x4e\x38\x8f\x81\x7f\xed\xa3\x1c\x98\x28\xe7\xe7\x5c\xcd\x0d\x3d\xcd\x5a\x9c\xba\x08\xec\xfc\xde\xcd\x90\x70\xf9\xe3\xc6\x2f\x8e\x01\xb8\x97\xfa\x27\xf6\x4b\xc9\xca\xd0\xe3\xb5\xd6\x49\x9d\xdb\x5b\x7c\x98\x04\x1e\x98\x5a\x7a\x15\x29\x8d\x8a\x6b\x73\x71\x82\xd3\xc1\x61\xed\xda\x35\x76\x7e\x63\x86\x0f\x27\xcf\x41\xbf\x36\x87\x79\xa1\xd3\xc0\xa8\x0e\xad\x5a\x35\x01\xf8\x68\x11\xee\x3c\x8e\x0b\x6f\xd7\x02\x1f\x0f\x49\x56\x91\x9b\x85\x34\xd0\xad\xa2\xae\x7d\x3b\xcf\xf5\xed\x23\x17\x67\xf6\xc1\xbe\xf5\xaf\x99\xbb\x80\x25\x69\x05\xe3\x27\x2c\x6c\x91\xd4\xe2\x41\x61\x86\xf6\xf1\xfe\xc9\xe3\x3a\x25\x58\x76\xbc\xb7\xc8\xc9\xbb\x49\xe8\xfe\x94\x4d\xba\xf2\x63\x8f\x84\xee\x52\x49\x1b\x8f\x26\xa3\x6b\xf7\xc1\xac\x7b\xad\xea\x5c\x7b\xfe\xfe\x98\x72\x6f\xd1\xd6\x2c\xb2\x81\xe3\x07\x69\x02\xfd\xd5\xd9\x13\xd3\xbf\xd4\xd9\x3b\xb1\x69\x57\xfd\x8c\x3c\x7e\x88\x5e\x11\xdc\xaf\xb5\xde\xf1\x5f\x6a\x8f\x3f\x5e\xe7\xf8\xcf\x35\xc7\xeb\xed\xef\xda\xe0\x5e\xa6\x8a\x5a\x7d\xcc\xbf\x94\x98\x81\x5f\xf0\x37\x52\x13\x94\xbe\xca\x00\xe0\xf4\xa8\x7e\x56\x07\x25\x95\x0c\x4c\x7d\x38\x95\xa6\xf6\x8f\x6b\xcc\xba\x05\x37\xc2\x5b\x37\x6d\xae\xe9\xdc\x5d\x22\x64\x53\x9a\xe4\x90\xfa\x85\x36\xae\x09\x3d\xae\x45\x5b\xac\xfa\x58\x7c\x6c\xc7\xf8\xf8\x8e\xb1\xf1\xfb\x6a\x2a\xf7\xc6\xc5\x76\x8a\x8b\xeb\x14\x1b\x47\x27\xc4\x75\x8c\xed\xdd\x3b\xb6\x63\x5c\x97\x9a\x43\x5f\x67\xf8\x32\x67\x3a\xbf\x73\x1a\xbc\x54\x96\xab\x64\xbd\x77\xef\x5f\x3b\xc6\xc5\x39\xc7\x56\xc9\x36\xf1\xf1\xf1\xa4\xc4\x7f\xbb\x73\xaf\xf2\xea\xd3\xfe\x65\xa4\x2d\xf8\x16\xdc\xdb\xa7\xbd\xe3\x17\x53\x94\x36\xd1\xb0\x58\x1e\x18\xf3\x70\x0c\x8d\x69\xdb\x48\x93\x4f\x9a\x1d\xaf\xe4\x84\x25\x20\x79\xf8\x2b\xbb\xfd\x11\xc4\xdd\xd4\xff\x26\xbd\xa6\x41\x13\x5d\xb3\x2f\xb9\x80\x31\xe7\x6c\xd1\x80\x2d\xda\x43\xa4\xbb\x0c\x8c\x56\x9d\xad\x8f\x63\x5b\x2a\x6d\xc9\xc0\xb6\x0f\xb7\xa5\x6d\x3b\x44\x39\x5b\x2a\x5a\x1b\xd0\x1a\xc9\x40\xc9\x72\xf3\x38\xed\x2f\x6d\x1a\xdb\xdc\x17\x0d\x66\xcd\x69\x4a\xde\x6e\xd0\x2c\xff\x91\xca\xd9\xb3\x2b\x5f\xba\x50\x9c\xa8\x12\x05\x6b\xd5\x07\xc4\x3d\x4a\x4f\x65\x20\xd0\xda\x25\xcc\xd9\x6a\x3b\xb8\x93\xa6\xda\x8e\xb6\x6c\xc7\xb4\x48\xe6\x3c\xec\x4e\xbe\x84\x25\xc7\x33\xa6\x06\x6f\xb7\x4b\x48\x3c\xe9\x06\xff\x47\x32\x52\x16\x91\x36\x73\x91\x3b\x33\xb7\x45\xbf\x9e\x79\x97\xe6\x45\xea\xd1\x71\x59\xbd\xec\x61\x3d\x44\xe3\x8b\x26\x2f\x7b\xcc\x33\xe3\xa6\x71\x2d\x5a\xb4\x98\x7a\xd9\x5d\x97\x76\x4e\xee\x14\xf6\x68\x13\x76\xf1\xa8\x7e\xc5\xf7\x77\x8b\x20\xad\xed\x6e\x6a\x18\x77\x15\x4c\x1d\xca\x1f\xef\x33\xf9\x92\x0e\x7d\xdb\x77\x49\x18\x9d\xd9\x25\x23\x73\x48\x4f\x57\x81\xef\xb2\x21\x25\x2b\x17\x0d\x74\x15\x3e\x50\x50\xf8\x50\xf9\xb0\x66\xdd\x86\x0e\xbf\xb4\xba\xc9\xf0\x45\xd9\x09\x2f\xbd\xde\xaf\x60\xea\xd8\xee\x22\x4c\x44\xa5\xcc\xba\xcb\xb1\x7f\x5c\xe0\x80\x38\xcc\x4f\x41\x3f\x5b\x60\xbf\x93\x19\xd5\xfc\x74\xa2\x7c\x4a\x8b\xbf\xda\xea\x6c\xc6\x67\x31\x35\xa4\xee\xfc\x9a\x96\xbc\x92\x5c\x1c\xcd\x57\x46\x9f\x7d\x72\xf4\xda\x51\xe3\x66\x85\x7b\xaf\x32\x48\x5c\xbe\xda\x34\x21\x31\xf1\xa6\x7c\x23\xe7\x89\xbc\x98\x44\xcb\xba\xcd\xab\xcf\x7a\xf2\xde\x79\xba\xff\xa7\x36\x83\xde\x1a\x3f\xbd\x80\x5f\x5f\x5c\x7c\x36\xd5\xb3\x68\x8e\x37\xfa\x52\x3a\x2c\x26\xae\xfa\xcd\x76\x0b\x1b\xc7\x25\x4f\x5e\x96\x44\x07\x56\xbf\x79\x55\xa7\xb8\xe4\x19\x97\xb9\xe8\x40\x67\xbb\xf4\x0f\x66\x2e\xf6\xc9\x38\xe7\x05\x0e\xb2\x9f\xa5\x9d\xed\xd1\xce\xe0\xee\xd0\xa1\xa6\xd4\x18\xad\x92\x88\x68\xfa\x79\x74\xb5\x19\xfc\x59\xa8\x27\x24\x74\xeb\xb1\x2f\x4f\xf4\xe6\x85\xe7\xf9\x74\x12\x93\xd7\x52\x9a\x90\xe2\xfc\x30\x14\x5d\xe0\xe0\xac\x99\x53\x52\x9c\xd7\x78\x04\x1d\x7d\x51\x5c\xf5\x5b\x4b\xe4\x6a\x52\x89\x1e\xae\x10\xe6\x82\x29\xc0\xd0\x2e\x01\xdc\xce\x81\x1d\x0a\x63\x7d\xa5\xcc\x94\x72\x90\x94\x23\x41\x36\x53\x9a\x05\x0a\x60\xf6\x65\x50\xef\xac\x24\x07\x5e\x06\x99\x1a\x58\x01\xb2\x8f\xac\xf7\x0b\xdc\x02\x72\x92\x94\x93\xa5\x9c\xea\x48\xed\x47\x38\xdb\x43\x69\xec\xff\x03\x64\x94\x94\x9d\x41\x26\x48\x3d\x09\xa0\xe7\x6b\x90\xa9\x70\x4d\x82\xd4\x93\x00\x7a\x9c\x23\x53\x03\x6b\x95\x04\xd9\xd6\x92\x57\x5a\x52\x83\x25\x35\x58\x52\x83\x0b\x5a\xed\x00\xd9\x47\xca\x7e\x52\x4e\x05\x99\x2c\xaf\x4f\x56\x1a\x83\xb5\xc9\x4a\x13\x29\xa3\xa4\x6c\x0b\xf6\x24\x2b\xed\x02\x8b\x41\x76\x96\x47\x4c\x79\x65\x66\x20\x13\x64\x96\x94\x83\xa5\x1c\x2e\xaf\x1c\x23\xeb\xe3\x65\x7d\x82\xac\x4f\x94\xf5\xc9\xb2\xed\x54\x90\xa9\x12\x2b\x55\xda\x96\x0a\x58\xb7\x80\x8c\x92\xf5\xb6\x80\x92\x0a\x58\xce\x35\x9d\xa5\x34\xc1\xa3\x54\xc0\x6a\x0b\x72\xb0\x94\xc3\xe5\xf1\x31\xb2\x3e\x5e\xd6\x27\x4a\x39\x15\xb0\xfa\x80\xfd\x8e\x6c\x02\x11\xe8\x03\xf6\x3b\x75\x47\x67\x1f\x69\x7f\x1f\xd0\x39\x17\x64\xa6\x3c\x3e\x58\x4a\xc7\xe6\x3e\xd2\xe6\x3e\xd2\xe6\x3e\xd2\xda\x3e\x52\x5b\x3f\xa9\xad\x9f\x8c\x46\x3f\xa9\xad\x9f\xd4\xd6\x4f\x6a\xeb\x27\xb5\xf5\x93\xda\xfa\x49\x6d\xfd\xa4\x6d\xfd\xa4\xb6\x7e\xca\x58\x29\xc7\x81\x9d\xfd\x40\xa7\x53\x9f\x04\x72\x88\xf6\xa3\xf2\xb6\x32\x1e\x34\xb7\x05\xd9\x04\x7a\x6d\x3c\x68\x76\xea\x59\x60\xf3\x78\x65\x90\x94\x83\xa5\x1c\x2a\xe5\x30\x88\xd5\x78\xd0\xe9\xd4\xc7\x39\x12\x34\x0c\x57\x26\xc9\x9e\x9a\x24\xfb\x68\xb2\xac\x4f\x96\xf5\xa9\x50\xbf\x05\x64\x54\xe0\x16\xd6\xd7\x89\x33\xeb\xcb\x86\x05\x9e\x00\x39\x46\xca\x09\x81\x97\x41\x66\x07\x26\x82\x9c\x28\x8f\x4c\x93\x75\x6f\xe0\x71\x90\x3e\xa7\x15\x5b\x08\xf5\x81\x70\xcd\x73\x2c\x4d\x59\x1e\x78\x95\xa5\xb1\x0c\xa5\x2f\xc8\xcc\x40\x2a\xc8\x41\x81\x72\x90\xc3\xe4\xf1\x91\xf2\xc8\x18\x59\x9f\x18\xb8\x0e\xe4\xf4\x40\x16\xc8\x99\x81\x87\x41\x7a\x02\xcb\x41\xe6\xc8\x23\x79\x81\x4a\x90\x85\xf2\xf8\x1c\x79\xbc\x48\xd6\x4b\x02\x05\x20\xe7\xca\x6b\x2a\xa5\x5c\x20\xe5\x65\x12\x71\x09\xd4\x33\xa5\x17\x99\xd2\x8b\x4c\xe9\x45\xa6\xf4\x22\x53\x7a\x91\x29\xbd\xc8\x94\x5e\x64\x4a\x2f\x32\xa5\x17\x99\xd2\x8b\x4c\xe7\x5e\x60\x59\x30\xd2\xce\x80\x8c\x72\x24\xf8\x32\x01\x64\xa6\x7f\x27\xc8\x41\x52\x8e\x94\x72\x0e\xb4\x1a\x24\xb1\x06\x01\xd6\x37\x20\xc7\x48\x39\x41\xca\x6c\xf0\x7a\x10\xa0\x94\xb3\x61\x10\x87\x27\x40\x0e\x0a\x6c\x04\x39\x52\xd6\x27\x40\xab\x61\x32\x62\xc3\xe0\x9a\xe7\xd8\x08\xd0\x70\x0b\xc8\x31\x52\x4e\x04\xdb\x46\x40\x64\x3e\x04\x99\x23\x65\x9e\x94\x05\x52\xce\x96\xb2\x54\xca\xb9\x52\x56\x4a\xb9\x40\xca\xc5\x52\x2e\x91\x72\x19\xc8\x91\xd2\xc2\x91\x32\x1a\x23\x65\x34\x46\xca\x68\x8c\x94\xd1\x18\x29\xe3\x30\x46\x5a\x38\x46\x5a\x38\x46\x5a\x38\x46\xda\x36\x46\xda\x36\x4e\x46\x63\x9c\x8c\xc6\x38\x88\x83\x23\x07\x05\x86\x83\x1c\x09\xf5\xf1\x6c\x5e\xe0\x4d\x36\x41\xa2\x4c\x70\x46\x3e\xc8\x28\x29\x61\x1e\x00\xd9\xce\x91\x10\xc3\xc9\x20\x33\x9d\xe3\xd0\xf6\x09\x90\xc3\x9c\xeb\x01\xcb\x39\x32\x46\xd6\x27\x4a\x39\x45\x4a\x67\x54\x4c\x60\x33\x02\x0f\x82\xcc\x91\x75\xaf\xbc\x32\x4f\xd6\xf3\xa5\x2c\x94\x9a\xe7\x48\x59\x22\xa5\x4f\x5e\x33\x57\x9e\xad\x94\x72\x81\x94\x0b\xe5\xf1\x45\xf2\x9a\x25\xf2\xc8\x52\xa8\x67\xc3\xc8\xcf\x02\xe9\xd8\x9c\x0d\x36\x3b\xf5\xb6\x81\xcb\x41\xb6\x73\xa4\x1c\xc3\xd9\x72\x0c\x67\xcb\x31\x9c\x2d\x6d\xce\x96\x63\x38\x5b\xda\x9c\x2d\xc7\x70\xb6\xb4\x36\x5b\x8e\xe1\x6c\x39\x86\xb3\xa5\xcd\xd9\x60\xf3\xa3\x20\x9d\x91\x9c\x2d\x47\x72\xb6\x1c\xc9\xd9\x72\x24\x67\xcb\x91\x9c\x2d\xad\xcd\x96\xd6\x66\x4b\x6b\xb3\xe5\x48\xce\x96\x76\x4e\x94\xfd\x32\x11\xfa\x62\x16\xc8\x69\x20\x27\x41\xff\x6e\x04\xb9\x0c\xe4\x64\xc0\x7d\x02\x64\x8e\x94\x79\x52\xce\x96\xc7\xe7\xca\x7a\xa5\x94\x0b\xa4\x5c\x2c\xe5\x12\x29\x97\x81\x9c\x02\x3a\xbf\x04\x39\x0d\xe4\x34\xe9\xe9\x34\xe9\xe9\x34\xe9\xe9\x34\xe9\xe9\x34\xe9\xe9\x34\xe9\xe9\x34\xe9\xe9\x34\xe9\xe9\x34\xe9\xe9\x34\xe9\xe9\x34\xe9\xe9\x34\xe9\xe3\x34\xe9\xe3\x34\xe9\xe3\x34\xe9\xe3\x34\xe9\xe3\x34\xe9\xe3\x34\xe9\xe3\x34\xe9\xe3\x34\xe9\xe3\x34\xe9\x63\x1e\xf4\xce\xd7\xac\x00\x34\xdf\x00\x72\x66\xe0\x5d\x90\x39\xb2\xee\x0d\xac\x00\x99\x17\x78\x0a\x64\xa1\x3c\x3e\x5b\xd6\xe7\xc8\x7a\x91\x94\x3e\x79\xcd\x5c\x79\x7d\x19\x8c\xc3\x02\x40\x71\xea\xf3\xc0\x8b\x02\xc0\x72\xea\x8b\xa5\x5c\x22\xe5\x32\x90\xc5\x6c\x7e\x60\x27\x2b\x05\xc4\x67\x40\xe6\x48\x99\x27\x65\x81\x94\xa5\x52\xce\x95\xb2\x42\xca\x4a\x29\x17\x48\xb9\x04\xe4\x5c\x69\x73\x19\x2b\x50\x3a\xb0\x79\x52\x2e\x60\xc5\x81\x6d\x20\x9d\xe3\x0b\x41\xf3\x36\x90\x39\x52\xe6\x49\x59\x20\xe5\x5c\x29\x2b\xa4\xac\x94\x72\x81\x94\x8b\xa5\x5c\x22\xe5\x32\x90\x8b\xa5\x9e\x25\x52\x2e\x93\xf2\x65\x18\xab\x4b\x41\x46\x05\xf2\x40\xb6\x55\x2c\xf6\x26\xcc\x54\x3a\x7b\x0b\xe4\x70\xb6\x86\x7d\xa8\xb4\x05\xf9\x71\x60\x1f\xc8\x0d\x70\xfd\x1a\xb6\x29\xb0\x1a\xe4\x17\x30\x1e\xd6\xb0\xcd\x52\x6e\x91\x47\xb6\x82\x9e\x35\x6c\x1b\xf4\xd1\x1a\xb6\x5d\xd6\x77\x41\x0c\xd7\xb0\xdd\x81\xdd\x20\xf7\x48\xb9\x5f\xca\xa3\x52\x1e\x97\xf2\x44\xe0\x6d\x90\x27\x65\xdd\xef\x48\xc0\x4d\x64\x1f\xb0\x35\x81\x4f\x40\x7e\xa8\xc4\x80\x5c\x0f\x56\x7d\xc0\x3e\x56\x86\x83\xdc\x1a\x58\x09\x72\x9b\x3c\xfb\x15\x58\xf5\x01\x60\x39\xf5\x5d\xb0\x1e\xfa\x80\xed\x93\xd7\x9f\x08\x1c\x60\x1f\x38\x3f\x06\xc2\xd6\x82\x9e\xd5\x20\x3f\x0c\xdc\x01\x72\x3d\xb4\x5d\x0b\xbe\xbc\x09\x72\x13\x8c\xa2\xb5\x60\xbf\x23\xb7\x40\xdf\xad\x05\xcd\x63\x40\x6e\x0b\xdc\x06\xf2\x2b\xf0\x6b\x2d\x68\xbe\x06\xe4\x0e\x98\x2b\xd6\xb2\x1f\xe4\x95\x8e\xfe\xb5\xec\x67\xc0\x5d\xcb\x7e\x93\xf5\x13\x80\xbb\x96\x9d\x92\xf2\x0f\xe7\x08\xe0\xc6\xb0\x75\x32\xaa\xeb\x64\x54\xd7\xc9\xa8\xae\x03\x4b\xa0\x0e\x5e\x74\x03\xb9\x01\x34\xac\x63\x1b\x01\x65\x1d\x58\xe2\xd4\x7f\x90\x72\xb7\x3c\xb2\x17\x6c\x5e\xc7\xf6\xc1\xdd\xb1\x0e\x22\xb6\x16\xe4\x21\x98\xf9\xd7\xb1\x23\xe0\xc5\x3a\x40\x5f\x09\xf2\x17\x79\xfc\x68\xe0\x6e\x90\xc7\x02\xeb\x41\x9e\x80\x31\xbc\x8e\x9d\x95\xd7\x54\x43\xe4\xd7\xb1\x40\x60\x31\x5b\xc7\x15\xb8\xfe\x23\xf0\x7a\x2f\x5b\x0f\x58\x77\x80\xdc\x2c\xe5\x56\x88\xc3\x7a\xf0\xd1\x91\x47\x01\x7d\x3d\x68\x80\xe8\xb0\x2d\x60\xff\xc7\x70\x76\x1f\xc8\xed\xa0\xe7\x63\xf0\xba\x35\xfb\x4c\x46\xec\x33\x19\xb1\xcf\xe4\xd9\xcf\x20\x56\x53\x41\xee\x92\xf5\xfd\x60\xf9\x67\xa0\x67\x35\xc8\xe3\xb2\xee\xd8\xf3\x19\xf4\xe9\x46\xb6\x11\xae\x74\xe4\x6e\xb0\x61\x23\x5c\xe9\xc8\xa3\x52\x1e\x07\xb9\x09\x22\xf3\x20\xc8\x0f\xe1\x9a\x4d\xd0\x47\xab\x41\x6e\x90\xf5\xad\x81\xeb\x41\x6e\x03\x7b\x36\x41\x8f\xac\x00\xb9\x5d\x9e\xfd\x01\xe4\x97\x10\xe1\xe1\x20\xa3\x02\x16\x48\x27\xc2\x5f\x82\x1e\x38\x02\x7a\x5c\x20\xd7\x43\x64\xbe\x04\xaf\xdf\x06\xb9\x21\x30\x13\xa4\x13\xed\x2f\x65\xb4\xbf\x04\xcd\x3e\x90\xce\x28\xfa\x12\x34\x2f\x05\xf9\x83\xbc\x66\xb7\xa3\x19\x22\xff\x2a\xc8\xfd\x52\x1e\x95\xd2\x0f\x76\x7e\x09\x91\xdc\xc8\x36\xcb\x11\xb5\x99\x6d\x00\xab\x36\xcb\x38\x6c\x96\xe3\x70\x33\xd8\xe6\xc8\xdd\x4a\x24\xc8\x3d\x52\xee\x97\xf2\x80\x94\x07\xa5\x3c\x2a\xe5\x71\x29\x7f\x83\x3b\x6b\x33\x3b\x29\xeb\x7e\x90\x5b\xc0\xa3\x15\x20\xa3\xc0\x9e\x2d\xe0\xd1\x70\x90\xed\x00\x65\x8b\x52\x0c\xde\x6d\x51\x2e\x77\x24\xa0\xc3\x59\xb8\x2f\x9c\xba\x63\xff\x16\xb0\xf9\x55\x90\x7b\xa5\xdc\x2f\xe5\xa1\xc0\x26\x90\x87\x65\xfd\x88\x94\x3f\x4b\x79\x54\xca\x5f\xe5\xd9\x63\xe0\xcb\x16\x88\xbf\x73\xe4\x84\x3c\x72\x4a\xca\x33\x52\x9e\x95\xc7\xab\xa5\x0c\x38\x12\x7c\x87\xfe\x00\x0b\x97\x83\x74\x2c\xdc\x2a\x63\xbe\x15\x6c\x8b\x01\xe9\xd8\xb6\x55\x8e\xf0\xad\x10\xff\x95\x20\x37\xc0\xd8\xdb\x0a\xd1\xfe\x04\xe4\x36\x18\x6f\x5b\x21\xc2\x8e\xdc\x03\x51\xda\x0a\xd6\x3e\x0c\xf2\x47\xf0\x77\x2b\x44\xdb\x39\xb2\x5f\x1e\x39\x20\x8f\x1c\x94\xf2\x10\xcc\x06\x5b\xd9\x4f\xf2\xec\x61\xb0\x76\x2b\xf8\xe2\x1c\xff\x59\xca\x5f\xe4\x91\xa3\xb2\xd5\xaf\x30\xfe\xb7\x82\x47\x0e\xee\x71\x79\xe4\x94\x94\xbf\xcb\xb6\xa7\xa5\x3c\x23\x65\xc0\xb9\x12\x7c\x79\x98\x6d\x03\x6b\x57\x80\xfc\x50\xd6\x9d\xfb\x71\x1b\x8c\x90\x13\x20\x37\x81\x47\xdb\x60\x4e\x70\x8e\x6c\x05\x66\xdc\x26\xef\x91\x6d\xf2\x0e\xdd\x06\x36\xec\x66\x5f\x81\x5f\xcb\x41\x6e\x86\x91\xf0\x95\x1c\xdb\x5f\x81\x25\x5f\x83\x3c\x01\x72\x07\x5c\xf9\x21\xdb\x21\x67\xd1\x9d\x80\xf2\x26\xc8\x0f\xa1\xed\x4e\x18\x93\xeb\x41\x7e\x2c\xeb\x1b\xe1\xca\x9d\xa0\x67\x23\xc8\xcd\xb2\xbe\x05\x74\xee\x84\xb1\xb4\x12\xe4\xf6\x40\x6b\x90\xbb\x40\xff\x4e\x89\xbb\x53\x6a\xdb\x05\x1a\xf6\x81\xfc\x18\xa2\xbd\x4b\xda\xbc\x0b\xae\x5f\x0d\xf2\x07\x59\xdf\x07\x23\x6a\x17\x8c\x37\x47\x1e\x09\x1c\x07\xf9\x33\x8c\xdb\x5d\x30\x23\xb5\x65\xdf\x83\x25\x37\x81\x74\x2c\xf9\x1e\xf4\x6c\x04\xb9\x41\xca\x4d\xf2\xc8\x16\x29\xbf\x02\x1b\xbe\x07\x74\xe7\xf8\x3e\x18\x93\xdf\xcb\xd1\xbb\x1b\xfc\xda\x07\xf2\x0f\x90\x7b\xa0\x8f\x1c\x79\x50\xca\x23\x70\xe5\x1e\x40\x59\x0d\xf2\xa8\x3c\x72\x5c\xca\x13\x52\x9e\x94\xf2\x14\x78\xb7\x07\xdb\xfe\x29\xaf\xf7\x3b\x75\x79\x37\xed\x85\xd1\x7b\x1c\xa4\x33\x2a\xf6\xc2\x48\xf8\x06\xe4\x41\x59\x3f\x2a\xe5\x71\x29\x4f\xca\x6b\xfe\x74\xea\xd0\x6a\x1f\xfb\x11\x46\x20\x48\x40\xdf\xc7\xf6\xc1\x5d\x16\x03\xf2\x84\xac\xff\x29\xa5\xa3\x7f\x3f\x68\x76\xe4\x1e\x29\xf7\x01\xd6\x7e\xb0\xdc\x91\x07\xe5\x91\x23\xb2\xfe\xb3\x94\x47\xe5\x91\xe3\x52\xfe\x26\xe5\x49\x79\xfc\x94\xac\x3b\x96\x1f\x90\xda\x0e\x48\x6d\x07\x60\xac\x3a\xf2\xa0\x94\x47\xe1\xca\x03\x72\xc6\x3b\x80\x57\x3a\x36\x1c\x94\xa3\xfa\xa0\x8c\xd5\x41\x79\xe5\x41\x89\x78\x50\x22\x1e\x94\x88\x07\x25\xe2\x41\xb0\xfc\x38\xc8\x3f\x64\xdd\x69\x7b\x58\x29\x86\xbb\xe6\xb0\xe4\x82\xc3\x80\xe8\xc8\xfd\x52\x3a\x7a\x0e\xb3\x23\x4a\x0f\x90\xce\x4c\x7b\x18\x34\x38\xf2\x37\x79\xfc\xa4\xbc\xe6\x0f\x59\x77\x22\x70\x04\xe6\xa2\x18\x90\x7b\xa4\xdc\x0f\x63\xe6\x08\xcc\x42\x4e\xfd\xa8\x94\xc7\xa5\x3c\x21\xaf\x3c\x29\xeb\x4e\xdb\xa3\xd2\xc7\xa3\xd2\xfe\xa3\x32\x62\x47\x25\xee\x51\x69\xff\x51\xd9\xd7\x47\xe5\x38\x3f\x2a\x7b\xf6\x28\xb4\x82\x79\x5f\x22\x1e\x95\xbd\x73\x4c\xb6\x3d\x26\xdb\x1e\x93\x6d\x8f\x41\xdb\xd5\x20\x9d\x3b\xf7\x98\xb4\xf6\x98\xc4\x3d\x26\x35\x1c\x93\xb8\xc7\xa4\x86\x63\x52\xc3\x71\xf0\x1d\x58\x44\x5a\x72\x5c\x46\xfb\xb8\x8c\xe4\x71\xa9\xed\xb8\x8c\xf9\x71\x19\xb7\xe3\xd2\xeb\xe3\xb2\xa7\x8e\x4b\x3d\xc7\x65\x0c\x7f\x53\x1a\x83\xbf\xbf\x29\x51\xe0\xd7\x6f\x32\x0e\xbf\x49\xdf\x7f\x83\x56\x1b\xd9\x6f\x92\xa3\x4f\xc8\xf9\xf6\x84\x9c\xcd\x4e\x40\x7e\x0e\x63\x08\xf2\xf3\xd5\xec\x04\xd8\x7f\x06\xa4\x63\xff\x09\x89\x78\x02\xec\xff\x04\xe4\xcf\xf2\xc8\x31\x79\xe4\x94\x94\x8e\xcd\x27\xc0\xe6\xdd\xec\xa4\x8c\xcf\x49\x19\x9f\x93\xb2\x7f\x4f\x4a\x4f\x4f\xca\x0c\xe7\xa4\xb4\xed\xa4\xf4\xee\x94\x1c\x4b\xa7\x64\xcf\x9e\x92\xfa\x4f\x49\x8f\x4e\xc9\x51\x74\x4a\x7a\x74\x4a\x5e\x7f\x4a\xde\x2f\xa7\x24\xca\xef\xd2\x8b\xdf\x65\x3f\xfe\x2e\x7d\xf9\x5d\xf6\xe3\xef\xb2\x1f\x7f\x97\xf1\x3c\x03\xd7\x58\x20\xf7\x4b\xe9\x9c\x3d\x23\x8f\x57\x4b\x4b\xaa\x41\xe7\x6a\xe6\x97\x51\xf5\xcb\x3e\xf2\x4b\x1f\xfd\xd2\x06\xbf\xb4\xdf\x2f\xed\xf7\x4b\xfb\xfd\x72\x7c\xfa\x65\x5b\xbf\xbc\x97\xfd\xb2\xbf\xfc\xf2\xce\x0d\x48\x3d\x01\xd9\x2f\x01\xd9\x36\x20\xdb\x06\x64\xdb\x80\x6c\x1b\x80\xeb\x57\x82\xfc\x43\xd6\xc1\x0b\xde\xd8\x89\x39\x48\x88\x39\xc8\xb6\xf2\x08\xc4\x1c\x24\xf0\x08\xc8\xcb\x41\xa6\xc1\x35\x1b\x41\x46\xc1\xf1\x34\x87\x65\x40\x16\x4b\x09\x2c\xa3\xed\xd5\xf6\x06\xda\x6a\x3f\xc2\xaa\xd0\x91\x13\xfc\x7f\x80\xcc\x76\xea\x30\x43\xb6\xd5\xf6\xb1\x97\x02\x31\x20\xdf\x96\x72\x8b\x94\xdb\xfd\xcb\x41\xee\x08\x0c\xd7\x0e\xc9\xb3\x87\xe4\xd9\x43\xf2\xec\x21\x98\xeb\x14\x90\x3b\x02\x2b\x14\x45\x69\x47\x4a\x9c\x67\x6a\xf2\xbf\x09\xca\x4a\xac\x13\xa5\x09\xe9\x86\x75\xaa\xa8\x24\x0b\xeb\x4c\x69\x4d\xae\xc1\x3a\x57\x5a\x92\x2f\xb1\x2e\x94\x48\xaa\x61\x5d\x55\x5a\xd0\x4c\xac\x6b\xca\x22\x76\x29\xd6\x75\xa5\x19\x3b\x85\x75\x43\x89\xe4\x3d\xb0\x1e\x46\x4a\xb4\x16\x58\x0f\x57\xda\xe8\xef\x61\x3d\x42\x89\x37\xfa\x60\xbd\x91\xe2\x32\xb6\x61\x3d\x52\x69\x15\x96\x06\x96\x10\x6e\xc0\xab\xe7\xa4\x55\x4e\x9d\x28\xb1\x44\x60\x9d\x2a\x11\x24\x05\xeb\x4c\x49\x22\x23\xb0\xce\x95\x78\xf2\x08\xd6\x85\xd2\x86\x1c\xc2\xba\xaa\xf4\xa2\x2d\xb0\xae\x29\x27\xe8\x14\xac\xeb\x4a\x77\xc8\x7a\x82\x75\x43\x69\xc3\xc3\xb1\x1e\x46\xbf\xe3\x35\xfa\xc3\x95\x14\xfd\x1a\xac\x47\x28\x53\xf5\xef\xb0\xde\x48\x99\x6d\x14\x62\x3d\x52\xb1\xc3\xc2\x95\x4c\xa5\x50\xc9\x87\xbf\x0a\xf8\x5b\xa4\x78\x95\x5c\x25\x16\xfe\x3c\xf0\xda\x03\xb5\x1c\xc5\xa7\x94\x2a\x0b\x95\x32\x79\x55\x01\x1c\x8d\x55\xba\xc3\xd1\x1e\x50\x9a\x4a\x6f\x25\x11\xfe\x62\x95\x41\x70\x95\x0f\xce\x17\x41\xfb\x58\x25\x03\xea\x65\xd0\xca\x91\x1e\xa9\xd7\xa7\x94\x28\xf1\x4a\x98\x3c\xf3\xd7\xda\x4c\xa8\x8d\x41\x2b\x06\xcb\xd6\xbd\xa0\x36\x04\xda\xe7\x80\x06\x25\xb3\x30\xbf\xb0\xa2\x70\x91\x37\x37\x36\xd7\x53\xe1\x89\xcd\xf1\x95\x2e\x2c\x2b\xcc\x2f\xa8\x88\xed\x9e\xd3\x23\xd6\xec\x9d\xd8\x3b\x76\x90\xcf\x97\x5f\xe4\x8d\xcd\xf0\x95\x95\xfa\xca\x3c\x15\x85\xbe\x92\xf8\xb0\x8c\xfa\x97\x99\xb1\x63\x40\xc5\x60\x4f\x45\xaf\xd8\x21\x25\x39\xa0\x77\x38\x18\x34\x0b\x60\x43\x0d\x8e\x55\xc6\xca\x23\x85\x4a\x1e\x5c\x50\x38\xcb\x1b\x54\x17\x3b\xd6\x5b\x56\x08\x47\x86\xc8\x08\x15\xc1\xe9\x1c\x78\x51\xe1\x29\x2a\x84\x32\x4d\x29\x87\x97\x5e\x68\x9d\x2b\xdb\xc6\x2a\x71\xf0\xf7\xb7\xda\xd3\xca\x73\xbc\x25\xb9\xde\xb2\xd8\xb8\xd8\xf3\x81\xfe\xae\x75\x6c\x5d\x53\xea\x2b\x88\xad\xb1\x6d\x82\x6c\x51\x5e\xab\xc1\x84\x80\xf6\x86\x7f\xf1\x10\x76\x65\x82\xb7\xac\xdc\x69\x62\xc6\xf7\xee\x1d\x9f\xd8\x30\xe8\x39\xc8\xb8\x0b\x41\x4a\xc4\xb8\x1a\xc4\x86\x2d\x2f\x04\x1b\x62\xe5\xe0\xaa\x90\x67\x9c\x48\x15\x43\x59\xa6\xcc\x81\x63\x3e\xe9\xd1\x85\x87\x40\x2c\x5c\xe7\x95\x03\xb6\x1c\xce\x78\xe5\xab\x5c\xa9\xd5\xd1\x3d\x1e\xae\x18\x2b\xaf\x1a\x2d\x5b\x3a\x3d\x51\x21\xd1\x4a\xe4\x55\xe3\x1a\x40\x1c\x05\x88\x79\xd2\x11\x6f\xc8\x95\x39\x52\xb7\xe3\x64\x50\xb3\x0f\xea\x05\xd8\xa7\xb3\x95\x4a\x19\x88\x72\xb8\xd2\x69\x57\xe3\x5b\xb9\x33\x44\x43\xe2\x5f\x58\x1e\xeb\x89\xad\x28\xf3\xe4\x7a\x8b\x3d\x65\x73\x62\x7d\x79\x75\x87\x5d\x6c\x99\x37\xbf\xb0\xbc\xc2\x5b\x06\x07\x0b\x4b\x62\xc7\xc7\x8f\x8d\x8f\x1d\xed\xa9\xf0\x96\x54\xc4\x7a\x4a\x72\x63\xc7\xd5\x36\x1c\x95\x97\x57\x98\xe3\x95\x07\x73\xbc\x65\x15\x1e\xb8\xd8\x57\x51\x00\xc3\x65\x76\x65\x59\x61\x79\x6e\x61\x8e\x83\x56\x1e\xdf\xd0\xf0\x6b\xf8\x5e\x3c\x37\xe0\x42\xee\x13\x05\x22\xe7\x44\x6c\x9e\x8c\xc3\x08\x79\xb9\xf3\xba\x3c\xd8\x64\x6c\x85\x77\x9e\x37\x76\x84\xa7\xa2\xc2\x5b\xee\x5c\x9c\x0e\x17\x94\x63\xf0\x83\x1d\x3b\x4e\x86\xca\x07\x47\x9d\x0e\x9b\x0f\xe1\x72\x82\x53\x20\xeb\x1e\xd9\xe9\xb9\x52\x9d\x73\xef\x97\x60\xcb\x59\x30\x1b\xc4\xfe\x25\x70\x2c\xb6\xf5\xe0\xe0\x29\x91\x18\xf3\xd0\x1b\xa7\x4d\x2f\x1c\x14\x79\x52\x96\x4b\xdc\x12\xc0\x88\x95\xf6\xd5\xdc\x24\xa1\xd8\xb1\xb2\x33\x3d\x72\x68\x04\x87\x63\x31\x9c\xad\x90\xd7\xe6\xc8\x71\x5d\x24\xed\x72\x66\xbf\x62\x88\x5e\x10\x6b\x16\xce\x6f\xf3\xe5\x6c\x59\x80\x1e\x17\x4b\xbd\xb1\xca\x48\x28\xe7\xcb\xa1\xeb\x93\x83\xab\xa4\x43\x47\x39\x10\xcf\x45\x25\x38\xb8\xf3\xf0\x36\x8c\x95\x6d\x4b\xa1\xee\x93\x5e\xd4\xc4\x31\x4e\xf6\xa1\xe3\x89\x57\x5a\xea\xd4\x3c\x72\x46\x9e\x05\x2d\x8a\x24\x76\xd0\xb6\x02\x39\x84\x3d\x72\x00\x7a\x71\x40\x56\x48\x0f\xca\x43\x06\x72\x70\xd8\xc6\x4a\x2f\x1c\xed\x6e\x39\x78\x9d\x79\xd8\x8b\x31\xcd\x86\xf9\x7b\x78\x83\x1a\x83\x11\x0c\xbd\x81\x9c\x3e\x29\x92\xf6\x96\x87\xe8\x2e\x91\xd6\xe6\xd6\xfa\x18\x8c\xb6\x73\x55\x11\x22\x05\x3d\x2e\x92\x3c\x31\xa7\xb6\x7f\xf2\xe4\xb8\x0c\x46\x34\x57\x6a\x8b\xbb\x40\xcc\xf3\x64\x6c\x2a\x10\xd5\x27\x2d\xca\x85\x7f\xc1\x1e\x0f\x8e\x2d\x1f\xb4\xad\x94\xfd\x11\xbc\xe9\x83\xa3\xbe\xe2\xbc\xc8\x79\x64\x7c\x7d\xd8\xae\x14\xce\x38\x58\x41\x5b\x8a\x83\x37\x71\xba\xa7\x1c\x6e\x4a\xb8\x85\xc7\x15\x96\xf8\xca\x7b\xc5\xce\x2f\x28\xcc\x29\x88\x9d\xef\x29\x8f\xcd\xf5\x96\x17\xe6\x97\xc0\xc9\x59\x0b\x63\xeb\xde\x12\xb1\x70\xd6\x03\x37\x7d\x49\x89\x6f\x1e\xdc\x50\xf3\xbc\xbd\xe0\x06\xcf\x2b\xf3\x96\x17\x14\x96\xe4\xc7\x96\xcb\xb9\x38\xd8\x3a\xb6\xa2\xc0\x53\xe1\xcc\x0e\xc5\xde\x8a\xb2\xc2\x1c\x4f\x51\xd1\x42\xa0\xb2\xe2\x52\x68\x35\x0b\xb8\x6b\x7e\x61\x45\x01\x00\x17\x7b\xcb\x63\x47\x7a\xe7\xc7\x8e\xf1\x15\x7b\x4a\x9e\x89\x0f\x9a\x02\x93\x48\x1e\x4c\xd5\xb1\x85\xc5\xa5\x65\xbe\x79\xd2\xc6\xb8\xf2\x9c\x32\xaf\xb7\x04\xc0\x3c\xb9\x9e\x59\x85\x45\x85\x15\xa0\xad\xc0\x53\xe6\xc9\x81\xa9\x05\xe6\x97\xc2\x9c\x72\x39\x75\xc0\x8c\x11\x5b\xea\x29\x89\x73\x57\x96\xf9\x4a\xbd\x60\x69\xf6\xa0\xe1\xe7\x2e\x04\x03\x83\xd3\x4e\xb9\xaf\x68\x1e\x20\x3b\x57\x97\x78\xbd\xb9\x0e\x22\x98\x3d\xcf\x5b\x04\x8d\x00\xb8\xc8\xe7\x9b\xe3\xf8\x93\xe7\x2b\x03\x43\x73\x2b\x0a\xe2\x42\x2c\xcf\xf3\x95\x54\x40\x53\x5f\xac\x27\x37\x17\x1c\x87\x68\xf9\x72\x2a\x8b\x9d\x09\x0d\x26\x99\x8a\x1a\xe3\x3c\x39\x65\x3e\x38\x57\x5a\xe4\xa9\x00\x2d\xc5\xce\xc4\x55\x20\x6f\xf9\x52\xa5\x8f\x92\x00\xff\xe6\xcb\x7f\xf1\xf2\xc6\x0f\x9d\xce\x72\x70\x32\x8b\xc7\x41\x92\x00\x0d\x2b\x2a\x4a\xfb\x24\x24\xcc\x9f\x3f\x3f\xde\x83\x73\x5a\x0e\x4c\x69\xf1\x60\x54\xc2\x3f\x57\xeb\x8c\x93\x52\x39\xa2\x43\xe7\xab\x32\x39\x36\x1c\x9d\xc5\x30\x66\xfe\x12\xba\x62\x61\xa9\x17\x47\x4a\x59\x79\x7c\x41\x45\x71\x51\x90\x0d\x83\xb0\x35\xd3\x66\x65\xc8\x44\x5d\x73\x2b\x8d\x05\xa6\x1b\x2e\x59\xa9\x14\x27\x80\x2c\x1c\xfa\xb1\xf5\x34\x38\xd3\x5e\x7d\x4e\x4f\x0c\xb2\xf9\x70\xa0\x8b\x12\x67\x04\x57\xca\x49\xde\xe9\xcb\xb1\x43\x86\xc7\x8e\x2a\x85\x61\x92\x05\x7d\x14\x8b\x17\xf4\x8a\xad\xe1\xfd\x44\x87\xf4\xeb\x86\x2b\x38\x0d\x15\xc2\xeb\x0a\xe9\x78\xb9\xbc\x89\xe2\x65\xb0\xf2\xe1\xfc\x28\xb0\x6c\x78\x6d\x18\x60\x10\x16\x96\x56\x94\xc7\x97\x17\x16\xc5\xfb\xca\xf2\x13\x46\x65\x0d\xc7\xef\xbd\x05\x8e\x3e\xf3\x7e\xa0\x03\x38\xda\xc0\x7f\x61\x17\xc9\xbc\x9e\x42\x46\xca\x21\xf7\x55\x21\xcf\xd5\x9d\x5f\xe2\x84\xfc\x35\x02\x72\xd5\x48\x58\x3d\x36\x71\xbe\x87\xe7\xfc\x1a\x9e\xd2\x5c\x69\xa1\xb4\x54\x2e\x52\x62\x94\x56\x4a\x6b\xa5\x0d\xac\x48\xda\x29\xed\xc1\xe9\x0e\x4a\x47\xa5\x93\xd2\x59\xe9\xa2\x74\x55\xba\x41\x3e\xd9\x43\xb9\x58\xe9\x09\xe1\x89\x03\x63\x13\x30\xab\xb4\x14\x5b\x71\x29\x49\x4a\xb2\x92\xa2\xa4\x82\x83\x7d\x95\x7e\x4a\x7f\xe5\x12\x65\x80\x32\x10\x58\x33\x1d\x78\x32\x13\x66\xc6\x2c\x98\x09\x07\x43\x07\x0c\x55\x86\x81\x6b\x23\x60\x4e\x1f\x05\x89\xc4\xa5\x30\xa7\x8f\x85\x79\x7c\x3c\x84\x3b\x5b\x99\xa8\x4c\x52\x26\x2b\x53\x94\xa9\xca\x34\x65\xba\x32\x43\x99\xa9\x78\x08\x55\x1e\x53\xae\x56\xae\x51\xde\x51\xee\x56\x0e\x2a\xd7\x2a\x37\x2b\x37\x28\x0f\x28\x4f\x2b\x8f\x13\xa6\xfc\x8b\x70\xe5\x2a\xe5\x0e\xe5\xb8\xf2\x9b\x72\x13\xac\x05\xaa\x88\xaa\xec\x52\x8e\x29\x0f\x2a\xcf\x28\x27\x95\x13\xca\x29\xe5\x51\xe5\x79\xe5\x13\x65\x3d\xac\x73\x66\x41\xc8\x6f\x85\x48\x7d\x06\xdd\xfa\xb1\xf2\xa9\xb2\x49\xd9\xa0\x6c\x54\x3e\x57\x0e\xc1\xec\xb4\x45\xf9\x42\xf9\x52\x59\x05\xa1\xff\x55\xb9\x4d\xf9\x4a\xd9\xaa\x6c\x83\x0e\x3b\xac\xfc\xac\x5c\x0f\x09\x49\x21\xcc\xaa\xce\xa8\x2c\x51\x1e\x86\x0e\x9a\x2b\x79\xa5\x1c\x06\x58\x05\xcc\xc2\xf3\x95\x9f\x94\x05\x90\xdb\x2f\x54\x16\xc3\xca\xed\x32\xe5\x75\xe5\x11\x65\xa9\xb2\x44\x59\xa6\x5c\xa1\x1c\x51\x7e\x51\xde\x24\x1a\xd1\x89\x41\xc2\x48\x38\x89\x50\xaa\x15\x3f\x69\x44\x22\x49\x63\xd2\x44\x09\x10\x85\x44\x91\xa6\x24\x9a\x10\xd2\x8c\x34\x27\x2d\x48\x4b\x72\x11\x89\x21\xad\x48\x6b\xd2\x86\xb4\x25\xed\x48\x7b\xe5\x0f\xe5\x34\x89\x25\x1d\x48\x47\xd2\x89\x74\x26\x5d\x48\x57\xd2\x8d\x74\x27\x3d\xc8\xc5\xa4\x27\xe9\x45\xe2\x48\x3c\x49\x50\xce\x28\x5f\x93\xde\x24\x91\x98\xc4\x22\x36\x71\x91\x24\x92\x4c\x52\x48\x2a\xe9\x43\xfa\x92\x7e\xa4\x3f\xb9\x44\xd9\xa3\xec\x25\x03\xc8\x40\x92\x46\xd2\x49\x06\xc9\x24\x6e\x92\xe5\xfc\x6c\x08\x19\x42\x86\x92\x61\x64\x38\xac\x95\x5e\x50\x5e\x24\x23\xc9\x28\x32\x9a\x5c\x4a\xc6\x90\xb1\x64\x1c\x19\x4f\x26\x90\x6c\xe5\x4f\xe5\xac\xf2\xa3\xb2\x8f\x4c\x24\x93\xc8\x64\x32\x85\x4c\x25\xd3\xc8\x74\x32\x83\xcc\x24\x1e\x32\x8b\xe4\x90\x5c\xe2\x25\x79\x24\x9f\x14\x90\x42\x32\x9b\xcc\x21\x45\xa4\x58\x79\x8b\x94\x10\x1f\x29\x25\x73\x95\xfd\xca\x01\x52\x46\xca\x49\x05\xa9\x24\xf3\xc8\x7c\xb2\x80\x2c\x24\x8b\xc8\x62\x72\x19\xb9\x9c\x2c\x21\x4b\xc9\x32\x72\x05\xb9\x92\x5c\x45\xae\x56\x9e\x20\xd7\x90\x6b\xc9\x75\xa4\x8a\x5c\x4f\xfe\x45\x6e\x20\x37\x92\x9b\xc8\xcd\xe4\x16\x72\x2b\xb9\x8d\xdc\x4e\xee\x20\x77\x92\xbb\xc8\xdd\xe4\x1e\xb2\x9c\xdc\x4b\x56\x90\xfb\xc8\xfd\xe4\x01\xf2\x20\x79\x88\x3c\x4c\x1e\x21\x8f\x92\xc7\xc8\xe3\xe4\xdf\xe4\x09\xf2\x24\x79\x8a\x3c\x4d\x9e\x21\xcf\x92\xe7\xc8\xf3\x64\x25\x59\x45\x5e\x20\x2f\x92\xd5\xe4\x25\xf2\x32\x79\x85\xbc\x4a\x5e\x23\xaf\x93\x37\xc8\x9b\xe4\x2d\xf2\x36\x79\x87\xbc\x4b\xde\x23\xef\x93\x35\xe4\x03\xb2\x96\xac\x23\x1f\x92\x8f\xc8\x7a\xf2\x31\xf9\x84\x7c\x4a\x3e\x23\x1b\xc8\x46\xf2\x39\xd9\x44\xbe\x20\x5f\x92\xcd\x64\x0b\xd9\x4a\xb6\x91\xaf\xc8\xd7\x64\x3b\xf9\x86\x7c\x4b\x76\x90\xef\xc8\x4e\xb2\x8b\x7c\x4f\x7e\x20\xbb\xc9\x1e\xb2\x97\xfc\x48\xf6\x91\xfd\xe4\x00\x39\x48\x0e\x91\x9f\xc8\x61\x72\x84\xfc\x4c\x7e\x21\x47\xc9\xaf\xe4\x18\x39\x4e\x7e\x23\x27\xc8\x49\x72\x8a\xfc\x4e\xfe\x20\xa7\xc9\x19\xf2\x27\x39\x4b\xaa\x89\x9f\x04\xa8\x42\x09\xa5\x94\x39\x9b\xf9\x53\x95\x6a\x54\xa7\x06\x0d\xa3\xe1\x34\x82\x36\xa2\x91\xb4\x31\x6d\x42\xa3\x68\x53\x1a\x4d\x9b\xd1\xe6\xb4\x05\x6d\x49\x2f\xa2\x31\xb4\x15\x6d\x4d\xdb\xd0\xb6\xb4\x1d\x6d\x4f\x63\x69\x07\xda\x91\x76\xa2\x9d\x69\x17\xda\x95\x76\xa3\xdd\x69\x0f\x7a\x31\xed\x49\x7b\xd1\x38\x1a\x4f\x13\x68\x6f\x9a\x48\x4d\x6a\x51\x9b\xba\x68\x12\x4d\xa6\x29\x34\x95\xf6\xa1\x7d\x69\x3f\xda\x9f\x5e\x42\x07\xd0\x81\x34\x8d\xa6\xd3\x0c\x9a\x49\xdd\x34\x8b\x0e\xa2\x83\xe9\x10\x3a\x94\x0e\xa3\xc3\xe9\x08\x3a\x92\x8e\xa2\xa3\xe9\xa5\x74\x0c\x1d\x4b\xc7\xd1\xf1\x74\x02\xcd\xa6\x13\xe9\x24\x3a\x99\x4e\xa1\x53\xe9\x34\x3a\x9d\xce\xa0\x33\xa9\x87\xce\xa2\x39\x34\x97\x7a\x69\x1e\xcd\xa7\x05\xb4\x90\xce\xa6\x73\x68\x11\x2d\xa6\x25\xd4\x47\x4b\xe9\x5c\x5a\x46\xcb\x69\x05\xad\xa4\xf3\xe8\x7c\xba\x80\x2e\xa4\x8b\xe8\x62\x7a\x19\xbd\x9c\x2e\xa1\x4b\xe9\x32\x7a\x05\xbd\x92\x5e\x45\xaf\xa6\xd7\xd0\x6b\xe9\x75\xb4\x8a\x5e\x4f\xff\x45\x6f\xa0\x37\xd2\x9b\xe8\xcd\xf4\x16\x7a\x2b\xbd\x8d\xde\x4e\xef\xa0\x77\xd2\xbb\xe8\xdd\xf4\x1e\xba\x9c\xde\x4b\x57\xd0\xfb\xe8\xfd\xf4\x01\xfa\x20\x7d\x88\x3e\x4c\x1f\xa1\x8f\xd2\xc7\xe8\xe3\xf4\xdf\xf4\x09\xfa\x24\x7d\x8a\x3e\x4d\x9f\xa1\xcf\xd2\xe7\xe8\xf3\x74\x25\x5d\x45\x5f\xa0\x2f\xd2\xd5\xf4\x25\xfa\x32\x7d\x85\xbe\x4a\x5f\x53\xb6\x2b\xbb\xe9\xeb\xca\xb7\xf4\x0d\xfa\x26\x7d\x8b\xbe\x4d\xdf\xa1\xef\xd2\xf7\xe8\xfb\x74\x0d\xfd\x80\xae\xa5\xeb\xe8\x87\xf4\x23\x65\x87\xf2\x9d\xb2\x53\xf9\x41\xf9\x46\xf9\x9e\xae\xa7\x1f\xd3\x4f\xe8\xa7\xf4\x33\xba\x81\x6e\xa4\x9f\xd3\x4d\xf4\x0b\xfa\x25\xdd\x4c\xb7\xd0\xad\x74\x1b\xfd\x8a\x7e\x4d\xb7\xd3\x6f\xe8\xb7\x74\x07\xfd\x8e\xee\xa4\xbb\xe8\xf7\xf4\x07\xba\x9b\xee\xa1\x7b\xe9\x8f\x74\x1f\xdd\x4f\x0f\xd0\x83\xf4\x10\xfd\x89\x1e\xa6\x47\xe8\xcf\xf4\x17\x7a\x94\xfe\x4a\x8f\xd1\xe3\xf4\x37\x7a\x82\x9e\xa4\xa7\xe8\xef\xf4\x0f\x7a\x9a\x9e\xa1\x7f\xd2\xb3\xb4\x9a\xfa\x69\x80\x29\x8c\x30\xca\x18\xe3\x4c\x30\x95\x69\x4c\x67\x06\x0b\x63\xe1\x2c\x82\x35\x62\x91\xac\x31\x6b\xc2\xa2\x58\x53\x16\xcd\x9a\xb1\xe6\xac\x05\x6b\xc9\x2e\x62\x31\xac\x15\x6b\xcd\xda\xb0\xb6\xac\x1d\x6b\xcf\x62\x59\x07\xd6\x91\x75\x62\x9d\x59\x17\xd6\x95\x75\x63\xdd\x59\x0f\x76\x31\xeb\xc9\x7a\xb1\x38\x16\xcf\x12\x58\x6f\x96\xc8\x4c\x66\x31\x9b\xb9\x58\x12\x4b\x66\x29\x2c\x95\xf5\x61\x7d\x59\x3f\xd6\x9f\x5d\xc2\x06\xb0\x81\x2c\x8d\xa5\xb3\x0c\x96\xc9\xdc\xce\xe7\x35\xd8\x60\x36\x84\x0d\x65\xc3\xd8\x70\x36\x82\x8d\x64\xa3\xd8\x68\x76\x29\x1b\xc3\xc6\xb2\x71\x6c\x3c\x9b\xe0\xbc\x83\xcf\x26\xb1\xc9\x6c\x0a\x9b\xea\xbc\xbb\xcd\x66\xb0\x99\xcc\xc3\x66\xb1\x1c\x96\xcb\xbc\x2c\x8f\xe5\x3b\xef\x3d\xb3\xd9\x6c\x0e\x2b\x62\xc5\xca\x53\xac\x84\xf9\x9c\xf7\x86\x59\x19\x2b\x67\x15\xac\x92\xcd\x63\xf3\x9d\x77\x7d\xd9\x22\xb6\x98\x5d\xc6\x2e\x67\x4b\xd8\x52\xb6\x4c\x79\x88\x5d\xc1\xae\x64\x57\xb1\xab\xd9\x35\xec\x5a\x76\x1d\xab\x62\xd7\xb3\x7f\xb1\x1b\xd8\x8d\xec\x26\x76\x33\xbb\x85\xdd\xca\x6e\x63\xb7\x2b\xf7\xb0\x3b\xd8\x9d\xec\x2e\xe5\x3e\x76\x37\xbb\x87\x2d\x67\xf7\xb2\x15\xec\x3e\x76\x3f\x7b\x80\x3d\xc8\x1e\x62\x0f\xb3\x47\xd8\xa3\xec\x31\xf6\x38\xfb\x37\x7b\x82\x3d\xc9\x9e\x62\x4f\xb3\x67\xd8\xb3\xec\x39\xf6\x3c\x5b\xc9\x56\xb1\x17\xd8\x8b\x6c\x35\x7b\x89\xbd\xcc\x5e\x61\xaf\xb2\xd7\xd8\xeb\xec\x0d\xf6\x26\x7b\x8b\xbd\xcd\xde\x61\xef\xb2\xf7\xd8\xfb\x6c\x0d\xfb\x80\x39\xef\x3e\x7e\xc8\x3e\x62\xeb\xd9\xc7\xec\x13\xf6\x29\xfb\x8c\x6d\x60\x1b\xd9\xe7\x6c\x13\xfb\x82\x7d\xc9\x36\xb3\x2d\xce\xfb\x3e\xec\x2b\xf6\x35\xdb\xce\xbe\x61\xdf\xb2\x1d\xec\x3b\xe7\x1d\x0d\xf6\x3d\xfb\x81\xed\x66\x7b\xd8\x5e\xf6\xa3\xf3\xec\xde\x79\x8e\xce\x0e\xb1\x9f\x9c\xe7\xda\xec\x67\xf6\x0b\x3b\xca\x7e\x65\xc7\xd8\x71\xe7\x49\x2d\x3b\xc9\x4e\xb1\xdf\xd9\x1f\xec\x34\x3b\xc3\xfe\x64\x67\x59\x35\xf3\xb3\x00\x57\x38\xe1\x94\x33\xce\xb9\xe0\x2a\xd7\xb8\xce\x0d\x1e\xc6\xc3\x79\x04\x6f\xc4\x23\x79\x63\xde\x84\x47\xf1\xa6\x3c\x9a\x37\xe3\xcd\x79\x0b\xde\x92\x5f\xc4\x63\x78\x2b\xde\x9a\xb7\xe1\x6d\x79\x3b\xde\x9e\xc7\xf2\x0e\xbc\x23\xef\xc4\x3b\xf3\x2e\xbc\x2b\xef\xc6\xbb\xf3\x1e\xfc\x62\xde\x93\xf7\xe2\x71\x3c\x9e\x27\xf0\xde\x3c\x91\x9b\xdc\xe2\x36\x77\xf1\x24\x9e\xcc\x53\x78\x2a\xef\xc3\xfb\xf2\x7e\xbc\x3f\xbf\x84\x0f\xe0\x03\x79\x1a\x4f\xe7\x19\x3c\x93\xbb\x79\x16\x1f\xc4\x07\xf3\x21\x7c\x28\x1f\xc6\x87\xf3\x11\x7c\x24\x1f\xc5\x47\xf3\x4b\xf9\x18\x3e\x96\x8f\xe3\xe3\xf9\x04\x9e\xcd\x27\xf2\x49\x7c\x32\x9f\xc2\xa7\xf2\x69\x7c\x3a\x9f\xc1\x67\x72\x0f\x9f\xc5\x73\x78\x2e\xf7\xf2\x3c\x9e\xcf\x0b\x78\x21\x9f\xcd\xe7\xf0\x22\x5e\xcc\x4b\xb8\x8f\x97\xf2\xb9\xbc\x8c\x97\xf3\x0a\x5e\xc9\xe7\xf1\xf9\x7c\x01\x5f\xc8\x17\xf1\xc5\xfc\x32\x7e\x39\x5f\xc2\x97\xf2\x65\xfc\x0a\x7e\x25\xbf\x8a\x5f\xcd\xaf\xe1\xd7\xf2\xeb\x78\x15\xbf\x9e\xff\x8b\xdf\xc0\x6f\xe4\x37\xf1\x9b\xf9\x2d\xfc\x56\x7e\x1b\xbf\x9d\xdf\xc1\xef\xe4\x77\xf1\xbb\xf9\x3d\x7c\x39\xbf\x97\xaf\xe0\xf7\xf1\xfb\xf9\x03\xfc\x41\xfe\x10\x7f\x98\x3f\xc2\x1f\xe5\x8f\xf1\xc7\xf9\xbf\xf9\x13\xfc\x49\xfe\x14\x7f\x9a\x3f\xc3\x9f\xe5\xcf\xf1\xe7\xf9\x4a\xbe\x8a\xbf\xc0\x5f\xe4\xab\xf9\x4b\xfc\x65\xfe\x0a\x7f\x95\xbf\xc6\x5f\xe7\x6f\xf0\x37\xf9\x5b\xfc\x6d\xfe\x0e\x7f\x97\xbf\xc7\xdf\xe7\x6b\xf8\x07\x7c\x2d\x5f\xc7\x3f\xe4\x1f\xf1\xf5\xfc\x63\xfe\x09\xff\x94\x7f\xc6\x37\xf0\x8d\xfc\x73\xbe\x89\x7f\xc1\xbf\xe4\x9b\xf9\x16\xbe\x95\x6f\xe3\x5f\xf1\xaf\xf9\x76\xfe\x0d\xff\x96\xef\xe0\xdf\xf1\x9d\x7c\x17\xff\x9e\xff\xc0\x77\xf3\x3d\x7c\x2f\xff\x91\xef\xe3\xfb\xf9\x01\x7e\x90\x1f\xe2\x3f\xf1\xc3\xfc\x08\xff\x99\xff\xc2\x8f\xf2\x5f\xf9\x31\x7e\x9c\xff\xc6\x4f\xf0\x93\xfc\x14\xff\x9d\xff\xc1\x4f\xf3\x33\xfc\x4f\x7e\x96\x57\x73\x3f\x0f\x08\x45\x10\x67\xbb\x59\xc1\x85\x10\xaa\xd0\x84\x2e\x0c\x11\x26\xc2\x45\x84\x68\x24\x22\x45\x63\xd1\x44\x44\x89\xa6\x22\x5a\x34\x13\xcd\x45\x0b\xd1\x52\x5c\x24\x62\x44\x2b\xd1\x5a\xb4\x11\x6d\x45\x3b\xd1\x5e\xc4\x8a\x0e\xa2\xa3\xe8\x24\x3a\x8b\x2e\xa2\xab\xe8\x26\xba\x8b\x1e\xe2\x62\xd1\x53\xf4\x12\x71\x22\x5e\x24\x88\xde\x22\x51\x98\xc2\x12\xb6\x70\x89\x24\x91\x2c\x52\x44\xaa\xe8\x23\xfa\x8a\x7e\xa2\xbf\xb8\x44\x0c\x10\x03\x45\x9a\x48\x17\x19\x22\x53\xb8\x45\x96\x18\x24\x06\x8b\x21\x62\xa8\x18\x26\x86\x8b\x11\x62\xa4\x18\x25\x46\x8b\x4b\xc5\x18\x31\x56\x8c\x13\xe3\xc5\x04\x91\x2d\x26\x8a\x49\x62\xb2\x98\x22\xa6\x8a\x69\x62\xba\x98\x21\x66\x0a\x8f\x98\x25\x72\x44\xae\xf0\x8a\x3c\x91\x2f\x0a\x44\xa1\x98\x2d\xe6\x88\x22\x51\x2c\x4a\x84\x4f\x94\x8a\xb9\xa2\x4c\x94\x8b\x0a\x51\x29\xe6\x89\xf9\x62\x81\x58\x28\x16\x89\xc5\xe2\x32\x71\xb9\x58\x22\x96\x8a\x65\xe2\x0a\x71\xa5\xb8\x4a\x5c\x2d\xae\x11\xd7\x8a\xeb\x44\x95\xb8\x5e\xfc\x4b\xdc\x20\x6e\x14\x37\x89\x9b\xc5\x2d\xe2\x56\x71\x9b\xb8\x5d\xdc\x21\xee\x14\x77\x89\xbb\xc5\x3d\x62\xb9\xb8\x57\xac\x10\xf7\x89\xfb\xc5\x03\xe2\x41\xf1\x90\x78\x58\x3c\x22\x1e\x15\x8f\x89\xc7\xc5\xbf\xc5\x13\xe2\x49\xf1\x94\x78\x5a\x3c\x23\x9e\x15\xcf\x89\xe7\xc5\x4a\xb1\x4a\xbc\x20\x5e\x14\xab\xc5\x4b\xe2\x65\xf1\x8a\x78\x55\xbc\x26\x5e\x17\x6f\x88\x37\xc5\x5b\xe2\x6d\xf1\x8e\x78\x57\xbc\x27\xde\x17\x6b\xc4\x07\x62\xad\x58\x27\x3e\x14\x1f\x89\xf5\xe2\x63\xf1\x89\xf8\x54\x7c\x26\x36\x88\x8d\xe2\x73\xb1\x49\x7c\x21\xbe\x14\x9b\xc5\x16\xb1\x55\x6c\x13\x5f\x89\xaf\xc5\x76\xf1\x8d\xf8\x56\xec\x10\xdf\x89\x9d\x62\x97\xf8\x5e\xfc\x20\x76\x8b\x3d\x62\xaf\xf8\x51\xec\x13\xfb\xc5\x01\x71\x50\x1c\x12\x3f\x89\xc3\xe2\x88\xf8\x59\xfc\x22\x8e\x8a\x5f\xc5\x31\x71\x5c\xfc\x26\x4e\x88\x93\xe2\x94\xf8\x5d\xfc\x21\x4e\x8b\x33\xe2\x4f\x71\x56\x54\x0b\xbf\x08\xa8\x8a\x4a\x54\xaa\x3a\xdb\x59\x0a\x55\x55\x35\x55\x57\x0d\x35\x4c\x0d\x57\x23\xd4\x46\x6a\xa4\xda\x58\x6d\xa2\x46\xa9\x4d\xd5\x68\xb5\x99\xda\x5c\x6d\xa1\xb6\x54\x2f\x52\x63\xd4\x56\x6a\x6b\xb5\x8d\xda\x56\x6d\xa7\xb6\x57\x63\xd5\x0e\x6a\x47\xb5\x93\xda\x59\xed\xa2\x76\x55\xbb\xa9\xdd\xd5\x1e\xea\xc5\x6a\x4f\xb5\x97\x1a\xa7\xc6\xab\x09\x6a\x6f\x35\x51\x35\x55\x4b\xb5\x55\x97\x9a\xa4\x26\xab\x29\x6a\xaa\xda\x47\xed\xab\xf6\x53\xfb\xab\x97\xa8\x03\xd4\x81\x6a\x9a\x9a\xae\x66\xa8\x99\xaa\x5b\xcd\x52\x07\xa9\x83\xd5\x21\xea\x50\x75\x98\x3a\x5c\x1d\xa1\x8e\x54\x47\xa9\xa3\xd5\x4b\xd5\x31\xea\x58\x75\x9c\x3a\x5e\x9d\xa0\x66\xab\x13\xd5\x49\xea\x64\x75\x8a\x3a\x55\x9d\xa6\x4e\x57\x67\xa8\x33\x55\x8f\x3a\x4b\xcd\x51\x73\x55\xaf\x9a\xa7\xe6\xab\x05\x6a\xa1\x3a\x5b\x9d\xa3\x16\xa9\xc5\x6a\x89\xea\x53\x4b\xd5\xb9\x6a\x99\x5a\xae\x56\xa8\x95\xea\x3c\x75\xbe\xba\x40\x5d\xa8\x2e\x52\x17\xab\x97\xa9\x97\xab\x4b\xd4\xa5\xea\x32\xf5\x0a\xf5\x4a\xf5\x2a\xf5\x6a\xf5\x1a\xf5\x5a\xf5\x3a\xb5\x4a\xbd\x5e\xfd\x97\x7a\x83\x7a\xa3\x7a\x93\x7a\xb3\x7a\x8b\x7a\xab\x7a\x9b\x7a\xbb\x7a\x87\x7a\xa7\x7a\x97\x7a\xb7\x7a\x8f\xba\x5c\xbd\x57\x5d\xa1\xde\xa7\xde\xaf\x3e\xa0\x3e\xa8\x3e\xa4\x3e\xac\x3e\xa2\x3e\xaa\x3e\xa6\x3e\xae\xfe\x5b\x7d\x42\x7d\x52\x7d\x4a\x7d\x5a\x7d\x46\x7d\x56\x7d\x4e\x7d\x5e\x5d\xa9\xae\x52\x5f\x50\x5f\x54\x57\xab\x2f\xa9\x2f\xab\xaf\xa8\xaf\xaa\xaf\xa9\xaf\xab\x6f\xa8\x6f\xaa\x6f\xa9\x6f\xab\xef\xa8\xef\xaa\xef\xa9\xef\xab\x6b\xd4\x0f\xd4\xb5\xea\x3a\xf5\x43\xf5\x23\x75\xbd\xfa\xb1\xfa\x89\xfa\xa9\xfa\x99\xba\x41\xdd\xa8\x7e\xae\x6e\x52\xbf\x50\xbf\x54\x37\xab\x5b\xd4\xad\xea\x36\xf5\x2b\xf5\x6b\x75\xbb\xfa\x8d\xfa\xad\xba\x43\xfd\x4e\xdd\xa9\xee\x52\xbf\x57\x7f\x50\x77\xab\x7b\xd4\xbd\xea\x8f\xea\x3e\x75\xbf\x7a\x40\x3d\xa8\x1e\x52\x7f\x52\x0f\xab\x47\xd4\x9f\xd5\x5f\xd4\xa3\xea\xaf\xea\x31\xf5\xb8\xfa\x9b\x7a\x42\x3d\xa9\x9e\x52\x7f\x57\xff\x50\x4f\xab\x67\xd4\x3f\xd5\xb3\x6a\xb5\xea\x57\x03\x9a\xa2\x11\xcd\xd9\x48\x8b\x6b\x42\x53\x35\x4d\xd3\x35\x43\x0b\xd3\xc2\x35\x67\xdb\x8f\x48\xad\xb1\xd6\x44\x8b\xd2\x9a\x6a\xd1\x5a\x33\xad\xb9\xd6\x42\x6b\xa9\x5d\xa4\xc5\x68\xad\xb4\xd6\x5a\x1b\xad\xad\xd6\x4e\x6b\xaf\xc5\x6a\x1d\xb4\x8e\x5a\x27\xad\xb3\xd6\x45\xeb\xaa\x75\xd3\xba\x6b\x3d\xb4\x8b\xb5\x9e\x5a\x2f\x2d\x4e\x8b\xd7\x12\xb4\xde\x5a\xa2\x66\x6a\x96\x66\x6b\x2e\x2d\x49\x4b\xd6\x52\xb4\x54\xad\x8f\xd6\x57\xeb\xa7\xf5\xd7\x2e\xd1\x06\x68\x03\xb5\x34\x2d\x5d\xcb\xd0\x32\x35\xb7\x96\xa5\x0d\xd2\x06\x6b\x43\xb4\xa1\xda\x30\x6d\xb8\x36\x42\x1b\xa9\x8d\xd2\x46\x6b\x97\x6a\x63\xb4\xb1\xda\x38\x6d\xbc\x36\x41\xcb\xd6\x26\x6a\x93\xb4\xc9\xda\x14\x6d\xaa\x36\x4d\x9b\xae\xcd\xd0\x66\x6a\x1e\x6d\x96\x96\xa3\xe5\x6a\x5e\x2d\x4f\xcb\xd7\x0a\xb4\x42\x6d\xb6\x36\x47\x2b\xd2\x8a\xb5\x12\xcd\xa7\x95\x6a\x73\xb5\x32\xad\x5c\xab\xd0\x2a\xb5\x79\xda\x7c\x6d\x81\xb6\x50\x5b\xa4\x2d\xd6\x2e\xd3\x2e\xd7\x96\x68\x4b\xb5\x65\xda\x15\xda\x95\xda\x55\xda\xd5\xda\x35\xda\xb5\xda\x75\x5a\x95\x76\xbd\xf6\x2f\xed\x06\xed\x46\xed\x26\xed\x66\xed\x16\xed\x56\xed\x36\xed\x76\xed\x0e\xed\x4e\xed\x2e\xed\x6e\xed\x1e\x6d\xb9\x76\xaf\xb6\x42\xbb\x4f\xbb\x5f\x7b\x40\x7b\x50\x7b\x48\x7b\x58\x7b\x44\x7b\x54\x7b\x4c\x7b\x5c\xfb\xb7\xf6\x84\xf6\xa4\xf6\x94\xf6\xb4\xf6\x8c\xf6\xac\xf6\x9c\xf6\xbc\xb6\x52\x5b\xa5\xbd\xa0\xbd\xa8\xad\xd6\x5e\xd2\x5e\xd6\x5e\xd1\x5e\xd5\x5e\xd3\x5e\xd7\xde\xd0\xde\xd4\xde\xd2\xde\xd6\xde\xd1\xde\xd5\xde\xd3\xde\xd7\xd6\x68\x1f\x68\x6b\xb5\x75\xda\x87\xda\x47\xda\x7a\xed\x63\xed\x13\xed\x53\xed\x33\x6d\x83\xb6\x51\xfb\x5c\xdb\xa4\x7d\xa1\x7d\xa9\x6d\xd6\xb6\x68\x5b\xb5\x6d\xda\x57\xda\xd7\xda\x76\xed\x1b\xed\x5b\x6d\x87\xf6\x9d\xb6\x53\xdb\xa5\x7d\xaf\xfd\xa0\xed\xd6\xf6\x68\x7b\xb5\x1f\xb5\x7d\xda\x7e\xed\x80\x76\x50\x3b\xa4\xfd\xa4\x1d\xd6\x8e\x68\x3f\x6b\xbf\x68\x47\xb5\x5f\xb5\x63\xda\x71\xed\x37\xed\x84\x76\x52\x3b\xa5\xfd\xae\xfd\xa1\x9d\xd6\xce\x68\x7f\x6a\x67\xb5\x6a\xcd\xaf\x05\x74\x45\x59\xad\xbc\xa4\x13\x9d\xea\x4c\x79\x55\x79\x4d\x59\xa7\x73\xe5\x65\xe5\x15\xe5\x43\x5d\x28\x57\x2a\x1f\x28\xd7\x29\xcf\xea\xaa\xae\xe9\xba\x6e\xe8\x61\x7a\xb8\xf2\x91\x1e\xa1\x37\xd2\x23\x95\x77\x95\xf7\xf4\xc6\x7a\x13\xe5\x6d\x3d\x4a\x6f\xaa\x47\xeb\xcd\xf4\xe6\x7a\x0b\xbd\xa5\x7e\x91\x1e\xa3\xb7\xd2\x5b\xeb\x6d\xf4\xb6\x7a\x3b\xbd\xbd\x1e\xab\x77\xd0\x3b\xea\x9d\xf4\xce\xca\xef\x7a\x17\xbd\xab\xde\x4d\xef\xae\xf7\xd0\x2f\xd6\x7b\xea\xbd\xf4\x38\x3d\x5e\x4f\xd0\x7b\xeb\x89\xba\xa9\x5b\xba\xad\xbb\xf4\x24\x3d\x59\x4f\xd1\x53\xf5\x3e\x7a\x5f\xe5\x46\xbd\x9f\xde\x5f\xbf\x44\x1f\xa0\x0f\xd4\xd3\xf4\x74\x3d\x43\xcf\xd4\xdd\x7a\x96\x3e\x48\x1f\xac\x0f\xd1\x87\xea\xc3\xf4\xe1\xfa\x08\x65\xb9\x3e\x52\x59\xa1\xdc\xab\x1c\xd5\x47\x29\x6b\x95\x7f\x2b\xb7\xeb\xa3\xf5\x4b\x95\xfb\x95\x27\x95\x5b\xf4\x31\xca\x9d\xca\x5d\xfa\x58\x7d\x9c\x3e\x5e\x9f\xa0\x67\xeb\x13\xf5\x49\xfa\x64\x7d\x8a\x3e\x55\x9f\xa6\x4f\xd7\x67\xe8\x33\x75\x8f\x3e\x4b\xcf\xd1\x73\x75\xaf\x9e\xa7\xe7\xeb\x05\x7a\xa1\x3e\x5b\x9f\xa3\x17\xe9\xc5\x7a\x89\xee\xd3\x4b\xf5\xb9\x7a\x99\x5e\xae\x57\xe8\x95\xfa\x3c\x7d\xbe\xbe\x40\x5f\xa8\x2f\xd2\x17\xeb\x97\xe9\x97\xeb\x4b\xf4\xa5\xfa\x32\xfd\x0a\xfd\x4a\xfd\x2a\xfd\x6a\xfd\x1a\xfd\x5a\xfd\x3a\xbd\x4a\xbf\x5e\xff\x97\x7e\x83\x7e\xa3\x7e\x93\x7e\xb3\x7e\x8b\xf2\x86\x7e\xab\x7e\x9b\x7e\xbb\x7e\x87\x7e\xa7\x7e\x97\x7e\xb7\x7e\x8f\xbe\x5c\xbf\x57\x5f\xa1\xdf\xa7\xdf\xaf\x3f\xa0\x3f\xa8\x3f\xa4\x3f\xac\x3f\xa2\x3f\xaa\x3f\xa6\x3f\xae\xff\x5b\x7f\x42\x7f\x52\x7f\x4a\x7f\x5a\x7f\x46\x7f\x56\x7f\x4e\x7f\x5e\x5f\xa9\xaf\xd2\x5f\xd0\x5f\xd4\x57\xeb\x2f\xe9\x2f\xeb\xaf\xe8\xaf\xea\xaf\xe9\xaf\xeb\x6f\xe8\x6f\xea\x6f\xe9\x6f\xeb\xef\xe8\xef\xea\xef\xe9\xef\xeb\x6b\xf4\x0f\xf4\xb5\xfa\x3a\xfd\x43\xfd\x23\x7d\xbd\xf2\xbe\xb2\x46\xff\x58\xff\x44\xff\x54\xff\x4c\xdf\xa0\x6f\xd4\x3f\xd7\x37\xe9\x5f\xe8\x5f\xea\x9b\xf5\x2d\xfa\x56\x7d\x9b\xfe\x95\xfe\xb5\xbe\x5d\xff\x46\xff\x56\xdf\xa1\x7f\xa7\xef\xd4\x77\xe9\xdf\xeb\x3f\xe8\xbb\xf5\x3d\xfa\x5e\xfd\x47\x7d\x9f\xbe\x5f\x3f\xa0\x1f\xd4\x0f\xe9\x3f\xe9\x87\xf5\x23\xfa\xcf\xfa\x2f\xfa\x51\xfd\x57\xfd\x98\x7e\x5c\xff\x4d\x3f\xa1\x9f\xd4\x4f\xe9\xbf\xeb\x7f\xe8\xa7\xf5\x33\xfa\x9f\xfa\x59\xbd\x5a\xf7\xeb\x01\x43\x31\x88\x41\x0d\x66\x70\x43\x18\xaa\xa1\x19\xba\x61\x18\x61\x46\xb8\x11\x61\x34\x32\x22\x8d\xc6\x46\x13\x23\xca\x68\x6a\x44\x1b\xcd\x8c\xe6\x46\x0b\xa3\xa5\x71\x91\x11\x63\xb4\x32\x5a\x1b\x6d\x8c\xb6\x46\x3b\xa3\xbd\x11\x6b\x74\x30\x3a\x1a\x9d\x8c\xce\x46\x17\xa3\xab\xd1\xcd\xe8\x6e\xf4\x30\x2e\x36\x7a\x1a\xbd\x8c\x38\x23\xde\x48\x30\x7a\x1b\x89\x86\x69\x58\x86\x6d\xb8\x8c\x24\x23\xd9\x48\x31\x52\x8d\x3e\x46\x5f\xa3\x9f\xd1\xdf\xb8\xc4\x18\x60\x0c\x34\xd2\x8c\x74\x23\xc3\xc8\x34\xdc\x46\x96\x31\xc8\x18\x6c\x0c\x31\x86\x1a\xc3\x8c\xe1\xc6\x08\x63\xa4\x31\xca\x18\x6d\x5c\x6a\x8c\x31\xc6\x1a\xe3\x8c\xf1\xc6\x04\x23\xdb\x98\x68\x4c\x32\x26\x1b\x53\x8c\xa9\xc6\x34\x63\xba\x31\xc3\x98\x69\x78\x8c\x59\x46\x8e\x91\x6b\x78\x8d\x3c\x23\xdf\x28\x30\x0a\x8d\xd9\xc6\x1c\xa3\xc8\x28\x36\x4a\x0c\x9f\x51\x6a\xcc\x35\xca\x8c\x72\xa3\xc2\xa8\x34\xe6\x19\xf3\x8d\x05\xc6\x42\x63\x91\xb1\xd8\xb8\xcc\xb8\xdc\x58\x62\x2c\x35\x96\x19\x57\x18\x57\x1a\x57\x19\x57\x1b\xd7\x18\xd7\x1a\xd7\x19\x55\xc6\xf5\xc6\xbf\x8c\x1b\x8c\x1b\x8d\x9b\x8c\x9b\x8d\x5b\x8c\x5b\x8d\xdb\x8c\xdb\x8d\x3b\x8c\x3b\x8d\xbb\x8c\xbb\x8d\x7b\x8c\xe5\xc6\xbd\xc6\x0a\xe3\x3e\xe3\x7e\xe3\x01\xe3\x41\xe3\x21\xe3\x61\xe3\x11\xe3\x51\xe3\x31\xe3\x71\xe3\xdf\xc6\x13\xc6\x93\xc6\x53\xc6\xd3\xc6\x33\xc6\xb3\xc6\x73\xc6\xf3\xc6\x4a\x63\x95\xf1\x82\xf1\xa2\xb1\xda\x78\xc9\x78\xd9\x78\xc5\x78\xd5\x78\xcd\x78\xdd\x78\xc3\x78\xd3\x78\xcb\x78\xdb\x78\xc7\x78\xd7\x78\xcf\x78\xdf\x58\x63\x7c\x60\xac\x35\xd6\x19\x1f\x1a\x1f\x19\xeb\x8d\x8f\x8d\x4f\x8c\x4f\x8d\xcf\x8c\x0d\xc6\x46\xe3\x73\x63\x93\xf1\x85\xf1\xa5\xb1\xd9\xd8\x62\x6c\x35\xb6\x19\x5f\x19\x5f\x1b\xdb\x8d\x6f\x8c\x6f\x8d\x1d\xc6\x77\xc6\x4e\x63\x97\xf1\xbd\xf1\x83\xb1\xdb\xd8\x63\xec\x35\x7e\x34\xf6\x19\xfb\x8d\x03\xc6\x41\xe3\x90\xf1\x93\x71\xd8\x38\x62\xfc\x6c\xfc\x62\x1c\x35\x7e\x35\x8e\x19\xc7\x8d\xdf\x8c\x13\xc6\x49\xe3\x94\xf1\xbb\xf1\x87\x71\xda\x38\x63\xfc\x69\x9c\x35\xaa\x0d\xbf\x11\x08\x53\xc2\x48\x18\x0d\x63\x61\x3c\x4c\x84\xa9\x61\x5a\x98\x1e\x66\x84\x85\x85\x85\x87\x45\x84\x35\x0a\x8b\x0c\x6b\x1c\xd6\x24\x2c\x2a\xac\x69\x58\x74\x58\xb3\xb0\xe6\x61\x2d\xc2\x5a\x86\x5d\x14\x16\xa3\x55\x96\x14\xf6\xee\x9d\xd6\x1b\xcb\x4c\xc3\x37\xcf\x5b\x56\x9e\xe3\x2b\xf3\xb2\xe2\xca\x44\xb5\xb8\x30\x37\xd7\x57\xa1\xa5\x15\x3b\x0f\x99\x4b\x34\x4f\xb0\x54\xd3\x66\x95\x79\xe7\x79\x55\x8f\x2c\xb4\x34\x5f\xbe\xaf\xc4\x3b\x47\xf3\x04\xcb\xf0\x8c\x9c\xc2\xb2\x9c\xca\xe2\xbc\x22\xef\x82\xf0\x9c\x73\xf5\xb0\x0c\x50\xe5\xc9\xc9\xf1\x96\x54\x84\xe5\xd4\x56\xd5\xcc\x1c\x8f\xa3\x32\x37\x58\x64\x82\x7e\x4f\x85\xe6\x46\x40\x2f\x02\xba\x83\x80\x5e\x59\x84\xb9\xcf\x29\xf2\xd6\x56\x35\x37\x9a\xe1\x0d\x96\xaa\x3b\xa8\xd1\x2b\x8b\xf0\x41\x21\x46\xe5\x87\x18\x35\xe8\x9c\xae\xfc\xda\x6a\xc4\xa0\x1c\x5f\x71\xb1\x07\x5f\xe4\x87\xbc\x08\x1f\x1c\xa2\xa7\xe0\x5c\x9d\x0f\x9e\xe5\x29\xe3\x05\x20\xd4\x21\x15\x85\x45\xb9\x5e\xb5\x50\x16\xda\x10\xf4\xa4\x10\x3d\x19\x12\xf4\xa4\x30\x18\xba\x21\x68\x73\x61\xb0\xa4\x43\x86\xd2\xc2\xd9\xe1\x43\x43\x30\x66\x9f\xab\x47\x0c\x0b\xb5\x6a\x4e\x9d\x17\xf9\xce\x7b\x16\x45\x9e\x92\xdc\xc2\x1c\x75\xb8\x27\xa7\xb2\xc2\xab\x16\xc9\x22\x62\x78\xe8\x75\x45\x21\x2f\xd4\xe1\xc1\x00\x15\xc9\x82\x0f\x07\xef\x79\x11\x08\x75\x64\xb0\x7d\x49\xb0\xfd\xc8\xd0\xf6\x25\xa1\xed\x47\x06\xdb\x97\x04\x03\x5c\xe2\x29\xf5\x95\x57\x94\xf9\x4a\x0b\xbc\xcc\x5d\x92\xcf\xbc\x25\xf9\xda\x28\x74\xde\x87\xce\x8f\x0a\x3a\xef\x93\x45\xa3\x51\x05\x95\x25\xf9\x9e\xb2\xca\xe2\x22\x4f\x65\x45\x23\x5f\xe8\x2b\x75\x4c\xd0\x86\xb2\xa0\x0d\x63\x42\x6d\x28\x0b\xb5\x61\x4c\xd0\x86\xb2\x60\x31\x36\xd8\xaa\x5c\x16\xe1\x63\x43\xc2\x58\x1e\x12\xc6\x71\xa1\xda\x2a\x42\xb5\x8d\x0b\xaa\xa9\x08\x46\x64\x9c\xd3\xa5\x15\x4e\x97\x8e\x0f\x76\x69\x65\xb0\x4b\xc7\xa3\x57\x95\xe8\xd5\xf8\xa0\x57\x95\xb2\x10\xe3\xcb\x0a\x4b\xf2\x45\xa5\x23\x1b\x8d\xaf\xe3\x61\x65\xe8\x2b\x6d\x3c\x76\x7d\x25\xde\x35\xd9\x21\xd6\xce\x0f\xa9\x4f\x0a\xa9\x2f\x3c\x57\x57\x27\x07\x7d\x5d\x24\x8b\xb0\xc9\xe7\x86\xf1\xa2\xda\xaa\x28\xf2\x95\xe4\x97\xcb\x5b\x3b\x31\xa5\x37\x96\x89\x58\x9a\x58\x5a\x58\xda\x58\xba\xb0\x4c\xc2\x32\x19\xcb\x14\x2c\x53\xb1\x4c\xc3\x32\x1d\xcb\x0c\x2c\x33\xb1\x74\x63\x99\x15\x2c\x53\x11\x3f\x15\xf1\x53\x11\x37\x15\x71\x53\x11\x37\x15\x71\x53\x11\x37\x15\x71\x53\x11\x37\x15\x71\x53\x11\x37\x15\x71\x53\x11\x37\x15\x71\x53\xb3\xc4\xa8\x02\x5f\x19\x2c\x3c\x1d\x19\x3c\x96\x86\x3e\xa7\x21\x76\x1a\x62\xa7\x21\x76\x1a\x62\xa7\x21\x76\x1a\x62\xa7\x21\x76\x1a\x62\xa7\x21\x76\x1a\x62\xa7\x21\x76\x9a\x5b\x8c\x97\x98\x95\xe7\x30\xd3\xd1\xdf\x74\xc4\x4e\x47\xec\x74\xc4\x4e\x47\xec\x74\xc4\x4e\x47\xec\x74\xc4\x4e\x47\xec\x74\xc4\x4e\x47\xec\x74\xc4\x4e\x47\xec\x74\xf4\x3b\x1d\xe3\x9d\x81\xf1\xce\x40\xfc\x0c\xc4\xcf\x40\xfc\x0c\xc4\xcf\x40\xfc\x0c\xc4\xcf\x40\xfc\x0c\xc4\xcf\x40\xfc\x0c\xc4\xcf\x40\xfc\x0c\xc4\xcf\x40\xfc\x0c\xc4\xcf\x40\xfc\x4c\xc4\xcf\x44\xfc\x4c\xc4\xcf\x44\xfc\x4c\xc4\xcf\x44\xfc\x4c\xc4\xcf\x44\xfc\x4c\xc4\xcf\x44\xfc\x4c\xc4\xcf\x44\xfc\x4c\xc4\xcf\x44\xfc\x4c\xc4\xcf\x44\x7c\x37\xe2\xbb\x11\xdf\x8d\xf8\x6e\xc4\x77\x23\xbe\x1b\xf1\xdd\x88\xef\x46\x7c\x37\xe2\xbb\x11\xdf\x8d\xf8\x6e\xc4\x77\x23\xbe\x1b\xf1\xdd\x88\xef\x46\xfc\x2c\xc4\xcf\x42\xfc\x2c\xc4\xcf\x42\xfc\x2c\xc4\xcf\x42\xfc\x2c\xc4\xcf\x42\xfc\x2c\xc4\xcf\x4a\x0d\x4b\x73\xe6\x92\xe0\x6d\xee\xa9\xad\x6a\x69\xee\x60\xe9\xf1\x06\x67\xbb\x51\xe5\x45\x9e\xf2\x82\x60\xdd\x77\xae\x2e\xb5\x98\xbd\x7b\x63\x99\x88\xa5\x89\xa5\x85\xa5\x8d\xa5\x0b\xcb\x24\x2c\x93\xb1\x4c\xc1\x32\x15\xcb\x34\x2c\xd3\xb1\xcc\xc0\x32\x13\x4b\x37\x96\xc1\x68\x98\x89\x88\x9f\x88\xf8\x89\x88\x9f\x88\xf8\x89\x88\x9f\x88\xf8\x89\x88\x9f\x98\x1c\x31\x36\x74\xb6\x2e\x0f\x79\x81\x57\xa0\x25\x89\x68\x49\x22\x5a\x92\x88\x96\x24\xa2\x25\x89\x68\x89\x89\x96\x98\x68\x89\x89\x96\x98\x68\x89\x89\x96\x98\x68\x89\x89\x96\x98\x18\x09\x13\x23\x61\x62\x24\x4c\xc4\x37\x11\xdf\x44\x7c\x13\xf1\x4d\xc4\x37\x11\xdf\x42\x7c\x0b\xf1\x2d\xc4\xb7\x10\xdf\x42\x7c\x0b\xf1\xad\x24\x63\x76\x3c\xcc\xe8\x45\xde\xf2\x72\x3c\x82\x16\x58\x68\x81\x85\x16\x58\x68\x81\x85\x16\x58\x68\x81\x85\x16\x58\x68\x81\x8d\x16\xd8\x68\x81\x8d\x16\xd8\x68\x81\x8d\x16\xd8\x68\x81\x8d\x11\xb0\x31\x02\x36\xe2\xdb\x88\x6f\x23\xbe\x8d\xf8\x36\xe2\xdb\x88\x6f\x23\xbe\x8d\xf8\x2e\xc4\x77\x21\xbe\x0b\xf1\x5d\x88\xef\x42\x7c\x17\xe2\xbb\x10\xdf\x85\xf8\x2e\xc4\x77\x21\xbe\x0b\xf1\x5d\x88\xef\x42\x7c\x17\xe2\xbb\x10\xdf\x85\xf8\x49\x88\x9f\x84\xf8\x49\x88\x9f\x84\xf8\x49\x88\x9f\x84\xf8\x49\x88\x9f\x84\xf8\x49\x88\x9f\x84\xf8\x49\x88\x9f\x84\xf8\x49\x88\x9f\x84\xf8\x49\x88\x9f\x84\xf8\xc9\x88\x9f\x8c\xf8\xc9\x88\x9f\x8c\xf8\xc9\x88\x9f\x8c\xf8\xc9\x88\x9f\x8c\xf8\xc9\x88\x9f\x8c\xf8\xc9\x88\x9f\x8c\xf8\xc9\x88\x9f\x8c\xf8\xc9\x88\x9f\x8c\xf8\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\x98\x09\x98\xa9\x88\x8f\x19\x81\x89\x19\x81\x89\x19\x81\x89\x19\x81\x89\x19\x81\x89\x19\x81\x89\x19\x81\x89\x19\x81\x89\x19\x81\x89\x19\x81\x89\x19\x81\x89\x19\x81\x99\x8a\xf8\xb8\xd8\x31\xd3\x10\x1f\xb3\x02\x13\xb3\x02\x13\xb3\x02\x13\xb3\x02\x13\xb3\x02\x13\xb3\x02\x13\xb3\x02\x13\xb3\x02\x13\xb3\x02\x13\xb3\x02\x13\xb3\x02\x13\xb3\x02\x33\x0d\xf1\xd3\x10\x3f\x1d\xf1\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x33\x30\x31\x13\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x31\x03\x30\x91\xd1\x4d\x64\x74\x13\x19\xdd\x44\x46\x37\x91\xd1\x4d\x64\x74\x13\x19\xdd\x44\x46\x37\x91\xd1\x4d\x64\x74\x13\x19\xdd\x44\x46\x37\x91\xd1\x4d\x64\x74\x13\x19\xdd\x44\x46\x37\x91\xd1\x4d\x64\x74\x13\x19\xdd\x44\x46\x37\x91\xd1\x4d\x64\x74\x13\x19\xdd\x44\x46\x37\x91\xd1\x4d\x64\x74\x13\x19\xdd\xcc\x42\xfc\x2c\xc4\xcf\x42\xfc\x2c\xc4\xcf\x42\xfc\x2c\xc4\xcf\xca\x32\xf2\xcb\x3c\xf3\xbc\x40\x7d\xb3\x0c\xc9\xe9\x4e\x4d\x9e\xb3\x7a\x9b\x86\x5c\x93\x84\x1c\xb1\xb1\x74\x61\x99\x84\x65\x32\x96\x29\x8d\x0a\x7c\xbe\x39\x9e\x59\xbe\x79\xa1\xad\xd2\xb0\x4c\xc7\x32\x03\xcb\x4c\x2c\xdd\x58\x06\x63\x61\x21\x9f\x5b\xc8\xe7\x16\xf2\xb9\x85\x7c\x6e\x21\x9f\x5b\xc8\xe7\x16\xf2\xb9\x95\x88\x56\x24\xa6\x60\x99\x8a\x25\xe2\x23\x8b\x5b\xc8\xe2\x16\xb2\xb8\x85\x2c\x6e\x21\x8b\x5b\xc8\xe2\x16\xb2\xb8\x65\x9a\x11\xc0\x91\xb3\xbc\x45\xbe\xf9\xe7\x9c\x42\x2a\xb7\x90\xca\x2d\xa4\x72\x0b\xa9\xdc\x42\x2a\xb7\x90\xca\x2d\xa4\x72\x0b\xa9\xdc\x42\x2a\xb7\x90\xca\x2d\xa4\x72\x0b\xa9\xdc\x42\x2a\xb7\x90\xca\x2d\xa4\x72\x0b\xa9\xdc\x42\x2a\xb7\x90\xca\x2d\x0b\xf1\x2d\xc4\x47\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\x22\xb7\x90\xc8\x2d\x24\x72\x0b\x89\xdc\x42\xa2\xb6\x90\xa8\x2d\x24\x62\x0b\x89\xd8\x42\x22\xb6\x90\x88\xad\x64\xb7\xa8\xf0\x95\xf8\xca\x1b\xe5\x16\x7a\xcb\xbc\xe5\x85\xe5\xf2\x55\x58\x5a\x51\x69\x81\x47\x56\x0d\x4f\x89\xaf\xc2\x5b\xe4\x2d\xf4\x44\xb8\x4b\xcb\x0b\x61\xf5\x2e\x0f\xeb\xee\x0a\x3c\x3f\xc4\x87\xb5\x88\x51\xc5\x85\xce\xb3\x87\xe0\x8b\xf1\x21\x17\x87\x8d\x2a\xf6\xe6\x07\x2f\x8a\x2a\x84\xcb\xeb\x60\x09\x89\xc5\xd3\xbd\x15\x1e\x31\xc8\x03\x99\xb4\x86\x38\x7c\x32\x1c\x62\x80\x23\xc6\x15\x40\x8d\x3b\x40\x62\x98\xa7\xb4\xd4\xa3\x0e\xf7\x14\xcf\xca\xf5\xd0\x11\x95\x74\x64\x25\x9d\x58\xa8\x21\x32\x1d\x5d\xc8\xc6\x14\xf8\xc4\xd8\xc2\xfc\x62\x0f\x1b\xe7\xa9\xd4\xd0\x0a\x36\xba\xa0\x90\x65\xc0\xdf\xe8\xf2\xc2\x88\x21\x21\x16\x34\xc6\x0b\x6a\x5e\x87\x79\x6a\x1d\x8f\xf0\x86\xba\xeb\xad\x71\xb7\xb0\xc6\xdd\x66\x95\x75\x9b\x06\x9d\x91\xed\xf9\x2c\xc7\x99\x7c\xc7\x19\x91\xeb\x2d\xaa\xf0\x68\xa8\x8b\x2f\x72\x5c\x72\x4e\x56\x48\x97\x1c\x65\x62\x8e\x74\xa9\x28\xe8\x52\x49\x25\x5d\x50\xa8\xf9\x82\xfe\xb0\xb2\x02\x9f\x5a\xee\x38\x93\x28\x64\xc1\x2a\xc0\x27\xc4\x65\xa5\xe0\x4f\x0e\xfc\xc1\x4b\xe1\x73\x02\x1c\x11\x1a\xdb\xc6\xf5\xcc\x8b\xf0\x85\xf6\x4e\x65\x68\xef\xf8\x6a\x7b\x27\x38\x26\x90\x24\x2d\x24\x49\x0b\x49\xd2\x42\x92\xb4\x90\x24\x2d\x24\x49\x0b\x49\xd2\x42\x92\xb4\x70\x99\x6c\xe1\x32\xd9\xc2\x65\xb2\x85\xcb\x64\x0b\x97\xc9\x16\x2e\x93\x2d\x24\x55\x0b\x49\xd5\x42\x52\xb5\x90\x54\x2d\x24\x55\x0b\x49\xd5\x42\x52\xb5\x90\x54\x2d\x24\x55\x0b\x49\xd5\x42\x52\xb5\x90\x54\x2d\x24\x55\x0b\x49\xd5\x42\x52\xb5\x90\x54\x2d\x24\x55\x0b\x49\xd5\x42\x52\xb5\x90\x54\x2d\x24\x55\x0b\x49\xd5\x42\x52\xb5\x90\x54\x2d\x24\x55\x0b\x49\xd5\x42\x52\xb5\x90\x54\x2d\x24\x55\x0b\x49\xd5\x42\x52\xb5\x90\x54\x2d\x24\x55\x2b\x2b\x88\x6f\xe3\xc2\xd8\xc6\x85\xb1\x8d\x0b\x63\x1b\x17\xc6\x36\xd2\xa9\x8d\x74\x6a\x23\x9d\xda\x48\xa7\x36\x2e\x8c\x6d\x5c\x18\xdb\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\x48\xa4\x36\x12\xa9\x8d\x44\x6a\x23\x91\xda\xb8\x1c\xb6\x71\x39\x6c\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\x23\x87\xda\xc8\xa1\x36\x72\xa8\x8d\x1c\x6a\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x72\xac\x8d\x1c\x6b\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x72\xb0\x8d\x1c\x6c\x23\x07\xdb\xc8\xc1\x36\x2e\x86\x6d\x5c\x0c\xdb\xb8\x18\xb6\x71\x31\x6c\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x2e\x86\x6d\x5c\x0c\xdb\xb8\x18\xb6\x71\x31\x6c\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x2e\x86\x6d\x5c\x0c\xdb\xb8\x18\xb6\x71\x31\x6c\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x2e\x86\x6d\x5c\x0c\xdb\xb8\x18\xb6\x71\x31\x6c\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x2e\x86\x6d\x5c\x0c\xdb\xb8\x18\xb6\x71\x31\x6c\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x2e\x86\x6d\x5c\x0c\xdb\xb8\x18\xb6\x71\x31\x6c\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x2e\x86\x6d\x5c\x0c\xdb\xb8\x18\xb6\x71\x31\x6c\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x2e\x86\x6d\x5c\x0c\xdb\xb8\x18\xb6\x71\x31\x6c\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x2e\x86\x6d\x5c\x0c\xdb\xb8\x18\xb6\x71\x31\x6c\xe3\x62\xd8\xc6\xc5\xb0\x8d\x8b\x61\x1b\x17\xc3\x36\x3e\x26\xb7\xf1\x31\xb9\x8d\x8b\x63\x1b\x1f\x93\xdb\xb8\x48\xb6\x71\x91\x6c\xe3\x22\xd9\xc6\x45\xb2\x8d\x8b\x64\x1b\x17\xc9\x36\xf2\xbf\x8d\xfc\x6f\x23\xff\xdb\xc8\xff\x36\xf2\xbf\x8d\xfc\x6f\x23\xff\xdb\xc8\xff\x76\x66\x8a\xe1\xc9\x2b\x2c\x4c\xec\x9d\x52\x33\x33\x61\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\x60\x63\x06\xe0\xc2\x0c\xc0\x85\x19\x80\x0b\x33\x00\x17\x66\x00\x2e\xcc\x00\x5c\x98\x01\xb8\x30\x03\x70\x61\x06\xe0\xc2\x0c\xc0\x85\x19\x80\x0b\x33\x00\x17\x66\x00\x2e\xcc\x00\x5c\x98\x01\xb8\x30\x03\x70\x61\x06\xe0\xc2\x0c\xc0\x85\x19\x80\x0b\x33\x00\x17\x66\x00\x2e\x64\x74\x17\x32\xba\x0b\x19\xdd\x85\x8c\xee\xc2\x99\xc3\x85\x33\x87\x0b\x67\x0e\x17\xce\x1c\x2e\x9c\x39\x5c\x38\x73\xb8\x70\xe6\x70\xe1\xcc\xe1\xc2\x99\xc3\x85\x33\x87\x0b\x67\x0e\x17\xce\x1c\xae\xd4\x1a\x1c\xb4\x1b\x67\x0e\x17\xce\x1c\x2e\x9c\x39\x5c\x38\x73\xb8\x70\xe6\x70\xe1\xcc\xe1\xc2\x99\xc3\x85\x33\x87\x0b\x67\x0e\x17\xce\x1c\x2e\x9c\x39\x5c\x38\x73\xb8\x70\xe6\x70\xe1\xcc\xe1\xc2\x99\xc3\x85\x33\x87\x2b\x2d\x4b\x94\x17\x78\xe7\x79\xc2\x60\xed\xe0\xc9\x2b\xf7\xe6\xfb\x8a\x82\xd5\x52\x10\x05\xe1\xb2\x3a\xd7\x53\xec\xa9\x28\x17\x05\x85\x65\x85\x73\x45\x45\x39\x64\xe5\x42\x5e\x28\xe4\x35\x6a\xcd\x69\x1f\x2c\x04\x82\x4a\xd3\xd3\xd4\xb9\x95\xb3\x2a\x2b\xca\xd5\x5c\x4f\xbe\xb7\xbc\x40\x14\x7b\x2b\xbc\xf9\xa2\xd8\x33\xd7\x93\xc7\xcb\x3c\x79\x5e\x68\x59\xee\x9d\xab\x39\x5f\x3e\x74\xde\x22\x2f\x97\x85\x5e\xee\x03\xd4\xf2\xca\xb9\x46\x65\x69\xa9\xb7\x6c\x86\x73\xa8\xc8\x37\xdf\x5b\xe6\x7c\x66\x42\xea\xcd\x48\x0a\x0f\x82\xcd\x05\xe0\x12\xee\x29\xf2\xe6\x31\x58\xb0\x88\xfc\xc2\x62\x6f\x91\xc8\x85\xd7\x15\xb4\xc0\xcb\xe6\x79\xe6\x89\x45\x9e\x85\x85\x25\x0c\x96\x2a\xac\x02\xfe\x16\xfa\x72\xf5\xbc\xc2\x12\x4f\xd1\x1c\x4f\x1e\x83\x3f\x01\xa6\x7a\xf1\x50\xb1\xb7\x98\xc1\x5f\xf0\x45\x49\x65\x09\x83\x3f\xb5\x1c\xce\xcf\x29\xe0\x8e\x12\x4d\x9e\x28\xf5\xd2\x52\x6f\x98\xac\x56\x94\xc3\x52\x45\x48\xc9\xe6\xfa\xc0\x21\xf0\x90\x3b\xae\xc0\x1a\x67\x9e\x0a\xe0\xf3\x82\x05\x80\xaa\xf0\xe7\x14\xf9\xce\x4a\xa6\xc0\x80\xa2\xbc\x00\x74\xca\x30\x25\x66\x06\xef\x15\x28\x13\xb1\x34\xb1\xb4\xb0\xb4\xb1\x74\x61\x99\x84\x65\x32\x96\x29\x58\xa6\x62\x99\x86\x65\x3a\x96\x19\x58\x66\x62\xe9\xc6\x32\x2b\x58\x26\x22\x7e\x22\xe2\x27\x22\x7e\x22\xe2\x27\x22\x7e\x22\xe2\x27\x22\x7e\x22\xe2\x27\x22\x7e\x22\xe2\x27\x22\x7e\x22\xe2\x27\x22\x7e\x22\xe2\x27\x22\x7e\x22\xe2\x9b\x88\x6f\x22\xbe\x89\xf8\x26\xe2\x9b\x88\x6f\x22\xbe\x89\xf8\x26\xe2\x9b\x88\x6f\x22\xbe\x89\xf8\x26\xe2\x9b\x88\x6f\x22\xbe\x89\xf8\x26\xe2\x5b\x88\x6f\x21\xbe\x85\xf8\x16\xe2\x5b\x88\x6f\x21\xbe\x85\xf8\x16\xe2\x5b\x88\x6f\x21\xbe\x85\xf8\x16\xe2\x5b\x88\x6f\x21\xbe\x85\xf8\x16\xe2\xdb\x88\x6f\x23\xbe\x8d\xf8\x36\xe2\xdb\x88\x6f\x23\xbe\x8d\xf8\x36\xe2\xdb\x88\x6f\x23\xbe\x8d\xf8\x36\xe2\xdb\x88\x6f\x23\xbe\x8d\xf8\x36\xe2\xbb\x10\xdf\x85\xf8\x2e\xc4\x77\x21\xbe\x0b\xf1\x5d\x88\xef\x42\x7c\x17\xe2\xbb\x10\xdf\x85\xf8\x2e\xc4\x77\x21\xbe\x0b\xf1\x5d\x88\xef\x42\x7c\x17\xe2\x27\x21\x7e\x12\xe2\x27\x21\x7e\x12\xe2\x27\x21\x7e\x12\xe2\x27\x21\x7e\x12\xe2\x27\x21\x7e\x12\xe2\x27\x21\x7e\x12\xe2\x27\x21\x7e\x12\xe2\x27\x21\x7e\x12\xe2\x27\x23\x7e\x32\xe2\x27\x23\x7e\x32\xe2\x27\x23\x7e\x32\xe2\x27\x23\x7e\x32\xe2\x27\x23\x7e\x32\xe2\x27\x23\x7e\x32\xe2\x27\x23\x7e\x32\xe2\x27\x23\x7e\x32\xe2\xa7\x20\x7e\x0a\xe2\xa7\x20\x7e\x0a\xe2\xa7\x20\x7e\x0a\xe2\xa7\x20\x7e\x0a\xe2\xa7\x20\x7e\x0a\xe2\xa7\x20\x7e\x0a\xe2\xa7\x20\x7e\x0a\xe2\xa7\x20\x7e\x0a\xe2\xa7\x22\x7e\x2a\xe2\xa7\x22\x7e\x2a\xe2\xa7\x22\x7e\x2a\xe2\xa7\x22\x7e\x2a\xe2\xa7\x22\x7e\x2a\xe2\xa7\x22\x7e\x2a\xe2\xa7\x22\x7e\x2a\xe2\xa7\x22\x7e\x2a\xe2\xa7\x21\x7e\x1a\xe2\xa7\x21\x7e\x1a\xe2\xa7\x21\x7e\x1a\xe2\xa7\x21\x7e\x1a\xe2\xa7\x21\x7e\x1a\xe2\xa7\x21\x7e\x1a\xe2\xa7\x21\x7e\x1a\xe2\xa7\x21\x7e\x1a\xe2\xa7\x23\x7e\x3a\xe2\xa7\x23\x7e\x3a\xe2\xa7\x23\x7e\x3a\xe2\xa7\x23\x7e\x3a\xe2\xa7\x23\x7e\x3a\xe2\xa7\x23\x7e\x3a\xe2\xa7\x23\x7e\x3a\xe2\xa7\x23\x7e\x3a\xe2\x67\x20\x7e\x06\xe2\x67\x20\x7e\x06\xe2\x67\x20\x7e\x06\xe2\x67\x20\x7e\x06\xe2\x67\x20\x7e\x06\xe2\x67\x20\x7e\x16\xe2\x04\x73\xb2\x44\x37\xf2\x8c\x1b\x79\xc6\x8d\x3c\xe3\x46\x9e\x71\x23\xcf\xb8\x91\x67\xdc\xc8\x33\x6e\xe4\x19\x37\xf2\x8c\x1b\x79\xc6\x8d\x3c\xe3\x46\x9e\x71\x23\xcf\xb8\x91\x67\xdc\xc8\x33\x6e\xe4\x19\x37\xf2\x8c\x1b\x79\xc6\x8d\x3c\xe3\x46\x9e\x71\x23\xcf\xb8\x91\x67\xdc\xc8\x33\x6e\xe4\x19\x37\xf2\x8c\x1b\x79\xc6\x8d\x3c\xe3\x46\x9e\x71\x23\xcf\xb8\x91\x67\xdc\xc8\x33\x6e\xe4\x19\x37\xf2\x8c\x1b\x79\xc6\x8d\x3c\xe3\x46\x9e\x71\x23\xcf\xb8\x91\x67\xdc\xc8\x33\x6e\xe4\x19\x37\xf2\x8c\x1b\x79\xc6\x8d\x3c\xe3\x46\x9e\x71\x23\xcf\xb8\x91\x67\xdc\xc8\x33\x6e\xe4\x19\x37\xf2\x8c\x1b\x79\xc6\x8d\x3c\xe3\x46\x9e\x71\xff\x1f\x7b\xdf\x03\x26\x45\x75\xed\x79\xab\x6e\xf5\x4c\x77\xcf\x1f\x06\x1c\x79\x60\x80\x20\xf2\x65\x7d\x7e\x7e\x2e\xf4\xcc\xf4\x1f\x43\x58\x61\xa6\xae\x86\x10\x75\x09\x20\x1a\x12\x99\x61\x1a\x67\x74\x98\xc1\xf9\x83\x88\x46\x5d\xd7\x97\x97\xa8\x89\xc6\x24\xae\xeb\xba\x2e\xeb\xb2\x88\x13\x97\xe7\xe3\xb1\xac\xcf\xc7\xf2\xd4\xf8\x07\xf3\x18\x48\x10\xc4\x04\xf4\xc9\x9f\xc1\x51\x51\x10\x07\x44\x42\xa8\x3d\xf7\xd4\xaf\xbb\xaa\xab\xbb\x71\xd0\x67\x36\xd9\x6f\xbf\xf9\xee\xbd\xe7\xde\x3a\xf7\x9c\x73\x7f\xf7\x56\x9d\x73\xab\xaa\xa7\xe0\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x86\x9f\xb1\xe1\x67\x6c\xf8\x19\x1b\x7e\xc6\x4e\xa8\x92\xab\xf8\x59\x67\xc9\x4d\x6e\x71\x95\xfb\x92\xe3\x4d\x5c\x44\xae\xca\xdc\x60\x8f\xdc\x94\xa1\xdc\x7e\xf0\x33\x36\xfc\x8c\x0d\x3f\x63\xc3\xcf\xd8\xf0\x33\x36\xfc\x8c\x0d\x3f\x63\xc3\xcf\xd8\xf0\x33\x36\xfc\x8c\x0d\x3f\x63\xc3\xcf\xd8\xf0\x33\x36\xfc\x8c\x0d\x3f\x63\xc3\xcf\xd8\xf0\x33\x36\xfc\x8c\x0d\x3f\x63\xc3\xcf\xd8\xf0\x33\x36\xfc\x8c\x9d\xb2\x23\xd3\x32\xcf\x2b\x23\x8d\x19\x2a\x3a\x2d\xfb\x64\x36\xda\x98\x25\xab\xa6\x79\x2f\x7d\x32\x0c\x55\x8d\xc1\x06\x1f\x07\xc3\xe6\xe7\xe0\x86\x6a\x1f\x47\x56\x70\x75\x63\x81\x46\xbf\x2c\x7e\xb2\xec\x97\xc5\x0d\x67\xf9\x38\x32\x96\x9f\xd5\x98\xdf\x56\xe6\xbe\x24\xee\xbe\x90\xd6\xe8\xa3\xdd\x76\xb6\x0b\xed\x4c\x0f\x73\xdb\xb3\x96\x0c\x6b\xcc\xad\xa3\x1f\xdb\x80\x7e\x4c\x57\xba\xed\x19\xb5\x95\x8d\x39\xd5\x88\x9d\xa5\xb2\x6d\x51\xdb\xc3\xd9\x93\x5f\x62\xbb\x2f\xf9\xba\x52\xab\xec\x20\xc8\xe9\x60\x83\x1d\x44\x3d\x1d\x44\xdd\x2e\x84\x7a\xba\x10\xea\x76\x10\xf5\x74\x10\x75\xbb\x00\xea\xe9\xfc\xb6\xe8\xd7\xbd\xb1\xb5\x66\xc9\xc8\xd7\xb3\x28\xb4\x66\xa9\x2b\xb2\x54\x47\xb6\xf7\x15\x5e\xef\x0e\xcf\xba\x2b\x82\x43\xef\x08\x36\x5c\x11\xc4\xa2\x23\x88\xc5\x15\x85\xb0\xe8\x28\x84\xc5\x15\x41\x2c\x3a\x82\x58\x5c\x51\x00\x8b\x8e\x02\x58\xf0\x0b\xc0\xee\x8b\x93\x1d\x1e\xc9\xad\x6c\x94\xdb\xca\x64\x25\xb7\x66\x8d\xa8\xec\xc8\xa9\xba\x7d\x58\xb9\xdb\x87\xc9\x0a\x6e\xcd\x68\xab\xe8\xf0\xd7\x22\x73\xb2\x54\x4f\xd6\x9e\x39\x9e\xc0\x1e\x8f\x9c\xe3\x99\xd6\xe3\x91\x73\x3c\x2b\x7b\x3c\x2b\xe7\xe4\x5a\xd9\x93\x6b\xe5\x1c\xcf\xca\x1e\xcf\xca\x39\x39\x56\xf6\xf8\x6b\x25\x57\xbb\x97\xd9\x9b\xb9\x88\x5c\x9d\xb5\xf9\xe6\xac\xcd\x57\x7b\xe2\x6f\xf6\xce\x95\xab\xdd\x73\xe5\x66\xf7\x85\x78\x7d\x4d\x53\x88\xd9\x14\x62\x36\x85\x98\x4d\x21\x66\x53\x88\xd9\x14\x62\x36\x85\x98\x4d\x21\x66\x53\x88\xd9\x14\x62\x36\x85\x98\x4d\x21\x66\x53\x88\xd9\x14\x62\x36\x85\x98\x4d\x21\x66\x53\x88\xd9\x14\x62\x36\x85\x98\x4d\x21\x66\x53\x88\xd9\x14\x62\x36\x85\x18\x4d\x21\x46\x53\x88\xd1\x14\x62\x34\x85\x18\x4d\x21\x46\x53\x88\xc9\x14\x62\x32\x85\x98\x4c\x21\x26\x53\x88\xc9\x14\x62\x32\x85\x98\x4c\x21\x26\x53\x88\xc9\x14\x62\x32\x85\x98\x4c\x21\x26\x53\x88\xc9\x54\x2c\xa3\x0f\xe3\x43\x4c\xa6\x10\x93\x29\xc4\x64\x0a\x31\x99\x42\x4c\xa6\x10\x93\x29\xc4\x64\x0a\x31\x99\x42\x4c\xa6\x10\x93\x29\xc4\x64\x0a\x31\x99\x42\x4c\xa6\x10\x93\x29\xc4\x64\x0a\x31\x99\x42\x4c\xa6\x10\x93\x29\xc4\x64\x0a\x31\x99\x42\x4c\xa6\x10\x93\x29\xc4\x64\x0a\x31\x98\x42\x0c\xa6\x10\x83\x29\xc4\x60\x0a\x31\x98\x42\x0c\xa6\x10\x73\x29\xc4\x5c\x0a\x31\x97\x42\xcc\xa5\x10\x73\x29\xc4\x5c\x0a\x31\x97\x42\xcc\xa5\x10\x6b\x29\xc4\x58\xaa\x2e\x23\x17\xf6\x23\xa6\x52\x88\xa9\x14\x62\x2a\x85\x98\x4a\x21\xa6\x52\x88\xa9\x14\x62\x2a\x85\x98\x4a\x21\xa6\x52\x88\xa9\x14\x62\x2a\x85\x98\x4a\x21\xa6\x52\x88\xa9\x14\x62\x2a\x85\x98\x4a\x21\xa6\x52\x88\xa9\x14\x62\x2a\x85\x98\x4a\x21\xa6\x52\x88\xa9\x14\x62\x2a\x85\x98\x4a\x21\xa6\x52\x88\xa9\x14\x62\x2a\x85\x98\x4a\x21\xa6\x52\x88\xa9\x14\xf6\xea\x0a\x7b\x75\x85\xbd\xba\xc2\x5e\x5d\x61\xaf\xae\xb0\x57\x57\x88\xa1\x14\x62\x28\x85\x18\x4a\x21\x86\x52\x88\xa1\x14\x62\x28\x85\x18\x4a\x25\x33\xfa\x30\x5e\xc4\x50\x0a\x31\x94\x42\x0c\xa5\x10\x43\x29\xc4\x50\x0a\x31\x94\x42\x0c\xa5\x10\x43\x29\xc4\x50\x0a\x31\x94\x42\x0c\xa5\x10\x43\x29\xc4\x50\x0a\x7b\x75\x85\xbd\xba\xc2\x5e\x5d\x61\xaf\xae\xb0\x57\x57\xd8\xab\x2b\xec\xd5\x15\xf6\xea\x0a\x7b\x75\x85\xbd\xba\xc2\x5e\x5d\x61\xaf\xae\xb0\x57\x57\xd8\xab\x2b\xec\xd5\x15\xf6\xea\x0a\x7b\x75\x85\xbd\xba\xc2\x5e\x5d\x61\xaf\xae\xb0\x57\x57\xd8\xab\x2b\xec\xd5\x15\xf6\xea\x0a\x7b\x75\x85\x3d\xba\xc2\x1e\x5d\x61\x8f\xae\xb0\x47\x57\xd8\xa3\x2b\xec\xd1\x15\xf6\xe8\x0a\x7b\x74\x85\x3d\xba\xc2\x1e\x5d\x61\x8f\xae\xb0\x47\x57\xd8\xa3\x2b\xec\xd1\x15\xf6\xe8\x0a\x7b\x73\x85\xbd\xb9\xc2\xde\x5c\x61\x6f\xae\xb0\x37\x57\xf5\xd0\x5b\x0f\xbd\xf5\xd0\x5b\x0f\xbd\xf5\xd0\xdb\x00\xbd\x0d\xd0\xdb\x00\xbd\x0d\xd0\xdb\x00\x7d\x0d\xd0\xd7\x00\x7d\x0d\xd0\xd7\x00\x7d\x0d\xd0\xd7\x00\x3d\x0d\xd0\xd3\x00\x3d\x36\xf4\xd8\xd0\x63\x43\x8f\x0d\x3d\x36\xc6\x67\x63\x5e\x6d\xe8\xb5\xa1\xd7\x86\x5e\x1b\x7a\x6d\xe8\xb5\xa1\xd7\xc6\x38\x6d\xe8\xb7\xa1\xdf\x86\x7e\x05\x7d\x0a\xfa\x14\xf4\x29\xe8\x51\xd0\xa3\xa0\x47\x41\x8f\x82\x1e\x05\x3d\x0a\x7a\x14\xf4\xb8\xf7\x40\x62\x93\x5c\x3f\x4a\xe5\x64\x94\x31\x94\x35\x28\x6b\x51\xd6\xa1\x8c\xa3\x4c\xa0\x4c\xa2\x4c\xa1\x9c\x86\x72\x3a\xca\x7a\x94\x0d\x28\x33\x7a\x95\x5b\x4e\x86\xbe\xc9\x90\x3f\x39\x5e\xc1\xff\xf6\x8e\x7f\x14\xda\xdc\xd4\x56\x71\x63\x4f\x87\xfe\x27\xab\xfa\x77\xa2\xe9\x66\xf0\xa0\x6f\x0c\xba\x62\xd0\x15\x83\xae\x18\x74\xc5\xa0\x2b\xa6\x4a\x16\xb7\xb6\xf3\x4f\xf5\xd2\x0b\x3b\xda\x21\xa5\xa6\x36\x92\x5e\xb6\xb0\xad\x71\x31\x69\x89\x74\x36\x36\xeb\x7f\xe5\x98\x5e\xe6\x1e\xab\x43\xcf\x38\x34\xc4\xa1\x21\x0e\x0d\x71\x68\x88\x67\xf8\x54\xf9\xa2\x8e\x9e\xce\xae\x9e\x25\xe9\xce\xd6\x8e\xce\xf2\x45\xad\x4b\xd3\x99\x4a\x45\x17\x19\xdf\x9e\xad\xa5\xf5\xbf\x32\xce\xd4\x22\xd9\x76\x57\x4e\x0a\xb3\x91\xc2\x6c\xa4\x80\x4e\x0a\xb3\x91\xc2\x6c\x4c\x03\xdf\x34\xf0\x4d\x8b\x59\x6d\xad\x9d\x8d\xa8\x00\xca\x69\xf1\x92\x25\xe9\xae\x74\x77\xa6\x19\x33\x35\x2d\x55\xd2\xd5\x92\xbe\x31\xdd\x66\x35\x77\xb4\x5f\x67\xe9\x7f\x28\x89\x03\x18\xd4\x34\x0c\x6a\x1a\x60\x9e\x0e\x65\xd3\xa1\x6c\x3a\x8c\x9a\x0e\xa3\xa6\xc3\xa8\xe9\xd0\xeb\x3e\x62\x8d\x4d\xc6\x92\x99\xec\x86\x44\x54\xc6\x51\x26\xe4\x15\x2d\x8b\x23\xe9\xae\xee\xd6\xc5\x8d\xdd\x98\xd4\xc9\xae\x63\xa6\xd2\x0e\x77\xb4\xa7\xbb\x5b\x5a\x3b\x9b\x23\xdd\x37\x75\x30\xd1\x15\xa1\x26\x06\xae\xa5\xbc\xbb\xa5\x33\x0d\xba\xab\x4c\xe3\x0c\xba\x9c\x61\x46\xc5\x15\x95\xac\x8d\x34\x76\x76\x76\xdc\xd4\x96\x5e\xd4\x5d\xca\x54\xcf\x92\x28\x97\xfc\xff\xa4\xdd\x83\xcd\x1d\x37\xb5\xbb\x54\x13\x29\x8b\x80\xad\xb9\xbd\x3c\x4b\x35\x75\x71\xcc\x19\xc3\xcf\x94\x62\xb1\xc9\x75\xd1\x8e\xce\xee\x16\xfd\x4b\xca\xc6\xb6\xf2\xd6\xf6\x6e\xbd\x36\xf9\xdf\xf8\x96\xa5\x6f\xec\x69\x5d\x4a\xeb\xa8\x7d\x61\x3a\xd4\xd2\xd1\xd3\x95\xae\xa0\xa5\xdb\xd6\x71\x9d\x5e\x5c\xed\x1d\xdd\x51\xcd\x4c\xd1\x6f\x5b\xf7\x92\x2c\xd9\xc4\x0f\xef\x62\x78\x32\x1c\xc3\x13\xe1\x18\x9e\xe4\xc6\xf0\xc4\x96\xca\x5a\x94\x49\x94\x38\x1e\x43\x3b\x56\x7f\x5d\x0d\xea\x35\xa8\xd7\xa1\xbf\x1b\xe9\x50\x09\xf9\x6e\xa4\x43\x25\xf8\xdd\x48\x87\xca\x38\xca\x04\x4a\xe8\x73\x23\x1e\x2a\xa7\xa1\x9c\x8e\x32\xa3\xa7\x01\xa5\x8d\xd2\x5d\x3e\x75\x71\xe8\x8f\x43\x7f\x1c\xfa\xe3\xd0\x1f\x87\xfe\x38\xf4\xc7\xa1\x3f\x0e\xfd\x71\xe8\x8f\x43\x3f\xce\xc9\x3a\x9c\x93\x75\xfa\x9c\x5c\xd2\xd4\xd6\xb1\xf0\x86\x52\x9a\x2b\x5d\x86\xdc\x5a\xdb\x22\xb7\xec\xec\x46\xbd\xbb\xab\xa5\xb1\x39\x1d\xe2\xbc\xb4\xf9\x06\x2e\x23\x8b\x5a\xdb\xda\xe8\x42\xd3\xe1\x9e\xf9\x78\xbe\x1c\xc3\xf3\x61\x2a\xa7\x47\x5d\x8e\x4e\x9a\xe1\xd2\xee\xce\xd6\xc6\xeb\x7a\x96\xb8\x65\x27\xea\xcd\xed\x6e\xd9\xb6\xa8\x44\xef\x0a\xdb\xdc\xd5\x52\x57\x0f\x5c\xea\x55\xa4\xb5\x7d\x69\x53\x0f\x09\xe9\xd6\x94\xcb\x13\xed\x58\x92\x6e\x47\x63\xd7\xe2\x56\x5a\xa2\x8d\x0b\xd3\xb4\x96\x96\x66\x2b\xb2\xab\xa7\xbd\x64\x51\x7a\x31\xad\x26\x4b\x67\xa1\xae\x25\x64\xaf\xb5\xb0\xad\xa7\x29\xd4\x92\x6e\x24\xed\xcd\xad\x8d\x8b\xe9\x72\x56\xb6\xb8\xa7\x0b\xeb\x2b\x5d\xe9\xa3\xe9\xba\xc6\x16\xc4\xdd\x98\x30\x56\x8f\x99\xa8\xc7\x4c\xd4\x63\x26\xea\x31\x13\xf5\x98\x89\x7a\xcc\x44\x3d\x66\xa2\x1e\x33\x51\x8f\x99\xa8\xc7\x4c\xd4\x63\x26\xea\x31\x13\xf5\xb8\x3a\xd6\xe3\xea\x58\x9f\x80\x9e\x04\xf4\x24\xa0\x27\x01\x3d\x09\xe8\x49\x40\x8f\x1b\x7b\xc6\x70\x5f\x7b\x5a\x22\x5b\x26\x51\xa6\x50\x4e\x43\x39\x1d\x65\x3d\xca\x06\x94\x36\x4a\xe5\x96\xee\x5e\x8a\xca\xc9\x6e\x99\x84\xbc\x24\xe4\x25\x21\x2f\x09\x79\x6e\xac\xa9\xe0\xfb\x14\x7c\x9f\x82\x6f\x53\xf0\x6d\x0a\xbe\x4d\xc1\xb7\x29\xf8\x36\x0a\xc1\x1a\x50\xda\xe5\xee\xf3\xed\x6b\xf9\x45\x80\x61\x74\xda\xa7\x69\xc3\xad\xff\xbb\xb0\x7e\x70\x1e\xd6\xcf\xe7\x6f\x6a\xa5\x35\xc8\x4f\xe6\x35\x55\xd2\x92\xd6\x45\xe9\x0d\x8d\xee\x01\x7e\x0c\xaf\xa9\xf2\xcc\xa3\x78\x5d\x09\xeb\x87\xe5\xcc\xd7\xdd\xb8\x94\x8f\x92\xe4\x6b\x97\xb4\xf5\x74\xe9\xff\x59\x5b\xa6\x1f\xb5\xe3\xcd\x81\x28\xd3\x4c\x0e\xe7\x26\x7e\xdd\x00\x07\xab\x7c\x2d\xdc\x10\xd1\x06\xb1\xa9\x51\x4d\xb9\xaf\x12\x70\xe3\xe2\xc6\x25\xad\x37\x46\x9a\xd2\xdd\x2e\x7b\x19\xbf\x50\x00\x9a\x8d\x77\xe9\x70\x4b\xda\x25\x22\x4b\x1b\x97\xe2\x30\xbf\x68\x80\xd6\xee\x0c\x63\x84\x40\x71\xa9\xca\xcc\x6b\x07\x38\x90\xa5\xca\x78\xec\x68\xa5\x81\x83\x6a\xef\x81\xb0\x72\xf7\x15\x04\xb7\x52\x81\x77\x10\x60\x46\x86\x28\xe3\x97\x10\xd0\xf3\xc6\x0e\x48\x8e\x6a\xf8\x40\x7a\x10\x44\xba\x33\x26\x87\xc9\x78\xf7\x65\x0d\x1a\xb0\x7e\x1b\x43\x4f\x87\x2e\xc9\x9d\xea\x82\x11\x61\xeb\x78\x9a\xf1\xf8\x44\xe1\xf1\x89\xc2\xe3\x13\x85\xc7\x27\x8a\x42\x2f\xab\x9d\x4e\x74\xb9\xa4\x75\x72\xc5\xc2\x9b\x3b\xe9\x6a\xd2\xba\x90\xef\x1a\x56\xf1\x0f\xff\x7d\xbf\x31\x1d\xee\xa3\x3b\xf5\xdb\xe8\xe9\x28\xdf\x2a\xb9\x88\xe6\x77\xb2\x47\xc6\x3c\xb2\x26\xca\xf7\x6f\x5c\x86\x2c\x19\xf3\xc8\x9a\xca\xec\x6d\x14\x66\xca\xad\xc6\x72\xab\x35\x51\xbe\xc3\xe2\x4a\xcb\x92\xb1\x28\x5b\xcb\xad\xc3\xbc\xfb\x5e\x5c\xaf\xc8\xdc\xb9\x09\x58\x50\xeb\x91\x75\x9e\xb5\xb5\x1e\x59\x97\xab\xb9\x36\xb7\x5a\xe7\x69\xf7\xd9\x54\xeb\x91\x3e\x86\xb8\x47\x26\x3c\x32\x99\x63\x59\x2c\xa7\x56\x93\x53\xab\xcd\xa9\xd5\xe5\xd4\x7c\xb2\x53\x39\x07\x12\x39\xb5\x5c\x65\xa9\xca\x1c\x50\x26\xe5\x56\x27\xe7\x56\x63\xb9\xd5\x9a\xdc\x6a\x6d\x6e\xb5\xae\xcc\x9b\x9f\x49\x3e\x7a\xb2\x8f\x8e\xf9\x68\x1e\xa8\xfe\x29\x6f\xab\x3b\x79\xb4\x1c\xf5\x4f\xb2\xf4\xcf\xb6\x2e\x5a\xd8\xb8\xc4\x57\x9f\x1c\xa8\xd7\x07\xea\x93\x7c\xf5\x44\xa0\x7f\x4d\x4e\x3d\x66\xd7\x21\xc5\x03\xf5\x44\xa0\x9e\x0c\xd4\x53\xbe\x7a\x5c\x97\x81\x7a\x3c\x50\x4f\x04\xea\xc9\x40\x3d\x55\xe6\xab\xfb\x8e\x25\x02\xb2\x13\x05\x8e\x27\x02\xf5\x64\xa0\xee\x97\xed\xe7\x4d\x06\x64\x27\x03\xb2\x93\x05\xf8\x93\x81\xba\x5f\xb6\xff\x58\x2a\x20\x3b\x15\x90\x9d\x0a\xc8\x4e\x15\xe8\xef\x97\x9d\xc1\x3b\x9e\x99\x83\x40\x3d\x1e\xa8\x27\x02\xf5\x64\xa0\x9e\x91\x1d\x0f\xc8\x2a\x54\x4f\x04\xea\xc9\x40\xdd\x6f\x5b\x22\xd0\x3f\x11\xb0\x2d\x11\x90\x97\x08\xc8\x4b\x04\x6c\xf3\xf3\x26\x03\xb2\x93\x01\xd9\xc9\x02\xfc\xc9\x40\xdd\x2f\xdb\x7f\x2c\x15\x90\x9d\x0a\xc8\x4e\x05\x64\xa7\x0a\xf4\xf7\xcb\xce\x60\x92\x08\xcc\x57\x22\x30\x5f\x89\xc0\x7c\x25\x02\xf3\x95\x08\xcc\x57\x22\x20\x2b\x5e\xa0\x1e\x0f\xd4\x13\x81\x7a\x32\x50\xf7\xcb\xf6\xf7\x0d\xea\x2a\x74\x3c\x19\xa8\xfb\xc7\x9d\x0c\xf4\x4f\x06\xfa\x27\x03\xb6\x25\x03\xf2\x92\x01\xdb\xfc\xc7\x52\x01\xd9\xa9\x80\xec\x54\x40\x76\xaa\x40\x7f\xbf\xec\x8c\xdd\xc9\xc0\x7c\x25\x03\xf3\x95\x0c\xcc\x57\x32\x30\x5f\xc9\xc0\x7c\x25\x03\xb2\xe2\x05\xea\xf1\x40\x3d\x11\xa8\x27\x03\x75\xbf\x6c\x7f\xdf\x44\x40\x76\xa2\xc0\xf1\x44\xa0\x9e\x0c\xd4\xfd\xb2\xfd\xbc\xc1\x71\x04\x75\x17\xe2\xf7\x63\x9a\x0a\xf4\x4f\x05\xfa\xa7\x02\xfd\x53\x01\xdb\x52\x01\xdb\x32\xb2\x53\x81\xf9\x4a\x05\xe6\x2b\x15\x98\xaf\x54\x60\xbe\x52\x81\xf9\x4a\x05\x64\xc5\x0b\xd4\xe3\x81\x7a\x22\x50\x4f\x06\xea\x7e\xd9\xfe\xbe\x89\x80\xec\x44\x81\xe3\x89\x40\x3d\x19\xa8\xfb\x65\xfb\x79\x93\x01\xd9\xc9\x80\xec\x64\x01\xfe\x64\xa0\xee\x97\xed\x3f\x16\xc4\x28\x38\xae\xa0\x2d\x6e\xff\x4c\x34\x7d\x6d\x47\xb7\xfe\xd4\x52\xc4\x8d\x53\xa9\x15\x91\x49\x6d\x20\x72\xa9\x0d\x44\x3a\x35\x05\xea\x49\x5f\x7d\xb2\x8e\x76\x7c\xf5\xfa\x40\xbd\x36\xc3\x5f\xde\xd4\xd8\xd9\x9a\xf9\xbf\x29\x67\xf1\xc1\xe9\x93\x5d\x86\xc9\x5a\xe8\xa4\x02\x6d\x93\x03\x6d\xb5\x05\xf8\x6a\x03\x7c\xf1\x02\xf2\xe2\x05\xe4\xc5\x0b\xc8\x8b\x07\xe4\xa5\x0a\xd8\x97\x2a\x60\x5f\xaa\x80\x7d\xa9\x02\xf6\xa5\x0a\xd8\x97\x2a\x60\x5f\xaa\x80\x7d\xa9\x7c\xfb\xea\xeb\xf2\xed\xcb\x69\x0b\xf2\xd5\x16\xe0\x0b\xca\x8b\x17\x90\x17\x2f\x20\x2f\x5e\x40\x5e\x21\xfc\x92\x99\x45\x56\xa0\x2d\xc8\x17\x2f\xc0\x17\x0f\xe8\x0d\xc8\xcb\x69\x0b\xf2\xc5\x0b\xf0\xb1\x3c\xfd\xbf\x09\xba\xd3\xcd\xad\xbc\x03\x0b\xdb\xed\xd7\x71\xf0\x9f\x21\x62\x19\xa2\x26\xbc\x3c\xdd\xd9\xa1\xa9\xd2\x8e\x76\xde\x2f\x94\x76\xdf\xc4\xf5\x08\xdf\x63\xd5\x54\x58\xdf\xd5\x76\x89\x56\x77\x67\x56\xda\xd5\xca\x3b\xbf\x08\xdf\x6e\x65\x8a\xef\xb9\x32\x53\x7b\xab\x2b\xa8\x2c\x7b\x3b\xfd\x22\xbe\xad\x36\x09\xf7\x96\xc9\xba\x54\xe9\x9c\xcb\xbf\xae\x6f\xa5\x0e\x0b\xbc\xd4\x31\x2c\xf0\x0a\x47\x65\xee\xcb\x1a\xc3\x02\x6f\x65\x44\xbd\x57\x7c\xa2\xde\x5b\x3d\x91\xec\x4b\x3c\x51\xef\x95\x9d\x2a\xde\xab\xf3\x8e\x1e\xbb\x7e\xaf\x21\x7b\xfb\xc1\xbd\xd9\x51\x91\xa9\xf2\x6f\x3e\xce\xca\x6e\xf4\xbd\x1f\x7f\x54\x66\xdb\x02\x55\xfe\xdd\x47\x95\xef\x16\x0f\xb7\xf2\x8d\x14\xdc\x8c\xd0\x00\xd4\xd1\xa9\x58\x37\xbd\x01\x74\xcc\x47\xd7\x68\xda\xfa\xd6\xb5\xd3\x6d\xca\x66\xeb\xec\x4a\x5b\xe0\x0b\x99\x61\x61\x8a\x6a\x61\x38\x8e\xfe\xf6\x23\x7f\xaf\x52\x88\x65\xe2\x0e\xfe\x42\xcf\x70\x21\xac\x4d\xc2\xb0\x5e\xb1\x8e\x0a\x69\x1d\xb3\x8e\x11\xfd\xb1\xf5\x31\xd1\xc7\xad\xe3\x44\x7f\x62\xfd\x81\xe8\x53\xd6\x29\xa2\x1d\x8b\x24\x84\x44\xb8\x4f\x18\xe1\x2d\xe1\x2d\x42\x86\xb7\x86\x3f\x21\xfa\x44\xf8\x84\x30\xc3\xbf\x8f\x96\x0b\x23\x5a\x11\x1d\x26\x4c\xfd\xbf\x3b\x89\x1e\x11\xad\x16\x32\x7a\x76\xf4\x2f\x48\xab\xe5\x7e\x0f\x88\xf5\x67\x52\x54\x34\x89\x07\x85\x45\x17\xdc\x36\x71\xce\x75\x9d\xe9\x1b\x44\xac\x25\xdd\xd4\x29\xa6\xb6\x35\x76\xb7\xeb\xcf\x0b\x09\xf3\x9b\xdf\x68\x18\x2f\xaa\xbe\x35\x6b\x3a\xe5\x42\xd0\x08\x0c\xfe\x5a\x90\x00\x2d\xb2\xb4\xc9\x5f\x12\xca\x39\xb2\x70\xe1\xe2\x25\xe2\x1c\xce\xc7\x37\xb7\xb5\x5e\x27\xce\x6f\xeb\x58\xa8\x3f\x62\x24\xb2\xf6\xe8\x6f\x0f\xe9\x5a\xc6\xa2\x12\xc2\x66\xa4\x18\x27\xbe\x42\x5c\x71\xb4\x4e\x22\x5e\xcd\xa1\x50\xce\x25\x2e\x2a\xcd\x51\x2c\xc3\x30\x67\xb9\xed\xa5\x1b\x49\x5a\x95\x08\x45\xcf\x16\xef\x8b\x19\xd1\xbf\x88\xea\x2f\x88\x86\xe4\x5e\xfe\xc2\xc2\x61\xf9\x11\xd5\x46\x50\x0a\x6b\xdd\x1a\xaf\x50\xb9\xee\x15\x22\x09\xc6\x23\x62\xb4\x48\x8a\xe9\x34\xe2\xb9\x62\x81\xb8\x5e\x74\x8b\xdb\xc4\x0f\xc4\xc3\x62\xa5\x58\x23\x9e\x15\xbf\x13\xfb\x89\x31\x6a\x54\x1b\xe3\x8c\xf3\x8d\x98\x31\xc5\x50\xc6\x95\xc6\x03\x5a\x4e\x74\x84\x30\x69\xde\x34\x75\x56\x96\xaa\xce\x52\xc3\x89\x1a\x64\x7d\x7b\xb2\xd4\xde\x2c\xb5\x2f\x4b\xed\x67\xca\xa4\x71\x95\x87\x8f\x11\xfd\x61\xb8\x3f\x7b\xec\x40\x96\x7a\xdb\xc7\x35\xa0\x69\x5a\x07\xa6\x75\x90\xd7\x57\xa5\xa8\xa6\xd9\x37\xad\x81\x68\x19\xe5\x87\xc3\xef\x64\x7b\xbd\xcb\x94\xe6\xa9\x12\x23\xa3\x11\x5a\x4b\x83\xd6\x87\xd1\x28\x6b\x79\x2f\xcb\x75\x30\x4b\xbd\x9f\xa5\x3e\xc8\x52\x87\xb2\xd4\xe1\x2c\xf5\x61\x96\x3a\x92\xa5\x3e\x62\xaa\x94\x34\x8d\xe2\x6f\x8b\x4e\xa2\x39\x9c\x12\x7e\x83\x74\x9e\x20\x6b\xdf\x60\xdd\x27\xf4\xd7\x50\x69\x55\x0f\x72\x39\x68\x7d\x12\x1e\xe4\xb1\xec\xa2\xfc\x44\xf8\x77\x94\x7f\xc2\xb2\x8e\x62\xb4\xa5\xd6\x3b\xd6\x7b\xfa\x73\xb2\xa1\x12\x5a\xfb\x61\x9a\xb5\x68\xa8\x32\x54\x29\xf8\x0b\x07\xa2\x4a\x7f\xe1\x40\x8c\x08\x8d\x0c\x9d\x43\x67\x98\xe4\x35\x55\x2d\x26\x90\x84\x0b\x79\xf5\x84\xf4\x1a\xe0\x6f\x25\x94\x85\xaa\x43\x63\xf5\xea\xe5\x6f\x2b\x7c\xac\x57\x1e\xb5\x8f\x15\x22\xfc\xa3\xf0\x8f\xc4\xb8\xf0\x6f\xc2\xaf\x8b\x2f\xd3\x7a\xb8\x9e\xfa\x54\x19\x13\xcc\x5a\xa9\xac\x79\x62\x8c\xb8\x98\xd6\xc5\x0c\x31\x4b\x5c\x43\xe7\xca\xf5\xa2\x53\x2c\x17\x77\x8a\xbb\xc5\x03\xb4\x3a\x1e\x13\xbd\x62\xad\x78\x46\x3c\x2f\x7e\x25\xb6\xd1\x2a\xd9\x2b\xde\x15\x47\xc4\x09\x5a\x2b\x25\x46\x79\xe4\x5b\x42\x9a\xbf\x30\x7f\x11\x99\xc5\x65\x6f\xe4\xdf\x72\xf9\x44\xe4\x4a\x2e\x57\x47\xae\xe0\xf2\xf1\xc8\x37\xa9\xec\x25\xbe\x99\x5c\xf6\x46\xbe\xc1\xe5\x13\x91\x19\x5c\xae\x8e\x7c\x9d\xcb\xc7\x23\x97\x52\xf9\x04\xf1\x29\x2e\x7b\x23\x36\x97\x4f\x44\x1a\xb8\x5c\x1d\xa9\xe7\xf2\xf1\xc8\x34\x2a\x57\x13\xdf\x25\x5c\xf6\x46\xfe\x0d\x97\x4f\x44\xa6\x72\xb9\x3a\xf2\x35\x2e\x1f\x8f\x4c\xa1\xf2\x71\xe2\xfb\x2a\x97\xbd\x91\x8b\xb9\x7c\x22\x92\xe2\x72\x75\xe4\x72\x61\x52\xeb\x6c\xca\x7f\x11\x99\x4e\xf9\xea\xc8\x65\x94\x3f\xf1\x39\x10\xe9\x00\x22\xed\x40\x64\x31\x10\x69\x03\x22\x37\x00\x91\x56\x20\xd2\x02\x44\xae\x03\x22\x8b\x80\x48\x1a\x88\x2c\x04\x22\x4d\x40\xa4\x11\x88\x2c\x00\x22\xd7\x02\x91\xef\x02\x91\xef\x00\x91\xf9\x40\xe4\xdb\x40\xe2\x6a\x20\x31\x0f\x48\x5c\x05\x24\xe6\x02\x89\x39\x5c\x3e\x1e\x59\xc2\x58\x34\x6b\x14\x22\xd7\x50\xfe\x78\xe4\x7a\x8d\xd1\xe7\x40\xe4\x1e\x20\x72\x37\x10\xf9\x21\x10\xf9\x01\x10\xf9\x6b\x20\xf2\x57\x40\xe4\x2e\x20\xf2\xef\x81\xc8\x9d\x40\xe4\xdf\x01\x91\x3b\x80\xc8\xed\x40\xe4\x36\x20\xf1\x3d\x20\x71\x0b\x90\x58\x0e\x24\x6e\x06\x12\xcb\xb0\x36\x6e\x02\x22\x3d\x40\xa4\x1b\x88\x74\x01\x91\x4e\x20\x72\x23\x10\xf9\x3e\xaf\x91\x7b\x19\x97\xa5\x8c\xc8\xad\x7a\xa5\x7c\x0e\x44\x1e\x07\x22\xab\x80\xc8\x7f\x07\x22\x2b\x81\xc8\x7f\x03\x22\x8f\x01\x91\xff\x0a\x24\x56\x00\x89\xff\x02\x24\xfe\x33\x90\x78\x04\x48\xfc\x27\xac\x8d\x87\x81\xc8\x7f\x04\x22\xff\x01\x88\x3c\x08\x44\x7e\x0e\x44\x7e\x06\x44\x7e\x0a\x44\x7e\x02\x44\xee\x07\x22\xf7\x01\x91\x1f\x03\x91\x1f\x01\x91\x47\x79\x75\xac\x66\x44\x1e\x60\x44\x1e\xfa\x9c\x88\xbc\x00\x24\x7e\x09\x24\x9e\x07\x12\xcf\x01\x89\x7f\x04\x12\x1b\xb1\x36\xfe\x37\x10\xd9\x00\x44\xfe\x01\x88\xfc\x3d\x10\x79\x1a\x88\xfc\x2f\x20\xb2\x1e\x88\xfc\x4f\x20\xf2\x77\x40\x64\x2d\x10\xf9\x5b\x20\xf2\x14\x10\xf9\x1b\x20\xf2\x3f\x80\xc8\x93\x40\xe4\x17\x40\xa4\x17\x88\x3c\x01\x44\x9e\x61\x44\x9e\xe5\x95\xb2\x86\x11\x59\xc7\x88\x50\xbc\xa0\xfb\xb3\x87\x9f\xa1\xaf\xb9\x74\xd5\xbe\x90\xfc\xc5\x25\xf0\x70\xff\xcc\x7e\xec\x4d\xca\x0f\xb1\x3f\xa0\x2b\x36\x5d\xb5\x35\x75\x3c\x4b\x7d\x92\xa5\xb6\x82\xcf\x7f\xad\xcf\xc4\x38\xb3\xc5\xbd\x39\x31\xce\x57\x38\xc6\x89\x71\x8c\x33\xb5\x60\x2c\x93\x4b\x1b\x39\xed\xe6\x0d\x14\x20\x8a\x4a\xbd\x5f\x25\x4f\xc3\xdf\x45\xa7\xbc\xea\x53\xbf\xa4\x38\x5a\xd4\x8a\x29\xa2\x81\x62\x8c\xd9\x62\x3e\x7f\x3b\xf5\x0e\xf1\x63\xf1\x08\xc5\x18\x4f\x8a\x75\x34\xf3\xef\x8a\x41\x71\xd2\xb0\x8c\x72\x8a\x33\xc6\x18\x13\x8d\x0b\x8d\x5a\x37\xae\x31\xc2\x1c\xb3\x18\x72\x35\xd5\x4b\xa9\xdc\xee\xb6\xcb\x13\x6e\x69\xfd\xca\x2d\xa3\x77\xbb\xb1\x4d\xd5\xfa\xe1\xe1\xe1\xd7\x0c\x7f\xd2\xad\x0d\x3f\x3c\xa2\x65\xc4\xbb\x67\xb5\xb9\xb5\xb3\x5e\xab\x3e\xbf\x7a\x79\xf5\x66\xb7\x76\x76\xd5\xd9\x0f\x8c\x8c\x8e\xbc\xd7\xed\x3f\xf2\x98\x5b\x8e\x5e\xe3\x96\x63\xae\x61\xae\xf0\x97\x4b\xbe\xdc\xfd\xe5\x2d\xe3\xcf\x1f\x7f\xe7\xf8\xdd\xe7\xc6\xcf\xbd\x9f\x5b\x2b\xce\xdd\x7c\xee\xc9\x09\x17\x4e\x98\x3f\xe1\xde\x09\x1b\x26\x1c\x3c\x6f\xcc\x79\x33\xcf\xbb\xf5\xbc\x27\xcf\xdb\x3d\xb1\x9c\x8f\x9b\x13\xc7\x4c\x9c\x41\x78\x10\x3d\xb1\x9d\x31\x34\x6a\xda\x5c\xb9\x35\xdd\x6e\x19\x1f\xef\x96\xa9\xb7\xdc\xf2\x6b\x63\x5c\xbe\x4b\x76\xa3\xdc\xcf\x31\xa5\x31\x4d\xc7\x78\x0f\x9a\x24\xc5\x7c\x84\xd0\x9c\x49\x67\xcc\x0a\xb1\x8a\x50\x5b\x2b\x9e\x16\x1b\xc5\x0b\x84\xdd\xaf\xc5\x6b\x62\x37\x9d\x37\x03\xe2\x03\x42\x11\x67\x8e\x31\xc2\x18\x45\x11\xdb\x44\xe3\x02\x63\x92\x11\xa7\xa8\x6d\xba\x71\x99\x71\xb9\x31\xdb\xb8\xc6\x58\x60\x2c\x32\xda\x8c\x4e\x63\x99\x71\x9b\x71\x97\x71\xb7\x71\xbf\xf1\xa0\xf1\x88\xf1\x98\xb1\xda\x58\x63\xac\x33\x9e\x31\x9e\x35\x5e\x32\x36\x1b\xdb\x8c\xd7\x8d\x37\x8d\xfd\xc6\xbb\xc6\x61\xe3\x98\x71\xd2\x34\xcd\xb0\x59\x69\x56\x9b\xe7\x98\xe3\xcd\xaf\x98\x17\x9a\x31\x33\x69\x4e\x35\x1b\xcc\x19\xe6\x95\xe6\x5c\x73\x3e\xd9\xda\x1c\x8a\x51\x3e\x85\xf3\x3b\x39\x1f\xc7\xb9\xdb\xbe\xc2\x47\x2f\xe3\xfc\x4a\x1f\xff\x38\x8f\x76\x16\xf8\xf8\xa7\xf8\xf2\x65\x3e\x09\xcd\x3e\x09\xfe\x76\x3f\x67\x75\x9e\x3d\x22\x4f\x66\xb3\xaf\xbd\x39\xcf\xe6\x7c\x7b\xaa\x7d\xd2\xdc\xa3\x7b\xf3\xe8\xe6\xbc\xbc\x18\x26\xe3\x7c\xd6\x4e\xf1\x59\x92\x8f\x86\x5f\x42\xfe\xd8\xa7\xe4\xc9\xf4\xf1\x3b\x07\xf3\x46\xcd\xed\xa7\x9e\xa5\xd8\x11\x39\x7a\xe9\x9c\xae\x3f\x39\x91\xe1\x56\xba\xba\x7c\x99\xe3\xc3\xf1\xe1\xdf\xd1\x35\xe7\xfc\x68\x84\x62\xed\xcb\xf8\xdc\xfb\x50\xb8\xbb\x16\x6d\x77\x35\xef\xee\x46\x09\xbd\xcf\x70\xaf\x3d\xc3\xc1\x43\xfb\x22\x92\x48\x57\x91\x50\x09\xc5\xa9\x21\xfd\x0d\x2e\x71\x0e\x4b\xd4\x6b\x7e\x8c\xd0\x3b\x95\x09\xa2\x9c\xaf\x34\x86\x39\x8f\xed\x31\x48\xb7\xee\xfd\x49\x56\x43\x2f\x5b\xf8\x92\x78\x94\xf2\xcd\xc4\x3d\x82\x76\x49\x17\x8a\x18\xed\x5c\xa6\xd2\x75\x65\x86\xb8\x92\x76\x2f\xf3\xc9\xbb\xb4\xf0\x07\x6b\x97\xd3\xf5\xe5\xfb\x74\xe5\x23\x79\xe6\x3c\xca\xef\xd0\x39\x5d\xbe\xe6\x65\x5a\x5c\xda\xcd\x9d\x2d\x72\x7c\x26\x07\xff\x18\x83\x6c\x31\x6e\xf5\xf8\x8d\x95\x9c\xaf\x31\x37\x70\xae\xdb\xdb\x74\x2e\xc7\x1b\x83\x99\x9c\x22\xf1\xd2\x50\x45\x68\x58\x68\x44\xe8\x6c\xf7\x5b\x63\x84\xa1\xf7\x15\x13\xfd\x0d\x93\xdf\x51\xa4\xaf\xc7\x35\x98\x1d\x57\xb5\x96\x48\x3b\xdf\x2d\xb4\x27\x1b\xa3\xcf\x70\xda\x63\x25\x8d\xa9\x46\x83\x31\x83\xf6\x59\x73\x8d\xf9\x46\x93\xd1\x62\xb4\x1b\xdd\xc6\x72\xe3\x0e\xe3\xfb\xc6\xbd\xc6\x03\xc6\x43\xc6\xa3\xc6\x4a\xa3\xd7\x78\xca\x58\x6f\x6c\x30\x9e\x37\x36\x19\x5b\x8c\xed\xc6\xef\x8c\xb7\x8c\x03\xc6\x41\xe3\x88\x71\xdc\x38\x65\x5a\x66\xd4\xac\x32\x47\x9a\x63\xcc\x09\xe6\xf9\xe6\x45\x66\xad\x79\xb1\x79\x89\xa9\xcc\x99\xe6\x2c\x1a\xd1\x77\xcd\x66\xf3\x7a\x73\x89\xb9\xd4\xbc\xd5\xbc\xd3\xfc\x81\xf9\x63\xf3\x67\xe6\xc3\xe6\x0a\x73\x95\xf9\xa4\xb9\xd6\x7c\xda\xdc\x68\xbe\x60\xfe\xca\xfc\xb5\xf9\x9a\xb9\xdb\xdc\x6b\x0e\x98\x1f\x98\x83\xe6\x09\x29\x64\x89\x2c\x97\x23\xe4\x28\x39\x4e\x4e\x94\x17\xc8\x49\x32\x2e\xa7\xc8\xe9\xf2\x32\x79\xb9\x9c\x2d\xaf\x91\x0b\xe4\x22\xd9\x26\x3b\xe5\x32\x79\x9b\xbc\x4b\xde\x2d\xef\x97\x0f\xca\x47\xe4\x63\x72\xb5\x5c\x23\xd7\xc9\x67\xe4\xb3\xf2\x25\xb9\x59\x6e\x93\xaf\xcb\x37\x69\x5f\xfa\x2e\xed\x4b\x8f\xc9\x93\x96\x69\x85\xad\x4a\xab\xda\x3a\xc7\x1a\x6f\x7d\xc5\xba\xd0\x8a\x59\x49\x6b\xaa\xd5\x60\xcd\xb0\xae\xb4\xe6\x5a\xf3\xad\x26\xab\xc5\x6a\xb7\xba\xad\xe5\xd6\x1d\xd6\xf7\xad\x7b\xad\x07\xac\x87\xac\x47\xad\x95\x56\xaf\xf5\x94\xb5\xde\xda\xc0\x6b\x26\xa6\xf3\x92\x16\x9a\x9b\xa7\x35\x6d\x3c\xcd\xf4\x6c\xa6\x67\x33\xbd\x99\xe9\xcd\x9a\x36\x27\x31\xff\x24\x4d\x8b\xdd\xbc\xae\x76\x33\xcf\x25\xcc\x73\x09\xf3\xf8\x64\xfa\x69\x71\x98\xf9\x0f\x07\x65\xe6\xc8\x0f\x33\x7f\xf8\x74\x72\x0c\x8b\xf9\xad\xa0\x9d\x7e\xdb\x72\x68\xbf\x4c\x3f\x5d\x8c\xc7\xd7\x9e\x63\xdb\x71\x6e\x3f\x9e\x67\x4f\x91\xb1\xe4\xf4\x2d\xc2\x5f\xb4\xbd\x98\x0d\x45\xf0\x29\x26\x33\xc7\xe6\xa1\xd0\x45\x30\xff\xa2\xd7\xc9\xe7\x59\x1b\x45\xd7\x40\xb1\x79\xff\x3c\x73\x6d\x85\x0e\x67\xc7\xf2\x74\x68\x77\x16\x87\x95\x4c\xaf\x64\x7a\x50\xd3\xa7\xd7\x5b\x64\x8c\x43\xf7\x20\xc3\xb3\xdf\x8c\xd4\x5f\x8c\xdc\xce\x5f\x8a\xfc\xad\xf5\x16\x7f\x17\xf2\x6d\xeb\x63\xeb\x64\x78\x8b\xbe\x43\x28\x94\x10\x7c\x3f\x6e\x16\xa5\x79\x94\xbe\x4b\x49\x7f\xd3\xfb\x7a\x4a\x4b\x28\x2d\xa5\x74\x2b\xa5\x3b\x29\xfd\x80\xd2\x8f\x29\xfd\x8c\xd2\xc3\xda\x6f\x53\xb9\x8a\xca\x03\x21\xc5\x7e\x4a\xb1\x2f\x51\x8c\x82\xd7\xe2\xe6\x2b\x74\xee\x3c\x92\xd7\xee\xe6\xd5\x39\x2d\x77\xea\xdc\x3a\xa8\xf3\x92\x4a\x6e\x59\x97\xbd\x8e\x5f\xf4\xff\xaf\xe3\x9f\xed\x3a\xce\x77\x34\x39\x37\x9e\xf6\xe5\xb3\xbd\xdc\xfc\x35\xd3\xf7\x33\x3d\xc9\xcb\x0d\xfe\x9a\xbb\x11\xf7\xd1\xa3\x3c\x69\xf9\x39\x45\xcc\xd9\xdc\x95\x56\x20\xf7\xeb\xbd\xa3\x70\xee\x2c\xf0\xf2\xa2\x7a\xfd\x76\x6e\xf6\xe5\x83\x5e\x6e\xee\x0f\xb6\xa0\x7d\x83\x47\x53\x7c\xe2\xb5\xfb\xe5\xfb\xad\x1a\xe3\xe5\xf9\xd2\xf2\xfb\x16\x6b\x2f\x8a\xf3\x10\xf0\xc9\xb1\xd3\x6f\x5b\x91\xb9\x28\x96\x1b\xee\x1d\xee\x79\xce\x96\x2c\xdd\xa4\xe9\x2f\x7a\x9d\xe4\xac\x8d\x95\xbe\x7c\x08\x63\x2f\x26\xb3\xd8\xbc\xe7\xcf\xb5\x9b\x0f\x65\xae\x73\xc6\xe2\xc7\xc1\x6f\xa7\x5f\xcb\xec\x22\xb9\x9f\xdf\x1b\xef\xd0\xaf\xe3\xe7\x58\xaf\x58\x5b\xac\x57\x73\xbe\xf0\xbb\xb7\xc0\x37\x7d\x3f\xb2\x8e\x5a\x7f\xb0\x1c\xf7\xbb\x6a\xe2\x1c\x31\x94\x2b\xb8\xc0\x15\x5c\xd0\x9e\x57\x7f\xf5\x51\x08\x3d\xc6\x8d\x94\x5e\xa0\xf4\x2b\x4a\x7a\xa6\x5f\xa3\xa4\xe7\x6b\x2f\x59\x33\x40\xe5\x07\x94\xf4\x98\x4f\xe8\x89\xd4\xb1\x3d\x3f\x81\x7a\x44\x8f\x8d\xf2\x71\x94\xbf\xa0\x5b\xa8\xae\xe9\xbd\x3a\x17\x82\x8f\xee\x45\xae\xdb\x9f\xe2\x5e\x19\x7a\x1c\xcb\xf1\xf2\xa7\x98\x73\x15\xe7\x2f\xf8\x5a\x32\xb9\xd7\xf2\x02\xaf\xa7\x75\x42\x04\x24\xe8\x5c\xf2\x1e\xc8\x60\x6b\x78\x07\xc8\xcf\x69\x4c\xeb\x63\xf2\x7d\x45\xee\xd2\x8b\xca\xd3\xf9\x4d\x92\x68\x92\xc4\x29\x2c\x53\x04\x24\x7e\x5a\xdf\xc2\x1a\x3f\xc5\x46\x5e\x19\x82\xd7\x84\xc1\x6b\xe2\xdc\x2f\xda\xc6\x02\x1a\xb5\x8d\x33\x60\xe3\x02\x96\x78\x16\xe5\xa3\xcf\x60\x65\x66\xd6\x65\x31\xd4\xa3\x85\x64\xfd\x11\xf4\x0e\xfb\x94\x7e\xff\xa2\x16\x14\x9c\xcb\xff\xfb\x16\x14\xc3\xde\xe4\xfb\x8a\xde\x2a\xaa\xfe\xd4\xd5\x73\xfa\x73\x4b\x8f\xa4\x16\x23\x99\x31\x44\x89\xc5\xe6\xcd\xd5\xf3\x39\x6d\x2c\xb2\xd2\x3f\x83\x8d\x05\x71\xf5\x6c\x9c\x21\xda\x7c\x36\x9e\xfd\x19\xe7\xef\xd3\xd7\x4a\x31\xdc\xb5\x05\x4d\xff\x22\x16\x14\x5e\x2b\xa7\xd3\xfb\x47\x1b\x79\xc1\xd9\xfc\x23\x8c\xbc\xd0\xdc\xe3\xae\xf2\x8a\x3f\xf1\xbb\xca\xd8\x53\xf3\xee\xf2\x42\xa6\xd7\x31\x3d\x8a\xe9\x4d\x5e\x3b\x8e\x1e\xf6\xda\x91\x73\x8b\xf3\x54\x1e\xcf\xe1\x60\x0b\x64\x1e\xce\xcb\x7d\x5a\xfc\x32\x73\x5a\x36\x9d\x8e\x33\xc7\xe6\x7c\x7b\x36\xe5\xd9\x36\xa5\x08\x9d\x97\x9f\x1e\x93\xd3\xa3\x51\x80\x33\x6f\x5c\x45\x47\xed\x5a\xb5\xc2\x97\xbb\x92\x27\x7a\xb9\x4f\xef\xd0\x63\x49\x69\xfd\xc6\xda\x63\x1d\xe0\xb7\x19\x2a\xf9\xda\x26\x28\x52\x2c\xb0\x1f\xc7\xfa\x7d\xf4\x4f\x7b\xfd\xca\x93\x7c\xbf\x64\x03\x23\xf7\xb0\xce\xe5\x78\xce\xef\xf2\xad\xdc\xfb\xbd\x16\x97\xdf\x6d\x97\xe5\x5e\xee\x4a\x70\x8f\xfa\x79\x8c\x16\x5f\xdf\xbb\x7c\xf2\x7d\x5a\xe4\x7c\xce\x2f\x63\x39\xfb\x75\x1e\xe2\xd9\x93\xdb\xdd\xfb\x43\xc1\x5c\x0e\xf8\xb4\xfb\xec\x77\xa5\xb9\x12\xfc\xf6\xb8\x2d\xae\xb4\xd0\x6e\x4f\xbe\x9f\xf6\x5b\x5e\x00\x93\xf2\x22\x98\xf8\x46\xea\xf2\xfb\x73\x1c\xf5\x23\xe0\x43\xec\xf4\xa3\x76\xef\xff\x61\x2c\xfb\x3d\xc4\x72\xe4\x7b\xd2\x86\xbe\x7e\x4d\x6b\x87\xf5\x3a\xbf\x6b\x16\x15\xfa\xc9\xa8\x7e\xaa\xa2\xf8\x7c\xf9\xf3\x59\xb3\x03\xbc\xc7\xfc\x7b\xce\xdd\x9d\xec\x0a\xde\x93\xfe\x8c\xf7\x86\x7f\xc1\x7e\xea\x30\xb7\x3c\xc3\xf9\xdf\x78\xfb\x1b\xb9\x9d\xf9\x9f\xf3\x76\xac\x16\xbf\xc7\x26\x9f\xe5\xbe\xfc\xc4\xdb\xf8\x39\xb7\xb8\xfb\xdc\xf9\x9c\xb3\x46\x39\xdd\xb7\xe7\x75\x7c\x7b\xde\xe3\x2c\x27\xc9\x3c\x6f\x71\xcb\x1b\x9c\x0f\xf8\xf6\xcb\x3e\xda\x92\x3e\x9b\x7f\xc8\xf4\xce\xa0\x3d\xae\x4c\xf9\x9e\x27\x39\x3f\x97\x27\x83\x79\x0e\x26\x3f\xf7\xe4\x1b\x86\x0f\x93\xd3\xa2\x01\x1c\x5c\xdb\xfe\xd6\x37\xf6\x91\x22\xbb\xeb\x2f\x30\xea\x9d\x9e\x16\xd8\xc0\x32\x65\x99\x08\xdc\x1f\x70\x35\x72\x7e\x26\x6b\x76\x9b\xd5\x9f\xb3\x66\x85\x38\x9f\x77\xbe\x51\xec\xd4\xa6\xfa\xe2\x93\x91\xd9\x1e\x9f\x1e\xf3\x18\x62\x64\xc8\x0c\xc9\x50\x28\x54\x12\x8a\x84\xca\x43\x55\xa1\x51\xe1\x6d\xfc\x2c\x4c\x7f\xbb\x5f\x7f\xb9\x7f\x20\xfc\x5e\xf8\xfd\xf0\x47\xe1\x63\xfa\xfb\xeb\xa4\x4d\xd2\x9e\x78\xa2\xb8\x40\xf7\x2c\xa0\xcf\xe0\x3b\xae\x86\x35\xf0\x05\x48\x3e\xfa\x05\x4b\x3e\xf8\x85\x49\x7e\xff\x0b\x93\x7c\xe8\x0b\x93\x7c\xf8\x33\x48\xd6\x2b\x71\x42\x91\x95\xe8\xca\x3d\x73\x89\xae\xa5\x19\x89\xfa\x5d\xe1\x12\x8e\xa2\xdd\x08\xfa\x68\xce\xfc\x0d\x95\x7f\x17\x66\xe5\xcc\xe4\x0f\x9d\xdf\x95\xff\xc1\x90\xf9\xb7\x9d\x21\xff\x16\xcc\xfd\x50\xf9\x07\x30\xa3\x43\xe5\x3f\x78\x86\xfc\x5b\xce\x90\x7f\xdb\x19\xf2\xef\x3a\x43\xfe\xdd\x67\xc8\x7f\xd4\xc7\x3f\x81\xae\xac\x26\xad\xdc\x31\xe8\x31\xca\x27\xf1\x0d\x91\x79\xab\xc2\x08\x8d\x18\x22\xf7\x20\xb8\x8d\x4a\xf7\x6d\xae\x26\xb1\x45\xec\x17\xef\x1a\x55\x14\x33\x4c\xa1\x38\x61\x81\xd1\x6b\x0c\x98\xe3\xf8\x59\xd1\xbd\xf4\xf7\xa0\xb9\x42\x3f\x11\x92\x17\xc8\x79\x72\xa9\xbc\x5f\xf6\xca\x01\xcb\xb4\x46\x59\x17\x59\xb5\xd6\x9a\xd0\x98\xd0\x05\xa1\xda\xd0\x77\x43\x2d\xa1\x8d\xa1\x17\x4a\x2a\x4b\xaa\x43\x1b\x4b\xa6\xd2\x5f\x43\xc9\xe5\xd4\x42\x7f\x25\xb7\x96\xdc\x5d\x72\x7f\xc9\x83\x25\x03\xa5\xe7\x94\xb6\x95\x6e\x29\xdd\x5e\xfa\x41\x58\x84\x2f\x08\x5f\x12\x5e\x14\x7e\x3a\x7c\x2c\xd2\x1c\xf9\x20\x3a\x2a\x7a\x51\x34\x19\x6d\x8f\x3e\x14\x7d\x3e\xba\xb9\xcc\x2c\x3b\xbf\x2c\x56\xd6\x50\xb6\xbc\xec\x91\xb2\x97\xca\x8e\x97\x8f\x2b\x9f\x59\xbe\xbc\x7c\x75\xf9\xf3\xe5\xc7\x2b\x46\x56\x4c\xa9\x98\x5b\xd1\x52\xd1\x59\xb1\xb2\xe2\x57\x15\xfb\x2b\x4e\x54\x8a\xca\x11\x95\xe7\x8b\x90\x98\xe8\xec\x92\x5f\xa5\xd4\x40\xe9\x52\x4a\x97\x3b\x7a\x96\xaa\x9d\x16\x11\x11\x92\xe8\x84\xb3\x4e\xa4\x9c\x87\xc5\xc5\x54\x4e\x71\xee\x13\x57\x53\xba\x86\xd2\x7c\xe7\xbe\xd2\xfd\xd4\x26\xc5\xb0\x53\xc7\xc5\x70\x4a\x13\x29\x95\xa2\xcf\x4e\xea\xb3\x0e\x7d\x76\x12\xef\x2f\x99\xd7\xe2\xa3\x7e\x7e\x8b\xf8\x76\x11\xdf\x2e\xe2\xdb\x45\x7c\xbb\xc4\x08\x97\x87\xf4\x57\x51\x1a\x4e\x69\x2c\x69\x1b\xe7\xdc\x42\x96\xb6\x88\x18\x1d\x6b\x70\x1a\x84\xa2\x74\x19\xa5\x99\x74\x6c\x16\x95\x73\xa8\x9c\x4b\xe5\x3c\xb6\xae\x85\x24\xb5\x88\x61\x59\x6d\x55\xd4\xaa\x35\x8e\x25\x29\xe3\xe8\x88\x2b\xe9\x97\x24\x69\x2c\x49\x19\x4b\x52\x5a\x48\xca\x58\x92\xd2\x42\x12\x74\xef\x06\x51\x41\x36\x34\x50\xcf\x75\x64\x43\x03\x7a\x6a\x1b\x6e\x64\xfd\x41\xdd\xf3\x18\x91\x06\xfd\x0e\x1e\xf7\x6a\x39\x4d\xaf\x16\xee\xf5\x2d\x4a\xb3\x49\xe7\x3c\x2a\xaf\xa6\x64\x94\xee\x17\x1b\x44\x19\xf5\x1f\x4b\xfd\x77\x52\xff\xb1\x34\xca\x75\xe2\x52\x4a\x97\x51\x9a\x41\xe9\x1b\x34\x9e\x59\x54\xce\x76\xd6\x11\xf7\x4c\x5a\xb1\xc3\x80\x91\xa6\x68\x8c\x94\xa2\x7a\xd4\xf2\x1b\xce\x2a\x39\x8b\xd2\x5c\x67\x9d\xbc\xca\x99\x27\xe7\x11\xfd\x1d\x2a\xd3\xce\x4a\xd9\xe1\xdc\x27\x6f\x76\x56\x52\xf4\x72\x95\xf3\x24\xad\xf9\x87\x9c\xf5\xb2\x5e\x7c\x95\x56\x40\x8a\x56\x40\x17\xf5\x5d\x4f\xab\x20\x45\xfd\xd7\x53\xbf\xbf\x96\xdf\x75\x94\x5c\xe0\xac\x90\x8d\xce\x43\x72\x21\xd1\x8b\x9c\x1e\xd9\x4a\xf5\x1b\xa8\xde\x46\x65\xbb\xd3\x22\x6f\xa4\xf6\x1e\x4a\xcb\x28\xdd\x4a\xb2\x6e\x73\x14\x8d\x65\x88\x96\xf0\xda\x28\xa5\x99\x3a\x41\xb3\x74\x82\x6c\x99\x2b\x1b\x4e\xbd\x21\x2f\xa5\x74\x39\xa5\x1b\x68\x54\x25\x90\xf5\x5b\x92\xf5\x5b\x92\xf5\x5b\x92\xd5\x45\x72\xba\x44\x09\xd9\xbd\x8a\xec\xee\x23\x9b\xb5\x96\x5d\x7a\x54\x74\xe4\x49\x31\x8c\xf8\xef\x23\xfe\xfb\x48\xe7\x3c\x1a\xc5\x8b\x64\xfd\x8b\x64\xfd\x8b\xb2\x85\xd2\xf5\x94\x96\x50\xba\x91\x52\x0f\xa5\x65\x94\x6e\xa1\x74\x1b\xa5\x3b\x9c\x17\xb3\x1a\x73\xad\x27\xcb\x45\x28\x47\x63\x46\x5b\x28\x6b\x7f\x03\xa5\x4b\x9d\x99\x64\xfb\x09\xc2\x78\xa9\xf3\x8c\x7e\xfa\x40\x33\x97\xbb\x9e\xef\xa3\x71\x5e\x43\x92\x5a\x88\x77\x15\xe9\xd1\x67\x5e\x0b\xe9\xda\x45\xd6\xee\x92\xdf\xa6\xa4\x71\xbf\xd6\x79\x94\x31\x4f\xd3\xb1\x45\x54\x5e\x47\xa9\x95\xfa\x12\x26\x84\xfb\x7d\x84\x60\x2e\xf6\x37\x53\x7d\x39\xb5\x13\xfe\xf2\x76\xd2\xf3\x25\x5a\x17\x0a\x9a\x15\x69\xfe\x1e\x69\xfe\x5e\x60\xb6\x77\x61\xb6\x77\x15\x9c\xed\xb4\xf3\xd8\x90\x67\x5c\x32\x32\x57\x39\x4d\x84\x48\x93\x30\x09\xcf\x3e\xc2\xb2\x4f\x44\x49\xea\x2a\x92\xb6\x8a\x24\xad\x22\xe4\xfb\xa8\xf7\x2a\xea\xbd\x8a\x7a\xaf\x22\xae\x55\xd4\x7b\x15\x71\xae\xa2\x3e\x57\x39\xbf\xa1\xde\xbf\x11\x67\x9f\x91\x95\x43\xb5\xd0\x20\x84\x76\x8a\x11\xd4\xff\x1e\xea\xbf\x91\xfa\xde\x43\x23\x7c\x98\xfa\xaf\xa6\xfe\x1b\xc9\xb6\xd5\x24\x63\x23\xc9\xd8\x48\xd8\x3e\x4c\x32\xee\x91\x9d\xce\x33\x24\xe7\x1e\x9a\xc9\x2e\x92\x75\x0f\xd9\x7b\x0f\xc9\xba\x87\xec\xbd\x87\xe4\xdd\xe4\xbc\xc1\xe3\xeb\x25\x59\xbd\x24\xa7\x97\x56\x57\x2f\xad\xac\x5e\xea\xdb\x2b\xbb\x29\xf5\x50\x5a\x46\xe9\x36\xa7\x97\xf8\x5b\xc4\xb9\x34\xca\xc5\xce\x0e\xb6\xa4\x8c\x7a\xee\xa0\x9e\x3b\xa8\xe7\x0e\xea\xb9\x83\x7a\xed\xa0\x5e\x3b\xa8\xd7\x0e\xea\xb5\x83\xb4\xed\xa0\x9e\x3b\x48\xdb\x0e\x7d\xad\x75\x6e\xa7\x99\x5c\x24\xc6\x8a\x1a\x7d\xc5\x70\xc2\x9c\xcf\x14\xd5\xf2\x45\x31\x56\x6e\x72\xfa\xe5\x66\x67\xa7\xdc\xea\xac\x95\xbf\x26\x94\xb7\x51\x7a\x95\xe8\xed\xce\xed\x72\x07\x21\xf3\x3a\x95\x6f\xd2\xa8\xf6\x38\x7b\xe4\x5e\x4a\x07\x28\x1d\xa2\x74\x84\xd2\xa0\xb3\x41\x1e\xa5\xf2\x94\xb3\x87\x24\x4e\x16\xe5\xf2\x39\xe7\x15\x92\x3a\x5a\xbe\x2c\x6a\xe4\x26\x31\x93\xa4\xac\x21\x29\xaf\xc8\xd7\x48\xcb\xeb\x54\xbe\xe9\xec\x93\xfd\x74\x7c\xd0\x79\x9b\x1c\xe2\xbf\x26\x1b\x9e\x23\x5d\x2f\x3a\x3f\x95\x2f\x13\xe7\x26\x42\x6d\x2b\xcd\xc4\x36\x4a\xaf\x12\x5a\xdb\x9d\x59\xd4\xfb\x27\xd4\xbb\x8f\x7a\xff\x95\xdc\x45\x2b\xfb\x2d\x3a\xa6\x25\xbc\x4f\x12\x3f\x62\x49\xfb\xe4\x31\x4a\xc7\xc5\x68\x92\x38\x9a\xbc\xb0\x6f\xbc\x24\x7d\x11\xd9\xf1\xaf\x68\x84\xfd\xb2\x8f\xa4\x6c\xa5\xf2\x2d\x4a\x7b\x88\xde\x47\x9a\xfb\x69\x6d\x1c\x70\x7e\x29\xdf\xa1\xab\xc3\x41\xb2\xe2\x7d\xb2\xe2\x03\xaa\x1f\x72\x1e\x94\x1f\x3a\x2f\x93\xf4\xd5\xf2\x24\xb5\xff\x81\x10\x70\x9c\x5b\x2c\xe1\xac\xa1\xf9\xd8\xe4\xec\xa3\x6b\xc8\x56\x6a\xdf\x46\x69\x3b\x59\xfd\x3a\xa5\x43\x24\x77\x90\x3c\x84\x25\x5f\x25\xbb\xb6\xf3\x88\x1f\x26\x5b\xbf\x44\x73\x9d\x19\x95\x6e\xdd\xe1\xcc\x27\x1c\xfa\x49\x6f\x1f\xf5\x59\x4b\x48\xf6\xb1\x9e\x53\xb4\xea\x43\x74\xb4\x8f\xac\xdb\x47\x47\xf7\xd1\xd1\x7d\x74\x74\x9f\x88\xd0\x38\x1e\x25\x94\xfa\x08\xa5\xb5\x34\x96\x3e\x92\xf3\x43\xb9\x83\xb4\xbc\x46\x1a\x5e\xa7\xb6\xb7\x9c\xb5\x14\xe7\x0c\xa3\x59\x1d\xee\xd4\x60\xe4\x33\xa9\x47\x1d\xf5\x78\x90\xec\xdd\x40\xbd\x16\x64\x11\xd8\xee\x74\x60\x56\x6e\xa7\x9e\x0b\x48\x9f\x46\x62\x3d\xe9\x5c\x4f\x3a\xd7\x93\x25\xfb\x68\xa4\x7d\x74\x35\xd4\xb3\xb3\x19\xa3\x71\xe7\x90\xb0\x13\x95\x72\x2f\xa5\x03\x94\xde\xa6\x34\x40\xe9\x10\xa5\x23\x94\x3e\xa2\x15\x75\x94\xca\x53\xe4\xd5\xf4\x75\xe4\x61\xb2\xe7\x76\xb2\x67\x26\x5d\xcf\x46\x8b\xc5\xb4\x02\xbf\xc7\xb6\xdd\x4e\xab\xa4\x86\x6d\xd8\x43\xfa\xf6\x41\xf7\x3b\xce\x56\xf9\x1e\x95\x07\x29\xbd\x0f\x5b\x0e\x53\xdb\x87\x64\xf7\x11\xa2\x07\x89\x3e\x46\xe9\x04\xa5\x93\x54\xff\x03\x25\xc7\x59\x4f\xb6\x6e\xa5\x68\x6c\x98\xf3\x10\xb4\xd5\x90\xa6\xd1\xd0\xb4\x88\x50\x58\x43\xa3\xbf\x85\x46\xfe\x0a\x69\xfc\x29\x8d\xf8\xa7\xb4\x92\xfb\x49\xeb\x0a\xb9\x5f\xcf\x10\xcf\xc5\x0a\xf9\x36\xd1\x03\x94\xde\xa1\x15\xfd\x2e\xb5\xbd\x47\x5a\x0f\x52\xfd\x7d\x4a\x1f\xf0\x5c\xad\x20\x6b\x5e\x26\x6b\xd6\x90\x35\x2b\xc8\x92\x15\xf2\x63\xe2\xfb\x84\xd2\x09\x4a\x8e\xf3\x32\x59\xb2\x82\x66\xfb\x39\xea\xf1\x22\x1d\x75\x57\xdd\xa0\xdc\x4a\x08\xbe\xca\xb8\x37\xf1\x4a\xd1\x2b\xf0\xa0\xb3\x87\x66\x7b\x2b\x9d\x61\xdb\x08\xe3\x1d\x2c\x7f\x27\x8d\x70\x27\x9d\xe9\x6f\x39\x2f\xf2\x79\x5a\x41\x92\x9e\x21\x49\xfd\x34\x8b\x2f\xf3\x99\xda\xc7\x67\xaa\x3e\x4b\x77\x92\xc4\x87\x68\x4e\xd6\x90\xc4\x2f\xd1\x7a\xd2\x6b\xa0\x9f\x7b\x45\x89\xbb\x9f\x56\x7d\x0d\xeb\x7f\xcd\x3d\x42\xeb\x70\x2c\xcd\xd6\x58\xd2\x7b\x84\x46\x44\xf3\x4b\x38\x69\x4b\x7f\x04\xf9\x7d\xbc\xae\xf4\xea\x78\x95\x7b\xe9\x33\xbf\x8f\x7a\xf1\x1c\x93\x4d\x83\xd4\x7a\xdc\xe9\x27\x9b\xde\x26\x6a\x80\x47\xd0\x47\x92\xd6\xf2\xba\x3f\xc2\x6b\xbf\x9f\xae\x06\xfd\x84\xcb\x4e\xcd\x29\x7f\x4f\xc7\x4f\x39\xfd\xbc\x92\x22\x34\xcf\x47\x18\xf5\x7e\x3a\xd3\x74\xef\x4c\xaf\xa3\xd4\xfe\x7b\xe6\xd2\x77\x39\x86\xb3\xdc\x7e\x3a\x87\x0e\xf0\xb9\xad\xa5\xf4\x6b\x29\xa4\x77\x0f\x51\xae\x84\x3e\xb2\xa1\xcf\x67\x43\x5f\x56\xda\x47\x2c\xb1\x8f\x6c\x70\xad\x0d\x67\x7b\x1d\x80\xd5\x87\x78\x2d\xf5\xc1\xc2\x7e\xc2\x40\xcf\x7f\xee\x98\xfa\x7c\x63\x3a\x92\xe5\x2c\x17\x8b\x79\xbd\xf6\x91\xbc\x3e\x3e\x7b\xb9\x87\xf8\x4b\x9c\xc5\x6b\xb3\xda\x8f\xc3\x66\x1a\x35\x8d\x62\x2f\xa5\x03\x34\x1b\x03\x54\x1e\xa2\x74\x04\x23\x3b\x4a\xa5\xb6\xb1\x0c\xa3\xea\x0f\x8c\x6a\xad\x5e\x0d\x40\xf3\x9f\x80\xa4\xe6\xce\xe5\x5c\xcb\xeb\xf3\x23\xe0\x9f\xc1\xde\xe3\xde\x43\x7d\x33\xe3\x7f\xdb\x87\x81\x1e\x99\x0f\x29\x1e\x61\x09\xc5\xbf\x35\x62\x38\xd9\xa5\xed\x1e\x60\x3b\xfb\xf8\xaa\x5a\xe1\x9d\xcb\xc4\x37\x8e\xaf\x17\x27\x7c\x56\xbc\xc2\xa8\x7d\xc8\x16\x64\xb4\xef\x11\xa5\x39\x6b\xc4\xb5\x71\x83\xd6\xc6\xb6\x45\x30\x37\x7d\x39\xf3\x72\x34\x3b\x37\xbc\x7a\xe8\x3a\xbb\xa7\x30\x7e\xb4\x46\xf6\x50\xab\x3e\x72\x08\x2d\x26\xeb\x38\x4e\xd7\xc2\xf2\xa2\x98\xe6\xae\x14\x46\x0c\x2b\x74\x2f\x10\x0a\x72\x1e\xa3\x73\x2c\x33\xa3\x25\x41\x1c\x70\xa5\x19\xad\x63\x39\x92\x32\x9c\x5a\xdc\xeb\x0f\x5f\xe9\xc8\xd3\xee\xa3\x98\x5c\xef\x61\xc6\x8a\xb9\xb4\x9b\xb8\xca\x19\x4b\xe7\xe8\x58\x3a\xf3\xff\xce\x19\x2d\x37\x38\xfa\xba\x30\x5a\xbe\x7e\xea\x21\xf2\x6d\x33\x83\xad\x8e\xa0\x56\xfd\x9e\x64\x13\x79\xf1\x6a\xda\xcd\xfe\x25\x79\xcc\x1a\x51\x27\x12\x22\x25\x2e\x16\x53\xc4\xd7\xc5\x1c\x71\xb5\xb8\x46\xcc\x97\x5f\x95\x97\xc8\x69\xb2\x41\x2a\x79\xa9\xfc\x86\xfc\xa6\xbc\x5c\xce\x92\xb3\xe5\x1c\x39\x57\x5e\x45\x7b\xc9\xab\xe5\x35\xf2\xdb\xf2\x3b\x72\x91\x6c\x91\x8b\xe5\x12\x79\xa3\xec\xa4\xfd\xe5\x32\x79\xb3\xbc\x45\xde\x26\xef\xe0\xf7\x06\xff\x41\x3e\x27\x9f\x97\xbf\x94\x2f\xc8\x97\x24\x5d\x6b\xe4\x3f\x49\xba\x1a\xc8\xdf\xc8\x6d\xf2\x55\xb9\x5d\xee\x90\xaf\xc9\x5d\xf2\x0d\xf9\xa6\xfc\x67\x49\x71\x80\xdc\xc7\xbf\x5d\x3e\x20\xdf\x96\x03\xf2\x3d\x79\x50\x1e\x92\x1f\xca\x23\xf2\x23\x39\x28\x8f\xca\x63\xf2\x63\x79\x42\xfe\x41\x9e\x92\x8e\x35\xcc\x9a\x56\xba\xaf\x74\x7f\x69\x7f\xe9\x3b\x34\x8e\x28\xa1\x34\x9a\x72\xec\xa4\xff\x4c\xee\xb8\x9f\xf4\x9e\x37\x18\xaf\xf9\x9e\xdf\x6c\xf7\x9e\x85\x18\x83\xde\x33\x0f\x6b\x62\x1e\xa7\x9b\x47\xf3\x9e\x12\xad\xf4\x71\x6e\xf7\x1d\x5d\xee\xcb\x4f\xe6\x3d\x43\xe2\xa7\x26\xa1\x7b\x7d\x47\xa7\xe6\xe5\x27\xf3\x68\x9f\xcd\xa0\x7d\xcf\x90\x5c\x99\x2e\x5d\x72\xbf\x27\xdf\x4f\xe7\x3f\x25\x1a\x0a\x26\x45\xd1\xf0\x69\xcf\x41\xc0\x3f\xf6\xd3\x8e\xda\x7d\xb3\x1a\x4f\x92\xa6\x16\x79\xce\xe4\x69\x3c\x93\x3b\xee\xee\xfb\x1d\xbe\x3b\xee\xee\xbb\xc4\xfa\x2d\x62\xac\xd9\xcd\x7f\xda\x6b\x36\xe7\xfd\xcb\xd9\xbe\x27\x37\xfc\x9e\xa5\xd8\xe4\xe5\x39\xef\x56\x6e\xf2\x9e\x94\xe0\x8d\x43\x2b\xc8\x03\x99\x17\xfa\xda\x27\xf9\x7a\xb9\xef\x32\xae\xf4\xd1\x9b\xbd\x67\x3f\x39\x72\xf2\xde\xe8\xf5\xb7\xfb\xdf\x7f\xcd\x79\xb7\xd5\x6f\x4f\x9e\xcc\xfc\x5c\xde\xe5\xe5\x45\x31\x99\x57\x18\x13\x77\x8c\xc5\xd0\xf0\xbf\x45\x9a\x33\xf6\xd3\x8e\xda\x95\x9f\xf3\x26\xe8\xa0\x27\xd9\xcd\x5d\x69\x9c\x0f\x7d\xcd\x7e\x96\x77\x52\x46\x93\x86\x45\x94\xda\x28\x75\x0a\xfd\x7f\x3f\x84\xb8\x8d\x92\x46\xeb\x6e\x4a\xda\xbe\x07\x29\xe9\x37\x33\x1f\xa3\xb4\x9a\xd2\x1a\x4a\xfa\xe9\x99\x7e\xb6\xf8\x2c\xa5\x97\x28\xe9\xb1\x6e\xa3\xf4\x3a\xa5\x37\x29\xe9\xb7\xa5\xdf\xa5\xa4\x47\x70\x4c\x18\xa7\x9e\xd4\xef\x53\x7e\x4a\xbe\xdd\x97\x9f\xfe\x68\x26\x17\xbe\xbc\x70\x0b\x3f\xbb\xc3\x3b\xa3\x55\xfc\x4e\xa7\x2f\xc7\x79\xbc\xfe\x4f\xfd\x3c\xf6\x9e\x87\xe3\x57\x28\x9b\xbd\x6b\x9f\xfb\xbb\x17\xf7\x17\x2f\x99\xdf\x90\x70\xfb\x61\x8f\x13\xfc\x1b\xbc\xa3\xee\x75\x19\xbf\x71\x9a\xed\x49\x43\x1e\xf6\xe5\x93\x82\x34\xa4\x1d\xf7\x49\xdb\x9c\xa7\x6b\x5e\x11\x7a\x52\x11\x7b\x7c\x9c\xf9\xef\x3b\xf8\x75\xf9\xf3\xa1\x63\x52\x0c\x0d\xe0\x30\xbb\xc8\xd8\x4f\x3b\x6a\xfc\x9e\xd3\xff\x5e\x91\xe5\x1b\xd7\x86\x80\xc6\xa1\x9f\xc7\xa7\x7f\x53\x50\xbf\x73\x73\x31\xa5\x4b\xc4\x99\xfe\xee\x46\x8f\x47\xf1\xdb\x1a\x8a\x6d\x52\x3c\x12\xc5\x48\x29\x7e\x4f\x23\xdb\x4e\xde\x5b\x31\x3a\x8a\xb1\x2b\x98\x1b\xa3\xf4\x6f\x6c\xfe\x5c\x7d\xa1\xb9\xda\xe7\x57\xac\x22\x7e\xce\xca\xf3\x55\x2d\xdc\x72\x07\xe7\xee\x33\x9f\x7b\x83\x9e\x00\xbf\x66\xf0\xfd\x2e\x84\xdf\x90\xcf\xd0\xf7\xe6\x79\x05\x9f\xb4\xfc\x5f\x7b\xe4\xfc\xc2\x60\x75\x9e\x2f\xf4\xdb\x33\x04\x5f\xe8\xff\xb5\xc4\x99\x62\x52\x14\x8d\x31\x79\x08\x6c\x08\x8e\xa5\xd8\xa8\xa1\x25\xdf\x17\xb6\xf8\xe4\x7b\xf6\xff\x3f\xe1\x0b\xe9\x7c\xa8\xf6\xc5\x1a\xd5\x8c\x42\xb5\xaf\x7d\x5c\x16\x97\x16\x60\x74\x1e\xe3\xeb\x1d\x9d\xcd\xf9\x25\x5e\x8e\x98\xe2\x42\xe4\xe3\x7c\x74\xa0\x05\xb3\x75\x2b\xb7\xf8\x72\xfd\xbf\x10\x48\x96\xf7\xae\x89\xd6\x56\x72\xea\xb2\x53\x4f\x9e\x5a\x72\x6a\x3b\xe5\x27\x0b\x3c\x39\xe5\x5f\x82\xd3\x5f\x39\x3f\xed\xdc\xe4\x24\xf1\xf4\x53\xf0\xd8\x34\x14\x5f\x7b\x6c\xab\x2e\xff\xf1\x4b\x8d\x87\xb9\xfe\x93\x53\x73\xff\x4f\x00\x00\x00\xff\xff\xb7\xf8\x6f\xa0\x18\xa9\x05\x00") + +func liberationserifItalicTtfBytes() ([]byte, error) { + return bindataRead( + _liberationserifItalicTtf, + "LiberationSerif-Italic.ttf", + ) +} + +func liberationserifItalicTtf() (*asset, error) { + bytes, err := liberationserifItalicTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationSerif-Italic.ttf", size: 370968, mode: os.FileMode(420), modTime: time.Unix(1459927769, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _liberationserifRegularTtf = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xe4\xfd\x79\x60\x54\x45\xd6\xff\x01\x9f\xba\xf7\x76\x77\x1a\xb2\x27\x2c\x21\x40\x77\x48\xc2\x62\x80\x04\xc2\x16\xd6\x66\x49\x88\xac\x01\x02\x26\xac\x09\x86\x00\xb2\xcb\x22\xa8\x48\x54\xf6\x45\x36\x65\x47\xa3\x02\xb2\x29\x41\x11\xd1\x71\x14\x47\xdc\x46\x19\x99\x71\xdf\x11\x90\xe8\xb8\x31\x8c\x3b\xd0\xfd\x7e\xea\x76\x07\x03\xea\xcc\x3c\xef\xef\xfd\xef\xcd\x33\x27\x75\x6f\xd5\xa9\xb3\x7c\xcf\xa9\xaa\x53\xdd\xe1\x51\x94\x88\xc4\xf1\xcb\x92\x8c\x9c\x9c\xfc\xfe\xc5\xf1\x37\x3e\x25\x8e\xaf\xce\xd0\x5b\xbf\x77\xaf\xec\x9c\xf9\xaf\xce\x72\x8b\xa3\xbc\x03\xef\x4b\x7b\xe7\x0d\x1c\xf2\x8f\xe2\x82\x89\xe2\xd8\xb3\x46\xa4\xe7\xe0\xde\x43\x86\xf6\xe8\xff\x72\xf3\x58\xc6\x8f\x8a\x84\x9d\x18\x38\x24\xbd\xb5\xb9\xf4\xc5\x72\x11\x75\x04\xfe\xa2\xeb\xa7\x14\x4f\x4f\x5a\x9e\xfd\x27\x91\x6b\x0a\x44\x9c\xed\xae\x9f\x33\xcb\x3b\x3a\x71\x70\x2b\x91\x4e\x6f\x8a\x18\xff\x28\x9d\x3e\x7e\xca\x6d\xc5\x87\x63\x44\x32\x90\xe7\x3a\x34\xbe\x78\xe6\x74\xa9\x27\x5a\x5f\x53\xe6\x47\x8f\x9f\x3c\xaf\xd4\x7a\x7b\xec\x8b\x22\xa5\x5f\x89\x75\xf0\xe2\x84\x71\xc5\x25\xd2\x61\xe1\x05\xe4\x77\x66\xbc\xdd\x04\x3a\x22\x46\x44\x7c\xc2\xfb\x2c\xde\x53\x26\x4c\x99\x35\xf7\xad\x41\xe7\xef\x47\x76\x5d\x91\xa6\xbe\x49\xe3\x6e\x9c\xda\x7a\x7f\x6f\x8f\x38\xea\x7e\x2e\x12\x5f\x32\x79\xda\xf5\xc5\x09\x6f\x6d\x28\x11\xe9\xba\x9b\xf1\x5e\x53\x8a\xe7\x4e\x8f\xd8\xee\x78\x8b\xf9\x9b\x98\xef\x9d\x5a\x3c\x65\x5c\xbb\x8e\xf3\x22\xc4\xd1\xa2\x9f\x48\xcd\x07\xa7\x4f\x9b\x39\xeb\x4f\xef\xdf\xb9\x48\x1c\x1d\xce\x89\x8c\x6f\x3f\xfd\xc6\x71\xd3\xd5\xf8\x7b\x9c\x22\x1d\x7a\x89\x98\x6b\x6c\xec\x0c\x91\xa8\x1f\x5b\xe6\x8d\x89\xea\xfc\xbd\xe1\x09\x13\xfd\xf3\xda\xfa\x06\xb9\x55\xed\x85\x5d\x97\xd6\xd7\xe8\xe8\x7a\x9f\x57\x3d\xa8\x6c\x06\x7e\xbb\x92\xfc\xd9\x72\x5d\x8d\xbd\x17\x76\xfd\xf2\x49\x8d\x8e\xa1\xfe\xcb\x3f\x35\xa2\x75\x4f\x8d\x68\x35\x58\xf2\x65\x85\x38\xd1\x12\x2d\xe9\x32\x12\x75\xcf\x9b\x2f\x8a\xc9\xa8\x69\x95\xa8\x35\xe2\x10\x71\x6c\x71\x64\x22\x32\x35\xd8\x9a\xe5\x52\xa2\x76\x28\x87\x61\x38\x4d\x87\xe5\x30\x4c\xeb\xa4\xd4\x08\xe4\xc9\xdc\x00\x62\x93\xb4\xec\x56\xdd\x87\xf4\x14\x9f\x78\x03\x17\x1d\x2b\xfd\x39\x2a\xd3\x95\xa4\xfe\x54\x24\xea\xd9\x4f\x7e\x64\xf6\x7e\x47\x17\x8d\x84\x44\x3a\xb3\x82\x96\x18\x55\xb4\x57\x3e\x30\x7b\xc9\x02\x4b\x24\x15\x2a\x70\xee\x95\x1c\x78\x06\xa8\x19\x32\x8c\xb1\xe1\x50\x0f\xfa\x4b\xac\x3b\xa5\x14\xfe\x01\xbc\xf7\xa3\x5d\x62\x64\xe9\xd4\x92\x01\xd0\x21\x68\x38\x34\x16\x6a\x0a\xdd\xa4\xe5\x40\x4b\x42\xe3\x3d\xe0\x7d\x00\xba\x41\xcb\x08\xd1\x04\x73\x95\xdc\xe0\x1a\x2d\x53\x1c\x2f\x49\xbc\x63\x98\x74\x82\xf2\x79\xee\x64\x9d\x86\x66\xf2\xfe\x52\xf0\x1d\x7d\x7d\xcc\x06\x92\x56\x35\xe6\x6a\x60\x8f\xd9\xe3\x97\xf9\x86\xd9\x73\x96\x31\x9e\xca\xbb\xe6\xad\xe3\x5a\x25\x06\x6d\x0b\xfd\x4c\xff\x58\xe4\x6c\xd2\x36\xdb\xf2\x9e\x93\x06\x96\x04\xce\xf1\x7c\x13\x76\xe4\x62\xa3\xd0\x6a\x5b\xfb\xd0\xe6\xd1\xdf\x2d\xe4\x43\x3c\x73\xd2\x8c\xac\xc0\x0b\x3c\x37\xe1\xb9\x19\xd8\xa4\xf1\x9c\x1e\xf2\x2d\x49\xcf\x81\xbf\x19\x36\xe6\x33\x1e\xcf\x7b\xa2\x96\x87\x5e\x83\x36\x16\x4a\x40\x66\x7b\xf3\x1d\x79\x4a\x6d\x91\x2d\xba\xb5\xf2\x25\xab\x0a\x7b\xc6\x35\xf6\xf3\xa0\x22\xc8\xd0\x3c\xb4\x0f\x68\x1b\x9c\xf1\x52\x60\xb4\x95\x64\xde\x67\xdb\xf8\x83\xbd\xee\xc3\xf6\x6f\xcd\x4c\xf0\x2e\x91\xa1\x46\xa9\xf4\x82\xd2\x18\xdb\x66\x6d\x93\x1e\xe4\x49\x18\xcf\x1f\x42\xab\xe9\xef\x61\xdc\x62\xc7\x75\x30\xc9\xdd\x23\x44\xda\xc7\x7c\x1b\xf7\xdf\x21\xf0\xd5\xf1\xc8\xb7\xe3\x50\x8d\x90\xd7\x4e\x63\x07\xc5\x6a\xdb\xe0\x6d\x5b\x15\x87\xab\x09\x5b\x1f\x08\x3d\xa7\x5d\x45\x75\x88\x93\xc6\x3b\x5e\xe3\xfe\x7b\x84\x6e\xdd\x0e\xd0\x71\xa8\x4e\x60\x5b\x3b\x14\x8b\x77\xa1\x5f\x42\xf8\x57\xc5\xe1\x4a\x02\x17\xda\x9c\x50\x2c\xaa\x53\x02\x14\xa9\x5b\xed\xab\xad\xef\xea\x16\xdf\xb5\xfe\x3f\x6c\xb5\xcf\xcd\xa5\x8f\xf6\x5f\xc7\x5e\x63\xa3\xed\xfb\x6f\xad\x8d\x0b\x39\xf5\x1f\xda\x4e\x1a\x97\xaa\xd6\xc6\x39\x2b\xf0\x3e\x6d\x22\xed\x19\x1b\xff\xac\x40\xc0\x8e\x41\x96\x1d\x6f\xbb\x75\xec\xc3\x86\x49\x92\xa6\xd7\x88\xce\xd3\xd0\xfc\x26\x36\xe9\xb8\x91\xb3\xd5\x5b\xd3\x27\xbd\xed\xf7\xa3\xf6\x7b\x9a\xce\xd9\xd0\x9c\xf4\xab\x5b\xeb\x2d\xd6\xd0\x76\xe6\x7c\x6f\xf7\x69\x3b\x07\x5c\xdd\x92\x2f\x3a\xce\x1a\x1f\x9d\x23\xcd\xae\x6a\x63\xf5\xba\xd4\x6b\x23\xd4\xf6\xb9\xea\x5d\xe7\x59\xaa\xbd\x6e\x68\xcd\x49\xc1\x36\x64\x93\x5e\x67\x89\xff\x6b\x1b\x5a\xef\x86\x9d\x63\xc1\xf8\xda\xeb\x5e\xaf\xbd\xab\x5b\xe4\xb7\x62\x0d\x5d\x60\x2d\xa5\x5a\x9b\x6c\x5f\x97\xd1\xa6\xd8\xeb\x76\x98\xcc\xa8\x16\xeb\xb6\xce\x45\xc4\x79\x93\xf4\x64\xac\x97\xf9\x02\xfb\xc2\x69\x29\xb5\x7d\x37\x64\x94\x35\x33\xa0\xf7\xba\xe7\x43\xb9\x5e\xc7\xd9\x8c\xb8\xb9\x02\x7e\xfc\x4e\x0e\x61\xa8\x71\x4f\x32\x3f\x95\x76\xce\xa5\xda\xa6\xc0\x84\x10\xbe\xc1\x75\xd2\x09\xfc\x4a\xc9\xa5\xa5\xe8\xca\x94\x2e\xf6\x7e\x32\xd3\xde\xcb\x6e\x05\x9b\xee\xd6\x6e\xf2\xfe\xa8\x58\x21\x7c\xc2\xaa\x70\x72\xb6\xc5\xe7\x61\xf8\x7e\x5e\x6e\xd0\xfe\x3b\xbb\x05\x7d\xbe\xec\x67\x1e\xe3\x79\xd2\x8d\xe7\x1c\x3b\x07\x83\xfb\xf3\x35\xe6\x4a\x69\x63\x16\x49\x4b\x7c\xff\x99\x7d\x66\x9b\xd1\x4d\x96\x2a\xbf\x44\xe8\x7d\xa8\xc6\x5e\xe9\xe4\xce\x67\x7f\x5d\x25\x7d\x38\xd0\x3a\xb9\xea\x63\xc7\x8d\xd2\x2c\xec\x8c\x74\xd2\xef\xec\x7b\xe9\x55\x6b\x24\x94\x9b\x1f\x55\xcb\x85\xff\x29\x46\xcc\xed\x7d\xf5\x7a\x0b\xed\x37\xb9\x21\x59\x72\xd5\x7a\x68\x72\x75\xbe\x69\xdf\x98\x97\xa4\x73\xbd\xba\xcd\x55\xf3\x5c\x9b\x99\x77\x8b\x34\xaa\x96\xcb\xbf\xa7\x27\x27\xd4\xdf\xa4\x6a\xfc\xea\xf5\x6a\xec\x0d\x1c\x47\x47\x59\x68\xdd\x9d\xfb\x4d\xfe\xdb\xf9\x1d\xb8\xfb\x72\xbe\x5f\xe5\xeb\x6f\xf2\xfb\x76\xe9\x6b\x36\x93\xfe\x97\xd7\x79\xa6\xdd\xf6\xb1\xde\xb4\xf7\xc3\x01\x55\xb1\xbb\xda\x9e\x3f\x5a\x77\xd5\x5a\x3b\xf6\xf6\xfa\xc6\x5f\x63\x99\xc4\x69\x6c\x9c\xad\xa4\x8f\xb3\xa5\x8d\x4b\x70\x3f\xd7\xe7\xcc\x69\x7b\xcd\xa7\x6a\xbb\xec\x3c\xc9\x96\x7b\xcd\x96\xf6\x5a\x6d\x67\xef\xcf\xc7\xed\xfc\xb2\xf5\x5e\xde\x4f\xee\xb5\xe7\xf6\xa9\xe6\x67\x9d\xd0\x99\x56\xdf\x4a\xc7\xfe\x74\xdb\xfe\x65\xbc\x77\x0b\x9d\xa5\x7d\x42\xe7\x68\x6f\x3b\xde\x16\xb2\x46\xca\x40\xa8\x93\x75\x08\xd9\x2b\x38\xaf\xf6\x06\x96\x5c\xe6\x2b\xb7\x71\xd0\xe7\xaf\x84\xf6\x68\xed\x47\x33\xfc\xa9\x63\x34\x91\x16\xb4\xc3\x20\xdb\x3f\xdb\xc7\xfb\xec\x33\xd8\x1b\x22\xb0\x0e\xac\xd4\x7e\x9b\xbf\x48\x9c\x8d\x47\x0d\xc9\x76\xf4\x92\xbe\xd6\x14\xbb\x56\x89\xad\x46\xcd\x42\x94\x08\x75\x34\x2b\xc1\xa1\x32\x88\x05\xf6\x9c\xd4\x64\xce\xb7\xdb\xd7\x75\xbc\x2e\x9f\xe5\x25\x52\x60\xfe\xe5\xf2\x99\x8e\x3b\x12\x6d\xfe\x4b\x9c\xf6\x99\xfe\x23\x44\x2e\x42\xb1\x50\x09\xd4\x2b\xd4\xda\xf1\x31\x5f\x42\x3e\xfe\xda\x3e\xe6\xea\x3c\x08\xec\x60\xbe\xdb\x9c\x6e\x9f\xc9\x7d\xaa\xe6\x38\x27\x11\xab\xbf\x40\x6f\x80\xc9\x22\xe2\xff\x08\x31\x6b\x25\xf1\xce\xfe\xec\x37\x4b\xf0\xf9\x66\xa8\x01\x7a\xde\x93\xce\x56\x40\x8a\xad\xaf\xa5\xd8\x58\x27\x8d\xa1\x4c\xd5\x35\xf0\xa3\xfa\x33\xed\x9f\x25\x5e\x93\x51\x08\xdf\x14\xf6\xa0\x22\x71\xaa\xa3\x32\xce\xf8\x4a\xa6\xe1\xef\x0b\xd0\xa1\x50\xfb\x2f\x4d\xea\xa2\x78\xa1\x86\x9c\xd5\xd7\xeb\x7a\x0c\x1a\xa2\xe9\x57\xbc\x54\xc3\x10\x56\xdb\x74\x9d\x54\xed\xfd\x26\x9b\xb2\xe4\x61\x9b\x42\xf2\x42\xf2\xab\x48\xf3\xb5\x85\xbe\x84\x96\x41\xf3\x83\x32\x03\x3f\x41\xdf\x98\x91\xe4\x69\x81\x38\x54\xbe\xd4\x53\x8f\x49\x3d\x23\x8f\xba\x07\x5b\xcc\x68\xd9\x70\x35\x31\x6f\x6c\x88\x62\xb4\x5c\xf0\xd2\x75\xe9\xda\x10\x7d\x10\xa2\xe5\x41\xbb\x02\x47\x83\x3a\xf4\xfe\x74\x85\x3d\x36\x91\xeb\x8d\x35\xf1\x1c\x2f\x72\xe9\x6b\x11\x3f\xf5\xbc\xff\x69\x42\x1b\x4b\xcb\x7d\xe4\x92\x9f\xf6\x53\x91\xc0\xdd\xb4\xff\x84\xea\xf0\xdc\x96\xf6\xc1\x20\x5f\xe0\x15\x68\x18\xcf\x87\x83\x7c\x36\xef\x9a\x5f\x49\xff\x04\xda\x84\x68\x70\x90\xfc\xab\x69\xb9\x67\x04\xb6\x42\x63\x7e\x25\xad\xcf\xff\x55\x68\xce\x7a\x9e\xbf\x0c\xea\x0a\x2c\x86\x7c\x50\x56\x50\x9f\x9e\xef\x5f\x17\xd4\x6f\x53\x48\xaf\xfd\x1c\xb2\xd9\xb6\xbb\xda\xbb\xdf\x0b\xbd\x1e\xd4\xe9\x5f\x49\x3b\x94\x76\x23\x6d\x32\x74\x4f\x88\x67\x7c\x50\xb7\xed\x17\xb6\xfb\xb9\x6f\x05\xee\x08\xea\xd3\xe3\xda\x4f\xdb\xce\xa7\x7f\xa5\x80\x09\x0d\x62\xdc\x43\xbb\x28\x24\xff\xd3\x90\xdc\x45\x41\xf2\x3f\x1c\xec\x17\x6e\x26\x81\x8c\xa0\xed\x81\xae\xd0\xab\x57\xd1\x13\xa1\x76\x08\x14\x01\x35\x80\xa6\xc2\x7f\x11\x3a\xc9\x73\xbd\x20\x26\xfe\x0f\x20\x8d\x45\x76\xc8\x9e\xe3\x90\xae\x8b\xde\x81\xde\x80\x8e\x87\xf6\x1e\x9f\x5e\x77\xfa\x9e\x11\x1a\xcb\xd4\x7b\x1f\xef\x4b\x1c\xab\x02\x47\x9c\x37\x05\x8e\x98\x7d\x02\x47\x38\x83\x8f\x39\x97\x04\xfe\xec\x38\x1f\x38\x66\x34\x09\xfc\x58\x75\xff\xb0\x58\xa3\x8e\x54\x7b\x1f\xd6\xf5\xee\xd8\xaa\xda\x56\xd7\x59\xf6\xf3\x71\xbb\x36\x0e\xde\x3d\x52\x65\x6a\xd5\xfd\xc4\x3e\xaf\x77\xdb\xe7\x86\xbe\x7b\xd4\x71\xbc\x27\x5d\xed\x7b\x47\xa5\x38\xf5\xf9\x1c\xaa\x95\xeb\x58\xad\xa8\x69\xd9\x07\xd9\x2f\xbd\x7a\x5f\x33\x7f\x60\x4f\xa1\xcf\x8a\x95\x85\xe6\xb2\xc0\x25\x6a\x8b\xfe\xf6\x3e\x99\x27\x85\x9a\xc7\x7c\x4b\x8a\x34\x9f\x15\x26\x4d\x74\xfd\x60\xf5\x91\x5d\xe6\xbd\xe2\x30\xd7\xda\x67\xf9\x00\xab\x86\xd4\x37\xfd\xcc\x4d\x63\xaf\xcb\x43\x76\xfb\x90\xcc\x7b\x91\xb1\x2a\xe0\x77\x18\x9c\x45\xbd\x38\xc7\x9a\x04\xfe\x65\xf7\x33\x47\xb7\xba\xcf\xd6\xf9\x43\xf0\xac\x72\x79\x44\xd9\x67\x56\x3b\x7b\xdf\x14\xce\xce\x06\xd5\xce\xb8\x7c\x6c\xea\xab\x7d\x34\xd7\x8b\xc7\xda\xca\xbc\x6d\xd4\x1c\xef\x4b\x0d\x8b\x48\x39\xcb\x25\x41\xef\xc3\xec\x47\x39\x56\x1a\xf3\xfb\x48\x3f\x62\xe0\xa0\x36\xb9\x0e\x3a\xe6\xf0\x51\x37\xed\x92\xee\x8e\x4d\x8c\xc7\xa2\xff\x38\x6b\xbc\xb6\xd4\xd3\x3a\x78\x2f\x0a\xc6\xcb\xae\x59\xf3\xcd\x2e\x8c\x77\xc1\x8e\xe0\xfd\x20\x52\xeb\xb6\xf1\xe6\x7e\x8c\x9f\x35\xaa\xea\x32\xdd\x56\xdd\x49\x9c\x16\xfb\xa8\x8e\x5b\x6e\xb0\x9e\x0c\xdd\x4f\xba\xe9\xb3\xcb\xc9\x79\x00\x75\x72\x7c\x43\x5c\x86\x85\xe2\xb6\x17\x5b\x82\x71\x8d\xd7\x75\xdf\xe5\xb8\xcf\xe6\x4e\xa0\xef\x96\x69\xf8\x6f\x48\x71\x88\xc7\x1e\x77\x4c\x91\xb8\xea\x77\xce\xaa\x98\x87\xee\x48\xa9\x5a\xa6\x73\xb0\x0c\x09\xdd\x35\x3b\x71\xae\xd7\x0a\x8b\xa5\x66\x82\x1c\xbb\xa4\x8b\xb6\xc1\xd6\x95\x2b\x33\xc2\xb2\xec\x79\x61\xf6\x39\xa9\xfd\xd7\xe7\x03\xe7\x02\xcf\x62\x9f\xf5\x4b\x02\x3f\x51\x23\x74\xd4\x67\x85\x26\x53\x9f\xd5\x7e\xf2\x13\x0c\xec\x3e\x1d\xf7\x60\x9b\x64\xdf\x91\x16\xb0\x7f\xeb\x5a\x37\x9d\x18\xe9\xbb\xa6\x1e\x73\x8a\x87\x3a\x34\x59\x93\x95\x2c\x29\x8e\x22\x64\xec\x82\xa6\x11\x9f\x5f\x24\x85\xb3\xc5\x79\xf9\x5e\xf5\x11\x67\x4d\xae\x3d\x36\x20\x74\x7f\xd5\xf7\x01\xb7\x1d\x93\xbf\xa3\xf7\x15\x5b\x57\xbc\xb6\x23\xa4\x37\x81\x36\xc5\x5d\x2c\x45\x8e\x18\xc6\x47\x4b\x5d\xab\x40\xea\xb9\x9e\x61\x8d\x4c\x92\x8e\x36\xae\x47\x24\x26\xac\x27\x67\xd9\x7e\xe9\x08\x9e\xad\x1c\x4b\xa4\xb5\x9b\x3b\x8a\xeb\x16\xfc\x32\x44\xe1\x9f\x38\x2a\x03\x9f\x93\x9f\x91\x55\x79\xe6\xbc\x83\xf5\xc1\x8e\x5a\xd5\x86\x3d\x4f\xec\x6b\xd0\x5f\x0f\x9c\x96\x48\x8e\xfb\x90\x2c\x75\x0e\x93\xec\xcb\x7a\x83\xf5\x79\x8e\xb1\x5f\xd8\x33\xfc\x15\xd0\x96\x5f\xf7\xe0\x4b\x3b\x44\x2e\x12\xc9\x8b\x19\x76\xac\x72\x83\x35\xbe\xf9\x3c\x6b\x69\xa6\x5d\x6b\x24\x99\x5b\xa8\x65\x5e\x27\xd7\x88\xbd\xf6\xdf\x11\x41\xbf\x47\x52\x75\xfc\x75\x0c\x74\x0e\xe8\x38\xe8\xf8\x6b\xdf\xaf\x6e\x9d\xd7\x22\x73\x83\x34\xac\x92\xef\xfc\x1b\xed\x45\x49\x0d\xeb\x41\x4e\xe6\x49\x67\xf8\x06\x63\x5f\x66\xd5\x3d\xc2\xae\xb9\x16\xd8\xfc\x75\x42\x75\x44\x55\xdb\x42\xc7\xcd\x59\x24\xd7\x58\x6f\x90\x3f\xe4\x8e\x8e\x5f\xb5\xd6\xae\x15\x5d\x2e\x89\xb6\xc6\x48\x58\x55\xab\xf3\xbc\xca\x56\x3b\x87\xb1\x5d\xe7\xa9\x9d\x2b\x21\x9b\x2e\xb7\x21\x59\x55\x6b\x49\xd7\x50\x7f\x54\x83\x57\xaf\x39\x43\xb5\xba\xdd\x5e\x8d\x0b\xad\xee\x4f\xfa\x8d\xae\x3f\xaa\x51\xc9\x7d\x3b\xff\x58\x2b\x76\xbe\x5e\xdd\x86\x6c\xac\x8a\x87\xbd\x6e\x8b\x82\x6b\xdb\x0c\xca\xb5\x71\xaa\x6a\x89\x67\x2f\x5d\x3f\x39\xa7\x52\x3b\x5d\x43\x3b\x49\xa6\x38\x76\x4a\xa9\xb5\x51\xa6\x9a\xf7\x49\xa9\xab\x3b\x6b\xdf\x02\x37\xee\x02\xd4\x50\x8d\x6c\x3f\xca\xb1\x63\x2d\x32\x4f\xb0\x66\xb8\xbb\xe1\x47\x76\x35\xcc\xec\x1a\xb7\xea\x0e\x49\x1e\xb1\x13\x0a\x5e\x07\xa6\xd0\x8e\xd6\x9f\x79\xf2\x3c\x00\x9a\x40\xae\xbd\x05\x1d\x09\x9d\xdb\xcd\x7e\xfd\x6c\x4f\xf7\xf9\x9b\xf0\xa0\xcf\xb1\x91\x41\x19\x01\xea\x8b\x00\xf3\x03\x37\x04\xc7\x03\x63\x83\x63\x9a\xcf\x1e\x1f\x1d\xe4\xd1\x3f\x97\xf6\xf2\xdc\x05\xd2\xf9\xfc\x06\x74\x3e\x48\xfa\xdd\xee\xef\x12\x92\x3b\x32\xd4\xa7\x29\x36\xd4\xbe\x42\xad\xa4\xcf\xdf\x91\xd6\xed\xea\xbb\xaa\x71\xfd\xb9\xdb\xe5\xe7\x2d\x72\x27\x4a\xda\x5a\xc7\xd9\x77\x3e\xa0\x3e\xdb\x41\x1d\xfb\x1e\xeb\x79\x8b\x94\x1a\xe1\xd4\xd7\x9d\xe4\x26\xeb\x69\x59\xc1\x9d\x7f\x98\x91\x20\x99\xe6\x37\xd4\xf8\x5f\x48\x03\xf3\x99\xc0\x77\x96\x5f\xca\xad\x67\x24\xcb\xa8\x21\x5d\x90\x13\x6d\xad\x92\xb1\xac\xcb\x4c\x2b\x55\x86\x71\x86\x75\x61\xef\x9f\x46\xdb\x8a\x1c\xb8\x49\xcf\x23\xae\x03\xac\x4f\xb9\xa7\x69\x19\x3f\x21\xeb\x0b\xea\xd3\xf7\xd8\x63\x58\xd3\x96\x03\x8c\x9b\x89\x69\x7f\xce\x73\x84\x75\xf1\x06\xf7\xd1\xd6\xc4\x05\x32\xef\x82\xc8\x2f\x7b\x1f\x1a\x83\x9e\x41\xbc\xaf\x96\xfa\xd5\xf7\x3f\xf8\x3b\x5b\x43\xa5\xab\xd5\x9f\x3c\x1c\x6a\x9f\x5d\x03\xcc\xdb\xb8\xcb\x84\x3e\xfb\xb1\xf7\x3a\xbd\xc7\x69\xd2\xfb\x63\x3f\xc9\xe2\xac\x4c\x75\x74\xc1\x77\xb7\x2d\xc3\xfe\x6c\xce\xae\xdf\xd1\x45\x3d\xd8\xc5\x1a\xc8\x5d\x25\x28\x5f\xec\x7d\x17\x19\x56\x47\xe6\x93\x1b\x66\x51\x20\x60\x0d\xe0\x7c\xae\x2b\xcd\xa1\x86\xd4\xee\xd7\x18\x3f\x60\xdf\x0f\xd2\xc5\x9c\xc3\x99\xbb\x58\xae\x51\x9b\x25\x4d\xfd\x4c\x6d\xba\x97\xfe\x9f\xd0\x33\x58\x9a\x99\x8f\x49\x77\x73\x09\x77\xee\x02\x69\x64\x54\x48\xb4\xf1\x10\xcf\xbd\x99\x7b\x16\xdc\xcb\xf1\x79\x6a\xe0\x7b\x23\x83\x5a\x54\xd3\x9d\x9c\xf1\x1e\x69\x68\xdc\x2c\x1e\x63\xbe\x34\x31\x22\x24\x45\x93\xfa\x56\xea\x43\x49\xc6\x04\x69\xa2\x06\x8a\xcb\x58\x8c\x6d\x5f\x48\x2b\xa3\xbb\x64\x1a\x03\xb8\x4f\x84\x53\x4b\x0c\x90\x64\x9b\xe6\x4b\x0b\xb5\x94\xf6\x3e\xe6\xdf\x68\xc7\xae\xb9\x31\x3c\xf0\x8b\xb1\x8a\xb6\x07\xfc\x1e\xa9\x69\xa4\x21\xf7\x61\x78\x7a\x48\x2c\xf2\xea\xa9\xb7\xe9\xbf\x4f\x5a\xc2\x77\x81\xbe\xb6\xf0\x44\x18\xa3\xb1\xe7\x61\xf8\x7a\xb0\x86\x6a\xeb\xba\x21\xb0\xcf\xb2\x3f\xe3\x0c\x9c\xe3\xac\xd7\x77\xac\x18\xfa\x76\xf3\x4e\xed\x4f\x4d\xd5\x00\xbb\xb3\x02\x3b\xed\xfb\xa4\x48\x3f\x63\x03\xf1\x7e\x81\x73\x2f\x89\x7a\x5d\xc7\xb1\x89\x7d\x1f\x4e\xb2\xe3\x50\x22\xb5\x6d\x8c\x83\x9f\x99\x76\xb3\x5e\xb4\x3f\x63\xbd\xfa\x73\xd5\xa4\xaa\xcf\x53\xcd\x71\x81\x93\x21\xfe\x58\x3b\x5e\xfa\xdc\x4c\xbf\x7c\xbf\xbc\x7c\xaf\xd4\x7b\x94\xd6\x65\x9f\x89\x0b\xa9\x4d\x82\x9f\x35\x74\x04\xd7\x2c\x30\xf2\x40\x89\x46\x7f\xf1\x80\xa5\x47\xed\x93\xa6\x6a\x5f\xe0\x3d\x23\x49\xea\x73\x7f\x6a\x04\x0e\x11\x6a\x36\x31\x1c\x24\xed\xa0\x86\x6a\x85\xd4\xa6\x2f\x41\xe3\x63\x5c\x23\xc9\xe6\x3d\xd2\x0a\x2c\xaf\x31\xee\x0b\x7c\x0c\x56\x1d\x8c\xf5\xc4\x53\xe3\xbd\x96\xf8\x3c\x26\x89\xea\xc9\xc0\x25\x70\x6f\xc8\x58\x0b\xee\xde\xcd\x59\x1f\xa9\xc6\x10\xf8\x35\xf6\xad\x68\x5b\x31\x67\x2a\xe4\xe5\x3e\xdb\x54\x52\x59\xd3\x4f\x04\x29\x70\x30\x78\x6e\xd9\xf7\x80\xdf\x21\xfb\x0e\x60\xd7\xd3\xd5\x3e\x9b\xec\x14\xfa\x8c\xea\xea\xf6\xf2\x67\x93\xf6\x5d\xfd\xbf\xb4\xff\xeb\x67\x96\xfa\xbc\x0c\xd5\xaf\xbf\xfb\x19\xe5\x1f\xb5\xcc\xa9\x4d\x4e\xbc\x17\xfc\x8c\x32\x10\xa8\xf6\x59\xce\x15\xed\x95\x9f\x4f\x06\x4e\x84\xda\x33\xa1\xf6\x5d\x7d\x66\xe9\xbc\xb8\xba\xfd\xa3\xcf\x2b\xab\xb5\xff\xf1\x33\x93\xaa\x3a\xa0\xaa\xfd\x83\xcf\x2e\x53\x42\x6d\xf2\x6f\x3e\xb3\xfc\xa3\xb6\xda\x67\x99\xbf\xb6\x81\x8b\xa1\x77\xe7\xff\xe1\x33\xcd\x2b\xea\x84\xaa\x73\xe9\xbf\xb5\x57\x9f\x93\x55\x9f\xd5\xfc\xd1\xe7\xa0\x56\xf0\xfb\x0d\x6d\x97\x11\xfa\x4c\x27\x57\x7f\x36\xea\x78\x1c\xfa\xa3\xcf\xc7\xed\x36\xf0\xed\x7f\x1e\xff\xef\xed\xff\x96\x83\x36\x76\xbf\x3b\xfe\x9b\xcf\xc1\xff\x73\xcc\x1b\xfd\xc7\xf1\x4e\xff\x53\x7b\x45\x8c\xaa\x3e\x83\xfd\x6f\xad\xa3\xfa\xe7\xd1\xbf\xd3\xda\x77\xc0\xff\x40\x8e\xd0\xf7\x32\xce\x7c\x51\xbf\x47\xa1\x3d\xf0\x37\xe4\xb8\xc8\xd9\x08\xb9\x3a\x5f\x49\xfa\x6e\xf9\x9f\xc8\x79\x12\xb9\x50\x98\xf7\xf7\xc9\xfe\x4c\xce\xa6\xc0\x5f\x83\x64\xf7\x41\x81\xd7\x35\x51\x67\x2b\x4d\x0e\xf3\xf7\xc9\xfa\xbd\xef\x6b\xf4\x1d\x20\xe4\x8f\xeb\xa7\x10\x65\x04\x49\xdf\x53\xff\x13\xd9\xb6\x5e\xf3\x2b\xe9\xfb\xed\x7f\x22\xe7\x02\xf4\x40\xae\x0b\x21\x9a\x76\x25\x55\xe1\x5e\x85\x63\x15\x2e\x55\x7e\x5f\xae\x33\x42\xfa\xab\xe4\xfe\xbf\xc6\xf1\xff\x35\x2e\xff\xbf\xf2\xfb\x3f\xd9\x5e\x9d\x58\x77\x9f\xe9\xcf\x5e\x42\xad\xfe\x6c\x2e\xe6\xf7\xec\xd6\x39\xe8\x8c\x83\x3e\x85\x7e\xb4\xeb\x35\xbd\xa7\x76\x0f\x51\x0c\x39\x73\x0e\x7a\x1b\xfa\x25\x44\xc7\x6d\x0a\x7e\x7e\x98\x68\x1e\x23\x07\xde\x27\xbf\xaa\xcd\xf9\x4d\x1e\xe8\xcf\x41\xfc\xc1\xcf\x34\x42\x9f\x6b\xd4\xd1\xe4\x72\xe3\x5b\x26\x3a\x57\xda\xf3\x33\x43\xf4\xc6\xef\xe2\x73\x1c\xfb\xd2\xa1\x33\x50\x6b\xe6\x9c\xbf\xfc\x39\xd2\x67\x56\xe8\x4b\xfe\xaa\xd6\xd8\x17\xfc\xee\x5c\x0d\x0d\xf6\xd9\xcf\x9c\xe4\xb2\xaf\xea\x2e\x10\x78\x1b\xf2\x42\xef\x70\x7e\xf7\xa3\x5e\x3a\xaf\x29\x2c\x44\xfa\x7b\x97\xd0\xf7\xcf\x55\x9f\xcb\x3e\xaa\x9f\xd9\xd7\xf4\xbe\x3c\x2c\x44\xfa\xfb\x74\xfd\x3d\x74\x37\xe3\xb8\xcc\x44\xef\x7b\x21\x79\xfd\x43\x75\xbf\x4d\x5a\x2f\x63\x2d\xf4\x67\xbd\xe6\x50\x99\x06\x79\x90\xb5\x48\x93\x75\x8f\xfe\x6c\x34\x70\x4c\x0d\xf3\x6f\x60\x8f\x7c\xb0\xda\xbc\xe8\x10\xc5\xe8\x77\xa3\x54\x2c\x28\x1d\x6a\x0c\x35\x32\x16\x51\xdf\xe8\xba\x54\xd7\xa1\xba\xce\x1c\xcc\x78\x84\x34\xb6\xbe\x95\x96\xa1\xcf\x60\xf4\xde\x59\x1f\x9a\x17\x3a\x8f\x33\x5c\x47\xa5\x79\xd8\x09\xfb\xbb\x18\xc3\xfa\x48\xee\xb4\xea\xb1\x77\x0b\x77\xd8\x97\xa4\x91\x3e\xff\xc2\x82\x9f\xeb\x37\xe2\xac\x6c\x14\xfa\x1c\x25\x9e\xe7\xe6\x5a\x16\x3e\x95\x3a\xf7\xc9\x14\xf3\x2d\x99\xe7\x7a\x80\x33\x3e\x5e\x0a\x5c\xef\x48\x91\x33\x15\x39\xc7\x79\x8e\x0c\x04\xf0\x6b\x5c\xe8\xfb\xeb\x5e\xa1\x76\x28\x74\x1d\xa4\xbf\xc3\xef\x16\x26\xea\x01\x4b\x54\xf4\xd5\xad\x26\xf3\x3b\xee\x8b\x9f\x49\x0b\xe7\x06\xb9\xd1\x71\x48\x46\xea\xef\xd2\x6d\x4c\xf4\xdf\x28\x94\x70\x4f\x3f\x24\xfd\x5d\x6f\xa9\x4d\x8e\x97\x54\x3d\xa3\x55\xe0\x1e\xfa\xb2\xec\xef\x90\xf5\xdf\x2a\xe8\xb6\x04\x7f\x8f\xcb\x16\xfb\xfd\x2d\xa3\x91\xf5\x96\x72\x38\xf6\x05\x7e\x70\xec\x33\x56\x05\xa9\xea\xb9\x7a\x7b\x35\xa9\xf7\x82\x63\xba\xd5\x54\x7d\xec\xff\xda\xff\xbf\x10\xf5\xc3\x15\x64\xbc\x45\x3b\xde\x7e\xe6\x06\xcb\x3d\xef\x16\xc8\x69\xbc\x2d\x53\x34\xe9\xbc\x76\x7d\xa9\xee\x85\xd6\x56\xb5\xe0\x16\x06\xcf\x43\xd6\x73\xe4\xe2\x5b\xf2\x28\xd4\x4c\x13\xfc\x33\xc3\xd2\xd4\xc1\xb0\x49\xea\xef\xae\xa1\x2a\xc7\x29\xea\x7d\x68\x90\xe5\xe3\xde\xee\xe3\x7e\x76\x14\x9c\x6a\xd9\x7f\x37\x72\xcc\x69\xc7\x40\x5a\x93\x03\x19\xa1\x5a\x2f\xd6\xce\x81\x61\xf6\x39\x4e\xbd\x11\xf8\xf0\xaa\xfa\xb1\xc9\xe5\xef\xc2\x5e\x01\x77\x2a\x61\xd7\x45\x31\x9c\x1b\x25\xdc\x7c\x91\x5a\x32\x07\x1e\x7d\x8f\xbb\x57\x06\x92\xe3\xfa\xb3\xe3\x8e\xa1\xcf\xb7\x75\xdd\xfc\x0d\xf3\x37\x6b\xaa\xf6\xdd\x80\xfe\xfc\xb8\x5c\x53\xe8\x7b\x81\x07\x8c\x7f\x73\xf7\x99\x21\xc3\x42\x7f\xe3\xd2\x1a\x7b\xba\x69\xd2\xf7\x5e\xfd\xd9\xbe\x45\x6b\xdf\x6f\xf5\x5d\x39\x74\x47\xae\x7e\x17\xd6\xf7\x5a\x7d\xbf\xb5\x16\xc8\x70\x7d\xd7\xad\x4e\x7a\x4e\x15\xfd\xf6\x9e\x1d\xf8\xd4\xe8\x14\xf8\x34\x78\xc7\x0e\x7c\x7a\xc5\x1d\x5b\xdf\xaf\xab\xee\xd6\x55\xf7\xea\xdf\xb9\x53\xeb\xbb\xba\x96\xab\xe7\xd9\x3c\xc7\x03\xdc\xf7\x2f\x7e\x01\x06\x97\x68\x2f\x4a\x68\x8f\xd2\x3f\xe4\x6d\x7d\xd6\xff\x67\xaa\x97\xb4\xd6\x44\xd7\x4d\xd5\x68\xdb\xaf\xa4\xbf\xe7\xb8\xc4\x5e\x70\xb1\x20\xf8\x5d\x88\x4d\x6d\x83\x6d\x20\xaa\x1a\x6f\x68\xae\xe6\xd7\x74\x99\xf7\x2a\xba\x18\x80\x56\x88\x5c\xf8\x92\xf6\x75\xda\x5d\xc1\xfe\x4b\x53\x98\xb7\x10\xfa\x2b\xfd\x3f\xf3\x7e\x33\x54\xca\xf3\xbd\xb4\xc9\xb4\x1d\xaf\x96\xa5\x6b\xbb\xd0\x7d\xc8\x4d\x7b\x26\xd4\xea\x58\x3f\x67\x5d\x27\xe5\x57\x51\x7f\x68\x70\xa8\xd5\x94\x63\x46\x4b\x0e\x6d\xdb\x10\x0d\x84\x5a\x40\xb9\xf4\xeb\x36\x05\x4a\x0d\x51\x13\x28\x9d\x7e\xfd\xdc\x00\xaa\x03\xb5\x0b\x51\x06\xfd\xcd\x42\xf3\xfb\x55\xa3\xd1\xf4\xf7\xfb\x1d\x3b\xf2\x42\xe3\x39\x55\xbc\x21\xbe\x74\x28\x0b\xea\x56\x45\xf4\x77\x0b\xe9\x68\x5b\x4d\x5f\x3b\xfa\xdb\x5e\xa5\xab\x4a\xce\x84\xab\x65\x57\x93\x7f\xb5\x1d\xc3\xa0\xeb\xa0\xc2\x50\x3b\x0c\xbe\x91\xb4\x1d\xa0\xf6\x21\xd2\xcf\x1d\xe8\xd7\x6d\x6f\x28\xbb\x3a\xd1\xaf\xdb\xdb\x43\x94\x15\xa2\x8e\xf4\xeb\x76\xed\xd5\xf4\x07\x76\x5c\xed\xc7\x40\xf8\x34\x96\x19\xd5\x7c\xd6\x78\x37\x08\xe1\x9c\x1e\x8a\x47\x55\x6c\x52\x42\x71\xc9\x0d\xc5\x6f\x60\x55\x4c\x43\x71\xcc\xa9\x16\x73\x3b\xfe\xa1\xb8\x5f\x61\x07\x39\xd3\x55\xaf\x87\x6a\xf7\xec\xaa\xef\xb5\x06\x06\x73\xcb\xff\xa2\xfe\xde\xf9\xbf\xd5\x72\xa1\x7a\xa5\x3a\x9d\x0b\xd1\xc7\xba\xfd\x6f\x35\x2b\x3c\x6f\x86\xe8\x67\x4d\xbf\x19\xd7\x67\xea\xf6\xd0\x77\x0e\xb4\xc1\xef\x09\xf5\x59\xed\xd7\xdf\xdb\xfd\x3b\xf8\xdd\x9e\x9f\xf5\xe3\xaf\x84\x7e\x0a\x7d\x57\x59\xa9\xcf\x7a\xfd\x37\x62\xfa\x73\x40\xfd\x5d\x16\x7d\x27\xa0\xa4\x50\xfb\x71\xb5\xef\x0e\x35\x7d\xcc\xbe\x33\xc9\x26\xbd\x0f\xe9\x3d\x8d\xbd\xa4\x8a\xec\x3d\xe9\xb8\xfe\xdc\xd3\xfe\x8e\x54\x7f\xef\x36\x46\x7f\x47\xa5\xbf\xaa\x0f\x51\xfd\xe0\x5f\x37\x5a\xcd\xed\xbf\x5b\xd4\xef\x96\x15\xad\xff\x08\x52\xff\x19\x24\xef\xb7\x99\xd3\xcc\xd9\xe6\x6d\xe6\x72\x73\xa5\x79\xbf\xf9\x37\x47\x9c\xa3\x81\xe3\x25\xc7\x3f\x1d\xdf\x35\xf8\x6b\xc3\xad\x0d\xef\x6d\xf8\xb3\xa7\x96\xa7\x81\x27\xdb\xd3\xdf\x73\x9d\xa7\xd0\x33\xc2\x33\xca\x33\xdf\x73\xc8\x73\xcc\xf3\x86\xe7\x03\xcf\xb7\x9e\xef\x3c\x7e\x6f\x94\xb7\x91\xb7\xb1\x37\xc3\xdb\xc6\xdb\xd1\xdb\xd9\xdb\xd5\xdb\xcb\x3b\xda\x3b\xcd\x3b\xdb\x3b\xd7\xbb\xc0\x7b\xb7\xf7\x71\xef\xb9\x24\x47\x52\x5c\x52\x9d\xa4\x46\x49\x8d\x93\x5a\x26\x0d\x48\xca\x4f\x1a\x9d\xb4\x30\xe9\x9e\xa4\xdd\x8d\x8c\x46\xce\x46\x51\x8d\x62\x1b\xd5\x6a\x54\xaf\x91\xa7\x51\xb3\x46\x69\x8d\x72\x1b\x15\x37\x1a\x97\x6c\x24\x47\x27\x27\xa5\x52\xd2\xa4\x86\xa7\x46\xa7\xc6\xa7\xd6\x4d\xad\x9f\x9a\x92\xda\x3c\xb5\x4d\x6a\xe7\xd4\xc9\xa9\x65\xa9\x0b\x53\x97\xa6\xae\x4c\x5d\x9f\x7a\x7f\xea\xfe\xd4\x47\x53\x9f\x4a\x7d\x3a\xf5\x58\xea\x6b\xa9\xaf\xa7\xbe\x97\x7a\xb6\x71\xe7\xc6\xbe\xc6\x3d\x1a\x17\x35\xbe\xbe\x71\x69\xe3\x49\x8d\xa7\x35\x9f\xd2\xfc\xa6\x96\x75\x1e\x4a\x7a\x68\xe5\x39\xeb\x82\x71\xa1\xdd\x85\xce\x17\xba\x5e\xe8\x7e\xa1\xd7\x85\x81\xfe\xe4\xc0\xc5\x40\xc0\xfe\x7b\xcb\x72\x73\x96\x79\xb3\xb9\x10\x04\xee\x32\x1f\x34\x4f\x38\xea\x39\xd6\x3a\x4e\x38\xce\x35\x90\x06\x7e\x10\x28\xf7\x88\xa7\xae\xc7\xeb\xc9\xf5\xe4\x85\x10\x18\xe3\x29\xf3\x1c\xf6\xbc\xe8\x79\xdb\xf3\x91\xe7\xbc\xe7\x07\xaf\x78\x63\x41\xe0\x1a\x6f\x6b\x6f\xd6\x65\x04\x6e\xf0\xce\xf2\xde\x04\x02\x6b\xbc\xe5\x21\x04\x6a\x87\x10\xe8\x9f\x34\x24\x69\x04\x08\xac\xb9\x8c\x40\x0c\x08\x24\x34\x6a\x18\x42\xa0\xa8\x51\x89\x8d\x80\xf7\x0f\x10\xc8\xbb\x8c\xc0\x9a\xd4\xf2\xd4\xbd\x97\x11\xf8\x2b\x08\xbc\x0b\x02\x1d\x2f\x23\x30\xae\xf1\x0d\x20\x50\xd4\x7c\x06\x08\xd4\x79\x68\x29\x08\xa8\x0b\x0d\x2e\x74\x00\x01\xdf\x85\x9e\x17\x72\xfc\x5e\x8d\x40\xe0\x74\xe0\x2f\x81\x67\x02\x4f\x05\x1e\x0f\x1c\x0a\x3c\x16\x78\x34\x70\x30\xb0\x2f\xd0\x21\x90\x11\x48\xfb\xdc\x5b\xf9\x75\xe5\x97\x95\xff\xac\x3c\x53\x79\xaa\xf2\x64\xe5\xc7\x95\x1f\x56\x7e\x50\xf9\x7e\xe5\x7b\x95\xef\x56\xbe\x5d\xf9\x56\xe5\x9b\x95\xff\xa8\xfc\x7b\xe5\xeb\x95\x7f\xab\x3c\x5e\xf9\x6a\xe5\xcb\x95\x2f\x54\x1e\xab\x3c\x5a\xf9\x6c\xe5\x33\x95\x4f\x56\x96\x57\xde\x53\xb9\xb6\x72\x4d\xe5\xf2\xca\x9b\x2b\xa7\x55\xb6\xad\x4c\xaa\x8c\xaf\x8c\xad\x0c\xab\x74\x9c\xf5\x9f\x3d\x79\xf6\xc3\xb3\x6f\x9f\x3d\x78\x76\xd7\xd9\xbb\xcf\x76\x3a\xdb\xe1\x6c\xc6\xd9\xf4\xb3\x2d\xce\x5e\x73\xb6\xc9\xd9\x86\x67\x1b\x9c\x55\x9f\xfd\xf3\xb3\xcf\x3f\xeb\xf7\x59\xb7\xcf\x32\x4e\x0f\x3e\x3d\xe8\x74\xee\xe9\xec\xd3\x3d\x4e\x77\x3b\xdd\xf9\x74\xdb\xd3\x2d\x4f\x37\x39\xed\x3d\x1d\x71\xea\x97\x53\x3f\x9e\xfa\xee\xd4\xbf\x4e\x7d\x73\xea\xd4\xa9\xf7\x4f\xbd\x75\xea\x6f\xa7\x8e\x9f\x7a\xf1\xd4\x73\xa7\x9e\x3d\xf5\xc4\xa9\x7d\xa7\x0a\x4e\x0d\x3d\x95\x7f\xaa\xfd\xa9\xb6\xa7\xda\x9c\x6a\x75\xaa\xe5\x87\x5d\x3f\xec\xf4\xfe\xb6\xe2\xed\xc5\xed\xeb\x1e\x8d\x38\x16\xb1\x37\x62\x4f\xc4\xee\x88\x87\x22\x76\x45\xec\xac\xf1\x56\xd8\xa5\xab\xff\xf6\xf7\xff\x0f\x7f\x9c\x46\x0d\xdd\x28\xf9\x0d\x16\xca\xbe\x34\xe9\x1f\xe3\xbf\xc8\x08\xce\x34\xb9\x68\x39\xc4\xc9\xbe\x12\x26\x6e\xa9\x21\x35\x25\x5c\x22\x24\x52\xa2\x24\x5a\x62\xa8\x14\xe2\x24\x5e\x6a\x49\x6d\xa9\x23\x75\x25\x41\xea\x49\x22\xbb\x51\x03\x69\x28\x1e\xd6\x60\x92\x34\x92\x64\x49\x91\x54\x69\x2c\x4d\xa4\xa9\x34\x93\x6b\xa8\x29\x9a\x4b\x0b\x69\x29\xe9\x92\x21\xad\xa8\x8c\x32\xa5\x0d\xf5\x4e\x3b\x69\x2f\x1d\x24\x4b\x3a\xb2\xe7\x76\x96\x2e\xd2\x55\xba\x89\x4f\xba\x4b\x0f\xe9\x29\xbd\x24\x5b\x72\xa4\xb7\xe4\xca\xb5\xd2\x47\xfa\xb2\xcb\xf6\x67\x87\x1d\x28\x79\x32\x48\x06\x53\x87\xe6\xcb\x50\x19\x26\xd7\x49\x81\x14\xca\x70\x19\x21\x23\x65\x94\x8c\x96\x31\xec\xa0\xc5\xd8\xbf\x58\x96\xc8\x32\x59\x21\xeb\x65\x93\xdc\xcb\x4d\xec\x01\xd9\x21\xbb\x64\xa7\x3c\x24\x7b\xb8\x35\xee\x95\xfd\xf2\xb0\x1c\x90\x47\xa4\x42\x0e\xca\x63\xf2\xb8\x1c\x92\xc3\x72\x44\x9e\x90\xa7\xe5\x4f\xf2\x67\x79\xc6\xf5\xa5\xdc\x28\x25\x32\x4e\x26\xba\xbe\x96\xb9\x72\xbf\x4c\x97\x49\x61\xd7\xc8\x1c\xb9\x21\xac\x8f\x2c\x95\x2d\x61\xd9\x54\xe4\xfd\xc2\xfa\xcb\x78\xb9\x29\xac\x4b\x98\x2f\xac\x9b\x79\x63\x58\xae\x4c\x96\x5b\xcd\x11\xb2\x5b\x9e\x92\xdb\xe5\x7a\x99\x1a\xd6\x4b\xe5\x87\x5d\x1b\xd6\x55\xa6\xc8\x7c\xd7\x37\x32\x56\xee\x90\x45\xb2\x51\xc5\xab\x5a\xae\x8f\x5d\x9f\xb8\x2a\x5d\x9f\xbb\x4e\xbb\xce\xc8\x93\x61\x2b\xe4\x39\xd5\xd1\x75\x29\x2c\xd1\xf5\xb3\xeb\x97\xb0\x17\xc2\x5e\x74\x7d\xc5\xcd\xec\x33\xd7\x17\xae\xef\x65\xa1\xac\x94\x3b\x65\x95\x2c\x97\xd5\xb2\x46\xd6\xca\x5d\x72\x8f\x6c\xc0\xc3\xbb\xa9\x0f\xb7\xcb\x56\xf9\xb7\xb1\xd4\xb8\x57\x66\x18\x5b\x8c\xad\xc6\x36\xb9\xd9\xb8\xcf\xd8\x6e\x2c\x13\xf1\xf5\x1e\x31\xbc\xb0\x60\x68\xfe\x90\xc1\x83\xf2\x06\x0e\xe8\xdf\xaf\x6f\x9f\x6b\x73\x7b\xe7\x64\xf7\xea\xd9\xa3\xbb\xaf\x5b\xd7\x2e\x9d\x3b\x75\xcc\xea\xd0\xbe\x5d\xdb\x56\x19\xe9\x2d\x5b\x34\x6f\xda\xa4\x71\x6a\x4a\x72\xa3\x24\x4f\xdd\xf8\x98\xe8\xa8\xc8\x88\x9a\x35\xdc\x61\x2e\xa7\xc3\x32\x0d\x25\xcd\xbd\x15\xaa\x28\xbb\xc2\x4c\xf5\xc6\xe4\x14\x27\x67\x27\x17\xe7\xb6\x68\xee\xcd\xae\x3b\xa1\x57\x8b\xe6\xd9\xc9\x39\x45\x15\xde\x62\x6f\x05\x8d\xd5\x38\x39\x37\xd7\xee\x4a\x2e\xae\xf0\x16\x79\x2b\x1a\xd3\x14\x57\xeb\x2e\xaa\xf0\xc1\x59\x7a\x15\xa7\x2f\xc8\xe9\xbb\xcc\xa9\xa2\xbd\x9d\xa5\xb3\x56\x91\xec\xad\x38\xde\x2b\xd9\x7b\x44\x0d\x1f\x54\xc0\xf3\xaa\x5e\xc9\x85\xde\x8a\xaf\xed\xe7\xfe\xf6\xb3\xd5\xd8\x7e\x89\xe0\x25\x29\x89\x19\xb6\x55\xda\x5a\x6f\x76\x45\xce\x9c\x09\xcb\xb3\x8b\xb0\x51\x1d\xac\x59\xa3\x67\x72\xcf\x71\x35\x5a\x34\x97\x83\x35\x6a\xf2\x58\x93\xa7\x8a\xa6\xc9\xd3\x0f\xaa\xa6\x5d\x95\xfd\x60\x34\xcd\xee\x78\xd0\x90\xb0\x08\xad\x16\x4f\xb3\x8b\x4b\x2a\xf2\x06\x15\x64\xf7\x4a\x4c\x4a\x2a\x6c\xd1\xfc\xda\x8a\xc8\xe4\x5e\xf6\x90\xf4\xb4\x45\x56\x38\x7b\x56\xb8\x6c\x91\xde\x89\xda\x74\x59\xe1\x3d\xd8\xfc\xe8\xf2\x95\x47\xa2\x65\x6c\x51\x5a\x78\x49\x72\x49\xf1\xc8\x82\x0a\xb3\x98\xb9\xcb\xcd\xec\xe5\xcb\x97\x54\xc4\xa4\x55\x34\x4b\xee\x55\xd1\xec\xe6\x33\x75\xf1\x7c\x5c\x45\xf3\xe4\x5e\xd9\x15\x69\x5a\x6a\xdf\xc1\x97\xf5\xf4\xfd\x55\xa5\xaa\x70\xa4\x72\x6c\x2c\xff\x5e\x70\x27\xf9\xeb\xaf\xae\xec\x29\x0e\xf5\x38\x53\xa3\xbf\x17\xfd\x58\x61\xf4\xac\x50\x83\x0b\x92\xf4\x4f\x62\x0e\x58\x2f\x5f\x9e\x93\xec\xcd\x59\x5e\xb4\xbc\xf8\x48\xa0\x6c\x6c\xb2\x37\x3a\x79\xf9\xc1\xf0\xf0\xe5\xd3\xb3\x81\x5b\xf2\x0a\x10\x71\x24\xf0\xd4\x8a\xc4\x8a\x9c\x95\x85\x15\xd1\x45\x13\x54\xc7\xc2\x90\xeb\x39\x83\xfb\x56\xc4\x0d\x1a\x51\x50\x61\xa4\xe6\x78\x27\x14\xd3\xc3\xff\xba\x25\x27\x75\x48\x4c\x8a\xb9\xcc\x93\xf7\x47\xc3\x02\x2c\x80\x03\xc2\x49\x49\x1a\x86\x15\x47\x7c\x32\x96\x97\x8a\xb2\x41\x05\xc1\x77\xaf\x8c\x4d\x7c\x54\x7c\xe9\x69\x85\x15\x46\x91\x1e\x39\x5a\x35\x52\x6b\xa8\x1e\x29\xab\x1a\xb9\x3c\xbd\x28\x99\xd8\xf6\x1d\x52\xb0\xbc\xc2\x4a\xbd\xb6\x24\x39\x1b\xc4\x57\x14\x57\x94\x8d\x25\xbb\x6e\xd0\x81\x49\x8e\xae\x88\xfc\x21\x31\x29\x79\x79\x6c\x8c\x37\x2b\xbd\xd0\xe6\xf5\x62\xd5\xb5\x25\x13\xbd\x15\x8e\xc6\x80\xc4\xac\xea\x13\xc8\x1b\x3d\x65\x79\xb4\xfd\x12\xf9\x43\xb0\xf9\x3a\x11\x05\x8d\x63\x62\xbd\x59\xc9\x88\xd1\x72\xb2\x93\xb3\x8b\x42\xff\x9b\x33\xa1\x2e\x02\xbc\x00\x9d\x9b\x16\x4c\x84\xfc\x82\x0a\x5f\x2f\x1e\x7c\xc5\xa1\x88\x65\x1f\xcc\x48\x67\x46\x71\x11\x01\x9b\xd8\xcb\x0e\x66\x45\x7a\xf2\xf4\x8a\xf8\xe4\x1e\x97\xa3\xab\xcd\xca\x9e\x38\xa4\xc0\x9e\x12\x9a\x56\x11\xdf\xb3\x42\x8a\xae\x0f\xcd\xaa\x48\xcf\xb6\xd7\x95\x37\x7b\x79\x51\xaf\xa0\x09\x5a\x56\xf2\xa0\x82\x27\x25\x33\x70\xf2\x60\x1b\x6f\xe2\x63\x7a\xeb\x2c\xec\xa5\x99\x6b\xf7\x24\xcb\x1a\x67\x2f\x2f\x28\x29\xad\xf0\x14\x25\x96\xb0\xee\x4a\xbd\x05\x89\x49\x15\xbe\x42\x22\x5c\x98\x5c\x30\xae\x50\xa7\x1d\x08\x35\x3b\x99\x68\x27\x47\xa1\x9d\x2b\xf9\x05\x7d\x87\x24\xf7\x1d\x34\xbc\xa0\x43\xc8\x90\xe0\x80\x16\x67\xa5\x66\x5f\x25\x26\xb9\x20\x31\x28\x86\x04\xac\x08\x4b\x0d\xf3\x16\x18\x89\x66\x21\x8c\xd1\x74\x78\x73\x78\x48\xee\xd1\x99\xdf\x15\xae\xd4\x30\x28\x1a\xc0\xed\x5e\x9d\xb8\x3d\x3a\x7b\x0b\x54\xa2\x54\x71\x63\x46\x45\x33\x6f\xf6\xb8\x5e\x21\x3e\xfd\x7e\x85\x50\x87\x4e\xa7\x9e\xb9\x55\xd2\x9c\xfa\x15\x39\x3d\x73\x13\x93\x0a\x93\x82\x3f\x2d\x9a\x1b\x0c\x7b\x43\x8a\x99\x11\xa6\x41\xcd\xad\x1a\x62\x9b\x62\x20\x8c\xfc\xec\x99\x6b\x77\x69\x2c\xeb\xea\xa4\xf7\x16\x24\x8f\x4b\x2e\x4c\x9e\xe0\xad\xf0\xe5\x15\x68\xdf\x34\x3c\x36\xca\x21\x30\x6c\xcc\x43\xb1\xca\xbf\xe2\xad\x1a\x58\xc0\x24\x49\x0c\x57\xbd\x68\x30\x2b\x72\xd2\x12\xab\x83\x5b\xd1\xdb\x7e\xbf\xfc\x9a\x7b\xd5\xf0\xb5\x55\xc3\xde\xe5\x61\xc9\x7d\x87\x2c\xd7\xc2\x93\x43\x02\x05\xcb\xaf\xad\x10\x9d\xc2\xbe\x0e\x31\x89\xf6\x5e\xa0\x17\x74\x32\x7b\xaf\x37\x9a\x25\x6d\x2f\xe8\xe5\x07\x7d\x3e\xbd\x98\x27\x74\xd4\x42\x92\xaf\x2d\x59\x9e\x3c\xa4\xa0\xb3\xcd\xcd\x7e\x32\x3f\xf1\x66\xad\x2b\x56\xfa\xaa\xbe\xf9\x3d\x5a\x34\x67\x6b\xeb\x71\x30\x59\x2d\x1d\x74\xd0\xa7\x96\x0e\x19\x5e\xf0\x24\x97\x06\xef\xd2\xfc\x82\x47\x0d\x65\xf4\x2c\xea\x51\x78\x30\x85\xb1\x82\x27\xbd\x1c\x1a\x76\xaf\xa1\x7b\x75\xa7\x7e\xf1\xea\x17\x2d\x69\x30\x2f\x61\x36\x7f\xe2\x93\x3e\x91\x32\x7b\xd4\xb2\x3b\xec\xf7\xeb\x8f\x28\xb1\xfb\xc2\xaa\xfa\x94\x5c\x7f\xc4\x08\xf6\x45\x07\x15\x35\xb6\x15\xf9\xa8\x41\xae\x3f\x62\x05\x47\x7c\x55\xdc\x16\x7d\x61\xc1\xbe\x32\xbb\xcf\xfe\x39\x28\x1a\x32\x5f\x0d\x87\x2f\xcc\xe7\xf6\x85\x1b\x11\x46\xe2\x41\xa5\xbb\x1e\xa5\xe7\x29\x6a\x15\xb7\x92\xc7\xc2\x55\x84\x4a\x3c\xc8\xac\xc1\x76\xf7\x11\x55\x76\xd0\xed\x4b\x0c\x72\x94\xc1\xe1\x0b\x5a\xb8\x74\xe8\xaf\xaa\x87\x0e\x2f\x78\x8c\x8a\x46\x25\xda\xbf\x51\xd4\x43\xff\x90\x2e\x75\x27\x10\x6c\x8e\x95\x6c\x6f\x89\x4e\x94\x5b\x0b\x27\x2c\x2f\x2a\xd4\x8b\x4d\x6a\x13\x1a\xfe\xa7\x2a\x54\x72\x57\xc2\x94\xdc\x15\x43\x9c\xe1\x15\x35\x92\xc7\xf5\xa8\xa8\x99\xdc\x43\xf7\x77\xd3\xfd\xdd\x82\xfd\x4e\xdd\xef\x22\x45\x55\x6d\xc5\xf4\x32\x62\x9f\x57\xa1\x74\x06\x8c\x28\x48\x62\x49\x7a\xeb\xbd\x92\xb8\x3c\xfa\x6b\x1d\xa9\x42\x36\x95\xe5\xd1\x9f\xb5\x38\xe8\xce\xeb\x3e\x56\x8d\x13\xa5\x26\xa8\xf1\x94\x58\x1e\x55\x24\x03\xd4\x18\x19\xaa\xba\x4b\x17\xe5\xa3\x05\x54\xd5\x83\xb6\x27\xef\xba\x6d\xa9\xba\x48\x19\x7c\x5d\xe8\xef\xca\x3b\x45\x94\xea\x44\x61\xe4\xe1\x77\x37\x68\x20\xb4\x1a\xb2\xa0\x20\x47\x06\x1c\xe9\xb4\xe9\xa1\xf7\x16\xbc\x37\x67\xc6\xeb\xfc\x56\x36\xe9\xde\x6e\xf4\xea\xb6\x0f\xef\xb9\xb4\xbd\x43\x6d\x0e\xfd\xd9\xb4\xd9\xa1\xf7\x6b\x79\xa7\x95\x22\xe5\x22\xdc\xdd\xec\xdf\xcf\x2a\xcb\xf7\x98\x3a\x79\x49\xbd\x7e\x49\x79\x2f\xa9\x05\x17\x54\xde\x05\x55\x76\x7e\xcd\x79\xe3\x5f\xe7\x9a\x79\x0e\x9c\x7b\xf6\x9c\x31\xf0\xdb\x31\xdf\x1e\xf8\xd6\xcc\xf8\x56\x45\x7d\xab\xc2\xe4\xeb\xe8\xaf\xf3\xbe\x2e\xfa\x7a\xfa\xd7\xe5\x5f\x3b\x6b\x44\x7d\xa5\xc2\xe5\x4b\x15\x73\xfa\x64\x07\xcf\x27\x5d\x3e\x1a\xfa\x71\x97\x0f\x87\xca\x47\x78\xf6\x51\xc6\x47\x79\x1f\x95\x7d\x54\xf1\x91\xe3\x23\x65\x0e\xfd\xd0\xac\xed\x89\x3e\xea\x3d\x9a\x71\x74\xfa\xd1\xb2\xa3\x27\x8e\x9e\x3c\x7a\xee\x68\x58\xd9\x33\x6b\x9e\x31\xfe\xfc\x74\xba\x27\xea\x69\xcf\xd3\x86\xe7\xb1\x81\x8f\x2d\x78\xcc\x2c\xda\xad\xa2\x76\x7b\x76\x1b\x79\x5b\x8b\xb6\x1a\x6b\xb6\xa9\xa8\x6d\x9e\x6d\xe9\xdb\xcc\x2d\x9b\x5b\x7a\x36\xf7\x6e\xe8\xd9\xb8\xa1\x89\xe7\xe4\x86\x73\x1b\x8c\x23\x81\xa3\x8f\x6d\x88\x88\xc9\x79\x5a\x0d\x54\xfd\x28\x46\x3d\x6a\xc0\x63\x66\xc0\x73\xa0\x7b\x2d\xd5\x1f\xb7\xa2\x94\xfe\x8b\x86\xfe\x92\x0e\x0d\x84\xa6\x41\xab\x21\x27\x23\xfd\x18\xe9\xc7\x48\x3f\x5f\x07\x73\xcc\x3d\xaa\xe6\xba\xc4\x75\x69\xeb\x6e\x59\xb7\x62\x9d\x63\xfa\xe2\xb2\xc5\x6b\x16\x9b\x65\x8b\xd6\x2c\x32\x0e\xcc\x79\x76\x8e\x31\x33\xaf\x99\x67\xda\xd4\x34\xcf\xd4\xde\xd7\x78\x12\x32\xeb\x0e\x75\x65\x9a\x43\x9d\xa8\x41\xbb\xef\xda\xb1\xa9\x4d\x73\x8a\xc6\xf8\x3c\x63\x60\x1a\x31\x3c\xc3\x33\xbc\x77\x33\x4f\x5c\x66\xec\x50\x07\x0e\x5b\x30\x46\x99\x1e\xb3\x9b\x39\x90\x7b\xfe\x6a\xf3\x59\xd3\x15\x36\x38\xaf\xa1\x67\x10\x74\x32\xef\x5c\x9e\xe1\xcb\x73\x87\xe7\x44\x0d\xf4\x0c\x4c\x1f\x68\x1e\x09\x9c\xf4\x8d\xeb\x9b\x84\xb4\x3e\xd3\xfb\x94\xf5\x31\xaf\xcd\x69\xe6\xc9\xed\xdd\xc1\x13\xd5\xdb\xd3\x3b\xbd\xf7\xeb\xbd\x3f\xe9\xfd\x6d\x6f\xe7\x98\xde\xea\x3e\xfe\x97\x73\x20\xe7\xd9\x1c\xd3\x97\xd3\x2c\x3d\xc7\x97\xd3\x30\x29\xa7\x7e\x6e\xe2\xd0\xda\x99\xb5\x86\xc6\xa8\xa8\xa1\xd1\x99\x51\x43\xa9\x01\x87\xaa\x4c\x19\x9a\x1e\x15\x88\x32\xa2\xa2\xc6\x44\x2d\x88\x32\xa3\x28\xd4\x8d\xb2\xda\xca\xa1\x8e\xa8\x35\x07\xf3\x87\xa4\xa5\xf5\x3d\xe2\x0a\x50\x3b\x84\xe5\x8d\xa8\x50\x4b\x2b\x52\x87\xe8\xdf\xbe\x41\xc3\x2b\x9c\x4b\x2b\x64\xe8\xf0\x11\x05\x07\x95\xba\xab\x70\xd1\xaa\x55\xd2\xa3\x41\xdf\x8a\xd6\x43\x0a\x2a\x8a\x1a\x14\xf6\xad\x28\xe1\xc1\xa7\x1f\xca\x78\x88\x6e\x70\xb0\xb6\xf4\x28\x9c\x39\x73\x56\x9a\xfd\xa3\xd2\xd2\x78\x9e\xcd\x6f\x49\x9b\x9d\x46\xe7\xe8\x99\xc1\x5e\xb9\x3c\x2e\x69\x33\xd5\xcc\x99\x32\x73\xa6\x3d\x49\xa5\x69\x86\xe0\xbb\xe2\x77\x9a\x1e\xa3\x43\xcf\x53\xcc\x1e\x3d\x53\xf4\x2f\x3d\x98\x16\x9c\xa4\x67\xcf\x0c\x89\xb3\x27\x07\x7f\xd9\x0f\x75\x47\x3b\x56\x71\xc7\xc9\x75\x74\xe1\xd6\x33\xdd\xfe\x7d\xc5\x8f\xb9\x9f\x9b\xcf\x66\x91\x80\xfd\x37\xe5\xbf\xfe\xf6\xf7\x0b\xfc\xf2\xff\xed\x05\xee\xf7\x7e\x42\x9f\x2e\x6f\xe2\xfe\x72\x88\x7b\xc0\x7b\xdc\x73\x82\x3f\x39\xdc\x85\x26\xca\x6c\xfd\x3d\x55\xb5\x9f\xe7\xe4\xef\xf4\xea\x9f\x3c\xee\x45\x7b\xb9\x37\xfc\xfe\xcf\x7e\xee\x3b\xc3\x43\x7c\x45\xdc\x2d\x36\xff\x01\x5f\x9e\x6c\xe4\x86\xf4\xd2\x15\x5a\xf2\xb8\xd1\xdc\x82\x2d\x8f\xcb\x7b\xaa\x95\xbc\xc2\xa5\x71\x9a\x9c\x67\x21\xdf\x2e\x2f\x20\xf5\x3c\x7d\xfd\x7f\x4f\x94\x11\xc9\xaf\x52\xfb\xb1\xb4\x5a\xef\x07\xb2\xd5\x58\x21\x7d\x8c\x33\xbc\x6c\xd6\x23\x46\xba\x11\x2d\xc7\x64\x9b\x1a\x6d\xff\x8b\xe4\x1c\x34\x55\x79\xdc\xf9\x37\x42\x97\xc8\x7c\x7e\x0f\x91\x09\xdc\xce\x96\x04\xbb\x1c\x5d\x2e\xbe\x2f\xee\xc0\xbf\xf1\x6a\x3e\x77\xc7\x3b\xb8\x51\x4e\xae\x36\xe3\x69\x75\x9f\xc9\x3d\xd9\xcc\x97\xfb\xc0\xf4\x39\xbb\x2f\xbd\x6a\xd0\x95\x6b\xde\x60\x1c\x36\x8c\x4b\xeb\x79\x59\xcb\xfd\x6e\xad\x14\x2b\x7c\x37\x56\x99\xdd\xff\x00\xa1\xff\xf3\x8f\x39\x94\x33\xa7\x99\x99\xca\xcd\xfa\x77\x7e\x8c\x36\x12\xe5\xff\xc5\x68\x1d\xf8\xce\x4c\xe1\xe6\x3d\x54\xff\x5b\x86\x60\x5f\xa0\x6f\xe0\xdf\x66\xb1\x7f\xaa\x35\xc6\xaa\xef\xe8\x62\xbd\xfa\x9f\x74\x38\xd7\x5a\x53\x98\x2d\x81\xcf\xfc\xb7\xf8\x4b\x1c\x03\x1c\xbb\x88\xd6\xee\x3f\xe2\x56\xbd\xd0\x31\x1d\xcb\xe6\x8a\x58\x47\x41\xf0\x10\x48\x6c\x22\xf7\x3e\xe7\x84\xed\x07\x55\x88\xd4\x4c\x81\x6e\x85\x88\x53\x38\x63\xe1\x1f\x8a\x44\xd4\x85\x18\x8b\x6c\x0e\xc1\x1b\xf5\x9d\x48\xf4\x52\x91\x98\x91\x22\xb1\xcc\x8b\x7d\x59\x24\xee\x69\x91\x78\x34\xd7\xda\x21\x52\x7b\x02\x84\xfc\x3a\x4d\xa1\x32\x91\x84\x6d\x22\x89\x05\x22\x0d\x48\xf2\x86\x25\x22\xfa\x1f\x7e\x7b\xd0\xed\x65\x2c\xe9\x98\x48\x23\xe4\x25\x5f\x14\x49\xed\x20\xd2\x38\x43\xa4\x09\xb2\xf5\x9f\x80\x36\x43\xf7\x35\xf0\xa4\xc5\x8b\x34\x47\x56\x0b\xfa\x5a\xbc\x2b\xd2\x12\x5b\x32\xda\x88\xb4\xaa\x2f\xd2\x9a\xfe\xcc\xd7\x44\xda\xc0\xdb\x16\x3d\xfa\xcf\x6f\xda\x63\x63\x07\xe4\x65\x9d\x14\xe9\x98\x0f\x2d\x14\xe9\x74\xb7\x48\x67\xfc\xee\x82\xcd\x5d\xd1\xdf\x95\x35\xdc\x0d\x59\xdd\x8b\x44\x7a\x62\x7b\xaf\x37\x45\xb2\x69\x7b\x33\x3f\x17\x99\xb9\xd8\xd4\x97\x3c\xec\x87\xdd\xfd\xe1\x19\x90\x27\x32\x10\xdb\x06\xa2\x2b\x0f\x3d\x83\xc0\x62\x30\x25\xd6\x10\xe6\x0c\xc5\xae\x61\xf0\x16\xa0\xa7\x70\x96\xc8\x70\x30\x1c\x81\xff\x23\xc9\xc7\x91\xc8\x19\x85\xcc\xd1\xd8\x31\x86\xbe\x22\xf4\x14\xaf\x11\x19\xbb\x52\xa4\x84\x39\xe3\xc0\x6b\xfc\x09\x91\x09\xf0\xdd\xc0\xf3\x64\xe4\x4d\xc6\xf6\x29\xe1\x22\x53\xcb\x21\xf8\xa7\xf3\x3c\x9d\x98\xcc\xa0\xbd\x11\xf9\xb3\xb0\x6f\x36\x98\xcc\x41\xee\x9c\x5c\x91\xb9\xe8\x9b\x8b\x6f\xf3\xc0\xf2\x16\x70\xb8\x15\x79\xf3\xe1\x9d\x8f\xce\x05\xd8\xbd\x00\x0c\x17\x80\xd9\x02\xf0\x28\xc3\xe6\x32\xf2\xa0\x0c\xfe\x3b\x89\xeb\x9d\x3e\x88\x9c\xb8\x13\x5d\x77\x32\x6f\x21\x32\x17\x82\xed\x42\xe2\xb4\x10\xcc\x16\x12\xdb\xc5\x5e\x08\x39\x8b\x91\xb3\x18\x39\x8b\x91\xb3\x04\x39\x4b\x90\xb3\x84\xf7\xa5\xc4\x7d\x29\x58\x2e\x03\xd7\x65\xc4\x70\x19\x7e\x2f\x03\xa3\xe5\xf8\xb4\x92\x79\x2b\xd1\xb5\x12\xf9\x2b\x91\xb5\x92\x3c\x5f\x45\xdc\x56\x61\xf7\x5d\xf0\xdc\x85\xcd\x77\x11\x8b\xd5\xf8\xb3\x1a\x3c\x56\xa3\x77\x35\xf8\xac\x26\x3f\x56\xe3\xcb\x1a\xec\x59\x43\x3c\xd7\xa2\x6f\x2d\xb2\xd7\x12\x8b\xb5\xe4\xc7\x5a\xf4\xae\x65\x7c\x1d\xb8\xac\x27\xdf\xd6\x33\x67\xfd\x11\x08\xdb\xee\xc6\x8e\xbb\x89\xd5\x3d\xe8\xbb\x07\x7d\x1b\xb0\x7f\x03\xfa\x36\x60\xd7\x06\x7c\xda\x40\xff\x06\xfa\x37\xa2\x73\x23\x3e\x6c\xc4\xff\x8d\xf4\x6f\x24\x3e\x1b\xc9\xfb\x4d\xf4\x6f\x02\x97\x4d\xf4\x6f\x3a\x23\xf6\xa6\xb9\x19\x1b\xb7\x80\xd7\x16\x6c\xdc\x82\xbe\x2d\xc4\x6f\x0b\xfa\xb6\x60\xc3\x56\x6c\xdc\x4a\x3e\x6c\x25\xb7\xb6\x82\xd1\xd6\xfd\x10\x58\x6e\x25\x8e\xdb\x90\xb5\x0d\x59\xdb\x98\xb3\x8d\x39\xdb\xf0\x6b\x1b\x36\x6e\x47\xce\xbd\xd8\x7c\x1f\xf1\x05\x1a\x29\x27\x86\xe5\xc4\xab\x1c\xac\xca\xc1\xb3\x9c\x3c\x2b\xc7\xc6\xfb\x99\x7f\x3f\xf3\xef\x47\xff\x03\xe8\x7f\x80\x35\xf9\x00\x98\xed\x20\xbe\x3b\xf0\x71\x07\xf9\xb9\x93\xb9\x3b\xd1\xbd\x13\xdd\x3b\x99\xbb\x13\xdd\xfa\xab\xc1\x5d\xcc\xdb\xc5\xf8\x2e\x30\x7a\x08\xec\x76\x83\xc1\x6e\xf2\x67\x37\x76\xec\xc6\x8e\xdd\xd8\xbe\x07\x39\x7b\x98\xbf\x07\x9e\xbd\xac\xe5\x7d\x60\xb5\x4f\xb7\xf8\xbe\x8f\xf8\xec\x03\x93\x7d\x60\xb0\x0f\x5f\x1e\x46\xff\x23\xf0\x3e\x82\x9c\x47\xc0\xf2\x11\xec\x7f\x04\x0c\x1e\x21\x3e\x07\x88\xcf\x01\x7c\x3a\x40\x7c\x0e\xd0\x7f\x80\xfe\x03\xf8\x59\x41\x2c\x2a\xd0\x5d\x81\x7d\x8f\x82\xc1\xa3\x38\xfb\x28\xf6\x3f\xca\x9c\x43\xc8\x78\x9c\xb1\xc7\x89\xf9\xe3\xc4\xf4\x71\x6c\x7a\x9c\x3c\x3a\x0c\x9e\x87\xc9\xf1\xc3\xf4\x1f\xc6\xd6\xc3\xd8\x70\x18\xfe\x27\xd0\xf1\x04\xb9\xf9\x04\x3a\x9e\x60\xad\x3d\x41\x0e\x3c\x01\x7e\xdc\x28\xe4\x08\xfd\x47\xf0\xf5\x08\xfd\x47\xc0\xff\x08\xbe\x3d\x09\x06\x4f\x82\xe7\x53\xc4\xf8\x4f\xe8\xf9\x13\x78\x3e\xcd\xd8\x9f\x79\xfe\x33\xb6\x3d\x03\x16\xcf\xf2\xfc\x2c\xfe\x3d\x4b\xae\x1e\x05\xbb\xe7\x88\xc1\x5f\xc0\xfc\x2f\xf4\x3d\x0f\x26\xc7\x18\x7f\x81\xf7\x17\xd0\xf3\x22\x36\xbe\x84\xcd\x2f\x93\xbf\x2f\x63\xcf\x2b\xe0\xf0\x0a\x58\xff\x95\x75\xfb\x2a\xb2\x5e\x45\xc6\x6b\xf8\x77\x1c\x1b\xfe\x86\xfd\x7f\x63\xce\xeb\xbc\x9f\x40\xce\xdf\x91\xf3\xf7\x9f\x44\xfe\x81\xfe\x37\xc0\xe2\x4d\xec\x7d\x0b\xbb\xdf\xc2\xb7\xb7\x91\xf9\x36\x3c\xef\x10\xcf\x77\xb0\xfb\x5d\xfc\x7e\x4f\xff\x69\x0a\x73\xdf\x67\xec\x03\xec\xff\x90\xb8\x7c\x08\x6e\x1f\x31\xf7\x63\xec\xf9\x18\xbd\x9f\xa0\xe7\x24\x72\x4f\x92\x1b\x9f\x92\x17\xa7\x88\xd9\x69\x64\x9c\xc6\xb7\x33\xc4\xe0\x33\x74\x7c\x06\x9e\x67\xc1\xf3\x2c\xb6\x9e\x25\xef\xcf\xf2\x5e\xc9\x7b\x25\x71\xac\x44\x6e\x25\xf2\x2a\xb1\xbd\x12\x9c\x2b\xf1\xa3\x92\xfd\xa7\x12\xbb\x3f\x87\xe7\x73\xe6\x7f\x8e\x2d\x9f\x23\xeb\x73\xec\xfc\x1c\xfc\xbe\xc0\x8e\x2f\x58\xd3\x5f\x80\xc5\x17\xf0\xfd\x93\xfc\xf9\x27\xb9\xff\x4f\xf8\xfe\x49\xbe\xfc\x53\xf7\x81\xc3\x97\xcc\xf9\x12\x7d\x5f\x11\xb3\xaf\xd0\xf3\x15\x7e\x7c\xc5\xf8\x57\xe4\xf5\xd7\xe8\xf9\x96\x79\xdf\x92\x2f\xdf\xd2\xff\x2d\xfd\xdf\xd2\x7f\x0e\x7f\xff\x85\x1f\xff\x62\xde\xbf\xc0\xea\x3c\x18\x9e\x27\x1e\xe7\xc9\xeb\xf3\xf4\x9f\x27\xde\xe7\x19\x3b\xcf\xd8\xbf\x19\xfb\x0e\x19\xdf\xd1\xf7\x1d\xfe\x7e\x8f\x9e\xef\xe1\xfd\x1e\xbd\xdf\x63\xeb\xf7\xc4\xef\x07\xfa\x7e\xc0\x87\x1f\xc8\xbb\x1f\xd0\xf1\x03\x3a\x7e\x20\x8f\x7f\x04\xa3\x1f\xb1\xf7\x47\xd6\xfc\x8f\x60\xfa\x23\xf2\x7e\xc2\x87\x9f\xc0\xe2\x27\x70\xf8\x89\xf9\x3f\xe1\xc3\xcf\x60\xf4\x33\x32\x7f\xc6\xd7\x9f\xc1\xe5\x67\x70\xfe\x85\xd8\xff\x82\xff\xbf\x80\xfd\x2f\xe4\xeb\x2f\xe8\xb9\x80\x1d\x17\xd0\x73\x01\xde\x0b\xf8\x73\x11\xdb\x2e\xbe\x16\xfc\xbb\x81\x4b\xc8\xbd\x04\xe6\x7e\xfd\x6f\x15\xbf\xe3\x86\x71\xd4\xbe\x54\x29\xf5\xa1\x28\x23\x1c\xea\x2c\xca\xd4\x7f\x41\x98\x02\x8d\x84\x76\x43\x8c\x39\x9a\x42\x05\xd0\x52\xe8\x69\xe8\x73\x51\xce\xba\x10\x73\x5d\x1c\xe5\x61\xd1\x10\x7c\x6e\x2e\x8b\x35\xe8\xab\x39\x5d\x54\xf8\xad\xa2\x22\x56\x42\xdb\x44\x45\x22\x33\xca\x2b\x2a\x9a\x39\xd1\xaf\x89\xe2\xac\x56\x31\xc8\x88\xfd\x49\x54\x1c\x36\xc4\x9d\x10\x15\xcf\x7b\x6d\x6c\xa8\x8d\xce\x3a\x13\x44\xd5\xcd\x80\xb0\x31\x01\xfe\x7a\x73\x45\x25\x76\x10\x55\x1f\x3d\xf5\xd1\xd3\x60\xa1\xa8\x86\xd8\xd4\x90\x67\x0f\x76\x79\xb9\x44\x7a\xcf\x89\x4a\x3a\x24\xaa\x51\x3f\x08\xb9\xc9\xcc\x4d\xb1\xa0\x33\xa2\x1a\xd3\x36\x7e\x53\x54\x13\xec\x6a\x5a\x22\xaa\x19\xfc\xcd\x90\x7b\x0d\x72\xd3\xb0\x29\x0d\x1b\x9a\x97\x89\x6a\x81\xac\x96\x61\x10\x7d\x2d\x67\x89\x4a\x6f\x03\x31\x3f\x03\x99\xad\x98\xd3\x1a\xfd\xad\x2f\x8a\x6a\x03\x4f\x1b\xe6\xb4\x65\x4e\x3b\xfa\xda\xe1\x5b\xbb\xaf\x44\xb5\x47\x7f\x07\xfc\xcd\xe2\x3d\x6b\x87\xa8\x8e\x60\xd1\x11\xdf\x3a\xe1\x4f\xa7\x77\x45\x75\xe6\xbd\x0b\xfc\x5d\xb0\xa5\x2b\x38\x76\x03\xaf\x6e\xcc\xf3\x61\x57\x77\x9e\xbb\x23\xb3\x07\x3c\x3d\xd1\xdf\x13\x3c\x7a\x21\xbf\x17\x7e\x64\x83\x7b\x0e\x78\xe4\x30\xa7\x37\x36\xe7\xf6\x82\xe8\xbf\x16\x9f\xfb\x80\x45\xdf\xfa\x10\xba\xfb\x61\x6f\x3f\xfa\xfa\xbf\x2c\x6a\xc0\x26\x51\x03\xf1\x35\x0f\xbb\xf3\xc0\x63\x10\xe3\x83\x89\xeb\x60\xe6\x0d\xa9\x10\x95\x3f\x59\xd4\x50\xec\x1a\x06\xde\xd7\x31\x5e\x70\x52\x54\x21\xf3\x86\x63\xef\x08\x64\x8c\xe4\x79\x14\x18\x8c\xc6\x86\x31\xd8\x3c\x06\xac\x8b\x8e\x89\x2a\x26\x76\x63\xe3\xa1\x72\x51\xd7\xe3\xe7\xf5\xe8\x29\xc1\xb6\x12\x70\x1a\x87\x1f\xa5\x60\x53\x8a\xfd\xa5\xc4\xa7\x94\x98\x95\xe2\x4f\x29\xb8\x96\x82\x47\x29\x72\xc7\x93\x17\x13\xe0\x99\x00\xcf\x04\x78\x26\x30\x67\x02\x7e\x4d\xc4\x8f\x1b\xf2\x20\xf4\x4d\x82\x67\x12\xb9\x33\x09\x2c\x27\x11\xa7\x49\xd8\x37\x19\x1d\x93\xb1\x77\xf2\x11\x08\xcc\xa6\x20\x7b\x0a\x73\xa6\x60\xe7\x54\xf2\x66\x2a\x63\x53\xef\x86\xe0\x9d\xce\xd8\x74\x6c\x9d\x01\x1e\x33\xf6\x8b\x9a\x89\xcc\x99\xe0\x39\x0b\x5b\x66\xd1\xce\xa6\x7f\x36\x31\x98\x83\xee\x39\xc4\xf3\x26\xf8\x6f\x42\xd6\x4d\xf8\x3e\x17\x2c\xe7\xe2\xe3\x5c\x64\xcd\x25\x66\xf3\x78\x9f\x57\x04\xc1\x3b\x0f\x0c\xe7\x21\xff\x66\xf2\xf9\x66\x6c\xbc\x19\x59\xb7\x80\xe9\x2d\xc8\xbf\x05\xde\x5b\xf1\x93\x7a\x47\xcd\xc7\xbf\xf9\xc4\x73\x3e\xf8\xcd\x47\xff\x7c\xfc\xbe\x0d\x5f\x6f\x63\xce\x6d\x60\x7f\x1b\x58\x2d\x00\xbb\x05\xf8\xb4\x00\xd9\x0b\x88\xef\x02\xf0\x2d\xa3\xaf\x0c\xbf\xcb\xe0\xbf\x3d\x1f\xc2\xff\xdb\x91\x7b\x07\xf2\xee\xc0\xf6\x3b\xd6\x88\xba\x93\xf5\x76\x27\xf9\x78\xa7\x7e\xc6\x87\x85\xe0\xb8\x10\x7b\x17\x22\x63\x21\xf6\x2d\x44\xf6\x22\xe2\xb3\x08\xfd\x8b\xf0\x69\x11\xd8\x2e\x02\xaf\xc5\xf8\xb1\x18\xfb\x16\x63\xc3\x62\xf2\x6c\x09\x6b\x62\x09\x3c\x4b\x88\xdf\x12\xf4\x2d\xc5\x96\xa5\xf0\x2f\xc5\xfe\xa5\xe4\xc8\x32\xfc\x5a\x06\x06\xcb\xc0\x7f\x39\xbc\xcb\xd1\xb9\x1c\xdb\x96\xc3\xbb\x02\x9d\x2b\x98\xbb\x02\x59\x2b\xc8\x9b\x95\x8c\xaf\xc4\x3f\xea\x2b\xb5\x12\x9f\x57\xe2\xf3\x4a\xfc\x59\x45\xde\xac\x82\x67\x15\x36\xdc\xc5\xf3\x5d\xe4\xed\x5d\x8c\xdf\x45\x2e\xac\xc6\x8f\xd5\xc8\x5c\x8d\xfc\x35\xc4\x6f\x0d\x98\xae\x01\xe3\x35\x8c\xad\xa1\x6f\x2d\xb6\xae\x23\x77\xd7\xe3\xcb\x7a\xf2\x78\x3d\xfd\x1b\x90\xb9\x11\x3f\x36\xf2\x4e\x6d\xa4\xa8\x8b\xd4\x26\xb0\xdf\x84\x3f\x9b\x89\xe1\x66\x9e\x37\xf3\xbc\x85\xf8\x6e\xc1\xce\xad\xb4\x5b\xf1\x81\xed\x56\x6d\xe3\x79\x1b\xf3\xb6\x31\x8f\x7a\x47\x6d\x67\x1d\xdd\x8b\xde\x7b\xb1\xe7\x5e\x30\xbe\x8f\xf9\xf7\xb1\x16\xca\xc1\xba\x1c\x6c\xa9\x75\xd4\xfd\xf4\x3f\x80\x8d\x0f\x10\xb3\x07\xe1\x7d\x90\x78\xec\xc0\x97\x1d\xe0\xb3\x13\xdd\x3b\xc9\xc5\x9d\xe4\xc0\x2e\xf0\xd8\x85\xff\x0f\xe1\xff\x43\xe8\xdd\x0d\x76\xbb\xc9\xc7\xdd\xe4\xe6\x1e\x74\xed\x61\xde\x1e\x6c\xdf\xcb\x9c\xbd\x60\xbc\x17\x79\x7b\xb1\x73\x2f\x58\x53\xdf\xa8\x7d\xc8\xd9\x07\xef\x3e\xf4\xed\x43\xde\x7e\xfa\xf7\x83\xeb\x7e\x64\x3d\x8c\x7d\x0f\x33\xe7\x61\xfc\x78\x04\x9b\x1f\x21\xce\x07\xb0\xf5\x00\xf9\x70\x00\xde\x03\xe4\x23\x75\x8d\x3a\x88\x9e\x83\xc8\x7a\x14\x7c\x1e\x03\xbb\xc7\x88\xd5\x63\xe8\x78\x8c\xd8\x1f\x02\xfb\x43\xf8\x7f\x88\xfe\x43\xc8\x7a\x1c\xbe\xc3\xd8\x7c\x18\x3b\xa8\x5d\xd4\x11\xf6\x82\x27\x91\xf9\x24\x7a\x9f\xe2\xfd\x29\xfc\xfb\x13\x79\xf1\x34\x73\x9e\xc6\xdf\x3f\x93\x8b\xcf\x80\xc9\x33\xac\xf9\x67\x89\xe1\xb3\xf8\x72\x94\xf1\xe7\x18\x7f\x8e\x9c\xfb\x0b\x7d\xcf\x83\xcf\xf3\xcc\x3f\x46\xbc\x5f\x20\xa7\x5f\x40\xce\x0b\xe4\xc1\x0b\xf4\xbd\x80\xbc\x17\xd1\xf7\x22\xf9\xfa\x12\x58\xbc\x8c\xae\x97\xc9\xd9\x97\x91\xf9\x0a\x36\xfd\x95\xdc\x7b\x15\x6c\x5e\xc5\xdf\xd7\xe8\x3b\x8e\x2f\xc7\x99\xf7\x37\x7c\xff\x1b\x7d\xaf\x63\xdf\xeb\xd8\x71\x82\xf7\xbf\x23\xe7\x1f\xd8\xff\x06\x7a\xa8\x5b\xd4\x9b\xac\xdf\xb7\xf0\xf1\x6d\xf0\x7a\x87\x1c\x79\x17\x5b\xde\x23\x76\xef\x91\x43\xef\xe3\xdf\x07\xc4\xe1\x43\xe4\x7d\xc8\xf3\x47\xd8\xf4\x31\xcf\x1f\x63\xf3\xc7\xec\x0f\x1f\x63\x0f\x75\x8b\x3a\x89\x9c\x93\xcc\x3b\x89\x9f\x27\xd1\xf7\x29\x79\x70\x0a\x5d\xd4\x2f\xea\x34\x72\x4e\xa3\xe3\x0c\xb9\x78\x06\x9b\xcf\x80\xeb\x67\xcc\xf9\x0c\x79\x67\xb1\xe1\x2c\xef\x67\xf1\xe9\x2c\xf6\x9e\xc5\x86\x4a\x62\xf8\x39\x71\xf9\x02\xec\xbf\xc0\xae\x7f\x92\x6f\x5f\x62\xcf\x97\x8c\x7d\x89\xec\xaf\xd0\xfd\x15\xba\xbf\x42\xf7\xd7\xc4\xf3\x6b\xe2\xf9\x0d\x58\x7e\x4b\xee\x9f\x43\xff\x39\x72\xf8\x5f\xb4\xe7\xc9\xd9\xf3\xc4\xed\x3c\x7b\xc2\x79\xec\x38\x0f\x3e\xe7\xc9\xaf\xf3\x60\x7b\x1e\xde\x7f\x83\xc3\x77\xf0\x7d\x47\x4e\x7f\x4f\xee\x7d\x8f\xce\x1f\x90\xfb\x23\xb9\xf4\x13\xb6\x53\x2b\xa8\x5f\x90\xf1\x0b\xb8\x5d\x40\xe7\x45\x6c\xbd\x88\xad\x97\xc8\x1b\x3f\xfc\x7e\x7c\x0c\x30\x37\x30\x4b\x0c\x59\x23\x86\xa2\xe5\xce\x6f\x18\xfd\xc4\x30\xe3\xa1\xd7\xc4\xb0\xca\xc4\x70\xf0\xee\x18\x09\x7d\x05\xe9\xbf\xd2\x0c\x87\xb6\x41\xfb\xc5\x70\xbd\x09\x9d\x11\x23\x6c\xa9\x18\xee\x5c\xd1\x7f\x0a\x60\xd4\x60\x5e\x4d\xe4\x85\x23\x2f\x22\x05\x62\x3c\x92\xbe\xa8\x95\xd0\xd3\x10\xef\xd1\xc8\x89\xf1\x42\x3c\xc7\x7c\x27\x46\xac\x05\x35\x87\x3a\x8b\x11\xd7\x41\x8c\x78\xda\x5a\xd3\xa1\xbb\xc5\xa8\x8d\x9c\xda\x87\xc4\xa0\x26\x30\xea\xde\x2a\x46\x02\xf3\xea\x61\x43\x3d\xe6\x51\xfe\x18\xf5\x91\xd1\xe0\x88\x18\x0d\xd1\xe9\x39\x26\x86\x17\x3b\x93\x4e\x8a\xd1\x08\x9d\xdc\xe3\x8d\xd4\xa6\x62\x34\x46\x4e\x93\x9f\xc4\x68\x4a\x5f\x33\x64\x5c\x53\x22\x46\x1a\xfa\xd2\x90\xdb\xdc\x07\xa1\xa3\xf9\x6e\x31\x5a\x94\x8b\xd1\x72\xa1\x18\xe9\xe8\xce\xc0\x1f\xce\x7b\x23\xf3\x28\x74\x4e\x8c\x36\xe8\x6d\x83\xfc\xb6\x60\xd1\x0e\xfd\xed\xb0\xa7\x1d\xef\xed\xeb\x42\xf0\xb7\x7f\x57\x0c\xce\x7c\xa3\x13\xb6\x74\x46\x4f\x97\x0f\xc5\xe8\x8a\xac\x6e\xe8\xe1\xea\x63\xf8\xd0\xdf\x1d\xbd\xdd\x4f\x88\xd1\x83\xb9\x3d\x91\xd1\x13\xb9\xbd\x5e\x16\x23\x1b\x5f\x7a\xc3\x97\x8b\x9c\x6b\x37\x89\xd1\x07\xbe\xbe\xe0\xd0\x0f\xfc\xfa\x13\x8b\xfe\x8c\x0f\xc0\xa7\x81\xd8\x9b\x07\x8e\x83\xf0\x67\x70\x91\x18\x43\x98\x33\x04\xb9\xf9\xf8\x3c\xf4\x73\x31\x86\x61\xc3\x75\x15\x62\x14\xc0\x53\xd8\x0b\x62\xce\x70\x64\x0e\x27\x8e\x23\xc2\x20\xb0\x1a\xc9\xdc\x51\xf8\x39\x1a\xde\x31\xf0\x15\x81\x75\x31\xf8\x17\x63\x33\x67\xba\x71\x3d\xb6\x95\xe0\x53\x09\xb8\x8d\x63\xce\x38\xec\x2b\x25\x6e\xe3\xc1\x77\x3c\xe3\x13\xe9\xbb\x61\xae\x18\x93\xa0\xc9\xc8\x9e\x82\x0d\x53\xd0\x3f\x15\xbf\xa6\xa1\x7b\x3a\xba\x66\xe4\x8b\x71\x23\x32\x6e\x04\x83\x99\x60\x32\x0b\x7f\x66\x81\xf1\x2c\xfd\x4c\xce\xcc\x46\xc6\x6c\xf4\xce\x26\xb7\x66\x83\xe7\x6c\xec\x98\x8d\x8e\xd9\xd8\x30\x9b\x39\x73\xc0\x7d\x0e\xf6\xdf\x84\xbf\xf3\x32\xc4\xb8\x19\x1e\xce\x58\xe3\x56\xe6\xdc\xca\x9c\xf9\x8c\xdd\x56\x5f\x8c\x05\xe8\x29\x9b\x0c\x61\x57\x19\x72\x39\x2f\x8d\x3b\xd0\x73\x07\xb1\xbc\x03\x39\x77\x62\xd7\x42\x70\x59\x84\x9c\x45\xf8\xbe\x18\xbc\x97\x80\xe9\x52\xe6\x2e\xcd\x13\x63\x19\x73\x97\x93\x0f\xcb\xc9\x13\xce\x32\x83\x73\xcb\x58\xc5\xbc\xbb\xf0\x63\x35\x39\xcd\x79\x64\xac\x85\x6f\x1d\x36\xac\xc7\x66\xce\x20\x63\x3d\xb2\xee\x06\x8b\x7b\xf0\x7f\x03\x76\x71\x67\x37\x36\x81\xdf\x26\x72\x61\x33\xe3\xdc\xc5\x8d\xad\x60\xb8\x8d\xfe\x6d\xc8\xdd\x8e\x4d\xf7\x16\x88\x71\x1f\xf3\xef\x03\x93\xfb\xb0\x87\x3b\xb5\x71\x3f\x3c\xf7\x23\xe3\x7e\xf4\xdc\x4f\xcc\xef\xa7\xef\x01\x72\xe2\x01\x7c\x79\x80\xb8\x3d\x88\xde\x07\xc1\x74\x07\xb2\x77\x80\xf1\x0e\xf4\xee\xc0\x9f\x9d\xe4\xc3\x4e\xec\xde\x09\xdf\x4e\xec\xdc\xc5\xf8\x2e\xf8\x1e\x22\x8f\x1f\x22\xb6\x0f\x91\x2b\xbb\xc9\x55\xee\xd7\xc6\x6e\x7c\xda\x0d\xa6\x7b\xc8\xbf\x3d\xcc\xdb\x43\x3e\xee\x81\x67\x0f\x39\xbd\x07\x2c\xf6\x32\x77\x2f\x36\xed\xc5\x8e\xbd\xe4\xc3\x3e\x6c\xd8\x0f\x36\xfb\xb1\x99\x33\xc8\x78\x18\xbd\x0f\xa3\xf7\x61\x30\x79\x04\xfb\xb9\x6b\x1b\x8f\xe0\xcb\x23\xbc\x73\xc7\x36\x0e\x80\xcb\x01\x30\xe0\x8e\x6d\x1c\x40\x26\xd7\x1f\xa3\x82\xfe\x0a\xf4\x56\x60\x5b\x05\x98\x1f\xc4\xb7\x83\xd8\xf0\x28\xb6\x73\x26\x19\x87\x88\xd9\x21\x70\x79\x1c\x3b\x0f\xa3\xf7\x09\x6c\xe5\x7a\x6e\x3c\x89\xef\x4f\x62\xdb\x53\xe8\x7f\x0a\x9d\x7f\x62\xfe\xd3\xe4\xcd\x9f\xa1\x67\xb0\xf3\x19\xde\x9f\x25\x1e\x47\xc1\xf8\x39\xf8\xfe\x82\xce\xe7\xb1\xf3\x18\x7a\x5f\x80\xff\x45\xd6\xcb\x4b\x60\xf2\x32\x3e\xbe\xc2\x9c\xbf\x92\x27\xaf\x12\x83\x57\xe1\x7f\x0d\xbb\x5f\x43\xff\x71\xd6\xca\xeb\xc8\xe7\xba\x6a\x9c\x80\xef\xef\xd8\xfa\x77\x7c\xf9\x07\xb2\xde\x60\xce\x1b\xc4\xe6\x4d\xec\x7b\x8b\xfe\xb7\xd0\xf7\x36\xfa\xde\x01\x83\x77\xc8\xbb\x77\x88\xef\xbb\xe8\x78\x97\xf5\xfd\x1e\x73\xdf\x27\x7e\x1f\x68\x42\xff\x87\xc8\xfc\x90\xfe\x8f\xe0\xff\x98\x75\xf3\x31\x3a\x3f\xa1\xfd\x04\x3c\x4f\xc2\xfb\x29\xf1\xfa\x14\x4c\x3e\xc5\xff\x4f\xb1\xf9\x14\xf6\x9c\x02\x83\xd3\xd8\x7d\x06\xbe\x33\xc8\x3d\x83\xfc\x33\xe4\xf0\x67\xf8\x70\x16\x8c\xcf\x32\x5e\x09\x7e\x9f\x23\xeb\x0b\x72\xff\x9f\xd8\xcc\x9d\xd6\xf8\x92\x3d\xfa\x4b\x78\xbf\x42\xf7\x57\xe8\xfe\x9a\xf9\x5f\x63\xf7\x37\xf8\xfb\x0d\xfe\x7d\x4b\x3e\x9d\x43\xde\x39\x74\xff\x8b\x79\xe7\xc1\xf5\x3c\x7c\xff\x66\xde\xbf\xb1\xf1\x3b\xf2\xe4\x3b\x62\xff\x3d\x7a\x7e\x80\x8f\xfb\xa7\xf1\x23\x6b\x8f\xfb\xa6\xf1\x13\x79\xf7\x33\xfb\xca\x2f\xf8\xff\x0b\x73\x2e\x60\xcf\x45\xe4\x72\x77\x34\x2e\x81\x93\x1f\xd9\x7e\x74\x04\xd0\x1d\x78\x5a\x4c\x89\x86\x68\x55\x06\x74\x44\x4c\xa3\xb9\x98\x26\x7d\x66\x99\x98\x16\x7d\xd6\x39\x31\x1d\x3c\x3b\x7d\xd0\x77\x62\xba\xb6\x89\x19\x16\x0f\xdd\x2d\xa6\xbb\x2e\xb4\x50\xcc\x1a\x9d\xa1\xd7\xc4\xac\x39\x4b\xcc\xf0\xa6\xd0\x51\x31\x23\x0e\x89\x19\x59\x21\x66\x14\xcf\xd1\x3c\xc7\x32\x3f\xae\x40\xcc\xf8\xe9\x62\xd6\xa2\xad\x9d\x02\xfd\x24\x66\x9d\x13\x62\xd6\x45\x6f\xc2\x19\x31\xeb\xa1\x27\x91\xb1\xfa\xf0\x37\xe8\x00\xbd\x2c\x66\x43\xe4\x7a\xd6\x88\xe9\xdd\x2f\x66\xd2\x52\x31\x1b\xcd\x15\x33\x39\x5f\xcc\x14\xfa\x53\x19\x6f\xcc\x73\x13\xfa\x9b\x4e\x10\xb3\x19\x74\x0d\xf6\x73\x1f\x34\xd3\xb0\xbb\xf9\x0e\x31\x5b\x60\x6f\x4b\x64\xa6\x43\x19\xd8\xd9\x0a\xbd\xad\x2e\x8a\x99\x89\x8f\x6d\x78\x6e\x1b\x0e\x21\xab\x1d\xba\xdb\x33\xde\x21\x0c\xfa\x4a\xcc\x2c\x64\x66\x61\x5f\xc7\xdd\x62\x76\x62\xac\x33\xf6\x74\x46\x5f\x17\xe4\x74\x65\x4e\x57\xec\xe9\xd6\x0f\x62\xbc\x1b\xf2\x7c\xd8\xd5\xbd\x0d\x84\xad\x3d\xc0\xa7\x07\xef\x3d\xf1\xb5\x17\xfc\xd9\xc8\xcc\xc6\xc7\x9c\x5c\xe8\x5d\x31\x7b\x33\x37\xf7\x56\x88\x79\xd7\x96\x8b\xd9\x67\xa4\x98\x7d\xc1\xad\x2f\xf6\xf6\x03\xf3\x7e\xd8\xcc\x99\x61\xf6\x3f\x26\xe6\x00\xec\x18\x88\x9d\x9c\x1b\x66\x5e\x1e\x84\x6d\x83\x98\x33\x18\xfb\x07\xe3\xfb\xe0\x4d\x10\x32\x87\xe0\xf3\x10\xfc\x1f\x82\x9e\x7c\x64\xe5\xf3\x9c\xff\xa1\x98\x43\xd1\x3d\x14\xbb\x86\x96\x40\xc8\x1a\x4a\x4c\x86\xc2\x3f\x4c\x20\xf8\x86\x21\x63\x18\x71\x1b\x86\xee\x61\xe4\xc1\x30\xe2\x70\x1d\xfe\x5d\xc7\x9c\xeb\xb0\xeb\x3a\xe2\x7b\x1d\xf6\x5e\xf7\x26\x84\xbd\x05\xd8\x57\x80\x1d\x05\xf4\x17\x30\xa7\x00\xec\x0a\xc8\x8b\xc2\xfa\x50\x2f\x08\x59\x85\xd8\x57\x48\x5c\x87\xa3\x63\x38\xfc\xc3\x8b\x20\x70\x19\x4e\x2e\x0c\xff\x5c\xcc\x11\xd8\x3e\x02\xde\x11\x60\x34\x12\x9d\xa3\x88\xd5\x68\xec\x1f\x4d\x8e\x8c\xc6\xee\xd1\xf0\x8e\x06\xeb\xd1\xf0\x8e\xa1\x7f\x0c\xb8\x8d\x01\xcb\x31\xf8\x3a\x06\x19\x63\xe8\x2f\x42\x46\x11\x31\x29\xc2\xaf\x22\xf8\x8b\xf0\xbb\xe8\xa4\x98\xc5\xf8\x5b\x8c\xce\x62\x74\x16\xd3\x5f\x0c\x7f\x31\xf2\xc7\x22\x67\x2c\xf2\xc7\x22\x87\x33\xd2\x1c\x8b\xfc\xb1\xf4\x5f\x4f\xff\xf5\xf4\x73\x66\x9a\xd7\xc3\x7f\x3d\x98\x5f\x0f\x06\x25\xf8\x53\x42\x3e\x94\xc0\x5f\x42\x7f\x09\xfd\xdc\x8f\xcd\x71\xc4\x65\x1c\xb6\x8f\xc3\xcf\x71\xf8\x3f\x0e\x5c\x4a\xf1\x93\xbb\xb2\x59\x0a\x2e\xa5\xc4\xb5\x94\xf8\x95\xc2\x5f\x4a\xac\xc6\x23\x67\x3c\x79\x32\x1e\xfe\xf1\xf4\x8f\x07\x97\x09\x16\x84\xed\x13\x26\x43\xf8\x34\x01\xdb\x27\xe0\xd3\x44\x7c\x9a\x48\xff\x44\x6c\x9f\x48\xac\x26\x12\xab\x89\xc4\xea\x06\xe4\xdf\x80\x7c\xee\xd6\x26\xe7\xb6\x79\x03\xf6\xdf\x80\xfd\x37\x60\xff\x24\x72\x63\x12\x31\xe4\xae\x6d\x4e\x42\xe7\x24\x62\x31\x99\xbe\xc9\xe8\x9c\x8c\xce\xc9\xf0\x4e\x86\x77\x32\xfd\x53\xf0\x75\x0a\x58\x4e\xc1\xa7\x29\xf4\x4f\xc1\x96\x29\xe4\xf8\x54\x2f\x84\xec\xa9\xe4\xf9\x54\xf2\x6c\x2a\xb6\x4c\x83\x77\x1a\xbc\xd3\xd0\x37\x0d\x3f\xa7\x11\xe7\x69\xc8\x98\x8e\x3f\xd3\xf1\x7f\x3a\xb6\x4f\xc7\xf6\xe9\xf4\xcf\xc0\xbe\x19\x60\x3e\x03\xbb\x6f\x24\x6f\x6e\x24\x6f\x6e\x24\x3f\x6e\x44\xd6\x8d\x60\x36\x13\xcc\x66\x22\x6b\x26\xd8\xcc\xc4\xa7\x99\xf4\xcd\x42\xfe\x2c\x6c\x9c\x85\xce\x59\xe4\xd7\x2c\xe4\xcc\x46\x0e\xf7\x7a\x73\x36\xb1\x98\x0d\x56\xb3\xb1\x6f\x0e\x58\xcd\x01\x93\x39\xe8\x9b\x83\xbe\x39\x60\x35\x87\x38\xdf\x44\x9c\xb9\xf3\x9b\x37\xc1\x7b\x13\xfd\x37\xe1\xe3\x4d\xe4\xe7\x5c\xec\x98\x4b\x4e\xcc\xa5\x6f\x2e\x32\xe7\x21\x73\x1e\x32\xe7\xc1\x37\x8f\x3d\x8b\xfb\xbf\x39\x0f\xfd\x37\x63\xd3\xcd\xc4\xf7\x66\x78\x6f\x06\xbb\x9b\xe9\xbf\x99\xfe\x5b\xe8\xbf\x05\x5b\x6f\xc1\xd6\x5b\xb0\xf5\x16\xfa\x6e\xc5\x56\x6a\x16\xf3\x56\x6c\xbd\x15\xbe\x5b\xd1\x3f\x1f\xb9\xf3\xc1\x79\x3e\x32\xe6\xe3\xf7\x7c\x70\x9a\x8f\xcd\xf3\xc9\xb7\xf9\xcc\x99\x8f\x2d\xb7\x31\x7e\x1b\xf3\x6e\x23\x0e\xb7\x31\x76\x1b\xf6\xdc\x46\xff\x02\xf0\x5e\x80\xed\x0b\xc0\x69\x01\x63\x0b\xb0\x75\x01\xeb\x60\x01\x72\x17\x10\x8f\x32\xc6\xcb\xb0\xa1\x0c\x99\xd4\x45\x66\x19\xbe\x95\x31\x76\x3b\xf9\x71\x3b\xb9\x7a\x3b\xf1\xbb\x9d\xfe\xdb\xc1\xe7\x0e\xec\xb8\x03\xff\xee\xc0\xbf\x3b\xd0\x71\x07\x7d\x77\x82\xd9\x9d\xc8\xbf\x93\xbd\xe7\x4e\x64\xdc\x49\xff\x9d\xd8\x75\x27\x76\x2d\x04\xb7\x85\xec\x91\x0b\x89\xf7\x42\xfc\x59\x88\x8f\x0b\x91\xbd\x08\xd9\x8b\x88\xeb\x22\xf8\x17\xc1\xbf\x08\x7e\xea\x2d\x73\x31\xfc\x8b\xe1\x5f\x0c\xff\x62\xf8\x17\xc3\xbf\x98\xfe\x25\x60\xb2\x04\xdf\x96\xd0\xb7\x04\x4c\x96\x90\x33\x4b\xd9\x37\x96\x82\xff\x52\xf2\x71\x29\x72\x96\x22\x67\x29\x72\x96\xc2\xbf\x0c\x39\xcb\xb0\x69\x19\x76\x2e\xa3\x7f\x19\x76\x2e\xc7\xce\xe5\xf4\x2d\x27\xb6\xcb\xf1\x67\x39\xf9\xbb\x1c\x39\x2b\x90\xb3\x02\x39\x2b\x90\xb3\x02\x39\x2b\xe0\x5f\x81\x9c\x15\xe4\xfb\x4a\xb0\x59\x49\xff\x4a\xd6\xc7\x4a\x30\x5b\x49\xdf\x2a\x62\xb6\x0a\x39\xab\xc0\x73\x15\xf6\xac\x22\x5f\x57\x81\xd9\x2a\xb0\xbc\x8b\x75\x73\x17\xfd\x77\xb1\x86\xef\x42\xfe\x5d\xf4\xad\xc6\x9f\xd5\xc4\x6c\x35\x39\xba\x9a\xfd\x7b\x35\x71\x59\x8d\x9c\x35\xc8\x5e\x83\x9f\x6b\xe8\x5f\x43\x9e\xad\x61\xfd\xae\xa5\x6f\x2d\xfa\xd6\xa2\x6f\x2d\x79\xba\x16\xbb\xd7\xb2\x0e\xd6\xe1\xff\x3a\x62\xbf\x0e\x39\xeb\xe0\x5f\x87\x9c\x75\xac\x55\x6a\x4c\x73\x3d\xb6\xac\xc7\xcf\xf5\xc4\x75\x3d\x76\xac\x47\xe7\xdd\xe4\xc2\xdd\xc8\xb9\x1b\xde\xbb\xc1\xeb\x6e\x30\xb9\x07\xbb\xef\x01\xf3\x7b\xc8\xc1\x7b\xe8\xbf\x07\xbb\xef\xc1\xc6\x7b\x18\xdb\x00\x36\x1b\xc0\x80\xfa\xd4\xdc\xc0\xd8\x06\x74\x6f\x40\xfe\x46\xfa\x37\xd2\xbf\x91\xfe\x8d\xd8\xb4\x11\x59\x1b\xd9\x83\x36\x62\xd3\x26\xe4\x6d\x22\x17\x36\xa1\x67\x13\x79\xb5\x09\x4c\x37\xe1\xdb\x26\xf4\x6f\x46\xff\x66\x7c\xdb\x4c\x5e\x6f\xc6\xd6\xcd\xcc\xd9\x42\xee\x6c\x01\x8b\x2d\xc4\x71\x0b\x31\xa0\xee\x35\xb7\xa0\x67\x0b\x73\xb6\xe0\xfb\x56\x7c\xdc\x8a\x7d\x5b\xc9\xb7\xad\xc4\x60\x2b\xbe\x6c\x45\xcf\x36\x30\xd9\xc6\x9c\x6d\xc4\x66\x1b\x36\x6f\x43\xd6\x76\xec\xda\x8e\x8e\xed\xf4\x6f\x47\x16\x35\xb3\xb9\x9d\xf8\x6c\x47\xce\xbd\xec\x19\xf7\x82\xd5\xbd\xd8\x7c\x2f\xbe\xdc\x4b\xbe\xdd\x87\x0f\xf7\xa1\xaf\x1c\x9b\xef\x67\xee\xfd\xcc\xbd\x1f\x9e\xfb\xe1\xb9\x9f\xfe\xfb\xb1\xe3\x7e\xb0\xbe\x1f\x7d\x0f\x60\xc7\x03\x8c\x3d\x00\x4e\xd4\xd5\xe6\x83\xf0\xec\xc0\x86\x1d\xf8\xb3\x83\x78\xef\xc0\xcf\x1d\xe4\xc7\x0e\x62\xb8\x93\x3c\xde\xc9\x1a\xd9\x89\xcd\x3b\x59\xef\x3b\x89\xe3\x2e\x30\xd9\x45\xde\x3e\x04\x26\x0f\x61\xef\x43\xd8\x4b\x8d\x6d\xee\x46\xf7\x6e\xfc\xdb\x4d\xff\x6e\xfa\x77\xd3\xbf\x07\x5b\xf6\xc0\xbf\x87\xb5\xb3\x07\xac\xf6\x20\x7b\x2f\xef\x7b\xf1\x7d\x1f\x63\xfb\xb0\x73\x1f\x3e\xee\xc3\xc7\x7d\xf8\xb8\x0f\x1f\xf7\x61\xd3\x7e\xc6\xf6\x93\x6b\xfb\x19\xdb\x8f\x9d\x0f\x13\x9b\x87\x4f\xfe\xdf\xe9\x11\x72\xff\x11\x70\xa5\x3e\x37\x0f\xe0\xf3\x01\xe4\x1d\xc0\x8e\x03\xe0\x71\x40\xf7\x81\x67\x05\xba\x2a\xf0\xf5\x20\xef\x8f\xc2\xf3\x28\x76\x1c\x22\xdf\x1e\x07\x93\xc3\xf4\x3f\x01\x7e\x47\xc0\xf9\x49\xf2\xe5\x29\xfc\xfc\x13\x79\xf8\x27\xb0\x7c\x9a\xdc\x7c\x1a\x79\x4f\x13\xff\x3f\xf3\xfc\x67\x70\x7d\x06\xdf\x9f\x45\xfe\xb3\x8c\x3f\xcb\xdc\xa3\xf8\x7a\x94\xf7\xe7\x99\xf3\x3c\x3e\x3f\xcf\xfc\x63\xb4\x2f\x90\xd3\x2f\xa0\xe7\x05\x30\x7a\x91\x79\x2f\x82\xfb\x8b\xd8\xfb\x12\xf9\xff\x32\x79\xf4\x32\x31\x79\x85\x78\xbc\x42\xae\xfd\x15\xf9\xaf\x82\xc5\xab\xc8\x78\x0d\x7c\x5f\x23\xa7\x8f\x13\x87\xd7\xe1\x7b\x1d\x79\x27\xb0\xfb\x1f\xc4\xe8\x0d\x64\xbc\x49\xff\xdb\x60\xf5\x36\xed\xbb\xc4\xee\x3d\xfc\x79\x8f\xfc\x7d\x9f\xbe\x0f\x88\xdf\x87\xd8\xf7\x31\x7e\x7d\x02\x2e\x27\xd9\x13\x3f\xc5\x8e\x53\xe8\x3c\xcd\xdc\x33\xf0\x9d\xc1\xef\xcf\x78\x3e\x8b\x5f\x95\xc4\xe4\x73\xe6\xfc\x13\xfc\xbe\x24\x6e\x5f\x61\xd3\xd7\xd8\xfb\x0d\xfd\xdf\x60\xd3\x37\xac\xab\x6f\xb1\xeb\x5b\xc6\xbf\xc5\xdf\x73\xc8\x3d\x47\x1e\x9e\x43\xd7\xbf\xc8\x8f\xf3\x60\xf2\x6f\xde\xff\xcd\xd8\xf7\xc4\xf9\x07\x64\xfd\x88\xfc\x9f\xb0\xe9\x27\x70\xff\x19\x7f\x7e\x06\x8b\x9f\xc1\xf5\x17\xda\x0b\xc8\xba\x48\x2c\x2e\x32\x7e\x11\x7d\x97\xb0\xcf\x0f\x05\x5e\x16\x4b\x3a\x40\x4f\x8b\xa5\x7a\x41\x67\xc4\x32\xea\x42\xb7\x42\x1f\x8a\x45\x7d\x6d\x99\x3e\x68\x21\x04\xaf\x15\x06\xf5\x83\xb6\x41\x5f\x89\xe5\xe8\x0c\xad\x84\xbe\x13\xcb\x49\xbf\xf3\x6e\xe8\x27\xb1\x5c\x79\xd0\x51\xb1\xc2\x52\x20\x64\x85\xc1\xeb\xa6\xcf\xbd\x43\xac\x1a\xf1\xd0\x5c\xe8\x84\x58\x35\x91\x5d\xb3\x42\xac\x70\x74\x86\x97\x8b\x15\x11\x0e\x4d\x87\x90\x11\x39\x19\x82\x27\xaa\x00\x7a\x4d\xac\xe8\x0c\x08\x3b\x63\x78\x8f\xf9\x5c\xac\x58\x64\xc5\xbe\x29\x56\x9c\x05\xb5\x81\x4a\x20\xf4\x27\x30\xee\x61\xbc\x31\x6d\xe3\x77\xc5\x6a\x82\xdd\x4d\xd7\x88\xd5\x0c\x1f\x9a\xa1\xab\x19\x7e\x5d\x83\x9e\x6b\xb0\xfd\x9a\x09\xd0\x49\xb1\xd2\x98\xdb\x82\xf1\x96\x8c\xa7\xd3\x66\x60\x77\x2b\x64\xb6\x66\x3c\x93\xb1\x36\xb9\x62\x51\x7f\x5b\x6d\xf1\xb3\x3d\xe3\x59\xf8\x4c\xcd\x6d\x75\x44\x47\x47\x74\x74\xda\x2d\x56\xe7\x22\xb1\xba\x34\x85\xc0\xb0\xcb\x45\xb1\xba\xe2\x7f\x37\x7c\xf2\x21\xbf\x3b\x6d\x77\x64\xf7\xc0\xa7\x9e\xe0\xdd\x0b\x1c\x7b\x21\x23\x1b\x7c\xb3\x8f\x89\x95\x03\xf6\x39\xd8\xdc\x1b\xd9\xb9\xc8\xc9\x45\xcf\xb5\x8c\xf7\xc1\x86\x3e\xf8\xd4\xe7\x9c\x58\x7d\xc1\xb7\x2f\x32\xfa\xf2\xdc\x0f\xdc\xfa\xd1\xdf\x0f\x3d\xfd\xe1\xa7\xfe\xb6\x06\x80\xeb\x00\x6c\x1d\x80\x2d\x03\xbd\xd0\x2c\x08\x8c\x06\x82\x51\x1e\xd8\xe5\xc1\x9f\x87\xcd\x83\xd0\x39\x68\x24\x44\x5c\x06\xa1\x63\x10\xb1\x1c\xb4\x1f\x02\xdb\x41\xe0\x3c\x08\x7c\x06\x11\xaf\x41\xc8\x1e\x8c\xcf\x83\xe1\x1d\x8c\xac\xc1\xf0\x0e\x86\x6f\x30\x3c\x83\xf1\x71\x30\xe3\x43\xd0\x39\x04\xdb\x87\x30\x3e\x64\x13\x84\x8c\x21\xf8\x9b\x4f\x4c\xa8\xed\xad\x7c\xe6\xe6\x33\x96\x8f\x1d\xf9\xc4\x21\x1f\xfd\x43\xe9\x1f\x0a\x6e\x43\x89\x33\x75\xbe\x45\x9d\x6f\x0d\xc5\xc6\xa1\xe8\x1c\xc6\x3c\x6a\x7d\x6b\x18\xfe\x0d\x83\x67\x18\x3c\xc3\xe0\xb9\xee\x10\xc4\xdc\x02\x62\x56\x00\x96\x85\xe0\x37\x62\x7a\x90\x46\x62\xc3\x48\x6c\x1b\x09\x2e\xa3\xc8\xb1\x51\xe0\x31\x8a\xfe\x51\x65\x10\x71\x1f\x05\xff\x28\x74\x8c\x86\x6f\x34\x3e\x8f\xc6\xf6\xd1\xe0\x3b\x06\x5d\x63\xe8\x1b\x43\xac\xc7\x80\xed\x18\x6c\x1d\x43\x7c\xc6\xc0\x33\x06\x79\x63\xc0\x65\x0c\xfe\x8e\xc1\xa7\x31\xf8\x3c\x06\x5c\xc6\x60\xe3\x18\xfc\x2e\x02\x97\x22\x30\x2e\x22\x3e\x45\xe4\x46\x11\x73\x8b\xd0\x59\x84\xce\x22\x70\x2e\x22\x06\xd4\xf9\x56\x11\xf3\xa8\xf5\xad\x22\xf4\x51\xef\x5b\xc5\xf5\x21\x62\x51\x8c\x7f\xc5\xd8\x4a\xed\x6f\x15\x33\x8f\xda\xdf\x1a\xdb\x1c\xc2\xd6\xeb\xb1\xe7\x7a\xb0\xbc\x1e\x5d\x25\xac\x93\x12\x64\x8c\x43\x17\x75\xbc\x35\x0e\xbe\x52\x6c\x2e\x25\x2f\x4b\xc1\x64\x3c\x32\xc7\x83\xd3\x78\xf0\x1d\x0f\x3e\x13\x78\x9e\x80\xcd\x13\x05\xc2\xae\x89\xd8\x32\x11\x39\x37\x10\xa3\x1b\xe0\xb9\x01\x9e\x49\xf4\x4f\x02\x97\x49\xe0\x30\x19\x3c\x27\xc3\x33\x19\xec\xa6\xe0\xcb\x14\x7c\x9f\x42\x2e\x51\x67\x5b\x53\x79\x9e\x4a\x6e\x4f\x23\x1e\xd3\xb0\x71\x1a\xfe\x4c\x27\x77\xa6\x93\x63\xd3\xd1\x3d\x03\x0c\x66\xd0\x3f\x03\xfe\x1b\xb1\xe9\x46\xfa\x6f\x04\xe7\x99\xd8\x34\x13\x1c\x67\xb2\x76\x67\xe1\xcb\x2c\xec\x9e\x05\xcf\x6c\x7c\x9f\xcd\x33\xb5\xb2\x35\x07\x5f\xe7\xf0\x3c\x07\x6c\x6f\x22\x0e\x37\x31\xf7\x26\x78\xe6\xc2\x33\x17\x99\x73\xd1\x35\x17\x9c\xe7\xe5\x43\xe8\xa2\x06\xb6\x6e\x46\xe6\xcd\xf0\xdf\x82\xde\x5b\xe0\xbf\x85\xe7\x5b\x79\xbe\x15\x2c\x6e\x05\xa3\xf9\xe0\x3a\x9f\xf5\x33\x9f\xe7\xdb\x90\x73\x1b\x72\x6e\x43\xd7\x02\x74\x2d\x20\x87\x16\xf0\x5c\xc6\x3e\x53\x06\xe6\x65\xe0\x78\x3b\x3e\xde\x4e\xbc\x6e\xc7\xc7\x3b\x78\xbe\x03\xfe\x3b\xc8\xd1\x3b\xf1\xf7\x4e\xf8\xa9\x41\xad\x85\x60\x42\xed\x69\x2d\x64\xee\x22\xfa\x17\xd1\xbf\x88\x78\x2e\x46\x17\x35\xa6\xb5\x98\xb9\x4b\xe0\x59\x82\xde\x25\x3c\x53\x53\x5a\x4b\xc1\x76\x29\x98\x2f\xa3\x7f\x19\x18\x2e\x43\xd7\x72\xec\x59\x4e\x2c\x97\x93\xe7\x2b\x90\xb3\x02\x5f\x56\xe0\xe3\x4a\xec\x5f\x89\xfd\x2b\xf1\x7d\x15\x3c\xab\x78\x5e\x45\xfc\xee\x22\x7e\x77\xe1\xfb\x5d\xe0\xb9\x1a\x3c\x57\xf3\xbc\x9a\xdc\x58\x4d\x1e\xad\x21\x77\xd6\x10\x33\x6a\x3e\x6b\x2d\x7b\xc9\x5a\x74\xaf\x45\xf7\x3a\xfc\x5c\x87\x4d\xeb\xb0\x95\xba\xce\x5a\x4f\x0e\xaf\xc7\x07\xea\x38\x8b\xba\xcd\xba\x07\x5c\x36\x90\x07\x1b\xb0\x61\x23\xf2\x36\x82\xff\x46\xe4\x50\x97\x59\x1b\x75\x1f\xb2\xa9\xcb\x2c\xea\x32\x8b\xba\xcc\xa2\x2e\xb3\x36\x31\xbe\x89\xf1\x4d\x8c\x6f\x62\x7c\x33\xe3\x9b\x19\xdf\xcc\xf8\x66\xc6\x37\x33\xbe\x99\x71\x6a\x34\x6b\x33\xe3\x5b\x18\xdf\xc2\xf8\x16\xc6\xb7\x60\x2f\xb5\x99\xb5\x0d\x7f\xb7\x83\xf9\x76\xfc\xda\x4e\xfe\xdd\x47\x8e\x96\xe3\x7b\x39\xcf\xf7\x83\xcd\x03\x60\x4a\x9d\x64\x3d\x08\xf6\x3b\x88\xcf\x0e\x64\xee\x64\x3d\xee\xe4\x7d\x17\xf3\x1e\x22\x3f\x1e\x62\x7c\x37\xd8\x52\xf7\x58\xd4\x3d\xd6\x1e\xf4\xec\xc1\xaf\x3d\xf8\xbd\x17\x3c\xf6\xb2\xde\xf6\x91\xd7\xfb\xc8\xe3\xfd\xd8\xb5\x1f\xd9\x0f\xd3\x47\x7d\x62\x3d\xc2\x5a\x7a\x04\x1c\x1f\x41\xde\x23\xc4\xee\x11\xc6\x0e\x90\xc7\x07\xb0\xeb\x00\x38\x1d\x60\x1d\x56\xf0\x5c\x01\xcf\xc1\x5e\xfa\xbf\x1f\x23\x86\x7c\x10\x38\xad\x8e\x3b\xba\x48\x4d\x89\x52\x2e\xdf\x13\x12\x11\xe1\x0c\x0f\x8f\x8e\x89\x30\xa3\x22\x55\xb8\x19\x69\xfa\x4c\xf7\xd6\x11\x66\xdc\xdb\x31\xea\xc5\x18\x95\x13\xa3\xda\xc5\xa8\xc3\x31\x6a\x57\x8c\x6a\x1c\xa3\x6a\xc7\xa8\x60\x3f\x3d\x3b\x62\xd4\xdd\x31\xea\x8e\x18\xa5\xa6\xc7\xa8\xa2\x18\x95\x17\xa3\x7a\xc5\xa8\x36\x31\x2a\x25\x46\x45\xc7\x28\x89\x51\x59\xe7\x62\xd4\x99\x18\xf5\x66\x8c\x3a\x1a\xa3\x0e\x55\xcd\x28\x8b\x09\x4d\xc8\xaf\x9a\x60\xc5\x28\x38\x4f\xc6\xa8\x13\x31\xea\x58\x15\x67\x89\xcd\xe0\x8b\x51\x46\x46\x8c\xf2\xda\x22\x4f\xd8\x82\x2a\x6c\x11\xa3\xf8\x99\x31\x63\xc6\x98\x19\x55\x3f\x37\x5e\xf1\x33\x7a\x54\xe8\x67\x4c\xb0\xa9\xe2\x90\x6e\x69\x52\xaf\x6e\xf4\x6b\x63\x46\x8f\xea\x16\x13\xab\xb2\x62\x32\x33\x63\x32\x5b\x65\xa4\xc6\x3b\x93\x1b\x35\x6e\xdb\xa6\x5d\x66\xeb\xda\x66\xa6\x99\xac\x8e\x67\xb7\x69\x93\x9d\x93\x99\x99\x73\xf6\xfd\xae\xa3\x47\xb6\xca\xcd\x6d\x95\x99\x93\x63\x3d\x72\xd1\xfe\x7f\x40\x69\xc8\x02\x73\xa4\xf1\x02\x18\x9a\xe2\x92\x80\xef\x31\x87\xa5\x28\x34\xc2\xdc\x2e\xa7\xa1\x6a\x18\x14\x23\x87\xdd\x6a\x97\x5b\x4d\x74\xab\x42\xb7\xea\xeb\x56\x96\x5b\xfd\xe0\x56\x67\xdd\xea\x6d\xb7\xda\xe3\x56\x9b\xdd\x6a\x99\x5b\xcd\x73\xab\x76\x6e\xd5\xd8\xad\x6a\xbb\xd5\x17\x6e\xf5\xa2\x5b\xcd\x72\xab\x52\xb7\x1a\xec\x56\xca\xe7\x56\x19\x6e\xe5\x75\xab\x78\x7b\x72\xc7\xa3\x6e\x75\xc8\xad\x76\xb8\x55\x99\x5b\x4d\x77\xab\x12\xb7\xca\x77\xab\x14\xb7\x12\xb7\xfa\xce\xad\xce\xb8\xd5\x9b\xf6\xe8\xdd\xf6\x10\x93\xdb\xd8\xa3\x4c\x3e\x56\x35\xc5\x28\x72\xab\x3c\xb7\x1a\xe8\x56\xe9\xf6\xb4\xcb\xe0\xcc\xf8\x2d\x82\xa3\xab\x21\x77\xf5\xb0\x74\x6b\x7d\x7c\xf4\xa8\xd6\x1a\x3b\xc0\xd3\xd8\x29\x8d\x17\x64\xc8\x0b\x5d\xfb\xf8\x7b\xf0\xcb\xd1\xc5\xef\x51\x9f\xfa\x3d\x41\xac\x52\x29\x38\x3f\x00\xab\x44\xf1\xc8\x46\xdf\xd0\x38\x4f\x7d\xa7\xe5\x8a\x8d\x8e\x08\x77\x5b\x61\x31\x75\xea\x25\x1a\x96\x59\x3b\xbe\x61\x03\x87\x65\xd5\xaa\x55\xdb\x32\x63\x63\x5c\x61\x61\x31\x66\x6d\x4b\xd5\x50\x35\x92\xbc\x4e\xa3\x46\xcd\x1a\x0f\x17\xd6\x4f\xac\xe9\xa9\x17\x19\x15\xf9\x70\x61\x9d\xb8\xa8\xa8\x9a\x2a\x2a\x4a\x85\xd5\x8c\xaa\x19\x65\xd6\x8a\x31\xc3\xcc\x58\xe9\x96\xd9\x2d\x33\x36\x2b\x2b\x3d\x1d\xdb\x89\x69\x5a\x8c\xe8\xc0\x86\x5a\xdb\xd6\xd8\x3a\xb6\xbd\xf6\xff\xe9\xe7\x6a\x84\x0f\xb5\x92\xcc\xe4\x38\x4d\xc9\x6d\x33\xa1\xa4\xb8\x4c\x53\x53\x66\xad\x64\xb3\x99\x62\xe0\x03\xff\xc5\x01\x13\x06\xf8\xff\xda\x7f\xe2\x80\xfd\x47\x3b\xfe\xa2\xc2\xfb\x4d\xe8\xab\xda\xf6\x9b\xd0\x6f\xc7\xe1\x2c\xff\x58\xd5\x36\xcb\xff\xaa\x11\x5e\xea\x1f\xae\x76\x69\x2a\x55\x99\xe3\xd5\x46\xff\x44\x4d\xe3\xfd\xc7\x95\xfe\x8f\x12\x49\x41\xa0\xc4\x7c\xce\xf1\xaa\x34\x95\x74\x69\x2f\x1b\x7c\x85\x19\x56\x6d\x4f\x0b\xb3\x49\x5c\x9b\x26\xa6\xbb\x69\xd3\xe8\x66\xcd\x12\x92\xa3\x93\x3b\x64\xb5\x6d\x58\xbb\xe1\xcc\xc2\x66\xc9\xcd\x6b\x78\xda\x44\x67\x84\xd5\x16\xa9\xa7\xdc\x66\xbd\x7a\xb5\x7c\x71\xb5\x5d\x2d\xdc\xe2\x9e\x59\xd8\x54\x1a\x3b\x1c\x92\x50\x94\xa5\x32\xb2\x94\x37\x4b\x49\x96\x3a\x99\xa5\xca\xb3\x14\x3d\xbe\xac\xaa\xb5\xa1\x63\x95\xde\x3a\xfa\xb8\x06\xa1\x6e\xb7\xcc\x7a\xc7\x33\xd3\x49\x7b\xed\xb0\xee\x09\x45\x90\x96\xdf\x75\x32\x63\xea\x64\xb6\x6e\xdd\x2a\xc3\xd1\x52\x35\xe1\xb5\xa1\xaa\x13\xd3\xd2\x62\x3d\xb4\x6f\x9b\x59\xab\x76\x9d\x98\xe4\x26\xba\x9f\xee\x5a\xf1\x4e\x57\xad\x64\xd5\xa6\x71\x93\x98\xae\x4a\xc5\x6b\xbe\x48\xa5\x3e\x9d\x54\xd9\xbe\x47\x23\xcf\xc3\x85\x37\x15\xf5\x6b\xdf\xe0\xf8\xde\xc1\x9b\xb7\x74\x6f\xd0\x70\x5e\xd7\x31\x3b\x97\xbf\xf3\xc4\x60\xd5\xae\xf8\xce\xa9\x73\x2e\x5d\x68\xd2\x67\x74\xc9\xa4\x78\xa3\x79\x82\xf2\x3d\xdb\xec\x5a\x87\xd1\xae\x59\x7a\xc7\x01\xe3\xba\xae\x39\x1c\x79\xfb\x02\x67\xaa\xff\x8b\x1d\xf5\xaf\xb1\xfc\xc9\x8d\xba\x3c\xb6\xf8\xc0\x3b\x11\x2b\xd5\xd9\xd1\x37\xb7\xbe\xf4\x4d\xcc\x42\x33\xbf\xd3\x90\x2e\x4d\xd4\x9f\x22\x6e\xd0\xf9\xe4\x90\x9c\xc0\x67\xce\x12\xc7\x60\x10\x8d\x90\x04\x49\x91\x0c\x19\xe9\x6b\x67\x98\xa2\xd2\x3c\x91\x96\xa5\x4c\x8f\xe5\x4e\xad\x17\xef\xae\xe7\x6e\xdd\xca\x59\xe7\x70\x61\x4d\xe7\x13\x23\x6a\xc6\xd0\x5a\x86\xd5\xa8\xe9\xe1\xc2\xfa\x8d\x9e\x18\x51\xbf\x25\x6d\x7d\x89\xd3\x00\xa5\xa5\xa5\x49\xdd\x6e\xdd\x68\x2e\xe7\x74\xb5\x54\x01\x11\x92\x5b\x45\x27\xb1\x3b\x44\x27\xb5\xae\xed\x6a\xd3\x38\xb9\x91\xb3\x56\x7c\xed\xcc\xd6\xed\x82\xbd\xf6\x9e\x71\x45\xf7\x91\xa9\xe6\xa1\x69\x97\x4a\xfc\x87\xef\x2f\x57\xbd\xef\xdb\xb9\x6d\xc8\x88\xeb\x06\xe6\x0d\x1b\x9e\x6f\xa5\xfb\x9f\xb8\xff\xfe\x07\x76\xdd\xb7\x63\x6b\x55\x57\xbc\xa3\xd4\xbf\xd6\xbf\xf2\x99\xc3\x6a\xda\x91\x27\x36\xad\x5a\x54\xbe\x63\xc9\x6a\x7f\x9c\x7f\xc5\x33\x4f\x3c\xfa\xe7\xcb\x1d\x78\x3a\x20\xf0\x95\x33\x1e\x9f\x53\xa4\x85\x74\x50\xad\x7c\xaf\xc5\x35\x69\xda\xc0\xf2\xc4\xc6\x46\x3a\xac\x0c\xab\x65\x54\x1b\x69\xe9\x09\x77\xb9\xc4\x63\x26\xd4\x88\x4a\x4b\x88\x4a\xe8\x98\x15\xee\x72\xbb\xf2\x0a\xdd\xee\xd8\xb8\x26\x91\x0e\x98\x33\xc2\x1a\xd5\x6e\xd4\x2e\xaf\xb0\x91\x55\x3b\x35\xaf\xb0\x76\xed\xd8\xa8\xbc\xc2\xd8\x5a\xe7\x3a\xaa\x93\x1d\x55\x45\x47\x55\xde\x51\x4d\xef\xa8\xf2\x3a\x2a\x5f\x47\x95\xd1\x51\x79\x3b\xaa\xe8\x8e\x4a\xe8\x64\xf8\x44\x47\xb5\xe6\xca\x31\x06\x98\x79\xd4\x9e\x99\x57\x6d\xc2\x49\x5b\xd0\x65\xce\xa0\x08\x5f\x75\x0d\x5e\x9b\x29\x28\x91\xf9\x51\x1d\x55\xd8\xe8\x60\xb6\x56\xdf\xb6\xaf\xda\x91\x2e\xef\xe6\xfc\xe8\x1d\xbc\x6e\x90\x62\x62\x85\x48\x65\xd5\x4d\xaf\x96\xcf\xd5\xa3\xc7\x53\x66\x68\x7d\xc7\x47\x2a\x97\x6a\xd7\xbe\x49\xdb\xa4\x5a\x2e\xc3\xe5\x61\xbd\x37\x89\x54\xf6\x96\xdf\x55\xb5\x0f\x05\x51\xb5\x6e\xaf\x22\xc9\xf0\xda\x66\x7c\x9d\xae\x46\xdb\x36\x44\xd4\xfc\xa8\xe7\xcd\xab\xd5\xae\x62\xe7\x5d\xea\x95\x15\xfd\x6e\x3a\xb3\xd3\xbf\x7b\xdf\x84\xd3\x4b\x7e\xfa\x39\xf7\xd6\xc5\x1b\x8f\x1e\x7e\xe4\x88\x7f\xfe\x7b\x9b\xfd\x11\x13\x47\xef\x71\x6f\x29\x1e\x9a\x76\x78\xe2\x48\xab\xd3\x80\x1b\xaf\xeb\xe0\x2f\x7b\x71\x67\x62\xdb\xb6\x89\xfe\x1f\x2b\x4e\x24\xb4\xdd\x3a\x6a\xf0\x73\x4f\x14\xaf\xbc\x3e\x73\xdd\xe3\xab\xef\xb9\xeb\xc2\x6d\x9b\xd5\x2b\x2d\xb6\x4c\x5d\xbb\xcd\x92\x07\x67\xa5\x64\x97\xf4\x39\x5a\xa4\xff\xed\xfe\x30\x73\xa4\x4a\xd4\x67\x8a\x6a\xeb\xfb\x48\x91\xe9\x96\x7d\x9a\x88\x39\xcf\xa1\xae\x75\xa8\x2c\x87\xda\xec\x50\xcb\x1c\x6a\x98\x43\x35\x73\xa8\x04\x87\x72\x3b\xd4\x84\x1f\x1c\xea\x6d\x87\x7a\xd1\xa1\x0e\x3b\xd4\x2e\x87\xea\xe5\x50\xed\x1c\x2a\xc5\xa1\xe2\x1d\xca\x72\xa8\xef\x1c\xea\xcc\x95\x0c\x1b\x1c\x6a\x8e\x43\x95\xda\x52\x72\x6c\xe6\xb3\x0e\xb5\xc3\xa1\xd6\x39\xd4\x1d\x0e\x4e\x72\x87\x2a\x72\xa8\x3c\x87\xf2\x39\x54\x46\x35\x41\x1d\x82\x92\x4e\x38\xd4\x31\x87\x3a\x64\xcf\xb8\xdb\xa1\x16\x3a\xd4\x39\x87\x3a\x69\xf7\x1b\x47\x1d\xaa\xc2\xa1\xca\x1d\x6a\x8d\x43\x95\x39\xb4\xa4\xcb\x62\xbc\x0e\x15\xed\x50\xcf\x3a\xd4\x01\x87\x8a\x72\xd8\x01\xaf\x76\xae\xd8\x67\xf8\xef\x9f\xdb\xd5\x98\x66\xfc\xe6\x6c\xa7\x4f\xba\x1d\xd7\x1b\x9a\x3e\xc6\x5b\x65\xb0\x5d\x27\x0f\x0b\x9d\x3e\x1a\xcf\xe1\xfe\x7e\xc6\x04\xc7\x2a\x89\x91\xfa\xbe\x70\x71\x47\x5a\x6e\x2b\x36\x2e\x42\x1c\x89\xd2\xad\x5b\xf5\xe3\x2b\x3a\xb6\x76\x9d\x5a\x2d\x15\x01\x8f\x6d\xd7\xbe\x56\xa4\x32\x54\x62\xce\x86\x19\x2f\x7e\x32\x71\xc2\xc7\x2f\xdf\xbc\xa6\xa7\xfa\xc6\x7f\xd1\xff\xea\x9b\xdd\xf3\x27\xfe\xac\x06\x7d\xfb\x8d\x1a\xf8\xd3\x0d\xf9\x39\x1f\xf8\x3f\xd4\xff\xf4\x42\x7a\xa0\x23\xaf\x4a\x87\x5b\x1c\x91\x12\x19\x1b\x57\x43\xe4\x2a\x1d\x71\x6d\xbb\xaa\xd8\x98\x68\xa3\x71\x93\xb6\x0d\x55\x6c\xad\x78\xc3\xd9\x63\xc6\x86\x9c\x9e\x6b\x6e\x7e\xf9\xe3\x09\x13\x3e\xf6\xf7\xcb\xef\xfe\x96\x6a\xab\x4c\xe5\x54\x29\x1f\xe4\xe4\x4f\xfa\xd1\x7f\xf0\x9b\x6f\xfc\x07\x7e\xb2\xff\x79\x87\x94\x18\x03\xcc\x7b\xc9\x8b\x18\x95\xea\x6b\x1c\x1d\x6e\x59\x11\x66\x58\x4d\x47\xa4\x11\xe3\x14\xb7\xcb\x65\x8a\x19\x1b\x17\x55\x23\xda\x5d\x33\x32\x26\xcc\x70\xb8\xc4\xa9\x22\xc3\xf5\xbf\x48\xdb\xed\x0e\xcf\x0d\xb7\xcc\x94\x38\x55\x3b\x4e\x19\x71\xea\xbb\x38\x75\x26\x4e\xbd\x1d\xa7\x5e\x8c\x53\x3b\xe2\xd4\x86\x38\xb5\x38\x4e\xcd\x89\x53\xa5\x71\xca\x17\xa7\x5a\xc7\xa9\x46\x71\x2a\x3e\x4e\x59\x71\xea\x87\x38\x75\x2a\x4e\xbd\x19\xa7\x8e\xc5\xa9\xc3\x71\x6a\x97\xcd\x36\x36\x4e\xa9\x3c\x9b\xb5\x4d\x9c\x42\x68\x74\x9c\x92\x38\x95\x15\x94\x7a\xc8\x16\x59\x16\xa7\x66\xc5\xa9\x92\xb8\x2b\xf8\x82\x0c\xc1\x51\x63\x7a\x9c\x2a\x8a\x53\xde\x38\x75\x34\x4e\x55\xc4\xa9\x72\xfb\xb5\x7a\x25\xf7\xdb\x0a\x6e\xcc\xa8\x2b\xb7\x84\x5f\xb3\x41\xba\xbd\x96\xa6\xcf\x6f\xa5\xd7\xbb\xbd\xe8\xc1\x9a\x23\x2c\xae\xbd\x83\x12\x2e\xb5\x4e\x84\x72\xa5\xc6\x25\xc7\x39\x9a\xa4\x96\xf8\x54\xa7\xb4\x6d\xe9\xaa\x8b\xcf\x7f\x48\xf5\xf3\xf9\x9f\x4f\xdf\x96\xe6\x7f\xc1\xa7\x72\xad\x66\xab\xff\xa2\x7a\xfb\x9f\x7c\x66\xd5\xd8\xe2\x55\x4f\xfb\xff\xa4\x72\x9f\x5f\x7d\xbd\xc6\xbc\x54\x5e\xb5\x3c\xd6\x22\x6a\xe4\x54\x5f\x0c\xf5\x98\xd3\x30\xc2\x23\xc4\x72\x58\x0f\x17\xba\x1d\x8f\x51\x6d\x54\xed\x38\xa1\xfa\x51\xc5\x24\xc7\x24\xb5\x4d\x22\xda\x49\xb5\x8c\xd9\xe3\xfd\x05\x6a\xf7\x78\xb5\xd7\x98\xed\x1f\xa6\xf6\x96\xaa\xbd\xfe\x61\xa5\xc1\x58\x0e\xf0\xbf\xa0\x16\xc8\x1b\x12\x2d\xcd\x7d\x75\x9d\xdc\x84\x6a\xd6\x8c\x89\x35\xad\xed\x85\x91\xe6\xee\x11\xce\xc8\x13\xb1\xaa\x28\x16\x40\x24\x3d\x33\x78\x1c\xfd\x5a\x9e\xba\xda\xb6\x6b\xcb\xa9\x5b\xb5\x55\x2d\xb8\x6f\x5d\x45\xc3\xd4\x5e\xbd\xda\xfa\x06\xb6\x5a\xf6\xe4\x35\xfd\x3b\x4c\x8f\xf7\xc6\x25\xfb\xda\x65\x8d\xb4\xf5\xf4\x53\x1b\x8c\x22\x23\x9d\x93\x63\x8b\x6f\xb2\x29\xba\x3e\x7d\xb2\x50\x3d\x9d\xf1\x9b\xbd\xe1\xcd\xaa\xe5\xcc\x5a\x9e\x65\xef\x1f\x77\xdb\xcb\xd7\xb8\x6a\x27\x60\x09\x0b\x7b\x10\xcb\xfd\x68\xd5\x8a\xbf\xbc\xe0\x83\xab\x1d\xbe\x05\x0e\x35\xea\xd7\x00\x8d\xfe\x75\x25\x57\x5f\xc3\xd2\x2d\x78\xd0\xea\x55\x91\x54\xab\x9f\x11\xaf\x36\x6c\xde\xac\x6d\x5e\xc2\xbd\x64\x9e\xbc\x05\xe6\x75\x7d\x35\xc5\xe9\x0c\x8f\x08\x5e\x44\x42\x13\xae\x2e\xd3\xd5\xbc\xaa\x12\xbd\xaa\x3c\xd7\xff\xff\x4f\x02\x5f\x19\x59\x8e\x1c\xfc\x6e\xe4\x8b\x35\x95\x83\x33\x9f\x53\xde\xa1\x3a\x97\xdb\xee\xcc\x98\x31\x7a\x54\xd5\xca\x6c\x95\x51\x87\x93\xbd\xa4\x44\xbd\x33\x36\xde\x31\x9c\x3a\x95\x33\xd6\x7c\x94\x33\xb6\x86\xd4\x16\x9f\xaf\x71\x8c\xa3\x26\xc5\x46\x9d\xba\x61\x91\x33\x0b\xc3\x5c\x46\xfc\xcc\x42\x23\xc1\x57\x57\x49\x5d\x75\xb2\xae\x2a\xaf\xab\x8a\xea\x2a\x5e\x83\x99\x29\x55\xe7\x51\xb5\x5d\x25\xa9\x91\x11\x13\x1d\x9b\xd9\x3a\xd6\x8c\x36\x92\x2f\x3f\x3f\xea\xcf\x7d\xf3\xdd\x77\x3f\x7c\xf3\xc3\x23\x37\x2f\xbe\xe3\xc6\x59\x65\x0b\x6f\x35\x76\x5c\xca\x55\x25\x2a\x5f\xf5\x57\xc5\xfe\x07\xfd\x07\x54\x0f\x55\xdf\xff\x9d\xff\x11\xff\x7e\xff\x97\x2a\x19\x9f\x0e\x51\x3c\x2e\x72\xe4\x62\x57\x5f\x5f\x0b\x97\x38\x1c\x35\xc3\xc5\x15\xed\xf2\xba\x4c\xb7\xe9\xf2\xd5\x70\x8a\xc3\x74\xcc\x2c\x34\xeb\xfa\xc2\x95\x84\xab\x93\xe1\xaa\x3c\x5c\x15\x85\x2b\x5e\x2f\x1b\x67\x17\x80\xf5\x8e\x8f\xa9\xda\x2c\x35\x94\x8e\x5a\x49\x6d\x53\x63\x1c\x6d\x53\x33\x8d\x99\x2a\xf6\x52\xba\x8a\xf3\xff\x4b\x2d\x69\x93\xa7\x8f\x2d\x2b\xa7\xb8\xed\xc7\xf6\x1e\x8a\xee\xd5\x8e\x7e\x52\x5f\x8a\x7c\xed\x13\xa3\x8d\xfa\xae\x5a\x46\xad\x06\x0d\x5d\xb1\x89\x12\x19\x1d\x69\xb8\xcd\xc8\xc8\xd8\xd8\x1a\x33\x0b\x63\x9d\x46\xa2\x4a\x9c\x53\xa8\xea\xfa\x1a\x2a\x69\xa8\x4e\x36\x54\xe5\x0d\x55\x51\x43\xc5\xeb\x95\x56\xd8\xbf\x83\x75\x68\xd6\xe5\x12\x54\x1b\xd4\x4c\xb5\x6d\xaf\x4f\x5d\x5d\x48\x45\xa9\xe4\x18\x1d\xe3\x5a\xfa\xd8\x76\xba\x92\xcc\xd5\x17\x5f\x7d\xea\xb1\xdd\xd7\xce\x59\xdc\x76\x7a\x5a\x72\x8f\xc3\x0b\x3e\xfc\xe8\xba\x43\x27\x0a\x4b\x8c\x47\xd7\xef\xd9\xfe\x97\xbf\x2d\xba\x63\x69\x83\xba\x3b\x94\x91\xf6\xc4\x43\xd3\x5f\x7a\xe1\x60\xbf\x11\xf6\x1a\x18\x4b\x3c\x2b\xb0\xfd\x1a\x59\xea\x1b\xd4\x34\x36\x35\xb5\x4e\x9d\x58\x8f\xe9\x8c\x8c\x14\xa7\xa4\x35\x6f\x1a\x17\x1b\x17\x3b\xb3\x30\x3d\x4e\xc5\xc5\x25\x9b\xd2\x30\xba\x21\xde\x34\x6c\x98\x9c\x5c\x6f\x66\x61\xb2\xcb\xac\x39\xb3\x70\xba\xab\xcc\x65\x44\xb9\x14\x7b\x6c\x82\xaf\xb9\x92\xe6\xea\x64\x73\x55\xde\x5c\x15\x35\x57\xbc\x56\x79\x95\x99\x3e\x6a\x54\x30\xf8\xbf\xfa\x95\x3e\x4a\x97\x26\x55\xee\x85\x6e\x1e\xb1\x76\x19\x42\xfe\x36\x31\x75\x7d\x4d\xa1\x88\xaf\xe9\xda\x69\xf5\xab\xd3\x5d\x55\xa6\x37\x86\xc5\xde\x50\x99\x15\x3f\x9d\x7e\x66\x6f\xcd\x1e\x2d\x9a\xac\xee\xba\x7d\xc3\xf2\xb5\xab\x57\xcf\x98\x3c\xbb\xac\xed\xac\xe6\xc9\x3d\xae\x5f\xd3\x5b\x3d\xb2\x79\xe5\xe1\xfd\x6a\xca\xe3\xaf\xa5\xa9\x7a\x4f\xd7\xf6\xae\xd9\xbd\x70\x99\x2b\x6c\xb0\xdb\x59\x76\xc7\x92\x5b\x6c\x2c\xea\xc5\xf8\x0f\xaf\xd8\x19\x5f\xeb\x21\xfb\x0e\xd6\x94\x38\x9e\x74\xf4\x22\x87\x22\x65\xb0\x2f\x3d\xc2\x0a\x53\xce\x48\x65\x1a\x96\x11\x15\x1d\xe6\x88\x34\x23\x67\x17\x8a\x69\xaa\x9a\x2e\x27\x11\x8c\x56\x12\xad\x4e\x46\xab\xf2\x68\x55\x14\xad\x78\xad\xf2\x55\x5f\xb1\xd2\xab\xdf\xa9\xea\x84\x6a\xe4\xe0\xf6\xa7\x78\xae\xa5\x92\x55\x92\x79\xcd\xfe\x4b\x7b\x8d\xd5\x33\x0f\xfb\xef\x75\xf8\xbd\xea\x33\xd5\xc4\xff\x9e\x6a\xb2\xc8\xdc\x74\xf1\xc6\xd5\x66\xeb\x4b\xa3\x82\x7b\xe1\x4d\x76\x7c\xba\x48\x43\xb9\xd1\x97\xdd\xa0\x6e\x5d\x77\x8c\x69\x26\xba\x4d\x8f\xb7\x4e\x2d\xa9\x35\xb3\x30\x8a\xeb\xa2\x11\x6e\x8a\x38\x13\x12\xea\xcf\x29\x4c\x70\x3a\x59\x88\xd3\x6b\x94\xd5\x30\xa2\xb8\x18\xd6\x70\x26\xf8\xbc\x4a\xbc\xea\xa4\x57\x95\x7b\x55\x91\x57\xf1\xfa\xdb\x98\x10\x05\x3b\x28\xa1\xed\xba\xaa\x32\xc4\x62\x9d\x5c\x57\x06\xa3\x25\xf5\xa0\x0b\x3f\x6a\x25\xc5\xb4\x53\x9f\x7d\x7e\xfa\x87\xcf\x9e\xb9\x07\xfc\x9b\xdf\xd2\xe1\xde\x7b\x7c\x2b\xe7\x8c\xb8\xae\xc8\xd8\x7d\xe9\xd1\xc9\x66\xf4\x33\xcf\xff\xf5\x3d\x0d\x7b\xdd\x86\xf7\x1c\xbc\x75\x41\xe7\xba\xc6\xe6\xcd\xfe\xfc\xba\x36\xce\x05\xf8\xf4\x3c\x39\xa7\xef\x25\x73\x7d\xbd\x6b\x35\x6a\xe4\x6c\x10\x41\xbe\xa5\x36\xe6\xd1\x5b\xc7\x3b\xab\x30\xaa\x8e\xa7\x0e\x6e\xd5\xa9\x63\xd6\xa8\x41\xfe\xe9\x65\xe4\x8d\x34\xf5\x42\xaa\xe1\x32\xc9\x3d\x72\xad\xb1\x92\xc6\xea\x64\x63\x55\xde\x58\x15\x35\x56\xbc\x56\xdf\x64\x32\x83\xee\x5c\xe1\xd8\xaf\x77\xb9\xa0\x6f\xda\x31\x23\x86\x72\x26\xb3\x75\x9d\x5a\xfa\xea\xc6\xab\x19\xac\x70\xdb\xd9\xb9\xe6\x8a\x8e\x35\x9f\x7f\xe3\xa5\x53\xdf\xde\x76\xfa\x9e\x75\x6b\x7b\x24\x27\x4d\x6f\xb1\xee\xc1\xb0\x07\x77\x1c\x7c\xca\x3f\x76\xde\xe4\xf1\xd3\x97\x6d\x59\xae\xca\xff\x7e\x5a\x15\xa9\x3e\xef\xaa\x8e\x3b\x92\x2b\x97\xc5\x26\xfa\x3f\xf3\x9f\x1b\xf6\xd2\xa5\x4f\xb6\x3f\xbe\x63\x5d\x6b\xff\xeb\xfa\x3f\x35\xa5\xf4\xbf\xda\x35\xf5\xe7\x20\x61\x32\xc8\x97\xee\x70\x3a\x95\xcb\x54\xa6\xbb\x86\xa3\xae\x65\x84\x19\x61\x73\x0a\x57\x87\xfe\x1f\x5a\x19\x4e\x5f\x0d\x25\x35\xd4\xc9\x1a\xaa\xbc\x86\x2a\xaa\xa1\x78\xbd\x22\x5a\xb6\x43\x55\x25\x53\x6c\xb0\x9e\xd3\xb1\xd0\xe9\xf4\x4a\x0f\xb3\xeb\xa5\xbd\xb7\x1b\x7d\x2f\x3d\x66\x89\xea\xd2\xff\x42\xb4\xb5\x23\x78\x27\xb2\xf7\xeb\xda\xd2\x48\x5a\xca\x78\x5f\xa7\x06\xcd\x62\x92\xb1\x27\x32\xc6\xaa\x59\xc7\x59\xd3\x99\x9e\x61\x46\x36\xaf\xd7\x1c\x4c\x9b\x37\xf7\xc6\xc7\x37\x9e\x59\x18\xef\x72\x7b\x67\x16\xba\x13\x7c\x19\x4a\x32\xd4\xc9\x0c\x55\x9e\xa1\x8a\x32\x14\xaf\x57\x6d\xe3\x62\xdf\x29\x68\xaa\xd6\x70\xe8\x4e\xd1\xda\x06\xd7\x65\x5f\x83\x93\xbd\x31\x5c\x8f\x5b\xaa\xd0\x87\x46\xd5\x2e\x80\x57\x3c\x2f\x9b\x34\xe2\xc6\xf9\x6f\x9f\xf2\xe7\x97\x4d\xb9\x6e\xca\xab\x47\x9f\x3a\xbe\x62\xfe\x92\x85\xb3\xe6\xdc\xb1\x68\x41\xb3\xc9\x53\x6e\x18\x5f\x32\x65\xfa\x44\xf3\x87\xa9\x9b\x9b\x5e\xf3\x58\xd9\x33\x47\xd5\x6d\x8b\x0e\x34\x6b\xba\x69\xda\xae\xc3\x8f\x5f\x3c\x5e\xbe\x66\xd9\x43\x7b\x16\xaf\x30\x33\x96\xdf\x71\xdb\x5d\x2b\xe6\xdd\xa2\xf3\xab\x07\x3e\xef\x27\xbf\xea\xe2\x33\xf9\x95\x58\x53\xf0\xcc\x29\xce\xe4\x94\x78\xaf\xb7\x61\xed\x86\xb3\x0a\xa5\x76\x74\x6d\xf2\xab\x76\x6d\xd3\xed\x8e\x61\x15\x45\x78\x22\xd2\x39\x48\xcd\x88\x08\x77\x82\x99\x40\x7e\xb9\x7c\x29\x4a\x52\xd4\xc9\x14\x55\x9e\xa2\x8a\x52\x14\xaf\xff\x6b\x7e\xc5\x04\x77\xea\x38\xed\x31\xe5\xac\xb0\x7c\xda\x06\x97\x4f\x6c\x9c\x3e\x98\x55\xa3\x18\xed\x74\xfb\x68\xa3\xc7\xa9\xbf\x7d\xf6\x96\xff\x9b\x9f\x1e\x5c\xda\x3d\xd9\x3b\xb9\x7d\xf9\x7e\xf7\xa6\xed\x07\x5f\x55\x8f\xfe\x32\xf7\xb6\xdb\xef\x9c\x67\xee\xf8\xeb\xc7\xfe\xc3\xfe\x72\xff\x01\xff\xd6\x46\x9f\xaf\x89\xaa\xab\x12\x54\xcc\xd0\x37\x8c\x5a\xfe\x1d\x9b\xd7\xb1\x8d\x28\x8f\xf6\xf5\x01\xea\x81\xf5\xe6\x73\xd4\x03\x75\xa4\xc2\x37\x2f\x5c\xff\xd7\x7f\x9c\x75\x13\x6a\x45\x6d\x1d\x51\x2b\x3a\x58\x1a\xbc\x99\xa0\x8e\x25\xa8\x43\x09\x6a\x47\x82\x5a\x98\xa0\x66\x25\xa8\x92\x04\xe5\x4b\x50\x19\x09\x2a\x25\x41\xc5\x27\x28\x2b\x81\x12\xd5\x66\x2a\xab\x1a\xce\x4f\x50\xbd\x12\xd4\x89\x6a\x33\xbd\x09\xca\x88\x4e\x50\x92\xa0\xce\x25\xa8\xf2\x04\xb5\x26\x41\x4d\x4f\x50\x45\x09\x2a\xcf\x16\x76\xb9\xfe\x1c\x53\xfd\x1e\x52\xfd\x4a\x3a\xaa\xda\xf9\xff\x3b\x1f\x28\xc6\x54\xaf\x5a\xd6\x67\x67\xea\xaa\xa5\x75\x4e\x4e\xeb\xcc\x9c\xec\x36\x99\xd9\xa1\xea\x25\xdb\x38\x42\x09\x93\xc9\x8b\xf6\xfd\x06\xea\xc4\x6d\xb6\xef\xf5\x65\x82\xaf\x7b\x6c\x78\x78\x1d\x2a\xa2\xa8\x3a\x75\x1a\x34\x8c\x8a\xde\x5e\x58\x2f\x6a\xf7\x88\xd8\x7a\x6e\x73\xeb\x08\x77\x74\x99\x7d\xe0\x76\x5b\xd3\x50\xf1\x74\xa2\xa1\xaa\xb0\x8f\xde\x93\xf6\xf3\x51\xfb\xb5\x2c\x78\x06\x8f\x0a\x55\x65\xf6\x67\xa0\x75\xaf\xa8\x30\xab\xed\x1b\x21\x3b\xe3\x7e\x53\x71\xae\xaf\x32\xd8\x7d\xdf\xfa\x83\xde\x94\x5e\xd9\x6d\x7c\x79\x66\x6e\xc8\xe6\x8b\x47\x82\x45\x68\x2d\x6f\x6c\xa3\xee\xed\xb2\x46\x04\x6b\xe8\xa7\xa8\xa1\x37\xb0\xfb\xb5\xf2\x25\x5a\x6c\x01\xe2\x74\x85\x71\xa5\x95\x74\x4b\x45\x59\xdd\xac\x69\xd6\xeb\x56\x80\x92\x5a\x12\xd2\x47\xcd\xc8\xcc\x3c\x7e\xfc\x8a\x0b\x93\xaa\xe5\x56\xb5\x4a\xcd\x27\x2f\xbe\x63\x36\x33\x56\xb7\x56\x6f\x8d\xf7\xcf\xf3\xcf\x1b\x0f\x36\xa5\x6a\xb7\xe5\x31\x77\xdb\x9f\xbd\xfa\x7c\x29\x4e\xc3\x41\x67\x98\xdb\x34\x1e\xe6\x0c\x53\x1c\x22\x2e\x9f\xcb\xf9\x70\xa1\xc7\xa5\xf4\xe1\xed\x0b\x8f\xce\x75\x49\x7a\xda\xa8\x19\xf6\x07\xbf\x7f\x0b\x66\xf7\xaf\x75\x1a\x55\x90\x26\xcb\x73\xb1\x37\xca\x7a\x1b\x91\xa5\xa5\x6a\x4b\x69\x29\xf6\x4f\xc0\xfe\xa4\xdf\xd8\x8f\xbd\xe9\x86\x8a\x32\xba\x19\xd3\x8c\xd7\x8d\x80\xe1\x30\x6c\xfb\x8f\x1f\xcf\xcc\xac\x26\xb6\x7d\x5b\x37\x17\xba\x5a\x13\xcc\x66\xd8\xff\xe4\x53\xe3\xd5\x12\xb5\x64\xbc\x3f\xad\xb5\x1d\xdb\xc0\x69\x33\x8b\x35\xcc\xbe\xa5\x0e\xf8\x02\x75\x0c\x65\x36\x70\xc6\x46\xc4\x36\x30\x53\x92\x8d\xda\xdb\x0b\x0d\x23\xba\xea\xec\xab\xe7\xab\xe7\xdd\x3a\xa2\x5e\x5c\x78\x78\x74\xb4\x7b\x7b\x61\xb4\x75\x4b\x8a\x9a\x94\xa2\xc6\xa4\xa8\x81\x29\xaa\x53\x8a\x4a\x4f\x51\x89\x29\xaa\x66\x8a\xba\x90\xa2\xbe\x4d\x51\x1f\xa4\xa8\xd7\x53\xd4\x9f\x52\xd4\xbe\x14\x75\x5f\x8a\x5a\x9d\xa2\xe0\x1f\x91\xa2\xfa\xa6\xa8\x6e\xd5\x98\x27\xc0\xfd\x65\x35\xee\xad\x29\x6a\x45\x8a\x5a\x90\xa2\xa6\xd9\x42\xd3\x6c\xbe\xa8\x2a\x9e\x57\x6d\x9e\x03\xb6\xac\xa0\xee\xbe\xd5\xb4\x9e\x49\x51\x27\x52\xd4\xb1\x14\x75\x28\x45\xad\x49\x51\x0b\x53\xd4\x74\x7b\x57\xc9\x4f\x51\xbd\x52\x54\x9b\x14\x95\x92\xa2\xe2\x53\x94\x95\xa2\x3a\x04\xf9\x2a\x52\x94\x51\x6e\xf3\x96\xd9\xbc\xbe\x56\x6c\x40\xde\x14\x15\x5d\xb5\x2b\x1d\xb5\x79\x18\xc9\xb3\xfb\xe9\xfc\xc4\x66\xc7\x7c\x8f\xfd\xfa\xff\x61\xef\xdf\xe3\xab\xa8\xae\xc6\x61\x7c\xaf\x99\x39\xb7\x9c\xcb\xcc\xb9\xdf\xaf\x39\x39\xb9\x11\x73\x39\x09\x21\x44\xc8\x10\x31\xc6\x80\x70\x88\x11\x39\x20\x9c\x88\x29\x72\x95\x80\x5c\x54\x54\x82\xdc\x4a\xd1\x12\x34\x5e\x8a\x16\x52\x1e\x44\x8b\x51\x23\x46\x1f\x2f\x6d\x89\x8a\xb6\xd6\x5a\xf0\x11\x6b\xad\xb5\xc4\x8a\x5a\x9f\x5a\x4d\x2d\x5a\x0b\x64\xf2\xdb\xb3\xe7\xcc\xc9\x9c\x24\xf6\xf9\x7e\x9f\xdf\x5f\xef\xfb\x79\x15\x98\x33\x7b\xd6\x5e\xb3\x67\xef\xb5\xd7\x5e\x6b\xed\xb5\xd7\xd2\x2e\x1a\xcf\x44\x94\x1a\x3d\x27\xb3\x55\xc6\xf1\x37\x07\x46\xc1\xa5\x65\xd4\xd2\x91\x3d\x02\x73\x8d\xb8\x0e\x48\x72\x83\x53\x24\x97\x5c\x5a\x96\xd7\xb0\xb8\x56\x35\x91\x48\x6b\x2c\x58\x95\x33\xfc\xb9\x84\x67\xcf\xdc\x59\xcb\x77\xb4\x37\xe7\xd6\xef\xdf\x05\x8f\xfe\x64\x5f\xcd\x15\xf2\xa4\x87\x45\x30\xcb\x6f\xbe\x73\xc7\x3d\x37\x97\x1f\x12\x8a\x85\x9e\xff\x78\x2d\x64\x1c\x3a\x97\xe6\x00\x98\x36\x56\x09\x9b\xd4\x5f\xa9\x5a\xd0\x54\x74\x39\x7a\x97\xdf\x55\xad\x41\x8e\xb2\x32\xd3\x74\x5f\x5e\x61\xdd\xe5\x85\xb4\xc3\xe7\xd0\x98\x34\xa6\xa6\x19\x96\x09\xef\x26\x2d\x6e\x77\xc3\xef\x93\x11\xfe\x77\x49\xd6\x9d\x72\xaf\x76\xd3\x7a\x36\x12\x8c\x50\x1c\xed\x8e\xb8\x23\xb4\x5e\x1f\x7f\x27\xa9\x67\xa6\xd2\x74\xed\x3b\x49\x9a\x9d\x01\xc3\x33\x60\x60\x06\x9c\x9c\x01\xfd\x33\xa0\x77\x06\x74\xcf\x80\x41\xb9\x84\x9b\x01\x68\x06\xf0\xb8\x88\x9f\x01\xed\x33\xa0\x55\x86\xe8\x9c\x01\xc1\x19\x80\x2b\x67\xba\x5c\xee\xbb\x74\xa7\xa2\x52\x59\xa8\x17\xd7\x4a\x57\xa9\xb8\x62\xe0\xf9\x25\x16\xa6\x27\x99\x25\x23\x25\x9a\x25\x4b\x73\x79\x99\x4a\xcd\xe4\x46\xa2\x54\x15\x67\x41\xe1\x10\x32\xdb\x28\x7c\x5b\x55\x59\x2d\x9b\xe3\xe8\x5a\xa8\x70\xd2\xc4\x0e\x87\xd7\x4f\x4b\x55\x25\x0a\x47\x18\xca\x6c\xb3\x30\xf8\xb6\x1a\xf2\x23\x6a\xca\x6e\x13\x7f\xaa\x8e\xde\x25\x7c\x78\xf8\x43\xe1\xa7\x2f\x9e\x87\x17\xc1\x04\x09\x58\xf3\xb2\xf0\xec\xd3\xd3\xb4\x57\x3f\x7a\x49\xe3\xec\x29\xab\x1f\xe9\xbe\x23\x1a\x2b\x5b\xab\x65\xf3\xf2\xd6\xf5\xb7\x0b\xbf\x12\xbe\xf8\x4c\xd8\xfd\xee\x83\x10\xfb\x55\xd7\xbf\xb6\x0b\x7f\x2e\xbf\xe3\xc9\x65\x89\x49\xf7\x4c\x79\xee\x86\xd4\xcf\x61\xde\x1f\xc0\x07\xbf\x01\x4a\xf8\x85\xf0\xa7\x5f\x08\x4f\xfd\x3a\x5e\x31\xe3\xea\xe4\xaa\x05\x1b\x3f\xea\xdd\x54\xa2\x1e\xfa\x22\x77\xad\x3b\xcf\xfd\x1f\x10\xd9\x77\x01\x5c\x1f\x09\x57\x0a\xe7\x5f\x11\x4e\x3e\x76\x45\x8a\xee\x61\x92\xc2\xb7\xf7\xde\x3b\xb5\x52\x9c\xd7\x36\x84\x54\xcf\x61\x3d\x8d\x45\x16\x48\xf1\x5f\x99\x4d\x2c\xcb\x58\x8c\x9c\xc1\xa0\xd1\x70\x0c\x6d\xb5\x19\x4d\x66\x53\x6b\xd2\x62\x36\x03\x87\xb9\x88\x41\xc3\xb0\xc0\xa6\x92\x39\x60\x39\x6b\x83\x33\x36\x38\x65\x83\xe3\x36\xe8\xb3\xc1\x21\x1b\x74\xd9\x60\x9b\x0d\xd6\xd9\xa0\xcd\x06\x2d\x36\x98\x6e\x83\x4a\x1b\x44\x6d\x60\xb3\x01\x63\x83\xff\x5b\xf8\x9a\x7f\x53\x41\x09\xcd\x10\x98\x7e\x1b\x50\xbd\x36\xe8\xb6\x41\xa7\x0d\x3a\x6c\xd0\x6e\x83\x84\x0d\x78\x1b\x94\xd9\x20\x64\x03\xce\x06\x03\x04\x68\x14\xc0\x6c\x1b\x8c\x9d\x76\xa9\xef\xdc\x96\x1b\xdf\xaa\x43\xc4\x41\xa2\x5f\x88\x1b\x16\x92\xb6\x81\x2e\xca\x48\xee\x16\xc2\x5e\x45\xd5\x3d\x0f\xb3\xec\x6a\x2c\x28\x38\xc5\x2b\x1d\xc6\x42\x67\x18\xde\x14\x2e\x7b\x00\x5e\xff\x05\xbc\x7f\x64\xe8\xf5\xbe\xed\x43\x83\x3b\x61\xf7\x27\xf0\x76\x95\xa8\xce\x7e\x7b\x5e\x2b\xaa\xb5\xb0\x55\xb8\x8d\x59\x3a\xb4\x5e\xd4\x3f\x68\x54\x3b\x7c\x8e\xf9\x8a\xc8\xae\x16\x14\x43\x1f\xf0\xf7\xe8\x22\xc8\xa7\x32\x99\xec\xf6\xa0\x2f\xc2\x14\xe4\xe7\x71\xad\xc9\x3c\x4b\x50\x65\x50\x19\x5a\x93\xac\x0a\xf4\xb4\x4a\xe5\xb2\xba\x1c\xa9\xa4\x8b\x69\x4d\xba\x68\xab\x3d\x95\xb4\x5a\xba\x0b\xa0\xb3\x00\x3a\x0a\xa0\xbd\x00\x5a\x0b\x80\x2f\x80\x81\x02\x38\x40\x4a\xf0\x6d\x82\x94\x84\x0a\xe0\x74\x01\xf4\x93\x92\x32\x72\x8b\x0a\x60\xf2\x09\xf2\x98\x2b\x80\x41\x82\x02\x91\x9a\x27\x0b\xa0\x9b\xe0\x92\x6a\x2e\x1c\x59\xb8\x15\x66\x4f\xe5\x6e\x1c\x11\x3c\x94\xf2\x1a\x11\xa4\x8b\x15\xca\x0e\x59\xe6\x2a\x63\xc5\x80\xe5\xd7\x89\x56\xf2\x43\x9c\x59\xaa\xaa\x6a\x73\x7e\x55\x38\x24\xea\x41\x44\xa2\x65\xc2\x79\xf4\x2f\xf6\x3d\x7e\xe2\xfd\x83\x3f\xfa\xde\xcf\x4e\x0c\xfe\xe0\xa1\xc7\x8e\x5c\x70\xf5\xf4\x50\xdf\x43\xc3\x9f\xef\xdd\xfa\xcc\x6b\xc2\xd7\xc3\x48\x68\xa1\xbf\xdd\xd4\x2e\xa8\x3a\x04\xc7\x5d\x5b\x87\x7e\xa3\xde\xfb\x31\xee\xdd\xfd\x9e\xaa\xfb\x0f\x6d\x38\xec\xb3\x3e\xfe\xfd\x97\x7e\xa9\x26\xba\x5d\xcb\xf0\xe7\xcc\xc7\x78\x8d\xf3\xa2\xa9\x7c\xd8\x4c\x8b\xa2\xa7\xcf\xaf\x36\xa5\x92\x58\x07\xd0\x61\xcd\x47\xcd\xb8\xdd\x08\xd9\xf0\xbd\x95\xf7\xc3\xc2\x0c\xe3\x95\xa5\xcf\xcc\x42\xaa\xc2\x1c\x82\x43\xe1\x0a\xa7\x95\xe8\x31\x21\xc9\x8e\x32\xb1\x0e\xe2\xb4\x9a\x56\x0b\x2f\x08\x5d\x98\xa5\xce\x7b\x6b\x50\x5d\x1f\x68\x78\xbe\x55\x18\xfe\xfc\x9f\x9f\xaf\xfd\x75\x6d\xde\x34\xf5\x1f\x6d\x70\x1d\xf0\x30\x1f\xae\x8b\x0b\xef\x3f\x51\x5c\x2a\xfc\x97\xf0\x8a\xf0\x47\xe1\x37\xd5\x17\xfd\x4a\x78\xb5\x4e\x9c\xaf\xb5\xc3\x17\x54\xeb\xf1\xf8\xeb\xb0\x7c\x39\x13\x6b\x2f\x36\x64\xb4\x19\x5d\x6e\x27\x1e\x56\x27\x1e\x60\x27\xcd\xe1\xf6\x71\x9a\xd6\x24\x66\x54\x6e\xa8\xe3\x89\xa0\x38\x40\x24\xc4\x76\x22\x15\xae\x59\x2b\x5a\x93\x8a\xe5\x11\x50\xd8\x7e\x50\x38\x57\xec\x63\x0b\x48\xad\xcf\xcb\x25\x7d\xcd\x1c\x12\xde\x12\x3e\xed\xbb\xe9\xe1\x6f\x3e\x1b\xfa\x16\x6e\x84\x25\xc2\x23\xc2\x4f\x85\x48\x0f\xee\xe3\x47\xb1\x04\x1c\x39\xbf\x49\x0b\x11\xfa\x55\xe1\x19\xa1\x4f\xe8\x15\x0e\x33\x52\xd7\x92\xfe\xac\x45\x88\xb9\x8d\xec\xa1\xde\xc0\x37\x18\xf0\xb4\x76\xe3\x55\x87\xf1\xf9\x0d\xd6\xd6\x64\xca\xb0\xda\x40\x95\x18\x80\x46\x06\xce\x40\xe9\x54\x06\x03\xe3\xf5\xda\x5a\x93\x5e\x48\x25\xbd\x16\x46\xdf\x9a\x64\xa8\x54\x92\xa1\x07\xfc\xd0\xed\x87\x76\x3f\x24\xfc\x20\x76\x7a\x5a\x70\x1d\x45\x40\x29\xa2\x8c\xa5\x89\xa7\xbc\xac\x0e\x44\x22\x31\xe7\xe6\x8b\x64\x13\xae\x8e\xe3\x5f\x61\x73\x38\x24\xf6\x7f\xb8\xb6\xa7\x87\xfe\xa2\x3e\xd4\x7e\xea\x7d\x58\x1e\xe4\xf9\xa0\x70\x1f\x68\x81\x4a\xd4\xd4\x5b\xcf\xbf\x25\xb5\x5d\x38\xf6\x9e\x69\xe8\x6c\xb7\xd0\x76\x70\xe8\x03\xee\x5b\x61\x7f\xe6\x5b\x0a\xf1\xb7\x38\xd1\x59\xfe\xb0\xc3\x62\xb1\x99\x01\xd4\x6a\x9b\x9e\x76\xbb\xcc\x08\x7f\x8e\x79\xb5\x99\x2a\x31\xe3\xcf\x31\x73\x66\xfc\x39\x66\xb3\x5a\xa7\xc3\x53\x51\xa7\x49\x25\x75\x34\xa8\x19\x35\xfe\x18\x8b\x24\xb9\x77\x29\xe4\x7a\x86\x88\xef\x67\xdc\x70\x8a\x94\xaf\x23\x12\xfc\x58\x61\xbf\x4b\xa1\x29\xb4\xc8\xca\x42\x48\xa9\x2c\x9c\x91\xe1\xf0\x7d\x3f\x56\x0d\x7a\xdd\x80\x19\xd9\x78\xec\x6b\x94\x70\x91\x31\x71\x7d\x47\x6f\xca\xb6\x12\xc2\xb4\xc6\x74\x2b\x3c\x7a\x7a\xe8\xa5\x03\x99\x1e\xdd\x1d\x9c\x32\x25\x48\xcd\x1f\xfa\x86\xd8\xe3\xe4\xbe\x7c\x4b\xec\x4b\x69\x7e\xa9\x76\xe2\xf9\x15\x42\xfd\xfc\x66\x9b\xda\x63\xc0\x52\x6a\x38\x12\xf2\xfa\xbd\xa9\xa4\xdf\x2f\xaa\x7e\xb8\xb3\x18\xda\x99\x4a\xd2\xd6\x0d\x11\x58\x12\x81\x86\x08\xc4\x22\xf0\x4d\x04\xfe\x2b\x02\xd0\x1f\x81\xbe\x08\x1c\x8a\x40\x57\x04\xb6\x45\x20\x11\x81\xe9\x11\xa8\x8c\x40\x34\x02\x4c\x04\x6a\xf0\xdf\xb3\x11\x38\x13\x81\xe3\x04\xae\x4b\xf1\x98\x8b\x00\x35\x10\x81\xf6\x08\xb4\x46\x80\x8f\x40\x28\x92\xf6\x24\x18\x91\xb4\x14\x9d\x94\x36\xfd\x8e\xd2\xab\x15\x7b\xcf\xa2\xa6\x84\x17\x7e\x79\x92\x9b\xb3\x26\x39\xe9\x23\xbb\x46\xc5\xac\x3b\xd7\x49\x66\xfa\xb5\x70\xd5\xd9\x8f\x2e\xf1\x5e\xfa\xd2\x8a\x61\xf4\xb7\xb3\x5f\xb6\x3c\x57\xd6\x03\x5f\x6e\x6d\x88\x55\x42\x2b\x5c\x82\xff\x2e\xbc\x58\x18\x38\x5c\x5e\x25\x9c\x10\x5e\x13\xde\x13\x4e\x14\xf8\xe0\x36\xcf\xc4\x89\x1e\x89\xe6\x54\xbb\xc9\xfc\x79\x92\xbf\x21\xc7\xe1\x30\xeb\xdc\x6e\xca\x4c\xf9\x7d\x3a\x17\xe6\xed\xba\x3a\xdd\x6c\x1d\xad\xc7\xdd\x86\x54\x9c\x5e\x4b\xab\xe8\x54\xd2\xa8\xa2\xdd\x0e\x33\x85\xf0\xd4\xb1\x21\x4b\xa5\x1f\xa2\x7e\xb0\xf9\x81\xf1\xc3\xe4\xe3\x7e\x68\xf3\xc3\x74\xf9\xfe\xac\x1f\xce\x90\x5b\x09\x08\x4f\x33\xea\xa4\x62\xaa\x49\xfd\x30\x42\x27\x8b\xa4\x79\x57\x91\x59\xe6\xa4\x1f\x78\x71\x73\x65\x33\x3f\x89\x5c\xe2\x55\xe9\x6e\x30\x87\xd3\x57\x89\x7c\xc2\xf8\x8a\x27\x20\xe5\xee\xa1\x36\xf6\x50\x98\x4f\x0f\xfd\xa5\x67\x68\x57\x8f\x44\x2b\x55\x9e\xa1\xbf\x53\xac\x78\x3d\xbf\x58\xa4\x1f\xaa\x6a\xe8\x0d\x6f\x15\xee\x87\x26\xcc\xf8\x16\x8b\xbe\x3f\xa0\xe7\x7f\xae\x32\x1a\xf4\x6a\x2d\x9e\x4e\x5a\x5a\xb4\x21\x63\x5a\xb1\x74\x1a\xa1\xc3\x08\xed\x46\x68\x33\x42\x8b\x11\xa6\x1b\x21\x64\x04\xce\x08\x8c\x11\x06\x8d\x30\x60\x84\x53\x46\x38\x6e\x84\x3e\xf9\x69\xa5\x11\xa2\x46\x38\xa3\x28\x3f\x64\x84\x2e\x19\x49\xab\x0c\x56\x46\xc0\x6c\x04\x4f\x6d\x06\x7a\x9b\x11\xd6\x91\x37\x49\x88\x18\xf2\x82\x93\x46\xa0\xfa\x8d\xd0\x6b\x84\x6e\x82\x20\x41\x6a\x4b\xad\xc0\xcf\xa4\x47\x18\xbd\x72\xfe\xa5\xc6\xf8\xae\x8c\x23\x60\x64\x20\x94\x96\x68\xb1\xb3\x31\x09\x66\x66\xa4\x5d\x03\xcf\x8a\x3d\x29\xf6\x68\x42\x9e\x79\x55\x1e\xc2\xb7\x8a\x87\x3f\xa7\x44\x79\xc1\x86\x7a\xf9\x9b\x6c\x06\xb5\xda\x61\xcf\xb1\x60\xea\x31\x05\x4d\x54\x8e\x68\xbf\xb3\x8a\x8a\x68\x2a\x49\xd1\x7b\x1c\xb0\xd9\x01\xb3\x1d\x10\x74\x00\xeb\x80\x61\x07\x9c\x70\xc0\x93\x0e\x38\xe0\x00\xe9\x51\x29\x79\x74\x5a\x51\x58\x4a\x20\x2f\xfe\xd2\x01\xc7\x1c\xb0\xda\x01\x75\xa4\x0e\xfe\xdd\x4d\x2a\x84\x1c\x90\x72\x00\x72\xc0\xc2\x11\x4a\x5a\x34\x0e\x13\x92\xbf\x6d\x64\x1d\xb5\xd4\x88\x46\x2b\x89\x72\x6c\xa2\x8c\x2d\x9b\x6c\xaa\x60\x5f\x0f\xc5\x3c\xd0\xfc\xc8\xf5\x1d\xb3\xeb\x03\xd6\x86\xa2\x3b\x99\x2f\xc4\x6f\xbd\xf0\xf2\x8e\xd7\xd7\x07\xce\xee\x76\x7a\x7e\x81\x64\x7e\xad\x3a\x8a\xbf\xdb\x8d\xbe\xe5\x7f\xea\xc8\xc9\x61\x9d\x58\xe9\xa5\xb5\xac\xca\xe3\x75\xda\x29\xce\xc2\x61\x56\xe3\xd0\xd2\x8c\xd1\x6d\xa1\x73\x18\xd6\x88\x85\x5a\x8d\xd1\x72\xc8\x0b\x9d\x5e\xd8\xe6\x85\x36\x2f\xb4\x78\xa1\xd6\x0b\x8c\x17\x06\xbd\x70\xc6\x0b\x7d\x5e\x78\xd0\x0b\xeb\xc8\xa3\xe9\x5e\xa8\xf4\xc2\x49\x2f\x1c\xf7\x02\xae\xd2\x25\xc3\x4b\xe5\x21\x2f\xd8\x48\xc5\x1a\xfc\x80\xf7\x02\xf2\x02\x85\x71\x0c\x78\xa1\xdf\x0b\xbd\x5e\xe8\xf0\x42\x3b\x79\x50\x46\x60\x07\x08\xa6\x6e\x2f\x24\xbc\x59\xf4\xb1\x66\xb4\x72\x38\x86\x71\x4b\x93\x10\xf7\x5b\xda\x39\x26\x3e\xca\x5a\x6c\xd7\xe8\x44\x59\x13\x34\x66\x05\xa9\x98\x71\xb7\xaa\x2e\x7f\x50\x98\x48\x4d\xd9\x2b\x3c\x37\xf4\x8f\x67\xfa\x87\xde\x96\x66\xe4\x1d\xdb\x55\x53\xaa\x3c\x02\x3f\x14\xf1\x56\x51\x87\xf7\x0a\xb5\x23\xa4\x34\xf4\x7d\xea\x26\x71\x51\x97\xd6\xc1\xa5\x62\x6c\x4a\x98\xc4\xff\x81\xd2\xe8\xf5\x66\x0e\x0c\x26\x43\x2a\x69\xa2\x75\x7a\x2c\x19\x69\xc0\x44\x6b\x34\x3a\x1d\x8d\xd7\x3e\x4b\xc6\x7b\x6e\x9b\x19\xd6\x99\x61\x89\x19\xe6\x12\xe7\x3c\xc9\x27\x4f\x6d\x86\xb3\x66\xf8\x84\xb8\xda\xbd\x26\xbb\xeb\x6d\x20\x60\x2d\x32\xd8\xef\x14\xbe\x75\x12\x9e\x0c\xc0\x74\x33\x54\xe0\x45\x38\x64\x06\x9b\xe4\xb7\x77\x56\xf6\xdb\xeb\x22\x7e\x78\x95\xf2\x03\x2a\xe3\xa6\xd7\x4f\x9c\xf8\x78\x33\x64\x9c\xf3\x06\x14\xfe\x79\xdd\xe4\x69\x82\x00\x8c\x99\x88\x29\xe5\x54\x4d\xfd\x8f\xea\x3a\x1a\xd9\x5a\x91\xf7\x59\x88\xdd\xaa\x46\x1c\x17\xcc\x15\x2b\xaa\x45\x5f\x2d\x69\x4c\xa8\x8d\x27\x40\xfb\x4e\xdb\xd4\x69\x96\xf3\x1f\xe3\x91\xb8\x58\xa5\xf5\x9c\x5f\x6a\x03\xa7\xb0\x39\x5b\x96\x52\x7f\x88\xfb\xdd\x85\xb6\xf0\x16\x93\xd3\x69\x01\x64\x34\xd0\xb4\x56\x6b\xb4\xd0\x1e\xb7\xf1\xb9\xe1\x6f\xf9\x89\x3a\x63\xa3\x51\xaf\x76\x99\x75\x7a\x1d\x1e\x0f\x4a\x8b\xef\x29\x3d\xed\xb4\xd0\x5a\xb5\x16\x0f\x0d\x80\x5d\x6d\x19\xf0\xc0\x49\x0f\xf4\x7b\xa0\xd7\x03\xdd\x1e\xa8\xf3\xa4\x3f\x15\x53\x13\x26\x9a\x11\xf6\x2e\x6f\x98\xd4\x28\x25\x81\x34\x61\x85\x73\x15\xe2\x80\x0e\x46\xd8\x3b\xbd\x28\x57\xb0\xf7\x09\xd5\x3d\x3d\x70\x1f\xf4\xc1\x1f\xa1\x03\x73\xf8\x81\x3e\x66\xcb\xf9\x13\x32\x2d\x5d\x60\xe8\x0b\x32\x83\x67\xca\x47\xe6\xea\x03\xf8\xdb\xac\xe8\x6a\xbe\xcc\xaa\x51\x5b\x74\x3a\x93\xda\x64\xb7\xa9\x10\x6b\xc6\xf3\x52\x4b\x61\x59\xdc\x64\xc0\x72\xb8\x55\x63\xb0\x20\x3b\x96\x6a\xed\x10\xb2\xc3\x80\x1d\xba\xed\x20\x4b\xb4\x92\xdb\x9c\xab\x2e\xcb\x7d\x4e\x36\xfe\xa6\x59\x89\xb2\xdd\xc0\x6c\xed\x83\xd7\x7b\xae\xbd\xf0\x6a\xba\xc1\xd4\x51\x89\x95\x9c\xb7\x30\xcf\x9e\xdf\x97\x69\x6f\xda\x1f\x50\x94\x5d\x6e\xc4\xb2\x8b\x1e\x39\xd0\x44\x3e\x80\x0c\x6a\xb3\xc1\xec\x74\xd9\xf0\xa2\x6b\xb3\x9a\xc4\xfe\x66\x90\x0b\xb7\xcc\x05\x21\x57\x7a\xc7\x76\xec\xee\xaa\x85\x58\xa0\xc5\x8d\x55\x9a\x0b\x4b\xe2\x43\x08\x41\xde\xef\x3f\xf9\xf8\x0f\xef\x7d\xf2\xe9\xbb\x6f\x51\x7b\x60\x3a\xcc\xc4\x62\x74\xbf\xf0\x92\xd0\x4b\x75\x0b\x3f\x17\xfe\x04\x11\x2c\x25\x4c\x03\x71\x27\xe3\x18\xd5\x23\x3c\x2c\x3c\x29\x1c\x11\x0e\x62\xed\x83\x22\x73\x31\x4c\x74\x41\x17\x96\xa8\x3a\x90\x5d\x85\xf9\x9c\x9d\xf5\xb8\x75\x6a\x3c\xfb\x74\x46\x8b\x05\xcf\x42\x91\xd3\x61\x16\x47\x38\x9c\xd1\xb2\xc7\x03\x9b\x3d\xb0\xda\x03\xa5\x1e\x60\x3d\x70\xda\x03\xc7\x3c\x70\x80\x94\xcc\x26\xd4\x80\xcb\x87\x49\xf9\x09\x52\x98\x22\x60\x93\x24\xb8\x63\xa4\xb2\x54\xf3\x49\x52\x6d\x33\xa9\x13\x24\x25\x5a\x05\x6b\x1f\x57\xef\x1b\x2d\x69\x2a\x85\x06\x85\xb2\xa7\x1a\x19\x23\xd1\x4e\x95\x4b\xcf\xdf\xf7\xec\xe2\xa5\x3f\xfd\x89\x30\xeb\x9d\xa1\x37\x0e\xf4\xc0\x39\xf8\xfc\x5f\x9f\xd1\xbd\x0f\xff\x70\x68\xfb\xbe\xb3\x42\x7d\x46\xd2\x5c\xff\xdb\xdf\x89\xe3\x24\xf4\xa9\x0e\x91\x71\x8a\xa2\xb9\x7c\x29\xb2\x86\x0c\x6e\x71\xa8\xf2\x62\xce\x3d\x3e\x40\x3e\xac\xc8\xf9\x22\x21\x6b\x24\x82\x07\x2e\x22\x0f\x5c\x0c\x0f\x5c\x0c\x42\xb1\xac\x81\x13\x59\x2b\x77\x1c\x4f\xe0\x8c\xdf\xa8\xe8\xab\x59\x31\xee\x38\xaa\xc4\xc5\x49\x74\xc3\xc9\x8d\x5c\x04\xf9\xea\x5c\x79\x54\xdf\x3f\xf3\xc9\xef\xc5\x51\xad\x87\x59\xc2\x8f\x2b\xe6\xdd\x7a\x71\xb3\x73\x73\xe9\x65\x37\xb4\x6f\x8d\x96\x09\xc7\x84\xa3\xd4\x7e\x3c\xc2\x03\x10\x80\x4b\xf1\x18\x7b\x85\x8f\xf0\x08\x3f\x81\x47\xf8\x71\xc1\x7e\xf7\xd4\x1b\x16\x31\xf5\x39\xde\xd2\xeb\x0f\x33\x90\x92\xc6\x5a\x75\x25\x1e\x6b\x3b\x0a\x60\x6d\x6a\xaa\x9d\xe3\xbc\x46\x2f\x56\x41\x1c\x46\x9b\xd9\x62\x36\xaa\x99\x60\x88\xc3\x82\x22\x56\xa0\xbc\x3a\x46\xe7\x96\x35\x0f\xb3\xa4\x7a\xd8\x18\x0b\x17\x82\x93\x21\x68\x97\xb7\x1c\x15\xcb\x47\x71\xb6\x8c\xab\xf4\x38\xad\x19\x25\xfb\x93\xfd\x47\x8d\xb8\xa8\xe8\x32\xe3\x05\x8f\xbe\x31\xf4\xce\x81\x1e\xea\x92\x0b\x83\x77\x6f\x81\x15\x7b\xf1\x87\xed\x84\x9c\x7b\x5f\x7c\xec\xa9\xa7\xef\xa7\x66\x0a\x8c\x3c\x40\x47\x7e\xb6\xe3\x95\xd8\xd0\x5f\xf0\xda\x32\x13\x6e\xfb\xd1\x96\xa1\x57\xb6\x8b\x73\x7f\xd7\xf0\xe7\xf4\x59\x3c\x5e\x25\x28\xc9\x57\x3a\xb5\xf9\x01\x64\xce\x37\x97\x5e\x14\xd0\xda\x8a\x8a\xb0\x70\x07\x45\x56\x1b\xd6\x0e\x5c\x36\x66\xb0\x14\x06\x4a\xe1\x64\x29\xf4\x97\xc2\x20\xf9\xb7\xac\x14\x42\xa5\xd2\x92\x99\x5e\x0e\x11\x11\x4c\x15\x3b\x60\xe9\xad\x9f\x91\xdd\x52\x35\x31\x77\x8a\x22\xbb\xb4\xdb\x15\x50\x93\x0d\xd5\x58\xfe\xee\x69\xb9\x79\xcf\xcc\xbb\xf3\xc7\x53\xae\xbb\x7d\xfb\xed\xd7\x4d\x19\x7c\xe7\xe0\x2f\xa6\xe5\x2e\xb9\x6f\xc7\xfd\x53\xae\xdb\xbc\x7d\xf3\x75\x53\xbe\x18\x58\xf9\x87\xab\x60\xd9\x33\xa5\x8d\x7b\x6e\x6f\x5c\x34\xad\xe4\xa2\x49\x73\x37\x2f\xec\x7e\xb6\x58\xf8\xec\x50\xd3\xaa\xd6\x69\x73\xa7\x4c\x28\xad\x5d\xb0\xb5\xf5\xe5\x77\x62\x61\xc2\xd3\xf2\xf0\xdc\x7c\x49\x94\xbb\xe0\x62\xfe\x03\x0b\xa5\xa7\xb4\xb4\xdd\x61\x40\x5a\x4c\x7f\x5a\xad\x0e\x33\x34\x71\x81\xa4\x2d\x44\x54\x47\x96\x3a\x22\x48\x0d\x10\xd9\x49\x12\xb6\x52\x44\x9a\x0a\x91\xf2\x15\x83\x44\xae\xea\x26\xcf\xda\x15\x32\x9a\x54\xde\x2b\x8b\x63\xab\x49\x35\xde\x01\x65\x04\x00\x11\x61\x0d\x3f\xed\x20\xe5\x65\xa4\xa4\x76\x98\xbc\x47\xaa\xb6\x87\x3c\x98\x4d\x9e\x0d\x92\xf2\x5e\xf9\x1d\x52\x85\x10\xa9\x33\x48\x10\xf5\x93\xd7\x74\x90\xa7\x75\xb2\x34\x48\x84\xbb\xef\x94\x5a\x17\x7d\xe7\x12\xb9\x68\xa4\x4e\x96\x64\x2b\x2d\x99\x32\x19\xe2\xa5\x06\xd3\x1d\xb1\x5a\x9b\xc3\x44\xcd\x2a\x16\x89\x11\x6a\xdf\x89\x0f\x2d\xf4\x5e\xc2\x3c\x34\xdd\x1b\xf8\xf5\x4d\xe5\xef\x60\x02\xbb\xdf\xf6\x16\xd4\x0a\xaf\xbe\xa5\xd1\x9f\x5f\xe1\xad\x42\xb2\xec\xab\x7a\x88\xac\x99\xf7\xf0\xad\x56\x83\x4b\x6d\x50\xbb\x3d\x16\x15\x32\xb2\x46\x2c\xf0\xb2\xb4\xce\x8e\xc7\xc0\xca\x60\x1e\xd6\xe6\x81\x16\x0f\x4c\xf7\x40\xa5\x07\xa2\x1e\xb0\x79\xa0\xcf\x03\x87\x3c\xd0\xe5\x81\x6d\x1e\x58\x27\x97\x73\x1e\xc0\xd0\x67\x3d\x80\x57\x51\xea\xa4\xbc\x86\xb6\x7b\x20\xe1\x01\xa5\xea\xa8\xf8\x54\x99\x9f\x64\x14\xa6\x91\xe5\x20\x2d\xde\x32\xb9\xa1\x68\x55\x5a\x36\xe3\xc2\x98\x4a\x99\x9d\xe2\xc2\x24\xfc\xf3\x82\xf0\xb5\xf0\x4f\x51\xa6\x87\xeb\xfa\xdf\x4c\x8b\xb9\xa7\xff\x3e\xf8\xf7\x0f\xe8\x4a\xf2\xfb\x7d\xe1\x9e\x67\x9f\x16\xbf\xd3\x39\xfc\xa1\x4a\xf4\x49\x30\xa1\xdf\xf0\xbb\x0d\x14\x43\xeb\x73\x54\x2a\x3d\xe6\x4d\xac\x21\x87\x52\x69\xf0\x34\x32\x69\xb0\xa2\x68\x4d\x71\x10\xe4\xe0\x4b\x0e\x9e\xe4\x60\x33\x07\xb3\x39\xa8\xe3\x80\xe5\x60\x98\x83\xd3\x1c\xf4\x72\xd0\x4e\x1c\x27\x10\x07\xb5\xfd\xe4\x5e\xf2\xa5\x48\x90\xd2\x32\x0e\x3a\x39\xe8\xe0\x20\xc4\xc1\x20\xf1\xb4\x38\x29\xc3\x48\xe5\xed\x0a\xc8\x10\xc1\x32\x5a\xa5\x19\x8f\x2a\xc8\xc4\x55\xf4\x8e\xc4\x7d\x64\xf9\x15\x72\xa5\x5e\xd2\x89\x42\x6b\xef\x3d\x43\x1f\xc7\x87\x4e\xdf\x4f\x05\xfa\xb0\x78\x71\x6f\xaf\x28\xad\x9e\xfb\x87\xca\x48\x3a\x23\x8f\x7e\xdf\x23\xea\x8a\xd4\xf0\x87\x9a\x5d\x64\xde\xcd\xe6\x43\xac\x2d\x47\x65\x53\x39\xec\x94\x36\x07\x8b\x42\x06\x83\xd1\x68\x63\x73\x48\x87\x98\x35\xb4\x49\xaf\x17\xa5\xa6\xe3\xf8\x91\x9e\x06\xf1\xb8\xa2\x03\xe6\x3a\xc0\xe1\xc0\x4c\x15\x3e\x73\xc0\xfb\x0e\x78\xcd\x01\x87\x1d\x70\x9f\x03\x96\x90\x47\x0d\x0e\x98\xe8\x80\x18\x01\x58\xf6\x8d\x03\x3e\x71\xc0\xef\x1c\xf0\xbc\x03\xee\x70\x80\x38\x2b\x30\x82\x33\x0e\x38\xe5\x80\xc7\x1c\xf0\xa0\x03\x76\x3b\xd2\x85\x2d\x64\x52\x56\x3a\x20\xea\x00\x1b\x01\x38\xee\x80\x3e\x07\x1c\x22\x30\x09\xf2\x94\x92\xa6\x67\xcd\xa0\xac\x42\x75\x3a\x80\x23\x45\x27\xc9\xd4\xeb\x25\xc8\x38\x32\x49\x33\x25\xb3\xe5\x69\xa8\x9c\x80\x99\x4e\x4e\x8d\x95\x50\xd7\x48\x5b\x4e\x63\xf5\x0a\x51\x7e\x12\x25\xa7\xcc\x50\xe0\x89\x18\x2f\x8d\x67\x19\x35\x73\x75\x23\xc3\x11\xd7\x49\xbf\x54\x8b\xaa\x84\x43\xc2\x83\x55\xc2\xf4\xf5\x14\x7a\x15\xea\x60\x59\x09\x5c\x03\x65\x6f\xc1\xcf\xd6\x07\xe9\x87\x2e\xb4\xa5\x47\x67\x36\x7d\xf0\xc2\x22\xfa\x29\xa2\x95\x82\x18\x3c\x5b\x75\x90\xd8\x35\x0e\xf1\x2b\x55\x76\x9f\xdf\x6a\x12\xfd\xbe\x53\x49\xaf\xda\x66\x64\x68\x4e\x47\x7b\xec\x92\x6e\xef\xa2\x2d\x29\x3f\x04\xfd\xf0\xa5\x1f\x9e\xf4\xc3\x66\x3f\xcc\xf6\x43\x9d\x1f\x58\x3f\x0c\xfb\xe1\xb4\x1f\x7a\x89\xc1\x82\xf7\x03\xf2\x43\x2d\xbe\x74\xfa\xa1\xc3\x0f\x21\x62\xd0\x38\xe9\x87\x7e\xd9\xa4\xd1\x4a\x20\x14\xa4\x38\x96\x08\x33\xb2\xaf\x52\x9b\xaa\xc9\x28\xda\xba\x11\x4a\x0c\xa7\x15\xab\xaa\x6a\x80\x29\x87\x85\xa6\x2e\xf8\x95\xb0\xe9\x7e\xaa\xf0\x08\x38\xa0\xfa\x30\xfc\x67\x17\x5e\x00\xdf\x7c\x60\xe8\xdd\x23\x42\x37\x51\xc7\xa9\x45\x14\x2f\x7e\xba\xb0\x18\x88\x36\x25\xe4\x0c\xcd\x23\xe5\x5a\x89\x4f\x39\x71\x7f\xdc\x43\x74\xf4\xd5\xfc\xa5\x48\xa3\xc1\x8b\x2c\x6b\xd4\xe6\x60\x99\x5d\x83\x4c\x34\x63\xce\xc9\x18\x10\x31\x39\xd4\x49\xf4\x92\x90\x99\xf3\x00\x59\x18\x24\xb6\x9c\x90\xb9\xbf\x72\xce\x2d\x5a\x98\xd1\xaf\xb3\xbe\x4c\xb9\xb4\x67\x7d\x1b\xdd\xf0\xce\xd0\xbd\xef\x08\x85\xf7\x53\xd5\x7d\xb0\x05\x6e\x38\x02\x7d\xf7\x50\x9c\xc0\x93\xcd\x88\x17\xa8\x33\x44\x21\xbc\x97\x5a\x91\xb1\x31\x2c\xc6\x6b\xdd\x8d\xb8\xfd\x16\x08\xf1\xbf\x06\x5d\x0e\x56\x55\x74\x1c\x63\xb3\xa2\x1c\x4b\x4e\x2a\xc9\x5a\x2c\x3a\xd0\x42\x6b\x52\xa5\xa5\x95\xfb\x38\xed\xe3\x6d\xfc\x28\x37\x7d\x0e\xc9\x7b\x3d\x78\x32\x53\x83\x64\x07\xe7\x24\xd9\xc4\x19\xbb\xd1\x23\xed\xf2\x60\xb8\x9a\x01\xf2\x20\xb3\xeb\x83\xe4\x8d\x9f\x5e\x52\xde\x4e\xf6\x84\x32\x8f\xc6\x22\x95\xd0\xd5\x91\xa7\xdf\xb9\xb0\x65\x5b\x6b\x52\xe3\xaa\x7f\xb2\x36\x92\x25\x54\x95\x97\x55\x43\x7a\x35\xb3\x03\x66\xf5\x44\x09\x5c\x4c\x0d\x9e\xfb\xe7\xc2\xe0\xa5\xf4\xde\x21\x3d\x44\xd6\x7d\x59\x5e\xdb\xe0\xbd\x90\xb3\x88\xd9\x65\x7b\x1b\xa6\xcc\x3d\xbf\xca\xa1\x07\x24\xec\x16\xfb\xf9\x01\xe1\x0b\xaa\x55\x75\x17\xd2\xa0\x9f\xf3\x77\x68\x28\x06\x28\xd0\x69\x29\xfa\xeb\x24\x85\x7b\xfc\xeb\x24\xaa\xd5\x41\xb1\x0e\xde\xd7\xc1\x63\x3a\xd8\x46\x8e\x70\x49\x25\x5e\x72\x1c\x6b\xd9\x59\x1d\xbc\xa8\x83\x05\xe4\xc1\x1b\x3a\x78\x50\x07\xbb\x75\xb0\x82\x94\x64\xe0\x58\x1d\x0c\xeb\x80\xfa\x52\x07\xa7\x75\xf0\xa4\x0e\x0e\x90\xf3\x57\xb8\xb4\x06\x17\xf7\xeb\xe0\x24\x39\xa8\x75\x9a\x9c\xcf\x52\x6e\xad\xca\xc6\xc2\x51\x66\x1e\xb2\xbe\x97\x8e\x56\x84\xac\xf8\xf3\x55\x66\x95\xfd\x01\x3c\x6f\xde\x85\x42\xe1\x0b\xf5\x81\xd2\xc2\x73\xe6\xc2\xd2\x2c\x5f\xd8\x6f\xf9\x5e\x31\x1d\x1c\x85\x54\x0c\x65\x45\x8c\xe4\xb5\xdb\x25\xfb\xfc\xb6\x10\xb7\xdf\x4a\xe2\x14\x2c\x79\x04\x8f\xf2\xf1\x6f\x23\x7e\xc0\x12\x4c\x94\xb8\xf2\x63\x4c\x69\xcf\xff\x8c\x13\xf0\x28\x7f\x61\x4e\xe9\x2f\xdc\xa1\x78\x26\x9d\x05\x18\xeb\x3e\xdc\x2a\xbb\x19\xf7\x92\x9a\xdf\x2d\x02\xa5\x3b\x23\xb5\x66\xcd\x78\xf6\x82\x6c\xbf\x7b\x73\x1c\x72\x17\xc3\xbb\x6d\xaa\x86\x73\x87\xc9\xfc\x6a\xc2\xe3\x6e\x21\xe3\xfe\x22\xbf\x85\x41\x94\x46\x83\x74\x5a\x15\xf3\x75\x52\x85\x9f\xe2\x71\x97\x46\x04\x8f\x4e\x2f\x19\x97\xd9\xe4\xa8\xdc\xb2\x41\x1d\x1c\xd3\x41\xb7\x0e\x3a\x75\x90\x22\xa5\x1c\x79\x70\x42\x07\xab\x49\x49\x1d\x39\x55\x17\x94\x07\x5d\x39\xe6\x1d\x99\x61\xc7\x58\x5b\xff\xcd\xb0\x7f\xd7\xa1\x97\xf1\x46\xbd\x2a\xcf\x9c\x57\x15\x36\x37\xe1\x11\x7f\x17\x8f\xfc\x17\xa5\x85\xaa\x2f\x0b\x4b\xff\x75\x2d\xf9\x46\x3f\x6c\xa7\x0f\x63\x1e\xa2\x46\x97\xf3\xc5\x2a\x35\x5e\x8f\x69\x8a\x62\xd4\xb4\xe8\x7c\xc3\x60\x6a\xd0\xc2\xac\x90\x16\x06\xb5\x30\xa0\x85\x5e\x2d\x74\x63\x86\xa2\x85\x84\x56\xde\x6b\x14\x99\x5c\x45\xe9\x68\x01\x02\x77\xa4\xb8\x66\xbd\x5e\x0e\x3d\xd7\x0b\x07\x85\x83\x4b\x54\x53\x2e\x34\x8a\xde\x2d\x84\xef\x0e\x0f\x0a\xdf\x32\xdc\xf0\x22\x8c\xdd\xce\xeb\x28\x4c\x4a\x80\x5e\x48\x82\xe8\x1e\x00\xa4\x3e\x8d\xb9\x21\xc7\x84\x84\x6f\x97\x2c\x91\x7c\x3f\x99\x14\xc5\xa9\x3a\x91\x0a\xfd\x95\x7f\x04\x2f\x50\x94\x8a\xd2\xa8\x11\x75\xf7\x02\xd1\xf3\xa5\x14\xd1\x5a\xd4\xaf\x81\x5e\x0d\x74\x6b\xa0\x43\x03\xed\x1a\x68\xd5\x40\x42\x03\xbc\x06\x42\x1a\xe0\x34\x80\x34\x30\xa8\x81\x01\x19\xa6\x93\x80\x49\x00\x65\x04\x46\x7a\x7a\x52\x03\xfd\xe4\xa9\x84\xa1\x4c\xae\x3b\x49\xaa\x26\x55\x90\x40\x25\x14\x52\x65\xa9\x9a\x54\xa7\x54\xae\xa3\xcd\x3e\x9b\x34\x8a\x22\xc7\x37\x5d\x95\x66\x6f\x66\xea\xa0\x2a\x6e\xb5\xc3\x7b\xc2\xfe\x77\x8e\x33\x29\x30\xe4\x09\x83\x61\xc9\x26\xd2\x88\x75\xb7\x35\xf4\x4b\x78\x1d\xcf\x43\xab\xf8\x3a\xb3\x36\x2f\x8f\x09\x19\x0c\x6e\x86\xce\x8f\xe5\x45\x72\x22\x73\x92\x2e\xbb\xd9\xec\x4b\x24\x59\x73\xd0\x4c\x19\x68\xb3\x19\x69\x73\x1c\x1a\x26\x91\xd4\xd8\x91\x3d\x91\x44\x5c\x47\x3e\xa4\xf2\x81\xcf\x07\xfc\x63\xe1\x9a\xcc\xce\xb0\x28\x2f\x5b\x6a\x32\x3b\xc3\xa3\x14\xd3\xb4\x23\xac\xb8\x74\x61\x55\x3b\x62\xae\x9c\x8a\xe5\x8e\x11\xef\x16\xd0\x88\x6e\x18\xc4\xed\xe2\xad\x7d\x7b\xd7\x0b\x82\x75\xed\x53\x7f\xbf\xbc\xfb\x81\xbb\x2e\x6b\x6a\xbb\x32\x32\xe9\x20\xa0\xad\x3b\x52\x7b\xa6\x5f\x57\x41\xbf\x74\xfb\x1d\x43\xdb\xdd\x25\x8b\xd6\x82\x6b\xd1\xa6\x69\x34\x73\xcf\xb5\xd7\x94\xae\x7f\x33\x57\x08\x30\xaa\x45\x37\xf4\x06\x5d\x24\x77\x29\xf1\xd7\xbc\x0b\xe9\x91\x1f\x75\xf0\x73\x2c\x1a\x8d\x1f\x39\xfd\xce\x40\xd0\xa3\x4b\x24\x3d\x0e\xb5\xc5\x62\xb3\xd1\x73\x92\x36\x2c\x6b\xe3\xef\x44\x7c\x10\x3a\x82\x80\x82\x50\xd3\x19\x04\x2e\x08\x03\x41\xe8\x0f\x42\x6f\x10\x3a\xc9\x83\xd6\x20\xf0\xa4\x44\xfa\x1d\x0a\x42\xd6\x14\x5a\xb4\x70\xe1\xda\x11\xf3\x83\x39\xae\x9c\x40\x69\x1b\x09\xd6\x5a\x35\x64\x27\x5c\x5c\xab\xcd\x36\x8d\xe4\x70\x4e\x89\x2a\x2c\x25\x74\xec\xa8\x5d\xe7\x69\x59\xff\x83\x5b\x87\x76\xef\x82\x52\x75\xdb\x03\xfd\x6f\x7e\xf8\xce\xdc\x13\xb3\x60\xf0\xb9\x3e\xbb\x61\xc8\xc9\xfd\x9e\xb9\xc8\x55\x22\xf4\x4e\xec\x9c\xf5\xd9\xe7\x43\xc2\xbf\x62\x41\xe9\x7c\x07\xfe\xc6\x59\xf4\xab\xc8\x81\x5a\xf9\x8b\xcd\x2a\xbd\x43\xe5\x70\xba\xb4\x6c\x22\x69\xd0\x72\x0e\x1b\x6d\x9b\x93\xa4\x1d\xc8\x05\x53\x79\x17\x94\x11\xfb\x16\xe7\x82\x41\x17\x9c\x24\x27\x0a\x3a\xc8\x89\x82\x27\x5d\x90\x72\x65\xdb\xf9\x33\x52\x87\x92\x98\xc8\xbe\x99\x79\x44\x07\x0f\x49\xbe\x97\xf4\xac\xf2\x9e\xf9\x42\xf5\x67\xef\xed\xec\xae\x2e\xbe\x72\x9d\x70\xf6\x3f\x1e\xbb\x7b\x65\x4d\xb4\x10\xfe\xfe\xd7\xa1\xa0\x70\xee\x70\xa9\xb0\xf4\xd4\x33\x61\x71\x3c\x9a\x70\x5b\x3f\xc5\xe3\x61\x25\xe3\x31\xdb\xc6\xe8\x91\xdb\xcd\x31\x5c\x20\x68\xe5\x12\x49\xab\x5d\x1a\x06\x0d\x26\x3a\x0d\xe7\xc6\x15\x28\xe7\x9c\x24\xe5\xc0\x03\x72\x59\x82\xf4\x7d\x19\xe9\x75\x24\x0f\xc2\xf8\xa3\xb1\x56\xf9\x05\x64\x18\x46\x0e\xef\xa5\x3f\x45\xfa\x1a\xe2\x4f\x6b\xc1\x1f\x13\x9b\x42\xc6\x43\xb4\xb6\x93\x0f\x32\xe3\x4f\xa3\xde\x5e\x73\xbf\xb0\xf9\x0f\xa7\x56\xae\x56\xef\x87\xe9\xeb\x84\x6f\x85\x60\xc7\xb6\x35\xf3\x93\x6b\x85\x0b\x0d\xf3\xe1\xc3\x7f\x02\x38\xc3\xdb\xcf\xba\x4a\xce\x3d\xef\x2e\x81\x37\x7f\xf1\x62\x3e\xf5\xa9\x99\xcc\xab\x04\xfe\xc6\x06\x3c\x1e\x76\xe4\x43\x77\xf1\xf3\xdd\x00\xac\x47\x6b\x67\xed\xfe\x80\x1b\xe1\xaf\x73\x07\xdd\x78\x32\xb9\xdd\x06\x8b\xc5\x91\x48\x5a\x38\x83\x6a\x4e\xd2\xe0\xe8\x97\x9d\x28\x25\x9f\xca\x76\x72\x90\x21\x41\xdc\x2c\xa7\x26\xc8\x91\x86\xb2\x00\x84\x02\xc0\x05\x60\x90\xc0\x61\xa0\x35\x6b\x46\xef\x10\x67\x6d\x7a\x2a\x36\xf6\x32\x5b\x0a\x36\x62\x49\x91\x4c\x5d\x31\x71\x20\x43\x66\x3b\x44\xd4\xf6\x70\x65\x0c\x98\x29\x9b\xaf\x9f\xd8\x55\x56\xf6\xf0\xdc\xf7\xdf\xf8\xed\x31\x58\x26\xdc\xbf\x74\x35\xdc\x7d\x0d\xbc\x67\xf9\xc1\x8f\x12\x16\xfd\xa4\xe0\x45\x9f\x83\xea\x9b\xaf\x84\x25\xcd\xf0\xd0\xa3\x87\x9e\x26\xe7\x67\x44\xa7\x86\x23\xaa\x83\xc8\x0b\x13\xf9\xdf\x5b\x1c\x0e\xda\xeb\x75\x5a\x73\x18\xbf\xcf\xe1\x75\x7b\x13\x49\xb7\x1d\xd9\xac\xb6\x44\x92\xb6\xb2\x1a\x53\x22\xa9\xd7\x80\x57\xde\xbe\x7c\xd1\x0f\xdb\xfc\xb0\x8e\x6c\x6b\x16\xfb\xd3\xe5\x2b\xce\xf8\xe1\x94\x1f\x8e\xfb\xa1\xcf\x0f\x5d\x04\x02\x3f\x9e\xa1\xa8\xf3\x18\x29\x5f\x40\xea\x48\x5b\xa1\x6f\xc8\xe5\x18\x57\x8b\x62\x8b\x74\xf2\x5f\x09\xa2\x43\x44\xab\xc8\xbc\x2a\xb3\xa9\x8a\x97\x2c\x6a\x50\x56\x34\xba\x89\xde\x21\xa9\x22\x58\xfb\xe0\x64\xcd\x84\xcb\xe8\x1d\x19\x56\x9b\x52\xf0\xda\xd1\xab\xe8\x38\x3b\x82\x92\x77\x91\x6c\x41\xc8\x6c\x25\x38\xe5\x9d\x68\x6b\x6e\x55\xb5\x64\xd4\xb2\x4b\x46\x2d\x3f\xc4\xed\xb9\x92\x5c\xff\xe1\xc1\x83\x0f\xdf\x7b\x45\x7d\x79\x49\xa4\xac\xae\xf2\xdc\xb9\x37\x04\x66\x37\x3d\xaf\x3c\xbf\xfe\xe4\x80\xf5\xcd\x4d\xf6\xf6\x7d\x0f\xb5\x5c\xf8\x26\x5c\x52\x12\x16\xcf\x79\x0b\x0d\xf4\x7b\x8c\x17\xe5\xa3\x4a\xc4\xc3\x7e\x7e\x78\x42\x69\xa9\xd3\xa6\xf6\x4c\xf5\x4f\x42\x05\x46\x23\x8a\xe5\xaa\xbc\x7e\x8f\x4d\x37\xad\x9e\xae\x4a\x24\x9d\xc5\xc5\x39\x2a\x6f\x2c\x97\xa1\x73\xe8\x9c\x90\x39\x54\x9b\x48\x86\x38\x73\x45\x22\x69\xf6\xf5\xd5\x43\x77\x3d\x74\xd5\x43\x47\x3d\xac\xab\x87\xb6\x7a\x68\xa9\x87\xe9\xf5\x50\x59\x0f\xd1\x7a\xb0\xd5\x03\x53\x0f\x03\xf5\x70\xaa\x1e\xfa\xeb\x01\x03\x1f\x22\xc0\xdb\xb2\x81\x25\x48\x54\x0f\x67\xeb\xe1\x0c\x01\x3e\x9e\x0d\xdc\x36\x06\x67\x8d\x12\xf4\x90\x0c\xa4\x7c\x37\x33\x06\x20\xf3\x4a\x9e\xc0\x84\xea\x81\xe2\xc8\x6b\x07\xeb\xf9\x88\xd8\xca\x93\xa4\x95\xbd\xe4\x93\x3a\xc9\x27\xb5\xd7\x43\x6b\x3d\x94\x11\xe0\x2c\xd1\x2e\x4b\xb6\x5b\x3b\xde\x18\x8f\x5e\x73\x47\x03\x2a\xe6\x9e\xe8\x95\x28\x2d\x77\xd9\x8e\x18\xb2\x60\x43\x0e\x81\x68\xf0\x54\x0c\x4b\xc7\x8d\x24\x3f\x4e\xd1\xaf\x5f\x3e\x16\xec\xac\x76\x6a\x88\x7f\x7f\x58\x76\x4a\x94\x8f\x51\x88\x3e\xfe\xf4\x92\x97\x9f\x6d\x6e\xa8\xa3\x1b\x27\x82\xe3\x81\x7b\xd6\xff\xf9\x27\xfd\xaf\x37\xb6\xd6\xcc\xda\xbf\xff\x95\x17\xf2\xd6\x05\x3f\xc8\xdd\x7d\x49\x61\xc3\x65\x42\x57\x51\xd5\xad\x1d\x8f\x3c\x23\x3c\xbd\x6a\xc1\xa2\xa5\xcb\x16\xb7\x52\x5b\x0f\x1e\x66\xb7\x9a\x03\xdb\xd6\x2d\x7b\xe8\xaa\x0d\xab\xaa\xae\xbf\xd4\x7a\x4d\xd5\xd1\xa6\xf7\xf6\x3d\xca\xe6\xac\x2e\xee\x9c\x71\x61\x65\x0d\x1f\x5d\x5d\x36\x77\xc6\xad\xd4\xfa\xdb\x36\x6f\x5f\xb3\x76\xdb\xb6\x9b\xc4\x39\x6e\x43\x88\xfe\x18\xf3\x6c\x3f\x7a\x81\xbf\x19\xd9\x6c\x6e\xa3\xc9\xa4\x73\xeb\x02\x41\xbf\x27\x91\xf4\x23\x1b\xbe\x71\xba\xf1\x6a\xe3\xb4\x5b\x29\x4a\xa5\x32\x37\x27\x55\x5c\xb7\xbc\x76\x72\xd2\x72\x3a\x40\x96\xd0\x76\xc2\xa8\x95\x9c\x3c\x48\x1e\x4b\xab\x6b\xbb\xbc\xc0\x9e\x94\x57\xdd\x6e\x45\xb9\xb2\xff\x47\x8d\xce\x9a\x11\x4e\x9f\x31\x03\x8c\x76\x69\x00\x9b\x66\x2a\xc4\xd3\x72\x07\x56\x99\x2b\x73\x23\x8a\x7d\x55\x68\xd0\x34\xfe\x67\xdd\x2d\xb7\xae\x15\x56\xdc\x76\x78\xd1\xd6\xcd\x42\xdb\xc6\x3b\xa1\x82\xfe\x66\xe9\x45\x85\x17\xff\x70\xe7\xd0\x7d\xee\x92\x12\x37\xb5\xa8\xc7\x3f\x64\x15\x7f\xa9\x28\x57\x09\xe6\xf3\xc5\x98\xf7\x59\xc8\x5e\x85\x1d\xfd\x98\x5f\x82\x0c\x06\xb5\xd9\xec\x74\xd0\xba\x2b\x45\x9f\x70\x8e\xa6\xed\xbc\xdd\x92\x48\xe2\x35\xcd\xcc\x9a\x31\xe3\xb7\xdb\x9c\xc0\x38\x31\xa5\x3b\xa1\xd3\x09\x54\xbb\x13\x5a\x9d\x90\x70\x02\xef\x84\x7e\x27\xf4\x3a\xa1\x9b\xdc\x86\x9c\xc0\x39\x01\x39\x61\x90\x94\x60\x50\x25\xe4\x58\xb1\x3d\x45\x7a\x21\x63\x86\xcd\x72\x38\x57\x12\x9c\x1c\x69\x64\xe4\xa3\x37\xf1\x25\x13\x78\x7e\x42\x09\x9f\xf3\x13\xc1\xdd\xbd\x1d\x8a\x99\xd3\xd2\x3d\x7f\x7e\xb2\xf8\x9d\x74\xc8\x8d\xbf\x73\xf8\x55\x61\x26\xec\x22\xdf\xe9\x47\x9f\xf1\xfb\xf1\x77\x9a\xd5\x6e\x77\x20\x38\xf2\xa1\x7e\x9e\x90\x02\xcb\x8a\x0b\x1a\xeb\x3d\x1f\x84\x17\x83\xb0\x2d\x08\xfa\x20\xac\xc2\x37\x7f\x0d\xc2\x8c\x20\xd4\x06\xa1\x38\x08\x5e\x52\xfa\x60\x10\x76\x07\x61\x53\x10\x16\x90\x47\x95\x04\xe6\x7d\x52\xed\x31\x52\x8e\x61\x6a\xf1\xe8\x53\x1d\x0a\xa2\x09\x29\x28\x23\x23\x07\xf4\x2a\x00\xd8\x60\xb6\x9f\xf6\x5a\xa9\x7b\x16\x8d\x16\xa1\xd7\x66\x1c\x62\xe2\x92\x64\x30\xaa\xcb\xc6\xf6\x19\x99\xb0\x55\x71\xa7\x38\x11\x89\xb1\x17\x76\x91\x7e\xc2\xfd\x97\x73\xff\xdd\x53\xaf\x2c\xf5\x86\x2b\x6a\x2f\xbe\x0b\xe2\x99\x1e\x3c\xf7\xe6\x2b\xbf\xb6\xfc\x72\x95\xef\xf6\x3b\xe9\x7e\x77\x09\x91\xd3\xf2\x91\x98\x24\xff\x2e\xe4\x46\xc7\xf9\x2b\x4c\x1a\x8d\x9a\x45\x1c\x67\x07\xb5\x51\xab\x55\xdb\x69\x8f\x97\xf7\xb6\x7a\xa9\x6e\xd1\xe1\x20\x84\x7f\x27\xbc\xfd\xde\x01\xaf\x7a\x0a\xe7\xed\xf5\x52\x9c\xb7\x0c\x17\xb4\x7a\x4f\x7a\x07\xbd\x6a\x84\x7f\xb6\x7b\x3b\x71\x79\x3f\x2e\xd0\x68\x69\xaf\x98\x8a\x34\xb9\xb0\x91\x5c\xaf\xb8\x4a\xba\x56\xd5\x90\x2b\x1f\x29\x2e\x6f\x74\xe3\x71\x71\x23\xce\xa8\xb5\x5b\xed\xa2\x7c\x65\xd2\x30\xb4\xde\x6a\x57\x03\x0d\x78\x6d\x66\xc7\x1a\x98\x70\xa7\x80\x98\xd4\x12\x77\x8a\x68\x6b\x5b\xb3\x56\x19\xc9\x24\x7d\x54\x6a\x94\x29\x4d\x39\x9b\xe6\xc1\x96\xc5\x30\x73\xbd\x70\x16\xe6\x2d\x11\x36\xcf\x15\x84\x4d\x6d\xc2\xe6\x8d\xbb\xa1\x1c\x5e\x85\x03\xde\x92\x12\xa7\xf0\xc5\xd0\x17\x4e\x4c\x61\x70\xef\x4e\xe1\xab\xcc\x94\xc2\x7d\x54\x88\xe7\x14\x87\xfb\x48\x87\x0e\xf2\xed\x2a\x7d\x8e\x4e\x9d\x48\xea\x90\x68\x4d\xc4\x0d\xb5\x9f\xd2\xc3\x71\x3d\xf4\xe9\xe1\x90\x1e\xba\xf4\xb0\x4d\x0f\xeb\xf4\xd0\xa6\x87\xa8\x1e\x6c\x7a\x60\xf4\x78\x6e\x11\x88\x4e\x3d\x9e\x5e\x7a\x68\xd5\x43\x42\x0f\xbc\x1e\xfa\xf5\xd0\xab\x87\x6e\x72\xcb\xe9\x01\xe9\x61\x90\xdc\x62\x38\x25\xd8\x18\x5d\x6b\xb4\x0b\xc7\xc8\x5e\xc7\x28\x17\x1e\x58\x2d\xce\xa0\x6e\x68\x68\xc8\x7c\x0c\x88\xfc\x41\xed\xc6\x72\x60\x39\x1c\xe5\x87\xcd\x06\xb5\xcf\x17\x46\x05\x05\x78\xbd\x36\xd0\xf1\x8a\xf2\x8b\x12\xc9\x72\xb6\x20\xec\x33\x1b\x4a\x8a\x4b\x12\xc9\x20\x5b\x6c\x77\xab\xd5\x3a\x9d\xad\x39\xa9\xe3\x30\xa9\xd0\x74\x5e\x73\x92\xe6\x36\xc4\x61\x6e\x1c\x26\xc6\x21\x1a\x07\x47\x1c\xd4\x71\xf8\x26\x0e\x67\xe2\x70\x2a\x0e\xaf\xc5\xe1\x50\x1c\xee\x8b\xc3\xe2\x38\x40\x22\x0e\xd3\xe3\x50\x46\xe0\x6c\x71\x60\xe2\xb0\x74\x50\x06\xec\x8b\xc3\xba\x38\xf0\x71\xa8\x24\x8f\xf1\xb3\xb3\x71\x78\x3f\x0e\xfd\x71\xe8\x25\x38\xb6\xc5\xa1\x2d\x9e\x46\x21\xc1\x70\x32\xd8\xc9\x38\x1c\x8f\xc3\x63\x71\xe8\x24\x60\x2b\xe2\x50\x1b\x87\x90\xfc\x8e\x49\xd2\x0b\xba\xe3\xd0\x1a\x87\x16\xf9\x1d\x36\x52\xf3\x0c\xa9\xd9\x15\x87\x0e\xfc\x7a\xbe\x58\xf1\xdc\x4b\xea\x9e\x21\x0d\xa0\x7a\x09\x40\x3b\x79\x3d\x7e\x2b\x1b\xcf\x28\xbd\xa9\x7f\xbf\xf5\x34\x7a\x31\x1e\xbd\x62\x67\xdb\xcf\x15\xca\x80\xbc\x54\xc8\xa6\xf2\xf8\x68\xd7\x65\x32\xfd\xc9\x6a\xe1\x14\xff\x75\x43\x66\xc9\x30\x51\x9a\x91\x15\x24\x36\x6a\x09\x99\xf1\x28\x7f\xe9\x7a\xff\x15\x27\xa6\x0f\xde\x2c\x5c\x75\x67\xb7\xe7\xd2\x4b\xeb\xec\xe6\xbb\x84\xfa\xdd\x57\x5d\x35\x6f\xeb\x5d\xc2\xdc\x8d\x1b\xc1\x4a\xb7\x16\x4f\xae\xac\x29\xae\x17\xfe\x9a\x5e\x54\xe6\xf5\x68\x73\x8c\xcc\xc4\x69\xf2\xed\x95\x49\xff\x90\x3b\xc3\x7c\x09\xdf\x28\xc5\xc4\xf0\x21\xa6\x23\x1f\xea\xe7\x6f\x43\x56\xab\x4b\x6f\x30\x68\x5c\x1a\x7f\xc0\x87\x57\x5d\x1f\x6b\xc5\x37\x0e\x57\x22\x99\xe3\xb0\x5b\x44\xb2\xe1\x44\xb2\x39\x14\x80\x33\x01\x38\x1e\x10\xa3\xe5\x30\x01\xa8\xc1\x37\x5d\x01\x58\x17\x80\xb6\x00\xb4\x04\x60\x7a\x00\x2a\x03\x10\x0d\x80\x97\x3c\xc6\x9a\x07\xa5\xd4\x3b\x78\xc5\x41\xae\x6e\x45\xb9\xb2\x47\x53\xff\xab\x55\x38\x7b\x0d\x1e\xd5\x83\xd3\xaf\x78\x62\xb2\xb4\x06\xcf\xb9\x6a\x3e\x5e\x84\x97\xaf\x59\x03\x06\xba\x75\x42\x4d\x66\x09\x9e\x77\x65\x2a\xbd\x06\x4b\x6b\x93\x74\x1e\x13\xf7\x8d\x78\x7e\xfe\x05\x7e\xcb\xc8\xf9\xf9\x44\x52\xcb\x51\x58\xf3\xa0\x1c\x21\xf9\xfc\x7c\x82\xe8\xbf\x92\xf2\x3b\x40\xf4\xdf\x7e\x17\xf4\x12\x2d\xb8\x93\x28\xc2\xed\xf2\x01\x7b\xa9\x4a\xed\x01\x52\x94\x20\x45\x19\xcd\x19\x65\xd7\x97\x54\x68\xa9\x1a\xfe\x77\x8c\x26\xb0\x68\x8c\xf4\xa8\x90\x14\xb3\x4e\xee\x8f\x13\xd5\x47\x3e\xb9\xff\xbb\x3f\xf4\xdd\xbe\x63\xeb\xfa\x8d\x5b\xb6\x75\xc0\xfb\x82\x59\xf8\xfb\x17\x17\xfe\xf9\x8f\xdf\xbf\xfc\xc2\xc0\x47\x3f\x3f\x2e\xd9\x72\xc2\xc2\x4c\xba\x17\xf7\x83\x13\x85\xd1\x76\x7e\x4e\x80\x65\x2c\x16\xa7\x2b\xc7\x99\x13\xc9\x75\x5a\x6c\x58\x0a\xb1\x79\x8d\xa1\x44\xd2\xe8\xf0\x7b\x35\xde\x39\x49\x46\xc3\xd1\x48\x64\xfd\x7c\x2e\x74\xe4\x02\xca\x85\x9a\xb2\x5c\x18\xc8\x85\x7e\x72\xdf\x9a\x0b\xbc\xe2\x77\x5d\xee\x88\x0a\xa4\x30\x72\xc8\x1a\x8d\xc2\x41\x4a\x36\xf1\x88\x8a\x0d\x1e\x51\xa7\x34\xdc\xa2\x7d\x23\xdf\xe1\x4f\x2f\x14\xd2\xa8\xe3\xcf\x7b\x60\x05\x68\xa9\xa2\xbb\x2e\xef\x7b\xf5\xdd\x37\xd6\x2c\x51\x1f\x12\xf8\x8d\x54\xdb\x6d\x9b\xd7\xcf\x4a\x2e\xbf\x40\x2f\x71\x97\x54\x47\x27\x9c\xfb\xef\x2f\x85\x73\x8e\xc6\x42\x01\x0b\xd4\x2e\x7a\x56\xff\x8b\xe1\x21\xb3\x99\xd8\x11\xf0\xf7\xbe\x4f\xbf\x87\xac\x28\x80\x6e\xe2\x2f\xb7\x99\x3c\x56\x8d\x86\x32\x51\xc1\x90\xd9\x9f\x48\x82\x99\xf3\xe4\xe4\x18\x0c\x4e\x51\xb3\xa6\x34\x2a\x4d\x22\xa9\xf2\xf2\x21\xe8\x20\xa7\xb7\x6b\x12\xe4\xf8\x76\x87\x7c\x82\xbb\x5f\xfe\x1d\x0a\x65\xbe\x53\xfe\x4c\xe5\xd6\xb6\xd2\x14\x92\x36\x50\xca\x84\x5c\x9d\xb1\x24\x10\xfb\xc1\x44\x62\x40\xa0\x4b\x1a\x96\x0a\x6b\xb6\xe4\xac\xf8\x89\xb0\xf9\xbd\xb7\xda\x57\x0b\xc5\x9b\xb7\xd7\xde\xe8\x17\x0d\x08\xf4\x7b\xe7\x5e\x10\x3f\x09\x54\xd7\x36\x5c\x09\x9f\xfe\x1d\xc0\x29\xe4\x1d\xeb\xb7\x19\xa9\xbf\x99\x91\xbc\x0e\x3e\x80\xc7\xd3\x86\xe6\xf0\x25\x66\x8d\x06\x0c\x06\xbb\x43\x6d\x26\xee\xe9\x26\x95\x99\xa6\x6c\x1c\x67\x4c\x24\x39\x56\x63\xc8\x31\xe0\xb9\x6f\x4f\x91\x8d\x44\xde\x01\x6b\x14\x9e\x3a\xe2\x20\xc5\xe3\xe2\x91\xb2\x78\xda\x2d\x53\xb2\x02\xe4\xe6\x8b\x66\xa8\xcc\xc4\x13\x87\x89\x7a\xa0\x78\x72\xc5\xae\x8a\x9f\x08\xf5\x98\x4d\x59\x74\x17\xbf\x79\x31\xfd\xaa\x70\x83\xd7\x31\x54\x2f\xcf\xb6\xf5\x15\xd7\x20\xf9\x9c\x05\xf5\x36\x6e\x5b\x81\xe8\xf3\x11\xd6\xd8\x3c\x46\xdc\xcc\xc2\x22\x63\x98\x76\x3a\x03\x89\xa4\xd7\xc9\xd1\xfa\x44\x52\x43\x3b\x3a\x8a\xa0\xbd\x08\x5a\x8b\x20\x51\x04\xa1\x22\x78\xb2\x08\x52\x45\x30\xbb\x08\x64\x5a\xfa\x37\x3e\x1f\x92\xf4\x95\x16\xb9\xaa\x2a\x4b\xe1\x22\x2a\x4b\x4b\xc6\xf3\xc3\x19\xa0\xa9\xb7\x9f\x7a\xbc\xe1\xa7\x65\x25\xe5\x33\x6e\x7a\xf9\x47\xc9\xef\x5d\x53\xf1\xd3\xce\xeb\x1f\x2c\x2d\xaa\x5a\x3b\xe7\xaa\x2b\x66\xdd\x33\x1f\xd3\xad\xf6\xce\x4e\xbf\xe5\xd3\xad\xd3\x0f\xdf\x52\xe9\x0f\x4f\xbf\xae\xe1\xd6\x3d\xc1\x37\x57\x95\x26\xa6\xd7\xcc\xf2\x54\x5c\x74\xc9\x5c\xf2\x3d\x36\xfc\x3d\x25\xcc\x16\xcc\x41\x2e\xe3\xf3\x73\x4c\x26\x8d\x95\xa6\x9d\x2e\xc6\xa0\xc7\x1d\xab\xd3\xe8\x59\xac\xff\x98\xe7\x24\x91\xe3\x00\xe1\x16\x75\x2e\x28\x75\xa5\x5d\x70\x94\x2e\x6b\xe9\x0e\x26\x3d\xac\xc2\x93\xd9\x9c\x5b\x55\x87\x55\x79\x51\x99\x27\x26\x25\xbb\x09\x60\x56\x6b\x6a\xd3\x6d\xdf\xab\x7b\xf7\xdd\xda\xb2\xc9\x57\xe6\x6e\xb3\xad\xbd\x9e\xba\xa7\x24\xff\x9d\x77\x5a\x86\x36\x4f\xab\xe7\xa6\xb9\x24\x7b\x9e\x17\xf3\xb4\x0f\xe8\x1e\xdc\x9e\x7b\xf9\x14\xb2\x18\x19\x46\x67\xd1\x39\x5d\x2a\xab\xc3\x8a\xbb\xd5\xc1\x32\x14\x47\x35\x27\x8d\x9c\xc3\xa0\xc3\x5a\x97\xbd\x9b\x70\xa3\x7e\x99\x39\xd5\x0c\x28\xf8\x15\x22\x4d\xce\xf0\xb5\x5e\x99\x5f\x49\x25\x21\x17\x28\xd9\x92\x92\x91\x8f\x4c\xef\xf8\xa8\xb9\x2d\x8e\x8d\x68\x21\x4b\xdb\xcb\x48\x44\x2b\xb7\x28\x0a\x42\x4d\xf7\xad\x2b\x7f\x08\xf1\x8d\xc2\x17\xda\xcb\x5e\xa8\x1b\xbc\x09\x02\x60\xe8\x09\x52\x9f\xba\x4b\x2e\xec\x73\x97\xcc\xcc\xaf\x01\x1b\xb5\x24\x2d\x0b\xa3\xe1\xcf\xc5\xb0\xd9\xc8\x04\xab\xf9\x61\x0d\xa5\x33\x51\x26\x96\x33\xe9\x34\x14\x43\x25\x92\x7a\x86\xd5\x68\xc1\xa8\x45\xe0\x58\xc7\x41\x1b\x07\x2d\x1c\x4c\xe7\xa0\x92\x83\x28\x07\x36\x0e\x18\x0e\xce\x72\x70\x86\x83\x53\x1c\x1c\xe7\xa0\x8f\x83\x43\x1c\x74\x71\xb0\x8d\x83\x7f\x03\x3f\xf0\x7f\x03\x5f\xf3\xff\xe7\x0b\xba\xc7\x83\x97\x3c\x2b\x38\x02\x7f\x9c\xe0\xec\xe0\xb0\xa0\xda\x47\xdc\x34\x46\x07\x46\x1c\x6b\x60\x18\xc7\x1a\xf1\xdd\x15\x44\x8f\x80\x45\x0b\xc7\xf1\x5b\x51\xe5\x66\xed\x16\x53\x25\x4d\xc2\x6d\xad\xf0\xec\xbd\x60\x01\xf5\xbd\x70\xcd\x7c\x1b\x7d\x0b\x9e\xf1\xde\xa1\x8d\xd4\x6e\x7c\xb5\x13\x9f\x8c\xcf\x55\xbf\xc0\x63\x65\x43\xff\xe0\x03\x39\x2a\xd6\xa6\xb2\xd9\x1d\x92\x4f\x86\xec\x91\x91\x48\x9a\x35\x6c\xda\x23\x63\xab\xec\x91\xe1\x68\x71\xc0\x74\xe2\x35\xc1\x39\x80\x71\xc0\x59\xe2\x35\xd1\xed\x80\x2e\x07\x6c\x73\xc0\x3a\xf2\xb4\x8c\x00\x1c\x22\x85\x92\xaf\x85\xe8\x46\x71\x96\xb8\x62\xb4\x64\x5c\x2b\x42\xb2\x37\x45\x87\x03\x5a\x15\x1b\xe5\x21\xe2\x4d\x71\x4c\xb1\x87\x9e\x22\x85\xe3\x4a\xf2\x59\xc7\x48\xd7\x64\xbc\x1a\xc7\xf1\x9c\xc8\xf6\x9b\xd0\xcb\x7e\x13\x5e\x88\x7b\xa5\x5f\x8c\x77\xd6\x5f\x3e\x6e\x12\x5e\x5c\x0d\xc7\x1e\x3a\xfd\x51\xcb\x9f\xdf\xd9\x07\x4b\x96\xda\xa8\x95\x43\x5d\xe9\xde\xdb\x4e\x7d\x6f\xe8\x7e\x6a\x0b\xe9\x41\x91\xde\x45\xc9\xec\x53\xdc\x87\x5e\x74\x8a\xff\x9e\x5a\x6f\x31\x1a\x54\x1e\xab\xcd\xcd\x78\xbd\x6e\x3b\x6d\x55\x99\x35\x46\x7d\x8e\xcf\xef\xe7\xaf\x6d\x6b\x64\xfc\x36\x3f\x15\xf5\x57\xfa\xa7\xfb\xdb\xfc\xdb\xfc\x87\xfc\xc7\xfd\xa7\xfc\x67\xfc\x3a\xb1\x3c\x8a\x0b\xc5\xa2\x3e\x5c\x78\xc6\x7f\xd6\x9f\x53\xc3\xe0\x32\x11\xac\x0b\x97\xaa\xa3\x04\x5a\x7c\xa0\xf2\x8b\x3a\xa0\x3f\xdc\x28\x5e\xf9\x22\xd6\xd9\xc8\xfb\x81\x42\xfe\x32\x3f\xa5\xa3\xdd\x36\x8b\x91\xc5\xab\x87\xca\xe0\xb1\x32\x3a\x07\xcb\x7a\xd5\x8c\x5e\x87\x79\x36\xa5\xb3\x8f\xeb\x49\x01\xe4\x54\x51\x71\xb1\xa4\x0b\x16\x67\x85\xb5\x94\x2c\xe9\xe2\x52\xa2\x07\xa5\xa7\x85\x57\x26\x33\xfa\x53\x61\xee\x6d\xef\x09\x5b\x84\x27\x56\x41\x95\x30\xb8\x1a\x8e\xdc\xf6\xcc\xc9\x2d\xd0\xbc\x52\xf8\x16\xaa\x4a\xb0\x32\x08\x57\x08\x4f\xd9\x4b\x4a\x38\x78\x00\xf6\x8a\x9d\x27\x7c\x05\x9c\xd8\x71\xc2\x11\xe1\x22\xb1\xef\xdc\x42\x03\xfd\x2d\xee\x3b\x1f\x7c\x24\xea\x51\x56\x97\xc1\x15\x70\x53\x16\x30\x32\x16\xbd\xdf\x65\x35\x1b\x4c\x98\x51\xdb\x4d\x2c\xd2\xcc\x49\xd2\xc8\x87\x85\xdc\x25\x01\x98\x8b\x45\xda\x00\x7c\x45\xc4\xe0\x53\x01\x78\x2d\x00\xcf\x06\x60\x17\x11\x81\x25\xc3\x7a\x7d\x00\x2a\x88\x08\x8c\x25\x64\x75\x00\x96\x7e\x13\x80\xdf\x05\xe0\xe5\x00\x1c\x0d\x00\x96\x9e\xef\x0e\xc0\x36\x02\xbd\x84\x08\xcc\x0d\x04\x3a\x12\x00\x0b\x11\x98\xcf\x06\xe0\x13\x02\x8f\x25\xec\xbe\x00\x1c\x96\xe1\xd7\x06\x60\x71\x00\x9a\x65\x01\x3b\x16\x00\x87\x0c\x9f\x69\x47\x5f\x36\xfe\x51\xf0\x52\x6b\x26\x7d\x43\xa0\x33\xad\xe9\x92\xb1\xf3\x57\x2b\xdb\x13\x25\xed\x11\xf7\x08\x06\xe5\xe8\x0b\x52\x83\xba\x64\xec\x6d\xe4\x5b\x25\xec\x67\x09\x00\x25\x89\xf5\x19\x71\x7f\x76\x00\xd8\xc0\xc8\x46\x63\x6a\x94\xc3\x51\xea\x7f\xc9\x7f\xbe\xdb\x7a\x2a\x1e\x43\x52\x78\xd4\x11\xf9\x24\xae\xd8\x67\x96\x0d\x2d\x53\xa1\x3a\x8b\x92\xc0\x44\xfd\x72\xd6\xcc\xd2\x70\xb0\xba\x72\xde\xe5\xd5\xc2\xbe\x56\xe8\xeb\x12\xbe\xb9\x07\x16\x2d\x16\xf6\x4e\x6b\x5d\x27\x34\x58\xde\x68\x75\x5e\xbc\xe1\x01\xba\x9d\xcc\xc0\xd5\xd4\x3d\x22\x11\x5d\x58\xf0\x70\x67\x93\x24\xb7\x54\xe3\x39\xd8\x82\xe9\xc8\x8a\x1e\xe5\xdb\x29\xbd\x01\x40\xab\xb7\x30\x76\x9b\x9e\xca\xc1\x8b\x8e\x26\x87\x05\x03\xc2\x94\x64\x41\xf6\x3d\x76\x90\x7c\xd4\x91\x1d\x4e\xda\xa1\xd7\x0e\xa7\xed\xd0\x69\x87\x76\x3b\x24\xe4\xf2\x8b\xf7\x90\xcb\x00\x79\xdc\x49\x7e\x0f\x92\xdb\x7e\x72\xdb\x21\x43\xcf\x26\x8f\xb4\x8b\x46\xe9\x00\x19\xa3\x94\xc4\x84\x2a\xc6\xf7\x37\x89\x57\x81\x14\xa4\xa9\x4a\xf2\x38\x11\x8f\x40\x56\x53\xcc\x07\x93\x96\xda\x82\xa5\xd4\xb3\x43\x17\xc0\x5a\x73\xbb\x27\x5e\xea\x2e\xa1\x4b\xad\xdc\xce\x73\xe5\x17\xde\xf1\xda\x5e\x15\x7e\x46\xbe\xf7\x05\xe1\x0b\xda\xaf\xba\x0b\x45\x50\x13\x9f\xcf\x45\xec\x7e\x4d\x8e\xcb\xcf\xd0\x11\x3a\x9a\xeb\xd2\x6a\xb4\x9a\xaf\x93\x5a\x2d\x1b\x8e\x84\xbf\x4e\x46\x58\xee\xeb\x24\x8b\xda\xa3\x20\xed\x20\x95\x2a\xc3\xd1\x8c\x8a\xba\x24\x8a\x36\x95\x58\x32\x9b\x88\x2f\x13\x6b\xb1\x2c\x89\x85\x31\x31\x7a\x94\x3d\x00\xf8\xea\xc0\x25\xd4\x7d\xb7\xef\x5c\x76\xc3\xbb\x77\x6c\xdd\x39\x75\xc1\x15\x4b\xe7\x25\xaf\xbf\x62\xc1\x54\xe1\x8b\x7d\x77\x42\xfe\xfa\xf5\x4c\x09\xf3\x17\x88\xdd\xf5\x40\xe9\xaa\xe5\xc2\xb3\xa9\x5d\x56\xda\xbe\xf3\x5a\xe1\xe8\xf2\x55\xa2\xef\xc8\x3e\xa1\x01\x44\xfb\x18\x0d\x1d\xfc\x30\x8d\x48\x00\x39\xe4\x53\x86\x8d\x8c\xa9\xe0\x1b\x12\x3c\xf2\x77\x24\xa8\xe4\x8e\x31\x71\x25\xa5\x40\x73\x94\x0a\x96\x7d\xa5\x82\x3f\xab\x20\xcb\xe7\xa3\x53\x76\x3e\x69\x93\xfd\x42\x2a\x65\xd7\x10\xa4\x08\x2a\x99\x81\xef\x52\xb8\x89\xb4\x64\x87\x95\x44\x8a\x50\x76\xc7\x09\xfc\xa1\x31\xa1\xeb\x38\xe2\xdc\x52\x73\x96\xe0\x95\xe0\x24\x74\x6d\x0a\xf7\x97\xa8\x22\x7a\xa5\x32\xfc\x9d\xb8\xbc\x65\x37\x1d\xe3\x0d\xaa\x20\x4b\x01\x1f\x2f\x74\xe1\xff\xd1\xb4\x4c\x8d\x0b\x9e\x76\x63\x91\x5c\x7c\xe2\xe6\x7d\x4b\x84\x06\xcd\x65\xdf\x3e\x3f\x8a\x96\x2e\xe3\xa3\x3a\x97\x97\x0e\x06\x8d\x2a\xbc\xa8\xa9\x72\xa3\x39\x1e\xaf\xc7\xfb\x75\xd2\xe3\x01\xab\xd5\xf2\x75\xd2\x2a\x39\xb5\x64\x1c\x48\x46\xd1\x11\xd1\x9d\x9c\xc4\x9f\x84\xd8\x52\xc5\x68\xbf\x17\x81\x48\x52\xc5\x50\x45\x6c\x03\x36\x27\x16\x95\x45\x92\xca\x7d\x01\xd3\xcf\x92\xf9\xf3\x96\x62\xfa\xf9\xfe\x1d\x77\xbc\xbb\x72\xc5\xce\xdb\x84\x2f\x30\xe5\xc0\xac\x6b\x77\xe2\x55\xf3\x07\x8b\xa0\x09\x53\xce\x03\x77\x09\x7f\xf8\x0b\xa6\xab\x75\x1b\x84\xf7\x76\x3f\x88\xc4\xb8\xc4\xdf\x30\x6e\x7a\x16\x72\xa3\x4a\xde\xa7\x73\x78\xbc\xc8\xf2\x38\x6e\x90\xb6\x55\x4b\x69\x69\x2d\x6f\x37\x18\x54\x8f\x27\x0d\x65\x5e\x4c\xec\xb8\x91\x9c\xeb\xb8\xe7\x8f\x98\x05\x1d\x97\x23\x04\x42\x84\x04\xaf\x52\x6b\x72\x25\x13\x90\xb4\x63\x1a\x37\x51\xb4\x61\xf9\xee\xa6\x6b\x63\x57\xcc\x32\x7e\xcf\xb2\x7d\xc3\xa4\x8d\x33\xe6\x5e\x99\x7b\xe9\x2c\xeb\xf5\x66\x7e\x39\x7c\x73\x73\x5d\xcd\xaa\x6d\x2f\xfe\x78\x72\x5d\x63\xf9\xb2\x5d\x77\xfc\x60\xe6\xf0\x30\x4a\xff\xc7\xa9\x11\x4d\x74\xf4\xf7\x85\x25\xf0\x26\x89\xaf\xc3\x82\x8d\x7f\x45\x6d\x30\x20\xa3\x91\x33\xf3\x86\x4e\xc3\x80\x81\xc6\xac\xc7\xd0\x6d\x18\x34\x30\x66\xda\x60\xd2\x49\xf1\xd0\xb9\xff\x57\xc7\x43\xff\xad\xb8\x43\xbd\x46\xb1\x4d\x41\x62\x3c\x49\x21\xd2\x62\xd6\x5c\x6b\xfc\x7d\x65\x3c\x74\xba\x31\x1d\x71\xf1\xfc\x1c\xfa\x79\x29\x1e\x3a\xe6\xe7\x9b\x55\x53\x90\x07\xeb\xf4\x34\xdf\xe3\x35\xeb\xdc\xea\x80\x9b\xf6\x78\x68\x9b\xcd\x40\x1b\xc2\x91\x20\xa7\xe3\x12\x49\xa3\x51\xad\x0b\x98\x5d\xa2\x0a\xe7\xd2\xe1\xff\xb5\x6e\xbb\x96\xee\x20\x67\x89\x13\xf2\x71\x62\x14\x81\x93\x11\xf1\x84\x72\x77\x04\x3a\xb2\xcb\x71\x61\xaf\x5c\x8e\x0b\xcb\xe4\xf2\xda\x4c\x85\x0c\xb4\x12\x45\xa6\xfe\xc0\x98\x72\x14\x19\x67\x17\xe7\x3b\x37\x93\xf1\xac\x24\x31\xc6\xa5\xd3\x5d\x66\x51\x3e\x55\x6a\x64\x16\x89\x35\x8b\x51\xc2\xf2\x48\x5c\xb0\x4c\xf0\xec\x58\xbe\x59\x52\x3b\x35\xf6\x5c\x1a\xab\xcb\x66\x35\xe5\x3a\xf1\xeb\xb7\x5f\x6b\xde\xb9\xb1\xba\xb8\x7e\xbe\xf3\xee\x95\xb9\x3f\x6c\x6b\xfe\xf8\x86\x8d\x1f\xbf\x60\xfc\xf6\x6f\x1f\x0c\xe9\x7b\x8e\xa8\x5d\xc2\xb9\x87\xa3\x39\x17\x3e\x0c\x5f\xec\x2b\xd6\xbc\x40\xf5\x1c\x7d\xc6\x45\xdb\xfd\x78\x4e\x89\xc9\xd4\x5e\x52\xcd\x44\x79\xe8\x61\x7e\xb5\x9e\x0a\xf9\x23\x5e\xaf\x29\xa2\x46\xf6\x80\x5a\x67\x30\x51\xda\x58\x3e\x9f\xdf\x9a\xdf\x91\x4f\x87\xd2\x3f\xba\xf3\x7b\xf3\xd5\x28\x5f\xba\x65\x6a\x33\xbf\xc4\x1f\x03\xf9\x34\xca\xef\x17\x2f\x3a\x3a\x94\xa3\xcf\xb9\x31\xe9\xd7\xeb\x29\xb3\xd9\x7d\xa3\x14\x49\x4c\x47\x3b\x1c\x66\x0d\x9d\x47\x51\x79\x1b\x92\x94\x0b\xa5\xd9\x48\x56\x98\x30\xd2\x1b\x30\x76\x7f\x82\x84\xeb\x48\x0b\xa4\x24\x94\x54\x6e\x55\x5c\xde\x53\x95\x8e\x8d\x60\x06\x13\xb6\x87\xc9\x49\x18\xfa\xa5\x0b\x2f\x34\xee\x09\x3b\x0e\x6e\xbe\xe4\xad\x93\x93\x36\x6c\x9c\x96\xbb\xb0\xed\x63\x3f\x38\x84\x73\x5c\xe3\xd5\xfb\xf6\xad\xe7\x6f\xbd\xad\x74\xf1\xc4\xe6\x87\x76\x3f\xfa\x2c\xeb\x13\x84\x43\x55\xc2\x37\xbb\xf6\x37\xaf\x9a\x92\xfc\x61\x13\xa6\xbf\x56\x60\xe8\x83\x4c\x03\x96\xe9\x0b\xd1\x64\x3e\xe8\x43\xb9\x26\x64\x2a\x2a\xb6\x87\x1e\x4f\xe2\x75\x9f\x25\xeb\xbe\x8e\xb6\x6b\x78\x4d\xec\xf1\xa4\x18\x0e\x4a\x0e\xf0\xb3\x66\x4d\x96\x63\x5d\x65\x75\x7e\xb5\x53\xb4\x6d\x88\x7b\xbe\x76\x9b\xc6\xa9\xc9\x27\xfb\xc3\xf9\xd5\xb1\x6a\x9b\x1c\xb4\x31\x37\x62\x82\x4d\x89\x15\x4d\x4b\x57\xde\x71\xc7\xca\x95\x8d\xab\x9a\x9b\x57\x35\xae\xbc\x7e\xe7\xf6\x65\xcb\x1b\x57\x24\x5a\x67\x7f\x7f\xd6\x4d\x4f\x3e\x71\xf3\x15\x3b\xe7\x50\x87\x76\x5c\xbf\xa2\x89\x3c\x5e\x75\xc3\xe6\x3b\x56\x8a\x8f\x13\x2b\x1a\x97\x2f\xdb\x7e\xc5\xf7\x13\x3d\x37\xdf\xfc\xc4\xac\x1f\x88\xfc\x9c\xc2\xe3\x29\xe0\xb9\x13\x45\x3b\xf9\x22\xa7\xc5\x1d\x08\xe4\x86\x81\x36\x5a\x68\x9a\xcd\xd1\x6a\x63\x79\x4e\x77\x80\xb6\xd8\x2c\xa9\x64\xc4\x64\x36\xa5\xb0\x62\x60\xd0\xa5\x92\x51\x12\xe3\x37\x20\xc6\xf8\xe5\x83\xc6\x5c\xb5\xcb\x66\xe6\x75\xc6\x46\xb3\x59\xed\xb5\xd1\xd2\x29\x45\xb5\x65\x64\x33\xa9\xa6\xb4\xd8\x52\x83\xc7\x23\xee\xf9\x4d\x71\x85\x14\x9e\x87\xfc\x75\xca\x41\x6c\x09\xe1\x8e\xf8\xa6\x84\xed\x44\x7f\xa8\x0a\xe3\xff\xf3\xc3\x55\xf1\x6c\xe9\x2f\x6e\x0f\x6b\xec\xf4\x7a\xe1\x33\xf1\xa8\xb4\xf0\x19\x38\x59\xe1\xdb\x4f\x84\x7f\xb5\xc1\xab\x5b\xbf\xfc\x66\x13\x24\x96\x0a\xff\xfc\x8b\xf0\xb5\x01\x76\x35\x7f\x2a\x7a\x3a\x7f\xda\xbc\x25\xb7\x99\x5a\xad\x74\x76\x1e\xda\xdb\xec\xdf\x89\xbf\x3c\x23\x67\x20\x0d\x7c\x1f\x4b\x1a\x1a\x0d\x62\x18\x9d\x56\x85\x54\x08\x18\x1f\xa0\x75\x72\xae\x83\xe9\x24\xa7\x81\x94\xeb\x40\x4a\x74\xb0\x8d\xe4\x4b\xc8\x3c\x95\x12\x25\x2c\x3d\x4b\x52\x21\x48\x0e\x9c\xdd\x63\xe0\xa4\x9c\x0a\x92\xf3\xe6\xa0\x0e\x06\x88\x3b\xa6\x04\x3c\x0a\x69\x42\x37\x92\x83\x81\x23\xa8\x33\x79\x16\x8e\x93\x7c\x0a\xad\xd9\x30\xd2\xeb\x27\x65\x80\x3a\x89\x83\xe7\xa8\xe6\xf7\xca\x4e\xa4\x54\x47\x36\x8e\x2f\xa5\x86\xf0\x2e\x19\x26\x93\xa9\x41\xf2\x29\xd5\x8e\xf6\x34\xcc\x16\x38\x16\xfd\x9f\x8b\x1b\x63\xb6\x6c\x32\x3c\x4d\xc1\xfb\x31\x15\xd0\x44\xea\x58\xb2\x84\x0e\x8b\x9a\xf4\xf9\x3c\xea\x86\xa1\xbb\x49\x4c\x3e\x44\x2f\x55\xad\x42\x93\x51\x23\x7a\x90\x4f\x35\x54\xd7\xa3\xfa\x09\x01\xc4\xb2\x75\xde\x00\xe3\xaa\xad\xcd\x55\xab\x5d\x95\xae\xca\xcb\x9b\x26\xd4\x35\xb0\x0c\x1d\x0e\x17\x26\x92\xd1\x68\x47\x18\xd8\x70\x69\xb8\x2e\x8c\x99\x4c\x98\xc6\x72\x3d\x4f\xa2\xaa\x0e\x34\x41\xa8\x09\x50\x13\xf0\xe4\x47\x6f\x13\x74\x37\x41\x67\x13\x74\x34\x41\x19\x29\x51\xc8\xe5\xa8\x34\x5e\x2a\x9e\xff\x15\xd9\xce\xc2\x78\x69\x3a\xf4\x7b\x3a\xc4\x94\xa5\x46\x0e\xb2\x1a\xaf\x10\xb9\x8e\x1c\x7e\x4f\x3e\xea\x2e\x1f\x57\x93\xa3\x35\xca\x41\x31\xc5\x53\x6b\xe0\x0c\x50\x24\x02\x0e\x45\x57\x5e\x04\xf9\x26\xe2\x97\xe5\x9c\x0a\x74\xd3\x0b\x4f\xce\x7e\x26\xaf\x24\x3f\x70\xdb\xc5\x8b\x57\x94\x34\xa5\x16\xa7\x9a\x4a\xb6\x2d\x5b\xb9\xf8\xa7\x9d\x37\xee\x29\x0d\xbb\x16\xd6\x36\xb7\x94\x5d\xb9\x63\x55\xdb\xa4\xef\xdf\x72\xcd\xbc\xb2\x4d\x45\x89\x05\x57\xdd\x10\xad\x5f\x75\xcd\x32\xff\x0f\xee\x09\x9b\xfe\xb2\xcd\x97\x7f\xd5\x9c\x8a\x99\x17\x57\x56\xd5\x5e\x71\x5d\x7d\xeb\x6e\x7b\xf5\xee\xf9\xb7\xee\x71\xbf\xbd\xca\xee\x49\x4c\x2f\x6b\x98\x34\xb5\xa2\x79\x69\xfd\xf2\x7b\x3d\x55\x57\x2f\x87\x33\xc5\xf5\x93\x0b\x99\xd6\x86\x8b\xa6\x4d\xbc\x58\xdf\x26\xae\xa7\x75\xcc\xa5\xd4\x72\x95\x49\x8c\x7d\x08\x7f\xe4\x87\x0d\x16\xa4\xb6\xa8\xdd\x2e\x9d\x9d\xb5\xdf\x93\xa4\xb5\xac\x8b\x2d\x60\x1b\xd9\xa5\xac\x4a\xcb\xde\xe2\x86\xe5\x6e\x98\xef\x86\x19\x6e\xa8\x75\x43\xb1\x1b\x7c\x6e\xc8\x71\xc3\xbf\xdc\xf0\xdf\x6e\xf8\x83\x1b\x7e\xed\x86\x17\xdd\xf0\x98\x1b\x1e\x74\xc3\x9d\x6e\x40\x9b\xdc\xb0\xc2\x0d\x0b\xdd\x70\x85\x1b\xa6\xb8\xa1\xd4\x0d\x7e\x37\x18\xdd\xb0\x74\xd8\x0d\x7f\x75\xc3\x7b\x6e\x78\x43\xae\xf1\x63\x37\xdc\xe5\x86\xdb\xdc\xb0\xda\x0d\x0b\x14\x6f\xf0\x92\x0a\x43\x6e\xf8\x9b\x1b\x4e\xcb\xf0\x8f\x2b\xe0\x57\xc9\xf0\x6e\x37\xe8\x48\x5b\xa4\xc0\x2c\xc7\xdd\xf0\xac\x1b\x0e\xbb\xe1\x6e\x12\x86\x65\xad\x1b\x16\xcb\x41\x5a\x2a\xdd\x10\x73\x83\xc3\x0d\x6a\x37\x4c\xc2\xa0\xaf\xc9\xa0\xf7\xb9\xf9\x79\xb0\x83\xc4\x6c\x59\x22\x03\x4f\x24\xc0\x16\x37\xa4\xa3\x36\x0e\xc8\xd8\x7b\x15\x41\x5e\x12\x6e\xa0\x32\xf1\x5d\x30\xd0\x31\x37\x3c\x49\xa2\x3b\xe2\x4f\x0e\xba\x81\x75\x67\xf9\xf4\xa6\xbe\x4b\xd1\xfe\x1f\xf4\xec\xb5\xdf\xa5\x66\x8f\x89\x5c\x2e\xba\x03\x67\x9b\x70\xb3\x5d\x1b\x54\x8a\xdf\xd4\xf2\x49\x45\x45\x93\x27\x17\x15\x4d\x12\x1e\x9a\x54\x54\x78\xf1\xd4\xfc\xa2\x49\xcc\x91\xa2\x5a\x7c\x15\x4b\x6b\x2f\x2e\xc4\x57\x29\x8e\xd5\x3c\xd1\x26\xa8\x6a\x46\xa2\xeb\xf4\x24\xb4\x8a\x9f\x52\x58\x5d\x96\x5b\x9d\x8b\x5c\x2e\x2d\x87\xb4\x68\x72\x4d\x55\x28\x54\xf1\x7a\x32\x56\xf2\x7a\xb2\x28\xc6\x86\x82\xa1\xd2\x10\xad\x45\x31\x2e\x86\x17\xf7\x50\x2c\x14\x33\x30\x06\xdb\xaf\x92\x06\x2b\xe3\xfb\x55\x92\x61\x46\xb9\x4e\x91\x80\x6e\xe6\x78\x71\xb6\xe5\xd9\x32\xb2\x60\x5a\xa2\xf1\x0a\x46\x0c\x69\x4f\x82\xba\x55\x93\x30\x6d\x51\x4b\x55\x25\x15\xcd\x8d\x30\x14\xa4\xbf\x27\x08\xe9\xbd\x02\x2e\x5c\x81\x15\x67\x8d\x7a\xde\x8b\x30\xe5\x85\x17\x81\x7f\xfe\x19\xe1\xd8\x2f\x5e\x10\xfa\x9f\x6b\x78\x04\x82\x87\x1f\x81\xd0\xa3\x47\x84\x3f\x3f\xf2\x88\x30\xf0\x30\x75\xdb\x2b\x1f\xbc\x7d\xe2\xc6\x1f\x31\xe5\xd6\xe6\x0d\xf7\x74\x80\xf1\xae\x26\x47\x39\x73\x2b\xb5\xff\xe7\x30\xed\xd9\xe7\x84\x97\x7e\xfe\xbc\xf0\xca\xcf\x9e\x03\xfe\x85\x47\x84\xd3\x0f\x3f\x8c\x2b\x3e\x0a\x91\x43\xf8\xf7\xd0\x2f\xde\x79\xe9\xad\x53\x81\x17\x97\xc5\x8f\xfc\x4c\xf8\x8f\x8b\x37\xfe\x32\x1f\xcf\xa7\x5c\x5a\x4d\x95\xe3\x3e\xf2\xa2\x18\xd4\xf2\xe5\x61\xb7\xc9\xa2\x8d\xc5\x18\x13\x93\x5f\x60\xf6\x9d\x49\x9a\x79\xab\xa3\xd1\xec\x36\xbb\xf5\x48\x1f\x3d\x93\xd4\x30\xf8\xaf\x06\xe9\x21\xa4\xef\xd4\x53\xbd\x7a\xd0\x8b\x8b\xed\x21\x3d\xdb\x88\xcb\xb4\xb4\x1e\xf1\xc8\x7e\x26\x89\x98\x15\x05\x30\xa3\x00\xf4\x24\x6a\xd7\xf1\x02\xe8\x2b\x80\x43\x05\xb0\xae\x00\xda\x0a\x60\x7a\x01\x54\x16\x40\xb4\x00\x98\x02\x58\x76\x56\x71\x6f\x23\x45\x67\x0a\xe0\x14\xa9\x1c\x2a\x00\x8a\x23\xc1\xbf\x06\x49\xfc\xaf\xfe\x02\xe8\x25\xb7\x35\xfd\x24\x12\x98\x14\x5b\x8c\x93\xa3\x8a\x49\x41\xc6\x42\xa4\x44\xaa\x23\x55\xd8\x5c\x00\x75\x05\x50\x5a\x00\x63\x85\x59\xd9\xd2\x9a\x1a\x47\xbc\x4d\x27\x51\xc8\x48\x43\xc5\x58\x7c\x13\x33\xa2\xc8\xa3\x5f\x9c\xb5\xcb\x36\xe2\x2d\x9e\x2b\x27\xcf\x98\x28\xba\x8b\xa7\xbd\xc5\xad\x26\x9a\x6c\x95\x56\x83\xfb\x86\xef\x5d\xfa\x84\x21\xb4\xbc\xea\xf2\x99\x37\xee\x6a\xb9\x76\x6a\x99\xbd\xb8\xf9\xe7\x37\x97\x06\xb9\xa2\x09\x93\x2f\x53\x35\x27\xaf\x14\xba\xd9\xbc\xa9\xa1\xa2\xab\xae\x6c\xbe\x9a\xa6\x12\xab\xfd\xb5\xb7\xd8\x85\x77\xe8\x1c\x57\x71\xde\xc4\xa2\x7c\x91\xff\xad\x47\x4d\xf4\x13\x74\x0b\x52\x23\x23\xbc\xcd\x0f\xeb\x72\xf4\xb4\x91\xa2\x19\x5a\x6d\x54\xb3\x26\x83\x0a\x54\x7f\x5b\xa0\x85\x2f\x97\xb0\x70\x15\x0b\x97\xb2\x30\x91\x85\x18\x8b\xc5\x10\xd0\xb0\xf0\x29\x0b\xbf\x64\xe1\x3f\x59\x78\x98\x85\xfb\x58\xd8\xc1\xc2\x46\x16\x30\xe4\x5c\x16\x1a\x58\xa8\x66\x21\x9f\x80\x2d\xfb\x86\x85\x8f\x59\x38\xc5\xc2\x2b\x2c\xa0\x5e\x16\xba\x59\xb8\x9b\x85\x3b\x58\x58\xc7\x42\x1b\x0b\xcd\x2c\xd4\xb3\x50\xc9\x42\x94\x05\x0b\x0b\x14\x0b\x67\x59\x38\x43\x2a\xbc\xcc\x42\x1f\x0b\x07\x59\xe8\x62\x61\x1b\x0b\x1b\x08\xfa\x04\x0b\x3c\x0b\x15\x2c\xe0\xce\xb0\xb1\xc0\xc8\xf0\xff\x25\xc3\x1f\x22\xcd\xc9\xe0\x9f\xab\xc0\xef\x60\x41\xcd\x42\x0d\x06\x3d\x4e\x40\x0f\x13\xd4\x3b\x08\x28\x46\xdd\xc2\x27\x48\xdb\x27\x12\xcc\x18\xf2\x1b\x19\x33\xf4\xb3\xd0\x4b\x50\x63\xf8\x15\x18\x92\x85\xe9\x2c\x94\x11\xa4\x36\xd2\x82\xc7\xe4\x56\x62\x54\xc5\x2c\x78\x59\x92\x39\x89\x4a\x8d\xd1\x70\xc6\x18\x31\xfe\x2f\x0d\x8c\xa9\xef\x34\x7c\x20\xe5\xbe\x95\x33\x6d\x71\x80\x38\x6d\xcd\x85\x3c\xe9\xb2\x1e\x66\xcd\xf9\xe8\xa3\x39\xc2\x51\xf8\x11\xcc\x9e\x73\xe6\xcc\x1c\xe1\x29\x18\x84\x36\x61\x93\xb0\x49\xf4\x2a\x4d\xff\xc8\xe4\x65\xa0\xde\xc7\xe2\x61\x88\xe7\x28\x60\x40\xad\x11\x73\x32\xf0\x14\x50\x62\x5a\x86\xdf\x64\xbc\xac\xe5\x98\xe4\x4c\xf0\xfa\x0b\x4f\x50\xef\x0f\x0d\xc2\x91\x25\xc3\xc3\x72\x5e\x04\x4e\x8d\x38\x24\xba\x80\x29\x79\x67\x15\x9a\x8a\x7e\xcd\x6f\xaa\x2a\x2b\x0b\x4f\x2c\xa9\x2c\x2f\x2f\x71\xd5\x86\xc3\xb1\x98\xcc\x47\xf9\xba\xf2\x58\x38\x1a\x7e\x3d\x59\x19\x2d\x0b\xd5\x86\x5e\x4f\xe6\x4f\x2e\x9c\xfc\x7a\x12\x45\xb9\x28\x15\x8a\x76\x44\x3b\xa3\xdd\xd1\xc1\xa8\xaa\x9b\x84\x4e\xd5\xa2\x42\xae\x10\xf3\xd7\x68\x6d\x61\x61\x6d\x94\xce\x66\xb1\x27\x79\xe0\x79\x28\xe3\x01\xe1\x1f\x03\x3c\xe0\xfb\x6e\x1e\x5a\x79\xd1\x89\x7c\x0d\xc9\x8d\x82\x14\xf9\x6d\xf0\x34\x94\xb8\x30\x31\xf7\xa3\xb4\xea\x39\x2a\x32\x87\x45\xca\x7c\x93\x4e\x80\x53\xf3\x7f\xc2\x9a\x55\xa3\x63\x11\x58\xf1\xbc\xa6\xab\xe5\x58\x04\xff\x33\x83\x06\x61\xad\x70\xb8\x75\x29\x34\x3d\x74\x60\xfe\xbc\x77\x5a\xde\xfc\xf8\x89\xb9\x37\xd6\x5d\xb2\x7c\xc1\xff\xc8\xa1\xdf\x16\x4e\x9b\x31\x67\xa1\x7a\xb9\xc2\x1b\x97\x5f\xd1\xee\x13\xde\x34\x17\xc3\xc2\xcf\x92\x97\x0b\x7d\x4d\x08\x86\xbf\x54\xf5\x30\x16\x75\x0e\x5e\xd9\xdc\xbc\x01\x89\x67\x89\xa8\x17\x92\x98\xd6\x01\x89\x71\xf5\xa5\xf3\x44\x80\x15\x13\xc6\x72\xfe\x03\x26\x57\xd5\xb3\x08\xf3\x8b\xc5\xd4\xc7\xd4\x09\x3c\x8e\x26\xe4\x41\x1f\xf1\x07\x58\x64\xd7\x22\xad\xd7\x67\xb0\x3c\x9e\xdc\x63\x38\x60\x38\x66\x38\x61\x60\x36\x1b\xf6\x18\x28\x64\xc0\x0c\xdc\xc0\xf0\x8c\xeb\x71\x3c\x12\x58\xc5\x38\xeb\x83\x01\x1f\x9c\xf2\xc1\x71\x1f\xf4\xf9\xe0\x90\x0f\xba\x7c\xb0\xcd\x07\xeb\x7c\x30\x9d\x94\x74\xfb\x80\xea\xf4\x41\x87\x0f\xda\x7d\xd0\xea\x83\x84\x0f\x78\x1f\x94\x91\x08\x18\x7c\xbf\x0f\x7a\x09\x88\x12\xa2\x4c\x2e\x1c\x5b\x27\xe4\x83\x41\x1f\xfc\x9b\xb3\x6d\x59\x36\x7f\x65\xb6\xba\x85\xa3\x14\x55\xd1\x20\x26\x46\x6d\x24\x8c\xb8\x9a\x78\x3a\x48\x3e\xc9\x8b\x9b\xf7\x5e\x79\x65\x67\xcb\x55\x9d\xcd\x77\xf4\x2d\xd9\x74\xd5\xbc\x9b\x6f\x9e\x77\xd5\x26\xc6\x8b\x8b\xf0\x9f\x96\xbd\x73\xfa\xee\x48\xde\x7c\xcb\xbc\xe4\x2d\x37\x8b\x7c\xf6\x2a\x3c\x09\x4c\x24\xcf\x09\x8b\xca\x79\xb7\x41\x07\x6a\x60\x69\x8a\x32\x73\x26\xc3\xe3\x49\x13\xa2\xd5\xf4\xe3\x49\x9d\x5a\xce\x78\x92\x8e\x34\x22\x99\x39\xb2\xb3\x9e\x98\x31\x31\x51\x6d\x72\xe6\x93\x0b\x97\x29\x73\x9f\x0c\xfd\x7d\x49\x3a\xff\xc9\x74\xca\x49\x55\xab\x1a\x90\x0b\x4d\xe5\x03\x4e\x23\xb8\x34\x56\xb0\xba\x3d\x1a\x27\x47\x42\x1c\x9f\x49\x72\x7f\xa2\x9c\xe0\xfc\x38\x09\x1f\x64\x27\x8c\x18\x9d\x2d\x02\x13\x40\xb5\x94\xa3\x49\x8a\xc3\x4b\x48\x98\x85\x30\x55\x2d\x18\x6f\x68\x5b\x90\xbf\x6d\x4a\x95\xbd\xfa\x86\xc4\x8e\xbb\x16\xdc\x7c\x00\xb6\x52\xce\xd6\xb6\x05\x6b\x36\xcd\xd9\x13\x5e\xdc\xe3\x5d\xdd\x76\xed\x03\xcb\x7e\x98\x8e\x6b\x40\xe5\x50\x75\xb8\x3d\x05\xe8\x0b\xfe\xc7\xce\x7c\x4b\x34\x60\x11\x13\x44\xa0\xa8\x9a\x2e\x2c\xca\x17\x53\x44\x9c\x49\xce\xb6\xa6\xac\xab\xad\xb4\xc1\xea\xb3\xe2\x19\x6d\xb5\x86\x69\xbf\x3f\x1c\xf6\x9c\x49\x86\xff\x44\xeb\xcf\x24\x19\x31\xce\xb4\x86\x3e\x7d\xa6\x08\x8e\x17\x41\x5f\x11\x1c\x2a\x82\xae\x22\xd8\x56\x04\x4c\x11\x9c\x22\xb7\xf8\xf7\xba\x22\x68\x2b\x82\xe9\x45\x50\x49\xca\xeb\x47\x81\x4a\xbf\xdb\x8b\x80\xca\xb8\x68\x70\x45\x80\x8a\x60\xa0\x08\x4e\x16\x41\xf7\x88\xa3\x46\x6a\xcd\xe8\x93\x26\x23\x6c\xb6\x74\x91\x22\x15\x85\x59\x3a\xf6\x95\x49\x45\x91\x89\xa0\x6a\xa9\x91\xe5\xce\x52\x18\x37\x13\x85\xa2\x47\x35\x0e\xaa\xee\xc8\x5d\xcb\x6e\x50\x57\x7b\x1d\x8d\x79\xad\x89\xc6\xf9\x73\xe7\x4e\xaf\xa9\x4d\xf0\xe5\xb6\xea\xd5\x57\x6c\xbb\x7f\xf1\x82\x0f\xa9\xaf\x96\xdf\xee\x7d\xa1\xdd\x68\xbb\xfc\xda\x59\x33\x54\xea\x69\x0c\x7d\xe9\xac\x2b\xa6\xfa\x97\xf4\x78\xaf\x6f\x9d\xb1\xdc\xe4\x26\xfd\xfc\x10\x93\xa2\xaa\xc4\xf3\x7e\x70\x0f\x3f\x4c\xd1\x2a\x1a\x21\xe9\xbc\x9f\x0e\xb9\x51\xa1\x78\xde\x6f\x89\x06\xe6\x6a\x60\xa2\x06\x62\x1a\xc0\x5d\x7a\x56\x03\x9f\x68\xe0\x77\x1a\x78\x4d\x03\x87\x35\x70\x9f\x06\x36\x68\x00\xc3\x34\x10\x18\xb5\x06\x96\x9e\xd1\xc0\x29\xf2\xf8\x59\x02\xb1\x81\xd4\xc7\x8f\x1d\xa4\xb0\x4f\xae\xb6\x43\x81\xf7\x1b\x0d\x48\xb5\x8e\x93\x5a\x87\x34\x70\xb7\x06\xee\xd0\xc0\x5a\x0d\x2c\xd6\x40\xd6\xf9\xc1\xf4\x39\xc1\xb3\xa4\x86\x74\x1e\x50\x3a\x33\xd8\xa5\x81\x6d\xd9\x27\x12\x2b\x35\x10\xcd\x3e\x94\x28\xbd\xa1\x8f\xbc\x41\x82\x6f\xd1\xc0\x74\x19\x35\x9f\x4b\x65\x80\x47\x1d\x50\x1c\x7b\xd8\x70\xf4\x71\x88\xef\x52\x37\x52\x63\x57\xe9\x7f\xa3\xf3\x97\x66\xfb\xa4\x5b\xab\xac\x71\x3b\x3c\x74\xfc\x1d\x61\x3f\x93\x0a\x03\x97\x27\x9c\x95\x72\x5b\x31\x49\xba\x07\xaf\x8c\xdb\xf9\xd9\x41\xe4\x74\xfa\x34\x5a\x95\xd9\xac\x35\xf8\x0c\xe1\x50\xd0\x97\x48\x06\xed\x2e\xa3\xe8\xf9\xe4\xe1\x58\x8d\x17\x39\x79\xd6\x5c\x67\xa6\x58\x55\x9d\x8a\x32\xd1\x78\x75\xa1\x6d\xb4\xad\x39\x69\xa0\x1d\xb6\x30\xf4\x85\xa1\x23\x0c\xed\x61\x68\x0d\x03\x15\x0a\x83\xd4\xde\xf4\xe1\x6e\xa7\xb8\xed\xb8\xd0\xc3\xbd\xee\xaa\x1b\x39\x9a\xa3\x38\x2c\x95\x3e\xa9\x98\x47\xa2\xd7\x71\x1a\x4c\x9c\x16\xe2\xf8\x6d\x4e\xfb\x77\xa5\xdd\x5f\xe8\xb2\x05\xb7\xd4\x6c\x9c\x12\x39\x6a\x0f\xde\x09\x15\xab\x5b\xe3\x9b\x27\xfe\x10\xe2\xbb\x84\xff\xbe\xf9\xca\xc9\xb3\x84\x81\xdf\x96\x5c\x02\x96\x8d\x74\xd8\x5d\x32\xb4\xee\xea\x65\x65\xf9\xd4\x93\x92\x33\x0c\xa1\x4f\xad\x20\xd0\x62\xac\x0b\x16\xf5\xf1\x1b\x55\x6a\x75\x0e\x05\x90\x63\xe6\x34\x78\x6e\x1b\x11\x63\x64\x6e\x4c\x1a\xd5\xea\x74\x4c\xb3\x32\x62\x7b\xef\x27\x51\xce\x3a\x88\xe1\x9e\x23\xf6\xfa\x93\xc4\x14\xdf\x49\x4a\x78\x62\xa2\x17\x4d\xfe\x03\xb2\x8d\xbe\x53\x8e\x89\x36\xdb\x0c\xa5\x66\x38\x6d\x86\x63\x66\x38\x60\x06\xd6\x0c\x5f\x9a\xa1\xce\x0c\x0a\xdf\x9f\x31\xd3\x7b\xad\x64\x02\x21\x53\xdb\x42\x52\xde\x65\xa5\xca\x10\x19\x31\xfe\xdf\x2a\x69\x5b\x61\x3b\x5d\xbc\xe8\xc8\x22\xea\xad\x2f\x06\xfe\x0b\x4e\x30\x5f\x9d\x33\xa8\xce\x9e\x33\xd0\xd5\x6f\xbf\xf8\x9f\xaf\xa4\xe3\xb9\xfc\x91\x2a\x81\xdf\xd2\x41\xd1\xbe\xc0\xe7\x90\x5c\x4b\x24\x99\x00\x2a\xcd\xa4\x5a\x52\x2a\xa6\xf0\x5b\xd1\xf2\x2f\xee\x00\x50\x87\xe5\x24\x05\x80\xf6\x08\x33\x29\x0e\x59\x90\x0d\xee\xe3\x87\x59\xb3\xca\x80\x90\xca\x61\x67\x2d\x16\xda\xcc\x6b\xb9\x46\xb3\x4e\x4d\xdf\x47\x1f\xa6\x69\x3d\xad\x0c\xb4\xd1\x4d\xe2\x71\xdc\xe1\x80\xb5\x0e\x58\x4c\xfc\x4a\xea\x65\xf7\x11\xc9\xad\xe4\x2b\x39\x30\xc7\xcb\x0e\x38\x4a\xe0\xef\x96\xe1\xdb\x64\xf8\x4c\x00\x10\xb5\x03\xa4\xe8\x21\xca\x48\x20\xf7\x11\x07\x14\x09\x7f\x33\xf1\x6c\xc1\x9f\x10\x21\xf0\x8c\xe4\xd0\x22\x55\x78\x99\x54\x38\xe8\x00\xb1\x45\xdb\x88\xcb\x4a\x2b\x79\x83\xe4\x0b\x63\x23\xcd\x39\x9b\x1d\x27\x44\xe9\x32\xa3\x88\x47\xc2\xe7\xa6\x1b\x24\xf9\xd6\x9c\x91\x5b\x83\xdb\x41\xb5\xcb\x7e\x32\x0b\xc7\xe6\x54\x1d\x35\x53\x53\xff\x0b\xc1\x7b\xad\x74\xce\x38\x2e\x5a\x78\x4b\xe3\x19\xb2\xa8\x29\x2f\x53\x49\x47\x25\x64\x0e\x9f\x5f\x1d\xd7\x04\xb0\xb6\xb9\x7b\xe5\xcc\xa9\x8e\x99\x8e\x8b\x27\x26\x1a\x0b\xe7\x5a\x16\x5c\xff\xdf\xd7\xdc\xe0\x68\xd2\xe8\x6a\x4b\xca\xa7\xaa\x7f\xd4\xac\x9b\x47\xf2\xda\xe1\x75\xda\xaf\xaa\x47\x39\x28\x9f\xb7\x90\x94\x53\x6a\x0d\xaf\xfb\x93\x18\xe0\xf2\x4c\x92\xfa\x60\x24\xa5\xd4\x48\xfc\x0b\x49\x9a\xd4\x54\x55\xc7\x61\xe3\x61\x21\xef\xe1\x9f\x7c\xd6\x48\xcd\x35\x95\x97\x9b\xa8\x35\x93\x4b\x77\x88\x79\x60\xb1\x5c\x31\x17\xcb\x68\x62\x3e\x8f\x21\x9e\xb3\xa8\xc5\xa0\xb5\x2e\x37\x8d\x55\xe9\x5e\x1a\x68\x51\xc5\xfe\xb1\xa8\x62\xd3\x58\x42\xa3\x75\xbc\x8e\x3d\x93\xd4\x31\x75\x0a\x6b\xcd\xb0\x1b\xbe\x74\xc3\x09\xd9\x90\x73\xc0\x0d\x7b\xdc\x50\x47\x1e\xad\x3c\x4d\x8a\x36\x13\x4b\xd5\x6c\xb9\x74\x98\x58\xa7\x4e\x28\xa0\x79\x19\x4c\x02\xa8\x1d\x85\xb2\x95\xfc\x4e\x91\x77\x4a\x8f\x8e\x91\x6a\xad\xc4\x8a\x94\x19\x0b\xc5\x28\x65\x0f\x48\xb6\x67\x41\x96\x62\x5d\xfc\x1d\x46\x1f\xa5\x8f\x31\x35\xb7\x6b\xd7\x96\x7b\xee\xdd\xbe\xfd\xee\x2d\x4d\xcd\x57\x34\x5c\x36\xb3\xb9\x89\x29\xd9\xbb\xef\xc1\xce\xce\x7b\x1f\xda\xb5\x65\xc5\x92\x1d\x3b\x97\xad\x92\x7c\x8c\x9b\xb1\x7e\xbc\x7b\x44\x3f\xd6\xe8\xf4\x74\x0e\xa2\x18\x9a\xa6\x73\x58\x13\xa5\x35\x68\xff\xb6\x80\x31\xfc\x7f\xfa\xf1\xff\x63\xf5\x63\x1d\xe4\x5a\xe9\x38\xa8\xa4\x0b\xbd\x5b\x38\x2a\x2a\xc8\x30\x4b\xb8\x5e\x78\x4a\x54\x90\x61\x36\x3c\x21\x3c\x04\xdb\x61\xbb\xf0\x50\xbd\xfc\x03\xeb\xb7\xf5\x98\x07\xaf\x55\xd5\x73\xf9\x9a\x21\xaa\x05\x21\x2e\x86\x36\x21\x64\xc6\xeb\x36\xed\x1c\xfa\x6f\xf4\xd6\x33\x41\x3e\x95\x6a\x0c\x8a\xfe\x68\x8b\x16\x49\xd7\x85\x0b\xc9\x95\x37\xcd\x9f\xdf\x18\xe4\x5b\x5a\xf0\x3f\x57\x5e\x99\x2e\x6a\x6e\xc6\x77\x33\x66\xe0\x7f\x1a\x1b\xa5\x22\x5d\x43\x03\xbe\xab\xab\x4b\xdf\x4d\x9e\x8c\xef\xe2\x71\x09\x53\x79\x79\xba\xf4\xa2\x8b\x70\x69\x7e\xbe\x54\x1a\x8b\x49\xd7\xbc\xbc\xf4\xd3\x48\x04\x3f\xf5\xf9\xd2\x77\x1e\x0f\xbe\xb3\x5a\xa5\x3b\x8b\xc9\x84\x17\x96\x32\xe0\xa1\x1d\xba\x81\xa1\x29\xce\x8e\xea\xaa\xaa\x60\xe1\x45\x55\xc5\xe3\xff\x87\xd2\xdf\x7c\x74\xec\x37\xa3\x75\xf4\x26\xfc\xcd\x4e\xde\x24\xa2\x6c\x87\x0e\x11\xa5\x84\x51\x44\x88\xa7\x11\xae\xdb\x84\xeb\x5e\xa5\x6a\x50\xd4\x5d\x1f\x24\xfd\x45\x9d\xc3\x75\xf3\x78\x27\xe4\xa4\x72\x00\xa5\xab\xd3\x62\xd3\x28\x9a\xba\x28\xdd\x2c\x8c\x86\x60\x12\x63\x25\xce\xa3\x73\xe9\x97\x48\x4e\x97\x1f\xf2\xc3\x0e\x5c\x06\x4e\x3f\xf8\xd5\x26\xb5\xc5\x64\x91\xf2\xba\xe0\x22\x2d\x66\x81\x1c\x0a\x49\x59\x5d\x38\x39\xab\xcb\xe5\x51\xa8\x89\x42\x61\x14\xde\x8b\xc2\xeb\x51\xd8\x15\x85\x9b\xa3\xb0\x2c\x0a\x73\x49\xa1\x3b\x0a\x3a\x7c\x8b\x1f\x3c\x1f\x85\xc3\xf2\xb3\x64\x14\x1a\xc8\x83\x7f\x45\xe1\xa7\x51\xf8\x51\x14\x76\x90\x42\x09\x57\x2c\x0a\x9f\x44\xe1\x77\x72\x62\x16\x5c\xab\x8b\x00\x6c\x88\xc2\xe2\x28\x88\x99\x55\x78\x39\x39\x0b\x8a\x62\x29\x37\x3b\x8f\x4b\xb7\x9c\xca\x65\x9d\x02\x4e\x4a\xe2\x32\x10\x85\x53\x32\x98\x04\xd0\x42\xb2\xb4\x50\x41\x39\x53\x4b\x3f\xae\xcc\x5b\x48\x0e\x98\xc4\xd8\xa4\x2d\xd9\xf2\xec\x78\x92\x6c\xea\x3b\xe5\xd8\x2c\xe6\x9a\xce\x3c\x92\x4e\xd5\xf2\x5b\x73\x4d\x56\xec\x6c\x4b\xd6\xc9\x00\xab\x26\x7d\x70\x57\x74\x02\x97\xf2\x76\xd5\x01\xad\x70\x70\x80\x77\x48\xca\x96\x95\xdb\xc4\x94\x2d\x5d\xf7\x08\xf3\x7e\xb2\x6f\xf2\xac\x4b\x2b\x2b\x2e\x13\x9d\x1c\xa8\x06\xe1\xa8\x98\xb2\xa5\xeb\x26\x31\x65\x0b\xb4\xfc\xe4\x57\x21\x23\xa5\x2e\x6f\xbc\xac\xa2\xf2\xd2\x06\x91\x86\x48\xde\x0f\xf5\x9f\x2c\x31\x14\x25\x74\x77\x09\x4c\x87\x59\xc8\xde\x47\x59\x55\x31\xea\xb9\xe1\x83\x7d\x36\x27\xa5\xcd\x83\xe2\x2a\x84\xff\x8c\x03\xbf\x01\x7e\x89\xe1\xad\xbc\x9e\x54\xb8\xdc\xea\x18\x81\x46\x23\xf0\xa7\x65\x78\xea\xfb\x70\xb3\x12\xff\x67\x7d\xd6\xf1\xf0\x1f\xcd\xc0\xef\x87\x8d\x4a\xf8\x4f\xfb\xfc\x05\xe3\xc0\x6f\xca\xb4\x67\x39\x6c\x81\x55\xc8\xfd\x2c\x4d\x39\x54\x31\x1a\xd7\x18\xec\xcb\xb3\x4a\x35\xc4\x2a\x8a\x3a\x7b\x32\xef\x78\x08\x6e\x47\xc7\x91\xeb\x19\x9a\x2a\x60\xc4\x2a\x9f\xf7\xb9\x33\x55\xf0\x54\x41\xe9\xfc\x28\xea\x67\xb1\x8c\x9d\x8b\x62\x94\x9f\x1f\x8e\xd1\x79\x8c\xc9\x69\xf3\xe5\xe5\xf8\x68\x00\x93\x93\x0e\x33\xba\xb0\xae\x20\x3f\x14\xca\xcd\xf5\xb5\x26\x73\x21\x95\xcc\xb5\x38\xbc\x36\x6f\x6b\xd2\x6d\x8b\x52\xad\xc9\xd5\xb6\xcd\x36\x6a\x8a\x0d\x1c\xb6\x98\x8d\x12\x6d\x6c\xb4\x2d\x6a\x8b\x1a\x34\x79\x56\x31\x0b\x02\x62\x41\x47\xb3\xac\xc1\x90\x93\xc2\x3a\x07\xa3\xd3\xe8\x52\x49\x8d\x65\x6e\x01\x34\x14\xc0\xc4\x02\x88\x15\x80\xa3\x00\xd4\x05\x70\x96\x18\xdf\x7f\xa7\x30\xd8\xdf\x57\x00\x3b\x0a\x60\x43\x01\x2c\x29\x80\x66\x85\xa5\x5e\x82\x5f\xfe\x4d\x01\x7c\x52\x00\xaf\x15\xc0\xd1\x02\x38\x58\x00\x23\xd9\x3e\xda\x48\x92\x8e\xe9\x24\xa5\x47\xc6\xb0\x2f\x59\xf1\x4f\xc9\x76\xf9\xee\x02\xe8\x22\x90\x52\xda\x0f\x1b\x79\x39\xd9\x2d\xe0\x6f\x14\xdf\xdd\x25\xef\x17\x24\xc6\x6c\x11\xd4\xe0\x96\xbe\x5f\x00\x8f\x15\xc0\xee\x02\x90\x76\x1a\x6a\x0b\xa0\x98\x3c\x46\x8a\x17\x1d\x27\x00\xb8\x3e\xc5\x17\x00\x5b\x00\xc3\x05\x70\xa2\x00\x8e\xc9\x5b\x07\x09\xb2\x33\x10\x24\x8f\xc6\xd3\x2a\xbf\x6b\x39\x1b\x77\x19\x1b\x1b\xf1\x4e\x01\x3b\x26\xc3\xa7\xb4\xaa\xc9\xdb\x48\x0b\x17\x2e\x94\xcd\x97\x24\x50\xaa\x64\xa3\xc8\x64\xd7\x13\x4d\x4a\x52\xbe\x20\xac\xe9\x55\x9b\xc3\xd2\xd9\x68\x18\x9b\x7c\x22\x2e\x25\x9f\xb0\x9a\x81\x7a\xff\x01\xa1\xed\xc4\x7e\xe1\x86\xef\x53\x3b\x0f\xd1\x1f\x4d\x0b\xb7\x9f\xda\x05\xee\x00\xcf\x07\x84\x4f\x9f\x05\x2a\x31\x79\x9a\xe5\x42\xf5\x03\xc2\xbd\x52\xe2\x17\x12\x3c\xf5\xb0\x65\x4c\x4e\x0a\xaa\x84\x3a\x38\xb4\x08\xd3\x74\x0b\xd6\x77\x3f\x56\xcd\xc4\x34\x1d\x23\xf3\xe0\x16\x78\x1c\xd3\xad\xfe\x59\xac\xb3\xfa\x68\x37\x99\x30\x64\x3e\x92\x5c\x1c\x64\xfe\x16\xa4\xe7\xbb\x5f\x9a\xbf\xe0\x53\xc5\x80\xf1\x87\x90\x3b\x6b\xfe\x8e\x86\xdf\x00\x93\x15\xf0\x0d\xbe\xe0\xb8\xf0\xa7\x65\x78\x3c\xdf\x95\xf8\x9d\xbe\xf1\xf1\x6f\xca\xe0\x5f\x0e\xf9\x78\xfe\x3a\x79\x23\x05\x41\x3c\xe3\x21\x78\x91\x4f\xaa\x21\xcd\x5e\x52\x67\xa2\x98\x07\x80\xb4\x69\x82\xf4\x0d\xc3\xc7\x08\x8f\x00\x03\x7e\xc5\x73\xc3\x8f\xf7\x19\x39\x1a\x14\x3c\x42\xcc\x1b\xb0\x5c\x01\xbf\x01\x55\xa5\xdb\x24\x56\xb8\xcc\xc0\x8e\x40\x13\xfc\x16\x0c\xbf\x8f\x7c\xc3\x04\xe9\x1b\xb0\x52\x31\x02\x8f\x0c\xdc\x28\xf8\x3a\x82\x7f\x53\x06\xff\x72\x0c\x2f\xf2\x20\x0a\x58\xf1\x13\x9e\x1b\x1e\xee\x0b\x18\xa4\x3a\xe9\xaf\xa0\x50\x55\x3a\x7f\x8b\x19\x05\xd1\x47\xfc\x03\x96\x1c\x3a\x68\x37\x9a\xec\x74\x8e\x87\xce\xa1\x43\x61\xbd\x2d\x68\x4b\x25\x4d\x6c\xb0\x2e\xb8\x3a\xb8\x39\xf8\x64\xf0\x74\xf0\xcb\xa0\x46\x4b\x07\x83\x66\xb5\xd9\xdf\x9a\x14\xe3\x61\x9b\x69\x2d\x66\x17\x5a\x8b\xda\xd9\x9a\x54\x5b\x7a\xc3\x10\x0c\xc3\x60\x18\x9e\x24\xd6\x8a\xba\x30\x94\x86\x81\x0b\xc3\x89\x30\x74\x87\x21\x15\x86\x32\xd1\x8f\x01\x26\x1d\x20\x0f\xbe\x0c\xc3\x31\xf2\x60\x73\x18\x66\xcb\xcf\x4e\x87\xe1\x00\xa9\xbc\x99\xc0\xe0\x12\xed\xe8\xf0\xcd\xd9\xa7\xe2\x15\xd9\xec\x47\x42\xc5\x64\x6d\x12\x3b\xe3\x72\xf2\x58\x45\x32\x99\xdc\xaa\xb8\x39\x5f\x4c\x5c\x47\xd2\xcc\x98\x49\xc2\x19\x6a\x23\x6c\xc2\x84\xfe\xac\x70\x54\xc8\xe9\xe9\x39\x7a\xb4\x87\xfa\x44\xd8\x79\xd3\xc3\xff\xfc\x8b\xf0\xae\x70\xe2\xa0\x6a\x8a\xf0\xb8\xf0\x33\xe1\x11\xe1\x49\xa6\xca\x4b\xe5\x35\x53\xf9\x9e\xaa\xa1\x1f\x34\x0f\x7d\xa6\x05\xac\xee\x40\x18\xa2\x43\x67\x32\xf4\xa4\x7a\x80\xac\x1f\xe5\xe9\xf5\xe3\x81\xf4\xd8\xd9\x44\xfa\x0e\x14\x1a\xe8\xac\xb1\x23\xf1\xbc\x09\x6d\x54\xa4\xe7\xc3\x6a\x69\xbd\x71\x92\xf5\xe6\x44\x9f\xcb\x6b\x30\x2b\x68\x69\x34\xfc\x06\x78\x37\xbd\xfe\x89\x15\xae\x71\x7a\x46\xa0\x15\xf8\x4f\xcb\xf0\x78\x3e\xec\x51\xc0\x83\xd3\x3b\x2e\xfc\xd1\x0c\xfc\x7e\xb8\x53\xd9\x9e\xe1\xbe\xf0\x84\x71\xda\xb3\x29\xd3\x9e\xe5\xb0\x3b\xbd\xfe\x79\xa4\xf5\xef\x42\x5f\xa1\x53\xaa\x91\xa6\x3d\x40\x07\xf1\xea\xf3\x11\xd3\x84\x75\xd9\x7c\xde\xca\x50\x6a\xa4\xcd\xc1\xfa\x17\x6d\x30\x96\xd2\xd0\x89\x95\x59\x92\x13\x30\x2b\x85\x80\x0e\xf2\x75\x50\xad\x03\xa7\x0e\x34\x54\xbd\xf0\xc8\x65\x30\x4f\x78\xb4\x09\xe6\xc2\xfc\xcb\x84\x47\x61\xde\x65\x54\xab\xf0\x68\x23\xcc\x87\xb9\x4d\xe2\x6d\xa3\xf0\xa8\x70\xb8\x51\xda\xdf\x6f\x19\x7e\x5d\x75\xa3\x6a\x35\x9e\x53\x1e\x14\x41\x1b\xf8\x52\xbf\x23\x60\x67\xac\x5e\xb5\x86\x31\x99\x39\xb5\xce\x8a\xbc\x3a\xa4\xcb\x8d\xb2\x7e\xd1\xcb\x4d\x8f\x0b\x03\x76\xbf\x43\xc3\x68\x29\x83\x21\x94\x4a\xb2\xa2\x64\xed\xd4\xea\x1b\xf1\xe2\x68\xa5\x5c\xa9\xa4\x8a\xc7\x37\x2a\x15\xc5\x60\xd9\x8e\x58\x8d\x8b\xa5\xbc\x9f\xc5\xd2\x7e\x93\xc8\xaa\x33\xba\xaa\xc8\x99\xf1\xdf\xf2\x32\x2b\x17\x0e\x39\xab\xe3\x1a\x07\x89\xb4\x9e\xaf\xc9\xad\x8e\x59\x6d\x4e\xc0\xba\x2b\x05\x95\xf9\x20\x52\x61\x0b\xb5\x07\xe8\x03\x9b\x6e\x3c\x72\x84\x84\x5d\x1f\xda\x77\xf3\xc6\x23\x3d\x6f\x4d\xa3\xde\x58\xf9\xe7\x4f\xdf\xa5\x6f\xe3\x87\x26\x2d\x3f\xfd\xf1\x1f\xa8\x6e\xaa\x67\x4d\xd7\x9b\x47\x31\xcc\x11\xe1\xe0\x0d\x7b\xdf\xec\x85\xf9\x43\x7b\xe9\x6b\x77\x89\x51\xd9\xcf\xee\xb9\xb0\x7f\x07\x44\xa4\x71\x24\x31\x87\x09\x9d\x4c\x4a\xd3\xd5\x8d\x12\x8f\x72\x13\x1e\xf5\x76\x9f\xc7\x6f\xa2\x15\xe3\x38\x1a\x7e\x03\x0c\xa6\xe9\x56\xac\xb0\xde\xed\x33\x65\xd3\xad\x04\x7f\x5a\x86\xc7\x74\x75\x44\x01\xef\x73\xfb\xc7\x85\xdf\x94\xc1\xbf\x1c\xd3\x61\x9a\xcf\xfa\x44\x42\x44\xc5\x6e\xa9\x86\x82\xcf\x92\x78\xa4\xa4\x4d\x17\xa7\xdb\xf4\x71\xfa\x1d\x76\xfc\x8e\x9b\xec\x2e\x9d\x65\xe4\x1d\x62\x1c\xb8\x4c\x1c\x7a\x1f\x3a\xcf\x3f\xe6\x53\x71\x58\x61\xd1\xdb\xf5\xfe\x80\xd7\x21\x66\x1e\xf3\xd1\x78\x40\xd5\xf8\x2f\x1b\x64\x4b\x59\x5a\x4b\xfb\x58\x1f\x6b\x75\xd1\x9c\x5d\xca\x46\xb6\x27\x00\x9b\x03\xb0\x3a\x00\xa5\xe4\x28\xc9\xe9\x00\x1c\x0b\xc0\x01\x52\x32\x3b\x00\x75\xa4\x7c\x98\x94\x9f\x90\x21\x53\x32\xf0\xa4\x0c\xf4\x1e\x02\x8d\x4b\x83\x04\xee\x18\x01\xcd\xc0\x7d\x49\xea\x4b\x60\x9b\x09\x8c\xf2\xd0\xca\xf8\xf6\x10\xa5\x24\x21\xcb\x09\xc4\xed\x4c\x14\x13\x8a\x47\x1f\x59\x56\x84\xb0\x07\x31\x70\x7d\x31\xd8\x15\x69\x37\xec\xf4\xfc\x03\x4f\x2d\x5e\x7a\xf8\x90\xf0\xbe\x18\xbf\xfe\xfe\x9e\xa1\xb3\x07\x0e\x50\x86\x1e\xea\x89\x23\xf7\x0d\xad\xfc\x0f\x6a\xaa\x18\xbf\xfe\x67\x23\x19\x37\x9e\x96\xce\x95\xd2\xcf\xa9\x0e\x62\x8e\xf6\x5b\x7e\x8b\x2a\x88\x22\x96\x60\x30\x32\xc1\xed\xd6\xe7\x4f\xd0\x4f\x88\x57\xa8\xdc\x26\xc4\xa3\x48\x67\x84\xd2\xd2\x91\x88\xb3\xb4\x34\x2f\x91\x44\xa5\x60\x56\x95\x42\x41\x71\x22\x59\x60\x37\x39\x13\x49\xab\xd5\xe4\xd8\x1c\x87\x14\x09\x9d\x70\x9a\xfc\xa8\x23\xf1\x17\x8e\x91\xb0\x09\xf8\x77\x30\x0e\x28\x0e\x35\x07\x48\x08\x86\xe1\x38\x0c\x90\xb0\x0a\x9b\xe5\x0a\xfd\x24\x3a\x03\xae\x90\xe9\x11\xe5\x6a\x40\x7a\x26\x5e\x2a\x2f\x07\x59\x59\x78\x3d\x6f\x5a\x6a\x6a\xc6\xb8\xdf\x10\xed\x86\x38\x5d\x38\xa5\x8c\xc4\x23\x1e\x6f\xa2\xb9\x4f\x72\x41\x16\xcd\x4b\x76\x33\x39\x19\x4d\xc2\xa7\xac\x2a\x49\xcd\x2c\x9f\xbd\x60\x6e\xcb\x8f\xba\xa6\xee\x8a\x94\x84\x9d\xb3\xe3\xf7\xcd\xb9\xfa\xca\xab\x6e\xbf\x75\xee\x8a\x97\x85\xdf\xde\xf9\xcc\xd3\x2f\x1e\xa1\x3f\x56\x19\xa3\xf5\x93\x2f\x5f\xcd\x4f\xb9\x6f\xe9\xae\xdd\x1e\x7b\xff\x22\x5f\xec\xf0\x9c\x9b\x6a\x6b\xf6\x5c\xb7\x72\x87\xfd\x91\xae\x0b\xe7\x8f\x94\xb8\xe9\xd3\x3f\x7b\xe9\x14\xa6\x71\x12\xbb\x50\xd5\x89\x69\x7c\x3a\xa6\x71\x35\xba\xe4\x32\x84\x4c\xcf\x23\x6a\xf8\x89\xbe\xfc\x22\x83\x4a\x12\x9c\xc6\xc0\x89\x32\xc4\x0b\x44\xbe\xa2\x1a\x62\x85\x32\xd8\x08\xdc\x5e\x19\x1f\xf5\xfd\xdb\xd2\xf8\xfe\xd9\x17\x1b\x8b\xaf\x2d\x03\xb7\xff\xc6\x34\xdc\xdf\xfa\xca\x6a\xc7\xc0\x99\x32\xed\x5b\x8e\xe1\x6c\x7d\x34\x95\x98\x84\xb9\xc8\x5f\xfb\x26\xc5\x08\xec\xc2\xaa\xaa\x0c\xec\x1b\x72\x1b\xa9\x87\xd0\x56\xf1\xd8\xc0\x53\xe2\x32\x70\xbe\x6f\x82\x04\x4a\x26\x37\x2d\xc2\xaa\x2c\xf4\xab\xa8\x08\x4b\x53\x53\xd0\x01\x7e\x41\x55\xd0\x12\x2d\x9f\x8c\x4c\xce\x12\xc4\x94\x97\x5b\x6a\x6b\xb5\x45\x96\xa2\xa9\x75\x93\xc5\x48\x73\x93\x83\x93\x29\x03\x3d\x79\x72\xcc\x10\xab\x4e\x24\x63\x5c\x20\xe0\x8c\x7a\x23\xde\x44\xd2\x59\x9e\x48\x9a\x4a\x4a\x8a\x33\x79\xc1\xb9\x08\xc7\x15\xcf\x49\x72\x0e\x29\x18\x5d\xa2\x0e\x4a\xeb\x60\xa1\x42\x50\x90\xf6\xf5\x44\xc3\x7f\xb1\xb4\x1d\x20\x6a\xc1\xe3\x84\x99\x4b\xbb\xa3\x5b\xa4\x7c\xff\x60\x0f\x50\x99\x70\x73\xe3\x05\x7b\x8c\x57\x88\x8e\xcf\x0e\x3f\x40\x45\xf5\x45\x30\x45\x8a\xfd\x98\x8e\x47\x47\x5d\xa0\xe2\x2b\xe6\x4d\xec\x2a\xab\x78\xe8\xca\x4f\xae\xd9\xfb\x92\x32\x08\xe4\xa6\x47\x1a\xe6\x3d\xf4\xe4\x53\x17\x56\xdc\xb8\x45\x67\xd9\xba\x23\x45\x1d\x4f\x5d\x0d\x4b\xaf\x86\xf7\xe6\xdf\xba\xae\xd6\xa2\x9f\x14\x2a\xd9\xb2\x25\x3b\x2a\x64\xd3\xac\x93\xbf\x6e\x16\xb6\x4c\x37\xb7\x96\x75\x93\xf8\x90\xb4\xb7\xeb\xb9\xc7\x7e\x22\x8e\xd5\x2c\x61\xa6\x18\x3f\x11\xf7\x7f\x83\x24\x83\xa3\xa3\x92\x0c\x1e\xf7\x39\x55\x68\x84\x46\x48\x5c\x3f\x42\x4b\x8d\x12\xcd\xdd\x9c\x1e\xfb\xaf\xfa\x02\x61\xd6\x96\x19\xfb\x6c\x38\x91\xe6\xfe\x2c\xd1\xdc\x66\x7f\x48\x06\x1b\x81\xdb\x2b\xc3\x61\x79\x75\xbb\x04\xc7\xf9\xc3\x63\xe1\x4c\x99\xf7\x2e\xc7\xb4\x69\xfc\x4f\x9a\x52\x97\xfa\x25\xb0\x34\x9c\x83\xc4\xa3\x12\xdf\xfb\x0f\xa9\x7d\x07\x10\xb2\x3c\x2d\x06\xbc\x79\x6e\xf8\x78\x9f\xde\x44\x44\xd9\x85\x52\x1b\xc5\xd8\x55\xb9\x0a\xd8\x0d\x5f\x90\x2f\x9e\x94\x63\x4c\x0b\xc9\xc3\xc3\xc3\xbf\xc7\x30\xad\xa4\x7d\xff\x90\xe6\xc4\x6b\xe4\x7b\x61\x58\xe8\xcb\x31\xa5\xc1\x44\xb8\x73\x18\x2e\x8f\xb4\x4f\xc2\xb5\xfc\x45\x91\x7a\x45\x01\xfa\xef\x7d\xbe\x1c\x59\x80\x4e\xc7\xea\x50\x1d\xc2\x12\x45\x0c\xb5\xf1\x95\x3a\xb5\x1b\x18\x5a\xab\x0d\x1b\xc3\xb4\xc7\x63\x71\x7a\xbd\x46\x8b\x31\xbf\xc0\x0d\x3a\x35\xe3\xf1\x68\xec\xf6\x00\x26\x54\xbb\x9d\x61\xd9\x28\xa6\x65\x87\x46\x43\x33\x48\x3c\xad\x9b\x21\xbc\x78\xfa\xea\x1c\xe1\x52\x22\xdd\x55\x90\x6d\x7b\x22\x3f\x54\x63\xde\xe4\x70\xe6\xd9\x35\x0e\x4b\x70\x24\xc4\x86\x33\x96\xaf\x02\x85\x05\xfc\xe3\x33\xd7\xaf\x7b\x66\x07\xe4\xbc\x7c\xff\x21\x86\x92\x02\x6e\xac\x9a\x57\xb6\x5b\x78\x8f\x72\xdf\xbe\xe3\x8e\x0d\x62\xd4\x0d\x66\xd6\xd6\xa6\xe8\xac\x09\xc9\x87\x16\xdd\x78\x8b\xb0\x7d\x38\x57\x28\xfb\xe2\xcf\xa7\x3f\xcf\x3d\xba\xad\x67\xe8\xb7\xbf\x7a\xfa\xc8\x5b\x6f\x3f\xf1\xac\x34\x06\x24\x56\x0b\xe1\x0f\x73\x24\x39\x10\x3d\x81\xd2\xbd\x76\xa1\x2f\xbf\xc2\x41\xcc\x13\x22\xcd\x91\xbe\x10\xfb\xbf\x59\x92\x33\xd0\x1d\x28\x4d\x4d\xaf\x61\xd9\x55\x22\xbb\x71\xe0\x36\xa0\x6f\x25\x1a\x69\x75\x7a\x94\xb4\x29\xc1\xed\x95\xe1\x30\x2d\xfd\x54\xc6\x37\xdc\xe7\x1c\x8d\xaf\x2d\x03\xb7\x1f\x1d\x94\xe1\xbe\xc5\x32\xea\x28\x38\x53\xe6\xbd\xcb\xd1\xa3\x19\x9e\x34\x84\x45\x53\x09\x50\xe2\x49\x57\xa1\xd7\x19\x13\xb3\x93\xec\xb1\x78\x51\x03\x9f\x27\x46\x42\xb3\x58\x3c\x2e\x8f\xcb\xe7\xb7\xf3\x88\xe5\xd9\x0e\x96\x16\x0d\x25\x5e\xaf\xe7\xf1\x24\x8d\xc5\x52\x9d\xf7\x69\x54\xf7\xc7\x85\x6f\x66\xd4\x76\xcf\x9b\xb2\x5f\xf5\x38\x21\xcb\xb2\x72\x99\x8b\x2e\x1f\x7b\x27\x15\x14\x4e\x9a\x54\x58\x30\x49\xbe\xc2\x6d\x17\x2e\x63\xf2\xc5\x7b\xfc\xf7\xc2\x1f\xd2\x3f\xe0\x07\x4b\x96\xe0\xf6\x35\x0c\xf7\xd0\xcf\xd1\x42\x5a\x96\x5d\xc3\x4f\x4c\xcb\xb2\x56\x9d\x17\xcc\x9a\x1c\xc6\x80\x68\x03\x9d\x1b\x15\x05\x58\xc6\x15\x62\x5d\x89\xa4\x19\x72\x34\x8c\x8a\xb5\xf0\x5a\x73\xa3\xc5\xc2\x72\xaa\x50\x22\xa9\x15\x45\xda\x1c\x2d\xd7\xa8\xd5\xaa\x1c\x5c\x14\xd6\x2a\xa5\x58\x33\x39\x2a\x3d\xe2\x1e\x2e\xca\xb0\xf1\x8a\x0a\x89\x0c\x41\xe3\xb0\x63\xe2\x23\xf2\xab\x14\x3b\xb5\x1a\x24\x31\x56\xad\x92\xc4\xd8\x89\xf4\x73\x9b\xd6\x0b\x8d\x7b\xaf\x9d\xbb\x72\xf3\xc6\xdf\xff\xf1\xde\xef\xb5\x0c\x1d\xf5\xc3\xbd\x53\x6f\xdd\xba\x1e\x2e\x04\x85\x15\x17\xaf\xdb\xd6\x41\x0b\x4f\x6c\xfe\x46\x30\xd7\x6e\x3a\x7a\x1b\xa0\x2f\x2e\xf0\x37\x0f\x7d\xf0\x93\x05\x54\x7d\xcb\x0b\x03\xf7\x2c\x1c\xfa\xd9\xcc\xe3\x12\x1d\x90\xd8\x11\x84\x5e\xe6\x49\x3c\x60\x6e\x9a\xfa\xf6\x63\xaa\xb2\xe5\x64\x78\x54\x36\x9c\x28\x23\x6a\x25\x9e\xb7\xce\xe9\x91\xc1\x46\xe0\xf6\xca\x70\x98\xae\x1e\x91\xe0\xb0\x0a\x34\x16\xce\x94\xc1\xb7\x1c\xf5\x20\x91\x4b\x51\xc0\x14\x3a\x25\x40\x22\x2f\x93\xb3\xdc\xe4\xbd\xd7\x64\xd1\x33\xcc\xf3\x87\x8c\x8e\x34\x3e\xcc\x2b\x4c\x62\x3c\x1b\xd5\x5d\x28\x07\x45\x21\x97\xff\x25\x72\xb2\xea\x60\x30\xea\x8c\xc6\xf2\xa2\xc1\x70\x30\x91\x0c\x7b\x3d\x5a\x31\x80\xaf\x8a\x16\xc3\xf7\x9a\x6d\x9c\x49\x8f\x97\x34\xb4\x3a\x06\x75\x24\x13\xd0\x70\x0c\x4e\xc7\xe0\x44\x0c\x8e\xc5\xe0\x40\x0c\x36\xc7\x00\x3f\x4a\x91\xa7\xa5\x31\x08\xc6\x80\x8d\xc1\x32\x0c\x74\x32\x06\xfd\x31\xe8\x8d\x41\x77\x0c\x3a\x62\xd0\x1e\x83\xd6\x18\xf0\x31\xe0\x62\x80\x48\xa1\x94\x58\x08\xff\x1e\x90\x81\x25\xc8\x56\x52\x58\x83\x8b\xf6\x10\xdc\x18\xeb\x20\x81\xc0\x28\x12\x31\x28\x8b\xc1\x97\xe4\xfd\x9d\x31\x98\x4d\x9e\xe2\x17\x66\xa9\xe5\x4a\x51\x75\x94\x5d\x7a\xf4\xd1\x8a\x7f\x1f\x6e\x67\x24\xb4\x70\x56\x64\xe1\x71\x42\xef\x50\xdf\xdc\x7c\x9b\x18\x5d\xe7\xd6\x5b\x86\x0e\xfe\x00\x4a\xd5\xd9\xb1\x77\xe0\xc3\x57\x9e\x13\xc3\xeb\x9c\x60\xa6\x8a\x41\x86\x27\x75\x8e\x0a\xbf\x83\x46\xc6\xcf\x94\x19\xbf\xe5\xe8\x95\xf4\x38\xb3\xa5\x7e\x69\x00\x15\xb6\xda\xb2\x8c\xad\x76\x37\xfc\x50\x69\x0f\x1e\xea\xb3\xda\xb3\xec\xc1\x44\x06\x62\xfe\x9c\x91\xab\x76\xdf\x9a\xe6\x4a\x5f\xf7\xc5\x0a\x14\x72\x95\x84\xf7\xd5\x0c\xde\x7d\xb0\x09\xe3\xd5\x3e\x2d\xe2\x45\x59\xb2\xd7\xc6\x0c\xae\x7d\x6b\x71\x0b\x45\x5c\x5f\xf4\x15\x96\x7b\xe8\xbc\x8c\x8d\x5b\x58\x25\xe6\xce\xce\xe0\xfa\x31\x7d\x39\x7e\xe0\xe1\xcd\xd4\x6a\x92\xa8\x22\x44\x52\x57\x60\x0d\xd7\x6f\x26\x23\x41\x64\x35\x61\x15\x7d\x90\x7e\x29\x23\xab\xfd\x18\xee\x43\x69\xec\x3f\xef\x2b\x2c\xcc\xcb\xcb\xcb\xe8\xf7\xcc\xc7\x44\x07\x8b\xa5\xe7\xd7\xeb\xa4\x9d\x10\x1e\x69\x27\x89\xdb\x4c\xe6\x42\x43\x7a\x2e\xfc\x17\xc6\x65\xe5\x8d\xe9\xf0\x2c\x2b\x5d\x6e\xcc\x66\x8b\x17\x2e\x1c\xb1\x31\x60\x9c\xa7\x65\x9c\x58\x77\x3c\x8a\x71\x5a\xb0\x5e\x87\x91\xc2\x0a\x5f\x88\x76\xe7\x91\x0e\xcd\xe0\xde\x2b\xe3\xc6\xf3\xf6\x08\x46\x92\xf3\x2c\x54\x90\xc5\x80\xc0\x48\xf8\xf6\x65\xf0\x3d\x08\x3f\x4d\xe3\x0b\x62\x7c\x6d\x11\xdf\x18\x7c\x33\x33\xf8\x1e\x44\x2f\x4a\xf8\xa6\xfb\x9d\xd9\xf8\x46\xda\xb7\x0b\x9e\xc4\xf8\x1c\xbc\x89\xb4\xaf\x35\x0a\x4b\xa3\x41\x11\xe5\xc2\xef\x68\xe3\x2e\xd4\x8b\x71\xb2\x7c\x8e\x18\x34\x74\x52\xd0\x43\x3e\x5e\xb6\x37\x8a\x76\x37\x82\x3b\x3f\x8d\x7b\x2b\xc6\x6d\xeb\xa3\xfc\x84\x9e\x1e\xeb\x0b\x79\xed\xc6\xbc\xb4\x52\x2b\xda\x0e\xb1\x9c\xac\x55\xfd\x90\x8b\xa1\xcb\xc8\x5e\xe4\x10\x7d\x08\xaf\xc8\x57\x3f\x8f\x2a\x86\xfb\x9f\x2e\x2c\x6c\xac\x10\xb7\x07\x0b\x0a\xa4\x6b\x7e\xbe\x74\x8d\xc5\xa4\x6b\x5e\x9e\x74\x8d\x46\xa5\x6b\x6e\x2e\xb9\xf2\x46\xbf\xbf\x91\x3a\x16\x81\xeb\x22\x11\x96\x15\xdb\x96\xd9\x11\x24\xef\x4c\xdb\x06\x31\xd7\xbd\x5b\xec\x9b\xe7\x51\x78\xb8\xff\x28\xc7\x35\x16\xa7\xe3\x5e\x5f\xc0\xfc\x4c\x8c\xb5\xbe\x91\xbf\xc4\x67\x64\x90\x81\xa5\xc3\x36\x7b\x98\x76\x31\xae\x58\xbe\x07\xaf\x3a\x1e\xbb\xd3\x68\x32\x26\x92\x36\x93\x49\x63\xb1\x70\x62\x24\x02\x0d\x16\x7d\x90\x86\xd3\x50\x3a\x5a\xc3\x85\xb1\xba\x48\x51\x41\x31\x20\x76\x28\x5f\xce\x5f\x4d\x3c\x98\x32\x69\x0a\x47\x8e\x46\x66\xdc\x99\xc8\xe6\x2e\x49\xc8\x99\x15\xee\x9a\x1c\xb2\xc3\x9a\x6d\x3a\xd8\xf0\xb8\x61\xaf\x85\xbf\x81\x75\x3f\x4c\xdf\xb5\x6b\xfc\xe0\xd7\x6b\x5c\x2d\x0f\xb9\x4a\x3e\x6c\x39\xff\x85\x22\x00\x76\xc6\x36\x5c\x96\xb1\x25\xef\x06\x5f\x9a\xae\x44\x5b\xb2\xdd\x17\x40\x23\x74\x45\x64\x5b\x32\xef\x25\x19\x78\x37\xfa\x3e\xa1\x2b\xca\xe2\x0f\x62\xe1\x96\xc0\x48\xf8\x5e\xcd\xe0\xdb\x47\x6c\xd3\x19\x7c\xc1\xfc\xd1\xf8\xc8\xdc\x97\xf0\xed\x43\x1d\x12\x3e\x5d\xa8\x20\x1b\xdf\xbe\x0c\xbe\x07\x21\xaa\xa0\xfb\x60\xc4\x37\x06\xdf\xcc\x0c\xbe\x07\x89\x9c\x86\xf1\x99\x72\xfd\x19\x7c\xc2\x2a\x31\x4f\x76\x06\xdf\x8f\xa9\xa4\xc4\x13\x60\xf8\x2f\x7d\xc5\xc5\x6e\x77\x9a\x27\x24\x30\xef\x68\x20\x7a\x46\x63\x9a\x77\xc4\x50\x86\x33\x4d\x98\x60\xb3\xa5\xe1\x46\xdb\xe2\x77\x61\x09\x5a\xa4\x75\x32\x8d\x9e\x1b\xfe\x47\x5f\x34\x48\xa9\x14\xb4\x3e\x5a\x8f\xd8\x85\x76\x49\x6d\xb4\xe5\x85\xe4\x36\x92\xdc\xcd\x04\x67\x51\x9a\x77\x3c\x95\xfe\xe6\x18\x46\xea\x0e\xe7\xa9\x03\x99\x6f\x26\xb1\xa4\x09\xbe\xa6\x2c\xde\x41\x73\xd3\x2e\xf5\x23\x25\xbe\x57\x33\xf8\xf6\xc1\xe3\x18\x9f\x99\xd7\x91\x46\xf2\x61\x08\x9b\x17\xca\xbc\x5d\xc2\xb7\x51\xc2\xc7\x89\x63\xd2\x99\xb1\x99\xee\x24\xe3\x50\x94\x1e\x87\xde\x74\x9b\xa2\x18\x87\x27\x3f\x3c\xa6\x4d\x33\x33\x6d\x7a\x10\xdd\x4f\xe4\x06\x9a\xbb\x6c\x9a\x5f\x21\x07\xb7\x08\x33\xc5\x1c\xd5\x32\x4e\xed\x71\xea\x2a\x89\x4f\xe9\xa2\x12\xba\x0c\xae\x13\x32\x2e\xad\x00\x73\xa4\x71\xa0\x87\xdf\xef\x9b\x36\xdd\x66\x1c\x19\x07\xd5\x6e\xd2\x67\xc5\xe9\x3e\xbb\x4b\xc1\x6f\x91\x2f\x84\x4c\x99\xf6\x91\x18\xc9\x1a\x0d\x86\x9d\x21\xcb\x49\xb0\x01\xd5\x3d\x05\x01\x91\x81\xb8\x5c\x8d\xe4\x6a\xb5\x4b\x57\xb3\x59\xba\xb2\x2c\xb9\xf2\x46\xad\xb6\x31\x40\x61\x9c\x81\x88\x37\x87\xe0\x24\xff\xa5\x65\x21\xb1\x1d\x77\x92\x3d\xcc\x7c\xf4\x47\x7e\x02\x56\x5e\x72\x54\x1e\x15\xa5\x67\xbc\x0c\x95\x6f\x0c\x87\xd5\x54\xd4\x14\x08\xd8\xdd\x94\xbb\xa0\x90\x29\x9c\x5e\x48\x55\xe2\x7f\xce\x14\x9e\xc5\x37\x22\xf2\x85\x93\xa7\x34\x0e\x14\x02\x95\x28\x6c\x2f\xec\x2e\x3c\x59\xc8\xb0\xb1\x60\x8c\x8a\xb1\xae\xa0\x0b\xb3\x15\x17\xa3\x62\x52\xc9\x98\x1d\x8c\x76\xbf\x9d\xb2\xc7\x8c\x60\x34\xfa\x8d\xf8\x81\x51\x95\xcf\xe7\x87\x5a\x93\xf9\xf9\x94\xce\xc6\x1a\x34\x9a\x90\x56\xdf\x28\x66\x79\x32\xeb\xe8\x70\xc0\x4d\x32\xdf\xf9\xb0\x4c\xad\x4c\x2a\x8d\x8a\xcd\x72\x56\x69\xc9\x0b\xa9\x82\xe4\x5f\x94\x36\xe1\xc4\x3d\x86\x85\xa2\x13\x66\xb1\x78\x5c\x5b\xf6\xaa\x96\xfe\x20\xbc\xbc\x4a\x69\xa7\x73\xab\xe2\x55\x92\xc5\x2d\x9c\xbe\x66\xc2\xa1\x93\xf4\xd3\x80\xcb\x6a\x7b\x1e\x7b\x6c\x24\x09\xf5\xe3\x8f\xa7\xd3\x50\xc3\x1b\x43\xbb\xaa\xbc\xf4\xaa\xe6\xd3\xa2\x05\xee\xb4\xf4\x6f\xf3\x85\x7b\x46\x92\x51\x53\xa7\xff\xf4\x27\xc9\x17\x51\x8e\x69\x9d\x87\xde\x7e\x1e\x85\x86\x07\xf9\xb0\x8e\x6b\xa4\x91\xcb\x15\xf6\x5b\xf0\xf7\xc7\xf2\xd3\xe7\xd4\x2f\x2d\x4b\x9f\x65\x67\xf2\xc5\xbe\xb4\x17\x97\x35\x1e\xcb\x87\xee\x7c\x40\xf9\x1c\x81\x60\x58\x5a\x7c\xf2\x74\x30\xd2\x48\x20\x72\xac\x8e\x46\x3a\x18\xc2\x22\x2a\x7a\x0e\xa3\xad\xc4\x68\x51\x28\xa4\x8b\x1a\x23\xfe\x08\xc5\x32\x11\x4e\x67\x6a\x8c\x46\x12\xc9\x28\xf2\xbb\xa4\x28\x4c\x5e\xd6\xee\x14\x03\xbf\xda\x9b\x93\x48\xc7\xe9\x28\x1d\x87\xea\x16\x8e\x8d\xa4\x89\xc4\x60\xbc\xa4\x6b\x25\x13\x0c\x48\xd1\x79\xd7\x14\xaf\x25\xc5\x99\xf3\x52\xa8\x58\x74\x54\xb7\x87\xed\xdf\x1d\xf0\x3a\xdd\xc7\xd0\x00\x56\xe1\x6f\x63\x02\x5f\xef\xda\x75\x27\x54\x30\x3d\x2d\x8b\xc7\x0f\x7e\xcd\x58\x44\xae\x3f\xb2\xdf\x76\x34\xb3\xdf\xb6\x9f\xec\xb7\x59\xe4\xfd\x36\x47\x18\xab\xfe\xe9\xf9\x31\xfc\x07\x92\x03\xbc\x2d\x63\x4b\xd8\xff\x2b\x32\x2b\x91\x2d\x28\x01\x11\x1d\x02\xc3\xec\x21\xeb\xc6\x84\xf4\x5a\x80\x24\xbe\x27\xed\x0f\x0e\xf7\x19\x4c\x32\x46\x62\x77\x38\x83\xe1\xe7\x91\xb5\x43\xc2\xb9\xfb\x75\x09\x67\x8e\x61\x04\xa7\xb8\xe7\xb8\x8e\xf0\xa9\x09\xe9\xf5\x00\xb2\x71\xb2\xce\x2c\x9c\xc3\x18\x7e\x0a\xe1\x55\x12\xce\x7d\xbf\x96\x70\x1a\xed\x23\x38\x9b\x84\x55\x62\x3e\xf3\x34\x4e\x35\xf5\xe3\x99\x04\x66\x32\xeb\x1d\x81\x29\xc6\x30\x36\xc2\x87\x66\x4a\x30\x5a\xc2\x91\x2f\x72\xe7\xb1\xc6\x0c\x1e\xb2\x1f\xba\x2f\xd3\xb6\x07\x87\x87\xd3\xfd\xc7\x8a\xfd\x67\x31\xa8\xf5\xe9\x96\xc1\xff\x8f\xb5\x37\x81\x8f\xa2\x48\xff\xc6\xab\xfa\x98\xfb\xee\xe9\xb9\xef\x23\x93\x64\x72\x0f\x21\xdc\x69\x4e\x23\x22\x99\x84\x20\x34\x02\x09\xa0\x80\x20\x82\x5c\xba\xeb\x81\x8a\x0a\x11\x50\x14\x45\xc4\x0b\x14\x11\x35\xba\xa8\x01\xcf\x55\x58\x51\xd7\x13\x11\x2f\x44\xd7\x6b\x5d\x5d\x97\x55\x74\x59\x0f\x20\x9d\x7f\x55\x75\xf7\x1c\x01\x7f\xbf\xf7\xfd\x7f\x5e\x91\x09\x33\xe9\xa9\xae\xa7\xba\xea\xa9\xef\xf3\xd4\xf3\x7c\x1f\x99\x6b\x9c\xee\x02\x7a\x70\x8d\x30\x09\xb0\xac\xc1\x48\x98\x91\xad\x2a\x33\x72\x9e\xfe\xf8\x7f\xe2\x3e\x8e\x14\xd0\x1f\xff\xe9\x7f\xa6\x3f\x3e\x1d\xb5\xb8\x1a\x76\x59\xc0\x7b\x7c\xb1\xc2\x1c\x3e\x46\x65\x89\x54\xb0\xd7\x55\xec\x50\x9b\x7a\xae\x5a\x49\xe1\xc4\x07\xc7\x33\x20\xd6\xbb\xe7\x29\xa3\xb1\x09\x67\xc6\x7a\xd1\xf6\x90\x26\xe3\x34\x8e\x7e\x8e\x1d\x67\x93\xc7\x49\x0b\xce\xa6\xea\xd0\xb5\xb3\x9e\x41\x60\x6a\xcf\x93\x5e\x6f\x53\x3d\x5e\x5b\x6e\xb7\xfc\xd3\xe1\xc0\x3f\xaf\x7a\x12\x61\xaa\x7a\x45\x7d\x92\x9f\x16\x0b\xf9\x29\x98\x4c\xa6\x26\x9a\xfa\x53\x35\x5c\x54\x0d\xab\x65\x73\x5d\xd7\x54\x0d\xc1\x9f\xd0\x00\xa2\xfb\xd5\xdb\x31\x96\xae\x2f\xc2\x6c\x69\xb4\x77\x0e\x21\x3a\xbe\x52\xd1\xdb\xf7\x29\xcf\xc0\x47\xe6\xb0\x17\xa8\x3b\x2d\xe1\x41\xa7\x66\xb0\x37\x03\x3b\xf0\x81\x23\xc2\x56\x87\xc6\xec\x36\x03\x10\xf0\x3b\xbd\x37\x8a\x0e\xe7\x2d\xe7\x7a\x1c\x76\xc1\x6e\xc9\x8a\x76\x2b\x6d\xc8\x8a\x1a\xda\x7f\x22\x00\x9f\x23\x79\x3d\xc6\x00\x5c\x80\xde\xfc\x2b\x00\xcf\x0a\xc0\xc1\x01\x98\x0e\x40\x3f\xf9\xf4\xce\x00\x5c\x13\x80\x97\x05\xe0\xb9\xe4\x57\xfd\xc8\x35\x87\xc9\xd7\x1e\x21\x9f\xa3\x6b\x06\xe3\x64\xa0\xc2\xac\x9e\x48\x00\xbe\x13\x80\x72\x16\xd0\x7a\x35\xc3\x07\x90\xb7\xb9\x6b\xac\x81\x62\x2a\xf4\xff\x3b\x2e\xf4\xba\x74\x3e\x52\x3f\x93\x8b\xe9\x2d\xa0\x3f\x4f\xd6\x73\x19\x8e\x8f\x27\x59\xb8\xa2\x88\xfe\x5c\x9a\xf2\xf1\xfb\x87\x06\x48\xc7\xa4\x63\xa9\x42\xfa\xf3\x27\xa3\xd0\x2e\xfd\x10\x7d\xea\x29\x19\xcb\xa3\x3d\xfa\x09\xb2\x7e\xaa\x94\x3d\x7a\x9a\xbc\x47\xeb\x82\x3e\x33\x2b\xef\xd1\x29\x69\x1c\xe6\x4a\x47\xd7\x8c\x97\xaf\x81\xed\x2a\xa6\xfa\xbe\x3b\xe8\x73\xeb\xc9\x22\x52\x38\xd5\xd1\xba\xf0\x82\xf9\xc2\x60\x8b\x56\x6b\x83\x1a\x8d\x0e\xd3\xaa\x9b\x75\xbc\xce\xe7\xaf\xc1\x6c\xea\x59\x3f\x65\xa0\x09\x05\xba\xf5\xff\x92\x02\x5d\xe6\xa7\x51\x0f\x3e\x1c\xb9\xd0\xf7\xff\xa7\xd4\xe7\x74\x14\x53\x9f\x2b\xb8\x6f\x2e\xb1\x19\xab\x15\x7b\xb0\x13\xcd\x45\xff\x2e\x68\x43\x53\xd1\x4e\x22\x17\x75\x96\xfe\xc3\xec\x76\x93\x29\x99\x2e\x38\x23\xc4\x5c\xb1\x35\x5a\x0d\xfa\x5e\xb3\xfc\xbd\xde\x13\x08\x7b\x20\x5b\xd3\x40\xe5\x6c\x4d\x34\xe6\xb8\xee\xbb\xda\x36\x1a\xcf\xb7\x64\xbf\x4b\x90\xb3\xe9\xb5\x79\xfc\x54\x86\xe3\xeb\xc9\xb8\xe3\xb6\x34\xba\x7d\xcb\x94\x51\x3f\xd1\x6d\x36\x28\xea\x2d\xd7\x57\xb2\xc6\xe5\xf6\x7a\x28\xa4\xe1\x81\xf3\x19\x90\xc0\xcb\x0e\x2d\x50\x58\xef\xb4\x01\x2d\xba\x3e\x4d\xae\x47\x56\x18\x1d\x20\xf6\x58\x73\x88\x5c\x0f\x9f\x46\xf6\x58\xc9\x33\x20\x84\xd6\x2f\xaf\xc0\x22\xf4\x35\x02\x87\x0c\x68\x41\xc3\x69\x16\x8b\x1e\x3f\x65\xb4\x54\xf3\xf7\x93\xfb\x6f\xc3\x58\xf1\x60\x8f\xa4\xc8\xfe\x14\xbb\xce\xa6\xc8\x8e\x70\xe1\x7f\x7a\x24\x6c\x7b\xb9\x91\xed\x85\xf4\x43\x5a\xd6\x9d\xa4\xe6\xbd\x1b\xcc\x16\x06\xea\x4c\x00\x9a\x68\xde\x6e\xe0\x69\x8f\x57\xa3\x83\x2e\x68\xd4\x31\x6e\xe0\x86\x76\x5a\xef\xd6\xbb\x19\x0e\x9f\x69\xda\x6c\x1c\x67\xee\x10\x39\x07\xe6\x23\x6d\x17\x19\x7a\x91\x17\x4e\x2b\x0e\x35\x2a\x4c\x56\x47\x73\x66\x9a\x7c\xee\xee\x96\x53\x5b\xd4\x5a\xfd\x49\x9e\x2d\xa8\x15\xaf\x4d\x3f\xdf\x45\x0d\xd9\x8f\x56\xc9\x5b\xf9\x82\xf1\xcf\x53\x9a\x05\xd4\x65\x84\x9e\xe4\x3f\x4f\x4c\x7f\xa2\xe7\xa0\x52\x39\x1e\xee\xbb\x48\xc1\x29\x54\x35\xc2\x29\x76\xf0\xa6\xb0\x4a\xa7\x31\x18\x20\xb0\x5a\x1d\x1c\xae\x07\x9e\x15\x6d\xd8\x55\x6e\x07\x5a\x68\xa4\xb5\x76\xad\x9d\x35\xf3\x2c\x95\x15\x59\xf0\x1e\x07\xf7\x71\xb0\x9b\x83\xdb\x38\x78\x2b\x07\xaf\xe5\xe0\x52\x0e\x9e\xc7\xc1\x04\x07\x9d\x1c\x64\x38\xb4\x4f\x90\x2b\xd6\x73\x68\xab\xe0\x60\x07\x07\xb3\x1c\x14\x38\xb8\x87\x83\x3b\x39\xb8\x85\xbc\xb5\x71\x10\x70\xf0\x28\x79\x8b\xae\x2b\xbc\xec\x94\x43\xd7\xd3\xd0\xe4\x83\xfc\x51\xab\xb2\xa2\xf2\xb5\x15\x72\x23\x64\x6f\xc8\x95\x9e\xd7\x3a\x77\x6d\x81\x63\xf6\xec\xc1\xdb\xc9\x2e\x4a\x33\x87\x3a\xec\xa9\xec\x11\x16\x4d\x5f\xd4\xf3\x21\x5e\x23\xf0\xaf\x73\x0b\xe3\x44\xfe\xa6\xc6\x89\x80\xe5\xf0\x17\x45\x5f\xe3\x38\x91\xe5\xbc\xdb\xca\xe6\x30\xb9\xec\x8b\x5f\x2f\xfb\xe2\x6d\xf8\x5a\x98\xd3\x3f\x9b\xc8\x5c\xaa\x55\xf4\x4f\x95\xaa\x5b\xbe\xe9\x76\x3b\x4d\xb4\x82\xff\xab\xd1\xde\xf4\x05\xb1\xd7\x5a\x94\x35\xd3\x96\xd7\x41\x91\xa0\x4b\x57\x60\x27\x6c\x22\x7b\x48\xad\x62\xaf\xad\x93\x31\x86\x8f\x60\x8c\xe3\xdd\x7e\x8f\xb5\xd0\x5e\x93\xfb\x75\xb3\xda\x2f\x64\xaf\x75\x91\xcf\x29\x34\x4f\x9f\x40\x73\x39\x85\x3e\x3f\x80\x5b\xd2\xfe\xbd\x77\x3c\x6a\x7d\xd0\x33\xa0\xba\x77\x4f\x37\x5e\x54\x51\xb4\x3c\x76\xe9\x8d\x4d\x51\x00\x48\xb0\x34\xda\x21\x81\x80\xac\x0b\x20\x38\x5d\x4d\xf8\xa3\x27\xf5\xfa\x26\x60\x27\xc6\x83\x9d\xac\x3d\x5c\x9f\x1f\xed\xc7\x90\x3d\x03\x94\x80\x29\x42\x2d\x6a\x35\x64\x2a\x29\xf1\x98\x3c\xa9\xd2\x40\xa2\x43\x0c\x07\x38\x0d\xed\xa4\x11\xf6\xc4\xd4\xd2\x06\xc6\xee\x64\x6c\x66\xb4\x02\x68\x4c\x2c\xdd\x2e\x1a\x1c\x45\x64\xd2\x4a\x80\x5d\x21\x15\xb6\x4a\x2a\xad\xd4\x36\xcb\x93\x4a\xf7\x4f\xc8\x74\x6e\xe4\xec\x4f\x3d\x22\x66\x46\x2c\x5f\x75\xce\x07\x17\x77\xf5\x7c\xd3\xd5\x05\xe7\x53\xcb\xa0\x79\xce\xde\x3f\xb5\x3e\x38\xe7\xaa\xe6\x11\x21\x6e\x4c\xf9\x3a\x7a\xf7\x9a\x1b\x87\x0c\x3c\xf1\xb3\x7a\x92\xbe\x76\x44\xdb\xd3\xef\xf4\xfc\x78\xfd\x6b\xcb\x42\xc7\xd6\xb8\x7d\x2f\x10\x3e\x7c\xf4\x5c\x86\xd3\x2f\x23\x7b\x68\x8e\x30\x38\xc8\x71\x1a\x8f\xd9\x0c\x3c\x20\x91\x5c\x94\xdc\x99\x7c\x27\x49\x5b\x93\xd5\xc9\xe6\x24\xad\xa7\x1d\xc1\x60\x24\x62\x6b\x15\x23\x36\xbf\x17\xe3\x6c\x0f\xc7\x73\x59\x91\xe7\xf1\xf6\xac\xa5\xfd\xea\x96\x57\xec\x56\x25\xa4\x52\x2a\xa2\x56\x84\xeb\xb3\x01\x16\xd7\x8e\x51\x48\xce\xe9\xe1\xf9\x9d\xf0\xe6\xec\x52\x85\xbd\x5e\x3f\xfc\xfe\x81\x17\x2d\xce\x6d\x86\xd4\xaf\x4f\x14\xf0\xd7\x8f\x2b\x1f\xbc\x6e\x75\x61\xfc\x50\x4d\x2e\x7e\x48\xf6\x97\xa2\x79\x8d\xe3\x81\x28\xe0\xf6\x9a\xec\x45\xbe\xb8\x27\x08\xee\x6d\x55\x70\xf2\x23\xb2\xbd\x8f\x2e\x2b\xf0\xc5\xa1\xf6\x5e\xce\xb5\xb7\x99\xc4\x2f\x39\x94\xf8\x25\xe0\x8b\xf5\x6d\x8f\x60\xde\x56\x05\x23\x77\x29\xed\xf9\x62\xc5\xed\xe5\xe2\xa7\xa8\x7b\xe1\x21\xd4\x9e\xa1\x9b\xc6\x0e\x38\x1c\x7a\xd2\xf7\xac\x0a\xcd\xeb\x7b\xc1\x31\x62\xbf\xb6\xf5\x1e\xd7\xec\x66\x47\x81\x10\xd2\xd6\x6b\x85\x6c\x8a\xb1\x61\x33\xcb\xc0\x45\x19\xb6\x3c\xed\x70\xdb\xdc\x1d\x22\xdf\x6e\x5b\x68\xa3\x2a\x6d\x90\x46\x7b\xb7\x8d\xd2\xb3\x36\x9b\x0e\x68\x13\xed\xa2\x56\xab\xd3\x59\x3b\x44\x04\x59\xf5\xb4\xd1\xa8\xa3\x61\xb8\x5d\x44\xcb\x38\x10\x00\xc0\x83\x3e\x76\x08\xe9\x9c\x62\xae\xb6\xcb\x81\x0c\x19\x35\x0c\x34\x47\x63\x49\xd8\x6b\xa7\x65\xfa\xd4\x21\xac\xad\x89\xb2\x72\x74\x1b\x7b\xfa\x70\xcf\x24\x71\x88\xc5\x28\xbb\xcd\x41\xff\x2a\xfd\x4b\x7a\x4e\xda\x0d\x47\xc1\xb3\xa0\x9d\xba\xe8\xb4\x61\x9f\x8d\xe3\x85\xba\xa9\xdf\x7c\xf8\xa1\x06\x4e\x84\x2d\x70\x02\x6c\xd1\xf6\x0d\xfb\x1c\x6b\x60\x6e\x33\xa2\x96\xf6\x4a\x7b\xa4\xef\xc8\xd9\x19\x1a\x33\x76\x05\xa9\xed\x50\x06\x6a\xc0\x65\xc2\xa8\x88\xc3\xec\x2e\x41\x78\xa0\xa4\xc4\x51\x55\xa5\xf5\x3b\xfc\xb5\x75\x55\xb8\x04\x63\x55\xb8\x8a\x32\xd1\x55\x55\x5e\xa3\xb7\x1c\x21\x19\x9b\x3b\xc8\x07\xd1\x5c\xb6\x99\xe3\xd6\x38\x3e\x1e\x35\x32\x2d\xa2\xd1\xf5\x62\x1d\x5c\x54\x07\xf3\x75\xe0\x72\xfb\xd5\xef\x1d\xd6\xab\x09\xfc\xa4\x36\x9c\xab\xe8\xac\x5e\x39\x2c\xcd\x95\x88\x23\xbf\x1e\x0a\xab\x60\x54\x3e\x9f\xa7\x3b\x56\x77\x66\xd6\xa4\xab\xb7\x8c\xff\x78\xc6\xac\xb7\xf7\xfe\xe5\xa5\xbf\xfe\x75\x56\xfb\x3e\x38\xf9\x64\xeb\x45\x33\x66\x2e\xb8\x78\x1e\x3b\x0f\x7e\xd7\x71\x3e\x5c\x38\x01\x1e\x72\xfc\xf5\x11\x72\x28\xbf\x72\x65\xcf\x4f\xdf\x9f\x5c\xbd\x9a\x94\x90\x7b\xee\xb3\xcf\xf7\xfc\xf5\x23\xff\xfe\x9d\x3b\xb6\xed\xbc\x4b\xd5\xa3\x13\xc8\x1c\xab\x57\x74\xfb\xe5\xb2\x6f\x3f\x91\xf7\x99\xe3\xfd\x7e\x3b\x99\x63\x13\xe5\x73\xeb\x8b\x09\x72\x1c\xe1\xf2\x98\x41\x32\x8f\x75\xd8\x09\x44\xbf\xd7\x2b\xfa\xbd\x44\x9e\xcf\x30\x16\xd6\x39\xe4\xf9\x8c\x71\xce\x26\xa2\xdb\x27\xca\x38\xe7\x6c\x45\xb3\xdf\xd4\xed\xe1\x0d\xa0\x10\xe7\xa0\x3e\x7d\xa6\xb6\x85\x74\x7b\x5c\xf6\x3b\x27\x88\xdf\xf9\x40\x77\x2a\xa6\x2d\xf4\x3b\x13\x9b\x98\xe8\x76\xd2\x2e\xd5\xa9\xee\x18\xcf\x76\x07\xd5\x2e\xe2\xeb\x3a\xd1\x5a\x39\x46\x64\xed\xaf\xc8\x3a\x56\xd9\xc7\x32\x68\xd3\x58\x5a\x55\x6b\x4f\xe5\xd6\x27\xe1\xdb\x27\x32\x9f\xa3\xe0\xc2\x9b\x65\xbc\x3c\xbb\xbc\xc2\xa9\xac\x4f\xb9\xbd\xcf\xd4\xf6\x90\x1d\xf3\x95\xbc\x07\x65\xc8\x1e\x74\xa2\xbb\xaa\x4e\x6d\x51\xf5\x8f\xa3\x36\x6f\x56\xda\xd4\x50\xab\x07\xe4\x70\x5e\x59\xa5\xb3\xa0\x9f\x48\xd7\x1e\x23\x76\x6c\x7f\x25\x36\xe2\x13\x55\xa2\x23\xdd\x99\x2a\x90\x52\xcf\x3b\xd0\x78\x1e\x24\xe3\x49\xda\x03\x7f\x0c\x29\x57\x1d\xea\xae\x2a\xd3\xf6\x95\x3b\xdf\xcf\x4e\x08\x95\xd8\x34\xdc\x51\x4f\x3d\x96\xbb\x4f\x5c\x25\xf5\xf7\x82\x7e\x76\x8e\x25\xa8\xd5\x54\x83\x25\x97\xe3\x14\x40\x12\x61\xdb\xbd\x04\x8b\x36\x28\x31\xd4\x26\xb4\x4d\x1c\x15\x8c\x69\xe1\xca\x2b\x9b\xd2\xc2\x65\x97\x35\xa5\xf1\x6e\x19\xfc\xc3\x1f\xd0\xbb\xe5\xcb\xd1\xcb\x92\x25\xe8\x65\xf1\x62\xf4\xb2\x68\x11\x7a\xb9\xe8\x22\xf9\x0a\xfd\x82\x05\xe8\xdd\xfc\xf9\xca\xbb\x79\xf3\xd0\xbb\x39\x73\x94\x77\xe7\x9f\x8f\xde\xcd\x9a\x25\xbf\xe3\x66\xce\x44\xef\xda\xdb\xd1\xcb\xd4\xa9\xe8\xe5\xdc\x73\x95\xab\xa6\x4c\x41\xef\x26\x4d\x92\xdf\x79\xce\x39\x07\xbd\x6b\x6b\x43\x2f\x13\x26\xa0\x97\x96\x16\xf4\x92\xcd\x92\x5f\x3e\xd9\xdc\xac\x7c\x65\xfc\x78\xf4\xe9\xb8\x71\xca\xbb\xb3\xce\x42\xef\x9a\x9a\xe4\x6b\xc6\x8c\x51\x3e\x1d\x39\x12\x7d\x2a\x08\xf2\xa7\xc3\x86\x29\x9f\x0e\x1e\x8c\x3e\x1d\x30\x40\x79\xd7\xd0\x80\xde\xd5\xd7\x2b\x1d\xec\xd7\x0f\xbd\xab\xad\x45\x2f\x55\x55\xe8\xa5\xb2\x52\xfe\x6e\x45\x85\xfc\xb3\xb4\x54\xfe\x99\x4a\x29\xdf\x4e\x24\xd0\x55\xd1\xa8\xf2\x2e\x12\x41\xef\x42\x21\xf9\x9a\x40\x40\xfe\xe9\xf7\xcb\x3f\x11\xea\x90\xaf\x42\xc8\x23\x2d\xb8\x5c\xca\x3b\x04\xe3\xd3\x02\xb2\xd1\xd3\x8a\x8b\x53\xee\x07\x3e\x00\x41\x96\x39\x7a\x41\xa6\x7f\x5a\x30\x18\xe4\xcf\xad\x08\xa8\xc0\x84\x60\xe7\x9a\x12\x82\xc1\xd8\x94\x40\x98\xe5\xf7\xf2\xad\xfe\x0f\xff\x53\xce\xf4\xc6\xe1\x5a\x0e\x68\x2e\x4c\x92\xe7\x21\x03\x40\x70\x57\xa5\x50\x57\xd7\x54\x49\x3c\xad\x4e\x67\x53\x25\xee\x4e\x25\xe9\x4e\xce\x0f\x90\x44\xd8\x6b\x2f\x99\x97\x0d\xca\xbc\xf4\xcb\xe7\x75\xbe\xbc\xee\xc1\xf1\x7c\x67\xb0\x0f\x2a\x6d\x63\x1b\xe6\x2b\x30\x0f\xaf\xc3\xcf\x7d\x3e\x03\x71\xdb\x42\xb9\x1d\x64\x6b\x04\x60\x99\xf0\xbe\xcb\xe7\xd3\x50\x26\x2b\x45\x07\x43\xd6\x50\x63\x88\xfa\x1c\x47\x43\xb6\x87\x56\x84\x6e\x0a\xbd\x18\x62\x23\x24\x86\x71\xfe\x51\x12\xee\xb8\x85\x44\x36\x2e\xc2\x1f\x85\x43\xcd\x21\x5a\xfe\x74\x27\x8e\x80\x5c\x88\x2e\xbf\x37\xc4\xd4\x84\x84\x10\x15\x26\x05\x41\x3f\xc3\xdc\xdd\x3b\x43\x54\x3b\x7e\x57\x13\xa2\x06\xf7\x12\xf6\x6f\xf9\x0b\xcd\xe8\x0e\x37\x85\xe8\x1a\xfc\xe6\xf3\xd0\xd1\x10\x2d\xb7\x4b\xae\x8d\xa0\xab\x71\xd3\x9f\x91\xe2\x3e\xf7\xe2\x5f\x5c\x85\x1b\xad\x46\xbd\xa3\x51\xc3\xb4\xcd\x04\x4c\x50\xcf\x98\xcc\xbc\xce\xac\xeb\x10\xbd\xc4\x39\xec\x62\x59\xca\x4c\xfb\x88\xc7\x17\x38\xf2\x91\x94\xd5\x99\x3c\x35\x0c\xa9\x31\x02\x8b\x4a\x2e\xfd\x5e\xc2\xaa\xfc\x89\xcc\x9d\x27\x6f\xc3\xd8\xb5\x8b\x53\x2e\xe4\xd2\xea\x76\xcc\x93\x87\x37\x63\x9e\xf8\x7b\x07\xbf\x2f\xbd\x08\x87\x67\x7a\xa6\xf9\x47\x32\x77\x8d\xf2\x87\x5e\xbf\xb4\x16\x8e\x92\x9e\x7f\x5f\x0e\x28\x8f\x38\x0f\xc0\xc1\xd2\xcb\x07\xb4\xc6\x9e\x2f\x5b\x7b\x0e\xfb\xeb\x0b\xea\x79\x84\xc0\xc5\xc2\x70\x87\xc5\xe5\x32\x6a\x69\xda\x1f\x8e\xac\x88\xc0\xf5\x11\x88\xc9\xc8\x28\x23\x6d\xd7\x5b\xf4\x68\xff\x64\x35\x6c\x56\x74\x2c\xd4\x40\xa0\x81\x16\x5a\x63\x16\xf4\x96\x26\xb3\x60\xb4\x58\xfd\x5e\xe0\x6d\x11\x03\xc0\x95\xe7\xe6\xf6\xbd\x95\x26\xa4\x28\x39\x2e\x4b\x82\x14\x55\x5f\xb6\xe2\x2a\x91\x2b\x7f\x64\x0a\xaa\x7f\xf4\xad\x00\x72\xe9\xa5\x72\x0d\x90\xb7\xdf\xce\x55\x01\x81\x15\x6d\x90\x23\x85\x40\xa4\x7f\xb7\x49\xff\x50\x6b\x81\xe4\xe2\x7f\x9f\xc8\xc5\x0b\xdf\x93\x3b\xf3\xc5\xf1\xc2\x89\x78\x95\x85\xce\xed\x13\x72\x0c\xc6\x79\xb9\x58\x8d\x7b\xd4\x33\x5f\x26\x5a\xe1\x34\xc8\xfb\x84\xdc\x5e\x4d\xae\xbd\x35\xb0\xab\xe0\x2c\x2d\xe8\xf5\xf7\x6d\x8f\xe0\xcc\xc9\x45\x38\x13\x32\x6e\x6f\x71\x7b\x2f\xe7\xda\xdb\x0c\x9f\x2d\xe8\x5f\x79\x20\x71\x4a\xff\x2e\xc9\xb5\xa7\xe2\x4c\xc8\xf8\x62\x45\xed\x69\xbd\xb9\xf6\xee\x82\x2f\xa0\xf6\x22\x4f\x29\xe1\xce\x72\xfe\xa6\xc5\xd6\xbf\x2a\xec\x35\xe3\xa8\x80\x5c\xe0\x73\xae\xfd\x37\x72\xed\xdf\x45\xda\x37\xa1\xef\x82\xa0\x9b\xc3\xd6\x5a\xfd\xe9\x62\xbc\xa9\x7b\x29\x06\xdd\xc3\x2b\x58\x28\x7c\xf0\x44\xc1\xac\x0f\xda\x7c\xd0\x67\xc7\xce\x42\x35\xf7\xac\x4f\xbc\x0c\xc2\xb6\xff\x52\xda\x36\x79\x22\x85\x6d\x4b\x73\xd9\xbb\x08\xf6\x18\xa0\x9c\x05\x56\xf5\x9e\x20\x3b\xa1\x74\x4d\x77\x24\xa2\xd1\x28\xfb\xa5\x5f\x5a\xc0\x40\xba\x2b\xd7\xde\xdd\xf0\xbf\xf2\x58\x80\x60\x10\xbb\x77\xf0\x58\x50\xbd\x5f\x68\x3b\x89\x4e\x1a\x24\xef\xe9\xd4\xad\x05\xbe\xc9\x04\xef\xd5\x38\x72\x63\x4b\x6a\x74\x90\x7d\x72\x8a\x72\x56\xa5\x8c\x6d\x4c\xb9\x2c\x17\x17\xfe\x99\x1a\x17\x5e\x70\x9e\x85\xdb\xb3\xf0\x5e\x7d\xbe\x3d\x39\xce\xe3\x66\x35\xce\x03\xe1\x89\xbd\x72\x7b\x96\x60\xd4\xec\x2a\x6c\xef\xb2\x5c\x9c\xf9\x3c\xb8\x59\x8d\x4d\xf7\xe0\x71\xf4\xa6\x78\x39\xd2\xbc\x20\x36\x7d\x26\xd2\x8f\xb2\x1d\x31\x54\xc1\x3d\xb3\x95\x3e\xa0\xaf\xc0\xd9\x4e\x97\x56\x97\xeb\x03\xe1\xeb\x27\x63\x3e\x4d\xc1\x3d\xdd\x72\x1f\x32\xbc\x5b\xaf\xcc\x17\xb9\xbd\xcd\x6a\x7b\xd4\x9d\xb9\xb3\x61\x17\x6a\xcf\xe4\xe5\x4e\x69\x6f\x9c\xd2\x9e\x86\xba\xf3\x0f\x72\xb4\xc1\x4e\x1f\xf4\xfa\x9c\xb8\xc5\x69\xf5\xf9\x3e\x7e\x96\x6b\xb3\x13\x46\x15\x8c\x82\xfb\x68\xf2\xb9\x80\xad\x08\xa3\xc8\xed\xde\x9c\x6b\xb7\x73\x09\xc1\x28\xb4\xdf\x0d\xe4\x40\x7b\xa4\x93\x6a\x11\x2e\xbc\x8e\xbd\x0f\x70\xa0\xbf\x10\xc4\xa4\x15\xac\x93\xb7\xf2\x61\x1e\x69\x22\xcc\x51\x6d\xd2\x43\x4c\x73\x90\x15\x29\x3e\x5f\x77\x1b\xca\x07\x3e\x4a\x85\x0d\xe5\x14\xa7\xb0\x06\x12\x9c\x79\xbf\x54\xb1\xe6\x81\xdb\xc6\x8d\x94\x4b\x04\x8f\xc7\xc5\x80\xe9\x6d\x6a\x79\x60\x74\xcb\xde\x13\x68\xde\x3e\x43\x6a\x4e\x26\xc1\x24\xa1\xd2\xc0\x44\xa3\x5e\xde\x67\xe5\xad\x25\x29\x07\xb2\x1b\x1c\x2e\xad\xdb\xe3\xce\x8a\x8c\xc7\x63\xa2\x22\xb8\x64\x56\xb0\x45\x34\xd9\x28\xd0\x2c\x52\xa0\xb0\x94\xb9\x72\xf0\x54\xc4\x93\xa2\xba\x87\x71\xa5\x2f\x5e\x3e\x71\x2a\x28\x67\x8e\xb5\x60\x61\xc1\xf3\xf5\x9d\xb0\x1a\xa6\xa5\xf7\xf3\x65\xcd\x6f\xbb\x8d\x5a\x96\x2b\x79\xce\x36\xe1\x50\x02\x7f\xbe\xb4\x39\x93\x6a\xeb\x19\xa5\xd6\x3d\x27\xb6\x52\xb2\xf7\x38\xbb\x8d\xe4\x29\x38\x40\x25\x98\x21\xd4\xa5\x4b\x59\x8b\x25\x0a\x4a\xf5\xa5\x3e\xce\xc7\x55\x55\x33\x81\x44\xa0\x43\x4c\xb3\x66\xd6\xdc\x21\x5a\x59\x68\xa4\x59\x64\xdb\x79\x12\xb4\xc5\xe7\xf1\xb5\x8b\x6e\x8f\x43\xa5\x94\xca\xe7\x01\x14\x14\xa8\x97\x69\x8a\xec\x38\x6e\x2f\x43\x72\x9f\xd4\x7c\x00\x8e\xfc\x83\x58\x47\x4e\x26\x9a\x24\x47\x68\xa4\x2a\x03\xd7\x3f\x13\x8d\x10\xca\xa2\x10\x64\x16\x6d\x7e\x74\xff\xe1\xfb\xee\x38\xff\xf9\xfd\x47\x6f\xb8\xeb\x91\x87\xf7\x4b\xff\xed\x05\x52\x5b\x2f\xe8\xea\xdf\x3c\xd3\x53\x37\x52\xdb\xbe\x87\xd2\x82\xde\x23\x37\xaf\xdc\xf5\x0a\xfd\xeb\x65\x8b\x24\xf6\x2a\xc9\xb5\x6e\x65\xcf\x9b\x9a\x9b\xef\xde\xfb\xaa\xa6\xde\xcf\x6c\xa8\x1c\xfc\x07\x68\xa8\xbd\x7d\xdb\xf2\xed\x01\xee\xd1\xdc\xd9\x2f\xc9\xcd\xe0\xd1\x6e\xd6\x2a\x54\x58\x68\x3d\xef\xf7\xeb\x5d\xb4\x9e\x0e\x47\xac\x11\x24\x21\xef\x43\xd6\x33\xaf\x35\x39\x0d\x72\x12\xaa\xd6\xdf\x21\xca\x69\xa8\xe8\xf1\xe5\x63\xc5\xf0\x89\xac\x32\x9f\xd4\xd2\x2d\x44\x44\x39\x1b\x59\xf1\x64\x70\xca\xce\x9b\x13\x9c\x6a\xfc\xf7\x7f\x8f\xff\x24\x69\xba\xee\xa5\xaf\x33\x0f\x1f\x58\xb6\x6d\xfc\xdd\xf0\x89\xad\x0f\xcd\x9d\xb9\xeb\x4e\xea\x9f\x7f\x7e\xfa\x99\xe7\xea\x7d\xcc\x3d\xfe\x7a\xe9\x8d\x37\x74\x26\x89\x92\xae\xb9\xb3\xb3\xe7\x8d\x2b\x49\xbf\x3b\x89\x2f\x60\x28\x30\x82\x18\x38\x5b\x48\xf1\x0e\x93\x5f\x8b\xba\x64\x72\x98\xe2\x09\xad\xc3\x61\xd5\x84\x42\x11\xce\x9f\x15\x39\x3a\x42\xb7\x88\x11\x9b\x55\x8f\x8d\xd8\x82\xc4\x34\x79\xd6\x65\xec\x85\x39\x1a\x76\xe5\xa9\xe4\xe6\x54\x83\x32\xd5\xd4\x9e\x2b\x33\xb0\xa0\x92\x7e\x37\x99\x69\xd4\x01\xb9\xf7\xf7\x93\xc9\x97\x2f\xa7\xff\x01\x99\x69\xac\x49\xea\xb9\x43\x67\x7a\x18\xcf\x3d\xdc\xf7\x04\x1a\xf3\x36\xc2\xcb\xe3\x01\x03\x85\x90\x89\xe7\x75\x1a\x1b\xd0\x00\xaf\xcf\xe4\xec\x10\x4d\x26\xc6\x40\x33\x7c\x87\xc8\x68\xda\x45\x46\x1d\x65\x4c\x76\xdd\x27\x22\x2f\x37\xae\x49\x3c\xa7\x30\xe7\x86\x3c\xa8\x4c\xdb\x89\x9f\x7a\xde\xeb\x7a\x09\x8e\x6e\x7c\xfd\xbb\x5f\xff\xba\xf5\xa1\xcd\xb7\xee\xba\x13\x2e\xdc\xfd\x4c\xbd\x8f\x6e\xdb\xde\xb8\xab\xa7\x6b\xcf\x0b\xca\x40\x52\xb8\x4e\x16\x1a\xc7\x75\x68\x1c\x43\x60\x84\x10\xb5\x6b\xb5\xe6\x10\xf0\x84\x3c\xe1\x88\x36\x14\x42\x33\x21\x2b\xfa\x5d\x1a\x8e\xe3\x79\x34\x8a\xbc\xcd\x8a\xd6\x6c\x9f\x3a\x97\xa7\x09\x13\xd4\xe4\xe2\x04\x1b\x32\xf6\xa2\x35\x5b\x30\x70\x3d\x6b\x3a\x7b\xea\xf2\x6b\x35\x3f\x66\xd4\x3b\x8f\xd5\xee\x93\x76\xe6\x17\x2a\xf1\x31\x5e\x8c\xf6\x1f\x8a\x1d\x07\xfc\xa0\x4a\x70\xeb\xbd\x76\xda\x4b\x07\x82\x1a\x4b\xbb\xa8\xd7\x70\x5e\x00\x9c\x08\x39\x32\x79\xcd\x56\x48\x4b\x22\xbb\x60\x62\x29\x9a\x78\x08\x23\x0e\xbb\x8d\x52\x17\x17\x95\x85\x63\xe0\x85\xd2\x7d\xd2\x8e\x03\x47\x35\x23\x42\x63\x9e\xe9\x80\xf0\xc8\x2f\x47\x16\xbf\x3e\x38\x39\x5c\xf3\x29\x3b\x4e\xba\x5b\xda\x23\x6d\x97\xee\xce\xc0\xe4\x63\xe9\x6a\x88\x13\x08\x12\xb0\x5f\x43\xd5\x5f\xe1\xe0\x46\xb9\x4e\x9d\x66\x88\x66\x1e\x28\x03\x43\x85\xb0\xde\x1d\x83\x76\xb7\xbd\x3c\x1d\x4e\x75\x88\xe1\x38\x42\xe6\xed\x22\xf4\x31\x76\xa7\xd3\xd4\x2e\x3a\xb9\x7c\xdf\x80\xc7\xb6\x6f\x5f\x01\x15\x14\x66\x99\x21\xcc\xcd\x11\xec\x08\xca\xc8\x35\x58\x34\x71\xb9\xdb\x75\xc4\xf9\xa7\x52\x3b\xf3\xcc\x5b\x0c\xe9\xa6\xd4\x9b\xeb\xe6\x27\x3d\xd2\xb3\xd2\xad\x70\x3a\x9c\xfc\xf8\x63\xec\x0d\xcb\x14\x3f\xe7\x5a\xe6\xab\x1f\x50\x97\xa5\x77\xa5\x97\xa4\x4f\xa4\x37\x51\x97\xa5\x97\x1b\xe1\x2c\x28\xc0\x29\x70\x56\x64\xd3\x76\xc5\xd9\x09\xb1\x7f\x88\x99\xc2\xec\x05\x71\x20\x08\x11\x8d\x3d\x00\x8c\x76\x63\x22\xe9\xb2\x7a\x23\x59\xd1\x1b\x74\x3a\x99\xac\x88\x46\x17\x2d\x9f\x96\xdc\xf2\x21\x5e\x30\x2c\x03\xfa\x77\x91\x18\x78\xd7\x88\xe4\xa0\x28\xa1\x24\xc8\xe4\x05\x20\x3b\x0a\xdd\xd0\x90\x9e\xb0\x54\x3a\x76\xff\x23\xb7\x5c\x58\xdb\x35\x45\x6a\xf8\xe7\xa1\x99\x73\xec\x4b\x2e\x52\x77\x18\x6a\xcb\xf6\x6a\x69\xee\x7b\xbb\xa2\x43\x12\x65\xf0\xc7\x7f\xf5\x58\x3b\xaf\x51\xf6\x9a\x7c\xfc\x9b\x43\x8e\x7f\x23\xb9\xb2\x9a\x06\xb4\x8e\xf4\x64\xee\xc6\x6c\x6c\x08\xb8\x43\x6e\x3c\x73\x03\xa1\x76\xd1\xcf\x76\x88\xfe\x80\xcd\xc6\x05\x1c\x8c\x91\x33\x76\x20\x55\x50\x60\x5a\xf4\x65\xff\x25\x35\x32\x71\xc2\x29\x4e\xfa\x83\x05\xda\x37\x97\x9e\xca\xce\x96\x0e\x48\xdf\x74\x5f\xfa\xc0\xcf\xff\x3c\x39\x32\xaf\x72\x69\xb8\x04\xce\x96\x1e\x94\x1e\x92\x62\x5d\x5d\xd4\x0e\xe8\x85\xb1\x13\x97\xe9\x60\x8c\x9e\x2f\x6b\x5b\x69\x97\xd4\x2d\xed\x94\xb6\x33\xf5\x38\xfc\x00\x8c\x44\x6b\x7f\x2a\xd9\x63\x42\x60\xb4\x90\x04\x1e\xb3\x9d\x61\x82\xe6\x60\x38\x12\xe0\xbc\x5c\x87\x68\xd3\xa0\xbf\x36\x83\xc7\x4b\x1b\x82\xed\xa2\x81\xee\x90\x3d\xe4\x64\xdc\xb1\x0e\x28\xea\x34\x89\xba\x83\xb8\x26\x0e\xde\x2f\xa0\x9c\x7f\x20\xbf\xc1\xdd\xc7\x27\x44\x6e\x68\xbc\x73\xd7\xad\x9b\x1f\xda\x4a\xb7\xf4\xbc\xf7\x9f\xe3\xc7\xff\xf9\xda\xfe\xec\x03\x25\x03\x87\x9b\xe9\xa7\xee\xed\x82\xf3\x37\x5c\x49\xd5\x77\xf6\x1c\x7f\x66\xf7\x73\x2f\x42\xc9\xa4\x7b\x03\xd6\xd7\xfb\x4f\xcc\xf4\xc9\x7b\xc3\x28\xa4\x1b\xbe\x20\xe3\x1b\x05\x2d\x42\x19\x08\xda\x3c\x26\x96\x8d\xd8\x22\xb1\x78\x30\x18\x0a\x79\xb3\x62\x88\xe3\x74\x48\xc7\xda\x4c\x16\x0b\xd2\x0f\x16\x97\x31\xd2\x2c\x1a\xf9\x22\xe7\x20\x9e\x2a\x45\x79\xf1\xa4\xbe\x33\xea\x37\x97\x8b\x08\x84\xd1\x54\x61\xe4\xa0\x6a\xa6\xb9\x7f\x55\x23\x02\xa9\x7f\x4a\xbf\x9a\x72\x51\x83\x7f\x90\xa6\xfa\x47\x52\x1f\x2e\x55\x43\x02\x4f\xae\xcb\x45\x0c\x5e\xb7\xc1\x79\x07\xa4\x4f\xe8\xbd\xa4\xff\x8d\xd2\x19\xf4\x05\xf4\x2b\x20\x82\x76\xf3\x51\x42\xbc\x34\x94\x00\x09\xde\x02\xd2\x7e\x3f\xd0\xf2\x4c\x55\x75\xa8\xd4\x5e\x8a\x80\x49\x34\x2b\x7a\x6c\x8c\x11\x81\x94\x40\x21\x4f\xb4\xbd\xd0\x97\x2b\xa7\xf0\xb3\xbc\x4a\x30\xe8\x52\xf9\x05\x15\xf2\x75\x65\x8f\x96\xdd\x98\x61\x48\x38\x07\xa9\x2f\x9f\xdd\xd2\x71\x81\xb1\xba\xa6\xe6\x1c\x71\xea\xe8\xb1\x17\xdc\x7c\xfd\x57\x2f\x3e\xf9\xfe\xc3\xf7\x5f\x38\x49\xfa\x7e\xd1\xc5\xd3\x2e\x4c\x2d\xbd\xf0\xb2\x17\xcd\x17\xad\xe0\xde\xba\x20\x75\xe6\x88\xcc\xb9\xfd\xce\x9c\xf5\xe5\x5d\xaf\xfd\xf0\x8f\x37\x1e\xfc\xa6\x5f\xcb\xe5\xf4\xd1\xfb\x6f\xdb\xf8\xfc\xd9\x81\xca\xdd\x77\xed\x7a\x51\x8e\x29\x9a\x8d\xe6\xce\x0e\xf4\x3c\xfc\x60\x88\x10\xb6\x6a\xb5\x3e\x9f\x89\xa7\x98\x40\xd0\x6b\x73\xd9\x3a\x44\xbd\xc5\x02\x5d\xb4\x4f\x0b\xb5\x1d\x22\x3c\xc5\x8a\x2e\xa8\xf9\x54\x06\x91\x2a\x74\x95\x21\x03\x58\x8b\x8c\x47\x77\xce\x2e\xc6\xb3\x85\xd9\x71\xe2\x00\x37\x62\x60\x16\x52\x50\x27\x6d\x0c\x0b\x42\x18\xce\x3b\xfc\xe1\x82\xc8\x08\xfa\xfb\xae\x2e\x38\xf3\x57\xa4\x3b\xef\x83\x77\x6d\xa1\x4c\x96\x43\x70\x78\xbd\xef\xc4\x4c\x3f\xf1\xbf\x1f\x61\x97\x22\xdd\xcc\x83\x00\x38\x4b\x28\xf7\xd9\x39\xaf\xd7\x68\x64\xed\x74\x30\x24\xc8\x5e\x01\xca\x4f\x3b\x10\x8e\x70\x38\x2c\x3a\x8b\xab\x5d\xb4\x70\x3a\xd0\x2e\xea\x0a\x69\xb9\x15\xf8\x50\x50\x07\x1c\x17\xca\x51\x56\xa1\xbc\x08\xd1\x6b\x43\x94\x2a\xa1\xeb\x1c\xf6\xa8\xcd\x41\x3d\xd7\xf1\xcc\x98\xd0\x08\xcd\xd1\x03\x48\xa5\x4d\x92\x1e\x91\x9e\x97\x5e\x94\x9e\xa5\x99\x33\xad\x9f\x7d\xf8\xed\xe7\x27\xaf\xf9\x88\x39\x59\x9d\x7e\x0c\x26\x33\xe8\x57\x9b\xa4\xa7\xa4\xed\x48\x45\x4e\x1c\x0b\x03\xbf\x9c\x18\x0a\x4b\x60\x8d\x74\x50\xfa\x10\x8f\xe9\x34\x34\xc7\xb7\xb2\x67\x83\x72\x70\xae\x50\x17\x74\x6a\x4c\x5e\x5a\xc3\x20\x2c\x9b\x4c\x57\xd0\x1e\xaf\xc7\xdb\x2e\x56\x7a\x20\x8d\x26\xb1\x87\xd2\xb3\x1e\x8f\x3e\x59\x5a\x1a\x69\x17\x4b\x39\xbd\x1d\x81\x21\x3d\x53\x70\xc4\xe3\x50\x0f\x02\x0a\x8a\x11\x11\x61\xea\x48\xe1\x99\x1c\x4d\xbf\x3d\x47\xd3\x8f\x26\x0a\xaf\xb2\xb8\x28\x5a\x3f\x96\x98\xb6\xe3\xb1\x1b\xef\xff\xe4\xe0\xad\x0f\x8e\x88\x26\x2f\x6d\xb8\xe2\x82\xab\x97\xde\x74\xd3\x86\xd5\x37\x6e\xac\xef\x2c\x4b\x8f\x30\x3e\xb8\xeb\xd3\x5e\x00\x17\xdc\xf6\x20\xcf\x3f\x76\xcd\xd6\x87\xd2\x92\xb4\xcd\x15\xbe\xea\x9a\x2b\xae\xd7\xe8\x5b\x75\xda\x1b\x56\x3e\x78\x73\xc8\xf3\xbc\xf4\x8f\xf4\x7e\x24\x5b\xef\x25\xd2\x68\xa6\x0c\xcd\x97\x08\x98\x22\xd4\x6b\x2c\x16\x3e\x00\xf4\x01\x3a\x1a\xd3\x20\xf4\xda\xae\x59\xa8\xa1\x2a\x35\x48\x34\x8d\x4d\x83\x44\xd3\x68\x1c\xe1\x30\xd2\x38\x61\xa4\x35\xc3\xe4\x61\xf1\xbc\x23\x90\xcb\xdd\x2c\x3a\xe8\x50\x8b\x59\xe7\xb4\x7e\xc1\xc9\x46\xf1\x69\x1c\x46\xee\x4c\xd9\x88\xc8\xa2\xf7\x0e\xc3\x35\xe1\xa1\x43\xc3\xd2\xb2\xd6\x07\x2f\x50\xf7\x28\xd8\x45\x7f\x4f\x9f\x3c\x64\xe9\x39\x40\x4e\x30\xfe\xb4\xea\xb5\xa5\xf2\xbe\xc4\xde\xe6\xc3\x7e\x96\x97\xa4\xaf\xe8\x2b\xd8\x56\x84\x92\x3a\x84\x06\xb7\xd3\xe3\x61\x21\x40\xda\x85\xf6\xfa\xa0\x8b\x77\xa1\xf5\xca\x22\x5c\xa2\x03\x1e\x9d\x35\x2b\x66\x4d\x1d\x26\xca\x64\x42\x73\xca\x07\x3f\xf7\xc1\x2d\x3e\xd8\xe1\x83\x82\x4f\xce\x4a\xc5\x62\x90\x3a\x0b\x58\x85\x0e\x1c\x58\xb8\x20\x14\x13\xc3\x0f\xe3\x8d\x54\xc1\x4e\x65\x81\x56\x98\xd1\xc6\xe9\xc3\x9d\x5b\x75\xdb\x23\xae\xee\xd5\xe7\x36\xe2\xc2\x70\x55\x83\x93\x8e\xd0\x6f\x96\x5f\x6f\x42\x3d\x3b\x5c\x17\xfb\x76\xeb\x53\xdc\xee\x0e\x77\xbf\xf3\xaf\xfc\xb0\xed\x64\x12\x28\xb5\x6b\x35\x59\x84\x09\x2a\x91\xc6\x2c\x8f\x6a\xec\xde\x14\x00\x5e\x0d\x5d\x55\x5d\x59\x5a\x5e\xda\x2e\x96\x97\xd3\x7a\x8b\xab\x43\xb4\xe8\xf5\x68\x8b\x72\x18\xf5\x0c\x9d\x68\x17\x69\x4e\xd9\x59\xf7\x29\xea\x52\x29\x6a\xd5\xe7\x38\x09\x73\x45\x9e\x16\x16\xd8\x8b\xf0\x83\x12\x1c\xc0\x32\x4b\x8f\xaf\x27\xd8\x60\x06\x9c\xb8\xfb\xcf\xf4\x9a\xe5\xea\xb8\x8f\xf4\x8f\xde\x3b\xbf\x17\xfc\xfb\xd8\x0f\x6d\x4f\xd7\x74\xc1\x1f\x56\x8e\x29\xe9\x07\x3b\xe0\x48\xf4\x77\x5a\xf2\x8e\x87\xe5\x67\x20\x6d\xde\x5e\x5b\x2f\xed\x97\x5e\x91\x0e\x49\xfb\x4b\x03\xf0\x0a\x5f\xff\xfe\xca\xbe\xe0\x96\x46\xb3\x3b\x89\xcd\x10\x00\xc3\x84\x88\xdd\xc4\x51\x26\x2a\x18\xa2\x38\xce\x64\xb7\xa0\x75\xe1\xa0\x8d\x1e\x46\xcb\x5b\x64\x5b\x41\x51\xaa\xb9\xc0\x17\x7b\x51\xa5\x00\x5e\x0b\x5d\x0e\x37\x9b\xca\x15\xe3\xc3\xa1\x2f\x74\x09\x2e\x59\xe1\x66\x77\x6e\x90\xaa\x5a\x9a\xcc\xd2\x4d\x23\xb4\xb5\xc3\x7a\x8e\xdf\x4e\x85\xba\xe1\x46\x78\xdb\xce\xb7\xcd\x83\xbc\x69\x27\x3b\x14\x29\xa0\xfb\x5f\xef\x05\x97\x18\x83\x33\x9f\xbf\x97\xd9\x8f\x83\x1c\x4e\x26\xe9\xc3\xbe\xfa\xdf\x66\x2e\xbe\x69\xd8\xe6\x32\xad\x12\x8b\x89\xf4\xd3\x16\x84\x71\xcb\xc0\x78\xa1\xcc\xa1\x47\x6b\x80\xb6\xc4\x52\x96\x54\x79\x3a\x19\x6f\x16\x93\x56\x8f\xa6\x15\xed\x00\x76\x6b\xb3\x68\x07\x61\xbd\xc5\x64\x69\x16\x81\x29\x57\xa8\xd2\x53\x60\x33\xe4\xe9\x29\xf3\x65\x78\x8b\x0f\x6b\x73\x89\x31\x32\x8f\xa7\x42\xe9\xa9\x61\x1a\x9e\x78\x5a\x09\x7f\x5c\x0b\xeb\xe4\x90\xc8\x05\x93\x26\x2d\xb8\x11\x66\x9e\x71\xde\x7c\x2d\xbc\x5f\x8d\x7e\xc4\xa5\xfd\xa5\x0b\xe4\xc8\x48\x69\xda\xf4\xa5\x4b\xa7\x53\xa2\xb7\xb2\x67\xe2\xf5\x37\x11\x59\x7a\x11\xf2\xa3\xb4\x48\x16\x1b\x48\x08\x0e\x1d\x4d\x9b\xed\x0e\x62\x27\x30\x00\x21\x1c\xc0\x15\x57\xfe\x56\x7a\xa8\xb2\x8a\x12\x07\xe1\xe4\x73\xce\xdb\x02\xc7\xd4\x56\xc7\x05\xf7\x3c\xe7\xe2\x39\xcc\x4a\x4f\xe5\x89\x33\x87\x8c\xb1\x0d\xe7\x12\x78\xac\xe2\xe8\x01\xaf\x46\xcf\x96\x03\x23\x85\x98\x83\xa2\x8c\x5a\xad\x93\xc7\x15\x30\x11\x9a\xd5\x1b\x90\xdd\xe7\x30\x18\x58\x0b\x8d\x6b\x5e\xb7\x8b\xec\xe9\x9d\xb5\x79\x0e\x56\x18\xcf\x47\x84\x2a\x21\x2b\x19\x6a\xf5\xbb\x38\x9e\xf6\xe0\x41\x1c\x5b\xfb\x2e\x75\x7f\xcf\xa3\x24\x7e\x76\x42\x2b\xfc\x0d\x3f\x40\x49\x2b\xc7\x14\x00\xc0\xee\x61\x5b\x50\x7f\xa6\x0b\x75\x51\x77\x20\x16\x74\x01\x10\x34\x07\xe8\x10\x1b\x62\x93\x89\xa8\x23\xe0\xf6\xba\xdb\xc5\x60\xcc\x15\x67\x90\x2d\x60\x70\x20\xa0\xc4\x84\x00\x0e\x57\x44\xeb\xc9\x51\x50\x8d\x1f\x1b\x4f\xf2\xd4\x53\xe1\x2a\xce\x9d\x93\xd7\x54\x5d\xde\xef\x51\xb8\xa0\x34\xbc\xbd\x20\x00\x0b\x6a\xe1\x8e\x3d\x3d\x07\xbb\x5a\xb6\xcd\x9c\x3f\x65\x44\xc8\x2e\xc4\x87\x9d\x49\xad\xbf\x0e\x6e\xbb\x53\xea\x4f\x0d\xbd\x59\x7a\xba\xe7\x3f\x2f\x35\xe3\xae\xd3\xc3\xae\x7b\x1d\x87\x11\xb8\xfc\x1d\xd3\xa5\x34\x75\x3d\x11\x47\xe8\x89\xf9\xeb\xa9\xed\x77\xcb\x32\x31\x80\xbd\x0f\xc9\x34\x55\xa8\xf1\xb2\x2c\x1d\xf1\x85\xa9\x48\xd8\x10\x35\x44\x13\xc9\xb0\x2f\xe0\x6b\x16\x23\xb4\x97\x61\x74\x01\xab\x85\xcf\x8a\x38\xad\x85\xa5\x0c\x3a\x03\x9a\x8e\xba\xdc\x74\xec\x23\x93\xea\x56\x90\x25\xaa\x53\xdc\xdd\xb9\x88\xb1\x22\x77\x4e\x81\x50\x54\x2e\x72\x2c\xef\xdd\x29\x08\x2c\x2b\x8c\x1e\xeb\x52\xdd\x3d\x3d\x57\x14\x06\x98\x21\x79\xa2\x68\xae\x78\x48\xec\x10\xb2\x1c\xad\x10\x1a\xd0\x26\xc2\x01\x9d\x1e\x41\x42\xab\x5e\xcf\x98\xcd\xc6\x66\xd1\x0c\xa0\x86\xd1\x34\x8b\x0c\x0f\x8a\x0f\x8a\x4f\x99\x2a\xc5\x33\xc5\x9e\xe1\xe1\x42\x1c\xac\xb3\x63\x07\x9a\xae\x0f\x51\x5b\x7b\x1e\x20\x61\xc2\xe7\xb6\x51\x13\x3c\x95\x3d\x73\xdb\xd0\xfd\xfb\x03\x40\x7f\x80\xc6\x33\x44\xb4\x10\xcd\x02\x1f\xeb\x0b\x47\x5c\x06\xaf\x56\x03\x35\x6e\x1d\xfa\xc3\x20\x95\xd4\x22\x72\x10\xe0\xdb\x67\xf2\x05\x40\x1c\x05\x29\xbd\x78\xc4\x68\x0d\x8c\xd7\xc3\x14\xac\x87\x05\x4c\xd1\xee\x06\xa4\x9c\x42\x68\xb0\x68\xc7\xbf\x63\xd2\x17\x8f\xc1\xc7\x7c\xd2\x63\xb0\xff\x98\xf6\x40\xb0\xb4\x76\x74\xf3\xa4\x05\xe9\xe7\xee\x86\x63\x6d\x23\x62\xd4\xc9\xe9\x3d\x33\xa3\xf4\x33\xe3\xa5\x67\x16\xc3\x8a\x97\x4d\x13\x1e\xe6\x66\x2f\xd9\xb5\x78\xd3\xc9\x70\x4d\x85\xa1\x52\xd6\x41\xde\xde\x6f\x34\xf3\xd0\xba\xaa\x05\xcd\x42\xca\x11\xf5\xf9\x8c\x20\x95\xaa\x32\x56\xd5\x65\x2a\x4b\x23\x7e\x79\x81\x95\x07\x2d\x74\x55\x82\xd7\xf3\x33\xc5\xda\x5a\x5a\xef\x20\xc9\xc8\x8a\x0e\xca\xa8\xd5\x83\x33\xc5\xb9\xc8\x0a\x83\x70\x49\xbe\x4c\x36\x5a\x63\xf2\x41\xbb\xbc\xf2\x73\x6f\x95\x37\x68\x94\xd9\xf4\xa4\xc7\x86\x35\x5d\x16\x9e\xf8\xd1\xa8\xe3\xd7\xc0\xb7\xd7\x9e\x75\x4e\x62\x6b\x9d\x7d\x1d\xfc\x68\xcd\x39\x13\xd3\x6b\x93\xeb\xe0\xdb\x57\x5f\x2d\xbd\x36\xae\xba\x7f\xbf\x81\x95\x02\xe4\xe9\x9f\x88\x62\x8d\x4c\x10\xdd\xa6\xfe\xc3\xf3\xef\x1c\x46\x86\x94\xbf\x42\x20\xb0\x9e\xe8\xa6\xb9\x68\x5f\xd8\x84\xcf\xa6\x10\xda\x8e\xf9\xf5\x7a\xab\x1b\xad\x65\xd6\xcd\x06\x43\x2c\xf0\xf8\x3c\x08\xf1\x51\x3e\xda\x84\x4c\x75\x9b\x29\x10\xc0\xfe\xa3\x8c\x52\x9f\xbd\x2f\xf1\xbf\x32\x23\xe4\x0e\xc7\xa1\xbd\xb0\x56\xbb\xac\x52\x21\xb3\xb2\x1b\xbe\xd6\x35\xe3\xe4\xcb\xb7\xdf\x52\xb9\x3c\x30\x66\x58\x62\xc8\xd9\xe3\xbb\xe0\x46\xea\x09\xe6\x7b\xd2\x27\x07\xb3\xfb\x44\xe0\xa5\xd7\x4d\x9a\xef\x6e\xe7\xaf\x5c\xcb\xa2\xf5\x79\x32\x2c\xc7\xf6\x8c\xc6\x31\x57\xa8\x8f\x59\xa1\x1c\x70\x9c\xc7\xa4\xf5\x68\x83\x21\xbf\xb7\x59\xf4\x5b\x39\x8f\xcb\xd3\x2c\xba\x78\x1c\x9a\xd4\x2c\x1a\x02\xb8\xa8\x32\x6d\x6b\x15\x69\x1b\x28\xf2\x7a\x78\x1a\xfb\x3a\x2a\x49\x7f\x8b\xc3\xe1\x4b\x8a\xf6\x05\x38\xea\xec\xc7\x06\xc9\x61\xf0\x2d\x13\xa7\xac\x54\xa2\x77\xe8\x8e\x8a\x81\x37\xae\x3a\x71\x98\xc4\xbd\x73\x13\xda\x0b\x62\x77\x08\x47\xce\x11\x76\x09\xc2\xd5\x06\xb4\xc2\x3c\x60\x9a\x50\xcf\x5b\xad\xc0\x65\xb1\xb0\x80\xf5\xfa\x10\xb6\x01\xbe\x88\x0f\x21\x6b\xde\xda\x2e\x8e\xe3\x21\x6d\xe5\x1b\x79\xca\xc8\x20\x48\x44\xe9\x8c\x68\xb0\x39\xca\xd1\x2e\x52\xc5\x20\x5b\x06\xa8\x0a\xd2\xce\xb9\xbd\x32\x32\x15\x8e\x82\xb2\x61\x9d\x83\x8b\xfa\x20\x17\xa3\xe8\xa8\x01\x62\x02\x9c\x51\x70\x1c\x61\xbf\xd9\x2b\xed\xa4\x6e\xfa\xe2\x10\x7b\x72\x25\x75\xe8\xab\x8f\x3f\xd6\xd3\x97\xe9\x0f\x61\xea\x1b\xe9\x01\xe9\x4f\x98\xf8\x06\x4e\x93\x7e\x82\x6e\xd8\x5f\x7a\x5b\xfa\x9a\xd9\x2b\xf5\x4a\x5f\xc0\x00\x64\x94\x18\x9d\x23\x1a\x3d\xfb\x14\xc9\xcd\x9f\x28\x54\xfb\x79\x1b\x00\x51\x0b\x65\x60\x0c\x4c\xaa\x54\x28\xdd\x52\x4a\x81\xd2\x48\x29\x92\xc6\x42\x21\xfb\xc0\xa2\x35\x99\x10\x2e\xf2\x98\x18\x2d\x82\x49\x5a\x65\x5b\xdb\xd7\xc7\x52\x50\x14\x9f\x52\x9d\x10\x3a\x71\x1a\x34\x31\x13\x90\x2c\x1c\x21\x07\x56\x73\xba\x31\x2e\x92\x1d\x3f\x94\x46\xff\x7a\xbf\xbc\x30\x70\xc7\xed\xb3\x43\xc9\x51\xa3\xea\x87\xb6\x9e\x08\x7c\xf4\x8f\xaf\x3f\x3e\xf4\x8f\x6f\x3e\x64\xf9\x57\xe7\xad\x7e\x5e\x16\x08\x4e\x42\xe2\x7d\xdc\x30\xdc\x19\xe1\xe2\x42\xff\x81\x93\x7a\x04\xe9\xcf\xd2\xdf\x60\x0c\xa1\xa5\xe1\xd0\x2f\x7d\x0d\x64\xde\x01\xa6\x85\x59\x47\x64\x1b\x2d\xc4\xa3\x58\x36\xbf\x85\xd2\x33\x7a\x24\x9b\x85\x6a\x46\xf2\x68\x4c\xa6\x10\x32\x33\x4d\x36\x4d\x22\x2b\x6a\x5c\x7d\xe4\xc9\x2b\xf1\x22\x59\x14\x3e\x81\x88\xbb\x48\x96\x02\x62\x01\xa6\x65\x4f\x54\xe6\x13\x80\xc6\x39\x53\x15\x39\xa4\x47\xaf\xbc\x7e\xe5\x32\x4c\x2a\x40\xff\xeb\xa5\x79\x1d\x2b\x25\xbb\xf4\xe3\xf7\x27\x5f\xea\x37\x2c\x27\xc2\x03\x1f\xfd\xe5\xd9\xcf\xbf\xfa\xf3\x3e\xdc\xf7\xb1\xd2\x68\xed\x10\x34\xc7\x1c\x48\x8b\x8e\x13\xca\x5c\x66\x5d\x80\x05\x20\x60\xa6\xc3\x11\x3b\x32\x24\xed\xb4\x8d\x43\xeb\x95\x09\x78\x0d\xc8\x14\xd2\x19\x38\x65\x83\x0d\x14\xf8\xda\xf2\xd1\x6d\x85\x60\x55\xa1\x4e\x8e\xdb\x99\xb8\x1a\x04\xc5\xe6\x11\x6a\x89\x66\x3d\x06\x01\xc7\xa4\x63\x5f\xa3\x07\x71\x0f\x86\xa8\xf0\x0e\xf8\xcb\xc9\x4b\x11\x2c\xfd\xee\x9b\x09\x4f\xa4\x9f\x97\x6e\xc3\xb0\x40\x33\xfe\xc4\xac\x29\x70\x26\x1a\x6b\x84\x4d\xad\xc3\x09\x1e\xfd\x44\x7a\xb3\xcc\xcf\xcc\x96\x6d\xfc\xf1\xd2\x38\xf6\x5c\xb4\x9e\x79\xb4\x1b\x8d\x11\x92\x61\xd6\xeb\x35\x50\x9c\x81\x8b\xa1\x1b\xe3\x48\x79\x73\x20\x2b\x9a\x6d\x5a\x64\x2d\x68\x5d\x1c\x05\xd0\xc3\x40\xe6\x73\x61\x48\x5e\x5f\x5c\x87\x7a\x4e\xba\x9d\x67\x73\x70\x65\xc8\x39\x31\xd6\x3c\xca\xd0\xd3\x6f\x5e\x7d\xa7\x3c\xee\xd5\x57\x5c\x51\x0f\x37\xcc\x3d\x79\xef\xb5\x57\x6d\xbc\x08\x8d\xba\x34\xae\xda\xc3\xec\x93\xae\x95\x07\xdd\x64\x3e\xfe\x8d\xa7\x1a\xfe\xb0\xef\x13\x78\x79\x08\x0f\xb9\x8c\x9f\x87\x22\x1c\xf0\x2f\xe2\x03\x0a\xa3\x3e\x27\x58\x9b\x2d\x40\xf8\x90\x22\x51\xc6\x1d\x76\x77\x88\xac\x15\xfd\x0d\xb0\x01\x2e\x9c\xa3\x40\x2a\xa2\x17\x4a\x9f\x36\x3d\xbb\x88\x5a\x48\xdd\x4c\x55\x0b\x9a\x49\x6c\xde\x3d\x73\xee\x43\x5b\x15\x76\xa1\xf7\x7b\xde\xb8\x37\xe7\xc2\xa2\x77\x3e\x70\x63\xcf\x75\x9b\xa9\xc1\x98\x62\x48\x1a\x41\x22\x23\x95\xa3\x02\xb9\xbf\x51\x92\x2b\x7f\x1f\xd0\x83\x0a\xd0\x2a\xa4\x2b\xbc\x76\x4d\x34\x5a\x02\xbc\x25\xde\xca\xaa\x72\x4b\x56\x2c\x87\xd1\x92\x44\x49\xb3\x98\xf0\x07\xd0\xd6\x1f\x70\xb1\x1c\xe7\x72\xd1\x2d\xa2\xcb\x56\x0c\xc3\x4e\x55\x9a\x99\x9c\xc3\x9d\xb8\x8c\x69\x05\xa8\x9c\x36\xb9\x5c\xc6\x32\xd4\xc9\x2b\x56\xe0\x14\xf3\x93\x77\xca\xa0\x45\x5b\x9c\x63\xfe\xc0\x6d\x67\x8f\x80\x5f\xec\x79\x0e\xe7\x99\x33\xab\x30\x6a\x59\xd1\xd6\x27\xcd\x9c\x6d\x47\x80\x46\x3e\xfb\xe8\x0d\xb3\x73\xc9\x73\x88\x81\x99\x42\xc6\x69\xb5\x9a\x62\xac\xcb\xe5\xe7\x6c\x36\x60\xf2\x9b\xe2\x89\x68\x20\x14\x68\x17\xad\x3c\xcb\x77\x88\x31\x06\x3d\x94\x18\x1b\xf3\x86\x68\x97\xdf\xeb\x47\x8b\x82\xf3\xa2\xc7\xf2\x4a\x5d\xdf\x07\x53\xf0\x70\x32\x39\x29\x8b\x9f\x91\xec\x2e\x22\xd8\x32\x6e\x2f\x22\x81\xba\xff\xb6\xe7\x1e\x79\xfc\xc9\xdb\xa5\xc3\x27\x8f\xde\x72\x35\xbc\xea\x66\xe9\x45\x69\xf1\x8f\x6f\xf4\xbc\x7f\x6f\x17\x35\xe0\x0d\x5a\x7b\xc7\xd5\x3d\x2f\x5d\x47\x39\x1e\x7e\xfe\xfa\x97\x4a\x7a\x5e\x43\xb8\x72\xbe\xf4\x4a\x8e\x13\xca\xbf\x18\xed\x6f\x97\xf7\x1e\xa1\xbf\x41\xeb\xb9\x02\x0c\x12\x42\x09\x8d\xc5\xef\xaf\xe0\x35\x4c\x65\x95\x25\x41\xf3\x1e\x0f\x32\xce\x3c\x4c\x05\x4d\xa7\x14\x9b\x33\xb7\x97\xc9\x4c\x4c\xaa\x87\x28\xa9\x14\xc2\x1a\x46\x15\x54\xcf\xb0\xcb\x6e\x2e\x8b\x26\xef\xaf\xf8\xba\xed\xe3\x05\x5f\xfc\xbb\x6e\xfa\xb5\xef\x2c\x5c\x74\xfb\xf5\x1b\x67\xc7\x87\xbf\x70\xdf\x7b\x3f\x0e\x9d\x75\xe5\x75\x57\xce\x1a\x7a\xf7\xda\x49\x8f\x97\xc7\x87\x67\xa2\x25\x1f\xec\x9d\x74\x79\xc7\xc8\xa6\xd4\xe2\x96\x8e\x05\x63\xb7\x41\x77\x7a\xf7\x96\x69\x2b\xce\x19\x50\x55\x39\x7c\x7a\xd3\x95\x37\x8d\xa9\xdd\x85\xfa\x3d\x1c\xd9\x35\x7b\xd0\x3a\x4e\x81\x06\xc1\x6f\x8d\xf1\x01\x0c\x79\xf9\xd2\x32\x5d\xc0\x51\x52\x82\x54\x67\x89\xcb\x61\xcc\x8a\x0e\x5b\x91\x87\x2e\x8f\x84\x06\x92\xea\x31\xd4\xa9\xc5\x3e\xb0\x21\x8f\x7a\x2c\xd3\xe4\x62\xfb\x79\x78\x7c\xf8\xb9\xeb\x9b\xc7\x4d\x6c\x59\x5c\x5f\x5e\x7d\xe7\x9c\xf5\x0f\xd5\x4d\x9b\x25\x6e\xfe\xcb\xa5\x67\xd5\x56\x56\xed\x38\x13\xa9\x7c\xdd\xb0\x49\xa3\xaa\x6a\xfd\x67\x0f\x1c\x95\xad\x5e\xf0\x56\xf8\xa6\xcb\xcf\x98\x35\x32\x1a\xec\xf7\xc7\xed\xa3\x56\x7e\xe3\x08\x92\x7c\x58\xb4\x7e\x87\x63\x3f\x34\x3d\x91\xcc\x23\x06\x61\x0a\x96\xdd\x44\xf4\x7f\xa3\x10\xf1\x71\x1c\x9b\x30\x1a\x43\x2c\x9b\x2a\xf5\xa3\x05\xe1\xf7\x53\x16\x4b\x14\xe3\x79\x0a\xa9\x21\x2a\x50\xec\xf5\xca\x41\x60\x45\x6d\x92\xc0\x48\x7b\x2e\x3c\x52\x2e\x7a\x4e\xba\x0f\xd5\x62\x38\x58\x03\xb1\x23\xce\xde\xb8\xad\x76\x48\xdb\x25\x97\xb4\xb5\x5e\x36\x26\x23\xd4\xc4\x2a\x6b\x7b\x5e\xaf\x39\xab\x29\x93\x69\x1a\x2b\x4d\xe6\xbe\xd8\xcf\x54\x46\x2e\x69\x6b\xbb\x64\xda\x93\xd7\x9c\xb8\x63\xd3\x62\xfe\x32\xb6\x72\x4c\x7d\xa6\xa9\x29\xd3\xef\x0c\x62\x13\x4b\xe3\xa8\x21\xcc\xd5\xc8\x16\x39\x43\x48\xf8\x42\x21\xb7\x86\xe3\x12\x49\x33\x00\x49\x67\xd0\x17\x44\x5b\x95\xe0\xf6\x59\x6d\x51\x4c\xd9\x84\xa3\x99\x71\x30\xb3\xaa\x2e\x71\x9c\x0a\x9e\xe3\x50\xad\xd1\x24\xab\xa0\xa2\x18\xe6\xa1\x8a\x1c\xf9\x28\x15\x62\x80\x52\x43\x6e\xbf\x45\x68\x91\x63\x98\x03\x15\x1d\xed\x72\xa0\xca\xe0\x9a\x41\x33\x73\x11\xcc\x59\xc3\xe2\x39\xd4\x06\x12\xab\xd2\xb3\x62\xf8\x08\x0e\xd7\xb1\x50\x62\x9e\xdc\x68\x6e\x04\xb4\x26\x60\xe2\x68\x8f\x17\x22\x25\xa3\xb1\xb8\x2c\x1d\xa2\xeb\xd4\x50\x72\xf5\x70\x4f\x9e\xd2\xc4\x49\x45\x0e\x1e\xfb\x68\xc5\x28\xb3\x57\x0e\xf8\x79\xbf\xe7\xb6\xf7\x5f\xcf\xe9\xc3\x0d\x0c\x75\x40\x6b\x3c\x31\x9f\xac\xac\xdb\xaa\x15\x4d\x28\xc7\xfd\xec\x21\xf6\x1b\x5a\x5b\x5a\xa3\xd1\xef\x76\x27\xe2\xc9\x30\x9d\x15\xc3\xd0\xe0\xc5\x21\xe0\x5a\xbf\xd5\x69\x69\x11\x9d\xae\x62\x46\x0d\x34\x54\x79\xde\x19\xa2\xe2\x82\xb0\x30\x6a\x47\x19\xaa\x06\xa5\x8c\x30\x4f\xcd\x99\x1a\xab\x19\x3b\x88\x8c\xcc\x84\xf8\xb5\x03\xd0\x40\x5d\xf6\xc8\x96\xca\x6b\x1a\x98\xdb\x76\xf0\x17\xdf\x71\x17\x19\x19\x1c\xc2\x23\x0f\xd5\x98\xf7\x0f\x7b\xb8\x2f\x65\x3b\x23\x29\x8d\x26\x63\x15\x04\x43\x84\x88\xd6\x0d\x2c\x6e\x8b\x93\x0e\x85\x3d\x4e\x27\x1f\xb4\xf1\xb6\x0e\x91\x47\x96\x32\x4f\x1b\x28\x64\x2f\xab\x33\xb1\xcf\x70\x39\x48\x95\x05\x79\x89\xf3\xe8\x31\xe2\xea\xe9\xc5\xa1\x53\xd4\x81\x75\xe5\x63\xb8\xd0\x88\xe6\xab\xe6\x3e\x38\xa1\x28\x72\xea\xc1\x17\x7c\xee\x35\xc7\x42\x4b\x5f\x5b\xc5\xfc\x2d\x17\x39\x45\x6a\x12\x21\xfc\x57\x8b\xf0\x5f\x29\x38\x4b\x28\xb1\x1b\xe2\xc8\x54\xf7\xbb\x10\xf8\x2b\x2b\xf7\xd3\xed\x68\x89\x68\xcd\x6e\x9b\xd1\x8c\x60\x6b\x89\xd7\x4c\x6b\xb9\x8e\x1c\xe8\xcb\xec\x53\x8c\x83\x3c\x50\xca\x64\x0a\xce\x40\x91\x79\x83\x10\x46\x42\xb5\x75\x6c\x51\xd5\xe9\x42\x54\x81\x8a\x9a\x34\xb5\xf7\xdc\x2f\xfd\x72\x52\xfa\xaf\xf4\x0b\x76\x3b\xc0\x59\x7b\xde\xea\x86\xc1\xf3\xcf\x55\x30\x13\xcb\x2f\x7f\xb6\x56\xf2\xfe\x78\xf4\xc7\x4f\xe9\x7e\xc4\xbe\x39\x2c\x6d\xd8\xfd\x24\x5d\xe6\xab\x97\xf6\x45\xdb\x4a\x55\xe8\x24\x8f\xb1\x1f\xe1\xbd\xb5\x08\xef\x95\x82\x73\x85\x6a\x87\x59\xe7\x72\x31\x44\x1e\xc6\x4c\xc4\xc1\x2b\x5e\x6b\x73\x5b\x6c\x96\x66\x24\x8d\xcd\x6a\x74\xb6\x8a\x3a\xa3\x4b\xcb\x34\x8b\x5a\x5e\x9d\x18\x39\xc9\x8a\x05\x2b\xd4\x04\x4e\x39\xdb\x21\x6f\xd9\xd9\x9d\xf8\xc0\x04\xcb\x59\x24\x1b\xb3\x76\xfd\xc6\x4b\xa4\xef\x75\x67\x3c\xdb\x78\xf4\x52\x18\xda\x72\xf9\x85\x37\xc2\xcc\xa4\xf1\x8a\x68\xf4\xbf\x2e\xde\x95\xe9\xe9\xf6\x56\x8e\x4b\x0d\x84\x4e\x6a\xb6\xb7\xb2\xa7\xa3\x2b\x4c\x7d\xe3\xad\x7c\x33\xd2\x9c\x2c\x10\x0c\x82\x79\xbd\x3f\xb2\xd8\xf7\x53\x86\x6d\xd4\x54\x34\x10\xb7\x68\xe3\x5a\x8f\x9e\x76\x78\x1c\xe5\x69\x4b\x30\x16\x9c\x21\x1a\xa2\xd1\x98\xd5\xef\xe7\xb5\x31\x9a\x07\xed\x68\x32\xa9\xce\x3d\x5c\xa5\x23\x63\x2f\xda\xfc\x14\xfb\xa2\x0e\xdb\xa8\x72\xad\x0e\x1a\x9f\xa3\xa3\x4d\xd0\xed\x02\x0a\x52\xef\x07\x1a\xe5\xf3\x1e\x2e\x4a\x13\x4f\x38\xf5\xdb\x97\x9f\x3c\xfd\x90\x9f\x1a\x88\x4f\x21\xde\x6c\x32\x7c\x08\x7a\xa5\x5d\xd2\xf3\x08\x74\x77\x43\xf0\x81\xa1\xe9\xcd\xec\xc0\x11\x1c\x35\xd0\xff\xf0\x53\x9f\x0c\xff\xea\xd7\x57\xbf\xe7\xe1\x24\x69\xf7\x7a\xdb\xf9\x51\xe9\xcb\x83\xd2\x51\xe9\x6b\xe8\x87\xb6\x83\x30\x14\x3d\xdf\xb6\x1e\x8e\x95\x1e\xe2\xbf\x7f\xf5\xb7\x2f\x95\xf9\xc7\x1c\x65\x5b\xd0\x4e\x8f\xf6\x17\x4f\xc4\x40\x5b\x23\x74\x24\x9e\xe0\xf4\x8c\x86\x41\xf3\xcf\xa3\x61\x80\x29\xef\x40\xeb\x6b\x91\x92\x25\xd1\x77\x92\x11\x5d\xac\xec\x34\x44\x4d\x33\xd4\xbf\x0a\x27\xd8\xa8\x61\xe1\x41\xf6\xf8\xb8\x29\xf3\x3b\xe6\x0c\x90\x7e\x71\x16\x4f\x2d\xea\xd2\xe9\x1d\x21\x0e\x2d\x15\xe1\xfa\xc5\x3d\xdd\x3f\x1e\xc5\x7d\x74\x03\xa0\xf1\xa2\xbd\x3b\x00\x6a\x05\x8f\x39\x18\xe2\x8d\x76\xda\x69\x47\xf6\x72\xc0\x6b\x67\x74\x66\xa3\xb9\x5d\x34\xe6\xcb\x5f\x2b\x63\x4d\x76\x41\x55\xad\x68\x55\x15\xa7\x7a\x7a\x64\xaf\x16\xfb\x61\x34\xd4\x7f\xd0\x94\x72\xe9\x3e\xac\xe8\xa4\xb2\xdb\xa9\x86\x6e\x78\x35\xac\x1a\x7e\xd3\x94\x89\x2d\xcc\xa0\x4d\xce\x33\x9b\x7a\x9e\x93\x04\xac\xef\xe0\xb3\xd4\xdf\xe5\x9a\xd6\xb0\x67\x41\xbb\xff\x17\xe2\xbb\x90\xc6\xb0\xb3\xd9\x75\x20\x01\x04\x21\x1a\xf4\x78\x92\x25\x61\xad\x36\x51\x12\x63\x5a\xc4\x18\x08\x99\x7c\x1e\xb4\x63\x34\x8b\x3e\xab\x89\x6b\x11\x4d\x81\x82\xa8\x1e\x34\xb5\x89\xf2\x53\x37\x0a\xe5\x8c\x18\xf7\xd3\x42\xe5\x37\x8b\x46\x28\x77\x97\x93\xbb\xcb\xce\xae\x4e\x45\x2a\x9a\x26\xc5\xa4\xc4\xf0\x8e\xa5\x67\x8d\x1f\x87\x3d\xef\x67\x2d\xaf\xf5\x49\x9b\x3b\x60\xf7\xad\x12\x9c\x5f\xb5\xe1\xc2\x49\x02\xd3\xb5\xd0\xd9\x32\xf1\xc4\x90\x07\xd6\x8f\x75\xbc\xd1\xe1\xbe\xe2\xfa\x33\xe8\x45\xc8\x78\xf6\xf7\x2c\xa4\x5f\xba\xec\x72\xbc\x6f\x90\x38\x2b\x52\xbf\x7f\xb2\x50\x65\xb1\x9b\x1d\x0e\x64\x8c\xb2\xac\xd9\x63\x36\x00\xc6\x1f\x00\x0e\x1f\x32\x90\xed\x14\x8d\x2d\x4e\x9a\x36\x7a\x7c\x0e\xb3\xc6\xa8\x41\x8a\xd1\x48\xe7\xe2\x78\x32\x7d\x3c\x9b\x6a\xc1\x31\xa5\x24\x73\x03\xe6\x39\x51\x4f\x2c\x79\x9c\x16\x0f\xd1\xdc\x20\x09\x79\x33\xe1\x62\x84\xb6\xcf\x85\x4d\xc7\x7f\x99\x16\x1e\x4d\xdf\x2c\x3d\x03\x13\xc8\x50\xee\x84\xb1\xa5\x3f\xd4\x0e\x1e\xe3\x3f\x69\x98\x4e\x0d\x6e\x83\xc7\x9d\x07\xe1\xd0\x73\x24\x4d\x5b\xcf\x73\x2e\x23\x04\xd2\x1a\x59\xc7\x90\x98\x2f\xba\x0b\x19\x2b\x6d\x42\x05\xf0\x42\x0f\x34\x5a\x0c\x56\xab\x47\xeb\xe1\x0d\x4c\x20\xe8\xb1\xb9\x6c\x59\x11\x98\xcc\xa6\xac\xe8\x35\x9b\xf5\x2e\xab\x01\xea\x61\x56\xd4\xf3\xbf\xe3\x91\xed\xd3\x6f\x48\x47\x65\x08\x17\xad\xe7\xe2\x38\x30\x47\x9e\xc9\x51\x9e\xce\xf0\xf0\xd8\x3f\x20\x37\xf0\x4a\x5f\xa6\xda\x7b\xf2\xe4\x89\x77\x20\xfb\xde\xa7\x03\xe6\x3a\xc3\xd5\xd4\xee\x6f\xdf\x81\xcf\x4a\x1b\xfd\xce\x97\xa5\xe7\x2b\xe1\xba\x36\x38\x9e\xb3\xad\x3a\x5e\x2b\x6d\x68\x93\xfb\x9c\x46\x7b\x8f\x1d\x8d\x77\x18\x9c\x29\x94\xf8\xac\x76\xaf\xd7\xea\x42\xe3\x1a\xa4\x83\x91\xa8\xd7\xe1\x46\x1b\x8f\xcd\xe7\xb3\xb6\x8b\x3e\x1f\x70\xd3\x40\xd7\x2e\x82\x80\x9a\xc9\x57\xdd\x07\x39\x3b\x54\x28\x0a\xd5\xc0\x0d\xa2\x41\xd2\xb0\x3e\x3f\xd8\x44\x89\xc0\x7d\xef\xbc\xcc\x8c\xf4\x56\x3f\x30\xed\xc5\xd7\x3e\xfb\x68\x21\x7c\xf8\x91\xaf\xda\x42\xa3\xe9\x5a\x29\xdb\x03\x9d\xd2\x1b\xd2\x68\x01\x0e\x7e\xad\xb2\xe1\xd8\x77\xff\x3d\x36\x9e\x6a\xe4\xdf\x85\x43\x5b\x7b\x9e\xb3\x4b\x1f\xf5\x4a\x3d\xd2\xc7\xa8\xcf\x8d\xa8\xcf\x49\xd2\xe7\xd1\x42\x82\xb7\x6a\x35\x76\x83\x5d\x4b\xd3\xa4\xcf\x1a\x34\x3d\x6c\x1a\x0d\x20\x19\x42\x3a\x1a\x78\xf2\x3d\x2e\x60\x08\xcc\x9d\xf3\xc9\xc6\x23\x31\x76\x1b\xa0\xca\xf0\x0e\xf9\x9c\xb5\x4e\x4e\xf8\xa8\xb5\xd2\xb7\xd2\x1b\xd0\xd9\x23\x65\xe9\xda\xd1\x21\xf1\x6f\x8f\xc0\x87\x17\x7e\xf4\xd9\xeb\x2f\x4c\xdf\x56\xed\x1d\xc9\xbc\x2c\x8d\x86\x25\x90\x86\x00\x96\x38\xa8\xd1\xad\xd2\x4b\xef\xf2\x3d\x7b\xc7\xff\xf7\xd8\x77\xc7\x1a\x2a\x5f\x93\x5e\x16\xc8\x38\x8f\x41\x78\xf3\x42\x34\x37\xf0\x69\x6b\x99\x55\xe3\xa4\xec\xac\x57\xcf\x52\x1a\xec\x68\x73\x34\x8b\x36\xd6\xcb\x1a\x0c\xac\x97\x06\x5a\xad\x15\x61\x12\x2b\x70\xb7\x14\x75\x5c\x2e\xbf\x69\xcf\xf4\x31\xd8\x71\xbc\x06\xee\xb8\xec\x04\x8f\xa2\x9e\xe7\x83\x39\xa8\x7a\xa9\xe1\xae\x5b\xa5\x87\x29\xa9\x3a\xcc\x9d\x3f\x44\xfa\x3b\x1c\x37\x46\x8d\xe2\x40\x5d\x7e\xfa\xa1\x0f\x62\xf0\xd3\xda\xe3\xab\xac\x4e\xa9\xba\x52\xda\xba\xfb\x2e\x1c\xc0\x81\xfb\x9a\x55\xfa\x5a\x86\xe7\x71\xd4\x63\x2a\x31\x39\x69\x4a\xe7\xb3\xb8\xdd\x3e\x8a\x2e\x4f\x9b\x3d\x1e\x53\xb3\x18\xd5\x79\x9c\x1e\x27\xe0\x79\xd4\x5d\xde\x0a\x12\xc5\xdd\x25\x1e\xdb\x81\x03\x8b\x8e\xc3\xd4\x83\x55\xb9\xd3\x64\x3b\xc4\x73\x23\xaa\x4e\x63\xc8\x60\xe8\xaf\x1e\xae\x12\x09\xac\xd2\xf0\x3d\x8f\x2f\x9b\x7a\xc3\x35\x63\xe0\x38\xe9\xef\xf2\x8c\x96\xa4\x87\x61\x4d\xe3\x95\xd7\x5f\x73\xc5\xdd\x0f\x2a\xa2\x8c\xef\x7c\xc8\x61\x1a\x34\x68\x6c\x63\x25\x6c\x96\xa7\xf7\x03\x89\x07\x85\x6c\xa5\xd1\xb8\x74\xd9\x15\x0b\x65\xb1\x90\x5c\x53\xd0\xfa\xbc\x09\xe9\xea\x38\xda\x2b\xcb\xa2\x20\xcc\x30\x56\x93\x5d\x67\x0f\xb3\x61\xaf\x8e\x49\x24\x81\xd9\x82\xb4\x75\xd4\x62\xd1\x06\x02\x58\x81\x33\x5a\x66\xa6\x1c\x32\x07\x4e\xf1\x80\xab\x4b\x53\x09\x32\x80\xd8\x64\x89\x62\x2d\x3e\x0c\x36\x20\xed\xa2\x80\xfe\xbc\x05\xa6\xcd\xf0\x34\xa8\xbd\xe3\xd1\x2e\xea\x89\x93\x6f\xec\xdc\xbc\xa9\x54\x1a\x0e\xbf\xa9\x58\x7e\x7d\xfd\xa2\x74\x7c\xc4\xee\x15\x9f\x7c\x2a\x4c\xa1\xee\x19\x7e\xdb\xc6\x4d\x9b\x37\xdc\xbb\x7a\xcb\xa8\xd6\x0b\x6f\xb9\x66\x75\xd0\xb3\x0d\x52\xe9\xa7\x1e\x5c\xbd\xbc\x55\x5e\xab\xe5\xc8\x4e\xbc\x8b\x70\xbe\x8c\x10\xe2\x01\xbb\xd1\xee\xa2\xa3\x74\x34\x91\x0c\x59\xda\xc5\x50\x08\x38\x9d\xfe\xe5\xa2\x13\xcd\x7f\xa7\xbc\x50\x39\x50\x44\xe7\x9e\x2e\x3c\x76\xc0\xa7\x4c\x85\x8b\x14\x19\xf3\x71\x7b\xbe\xc4\x81\x12\x1d\x01\xf7\xbe\x70\x9b\x71\x44\x65\xc5\x65\x03\xee\xb9\xed\xca\x1b\xce\x3d\xab\xa3\x8b\x3e\x1b\x1f\x0c\x6f\x9d\x7d\xc1\xeb\x07\x7f\x76\xa6\xa1\xef\x79\x4f\xe8\xf6\x3f\xed\xb8\xc9\x43\x8d\x45\xa8\xeb\xaa\x43\x16\xa9\xcd\xf3\xf4\x6b\xaf\x1f\x92\xfb\xdb\x0f\xf5\x77\x34\x9a\x47\xd8\x5e\x49\x15\xf5\x37\xab\xf4\xb7\x55\x74\x7a\xd0\x5f\x07\x82\xdf\x56\x80\xcc\x2e\xa0\x46\xfb\xfd\x6e\xa7\x0b\x2b\x45\x16\x77\x9a\x57\x3b\xfd\xf0\xa3\x9d\x3a\x64\xd1\x2d\xed\xbf\xe6\x9a\x25\x2b\xc7\x8f\x1d\xbd\x91\xea\xc1\x9d\x9e\x33\x71\xd2\xce\x97\x0f\x3a\x43\x87\x57\x5a\x3c\xe7\x5f\xb2\x78\xba\x0d\x2e\x8e\x09\xd2\xae\xc7\x2c\xff\xb1\x6f\x58\x79\xc7\x16\xd4\xdf\x2a\x40\xd3\x3c\xb2\xaf\x92\x20\x23\xf8\x9c\xda\x64\xc0\x12\xd0\xd2\xa9\x92\x40\x32\x96\x44\xe6\x42\xcc\x6a\x70\x20\x83\xd0\xc0\x2b\xf1\x03\x7d\x43\x34\x20\x29\xe1\x5f\x40\x7f\xec\xc2\xec\xc7\x55\x30\x85\x43\xd0\x72\x36\x15\x6c\x2e\x1d\x79\xe9\xd5\x33\x1f\x7f\x74\xcc\x43\x35\x95\xb5\x67\x5d\xfa\x97\xb2\x91\x57\xac\x9e\x21\xdb\x54\xd4\xb1\xaa\x21\x65\xe9\xea\x6b\xcf\x5b\xbb\x3e\xe8\xf8\x66\xe5\xa8\xed\x75\x23\x2a\xd2\x55\x2b\x66\xac\x22\x96\x15\xf1\xeb\xf4\xfe\x86\xd6\xe6\xb3\xc8\xe6\xb6\xa2\x1d\x72\xac\x90\xb2\x21\x3b\x8b\xe6\xcc\xb4\xd9\x1f\xb0\x59\x91\x1a\xe1\x7d\x3a\x9d\xc1\xe0\x6a\x11\x0d\x36\x0d\xc2\xae\x68\x06\xd2\xcd\x22\x0c\xf4\x8d\xa1\xec\xe3\xd1\x91\xab\x98\x12\xa0\x44\x06\xd1\xc6\xe2\xca\x86\xfd\xc8\x99\xba\x16\x0e\x95\x9e\xbf\xe7\x0e\xd8\xb8\xfa\x9d\xd5\x77\xf7\xac\xfc\xe6\xe8\xbc\x73\xd2\xd9\xf1\xe3\xa5\xd1\x95\x5e\xe6\xb0\xb7\xf2\xb5\x2f\x5f\xea\x92\xfa\xbd\x77\xc6\x14\x58\xfb\xe6\x25\x6b\xe3\xc2\x64\x5c\x63\x13\xf5\x54\x42\xd8\x83\x06\xce\xa7\x00\x84\x0c\x4b\xe1\xd8\x96\xb7\x54\xa6\x90\x4c\xdc\x9e\x91\x66\xce\x44\x17\x20\x3b\x1c\xd7\x63\x78\x8a\x5c\xab\x05\x61\xc1\xcc\xb0\x10\xb0\x40\xa7\xa7\x34\x10\x1f\x54\x66\xde\xaa\x2b\x38\x78\x8e\xa2\x2f\xd2\xe8\x2f\x7c\x6a\xe6\xcc\xb7\x70\x03\xc7\x97\xa0\x6f\x42\x80\x2c\x60\xf8\x23\xfa\x17\x3e\xff\x8c\x3a\x2c\xf8\x00\x94\xa6\x9d\xbc\x9d\x9c\x7d\x5a\x0c\x90\xd5\xb0\xed\xa2\x43\x63\x40\x7f\x4c\xf8\x98\xf1\x15\xec\xf7\xb1\x17\xd4\x2f\x2e\x4a\x43\x87\xa4\x82\x61\x7d\xa6\x1e\x9f\x6a\x65\x70\xa6\x06\x9f\x81\x3f\xee\x9d\xb9\x17\xfd\x87\x5f\xe0\x2f\x92\x1e\xfe\xd2\xb6\xbb\x8d\x1a\xd0\xf3\xd7\xb6\xdd\xbd\xbd\xe0\x70\xef\x57\xf0\x2d\x12\xe3\xc6\xa8\xbc\x74\x86\x41\x9a\xcf\x6c\x84\x97\xce\x96\x02\x43\xd9\x57\xe5\x98\x71\xcd\xb7\x24\x7f\x88\xae\xc9\xe7\x0f\xa1\x6b\xf5\x7e\xf6\xe6\xdc\xb5\xd3\xf0\xb5\x38\xff\x5b\xd3\xa4\xe6\xe4\x69\xdb\xc8\xef\xcf\x90\x7f\x8f\x5d\xf3\xf8\xf7\x68\x9e\xca\xdf\x3f\xa2\x7d\x5f\xe5\x5c\xb0\x69\x41\x25\xf3\x95\x9a\xef\xa8\xb9\x90\x70\xa8\xc8\x9f\x9f\xad\x7c\x5e\x26\x8d\xa3\xff\xa2\x72\x23\xe0\xcf\xa9\x81\x6a\x3b\xba\x67\x48\x3b\xb5\x72\x3b\xb8\x1f\x72\x3b\xda\x2c\x69\x47\xfe\xfc\x6c\xe5\xf3\x6a\x69\x1c\xdb\x49\x3e\x6f\x51\xda\x07\xa7\xad\x11\xd4\x09\xaf\x94\x39\x1e\xbd\x24\x37\xf2\xfb\x6e\xbf\x9b\xd6\xf7\xe5\x78\x2c\xe0\xd8\xee\x5c\x04\xf0\xd5\x15\x76\x7c\xf5\x77\xdd\x55\xe5\x26\xcd\xff\x58\xcf\xa3\x33\x57\xcf\xc3\x81\xb9\x59\x9c\x36\x9d\xa1\xf0\xfa\xde\x4f\xd1\xf5\xe7\x17\xf0\x15\x77\xbe\x01\xc8\xd5\x36\x7b\x09\xa4\x1c\x16\x86\x3a\xa5\xfe\x42\xbe\xbe\x43\x27\xbc\x5d\xa9\xef\x80\x09\x05\xf5\xe1\xbe\xf5\x1d\xfa\xf2\xeb\x76\x92\xdc\x1a\x72\x3d\xea\x3e\x08\x2b\x0c\xbb\xbf\xcb\xf3\xdf\x09\x3b\xe5\x3a\x02\x61\x92\x8f\x79\xb2\x3b\x1a\xb4\x32\x05\xfd\xe9\xcb\xb3\xda\x49\x72\x6d\x70\xef\x51\xfb\x90\x0d\xfb\x79\xe3\xa9\xed\x6b\xa3\x6a\xfb\xfa\x4a\xea\x24\xfa\x85\x5f\xb0\xd2\x14\xac\xc0\x15\x24\xa0\xc7\x17\x90\xef\x20\xa7\x5f\x14\xf1\xb4\xfe\x59\xbe\x0f\x9a\x63\xf3\xc0\xc3\xbd\x5f\x92\xdc\x9e\x87\xc1\x61\x90\x12\xbc\x74\xb5\xa0\x37\x37\x55\x53\x98\xe0\xd4\x46\x08\x4d\x77\x12\x12\xd3\x12\x60\x27\x89\x5c\x98\x45\xa7\xa8\x0f\xae\x5c\x1f\xaa\xa8\x93\xe8\x32\xb9\x0f\xfd\xe4\x3e\x84\x6b\x7f\xaf\x0f\x9a\xc5\xc5\x7d\xc0\xfc\x0c\xe0\x53\xf0\x65\xae\x5d\x77\xae\xdd\x6a\xd4\x6e\x4a\x69\xb7\x54\x6e\x77\x60\xfd\xef\xb6\xbb\xa4\xa0\xdd\x87\x88\x6c\x9d\xe0\x21\xf0\x25\x1a\x4b\x13\xdd\x4f\xb0\xb9\x9a\xfa\x61\x01\xfb\x61\x92\x84\x22\x39\xf2\xf7\xab\x29\xb8\x5f\x95\x7c\xbf\xda\xf0\xff\x91\x1c\x0f\x11\x39\x46\x82\xc5\xe8\x7e\x14\x38\x03\xfd\x7e\x28\x39\xfb\x08\x80\xc1\x42\xc8\xa7\xf3\x3a\x81\xd5\x69\x45\x86\xa3\x0f\xb3\x10\x38\x4c\x0e\x17\xce\xc0\x20\x94\xeb\xb6\x53\xbd\x8e\xc4\xd5\x53\x47\x0e\x3c\xfa\x91\xa8\x07\x6d\x3d\x71\xbb\xe3\xe3\xd6\x88\xbd\x1e\xbb\x1b\xa3\xc8\x20\xef\x1c\xba\x62\x4e\xff\x5b\x6b\x6a\x1e\x38\xe7\xf0\x1b\xfb\x5f\x90\x6e\x87\x17\xcc\x5d\x28\x5d\x34\x15\x7e\xe4\xb8\xe1\x8e\xac\xc3\x38\x20\x5c\x75\x44\x3a\xf1\xf3\x4f\x70\x73\xab\x74\xde\x8e\x6d\x4f\xde\x51\xb0\x76\xc9\xfc\x49\x28\xf3\x07\x73\x8f\x86\x04\x3d\x43\x53\x25\x6c\x89\x52\x4f\xcb\xe9\x92\x17\xb0\x22\x76\x6e\x0d\xff\x59\x5e\xc3\x48\x23\xcc\x5b\x22\xcf\x9e\x25\xf2\xec\x61\x86\xe1\xc1\x1d\x46\x53\xff\xe3\xec\x39\xcd\xfd\x6b\xc9\xfd\x0b\xea\x9f\x14\xdc\x5c\xcd\xc1\x92\xef\x7d\x48\xbd\x37\x75\xe7\xa2\x6e\x72\xef\xc5\xe0\x17\x9c\x25\x5e\x66\x2f\xc9\x71\xf1\x69\x76\x93\x1c\xb7\xd5\x72\xde\x1a\x75\x44\x59\xdb\xe5\x68\x6d\x7f\x52\x5a\xae\x8b\x16\xad\x25\xc2\xa9\x4f\xf2\xdc\x76\x28\x39\x71\xd3\xe5\xb5\x47\x0f\xb7\x97\xd0\x9a\xc6\xe1\x8e\xf2\x82\x7a\x19\x50\xe6\x2d\x44\xd8\xb2\x14\x9c\x23\x54\xba\x74\x91\x40\x20\x45\x51\x16\x1d\x5d\x56\x0e\x43\xe1\x50\xbb\x98\x0a\x97\x44\xe3\xd1\x76\x31\x1c\x0f\xc7\x59\xa3\x91\x6b\x17\x8d\x0c\xeb\x6d\x17\x59\xae\x0f\x68\x2e\xda\x95\xdc\xaa\x9b\x19\x6f\x4b\x7c\x41\x28\x59\x9f\xe8\xb1\x7a\x95\xb9\x53\xcb\x67\xd8\x55\x2b\x0b\x82\xc8\x8e\x7d\x55\x14\x39\x26\xfd\x07\x9a\x71\xf4\xd8\x4a\xe8\x7a\x27\x1f\x40\x36\x44\xfa\xbc\x28\x70\xec\x8e\xb6\xf5\x38\x72\x6c\x3d\xde\xcf\xa4\x31\x74\x2f\xe3\x47\xda\x76\x00\x10\xd0\x1e\xb4\x5e\x18\x37\xd4\x68\x1c\xd8\xa8\x1f\xad\x8f\x59\xfa\xdb\xdd\xbe\xa8\xb5\x26\x80\x86\x7e\x60\xc0\x6e\xb1\xfa\x58\x4d\x99\xa6\xac\xe9\xcc\x70\x65\x56\xb4\x86\xc3\x43\x9d\xa3\x81\x56\xa7\xcd\x8a\x8d\xe5\x3a\x1d\x3d\x74\x68\xb2\x55\x1c\xca\x3b\x33\x59\xd1\xe7\x71\xda\xe8\xe1\x59\xf9\x48\x12\x09\xff\x4a\xa6\x10\x62\x67\xf2\xce\xc3\x02\x5b\x2d\x5f\x81\xd9\xae\xa4\xe3\xd8\xe5\x68\x29\x39\x94\x02\x6d\xd6\x24\x5c\xb3\x41\x71\xb0\xb9\x1b\xdc\x5a\xb9\xa8\x5e\x4a\x8b\xf0\x62\x14\xa1\x1a\x84\xc1\x0b\xdd\xf1\xf8\x08\x2b\xaa\xd1\x46\x59\x34\x7e\xd1\x10\xa4\x5f\xa8\x3e\xf6\xec\xb3\x6f\x30\x93\xe7\xc5\x96\x0e\x1c\x7f\xcf\x3d\x2f\x3d\x9b\x5c\x1a\xfe\x34\xbe\x66\xe4\x5f\x76\xb7\x8e\x69\xa4\x9b\xfa\x43\xd7\xa6\x0d\x74\x59\xcf\x8f\x0b\xce\x9d\x3e\xf7\x82\x99\x1d\x70\xf7\x98\x33\xa4\x5b\x1b\xdd\xd4\x78\xe9\x81\xeb\xb6\x44\x7a\xf6\x68\xaf\xf8\x7c\xde\xa2\x8b\x2f\x68\x1b\xd5\xca\x4d\xad\x7f\x62\xec\xa1\xcd\x3b\xac\x86\x85\xe9\xf5\x67\xdd\x72\xdf\x76\xeb\x4a\x7b\xe8\xda\xa5\x15\x6d\xd4\x9c\x2b\x56\x5c\x77\xf1\xe2\x6b\xaf\xbd\xb4\xe7\xf8\x40\xa1\xa1\xf9\x6f\xe3\x86\x35\x8d\x00\x05\xbc\x97\x79\x2e\xce\x4e\xf8\x94\xb2\xaf\xa5\x30\xff\x68\x59\x52\x13\x2e\x9a\x9f\x7d\xf9\x38\x3b\x01\xe6\x1c\xe6\xbb\xe9\x33\xd0\xf4\x7c\xba\xf7\xbd\xee\x33\x47\x3b\xcd\x05\x7b\x09\x8e\xcd\x7a\x82\xb4\x5f\xa5\xb4\x2f\xc8\x7b\x4f\x84\xec\x3d\x5b\xba\x63\x21\x87\xa6\xe0\x7a\xc2\xa1\x45\xb8\x2b\xc7\xab\xed\xc3\xe5\xe4\x7a\x0a\x5f\x7f\x08\x5d\xef\xc9\xef\xb4\xb8\xee\xe4\x02\x12\xf7\x80\x73\xca\x90\x85\xeb\x73\xd0\xb4\x5b\x17\x31\xeb\xcc\x25\x29\x01\x13\x23\x46\x52\x94\x9f\x36\xc4\xdb\x45\x03\x03\xf8\x0e\x11\xb0\x6c\x10\x19\xea\x78\xf6\xcb\xd9\x15\x64\x02\x14\xc4\x38\x90\x17\xac\xe7\xf0\x99\x4a\x43\x82\xc4\x07\xe0\xb9\xcf\x6a\x14\xeb\x50\x53\x18\x20\x40\x2f\x5f\x78\xe9\x60\xe9\x35\x69\xaf\x12\xf8\xf0\xb5\x74\x24\x71\xc6\xc8\x21\x03\x46\xf5\x9c\xa5\x06\x08\x48\x0b\x96\xcc\x9e\xdc\xac\x81\xb3\xe0\x58\x25\xf8\xe1\x55\x69\x9b\xaf\xe9\xac\xb1\xcd\x2e\xa1\x8a\xc9\xf4\x8d\x10\x90\xcf\xa9\x17\xd0\x4f\x20\x5d\x8d\x65\xba\x4e\x88\x47\x18\xab\x55\xef\xf4\x21\x55\x52\x92\xb2\xa5\xb6\xa4\xf6\x60\xa6\x47\x90\x7a\x27\x75\x34\x45\x37\xe2\x37\x14\x21\x7b\xf4\x0c\x1f\xdb\xd4\x98\x82\x36\x59\x6a\x21\x45\x03\xfc\x2b\x99\x11\x52\x70\x25\xab\x9a\xdc\xc1\xac\xe8\xb6\x99\xd0\xba\x30\xd9\xed\xf1\xac\x48\xd9\x5d\xc5\xa3\x40\x38\x1c\x17\x2f\xc6\x24\x8e\x17\xf7\x19\x0d\x5b\x5e\x7e\x72\xda\xa4\x46\x28\x17\x55\xef\xa5\x9f\x90\xb6\xc8\xe2\x9f\x87\x86\xe5\xe5\x97\x3f\xfa\xe4\x83\x8f\xbb\xd5\x00\x03\x78\x58\x1a\x53\x3d\x7e\x0c\x11\x7b\xc9\xec\x49\x59\xe3\x89\x6f\xbf\x3f\xf9\xcb\x7f\x72\xe1\x05\x84\xb7\x61\x81\xcc\x3b\x83\xf3\x45\x73\xbc\x33\x58\x57\x96\x61\x9e\x98\x54\x99\xce\x5c\x8c\x83\xf0\x38\x61\x5d\x89\xeb\xd4\xe5\x72\x82\xc9\xf5\x76\x72\xbd\xb3\x0f\x0e\xc2\x3e\x27\x3c\x17\xe1\x1f\x94\xb9\xf5\xae\x32\xd7\x31\xef\xac\xa1\x34\x41\x07\x8b\xae\x8f\x22\x9b\x67\x02\x9e\xeb\xb8\x32\x2a\xc6\x70\xe7\xc9\x28\xa8\x04\xa1\x20\x50\x9a\x60\x82\xf9\x79\x4b\xf8\xf8\x26\xe2\x6b\xe1\x6f\xf2\xb5\xcf\xc9\xd7\x7a\xd0\xb5\x0b\x7d\x2e\x4d\x61\xbd\x2d\x82\xd3\x09\xe6\x4d\x11\x0c\x3b\x54\xc5\xbc\x04\x93\xe7\x3f\x9f\xa6\x7c\x2e\x63\xf1\x75\x0a\x16\xd7\xca\x58\x3c\xb7\x76\xff\xa6\xae\x5d\xb0\x1c\xbe\x59\x20\xcf\x19\xb1\xd3\xaf\xdd\xf5\xea\xda\x55\x78\xf6\xf1\xde\x32\x06\x2d\xde\xc9\x23\x0a\x56\xae\xca\xd5\xa4\x35\x21\xbb\x1f\xed\xac\xc2\x20\x64\xde\xb8\xac\x25\x25\xda\x40\x54\x1b\x4d\x95\x5a\x60\x87\x88\x43\xc0\xad\x96\x46\x4b\xb3\x85\x36\xd2\x96\xb0\x25\xcc\x1a\x78\x9b\x59\x67\xd0\xe1\xc0\x4f\xda\x2b\x87\x7d\x26\x58\x47\x3e\x38\x56\x89\x4b\xcb\x97\x44\x4c\x17\x86\x53\xc8\x11\x89\x30\x5a\x78\xca\x6d\x8f\x16\xc6\xa5\xa9\x11\xb2\x08\x72\x30\xe1\x9e\x4e\x42\xdc\x94\xa3\x5e\xed\x38\x6f\xf2\xfc\x4b\x61\xe8\x99\x9d\xd2\xe5\xd4\x75\x98\x60\x55\x2d\x7f\xd4\xf3\x23\x65\x25\xce\xf4\xf0\xc5\x33\x96\x4d\x53\x43\x64\x21\x4f\xd6\x5a\x0c\xcd\x89\x0c\xd2\x1f\x36\xb4\xda\x90\x5d\x6b\xc7\x76\xad\x13\xd9\xb5\x3e\xbf\xcd\xde\x81\xcf\xed\xb1\x5d\xeb\x9e\x81\xd4\x07\xf6\xfd\x6b\x68\x48\xb7\xff\xff\xb0\x6b\x01\x36\x6c\xe5\x30\x2f\xb8\x4e\xba\xed\xe1\x87\xe1\xfc\x6b\x5e\x79\xb8\x5b\x7a\x48\x7a\xfc\xc8\x7f\x16\xcf\x5d\x75\xa5\x34\xba\xde\xaf\x11\x7d\xf5\xaf\x7e\xd0\xfb\x8d\xf4\xae\x34\xec\xda\x19\x0b\xd0\xe4\x37\xdf\xbe\x73\x83\xca\xe9\xa5\x4d\xe5\x78\xc6\x46\xc2\x8b\xe0\xed\xf9\x3a\x60\x7f\xed\x76\x79\xed\x85\xf8\xbd\x88\x6b\x0c\xd7\x5d\x98\x87\x35\x34\x8c\xd9\xf1\xd5\xdb\xbb\xc3\x31\xbf\xfe\xd4\xfa\xaa\xda\x8f\x65\xfc\x63\x4b\xc9\xb5\x4c\xc9\xfc\xf8\x80\x1a\x0b\xa2\x82\x99\xa6\x4a\x69\xe6\xc2\x8a\x2a\x2f\x97\xc4\x70\x48\xea\xf6\x72\x2c\x4e\x1e\xaf\x4f\xcb\xc5\x4d\x55\x3c\xa4\x4d\x2b\x78\x28\x25\xd7\x0d\x22\x79\xd2\xfb\xe0\x9d\xc0\x87\xb0\xdc\xc4\xc6\xe1\x15\x25\xc9\x3e\x75\x84\x0a\x30\xd2\xdf\x54\x8c\x04\x96\xd3\x82\xcc\x6b\x53\x81\x6d\x37\x38\xb2\x3b\x55\xae\x8d\x16\xf0\xc5\x10\x8c\x44\xe4\xdb\xa1\xcc\xe3\x7b\x49\x2e\x36\x3d\x65\xd8\x70\x47\x99\xca\x11\xf5\x9a\xc2\x11\xb5\x59\xb9\xe6\x43\x39\x17\x9b\xc6\xa8\x7d\x6a\xbc\x04\x68\x72\xb9\xd8\xa4\x26\x07\x69\xef\x59\x90\xaf\x03\x81\xda\x9b\x11\x2f\xd1\x2b\x9c\x36\x7d\x6a\xd6\x52\x07\xa8\xab\x70\x9e\x3e\xc2\x88\x21\x19\x23\x3e\xda\xed\xf7\xf4\xc1\x88\xa9\xe2\x7a\x4f\xd4\x01\x78\xb1\x82\x2b\x6b\xed\xe4\x3b\x3b\xba\xab\xd2\xb2\x9d\xd9\xa7\xae\x6c\xbe\xa6\xc0\x41\xea\x7d\xd9\x8e\x0d\x11\x3b\xf6\x87\xee\x90\xeb\x34\x76\xec\x25\xb9\x7b\x1c\x84\x9f\x28\x3a\xb0\x16\xeb\xc0\xda\xb2\x3e\x76\x6c\x9f\x5a\x9c\x48\x0e\x37\x91\x83\xc2\xfb\x3d\x2e\x93\xf3\x76\x77\x22\xea\xf7\x16\xf5\xa9\x4f\x0d\x21\x24\xc7\x76\x45\x8e\x52\x59\x8e\xef\xbb\x93\x31\x2b\x5f\xf4\x9d\xbe\x3c\xe9\x07\xa9\x69\x05\xb8\x02\xa6\xc2\xfe\xe2\x1a\x9e\x7d\xb9\xd2\x0f\xc2\xcf\x14\x39\xd0\x3d\x28\x67\x69\x44\x6e\x3f\x67\x5f\xbf\x85\x16\xef\xaa\x7c\x3d\x4e\xd4\x27\x55\x0e\xb7\x2c\xc7\x7b\xdd\x4e\xbb\xce\x50\xd8\xa7\xde\xab\xd0\x77\x06\xe5\xea\x0c\xa1\xef\x80\xd7\x89\x1c\x14\xe4\xed\xe4\x3b\x2f\x76\x3b\xac\xb2\x65\x9e\x93\xa3\x2f\x67\xef\x41\x38\x51\xc6\x2f\x6e\x85\xb3\xd7\x6d\xcd\x5b\xfe\xe8\x1e\x47\xd1\xf5\x55\x39\xce\x5e\x7c\xbd\x95\xe0\x23\x7c\x0b\x52\x84\x88\x37\x9f\xc6\xf6\xcf\x73\x99\xe5\xe7\x55\x4c\x9e\x57\x3b\xbb\xc3\x81\xc2\xda\x8b\x7d\xb9\xcd\x8a\x9e\x47\x4c\x7e\x1e\xcf\xa0\xef\xa8\x45\x71\x94\xef\xf4\xe5\x60\x3b\x48\x7d\x29\xcf\xab\x98\x52\x13\x32\xe6\x2b\xaa\x09\xd9\x97\x87\xed\x20\x94\x88\x1c\xf8\x16\x44\x05\xc4\x7c\x79\x2f\xc3\xa9\x7c\x59\xa8\x4f\xbf\x29\x72\x94\xcb\x72\x8c\xee\x4e\x25\xf4\x5c\xd1\xf3\xb8\x15\x8d\xd5\xa6\x1c\x7f\x16\x7e\x1e\x7f\x53\x9e\x47\x44\x7e\x1e\x37\x77\x07\x7d\x56\xd8\x77\x5e\xa1\xfb\xbc\x9c\xbb\xcf\x41\x6a\x8e\x2c\x47\x39\x91\x63\x4b\x77\x79\x4c\xbe\x8b\xd2\xaf\x32\x72\x8f\x4b\x72\xf7\x38\x08\x97\x2a\xbe\x0c\x74\x0f\xc8\x45\x3c\x56\x78\x1a\x5f\x49\x9e\x8f\xe3\x00\x75\x9d\x32\xaf\x12\xf2\xbc\xda\xd5\x1d\x0d\x29\xf6\xf7\xef\xf1\x71\x1c\x80\x37\x2b\x72\xc4\x64\x39\x76\xa0\xe7\x21\xfb\x4c\x72\xdf\xe9\xcb\x55\x72\x90\xd6\x2a\xeb\x03\xf3\xcd\xc7\x13\x81\xbc\x47\xa6\xc0\x57\x92\xe7\x2b\x39\x48\xe9\x15\x39\xb0\x5a\x37\xc7\x7c\x7d\x7c\x32\x7d\xb8\xb2\x74\xfb\xe0\x45\x40\xa9\xbe\xf3\x6e\x77\x5d\x95\xcc\x6c\x75\x0a\x57\x16\xba\x0e\x1c\x51\xaf\x3b\xd1\x5d\xa9\x20\xa8\x53\x79\xad\x50\x7b\xb8\xc8\x0f\xfb\xc4\x51\x5c\xfc\xa1\x2f\xd7\x91\x0d\xb7\x73\x23\xc1\x10\x67\x29\xfb\x6b\x02\x0c\x17\xa2\xa6\xb8\x23\xaa\x8f\xc6\x2d\x3e\x86\x41\x28\x3f\x59\x12\x37\x59\x2d\x16\x13\x13\x0a\xf1\xed\x62\x88\x61\x71\x4e\x65\x26\x9f\x51\x99\x29\xce\xc0\xa8\xad\x49\x3a\x35\x0c\x5b\x5f\x01\x49\x7c\x80\x46\x8b\xfe\x95\x3f\xee\x18\x06\x33\x11\xec\x40\x66\x98\xcc\x01\x69\x8c\x74\x3f\x52\x07\x53\xb7\xdf\xbc\xee\xee\xb7\x60\x03\xac\xd8\xb6\x73\x7c\x57\x43\x7c\xc4\x55\x2f\x4c\x86\xa9\x13\xd2\x41\x38\xe1\xbe\xa7\x7e\xda\x10\x6d\x4d\x5c\xff\xfa\xc6\x7b\x9f\x34\x97\xbb\x5a\x2b\xde\x7f\xf6\xde\xb5\x61\xd7\x36\x48\xf9\xec\x4f\xbc\x2e\xfd\x77\x7d\x13\xee\xfb\xd9\xd2\x68\xea\x1b\x84\xc3\x23\x38\x67\x80\x71\x38\x9c\xc0\xc4\x78\x83\x2e\xaf\x2b\x1a\x73\x86\x21\xf0\x99\xc2\x80\xb6\x7a\x03\x56\x84\xa8\xad\x8a\xcf\x24\x97\x2e\x52\x70\x34\x59\x5b\xd3\x50\x3f\x0c\x9e\x72\x32\xc3\xf0\x4e\x24\x4d\x02\x09\x93\xd2\xbc\xd8\xb5\x75\xf2\xf4\xba\x6c\x30\xdd\xb0\xf6\xf2\xbd\xf7\x7d\x0e\xb5\xd2\x3e\xe9\x3e\xd0\xfb\x8f\xe7\xb2\x92\x10\xdf\xb1\x7e\xd9\x9c\x88\x75\x3b\xd4\x84\xd7\xdd\xfd\xe9\xc2\x51\xdf\x1f\xfc\xac\x44\x28\xff\x4b\xd7\x07\x75\x5e\x65\x3d\xac\xd1\x86\x1d\x6a\x5d\x80\x4e\x88\x50\x33\xd9\xed\x89\x7e\x92\xba\x13\x11\x96\x2b\xae\x75\x4e\x7f\xad\x2d\x73\xa8\xb5\x01\x3a\x41\x37\xdc\x24\xcf\x3b\x64\x60\x99\x4b\x62\x01\x63\x31\x06\x94\xc6\xb1\x25\xec\x19\xc0\x8f\x73\xd4\x1c\x3a\x9d\x99\xf2\x9a\xbd\x81\xa0\xd6\xe1\xe0\x79\x76\xa6\xc8\x33\x36\x0b\x26\xe8\x54\x23\x0e\x64\x2a\xfe\x82\xb0\xd9\x3e\x7c\x96\xc5\x41\xf0\x08\x23\xd9\x8a\x22\xdf\xf9\x5c\x58\x3c\x6d\xe9\xfa\xe4\x86\x2e\x99\x9a\x73\xc1\x0d\x7f\x69\xbe\xed\xbe\x2e\x69\x5c\xbd\x9f\xad\x82\xec\xdc\x13\xff\x54\xc1\xdd\x8a\x71\x43\x5f\x79\xf6\xf8\xfb\x7e\xb9\xf6\xd7\x58\x34\xd7\x76\xb0\xeb\xd0\xf3\x2a\x47\xda\x61\x99\x30\x34\xcd\x71\x38\x0b\xd4\x63\x08\x06\x6b\x2c\x94\xa5\x7f\x83\xa7\xa6\xa6\xca\x56\xd5\x2a\x06\x2d\x16\x9b\x0d\xf8\xfd\xae\x4c\x56\x74\x05\x4c\x86\x66\xd1\x04\xd8\xb2\xac\xc8\xda\x4a\xc2\x61\x40\x0e\x15\x5d\x7d\xe2\x51\xf3\xb5\x07\x55\x37\x49\x41\xe4\x66\x3e\x12\x87\xcd\xe7\x26\x63\xac\x9a\x2b\xb1\x8f\xe6\x6b\xbc\x7f\x43\xaa\x5e\x93\x2f\x6e\x22\xc7\xb2\x92\x43\x25\xf8\x86\x92\xaf\x7c\x0f\x1c\x55\x51\x75\xfe\xf2\x8b\x67\xec\x1e\x5c\xeb\x3b\x33\x30\x03\x2e\x92\xb6\xaa\x99\xcd\x74\xf3\xe0\x91\xfd\x4a\xe9\xe1\x43\xca\x6b\x9c\x6a\x0e\xf3\x31\x4f\xe5\xf1\x80\xf1\xc2\x09\xe3\x67\xde\x3e\x70\xd2\x9d\xb3\xb8\xbf\x4f\x84\x5f\xc8\x99\xce\x27\x16\x26\xea\x8d\x67\xb7\x56\xe1\x9a\xaa\x38\x06\x89\x9d\x0b\xe2\x68\x0f\x5b\x2c\x24\x80\x87\xd7\x94\xd3\x8e\x92\xf2\x00\x1f\xa1\x4b\x78\xda\xaa\xb7\xea\x2b\xab\x3c\x5e\x5c\x01\xda\x11\x2a\x0d\x95\x76\x88\x1e\x52\x5f\x40\x6f\x6e\xf2\x84\x3c\x21\x60\x02\x71\x64\x39\x9b\x4c\x89\x0e\xd1\x24\xbb\x8d\x94\xbc\x43\xe2\x37\x92\x53\x58\x33\xe9\x3e\xd9\x45\x38\xd8\x64\xa0\x7c\x48\x49\x0e\xa7\xb4\xf8\x95\x89\x46\x12\xf5\x6a\x7e\x6b\x83\xdb\x02\x79\x64\x5e\xdb\x71\xb4\x4f\x04\x1b\xda\x08\xe5\x53\xf7\xff\xed\x8d\x6d\xeb\x76\xee\x95\xfe\x29\xfd\x57\x3a\x26\x7d\xb7\xe7\xf1\x1b\x1e\x7c\xeb\x30\xbc\x78\x3e\xe4\x21\x3f\x7b\xf9\x40\x38\x41\x7a\x54\x7a\x74\x07\x3b\xd7\xba\x75\xfb\xd5\x8f\x05\xb9\xc7\x3b\x5f\x7d\xe5\x95\x57\x57\x3f\xc1\xf9\xee\x5f\xbe\x66\x8d\x75\x0a\x77\x81\x28\xfd\x0c\x13\x17\x5d\xed\x3a\x31\x00\x56\x43\x97\xf4\xdd\x9d\xb7\x82\x5c\xbd\xbf\xf5\x20\x88\x76\x84\xb1\x42\x49\xc2\xaa\xf7\x39\x9d\x01\xad\x9e\x61\x43\x80\x05\xe5\xe9\x80\x56\xeb\x88\x3a\xa2\x59\xd1\xe1\xa0\xdc\x26\x40\xa5\x90\x7d\xec\xca\x07\x2c\x29\x42\x16\x47\x1c\x10\xc3\x18\x87\x7e\xdb\x88\xf7\xa7\xc1\x2d\xdb\xc1\xf6\x7e\xa9\x06\x2c\xac\xd6\x45\x17\x1b\xc7\x4d\xef\x7d\xf4\xef\xfd\x17\xcf\x2a\x3b\xf3\xc2\x8b\xfe\x71\x66\xd9\xac\x8b\x0f\xfc\xd0\x7d\xc5\xaa\x95\xcb\x96\x5f\x73\xdd\x0a\xb8\x4b\x6a\x38\xf2\x29\x14\xa6\x8c\x3d\x34\xed\xf6\xf2\xf2\xb3\x37\xaf\x5e\x01\xb5\x9b\xcf\x2e\x2f\xdf\x34\xf5\xc3\xb3\xa6\x48\x2f\xbe\xf4\xf8\x43\x6f\xbc\xf5\xe8\x2e\x79\x4d\xce\x44\xf3\x1c\xc7\x22\x7b\x40\x3f\xc1\x8f\x74\xb1\x8d\xe2\x91\xe1\xa5\x65\xbc\x3e\x4f\xc0\xa2\xef\x10\x2d\xb4\xc6\x8e\x6c\x15\x47\xde\x4a\x29\x3e\xbc\x27\xbe\xa8\x68\x41\x74\x44\x54\x0e\x32\xa6\x93\x5b\x6e\xbc\xbc\xe7\x41\xea\xa8\x12\x85\xd2\x63\x84\xaf\x3f\xba\x6b\xed\xcd\xd2\x95\x0b\x67\x67\xa7\x4d\x67\x3a\x49\xf8\xc9\x89\x05\x0b\xe6\x9f\xb9\x11\x9f\xb7\x35\x48\x1d\x74\x15\xdd\x05\x7c\xd8\xa3\xcc\xe9\xf4\x0e\xda\xed\x76\x58\x75\x8c\x3f\x60\xb5\xda\x6c\x86\xac\x68\xb3\xfa\xb4\x5a\x2e\xab\x86\xb2\xd9\x5e\x69\xcc\x65\xf7\xbb\x0b\x53\x61\x72\xfd\x51\x4f\xe4\x95\x24\x79\x8a\x39\x6b\xe4\x86\xd5\xd2\x1e\x8a\x51\xa3\x4a\x7a\x4e\xbe\xb3\xf5\x4f\x97\xdf\x20\xdd\x9e\x99\x5a\x3f\x7e\x52\x25\x5d\x4d\x8e\xdd\x4f\xbe\x3f\x67\xce\x19\xab\x27\xe4\xf1\xf3\xe6\x1c\x7e\xbe\x13\x5e\x25\xe3\x03\x17\xc1\x07\x3f\x21\xd3\xe5\x34\xf8\x79\x5c\xee\x1c\xe8\xce\x85\x04\xe5\x94\x29\xe7\x40\xc8\x50\xd1\xf4\xd5\x87\xb8\xbe\x0e\xa8\x01\x17\x09\x8d\xb1\xf2\x72\x1b\x13\x48\x32\x7a\xc6\x5d\xed\xae\xae\xad\x8b\x95\x75\x88\xed\xb1\x85\x31\xaa\x32\x06\x69\x10\xb3\xc5\x28\x3d\x1b\x8b\xf1\x3e\x4f\xd4\x17\xed\x10\x7d\x74\xb9\x9b\x77\x23\xed\xc8\x3b\xb4\x48\x59\x6a\xfd\x7d\x02\x3f\x95\xf8\xbe\x7c\xde\x74\x2e\x29\x9c\x1c\x42\x6a\x95\x33\xde\x54\xbd\x7a\x0e\x9d\x6a\x50\x13\x49\x8b\xf3\xaa\xa3\x84\x31\x96\xba\xd6\x72\xee\x9c\x35\x17\x8e\x1b\xe6\x1a\xe7\x1a\xd2\x3f\xdb\x94\x90\x2c\x5d\x5d\xf4\xf7\x72\x82\xf5\x3c\x9c\xae\x2f\x6d\x84\x3a\x48\xe1\x20\x39\x41\x3f\xf9\xcc\xa9\x17\xb9\xc6\x6a\xf5\x83\x2b\x6b\x87\x69\x56\xc9\xda\xb5\x2f\x63\x2c\x5e\x47\x59\x84\x2b\xc6\xa0\x3d\x11\x33\xc4\x4e\x12\xaa\x2a\x21\x34\x47\x02\x36\x5b\x84\xa7\xe3\x55\x65\xf1\xb2\xda\xba\x4a\x90\x15\x2b\x2b\x4d\x25\x25\xe5\xb8\xca\x2b\xe7\xcd\x8a\x9c\x3f\x62\x92\x4b\xb9\x16\x25\x53\xf4\x39\x5d\x50\x96\x94\xc2\xfe\x4a\x44\x24\xe1\xae\xa7\x13\x5b\x76\x3e\x29\x54\xb0\xd1\x7e\x25\x90\xc9\x9d\x3b\xe8\x8b\x64\x8e\x3c\x7a\xff\xdb\x2f\xc2\x0b\xa4\xdb\xe7\x2e\x84\xb7\x4c\x85\x87\x72\xc7\x10\x15\xc5\x02\x5f\xea\xfc\xfe\xbb\x9f\x7f\x22\x4c\xb0\xf8\x58\x42\xc5\xcb\xe4\x4c\xa0\x4e\x39\x93\xf8\xbb\x7c\xa6\xc5\x10\x44\x8b\x5e\x81\x47\x41\xcc\x45\xe7\x30\xb2\x9e\xf9\xb3\xc2\x3b\x7c\x9a\x33\x2d\x46\x3e\xd3\xfa\x5f\x4e\x25\xf2\x3c\xcc\x05\x7d\xa8\x23\x7d\x70\x63\x7b\xdc\x8f\x41\x35\x95\xac\x29\xaa\xca\x9e\xbf\xff\x61\xf5\xfe\xd4\x3d\xe0\xa1\xde\x17\xc9\xfd\xbb\xc0\x6f\xa0\x4c\xf0\xd3\x2f\x56\xc1\x2a\x41\x6f\x6f\xaa\xa2\x04\x37\xdc\xe9\x86\xfb\xdd\xf0\x4f\x6e\x78\x93\x1b\xba\xe5\x1e\x2c\xc6\xa5\x29\x0a\x6c\x86\xcd\x39\x9b\xe1\x4e\x52\x47\x9e\x53\x79\xa0\x83\xee\xd3\x9e\x4b\x56\xe7\x6c\x86\x3b\xd1\xbd\xbf\x92\xaf\xb7\x93\xeb\xfb\x9c\x4b\xf6\x95\xaf\x96\xfa\x4a\x95\x8f\x18\xd5\xf9\x11\xee\x2b\xdf\xa1\x9c\x7c\xf8\x1e\xdd\x8a\xef\x8f\x9c\xbc\xf8\xec\xb9\x33\x6e\x99\x13\xae\x26\xc7\x31\xb7\x06\xde\x57\xc0\x9d\x16\x73\x79\x0c\x5c\x51\x7f\x08\xcf\x1c\xb3\x2f\xc7\x33\xb7\x06\xbc\xd6\xfb\x65\xce\x56\xe0\x43\x11\x8b\xbb\xa8\x56\x79\x19\xc2\x87\xdb\x10\xde\x70\x82\x30\xe6\x3c\xe1\x59\x36\x6a\xb0\x5a\x7d\x00\x44\xa2\x06\x9f\x0f\xd9\x7d\x14\xe5\x69\x15\x29\xca\xcc\x71\xf6\x66\x91\x03\x66\xbf\x2e\x98\x15\x75\x8a\xf7\xa8\xb1\x30\x75\x5f\x4d\x75\x2f\x88\xe9\x65\xfb\x62\x07\xc2\x8a\x55\x80\x19\x16\x96\xf4\x2b\x44\x0a\x5b\xe0\x98\x8f\x73\x00\x61\x52\x01\x26\x60\xff\xe5\xa9\xfc\x6d\xa2\x82\x06\x70\xbf\xab\xd1\xfe\xb1\x8d\xe4\x4f\xd4\x81\x4b\x84\xc6\x52\x93\xa9\x1f\x08\x85\xe2\x76\x97\xab\x52\x1b\xd7\x66\xfa\x95\x24\x9a\xc5\x12\x6b\x28\x1e\x8d\x37\x8b\xf6\xca\xca\xb4\x3e\xdd\x2a\xba\xb4\x5a\xbd\xde\x19\xe5\x9d\x7e\x6b\x0d\x82\xbb\x81\x20\x4e\x77\xf4\xf7\x49\x77\xc4\x52\x15\x02\xa4\xe2\x24\x9e\x82\x63\x94\x7c\x02\xe4\x29\x42\xf6\xcd\x85\x2c\x10\x58\x4e\x8b\x2c\xc6\x47\x85\x09\x92\x96\x9c\xf8\x72\xae\xe4\xc9\xdf\x0a\x46\x81\x1e\x5e\x94\x32\x79\xa2\xbf\x3a\x20\x14\xe0\x7a\x8f\x50\xf3\x98\xab\xd1\x3e\x96\x00\x53\x84\x2a\x77\x24\x02\x80\xc1\xe6\x67\x6d\x6c\xb2\xc4\xee\x73\xfb\xb2\xa2\x21\x12\x09\x51\xa1\x56\x91\x3c\x53\x33\x2f\x38\xdd\x56\xb3\x4b\x17\x43\x0f\x53\xc1\x08\x38\xd1\xa1\xaf\xe4\x85\x59\x57\xf2\xbe\xdb\x57\xd6\x5c\x74\x8e\xfc\x58\x09\x11\x56\x7d\x79\x8d\x2c\x5f\x75\x00\xcb\x27\x47\xe8\xa0\x07\x5b\x55\xa5\xf9\x63\x79\x0d\x6c\x36\x61\x91\x36\xd6\x4f\xb9\xe3\x3c\x27\xd5\x26\xa7\x3e\xd4\x22\x51\xee\xad\x92\x73\xfe\x5f\x96\xc6\xc1\x15\x68\x4f\xb6\x83\x12\x81\x63\x81\xd9\xec\xe0\x70\x6c\xb9\x4d\x2d\x03\x93\x23\x21\x91\x27\xdb\xe9\xea\xa9\xf4\x29\xa3\x52\x54\x3c\x45\xc6\xd9\x68\xdd\xfe\x8c\xe6\x7d\x00\xe0\x95\x3b\x4f\x18\x18\x74\x55\x55\xd9\x35\xb1\x98\x21\x05\x0c\x20\xd3\xcf\x57\xde\x22\xfa\x6c\x4e\x47\xb3\xe8\x04\x1a\x8f\xc6\x43\x5b\x09\x2d\xb8\xd5\x9c\xc4\xf9\x75\xba\x48\x0b\x1a\x36\x1a\xcd\x22\xba\x90\x63\xad\xf0\x2c\xf2\x94\x4c\xbb\x8c\x82\xb6\x64\x66\xb0\x42\x02\x20\x99\x46\x81\x24\x3b\x16\x03\x6b\x85\x58\x8c\xfd\xf9\x8b\xf7\x27\xbf\xd9\x3c\xfb\xae\x3c\xc0\x26\x44\x62\x27\x74\x57\x5d\xbb\xb2\x09\xc3\x6a\x66\x14\xe1\x19\xbb\xf2\xac\x1b\x2e\x87\x47\x7b\xa4\xdf\xaa\xc2\x67\x17\xa0\x6b\x99\x5c\x4c\xfa\xf1\x85\xe7\xc2\xd4\x0f\x76\xe9\x0a\xc2\x3c\x16\xf6\x7c\x24\xdb\x1b\xe3\xd8\xaf\xe9\x43\x20\x8a\x70\x75\x7f\x70\x95\x30\x3a\xe6\x2d\x2d\x35\x67\x02\xc8\x4a\x32\x3b\x2b\x91\x5a\x68\x18\x10\xae\x69\x11\xc3\x36\x5b\xc0\x16\x60\xbd\xde\x32\x5c\xf5\xc5\x9d\xce\x8a\x3e\xb7\xcd\x91\x6c\x11\x1d\x2e\x6c\x36\x35\x8b\x46\x3f\x9b\x69\x16\x59\x9e\xae\xef\x33\x26\xb9\xcd\xf2\x95\x3e\xc3\x53\x30\x34\xca\xf4\x52\x47\xa7\x20\x05\xae\x21\x37\x4e\x0d\x19\xd9\xb0\x62\x95\xec\xee\x9c\xf1\x81\x87\x88\xfd\x5a\xc9\x88\xeb\x7f\xb5\x61\xfe\x56\x69\xc5\xa1\x03\x8b\x16\x4e\x19\x93\xbe\x76\x6c\xf7\xcb\x27\xbc\x2b\xae\x1b\xbc\x24\x48\x46\x29\xa3\xe4\xd2\xc1\x2f\x0a\xf2\xe3\x20\x3b\x63\xcc\x04\xf8\xcd\x8f\x68\xb4\xd2\xd3\xa3\x65\xc7\x7f\x7d\x71\x8f\xd3\x4c\xfd\xdb\x2e\x5d\x24\xa7\xd5\xe1\x39\xc9\x00\x67\xef\x26\xf6\x69\x76\x09\xa9\xc8\x1c\x42\x6b\xec\x0a\x61\xa4\x26\x1a\xb5\x3a\x78\xbb\xcb\x6e\xf3\xd0\x2e\x17\x13\x08\xfa\x3d\xde\xb0\x55\x9f\x2c\x61\xc3\xde\x70\x87\x18\xf2\xc6\xf4\x81\xa0\xc3\x6b\x0b\x78\x03\x5e\xbd\xcd\xe6\x99\x29\x72\x36\xc6\xec\x70\x59\x69\x8d\x5e\x83\x0c\x4d\x48\x32\xde\xdf\x52\xab\xe3\xa0\x01\x52\x07\x47\x49\xf5\xb5\x17\x87\xc9\x65\xd4\x0c\x66\x4c\x69\x54\xdf\x40\x47\xd1\x20\xc5\xb5\xf1\x86\x78\x7d\x03\xcc\xf8\x61\x46\x0f\xdd\x90\x46\xff\x48\x59\x21\xad\x75\x37\x70\xec\xd3\x3d\xaf\x75\x5f\x27\x3d\x26\x49\x17\xdf\x33\x72\xd6\xc8\xa7\x37\xc1\xd7\x5e\xe8\xd8\x37\x4b\xea\x81\x93\x1e\x3e\x79\xe4\x1f\x97\xfe\xed\x0a\xf1\xde\xdf\x3a\x74\x34\xf3\x7c\xbd\x1f\xae\x94\x96\xd8\xeb\xe7\xce\x45\xa0\xe9\x57\x49\x82\x95\xd2\xe2\x93\xf3\xfd\xcc\xca\x9e\x65\xf0\x1c\xe9\xe1\x63\xc7\xa6\x48\x47\x38\x5a\x07\x63\x40\xc9\x6d\x5e\xc9\x7c\xcd\xbe\x8e\x6c\xd4\x52\x70\xb5\x30\x36\xaa\x33\x27\xe2\x2c\xc3\x58\x2c\x94\xdb\x65\x63\xac\x34\xcd\x30\x0e\x84\xa1\x43\xba\x50\x59\xb9\x9b\xea\x10\xe3\xc8\xc8\x76\xc7\x83\x9c\xcd\xc6\x05\xe3\x6e\xbc\xa0\x91\x15\x66\x76\xa1\xbf\xb4\xb1\xa4\x5d\xb4\x18\x19\xe0\x6d\x17\x19\x1c\x74\xb9\x2f\x3f\x53\xf2\x91\xbb\xb2\x81\xa6\xd2\x49\x12\x13\xc6\x3d\xb0\xce\xae\x38\x26\x58\xb9\x10\x34\x55\x4f\x0e\xf7\x1b\x32\x5a\x37\x4e\xba\x90\xcb\x40\x93\x10\x64\x68\xc3\xb5\xa1\x23\x14\xad\x79\x7a\x6d\xf6\xdc\x19\x37\xdd\x86\xc9\xe3\x66\x5e\x3a\x6a\xc6\x59\xeb\x34\x23\x42\xe9\x01\x3d\x5f\x2d\x7a\x50\xe5\x96\x8b\xad\xa5\xf4\x62\xb3\xd4\x7b\xc4\x39\xe8\xfe\x57\x27\xc0\x92\x37\x31\x7f\x9c\xe9\x86\xdb\x7d\xd2\xe1\xc7\x7c\xce\x13\x4f\x8d\x97\x99\xe5\xa8\x07\xa4\x57\x36\x31\xe5\x9c\xf4\x2e\xde\x73\x57\xa0\x85\xb4\x82\xc4\xb0\x9d\x47\xf0\x75\x59\xae\x3e\xce\x59\x42\x09\xa5\xd1\x70\x56\xab\xd1\xe3\x45\x6b\xdb\xd9\x2e\xb2\x76\x07\xb2\x6b\x28\x87\x01\xfd\x31\xbb\x68\x8d\xd5\x6c\x6d\x17\xcd\xc5\xf9\xae\xf6\xcc\xa9\x79\x95\xb8\xea\x35\x61\x70\xce\x97\xbf\x51\x98\x23\xa8\x4b\xf6\xc3\xcb\xa5\x6b\xf3\x15\x70\x5e\x78\xa1\x8b\x1a\xc2\xea\x7c\x3d\xbd\x6d\x3d\x7f\x56\xaa\xdf\x50\x67\xb6\x51\xd0\xa7\xec\xf9\xc9\xde\x3d\xcc\x5e\xf6\x4e\xb4\x57\x84\xc1\x32\x61\x88\xd9\x61\x02\x20\xe8\x74\x52\xde\x90\x01\x1a\x8d\x26\xa8\x33\x79\xad\x56\xaf\x8e\x8e\x44\x9d\x5e\x37\x7a\x32\x36\x9d\x2f\xa8\xd3\x05\x7d\x34\x9a\x61\x8e\x80\xdf\x61\x67\xd0\x04\x46\x4f\xcf\xa8\xa7\x01\x8e\x3f\x50\x88\x1a\x3c\x8d\xfb\xd0\x23\xa9\xce\x85\x07\x92\x79\x8b\x66\xb1\x12\xee\x4b\xc4\x50\xc2\xf1\xdd\x71\xa8\xa6\x58\xa1\x07\x86\x10\x7f\x35\x54\x33\x39\xb8\xb8\x9d\x2b\x79\x61\x16\xdc\x45\xf2\xac\xe8\x57\x87\xce\x1a\xba\x78\x94\xbf\x55\xda\x8b\x53\x39\x7e\xaa\xfd\x2c\x2b\x50\x5b\xa8\x55\x38\xd7\x6a\xfa\x74\xe9\xe5\x03\x7a\x89\xef\x69\x27\x89\x1c\x97\xd2\x41\x69\x1b\x9c\xcc\x28\x31\x25\x08\xd7\x1c\x44\xf8\x60\x20\x38\x47\x48\xd7\x79\x92\xb4\x2b\x1d\x72\x25\x2d\x20\x09\x06\x0d\xf6\x54\x78\x2a\x98\xd2\xd2\xea\xac\x58\x6a\x33\x99\x6c\x8c\x4d\xdf\x2a\xda\x02\x4c\x20\x2b\x32\xae\xa2\xb0\xa1\xc6\x82\x15\x89\x1e\x04\x96\x85\x04\x4f\x64\xe4\x74\xa5\x34\x0c\xd1\x58\x17\x91\xac\xb1\x92\x54\x15\xb2\xd5\xd5\xd0\xd5\x6a\x58\x45\xd5\x17\x91\x91\x38\x5d\xee\x10\x4d\x1d\x7c\xfc\x51\x4d\xb0\x3c\x5d\x5f\x56\x55\xa7\xad\x0c\xd4\xcc\x5c\x57\xd9\xd8\x58\x75\x01\x09\x66\xbd\x43\x3c\x7f\x6a\xdd\x43\xeb\xe7\xdc\x59\x5d\x5e\xbf\xb8\x65\xe2\xd9\xe3\x37\x4c\x69\x8c\x43\xdd\xda\xf5\x65\xe7\x4f\x1e\x5c\xe5\xd9\x6b\x9c\x7d\xfe\x9a\x49\xc6\x10\x8e\x6d\xfd\x63\xbf\x60\x74\xd4\xac\x31\x97\xdf\x14\x7e\x6b\x41\x75\x76\xd4\xc0\xf1\xbe\xba\x2a\x5c\x98\x9c\xd8\xb3\xa3\x69\x1f\xda\x3b\x63\xa0\x49\x48\x98\x28\x1d\xf4\x18\xa1\x31\x9e\x70\xb9\x7c\xc0\xc7\xb5\x8a\x3e\xa4\xd8\x81\x5e\x4f\x93\x52\x77\xa6\x2c\xb2\xe3\x4e\x23\xb0\xa7\x40\x5c\x1c\x73\x5a\x68\xd5\x86\x28\x39\x84\x58\x16\xba\x8a\xc2\xa1\x34\x0d\x05\xb6\x6d\x4f\x7d\xf3\xb0\xc1\xbe\xc1\x49\x59\xbe\x21\x93\xc7\x64\x06\x47\x26\x0c\xc8\x19\xb9\x1f\x52\x15\x13\x6f\x10\x06\x61\x71\xc2\x83\x5b\x57\x9e\x31\x1a\xf7\x19\x19\x65\xf4\x31\xf6\x3e\xe0\x05\x83\x84\x80\xde\xc2\x59\xbc\xac\x97\xf5\xf9\xbd\x5e\x13\xcf\x53\xed\x22\xcf\x60\x8e\xa2\x76\xd1\xe4\xe8\x43\xa9\x52\x40\x31\x5b\x5b\xc3\xa9\xac\x74\xca\x3c\xc2\x41\xf2\xb6\x28\x9e\x63\xf7\xec\xdc\xff\xf5\x4f\x6f\xec\xc5\xf9\xf7\x93\x1e\xde\x20\x7d\x7b\xcf\xca\xf8\x08\x76\x4a\xd3\xe7\x1f\xec\xfb\x31\x24\x35\x10\x32\x1e\xc6\xe0\xdc\xfb\x0c\x9c\xd9\xf2\x80\xba\x7e\xa9\x5f\x49\xec\x02\xea\x8f\x1b\x81\x25\x0d\x67\xe6\x7c\x7e\xb3\x19\xd8\x6c\xfa\xac\x68\xb3\xb9\xe5\xc4\xfa\xbe\x14\x2f\x05\x3b\x9a\x5c\x7b\xb3\xa1\x7f\x9f\xec\x5c\xd2\xbb\xcd\x5b\x06\x1d\xb8\xec\x8f\x8b\x5a\xe3\x23\xee\xe9\xfc\xeb\xe7\xab\xd7\x6f\xad\xf4\xc2\x46\x63\xc9\xc7\x4b\x17\xd4\x6e\x93\xd2\xf7\xdf\x72\xd9\x86\xb8\xf4\x0d\x81\x29\x68\x7f\xee\xdf\x7b\x9c\xf9\x89\xe8\x92\x24\xa8\x02\xd7\x09\x63\x6d\xe6\x74\xdc\xeb\xd5\x94\x98\x43\x66\x8a\xa3\xb8\xea\x1a\x5c\x77\xb4\xda\x43\xeb\x94\xca\xa3\x71\xd6\x96\x8e\xa5\x63\x84\xaf\xd7\x9a\xc6\x94\xbd\x69\x36\x8d\x1e\x79\x79\x87\x88\x8b\x8d\xea\x69\xd9\xbd\xe9\xce\x55\x1a\x55\xa3\xdc\x95\xe3\xec\x69\x39\x5f\x18\xa9\x30\xda\x87\xc6\x97\x64\x86\x21\xd1\xea\x15\xe5\xa3\x92\xf5\x62\xb7\x58\x92\xe3\x5d\x6a\xda\x0a\x1f\xe5\x39\x35\xfd\x7b\x70\xd7\xe3\x8f\x77\x51\xe7\x2b\x54\xbd\x32\x8b\xef\x02\xcc\xe8\xfb\xfc\xfe\xa3\xf0\x9c\x3d\x32\xcb\x6f\xbd\xff\xfb\x36\x7a\xaa\xaf\x5e\x21\xeb\x5d\xbd\xf7\x55\x0d\x1c\xf6\x77\xcd\xcd\x77\xac\x5b\x79\xb2\x8d\x7a\x96\xd0\xfb\x62\xdd\x45\xce\x1c\x08\xe7\x4a\x02\x4c\x14\xd2\x21\xbb\x5d\x67\x42\xba\x0b\x78\x4d\xde\x64\x89\xd7\x29\x13\xcb\x84\x00\x09\x5f\xf6\x39\x0c\x06\xc6\x65\xa1\x99\x68\x87\xc8\x70\x05\x99\x7b\xb2\xca\x52\x0f\xf2\xf3\xc0\x3e\xa3\x58\xee\x38\xc1\x12\xc7\x9d\x67\xfa\x1c\xe0\x67\xf8\x32\xec\xed\x43\x32\x32\x47\xd5\xec\xca\x2e\x7c\x6e\x4f\x1d\xc5\xec\x2c\x5d\xd2\xbf\x7a\x6c\x38\x13\x8e\xba\x6b\x3f\x4e\xad\xfc\xb2\x0d\x4a\x84\x13\x89\x52\x7f\xb6\x1d\xc4\xb9\x70\x39\x1f\x0f\xdb\xe4\xd0\xd0\xe3\xc9\x73\x1e\x8c\xf6\xd4\x2b\xd0\x9e\x1a\x43\x16\x4d\x39\x58\x2b\x9c\x5d\x1a\x0f\x04\x90\x79\x92\x34\x18\x70\x55\x53\xb4\x53\x44\x35\xd1\x74\x45\xd2\x91\xd2\xa7\x3a\x44\x5f\x79\x1c\x3d\x4f\xae\x3d\xbe\x30\x4e\x55\xc6\x21\x0d\xe2\xb6\x38\xa5\x67\xe3\x71\x06\x29\x65\xf9\x31\x97\xfa\x03\x01\x0d\xa6\xca\xa2\x00\x26\xd5\xcd\xbc\xa2\xd8\x68\x32\x45\xe5\x2b\x78\x1c\x0a\xca\xf8\x14\xa4\xff\xa9\x75\x04\xea\xc8\xff\xc4\x6b\x43\x30\x06\x1e\x03\x55\x59\xd3\x19\xe2\xa6\x89\xd3\xbc\xec\xa7\x81\x19\x2e\x15\xb7\x37\xc4\xe1\xf8\xc1\xe7\x0e\x7a\xaa\xab\x8b\xae\x1c\x39\x63\x64\xc7\x88\x48\xe5\xb1\x0b\xb1\x93\x66\xe3\x7b\xaa\x93\xa6\x67\xd8\x96\x63\xcf\x1c\x5e\xb6\xec\x8a\x2b\x64\xf7\xcc\xba\x75\xd2\x8b\x87\xd8\x9e\x1e\xec\xa0\x91\x86\x9f\x87\x3d\x34\xd4\x87\x94\x8e\x39\x79\xef\x09\x19\x77\x65\xa5\xed\xf4\x18\xd6\x02\x82\xe8\x79\x97\x81\x4a\xd0\x29\x9c\x59\x16\x4d\x26\xfd\xc8\x6e\xb6\x96\x56\xc6\x2a\xe2\x46\x9d\x2e\x1e\x2b\x4d\x01\x0d\x5d\xce\x5b\x68\x4b\x55\xb5\xb5\x2c\x8a\x40\x6a\xa5\x35\x1a\x8e\x52\x26\x3a\x1a\xd5\x78\x53\x0e\xaf\xa3\x45\x0c\x02\xaf\xab\x22\x1e\x0f\x69\x42\x59\x11\x7d\x49\xaf\xb1\xe1\xcd\x4b\x35\x76\x8a\xd2\x53\x71\x65\xdd\xa2\xcc\xce\x1c\x2d\x66\x46\x71\xf0\xe0\x93\x1c\x95\xe0\x10\x6d\xc7\x2e\x3b\x1f\xa5\x0b\xaa\xfd\xd0\x71\xec\xd5\xc9\x70\x25\xd0\x89\xd0\x48\xb2\x5f\x4a\x0b\xad\x33\xa6\xbf\xfd\xe2\xb0\x7e\x97\x9c\x73\xd5\xc3\xd2\xb3\x97\x8d\xe8\x90\x5d\x3d\x13\x9a\x2e\x39\x07\x36\xcf\x5d\xf8\xe2\x85\x71\xe9\x67\xe1\xfc\x07\xe0\xad\xa5\x13\xfd\x75\x9f\x3e\xf9\xf3\x4f\x66\x84\xbc\x6e\x14\xa5\x6f\x5b\xa5\x7b\x13\xc4\xdd\xc3\x49\x0f\x32\xfb\x77\x6c\x83\x03\x9c\x52\xeb\x73\x22\x2c\xc9\x6e\x1f\x7f\x4c\xc9\x43\x43\xb6\xdf\x4f\x64\x4d\x8c\x16\xe2\x7e\x08\x9d\x7a\xbb\x3d\x18\xf2\xf1\x6e\xbe\x5d\x84\x0e\xce\xd1\x2e\xfa\x39\x4e\xe3\xa6\x35\x16\xa4\x03\xf4\x1a\x4e\x65\x39\x3c\x0d\x89\x99\x1a\x2e\x59\x4c\x6b\x58\x44\x67\xf6\xd3\xa6\x7c\x79\xb1\xb5\x78\xfa\x33\x9b\x36\x51\x77\x1d\xc9\x55\x14\x83\x77\xe5\xa6\xbd\x52\xe3\x33\xac\xc4\xb6\x65\x85\xb2\x88\x1b\x42\x9f\x43\x6b\xb1\x94\xa4\x82\xf1\x09\x62\x90\x07\x36\xbb\x2d\x2b\xba\xed\x76\x86\xe7\xb9\x66\x91\xb7\x62\x62\x52\x2d\x53\x60\xe3\xe5\x2b\xb0\xdb\x5e\x51\x4d\x3e\x35\xdd\xc0\x5e\x6c\xf8\xe5\xb9\xb4\x68\x67\x8e\x51\xc0\x85\x6d\x41\x35\x09\x7f\xeb\x56\x64\x0d\x6e\xd9\x28\x54\x54\x0a\x42\x65\x85\x00\x9f\x95\xc2\xb9\x52\x62\xce\x36\x38\xd9\x5b\x29\xcd\x6c\xa3\x93\x15\x02\xb9\x82\xc4\xe6\x8d\xd6\x34\xa3\xfe\x1b\xd1\xba\x1c\x21\xc4\x68\x7b\xca\xa5\xd7\x47\xbd\x76\x6f\x69\x59\x24\x1e\xf7\x23\x70\x1b\x70\xd3\x4e\xd0\x2e\x3a\x19\x8b\x06\x33\x7d\xe6\x4d\x9f\xc6\x62\x04\xa7\xa4\xf7\xe5\x29\x61\xb8\x3c\xe9\x31\xe6\x8d\x2e\x4a\x40\xa7\xc1\x7f\xbe\xfd\xfa\xcb\x51\x5d\xa3\xff\xf8\x87\xbb\x1f\x93\xde\x91\xfe\x04\xcf\x85\x2d\xd7\xdc\xbb\x2e\xb3\x26\x97\x88\xde\xc2\x9c\x24\x74\xc7\x1f\x48\xef\x26\x43\xcc\xb8\x7e\x27\x6a\x87\x13\xc2\xe3\x49\x70\x76\xd2\x75\x3c\x20\x27\xa6\x2f\x7f\xfb\x7a\x19\xf3\xe1\x73\xa5\x55\xc8\xce\x33\xa0\xe7\x30\x4e\x28\x01\x2e\xbf\x4d\xa3\x31\x86\x5c\xa1\x92\x54\xc0\xeb\xd5\xe3\x0a\x58\x1a\x87\xc3\xe9\xa4\x71\x36\x7f\xd2\x6c\x8e\x22\x33\x37\x50\xcc\x2f\xa0\x68\x8e\x3e\x12\x71\x05\xf6\x98\x12\x57\x57\x60\xb3\xa9\x5c\x0e\x52\xce\x08\xa3\x3b\x5b\x84\x1b\xee\x2d\xb0\xd2\x86\x0c\xae\x8b\xfa\xab\xe1\x41\xc5\xec\x3a\xfe\x77\xc7\x13\xf7\x75\xe4\x2c\xb2\x13\xaf\xac\xbd\x32\xb0\x40\x96\x81\x9c\x9b\xa3\x79\xee\x45\x5a\xf2\x7c\xa1\x5f\x18\x42\x83\xd7\xe9\xe1\x79\x9f\x53\x63\xd7\xd8\xe3\x09\x8f\x03\x69\x55\x9d\x5e\xd7\x21\x86\x09\x1d\x5b\x08\x63\x54\x84\xae\x69\x1e\x42\x4d\x8e\x5d\x5c\x95\xa5\x28\x2b\x2d\xcf\x95\xa7\x04\xcb\xd6\xd5\x9d\x86\xa4\x2d\xcf\x63\xa2\xcf\x93\x9b\xec\xc0\x74\x25\xdb\xb7\x77\x51\x23\x09\x87\xc9\x7c\xcc\x61\xb2\x0a\x1a\x64\x62\x13\x6a\x9c\xc4\x10\x74\x7a\x72\x0a\xd5\xe4\xab\x97\x89\x4c\xbe\xf5\xd7\x53\xe3\xe0\x15\x84\xdc\x44\xc5\x1b\x9b\x08\x47\x57\xab\x50\xe6\x93\x89\xe5\xb8\x60\x08\x81\x70\x27\x67\x93\xf9\xe5\x7c\x39\x7e\x39\xeb\xff\xc4\x2f\x87\xd3\xa4\x8b\xce\xf4\x4e\x11\xc1\x3d\x0c\x0e\x86\x08\x93\x62\xdf\x42\x86\x87\x63\xb6\x4a\x23\x2e\x41\xff\x41\x87\x7e\xc8\x5b\x43\xac\xe9\x41\x75\x9d\x75\x8f\xc0\x2e\x69\x33\x29\x12\x39\xbb\x0d\xce\xf6\x56\x2e\xab\x9b\x2a\x5d\xe4\x77\x49\x27\xdb\x30\x17\x26\xf6\x47\x12\xbe\x85\x08\xb1\x6e\xd0\x62\x88\xf9\x5d\x2e\x0b\x87\x79\x93\x22\xd0\x68\x42\x03\x1e\x70\x86\x4c\x26\x8d\xc7\x46\xd3\x3a\x8d\x4e\x39\xc4\xc9\x25\x17\x0f\x2c\xdc\x7d\x55\x87\x21\x0e\x36\xcb\xa5\x72\x47\xeb\xa3\xd5\x38\x2d\x53\xeb\x8e\x36\x60\xa5\x63\x45\xbf\xe3\xa2\xec\x06\x34\xd7\x8f\x92\x7c\xee\x4f\xa4\xdd\x90\xbf\x12\x27\x75\x5f\x06\x7b\x97\x3d\x0c\xbb\x37\x5c\x02\x0d\x3d\xab\x5f\x95\xe6\xd0\xef\x49\x43\xd4\xbc\x6e\xf8\x7a\xdb\x2b\x58\x0d\xbd\x22\xbf\x4a\x68\x01\xa1\xfe\x13\xff\x28\xc2\xc7\x49\x64\xbb\x22\xfc\xe0\xe3\x83\x31\x2d\xcf\xc7\xca\xca\x63\xc1\x20\xef\x73\xfb\x9a\xc5\x52\x80\x54\x66\x56\x8c\xfb\x6d\x25\x1c\xc7\x86\xdd\x56\xd6\xd4\x22\xea\xd8\x80\x9a\xba\x26\x53\xaa\x9e\x22\x84\x6c\xe7\x60\x49\xe8\xe2\x5c\x6f\x1a\x8d\x7c\x1f\x79\xd0\xc0\x73\x68\xbf\xf8\x21\x9f\xee\x7d\xe6\xf2\x8c\xef\xab\xaf\xf6\xce\xc0\x09\xdf\xe7\x42\x41\xdc\x00\xa7\xcf\x6c\xdf\x2b\x35\x5e\x29\xf5\x52\x89\x9e\xad\x4a\xce\xf7\x25\x6b\x9a\xa8\xaa\xb6\xef\x71\xd6\xf7\x11\xfc\xca\xff\xd4\x86\x34\x43\x0b\x5e\x1b\x01\x92\x2f\xb8\x17\xf8\x91\x64\xe7\x08\x15\x01\x9d\xc3\x11\xf1\xd2\x26\xda\x54\x92\xf2\x80\x24\x0e\x00\x8c\xe1\xc4\xb6\x80\xbd\x59\x44\xb8\x42\x23\x27\xb8\x01\xbe\x20\x6d\x50\xf1\xe4\x82\x22\x3a\x11\x79\x45\xd4\xe5\x4b\xf1\x90\x42\x94\xe8\x03\x42\x34\xc3\x2b\xab\x9b\xd7\x40\x92\x93\x4a\x32\xdd\x9f\xdf\x7c\xf3\x32\x48\x71\x8b\x1f\xff\xb1\x75\xe3\x1d\xeb\xce\x18\x7b\xde\x84\xd8\x80\xfb\x7a\xc1\xca\x6b\x67\xdc\x34\x6a\x56\x9d\xf3\xca\x6b\xa8\xcb\xbc\x95\xd3\x17\x4b\xdf\x9e\xff\x87\xc1\x0c\xb3\x61\xc6\xd4\xea\x65\x6f\xc5\xe1\x97\x0c\x35\xe3\xa2\x9d\x61\x0f\xd1\x55\x98\xd3\x07\xad\x07\x1b\x9a\x65\x67\x08\x09\xb7\xd6\x4c\x07\x83\x36\xad\x2d\x14\xb6\x58\x0d\x4e\xa4\x98\x0c\xb6\x20\x4d\xb3\xac\xaf\x45\x64\x5d\x94\xad\x59\x2e\xf2\x51\x10\xc8\x98\x29\xa0\x6a\x57\xd4\x54\x92\xcf\x93\x6e\xbb\xdc\x68\x2d\x14\x9e\x6b\x36\xd0\xdf\x48\xbf\x3a\x96\xef\x94\xee\xdf\xff\xf4\x39\x7f\xac\xd8\xbe\x7d\xc5\x45\x4b\x16\xce\x58\x78\xe6\x1f\x87\x54\x56\x5e\x78\x15\x3c\x74\x0c\x9a\x1a\x86\x4d\x3d\xb9\x19\xee\xdc\xfd\xfa\x17\xef\x3c\xb5\xa7\xae\x3f\xd1\x47\xf8\xdc\xed\x6b\xd2\xcf\x00\xee\xa7\x9d\xb6\x58\xac\x2e\xad\x55\x1b\x0c\x59\x79\xb9\x9f\xae\x00\xee\xa7\x17\xf5\xd3\x06\x51\x3f\xa1\xf5\x7f\xea\xa7\x5c\xfb\x83\x8c\x6f\xc4\x2e\x7b\x09\x79\x64\x0c\xcb\xc7\xb1\xc4\x1b\xd8\x04\x75\xa8\x97\x70\x5a\xae\x97\x5f\x92\x4e\xd2\xd7\xa2\x5e\x4a\xa9\x63\xd2\x31\xd4\x4b\x7a\xb6\x94\xdd\xf5\x06\x7c\x9c\xf4\x52\xad\x1b\x71\x1f\xda\xbf\x08\x57\x4f\x4c\x29\x1a\x91\x2a\xd5\xc4\x62\x89\x04\xd2\xf6\x09\x9b\x2b\x98\x15\x5d\xf0\x77\x0a\x46\x14\xc5\x3a\x9c\xa6\x52\x44\xb1\x8d\x7b\xfa\x6a\x11\x98\xa4\x4a\x66\xaf\x3a\x6d\xb9\x08\x7a\xaf\xca\xb8\x79\x71\xc7\xf8\x7f\xe2\x1c\x75\xd4\xe7\x46\x34\xae\x6e\x5c\xfb\xc0\xe8\xb6\xb3\x6e\xd6\xe3\xc5\xa4\xc7\x46\x9d\xcb\xed\xa4\x9d\x2d\x39\x8f\x7d\x9f\xda\x07\x1c\x8e\xa0\x91\x31\x81\x1d\x2f\xbf\x88\x32\x6e\x8d\x55\x8f\x4e\x85\xaf\xfd\xf3\xd0\xaa\x2d\x98\x8d\x1f\x9a\xee\x7f\x64\xd4\x8d\x15\xf4\xa5\xf1\x72\xc9\xfa\x9d\x14\x86\x9a\xed\xd5\x70\xd3\x7b\xbb\x38\x0b\x79\xa6\x8f\xd2\xb3\xd1\xbd\x43\x48\x3f\x4c\x16\x6a\x79\x7d\x38\x10\xb0\xea\x59\xa6\xac\xdc\x1b\x6b\x15\xad\xde\xb0\xb7\xda\x4b\x23\x23\xca\x0b\x4c\x26\x0e\xd9\x82\x26\x5b\x82\xa2\xdc\x5a\x2d\x00\x25\xe8\x29\xe3\xc5\xb4\x2f\x77\x18\x22\xf7\xae\xa0\x4a\xa4\x9a\xee\xca\x2a\xde\xf3\x92\x1c\x43\x36\x29\x24\xe0\x56\x8c\xc4\x86\x9c\x27\x9d\xe2\xde\xbe\xb4\x8c\x3b\x93\x1b\x30\x5a\xed\xbc\x74\xcc\xb8\xea\xb1\x55\x77\x3f\x3e\x79\xee\x05\xf7\x5e\x34\xa1\xeb\xc2\x25\xce\x45\x6d\xe7\xae\x5d\xb0\xf4\x85\x1f\xa4\xb0\x74\x7c\x7b\xb5\x34\x6b\xf2\xe0\x05\x7f\x9c\x79\xd1\xe5\x7f\xcb\x0c\x99\xbc\xae\x51\xd9\xfb\xc7\x31\xab\xd8\x75\x40\x8f\x30\xcc\x99\x68\xef\xb7\xb8\xd8\x54\xca\x67\xf1\x95\x46\xcb\xa2\x89\x04\x7a\xfa\x09\xbf\xc7\xd5\x2c\x7a\x80\x1d\xed\x34\x76\x9b\x89\x56\xce\x39\x8b\xdc\xda\x84\x00\xc9\x51\xb0\xa2\x0a\xf8\xec\x4f\x71\x66\xab\x6a\x01\xe3\x01\x49\x8d\xfd\x80\xfb\x17\xdd\x92\xf7\x60\xcb\xdb\x7e\x8b\x70\xcb\xed\x39\x5e\xfb\xb7\x27\x16\x86\x84\x78\xf1\xc6\xff\xaa\xe3\xb5\x7d\x40\xd1\x09\xcc\x46\xc2\xc9\x86\xf1\x4b\x29\xf0\x86\x79\x96\x4d\xd8\xbd\xf6\x92\x54\x32\x16\x33\x67\xc5\x18\x0c\x59\x09\x1d\x9b\xcd\x8d\xfa\xef\x76\x39\x91\xa6\x73\xf2\xc5\x52\x9c\x0e\x91\x15\x88\xa1\xb0\xc6\xba\x0b\x54\x85\x3b\x25\x4f\xf0\x9c\x10\xf4\x1c\x32\x91\x97\x16\x12\xf4\x6f\xdb\x38\x6e\xa4\x2a\x04\x6c\xc6\x13\xf9\x84\xe4\xad\x54\x49\xfa\x47\xbe\xf3\x05\xf7\x16\x91\x41\xcd\x5f\x73\x22\x2d\x3d\x54\x08\x7b\x4c\xc0\xeb\x74\x6a\x80\x26\x10\xf4\x80\xac\xe8\xf1\xe8\x69\xbd\xad\x45\xd4\xbb\x68\xa4\x96\xe9\xd3\x27\xb0\xe5\xb4\x84\x0d\x83\x11\x9b\x9c\x2e\x4d\x1c\x32\x43\x21\x2d\x1f\x24\x9f\x01\x2f\x78\x61\xff\x1b\x87\x27\x3e\x58\x9d\xd9\x58\xbb\x61\xfd\xa1\xf6\xa9\xf0\x96\x85\xf0\x50\x2b\xdc\xfc\xd3\xcf\xd2\x89\x23\x55\xe1\x01\x26\xfb\x23\x7f\x75\xc0\xbb\x36\x75\x3f\xf0\x60\x51\xbf\x54\x3e\x7b\xa7\x17\x00\xab\x55\xe7\xa4\x83\xa1\x77\x14\x3e\xfb\x28\xfd\xbf\xe7\xd8\x29\xd5\xdd\x0b\xa2\x22\xfe\x5f\xe7\xd9\xe1\xb3\x7b\x64\xff\x33\xa8\xaf\x38\x37\x77\x8e\xd0\x3f\x44\xd3\x09\x4d\xa2\xb6\xcc\x61\x32\xa7\x52\x5e\x8d\x49\x53\x53\x5b\x66\x8a\xa2\xd1\x2c\x35\x7b\x99\xac\x68\x8a\x9a\xbd\x5e\x73\xd4\xc4\xe8\x5d\x2e\x2b\x26\xe8\xd3\x57\x64\xd1\x00\xf7\xa5\x86\xe8\xcb\xc6\xa1\x3a\x03\x54\x12\x17\x34\x8b\x95\x84\xa8\x12\xc2\x98\xab\x4a\x84\xc0\x54\x83\x5b\xce\x29\x71\x5b\x60\x32\x25\x9f\x4d\xd4\x33\x03\xce\x5f\x52\xe5\xdc\xff\xc2\x93\xbb\xa9\x9a\xba\xcf\x64\x19\x37\x3f\x55\x8e\xae\x99\xdc\xd0\x78\xce\xf0\x52\xcb\x12\xc9\xca\x48\x8b\xa6\x4d\x9f\xb7\x10\xee\xba\xee\x8f\xee\x73\x2f\xfa\xf9\xa7\x57\x5f\x84\xa9\x7d\x44\xea\x85\xf3\x83\x2e\xb7\xa9\xf1\xe2\x0b\x2f\x4f\x8d\x9d\x55\x3f\xf5\xdd\x07\x36\x3c\xb2\x55\x3e\xdb\x6d\x46\xcf\x29\x4a\xbf\xec\xd0\xd0\x73\xd4\xdc\x06\xda\x8c\xc6\xa2\x12\x4c\x13\xea\xf4\x09\x27\xd2\xe8\xa6\x00\x03\x34\xa5\xa0\xb4\xaa\x3a\x61\x32\x9b\x11\x70\xb1\x9a\xc3\x66\xca\x84\xb0\x63\x3a\x0c\xe8\x34\x5a\x19\x69\x57\x20\x1c\x76\x67\xc5\xb0\xad\x08\xdd\x3b\x72\x5a\x4a\xe5\xf2\xcf\x73\x92\x34\xe4\xa2\x16\x34\x69\x58\x2f\xcb\x9d\x0b\x05\x4c\x29\xa1\x80\xbc\x1a\xe3\x30\x78\x5a\xe7\xf0\x4b\x56\x35\x8d\xfe\xd3\xa8\x48\x84\xbf\xab\x66\xc0\xc8\x05\xe7\x55\x77\xf8\x07\xd6\xc0\x15\x37\xee\x3c\xf0\xf4\x9c\x3f\xec\xdb\xbd\xbf\x73\x55\xd8\x39\x6f\xf2\x19\xe7\x39\xcd\x1d\x5a\xc6\x36\x75\x34\xb6\x3e\x2e\xde\x97\xb8\x6a\xd1\xed\x43\xb5\xfc\x15\xe7\xde\x70\xfb\x14\x55\x3e\xa6\x1b\xc9\xd7\x08\xe6\x0b\x83\xbd\x9a\x04\x53\xd7\x40\xd7\x69\x82\x15\x8c\x8d\x36\xd8\x0c\xc2\xd0\xe1\x83\xd0\x83\xd6\x04\x03\xc1\x40\x8b\x58\x47\x37\x8b\x83\x82\x75\x75\xc1\x41\xb4\xb9\xa2\xba\x3a\x95\x15\xab\x6d\x36\xce\xcc\xb5\x88\x66\x57\x11\xf1\x9f\xfc\xc4\xd3\x4a\x9d\x2a\xa2\xd2\xd0\x53\x76\x17\x50\x4b\xe2\xa7\xad\xc9\xcb\x53\xff\xbf\x4a\x5f\x3c\x0d\xe8\x6f\xcf\x5f\x92\x09\x6e\x90\x05\xfd\xfd\xb1\x78\xe0\x1d\x83\xdf\xc5\x4d\x1e\x38\x94\x4c\x08\x3c\x0f\x7c\xb3\x33\x8a\xf4\xc3\x4f\x3b\x3c\x4b\xce\x37\x39\x4b\x4d\x8d\xcb\xe6\xe2\x89\xa1\xd6\x2b\xc1\x71\x2c\x3e\x50\x05\x9a\x84\x24\xe3\x09\x85\x62\x76\x3a\x6d\x4c\xa6\x93\xd5\x35\x51\x87\xdd\x61\x6f\x11\x1d\x8e\x52\x7f\xa9\xae\x55\x2c\x75\xf9\x41\xab\xe8\x3f\x45\xab\x14\x3f\x6d\x92\x34\x66\x51\x63\x57\xb0\xcc\xd8\x77\x49\x8a\xda\xe0\x37\xb2\xfd\xa3\x8e\x0c\x26\x4c\x84\xf0\xe8\x79\x77\x4f\x9a\x7c\xf7\xac\xc5\x6b\x96\xcf\xcf\x2c\x72\xb9\x22\x7f\x98\x77\x75\xe7\xd2\x2d\xbb\x17\x4e\x98\x34\x7f\xd7\xd6\x03\x87\xe7\xee\xa5\x93\xe3\x6f\xb9\x70\xc1\x86\xb3\xb3\xa3\x06\x4f\x30\x33\xfa\x0e\xa3\xfe\xec\x41\xa3\xc6\x6f\xb9\xf5\xea\xe6\x45\x56\xad\xe9\x92\x73\xae\xbd\x45\xfa\x61\xf3\xa7\xcb\x00\xec\x5d\x25\x8d\xa6\xa6\x11\x9e\x97\xd1\x42\xdc\xa9\xb7\xf9\x29\x1b\x25\xfb\x31\xb2\xc4\x8f\x91\x95\xfd\x18\x56\xbd\x46\x63\x41\x0f\x3e\xf0\x7b\x64\xec\x2a\xcd\x75\xb2\x8f\x1f\xa3\xd0\xa5\x97\xa1\xa6\x3d\x58\xe0\xc7\x78\xfd\x75\xec\xc7\x78\xb0\xa9\x31\xe7\xc6\xf8\xa1\x8d\xda\x4b\x32\x6f\x1a\x73\xf6\x33\xde\x7f\x52\xa0\x1f\x8e\x19\xaa\xf3\xa5\xa3\x3c\xaf\xd5\x9a\x7d\x74\x7d\xaa\x7f\x0a\x21\x29\xb4\x8b\xc2\x60\x75\x56\x8c\x04\x6d\x69\x97\xcb\xe3\x29\x6d\x11\x3d\x2e\xcc\x7a\x61\x36\x04\x0a\xaa\x66\xe4\x60\x9f\xba\xa3\x16\xce\x3c\x65\x03\x52\x01\x8c\xa2\xd7\x0b\x60\xab\xbc\x19\x41\x6c\x6f\xab\xf0\x95\x39\x9f\x6c\x48\xef\xbe\xb3\x6c\x63\x43\x3a\x79\x5e\xfa\xea\x45\x7f\x78\x54\xc1\xb1\x98\xea\xbc\x67\xc0\xe8\xcb\x1a\x09\x9c\x65\xfe\x42\x76\xa6\x27\xdf\xff\x02\x23\x1e\xde\xf7\xc0\xde\x8b\x55\x68\x7b\x1f\x06\x60\x27\xd6\x56\x0d\x84\xc3\x65\x80\x9b\xf3\x19\xd0\x4b\xd0\xfc\x32\x21\x2c\x74\xb6\x90\x32\x94\xd0\x7e\x3f\xf7\xff\x51\xf7\x26\xf0\x51\x55\x67\xe3\xf0\x39\x77\x99\x3b\xfb\x9d\xed\xce\x9a\xcc\x92\x49\x32\xd9\x13\x32\x19\x42\xd8\x32\x20\x81\xb0\x48\x02\x44\x64\x14\x08\x68\x04\x41\x76\x15\x04\x45\xb0\xa0\xb8\xb0\x2a\xe2\x86\x0a\xa8\xd4\x22\xb6\x22\x6b\xd5\xba\x54\x5c\x5a\xa5\x60\x45\xad\xb4\xee\x75\x79\x5b\x5b\x6d\x5d\xaa\x42\xee\x7c\xcf\x39\xf7\xde\x59\x92\x60\xdb\xff\xf7\x7e\xdf\xef\xfb\x58\x66\xe6\xce\xdc\x7b\xce\x73\xce\x79\xce\xb3\x9f\xe7\x09\x5b\xc2\x96\xf2\x8a\x98\x58\x1a\x8d\x0a\xa0\x25\xd9\xd8\x82\x82\x60\x10\x4d\x48\x05\xdd\x36\x2f\x29\x8d\xd3\x73\xb0\x79\x89\xe8\x89\x19\x39\xae\xe4\x47\xcb\x8e\x80\x3f\xeb\x78\x1b\xe3\xf8\x77\x1a\xf8\x8c\xab\xaf\x21\x3a\xb6\x8e\xcf\x42\x3d\xa9\x8f\xa1\x4d\x55\xe9\xe4\xfd\x54\xa6\x1b\x9e\x8c\x98\x90\x83\xf7\x22\x1e\x85\xc2\x41\x1f\xcd\x82\x1d\x60\xf4\x8a\x6c\x69\x63\xa4\xb6\x6c\xc0\x64\x7e\x51\x8a\x6c\x5a\xb4\x92\x6c\x25\xef\xac\x6b\x27\x9b\x6f\x9c\x1d\x75\xf8\x8e\x93\x7f\xf9\xe8\x8f\xb7\xed\x1a\xea\x9e\x74\xc3\xad\x6b\x6f\x5a\x53\x77\x91\xf7\x72\xbc\x78\x4a\xf5\xb0\x33\x9f\x9e\xf9\xa1\xfa\x2f\xeb\x9b\x7f\xff\xe6\x6f\x5e\xf7\xdb\x30\xe7\x07\x15\x9b\xce\x33\x02\xdc\x42\x80\xf7\x6a\x7d\x09\xab\xc1\x26\x19\xa4\xc2\xa0\x64\xb3\x19\xac\x26\x6b\x5b\x4a\x44\x7a\x2f\xc7\x39\x4c\x22\x17\xc8\x16\xed\xe9\xbb\xbe\x44\x49\x10\xf7\x2c\x2e\x01\x6f\x58\xa9\x2f\xc1\x4c\xea\x68\xb1\xca\x37\x0f\xd1\xd7\x8d\x93\x6f\x9f\x81\x0f\xdd\x8e\x39\xec\xba\x1d\x4f\xbd\x40\xde\x61\x1f\x52\x5c\xed\x5a\xf8\xfa\x5f\x67\x9a\x0a\xdb\x1e\x3e\xc8\x4e\xa1\x89\xc5\x56\x32\xd7\x13\x25\xf3\x74\xe2\x8a\xcd\x13\x36\x15\x0b\x48\xab\x9f\xb6\x01\x60\x75\x22\x1f\xa9\xca\x63\x35\x39\xb0\x09\xfb\x03\xd8\x44\x8c\x13\x36\xd6\xe0\xe5\x74\x0e\x8b\xe8\x76\xe9\x5c\x6a\xde\x67\x55\xf1\xcf\xcd\xde\xaf\xba\x33\x75\x82\xdb\xc9\xc7\x40\x0a\x66\x01\x48\xb7\xa7\x3f\xac\xb6\xa7\x11\xa8\x2c\xbb\xe1\xea\x9d\x73\x96\x57\xc8\x73\x47\x05\x6e\x98\xfa\xb3\xb9\xd8\x72\xd5\x84\x4b\xd6\xbf\xd8\xfd\x88\x6b\xa7\x73\xe0\x24\x76\x95\xfb\xd5\x87\xba\xe5\x33\xa6\xc2\x23\x5f\x1c\xc4\xd8\x57\x7d\xf0\x9e\xed\x07\xce\xdc\x2d\x08\x2b\x6e\xbc\x9b\xe6\x2a\x94\xc7\xb1\x9f\x03\x7c\x41\x42\x11\x41\x86\x09\x06\x03\xfa\x00\xac\x75\xa0\x2d\x15\x0c\xf8\x25\xab\xc1\x64\x68\x4b\x79\x4c\xa2\x8b\x61\x78\xde\x3e\x11\x14\x48\x94\xb3\x2f\x55\x57\x7c\x7e\x9e\x73\xbe\xa1\x51\x4d\x59\xa9\x1e\xe3\xcb\xcf\x2e\xcf\x3c\x21\x4c\x7c\x6c\xf0\x8a\x6b\x96\xe0\xdb\x57\xee\x2e\xdf\x54\xbe\x0a\x6f\x5f\xb6\x5e\xfe\xdd\x98\x39\xd5\xd5\x03\x36\xae\x63\xe6\x12\x4b\x4a\xf7\xae\xbd\x0e\x13\xf3\x37\xf2\xf1\x74\xb1\xbd\x5a\xb1\xf9\xb0\x1f\x53\x7a\x02\x3b\x2b\x40\x62\xd2\x4b\x2c\x25\x65\xe5\x42\x30\x48\x7c\xbc\xfc\xc4\x54\xc4\x66\x87\xfd\x64\xc7\x25\x7a\x86\x06\x58\x90\x4a\x30\x39\x10\x6a\x44\xbc\xbe\x87\x8e\x46\xa3\x26\xb2\xd1\x47\xb9\x78\x5a\x88\x33\xb5\x3a\x3c\x12\xd3\xbe\x52\xad\xcf\x91\x2d\x88\xa0\x94\xe9\x58\x52\xed\x63\xa6\x6b\xe5\x39\xb2\xd5\x10\x26\x2a\x35\x3a\xba\xb7\x11\xcf\x14\xa6\xb9\x50\x2e\x07\xf8\x6b\x49\x4c\x7d\xd4\x66\x93\x8c\xd5\x52\x75\x5d\xbf\xd2\xf2\x72\xcb\xc4\x54\xb9\x8d\x94\x53\x2b\xf4\x61\x92\xce\xb9\x2d\xc5\xb2\xc8\x29\x21\xa0\x16\x28\x90\x97\xff\x2c\x97\x12\xe6\xe9\x99\x39\x26\xdd\x7f\x3f\x16\x97\x8e\x19\xa3\x99\x77\xcf\x32\xa4\x3b\xe4\x71\xaa\x8d\x57\x3e\xfb\xc0\xca\x9f\xff\xad\x62\xdf\x62\x4a\xf9\x71\xc8\x8e\x0a\x89\xbd\xda\x21\x62\xec\x35\xea\x74\xc1\x90\x14\x98\x94\x92\x2c\x3d\xab\x3d\xfc\xb8\x35\x2e\xc7\x60\xdd\x97\x2d\xae\xa7\x9d\x7a\x31\xa9\xff\x70\xe0\xc0\xf5\xb8\xf2\xe0\x23\xc4\x3a\x4d\x6c\xd0\x3d\x6c\x71\x72\x47\x07\x1b\xd7\xac\xd3\x44\x26\xac\x4e\x7f\xce\x04\xd9\xbd\x20\x13\x5e\x46\x65\xa6\xc9\xf0\xf2\x11\xe0\xbf\x09\x55\x26\x25\xc4\xf3\x66\x8b\x49\xa7\x07\x08\xf5\x22\xc9\x64\x0e\x6b\x21\xe5\x8b\x7d\x8a\xf5\xad\x24\xe7\xb8\x2a\x5e\xbc\x44\xbe\xfc\xca\x2b\xf1\x86\x25\x23\xb5\x40\x33\x4a\xa7\x30\xec\x78\xc4\x84\x41\x8f\x0c\x81\x66\x6c\xf5\x30\x8c\x43\x10\xc2\x11\x52\xd5\xd9\x8a\x48\xac\x7d\xd0\x60\x6d\x45\xf6\x64\xa1\xdd\x6e\x9c\x90\xb2\xdb\x79\xc5\xa0\x8f\xc8\x19\x5a\x12\x19\xd4\x63\x86\xc8\x85\xdf\x6b\x3b\x56\x59\x5f\x99\x5b\x15\x23\xa6\x4e\x11\x95\xb2\xa3\xb0\xc4\x1e\x3a\x53\x94\xc2\xc6\xad\x18\xaf\x95\xc8\x24\x15\xfa\x22\xc5\xba\x5a\x66\xc2\x68\xd7\x0e\x3c\x32\xe2\x0e\x17\x0b\xb5\x6c\x1b\x33\x85\xe9\xfe\x9c\x16\xcd\x58\xe4\x28\x6f\x9c\x3a\x8b\x61\xc2\xde\xea\xee\x61\xce\x8a\x86\xce\x8b\x94\x58\x47\x78\xb1\xd1\x58\xc7\x00\xb1\x91\x49\x3a\xab\xc3\xe1\x35\x30\x3a\xa6\xa0\xd0\xce\x7a\x81\x83\x5b\xbd\x06\x1f\x28\x62\x06\xaf\x01\xb4\x7b\x7a\xa0\xc2\xd1\x97\xa7\x57\x4b\x35\x91\xab\x31\xa8\xa8\x4b\xbc\xbe\xca\x7a\xaa\x0b\x4c\xf2\x5d\x63\x17\xb0\x6e\x2b\x2e\xdf\x91\x9c\x31\x23\x09\x00\xef\xdc\xb9\x53\x9e\x5b\x13\x89\xd4\xc0\xb2\xbe\x30\x7d\xc4\x88\xe9\xf8\x7b\x6f\xf5\x99\xd7\x26\xc8\x4d\xbe\x6a\xe6\xd1\xa2\x1a\xbc\x0b\xd7\xaa\x7b\x8c\x59\x43\xeb\x8d\x94\x25\x5d\x7a\x96\x75\x88\x4e\x6a\xb7\x43\x22\x42\xa6\xf6\xbc\x13\x2a\x38\x9e\x55\x55\xec\x79\x2a\x38\xfe\xe7\xad\x77\x40\x9f\xaa\xba\x2d\x8f\xfb\xcd\x51\x7e\x61\x56\xbb\x56\xfc\xdd\xc0\x7f\x86\x42\x3f\xa5\xa8\x2b\x99\x28\xf6\xfb\x91\xc3\x11\x12\x59\x57\x69\x29\x1b\x62\x63\x65\x4e\x84\x1c\x30\x05\xa8\xb0\xb8\x18\xe4\xb0\x62\xb1\x28\xdc\x96\x2a\x42\xfe\x50\x61\xa8\x2d\x55\x28\x11\xe3\x28\x5f\xd0\xa3\x02\x5e\x73\x5f\x15\x9d\x32\x55\x84\xc8\x59\x0a\x72\xe4\x40\x93\xac\x6d\x91\xa8\x9a\xc9\x2e\xa7\xac\x50\x44\x62\x3e\xdb\xba\x5d\x6e\x9c\xba\xb7\xb6\xe2\x96\xd1\x7b\x77\xc9\x5f\x67\xd2\xd8\x11\x04\x80\x11\x31\xc7\xf1\x7d\xd1\x37\x1f\x96\x5b\x2b\xa2\x83\x2d\xae\xed\x87\x70\x67\x35\x7e\xcd\x69\x5b\xd7\xbd\x35\x53\x57\x28\xd4\x8f\x8e\x2f\x9c\xfe\x54\x67\x85\x3d\x51\x07\xb4\xaa\xcc\x11\xd6\xf9\x7c\xa6\x6a\x53\x75\xbf\xfa\xea\x3a\xa9\x2a\x16\xf2\x13\x9f\x71\x5b\xaa\xbc\xc0\x2a\x82\xd0\xe9\x9a\x98\x42\x3a\x1d\x4b\x74\xc4\x78\x26\xfa\x33\x9e\x13\xe3\x92\xb1\x8a\xaa\x92\x4c\x1f\xd5\x48\x7e\xb4\x18\x09\xf7\xd5\xf9\x3b\x07\xb5\x5c\x59\x78\xee\xf1\x11\x5f\x2e\xc7\x8f\xac\xdf\x51\x7c\x7f\xc2\xbe\x01\x3f\x7d\xcb\x79\xe7\x95\xdf\x50\xb5\x01\xef\x59\xb6\x4c\xfe\xdb\xb8\xba\x44\x43\x53\xe5\x70\x2c\xa9\xec\xe3\xe1\xbd\x6e\x4b\xff\x61\xda\xc5\xa4\x94\xdd\x4c\x12\xda\x56\xfb\xce\xbc\xef\x53\xeb\xad\x84\xe5\x71\xea\x18\x53\xc9\x1a\x67\x44\xf0\xc7\x10\xf2\x9b\x6b\xcc\x35\x30\xcc\xb2\x70\x80\xf8\x90\xdb\x52\x15\x85\xa2\x58\x2c\x19\xa5\x89\x29\x4e\xc0\xac\xd1\x8d\x6a\xda\x32\x34\xd9\xd3\x6b\xac\x39\x32\x9b\x5a\xa5\xc1\xfe\x5f\x0e\x96\xfb\xc7\xc4\xdd\x4d\xff\x66\xac\xe3\x70\xba\xba\xf1\x3f\x1a\xec\xe9\x2a\x3a\x58\x92\x77\x73\x1c\xbf\x83\xc6\xf6\x5c\x92\x4c\x54\x46\x22\xfd\x24\xc9\x6f\xf4\x97\x36\x96\x36\x0e\x1c\x64\x09\xd6\x04\x27\xa6\xfa\x55\x56\x36\xd4\xd8\xca\x63\xb0\xac\xa2\xe4\x8f\xb0\x34\x5d\xbf\xb7\x58\x62\x51\x86\x0d\x69\xd6\x43\xe4\x51\x71\x36\x9e\x17\xf2\xea\xc8\x29\x30\xd4\x83\x1f\x59\x19\xe1\x6c\x55\x4f\x3c\x9a\x59\x20\x5e\xef\xc3\x2e\x1d\xb7\x4c\x63\x4c\x3b\xfc\x2d\x2d\xcd\x92\x7d\x83\x3c\x1c\xc6\x3e\x65\xcd\x06\x79\xf2\xb2\x65\xd8\xa9\x1f\xfb\x70\x52\x9d\x9e\x2c\x8b\xfa\x6e\xaf\xde\x68\xe1\xfa\x0f\x23\x9c\x16\x68\xd9\x94\x49\xa9\xc2\x6e\x9f\x46\x89\xc7\x55\x0e\x24\x73\x25\xff\x95\xb2\x2b\xd0\x99\xd6\x03\x1f\x26\xf5\x5d\x8a\x89\x55\x2c\x60\x30\x58\xdd\x4c\x91\xbb\xa8\xa4\x34\xa8\x03\x6d\x2f\x68\xf3\x79\xda\x52\x3e\x51\xa4\xb6\x4a\x73\xa0\xa8\x17\x35\xd3\x36\x6c\xbc\x47\xb1\xdd\xec\xd8\x7a\x85\xd6\x7a\xb2\x32\xc4\x38\x5a\xdb\x25\xeb\x5d\x5d\x8c\xcd\x06\xa5\xec\x0b\x05\xbc\xb3\xf0\xcc\xee\xdc\xc0\xdb\x71\x24\xa0\x99\x0a\x10\xa4\x2e\xcd\x38\x6e\x0d\x85\xbb\x2d\x59\xee\x32\x1a\xc5\x28\x1b\x10\x03\x25\xa5\x2e\x8f\x47\x98\x98\xf2\xd8\x1c\xb6\xb6\x94\x43\x34\x8a\x16\x11\xb8\xac\x54\x84\x50\xb0\xfd\xec\x47\xf2\x72\xac\x36\x2a\x09\xec\x73\x5d\xa4\x2c\x55\x64\x81\x2a\xe6\x84\x5d\x2b\x50\xe7\xd0\x48\xe6\x85\xbc\x48\x6b\x0a\xf9\x99\x6f\x73\x68\x26\x50\x45\xf6\x13\x2a\x07\x8f\x48\x16\x39\x60\xde\x49\xe9\x1f\x2b\xef\x92\x78\x24\x92\xca\x6a\x7a\xc6\x2e\x2a\xa5\xd5\xcc\x92\x53\x50\xab\x31\xe5\xec\xaf\xdc\x2a\xcc\x79\xb5\x7f\xb2\x51\xe3\xac\xe1\x1a\x9c\x5a\x3a\xb3\xfb\xc3\x15\xf2\xc3\x4b\x97\xe2\x04\x7e\x8e\x9d\x45\x37\xfd\xdd\xac\xd4\xdd\x4f\x03\xad\xfb\x9a\xec\x99\x02\x62\x1b\xe2\xee\xa6\xbc\xae\x25\x7d\x86\x3b\xc6\xee\xa3\x76\xec\x89\xc9\xea\x52\x9b\xd7\x1b\x36\x3a\xc3\x2c\x57\xc8\x15\x96\x57\xd8\x3c\x24\x8c\x09\x53\xc5\x47\x2f\x0a\xd1\xb6\x94\x20\x62\xa0\xe7\x18\x44\x4e\x2c\x69\x85\xae\x7b\x99\x1f\xb3\x67\xc6\x22\x82\xc2\xe5\x3c\x24\x7b\x2a\xf5\x84\x2a\x01\x21\x76\x3a\xbf\x6c\x49\xa3\x56\x3a\x84\x39\xf1\xfc\x07\x9f\xbe\xff\xd9\x0b\xf8\xb9\xc6\xc2\x21\xb7\x75\x3d\xe3\x6a\x6c\x74\x3d\xb3\x66\xed\xf9\xd5\x8d\xe6\xee\x71\x53\x22\x8d\xb7\xaf\xbb\x89\xfb\xfb\xdf\xfe\xfe\x39\xff\xcf\x3b\xf4\xf2\xcf\x17\xc8\xbf\x5f\x24\x6f\x37\xec\x95\xbf\x1b\xc9\xb3\x6e\xfe\xc9\x93\x6f\x3d\x01\x63\x19\x9b\xfe\x9c\x3b\x4d\xed\x1c\x55\x28\x99\x0c\x99\xdc\x12\x2b\x45\x2b\xa2\x15\xd5\x35\x52\x50\x0a\x97\x96\x0a\xe4\x94\x0e\xb2\x86\xad\xed\xa9\x40\xd8\x8d\xb2\xa7\x91\x14\x5e\x9d\x1b\xc2\xa4\xa6\xe6\x26\x66\x49\xad\x10\x65\x63\xac\x74\x08\xa0\x84\x4b\x70\x7b\x8a\x62\x51\x2a\x8e\x11\x9f\x3c\x47\x6c\x1d\xec\xe6\xce\x79\x0b\x8f\xae\xbd\xfe\xc5\x05\xf3\x2e\x68\x9b\x65\x33\x04\x76\x97\x46\x1f\x3b\x3c\x5a\x3f\xfa\x89\xfb\xf6\xe1\x38\x2e\x7d\x12\x5b\x36\x1d\x69\x79\x6a\xfb\xa6\xb7\xe7\x2d\x78\xe7\xa6\xfb\x7f\xb9\x74\x7e\xff\xbb\x12\x0d\x0d\x8d\xc7\x3e\x4a\x3d\xf5\xd4\x27\xc7\xb1\x01\x07\xd6\x7e\xff\xd3\xdf\x7d\xaa\xc4\x72\x8d\x07\x9c\x0f\x01\x9f\xf5\xc0\xaa\x94\x90\x7a\xeb\xde\xa8\x28\x49\x01\x3d\xc3\xe8\x42\x0e\x9d\x03\x08\x2b\xd5\x4e\x4c\xa8\xa8\x40\x5f\x00\x52\xa6\xde\x16\x0d\xb0\xa0\xf2\xb9\x58\xb7\xd4\xa3\x94\x4b\x3c\xef\x2d\x37\x91\xb0\x26\x6d\xaa\x85\x5d\x6a\x70\xc2\x56\xe2\x54\xb0\x8b\xf0\x5d\x5e\x95\x47\x80\x94\xf3\x0d\xa5\x31\xfb\x50\x8c\xcf\xd9\xf1\xdb\x57\xf0\xed\x78\x27\xfe\x74\xe7\x6f\x8e\xc9\x73\x77\x76\xff\x61\xee\xb2\x2b\xe6\x33\x73\x16\x5c\xb1\x78\xb1\x3c\x0e\x64\x94\xe9\xae\xef\xdf\xc5\xbf\x2a\xc7\x37\x10\x9c\x93\x57\xb8\xbe\x79\x47\x1e\x56\x29\xef\xf4\x55\xb3\x9b\x8e\x3e\xeb\x66\x6b\x9c\xbf\x7c\xf9\xc8\x33\xfe\x33\x7f\xf0\x1c\x55\x78\x91\x23\xfd\x29\x73\x1d\xec\x0d\x17\xb1\x72\x83\x7e\xc8\x9b\x24\xb7\xc2\x64\xad\xa2\x09\x63\x9e\xd7\x53\xbd\xcb\xd1\x96\x13\x7e\x98\x53\x62\x5b\xdd\xcd\x80\x64\xc0\x69\x88\xc9\xcd\x93\xcb\x53\xf0\xc2\xac\xa7\x7a\x27\x7e\x7a\xd9\x32\xd5\x3d\xcd\x3c\x9d\xc3\x10\x55\x18\xa8\xac\xd7\x0b\x06\xf4\xff\x18\x0c\xdc\xfd\x04\x86\x1f\xd2\x1a\x0c\x40\x9b\x83\x54\x17\x6d\x49\x46\x0b\x25\xc9\xca\xea\xd9\x50\xd8\x45\xe9\x83\x5d\xb4\x72\x9c\x5e\x6f\x9a\x98\xd2\xbb\x0b\x10\xf2\xf6\xa4\x6e\x3d\x21\x51\x29\xdb\x10\xdc\x0b\x9c\x0c\x4d\x63\x36\xdc\x7a\xc7\xf0\xa3\x43\xb2\x60\xe5\xd0\xb3\xbb\x1b\xa6\xe4\x4c\x52\x52\x23\x64\x8a\x8c\x79\x27\xf5\x49\x34\x27\xc3\x22\xcf\x1b\x8d\x2e\xc9\xcd\x89\xa2\xd3\x89\x27\xa6\x9c\x36\x45\xc9\xe1\x69\x51\x3e\x7d\x7e\x21\xa1\x7c\xff\x20\x21\x61\x45\xba\x7c\x92\x3b\x08\x58\xfa\x7c\x0a\x0c\x09\x32\x50\x43\x0c\x98\x97\x00\x8e\xd3\x1b\x69\x05\xb0\x93\x4a\x70\x41\x2e\x1c\x05\xb0\x5e\x61\x0f\xcf\x3b\x0a\x2c\x0e\xb6\x30\xe8\x09\x04\x30\x31\x5b\x2a\xb1\x41\x66\x51\x24\xda\x57\x6f\x38\x72\x32\xc9\x52\x28\xf2\x1c\x50\x3d\xa1\xc9\x7a\x9e\xf2\x60\x3a\xb3\x4b\x73\x38\xb1\x1b\xb2\x70\x91\x22\xd6\x8b\x01\x2e\x27\xaa\x48\x4a\x7a\x8b\x05\xb9\x24\x52\x68\x09\xdb\x6d\xea\xb9\x07\xa9\x97\x27\x32\x93\xf5\x5d\xca\x55\x5c\x99\xc5\x8a\x46\xba\x41\x4e\x6e\x20\xfa\x29\xf3\x31\xad\x31\x48\x4b\xa1\xe1\xe3\x4a\x89\x1e\xe8\x6f\x20\xf4\xb7\x99\xf6\x57\x9d\x74\xeb\x4c\x4e\x93\x4b\xd2\x99\x0c\xb0\x0a\x06\xc9\xc9\x30\x40\xae\x19\x5b\x4f\x05\xae\x29\x1b\xfe\x9a\x23\x95\x88\x38\x3a\x90\xd4\x4c\x21\xfd\x35\x34\x93\x72\x29\xec\xe3\xce\x0f\x8e\xcb\x94\x71\x30\x25\x77\x2d\x96\xae\xa6\xb1\xe0\x40\x98\x5e\xa1\xb6\xa7\x20\xea\x4c\xd6\x4b\x36\x9b\x25\x80\xb1\xce\x6d\x71\xd9\xed\x16\x1d\x41\x57\xc9\x06\x93\x40\x6a\x3c\x70\x06\x83\xbf\x3d\x65\x00\x65\xce\x20\xda\x71\xbe\xe2\x9b\x1b\x51\x93\xb1\xf8\x65\xa3\xe6\x54\xe5\x24\x8b\x1d\x8a\x25\xd9\x09\xea\x3c\xce\xc4\x89\xe2\xd6\x5b\xe4\x89\x2b\x57\xe2\xdd\xfb\x1f\x9d\x79\xfe\xd7\x5d\xdf\xc8\x67\x1e\x9a\x75\xf9\xe4\x0b\x16\x77\xe1\xad\xf2\x7e\xbf\xca\xee\xae\x59\x3b\x7d\x5d\x40\xbe\xc3\x5d\x8d\xb7\x62\xb1\xeb\x3c\xf9\xa6\xf3\xd5\x98\xf6\x9c\x71\x4c\x4b\xf6\xb3\xc3\xa5\x2d\x18\x34\xf8\x58\x87\x24\xb1\x06\x18\x87\x43\xb4\x15\xc2\x26\xb3\xd9\x04\xb3\x24\x8a\x46\xaa\xde\x89\x02\x48\x15\x82\x41\xad\x53\x91\x8b\xd5\x54\x85\x47\x7d\x8f\x42\x31\x7f\x67\xd3\x3b\xc5\x01\xd1\x04\xac\x06\xbe\xda\x99\xcb\xcf\x9f\xf9\xe8\x7e\xf9\x02\x18\xc8\xcf\x6f\xb9\x19\x73\xdf\x74\xc9\x8d\x4b\x2f\xee\x5a\x7c\x01\x83\x02\xeb\xa6\xaf\xbd\x46\xd5\xa8\xfd\xf2\x7e\xbc\xb5\xda\x7d\xe6\xd3\xc9\x17\xcf\x9a\x22\xdf\x94\x17\xb3\x9e\x20\x91\x29\x3e\x73\x8c\x8f\x98\xfb\xd7\x38\x1a\x22\x0d\x91\xfe\x8d\xd5\xd5\xfd\x8a\xfb\x55\xb4\xa7\xfa\x15\x94\xba\x7d\xbc\xa8\x18\x9c\xdd\xa2\x3b\x9b\xb6\x41\x65\x77\xcd\x3d\xa3\xa3\x69\x60\x0a\x95\x63\x9d\x3f\x1a\x9b\xae\x78\x3b\xa4\xfc\xad\xb3\xe6\xac\x91\xe9\xfb\x1e\x1d\x30\x4c\x29\xc3\x73\xce\xb8\x6d\x0f\x62\xe6\xac\x61\xe9\xcd\xeb\x37\x1b\x26\x93\x82\x3c\xc7\x00\xfd\xb0\x05\x64\xd6\xf7\x61\x9c\xaf\x02\x6d\x0e\xa0\xda\xa4\xc7\x2f\x08\x66\x97\x8b\x1c\x9e\x21\x1a\xb8\x17\x19\xed\xbd\x4c\xe6\xb9\xe6\x81\x1c\x0b\x79\x56\x26\xa7\x63\x61\xee\xa1\xfb\x2b\x1b\x6c\x40\x76\x19\xf7\x28\x35\x7a\xff\x5a\x33\xf6\x70\x43\xc9\xa7\x1c\x18\xa2\x68\x64\x32\x1a\xf1\x81\x8e\xab\x03\xdd\xa8\x44\x09\x47\x8c\xd8\xed\x9c\x9b\x84\x45\xf8\xdd\x48\x89\x47\x2c\xc8\x26\xae\xee\x55\xcd\x53\x75\x36\x48\xf9\xf5\x80\x88\x8d\x27\xbf\x1a\x69\x5c\xc2\x3f\xcb\x42\xf7\x97\xbf\x64\xad\x54\xfb\x86\x8e\xd6\x00\xbc\xbf\x83\x1d\xab\x7d\x3e\xd3\xd9\x41\xcf\xc3\xbd\x9f\xfe\x3c\x3b\x5f\x56\x41\x40\x64\xbe\x2c\x76\xbb\xb1\x3d\x65\x77\xb3\x84\x75\x80\x5e\xd3\xe7\x7c\xb1\x4a\xdc\x79\x0f\x7a\xa8\x90\x87\x30\x59\x37\x65\x05\x09\x9d\xa0\x34\x82\x7b\x94\x2c\x52\xf7\x1c\x6d\xb9\x98\x3b\x54\x3a\x91\x3e\xae\xce\x97\x11\x55\xa0\x73\x93\xe5\x28\x14\x2a\xf6\x9b\x9c\x4e\x5d\x71\x71\x65\x55\x11\xf0\xd2\x62\x49\xe7\xe7\x8a\x8a\xbc\x65\x65\x40\xa3\xcc\x65\xa8\x00\x16\xb3\xa0\xc0\x0b\xa4\x3a\xcf\x9c\x4e\xcc\xc0\x1a\x78\xaa\xe8\xab\x06\x10\x92\x39\xd2\xe8\xa6\x53\x02\x61\x2c\x4a\x0e\xc9\x69\xa6\x76\x96\xbe\x56\xd4\x55\x0c\x1e\xc6\x96\x35\x0c\x4d\x32\xbb\xd4\x1a\xae\x78\x66\xc1\x68\x7f\xbf\x41\x87\x66\x2c\x59\x7e\x51\x3c\x86\xc9\x9c\xca\x1f\x46\x6b\x26\x9e\x6b\xaa\xe3\x77\xd1\xb5\x1f\xe2\x74\x5e\x7c\xcf\xf9\x4d\x77\xcc\x6c\x3b\xff\x52\x13\xd7\x40\x29\xad\x52\xdb\xa8\x9a\xbb\x0e\xb9\xd1\x80\x64\xc0\xed\x74\x32\xbc\x99\xf7\x78\xdd\x2c\x07\x70\x3b\x39\x4e\xc4\xa2\x61\x42\x4a\xc4\x4a\x3c\x47\xfe\x92\x6b\x93\xcb\x47\x69\x14\x3c\x55\x35\x12\xaa\x82\x41\x28\xc1\xd8\xe6\xdc\x42\x46\x2b\x5d\x6f\x74\x30\xd7\x69\xe5\x8b\xba\xe7\x57\xc7\x90\x56\x8f\x6a\x34\xf4\xef\x41\x83\x93\x85\x6e\xa3\xd5\x2a\xb0\xac\xd7\xc7\xf3\xc8\x68\xb4\x80\x4c\x9e\x34\x8a\x12\x42\xf6\x5c\xa9\x80\x54\xa1\xca\x6c\xec\x4c\x74\x5f\xef\xa2\x53\x8a\xd5\xe7\xc8\xad\x77\x28\xc7\x2e\x73\x84\x00\x76\x15\x3d\x6b\x79\x66\x7c\x46\x8f\x61\x94\x9c\x3c\xb4\xee\x46\x11\xd0\xff\x7e\xce\x70\xd8\x6a\x72\xf1\xa1\x90\x0f\x99\x50\xb4\x58\xa2\xb2\x4a\x58\xad\xbb\xe1\xb4\x58\x38\x8f\x5d\xd4\x17\x80\xe8\xa4\x77\x73\x58\x25\xff\x99\xfa\x3e\xf9\xa1\xf5\x79\x71\x16\xf1\x0c\xfd\xa7\xd6\x03\xbb\x76\x7e\x40\x09\xad\x27\x5b\xa3\xbe\xd1\x1e\x91\x5c\xec\x2c\xad\xb2\xcf\xa5\x97\x5e\x05\x94\xf6\xc6\x8d\x38\xbe\x40\xe6\xaf\x99\x27\x5f\x85\x0f\xc9\x9b\xd5\xaa\x3e\x87\x3a\xf0\x54\x5f\xb5\x3c\x5d\x79\xed\x90\xf7\x84\x70\xe3\x9e\xbd\x74\x5e\xa7\x80\xae\xc0\xd0\xfa\x0b\xa4\xee\xac\x59\xb0\x46\x0b\x82\x5e\x6b\x01\x1b\x63\x63\x15\x95\x21\xb3\xd9\x12\xd5\x5b\x08\xba\xea\x74\xa8\xc0\x92\x17\x00\x97\xa9\x7c\x92\x1b\xfa\x96\x89\x06\x55\xc2\xdf\x1a\xfa\xab\xe5\x7b\x1a\xd5\xf2\x3d\x71\xad\xd0\x8f\x47\x29\xf4\x43\x79\x03\x53\xfd\xc1\xd7\x07\xb6\xeb\x9a\x6f\xae\x29\x6b\xb4\xe2\x07\xa4\x25\xd7\xdc\xb6\xf5\xf6\x2d\xd7\x2c\x96\xf0\x2e\xb1\xb1\xac\xe1\xfa\xa1\xba\xed\xfb\xff\xe9\x7a\xe1\xc5\xdb\x5f\xf6\x27\x8c\xb3\xbe\x4f\x23\x71\xd7\xda\x9f\xde\x79\xd7\xee\xeb\x77\x8a\x18\x7d\x3f\xcb\x98\x08\xbc\xbc\xf5\xc5\x17\x14\x79\x80\xac\x0f\xd1\x93\x0b\x51\x53\xb2\x50\xb0\xb8\x18\x3f\xe3\x0f\x86\x40\x4b\x26\x51\xd3\x36\x9e\x6d\x4b\xf1\x22\x32\xe4\x84\xf1\xe5\xe9\xc4\x24\x76\x8f\xe4\x73\xc9\x94\x53\xea\x55\x2f\x8e\xd1\xe1\x37\xe5\x5f\xc1\x54\xef\x99\xb6\xfd\xdc\xce\xf3\x14\x7a\xbe\xfd\xb6\xb9\xaf\xb8\xf0\x60\x66\x28\xa8\x97\x5d\x27\x6f\x78\xff\x8e\x3b\x1f\x24\xf4\xe0\xb9\x63\x8f\xc8\x3f\xdc\xad\xc0\x45\x83\xf3\xd9\x67\x91\x15\xc5\x93\x5e\xce\xc0\x98\x0d\x66\xd1\xc6\x0a\x46\x9b\x99\x61\x0c\x1c\xa9\xfd\x84\x84\xbc\x1a\xce\x8e\xa6\xdc\x6c\xf4\x89\x46\x83\x72\xc4\x13\xb4\x28\x20\xdd\x63\x6e\x97\xff\x2e\xff\x70\xbb\xfc\xe0\x05\x78\xf9\x18\xbc\x66\x46\x75\x80\xb9\xa9\xfb\x4a\xe2\x7c\x62\xaf\x3d\x73\x83\x66\xe3\xe2\x41\xc5\x7e\x0e\xfa\x74\xa1\x61\xc9\x90\x60\x66\x1c\x66\x87\x44\x8e\xd0\xe9\x2c\x20\xb7\xda\x2c\x36\x07\xc3\x98\x05\x23\xc8\x27\xc8\x98\xd7\x35\x59\x59\x25\x72\x29\x0f\x02\x13\x8e\x9a\x34\x20\x02\x14\x0e\x8e\xd9\xfe\xde\x47\x1d\x1f\xbe\x71\xb7\x7c\xf7\xa5\x78\xd0\xf8\xcf\x3e\x1e\x83\x5b\x16\x02\x2c\x57\x77\xdf\xc3\xcc\xe9\x5e\xa5\xc0\xd3\xbd\x95\x99\x97\x85\xc9\x06\x82\xc6\x17\xfc\x2c\x58\x9f\xe1\xc9\x08\xcc\x43\xc0\x1e\x30\xb0\xc1\x90\x9f\xb5\x0a\x56\xf7\x84\x94\xc3\x2a\x04\xfa\x9e\x10\xdb\xd1\xfa\x4c\x55\x3f\x4f\x2e\x50\x0a\x44\x43\x19\x5a\x19\x4d\x21\x88\x22\x26\x93\x34\x68\xab\xfc\xed\x6d\xf2\xae\x8b\xf0\x42\x12\x37\x1a\x2c\x9f\xa4\x05\x8e\xe2\x59\x64\xc2\xb6\x74\xcf\xa7\x00\x3e\xf4\xd0\xe6\x31\xac\xa8\x44\x8b\x9e\xd9\xac\xc1\xa9\x03\x38\xff\x4a\x75\xb2\xa6\x64\x01\x63\x30\x90\xe0\x21\x33\x06\x1e\x02\x42\x75\x5b\xca\x69\x16\x49\xac\x6e\x5b\x4a\x27\xe5\x69\x98\x6a\x0c\x8c\x16\xa3\xdb\xa3\xdc\x52\x80\xbc\xb1\x7f\x9d\x2b\x9f\xdc\x22\x37\x6d\x96\x9f\x9e\x8d\x1f\x58\xfa\xd5\x5f\x16\xe3\x71\xec\x2a\xb7\x6c\x96\x5f\xa3\xa2\x6d\x39\xfe\xc1\x4d\xc4\x9d\xe5\xf8\x26\xaf\x0a\x4b\xa3\xdc\xc2\x4d\xa7\x67\xd4\x80\x93\xd8\x75\x82\x2d\xcc\xf9\x3c\x3e\x9b\x45\xc7\x47\x8b\x6d\x7a\x2b\x88\xf8\x16\xab\xa8\xb3\xf3\x40\xfe\xdc\xbc\x14\x42\x08\x94\x61\xd4\xb3\x02\x6b\x5f\x69\x9e\x89\x7e\x94\x97\x83\x45\x29\xfa\xc3\x64\x85\x1a\xf6\xf8\xb6\x07\xbb\x77\xe5\xe6\x62\xd1\x4a\xff\xa8\xb2\x8c\xdc\xf2\xc1\x71\x53\x36\x27\x0b\xa9\xfd\xf3\xdc\x2c\x85\x1d\x52\x7a\xd9\x98\x5e\xcc\x9e\xa2\x31\x0a\xc5\x68\x72\xb2\xa6\xc0\x1e\x32\x1a\x91\xe8\x08\x14\xe9\x74\x01\xd1\x6b\xe7\x4b\x4a\x03\x4e\x9f\xb3\x3d\xc5\x82\xf4\xc0\xb2\x36\xaf\x4f\x0c\xd9\x0b\x6c\x05\x34\x68\x55\xd2\x8e\xe1\xa8\x38\x59\x99\xa7\xbb\x64\x86\x51\xa2\x16\x03\xd5\x91\x14\xcb\xd1\xfe\x8d\x79\x23\x2a\x29\x12\x88\x0c\x57\x8a\x37\x9c\xf3\xfc\x82\x8b\x96\xad\xb9\x56\x7e\x3f\xe4\x6d\x75\xfa\xe5\x13\x79\x83\xfa\xea\xc1\x15\xff\x7a\xa8\xa5\x7d\xd5\x5d\x17\x4d\x38\x7f\xfa\xf0\x73\x3b\x06\x65\x87\xf4\xf2\xcb\x97\x94\x0f\xa4\xeb\x40\x73\xc3\xc2\x58\x42\x68\x6c\x32\xe6\x17\x6d\x3e\x23\x2d\x60\xa4\xd4\x2f\xb2\x7b\x60\xfa\xfd\xa2\x48\xfc\xcf\x22\x72\x7b\x44\x24\x64\xcb\xd4\xc4\x7b\x55\x30\xca\x66\x38\xc3\x59\xcb\xbe\x56\xc0\x28\x73\x78\x90\x9c\xad\xc2\xf3\x66\xfe\xb2\x5f\xdd\xf6\xd6\x27\x7f\xb1\xeb\xd6\xb1\xb8\x5c\x56\x80\xfe\x58\x7e\xfa\xf0\x63\xb2\x2c\xb7\x54\x44\x07\x5b\x9d\xf7\x1e\x7c\xe8\x89\x7e\xf8\x18\x81\xb8\x41\x2e\xf5\x1f\xfd\xc5\x5b\xdf\xc0\xdc\x3b\x54\x78\x4b\x50\x3f\x74\x71\xb2\xb1\x56\x08\x3a\x5d\x85\xd6\x48\xa4\xd0\xe9\x17\xf8\xfa\x78\xa1\x14\x00\x72\xee\x0c\x06\xed\x6d\xa9\x60\xd0\xe8\x0f\x88\xe6\xf2\x28\xc3\x01\x47\xad\x6a\x4f\x19\x25\xae\x74\x02\x71\x9e\x6b\x12\x89\x1a\xfd\xd5\x73\x28\x9e\x5c\xa3\x5c\xae\x04\xd2\xf7\x68\x40\x4e\x21\xb1\x0c\x4a\x11\x7d\x97\x9b\xf9\x9d\x49\xba\xf9\xf8\xb6\x47\x37\x2d\xfd\xfd\x0e\x77\xaf\xe1\xcd\x0d\xda\xe4\xa6\xc9\x1b\xab\x87\x3f\x36\x71\xdc\xcc\xab\xe4\x71\x55\x95\xd3\x6f\x98\x3f\x6d\xc9\x8e\x61\xe7\xf7\x18\xed\xd3\x2b\x86\xb6\xcd\x1c\xd0\xd0\x3a\x79\x4c\x62\xc8\x78\x65\xcf\x74\xc1\xfe\x1d\xcd\x3f\x82\xfc\x20\x2f\x04\x7d\xac\x1e\xb4\x1a\x2b\x1b\x28\xf0\x72\x1c\xb6\x3a\x1c\x20\x09\x3a\xb0\x8f\xc5\xac\x6a\xbe\xcb\x86\x3b\x11\xc1\x25\x87\xc2\x90\x83\xe3\xca\xd1\x48\xe5\xf8\xad\x86\x6a\xa0\xb8\x33\x8f\x75\x7f\xb6\xb7\xf5\x96\x15\xaf\x2f\xbf\x26\x3a\x7c\xc4\xcb\xe7\x3e\xf7\xca\xee\xfb\xf7\x26\x02\x8c\xc5\xe8\x7a\xfa\x29\x72\x36\x12\x33\x85\x95\x1f\xbc\xf1\xfc\x3f\x83\x72\x4d\x80\xc2\x34\x02\x60\x2a\xa7\x30\x0d\x4d\x06\x75\x26\x9b\xcd\x45\x5c\x6b\x05\x76\xa3\xd1\x8a\x3d\x1e\xd0\x92\x3d\xd8\x64\xb3\x02\xa3\xb2\xf6\x09\x93\xea\x45\xa9\xd7\xf4\x65\x90\x5e\x42\x1a\x81\xd1\x52\x33\x7b\xd8\xf2\xe1\xd1\x6b\x96\xbf\xbe\xe2\x96\x56\x72\x7e\xf3\xfe\xdd\xbf\xfd\x75\xdb\x8b\x23\xb8\x99\x0f\x4d\x90\xef\x7b\xf2\x19\x97\xb1\xfb\x2b\x1a\xec\xff\xfb\xe0\x3f\x8e\x9e\xfc\xb0\xb2\x50\x9d\x2b\xe0\x99\xa3\x79\x52\x9f\x3a\x99\x0c\x49\x56\x2b\x6b\xf4\xb2\xde\x40\x81\x55\x92\x90\x9d\x58\x5f\xda\x53\x1c\x02\x05\x31\xa7\x66\x8e\x66\xf9\xcf\x42\xa6\x2a\x7b\x3c\x89\x71\xa6\x22\x3d\xc8\x79\xb5\xd8\x9e\x31\xa4\xb9\x74\xf8\x57\x00\x49\x06\x38\xc6\x4b\x80\x73\x55\x16\x62\xe6\xa1\x09\xf8\x22\x02\x1b\xc3\x12\xd8\xe4\x01\x14\x36\x02\xd7\x78\xc0\xdf\xf1\xc0\xcb\xbd\xa8\x2a\xe9\xb1\x31\x92\x81\x61\x7d\x7e\x1d\x88\x7b\x46\x9d\x4d\x72\x22\xe7\x84\x7c\x2a\x97\x29\xe6\x09\xec\x3b\x27\x4e\xd8\x87\x33\x25\x9e\x3c\x72\x63\x36\x2e\x38\x53\x9c\xea\x1f\xf8\xa7\x7f\xed\x56\x82\x81\x2f\x95\x53\x27\x0f\xaa\x35\x9c\xb2\xf5\xd5\x4d\x30\xec\x22\x34\x24\x59\x88\x3c\x85\x85\x66\x9d\xdd\x6c\x8f\x16\x87\xfd\x61\xbf\xd5\x65\x05\x49\xc2\xea\x72\x01\x1a\xa9\x25\x3d\x73\x92\xa4\xd9\xf3\x8b\x46\xe7\x66\x10\xcf\xa9\xa5\x9e\xeb\xcf\x2e\xd1\xf2\x87\xbf\xd6\xa3\xa6\xfa\x19\xcd\xbb\xcd\xec\xc8\xcf\x1d\x2e\x3f\x93\x5b\x5c\x1d\x4f\xd2\x3c\xdd\x2c\xd5\xef\xaf\xa3\xf6\xf6\x02\xf8\x7c\x69\x72\xa0\xd9\x50\x58\x50\x10\x31\x18\x18\x98\x49\x5b\x69\x0c\xc5\x70\x80\x35\x07\x0a\x0b\x03\xa0\x7e\x14\x16\x14\x32\x66\xb6\xb0\x10\xf1\x7c\x49\x7b\x4a\x15\x92\x08\x13\xd1\xbc\x1f\xb9\xb5\x9d\xb4\xa8\x47\x4c\x4f\xbb\x66\x86\x68\xd7\x8e\xba\x66\xcd\x15\x6a\xe0\x5b\x4c\xa5\x6c\xbe\x0c\x8d\x2b\x01\x65\xff\xd6\x77\x0e\xcf\xef\x5a\x75\xe3\xb1\x4f\xc4\xad\x2b\xae\xbb\x7b\xee\xdc\xab\xe6\x2f\x5c\x31\x4b\x51\xf6\x17\x5c\x39\xe3\x52\x8f\xde\x3a\x6b\xd6\x86\xab\xdb\xa7\x74\x75\x4e\x90\xb7\xe2\xa7\xda\x67\x4c\x68\xcb\x8f\xe1\xab\x26\x11\x2b\x5e\x53\x89\x23\x52\xc2\x06\xb9\xca\x60\x65\x4d\x6d\x11\x49\x99\x30\x21\x65\xb3\x05\xca\x68\x0c\x9f\x8d\xc6\xf0\xb9\xff\x6d\x0c\x5f\x09\x95\xf3\x34\xa2\xe4\xe9\x4f\x4e\xfc\xd4\x62\x2a\xb0\x7a\xe8\xea\x34\x26\xd4\x0d\xe6\x20\x88\x7c\x77\xd7\xf6\x29\xe7\x6f\xbf\xe4\xf2\x9b\x7f\x32\x67\x79\xd8\xed\x6e\xee\x9a\x73\xd5\xfa\xc5\x3b\x0e\xcd\x9b\x3c\x69\xe1\xa1\x1d\x2f\x7e\xf2\xc7\xf5\xe3\x6f\x9b\x77\xd9\x6d\xe3\xcf\x6d\x19\x34\xce\x60\x9a\xc1\x19\x2c\x13\x07\xb7\xb4\xed\xd8\x72\xfd\xe4\x65\x66\x41\x5c\xd4\x76\xdd\x56\xf9\xf4\xa7\x5f\xc8\x6a\x6e\xb1\xf4\x3f\xb9\x09\xdc\x8b\xa0\x25\x8e\x4f\x96\x89\x11\xb7\x1e\x05\x22\x81\xca\xaa\x32\x62\x33\x2b\x8b\x06\xdc\x34\xd0\xdc\x1b\x8c\x46\x41\xa1\x30\x44\xc5\xa0\x03\x68\x75\x1f\x21\x57\xaa\x78\x94\xf1\xad\x67\x6c\x6a\x85\x38\x2f\xe8\x4a\x29\xdc\xa0\x94\x0f\xb6\x45\xea\xa9\x9f\xc7\xc3\x4d\x50\x94\x43\x25\x02\xeb\xc6\xb5\x6a\x04\x16\x09\xcc\xc2\x4f\x2f\x59\x66\x98\x3b\xff\xdc\xe1\xec\x27\x44\x39\x7c\x75\x7d\xf3\xef\x4e\x1c\xfd\x9d\xdf\xf6\x03\xb1\x2f\xc9\xaf\x0f\xfb\xee\x03\xfc\xb9\x7f\xe7\x8d\x4e\x3a\x16\xc0\x39\xce\x4b\x75\xa3\x79\xc9\x66\x9d\xdb\x1d\x10\x9c\x4e\x6b\xc0\x5a\x50\x88\x0a\x6d\x85\x75\x85\x40\x80\xdd\x70\xed\x0b\x10\xb1\xa9\x3d\x25\xea\x42\xba\x36\x5d\xa7\x6e\xa1\x8e\x37\xb3\x3a\x1d\x63\xf7\x49\x16\x3d\x0f\x4b\xdc\x96\x32\x32\x62\x4e\xec\x8e\x7a\xf4\xb6\x52\xb9\xce\xa2\x9d\xc6\x76\x9c\xf9\x87\x8e\x15\x82\xa8\x66\x14\xdf\xb5\x12\xdf\xbe\x04\x1f\x21\xaf\x4b\xe4\xcb\x56\xca\xad\xe4\x55\x71\x0b\xc9\x0f\x12\x75\x48\x31\x81\x83\xdc\xb5\x58\xde\xa4\x04\x6e\xb0\xe9\x07\x41\x77\x37\xa8\x31\x2d\x65\x24\xaa\x05\x89\xa2\x31\xa8\xd3\x95\x18\x8d\xe5\x15\x6a\x5c\x4b\xa9\xa1\x94\xc6\xb5\xb0\x6a\x5c\x0b\x1b\xc9\x96\x98\x38\x4b\x4c\x4b\x26\x3e\x4a\xad\x9e\x0d\x68\xd6\x57\x54\x8b\x4b\xb5\x87\x80\x7a\xbf\xd2\x78\xc3\xb2\x19\x4b\x96\xcc\x4d\x6d\xc0\xf1\x9b\x57\x6b\x87\x30\xe5\xa5\x0d\xe5\x83\x87\x5d\xd8\x9c\xfc\xe5\xaa\x35\xd3\xce\x1d\x37\x83\x7d\xc5\x57\x7d\xfa\x8b\x0e\xfe\x4e\x75\xf7\x7f\xff\xa7\xf2\x9a\xd4\x79\xfa\x04\x5d\x13\x83\x3c\x8e\xfd\x10\xd6\xc4\x87\x2e\x4c\xd6\x59\xf4\xd8\x2a\x08\x3a\x64\xb3\xe9\xf4\x92\x5e\xf2\x07\x7c\x80\x5d\xbe\x80\x64\xd3\x5b\x8c\x16\x12\x37\x67\x15\x38\xce\x61\x14\x75\x38\xa3\xac\xe6\x85\xa3\xe5\xc4\x7a\x51\xf7\x50\x26\x44\x41\x55\x4e\xb4\xf0\xb9\xdc\x68\xaf\x7d\xf2\xaa\x8b\xe4\x03\x57\x62\xb3\xfc\xf0\x2c\x7c\xdd\x64\xcc\x5c\xdd\x85\xaf\x5b\x76\x8b\x7c\x1c\x7f\x2a\xcf\x0c\x54\x57\x7b\xb0\x83\x71\x78\xc8\x7a\x5c\xb6\x0e\x5b\xa9\xdf\xba\xd2\x5b\xad\xe1\x13\x5b\x05\xb0\x8b\xa4\x46\x1a\x63\x32\x09\x36\x3b\x56\xdd\x22\xc4\xc2\x2b\x00\x31\xcb\x56\xb4\xec\xe1\xdc\xa4\xf9\x3f\x14\xe7\x9a\xe6\x1f\x3c\x7a\xcd\x63\xd7\x8c\xaf\x6c\xb6\x74\xeb\x80\xfc\xdc\xcf\xae\xf2\x9d\xf9\x9b\xf9\xd7\xf2\x7b\x0a\xcd\xd1\xce\x7d\x90\x98\xd5\x10\xec\xc6\x71\xc9\xb2\xb0\x2b\xa4\xd7\x97\xfa\x2c\x2e\x4b\x65\x55\x21\xec\xc7\x42\xec\x21\xd9\x7c\x3c\x36\x47\x14\x68\x4c\x36\x91\x4f\x96\x05\x21\x6f\x4e\xa6\xa5\x9c\x28\x97\x9e\xf6\xed\xec\x89\x4f\x45\x56\xc2\xd9\x33\xa1\xdc\x36\x65\x2f\x5e\x2a\x2f\xd6\x52\xf3\xcc\x5e\x42\xac\x34\x67\x2e\xcd\xe6\xe5\xa1\x91\xa9\x3f\x8c\xcd\xcf\xc6\xe3\x3e\xe7\xc4\xfb\xce\x33\x23\xd4\x63\xa1\xb9\x32\x50\x11\x3a\x3f\x59\xe5\x2d\x28\x60\x22\x11\x8b\xe0\xb2\xb8\xa2\xc5\x05\x91\x10\xe0\xab\x87\x0d\x90\x0a\x8c\x29\x2f\x06\x49\x08\xdb\x43\x92\xc5\x6e\x37\x90\x18\xba\x3e\xb2\xab\xe4\xa5\xb7\xca\x14\xab\x76\x26\xe2\x89\xbe\xa4\x23\x62\x5c\x91\xe8\x60\x13\x73\x4f\xf5\x90\x91\x4e\x9d\x22\x92\x09\xb6\x77\x7c\xd7\x4b\x50\xfa\x55\xc7\x73\x44\x04\x78\x2e\x47\x56\x2a\x22\xf9\x48\x02\x61\x7a\xc6\xd3\x2a\x59\xa5\x68\xb1\x29\xa4\x04\x95\x85\x0d\x21\x43\x88\x73\xdb\xed\x3e\x02\x32\x31\xaf\xb7\xe7\xc5\x95\xd1\xa2\xf5\x30\x45\x79\x89\x5b\x55\xc8\x09\x43\x56\xe1\x23\xd5\xd7\x32\xd2\x93\x3d\x2b\x58\xc1\x10\x98\xd1\x04\xd2\x53\xa7\x54\x29\x4a\x93\x5d\x4e\x61\xbb\x02\x66\xc7\xaf\x54\x31\x4a\x96\x35\xf9\xea\xbb\x0e\x25\x57\x96\x6e\x30\xb5\x3f\x96\xa0\x2a\x34\x27\xd9\x58\xe0\xb4\x55\x55\x19\x50\xa4\xd4\x11\x71\x70\x3e\xce\x57\x5d\x53\xe5\x0c\x80\xd2\xe3\x0d\x48\x8e\x98\x2d\x06\x48\x6c\x13\x15\x57\x9b\x50\xdc\x9e\x12\x6c\x4c\x08\x44\x1b\x46\x2b\xfe\x97\xa9\xab\x9e\xaf\xc8\xa9\xc6\xea\x78\xd6\x7f\x59\xd2\xf3\x5c\x51\x46\xa3\x63\x23\xd9\x4c\x59\x3c\x95\xc8\xed\xcc\xeb\x99\xf3\x38\xf7\xe1\x11\xcc\xba\xac\x66\x77\xe6\x29\x39\xa4\x1d\xdf\xe1\x4a\xa8\x92\xa4\x9d\xcd\x51\xd2\x63\x85\x54\x45\xef\x29\xed\x10\x8f\x87\x84\x11\xa5\xb5\x18\x68\xdd\x78\x18\x7b\x3d\x1a\x8c\xd6\x25\x47\xc7\x2b\xdc\xee\x12\xff\x80\x6a\xd1\x56\x65\xac\x12\xd9\x01\x5c\xb0\x2e\x58\x37\x64\xa8\x58\x5d\x0d\x7a\x52\x75\x75\x85\xaf\xca\x5e\x01\x7a\x53\x85\x58\x56\x4a\x4e\x92\x46\x06\xb5\xa7\xa2\x11\x5b\x41\xff\x09\x29\x7f\x81\x9b\x52\x27\x29\x57\x8f\xca\xda\xce\xf2\x6d\x37\x79\x81\xc7\x99\x7c\xcc\x99\x14\x62\x7d\x6a\x58\xf9\xe7\x96\xb2\x33\xa6\x28\x5d\x99\xe9\xe2\x66\xf7\x56\xbf\xf2\x4e\x33\x91\xd9\x3b\xa4\x68\x63\xa7\x1f\xd7\xe6\xad\x97\x5e\x46\xa2\xac\x7a\xcc\xa2\xa6\xa9\xb1\x37\x2a\xb3\x48\x4d\x44\x63\xd2\x8b\x75\xbf\xa6\x67\xcf\x6c\x28\x81\x86\xa0\x5b\x93\xe3\x51\x71\xc4\x66\x2b\xb0\xf3\x03\x6a\x6b\x4b\x1a\x8c\xd1\x41\xd1\x06\x3e\xc8\x49\x95\x52\xe5\xd0\xe6\xb2\xfe\xed\xa9\xb2\xb2\x44\x64\x80\xad\x38\x01\x98\x53\x9b\x90\xa2\xa6\x88\xa9\x3d\x15\x11\x43\x85\x6d\xa9\x10\xf2\x7b\xbd\xb0\x53\xbc\xb6\x7a\x67\xd2\xee\x74\xb2\x13\x52\x4e\x75\x83\xf8\xbd\xb6\xdf\xf5\x70\x0a\x66\x4c\x18\x8e\xbc\x00\x86\xac\xa6\xad\xa1\x99\xb3\x27\x2a\x09\x7d\xcc\x62\xbc\xa7\x52\x8e\x55\x45\x5c\xee\x81\x5a\x3b\x7a\xa2\xe1\xaa\x1e\x8a\xfa\x66\xd6\x48\x95\xf3\x7c\x64\xbb\xac\x17\x46\x66\x75\x77\xec\x55\x55\x76\xc0\x47\x57\xfa\x73\x6e\x28\x77\x1d\x8a\x00\x46\x76\x24\xab\x0c\xa5\xa5\x3a\xc6\x5d\x54\x15\x0c\x8a\x45\x0c\x17\x6f\x70\x57\x99\x11\x89\xf5\x11\xcd\x36\xb6\xc4\x50\x42\x2c\xc9\x3a\x83\x88\xca\x73\xcc\x9c\xfe\x63\x59\x0d\x23\xd7\xfc\xa4\x59\xb5\x8b\x34\x83\x72\xa4\x4f\x17\x11\x6e\x68\xa4\x76\xe6\x88\xea\x49\xc2\x53\x7e\x43\x0c\xcd\xb8\xe6\x9c\x89\x3d\x1d\x44\xf2\x7b\xfd\x9e\x4c\x24\xf1\x00\xc5\x81\xe4\x3a\xce\xdc\x4b\xec\xcf\xbe\x9e\xde\x21\xe6\x77\xd3\x93\xdd\x53\x47\xd5\xab\xfe\x23\x75\x9c\xa0\x2b\x9d\x00\xbc\x29\x07\x5d\x3f\x95\xac\x89\xd4\xd6\x56\x15\xb9\x5c\x66\xbf\xe0\x17\xea\xcb\xe2\xe5\xa5\xa5\xa0\xa3\x94\xa2\x40\x4d\xa4\xa6\x3d\x15\x8c\x88\x9e\x8a\x09\x29\xc9\xe3\xce\x77\x1e\xc5\x7b\xa6\xa6\x55\x0e\x30\xaa\xa7\x10\xce\xe6\x4f\x1a\xa2\xa4\x31\xd0\xac\xea\x99\x33\x17\x8d\x76\x32\x6e\xf6\xfe\x1e\x5e\xa6\x0b\x3a\x89\x91\xff\x92\xe6\xdf\x93\xaf\xba\x4f\xd4\x0e\xf8\xfd\xa0\x9e\x4e\xa7\x45\xd1\x25\xb3\x99\xdb\xc8\xd8\xfb\xd1\x83\x16\x3f\x35\x30\xa7\xbb\x57\x0d\x1b\xae\xad\xe7\x69\x58\xcf\x3a\x34\x90\x44\x84\x88\x4e\xa7\x39\x16\x08\x44\xf4\x03\x6a\xf4\x35\x83\x06\x07\x61\x05\x23\x41\x5b\x65\xbf\x89\xa9\xca\x4a\x5e\x34\x38\x44\x52\x46\x35\x69\x16\xc5\x84\x9b\x77\x03\x1d\xe1\xb3\xe1\x2e\xea\xc2\x2a\xe8\x9e\x1b\xd2\xa5\x14\x40\xaa\x57\x0f\x9e\xaa\xa1\xec\xf9\x3e\x83\xb3\x1e\x45\x65\x95\x73\xa8\x80\xe7\xec\xde\xdf\x2f\xaf\x5d\x33\x53\x19\x2c\x71\x70\xd4\x8c\x08\x8e\xcc\x6a\x9f\xe2\xe5\x4f\xac\xbd\x77\xdf\xd2\x7b\xe7\x75\xfc\xf4\xf2\x39\xb3\x5d\xcb\x1b\x5a\xb4\x31\x77\x90\xa1\x56\x47\x97\xfc\x3a\x73\x42\x75\xfa\x88\x6b\xae\xea\x5a\x70\x0d\x3e\x77\xca\x86\x11\xf5\xf1\xc1\x54\x36\x6a\x96\xc7\xf1\x0f\x83\xac\x32\x88\x64\xf3\xac\xf3\x7a\x23\xf5\x36\x9b\xc4\x48\x31\xb6\xd0\xd8\x54\xd8\x34\x78\x88\x58\x5f\x9f\x48\x58\x26\xa6\x12\xb6\xa0\xa7\xce\x03\xb3\x52\x27\x96\x54\x01\xb1\x28\xc1\x5e\xc9\x56\x18\x28\x24\x29\x7a\x69\x8c\x39\x4b\x2c\x3c\xf5\x99\x95\x8f\xc7\xfb\xc0\x83\x9e\x39\xb0\xfb\x8a\xf2\xeb\x21\x78\xc3\x84\x35\x26\xf2\x23\xd0\xb3\x51\x65\x3a\x6e\x95\x16\x02\xb7\xa5\xfd\x0a\x12\x53\x26\xaf\x7e\x45\xe6\x6e\xd9\xb5\x2b\x8b\x27\x4c\xc0\x30\xec\x81\xa6\x05\x4b\x72\x02\xfd\x1e\xd7\x22\xcc\x1c\x67\xbe\x8d\x54\x57\x47\x58\x63\xbf\xd8\x70\x0d\x69\xb6\x8f\xab\x18\xb4\xe1\x46\x25\xcc\x8f\xc4\x47\x00\x9e\x34\xc3\x7e\xa8\x21\xf1\x72\x96\x98\xdf\x1f\xd6\x3b\x91\x1e\xd5\x82\xb6\x00\x8a\x6e\x31\x3d\x77\xa4\x04\x0f\x29\x66\x5c\xd6\xd6\x3b\x37\x65\x76\xc7\xe7\xd5\xc5\xa2\xc8\xaf\xc5\xdd\x2a\x13\x70\x36\x1f\x31\xd7\xbc\xef\xd1\x85\x5d\x72\x80\xc4\xdf\xf6\xeb\xfa\xed\x82\x39\x67\x4d\x5a\xe6\x52\x42\x70\x4f\x6f\x5c\x33\x6d\xc2\x79\x67\xcd\x57\x46\x63\xb2\xb9\x01\x34\xc6\xd9\x4b\x46\x66\x04\x15\xcb\x05\x72\x30\xe8\xf4\x3e\xbf\x41\x12\x24\x52\xcf\x9b\x2a\xf0\xc8\x69\x44\xc6\x76\x9a\xbd\x34\x1b\xc2\xd8\x57\x1c\xa0\x2a\xc4\xc7\x33\xca\x7b\x8e\xd8\x80\xed\xf4\x3c\x6a\x39\x8d\x1f\xce\x11\x11\xba\xdb\xf1\x63\x84\x7a\x67\xe2\x86\x55\x81\x80\x79\xbc\x3b\xcd\x3c\xe2\xb4\x29\x34\x29\x92\xfe\x8a\xfd\x9e\x1f\x82\x5c\x00\xf5\xca\xe4\xd0\x90\xdf\xc8\x17\x97\x8b\x2e\x57\x39\xef\xe7\x2a\x2a\xa3\xe1\xb0\xcf\x53\x54\xe4\x06\x3e\xef\x12\x45\xde\x68\x14\xac\x26\x13\xc7\x58\x2c\x58\xc0\x5c\x79\x71\xb1\x3f\x14\x2a\x2d\xe0\xe0\xaf\xcf\x2e\xb0\x3e\x58\x1a\xa2\x08\x52\x79\x54\x63\x48\x76\x25\xfb\x6a\x8e\x31\x38\xfb\x4d\x0f\xcb\x64\xd4\x84\xa3\xac\x6a\x84\x27\x29\x1f\x13\x71\x49\x60\xfb\xfa\x92\x79\xbf\x61\xfb\x5d\xf5\x6f\x8f\xc5\x55\x73\xb6\xdd\x39\xe0\xce\x8d\xb3\xbf\x1c\xf9\x7a\xaf\x6f\x98\x27\xf0\xfd\xf2\x4c\xa6\xc3\x1e\x0c\x3a\xe4\xc9\xf8\x1e\xf9\x22\xfc\x73\xf8\x6c\xfd\xe1\xc3\xbe\xbf\x87\xb9\x80\x5d\xcb\xde\x0b\x73\x61\x06\x4d\x6c\x40\x32\xe8\x31\x5a\x90\x11\xf9\x03\xce\x5a\x6f\xb3\x97\xf1\x7a\xad\x40\x31\xc3\xc6\x3a\x23\x63\x34\xea\x4c\x2c\x89\xa5\xae\x9d\x16\x57\x5e\x73\x43\x86\x48\x25\xc6\x4a\xac\x24\x02\xb4\xe7\x5e\xb0\xf7\x8e\x28\x09\xed\x9f\x3a\xf0\xd5\xa9\x25\xe7\xb0\x33\x73\x3f\xb3\x77\x7d\x2c\x58\x5c\x1f\xe3\x07\x7f\x78\x5e\xfd\x40\xf7\xc7\x4c\xd0\x75\x4e\xd0\x7c\xc0\x93\x92\x95\x5e\xbb\x01\x87\x42\xc5\x86\xe2\xb2\xf2\xe2\x50\x24\xd4\x06\xf2\x83\xdd\xe5\xb2\xb4\xa7\x5c\xb6\x20\x0b\xba\x79\x60\x22\x39\x9b\x54\x92\x0d\x7e\xce\x3f\xac\xd6\xe3\x40\x0a\xf5\x5c\x66\xce\x00\xe5\xb9\xcf\x7a\x06\x3c\xb3\xf7\x09\xa3\x0f\x0c\xd1\x22\x49\xa7\x35\x90\x20\xd3\x8a\x9b\xcb\x57\xe1\x6d\x8b\xd7\xcb\xe3\xf0\xfc\xb1\xe7\x56\x0c\xda\xb8\x0e\xcf\xd5\x22\x8d\xe4\x3f\x4e\xea\x74\x98\x98\xcf\x72\xd4\x44\x3a\x96\x16\x7e\x0a\x8c\xa5\x0e\x74\xdc\x5a\x8f\x4d\x8f\x82\xc1\xca\xa8\x3e\xda\xaf\xbe\xa2\x86\xaf\x01\xe9\xba\xa6\x20\x1a\x0c\x07\xdb\x52\x61\xd1\x06\xec\x82\x1c\xba\x2b\x24\xa7\x99\xfc\xf9\xa7\x99\xf2\x22\x65\x73\x8c\x44\xda\x98\xf8\xff\x64\x48\xb9\x81\x03\x3f\x32\x38\x2d\xa4\x6a\xcb\x9d\x83\x46\x8e\x3c\xfb\x10\xcf\x34\x29\xdf\xbe\xa8\x8c\xb3\x94\xa9\x67\x16\xf1\xeb\x88\x30\x9c\x34\x21\xa7\xd3\x6b\xd1\x7b\xf5\x85\xc1\xc0\x11\x5c\x75\xc8\x09\x9f\xbd\x26\xf7\x11\x3c\xf4\x80\x83\x61\x6c\xfc\x11\x3c\x58\x89\xc8\x6f\x56\x6a\x55\x34\xe7\x9d\x18\x72\x2a\xa7\x81\x88\x42\x1a\xcd\x1e\x80\x52\x92\x96\xc5\xdf\xe5\x4b\xaf\x2c\xde\x3a\xe2\xab\xb1\x17\xb7\x0c\x1f\xf7\xaf\x51\x1d\x47\xb8\x5b\xeb\xcb\xdc\xb1\xdd\xf2\x06\x31\x10\x10\xf1\xbc\xd9\x0e\xb9\x99\x7c\x62\xb1\xa8\xd8\xb5\xe3\x14\xae\xdb\x50\x29\x6a\x4d\xda\x49\x26\x5c\xa6\xb8\xd8\x69\x61\x63\x65\x42\x30\xc8\x47\x7e\x05\x90\x78\x71\x1d\x90\x20\x3b\xae\x3e\x54\xac\x87\x1d\x8e\x4c\x00\x27\xd2\x20\x8b\x37\x6b\x59\x78\x72\x8f\xc2\xe7\x41\xd5\xd7\x51\x26\x02\x3c\x5e\xa9\x02\xd9\x35\xa5\x5f\x09\xc9\x27\x5b\x11\x50\x80\x67\xea\x73\x21\x65\x1a\x56\xaf\x31\x5d\x3d\xc6\x3c\xb6\xa3\x3e\x33\x12\xc4\xa4\xff\x85\xab\xb0\x8e\x9f\x81\x4c\x30\xa3\xfd\x60\x46\xcd\x66\xbb\xce\xeb\x2d\x0c\xfa\x60\x46\x07\x3d\xee\x76\x88\x4f\xe2\x21\xa0\xce\x19\x00\xf8\x66\x32\x8f\xcd\xf9\x59\xbf\x72\x8c\x36\x6c\x8e\x40\x44\xe2\xe7\xe2\x58\x17\xf3\x07\x4a\x4b\x03\xfe\x98\xee\xc2\xf3\x63\x75\x05\x36\x57\x10\x26\x92\x0f\xfa\x63\xf0\x7d\x2c\x76\xe6\xc3\x2b\x57\x98\xae\x1a\x6e\xdf\xc1\x24\xb3\x73\x88\x1f\xe6\xae\x24\x09\x84\x93\x06\xbb\x20\x98\xcd\x48\x72\x8b\x00\xc7\x7e\xf8\x68\x84\xe9\x3a\xa8\xb3\xdb\x59\x06\xd1\x75\xad\x27\x1c\xb8\x99\x2c\x6e\x2e\x71\x50\xb3\x14\x69\x31\x63\x71\xc2\x6e\xf1\xc3\xbe\x68\x68\x52\xc1\x0c\xf9\x9b\x51\xa3\x1e\xe4\x2b\x97\x16\x71\x57\xde\x39\xdc\x6e\x91\x2f\xa4\x4b\xf9\xbe\x18\x18\x59\x14\x57\xe2\x2b\x98\x28\xbe\x99\x9b\x85\x9c\xa8\x21\x69\xb2\x63\x23\x6f\x74\x49\x36\x93\xc9\x02\x10\x1c\x34\x62\xac\xd7\xf1\x4f\xe0\x66\xb8\x71\x28\xa1\xc3\x0a\x5e\xd9\x73\xc2\x3e\x9d\x99\xb0\xcf\xec\xe6\xfe\x98\xf4\x67\xf0\x17\x8d\x1e\x39\x13\x9b\x5b\x5b\x99\x7a\xe8\xeb\xce\xe1\x41\xfc\x10\xe9\x5b\x0e\x93\x81\x43\xbf\xb0\x06\x9f\x41\xbf\x24\x8e\xd1\x12\x70\x3a\x39\xab\xde\x5a\x18\x74\x5a\xad\x36\xd2\xb3\x85\xe3\x4c\x06\xfd\x11\xdc\xfc\x38\x30\x80\x23\xb0\x1a\x30\xf4\xde\xdd\xf7\x8a\xf5\x6c\xcc\x9e\x3c\x54\xa2\x3b\xb6\x9c\x7f\x61\xd1\xca\x68\x16\x96\xa0\xd3\x5e\x50\x83\xab\x56\x5c\x39\x35\xd8\x3f\x03\x52\xf7\xb3\x3b\xec\xc3\xaf\x32\xa9\xbc\x0b\x70\x7a\x22\xc0\x45\xe2\xe3\x26\x25\x0b\xd5\xf8\x38\x10\x3d\x58\x83\x64\x90\x42\x61\x64\xb3\x99\x05\x12\x18\x67\x74\x98\x9f\xc6\x83\x40\x5f\x13\x60\x6e\x82\x48\x47\x11\xbb\x59\xd9\x76\x1a\x43\xca\x09\xa8\xce\x8f\x8a\xab\xc4\x5a\x54\x9c\x14\x6f\xcc\x89\x8a\x93\xf0\x9a\xda\xe4\xac\x05\xdd\x63\xc7\x62\x66\xd2\xa4\xed\xb7\x0d\x96\xff\x36\x72\x48\xd3\xa8\xfe\xec\x25\xe2\xd8\xe6\xf1\xe3\x94\xa5\x0b\xd8\x5e\xfa\x67\xc0\x22\x17\xc7\x07\x0f\x1c\xf0\x01\x89\x7b\x92\x99\x52\x76\x21\xc0\x4c\x62\x78\x9d\x46\x5e\x74\xf1\x2e\xc9\x4d\x79\x2b\x63\x36\x73\x76\x01\x66\xf4\x00\xf0\x58\xcc\xc1\x84\x6a\xc4\x81\xc0\x57\xdb\xe3\x50\x6c\x9f\xdc\x92\xb9\xa2\xf6\x96\x9b\xab\x9e\x3f\x07\x9b\xa7\xdd\x70\x63\xfd\x8d\xab\xa7\xbd\x35\x94\x29\xc5\x57\xc8\xeb\x19\x37\x01\x45\x5e\x83\x17\xc9\x1b\xf0\x75\xf0\xd9\x42\xfd\xe7\xb8\x9c\x49\x01\x2c\x01\xd4\x94\x74\xd9\xcd\x4e\xaf\xd7\xcc\xb0\x05\x85\x5e\x20\xc0\x76\xbb\xc9\x21\x59\xc9\x16\x13\x58\x58\xd4\x1a\x65\x51\x69\x0d\x99\x5c\x32\x00\x48\x95\x9b\x15\x2a\xe3\x41\x27\x9c\xdb\x8a\x17\x54\xd5\x15\xb8\x9c\x91\x86\x16\xaf\xf8\xe6\x40\xac\x4b\xdd\xb9\x75\xca\xef\x07\xfd\xa9\x61\x06\x2e\x37\x2d\x6f\xb2\x4e\x6e\xa9\x64\x6c\x14\xac\xa5\xf8\x16\x02\x52\xf7\x6b\xeb\x3a\x69\xdc\xff\x25\xec\x54\x7c\x21\x3f\xc4\xa6\x13\xbe\xa5\xd7\x0b\xd9\xa9\xcc\x27\xf4\xfa\x5f\xf4\xfa\x05\x76\x24\xfe\x96\xef\x80\x6b\xa5\x86\xfd\x01\x76\x04\xfe\x98\x9f\x08\xd7\x7f\x56\x7f\x1f\x01\xbf\x4f\x74\xe8\x84\x4f\xe8\xbe\xf9\x07\x97\xc0\x4f\xf1\xaf\x20\x0b\xf2\x27\x8d\x48\x10\x8c\x2c\x6b\x15\x39\x23\xaa\xfd\x5d\x6e\x18\x1e\x70\x8c\x84\xa2\x0d\x27\xea\xfb\xe3\x79\xad\xf1\x8e\x65\xcb\x3a\xea\xc6\xf2\x28\xde\xda\xbe\xac\xa3\x63\x59\xfb\xc8\x5e\x6d\x99\x58\x16\x9a\xb3\x8a\x46\xae\x47\x5b\xc0\x62\x24\x85\xee\x48\x45\x3a\x3c\x6c\x4c\x3f\xd2\x56\xbc\x95\x47\x0d\xa3\x94\xb6\x68\x1d\xab\x30\xd0\x93\x77\xf8\xbb\x40\xda\x68\x4c\xda\x49\xb6\x53\xab\xcb\xea\xf2\x07\x3c\xc4\xff\x69\xb4\x1f\xc1\xd5\xfb\xbd\x2c\x8b\x15\x32\x4c\x99\x44\x0f\x44\x55\xcb\x59\xaa\x69\xaa\xf2\x33\xb2\xe2\xeb\xe4\xa7\x67\x57\x4d\x1c\x73\xed\x98\xd1\x52\xd9\x65\x5d\x57\xac\xb8\x64\xfa\x6c\xa6\x3e\x6c\xc3\x83\x74\xa6\x2b\x16\x9d\xac\xbb\xf8\xee\xaa\x75\xab\xaf\xb8\xcd\x2e\x7f\x66\xa3\x73\x14\x04\x58\x4e\x69\xb0\x68\x7e\x4f\x7f\x80\xf8\x3d\x39\xe4\x21\xb0\xc0\x77\xd6\xb3\xc0\x92\xe3\xf0\x94\x7a\x3b\x3c\x3d\xf8\x54\x4c\x1a\x3d\x66\xd5\xb9\xed\x95\xb3\xe5\x67\x66\x77\x76\x2d\xbf\xa2\xeb\x32\xee\xf5\x8b\xeb\x4e\x5e\xbe\xd8\xa4\x93\x5f\xb0\x85\x01\x2c\xaf\x63\xf3\xd2\xd5\xeb\xaa\xe8\xfa\x5d\x8c\x9e\x01\x99\xf2\x1e\x9b\x0e\x85\xba\x79\xb8\xbe\x14\x3d\xc1\x45\xb8\x6d\x0e\x1d\x8a\x50\x58\x27\xa1\x57\xb8\x5a\x6e\x2d\xd2\xa1\x60\xd2\x8c\x61\xd7\x73\x9c\xa0\x67\x74\x1c\x46\xb5\xf1\x63\xf5\x39\xeb\x50\x12\x35\xe0\x28\x8e\x73\xb5\xb3\xe5\xe5\xf2\xf2\xd9\xf8\x8d\xfa\x57\xd8\xf2\x33\x6f\xb1\xbf\x44\xbd\xdb\xd1\x81\xd0\xce\xb2\x82\x9e\x45\x3c\xd3\xb3\x1d\xda\x8a\x01\x73\xb5\x72\x65\xbd\x5c\x39\x1b\xaf\xc3\xeb\xb8\xb5\x67\x46\xb1\xbf\x84\xb6\xca\xd5\xf3\x01\x5c\x27\x73\x37\xbf\x05\xd4\x97\xed\xc9\xcb\x58\x46\x10\x10\x89\x7b\x33\x30\xc2\xc6\x14\x62\x6e\xbd\x50\x27\xa2\x10\xaa\x45\xac\x1e\x75\x1a\x71\xad\x11\x87\x8c\x38\x6d\xc4\x5f\x18\xf1\x42\x23\x6e\x36\x62\x91\x5e\xb6\xd1\xef\xe1\x73\x13\xfc\xf0\xac\x11\x2b\xb7\x2a\xf7\x9d\xc8\xb9\xef\x7d\x23\x7e\x4c\xbb\x7b\xda\x34\x5a\x9d\x04\xfe\x2c\x81\x3f\xd3\x73\xaf\x50\xed\xf4\x69\xf5\xd9\x2c\xe3\x6a\x92\x1d\x67\xdc\x29\x45\x4b\x78\xc7\xa9\x37\xde\x1e\x20\x7f\x2d\x7f\xcd\x75\x46\xb0\x5d\xfe\x22\x72\xf8\x70\x8f\x71\xdc\x9f\x9c\xa7\xe3\x81\xab\xb0\xac\x1e\xc6\x01\x93\x04\xa3\xc0\x1b\xa9\x4b\xa8\x56\xc7\xea\x75\xff\xef\x0e\xa4\x32\x5f\x19\x22\x43\xe1\x4b\xe2\x12\x1b\x65\x13\x63\xb0\x19\x9b\x07\xbc\xfd\xc6\x29\x7e\xcb\xe1\xc3\x11\xf9\x0b\x6c\x8f\xd0\x35\xc1\x41\xae\x0d\xaf\x87\xb1\xb0\xc8\x79\x08\x2e\x39\x9e\x05\x0c\x39\x96\x89\xfc\x89\xda\xe3\x78\xfd\x82\x05\x70\xd3\x70\x35\x2e\x8d\xbb\x92\xd9\xc4\x7d\x08\xf7\x7f\x94\x7c\x00\xb0\x8a\x47\x78\x43\x8a\x2c\x1c\xa3\x47\xcf\xf0\xf8\x17\x3c\xbe\x9f\xc7\x9b\x78\xbc\x8a\xc7\x0b\x79\xdc\xc9\xe3\x36\x1e\x37\xf3\xb8\x96\xc7\x21\x1e\x8b\x3c\x4e\xf3\xf8\x0b\x1e\xbf\xc7\xe3\xe3\x3c\xce\xdc\xbf\x90\xde\x23\x6a\xdf\x2b\x5f\x2a\x2d\x28\x8f\x2b\xcf\x36\xf5\x7e\xf2\xf8\xd9\x9f\x6f\xe7\x71\x98\x57\xa6\x2c\x3b\x67\xea\xac\xe5\x7c\x9b\xf3\x93\xf2\x87\xce\x24\x9d\x45\x9a\x95\x4d\x0a\x30\x57\x70\x57\xce\x9f\x0f\x7b\x6c\x3b\xac\x7b\x82\xdf\x0c\x7b\x6c\x29\xdd\x83\xcb\xe0\xda\x46\xaf\xcf\x51\xe6\x52\x6e\xc1\xeb\xd3\xeb\xb2\x73\x89\xd9\x3e\xe6\x12\x6e\xd2\xe6\x52\xfe\x8a\xd9\x94\x9e\x41\xef\x67\x61\x6b\x11\xa7\x61\x6d\xe6\x6c\xb6\xda\xb7\xfc\xd5\xfc\xf9\x70\xef\x32\x79\x24\x63\x4b\x2f\x43\xa0\x0f\x1f\xe2\x30\xd6\x09\x28\xb7\x6d\x03\x88\x0b\x4e\x09\xbf\x2d\xdf\xf7\xc6\x51\x79\x24\x36\x97\xc8\x5f\x2a\xeb\xfb\x7f\xf8\x1c\x83\x1e\x85\x87\x6f\x61\xf7\xc2\x73\x26\x14\x4e\x5a\x61\xe7\x0b\x2c\x6b\xb6\x18\x04\x89\xe1\x45\xd4\x7c\xac\xf9\x58\x2e\x2d\x17\xa2\xc0\xcf\x88\xa9\x24\xee\xc1\xb7\x74\xf4\xef\x78\xf7\x5d\x78\x61\xd7\xed\xdd\x5b\x72\xa6\xa3\x64\xef\x5e\x80\xe3\x51\xe6\x8f\x6a\x7b\xae\xc3\x08\x74\x31\x01\xd3\x66\xb2\x21\x66\xa4\x05\xe5\x59\xfa\x1c\xe5\x23\x28\x85\x9f\xc2\x5f\xfc\x9f\xf1\x24\x5c\x9c\xcf\x93\x72\xdb\xfa\x6f\x79\x12\x2e\xce\xe3\x49\x07\xd0\xcf\xf1\xb7\x0c\x46\x02\xcc\x8c\x05\x16\x4e\x07\x14\xc0\xa0\x03\x55\x0c\xb6\xce\xab\x71\x7b\x6e\x20\x76\x49\x24\x11\x07\x4e\x1f\xc7\xdf\xca\x4f\x2f\xec\x5a\xf8\xf3\x05\x1f\x7f\xac\xac\x4b\xcf\x36\x40\x8f\xd3\x1b\x30\xcf\x83\x28\x51\xfb\x6a\x7d\x5e\x1b\x38\x2a\x91\x88\xe3\x08\xfe\x16\x5a\xc0\xc3\xf1\x6d\x1f\x7f\xbc\x40\x6d\xe3\x71\xfc\x2d\x96\x61\x85\xea\x92\x92\x11\xfa\x87\x25\x42\xf4\xec\x3f\x34\x64\xd4\xe9\x0c\x64\xa9\x9b\x6a\xb3\xe9\x36\x73\x0d\x09\xb4\x4d\x15\x36\x68\x97\x34\x1d\x59\xb8\x70\xc1\xc2\x85\x2a\x6e\xe2\xc9\xcc\x26\xfc\x7c\x16\x37\x81\x87\xd4\xd6\xf7\xc0\x4d\x3c\x99\xe2\x66\x02\xf6\xc1\xe5\xfc\x32\x98\xdb\xda\xa4\x8f\x35\xc1\xbc\x8a\x6c\x88\x65\x0c\x00\x4d\x12\x09\x9b\x14\xf2\x00\x8f\x4f\xab\x44\xe4\xe4\x7f\x27\x90\x5c\x75\x7f\x11\x8f\x46\x5c\xcd\x2b\x6f\xc5\xb8\xe3\x86\x6d\xec\x18\xdb\xe2\x8e\x8e\x45\xf6\x31\xfc\x36\xae\xf3\xae\x55\xe7\xb4\xb6\x9e\xb3\xe6\x76\xe8\xe3\xaf\xdc\xe5\xf8\x28\x89\x61\xc1\xce\xe4\x8b\x48\xa7\x33\x5b\x58\xc3\x96\x94\x89\x0d\xb0\x8c\x9e\x7d\xd2\x82\x6f\xb1\xe0\xab\x2d\xf8\x42\x0b\xae\xb4\xe0\xd3\x16\xfc\x57\x0b\x7e\xc5\x82\xef\xb1\xe0\xcb\xe8\x97\x83\x2c\xd8\x64\xc1\x27\x2d\xf8\xa8\x05\x3f\x66\xc1\x0f\x5a\xf0\x56\x0b\x5e\x6d\xc1\x8b\x2c\x78\x86\x05\xb7\x5b\xf0\x08\x0b\x6e\xb0\xe0\xb0\x05\xbb\x2c\x98\xb3\xe0\xa6\xaf\x2d\xf8\xcf\xf4\x81\x67\x2d\xf8\x00\x7d\x60\xb3\x05\xaf\xb5\xe0\x2b\x2c\xb8\xcb\x82\x3b\xb4\x07\xe0\x6e\x64\xc1\xcc\x97\x16\xfc\xbe\x05\x9f\xa0\x77\x43\xf3\x3b\xb4\xb6\x93\x16\x5c\x47\x5b\xb5\x59\xb0\x72\xcf\x6a\xad\x43\xf8\xb2\x27\x11\x5a\xbc\xb8\x73\x49\xfe\x9f\x1c\x5a\x95\x7b\x6b\x3e\x99\xea\xa9\xc3\xe1\xa3\x5a\x94\x0d\xf7\x5e\x36\x9f\xf1\x4d\x5c\x82\x09\x81\x4c\x66\x42\x1e\x34\x34\x59\xea\xd0\x99\x81\x5b\x79\x7d\x06\x71\x7d\xca\x90\x34\x98\x5b\x61\xb1\xa4\xf5\x29\xb2\x6e\xb5\x6c\x1b\xbb\x90\xdd\xc4\xea\x80\xcd\x93\x3e\x68\x30\x50\x6e\xb6\xc5\xdc\xce\x72\x4b\xe8\x33\x21\xb2\x45\x94\x6d\x12\x8f\xb7\x8e\xe9\x47\x04\x43\xe5\x0b\xb2\x89\x5a\xe3\x0d\xa3\x46\x52\xdc\x5a\x29\xcf\x67\xcc\xc8\x86\x80\x5b\x25\x0b\x04\x23\x6c\x6b\xd1\xe1\xd4\x78\x26\xab\x43\x96\xf5\xa9\x30\xaa\xd3\x50\x86\x46\xea\xe4\x76\xaf\x44\xb2\xc4\xd5\x38\xec\x46\x50\x8b\xba\x16\x5e\x55\x5b\x39\xdf\x13\xa2\xf5\xfb\xe5\xf9\x97\xcf\x4a\xcc\xa9\x8a\x5c\x5a\x4e\xeb\xf5\x53\x7e\x3d\x1d\xf8\x75\x17\x72\xa3\xaa\xa4\xcf\x28\x79\xbc\x2e\x3e\x64\xae\x35\x37\x9b\x59\xb3\xdd\x98\x11\x3a\xc8\x60\x8f\xc6\xdf\x99\x56\x7f\x34\x83\x9c\x35\x0c\x39\x2e\x2a\x44\x61\xa4\x41\x86\x22\xa9\x0e\xbf\x55\x37\xa1\xf5\x9c\x48\x38\x06\x43\x17\x0f\xd4\x4d\x18\x7d\x4e\xb8\xb2\xce\xd0\x20\x72\xd3\x2b\x13\x95\xde\xea\xfa\x7f\xc2\x5b\xfd\x88\x7f\x10\x1a\x9a\xfe\x0e\xf6\x05\xa9\xdb\x08\x34\x14\x6f\x4f\xa6\xf5\x3a\x03\x03\x5b\xc2\x60\x41\x66\x3d\x43\x05\x1e\x03\x88\x92\xe5\xa4\xef\xe5\x16\x3c\xcb\x82\x27\x5b\xf0\x48\x0b\xee\x6f\xc1\xc5\x16\xec\xb6\x60\x9d\x05\x7f\x6b\xc1\x87\x2c\x78\xb7\x05\x6f\xb3\xe0\xa5\xf4\x9e\x72\x8a\x9f\x97\xc2\x0f\x1f\x5a\xf0\xef\x29\x42\x2b\xf8\x09\x77\xdc\x90\x8f\x9f\xd0\x50\x91\x05\x3b\xe8\x03\x5f\xd3\xfb\x4f\x6a\xf7\xef\xd6\xee\x87\x9b\x27\x6a\xc8\x9c\xdb\xeb\x8b\xf4\x9e\x5b\x2d\x38\xbb\x4b\x3a\x34\x7c\x2e\xd6\x76\xc9\x80\x13\x39\xfd\x5f\x41\x77\x99\x8d\x6e\x08\x05\xd7\x99\xcc\x86\x58\x65\xc1\x0b\x2d\xc9\x52\x82\xf7\xb9\x5b\x42\xb9\xf3\x19\x0b\xfe\x05\xdd\x5e\xb5\xf4\x1b\xfd\xf4\x5e\xfb\xa2\x33\xcb\xa0\xb3\x3b\xa2\xb3\xe7\xe6\xe9\xc1\xc6\xf3\xee\xd6\x6e\x50\xc4\x3d\xc5\x25\x94\x31\xb8\x92\xe3\x32\xce\xb8\x04\x7a\x02\x79\xd5\x6f\x7f\x56\xfe\x23\x8e\xc1\xeb\x9f\x88\xd8\x67\x2b\x91\xbf\x56\x5e\x29\x5d\x4c\xff\x1d\x1f\x64\xac\x6c\x02\x39\x09\xdd\xb6\x0a\x40\x89\x5c\x92\xa0\x33\x3b\xed\xb0\x59\xe2\x47\xff\xa4\x20\x0f\x31\xad\x00\xfe\x28\x66\x36\xa1\x19\x67\xf3\xc4\x31\x56\xeb\xe5\x63\x2f\xb9\xfc\x1a\x3c\xba\xc4\x6b\xa6\x49\xe0\x98\x8b\xc6\x5c\x7c\xfd\x8a\xe6\x54\xcc\xe5\x91\x68\x92\x37\x85\xfe\xd6\x32\x7f\x62\xde\xe3\x37\xc0\x7e\x0d\x24\x8d\xb0\x13\xf4\x84\xe4\x61\x01\xf9\x6a\x73\x59\x03\xc8\xce\x06\x1c\x33\xe0\x46\x03\x66\xde\x93\xff\x81\xc5\x56\xf9\x4b\xf9\xcb\x56\x6c\x93\xbf\x1c\x8d\x45\x6c\xe3\x47\xc8\xff\x20\xd7\x56\xf9\x1f\xad\xd8\x8e\xc5\xd1\xf2\x97\xb4\xa6\x37\x83\x78\x5c\xc6\x5c\x46\x75\x6c\x12\x59\xea\xb1\xe8\x45\x97\xde\x15\x28\x00\x2d\xdb\x62\xd1\xeb\xad\x48\xf0\x70\xac\xdd\xf8\x24\x1e\x04\x28\xca\x12\xdd\x36\x4e\xa3\x67\xb4\x59\xcb\xd9\x8e\x6e\x8f\x40\x12\x4f\xe5\x2b\xb6\xa5\x31\x9d\xe4\xc1\x73\x27\x5b\xdf\x2f\xe1\x0a\x6a\xdf\x1e\x88\x85\x0b\xb6\xef\x4e\x9d\xe8\xff\xba\xa1\xb4\xce\xcc\x5c\xf9\xa7\xb9\x82\xa3\xf2\xa2\xcb\x19\x86\xea\xb6\xd7\xe2\x35\x54\xb7\x0d\x8f\x9c\x3c\xaf\x4e\xad\xe3\xe2\x07\x5d\x6b\x28\xbf\x0e\x19\x50\xd1\x21\x60\x69\x46\x93\x4e\x7f\x04\x57\xed\x87\x8f\x6c\x56\xc1\xca\xb0\xa3\x8c\xad\xe8\x9d\x99\xf2\x9f\x66\xcc\x78\x9e\x99\x9a\x35\xec\x91\xb6\x4a\xf1\xdd\xdc\x95\xa8\x18\xe8\x8d\x2d\x64\xd6\x79\x1d\xc8\x81\x4a\x4a\xcd\x21\xb6\xc0\x27\x1d\xc1\x83\x1f\x37\xea\x58\xd5\x94\x40\x95\xb6\xa6\xec\x29\x90\x8c\x9f\x44\x2b\xf0\x42\xca\xbd\xf4\x76\x90\x60\x7c\xf7\x65\xb3\x67\x8e\x0d\x14\xd6\x8c\xba\x62\x78\x5b\xeb\x98\xd9\xe7\xb5\x4e\x2a\xf0\x85\x5b\xea\xe2\xc3\x26\xb6\x8e\x65\x4e\x74\x4c\x2e\xb8\xa5\xad\xbc\xab\xba\xbf\xc7\x35\x3e\x39\x66\xb2\xf3\xea\xe1\x05\x75\xe5\xe5\xf5\x5e\xf7\x24\x02\x1f\xc3\xd4\x33\xe3\xa9\x8d\x61\x38\xd1\x2b\xb9\x80\x29\x50\x50\xe8\x73\xb9\x1c\x0e\x8b\x85\xda\xce\x92\x86\x00\xc7\xe9\x74\x26\x13\x63\xc8\x18\x1c\xed\x9a\x4d\xb4\xe7\x7a\x10\x43\x63\x4c\x20\xf6\xc6\x66\xac\xe6\x9f\x6e\x24\x8b\x22\x62\x27\x33\x3e\x3d\xf6\x27\x77\x8d\x7f\x65\xd8\x13\x0f\x0e\x47\xe9\xb1\xf3\x57\xc2\xc7\xfb\x7e\xc9\x9c\x1b\x08\x58\x5f\xfe\x8d\x25\x10\x30\x7e\xfd\x0f\xb2\x20\xbb\x1e\x20\xcb\x71\x4c\xfe\x9f\xff\x2f\xe9\xbc\x00\xcb\x36\x40\xdc\x15\xfc\x23\x40\x4f\x0b\x0f\x83\x0a\xca\xeb\x04\x96\x39\x82\x99\xc7\x53\x20\xa0\xd4\xd6\x66\xcb\xc2\x45\xec\x91\x44\xc4\x8e\xff\x47\x7e\x14\xff\x99\xf7\x6f\xf9\xe1\xbc\x9c\x67\x05\x54\x9a\x04\xb1\x0f\xb1\x82\xa0\x37\xd0\xc7\x0f\xa4\x40\x1c\x25\x0d\x34\xd5\xe6\x66\x24\x52\x1a\x89\x2b\xcd\x4c\xda\xc2\xbe\xba\x05\x8f\x87\x96\xd0\xff\x42\x5b\xcc\xd6\x2d\xcc\x0d\xff\x4b\x6d\xe1\xf1\x00\x5a\x8f\xb6\x78\xa0\x4d\xa0\x8d\x92\x09\xe2\x10\x86\xa6\xf6\xa5\xa0\x1d\xc2\x49\x33\x53\x14\xa7\x6d\x6c\x83\x06\xb6\xf0\x7e\xfa\x38\xa9\xcd\x0b\xcf\x8f\x66\x17\xc1\xf3\xde\xa4\x81\x23\x82\x2d\x4c\x30\x3c\x79\x2c\x9e\x7d\x0e\x9e\x8a\x48\x17\xcd\xc1\xd7\xb2\x8b\xce\x7c\x3f\x27\xff\x39\x2a\xcb\x82\x3a\x0c\xa2\xb0\xde\x00\xdd\x73\x8c\x22\x7f\xe6\x40\xef\xb4\x47\x69\x0b\xaf\xcc\x81\x26\xf0\x1a\x79\x25\xbb\x48\xbe\x66\x0e\xb4\x61\x97\x5b\x98\xbb\x40\x4f\xd1\xd3\xbe\x05\xc1\x60\x84\x66\x88\xc8\x79\x2c\x23\x74\x7a\x34\x65\x76\xb4\xa6\xcc\xde\x94\xab\xcb\x32\xa0\x9b\x9a\x98\x4d\x20\x23\x82\x70\x4f\xac\x15\x20\x0d\x73\xa4\x2e\x00\xc8\xd6\x20\xe7\xc7\x5f\xcd\xb5\x56\x10\x01\x96\x57\x84\xd8\xee\xf5\xa0\xe0\xbd\x37\x7f\xfe\x49\xaa\xe3\x4d\x66\x47\xb0\x95\xd4\x4e\xf6\x19\x1d\xdb\x16\x79\x13\xe3\x4f\xaf\x05\xb8\x0a\x92\x26\x5e\x80\x36\x0d\x46\x1e\xeb\xb8\x1c\xf3\x07\x89\x17\xc6\x44\x7d\x21\xb5\xea\xf0\x8e\xdb\x57\xc4\xee\xbd\x2f\x26\x6f\x3a\x15\xb8\xed\xb6\x40\xef\x36\xb0\x5e\x4f\xda\x60\x11\xd6\xf5\x6c\x23\x26\x50\x0d\x4a\xc2\x5f\xdd\x77\x6f\x6c\xc5\xed\x2b\xe4\x4d\xd0\xc2\xa9\x53\x94\x86\xfd\x11\xd4\xc6\x13\xe9\xdf\x41\x1b\xa0\xbf\xe8\x81\x1a\x60\x6c\x30\x22\x00\xe3\xd5\xbc\x63\xb2\x09\x62\x7d\x85\x16\x0e\x9e\x22\xdd\xcb\x2d\x2b\x14\x68\x94\x75\xca\x6b\x03\x10\x8d\x23\x6d\x10\x30\x72\xdb\x70\x12\xf2\x01\x63\x91\xbe\x25\xf0\x9f\x92\x5b\x62\x14\x18\x32\xbf\x37\xc3\x1a\x85\xd3\x7f\xa4\x32\x24\xac\xb4\x99\x1c\x9e\xd5\x79\x7d\x12\xbb\x5a\x34\xc0\x58\xfc\x79\x33\xcc\x9f\x4d\x4a\x0c\xf7\x92\x12\xbf\xec\x25\x24\x82\xde\x8a\x5e\x64\x6c\xf8\x5f\x80\x8b\xfe\xa4\x99\x67\x18\x9d\x40\x75\x0a\xb2\xd3\x8f\x4d\xcb\xa4\x2f\xcb\x51\x5f\x5f\xd4\xb4\x57\x26\xfd\x2c\x3c\xfb\x3f\xf4\x59\x13\x2a\x4e\xda\x4d\x7a\x3d\x0f\x2d\x98\xf5\x4a\x0b\x3a\x8a\x55\xa0\x82\xe0\x8c\x36\xa4\xb4\x13\x51\x5a\x2b\x22\xad\xe1\x54\x4e\x9b\x39\x7a\x71\xfa\x3b\x68\xfb\x71\xb5\xed\xa2\xa4\xcd\xa0\xd3\x01\x48\x7d\x36\x4d\x83\x0b\x62\x7d\x4b\x16\x2f\xf6\x10\x2c\x48\xce\x88\x95\xcc\xdd\xe9\x35\x20\xa3\x36\x24\x0b\x24\xa3\xd1\xe3\x45\xf6\x8d\x29\x23\x02\x31\x39\x8c\x58\xd0\xe4\x92\x2e\xb3\x99\xdf\x98\x32\xd3\x8d\x6c\x3b\xea\x7f\x07\xa4\xe2\xa3\x59\x05\xe0\xbf\x91\x55\xe5\x95\xbd\x64\x55\x74\x00\xaf\xc5\x1b\xe8\x19\x01\x0f\xaa\x80\xbe\xd4\xb5\x35\xb0\x5b\x52\x06\x31\x29\x4a\x5b\x40\x8b\xab\xa5\xfa\xdb\xab\x79\x79\xdb\x72\x56\xd9\x9e\xab\x84\x6c\xd0\x94\x90\x5e\xca\xc8\x99\x3f\x67\xf2\xd8\x11\x1d\x96\x3d\x8d\xbf\xe5\x87\x28\x34\x87\xc5\x94\xe6\x60\x9e\xea\xc0\x1a\xcd\x71\x46\x24\xd0\x56\x0f\xe0\xe1\x27\x17\xf0\x43\x16\x9c\x44\x3d\x9e\x03\x5c\x26\xf6\x4d\x16\x1e\x24\x0a\xb8\xb6\xa3\x14\x2d\x57\xd1\x9b\x17\x9c\xc4\xc3\xd9\xd3\x27\x17\x90\xe7\x60\x0f\x7c\x9b\x5e\xa7\xf6\xc7\x90\xfe\x98\xdc\xc7\x08\x9d\x21\xf1\x31\x91\x03\x0b\x4e\xca\x4f\x2f\xef\xf1\x0c\xd9\x37\xc4\xd2\x03\x0f\xe5\x02\xa9\x9a\x99\x41\x9b\x26\x7a\xfe\xc9\x05\x72\x0b\x80\x89\x51\xa9\xdc\xc2\xea\xd3\x87\x15\x6a\x04\x34\x8d\x25\xd4\xa8\x2f\xdb\xa9\xd3\x0e\x1d\x26\xe2\xf6\xd2\xb5\xf8\xd4\x5a\xe8\x6c\xc9\x37\xdf\xc8\x1b\x55\x5f\xa9\x3c\x8a\xe8\x26\x0a\xbc\xbc\x42\x93\x89\x99\x28\x07\x5e\x27\xa5\xa8\xa5\x6b\x99\xe9\xf2\x28\xfc\x4b\xf9\xe8\x4a\xe5\x9c\xf1\x6c\x66\x5b\xfa\x65\x90\x9f\xca\x80\x6f\x63\xcc\x0a\xd0\x39\xcb\x1a\x4d\x48\x80\x01\x03\xe8\xb9\x74\x59\x75\x53\x80\x20\x97\x68\xf4\x08\x11\x69\x7b\x2c\xbc\x69\x53\x38\x86\x7f\x90\x3f\x99\xe7\xbc\x37\x76\xaf\xf3\xb2\x2e\x68\xb3\xfb\x6f\xfc\x97\xe9\x1b\x84\x08\xc0\x62\x3f\x48\x6c\x49\x74\x33\x52\x5c\x07\x11\x9a\x6e\x9e\x7d\x64\xd7\xf0\x5f\x66\x36\x0c\x96\x5b\xe1\x99\x0f\xd4\x67\x08\xf4\xb9\xcf\x60\xba\x2d\xe4\xd6\xa3\x6f\xc8\xf7\xf1\x5f\x6a\x9b\x01\xcb\x4f\x71\x9d\x78\x04\xb5\xaf\x8a\xfb\x61\xb4\xba\x23\x78\x1c\x29\x98\x59\xaf\x3c\x41\x4d\xb3\xf2\x53\x7d\xd9\x66\x81\x7e\xab\xba\x9e\x4d\xc7\xdc\x47\xfb\x7f\x91\xbb\x12\x0f\xa4\xf6\x4a\x77\xd2\xa2\xd9\x2a\x33\xfa\x5e\x25\x69\x32\x22\xc9\x2f\x2a\x36\x3e\x18\xa3\xcc\x3f\x02\xc4\xc6\x0b\xf7\x9b\x0e\x90\xdb\x09\xe3\x54\x6e\xea\x96\x39\x8e\x7f\x64\x3e\xad\x49\x83\xe5\x0f\x00\xc6\x10\xb5\x79\x44\x92\xa2\x51\xe4\x42\x1c\x63\x20\xec\x46\xd8\x94\x42\x14\x5e\xba\x4b\x89\xa9\xa3\x5f\x9d\x3d\xcf\xca\x71\x56\x1b\x47\x7a\x2b\x77\x39\x9a\xaf\x9c\xd3\x49\x52\xf3\x86\xa2\x8e\xb3\xaa\x22\x4e\xdc\xdd\xd9\x1d\x36\xbf\xb7\x96\x0f\xfb\x58\xfe\x0b\xd7\x82\x25\xde\x4a\xf7\x71\x61\xd2\x26\x19\x58\xc3\x6d\x29\x31\xaf\x21\x1a\x3d\x93\xbf\x75\x73\x89\x35\x96\x06\x54\x54\x0c\x1c\x58\x51\x31\x40\xde\x3e\xa0\xa2\x7c\xf0\xd0\x58\xc5\x00\x6e\x4f\xc5\x20\x78\x27\xdf\x0e\x1a\x5c\x0e\xef\x74\x0e\x3c\xfc\x6f\xd2\x2f\x0b\x95\x20\x4c\x97\x26\x6d\xa2\xd5\x8a\x90\x91\x54\xb0\xe1\xa1\x23\x8b\x48\x39\xae\xed\xc5\x1c\x45\x0b\x90\x84\x9e\x99\x27\xb9\xb3\x69\x70\x75\x34\x31\x14\xbf\x17\xaf\x68\x1d\x19\xba\x60\xee\xdf\x26\x5c\xb8\xa8\xa5\x4e\x77\x5d\xa8\xc8\x7b\x71\xf0\xf6\x41\xe7\x99\xea\xaf\x62\x83\x40\x6f\x13\x5c\x02\xbd\xa2\xda\x2d\x3c\x49\xb3\x68\x90\xf2\xc7\xf2\x6a\x7d\xfe\xb4\xe4\xb2\x9a\x57\xfe\x23\x7b\x04\x23\x3f\x00\x6b\x39\x4d\xd1\xd3\x01\xe3\x88\x05\x82\xae\x60\xbd\x86\x71\x1a\x01\x97\x1f\xf8\x51\xdd\x30\x0f\x6f\x19\xe0\xef\x39\x78\xab\x89\x2e\xf2\xd7\x7d\x1a\xe2\x71\xfa\x37\x5c\x1b\x6a\xa4\x76\x78\x29\x69\x02\x86\x8a\x43\x20\xbc\xb3\x7a\x4c\x06\xe9\x3f\x46\xd8\xb2\x3d\xde\x98\x31\xc4\x33\xe9\xc9\x70\xff\x1e\x7a\x3f\xe8\x84\x49\x8b\x8e\x5d\xcd\xe7\x3d\x13\xf7\x93\x7e\x59\x78\x8a\x3c\x39\x78\xc1\x82\x4f\x94\x87\xe5\xa7\x49\x03\x8c\x7c\x08\x60\x5d\xa4\x8e\xd9\x7e\x40\xcf\xae\xd6\x06\x4d\x9f\x33\xe4\x32\xc4\x26\xf9\x8f\xcf\x6e\x97\xe7\xca\x7f\x7a\x76\x3b\x3c\x94\xc7\x11\x19\x65\x1f\xe8\x5c\xb0\x0f\x7c\x84\x3a\xda\x85\x5a\x0f\xf6\x80\x70\x91\x99\xc2\xa3\xd3\xec\x4d\x3d\xb7\x40\xee\x39\x91\xbc\xed\xe0\xc9\x20\x75\x66\x5f\xe0\xd6\x2c\x7a\xe7\xed\x3b\x77\xd2\x20\x28\x96\x45\x13\xa7\xcc\xf4\x51\xba\xd9\xea\xdd\x9e\xa8\x52\x7e\x20\x3a\x14\xaf\xdd\xc6\x6b\xad\x33\xdb\xf8\x65\x5b\xd7\x92\x46\xaf\x55\xce\xb2\xa7\x37\x73\x33\xd0\x22\xfe\x38\xb0\x58\xd3\x3e\xd6\x4a\xdb\x78\x95\x20\x69\xff\x46\x09\x30\x28\xc8\x28\xd9\xce\x17\x75\x5d\x73\x55\x51\x45\x51\x63\x65\x7c\x18\xf7\xe9\x94\xcb\x4a\x9a\x8b\x13\x1e\xb7\x14\x29\x2a\xad\x3a\xb7\x47\x1b\x56\x56\x6b\x03\x30\x52\x48\x90\x7c\x63\x4a\x30\x9d\x3b\xa7\x0d\xbe\xf5\x47\xdb\xc8\x83\x83\x7a\x2a\xad\x00\x87\x47\xaa\xc1\x8b\x86\xd7\x57\x36\x42\x23\x57\x5d\x7d\x09\xdf\x3a\x68\x5c\x55\x69\x51\x44\x72\x7b\x12\xc5\xcd\x25\x97\x91\x73\xf9\xd0\xc6\xfb\xff\x16\x8e\xf7\x7f\x14\x8e\x06\x79\x24\x3a\x46\x7d\x05\xc6\xc7\xd1\x6a\xd8\x5f\x14\xf1\x28\x12\x6c\xcb\xf7\x10\x9c\xe5\x5e\xc5\x8e\xf2\x2a\xa1\xe7\xf2\xc8\x0c\x3d\x4f\x4f\x94\x5b\xd0\x43\xc0\x3f\x05\x64\x3d\xc0\x72\x1c\x16\x14\xb5\x80\xca\x9a\xd4\x06\xfd\xd0\x82\x8f\x3f\x06\xa6\xb9\xb0\x6b\x21\xea\x79\x3f\x06\x01\x8b\xcf\xde\x2f\x01\x32\x4b\xf1\x87\x3e\x5e\xb0\xe0\x63\xf9\xc0\x42\x3c\x7c\x21\xc1\x89\x4d\xdc\xf3\x78\xb1\xee\x1a\x0a\x0b\xc3\x11\x06\x43\x88\x02\xd5\x93\xfe\xd6\xbd\x8b\xf9\x10\x7e\x1e\xbc\x52\x1e\x45\xdb\xfe\x92\x3d\x80\x87\xf1\x87\x61\x9e\xf4\xfb\x8c\x36\xe0\x83\x00\x35\x4d\xe5\xa0\xa2\x23\x21\x4c\xb6\x13\xc1\x92\x11\x23\x12\x43\x26\xee\xfa\x05\x87\x47\xa4\x5c\x61\x67\x34\xd9\xbf\xe9\xfc\xb1\x4b\x0f\xd1\xb3\x48\xe9\x7b\x00\xbe\x59\x20\x07\x5b\xa0\x0d\xea\x8e\xe8\x57\x27\xe4\x79\x0e\x24\xcd\x71\xf0\x65\xae\xdf\x20\xdd\x09\xcf\xed\x4c\xdf\x49\xc7\x05\x3a\x92\x2a\x41\x50\x09\x47\xb1\xc4\xef\xa4\x4e\x02\x90\x1e\x88\x97\x20\xff\x7e\xcc\xf3\xb0\xa9\xa8\x7b\x81\x94\xd1\x55\x3c\x02\x3b\xa9\x43\xe0\x4d\xd5\x1f\xa0\xde\xbf\x05\x76\xb4\xeb\xb0\xe2\x01\x60\x0d\x19\x0f\x80\x32\x7b\x9a\xcd\x7f\xa7\x62\xf2\x87\x39\xa4\x26\x7f\xe0\x93\xf2\x57\x78\x20\xf5\x45\xe9\xf7\x51\x37\x54\x96\x33\x52\x0f\x14\x99\xe7\xcf\xe5\x71\x68\x37\xda\x8a\x44\x64\x3b\xa8\xd3\x19\x8d\xac\x48\x06\x00\x0a\x3f\x40\x94\x1f\x49\x1d\xdf\x9d\x2d\xc3\xbe\x3b\x53\x84\xfd\xef\x04\x4f\xe5\x71\xf8\x09\xb5\x0d\x22\x97\x9b\x71\xa6\x0d\x80\x2b\x2f\x5f\xcd\x6e\x25\xba\x6c\xd2\xd0\x5b\xef\xd8\xfa\xf7\x6c\x51\x18\x9c\xbe\x4d\x7e\x14\xcd\x4b\xdf\x40\x28\xd7\x41\xe2\x0a\xa0\xa3\x54\x65\x0a\x4f\x0e\x69\x99\xa7\x51\x93\x4f\x33\x76\x70\xf9\xaf\xf2\x43\xd8\x9d\x5e\x40\xf9\x89\x79\xbf\xc8\x4a\x06\x2a\x8c\xe5\xeb\x2b\x79\xec\xd0\xdd\x9b\x1d\x7e\xdb\x93\x1b\x02\x9f\x82\xb9\x7f\x45\xd5\x8d\xcc\xfb\x25\x96\x6a\x44\x84\x39\x79\xfe\x63\xe6\xd4\x5b\x0d\x82\xb1\xde\x20\x73\x68\x79\xfa\xa7\x14\x5f\x59\x2b\xc5\x57\x4f\x8f\x4d\xbd\xfc\x27\x8b\xd7\x47\xca\x23\xfd\x2b\xea\x93\xa7\x16\x6c\x0d\x0f\xa9\xba\xc0\xed\xf1\x14\x15\x55\x56\x8f\x82\xe7\x93\xb0\x66\xcf\x01\x87\x76\x91\x35\x33\x18\x58\x87\x5d\x65\xcc\x99\x35\xcb\x94\x7c\x68\x8c\x0b\x41\xfc\xdc\x2d\xf3\xc6\x0d\x75\x8f\x73\x0f\xee\xdf\xde\x5a\x3e\xd9\x71\xe1\xec\xbf\x4c\x5d\xe0\x1e\x23\x18\x06\x55\xf7\x1b\xaa\xbb\x6b\xa2\x61\x0a\xb4\xd9\x24\xcf\x47\x2f\x53\xfb\xbd\xf5\x80\x68\xb1\x20\x82\x97\xb4\x45\x67\x2f\xd3\x7c\xf8\xc7\x2c\xf3\x94\xef\xc1\xbc\x35\x52\x9f\xa9\x7e\x1f\x75\x97\x66\x58\x5d\xc6\x4f\x2a\x6f\x02\xc2\xb3\x38\x7d\x04\xfa\x31\xef\xe7\x10\xa3\x53\x57\x8c\xe8\xf0\x24\x7e\xf4\x6f\x32\xc8\xbe\x1f\xca\x23\xbf\xf9\x06\x2f\x01\xb1\x19\xcb\xb7\xca\x87\xf1\x82\xf4\x4f\x90\x17\x95\x1e\x32\x4a\x20\xf8\x3a\xac\x24\x4f\xb5\xc9\x20\xb6\x5a\x6d\x54\x54\x03\xbd\x79\x5a\xfc\x68\x25\x09\x3f\x3b\x0a\x2d\x09\x30\x01\x71\x25\xa9\x4b\x9c\x4e\x0a\x5d\x32\xf8\xe6\x01\xd8\xbf\xa3\x1a\xa8\x23\x71\xd6\x90\x21\xb3\x60\xb1\x46\x7d\x3f\xba\xbe\xdf\x18\xe2\x64\x9c\x30\x61\x59\x47\xbf\x31\x94\xef\x03\xa8\x23\xa8\xed\xc2\xbc\x3f\x63\xb5\xe8\x57\x67\xc1\xbd\x98\x7e\xae\xc1\x22\xff\x39\x2a\xd7\xd7\x9e\x4d\xc8\x95\x5b\xb2\x42\x2e\xf0\x40\x79\x2a\x0e\xa5\xaf\x00\xfa\xe3\x04\x1e\x48\x54\x44\x06\x11\x57\xa6\xca\x00\xcf\x2e\x6d\xca\x53\x33\xd2\xa6\xd2\xce\x48\x68\x67\x3a\xb4\x63\x3d\x60\xe2\x56\x0b\x04\x70\x3f\xc1\x59\xe9\xec\x3c\x74\x57\x86\x85\x12\xf8\xaf\x05\xf8\xd7\x82\xce\x0a\x12\x88\x5d\xd3\x55\x91\x8b\x37\x13\x58\xde\x99\x76\x94\xc6\x3e\xf5\xa1\x98\x5e\x77\x16\xbd\xf4\xda\x9e\x7a\x29\xd0\xa5\xb4\x1d\xe8\xd2\xb5\xd0\xac\xf9\x80\x40\x6c\xa5\xd0\xf4\x34\xd8\xad\x2a\x6d\xfa\x42\x95\xc7\xbb\xe5\xb4\x9d\x61\xfa\xbe\x8f\x08\xee\xea\x7d\x4c\xb7\x2c\xb7\xa8\xf7\x09\x48\xda\x87\x49\x02\xf3\x83\x16\x5b\x2b\xe2\x08\x56\xbd\x5a\x59\xaf\x90\xbd\x12\xf5\xb1\xd3\x67\x38\x4e\x6e\x99\x3f\xff\x55\xa2\x1b\xc8\x4f\x31\x95\x78\x04\xdb\x4f\x19\xaf\x8b\x17\xcd\xc4\x8b\x44\x7c\x48\x30\x71\x8a\xe7\xe8\xbf\x1b\x2f\x53\xd9\xc7\x78\x99\x2b\xf0\x40\xe6\x03\x65\x3f\x90\x05\xc9\xd2\x61\xe6\x0a\x85\x0e\x77\xcb\xf0\x99\xe9\x7d\x0f\x01\x58\xbb\x47\x0e\xa7\x3f\xc7\xef\xb3\x7b\xe9\x3d\xd4\x86\x07\x73\x11\xc3\x1e\x79\xfe\xb9\xec\xe5\xe7\xba\xc8\x8b\xb2\xb7\x8e\xc3\x7d\xe7\xf2\x1b\xe8\x7d\x34\xf4\x03\x76\x43\x14\xc7\x8f\x75\x31\x05\x17\xb9\xf8\x9d\xbd\xf8\x1d\x75\x99\x03\xed\xc8\xf3\xba\xbb\x35\xa7\xfb\x97\xb9\x3e\x77\x79\x7d\xce\xbe\xcd\xa8\xbd\x24\xa8\x5a\xd1\x76\xe5\xf5\x6b\xf1\x3b\x6b\xe1\x1e\x45\xdd\x65\xd2\xe7\x41\x3f\x8f\x50\x5a\x40\x9e\xd0\x51\x75\x9e\xd2\x50\x21\x62\x8f\x34\x46\xa5\xf8\x23\x78\xb2\xbc\xe7\xb3\x15\x2b\x96\xcb\x4f\xbf\xbb\x42\x81\xff\x0e\xf9\x5e\x3c\x07\xf6\xba\x1f\xb4\x03\x03\xb2\xb1\x66\xb3\xa4\xf7\x38\xe9\x73\xc0\x0f\x68\x77\x14\x91\x0b\x71\x54\x29\xde\x43\x93\xcb\xd7\xd3\x73\x2e\x20\xa9\x5a\x9a\xcb\x12\x23\xdb\x47\x26\xca\x87\x5a\x26\x5a\x17\x8c\x99\x3d\x78\xf0\xec\xd6\xf9\x76\xf9\xc3\xe2\xaa\xd6\xb8\xdf\x5f\x37\xb6\xaa\x78\xc4\xd4\x09\x13\x52\x8a\xec\x10\xe5\x82\xe8\x1d\xfe\x2d\xa0\xf1\xe6\xfd\x06\x81\xc5\x1a\x1d\x12\x62\x42\xac\x31\xd6\xe8\x01\xdd\xf9\x9d\x51\xdb\xb6\x69\xff\xb8\x4b\xc8\xdb\xed\xca\x05\x79\xfe\x76\xae\x00\xcd\xd6\x85\x91\x04\xb4\xd8\xc2\x98\x8c\xf0\x81\xc0\x49\x7c\x8d\x6c\x86\x9e\x67\x45\xcf\xcb\x2e\x0d\x97\x86\x2f\x51\x5f\xb9\x15\xba\xb8\xa7\xba\x7e\x60\x74\x64\xc7\xf4\xcc\x27\x82\xcf\x54\x5f\xfd\xb3\x3a\x67\x9c\x8e\xe2\xc3\xab\x7d\xa0\x31\x51\x5d\x09\x1a\xc3\x9c\xcd\xe6\x3a\x11\xa2\xb2\xbf\xe5\x71\x76\xb5\x22\xa9\x53\xf1\x8d\x8a\x7a\x8d\x44\xd4\xd3\x04\x7d\x6a\x83\x40\x70\x75\x57\x1f\xf7\xdb\xa9\xb8\x47\xa4\x3d\x4d\x1b\xd2\xf4\xa0\xe9\xa0\x07\x11\x7f\xab\xf3\x20\x10\x03\xd8\x1f\xf4\x11\xd8\x22\xff\xed\x0e\xe9\xe9\x55\x25\xb2\x72\x1c\x64\xe5\x5d\x40\x6a\x9c\x49\xa3\x35\x4f\x17\xfc\x37\x72\x77\xa0\x87\xbc\xcb\xca\xef\xc1\xb8\x8a\xf8\x5f\x13\xdb\x04\x2a\x44\xa1\x24\x89\xb4\x64\x57\x4b\x86\x3c\x13\x41\x3d\x68\x44\x54\xf8\xa4\xc2\x2d\x5b\x72\x16\x31\x61\x6c\xbf\x27\x0f\xe2\xfe\xf5\xa5\x25\x89\x44\x49\x69\xbd\xbc\x28\x5e\x52\x9a\x48\x94\x96\xc4\xc9\xcc\x0c\x2f\x91\x7f\x3d\x8d\x5c\x96\x36\x34\x94\xaa\xef\x04\x1f\x7e\x02\xf8\xbe\x3a\x7d\x2b\xa5\xbf\x46\xbd\x1e\x11\x39\x97\xf2\x51\xb6\x48\x49\x4d\xac\x14\x96\xb2\xf5\x1f\x70\x45\x69\xb0\xa2\x20\xdc\x2c\xb7\x8c\x3e\xe7\xb9\xa7\x93\xde\x7a\x4f\x50\x91\x7b\x8f\x83\xdc\x3b\x8c\xae\x3c\xa3\xe3\x34\xbe\x93\xcf\x17\xb9\xe3\x2a\x5f\xcc\xa7\x7d\xc0\xa9\x54\x9a\xf7\x23\x24\x8f\xe8\x99\x00\xe3\x9e\xcc\x9e\xe4\x89\xd1\x47\xc1\xfa\x7c\xd5\x92\x30\x6b\x45\xb5\xcc\xc8\xa1\xeb\xa8\x3c\x4e\x8d\x79\xc7\x34\x59\x3f\xb2\x93\x98\xe2\xe4\x96\x77\xbb\x14\x3c\x01\xf1\x9a\x5f\x0f\x7b\x37\x91\x0c\xbb\xc5\x8d\x29\x9d\xe8\x0e\xb9\x6b\xdd\xac\x81\x75\xeb\x93\x2e\xbd\x9e\xd9\x98\x12\xf5\x21\x7d\xad\x9e\x85\xd9\xa1\xf1\x0e\x4a\xed\x08\x62\x56\x21\xe6\x10\xa5\x3a\x04\x61\xd8\xb0\x01\x4b\x33\x48\x05\x1b\x71\xdc\xe0\x62\x8a\x40\x07\x06\x0c\x1f\x38\xa5\x79\x70\xb1\x8a\x59\xe4\x8a\xfb\x9f\x72\x40\xa5\xb2\x39\xfd\x96\x94\x13\xcc\x2a\x9b\x53\x87\x00\x17\x9e\xe2\xac\x78\x84\xee\x0e\x9a\x21\xa5\x06\x8d\x4d\x56\x85\xfd\x9b\x53\x61\x54\x5a\xb5\x39\x55\x6a\x96\xa8\xe9\x55\xa5\xf7\x06\xd6\x8c\x92\xd4\x38\x9b\x8f\x27\x99\xe0\x16\x2d\x5d\x02\x29\x9a\x5c\x79\x16\x7c\x17\xce\x62\x37\x3d\xcb\x3e\x78\x37\x5e\x1c\x8d\xc7\xa3\xc5\x71\xed\x9d\x3b\x9e\xb7\x31\x2e\x53\x7f\xc5\x47\xd4\x0f\xd4\xae\xf1\x14\x27\xc1\x98\xa2\x30\xa6\x6a\x34\x23\xd9\x74\x96\x51\xa0\x68\x55\x34\x5a\x00\x3f\x44\x43\xd1\xda\x28\xfc\x10\xf5\x24\x3d\x65\x1b\x53\x11\xd1\x13\xf2\xd4\x7a\x58\xbd\x47\x31\x1a\xf5\x18\x5e\xfe\x78\xcf\x32\x4c\xf6\xbf\xd8\xeb\x07\xfa\xfe\x9a\x2f\xcc\x1b\xa9\xfc\x5d\x2f\x9e\x99\x66\xe5\xd9\xa8\x3b\xfd\x32\xe8\x14\x8e\x43\xac\xd1\x08\x64\x4a\xaf\x10\x56\xaa\x33\xc6\x1a\xa3\xaa\x61\x33\x0e\x34\x5a\x5a\x10\x8e\xfd\x45\x31\x6f\x92\x37\x79\xb6\x73\x9e\x6a\xe2\xbc\x0c\xde\x14\xbb\xc0\x04\xc0\xdf\x5f\xa4\x0f\x23\x03\xe8\x51\x02\x83\xf5\x18\xd3\xad\x09\xfc\xc4\x46\x31\x3f\x01\xd8\x16\x87\x36\xa5\xfa\xb9\xce\xed\xa5\xdb\x9d\x73\xe5\x16\xad\x49\x78\xde\xdb\x1d\x82\xc9\x7f\x9f\x7f\x8e\xea\x02\x51\xc0\x90\x41\x68\x14\x9a\x84\x3a\xd1\x65\x68\x19\x5a\x83\x36\xa1\x7b\xd0\x4f\xd1\x7e\xf4\x0c\x7a\x01\xbd\x82\x5e\x43\x6f\xa1\x3f\xa2\xf7\xd0\x47\xe8\x53\xf4\x70\xf2\xfc\x48\xe0\xba\x5f\xfd\xea\xea\xc3\x13\xa6\x4d\x1b\x7b\xfe\xbe\x39\x73\x1e\xb9\x58\x32\x18\x44\xf6\xca\x87\x1e\x5a\x78\x7f\x53\x4b\x4b\xbc\xf9\xae\x0d\x1b\x6e\x5b\x57\x1d\x0b\x1c\x3e\xff\x62\xf6\xfe\xe6\x75\xb1\xd8\xba\xe6\xfb\xd9\x8b\xcf\x3f\x1c\x30\x9c\x7a\xf9\xcd\x37\x5f\xff\xed\xc9\x0f\x3e\xfe\xf0\x93\xe7\x8e\x1f\xff\xe4\xe3\x93\xdc\x89\xb7\x5f\x7a\xfd\x9d\xe7\x8f\x1d\x7b\xf7\xe8\x09\x98\x0e\x7a\x48\xa5\xb6\x57\x4d\xfb\xb8\xa7\xa9\x56\xfb\x93\x3d\x21\xfd\xa3\x2f\x24\xe6\x4e\x55\x95\x01\x6f\x4b\x72\x3e\xe7\x7e\x6f\xcf\xf9\xcc\xff\x07\xf7\xe7\x7e\x1f\x3b\xcb\x3d\xec\x7f\xf0\x2c\x7f\x96\x7b\xf2\xbe\xa7\xb4\xc8\xae\x58\xec\xa3\x94\x58\x92\xf4\x25\x71\x3e\x42\xbf\x8d\xd0\x50\x4d\xf8\x2f\xe3\xa0\xdb\x1d\x24\xff\xd9\x6d\xda\x27\x39\xa1\x7d\xd2\xfe\xe3\x11\xda\xa7\xee\xab\xb4\x4f\xcc\x8d\xbd\xbf\xeb\xca\x34\xd6\xae\x7d\xfa\x8e\xbc\x84\x24\x68\x75\x07\x79\xa5\xad\x75\x6a\x9f\xba\xf7\x68\xbf\xb2\xe3\xfb\xf8\xee\xf9\xae\x93\x78\x80\xfc\xf2\xc9\xae\xd3\xcb\x4e\x76\x91\x4f\x5d\x27\x99\x16\xf9\x65\xf2\x09\x0f\x60\x46\x74\x75\xfd\xf0\x40\x57\x17\xf3\x7e\x3e\xac\x41\x79\xac\xfa\x81\xdd\xab\x7e\x58\xdc\xe3\x8e\xee\x8d\x3d\xbe\xd8\xa3\xbc\x87\xf0\x95\x4a\xcf\xc1\xee\xa7\xb5\x36\x66\xa9\x1f\x54\xe8\x42\x1f\xa9\xef\xf2\x61\xf5\xd6\x0f\xd5\x77\x76\xd6\xc9\xae\x1f\x9a\xbb\x4e\x72\x25\x00\xf4\x0f\xcd\x78\xc0\xc9\xae\x2e\xee\xfb\xae\x33\x6b\x14\x70\x95\x7d\x77\x3d\x67\x47\x2b\xf8\xbb\x15\x1f\xb0\xc0\x30\x3c\x42\x06\x6a\x24\xa1\xba\xbd\x62\x41\x8e\x7b\x24\xe2\x25\x8d\x5d\x1d\xa0\x1e\x4e\xfe\x6e\xe2\xe1\xbc\xef\x5e\x45\x4e\x05\x86\x36\x8b\xdf\x0e\xfc\x14\x9e\x57\x63\x3c\x95\x10\xcf\xec\xf3\x7d\xdb\x69\xb8\xd7\xb2\x86\x9a\x7c\x9b\x66\x45\xd2\x41\x12\x63\xb1\x26\x93\xdf\xe3\xb1\x23\xce\x24\x08\x20\x2d\x10\x7d\xf7\x68\x3d\x39\x14\x43\x9b\x56\x8e\xc2\xe4\x5b\x1e\x73\x8d\xd2\x79\x1a\xd4\xd7\x9a\x55\x42\xe7\xd2\x74\x29\xf9\x88\xea\x27\x53\xe6\x21\x0a\xf4\xe7\x9d\x34\x89\xeb\x2c\x4b\x12\xe5\x42\xc7\x71\x66\x13\xcf\x30\x7a\x3d\x8b\x41\xdf\x23\xfc\x17\x48\x1b\xd0\xa2\xec\xb8\xce\x26\x83\xca\xeb\x7b\xc8\xa0\xd7\x43\xdb\x2b\xa8\x0f\x98\xf8\xbf\xe0\x1b\x9e\x37\x70\xfa\xbc\x39\xf6\x90\xe0\x11\xe2\x49\x5e\xa1\xb8\x9f\x53\xf7\xde\x47\xbc\xd1\xea\x1a\xe5\x3e\xaf\xae\x11\x8d\x7b\xcd\x3e\x2f\xf4\x58\xa3\xfa\xcc\x12\xc1\xdc\x3e\x0a\x92\xc2\x24\xfa\xbc\x1d\x35\x24\x3d\x36\x93\x89\x68\xb0\x3c\x6f\x35\x18\x9c\x3a\x24\x30\xa0\xb8\x31\x56\x23\xf1\x4f\x35\x29\x04\x49\x6b\xd7\xa1\xfa\xd9\x58\xea\x22\x8f\xc6\x04\xac\x75\xd3\x5f\x69\x5f\x7e\x4a\xe9\x4e\xde\xa4\xbc\xe3\xe6\x6c\xbf\x3d\x70\x43\x8d\x25\x56\x42\x89\xb3\x73\xd8\xb7\x4e\xc3\xbd\x96\x55\x6a\x30\x4a\x73\xbf\xc0\x7b\xf9\xa9\x9a\xed\xc9\x42\x63\x6c\x35\x7f\x56\xae\xd9\x68\xaf\xc6\xaa\x79\x3e\xcb\x93\x71\xba\x0e\xe6\xef\xb5\xf4\x53\x30\xfa\xfa\xa4\x9b\x33\x9b\x59\x8b\x05\x19\x04\xc1\x86\x10\xcd\x57\x24\x62\x0b\x47\x4c\x76\x4d\x3d\x87\xae\xcc\x6c\xa3\x27\x16\x87\x17\x01\x98\x8f\x27\xda\x08\x2b\x7e\xa2\xf8\x2e\xdf\x05\x05\xf7\x14\x3f\xf0\x40\xf1\x3d\x05\x17\xf8\xee\x2a\xde\xf5\xfa\xc4\x8b\x77\xec\x98\x39\xa1\xaa\x72\x42\xe7\x7d\x3b\xbb\x26\x56\x81\x6c\x73\x2b\xcc\xf9\x02\xd0\xdf\x9c\x20\xaf\x54\xa2\xc1\xc9\x80\xc8\x87\xc3\x2e\x97\xb1\x14\x21\xbf\xd1\x58\x55\x2e\x7a\x3c\x96\x28\x5f\x58\x28\xb0\x76\x0b\x65\x9c\x80\xdc\x84\xd9\x1d\xcd\x83\xc0\x41\xf4\x14\x3e\x6b\x1e\x51\xb2\x23\x12\x31\x38\xb7\xa2\xba\x96\x1a\x97\xa4\x7d\x5a\xb0\xac\x83\x28\x54\x64\x1a\x95\x77\x79\xee\xc8\x84\x62\xeb\x6a\x1f\x5d\x5f\x37\xb6\x35\x9e\x18\xf9\x65\xc7\xb2\x89\x13\xc9\xec\x12\x73\x0a\xf9\xaa\x61\xd4\xc8\x44\xfd\x68\x72\xdf\x38\x32\x5f\x43\xb9\x8b\xd1\x0b\xba\x0b\x15\x1f\x2a\xd6\xe9\xc8\x36\x60\x78\x9e\x08\xbb\xd4\x85\x99\xdd\xd9\x8d\x51\x67\x5c\x88\xb3\xe6\xe6\x6f\x2e\x5e\x00\xff\xb9\x8b\x7f\x8b\x6b\x7e\x2b\xff\x1e\xda\x78\x45\x5e\xc6\x5b\xd3\x9b\x40\x3e\x00\x19\xdf\xcc\x71\x36\xa4\xdf\x94\x52\xcc\x26\x26\x9e\x9a\x4d\x2a\xb5\x15\x2c\x2a\x2e\x8d\xc5\xdd\x5c\xbc\xbe\x98\x18\x4f\x38\x66\xde\xcb\xf2\xdb\x3f\x35\x8d\xa9\xc4\x0d\xdf\x7d\x8f\x1b\x2a\xc7\x98\x7e\x2a\xbf\x2d\x2f\x6b\x59\xd5\x41\x36\x6e\xc7\xaa\x16\xba\xa6\xaf\x70\x9d\xbc\x95\x5f\x06\xed\x57\x24\x9d\xa4\x7d\x93\xc8\x87\x78\xc6\xc0\xc2\xe6\xd0\xf7\xf2\x07\xfe\x37\x5d\x71\x9d\x79\x5d\xd1\xbe\x4e\x70\x7b\x78\x72\x9c\x53\xd9\xbf\x1c\x75\x52\x1e\xc1\x6d\xa8\x59\x1b\x04\x0b\x92\x7c\x82\x7b\x8f\x3b\xa1\xda\x46\x60\xfc\x5f\x73\x7b\xd2\x33\xa9\x6f\x89\x3e\xc3\xb0\x1b\x52\xa0\x8d\xf7\x78\x40\xfe\x5a\xb1\x1d\xa4\x0f\x73\xd3\xf9\x08\xe8\x6f\x1e\x54\x97\xf4\xba\xfa\x94\x1a\x0d\xaa\x4a\x97\x15\x02\xc9\xf0\xb4\x38\x04\x55\xc9\x56\x05\x3e\x2b\x66\x7f\x35\xfb\xe5\x27\xf7\x8c\x99\x79\x9d\xa3\xc1\xfe\xc4\xdd\xb3\x5f\x52\x3f\x3b\x8f\x50\xfd\x6e\x58\xff\x45\x3f\x81\xb7\x64\xff\xc5\xab\x51\x8f\xf9\xf4\x25\xcd\x64\x06\x15\x37\x8f\x99\xd7\xdc\x3c\xc4\x23\x5b\xcf\x91\x54\xe1\xc5\xd1\x22\x8e\x74\x56\xcc\xcc\xfb\x2d\x8e\xfd\xd4\x38\xa6\x52\x7e\xf5\xfb\x7f\xc9\xaf\x56\xc1\xf4\xe1\x18\xbf\x6c\xe4\xaa\x49\xda\xf4\xe1\xf4\x24\x79\x36\xfb\x1a\xf5\x89\x53\x3f\x04\xb5\x5b\x52\x19\x11\xc7\x1a\x81\xeb\x13\xe9\x90\x1d\x1e\x8e\x9d\x31\xb2\xdf\xaa\xa2\x61\x97\x2a\x14\x32\x69\x0b\x53\x85\xbe\xe2\x96\x83\xae\x12\x45\xb1\x03\x51\xbd\x3e\x42\x0e\xb3\xee\xb7\xd9\x38\x01\xde\x1f\xf7\xba\xb4\x13\xad\xcd\xf1\xa6\xda\x66\x15\x25\x95\xca\x0c\x51\xb2\x5f\x48\xcd\xdc\xe6\xec\x19\x34\xa7\x40\x6c\xa4\xa0\xdf\x09\xd3\xcf\x1b\x75\x8f\x79\xc4\xdc\x2d\xfd\xa6\x4c\x3f\xef\xfc\xe6\x5a\x57\x51\xd7\x1d\x6d\xed\x4d\x93\x07\x8d\xe2\x96\x8f\x1f\x27\xaf\x11\x03\x03\x46\x3c\x3c\x78\x4c\x94\x61\x52\x8b\x0b\x46\x5e\x2d\xc9\xef\x32\xcc\xc0\x61\x73\x69\x9c\x4b\x21\xc0\xf4\x67\xee\x6a\xe4\x40\x5e\x14\x38\x88\x24\xc9\xe8\x14\x9f\x04\x28\x38\x64\x54\x4f\x6f\x3a\x14\xcd\x55\xd2\x32\x47\xd2\x74\x79\xf1\xfa\x42\x1c\x2b\x92\xe2\x0d\xa5\xcb\xce\x9f\x32\x62\x62\xe1\x8c\xc6\xeb\xae\xf9\xfb\xdb\x6f\x5f\xf7\x8f\x46\xb6\xc3\xb4\x7c\x96\xa3\xc8\x5e\x78\xcb\xfd\xb8\xe4\xdb\x7e\xff\x7a\xe9\xb2\xa9\xa4\x9f\x05\xcc\x00\x74\x2b\x3f\x0b\x68\x9e\x84\x02\xfb\x59\x83\xc3\x45\xce\xf3\x9a\xed\x76\x31\x1b\xf7\x77\xb4\x87\x1f\x96\xcd\x84\x64\x36\x92\xd3\xc3\xe4\x14\xb1\x8e\xc4\x66\xb6\xef\xe7\x8b\xd5\xc3\xc3\xdd\x51\xed\xf0\x2e\xf0\x85\x33\x4c\x15\xe6\x61\x2c\x06\xe8\xc3\xb9\xcf\x22\x90\x71\x38\x11\x43\xa3\x32\x9b\xc9\x12\x91\xca\x71\xb4\xfa\x79\xae\x11\x1d\xf3\xf2\x77\xab\xaf\xc3\xfc\xea\xb5\xf3\xc6\x4c\x1c\x3f\x6a\xd4\xf8\x89\x63\xd8\xf3\xe4\xb7\xee\xb8\x15\x97\x6e\xbd\x75\xf5\xd2\x05\x37\xde\xb8\x44\xb5\x13\xbd\x0f\xed\x47\xb8\x79\xa0\x0b\xc5\x0e\xf0\x4e\xa7\x20\x91\x43\xa4\x9c\xc5\xc2\xd8\x9e\x84\x31\x18\x90\x59\x9d\x31\x2d\xaa\x92\x88\x0a\x71\x7a\x00\x37\x4e\x97\x90\xcc\x1d\x3d\x11\x7d\xc5\x8c\xd1\xc3\xcf\x3b\x32\xea\x41\xbe\xe8\x8a\x8a\xcd\xad\x7b\x99\xb7\x67\x3b\xf0\xd3\x62\xa0\xfb\x5b\x31\x50\xe3\x2a\xdd\x8d\x17\xd1\x98\xd3\xb4\x1f\xd6\xe6\x53\x18\x8f\x1b\x49\x8f\x8b\x26\x3d\x19\x8e\x0b\xb1\x5a\x27\x30\x57\xd0\x60\x38\xf7\x3c\xb8\xb2\x46\x9f\xfa\xe7\x0c\x90\xff\xbe\x71\x75\x6a\x4a\xc4\x5f\xdb\xba\x73\xe6\xec\xc9\xe7\x30\x17\x38\x03\xb8\x62\xd3\x36\xe7\xbd\x5d\x05\xdf\xac\x9a\xef\x52\xf8\xe8\x5f\x61\x3c\x6e\x7e\x03\xcd\x8b\x59\xbd\xcf\xe6\x24\xa3\x30\x23\x2b\xae\x3e\xe0\x33\x18\x02\x80\x93\x83\xf7\x7b\x91\x9b\x51\xc3\x45\xeb\xd5\x81\x91\x99\x74\xc2\x22\x29\x1d\xd3\x2c\x47\x74\x78\xd8\xa5\x64\x42\x2a\x5a\xdc\x72\xc1\xa7\x6b\x56\x8d\x48\x72\x9d\xcf\xb7\xdc\x27\xbf\xb7\xbd\x25\x51\xdf\xba\x9d\xb9\xa8\x3f\x8e\xdc\x76\x8f\xb5\xa0\xdf\xcf\xc4\xc0\x99\x37\xc4\x00\x96\x3e\xf2\xe2\xa7\x8d\x64\x5e\xff\xc8\x0c\xc0\x25\x00\x47\x01\xaa\xdc\x47\xce\x9b\x57\xff\xfb\x13\xfc\x74\x6e\x7f\xe4\xdc\xfe\xfc\x5e\xe7\xf6\xef\xfc\xd1\x73\xfb\x72\x13\xc0\xf0\x32\xcc\x75\x35\x6a\xde\x57\x51\x45\xe2\x65\x8d\xc5\x41\x9f\xcd\x54\x5e\x5e\x60\x8d\x01\x1c\x49\x93\x33\x12\x61\xdd\xd1\x28\x8f\xf4\xac\x0a\x0e\x31\xfd\xab\x21\xb4\x14\x2a\x05\x2e\x4c\x6d\x83\x1a\x68\x6a\x4d\x55\x5d\x4e\xd9\xb7\x3c\x40\xe5\x8f\x2a\xe6\x16\x77\x16\x55\xac\x2e\xdf\x3c\x5a\x4e\x77\xcc\x70\xcf\xf6\x18\x3b\xe4\x6f\x26\xcd\x6a\x19\xda\x91\x1e\x35\xea\x21\x6e\xa8\xaf\x78\x98\xb7\x5c\x03\xfc\xd2\xd9\xa2\x2e\x1c\xcb\x5c\xd8\xe5\xe1\x19\xfc\xc7\xe9\x16\xd8\x63\x4f\xc0\x18\x5c\xa8\x72\xbf\xce\x6e\x77\x91\xc8\x6b\x0b\x12\xd5\x73\xf3\x64\x75\x19\x18\x2a\xa1\x30\xcd\xea\x4a\x52\x91\xa5\xaf\xb3\xf2\x4f\xf4\x3c\x2a\x7f\x75\x5f\x47\xe5\x89\x9d\x06\x70\x74\x27\xf7\x39\xe0\x68\xe0\x20\x6c\x05\xbd\x40\xe3\xbd\xed\xca\xe9\x78\xe8\xe7\x98\xd2\x47\xef\xb4\x41\x84\x94\x04\x9a\x9a\xc6\x8c\x1d\x52\x72\xdd\x75\xc5\x85\xb1\x6a\xc7\x58\xa6\xaa\x65\x08\x5e\x1f\xf0\xac\x5e\x5d\x2f\xaf\x8a\x95\x19\x63\x66\x89\xae\xcd\x31\xc0\xd3\x38\xec\x3b\x2b\x2a\x4a\x1a\x40\xc8\x13\x40\x66\x34\x71\xa4\x1f\x3d\xc2\xd9\x3d\xa7\x46\x20\x45\xf3\xa2\xc8\x03\x55\x9f\x91\xc0\xf1\x87\xee\x4d\x9d\xe8\xcf\x54\xa9\xe7\xb3\x57\xe0\x75\xea\xd9\x6c\xf9\x14\xac\x7b\x29\xb4\x1d\x40\xf1\xa4\x51\x8d\x97\xf6\x48\x79\x01\xd3\xb8\x57\xc0\x74\xf6\x08\xd4\x8f\x04\x4a\xe3\xd2\x3e\x03\xa5\x27\x9d\x35\x50\x9a\xda\x49\xdf\x02\xbd\xe1\x2d\xfe\x41\x04\xf2\x70\xf2\x62\x1a\xaa\xb5\x56\xd8\x2a\x1c\x10\x8e\x0a\x5c\xbb\x30\x43\x60\x38\xa1\x58\x68\x10\x46\x08\xdc\x92\x2e\xf8\xfe\x41\xf8\xfe\xa4\xf0\xb5\xa0\xab\x13\x92\xe4\x37\x17\xfc\xca\x16\x0b\x57\xc0\x0f\x07\xe0\x07\xde\x26\x60\x4e\xc0\x1d\x6a\x1b\x7f\x26\x77\x86\x05\x72\x2f\x6c\x1e\x8c\x04\x3c\x5c\x38\x92\x4e\xee\x1f\x3a\xac\x15\xde\x57\x27\x0d\x03\x86\xb4\x92\x7b\x18\xe5\xaa\x3e\xd1\x4a\x9e\x53\xaf\xaa\x6a\x5b\x49\xcf\xea\x55\x69\x79\xeb\x08\xa1\x83\x5e\x3d\x9b\x8c\x85\x4b\x5a\x49\xb3\x0c\x83\x04\x9b\xc0\xcc\x10\x16\x09\x9b\x85\x67\x85\x13\xc2\x97\x82\xae\x96\xf4\x03\x5f\xea\xb3\x46\x5f\x4c\x8e\x54\x2c\xee\x5c\x5c\xb9\xb8\x72\x09\xfd\x5b\xa9\x9d\x42\x55\x8f\x5b\xd8\x1d\xea\x01\x31\x62\x2c\x7d\xab\xe5\xc9\xdf\x10\x03\x68\x71\x89\xfc\x3e\xcc\xcf\xeb\x20\x87\xbe\x9e\xbe\x19\xf1\x48\x52\xce\x00\x42\xbb\x24\x70\x40\x0b\x62\xe4\x25\x36\x9a\x70\xe2\xd7\xe1\xa9\xa5\x11\xf9\x4f\x25\x38\xac\xcc\xeb\x31\x78\xee\x15\x6a\x27\x25\x7a\x9d\x8e\x9c\x02\x54\x8d\xa5\x99\x18\x38\x9c\x67\x31\xc5\x83\xfa\x36\x99\x92\x7c\x53\xe9\xcf\xd9\x66\xf6\x45\x90\x6d\xca\x92\x2e\x07\x6f\x26\x81\x75\x3e\xb7\x38\x21\xe5\xb6\x31\x86\x09\x99\x32\xe0\x79\xe7\x9d\x72\x8b\x96\x2a\x3e\x04\x52\xf6\x23\xcc\x36\x6b\x65\x4a\x1f\x79\xe0\x81\x47\x46\x6c\xac\xaa\x79\x74\x2a\xfe\x0d\x7e\x5b\x76\xd2\xca\xa4\x07\x4f\x9c\x38\xe8\xb4\x0e\x8e\x56\xd0\xb8\xb4\x24\xf4\x9b\x64\x8f\xda\x4a\xd9\x07\xfe\x89\xec\x02\x73\x0f\x7a\xa7\x5b\x87\x9c\x49\x13\x5e\xe8\xc3\x6d\x3e\x8c\x7c\xd8\x87\xec\x30\x81\x24\xc4\x40\xad\xeb\x37\x9e\x7d\x11\xee\x4f\x88\xca\xfd\xf8\x47\xef\x9f\x2b\xbf\x80\xb7\xb3\xcf\xd9\x74\x28\xd8\x03\x17\xf5\xff\xbf\xc1\xc5\xda\xff\x04\x17\x45\x66\x21\x73\x9c\x79\x8f\xe1\x18\x05\x27\x8f\x4d\xfb\xbf\x81\x93\x2c\x8a\x73\x9d\xcc\xd2\x8c\x0f\xa0\x39\x19\xe2\x30\xf6\xea\xcc\x66\x87\xd7\x1b\x0c\x89\x01\x29\xb0\x39\x25\x32\xcf\x40\x8f\xac\x1e\x08\xb0\x41\x52\x44\xd0\x78\xed\x31\xc5\xee\x99\x09\xa1\x54\xb3\x61\xfc\xa8\x8f\x00\x1b\xfe\x4b\x27\x01\xac\x2b\xb0\x7b\xfe\x08\x3f\xda\x51\x8a\x8a\x11\xb2\xeb\xd8\xa6\x3b\x1f\x42\x05\x07\x18\x89\x65\xdc\x30\x65\x8f\x1b\xcc\xad\x47\xe4\x1f\x0e\xb8\xdd\x3c\x5f\x52\x59\x99\x40\xcd\x09\x58\xfb\x75\x4c\x35\x5e\xce\x86\x88\xfd\x31\x69\x24\x4a\xaa\xd9\xc0\xde\x73\xa1\x01\xd5\xf6\x7d\x5e\x70\xf9\xc8\x78\x7c\x64\x4b\x43\x43\x0b\xb3\x3b\x3e\x72\x64\xbc\x5f\x6b\x6b\x3a\x9d\x3e\x02\xfd\xc6\xf8\xa1\xb6\x18\x2a\x43\x7b\xa0\x67\x81\x6d\x92\x3f\x48\xdf\x8d\x86\x1d\xc6\x41\x16\x2f\x0a\xe1\x10\xe9\x5e\x0f\xdd\xa7\x63\xc9\x82\x50\x88\x61\x4a\xd0\x17\x08\x6f\x46\x78\x13\xc2\xab\x10\xee\x44\xa0\x92\x60\x82\x89\x76\xf5\x0c\x56\xa2\xb2\x72\x1a\x05\x90\xe0\x2b\x69\x5f\x97\xa0\xed\x57\xe6\xb5\x7f\x5e\x5f\xed\x57\x2a\xed\x43\x83\xcd\xf4\x5f\x2d\xc2\x5f\xd0\x7f\xef\x9d\xbd\x3b\x7a\xe6\xab\x57\x9f\x2c\x43\xfb\xac\x42\x3b\x72\xfa\x1c\x7e\x18\x5b\x59\x3c\xc3\x86\x6d\xb4\x4f\x0b\xf4\x59\x94\x74\xdb\x6c\x30\xa7\xe8\x7d\xda\xc9\x71\xad\x1f\xe2\x2f\xde\xaf\xd7\xb7\x22\x7b\x65\x8f\x41\x41\xfb\x47\x95\x3c\xeb\xb0\x56\xf5\x6a\xeb\x7f\x83\xd6\x4b\x92\x76\xc6\xc7\x32\x5f\xfa\xf0\x6a\x1f\x5e\xe4\xc3\x33\x60\xe7\xd2\x56\x4c\xad\x3e\xa5\x15\xda\x00\x3c\xff\x2b\x98\x93\x49\x14\xbe\xc1\xe8\x59\xb5\x85\x4f\xa0\x85\x91\x49\x2b\xf6\xb2\x78\xb3\x17\x2f\xf2\xe2\x19\x5e\xec\xa5\x60\x9a\x00\xcc\x4f\x92\x3e\xaf\xd7\x60\x28\x41\xbf\xa0\x00\x2a\xb3\xd0\x9c\x37\x11\x04\xc2\x69\x39\x30\xc2\xba\xde\xc4\x8f\xb3\x95\xea\x2b\x3f\xcb\xc2\x58\x7e\x18\x57\xb1\xf8\xb1\x0a\x5c\x41\x20\x13\xed\xad\x15\xb4\x0b\x23\x74\x91\x3a\x50\x51\xe1\x70\x00\x72\x55\x66\xe0\xfc\x57\xfa\x73\x66\x20\xff\x6b\x47\x29\xa9\x3d\x0e\x38\x39\x10\x1a\xb5\x3f\xce\x32\xf8\x48\xfa\xab\x03\xe5\x1e\x2b\xa0\x62\x22\xa1\xd2\x25\x05\x7f\x5b\x1d\x3a\x82\xbf\x70\x3d\x28\xfd\x03\xf7\x4f\x7e\x08\x5c\x97\x50\x3a\x35\x08\xd4\xd1\xe9\xa0\xcf\x8a\x68\x68\x32\x62\x65\x0d\x7a\x56\x6f\xb3\xeb\x2c\x33\x52\xc8\x80\xf5\xbc\x41\xa7\xe3\x3a\x53\x84\xe2\x23\x6b\x67\x0a\x14\x9d\x9c\xec\x56\x9d\xda\x31\xfd\x9c\x0a\x07\x20\x3d\x80\x0c\x41\xca\xb1\x79\x98\x65\xdd\x47\xf7\xee\xe5\xec\x8e\x61\x43\xbb\xde\x90\x8f\x27\xfc\xdc\x7d\x81\x84\xbc\x0a\x7b\x5c\xa7\x2f\xf5\x2b\xe7\x45\xc6\x43\xdf\x7f\xe0\x5b\x61\xef\xeb\x51\x53\x32\x20\x70\x24\x7d\xb7\x9e\x67\x78\x83\x51\xc7\xb1\x1c\x03\xb4\x53\xc0\xc2\x84\x14\x56\xfb\x25\x79\x78\x9b\xe3\x79\xc9\x83\xeb\x49\xc7\x31\x1c\x37\x30\x11\xee\x0f\xa7\x97\x61\xfc\xce\xd3\xf8\x8b\xee\x1b\xe4\x45\x6c\x69\x3b\xf7\xdd\x69\x3d\x37\xf5\xf4\x73\xca\xb8\xa1\xaf\x95\x74\xdc\x65\xf4\xfa\x22\xb8\xbe\x9c\x5e\x0f\xd1\x7e\xe7\x6f\xa1\xd7\x95\xa8\x77\xce\xfe\xae\xe4\x20\x5f\x18\xe9\x90\x9a\xb4\x1f\x15\xe3\xe6\xba\xe2\xf6\x62\xc6\x63\x28\xc0\xb5\x05\x9d\x05\xcc\x90\x02\xcc\xa2\x02\x5b\x41\xb8\x80\xd5\xf3\x05\x05\x2e\xab\x8b\xed\x4c\xb9\x9c\x56\x43\x67\xca\xca\xe5\x65\xf3\x86\x69\xeb\x9c\xb6\x78\x49\x1c\x2f\xce\xc9\x3f\x4e\x6d\x3b\x67\x4b\xed\x2f\x44\xed\x71\x4f\x84\xd6\x79\x3d\x6b\x6a\x7f\x7c\x2a\x94\x4c\x86\xf0\x5c\xf2\xfa\x6f\x92\xfb\xfb\x36\xe2\xed\xeb\xd7\xcb\x5d\x1b\xe9\xb8\xc7\xc0\x42\x5c\x44\xc7\x5d\x95\x99\x87\xc7\xe9\x35\x8d\x0f\xd2\xf0\x07\xe4\xc7\x51\xc9\x62\x41\x67\xb5\x02\xe7\xb7\xe8\x79\xbd\x68\x1b\x69\xc5\x16\xf8\xc7\x5a\x05\x1d\xa7\x24\x5c\xef\x4c\x99\x18\x47\x6e\xc2\x75\x82\x23\xd9\xa3\xc3\x6a\x4e\x8c\x92\x6c\xfd\x21\xf2\x8e\x7d\x07\xe4\x51\x5b\xf0\x89\xa7\xf1\x1f\xf7\x74\xff\xe6\x80\x7c\x65\x3b\xc9\x89\x4c\xd6\x8e\xbe\x4f\x53\x60\xd2\x7d\x40\x61\xaa\xcb\xc0\x78\x27\xbd\xee\x47\xd7\x6a\x01\xac\xe5\x21\x9a\x13\xcf\x0b\x58\xde\x95\x1c\x52\x14\xb0\xbb\x38\x01\xfe\x96\x94\xfa\x0c\x41\x5c\x4b\xfe\x75\x06\x99\xe6\x20\xb6\x04\xb1\x3e\x18\xd4\x6d\xf6\xee\xf0\x32\xc8\x6b\xf3\x9e\xf0\xb2\x0e\xd6\x9b\x74\xd9\x1d\xac\xce\x3c\x33\x25\x70\x3a\x32\x00\x25\x71\x65\xdc\x4f\x0c\x2b\x8b\x41\x87\x87\x51\x00\x2f\xcb\xa6\x05\x86\x41\x84\x69\x36\x64\x36\xee\x01\xb1\xc4\x49\x6c\x0a\x4e\xc0\x7c\xd0\x23\x73\x57\x8b\xf9\x1f\xcc\xb4\x37\x0d\x77\x9e\x7e\xd7\x39\xbc\x29\xfa\xd6\xe5\xdc\x1f\xe6\x35\x0c\x77\xb1\xbf\x72\x0d\x6f\x58\x74\x52\xfe\x17\x5d\xb1\x1d\xe4\x75\x8f\xed\x29\xf9\x66\xbc\xf4\x29\xc1\xc0\x7e\x65\xbd\x17\x8f\x95\x0f\xde\x6b\xed\x7e\x21\x6f\x9d\x54\x7c\x84\x31\xd7\x6b\xfb\x96\xe0\x2b\xe8\x9f\xf3\x92\x3e\x3b\x63\x35\x30\x06\x97\xb4\x55\x7a\x50\x3a\x20\x7d\x2d\x71\x27\xa5\x3f\xc3\x1b\x2b\x11\xae\x5e\x3e\x70\x48\xeb\x66\x09\x33\x48\x0a\x4b\xed\xd2\x6a\x89\x23\xe5\x50\x79\x40\x4f\xde\x36\x23\xc5\xb3\x76\x78\x14\x31\x9d\xa4\xe6\x3e\xc9\xdf\xa9\x65\x67\x27\x1f\x30\xc5\xd5\xca\x69\x8b\x35\x3c\xcd\xa4\x76\xcc\x4b\x8f\x3f\x68\xef\x5e\xbe\x7d\x2f\x49\x71\xdd\x7d\xd3\x5e\x58\xb2\xfb\xfc\x89\x84\xff\xf4\x45\x74\xf9\x6e\x3b\x3d\x3f\x90\xd0\xf6\x5f\x84\xae\x99\x92\x27\xac\x1d\xae\x87\x01\xfc\x12\xa9\x45\xc4\x60\xb3\xd9\x62\x63\x8d\x7a\xa3\xde\xed\x11\x3d\xd8\xc4\x5a\x24\xab\x04\x34\x08\x9b\x01\x3e\xd6\x64\x64\x8c\xcc\xcc\x94\xde\xa8\x20\x17\xd9\x46\xcd\x71\x25\x93\x7c\x26\x8b\xbf\x56\x82\x01\x93\x9c\x93\xc5\x4a\xba\x76\x03\x28\x15\x34\xb1\x6a\x84\xd9\x2d\xcf\xc7\xfc\xa5\xb8\x24\x02\xcb\x71\xa6\x08\x1f\x92\x27\xb2\x77\x0d\xaf\x58\xf4\x6b\xf9\x5b\xe6\xf3\x78\xf7\x3f\x0c\x02\x2c\xc0\x18\x66\x30\x73\x69\x9b\xfc\xcc\xdb\x56\x80\x97\xd4\x20\x78\x8e\xc2\xdb\x48\xe7\xdf\x03\xf3\x7d\x1b\xbd\x1e\x4c\x71\x6e\x28\x5c\xdf\x03\xf0\x87\x80\x9e\xf4\x43\x0f\x24\x2f\x29\x73\x23\xb1\x1a\xb1\x3c\x6f\x8a\xfa\xcb\x4d\x7e\x53\xbc\x3e\x19\x5f\x1d\xdf\x1c\x67\x59\xc9\x26\xda\x42\xb6\x5a\x1b\xab\xe7\x1c\xb6\xce\x54\x59\x95\x50\xd5\x99\x0a\x09\xb1\x5a\x6b\x6d\x67\xca\x6d\x15\x92\x06\x0b\xec\x2f\x9b\x75\xb3\x75\x87\xf5\x31\x2b\x5f\x67\x4d\x5a\xdb\xad\x2c\x2b\x58\x05\x2b\xe3\x20\x36\x4c\x84\xf5\x1c\xd9\x5d\x64\x73\x55\x22\x32\x62\x2d\xa7\x3a\x50\x92\xca\xdc\xbc\xea\xea\xaf\xb8\x33\x43\x5a\x60\xd3\x79\xe2\x39\xfb\x2e\x11\x2d\x22\xc7\x3f\x8b\x07\xe1\x84\x9a\x2f\xac\x9e\x93\x5c\x24\xe1\x59\xa3\x56\x49\x13\xbb\xdc\x83\xb0\x1d\xc4\x6c\x76\xd4\xde\xee\x7f\xee\x5d\x7c\xeb\x9b\x2b\x30\xf3\x97\xd9\x7b\x19\xeb\xde\x4b\xff\x82\x99\xe5\x6f\xde\xb6\xe4\x9c\x1d\x7b\xf6\xec\x1e\xd2\xfd\xf4\x9e\x1d\xc3\x07\xef\xde\x43\x77\xec\xc6\xb9\xa7\x6e\x7d\xf3\xd3\x95\x64\xed\x57\x7e\xfa\xe6\x96\x53\x97\x8d\x7f\xe9\x99\x23\x4f\x74\xeb\xf1\x0d\xcf\xbc\xc4\x7c\xf7\x04\x99\xc3\x6a\x98\xb3\x5d\x74\x0e\x07\x51\x1c\xd0\xc1\xf5\x87\x30\x87\x51\x34\x35\x59\xe3\x05\x1e\xc6\xf3\x61\xab\x21\x10\x36\x84\x8b\x4b\xa2\x3a\xbb\xae\x33\xe5\xb5\xdb\x91\x39\xe4\x71\x18\xcd\xc6\xce\x54\x81\xcb\xcc\x2a\x64\x86\xc9\x30\x22\xad\x6a\xbe\x5a\x39\x34\x37\x81\x64\xc6\x6a\xaf\x0c\xdc\x1e\x2e\xa6\x15\x69\xed\xa4\x08\xb3\x82\xc2\x43\x71\xc2\x4e\xd3\xbb\xe9\x22\xec\xf8\x43\xdd\xef\x1e\x92\x3f\x4b\xa3\x15\x78\xe0\x83\x07\x0e\x31\x45\x87\x0e\x3e\x84\x07\xae\x48\xcb\x1f\xd3\xd1\xe1\x3d\x2f\x7e\x84\xc7\xfa\x13\xf2\xcc\x47\x7e\x86\x99\x87\xc8\x28\xbb\x2f\xc4\x0f\xef\xc5\xf7\x27\xfc\xf2\xc1\x0f\x5f\xa2\xe3\x99\x0b\xe3\xb9\x11\x78\x46\x39\xfa\x79\xf2\x12\xd1\xaa\x13\x8a\x0b\x02\x51\x01\x74\x6a\xd6\xe0\x88\x45\xbc\x0e\x6f\x45\x65\xb4\x60\x66\x2a\xea\x40\x84\x77\x98\xb9\x40\x71\x67\x2a\x20\x22\x5d\xbb\x0e\x2e\x44\x18\xee\x26\x11\x5f\x25\xe2\xd1\x22\x16\xc5\x90\xc8\x18\x45\x11\x09\x3e\x84\x59\x11\x61\x9b\x4e\x82\x71\x4b\x5c\xc4\x00\x7c\xd9\xce\x83\x1a\x6f\x05\x6a\xa5\x4e\x83\x8a\x11\x74\xf1\xe9\xca\x7b\x6b\xa9\x04\x4e\xbf\xb0\x79\x8f\xd2\xf7\x9c\x6a\x02\x76\x3a\x5f\x6a\x02\x42\x45\x7b\xa3\xc7\xa8\x9d\x84\x9e\xc1\xda\xc7\x4a\x99\x04\x65\x3d\x76\x17\x12\xb1\x5a\xfc\xc0\x49\x4b\xd8\x31\xdf\x7f\xf8\xa7\x23\x3f\x0b\x74\xbf\x04\x14\xad\xfd\xd5\x56\xe3\x5b\x69\x3c\x0e\xf8\xcc\x39\x78\x5c\x1a\xbd\x69\x6c\x7d\x95\x90\xbb\xee\x97\x02\x7b\x0e\xff\x89\x3b\xf3\xd1\x77\x2f\xfd\x5d\x92\x7f\x86\xc7\x6c\xb6\x5d\x12\xc1\xc1\xd7\xb1\x8d\x72\xa3\x2f\x5f\x97\x3f\x8c\x5c\x62\xdb\x2c\x1f\xc2\xe7\x4b\x7f\x7f\xe9\xfb\x0f\xe9\xfe\x6a\x06\x3e\x34\x57\x77\x35\xc8\x6e\x55\x44\xf2\x22\x73\x89\xe7\x23\xdf\x21\x06\x8b\x7c\x29\x91\x6c\xd2\x07\x82\x66\x16\x97\x60\x10\x6d\x10\xf9\xaf\xed\x49\xfa\xcc\x60\xe5\x19\xbc\x09\x9e\xf1\x24\x2d\x0c\xf6\x92\x87\x7c\x31\xc9\xe0\xc8\x3e\xa1\xe9\x75\x1c\xcb\x3f\x08\xb2\xd3\xc5\x8a\x84\x87\x88\xf1\x40\x4c\x1a\x99\xb6\x32\xec\x29\xab\x34\x4b\x25\x95\x9a\x4e\xd7\x06\x3a\x60\x84\xde\x3b\x5b\xbd\x97\xe4\x04\x36\x1e\xc2\x73\x6a\xfa\xf1\x08\x84\x2c\xb8\x27\x2c\x8f\x63\x8f\xd2\x7b\xe6\xa8\xf7\x7c\xad\xdc\x93\xf2\x17\x22\x93\x72\x4f\x35\xc8\x6b\x41\x7a\x8f\x22\xaf\x35\xfd\x95\xde\x61\xb3\xdb\x2d\x16\xb8\x83\xf6\x45\xea\x0d\x3e\x44\x65\xba\x65\xb4\x9d\x81\x44\x42\x06\xb8\x0c\x20\xd6\xb9\xea\x82\xbc\xa4\xc9\x74\x44\x6e\x22\x63\x00\x1d\x3a\x80\x62\x84\x7a\x46\xcc\x9c\xb3\xa0\xc0\xc7\x04\x02\x2e\x49\xf2\x99\xd9\xb2\x72\xbe\xc0\xe7\xe0\x18\x17\x60\x11\x29\x53\x6b\x28\x9e\x90\x32\xb8\x03\x8c\x52\x0c\x5f\xcd\x49\x4c\xe8\x65\x4e\x11\x37\x87\x52\xeb\xa2\x44\x8a\x96\xc6\xa2\x56\x86\x2a\x27\x0e\x12\xa2\x47\xd2\x09\x5a\xb1\xe0\xf6\xb0\xc4\xb3\x4a\xad\x4f\x43\x31\x87\x4e\x96\x14\xea\x5a\xa7\x2e\x1a\xbd\xed\x81\x63\x4f\xac\xde\x56\xab\x1b\x79\xaf\x67\xe8\x05\x4d\xe7\x9c\xf1\x2f\xe9\xfa\x60\xfa\xf8\xc1\x9d\x6d\xd5\xd5\x4b\xb7\xdf\x34\xa7\xe1\xdb\x8f\xfe\x89\xc5\xd5\x5b\x7f\x28\x2b\xde\xf8\xc5\xb7\xfb\xf0\x6d\x1f\xbe\x20\xb7\x1d\x79\x66\xdc\x7a\x3a\x8e\xb5\x30\x77\x4f\xf2\xbb\x40\xc6\x28\x45\x93\x92\x15\xa6\xa8\xa4\x8f\xea\x71\x58\x2c\x20\x47\xfc\xc4\x58\x99\xa9\x38\x5a\x1c\x6d\x4f\x15\x17\xf3\x41\x47\xb0\x3d\xe5\x70\xf3\xde\xf6\x14\x8f\xf3\x4a\x89\xf5\xa8\xc4\x93\x19\x8b\x72\x28\x38\x13\x04\xa1\xd5\x10\x2a\x8a\x61\xc5\x7c\x6d\x57\x4a\x4b\xc5\x12\x43\x31\xae\xd8\xfd\x9b\xd7\x7e\xf6\xeb\xeb\xe7\x6d\xdd\xf4\xca\x53\x9b\x57\xe0\x83\x17\xcd\xfc\xc9\xa2\xa5\x37\xfe\x79\xdb\x3d\xeb\x56\xca\xe3\xf8\x99\xa7\x7f\x38\xb8\xeb\xfa\x03\x1e\x63\xe8\xb1\xbb\x8f\xfe\x21\xc1\xc5\x56\xdf\xfc\xca\xbb\x67\x9e\x2b\xc5\xc3\x76\x6e\xd7\x8d\xe7\x36\x2b\xb6\xbc\x6e\x18\xcb\x05\xec\x5e\x14\x46\x55\x49\x37\x13\x36\xda\xc3\xf6\x22\xb1\x28\x54\xc4\x14\xb8\xf8\x88\x37\x10\xb6\x62\x91\xe6\x37\x20\x1b\x0e\x4f\xcb\xf0\x53\x36\x11\x77\x3b\x3c\x71\x65\x73\xc5\xe0\x42\x72\x09\xac\xdb\x21\x09\xb1\x86\xfe\x8d\x4c\x0d\x8e\xb1\xa7\x06\xdf\x35\x48\xbf\xc7\x1b\xad\xf1\x3e\x67\x3a\xff\x3b\x8b\xed\xfe\x1a\xc9\xfe\x93\x29\xed\x51\x76\x55\xf5\x3a\xf9\xbc\x57\xf1\x9d\xfd\xaf\x2d\x29\xaf\x13\xaa\xed\x83\xa6\x3e\xd3\x7d\xac\x4d\xfe\xe0\x5c\x53\x61\xea\x9d\x14\x5e\xf9\xb7\x5f\xb7\xc0\x1c\x9f\x0b\x78\x75\x15\x7f\x07\x0a\x82\x5c\x3b\x21\x59\x6d\x41\xa8\x3a\x54\x5e\x60\x63\x7d\x25\x3a\xa7\xcf\x59\x55\x2d\x56\xb7\x55\xff\xa2\xfa\x99\x6a\xce\xc0\x96\x5b\xdc\xac\xbb\xa8\x3d\xe5\x76\xb3\xc6\xf6\x94\x2e\xa7\xb6\x2d\xc9\x5e\x9d\xad\x97\x43\x42\x58\xea\xed\x8a\x4a\xdf\x3b\x13\x83\xa4\xa9\xb6\x8d\x35\x98\xd5\xbc\x91\xa4\x08\xd2\xe9\x3d\x9b\x66\xde\x5e\x5b\x91\x98\x35\xe1\xbc\xf3\x6e\xdd\x78\xf9\x6b\xcf\x1d\x7d\xe3\xe9\x7d\xf3\x3b\x98\x6b\x96\xcc\x5f\x3a\xf9\x62\xdf\xcd\x57\x72\x0f\x2e\x5a\xa3\x24\xaa\x6e\xbc\x7c\xe9\x95\x6f\xac\x7b\xe7\xfb\x3f\xbc\x72\xe4\xeb\x9a\x19\x9b\xba\x6b\x77\xec\xdd\x7f\x64\xe9\xbe\x0e\x57\xdd\x1b\x84\xce\xd2\x7d\xc9\xbe\x00\xfc\xe4\xe2\x64\xff\x98\xcf\x54\x60\xb0\x47\x0c\x26\x8e\x07\x45\xa2\xa6\xd6\x10\x82\x59\x9f\x90\x0a\x85\x2a\xac\x56\x77\x7b\x2a\xe6\xc0\x7e\x07\x90\x50\x07\x36\xf3\x0e\xab\xad\xba\x82\xa9\x50\xad\x4c\x0a\xff\xa0\x24\x73\x5a\x6f\x4c\xd2\x52\x94\xd3\x6a\x18\x6a\xed\x26\xd5\xe7\x2a\x90\x84\xc9\xea\x78\x69\x79\xf3\x28\xc9\xee\xae\xfa\x5f\xd9\xc8\x4d\xc7\x0f\x3f\xbf\x7c\xf6\x91\x13\xfb\x36\xae\xc2\x75\x4d\x81\x99\x35\x5d\xf3\xcf\x19\x50\x76\xbf\x3f\x1c\x1e\xf1\x8b\x96\xd6\x75\xcb\x5a\x6e\x98\x3a\xf2\x82\x3b\x6e\xbe\x70\xa5\x24\x0c\xb9\x63\xd1\xea\xe2\xa3\x8b\x6d\xbe\x54\xfb\x88\x69\x36\x4e\x98\x61\x71\x5d\x32\xf2\x82\x4b\x5d\x21\xc5\xee\x96\x92\xb7\xb1\x45\xfc\x7d\x80\x53\x17\x26\xe3\x7e\x87\xc5\xe6\x76\x0b\x1c\x39\xf1\x58\x64\x07\x14\x71\x3a\x26\xa6\x9c\xa2\x10\x12\x6a\x05\xc2\x21\xf4\x9c\xdf\x82\x40\x85\x92\x30\x4b\x6a\x5e\xb2\x38\x93\x3e\x88\xec\x75\x22\x88\xbf\x98\x97\x86\x3c\x9b\x8f\xd8\x45\xed\x69\x5a\x6a\x0d\x84\x13\x7c\xa2\xb8\x51\x32\x32\x92\x2b\x48\x0a\xab\xb2\x45\x6b\xef\x6b\x6f\xbd\x74\xd6\xf3\x3f\xc7\x46\x5c\x2b\x0b\x78\xe7\xef\xdf\x3d\xd2\x59\x7f\xf1\xb5\x57\xaf\x9c\x38\x73\x4d\xc3\xb0\xd0\xb9\xfd\x07\x0e\x74\xc5\x1e\xd9\xf5\x14\x7e\x15\x37\x73\xe3\x97\x04\x42\x23\xe4\x7f\xc9\xef\xc8\x9f\x6f\x69\xed\x1c\x12\x2a\xbc\x98\x8e\x85\xd2\x49\x58\x33\x1f\xa9\xd7\xc9\xb8\xdd\x1e\x8b\x28\x9a\xf5\x1e\xbd\x3f\xe0\x96\xcc\x01\x89\x61\x38\xce\x39\x31\xc5\xd9\x68\x45\x7e\x31\x3f\x3b\x74\x73\x6e\x06\x65\xe5\xbc\x8e\x47\xcd\x99\xec\x00\xe4\x2b\xf5\xd1\x3d\x2d\xd8\xa3\xf6\x58\x18\x87\x0d\xbf\x5b\x7d\xed\xf5\x3e\xfb\x2f\x22\x13\xa7\xcd\xb8\x7b\xf7\xf5\xec\xde\xce\xab\x36\xae\xeb\xde\xb6\x5a\xfe\x2c\x51\x7d\x00\x0f\x64\xba\xa6\x5c\x70\xce\x99\xaf\xd8\xff\x8b\xb5\xf7\x80\x8f\xa2\x4c\x1f\xc7\xe7\x9d\x77\x66\x7b\x99\xd9\xd9\xde\x4b\x36\x9b\x64\xb3\x69\x9b\x42\x42\x20\x9b\x84\x12\x21\x98\x84\x22\x19\x5a\x42\xa4\x08\x22\x5d\x10\x14\x41\xc5\x82\x62\x43\xb1\x9f\xa2\x87\xed\x8c\x1d\x15\x14\xdb\x89\x28\x22\x22\x1e\x7a\x96\xb3\x9d\xf5\x14\xbb\xe7\x59\xb2\xc3\xff\x7d\xdf\x99\xdd\xec\x06\xf4\xee\xff\xfd\xfc\xce\x4b\x76\x37\x59\x36\xef\xf3\xbc\x4f\xaf\xf3\x5c\xc4\x8e\xeb\x45\xb4\x74\x36\x7b\x1d\xf2\xf3\x04\xca\x8d\x7c\x9c\x28\xe7\x74\xaa\x78\x87\x03\x19\x27\x1e\xaf\xd9\x8b\xfc\x1b\x0e\x9d\x88\xe3\xac\x5a\x2d\xde\x9c\x85\x48\x3a\x67\xbe\xbb\x42\x35\xc7\xae\x92\x02\xc4\x89\xe3\x89\x43\x07\x70\xfd\x5d\x48\x07\x60\x95\x45\x08\xb9\x01\x3c\xfb\xe5\x57\xf6\x3c\xf3\xdc\xbe\x97\x5e\x94\xe6\xb5\x8b\xc8\xf4\x7d\x94\x5d\x74\xfa\x8a\xd3\x58\x69\x3c\x3d\x9b\xde\x2b\x5d\x2a\x5d\x0f\x16\x80\x65\x60\x29\xe8\x93\xae\x04\x81\x15\x5f\x0e\x80\x13\x00\xff\xeb\x0f\x40\x00\x6d\xd2\x9d\x12\xd9\x8d\x4f\xf4\x09\x92\x35\x1c\x55\x9b\xf2\xb3\x78\xdc\xb0\xe5\x1b\x0b\xa0\x2c\x15\x16\x5a\x07\xcd\x46\x24\xf3\xcd\x2c\xd4\x42\x2c\xf5\xb3\x0e\x3b\x90\x5d\x31\xc5\x05\xcb\xcd\x47\x92\x9d\x46\xdd\xe5\x85\x65\xad\x91\xc5\xc9\x29\x93\xce\x07\xf1\x37\x9a\x9b\xb9\x66\x97\x7f\xf9\x7c\xfa\x56\x57\x02\xfd\xbd\x18\x42\xd4\x11\xf4\xf7\x78\xaa\x3b\x55\xae\x63\x01\xc3\x32\xc8\x15\x36\x18\xb5\x2a\xa3\xca\x22\x50\x42\x50\xa0\x8d\x90\x41\x16\x6c\xa7\xa8\xa7\x74\x2c\xa3\x05\x9c\xd9\xa0\xd5\xaa\x06\x97\x2a\x0d\xae\x7e\xca\xc7\x55\x56\x0e\x6a\xf1\x2e\x77\xb2\xfd\x09\x90\x7b\x44\x47\x1a\x05\x1e\xda\x75\xba\xf4\x33\x98\x3c\xef\x28\x25\xfd\x63\xe3\x1d\xab\x81\x0f\x3c\x0f\x3e\x4b\x38\xa4\x2f\xd2\xdf\x3b\x12\xe0\xed\xc5\xd2\xd5\x70\x7e\x66\x76\x77\x2d\x3a\xe3\x1b\x48\x97\x38\xa9\x51\xa9\xa8\x41\xa0\x19\xa7\xc0\x08\x2e\xb7\xd9\xdd\xe1\x26\x8d\xc1\x2c\xa4\xf5\x66\xb3\x06\xef\x96\x76\x9e\x60\x07\x76\xa2\x0d\x67\x26\xe5\xb8\x82\xa3\x3e\xf7\x58\x44\x75\xa8\x40\xa4\x86\x6c\xa9\xc8\x8c\x2c\x75\x00\xc4\x0d\xb6\x08\x1d\x0d\x4b\x1f\xde\x07\xee\x4b\xb4\xcd\xf3\xfa\x8a\x2a\x47\x77\xcc\x5c\x39\x0c\x9c\xc8\xb5\x84\xf7\xd0\x03\xb3\xd2\x7d\x21\xb8\xeb\xe2\x0f\x0c\x93\xfe\x22\xac\xbd\x6b\x40\xa8\x28\xd5\x25\xf0\xd9\xee\x90\xc6\xc1\x9f\xc8\x0e\x3d\x44\xfb\x26\x9d\x4e\xcf\x5a\x2c\x40\x0f\xac\x36\x9d\xc7\xc2\xb2\x6a\x35\x37\x51\x54\xdb\x19\x80\xd7\x0e\x19\x30\xed\x57\xe5\x51\x7f\x8e\x66\x1b\x5c\xe6\x8c\x35\x19\x19\xe5\x41\x12\x87\x70\x3d\xde\xde\x7c\xc3\xb2\x8e\xda\x3b\xee\xb8\x63\xe1\xd9\xb0\x7f\xe0\x06\x57\xe2\xa4\x85\xe5\x52\x39\xdb\x97\xee\xed\x4f\xc0\x00\xc1\x11\x8b\x68\x7d\x31\x39\xc7\xb8\x54\xd8\x6c\xa0\xd4\x06\xb5\xd5\x66\xb6\x21\x27\xcb\x6c\x32\x21\xea\x36\x99\xab\xb9\x51\x1c\x3d\x8a\x03\x9c\x4e\x6f\x87\x3b\x8f\x7e\xf0\x88\x96\x6b\x83\x0c\x59\xa2\x86\x94\xd7\xcc\x65\x4d\x43\xaf\x90\xcc\xff\x53\xf4\x16\x88\xe0\xb4\x11\x40\xba\x8c\xfe\xa8\xd2\xb7\x57\x18\x2e\x3d\x35\x56\xba\x6d\xec\xbf\x80\xf5\xa6\x70\x04\xba\x4b\x2b\xb4\x89\x50\x59\xe7\x59\xe9\xe9\x70\xad\x2b\x91\x0e\x82\x69\xed\xe7\xca\x77\x37\x0d\xc9\xb9\x93\x91\x8e\xaa\xa6\xb6\xa5\x0a\x54\x54\xb8\x2a\x1c\x85\xb1\x72\x27\xb4\x45\x8b\xcb\x59\xbf\x93\xd7\xfa\x79\x7f\x4d\x6d\xac\xbc\xac\xb8\xa4\xb8\x4b\x2c\x29\xd3\xee\x3c\xfa\x6d\xaa\xce\xe1\x6b\xeb\xd5\x82\x89\x5a\x60\xe6\x81\xc6\xe8\xf4\x39\x69\x2f\xe3\xe4\x1c\x9e\x36\x27\xef\xd7\x56\x45\x55\x65\xd6\x10\x64\x20\xd3\x25\x22\x0f\xac\x8c\xb2\xda\x90\x50\xb4\x02\x8d\x35\x2b\x14\xeb\x33\xe2\x1e\x11\x26\x82\x08\x5b\xcc\x71\x79\xcb\xda\xa0\x90\xe4\x33\x33\x97\x2c\xf5\xf2\x6a\x03\x40\x76\xfa\x11\x71\xef\xa7\x65\x6d\x97\x2b\x3c\x95\x05\x7f\x51\x24\x42\x87\x83\x02\xcc\x61\x78\x39\x69\xdb\xc9\xd5\xc1\xe0\xd6\x9b\x6f\xac\x14\xcf\x9e\x70\xd6\x39\x58\x9a\xce\x5c\xf6\xdd\x33\xfb\xf6\x9e\x7e\x1d\xb8\x4e\x72\x4e\x5e\x08\xc6\x9c\xbd\xe7\xa5\x95\x30\xac\x5f\x68\x4c\xde\xb2\xa6\x65\x52\x6d\x98\xf7\xcc\xeb\x56\x64\x6b\x4d\x93\xb5\xf4\xb6\xad\xeb\xf6\x35\xeb\x43\xd7\xcd\x7c\x77\x06\x74\xcf\xa6\x55\x27\x45\x6f\x5d\x39\x75\x7d\x36\x4f\xf1\x10\x7c\x1e\xf9\x54\x13\x09\x2e\xbd\xe8\x35\xde\x37\xec\xa7\x5a\x53\x51\x4a\xe7\xe7\x1d\xbc\xce\xc8\x04\x82\x0e\x9b\xc7\xd6\x25\x7a\xec\x7e\x3d\x6f\xe6\x3b\xc5\x94\xb1\xd3\x48\x1b\x91\x0c\x86\x36\x3c\x88\xbb\x7c\xa6\xb2\x1e\x37\x6f\x1b\x2b\x02\x97\x56\xa9\x23\x35\x23\xe9\x3a\x01\xf9\x31\x75\xa1\x9c\xf4\x23\xce\xc6\x83\x53\x93\x36\xfd\x63\xd5\x71\x97\xa6\xe4\x82\x8a\x7a\x1b\x7c\x7c\x77\x45\xa1\xaf\xc6\x39\xb9\xe2\x21\xd8\x9d\xbe\xf0\x91\x92\x44\x6d\xd7\xf2\x69\xe0\xcd\x0d\x87\x27\xa7\xcf\xc6\x22\xc5\x1a\x79\x8b\xbe\x4a\xb1\xfb\xee\x81\xcf\x22\x52\xf7\x50\xc3\x53\x01\xb7\xc9\x64\x16\xd4\x66\xb5\xd7\x67\xf6\xdd\xef\x43\xdc\x6a\xf2\xe8\x39\x24\x4a\xec\xd0\x81\x2e\x8f\x1b\xdc\xa5\x91\x2f\x3b\x14\xeb\x03\xdf\x01\x3e\x0e\x62\x07\x32\xf5\x1a\xab\x66\x17\xb0\x6f\xdc\x75\xf7\xb9\x87\x96\xcf\x7d\xec\xf4\xd3\xcf\xba\x1d\x9c\x7d\xd6\xd9\xa3\xce\xec\x7a\x6e\x11\x5d\xf9\xdc\x81\x73\xbf\xbd\xe5\xd2\xfd\x8b\x4a\xa4\x5a\xf0\xed\xae\xfb\x2e\x7b\x7e\x9e\xf4\x91\x54\x14\x97\xe9\x70\x3c\xa2\x43\x07\xd2\x51\x21\xaa\x33\x55\x6a\xf2\xeb\x20\xc2\x9d\x43\x17\x8e\x98\x23\x4d\x11\x24\xe1\x74\xc0\x04\x79\x1d\x84\x46\xbf\xc7\x43\x75\x8a\x1e\xce\x68\x42\x34\x65\x44\xc4\x97\xa1\x29\x45\x98\xa0\x63\x82\x5c\x71\x42\x66\xd9\x65\xd4\xe9\x10\x8a\xb1\x64\x0c\x28\x30\xb0\x78\x73\xf5\x29\x37\x2c\x59\x7a\xee\xb6\xae\xb1\x33\x67\xbe\x75\xff\xca\x7d\x2b\x97\xae\xaf\x8b\xb7\xc0\xb3\xa4\x8f\xde\x1a\x23\x36\x14\x7a\xe6\x76\xcf\x3e\xb7\xb6\x25\x38\xa1\xae\xbe\x41\x40\x34\xb1\x1d\xb8\x6f\x0b\xbf\x75\x4e\x65\xd6\x27\xa8\x64\x9c\x24\x8b\x52\x9f\xf2\x7a\x8c\x4e\x44\xf6\x40\x6d\x54\xfb\x03\xd0\x89\x55\x18\x95\xe2\xcc\x3a\x4b\xa7\xa8\x53\x94\x97\xfb\x95\xdc\x65\xf1\x19\xe1\x92\x54\x87\x32\x96\x32\x5d\x53\x5d\x90\x0c\xc9\x93\xc4\x63\xc4\xda\x81\x3f\xd7\x5b\xa4\x77\x67\x9e\xfc\xe5\xde\xfd\xdf\x03\xdf\xcf\x60\xa6\x34\x65\xd9\x86\x96\x86\xa7\x5e\xda\xca\x38\x9f\x51\x77\xfd\x7d\xc5\xeb\xff\x06\xa6\xf7\xdf\xf9\x79\xe0\xf2\x97\x1e\xdb\xf4\xf7\xc6\x83\x7b\x77\x1d\xa4\x14\x7d\x05\x75\x44\xee\x0c\x4f\xf9\x69\xb5\xda\x62\xb1\x32\x58\xee\xe8\xa1\x5e\x4b\xd6\xfd\xdb\x55\x48\x13\x77\x8a\x34\x34\x53\xb9\xfb\x62\xc8\x7d\x67\x0b\x0f\x05\x42\x81\x64\x9b\x7a\x56\x75\x5d\x83\xc8\x8e\x7e\x51\x7a\xfb\x94\xe2\x56\xe7\xe2\xaa\xee\x85\xb0\x9b\x10\xdb\xb9\x98\xd6\x4e\x5d\x8c\x88\x8d\xfc\x7d\xe2\x5b\xc1\x3d\xc8\x5f\x6c\x49\x45\x35\x90\x37\x99\x6c\xd0\xe6\x74\x99\x5d\xe5\xae\xfb\x5d\x10\xf7\x64\x76\x88\x16\x4e\xc5\x20\xa3\xd7\x4c\xe9\x87\xec\x74\x1f\x4a\x74\xac\xa2\x32\xf9\x41\xdb\x16\x23\x8c\xa6\xe9\x87\xf0\x3a\xf7\x05\xb3\xcf\x5a\x96\x6c\x05\x37\x5e\xf9\xae\xf5\xc1\xbb\xe8\x10\x12\x74\x8b\xe7\xac\x7c\xe4\x8d\xfb\xde\x2c\x3a\x21\xf4\xdd\x6b\x5f\x4b\xbf\xe2\xc5\x94\x52\x3b\x73\x22\xf2\xdf\x5c\x64\xa3\x5e\x99\x16\x99\xa6\x41\xe4\xeb\x01\xb7\xdd\x0e\x58\x18\x29\x30\x17\x00\x2d\x34\x07\x5d\x41\x84\x12\x97\x5d\xa3\xed\x10\x35\x1a\x41\xc0\xab\x76\x38\xd9\xf7\xc1\x18\x2a\xcf\x2e\xd7\x91\x4f\x28\xb3\x6c\x32\xab\xc0\x22\xf2\x98\xaf\x3a\xb5\xbc\x7e\x34\xe3\x09\xd1\x6a\x62\x2c\xd9\x78\x24\xa5\x37\x2e\xfc\xfc\xa3\x3b\x9e\x03\xbd\x93\x2e\xb8\x62\xed\xb2\x3f\xf5\x1f\x79\x0f\x38\xba\x3b\x97\x5c\x7e\x91\xd4\x0e\xb6\xf3\x5f\x7e\xfa\xfe\x77\xe1\x13\x0a\x9e\xfc\xeb\x33\x2f\x38\xe8\x39\x97\xdd\xf0\xdd\xbf\x3e\x92\x7e\xb5\x82\x6f\x5e\x78\xf5\xef\xe9\x9b\x6d\xfb\xb1\xcf\x23\x21\x3e\xde\x88\xee\xd5\x87\xbd\x37\x8b\x93\x77\xe9\x18\x3d\x45\xb9\x78\xbd\x4b\xaf\xb1\xda\xed\x01\xbf\x4a\xa3\xf1\x37\x05\x80\x45\xe7\x64\x18\xbb\xd5\x68\x32\x7b\x35\x2a\xb2\x26\x48\x9e\xbe\x8f\xd4\xee\x4c\x25\xfc\x9d\x35\x05\xe4\x60\x1e\x61\x19\xec\xfd\xd0\x48\xfc\x50\x75\x90\xa8\x18\x87\x60\x41\xce\x28\x0d\x89\x22\xa6\xbf\x34\xc4\x0d\x6f\xbc\x30\xfd\x21\xd0\x30\xfe\x93\xe0\x82\xc7\x5c\xbe\xdd\xd7\xcf\xbc\xff\xa6\x9d\x40\x67\x4f\x86\xa5\x76\x4d\xa7\x1f\x7c\x24\x9d\x71\x28\x44\x9f\x70\x25\xf8\x60\xb4\x90\xe0\x47\x4b\xe3\x41\xd5\x5b\x31\xe9\x2b\xe9\x8a\xf4\xc1\xf2\x02\x56\xb1\x1b\x3c\xe8\x2e\x3e\x67\x5e\x45\x76\xc3\xe4\x54\x29\xa5\xd3\xd9\xf5\x7a\xb5\xd5\x4c\x23\x71\xe4\x72\x53\xee\x5e\x37\xe2\x7b\x15\x67\xc1\x4b\xff\x1d\xd0\x62\xa6\xec\x06\xe4\x53\x68\x0d\x76\x1d\xbe\x87\xcc\x02\xa8\x64\xf9\x50\xb5\x38\x18\x7b\x2a\x90\x43\x4c\x1c\xcb\x93\x0b\x91\x29\x87\xe5\x93\xf4\x63\xc8\xa2\xf3\xaf\x91\xda\x16\xbe\xfb\x2e\x22\x1b\x60\x5d\xd8\x68\xfe\x90\xde\x90\x70\xa5\xdf\x96\x9e\x34\x49\x33\xc1\x6d\xea\x3f\xdf\x45\x17\x22\xfa\xd9\xf0\xa1\x99\xb9\x5a\x8e\x99\x22\x1e\xff\x11\x3e\x83\x3c\x39\xe4\xf7\x38\x79\xba\xa0\xc0\x16\xa2\x54\xaa\x10\x0f\x4b\x13\x4b\x13\xa0\x33\x01\x02\x09\xc4\x6d\x40\x07\xc3\x61\xe8\x29\xd6\x22\x65\x69\xd2\xda\xb1\xe6\xc3\x15\xd4\x74\x87\x2c\x4c\xf3\x89\x07\x07\x8b\x88\x6d\x88\xa3\xbc\x39\x34\x84\x6d\xd8\x68\x8d\xdd\x22\x3b\xcd\x11\xd9\x07\xb2\x28\x1a\x0d\x3b\x3a\x31\x39\xe1\xaf\x26\x69\x79\xa6\x49\xfa\xe5\xb5\x2f\xee\xfb\xd3\x63\x27\x68\x4e\xd8\x79\xd3\x8e\x2f\x0f\x6d\xb8\xf0\xd4\x59\x8d\xb3\xcd\x5a\xcf\x1d\x85\x7c\x77\xe3\xac\x79\xe0\x36\xb0\xf2\x94\x96\x88\xf4\xd1\x3b\x07\xbf\xd8\xbd\xfb\x8b\x83\xef\x02\x6f\xb8\xa5\xea\xbb\x5d\x37\x3c\xba\xb2\xaf\xf6\xfa\x9a\xea\xea\xba\x03\x73\x4e\xbb\xff\xe8\xd1\xa3\xdf\x91\x58\x89\x29\x13\x2b\xa1\x16\x3e\x44\x51\x86\xc7\x68\x00\x23\xbc\x91\xc3\x31\x90\x6c\xac\xc4\x94\x89\x95\x50\x0b\xa9\x3b\x29\xf9\x5d\x9e\x12\xa7\x1c\x29\x19\xd4\x8d\x38\xee\x82\x75\x23\x89\xcd\x7c\x48\x62\x33\xf4\x30\x87\x3b\x13\xbf\x91\x3f\x6b\x7b\x36\xee\x52\x4f\xbd\x2d\xc7\x6f\xba\x9c\x1e\xf2\x51\xe8\x3d\x04\xef\xe4\x3d\x67\xca\xef\x01\x1b\xe4\xf7\xd4\x94\x96\xf3\x2a\x1c\xc1\x41\x3a\x0d\x7d\x0e\x8e\x65\x58\xc8\xf6\x92\x28\xa7\xf5\xf9\x82\x2c\xb4\xd3\x05\xf6\x82\x58\x51\x90\x55\xa9\x58\x24\x5d\x54\x82\xdb\x8d\xec\x2c\x37\x10\x90\xb4\x13\xfe\x97\x7d\xc2\x4a\x88\xa2\x46\x09\x5a\xc8\x7b\x84\x87\x46\x35\xe8\x22\x12\xab\xc0\x61\x8b\x4d\xab\xf7\xbf\x93\x09\x66\xbc\x36\x2a\x13\xa2\xb8\x19\x87\x2c\xd2\x2f\x6e\xbe\xb5\x7b\xdf\xd3\x74\x7d\x4e\x3c\xe3\x85\xd7\xc9\xdc\x36\x74\xf6\x9f\xd8\x4b\x91\x9f\x59\x82\xe3\x49\x86\x98\xc3\xa1\x06\x25\x16\x8b\x1f\xa8\x41\xbc\xd4\x5d\x80\x4e\x4c\x59\x91\x45\x81\x94\x87\xa6\x43\x2c\xf6\xeb\xcc\x0c\xde\xe5\xad\x9c\x7f\x4f\x55\x3c\xbb\xec\x26\xeb\xa6\x65\x66\x0f\xf2\x56\x3a\x92\x2f\x30\xf9\x6c\xe2\xdb\x87\xe8\x27\xa6\x14\x13\x0e\x07\xf0\xa9\xf7\x5f\xda\xbd\x17\xb1\xc2\xd2\xd3\x2e\x3e\x43\x5c\xbd\x71\xc3\xb2\x4d\x1b\x86\xbd\x37\xbc\xa5\xa1\xe5\xe6\xe9\xb0\x5b\xba\xe8\x1b\xe9\xb7\x7b\xfb\x65\x81\x3a\x77\xc5\xc3\x6f\x82\x4b\xb6\x6c\xba\xf0\xaa\x67\xde\x6a\x9b\x7c\xe0\x8a\xcd\xf3\x7b\x5f\xc1\xfc\x81\xd4\x38\xfb\x0e\xdb\x8e\xe4\x51\x32\xe5\x32\xf0\xbc\x3f\xe0\x36\xdb\x1d\xd0\x80\x2c\x9e\x1e\xd1\x6c\xa1\xd4\xbd\x22\xa4\x18\x65\x4b\x59\xc6\x2d\xa9\xcf\xe6\xe4\xab\x1c\x82\x1c\xc8\xa0\xb3\xe5\x66\x74\x41\xa4\x26\x48\x09\xb5\x96\x5a\x96\x3d\xad\x4f\xdd\x5a\x15\x9f\xd7\xf3\xcc\xd2\xd7\xd3\x5b\x5f\xbf\x53\x3a\x72\x0b\x98\x08\xce\xf1\x58\x36\xbf\xce\xb6\x57\x4a\x3f\xad\x59\xf0\xae\x74\xe3\x21\x69\x29\x89\x16\x3f\xfe\x02\x58\xf0\x4a\x8d\x74\xb7\xf4\xe4\x1e\x50\xdf\x8f\x69\x11\x50\x94\x5a\xcf\xb6\x73\x31\x78\x1e\xa8\x90\xa9\xe8\x68\xc9\xd1\x1b\x28\xf5\x43\x20\x04\xe5\xbc\xae\x7c\x7e\xd5\x39\x88\xce\xce\x53\xe2\x99\x5b\xc1\x0a\x12\x03\x4d\xc8\x31\xd0\xcf\x76\x54\xf8\x1d\x30\x27\xa2\x09\xa9\xd1\x48\x06\x7f\x83\xee\x0e\x89\x26\x04\x37\xf2\xcf\x38\x8f\xd6\x6c\x16\x54\xe8\x77\x0e\x03\x34\xf8\x03\xe6\x40\x20\x50\x1e\x80\x1a\xa8\xa6\xdc\x56\x15\xf2\x5e\xb5\x2a\xce\x23\x00\x01\x99\xfb\xc0\x4e\xe5\x8a\x31\xf9\x21\x7f\x1d\x77\x66\x57\x23\xe0\x0b\x10\xd5\xd5\xa1\x9b\x45\x14\x87\x84\x19\xc0\x2a\xc5\x04\x58\x44\x9e\x48\x93\x20\x51\xdb\x77\xe0\xd0\xe2\x03\x87\xa4\x3e\xe9\xae\xa5\x6b\xd7\x2e\xa5\x5b\x96\x9f\xb1\x6a\x25\xd2\x23\xb7\x79\xc1\xa1\xf7\x7f\x35\x83\x97\xa4\x5a\xd3\x4f\x1f\x4b\xc9\x80\x34\x13\x5e\xfe\xda\x53\x26\x58\x63\x7a\xfc\xe0\xb3\x7f\xb5\x0c\x1c\xb4\x3c\x4f\xec\x17\x8a\xc8\xb6\x7e\xca\x46\x95\x51\xed\xa9\xa8\x9d\x0b\x07\x4a\x84\x80\x1e\xf9\xe5\xe5\x15\xc1\xa0\x86\x4f\x58\x4d\x3c\xf2\x2f\x39\xde\x1c\x73\x69\x5c\x5d\x22\x0b\x35\x76\x4a\x09\xff\xe7\x6d\x9c\xcc\xee\x9e\xc0\xd1\x9b\xec\xf8\x50\x59\x80\x71\x75\x8a\x19\xab\x6c\x47\xce\x17\x62\x35\x5c\x2c\xa4\x62\x7e\xcc\x4a\xb1\x67\xef\x42\xd6\x05\xf3\xfe\xb3\xcf\x0e\xf0\xf9\xc2\xec\x49\xa9\x69\x37\xb8\x5d\x16\x64\x20\x78\x15\x32\x39\xb6\x4a\xef\xe7\x4b\xb2\x9b\x40\xdd\x7a\x32\x07\xcc\x87\xf4\xcb\x7c\x64\x53\x36\x52\xa7\xa4\x6a\xf9\xa2\x22\x57\x31\xc7\x55\xea\x2a\x69\x17\x0c\x35\x84\x1a\x46\x8c\x2c\xe6\xf8\x22\xae\xc8\x56\x6a\x0e\x15\x14\xf8\x26\x8a\x05\x9c\xcd\x56\x6f\x30\xd4\x4c\x14\xf5\x06\xfb\x71\xd6\xea\x39\x9b\x06\x57\xea\x0e\x0e\x1e\xcd\x19\x0c\x9b\xcc\x5d\xa8\x37\x02\xa8\x71\x5d\x16\x8e\xf0\x44\x10\xd3\xd5\x29\x62\x24\xa2\xb0\x5f\x14\xcf\x8a\xc0\x9e\x9b\x4d\x99\xbd\xc0\x5b\x55\x70\x64\x66\xa3\x9e\x73\xd1\xc9\xd2\x01\xde\x78\x97\xed\xe2\xe6\xb1\x8d\x23\xeb\x4e\x39\x69\xd1\xc9\xa0\xc2\x62\xb8\xcb\x76\x21\x79\x9d\xdd\xa7\xd7\x46\x1f\x38\xd0\xf4\x5a\xeb\x45\x45\x63\x53\xdb\x16\xaf\xbb\xf2\xba\x29\xad\x17\xde\x78\xe0\xc0\xac\x57\xc6\xfd\xb9\x60\x6c\x73\xff\xea\x3e\xfc\x13\x69\x3f\x59\xa7\x87\xee\x79\xb2\xd4\x4e\xf2\xea\xd8\x4e\x1d\x99\x0a\x5a\x34\x66\xa7\x99\x62\x29\x16\x11\xaa\xad\x47\xd4\x98\x2d\x5a\x93\xc1\xd4\x23\x1a\x3c\xb4\xa7\x47\xa4\x19\x2a\x7f\xad\x68\xce\x02\x1c\x64\x10\x2a\x39\x72\x56\xe1\xd6\x02\x4a\xc8\xc9\xa0\x4f\x56\x12\xe4\x9f\x48\x47\x70\x6a\x52\xfa\x52\xfa\xe4\x50\x26\x79\x4e\x6f\x53\x32\xe2\x2f\x48\xdb\xdd\xd2\x3d\x84\x65\x27\xbb\xc0\x2c\x50\x9f\x9f\x39\xc7\x76\x35\xe2\x2f\xe4\x5f\x51\x1c\xe5\xc5\xe7\x75\xd0\x5a\x5e\x8b\xa9\xd2\xe7\x37\x21\x5e\x32\x71\x5a\x77\x87\x48\x6b\xed\x50\x43\xd6\xff\xe5\xef\x70\x1e\x72\x5e\xc0\x65\x4f\xca\x1f\x33\x8e\x04\x3e\x24\xdd\x7a\xab\xe4\xda\x26\xdd\xfa\xe6\x3f\xde\x78\x7b\xc7\xd9\x17\x9c\x77\xfa\xea\x73\x36\x6e\x00\xef\x48\x63\xca\xa5\x6d\x64\xb3\x78\x4f\x29\x78\xea\xeb\x81\xff\xfc\xf0\xe6\x5f\x1f\xff\xe0\xa3\x27\xf7\xc8\xf6\xcb\x64\x69\x31\x73\x08\xe1\xb3\x00\xf7\xb3\x50\x0e\x1f\xa7\x75\x68\xa3\x85\x1c\x65\x70\xbb\xc3\x3d\xa2\xcf\xcd\x18\x0d\x3b\xc1\x78\x52\xe6\x99\x1f\xfe\x93\xcb\x90\xb0\x4b\x02\x07\x5d\x92\x72\x50\x40\xe1\xd4\x0f\x11\x85\xd8\x93\xa2\x41\x74\x46\xff\xce\xf9\xfd\x67\x8e\xbe\x69\x5b\xeb\x94\x95\x1b\xef\x96\x7e\x93\x3e\x05\x0b\xc0\x84\x43\xdf\xaa\x5a\xfc\x63\x76\xf5\x7e\xff\x1b\x7d\x60\xed\xbd\xeb\x5a\x0a\x5b\xda\x7b\x9a\x4f\xbd\xb8\x62\x8c\xa7\xa3\x79\x58\x57\x71\xdd\x34\x30\xe2\x30\x18\x09\xa6\x27\xa5\x77\xee\x8b\x97\x4b\x1f\xca\xfe\xd5\xb5\xd0\x83\x7c\x14\x3f\x55\x96\xb2\x63\xe7\xca\xa7\x73\xc0\x40\x90\x87\x26\xa3\xd7\xed\x46\xea\xc5\x2d\x07\xfe\xb8\xbd\x7b\xaa\x72\x16\xa4\x2a\xf9\xa9\xe3\x78\x4f\x1c\x35\x1c\xd4\x25\xd5\xf4\xb0\x6b\x6f\x21\xae\xd3\xc6\x9b\x65\xd7\x09\xe8\x3e\x5a\x3e\xac\xde\x02\xbb\xbf\xf8\x3c\xe3\x38\x21\x67\x3a\xeb\x38\x01\x23\x68\x58\xf4\x0c\x95\xad\x7f\x29\x26\x79\xe8\xee\x54\x35\x5e\xff\xac\xb7\xa8\x20\x92\x6d\x54\xaf\xd8\xc3\x2f\xe1\xe9\x04\x0f\x20\x22\x32\x9e\xd6\xb2\x3c\xcf\x68\xb5\x5c\xaf\xa8\x55\xf7\x88\x5a\x88\x17\x45\xf7\x88\xcc\x60\x49\x4c\x6e\x7d\x07\xa9\x8c\xc9\x9e\x3e\x5b\x1e\x4c\xb2\xd1\x71\x80\x2c\xc2\x48\x0c\xdc\xf5\x7e\xfa\xd9\x5b\xfa\xe1\xd7\x2d\xc1\xa5\x87\xdf\x01\x9f\x8d\x08\xd0\xd3\xd2\x3f\x91\xa4\xf9\xcd\xee\x1a\x9c\x85\x4e\x1f\x1a\xb8\x8d\x9c\x31\x20\x8d\x86\x67\x13\xff\xa9\x2e\xe5\x37\x02\x40\xab\x39\x1a\x5a\x6d\x46\x84\x31\xa3\x91\x66\x59\x64\x52\xb0\x10\x7d\x99\x69\x2f\xf6\x0e\x06\x0d\x8a\xec\x11\xa2\x72\x4c\x4d\xf9\xf3\x49\xb9\x96\xa4\xeb\x8e\xcd\xb0\x07\xff\xf5\x0b\x3f\x0d\x8c\x18\x11\xd8\x97\x3e\x8b\x75\x66\xfe\xf2\x36\x69\x8e\xfc\xb7\x37\x22\xfc\x38\x10\x7e\x5c\x54\x41\x8a\x13\x8c\x2a\xbc\xc0\xc1\xa3\xb3\xdb\x19\x0e\x62\xd8\x71\x18\xe5\x40\x4e\x15\x50\xd4\x8a\x03\xb2\x48\xbf\x0b\x21\x01\x39\x47\x72\x64\x48\x05\x43\x50\x05\x6f\x99\xf6\xac\xde\x3e\x6e\xe0\x3f\x53\x5d\xe8\x89\xa3\x19\x6a\x7b\x5c\x37\xf5\x70\x09\x57\xb2\xf4\x3c\xd0\x0d\xae\x5f\xd9\x4c\x5e\x94\x5d\x28\xbd\x2e\xa5\x56\x66\xf2\xa9\xb0\x0a\xe9\x36\x35\x15\x4b\x09\x14\xcb\x00\x16\xe0\xb9\xb6\x13\x45\xf4\x73\xe4\x31\xda\xe4\x3f\x9f\x5b\x84\x24\x84\x20\x2e\xc4\x48\x7e\x40\x4f\xbc\x79\xd6\x45\xe9\xfe\xbb\x67\xd1\xff\x4a\x3b\xe8\x35\xd0\x8a\x3f\x4f\x27\x8d\x66\xb7\xb2\x0b\x91\xd7\x95\x4a\x85\x34\xda\x30\xe5\xd1\x52\x46\xb2\xc7\xdc\xe1\xd5\xa9\x39\x75\x9f\xc8\xf8\xd1\xd5\x32\x7e\x68\xe0\x70\x35\x44\x39\x2e\x32\x90\x6f\x77\x70\x22\xb5\xfc\x87\x42\x58\x1b\x16\x16\xe0\x18\x9c\x0a\x8f\xdf\x4e\x06\x19\x0b\xb2\x75\xd4\xb1\x5a\x4b\x4d\x35\x8d\xdd\x65\x9e\x7e\x79\xc7\xd6\xa5\xd2\x8b\xcf\xcd\xb9\x66\x7d\xec\xec\xdf\x2e\x43\xb6\xd4\x0d\x1f\xad\x9f\x35\xb2\xbe\x45\x9c\x36\x67\x11\xf8\x6c\xf7\x8f\xce\x2d\xdb\x75\xe9\x34\x4d\x99\x67\x9c\x70\xd2\xb8\xa3\x52\x42\xfa\xf4\x5d\xa9\xf2\xd2\xc0\x1a\xd0\xfd\xd4\x5d\xe0\x84\x4b\xae\xbd\x31\xfd\x9c\x4c\xa3\x94\x34\x9a\xa9\x60\x4c\x48\x02\x0d\x4f\x05\x05\xaf\x83\x35\xb0\x06\x9f\xdf\x69\xeb\x12\x29\x37\xf2\x56\x9d\x1e\x3b\xa3\x31\x7b\x59\x8d\x06\x76\x89\x1a\xaa\x5c\x51\x10\xe4\xec\xd9\x63\x2b\x73\x38\xd4\x38\x96\xc9\x58\x6c\x99\xa3\xc6\xd8\x18\x28\x8c\x81\x18\xfd\xb7\x93\xde\x3d\x7b\xd3\xf5\xb7\xbe\x70\x10\x34\xef\x3c\x65\x62\x4d\x75\x8d\x53\x1a\x5f\x05\xf6\x17\x35\x4a\x45\x55\xf4\x7b\xb3\xe7\x87\x1a\x27\x3c\x29\xdd\xf0\xc6\x0b\xd2\x8a\xb3\xdc\x4b\x41\xfc\xf6\x9e\xb9\x03\x53\x81\x66\x69\xb7\xf4\xdd\x54\x72\x46\x97\x34\x5a\xb5\x10\xd1\xc9\x68\x6a\x51\xaa\x21\xde\x10\x40\x16\x98\xcb\x94\x2c\x00\x05\x60\xcc\x58\xaa\xa4\xba\xbe\x99\x8d\xc6\xa2\x3d\x62\x6b\x6d\x0c\x8e\x28\x0b\x97\xf5\x89\xae\x40\x20\xcc\x69\xfb\x44\x8e\x63\xbc\x61\xc1\xe8\x65\x6c\xbd\x22\xa3\xac\xe7\x26\x8d\x33\x83\x55\x0d\x4a\x9a\xdf\x91\xcc\xbf\x05\xc5\xc0\xc4\xea\x5d\xe9\xfa\xc4\xc0\x39\x88\x2e\x6f\x92\x87\xbf\x93\xb6\x11\x17\x18\xdc\xa9\x88\x17\xee\xf2\xb9\x2f\xc9\x0b\xf6\x5f\x2f\x3f\x75\xfe\x35\x27\xae\x1e\xd1\xb6\xd4\x91\x98\xbf\xf1\xda\xdb\x26\xaf\x19\x31\xa7\x13\xd0\x53\xef\x1b\xd9\x76\x66\x60\xca\x9b\xa3\x7e\x3d\x17\xbc\xb2\x79\xfc\x49\x05\xb7\x56\xf1\x97\x82\x37\x2f\x39\x69\x4a\x7c\x73\xf4\x52\xf0\x0a\xf3\xf5\x6f\x9e\xf7\x3e\x1d\x15\x0e\x8d\x4d\x3d\xdb\x38\xa9\xb4\xa8\x77\xd6\x0f\xe5\xb5\xd5\xf5\x89\x14\xb0\xc1\xef\x71\x8d\xc0\x40\x70\x92\xe8\x30\xd4\x36\x0f\xbe\xb2\xe8\x99\x25\x6e\x92\xc8\xc5\x39\x91\xd1\x2a\x13\xe2\x6b\x82\xb3\xd2\x86\x60\x32\xe5\x76\x9b\x93\x51\x10\xc5\x38\x8b\x63\x9c\x15\xe2\x75\xe6\xad\xb5\x45\xe6\x11\x65\x91\xb2\x89\xa2\x3b\x18\x8c\xf0\xba\x2e\x11\x49\x22\x5f\xc4\x6e\xf2\x32\xc8\x19\xfd\xbf\xe2\xac\xf0\x58\xa4\x8d\x38\x1e\xd2\x7e\x17\x67\xd7\x3e\x7d\x4f\xc3\xea\xae\x8e\x73\x9a\xc7\x2d\xc6\x48\xbb\xec\x96\x29\x2b\xea\x7a\x66\x4e\xbc\xa3\x7e\xf4\xe9\xbe\x09\x07\x47\x7d\xbb\x06\xdc\xb3\x79\x5b\xc1\x2d\x35\x08\x63\x4f\x5d\x32\x65\x4a\xf1\x05\xa5\x97\x82\xbf\xc0\x79\x03\x2b\x9f\x7b\x2d\x14\x8d\x86\xda\x53\xbb\x1b\x27\x27\x62\x33\x4e\xf9\x3e\x51\x57\x5d\x1f\x6f\x01\x36\x7a\x21\x56\x73\xe9\xbb\xfa\xed\xc6\xda\xe6\xcc\x8b\x49\x22\x6f\xa0\x3f\x43\xcf\x11\xbe\xc6\x20\x59\xf4\x20\xd1\x75\xe3\x52\x85\x0e\x2f\x84\x9c\x36\xa2\x8d\x44\x0b\xc3\x3e\xc4\xc4\xbd\xa2\xca\x8d\x18\x58\xa5\x02\x01\xce\xc8\x44\x20\x80\x3d\xd9\xc2\x41\xa7\x32\x17\x3d\xae\x98\x89\xb9\x5a\x99\xd4\x2d\xca\xee\x2d\x69\x3e\x19\x4c\x66\x26\x07\x77\x10\x32\xdb\xd3\xfb\x5f\xbf\xe3\x89\xa7\xde\x9f\x71\x33\xf2\x94\x5b\xfc\x45\x23\xda\x46\xdc\x7a\xf7\xa2\x73\x56\x81\x8f\xfa\x6f\xa9\xf1\xd0\xda\x39\x3f\xbc\x74\xce\xa3\x27\x47\xbf\xba\xa4\xf2\xc6\xbb\xef\xbf\xb1\x9a\x9e\xa8\xd4\x40\x91\x7b\x1e\x8d\xd7\x76\x21\xdf\xb0\x90\x9a\x92\x2a\x75\x07\x68\xda\xa2\x2f\xd0\x63\xb7\x30\xd2\x21\x06\xa9\x00\x8b\x38\xd7\x3b\x51\xd4\x68\xcc\x94\x19\x5d\xa8\xc5\x0c\x0a\xe8\xdc\x65\xbb\x99\x05\xc2\xca\x6e\xfa\xe4\x31\x86\x05\x71\x55\xc8\x52\x51\x3a\x0f\x08\xe4\xab\x73\xe4\xbe\xe4\x7a\x2d\x7a\xe2\x7a\xf5\xa4\x07\x47\xdd\xf8\xc0\xc9\x8f\xac\x6e\x6f\xc5\xdb\x91\x6b\x27\x57\x7c\x55\xb9\x35\x0a\x7c\xab\x37\x23\xfb\xa2\x6b\x41\xa2\xac\x0e\x68\xfe\x75\xd3\x3f\x96\xe1\x55\xc8\x7d\x8f\x9e\x23\x6d\xb4\xe8\x61\x32\xe1\xfa\x55\x72\x62\xfc\xb7\x23\xf9\xc9\x20\x1e\x2f\xa5\xe6\xa5\x6a\x8b\xbc\x5e\x63\xc8\x41\x85\xa8\x44\x99\xa7\xa8\xa8\xa4\xc4\xd5\x27\x96\x94\x04\x0a\x62\xe1\x02\x64\x77\x14\x40\x6f\x28\x10\xea\x11\x15\x06\x0f\x58\x86\xf0\x37\x26\xd5\xdc\x9d\xaf\x59\xd8\xb2\xb2\x5c\xd1\x26\x34\xa1\xd4\xc2\x3c\x42\x0d\xf2\x5c\x28\x3c\xd8\x73\x83\x81\x43\xbf\xb1\xb0\xcc\xca\xbf\x5f\xd9\xb0\x78\xf4\x79\x4b\x65\x2e\xde\x7a\xf1\xb8\x05\x35\x40\x25\x5d\xb4\xe8\x9c\xd7\xd3\x4f\xf5\xdf\x42\xd7\xa0\x1b\xfc\xe0\xe3\x2f\x0e\x4b\xaf\xde\x1a\x2c\x68\x25\x2c\x5b\x56\x48\x37\x83\x5f\xaa\xd3\xf7\xe1\xeb\xc2\x05\xaa\x35\x9e\xf4\x7f\xe6\x48\xfb\x65\x5b\x95\x3d\xfa\x13\x2c\x47\xb6\x5f\x09\x55\x4d\x4d\x4b\x55\x94\x69\x3d\x49\x41\x28\xf2\x14\xd5\xd4\xea\xd9\x2e\xb1\xd2\xd1\x29\xda\x92\x85\xa1\x64\xa8\x32\xa2\xaf\xd4\x57\x6a\x23\x5c\x20\xde\x25\x06\x38\xad\x8d\xe2\x26\xca\xb7\x87\x61\x95\x93\x0d\xb8\x9b\x5a\xb1\xd9\x73\x96\xb9\xc8\x09\xd8\x4c\xcf\x66\x66\x46\x07\x12\xcb\x2a\xb9\x4c\x4b\x1e\x95\x84\xe7\x95\xe0\xd0\x1d\xc8\x90\x65\x21\xd8\xdf\xdc\xd3\x56\xef\x8a\xf8\x75\xcd\xa6\xf3\x4b\x5b\x5b\x27\xd4\x76\x9f\x14\x38\x7f\xdb\xa8\x53\x9b\xda\xce\x9e\xb4\x7b\x7d\xc4\x74\x02\x57\x33\x73\xaf\xf4\x79\xd7\x8c\xee\xd6\x73\xce\xec\xd2\x15\x57\x16\xd7\xb6\x7e\x12\x2b\x8f\x6d\xbc\xe5\xa2\x93\x57\x0c\x9b\x5b\x3f\x72\x49\xd3\xfa\xa6\xfa\x19\x33\x2e\x7a\x7a\xdf\x51\x0a\xce\x6f\x6f\xaa\x6b\x3b\x7d\x2b\xa6\xd5\xa9\x47\x8f\xc0\x1f\x10\x8f\x15\x51\x6d\xa9\x88\x5b\x6d\x0b\x72\x36\x18\x85\xd1\xe2\x12\x88\x2c\x34\xb5\x25\x12\xa1\xcc\x16\x8b\xae\x47\xb4\x30\x94\xaf\x47\x44\x26\x49\xd6\x40\xc7\x97\x68\xa9\x27\xd1\xda\x1c\x91\x53\x25\x47\x4c\x4b\x81\xd2\xba\x81\xb7\x0c\x67\xe6\x6a\xaa\x95\x10\x6a\xac\x0e\xbf\x04\xf4\xd8\x81\x1f\x81\x0f\x78\x37\x5c\xb0\xa6\xf9\xcc\xd2\x48\xf3\x53\xb7\x3d\xf7\x71\xfb\xd6\x5f\xbf\xbd\xed\xbe\x35\x5b\x2b\x0a\x6f\x5e\xf4\x57\xeb\x8b\x2f\xcd\xbb\x6b\xcf\x45\x9b\xae\x2d\x09\x6e\x07\x8e\xf8\x8b\xf7\xcc\xb9\x73\xf3\x05\xb3\x6e\xb8\x70\xe3\xac\x09\x27\xd4\x8f\xb9\x7a\xe2\x26\x79\xa6\x16\xb5\x07\xc1\x70\x1f\xe2\xb7\x00\xd2\x97\x3e\xc4\x53\x2a\x83\xd7\xe0\x0d\x86\x0c\x14\x65\xd6\xd9\x5d\x2e\x4b\xa7\xe8\x02\x3a\xa4\x2b\x75\xf6\xdc\xd3\xe7\x1d\xbc\x8a\x6c\xd6\xc4\xcc\x83\x43\xcd\x41\x58\x60\xa9\xc9\xdb\xd6\x8b\x8e\x0b\xce\x30\xdd\x78\x65\xeb\x45\x85\xa5\x77\x74\x4b\xbd\x36\x30\xe2\x97\x73\x97\x2e\x99\x51\x5c\x79\xed\xcd\xbb\xdf\x5e\xfa\x0f\x70\xd9\x5d\x5b\xac\xc6\xc6\x48\x09\x78\xfc\x3c\xe0\x38\x74\xc3\x9d\x65\x4b\x5e\x09\xbc\xf5\xc4\xc5\x6f\x3c\x84\xe8\xaa\x15\xc9\x83\xdf\x08\x8e\xe3\xb8\xe3\xa1\xc4\x18\xd7\x19\x75\xa5\x89\xe2\x90\xc1\x47\xb9\xdd\x3e\x68\xf3\x21\x5e\x89\xfa\x18\x43\x49\xaf\x68\xb0\x50\x4d\x59\xef\x6f\x30\x40\x3a\xd8\x1c\x13\x93\xb1\x6a\xb7\x60\x7e\xa8\x15\xea\x62\x84\x98\x14\x34\x23\x9b\xb9\x8e\xd0\x10\xaf\x05\x21\x66\x57\x5d\x69\xc3\xf0\xf9\xd5\x6d\x6b\x7e\xd8\xf8\xdb\x7d\xa7\xfc\x63\xed\x59\x0d\x95\xd5\xd1\x60\x91\xbd\xae\x65\xf6\x8a\x19\x17\x2c\x9e\x35\x6a\xe4\x95\xf3\xa7\xcf\x4e\x5f\x2f\xed\xa2\xb7\x32\xf6\xfb\xbc\xbd\x7d\x17\xbc\x2d\x8d\x3a\x5c\x56\x76\x3b\xb8\xec\xdd\x8f\x4f\x69\x74\x9b\x4c\xf7\x01\xaf\x7b\xf8\xf2\x6d\x6b\x96\xcc\x75\x4b\x1f\x4b\x4f\xa6\xff\x84\xf9\xa4\x19\xc1\x33\x17\xf1\x49\x04\x49\xb8\xba\x94\xc7\x1e\x89\x15\x15\xf8\xf4\x2e\xca\x6e\x77\x41\x0b\x46\x77\xd0\xc5\xe9\xa3\x9d\xa2\xde\xf6\x7b\xb0\x0c\xc2\xa1\x80\x41\xaa\x8d\x32\xd8\x0e\x80\x3a\x92\x25\x01\x30\xc4\xd4\xc6\x82\xa5\x63\xa6\x14\x2c\xde\x71\x7a\xba\x7b\xfa\x9f\x6e\x28\x6a\x2e\x2e\x0d\xc6\xca\x53\x53\x57\x5c\xdf\xda\xbc\x60\xf2\xdd\x53\x53\xe9\x37\xb7\x81\x14\xfd\xf9\x12\x6b\xfd\xa8\x57\xa4\x27\x1e\x0f\x85\xae\x02\x5e\xe0\x1f\x5b\x6b\x5d\xf2\x92\xb0\x68\xe5\x8a\xdd\xd7\x0a\x2f\x49\x5b\xa4\x37\xf0\xb9\xc7\x1c\x3d\xc2\x76\xb1\x4f\x23\x19\x56\x8e\xa8\xbd\x40\x1d\x8b\x25\x82\x82\x51\x30\x56\x54\x46\xd5\x6a\x9d\x0e\xc9\x31\x9d\x8e\x0b\x38\x1c\x4c\xaf\xe8\x60\xb8\x12\x24\xce\x86\x90\x7b\xae\xcc\x42\xc2\x38\xb3\xce\x9e\x88\x2b\x6c\x13\x52\x36\xb9\x8c\xae\xda\x52\x80\xce\x2f\x4f\x4b\xb2\xa9\x58\xf4\x5b\x95\x0d\xbb\xaa\x98\x27\x18\xff\xd8\xa5\x4b\x87\x5f\xff\x7a\x74\xc9\x77\x2b\x11\xc9\xd5\x4a\x8f\x4a\x7b\xa4\xe7\xa5\x47\xff\x02\x6a\xfb\x27\x8a\xdd\x2d\x27\x2c\xb5\x27\x16\x4b\x4d\x67\x1e\x99\xcd\x1e\xfe\xe0\xbd\xbf\xef\x67\x1e\xf6\xfb\x5f\x7e\x7c\x62\x87\xf4\xcd\x6f\x52\x5a\xfa\x0e\xf4\x81\x89\x7b\xc0\xb0\xc7\xcd\xe6\xb6\xa6\x97\x53\xbf\x4c\xeb\x6c\x2e\x97\x9e\x96\xfe\xf1\xfa\xd7\x9f\x1f\x26\xbc\x80\x63\xa0\x2f\x33\x78\xee\xc0\x88\x54\xc0\xe9\x2f\x80\xe6\x62\x58\x5c\x9a\x28\x0c\x75\x8a\x85\x85\x94\x5a\x8d\x8c\x48\xa3\xda\x4c\x79\x06\xb3\x1e\xc9\x1c\xff\xa1\x1e\xf3\x73\x7d\x95\x92\xf6\x20\xe2\x28\x03\x45\x24\x3c\xa8\x27\x65\xde\x56\x67\x56\x7b\xd2\xae\xf7\x8f\xac\xff\xe7\xc5\x25\xb3\x22\x6d\x3d\xd6\xc4\x84\x99\xf1\xf6\x09\x89\x2b\x6e\xb9\xfe\xa2\x55\xeb\x2f\xb8\x64\x42\xeb\xa4\x55\x8f\xbd\xfe\x91\xf5\xab\x4f\xae\xfa\xe0\x4c\xc3\x98\xfa\x67\x4b\x8d\x86\xc3\x3b\x1f\x7e\xe9\x9c\xb5\xe7\xaf\xb6\x35\x16\x3d\xb4\xf5\xd6\x1d\xe4\xdc\x7e\x64\xe3\xdf\x8f\x74\x4d\x31\x25\xa6\xca\xac\x9e\x42\xbd\x3e\xc0\xe1\x51\x8b\x1e\x58\x12\x8f\x06\xc3\xc1\x1e\x11\x3a\x75\x16\xbf\xa5\x47\x2c\xf4\x3b\xd1\x7f\xa6\x30\xd4\x73\x26\xae\x47\x34\x65\x75\xbe\xb2\xe5\x7d\xd0\x26\xca\x3a\x44\x99\x40\x89\x95\xd8\xee\x35\xd5\xf1\x8c\x8b\x46\xda\x80\x1d\x6a\x92\x39\xc9\xa9\x90\xb5\xc3\xfb\xfb\x66\x79\xeb\xe3\x0f\x8f\xc4\xa1\x84\x11\x0f\xc7\xeb\xbd\xb3\xfa\x56\x2c\xd8\xdc\x4f\x3b\xfb\x2f\x5d\xb8\x1c\xde\xdf\xb2\xb8\xa1\xa4\x68\x6c\xd1\xc2\x81\x5e\xac\x42\xe0\xb6\x85\xe8\x45\x49\xc3\xe2\x96\x51\x63\x77\x60\xcd\xb2\x43\xde\xbb\xe5\x46\x44\x37\x40\x62\x75\xc3\x52\x3e\xe4\xc7\x69\x18\x86\xe3\xb5\x86\x0e\x51\x8b\xfb\xc3\x54\x9d\xf8\x26\x68\xa6\x43\xa4\x73\xf9\x44\xd1\xf6\x19\x8f\x9d\x27\x55\xd7\x64\xb9\xbe\x1a\x2f\xd8\x7f\x4f\xda\x75\xab\xf4\x4f\x44\x38\xf1\xf3\x81\x1f\x76\x0f\xdc\x95\x40\x3c\x37\x19\x7c\x98\x70\x49\x73\x27\xe3\xf8\xd3\xd1\x23\x24\xfe\x54\x4e\x75\xa5\x8a\x13\x56\x2b\xeb\xb7\xc5\xd9\xb8\x31\x6a\x8c\x22\x2a\x2f\x2a\x0a\x4d\x14\x8b\xec\xb6\xd2\x84\xb5\xd4\x0a\x9c\x66\x4e\x3b\x51\x34\x72\x1c\x20\x39\x61\x45\x6f\x91\xb6\xcd\xdc\xc5\x96\xf5\x59\xfc\x85\xfe\xa7\xa0\x12\x31\x36\x49\x10\x0a\x6c\xfa\xbd\x60\xd2\xfc\xa9\x24\xd8\xf4\x07\x11\x24\xfc\x13\x1c\x65\xc2\x7c\xdb\x8b\xfc\x61\x5c\x4b\xe4\x43\x12\x14\xc9\x1b\x5d\x24\xe2\xb7\x51\x0c\xf2\xe3\x4b\xec\x5e\xbd\x5a\x5d\xd8\x29\xaa\xed\x34\x22\x70\x9a\xcb\x0d\x1f\xe5\xb3\x29\x0e\x1e\x29\x76\x70\xc4\x0f\x1d\xe8\xff\x91\x32\x50\x8e\x7c\x24\x9a\xe4\xc7\x64\x4b\xb7\x17\xf4\x83\x9d\x6f\x1c\x5e\x72\x6f\x44\xad\x09\x36\x2d\x59\x36\xfb\x8a\xd9\x55\xb0\xca\xd8\x7b\xea\xea\x3f\x3f\x2f\xd2\x0f\xac\x3f\xff\xe7\x55\xe7\x5e\x70\x36\x58\x42\x9f\x24\xf1\xdf\xff\x7c\x6a\xdf\x35\xeb\xdb\x8a\x8d\x7a\x6b\xbc\x6b\x8c\xdd\xa5\xd3\x73\x7f\x46\x1f\xb7\xe8\x9d\xe7\xa5\xde\x0f\x77\xfd\x35\xc3\x8b\x27\xc2\x3d\xc8\x32\xa8\x4c\x39\xf5\x14\xcf\x52\xac\xdd\xc1\x99\x54\x1a\xab\xa9\x4b\xb4\xda\x69\x4d\x57\xde\x91\xf3\xd6\x0a\x09\xb8\xf5\xde\x61\x1b\x34\x4d\x89\x5e\x3a\x11\xec\x9b\xf6\x97\xe4\xa2\x2d\xfd\xb7\xfd\xf9\x9e\x2d\x8b\x2a\xfb\xa7\x49\x75\xe0\x2d\xf0\x65\x51\xb4\x31\xb4\xe3\xe0\xab\x8f\x84\x1a\x0b\x8a\x8f\x1e\x3d\xfa\xbc\xd4\x0e\x36\x91\xde\x81\x09\xf9\xbd\x04\xcc\xf5\x59\x19\x61\x41\xf8\xf4\x50\x27\xa5\x2a\x90\x7a\xe7\x69\x97\x86\xd6\x78\x7d\x4e\x9b\xd6\x60\xb6\xe0\x72\xa2\x80\xb9\xc3\xdc\x63\x5e\x62\x66\x0d\xd0\x6c\xc6\x1b\x0e\xbb\x44\x96\xa3\xb0\x03\x6a\x1f\xda\xdc\x92\x77\x72\x52\x36\x81\x84\x87\xdc\x69\x6f\xc7\x63\xb4\xb1\x6c\x0c\xd9\x42\x59\xe5\x0a\x7e\x90\xa6\xbf\xf5\xf2\xa4\x9b\xcb\x0a\xd7\x35\x5f\x75\x99\x16\xd4\x49\x2f\xd0\x5b\xae\x1b\x71\x76\x71\xd9\x8d\x56\xf0\xdd\x91\x81\xe2\x82\x46\xa3\xf5\xb6\x07\x3b\x9f\xb8\x47\x30\x21\x70\x48\x9c\xff\xe8\x11\xfa\x1b\x72\xde\xee\x54\xa5\xa0\x87\x6e\xa3\x4e\xe7\x86\x6e\xaf\x8f\x51\x0b\x9c\x41\xdf\x49\xa6\x65\x74\x18\x7a\x0c\x4b\x90\xa3\x0c\x0d\x06\xca\xe1\xe0\xba\x44\x07\x47\xa9\xff\xeb\x81\xe5\x52\x0f\x22\xee\x94\x8e\x53\x3c\x99\x42\x3e\x75\x0d\x11\x7f\x36\x0e\x8c\x93\x4f\xbb\x75\x0b\x2b\xbd\x00\xea\x0c\x97\x5e\x49\x4e\x7b\xd2\xfe\xb7\xad\xe4\xb0\xb7\x3f\xdb\xf9\xd8\x4d\xe4\xb0\xbf\x7d\x25\x99\x11\xbe\xdb\xb2\xbd\x0f\xdb\x08\xfe\x4d\x52\x3b\x7c\x80\xbd\x14\xbd\x7e\x46\x8e\xe1\x21\x1e\xfd\x04\xd9\x03\x1e\xaa\x36\xe5\xa6\x4c\x56\x8d\x09\x21\x5f\x8d\x24\x8f\x9e\xe7\x5d\x3d\x22\xcf\xe8\x91\x2f\xa3\x17\x72\x0e\x8e\x4e\x5e\x9e\xd7\x21\x6b\x21\x3e\x6f\x12\xaa\x22\x72\xdb\x50\x6e\x00\xef\xa7\xaf\x96\xbf\x34\x3c\xda\xac\xfa\x47\x5a\x7a\x5c\xba\x1a\x9c\x06\x46\x0f\xbc\xab\x6a\x8e\x0e\x7f\x71\xe5\xd7\xff\xa6\x6f\x92\x0e\x4b\xfb\xea\xca\x5e\x94\x9e\x6f\x02\xf3\xc1\x09\xe8\xbf\xf9\x4d\xd2\xf3\x2f\x96\xa1\x6b\xc8\xc4\xc7\x70\xef\x0d\xe5\xa4\xa6\xa7\x12\x80\x32\x1a\x1d\x1a\x03\x84\x1a\x93\xc3\x61\xd1\x58\x5c\x6e\x93\x9e\xd7\xea\xb5\x3d\x22\x92\x66\x2a\x27\xad\x87\x0e\x0b\x8e\x84\xf6\x88\x36\x55\x7e\x23\x10\xf1\xbe\x86\x20\x3a\x93\x27\x22\x8b\x42\x72\x82\x64\xc8\x54\xc9\xf6\x97\xc0\xf9\x11\xc9\xb0\x43\xaa\xeb\xef\x07\x4b\xc1\xe7\xe0\x45\x70\x41\x7f\x7f\xfa\x83\x1d\x74\x03\x3d\xf6\xb7\x83\x99\x60\x59\xfa\x35\xba\x2c\xdb\x71\x72\x86\x6c\x03\x96\x4b\xed\x0c\x9e\xbf\xea\xa4\x96\xa6\x1a\xa1\x20\xf0\x1c\xc3\x9a\x4c\x8c\x53\xeb\xd4\xba\xdc\x01\x37\x12\xc6\xc0\x00\x05\xa7\xdd\xd9\x21\xda\x3d\xbc\x0d\x47\x9d\x3b\x44\x86\xa1\x0d\x36\xb3\x85\xb6\x20\x6f\x0c\xe7\xe9\x45\x96\xce\x54\x24\x64\x54\x4a\x79\x4e\x14\x3e\x53\x53\xa7\x78\x62\xd8\xbb\x26\xac\x3a\x04\x86\x2c\x70\xb7\xad\x00\x13\x90\x8b\x6d\x05\x2d\xcb\x97\x4b\xeb\x17\x48\x3b\x6a\xa5\xdd\xb3\xa4\x83\x2b\xe0\x3c\x57\x22\x3d\x95\xbe\x3b\xe1\x1a\xf8\x00\x7b\xbd\xf4\x57\x03\x07\x60\xc5\x6f\x7d\xf8\x39\x96\x77\x3a\xa5\x5e\x06\x4f\xb3\xeb\x48\x15\x85\x6d\x78\xc5\x93\xc7\x44\x9b\x0a\xa2\x56\x8b\x8e\x62\x58\x06\x79\x22\x2c\x4b\x5b\x2c\x4e\x5c\x25\xad\x0b\x20\xd3\x96\xa3\x87\x54\x49\x2b\x1a\xb0\x3e\xd7\xc3\x22\x3d\xdf\x64\x26\x39\x9f\x57\x4a\x63\x0b\xd9\x60\x4e\x2d\x0d\x28\xbe\x7d\xed\xda\xc1\x7a\x1a\x50\x31\x55\xa9\xa7\x91\x1e\x7d\x74\x32\xfd\x4e\xb6\xa6\xe6\x99\xc9\xa0\x61\x68\x4d\xcd\x32\x24\x6b\xe8\x0c\x6d\xdb\x55\x26\x4a\x45\x79\x7d\x2a\xbb\xca\x0e\x5d\x2e\xbe\x47\x74\x31\x50\x8f\x54\xf9\x1f\xd2\x36\x15\x0a\xc7\xe4\x46\x2b\x25\xb6\x8f\xad\x5b\xa1\x16\x99\x57\x2c\x2d\x5d\x25\x3d\x31\x48\xcd\x19\x4a\x7f\x77\x00\x8c\x01\x8b\x10\x6d\x3f\x26\x5d\xdf\x04\x86\x23\x6a\x06\xf5\xa0\x04\x94\x82\x3a\x44\xe9\x60\x78\x93\x74\x7d\x46\x0e\x62\xbe\xb3\x14\x42\xd2\x01\x4b\xdf\x08\x1e\x48\x1f\x22\x3d\xde\x1d\x61\x50\x1e\x06\x54\x18\x84\x73\x7b\xbc\x15\x58\xd0\xfb\xef\x93\xdf\x4f\xfd\xf4\x87\xef\x27\x3d\x87\xaa\xf7\x2c\x85\xb8\xe7\x90\x57\x53\xad\xc8\xbb\x39\x91\xbc\x3f\xc4\x16\x02\xc6\x1f\xf2\xb8\x70\x2e\x8f\x8a\xe7\xbd\xff\x9c\xec\xfb\x17\x82\x00\x58\x81\x77\x91\xd0\x20\x80\x13\x80\x8e\x32\x2f\xe5\x8a\x66\x92\x7f\x80\x8a\x4a\xed\x2c\xee\xa1\x2a\xa3\x16\xa7\x1a\xdd\x2a\x55\x4c\x5f\x56\x16\x0c\x5a\xf5\x3c\x53\x5e\x51\x50\xda\x2b\xc6\x0a\x3c\x6e\x96\x85\x5e\x38\x51\xf4\x7a\x2d\x5a\x97\xc1\x62\xe8\x15\x3d\x56\x60\xa5\x78\xa0\x65\x70\xcb\x9b\x5e\x8b\xb0\xaf\xb5\xe4\x56\x43\x27\x67\x0e\x71\xc9\x95\xc4\x0b\xb1\x9c\x14\x79\xae\xd4\xdb\x66\x6c\x26\xec\x6c\x64\x62\xcb\x4a\x5d\x2e\x21\xa3\x1a\xf9\xd2\x6a\x98\x73\x4e\xdf\x34\x67\xd5\x9f\xd3\xdf\xdc\x9b\x7c\x73\x9a\xa7\x95\x69\x1b\xe5\x99\xf4\x61\xe5\xdd\xab\x5f\x78\x70\xe2\x9d\xf3\x37\x74\xb4\xf8\x85\x31\x25\x9b\xc1\x97\x17\x5f\xee\x49\xcf\x27\x3c\x7c\xad\xf5\x10\x18\x2e\x3d\x7f\xc8\x22\x89\x23\x1f\x3f\x28\xf9\x2e\xd8\x77\xba\xff\xc7\x4b\x1c\xee\xa7\x06\xf1\x34\x0b\xe3\x15\x8e\x21\x78\x5a\x05\xa6\x20\xbc\x5a\x10\x5e\x6d\x08\xaf\xcb\x38\x01\x68\xa2\x32\x5a\x07\x65\xab\x1f\xc9\xaf\x2a\xca\x66\xd6\xfa\x00\x30\x9b\xb5\x81\xa0\x39\x08\x4c\xd0\x07\x90\x87\xe5\x6b\xf4\xb5\xfb\xa0\x1e\xfa\x7c\x06\x8b\xc5\xdd\x23\xda\xed\x16\xc6\xc0\xf4\x88\x1a\x8d\x01\xd1\x65\x52\xae\x95\x28\xcf\x51\x18\x79\x25\x41\x72\xad\x4a\xc8\x0d\x7e\x57\x02\xc3\x10\x3c\x2d\xbd\x93\xfe\xcf\x17\x79\x62\x78\x16\xe8\xce\xe6\x50\xbe\x32\xd0\x63\xe8\xf3\xa5\x0f\xa5\xbf\x29\x92\xf8\x64\x90\x02\xd3\xc0\xc9\x4a\xf2\xe4\x27\xe9\x2b\x02\xf7\x26\xa4\xa7\x7f\x24\x7a\xbc\xf6\xb8\xbd\x9b\x72\x0f\xcd\x39\x79\x3d\x34\x2b\x28\xe7\x31\x3d\x34\xd9\xf4\x31\xce\x39\x23\x5d\x2a\xf7\x03\x27\x48\xcc\x43\x38\x7a\x44\xf5\x08\xa2\xa9\x10\x55\x42\x2d\x49\x8d\x44\x92\x2b\x16\x43\xc6\xa6\x36\xec\xd1\x7a\xe2\xa5\xe6\x52\x24\x35\x1d\x85\xbd\x22\x69\xd2\x73\x38\xfc\x82\x3f\xd6\x2b\xfa\x43\x3d\xa2\xdf\x62\xe7\x05\xc4\xd0\x02\xc2\xa8\x00\x55\xc6\x3e\x51\xab\x12\x32\x0d\x04\xc7\x64\x48\xe2\xb9\x59\xe6\x6c\x69\x15\x08\x41\x1d\x40\x26\x59\x39\x20\xe9\x4b\x8b\x47\x89\x41\x2a\x73\x23\x71\xb7\x28\x69\x50\xc3\xe9\xb2\x36\xe9\x88\x27\xd4\x7d\xe1\xbc\x59\xc3\xd5\x89\x72\x5f\xd5\xf4\xd3\xa3\x9e\x7e\xb8\xfb\xf5\x7d\x5f\xfc\xf2\xdb\xf7\xe9\xc3\xfd\xf4\xed\xb7\xde\x7d\xc3\xd5\x8f\xdc\xc8\x7c\x24\xed\x93\x2e\x94\x96\xef\x2a\x7f\x4b\x8c\x82\x6b\xc0\xbd\xa0\xc6\x8d\x83\x3c\x03\xcf\x3c\xfe\xe8\xae\x1a\x37\xf0\xde\xb8\x29\xbd\xff\x6c\x04\x37\xd6\x73\x18\xee\x20\xf2\x38\x36\xa7\x26\xf8\x2d\x16\xb6\xb0\x30\x60\x36\x3b\x42\x5a\x87\xb6\x24\x6e\x8e\x23\xc0\xfd\x3c\x02\xdc\xdf\xe4\xef\xf0\x23\x6a\xf1\x23\x69\x69\x31\x3b\x6c\x0e\xa4\xec\x2c\x6c\x14\xfd\x86\x45\x28\xc1\x0b\x15\x0c\x85\xd8\x6d\xf7\x39\x99\x20\x40\x6e\x8a\x1b\xc0\x1c\x4d\x98\x83\x02\xc5\xca\x93\x59\x6d\x28\x4e\x88\x78\x96\x79\x6d\x08\x0a\x48\xcb\xe5\x60\xe4\x2b\xc4\x67\x71\x42\x7f\x41\xbb\xfe\xb2\x06\x23\x40\x2a\xe8\x97\xb8\xfe\xf4\x67\xfd\xfd\xb4\xab\x1f\x7c\x4b\x4f\xb9\xf5\xee\x71\xa3\x1e\xb9\x91\xd5\xe4\x80\x4e\xd7\xa6\xf7\x67\x14\x68\x8d\x3b\xfd\x1d\x6d\x1e\x58\x27\x23\x83\xc8\xed\x28\x45\xb1\x07\x11\x3e\xa2\xd4\xdc\x54\x2d\x1f\x89\xd0\x5e\x87\x43\x4f\x6b\x98\xc2\x18\x1f\x0e\x07\x85\xe0\x44\x51\x10\xf0\xbc\x6f\x2d\x44\x22\x45\x0f\xf4\x94\x06\x89\x14\x8d\x16\x46\xbc\x0e\xd2\x4e\xea\xce\x6b\x27\x3d\xae\x60\xc9\xba\x63\xc4\x97\xf8\x1d\x49\xa2\x14\x62\x28\xf2\x06\x0c\x57\x44\xc8\x18\x24\x42\xde\x47\x22\xe4\xf9\xbb\xaf\x93\x0a\x36\xae\xdc\x80\xc4\xcb\x10\xb9\xf1\xc8\x21\x49\xc4\x90\x81\x5b\xae\x3e\x97\xc8\x95\xac\xec\x60\x67\x12\xd9\xb1\x5f\x91\x1d\xf7\x2b\xb2\x03\x89\x58\x30\xde\xed\x33\xb2\x8a\xec\xa0\xe5\x1e\x5b\xd5\x7b\x48\x77\x85\xa8\x8b\x52\x1e\xad\xcb\x45\xeb\xec\x76\x9e\xe6\xc3\x11\x26\x32\x2a\x42\x57\xa3\x6f\x1f\x47\x7e\x44\x2f\x70\x9f\x6d\x75\xc3\x88\xb6\x0f\x22\x80\xee\x8c\x2c\x8d\x6c\x8b\xbc\x1a\x61\xcc\xfe\x80\x9f\xd6\x42\xbf\x97\x4d\x71\x72\xc7\xad\xd1\xa1\x63\xa1\x0b\x7d\x02\xc6\x90\xd6\x69\x25\x38\xaa\x1a\xc4\x92\xd2\xcd\xe8\x76\x72\xef\xe1\xd6\x63\x80\xbb\x6f\x97\x2d\xcf\x6f\x2d\x18\xec\xc0\x55\xfc\xd3\x8c\x95\x61\x73\xd8\xe4\x5d\x31\xc3\xc9\xb5\xd3\xab\xb1\x77\xaa\x74\xe5\x3e\x8f\x67\x8a\x67\xee\x7a\xa0\x0e\xde\x5a\x34\xd8\xa3\x0b\xdf\x18\xe8\xa9\xf1\xd4\xb0\xf7\xca\x13\xc7\x11\x8e\x9a\x91\x9e\xbb\x5b\xf5\x22\xc2\xd1\x61\x8c\x23\xcd\x00\xd8\xa9\xe8\x2d\x3f\xc2\x91\x23\x54\x4c\x69\x07\xf5\x16\xb6\x11\x91\x1e\xc2\xbd\xc8\x0e\xea\xcc\x94\x57\x6b\x75\x38\x68\x1d\x42\x92\xd3\x75\xb5\x6b\xbb\x6b\x87\xeb\x47\x17\x73\xd8\xf5\x31\x7a\x80\x78\xec\x42\x2a\x81\xdb\x91\x5d\x80\xa6\x5c\x41\x57\xa7\x6b\x83\x8b\x31\x41\x9b\x87\xd3\x2b\x08\x62\xa1\x8c\x1c\x2b\x45\x69\x7b\xb3\x03\x07\x72\x8b\x3c\x94\x12\x95\x9c\xbe\x64\xa5\xd6\x28\x99\xc3\x13\x59\xc4\xc0\x08\xcc\x47\xc7\xb3\xa3\x9b\xc7\x64\x7b\x94\x17\x31\x57\x67\xf0\x80\x5c\xa4\x1d\xc7\xcc\x4b\x90\x69\x00\xdb\xee\xc8\x67\xf3\x53\xbd\xa9\x1a\x93\x16\x9d\xd6\xa3\xc5\x23\xb2\x89\x0a\xd1\x43\x9b\x1b\xb1\x3e\xae\x65\xb5\xd9\xd4\x06\x83\x15\xbd\x30\xe0\x66\x55\x03\x54\x7b\x7a\x45\x35\x32\x8d\x49\x97\x66\x86\xdb\x7f\x4f\x8b\x60\xbe\xc0\x25\x48\x59\x2e\x27\x93\x14\x90\xfe\xc0\xfd\xb8\x59\x06\x6f\xfa\xea\xdf\xbf\x7e\x2f\xa9\xfa\x6f\x81\xe7\x1b\x9b\xeb\x8b\xb7\x9f\xf8\x27\xf0\xd0\xad\x77\x9f\xd2\xf7\xc8\x8d\xf4\xbf\x9e\xdc\xb9\xeb\x09\x65\xc8\xc2\xfe\xfd\x1a\x83\x44\x4b\xe7\x12\x76\x1e\x3a\xf3\x21\xa3\x3f\xf1\x6b\x48\xf6\x6f\x61\x7f\x84\x6d\x25\xbb\xfc\x1c\x54\x5b\x2a\x46\x1b\x8d\x02\xab\xa3\x04\x9d\xe0\x74\x59\x8c\x66\x63\x8f\x68\xa6\x11\x58\xd0\xae\xf6\x08\x3a\x15\x82\x4d\x45\xf5\x8a\x2a\x02\x95\x7c\x2f\xf2\x93\xbc\xc6\x5b\x9c\x72\x0e\x71\xb4\x19\xa0\x0b\xa8\xab\xb5\x64\x2e\x04\xbd\x82\x07\xa5\x45\x17\xae\x5d\x33\xbb\x99\x7f\xe0\xbc\xab\xfb\x19\x4b\xff\x0e\xbe\x79\xf6\x34\x66\x93\xf4\x66\xfa\x9a\xff\x4c\x43\xd7\xf0\xad\xf5\x67\x7a\x11\x68\x90\x2f\xc6\x2a\x71\xf2\xbd\xe4\xcd\x6f\xc0\x39\x51\x8a\x52\xc7\xd1\x99\x63\xd4\x86\xd4\xa8\xa0\xc7\xe3\x0e\x03\x95\x4a\x1d\xb3\xb9\x0d\x6a\x6b\x38\x6c\x8c\xc5\xd4\x6e\xc8\x06\xbc\x34\xeb\x65\x8b\x8b\xc2\x5e\x36\x16\x8d\xf5\x88\x54\xc8\x68\x05\x41\x95\x47\xc3\x05\xe8\xa8\xc5\x6d\x13\x0c\x6a\x13\x67\xea\x11\x1d\x3a\x0e\x52\xd9\x5e\x62\xc5\x63\x91\xfb\x55\x92\xc9\xdc\x56\x00\x3e\x99\xeb\xb8\x28\x73\x6d\x40\x0c\xa0\x1b\xd3\xca\xca\x0a\x64\x98\x93\x3c\x64\x3a\x5a\x08\x8b\xc2\x9a\xab\xa4\x0b\xa4\x37\xd7\x80\xfb\xa4\xab\x2f\x02\xbd\x93\xc1\x4f\x1b\xc1\xbe\x8d\xe0\xa7\xc9\xa0\xf7\x22\x64\x10\xdc\xb7\x46\x7a\x53\xba\x68\xeb\x75\x52\x64\x23\x1d\x38\x3f\x3d\xa3\xc6\x43\x7f\x00\x9e\x22\xc2\xf9\x32\x7a\x79\xee\xa3\xd4\x92\x0e\x7a\x6a\xe8\xed\xe7\x4b\x95\x98\x81\x09\x3e\x66\x93\x3a\xc6\x09\x48\x6b\x9f\x94\x4a\x14\x09\x8e\x68\x54\x08\x40\x62\x6e\xc7\x4b\x8b\x04\x8b\x60\x41\xb7\x28\x20\x2a\x15\x04\x18\x08\x87\x91\x95\x13\x26\x96\xb7\x0a\x66\x95\xb4\x12\xd3\x94\xc7\x7a\xe4\x97\x22\x12\xda\xb4\x32\x91\xac\x1d\x2e\xd7\x3d\xd7\xd4\x65\x2a\x13\x07\xa3\xfa\x2a\xb5\x1f\xc0\xdb\x8f\x52\xef\x3e\x72\xa7\xbe\x25\x1e\xb9\xb4\x6e\xeb\xe5\x17\x5f\x79\xf9\xe5\x67\xac\x5b\xb0\xae\x6e\x5d\x30\xd4\x72\xe7\xd5\xaf\xbd\xbb\xfd\xd2\xfb\xee\x02\xa7\x3d\x74\x30\x0e\xdc\xbb\xed\xc1\x2b\xef\xdc\xb8\x49\xad\x99\xa8\x55\x6d\x5a\x7b\xee\x86\x90\x75\x3b\xa0\xe3\x77\xdd\x76\xde\xbd\x36\xdb\x9d\xb9\x73\x0e\x3c\xd4\x85\xb9\x12\xd8\xeb\xbb\xda\xb7\xdd\xb7\xc3\xf7\xa3\x8f\xf9\x18\x7d\xa3\x7d\x19\x09\x7c\x85\x0f\x89\x16\x5f\xd0\xd7\xe9\xdb\xe0\x43\xa2\x05\xd9\x29\x3c\xeb\xc8\x11\x2f\x48\xfa\xca\x1d\xd4\x8a\x98\xc9\x68\x29\xac\xa0\x92\x83\x42\x06\xbf\x3e\x66\xfc\xc1\x7f\x17\xc0\xc7\x11\xbd\x7f\x2c\x75\x07\x67\x8f\x10\x79\xbb\x4f\x91\xb7\x5b\x14\x9d\xe4\x45\xf2\x16\x06\x62\x94\x29\x6b\xcf\x12\xfd\x45\xea\x31\x56\xa6\x9a\x34\xd0\x41\x43\x9a\x31\xdb\x75\x3a\xb3\x9a\x31\x33\x6e\x0f\xe5\x01\x46\xe8\xb0\xd1\x1c\x9e\x34\x30\x17\x02\x0a\x02\x2d\xa4\xed\x80\x67\xb4\x76\x0d\x64\x8c\x2e\x0b\xd4\x31\x66\xa3\x19\x89\x25\x63\xd6\x43\x97\xbb\xb3\x30\xb4\xb3\x66\xca\x8d\x20\xc9\x63\x84\x53\xc6\x1b\x1b\x42\xd3\x83\xd4\xce\x46\x6e\x94\xa6\x82\xaf\xae\x94\xee\x93\xda\xee\x79\x26\xfd\x37\x19\x13\x53\x37\xb0\x23\x10\xc1\x36\xa6\x0b\x11\xc1\xde\x7c\xbd\x34\x3e\xc7\xe4\x38\x8f\x5e\xe7\xae\xc1\x77\x8c\x6c\x4e\xb6\x0a\xc1\xe4\xa5\xc6\xa4\xa2\x4e\xbd\x1e\xda\x79\xc8\xfb\xfc\xbc\xdd\x6a\x47\x57\x64\xe1\xf4\x46\x44\xa9\x46\x67\xaf\x68\x84\x94\xba\x4f\x84\x38\xeb\x54\x95\x6b\x58\x0e\x4a\x1f\x99\x23\x1d\xc7\x98\x90\xca\xb4\x0a\x6c\x5f\x3e\x9c\x6b\x32\x32\x1c\xb9\x27\x69\x31\x36\x26\xad\x79\x46\x62\x76\x84\x85\x62\x41\x66\xed\x87\x63\x66\x91\x64\xe7\xc6\x0c\x9d\xd3\x91\xfb\x7b\x38\x89\x3a\x66\x0e\x46\x8e\x0f\xaa\xa2\x0a\xc9\xeb\xbc\xb9\x13\x08\x37\x44\x17\x23\xdc\xf8\xa8\xe6\x14\x72\xed\x18\x9f\x4a\xef\xd3\xfb\x03\xac\x17\x70\x9c\xab\x4f\xb4\x72\x82\x5e\xc5\xf8\x80\x0f\xb9\x2b\x79\x86\x66\x72\x68\x1f\x53\xbd\xbc\x98\x42\x9d\x91\x53\xa4\xc9\x1b\xa3\x49\x8e\x72\x81\x66\x3a\xf1\x17\x70\x09\x98\x73\x0d\xd8\xbc\x5e\x3a\x61\xc5\x99\xe7\x4c\x4c\x74\xfb\xb4\x89\x4a\xbe\xce\x7b\xc2\x79\x63\xd2\x69\x6c\x3c\xba\xd3\xed\x34\x09\x68\x0f\xec\x79\xeb\xb6\xf1\x4e\xe1\xbb\xd9\x0e\xf7\x86\x0b\xe1\x32\x0a\x52\x08\x3a\x15\x95\x9d\x87\x71\x67\xea\x94\xec\x3c\x0c\x77\xb1\x3e\xe2\xd6\xbb\xab\x92\x54\x12\x54\x24\x97\x26\x1f\xf8\x7f\x30\x12\x83\xfe\xbf\x8c\xc4\x58\xf6\xdf\x66\x62\x84\x92\x99\x88\x7f\xf0\xf7\x67\x62\x6c\xc2\xf4\x32\xfb\xb6\x23\x17\x02\x3b\xd0\x9d\x84\x19\x7d\x2a\x40\x8e\xe7\x85\x5f\xdd\xda\x57\xf9\xc4\x9e\xbd\xcf\x94\xa4\xaf\x7c\x6e\x77\x45\xf1\x33\x7b\xb3\x53\x31\x5e\xfd\x4a\x9e\x8a\xf1\xf5\xc1\x2d\x6f\x2f\x3c\xf1\xc5\xa7\x76\xed\xc2\x53\x31\x9e\xdc\x47\xff\xac\xd0\xd4\xd0\xb9\x18\xd8\x9e\xba\x8a\xd8\x1c\xa7\xa7\xbc\x80\x31\xa9\xcd\x78\x56\xae\xdd\x71\xb5\x63\xbb\x63\x87\xe3\x47\x07\x73\xd8\xf1\x31\x7a\x80\x0e\x2c\xf4\xe2\x58\xe8\x39\x90\xd0\x73\x04\x1d\x9d\x8e\x0d\x0e\x6c\x4f\x71\x46\x8d\x4e\xd3\x23\x5a\x74\x88\x5f\x58\x75\x8f\xc8\x9a\x7a\x45\xd6\x22\x47\x84\xf2\x6c\xa9\x21\x22\x4e\x91\x70\x51\xac\xa7\x43\x43\xcd\x29\xe6\x7d\xa4\xa9\x4f\xfd\x6d\x6e\x8e\x88\xeb\x24\xea\x79\xa8\x39\x45\x60\xb0\x21\x3a\xfe\x99\xd0\xc3\xb4\x54\x19\xaf\x73\x40\xe8\xd7\xf9\x83\x21\x73\x08\xe9\x20\xc6\xe1\xb0\xaa\xad\x13\x45\xb5\x9a\x32\xfa\x9c\x32\x7b\xbb\x8d\xe8\x1d\x94\x3f\x77\xc8\x54\xee\x68\x0f\xf9\x3e\x87\xf6\xe2\x90\xda\x8d\xc1\x2e\xd6\xfc\x02\x15\x5c\xb6\xf1\x73\xfa\xf0\x33\x7d\x4f\xb6\xee\x7f\xe8\x3a\x9a\xe9\x3f\xeb\xe2\xf8\xc2\x8d\x44\x32\xd7\x78\xc0\xb3\x05\xa5\x7f\x7d\x07\x5c\x41\xd4\xe9\xb2\xdb\x36\x9a\x02\xf4\x45\x83\x25\x1b\xb2\x9c\x55\xff\x9d\xe8\x9d\xf3\x52\x5e\x5e\x67\xd1\xea\x68\x17\xed\xf2\xfa\xaa\x7d\xc0\xea\x2b\x40\x0f\x87\x7d\x58\xf1\xa8\xb2\x8a\xe7\x55\xa2\x78\x38\x5f\x85\x2f\xe5\xeb\xf5\x5d\xe1\x7b\xc6\xa7\xd6\x41\xa7\x90\x51\x3d\x36\x6c\xda\x6a\xb1\x51\xeb\x22\x9a\x67\x88\x69\x9b\x35\x3d\x94\x1b\x51\xac\x7e\x4b\x7d\xd5\x10\x9d\x13\x3a\xc6\xc6\x55\x74\x0e\xc0\x90\xd1\xb4\x02\xdf\x10\x03\x37\xc7\xd0\x95\xe9\x4b\xfd\x3e\x91\x29\x97\xa5\x82\x80\xb1\x9b\xcd\x6a\x07\x43\x99\xd0\x75\xf8\x03\xd5\x01\x60\x0d\x14\xa0\x87\xc3\x81\x8f\x03\x3f\x06\x54\x78\x0c\x5c\xaa\x16\xc3\x17\x40\xf0\x05\xb8\x40\x45\x20\x15\xe8\x0d\x5c\x11\x78\x26\x80\xe0\xf3\x39\x33\xb4\xe6\x46\xc4\x66\x37\x61\x42\x53\x48\xce\x02\x33\xad\x4a\x7f\x0c\x22\x66\xc4\x4c\x8b\xd7\xf1\x09\x2f\xf3\xa8\x8e\x63\x02\xfc\xc5\x75\x0c\xbc\xc7\x27\xc3\x1c\x72\x44\xf2\x62\x04\xe2\xb1\x3e\x04\xb3\x15\x41\x3d\x23\x55\xcd\xbb\xdd\x2a\x44\xa2\x2a\xe4\xd4\x07\x78\x17\xb2\x6e\x79\x44\x97\x3c\xcf\x1a\x8d\x48\x1c\x51\x06\xa0\x65\x0d\x46\xa3\x06\x6b\x1c\x06\xd9\xf7\xd9\x4a\xcf\x8c\xa1\x94\x31\x92\x32\xe6\x52\x8e\x23\x0b\x14\x03\x1e\xf9\x7f\xd8\x99\x95\x7d\x77\x75\xc6\x84\x67\xfb\x06\xbe\x45\x06\x7c\x52\xfa\xe6\x04\x4f\x2b\x3c\xe7\xf5\x6b\xff\xf5\xcb\x0b\xb2\x05\x0f\x56\xec\x7a\x1c\xd9\xef\xd7\x31\x1c\xf2\x61\xb1\x9b\xbe\xfb\xaf\xb2\x3b\x0e\x89\xce\xd9\x8d\xce\xae\x41\x5a\x3f\x4a\xcd\x49\xd5\x50\x06\x83\x25\xe0\x62\x59\x4b\xc0\x6d\x71\x17\xc6\x5c\x0c\x02\xc0\x85\x00\x70\xb9\x38\x5b\x34\xe8\x14\x6c\x02\xb2\xef\x6c\x10\xfd\x96\x43\x76\x1f\xc7\xf6\x8a\x3e\x8e\x68\xfb\x8c\xba\xcf\xe1\xac\xbc\x31\x6e\x83\x36\x6d\xe6\xc0\xf9\x2e\x09\x56\xf5\x39\x7a\x1f\x6e\x96\xa3\x2c\xd2\x27\x4a\xd8\x05\x17\xd9\x30\xa7\x60\x09\x89\xef\x05\x9c\x4a\x20\xa0\x79\x39\xe2\xa0\xd4\xd7\x0c\x28\x41\xbe\x9b\x95\xcb\x91\x7d\xac\xc9\x0a\x7c\x93\x53\x65\x18\x30\xca\x60\x31\xb8\x3d\x66\x0f\x06\x2a\x17\x3a\x19\x36\x1b\xc4\x30\x11\xd8\x72\x6f\xe5\x38\x91\x94\x6c\x8f\xf2\xef\x40\x73\x5c\x08\x7e\xe7\xdc\x99\x78\x36\xf3\x03\x89\x27\x76\xa4\xe2\x46\xbb\x17\x9a\xf4\x7a\x2f\xf4\x06\x82\x46\x43\xaf\x68\x30\x36\x1a\xdb\x8d\x50\x8f\x97\x0a\xd8\x94\xf8\x36\x85\x98\x83\x19\xb4\x58\xf2\xac\x6c\x90\x1b\x43\x64\x07\xa3\xdc\x42\xa8\x26\xa4\x03\x39\x81\x6e\x9e\xa3\xe8\x96\x7f\xbf\xa1\x6a\x8e\xd6\x3c\xb6\xee\xd3\xff\x30\xe9\xdd\xf4\x28\xfd\x3b\x5f\xf5\xee\x1a\xe3\x6f\x51\x7d\x7b\x08\x4c\x06\x27\x48\x5b\xac\x38\xd4\x5d\xdc\x08\xca\x80\x7f\x1a\xf0\x00\xba\x3c\x7e\x1f\x88\x26\xa5\x07\xa4\x5b\xa5\xa7\xa4\x2b\x31\x9e\x8f\x1e\x51\xe3\x58\x28\xa6\xa2\x45\xa9\x46\x37\x30\x18\x54\x02\x65\x32\x09\x41\x95\xa0\x42\x64\x64\xb5\x5b\x11\xf1\x1b\x11\x1c\x54\x23\xd5\x4e\x21\x38\x90\x39\x6a\x87\x26\x81\x47\x38\xe7\x2d\x5a\x64\x64\x68\x05\x18\xe9\x11\x21\x93\xd3\x20\x99\x49\x8c\x60\x90\xf2\xfc\xc0\x9c\xf4\x4e\xc8\x92\x1d\x67\x07\xf3\xe2\x57\xb9\x33\xef\xc0\x5d\x60\x89\x87\x1e\x0f\xaa\x40\xad\xb4\x57\x7a\x4d\x7a\x5b\x7a\x5e\x25\x6d\xc9\x84\xb1\xe8\xa6\xbd\xaf\x1e\xda\xbb\xe7\x6f\x87\x9e\xa7\xdf\xa7\x4f\x93\xb6\x23\xb8\xfa\xa5\x6d\x60\x22\x18\x9b\x17\xc7\x7a\x48\xda\x2d\xbd\x0f\x22\xa0\x05\x34\x01\x9f\xf4\x19\xa1\x2f\x0d\xe2\x7d\x8f\xe2\xc3\xcf\x4c\x55\x50\x2c\x6b\xb5\x6b\x34\x66\xc0\xb8\xad\x56\x33\x63\x0e\x04\x59\x84\x12\x24\x98\x5d\x34\xba\xcb\x5e\x51\x8f\x3c\x42\x3d\x44\xbf\x01\x0c\xd2\xa1\x20\xc7\x4c\x8e\xe7\xd6\xe1\xe5\x0e\x9c\xc9\x18\x9e\x5a\xec\x09\x02\x52\x3e\x50\x0c\x06\x3d\x83\x8c\xf1\x40\x5f\x8a\x4e\xf7\xf4\xb5\xa0\xea\xac\x4d\xbf\x01\x9a\x9e\xd8\x7f\x4b\xfa\xf5\xfd\xe9\x4f\xae\xd9\x71\xe8\xf1\x67\xb7\xd1\xed\x69\x24\xc3\x68\x7b\xf4\xb9\x4d\x8f\x3e\x90\xb1\x3e\xc1\x00\x58\x77\xf3\xf9\xf4\x88\x8d\xd8\x4e\x68\x43\x3e\xde\x32\xf8\x2c\xb2\x13\x46\x11\xb8\xf0\xec\x8a\x3d\xec\xe3\xc8\x6e\x8e\x51\x8d\xa9\x30\x2e\xce\xd2\xba\x28\x57\x51\xb1\x27\xda\x29\x7a\xec\xf6\x20\xce\x06\x71\xbd\x9a\x2b\x34\xdb\x34\xd0\xac\x01\x1a\xaa\x7c\xe6\xcc\xbc\xd6\x84\x4c\x23\x35\x67\xa9\xad\x1b\x49\xd7\x25\x4d\xc8\xc4\xa2\xd5\x49\x25\xd1\x19\x0a\x2a\xc3\x72\x70\x15\x61\xef\xf4\xbd\xdb\xee\x99\xd1\x68\xa8\x82\x55\xb3\xaf\x98\x7d\xce\x39\x0d\x7a\x75\xa4\x7f\xe9\xe1\x37\xa4\x36\x69\x32\xfd\x00\xee\x57\xf8\x79\xe3\x06\xba\x05\x08\xa0\xf9\x21\x41\xb0\xf9\x5d\x1d\x62\x95\xdd\xc0\x8d\xdf\xfa\x46\xdf\xa9\xbf\x7c\x27\xf1\xe0\x1b\xdc\xb7\x20\xf5\x92\xbe\x05\x88\xed\x5c\x78\x0e\xa9\x69\xf7\xa2\xe7\x8b\x53\x29\x83\x37\xa4\xd5\xd2\x9c\xcf\xeb\xa5\x69\xae\x30\x46\xc5\x80\x07\x1a\x7c\x1e\x9f\xa7\x53\x34\xf8\xbc\xbe\x76\xdf\x0c\xdf\x22\x1f\x6b\x80\x3e\x1f\xba\xbf\x68\xa6\xe2\x9d\xf2\x76\x8a\x14\xdd\x29\x57\xdb\x29\x2e\x41\x8e\x5c\xa6\xea\x87\xc4\xea\x65\x43\x58\x51\xa7\x79\x93\x81\x62\x8a\xa9\xe7\x52\xdc\xdb\x38\x88\xae\x5b\x07\xb6\xbc\xfb\xd8\x69\x73\xd6\x5f\x74\xe0\x53\xf3\xd5\x6b\xcf\xb9\x61\xe1\xc2\x33\x4e\x5b\xb2\x76\x5e\xc2\x05\x83\xae\xc4\xe2\xd3\x7b\x4f\x71\x68\x4c\xf3\xe6\x5d\x7a\x66\x67\xf7\x9c\x9e\x2e\xe4\xc2\xef\xee\xec\xed\xea\xc8\xc6\x4f\xa1\x80\xe0\x33\x53\xad\xa9\x98\x4a\xaf\xa7\x38\x9e\xe2\x01\x07\xc9\x9c\x05\xb6\x53\x54\x96\x75\x6a\x91\xde\x35\xeb\x55\x1a\x55\xa7\xa8\xb1\xe5\xa6\x61\xe2\x39\x42\x0c\xe7\x47\x49\x48\x34\xcb\x38\x50\xa8\x8b\x2f\xe9\xbe\xed\x06\xa9\x75\xdd\x3a\xfa\x6b\x7a\xdb\x1d\xc2\xc0\x57\x38\x5b\x88\xcf\x25\xeb\x3b\x4a\x5a\x09\x3f\x26\x33\x3b\x1c\xd4\xac\x54\xb5\x0d\xe9\x36\x8b\xce\x24\x68\x59\x13\xeb\x74\xe1\xd8\x1b\xad\x87\xac\xc9\x64\x21\x2d\xe1\x36\x03\xa5\x7e\x40\x4d\x1b\xa0\x9a\xe1\x01\xdf\x29\x02\x1b\xfa\x32\x67\x02\x3c\x18\x97\x4a\x09\x48\x8e\x05\x96\xd1\xdb\x8a\x5b\x41\x62\x3b\x21\x39\xda\x53\x87\x78\x3c\xa2\xa2\x3f\xa7\xff\xb1\x7c\x0b\xdf\x3c\x35\xbd\x78\x6a\x33\x7f\x75\xd7\x32\x6e\x01\xb8\xff\x5b\xe3\xc9\x70\x7d\x02\x27\x3a\x39\x69\x24\xd8\x2c\xad\x04\x7f\x15\x6e\x00\xb7\x7c\x3c\xf0\x15\x14\xde\x91\xe6\xcb\xf6\x70\x27\xa2\xeb\x31\x64\xa6\x41\x1b\x99\xad\xf4\x33\xde\x96\x88\x60\x89\x51\x57\xa4\x3a\x8f\x13\xeb\x51\xbb\x63\x83\xb1\x9e\x60\xf1\x86\xe2\x67\x8a\xa1\xb9\x18\x39\xbe\x6e\x9b\x60\x32\xa8\xb5\xea\x4e\x31\x44\x59\x8d\x41\xe0\x51\x69\x68\x07\xa7\x35\xc7\xc2\x5e\x96\x46\x97\x10\x0d\x90\x31\x20\xb9\x79\xea\x4c\xd4\x27\x99\x93\xdd\xfd\xe3\xd8\x4f\x04\x71\x3c\x3c\x4e\xec\x07\xe2\x71\x21\x19\x3f\x99\x5e\xb5\x41\xfa\xe0\xbd\x76\x30\x4e\x9a\x0b\xaa\xba\xc1\xb2\x29\x60\xf4\x64\xb0\xac\x1b\x54\xcd\x95\xc0\xb8\xf6\xf7\xa4\x0f\x36\x4c\x96\x9e\x98\x02\x56\xcc\x93\x62\x09\x07\xad\x06\x3e\x47\x22\xe1\x91\xfa\x00\xe9\xfc\x91\x7a\xc1\xcd\x9e\x44\xc2\x21\x7d\x94\xfe\xc5\x91\x00\x6f\xcd\x93\xfe\x26\xa7\x86\x11\x9d\x35\x1c\x3d\x42\x7f\x0c\x9f\x47\x5e\x17\xe2\xa1\x4c\xdc\x47\x83\x47\x3c\x16\x97\x90\xb8\x4f\xa7\xe8\x15\x4a\x85\x19\xc2\x22\xe1\x2c\x81\x15\x04\xb6\xc4\x0f\x5c\x7e\x00\xcd\x7e\xa0\x57\xf9\xc3\x61\x77\xa7\x18\xe6\xb4\x7a\x56\xdf\x25\xb2\xf6\x21\xe3\x5d\x7b\x66\xce\xc4\xba\xea\x77\xe2\x41\xb8\x11\x90\x0c\xe6\xb6\x67\x18\xa6\x26\x3b\xa0\x7b\xb0\x4e\x52\xa5\xa6\x43\x53\x16\x4b\xbd\xe3\x6e\x0d\xcc\x38\xe7\x92\xcb\x96\x4e\x3b\x63\xcd\x49\x73\xc5\x85\xc5\xdd\xbe\x82\xba\x2b\x97\x3c\xd9\xdf\x7b\x22\xf8\xd4\xb4\x6c\x82\xf4\x5a\x89\xaf\xd1\x33\x63\x5e\xbb\x38\x69\xc6\xc4\xe9\xb3\xdc\xb6\x8b\x3e\x0f\xac\x3d\xb7\x6b\x89\x4f\xe1\x25\xc6\x89\xee\xdf\x83\xfb\x9e\x55\x76\xbb\x47\x2d\x08\x26\x8f\xc9\xab\xd8\xda\x10\x7a\xec\x02\xa5\x02\x7a\x56\x45\x66\xd0\x20\x33\xc1\x6c\x45\xaf\xac\xf2\x54\x52\x44\xdf\xd9\x2c\xbe\x1c\xd8\x51\x0c\x20\x39\xe4\x93\x33\x2b\x51\x11\x86\xbf\x17\xdc\xc1\x19\xfc\x75\x60\xeb\x72\xb0\x13\x7f\x5f\x2e\x9d\xba\x4e\x6a\xc3\xdf\x71\xfa\x3e\xe1\x4a\x3f\x08\xfe\xb1\xc2\x95\xc8\xe6\xf0\x1b\xa5\x82\x5e\xfc\x44\xf1\xe9\x9d\xec\x5a\x4b\x21\xfc\x17\x62\x7b\xb5\x66\x80\x7a\x39\x2b\x23\x3e\x21\x70\xcd\x49\x55\x5b\x8d\x46\xbb\xda\x60\x30\x79\x30\x80\x32\x78\x94\x0f\x09\x0c\x3b\x7a\xee\x42\x42\xd0\xa6\xb2\x1a\x19\x9a\x77\xd9\x0c\x6a\x19\x2a\x6d\x0e\x54\x83\xf3\x75\x8e\x13\xba\xc9\x28\x27\xe1\x98\xc8\x24\xa2\x5c\x05\x40\x19\xb0\x0d\x7d\xa0\xfd\x74\xe9\x47\xd0\x3d\x43\xda\x74\x92\x24\xad\x1d\x84\x2e\x4b\x82\x5f\xa7\xbf\x76\xe0\x66\xb4\xad\xa7\x64\x88\x10\x50\x56\xc4\xaf\xaf\x90\x99\x23\x9d\xa9\x38\xcf\x30\x6e\xb3\xce\xad\x23\xe1\x71\xc4\x82\x76\x3b\xd5\x25\xda\xed\x3a\xb3\xd1\xdc\x29\x1a\x6d\x5a\x86\xcc\x59\xe0\xc9\xac\x85\xdc\x00\x8e\x73\xc8\x6c\x19\xf9\xcc\xc8\x01\xcf\x0f\xe1\x44\x20\x4d\x1c\x3e\x39\x72\x71\x65\xe9\xf8\x78\xc9\x79\xf4\x8f\xe4\x36\x8e\xc6\x13\x4d\x33\x46\x85\xea\x4c\xaa\x44\x40\xe5\x39\xe9\x47\xa4\x8a\xb4\x83\x17\x02\x05\xe9\x5f\xd2\x7b\x07\xe7\xda\x0c\x7f\xae\xd1\xcb\x3e\x6a\x39\xba\x17\xb9\x46\x44\x4c\x95\x41\x41\x70\x22\x81\x98\x57\x1f\xe2\x14\x4c\x5a\xbd\xb6\x53\x64\x68\x3b\xaf\xb7\x69\x08\xda\x2d\x66\x16\x12\xcc\x27\xb3\xcd\xa7\xe8\xac\x83\xa8\x3f\x0e\x35\xfd\x3f\x28\x06\x49\xdb\x09\xb2\x73\x79\x61\x49\x2a\x95\xcb\x0b\xb2\xef\x09\x4d\x50\x85\x84\xb7\x41\xe5\x55\xb5\xab\x66\xa8\x16\xa9\x90\xc6\x54\xa9\x38\xda\x63\x37\x09\x9c\x40\x78\xe3\x78\x5c\x71\xac\x4b\x70\xec\x4c\x2b\xe1\x98\xe4\xca\x60\x32\xf2\x0f\xf8\x42\xda\x0e\x66\x0c\xde\x02\x58\x26\x5d\x2e\x93\xcd\x71\x66\xd7\x64\x60\x13\xa8\xb6\x54\x91\x49\xd0\x23\xab\xd4\x6a\xa3\x6c\x9c\xad\xc2\x86\xe0\x12\x4c\xb2\x9e\xe4\x35\x36\x19\x00\xda\x88\xbe\x06\x89\x28\x79\x2c\xf9\x67\x0f\x3d\xe4\xb0\xf0\x87\x63\x8e\x99\x21\x12\x59\x8f\xca\x7a\x28\x84\xeb\xb4\xc8\xf9\x26\xe5\xec\x04\xc0\xaf\xc7\x64\x6b\x54\x67\x93\xf3\x8e\x4f\x59\xd4\x06\x60\xb0\x40\xf9\xbc\xb4\x11\x02\x8b\x65\xe7\xd1\x0f\x52\x36\xad\xa1\xcd\x22\xa8\x4c\x02\x92\x4b\x82\x59\xd6\x45\x83\x43\xb1\x32\x51\xaa\x9c\x11\x1e\xb8\xc4\x33\x57\xd9\xcb\x39\x51\x38\x1b\xeb\xfb\xc2\x0b\xa4\xd6\x2b\xa3\xdd\x4b\xe2\x75\xb0\x5f\xfa\x31\xab\xf3\x05\xe1\x0e\x60\xc0\xe7\x73\x49\x63\xe0\xcf\xb0\x1f\x9d\x6f\x06\xb1\xb1\xc6\x4b\xed\xcc\xc7\xec\xa5\x08\xaf\x65\x54\x3d\x75\x46\xaa\xb9\xda\xab\x52\x95\xb8\xf4\xfa\x48\xa1\xa5\x3c\x62\x89\x34\x0c\x0f\x0e\xaf\x18\x4e\x9b\x87\x03\x23\xf4\xb8\x90\xc9\x48\x55\x26\x6c\x89\x4e\x31\xe8\x77\xd8\x38\xc5\x28\xf1\x54\x97\x14\xd5\x51\x75\x9d\x22\x67\x82\xb8\x76\x2e\x27\x5d\x99\xa1\xfe\x4c\x99\x6a\xbe\xc2\xcc\x34\x8f\xcb\xb5\x74\x76\x9f\x2c\x6f\x6a\xaa\xeb\x54\x78\xef\x0e\xb2\xfa\x1d\x31\x2c\x61\x79\xb5\x32\x97\x04\x70\xca\x0a\x1c\xc0\xe1\x5c\x2f\x89\x4a\xc2\x8d\xc5\xa2\x5f\x75\x96\xb4\x70\x35\x33\x6b\xae\xf4\xdc\x43\xf7\x8e\x99\xc1\xae\x00\x76\x38\x6d\xe9\x15\x7f\xde\x35\x70\xf8\xf1\x09\xcd\xa9\xb6\x67\x60\xf2\x89\x09\x29\xd7\xc4\x70\x9f\x68\x75\xf3\x6d\x63\x7e\x72\x96\x97\x3b\xff\x7d\xf2\x98\xd1\xe0\xc3\x6f\x81\xa6\xf0\x91\x1f\x9d\x09\xe9\xee\x07\x53\xff\xf9\xea\x4b\xe9\x27\xf0\xa1\xb4\xae\x80\xfe\xca\x2a\x2d\x07\xe7\x07\xd2\x76\x13\xf7\x77\x72\xaf\x16\x84\xac\xcf\x08\xde\xa6\xcb\x74\x28\xad\x64\xdc\xa4\x17\x7d\x6a\xaa\xd2\x62\xd3\xd2\x36\x9c\xcf\xb4\x3b\x82\x8e\x0a\x47\xa7\x03\x52\xd6\x07\xac\xc8\x56\xb2\xca\xa1\x1d\x24\xd4\x58\x33\x4e\x5a\x22\x9b\x4e\x9b\x31\x44\xf3\xf2\x95\xe5\x24\x95\x9b\x17\x61\x3b\x4e\xae\x12\x99\x4e\xd8\xe0\xcc\xb0\xd1\x4a\xbe\x79\xb6\x6c\xcf\x21\xda\x44\xc6\x91\x6b\xd0\x68\x92\x7b\x42\xd1\x99\x5f\x27\x32\x77\x56\xaa\x8a\x72\xb2\x3c\x6f\x70\x1a\x02\x41\x0b\xcb\x42\x1b\x9c\x28\x9a\x6d\x01\x5b\xb9\x0d\x6a\xa1\xcd\x66\xd2\xf0\x06\x62\x75\x22\x9b\x5c\xbe\x54\x8f\xc6\x9c\x57\x92\x90\xe3\x39\x0f\x2d\xd1\xc3\xf1\x8c\xdc\x46\x28\x42\x93\xb9\x11\x37\xd0\x32\xa1\x75\xee\x05\x19\xc6\x3f\xed\xf2\x86\x65\x6b\xf1\x0b\xba\x68\x64\x67\x08\xdc\x93\xc3\xf8\x23\x6a\x8a\x37\x9e\x05\x9a\x33\x3a\x23\x42\x51\x2a\x9a\xc8\xb1\x99\xa9\x24\xaf\xd3\xb9\xb4\xb4\x85\x04\xd8\xb0\x1c\x4b\xf9\x3a\x7d\x8c\x39\x1b\x3d\xeb\xc4\xd1\x33\x33\x8e\x9e\x75\x92\xe8\x59\x67\xb6\x35\xea\x78\xa1\xa5\x5c\x0a\xfc\xe3\xc8\x59\x44\xc6\x37\x39\x30\x58\x83\xbf\xaf\x3b\x06\xe5\x59\xd4\x13\xc3\x1a\x9d\x5b\x3a\x89\xfd\x85\xcc\xbc\x59\x88\x3c\x68\x1f\x3a\x39\xed\x43\xe7\xf6\x07\x70\x6c\x2c\x15\xe8\x0c\x30\x66\xb3\x37\xe0\xed\xf1\x42\x1e\x7a\xff\xff\x03\x20\x13\x4b\xae\x0e\xfc\x2f\x40\x20\xb2\x39\x16\x8c\xe3\x12\x4f\x0e\x11\x05\xc1\x5f\xb0\x8f\x50\x80\x68\xe8\x63\xc5\x07\x3b\x39\x15\x82\x5e\xaf\xd1\xa1\x56\x1b\x2d\xd0\xe7\x87\xc8\xe2\xc0\xcb\xbd\x3b\x60\x0f\x5c\x02\x91\x12\x81\x50\x6f\xc1\xa1\x40\x97\xd6\x88\x04\x1a\x11\x67\x34\x16\x69\x7a\xe4\x80\xe9\x8d\x4a\x6f\x47\x36\x27\x13\xb7\x1c\x37\x34\x96\x5f\xc8\x42\xb2\x86\x20\x13\x61\xa7\xa7\xac\x3b\xf9\xed\x83\x7b\x3f\x95\xd6\xad\x5b\x5d\x13\xaf\xa3\xd9\x2b\x56\xaf\xba\xb2\x0b\xf6\x23\x0d\x72\xc7\xaa\xf3\xb7\x9e\x85\x05\x1d\xad\xb9\x1f\x18\x06\xb6\x4f\x9f\x8d\xbd\xad\xac\x1f\xc9\x56\x20\x18\xe4\xd8\xd8\x69\xa9\x11\x1c\x84\xf6\xa0\x41\xa3\xb1\x47\x83\xf6\x60\x61\x0c\x7d\xb7\xda\x91\x42\x54\x1f\x53\x15\x6c\xd5\x5a\x35\x9d\x62\xc4\x6a\x0b\xb8\x1d\x7a\xad\x1e\xd9\xc9\x5a\xf3\x31\x09\x14\x67\x36\xac\x71\x4c\x5c\x03\x8f\x67\x51\xce\x2e\xe4\x03\x16\xab\x61\x73\xd8\x05\xdc\x8b\x21\x99\x8b\xc0\x22\xe0\x2d\x58\x87\xd4\x4f\x86\x5f\x3a\x65\x50\xe0\x8c\x1c\x28\xd1\xad\x8d\x19\xe4\x1b\x7c\x4f\xd8\x4e\x3c\x45\x81\x71\x46\xaa\x16\x03\x07\x39\x3b\x47\xe2\x63\x08\x92\xdf\x03\x0d\xc3\x6d\xb5\xc9\xb0\x61\xd0\xfe\xa8\x0a\x4b\x89\xbf\xfe\x2e\x40\xc7\x02\xf1\x3b\x47\x27\xfd\x8e\xca\x7c\x56\x0f\x35\x3f\x35\x42\xe3\xb1\x01\xb7\xdb\x64\xc3\x26\x0a\xf6\xe5\x11\xad\xb5\x23\xfd\xb4\x88\x42\x27\xa5\x28\x64\x56\x39\x78\x47\x97\xc8\x23\x43\x26\xae\x3e\x53\x0d\xa1\x59\x8d\x4c\x77\xb5\x5e\x8f\xac\x44\x3d\x47\x0d\xba\x22\x43\x05\xd5\x60\x62\x0b\x67\xb6\x42\x4a\xbf\x90\x92\x85\xc6\xb9\x2d\xd9\x31\xa9\x0b\xbd\x0d\xb6\xa8\xcf\x5c\xbb\xb0\xad\xa8\x6e\xdb\xea\xd7\xde\xfa\xed\xcb\xc9\xe7\x06\x7b\x2f\xb8\xe9\x66\xb5\xb4\x98\x36\xed\x78\xb8\xfc\x0e\xa0\x0a\xfc\xf8\xcd\x0f\x52\x3a\xee\x6d\xf4\xdc\xb7\x8b\xf0\xc5\xd1\x23\x6c\x3f\x99\x55\x1a\xa5\x96\xa5\x52\x82\x5a\x1d\xb4\xb2\xac\xc1\xed\xa6\x0c\x54\x61\xcc\xe1\xeb\x14\x1d\x9c\x80\xe4\xa8\x41\xf0\x0a\xed\xc4\xb5\x42\xb0\x08\x82\x59\x87\xab\x25\x70\xb9\xbc\xda\xa0\x33\x60\xb7\x9a\x8e\x74\xe6\x6c\x34\xa2\x86\x0a\xdb\xdc\x38\x8c\xbc\xcd\x62\x70\xdd\xd1\x90\x2a\x2f\x12\x91\xc9\x9d\x17\xc1\xf6\x4b\x6d\x07\xde\xd0\x48\x12\x26\x23\xc2\xf9\xb4\xee\xcd\x43\xf9\x93\x23\xf8\x2f\x3e\x94\xad\x2d\x59\x12\x48\xdb\xdf\xfc\x28\x67\x7a\x04\x8d\xe7\xaf\xc3\x4d\x88\xae\xac\xe8\x4e\xe6\xa6\x6a\xac\x8c\x4b\xcd\xa8\x8d\xd0\x6b\xb1\x18\xb5\xd0\x08\xfd\x3e\xc6\xea\xb1\x22\x78\x3c\x40\xc3\x7a\x3c\x9c\xd6\x08\x2d\x1c\xf2\x27\x29\xce\xa6\x25\x53\xb0\x14\xb2\xca\xb6\xaa\xe4\xab\x91\x3c\x76\xc9\x08\x32\xe4\x2c\x0b\x78\x70\x43\x4e\x74\x2c\x22\x28\x13\x80\xbe\xf8\xb8\xeb\xfd\x39\x4b\xc0\x65\xe0\xba\x75\xeb\xa4\xbe\x33\xb7\x6c\x99\xb7\x76\xc9\xdb\xa7\x27\x1c\x60\xb1\x63\x63\x2f\x75\x54\xe1\x08\x37\x32\x9b\x5f\x9c\x2e\xee\xc9\xc4\x09\xd8\x2b\x2c\x85\x38\x4e\xc0\xab\xa8\xd6\x35\x14\x65\xdb\x41\x87\xf9\x42\x7a\xe7\xd1\xef\x77\x04\xc2\x66\x5b\x5e\x7d\xad\xfc\x7e\x93\xf2\x7e\x5c\x1f\x79\x3d\x99\x1b\x05\x69\x55\xb9\xcf\x6c\x95\xe7\x46\x61\x7f\x06\xd9\x7d\x2b\x90\xdd\x94\xa0\xae\x45\xf4\x70\xf4\xdb\xd4\x70\x2d\xd7\xa6\x55\x15\x16\xba\xe2\xc1\xa0\x10\x17\xca\xca\x97\x96\x3f\x50\x4e\x9b\xcb\xcb\xcb\x69\x2d\x8c\x17\x16\x15\x76\x8a\x45\x36\x3b\xa2\x0b\x97\xdd\x63\x88\xa6\xa2\x11\x73\x64\xa2\xa8\x4d\x50\xc8\x96\x52\xe1\x59\x95\x76\xf4\xef\x55\x78\x57\xa8\x99\x33\xa3\x7f\x61\xe6\x18\x24\x3b\x19\x4a\x26\x0c\x84\xaf\x6c\x6f\x32\xfe\x72\x73\xfb\x9c\x83\x25\x19\xb9\x46\x95\x3c\x84\x92\xc2\x3b\xed\xe5\x4c\x25\xfe\x4f\xde\xe4\x87\x6b\x6e\x55\x91\xec\xe0\x97\x9a\xcc\xa6\x3c\x82\x60\xfb\xc5\x9b\x41\x15\x60\xa5\xdf\xd4\x6d\x8f\x35\xad\x3d\xeb\xda\x2d\x23\x27\xc9\x23\x5e\xee\x98\x75\xde\x7a\x69\xce\xea\x8b\x99\xbb\xb6\x39\x13\x9f\x4c\x5a\x71\x4a\x59\x71\xe3\x65\x17\xa6\x47\x3c\xf7\x92\x3c\xda\x85\xfe\xa2\xdf\x97\x8e\x61\xda\x61\xcc\xb2\x1f\x0b\x05\x8c\x6f\xf8\x31\xc1\xf7\xaa\xf5\x64\x0a\xd6\x78\x4e\xd0\x52\x64\x8e\x79\xb6\xc7\x05\xf3\xce\x69\xa9\x94\xde\xe2\x62\x79\x2b\xe2\x1d\x17\x91\x55\x3c\xe4\x11\x39\x19\x78\x2f\xdf\xce\xcf\xe0\x17\xf1\x88\x6b\x78\x1e\x6a\x34\xc8\x31\xf4\xe8\xe3\x7a\x1a\x9a\xf5\x88\xf7\xf5\x1a\xce\xe5\x20\xa3\x1f\x87\x4c\x69\xfe\xc3\x0a\xdc\xe8\xe0\x3e\x47\xb2\xf2\x21\x0c\x95\x26\x93\x3a\x78\x22\xe9\x8b\xf9\xd7\x5b\x17\x6e\xab\x8b\x4f\x5a\xf9\x2b\x0f\x4e\x92\xee\x66\x6f\xbb\x73\xcb\xa2\xfa\x82\x62\xf0\xdd\x97\xe9\x80\xf4\xeb\x1d\xe5\xd2\x2d\x9d\xcf\xdf\x13\xa2\x32\x39\x79\xfa\x6f\xc4\xce\x3f\x89\x52\xe6\x32\xd1\x16\x92\xa3\x6f\x27\xaf\xb5\xe8\x75\x35\xa1\xa3\x1f\xe4\x19\x65\x2f\x51\x94\xf9\x41\x5c\x60\xfb\xdd\x0e\xaf\x4e\x29\xb0\x1d\xda\x77\x83\xf8\x0d\xf9\xc9\xec\x16\xc4\x6f\x11\xaa\x14\xc9\x95\x96\x80\xd1\xe8\x13\x4a\x4b\x7d\x3e\x26\xe6\x60\x1c\x89\x32\x21\x8e\x78\x4d\x08\x08\x1d\x42\x8f\xb0\x44\x16\x29\x6e\xb3\xbb\xb4\x53\x74\x23\xca\x72\xdb\x14\xe1\x82\x47\xba\x9b\x29\x6d\x17\xa2\x1f\xfb\x90\x32\x88\xfc\x94\xd4\xa0\x01\xc1\x2b\x45\x11\x83\xe9\xfe\x63\x2b\x6b\xf9\x10\x76\xac\xb3\x0a\x60\x43\xc6\x8d\xe6\x88\x87\x0d\x6d\x59\xc1\x2f\x7d\x89\xdd\x6c\x28\x10\x7d\x60\x95\xbd\xe9\xac\xab\x3d\xa8\xaa\x65\x67\x7b\x8e\xa2\xaa\x89\x0e\x63\x37\x91\xf9\xe8\xc5\xd4\x86\xd4\x58\x2f\xc7\xc1\xe2\x62\x9f\xd1\x68\x2b\x50\xdb\xd4\x25\x71\x2a\x0e\x3c\xb0\xc8\xec\x45\xa4\x00\xb1\xfd\xd4\x81\x2c\xa8\x25\x5e\x84\x03\xaf\x57\xa0\x38\xa3\x4d\x40\x4e\xad\x60\xd3\x15\x63\xa9\xea\xf7\xd8\x89\x0d\xe5\x24\xb3\x72\xb3\x66\xec\xd0\x7a\xda\xe4\xb1\xf1\x84\x6c\x4d\xed\x1f\x57\xd4\x22\x75\x97\xc1\x03\xfc\x74\x10\xf0\xf3\xb3\xa2\xf6\xcc\x75\xe0\x22\x02\x7f\xae\x79\x92\x71\x6d\x33\xc2\x16\xbb\xbd\xb9\xb6\x0a\xd9\xa5\x03\x3f\x21\xfe\xd8\x1e\x59\xae\x84\x88\x5c\xf1\xfb\x41\xc4\x29\x44\x04\x1c\xf4\x0e\xc6\x3e\x88\xc1\xd1\x15\xb1\x0d\xb1\x6d\xb1\x07\x62\x4c\x0c\x9b\x5c\xb6\x78\x45\xdb\xd3\x31\xb0\x2d\x06\xa8\x18\x47\xde\x81\x6c\x63\xfc\x9b\x87\x03\xe1\x36\xf2\x0e\x9f\x60\x6f\x8b\xf8\x71\x6e\xac\x53\x0c\xd9\x6c\x06\x9f\x0f\xb1\x1b\x92\x40\x51\x2a\xfa\x7f\x91\x40\x7c\x8e\x37\x1d\xc7\xb3\x71\x97\x2d\x8b\x2f\x1f\x64\xb8\xe4\x1f\x08\xa1\xbc\x35\x9d\xc7\x13\x3e\x18\x87\xbf\x23\x76\xfe\x42\xc2\x1d\xe3\x06\x45\x8e\x52\x0f\x83\x70\x86\x65\xce\x97\x72\xbd\x6e\x66\x3e\xdf\x08\x6f\x00\x98\xe5\xd9\x7b\x72\x7c\xed\x0a\x52\xa7\x7b\x6a\xaa\x61\x30\x2a\x12\x8e\x50\x11\x2e\x52\x11\x81\x26\x25\x8c\xd6\x21\xda\x54\xbc\xcb\x96\xad\xcc\xa5\x53\x72\x34\xa4\x43\xd4\x59\xd5\x4a\x54\x47\x06\x3c\x53\x83\x3b\xf8\x93\xdf\x8d\x88\x1c\x37\x52\xa8\x25\xa5\xb8\xc7\x8d\x8b\x80\x67\x70\x35\xee\x1f\x47\x0d\x19\x97\x5c\x8d\x4b\x65\xfd\x7a\x76\x2d\x57\x88\xfd\x7a\x5c\x1f\x46\x3d\x86\x70\x50\xb8\x8b\x2a\x45\x34\xc0\xf3\x6d\xa5\x98\x16\xf4\x7a\xf2\x98\xd2\x69\xb5\x6d\x80\x0e\x16\x19\xed\x08\x39\x71\xa4\x9c\x01\x55\x20\x9d\xc6\x38\x10\xef\x39\xa8\xbe\x54\x2d\x92\xc7\x0e\xb5\x49\xe5\x70\x98\x70\x1e\x80\x73\x55\xb8\x10\x76\x4c\x0e\x9b\xa3\x53\xe4\x6d\x36\x64\xd5\xd8\x96\xe0\x59\xe2\xc8\xb0\xb4\x1c\x37\x52\x84\x59\x6b\x66\x79\x86\x54\x8e\x75\xb8\x8e\x0d\x13\xc9\x39\xfd\x5b\x73\x51\xd1\x9b\x6c\xae\x96\xa6\x64\x42\x2f\x39\x3e\x96\x74\x1a\xb8\x8a\xc4\xb9\x7a\x8f\x1e\xd1\x52\x6c\x3b\x35\x0c\xc7\xe6\x2a\x98\x5a\x4b\x6d\x11\x0c\xeb\x9c\x61\x67\x7d\x83\x31\x11\x4d\xf4\x88\xb0\x8e\xaa\xeb\x11\x2d\xc5\xc5\xe8\xf6\x03\xb6\x28\xa3\x4e\x06\x92\x3d\xa2\xcf\x13\x10\x72\xc6\xc2\x21\xb2\xe6\x33\x75\x40\x39\x45\x62\x99\x5d\x41\xf8\x80\xf9\x6d\x45\xbc\x92\x6d\x0d\xe1\x25\xeb\x99\x46\x0e\x5e\x69\xe4\x20\xf3\xdc\x71\x75\x09\xdc\x4e\x3b\xfb\x2b\x76\x4e\xfe\xe6\xc7\x27\xf7\x4e\xb9\xb6\xd6\xd3\xfa\xec\x7e\xe0\x07\x25\xd2\x56\x69\xd7\xb3\xef\xbd\xf7\x34\xe9\xef\x28\x06\x81\xfd\xcf\xb6\x7a\x6a\xaf\x9d\xf2\xc2\xee\x1f\xbf\x99\xbc\xb3\xa2\x9f\xde\x5b\xeb\x96\xd4\xde\x22\x50\x09\x62\xa0\x09\x94\xd6\x54\xde\x01\x82\x8d\xd2\x9f\xa5\x6d\xd2\x53\xd2\x2d\x8d\x8d\xa0\x17\xb4\xa2\xaf\x99\x8d\xd2\x07\x77\x54\xd6\x48\x87\xa5\x67\xa5\xb7\xa4\x83\x45\x5e\xf0\x8b\x5b\x91\x1f\x47\x8f\x30\x5f\xa3\x7b\x0c\x51\x65\x29\x9b\x60\xa1\xd4\x16\x75\x38\x62\x70\x38\xdc\x8c\xc5\xec\xb7\xdb\xf5\x26\x7b\x76\xd1\x6f\x7e\xf3\x68\xee\x8c\x6e\x3d\x88\xe0\x04\x65\xd2\xee\xf0\x64\x1f\x47\x02\xe6\x64\x3c\xb1\xbb\x5c\xfa\x69\xc4\xdb\xe9\x11\xd2\x67\x01\xe7\x6e\x7d\xf4\xfe\x27\xe2\x0e\xf4\x70\xc7\x92\x80\x27\x33\xbd\x7b\xca\xea\xf4\x74\xba\x24\xfd\x06\xbd\xbf\xf3\xb4\x61\x1b\x7b\xa5\xe1\xe0\xda\xe5\xa7\xd6\xa0\x27\x13\x81\x61\xfc\x79\x58\xc7\x39\x95\x5c\x2b\xee\x1f\x59\x98\x1a\xee\xb7\xc5\x62\x26\x55\x98\xa2\x1c\x2a\x03\x13\x2f\xb5\x9a\x79\x73\x8f\xe8\x2f\xec\x15\x9d\x06\x83\xd1\xa7\xd6\xe0\x1a\x0b\x9b\xd1\xa8\xeb\x15\xfd\x46\xbf\x91\xe1\x21\x13\x1b\x52\x6e\x41\x8a\xba\x32\x17\x48\x18\x2f\x93\x65\x76\xe4\xb4\xb1\x65\xab\x2e\xe4\x16\x02\xa5\x8e\x2b\xc4\x2b\x25\xd4\x79\x25\x18\x1e\x92\xe8\x37\xbf\x31\xc9\xd3\x0a\xae\x21\xf9\xfe\x6b\x46\x79\xfc\xbb\x4f\x34\xef\xfb\xe2\x97\x17\xe5\x72\x00\xb0\x04\x27\xfe\xe1\x3f\x2d\x87\xc0\xf0\x39\x38\x0f\x3b\x47\x7a\xfe\x90\x5a\x2f\xed\x7c\xe6\xa9\x6c\x8f\x04\x8d\xfb\xb9\x19\x37\x99\x9b\x59\x4c\xcd\x4b\xd5\xf9\x6c\xc5\xc5\x26\x55\x81\x0c\x6b\x49\x1c\xc3\xda\x21\xf2\x94\xaf\xa8\x53\x86\xd6\xc7\x18\xbd\x18\x62\x1c\x0d\x30\x33\x48\x95\x31\xaa\x0e\x91\xb1\x1d\x6b\x41\x13\x20\xa9\x21\xc3\xb8\x8f\x0b\x67\x56\x65\x29\x83\xbd\xaa\xec\x59\xcd\xc5\xb8\x89\xd6\xe2\x71\xb8\x10\x34\xac\x03\xdb\xd6\x81\xe1\x38\x88\x68\x41\xfa\x4c\x1a\x4d\xb4\x17\xe0\x65\x5d\x8d\xe3\x87\xe0\x46\xa2\xb5\xe6\xe2\xb8\xa2\xf4\xf0\x2a\xe9\xf1\xac\xe2\x02\xd4\xb8\xa3\x47\xd4\x13\x11\x2f\x26\x90\xd5\xd2\xe8\xe3\xf9\x52\x00\xfc\xe6\x02\xca\x0c\xed\x5a\xbb\xb6\xac\x3c\x54\xdc\x23\x16\x84\x18\xc0\xf9\xb8\x5e\x11\x99\x33\x56\x97\xd7\xe1\x72\xe0\xda\x87\x4c\x05\xa7\xd6\x80\xfb\xa9\x70\x37\xd5\xd0\x78\xff\xe0\xde\xa6\x9c\xf9\x7e\x8e\x5c\x55\x9d\xdf\x59\x05\x87\xe8\x6a\x4b\x7e\xa3\x15\xfb\x76\x7e\xa3\xd5\x93\xd2\x55\xb4\xf4\xef\x6c\x3d\x8a\x51\x00\x33\xc1\xa8\xdf\x6f\xbb\xea\x01\x0d\xf9\x4d\x31\x20\x09\x1a\x72\x9b\xb0\x48\xbe\x8d\x6d\x41\xf6\x6d\x31\xf2\x6d\x87\xa9\x0a\x0a\x8a\x05\xbb\x5d\x1d\xf6\x18\x6d\xe1\x62\xb6\x24\x5e\x50\x1c\x2b\xee\x10\xed\x11\x15\x72\xfc\x04\x95\x8a\x8e\xd9\x02\xae\x2e\x31\x60\xd7\xf1\x9d\xa2\x51\xc7\xc9\xaa\x86\x36\xe7\x4f\x09\x94\x87\xd1\xe7\x0a\xa9\x9c\x64\x63\x56\xa0\x26\xe5\x39\x1e\xf9\xb6\xad\x3c\x07\x3b\x16\x91\x91\xf2\x18\x16\xae\x9f\x19\x3f\x7b\xf9\x18\x4b\x17\x59\xc0\xef\x7d\xa2\xfa\x24\x27\x2a\x7f\xdf\xc1\x7f\xe6\xd8\xbd\x8d\x05\xc5\x9f\x7f\x2b\x9d\x4b\x02\x0e\x74\x76\xe7\x9f\x8b\x0a\x50\xb3\x53\x15\x7e\x33\xc7\xd9\xd4\x06\x2f\xe3\x83\xd0\xe0\xb3\x39\x6d\xce\x60\x88\x31\xfb\x11\x23\x7b\xfd\x6e\xf4\x9f\xe0\xb3\x33\x06\x35\xe4\x04\xae\x47\xd4\x01\xc1\x92\x97\x51\xcd\x1d\xc2\x30\x38\x16\x26\xa3\x46\xb1\xe5\x8e\x8b\xf8\xa0\x2a\x6b\x3a\xc4\x60\x76\x3f\x20\xa8\xad\xd3\x03\x3b\xbb\x53\xd2\xad\x78\xe2\xec\xb9\xd2\x15\x73\x37\x3c\xb9\x44\xda\xac\xec\x0a\x1c\xf8\xae\xe4\xf2\x9d\xbb\xb7\xd4\x78\x68\x73\xeb\xed\xd2\x41\x12\x63\xac\xfc\xf3\xe8\xf4\x77\xd9\xf5\x81\x60\xe7\xea\x26\x5a\x97\xfe\x77\x0b\xe6\x55\x1e\xf1\xea\x9d\xf0\x21\x02\xd3\xfc\x54\xb5\x47\xe5\x56\xab\x0d\x4e\x68\x0b\x58\xdd\x56\x37\xc4\x6d\xed\xc1\x90\x4d\xe5\x41\x1c\x19\xf0\xe0\xaa\x03\x9d\xdb\x68\x36\x5b\xad\x4e\x03\x54\xeb\xd4\x1d\xa2\x05\xe8\x72\x32\xc5\xb2\x85\x34\x04\x34\xde\x91\x03\x98\x25\x03\x59\x4d\x2e\x40\xa4\x0b\x40\xe5\x03\x0e\x04\x96\xa3\xb6\x8e\xfe\x17\x82\x69\xd2\xf6\x19\xd2\x2b\xf3\xc0\xf5\x1b\xc1\xad\xcb\xa5\x33\x66\xdc\xd9\x39\xf7\xf1\x8d\x27\x47\xc2\xb3\x13\xae\x6d\xe7\x8d\x91\xae\x25\x16\xe5\xa2\x81\xad\x6e\x0c\xdf\x82\xd1\x1b\xb7\xb9\xd0\xbf\x7a\xbf\xa1\xa7\xb7\x41\x96\x41\xe3\x28\x4a\x53\x8c\xee\xaa\x98\x2a\xa7\xae\x49\xb5\x17\x38\x9d\xbe\x32\x73\x82\xe3\xd4\x06\x7b\xd4\x56\x58\x58\xca\x24\x20\x4c\x18\x6c\xd0\x57\xe4\x2b\xaa\xa8\x4c\x14\x32\x66\xc6\x51\xe0\xe8\x15\xcb\x4a\x4b\x0a\x0a\x3c\xc1\x88\x3f\xe8\xef\x11\x83\x90\xb3\xd9\x7c\x45\x10\x3a\x0d\x6a\x04\x7c\x8f\x28\xe8\x80\xc7\x92\x63\x0d\x29\xc4\x98\xc3\xb3\xf5\xc9\x6c\xed\x78\xce\x0c\x52\x04\x76\x95\x8c\x83\xaa\x41\xa7\xff\xf8\x17\x2c\x0c\xe1\x64\x21\x7b\xe1\x9a\xe2\x21\x17\xfe\x6c\xfa\xfd\x0c\x0b\xd3\x2d\x5f\xff\xd7\xcb\xa7\x2d\xe9\xaf\x73\x98\xf8\x15\x7a\x73\x1e\x31\xd0\x14\x42\x9d\xea\x46\x44\x0b\x18\x67\x9b\x53\x6d\x98\x8b\x3d\x71\x6f\x89\x37\x24\x38\xd5\x61\x4d\x48\x53\xce\x95\x98\xcd\x25\xce\x10\x2c\xd6\x15\xeb\x2a\x2a\x0b\xbc\x4e\xc1\x4c\x18\xdb\xc3\x11\xce\x2e\x8f\x27\x62\x88\xb9\x03\x76\x63\xcc\x56\xa2\x31\x1f\xc3\xd5\x18\x6f\x88\xa3\x2d\x19\x1c\x65\x82\xbb\xc7\x45\x54\x6e\x78\x44\xc8\xc1\x45\x96\x56\xe4\xb4\xc9\x10\xac\x01\x88\x09\x88\x30\x3c\xf8\x70\xef\x20\xed\x64\x09\xea\x5e\x69\x34\xe1\xf6\x45\x84\x98\xb2\xa9\xb8\xbb\x72\x29\x29\x91\x43\x63\x60\xa5\xb4\x99\x58\xa0\xaf\x66\xa8\x8b\xc6\xdb\x35\x55\x69\x44\x5b\x05\x54\x8c\x5a\x90\xaa\xe3\x62\x2e\x9f\xca\xa9\xd2\x17\x7a\x81\x57\x8f\xd4\x46\x44\x88\x14\x15\xb3\x06\xa7\xa1\x47\x8c\xfa\x9c\x4e\xad\xdb\x1b\x73\x23\xed\xed\x66\x00\x6f\x51\x45\x04\x98\xdb\x5c\xec\x90\xfb\x84\xb2\x12\x3f\x57\x20\x28\xc3\x6b\xc9\x37\x32\x90\x0d\x0f\xff\xc9\xa6\x1a\xd4\xc8\x78\x6c\x02\x23\xe9\x3a\xdc\x08\x09\xfc\x8c\xe0\xd0\x82\x90\x2a\x2d\xed\x3d\x63\xd4\xcd\x67\xe0\xa5\x7d\x67\xdc\x38\xfa\x0c\x69\xef\xda\x33\x4e\x3e\xe3\xba\x15\xd2\x78\xe6\x1c\xa9\xbb\xe3\x74\x71\xe2\xd4\x2b\xd6\x0e\xbc\x01\xfa\xd2\x75\x60\xf4\xce\xab\xd2\x4f\x63\x4a\xa0\x9b\xe9\xcb\x1f\x97\x9e\xa8\x71\x7f\xf7\xe2\x65\xad\x2c\xed\xee\xec\x4c\x7f\xc2\x86\x86\xcf\xdf\x2e\xbd\xe7\xa6\x0f\x83\xd7\x08\x3f\x55\x21\xd9\x37\x99\xf8\xe8\x85\x04\xe6\x42\x04\xb3\xca\xa9\x8f\x2a\x30\x87\x85\x70\xac\x08\xc3\xdc\x21\x16\xc8\x30\x17\xba\x0b\xf1\xe0\x52\xc0\xdb\x54\x61\x02\x73\x47\x26\xc1\xf7\xff\x03\xe6\x10\xd6\x60\xb1\x2c\xcc\xb8\x7c\x22\x07\x66\x3a\x40\x03\x21\xc4\x4e\xfe\xf1\xa4\xd2\xd3\xa6\x9f\x25\xcd\x5e\x37\x63\x61\xd9\x94\x7f\x77\x77\xa6\xc4\x35\xbd\xd2\xdb\x70\x98\xf4\xe1\xac\x55\x27\x8d\xea\x9c\x9a\xbe\xee\x88\x14\xfb\x64\xd5\x74\x56\xba\xd8\x99\x48\x38\xc1\x2a\xf6\xa4\x33\x3f\x29\x75\x6d\x3f\xbf\xaf\x9c\x05\xf3\x5a\x5a\xa4\x1b\x98\xb2\x59\x97\x6c\x77\x01\x09\x94\x2b\xb2\x43\xbb\x0e\xdd\x6f\x15\x55\x83\xbb\xa8\xa2\x2e\x17\x27\xd4\xc4\xe2\x2a\x55\xa1\xbe\xba\x04\x94\xe8\x63\x02\xe3\xaf\xf4\x57\xd6\xd6\x19\x58\x67\xd4\xd9\x2b\x26\xe3\xd1\xa8\x37\x54\x52\x53\x53\x10\x08\x05\x7a\xc4\xa2\x10\xa3\xd2\xbb\x84\x4a\xd6\xef\xc5\x63\x33\xbd\x16\x74\xef\xca\xa0\x59\x19\xf6\x8c\xc5\x36\x08\xfd\xf1\xc0\x57\x14\xfd\xf1\xaf\x1d\xd4\x0d\x11\x13\xb9\x54\xa0\x5d\x77\x2c\x15\x34\xf7\xd4\xa4\x47\x66\xa4\x05\x7c\x4d\x6a\xff\x9f\x08\xe2\xfc\xab\x12\x43\xba\x61\x5d\xc7\x50\x07\x91\x1b\xea\x36\x44\x1b\x95\x54\x75\x16\x5f\xd5\x32\xbe\x92\x19\x7c\x55\xf8\x2b\x6a\x6a\x09\xbe\x3a\xc5\x2a\x19\x5f\xd5\xd5\x18\x5f\x1d\x08\x5f\x66\x8c\xaf\x0a\x8c\x2f\x44\x24\x5e\x1b\xa2\x99\xff\x3b\xbe\x8e\x4f\x32\xbf\x83\x2f\x99\x82\xd4\x6d\x43\x29\x28\x32\xb2\x48\x52\x65\xc2\x1a\xf4\xbb\xd2\x07\xff\x9d\x98\xda\xe6\x47\xa4\x4b\x72\xe2\x1c\xb7\x83\x9e\xa1\x94\x85\x69\x0b\x48\xa3\xe1\xd3\xaa\xf7\xa9\x36\xaa\x8b\x3a\x3f\x35\x0e\x96\x35\x46\x4d\x8d\x13\x9a\xc6\x15\x77\xd6\xaa\x3d\x2d\x9e\x96\x89\x93\xf4\x42\x9f\xa8\xd7\x3b\x47\x8f\x0e\xf7\x88\xa3\x05\x73\x17\xd0\xc2\xae\x8e\xfa\x54\x53\x49\x71\x09\x32\x28\x4b\x4a\xa8\x5a\xa4\x43\x7b\xc4\x7a\xc6\xa9\x42\xee\x82\x97\xf3\x52\x7e\xa5\x23\x34\x33\x55\x2f\x53\x4c\x4b\xe2\x5e\x59\x87\x3d\x6f\x7c\x15\x41\x9d\xc2\x63\x99\xd0\x79\x9d\x3c\x8a\x26\x22\x4f\x75\xc9\x2e\x62\x77\xd8\xff\x5b\x5f\x9b\xbc\x0b\xa1\x10\xb2\xd1\xa4\x0d\x39\xb5\x35\x60\x62\x5b\xf7\xd4\xd1\x25\x93\x47\x9f\xb1\xb8\x6c\x69\x49\xc2\x76\xca\xc8\xe2\x49\xa3\xd6\x9e\xbd\xe1\xe6\x9b\x96\x57\x9d\xd8\x56\x7c\xea\xe2\x8b\xae\xba\xfc\xf2\xd3\x37\xe4\x75\xbe\xdd\x75\xdf\x9e\x87\x5a\x9b\x46\x6e\x45\x16\xb7\x61\xd8\x5b\xaf\xbf\x7d\x4a\xd7\xb8\xbe\x82\x8a\x49\x01\xdf\xb3\x8d\xe3\x7d\x85\xa3\x2e\x5f\xbd\xf2\x3a\x83\xe1\xfa\xad\x9b\x2e\x23\x2d\x71\x17\x9e\x95\xdf\x12\xf7\xe8\x35\xf7\xff\x55\xa7\x53\xbd\xff\xd8\x63\x21\xe9\x1b\xc0\x87\x32\xb5\x7e\xa3\xe9\x5f\xd8\x2b\xa9\xb1\x54\x27\x75\x51\xca\x49\x95\x0c\x0b\xe9\x86\xb5\x0f\x3f\x21\x5a\xd5\xa1\x76\x34\x39\x9a\xba\x26\x8e\xeb\x4c\x9d\x70\xe2\x4e\xd0\x9e\x2a\x1f\x5e\x18\x2d\x8c\x76\x8a\x85\x55\x85\x55\xa3\x6b\x46\x7b\x3a\xc4\xd1\x36\x8d\xb9\x4b\xd4\x68\xac\xcd\xcd\x88\x2a\x9b\xed\x35\x89\x4e\xb1\x86\xb3\xc2\x4e\xd1\xea\x35\x78\x33\x33\x44\x72\xf6\x14\xe4\xce\xe9\xc8\x2c\xe3\x75\x1f\xa8\x1a\x8a\x6e\x47\x16\xd7\x0a\xaa\x95\xad\x92\x99\x19\x62\x7f\x50\x31\x66\x93\x4b\xcb\xc8\x7c\xb1\x2c\xb2\x37\x8f\x1f\xe9\x6f\x6c\x98\x25\x8e\x3f\x31\x61\xed\x1e\x5e\xd4\x32\x76\x4a\xfd\xfc\xf5\x4d\x8b\x46\x24\xbb\x22\x27\x4e\x3a\xb5\xe7\x98\xb2\x32\x71\xa1\x74\xa4\xb8\xbe\xc9\x37\x7c\xbc\x31\x83\xeb\x87\x27\x4d\xf7\x94\x8c\x8a\xed\xae\x1f\x19\x4d\x44\x2f\x5d\x77\xc2\xb2\x11\xfc\x82\x39\x53\xfb\x86\x54\x9c\xa9\xcc\x6b\xba\xa5\x4f\x0d\x86\x1e\xf6\x48\x16\xcd\xe0\xe8\xe7\xca\xae\xda\x02\xaa\x3b\x55\x66\x0d\x60\x9d\x10\xd1\xf3\x80\x07\xd1\x42\xc0\xfb\xa1\xcb\xe3\xea\x11\x65\x5d\x18\x40\x6a\x21\xe2\x81\xc2\x31\xd3\x35\x9a\x92\x39\x66\xbe\x23\x77\x0c\xa9\x8c\x31\x40\x36\xd1\x2a\xec\x1b\xc6\xdb\x4f\x70\x13\xb0\x1f\xe4\xad\xab\x65\xff\x89\x77\xd2\x62\x89\xd7\xb9\xe6\xb4\xae\xfb\xd7\x82\x86\xeb\x6a\xe6\x8e\xca\xec\xab\x65\x35\x64\x1b\xad\x74\x92\xbc\xb3\xb6\xe5\xaa\x7e\xb0\xc2\x5d\x23\xa5\x6e\xbe\x9a\xce\x5b\x5a\x2b\xc7\x13\x4c\x48\x3a\x7e\x44\x6a\x08\xc6\xa6\x0a\x78\x97\x4a\x65\x57\xfb\xd4\x26\x60\x02\x81\xa0\x09\xf8\x40\x87\xe8\x33\x3b\x38\xb3\xcb\xae\xb1\x77\x8a\xac\xc6\xae\xce\x5d\x16\x90\x37\x12\x2c\x17\x04\x4e\x15\xe1\x23\xe8\xf8\xb4\x72\x7c\x1a\x8b\x2c\x72\x74\xe6\xa3\xb5\xcf\xbc\x7e\xc7\x94\xf9\xa3\x12\xee\xbe\xd5\xc0\xb6\x0c\x79\x4b\xe1\x3b\xd6\x2d\x07\x41\xb8\xde\x25\xad\x92\xd2\x47\xa4\x1e\x70\x6b\xf2\xb4\xbf\xac\x02\xbb\x5c\x89\xf4\xbf\xf7\x2d\x2e\x83\x4b\x07\xae\x00\xcf\xed\x03\x1f\xc9\xb9\xde\xcc\x4e\x76\x1d\xe5\xa1\x4a\xa9\xb6\x54\x61\x40\x10\xa8\x12\x97\x8b\xa5\xd8\x44\x99\x3e\xd6\x27\x86\x39\x24\x52\xc2\xfa\xb0\x86\xd6\x20\xbf\x53\x23\xd0\xde\xdc\x19\xf2\x19\x9a\x8d\x0f\xd9\xa8\x26\x0c\xee\x5a\x8f\x66\x46\x09\xbb\x49\x19\xbe\x09\x00\xe4\x55\x12\xc7\x4b\xee\x92\xa3\x0b\x27\xe7\xef\x5d\x87\x93\x57\xad\x6f\x9d\x56\x58\xb7\xca\xcf\xbe\xf5\xc1\x47\x6f\xd3\xc3\x37\x1e\xa5\xde\x7f\x53\xdd\x78\xc1\xb0\x15\xe7\x9e\x30\x39\x9a\x3c\x23\xa0\x7f\x33\x3b\x6d\x9e\xec\x5f\xff\x60\x7c\x61\x41\xcc\x29\xbd\x26\x7d\x01\xbc\x20\x55\xdd\x40\xff\x0d\xb9\x96\x6f\xd7\x0c\x1b\x57\x12\x8a\xba\x80\x7f\x00\xc1\xa9\xd4\x45\x21\x38\x5d\x64\x0e\x67\xa1\x0f\x4f\xa3\x70\x3a\x29\x96\x2a\x2e\xd1\x17\xe0\x19\xa3\x5d\xa2\x3e\xa0\x0f\xd0\x1a\x8d\xbb\x53\xd4\x70\xb4\x2d\x37\xcf\xf8\x7b\x70\x92\xc4\xa2\xbc\x7a\x03\x90\x91\xa3\xf2\xfc\xcd\x3a\x15\x44\x00\x2b\xb3\x47\xf1\xd2\xce\x87\xa4\xb6\xc3\x6f\xe2\x29\xf4\xd2\xe1\xb2\x13\xc7\x34\x87\x2a\xcb\x4f\x3f\x6f\xc3\xd9\xec\xa8\xa7\xcf\x3c\x5d\xdd\x5a\x53\x36\x01\xfd\xa8\x2a\xc1\xac\xc7\x09\x46\xe9\xbb\xaf\x07\xfe\x23\xed\x0c\x46\x83\xee\xb7\x9e\x7c\xe4\xe5\x5a\xf0\xcd\x9f\x77\xd7\x04\xa2\x01\xd7\x73\x0f\x22\xfa\x72\x1c\xfd\x50\xd5\x85\xee\xcb\x41\x95\xa7\x9c\x9c\x5e\xef\x70\xba\x6c\x0c\x92\xe1\x36\x46\xcf\xe1\x3e\x1b\x23\xe4\x75\x02\xa5\xd0\xd2\xa0\xff\xaf\xd4\x3b\xe3\xf9\xb5\xf2\x4e\x39\x52\xae\x48\x6e\x41\xd5\xd5\x12\xf2\xd7\x26\x5b\x53\x7e\xa9\x31\x99\x7e\xff\x5a\xda\xbf\x03\x5c\x03\xc6\x37\xfc\x69\xf9\x94\x2e\xa6\xe1\x3a\x6b\x6c\xea\x09\xbf\xfd\x95\x35\x92\x16\xc5\x28\x2c\xbc\xec\x7c\x0f\xe9\x15\x3f\x7a\x84\xb9\x09\xe1\xd3\x4e\x0d\x4b\x79\x4d\x5a\xad\xcd\xe1\xb4\x0b\x02\xc4\xfb\x94\xcc\x66\x8d\x5e\x6b\xd2\x9b\x3a\x44\xbd\x19\x2f\x94\x18\x34\xd7\x72\xbb\x4a\x33\xe3\x29\xb3\xc7\xc1\x4b\xee\xb0\x60\x63\x4e\x4d\x84\xa3\xf1\x61\x4e\xe9\xc1\x71\xd2\xba\x5e\xf0\xe8\x56\x60\xf9\x7b\x62\x75\xcf\x84\x16\xfa\x93\x33\x6d\xc9\xfa\x81\x8f\xf0\xaa\xbb\x84\x27\xbd\x9a\x76\x2c\x3d\x59\x38\x80\x77\x16\x63\x9c\xe0\xf9\x13\x4c\x94\xcc\x10\x3a\x44\x7f\x0d\x4e\x24\x3b\x3e\x22\xf2\x8c\x96\x03\x3b\x82\x3e\xa3\x23\x6f\xcf\x31\x39\x3f\x8e\x81\x33\x85\xf2\xbf\x01\x6f\x20\x7e\xc0\xff\x06\xa7\x3a\xd1\xbf\xb9\x71\x47\xc0\xab\xb7\xe7\xed\x05\x99\x2c\xb5\x6b\x3e\x43\xb8\xb7\x53\x61\x2a\x41\x4d\x49\x25\x1c\xbe\x22\x15\x28\x02\x91\x48\x99\xb1\x3c\xee\xee\x11\xe3\x42\x34\x88\x0c\x77\x46\x8d\xde\x6d\xf7\xe8\x2d\xbd\xa2\x49\xcf\x01\x15\x54\xf5\x88\x30\x3f\x40\x81\xa5\x96\x42\x5a\x20\x89\x27\xbc\xd6\x2b\x56\x6b\x54\x46\x86\x07\xe4\xcc\x1c\xc6\x28\xca\xe9\xe9\x80\x83\xbc\xa5\x7a\x48\x7a\xa1\x17\x5c\xb3\xea\xe0\xe5\x05\x7d\x9d\xe3\xcb\x13\x2e\x4b\xb4\xab\x40\xba\x69\xd1\x6f\xd4\xc3\x4f\xec\x7e\xf8\xa1\x27\x9f\x7c\xf0\x10\xdd\x84\xc4\x4e\x44\x7a\x5b\xfa\x54\xfa\x4c\x7a\xdb\x04\xbb\x09\xf2\x76\x83\xbf\x9f\x2e\x0a\xb7\x8d\xb5\xae\xfb\x6d\x16\x33\x59\x7a\x5c\xfa\x10\xe0\xed\x90\x29\xe0\x45\xef\x7a\x12\xf1\xd6\x1d\xd2\x7d\xd2\x3d\xd2\xad\xa0\x07\xf3\x8e\xd4\xae\xae\x20\xbc\x63\x47\x70\x4f\x4e\x25\x78\x56\x4f\xf9\x30\xef\xc0\xb2\x82\xf2\x84\x27\x5c\x8c\x94\x5f\x98\x73\xfa\xdc\xbe\x0e\x64\xb6\xfb\x1d\x36\x8d\x89\xb0\x90\x35\x87\x85\x28\x67\x0e\x51\xa2\x17\x18\xee\x9c\x32\x96\x41\x3e\xca\xcb\xc8\x1f\x1f\x1b\x70\x95\x34\x6f\xef\x8b\xfb\x0e\xec\x7d\x79\xc7\xe2\xd5\x2b\x4e\x59\xb0\x7c\xd5\x12\xba\xfe\xf8\x98\xc0\x1c\x95\xfe\x1e\xaf\x78\xf8\xfb\x73\x3b\xff\xf9\xc9\x13\x7b\x7f\x38\x0e\x06\x90\xbe\x6f\x3b\x7a\x17\xfb\x1a\xd2\xf7\x76\xaa\x8c\x1a\x93\x0a\x39\x0a\x83\xc1\x52\xb7\x9b\x8a\xe8\x29\x7d\x79\x45\xd0\xe7\x4e\xf1\xee\x3e\x91\x2f\x2e\x4d\x15\x96\xb2\xa5\xb3\x45\x56\x1e\x09\x8f\x0c\xa4\x03\x48\x7b\xe3\x87\xdc\x6e\xe9\xa4\xb2\x4b\x23\x4a\x14\xb3\x83\x21\x1b\x35\xe4\xb0\x12\x59\xa8\xe1\x90\x7f\x5e\x8b\x2f\x34\x26\xff\x5c\x45\xb7\xd1\xb3\xf4\xc3\x22\x91\x7a\x3d\xa8\x00\xe5\xd2\x01\xe9\xb0\xbe\x3e\x12\x19\xa6\x97\xde\x90\x5e\x3e\xb4\xe7\x80\xb1\x26\x18\xac\x31\xbd\xbc\x77\x2f\x79\x56\x6d\x7a\xf5\x59\x24\x02\xd7\x96\x05\x8b\x8b\x83\x6e\xe9\x2e\xe9\x25\xe9\x05\xe9\x36\x57\xb0\xa8\x28\xe8\x02\x33\x41\x83\xf4\x0f\xe9\x7d\x97\x37\x12\xf1\xba\x40\x10\x44\x11\xf9\x78\x9c\xde\x70\xd8\xeb\x92\x3e\x92\x67\xb4\xde\xc9\x34\x33\x5a\xca\x86\x6e\x13\xc1\x1a\x76\xc5\xe3\x81\x68\x54\x6f\xa7\xf4\x54\x59\xb9\x37\x90\x72\x05\xb8\xc0\x44\x91\x8b\x17\x45\x53\x6c\x74\x22\x81\x55\x06\x31\x0b\xf3\x31\xb0\x02\x4e\x81\x0f\x17\x22\x28\x60\xfb\x01\xba\xca\x58\x66\xfc\xb9\xbc\xd9\x17\xff\x7c\x24\x60\x9a\xa5\x85\xfa\xfa\x02\x04\xeb\xfe\xfd\xe0\x1a\x04\x67\xc1\x30\xfd\xbe\x57\x76\xac\x58\x65\x4a\x62\xd8\xce\x58\xb2\xf4\x0c\x63\x75\x30\x90\x34\xad\x59\x86\xee\xef\x84\xca\x50\xbc\x24\xe8\xf8\xf5\x2d\xf0\x70\x65\xb0\xa4\x24\xe8\xfc\xe1\xad\xc7\x9e\x76\xb9\x83\x61\x8f\x6d\xd7\x9e\xbd\x4f\xda\xbd\xe1\x90\xdb\xfb\x1c\xa2\xd3\x8b\x8e\x1e\xd1\x16\xa9\x57\x51\x63\xa8\x5e\x6a\x25\xb5\x31\x35\xca\xab\x5f\x30\x77\xe5\xca\xc5\x8b\x3b\x3b\x67\x54\x36\xf2\x33\xa0\xbe\x45\xdf\x72\xfa\xaa\xae\x13\x4f\x1c\x3b\x63\xd9\xb2\xb1\x73\x4d\xdd\xe6\xb1\x81\xb1\xb4\x16\x8e\x4d\xcd\x30\xd5\x3a\x4c\x8e\x1e\x71\xb8\x20\x34\x99\x98\xd2\x90\x2a\xd4\x23\x16\x42\x48\x91\x79\x4b\xc9\xc1\xf1\xef\xca\x33\xee\x0d\x37\xb6\x8b\xab\xb8\xbd\x7c\x3d\x9e\x41\x5d\x9e\xe7\x54\x58\x32\xc1\x65\xb9\x4e\x13\x63\xa0\x8c\x6c\x7f\x47\xc0\x2b\x79\x0f\x13\x5e\x5d\x88\x74\xc3\x48\xc4\x9e\x7e\x88\x1f\x6b\xaa\xb3\x43\x86\xc9\x98\x5b\xde\x6a\xa2\x41\x95\x9f\x49\x22\xb2\x0f\x97\x31\x64\x98\xf5\x48\x68\x31\xd1\xf2\xae\x0e\xf4\x81\xf2\xc6\x2a\xd5\xaa\x0d\xfb\x26\x4d\x3a\xb0\xe1\x96\xa3\x3b\x7a\x71\x82\xe4\xb4\xe7\xa7\x91\x0c\xc9\x8c\xcb\xe7\x54\x9f\x78\xfe\xfd\xb3\xab\x16\xcd\x9d\x16\x6c\x0e\x76\xcf\x39\x35\x39\xfb\xfe\xf3\x4f\xac\x9e\x73\xc5\x74\x92\x5e\x99\xf6\xfc\x69\x38\xbf\xd2\xbb\xe3\x68\x7a\x7a\xc9\xb8\xd6\x54\xeb\xb8\xf8\x29\x33\xab\xa6\x8c\x6f\x6d\x6a\x0a\x0e\x9b\x64\x1e\x07\x5c\x35\x93\xbe\x77\x55\x8d\xaf\xaa\xaa\x0f\x14\x04\x2a\x0b\x4b\x46\x5a\x5b\x26\x4c\x68\x99\x7a\xcf\xc0\xed\x38\xa1\x12\xf4\x92\x8c\x4a\xf3\x96\xaf\xee\xb9\xf7\xb3\x8b\x1b\xc2\x0d\x9d\x65\xa0\xbc\x13\x3d\x5e\xfc\xd9\xbd\xf7\x7c\xb5\xa5\x99\x24\x62\xbc\x41\x9c\x89\xb9\x7d\xe0\x9e\xa9\xea\x8b\x5d\xd1\xd2\xa8\x1b\x2c\xb6\xf9\xa3\x7e\x5b\xf3\xb8\x11\xf3\xc7\x95\x48\x17\xa6\x2a\xa2\xe6\x61\x5c\x91\xc3\x6a\x15\xfc\xfe\x70\xac\xa9\x5e\xb6\x49\x46\x1f\x3d\xa2\x12\x54\x4e\xe5\x1e\xcf\x48\x8d\xcc\xde\x62\xbd\x65\x06\xd4\x35\xeb\x9a\x4f\x5f\xd5\xd1\x89\xae\x70\x6e\xf6\x02\x67\xcc\x35\xa7\x92\x4e\x33\x72\x10\x87\x59\xad\x8d\x66\x2e\x1e\x64\x83\x5d\x62\x94\xa6\xc7\xb0\xf6\xe3\xdd\x20\xf6\x6c\xde\x20\x57\x88\x2e\x90\xdb\x53\x95\x13\x25\x57\x6e\xaf\xb2\x82\xc9\x5e\x5d\xf5\x48\x5a\x76\x6f\x32\x4b\xaa\xe5\xab\xab\x4b\x66\xae\x2e\x63\x6d\x63\x02\xf7\xd3\x78\x0e\x77\xe4\x7f\xb9\x3b\x06\xdc\x5e\x51\x71\xfb\x69\x27\xdf\xb4\xa8\xa1\x7e\xce\x05\x27\x36\xaf\xa9\xaa\x8b\xbb\xda\x0a\x7b\x66\x87\x47\x2f\x18\x5b\x31\xa5\xa5\x4c\x3f\x4c\x57\xde\x32\xa5\x62\xec\x82\xd1\xe1\xd9\x3d\x85\x6d\xae\x78\x5d\xd5\x9a\xe6\x13\x2f\x98\x53\xdf\xb0\xe8\xa6\x93\xa5\xf9\xff\xe3\xbd\x4d\x44\xff\x4b\x9d\xfd\xf8\x9a\xb3\x76\xae\x19\x2e\x18\xbe\xdf\x62\x73\xbf\xf4\xca\xb4\xcb\xe7\xd4\x7a\x12\xc3\x83\xc1\xe1\x09\x4f\xed\x9c\xcb\xa7\xbd\xf2\x92\xdb\xb6\xe5\x7b\x83\x30\x7c\xcd\xce\xb3\xd6\x3c\x7e\x76\x4a\x55\xfa\x3f\x5e\x18\xd2\xa5\x24\xaf\xa8\xba\x04\xe9\x52\x1e\xeb\x52\xed\xd3\xcc\x03\xca\x6c\xa3\x56\xb6\x10\x50\xa3\xc7\x84\x9d\x79\x35\x43\x24\xe7\xc6\x06\xd0\xfb\x2d\xf2\xfb\xe9\x4d\x47\xff\x49\xde\x5f\xca\x17\x02\x4d\x59\xb9\x45\x9d\x37\x0b\x09\xe9\x5d\xb2\x8f\xc7\x43\x35\xa6\x02\x4e\xa0\x52\xe9\x38\x1d\xe7\xf5\x19\x6d\x3d\x22\x67\x44\xca\xb6\x47\x54\x0b\xca\xea\x98\xec\xb2\xa0\xcc\xd4\x65\xd9\x98\x96\x55\x6b\x76\xa7\x51\xee\x2c\xb9\x20\x8d\x85\x33\xbc\x85\x8c\xac\x78\x49\xba\x27\x77\x88\x9c\x74\xf4\x08\xa0\x41\xa8\x54\xd9\x40\xd6\x65\x00\x7d\xa0\x3a\x67\x88\xdc\x6b\xd2\x73\xe8\xeb\x5d\x33\xde\xa3\x20\xb5\x2b\xf3\x5e\xd1\x19\x35\x46\x8b\xc5\x8e\x54\x89\xd7\xe7\xc2\x6d\x69\x2e\x4e\xd0\x4f\x14\x05\xbb\xd1\xc2\x59\x3a\x44\xee\x8f\xce\x08\x06\xf7\xa0\x07\x32\xe5\xea\x64\xa5\x29\x52\x7f\x50\x57\x57\x12\xef\xae\x5e\xb9\x71\xf3\x35\x53\xf0\x5a\xa3\xdd\xfb\x3e\x7c\xe9\xf2\x8b\xe9\x6d\xeb\xcb\x63\x6f\x3f\xf1\x97\x47\x39\xad\x14\x27\x51\xc7\x99\xc6\x7f\x7f\xf3\x11\xa0\xe5\x7a\x7a\xdf\xd1\x23\xf4\x65\xec\xa5\x94\x40\xf5\xa4\x2a\x55\x6a\x56\x43\xeb\x81\xc1\x62\xe6\x78\xde\x6c\xd0\x6b\xd4\x2a\xad\xa0\x15\xac\x36\x83\x19\x58\x34\x7a\x96\x36\x5b\x4c\x94\x9e\xd6\x31\x8c\x8e\x32\x31\x9c\x1a\x09\xbf\x3d\x8e\xfa\xcc\xfa\x48\x3e\xdb\xab\x95\xb3\xcc\x3d\xc7\x14\x8e\xa9\x1d\xea\x18\x8c\x08\xb1\x3a\x47\x1d\xfa\x12\x92\xd0\x41\x2f\xdb\x3f\xee\x25\xdf\x4b\x0f\xce\xd9\xbd\xcf\xb7\x6f\x3c\xfa\xba\xbf\x6f\xd7\x7e\xfa\xcd\xd1\x6f\x8e\x9e\x32\x3a\x3d\x40\x47\xd0\x03\x7e\x0a\x06\xd2\x9f\x8c\x26\x77\x2d\x3d\xc0\x34\x80\x09\xec\x72\xa4\x9b\x6c\x8f\xe9\x78\xde\x86\x1c\x28\x1b\x55\x8e\x8c\x05\x45\xa0\xc2\xcc\x2a\xfc\x64\xa8\x26\xb3\xb2\x2f\x12\xda\x34\xac\xa4\xb8\xb1\x71\x18\x38\xb9\xa1\xa4\x64\x58\xfd\x30\xe9\x46\xe6\x96\x92\xe1\x8d\xc5\x25\x0d\xfa\x92\x86\x06\xf4\x2b\xf9\xb3\x6f\x60\x7a\xc0\x3c\x76\x35\xc5\x53\x9e\x94\x96\xd6\x5b\x0c\x7a\x96\xda\x00\x91\x0b\x4f\x35\xb9\x5f\xae\x42\x42\x00\x10\xb5\x5d\x25\x44\x88\x61\xaa\x42\xbe\x74\x5d\x55\xdd\x48\xb0\xe9\xb0\x76\x9c\xf7\xec\x50\x47\xed\x92\x55\x33\x4f\x99\xb9\x64\x58\x37\xbb\x5a\xfa\xfc\x92\x48\x78\xcc\x62\x30\xa5\xb4\x88\x7c\xf6\xd1\x2b\x98\x5e\x6a\x29\x7b\x90\xe2\xf0\x67\x1b\xf5\x2a\x5c\x86\x09\x4d\xe4\xb3\x5f\xae\x92\x8f\x8f\x4f\x5f\x9d\x99\xd3\x6f\xb3\xe2\xc1\xbd\x4b\x5b\xaa\xe2\x75\xe1\x92\xf0\x19\x67\xce\x65\xdb\x86\xb7\x97\x16\x86\x43\x36\xbb\xa3\xa6\xa0\x29\x7a\x6a\xde\x67\xfa\x52\x3a\x15\xa4\x28\xbd\x9e\x57\x99\x60\xee\x87\x12\x41\x25\xe0\x05\x4e\xb5\x83\x72\x65\xe9\x9c\xb3\xce\x40\x1f\x5a\x17\x4f\x36\xb3\x6d\xdd\xa7\x46\x9b\x0a\x6a\x1c\x76\x1b\x32\xb0\x4a\x71\xcd\x14\x48\x6f\x67\xfa\xe8\x6a\x76\x2d\xfa\xdc\x58\x8a\xd7\x33\x0c\x6f\xd0\x5f\x2a\x1a\x0c\x88\x93\x36\x8b\x6a\x86\x7c\xfc\x01\xb9\x4b\x31\x4e\xfe\x08\x3a\x37\x91\x60\x08\x3d\x2c\x93\xb4\x85\xa3\x65\xe0\xab\x99\xa7\xa8\xb6\xb3\x0f\x3f\xb6\x0e\xb0\x80\xb9\xf1\x01\xe9\xfb\xbb\x2e\x61\x93\x0b\xe7\x6f\x3d\xaf\xb3\x73\x7e\xef\xf0\x28\xc6\x89\x66\x20\x8e\x7c\xb9\xd7\xd9\x07\x29\x23\xe2\x8a\x62\xaa\x8e\x1a\x4d\x4d\xa2\x66\x53\x4b\xa8\x6d\xa9\x8e\x59\x9d\x9d\xdd\xe3\x9c\x3a\x9d\x85\x29\x43\x1a\xbf\xb0\x90\x19\x07\xe7\x35\xb6\xb4\x2c\x9a\x37\x6f\x59\x57\x2c\x38\x6e\xdc\x04\xef\x98\x31\x91\x09\xa7\xb5\x36\xce\x9b\xb7\x60\x58\x5f\x5f\xd3\x82\x9e\x9a\xb2\xee\xee\xe9\x25\x93\x27\x57\x4e\x9f\xb0\x60\xfa\xf4\x05\x13\xa0\xde\xe6\xb2\x58\x4c\x36\x4a\xad\x66\xf4\x54\x79\x32\x59\x9e\x24\xdf\x30\x61\x96\xe3\x1c\x12\xc1\x4e\xb9\xdc\x30\x71\xbc\xa7\x0a\x49\x0d\x76\x21\x26\xb3\x5a\xdb\x96\x9d\xbd\x8d\x1e\x0a\x61\xde\x2b\xf0\x07\xbf\x13\xfe\xe7\x77\xe6\xbf\x4a\xb6\x75\xae\x9e\x3c\x79\x75\xe7\x98\x9a\xec\x33\x7a\xf2\x71\x7e\xd8\x9e\x7d\xf6\xeb\xb0\x9a\x31\xf2\xd3\xb6\x64\xf6\xd9\x8e\xec\xb3\xd7\xdb\x92\x93\x57\xaf\x9e\x5c\x31\x5e\x55\x9b\x79\xf6\xeb\xab\x99\x67\x4c\x2c\xf3\x4c\xd2\x64\x9e\xa5\x0f\xb5\x97\xe3\x67\xc9\x36\x26\x96\x79\x26\x69\x32\xcf\xd0\x5d\x56\x48\x73\xe0\xab\x2a\x06\xd1\x4c\x88\xaa\xa2\x5a\xa9\xa9\xd4\xa9\xd4\x7a\xea\x2a\x6a\x43\xea\xff\xe3\xec\x4b\xe0\xdb\xa8\xae\xbd\xe7\xce\xa6\x6d\xa4\xd1\x48\x1a\x8d\xf6\xd1\x62\x49\x96\x65\x59\xb6\x65\x59\x76\xec\xd8\x13\x67\x27\x8b\x15\x27\x84\xc8\x24\xb1\x13\x42\x80\x84\x10\x12\x02\x01\xd2\x90\xd0\x40\x37\xa0\x61\xdf\x0b\x29\x0d\xcb\xa3\x29\x6b\x48\xa1\xd0\x94\x96\xa5\xd0\x92\x52\xda\xd2\x05\xfa\x68\x69\x4b\x37\x68\xa1\x2d\xef\x3d\x0a\xf1\xf8\xbb\xf7\xce\x68\xf3\x92\xd0\x8f\xfc\xb0\x2d\xd9\x92\xee\x59\xee\xb9\xe7\x9c\x7b\xce\xff\xcc\xda\x7b\xe5\x39\xa3\xa7\x07\x24\x51\xc0\x2a\x3a\xff\xd4\x9d\xe7\x9e\xbb\x6d\xdb\xa9\x16\xe1\xf4\x2b\xd9\xce\xd6\x78\x7c\x56\x67\xe7\x8d\x0b\xe7\xcc\xd9\x77\x5d\x22\x13\x8d\xf6\xe5\x3a\x77\x6f\x5d\xb5\xe6\xba\xce\xad\x6b\xd6\x6c\xed\xbc\x8e\xa6\x64\x97\x8d\x22\xb2\xaf\x64\x5f\xd1\xc4\x96\xb5\xbf\x62\x3f\x66\x7f\x05\x0a\xf2\x58\x3b\x72\x38\x5f\xa9\x13\x53\xf9\x5f\x4e\x28\xcb\x12\xe5\xc4\xea\x95\x1f\x6e\xb1\x82\x88\x8f\x68\x9c\x5a\x4c\x00\x78\x70\xa3\xfd\xac\xa7\xca\x3a\x91\x47\x96\x73\xa3\x63\x5b\x33\x1e\x18\xbe\xc0\x90\xd4\x53\x66\xda\xdf\x00\xf4\xb5\x20\xe9\x41\x88\xf6\x77\x71\x9c\xcf\x34\xe8\xb1\x89\xfe\xde\x38\x79\x59\xd0\x53\x6f\x93\x36\xdf\x6f\xab\x3f\x52\xab\xea\xf7\xe1\xc7\x9b\xea\x1f\xd3\xf7\xf7\x9d\xd5\x93\x69\x70\xbb\x5d\x19\x4f\xa8\x65\xf6\xf1\x9e\xba\x87\xd4\x9a\x0b\xe7\x2c\x3c\xaf\x79\x5e\xd2\x25\x3b\x33\xe1\xc6\x81\xe3\x6f\x55\x1f\x67\x43\x8d\x03\x87\xeb\xdf\x8c\xb9\xb9\xfe\xf1\xd8\xf7\xa6\x5c\x93\xfa\x9b\xfa\x77\xa5\xa2\xf5\x8f\xcf\x9e\x76\x49\x72\x66\x36\xc6\x98\x50\x17\x33\x77\xb0\x2f\x11\x41\x22\x8d\xbc\x6d\xd1\x64\x6a\x4c\xa5\xa2\x11\x37\xcb\x06\x09\x8a\x8a\xd8\x82\xb6\x60\x73\xa6\x91\x8f\xc8\x11\xe8\xa2\x45\x42\x4a\x28\x3e\x52\x0a\x09\x4a\x40\xd2\x4a\x56\xbc\x06\xb7\x40\x05\x4d\x2c\x1e\x4e\x68\x14\x69\x4e\x43\xd3\xc9\xd5\xf6\x0e\x57\x2b\xc7\x7e\xa4\xc5\x20\xd8\x65\xab\xa6\xc8\x2a\xfa\x80\xf3\xf7\x71\x34\xa9\xac\x5a\x2f\x36\x01\x52\x0c\x20\xc9\x6b\x39\xa7\x9c\x0d\x30\x77\x3c\x3a\xab\x5d\xbd\x15\xc1\x89\x95\xd1\x10\x30\xfe\x8e\x6a\xf8\xe6\xe3\xcc\x41\xf6\xec\x35\x9a\x85\xeb\xd5\x60\x50\x74\x68\xb1\x29\x80\xc7\x98\xd1\x2b\x6e\x3c\x6b\x13\x32\x7d\x38\x6f\x8c\xfa\x9c\x52\xd0\xb6\x5a\x21\x4f\xf6\x2a\x03\x31\x49\x32\x5b\x2c\x34\xd5\xe0\x72\xa5\x6d\x82\x40\x05\xd2\x81\x74\x73\xa6\x29\x1e\x0d\xca\x30\x56\x36\xa3\x76\x10\xc8\x1b\x8a\x50\x08\xc3\x60\x89\x50\x92\x62\x83\xcc\xa7\x25\x57\xc0\x17\x40\x25\x0f\x0e\xbb\x4f\x24\xfa\x5f\xac\xe7\x88\xaf\x86\x13\xe5\x06\xc3\x69\xf8\x51\x4f\x31\x80\xdc\x89\x4d\xcb\x1d\x32\x5c\x47\x37\x18\x7a\x64\x56\xfb\x9f\xf4\xea\xba\x6a\x99\x19\xbd\xbe\x4c\xed\x27\x3f\x43\x7d\x53\x35\xe5\x75\xda\xdd\x45\x4d\xf1\x5d\x1d\x0e\x09\xc2\x88\x59\xa2\xa4\x04\xab\xcf\x67\x66\x45\x82\x25\x34\x8c\x18\xbb\xd1\x84\x10\x61\x4c\x02\xfc\x47\x5b\x26\x03\xc3\xd4\xd4\x03\xa4\x27\xa0\x6c\x57\xca\x76\xf2\xb9\x7c\x4e\xcc\x89\xb1\xba\x8a\x24\x7a\x05\xae\x48\x3a\x74\xe8\xbb\x3f\xfd\xe9\xa4\x1a\x24\x75\xf8\xe6\x9b\x87\xd5\x3b\xab\x85\x47\x24\xc2\x8b\xa2\xae\x84\x7e\x52\x65\x9d\xc1\xa0\x19\x86\x20\x78\x9d\x81\x22\x5e\x67\xb1\xb2\x4e\x82\x0e\x4e\xa8\x34\xfa\x4f\xd7\x59\x2d\x86\xbd\x12\x97\x14\x5d\x7f\xfd\x7d\x3f\xfb\xd9\xc4\x2a\x22\xda\xb9\xfc\xed\xb7\x97\x8f\xd5\x54\x0e\x55\xb1\x33\x9d\x44\x98\x38\x4b\x99\x21\xca\x52\xc0\x26\x70\x01\x00\x58\x89\x63\xb9\x48\x34\x40\x8c\x96\x44\x79\xa4\x24\x0a\xeb\x4a\xf6\x80\xe8\x72\x89\x01\x3b\x4d\x9b\x4c\xfe\x13\xce\x58\x94\x50\x72\x13\xa5\x37\xd3\x75\x10\x1c\xe5\xa9\xe1\xd5\xeb\xaf\xb0\xe0\x42\x5e\x1e\x1b\x73\x4a\x3a\x01\xb9\xf6\x42\x12\x3c\xf0\xfa\xd8\x0f\xef\x3e\x04\x3e\x06\xef\xed\xda\xde\x73\xd9\xf9\x8f\xec\xdb\x96\xbc\xfd\xc8\xfa\xb3\xbf\xba\x64\x27\x69\x53\x07\x2a\x03\x18\x2f\xfc\xc1\x79\xdb\x7a\x77\xf7\x82\xe2\xb6\x05\xbb\xee\xfd\xf2\xd8\x95\xb3\x2f\xc6\xbc\xd7\x7b\x42\xa1\x97\xd0\x44\xec\x50\x66\x06\x53\x72\x3c\xce\xf1\x66\xda\xed\xf6\xcb\x66\xbf\x39\xdd\xec\xc6\x65\xa6\x36\x9b\xe0\xf5\x07\x53\x3c\x47\xdb\x02\x01\xc1\x20\x24\x8b\x25\xc1\xdd\x40\xd3\x06\x43\x74\x59\xc9\x60\xaf\x14\x0c\x54\x46\x3d\x54\xee\x57\xe0\xe1\x51\x86\x99\xaf\xa7\x4f\x2f\x2a\x41\x35\x02\x92\x0e\xd0\xa1\x91\x17\xad\x74\x57\x02\x49\x9f\xc4\x22\xa0\x9e\xbd\xe4\xad\x9b\x81\x91\x6c\xba\x66\xe1\xe1\x17\x76\xed\xea\xbe\x7c\xe4\x8b\xdb\x36\xb2\x07\x55\x65\x27\xf8\xde\x8e\x96\xdd\x7b\x2e\x5c\x5a\xda\xb4\xb1\x67\x2f\xaa\x0c\x28\x34\x34\x7f\xfc\x57\x75\x7c\xdf\xa5\x33\xf6\xce\x74\x2f\x48\xa9\xa8\x83\x92\xbc\x77\xc7\xd9\x4f\x3c\xfb\x74\x64\x4c\x10\x66\x5f\xae\xe1\x61\x51\x57\xb2\xd7\x42\x5b\x91\x53\xfc\x8c\x99\xa0\xcc\x94\x8d\xc7\xb8\x7c\xf4\x68\x89\xb4\x52\x66\xc6\xc0\xe8\x58\xa7\x7a\xde\xac\x76\x2e\x23\x70\xe6\x9c\xf1\x8a\x64\xc8\x57\x37\xcc\x12\xd4\xd8\xab\x63\xcf\x1f\x3a\xc4\xcc\x04\xcb\xd5\x95\xe0\x93\xb3\xcb\x13\xb8\xb4\x39\xce\xe4\xd3\xf4\xfd\xf0\xb3\x3a\x95\x00\x60\xcd\x56\xd6\x6a\xe3\x39\x13\xee\x9d\x45\x8d\xef\x3c\x0b\x28\x50\x2c\x51\x62\x8d\x5e\x10\x75\xf5\x8e\x55\x25\x28\x40\xe7\x69\x1b\x8a\x40\xae\x24\x89\x05\x19\x6a\xd5\xf1\xbf\x97\xf7\xff\x27\xea\xa3\xfa\xfc\xcf\xb5\x18\xbb\x76\xa1\x12\x77\xb8\xdd\x06\x17\xc5\x51\x9c\xc7\x2b\x60\x54\x2b\x91\x61\x99\xd1\x92\x83\x65\x81\x99\x72\x4f\x18\x29\x37\xa1\x66\x4b\x43\xeb\x6a\xaf\xc0\x92\x21\x50\x7d\x0c\xe2\x4a\x69\x13\x3f\x23\x82\x44\xee\x44\x14\x1f\x3a\x44\x0b\x8e\x59\x7d\x1b\x5e\x57\xc1\x67\xd4\x2b\x5e\xcd\xfb\xc8\xc1\x61\xf0\x3f\xfe\xbc\xba\x07\x48\x2e\x55\x18\x1e\x7b\xd4\x57\x83\x1f\x22\x11\xa7\x29\x2d\x06\xc9\xc6\x98\x4c\x0e\x9b\x4d\x42\x35\xbb\xc0\x4e\x19\xed\x82\xbd\x58\x42\x4d\x9f\xa2\xe8\x1c\x2c\x89\x68\x00\x00\xaf\xcd\x30\xe0\xc4\x89\x9d\x5e\x13\x0a\x75\xb5\x1b\x66\x9c\xd2\x46\x5b\x42\x2c\xdf\xb9\xeb\x0b\x16\xc8\x5f\x23\x68\x91\x9f\xff\x1c\x83\x8b\x94\xe1\x45\xd4\x67\x56\xa8\x57\xe2\x88\x6d\xd7\x0a\xb0\xcc\x9b\x51\x3f\xc4\x38\x62\x73\xe9\x97\xf0\x8c\x9e\x35\x4a\xab\xad\xb1\x31\xea\x33\x52\x2e\xca\xd5\x94\x96\xe0\xa6\xf6\x49\x81\xa4\xcd\x66\xb7\xc7\xd1\x04\x38\xc0\x5a\x69\x16\x41\xaa\xb3\x54\xe3\xc4\xc9\x7c\x95\x8c\x7b\x4d\xe9\x79\x75\x0e\x57\x85\x9f\x1a\x20\x6e\x19\x18\xda\x81\x6b\x74\xcb\xfd\x0c\xf0\x91\x06\x10\xad\x71\xb8\xcc\xdf\xdf\x5d\x7e\xe0\xb9\x61\xf5\x6f\xea\x87\x5f\xfd\x0e\x3d\xc7\x95\xfb\xec\xec\xa7\xfe\xeb\xba\x7b\xcf\xff\xaf\x57\x75\x98\xdc\xa7\xdf\x74\xa9\xf3\x06\xbf\xa4\xfe\x45\x55\xd5\x6f\xa9\x8f\xe5\x8e\x5f\x99\xce\x82\x00\x48\x80\xd6\xb1\xcc\xd8\xc5\x7a\xcd\x6d\x5c\x9d\x4b\xbd\x81\xb1\x47\x46\x94\x76\x36\x14\xf2\x38\x88\x18\x17\xe3\x1a\x53\x41\x96\x85\x96\x6a\x59\xc9\x64\x8a\x24\x12\x0d\x83\xa5\x04\x8a\x9e\x13\x7c\x28\x16\x89\x0d\x96\x22\xa2\x36\xc9\x2f\x50\x03\xae\xaa\xef\x09\x62\xd2\xdc\xa8\xf2\xe0\x28\x8d\x3a\x6d\x6b\x63\x67\x4d\xc0\xcd\x3c\x42\x2d\xd8\x7e\x15\xfb\x65\xee\xcd\x9d\xcf\xbc\xf0\xfa\x0f\x2e\xb9\xa1\x90\x5e\xb0\xfe\xdd\x9b\xbf\x3c\xb8\xb9\x06\x0d\x46\x1d\x8a\x25\xdf\xfd\xdd\x9f\x3f\x91\x01\x7b\x5f\x16\xec\x7b\xf2\xdb\x5e\xf5\x27\xb5\xf8\x30\x68\xa6\xe8\x62\x8c\x9f\x9b\x22\x6e\x52\x96\xf0\x0e\xaf\xcb\xe6\x64\x1a\x23\x06\x83\x8f\x8b\x52\x68\x24\x6e\x63\xd2\xe0\x74\x71\x49\xce\x45\x39\x52\x8e\x54\x53\x3a\x19\x8d\x86\xfd\x2e\xaf\xdb\x3b\x52\x8a\xf8\x18\x5b\xa3\xd3\x69\xf3\x51\xe6\x86\xa0\x9b\xa2\xed\x8e\x94\xc1\xe0\xe0\xcc\xdc\x48\xc9\xac\x83\x0c\x6a\x85\x0c\x5a\x29\x54\xc5\x1b\xae\x96\x92\x55\x82\x72\x87\x96\x4c\xd0\x7c\x80\xba\x08\x3d\x8e\x1a\x5b\xab\x28\xa3\x27\x40\xd8\x35\xa4\x85\x59\x9b\x37\xeb\xc8\xb9\x27\x44\xd8\x7d\x14\x3b\x48\x15\xdc\x5c\xf0\xea\xc9\x50\x76\x35\x2c\xc0\xf1\x8f\xd4\x1d\x18\x7f\x26\x45\x1c\x54\x56\x7d\x0a\x5e\x85\xd3\x7b\xd3\xcf\xa6\x29\x3e\x0d\x4c\x54\x85\x6f\x83\x13\xf8\xc6\xd3\x76\x51\xe7\x1b\x3c\x0b\x50\x75\xe1\x8b\x27\x61\x5b\xcd\xb8\x91\xff\x88\x75\xd3\x03\xd4\x30\xd7\x0a\xb3\xd6\xa5\x75\xf0\x99\xe9\x01\x6a\x96\x74\x22\xf7\xa9\x82\x3b\x03\x32\x27\x43\xa9\xf9\x1f\x4d\xc7\xd6\xa9\x5b\x30\x26\x71\x37\xf1\x15\xe5\xf4\x6c\xb3\xd7\x58\x08\x35\x37\x17\xbc\x64\x82\xb1\x8a\xed\xd6\xf6\x19\x3d\x79\xab\x19\xcd\x12\xcc\xfa\xbc\x3e\xa8\x57\xbc\x6f\xab\x6f\x8f\xef\x61\xdf\xab\x3e\x46\x76\x0c\x3a\x46\x1c\x5b\x1d\x77\x3b\x1e\x76\xb0\x83\x0e\xc0\x3b\x64\x47\x16\x3f\xb3\x07\x3e\x33\xee\x30\x1a\x29\x87\xcf\xe1\x83\x12\x81\xe6\x99\x78\x12\x2c\xfa\x66\x22\x95\x8a\x8c\x94\x52\x74\xb5\xc4\x58\xbf\x06\x45\xed\x2b\xdb\xb5\xde\xb1\xda\x36\xde\x32\x7b\xb1\x25\x8c\x96\x41\x6c\x92\x89\x4f\x87\x70\x8c\xbe\xe2\x80\xec\x8a\x0d\x73\xba\x7a\x67\xcf\xbf\x79\xdf\xa9\xb5\x68\xc7\x13\x6a\x3e\x1e\x7a\xe0\x97\x47\x57\x5f\xaa\x6e\x69\x51\xdc\x8b\xfa\xaf\x71\x39\xc4\x7a\xdc\xe3\x89\x45\x1e\xf7\xdf\xf4\xb5\x1f\xda\x67\xee\x5c\xb3\x0d\xd7\x1b\xab\x5b\x30\xbe\x4f\x27\xb1\x5f\x39\xa5\x39\xe5\x36\x76\xf8\x53\xa9\x0e\x37\x19\x63\x38\x47\x2b\xd7\x5a\xe8\x6a\xe7\xcd\x4a\xb3\xe4\x96\xa0\xbd\x19\x34\xdf\x6d\x7e\xd8\x4c\x0d\x9a\x47\xcc\xe3\x66\xea\x61\x33\xe0\xa5\x41\x69\x44\xda\x2f\xdd\x2d\x3d\x2c\xb1\x46\xca\x2c\x99\x25\x22\x41\x20\x43\x05\x59\xa6\x98\x62\x89\x44\xa8\x58\x4a\xd8\xdd\x44\x76\x0a\xae\x41\xb6\x95\x0b\x6b\x8e\x9d\x94\x6b\x27\x03\x01\xc2\x20\x5b\x0c\x66\x59\x87\xc6\xb2\x9b\xae\xce\x4e\x03\x08\x74\xea\x79\xea\xeb\xeb\xcb\xec\xfa\x92\x47\x4a\x4f\x09\x0c\xc4\xda\xb6\x2d\x19\x6f\xec\xfd\x0c\x62\x93\x8e\x99\xba\x06\xe3\x75\x6e\x50\x3a\x19\x9f\xcf\xeb\x34\x18\x50\x83\x31\xed\xf7\x7b\x39\x0a\x63\xe9\x58\x29\xaf\x4b\xc3\x33\x67\x58\xa7\x8f\x36\xbb\x79\xca\x6f\xd0\xcd\x16\xad\x19\xae\xfe\x72\x4d\xeb\x04\x34\x9d\x9a\x82\x6c\xbd\xf5\xbb\x7e\x8f\xd5\x19\x24\x66\x0d\x34\x48\x37\xd5\xa3\x20\x83\x83\x08\x1d\xf9\xef\x9a\x01\x9a\x0a\x07\x19\x83\x24\xc7\xcb\x67\xce\x0e\x8c\x0b\x84\x30\x06\xba\x20\x0d\x6c\xd0\x10\x08\xf8\x61\xc8\x6a\xb3\xf9\x83\x94\x1c\x22\x64\xe8\x02\x04\x44\x83\x91\xe6\x04\x3f\x0c\x72\x71\xa3\x81\x47\xe0\xd1\x91\xa4\xcd\x31\x22\x39\x1c\x8b\x55\x0d\x4a\xa5\xb4\x4c\xea\xae\x52\x54\x77\xfb\x83\x29\xaa\x02\x02\x4d\xa0\x89\x7a\x07\x5a\x8a\xe7\xcb\x98\x40\x75\x60\x41\xc3\x9d\x5a\x70\x55\x81\x04\xd2\x0b\xc3\xaa\x88\x41\xef\xd5\xe0\x56\x87\x89\xcf\x28\x03\x21\x52\x92\x18\x97\x2b\x88\x64\xe4\x09\x02\x59\x0e\x72\x54\x24\x4a\x44\xa1\x88\x82\x1e\x8f\x26\x23\xd6\xc9\xb8\xa4\x90\xcb\x49\x32\x22\x0d\xff\x99\x7d\x3c\x55\x16\x96\x8c\x31\xf9\xfa\x2b\x3d\x3e\x30\x9c\xd1\xe9\xd1\xc9\xac\x25\xb1\x4c\xa6\x16\xe0\xa4\x00\x10\x62\x42\x3d\x8d\x05\xe8\x04\x55\x40\x91\x98\x35\xea\x43\xea\x15\xc3\xd7\x94\x65\x77\xcd\x30\x38\x5f\x97\xde\xdf\xae\x23\x07\xd4\x6f\x80\x1b\x2f\xab\x97\xde\xcd\x60\xce\x3b\xe0\x0b\xba\x04\x13\xfe\x1a\x5c\xa7\x28\xb1\x47\x99\x1d\xa6\xbd\x5e\x83\xdb\x2d\x23\xf1\xf9\x64\x2a\x12\x91\x6d\x54\xac\x81\x68\x80\x22\x94\x7d\x3e\x4d\x76\x46\xd1\xe0\xf6\x86\xdd\x22\xcd\x48\x2c\xfc\xc7\x05\x04\x3e\x42\x51\x9a\x2c\x01\x12\x65\x8d\x24\xff\x43\x72\xf3\x05\x4a\x9c\x44\x30\x8c\xed\x0a\x65\x82\xa9\x77\xd4\x2f\xae\x7c\xb1\xb8\xb1\x2c\xd7\x8d\xc5\x1f\x54\x50\xa0\xa0\x50\x0b\xef\x80\xf6\xd3\xea\xe5\x7a\xde\xaf\x3f\xf7\x46\x05\x0b\x8a\xa8\x91\x6d\x84\xd8\xa6\xf4\x78\x5c\x34\x6d\x35\x91\xb2\x37\x04\xc2\xe1\x90\x6c\xa2\xa3\xb1\x90\xd7\xeb\xc4\x38\xfb\x94\x87\x94\x25\x0b\x67\x19\x2d\xb9\x3c\x32\xc7\x19\xfc\x76\x2a\x0c\x03\x3e\x6d\x4a\x02\x12\x6a\x25\x18\x42\xa5\x52\xd0\x31\xd2\x1d\xa5\xaa\xfa\x82\x2a\x95\x15\x81\x1a\xaa\x0e\x6c\x19\xbf\x19\x92\x5c\x2f\x51\x7d\x33\x62\x91\x3e\xf7\x5c\x65\x43\x42\x91\x96\x37\x23\xb5\x7b\xf8\xfb\x48\x88\xdf\x1f\x56\x0f\x56\x36\x64\xc2\x5f\xc1\xe9\x82\xf1\x76\x84\xd8\xa5\xf4\x7b\x43\xb4\x1c\x92\xc3\x1e\x17\xcb\xf2\x16\x2a\x6c\x09\x23\xfa\xfc\xf0\x78\x67\x3c\xb4\xec\x91\x4d\x7e\xc9\x6a\xb3\x16\x4b\x2e\x9b\xcd\xe1\xe7\x1d\xf6\xc1\x92\x83\x08\x53\xb8\x16\x0c\xca\xd2\x54\x27\xcb\xda\xce\x8f\xca\x70\xe0\xda\x48\x26\x87\x31\xf6\x6a\xca\xe8\x27\xd2\x2a\xd4\x51\x8a\x45\x59\xde\xa2\x50\x98\xb1\x7f\xfd\xab\x06\xd2\xab\x76\x87\xfe\xb9\xf8\x32\xf4\xe1\xff\x51\x1c\xbb\xb5\x06\xd6\xab\x8c\xc1\xc4\x0e\x41\x59\x86\x50\x47\x93\xc5\xeb\x0d\x49\x0e\x4e\x70\x3b\x9d\x82\x23\xc4\x32\x72\xd8\x09\x9f\x41\xd5\xbe\x1e\x8b\xe4\x60\x1d\x16\xca\x10\x70\x40\x5f\x9c\xe3\xcc\x06\x78\x8e\xdb\x0c\x06\x30\x5a\x32\x50\x55\x68\x13\x44\x65\x7f\x8d\xb2\x4e\x10\xa1\xe6\xf6\x6a\x87\xeb\x34\x43\x13\xc0\xaf\x5b\x4f\x3b\xe2\xf7\xcf\xa1\x1a\x0e\xd5\x48\xad\x22\x51\xfa\x1d\x8e\x45\x78\xb9\xb5\x56\xb4\x16\x6a\xbe\x8c\xd3\x44\x7f\x03\xee\x47\x99\xd8\xac\x74\x49\x01\x3a\x18\x08\x86\xdc\x2c\x8b\x66\xf8\x58\x04\x2a\x1c\x09\x48\x92\xe8\x10\xa1\x04\xdd\x74\x50\x80\x1e\xad\xc9\xeb\x70\x58\x91\xfb\x1e\x9a\x4e\x70\xa8\xf0\x74\x1a\xaa\xa6\x91\x57\x74\x12\x8d\xf4\x37\xaa\xd2\x8a\xa1\x2e\x2d\x72\xc3\xf6\x69\xc4\x85\x3b\xb4\x26\x80\xb0\xe1\x33\x6f\x07\x9e\x8d\x10\x24\xee\x55\xc2\xc8\xbe\xa0\x6c\x26\x3c\x2f\x82\xb6\x60\x48\x76\xc9\x3b\x64\xf2\x43\x19\x68\x38\xce\x14\xc2\x71\x7e\x7c\xc6\xcc\x05\x18\xcf\x79\x46\xb2\x69\xc1\xb5\x18\xcf\x39\x2c\x17\xe5\xbd\x32\xc2\x0c\x37\xa2\x31\x26\xfd\xe2\xa0\x48\xa1\x51\x26\x9c\x50\xc9\x7c\x56\xf3\x9e\x34\xe7\x00\xd0\x71\x28\x57\x01\x4e\x07\x1b\x36\xb2\x26\x9d\x5e\x53\x3f\xb6\xa6\xea\x98\x4e\xdd\x6f\x8d\xbe\x33\x57\xc1\x23\x46\xbd\x63\x52\x92\x13\x1f\x2f\xd0\x4d\xcf\x4f\x9c\x57\x84\x73\x9a\x6b\x74\xbc\xa6\x4e\x7c\x5e\x9e\xa3\x74\x4d\xe4\x83\x86\x59\x4d\x21\x0a\x61\x90\x5c\x21\x6c\x10\x12\xc6\x6b\x84\x4d\x38\x2f\x27\x22\x8f\x4f\xec\xfb\xfd\x34\xb4\xd0\x9d\x90\x96\x71\x62\x52\x4a\xb2\x7c\x54\x4e\xd1\x2a\x9e\xf1\x1e\xff\x9d\x3e\x6f\xf1\x0e\x7c\x4e\xae\x57\x3a\xfd\x3c\xef\x0a\x40\x3b\x49\x18\x5c\xf0\x7c\x0c\xfa\x58\x51\x12\x47\x4a\x7e\xdb\x68\x09\x48\xbc\xbf\xdf\x3f\xe8\x87\xc2\xf2\xfb\x1d\xb2\x44\xf1\x9c\xc1\xe5\x70\xa1\xd3\xb1\x6e\xf0\xa2\x86\xcb\xeb\xe8\x4e\x57\xb2\xaf\x52\x6d\x45\xa0\xde\x1e\x59\x07\x8f\x56\x4b\x0a\x7b\x07\xee\x8c\xcc\xeb\xb3\x2c\xaa\x72\xa1\x1a\x69\xf2\x35\x83\xe5\x93\xcd\xb8\xe1\x66\x0a\xd1\x94\xf1\xdc\xde\xc2\xfb\x6e\xa3\xd2\xe3\xb3\xd9\x9c\x7e\x8b\x85\x25\x58\x27\xda\x72\x5e\xc6\xe5\x76\x0d\x96\x7c\x08\xd2\xc0\x37\xe8\x1b\xf1\xed\xf7\xdd\x0d\x7d\x7f\xe8\xa5\xfa\x7c\x02\x08\xb9\x79\x9b\x85\x75\x0a\xce\xc1\x92\x49\x10\x27\x4e\x92\xac\x40\xf2\x4c\x41\x4f\xe2\x44\xe4\xd0\x6f\xa1\xd0\x99\xaf\xb6\x62\xeb\x92\x21\x4f\xaf\x42\xa8\x4e\x25\x1b\x2d\xd7\x61\x18\x87\x72\xc9\x10\x67\x29\xf9\xb4\x29\x16\x6b\x0c\x36\x8a\x24\x4f\xf2\x2d\x59\x34\x33\x4e\x74\x04\xa2\x26\x93\xc5\x12\x46\x35\xed\x04\xd3\xa4\x81\xbe\x33\x54\xba\x31\x86\xe1\xde\x13\x75\xe3\xb0\xaa\xad\x9e\x53\xe5\x3c\xf4\xea\xba\x5c\xed\x74\xfb\xe9\x12\x1e\x15\x4a\x7b\x0e\x1d\x62\x8a\x87\xa6\xc9\x78\x4c\x18\x45\xa2\xf6\x4f\x97\xf5\xb8\x44\x9b\x78\xf1\xc9\x16\x9c\x87\xeb\x55\xe7\xb2\x66\x28\xbf\x34\x71\x89\x32\xd7\x27\x27\x1c\x0e\x89\x83\xea\x29\xc9\x74\x73\x46\x48\xc0\x88\x8b\x5f\x56\xe2\x53\x83\xa9\x91\xd4\xfe\xd4\xdd\xa9\x87\x53\x50\x78\xa9\x54\x30\x1a\xf7\x86\xa3\xe1\xc1\x52\x94\xf7\x49\x0e\x39\x28\x0f\x96\xc4\xa0\x48\x99\x8b\x25\x96\x2a\xa7\x43\x72\x93\x19\x51\x0b\x3e\x56\x2b\xd2\xf8\x74\x99\x90\x7a\xf1\xe2\xac\x09\x6b\xae\xc9\x87\x14\xce\xc5\x62\xbe\x08\x8b\x99\x7a\x61\xfb\xcc\x2f\xe4\x9f\x79\xa1\xb1\x26\x25\xe2\x52\x8f\xd5\x42\xfe\xe9\xf2\x2e\x06\xa3\xef\xa2\x3c\xef\xd0\xf8\x7b\x8c\x9b\x59\x4c\x34\xc1\xc8\x6b\x91\x92\xf0\xb6\x85\xc3\x02\x97\x26\x13\x5c\xa2\xd0\x15\x6b\x19\x29\x39\x6c\xb1\x18\xf4\xc7\xdd\xf0\xd4\xa3\x89\x80\x29\x00\x85\x6d\x72\x12\x35\x23\x9b\x09\xdc\xc8\x5b\x4e\x82\x6a\xc7\x02\x2a\xec\x68\x2f\xe0\xd9\xd9\x5a\x77\x79\xa4\xbd\x5c\xa8\xa3\x35\x97\x17\x12\x42\xb9\x50\xc0\xe0\x76\x96\x8b\x0b\x51\x15\x5a\xef\xb6\x73\x36\xdd\x54\x5c\xb4\xe1\x1c\xf5\x0d\xf5\x65\x72\xff\xd7\xbe\x30\x2b\x16\xd9\xd2\xfd\xa7\x5f\x3c\xfb\x4a\x67\xec\xd9\x67\xef\xf8\xca\x4b\x57\xee\x70\x3b\x16\xce\x9b\xb3\xe8\x94\xb9\x0b\xe7\xf5\x36\xcf\xec\xf7\xa2\xe2\xba\xd3\xc8\x43\xd1\x3f\x5f\x6b\xf7\xa9\xef\xa8\xdf\x51\x9f\x51\x7f\xcb\x5c\x0b\x86\x8e\xfe\xe1\xcf\x4f\x1f\x7a\x7f\x2e\x0b\xde\xba\xf7\xc8\x93\x5f\xfb\xd2\xcf\xfb\x3a\x5e\x86\xf4\xe6\xc6\xdf\xa3\xae\xc1\x38\xb2\x6d\x88\x5e\x7b\xca\xdd\x12\x71\x9b\xa8\x00\x15\x68\xcf\x79\x5b\x8b\x25\x33\xeb\xf5\x12\x2c\x0b\xb7\x2b\x6b\x97\x9d\x84\xb3\x58\x8a\x6b\xf8\x23\x53\xd2\x8b\xd4\x38\x57\x19\xfe\xdf\xd1\x59\x29\x88\x44\xe4\xf4\x80\x44\xb9\x1c\xc2\x20\xe9\x3d\xac\x49\x96\x72\x49\x28\xd6\x8e\x45\xc1\xef\x7e\xf2\xdf\x7f\xf8\xc9\x15\x77\x14\xd2\x4b\xcf\xdf\x77\xd9\xf5\x57\xb2\x9f\xbd\x7a\xf3\xe6\xab\xbf\x1c\x5f\xd0\xe7\x39\xad\x75\x6e\xef\x80\xeb\x8c\x4c\xc7\xfa\xf5\xae\xb1\x0f\xff\xaa\xca\x7f\xfe\x42\xf6\x95\x57\xbe\xf7\x9b\xb3\x9f\xbe\xe4\xb6\xdb\x2e\x39\xb2\x99\x14\x7a\xed\xa2\x28\x82\xcf\x3d\x35\xd8\x70\xc9\x92\x63\x5a\x3d\xce\x16\x3c\xff\xb1\x99\x58\xa8\xb8\x03\x46\xb2\xa9\xc9\x65\x6b\xb0\x35\x64\x5a\x44\x01\xe5\x0e\x62\x96\x46\x1c\x0b\x73\x8d\xa8\xa1\xc9\xa9\x8d\xdb\xad\x56\x81\x0a\xb9\xfa\xce\x55\x84\xd1\x54\x1b\xf9\x26\x92\x89\x49\x05\x3a\xe5\x51\xbc\x36\x80\x53\x04\xe4\xf5\x5a\xbc\x3b\xb4\xe2\x6f\xea\xf8\x84\x82\x9d\xff\x7b\x4f\xeb\x54\x5e\xfe\xfe\x85\xcb\xca\x01\xef\xc2\x53\x1d\x39\xb0\x02\x98\x26\x94\xee\xfc\x5a\x7d\x05\x37\x29\x7b\x63\xe4\xc0\xf9\x7a\xcc\xbb\x54\xdd\x82\xb1\x76\x12\xc4\x2c\xc5\x13\xb1\x9b\x19\xc6\x2f\x26\xc4\x44\xb2\xd1\x23\x17\x4b\x7e\x8f\xdd\x08\xa5\x65\x84\xd4\x1d\xa1\x1a\x96\x95\x9c\x08\x4e\xa7\xd2\x70\x5c\x23\x28\x8d\xa6\xb8\xbe\xdc\x58\x0d\x6d\x0d\x35\x78\x3a\x61\x3c\x5a\xa3\x40\x2d\x4d\x7f\x69\xe1\xd0\xa5\x5b\x34\x9a\x16\x0f\xaa\xbf\x2c\xe3\xea\xa8\x1f\xa2\x11\xd4\xdd\xe1\x04\x33\x1b\xae\x0f\x93\x32\x7f\xb9\xb8\x04\x5c\x5f\x06\xd8\x39\xfb\x67\x4f\x44\xca\xf1\xed\x62\x34\xe3\x06\xea\xcf\x22\x25\x69\xb4\x58\x0c\x06\x97\x44\xa0\xe4\x36\x70\xb9\x44\x96\xb1\x8b\xf6\x51\x68\x50\xe1\xff\x94\x01\xfb\x1d\x9c\xc3\x5c\xce\x2a\xea\xb9\xfe\x5c\xb9\xb6\x07\x8f\xa7\x9f\x70\x98\xe9\x27\xb3\xee\x72\xd1\xdf\x85\x47\xd8\x0f\x2e\x6e\x7b\x1d\x06\xe5\xea\xd0\xeb\xb9\xb1\x35\xfe\xd9\xf4\x9d\xfa\xe9\x55\x1e\x1c\x81\x07\x07\x6a\xbe\x22\x8c\xbd\xd7\x61\xec\xc7\x39\x4a\xc4\x60\x36\x43\x95\x27\xac\x90\x77\x12\x70\x3a\x5d\x0c\xef\xe2\xa1\x6b\xcf\xb3\x56\x8b\x75\xb0\x64\x11\x4d\x9a\x37\x54\xd3\xce\x5e\x6f\xc0\xaa\x27\x52\xfd\x9a\x74\x38\xcf\x9b\x91\xc3\xf3\x47\x1d\xd1\x73\x36\x3e\x82\xde\x77\x68\x1e\x82\xe6\xf2\xa1\x7a\x71\x18\x5b\xdd\x80\x67\xc3\xf4\x96\xf3\xb6\x34\x81\x31\xbb\xba\x95\x00\x9a\xdf\xef\xb6\xd1\x66\x17\xcf\x1b\xad\x66\xb8\x24\xc1\xcc\xa3\x3b\xb3\xc1\x9a\xe2\xb2\x9a\xae\x32\x6d\x8e\x7c\xb5\xb8\xac\xec\x8a\xe2\x6f\xe4\xe9\xe8\x96\x44\xfd\xba\x56\xc5\x0e\xd8\x9b\xc0\xea\xe1\x05\xea\x29\xf8\x48\x7c\x9c\x8a\xe0\x3a\xe4\x33\xc8\xbb\xe1\x77\x11\xad\x43\x5f\x17\xe1\x23\x76\x2a\x0b\xbd\x00\x58\x8c\x46\x7f\x80\x08\x80\x7e\x7b\x20\x1c\x20\xc3\x01\x40\x04\xd0\x4f\x4a\xa0\x18\x38\x3f\xf0\x48\xe0\xc7\x81\x0f\x02\x26\x04\xa8\xeb\xe4\x04\x9b\x30\x02\x1d\x6a\x33\x0c\xfa\xbc\x0e\x9b\xd9\xcc\x88\x36\x8a\xd4\x67\x86\x10\xd5\xa0\x1e\xb5\xcf\xd6\xc0\x3e\x00\x9c\xc7\xc3\x9e\x58\x79\x14\x7e\xf9\x04\x88\xe4\x23\x75\x94\x80\x08\xfd\xb8\x7a\xc3\xeb\x63\x37\xbd\xae\xee\x01\xbb\xd5\xcc\x2d\x64\xe1\x30\xb8\x1c\x9c\xf7\x20\x38\x7c\x83\x3a\x0f\x6c\x01\xcf\xa8\x37\xe2\xfc\xef\xb9\x2b\xc8\xb7\xb0\xc7\x72\x13\xb9\x19\x7f\x8f\x12\x75\x3c\xf6\xa1\x69\xcb\x1e\x82\x30\x1b\x0c\x01\xbf\x60\xb4\x4a\x0e\x07\x6a\x5c\x18\x2c\xb9\xac\xbc\xc7\x64\x44\x68\x9f\x46\x71\x4a\x7e\x4f\xc1\x76\xbc\xe6\xe9\x97\x2c\xea\xfc\x5f\x04\x1e\x52\x1f\xab\x95\x81\xfa\x2d\x70\xb7\x7a\x3d\x16\xc3\x79\x2b\x28\x47\xad\x1c\x8e\xff\x75\x05\x5e\x6f\x46\x5d\xcc\xdc\x8b\xe3\x80\xdb\x94\xb3\x0c\x1c\x19\x0c\x32\x01\x2e\x10\x92\x65\x79\x44\x26\x79\xb9\x5f\x1e\x94\xf7\xc8\x0f\xcb\xef\xcb\xec\x6f\xe4\x71\x19\x7a\xfd\x8a\x7c\xbe\xfc\x88\x4c\xf7\x28\x32\x08\x43\xf7\xff\x5a\x99\x22\xe4\x51\xf8\xdc\x01\xf9\x59\xf9\xc7\xf2\x6f\x65\x03\x82\x4e\x17\x11\x62\xf0\x48\xc9\xe5\xb7\xb2\xb4\x59\xb2\x53\x01\x86\xe1\x0c\x66\x28\x26\xca\xec\x00\x95\x56\x20\x3d\x5a\xd7\xd3\x65\x55\x39\x55\x02\x80\xca\x46\xa0\x70\x0a\x5f\x07\xc7\xa9\x25\x1e\xc5\xe8\x37\xc2\xcd\x79\xdd\x83\xea\x01\xf5\xd2\xfb\xd4\x53\x6e\x04\x2f\xa9\xbb\x6e\x21\x53\x0f\x02\x37\x28\xdc\x07\xbe\x79\xa3\xfa\x79\x70\xec\x0e\x34\xa1\x11\xfa\x9a\xc6\xb1\x8f\xb0\xcf\xb9\x96\x54\xb0\x2f\xb3\x1e\x68\x3e\x8d\x79\x6c\x95\x0b\xf2\xc2\x01\xf7\xef\x5f\x71\x2c\xf0\x7d\xe5\x34\xd6\x02\x02\x01\xda\x6f\xf1\x43\x5e\x28\xeb\x36\x2c\xa0\x61\x54\x44\xa2\xe1\x36\x73\xe4\x0d\xf2\x15\xf2\x41\xf9\x79\x3c\xe6\xc6\x84\x9e\x6f\x80\x4f\xa2\xa7\x0e\xc3\x27\x51\xc4\x64\xee\xa6\xe1\x73\xe8\xcf\x6e\x84\xcf\xb2\x0d\xf8\xaf\xd1\x2f\x18\x1c\x4a\x05\x23\x5a\x28\x95\xe1\xa5\x05\x0a\x0e\xa5\x5a\x65\xd2\x44\x79\x5d\x2e\xab\x83\x77\x0c\x96\x9c\x3e\x8e\xa1\x4d\x6e\x9e\xf7\xd3\xb4\x85\x35\x41\x15\x21\x09\xd3\x84\xa4\x5c\x3d\xd7\x50\xd8\x84\x38\x87\xd3\xae\xb5\x9c\x43\x69\x39\x4b\x1d\xe3\xfc\xd5\x90\x9f\xba\x75\xdd\xc7\xbb\x7f\xa5\x5e\xae\x3e\xb4\x05\xe4\xd5\x0f\xb6\x82\x07\x77\x3f\xf1\xe3\xcb\xc1\xd0\xb9\xea\x47\xa0\x7d\x87\xa0\xee\x80\xd6\x44\x02\x4b\xd4\x47\xc5\x4c\xc6\x0e\x6e\x05\xd7\x21\x05\x52\xff\x09\xec\x48\x81\xd4\x07\xd5\x76\xbb\xda\x87\x74\xa8\x49\x5d\xcc\xa6\x71\xdc\x3f\xa8\xa4\x44\x26\x44\x92\xee\x60\xd0\xc6\x58\x68\x39\xcc\x5b\x2c\x1c\x0c\x9a\x0c\x26\x0e\x4d\x2f\xe2\xa8\xa0\xc8\x50\x0c\x54\x03\x4d\x0b\xca\x19\xd3\x5a\xa0\x80\x1a\x04\x8b\xb2\xe4\x6b\x86\xbb\x62\x2b\x5d\xc1\x07\x62\x7d\x78\xa8\x94\x78\x25\xb4\xcb\xd4\x66\x68\xab\xbf\x5c\x70\x6a\x81\xdf\x61\x4d\xe2\x95\xa9\xae\xd0\x60\x5f\x58\x9e\x63\xe4\xd2\xf4\x7e\x07\x7d\x0d\xc6\x90\x1d\x52\x78\x07\xe3\x27\x49\xa7\xcf\x67\x65\xcc\x74\x20\x88\xe2\x54\xc5\x03\xad\x8b\xc5\xeb\x12\x58\x0b\x5b\x2c\xb9\x2d\xbc\xcf\x01\x17\x3e\x58\xb9\x37\xae\x09\xf4\xb0\x3c\xa6\x5c\x76\x75\x24\x6d\x15\x6e\x45\xa2\x3f\x33\x6b\xdd\xf1\xa3\xbb\x57\xb6\xc2\xa0\xfd\xa2\x42\xba\x75\xa5\x8e\xd9\x8b\xb9\xad\xdb\x6e\x0c\xd0\xfc\x71\x05\x73\x15\xcf\xc4\x82\xfb\x94\xc0\x79\xb2\x61\xa5\xc5\xc9\x79\x19\x26\x1c\x21\xc9\x30\x17\x8e\xc6\x64\x9f\x96\xf5\xf4\xa2\x5b\x45\xf7\xfa\x92\x09\xba\x5e\x3c\x15\x9e\xc8\x68\xcd\x32\x6a\x27\x4d\x6d\x3d\x4d\x5d\x3e\x85\x9a\x88\xd1\x3b\x71\x2a\xd6\xfb\x70\xb3\x7d\x71\x8a\xb9\x58\x3a\xc3\xa7\x9f\x8d\xe5\xd2\xec\xa3\x0c\xf7\xd8\x2f\x30\x96\xdb\x6a\x25\xe3\xb0\x48\x34\x1d\x92\x01\x08\x59\x42\x30\x46\xf5\x20\xb0\xe1\xc1\x92\xc4\x30\x46\xa3\x38\x54\x32\x1a\x49\x9f\x8d\x0f\xd1\x24\x0d\x37\x80\x48\xd4\x9e\x97\x27\xa7\x04\x29\xfe\x64\x42\x2a\x74\x50\xd4\x95\xeb\xfe\x50\x85\x1c\x2e\xe3\x10\xeb\x4a\x5f\x87\x38\xac\x7e\xaf\x06\x8e\x18\x6b\x7c\xed\x8c\xb2\x38\xba\xdb\x15\x6d\xac\xdf\x6f\xf2\x50\x0d\x0d\x1e\x1b\x95\x48\xc6\x42\x5a\xfa\x83\x35\x79\x4c\xeb\xa1\x33\x65\xf4\x78\xbd\x1e\x23\x05\xc2\x02\xd5\x30\xf1\x06\xbb\x5c\xc5\x59\x39\xae\xea\x50\x7b\x2a\x37\xd8\xac\x41\x8c\xe5\x0d\x75\xd4\x48\xf0\xd7\x13\xc6\x95\x9d\x77\xd1\xb0\x53\xd0\x04\x73\xf6\x25\xc3\xc5\x1b\x2b\x03\xcb\x9a\x3c\xbf\xfd\x29\xa8\xca\xe5\xc6\x2f\x1a\xc1\x5f\x54\x8f\x31\x56\x3b\xb8\xac\x8a\x0b\x1d\x27\x4a\x4a\xd6\x65\xf5\x49\x64\x2c\x26\x59\x21\x41\xd1\x20\xca\xc1\x0e\x96\x18\xa3\x64\x5c\x56\xf2\x49\x06\xc9\xe3\x91\x0c\xd0\xf0\xdb\x79\x14\xa2\x0e\x56\x20\x89\x4f\x4c\x50\x79\x56\x33\x26\x86\xad\x17\x4d\x3e\x27\x56\x89\x11\x49\x65\xf7\xa9\x03\x2b\x22\x4d\x65\xe9\xac\xe8\x5f\x85\xc1\xbf\x90\x64\x52\x9e\xaf\x5d\x63\xa8\x15\xce\xbf\x3f\x34\x88\x55\xb8\x68\x3d\xa7\x1c\xc2\x67\xda\x90\x92\x46\xf3\x2d\xe1\x7e\x80\x47\x9a\x1b\x7a\x0d\x1e\xc3\xfa\x92\xdb\xe3\xf6\x58\x1d\x22\x1e\x73\xe9\xa0\x02\x66\x0a\xcf\xb4\x04\x56\xc7\x64\x60\xeb\x49\xbd\x90\xba\x38\x26\x5c\xab\xeb\x71\xb6\x28\x48\x4c\x68\xec\x38\xdc\x14\x6b\x9e\xd1\x60\x04\x9a\x9f\xfd\xe5\x97\x5e\x3e\x7c\x6b\xde\x07\xf6\xdf\x73\x05\x2a\x0c\xc8\x97\x47\x42\xa9\xfd\xc5\x67\xff\x5b\x3d\xdf\xa7\xcf\x0d\x46\x39\x62\xe8\xa7\x2d\xc2\x75\x42\xf6\xf1\xf7\xd8\x47\x60\xdc\x11\x26\x92\xc4\x72\xa5\xb9\xc1\xe1\x30\x86\xe3\x3c\xef\x0b\x93\x74\x63\x4a\x20\x0c\xc4\x68\xa9\x81\xf2\xf2\x06\x60\xa3\x0c\x86\xa0\x25\x28\x8e\x94\x82\x4e\x4b\x64\xa4\x64\xa9\xed\x57\xc5\x71\x71\x7b\xae\x16\x17\x48\xf7\x24\x9c\x1a\xd6\x67\x0f\x54\x43\xd4\x61\x27\x1a\x22\xa2\x0b\xc6\x21\x55\xa0\x24\x00\x43\xca\x88\x9d\x7c\x64\xe3\x8c\x81\xd6\x74\xdf\xbd\x24\x8c\x06\x8b\x60\x26\xe8\x20\x3f\x39\x0c\x48\x40\x6d\x7c\x6e\x51\x68\x80\xfd\xf8\x03\xf5\x2e\xf5\x5b\x02\xf9\xd0\xdf\xfe\x41\xed\xfa\x3e\x39\x18\xfc\x9f\xdb\x64\x30\x08\x56\xa8\x87\xd5\x6f\x15\x3a\x3c\x9f\x8c\x13\xd9\xf4\x43\xea\x9b\x39\x20\x83\x39\xe4\x23\xea\x31\xf5\xbf\xc1\x2c\x20\xe2\x99\x4a\xe3\xef\xd1\x09\x18\x7b\xa0\x39\xc9\xa7\x28\x09\xca\x6a\x35\xd0\x62\x80\xe3\x02\x32\x15\x4f\x58\x83\x0d\xc1\x62\x29\x0c\xf7\x92\xd7\xe4\x75\x2c\x2b\x79\xdd\xb8\x6e\xc7\x5e\x47\x59\x2d\x55\xd0\xd7\x6b\xd7\xab\x00\x59\x31\xd2\x91\x00\x8e\x48\x58\x40\xb8\x82\x5a\x41\xa0\x06\x73\x24\x94\xf1\x4d\xc9\x6f\x9f\xbd\x15\x5c\xbf\x5a\x95\xc2\x60\x13\x38\x67\xec\xe8\xcc\x3d\x67\x75\xde\xd8\xda\x7a\xef\xca\x37\x5e\x39\x54\x6c\x6e\xcb\x04\x53\xd4\x85\x0f\x1c\x7c\xfc\x36\xf5\x30\xb8\x53\xdd\x38\xe4\xf8\xd2\x6d\x45\x87\xa5\x4b\x6e\x79\x17\x90\xce\x63\xbb\x44\x4d\x3e\xea\x53\x58\x3e\x0d\x44\x1a\x59\xe3\x46\x51\xe4\x62\x0d\xa9\x86\x10\x1a\x90\xcb\x52\xcd\x19\xd1\x40\x5b\xe8\xd1\x52\xa3\xc5\xc2\x37\x44\x95\x50\x34\x0a\x23\x43\x22\xea\xe4\xe3\x23\x25\x5e\x97\x50\xb9\x39\xe7\x58\x39\x87\x5f\x21\x06\xe5\x70\x34\x7a\x98\x06\x82\x8a\x9d\x40\x54\x30\xea\x12\x62\x4e\x4d\x54\x34\xa9\xbe\xa8\xbe\x61\xff\xdd\x09\x25\x76\xd7\x33\x1b\x2f\xe8\xc3\xd2\x72\x70\x20\x02\x3a\xa6\x91\x98\xec\x04\xea\x31\x76\x5e\x55\x62\x58\x66\xea\x53\x58\x66\x48\x27\x57\x28\xe9\x06\x96\x25\x9c\xae\xb8\xcb\xe6\x61\x18\x8f\x9f\x6a\x4c\x05\x58\x34\x93\xbb\xd4\x10\x0e\x93\x2e\x87\xe2\xb0\x2c\x2b\x39\xdc\x64\xa4\x58\x22\xcb\x82\x23\x4e\x42\xed\x64\xb1\x41\xea\x50\x4f\x48\x59\x72\x65\xf1\xe6\xea\x24\x97\xba\x72\xe9\x05\xdf\xfc\xba\x2e\x3a\x52\xc0\xc2\x25\x53\xb5\xb2\xf3\xa5\x59\xf5\x87\xa0\x53\x78\xf7\xef\x48\x80\x60\x31\x92\xae\xd6\x9f\x73\x0a\x24\x6c\x3d\x8e\x8f\x9a\x35\x2c\x04\x34\x17\x9a\x7d\x09\x52\x98\x27\x1e\x51\xd6\xc8\xa2\x2f\xec\xc7\x43\x82\x00\x0b\xf7\x51\x73\x9a\x33\x90\xf0\xf7\x49\xbf\x8f\x0d\x30\x01\xa6\xd0\x19\x88\x46\xb5\xd9\xd0\x30\x36\x45\x23\x82\x80\x9f\xb5\xb2\xa6\xb8\xa3\x9d\x4f\xcb\x69\x84\xee\xdb\xa8\x34\x66\x47\x4a\x8d\x26\x05\x7a\xc4\x4e\x9b\x81\x33\x71\x23\x25\xc9\x6e\xa2\x64\x4a\x03\x3b\xa9\x3a\x3e\xf5\x85\xbf\xfd\x55\x1f\xae\xee\x02\x6b\x32\x9c\x87\xfe\xad\xfd\xd3\x4f\x92\x76\xd6\xd5\xca\x7e\xfa\xb9\xd2\xa3\x75\x65\xb3\xff\xd9\x94\xe9\xfa\xda\x61\x6d\x26\x13\x73\x29\xe6\xf3\x51\xa5\xe7\xa4\x7c\x0e\x17\xf6\x16\x9e\x2d\x50\x7c\x01\xd4\x71\x76\xb0\xd4\x88\x60\x29\x9a\x74\x31\x0c\x4e\x10\x83\x58\x61\xfa\x20\x62\x3a\x2f\x53\xe2\x04\xa6\x7b\xa6\xe4\x73\x59\x57\x91\x20\x40\xb5\x68\x66\x5a\xae\x7f\xaa\x19\x4e\xf5\x5c\xff\x74\x13\x9d\x96\xd6\x17\x2a\xff\x47\xf3\x9d\xe8\x40\x85\xe3\x38\xff\xcc\x38\xe1\x79\x88\x90\x83\x7b\x12\x3e\x1f\xe1\x49\x36\x37\x7b\xcc\x94\xec\x64\x64\x26\xd3\xd2\x9c\x4c\xc6\xc3\xd1\x30\x74\x20\x13\x1e\x37\x09\x1d\x48\x22\x41\x92\xc1\x54\x94\xf2\xc9\x41\x19\x1e\x2a\xc6\xa0\xc3\x08\x8f\x4a\x63\x80\xd0\x6f\x1d\xab\x3e\x58\xf9\x96\xb5\x4e\x45\xcb\xd7\x5b\xda\xb6\xee\xc4\x19\xe7\x9a\xfc\x73\x27\x3e\x3d\x79\x30\x45\xad\x00\x79\xf9\xb6\xe5\x7f\x7b\x5b\x1d\x53\x3f\x2a\xe7\xa0\x1f\xb9\xeb\x6b\x0f\x6f\x1b\xdd\x59\xa9\x86\xc8\xee\x05\xb7\xdf\x41\x1e\x6b\x53\xdf\x50\x9f\x53\x7f\xa6\xfe\x1c\xa7\xa0\xff\x0e\xec\xc7\x3f\xf6\x6e\xae\xbb\x5a\xbf\x8c\xfc\x6c\x65\x9e\x2c\xaa\xc3\xfb\x15\xce\x45\x43\xfa\x1b\x3c\x1e\xc2\x1d\x6f\x12\x9a\xdc\x66\x2a\xc8\x04\x19\x54\xa5\x1e\x47\x50\x66\x50\x4b\x1a\xdc\x2e\xd2\xb5\xac\x44\x34\x90\xa4\x3f\x19\xe6\x3d\x41\x7f\x70\x10\xd2\xef\x17\x11\xcc\xf4\xa7\xa6\xbf\xac\x2c\x15\xfa\x35\x50\xf9\xda\x44\xf4\x94\xd4\x03\xf0\xf6\xdc\x99\x4f\x1e\xfd\xd9\xb3\x5a\x1e\xfa\xb7\xd7\x7d\xa1\x6f\x79\xae\x72\xd3\x70\x11\xbe\xdd\x53\x49\xa3\xf8\xd1\x5f\x3e\x50\xff\xad\xa5\xa2\x6f\x79\xe1\x79\xa1\x6d\xea\xca\x09\x34\x1b\x5b\x9f\xcd\x1f\x22\x96\x2a\x8d\x06\x09\xc6\x65\x8c\xc4\x07\xf9\xa0\x1c\x0e\x18\x30\xca\x22\xcf\x79\x29\xce\xb9\xbe\xc4\x39\x83\x93\xa3\x05\x2d\x87\x59\x53\xf7\xe4\xe8\xae\xc6\x37\xce\x48\x79\x24\x76\x6c\xf2\xbc\x6c\xfa\xfa\x59\xed\xea\x2d\xfa\x60\xec\x8d\x13\x46\x66\x7f\x5b\x8f\xcc\xca\xa3\xb1\x27\xce\xcd\xd6\xe3\x04\x17\x8c\x13\x7e\x83\xe3\x84\x65\x4a\x93\xc1\x1b\x86\x6b\xf7\xda\x65\xbb\x1c\x89\x6a\x37\xe6\x76\xce\x6f\x28\x96\xfc\x3c\x27\x2e\x2b\x01\xce\x2d\xd7\x45\x67\x9e\xfe\x17\xcb\x95\x93\xb5\x29\xd8\x9a\xe5\xc7\x26\x8d\x83\xaa\x41\xb6\x96\xa8\x2c\xea\x09\xa8\x9f\x09\x65\x2f\x8f\x8b\xda\x57\x8e\xd4\x6a\x67\x42\xd5\x0c\x8c\xb2\xeb\x35\x45\x73\xf1\xfd\x6a\x03\x71\x8e\xd2\x2d\x3b\x9d\x61\xbb\xdd\xe8\x21\x3d\x64\x3c\x21\x3b\x46\x4b\x5a\x62\x85\xb2\x50\xb2\xec\xf6\x47\x42\x00\x43\xc0\x20\xe0\x17\xe8\x9a\xc2\x9d\xc6\xb8\x1d\x0c\x2a\x35\xd2\x35\x4e\xa8\xcb\x0b\x4d\x9c\x63\x80\xfb\x21\x34\x5d\x33\xd4\x5f\xf4\x78\xc1\x14\xf7\x58\xcc\x55\x87\xd4\x0f\x55\xb5\x7a\xc9\x33\xe1\xce\x94\x31\xfa\x3e\x79\x57\x7d\x46\x7d\xa4\x7a\xbb\xf3\xd0\x54\x57\x74\xda\xbe\xc2\x33\x97\xa2\xc4\x56\xa5\x3f\x28\x08\x21\x9b\xcd\x00\x0d\x08\x19\x6b\x08\xda\x8b\x25\x3e\x38\x18\x1c\x09\xee\x0f\xde\x1d\x7c\x38\xc8\x1a\x29\x84\xed\x29\x07\x00\xd4\x3b\x68\xa8\xbd\x3c\x82\xf7\x1c\x84\x94\xba\x44\x86\x2b\xfe\xff\x50\x5a\x73\xb7\x33\x25\x9d\xb4\x67\xfb\x6b\xfa\x4e\x7a\x77\xc2\x55\x2a\xb5\xc7\x7b\xfc\x7b\xef\xa8\xfa\x6d\x0e\xb8\x7b\x8a\x4b\xbb\x4a\x5d\xd8\x1d\x38\x8e\xd8\xa4\x74\x97\xef\x86\x09\x8a\xc2\x77\xc3\x9f\xf2\xd2\x9b\xf4\x9f\xe8\xca\x7b\x42\xdc\x5a\xdb\xdb\x33\xcd\x45\xf7\x34\xdd\x3c\x7a\xfb\xce\x34\x17\xdd\xeb\x2b\xb5\x61\x74\x0a\xe7\xb7\xb6\x2b\x7d\x93\xe9\x81\x22\x83\xd4\x8c\x88\xfb\xc5\xbb\xc5\x87\x45\x28\xb2\xe9\x6e\xbc\x39\x91\x3c\xc9\x55\xfe\x34\x74\xc5\xa6\xbf\xf4\x4e\x4d\xd9\x86\x73\xe2\x3b\xef\xdf\x6a\x79\x11\x1c\x87\x47\x88\x55\x4a\xc6\xc9\xd1\x00\xa0\xd4\xc8\xd4\x69\x11\x10\xe0\x29\xca\x1f\x66\x00\x53\x1b\x82\x4f\x9f\x4c\xa8\x44\x7c\x68\x34\xe5\x89\x67\x85\xab\xd7\x6d\x9e\x25\x4c\x35\x2e\x1c\x5a\xbb\x0f\x5c\x27\x9c\x18\xae\xe5\x44\x5e\xc7\xb6\xee\x74\xa5\xc1\x65\x65\x48\x12\xae\x39\x6c\x0d\x47\xa2\xb2\x4f\x0b\xbc\xbd\x06\x83\xd9\x2c\x0d\x95\xcc\x66\x32\x60\xe7\x69\x54\xb4\x1a\x66\x49\x16\xe7\x45\x3e\x2d\x19\x71\x31\x36\x35\x1d\x95\x79\xc6\xaf\xff\x6e\xdd\x2c\x61\x72\x52\x24\x93\x41\xa3\x36\xed\xd3\xe6\x44\xca\x7b\x85\xfd\x27\xce\xe9\x9f\xa9\xe4\x9c\x66\xb3\xd1\x00\x77\x36\xe3\xf5\x91\xa4\x8b\xf7\xf2\x5e\x7f\xc0\x83\xe3\x6d\xd6\xc4\x9a\x1c\x2e\xab\xe8\xa0\xbc\x66\x06\xc7\xdd\x94\xd5\x61\xd4\x8e\x9d\x1a\x75\xaa\xf1\xc8\x26\x37\x7d\xb5\xd7\x1c\x41\x95\x91\x78\x42\x75\x56\x1e\x3b\x0b\x6e\x91\xfd\x87\xc7\xfe\x12\x53\xc5\xc3\x6a\xe1\xd0\x21\x78\xbc\x1c\x06\xbf\x06\x7b\x2b\x67\x4f\xdb\x27\x7b\xe8\xcb\x3f\x79\xb5\xbc\x53\x8e\xd3\xd4\x71\xed\xe8\x01\x44\x16\xee\x91\x7f\xe0\xfc\xfd\x5a\x25\x3b\x1d\x1d\x83\x90\x0e\x93\xe8\xe0\x35\x1a\x06\x4b\x2e\x0a\x58\x45\x34\x83\x15\xf5\xb0\x55\xcb\x0d\x4e\x46\x40\x6c\x1a\x02\x68\x48\xc0\x4f\xab\x53\xfd\xaa\xc3\xfe\xf4\xa3\xa7\x76\xac\x1f\xda\x12\xe5\x91\x7f\x76\x18\xd3\xa4\xa0\x83\x6d\xc7\xb9\x84\x41\x42\xcf\x2d\x30\x4f\xb2\x2f\x39\x12\x68\x62\x13\xc2\x7f\x07\xbb\xc0\x52\x34\xe9\xc4\xc9\xa0\x49\x27\x7f\x39\xec\x0e\x51\xa6\x32\x0a\x41\x79\x4e\x30\x9a\x37\x89\xe6\x04\x0b\xac\xf1\xf8\x76\x3c\x17\x25\x81\xe7\xa2\xfc\xf5\x70\xaa\x8d\x63\xeb\x31\x0e\xf0\xfb\xef\x2a\xbf\x3f\xb1\x09\x5c\x0e\xb6\x10\xde\x23\x14\x19\x65\x12\x14\x7c\xcd\x07\x87\xe3\x4e\xed\x13\x2a\x98\x44\xda\x67\xd8\xca\x9f\x41\x6c\xba\x80\xc0\xaf\xc8\x0b\xf8\x15\xef\x1e\xee\x4a\x68\x9f\xa2\x23\x12\xe9\x9f\xc3\x1e\xc1\xb1\xda\x17\x08\xfd\x3d\x18\x07\x9e\xb3\xf1\x00\x7e\x8c\x7a\x71\x76\x63\x3a\x1b\x75\x3a\x83\x3a\x36\x43\x80\x49\x00\x51\x4e\xfa\xbd\x53\xcc\x73\xb9\xb4\x3c\xcf\xc5\x78\x9c\xd8\x0b\x7f\x01\xff\x9e\x0c\x42\x52\x4d\xe1\xc6\x09\xf3\x5f\x10\x7e\xd8\x0e\x66\xb1\x9d\x05\xcb\xf0\xe3\xf9\xf0\xf5\x33\xa9\x17\xec\x2c\x34\xf0\x95\xdf\x23\x3e\xa0\xdf\x63\x3e\xec\xd1\xf9\xd0\x5c\xe6\x43\x36\x28\x58\xea\xf8\x80\xdf\x03\xf1\x01\xbd\x07\xe2\xc3\xa8\xc6\x87\x66\x8d\x0f\xff\x82\xaf\x10\xf9\x5a\x3e\x10\x94\x1e\xa3\xae\x86\xb1\x53\x8e\xe8\x27\x0e\x28\xcb\x2b\xc1\x53\x4b\x63\x63\xc7\x0c\xc0\x72\x06\x03\x3b\xa3\x1c\x3b\xcd\x52\xa6\x8b\x51\xdb\x66\x16\x66\xae\x2b\xa5\x0b\x9f\x32\x36\x6d\x2f\xf7\x2d\x9d\x20\x2e\xad\x89\x8d\xaa\x79\xd8\x4f\x19\x95\x82\x0a\xdc\x41\xbb\x9b\xa9\xf9\xf9\xd3\xc7\xa7\xe0\xa2\xae\x26\x04\x82\xd0\xd4\xa5\xde\x89\x50\x12\xfa\x92\x4d\x5d\xff\x61\x94\xfa\x40\x53\x0f\x7c\x15\x7a\x0f\x8c\xa9\x30\x03\xf2\x5b\x8f\x55\x6d\x3a\xbf\x1f\x51\x46\x4e\xc2\xef\xf0\xac\xbd\xb3\x9e\x9d\x45\xf1\xb3\x80\x89\x9a\x2e\x30\x45\xbc\x5f\x5e\xcf\xfb\xe9\x42\xd4\x93\xf0\xbe\xbe\xad\x63\x6a\xfe\x7f\xaa\xf8\x74\x3a\xfe\x7f\xca\xd9\xc3\x1b\x26\xf3\xfe\x3f\x8c\x57\x37\x4c\xe6\x3d\xb1\x0e\xee\x8f\x7b\xd9\x5d\xb8\x8e\x66\x00\x21\xea\xb6\xa5\xd3\x85\x99\x52\xdc\x16\x6f\x74\xcc\x94\x19\x96\x60\x89\xd9\x73\x3a\x94\x19\xca\xba\x52\xcb\x8c\xa8\x82\x47\x16\x8f\x94\x9c\x4e\x4a\x8e\x46\x7d\x23\xa5\x28\x4d\x59\xe0\x89\x43\x39\x6b\x1a\xa9\x6a\x21\x3f\x35\xc6\x4e\x4a\xab\xa0\x4e\x56\x3a\x16\xfd\x74\xcd\x1c\xd4\x74\x7a\x7b\xef\x38\xf1\xdf\x4f\xdc\x5f\xdb\xd8\x71\xf1\xee\x09\x8d\x1d\x77\x4e\xc1\xb4\x2d\x8f\xbd\x9a\xae\xef\xf0\xf8\xe2\xa5\x13\x3a\x3c\x68\x71\x12\xab\x20\xaf\xf0\x2c\x67\xa8\xa7\x8d\x44\x07\xa1\x40\x7f\xbc\x2f\x9b\x4a\xe5\x7b\x34\x5e\xf5\xc8\x8c\x89\x32\x51\xb3\x06\x9a\xfb\xda\xa9\x2e\x9d\x51\xd5\x11\x64\x34\x9a\x16\xc4\xc8\xfa\x3c\xe7\xca\x34\xe7\x1a\x8e\x95\x07\xa2\x23\xa6\x49\xed\x53\x71\xec\xd3\x0e\x74\x76\x4e\xa7\x67\x27\x19\xf4\x7c\xf1\x14\xbc\x3a\xe1\xec\x67\xf2\xe8\x44\x2e\x01\x64\xa3\xa9\x43\xb8\x3e\xb2\xa8\xa4\xfc\x82\xc3\xc7\xf9\x60\xac\x47\x87\xe8\x50\x24\x2a\xf8\xfd\xd0\x3d\xf1\xfb\x09\x8f\xcf\xe9\x71\x8e\x96\x24\x0f\x45\x98\xa0\x07\x4f\x38\xf5\x41\x49\x13\x7a\x0d\xeb\x78\xa0\xe1\x5f\xd5\x28\x0c\x24\x1f\x94\xcb\x76\x11\x6f\x5c\x34\x78\xfc\xd4\xa7\x17\xd1\xb3\xbd\xf1\x7d\x8b\x6e\x3c\x78\xef\x57\x17\x80\x81\x8b\x7e\xbf\x22\x34\x97\x02\xea\xa1\x6f\xbe\xac\x7e\xe0\x8a\x05\x41\xcf\xcb\xcd\x5d\xf7\x3d\xf0\xe0\xa1\x65\xe0\x49\xf1\x27\x60\xe6\x32\xb5\xdb\xfa\xf3\xc7\x5e\x7c\xab\x3c\x4f\x76\x2e\xb5\x1c\xcd\x19\x25\x57\x94\xfb\xcd\x99\xab\xd8\x56\xc2\x4f\xc8\xc4\x35\x4a\xc8\xe4\x85\xc1\x95\xd9\xed\x0e\x90\x02\x29\x84\x23\x37\x46\x0e\x46\x0e\x47\x3e\x8c\xd0\x7f\x80\x5f\xc8\x08\xba\x6c\xce\xcd\x98\xb9\xe0\xda\x08\x20\x89\x48\x38\x52\x8c\xec\x8d\xd0\x36\x2a\x10\x1c\x2d\x05\x18\x45\x9b\x33\x39\x52\xb2\x4a\x66\x86\xf2\xba\x05\x5c\x74\xe8\x31\xb9\x70\xd9\x61\x75\x64\x6b\x3d\x48\x81\x7e\xeb\xbc\x66\x9b\x8e\x9a\x53\xcd\x78\xe4\x26\xb5\xdc\x57\x87\xdb\x50\xf0\x71\x4f\x4d\xd8\xa2\x17\x17\x7e\x9d\xdc\x31\x05\xe2\x00\xae\xac\xd7\xf0\x08\x98\xe7\xb6\x6c\xd1\xf2\xd0\x78\x5e\x0f\xfd\x3b\x4c\xf7\xb9\x4a\x37\xeb\x76\xcb\x01\x83\xd3\x19\xf0\xdb\xfc\xb6\x70\x84\x88\xd8\x23\xad\x91\x89\x23\x7b\x02\xc1\x65\xa5\x13\x8f\xeb\xf9\x11\x96\xf0\xa4\x69\x3d\xb5\x64\x9d\x68\x60\x0f\x9a\x62\x3f\xe5\xb8\x9e\x59\xe4\x8e\x93\xcc\xea\xc9\x62\xc2\x28\x5d\x9e\xab\x21\x5d\xe8\xa4\xb9\x5d\x89\x40\x89\x46\x03\x81\xc6\x16\x28\xd4\x16\x24\xd4\x8e\xfc\x8d\xf9\x83\xf9\xc3\xf9\x0f\xf3\xf4\x1f\xe0\x17\x32\x8f\x84\xda\x89\x84\x9a\x87\x42\xcd\x87\xf3\xc5\xfc\xde\x3c\x14\x6a\xbc\x2d\xdd\xb6\xae\x24\xa7\xff\xff\xe4\x8a\x9f\x9d\x52\xb6\x9f\x46\xbc\xd3\x9d\x22\x53\x88\x1c\x1c\x9c\xbc\xa3\x4f\xa2\x03\x1f\x4d\x65\xf7\xb4\xf9\x4d\x36\x9d\x6f\x17\x2b\xfd\x50\x23\x30\xdf\xa0\x52\xb4\x20\xa5\xe8\xc8\x13\x79\x7b\xbe\x35\x3f\x51\x29\x10\x9f\x96\x43\x3e\x9d\x58\x2f\xf4\xb3\x77\x5a\xd5\xf8\x34\xda\x31\x1d\x57\xa6\xd4\x18\xf2\xda\xc9\x7c\x39\x89\x0a\x4d\x3e\x3a\x75\x7f\xf4\x02\xec\x97\xb7\xeb\xfe\xe8\x55\xba\x3f\x9a\xd0\xfc\xd1\xe3\x87\x53\x12\x27\xd4\xf9\xa3\x18\x3b\x16\xfb\xe5\x43\xfa\x8c\xc3\x07\x08\xcd\x23\x4d\x68\x1e\xe9\x18\x7c\x0d\x43\xd4\x63\x85\x56\x70\x75\x05\x3c\x0b\x3d\x27\xf2\x3c\xe1\xb6\xd9\x18\x02\x06\x4d\x0a\x9a\x85\x1e\xf6\x91\x7e\x4a\x84\x91\x5e\x4d\xb6\xc4\x48\x1a\x2d\x18\x64\xd7\x31\x01\x64\xb7\xda\x09\xb0\x7d\xc2\xbc\xac\x2a\x18\x28\x68\x77\x38\x23\x3e\xe0\x44\x43\x5b\xcc\x60\x02\xa8\x2e\xb9\xff\xed\x5f\x31\xc7\xf7\x91\xbf\xfa\xfd\x1b\x6f\x98\xa8\x5d\xa6\x5f\xd5\x23\xe8\xaa\xff\x44\x93\x22\xd4\x1f\xa9\xef\xd0\xdf\x55\xc7\xd5\xb7\x41\x00\xd0\x58\x8f\xaa\xb8\xb9\x88\x8e\xdd\x4a\x16\xd2\xc1\x40\x3a\x08\x86\xf0\xfa\x0e\xf8\x9e\xf5\xfd\xd6\x47\x21\x5a\x5a\x7d\x54\x3f\x7a\x40\xa2\x07\x0a\x7a\x0e\xfe\xcc\x53\x3e\xb4\x1b\x43\xf1\xc6\x05\x22\x0f\x0f\x56\x31\x20\x92\x1c\x24\x93\x34\x1a\x1d\x18\x20\xd4\x32\x01\x63\x57\x27\x33\xad\x17\x3c\x6d\xab\xa7\xb5\x16\x6c\x17\x4d\x21\x0d\x41\x5a\x59\x43\xa4\x0e\x5e\x77\xc1\xde\x3d\x8c\x4a\x43\xf7\xec\xd2\x8b\x0c\xe0\xdf\xa6\xcb\x2a\x88\xba\x63\x5b\x9e\xfc\xc9\xcf\x8e\x50\x33\xbe\xfa\xf4\x91\xfb\x6a\xf5\x80\xbe\xad\x4e\x0f\x68\xaa\x91\x49\xd0\x14\xd2\x83\xb4\x97\x60\xa6\xd6\x03\xfa\xf6\x3a\x3d\x80\xaf\x11\xf0\x6b\xc6\xe0\x6b\x26\xe8\xc1\xb6\xf1\xf7\xe8\x7f\x41\x5f\x2d\x84\xbd\xb5\x75\x4a\x7b\x5c\x96\xd3\x6d\x16\x9b\x8d\x6b\x73\x53\xa8\x14\xb8\xd0\xd5\xd8\xd1\xd2\xb1\xae\x14\x6d\xf1\x2a\x56\x6e\xb4\x64\xb5\x12\x6e\xaf\x57\x40\xa3\x7e\x08\xe3\x48\x89\xaa\x1c\xb4\x15\x37\x8d\x38\x91\x8f\xc6\x54\x1c\x34\xa8\x0c\x79\xa8\x07\x9a\xa3\xe1\xd4\x67\x70\x4d\xe7\x97\x91\x03\xff\xf3\x73\x76\x56\x3c\xff\xcd\xdd\x7f\xfc\x3f\x7a\xec\x19\x72\x8e\xe5\xcd\xbf\x8d\x3e\x35\x2f\x34\xc0\x7e\xf0\x1a\x58\x01\x16\xaa\xd7\x4b\x93\xf7\x9f\xab\x1f\xf4\xbc\x94\xea\x05\x2d\x20\x34\x0c\xfc\x80\xcc\xa6\x1f\x02\xf1\x1c\xd4\xb8\xaf\xaa\x47\xd5\xeb\xd8\xf4\x54\x76\x09\xcf\xb1\xad\xd8\xa5\x51\xa5\x1d\x1b\x25\x1f\x00\x44\x8b\x91\x12\x6d\x22\xb2\x4b\xfe\x62\x09\xc1\xa7\x69\x33\x6c\xcb\xf6\xc8\xa2\x18\xeb\x06\xd8\xd6\x58\xa1\xc9\xe8\xf4\xd5\x2b\xfd\x13\x0c\xb1\x9d\xce\xfe\x4c\x3f\xdc\x16\x3c\x3a\x45\x2c\x35\xc5\xc0\x5b\xf2\xfd\xc9\xa4\x43\x53\x3a\x0b\xea\xdc\x7f\x41\xdf\x24\x48\x44\x88\x95\x4a\x9a\x0e\xcb\xac\x4b\x0e\x5a\x82\x96\x68\x2c\xc0\x30\x76\x60\xf7\xae\x2f\xb9\xec\xce\x90\x3c\x5a\x0a\x01\xc5\xc2\xb2\x41\x1a\x20\x80\x07\x40\x55\x1b\xa5\x2a\x87\x32\x26\x5a\xa8\x1d\x00\x84\xc1\xeb\x6a\x0b\x20\x31\xe4\x55\x25\x8b\x5f\x00\x05\xf8\xec\x2c\x32\xf3\x20\x54\xf5\x0d\x37\x83\xab\xf7\xa8\x0b\x2f\xd8\x75\xf9\x50\x66\x55\xd0\x94\x69\x13\x0a\x81\x85\xfb\xe6\x8d\x8d\x7d\x42\xee\x60\x8c\x28\x16\x5c\x4c\x1e\xc6\x67\xce\xf3\xbf\xba\x67\x91\xc7\xf9\x8f\x75\x92\x6f\xef\xe7\xa9\x6d\xaf\xe3\x63\xb9\x3c\x3f\x8f\xfe\x9d\x43\x9f\x9f\x47\x5e\x45\xfc\x50\xcb\x13\x80\xb0\x90\x00\x52\x28\x6c\x93\x6a\x30\x1c\x29\x9d\xf6\xd5\x90\xf6\x14\x91\x27\xd6\x2b\x6d\x74\x43\x28\xd4\xd4\xca\xba\x5a\x11\x03\x3a\x0b\xb5\x0c\x48\xe6\x32\xb9\x75\xa5\x48\xe6\x44\x3c\x68\xaf\x24\xc4\x27\xb1\xe1\xe4\x9c\x30\x4d\x27\xfa\x93\x71\x87\xfa\xcc\x64\x05\x38\x11\xbb\x80\x79\xaa\x33\x48\x9b\x3d\x68\x2b\xf3\x0e\xda\x91\xe7\x20\x8f\x24\xc5\x4a\x22\x00\x4c\x12\xf0\xd9\xa0\x4d\x9a\x90\xdf\xd0\xf8\xf7\x16\xe4\x5f\x0c\x72\xf0\x4c\xa5\x83\x6e\x48\x26\x23\x21\xd6\x15\x42\xfc\x6b\x4a\xd7\xf2\x2f\xc1\x87\xe5\x30\x69\xa2\xc2\x0d\x27\x52\xa3\xb7\xda\xb5\x3b\xf5\xff\x3f\x16\x82\x78\xde\x99\x13\x41\x04\x7f\x3d\x19\xdb\x40\xe3\x9d\xcf\xaa\x6f\x82\x24\xfc\xfa\xeb\x13\xb1\xeb\x3b\x11\x60\x8f\xab\x1f\x6a\x5f\x6b\xf4\x0c\xcf\x23\xd6\xf4\xec\x6e\x40\x94\x79\xd5\x88\x78\xb5\x38\x94\x9c\xc4\x2b\x5c\x83\x06\x75\x4d\x26\xd2\x44\x81\xb8\x48\x99\x29\x20\x34\xe7\x76\x89\xa2\xda\xcd\x21\x73\xa8\xab\x9b\xef\x06\x16\x2a\x95\xcf\xe6\xd7\x95\x62\x59\xab\x12\xf4\xd8\x2d\x08\x76\x47\x42\x58\x42\xae\xf5\x25\x83\x01\xf8\xac\x54\x68\x52\x49\x5a\x7d\x1e\xb9\xce\x2d\x9c\xe8\xfb\xe8\xf5\x50\x27\xc8\x8d\x4f\xa7\x82\xb8\x60\x6d\xaa\x84\xf9\x6d\x53\x39\x86\x27\xc8\xa0\x33\xcf\x4d\x65\x7f\x71\x2d\x1b\xb4\xbf\xda\x79\x74\x9e\xd2\x45\xe0\x03\x89\x11\x84\x36\x0f\xe7\xe1\xb4\xd3\x68\x39\x3c\x8d\xfc\x4a\xc8\xc2\x6a\x4d\xb8\x0e\x87\x28\x52\x43\x25\x51\xe4\x8d\x7e\x9e\x13\x78\x61\x10\xfa\x2c\x27\x65\x4b\x5d\x7e\x57\xaf\x0a\xa8\xab\x35\x14\x27\xd6\x54\x4e\xc7\x12\x30\x50\x4e\xb9\x23\x4f\xb0\x92\x87\x07\xaf\x4e\x61\x8d\x1b\x6b\x12\xf0\xb8\xc0\xbb\x26\x3b\x0f\xe6\x4c\x8e\x7d\x7b\xd4\xc5\x18\xab\x48\x20\x66\x28\x41\xad\x37\xc1\x4a\x38\x9c\x0c\xee\xad\x26\xec\x14\x6a\x4b\x18\x29\x59\x1c\xa6\x9a\x72\xd1\x2a\x75\x95\x8b\x53\xaa\xb6\x23\x01\xdd\xb2\xad\xc5\x68\x39\x2f\xa0\x06\x89\xab\x10\x7a\x0e\xf5\x0c\x90\x5c\x9f\x6c\x76\xe3\xfb\x28\x0d\x94\xa9\x82\x4b\x80\x30\x89\x04\x84\x1b\xcb\x9a\x4c\x0c\xc3\x71\x82\xc3\x29\xf0\xbc\x15\x72\x99\x46\x83\x89\x19\x0c\x67\x62\xac\xc0\x99\x4c\xc4\x66\xd2\xb1\xf4\xeb\x17\xa0\x43\x0e\x5d\xab\xf5\x4c\xea\x10\x36\xd5\x56\x88\x30\x86\x1b\x82\x4e\x1c\xea\x8d\x7c\x06\xee\x15\x6d\xd6\x7f\x1b\x31\x93\xb8\x50\xe9\xf1\x32\x4c\x73\x22\xd1\xde\xc5\x11\x72\x17\x81\x40\x41\xfa\xfa\xb3\x3d\xf9\x9e\x75\xa5\x54\x5e\x54\xbc\xf4\x68\xc9\xeb\xb5\x8b\xf1\x30\x1a\x8e\x3b\x52\x8a\x8a\x94\xec\x63\x1c\x76\xe8\xb2\x06\xed\x0e\x62\xea\xcb\xaf\xc9\x4e\x4b\x77\x7d\xa0\x00\xca\xc0\x6d\xa0\x76\x44\x3e\x8e\x1d\x6a\xee\xc5\xa6\x4d\x87\x5e\xad\xe1\xbb\xa9\xef\xfc\xf5\xdf\x18\xf7\x0d\x8d\xa0\xa4\xcf\x2e\xcf\x2c\x52\x3f\x3b\x45\x9a\x64\x33\x06\x7f\x23\x85\x67\xbf\x85\x30\xe1\xb4\xea\xc3\xb1\xe3\x63\x67\x55\xef\x09\x27\x5b\x6f\x06\xcf\x5c\x6e\x85\xfb\xa7\xca\xaf\x9d\x4a\x1f\x67\x34\x62\x7e\xd9\xa9\x78\x17\xe5\x0e\xbb\xc3\x1a\xbf\x96\x43\x7e\x79\x15\xd9\x67\xc1\x97\xbb\x9c\x01\x7a\xc0\x9c\x2b\xe0\xe5\xe3\x61\x7c\xc9\x1b\x73\xb9\x8c\xc5\x92\x4b\xac\xb6\x76\x97\xb7\xd3\x34\x3b\xa9\x9e\x63\x95\xb9\xd2\xce\xfa\xc9\xcb\xc9\x3c\x53\xb3\xc1\xa6\x73\xf8\xc0\x37\x30\xd0\xdc\xee\xca\x28\xe6\xdd\xd4\xbf\xca\x3b\x6c\xf9\x64\x6e\x15\x35\x00\x3a\x6a\x75\xcd\x3c\x6a\xa8\x43\xf3\xaa\x1b\x6d\x8a\x70\x4b\xbf\xef\xc7\xfb\x2b\x81\xf1\x87\xcd\xe6\xa8\xdf\x62\x11\x04\x43\x08\x1a\xa0\x64\x23\x13\x8b\xc7\x46\x4a\xa6\x70\x24\x3c\x5a\x62\x23\x91\x40\x9c\x32\xe3\x4e\xf8\x80\x83\x77\x8f\x4c\x82\x7a\x9a\x0a\x1c\x4c\x2b\xa8\x69\xaf\xd9\x84\x18\x15\x4c\xac\x19\xdc\xde\x07\x66\x82\x1a\x2c\x2e\x7d\x67\x62\x9c\xb0\x6d\xdb\xfb\xfa\xda\x32\x01\x7f\x73\xda\xab\x86\x34\x14\x31\xbc\x4f\x35\xc4\xb0\x17\x6f\xbf\xd6\x79\x6c\x97\x33\xbb\xf1\xd4\x3d\x15\x40\xb1\x4a\xdd\x0c\xda\xb3\x09\x34\xe1\x1f\xd1\x83\xe8\x12\x92\x3a\x51\x88\x9c\xa2\x46\x4e\x3c\x36\x58\x8a\x33\xc5\x52\x9c\x37\xe3\xf9\x54\x81\x29\x21\xac\xea\x30\xc5\x2a\x68\xd0\x18\xf7\xac\xae\xe1\x49\x83\x15\x9b\x9e\x32\x1d\xc4\xea\xe7\x3f\xbf\xbd\x96\xae\xaf\x4c\x04\x1c\x3b\x5a\x25\xab\x02\x3d\x46\xe8\x3d\x2f\x73\x99\x53\x30\x7e\xd5\xe9\x4a\x1b\xb0\x1a\x79\x57\xd2\x15\x32\x52\xac\x87\xf5\x40\x07\xa3\x61\xb4\x24\x07\x02\x7a\x5b\xd4\x48\xc9\x26\x1a\x08\x9a\x16\xcc\x14\x0b\x68\x50\x0b\x28\x58\xd3\x82\x51\x37\x7f\x34\xa7\x97\x86\x4d\xd3\xaf\x82\x50\x91\x81\x46\x9a\x9e\x2d\x4c\x92\xcf\x4d\xdb\xba\xb2\xfd\xac\xb5\x07\xd7\xee\x1d\x1c\x08\x39\xe7\x35\x2d\x5e\xbb\x8e\x5c\x35\x6d\x07\xcb\x6f\x6e\xb9\x63\xe3\xdd\xa7\x87\x3e\xbc\x4a\xf2\x9d\x3f\xb2\xe5\x5a\x02\xf7\xb3\xcc\xa5\x9e\x84\xf2\x6b\x24\x56\x2b\x6d\x62\x24\x10\x6b\xb4\x37\x1a\x03\x94\x0f\xfe\x4b\x35\x35\xc6\x62\x81\x48\x28\x32\x58\x8a\x12\x7e\x17\xed\x89\x87\x78\x9f\xe8\x11\x07\x4b\x1e\x11\x35\x6a\x9a\xd8\x09\xf0\x63\x55\x62\x27\x11\x0a\x9c\xee\x5a\x69\xe1\xf6\xbf\x29\x7b\x4e\xc8\x39\x3f\xbd\xf8\x91\xeb\x8a\x3d\x59\x7f\x38\x3f\x38\xda\xd1\xf5\xfc\x14\xad\x27\xa4\x4b\xfd\xde\x63\x5f\xbb\xe6\x61\xc7\xf7\xb7\x04\xb6\xac\xe8\xda\xbb\x12\x64\xa6\xee\x3f\x41\x72\x84\x36\xea\x1e\x7c\xf7\x7f\x86\xd2\x6e\xf6\xba\xfc\x61\xa3\x2b\xcc\x53\x3c\x15\x8d\x85\xfd\x3a\xe0\x98\x89\x14\x1c\xc2\x68\x29\xe2\x73\x38\xac\x41\x18\x89\x1a\x8d\xbc\xd9\x6a\x1e\x29\xb1\xd5\x72\xef\x32\x66\x48\xed\xc4\x45\x21\x37\xa9\xa7\x1a\x88\x91\x32\x51\x5a\x5a\x67\x52\x23\x16\xfd\x47\x75\x3f\xb8\xe9\xd6\xb1\x5f\x54\x9b\x91\xbe\xab\x0e\x81\xcb\xd4\xc7\xea\xa4\x7a\x35\x39\x3e\x3c\xf6\x75\x2c\xc6\x72\x43\xd2\xa9\xc3\xe0\xfd\x3a\x79\x0a\x58\x7e\xd0\x87\xf9\x13\x9e\xd9\x0c\xe9\xa3\x9d\x36\xd1\x47\xda\x7c\x26\xd9\x24\x47\x63\x7a\x8b\xd5\x60\x29\x44\x59\x38\x4b\xb1\xe4\x77\x71\x9c\x41\xb2\xf3\x32\x49\x9a\x68\x03\x3d\x58\x22\x0c\x13\xa1\x5f\x4e\x46\x5f\xa4\xd2\x29\x84\x28\xa3\x6a\x05\x07\x22\x62\x0c\xfe\x8a\x9c\x59\xee\x16\xca\xa8\x3f\x02\xc6\xb7\xaa\x52\x1b\x27\x00\xff\x27\xc0\x9c\x57\xd3\x2e\xf4\xe5\x15\x60\x7e\x5d\xbf\xd0\x13\x2b\xd4\x9d\x62\x06\xc5\x87\x73\xa0\xdf\x8a\x30\x5f\xd0\xd9\x32\x47\x69\x20\xdc\x26\x9a\xb6\xbb\xed\x3e\xbf\x97\x45\x47\xae\x93\x43\xd3\x60\x9d\xd4\x68\xc9\xe9\xe0\xcd\x1c\x14\x16\x47\x4d\xc4\x25\xac\xaf\xc9\x07\xa8\x31\x58\x88\x45\xd9\x78\xd5\xe7\xd2\x0e\x00\xc0\xdd\xf1\xc4\x8d\xb7\xff\xd7\x57\xc1\x1f\x5e\x27\xf3\x77\x1f\x1a\xfb\xd9\xbf\x3e\xfe\xf8\x2f\x60\xf3\x0d\x97\x91\xf9\x2f\xfe\x9e\xa4\x11\xf3\x3f\x59\xef\xcb\x3f\x75\xe4\xe9\xef\xe8\x35\xc1\x30\x6e\xff\x13\xbe\x3f\x9f\x8f\x63\xd9\x39\xe3\xef\xb1\x23\x70\xad\x66\xa8\x6d\x83\x4a\x23\xe1\x75\xb0\xac\x4d\x4e\xd8\x12\x2d\x59\xcd\x2d\x88\x87\x8d\x82\x71\xb4\x14\x15\x04\x8b\x48\x05\x48\x0b\x39\x5a\x4a\x59\xaa\xdd\xdc\x95\x8a\xe7\x1a\x57\xc6\x51\xee\x05\xb6\x47\xda\x0b\xd0\x29\x84\x0b\xc7\x48\xcc\x9d\x3d\xa0\xd6\x85\xae\xf8\xd3\x2c\x1e\x9c\x02\x38\xd0\x78\xc9\x59\x03\x9f\x81\xc4\x08\x7f\xfc\xd7\xc7\x7f\xf9\x3a\xa2\x68\xc5\xc6\xd1\xe1\x43\x24\x7d\xeb\x63\x2f\x2d\xb9\xac\xf7\xf3\x60\xb3\xfa\x66\xc3\x8a\x97\x80\xe9\x8b\x63\x7f\xfc\xc1\x53\x4f\x7f\x47\x23\xf0\xf8\xc8\x35\x97\xec\xbf\x05\x84\xb0\x62\x8d\xbf\xf9\xbd\x86\xa6\xa5\xfa\xfc\x57\x18\x6b\xfd\x2f\x73\x0d\x8c\xb4\x5a\x11\x52\x64\x83\xd7\xd5\xdc\x6c\x95\x49\x2b\xd9\xd6\x2e\x41\x4b\x20\x11\x40\x6b\xc6\x8f\x32\x76\x7b\xb6\x58\xb2\xdb\x2d\xc9\x65\x25\x8b\x9b\x09\x14\xab\x37\x44\x35\xc3\xdd\xca\x39\x8a\x7a\x1a\x0d\x1a\x84\x34\x1a\x31\x11\x16\x30\xbe\x7f\x62\x26\xd2\x2a\x8d\x46\xfc\x23\xa3\x45\x0c\x90\x13\x89\x58\x98\xf9\xdf\xed\xf7\x1d\xd9\xba\xbf\x71\xf9\xf5\x43\xea\x9e\x37\x7e\x76\xee\x56\xf6\x2e\x30\xe7\xb4\xb5\x6b\x51\x03\xc8\x27\xc6\xbd\x57\xcc\xbc\x2c\x2b\x97\xb6\xab\xc7\xc1\xab\xde\x0d\xdf\xfe\xaf\x9e\xbe\x81\x02\x78\xfb\xff\x00\x90\x22\x57\x7e\xe8\xc9\x7c\x72\x68\xef\x9e\x3d\x7b\x2e\xf3\x66\xb2\x47\x9f\x96\x43\x4b\x76\x90\x76\x01\xee\xa3\x2d\x50\x86\xab\x99\x25\x44\x0b\xaa\xd6\x8f\x58\x42\x21\x7b\x93\xc5\x8e\x8a\xf1\xb2\xad\x20\x9d\x49\x8f\x94\x22\x1c\xdc\x44\x23\xa5\x0c\x97\xe1\x18\x8f\xdf\x0f\xa5\xea\xa7\x99\xe4\x68\x89\x71\xd6\xde\x83\x55\x86\xd6\x4d\xf2\x55\x30\xa4\x99\x2e\xa8\xbc\x3d\x9e\x9c\x1e\xfa\xad\x22\x57\x76\x35\x94\xd9\x0f\x9f\x56\x5f\xdb\xbf\xff\xd2\xfd\xdb\x2f\xeb\xfa\xbc\x1c\x19\xb8\xff\xae\x9f\xbd\x83\x2e\x06\x87\x47\x47\x87\xef\x01\x1f\x93\x07\xb1\xb8\xbe\xfb\x03\xc0\xf0\xc6\x21\x93\xe1\xaa\x9d\xfb\xf6\x68\x37\x81\x0f\x1e\xd0\xb0\xde\x6e\xdd\xaf\xc9\x15\xd2\xb8\x11\xca\xf2\x2c\xea\x05\x28\x49\x94\x6b\xe2\x64\x59\x48\x18\x9b\x8d\x02\x47\x79\x49\x2f\x94\x27\xc8\x64\x33\x50\x92\x56\xce\xca\x15\x4b\x59\x6b\xd6\xca\x78\xe1\x19\x57\x2c\x05\xec\x4c\xaa\x38\xe1\xbe\x6f\x2a\x3a\x75\x6b\xaf\x53\x2a\xea\x0e\xd6\x89\x21\xdb\xaa\xf2\x3d\x0b\x8a\xf4\xc8\xe3\x5b\x4f\x9f\x74\xad\x37\x7a\xc6\xaa\x35\x58\xb2\x9a\x34\x6f\xbe\xf5\xd4\xc5\x13\xa1\xda\xec\x67\x2d\xdb\x7c\x09\x96\x29\x3e\xbb\xcf\x53\x77\xd0\xcb\xa0\x2c\x63\xe8\x0e\xcf\x16\x20\x28\x8a\x09\xc8\x26\xca\x1d\x75\x47\x1b\xe2\xb2\x19\xb7\x06\x9b\xcd\x74\x39\xb5\x48\xc7\x50\x82\xd9\x41\x54\x0b\x42\x2b\x37\xc0\x75\x43\x07\x2b\x28\x66\xc2\x09\xa1\xfb\x04\x7a\x19\x0c\x34\x5e\xf8\xda\x81\xfd\xfb\x2f\xbb\xfb\x33\x97\x75\x5d\x8b\xae\x73\x1f\xf8\xd5\x5f\x91\xd4\x34\xa0\xc3\x9d\xbb\xf7\x1b\x91\xb0\xae\xb9\xb0\x2c\xac\x6f\x7c\x45\x13\x96\xfa\x16\x5a\xff\x46\x18\x07\x5d\x0a\xe5\xd4\x40\xac\x50\x9a\xe4\x80\x29\x60\x83\x24\xd0\x26\x9b\xbb\xc1\xdd\x10\x4f\x60\x02\x8a\x65\x02\x8a\x25\xaf\x9d\x6e\x18\x84\x04\x88\x27\x20\xa0\xbb\x3b\x57\x95\x4d\x99\x86\x13\x08\x26\x08\xa8\x4b\x21\x11\xb7\x4c\x89\x9e\xa7\x11\xe1\x9e\x12\x31\xef\x27\x68\xfd\xce\xf1\xf7\x0c\x1d\xd0\x1e\x36\x41\x8b\x91\x31\xfb\xc2\x46\x9f\xd1\x91\x20\x1d\x64\xba\x59\x36\xfb\x02\xbe\x91\x12\x48\xa6\x92\xc8\xa7\x4d\xa5\x98\x00\xc5\xbb\xd7\x97\x78\x27\x13\xab\xd9\x4a\x1a\x6e\x55\x4d\x7f\x58\xc5\x60\x94\x01\x78\xcb\x1b\x69\xba\xfa\xe2\xea\x26\x32\x74\xc0\x4d\xf4\xf2\xa3\xea\xd5\x93\x0a\x8d\xa9\x7f\x1e\xaa\xdf\x45\xcf\xbd\x41\x0d\x4f\x59\x71\x7c\x7c\x4f\x65\x17\xe1\xba\x63\xb8\x8f\x50\xdd\x71\x33\xb1\x56\x69\x33\x07\xa2\xc6\x80\xd1\xd9\x48\x3a\xc9\x4c\x4b\x24\x10\x0a\x0c\x96\x40\x2a\x9d\x1a\x2c\x39\xf9\x74\x9a\x09\x85\xcc\xc5\x52\x88\xe7\x3d\xcb\x4a\xbc\x9b\x89\x4f\x69\x14\x85\x09\x9e\x7c\x2d\x99\xfa\x2e\x9a\xbe\x0e\xb9\x66\x07\xfd\x06\xed\xa0\x7b\xa7\xa9\x48\xd6\xad\xa3\xb6\x87\x1e\x7c\x86\x34\x4c\x59\x99\x3c\xf6\x53\xdd\x36\x6a\xf1\x0a\x94\xe3\x35\xd8\x07\x5e\xab\x64\x25\x8b\x45\xf6\x18\x8d\xf6\x38\x69\x27\x9b\xd2\x09\x60\x96\xcc\xa3\xa5\x46\x49\xb2\x39\x43\x5e\xb7\xe0\x84\x3b\xc9\xef\xa4\xa2\x16\xbb\x0d\x9e\xcb\x8c\xad\xe2\x38\xd5\x87\xbe\x13\xa4\x59\xa9\x73\xd3\xc5\x39\x73\xaa\x22\xdd\x7a\x69\x5e\x83\xa5\x39\x76\x7f\xa5\xb4\xb5\x84\x82\xda\x89\x72\x3c\x3e\x55\x89\x6b\x8d\x14\x01\x11\x85\xf6\x7e\x06\xc6\x5c\x9d\x9a\xb6\x62\x2d\x6d\x83\x90\x36\x1e\xd3\x36\x08\x69\x13\xff\x43\xda\xc4\x93\xd3\x86\x05\xc8\xce\xc0\x02\x54\x3b\x2a\xf5\xad\xaf\xa0\xaf\x13\x24\x77\xe6\x54\x65\xae\xf5\x72\x43\xf7\x39\x5f\x67\x16\x43\x9f\x70\x40\x89\x48\xa6\x20\x4f\x9a\xc8\x68\x0c\xe0\x51\xec\x3c\x17\x0e\x33\x30\xf4\x86\x0e\x13\xcd\xc0\xad\x58\x3d\xbe\x6a\x74\xb1\x0c\x2a\x53\x5e\x3f\x11\x89\x36\x68\x43\xbb\x26\xe0\x90\x68\x8a\xf7\xf5\x5b\xd5\x0f\x54\xf5\x27\xea\xb1\x07\x26\xe0\x8f\x7c\xf8\xe7\xc7\x0e\x40\xcf\x03\x8a\xe5\x2b\xc7\xd5\x4f\x6e\x05\x1d\xbf\x98\x80\x3a\xf2\x2b\xf5\xd5\x17\x5f\xfb\x96\x4f\xcf\xff\xa0\x3b\xa5\xdd\xd0\xee\x85\xd0\xba\x9d\xac\x97\x03\x2c\x90\xc3\x04\x34\x19\x83\x25\xce\x14\x08\xd0\x26\x93\x1d\xb5\xf9\xd1\x30\x70\xa4\xdd\x27\x5b\x37\x62\x7b\xb8\x06\x61\xa4\x3c\x47\x0f\xaf\x59\xa4\x52\x07\xbf\xa1\x5e\xf4\xeb\x9f\x5c\x80\xc0\x45\x46\x2f\xdf\xb9\x61\xfb\x9a\xa5\xe7\x80\x33\xc0\xa5\x8d\x4f\x3e\x04\xfe\xfa\x3f\x1f\x63\x4c\x91\xe7\xdf\xfc\xf5\xb3\x7b\x2f\x1b\x80\x1c\xd6\x62\x5d\xc8\xd7\x3d\x38\x96\x40\xf3\x0e\x8d\x41\x92\x14\x8c\x36\xba\xcc\x59\x87\xcd\xc6\x43\xde\xf2\x4e\x8e\xe7\x46\x4b\x6e\x33\x0f\xf7\x07\x4f\x31\xbe\x7a\x17\xa1\x52\x21\x22\x54\x4b\x3f\xa5\x49\x56\xad\xda\xcc\x8e\x82\xdd\xaa\xfa\x33\x7b\xa0\xfa\xbf\xf4\x78\xee\x77\xc3\xfe\xd9\xf4\xe8\x1c\xff\xf2\xf7\xdb\xea\x55\xff\x7b\x6f\x52\x6b\xf5\x76\x76\xc7\xf1\x2f\xd4\xe8\x7b\x68\xfc\x3d\xfa\xdb\x38\x4e\x58\xa4\x24\x27\xac\x7d\xb0\xb2\x76\xb4\x6a\x9c\x66\xf3\xd5\x1f\xf8\xd3\xaf\x58\x9c\x7e\xc5\x98\xd1\xf4\xb7\xb7\x3f\xf1\xf4\x91\x7b\xbb\x31\x06\xc9\x66\x14\x94\xcf\x80\x0a\x7d\xae\xae\xd0\xdf\x7c\x18\x99\xa2\x72\x3b\xfb\xd8\x6f\x75\x2d\x86\x3e\xf6\x1a\xa8\x0b\x5f\x65\x96\x38\x58\x30\x84\x79\x3f\x77\xfc\x3d\xf2\x7d\x8c\x1f\x54\x52\x72\x61\xc9\xc4\x07\x58\x13\x4d\xc6\xc9\x78\xaa\x89\xf1\x05\x7d\xc1\x62\x89\x83\x7a\xb2\xd8\xb7\xda\x77\xae\x8f\xe1\x28\x9f\x8f\x80\x4a\x0e\x49\xe1\xec\x44\x6c\x59\x89\x70\x57\x5a\x2a\x2b\x37\xab\x75\xe7\xbb\x86\x25\x84\xd4\xa5\x90\x47\x33\xa6\x74\x44\xa1\xf2\xfc\xa9\x1e\x20\x96\xf5\x07\x75\x1d\x82\x77\xd4\xd1\xf3\x4e\x5d\x3a\x7a\xe8\xdb\x5b\xaf\x2b\x34\x04\x57\xa5\x36\x95\xce\x5c\x79\xc9\xc5\xc3\xe7\x5f\x7d\xcd\xe5\xab\xe5\x03\x2e\xd0\xb2\x78\xbb\x8d\x0d\x6e\x5d\xf6\xd9\x4b\xe5\x3f\x7f\x41\xf4\xad\x3d\x7d\x68\xf5\xf2\xd2\xe2\x8d\xab\xfd\xbd\xc1\x26\x4d\xd7\x9d\xea\x5c\xa6\x1d\xf7\x86\xcf\x53\xe2\x8e\x68\xd4\x6e\xf4\x91\x3e\x32\x91\x04\xd1\x86\xe8\x48\xa9\xc1\x81\xda\x77\xa5\xd0\xfa\x92\x4f\x72\xb2\xb6\xd1\x9a\x58\x5b\x0b\xb8\xeb\x92\xca\xdd\x65\xe5\xa9\x4d\x1a\x4c\x7d\x34\x32\xed\x87\x86\xee\x3f\x47\x4f\x16\x7c\x79\xca\xee\x1b\xd4\xdc\xe1\xff\xfc\xcb\x3b\x70\x9a\xe0\x28\xf3\xa5\x29\x4e\x44\xdc\x7b\xb3\x98\xfa\x11\xce\xfb\xc0\xf5\xdb\xa3\x51\x1b\xeb\x05\x5e\x90\x6c\x24\xe0\xfa\x07\x4b\x0d\x70\x9f\x36\xf0\x62\x68\x59\xc9\x2b\xba\x69\x18\x7b\x1a\x10\x80\xc9\x89\xd7\x2f\xd4\xe5\x07\xa6\x3b\xf1\xa8\xd5\xb7\x5c\xaf\x2c\xcb\xfa\x23\xed\x3d\xbd\x53\x1f\x75\xd4\xc6\xe3\x17\x3c\xf7\x03\x94\x1b\xb8\xec\x6a\xea\xf1\xa9\x8e\x39\x5c\xfb\xa0\x1e\x66\x0e\x32\x8b\x61\x0c\xd7\xa1\xc5\x74\x90\x9e\x37\xa9\x5f\xc1\xc7\x2b\xf0\x63\x72\xfc\x6d\xc3\x17\x71\x2d\xf1\x0c\xfd\xf1\x7b\xcc\x51\x54\x5b\x45\x0c\x63\xcc\xee\x39\xea\x1e\xe2\xe8\xf8\x0f\x09\x68\x1b\x15\xa7\xc0\xd8\x6c\xe6\xdf\x00\x40\x00\x05\x14\xc1\x28\xa0\x81\x9d\xc8\xbe\xb2\x66\x4d\x3b\x0a\xa8\xdb\x5a\x9d\x31\xcd\xc9\x0a\x42\x27\x0b\x29\x58\x0e\xb9\xbe\x47\x37\x26\x5a\x73\xc9\x0d\xb3\xe7\x6d\x5c\x30\x5b\xdd\x93\xed\x6c\x69\xe9\xcc\xb6\xad\x1a\xb6\xac\x5d\x6b\x39\xfd\x34\xed\xee\x26\xcd\x2c\x05\x0f\xb1\xcf\x10\x16\x42\x82\xbe\x6c\xa3\xe2\x16\x4d\x26\x9e\xa7\xc0\xc3\xd4\xfb\xd4\x38\x45\x51\x8a\xc9\xba\x80\xf2\x47\x9e\x04\x67\x42\xde\xbe\x92\x5e\xb3\x4d\x4b\xfe\x39\x2b\xb3\xc0\xa2\x89\x42\xcd\xcf\x86\x9a\x9f\xd3\x2d\xe1\x68\x4b\x4b\x34\xdc\xf2\x4e\xf9\x87\xed\xf0\x87\x4c\x06\xfe\xc0\x6e\x0d\x67\x32\xda\x93\xda\xf7\x87\xf1\xcf\xad\xad\x98\xee\x2d\xcc\x52\xe2\x06\xf6\x38\x5c\x93\xe5\x51\x82\xc5\x1f\xfd\x0a\xfc\x48\x83\x04\xff\xc5\x0a\x49\xf8\xef\x86\x3b\xe0\x7f\x8f\x5c\x84\xbe\xde\xc1\x1e\x5f\x59\xf9\x4f\x8b\x27\xd7\x42\x9a\x08\x9d\xa6\xa8\xe2\x34\x4d\x24\x87\x17\x6b\xc8\xa9\xa7\xa5\x76\xfd\xa3\x70\xb5\xad\xd9\x58\xb8\x85\x6c\x0d\x87\x5b\xb3\x91\x68\x0b\xbb\x45\x5b\x3e\x5a\x2e\x7a\xae\x45\xe3\xe1\x28\xfc\xbc\xef\xeb\x9f\xe7\x47\x3c\xf4\x52\x9e\x13\x7f\xe8\xf3\xf6\xe7\x51\x0a\xbe\xfa\x59\x62\xed\x1a\xa0\xdd\x03\x49\xcc\x0e\xc4\x9a\x70\x24\x8b\x78\xf7\xfd\xad\xd5\x4f\xd7\x56\xd3\xd2\x02\xce\x53\xaf\x87\xfc\x5a\x0a\xf5\xe4\xe6\xf1\x87\x08\x03\x61\xff\x26\x45\xd0\x76\x9a\xa4\x09\xa4\x1b\x90\x36\x34\x1e\x59\x84\xb6\x73\xce\x8e\x8d\x77\x1e\x1a\x5a\x7d\xce\xa6\x03\xfb\x35\x3c\xf8\xb3\x99\x55\xc4\xad\xec\x03\x70\xf5\x96\x47\x29\x80\x97\x76\x0c\xf1\x38\x59\xb8\x15\xfe\xc7\x12\x0f\x3c\xf0\x00\x9e\xe1\xf6\x3a\x53\x04\x69\x76\x1f\xb4\xe9\x61\xc5\x2a\x04\x08\x4b\x00\xfe\xe3\x25\x20\xe9\x72\x59\xa3\x0d\x62\xd1\x87\x96\x89\x2e\xc9\xa0\x27\xbc\x2b\x59\xc5\x82\x4e\x16\x34\x74\x77\x06\xe2\xdd\xbe\x2d\x43\xb3\xb2\xcb\xf2\x8d\x85\x30\x7e\xb0\xac\xaf\x7d\x79\x47\x73\x1b\xdb\x9d\x88\x2b\xee\x05\x89\x8b\x67\x0d\xe5\x4f\xe9\xce\xe2\x07\xa9\x0b\x67\x0d\x75\x2e\xec\x6b\xc2\xeb\x78\x12\xea\x04\xc1\xee\x81\x34\x3a\xbf\x49\xf1\xb4\x8c\x68\xd4\x57\xd0\x8e\xe6\xbc\x25\x62\x79\xc8\xbf\xad\xdb\xce\xbe\xfd\x21\x66\xe9\xea\xb3\xb7\xdc\x7d\x7d\x19\x07\x69\x0f\x18\x18\xff\x13\xc1\x10\xc6\x47\x01\x0d\xb9\x82\xd3\xbb\x85\x9c\x01\x0c\x5c\xfb\xd8\x63\xd7\x3e\xae\xee\x39\x7c\xf8\x30\xdc\x79\x29\xcc\xc3\x7f\xa2\xf7\x27\x44\xc5\x64\x30\xd0\x0a\x05\x28\x01\x4d\x3a\x7b\x05\xed\x31\x3c\xf8\x0a\x7e\x46\x67\x9e\xa9\x11\xd5\xcd\x0f\xde\x75\xe6\x45\xe3\x44\x59\x46\x43\xd7\xdc\xb3\xe9\x9c\xd5\x9c\x2e\x1e\xed\xf3\xa1\x6e\x2c\xd0\xd7\x4d\xe3\xf1\x43\x94\xb6\xee\x63\x68\xdd\xc8\x75\x40\xc3\xcf\x1e\xba\x7d\xe3\x05\xcc\xd2\xeb\x0e\x6c\x39\x73\x04\xcd\x4a\xd6\x5e\x63\x67\xe9\x9f\x21\x7d\x46\xb4\xeb\xef\xc1\x13\x01\x85\xe3\x2c\x16\xfd\x9d\x8c\xda\x5b\xb5\xc3\xf7\xc2\xbb\xb2\xfc\x76\x91\x9a\xb7\x55\x17\x1e\xba\xb3\xf2\xe6\xfb\xef\x81\x5f\xe0\x7b\xd2\x6a\x92\x59\x01\x7e\x61\xb0\xc3\x77\xf4\xe3\x5b\xdb\xa4\x22\x3a\xf3\xf9\x98\x97\xa2\xb2\xd9\x54\x7f\x6a\x30\x45\xa5\x4c\xc5\x18\x88\x11\xd9\x35\xb9\xe7\xd7\x54\x73\xe3\x35\x9b\x25\x09\x95\x25\x51\x70\xb9\x2b\x01\x1e\xa3\xcf\xaa\x99\x6a\xb2\xf0\x8a\xf3\x8b\x43\xdb\x2e\x28\xb6\xb6\x2c\x5d\x54\xf4\x8e\x76\x35\xa6\xba\x66\x24\x13\x33\xd4\xff\xf5\x16\x17\x2d\x6d\x69\x2b\x6e\xdf\xb6\xac\xb8\x6d\x14\x3d\x85\x7e\xc5\x2e\x2d\x6e\xdf\x5e\x1c\xda\x2a\x15\x17\x17\x13\xbd\x8d\x5d\x5d\x8d\xf0\xff\xe6\xae\x04\x7c\x28\x9d\xbf\x6c\xd9\xb6\x6d\x4b\xf4\xe7\xb4\xfd\x1e\xac\xa1\xc5\xab\xd8\xbc\x59\xaa\x9f\x1a\x84\xfb\xce\x59\x34\x01\x93\x4e\xc0\x89\x57\x3e\xf5\xea\xa6\x5c\x06\xdc\x3b\xab\xa1\x2e\x3e\xc0\xde\x8e\x2a\xb4\xe0\xd6\xa6\x69\x13\x1a\x48\x69\x2c\x6b\x23\xb4\xc7\xf0\xc3\xb4\xcf\x41\xc3\x87\x44\xcd\x4f\x79\xe0\xb4\xd3\xa2\xd2\x99\x67\x9a\x23\xad\x09\xf6\xf6\xf6\x55\x1b\xcd\x1b\xc1\xe2\x2f\x71\x99\x42\x3b\x31\xd9\xd6\xf3\x14\xcb\xfe\x86\x01\x04\xa3\x30\x45\x66\x94\xa1\x19\xa7\xa6\x87\x6b\x34\x5b\x8f\x46\xb0\x89\x31\xe8\x43\xcc\x04\xb9\xb2\xbf\x99\x3b\x3a\x77\xde\xc6\xd9\xf3\x36\x24\x73\xad\x89\x8d\x1b\x87\x87\x2d\xab\x57\x9b\x87\x4f\x6f\x6b\xcb\xb7\xb6\xe6\xdb\xe0\xfb\x2f\x50\x0f\x12\xfb\xc7\xff\x1b\xee\x03\xdb\x13\x14\x41\x02\xb2\x6c\x21\x24\x21\x92\xcf\xe5\xf7\xab\x4f\xbd\x19\x53\xbf\xbf\xe9\x55\xb4\x96\xb5\x70\x2d\xf7\xd4\xef\x19\x27\xde\x33\xf7\x5c\x7b\xf8\xf0\xb5\x87\xb5\x2d\x03\xff\x6e\x13\xfc\xbb\xc7\x74\xbb\x43\x13\x94\x1d\xe9\x36\x91\xc5\x8a\x5d\xde\x2c\x8f\x7d\xfd\x2b\x1b\x77\x0c\xed\x3f\xb0\x69\xd3\xe9\x84\xa6\xcb\x70\x3f\x2e\xc0\xaf\xe1\xa1\xac\xb0\x2e\x6b\xaf\xe4\xe1\x4b\x2b\x8a\x2c\xea\x2f\x8f\xe8\xdf\xbf\xfe\x95\xb3\xb6\x83\x6f\x3e\x78\xd7\x59\xdb\xd1\x7b\x6d\x1e\x86\xfb\x6c\xb3\x76\x46\xae\x87\x6b\xb8\x73\xfc\x23\xf8\x7e\xdc\x61\x05\x00\xc0\x20\xb2\xe0\x7a\x99\x7c\x21\x19\x17\x0d\x77\xaa\xbf\xbf\xe6\x41\x20\xef\x57\x1f\xcb\x15\xdd\xbf\xcd\x2d\xf6\xc2\x73\x16\xcb\xef\x20\xdc\x5f\x06\xfa\x35\xe2\x20\xa1\xad\x0b\xee\x07\x78\x1a\x57\x74\xc8\x99\xb5\xf6\x5b\x07\xad\x94\xd5\x5b\x34\x00\x43\x45\x87\xa8\x13\x68\xf8\xca\x69\x54\x79\x0a\xb5\x85\x6b\xd0\xe5\x0d\xf7\xf8\x1b\x98\x0e\x78\x66\x11\xf7\xb0\x47\x20\xcf\x2d\x8f\xd2\xa0\x72\xe6\xd5\xb0\x9d\x59\x8a\xd9\x8e\x64\x09\xff\x76\x3f\xfb\x79\xf8\xb7\xc2\x13\x48\xf5\x28\x52\x3f\x5a\x10\xe1\x15\x71\xb2\x9f\xc7\xf2\x44\xf6\x44\xe3\x39\xa4\xf7\x47\xc4\x63\x04\xce\x2f\x8f\x3d\xc8\x14\xa1\x3d\xdd\x07\x9f\xfb\xb1\xfa\xba\xc6\x83\xf1\x99\xcc\x7e\xe2\xbb\x06\x07\x3e\xc7\x44\xc5\x22\x96\xf7\x11\x6f\xd2\xac\x60\x75\x9e\x26\x3e\xf6\x6b\xf6\xcf\x73\x17\x14\x97\x9d\xbf\x75\x68\x68\xdb\x19\x88\xbe\x19\x09\xb8\x77\x86\x8a\xe7\x6f\x5f\x3a\xb8\x63\xfb\xb2\xf2\xbe\x21\xc7\x1f\x81\x34\x17\xc7\xff\x8e\xdf\x5f\x52\x38\x9e\x10\x81\x22\x1e\x10\x49\xd1\x44\xe1\x0f\x40\x87\xb1\x61\x9a\x43\xb1\x88\x4c\x2a\x3a\x73\xcb\x67\xf1\xfa\x48\x16\xfe\x58\x73\x14\x33\xea\x4f\x21\x9d\x19\xfd\xfd\xa1\xe1\x22\x7a\xa0\x55\x73\xe5\xfc\xfe\x6e\x22\x02\x94\xc8\x81\x08\x19\xc9\x40\xef\x26\xc9\xa3\x4f\xc3\xb8\xe4\xaf\x94\xdd\x19\xe6\x53\xb8\x33\xf1\x69\x9e\x57\x7f\x3a\xd9\xcf\xc9\x84\x63\x99\x4c\x2c\x9c\x01\x0b\xcb\x4f\x55\x7c\x88\x51\xb8\x66\xfd\xb9\x96\x5a\xcf\xe7\x7d\xfd\xb9\x0a\x3d\x94\xfa\x4f\x48\x8f\x1d\xd2\x43\x61\xad\x0c\x2a\x50\xd6\xc0\x49\x78\x81\xe2\x3d\xe0\x25\xbd\x56\x83\xce\x34\x6c\x70\x18\xe8\xb7\x16\xa6\xe1\x9d\xfa\x4f\x30\xbf\x0b\x2e\x27\x9b\x45\xcb\xd2\x97\x76\xcf\x96\x2d\x4a\xf9\x23\x75\x4f\x83\xa8\xf9\x4c\x74\x0e\xca\xd0\x16\x09\x2c\x49\x52\x94\x44\x04\x81\x12\x3c\x10\x24\x83\xfa\x89\x88\x3f\x15\x1f\xfa\xf9\x18\xfc\xe4\xd8\xb4\x9f\x7d\xe0\x3c\x30\x7f\xd3\x3d\x13\x3f\x5c\x7d\x6f\xfb\x96\x2d\xdb\x1f\x9b\xf4\xf9\x00\xea\xc8\x41\xa8\x23\x03\x50\x86\xc6\x47\xb1\x5a\xd4\x2b\x5d\x45\x0d\xd4\x7f\xea\xf2\x47\x7a\x0b\x5f\xf3\xdc\xf8\x1c\x2c\x77\xdb\x61\xe4\xc0\x62\x09\x0b\x13\x5e\x5b\xbb\xc4\xe7\xca\xe2\xf8\x73\xf9\xec\x56\x3f\xd4\x19\x1f\xad\x1e\xdf\x04\x05\xdf\x7b\x0f\x7c\xef\xb2\x4e\x41\x19\xf8\x2b\xca\x54\xf3\x41\x93\x75\x77\x3a\x2d\x7a\xae\x25\xaa\x7d\xce\x9f\x91\xf4\x11\x05\x17\x56\x34\x5a\xfb\x05\xfe\x70\xf4\x47\x0f\x23\x0d\x29\xfb\xc4\xab\xc7\xbd\xc4\xc1\xf1\x7d\x50\x17\xb8\xc3\x94\x01\x1a\x3a\x64\x93\xe0\x47\x46\xc4\xc8\x41\xb0\x40\x7d\x72\xf7\x26\xed\x1c\x59\x0d\x79\x81\xfe\xce\x40\x98\x1f\x37\x22\x33\x9f\x5d\x53\x15\x52\x7e\x2b\x58\xb0\x59\x3d\x78\xe1\xa6\x4d\x17\x62\x5e\x33\x3c\x51\x64\x1e\x86\xb4\x39\x15\x33\xb5\xd7\xf4\x88\x89\x94\xb5\x13\x73\xcd\x44\xb6\x97\x17\xc6\x8c\x68\x3b\xb0\x15\xd9\x51\xfd\xf5\xd0\x86\xfd\x03\xf3\xca\x01\x79\xf5\xc1\xf8\x07\x3a\xaf\xfc\x8a\x55\xe4\x79\xbf\x5f\x63\x96\xbe\xc5\xdb\x1d\x58\x5b\x6b\x39\x22\x4d\xf3\xf3\xdf\xcb\xdb\xe4\xae\xf2\x87\x1f\xa8\xec\x21\x5d\x71\x16\xea\x8b\x59\x50\xde\x33\x90\x26\x72\x1b\x51\xa4\x6c\x58\x7f\x28\xd3\x64\xfd\x29\x9b\x10\xf2\xa8\xa6\x89\x19\xf8\x9a\x97\x21\xcf\x0a\x98\xb7\xc6\x47\xa1\x3b\x81\x5f\x83\xc6\x4b\x9c\xa7\x1e\xfc\xcd\x6f\xa0\x7d\xbd\x92\x3e\x42\x7e\x97\x59\x0c\x7f\x2f\x3c\x41\x00\x9a\x21\x10\x2d\x38\xb2\x44\x05\xaf\x62\xe4\x4a\xb2\x77\xec\x79\x66\xf1\xcd\x98\xff\xf4\x27\xc4\x41\x66\x23\xfc\x13\x49\xb1\x12\x7b\x29\x20\x43\x23\x4a\x1a\xa1\x2f\x89\xd8\x8a\xf9\x5a\x16\x19\xb3\x71\x33\x96\x19\xf8\x50\x1d\x25\xaf\x31\xfc\x02\xbe\xc6\x79\x04\x8d\x7b\x61\xd0\xe1\x9c\x2d\x23\x9d\x02\x14\x0e\x7c\x78\x9b\x3a\x6a\xda\xf9\xbf\x5f\x24\x34\xb9\x35\x43\xbe\xbf\x02\x69\x14\x14\x13\x25\x9b\xf6\x98\x1e\x36\x51\x26\x4d\x21\xa6\x96\xda\x67\xca\x52\x23\x26\xcb\x8d\x84\x67\xfd\xef\xc1\x0d\xd4\x77\xb1\xdc\x22\xf0\x4c\x26\x08\x07\xcb\x7a\xbc\x3c\xb4\xcb\x4f\x82\xf5\xf0\x60\xd1\xa8\x2d\x0f\x59\xa9\xa9\x6a\x11\x6a\x2b\x5c\x6e\x98\x9b\xeb\x98\x3b\xb7\x23\x37\xb7\xfc\x7d\x75\xdb\x82\x05\x6d\xb9\x79\xf3\xc8\xa7\xd0\x63\xf8\x00\xad\x9d\x95\x88\x22\x3c\xe7\x4e\x26\x1f\x76\x23\x36\x0a\x58\x3e\x8f\xa8\x9b\xa0\x4d\x30\x9e\xdc\x26\x3c\x59\xb6\x09\x80\xd8\x07\x09\xfb\x22\x7d\x84\x68\x26\x0a\x0a\x17\x27\x08\x4f\x8a\x6a\xc9\x10\xc9\xa6\xe4\x2c\x33\x38\x8b\x28\x11\x4d\x60\x1d\x61\x23\xfc\xf8\x67\x1b\x18\xa9\x4d\x43\xe1\xcc\x53\x5b\x2b\xdc\xc1\xf8\xfa\x25\x89\x73\x35\x3d\x78\x82\xa4\xf6\xa1\x69\x10\x85\x81\x0e\x82\x7e\x86\x47\x7f\x2e\x22\x45\x5a\xc0\x3e\xb3\x3d\xd5\x28\x1b\x85\xae\x65\x8b\x13\x01\xd6\xe8\x4c\xed\xcc\x0c\x79\xa4\x76\x73\x04\x44\x72\x6a\xc6\x11\x79\xcc\x15\x8d\xac\xfc\xc2\xaa\x33\xbf\x95\x5d\x25\xcf\x6c\x76\x78\x1d\x5c\xa9\x65\xe7\xca\x9e\xeb\xae\xeb\x9c\x71\x4b\x90\x93\x8f\xb4\x5c\x00\xd7\x8c\xc6\xe7\xbd\x33\x7e\x17\x61\x42\x7b\x57\x73\x3b\xa0\x61\x8f\x49\xd0\xd7\x2b\xc0\x0d\x0c\xde\x39\xec\xdc\x62\x7f\x0c\x3c\x72\xec\x80\xcb\x75\x40\xd3\x1d\x62\x74\xfc\x1d\x7a\x1f\xfd\x0c\x71\x0a\x31\x4f\x71\x49\xa9\x86\x20\x61\x31\x76\x07\x5d\x99\xd6\x94\x69\xd1\x62\xba\x67\x41\xcf\x93\xe0\x6c\xc5\x54\xca\xb8\xba\x8d\x74\xb8\x63\xc1\x93\x60\xe4\xb1\x08\x1f\x7e\x12\x52\xdf\x9f\xcb\x55\xca\x29\x6a\xd3\x6d\x2e\x34\x73\xd7\xc0\x1a\x2a\x15\x22\x89\x24\xb0\xa1\x6b\x34\x09\x5d\xa6\x19\xa0\x7b\xd1\xae\x4f\xff\xed\x07\x49\x28\x7b\x04\x5b\x2e\xb9\x25\xd0\x59\x88\x56\x30\xb1\xdd\xb9\x42\xbb\x9b\xde\xe7\x8f\x87\xc2\xad\x5f\x3e\x1d\x14\xfa\x7d\x4d\x9c\x91\x94\xd6\x8f\x7d\xb4\x50\x69\x6a\xc9\xa4\x5d\xea\x8b\x9b\x33\xf1\x4c\xbc\xb4\x24\x7f\x55\x9f\x2f\x61\x36\x1b\xf8\x6b\x81\x75\xcb\xfd\x3d\xf3\x3a\x3d\x2c\xe9\x0a\xae\xee\x9c\x49\x7d\xd0\x1c\x8d\xa7\x3f\xf3\x63\xf5\xe0\xdc\xce\xe8\x40\xab\x71\xee\x3a\x72\x4e\xfb\x59\x03\x99\xf5\xb3\xfa\xd7\x67\x3b\x13\xfd\xad\xde\x39\xab\xce\x9d\x35\xf7\xc6\x42\xec\xce\x85\xf3\x22\x4a\xb3\xab\xe5\x5e\xf5\x17\x07\x76\xf5\xe4\x9a\x97\x5b\x04\xaf\x48\xcd\xd6\xf8\xe3\x47\x33\x1f\xe9\xc3\xd0\x1e\xe5\x15\xb3\x21\x08\xf8\x20\x15\x6f\x90\xb8\xa7\xb1\xe0\x25\x30\xf2\x78\x14\x1a\x49\xed\x11\x40\x4c\xa9\xde\x1e\x6b\x5a\x90\x02\x85\x08\xaa\xfb\xe9\x68\x01\xb1\x72\x37\x44\x10\x40\xa9\xb7\xa3\x81\xc7\x06\x1b\x30\xe4\xa8\xe1\xe3\xdf\xcd\x93\x2b\x5c\x82\x23\xdb\xab\x9e\xd2\xda\xdd\xec\xe6\x32\xe0\x99\x53\x17\xc5\x6c\x0e\x36\x2b\x3c\x70\xa4\xff\x2b\x37\xcd\xd9\x73\xa0\x65\x6e\x47\xcb\xa9\x0e\x67\x54\x5e\xf4\xd6\xc1\xf7\xcf\x90\x96\xea\xf8\x32\xf0\xac\x25\xd7\x43\x3d\x6d\x23\x7a\x14\x9b\x98\xe1\x02\x19\x82\xce\xb5\x1b\xb9\x58\xcc\x77\x14\xaf\x2a\x06\x95\x93\x23\xac\xe0\xac\xc7\x4a\x14\xa7\xc9\xad\x92\x93\xae\xac\x52\xdb\x93\x49\x74\xbb\x6d\x88\x14\xd0\x25\x36\xd4\x5c\xa1\x03\xa1\x94\x46\xf1\x92\x45\x17\x54\x60\x24\x3f\x3c\x09\x3d\x04\xc8\xf5\x7e\xd4\x96\x95\x2c\xca\xa7\x5b\xd4\x77\x3b\x6e\xea\x56\x82\x82\xc1\x99\x69\x92\x37\x26\xdd\xdc\x40\x72\x89\x12\xe1\x78\x6e\x28\xe9\xd9\xd0\xb2\x20\x60\xbd\x7d\x47\xc7\x0f\x92\x47\x3a\x86\x3b\x0b\x9d\x20\xb3\xbc\xcb\x7b\x41\x7b\xc9\x95\x77\xb7\xa6\xfc\x33\x87\xb6\x2c\x7a\xe5\x2b\xcb\x56\x42\x3a\xbc\xe3\x7f\xa2\x2e\x81\x7c\x6e\x22\x52\x8a\xc9\x65\x08\x18\x08\xaa\x39\x6d\x3b\x0a\xcd\x47\x1c\x7a\x2c\x88\x90\x78\x79\x97\x55\x56\x0d\x60\x1c\xc3\x6a\x3b\x09\x55\x3b\xe7\x0b\x9d\xf9\x2c\x80\xbb\x0e\xf3\x19\xa9\x95\x68\xc0\x8c\x06\x22\x7c\x6b\xe3\x59\xbc\xcd\x14\xd8\x64\x71\x50\x30\x46\x6d\x9b\x31\x76\x79\x2e\x23\xca\x56\x8e\xcc\x90\x77\xf9\xc3\x3c\xf5\x2b\x9b\x85\xf4\x1c\x5a\xf1\xec\xb3\x5f\x0e\xa0\xee\x17\x6e\xfe\xfd\x7f\x7d\x74\xdd\x15\x03\x73\x3b\xe5\xde\x84\x5d\x0a\xf3\xde\x90\x16\x2b\x6e\x1c\xff\x13\xcd\x42\x7e\x67\x88\xb9\x44\xa7\x62\xf7\xb0\xb9\x99\x91\x99\x2c\x41\xcf\x9f\x37\x7b\x76\x93\xd0\x85\x16\xdc\x44\x84\x74\x13\xa1\x2f\x18\x15\xad\xd4\xef\x10\xb4\x6a\x07\x5c\x35\x6d\x60\xb5\x75\x77\xa0\x9d\xa0\xaf\x5c\xd3\x10\x37\x5c\xb9\x88\xff\xd4\x59\xa1\x2e\xd9\x81\xa7\x60\xd3\xac\x2b\xeb\x8b\x43\x4d\x24\xa9\x0e\xd1\xec\xa4\x38\xbb\x10\x6a\x1f\x4b\x41\xcd\x71\xd9\x1c\x12\xf9\xc7\xd9\x63\x7d\xbc\x83\x76\x74\x0c\xd8\xdd\x54\x98\xb4\x77\x0c\x08\xac\x95\x7a\x2d\x6c\x4d\x2c\xe9\x7e\x41\xfd\xc7\xe7\xd2\xe9\x28\x45\x92\x69\xab\x57\xe8\xd8\xba\xeb\xe8\xb7\x63\xf3\xcf\x9a\x39\xb7\x13\xea\x96\x24\xf0\x1d\x6a\x1f\x13\x1a\x18\x55\xdf\x6e\x6f\xce\x44\x24\x9b\xb2\xf1\xed\xb9\x3d\xb3\xda\x8c\x58\x3e\x1f\x82\x2d\x90\x6e\x99\x48\x1c\x31\xca\xb2\x3d\x12\xa6\x8f\x42\x65\xf2\x21\xcd\x82\xb4\xfa\x6a\x84\xd3\xad\xab\x94\x5e\x2a\xac\x69\x91\xbe\xb5\x83\xb8\xc4\x05\x89\x04\x6c\x11\x0a\x9c\x99\xe1\xe4\x74\x4f\x6b\x6b\xca\xc5\x18\x9c\xbe\xbe\x85\x7d\xde\x61\xa7\xaf\x9b\xf7\x51\x81\x19\xed\xce\x39\xb9\xfc\x10\xc7\x3a\x2d\x5e\x77\xbe\x1f\xeb\xfa\xce\xf1\x0f\x80\x0a\x75\x24\x03\x75\xc4\xea\xe3\xa2\x1c\x41\x65\x5b\x9c\x61\x43\xda\xa0\x6d\xc0\x34\x5e\x04\xda\x80\xd9\x5a\x1d\x41\x26\x08\x47\x59\xd8\xe4\xa2\x55\x55\x38\xde\x07\x0a\x51\x4d\x55\xe0\xc2\xe0\xba\x80\x6a\x33\x99\xac\x6e\x7f\x6b\x9b\x9d\x77\xd9\x57\x39\x6d\x8c\xd7\x60\x10\x9a\xe2\xdf\xf2\x44\xad\x7c\xe6\x82\xeb\xa8\x3f\x85\x67\xf0\xee\xbd\x23\x4b\x5f\x39\xb6\xa0\xbd\x51\x9a\x6d\x17\xd7\x5c\x3b\xff\x9c\x73\x86\x97\xad\x58\xdd\xb5\x3b\xd9\xd7\x60\x73\x26\xe0\x3a\xaf\x82\x3a\x92\x82\xbc\xea\x85\x36\xc3\xe6\x62\xe5\xc6\xb6\x46\x82\x35\x32\x7d\x33\xb9\x18\x3c\x0f\x1f\xf7\xb4\x74\xb5\x68\x0b\xee\xaa\x2c\xb8\x3f\x37\x59\x41\x74\xfb\x09\x19\x97\xef\xa0\x92\x48\x3b\x90\x19\xad\x3c\x5d\xd6\xf6\xf2\x01\x8a\x8e\x12\x68\x3b\xe9\x94\xbd\x2f\x16\x4b\xce\x75\xf2\x16\x0f\xd3\xd0\x30\xf6\xec\x8c\x26\x8b\x45\x5a\x19\xb2\xd1\x0e\x86\x51\x16\xf5\xe7\x7a\x9b\x5d\xf6\x34\xf9\xc7\xb8\x87\x7a\x33\x68\xef\x3d\xad\xf8\xee\x7b\x6b\xd3\x0b\xbb\x25\xae\x23\xfb\x19\xb0\x7b\xeb\x82\x0d\xf9\x05\x17\x6f\x2e\x7c\xed\xe0\x9c\xfe\xc5\x25\xa7\xbd\xff\xb3\xc7\x7e\x5f\xfa\xf2\x4a\xa4\x1f\xe1\x94\x43\xd2\x6c\xce\x4a\xe8\x63\x6c\x82\x72\x98\x49\x0c\x2b\x8e\x56\xa2\xb3\xd0\x68\xb6\x9b\x0b\x04\xdd\xdf\xd7\xc9\xcc\x98\x91\xd3\xec\xce\x0c\x30\x4a\x78\x89\x06\x64\x77\xbc\x56\xfd\xd0\xf4\x42\x7a\x19\xa2\x19\xff\xcc\x60\x6b\x89\xf3\xec\x13\xcc\x51\x99\x09\x36\x40\x45\xd0\x74\x01\xb4\x31\xca\x34\x1a\x90\x94\xf4\x24\x0c\xba\xf8\x40\x1c\x09\x01\x29\x52\xae\x73\x30\x24\x1d\xf0\xcf\x42\x80\xde\x24\x34\xad\x1a\xf3\xf3\xe1\xa4\x1c\xed\x5f\x90\xf5\xc2\x7d\xbe\x74\xae\xc2\x9b\x59\xca\x10\xb4\xf9\xc3\x32\xe7\x9f\x4d\x76\x2d\x4c\xad\x5e\xb0\xe8\xca\x95\x03\x17\xde\xbf\xa6\xf7\xfc\xd9\xe4\x83\x83\x9f\x7b\x58\x7d\x63\xde\x65\x37\x1f\xba\xe0\x94\x6b\xce\xee\xef\xed\x58\x62\x17\xa3\xca\x2c\xb9\x8f\x31\x89\x9d\x37\x2d\x6c\x5f\xb7\xf3\xad\x1f\x7d\xe7\xf4\xdd\xb7\xdc\xfa\x88\x1f\x44\x5e\xdb\xf1\x23\xcc\x8b\x1c\x99\x04\xf7\xd1\x8f\x11\x51\xa2\x41\x31\xdb\x08\x42\x6c\x60\x42\xb1\x90\x53\x93\x6f\x48\x93\x2f\x24\xad\xbc\x2b\x80\x4b\x9f\x6b\xdf\x0f\xd0\x92\xab\x06\xd6\xad\x29\x60\x08\x80\xfb\x1a\x4f\x1f\xe5\x4d\x61\x93\x7b\xee\x29\xee\xac\x62\xbb\xa0\xd9\xcd\x98\x92\xc3\xc5\x82\x9f\xba\x6e\xe9\x05\x67\xcc\x4b\x19\x8d\xac\x33\x7f\x56\x4f\x53\xb3\x63\x67\xdb\x90\x99\x75\x46\x1b\x47\xd0\xfe\x54\xb7\x51\x4b\xa1\xce\x85\xe1\xfe\x34\x85\xc3\x42\x34\xc2\x1c\x05\x67\xc0\xe3\xcb\x86\x57\xe2\x9f\xb4\x3f\xb1\xf1\x2c\x6f\xd0\xca\xd1\xe4\xd6\x2d\x0f\xb2\x99\x4b\x8d\x19\x87\xd5\xc4\x70\x81\xe6\xb1\xb7\xcb\x5b\x94\x94\xe1\x1e\x55\x7f\xc1\xbb\x5a\x9d\x76\x2f\x7d\x77\x57\xce\x55\xb7\x4b\x01\x11\x84\xe7\xe5\x6e\xa8\x1b\x61\xa2\x5d\x31\x9b\x09\xca\x41\x50\xd1\x88\x9f\xd7\x15\x00\x2d\x83\x22\x68\xfc\x33\x55\x51\x80\xea\x66\xb5\xc3\xd3\x27\xd2\xde\x47\xe6\x27\xae\x09\x9f\x97\xd4\xee\x3b\xc7\x7a\xf3\xe0\xb5\xc1\x52\x67\xa8\x65\xed\x4a\x75\x65\x4b\x7b\x93\x9b\x31\xc0\xc3\x72\xc5\x69\x73\xe3\xe4\x3e\x75\xeb\x3f\x8f\x74\x6d\xfc\xca\xb6\x2d\x5f\x9b\x37\xb7\x23\xbb\x02\xae\x2a\xda\x72\xf9\xab\x5a\x5c\xf3\xe1\xf8\xef\xa9\x95\xec\x75\xc4\x3c\xe8\xcf\x59\x05\x8b\x8f\xe8\x8f\xc5\x2c\x04\xb5\x60\x7e\xdb\x2c\x13\x58\x0b\xb9\xb4\x9e\x18\x20\xc2\x78\x61\x03\x65\x5e\xf5\x4f\x52\x48\x03\x3a\xfe\xdc\xe5\xb2\x21\x78\x9e\x15\xf0\x5a\x49\x6d\xad\x05\x5c\x32\x8a\xdc\x3d\x7d\x80\xad\xe6\xf2\xe0\xd7\x60\x9e\x52\x2b\xa5\xd3\xce\xb8\xe9\x14\x3f\xdf\x12\x8d\x67\xe6\x9d\x1a\x3f\x6d\xcd\x5a\x99\x77\xb7\x0d\xaa\x69\xe8\xab\x84\x3d\x52\xca\xe7\x49\x72\x66\xca\x2e\xaf\x8c\x27\xb3\xc9\x64\x01\xbc\xd9\x3b\x37\x46\xf9\x3f\x7b\xd1\xb9\xfd\x23\x03\x9d\x3e\x5b\x23\xdf\x9c\xcb\x37\xcd\xbf\x6c\x76\xa0\xd0\xbb\x6c\x78\x4d\x72\x4b\x9b\x63\xc3\x99\xcb\x4e\x5d\x24\x3a\x45\x93\xd0\x1a\x0d\x74\x24\x4c\x16\xce\x66\xf1\xc8\x5e\xd7\xcc\x65\xeb\xbb\xbb\xe3\x9d\x0f\xa1\x33\xeb\x00\x9a\xef\x0c\x75\xd4\x47\x24\x91\x97\xe0\x27\xe2\x14\x65\x25\xa8\x54\x63\xd8\x2c\x9a\x75\xc9\x88\x58\x32\xf1\x89\x92\x99\xe0\xda\x51\x11\x0a\x1e\x41\x15\x93\x53\x16\x8c\x01\x8b\x0b\x5b\xa7\x48\x27\xbd\xd6\x7e\x7c\x23\x69\xf4\xce\x68\x88\xb5\xf7\xa6\xdd\xd6\x14\xb9\xf0\x8c\x65\x39\x69\x6d\x64\xf6\x0a\x75\xee\x29\xcd\x66\xf2\x25\x89\xbc\xeb\x2d\x55\x21\x83\xd7\xaf\x18\x18\x6c\x98\x97\x6b\x3e\xd5\x26\x85\x5b\x37\x3d\x31\xf6\x95\x87\x16\x2f\xde\xb1\x7b\xec\xa5\xdb\xa0\x1e\x75\x8f\x7f\x4c\xaf\x80\x7a\xd4\x43\xac\x50\x04\xa7\x97\x23\xe2\x5e\x9a\xa0\x67\xf6\x76\x04\xba\xe9\x6e\x9b\xbe\xe8\x6e\x68\x63\x5a\x88\x28\xfe\xb9\x05\xfa\x62\x12\x4d\x33\xda\xce\xa3\x6b\x7c\xb1\xb2\x79\xe9\xae\x23\x85\xd4\x54\x8d\xca\xdb\x23\xd0\x8a\x40\x11\xb1\x78\x2b\x3a\x90\x10\x5b\x40\xb2\xea\x8b\x62\x83\x63\x40\x93\x59\x0a\xf0\x09\x07\xbd\x42\xf6\x8d\x7d\x2b\x0b\x76\x45\x64\xbf\x8b\x53\x0f\x9d\xf2\xcc\x97\xe7\x73\xce\x54\x70\xe3\xe9\xb4\xa7\xb9\x3f\x3f\xa3\xc1\x6d\x64\xb3\xb6\x91\x21\x86\x39\x67\x85\x65\x89\xe7\xb5\x3f\x91\xc4\x95\xea\x7b\x67\x3d\x29\xb4\xaf\xbc\xb0\x03\x1c\xfd\xcc\xdf\xd5\x43\xaf\xf9\xc4\xf4\x5f\xc0\xcd\xfb\xcc\xde\x86\x26\x27\xb5\x64\xa0\x65\xa1\xc5\x9d\xe8\xeb\x9f\x17\x90\xd6\x6d\xee\x30\xab\x8f\x20\xbb\x32\x53\xdd\x00\x6e\x85\xf4\x37\x22\x7f\x48\x60\x02\x8d\x0c\xd5\x94\xb2\x1c\x05\x1b\x88\x06\x78\xd8\x22\x12\x1b\xa6\xf0\x87\x78\x80\xdc\x05\x56\xf3\x2a\xfa\x80\x53\x0f\x41\x2a\x5e\x9c\x6e\x3e\xc1\xad\x8d\xae\xa0\x68\xb0\xac\x94\x8c\xb4\x09\x90\xbc\xdb\x1e\xec\x56\x2e\x49\x49\x36\x32\xb9\x6b\x56\x33\xf5\x51\xcf\xe2\x64\xef\xa6\xe3\xfd\x36\x9b\x75\xa5\x25\x7a\xc6\xcf\xc9\xcb\x36\x8e\xc6\x83\xed\xae\xe8\xce\x96\xd3\x1c\x62\xb8\x39\x87\xfc\x4e\xa8\x58\x12\xb4\x37\x29\x22\xa7\x58\xb8\x38\x2d\xc6\x09\x3a\xdd\x14\x74\xea\x92\x09\xc2\xc5\xd1\xd0\xc6\x57\x65\x51\xb7\xd1\xa1\xbf\x89\xd9\xaf\x9d\xc2\x88\xe5\x55\x47\xd3\xad\x59\x78\x03\xda\x35\x92\x9b\x94\x82\x92\x9a\xe9\x00\xe1\x48\x30\xe4\x91\x86\x32\x3b\x1b\x9d\xbc\x3f\xb1\x78\x79\xa7\x31\xdb\x12\xf5\x3f\xc6\x9f\x33\xe3\x88\x6c\x5d\xbd\x3a\xdf\x79\xdd\x75\x3d\x2b\x77\x66\x86\x43\x5e\x47\x4b\x8f\xdc\xac\xaa\x17\xaf\xbb\x66\x41\xb7\xe6\xb3\xad\x1f\xff\x3b\x9d\x81\xfa\x1f\x80\xd1\x1c\xd4\xff\x20\x91\x30\xd8\xa0\x7f\xd9\x92\x89\x59\x24\x8b\xbe\x60\x09\x2f\x38\xa5\x2f\x78\xfd\x34\xfa\x4f\xb2\x68\x4a\x51\xed\xa1\x6b\xd0\xb6\x36\xda\x02\xa4\xb6\x05\x70\xa1\x3f\x9d\xb9\xf0\xcd\x5b\x7e\xfb\xb7\xa1\xb9\xf3\xdb\xf3\x29\x89\x23\xe3\x0e\xb2\x6d\xd1\x8a\x62\xd3\xfa\x40\x7e\x61\x51\xbd\x73\xd1\x92\x27\x1e\xda\xf5\xd0\x30\xb9\xf5\x45\xf5\xe7\xd7\x01\x2f\xb0\x5f\xf0\xcb\x95\xed\xfd\xcd\x6b\x6c\x12\x2f\x74\xde\xf3\xd4\x65\x2b\xaf\x58\x13\x5b\xfa\xdc\xa6\xef\xbf\x74\xe6\xcb\xe8\x8c\x81\xfb\x17\xf9\x9c\x25\x62\xbe\xe2\x1c\xa0\xbb\x85\x0e\x37\xe7\x77\x0b\xb4\x91\x3d\x7d\xf8\x14\x6f\xdc\xfb\x24\x3a\x64\x57\xc6\x61\x6c\xf6\x78\x8f\x95\xb3\x6a\x3b\x80\xab\xee\x80\xfa\x8a\x08\xdd\xc3\x20\x35\x57\x02\xc9\x21\x87\x75\x9e\x44\x87\x92\xee\x0d\x55\x4e\x23\xb1\xd6\x7d\xd2\xe2\x37\x5d\x68\xfd\x40\x93\x5a\xa2\xf6\xf8\x82\xae\xa9\x7d\x8e\x5b\x4c\x58\x8e\x7f\x3e\xff\x43\x56\x48\xb5\xa5\x64\xf7\xf5\x52\xc2\xca\x1a\x7a\x0a\x5d\xad\x5e\xbb\xd1\x6c\xe2\xfc\x62\xb8\x3d\xdd\xdc\x06\x1e\xf1\x1a\x4d\x33\x5c\xa2\x12\xcf\x75\x27\x5d\xac\x29\xd3\x33\x6b\x0e\xcd\xc6\x96\xa8\xbf\xfa\xce\xe2\x65\xcb\xec\xde\xdd\x81\x23\x52\x6f\x43\x6e\xfd\xa6\x4b\x16\x0d\x14\xbb\xf6\xc8\x5d\x09\x0b\x63\x4f\x89\xd9\x54\xbc\x87\xe5\x1a\x9a\xfb\x2e\x3c\x7b\x5f\x77\xef\x6d\x92\x7b\xde\xdc\xbe\x53\x7f\xbe\x68\xb1\xb3\x30\xb3\x2b\xb3\x9a\x33\x4a\xa1\x4e\xcd\x47\x51\x77\xe2\xb8\xad\x97\x58\xa8\x08\xa6\x5e\xa1\x31\xdb\x28\xf5\xd2\x7d\x33\x7d\x71\xc6\xe9\x84\xf1\xeb\xd9\x87\x4b\x4e\x67\x17\xf3\x24\x38\xe3\x71\x5b\x73\x57\xf3\x24\x7f\x0c\x77\xc9\x4d\x32\x1a\x75\x47\x26\x12\xb6\x5c\xf6\x46\x12\x49\xcd\xff\x28\x9f\x0c\xb1\x7a\x4f\xde\x2d\x52\x57\xda\xa4\x18\xf4\x2e\x5d\x4d\x39\xf5\xc1\xce\x52\x61\x45\x7b\x67\xc2\xc9\x72\x64\xaa\xab\xbd\x93\x65\x5c\x82\xa7\x38\xa7\xa3\xa5\xab\xd9\xc3\xd9\xbd\xa4\x7d\xf5\x29\xea\x73\x82\x5d\xf0\xd9\xbc\xf4\x1d\x6d\x9d\x9e\xf8\xfe\x6c\xa3\x81\xec\x6c\x1b\x38\xd7\x66\x69\x69\x0e\x37\x05\x76\xcc\x1b\x7e\x7a\x49\x6f\xae\xe9\x0c\x87\xd3\xe4\x1d\xda\x8c\xec\x05\x3c\x77\x5f\x80\x3a\xde\x4b\xac\x52\x1c\x66\xc2\xd1\x48\xb5\x34\x7a\x09\xe8\x73\x06\xe2\x94\x28\x46\xb4\x28\x5e\x14\xa9\x02\x9f\x2e\xa4\x75\x9d\x2f\x4c\x7d\x1a\x57\xe0\x61\x26\x92\x5f\x7f\x3a\x63\x5d\xaf\x78\x63\xd8\xfd\x12\x35\xea\x2b\xc4\x57\x4f\xee\x17\xee\x1c\x73\x75\x80\x7f\x2f\x3c\xbd\x5b\x6e\x2f\x8e\xa8\xff\xcc\x15\xe3\xad\x91\xb6\xae\x24\x0c\x68\x3b\x37\xd0\xa2\xdd\xfb\xf9\x7c\x6b\x47\xb3\xc8\x18\xd3\xe0\xd9\xa1\x12\x3e\xcc\xb7\xff\xcf\x91\x19\xe7\x1e\xdc\xb6\xfd\xae\x42\x64\x4f\x5e\x76\xe4\xdb\xda\xce\xf2\xca\xd1\x9c\x6f\x9d\x72\xe4\xc0\x8c\x5c\x76\x2d\x3c\xde\xc3\x2d\x7b\x5f\x81\xb4\x6f\x55\x77\xd1\x5e\x28\xeb\xf9\xc4\x5c\xc5\x99\x97\xba\x58\x5e\x6a\x09\x4a\xb1\x20\xc1\x32\x0b\x17\xe4\x67\xbb\xa0\x90\x8f\xb0\xe1\xae\xa6\xd9\xb3\xbb\x34\x39\xcf\x2e\xcb\x59\xc8\x61\x51\x4f\x1c\xa1\x07\x09\x42\x3a\x6f\xb0\xd1\xc1\x1a\x99\x77\x56\xcf\x77\xb4\xf3\xdd\x32\x46\xc4\x31\xe0\x63\xaf\x93\x28\x54\x05\x8e\x77\x0e\xed\x75\x99\x4c\x1e\x57\x30\xbd\xe2\xd8\xfd\xe7\x36\x58\xdd\x09\xab\xc9\x10\x48\xc6\x7d\x8d\xfd\xdd\xcd\x22\x47\xcf\xc9\xe6\x15\xef\xdc\x0c\x37\x1b\xcc\xfd\x52\x47\x5f\xbb\xc8\xf7\xf4\x75\xb6\xfa\x69\x22\xaa\xd0\x8e\xd4\xfc\x57\x5f\x7e\xe4\xde\x2f\x7c\x24\xb9\xec\x11\x9b\x97\x6a\xdb\x70\xdb\xa9\xa7\xf8\x9c\x4e\x86\xe9\x18\x48\x9c\xee\x4e\xd1\x14\xd9\x9d\x69\xec\xbc\xf9\x1b\x4b\x7a\xce\xdd\x02\xce\xba\xb0\xa7\x35\xbb\xc1\x66\x4f\xb9\x5b\x91\xde\xb7\x41\x3d\xf8\x3d\xb4\x15\x8b\x89\xd3\x94\x20\xd7\xe3\x94\xf8\x3e\x43\x57\xd8\x99\x0a\x1b\x08\x9e\x5d\xba\x84\x77\xc1\xe7\x16\x1a\x12\xfd\x0b\xfb\xb1\xd5\x68\x5f\x78\x14\xf2\xc2\x49\xb8\x30\x5f\x9c\x65\x25\x28\xd7\x09\x76\x6b\x7d\xc6\x35\x73\x3d\x6b\x22\x2a\x1b\x69\x28\x5b\x10\x64\x14\x12\x59\x52\xb3\x21\x48\x13\x6a\x79\x01\x4f\x4f\x7d\x82\x5b\x21\x16\xad\x7d\x9e\xfa\xbd\x60\x32\x71\x86\x40\x68\x68\xc5\x60\xe3\x8b\xf7\x34\x1a\x8e\xff\xb4\x83\xec\x0e\x7a\xe5\xc0\xc5\x5f\xdd\x16\x76\xd1\x5d\x9d\x6d\x9d\x4d\x2e\x2e\x95\x9b\x3b\x87\x76\x75\xef\x5b\x74\x75\x51\x3e\xbf\x59\xe0\x7a\xfb\x4f\xe9\xa6\x54\x69\x3e\xc7\x9d\xbe\xeb\xa6\x91\x1b\x2f\x49\x73\x37\x89\x47\xa0\x03\x2a\xb9\x57\x9c\xbf\xb6\x3b\xd9\xfb\xa5\xa4\x6c\xef\xe9\x4c\xad\x87\x47\x55\xae\xb9\xfd\xea\xc5\xed\x73\xd6\xdd\x72\x58\xb9\x30\xb3\xda\xe1\x6c\xe8\x46\xe7\xc1\x4e\x75\x17\xf5\x36\xdc\x2b\x6d\x84\x42\xf4\x41\xef\xc2\xea\x27\x94\x19\x0d\x33\x08\x2b\x3d\x30\xab\xaf\xaf\xd9\x0e\x3d\xc2\xf5\x70\x73\x9c\x01\x8f\x8b\x08\xe6\x4b\x73\xc5\x23\xac\x8d\xe4\x2b\x26\x81\x07\xf5\x6e\x21\xf4\xed\x6b\xbc\xc2\xce\x4a\x1e\x82\xd4\x95\x09\xea\x12\xce\x4e\x50\x6f\xdb\xe5\xc4\xbc\x6d\x67\xf4\xfb\xb8\x36\x39\x96\x3d\x7b\x5b\xdf\xfa\xd5\xb2\xe8\x9b\x31\x53\x65\xd3\xf9\xb4\xc3\x4a\xb5\x92\x83\x9d\x73\xbd\xf6\xb1\x38\x34\x05\xa2\xdd\x3c\xc7\x68\xa6\xfc\x97\x6c\xce\xf6\xb6\x2f\xec\xeb\x69\x97\xa1\x3b\x98\x6b\xee\x4c\x9d\x76\xfd\x29\x8d\xfd\xcb\x4a\xa7\x37\x6d\xcc\xb9\x66\xb5\x76\x2e\xb7\x7b\x03\x99\x55\xd7\x7e\xb2\x47\xf2\xd9\x82\x41\xea\xc7\x4e\x21\xcf\x6b\xf1\x3b\x8e\x0f\xfe\xbf\xe2\xf7\xa9\xc3\x03\x7b\x61\xca\xe8\x60\xd8\xe5\xeb\x42\x11\xfc\xe4\xd8\x60\x29\x41\x30\xb7\xc3\x7d\x3a\x4a\x0c\x29\xd2\x20\x31\xab\x79\x9e\x31\x95\xb0\xd8\x2d\xa9\x66\x82\x59\xbf\x6e\x68\x56\xb3\x4d\xb2\x41\xad\x7c\xbc\xb4\xb6\x53\x42\x87\x59\x6a\x9e\x71\x9e\xb6\x61\x8d\x35\x87\xd9\x34\xe3\x45\x10\x6f\xa1\x83\x0e\x3d\x54\x6c\x7f\xcb\x31\xb1\xb6\x49\xcb\x1a\x0b\x7f\x74\x48\x9d\x05\x67\x79\x0f\xd7\xff\xda\xc0\x5a\x40\x04\xee\x72\x2d\x36\xab\x7a\xf2\x50\xb6\x32\x70\x33\xb7\xcf\x3a\x2d\xbf\xb2\xf7\x8b\x63\xc3\xa3\x7e\x97\x74\x5e\x9b\x64\x9c\xd7\xd6\xde\xee\x34\xb2\x94\x24\x4a\x6e\xfb\xec\xb6\xa6\x0b\x7f\xd0\xd1\x9d\x93\xb8\x81\xb6\xce\x0e\x11\x72\xc6\xe4\x93\xdd\xe9\xcb\xfe\x0b\x3c\xb5\x5c\x5e\x79\x46\x67\x2c\x28\x04\x3a\x3a\x03\x4d\x1c\xe7\x91\xf2\x23\x34\xd1\xba\xe7\xfc\x81\x07\xef\x50\xef\x23\x73\x0f\xa4\x7b\x16\xb5\x38\xcf\x6b\x5e\xe2\xc8\x51\x24\xd5\x98\x69\x28\xd2\x6e\x6f\x57\xd7\x79\xea\xd5\x77\xaf\xfd\x37\x78\xdc\xd0\xdd\xd6\xb2\xc6\x95\x66\x19\xaa\x25\x17\x5b\xc2\xd9\xd2\x67\xa8\x1f\xa9\x77\xde\xb5\xf8\xa5\x4b\x66\xa5\xda\x9c\x76\x91\xb5\x76\x76\x44\x7b\xe3\x6e\xab\x97\xb1\x8a\xf8\xec\x4b\x8f\xbf\x47\x2f\x80\xfa\xdd\x05\xfd\x05\x9b\x95\x70\x35\x04\xd3\x0d\x04\x3d\xa3\xdb\x1b\x32\xa0\xfc\x83\xa3\x31\xd7\xa8\x9f\x00\x39\x28\xf6\xa0\x9e\xae\x0a\xd6\x9e\x00\x08\xc2\xb8\xee\xe4\xb3\xd1\x48\x19\x0a\x9d\x9a\x3a\x94\xbd\x01\xd6\x10\x2b\xe4\xda\xf3\xc9\x89\x47\x1e\xd6\x76\x7a\x01\xe0\x4c\xd1\x46\x0b\x6b\x66\xa4\xf0\xec\x53\xd5\x15\xfb\xe6\x99\xf8\x88\x5b\xcd\xaf\x96\x4d\xed\x73\x97\xf6\xb4\xf5\x65\x44\x2e\x45\xae\x5c\x5f\x6c\x76\x91\x33\x6f\x7a\xe2\xae\xa6\xb8\xcf\xc8\x36\xdf\x00\xce\xbe\xf3\xa1\x25\x5f\xfd\xee\x7d\x0f\x78\x1b\x05\xe7\xd6\x8e\x23\x5e\xf9\xb3\xd7\xee\xf9\xf1\x39\x73\xf2\x2d\xcb\x61\xa0\x90\xdd\xf1\x22\xda\xc3\x65\x7d\x0e\x11\x7d\x44\xa7\x62\x35\x86\xfa\x60\xc4\x64\x0f\xd1\x4a\x3f\x1d\x7b\x12\xac\x7b\xdc\xda\xdc\xdd\x8c\x2d\x9c\xaf\xfb\x49\xa4\xdb\xb9\xc9\x69\x96\x13\x66\xa8\xa0\x93\x7c\x92\x04\x56\x75\x03\xf4\x65\xdb\xa0\xfe\x1b\x9d\xbe\xfe\x33\xbb\x55\x79\xea\xb4\x56\x75\x53\xcc\x6d\x6f\x3f\x15\x6f\x8a\xdc\x69\xc7\x77\x4e\x93\xed\x42\xb3\x28\x3f\xa4\x56\x42\xfa\x82\xd0\x46\x75\x2b\x82\x31\x18\x6a\xce\x35\x27\xec\x41\x66\x20\xd6\x3b\x8b\x6b\xa3\x9f\x86\xd2\xea\x25\xda\x30\x85\xbd\x3a\x85\x84\x26\xb5\xee\x93\x90\x58\xa1\x90\x39\x69\x32\x82\x5a\x69\x2f\x58\x4c\x8c\x25\x94\xe9\x6b\x69\x4d\xba\xac\x1a\x89\xc5\xe9\x32\x14\x15\x2a\xdb\xdc\x73\x72\xd9\x55\x0e\x4c\xe4\xd0\xb4\x59\x0b\x24\xc7\x1c\x99\xa4\x76\x42\x5d\x8d\xc1\xc8\xbc\x5b\x71\xf3\x44\x43\x7b\x77\x7b\xb3\x9b\x30\xb1\x0b\xe6\xb3\xa9\xd4\xc0\x7c\x67\x61\xa0\x80\x05\x29\x0f\x54\x05\x89\x27\xe0\xd5\xeb\x27\x75\x62\x4a\x3e\x05\xad\x3b\xdd\x99\x55\x4b\x2d\x06\x9d\xae\x01\xae\x4a\x97\x9a\x9d\x3e\x27\xd3\x33\xbc\xf8\xd4\x8e\x98\x6d\x32\x79\xa7\x9e\x80\x6e\x68\x0b\xc9\xfd\xe0\x2a\x7a\x0b\x21\x12\xee\x23\x16\x82\x90\xdc\x46\x27\x26\xef\x58\xe5\xda\x0e\x7a\x16\x94\x26\xb3\x42\xa7\x03\x86\x71\x28\x3d\x79\x95\x6d\xc1\xca\x9c\xd3\x15\x33\x59\x18\xf7\x3e\x8f\xd1\x21\xf6\x06\xe8\xd5\x82\xef\xda\x7b\x4a\x92\xd5\x68\x34\x67\x40\x4c\x11\xdc\x98\xaf\xf0\xfd\xc9\x67\xf0\xfb\xa7\xd1\x9d\x9c\x85\x70\x47\x88\x48\xa6\xd9\x18\x72\xa6\x34\x36\x1e\x6b\xaf\xb4\x1e\x4e\xfd\x61\xcc\x14\xcf\x91\xcf\xd8\x0b\xf3\x17\x4b\x52\xc4\x64\xb1\x89\x3b\x7d\x46\xa7\xab\x2f\xa0\xbe\x3a\xd5\xa2\x6c\xc1\x2d\x57\x5d\x1d\xb2\x1a\x2d\xa1\x66\x60\x9c\xeb\x10\x85\xfa\x55\x3a\x44\xb8\x46\x12\xc6\x35\x24\xf5\x18\xc1\x13\x0e\xe8\xad\xc0\x03\x8f\xe3\x0c\x82\xcd\xce\xf3\x76\x03\x6d\xa0\x5d\x4e\xab\x4d\xb0\x15\x4b\x0e\x41\x20\xed\x2c\xc3\x1b\x38\x8e\xe6\x49\x7e\xb0\x64\x26\xeb\x5b\x42\x73\xd5\xf9\xf1\x65\x04\x0b\xcd\x71\x41\xde\x4a\x1c\x37\x82\xe6\xb4\x86\xd0\x64\xc4\xe0\xa4\x22\x60\x48\x7d\x64\x13\xe8\xbd\x13\xcc\xdf\xa9\x0e\x5f\xba\x52\x7d\xf8\xb4\xb1\x2f\x01\x4f\x06\x35\x2c\x9c\x7b\xfc\x26\x1f\xfc\xfe\x7f\xff\x47\xfe\x58\xdd\x85\xf9\x88\xee\x53\x7f\x4d\x1d\x82\xfa\x99\x20\xf6\x2b\xcb\x12\x54\x9c\x8e\x03\x9b\x14\x71\x05\x02\x66\x40\x9b\x4c\x20\x42\x35\x26\xe3\x66\x33\x67\x77\x72\xce\x62\x29\x41\x15\x4b\x2e\x7f\xb1\x14\x36\x24\xa0\xab\xb5\x35\x01\x78\x97\xec\x1a\x74\x8d\xb8\xb6\xba\x18\x8e\x4a\xb8\x12\x2e\x03\xc7\xcb\x01\x13\xc0\xcd\xad\xb1\x6a\x73\xab\xe6\x88\x76\x67\xb3\x3a\x12\xaa\x80\xe6\x55\x6b\x6d\x52\x42\xdd\x59\xa7\xfb\x64\x98\xb6\x42\x3e\x66\xd0\x3a\x5d\x51\xd9\xb1\xde\x75\x5e\xc8\x09\xb1\x64\x4c\xc8\xb5\xa3\xd9\x3a\x11\xa7\x40\x81\x77\xcf\x56\x3f\x77\x8e\xfa\xc3\x51\xf0\xc4\x16\xf2\x93\x7e\xdf\xea\x0b\x3e\xf7\x0b\x7f\x5f\x9f\xef\x97\xf7\x5e\xb1\xa2\xb1\xdf\x32\xe6\x3b\xfb\x27\x19\xef\xc7\x9f\x78\x10\x03\xe2\xae\xcc\x3f\x6f\x31\xaa\xdf\x38\x4f\x7d\xed\x7c\xf5\x2e\xd3\x21\xf5\x23\x70\x1d\xf8\x9c\x7a\x29\xae\x53\xd5\xb1\x8a\x31\x12\xc9\x4c\x62\x8b\xd2\xdb\xd3\x26\x49\xc4\x8c\x19\x79\xa3\x9c\x72\xa4\x1c\x7d\xfd\xfe\x42\xa2\x50\x2c\x49\x3d\x4d\x3d\xc5\x52\x1b\xdf\x24\x37\x65\x9b\x46\x9a\xb6\x36\x31\x76\xaa\xa9\x89\x6b\x88\xca\x09\x77\x9a\xe1\x98\x65\x25\xbb\x8d\xb3\x13\xfa\x49\x8e\x41\xe9\xb4\x81\xd6\x93\xd1\x02\x72\xdd\x15\x28\x12\x1c\x74\xc0\x00\x2b\x8f\xef\x0b\xe1\xc6\x45\xa5\xe4\xbc\x16\x6f\x43\x4a\xf5\x81\xc2\xa8\x87\x05\x44\x0d\xa8\x3b\x0c\x67\x3e\x00\x2e\x02\x73\x93\x6b\x73\xe7\x96\x3a\x6f\x6c\x6d\xbf\x73\xf9\x1f\x57\x5f\xf7\xdd\x7f\x0c\xdd\x7c\xdb\x35\xf3\x4f\xd9\xb0\x3c\xda\x75\xcf\xae\xfb\xe7\xad\xba\xf3\xe1\x47\xa9\x9b\x2e\xb8\xdc\xe4\xd8\x77\xc5\xba\xb1\xde\x91\xd3\xd4\x5b\x4f\x03\xbf\x1c\xde\xb9\x73\xa6\xc3\xd2\x15\xce\x5c\x7e\xb9\xfa\xe7\x33\x2f\xe9\xa1\xe9\x1b\xd6\xad\xce\x5e\x78\x2c\x76\xca\xd2\x1f\xff\x60\x08\xec\x99\x23\x8c\xb6\x1e\xa0\xc9\x75\xe7\x3d\x72\xfc\x9d\x1b\x9f\xfc\xfa\x57\x89\x32\x8e\x1f\x75\x39\xd4\x17\x89\x08\x13\x29\xe2\x6c\xa5\xd7\x0f\x35\x30\x1c\xb6\x89\xb4\x99\x36\xa7\x9b\x64\x12\x77\x2e\x46\x24\xde\x2a\x5b\x07\xad\x23\xd6\xad\x56\xa8\x17\x56\xab\x51\x10\x52\xc5\x12\x02\xa8\x17\x78\x63\xb8\x58\x32\x9a\x07\x4b\x08\x88\x3b\xad\x57\xa2\x97\x3b\x02\x72\x53\x0d\xb2\xc0\x4d\xdd\xb1\x0a\xa0\x84\x0e\x2f\x80\x93\x28\x40\x07\x9d\xf0\x56\x00\x3d\xa9\xcb\xcf\x3f\xff\xd8\x1f\xd5\xd3\x2e\x83\xff\x81\xeb\xff\xfb\x9b\xe7\xab\x7f\xb8\x61\xd7\xe5\xb7\x6f\xda\x74\xf1\x96\xad\x97\x6e\x24\xb9\x62\x7e\xcf\x35\xbb\x32\x5e\x70\x51\x11\x0c\x7b\x33\xe7\x5d\xb8\x6f\x86\x3a\x7f\xe5\x19\x23\xcb\xd4\x5b\xc0\x53\xc5\xd1\xe2\x12\x68\xbb\x5a\xc6\xdf\xa3\xce\x87\x7a\xe0\x23\x5a\x14\x89\xa7\x8c\x12\x25\xf9\x03\x0c\xc2\x3c\x61\xec\x12\x41\x38\x06\xb5\x5e\x86\x0a\xe0\x53\xc5\xcc\x30\xd1\x86\xbc\x3d\xd2\x2e\x83\xda\x5e\x17\x28\x3c\xe8\xb8\x91\x9e\x3f\xa9\x63\xe0\x6f\x37\x3c\x4a\xcf\xf4\x8e\x7e\xfe\xd0\x9d\xf7\xdd\xb9\x6c\x6f\x43\xb8\x87\x1e\x7c\xc6\xa5\xbe\x03\xfe\x37\xf1\xee\x97\xbb\x5e\xfb\xe5\x0f\x7e\x12\xf3\xdd\xf1\x2f\xa8\x73\x24\x11\x1f\x1f\xa3\x7e\x0f\xf9\x6c\x82\x9c\xee\x52\x64\xc6\x45\x58\x5d\x56\x8f\x17\xf7\xfb\xd2\x50\x07\x79\x34\x0a\x1e\x72\x93\x81\x5c\x75\xe0\x5d\x56\x6d\xbc\xae\x9a\x3d\x8c\xc7\x81\x16\x01\xc2\x34\x62\x5f\x3c\x86\x7b\x9f\xa8\xf6\x17\x9e\xde\xb4\x61\xe9\xbd\x37\xa8\xdf\x00\x14\x00\x1f\xfd\x43\xfd\xf0\x65\xc8\xad\x5f\x3f\xfd\xfc\xf1\x8f\x98\x97\xc8\x9b\xff\xf8\xee\xdf\x3f\xa0\xb4\xfe\x26\xa2\x66\x2d\x82\x36\xe5\x5d\x46\x3d\xed\x66\x1f\x65\xa6\xc2\x11\x17\x16\xb7\x3c\x59\xda\xa1\xb2\xb4\x25\x33\x92\xb5\x41\x2c\x96\x0c\xc6\x09\xeb\x2c\xcb\xbc\xae\xed\x4e\x07\xcf\xa8\x59\xaf\x26\x6f\xa8\x01\x82\xbb\x2c\x64\x01\xfc\xa6\x66\xe1\x97\x5d\x46\xf2\xef\x21\x72\x20\x55\xd4\x21\x7d\xf1\xba\x80\xd5\xd1\xa2\x7a\x0b\xf3\xd2\x8b\x4f\x3f\xaf\x3e\xaa\xcf\xab\xa7\x9a\xf1\x3c\xc9\xd5\x4a\x9e\x73\xb9\x78\x16\xea\x8e\x37\x10\x44\xc6\x8d\xe7\x64\x6e\x90\x1b\xe1\xb6\x72\x90\x0a\x8e\xf3\xd3\x92\x0b\xf8\xc1\x60\xc9\x2f\x1a\x2d\xa8\x81\x82\x26\x07\x4b\x34\x4f\xf4\x97\x49\x10\x88\x29\x46\x5f\x74\xe3\xf5\xf7\x6b\x1d\xe2\x53\x9a\xac\x38\x5c\xef\x6b\xd8\x4c\xfd\xd2\x57\x63\xa6\x68\x8d\xe1\x13\xcc\x13\x5a\x33\xc6\x0c\xc6\x7d\x37\xab\x95\x8e\x46\x87\x14\x8f\x3b\x64\xca\x68\xa3\x8c\x54\xaa\xe9\xff\x91\xf6\x1e\x70\x52\x95\xe7\xfe\xf8\x79\x4f\x99\x3e\x73\xda\x9c\xe9\x7d\x76\x67\xb6\xcc\xb6\x99\xad\x6c\x3b\x2c\xdb\x80\x85\xad\x94\xa1\x2e\x4a\x93\x0e\xb2\x80\x74\x04\x44\x54\x04\x45\x82\x41\x63\xd7\x60\xa2\x26\x2a\x22\x37\xe6\xda\xa2\x49\xae\xc6\x44\xa3\xf9\x59\xa2\x37\xcd\x5c\x73\x13\x4d\x62\x34\xcd\xb0\x87\xff\xfb\xbe\xe7\x4c\x5b\xc0\x7b\xef\xe7\x1f\xc2\xee\x0c\xee\xce\x79\x9e\xe7\x7d\xfa\xfb\x3e\xdf\x97\x50\x31\x82\x59\x31\x28\xf6\x8b\x8b\xc5\xf5\x22\xf3\xbf\x46\x09\xce\xbf\x05\x08\xcf\x0b\xff\x6f\xc1\x81\xff\x27\x10\xe0\x2f\x47\xfc\x55\x7b\x96\xe5\x4a\x17\x29\xc0\x75\x30\xc3\x08\x3e\x49\xf6\xeb\x44\x91\xb0\x58\x1c\x4e\x74\x15\x44\x7f\x9a\x65\x8d\xd4\x70\x1a\xd6\xce\x16\xb1\x3f\x6d\xc9\x40\x3b\x55\xe5\xb5\x2c\x33\x87\x6d\xf2\x67\x13\xc4\x2c\xa8\xc0\x8b\x72\x45\x42\x96\x13\x15\xb2\xe9\x5e\xf0\xd1\x3d\x07\x95\x27\xd4\x77\x32\xd8\xa1\x42\x74\x6a\xf7\x0f\x72\x17\xfe\x42\xd6\x43\x1a\x44\xa2\x4c\x96\x60\x6e\x2a\x4a\x76\x13\x3f\x90\xb6\x9a\x1c\x2a\xd0\x28\x42\x19\xcd\xb7\x72\x3e\x85\x91\x8d\xd4\x91\xc1\xcc\x9c\x0f\x94\x55\x1d\x30\xdf\x0a\xfe\xfd\xba\xce\xb1\xa9\xf3\xa7\x34\x84\xbc\xb5\xb3\x34\x20\xd0\x57\x57\xde\x34\xdd\xf3\xca\x76\xef\x36\x55\xef\x68\x09\x3e\xcb\x0d\xd7\xb0\x52\x67\xb7\x0b\x56\xbd\x85\xb7\x5a\xdc\x36\xb7\xcd\xe3\xb5\xdb\xdc\x4e\x77\x7f\x5a\xd4\x09\x56\x9d\x95\x74\x4a\xbc\x64\xd1\xeb\x55\x1a\x8c\x18\xea\x34\x9b\x0c\xb4\x6b\x73\xa9\x05\x5e\xf2\x12\xe8\xb7\x59\xe4\xf6\x2c\x72\xb8\x8a\x62\xfa\xc0\x15\x40\x1e\x53\x7e\x04\x0e\xaf\xfe\xa7\xf2\xd5\xb5\x7b\x94\x45\xbb\x54\x5a\x95\x25\xe0\x6b\x18\xee\xfb\x4d\xc5\xe8\xac\x00\x3f\x4d\xab\x17\xe7\xab\xfb\xa1\x3e\xcd\x66\x9c\x78\x96\x5b\x10\xf4\x14\xe5\x74\xb9\xad\x06\x93\x01\x1a\x36\xcd\xdb\x68\x1b\xcb\xc0\x3f\xc0\xc4\x3a\x01\x80\xca\x08\xa8\xfe\x34\x90\xb2\x76\x82\xc3\x7e\x1e\xdd\xf9\x13\x82\x18\x95\x4c\x9f\x1d\xc8\x6c\xc0\xd0\x41\xc8\x4a\x82\xe3\xba\x5d\xd7\x5d\xb7\x0b\xdc\xbd\xf3\xc7\x3f\xfe\xf6\xce\x99\xe5\xed\xd0\xa2\x03\x33\x07\x66\x82\x27\x30\xb9\x8f\x6d\x1b\xd8\xa6\x1c\xb5\xbc\x88\xe9\xab\x82\xb2\xfd\x25\xa4\xcf\x45\x5c\x21\xa7\xa0\xf6\xf3\x1c\xcd\xd8\x6c\xb4\xcb\xe8\x32\xba\x3d\x41\x84\x6d\x0a\xa0\x51\xd8\x8c\x2e\x87\x0b\xaa\x93\x43\xa2\x79\x89\x15\x04\xd2\x80\x05\xcc\x64\x05\xcc\xab\xe9\x56\x7b\x1e\x84\x6c\x21\x8e\x5a\x56\xc2\xda\xfd\x0f\x52\xc1\xcd\x16\xf7\xe5\xee\x7f\xd8\xa4\xec\xc9\x5d\x0b\x81\x04\x9c\xb9\xf9\x01\x03\xc2\xe6\xdd\x0a\xa1\x61\x6e\x21\x6c\x5c\xec\x93\x16\xcb\x49\x9d\xc3\xe1\xd5\x8b\xa2\xcd\x6b\xf3\xf9\x09\x3f\xe7\xaf\xf6\x53\x36\x0a\xfe\xa3\x86\x89\xcb\xbb\x61\xd4\xd3\x93\x06\xab\x55\x03\xc3\xcd\xd7\x0f\x3e\x83\x71\xa3\x5e\x78\x9b\x05\x82\xcb\x76\xfe\xbe\x0c\xfe\xf6\x92\x30\xb7\x5f\x0e\x69\x9b\xc1\x20\xc5\xf7\x3b\xa8\x33\x82\x2d\xf0\xfd\x6e\x1c\x3b\xab\x64\xa7\x48\x5b\x5c\xb4\xcb\xeb\x13\x1d\x0e\x18\x0b\x1c\x1c\x61\x84\x0e\x14\xc5\xce\x64\xbe\x29\x67\x83\x67\x6e\xce\xac\x4e\xbd\x7c\x2b\xda\x50\x9f\x0a\xf1\x76\x1a\xdc\x36\xe3\x99\x3e\xba\x39\x54\xb4\x77\x10\x06\xce\x47\x0e\x8d\xba\x5b\xe9\xc7\x8f\x83\x4f\x94\xf3\x76\x97\xe3\xb3\x3b\x3c\xd1\x9f\xbe\xf2\xce\x1b\x8d\x37\xff\x21\xa6\x98\x7e\xab\xa8\xfe\xa5\x8d\x70\xd1\x4e\x6a\x27\x61\x82\x8f\x8b\xc9\x82\xcd\x60\x27\x0d\xa4\xd3\xc5\xf0\xc3\x69\x86\x30\x0f\xa7\x09\x02\xb9\x93\xaa\x82\x68\x19\xca\x1e\xd7\x73\x66\x82\x37\x24\x84\x2c\x01\x7f\x52\x3e\xfd\xd3\xbf\xfe\xfe\xd9\x3b\x2f\x7e\xe7\x97\x1f\x7e\xf7\x25\x6a\x27\x42\x77\x7d\xf7\xfd\x9f\xbd\x77\x66\xf7\x75\xfb\xc7\xb6\xee\x3b\xb0\x57\x5d\xc7\x49\x44\x33\x2d\x52\xbb\x10\x96\xa8\x2c\xb0\x26\x91\x26\xdc\x22\x0c\x2d\x0e\xfd\x70\x1a\x16\x2d\x2c\x51\x95\xaa\xca\x3e\x30\x85\x9d\x49\x31\x3e\xa9\xa1\xe5\x0a\x41\x20\xe1\x96\x8c\x80\x3d\x9a\x9e\x22\xf3\x53\x02\xe5\xb7\x5f\x9c\x8f\xf5\x4e\xcc\x1d\xa6\x7e\x04\xa8\x7f\x7c\x7e\xcb\x19\x35\x37\x03\x84\x40\x0f\x53\x07\x60\xb5\xe1\x21\x22\xc4\x2c\xb9\xca\xe1\x97\x02\x74\xc8\xe5\x32\x86\x04\x8e\x30\xe9\xa1\x55\x30\xb6\x68\x91\x14\x70\xf8\x69\xaf\x68\xf1\x42\x29\x70\x7a\x13\x4d\x1a\x2d\xa4\x38\x9c\x16\xd0\xc9\x4e\x24\x13\xf5\xd0\x9b\x40\x38\xf3\xa1\x17\x60\x58\x86\xdf\x21\xc5\x3a\x75\x2b\x38\x5e\xe7\xc4\x6b\x03\xf3\xf3\xe2\x64\x03\x40\xf4\x8b\x11\x3d\xda\x33\x89\x51\xf7\xee\xba\x40\xfc\xe9\x5f\xf2\x35\x8f\xed\xf9\x1b\xf8\x53\xf3\x8e\xf1\x37\xee\x9d\x3f\xfe\xec\xc8\x77\x7e\x79\x7c\x21\xd9\xd9\xf7\xd2\x2d\x5b\xdf\x79\xff\xc4\xb2\x91\x95\x3b\xc6\x94\xde\x5b\x96\xcc\x5e\xf3\x5d\x3f\x38\xd1\xb6\x73\xff\x18\x38\x1f\x54\x56\xb7\x6c\xc6\xc2\xc4\x38\xbf\xcc\x1e\xa8\x47\x3e\x98\x65\x56\xa3\xfb\x61\x2b\xe3\x44\x05\xe1\x0d\x09\x5e\xa1\x26\xe9\x2f\x73\x97\x0d\xa4\x7d\x95\xf0\xaf\xcf\xec\x94\xdc\x0e\x36\x0a\x43\x20\x67\x35\x9b\xe9\xc1\x2c\x20\xab\xba\x33\x9a\xca\x02\x98\xe5\x0f\xf6\xab\x09\x77\xac\x20\xdf\xd6\x4e\x5d\xa0\x81\xe5\x3a\x90\x09\x7b\x7e\x18\x14\xc3\x5a\x8e\xbd\xf6\xfa\xc3\xa9\x1b\xcb\xab\xee\x99\xf9\xde\x92\x2b\x7f\xfc\xc2\x8b\x2f\xfd\xe0\x87\x57\x2e\x7e\x49\x39\x4d\x3d\xb6\x6e\xc9\x15\x6b\x37\xae\x22\x57\x2b\xae\xd1\x65\xca\x2d\xc3\xe0\x1d\xe1\x87\xdf\xc4\x99\xf5\xfe\xfd\xe3\x7f\xf9\xd3\xbf\xae\xbf\x1e\x9c\x1a\x52\x96\x3e\xf3\x8b\x5f\x3e\xff\xc3\x77\xbc\x3f\x38\x77\xfa\x81\x6f\xdf\x89\x75\xb4\x01\xdd\x6d\x02\x79\x8c\x12\x09\x62\xbb\xdc\x5d\xc6\xea\x7c\x46\x5f\x88\x12\xa4\x58\x8c\x22\x5c\x12\xcd\x1a\x59\x63\x45\xa5\x4e\x10\x02\x25\x81\x92\x81\xb4\xcb\x0d\xff\xba\x08\x36\xd0\x1f\x58\x1c\x38\x1a\xb8\x3b\xf0\xad\x80\xce\x40\x05\x02\x16\xc2\x52\x34\x00\xfd\x1a\x01\x85\x40\x70\x13\xd1\x8b\x55\xf6\xf3\x11\x35\x9d\x4d\x6a\x7f\x21\x89\xbf\xaa\x71\x5f\x83\x3d\xc9\xec\xee\xe0\xfe\x61\x83\x13\xf5\x13\xd1\x69\xc6\x58\x9c\x82\x5f\xa3\x11\xb8\xc8\xe0\xad\xd3\x77\x2d\x1a\x5e\x39\xf6\x83\x17\x5e\xf8\xfe\xd8\xb2\x59\xf3\xee\xbb\x1f\x0c\x75\x3f\xf6\x58\xf7\x90\xe3\x9d\x77\xde\x59\x4b\xbd\x6c\xde\xb4\xad\x6f\x4b\xc8\xb5\x63\xd6\x8d\x47\x6f\xbe\x69\xe1\x56\xbb\x6f\x6d\xcf\xf2\xa5\xe6\x41\x5b\x57\xe3\x23\xcf\xf5\xce\x62\xcf\xff\xf0\xfb\x67\xcf\xae\x5c\xa4\xcd\x9a\x83\x77\x30\x96\xb3\x15\x5a\x28\x0f\x08\x42\x6f\x30\xd8\x58\x90\x07\xab\x4b\xb8\xb8\x97\x92\x79\xd1\x1e\x44\x55\x5b\x89\xaa\x20\x7b\x4f\x40\xfb\x3b\xb0\xf9\x0c\xc2\x59\x06\xef\xbc\xf7\xbd\xef\xfe\xea\xd3\xf3\xff\xc8\xcc\xb0\x3f\x01\xde\x21\x2c\x30\xae\x8b\x16\x82\xd0\x31\x8c\xd5\x46\x10\x16\x86\x24\x8d\x59\x80\x67\xf8\xc9\x4d\x55\xf9\x9f\x8d\xc1\x9c\x53\xaa\xd5\xab\x00\xce\x67\x90\x69\x83\x77\x14\xfb\xf8\x9f\x7e\xfd\xcc\x4b\xef\x12\x1a\xae\x3d\xb5\x12\xfa\x6a\x03\xb4\x31\x84\x89\xe4\x76\x5b\x68\xbb\xc5\xee\xf5\x11\x2e\x84\x12\x6c\x52\x71\x12\xd1\x1d\x5d\xac\x1b\xe3\x24\x9a\xa4\xff\x01\x13\x29\x93\x6b\x89\x1a\x2e\x81\xba\x2b\x89\xd0\x13\x41\xef\xb2\x5b\xb6\x6c\x3d\xb6\xec\x0e\xa5\x63\xd7\x2e\x70\xf2\xce\xef\xcc\xfe\x8f\x5f\x6e\xbd\x03\xfc\x79\x70\xf1\x92\xf9\xe7\x1f\x50\xd3\xc5\x86\xcd\xcb\xaf\xbd\x46\x79\xc8\x8d\x68\xd3\x41\xda\x0e\x43\xda\xec\xd0\x6a\x16\xc8\xd5\x04\x45\xb9\xed\xb4\x4f\x10\x68\xbd\x55\x6f\xf5\x07\x68\xbb\xd7\x3e\x90\xf6\x7a\x39\x23\x4c\xd1\x05\x0e\x96\x31\x9c\x64\x74\x0c\xa4\xd1\xad\x26\x46\x16\x05\xec\xcc\x59\x25\x42\x85\x29\x29\xb8\x42\x41\x4b\x32\x54\x6c\x79\x98\x96\xa3\x1e\x33\x57\x0a\xb2\x51\x24\x2a\x62\x2f\xd6\x0c\x7e\xff\xe1\xe0\x2f\x96\xae\x07\x37\x83\xdb\x77\xed\x52\xae\xd8\x71\xeb\xad\xcb\xb7\xaf\x7f\x6f\xac\xc2\x09\xd6\x39\x0f\x8c\x12\x17\xb4\x20\xe2\x81\xc1\xf2\x87\xf3\xd3\x2f\x4d\xa4\x7b\xb6\x5c\x69\xd2\xeb\x5d\x66\x9d\xc5\xe7\xd3\x51\x22\x25\xfa\x03\x7a\x41\xcd\x0a\xcd\x90\x56\x9d\xd9\x0c\x60\x76\xc8\x02\x2f\x4c\x33\xc4\x4c\x9a\xa1\xed\x5c\xa8\xb5\x05\x7f\x29\x8a\x4b\x01\x9e\x2b\xa7\x60\xc6\x26\xa6\xb2\x90\xa7\x58\xa3\x9b\x01\x75\x58\x59\xa9\x6c\x5a\xbf\xf4\x17\x83\x1f\xfe\xfe\xd6\x1d\xe0\x2e\x48\xf7\x07\x63\xef\xc1\x6a\x91\xb8\x30\x7a\x00\xd1\x5d\xa1\xac\x01\x33\x3c\x6a\xfc\x03\x77\xbc\x94\x9e\xaf\xea\x6f\x00\xd2\xbd\x04\xe7\x8f\x0d\xb2\x4f\x6f\x01\x16\x81\xb2\x4b\xa4\x20\x88\x3a\x9b\x68\x1b\x48\x8b\xac\x7e\xa2\x06\x68\x59\x46\xee\x44\x83\x36\xab\xaf\x89\x10\xcf\xef\x53\x4b\xd0\x84\x7e\xec\x3a\x65\xca\x2d\xc5\x78\x62\xff\x11\x7c\xcd\xfc\x27\x18\x71\x02\x5f\x3b\x4f\xe0\xf3\x23\x1f\xe3\x7c\xd2\x45\xa4\x64\xb7\x4d\x2f\x02\x3d\x70\x7b\xec\x56\x02\x27\x65\x0e\x13\x4b\x73\x83\x59\x7c\x86\x89\x17\x8d\x65\x06\xbd\x73\x48\xb0\x59\x14\x2b\xea\x9e\xe7\x9e\x7a\xee\xd9\x2d\xe0\x96\xb1\xff\xda\x77\x60\x27\x18\xa4\x96\x8f\xbf\xf7\x8d\x6f\x7c\xf3\x0e\xb2\x16\xe7\x01\x6f\x7f\xba\xe3\x6a\x32\x91\xc3\x62\xf8\x35\xf5\x5b\xea\x01\x18\x61\x93\xb2\xcb\xe0\xa0\xad\x56\x0b\xc9\x39\x38\xa7\x4b\x74\x0c\xa5\x45\x2b\x63\x60\x86\xd2\x06\xa2\x4a\x4b\xde\x33\x81\x2f\xa3\xf7\x68\x9f\x3d\xac\x8f\xf2\x61\x58\x1d\x61\xe7\x53\x0a\xe0\x3b\xf2\xe5\x47\x82\xe3\x6e\x77\x05\x4a\x3c\xfa\xe2\x4d\xca\xc7\xe3\xa7\xdc\x15\x80\xb8\x67\xe7\x9a\x9b\x41\x6a\xab\xf2\x47\x43\xcf\x77\xda\xff\xbc\x0d\x20\xd1\x13\x75\x17\x7e\xcd\x84\xf1\xf3\x23\x44\x25\xd1\x2f\xc7\x3c\xb1\x58\x48\xa3\xc3\x91\xe0\x12\x5c\x55\xb5\xdf\x19\x2d\x75\x96\x1a\xc4\xcb\x50\x44\x68\x76\x98\x6d\x37\xe4\xa9\xcc\x65\x08\xa4\x92\xb9\x8d\x30\x31\xef\x35\x0d\x2e\x41\xf8\x0f\x27\x60\x50\x5e\x82\x11\xf0\xbd\x8b\xd1\x2d\x31\xa6\xe3\xdb\xd4\xef\xe9\x97\x89\x24\xcc\xb9\xe3\xe5\x41\x36\x26\x49\xc6\x12\xe8\xca\x74\x14\x0c\x0a\xa9\x5a\x8f\x3f\xe2\x1f\x4a\x47\x22\x95\xd6\xd2\xca\xa1\x34\x51\x6a\x15\x86\xd2\x56\x35\xa5\x49\xe5\xe1\x7c\xe5\x92\x8d\xcc\x9f\x89\xfe\x3e\xac\x8f\xf3\x41\x10\xc6\x47\xd6\xe3\xea\xdb\x94\x33\x8c\x07\x93\x11\xef\xf0\x35\xe4\x9e\x3a\x58\x5d\x57\xdb\x54\xde\x71\xd3\x0d\xe3\x27\x71\x02\x38\xe7\x51\x83\xc9\x4a\xd7\x4f\x1e\xff\x0a\x7e\x3b\x77\x38\xed\x47\xbc\xab\x2e\x89\xfa\xc6\x9c\xfb\x27\x75\x6d\xf6\xcf\xf8\x49\xe7\x96\xed\xd7\x00\xf0\x4d\x70\xd3\x3d\x9e\xae\xae\x76\x89\x3f\x02\xc0\xbf\xdf\x38\x6b\x56\xfa\xda\x23\xe0\x1b\x5b\xb7\x2a\x9f\xa0\xd9\x3b\xa8\xc7\x04\x9e\xe9\x4f\x5f\x3c\xe3\x0f\xdf\x37\xc0\x85\x1e\xc1\xef\x17\x12\xb9\x5a\xf8\x11\xe8\x29\x66\xca\x25\x4e\x8b\xcd\xe1\xb0\x88\x14\x65\xf4\x50\x1e\x7f\xc0\xea\x74\xa2\x0b\x9a\x9c\x76\xc2\x61\xb3\x23\x03\xb4\xb3\x84\xae\x00\x78\xe2\xa2\x9b\x61\x32\x77\xe0\xaa\x37\xc3\x64\x0a\xdf\xe8\x84\x5b\x61\x74\xa0\x53\xab\x76\x4f\xec\x04\x60\xe9\xed\x2b\xcb\x1b\xc8\x1b\x94\xcf\xb6\x9d\xf8\xb9\x5d\x2d\x72\x17\xac\xab\x03\x3d\x0e\x68\x9a\x75\xca\xc3\xfc\x89\x55\x37\xdd\x8e\x69\x6d\x85\xb4\x7e\x0a\xe3\x5b\x9c\x98\x2c\x87\x03\x3c\xe5\x61\x8a\x4d\x4e\x27\x43\x51\x25\xa5\x01\x13\xc1\xdb\xed\xd6\x81\xb4\x9d\x83\x11\x25\x3c\x90\xd7\x51\xd2\xc0\xbd\x34\x1f\x91\x59\x34\x06\x67\x5d\x59\xc0\xab\x5c\x39\xae\x97\xf4\xb6\xbc\x2e\x21\x78\xef\xbb\x6f\x7d\x91\x9a\x7b\xc5\x86\xf5\xcb\xa6\x47\x3b\x6e\x3e\x8c\xde\xa5\x97\xac\xb9\x1a\xbf\xb3\xef\x58\xff\x6c\x70\x23\x63\xec\x1f\x1e\xec\xab\x79\x40\x29\xcf\xbe\xed\x9f\x89\xde\x22\x9a\xd1\x5d\x67\x7f\xc5\x3d\xd0\x26\xd9\xeb\xf4\x5b\x4a\x2c\x25\xe5\x89\x10\x63\xb7\x1b\x3d\x5c\x11\x87\xb0\x5f\xe2\x16\x0b\x61\x74\x10\xd9\x7b\xf3\xf0\x01\x83\xbc\x62\x14\xd1\x0a\x75\x49\x9f\x57\x20\xb7\x81\x06\x6d\x47\x12\xf7\x0f\x70\x8e\x8f\xa9\xa5\x16\xb5\xf4\xb4\xd5\x4d\x2b\xaf\xdd\xb1\x7c\x8e\x5c\x15\x0f\x25\xea\x7b\x3b\xea\x76\x2c\xb9\x6b\xf7\xf6\xfb\x16\xef\x71\xd6\x5c\xd9\x97\x08\xc5\xab\x64\x3b\x17\xa9\x59\xd6\x3c\xb5\x53\x7c\x65\xbd\xdd\xd3\x3c\x78\xe8\x95\x05\x07\x4e\x7f\xfd\xe0\x82\x97\x8e\x84\x7a\xdb\xec\xeb\x5f\x11\x33\x7d\x1d\x84\x81\xca\x42\x5f\x1c\x80\x51\x82\xe0\x78\x82\x07\x1c\x65\x83\x1a\x61\x63\xa0\x7c\x6d\xac\xce\x6c\x34\xc3\x48\x97\x43\x8a\x2e\x2f\xcf\x55\x48\x59\x54\xd3\x2c\x3e\x90\x06\x5f\x7a\x4a\x99\x92\x85\x2b\xfe\x24\xa3\xe2\x2a\x06\x21\x1a\x14\x27\xa8\xe7\x05\x1d\x39\xb3\xa0\x8e\x13\x89\x2e\xb9\xd8\x26\x9a\x75\xa2\xce\x2e\x11\x12\x27\x55\x4b\xb0\x86\xb3\xc1\xf7\x3c\x0c\x59\x46\x5e\xb2\x16\xf6\x17\x72\x35\x5b\x7e\xc5\x96\xad\xd6\x54\x8a\xc2\x99\x32\x9e\xfa\xec\xa2\xfa\x4c\x2d\xcb\x28\x8d\x40\x4c\x9b\x96\xa7\x08\x3a\xa6\x11\xd3\x06\x63\x2c\x5d\x87\xfb\xfc\x0b\xe4\x4a\x9b\xd1\xc8\x78\x43\x21\x17\x41\xf0\x0c\x53\x54\x1c\xd5\xf1\xba\xfe\xb4\x8b\xe7\x29\x4b\xd0\x29\x98\x2c\xa6\xfe\xb4\xcf\x6e\x61\x89\x09\x77\xf5\xa6\x2e\x42\x5a\xca\xa6\x4f\xd9\x02\xb3\x58\x25\x16\x8d\x5e\xc3\xb5\xe7\xed\x0e\xa7\x16\x62\xd0\xbc\x45\x4a\xd2\xe3\xf6\xd1\x86\x4d\xca\xd5\x63\xcf\x3d\x92\x56\x16\x5e\x35\x06\x8e\x6c\x5a\xb5\x68\x7c\xee\xb7\x9e\xc5\xd0\xbd\x40\xa2\x8f\x7d\xf5\x03\x4f\x42\x79\x77\xf5\x06\x06\xbc\x88\x4b\xfd\x36\x66\xdd\x5a\x10\x4f\x78\x3e\xb8\xe3\x28\x45\x64\xb0\xbf\x30\xee\x49\x00\xfa\xfc\x72\x9e\x66\x4d\x26\xda\x43\x05\x43\x6c\x08\x18\x29\x13\xbe\xe8\xd1\x6a\xf5\x38\x1c\xc4\x60\xda\x21\x19\x69\x1d\xdd\x9f\xd6\xf1\x30\x75\x98\xd0\xb9\x53\xdd\x80\x2a\xf1\x8c\x13\x68\xc8\xbb\x5c\x58\x0d\xc9\x05\x08\x28\xb7\x64\x90\xbc\x90\xe8\x0b\x91\x4f\x66\xe7\xdd\x2c\xac\x2e\x46\x3e\xea\x89\x3a\x3f\x7c\x81\x4c\x52\x4b\x98\x85\x78\x3f\x68\xb6\xec\xc5\x5b\x41\xb4\x8e\xb1\x0a\x16\xce\xa2\xd7\x73\x34\x25\xda\x05\x1b\xda\x0d\x62\xce\x81\x6a\xd9\xa4\xb7\x58\x58\x9a\x26\x4d\x26\xf2\x1c\x68\x43\x53\x66\xda\x0e\x89\x06\x12\x9a\xd9\x34\xc9\x00\xcb\xa9\x87\x57\x2e\xb1\x1d\x64\x50\xfe\x3e\x1f\x08\x9b\x80\x7f\xb9\xf2\xc8\x9a\x01\xe5\xa5\xc1\x4f\x6e\x00\x2e\x72\x28\x14\xe2\xc8\x7f\x8d\x33\x1c\xfc\xfe\xbb\xdf\x91\x0f\x2a\xd7\x60\x1a\xc7\x21\x8d\xff\x60\xe6\xe0\xfd\xa0\xf5\x72\x39\xda\x0f\xa2\x8d\xc5\xc0\x69\xc3\x1b\x42\x61\x1b\x30\xd2\xf1\x12\x2a\xe6\xc5\x5b\x3e\x7b\xec\x78\xcb\x27\x5a\x2c\xda\x4c\x96\x73\xa0\x4a\x36\x85\xa3\x51\x3d\x80\xbf\x61\xd4\xab\x34\xab\x7a\x51\x85\xee\xca\x43\x95\x58\x53\x55\xd5\xc2\xbc\x04\x28\xa5\x82\x74\x65\x89\x57\xf7\x7b\xa2\x13\xf7\x7b\xa4\x6c\xf3\x54\x8f\xf7\x7b\x4e\xcf\xff\xfb\xae\xc5\x9f\x0e\x81\x03\x57\x92\xb3\xe2\x62\xd3\x0d\x43\x0f\x0b\xb1\x98\xf0\xf0\xda\x3b\xaa\xa3\x71\xf3\xf8\x33\xf3\xdf\x23\x87\x20\x4b\x88\x31\xf2\x15\x73\xe8\x85\x6b\x8d\xca\xcb\xa3\x7f\x5f\xa2\x9c\x33\xdd\xf6\x16\x98\x09\x4e\x28\xab\x61\xee\x90\x20\x2b\x29\x00\xf9\x34\xc0\x8a\xa9\x88\x98\x2e\x07\xfc\x1e\xc6\x66\x13\x8d\xa1\x90\x47\xa4\x8a\x63\x7e\xab\x75\x31\xb3\x9e\xd9\x03\x4d\x80\xe1\xed\xb4\x03\x32\x77\x86\x8d\x46\x45\x5e\x65\x4b\xe5\x08\x2e\xc3\xc2\x54\xc1\xe9\x2a\xdc\x46\xcd\x20\x87\x8b\xf8\x85\x33\xc9\x68\x79\xbd\x23\x17\x75\x8b\xc9\xde\xf4\xea\x5d\x07\xae\x98\xdf\xb2\x7e\xf7\xb1\xc7\x7f\x34\x7e\x7a\xe5\x4a\xb0\xe1\xf6\xa3\x0b\xa7\xae\xda\x7e\xf7\x1d\xca\x05\xfa\xb6\xee\x1e\xe5\x27\x7d\xca\xcf\x47\xfa\x95\xc7\xe8\x24\xe4\xe3\x65\x2e\x94\x5e\xda\x37\xca\x99\x96\xcd\xba\xfa\x1a\xe8\x74\x88\x00\xa4\xdf\x06\xe9\x77\x13\x61\xe8\xab\xd3\x72\x31\xe1\xb4\xc7\x83\x41\xab\x31\x62\x47\x77\xa0\x1a\xa9\xf2\x44\x80\x30\x9b\xe3\x4e\xd4\xce\xde\x83\xda\xd9\xfa\x98\x8d\x43\x6c\x84\x18\x26\xb3\x3a\x79\x6c\xa8\x56\x9c\xe3\x24\x7b\x1a\xca\x31\xa1\x0f\xaf\xf1\x01\x6d\x59\x63\x8f\xca\xf0\x4b\xde\x7d\x05\x22\xfe\xd4\xca\x2d\x5b\x30\x37\xad\xa9\x67\x6e\xc0\xec\xb5\x20\x5e\x97\x2c\xa0\xbe\x53\xbf\x0a\x12\x1f\xe2\xc0\xdc\x7a\xd0\x80\x18\x6a\x9d\xed\xac\xbf\x1f\xf3\x48\x56\x23\x8e\x67\xa8\xbd\x9b\x32\xb2\x9a\x9a\x01\x79\x43\x7b\x1f\x55\xb2\x39\xb3\xf7\x21\xd1\x4e\x48\xff\x53\x7a\x8e\xb3\x33\x82\xc6\x80\xca\xc1\xa5\xb7\x3c\x92\x8e\xbc\x2d\x0f\xf2\xf5\x27\x1f\x59\xd3\x7b\xe5\xed\xd7\x2b\x3f\xfc\xc5\xff\x7b\xe5\x4d\xe5\xd7\x2b\x57\xae\xa4\x5e\x79\xe8\xf1\xf1\xa9\xf4\x93\x64\xdb\xf7\x7f\xf8\xf2\x5b\xa4\x2a\x66\x74\xbe\x84\x4c\x92\xff\x06\x9f\xef\x25\xa6\xc8\x5e\x56\x67\xb1\xdb\x81\x5b\x07\x28\x9f\x5f\xcc\x0a\x93\x76\xdb\x81\x17\xd2\xf0\xa4\x59\x47\xd2\x90\x2a\x4c\x8b\xb6\xd3\xb7\x30\x27\x47\xa4\x0f\x62\x03\x7f\x59\x6d\x2e\x5f\xb9\x92\x5c\x50\x22\x36\x1d\x3e\xf0\x9e\x10\x8f\x0b\xef\xdd\x7d\x67\x55\x04\xaa\xf0\x2e\xa8\xc0\x88\x96\x02\xd5\x55\x7d\x5f\x2b\xa4\xed\x55\x4c\x9b\x2c\x7b\x58\xbd\xde\xe3\xb1\x48\x24\xed\xf3\x1b\x17\xdb\xd6\xdb\xf6\xc0\x28\x63\x03\x6e\x89\x43\xfa\xfa\xa4\x47\x4f\x82\x8c\x98\x2e\x26\x0d\x8a\x2a\x1c\x87\xd1\x19\x01\xf2\xea\xe1\xd2\x3a\x53\x6a\xfd\xa1\x3a\x3f\xf2\xd5\xf1\x5d\xe6\x78\xa4\xfa\x8e\xbb\x55\xc2\x0e\x1c\x4d\x89\x25\xe4\x02\x48\x6e\xf2\x67\x27\x4c\xa0\x77\xc9\xdf\x47\x41\xb3\x61\xff\x0b\x21\x76\x7c\x12\x87\xb1\xba\xc9\x18\xd5\xc7\x8c\x12\x7e\xa2\x4e\x16\x78\xc6\x65\xf2\x33\xfe\x40\xd0\xef\x72\x79\x3c\xa4\xcd\xa4\x7f\x06\x54\xc3\xf2\x8e\x04\xed\xea\xbd\x99\x02\x9e\x8e\x2f\x80\x8a\x53\x31\x59\xc3\x18\xf2\x2b\xb7\x79\xd6\xa0\x76\x2a\xc9\xf1\xfb\x8e\xbd\xf4\x1e\xb8\xf7\xc4\xc1\x12\x6e\xde\xfe\xaf\x1e\x3d\x7e\xb4\x7a\x5d\x70\x05\x28\xed\x27\x17\xd4\xff\xec\x79\xf0\x60\xd1\xa3\x57\xb6\x3d\xf5\xdc\xb7\xcf\xb9\xf8\xdf\xb2\xe1\x30\x3a\x0f\x56\x06\xfd\xd8\x3c\x2c\xa7\xa9\xb2\xd3\xe8\x76\x93\x26\x87\x83\x27\x79\x9f\xdf\x05\x63\x1f\x1a\xed\xa3\xac\xd0\xcb\x56\x9d\x45\xf7\xad\x91\x76\x02\xcb\x09\xe5\xfd\x58\x54\xb8\x4a\x69\xaa\x4a\x15\x5c\x8f\x8d\xee\x1f\x99\x08\x1c\x98\x0b\xcd\x65\xd0\x82\xa7\xac\x04\x3b\x56\x80\xc9\x2b\x56\x28\xcf\xad\x50\x0e\x42\x51\xa9\x1a\x15\xe2\x94\x97\x40\x0b\xfa\x3e\xde\x8c\xbe\x82\x61\xe5\xd1\x8c\x9e\x81\xb5\x90\x46\x33\x11\x97\x8d\x04\xc3\x58\xac\x66\x9d\xce\x80\x96\x0e\xbe\xa1\x32\x0e\xb4\x5d\x93\x14\x96\x52\xfe\xdd\x03\xba\x15\xca\xb3\xf0\xa9\x1d\x2b\xc8\x2b\xb0\xaf\xc3\x8f\xc2\x33\x9d\x64\x0c\xbc\x0c\x3f\x57\x24\x8a\x65\xa3\x55\x27\x8a\x76\x89\xb7\x9a\xce\x81\xf6\x27\x60\xde\xa1\x2a\x6b\x52\xb3\x1a\x9c\x5b\x8a\x97\xd8\xd2\xf8\xfb\x0a\x50\x37\xbf\x61\x71\xeb\xb4\x64\x5c\x70\x36\x8e\x30\x71\xcc\x87\x2d\xbd\x45\x16\x6e\x1d\xf6\x6f\x52\xcf\x61\x41\x19\x5f\x8d\x7d\xd0\xa8\x1c\x72\x98\x4c\x06\xca\x49\xea\x29\x92\xa5\x59\xda\xe3\x25\x9d\x4e\x89\xe3\x04\xa3\xc3\x40\x39\x28\xab\x5b\x40\xe1\xc1\x48\x9b\x50\x83\x44\xaf\xb7\xe6\x45\x34\x35\xa0\x65\xc5\x9c\xba\x08\xf2\x5a\x45\x12\x2c\xdc\xcd\xc8\xdd\x90\x4a\xd5\x2e\x54\x3e\x01\x73\xe7\xbc\xac\xbc\xbc\x76\xb3\xf2\xb8\xba\x0c\xd7\x0e\x30\x73\x20\xb9\x9f\x29\xbd\x5c\x08\x9c\x9c\xa3\xfc\x39\x27\x20\xe5\x20\xd8\x01\xa5\x8f\xe8\xaf\x83\xb6\xf4\x34\xa4\x9f\x25\x4a\x65\x13\x69\x36\xeb\x39\x1e\x58\x2c\x36\xb4\x00\x66\x3d\x69\xcc\xd9\x4e\x56\x55\x31\xc4\x9b\x66\xbb\x2a\x11\xe0\xc8\xae\xbb\xaf\xab\x2f\x86\x46\x7b\x18\x3e\x7a\x2e\xd3\xc0\x8d\xb7\x5b\xbe\xfe\x51\xd6\x97\x94\x92\x49\x3a\x0e\x9f\xe1\x22\x46\x64\x97\x85\xa2\x00\x61\xb5\x39\x9d\x56\x83\x60\x10\xdc\x1e\x17\x49\xf2\x46\xa3\xcd\x8c\x64\x63\x76\x0a\x94\xc1\xa0\xb3\x02\x20\xe9\xb4\x27\x6b\x02\xd1\x34\x72\x42\x5f\x23\x73\x3b\x75\x2e\x63\x4d\x19\x61\x4a\x9d\x91\x0f\x69\x96\x94\xf7\xd6\x28\x9f\xac\x5c\xf9\x39\xd0\x01\xff\x47\x2b\x57\x2a\xff\xb6\x06\xf2\x7b\x66\x7c\x67\x46\x16\xe3\x77\x92\x4b\x33\x3a\x49\x1e\x80\xb4\x4e\x86\xeb\x79\x0d\xd6\x9b\x2e\x99\x15\x20\x61\x7a\x82\x60\x6c\x8c\x5d\x62\x0d\x30\xee\x55\x3d\x6d\xb4\xd9\x2c\xa2\x5e\x0f\x23\x7d\x5b\x81\x26\x65\x56\x71\xa2\xbd\x68\x99\x54\x3e\x89\x80\x7c\x73\x0d\x10\x56\x4c\x52\x38\x8d\xb6\xbb\x54\xcd\x1a\x37\x93\x6f\x8d\x2f\xc8\x52\xf6\x08\x5e\x9f\x9c\x0d\x0f\xc8\x7c\xbe\x0d\x9b\x39\xce\x69\x45\xcb\x04\xcd\x98\xc1\x79\x87\xd1\xe5\xba\xd8\x92\x93\xaa\xf1\xb4\xe7\x64\x77\x09\x53\xbe\x78\x2f\xe4\x4b\x4d\x79\xfc\x19\xb2\xc2\x95\xb3\x65\x72\xc6\xf8\x9b\x21\xac\x4e\x30\x6e\x45\xa0\x0f\xac\x83\x3e\xd0\x0c\x8b\xb9\x62\xd9\x44\x58\x74\xbc\x85\x77\xba\x28\xfb\x33\xd0\xef\x19\x09\x1b\xf4\x81\xc8\xfb\xe5\x45\x2b\x31\x0f\x23\x46\xcf\x85\xb3\xa0\x20\x07\x0e\xdd\xb4\xef\xda\x1b\xaf\xdf\xbf\x1b\x1c\xfe\xde\x0f\x5e\x79\xfe\xb9\x57\xa8\x97\xbf\xf7\xe8\xe3\xcf\x3d\xf7\xc8\xe9\xef\x81\x3b\xde\x78\xe5\xb5\x9f\xfe\x14\x3d\x8f\x23\x63\xe4\xdd\xcc\x06\xdc\x3f\x1e\x92\x63\x3a\xaa\xac\x8c\xcd\xf4\x8f\xa3\xee\x4c\xff\xd8\xed\x12\x74\x25\x25\x01\x17\xfc\x13\x25\x8a\xe0\xe2\x21\x1f\xfc\x52\x52\xc5\x25\xcb\x9c\x80\x2e\xec\x0b\x6b\xf8\xd1\xff\xa7\xbe\xf0\xf6\x83\xdb\x47\xe7\x2c\xdb\xf6\xd0\xbd\xf7\x3f\xb8\x75\xc5\xd0\xb2\x5d\xfb\x40\x6f\xcb\x43\x0f\xb5\xf6\x44\x5e\x7d\xf5\x47\xcb\x99\x0d\xc6\xd1\xa5\x7d\x57\x09\xe6\x15\xb3\xc7\xae\xd9\xbe\x79\x78\x95\x99\xbd\xb2\x7b\x64\xd8\x58\x6f\x91\x6b\xef\xfe\x56\xc7\x0c\xeb\x78\xe4\xec\xd7\xbf\xbe\x68\x6e\x26\xfe\x27\xc9\x7d\x38\x37\x73\xc1\x6a\x8e\x67\xa0\xd3\x20\x24\x56\x72\x7b\x8c\x0c\x63\xe5\x68\xe4\x4a\x9e\x44\x7e\x24\xe7\x21\xd5\x80\x52\xd0\x56\xcd\x64\x25\x4c\xce\x61\x84\x10\x23\xa4\x69\x74\x55\x73\xfb\xb2\x25\xca\xbf\xf6\x2a\x8f\x8e\xae\x04\x50\x4b\x4f\xde\x40\xaf\x5c\x36\xa2\xec\x9f\x77\x4c\xf9\x3c\xa3\x82\x9f\xec\xda\x93\xa1\x85\x6a\x82\xb4\x48\xb0\xda\x98\x21\x7b\xa0\x4b\xb3\x7a\x01\xd0\xd9\x79\xde\x61\xd5\x59\x83\xc8\xe1\x7a\xbd\xb4\x47\x6f\x44\xa9\x09\x0f\x74\x3a\x3b\x9d\xb5\xde\x4b\x45\x3a\x5e\xcb\x79\x51\x0f\x2e\x4b\x98\x76\xe7\x2e\xf4\x6f\x54\x43\xf6\xde\x19\x66\xbb\xf2\x24\xa4\x6f\xc1\xed\x47\x17\x4c\x7d\x6f\xce\x0b\xbf\xbe\x27\xbd\x71\xc5\xea\x35\xf3\xa8\xe3\xca\x4f\x32\x44\xae\xd8\x30\x3c\x66\x57\x9e\x85\x3e\x6e\xc9\x87\x0b\x66\x2a\xa7\x07\xb5\x99\x79\x28\xbf\xb7\xb0\x1d\xa7\x64\x0e\x7a\x02\xd2\x40\xd9\x25\x8b\xc1\x60\xe4\x28\x0a\xd1\xf9\x24\x34\x14\xcd\x4e\xb4\xf0\x92\xdf\x93\x14\x33\x9d\xc8\x6c\xd2\xe2\x94\x9e\xde\x1b\x3c\x55\xc7\x97\x90\x2f\x95\x72\xad\x5f\xf1\xef\xc1\xe6\xf0\x82\x65\xd7\xbf\xff\xfb\x2e\xf3\xb8\x8c\xfd\x5c\x25\xd4\xfd\x4d\x38\x16\x54\x41\xdf\x61\x25\x18\x2b\xe3\xf1\x0a\x0c\x61\xb5\x92\xec\x33\xd0\x51\x38\x08\x63\x26\xf8\xf3\x13\x7a\x91\x79\xe8\xf9\x05\x57\x53\xd5\x91\xaf\xae\x01\xe2\xca\xbb\x4f\xde\x73\x37\x32\xc5\xb5\x2b\xc7\xae\xd1\xc2\x50\xe8\xd6\xa3\xc7\x0e\x82\x8f\xf1\x6b\xff\xda\x75\xeb\x35\x6c\x97\xbf\x92\x41\x1a\xf9\x2f\x3b\xd1\x28\x0b\x26\x86\xb5\x43\xd7\xe5\x20\x61\x15\x05\x35\x88\xe6\xf5\x28\xf9\xb5\x99\xcd\x08\xb1\x2b\x53\x46\x69\xed\xc8\x3c\x62\xa2\x66\xe8\x52\xb5\x3b\x15\x52\x5a\x2d\x48\x25\x82\x6f\xfc\xbf\x90\xf2\xd7\x6e\x90\xda\xf2\xfc\x3b\xde\x37\xce\xee\x02\xa6\x6e\x32\x48\x96\x8f\xff\x8c\x32\x60\x5f\xf0\x1f\x64\xe5\xf8\x4f\xc9\x06\x1c\x80\x49\x22\x06\xed\xd2\x42\x5f\x4d\x78\xa0\x65\x4e\x91\x85\xa0\x85\x37\x44\xa3\x34\x0d\xdd\x3f\xac\xb5\x0d\x86\x30\x0a\xc5\x67\xbc\x3c\x4f\xa3\x34\xfc\x09\x17\xf2\x59\x2d\xc8\x67\xb5\xa7\x9a\xaa\xb2\xde\x2a\x7b\x20\x0e\x75\x22\x1d\x12\x8f\xf2\x22\x3c\x87\xd2\x06\xda\x01\x32\x3a\xdc\x02\x12\xf5\xaa\x2d\x36\x00\x61\xd1\xac\x9e\x3b\x2c\x9d\xab\x6e\xa9\x99\xbb\x68\xd6\x9c\xf6\x2a\x7b\x64\xe9\xc9\xfe\x81\xa6\xd9\xcd\x3d\xf4\xd5\x33\xfb\x94\xfd\xac\xb7\xb1\xf3\x74\xcb\xb4\x28\x49\xa6\x37\xfa\xba\x77\x48\xca\x7f\x92\xe4\xa4\xc9\xab\xc2\x17\xd3\xeb\x35\x08\x02\x15\xb4\x5a\xdd\x94\x46\x2f\x8c\x4f\x2d\x67\x78\xa8\xe6\x30\x30\x35\x3f\xe1\x44\xf4\xb6\x5f\x86\x5e\xb5\xc1\xa8\x2e\x64\xca\xa9\x1e\x2e\xd7\xb1\x98\x44\xb5\xe1\x83\x1b\x58\xd1\x88\x1e\x84\x16\xcd\xee\xbe\xc3\x1c\x5a\x54\x73\xcb\xf2\x6b\x47\xe6\xb4\x24\xed\x91\xe5\x27\x66\xf6\x37\xcf\x6e\xeb\x24\x63\x33\x66\x80\x5d\x90\xde\x50\xd1\xe9\x91\x11\x8a\x9a\x8b\xe9\x05\x61\x2a\x43\x6f\x1c\xd2\x3b\x44\x8f\xc1\xb8\xed\x21\x3a\x64\x8b\xa4\x47\x58\xb3\xac\x9e\xf5\xfa\xa0\x4b\x68\x3e\xc3\x59\x2c\xa2\x09\x91\xec\xa1\x28\x17\xf3\x1d\x48\x2b\x89\x74\xbd\x3d\x95\x89\x05\xed\xd9\x05\x57\xc5\xab\x4a\x56\x85\x29\x86\x35\x0e\x02\x4b\x8c\x60\x15\x6c\x20\x87\xee\x32\x77\xad\xfe\xe9\xae\x75\xcb\x6b\x96\x2e\x9d\x31\xf9\xfa\x49\x53\x66\x75\x92\x33\xbc\x93\x67\x00\xdf\x6d\x77\x77\x37\x8c\xff\x0d\x50\x6b\xb7\x2b\xe7\xd7\x6f\x6a\x23\x70\x4d\x16\x23\x15\x48\x57\x8c\xa8\x21\x1a\x60\x85\xef\xa8\x2f\x4e\xd8\xed\x44\x5d\x35\xcb\xfa\xea\xf4\xc5\x4c\x63\x93\x33\x99\x0c\x45\xa0\xf4\x64\x63\xa2\x1e\xd6\xce\x31\xa3\x37\x00\xdf\x3d\x15\xa7\x69\xab\xce\x88\xb5\x20\x95\xad\xf0\x9d\x17\xab\x02\xa6\x16\x47\x0b\x3d\xea\xfe\x39\xf1\x11\x7f\xf5\x94\xe0\xc4\x43\x82\xc5\x11\xbd\x23\xef\x8c\x60\xd4\x0e\x16\xf5\xcc\xec\x1c\x9a\x39\x7a\x43\xc3\xac\x2d\xaa\x8e\x20\x99\x2f\xed\x59\x56\x5a\xb7\xe8\xaa\x55\x64\xac\x6b\x06\x07\xd5\x45\x99\x33\x29\xf5\x0e\x35\xa3\x7e\x59\xbf\x10\xa9\x9c\x31\xe3\x74\xcb\xd4\xa2\x8c\xc2\x54\x54\xed\xde\x56\xf3\x5f\xa5\x21\x79\x14\x2b\x8e\x12\x9d\xbf\xe6\x07\xaa\xbf\x0e\x42\xbe\xe7\x30\x87\x08\x13\xb4\xfe\x06\xd9\xc2\xea\x74\x6e\xc2\xee\xb6\x7b\xbc\x06\x27\xd2\x74\x86\xe3\x28\xe1\x19\xc8\x9c\x99\xb0\x82\x44\xc6\x07\xb4\x5f\xe4\xaf\x21\x57\x6a\xe1\x06\x55\x47\xd2\xe3\x13\x90\x88\x1f\xf0\x87\xbe\xa1\xbe\x44\xc5\xf4\x91\x69\xca\x75\x43\x67\xe9\x96\xf9\x7f\xda\x7f\x60\xc3\x7a\x6a\xc1\x9a\x75\x76\x65\xb2\x71\x1f\x79\x2d\xeb\x7d\x65\x6b\x95\xf2\xd1\x6d\xf7\x95\x66\x74\x03\xd2\x22\x12\x3e\x98\xc5\x58\xed\xb4\x99\x70\xb9\x38\x9a\xf3\x07\x38\xf1\x19\xa8\x06\x16\x18\x86\x13\x67\xdc\x46\xa3\x17\x1a\x5f\xcb\x93\x2e\xc2\x41\xaa\x11\x51\x4d\x89\x53\x05\x01\x3a\x5b\x99\xa8\xba\x11\x53\x9b\x5a\x28\x0d\x45\x26\xc7\x43\x8a\xc1\xa3\x5d\xf3\x3e\xda\xbf\xa7\x53\xa6\x17\x7f\xaf\xeb\x2e\xe5\x17\x77\x76\xd5\x25\x7b\xef\x84\x55\x09\x08\x1f\xbf\xc3\xe6\xab\x79\x98\xf5\x9e\xff\x19\xeb\x05\xd2\x6f\x5c\xe0\x59\x13\xa4\xaf\x08\xe6\xe6\x7f\x80\x3a\x22\xc0\xd8\x56\x87\x8e\x09\x13\x56\x87\x5e\xb0\xc2\x64\x10\x86\x18\xc9\x24\xb2\x48\x50\x34\x61\xd2\x9c\x25\x6e\x99\xe4\x47\x0f\x0c\x9d\xa8\x41\x20\xe3\x8a\x09\x9d\x77\x8f\x47\xa4\x54\x6d\xec\xd8\x9c\xb9\x9d\x43\xfe\xd1\x86\x7d\x3b\xff\xf8\xee\xbb\xfb\x3e\x6d\xa0\x66\x9a\xaf\x59\x2e\x44\x78\xff\x8d\x77\x83\xe2\xbf\xd5\xfc\xfd\x07\xab\x17\xa8\xeb\x95\x4f\x43\x4a\xe6\x1d\x7a\x1e\x91\xc1\x5b\xdd\x1e\x87\x20\x60\x12\xda\x31\x09\x2d\x1a\x09\x05\xa1\x35\x4f\x05\xd5\x29\x70\x2e\x1a\x69\x05\xce\x24\x54\x31\x07\xd8\x83\x48\xf0\x2d\xd1\x48\xf8\x4b\x1d\x35\x23\x4b\x82\xf2\x73\x44\xc2\x8a\x51\x74\x9e\x08\x3e\xff\xc7\xf0\xf9\xa5\xd0\x4f\x3b\x8a\x18\xb7\xb9\x94\x0f\x18\xcc\x8c\xae\xac\xdc\x18\x08\xf8\xfd\xa4\x43\xb0\x21\x29\xc4\x0b\xeb\x45\xa1\x60\x56\x2f\x93\x91\xd4\xa9\x67\xfe\x9d\xfa\x2c\x50\xb4\x13\x95\xd8\x91\xb8\xd6\x14\x6f\x00\x3f\x1e\xda\xb5\x6e\xac\x7b\xf2\xfa\xdd\x57\xcd\xeb\x05\xfe\x08\x3b\xc9\xdf\xdc\x31\xed\x90\x28\x46\x36\x94\x26\x86\x7a\x46\x16\xc2\xc5\x9a\x37\x5c\x37\x9d\xa5\xe3\x73\x3b\xfb\x1c\x63\x9d\x46\xb6\xae\x7a\xd0\xad\x6b\xd2\x5b\x9a\xcb\xeb\xdb\x83\x90\xde\x30\xa4\xf7\x4d\x48\x6f\x09\xa4\x57\x62\xfd\x4c\x34\xea\x0f\x9a\x9c\x25\xba\xd2\xb2\xa0\xc9\x64\x36\x7b\xc8\x18\xaa\xad\x9c\x82\x47\xb3\xe0\xf6\x8b\xe9\x15\xb5\x3c\x2f\x8e\x4b\xed\xdc\x99\xba\x78\xa6\x89\x9f\x19\xd3\x09\xcf\x9b\xd3\x33\x94\x28\xbd\xd5\x6e\x3f\x34\xad\xa3\xc5\x3f\x89\x8d\xf8\x41\xef\xbc\xab\x76\xaf\xeb\x9c\x32\xb6\x7e\xe7\x10\xb9\x3f\xd8\x5e\x5f\xde\x6c\xd1\x37\xe9\xdc\x83\xd5\x75\xac\xb1\x73\xcc\x31\x63\x4a\x3a\x46\x73\x33\x92\x43\xf3\xeb\xd5\x73\x20\x71\x50\x4a\x4e\xa6\x1f\xd6\xee\x83\x1b\x95\x13\xa5\x89\x84\xa3\xd9\xa7\x73\xd7\x41\xd7\x54\x14\x66\x3c\x6e\x9f\x5e\xb4\x8a\xd6\xb6\x76\x87\xb1\x34\x19\x2e\xf2\x30\x34\x15\x2c\xa5\x4a\x29\xae\x31\x12\x44\x92\xaf\x22\x38\x50\x99\x91\x3c\x56\x40\x27\x3a\xd6\x38\xf1\x92\x91\xcc\x46\x99\x0a\x19\x1a\x00\xd9\x61\xc9\x4c\xae\xa8\x4d\x29\x39\x1b\x9c\x7a\x07\x55\x5b\x0e\xb4\x35\xa9\xa7\x92\xb9\x53\x2f\xe0\xfc\xd8\xda\xba\x58\x8c\x4c\x84\xbe\x3e\x7f\xee\x9d\xb7\x6e\xda\xde\x94\x08\xa4\x16\x2d\xda\xba\xb6\xa3\xe2\x80\x34\x5c\xe2\x1e\xf9\xb9\x3b\x34\x7d\xc6\x9a\xa5\x3f\xe8\xa8\xaf\xeb\xe8\x68\x6c\xa0\xce\x2c\x59\x6a\xec\x37\x09\xfd\xdd\x8b\x37\x74\x77\x94\xc8\x41\x43\x53\x78\x75\xc5\xb5\x8b\xaf\x60\xa7\x78\xe6\x54\x8e\xbf\xdf\xeb\x98\x1c\x48\x55\x0c\x80\xcd\xd3\xfb\xfa\x7a\x7a\xfa\xfa\xa6\xab\x3a\xaf\x07\x8d\xa0\x9c\x5e\x8e\xcf\x1b\x56\xc8\x30\x33\xe7\xf1\x79\x43\x23\xcc\x96\x51\x1b\x87\xc7\x75\x5f\xb3\x96\x4e\x7e\x3f\x79\xb9\x23\x86\x99\x5a\x21\x7a\x45\xcc\xeb\x89\xc7\x3d\xde\x98\x6e\x09\x28\x1a\x1d\x78\x12\x5c\xe3\x8d\xc5\xbc\xf0\x2f\xf9\x9f\xac\xd7\xcb\x2a\x21\xd6\xab\xee\x09\xc0\x5c\x6c\x33\xf4\x47\x6e\x62\x91\x2c\x10\x1c\x67\x83\x75\xbb\x55\xaf\x93\x0c\x92\xc1\xe3\x75\xb8\xce\x81\x84\xcc\x19\xac\x56\x4e\x92\x44\x96\x80\x05\x97\x9e\x32\x8b\x88\x20\x1d\x00\x54\x8e\xa0\xc2\xfa\xb8\xfd\x92\x27\xff\x1a\x90\xdb\x64\x81\x88\x1b\xa8\x71\xbd\x84\xbf\xa3\x30\xfc\xfe\x47\x93\x7e\xd0\x7d\xef\x8f\x5b\x3f\xaa\xbd\x63\x5a\xcb\x47\xbd\x23\x4f\x53\x1d\xff\xe4\xbc\x5e\xdb\x03\xca\x8b\x36\x48\xea\x67\x83\xf7\x21\x8a\x29\x00\x29\x06\x44\x0d\xcc\x77\x9f\x87\xba\x5e\x41\x2c\x90\x9d\x44\x51\x51\x29\xe3\x76\x07\x38\xb3\x39\x50\x4a\x55\x56\x39\xa2\x51\x86\x28\x4b\x40\xba\x64\x53\x51\xc0\xcd\x99\x4b\x4b\x7d\xb6\x38\x24\xf7\x8c\x18\x0e\x1b\x28\x4d\xfd\x71\x94\xc5\x59\x1e\xce\x80\x93\x85\xf9\x81\x66\x0f\xf8\xd4\x0d\xce\x0f\xb4\x34\xb8\x16\x95\x40\x8e\xbc\x77\x58\xcc\x2a\x07\x3f\x2f\x5b\x55\xb4\x38\x52\xb6\xb7\xf4\xd8\x54\xe5\xc2\xc8\xa8\x63\x85\xd3\x34\xa2\xfc\x75\x78\x79\x57\xdb\xc8\x85\x9e\x9e\x07\xe9\x46\x77\xd1\x64\x57\xe9\x43\xca\x11\xc4\x08\x58\xb9\x82\xd5\x85\xe2\xd9\x37\xbc\xd2\x81\x5f\xfd\x12\xf3\x97\x02\x09\xd2\x0c\xf9\x0b\x13\x3d\x32\xef\x13\x04\xa7\x05\xd6\xb8\x4e\x2a\x12\xe5\x7d\x3e\x16\x2b\xbf\x8b\xf0\x80\xe6\x27\x05\xa7\x13\x29\xc6\x13\x26\x1d\x64\xab\x55\xb5\x6a\x35\x3a\x14\xb2\x93\x51\x7f\xad\x6d\x32\x81\x70\x95\x43\xd2\x3c\x7f\x4e\x69\xa5\x8f\xb3\x07\x7a\xe6\xb4\x34\xf5\x7d\xde\xd9\x79\x2f\x13\xbe\x2a\x7c\x88\xf4\x8e\x6d\x37\x6f\xeb\xe0\xef\x01\x3f\x5c\x2d\x28\xed\x19\x2a\x2b\x1d\xf1\x87\xd4\xb3\x26\x30\x96\x55\x42\x5a\x8d\x50\x67\x61\x3d\xc9\x31\x26\x82\x21\x1c\x4e\xab\x1e\x91\x29\x66\xbd\x63\x7e\xfa\x8a\x0f\xb1\xa0\x42\x32\x1f\x79\x95\xac\x54\xfe\xb1\x77\x1f\x60\xf6\x1e\x58\x33\x6d\x68\x66\x4f\xcf\xcc\xa1\x69\x54\xbf\xf2\xf6\xc9\x5b\x41\xec\xb6\x5b\xf7\x6e\x59\x77\xfd\xf5\x9b\xb6\x23\x5d\x0d\x41\x3f\xf7\x09\x7c\x9e\x83\x88\xcb\x66\x13\xc1\x33\x50\x32\x2e\xd6\x6c\x40\xf1\xc0\x4e\x50\x5a\x3c\x28\xa8\x5f\x21\x7f\xa1\x7c\xd0\x78\x35\x32\x84\x3c\x57\x35\x02\xe1\xc8\xbe\xf4\xdc\xb0\xa7\xaa\xf7\xde\x25\x2b\x66\x75\xd2\x3d\xa2\x57\xf9\x7f\x47\x6e\x17\xbf\xb6\xd4\xf7\xd7\x3d\x6b\xed\xe8\x79\x51\x6a\x26\x99\x80\xcf\xb3\xa0\x09\x1e\x68\x8e\x3a\xbd\xde\x6a\x83\x16\xa0\x65\x42\x85\x47\x7f\xb4\x93\x3f\xb8\x48\x06\xcf\x4f\x1f\x9c\xd9\xb3\x06\x71\x44\xcd\xdc\xb7\x65\xdd\x61\x10\x3f\xa1\xe1\x59\x47\xa1\xcc\x12\xd4\x4c\xf5\x33\x33\x67\x7f\x2c\x8c\x91\xcc\xd4\xbd\x97\x3b\xf2\x43\x26\x90\x90\xd6\xf4\xcc\x1c\xe8\xa3\x66\x2a\xef\x9c\xbc\xe5\xfa\x8d\x5b\xaf\x55\x7d\x47\x05\xd4\x99\x7e\x2c\x97\x20\xd4\x1a\xbb\x8f\x86\xc5\x9f\xd3\xe4\x30\x85\xc2\xbc\xc3\x61\x0f\x58\xad\x7a\x3b\xd4\x91\x33\x5e\x9a\x76\xe3\xa5\x81\xbf\x83\x2d\x57\xb5\x05\xad\x02\x9c\x10\x43\xc5\x8c\x76\x68\xc7\xce\x9c\xea\x21\x4c\x50\xab\x65\x41\x9b\xe5\xbb\x48\xf7\x50\xe5\xea\xad\x7b\xb7\xcb\x93\xa9\x2b\x95\xcf\x7a\xc0\xfa\x93\x3d\x95\x4d\x2d\x27\xe9\x16\xd6\x1b\x96\xbc\xc7\x8f\xde\x72\xa7\xb5\xf3\x76\x9b\xdf\x6f\x03\xe7\x7f\x63\x57\xda\xcc\x19\xfe\xc1\x32\xfa\xbf\x20\xad\x15\xb2\xcd\x64\xb3\xe1\xb3\xba\xb4\xd5\x6a\xd0\x9b\x9e\x81\x44\xa1\xfb\xea\x50\xee\xde\x9e\x7a\x2d\xdb\x56\x54\x57\x12\x5f\x20\x51\x87\x92\x48\x74\xaf\x63\x26\xc5\xf8\x45\x53\xd3\xb4\xe9\xad\xc5\xfb\xf6\x15\xf9\xe3\x15\xc2\x74\x98\x26\xb6\x82\x9b\xbc\xce\xbd\x7b\x93\xca\x9e\x78\x89\x29\x6e\x41\xf7\xfb\xa1\x9c\x6b\x25\xf4\xad\x0e\xa2\x55\x66\x09\x01\x21\x3e\x0b\x46\xa7\x8b\x11\x45\xbd\x84\x12\x72\xf8\x78\x92\x53\x7b\x20\x16\x5c\x1b\xe7\x52\xf1\x82\x1c\x50\xb4\xab\xb7\xf1\xe2\x14\x2b\x8e\x41\xa0\xd0\xbb\x37\x47\xa7\x76\xcc\x3a\xd7\xf3\x00\x13\xd9\x5c\x76\xac\xf7\x11\xf2\xcd\x15\x02\x78\x96\xf5\x8e\xff\x0d\x9a\x8a\x3d\xf6\x10\xd8\x80\x5d\x2d\x9a\x01\x26\xcb\xc9\x34\xbd\x06\xd2\x51\x26\x0b\xf9\xe7\x51\x1c\xa2\x95\x61\x0c\x08\x94\x32\x95\xcd\x65\x26\x9e\x43\xa9\x0b\xc3\xbc\x01\x37\x3b\xa2\xe8\x1d\x78\x64\x85\x80\x1c\x07\x69\x52\x9f\xa2\x1c\x83\xaf\xdf\x2e\xa4\x04\x3d\x33\x41\x46\xa9\x67\x20\xef\x15\xc4\x42\x99\xe7\x4d\x41\xc6\x45\x44\xa3\x65\x65\x2e\x13\x74\x97\x65\x15\xd0\x83\xc8\xa6\x52\xec\x2a\xcd\x31\x2f\xaa\x4e\x64\x73\x58\x14\x0d\xd8\x91\x52\x86\x4c\xe6\x99\xcc\x76\xd0\xb2\x6e\xb3\x70\x2b\x06\x92\x89\x9b\xb3\x19\x99\x64\x0e\xed\x34\xe4\x1f\xe1\xc9\x5d\x64\x1c\xa5\x78\xe8\x31\x47\xc3\xc9\xed\xf1\x63\x53\x01\x31\x32\x6a\x5f\x12\x32\xcd\x02\x16\xec\x31\x09\xe4\x32\xc9\x51\xe8\x32\xbd\x50\x78\x57\xe3\x68\x75\xfb\x0a\xab\x21\x14\xcf\xbe\xe1\x91\x7c\x33\x41\x0c\x5c\xf8\x02\xae\xef\x28\xe4\xd1\x86\xb2\x45\x3d\x69\xb4\x91\x36\x96\xb3\x19\x8d\x7a\x3d\x09\x7d\x29\x52\x2b\x03\x01\x72\xd5\x3d\x3f\xb1\xa4\xce\xdd\x51\x08\x25\x0c\x7a\x13\xbf\x9b\x04\xf4\xf3\x1e\xfc\x5a\xfa\xf5\x7a\xf8\xc1\x0e\xf8\x24\x4e\xd9\x0e\x0e\xc1\xef\x56\x75\x1d\x13\x30\x66\x2e\xa1\xf7\xc1\x04\xb0\x51\x76\x4b\x5e\x53\xcc\x14\x2b\x29\x0d\x08\x82\x8b\xa6\x0d\xae\x30\xcb\x1a\x8a\xcc\x66\xc2\xa0\x56\xf1\x78\x7b\x11\x9a\x98\xd0\xc4\xe7\x1f\x41\x00\x68\xcb\x36\xff\x08\x42\x7d\xc1\x09\x84\xec\x01\x04\x52\xd7\xd6\x13\xf6\x78\x82\xd3\x5a\x93\x25\x3e\xa7\xe8\xad\x99\x54\xd2\xd3\xba\xa8\x6f\xea\x15\x93\xfa\x2a\x5a\x12\x5e\xc1\xe5\x2b\x23\x93\x25\x15\xd1\x68\xa2\xd4\xbc\x7d\x8a\x25\xd6\x36\x63\x47\x53\xff\xb2\x65\xfd\x8d\x5b\x87\xe4\x22\xcb\x94\xed\x66\x3c\xe3\x09\xfd\x43\x98\x39\x0e\x7d\x64\x8c\xe8\x93\x7d\x3e\x82\x90\x0c\x21\x83\x39\x0a\x43\x2a\x60\xe3\x25\xe6\x68\xb4\xa8\x88\x11\x7c\x76\x7b\x40\xf8\x77\x28\x26\x17\xc1\x80\x0a\x28\xb0\x56\x54\x93\x6a\x56\x90\xc9\x17\xb3\xe9\x95\x1a\xd3\xa3\x7c\x96\xe4\x6c\x86\xa8\x79\x42\x5e\xf5\xb6\x71\x98\x85\x9f\x5c\xba\x6d\xf7\xca\x4d\xfd\x1d\x0b\x86\x77\xae\x9f\xd3\x0b\x74\x8d\xad\xfd\x1d\x53\x66\x1d\x1e\x5e\x3a\xbb\x1b\x24\xa8\xe6\x93\x27\xd6\x2e\xe9\x5f\x63\xd3\x49\xab\xe6\x5d\xb3\x3b\x44\xee\xee\x99\xbb\xe3\x80\x62\x73\x3e\x3f\xff\x4a\xba\x8a\x9c\x0f\xe5\x6d\x86\xf4\x73\x70\x7d\xbd\xb0\x22\xe1\x49\xc9\x69\x74\x7a\x39\x2f\xe7\xf3\xbb\x45\x86\x01\x0e\xe8\xda\x9e\xf0\x5a\x81\x9a\x8c\xa4\x0a\x0f\x7b\xa4\xb4\x7b\xd9\x53\x0e\xc1\x99\x52\xe1\x23\xe0\x6b\x74\x78\xd9\x21\xe9\xe3\xb5\x0d\x64\xdc\xbc\xbf\x6c\x7e\x80\x59\x1e\xf5\xb2\x9b\xf5\xb5\x27\xf8\xc5\x3e\xe7\xa1\xc9\xf4\x74\xef\x22\x45\x59\xf3\xd7\xd9\x09\xb7\x9f\xf6\x1a\x62\xa9\x2d\xca\x63\xbb\x8e\xe8\x85\x55\x07\xc1\x89\x9d\x6a\x7d\x42\x9a\x99\x23\xf8\x4e\xf0\x76\xd9\x11\x74\x5b\x7d\x25\x30\x15\x21\x18\xb7\xe8\x16\xcb\x13\xbe\x92\x12\x53\xc4\x81\x52\x6e\x93\x1e\x06\xe7\x8a\x4c\xca\x5d\xb0\x71\x90\x19\xc4\x11\x33\xd7\xc8\x68\xe1\xd0\x59\xd8\xce\xa4\xec\xaa\x18\xab\xa0\x7d\x1d\x59\x39\xdc\x3a\xc7\xe7\x0e\xb7\xd4\xa4\x52\x73\x87\x7a\x77\x6c\xb9\x7a\xff\xa6\x55\x75\x6d\x64\x4f\xef\xf5\xf5\x4d\x2c\x0c\x61\xff\xea\x9a\x21\xee\x98\xec\xaf\x2e\x8d\x74\xf6\x4c\xb9\x76\xe8\xe0\x89\xdd\xbb\xd6\xdf\xea\xab\x9a\xa3\xa4\x17\xac\x79\x6f\xea\xea\x6a\x4b\x68\x17\x8e\x17\x51\x28\xcf\xc3\xf4\x16\x98\xf3\x45\x88\x6e\x59\xb2\x30\x1e\x87\x01\x30\x21\x82\x60\x01\xe3\x88\x16\xf9\x45\xd1\x68\x40\xfd\x89\x10\xcb\xba\x49\xd4\x9f\xd0\x74\x61\x82\x53\x54\x15\x23\x63\x44\xea\x95\x38\x0d\xea\x61\x1f\x67\x4e\x2f\x44\x0c\x4c\xc2\xb7\x01\xb0\xa5\xfd\xc8\xa1\x2b\xb7\x80\xa6\xe4\xc8\x70\x6f\xd7\xa2\x15\x37\x1f\x3c\x5d\x5b\x33\x65\xf6\x10\x48\x9c\x37\x1f\xbd\xfe\xc0\x2d\x52\xb9\xb4\x69\x6c\xeb\x66\x2b\x58\x3f\x6b\xe1\xb1\x23\x87\xee\x36\x83\xd2\xcd\x7b\xf7\x29\xb7\x5a\x71\xec\x17\x20\xcd\x55\x50\x07\xfc\x44\x8b\xec\x64\xf4\x9c\x89\x10\x25\x93\x5e\x72\xeb\xdd\x81\x20\x6f\x74\x51\xb4\x4e\xb4\x22\x4b\x87\x11\x15\xa7\x43\x18\x1a\x15\x13\x8a\xee\x06\x56\x9b\xc6\x88\x4e\x28\x52\x1d\x74\x9f\x42\x03\x85\x55\xc1\x29\xd6\x37\x20\x33\xd3\x8b\x01\xe0\x94\xc0\x9b\x3a\xfb\xcd\x9b\x5a\x56\xdf\xb0\xf8\xb0\xd4\xba\xd6\x22\x6d\xdc\x10\xbd\x2a\x7a\xb3\xf7\x1e\x5b\xc0\x0e\x12\x4c\x14\x4c\xfe\xc5\x0d\x76\xe2\xc2\xd3\x20\x94\x30\x7a\x0d\x09\xe5\x8b\xdf\x0d\x39\xdb\x95\xcf\x1b\x94\x6f\xf9\xed\xb4\x57\x8d\xc5\x9e\x0b\xd3\x41\x1b\x79\x4d\x26\x8f\x47\x59\x03\x8a\xc6\x30\x8f\x87\x31\xb8\xeb\x49\x0b\xcf\xb3\xe7\x40\xef\x25\xf3\xf8\xfc\xfb\xb9\xb3\x1b\x12\xbf\xc9\xe5\xf1\xca\xfb\x30\x8f\x27\x1b\xf0\xdb\x78\x7c\x3c\x9a\xcd\x1a\x31\x0e\x1e\x7c\xee\x69\x70\x33\xb4\xf1\x26\xd9\xc4\xeb\xf5\x16\x0b\x90\x1c\x56\x16\x3d\x13\xbe\x36\xc1\x67\x3e\x05\x09\xa1\x50\x5f\xb5\x1b\xf5\xc6\xb2\x7b\x0f\xf9\x9e\x10\xaa\x21\x4c\x72\x73\xbb\x21\x28\x01\x00\xa7\xdd\xd1\xe0\xb0\x6f\x54\xf9\x6b\x0f\x0c\x2c\xe5\x5b\x22\xe0\xe6\xdb\x3b\x78\xab\x32\x3f\xf3\xf8\xee\x48\x0a\xcf\x24\xb6\x93\xeb\xc1\x1e\x18\xdb\x9a\x2f\x11\x63\xbb\x9e\x80\x11\xf6\x1c\x98\xfa\x84\x91\xb6\xa8\xec\xa7\xda\x53\x97\x88\xb0\xce\x4b\x47\xd8\xf7\x0a\xe3\x9a\xfd\x92\x01\x16\x5c\xf8\x17\xa4\x61\x09\xa4\xc1\x46\xd4\xc8\x5c\x5e\x1c\x20\xf5\x7a\x14\x06\xba\x70\x18\x98\x9a\x6d\xf2\x16\x44\x01\x66\x42\x14\x98\x9a\x17\x05\x5e\xb8\x28\x08\x90\x44\x9d\xd2\x45\x46\xc9\x47\xb0\x4f\xed\xbc\x9c\x4f\x85\x31\x01\xa0\x0e\xdf\x34\xf8\xdc\x1e\x64\x41\xaa\x1f\xfd\xff\xe3\x4b\xbf\x7a\x79\x5f\xaa\x74\xfd\x2f\x7c\xa9\x15\xcd\xb5\x41\x19\x79\x51\xac\xbc\xc8\x97\x3e\x03\xc9\xb4\x42\x62\xbb\x90\x90\xfe\x8f\x9e\xd4\x7a\x09\x4f\x0a\x96\x7e\x99\x27\x45\x72\x8c\x41\x7a\x2a\xc1\xad\x08\xaa\x12\x51\x64\x0a\x06\x3d\x22\xac\x22\x98\xe2\x98\x39\xa2\xd7\xa3\xad\xa9\x1e\x68\xf3\x14\x52\x5a\x35\x55\xcd\x5e\x57\xa9\x8a\x0d\xe1\xb4\x87\x78\x0e\x01\x40\x45\x03\xa4\x13\xfe\x3f\x0a\x9d\x65\x25\xc0\x92\x53\xcb\x8b\xd8\xde\xbd\xc0\x70\xa1\x73\xa5\x9d\xd6\x47\xa6\x0f\xec\xe9\x8d\x90\x01\xdb\xe6\x9e\xa3\xbb\xc1\x9d\xd3\x86\x6e\xeb\x86\xc5\x46\xf9\xb9\x6f\x29\x6f\x2b\xef\x75\x34\x6d\x99\x19\x33\x58\x7d\xc9\x84\xc7\xa8\xb3\xfd\x10\x14\xef\xdd\xfe\xc5\xa1\xf5\x5b\xb5\x9e\x14\xa4\xf3\x06\x70\x14\xfb\xcc\x4e\xd9\x6e\xc1\xde\xd2\x03\xdd\xa6\x03\xb9\x4c\xa3\xc1\xe0\x87\x65\x71\x57\xc6\x65\x4e\xcd\x2c\x78\xa1\xcb\x54\x0b\x62\x55\x94\xff\x1b\x8f\xb9\xf5\xd2\x1e\x53\xe9\xfa\x9f\x3d\xa6\x76\x7f\x18\x59\x0d\xd7\xda\x4f\x54\xca\x9c\x09\xfa\x4a\xe4\x2c\x29\x97\x91\x57\x9d\x65\x17\x76\x96\x3d\x05\xce\x52\xcb\x4e\xbe\xdc\x4b\xbe\x75\x59\x2f\xa9\x74\xfd\xcf\x5e\x92\x24\xbc\x17\x3e\x66\x4e\xe3\x33\x9c\x35\x30\x2b\xad\xf1\x56\x16\x13\x44\x28\x64\x74\x54\x95\x39\xca\x92\xa9\xf2\x30\xbe\xfe\xbf\x92\x18\x48\x1b\xd8\xca\xe2\xe2\x4a\xd6\x40\x0b\xf1\xa8\x9b\x83\xe6\x14\x18\x4a\x5b\x04\x47\x0e\x4d\x04\xd1\x5d\x05\xff\x57\x7e\x89\x1b\x40\xd5\xb1\x6c\x3b\x9e\xd7\xd2\xba\x91\xd8\xa3\x40\xa9\xf3\x99\x7b\x83\xd5\xec\x14\x69\x90\x04\xf0\xbd\x3b\x31\x6a\x79\xeb\x9e\x15\xf5\xb7\x55\x57\x3f\x38\xfb\xd0\xe3\xe5\xd5\x0f\x6e\x5c\xbf\xb1\x65\x1b\x08\x4c\x5b\xf4\xcb\x9b\x41\x6a\xee\x3e\x70\x95\x72\x72\xe5\x7a\x70\xeb\x02\xf0\xae\x70\xc3\x57\x07\x04\x73\x63\xb0\x72\xee\xcc\x99\x73\x9b\xf7\xae\x25\x87\xdc\x15\xe3\x9b\x97\x2c\xfe\x94\x94\xdc\x15\x81\x06\x65\xf9\x10\xb8\xf3\xf4\x03\x4f\x7e\x55\x3d\x5b\xf7\x4d\x34\xf3\x01\x73\x06\xd4\xf3\x5a\x21\x37\x86\x99\x8a\x0a\x1f\x1f\x33\xf3\xe6\x64\x8a\x8a\x0e\xa5\xbd\xf6\xa1\x34\xe5\x2a\xf6\x7a\x8b\x61\x28\x33\x04\x83\xfe\xfe\x74\x90\xa8\xa8\xb2\x55\x0d\xa4\x79\x9b\x23\xa1\xd3\x19\x0c\xa5\x83\x69\x03\x97\x81\xcd\x72\x65\x44\xa0\x0e\x42\xb9\x34\x21\xe4\x35\x86\xb3\x39\xb9\x5e\xd5\x2b\x84\xbe\x11\xe7\xf1\x46\x6e\x14\xba\x75\x27\xde\x56\xc6\x0d\x48\x75\x77\x17\xb7\xb6\xc9\x94\x71\xd9\xac\x70\x48\xb7\xf4\xf6\xe7\x5f\xfb\xd5\xcf\x66\xff\x64\x66\x2c\x54\x9a\x32\xd4\xc2\x7f\xf4\x1e\x06\x55\x53\xa3\xb3\x58\xe2\xc2\xde\xeb\x9a\x37\x7b\x46\xc6\x6e\xd8\x49\xff\x66\xc3\x5a\xc3\xc9\x99\xff\xfd\xf1\xb8\xf2\xcf\x58\x90\x8e\xf3\x15\xf5\x9b\xd6\x90\xcb\x5d\x15\xff\x1d\xbd\x62\xdc\x7a\xee\x8c\x64\x19\x77\x72\xef\xa8\xf7\x43\xd3\x03\x90\xf7\x32\xa2\x96\x18\x93\xe5\x72\xda\x69\x26\xaa\xab\x7d\x71\x3a\x5e\x57\x5f\x16\xef\x4f\x97\x49\x45\x70\x61\x25\xdb\x50\xba\x48\x08\x49\x52\x48\x28\xa2\xf5\x1e\x8f\xab\x3f\xed\x21\x6a\x50\x16\x9f\x1a\x48\xeb\xb9\x6a\x28\x45\xb2\x72\x50\x1d\x8f\xd1\x64\x90\xfb\x9e\x27\x04\x22\x77\x79\xb4\xba\x95\x87\x8e\x7d\xea\xf2\x2e\x8d\xce\xca\x20\x99\x13\x42\xca\x06\xca\x41\x1c\x45\x3e\x80\x4b\x4b\x74\x83\x34\xf9\xe6\xc6\x93\xda\xd5\xd1\xd3\x23\x9a\x18\x22\xa1\xbb\x40\x67\x51\x78\x16\x8b\xde\x58\xad\x9b\x95\x7f\x28\xc1\xbd\x07\x36\xce\x43\x37\x49\x77\xcf\xd3\x6e\x90\xde\xc8\x14\x21\x51\x18\xd7\xba\x2a\xfe\xc5\x5f\xb1\x61\x2d\x38\xdf\xee\xae\x00\xaf\x3d\xfb\x4c\x9c\xfc\x88\x87\x71\xea\xcf\x90\x95\x6f\x30\xf7\x11\x49\xe2\x4a\xb9\xa1\x3c\x4e\x51\x2e\x7b\x89\x21\x68\x08\xa6\x6a\x7d\xd1\x81\x74\xc8\x07\xca\x1c\x2e\xc7\x40\x9a\xa8\x18\x4a\x0b\xe6\xa1\x34\x47\x54\x0b\x42\x35\xc1\xd1\xba\xb8\x8b\xa5\x0c\x3a\xc3\x40\x5a\x97\x3b\xf4\x9a\xb5\x80\xc2\x79\x7f\x34\xa8\x9e\xd4\x76\xbb\xe2\x5a\x44\xc7\x08\x4c\xfa\x68\x3d\xbe\xed\xb2\xae\xa1\x2e\x3f\xf5\xf4\x83\x94\x36\xc0\xde\x90\xd2\x81\xa7\xdc\xd2\xab\x0a\x7d\x63\x43\x24\x14\x77\xe8\x6b\xd9\x33\x4e\xe7\x7d\xf7\x3d\x78\x62\x46\x47\x4d\x45\xa4\xba\xbd\xf6\x8b\x2f\x6a\x8b\xcb\xab\x8d\xb5\x2c\x18\xd1\x29\x9f\x87\x2b\x2a\xc2\x60\x6d\x91\xab\x22\xf9\x17\x1d\xa0\x6b\xe2\x1d\xaf\xff\x52\x7c\x6d\x87\xb4\xe1\xd4\x9d\x23\xca\x1d\x45\xc9\x4e\x7c\xb7\x04\x21\x42\x5f\x53\x09\x6d\xbe\x81\xe8\x26\x06\x89\xbb\xe4\xe1\x01\xa2\xa4\x24\x35\x45\xf6\xfb\xa7\x46\x1a\x9d\x4e\x4b\xa4\x42\xa8\x10\x86\x86\x7d\x51\x4f\xbc\xd1\x33\x94\x1e\x88\x0f\xa5\xa7\x4c\x6d\xb4\xd5\x34\xda\x06\x06\x6c\x8d\x35\x74\x79\x7d\x7d\x6d\x7f\xba\x9e\x2d\x89\xf8\x9d\x42\x45\x79\x45\x7f\x3a\x04\xdd\x5f\xf3\x0c\x6a\xc6\x50\x5a\xd6\xe9\xfa\x09\x23\xc5\x65\x6a\xd5\xc2\xe3\xc0\xa9\x42\x05\x41\x1e\xae\x3c\x8b\xad\x97\x87\xe2\x80\x5d\x86\x26\x32\xdc\xf8\xc0\xed\x0f\x5e\x42\x02\xd1\x72\xa2\x3a\x14\x93\xf9\xcc\x11\xe2\xec\x61\x6c\xa8\x4d\xf5\xea\x61\x1b\xb4\x75\x68\x23\xd1\xce\x16\x74\x3b\xc5\x50\xbf\x70\xbb\x49\xaa\x07\xdd\xd3\x4f\xcb\x5d\x63\x68\xe4\xe0\xcf\x1d\xae\x5a\xcf\xe6\x6b\x94\x59\x37\x15\x37\xee\xfd\xc6\x11\xa5\xe3\xc6\xa5\xdf\x99\x25\x1c\x51\x66\x6f\xed\xb1\xd7\x3a\xb7\x6d\x05\x22\xf5\x5d\x6d\x1c\x61\xe9\x33\xb3\xce\x3f\x3b\xf6\xe4\xac\x59\x73\xf7\x97\x51\xa3\xe5\x93\xd0\x88\x83\xf2\x87\xdf\x84\xda\x76\x4f\x51\xde\x47\x87\x78\xff\xc4\x94\x2b\x7f\xc0\xe7\x92\x27\xfb\x12\xca\x56\xfc\x6a\x45\xa4\x75\x77\x27\x98\x0d\x7d\xd1\x85\xcf\x1e\x51\xa7\x20\x9e\xf5\x95\xdf\x5d\xbe\x67\x38\xed\xff\x6f\x1d\x8e\x65\x3c\xba\x28\x06\xae\x05\xba\x37\x6c\xa3\xdc\x9a\x20\xbc\xde\x78\xa8\xc6\x6e\xd7\xb3\x21\xb6\xb1\xa9\x46\x1a\x4a\x27\xe0\x12\x14\xd5\x98\x12\x09\x53\x4d\x11\x1d\x28\x2b\x2b\x81\x46\xca\x7a\xed\x6c\x28\x10\xea\x4f\x0b\x01\x09\x4d\x3d\x50\x75\xd0\x65\x4d\x74\x48\xa9\xcb\xb8\xa4\x54\x9e\x57\xd2\x00\x2e\xdb\x00\xb2\xba\x8c\x64\x2b\xa9\x78\x4e\x9a\xf0\x3f\x21\x71\x8a\x01\x4a\x93\x20\xe8\x9c\xf1\xd8\xa4\xed\x3b\x4b\x12\xfa\x5a\xe3\xf4\x66\x74\xba\xb9\x6e\xd9\x92\x85\xe5\x7b\x94\x55\x1b\x7b\xc5\x5a\xd3\xb4\xe6\x8d\xc0\x62\xae\x5d\xbe\x64\x41\x62\x70\xd6\xbc\xfd\xd4\x68\xa2\xe9\xe6\x43\x9f\x8b\xed\xfe\x81\x6d\x3e\xe5\x02\x12\xcb\x1f\xf5\x45\xe5\x65\x56\xe5\x20\x16\xd1\xb6\x70\xff\xc8\x66\x1f\xa8\x75\x57\x28\xa7\x0c\xe8\xdf\xff\x6b\x78\xb1\x1f\xfa\xe8\xd3\x4a\x1f\xf5\x6d\x28\x97\x4a\xa2\x91\xd8\x2c\xcb\x75\x71\x37\x45\xd9\x0d\x55\xd0\x32\x9b\x26\xd5\x35\x44\x1a\xa0\x49\x96\xaa\x26\x49\x70\x09\x41\x48\x70\x04\xad\x2b\x8a\x38\x6a\xdd\x6e\x9f\x2f\x39\x98\xf6\x71\x18\xfd\x02\x9b\x68\x7f\x5a\xe7\x2d\x04\xc0\xd5\x84\x54\x60\xae\x05\xfe\x5a\x35\x55\xb5\xcd\x56\x97\x6f\xaa\x50\x12\x99\x4e\x1c\x74\xe2\x71\x28\x3a\xcd\x4c\xc5\xec\x9e\x24\x58\xeb\xf0\x3c\xa0\xc8\x5b\xeb\x33\x06\xeb\x70\xae\x06\x06\xb2\xec\xc8\xd4\x33\x2f\xbf\xfd\xea\xc6\xe5\xba\x86\x22\x6c\xb0\x3f\xdf\xb5\x67\x6c\x66\x7a\xd5\x79\xe5\x65\x3d\x5a\x20\xd7\xa9\x28\x36\x5b\xea\x5e\x77\x45\x43\x51\xe2\x8b\xdf\xff\x49\xf9\xc2\xd1\x5b\x5a\x1e\x83\x56\x4b\xf9\x9e\x7f\x26\x3c\xce\x23\x7f\xf5\x28\x54\x9a\xdb\xb1\xbe\x2c\x95\xeb\x8b\xb0\x50\x0c\x81\x44\x45\xd4\xed\xf6\xfb\x43\x43\xe9\x80\x9f\x23\x62\x19\xb9\x94\x0a\x42\x29\x92\x8b\xb3\x40\x16\x79\x13\x66\x85\x9e\x3a\x95\x3f\x11\x97\x51\x90\x4b\x3a\x2c\x55\x0a\xcd\x99\x1a\x25\xe3\xa9\x36\x49\xce\x7b\x95\x8e\xad\xf5\xc5\x1a\xe3\x76\xdf\x56\x20\x18\x5b\x5e\x6b\x61\xcb\x27\x25\x0f\x27\xeb\xc3\xaa\xa3\xea\x65\x94\x7f\xaa\xe6\x11\x43\x1c\xeb\x41\xd0\x5d\x31\x96\x5c\xa0\xac\xf3\x3a\x94\x5f\x47\xb1\x93\x02\x17\xce\x41\x3e\x37\x42\x3e\x4b\xd1\xb9\x7d\x83\x28\x16\xb9\x5c\x44\x59\x39\x67\x1a\x4a\x47\xbc\xd0\x0d\x87\xac\x91\x88\x35\xc4\xd1\x8e\x78\x9c\x1e\x48\x83\x38\x27\xe2\x81\x7d\x87\x94\x8f\xc2\x70\x29\xcd\x57\x67\x37\xb0\x93\xd5\xc8\x8e\x5e\x8a\x45\x1c\x91\xc8\x8d\xaa\x8f\xad\x53\x3d\xec\x19\xb7\xe3\x88\x22\x1f\xa9\x2d\xca\x3a\x62\xf3\x03\x37\xf4\x4d\x21\x7f\x8b\x1c\xec\xfe\x62\x48\xb8\x4e\xf9\x07\x66\xec\x2a\xd5\x03\x7f\xf7\x05\x51\x9d\xfd\x83\xf9\x86\x1e\xf2\x92\x82\xd9\x6a\xb8\x54\x32\x54\xd9\x22\x86\x48\x6d\x9d\x47\xe7\xa7\xe1\x9f\x62\x73\x71\xc5\x40\xba\xb4\xd8\x61\x16\x06\xd2\x36\x34\xcb\x9a\xca\x5d\x7d\x8b\x18\x10\x32\xde\x51\x5b\x13\x31\x82\x9d\x5c\xac\xae\xb0\x5d\x11\x20\x55\x7e\xf4\x19\x10\xd6\x4c\x97\xbd\x92\x3c\x5d\x12\x33\xd4\x9a\x7a\x1c\x0f\x1f\x5b\x71\x47\x55\x59\xdd\xa6\xc1\x59\xe5\x33\x3f\x4c\x96\xc4\xf5\xb5\x96\xc9\x81\xc7\x1f\xed\x7e\xb8\xba\xa2\x66\xfa\xb6\x17\x13\x83\x9f\x80\x37\x8b\xeb\x4e\x34\x55\x76\xed\x3c\x1a\x7c\x6d\x6d\xd5\x40\x67\x79\x7b\x65\x5f\x2c\x75\xbc\xa1\xb1\xef\xa6\x63\x7e\xe1\xa3\xfd\x9d\x0f\xd5\x74\x26\xa7\xc3\xf5\x79\xf0\xc2\xc7\x64\x05\xbd\x8f\xa8\x20\x46\xe4\xca\x58\x84\xa2\x82\x5e\x96\x35\x54\x56\xf9\x8a\x23\xc5\xd0\x36\x4b\x86\xd2\x6e\x01\xea\xa0\xb3\xdc\xed\x2e\x77\x12\xb4\x25\x24\x07\x23\xac\x45\x37\x88\x66\x8f\xd5\x09\x2b\xcf\x6b\x97\xb2\xbf\x9c\xde\xe5\x6f\x5d\xe3\x44\x21\x2f\x5e\x66\x5a\xcf\x19\xcd\x5b\xe5\xf1\x36\x57\x4f\x1a\x8e\x1e\x68\x1c\x5d\x5c\x9d\xb1\x3b\xde\xb1\x63\xd7\xb2\xf6\xb7\xdf\x6e\x51\xed\x0d\x0c\x19\xf6\x4f\xee\xe0\x26\xbb\x82\x9b\x56\xfc\x23\x84\x16\x88\x01\x4c\x45\xfc\x67\x3f\x1b\x51\xee\x2a\x55\x43\x23\x5c\x2b\x6d\x86\x0c\xda\xd7\x62\x39\x15\x25\x21\x63\x56\x97\xdb\x1d\xb4\x18\x23\x96\x48\xa2\x82\x28\x1e\x4a\x3b\x58\xc8\x97\x58\xe2\x70\x94\x88\x04\x6d\x0e\x86\x42\x1e\x98\x27\xb0\x46\xb3\x99\x1a\x48\x9b\x0b\xc6\x37\x85\x42\xfd\x43\xcd\x8f\x64\xa6\xe1\x84\x59\xa4\xc2\x18\xf2\x87\x0a\xd7\x89\x79\x89\x90\xa8\x41\xa8\x84\x25\x4d\x45\x6d\x80\xac\x6d\x68\x3e\x03\xc4\xa6\xdd\x9e\x54\x95\xfb\xfc\xf9\xf1\x54\x51\x6d\x9d\xb1\xd6\xbc\x6e\x59\xb2\xf5\xe9\x0f\x1a\x57\xda\x83\x55\xe4\xd9\x0b\x44\x4d\x69\x4d\x83\xa9\xd6\xb4\x1e\xf4\x7b\x95\xff\xf2\xda\x5f\x56\xbe\x5b\x01\x6e\xf1\xd5\x4e\xd9\x35\xe6\x01\x61\x91\x3b\xf4\x45\x8d\xb2\x36\x90\x9a\xb2\x63\x0b\xcc\x01\xfa\xc6\xff\x4c\xbd\x86\xe7\xcd\x6a\x09\x99\xd8\x20\xb7\x94\x34\x12\x3a\x4f\x9b\x3f\x51\x55\xe5\xf4\x7b\xbc\x4c\x34\x46\xe8\xad\x76\xab\x7d\x72\x47\x2c\xea\x65\xa8\xba\x81\xb4\xb3\xbc\x1c\x5a\x5f\x94\xa1\xca\xa9\xf2\x10\x1f\x6a\x1e\x48\x17\x85\x7c\x7c\x12\x26\xc5\xda\x1c\xf9\xf7\xb3\x1a\xdb\xd4\x94\x45\xaf\xca\xdb\x07\xce\x6e\xe9\xa1\x3b\x0d\xd5\xbd\xde\x0c\x9c\x66\x66\x73\x03\xf5\xd4\xb3\xfa\x8b\x2e\x96\x44\x87\x1e\xb3\x17\x1a\x80\x3c\xa4\x85\xe7\x5e\x3c\x3b\xd4\xdd\x4e\xf5\xd6\x2b\xbf\xbf\xfd\xf8\xd8\xaf\xef\x7d\xfe\x3f\x66\xcc\x6f\x9a\x79\xd7\x5d\xdf\xfb\x4e\xf1\xa6\xf0\x07\xd1\x1b\xa7\x94\x76\xf7\x80\x35\x65\x75\x3b\xf7\x7e\xfd\x29\x30\x63\xed\xfc\x45\x2b\xd7\x2e\x5a\xb0\xed\xbe\x87\xd8\xfd\x7c\xe0\xc0\xe6\xab\xee\x9c\xb5\x65\x6d\xdd\xea\xc9\xe2\x82\xba\x27\xa6\xbd\x7b\xea\xb4\xcd\xbc\xbe\xfc\xd8\x74\xea\xb6\x26\xb9\x68\x7d\xf5\xec\xe9\x3b\xc7\x6f\xdc\xb5\xe7\xe0\xc6\x6d\xbb\x77\xef\x56\xef\x35\x68\x24\x97\xd0\x8b\x60\x9d\xde\x2d\x87\x0a\xcf\x87\xbb\x8c\x76\x1d\x3e\x4c\x4a\xd8\xd5\x83\xe2\x3a\xb5\xd5\x8c\x86\x0d\xd4\x8c\x37\xff\x54\x46\xe1\x89\x52\x34\xe2\x14\xae\xc3\xdf\xd5\x5d\x40\xb8\xe2\x4e\x29\xd5\xd3\xf3\x41\x0f\xa0\x7a\xde\xef\xee\x7e\xbf\x47\x19\xef\x21\x1b\x1d\x66\xf0\x5b\xf8\x44\xd3\xbb\xef\xa2\xaf\x8a\xd7\xec\x70\x98\x7f\xf7\x3b\xb3\x8a\x6d\xd7\xaa\x74\x52\x5b\x31\x56\x4c\x9c\x98\x23\x27\x3c\x94\x68\x14\x74\x45\xfa\x50\x48\xd0\xb3\x14\xe5\xa4\x9c\x25\xa5\x06\xbd\x28\xea\x04\x13\x67\x82\x2b\xa6\xd3\x11\x2c\xc7\x12\x7e\x68\xa2\xbe\xec\x85\x2c\x6a\x96\x96\xdf\x62\x70\x66\x70\xe3\xd4\x4d\x7b\xb5\x03\x1a\xaf\x03\xe1\xac\x66\xaa\xbd\x51\x90\x59\x8e\x2a\x60\x23\xc1\x5b\xdf\xf9\xe0\xa3\x37\xe7\x82\x88\x72\x5a\x55\xc9\x3f\x29\x6f\x7e\x7b\xd6\xd4\xdf\x2a\x73\xf6\xae\xdd\x36\xd6\xd4\x1b\xd8\xb2\xaf\x53\xe9\x7c\xf5\xa9\xb3\xbf\xf3\x5f\x59\x07\xba\x54\x85\x3c\xf7\xfd\x25\x8f\x8d\xfe\xf0\x2f\x60\xc7\xe1\xfb\x1f\xbf\xe7\x8a\x13\x03\x11\xcf\xe8\xdd\x48\xe6\xfc\x85\x8f\x75\x56\x58\xa7\xb4\x13\xf7\xcb\xc3\x0d\x29\xbf\xbf\xba\xa4\x95\x90\xa4\x46\x0f\x1b\xf1\x24\x4c\x09\x93\x3c\x99\x68\xf5\x36\xb6\x36\x96\xb6\xb7\xb5\xe9\x9a\x9b\x9b\xfa\xd3\xcd\x84\xaf\xa1\xc1\x95\xaa\xa8\x4f\xd5\x0f\xa4\x93\x72\x75\x8a\x2d\x73\x94\xc6\x3c\x12\x6b\x0a\xc5\x42\x83\x69\xab\xcb\x15\x93\xec\x14\xa5\xd3\x41\xbf\xa4\xcb\xcf\x95\xaa\x32\xc9\x29\x06\xcd\x81\x7e\x29\x8b\xaa\x98\xc5\x46\xc8\x6e\xaa\x17\xb6\x0e\x52\xd9\xbc\x5e\xb2\xeb\x55\x1d\x2e\xdc\x93\x56\x8f\x09\xe7\x1c\x59\x1c\xdd\xb9\x9c\xe7\xbf\x54\xe4\xa7\x86\x14\xb5\x4e\xdf\xfb\x74\xfb\xf6\x9d\x28\x9b\x7a\x68\xf1\xb5\x7b\x94\xa5\x5b\x95\xb5\x9a\x47\x5b\x5f\xdd\xb8\x7c\x2f\xa9\xba\x32\x70\xfc\x26\x90\x1c\x5b\x4a\xdb\x5c\x2b\x2b\x4b\x5b\x6e\x3e\xa4\xcd\xd4\x2e\x7a\xc4\x3f\x2e\xe2\x57\xbf\x1a\xff\x71\x40\x75\x72\xfd\xfd\x4f\x88\xe4\xd7\x55\xff\x56\x46\xd6\x80\x13\xae\x8a\xcf\xee\x57\x7d\x5c\x39\x54\x1c\x1b\x9e\x3d\x9c\x22\x47\x54\x8c\x1e\xbb\xa4\x42\xf4\xf0\x8c\x8e\x81\x51\x48\xa7\x03\x26\x56\xa0\xb2\xe0\x3c\x19\x18\xf0\x02\x54\xba\x7c\x58\x1e\x6d\xde\x07\x41\xf2\x40\xb6\x9c\xe0\x37\xca\xd5\x63\xf7\xdc\x83\x26\xf6\xbe\xf6\xb5\x4d\x30\x22\x6e\x18\x01\x0b\xf0\x84\xde\x03\x23\xca\x31\xb7\x8a\xcb\x4a\x06\xf0\x4c\x7a\xa7\x1c\x71\x00\xc0\x5b\xad\x3a\xb7\x47\x67\x42\xea\x39\x90\x76\x70\x9c\xc9\x6e\x17\xfa\xd3\x76\xd6\x44\x0f\xa6\x4d\x8e\x02\xa4\x8a\x8b\x12\x15\xbc\x00\xf9\xd1\x42\x23\x07\x12\x03\xe6\x56\xc5\x2a\xa7\x44\xd7\xa5\x66\x0d\x1f\x3a\x74\x10\x94\xdf\x0f\xce\xfe\x72\xf2\x64\x6e\xb2\x3b\xb0\x69\xc5\xa7\x98\x28\x65\xd1\x08\xf4\x87\x61\x98\x6f\xa2\x59\xd6\x00\x51\x04\x6b\xe3\xed\x72\x7b\x49\xd4\x69\x34\x0a\xb6\xd2\x70\xd8\x0f\x6b\xf7\xf2\x44\xdc\xe9\xf4\x78\x8a\x07\xd3\x1e\x2e\x02\x38\x9e\x1b\x48\x97\xf8\x79\x9e\x96\x24\xb1\x3f\x2d\xb1\x46\x9b\xc5\xd6\x9f\xb6\x78\xa3\x3a\x1d\x4d\x07\x07\xd4\x69\xfa\xbc\xc2\x38\x47\x7a\x4a\x1b\xe2\x9c\xc8\x42\x2e\xef\x8c\x62\x45\x81\x99\xa5\x36\x55\xa8\xb2\xa2\x66\x9d\xce\x14\x48\x8a\x61\x1e\xc1\xa7\xf0\x61\x92\xfa\x6b\xb7\xf9\xed\xe7\x60\x46\x89\xd2\xcd\xb5\x6b\xb5\x2c\xf3\xe1\xef\x1b\xbb\x15\xf3\x9f\x2c\x4a\x47\x7a\xd5\xd8\x4c\xf0\xac\x19\x9c\xfd\xc5\x1f\x60\x26\xa9\xa0\x24\x93\x8a\x62\x9e\x61\x82\xf9\xeb\x77\x95\x1a\xb0\x43\xf9\x0a\x4f\x85\xc3\xca\x4f\xc0\x10\xf4\x25\x19\x9c\x00\x1f\x94\xc1\x2c\xb9\x5c\x88\x46\xcd\x7a\x11\xc6\x37\xa0\x07\xc5\x31\xb7\x9d\xb7\xa0\x01\xd9\x08\x61\x34\x19\x07\xd2\x1e\xc1\x64\xa2\x1d\x36\x96\xf6\xe7\x61\x07\xe0\x59\x43\xcc\x60\x01\x8a\x40\xde\xce\xa4\xea\xda\xb3\x0b\x94\x37\x1e\x03\x97\x0a\xdd\xbd\x1b\x86\x36\xaa\xe2\x0a\x6c\x41\xc8\x02\xe0\x0f\x3b\xc1\xe0\xd8\x98\x12\xdb\x77\x40\x91\xc0\xd9\x2d\x08\x5f\xe0\x40\x56\x97\x72\x3a\xf5\x95\x1d\x57\xef\xbc\xe6\x53\xc8\x83\x03\xf2\x30\x13\xf2\x80\xfa\x59\x3b\xe5\x4e\xc8\xb3\x51\x67\xb5\x17\xf9\xdd\x95\x95\x25\x44\x90\xf0\xdb\x75\x82\x2e\x99\x2a\xb2\x89\xb6\xa1\x74\x15\xa1\x37\xe8\xe1\x42\xba\x0c\x21\xa1\xd8\x22\x88\x2c\x2c\xfc\xab\x0c\x94\x91\x32\x58\x0c\x16\xca\x2f\xb2\x54\xf9\x40\x9a\xca\x31\xa7\x22\x52\x66\x0f\xd7\x64\x19\xcd\x1f\xbf\x2e\xdc\x84\x8d\xc5\x21\xa3\xe8\x10\xae\x8a\x50\x14\xa6\xd0\x9d\x62\x95\x00\x06\x7e\x27\x3e\x2e\x0d\xbd\xa8\x13\x33\xde\x10\x0e\x00\x9a\x31\xfd\xf9\xdd\x77\x3f\x35\xf5\x4e\xe3\x1e\xbf\x49\xd7\x7e\x43\x65\x49\x83\x0d\xdc\x2f\xad\xda\x62\x26\x7b\xcc\x63\xab\x24\x70\x1f\xdb\x50\x52\x7b\xb0\x4d\x77\xec\x51\x76\xfa\xf8\x87\x37\x1e\xd7\x8f\x9f\xd1\x1f\x07\x73\x9e\x3e\x73\xe6\xe9\x91\x6b\x4f\xbb\xeb\x4c\xcb\xff\x79\x81\x60\xaf\x5b\xb3\xfa\x10\x0b\x88\x7f\x2e\x37\xd5\xb9\xbf\xb9\x67\x44\xf9\xd5\x75\x5f\xfd\xca\x61\x1c\x2b\x08\xa5\x0b\xf7\xbd\x10\x02\xc2\xa0\x9c\xa0\xcb\xca\x22\x3e\x5b\xd4\x6c\xb6\x89\x11\xba\xaa\x3a\x98\x18\x48\x07\x1d\xbc\x6b\x20\x6d\xe7\x7d\xa5\xa8\xcb\x15\x43\x5d\x2e\x3c\x7c\x4c\x10\x85\x95\x53\xfe\x0d\x16\xd9\xa0\x86\x1b\x79\x6a\x87\x8b\xd3\x4b\x79\x07\x3d\xd0\x9d\x6f\x38\xa2\xe7\xb7\xb7\x0e\x1f\x06\x55\xb8\xb7\x75\xf5\xc6\x4d\x6d\x6d\x35\x15\x3e\x6f\xa2\xdc\xbd\xf4\xe0\xec\x9f\xcc\x24\xc7\xb2\x6d\x2d\xa6\xd7\x55\xa1\x7c\xbb\xfe\xd8\xcc\xff\xfe\x58\xb9\xb0\x7f\xfc\xd4\x31\xf1\xb5\x1d\x62\xd5\xf2\x59\xf7\xd6\xc7\x82\xe0\xb9\x6c\x5b\x0b\xf5\xb5\x20\x6f\x1f\x61\xde\x12\xc4\x4a\xb9\x31\x2a\x78\x6c\x25\x25\x81\xa0\xc5\x12\x08\x90\x02\x55\x51\xe9\xf3\xf4\xa7\x7d\x44\x29\x2c\x85\x24\xb8\xa8\x12\x57\x62\xb3\x71\x1c\x64\x90\x73\x58\x03\xfd\x69\xab\x44\x40\x45\xa0\x50\x4c\x54\xe1\xa6\x08\xd7\xa5\x1a\x5b\x79\xfc\xaa\x6b\x9c\xcf\x61\x34\x9e\xdf\xd8\x42\xc2\x70\x66\x22\x24\x6e\x61\x51\x74\x96\xcd\xc7\x2c\xd9\x6e\xd6\x5d\xa0\x73\xf3\xc6\xf1\xeb\x33\x7d\x2b\xa5\x4b\xe3\x70\x4f\xb6\x83\x75\xf0\x73\x57\xc5\x17\xff\xe6\x7e\xf6\xd4\x31\xea\x7a\xad\x6d\x05\xfd\x67\xbb\xd2\x85\xfb\x56\x65\xb0\x0e\xac\x8d\xc4\x62\xa2\x25\x1e\x8d\x93\x14\xeb\x61\x3d\xe5\x09\xaf\x57\x74\x3a\x03\x30\x65\x03\xc5\xbc\xc8\x0f\xa4\x23\x22\x1b\x63\xad\xd0\xaf\x52\x14\xa1\xb2\x9a\x89\xfe\xf8\x6a\x07\xa2\xb0\x85\xd9\xe4\xaa\xca\xa6\x01\xd9\x73\x7b\xf9\x9c\xaa\x6e\xe9\x52\x3d\x2b\xcc\xf1\xfa\x2c\x9f\xca\xa2\x1b\x0b\x7b\x55\xaf\x6e\xcc\x31\x58\x11\xa6\x4c\x05\x1d\xaa\xf3\x7f\x0b\x43\x26\xa1\x2f\x9e\xab\x74\xd3\xef\xd1\x5e\x62\x12\xd1\x43\x0c\x13\x87\xe5\xbe\x12\xa1\x3a\x45\xd7\x95\x59\x1a\x1a\x66\x75\x0c\x96\x89\xf1\xe9\x75\x75\xf1\x32\x92\x0e\x7b\xc2\x9e\x91\x59\x14\xa1\x27\xa0\x11\x0b\xbd\xd0\x27\xd7\x5b\x07\xd2\x42\xaf\xbe\xb7\xbe\xbe\x57\x4f\x55\x14\xb5\xb7\x3b\x86\xd2\xed\x52\xc5\xcc\x81\x74\x4d\x05\x17\xe8\x1a\x48\x07\x7c\x99\x5c\x95\x28\xc8\xd1\x11\xc2\x6c\x21\xe0\x6a\x66\xa9\xd5\xf3\x16\x2a\x9e\x55\x81\x10\xd4\x78\x1e\x00\xf8\x46\x0b\x0d\x5b\xba\xe0\x28\xa3\x03\x9f\x65\x94\xf4\x61\x24\x14\xa8\xf9\x99\x1b\x51\xea\x41\xde\x91\x46\xea\xef\x39\x69\xbd\x1d\x3c\x77\xab\x9a\xd4\x02\x87\x96\xd4\xf6\x8e\x6a\x49\xed\xe6\x20\x4a\x6a\x01\x18\xdb\xa8\xbc\xd5\xdd\xa3\xdc\xa6\x66\xb6\xca\x93\x28\xb3\xbd\xea\x8a\xd1\xb3\x9a\x54\x43\xab\xd7\xe4\x67\xb8\x2b\xba\x32\x19\x2e\x6b\x42\x19\xee\xad\xe1\x6b\x4f\x1d\x53\x5e\xcd\xa4\xb9\xe4\x18\x4a\x73\x37\x1d\x38\xb0\x0d\xe7\x05\x71\xa5\x8b\x26\xa0\x0d\x95\x10\x5b\xe5\x56\x2e\x1a\x8d\xf8\x04\xc1\x1f\x29\xb6\x58\x58\x32\xe2\x2c\x72\x16\x95\x96\x45\xfc\xa8\x1b\xce\xfb\xb8\xa8\x2f\x2a\x05\x59\xb5\x2f\x5c\xc4\xb2\x82\x53\x72\x22\x2b\x9a\x60\x46\x39\x2c\x42\x55\xd7\x26\xc0\xfa\x65\xa6\xd1\x91\x8c\xb5\x39\x97\x09\x6a\x96\x3f\xc2\x97\x07\x54\x68\xd7\x51\xfe\x9c\xd8\xde\x9d\xad\x28\x3b\x96\x2a\x7b\xb6\xde\x08\x6a\xc0\xbe\x2b\x40\xdf\x98\xf2\x39\x98\xbb\x3c\x5f\xd5\xdc\xe0\xc4\x21\xe5\x2f\x28\x58\x30\xa4\xab\xe2\x7c\x23\xb8\x1b\x03\x18\xfe\x71\xfc\x8f\x4e\xa4\x72\x68\xf6\x0e\xda\x13\x07\x79\x77\x11\x2d\x72\x50\xb2\x58\xec\x76\x92\x65\xdd\x1e\x81\xeb\x4f\x0b\x84\x5d\x05\x0a\x98\xe8\x24\xb2\xd7\x5b\xe6\x0e\x5c\x5f\x64\x27\x59\x3f\x50\x91\x23\xf8\xea\x7b\xee\x01\xdd\xf7\x16\xd0\x87\xc8\x52\x8d\x1c\xe5\x46\x4a\x97\xce\x0d\x73\x11\x99\xb8\x46\x6e\xab\x8e\xc5\x60\xe2\x11\x6c\x85\xab\x10\x24\xcb\x5b\xca\x5b\x26\x77\x38\x8b\x8b\xeb\xab\xab\x53\x42\x34\x15\x1d\x4a\x37\xa5\xb8\xca\x44\x7f\xba\x92\x6d\x89\x05\x3d\x6c\x79\x69\x79\x7f\xda\x6f\x2d\x9d\xb8\x10\xf9\xfd\xd7\xbc\x56\x4f\xe1\x76\x58\x2a\xab\xf1\x97\x60\x44\xeb\xa6\x66\x13\xdc\x58\x2e\xc3\xcd\xa5\x27\xe8\xab\x1b\x2f\x10\x53\x9f\xe3\xf7\x5b\x59\x4c\x17\xa5\xe3\x46\xd4\x41\x45\x1d\xd6\xad\x40\x34\xe4\x1a\xb1\xd7\x14\x48\x83\x9c\xfb\xc8\x97\x60\xc6\xf4\x65\xba\xaf\xf0\xbf\xe2\xd5\xc3\xb8\x8e\xd0\xff\xff\x0a\xf7\xc5\x16\xca\xd5\x21\x58\x9c\x23\xad\xf5\xc6\xbd\xf1\x44\x85\x14\x0a\x45\xa3\x22\x2c\x5d\xb9\x80\xaf\x3f\x1d\x60\xe3\x0e\x16\xc3\x23\x5a\xdd\x97\x54\xd7\x82\x2e\x61\x7e\x5b\xfa\x32\x72\xb9\x94\x20\x24\xbc\xe6\xa4\x92\x93\xc1\xcb\xbb\x50\x37\x14\x35\x49\x37\x02\x8b\x11\x77\x50\x37\x4d\xe0\x79\x78\xb1\x96\xc5\x63\x26\x51\xdb\x34\xcb\x20\x09\xf3\xd3\x2e\xdc\x0f\x2d\x21\x92\xc4\x2a\xb9\xb1\xca\x2f\x8a\x96\x62\xb2\xd8\x55\x1a\x75\x45\x53\xb5\x95\x7e\x7f\x28\x94\x18\x4c\x87\x38\xaf\xbb\x3f\xed\x65\xd5\x6e\x98\xca\x1d\xe1\xf0\x42\x13\xb6\xd9\x6a\x60\x5e\xef\x28\x2c\x7b\x26\xf6\x44\x0b\x60\xef\x32\x7d\x98\x82\x18\x9e\xcb\x4b\xf3\x3a\xa1\x68\x20\x8b\xca\xf6\x3f\xc9\x63\x59\xae\x57\xdd\x0b\x93\xd3\x53\xca\xb4\xad\xd9\x06\x68\xeb\x46\x5d\xa6\xed\x99\xe1\xfd\xc5\x39\x99\xe4\x94\x7e\x53\x6b\x7d\x9e\xdd\xa2\x7c\x07\x86\xbb\x3b\xb5\xae\x67\xc6\x3e\x6f\xc7\xf8\x77\xb3\xe4\x44\x08\xda\x67\x30\x08\x0d\xd4\x55\x54\x1c\xb0\xdb\x5d\x2e\xef\x50\xda\xed\xe2\xb0\xb1\xb2\xc1\x2f\x33\xd6\x4b\xb6\x39\x2f\x67\xb8\xf9\x3d\x4e\x6c\xc3\xb9\x08\xae\xdc\xb9\xb5\xa0\xb7\x59\x68\xcd\x68\x01\xb5\x8e\xe6\x78\x47\x4e\x47\x47\x20\x0f\x6f\xe2\x7d\x97\x41\xb9\x2c\xe1\xb2\x14\x91\x3c\x15\xac\x0d\xd6\x36\x36\xb9\x12\xb6\x48\xa4\x74\x20\x5d\x1c\xe1\x6a\xd1\x5a\x39\x60\x18\x83\x8b\x75\xb1\x76\xf2\xa9\x6c\x67\x30\x1f\x70\xf1\xe2\x85\xca\xb5\xff\xaa\x00\xbe\x60\x78\xc2\xc9\x26\x4a\x82\x8b\x06\xfe\x9c\x65\x68\xee\x23\x99\x2e\xe0\x57\xd3\xcb\x16\x24\x73\x9d\xc2\x19\x33\x8f\xcf\x6b\x8f\xe6\xd8\x7b\xa2\x47\xed\x03\x6e\xaf\xf5\x87\x3b\xaf\xec\xce\x34\x0a\x9b\x66\x7a\x92\x95\x53\x66\xb7\x2b\x2b\xb0\x3f\xbd\xf0\x4b\xa8\xaf\xa3\xd0\x9f\x56\x12\x23\x72\xb9\xa5\xbc\xcc\x6a\x15\xc9\x88\xb7\xdc\x5b\x5e\x55\x5d\x06\x83\x74\x59\x19\x1f\x0c\xc6\x60\x66\x12\x24\xb4\x8c\x53\x0d\xe3\x7a\x22\x9b\x8f\x64\x7b\xa0\x59\x3c\x30\x74\x4e\x2b\x79\x29\x3f\x9b\x9f\x6c\xd6\xd7\xf1\x05\xcc\xf2\xe8\xbf\x92\xbb\x72\x2b\x77\x7f\x2e\x21\x79\xf0\x44\xdf\x14\xf5\x15\x78\x7a\xa3\xf2\x5b\x8d\xc3\xd5\x27\x33\x39\x09\xdd\x96\x79\x75\xfe\xe1\xd7\xd4\x38\x41\xa0\x18\x09\xeb\x8b\x20\x31\x43\x8e\xbb\x78\xe0\xd1\x03\x31\x28\x06\x43\xe1\xa0\xc7\x23\xba\x24\x68\x75\x3e\x89\x75\x0b\x02\xe4\x45\x70\x30\x96\x81\xb4\x81\xf1\x65\xaf\x19\xce\x26\x5a\x13\x5a\x09\x70\xfd\x8a\xc3\x13\x33\xe6\x70\x26\xde\xa9\xa8\x06\x33\x41\x7b\x5e\xa2\xac\x7c\x5b\xd9\x35\x0a\xce\x9e\x00\x02\xd0\x9d\x00\x0b\xe6\xb5\xbc\x96\xcd\x8d\x57\x53\xdb\xa1\x13\xf1\x8e\x6f\x25\x6f\x84\xdf\xd1\x99\x5b\x01\xe5\xc6\xb8\x26\x82\x9e\x23\x6e\xe1\xfd\xae\x60\x91\x85\x2d\x22\x5d\x94\x23\xe6\x88\x95\x27\x8a\x82\x41\x97\xdf\x03\x03\x7b\xa0\xd8\xc9\xd1\xf6\xb0\x07\x66\x8b\xac\x83\xb7\xf3\xd0\x8c\xec\x97\x0d\xe9\x99\xfb\xae\x2f\xee\xf1\x5d\xd2\x51\x9a\x55\xbf\x61\x04\xd9\xa3\x3d\xb9\x60\x9e\x67\x57\xdf\xde\xf5\xae\xb2\x4f\x79\x6c\x2d\xa8\x53\xfe\xbc\x1e\x7c\x63\xd7\x53\xaf\xef\x03\x43\x6b\x94\x7f\x80\xba\x75\xf9\x26\xe6\x04\x33\x94\xc7\xa5\x8a\x0a\x0e\xdc\x0e\x6e\x41\xec\x2a\x7f\x01\x1c\x62\x57\xf9\x86\x52\x29\x69\x31\xbd\x01\xf2\x8d\x7a\xb9\x11\xb4\x56\x6e\xd6\x65\x09\x4a\xa4\x2d\xe8\xb2\xb9\x8a\x82\x51\x17\xe7\x80\xf9\xa2\xe4\x60\x6d\x6e\xab\x7b\xe0\x32\xee\x42\x33\x39\xcc\x5d\x93\x96\xbe\x4c\xb4\xb5\x30\xc2\xff\xca\x74\xc5\xd4\x7e\x2e\xb4\x2c\x72\x63\x96\xa5\xf1\x56\x92\xce\xf4\x68\xc7\xcf\x6b\x4d\xdc\x7c\x5e\xa8\x2a\xdc\x0a\x3b\xff\x33\xd4\xb2\x2d\xd7\xfc\x7d\x2f\xd4\xb3\x2d\xd4\x0b\x78\x9f\x7e\x99\x5c\x57\xc5\xea\x6a\x6b\x03\x41\x9a\x2e\x71\x9a\x02\xa6\x40\x5d\x3d\x0b\xe3\xbc\xd3\xc3\xb2\x0c\x54\x3b\x58\x8d\x73\x86\x1a\x58\xac\x39\x18\x58\xcb\x30\x52\x09\x41\x14\x69\x29\x7e\xce\xc1\xe7\xda\x27\x42\x53\x79\xe1\x6e\xab\x76\x3e\x03\xd7\xe5\xea\x74\xa3\x3a\x37\x9a\x8f\x1d\x86\x1c\x60\xf6\x24\x2c\xd0\x26\x49\xeb\x1b\xa8\x2f\xc6\xd6\x9d\x16\x37\x3d\x5e\x70\x8b\xc0\xa9\x5b\xc6\xdc\xb0\x08\xf1\x55\xd4\xb4\x29\x81\xfd\xd7\x2d\x3e\xda\x79\x65\x52\xe9\x3a\x7e\xf2\x96\x45\x9b\x80\x2b\xff\xf6\x80\xdd\xd7\x8e\x1f\x74\x3f\x32\x7b\x59\x95\xb8\xe3\x35\x91\x3a\x45\x33\x8b\xd6\x7d\x3b\xe8\x22\xb4\x7a\x8e\xfe\x18\xfa\xca\x20\xac\xe7\x16\xcb\x35\x31\x13\xa7\x4b\x24\x44\x3b\x4d\xfb\x45\x93\x58\x51\xc9\xb3\xd6\xe8\x40\x9a\xb3\x72\xd9\xe3\x18\x0e\x46\x44\xbc\xfb\x09\xc2\x7d\x11\xef\xf9\x65\x6b\xe1\x78\xb5\xe6\x4c\x62\xf9\xe5\x9b\xc3\x89\xcf\xbc\xe5\xb1\x9b\x37\x1f\xd1\x40\x6f\x18\x5b\xf7\x98\xb0\xe5\xdb\xca\xfd\x3f\x39\x37\x7b\x7b\xe2\xa1\xcd\x59\x56\x83\x7b\xd6\x5d\xbd\x7e\xc9\xfa\xa9\xdb\x5b\x30\xb3\x6b\xf6\x82\x77\x3f\x07\x96\x86\xb6\x05\xe7\x4f\xe5\x98\x7c\xfc\xec\x2b\xbf\x7a\xfd\xe9\xe7\x93\xf5\x98\xc7\x3e\xfa\x2b\xb0\x86\x33\x12\x55\x18\x83\xb3\xa8\x8c\x09\x06\xdd\x26\xa1\x48\xa8\xae\xa9\xb0\x0d\xa4\x4d\x15\x40\x57\x5a\x1a\x8f\x1b\x06\xd2\x71\x8e\x09\x85\x22\x11\x6a\x30\x1d\x71\xb8\x7d\x3e\x69\x20\xed\xf3\x16\x22\x45\xe6\xb3\x99\xbf\x97\x92\x85\x0e\xc0\x45\x68\xe6\xb6\x01\x3e\xef\xaa\x88\x18\x0a\x18\x5a\xe5\x1a\xc7\xbe\x53\xc9\x94\xa3\xd4\xed\xaa\x7b\x6c\x69\x4e\x86\xbd\x55\x83\xf2\xad\x27\x37\xdc\xaa\x15\xae\x0f\x7c\xa5\x6f\x4a\xe6\x1c\x05\xe8\x47\x3e\xf2\x5f\x8b\x6e\xda\xed\x5b\xfb\x03\xe1\x3f\x5e\x5a\x39\x4b\xad\x5d\xa7\xbc\xfe\x2b\x11\xf2\x39\x00\xd7\x32\x86\x63\x77\x19\x31\x47\xae\x88\x13\x84\xc1\x55\x22\xb8\xfc\x11\x7f\xa4\x3c\x11\x87\x9e\x32\x1e\xf7\x84\x42\x50\x65\x43\x9c\x81\xf1\x30\x83\x69\x97\xc7\xa1\x21\xde\xf9\x0a\xee\x6d\xcc\xaa\x70\xf9\xc5\x79\x59\xf6\x74\x51\x6e\xdd\x34\xd6\x22\x31\xbe\x36\xff\x58\x11\xa0\xd5\x63\x45\x99\x85\x6b\x1b\x5b\x77\xd5\xca\x9f\xbf\xfa\xe3\xe7\x2e\x3a\x50\xf4\x67\x6d\xd5\x8e\x9f\xbc\x27\xfa\x31\x60\xfe\xf6\x97\xfc\x83\x44\x80\xe8\xd7\xf8\x6a\x21\x56\xcb\x93\xca\xfd\xec\x24\x5a\x2a\xb2\xb2\xb4\xb1\xc6\x58\xd3\xda\x66\x89\xc6\xa2\xb1\xc1\xb4\x05\x56\x4a\xa4\x85\x8a\x46\x75\x82\xe0\x81\x0e\x47\xe0\x6a\x2a\x75\x95\x83\x69\x5a\xe7\x98\x44\x10\xf5\xf9\xaa\x9a\xca\xdb\xb9\xbc\x08\x7a\x5f\x73\xae\x19\x3b\xbd\xfc\x48\xa3\x43\xcb\x5a\xb2\x53\x8d\xf5\x0d\x7c\x4e\x24\xd4\x37\xc6\xd6\x6d\xba\xe9\xe9\xef\x5d\xb3\xe2\xdc\xeb\x8f\xdf\xbc\x07\x54\x37\x79\x97\x54\x2e\x5d\x3b\xa5\xb1\xe4\x6e\xb8\x04\x9d\xdf\xea\xea\x3d\xb4\xb5\xeb\xba\x05\x59\x9d\x86\x8a\xfc\x70\xe2\xe4\x0d\xf3\x77\x49\xfa\xd6\x93\x1b\xf6\x16\xbd\xb4\x91\x73\xa7\x07\x3a\x17\x72\xb4\x7e\xd4\x6a\x5f\xd6\x3d\x0f\xfa\x35\xe5\x0b\x4d\x4c\x48\x26\xcd\xd0\xe7\x5a\xb1\x4c\xd6\xc8\xcd\x35\x2e\x74\x1c\xbf\x99\x0f\x31\x74\x82\x4e\xb4\xb6\x95\xf0\x1c\xcf\x41\x99\xf0\x3e\x1e\xca\x84\xe7\xab\xa2\xb4\xbe\x4a\x3f\x98\xae\xa9\x72\xc0\x14\xdd\x3b\x00\x53\xf4\x89\x42\xc9\x77\xc4\x17\x5f\x48\xa0\x9d\xd9\xd4\xc6\xc8\x33\x70\xe0\x71\x1d\xbe\x8d\x00\x49\xe2\xf2\xc3\x93\xf9\xf6\x1d\x18\x5b\xb7\xf0\xf0\xe4\xad\x87\x7a\xbb\xbe\xd5\x19\x0a\x49\x77\x56\x37\x4e\x59\xbb\xb4\x6a\xd4\xdb\x54\x0d\xf6\xdc\xfc\xed\x37\xce\xad\xb8\xe6\xa5\xb3\x37\x6d\xca\x17\x0a\x70\x05\xed\xab\xe6\xf6\x2c\xb5\x5b\x47\xf5\x34\xb7\xa0\x6b\x20\xed\xe6\x36\xbe\x54\xb4\x77\xc3\xc9\x56\xbd\xb4\x6b\xfe\x0d\x27\x13\x27\x33\x42\x21\x89\x1e\xa8\x27\x77\xe1\xbd\xb6\x4a\x62\x9e\x5c\x99\x28\xb7\x58\x8a\x7d\x8c\xdd\xec\x35\x7b\xab\xaa\xa1\x68\xcc\x89\x81\xb4\xd7\x6c\x36\xb8\x5c\x3c\xd4\x7d\xce\x50\x02\xb3\x06\x87\x06\xf5\xe8\xbb\xe8\xea\x5e\xad\xff\x9d\x0f\x44\x9a\x27\x03\xd4\x3d\x0e\xf1\x75\xe1\x82\x2b\x62\x1c\xd0\xd5\xe5\xb1\xab\x62\x54\xd3\x91\xb1\x75\x0c\xf7\xea\xb7\x94\x93\x64\x47\xf6\x9c\xdd\x7b\x3f\xca\xae\xfd\xf8\xc0\xca\xf5\xca\xba\x05\x88\x5b\xd2\xfd\xfa\x8f\xc0\xa9\xa1\xec\x29\xbb\x4f\x2e\x10\xe3\x0f\x6b\xfc\x81\xbf\x6b\xf6\x80\xef\x69\xa0\x9c\x4c\x1f\xac\xa1\x8b\x60\xc4\x2d\xb1\xd2\xb4\xdb\x61\xb1\x04\xf5\xfa\xe2\x98\x2f\x32\x9c\xf6\x99\xd0\x0e\x83\x89\xb5\xe8\x19\x3d\x72\xd5\x0e\x82\x10\x2e\x5e\x6a\x04\xb7\xfc\xfd\x5c\x51\x9d\xe7\xa1\xf3\xca\xe9\x1c\x2f\x79\x07\xb5\xc9\x3b\xc6\xd6\xc1\xda\xfa\x20\x28\xbf\x37\xbb\x54\xf7\x65\x6e\x77\xc0\x2e\x59\xcd\xcc\xf3\xdc\xb1\xee\x94\x76\xdb\x83\x8a\x31\x0d\xe9\x9f\x09\xd7\x29\x46\xc8\x72\xd8\x6b\x72\x70\xf1\x62\xda\x41\x3b\xe2\x25\x6e\xe8\x81\x21\x2f\x76\xeb\x60\xda\xce\x15\x11\x44\x68\xe2\xc2\xe4\x4e\x7a\xf1\x4d\xb9\xb5\x40\x39\x42\x88\xcf\x41\x87\x6b\xd3\x6f\xf9\xe4\xf7\x8e\xad\x6b\x28\x1f\xde\x0c\x2c\xf7\x7f\xb3\xf3\xe6\x44\xe5\xa3\x0b\xc0\x7f\xfc\xf7\xbb\x8b\xd7\x15\xa8\xda\x7d\x0f\x55\x81\xdb\xdf\x7a\x4a\xb4\xb5\x44\xcb\x14\xf6\xf7\x0a\xb7\x23\xcf\xde\x4c\xb0\xa6\xf8\x1b\xcc\xb3\x4b\x11\x6e\xa8\xd9\xeb\x95\x22\xa5\x91\xd2\xb2\xf2\xd2\x18\xba\x7d\x29\x46\xd8\x9d\x4e\x98\xe6\x38\x7d\xa6\x20\x54\x31\x93\xa3\x20\x13\xcd\x6f\xc4\xa8\x3e\x34\x13\x1b\x74\xd1\x78\xa1\x1b\x55\x79\xc9\xe5\xd6\xe4\xcb\x5a\xfe\x5c\x97\xe7\x44\x73\x39\x35\xfd\x28\x8a\x07\xe3\x57\xbd\xfe\x4b\x72\x6d\xd6\x85\x82\x85\xe8\x1f\x49\x9c\x5c\xab\xf5\x90\x17\xda\xc5\xaf\x61\x7e\x56\x8c\xac\x82\x08\x9b\x3c\x1e\xa3\x8f\xa6\x45\x63\xd8\x18\x8b\x33\x91\xa2\x48\x7f\x5a\x5f\xc4\xd2\x3e\x5f\xd0\x48\x06\xc9\xa1\x74\xd0\xe1\x95\xd0\xed\x00\x03\x69\x47\x56\xf8\xed\x79\x97\x31\x5c\x0a\xc4\x16\x8d\x5c\x6a\xd3\x4e\x05\x7a\xa3\x6e\x42\xe0\x33\xa8\x6e\x94\x8a\x82\x26\x0d\x6c\x37\x8f\x9f\x73\x59\xd8\x5d\xcb\x23\x41\xf2\xa3\x02\xc5\x81\xca\xd4\x17\x6f\x02\x76\x72\xb9\x5b\xc5\x37\x9e\x04\xd7\xe1\x43\x9c\x63\x5f\x21\xa7\x82\xb4\xd3\x62\xb4\x39\x4a\x2c\x22\x45\x3b\x3c\xb4\xa7\x3c\x91\x85\x9b\xf5\xfb\x75\x83\x69\xbf\x23\x0b\x3a\x3b\x31\x57\x9b\x18\xe7\x34\x96\xa0\x62\x39\xf3\x26\x27\xd0\x8a\x5c\x0e\x7f\x76\x82\x86\xf9\xc7\xd6\x5d\x0a\x8c\xf6\xe5\xb9\x73\x0b\x94\x8c\xb8\x14\x32\xad\xf7\xba\xac\xa6\x21\xfb\x6e\x22\xa3\xe4\x52\x7a\x13\xc6\xd2\xe8\x92\x2d\x18\x49\x43\xd2\xb3\x7a\xaf\xcf\x86\xe6\x7a\x35\x2c\x8d\x76\x15\x4b\x03\x0d\x37\xb2\x04\xc8\x1b\x6e\x2c\x84\xd3\x50\x8f\xb2\xa0\x01\xf7\x0c\x78\x83\x14\xe5\x71\xa2\xa2\xb6\x54\x9a\xee\x36\xf5\xac\x7a\x63\xc7\xfa\x15\x35\x57\x5e\x39\xa3\xe3\xd0\xa4\x29\xc3\xdd\xf4\x74\xef\xe4\x19\xca\x87\xc7\xef\xe9\x6e\x20\x4d\xca\xf8\xda\xed\x80\xc6\x68\x1a\x48\xfe\x41\x32\x06\x3e\xce\xcc\xa3\xf2\x66\x86\x60\x08\x6d\x1e\xb5\x05\xcf\xa3\xb6\xe7\xcf\xa3\x42\x7d\x57\x37\x68\x42\xf9\xb5\xa2\x86\x01\xf0\xb1\xe7\xaa\x46\xe5\x8f\x37\xef\xcd\x0e\xa4\xce\x9e\x42\x8e\x88\x5e\x50\x76\xf4\x2b\xd9\x81\x54\x92\xf0\x92\x04\xf8\x4f\xf8\xbc\x00\x51\x42\x34\xc8\x42\x91\x24\x31\x46\xd6\x67\xf4\x95\x96\x45\xdc\x6e\x42\x64\x2d\xe7\x40\xcb\x13\x31\x46\x85\x3f\x79\xe9\x22\xd8\xa1\x4c\x11\x7b\xf1\x49\x1e\x74\x81\xae\x7a\x18\xa2\x01\xcb\x01\x37\x8c\xc3\x57\x4f\x71\x5a\x13\xe6\x48\xe9\x4d\xd7\x6a\x64\xe9\xfa\x16\x4f\x9f\x73\x45\x79\x63\xd3\x48\x4b\xc5\x82\xf6\x26\x32\x36\xa5\xb2\x79\x78\x4a\xf7\xc6\xa3\x5f\x45\x44\xfe\xa3\x3e\x32\x79\x6a\x73\xfb\x8c\x83\x81\xe2\xba\x59\x65\x19\xdc\x8d\x12\xe6\x36\xec\x9b\x47\xe5\x92\xa0\xe4\x76\x5b\x28\x97\xde\xa8\x73\x02\x17\x82\x9e\xb2\x40\x1f\x2d\x89\x46\xa7\xc1\x05\xb3\x7b\x82\x70\x89\xf0\x0f\x1d\x81\xeb\xda\xfe\xa4\x41\xaf\xa7\xcf\x61\x30\x8e\xaa\x2c\xca\x44\x4a\xbb\xec\xa4\xe0\xcc\x40\xf6\x74\x87\xd8\x80\xf0\x91\x9d\x0d\x92\xde\x21\x3a\x33\x63\xc6\xce\x58\x5c\x9f\x9f\x49\x5f\x73\xb8\xad\x6b\xed\xc0\xdd\x9b\x9f\xa1\x49\x75\xe4\xb8\xa3\x2e\x34\xf8\x38\x98\x32\x7d\x70\x46\x6f\xef\x8c\x81\x3e\xfa\x07\xfd\x09\x47\x95\xaf\x76\x61\x63\xd7\x57\x95\x37\x25\xe5\xf7\x37\x5f\x0f\xec\xd2\xba\xbe\x15\xca\x63\x5b\xd7\x2e\xdb\xb3\x67\xe5\x86\xcc\xba\xbf\x81\xf1\x21\xda\x65\x67\xd8\xcc\x05\x98\x80\xd9\x45\x41\x26\x8b\xca\xca\x43\x66\xb3\xc5\xe2\x25\xe3\x68\xfc\xcb\x25\x7a\x2f\x46\x5c\xc8\x66\x10\x18\x7b\xd1\x91\x9f\x3d\x7c\x19\xee\x42\x70\xe1\x08\xc2\x5d\xd8\x10\x11\xc5\x43\xd3\x3a\x9a\x73\xc0\x0b\xeb\x3b\xa7\x8c\xad\xdb\x75\x19\xe0\x85\xb9\xf1\x1c\xf0\x02\x20\x4a\xc8\x24\xb8\x83\x39\x4e\x78\x89\x66\xd9\x2a\x38\x1c\x94\xd7\x6b\xf2\xf9\x1d\x5e\xaf\x1b\x4d\x92\xdb\x4c\xfa\x73\xa0\xe2\x8c\x04\x80\xa0\x4d\xf6\xab\x06\xd4\x3e\x61\xdb\x5b\xbc\xdc\x36\x0c\x8c\x95\x87\x97\x2c\x59\x3a\xb7\xa6\xd8\xef\x75\xb9\xcb\xbc\x5f\xf9\xca\x35\xca\xeb\xc3\x74\xad\xdf\x59\xb2\x77\xbf\x79\xc7\x34\xcb\xf4\x91\x45\x49\xa5\xc2\xee\xf5\xda\x55\x3c\xa4\x77\x41\x09\x38\x82\xe7\xfa\x5a\x65\x09\xb8\xdd\x9c\xd1\x6e\xf7\xf9\xdd\x76\xbb\x03\xf0\xbc\x47\x10\x74\x0e\x84\xe7\x63\x35\xea\xce\x61\xb4\x07\x75\xfe\x23\x95\x1b\xe0\xcc\x46\xea\xa8\x94\x8f\x0d\x98\xbf\xd3\x9b\x02\x47\x96\x36\x2d\x6a\x99\x8a\xae\xa5\x6a\x1c\xd9\xbe\x7d\x25\xa8\x9f\xbf\x94\x5c\x18\x4b\x6f\x6b\x13\x8e\x8f\xf8\x37\x1d\x4d\x81\xaf\xb3\xa1\x10\xab\xa4\xa1\xbe\xfa\x40\x09\x49\xc2\x75\x35\xc1\xa5\xec\x92\xad\x86\x08\xe9\x72\x71\x7e\xb3\xdf\x5c\x1c\x8b\x22\x4a\x22\xba\x10\x1a\x8b\x23\xa1\xb1\x79\xd1\xfa\x4a\xbc\x2d\x43\x59\x46\x56\x79\xe3\x32\x38\x24\x27\x1b\xea\x34\xb4\x1e\x26\xbf\x5f\xd4\x9a\x03\x6d\x69\x48\x01\x66\xa4\x0b\x61\xf7\x00\x79\xcf\xce\x19\xc3\x61\x4f\xaa\x69\x66\x47\xcf\x55\x18\xd4\xc7\x9c\x26\x97\xb4\x3d\xaf\x42\xf8\x24\xf7\x5c\x8f\xcc\xec\xca\xcd\x9d\x1a\xba\x0f\x5e\xd3\x08\x48\x90\x6b\xa0\x0c\x03\x50\x17\xcd\x36\x63\x40\x92\x3c\x46\x4f\x30\x14\x38\x07\x5a\xcf\x7a\x24\x9b\xd1\xe8\x34\xa3\x11\x67\x3b\x49\xf2\x8c\x36\xce\xcb\x67\x40\xae\xda\x27\x20\xdc\x34\x68\x97\x95\xaa\xc7\x83\x70\xad\xcd\x67\x8f\x0a\x81\xa7\xe8\xe2\xcd\xb1\xde\xe9\x5d\x9f\x4d\x5f\x5a\x34\xcc\xf5\xfd\xbd\x77\xe4\x69\xd2\x5b\x1c\x72\xc4\x67\x0d\x6a\x83\xb9\xb7\xad\xb0\xd1\xe0\x05\xf4\x72\xdc\x61\xd6\xe6\xe1\xac\x50\xe7\xa6\x32\xa3\x04\x4f\xf8\x89\x4e\xd9\x22\xb0\x00\xb8\x4c\x3a\x5d\x20\x28\x79\x11\x88\xb0\x91\x30\x18\x58\xa3\x91\x36\xa3\xd9\xe3\x27\x81\x4e\x47\xe7\x40\xd3\xb4\xd5\x6e\xcf\x5b\x6b\x0c\x2f\xa3\x9e\x90\x85\x6b\x8c\xce\x31\xf1\x29\x89\xca\xcb\xc7\xde\x47\x53\x72\x6b\xd6\x0c\x3c\xb9\x76\x45\x66\x70\x8e\x4a\xbd\x8d\x48\x7a\x3b\x09\xbf\x29\x17\x92\xe0\x0f\xda\x00\x1d\xa1\x61\xf8\xc5\xc0\x08\x94\x1f\x47\x84\x9e\xd6\x11\x16\x0b\x2f\x58\x59\x34\x47\x48\x65\xf1\xc0\x72\x30\x94\xf9\xb8\x36\x48\x30\x1f\xf8\x9c\x81\x18\xd7\x11\x4d\x25\x07\x9e\x24\x9f\x88\xe1\x71\xf3\xae\x56\x70\x5b\x66\xde\xbb\x1e\xf2\x5e\x84\x31\x3d\x0a\xf1\x33\x9b\x2f\x8b\x9f\x29\x66\x91\x19\x24\xfd\x2f\xba\xfe\xd8\xdd\xfd\xc7\x2e\x72\x41\x66\xd0\xce\x8b\x70\x43\x03\xf0\x33\x65\xf8\x99\x22\xb4\x19\x7b\xee\x1c\x8d\xc1\xc4\x33\x0c\x3e\x42\x83\x3e\x5e\xa0\x28\x90\xfd\xf8\x8b\x8d\x46\x1b\xd8\xcc\xca\x50\xd2\xa3\x83\x41\x92\x13\xc4\xfe\xd8\x3d\x3a\x0a\x9f\xb9\x78\x71\x17\x99\xf4\xb2\x1f\x24\xdf\x40\x4f\x7d\x23\xf9\x01\x8b\xcf\xf0\x3b\xa0\xbd\x5e\xa7\xad\x65\x9c\x98\x22\xbb\x05\x9b\xcd\x1c\xd0\xe9\x8a\x5c\x66\x73\x49\xa9\x57\xb2\x12\xc5\xc5\x70\x31\x29\x33\x9e\xc4\x0c\xc3\x08\x58\x99\x45\xe8\x81\x0f\xe5\xb2\xe3\x8e\xb9\x44\x29\xb3\x85\xd9\x0c\xf8\x8b\x17\x13\x0f\xbf\xb6\xa2\x92\x02\x24\x99\xe1\xee\xe6\x29\x5d\xed\x75\x23\xe7\x86\x67\xa0\x55\x45\xab\xfb\x49\xc8\x35\xbd\x3e\x16\x07\xdf\xeb\xeb\x6f\xaa\xa8\x6c\x22\x7b\x58\xef\xf8\xd1\x24\x35\x5f\x5b\xe0\xf3\x83\x2e\xdf\x4a\x26\xa8\xcd\xde\x83\x04\xb8\x96\x39\x04\xd7\x39\xf2\x34\xab\xa7\x69\x5e\x40\x68\x61\x89\x27\xac\x26\x02\xe3\x67\x20\xb4\xb0\xec\x4a\x67\x00\xc2\xf8\x0c\x6c\x15\x28\x9f\x33\x7f\xf4\x7b\xbd\x01\x91\xf7\x55\x82\xc4\xf6\x31\xaa\x83\xf5\x9e\x1f\xbb\x87\xef\xd8\x66\x26\xd0\xf5\x5d\x25\xa0\x0d\x7e\x36\x42\x4c\xb2\x48\x30\x23\x11\x49\x8e\x73\x7b\x38\x01\x3e\xe0\x49\x3b\xcb\x5a\x11\xb0\x13\x05\xa9\xa8\xc4\xc8\x06\x79\x2a\xad\x9d\x62\x28\xd8\xd2\xaf\xcb\x0c\x40\xda\x75\x67\x8b\x63\x01\x2f\xc7\xc3\x94\xe7\x8f\xa3\xa3\xdf\x5b\xd2\x0b\x4a\x2c\xd0\x8d\xfa\xda\x93\x7d\x2a\x1e\xca\xf9\x9f\xb1\x9b\xae\x18\xd4\x70\x15\x92\xe0\x73\xa8\x17\x17\x61\x85\x36\xff\xaf\xb1\x42\x53\xc0\x37\xed\xaa\x8e\x46\x77\xcc\xa0\x34\x4c\x9f\xfe\x4f\x7a\x3a\xab\x94\xe8\x37\x3f\x9a\x19\x32\x05\x44\x0d\x48\x50\x5b\xa1\x7f\xac\x25\x96\xc8\xde\xb8\xdf\xef\x64\x05\xa3\x40\x46\x92\x91\x64\x5d\x3d\xeb\xf3\x25\xe2\xf1\x32\x8b\xc7\x53\x55\x86\xf2\x9f\x28\x51\x0c\x9a\xcf\xfa\x9d\x42\x24\x22\x85\x32\xfc\xb7\x62\xfe\x55\xdf\x93\x9b\xc5\x9f\xd0\x98\x9e\xd0\xca\xad\xfb\x52\xe4\x15\x67\x1e\x4e\x8b\x5d\x47\xbe\xac\xc1\x98\x5c\x04\xc1\xc2\x64\x11\x5a\xe6\x83\x84\x86\x69\x72\x59\x18\x96\x4a\x0d\xae\xa5\x6f\x6c\xbb\xea\x23\x20\xdf\xff\x86\x31\x14\x16\xc9\x2e\x3e\xa8\xf3\x80\xe2\x62\x8f\xa5\xcc\x52\x56\x59\x55\x56\x1c\xf4\xf0\x16\x4b\x1c\x65\xa3\xcd\xb2\x25\x62\xb7\x1b\x9d\x45\x45\x3a\x00\x68\x23\x02\x94\x28\x2f\x60\x7a\x22\x8a\xc2\x04\xbc\x54\x04\xb9\xf8\x7f\x41\x51\xa0\x6c\xb1\x55\xf1\x4b\x83\x28\xcc\x02\x44\x4f\x0f\xd4\xf8\x94\x23\xf6\x3f\xa2\x28\x8c\x7b\x34\x7f\x75\xe1\x3f\x61\x2c\xd9\x06\xd7\x37\x42\xf4\xc8\x9c\xdb\x60\xb0\xda\xc9\x90\x3d\x14\x2d\xd2\xbb\xdd\x8c\x0f\x2d\xaa\x44\x38\x61\x18\x14\x10\x20\x6c\xeb\x93\xa1\x02\x90\xc6\x3c\xe8\x99\xfc\x6c\x33\xb3\x60\x05\x18\x34\x39\x68\x11\xc8\x05\x38\x38\x7d\x69\x47\xc7\xfc\xb9\xa5\x95\x7e\x4e\x0c\xf6\x74\xde\xcb\x94\xae\x2d\x82\x61\x06\x39\x20\xb0\x72\xb5\x30\xae\x68\x20\x34\xa4\x0c\x57\xc6\x55\x3c\x6b\x10\x2d\x19\x5e\x97\x46\x48\xef\x1b\x98\xde\xa9\x32\x2f\x1a\x8d\xb6\x10\x45\x79\x6c\x9e\x68\x91\x41\x14\x75\x0e\xb5\x18\xe0\xa1\x01\x20\x5c\x58\x94\xe1\x04\x7d\x79\xb6\x7e\x11\xc1\x79\x65\xce\x25\x74\x0c\xd2\x9a\x71\x06\xe4\xf6\x39\xf3\x21\xc9\x2a\x4e\x0e\x26\xb6\x37\x60\xe7\x54\xc7\x00\x1e\x2e\x40\xca\xc1\xe4\x56\x64\xfc\x44\x84\x4c\x92\xeb\xb0\xef\xee\x96\x85\x7c\xfc\x5a\x86\x60\x31\x84\xad\x4a\xea\xbf\x43\xa1\x8a\x84\x1e\x7e\xc5\x30\x2d\xed\x39\x90\xd8\x4b\x00\xd8\xa6\x32\x00\xb6\x1a\xb1\x00\x7c\x36\xed\xe5\x9e\x49\xca\xe3\x53\x5f\xee\xe9\xf9\x0e\x70\x22\x34\x16\xb8\xc6\x7f\x03\xbf\x51\x7a\x32\x64\x29\x6b\x55\x1c\x2e\x8c\x45\x83\xf1\x7b\x38\xc2\x89\xd0\xde\xec\x36\x1b\x23\x59\xad\xb0\x8e\x71\xb9\x6d\x76\x3b\xc9\x63\xb8\x18\x53\x16\xc9\x47\xb8\x18\x73\x3a\x87\xe8\xa3\x9d\x28\x43\x93\x02\xe1\x4a\xa0\xc2\xd5\x20\x04\x1c\xe5\x1f\x33\xfb\x48\xe5\x27\x64\xf7\x8c\xa9\xbd\x34\xa8\xa2\xa7\x67\xb1\x7d\x94\xcd\x57\x6f\xdf\xb7\x06\xfc\x79\xf1\xa6\xd5\xcb\x11\x3d\x45\x70\x3d\xd7\x41\x3f\x2a\xc1\xd2\x34\x4a\xa4\x65\xc9\x11\xb6\x89\xa2\x5b\x4f\x92\x8c\x9f\x63\xb8\xa2\x62\x77\x38\x4c\x09\xa8\x3c\x40\x01\x0f\x3a\xd7\x33\x21\x8f\xc7\x86\x71\xf2\x44\xac\x8c\xad\x19\x65\xbc\x18\x58\x37\x83\xa5\xa9\x4e\x31\x37\xd4\xc5\x78\x4e\xc3\xee\x96\x1c\x3c\x87\xd0\xa8\x00\x1a\xc2\xb5\x01\x06\x66\xe3\x7c\x1b\x78\x7a\xf4\xb3\xcf\x46\x41\xd1\x92\xcf\x3f\x5f\xa2\x3c\x35\xb9\xbb\xb7\x1d\x6c\x6a\xe9\xeb\x6b\x01\x09\x2f\xfb\x53\x17\x60\x81\xc9\xf3\x7b\x24\xce\xdf\x7b\x94\xbf\x29\x9f\xb9\xdf\x64\xbd\x64\xf4\x9a\x8d\x16\xf0\x3b\xeb\x86\xb1\x65\x3b\x78\xc5\xcb\xed\xd1\xfa\x0d\x30\x36\xdc\x01\x65\x9c\x84\xf1\x92\x77\x45\x93\x0c\x9f\x48\x52\xe6\x80\x39\x90\xaa\x2d\x8f\x57\xc2\xf4\xf1\x29\x17\x63\x4b\x52\x61\x9c\x4f\x0a\xb6\x6c\xbd\x80\x6a\x9e\xf6\x42\x44\x33\x44\xb9\x86\x61\x14\xd7\xc0\x42\x2e\x01\x1c\x11\x97\x0a\xdb\xec\x8d\xfe\xca\x9e\xcd\x1d\xfd\xbd\xd3\x56\xcc\xea\x1d\xf6\xb9\x43\x5d\xd5\xa9\xc9\x43\xbd\xd3\x57\xaf\x08\x96\xf9\x4a\x03\xa2\x37\x50\x5a\x31\x77\x29\xf9\x5a\x7f\xe9\xd2\x8a\x7a\xa7\x7d\xa6\x3c\x6d\xb6\xb8\xa3\xc3\x57\x5d\x5a\x9a\x74\x39\x86\xe5\x91\xd9\x4c\x6a\xa4\xcf\x3a\x6d\x87\x65\xff\xde\xfb\x90\x8f\x18\x87\xfc\x3c\x0b\xd7\xc8\x0b\xe3\x8c\xd9\xa3\xd7\x5b\x50\xca\xee\xa5\x10\x50\xd8\x13\x18\xc4\x3b\x9b\x0f\xe7\xe5\x1a\xb9\x1e\xcf\x45\x3b\xa6\xe0\x1e\xaf\xdd\x5f\xea\x5b\x3a\xb7\xa2\xd4\xef\x75\x78\xcb\xbc\xcb\xe0\x2b\x86\x98\x66\xed\x1b\x19\xdf\xbc\x77\x3f\x8c\x77\xf0\x15\x79\xe3\xde\x03\x96\x1d\xea\x5c\x0b\xf4\x6a\x57\xd1\xff\x05\x6d\xbe\x5d\x16\xdc\x7e\xbf\x83\x11\xac\x11\x21\x12\x2d\x12\x7d\x3e\xa7\xc3\x8d\x12\x8f\x10\xc1\x22\xec\x8d\x3c\x60\xac\x1c\x9a\x90\xea\x9a\x52\x13\x71\xb1\xb4\xe6\xf6\x44\x80\x21\x70\x55\x06\x18\xab\x57\xf0\xe4\x21\x0d\xd5\x67\x91\xb1\xaa\x75\x05\x80\x43\x16\x15\x8f\x09\xda\xd5\x3a\x5c\xd7\x44\x88\xb9\x72\x20\x24\x08\x66\x36\xc8\x48\x12\xe1\x62\x5d\xd1\x22\x89\x65\xf9\x10\xcc\x34\xdd\xa2\xd5\x6a\x70\x22\xab\x3f\x13\x60\x18\x9f\x01\x01\x6d\xd0\x79\x40\xa0\x38\x6b\xca\x86\x8d\xfc\x93\x03\x2a\xf9\x52\x06\x22\x01\xd7\x3b\x38\x8f\xd3\xbe\x4a\x0c\x2c\x3b\x60\x4d\x44\xc6\x35\xc8\x84\xb6\xb6\xde\x47\xfe\x30\xeb\x5c\x87\xf2\xfa\xd4\x8e\x3f\x50\x4d\x1f\xa8\xb8\x09\x6b\x51\x7a\xf7\x2f\xf4\x37\xf9\x9a\xf0\xcc\xf2\x15\x1a\xb6\x4d\x8c\x5c\x0c\x69\x2f\x21\x86\xe5\x88\x40\xe9\x6d\x51\x9f\xcb\x67\xb3\x50\x54\x20\x4e\xc5\x4b\xcb\x82\x16\x8b\x35\x0a\x23\x83\x97\x65\x8b\x74\x3a\x1f\x4e\xf4\xa4\x2c\x66\x53\x5e\xa6\x99\xa1\x19\x37\x91\x92\xf9\xde\xb5\xb6\x3e\x73\x34\x35\x95\xb9\x19\x48\x3d\xcd\x9f\xca\x9e\x4f\x95\xec\xa0\xeb\xfa\x5b\xd6\xcd\xa7\x63\x9d\x65\xae\xb0\xe1\xbc\xb5\x6b\xda\x9c\x79\xf3\xe6\x4c\xeb\xb2\xfc\xcb\x18\x76\x55\xb7\xc7\xe8\xf9\xeb\xc8\xd8\x96\xad\x0b\xb6\xb0\x21\x5d\xeb\x89\x53\xc6\xd1\x81\xa5\xf3\xe7\x2f\xed\x5f\x62\x3c\x75\xa2\x55\x17\x62\xb7\x2c\xf8\x44\xc5\xb6\x8b\x91\x5b\x20\x2f\xe8\x96\x06\xd6\x6a\x10\x11\x60\x33\x94\x3a\x2c\x39\x24\x0c\x36\xc5\x41\x79\x5f\x06\xf3\x37\x07\xf7\xab\x95\x42\xea\x4b\xb2\xfa\xea\x35\x57\x6f\xea\xf9\xb4\xfb\x86\x3b\xa7\xbd\x42\xb7\x28\x67\x97\x2f\x5f\xbe\x08\x0c\xe1\x80\x7a\xe6\xd8\xcd\x60\x26\x7c\x95\xad\x2b\xc8\x3a\x68\xf7\x7e\xa2\x46\xb6\xe8\xac\x12\xe5\xa1\x3c\x81\xa0\x9d\x73\x3e\x0b\x2d\x9c\x22\x18\xf8\x78\x63\x56\x6e\x79\x4d\x22\xb5\x91\x9b\xcd\x3e\x2f\xba\x4e\xc9\x06\x40\xed\x8b\xbd\x8f\x2c\xaf\x4f\xd7\x36\xd6\x42\x83\xf1\x17\xd7\x2c\x9c\xdb\xb5\x95\x8c\x3d\x0b\xe6\x42\xcf\xbe\x7e\xcf\xd4\xeb\xae\x98\x7f\xa5\x75\xea\x0e\xf3\xd8\xf6\xd5\x77\xcf\x26\x54\x7c\xa4\x24\x39\x4a\x6f\xc2\xb8\x18\x26\xda\x48\x5a\x8c\x16\x96\xa3\x10\x04\xed\xd3\x16\x92\x34\xd2\x34\xa1\xcf\x61\x42\x4f\xc4\x04\x51\x77\xd1\xd1\x85\x7a\x29\x58\x9d\x80\x79\xe9\x07\xee\x9a\xf7\x46\xfd\xaf\x2b\x7e\xd7\x04\x23\x34\x07\xae\x53\xae\x41\x98\x18\xa4\x6b\xfc\xf7\x18\xbf\x0e\x61\x63\x1b\xa0\xcc\x05\x18\x4f\x58\xb3\x1e\xf0\xa4\x09\x98\x44\xbb\x89\x24\xf5\xa8\xf2\x39\x03\xcc\x66\x3e\x87\x81\x3e\x01\x4e\x06\x77\xe7\x40\x06\xdc\x19\x68\x97\x93\x97\x81\xfa\x83\xc3\x6e\xd1\x07\xee\x55\x5e\x79\x30\xd4\xe3\x08\xfa\x58\xf8\x68\xf0\xdf\xd2\xe0\x57\xfc\x8a\xdb\x66\xdb\xf2\x22\xce\x05\x4a\xc8\xb3\xf0\xb9\x11\x58\xb9\x0b\x9c\x45\x47\x39\x1c\x61\x3d\xab\x63\xa3\x45\x2c\x74\x52\x18\x77\x57\xc7\x71\x0e\x06\xe5\x01\x21\x94\x07\x54\xaa\x79\xc0\x84\x30\x91\xca\x74\x09\xb5\xee\xff\x45\xc4\xe8\x72\xee\x95\x1c\x9d\xbb\x54\xb9\xed\x22\xe2\x18\x93\xe6\x57\x41\xc9\xfe\xbd\xfa\x7c\x3a\xdb\x37\xcc\x50\x7d\x29\xf4\x11\x8d\xe0\x7d\x72\x05\xf6\x11\x51\x68\x69\x51\xaf\x93\x0f\xeb\x74\x82\x87\xf7\x14\x15\x7b\x04\xc1\xe5\x0b\x52\x55\x54\x3b\x75\x94\xba\x9b\xfa\x16\xa5\xa3\x28\xce\x09\x3d\x6c\xf3\x53\x01\x28\x6a\x13\xa7\x2e\xd6\xf7\x33\x5e\x62\xe1\x04\x0f\x91\x37\x65\x8b\x2f\x6a\xc4\xfd\xbe\x68\x1e\x2b\xc5\x11\x3d\x8e\x22\x80\xa9\x18\x6b\x9d\xdc\xd1\xdf\xf7\x88\xdd\x9a\x30\x73\x67\xf3\x58\x01\xe5\x57\x4c\xbd\xed\xca\x22\xf2\x8a\xe1\x59\x6d\x15\x75\x8d\xf1\xaa\xca\x92\x2c\x27\xdb\xb6\xb5\xda\xe3\x48\xc7\x9d\xb8\x5f\xb2\x1c\x46\xeb\xc9\xb2\xdb\x65\x65\x9d\x4e\xab\x3d\x73\xd7\x99\xcd\xea\x72\x49\x4e\x96\xb5\x4b\xc8\xd2\x74\xd9\xe2\x07\xd1\xa7\xdd\x0e\x54\x70\xbd\x99\x58\x78\xaf\xb7\x98\x21\x96\x42\x3c\x7c\xd0\xbc\xde\xd7\xb3\x68\xc3\xaa\xc5\xf3\x2a\x9e\xb8\x1d\x93\xf8\xdd\x17\xde\xb9\x0b\x94\x78\xec\x45\xe2\xc2\xb5\x57\x6c\xf4\x03\x09\x92\x16\x54\x7e\x13\x78\xfd\xda\x5b\xd5\xdc\x06\xd9\x3e\xc5\x1c\x81\xc9\x0b\x4f\xb8\x51\x6e\x63\x73\x38\x74\x2c\xf4\xc1\x3a\xc2\xe3\x75\xd8\x6c\x94\x19\x26\xe8\x15\x50\x4d\xa9\x2f\xc9\x6d\x72\xb5\xa8\x1e\x6d\xe3\x56\x02\x0a\xe7\x38\x24\x49\x6d\xbe\x76\xfb\xba\xf5\xbb\x3f\xfd\x5b\x67\x23\xd0\x91\x72\x6f\x57\x07\xa5\x7c\x41\xba\xeb\xa8\xf7\xdf\xfa\xf5\xaf\x7e\xf6\xe6\x7f\x56\xdf\xf9\xda\x0b\xa7\xcf\xff\xe3\xc1\x97\xef\x3a\x3c\x05\xd3\xa3\x3c\x4d\x2f\x06\x93\x99\x17\x61\x6a\x85\xaa\xe7\x26\xd9\x43\x32\x8c\xcb\x02\x97\xdc\xe5\x0a\x48\xde\x63\x69\x48\x19\x6b\x3c\x96\x66\x59\x0a\xea\x66\x1f\xd1\xfe\x5a\x32\x7b\x0b\x20\x48\x69\xd7\xdd\x60\x39\x51\x75\x29\x51\xca\xc7\x0a\x62\xf2\x5e\xbb\x9f\x7a\xa6\xe6\xd3\x64\xac\xb8\xae\xae\x38\x96\x54\x4a\x53\xc5\xb1\xba\xba\x58\x71\x0a\x3e\xbb\xad\x58\x79\x36\x0c\x8c\xe8\x7d\xac\xb6\xf6\x2d\xed\xfb\x65\x68\x83\xb5\x1a\x22\x0c\x92\x17\xf4\x4a\xc7\xd2\xd0\xa7\x19\xd9\x63\x69\x58\xd9\x7f\x39\x6d\x54\x9d\x08\x0b\x78\x90\x87\x47\xca\xe4\xbd\x9e\x5b\xf3\xcc\x53\xca\x3b\x19\xe2\xc0\xdb\x39\xe2\xc2\xa0\xa3\x58\x79\x11\x12\x57\x5b\x1b\x83\xff\x76\xbd\xf6\x1d\xfb\xae\xc7\x95\x2e\x62\xf0\xc2\x37\x88\x04\x51\x2f\x7b\xcb\xc8\x90\x45\x5f\x4c\x14\x5b\x48\x5a\xe2\xbd\x5e\x49\xaa\xe0\x43\xfa\x32\x3a\x41\x88\x2e\xa2\x2a\xf5\xa3\x24\x54\x26\x80\xd7\x4e\xc8\xc1\x5f\x8a\x68\xd4\x8f\x44\x13\xa9\xea\x77\x0d\x9b\x1a\xb9\x52\x12\x0d\xb0\xaa\xdf\x9d\xfd\xc7\xed\x2e\x3b\xcb\xb3\xa2\x43\x8c\xb8\xfd\xa1\x44\xb4\xc6\xee\xb4\xb3\x22\xeb\x70\x3b\x06\x95\x2e\x7a\x32\x2f\x71\x16\x83\xde\x6c\x15\x58\x56\x12\x78\x93\xd3\x5c\xc2\x87\x83\xbc\x4b\xe4\xf4\x06\xb3\x55\xe4\x38\x89\xb3\x1a\x7d\x0c\xf6\xfd\xca\x29\x28\xcf\xe5\xcc\x56\xa8\x5c\x09\x59\x34\x11\x46\xa3\x68\x14\x04\xe2\x48\x5a\xd0\xc9\x3a\xcb\xd1\xb4\x0e\x0b\xb1\x9c\xf0\xb8\xb8\x1f\xe1\xcd\x16\xa0\x99\xac\x5e\xa7\x57\x07\x38\x52\x78\x0b\xbd\xbe\x19\x80\xe5\x2b\x47\x57\x37\xcd\x2d\xbf\x6a\x23\x35\xcd\xb7\x3b\xdc\xdf\xb0\x6e\xcb\x42\xc6\x08\xc8\xe1\x44\xc9\x4d\x37\xdd\x18\x8d\x76\xe1\xe7\x7d\x9f\x7e\x15\x4c\x62\x5e\x85\xaa\x1d\x90\xcd\x3a\xe8\x69\x19\x8a\x22\x8f\xa4\x61\xfe\x33\x53\xbd\x4a\xf6\xfb\xf8\x11\xe8\x09\x61\x04\x23\x08\x26\x3d\xa0\x54\x83\xeb\x9f\xad\x64\xbe\xf5\xe1\x06\xf5\x9c\xe0\x84\xcf\xa0\xf4\x14\x90\x19\x70\x24\xcd\x68\x9f\x01\x69\x7d\x0d\x7e\x48\x12\xdf\xca\x03\x73\xa6\x30\x98\xa4\x54\x3f\x50\xf9\x2c\xb8\x9e\x7e\xf5\x43\xdf\x45\x9f\xe1\x91\x4d\x04\x45\xe9\x19\x48\x05\x03\xce\x81\x7e\xa8\x33\xe5\x19\x1a\xa2\x71\x48\x84\x13\x4c\xaa\x7c\x56\xd9\x06\x5e\x7f\x80\x7e\xf5\xd8\x86\x0f\x2f\xf3\xfb\x3a\x28\x34\x94\xc6\xc1\xdf\xff\x51\xf6\xf7\x11\xfa\x61\x03\x7a\xfe\xb6\x67\x2b\x1f\x00\xaf\x33\xf3\x8f\xf9\x26\xfc\xbe\x11\xe3\x75\x32\x26\xd2\x60\x60\xf6\xea\x29\xa4\xb5\xfd\xb8\x32\xf0\xfc\x08\x65\x22\x2a\x1b\xd1\x38\x83\x18\x29\x46\x94\xdc\xa9\x7c\xf1\x40\xe5\x9d\x40\x07\x89\xd9\xb2\xe5\x43\x1f\xfc\x3b\xe1\xf3\xa2\xb2\x15\x86\x49\x13\xa9\xd3\x19\xf7\xea\x61\x71\x8f\x3f\x30\x95\xfb\x40\x55\xb8\xc5\x88\x32\x46\x95\xef\x17\x77\x42\xe2\x74\x77\x22\x11\x6f\xd9\xe2\x83\x7f\xa1\x2e\xcb\x50\x97\x5f\xbc\xf0\x73\xc2\x0e\x73\x67\x81\x65\x18\xd1\x64\x92\x68\x96\x85\xfa\xc3\x98\x4c\x06\x1f\xfe\xc4\xf7\x5f\xc2\x78\xb4\x20\x93\xe6\x39\xd1\x49\x50\x29\x1f\x91\xab\x19\x48\x0f\xc6\x02\xb3\xdd\xab\x94\x0f\xfb\xfb\xbf\xa9\x0b\xef\x2b\x36\xbd\x36\xcd\x61\xfe\x1d\x1f\x08\xf0\xa0\x44\xf0\xf5\x05\xdb\x4e\xab\xf5\xfc\x41\x9a\x27\xb6\x33\xa7\xd0\x5d\xc0\xb2\x09\xf5\x5f\x18\xa8\x3b\x06\x9a\xa8\xfa\x51\x53\xee\x01\x22\xba\xd1\x2c\x5e\xd7\x90\xda\x7e\xfc\xb8\xf7\xbd\xf7\xbc\xcc\xd5\x5f\xbb\x2b\xbe\xfd\xc4\x76\x82\x54\x1e\x55\xba\xc0\xf0\x85\x1f\xc3\xdf\xe7\x89\xa4\xec\xb0\x70\x1c\x69\x64\xf4\x7a\x1b\x54\x68\x1d\xc3\x01\x0a\xfe\x31\xda\x88\xaa\x1f\xab\xf7\xe7\x27\x53\x39\x6f\xa0\xba\xaa\x28\x22\xb8\x21\x25\x15\xa7\x9c\x12\x12\x4d\xfc\xdd\x13\xdb\xe3\xf0\xd3\xc7\xe7\xa1\x07\x1d\x3f\xae\x1c\x45\x5f\xbd\xcb\xe0\xd3\xe2\x77\x7d\x8d\xc0\xf7\x02\x22\x08\xa1\x73\x4c\xaf\x10\x23\x8a\x08\x82\xd7\x93\x1f\x91\x5f\x87\xff\x81\x7b\x9c\x22\xcf\x5d\x78\xe1\x8c\x5b\xa4\x8c\xc5\xa0\x1c\xf9\x06\xf8\xb3\xbd\x4a\x17\xb5\x91\x7a\x01\xfe\x6c\xa7\xfa\xb3\xe0\xe9\xec\xcf\xfe\xfc\x4c\x22\x66\xd1\xe5\x7e\xb6\xf9\xc2\x17\xf4\x5f\x74\xa7\xe0\xcf\x16\xe3\x9f\xbd\x03\xc4\xa0\x66\x4b\x67\xa8\x32\x26\x46\x9d\xbb\xf0\xd1\x99\xff\x8f\xba\x37\x81\x6f\xaa\x4a\xff\x87\xcf\xb9\x4b\xf6\x34\xfb\x9e\x34\x49\x93\x26\x6d\xd3\x36\x6d\xd2\x15\x28\x0d\x50\x6a\x41\x96\x52\x16\x89\x2c\x2d\x0c\xa2\x22\x2a\x8b\xe2\x38\x8a\xa0\xe2\xc2\xa0\xb8\x2f\x83\x08\x88\xe8\xa8\x3f\x04\x06\x23\x6e\xa3\xa2\x03\x8e\x8e\x30\xea\xb8\xcc\x38\xea\xa8\x08\xb3\xe9\x08\x23\x8c\xe3\x28\xbd\x7d\xcf\x72\xef\xcd\x4d\x5a\xe0\xf7\x9f\xf7\xf3\x7e\x3e\xef\xbf\x85\xde\x24\xf7\x7b\x9e\xe7\x2c\xcf\x76\x9e\x73\x73\x4e\x4d\xdc\x5d\x86\xe1\x00\xfd\xa3\xe7\x7e\xe2\xef\x2d\x21\xfc\x58\x8a\x07\xaf\x23\xda\x9a\xa7\x98\xb0\x25\x86\x21\x84\xa6\xf0\x24\xf7\x0d\xdf\x26\xd3\x3c\xc2\x6c\x42\x18\xfd\x1e\x56\x2d\x13\xa3\xe7\x30\x0a\x4f\x16\xd0\x3a\x02\xff\x43\x70\x4c\x30\x5a\x5a\xe2\xca\xe3\x86\x0f\x58\x0a\xe8\x1d\x67\xf0\x06\xaf\x25\xcf\x01\x76\xe0\xab\x5c\x45\x15\x25\x49\xea\x66\x29\xa0\x77\x1c\x7e\x42\xe9\x71\xc1\xb0\x92\xde\x34\x61\x02\x77\x44\xf5\x27\x84\x8b\xa1\x6e\x89\x83\x9f\xc0\x27\x31\x1e\xac\x80\x6f\xa0\xb6\xa3\xb6\xd4\xf3\x72\x5b\x26\x09\x13\xd8\x49\xfc\xed\x08\xdb\x49\xb0\x2b\xc0\xef\xd0\x55\x0d\x7e\x02\x76\x8b\x75\x3b\xc9\x5f\x4e\xfa\x2f\x2e\xf6\xdf\x05\xa4\xff\x18\x1f\x1f\x43\xdd\xfd\xd7\x5c\xa9\xdb\x65\x54\xf4\xdf\x78\xd4\x7f\x7f\x21\x75\x3c\x0b\xd1\x51\x31\x0f\x74\xff\x5b\xea\x33\xfe\x72\xd2\xc6\xb8\xd8\x67\xcf\xd3\x36\x32\x03\x87\x64\x1a\xb8\x3c\xea\x33\xb9\x3c\xe9\xb3\x77\x25\xdc\xf3\xb9\x68\x29\x67\x15\x71\xa8\xcf\x0a\xe8\x1d\x67\xee\x96\x70\xbf\xcc\x79\x7c\x79\x7a\xa8\xcf\x94\xf4\x8e\x33\x7a\x09\x77\x3c\x17\x0c\xe7\xe9\x09\x5c\x01\xbd\xbf\x32\xaf\x49\xb8\xaf\x73\x7e\x65\xfd\xb8\x02\x7a\x7f\x65\x02\xe2\x18\x94\x89\x95\x13\xc7\x14\xc9\xb3\x92\xde\x51\x66\xaf\x44\xef\xaf\x39\x4f\x40\x41\x6f\x6c\x01\xbd\xa3\x50\x90\x70\x7f\xce\x05\x23\xf9\xfa\x01\xc0\xad\x54\x87\x11\xae\x02\xe3\xb4\xaf\x30\x78\xd3\x7c\x57\xc6\xc8\xc0\x20\x1a\x09\x08\x02\x41\x9f\x87\x8a\x3d\x11\x7d\x5c\x87\x6e\x7c\x8e\xbb\x6a\x19\x2a\xd3\x45\xc6\x76\x0c\x58\x07\x0e\x99\xd5\xcc\x3a\x70\xd3\xc0\xa1\x21\x68\xbe\xfa\x5f\xd0\x5c\x01\x1e\x2f\xa4\x89\x9c\xe6\x4a\xd2\xee\x0a\xb1\xdd\x57\x91\xfe\x81\xc1\x40\x98\x12\x13\xe9\xa0\x76\x77\xb2\xfb\x29\x1d\xd2\xee\x8f\x68\x3f\x9a\x4b\xcb\x4c\x0e\x65\x3f\x5e\x53\x40\xef\x1b\x66\x35\xa5\x17\x8d\xd5\x17\xd2\xbb\xa6\x80\xde\x37\xf0\x33\x4a\xcf\x11\x4f\x15\xd2\x9b\xc0\xad\x54\x21\x1c\xfc\x3b\xc1\x6d\x80\x7e\x24\xcf\xb6\x8c\x1e\x22\xa5\x80\xf6\x86\x11\xde\xa4\x24\xcd\x22\xdd\x09\x6c\x27\x7f\x05\xc2\x7f\x89\xf0\x2a\x66\xc3\x35\x00\xa3\x99\x7a\x4b\x8c\x51\x37\x8c\x88\x54\x2a\x64\x1f\xf7\x67\x25\xd1\x95\x4a\x51\x57\x34\x22\x6d\xa4\x2c\xb0\xa6\xd4\xad\xd5\x17\xd0\x6e\xc7\xfb\x41\xa9\xf6\x22\xfc\x38\xd1\xd6\x6c\x83\x97\x11\x3c\x5e\x69\xbe\xa9\xcc\xcf\xe8\x0a\xf0\xd3\x06\xbe\xe2\x6f\x52\xd5\x21\x7c\x15\xc1\xaf\x83\xaf\x88\xf4\xa3\x88\x7e\x45\x59\x54\x15\x2c\xc0\xcf\x14\x3a\xd9\x0f\xb9\x43\x08\x3f\x9e\xe2\xc1\xb3\xe8\x06\xb2\x7d\x1d\x16\x6c\xfb\xfe\x95\x1b\xdd\x61\x37\x16\xd6\x9f\x5f\x47\xea\x9f\x10\xeb\xff\x53\xa2\xeb\x58\x1a\xe0\xb3\x03\x03\xb9\x32\x3f\x6f\x53\xe0\xed\x28\x88\x3c\x42\xf0\x67\x8b\x78\x95\x58\x1f\x7c\x32\xc1\xbc\x68\xa9\xbf\xb0\xbd\xd8\x06\xac\x23\x63\x99\x10\x6d\xc0\x17\x74\x2c\x81\x4c\x58\xf4\x05\x4f\xb2\x47\x88\x4e\x9c\x2d\xe2\x78\x8a\xd3\xc8\x24\x41\xbe\xbe\xb3\x25\x7a\x60\x11\xbc\x15\xf1\xf7\xec\x61\x60\x02\x8b\x2f\xae\x71\xad\x48\x98\x4a\xb0\x5c\xe7\x6b\x25\xda\x60\x11\x78\x1d\x2e\xa7\x32\x8f\xd3\x37\x30\x54\x27\xb2\x90\x64\x9e\x3c\x67\x38\x01\xd7\x1b\xd4\x81\x5c\x26\x14\x57\xa9\x3c\x56\x63\x05\xcb\x1a\x43\xc9\x50\xb2\x3e\x65\x4f\x5d\x96\x62\x4e\xa4\xe0\x7b\xa9\xc3\xa9\x13\x29\x36\xf5\xec\xc0\xde\xa7\x86\xb5\x75\xe1\x6b\x66\x6c\xbc\xaa\xeb\xf6\x14\x64\x40\x2a\x94\xea\x4e\xad\x4e\x71\x25\x6c\x9c\xef\xcb\x9a\xe2\xed\xf1\xc9\x71\x56\xcf\xc6\xe3\xa5\x91\xda\xca\x58\x38\x12\xee\xcd\x26\x22\x6c\x32\x14\xd2\xcd\x47\x81\x4f\xa8\x34\xd4\x9b\xd5\xc2\x52\xab\xd9\xd9\x9b\x35\xfb\xc4\xef\x04\xe7\xbf\x03\xac\x38\x39\x5d\x7c\x4a\x11\x9f\x16\xdb\x3b\x27\x91\x98\xb3\x74\x99\xf8\xb0\x84\xb8\xb6\x20\x7f\x69\x1e\x3f\x92\x14\x91\xce\xcc\x8a\x37\xca\x8f\x2f\x36\x47\x06\x1f\x1e\xc8\xaf\xeb\xff\xeb\xf6\xfe\xb5\xdb\xff\x5c\x32\xeb\xfc\x75\x8b\x27\x8c\x74\x4e\x70\x8e\x68\xea\xee\x8a\x7e\xbc\x7d\x3b\xe3\xd9\xce\x5c\xb1\x9d\x71\x6f\xdf\xde\xe8\x63\x1a\xfb\xdf\xf4\x35\x66\xb4\x33\xc7\xcd\xbe\xc4\x39\x5e\xad\x1d\x5e\x53\x3f\x52\x75\x53\xa3\x8f\xdb\xe4\x6d\x6c\xf4\xf6\xff\x93\x31\xe1\xeb\x0f\xf3\xc9\x1a\x92\x1d\xe9\x11\x1a\x53\x90\x02\x0f\xa3\x3e\xd4\x68\x7c\x76\x13\x63\x2a\xab\x2b\xab\x4b\x37\x80\x86\x50\xc3\x67\x0d\xec\xd8\xba\x86\xd5\x0d\x5b\x1a\x76\x35\x70\x0d\xb8\xef\x1c\x89\xba\xae\x97\x1b\xe0\x96\x06\x08\x1a\xcc\x04\xc1\x99\x58\x7c\xe7\xa9\x60\x59\x17\x41\xc4\x6c\xce\xae\x6a\xbe\x27\x5b\x6d\x2e\x8f\x4c\xce\x96\x83\xba\xb2\x32\x43\x4f\x56\xc3\x94\x85\xca\x26\x67\xf5\x20\xe4\xb0\xba\xbb\xb3\xd6\xa1\xba\x8f\x3c\x97\x06\x13\x09\xd4\x6b\x4b\x97\x26\x96\x89\x67\x1b\x5b\xf3\xab\x50\xca\x05\xa7\xd3\x74\x9a\x45\xb1\x13\x03\xd3\xbd\xf2\xd1\xb9\xd7\xaf\xfa\x9f\xa2\x3e\xdb\x70\xc5\x2d\x30\x25\x6e\xb8\x90\xdf\x3d\xa1\xb8\xd3\xe8\x97\xf2\x84\x0b\xf3\x3b\x2d\x50\x7d\x99\x5d\xa0\x2f\xc7\x98\x43\xd4\x37\x40\x24\xd9\xc1\x38\x95\x6c\xa2\x2f\xb3\x0b\xf4\xe5\x18\xf1\x71\x48\x5f\x4a\xc2\x95\x4a\x7d\x71\x0a\xd7\x30\x9b\x08\xbd\x6a\xd1\x46\x9e\x4b\x71\x9c\x33\xac\xd1\xc9\xb8\x81\x0f\x11\x6e\x1e\x3f\x01\xe1\x26\x88\xb8\x80\xe4\x93\x06\x72\xa1\x84\xb9\x44\xf2\x5d\xc8\x7e\xcd\x57\x3b\x25\x7a\xda\x5a\x38\x03\xc6\x80\x2f\x63\x62\x19\x18\x47\xe1\x15\xf2\x20\xd6\x28\x25\x4c\xd5\x49\xa4\x8f\x22\x19\x66\x18\xf1\x21\xc7\x91\x0f\x89\x81\x45\x7b\x91\x07\x41\x9e\x84\x07\x87\x64\xbd\xde\x4d\xe2\x97\x5a\x31\x6e\xd9\x26\xda\x15\x6c\x88\x9c\xbe\x52\xab\xaa\xc0\xae\xc4\xf1\x79\xd7\xc4\x8f\x4d\xa2\x78\xf0\x27\x78\x87\x6c\x47\xd3\xbe\x52\xb7\x6e\x90\x1d\xda\x4d\xfa\xa1\x56\xb4\x2f\xdf\xe6\xfb\x35\xe4\xa5\xd4\x31\x5d\x14\xe7\x01\xd2\xaf\x93\x44\x9c\x87\xf6\x17\x1f\xf2\xba\x75\x05\xf1\x5b\x01\xbd\xe3\xcc\xf7\x14\xc7\xfa\x02\x62\x55\x69\x3d\x51\x9c\xa7\xa4\x77\x5c\xa6\xe7\x0b\x14\xd0\x43\x7c\x2f\x20\xf4\x92\x22\xdf\x8b\x28\xce\xe3\x34\x97\xa8\xf3\xb8\x4a\xe1\x49\xfc\x3d\x52\x84\x9b\x2c\xc6\x4a\xfe\x7c\x3b\xcc\x3a\x0d\x23\xc7\x36\x88\x1e\xf1\x1b\x49\xec\xb3\x29\x3d\xe2\x3f\x5c\x34\x1e\xf4\xcb\xf1\xe0\xc0\xdb\x88\x66\x87\x6a\x39\xa5\x89\xb0\xeb\x06\x9e\x86\x77\xc8\xb4\x35\x4f\x41\x1d\x93\x8f\x83\x51\x7b\x94\xf5\x3c\xce\x9c\x4f\xeb\xe9\xb0\xd8\x14\xf5\x1c\x38\x3c\x60\x61\x66\x2a\xea\x79\x1c\x96\x52\x1c\xd4\x1b\x69\x25\xe5\x98\xa9\x80\xde\x51\x12\xd3\x21\xdc\x68\x8b\x43\x49\xef\x0f\xc2\x58\xa6\x4f\x41\xef\x28\xa9\x1b\xf6\x23\x7a\x53\x01\x3d\x00\x54\x9f\x13\x39\xaa\xa3\x72\xc1\x8c\x13\xe5\xa8\x14\xc9\x51\xc4\x1b\xd0\xdb\x0b\xe4\x02\x69\x99\xca\x43\x62\xe1\x6e\x11\x8f\xed\x3f\xc6\x37\x5b\x62\xb0\x33\xdd\x54\x57\x52\x28\x47\x84\xfe\x06\x89\x3e\xf3\x00\x53\x43\xfd\xa5\x9f\xf8\xcb\x7f\xe7\x82\x9e\x3c\x07\x99\xfe\x04\x89\x3e\xf2\x97\xaf\x13\x7f\x0c\x1b\x2d\x18\x2f\xe4\x5a\x52\x79\x0e\x74\xdc\x54\x9f\x93\xfe\xa0\xf4\x8f\xb0\x13\xa4\xf1\x7d\x49\xa6\x8d\xe9\x22\x9c\x87\xc4\x3e\xdd\x22\x2e\x24\xe1\xf2\x34\x45\xbd\xba\x9f\xd4\xb7\x5e\xe4\xff\x90\xd8\x1f\x2e\x54\x61\x93\xd7\x6e\xe1\x0a\xda\x87\x46\x81\xfd\x9c\xd4\x77\x8a\x18\x9f\x3c\x4c\xeb\x1b\x22\xf5\x3d\x9e\x8b\x04\x7c\xda\xc2\xfa\xf2\xf7\x93\xfa\xd6\x2b\xfc\x3b\xa9\xc7\x7f\x72\x12\x75\x4c\x17\xf9\xf7\xcf\x49\x7d\xa7\x88\x38\x8d\x38\x7e\x32\x41\x59\xaf\x94\xf4\x8e\x33\x47\x45\x7d\x71\xb8\xc4\xaa\xd2\x7a\xa2\x18\x5f\x49\xef\x38\xa3\xa3\x38\xa6\x34\x54\x40\x0f\xc5\xe4\x4a\x7a\x47\x99\xc3\x52\xfd\x7e\xc8\x39\x3c\x8a\xfa\x8d\x2d\xa0\x77\x94\xd1\x8a\xf2\x5a\x5a\xa6\xa4\x87\xe3\xb1\xe5\xc4\xee\xa4\x88\xfd\xfb\x15\xa1\x87\x62\x09\x96\x89\x61\xf3\x07\x5c\x11\x83\xa5\x28\x7e\x9e\x84\xe7\x97\xaa\xb7\x51\x99\x1e\xa2\x5f\x9b\xc0\x13\x03\xbf\xc5\xd6\x0f\x32\x30\x33\x04\xcd\x7d\x84\x26\xb2\xa9\x1c\x21\xca\x29\xa9\x2a\x6c\xaa\x48\x77\xd2\x20\xba\x8b\xc0\xf6\x21\xe9\xbe\x42\xc6\x86\xd4\xd5\x4b\xea\xea\xf6\x9e\xa2\xae\x2b\x24\x9a\x68\xfe\x70\x23\xf8\x33\x89\xf5\xb7\x93\x58\xbf\x98\xe6\xab\xff\x05\xcd\x15\xe0\x40\x01\x4d\x1c\x43\x87\x89\xce\xa6\x45\x5b\xfe\x03\x95\x51\x06\xe9\x2c\xd3\xe8\x0d\x58\x1d\x05\x32\x8a\xf7\xd2\xd9\x45\x74\x76\xaa\x88\x7f\x8f\xea\x2c\x13\x47\x11\xfa\xb4\x48\xcc\xa9\x2b\xd6\x59\x44\x7f\x83\x44\x1f\xe9\x00\x27\xd2\x47\x4a\xcb\xd4\x04\x3d\x43\xd2\x9f\x20\xd1\x47\x3a\x90\x13\xe9\x97\x23\xfa\x91\x8a\xb2\xc1\xf4\xf9\xa9\x84\x7e\xa3\x48\xdf\x4f\xe7\xcb\x65\x64\xbe\xfc\x64\xae\x3c\xa8\x55\xc6\xd0\x95\x78\x8f\x45\x42\x7f\x3a\x99\x5f\x3c\x90\xa2\x16\xc7\x8d\x54\xac\xd2\xe7\x30\xc1\x22\xfd\x9a\x4a\xe4\xb7\x51\xd4\x9b\xb7\xe8\x1c\x47\x2d\x13\x95\xfd\xc2\xfd\x44\x7e\xa7\x53\x1c\xf6\xb3\x54\xce\xef\xcc\x49\x34\x25\x7a\xc4\x2f\x34\x8a\x7e\xe1\x2d\xd1\x2f\x84\x89\x5f\x60\x13\xf9\x3c\x41\x14\xd3\x24\x73\x89\xe9\x14\x4b\x7c\xb7\x8a\x59\xa7\xcd\xeb\xaa\xb2\x6e\xc7\x99\x9f\x4a\x31\xc3\xaf\x72\xa1\x32\xad\x14\xab\x44\x90\x2f\x50\xd6\xed\x38\x9c\x23\xd5\xad\x3f\xe7\x74\xcb\x75\x5b\x8b\xe4\xe4\x04\xe9\xc7\x26\xb1\xdf\xbf\x54\xcc\xd3\xb8\x86\x5a\x4b\xbc\x78\x6e\xc4\xbc\x4b\xfa\x71\x06\xed\xc7\x26\x62\xa9\xaa\x89\xa5\xfa\x3e\x97\xac\xb4\x83\x02\xfc\x5a\x64\x83\x4e\x10\x7c\x93\xd8\x97\x15\x52\x3d\xfe\x96\x93\xa8\x93\x5c\xca\x93\xf8\x7b\xd4\x22\x5d\xec\x07\xaf\x94\x70\x47\x64\xaa\x52\x7d\xd5\x21\x89\x9e\x76\x3f\xd3\x81\xac\x31\x99\x57\xb4\xe3\xc9\x48\xb6\x61\x24\xa5\xa9\xd0\x05\x5c\xe7\x8f\xf9\x8d\x12\x6d\xed\x7e\x78\xbd\x70\x80\x96\x19\x86\x84\x0b\x8e\x49\xb6\x52\xfa\x8a\x32\x94\x8f\x41\xe6\xf3\x1a\xe2\x23\xce\xd9\x33\x98\x0f\x3f\x7a\x68\x3e\xef\xf2\x47\x64\x3e\xaf\xc1\xad\xc2\x87\xb4\xcc\x70\xcc\xa7\xa4\x6d\x08\x3e\xb8\x7f\xa4\xfe\x27\xb2\x51\xa1\x18\x07\x14\x33\xb4\xe5\x65\x83\xf4\x91\xd4\xf7\xe6\x18\xee\x7b\xb3\xd4\x53\xf8\x7e\x39\xd2\xb9\x57\x08\xad\x66\x85\x4e\x10\x29\x47\x63\x09\x7c\x8e\xa2\x79\xb1\x1d\xef\xf7\xa8\x62\x10\xfe\x1c\x8a\x1f\xd8\x0b\xf6\xd0\x3e\xff\x77\x2e\xe0\x52\x49\x7e\xaf\x1c\xc5\x35\xaf\x10\x99\x6b\x16\xc7\xf0\x32\xd1\x8f\xc8\x24\xa5\xf9\x24\xde\x3f\x52\xa6\x77\x04\xce\xa0\xb8\x46\x89\x98\x58\x4f\x14\xcf\x28\xe9\x1d\x67\x2e\x17\xfd\x88\xd3\xad\xa0\x37\x70\x12\xc9\xf0\x12\x05\xbd\xe3\xb0\x49\x8c\x7b\xdc\xde\x02\x7a\x28\x9e\x51\xd2\x3b\x2a\xd5\x0f\x3a\xbd\xca\xfa\xa9\x50\x3c\xb3\x5e\x41\xef\x28\x1c\x4f\x71\x95\x6e\xbf\x92\x5e\x42\x78\x84\xdf\x48\xe8\xb5\x10\xdc\x9f\x89\xbd\x35\x3e\x83\xe2\xec\x84\xc7\xc4\xd1\x11\x44\x38\x9f\xf0\x08\xfb\x09\xbb\x1d\xe1\x66\x8a\xb8\x12\x11\x67\xad\x74\x39\xf4\x32\x2e\x21\x5c\x53\x40\xef\x1b\x79\x3e\x1e\xa9\x35\x29\xfc\xab\x4f\xb8\xa6\x80\xde\x37\x92\x7f\x2d\x09\x57\x3b\xf4\xca\xfa\x8d\x2d\xa0\x77\x14\x59\x09\xda\x5e\x6f\x69\x21\xbd\xb1\x05\xf4\x8e\x32\x06\x8a\x33\xbb\xfd\x05\xf4\x90\x7f\xd9\x48\xfc\x4b\x0b\xf5\xaf\xac\x4e\x92\xf5\x0a\x2c\xeb\x31\x4f\xb9\xd4\x6a\x59\x6e\x7d\x48\x3f\x3e\x51\xfd\x91\xd2\x96\xfc\x20\xf1\x0b\x5b\x51\xaf\x96\x3c\x03\xdf\x72\xc1\x5d\x2e\xe8\x02\x96\x39\x73\x1a\x87\xe0\xf1\x6b\xc2\x83\xce\x61\xfc\x64\x0e\x13\xf3\xfa\x45\x2e\x4a\x7f\x4b\xf8\xf0\x27\x64\x3e\xeb\xc0\x63\x84\xcf\x22\xf0\x04\xf8\x33\x96\x6d\x96\xd9\x59\x0a\x4b\x33\x5a\x63\x57\x29\xb0\x24\xe6\x48\xe5\x5c\x03\x9f\xf3\xbb\x54\xbb\x51\xb9\x56\xd2\xf6\x4d\xf0\x97\xa2\x2e\x98\x90\x2e\xd4\x7a\xa2\x6a\x58\xa0\x0b\x60\xe0\x2b\x34\x67\x58\x80\xf0\x59\x8a\x07\xbf\x17\x63\x52\x13\x32\x6d\x35\x9e\x28\x67\x2c\xc0\xbb\x90\x4d\xdf\x45\xc6\xa0\x55\xd4\x89\xbf\x49\x31\x93\x49\x24\x2d\xe5\xa6\xf1\xde\x02\x32\x5d\x39\x06\x53\x3b\x4c\x22\x49\x82\x63\x06\x3e\x57\xaf\x25\xfe\x78\x18\xf1\xaf\x63\x98\xeb\x51\x7d\xad\x88\x3f\x72\xf1\x48\x90\x3d\x2a\x6b\x39\x61\x4f\xb0\x5f\xf1\x2f\x11\x5f\x7c\x2e\xc5\xc2\x9b\xb0\xdc\x61\xbd\xfd\x32\x27\x21\x87\xa0\xb9\x82\xf9\xb5\x82\xe6\x22\x87\xfb\x34\x34\x57\x40\x2c\xa3\xba\x3d\xf0\x22\x11\x26\xd3\x9b\x2d\xd3\x5b\xc4\x6c\x44\xf4\x9c\x58\x4e\xdc\x58\x4e\x12\x71\x07\x81\x92\xf1\x93\x69\x96\xc8\x34\x17\xc1\xdd\x88\xa6\x01\xe9\x47\x4c\x46\xe6\xeb\xb9\x41\xa2\x8b\xe2\xfb\x8d\x0a\xbb\x55\xeb\x73\xa8\x6d\x05\x7d\x4f\xe9\x4e\x90\xe8\x22\x3b\xb7\x07\xe4\xbd\x79\xcd\x60\xbc\xf0\xa4\x7a\x2d\x19\xab\x61\x62\xdc\xfe\x5b\x31\xcf\x25\x43\x25\x1c\xff\x12\x19\xab\x73\xc5\xb1\xfa\xb3\x34\x6f\x2c\xc0\xd5\xa0\xd8\x63\x2b\xa9\xef\x70\x91\xff\xcf\x15\xf3\x66\x57\x99\x9f\x73\x15\xf0\xb7\xa2\xf8\xfe\x2f\xa4\xbe\xb3\x0a\x63\x1b\x18\x44\xf5\x35\x95\xf9\x75\x85\xb2\x48\xe9\xcf\x96\xe8\xa3\x7e\xc3\xf4\x89\x3e\x92\x84\x9b\xbd\x56\xe4\xa0\xd0\x47\xca\xa3\x44\xe2\x81\xf4\x23\x27\xe9\x70\x02\xfb\x1e\x43\xad\xc8\x45\x51\xc6\x85\xf8\xdc\x45\xda\x31\x42\x6c\xc7\x36\x45\xbf\xc7\x7c\x0e\x5d\x61\x3f\x7a\x84\x4e\xf6\x3b\xd2\x8e\xd9\x62\x3b\x3e\x16\xdb\x81\x27\x2a\x89\x48\xa0\xa4\xb0\xdd\xf3\x91\x3f\x5a\xae\xfa\x14\xe1\xdb\x08\xfe\x66\x12\xef\x48\x79\x5a\x83\xdd\x6d\x35\x17\xe0\xc9\x3e\xbd\xfc\x1d\x08\x3f\x87\xc4\x16\x37\x2f\xa7\xd4\xfd\x88\x3a\xeb\xf0\x40\xab\x22\x46\x9b\x8f\xf4\x6a\x39\x19\xd3\x36\x71\xac\x46\x4b\xf1\xc2\xef\x73\x1e\x1b\xa5\x8c\x69\x22\xff\x3a\x8d\x8c\xe9\x1c\xd1\x27\xfd\x52\xc2\x7d\x8b\xe6\x4a\x50\xca\xfb\xcf\x47\x3e\x49\x49\xef\x38\xb3\x58\xb4\xa9\x76\xa7\x58\x4d\x5a\x47\x34\x07\x52\xd2\x3b\x0e\x5f\x96\xe8\x7d\x9f\x73\xb8\x64\x7a\x76\x84\x53\xe6\x8a\x8e\xcb\xb9\xa2\x60\x58\x99\x2b\x52\x21\x1f\x5c\xcf\xef\x93\x7c\x12\x58\x34\xf0\x6b\xe4\x83\xcd\xbf\xc0\x69\xd5\x1f\x72\x95\xa2\xdf\x6c\x54\xc8\xfd\x9b\xb2\x7c\x6e\x84\xcf\x4a\x63\xec\xc6\x63\x5c\x2d\x89\xa9\x62\x8c\xe9\x98\x1d\x94\xc7\x6c\x23\xf8\x04\x30\xb4\x4c\x08\x97\xa9\x90\x46\x4d\x51\xa6\x0b\xd9\xdc\xa5\x84\x0f\x5d\xf7\x5b\x0d\xd6\x8a\xb1\x78\x1d\x2a\xc2\xd6\xd7\x18\x0a\xf3\x42\x68\x96\xc7\xdc\xa0\x7a\xcf\x1a\x83\xa3\x44\xb9\xd8\x0c\x6f\xa6\xf3\x5d\x26\x06\x1f\xf0\xda\x39\x43\x1e\x8f\x9f\x73\x1f\xf8\x17\x7f\x16\x3f\x05\xc5\xe4\x33\x32\xd5\x51\xbd\xde\xe9\x2c\x09\xab\xc3\x9e\xb8\x27\x5e\x95\x88\xea\x75\x7a\x5d\x5f\x56\xaf\x0f\x80\x80\xa5\x2f\x1b\xe0\x5c\x9e\xde\xac\xcb\x0a\xf8\xbe\x2c\xb0\x81\xe2\x6d\x2f\x94\x5f\x1b\x27\x8f\x70\xd2\x07\x25\xf8\x32\xfc\xac\x0b\xf9\x9a\x6e\x5c\xdc\x97\xad\x04\x3a\x2c\x24\xdb\x08\xd2\x29\x92\x68\xa4\xe9\x46\x76\xe6\x9d\xcb\x56\xaf\x81\xa1\x5f\xbd\x0e\x6f\xbb\x7f\xcb\x4d\xf3\xee\x9f\x2e\xdc\xb5\x1d\xba\xff\x73\xff\xe1\x15\x77\x5c\xff\x8b\xdf\x7c\xaf\x6f\x1e\x17\x83\xc1\x3b\xd7\x9f\x7b\xf3\xcd\xcb\x6f\xe9\xdd\x75\xd9\xc9\x5b\x1a\x7d\x8c\x70\x02\x9a\xa6\xde\xbf\x60\xc5\xa3\x7e\xeb\x2f\xd7\x3d\xbb\x4f\x8a\x7d\x0a\xd6\x55\x15\xeb\x6e\xef\xc9\xcb\xaa\xb8\x6f\x91\x3c\x2a\xd7\x54\x8f\xc0\xed\x12\xee\x2d\x79\x49\x95\xe6\xcf\xf9\x67\x55\xbf\x93\xe8\x69\xff\xc3\x7c\xaa\x98\x3f\x01\x9b\x9b\xd5\x16\x8c\x01\x1d\xb3\x85\x12\x5d\xed\x7f\xe0\xe7\x03\x87\x08\x3e\x89\xc6\x4c\x1f\x4b\x14\x8d\x19\xa1\xaf\xf6\xc8\xf4\x7f\x60\x7e\x45\x6c\xb9\x81\x65\x3c\x3c\x9a\x52\x7a\x4a\x59\x0d\x15\x8b\x76\x62\xcb\x31\xfd\x57\xf2\x32\xa1\xfd\x01\x1e\x92\xe6\xa0\x0d\x16\xe4\xbe\xe7\xd4\x54\x48\xcb\xc1\xb2\x1c\x15\xf3\x38\x49\x78\x78\xf6\xb0\x4c\x18\x7b\xfc\x67\x07\x6e\xcc\xb9\xc2\xd2\x82\x33\x8d\x95\x06\x8e\x16\xca\x9e\xf6\x24\xc4\xb6\x1a\x97\x21\x6c\x9e\x1d\xd8\x90\xab\x6a\x50\x72\x92\xf9\x78\x65\x3e\xfd\x84\x0f\xa9\x9b\x0f\x33\xf2\xda\x0b\xb8\x28\xfa\xeb\x80\xcc\xa7\x9f\xe8\x31\x29\x53\x8b\x19\x85\xe2\x0d\xa7\x68\x8f\x4b\xe6\x23\x20\x3e\x71\x52\x37\x1f\x6d\xcf\xa7\xb9\x58\x7d\x61\x7b\x44\x3e\xc7\x64\x3e\x02\x7c\x5f\x6c\x4f\x2d\x6d\xcf\x0f\xb9\xd6\x8e\xe2\xf6\x60\x59\x22\x76\x33\x2a\xce\x09\x9e\x17\xed\xe7\x95\x74\xbe\x18\xcc\xcf\x09\x88\x3c\x11\x9b\xd9\x41\xe6\x04\x37\xaf\xa4\x73\x82\xed\x60\xe8\x31\x18\x60\x0e\x8a\x63\xe0\xa1\x75\xfe\x4b\xce\x1f\x1d\xb2\xce\xf9\x31\x18\x80\xaf\x89\x75\xae\xa6\x75\xfe\x7b\x2e\xd9\x3c\xe4\x18\xc8\x7c\x74\xe0\xff\x9c\x8f\x0e\xfc\xaf\xf9\xc8\x63\xad\x83\x32\x1f\x9b\xc4\xc7\x59\x3a\x24\x1f\x79\xac\x75\x50\xe6\x13\x93\xf8\x54\xd6\x0f\xc9\x27\x24\xf3\x61\x10\x9f\x3a\x52\xa6\x8a\xf2\xf9\x5b\x2e\x50\x71\xfa\xb1\xd6\x31\x70\x9f\xc8\xa7\x4d\xe2\x53\x37\x7c\xc8\xb1\xde\x3f\x68\xac\x37\x9c\x72\xac\xb3\xf2\x58\x6f\x58\x79\xa8\x60\xac\x71\xfe\x59\xb9\x86\x2b\xcf\xd3\x50\x48\x52\xb8\x86\xfb\x64\xc1\x1a\xee\x11\xf8\x0d\xcd\x6f\xc4\x22\x81\x82\x35\x5c\xbc\x6e\x4d\x6c\x50\x85\x68\x83\xae\x14\xfd\x77\x39\xf2\xdf\x51\xbf\xb4\xd0\x9c\x50\xae\x59\xf3\x6b\x24\xba\xc8\x06\x9d\x10\xfd\x06\xea\x67\xa6\x2e\x20\x2d\x38\x17\xd2\xdf\x2d\xd7\x77\x13\x0c\x88\xf4\x71\x62\xd7\x25\x2f\x3c\x17\xd2\x5f\x20\xd7\x7b\x93\xec\x97\x02\x88\xbe\x5d\x5e\x80\x2e\xa0\x4f\x64\xb2\x42\xb4\x71\xcb\xa5\x38\xaa\x0a\xc7\x51\x97\x44\x4a\x87\x5c\x77\x7f\x9e\xc8\x64\x97\x68\xe7\x3e\x92\xec\x42\x02\x0f\xe2\xf9\xd1\x20\xe5\xa2\x28\x53\xcc\xe7\x24\xe1\x83\xd7\x47\xab\xe8\xfa\xe8\xde\x5c\xa8\x4a\xc9\x89\xcc\x6d\x71\x5b\xf2\x7c\x4e\x12\x3e\x58\x56\x12\x54\x56\x9e\xcb\x85\x13\x4a\x4e\x32\x1f\xaf\xcc\xa7\x3f\xdf\x9e\x28\x66\x34\x2d\x50\x35\x64\x7b\x6e\x24\xb2\xdf\x25\xda\x39\xb9\x3d\xe5\x98\xd1\xc4\xd2\xc4\x29\xda\x33\x52\xe6\x23\x14\xf1\xf1\x24\x87\x0d\xfd\xbc\x02\x91\xfd\x2e\xd1\xce\x15\xf2\xb1\xd6\x0d\x1f\xcc\x07\xcb\x2b\xb1\x73\x15\x44\xf6\x6f\xc6\xe3\x2f\xcb\xad\xe6\x29\x98\x5f\x2f\xa1\x32\x4b\xec\x5c\x17\xc5\x82\x0d\x80\x5a\xba\x6f\xc8\x7d\xb2\x46\x46\x64\xb5\x5a\x94\xbd\x73\x45\x59\x72\x20\x59\xd2\x1b\x2c\x1a\x5d\xf1\x1a\x04\x63\x25\xfe\xf2\xb8\x88\xb7\x21\x7f\xe9\xc8\x41\x1b\xc9\x64\x9d\xcc\xe9\x4c\x1c\xa3\x88\x37\xc7\x0b\x4f\x32\xf3\x15\x6b\x7a\x47\xe0\x39\xe2\x1c\xde\x6a\x50\xac\xe9\xe1\x35\x02\x44\x37\xbf\xa6\x77\x04\xda\x25\xff\xfe\xaf\x9c\xdf\x29\xaf\xe9\x4d\x43\x7a\xbf\x9c\xe0\x52\xa2\xae\x1e\xa6\x3a\x08\x02\x2e\x9a\xcc\x05\xe2\x73\x43\x4f\xb2\xbb\x89\xae\xf6\x88\x38\x20\xe3\x78\x50\x94\x23\x27\xed\x4f\x89\xba\xda\x2f\xc6\x0b\x21\x34\x64\x21\x97\x5f\x24\x9a\x50\xe6\x87\x89\xae\xf6\x88\x78\x8f\xa8\x4b\x38\x2c\x44\x78\x1e\x14\xe7\xfd\xf8\xe5\x44\xc6\x53\xa2\x2e\xfd\x55\xf2\xb1\xe5\xd8\x20\xce\x2e\xf5\x0c\x99\x83\xfe\x8c\xc8\x78\x8f\x58\x06\x16\xc8\xc4\xcc\x52\x0f\x5f\x9c\x0f\x2b\xe6\x73\x92\xf0\xc1\x7a\x51\x4e\xed\xee\x93\x39\x5f\xb9\x92\x13\x2a\x53\x46\xda\x92\xe7\x73\x92\xf0\x21\x65\xa8\x2e\x3d\x81\xca\x28\x39\xc9\x7c\xbc\x32\x9f\xfe\x7c\x7b\x82\x98\xd1\x68\x77\xf9\xd0\x39\x75\xa2\x4b\x3d\x62\x19\xb9\x3d\x41\xcc\x68\xa4\xbb\xfc\x14\xed\x71\xc9\x7c\x04\xe6\x73\x14\x33\xe4\xf9\x80\xaa\xc6\x53\xf0\x39\x26\xf3\x11\x8a\xf8\xb0\x55\x8d\x83\xf9\x60\x79\x22\xba\x94\x12\xfd\xc8\x61\x31\x66\xc0\xcf\x6a\xe8\x72\x2c\x13\x21\xca\xd4\x28\xc9\x14\xd1\xa5\x1e\x51\x97\x1e\xa7\xba\xc4\xc8\x75\x56\x69\x71\xde\x00\xce\x17\x73\x01\xbf\xa7\xb9\xc8\xb8\xe2\x79\xb6\x81\xaf\xb8\x29\x38\x5f\x00\x7f\x44\x9e\x63\x5b\x01\xbe\x1b\xb2\xec\x18\x78\xe9\x19\xcb\x8e\x01\xd7\x29\xca\xfe\x4e\x2a\x2b\xca\x30\x2a\x5b\x57\x5c\x76\x0d\x2d\x4b\x30\x3e\x62\x2b\xf0\xd4\x44\xce\x93\x12\x3a\xbb\x25\x3a\xc8\xaf\xdc\x32\xf8\x79\x3c\x42\x67\x81\x54\x07\xe4\x4b\xb6\x4a\xfd\xa8\xd2\xf2\xcf\xc8\x65\x8f\x48\x6b\x57\xcc\xc0\xd3\xb9\x9a\xb8\x4e\xca\x43\xa3\x3e\xe4\xa6\x70\xb7\x4a\xf5\x10\xf5\x92\xe0\x76\x21\x9c\x16\xe4\xd7\x0c\x0b\x72\x75\x8a\xb5\xba\x81\x5c\x50\xcc\x26\x92\x5c\xdd\x93\x05\xb9\xba\x23\xd2\x5a\x98\x21\xe0\x1a\x94\xab\x23\x7a\x4e\xf3\x68\xff\x61\xa5\x67\x81\xca\x90\x9d\xab\xf4\x48\x09\xc0\x44\x41\xfe\x6c\x8d\x44\x17\xd9\x39\x7c\x28\x8e\xbc\xb6\x78\x32\xe7\x92\x52\x81\xe2\xda\x29\xea\xbb\x7a\x32\x7e\x4b\xc5\xb1\x3f\x46\xfa\x0e\x56\xe6\xfb\x0e\xd1\xe4\x6e\x21\xe3\xb7\x8c\x8e\x3d\xd4\x80\xa1\xca\x8e\x81\xcb\xcf\x50\x56\x05\xc6\xcc\x00\x8a\xb2\xbf\x93\xca\x8a\xed\x42\x65\x53\xc5\x65\xd7\xd0\xb2\x72\x5b\x30\x26\x3f\xf6\x94\xce\x6e\x89\x0e\x1a\xfb\xdd\xa7\xa8\xc3\x02\xa9\xfe\x38\x77\x29\xd9\x6e\x55\x3d\x19\xfb\xa5\xc5\x63\xf5\x74\x2e\x59\x69\x04\xf9\xb1\xe2\x6e\x21\x63\xbf\x4c\x31\x56\x32\xce\x2c\xe1\x68\x7e\xe5\x4f\x52\x7e\x05\xf5\x47\x0f\xaa\x8b\x3d\x47\xd2\x6f\xf8\x71\x5b\xa7\x47\x2b\x66\xe0\x14\x73\xf5\xdb\xc5\xb9\x3a\xea\x9b\xab\xc5\xac\xde\x33\xb9\xd2\xb0\xd1\x59\xae\xcc\x3d\xde\x45\x64\x6a\x84\xc8\x5f\xcc\xff\x9a\xe4\x94\x4d\x9e\x1e\x91\xa9\xd9\xa2\x7e\x1f\x52\xe4\x7d\x7e\x27\x95\x47\x7d\x5d\xae\x58\xaf\x3f\xc7\xe1\x1d\x32\xef\xb3\x46\xca\x21\x20\x9d\x0b\x8b\x79\x1f\x14\xd7\xc1\x60\xa0\xac\x28\xef\x43\xe9\xef\x96\xeb\xb7\x09\x3e\xab\xf0\xc5\xad\xc1\xaa\x21\xe9\x2f\x90\x73\x14\x9b\xc0\x67\x22\xfd\x00\xce\xe7\xc5\x53\x45\xf4\xb1\xee\xb2\xb8\x9f\x58\xa2\x7b\xea\x3b\xc1\xf3\x44\xa6\x71\xe8\x44\x66\x00\xd5\x15\x06\xa7\x42\xa6\x8b\xf1\x07\x24\x7c\x93\x88\xaf\x68\x3a\x2d\xfe\x21\xf2\x6c\xb2\x22\x36\xfb\x57\xae\x7a\x24\x2d\x21\xfb\x93\xe2\x32\x3b\xe4\x32\x4d\x52\x99\x8a\x33\x95\xd9\x3a\x04\x9f\xb6\x33\x94\xd9\x39\x04\x9f\x21\xcb\xa8\xd6\xc9\x65\x1e\x1e\xcc\x67\xcc\xa4\x33\x94\xd9\x35\x98\xcf\xa0\x32\x64\xce\xc4\x8f\x17\xe7\x4c\x2a\xf5\x9d\xfb\x9f\x07\xea\xdd\x4c\x98\x03\xed\x43\xde\x3f\x40\xef\x3b\xa5\xfb\xc8\xcb\xa9\xc6\xf2\x73\xcc\x71\x74\xff\x56\x82\x78\x68\xef\x41\xa0\x7d\x8a\xa5\x24\x14\x98\xb9\x0a\xcc\x8e\xbd\xbf\x25\x18\xe7\x69\x30\x5b\x45\xcc\xe9\xe8\xec\x1c\x9a\x8e\xea\x02\x05\xe6\xe1\x63\x9f\x0c\x45\xa7\x00\xb3\x4b\xc4\xe4\xe9\x4c\x46\x36\x38\x4c\xc6\xec\x7c\x51\x5e\xa5\xfc\x6f\x3d\x92\xef\x29\xa9\x5a\xbe\xa6\x40\xbe\x8b\xf1\x07\xc0\xcd\x22\x7e\x04\xc2\x97\xd7\x8e\x38\x2d\x1e\xf5\xda\x8f\xc5\xac\x20\x7e\x78\x16\x3a\x52\x1d\x14\x2f\x8f\x53\x31\x7e\x87\x84\x1f\x41\xf0\xb5\xa7\xc7\x63\x39\xdd\x02\x94\x1c\xda\x52\x63\x94\x25\x86\x6c\xc3\xce\x7c\x19\xc2\xa5\xad\x76\x70\x19\xd4\x97\xfc\xbd\xfc\x48\xd4\x97\x15\xd0\x43\x7b\x6a\xc0\x3f\xb0\x03\xc9\x08\xac\x52\xc8\x48\x11\xe6\x80\x84\x09\x2a\xe5\xe8\x03\xbe\x07\x63\x98\xac\x28\x47\xaf\xa2\x31\x61\x28\x99\x53\x60\x76\x88\x98\xe0\x69\x30\x5b\xff\x17\x74\x76\x0e\xa2\x13\x12\x26\xb0\xfb\x48\x5f\x5c\x28\x8e\xff\xeb\x0a\xfb\x96\x28\xf5\x7a\x0c\x05\xe3\x59\x8c\x3f\x20\xe3\x2b\x30\xde\x5b\x71\x06\x3c\xb5\x57\xa4\xaf\xf1\xc4\x18\x71\xa8\xa3\x25\x14\x7d\x5d\x5c\x66\x47\xbe\x4c\x05\x29\xe3\x3d\x73\x99\xad\xe0\xd3\x02\x3e\xa3\x4b\x93\x67\x2c\xb3\x33\x5f\x86\xf0\x19\xed\x3d\x45\x19\x62\x7b\x2e\x54\xd8\x2b\x45\x7b\x1a\x33\x67\x2c\xb3\xab\xb8\x3d\x43\x94\xc1\x63\xb7\x8d\xc8\x52\xe2\x74\xf2\x56\x84\x19\x52\xde\xd4\x87\x89\x0c\x24\x4e\x27\x6f\x45\x98\x21\xe5\x0d\x61\xa6\x2a\x30\x5b\xf7\xfe\xea\x8c\x74\x06\xcb\x1b\xc1\x10\x9b\x24\x61\xa8\xdd\x1a\x44\xa7\x00\xb3\x4b\xc4\xe4\xe9\xd4\xe0\xf3\xbc\xc8\xd8\x5d\x44\xed\xf9\x4b\x24\x72\xb4\x93\xc8\xf1\xeb\x9c\xc3\x62\x2a\xcc\x29\x17\xe3\x0f\x50\x7c\x50\xc4\x5b\x82\x85\xf8\x81\xdf\x14\xe1\x1f\x5a\x0b\x48\xd6\xc4\x6e\x21\x59\x93\xe7\x72\x8e\xb8\xa9\x28\x07\x3b\xa8\xcc\x0e\xb1\x4c\x50\x2a\x63\x19\x54\x06\x05\x50\x5f\x31\x95\x8a\x32\x5b\xf7\x16\xf0\x39\x96\x73\xc4\xce\x58\x66\xe7\xde\x02\x3e\xc7\x72\x96\x41\x65\x06\xde\x42\x65\xce\x21\x32\x48\xcb\x3c\xfc\x52\x01\x9f\xaf\x73\xd5\xcd\x67\x2c\xb3\xeb\xa5\x02\x3e\x43\x95\xc1\x63\xc7\x5e\x45\x64\xb2\xba\x58\x6e\xbd\x0a\x99\x2c\xc2\xc8\x72\x6b\x52\x60\xb8\x17\x88\x2c\x55\x17\xc9\xad\x57\x29\x27\x45\x18\x49\x6e\x4d\xa7\xc1\x6c\xfd\x5f\xd0\xd9\x39\x34\x1d\x22\x93\xd5\x45\x72\xeb\x3d\x0d\x46\x92\xdb\x3c\x1d\x3a\x7f\xbe\x5d\x9a\x3f\x23\x7b\xbb\x5d\xcc\x6d\x78\x71\xaf\xfa\x5c\x45\xb9\x8d\x62\xfc\x01\x19\x8f\x9f\x3d\x83\xae\xf2\x33\xe0\x1f\x22\x78\xfa\x3c\x1e\x0e\x8e\xa0\xaf\x66\xd0\xfc\xbc\xb8\xcc\x0e\xb0\xbe\x30\x47\xf1\x45\xce\x55\x53\x94\xa3\x28\x2e\xb3\x75\x10\x9f\xea\x33\xf2\xd9\x99\x2f\x43\x18\x41\xd7\xe0\x32\x48\xd6\x55\x80\x9f\x80\xfa\x34\x45\x62\x98\xbc\x3c\x31\xe5\xb2\xac\x0c\xc2\x48\xf2\xc4\x78\x15\x18\xf5\x36\x32\xc6\x29\xa6\x5e\x21\x4f\x2c\x25\x73\x0a\xcc\x0e\x11\xe3\x55\x62\x54\x1f\x53\x0c\xbc\x50\x21\x4f\x45\x74\x8a\x30\x3b\x07\xd1\xc1\x73\xdf\x47\x88\x0e\x5f\x51\x28\x07\xd0\x87\x4c\x52\xd8\xef\x56\x39\x06\xcd\x95\x95\xf8\x03\x38\x27\x20\xcf\x73\x5c\xee\xd8\x19\xf0\x0f\x81\x07\x24\x9f\xe3\xc3\x82\x63\xf6\xd7\xaa\x8a\x73\x9e\x85\x65\x50\xeb\x17\x50\x7d\x8f\x51\x7d\xff\x30\xe7\x3e\x53\x19\x2c\x07\xbf\x2b\xe0\x73\x96\xbf\xe6\x8c\x65\x76\xe6\x9f\x07\x20\xac\x2a\xdd\xa7\x28\x43\x6c\xd1\x15\xa2\xdf\x7d\xae\x80\x4f\x6d\x7a\xe4\x19\xcb\xec\xc2\x73\x69\x05\x9f\xe0\x10\x65\xb0\x4f\xdd\x4e\x6c\xd3\x88\x62\xdb\xe4\x56\xfa\xd4\x6f\xc9\xf8\x8e\x60\x7e\x54\x60\x77\xdc\x05\x3e\xac\x10\xb3\x73\x68\x0c\xb1\x17\x12\x46\xb2\x17\x79\x4c\x37\x9a\xeb\x9c\x20\x7d\x75\x15\x95\x13\x38\x59\x1c\xf7\x24\x1a\x77\xa6\xae\xda\xa2\x2a\x5e\x87\x28\xc0\x1f\x90\xf1\xc3\x30\xbe\x7a\xd8\x19\xf0\x0f\xc1\x0c\xa0\xa3\x9e\xa4\xa3\x7e\x3c\x57\x37\xda\x52\xb8\x2e\x54\x5c\x66\x07\x74\x8b\x65\x86\xd1\x32\x6f\xe6\xaa\xcf\x54\x66\x2b\xbc\x59\x1a\x0b\xc2\x68\x78\xdd\x28\x4b\xb1\x2f\x29\x2e\xb3\x13\xce\x92\xca\x10\x46\x25\xd5\xa7\x28\x43\xc6\x9c\x96\x79\x18\x66\x0b\xf8\x18\xce\xea\x39\x63\x99\x5d\xf9\x32\xc3\x4e\x55\x06\xcb\x49\x2d\xb6\x39\x9a\x44\x91\x5d\x82\x2d\xca\xf8\xac\x10\x23\xcb\x52\x8d\x52\x96\x9e\xc0\x72\xa2\x49\xe0\x4c\x8d\xc2\xcf\xb5\x14\xc8\x49\x21\x46\x92\xb7\x9a\x02\x4c\x29\xc5\xc0\x95\x05\x7e\xae\xe5\x34\x98\x9d\x43\xd3\xc1\x32\x29\x63\x24\x3f\xd7\x72\x1a\x8c\x24\xb7\x35\x4a\x3f\xc7\xb1\xfc\x36\x71\x8e\xae\x52\xef\x9d\x45\xb2\x1a\x35\x24\xab\x71\x63\xae\xaa\x26\x9f\xd5\x00\x83\xf1\x6a\xb6\x55\x7e\x86\x1b\x17\x61\x2a\xab\x8b\xf0\x74\x0e\xb7\x4d\x9e\x27\x52\xfa\x30\x4d\xe2\xb9\x6f\x73\x75\xe9\x21\xe7\xa1\x12\x1e\xd3\xdf\x27\xea\x05\x2e\xf2\xa3\x64\xaa\x08\x4f\xe7\x06\xdb\xe4\x98\x7d\x2f\xb8\x0f\x28\x22\xc6\xef\x72\xfe\x60\x7e\xa6\x33\x18\x8f\xe8\x9f\x04\xf9\xe7\xa8\xe6\xf9\x4a\x8b\xe6\x45\x34\x1e\xdd\x26\xc7\x56\x7b\x6f\x24\xd4\x9d\x84\x7a\x2e\x67\x73\x0e\x19\xbf\xca\x78\xb6\xf5\x9f\x94\x3a\x2e\x50\x66\x75\xe4\xd1\xb2\x9f\xdd\x26\xfa\x59\xb9\xef\xfd\xa4\xef\x77\xe4\x3c\xc5\xeb\x27\x85\x78\x65\xdf\xe3\x22\x09\xb7\xaf\x08\x4f\xed\xf7\x36\xd9\x4f\x88\x7d\x1f\x20\x75\xff\x6d\xce\x1b\x18\xd2\x17\x49\x78\x05\x7d\x52\xe4\x6c\x8f\xbf\x08\x4f\xf5\x7e\x9b\xac\x8f\x7b\xc9\x77\x7b\x10\x87\x7a\xc2\xe1\x60\xae\xb6\xde\xa2\x6c\x6f\x11\x9e\x6d\x85\xb7\x29\x72\x18\x1d\x35\x75\x45\x36\x6f\x92\x30\x36\x9f\xa7\x32\xc7\x91\xef\x7d\x14\xe7\x20\x59\x35\xe3\x1f\xf2\xfe\x81\x33\xdc\x7f\x08\xfb\xaf\xd3\xdc\xdf\x71\x86\xfb\x24\xb7\x76\x9a\xfb\x24\x3f\x51\x7c\x5f\xca\x7f\xa1\xfb\x0f\x63\xfa\x16\xf1\x3e\x59\x4f\x49\x58\xf2\xeb\x29\x85\xd8\x5d\x83\xb0\x4d\x32\x96\xee\xbf\x30\x5e\x5a\xef\x47\x98\xaf\x15\xb9\x32\x36\x29\xe7\xca\x4e\x81\xa3\x39\x33\x36\x2a\xdb\x36\x61\xac\x6a\x2c\x3f\x5b\xca\x3f\x99\x63\xc8\xb6\x1d\xc0\xbc\xd9\x35\x88\x37\xb2\x17\xac\x22\x57\x45\xb0\x73\x15\xd8\x1d\x7b\x7f\x5b\x80\x75\x9e\x06\xbb\xb5\x08\x7b\x3a\xba\x3b\x4f\x4f\x37\x9f\x2f\x43\x58\x64\xfb\x4e\x47\xb7\x00\xbb\xab\x08\xeb\x54\xe4\x58\xc6\xe6\xf3\x0c\x44\xde\xc4\xf1\x86\x2d\x60\xa8\xfb\x07\xce\x70\xff\xa1\x33\xdc\xdf\x71\x86\xfb\x24\x37\x72\x9a\xfb\x3b\x87\xba\x2f\xe5\x2f\x88\xbc\xbd\x4e\x65\x08\xdf\x47\x32\x44\x52\x1f\xa2\x0c\x15\x63\x77\x0d\xc2\x56\xc8\x58\xdc\x87\xdb\xf8\x36\x29\x7f\x81\x7b\x06\xf9\xc7\x27\x31\x9a\xc3\xdf\x72\x2b\xc8\x75\x10\xec\x48\x05\x96\xf8\x52\x25\x36\xa8\xc0\x2a\xf3\x10\x44\xee\x5e\xc5\x48\xfe\x16\x3a\x36\xca\x5c\xc3\x20\xec\x8e\x22\x6c\xf0\x34\xd8\xad\xff\x07\x74\x77\x9e\x9e\x6e\x3e\xdf\x91\x97\xbb\x53\xd1\x2d\xc0\xee\x2a\xc2\xe6\xe9\xe2\x73\x90\xe4\xf8\x09\xf7\x2e\x8e\x05\x89\x1d\x39\x01\x86\xba\x7f\xe0\x0c\xf7\x49\x6c\x78\x9a\xfb\x24\x0e\x3c\xcd\x7d\x12\xf3\x9d\xe6\x3e\x89\xef\x8a\xef\x4b\x71\x19\x96\x3b\x98\x15\x6d\xd7\x09\x51\x96\x92\xb2\x2c\x15\x63\x77\x0d\xc2\x0e\x2b\x90\x3b\x45\x5c\x26\xca\x1d\x91\x25\xf6\x13\x2a\x4b\x2d\x4a\xb9\x2b\xc4\x1e\x28\xc6\xd6\x28\xe5\x4e\x11\xa7\x29\xe4\x2e\x2b\x8e\x4d\x4b\xc1\x38\x16\x62\x77\x14\x61\x6b\x0a\xb0\x8a\xb8\x2d\x2f\x77\xdc\xc1\x21\xe9\x16\x62\x77\x16\x61\x8b\xe8\xe6\xe3\xb8\xbc\xdc\x9d\x8a\x6e\x01\x76\x57\x11\xb6\x38\xf6\xbb\x42\x8a\xe5\x98\x0d\x80\x7e\xc7\x95\xa9\x20\x11\xc8\x89\x5c\x22\x3d\x78\x4d\x0b\x7f\xaf\x4c\xc4\xaf\x93\xf0\x74\xcd\xec\x5f\xb9\xca\x44\x21\x9e\xf8\xc7\x6d\x92\x4f\xa3\xbe\xcc\x4c\xe3\x10\xf9\x3e\xfb\x9a\x1c\x4b\x52\x5f\x27\x3e\xe7\x52\x2d\xf2\x3e\x25\x1d\x31\x3e\x91\xdb\xb1\x40\xae\xd7\xa6\xc2\x76\x7c\x9b\x4b\xb5\x0d\x51\xaf\x05\x12\x3d\x8a\x57\xf8\x6d\xfa\xdc\xec\x7e\xf9\x39\xdc\x0d\xf0\x2a\xfa\xbd\x40\x1b\xf9\x5e\xe0\xdf\xe4\xa7\x03\x45\x7a\x14\x5f\x27\xe3\xd7\xc1\xf5\x14\xef\x24\xf8\xfe\x9c\xdd\x39\x18\x2f\x3f\xe7\x8b\xfa\xe3\x96\x6d\x05\x6b\x58\x45\xf7\xd9\xd6\x9f\x3d\x5c\x78\xbf\x70\xff\x25\xea\xd7\xf1\xf3\x3c\x5a\x97\x54\x31\x80\x9f\x91\x3e\xc2\x85\xe1\x7e\xfe\x76\x60\xc6\x7b\x6d\xa9\x00\x60\xf5\x7a\x8b\x55\x55\xb2\x9a\x7d\x16\x4e\x04\xed\x78\x5f\x2c\xc5\xfe\xaf\x76\x95\xba\xb1\x89\x6e\xc1\x86\xb7\x5e\x83\xfb\x17\x5c\xfd\xe3\xb2\xaa\xb2\xe6\x44\x7a\x14\xaf\x9d\x79\x51\x79\x7b\xb4\xd1\xe5\x74\x84\xcb\x62\xd5\x13\x31\xed\x83\xc2\x58\xf8\xe6\xc0\x9d\xc0\x08\xfc\x19\xa3\x5e\xc5\xb2\x25\x26\x80\x4f\x43\xc2\x27\xd6\x1c\x4c\x28\x77\x69\x6f\x83\x69\x7c\x26\x60\xb3\xab\x04\xc2\xe1\x4d\x2d\x97\xc5\x4a\xab\xfc\xa1\x76\x61\xec\xb8\x31\xaf\xbc\x94\x71\xa7\x5c\xa5\x45\x75\x0d\x66\xf4\xf9\xba\xd2\xaa\xfe\xbf\xa8\x29\xa6\x6d\xe1\xe6\x32\x3f\xe3\x17\x00\x27\x18\x9e\x09\x38\x74\x3a\x97\xdb\x6e\x30\xf0\xeb\xb3\x26\x43\xd0\x90\x34\xb0\x5a\xd6\x00\x32\xc0\xb2\x3e\xab\xa3\x5b\xe7\xed\xa3\x5b\xa9\xe1\xbd\x3a\x80\xdb\xbc\x4f\xda\xf7\x1f\x96\xd5\x32\xf8\x19\x70\x75\x04\x71\x2d\x65\xf0\xee\x6f\x69\x15\xfc\xa0\x6e\x4a\xd7\x98\x70\x28\xee\x54\x37\x98\x72\x75\x53\xc6\x8d\x09\x25\xea\xb4\x0d\x26\x6e\x6e\xa2\x31\xe1\xae\x49\x7d\x83\x2e\xa9\x0e\xfc\x88\x01\x60\x51\x3d\x7e\xc4\xfc\x4c\xb5\x0e\xd5\x03\x9f\xb4\xbf\x30\xd3\x18\x70\xb9\x22\x95\x95\x0e\x54\xa5\x64\xdd\x29\xaa\x64\x02\x41\xc0\x68\x59\xe0\xcd\x54\x87\xbc\xa1\xbb\xb2\x31\x2f\xa9\x23\xd9\x1c\x03\xd5\xf2\x63\x54\xcb\x21\xeb\x6b\x95\xbb\x6b\xa8\x6a\xab\x4f\xb1\x37\xe1\xa9\x9a\x13\x6a\xa9\xaa\x1a\x36\xac\xaa\xaa\x45\xd8\xd8\x52\x55\x39\x62\x64\xbc\xaa\x85\xbf\xa1\xa0\x85\x2f\x56\x0d\x47\x9f\x62\xcc\xf0\x11\x95\xe8\x9a\x8f\x57\xb6\xc9\x31\xc6\x5e\x70\xcf\xe0\x78\x05\x3f\x97\x46\xee\x17\xc7\x39\x72\x39\xfa\x39\xd6\x77\x68\x51\xcc\xf9\x16\x48\x73\x38\xa4\xbf\x87\xc5\x79\x84\x17\xcd\x23\xba\xa2\xc9\x41\x6b\x5b\x63\xf3\x78\xa2\xef\x87\x0b\xf8\x0d\x5e\x0f\xdc\x3b\x50\x3b\xb0\xa1\x78\x7d\x86\x7f\x52\xc4\xd4\xd1\xd9\xcb\x40\xd5\x60\x8c\xea\x11\x31\xf6\xf1\x9e\x9a\x8e\xea\x05\x11\x73\x2a\x3a\xf8\xbb\xef\x8a\xbd\x44\x90\x07\x4b\x13\xfd\x86\x53\x42\x71\x79\xef\x1d\xc0\x80\x51\x5c\x98\xb9\x90\xe8\x8c\x13\xd4\x64\xac\x36\xa7\x53\xd4\x1c\x97\xdb\x86\xd4\xdc\x42\x95\xe7\x35\xef\xc7\xa9\x7d\x8a\xb3\x0c\x86\xd4\x21\xb2\x63\x25\x0c\xe7\x35\x09\x5a\xde\x78\x61\x6c\xb1\x3a\x09\x27\x60\xa8\x5c\xf8\x38\x3c\x98\xb7\xc5\x6e\xff\x6f\x79\xdb\xe8\x8e\x94\x0a\xde\x5d\x63\x5f\x78\x63\x30\xeb\x30\x8c\x96\x0b\x9f\xe1\x76\x5b\xd8\x6f\x88\x1e\x99\x41\x1c\x4c\xca\x24\x28\xdf\x58\xcc\xe7\xab\xa8\xb4\x94\xad\xcf\xfa\x80\xc5\x6c\x09\x59\x90\x12\x59\x32\xe5\x81\x80\x13\x69\x55\x20\x18\x60\x02\xc8\x9a\x80\xe4\xbe\xd4\x01\xaa\x26\xde\x4f\x88\xea\x14\x6b\x4b\x51\xe5\x9a\x87\x54\x7a\x85\xc5\xb1\x9c\x42\xff\xff\x58\x58\xfd\xa5\x05\xca\x32\x30\x30\x70\x6c\xe0\x2b\xa6\x96\xf8\x5e\x92\x27\x60\x36\xbc\x40\x66\xce\x16\x32\x73\xfe\x7b\xce\xee\x2f\x5a\xe7\xfa\x00\xe1\xc7\x13\xdf\x4b\xf1\xeb\x5e\x50\xac\xa3\x7d\x99\xb3\xda\x8b\xf0\xdf\x23\x7c\xb9\xea\x26\x8a\xc7\xfb\xb6\xbc\x70\xc8\x8c\xe5\xf1\x2a\xf0\x85\xe2\xfe\x8d\x85\xf7\x91\x2c\xfe\x85\xee\xeb\x32\x70\x10\xdd\x9f\x4e\x74\x86\xf2\xdb\xa4\xac\xdf\x57\x39\x5f\xac\x88\x1f\xc1\xab\x3a\x0b\xe9\x31\x9b\x06\x5e\x10\xf7\x89\x41\x30\x66\x39\xf1\xa9\xd5\x62\xac\x01\xe8\xfe\x1b\x06\x9e\xee\xa7\x61\x72\xe5\x9f\xae\xc5\xb9\x08\x84\xbf\x8d\xf8\xd4\x6a\x31\xd6\x10\xf1\x26\x71\x7f\x2b\xa3\xa9\x00\x8f\xd7\xaa\xae\x16\xd7\xaa\x8a\x74\x4f\xb9\x56\xc5\xde\x29\x62\x8a\x74\x8f\x62\x86\xd4\x29\x50\xa2\x52\xe9\x01\x40\x72\xad\x67\x57\xe3\xd3\x84\x4e\x21\xd7\xb6\x86\xfc\x96\xa5\x2e\x47\x2d\xe4\x89\x4e\x8d\x1a\x9d\x4a\x34\x23\x59\xf9\xf1\x55\xe7\xc1\x7f\x12\x95\x1a\x3e\xa1\x3a\x56\x16\x76\x38\x5d\x8d\xd1\xf6\xf2\x8b\x7e\x22\x6a\xd4\x10\xbc\x91\x4e\xfd\xd7\xbc\x89\x4e\x29\x79\x57\x10\x9d\x2a\xe2\x2d\xa9\x54\x91\x4e\x4d\xc8\x54\x51\xbe\x67\xd6\x29\xb6\x04\x24\xdf\xdb\x77\x3a\x8d\x2a\xae\x9a\x6d\x28\x8d\x3a\x92\xaf\xe9\x3f\x4f\xa5\x50\x85\x75\x87\x6c\x91\x83\x95\xf3\x57\x57\x48\xf9\x2b\x24\x63\xf7\x83\xfc\x77\x3a\x0d\xbe\xc8\x50\xf9\x2e\xa2\x53\x57\x88\x32\x76\xbf\x62\x6d\xc7\xe8\xf1\x0d\x85\x27\x3a\x75\x05\xd9\x0f\x63\x11\xde\x07\x03\x6b\x15\x58\x0c\xbe\x90\xef\xdf\xa8\xb8\xbf\x71\x80\x68\x15\x8a\x2f\xf1\x7e\x19\x6b\x90\xdf\xfa\x1f\x32\x8f\x5a\x0e\xf2\xcf\xf0\xa0\x38\x31\x48\xe2\xd4\x6f\x72\x21\xbf\x49\xad\x90\xe9\x62\xfc\x01\x09\x5f\x25\xe2\xfd\x55\x05\x78\xda\xfe\x05\x72\x7b\x36\xc9\x6b\x55\xb8\xfd\x65\x65\x35\x43\xb6\xa7\xb3\xb0\x3d\x62\xb9\x43\xc0\xb0\x87\x6d\xc5\x5f\x89\x6e\x05\x16\xf1\xd9\x42\xfa\x4c\xde\x7e\xf9\x99\xbc\x0d\x05\xcf\xe4\x35\xbb\x43\x45\xcf\xe4\x51\x7c\x9d\x8c\x5f\x27\xe3\xf1\x77\x43\x5b\x9c\xee\x22\x3c\xf6\x8d\xef\x8b\x6b\x3a\xa3\x0b\x75\x58\xb9\xa6\xa3\x1a\x10\x31\x8b\x0b\x75\x58\x89\xe1\x87\xf1\xed\x08\x93\x56\xac\x0d\xed\xc4\x31\xb4\x9f\xea\x39\x0b\xd2\x5c\x2f\xb3\x42\xde\x4f\x39\x9d\x71\x32\x3c\x6f\x70\x5b\xad\x2a\x83\xa1\x34\xe8\x33\xe1\xbd\x94\x1d\xf2\x5e\xca\xaf\xa5\xa4\x03\x17\x15\x3b\x29\x53\x9f\x19\x3f\x55\x24\x75\xe1\xd3\x2f\xd4\xbf\x80\x77\x51\xc6\xbb\x29\xc3\x3b\xf0\x2e\xca\x78\x37\x65\x69\x9b\xe7\x39\xe2\xee\xce\x31\x79\x97\xe7\x21\xea\xc4\x02\x20\xed\x3f\x1d\x34\xf9\xf0\x16\xd4\x5a\xc7\xe9\xeb\x44\xf4\xbe\xfc\x54\x75\xd2\xd6\xbf\xf0\x34\x6c\x92\xf7\x9e\x5e\x52\xbc\xbd\xf3\xa0\x4a\x41\xf0\x2e\xaa\xf0\xbb\xfc\x36\x54\x27\x5f\x46\xc7\x33\x8c\x4a\x6d\x62\xa1\x54\x87\x39\x72\x6c\x4c\xe3\x87\x8d\xc8\xc0\x21\x3c\xb1\x68\x72\xde\x60\x9b\x34\xd7\xa7\x73\x7c\xac\x2f\x10\xe6\xf3\x06\xec\x5e\x39\x1f\x4c\x73\x00\x28\xce\x99\x5a\xd7\x6c\x51\xec\xc5\x75\x0a\x3a\x28\x1e\xbc\x43\x91\x87\x5e\x20\xd1\x61\x36\xc1\x89\xa2\xdc\xe3\x2d\x45\x60\xd3\xa8\xe2\xb5\x34\x42\x6f\x81\x44\x8f\xe2\x15\xf9\x0c\xbc\x2e\x7c\x25\x5d\xa7\x86\xaa\x02\x39\x2c\x58\xa7\xe6\x3f\x42\x98\x18\x48\x5d\xa0\x94\x42\x11\x21\xcb\xf3\x5d\x62\x4e\xe2\x9b\x42\x79\x56\xae\x2b\xf1\x9f\x63\x3a\x9a\x44\xa6\x40\x9a\x6b\xf2\x74\x16\xa1\x78\xf0\x66\x8a\xf9\x0b\xa9\x27\x3b\x9c\xcc\x6b\x7e\x8f\xfa\xfa\xf7\x78\x6c\x20\x93\xf9\x11\xde\x0f\x5c\xbd\x46\x7d\xb7\x3a\xa7\xde\xa7\xe6\xba\xd5\x7d\x6a\x86\x53\x47\xd5\x0d\xea\x0e\x35\xb7\x6c\x01\xfa\x7c\x1b\xfa\xfc\x3d\xf5\x09\xb5\xaa\x4e\x9d\xc1\xf7\xec\xe8\x2e\x1b\x55\x5f\x86\x6e\xe4\xd0\x0d\xde\xac\x86\x9c\x1a\x4e\x13\x69\x1c\xc6\xc8\x90\x1a\x63\x59\xbb\x1a\x02\x35\x1c\xad\x7e\x76\x20\xf3\xd4\xc8\x51\x5d\xe8\xba\x3a\xa3\x6d\x69\xeb\xc2\x18\x86\xbe\x4b\x35\x76\xe1\x72\xe2\xbb\xea\x64\x17\xe6\x2c\xbe\x8b\x55\x76\x75\xa8\xa7\x91\x77\x7b\x33\x95\xa1\xf2\x2e\x4c\x96\x61\x80\x1a\x05\x08\x7d\xea\x25\xea\xdb\xd5\x7b\xd5\x6f\xab\x8f\xa9\x55\x49\xcc\x07\x7d\xa8\x51\x8a\x18\x9c\x3b\x67\xce\x9c\xa5\xbd\x4b\x13\x4b\x13\xcb\xc8\x6f\x02\x7f\x30\x67\xe9\xd2\xa5\xcb\x96\x2d\xc3\x2f\x2d\xe2\xa6\xeb\x44\xf4\x7f\x8f\xdc\x1c\x96\x66\xd1\xaf\x15\xcd\x2b\xa9\x57\xb3\x58\xf5\x2c\x75\xa5\xfb\x94\xf3\xca\x62\x47\xa5\xf0\x49\xc5\x8e\x13\x8d\xfe\x07\xc2\x51\x50\xc5\xab\xf1\xac\xee\x69\xc8\x30\x1c\x03\x40\x32\x29\xee\x32\x6d\xb3\x44\x2c\x55\xd3\x78\xf5\x7f\xfe\xaa\x72\xe3\x3d\x9e\x43\x08\xfb\x19\x7f\x23\x28\x01\x75\x19\x97\x41\x87\x06\x8a\x83\xd0\x64\xd4\xe8\xf9\x12\x86\x57\xb3\x2c\xd4\xa2\x86\x27\xf1\xd9\x93\x49\x72\x8a\x0c\x4c\xe7\x4f\xd2\x8b\x58\xd4\xf1\xe6\x78\xb3\xab\xd9\xa5\x76\xa9\xe3\x55\xd3\x56\x35\x3f\xfe\xb8\xf8\x6f\x95\x70\x94\xcf\xae\x6e\x7e\xec\xe7\x2d\x4f\x3c\xd1\xf2\xf3\xc7\x9a\x57\x63\x5e\xbf\x17\x8e\xc2\xa7\x10\x2f\x1d\xde\x0d\x5a\xc3\xb2\x40\x8b\x7a\x1a\xf0\xbc\x4a\x8f\x06\x17\xfd\xaa\x74\x2a\x80\x77\x82\xa6\x87\x75\xc2\x74\x2a\x7f\x16\x08\xde\x1e\x3b\xde\x1c\x41\x95\x0f\xc7\x9b\xe1\x53\x9f\x36\xaf\xf9\xae\x07\x8e\x5f\xd3\xcc\x3d\xfe\x51\xf3\xca\xef\x2f\xe6\x0f\xad\x6c\x21\xf3\x69\x61\x02\x6a\x4f\x05\xe1\x51\x97\x71\x68\x38\x4e\xa5\x65\x59\x95\x0a\x40\x3d\xab\xe5\xd1\x2f\x24\xad\x51\xb0\x48\xe5\x39\xa0\xf6\x44\x50\x3b\x50\x6b\xc2\x15\x3d\xdf\xad\x69\xfe\x14\x71\x81\xe3\x51\x43\xee\x5a\xd9\xfc\xd1\x27\x2d\x2b\x49\x2c\xf9\x0d\x7c\x82\x2b\x61\xcc\x56\x95\xfa\x4f\x98\x9f\xf4\x1e\x9f\x6e\x97\xd1\x41\x9e\xe1\x58\xe6\xf9\x2c\xfb\x22\x3e\x1a\x57\xdc\xd6\xdb\x11\x6e\xe4\x4a\x7e\x38\xcc\x98\x17\x2e\xa4\x78\xcd\x19\xf1\x9a\x92\x7f\x0f\x89\x07\x3c\x7b\x5a\x3c\xd2\xc7\x9b\x51\xa5\x9e\xe1\x6f\x35\xab\xe0\xf5\xa4\xbe\xc7\xfa\xbf\xe1\xcc\x03\x73\xad\x71\x80\xbc\x96\xf0\xbd\x59\x85\xaf\x48\xf6\xf6\xb3\x9d\xf0\x5b\x7e\x1a\x92\xbd\x5d\x99\x9f\x70\x2a\x3d\x52\x51\xab\x05\xcd\x42\x4a\x1e\x9b\xc5\x72\x0f\x66\x59\x2e\x64\x85\x47\xad\xf0\x6d\x2b\xdc\x6b\x85\xb7\x59\x61\x9f\x15\x02\x2b\xbc\x60\x89\x15\xb6\x5b\xa1\xd9\x0a\x3f\xb5\xc2\x5d\x56\xb8\xca\x0a\xbb\x15\x88\x24\xb9\x85\x70\x2d\x6f\x59\xe1\x96\x42\x50\xd0\x0a\x8f\x59\xe1\xcb\x56\x78\x3b\xc1\x05\x09\x4e\x43\xf4\x85\x68\x0c\xd6\x19\xc5\xbb\x65\xf9\x77\xa8\xad\xb2\x3b\x71\x51\x65\x68\x76\x90\x23\x8b\xc4\x93\x01\xf6\x6f\xbc\x67\x57\x69\x6c\x4c\x47\x63\x5b\x0f\xfb\x97\x9b\x9e\xab\x99\xd4\xb2\xc4\x11\xb0\x47\x46\x35\xb5\x9c\x43\xda\x9a\x63\x3b\xe0\x11\xbe\x07\xb5\x75\x67\xe6\x4a\x15\xea\x4a\xbd\xde\x6a\xc1\xad\x2c\x61\x1f\x9b\xa5\x2a\xf9\xff\x55\x53\xd3\x89\xc4\x10\xf9\xa4\x58\x5c\x72\x93\x47\x36\xdf\xb9\xab\xb4\xbc\x03\xb7\x95\xdb\xb5\xf6\xb9\xaa\x89\x2d\x4b\xec\x21\x5b\x24\xd3\xd4\x4a\xdb\xba\x5b\xd8\x0f\xbf\x00\xef\xa2\xb6\x46\x33\x56\x29\x57\x95\x6f\x2b\x48\x16\x32\x28\x1f\xc4\xe0\x8b\x3c\x83\xfa\x21\xe8\xef\x47\x7d\xf9\x2d\xe9\xcb\x58\xc6\x66\xc4\xf3\x6a\xab\xa5\xc4\xf8\x60\x56\x2f\x8a\x0e\x3d\x13\x5a\x62\xa1\x30\x5d\xe4\xac\x1e\x6c\xbb\xf6\x4f\x19\xd9\xd8\x31\xa6\xc2\xbf\xeb\xae\x4d\xdc\xae\xf1\x33\x5b\x9b\x32\x11\xc4\x61\x49\xcb\xc4\xaa\xe7\x51\xac\x3f\x9f\xed\x64\x9b\x89\x5c\x86\x61\x5f\xe6\x3f\x44\x32\x1d\x2e\x3f\x6b\x01\x96\xb2\x88\xdd\xf1\x60\xd6\x6e\x67\x5d\xc1\xa0\x52\x52\x87\x47\x60\x34\x02\xed\x11\xf8\x65\x04\x7e\x14\x81\x6f\x45\xe0\xae\x08\xdc\x16\x81\x77\x47\xe0\x9a\x08\x9c\x15\x81\x1d\x11\xe8\x8b\x40\x7d\x04\x2e\xfa\x21\x02\x0f\x47\xe0\x7b\x11\x98\x8b\xc0\xcb\x22\x70\x41\x04\x0e\x27\xf7\xb8\x08\x3c\x11\x81\x6f\x46\xe0\xff\x90\x62\xe8\xf3\x06\x42\xf4\x07\x89\xe8\x3e\x52\x04\xdd\xba\x28\x02\xa7\x29\x28\x0e\x7b\x8f\xdc\x93\x59\x9d\x4d\x28\xca\xd5\x79\x93\x14\x43\x75\xb9\x4a\x51\x52\x4f\xe8\xd2\x7a\x20\x7e\xab\x15\x55\x49\x44\x60\x30\x02\x4d\x11\xc8\xf4\xce\xc9\xff\x2c\x95\x7e\x96\x49\x3f\x73\x07\xdf\x3d\xd5\x3d\x51\x7b\xd2\xee\x24\x1a\xf0\xa4\x78\xe6\xbb\x2b\x4d\x34\x09\x16\x6b\x52\x79\xf1\x07\x8c\x4a\xd4\xad\x86\x4c\xb7\x30\x3b\xff\xba\x48\xcf\x66\x75\x16\xbe\xa5\x39\xa0\x19\x6c\x07\x9b\x20\xb2\x12\x06\x93\x33\x55\x44\x1a\x5d\x16\x8b\xdd\xaf\xf7\x97\x45\xd0\x20\x96\x88\xe3\xa9\x50\x45\xd4\x19\x4b\x22\x70\xce\x1c\xaa\x08\xf4\x8c\x10\x50\x7c\x3a\xcd\x90\x9a\xc1\x0f\x92\xe4\x9b\xf2\x92\x0c\xb7\x49\xaf\x33\x93\x8b\xd5\xe6\xec\x82\xb7\xb3\x71\xbd\x85\xfd\x6c\x82\xe8\x50\x18\x2e\xcc\xfc\xc7\x65\xb1\x5b\xfc\xc4\x6c\xf8\xf5\x91\xb2\x21\xeb\x4d\x47\xbe\xfd\x14\x22\xd8\xab\x18\xdb\x02\x29\x44\xa3\xff\x40\x04\xae\x3b\xb5\x14\x52\xba\x4a\x41\x1c\x42\x04\x29\x2d\xca\x8d\xca\x19\x2d\x46\x45\x98\x53\xc8\xef\x3a\x02\x58\x40\xca\xd3\xc2\x27\x48\x55\x6e\x47\x02\x47\x7b\xbe\x3b\x02\x93\xa4\x9e\x20\x22\x5b\xac\xde\x21\x45\x50\x29\x68\xa7\x95\x4f\x22\x84\xc9\x33\x0c\xe7\x20\x3b\xf4\xbf\x1e\xce\xfa\xd3\x8f\x26\x28\xb4\x29\x68\xe6\xe2\x0a\xba\x5c\x16\x1a\x6d\xf9\x2d\xc8\xa8\x94\x04\xf5\x7e\x3f\x8a\x23\xe9\xf9\x55\x8a\xb0\x2b\x1f\x7a\x14\x9b\xb0\xf2\xe2\x0f\x18\x55\x77\xa6\xa1\x63\x4c\xac\x74\xd7\xdd\x0f\x0a\xb3\xf3\xaf\xb9\xa7\x3a\x67\xb5\x34\x8d\x8a\xd8\x4b\xed\x4b\x5a\x26\x55\x3f\x77\x73\xe1\x5b\x64\x4f\xdb\x07\xcc\xec\x2b\xfc\xad\xc0\x08\x9e\xcb\x5c\xa7\x33\x72\x6a\x0e\x85\x5c\x06\xe4\x8d\x19\x5e\xc3\xe1\x95\x0b\xbd\xe1\xe5\xac\x56\xff\xea\x2c\x15\x8f\xae\xaa\x57\x67\x69\x01\xdc\x69\x82\xb7\x99\xe0\x2a\x13\xbc\xd4\x04\x93\x26\x68\x32\xc1\xa3\x26\xf8\x16\x79\x3b\x99\x7c\x82\x5e\x53\x0c\xba\x35\x6c\x00\x9f\xd9\x88\xd1\xbd\x26\x98\x31\xc1\x4f\x4d\xf0\x65\x13\xdc\x62\x82\xab\x4d\x30\x68\x82\x80\xdc\xed\x23\xb7\x42\x26\x98\x1f\xcd\xfc\x38\x2a\x86\x16\x24\x91\x35\x11\x1d\x08\xb1\x21\x28\x26\xc4\x33\xac\x08\xea\xdf\x46\x9e\x4d\xb3\xe5\x8e\x72\x66\xc1\xc4\xda\x71\xed\x42\x1f\xdc\x92\xd8\x98\x84\x5b\x84\x3e\xd6\x70\x92\x63\x4f\x6e\x49\x6e\x4c\xc0\xcd\xc2\x3c\xf4\x21\x50\xb4\xdb\x03\x8e\x66\x1e\xd1\x1a\x54\x2c\xc7\xe8\x35\x46\x23\x63\x33\x3b\x3d\x1c\xb0\x5b\x4c\x0e\xb7\x89\x05\x1c\x0a\x62\x19\xc6\xeb\x73\xb9\x5f\xce\xda\x5d\xaf\xce\xb2\x5a\xd0\xd5\xfa\xea\x2c\xbb\x4e\xff\x72\x56\xa3\x7b\x75\x16\xcf\xa1\x2b\xff\xea\x2c\x0d\x58\xe5\x83\xbd\x3e\x38\xd9\x07\xdb\x7d\x30\xe8\x83\x03\x3e\xf8\xa9\x0f\x6e\xf6\x41\xf4\xf9\xa5\xd2\x27\x2f\x93\x4f\x28\x00\xf8\xe0\xf0\x4f\x49\x99\x0c\xb9\xb7\xd7\x07\x57\x13\x74\x9f\x0f\x7e\x46\x70\xe8\xed\x12\xf2\x36\x43\xd0\x73\x0a\xfc\xb7\xd2\x81\x8b\xbd\x03\x48\xdf\x00\x24\xe3\x05\x5d\x84\x04\x49\x3c\x4e\x48\xec\x2d\x14\x32\xcb\x9d\x85\x23\x67\x74\xb1\x45\x6c\xe8\x23\xb8\x65\x5c\x41\xc7\x8d\x99\x38\x71\x0c\xbe\xa2\x9e\xc3\x9f\xc2\x3b\x5e\x7c\x49\xd1\x8b\x5b\x5e\x7a\x71\xb3\x78\x47\xec\xd3\xe5\x70\x37\x73\x2e\xbb\x01\xe8\xc1\xd7\x99\xc7\x81\x4a\x65\x34\xb0\x26\x2d\x34\x68\xcd\x46\x08\x8c\xf0\x98\x11\x7e\x66\x84\x7b\x8d\x70\x97\x11\xae\x36\xc2\x25\x46\xd8\x67\x84\xdd\x46\x98\x31\xc2\x3a\x23\x0c\x11\xcc\x62\x25\x42\x79\x03\x15\xde\x22\x15\xcb\x0c\x22\xd7\x27\x81\xd1\xe7\xc3\xd1\xa7\x6f\x93\x1b\xb7\x1b\xe1\xa5\xe4\x86\x99\xbc\x5e\x4d\xb8\x25\x09\xe8\x6d\x89\x33\xba\x55\x24\x62\x79\xdb\x51\x68\x53\x8a\x4c\x0a\x48\xce\x9d\x73\x50\x9e\xe2\x2b\x12\x09\xcc\xb9\xeb\x17\x9e\xb7\x7e\xfd\x79\x0b\xd7\x33\x8f\x2e\x5c\xbf\x7e\x21\xfa\x8f\xf3\x17\x1f\x0e\x7c\xa1\x8e\x83\xf7\x51\xdf\xb8\x40\x04\x34\x67\x02\x40\x65\xb0\xba\x4b\x4b\xad\x2a\x36\x5a\x1e\x76\x68\x59\xed\x03\xb3\x7c\x26\xd6\x96\x29\x87\xa1\x72\xea\x80\xe8\x4e\xef\x88\x47\xfe\x30\xa8\x53\x65\x2f\x0a\x32\x19\x6f\x8e\x6d\x68\x18\xdb\x99\x4e\x77\x32\x3b\x06\xbf\x9a\x5d\xdf\xd5\x55\x9f\xee\xec\x4c\x17\x5d\xe5\xf9\x11\xf7\x0e\x3e\x3e\x35\xa3\xe5\x21\x9a\xba\x21\xaf\xc3\xe0\xd9\x97\x78\x2c\x15\x9d\xbe\x85\x1d\x55\x53\xe1\xc7\xdc\x75\x78\xda\x33\x19\xcf\x79\x26\xa2\x39\x4f\x25\x29\xe7\x78\x06\xe9\x0c\xa7\xe2\x90\x30\x24\xd3\x49\xf9\x60\xa8\xc6\x30\x2a\x26\x4c\x84\x1f\x4f\xe5\xae\x9b\xfc\x7d\x29\x7f\x17\x99\x2b\x0d\x58\x51\xb9\xaf\xf9\xeb\x81\x1a\x94\x66\x0c\x80\x61\x78\x56\x03\x79\x1e\x4d\xe1\xc9\x14\x29\x29\xcd\x8f\xe8\xcc\x08\x33\xfe\x7a\xdf\xb4\x7d\xf0\x63\xf6\x9d\x1f\x4a\xb9\x43\x64\xaf\xbb\x3c\x0d\x3d\x39\xab\x8a\x47\xb3\x4e\x44\x88\x35\x20\x3a\x3a\x1d\xab\x55\xb1\xe2\xdc\x31\x9d\x9f\xd0\x15\x50\x74\x84\x25\xaa\xc2\xe5\x70\x9d\x44\x79\xb2\xf0\x65\x21\xed\xda\x8c\x1d\xaa\x54\x1a\x4e\xaf\xd7\x68\xb5\x06\xb5\x1e\xd9\x6e\x4e\x8b\x82\x4d\xd4\x48\x99\xb8\xc2\x60\xb3\x88\x2a\x69\x33\xfa\xfd\x1a\xae\x43\xa4\x3f\x46\x3c\xb8\x20\x74\x4c\x16\x26\x61\x16\x34\x77\x21\xfe\x98\x55\xea\x0f\xf0\x53\x18\xa0\x06\xc9\xc8\x3b\x28\x5e\xd1\x02\x07\x08\xe1\x13\xc3\xd0\x5c\xa9\x13\xdc\x94\x99\x32\xb6\x73\x4c\x47\x5b\x2a\xec\x8c\xfb\xd0\x04\xd9\xe7\x4c\x75\x74\xaa\xf8\xe6\x1a\x33\x5f\xc3\x77\x9d\x35\x96\x6b\x1c\xb6\x27\x5b\xd7\xf8\xcc\xac\xba\x0c\xba\xd6\x8d\x29\x8d\xee\xc9\x7a\x4a\x9f\x99\xe5\xa9\x42\x57\xcf\x18\x1b\x6b\xdb\x93\xd5\xb0\xcf\xcc\xd2\x18\xd1\x95\x5b\xdd\x05\x27\x77\x11\xf9\x22\xb6\xa2\x3d\x8d\xad\x05\xf5\x8c\xe4\x7d\xfe\x08\x39\x57\xab\xe2\x28\x4c\x51\xc8\x43\xf8\xd4\xd3\x10\xdb\x20\x9e\xd9\x9a\x4e\x35\xc9\x9f\xa6\x9c\x6a\xc5\xc7\xe5\x43\x82\xf9\x08\x4c\x33\xdb\xee\xdd\x2c\xbc\xb4\xf5\x51\x98\xdc\xd8\x31\x3d\x3b\x71\xd2\xcc\xe9\x1d\x6c\x84\x7e\x74\xf7\x03\xf9\x8f\x46\x0f\x42\xfd\xe7\xfd\x4b\xd8\xdc\x25\xec\x77\xbf\xd8\x09\xfb\x76\x3f\x26\x3c\xba\xee\x86\x2b\x7e\xf6\xc0\xd5\xeb\xfb\xdf\xff\xc5\x2e\x38\x6f\xf7\x63\x8f\x3c\x2d\x7e\xb0\x96\xbe\x97\x01\x6f\xf1\x68\x1e\x0b\xce\x63\x67\xc3\x59\x7c\x1b\xd2\xc4\x2f\x33\x65\x10\x85\x4e\xfc\x9d\xfc\x56\x9e\x59\xc0\x5f\xc6\xaf\xe1\xd9\x1e\x1e\x36\xf0\x1d\x3c\x12\x41\x2b\x5f\xc6\xb3\x97\xf3\x38\x39\x13\x58\x7c\x59\xd7\x6b\xfc\x07\x3c\x73\x37\xbf\x8d\xcf\xf1\xec\x8d\x3c\x9c\xc6\xe3\x02\xec\x07\x3c\xe4\x71\xc2\x46\x37\x77\x7e\xd7\x3e\x1e\xcd\x47\xc8\xdb\x3d\xd3\xb3\x5d\x87\xc8\xcb\xd5\x19\xdb\x98\xb3\xbb\x3a\x79\x18\xe5\x1b\x28\x51\x66\x24\xf9\x1c\x9f\xa8\x41\x4a\x96\x37\xb5\x76\xed\xe5\xa1\x48\x79\x09\xbf\x1a\xc1\x00\x32\xc0\xfc\x67\xfc\x31\xfa\x7e\x2f\xcf\x12\x64\x49\x75\xb2\x8b\xcf\x68\xf4\x5d\x66\x06\x32\xa8\xfa\x38\xed\x43\x0e\xc8\xe8\x45\x46\x89\x1c\xfd\x30\x67\x4e\x02\xfd\x2e\x4d\x10\x53\x45\x33\x40\x72\xe2\x27\x8d\xfa\x76\xff\xf6\xf1\x7c\x9b\x10\xa4\x31\xf1\xa5\xec\x6c\xe6\xcf\xa4\x1f\xd4\x20\x9e\xb1\xf1\x6a\x88\xf4\x4d\xa3\x7d\x59\x0b\xd5\x98\x01\x87\x39\xa4\x0e\xce\x49\x41\x7a\x96\x04\x1d\x79\x44\x05\xff\x67\xc2\x88\x94\xb0\x4b\xa4\x07\x3f\x27\x34\x91\x1c\x07\xd9\xd9\x6c\x13\xdf\x66\x8e\xa9\xbf\x7d\x1e\xaf\x65\x7f\x0b\x7e\x43\x72\x99\xdf\x92\x3d\x6a\x20\xb8\x01\x8c\x67\xca\xd9\x69\x40\x05\xfc\x99\x12\x86\xe5\x58\xa4\x4a\x6a\xc8\xfd\x63\x16\x3c\x8a\xa7\x6b\xf2\xbc\x1a\xf1\xb0\x45\xe0\x0d\x70\x52\xcf\xe1\xc3\x3d\xc2\x6e\x78\x0c\x2e\x10\xae\x12\xae\x82\x0b\x8a\x69\x00\x06\x85\x26\xac\x46\xcd\x31\xff\x98\xc5\x15\xd0\xd0\xc2\x88\x8d\x4d\x43\xa6\x5c\xd8\x8d\x89\xc0\x49\x70\x87\xb0\x11\x91\xbc\x41\xd8\x48\xeb\xfa\xd1\xc0\x17\xec\xf3\xb8\xae\x80\xc3\x59\x47\xc0\xc1\x7f\x20\xf3\x0c\x33\xde\x70\xe6\x9a\x6b\xba\xc2\x99\xab\xaf\xee\x0a\xaf\xbe\xea\x2a\xf4\xe7\x27\x3f\xe9\x0a\xef\xbd\xf2\xca\xae\x30\x1e\x85\xc0\x8f\x7f\x8c\x6e\x5e\x76\x19\xfa\xb3\x7c\x39\xba\xb9\x6c\x19\xfa\xb3\x74\x29\x42\x2c\x59\x42\x10\x4f\x5d\x7a\xa9\x88\xbc\xe4\x12\x04\xba\xe8\x22\xf4\x67\xd1\x22\x04\xba\xf0\x42\xf4\xe7\x82\x0b\x10\xf2\xfc\xf3\x29\x72\xe1\x42\x11\x79\xde\x79\x08\x34\x7f\x3e\xfa\x33\x6f\x1e\x02\xf5\xf5\xa1\x3f\xbd\xbd\xe8\xcf\xdc\xb9\x14\x39\x67\x8e\x88\x9c\x3d\x1b\x81\xb2\x59\x74\x6b\xe6\x4c\xf4\xea\x9c\x73\xd0\xab\x19\x33\xd0\x9f\xe9\xd3\x29\x72\xda\x34\x8a\x2c\x9b\x3a\x15\xdd\x9f\x32\x05\xfd\xe9\xee\x46\x7f\x26\x4f\x46\x7f\x26\x4d\x42\xc8\x89\x13\xd1\x9f\x09\x13\x28\xfc\xec\xb3\xf1\x35\xf3\x54\x67\x27\xbd\x8e\x1d\x8b\xaf\xab\x9f\xea\xe8\xa0\xef\xc7\x8c\xa1\xd7\xd1\xa3\xf1\x15\x3c\x35\x6a\x14\xba\x0a\x7b\x9f\xca\x64\xe8\xfb\xf6\x76\x7a\x1d\x39\x92\xe2\xda\xda\x68\xf9\x11\x23\xe8\x75\xf8\x70\xfa\xf9\xb0\x61\x14\xd7\xda\x4a\xdf\xb7\xb4\xd0\x6b\x73\x33\xc5\x35\x35\xd1\xf7\x8d\x8d\xf4\xda\xd0\x40\x3f\x4f\xa7\xe9\x35\x95\xa2\xe5\xeb\xeb\xe9\xb5\xae\x8e\xe2\x92\x49\x7a\xbf\xb6\x96\x5e\x6b\x6a\x68\xbb\xaa\xab\xe9\x35\x91\xa0\x9f\x57\x56\xd2\x72\x15\x15\xb4\x5c\x3c\x4e\xaf\xb1\x18\xbd\x5f\x5e\x4e\xaf\xd1\x28\x2d\x17\x89\xd0\x6b\x59\x19\xbd\x86\xc3\xf4\x7e\x30\x48\xdf\x97\x96\xd2\xf2\x81\x00\xfd\xdc\xef\xa7\x9f\xfb\x7c\xf4\xbd\xd7\x4b\xdf\x7b\x3c\xf4\xea\x76\xd3\xcf\x9d\x4e\xfa\xde\xe1\xa0\xef\x2d\x16\xfa\xde\x6c\xa6\x57\x93\x89\x5e\x8d\x46\x7a\x35\x18\xe8\x55\xaf\x27\xd7\xdd\x3a\x5d\x57\xe2\xff\xdb\x1f\xec\xef\xf6\xa9\x38\xe6\x2f\xaa\x69\xc8\x04\x38\x32\x5a\x64\x8d\x38\xc8\x74\x67\x91\x27\xcf\x1f\x5d\xd8\x18\x66\xfe\x72\xf2\x13\x36\xa2\xe2\xba\x91\xdf\xbf\x17\x19\x94\x97\x88\x2d\xb1\xee\x61\x11\x9c\x41\xd3\x86\x64\xbb\x08\x0e\x23\x93\x21\x9c\x5c\xc8\xee\x5b\x80\x10\x1c\x78\x78\xe0\x0b\x78\x0f\x7f\x91\x18\xff\x24\xc1\xb8\x4c\x2c\xea\x36\x00\x50\x85\x22\x20\x55\x5d\x7d\xd8\xf7\x40\x36\x5e\xf3\x40\x36\x1c\x0f\xc7\x1d\xac\xc3\xf4\x40\xd6\xc1\xa2\x90\x28\xcb\xd2\x3d\x29\xcd\xfb\xc8\x4e\x94\xad\xee\x64\x52\x4e\x1f\xd1\x43\x8f\x0b\x63\x22\xcb\xff\xe2\x35\xbc\x47\x8a\x85\x4e\x75\x95\x62\x24\xee\x47\xe2\x0b\x61\xbc\xf4\xa2\x5d\x0e\x97\x14\xf1\x81\x09\x0c\xcb\x78\x39\x93\xc9\xc8\xeb\x34\x3a\x03\x34\x18\x8d\x66\xbd\xc9\xa4\x41\x31\x82\x51\xcd\x92\x28\xc1\x42\xe3\x04\x45\xa0\x90\x8f\x15\xd2\x16\x7c\x4e\x6c\xc4\x82\x4f\xed\xc6\xf1\xc2\x3e\x14\x8c\xec\xdb\x27\xc5\x0b\x28\x14\x11\x23\x06\x46\xe6\xc7\xa2\x5e\xac\xcb\x38\xa0\x5a\xad\xd5\xea\x50\xbc\xa5\xd3\x19\x34\x1c\x32\x67\xbc\x8e\xe5\x8b\x42\x12\x4b\x41\x4c\xc2\x5a\x68\x50\xf2\x20\x1c\x26\xbc\x36\x05\x07\x25\x98\x87\xf0\x20\xdc\x2d\x86\x25\x70\xc0\x8c\x78\x1c\x43\x3c\x70\x2c\xc7\xb1\x00\x42\x15\x07\xa5\xec\x3d\x39\xc1\x3d\x62\x61\xc3\x6c\xd5\xb4\xd7\xe0\x67\xaf\x09\x47\xf9\x18\xbc\x44\xb8\x13\xc8\xe5\x7e\x4a\xce\xdf\x34\xa8\xb0\xe8\x20\xdb\xca\x31\x3c\x33\x28\x96\xc3\x35\xf0\x41\x44\xe1\xd8\x31\x31\xde\x7a\x4e\x38\x0b\xfb\xa6\x01\x0b\xa2\x71\x94\xbf\x11\xd1\xd0\x81\x86\x8c\x4b\x8b\x4f\xe0\xe4\x11\x71\xbd\x8a\xd1\xa9\xb5\x3a\xf4\x0b\x35\x9c\xb8\x1a\x40\x13\xe8\xe9\x41\x51\x1d\x4e\x9f\x37\xc7\xd5\xae\xaa\x69\xfb\x8f\x1e\xdd\x3f\xed\x9a\x6b\xae\x41\xb5\xe4\x9f\xfe\xe4\x93\xa7\x9f\x5e\xba\x74\x49\x61\xdc\x69\xc4\x71\x1d\x67\x34\xea\x35\x3a\x9d\x5e\x5f\xa2\x35\x1a\x55\x68\xcc\xf4\xf9\xb8\xae\xb0\x17\xa5\xb1\x52\x8e\x94\x5b\x1e\x28\x61\xa3\x34\x4e\x80\x63\x5c\x0c\x8e\x35\x74\xa0\x04\x8c\xce\x44\x8c\xbc\x06\xc2\x12\x15\xea\x0b\x93\x59\xc3\x1b\x39\xe3\x91\x2c\x58\xc5\xdd\xc6\x6d\xe6\x58\x8e\x83\x7a\xf5\xc7\xf0\x13\x7c\x68\x3a\x39\x09\x59\x0a\xf9\xf3\x67\x39\xe3\x0c\x3b\x62\xda\x88\xeb\xe1\x40\x7e\x38\x0c\xbf\x5d\x2b\xdc\x07\x6f\xba\xe8\xbc\xaf\x19\xe1\x4b\xe8\x62\xf6\x6c\xde\x3c\x8f\x89\xf5\x7f\x76\x3e\xfc\x4a\xa0\x67\xcc\x27\x19\x1d\x53\x87\xf8\x97\x82\xf6\x4c\xc8\xef\xf2\xba\xb4\xf8\xe1\x84\x60\x08\xd8\x0f\x67\x01\x70\xab\xdc\xbe\x23\x59\xf7\xc7\xaa\x92\xc3\x68\x42\xff\x29\xce\x74\x15\x6c\xf8\x4a\xcf\x35\xa6\x47\x60\x42\xf1\xf0\x5b\x7c\xb8\xb9\x74\x6a\x54\xa4\x4c\x4d\x02\x67\x47\x73\x13\xf4\xde\x74\xdb\xfa\x3b\x57\x9f\xab\x6e\xf6\x39\xce\x0a\x9c\xd3\x3d\xed\xdc\xb6\x9a\x61\x70\x8f\x70\xb7\x2b\xc5\xb1\xab\x2f\x59\xb9\xde\xfb\xc2\x92\x12\xdb\xcc\x05\x0b\x26\x95\xc0\xdb\x96\x7c\xc8\xeb\xe8\x33\x87\x31\xc6\xcd\xa0\x10\x02\x68\x40\x32\xe3\xe4\x55\x2a\xa8\xe6\x20\xa7\xd5\xf1\x9f\x70\x8c\x86\xd1\xa0\xde\x61\x3e\x26\x4f\xf1\xe1\x1a\xb5\xcb\x15\xa2\x03\x8c\xcf\x7f\x46\x9d\x30\xb7\x85\x89\x0a\x0f\xcf\x83\x33\x84\x3b\xb8\x73\xfe\x3c\xba\x3f\xc0\x3c\x4d\x9f\x23\x2c\x63\xb4\xcc\x24\xfe\x2c\xf2\x1c\x61\x0d\x58\x94\x19\xc6\x82\x80\xc9\x65\x89\x80\x0a\x0b\xb0\xa8\x02\x06\x97\xca\xa0\xaa\x4d\x9a\xd8\x84\x37\xe1\x3d\x9c\x35\x24\xfc\x89\x09\x89\xd9\x89\xc5\x09\x5e\xcb\x26\x12\x5a\xbb\xbd\xfc\x70\xd6\xfe\x27\x6d\x08\x75\xcd\xa7\x40\xb9\x13\x2e\x7e\x82\x90\x98\x20\x39\x40\x16\xc3\x23\x1c\x69\x59\x5b\x69\x42\x50\x3c\x61\x0b\x1b\x9a\x66\xd1\xda\x28\xc3\x5f\xb6\x41\x7e\xc9\x34\x74\xb4\x8e\xed\x59\x7b\xc7\xda\xb5\x53\xc6\x5e\x73\xfd\x55\x2b\x57\x5d\x78\x56\xf7\xc4\xd1\xa3\x27\x4e\x1a\xe7\x5e\x39\x72\xf8\xf0\x91\xed\x23\xb9\x15\xa3\x67\xbb\xdd\x17\x4c\xb9\xe8\xaa\x2b\x2f\xee\xbe\xd0\xdd\x78\xed\x82\x8b\x97\x08\xa8\x8f\x27\x9e\x3b\x6b\xc2\x04\xf8\x87\x3b\xcf\x3a\x7b\x62\x66\x14\xed\xcf\x08\x92\xb7\xf3\xb9\x73\x81\x0f\x74\x67\x12\xc0\x6a\x75\xe9\x55\x2e\x95\x3f\xe0\xb2\xea\x55\x1a\x77\xc6\xeb\x65\x2c\x78\x52\x64\x3a\x9c\x4d\x32\xed\x4c\x2f\x73\x29\xb3\x13\xc9\xa2\x43\x83\xa4\x2e\x7d\x60\x8e\x98\x10\x43\x13\x00\xef\x41\xf3\xc1\x54\x2a\xa5\x38\x44\x1a\x75\x78\x93\x78\x2c\x18\x3e\x29\x8c\x8c\xbd\xf8\x3a\xde\x98\xfe\x64\xe9\x88\xf1\x93\x3b\x8e\x37\x97\xa5\xab\x26\xb5\x9e\xe8\xe8\x78\x9a\x2b\x1d\x31\x7d\x8a\x70\x9f\xa9\xbc\xdc\x04\xe7\xa6\x92\x16\xa1\x87\xbc\x3c\x60\x2a\xa7\xb1\x67\x6c\xa0\x9d\x31\xc0\x5b\x80\x17\x79\x80\x31\x19\x4b\xd0\xa2\x89\x44\xdc\x06\xce\xc0\x45\xcb\x23\x1a\x4d\x58\xf7\x2c\x1c\x97\xf3\x59\x2c\x9c\xfa\x59\xd8\xb5\xdb\x6d\x07\xcf\xc2\x4e\x7a\xc8\x39\x52\x45\xc5\x21\xe7\xe2\xf9\x66\x54\x3a\x71\x75\xe2\xa8\xcf\x1b\x1b\x46\xc2\x76\x88\x8f\x47\x26\x67\xcd\xdb\x48\x6a\x2c\x9d\x6a\x86\xd6\xb9\xd3\xcf\x7a\xc0\xd0\xb1\xe8\x8e\xfa\x99\x73\xa7\x9f\xd3\x9e\xb4\x97\x2d\xb8\x6f\x72\x77\xeb\x8c\xe1\x67\xc1\x5b\x26\x4d\x10\xae\x37\xf9\x5a\x3a\x1e\x1b\x31\x3e\xc2\x30\xd9\xa5\xfe\xce\xab\x1c\xc2\x9f\x18\x66\xd8\xa8\x45\xf8\x39\xbe\xe8\x40\x3b\xfc\x12\xae\x07\x56\xe0\x06\xe9\x8c\x05\x38\x1c\x46\xa7\xda\x6a\xb4\x7a\xbc\xe8\xa5\xce\x66\x7a\x01\xd5\x8f\x03\x3a\x38\xae\xf8\x00\x6e\xb1\xf3\x9a\xc9\x58\x37\x3b\xc8\xa1\xc8\x8d\xe6\x74\x2a\x00\xe3\x65\x8e\x74\x43\xec\xf6\x73\x66\x76\xf4\x04\xfa\x9a\xaf\xbd\xfa\xeb\x0f\x3f\xbc\xf6\x9f\xcd\xe7\xeb\xaf\x5c\x68\x2d\xb3\x04\xd6\x6d\x86\xe5\xdf\xd6\xff\xfb\xd7\x17\xd1\xbc\x61\xf9\xc0\x48\xa6\x16\xde\x4a\xe6\x83\xe5\x19\x9d\x19\xe9\x0f\x0f\x9c\x2e\xa3\x1a\x33\xb6\x01\x46\x64\xac\x38\xed\xbe\xdc\x1c\xc6\x9c\xc2\x85\x93\x31\xa6\x56\xf8\x6e\xf5\xb5\x90\x5f\xbd\x66\xf1\xf8\x9e\x49\x67\x9d\x35\xa9\x67\xfc\xf9\xc2\xef\xef\xbb\x13\xc6\xee\xbe\x73\xf5\x8a\x4b\x6e\xbe\x79\xd9\x4f\x88\x1c\x71\x03\x67\x33\x53\xe0\x2a\x24\x47\x3d\x19\xbf\xca\x6a\xb4\x7b\x38\xa3\x47\xef\xd3\xfb\xfc\x01\x8f\xdd\x6e\xb4\x5a\x6d\x5e\x03\xcf\x69\x9d\xa6\x67\xe1\xd8\x67\x7c\x1c\xa7\x57\xa9\x18\x2d\x1a\x2b\xc5\xc9\xfb\x64\x8d\x56\x39\x54\xf4\x00\x3f\x34\x58\x3c\x3e\x02\x38\x8e\x0f\xeb\x6d\x6c\x87\x49\x88\x4f\xe8\x73\x35\x23\x29\x72\x98\xa0\x8d\x99\x32\x00\xce\xbe\xee\xfe\x89\x6f\x8e\x7e\xee\xe1\x31\x10\x9c\xbd\x78\xe5\xc4\x37\x47\x6d\x7e\x7e\x83\xcf\x57\xf2\xfa\x1b\x46\x9f\x4f\x77\xe2\x9f\x26\x9f\xcf\xbc\xf5\x61\x7c\x54\xff\x41\xe1\x6f\x54\x96\xe0\x3f\xf2\x63\x83\xc6\x05\x0f\x8f\xd5\xe8\xf1\x3a\xad\x56\x32\x36\xe3\xc8\xd8\x74\x0e\x75\x38\x3a\xee\x29\x6a\xc9\x1a\xe9\xb9\x77\xe6\x48\x59\x1b\x74\xa5\x1a\x23\x76\x27\xbc\xb6\x68\x70\x16\xca\x83\x23\x7c\x24\x0d\x0e\xc4\x27\xa4\x71\xbf\xe4\xaf\x05\x75\xe0\xfc\x4c\xb3\x35\x5c\x59\xe9\x84\x3e\x3d\x64\x55\xb5\xaa\xda\xfa\x14\x53\x11\xae\xe8\xcd\x3a\xc3\x9e\x50\x6f\xd6\xe3\xea\xcd\x86\x3d\x61\x4f\x9d\xa9\x12\xd6\xc1\xde\x6c\x6d\x9d\x55\xaf\x31\x69\x7a\xb3\x26\x96\xae\x55\x89\xa7\x20\xe2\xbe\xa2\xe1\x0d\x48\x4b\xcb\x8d\xa8\x03\x5d\x54\x9c\x50\x07\x96\x37\x5b\x22\x65\x51\x3c\xb8\x41\x18\x89\x8b\xa3\x3b\x1c\x92\xc3\x0e\xd1\xfb\x04\xb4\xa4\x9b\x91\x7f\x8a\xa3\x48\x02\x9f\xef\xcf\x86\xe1\xd3\xd7\xf8\xfe\x22\xf4\xc3\x7f\xdc\xf5\x0b\xae\xcd\xd3\x77\xd3\xf6\x8d\x8f\x6e\xb4\x5d\xc3\xbc\xd3\xee\x9d\xbd\xfc\xc6\x3f\x78\x47\x8e\xf4\xfe\xe1\x91\x35\xd3\x2a\xda\xf5\xfd\x5c\x8d\x07\xce\x17\x8e\xc0\x6f\x63\x5f\xae\x6f\x79\xe7\x0f\xbf\xf9\x1d\xbc\xdc\x53\xf3\xcd\x7d\x1a\xe1\xc9\x4b\x84\x77\x96\x08\x9b\xb4\xdb\x85\xef\x90\x6d\x9d\x36\x70\x15\x77\x84\x7f\x03\xc4\x91\x65\x4d\x83\x7b\x32\x3d\xbc\xc1\xe8\xe1\xbc\x1c\x53\x5f\xe7\xe7\x7c\x6c\x69\x6d\x1a\x72\x20\x18\xae\x4a\xc4\xb8\x78\x45\x30\xe4\xf3\x82\x38\xcb\x69\xb8\xb8\x37\xc4\x47\xed\x51\x7b\x43\x63\xc8\xeb\xf5\x5b\x6b\xab\xaa\xa0\xab\xce\xe4\x32\xf5\x66\xed\x2e\x5b\xc2\x90\x86\xe9\xde\x2c\x1b\x8f\xc7\x34\x28\x84\xc4\xa2\x94\x4e\x27\xa9\x1f\xcc\xf7\x8c\x05\xbf\x4e\x2a\xfb\x84\xfe\xa6\xf0\x6b\xc5\x7f\xbc\x4c\xef\x6a\x4e\xab\x9d\x2e\x1b\xea\x92\x38\xc4\xd2\x8f\xfb\x02\x1f\x7b\xa8\x8e\x34\xc7\xc8\x1f\x06\xf5\x61\x33\x34\xbb\xa0\x8a\xb1\x39\x5d\x30\x16\x67\x1f\x48\x5c\x96\xec\x4e\x75\xf5\xa8\x46\x97\x96\xb7\x09\x57\xb4\x8c\x5f\xf6\x9b\xe1\xe5\xa3\x54\x1f\xf7\x4f\xed\xaa\xea\x4e\xa6\x5b\x46\x74\x77\xdd\x72\x07\x73\x20\xd1\xff\xc7\x2b\xe1\xf9\x27\x0f\xe7\x6a\x9b\xe1\xcd\xf5\xa3\xf8\x37\x56\x6b\xd7\xde\xad\xb3\x0a\x1f\xed\x70\xb9\x7e\x58\x61\x6c\xae\x7d\x5d\xd8\xdf\x6e\x58\x79\x8b\xc1\xf3\x8b\xf7\xa6\xc2\xe8\x1b\xcc\x8b\x2b\x4f\xbe\x2e\x7c\x74\x1f\x17\xe3\x84\x77\x4e\xbe\x5d\xee\xe4\xd6\x1a\xd4\x48\x76\xa6\x0d\x7c\x85\xfa\x71\x02\x48\x80\x79\x99\xfa\x50\x85\x5a\x1d\x71\x47\xa0\xd5\x60\x35\x54\xd7\xa8\x2a\x2a\x90\x17\x9b\x9f\xc5\xcf\x17\x46\x7b\xb3\xb1\x98\xc9\xe1\x08\xf4\x66\xdd\x0e\x2e\xa2\x36\xa9\x7b\xb3\x06\x93\x4d\x7c\xc0\xdd\x2d\x79\xc8\xe4\xe0\x85\x0d\x85\xda\xa1\xe0\x01\x9f\xc0\x6d\xc1\xd6\x11\xf7\x43\x08\x58\xcc\x20\x9c\xc2\xfd\x53\x0b\x23\x21\xc6\x62\xb7\xba\xb0\x08\xb9\x90\x22\x70\xe7\x25\x86\xa5\xd6\xa6\x16\xef\x1b\x41\x1a\x2f\x3c\x2f\xdc\x0d\xe7\xc2\x99\xef\x1c\x43\xfd\xd2\xf9\x5c\x9f\x30\xf0\xd5\xff\x3c\x78\x05\xb4\x6a\x47\x1c\x1c\xc1\x96\x0b\x97\xf8\x9c\xfd\xef\x33\x8d\xa4\xd1\xf0\x47\x30\x03\xcf\x85\x3f\x4a\xa3\xbe\x48\x24\x85\xdf\x09\xbf\xfa\x4e\xf8\xac\x9a\xb9\xd2\x53\x73\x79\x6a\x36\xb1\x2d\x7e\xd4\xac\x87\x90\xcf\x0f\x82\x1b\x33\x67\xb3\x7e\x9b\x07\xf2\xbc\x41\xa7\xb3\x85\xc2\x9c\xc1\x68\xe8\xcd\x42\xa3\x0f\x78\x40\x5f\xb6\xd4\xe4\x69\xf7\x30\x26\x23\xd4\xb3\x1e\xa3\xc7\xa8\xb6\x58\xdc\x7d\x59\x93\x1d\xea\x38\xbb\xc5\x82\x44\xc6\xc2\xea\x78\x35\xdf\x9b\x55\x5b\x7b\xc3\xb0\x3d\x4c\x33\x59\xf4\x30\x4c\xf4\x57\xf6\xd2\x48\x93\x70\x66\x84\xca\x8f\x42\x9f\x88\xa1\x42\xdd\x43\x9e\x5b\x40\xbf\xe4\x60\xf2\xc6\x48\x63\x9a\x1c\x83\x49\xd5\x28\x4c\xd4\x08\xfe\x14\x5a\x85\xaf\xdf\xec\x7f\x7f\xf3\x93\x4f\x6e\x67\xd7\x8c\x0e\x2d\x79\x6f\x29\xbc\x38\xd8\xd6\x16\x64\x16\x1c\xee\xf9\x93\xaf\xb1\xd1\xf7\xa7\x1e\xf6\x12\x6f\xa3\xf0\xf2\x87\x25\xfd\x1f\x6d\x11\x16\x6c\xc5\xed\xbc\x12\xb5\xf3\x15\x32\xb6\x87\x32\xf3\x9d\x1e\xa4\x15\x76\x14\x03\xb3\xea\xd2\x4a\x2e\x91\x08\xdb\xd5\x2e\x7f\x89\x5f\x5d\xc9\x45\xcb\xa2\x65\xd5\x35\x99\x9a\xbe\x9a\xd5\x35\x6c\x48\x7c\xb1\xa5\x66\x57\x8d\x0a\xd4\xd0\xb7\xdc\x70\xf9\x15\x7e\xf1\x59\x0d\x0b\x6a\xf6\xe2\x8b\x96\x2d\x0f\x47\x4b\xab\x12\x55\xcb\xb3\xbe\x04\x9e\xf3\xd7\x6a\x4c\x5d\x09\x2e\xe3\x61\x39\x76\x79\xd6\x79\x29\xb7\x8a\x63\x38\x9c\x30\xe2\xb8\xb0\x0e\x84\xa1\x86\x8d\x86\x57\x64\xa3\x6e\x9d\x75\x79\xb6\xa4\x44\x87\xd7\x99\x92\x74\x9b\xff\x5e\x72\x60\x28\x12\x9d\x39\xd2\x57\x26\x7e\x9b\x10\x9f\x9c\x6b\xc5\x27\xb1\x2e\x5d\x36\x57\x3e\x88\x95\xea\x1c\x7d\x5c\x25\xaf\x6c\xb1\x38\xea\x3a\x31\xd2\x71\x59\x88\x55\xb2\xd8\x5d\xa8\x63\x9d\x2e\x14\x24\x97\x40\x75\x18\xf7\x6f\x53\x1b\x72\xc9\x70\xac\x2e\xb4\x75\xd5\x98\x77\xde\x6e\x59\x71\xc5\xa8\xc8\x9c\x05\x47\x02\xd0\x29\x7c\x6f\x60\xbe\xfb\x37\xdf\x39\x95\xd9\x7d\xf2\xf9\xae\xdb\x3e\x64\xd8\xc8\xe4\x9e\x8d\xeb\x1e\xdb\x63\xf2\x0b\xc2\xb6\x46\xe1\xdb\xb5\x9b\x7a\xa6\x06\x7b\x26\x5c\x37\x6e\xc3\xe5\x99\xab\x57\xb2\x3d\x34\xc6\x4b\x08\x27\x54\x1e\x6e\x13\x48\x81\x46\xd0\x0a\xd6\x66\x3a\x41\x65\x65\x28\xdc\xe2\xf7\x97\xa5\xb5\x3a\x5d\x3a\xcc\xd6\x3a\xcc\xb5\xe6\xe1\x0d\x65\xbe\x96\x96\x48\x59\x64\x18\x5b\x9f\xec\xcd\xd6\x9b\x1a\xd3\x95\x7e\x74\xa3\xba\x16\x19\xe4\xa0\xad\xda\xea\x8e\xb1\xb1\xf9\xd9\x26\x95\x0a\xa9\x9c\x51\xcb\x9a\x41\xfb\x6f\x45\x3f\x26\xea\x57\xfa\x35\x7a\x3c\x6d\x3a\x9d\x16\xe3\x40\xc9\xf0\xd0\x90\x54\x5c\x55\x91\xa7\x1f\x90\x38\x13\x57\x53\xb3\x2d\xad\x46\x3d\xe2\x81\xf4\xd8\x7b\x12\x93\xa0\x38\x25\x8c\xa2\x77\x39\x86\xa2\xe7\xe1\x87\x61\xa3\x1a\xd9\xa0\x66\xd8\x79\xf6\x63\x99\xb1\x97\x07\x22\xe9\xcb\xba\x17\x5e\xda\x76\xec\x4a\x61\xfa\x2d\x5b\xca\x67\x9d\x7f\xab\x70\xf3\xc5\xdd\x90\x99\x3e\x7d\xe6\xf5\xb7\x0a\x33\xae\xb8\x02\xda\xe0\x6d\xd5\xaf\xa8\x78\x17\xdb\x97\x18\xd6\xd0\xea\xb0\xc3\xc0\xf7\x61\xe1\x4b\x7c\xd0\x6a\x8d\x87\x99\xb9\xdd\xd8\x2f\xa8\x3c\x35\xc2\x09\xe6\x4a\x58\x3f\x35\x1b\xe8\xf7\xe0\xcf\xd9\x90\xa7\xe6\xe4\x86\xf9\x8b\x99\x2f\x6d\xa5\x2d\x68\x96\x88\x4f\x61\xe4\x9f\x40\xba\x58\x0e\x2a\x91\x25\xaf\x43\xb6\xfc\xf6\x4c\x0f\x17\xab\x65\x3d\xa0\xcc\xc3\x96\x3a\xab\xeb\x59\xb5\xd9\xae\x66\x0d\xa5\x86\x86\x46\xbb\x3b\xc5\x86\xc2\xc8\x91\x59\x62\x55\x6c\xd8\x5c\x59\xc3\x46\xcb\x91\x65\xe2\x8d\xb5\x48\x0e\x93\xe5\xe5\xc9\x30\xeb\x67\x3d\xa5\xfe\xd2\xde\x6c\xda\xe9\xb7\x1a\xd4\x90\x45\x5e\xae\x0e\x4d\xde\xe4\x25\x0c\xe9\xd4\x5a\x2c\x34\x48\x31\x93\x16\x17\x7e\x4b\x16\xa7\xe8\x35\xff\x4c\x80\xf4\x64\x80\x8d\x74\x8e\x74\x92\x2f\x92\x25\x07\x99\x74\xc1\xb0\xd8\x75\x48\xec\x90\xd6\xc2\x70\x3c\xcc\xa7\x1b\xc3\xe5\x69\x16\x46\x5c\x7f\xd9\x0e\xef\x85\x13\xe0\xc2\x1c\x7c\x63\xfb\x4b\xe8\x67\x9e\xb0\x5d\xf0\xe4\x84\xe6\xed\xcf\x3c\xf3\x0c\x0c\xc1\x9d\xb7\x08\x9f\x30\x77\x6f\x16\xde\xed\xff\xfe\xcb\x2f\xd9\xf4\xc2\x85\x6c\x2f\xbc\x0d\xa9\x6f\x19\xfe\xdb\xe8\x15\x96\xf6\x1c\xe8\x11\x2c\xf0\xa8\x30\x0f\xeb\x36\xdc\x8c\xdf\x1e\x3a\x70\xe0\x40\x0f\x3c\xa7\xbf\xf5\x2e\x7c\x34\x6b\xf5\xc0\x57\xea\xf3\xc8\xbc\xc5\x83\x7a\x2d\x0b\xde\xcf\x5c\xc9\x97\x94\x00\x6d\xb4\xa2\x22\x1c\x98\xd6\xd2\xd9\x19\xd0\xb2\xb6\xf6\x09\xf5\xb6\xfa\x73\x67\x81\x59\xa1\x59\x4c\x09\x3b\xad\x7d\x5c\x43\xc3\x88\xc9\xd9\x19\x2d\xd0\xd1\x02\x59\xd0\x02\x75\x7c\x4b\x83\xd3\x9b\xe8\xcb\x7a\x9d\xe3\xa6\x4c\xce\x7a\x26\x8c\x9b\x90\x9d\xc0\xb2\xa6\x09\x50\xa7\x9a\x30\x6e\x5c\x34\x1e\x8c\x06\x27\x67\x23\xd1\x4c\x38\x6a\xe4\xfb\xb2\x51\x63\xd4\x68\x76\x3a\xb9\xbe\xac\xd3\x8e\x42\x0a\xd6\x56\x62\x2e\xe9\xcd\x9a\xad\xb2\xd5\xcb\x27\x46\xa8\x0a\x1f\xa4\x26\xcf\x9d\x4c\xd3\xb3\x94\xc5\x03\x3d\xe8\x3b\xd1\x3a\xc2\x5e\xf1\xa8\x60\x71\x69\xb0\x50\x8a\x1b\x48\x2c\x91\x6a\x6a\xb6\xab\x12\x30\x2f\xaa\x29\xa7\x0d\xc5\x96\x16\x1c\xbe\xa5\xc9\x68\x48\xc1\x2d\x4d\xc0\xa0\x50\xce\xe5\xa4\x33\xc4\x24\xac\x85\xc4\x26\xe0\xd8\x1c\x79\x19\x12\xa9\xa0\xf9\x23\xf3\xdd\x86\x3d\xb1\xea\xc7\x1f\x7a\xf1\xe8\xdf\x66\x3d\xd9\xdf\xbf\xf9\x7e\xb8\xe5\xd8\x37\xbf\x9e\x3e\x75\xce\x9c\xf3\xdb\x1f\x79\x24\x19\xab\x1d\x13\xb9\x84\xd9\x73\xeb\xb5\x23\x1e\xac\xa8\x89\xb7\xcd\xcd\x74\xb6\xb6\x8d\x5d\xd4\xb3\xfe\x27\xd3\xd7\x24\xab\x6c\xe3\x62\x4d\xc3\xbb\x56\xcc\xed\x63\x77\x3d\xb2\xbe\xff\x86\x0d\xbb\xde\x7e\x4f\x18\x8d\x07\x0a\x9f\xd2\xfc\xca\x0f\x4b\x96\x9d\x0f\x1f\x8e\xc4\x9f\x79\x66\xbc\x70\xde\xa8\xd1\xe6\x66\x4f\xe9\xa1\x4b\x97\x7b\x4c\x6f\x5d\xd2\x31\xbc\xa5\x6a\x98\xd3\x15\xfd\xd1\xf8\xec\xf9\xc1\x5f\x5d\xec\x72\x37\xd5\x44\x93\xf1\xd0\x85\xe4\xbb\x44\x03\x5f\x69\x6e\x24\xb9\xe0\x46\x92\x0b\x9e\xc1\x3f\x85\x9f\x8d\xcd\x31\x5b\xca\x61\x39\x49\xc3\x99\xba\xca\x21\x3e\xf4\x0a\x90\xf5\x19\x72\x8e\x12\x1a\xff\x38\xb2\xee\x49\xa4\x35\x4d\xc8\xfa\x8c\x00\x37\x67\xba\x7c\xce\xb2\xb8\x33\xde\x36\x32\x5e\x56\xe6\x1b\x51\x5a\xea\xf4\xb9\x7d\xbd\xd9\xd6\x26\xbd\xda\x64\x46\x2e\xab\xae\xba\x82\x33\x23\x9b\xcb\xda\xec\xb6\xde\xec\xb0\x90\x1f\xd8\xcd\x66\x68\xb6\xc3\xa4\x1d\xfd\x35\xdb\x8d\x51\x37\xdb\xdc\xd0\xa0\x35\xda\x68\x20\xdd\x4e\xd3\x1b\x73\x96\x2e\x25\x59\x2e\xd1\x06\x29\x5f\xd3\x2c\x01\xfd\xcd\x07\xff\x68\x58\x22\xd8\xe0\xb2\x11\x96\xfc\x6f\x0c\x63\xeb\xcc\x12\x15\xb2\x85\x6d\x69\xf4\x9f\xbc\x86\xe9\x66\xa4\x35\xf8\x7f\x3c\x02\x9b\x23\x7c\x73\x04\xa6\xe3\xaa\x5b\xdf\xf9\xc7\x58\x98\x12\x76\xef\x6e\x7c\x4d\x78\xfb\xcd\xc6\xa7\x85\x5f\xc0\x74\xe7\x3f\xde\x59\x7b\x39\x03\xf6\xdf\x08\x6f\xbd\xa7\xe6\x36\xb8\x72\xf5\x3b\xf0\x97\x97\xff\x60\x7e\x71\xb2\xb0\x93\xad\xd9\x33\x4a\x78\x51\xb8\xf3\x9b\x89\x33\x84\x8f\xc6\x5e\xcb\xd6\xb6\x5e\x2d\xdc\xeb\xd2\xb3\xbd\x48\x6d\xfa\xbf\x61\x4a\xf0\x7f\xf4\x52\xd2\x2d\xb8\x5a\x58\x4d\x5f\xf7\x4f\x3d\x80\x7f\x84\xba\xdd\xbb\x77\xc3\x25\xa5\x78\x9e\x73\xfd\xc0\xa7\xdc\x4c\xee\x56\x34\x2b\xec\x02\xd3\x33\x2e\x0f\x88\xd6\x58\xd5\x8d\xa3\x46\xa9\x6b\x00\x37\x7e\x5c\x49\xc9\x98\xaa\x2a\x76\xcc\x88\x51\x46\x38\x1f\x8c\x01\x29\x78\x01\x52\xbd\x31\xb0\x17\xa7\x29\xc9\x6b\x16\xce\xcb\x1f\x5c\x83\xc4\x3a\x69\x41\xff\xf2\xab\xa6\xa4\x6b\xcc\x6c\xb8\x0c\x09\xa5\x05\x4d\xcc\xc5\x93\xae\x91\xf4\x86\x53\xd6\xc6\x86\x24\x6c\xc0\x9f\xb8\x9c\x68\x02\x6f\x82\x64\xf6\x8e\x8d\x74\xb8\x8c\x71\xd8\x83\xd0\x4e\xe6\x6e\xf1\x98\xc5\x6c\x0b\xe3\x73\x6d\xb8\x99\xdb\x84\xf5\x53\x6b\xcc\x46\xbb\xcd\xa9\xd1\xb2\xae\x7a\xa8\x99\x31\x5a\xa3\x6d\xb4\xa8\xcc\xac\x55\x78\x4b\x6f\x77\x5a\x74\x5a\xde\x59\x27\x7c\x3b\x65\xac\x99\x35\x36\xe9\xb5\x68\xa6\xbd\x0d\x5e\x3e\x21\x69\x66\x76\x09\x6b\x84\x03\xd6\xea\xe1\x4c\x02\x29\x95\xc3\x6e\xf2\x0a\x91\xf6\x00\xb4\x7f\xf6\xc0\xe5\x37\xd8\x47\x18\xbc\x5b\xfb\xbf\xb7\xb9\xec\x6e\x9b\xd9\x03\x3f\x1d\xe5\x17\xbe\xf8\xfd\xb3\x8f\x35\x19\x9c\x23\xcc\xfa\x17\xa1\x1a\x5e\x05\x1b\xcc\x89\x11\xf8\x5c\x03\xe1\x3b\xce\xcf\xdf\x8a\x64\x76\xb4\x01\xef\xef\xfc\xae\x81\xe6\x00\x82\x03\x5f\xe1\x33\x6e\x91\x5d\xda\x92\xf1\x7b\x4c\x76\x10\xb7\xb3\xd5\xea\x70\x75\xb8\x3e\x65\xad\x05\xc8\xe5\x79\xe2\x55\x71\x64\x40\xaa\x70\xc4\x30\x4a\x6b\xe8\x32\x55\x41\x4d\x55\xc6\x24\x7d\x87\x12\xb0\xd1\xa8\x1f\x4d\x4a\x42\x50\xcb\x86\x42\x51\x1b\x8b\x62\x32\xa0\x31\x6b\x18\x8d\x86\xe5\x32\x29\x88\xfa\xfd\xb3\x14\xdc\x92\x82\x7d\x29\x88\xde\x8a\x8b\xe0\x28\x94\x98\x43\x57\x11\xa5\xc8\x8b\x64\x4a\xd2\xde\x83\xe8\x6d\xaa\x70\x2a\x23\x3e\x8b\x80\x6c\xbb\x15\xa0\x11\xc0\x93\x18\x62\x1b\xb0\xc8\x22\x03\x81\xa3\x06\x92\x62\x12\xe3\x75\x20\x86\x16\xcd\x91\xc6\xdb\x82\x10\xbc\x3b\xfe\xbe\xf3\xb9\x0e\x7b\xcd\x8a\x11\xb7\xdf\x6b\x85\x73\x85\x4d\x0c\x83\xa6\x2c\x5b\xed\x9b\x57\x4f\xbc\x36\xe6\x19\xc3\x3d\x96\x7b\x5b\xe8\x0f\x2e\x59\xc4\x30\x8b\xd8\x36\x68\x84\x8c\xa3\xf4\xe4\x0d\x89\xe4\xa7\x9f\x4d\xe9\x70\xb5\x58\x7a\x0e\x7d\xd4\x52\xb3\x59\xf8\xba\x1d\x96\x9c\xec\x69\xb4\x76\xba\xa6\xe0\x3e\x2b\xc3\xe7\x73\x23\x7d\x8e\x80\x3b\x33\x53\x39\xb5\xc6\xc8\xb2\x4c\xd0\x64\x72\x87\x19\x3d\x63\xd7\xd8\x35\xd1\x72\x26\x1c\x2e\xf5\xf8\x3c\xbd\xd9\x92\x60\x10\xcd\xbb\x9d\x2e\x67\x6f\x96\x6b\x77\x4d\x76\x31\x26\x57\xbb\xeb\x52\xd7\x2a\xd7\x4e\x17\xaf\x61\x5d\x19\x87\xa7\xcb\xe5\xb2\x46\x7c\xac\xc6\x64\xb2\x5b\x91\xa5\xb6\x5a\xf5\xc8\x46\xb7\x8b\xc6\x98\xcc\x40\xc9\x31\xed\x79\xdd\x95\x5e\x28\x4e\x57\x4a\xd1\x3c\x97\x18\x9f\xaa\x21\xee\x13\x1c\x44\xc0\x88\x3a\xef\xf7\x24\x9f\x08\xe3\x8d\xfc\xb8\x07\x84\xa6\x69\xf0\x6b\xa1\x07\x3e\x7e\x87\xf0\xac\x10\xb8\x64\xe9\xde\xfe\x77\xb7\xef\xdf\x8f\xcf\xb7\x9f\xc8\x34\xde\xc0\xb7\x21\xe5\xcb\x2c\xee\xe9\xff\xcc\xd7\xc8\x2c\x99\x25\x0c\xc7\x16\x93\x09\xf5\x30\xd5\x44\x15\xdf\xc3\x57\x2a\x3f\xe4\x6c\x4b\xd4\x17\x51\xb0\x34\x33\xa2\xd4\x5b\x56\xa6\x43\xb3\x23\xc6\xcc\x96\xc7\x90\xb1\xb2\x78\xdc\x06\x8b\xa1\x2f\xab\x62\xc3\xa5\x3a\x75\xc0\xeb\x0d\xaa\x4b\x35\xac\xca\xc7\xa1\x5f\x60\xb1\x94\xf4\xa1\xb0\xbc\x8c\x01\x0c\x12\x99\xbc\x63\x92\xfc\x92\x62\xba\x96\xb7\x5b\x54\x3d\xc5\x07\xb9\x71\xc3\xd4\x28\x0c\x57\xe3\x06\xe2\xfc\x0d\x4e\x53\x23\xe1\x40\xde\xa7\xd9\xa1\x76\x34\xe3\xb3\xfc\x1d\x70\xf8\xfb\xdf\xa3\x9f\x74\xff\x1c\xdf\x18\x6e\x63\x87\xaf\xf4\x37\x3f\xae\xff\x37\xfa\x79\x1f\xf9\xea\xbb\x2f\xee\xb9\xf8\xf6\x8b\x7b\x16\xc3\xb7\xed\xef\xc0\xe1\xc2\xfe\x77\xd4\x7a\xe1\xc6\xc5\x3d\x8b\x6f\x5f\xdc\x73\x91\xe0\xf6\x35\xa2\x98\xa7\x52\xb8\x50\xfd\x35\xff\x5b\x54\xbf\x61\xa0\x13\xcc\x00\xbd\xe0\xba\xcc\x59\xae\x89\x13\xcf\x89\xa4\xe3\x1a\x6d\xf3\x34\x23\x3f\x6a\xd4\x34\x6d\x3c\xc2\x83\xd9\x81\xe1\x00\x04\xe6\xf5\x75\x77\xcc\xf5\xce\xed\xcd\xc6\xcf\x4a\x9f\xd5\x9b\xad\x49\x9b\x47\xf6\x65\x43\x59\x14\xf8\x4c\x8c\xb0\x21\x6f\xda\x1c\x0a\x99\xd3\x6c\x9d\x4d\xcb\x7a\x51\x93\xd3\xaf\xa5\xf7\xb9\x5a\x71\x68\x83\x5a\x2b\x4f\xe1\x95\xc9\x5c\x8b\xec\x69\x2d\x05\x0f\x11\xa2\x89\x29\xab\x52\x47\x46\xc2\x66\x1b\x31\x4c\x10\x99\xa9\x38\x4d\x18\xd1\xa8\xba\xd9\x0b\x9b\x51\x20\xdd\xd8\x54\xde\xdc\xd4\xec\xc2\x39\x46\xab\xc3\xce\x70\x50\xb9\x06\x5f\xc2\xa8\x19\x35\x51\x1e\x64\xd0\x18\x48\xef\xa4\x53\xea\xaf\x77\xae\x5f\x3c\xa3\x25\x56\xfa\x94\x2f\xa5\x5d\x1a\x7d\xe0\x9a\xeb\x1e\xfb\xa1\xa1\xb3\xef\x92\xf6\xd8\xaa\x09\x33\xe7\x9c\xd7\x1d\x9b\x11\x08\xb5\xdd\x34\x73\xdd\x97\x4d\xbf\x84\x75\xb1\x89\xd7\xd6\x8d\xef\xbe\xff\xf0\xd5\x9b\x85\x7f\xb1\xeb\xa7\x77\x4d\x98\x3d\xf3\xac\x71\x73\x7e\x18\xa8\x1e\x37\x32\x35\x36\xdd\x7a\xd3\xd4\xcb\xf7\xff\xe4\xd5\xfe\xf3\x33\xe3\x12\x6d\x0b\x2f\x85\x4d\xeb\xb7\x4f\x14\x84\x87\xda\x5a\x37\xc5\xe0\xbe\x7b\x7e\xba\x41\x98\xe2\x6d\x49\x8d\xec\x3c\x7b\xdc\xc8\x6e\x87\x65\x13\xec\x86\xab\xce\xd3\x24\xfd\xc3\xa6\x32\xe5\x13\x7b\xdc\x63\x2e\xe4\xee\x14\xbe\x7d\xe4\x25\x61\xd7\x33\xb0\x74\xde\xd2\xcb\xe6\xce\xbb\xec\xc7\x9c\x71\xcc\xf6\x97\x0f\x0a\x7f\x58\x52\x93\x79\x1c\x8e\xdc\xf1\x27\x68\xfc\xe1\x68\x2c\x96\x98\x8e\xfd\x41\x99\x30\x9e\x7d\x1d\xd9\x32\x7c\x5e\xf8\xb4\x4c\x75\xc4\x19\x37\xd5\x68\x59\xad\xc9\xc9\xa5\xea\xfd\xc0\x43\xb2\x2a\x3e\x18\x53\xb1\xd6\xa4\x81\xe3\x58\x83\xa1\xaa\x2f\x6b\xe0\x58\x2b\x8f\x4f\x30\x4b\xb5\x4b\x29\x5b\xa4\x46\x78\x22\xdc\x2e\x1d\x62\x96\x7f\x8c\x86\xd7\xc3\x08\x44\x14\xc4\x2f\xb2\xa2\xfe\x54\x97\x32\x24\x75\xab\x88\x62\xe2\x36\xb1\x8b\x6d\x56\xb8\x6f\xef\xa6\x0e\xa8\x7d\xf1\xe6\x8b\xa6\x6e\xf9\xe9\xf9\x17\x4d\xbb\xf0\xbc\xb3\xe3\xbb\x7e\x3a\x61\x4c\x7d\x4d\x59\x5d\xa6\xb3\xeb\x9c\x7d\x1d\x23\x3a\xce\xbe\xe6\x0e\x17\x6c\x11\x3e\x85\x7f\x15\xde\x84\x25\x1f\x40\x76\xde\x43\xbb\xae\x5e\x3c\x59\xf8\xee\xc3\x8f\x0e\x3c\x35\xfd\xc6\xa7\x6d\x07\xaf\x72\x2c\x9c\xf3\x63\xe1\x17\xcc\xeb\xe3\x66\x2d\x5e\xb0\x43\x18\x80\xed\x28\xa6\x44\x36\x88\x9b\x8d\xf4\x2e\x04\xf0\xb7\x39\x53\x60\x53\xa6\x2f\x1a\x4f\xb1\x50\x57\x02\x59\x55\x5d\x45\xd8\x1e\x08\xb3\x6e\x95\xbb\x21\x9d\x42\x93\xe3\xfa\x80\x46\xab\xe9\xcd\x46\xbd\xda\x88\x8b\xcc\x9a\xe3\x76\x63\x77\xaa\x2f\xc5\x24\xb5\xed\xda\xc9\xda\x9d\xda\x97\xb5\x3c\x30\x9a\x8d\xc8\xa0\xa7\xb4\x46\xa3\x36\xc5\x72\x16\x4b\x35\xd2\x4e\x32\x71\x86\x2a\x4e\x85\xcc\x57\x61\xe8\x48\x23\x72\xf2\x14\x81\x45\x0e\x2c\xe8\x35\xff\xac\x6e\x5a\x8e\xcb\x61\x41\xfc\x9d\x6e\x44\xb6\x28\x84\xa7\x7a\x2e\xbb\x9a\x4c\xf8\x22\x30\x8e\x6c\x56\x53\x79\x18\x6b\xaf\x0d\xc5\x90\x61\x07\x7c\xec\xfd\xfe\x37\x37\xef\x47\x3f\xdb\xe1\xf7\x70\xdd\xc4\xc9\x23\x59\xd5\xa8\xe9\xd5\x7f\xcd\x41\x1f\x2b\x4c\x81\x4f\xf2\xc2\x24\xb8\xd9\x7f\xef\xba\xf9\x17\xac\xb9\x23\x20\x2c\x64\x4a\x68\x5c\xc7\xbc\xd4\x73\x4b\xcf\x2e\x6f\xe3\x40\xcf\xb0\xaa\x8a\x9e\x55\xd7\xc2\xad\x23\x6e\xa9\xdb\x31\xbd\xbb\xff\x86\x19\xdd\x8f\xd2\x7c\xf2\xb4\x81\x05\xfc\x4d\xfc\x9b\xa8\xef\xe2\x38\x93\x12\xb6\x6a\x83\xc1\xa8\x2a\x14\x62\x1d\x06\x3f\xeb\xaf\xa8\xf4\x39\xdd\xc8\x5e\xbb\xdd\xaa\x50\xa6\xd4\x66\x29\x57\x95\xf7\x66\xb5\xea\x8c\x8a\xb3\x46\x01\x9a\xc1\x90\xe3\xee\x48\x47\x78\x0f\xa6\xa5\x17\xd8\x4c\x2b\x92\x05\x56\xc9\x48\xe1\x04\x66\x14\xa7\x4e\xca\x1b\xd3\x0e\x32\xd5\x45\x6a\x6a\x41\x5a\x2b\x5a\x63\x4e\xed\x88\x40\xb3\xd5\x65\x51\x31\xcc\xef\x85\xb7\x84\x1d\xf0\x2c\x38\xa2\xe7\xd3\x0f\xc7\xf8\x46\xe7\x16\xf4\x3c\x54\xb1\x1d\x1e\xbd\x5e\xf8\xfe\xfd\x1e\x61\xd2\x1f\xff\xf0\xf9\x3b\x36\x03\xec\x85\xcd\xb0\x07\xce\x31\xae\x5e\xc5\xb5\x08\x9f\x3d\x5a\xdb\xc0\xfe\x30\x92\xab\x74\xc1\x95\xde\xa6\x26\xaf\x30\x61\x1a\xbf\x96\xad\x11\xfe\x2e\xbc\x65\xe2\x5e\xb6\x0a\xbf\xa3\xf3\x5e\x71\xef\x0b\xe4\xb1\x23\x48\x5a\x1e\xce\xcc\x36\x84\x22\x51\x2e\x66\x34\x5a\x03\x00\x72\x1c\xef\xf7\xc7\xbc\x2e\xa7\x8d\xb3\xfa\x7c\xfa\x70\x59\x39\x17\xd3\xe9\x62\x56\xde\xca\xc7\x2b\x0c\x9c\xdd\x81\x9c\x52\x08\x3a\x22\xc0\xed\x71\x23\x11\x0a\x78\x4c\x9e\xa0\xa7\xdd\x33\xd9\xc3\x69\x59\x87\xc7\xe1\x31\xc7\x7c\x1c\xaf\xd3\x59\x91\xf8\xf4\x66\x35\x78\x82\x21\x49\x83\x5b\x0c\x48\xf1\xa4\xa1\x48\x44\xf2\xce\x0b\x59\xb7\x94\x98\x25\x90\xff\x22\x71\xc1\xb2\x61\x23\x22\x83\x62\x52\x72\xb5\x21\xb1\x69\x46\xb1\x29\x8e\x47\x1d\x3c\x9a\xc0\x35\x87\x59\xae\xaa\xed\xef\x07\xd6\x3e\xd1\xff\x46\xee\xba\xfe\xbf\x5d\x9f\x13\xce\xba\xe3\x86\x5f\xbc\x35\x42\xf8\x17\xac\x7c\xf7\xa5\x3f\xc0\xce\x93\x17\xc2\x8f\x5b\x85\xfb\x4a\x61\xed\xbd\xcc\x53\x0f\xf7\x08\x77\x92\x09\xda\x25\xd2\xb5\xe7\xe1\x1e\x66\x4c\xff\x8b\x3d\x0f\x3f\xdc\x03\x1f\xc3\xbe\x0c\xcd\xd3\xb8\x06\x64\x3f\x1a\xc1\x4d\x99\x09\x2a\xfc\xdd\xc1\x7a\x8d\xc6\xe3\x2f\x0d\x73\x51\x57\xb4\xbe\xde\x9c\x70\x71\x4d\xcd\x2a\xaf\xcf\xdb\x9b\x65\x7d\x20\x18\x0a\xa2\xa9\x6b\x48\x63\xf7\x45\x43\xb5\xa6\x50\x30\x94\x0c\xb1\x5a\xd6\x17\xf2\x85\xec\x89\xda\x5a\x14\x33\xd5\x72\x26\xbb\x5d\xdf\x9b\xb5\xdb\x94\xa9\x26\xab\x94\x64\xa2\x0b\x40\x96\xc2\x54\x93\xd4\x05\x52\x3f\xa0\xd0\x92\x86\x39\x62\x46\xd2\x22\x9a\x78\x14\xdd\xa4\x9b\x70\x77\x8c\x84\x24\x21\x8d\x9d\x9f\xf8\x6c\x6f\xda\xc1\x5e\x36\x65\xcf\x5c\xa6\xbc\xbf\xad\xe7\xc1\x5b\xce\xf9\x45\x55\x64\xd4\xb4\x3f\x5e\xfc\xf9\x3f\xcc\xd9\x95\x6d\xf7\x09\x3b\x99\xba\x1f\x2f\xb8\xef\xc6\x7b\x17\x46\x46\xbd\xb4\xf5\xbd\x7f\x56\x5d\xc3\xfc\xb3\x6b\x58\xb8\x67\xec\xc5\xd7\xdc\xd6\x59\xff\xb4\xf0\x9b\x70\xec\x83\x57\xc6\x34\xf5\xcc\x1b\xdd\x53\x7d\xc9\xa4\xbe\x8b\xc7\x6f\x83\xae\xc4\x9e\x2d\x17\x8e\xef\xa1\x7a\xc3\x1d\x41\x7a\x13\x40\xde\x7e\x72\x26\x5e\x6a\xd5\xfa\xfd\x61\x55\x20\xc0\x1a\x5c\xac\xab\x3c\x66\x29\x53\x95\xf5\x66\x0d\x54\x55\xc2\x20\xdc\x9b\x0d\xf8\x5c\xc4\xb4\xa6\x0e\xca\x0a\xa3\x0c\xec\x4e\xa5\x25\x36\x49\x4b\x70\x48\x87\x7c\x98\x52\x45\x7e\x2b\xec\x84\x63\xe1\xc8\x9e\xdc\xd7\xaa\xd1\xa5\xa3\xb7\x9f\x7b\x7e\x0e\x67\x5c\xbb\x4f\x2c\x43\x2a\xf2\xe9\xbb\x5f\xbc\x65\x2b\x81\xf3\x61\x0a\x4e\x86\xf3\x0c\xab\x57\xb1\x75\xc2\x47\x3b\x2a\x92\x58\x45\xd2\x35\xaf\x0b\xfb\xdd\x51\x06\xab\xc7\xdf\x84\xb7\x4a\x88\x7a\x0c\x0c\x08\x0b\xd9\xff\x81\x5b\x54\x1b\xcc\x6a\x60\x14\x18\x72\x16\x3b\x07\x2e\x1e\xf8\x4a\x35\x82\xef\x41\x9a\xe3\x07\x15\xa0\x01\x5c\x89\x3c\xbe\xd9\x9f\x8c\x54\xb2\x11\x3f\xe4\x74\x01\x5d\xa0\xb1\x49\xed\xdd\x93\xe5\x80\xba\x4e\xdd\xa7\xbe\x5d\xcd\xe9\x58\xb5\x31\x63\xb4\xef\xc9\x9a\x8d\x46\x86\x8b\x55\xef\xc9\x9a\x62\xed\xb1\x4b\x63\x9b\x63\xe8\x56\x2c\x94\x09\xa5\xf6\x64\x43\x21\xd2\x17\x49\xb2\xb3\xc8\x01\xba\xb3\x08\x4e\x4e\xcb\xef\x53\x09\x39\x4f\x2d\x2f\x7e\xa0\x29\x16\xcc\x7b\x75\x3c\x2f\x96\xdd\x77\xb3\xf2\xe9\x51\xe5\xb2\x0d\x7c\xea\x12\x36\x77\x69\x7f\xba\xfc\xca\x11\x4f\x3c\x91\x7b\x60\xd6\x65\xf5\xa5\xad\x5d\xe7\xce\x5c\x7c\xd9\xa5\x63\xd8\x87\x1e\xdf\xfc\xc0\x23\x4f\x3c\xf0\xb3\x27\x36\x4e\x99\x75\xee\xf8\x89\xe7\xcc\x9a\x62\xe7\x17\xf6\xff\xc4\x5d\xfa\xec\xb6\x87\x77\x3b\x5e\xbd\x2c\x7c\xf3\xba\xdb\xaf\x74\x09\x93\x1f\xdb\xfd\x8b\xc7\x1f\xdb\xb9\xfb\x91\xbb\xaf\xbd\x72\xe3\xa6\xab\xd6\x50\xbb\x79\x25\x9a\x2b\xcc\xe6\xa7\xa2\x5e\x89\xa1\xf9\x56\x55\xd4\xeb\x35\x69\x03\x4e\x86\x65\x9d\x5a\x36\x5e\x61\x8a\x1a\x8d\x3a\x83\xc7\x13\x8d\xda\x0c\x06\x60\xb3\x85\xba\xb3\x36\x4e\x05\xa6\x64\x19\x15\x7e\x8c\x3e\xbf\x24\x6a\x25\x32\x8e\xd5\x5e\xe9\x5d\xe9\x3a\x54\xaa\x39\x4d\x9a\xdb\x06\xf1\x63\xf4\xcd\x16\xd9\xcf\xa2\xa6\x89\x7e\x15\xc9\x05\x73\xc9\xcd\xe1\xb1\xae\x1b\xae\xb8\xe6\xce\xc9\x4b\x2f\x9a\xbe\x76\xf5\xa2\x65\x3f\x7b\xb4\x6b\xe3\xc8\xe6\x96\xe6\xcb\x2f\x9d\xf4\xfe\x83\x1b\x36\x3f\xb0\x33\x10\x18\x17\x28\x65\xb4\x77\xfe\xec\xc1\xdb\x76\x0c\x80\x59\x27\x16\xae\x60\x7f\xb7\xf8\xaa\x0b\xaf\x10\xce\x3a\xeb\x3d\x3c\xc6\x28\x56\x53\x4f\x25\xcf\xa0\xd0\xe7\x4a\x6e\xcc\x74\x55\x81\x52\xbd\x96\x2b\xe5\xdc\x56\x27\x32\x8d\x30\xea\xb6\xba\xeb\xea\x0d\x0e\x2d\x67\x73\xa0\xf9\xb7\x53\xe5\x60\x8d\x56\xb3\xb5\x37\xeb\xd2\x9b\xad\x35\xbe\xb8\x29\x1c\x0c\x27\xc3\x58\xe5\x33\x68\x5a\x14\xf6\x85\x7d\xac\x83\x45\xcd\x65\x41\x32\x9f\x5b\xc1\x93\x1a\x3c\x33\x97\x53\x83\x05\xd1\xbb\x14\xd4\x4a\x09\x66\xd4\x01\x38\x72\xa7\xae\x21\xa2\xc8\xa1\xc0\xf2\x53\x8c\x35\x9f\x64\x3c\xfd\x7f\x11\xbe\xc7\xb9\xab\x79\xfd\x41\x9c\xb5\xda\x0e\xef\x65\x66\xb2\x55\x77\xaf\xbd\xf6\xae\x7b\x6e\xb8\xe1\xce\x75\x99\x9e\x71\x99\xcc\xb8\x9e\xcc\xc2\x85\xdc\xd7\x38\x7a\xff\xc1\xca\xed\xfd\xe1\x76\x29\x05\x72\xd2\xb1\xef\x8e\x0d\x0f\xdc\x7e\xfb\x3d\x1b\xd7\xae\x58\x71\xe1\xf5\xd7\x5f\x4c\x0e\xad\xe7\xc0\x4c\x72\xa6\x6d\x0f\xc0\xf3\xbc\x3a\xd0\x0a\x2e\xce\x8c\x30\xd7\xd7\x34\x85\xc3\xb1\x98\xbb\x06\x68\x80\x66\xd8\xf0\x70\x2c\x1a\x7b\x23\xdb\x14\x7a\x23\xdb\x18\xaf\x8c\xbf\x91\x05\x95\xe6\x4a\x14\x41\x44\x9b\x2a\x2b\x9b\xa2\xac\x81\x33\xd8\x5f\xcf\x1a\x6c\x9c\xff\xf5\x2c\xc7\xe5\xd7\xc4\xe5\xc0\x81\x44\xba\x8a\x15\xab\xd6\xb4\x28\x09\xf8\x69\x91\x06\x6b\x34\x9d\xe2\x48\xc4\x1a\x29\x8b\x32\xcd\x76\x2b\x97\x4e\x45\x71\x94\x1a\x8d\x94\x71\x0c\xaf\x4c\x2f\xe1\x00\xac\x59\x4a\x3e\xcd\x7c\x01\xb6\x3d\xff\x02\xcc\x3c\xf7\xb4\xf0\xf2\x4b\xcf\x0b\x7b\x9f\xed\xfc\x39\x0c\x3e\xfa\x73\x18\x7a\xec\x09\xe1\xd0\xcf\x7f\x2e\x7c\xf6\x08\xe3\x5f\x26\x3c\xda\x77\x01\x1c\xbf\x71\xf3\x43\x1b\x76\xcc\x58\xde\x3e\x66\xd1\x2c\x66\xd3\x8b\x70\xd4\x9e\x67\x85\x57\x5e\x7c\x4e\xf8\xd5\x2f\x9f\x85\x99\xe7\x7f\x2e\x7c\xfa\xc8\x23\xa8\xd4\x63\xb0\x6c\x1b\x7a\xfd\xae\xf0\xa9\x05\x55\x96\xd9\x65\xae\x5c\xbe\x68\xf9\x8f\xff\x96\x1d\x27\xe4\xf0\xd1\x76\xa0\x8f\xf1\xa8\xaf\x47\x72\x64\x03\xd5\x70\x46\xe6\xcb\x90\xcb\xe5\xf7\x33\xb1\xb2\x84\xc6\x62\xd1\x33\x4c\x6d\x8d\x39\x50\xce\x72\x5a\xee\x8d\x6c\xd8\xe1\x00\x16\x97\x3f\x96\xe0\xd1\x84\xe7\x8d\x6c\xa5\x37\x04\xba\xc1\x12\xb0\x05\xf5\xb5\xd6\x19\x2c\xab\xe6\xb4\xe4\x7b\xba\x6a\x60\x30\x1b\x98\x12\x83\x41\xad\x65\x7b\x6b\x61\xa8\x16\x9a\x6b\xe1\x5b\xb5\x70\x57\x2d\xbc\xbd\x16\xae\xae\x85\xdd\xb5\x30\x53\x0b\x93\xb5\xd0\x54\x0b\x17\xed\x25\x1f\x5d\x5a\x0b\x11\x74\x32\xf9\x34\x58\x0b\xd1\x87\x9b\x6b\xe1\x6d\x8a\xcf\xdb\xc9\x2d\x4a\x05\x7d\xbe\x84\xd0\x45\xe5\x87\x7d\x2a\xbd\x9f\x4c\x4a\x0e\x10\xd0\xcb\xb5\x70\x27\xf9\x7c\x15\x29\xdf\x4e\x3e\xdc\x49\x88\x2a\x99\x0f\xf5\x1d\x9a\xb9\x43\x7e\xaf\x66\x6e\xc1\xd7\xba\xd2\xe9\xe4\xdc\x39\xc9\x39\x28\x2c\x34\x1f\x98\x93\x4a\xd1\x4c\x2e\xf5\x80\xae\xb4\x62\x0f\x0e\xe2\x1e\xe8\xb7\x90\xc5\xe9\x9d\xbc\x60\x89\x06\x5f\xa9\x1d\x36\x98\x76\x48\x13\x5d\x61\x55\xf0\xce\x94\xa5\x92\xd9\x5f\x69\xae\x7e\x30\xb0\x8a\xf9\xd4\x2f\x7c\x71\xb1\xf0\xc5\x05\x17\xc0\x92\x13\x50\x23\x2c\x5c\x28\x6c\x5b\xcc\x78\x12\x66\x66\xbb\x61\xe5\x6b\xaf\xad\xd4\xf5\xcf\x30\x27\x98\x07\xfb\x37\x99\x13\xe8\x33\x34\xba\xfd\xcf\x31\x67\x55\x9a\xfb\xbb\xc9\xfb\x3e\x3a\xc7\xbd\x1e\xc5\x4f\x0f\xa1\xb8\xa0\x12\x6c\xc8\x64\x55\x25\x26\x56\xed\xf3\x47\xd9\x88\x3a\xc2\xc6\x59\xad\x35\x1e\x46\x86\xa2\x2a\x01\xc2\x7d\xe1\x25\x61\x56\xc7\x86\xc3\x91\x88\x7f\x5e\x36\x62\xf5\xa1\x60\xd1\x67\x32\xa1\xd8\xf9\x36\x13\x64\x4d\x26\xa8\xe3\x4d\x26\x34\x2f\x05\xbd\x59\x07\xa7\x2e\x99\x97\x35\x6b\x97\x68\x57\xa3\x09\x8a\x56\x6d\xdd\x92\x80\xf9\xac\x48\x3e\x21\x82\xf3\xb0\x66\xf7\x3e\xfa\x21\x5e\xad\x23\x71\x83\xbc\x20\x45\x2c\x87\x14\x61\xd3\x6c\xa9\x2d\xcc\xa2\x99\xc8\x70\x18\xc7\xcb\x95\x20\x1c\x02\x16\x3b\x30\x41\x71\x65\xd7\x46\xa2\x05\xd6\x7a\xe8\xe3\x67\x1f\xf7\xf5\xff\xda\x36\xba\xb5\xfb\x40\x97\xee\xf7\x03\x70\x02\x1c\x83\x7e\x27\x0c\x80\x0f\x74\x5d\x07\xba\x5b\x47\xdb\xfa\x7f\xed\x7b\xe2\x99\x8f\xb9\x93\x5f\x7c\xf7\xeb\xaf\x1d\xc2\xe3\x70\xfc\xed\xe6\xf3\xc2\xb0\xf4\x5d\x68\x86\x3e\xe1\x88\x70\xec\x5d\xe1\x50\xf8\x3c\xf3\xed\xc2\x1e\x78\x8e\xe3\xeb\x5f\xff\xe7\x10\xf1\x0f\x33\x07\xfe\xc4\x5d\xcd\x75\x21\x8b\x1a\x04\xdd\x99\xea\xa0\xd9\xac\x76\x03\x93\xda\x14\x0a\x07\xcd\xdd\x59\x53\x30\x18\x64\xf4\x6c\x30\xc8\xea\xf5\xfe\xee\xac\x9e\xb5\x77\x67\xed\x2e\xc8\xbb\xa0\x0b\x3f\xad\x97\x9e\x33\x87\x7c\x07\x45\xf9\xd8\x8c\xf2\xa1\x88\x72\xe2\x17\xd0\xcc\xcb\x8a\x6d\xa0\xd5\x11\xb6\x90\x89\x6b\x33\x6b\xc1\xd9\x20\x14\x49\x8f\xec\xfb\xe8\xfe\x4d\xc7\x6e\xb8\xe5\xc4\x5d\xf7\x9d\xb8\xf1\xe4\xfe\xc6\x6d\x53\xd6\x3c\xdd\x33\x2f\xfd\xf0\x8c\xa7\x2e\x3f\xfe\xb3\xab\xef\x80\xea\x07\xff\x07\x82\x9f\xde\x2a\x08\x8f\x0a\x1b\x5b\x3a\x2e\xb8\x0e\x9e\x0d\x1d\x8d\xa3\x2e\x17\xfe\x8e\xed\x1d\x3e\xc1\x42\xf5\x1a\x7f\x01\xf2\x07\x36\xe0\x04\x13\xc0\x1d\x99\xf1\x0e\xab\xcd\xa6\xd1\x69\x21\xe3\xb4\xd8\xcd\x66\x7d\x5b\x35\x0b\x22\x9d\x76\x46\xa3\x4f\x03\x17\x5b\xdd\xd9\x59\xad\xd7\x70\x13\x27\xd9\xb5\x16\xab\xd5\xe9\x68\x49\xea\xcd\x66\x8d\xcd\x56\xd2\x96\x8c\xa8\xc6\x69\x1d\x49\x95\x2a\x89\x5c\x07\x5b\xea\x62\xc6\xa1\xd6\xed\x4b\x8b\x13\xfd\x24\xf6\x7a\xad\x38\x63\x93\x9f\xd0\x4b\x79\x0d\xb2\x3e\xd6\x9a\x7f\x7c\x9e\xbc\x26\x4b\x67\x38\xb1\xa3\x85\x11\x2d\xfe\xd2\x74\x33\x0a\x09\x88\xac\xc7\xc3\x6a\x1b\x1b\xc6\x4f\x58\xb1\xe9\xd4\x48\xd4\x33\xb5\x2a\x71\xee\x2f\xa6\xcf\xf1\xb7\xee\x4b\x55\xf4\xd1\xa2\xb8\x0a\x9e\x3c\xf7\x5c\xf6\xe7\x3f\xf4\x09\xff\x9e\x05\xad\xcb\x60\x60\xa1\xb0\x7d\x71\xb7\xb0\x6f\xca\x3f\x7e\x0a\xdd\xcc\x5d\x15\x4e\x43\x55\xba\xd5\x97\xec\xac\x71\x96\x8f\x9c\xd4\x33\x69\x64\xf9\x1d\x37\xb5\x5d\x92\xac\x74\xf8\xba\xeb\x6b\xc6\x24\x1c\xb1\xb6\xc9\x53\x26\xb7\xc5\xd6\xdf\x36\xe9\xa6\x2a\xfe\x82\xef\xe7\xf3\x9b\x4e\xfe\x3d\x14\x32\x33\x3f\xf4\xf3\x38\xa5\xf1\xd7\xbf\x32\x8f\x08\x57\xf6\x67\x97\x98\xbc\x76\x83\xa7\x66\x44\xb4\x7a\x78\x85\xdf\x1f\x69\x9c\x34\x6c\xde\x32\xb3\x6e\xfb\x79\x76\x8f\xbd\xac\xd6\x57\xd1\x58\xee\x0f\x94\xb7\x4c\x19\xbe\xfc\x66\x9f\x85\xea\xd6\x79\x68\x82\xd2\xc4\x6e\x47\x32\x33\x2e\x13\xb3\xa8\x39\x87\x11\x7f\x97\xcc\xa3\x71\xdb\x4d\x48\x3c\xec\x6a\xa0\x36\x76\x67\xd5\xdc\xe4\xac\xda\xe1\x64\x01\x3b\x39\x8b\x3c\x52\xc1\x12\x06\x5d\xc1\x96\x9f\xd1\x20\x8f\x54\x85\x45\x73\x40\x34\xc1\x82\x14\xd5\x92\x46\x5a\x12\x87\xb3\xe1\x1f\xaf\xb9\xa6\x3f\xa9\x78\x90\xe1\x19\x76\x7b\x8d\xe7\xe4\x67\xe4\xa9\x05\x38\xf5\x12\x98\x5c\x02\xcf\x0f\xe3\x1c\xff\xe8\x81\xef\xf8\x27\xf8\xd1\xe6\x18\xa0\x7b\x6a\xf6\x33\xd3\x48\xae\xff\x72\xf6\xa2\xfe\xaf\x81\x3b\x63\x64\xac\x0e\xc6\x67\x82\x26\xc8\x19\xa0\xc1\x32\xa7\x11\xfd\x23\x9b\x4b\xa0\xb2\x1d\xa4\x6c\x27\x2a\x7b\xd9\x29\xca\x86\x50\xd9\x10\x0c\x41\xce\x0b\xbd\x85\x65\x47\x0f\xfc\x9b\x7f\x6e\x30\x5f\x8d\x86\x94\x0d\x65\x6c\x1c\xcb\xb8\x1d\x70\x8b\x01\xae\x36\xc0\x25\x06\x58\x47\xb8\xa3\x1f\x72\x20\x38\xa5\x31\x9d\xd0\xe8\x94\x4a\x9b\xe3\xb4\xb4\x45\x05\x2e\xaf\x02\xa0\x3a\xe3\x83\x2c\x63\x74\x70\x47\x53\x30\x85\xfc\x0f\x5c\x0d\xe0\x12\x00\xeb\xd0\x54\x10\xef\xeb\x47\x0c\xb5\x58\x23\x91\xde\x39\x84\x5e\xdb\x60\x7a\x1a\xbc\x04\xda\x90\x09\x53\x7a\x6f\x8f\x87\xab\xc7\xc3\x25\xe3\xe1\xf8\x53\x53\x2d\xa8\xe7\x15\x88\xee\x23\x22\x5d\xb7\x48\xf7\x1c\x42\x57\x3d\x05\xd7\xd3\x43\xe9\xae\x4e\x23\xdb\xc5\xc0\xc9\x3a\xa8\x03\x93\x01\xb4\x53\x7a\xb8\x8a\x8d\x85\xf5\x6c\x47\xf1\x69\x3b\xfb\x9a\x55\xc5\xe2\xe4\x24\x84\x5b\xc1\x02\xd5\x5c\xa6\x03\x18\x41\x59\xa6\x44\x8f\x8c\xb8\x96\x61\x78\x03\x6f\x2a\x31\x1a\x40\xf2\xa0\xe2\x81\x3c\x92\x53\x73\xba\x22\xb1\x78\x23\xd9\xc9\x2f\xec\x60\xae\x6d\x1d\xd9\xb5\xea\xb6\xdb\x56\x75\x8d\x6c\x65\x3f\x81\x95\x63\xae\xbb\x67\x5c\x74\xdc\x3d\xd7\x8d\x99\x81\xe8\x9a\x07\x7e\xc5\x1c\xe3\x56\x21\xba\xc7\x32\x39\xad\x81\x31\x18\x8d\x25\xa6\x0e\xd3\x34\x13\x13\x33\x35\x99\x18\xce\x04\x2f\x3c\x64\xfa\xc6\xc4\xec\x33\xbd\x67\x62\x1e\x35\xed\x31\x31\x6b\x4c\x70\xa1\x69\x85\x89\x89\x9a\x20\x63\xb2\x9a\x98\xc3\xa6\x13\x26\xe6\x35\xd3\x07\x26\x66\x9b\x29\x67\x62\x6e\x34\xdd\x6b\x62\x46\x9b\x60\xd4\xd4\x60\x62\x54\x26\xa7\xb2\xe8\x7c\x13\x2c\x20\xdd\x7a\xaf\xe9\xcf\xa6\x6f\x4d\xec\x75\x26\x08\xfb\x4c\x4b\x4c\x0c\xb9\x1b\x42\x72\x68\xb2\x9b\x98\x2d\x26\xb8\xc6\x74\xb7\x89\xc9\x98\xba\x31\xb7\x06\xcc\x0a\xee\x45\x5c\x31\x74\x97\x89\xd5\x03\x2d\x63\xe4\x51\xeb\xf7\xa5\x5a\x5b\x21\x5e\xd9\x93\xfc\x74\x6f\xb1\xf7\x56\x38\x6f\x4b\x7e\x2f\x37\x12\x96\xa7\x91\x89\x89\xc5\x51\x84\xfa\x7e\xbe\x5f\xd8\x2d\xf9\x1e\x3b\x19\x19\xdc\xff\x40\xaf\x27\xfd\x6f\xe4\x4b\x4c\x06\xe3\x10\xfd\x1f\x8b\x63\xb2\x2a\x75\x04\xcf\x6b\xf9\x55\x4a\x6a\x70\xd5\x29\xfa\xff\x9b\xcc\x1e\xc6\xa8\x35\x1a\x0c\xff\x57\xf4\xff\x16\x34\x02\x1c\xd0\x33\x5a\x15\x92\xbf\x4f\xfe\xcb\x11\x28\xc7\xdf\x74\x57\x63\x51\x75\xba\x2c\x69\x26\x91\xef\x99\xad\x4a\x91\x55\xf6\xbf\x0b\x4c\xcc\x38\x90\xfc\xab\x18\x2d\x62\xed\x72\x59\x1c\x25\x25\x16\x95\xc5\xed\xf1\xe0\xc5\xca\xe9\xb3\xbb\xc8\x75\xf8\x68\x72\xcd\x85\xe3\x5d\x40\x8f\xc6\x07\x92\x6f\x83\xe6\x87\xe8\x14\xaa\xa2\x18\x36\xa5\xd2\x30\x42\xfe\xb5\x42\x7d\xe4\x17\x40\x31\x8e\x2e\xc8\x64\x5e\x2a\xd1\x3a\x18\xad\x9e\x41\xd5\x74\x7b\x3a\x3c\xd3\x3c\x4c\xcc\xd3\xe4\x61\x38\x0f\x1a\x4b\xcf\x37\x1e\x66\x9f\xe7\x3d\x0f\xf3\xa8\x67\x8f\x87\x59\xe3\x81\x0b\x3d\x2b\x3c\x4c\xd4\x03\x19\x8f\xd5\xc3\x1c\xf6\x9c\xf0\x30\xaf\x79\x3e\xf0\x30\xdb\x3c\x39\x0f\x73\xa3\xe7\x5e\x0f\x33\xda\x03\xa3\x9e\x06\x0f\xa3\xf2\x38\x95\x45\xe7\x7b\x60\x01\xe9\xd6\x7b\x3d\x7f\xf6\x7c\xeb\x61\xaf\xf3\xa0\xb1\xf4\x2c\xf1\x30\xe4\x6e\xc8\x03\x39\x8f\xdd\xc3\x6c\xf1\xc0\x35\x9e\xbb\x3d\x4c\xc6\xd3\x8d\xb9\x35\x60\x56\x70\x2f\xe2\x8a\xa1\x5b\x3c\xbb\x3c\x9c\xc1\x55\xe2\xb0\x62\x95\xe2\xf1\x26\x88\xad\xad\xff\xdd\x98\x5a\x06\x6b\x96\x62\x8c\x15\x3a\x26\xbf\x50\xea\x5a\x3f\x93\x7f\x0d\x18\xd4\xa7\x5d\xa4\x4f\x59\xe0\x83\x25\x99\xfd\xd0\x6a\x04\x1e\x95\xd1\xa4\x32\x71\x9c\x3f\xd0\x11\x98\x16\x60\x62\x81\xa6\x00\xc3\x05\x50\xbf\x06\xbe\x09\x30\xfb\x02\xef\x05\x98\x47\x03\x7b\x02\xcc\x9a\x00\x5c\x18\x58\x11\x60\xa2\x01\xc8\x04\xac\x01\xe6\x70\xe0\x44\x80\x79\x2d\xf0\x41\x80\xd9\x16\xc8\x05\x98\x1b\x03\xf7\x06\x98\xd1\x01\x18\x0d\x34\x04\x18\x55\xc0\xa9\x2c\x3a\x3f\x00\x0b\x48\xb7\xde\x1b\xf8\x73\xe0\xdb\x00\x7b\x5d\x00\xf5\x6b\x60\x49\x80\x21\x77\x43\x01\xc8\x05\xec\x01\x66\x4b\x00\xae\x09\xdc\x1d\x60\x32\x81\x6e\xcc\xad\x41\x64\xb5\x17\xf1\xc5\xe0\x2d\x81\x5d\x01\xce\xec\xb3\x7a\x90\xbf\x77\x9a\x38\xa3\x4a\x0b\x92\x07\x70\xe7\xfe\xe9\xa0\xf9\xc0\x7f\xd7\xbf\x74\x6e\xcd\xa3\xb9\xb5\xed\x54\xbd\x6c\x86\x9f\x09\xa1\xfd\x83\xbb\xfa\x82\x6e\x6e\xe6\x29\x3a\x9b\xc4\xbc\x1d\x03\x47\xd8\x2d\xfc\x7e\xe0\x07\x55\x60\x42\xa6\x22\xea\xd2\x98\x02\x01\x34\x3f\x4e\x54\x3b\xed\x75\xae\x40\x97\x3d\x63\xf2\x42\x2d\xeb\x0d\x84\x0c\x21\x14\x03\x1b\x4c\x7c\xbc\x3b\xcb\x3b\xe9\x7c\x38\x2d\x07\xf5\xde\x83\x89\x94\xc2\x20\xe2\x07\xf0\xec\x3a\xba\xaa\x4c\x03\x5e\x57\xba\x99\x3c\x02\x14\x6f\x46\xef\xac\x2c\x59\x01\x65\x68\x0e\xc0\xca\x6e\xe9\xba\xed\x8d\xab\xef\x7f\xec\x96\x8f\x6f\x9e\x73\x5b\x19\xc7\xdd\xb3\xfe\xff\xe1\xed\x3d\x00\xa3\xaa\xb2\xc7\xe1\x7b\xee\x2b\x33\x6f\xfa\x4c\x66\xd2\x26\x7d\x52\x80\x10\x52\x26\x85\xd0\xf2\x68\x21\xd2\x42\x8d\x0c\x2d\x21\x84\x10\x40\xa4\x48\xef\xa8\xe8\xb0\xa0\x90\xc5\x02\xa2\xc2\xaa\xbb\x12\xc4\x2e\xc5\xb6\x36\xd4\x75\x15\x61\x75\x11\xb1\x2c\xee\xa2\xbb\xeb\x4f\xd7\xb2\xba\xba\x26\x99\x97\xef\xde\xfb\xde\xcc\xbc\x14\xac\xfb\xff\x20\x73\xe7\xdd\xfb\xee\x9c\x7b\xef\xb9\xe7\x9e\x73\x6e\x3b\x67\xd1\xda\xcc\x05\xd5\xe3\x8f\x9f\xbc\xca\xb5\x76\xfc\x8c\x5b\xe6\x34\x05\x26\xee\x59\xca\x1d\x3e\xac\x5c\xa7\xfc\xeb\xc6\x27\x8f\xec\x87\x7e\xb7\xce\x9d\xbc\xe2\xe2\xbf\xa7\xa4\xdf\xe2\x53\x3e\x09\xbd\x39\x73\xed\xaf\x94\xcf\x76\x6c\xf8\xd5\x0d\xd4\xcc\x23\x46\x79\x44\x21\x3e\x2e\x54\x21\x81\xb4\xe3\x2e\xf9\x0a\x11\x1b\x05\x03\x46\x60\x92\x78\x11\x24\x91\xe3\x05\x8c\x0d\xe0\xda\x6c\x82\x7c\x13\xd8\x4d\xd0\x61\x82\x0b\x26\x78\xc6\x04\x0f\x9a\x60\xa9\x09\xd2\x4c\xb0\xcb\x04\x15\xec\xd5\x00\xf5\xdd\x69\xf6\xae\xce\x04\xb2\x09\x6a\xd9\x0b\xf5\x07\x07\x58\x56\xf2\x9b\x09\xec\x67\xc8\x04\xd1\x99\x62\xb4\x1f\x23\x1d\x8b\x2a\x4e\x15\xd1\xc5\x94\xc8\x1c\x88\xa2\xaa\xb0\xa0\x37\xe4\x80\x5f\xc2\xe9\xfc\xf1\xb6\xd5\x00\xef\xff\x1e\x3e\x0f\x5d\xa7\x2c\xe5\xb2\x27\xf0\xff\x6d\x33\xf2\x33\xdb\x9e\xa3\x7a\xe6\x72\x65\xac\x98\xcd\xe6\xe9\x0b\xe5\xa1\x4e\x6c\x93\xb0\xe4\xf6\x18\x39\x81\xab\x0d\x08\x8e\xba\x80\xc0\x39\x49\x12\xdd\x89\xb4\x20\xef\x41\x0f\xa4\x79\xc0\x41\xb4\x2c\x0f\xec\x66\x0f\x24\x44\x1e\x18\x72\xc6\x03\x13\x3c\x20\x7b\x40\x35\x84\x13\xae\x55\x91\x7a\xbc\x22\xbe\x22\x57\xbf\x6b\xad\xcd\x5c\xd5\xc5\x1c\x75\x72\x4a\x4f\x21\x2d\x3f\x72\x44\x78\xec\xc8\x91\xd0\x3f\x8f\x84\xb2\x8e\x28\x63\x4b\xbc\xe2\x24\xba\x2a\xf3\xdd\x03\x74\x45\x46\x1c\xf5\xdd\xe3\xde\x12\x5a\xdf\x99\xca\x58\x21\x8b\xd4\x37\x91\x50\x55\x76\xa2\xd3\x89\x91\xc3\x61\x73\x5b\x6c\x16\x6f\x92\xd3\x99\xe8\x4a\xac\x0b\x38\x00\x71\x36\xb7\x8b\xb3\x63\x1b\x9e\x13\xb0\xd8\xbc\xd1\x03\x9e\x74\x33\x91\x51\x96\x6e\xa1\x55\xbd\x45\x03\x1e\x48\x2f\x1a\xc2\xb3\xd9\x60\x89\x04\xea\xd9\xc5\x0c\x5f\x16\x57\x11\x7a\x13\x9e\xee\x3d\x67\x6e\xed\xb8\xfe\x26\x32\xff\x6b\x1b\x8d\x87\x85\x3e\xe1\x27\x0e\xeb\x53\xf7\x71\x9c\x72\x05\x1e\x93\xd3\xfe\x06\x60\x9e\xe3\xf1\x87\x4a\xfd\x68\x6e\x0c\x67\xad\x56\x7e\xf3\xad\x05\x33\x1d\xbe\x11\xaf\xe4\x53\xf1\xbb\xaa\xad\x27\x0c\xbc\xc0\xe1\xfb\x03\xdc\xa3\xda\xfd\xca\x72\xcd\x96\x54\x6a\xfb\x28\xfc\x2e\xb5\xf5\x14\xbe\xff\xe5\x10\x0d\x21\xf6\xfb\xeb\x71\x1e\xac\xe5\x52\x89\xd4\x79\x41\xfe\x15\xbb\xff\x2f\x71\xfb\x67\x48\xa9\x56\xb0\x5b\xa1\xc3\x0a\x9f\x5b\xe1\x82\x15\x0e\x58\x61\x97\x15\x36\x5b\xa1\xd6\x0a\xd5\x56\x50\xdf\x5e\x11\x79\xfd\x0c\x7b\xb7\x24\xfc\x5a\x4d\x57\x13\x2b\xd8\xf5\x7d\xf2\xfc\x20\xbb\xcd\x5f\x11\xbe\xcd\x3f\xe0\x34\x83\x71\x26\x0c\x58\xb5\x2b\xa0\xa6\xb0\x0b\xfe\xcb\xba\x1b\x3d\xea\xf1\x62\x3f\xbd\xd6\x9f\xdb\xd3\xa5\x7e\x58\x1b\xbe\x1f\x86\x7f\xa7\x5d\x9a\x27\xed\xf5\x77\xfc\x9b\xaf\x17\xa7\x90\xd1\xe5\x97\xbd\x02\x27\x62\x83\x11\x1b\x25\x13\xcf\xdd\x1f\xe0\x79\x30\xd8\xc5\x54\x31\x5f\xe4\x44\x7a\x17\x7e\x56\x3e\xdb\x59\x0a\x77\x63\x91\xba\x26\xec\x2b\x49\x97\xc0\x8f\x97\x2c\x52\xce\x1d\x22\x33\x10\x0c\x27\xa7\xdb\xb8\xc1\x13\x42\xa9\xc2\x31\xba\xdf\x33\x0e\xbd\x2a\x34\x72\xe7\x34\x9b\xd8\x63\xe4\xdc\xde\x66\xc1\x99\x86\x50\xa2\xd3\x67\x16\xf2\x0b\xe2\xb2\x6d\xd9\xf7\x07\x92\xfb\x1a\xfb\xde\x1f\x10\x12\x7d\x4e\x9e\x43\xc6\x09\xa4\x06\x6e\xbb\x0d\x6c\x28\x7f\x96\xff\xb5\x59\x45\x2a\x01\xe9\x37\x25\xa2\x1b\xcf\x9c\x7e\x9b\x99\x6d\x3e\x67\x65\x88\x86\xf0\x35\x1f\x08\x1f\xdc\xa2\xab\x93\x8d\x8f\x06\xdf\xb8\x41\xbe\x67\xd6\x8d\x0f\x3d\xb2\x73\xc1\x23\x43\xe5\x3b\x16\xdc\x78\x9f\xf2\xce\x84\x6d\xf2\xa0\x6d\x35\x75\x6b\xd7\x85\x3e\x2c\xdf\x36\x7d\xd6\xea\x95\x73\x27\x5e\x87\xc7\xff\xf6\x2f\x60\xdc\x7c\xcd\x9f\x1f\x6c\x79\x67\xcb\xd5\x1b\x37\x9f\xbb\x72\xe7\x8d\x37\xdc\x78\x70\xe3\x9a\x83\xca\xa7\x3b\x77\xfd\x66\xc3\xa6\xfd\x37\x30\x9d\x72\x2f\x51\x63\xea\xf8\x97\xd9\x3d\x33\x2c\x08\xbc\x68\xa0\xc2\x37\xac\x4c\xd2\xc3\x4c\xf4\x8e\x11\xec\x9d\xcd\x2f\x6c\xeb\xcf\xbf\xdc\x76\xeb\x6c\x36\xcf\x84\xc4\x0e\x85\x7f\x80\x37\x92\xf1\x9f\x21\xdb\x63\x90\xd9\x84\x4c\x6e\xcf\x52\x0f\xd8\x05\xa2\x71\xe4\x17\x11\x75\x47\x77\x71\x59\x70\xb2\xb3\x3d\x29\xe0\x71\xfa\x9c\xda\xaa\x33\x24\xae\xf8\xd3\xd5\xd7\xbc\xb9\x7a\xfe\xc9\x83\x77\x3d\x8b\x31\xba\xe5\xf3\x6d\xd7\xfe\xfb\x26\x05\x61\xfc\xfb\x0f\xff\xf6\xbc\x42\xef\x87\xdd\x1c\x7a\x17\xef\x23\x5d\x90\x83\xfa\xc8\xb1\xe9\x36\x5b\xaf\xde\xee\xe4\x89\x01\xbb\x7b\xb3\x1b\x4b\x9c\x1b\x99\x26\x06\x48\x51\x74\x91\x23\xbc\xba\xc1\x78\x04\x3d\x02\x37\x04\x88\x4c\xa2\xf8\xe3\x1c\x31\x43\x30\x9b\xc2\xdb\xc1\xc7\x0a\x8e\x71\x63\xce\x86\x1d\xc9\x93\x2c\xbc\x87\x77\x8f\x1c\x50\x52\x29\xda\x0c\x73\x0f\x56\x26\x04\xec\x2e\x87\xa7\xb2\xbc\xa4\x92\x37\x48\xe2\xbc\xfd\xa1\x77\xe3\x4c\x46\x6b\x6d\xdc\xc8\x3b\xd6\xe3\x83\x60\x01\xe7\xc2\xa7\xd7\xb8\x2d\xd2\xb0\xa1\x95\x77\x6c\x08\xfd\xfd\x32\xe5\xf7\xca\x47\x57\x3e\xb5\x9c\xc9\xac\x72\xc8\xe3\x13\xf8\x54\x94\x80\xfc\xa8\x41\x2e\xf3\x49\x05\xb1\x52\x6c\x71\x49\x22\xa1\x87\x44\x94\x51\x97\x81\x8d\x5c\x86\x9c\x9f\x9d\x9d\x7a\x7f\x20\xdb\x22\x23\xd7\xfd\xa4\xde\xc6\x3a\x42\x21\x9c\x51\xf6\x58\x2c\xc2\xfd\x81\x5a\x32\xeb\x44\xf9\xea\xe2\x54\x62\xd4\x5e\xfa\x6b\xfa\x04\xfd\x09\xb3\x0c\xed\xc8\x8e\x4f\x3d\xe9\xaa\xae\xdc\xf8\x6d\x98\xbb\xe4\x0b\xcb\xc2\x1d\xa3\xe7\x64\x8f\x1b\x6f\x9d\xe7\xda\xb6\xaa\xff\xea\x31\x35\x93\x7d\x23\xc7\xc7\xcc\x77\xca\x0b\x27\x5d\xf2\x0d\x7e\x79\x6d\x45\xf9\xe2\x6b\x9f\xbc\x63\x40\x45\x55\xe1\x82\xed\x57\xff\x6a\xac\xd2\xd8\x35\x85\xf2\x9b\xa9\x68\x27\x6f\xe3\x4f\xa2\x18\x28\x95\xcf\xc5\xb8\x10\xe1\xfd\xbc\xc1\x6a\x22\x82\xc9\x2c\x02\x98\x3d\x6e\xce\xee\xb0\xdf\x1f\x90\x24\x83\xd9\x62\x26\x63\xf2\x3a\xd2\x5a\x87\xcb\x85\x12\x1c\x20\xd1\x3f\xd9\xe2\xa8\x72\x5c\xeb\x81\x15\x1e\xa8\xf7\xc0\x14\x0f\x8c\xf0\x40\xa9\x07\x32\x3c\xe0\xf6\x00\xef\x81\xaf\x3d\xf0\x77\x0f\xbc\xe5\x81\x97\x3c\xf0\x98\x07\x7e\xe7\x81\x5b\x3c\x70\x1d\xcb\xdf\xe8\x81\x4a\x0f\x64\x86\x73\x7e\xe3\x81\x0f\x59\xce\x93\x1e\x38\x16\xce\xa9\x66\xab\x61\x30\x45\x0f\x0c\x22\x99\x86\x79\xa0\x98\x15\x40\x85\x11\x91\x44\x5f\x78\xe0\x03\x0f\x9c\x61\xbf\x7b\xc8\x03\xf7\x30\x09\x45\x6a\x44\x08\xba\x81\x09\x28\x5c\xbb\x6c\x99\xce\xf6\x51\x6d\x4f\xc6\x8d\x3a\xe5\x58\x1e\x36\x94\x93\x4b\x0f\x1b\xf9\xf3\x1d\xaf\xcf\x2a\xd2\xec\x6f\x75\x12\x6a\xea\xb6\xa4\xdf\x93\xce\xb1\x13\x83\xf4\x62\x5d\x0c\xdb\x95\xe5\x32\x3e\x55\x4e\x9d\xc3\xa6\xd0\x03\x2f\xad\x7f\xe9\x53\xf0\x9f\x0b\x7d\x83\x27\xbe\xb4\x91\x3b\xd4\xa8\xbc\xd6\xa8\x7c\x08\x49\x8d\x50\xdc\x48\x9d\x59\x71\xa8\x11\xc6\xf3\xa9\x3c\x66\xb6\x04\xcc\x68\x80\x9c\x6a\x22\x33\x13\x81\xb0\x31\x8b\xd5\x64\x36\x73\xa2\xdd\x90\x6a\xc8\xa7\xa6\x43\x11\x27\x73\x84\xea\x98\xcd\x94\xfc\x59\x74\x93\xfd\x94\x6e\xf5\x53\x95\x2b\xe1\x0f\x95\x2f\xdc\xe3\xea\x07\x1e\x6b\x6c\xc4\xe3\x1b\x1b\x95\xf3\x8d\x8d\x84\xde\xa7\x12\x7d\xc6\xc6\xdf\xc2\xee\x87\x4e\x96\x8b\x79\x64\xc2\xa2\xc1\x60\xb2\x98\x25\x03\xe9\x65\x5e\xb4\xcd\xc0\xbc\x6d\x02\xae\xc3\xbb\xf1\x41\xcc\x63\x40\x76\xbe\x82\xc7\x76\x52\xc7\x6a\x7e\x33\x7f\x81\x17\x8c\x3c\x4a\xc8\x67\x78\x39\x35\x2b\x57\x5b\xa5\xd4\x55\x23\x86\x54\x40\x82\x64\x9c\x5e\x32\x95\x94\x7e\x8e\xeb\x4d\x24\xdd\xae\x22\x38\x3b\x5f\x59\xab\xac\x9d\x3f\x85\xd5\x61\x0a\xa9\x83\x5d\xab\xc3\x54\xb9\xa4\x4b\x1d\x44\xa2\x52\xf1\xb6\x19\x08\xdb\x6a\xd1\x12\x74\x00\x3d\x88\x78\x64\xc7\x15\x18\xdb\x71\x2a\xae\xc6\x9b\xf1\x05\x2c\x18\xb1\x5a\x09\x5a\x85\x70\xc7\xe8\x6b\x51\x46\xe5\x39\x78\x38\x82\x8b\x1a\x52\x85\x73\xdc\xe3\xb8\x7d\xd4\x13\xf3\xe1\x7a\xb8\x7e\xbe\x92\x5b\x14\x3a\xc7\xea\x71\x1b\xa9\x47\x31\xbf\x95\xee\x3a\xa0\x26\x79\xbc\x80\x44\x1e\xf1\x26\x33\x32\x3b\xcc\xf8\x0a\x87\x79\x82\xb9\xce\xbc\xc5\xbc\xdb\x7c\xd0\xfc\x85\xd9\x20\x9b\x97\x92\xc8\x43\xe6\x67\xcd\x02\x7d\x9f\x46\x52\x1f\x32\x9f\x31\x7f\x40\xde\x19\x07\xd0\x14\x99\xe4\x3f\x48\xe2\xe2\x19\x33\x10\x25\x91\x70\xb7\x53\x84\x91\xaa\xc7\xff\x67\xeb\xf8\xa9\xdf\x29\x81\x33\x2b\x9d\x84\xb7\xc1\x29\x38\xd5\x7e\x0c\xb7\x2a\xd7\x28\xd7\xe0\xf5\x58\x0c\xb5\x86\xb6\x4d\xc2\x22\x1c\x56\x6a\x54\x5d\x02\xbd\xca\x74\x09\xca\xdf\x11\xc7\x11\xfe\x4e\xc8\x44\xc7\xdf\x55\x43\x32\xa7\xe6\x93\xd6\xad\x54\x6a\xb0\xa3\x11\x01\xce\x08\xdd\xc6\xbd\x21\x1e\x46\x1e\xe4\x95\xcd\x46\xc2\xec\xc9\xcc\xd8\x2c\x80\x82\x2a\xf2\x4f\x9d\x8a\xba\xcd\xf0\x85\x77\x13\xe9\x79\x9d\x6c\xba\x91\x6a\x10\x3d\xf8\xe8\x9e\x43\x9b\x2a\xc6\xf8\xb3\x52\xac\x8e\xec\x74\x47\xa6\x24\x86\x6e\x33\xd4\x9c\xfc\xa6\xa2\xa0\x57\xb1\xc9\xd8\x27\x27\xc7\xb7\x80\xc9\x0f\x21\x74\x1b\x3e\x4a\xca\x70\xa3\x24\x52\x06\xc6\x6e\xb7\x27\x96\x14\x42\x2d\x94\x86\xcb\xd0\xc4\x4f\x54\xfc\xc7\xc5\xaa\x67\x82\x70\xc6\x9e\xbb\xaf\x1d\x38\xbe\x28\x33\x3d\xd1\x94\x9a\xea\x48\x8e\x13\x0f\xff\xf7\xd0\x0b\xff\x19\x9c\x9f\x53\xe2\xe0\x7b\x67\xf9\x37\x13\xd9\xf1\x0d\xce\x12\x8e\xe2\x63\xa4\xb1\xf1\x47\x39\x01\xf1\x80\x4e\x00\x7e\x24\x00\xed\x51\x8b\x99\x1c\xd1\x24\x4d\xc2\x33\x38\xab\xb9\x99\xc9\x34\x7c\x43\x68\x0f\x97\x62\xa8\x62\x7a\x97\x84\xa9\x6d\x12\x4e\x41\xad\xa8\xa2\x22\xa2\x8a\xf8\x9d\x3e\x7c\x43\x73\xb3\xa1\xea\x9b\x31\x6a\x7e\x56\x86\x40\x64\xa0\x89\xda\xb6\x05\x83\xa0\x20\x8e\x15\x84\xda\xd5\x29\x09\x29\x4b\x9b\xe4\x53\x1b\x37\xe4\xd7\x5c\xaf\xd0\x82\x66\x7c\xac\xb9\xed\x4a\x76\x07\xfa\x1b\x5a\x66\x18\x06\x9b\x08\x88\xbc\x82\x05\x06\x03\x77\x85\xc1\x31\x63\x36\x26\xae\x57\x33\xa9\x74\xeb\xfb\xfc\xaf\xb5\x7a\xd3\xb6\x1a\xe8\xfc\x22\x95\xca\x70\x91\x37\x30\x00\x8f\x51\x00\xad\xec\xf0\x63\xa4\x12\x4c\x9a\x93\x26\xe0\x5b\xdb\xdf\x36\x54\xb5\x5d\xd9\x8c\x54\x5c\xb1\x76\xb3\x3a\x60\x6a\xbb\x47\xe4\x5a\xbf\xaf\x0e\x7e\xa7\x09\xdf\x4a\xeb\xc0\xff\xba\xf5\xfd\x08\xee\x58\x1d\x0c\xa8\xb7\x6c\x11\xa8\xf1\x64\x23\x2f\x19\x94\x2e\x15\x89\x02\x8a\xd6\x86\xa1\x14\xdf\x4a\xb0\xc2\x2a\xa4\xc7\x8b\x06\xcf\x46\x6f\xef\xf3\x12\x32\x8a\x0a\xa9\x97\xa1\x53\xbd\xf4\xf0\xd4\xaa\xf9\x58\xe5\xd4\xda\x7d\x33\x46\xc3\x11\x85\xc7\xfa\xca\x80\xfa\xca\x76\xde\x40\x46\x01\xc7\x00\xd2\xd5\x54\x1d\x65\x50\x75\x5f\xbd\x6a\x1e\x69\xad\x87\xe1\x5c\x78\x86\x76\x1b\x21\x95\xb6\x2b\x09\x48\x8d\xbe\x58\xfd\x08\x3c\x6a\x34\xc6\x60\x20\xf0\xb8\x56\xda\xf4\xef\x87\xe7\xa4\xad\x66\xf8\xbb\x95\xd5\x91\x76\x82\x56\x3f\x03\x5d\x29\x2a\x93\xdd\x82\xd1\x88\xcd\x66\x02\xd2\x8a\x2c\x26\xd2\x66\xa3\x19\x9b\x09\xd0\x47\x03\x02\x6d\xb6\x36\x2b\xd1\xc1\xf5\xeb\x41\xa7\x6b\x18\x60\x28\x0d\x97\xc0\x6a\x4d\xef\xf6\x7f\x03\xcb\x84\xa3\xdc\x42\x26\x2b\xfa\x11\xaa\xa5\xd5\xe6\x79\xa3\xc0\xb3\x7e\x12\x42\xe1\xda\xb7\x85\x77\x98\x21\xb2\xa2\x42\x71\x01\xea\x98\x69\x1d\x4a\xc6\xcd\xf9\xe6\x66\x65\xaf\x3a\x76\x30\x9c\x27\xfd\xf5\x06\x1b\x3b\x06\x94\x26\xdb\x00\x09\x84\x0f\x1a\x25\x03\x47\x30\xdc\x4a\x4f\x03\x76\x3e\x21\xef\xf4\xb1\x0f\x01\x01\x4d\xea\x78\x92\x8e\x46\xc7\x14\xa9\x9f\x84\xca\x65\x3b\x16\x45\x33\xe9\x7b\x84\x4c\x66\x49\xa1\xd7\x91\x49\x15\xf9\x50\x78\x84\xb5\xe9\x4f\x9b\x83\xfe\x94\x79\x3a\xbb\x53\x16\x19\x6e\x0c\x13\xdc\xc2\xe6\x73\xcd\xed\x19\x94\xf7\x9c\xd7\x68\x41\x42\x79\xb2\x55\x94\xb0\x20\x09\x26\x30\x63\x51\x12\x09\xe0\xa3\x01\xa9\x9d\x37\x2a\xf4\xba\x2a\x13\xd4\xe0\x8f\xda\xdf\xf1\x68\xb6\xa4\x9c\xc2\x51\x25\x99\x80\x63\xc3\x98\xe2\x57\xf0\x69\x38\x60\x75\x27\xdc\x1d\x0d\x94\x6d\xd8\x68\xb4\x72\x48\x12\x91\x68\x21\xa5\x10\xd0\xc7\x03\x62\xc8\x1c\xe5\x10\x5a\xfd\xfd\x15\xb9\xba\x2b\xb1\x51\x56\xa1\x85\xe7\xb9\xf7\xda\x8f\x12\x2c\xe1\x15\xa4\x48\xd2\x88\xd6\x27\xf8\x25\x6a\x3b\xd4\x31\x12\xc6\x15\xb3\x6f\x6c\x32\xf3\x04\x59\x46\x45\xe4\x18\xae\xc4\x36\x7a\x2f\x98\x8e\x96\x90\x0e\x57\x11\xb2\xd1\x3a\xb5\x44\xb5\x91\x65\xa2\x68\x22\xac\x05\x96\x91\x96\xb5\xf6\xe6\xfe\x12\x19\x87\x6f\x30\x5c\xf5\x93\x1d\x54\xae\x8a\xd8\x8c\x4c\x04\x41\x62\xf7\x81\xd3\x09\x59\x5c\xd8\xf0\x16\xe1\x57\xef\x51\x5c\xa9\x1c\x4b\x25\x44\xac\xc2\x8d\xe2\xca\x68\xa6\xc6\x34\x2c\x56\x5e\x92\x2c\x26\x15\x57\xa6\x10\x36\x28\x8c\x2e\x1f\x09\x08\x3a\x5c\x41\x64\x2b\x8f\xe1\x8a\xca\xaf\x12\x7a\x54\xb9\x24\x9d\x7b\xa3\xb9\xfd\x28\x5e\xd1\xac\x24\xe3\x15\xdc\xc2\xd6\xde\x42\x25\x6b\x47\x33\xe3\x4f\x94\xee\x09\x7d\x4a\x64\x7c\x59\x09\x5d\x49\x12\xc1\x95\xd1\x68\x66\x1d\x43\x30\x15\x0a\x73\xaa\xb6\x08\xa7\xca\xed\x8c\x29\x95\x5b\x79\xc2\xfc\x93\x92\x15\xe5\xa1\xed\x19\xa4\x71\xea\x9c\xe8\xbc\xc6\x13\x24\x32\x5f\x31\x1b\x05\xa2\x83\x91\x49\x28\x79\x20\x80\x8f\x05\xb0\xb1\x1d\x89\xad\xec\x16\x74\x6e\x27\xa2\x52\xc7\x2c\x79\xe6\x86\x36\xc3\xc5\xf6\xcc\xe6\x73\x8c\x0f\x0a\x3e\xc2\x09\x09\x4d\x69\xf5\x0e\xd3\x94\x60\x34\x0b\x66\xa2\xd7\xf1\xbc\xd5\x68\x66\x35\x36\xb6\xb1\xaa\x1f\x25\x9d\x2c\xaa\x43\xad\x53\xe5\x3b\x15\xa3\x85\xe7\x9b\xb9\x31\xed\x99\x64\xe4\xc1\xc5\xd0\x4e\x43\x55\xeb\x13\xcd\xc2\x39\xd2\x0e\xd6\xdf\xb0\x8c\xf1\x5d\x46\x53\x22\xc6\x0c\x4f\x84\xa6\x0c\xad\x3f\x9d\xa6\xfc\x2a\x4d\x11\x5e\xc4\x68\x8a\xfb\x4b\x6b\x6f\x14\x96\x37\x6f\xb0\x32\x08\x4d\x71\x44\x23\x11\x91\x19\x4c\x46\xbe\x95\x94\x07\x51\xee\xde\x9d\xa6\x40\x85\x4a\x71\xf5\x06\xa9\xff\x45\x95\xac\x34\xa2\x62\xbc\x8d\xc1\xd5\x70\x65\x26\x9a\xae\x91\xd0\x94\x04\x10\xa1\xa9\x36\x5e\x6c\x0d\x97\x11\xba\x24\x4d\xb1\x62\xd2\xfd\x2a\x4d\xb5\x67\x72\x63\x9a\x15\x43\x73\x68\x27\x5c\x24\xed\x10\x2a\xdb\x74\xfa\x82\xc6\xb3\x87\xc8\x0e\x11\x53\xe3\x25\x84\x82\xc9\xa8\x37\x2b\xdf\x47\x56\x5d\xf0\xd5\x89\xb4\x22\xc2\x50\x13\x88\x8c\xba\xe8\x68\x8f\xf0\x17\x26\x73\xcc\xc8\x2f\xc7\x98\x08\xcb\x12\x0d\x66\x83\x85\xb7\x1a\xcc\x0a\x32\x76\x15\xd9\x7e\x3d\xf2\xf4\xf2\x96\xb2\x5e\x46\x6c\x84\xa3\x50\x0e\xae\xc9\x5d\xc6\x81\xa9\x11\xae\x70\x39\x84\x79\x21\x3b\x1a\x25\x53\x2b\xa9\x4e\x04\x16\xa3\xd1\x2e\x91\xe9\x9a\xd3\x62\x67\x6d\xb2\xb4\x31\x96\x2c\x4b\x84\x27\x9b\x70\xab\x04\x8c\x69\xfa\xc3\x27\x93\x74\x07\xb2\xd4\xd2\x7d\x4e\x7a\xd4\x94\x72\x05\x55\x0b\x59\xd8\xdc\x7c\x8e\x71\x35\x46\x86\xa1\x3d\xd2\x51\x42\x88\xed\x19\xd2\x51\x46\x8a\x3a\x1d\x80\xe2\xd7\x45\xf1\x4b\x98\x83\x95\x10\x23\x91\x89\x7a\x72\x34\x77\x23\xc7\xae\xf8\x8d\x12\xa4\x2f\x42\x92\x61\x9a\xfc\x66\x0c\xe1\x74\x1a\x3f\xd2\x70\x5b\x28\xbb\x08\x9f\x33\x99\x45\x33\x91\xbf\x66\x51\x31\x76\xd3\x3a\x3a\xa1\x56\xa7\x79\x50\xcc\x9a\x08\x5d\x32\xa9\x16\xd1\x40\x04\x1f\x45\x2c\x17\x29\x43\xc5\x6b\xa5\xec\x14\x49\x93\xcc\x98\x33\x73\x0e\xa7\xc1\x6a\x75\xd8\x2d\x8c\x48\xed\x21\xce\xac\x84\x65\x51\x1b\xe2\x19\xd3\xe8\x89\x52\xf5\xb2\x94\xce\x19\x55\x26\x38\x94\x89\x65\x4a\xad\xcd\x8c\x13\xaa\xc2\x95\x10\xad\xc6\x0b\xb1\xaa\x6b\x10\xde\x4b\xdb\x2a\x33\x6d\xc8\x62\x35\x73\x9c\xd5\x48\x50\x2b\x19\xd5\x2e\x95\xda\xf4\xba\x51\x28\x3c\x1c\x75\x0a\x41\x17\x0d\x49\xd3\x0c\x08\xd5\x86\x16\x08\xcf\x10\xe4\x92\xae\xe4\xfe\x42\xf1\xd0\x49\xff\x32\xa3\x62\x39\xc6\x68\xe6\x29\xdd\x72\x04\xbd\xa2\x49\x31\x76\xd3\xc1\xb4\x71\xef\xec\x24\x4d\x22\xc2\x97\x94\xa2\x4a\x5f\x4d\x1b\xd3\x74\x1b\x2e\xd2\x2e\x3a\xfe\xed\xe8\x32\xd9\x65\x35\x1a\x9d\x84\x0d\x8b\x58\x74\x38\x6d\x1c\xe7\xb0\xdb\x18\x2b\xb6\xb7\x49\x1c\xcf\xb1\x47\x91\x0f\x99\x35\xba\x0d\x1f\x29\xd6\x63\x38\x42\xb9\x04\xb1\x7e\x75\xec\x90\xe9\x20\xa1\x5c\x8a\x58\x95\x78\xf1\x8a\xd6\xa1\xa4\x5f\xff\x42\xdb\x2b\x9c\x23\xad\xd5\x74\x2c\x8d\x96\x08\x7e\x0d\x66\xb3\x95\x68\x88\x16\x2b\x32\x1a\xa3\xf8\x0d\xe9\x75\xc5\xb6\xae\xf8\x75\x95\xeb\xb4\x2e\x36\x5e\x18\x7e\x99\x5a\xa7\x29\x5f\xdc\x5f\xc8\x38\xd1\x14\xb0\xa8\x3e\xca\xf0\xab\xb6\xd9\x42\xc9\xd7\xc0\xb5\x4a\xdd\x74\xd2\x1e\xf1\xab\xb5\x97\x94\xc2\x18\x2b\x5c\x8c\xb0\x56\x36\x4d\xa0\xf8\xd5\xc9\x22\x86\x5f\xde\x6e\x77\x12\xdd\x54\x30\x0b\x0e\xa7\x64\xb1\x38\xac\x16\x86\x54\x6b\x88\x08\x3e\x49\x95\x7a\xa6\xb6\xa8\xd4\xbb\x24\x7e\x23\xb2\x89\x5e\xc4\x4e\xf7\x30\xde\x14\xda\xa9\x51\xb1\x92\x2c\x3c\xc3\x18\x21\xbf\x84\x10\x31\x61\xc4\xcd\x48\xa7\x2f\xc7\xa0\x1a\x39\xd1\x2a\x39\x08\xff\x8d\x89\x71\x7b\xcc\x76\xbb\x87\x70\x08\xb7\x8b\x70\x08\x0b\xcf\xb4\x87\xe3\x01\x49\x68\x73\xa8\x24\xf6\x68\xc0\x4a\x69\xd9\xaf\xb3\xf7\x11\xe1\x16\x11\x65\xba\x2b\xcf\x88\xb0\xe6\x08\xef\x88\x30\x68\x8d\x87\x68\x5c\x9a\xa9\x4c\x9d\xea\x76\x99\x9c\xe0\x92\x24\xbb\x85\x4c\xaa\x62\x8c\x16\xa3\x9b\xf7\x58\xdd\xc8\x41\x7a\xc4\x6a\xb3\xb2\xaa\xb9\xb0\xad\x9d\x32\xef\x0a\xbf\xee\x92\x76\xb4\x6b\xfc\xfa\x61\x1e\x1d\x01\x9a\x18\x0c\xf3\xf0\x73\x84\x1c\x69\x9f\x69\x7c\x5c\xed\x34\xd6\x77\xec\xec\x69\xa4\x3e\xb4\xdf\x9c\x28\x0e\xd5\xcb\x89\xbc\xcd\x96\xe0\x36\x9b\xe3\x8c\xd8\x6e\x17\x2c\x46\x4b\x7c\x82\x47\x92\xe2\x05\x4f\xac\x87\x92\xa7\x39\x80\x63\xdb\x90\xab\xd5\x1e\xee\x46\x8b\x29\xe4\x34\xe8\x87\x89\xf6\xa0\xeb\x4c\xdd\xe1\xab\x48\x75\x39\xfd\xc0\xf1\x6b\xdc\x89\x76\xed\x39\xdd\x00\xd2\xba\x99\x75\x71\xeb\x13\xea\x40\x62\xfc\x8a\xad\x5f\x20\xbc\x58\xb8\x8f\xf1\x4c\xd7\x31\x6a\x0a\x0f\xb7\x42\xd4\xb6\x1d\xa4\x3b\xd3\x85\xfb\x5a\xa7\x0a\xf7\xe1\xc5\xbc\x6a\xe3\x12\x91\xb6\x92\x58\x34\x3f\x5b\xb6\xe8\x96\x3f\xb4\x87\x7f\x27\x9a\x9f\xc1\x8f\x39\xae\xc1\x57\x50\x45\xf7\x02\xa8\x78\xd2\xf2\xe3\xb7\x7a\xcc\xaf\x9e\x94\x72\xa6\xe3\xb7\x42\x7d\xc8\x47\xcd\x8f\xcf\xea\xe0\x03\x8f\x84\xee\xf9\x09\xec\x48\xfe\x3e\x68\x7e\xe8\x3f\xc2\x7d\xe2\xdd\xda\x5a\x9e\x9d\xd0\x50\x1c\xf2\xb2\x9b\x26\xe1\xdb\xce\x65\x68\x20\xaa\x40\xc3\xd1\x28\x34\x06\x55\xa3\xc9\xe8\x72\x34\x03\xd5\xa2\xb9\x68\x3e\x5a\x84\x96\xa0\xab\xd0\x6a\xb4\x1e\x6d\x46\xd7\xa0\xeb\xd1\x0e\xb4\x0b\xed\x41\xb7\xa2\xfd\xe8\x00\xba\x1b\xdd\xcb\xbd\x24\x77\xfc\xe6\x8e\x7d\x37\x37\xff\xf6\xb7\xf7\x2c\x9e\x3a\x32\xcf\xba\x76\xed\x15\x53\x46\xf4\xb5\xac\x99\x37\xae\x24\x59\xd8\xbe\xbd\x61\x6c\x71\x12\x1f\x5c\x16\x18\xda\xdb\xb9\x71\xe3\xd2\x69\x72\x2f\xc7\x86\x39\x13\xcb\x13\xa4\x1b\x6e\xa8\x9b\xd0\x3f\xde\xb8\x73\xe5\xac\xc1\x59\x9e\xad\x5b\x57\xcc\x1c\x94\xe9\xde\xb2\x65\xe7\x86\xe0\x1a\xe1\xda\x83\xb7\xef\xbd\x69\xf7\x3d\xf7\x2c\xb8\xac\x30\x1d\xb6\x6d\x6b\xaa\x2a\x48\x43\xd7\x5e\xdb\x72\xa8\xb1\x05\x86\xb6\x4c\x6c\xc1\x45\x2d\xe0\x6b\x01\xbe\xc5\xdd\x82\xff\xd3\x02\x7f\x6f\x81\xb3\x2d\xf0\x52\x0b\x1c\x6f\x81\x60\x0b\xac\x6d\x81\x79\x2d\x50\xd3\x02\x85\x2d\x43\x5b\x70\x46\x0b\xc4\xd0\xac\xb0\xe0\xeb\x16\xf8\x88\x66\x7b\xab\x05\x93\x8c\x6b\x5a\x82\x2d\x7b\x5b\xb8\x05\x2d\x30\xb5\x05\x2a\x69\x66\x70\xb5\x64\xb4\x60\xae\x05\x3e\x6c\xf9\xba\x05\x13\x88\xc7\x5a\x5e\x6a\xc1\xf7\xaa\x59\x31\xc9\x38\x9d\x65\x4c\x6f\x29\x6c\xc1\xb8\xc5\xd5\x82\xbf\x6a\x81\x3f\xb7\x7c\xd8\x82\x5f\x6c\x91\xef\x22\x99\xe1\xd6\x96\x7b\x5b\x70\x53\xcb\x9a\x16\x1c\x68\x81\xd1\x2d\x50\x4a\x33\x13\xa8\x40\x60\x96\x7f\x45\xe1\xd2\x7a\x9e\x6c\x81\xa3\x2d\xf0\xbb\x16\xb8\xbe\xe5\xd6\x16\x3c\xad\xa5\xa9\x05\x5f\xd6\x02\x03\x5a\xa0\x6f\x38\x6f\xd7\xf2\x9b\x68\xf9\x97\xb5\x04\x5a\x30\xc9\x95\xdd\x02\x71\x2d\x80\x5b\x20\x5a\x7a\xb7\xb2\x07\xb4\x8c\x6e\xc1\xde\x96\xdc\x16\x6c\x69\x01\x09\xdd\xbb\x6b\xc7\xf5\xd7\x5e\x7f\x02\xb8\x63\x81\xbb\xe7\xcf\x5d\xd4\xb4\x88\x3c\xca\xa6\xc0\xc1\x86\xba\xa6\xda\x19\x97\x4f\xb9\x5c\x8d\xce\x9c\x36\xe5\xc0\xe4\xea\x31\x55\x63\xd4\xe8\xed\x13\xc6\x56\x0d\xaf\x18\x35\x62\x94\x1a\x95\x07\x8d\xd8\x3f\xb0\xcc\x5f\xe0\x57\xa3\x7b\xfb\x17\x17\xe4\xe6\xe4\xf7\xcd\x57\xa3\xbd\x32\xfb\xde\x9a\xea\xf5\xa5\xf9\xd4\xe8\x4d\x49\xf1\x69\x71\x31\x76\xaa\xcf\xd1\xa8\xdb\x61\xd9\x43\xe6\xdb\x74\x7e\x4a\xa3\xbb\x89\x60\xbe\x66\xf3\xfa\x35\xeb\x69\xb4\x22\xb0\x65\xc3\x9a\xd8\x29\xe0\xad\x82\x84\x11\xe0\x2d\x00\x6f\x5f\x70\xa7\x41\xd3\x94\xaa\x11\x05\x7d\xd3\x2c\x68\xcd\x1a\x64\x49\xeb\x5b\x30\xa2\x6a\x4a\x93\xe9\x8a\x7b\x76\x06\xbd\xd7\x0e\xbc\x16\xdb\xaf\x05\x09\x5f\xbb\xfa\xaa\x25\x57\x2c\x21\x30\x1e\x0d\xac\x58\x7a\x05\xca\x0f\xf3\x39\xd5\x30\x0c\xb3\x7c\x90\x1f\xf9\xa7\x2e\xa6\xeb\xae\x37\x69\x57\xed\xff\x57\x29\x6a\x08\xb5\xb3\x7b\x5a\xb9\x5f\xbe\xbc\x47\xaf\x06\x97\xca\xd3\x29\x87\x9a\x45\x13\x20\x61\x33\x01\xd4\x90\x83\xdf\x1f\x36\xee\x10\x4d\xfe\x79\x11\xf5\x9b\x1a\x13\xf6\xf8\xb2\xb4\x8f\xa0\x7b\x36\xfc\x88\xf4\xb8\x5f\x90\x1f\xbe\xe7\xd9\xd9\xc3\x67\x7e\x53\x13\xdc\x49\x3e\x07\xe7\xcf\x0f\x35\x93\xef\x03\xea\xe7\xf4\xfc\xf9\x4a\x5d\x53\x93\x52\xdf\xd4\xc4\x5b\xc9\xf7\x1c\xf5\x73\x3a\x9a\xfb\x74\x8f\xa9\x97\x80\x71\x3a\x9a\xda\xfe\x7c\xf4\xb9\xed\xab\xe8\x2f\xe9\x77\xf4\x9f\x90\x51\x4f\xff\xcd\xa9\x8b\xfe\x9b\xdb\xfd\x79\x0e\xfd\x57\x3f\x9b\xfe\xab\x67\xcf\x6a\xb2\xe1\x5f\xec\xc7\xe0\x63\x31\xe5\x42\xbd\x72\xa1\x4e\x79\x9f\xfc\xcd\x51\xfe\x32\xc7\xf0\x19\x3d\xe0\x3e\x85\xc8\x88\xff\x67\x3c\x1c\xdd\x87\x1e\x44\x8f\xa2\xe3\xe8\x49\xf4\x0c\x7a\x01\xbd\x8c\x5e\x45\xa7\xd1\x9b\xe8\x1c\x7a\x17\x5d\x40\x17\xd1\x3f\xd0\x27\xe8\x73\xf4\x15\xfa\x16\xb5\xa1\x0e\xe0\xc0\x00\x66\xb0\x43\x0c\xc4\x81\x17\x52\xe9\xa5\x50\xc8\x85\x7c\xf0\x43\x19\x0c\x84\x0a\x18\x0e\xa3\x60\x0c\x54\xe3\xb7\x64\x29\xbe\x6a\xcd\xa1\xb7\xbf\x14\xbf\xf8\x62\x68\x05\x4c\x80\x89\x68\x3d\xf9\x00\x9a\x48\xc2\x39\xe4\x83\xd1\x30\x16\xf7\xb3\xd0\x4d\xc2\x4c\x96\x2a\xb0\xf8\xdf\x49\xf8\x0d\x8b\x9f\x63\xf1\x43\x24\x3c\xc1\xe2\xfb\x58\x7c\x1d\x09\x7f\xc5\xe2\x8b\x58\x7c\x28\x09\x27\xb2\x78\x11\x8b\xfb\x58\xc8\x93\x90\x40\x7e\x04\x37\xfd\x67\xe8\x1a\x96\xf2\x16\x09\xff\xce\xf2\xbd\xcc\xe2\x7b\x49\x78\x88\xc5\xb7\xb3\xf8\x42\x12\xae\x63\xf1\x19\x11\xb8\x80\x32\x48\x58\xc4\x52\x63\x22\x70\x01\x7d\xcd\xc2\x8f\x58\xf8\x12\x09\xdf\x62\x39\x8e\xb3\x78\x90\x84\x7b\x59\x7c\x2d\x8b\x4f\x27\xe1\x42\x16\x97\x59\xbc\x90\x85\x2e\x12\x66\xb0\x54\x8e\xc5\x3f\x24\xe1\xd7\x2c\x7e\x36\x02\x15\xd0\xbd\x24\x3c\xce\x52\x69\x1b\x82\xec\x69\x01\x7b\x33\x9a\x84\xd3\x59\xbc\x30\x52\x4f\x60\xb0\x62\x68\xab\xfb\x7f\x3d\x74\x35\x4b\xa1\xd0\x3e\x62\xf9\x54\x88\xd1\x3a\x02\x83\xb4\x96\xbd\x9b\xce\xe2\x63\x58\x38\x58\x07\xef\x97\xb7\x79\xcc\xff\x93\x36\x0f\x64\xf1\xbe\x2c\xb4\x92\x30\x99\xb6\xd9\x88\x7a\xe6\xc3\xcb\x2e\xc1\x87\x7b\xce\xd1\x2d\x03\x65\xc2\x71\x1a\x9f\x2c\xeb\xe1\x23\xfc\xff\x90\x9e\xd5\x25\x2d\xcc\x63\x73\x7a\xf8\x18\x2e\x01\x27\xee\x27\xe6\x87\x9f\x98\x1e\xa3\xc1\x8a\xfb\x81\x6f\xa7\x96\x77\x3e\x63\xb6\xe4\xef\x0c\xfb\x23\x0f\x6d\x3b\x09\xb3\x56\xff\xd4\xd4\xf9\xf3\xdb\xa7\xff\x82\x5c\x70\xa7\x3e\xcf\xf3\xf3\xe7\x73\xbf\xed\x9c\x89\xfc\xcd\xef\x06\x6c\xfe\x8f\xc8\xd3\xf6\xd5\x8f\xa9\x83\xfa\xd3\xf9\x97\x0a\xe9\xb7\x26\x3d\xea\xbb\xc9\x90\xba\x4b\xc8\x93\x4b\xa6\xcf\x89\xfe\x53\xe5\xcc\x6c\x9d\xb4\x99\xa3\x93\x39\x9d\x24\x4f\xbd\x5e\xfe\xd4\x85\xa5\xd0\x1c\x0d\x38\xf9\x10\x60\x34\x4a\xb2\x93\x4c\x74\xfe\x37\x9c\xcd\x71\xce\x12\x79\x74\x19\x1a\x87\x26\xa2\xa9\x28\x80\x66\xa1\x39\x68\x1e\x5a\x80\x16\xa3\x65\x68\x25\x5a\x8b\x36\xa2\xad\x68\x1b\xda\x8e\x6e\x40\xcd\xe8\x66\xb4\x0f\xdd\x81\x7e\x83\x7e\x8b\x5a\xd0\xfd\xe8\x61\x74\x14\x3d\x8e\x9e\x46\xcf\xa1\x17\xd1\x2b\xe8\x14\xfa\x13\x3a\x8b\xce\xa3\xf7\xd1\x5f\xd1\x47\xe8\x63\xf4\x2f\xf4\x25\xfa\x0f\xfa\x0e\x85\x00\x40\x00\x09\xac\xe0\x04\x0f\x24\x40\x32\xa4\x43\x16\xf4\x86\x3c\x28\x84\x12\x28\x87\xc1\x30\x14\x46\xc2\x65\x30\x0e\x26\xe2\x7f\xcb\xce\x6f\x47\x2f\xfc\xd5\xe1\x3f\x8a\x71\x71\x1e\xa7\x55\x12\xc4\xd8\xd8\xa1\xc3\x60\x12\x4c\x46\xcb\xc9\x07\xd0\x5c\x16\x4e\x64\x61\x11\x09\x87\x91\x0f\x26\x52\x62\x32\x93\x3d\x34\x14\x58\xf8\x1f\x16\xfe\x9d\x85\x2f\x93\xf0\x1c\xcb\x77\x88\xc5\xb7\x93\x70\x1f\x8b\xeb\x61\x4e\x61\xe1\xd0\x08\x64\xca\x2f\x27\x33\xc8\x98\xf0\xcc\xc9\x8f\x00\x91\x3d\x1b\x58\xfa\x5b\x24\xfc\x3b\x4b\x7f\x99\xc5\xf7\x92\xf0\x10\x8b\x6f\x67\xf1\x75\x2c\xac\x67\xe1\x64\x1d\xd4\x0c\x12\x16\xb1\x7c\x31\x2c\xce\xb3\xf0\x23\x12\xfe\x87\xa5\xbe\xc5\xe2\xc7\x49\xf8\x32\x8b\xef\x65\xf1\xb5\x24\xdc\xce\xe2\x0b\x75\x10\x47\xb0\xb0\x30\x02\x17\x3a\xc1\xfc\x3a\x02\x99\xf2\xe1\xc9\x0c\x32\x66\x90\x29\x77\x9f\xcc\x20\x63\x06\x19\x34\xa8\x33\x58\x38\x9c\x85\xc5\x2c\x74\x91\x30\x83\xe5\xe3\x68\xeb\x89\x0c\x52\xb1\x75\x96\x84\x1f\xb1\xf4\x97\x22\xf5\x55\xa1\x52\x19\x34\x99\x41\xa5\x32\x68\x32\x93\x41\x34\x1c\xc4\xc2\xcc\x08\x54\x2a\xd9\x26\x33\x89\x31\x99\xd5\x14\x33\x98\x80\x8e\x91\xf0\x25\x16\xbf\x97\xc5\xd7\x90\x30\xc8\xe2\x0b\x58\x5c\x85\x39\x90\x84\x63\x58\x6a\x5f\x16\xc7\x24\x74\xb1\xf8\x57\x11\xa8\x80\x5e\x24\xe1\x59\x96\x7a\x8c\xc5\xa3\x10\x41\x83\x36\x9a\x84\xd3\x59\x8e\x81\x2c\x9e\x44\x42\x02\xf1\x11\x8c\x88\x82\x32\xf9\x61\xea\xd9\xac\xf6\x87\x26\x02\x97\x3c\xe5\xf3\x43\x99\x54\x31\xa4\xde\x25\x4c\x77\xfa\x4b\x7c\x3d\x7c\xfc\x9e\x4b\x7d\x7c\x1e\xbf\xb3\x87\x0f\x74\xc9\x18\x47\xd2\x72\x74\x1f\x43\x97\xf7\x02\x49\x2b\xd3\xc7\xc9\x27\x9d\x7c\x0c\x25\x3e\x4f\x16\xf9\x8e\x21\xdf\x3e\xdd\xa7\xeb\xef\x7f\xf0\x7d\x97\xf2\xa1\x6b\xbc\x4b\x3d\xc3\xbf\x37\x68\xf5\xa2\xf5\x89\x23\x70\xe3\xba\xc0\x8f\xe9\x1a\xd7\x7e\x1f\xfe\x16\xce\xb6\xe6\x2e\x8c\xfe\x5b\x44\xff\xd3\x7f\xe1\xef\xf0\xbf\xd6\x9b\xa3\x49\x6f\x91\xbf\x85\x0b\xcf\x92\x3f\x2d\x2d\xf4\x7f\x0b\xb5\x97\xed\x87\x17\x41\xc5\xa2\xb3\x8b\xe0\xbe\x45\x51\x30\x3a\x58\x9d\xe3\x11\x40\x38\x96\x45\xce\xb2\x3f\xfc\x09\xcd\x11\x29\x60\x11\x85\xad\xd4\x90\x37\x67\xc3\xbf\x8e\x7c\xd3\x3c\x8b\xd8\x8f\x42\x7b\x20\x63\x0e\xfd\xf3\xd5\x41\x7a\x3d\xfb\xeb\x24\x31\x9e\x8b\x4c\x30\xc8\xdf\x6c\x12\x8a\x0b\xc3\xaf\x9e\xed\x2a\x84\x9e\x0d\x3f\xbc\xa0\x97\x0d\xdd\x64\x4c\x34\x29\x92\x4b\x3c\x15\x96\x2b\x61\xe9\x46\x4a\xd5\x8a\x98\x13\x01\xad\x82\x7d\x2e\x02\x4c\x05\x14\x05\xc0\x7e\x4c\xd7\xc8\xd6\xa3\x95\xfc\x74\x9e\xfa\xaf\xa8\x97\x87\x73\x98\x17\xaa\x05\x70\x08\x70\x41\x00\x59\x78\x56\xc0\x76\x01\x76\x09\xb0\x54\x80\x54\xa1\x42\xa0\x93\x88\x81\x4b\x04\x28\x10\x60\x33\x7d\x5f\xc7\xde\x7f\x21\xc0\x83\x2c\x4b\x85\x00\xd4\x99\x45\x7e\xd8\x3b\x58\xd4\x15\xdd\x72\x66\x10\x95\x68\x79\xe9\xce\xf4\xf5\xdc\x85\xf6\x74\x7e\x4a\x7b\xba\x7a\x87\x80\x7a\x0f\x38\xcd\xbf\xc2\xe6\x5f\x27\xe5\x58\x03\xbb\x32\x27\x19\x8b\x25\x78\x55\x7a\x57\x6a\x93\xb8\x06\x09\x24\x6a\x7f\xcd\xba\x62\x75\x95\x59\xca\x95\xf0\x15\x6d\x5a\x8a\x34\x6f\x41\x55\xae\x34\x46\xc2\x2c\x36\xf3\xf2\x19\x55\x03\xa5\x19\x12\x4e\x93\x00\x3b\x24\xf8\x42\x82\x25\xd2\x2e\x09\x23\x29\x4d\x92\x25\x6e\xe0\x83\xd2\x69\x09\xcb\x52\x9d\xb4\x45\xda\x2d\xf1\xa7\xa5\x0b\x12\x9e\x20\x2d\x25\xcf\x07\xa5\x87\x24\x21\x55\x82\xcf\xa5\x0e\x09\x6f\x21\xd1\x67\xa5\x33\x12\x6f\x97\x52\xa5\x7c\xa9\x5a\xe2\x8d\x3c\x12\xe8\x29\xac\xf7\x4f\xc1\x6c\x7d\xbb\x96\xd5\x2e\x63\x1e\xa4\x67\xcf\xca\x25\x91\xe8\x86\x24\x6d\x63\x8c\x33\xdd\x29\xf2\xaf\xb4\x95\x8d\xe5\x0b\xe9\x17\xbf\xb1\xed\x34\x5f\xc8\xd6\x30\x17\xc3\x66\xbc\x80\x5b\x4f\xda\x7b\x44\xbe\x0e\x73\xbc\xe0\x10\xd2\x04\xfc\x01\xc3\xa1\x20\x2f\x5f\x59\x85\x84\x02\x41\x16\xb8\xc5\x82\x3c\xb7\xb1\x8a\x3a\x35\x3a\x28\x70\x04\xcb\xa7\x85\x0b\xc2\xe7\x02\x57\x27\xec\xa6\x09\xf9\xb4\x87\x3e\x17\x3a\x04\x6e\x8b\xf0\x10\x75\x7b\x64\x17\x52\x05\xdc\x9f\xa6\xe1\xa5\x24\xc3\x43\x34\x85\x74\x18\xcd\x82\x77\x93\x0c\x67\x04\x2e\x55\xc8\x17\x70\x87\x00\x34\xff\x07\xea\x2f\xaa\xa9\xf7\x30\x4c\xef\x3b\x45\x9a\xb6\x3c\xf2\x94\x1b\x6d\x99\xb6\x58\xba\x40\xe1\xa1\x1d\x36\x43\x3b\xe9\xb7\x68\x3b\x0c\xe8\x0f\xb2\x45\xc4\x02\x87\x39\xa3\xf4\xa1\xd6\x37\xf6\xf5\x9b\xab\x76\x48\x4f\x4a\x98\x97\xdc\x12\x5e\xc8\xd2\x8a\x16\x2f\xab\xba\x8f\xa6\xed\x26\x3d\x54\x20\xd1\xbe\xa0\x77\xc0\x05\xd6\x17\x69\xd2\x04\xad\x6f\x0e\x4a\xe2\x69\xe9\x73\xda\x57\x2a\xa8\x0a\x79\x44\x95\x5d\x82\xf2\x0b\x34\x71\x29\xeb\xae\x67\x69\xff\xa8\x1d\xb6\x3b\xdc\x61\xf9\x12\x74\x48\x40\xdf\x7d\x20\x71\xb4\xf7\xaa\x25\xce\x68\x00\x11\x77\xe9\x3b\xad\xc3\x98\x2f\x28\xea\xf8\x29\x57\xef\xb4\x49\xf3\xf7\xa1\xb6\x74\xac\x72\x3b\x6d\xac\x32\x01\x1a\xa8\x27\x24\xa0\x04\x6b\x44\xb8\x49\xf5\xd1\x8d\x04\x9e\x63\x5e\x3e\xd4\x63\xfe\xe4\x57\xe9\x46\xf4\x5f\xf2\x3a\xb4\x97\x9e\x2f\xb8\x13\x21\x71\x2c\xff\x00\xc1\x94\xf3\x28\x22\xfd\x0c\x28\x9a\x37\x5d\x22\xef\xf1\x34\x5c\xc3\x3f\xd0\x36\x89\xe4\x6d\xee\xf8\x48\x9c\xce\x1f\x51\xf3\x02\xa7\xf9\xfe\x56\xf3\x4a\x18\x9a\x19\x09\x1d\x09\xdd\x19\xda\xaf\x9e\x5d\xb8\x93\xe4\x1f\xcb\xef\x61\xf9\x89\x3a\xd0\x09\xb6\x84\xc5\xb1\xa1\xc3\xa1\x43\xfc\x9e\xb6\x49\xa4\x78\x96\x5f\x0f\xbf\x6b\x7e\xa2\x04\x8a\xd3\x29\xf8\xb6\x72\x3c\x8f\xe4\x30\x22\xc4\x7d\x26\x1c\x44\x02\x92\xd0\x10\x39\xd9\x00\xc8\xc8\xf1\x46\x8e\x5a\xad\x17\xb0\x60\x32\x0b\x92\x84\x0d\x04\xad\x1c\x18\xe9\x19\x7d\x6a\xe6\x68\x70\xbe\xce\xaa\x87\x4b\x33\x7e\x55\x44\xbd\xd9\x48\xe0\x97\x78\xec\x9b\xa4\x94\xc1\x2b\x93\xe0\x55\xc5\xa6\xdc\x09\xf5\x50\x87\x4f\xe3\x3f\x85\x0a\x71\x49\xe8\xd5\xd0\xf3\x78\x88\xca\x07\xee\x45\x77\xf1\xfd\xf8\xde\xcc\xe6\x46\x8a\x6c\x71\xa0\x78\x23\x32\xa6\xa5\xbb\x2d\x49\x3c\xe9\xc0\xf7\x4e\xe9\x6f\x96\x84\x0f\xa8\x33\x43\x93\xfd\xa0\xcc\x4d\x8f\x4e\xd3\xeb\xfd\xec\xe2\x37\xdc\xbb\xe6\x4f\x6b\xd7\xbd\xb1\x76\xed\x9f\xd6\xaf\x3b\xb3\xa6\xa6\xfe\xde\xb9\xf5\x2d\x0d\xf5\xf7\xd5\xcf\x69\xa9\xc7\x0d\x34\xfd\x4d\xf2\x6a\xcd\x9a\x33\xeb\xea\x5b\xe6\xd4\x1d\xae\x27\x6f\xea\x5b\x98\x4b\x39\x54\x8f\x6a\xf8\x5a\x7e\x12\xa1\x68\x3b\xbb\xc7\x9f\x83\xf2\x51\x19\xaa\x40\xa3\x50\x35\xba\x1c\xd5\xa2\xf9\x68\x09\x5a\x8d\x36\xa3\x33\xf2\xa2\xa4\x09\x4d\x4d\x53\xae\xe8\xbf\x66\xcd\xa0\x0d\xbd\x96\x2e\xed\xbb\x22\xad\xae\x2e\xb3\xc1\x58\x55\x65\x19\x8b\x64\x99\x1f\xe1\x28\x28\x70\x17\x17\x8f\x18\xdb\xb0\x62\xc3\x15\x86\xf8\x69\x33\xe3\x67\x6e\xdd\x32\x7a\xf9\xf2\xf1\xab\x86\xad\x5b\x57\xb9\xa9\x68\xe1\xc2\xd2\x2b\x13\xa7\x4f\x4f\x99\xed\x9a\x34\x29\xb6\x06\x0f\x18\x20\x0e\x31\xf5\xe9\x63\xeb\xb7\x6a\xd3\x95\xb3\x6b\x86\xf4\xeb\x37\xa4\x66\xf6\x95\x9b\x56\x19\x1a\xb3\x1b\xeb\x33\xb2\xa9\x63\x15\x66\x12\x49\x5b\x76\xd5\x6f\xdf\x5c\x2a\x70\x45\x8d\x2d\xff\x60\x66\x76\xdf\x8a\x3a\x83\xf0\x17\xe5\x68\xdf\x31\xda\x77\x9c\xf6\x1d\x7e\x6f\xe8\x12\xef\xfa\xdd\xf5\x7d\xd7\x78\x56\x17\xf8\xe1\xf2\xb8\xb7\x8b\xfb\xf7\x2f\xbe\x89\x06\xdf\x96\x95\x94\x95\x64\xd2\x27\xa5\xac\x94\xfc\xbb\xbf\xac\xa4\xa4\x0c\x4f\xa2\x61\x28\x91\x26\xe0\x6b\x22\x79\x43\x0f\x14\xf7\x2f\x2d\x65\x99\xe1\x0f\xf4\x9d\x32\x93\x86\xdf\xd2\xcc\x37\xd1\x27\xee\x16\x12\xf4\x25\x31\xe5\xcd\xb2\xb2\x92\x8b\x24\x02\x7b\xc8\xc3\x74\x0a\x6c\x35\x09\xe0\xf1\x52\x7f\x79\x68\x04\x79\xda\x57\x5c\xdc\x1f\x27\x69\x99\x14\x8e\x3c\x7c\x48\x7f\x76\xb6\x7f\x71\xff\x3e\xe4\x41\xbd\xaf\xff\x08\xda\xce\xfb\xb8\x56\xf5\xee\xad\x89\xb7\xd9\xed\xf2\x86\xcd\x55\x8b\xec\x10\xb0\xc3\x18\x3b\x0c\xb6\x43\xae\x1d\x92\xed\x60\xb6\xc3\x4a\xbb\xbc\x74\x45\x95\x7d\xcb\xc2\x25\x55\x76\x99\xc8\xa9\x48\xa6\xf2\x70\x26\x78\xd2\xfe\xaa\xfd\x5d\x7b\x9b\x9d\x7f\xd0\x0e\xfb\xa9\x23\xd8\xcd\xf6\x5d\x76\xce\x2e\x8f\x9d\x50\x75\xc1\x0e\xaf\x32\x97\xaf\x3b\xec\xf7\xd9\xb1\x5d\xa6\x1c\xd0\x9e\x6a\xc7\x43\xec\x72\x49\x79\xd5\x69\x3b\xf9\x2d\x75\x16\x7b\x93\x1d\xbc\xf6\x5c\xfb\x40\xfb\x0c\xfb\x7a\xbb\x60\xb7\x03\xee\xb0\x83\x5d\x4e\x4a\xab\x4a\x63\xee\x65\xed\xb2\xd3\x5d\xb5\x85\x7a\x94\x25\xbf\x35\x1a\xec\x94\x85\xe5\xcf\x62\xbc\x90\xf9\xbe\xab\x55\x15\x62\x95\xd1\x93\x34\xaa\x09\x87\xd3\x72\x73\xc3\x7a\x72\xae\x26\x01\xd8\x88\x43\xbe\x0c\x44\xdd\x86\xe0\x85\x57\x9e\x5f\xae\x28\xc7\x8f\x29\xca\x92\x73\x5c\xeb\x8a\x77\x16\x1e\x57\x14\xe0\x8e\x5d\x71\x76\xb5\x3a\x9e\x7b\x13\xb9\x7e\x84\xbf\x86\xd9\x94\xb8\x51\x5e\xc0\x83\x05\x63\x70\x7b\x3c\x72\x5d\x43\xd5\x12\x0f\xe4\x7a\xc6\x78\x66\x78\xb8\x54\x0f\x98\x3d\xd0\xe1\x81\x19\x1e\xf0\xc8\x13\x6a\xaa\x3c\xf2\x88\xb1\x55\x0f\x7a\x00\xdb\x3d\xbb\x3c\xb8\x3c\xd5\x53\xeb\x59\xe2\xd9\xec\x39\xe0\x11\xec\x9e\x7c\xf2\xb0\xcb\xf3\xa0\xa7\xc3\x23\x7a\xe4\x41\x15\x24\x6f\x71\x59\xd5\x17\x1e\xa8\x20\x99\x0e\x90\x74\xde\x01\x46\xa4\x72\x7b\x52\xeb\x5c\x7a\x0c\xbb\x96\x7e\xab\x3e\xfe\xf4\x27\xb2\xd3\x9d\xd0\x85\x67\xf4\xe6\xaf\x69\xe7\x57\xbd\xba\x7a\xd5\xa9\x55\xab\x5e\x23\xe1\x4a\xfe\x9a\xb6\x8d\x78\xe8\xaa\xd7\x56\x91\x67\x92\xb8\xfa\x35\xd2\x12\x7d\x9b\x7c\xd4\x77\x26\xef\x76\x83\x25\x29\x89\xb4\x2c\x33\xcb\x11\x4f\xf8\x15\x45\xf0\xfb\xef\xbf\xee\x78\xff\xf5\x2e\xc7\x04\x59\x99\x5d\xf8\x56\x4e\x0f\x75\x98\x58\x7f\x78\xce\x1c\xc2\x94\x58\x38\xae\x7b\x85\x22\xef\x48\xa8\xaf\x1c\xc3\xf9\x55\xb0\x0d\xcf\xe5\x56\x12\xfa\x4c\x40\x4f\xc9\x3b\xdc\x06\x1b\x61\x65\x89\xde\x77\xbd\xe0\x95\xaf\x5a\x5d\x55\xeb\x85\x81\xde\x31\x5e\xcc\x7b\x61\xf1\x0e\xef\x7e\xef\x7d\xde\x57\xbd\xfc\x66\x2f\xe0\x5a\xef\x12\x2f\x4e\xa3\xae\x76\x4f\x7b\xb1\x57\x1e\x3f\xb9\xca\xe1\x4d\xf3\xe2\x0f\x98\xf3\x5d\xaf\x3c\x78\x58\x15\xf2\x3a\xbc\x78\xc0\x17\x5e\xd8\xe5\x3d\x40\x32\x71\x5e\x39\xb7\x9f\x9a\xe9\x0b\xea\x7f\x77\x17\xfd\x59\x62\xb2\x9a\xed\x03\xea\xaa\xb7\xc2\x5b\xed\xdd\xec\xe5\x91\x17\x8c\x71\x9c\xd3\xc4\x58\xb8\x2a\x83\x69\x7f\xe4\x86\xa5\x70\xee\xb2\xc8\x35\xd6\x4e\x72\x98\x9e\x23\x0f\xdb\xc3\xee\xec\x96\x65\xee\xad\x73\x46\x2c\x1d\xb1\x67\xde\xfc\x51\xa3\xc7\x36\x56\x56\x36\xd6\x8f\x1e\x57\x8b\x37\x2e\xba\x61\xe8\xf2\x91\xf3\x9b\x47\x8f\x9a\x5f\xd9\xd8\x58\x39\x6a\x1e\x3d\xb7\x2e\xc0\xc3\x44\xee\xad\x25\x72\xcf\x8c\xe2\x51\x26\x2a\x40\x03\xd0\x12\x59\x8e\x11\x07\x24\xa4\x96\xe6\x66\x59\x10\xca\x4a\x15\xf9\x81\x83\x7a\x25\x65\xf4\xcb\x28\x29\x6c\x2a\x84\x40\x21\x8c\x2a\x84\x84\x42\x28\xf4\xf7\xb7\x67\xd4\x66\x2c\xc9\xe0\x8c\xfd\x65\xc9\x56\x95\xd1\x3f\xa3\x3f\x67\xa7\x07\xaa\x62\xa9\x2a\xf8\x1e\xbd\x8e\x41\xd8\x31\x19\x22\x8e\x53\x7e\x75\x13\xcc\xe9\x77\x9c\x2a\x8a\xdc\x17\x8b\x9c\x04\x70\x23\x43\x06\xca\x29\xa6\xc6\x68\x0c\xc5\x28\x87\x9e\xba\x77\xa3\xb8\x22\x04\x97\x72\x44\x4b\x8d\x9b\xc5\xd1\x43\xfa\xe2\x5a\x65\x6f\x7b\x48\xb9\x0d\x88\xc4\xc4\xe4\x7f\xfd\x74\xe5\xf5\xb7\xdf\xb9\x75\x1f\x14\xbd\x7d\x1e\x0a\x42\x33\xfa\xa5\xa5\xe5\xe5\xa5\xa5\xf5\x83\x37\xfb\xa6\xa5\xe5\xe7\xa7\xa5\xf5\x0d\xfd\xdf\xd8\x3d\xcd\x63\x87\xd4\x3f\xfe\x78\x3d\xae\x52\x88\xf2\x02\x8d\xa1\x56\x58\xa8\xdc\xfc\xdd\x79\x28\x82\xdb\xf6\x9d\x7f\x5b\x79\x1d\xa0\x18\x6a\xd2\xfa\x85\x7f\xcc\xbe\x95\x67\xb6\x6f\xf7\x3d\xf1\x04\x3b\x7f\x00\x7f\x22\x38\xdb\xc7\x70\x46\x6d\x83\xe5\xa1\x06\xb9\x3c\xd3\xe2\xea\x95\x12\xef\x8a\x17\x89\xb2\xde\x2f\x3f\xdd\x63\xf7\xda\x7b\xe7\x35\xe5\x41\x20\x0f\xc6\xe4\xc1\xe0\x3c\xc8\xcb\xcd\xa6\x2c\xa6\xd6\xbe\xc4\xce\x1b\xab\xb3\x6b\xb3\xb1\x3d\xdb\x9e\x2d\x11\x54\xbd\xc6\x8c\x72\x13\x34\xbd\x1e\x45\xd3\xeb\x45\x11\x87\x1b\x91\xbb\x2c\x3a\x34\x09\x7a\x8f\xa8\x7a\xcb\x6e\x14\x33\x39\x0c\x33\xfb\xba\x60\x26\x84\x7a\x40\xc6\x03\x14\x0f\x43\xc6\x36\xef\x19\xdb\x19\x19\xeb\x74\x2d\xa7\xdf\xca\x7b\x4f\x3c\xe1\xdb\xbe\x9d\x9e\xd9\xab\xec\xb8\x4a\xb4\xf1\x03\x51\x1f\x22\xf5\x07\xc9\x99\xfd\x7c\x25\x26\x9f\xa9\x7f\x79\xe1\x96\x84\x33\x09\x1f\x24\x70\x9b\x13\xa0\x20\x01\xf2\x13\x20\x21\xd7\xde\xa7\xa2\x4f\x75\x1f\xce\xd8\x87\x5d\xcf\x79\x8f\xb6\xed\x54\x67\xab\xe2\x29\x10\x57\x16\x67\x60\x2e\x1d\x44\x43\x9c\x21\xc7\x86\x0d\x64\x92\x9c\x9d\x63\xc8\x29\x63\x0e\x20\x4a\xcb\x72\xca\xe2\x4a\xcb\xe2\xc2\x06\xed\xe8\xf5\x41\x6e\xfb\xb0\x61\x73\x07\x3d\x91\x77\xa2\x46\x3c\x77\xce\x39\xe6\x44\xe1\xb1\xcc\xd1\x43\x4a\x86\xad\x6d\x78\x2a\xf7\xd8\x78\xc7\xb9\x73\x96\x09\x8f\xf5\x7a\xfa\xca\x65\xa9\x3b\x9e\x7b\x61\xfb\x8e\xba\xb9\x27\xf9\x81\xe7\xc5\x9c\xbc\x63\x79\x27\x96\xad\x18\xb2\xb1\x8e\x64\x4a\xec\xe3\x30\x9e\x3f\xef\xbc\xec\xb1\xbc\x13\x0d\x1b\x87\x6c\xa9\x25\x10\xc6\x59\x07\xbf\x14\x0c\x9e\x9c\x33\xe7\x57\xc1\x97\x68\x1b\xdf\x41\x13\xf8\x6c\x7e\x2b\x19\x11\x39\x68\xb4\x9c\x93\x1c\xeb\xb2\xd9\x3c\xa4\xe3\x33\x33\x9d\x66\xde\xdc\xab\xb7\xcb\x63\x47\xf1\x8e\xf8\x09\xf1\x5c\x7c\x9a\x0d\xa1\x2d\x08\x1b\x51\x82\x81\x12\xfd\xec\x59\x45\xa7\xf2\x67\xf9\x4f\x15\x45\x8e\x0b\x6a\xc7\xd9\xe9\xc5\x4c\xe8\x87\xb5\xd1\xea\x71\x8b\x06\xed\x08\x0e\x3d\xe7\x96\x41\x7d\x4a\x69\x0d\xec\x07\xf8\xbd\xb1\x8b\x46\x3c\xb0\x7c\xd5\xe4\x9a\xdd\x0b\x01\x75\xa0\xd1\x44\x68\x60\x5f\xff\x99\xe5\xeb\x27\x5d\x3e\x70\x70\xf9\x2c\x3c\xcc\x3c\x76\xdd\x98\x4d\xbf\xad\x99\xbc\x6e\xf1\x5d\xd6\xdf\x55\x2a\xad\x20\x56\xe2\xe6\x92\xda\xf2\x9a\xb5\x43\x06\x4f\x19\x50\x5b\x4c\xdb\x30\x11\xb5\xf2\x0f\x92\x36\xf4\x45\xfd\xd1\x08\xd9\x57\x90\xda\x37\x3d\x27\xce\xe9\x2c\xe5\xd3\x73\xd2\xcb\x07\xf4\x4d\xed\xe3\x47\x99\x5b\x32\x71\x66\xde\x6e\x33\x91\xc5\xd4\x66\x37\xed\xa6\xd7\x66\x69\x03\x57\xef\x2a\x8e\x1a\xbb\x65\xf6\x37\xa8\x5d\xc9\x52\x66\xc7\x96\x5e\x32\xf7\xd0\x71\x9a\x0a\x6e\x3b\x33\x2d\x6c\x88\xf5\xe8\x2e\xb6\x18\xc2\x14\x49\x7b\xac\x63\x4f\xae\x51\x14\x8d\xe9\x23\x06\x4e\xeb\x9d\x69\x75\x88\x0e\x0b\xcf\xdb\x62\xb2\x32\xad\xff\x9a\xf2\xe0\x8a\x15\xf7\xb7\xac\x1b\x35\xf9\xb6\xc0\x86\x4d\x97\x07\xd6\x6d\xe0\x51\x6e\xae\x60\x35\x4a\x3c\xef\xb4\x5a\x6c\xde\x41\xf5\xe3\xfd\x69\x92\x28\x0e\x9d\x5e\xf4\xd9\xc4\xc5\x1b\x1f\xb8\x7b\xdd\x9a\xc3\xb9\x69\xeb\x02\xb5\xab\x36\x4e\xbb\x7c\x03\xd3\x37\x06\x92\x7e\x11\xf8\xd3\x28\x1d\x32\xe4\x0b\xc8\x6c\x8e\x73\x3a\xe2\x38\x31\x49\x4c\xca\xf0\x0d\xf4\x8d\xf1\xe1\x54\x5f\xbe\x0f\x9b\x7d\xd0\xe6\x83\x0b\xbe\xcf\x7d\xd8\x27\x93\x39\xf2\x2e\x1f\xcc\xf0\x2d\xf2\xe1\x6a\x1f\xe4\x92\x6c\xd8\xee\x4b\xf5\xe1\x45\xf7\xf9\x9e\xf4\x7d\xe2\x6b\xf3\xf1\x07\x7c\xb0\xde\x07\xb5\xbe\x25\x3e\xdc\x23\x8c\xfd\xbe\xfb\x7c\x98\xc0\x58\xe4\x83\x6a\x5f\x2d\x7d\xe5\xf5\xe1\x1d\xbe\xfd\xbe\x57\x7d\xef\xfa\xf8\xcd\x1a\xf0\x0a\x5f\xb5\x0f\x13\xd0\x50\xde\xe1\x83\xdd\xbe\x83\xbe\x33\x3e\x6e\x89\x0f\x90\xcf\xe1\x93\x7d\xdc\x16\xdf\x6e\xdf\xb3\x24\x89\xa7\xc0\x69\x51\xfc\x43\x24\x4e\xa1\x2e\xf5\x01\xad\x0f\x85\xcc\x4b\x09\xd4\xe1\x4a\x82\xb3\x9a\x68\xd6\x74\xc6\x33\x8b\x30\x54\xbf\xb6\x76\xa0\xae\xd3\xd5\xea\x56\xe8\x3a\x2d\xde\xb1\x09\xdc\xb2\xa8\x93\x15\x76\x3c\x87\x8c\x38\xf2\xc7\x2e\x38\xa5\xe0\x54\x48\x2f\x23\xa2\x75\x30\x84\x5d\xcb\x11\x95\x25\x2d\xa1\xee\xd6\x1b\x2a\xf1\xd5\x97\xdf\x31\x97\xab\xbe\xfb\x5a\x63\xfb\x3f\xc5\x0d\x47\x2e\x9f\x7e\x38\x70\x75\x60\xee\x8e\x6b\xf9\xd3\x75\x2d\x3b\x36\x5d\x3b\xaa\x6e\xcb\x33\x07\x7e\x37\x5b\xca\xca\x9a\x73\xa4\xd9\xf6\xcc\x96\x99\x81\xe0\xa4\xd5\x4f\xa8\xfa\xdf\x20\x22\x54\x78\xfe\x65\x54\x0c\x4b\xe4\x8e\x7c\x32\xff\x31\xc6\xa7\x08\xbd\xec\xbd\xec\x25\xbd\x4a\x67\x94\x2e\x2a\xc5\xe3\x4a\x21\xb7\x74\x60\x29\x4e\x2e\x25\x9a\xe5\xc7\xa5\xf8\xbe\x52\x48\x28\xed\x5d\x7a\x59\x69\xa0\x74\x6d\xe9\xf6\x52\xd1\x5c\x0a\x0b\x3e\x2e\xfd\xae\x14\xbf\x4b\x33\xbc\xc2\x32\x6c\x2f\xdd\x57\x8a\xd7\x97\xc2\xe2\x52\x08\x94\xc2\x98\x52\x18\x5c\x0a\xbd\x4b\xc1\x5b\x0a\xd6\x52\xf8\xae\x14\x3e\x29\x85\xf2\xd2\x05\x24\x53\x0b\xf9\xc1\xf9\x52\x31\xb7\x14\xa4\x52\x68\x2b\x85\xf3\xa5\xf0\x6a\x29\xb4\x94\xc2\x8e\xd2\xfd\xa5\x78\x6d\x29\xb0\x2a\x5c\xa6\x55\x21\xa1\x14\x48\x69\xe5\x24\xdf\xbf\x68\xbe\x77\x4b\xf1\xd3\xb4\x2c\x58\x15\xad\x12\xcf\xaa\x52\x2a\xa7\x67\x55\xad\xa7\x85\x2f\x28\xc5\x63\x68\xd9\xe5\xa5\x58\x5f\xfa\xfb\xa5\xf0\x4a\x29\x3c\x59\x0a\xf7\x97\x02\xd8\x4b\x2b\x4a\x97\x94\x1e\x28\xe5\x65\x57\x66\xae\x31\xdf\x9d\xc6\x9b\x53\xcd\xe0\x32\xbb\xcc\xe0\x05\xe6\xb6\x92\x32\x7c\x6a\xd8\xd6\x0f\xe1\xf5\x5a\xb5\x03\x73\xbb\x59\xc4\x9b\xd5\xd9\x87\xbc\xee\x2d\x5b\x92\xf5\x47\xba\x97\x9a\x39\x28\x1b\xc2\x95\xe4\xa8\x7a\x13\xed\xce\xa2\x38\x36\x64\x35\xb3\xaf\xa5\x65\x61\xd6\xc3\xf4\xaa\x14\x2e\x8e\xaf\x6c\x3f\x66\xbc\x7e\x75\x6d\x09\x2e\x7f\x24\x30\x6e\x6b\xe5\xaf\x67\x0d\x69\xc8\x76\x9a\xef\x5a\xb6\xe2\xe0\xc8\x29\x8e\xd8\x9c\x05\x23\x2e\xbb\x7d\x45\xff\x55\xb5\x83\x85\xc2\xc5\x9b\x97\xfb\xbc\xa5\x6b\x6e\x1e\x9b\xbf\x66\xd5\xd8\x4d\xe3\xae\xba\x13\xfc\x43\x7b\x65\x65\xaf\xbd\xe5\xe0\xa2\x9a\xfa\x5e\x9c\x71\xfc\xd8\x15\x2b\x7e\x5b\x38\x69\xc1\xa6\x7d\x6b\x4a\x3c\xea\x3d\xbd\x8e\x8f\xf9\xe9\xfc\x5a\xc2\x43\x13\x65\x13\xb2\xc6\x18\x0c\x31\x09\x89\xa6\xc8\xa4\x5a\xd5\x97\x85\x7e\x10\xf1\xe9\xa1\x5d\x15\xa7\xac\xd1\x06\xb8\x3e\x76\xc6\x43\xd3\xc7\x94\xee\x98\x77\xf9\xae\xec\x8c\x1b\xa7\xcd\xd9\x35\x6d\xc9\xce\xad\x71\x35\xc7\x3e\x5d\xdf\xb0\x75\xd8\xa2\xed\xcb\xd7\xac\x5e\x19\xac\xaf\xf9\xfd\xf6\x47\xcf\x92\xb2\x86\x75\xfc\x83\x7b\x83\xd0\x9c\x05\xa5\xca\xd4\xd5\xa6\x89\x33\x71\x56\xdb\x18\x6a\x0f\x2a\x21\x7f\x56\xb8\x3c\xd5\x32\x0d\x8a\x13\x91\x21\x1b\x67\xe7\x94\x22\x6c\xa8\x02\x69\xdd\x08\xe5\xf5\xc9\x59\x8f\xdf\x34\x75\x05\x70\xfc\xcb\x1b\x95\x5b\xb7\x57\x2a\x0b\x6e\x1a\x05\xc2\x33\x8d\xdb\x21\xa0\xd2\xf4\x49\x94\xcc\x0d\x24\xbc\x34\x01\xf5\x93\x3d\xd8\x66\x4b\x30\x09\x82\x3b\x21\x21\xd1\x6b\x35\x1a\xf3\xc9\xfb\x38\x27\xe1\xfd\xaf\xcd\x2a\xcf\x2f\xd7\x99\x27\xd4\x64\x1c\xc5\xb8\xc1\xc7\xec\x7e\xeb\x6f\xfe\xc1\xc7\x63\xf7\x2d\x9e\x9d\x5f\xbe\x5c\xde\xb3\xa8\x7c\xc0\xc6\xf1\x7d\xfb\xf1\x5b\x1b\x9e\xdb\x73\xf8\x96\xb5\x5b\xd6\xac\xb9\xd3\xac\x88\xeb\x6f\x2d\xed\x37\x6e\x45\x0c\x3b\x27\xef\xe8\x38\xcb\x7f\xce\x5f\x8f\x92\x50\x1a\xaa\x93\x8b\x93\xed\x76\x4f\x62\x8a\xc1\x62\x41\x89\x28\x3d\xc3\x96\x5c\x93\x0c\xc3\x93\x21\xd9\x9a\x52\x9a\x02\x59\x29\x54\x6b\xe7\x52\xc0\x98\x92\x94\xe6\x9d\x46\x54\xd3\xd4\xa4\x78\x97\x89\x67\x37\x2f\xf3\xfd\x7e\xa6\x5e\xcc\x56\xf5\x0c\x3f\x53\x36\xc2\x12\x39\xaa\x8e\xe9\xec\xc9\x3a\x85\x48\xa5\xe3\x48\x2c\x0b\xb2\x4a\x04\xfe\xf3\xd2\xf5\x97\x95\x97\xaf\x1b\x5f\xd0\x27\xf4\xce\xf6\xab\xca\x07\x6c\xa8\xce\xcb\xc3\x4f\x84\x76\xe3\xec\xd0\x3b\x30\x62\xfc\xb2\x29\xa5\xf9\x13\x97\xb8\xe0\xd9\x9b\x95\x55\x2b\xf7\x97\xe4\x8d\x5d\xc3\xc5\xe0\x2f\x1e\x51\xe6\xdf\xbc\x72\xaf\xaa\x83\x17\x75\xf4\xe7\x5e\x17\x5e\x63\x67\x48\x2e\x93\x73\x52\x5d\xa2\x68\x37\x1b\x92\x62\x38\x2e\x31\x16\x1b\x70\x5a\x7a\x5c\x5c\x6c\xb2\xcb\x62\xf5\x26\xf2\xa9\x46\xc9\xec\x70\x18\x3c\x06\xce\x85\x2a\x98\xc7\xd7\xb8\x72\x7f\xbe\x4e\x3a\xf9\x23\x07\x5c\xc1\x40\x2f\x32\x91\x8f\x41\x35\xfb\x4f\x1a\x95\x45\x3e\xd4\xca\x7f\x99\x40\x5e\x70\xaf\xff\xa1\x4e\x79\xac\xee\x0f\xe4\x5f\x1d\x8c\xa5\xdf\xca\xdb\xca\x63\xf0\x74\x80\x28\x3e\x83\x0f\x2a\xfb\x61\x48\xe0\x40\x00\xfe\x43\x83\x51\xca\x07\x07\x61\xa6\xf2\x2a\x79\x56\xcc\x81\x2d\xf0\x9f\x83\x8a\x99\xf4\x73\x01\x91\x35\x4d\xcc\xd7\xd8\x5c\xb9\x98\x9e\xdf\xf7\xc6\xc5\xc4\xd8\xd3\xd2\x21\x29\x25\xa9\x36\x20\x79\x62\x3d\xb5\x01\x31\x56\x48\x48\x4c\xa8\x0d\xe0\xc4\x58\xf2\xdf\x99\xc2\x39\x63\x6a\x03\x76\xa7\xd3\x54\x17\x70\x6a\x16\xd2\xe9\xd1\x77\xcd\xd1\x6c\xd4\xb6\xb3\xde\x3a\x78\xa4\x3d\xe1\x93\xba\xe9\x45\x65\x31\xd4\x20\x47\xc4\x3e\x3a\xb5\x1a\x82\x57\x9f\x86\x9d\xca\x0a\xf6\x31\x9e\x6d\x18\x32\xd4\xd5\xf6\x11\x75\x49\x74\xfc\x08\x1e\x24\x18\x35\xbf\x43\xf3\xdd\x10\xa7\x6c\xd6\xdc\x0e\x51\x47\x29\x94\x9e\xc9\x1c\x0d\x3b\x84\x1b\x08\x3d\x5f\x21\x0f\xe2\x91\xd1\xe8\x71\x5a\xad\x89\x5e\xea\x55\xa6\x3a\xc0\x3b\xa8\x3f\x99\xea\x00\x72\xdb\xdd\x15\xee\x25\x6e\x8e\xfc\x97\x25\x57\x15\xf5\x28\x63\x8e\x8f\x8f\xad\x0e\x90\x49\x9c\xd5\x6c\xad\x0e\x98\x3d\xdd\x7c\x32\xe4\x32\x5b\xde\x9d\x9d\xa3\x45\x1b\xe4\xd7\xdc\x2d\x75\x32\xf5\xce\xcc\xd7\x2e\xb9\x93\xfc\xfb\x8d\x92\x70\xf0\x76\xf2\xef\x20\x54\x72\x03\x46\x8f\x1e\x1d\xfa\x3f\xe6\x7d\x2a\x96\x3c\x62\x5b\x7c\x9e\xea\x67\xdd\xa5\xf6\x81\x23\x1b\xe5\x53\x5f\xf0\xf8\x4e\x84\x42\x4f\x53\xdb\xfe\x24\x3d\x9d\xd9\x6f\x49\x43\xd3\xe5\x82\xe4\x04\x00\x93\xe8\x26\xca\x46\x7a\x46\x32\xaa\x0b\x24\x31\x03\xf7\x09\x52\x32\xf9\xcf\x5b\xad\xf1\x75\x01\xab\xb9\x36\x60\xed\xd9\x76\x3d\x6b\x4a\xb8\x5b\xf4\xe3\xa3\x93\x9d\x7a\x5a\xf1\x34\x3a\x3c\x34\xc7\x46\xf4\x60\x01\x51\xc1\x35\xab\xf4\xd4\x26\xfd\xa7\xdf\x7d\x0c\xde\xdb\x8e\xd5\xff\xf3\x9f\x4d\x2d\xbf\x09\xdb\x9f\xe7\xfa\x8e\x86\x5e\x89\x25\xca\xca\xd7\xdf\x82\xbb\x7e\x7b\xa3\x72\x71\xb4\xf2\xe9\x6d\xea\xb8\x18\xa8\x8c\x14\x26\x33\xff\xba\xd4\xee\xbc\xdf\x26\x49\xa2\xcf\x67\x35\x99\x52\xe3\xc9\xac\x42\xec\xd5\x3b\x2e\x31\xd1\x55\x17\x48\x4c\x92\xec\x99\xf6\xba\x40\x66\xa6\x15\x5b\x4d\xa4\x11\x2e\xec\xab\x0b\x60\x44\x68\x8e\x7a\x7e\xec\xe4\x74\x37\x6c\x54\x3c\x62\x42\x97\xaa\xa2\x61\x1f\xfe\x61\xe3\xb8\x06\xd5\x15\x88\xd3\xad\x9a\x10\xf7\xa8\xf3\xca\x88\xbb\xa6\x7f\x1c\xc1\xc3\xdb\xbf\xf8\xf5\x56\x58\xd4\xac\x3c\xa3\x5c\xff\xe5\xce\x3e\x95\x31\x29\xc3\xaa\xb7\x34\x1c\x9e\x8c\x9f\xba\xf9\xc9\xfb\x1e\x7e\xf4\x56\x6a\x38\xf8\xf0\x53\xd7\xbd\x90\x1d\xfa\xa7\xb7\x04\x8f\x0d\x59\x7f\x9f\x18\xb7\xe3\xeb\x94\xf5\xaf\x5f\xcf\x3d\xb6\x6f\x6b\xe8\x85\x6d\xaa\xcd\xe0\x2a\x65\x1b\xb7\x4c\xe8\x87\xd2\xc9\xec\xa1\x00\x95\xa0\x1b\xe4\xd1\xb9\xb6\xc2\xe4\x3e\x7d\x12\xd2\x20\x2b\x2f\xb3\x5f\x89\xa1\xd8\x18\x1b\x13\x63\x34\xf4\xcb\x03\x91\x4b\xe0\x12\x4a\xcb\xf2\x72\xd2\x72\x26\x06\xfa\x24\x27\x03\x92\xd3\x62\xfb\x65\x14\x66\x54\x07\x0c\x85\x85\x49\xce\xa4\x84\xea\x40\x92\xa7\xd8\xe4\x34\x4d\x08\xc4\xba\x6d\x4e\x07\x73\x96\xa1\x23\xc7\xf8\x7c\x7f\xd4\xa8\xb8\xb3\xab\xeb\xcb\xce\xff\xfd\xd4\xa0\x92\x17\xb2\xe9\xaa\x4d\x59\x4c\xb6\xe6\xeb\x95\xf0\x3f\x32\xea\x98\x2b\xd8\x74\x32\xa9\xca\xe1\xc0\xe0\xe3\xa8\x52\x5b\x96\xe5\x8e\x8b\xb1\x11\x5e\x58\x9c\xc3\x5d\xbe\x75\x77\xd5\x75\x9b\x97\x79\xb3\x1b\x26\x67\xf4\xbf\x6b\x7d\x5a\xd1\x96\xaa\xeb\x6e\x5d\xa9\x28\x31\xcb\x1f\x4e\xdb\x00\x8f\xef\x14\xaf\x4e\xc8\x18\x31\xb7\x48\xd9\x9b\xbc\x64\xf4\x30\x68\x4a\x98\xa3\x6c\x83\x55\xf9\xef\xcc\x5e\x3d\xc4\x08\xa3\x2d\xf9\x2b\x4f\xf9\x04\x58\xae\x6c\x2a\x7c\x22\xb4\x2d\x21\x6f\xf6\x72\xac\xdc\xca\x4d\x17\x94\xed\x52\x6a\xfc\xda\x89\x7d\x60\x84\x6d\xd6\xd3\x7b\xa6\xe4\x32\x1b\xa4\xb8\xe3\x3d\x65\x1b\xfe\x33\xc1\x9f\x97\x50\x48\x40\xee\x6b\x33\xa5\xa4\xf0\x89\x00\x06\xc4\x5b\xdd\xbc\x3b\x35\xcd\x96\x94\x14\x6f\x82\xc4\xc4\xf8\x78\xd7\xc4\x00\x8a\x8f\xe5\x53\x4c\x29\x13\x02\x16\xa3\xc1\x64\x27\xd8\x39\xf5\x92\x8a\x8f\x93\x61\x8f\x8e\xe5\x7a\xee\x1f\xc6\x44\x61\x01\x17\x13\xf5\xc6\x15\xe3\x07\x9d\xaf\x59\x82\x81\x18\x5f\xe6\x73\xb6\xf5\x1b\xe7\x55\x3c\x79\x7b\x95\x32\x67\x60\xc1\x80\xc9\xbe\x6b\xfb\xd7\x14\xfe\x16\x62\xf6\xed\x23\x2d\xfb\x4b\xd6\x60\xbc\x27\x2f\xe7\xec\x59\xb8\xba\xad\xa3\x66\xe8\x30\xc7\xd0\xf8\xd4\x42\xa5\x89\xbb\x1c\x36\x50\xbf\x58\xca\x0a\x61\x87\x30\xd8\x25\xf2\x93\x99\x5c\x75\x2b\x2b\xb8\x8f\x08\x1f\x4a\x43\x53\xe5\x54\x14\x17\x97\x64\xb2\xd9\x9c\x52\x92\x94\x9e\x91\x9a\x5c\x1d\x20\x29\x24\x92\x98\x54\x1d\xb0\x27\x7a\x2c\x27\x60\x8c\x6c\x8a\xc5\x98\x48\xde\x49\x01\xc1\x81\x22\x1e\x70\x34\x77\x02\xfe\x6e\x77\xb4\xa8\x28\x33\x68\x4e\x99\xe2\x3c\x9c\x8f\xf3\xa9\x3e\xf3\xf4\x5e\xf2\x2a\x0d\x55\xc7\x2b\xd6\x6d\x58\x6e\x1f\x3a\xe7\xc3\x8d\xbf\x9b\x7d\xcd\x66\xa5\x61\xf5\x4e\x28\xe2\xbe\x69\xea\xd7\x7b\xd0\x8d\xd7\x87\x6e\x71\x17\x51\x0e\x4b\xb8\xd0\xec\x23\xc9\xa1\x18\xca\x8f\x04\x4c\x58\x11\x99\x77\x28\x63\x85\xe3\x64\xac\x7a\xc9\xec\xbf\x28\xde\x62\x31\x71\x09\x58\x30\x1a\x25\x0e\x3b\x79\x27\x9f\x94\x8c\x13\x12\xe2\x5c\x6e\x57\x6d\x80\x8b\x37\x99\x79\xbb\xd7\xcd\xf1\x16\x8b\xd3\xee\x24\xc2\xc0\x25\xb9\x44\xd2\x1c\x54\xa1\x77\xe3\xa3\x1a\xd4\x89\xac\x4b\xd3\x39\x97\xd6\x0e\xcd\x2e\x93\x41\x82\x38\xda\x08\xd0\xd5\x9f\x88\xb6\xb0\xb7\x1e\x3c\xf8\x16\xe7\xd0\x85\xcd\xa1\xaf\x8e\x52\x4f\x3d\xd4\x4f\x0f\xbe\x5a\x73\xd3\x13\xca\x70\x2b\x0e\x78\x0c\xff\xae\x59\xf5\xd3\x43\xcd\x7a\x97\x24\x86\x82\x78\x0d\x73\xd2\x03\x28\x47\x59\xc1\x23\xd2\x0f\x49\x68\xbe\xdc\x17\xc5\xc4\x38\x0d\x20\x4a\x56\xab\xc3\x20\xc6\x1b\xe3\x8d\xc9\x29\x5e\x32\xd6\xbc\xc8\xe8\x70\xc4\xc4\xc7\xc6\x93\xf1\x87\x9c\x2e\x9e\xb3\xc5\x7a\xcc\xa4\x15\xc7\x45\xe0\xa0\x3a\xc0\x45\xac\xae\xea\xdb\x12\xe9\x93\xae\xcd\x91\x54\x1b\xe6\xa4\x49\x5a\xc7\xe8\x5b\x05\xd3\x60\x6b\x3d\x8c\x5d\xa9\x7c\x0d\xd3\x1a\x49\xcf\x9c\xa9\x51\x94\xf5\x0d\xca\xe6\xd5\x3b\xa0\x10\x5e\x84\x03\xde\xbc\xbc\x38\xe5\xb3\xd0\x67\x2e\xad\x6f\xe0\xe6\xeb\x95\x7f\x47\xba\x86\x1e\x63\x51\xc6\xf2\xeb\x48\xdf\x38\xd0\x70\xd9\x6a\x76\x58\x2c\xd8\x00\x44\x19\x74\xba\x6c\x94\x8a\x9c\x26\x6c\xc4\x75\x01\x83\x91\x03\x33\x32\xeb\x5d\x0b\x69\x0c\xa3\x13\xb3\x2c\x2c\xf0\x97\x80\xe6\x3c\xc8\x03\xe9\xb4\xba\xf5\xf8\x8b\xd6\x6f\x67\xa5\x8e\xe4\x9a\x43\x66\x6e\x08\xc1\xfa\x6c\x7e\xbb\xfb\x4d\x18\x5c\xd3\xb6\x38\x9e\x22\x9a\xe1\xb4\x8c\xd0\xf6\x24\xee\x08\x72\x22\x59\x4e\x71\x70\x4e\xa7\x68\x11\xec\x82\xdd\x15\x63\x17\xad\x22\x19\x94\x56\xbb\xe0\xe0\x1d\x13\x02\xbc\x07\x54\x5a\xe8\xe4\xb2\xb7\x53\x05\x54\xa7\x6b\xd4\x0c\x8e\x6a\xe3\x1a\xd2\xb9\x49\x04\x2d\xa1\x5b\x30\xff\x7e\xff\x26\x77\x6a\x3e\x3e\x16\x6a\xc7\x23\x18\x32\xb8\xfc\x18\xc7\xf5\xad\x85\xed\x67\x55\x3f\x26\x9f\x0a\xdb\x85\xb1\xc8\x4c\x7a\x76\x8c\x9c\xc3\x39\x63\x2d\x92\x94\xe0\x4c\x48\x4e\x49\x22\x1a\x4a\x92\x2b\x8e\x33\xc5\xc6\xba\xdd\x44\x72\xb8\x79\xc9\x62\xb1\xd9\x88\x28\xb4\xc5\x44\x87\x56\x64\x88\x75\x92\x82\xd4\x5c\x0f\x76\x3a\x5c\x94\x11\x3a\xb3\x63\xa2\xae\x5f\xcb\xfc\xcc\x19\x25\xfa\xea\x9f\x1f\xfd\x6d\xc4\x91\x91\xeb\xd6\xdd\xf9\x80\x72\x46\x79\x10\x66\xc0\xc4\xab\x0f\xdc\xe0\x3f\xa4\x1c\xe4\xdb\xa9\x0b\x57\xe5\x2d\xe5\x8d\xac\x14\x7e\x6c\x71\x5b\xe1\x50\xe6\xe0\xf5\x72\x68\xcc\x8a\x6d\x8b\xf1\x96\xd0\xc5\xf7\x8e\x4f\xf9\xa7\xb8\xe3\x28\x16\xe5\xc9\x71\x06\x8c\x6d\x71\xf1\x96\x98\x89\x01\x8b\x1d\x1b\x78\x03\xd1\x4e\xec\x46\xa2\xc3\x6b\x77\xd9\xa3\x43\x9e\x59\xbd\x52\x9d\xd0\x31\x77\x47\x61\x47\x08\x06\x9c\x37\x5a\xd9\x58\x07\xc7\x6e\x06\xd7\xab\x05\xbb\xe7\x5f\x2e\xe7\xe7\xa4\xf5\x1d\x5e\x93\xe5\xe6\xd6\x11\x8a\xf1\x86\x56\xc3\x57\xab\xae\x8a\x79\x7d\x89\xbb\xfa\x72\x55\xd7\xa7\xbe\xf8\x3a\x08\xce\x92\xd0\x40\x39\x85\xe8\xf9\xc9\xee\x14\x57\x42\x5d\xc0\xc5\x63\x8b\xc5\x20\x98\x0c\x44\xe0\x1a\x78\x9b\xd9\x0c\x7c\xd8\xab\x5e\xc4\x2f\xa2\xce\x2e\x85\xe0\x93\xc0\x17\xa6\x71\xbf\x04\x9d\xea\x24\xcc\x2e\x51\xee\x51\xf6\x97\x28\x23\xa8\x0f\x3c\xa8\x80\x05\x79\x30\x13\x75\xe4\x2c\x9e\x36\x75\xe2\xb0\xf4\x94\x82\xfc\xe1\xc9\xa9\xdc\xed\xed\x0d\x82\x95\x8e\xd3\xf6\x6a\xee\xae\xf6\xd9\x5c\xd1\xfa\x7a\xef\xb7\x7b\xdd\x23\xa6\x93\x3a\x5a\x3a\x3e\x15\xaf\x21\x38\xf2\x6a\x75\x8c\x49\x4a\x76\xc6\x4f\x0c\x38\xed\xe1\x3a\x92\x31\x6a\x67\x75\x8c\xed\xa1\x8e\x51\x8c\x99\xc3\x75\xf4\x82\xdf\x0b\x3a\xff\x11\x06\x3e\x6b\xfc\x3f\x3f\x1a\xad\x3c\xb9\x04\x9e\xb9\xfd\xc2\xc5\x29\x7f\xdb\x3b\xfe\x82\x8a\xba\xcb\x02\xa9\x6e\x7c\x45\xe8\x26\x0d\x7d\xdb\xf0\xbc\xd0\xad\xf0\xee\xb7\x14\x83\xe3\xa7\x51\x19\xd5\xd1\xf1\x29\x77\x9a\x7b\x92\xe8\x96\x3e\xa2\x25\x17\x26\xd9\x13\x1d\x89\x29\x56\x01\xc5\xc7\xc7\x39\x9c\x84\xa5\xc4\x1a\x62\x33\xb3\x92\xec\x02\x22\x1c\x03\x63\x93\x23\x3e\x36\xd6\x19\xe3\xac\x0e\xc4\xd8\x4d\xe9\x13\x02\x26\x47\xd8\x4c\x03\xd2\x9c\x9b\x69\x1e\x87\xf5\xfe\x87\xa9\xb9\x6b\x55\x8d\xa1\xc7\x25\x44\x43\x4e\xc4\x29\x3e\x99\x6a\xc5\x68\x64\xe0\xc3\x9c\x3b\xae\x94\xf9\x3e\x11\xcf\x8e\xba\x32\x7d\xd1\xf8\xc2\x55\x13\x27\x4c\x0c\xee\x07\xf1\x66\x98\x39\x5d\xb9\x7e\xf4\xaf\x70\xc6\xe4\xa4\xb4\xe4\x24\xf8\x6b\xdf\xb2\x4a\x7f\xfe\xfa\xc0\xe4\x2b\xa7\x8e\x6c\x5a\xae\xdc\x84\x77\x90\xb6\x79\xda\xaf\x86\x41\xd0\x3a\xf0\xf2\xb1\xc3\x52\x0b\xfa\xa2\xc8\x5a\xd3\x13\x4c\xc7\x1c\x23\xf7\xb6\x02\x88\xa2\xc3\xed\xb1\x12\xed\xd2\x6e\xad\xb0\x56\x5b\x39\x33\x67\xb5\x92\x81\x64\x90\x0c\x64\x36\xd0\x5d\xb5\x54\x1d\xe0\x76\xb2\x5d\xee\xd4\xa9\x94\x2a\x3f\xd7\x9c\x04\x1f\x3a\x12\xfa\x87\xca\xc5\x1f\x4d\x95\xe5\x54\xbc\x2d\xf4\xaa\x8e\x75\x7f\xa9\x7a\x05\xd6\xfc\xab\x71\xcd\x84\xcf\xc4\xa0\x89\x72\xbe\x0d\x63\x83\xc1\xe9\x26\xc2\x7a\x42\xc0\x6e\xab\xb6\xd5\xda\x76\xd9\x0e\xd8\x1e\xb4\x89\x46\xce\x66\x13\x4c\x56\xa3\xc9\x58\x1d\x30\x91\xa1\x24\x90\xa1\x24\x78\x7e\xb0\x66\xe9\xdd\xab\xc6\x8d\x0e\x29\xcb\x95\x45\x1b\x37\xc2\xcd\xcb\x31\x47\x10\x05\xc7\x95\x5d\x61\x6f\xb0\x79\x09\xca\x3d\xb7\x29\x8b\x28\xef\xa9\xee\xf8\x9c\x1f\xcf\xbd\x84\xe2\x88\x74\x1f\x24\xa7\xd8\x52\x9c\x26\xa7\x21\x1e\x19\xc8\x8c\xd5\xec\xf5\x78\x27\x04\x3c\x0e\x93\x23\x85\xc8\x4a\x32\xa6\x63\x75\xb7\x45\x75\xce\x5f\xca\xb5\x7d\x57\x94\x0b\x69\x6c\x7d\x8a\xf9\xde\x8f\x8d\x73\x46\xbd\x5c\x50\x67\x1f\xfc\x78\xe5\x3f\xff\xe6\x15\xa5\xfd\x77\x2f\x40\xdd\xe4\xeb\x76\xaf\x5b\x76\xc7\x91\x47\xa7\x4d\x58\xb2\x2b\x08\x9f\x7e\xa5\x7c\xf3\xc5\x57\x17\xbe\xcc\xb8\x2c\xf3\xe9\xe7\x9f\x7d\x39\x0e\x37\xdc\x78\xdb\x97\xdf\xbe\x7c\xe6\x5c\xe8\x4e\xcf\xab\xaa\xce\x3d\x19\xdd\x8d\xa7\x71\xd3\xd8\x19\x8d\x02\xd9\x43\xe4\x20\x20\x90\x8c\x18\x78\x03\x90\xff\x9c\x28\x50\xfb\x42\xfe\x7c\xbf\x36\x63\x73\xea\xed\x7e\x50\x83\x4a\x4e\xf2\xc1\xd3\x42\x6d\x58\xa0\x1f\x7c\x56\x69\xbf\x06\x78\xa5\x9a\x7d\x91\xf1\x30\x80\x3f\x82\x5e\x32\xa4\x11\x20\x76\x94\x2e\xdb\x11\x51\xd7\xac\x56\xa7\x89\x6f\x0e\x98\x4c\x40\x37\x4a\xa8\xf9\x3e\x08\x73\x56\xa2\x6f\xfa\xb8\xa2\xe8\x52\x6a\x60\x31\x2c\x7e\x24\x4f\x96\xf3\xfa\xca\xb2\x21\x2d\xb4\x13\xee\x1d\x92\x4f\x1e\xfb\xe6\xc9\x74\xac\x4d\x15\x44\x58\x68\xf0\x32\xd8\xa9\xb2\x8d\x23\xb0\x0d\x0e\x0a\x1a\x21\x13\xa6\x46\x51\x35\xd0\x6c\xe9\x2f\x0e\x72\xca\x32\x22\xe3\x44\x84\xe4\x71\xca\x88\x71\x75\x7d\xe5\xa1\x7d\xfb\x56\xc8\x06\x3b\x8d\x7d\x4e\x01\xd3\xb2\x10\x56\x5e\x12\x6e\x81\x01\x86\x74\x06\xbb\x8f\xec\xe6\x4d\x26\x52\x22\x76\x58\x0d\xcd\x01\x2b\x96\x31\x77\x03\x99\x71\x68\xae\x6a\xc2\x85\x68\x26\x45\x4a\xf4\xbe\x48\x60\x00\xad\x34\xab\x3f\x81\x2d\x72\x8b\x23\xcd\x41\xa0\x7c\xc6\xd7\x82\x4b\x78\x8d\xda\xf9\x91\xad\xf4\x5c\x94\xc8\x09\xb2\x80\x6e\x0c\x08\x61\xd0\x0c\x72\x11\xb3\x60\xe0\x77\xa6\x2b\x9f\xc1\xbd\x1b\x43\xef\xf1\x6f\x7f\xad\xec\xa1\xb4\xbf\x8f\x37\x70\x4d\x86\x55\x48\x42\x29\xb2\x95\x4c\x7e\x38\x81\x33\x99\x41\x10\x8c\x2a\x5e\xc3\xa6\x09\x19\x21\x33\xab\x1a\x7e\xe0\x9a\x94\xbf\xed\x51\xfe\x06\x33\x9c\x30\x57\x34\x85\x42\x98\x8b\x83\xa9\xca\x61\x75\x2c\x45\xe1\x65\xc8\x36\xa3\x20\x10\x88\xc8\x64\x36\xf2\xbc\x01\x47\x00\x46\x96\x92\x28\x83\x57\xaf\xd3\x12\x98\x77\x38\x95\xdf\x42\xca\x1e\x48\x11\x66\x29\x87\x61\x6a\x1c\xe6\x42\x21\x95\xbe\xde\xe5\x1a\xe1\x14\xc1\x23\xbd\x37\x93\x2b\xc7\x20\xab\x55\xb4\x58\x1c\x4e\xbb\x5d\xb2\x72\x32\x27\xed\x67\xee\x60\xd4\xb6\x32\xef\xa2\xe5\x7a\x17\x7e\x1a\x12\x39\x42\x15\x70\x8a\x5a\x89\xa4\xd6\x22\xff\xfe\xce\x90\xd9\xdc\x85\xc2\xaa\xaa\x42\x7f\x65\x25\x67\x0f\x1d\xed\x56\x4e\x6f\xd9\x85\x88\x30\xb7\xdb\x1d\x4e\x8b\x85\xb3\x4b\xdc\xfe\x80\x64\x27\xf4\xa0\xcd\x8b\x2e\x59\x4a\x0c\x29\x25\x6c\x8f\xf2\xd0\xec\x21\xef\x88\x87\x34\x9b\x94\xca\xdb\xa4\x14\x52\x06\xfc\x1a\x4e\x09\xe3\xfe\xa7\x65\xf0\x7f\xd6\x97\x01\x44\x47\x58\x00\xfd\x09\x4d\x48\xa8\x97\xec\xc2\xd4\x56\x0e\x35\x83\x46\xad\x91\xdd\x18\x90\x0c\x74\x28\xbe\x16\xb9\xa8\x1b\xa6\x39\xed\x38\xa7\x33\x1d\xfa\x7f\xbe\xf1\xc1\x8d\x78\xaf\x50\xfd\xf7\xbf\xff\x1d\xe6\x22\x0a\x8f\x04\xfd\xc9\x23\x83\x47\xfa\x94\xee\xdf\x51\xdb\x1c\xc0\xdf\x18\x10\xe9\xe1\xa4\x53\x45\x5d\xe1\xf5\xa6\x93\x79\x76\x4c\x13\xfa\x87\x9a\x08\xc0\xcf\x61\x2e\x81\xa7\xd2\x88\x4b\xb9\x0c\xdf\xd6\xb1\x1e\x19\x51\xbc\x2c\x11\x68\x92\x89\x54\x90\x56\x4b\xdd\xf3\x51\xad\xba\xc6\xf8\x63\x3c\xbe\x2c\xc1\xf5\xce\xd9\xf3\xfd\x95\xaf\xc9\xff\xcb\xd2\xc1\xa9\x7c\x9e\x7e\xfc\x38\xeb\xab\xbb\xd0\xc3\xb0\x87\x7b\x8e\xed\x1f\xe6\xca\x1e\x0b\x42\x2e\x51\x8c\x4f\x60\xd4\xe0\x91\x3d\xf6\xfd\x84\x39\x52\x39\xa8\x0e\xae\x9e\x31\xe9\xd4\x0f\xb2\x3d\x23\xfd\x94\x36\x8a\x2a\x2b\x8b\x28\x66\xfd\x23\xa1\x8f\x4a\x1f\x23\xe1\xff\xc2\x66\x45\x49\xb9\x89\x70\x08\x9f\xe7\x0e\x31\x5e\x47\xc6\xb4\x40\x24\x18\xc6\x46\x89\x17\x6e\x08\xf0\xdd\xc6\xb4\xae\x58\xcd\x82\x1e\x3e\x1f\x1a\x8a\x9f\x21\x1f\x5b\x63\x23\xdc\xd6\xd8\xc8\xf0\x51\x03\xbb\xc1\xcb\xfc\x24\xb9\x8f\x03\xdd\x8b\xa1\x83\xa6\xe2\x54\x04\x17\x84\x74\x6b\x5e\x1c\x32\x5a\x18\xdc\xae\xce\xf9\x6a\xf0\xf1\x1f\x97\x3f\xb4\x8e\xe5\x2f\x52\xc6\x82\xab\xe3\x49\xa2\xcb\xfb\x64\xb3\x99\x4d\x3c\xb8\x9b\x67\x88\x36\x6a\x91\xdc\x6c\xab\xb2\x91\x0a\x47\x74\x66\xa2\xd3\xb8\xa9\xfd\xe6\x92\x62\x6d\xa7\x2d\x16\x5c\x0d\x1b\xd6\x64\xf4\xc9\x28\xcb\xf5\x0f\x7d\x6d\xda\xa2\xac\x8a\xcc\x92\xb8\x58\x4f\x7a\x46\x76\xdf\x71\x04\x76\x05\x29\x7f\xac\x70\x17\x91\x50\x28\x2b\x6a\x80\x57\x5d\xde\x29\x2b\x71\xa4\x47\xf4\xa1\x64\xa2\x72\x1f\xbe\x4b\xc9\xdb\xa1\x5c\x73\x83\x32\x6c\xc7\x5d\x77\xc1\x2d\xcb\x77\xfa\x07\x8c\x99\xd7\xb0\x18\xfb\x2a\x99\xf4\x73\xb5\x7f\x93\x9e\x97\x97\xce\x99\x0a\x73\x86\xc1\x43\x59\x2f\x2e\xc9\xdd\x7f\xdb\x32\xad\x8c\xd1\xc2\x9d\x28\x3d\x52\x86\x0a\x50\xbf\x0e\x56\xa6\x2d\x80\xfb\xb9\x43\xb4\x90\xed\x8b\x47\xca\xad\xad\x6a\x41\xc7\x0f\x48\x9e\x77\xd6\xb2\x22\xf8\x3f\x0e\x59\xbf\xe3\xf6\x29\xd1\x72\xc6\xbe\xf8\x3e\x38\xe8\x9a\x98\x1f\xb2\xe1\x77\xfc\x23\xae\x6c\x41\xa2\x6b\x62\xfc\xd7\x60\x52\xe8\x58\x3a\x26\x3c\x01\xa3\xc5\x8b\xc8\x4a\x68\xd5\x8c\x44\xd1\x4c\x34\x46\x8c\x4c\x94\x5a\x5f\x9c\x55\x04\xf9\xaf\x45\x48\xca\xaf\x6e\xd6\xc1\xe8\x07\x6e\xbf\xfd\x81\xbb\x26\x4f\x9d\x30\x4d\xbc\xf8\xab\x03\xbf\x09\xd6\x34\x35\x4e\x53\xd7\xdd\xfc\x50\xc0\x91\x32\x1c\x39\xfc\xe7\xd8\x82\xe3\x1c\x5a\x59\x82\x84\xb5\xf7\xa4\x9d\x22\x7f\xcc\x25\x0a\x2e\x16\xaf\xeb\xf8\x88\xbf\x86\x7f\x8a\xc4\xd5\xf7\x09\x1d\xff\xe0\xd6\xf2\x8f\x91\x38\xc7\xe2\x8d\x1d\xff\xd0\xf2\xf3\x2c\x9e\x4c\xf4\x98\x8d\xec\xbd\x99\xc6\x3b\xbe\xee\xb8\xc8\xd5\x88\xcd\x24\x6e\x61\xef\xc9\x38\xe6\x67\x93\x36\x8a\x82\x55\x83\xf7\x35\x37\x9e\xfd\x3e\x9e\xc5\x73\xc9\xbc\xa1\x8a\xbd\x4f\x64\x74\x33\x1d\x63\x3e\x87\x6f\x22\x94\xde\x4b\xb6\x90\x81\x4e\xc8\x4c\x32\x8a\x18\xf0\x09\x98\xff\x48\x00\xf8\x13\x50\x8b\xb4\xa5\x90\xa8\x94\x50\xf9\x39\x9f\xd3\xee\x87\xeb\x9f\x84\x1d\x18\x3f\x01\x47\x94\x29\x0c\xfe\x78\x84\x84\xdb\x84\xd7\x08\x8e\x13\x18\x8e\xbf\x23\x34\xdc\x63\x3a\xba\xd8\x43\x7a\x0e\xff\x35\xd7\xd0\x71\xdf\x25\x7f\x97\xa3\xfe\x8e\xf6\x1d\xcd\xc7\xf0\x97\xc0\xf0\x97\x4d\xf1\x47\xd2\x3f\xc7\x8d\x2a\x5e\x95\x7b\x3a\xa5\x7f\x11\x4e\xd7\xf0\x1d\x4e\xff\x1a\xaf\x0f\xfd\x8d\xa4\x7b\x09\x5e\xb7\x11\xbc\x66\x13\xbd\x06\x39\x29\x6d\xec\xe9\xb8\x0f\xc5\xc8\x66\xa8\xcd\x81\x82\x1c\x32\xf9\x87\x1c\xa4\xfa\xdd\x60\x70\x1c\x1d\x9f\xe1\x7a\x82\xd7\x6c\x01\xab\xf9\xd1\xef\xc3\xf9\x4b\xa0\xa0\x04\x50\x09\x94\xe8\xf3\x87\xfb\x35\x9b\xf6\x2b\x83\xbf\xb9\x63\x1e\x32\x3d\x46\x3d\x43\xf5\x23\x19\x4b\x74\x7d\x9d\x4d\xfb\x9a\xe6\xc1\xa3\x59\x1e\x5c\x7b\x19\x5c\xa6\xe6\xe9\xf8\x6b\xc7\xd7\xb0\x98\xe5\x11\xb4\x72\x0b\x35\x38\x3e\xf0\x45\xf2\x7c\x01\x0a\x2b\x4b\xec\x92\x27\x5a\x56\x0d\xa1\x93\x85\x2c\x8f\x51\x2b\x6b\xab\xd2\x46\xf3\xd4\x0d\x85\xa1\x61\x38\x38\x27\x3a\x5e\x9c\x22\xff\x75\xe1\x74\xe4\x95\x9d\x50\x97\x0d\x72\x36\x14\x64\x43\x7e\x36\xa4\x66\x43\x76\xd8\x2d\x09\x6b\xa7\xb2\x8c\xd1\x5b\xb6\x60\xd2\xc6\xd8\xde\x8e\x79\x3a\xba\xcd\xa6\x74\xcb\xda\xff\xa7\x30\xbe\x32\xa1\x20\x93\xde\x21\xc9\xd4\xe1\x2b\x42\xd7\xd9\x94\xae\x59\xfe\x23\x1d\x7f\x61\xf5\x8b\xe0\x02\x95\x77\xb4\xf2\x53\x18\x4c\x9b\xd6\x86\xdf\x85\x61\x56\x40\x41\x05\x61\x2a\x50\xd1\xa9\xcf\x08\x73\x8f\x63\x75\x73\x68\x78\xb9\x2b\x9c\x3f\x0f\x0a\xf2\x00\xe5\x41\x9e\x3e\x7f\x7d\xc7\x67\x7c\x1e\x6b\xbf\x53\x83\xdf\xd0\x71\x35\xcd\x8f\x49\xfe\xfc\x3c\x48\xed\x92\xbf\x46\x59\xad\xd1\x50\x8c\x46\x5b\x0b\x3b\xc6\x91\x74\x42\xc9\xdc\x8b\x0c\x8e\x5b\x4b\xdf\xde\xb1\x8e\xa4\x17\x92\xf4\x8b\xac\x3e\xb1\x5a\x1b\xab\x94\xeb\x90\xed\x38\xec\x9e\x00\xb5\x13\x60\x02\x73\xcf\x42\xfd\xbb\x28\xeb\xb9\xbf\xb2\xdf\xc7\x69\xf5\xf0\x77\xfc\x99\xd2\x45\xdd\x08\x18\xa1\xe1\x22\x3c\xce\xb3\xe9\x38\xd7\xe1\x9d\x8d\x1f\x56\xa7\x84\x4e\xe3\x26\xcc\x07\xb2\x29\x1f\x60\x30\xd7\xaa\x34\x52\x37\x08\x06\x45\x61\xc2\x62\xe1\x41\x95\xd6\xc8\x6f\xbf\x44\x67\x59\x3b\xd9\x58\x11\x1a\xd5\xb1\x42\xd2\xbf\x85\xa7\xa2\xbc\x89\xa5\x9b\xb5\xf4\x27\x58\x3a\x6b\x3f\x4b\x57\xdb\xff\x2d\xb6\x30\x7b\x29\x5f\xd3\xb1\x28\x36\x93\x3a\x56\xcb\xae\x3e\x43\x12\xc4\x14\x8c\xc5\x21\x23\x07\x08\x13\xaa\x87\xf5\x4a\xbf\xec\x04\xd4\x3f\x3a\xa4\x4f\x69\x9f\x13\xd0\xf4\x58\xa0\x34\x3d\x1d\x3d\x0d\xf3\x51\x00\xa5\x13\x8e\xe4\x80\xd9\xda\x52\x90\x3a\x21\x52\x4f\x62\x44\xed\x6b\xc7\x64\xd0\x23\x18\x74\x33\x91\xee\x9a\x6a\x1b\xa6\xd4\x2c\xb2\xc7\x4d\x9d\x39\xc5\x0e\x84\xa2\x14\x1c\x07\xa5\x3a\x4d\x3f\xd6\x5f\xc6\x26\xc6\xcc\x9c\xa9\x01\x62\xd5\x93\x75\x39\xd9\x39\xb0\x71\x66\x56\x5a\x7c\x5c\xef\xc4\xf8\x1c\x8b\x89\x73\xa4\xd6\x64\xe5\xe4\xe7\xf4\x1d\x54\xe9\xb0\x3b\xbd\x5e\xb0\x2e\xbe\x77\x60\x65\x69\xbc\x88\xdd\xc9\x33\x4b\x07\x7b\xb3\x52\xd2\x0a\x6e\x9c\x01\x65\x15\x89\x7d\x2c\x46\xec\x9a\x1f\xea\xcd\x9d\x78\x65\xe2\xd4\x31\x9e\x18\x8f\xe4\x2c\xc8\x48\x2a\xce\x96\xcc\x16\x9b\x39\x3e\x35\xc1\x3d\x78\x62\x7d\x79\x49\x4e\x42\x9f\xfe\xa9\xca\xb9\x83\xeb\x07\xfa\xfb\x4e\x36\x3b\x13\x3c\xdc\xf0\x01\x7d\x33\xb2\x72\x37\x9c\x51\xee\x19\x59\x9a\x31\xac\xc0\xe8\xbf\x8a\xcb\x42\xd0\xfe\x31\xff\x0c\x11\x1c\x45\x44\x3f\x8b\x93\x4d\x48\x10\x4c\x4c\xd1\xa3\xfe\x32\xc2\x66\x4d\x63\x7c\x19\xbc\xc1\x57\x9a\x99\xee\xe7\xf9\x4f\x94\xe3\xb3\xb7\xad\x81\x4d\x60\x8d\x17\x8e\xaf\xba\xfa\xf7\x47\x19\xbe\x43\xfc\x33\x5c\x7c\x18\x06\x61\x31\x66\x64\xbc\x31\x80\xf4\x30\x38\x7f\x1a\x1f\xe7\xcb\xce\xcc\x05\x2e\x1e\x2c\xb0\x79\xcd\xb6\xd9\xca\xf1\x4f\x48\xb9\x47\x7f\x7f\xf5\x2a\x0a\xa3\xbd\x9d\x3f\x49\x28\xea\x0c\x91\x95\xfd\xe4\x04\x64\x34\xda\x90\x75\x17\x35\x6b\x6d\x36\x73\xbb\x02\x76\x73\xaa\x39\xdf\xcc\x99\x8d\x44\x5d\x9c\x15\xd9\x5c\x51\x41\x3b\xd5\x83\x89\xaa\x85\xea\xb8\xba\x87\x2a\x67\x2c\x1b\xe2\xfa\x75\xda\x7b\x4f\xac\x3e\xc7\xb7\xc5\xf5\x8e\xeb\x57\xb4\x6b\xa3\xe6\x0b\x1d\xf1\x27\x39\x81\x94\x61\x43\x45\xb2\xd7\x40\x4f\x53\xdb\x68\x19\x9a\x39\x63\x89\x33\x98\x65\x5a\x9a\x59\x53\xc2\x4e\x91\xe9\x78\x79\xb4\x9c\x88\xed\x6b\xea\xad\x6b\xce\xc3\x23\xaf\xbd\xda\x7d\x53\xc2\xe2\x47\xd6\x8d\xbf\x7f\x9a\xb0\x3f\xbe\x4f\xf1\xf0\xc6\x65\x25\x19\x1e\x0a\x95\x9d\xc1\x17\x9e\x63\xe7\xd3\xad\xcc\x42\x4e\x32\xd1\x3f\xb2\x50\x6f\x94\x8f\x86\x6a\xe7\xb4\x17\xa2\x55\xe8\xbf\xf2\x16\x43\x6a\xaa\x4b\x4c\x49\x71\x99\xc1\xe3\x71\x2d\x9b\x17\xdf\x67\x51\xdd\xb8\xd1\x53\x67\xcd\xaa\x9c\x30\x7a\xda\xb0\x62\x3f\x17\x33\xa0\xa2\x22\x66\x90\x7f\xd8\xe8\xca\xba\x3e\xf3\x4c\xb9\x26\xe4\x72\xad\xc9\x48\xec\xd7\x2f\xd7\x9e\x93\x93\x6b\xcb\xce\xf6\x79\x73\x73\x57\x9b\x7d\xfd\x62\xfb\xce\x2a\x5b\xb1\xa2\xb2\xa0\x7e\xe6\x54\xf0\x5e\xd9\xd4\x34\x6a\xd0\x94\x29\x83\x47\xf5\xad\x2f\x9e\xea\x1d\x35\xca\x3b\xb5\xb8\xbe\xaf\x98\xd4\x2b\xcd\xdd\xaf\x5f\x4e\x6a\x4c\xae\x25\xd3\x6e\xe0\x12\x12\x1c\x46\x3e\x89\x9a\xcf\x50\xf7\x70\x5f\x2a\x8a\x3c\x46\xce\x71\x6b\x6b\xf9\xf9\xe1\xcd\x09\x75\x9a\xec\x38\x59\xa4\xaa\xeb\xfa\x1d\x1c\x16\x74\xdb\xda\x71\x95\x77\xc9\x12\x36\x80\x55\xe2\x2b\x49\x17\xa8\x79\x26\x9f\xd3\x4f\xe5\x3e\x9d\x60\x96\xd0\xdb\x5e\x74\x16\xa1\x4b\x17\xd2\xe9\x5c\x20\x8b\x60\xbc\x4c\x35\x60\xcf\x76\xfe\xdc\x22\x99\xe3\xd2\xdd\xb1\x34\xba\x7d\x96\x02\x9c\xb6\x57\x16\xa7\x7d\x83\x23\xbd\x27\x67\x9c\x46\xd4\x70\x01\x86\x87\x9e\x53\x9e\x86\xe1\xb8\xa2\xa1\xa1\xed\x6a\xfa\xc4\x6f\x52\x9e\xbe\xd0\xf0\xdd\xf0\x0b\x0d\xea\x33\x0c\x6f\xbd\xbb\xa1\x81\x4b\xa1\x4f\x34\x6f\xc3\x05\x01\xcd\xaa\xf5\x2c\xb2\xf4\x29\x28\xea\x3b\xfb\x8f\x0d\xca\xae\xfd\xbb\x1e\xba\x11\x52\xc6\x8d\x9f\xdb\x78\x47\xa0\x26\x2d\xed\xc1\xfc\x79\xf3\x8a\x07\x3f\xa7\xc8\xca\xf9\x9b\x7f\xfd\xeb\x5b\x6e\xfa\xf5\xb2\xc0\xcc\xba\xcb\xa7\xcf\x9c\x15\xe0\x37\x5d\x68\x68\x68\x68\xdf\x04\xc3\xe1\xdd\x86\xd6\x8a\x86\x0b\x7c\x22\xa9\x00\x79\x80\x77\x61\x78\xfb\xa6\x06\x52\xe2\x85\x8b\xb5\xab\x5d\x63\x46\x0c\xaf\x85\xbf\x4d\x0f\xbd\x7c\xf5\x86\x2f\xaf\x58\xcb\xe5\x9e\x1c\xd1\xe8\x34\x2f\x02\xdf\xb0\x72\x45\xf9\x70\xe4\x68\xe5\x1d\x18\xae\x4c\x3f\x75\xfe\xec\x2b\xaf\x9c\xbd\x6f\xdf\x6d\x87\x1f\x38\x70\x2b\xa3\xe7\x24\xc2\x6b\x47\x72\x47\x50\x0a\x1a\x2e\x67\x21\x53\x8a\x33\xce\x69\xb2\xf2\xa9\x69\x71\x1e\xaf\x67\x62\xc0\x1b\x9b\x62\x76\xda\x9d\x13\x02\xb2\x75\x82\x15\x5b\xad\x76\x3b\xe7\x21\xcc\x8d\xfa\x30\x54\xed\x42\x75\xf2\x1e\x40\x3a\x05\x8b\x06\x5f\xc9\x10\x5c\x16\xe3\x33\xf8\xca\xd2\x49\x4f\x44\x77\x9e\x4a\x9c\xb0\xc8\xef\x31\x1f\x2f\xce\x4d\x30\xf6\xb9\xae\xa0\xdc\xc3\xbb\x9f\x2a\xc8\x4e\x2e\x89\x9f\x52\xf0\x08\x37\x2d\x74\xfd\xd1\x3e\x79\xa5\x13\x97\x4f\x87\xb7\xb7\xfc\x79\x4a\x68\xd3\xd0\xa1\x8e\xa1\x6e\xdf\x79\xbc\x87\xf0\x86\x8f\xf8\x7a\xfc\x82\xb0\x8e\x8c\x83\xa1\x72\xb6\xc9\x6c\xb6\x93\x09\x84\x69\x0b\x07\x76\x2e\x95\xdb\xc5\x1d\xe0\x78\x89\xcc\x31\x65\x64\x98\x10\xa0\xb7\x2a\xf2\x11\x47\x8f\x47\x53\xdf\xbb\xda\x00\x9c\x45\x69\xad\x48\xab\x21\x21\x03\x7f\x78\x18\x02\x4c\x39\xfe\xa8\x70\x8f\xd8\x34\x6b\x56\x93\x78\x8f\xf0\x28\x5f\x7f\xed\x4d\xf3\x17\x2e\x9c\x7f\xf3\x35\xea\xbc\x85\xdb\x03\x0d\x44\xd7\x73\xa1\x2c\x39\xc6\x48\x74\x23\xab\xd5\x1d\xc3\xf1\x77\x04\x1c\xdc\xa1\x19\x46\x07\x47\x8d\x76\xe5\x86\xcd\xbc\xaa\x73\x3b\x43\x09\x73\xd2\x17\x9e\xba\x34\xec\xba\x7b\xf8\x84\xec\x64\x5f\x72\x59\x6e\xd1\x30\xfe\x81\xc5\xdb\xb3\x2a\xec\x7d\x0a\x72\x9c\x09\x49\x39\xa9\xd9\xbd\xc7\xd3\x32\xf8\x3a\x70\x09\xa7\xc9\x88\xcf\x94\x5d\x66\x91\x14\xe2\x72\xf2\x9c\xdd\x96\x6a\xcb\xb7\x71\x84\x83\x91\x76\x9c\x2c\x0a\x6f\xc1\xd3\x3b\x21\xd4\xa1\x8d\xc7\xad\xb9\xa4\xcf\x2e\x8a\xce\x8d\xf8\x7f\x74\x99\x1c\xa9\xfe\xd7\xf8\x5a\xec\x10\x76\x3b\x44\x7a\xe7\xfa\x47\xc4\x6f\x27\xf1\x12\x16\x5f\xf5\xc3\x71\x32\x3f\x89\x13\x5e\xe9\xf8\x83\x21\x97\xe0\x28\x5b\x76\xd8\x6d\x44\xd9\x31\x99\x44\x31\x46\xe0\x38\xa3\xd5\x4e\x67\xfa\x45\x8e\x97\xa2\xb6\xcc\x28\x1b\x57\x5d\xdc\xd0\xc3\x87\xf4\x04\x25\xa1\x16\xb8\xe0\xef\x53\x55\x99\x3a\x7d\xe1\xbf\x26\xce\x58\x3a\xb2\x40\xdc\x9a\x9a\x11\x3f\x37\xe5\xe6\x81\x53\xcd\x45\x6b\xb8\x14\x04\x21\xa7\xf0\x8a\xf2\xfc\x4f\x29\x03\xba\x97\xa1\x78\xbf\xb7\x10\x26\x3f\xa6\x91\x72\xa4\x5f\x58\x4e\xa8\xfe\x07\xca\xa1\xe7\x1f\xf8\xd9\xf8\x36\xa1\xc1\x21\xd2\x93\x0f\x3d\xc4\x4b\x08\x8e\xaf\x12\x56\x93\xf8\x6d\xda\xfb\x5a\xf2\xbe\x99\xc4\x83\x4c\x56\xda\x95\x57\x3a\x5e\xe8\x58\x49\xd7\xf5\x1e\xe3\x10\x8f\xe8\xca\x16\xa5\x70\x6a\x20\xce\xef\xf9\xf2\x31\xe5\x95\x23\x47\x7e\x4c\x5f\xfe\x00\x2d\x84\xfb\xd6\x25\xe2\x57\x7b\x8a\xff\x60\x3b\x7e\x61\xbc\xbd\x43\x79\x25\xf4\x68\xc7\x4a\x87\x41\xb2\x84\xbe\x40\x0c\x77\xed\x3b\x48\x5a\x85\x96\xb6\x41\x4d\x6b\xfb\x44\x79\xa5\xfd\x80\x9a\xd6\xfe\x9e\x96\xef\x34\xc9\x77\x8d\x96\xef\x59\x2d\xdf\xef\x48\xbe\xe9\x5a\xbe\x5b\x51\x8f\x7d\x11\x5a\xac\xbc\xa2\xa4\xab\x79\x94\xd9\x6a\x1e\xe5\x5a\x82\xef\xfe\x6a\x1a\xc1\xba\x9a\xf6\x47\x92\xb6\x89\xa4\x89\x92\xe5\x49\x5a\xde\x77\xa4\xbc\xfb\xb5\xf2\xfe\x4f\xcd\x13\x5a\x47\x60\xf5\xd3\x60\x2d\xd2\xd2\x1a\x49\x5a\xa2\x96\x76\xb9\x56\xd7\x3b\xc9\x6f\x27\x69\xbf\xdd\xa5\xe5\xf3\x91\xb4\x73\x5a\x3e\xb7\x96\x6f\x00\xa9\xff\x67\x5a\xbe\xdc\x9e\xeb\xff\xd3\xe2\x84\xff\x10\x38\xd8\x45\xf8\xbf\x44\x68\x3e\x86\xea\x6e\x66\xa3\x58\x1d\x30\xda\x91\xc0\x09\xd5\x01\x4e\x7f\x3c\x48\x5d\xdd\xc9\x8a\xee\xf1\x2e\xa3\xa7\x7d\xb6\x41\x6e\x65\x78\xef\x00\x71\xca\x4b\xc2\xed\x91\x35\x67\x2f\x72\x1d\xb3\x26\x24\x20\x1c\x63\x60\xa3\xa7\x3c\x9f\x8e\x19\xba\x0f\x71\x89\x5b\x01\xca\x4b\x78\xc5\xf0\xa2\xac\xac\xe2\xe2\xac\xac\x22\xe5\x05\xf2\x54\x52\x42\x9e\xc4\xc7\x16\x2f\xfe\x3d\x7b\xa4\x2f\xd4\x6f\x6a\xfb\x51\xe2\x87\xa2\x6f\x85\x2f\x88\x8e\xe4\x24\xda\x91\xfb\xb8\x47\x22\xcd\xe0\xbc\x6c\xa8\xd2\x95\x7e\x66\x31\xb1\xcc\xef\xb1\x43\xd4\x29\x40\x76\x96\xee\x39\x77\xde\xe1\xcf\x3f\x0d\x97\x07\x83\xc3\xe5\x09\xb6\xb8\x57\x13\xff\x70\x95\xae\x34\xfa\x4d\x11\xce\x29\x1f\xf2\x43\x21\x89\x94\x69\x66\xbb\x22\xc9\xb2\x45\xf2\xa4\x24\x78\xc8\xff\xc4\x78\x3b\xa7\xb6\x52\xdb\x63\x20\xcc\xfa\x12\xcd\xe4\xe2\x48\xa5\x0c\xbe\x9c\x92\x6f\xbb\xb7\xf5\xce\x0f\x3f\xec\xff\xe4\x73\x4f\xf1\xfb\xbb\xb4\x17\x0a\xd6\xaf\x4f\x7f\xee\xb9\xf4\x9e\xda\x6d\xf7\x12\x54\x73\xa4\xf5\xd1\x76\xc7\xe4\x94\xf8\xe3\x3c\x71\x97\xa8\x80\xf9\xf3\xc3\xf3\x5e\xeb\x5e\xb6\x60\xfb\x43\xe2\xab\x71\x57\x75\xc3\x34\xea\xb2\x97\x90\x20\x5b\x30\xba\x21\x80\x0d\xb2\xc1\xda\x1c\x30\x44\xd6\x1b\xbb\x77\x2e\xed\xd0\x53\x91\x9d\x03\xd2\x8d\x8f\xa8\x8f\x32\x83\xf9\x9c\xb0\x1b\x86\x33\x98\x5e\x94\x2f\x7b\xe3\x25\x87\x2c\x39\xab\x1c\x0e\x0f\xe6\x3d\x3b\x03\xac\x08\xea\x76\x1d\xdb\x78\x32\x0d\x78\x2d\x37\xe2\x0b\xd6\x7f\x52\x2d\x89\xcb\xe8\x87\x55\xbd\x9d\x94\x95\x82\x35\x99\x4e\xcb\x3c\x91\x3f\xb1\x6a\x58\x7a\x6a\x2f\x8f\xc1\xef\x78\x98\x3e\xa7\xf5\xc9\x37\x15\x9b\x6b\x69\x15\x94\xf7\x52\xb3\x53\x5d\xa9\x59\x0f\x91\x2f\x5f\xd1\xcc\xc9\xaa\x5e\x7f\x90\x20\xf6\xb8\xb0\x95\x8d\x03\x87\x01\x80\xda\x97\x36\xd3\x1b\xa0\x46\x5e\xa0\x07\x7e\xfd\x27\xc3\x67\x6d\xb4\x15\xd5\x74\x9f\x93\x29\x99\x4e\x3f\x77\x3c\xa8\xdc\xa3\x9c\x82\x79\xd0\x27\xc8\xdd\x01\x33\x83\xca\x5b\xd0\xe7\x7f\x00\x73\xb7\xf2\x57\x06\x13\x9f\xc5\x99\x41\x65\x24\x3c\xf9\x3f\x80\x79\x9d\xf2\x09\x2c\x81\xb4\x20\x1c\xe0\xa6\x07\x43\xd3\xf1\xef\xf4\x30\x8d\x74\xcf\x04\x44\xaa\x84\x48\x26\x11\x0c\xf4\x06\xad\x06\x51\x0f\x4f\x07\x6e\xb3\xf2\x6f\x06\x8e\xff\x2e\xd8\x3e\x82\x7b\x8a\xc0\x1a\xa7\x87\x45\x6f\xe0\x12\x48\x1c\x07\x02\x36\x32\x58\x74\x3b\xd8\x1f\x71\xd7\x41\xea\x26\x41\x99\x04\x0c\xd6\x09\xa5\x71\x26\x0c\x81\xaa\x20\xff\xb2\xf2\x1a\x6c\x9b\xa3\xfc\x19\x8a\xd5\xbe\x99\x14\x69\x73\xa6\x6c\x0f\xb7\x99\x13\x45\x10\x24\x06\x54\x07\x53\x6b\x71\x3a\x94\x51\xfb\x16\x14\xec\x4d\xca\xae\x7a\x18\x05\xc5\x41\xee\x5e\x58\x32\x47\x39\x01\x93\x18\xcc\x70\x3d\x0d\x14\xa6\x00\x74\xe7\xca\x28\x61\x41\xa0\x7b\x86\x2a\xcc\x6e\x58\x2c\x53\x1b\x1d\x4a\xa9\xc5\xd7\x04\xf1\x68\xfc\xda\xec\xd0\x7e\xbc\x5c\x07\xab\x53\xfd\x58\x9f\x08\x3d\xc3\x2a\x21\xad\x86\x18\x67\xb8\xd9\x93\xe1\xd1\xf7\x82\x9f\xe2\xdf\xc2\xb6\x45\x4a\x93\x92\xcf\x2d\x20\x30\x2b\x23\x78\x4c\x93\xad\xba\x3e\xe1\xc3\x10\xf5\xf0\x74\xe0\xee\x55\x96\x4e\x87\x07\xfe\x1a\xe4\x7e\x03\xeb\x1a\x95\x85\xa1\xdb\xb9\x56\xd6\x5e\x02\x0f\x2f\xed\xa9\xbd\x22\xff\x7d\xed\xc5\x4b\x83\xca\xec\xe9\xa4\x53\x08\x61\x6f\x69\x50\xde\x86\x5e\x04\x56\x49\xcf\x7d\x6c\xc0\xc2\x0f\xf5\xf1\x63\xca\xa4\x45\xa4\x33\x48\x1f\xaf\x0d\xbd\x85\x3f\x1c\x1f\xba\x80\xd3\xd5\x3e\x2e\x89\xe0\xb0\x9f\xec\x0e\xe3\x50\xe4\x08\x16\x89\xfa\x15\x45\x64\xbe\x36\x1b\xec\x54\x53\x06\xdf\x19\x2d\x60\x0e\xf4\x23\xed\x57\x1e\xc6\x1f\x8e\x09\x3d\x0a\x79\x90\x46\xe0\x57\x5f\x8a\x86\xa2\xa0\x2f\x4d\x43\x87\x94\x35\x2b\xa0\x01\x8c\x41\xbc\x1f\xdf\x59\x15\xba\x0b\xcf\x66\x75\xce\xfb\xa9\xfd\x4e\x6b\x0a\x71\x2a\xcc\x3b\x95\xba\x55\x70\xd3\x7f\x83\x60\x83\xb9\xf8\x8f\x95\xa1\xca\xef\xb8\x47\x09\xcc\x2a\x0d\xa6\xc8\xfa\x9d\xa7\x77\xe4\x8d\xa4\xd3\x05\xae\xa7\x7e\x8f\x90\x64\xc2\x6a\xd2\x51\xc2\xe0\x11\x6d\xfb\xf8\xf9\x28\x5c\xb7\x9f\xdb\xdf\x23\xaf\x22\x1d\x84\x6b\xf0\xc5\x2a\xd6\x3d\x80\x32\x23\xfd\x1d\xe1\x39\x97\xee\x71\x67\xf7\x71\x3d\x78\x83\xda\xe7\x09\xed\xef\xf3\x81\xa2\xf6\xf7\x39\x5f\xf4\xdc\x43\x37\x5e\x46\xe1\x1a\x7f\x00\x6e\x09\x03\xfc\xbc\x52\xbc\x09\xa6\xd1\x91\x7d\x20\xb4\x8d\xef\x55\xd2\xfe\x4f\xdc\xf8\x48\x67\xb8\xbf\x88\x96\x1e\x55\x86\xaf\x87\xab\x20\x89\xe0\x42\x79\x98\xaf\x2a\x6a\xdf\x08\x2e\x4c\xf7\x83\x72\x7e\x09\x2d\xdd\xac\xcc\x5d\x0b\xd7\x80\x25\x08\x13\x39\xa5\xa8\x7d\x1a\x77\x88\xe1\x22\xbf\x47\x1e\xac\x1b\xf0\xf9\xdd\x46\x7c\x5c\x98\x81\x54\x6d\x86\xfb\xff\x1c\x84\x51\x3c\x57\xd6\xee\x7e\x8b\x7f\x5e\xc3\x81\xd6\xff\x84\x8e\xc2\xfd\xaf\xef\xfd\x4e\xfc\x28\xd2\xf7\x83\xd7\x93\x8e\xfa\x8a\x9f\xa9\xf5\x12\xb0\x75\x53\xb5\x5e\x91\xb6\x92\x7a\x61\x30\x30\x8a\x54\xcf\x54\x5c\xba\xe7\x4b\x37\xc2\x38\xca\x3c\xce\xb5\xf7\x16\x26\x16\xb4\xf7\xe6\xce\x51\x98\x71\x3d\xe1\x8f\xc0\x14\xa4\xef\x85\x59\xa2\x01\x2d\xd8\x04\x01\x18\x1a\xe4\x56\xb6\xef\x10\xaa\xf3\xdb\xe3\xb8\x2b\xb6\xa8\xf4\x54\xfa\xf3\xe0\x86\xd1\x58\xbd\x19\xc6\x43\xdf\x20\xde\x15\x5a\x26\x4c\xce\x6b\xbb\x88\x17\xc3\xc3\x5d\xe0\xf6\x91\x5d\xfa\x71\x2e\x48\x94\x5a\x51\x3e\x5b\xdf\xea\x79\xb4\x67\x45\xa0\x6f\x82\x15\x60\x08\x42\x7f\xe5\x0f\x14\xfa\xfa\x56\x6e\x27\x52\xef\x23\x68\x72\x28\x91\xfa\x5a\xa2\xbd\x24\x32\xb9\xeb\xd7\xf1\xd0\xde\x40\x20\xf9\x29\x24\x25\x57\x19\xbf\x15\xf6\x7c\x12\x14\x26\xf7\x6b\xa3\x3b\x55\xe1\xbb\x00\x4b\x3b\xf3\x0c\x83\xf1\x7b\x79\x06\xed\xea\xa1\x5b\x61\x08\x05\xa3\xf6\x0a\xd2\xf1\x48\x03\xf5\x7f\x25\xd0\xaa\xf0\x3c\x30\x1f\x95\x3a\x02\xd4\xe8\x39\x07\xd2\x69\xbb\x5e\x53\x8e\xce\x21\xed\xfa\x9a\xff\x4e\x39\x31\x07\x96\xa8\x70\xc6\x76\xc1\x97\x40\xf1\x65\xc0\x98\x40\x33\x6a\xe0\xd8\xb1\xb0\xee\xf8\xca\x09\xf7\xc6\x71\xe5\xb9\x19\xb0\x9f\x92\xce\xaf\xa1\x44\x79\xb7\x11\xd6\x12\x9d\xa0\xf8\x7f\x03\x7b\xaf\xf2\xce\x54\x06\x1b\xf7\xc6\x5b\x95\x6f\x9a\x60\x6d\xe8\x39\x5c\xd1\x33\x6c\xb3\xe9\x87\x61\x97\x80\x10\x81\x7d\xad\xf2\xe9\x64\x06\xfb\x63\xee\x7e\x0a\xb9\xfd\x4d\x2e\x8f\xe1\x64\xb6\x7e\x7c\x8b\x3d\x72\xd0\x72\x9d\xcc\xd4\x81\xbc\x41\xf9\x6a\x22\x01\x59\x1a\xe4\xb7\xff\x83\xe0\xa1\x7d\x30\xf7\x82\x5a\x57\xad\xcf\x09\x3c\x81\xd1\xa4\xc1\x48\x00\x62\xb1\x47\x7e\xe1\xa4\xfe\x73\x69\xaf\x3f\x3f\x1b\x6e\x0f\xf2\xcf\x2b\xef\x2f\x80\xb5\x9d\x75\x3f\x42\x3b\xaa\x2c\xe7\x89\x94\xd0\xd4\xb5\xae\x92\xdc\x40\x55\x3f\x5a\xab\x0e\x65\x29\x4c\x81\x81\x41\xfe\xe4\x5f\x83\x10\xdb\x49\x2f\xed\x25\x3b\xc3\x63\xc4\x80\x79\x2a\x72\x24\xf5\xc6\x5c\x7e\x79\x37\x6e\xab\x53\x25\xf7\x13\xad\x99\x0a\x6e\xbc\x00\xd6\x91\x6a\xe2\x29\x5d\xf5\x72\xdd\x98\xe6\x0d\x9d\xa1\x5e\x0a\xe6\x9d\xca\x9b\xb0\x19\x1c\x41\x28\xc1\x0f\x04\x43\xff\xe6\x32\x3b\xc3\x64\x3c\x4d\xe5\xb5\x26\x89\x13\x69\x37\xf7\x0c\x93\x82\xd4\xf4\xab\xfb\x95\x93\x70\xe7\x97\x41\xee\x62\x30\x54\x11\x1e\x37\x13\x22\xf0\x22\x6d\xa7\xbd\x4b\x66\xd0\x51\x3c\xd2\x69\xd9\xa5\xf8\xe4\xe3\x4a\x53\x1d\xa4\xc0\x9c\x20\xbf\x26\x74\x16\x7e\x53\xaf\xbc\x8b\x6b\x3a\x8f\xa3\x02\xd9\x13\x95\x63\x84\x22\x05\x06\x5c\x8a\xdc\x44\xfc\x01\x49\x76\x42\x99\x57\x07\x03\xe9\x68\x7a\x48\x79\x1c\x6e\xaf\x53\x5e\x24\x02\xd9\x11\xd6\x0b\xbb\xcb\x60\x4e\x14\x44\x3d\xf8\x4b\x4b\xb3\x46\xe5\xe1\x7a\xe8\x03\xb3\x88\x66\x04\xab\x66\x2a\xc7\x88\x66\x14\xad\xb7\x81\xc2\x54\x65\x8f\x64\xa4\x8e\x5c\x79\x30\x84\x11\x7c\x49\xed\x3a\x79\x36\xde\x16\x84\x1c\xfc\xe1\xdc\xd0\x7a\x6e\x6f\x27\x7e\xd2\x59\x36\xea\xbb\xeb\x52\xda\x30\x69\xf8\x0c\x78\xe8\xed\x20\xbe\x0a\x6e\x9b\xab\x4c\x56\xe6\xf2\x33\x74\x63\xc7\xa0\x8d\x1d\x55\x36\x76\xaa\x5d\xcf\x9a\x51\xc3\x2c\xa8\x08\xe2\x06\xb8\x7d\x9e\xf2\x1c\x9e\xd1\x45\x6e\xff\xdc\xbe\x1f\xb5\x92\xc0\x9f\x12\xe4\x93\xdb\x3f\xe2\xe6\x54\x86\xf6\x71\x15\x14\x6e\xf9\x2f\xef\xfb\xb0\xbc\x9c\xb4\x0a\xfa\x33\x0d\x3e\xb4\x8c\x1b\x35\x2a\xf4\x1b\xbc\xeb\xa8\x4a\xb7\x15\xba\x32\x62\xf5\x65\x70\xa4\xb3\x30\x61\x26\x6a\x21\x6c\x27\xe7\x7b\xe9\xeb\x79\x65\xfc\x6a\x98\x45\x35\xa5\xab\x94\x7b\xb8\x69\x83\x43\x53\xa1\x3f\xae\xea\x52\xc6\xcf\xa2\xaf\xbb\x95\xc5\xab\xc9\x0c\xd3\x14\x84\x1a\x2e\x61\x70\xa8\x88\xbb\x5b\x07\xf3\x27\xd0\x43\x5c\x78\x7a\x30\x73\x35\xdc\x76\x81\x30\x04\x6e\xc0\xe0\xf6\xbf\xbc\xaa\xea\x4a\x15\x11\x7a\x88\xd0\x2b\xd3\x95\x7f\x90\x5e\x29\x4d\x5c\xbe\x1a\x8a\x82\x90\xc7\x0d\x1b\x1c\x3a\xcc\xe5\x76\xd2\x17\x3a\xe9\xcb\x94\x11\x1a\xd9\x69\x35\xbf\xbf\x07\x1a\xd3\x6b\x4d\xd5\x1b\xa1\x38\xac\x35\x49\x05\xed\xcb\xc2\x7c\xa6\xa4\xc7\xb9\x3f\x65\x85\x3f\x00\x37\x4c\x09\xe3\x37\xc2\xa0\xb0\xe6\x24\x15\xb6\xcf\x60\x9a\xd3\x25\xf4\x1b\x4a\x69\x5d\x21\x7f\x1f\x87\xd1\x6b\x4f\xe6\xbc\xf6\x5c\xa6\x3d\xfd\x22\xd8\x3d\xeb\x4e\xa6\xbc\xb6\x93\x9a\xee\x54\x1a\xe1\x33\x29\xb2\x45\xd5\x9d\x38\x8e\x37\xa8\xda\x53\x54\x02\x76\xd2\x9f\x0a\x28\xb0\xfd\x1f\x04\x29\x9c\x89\x9a\xfe\x54\xa2\x97\xa5\x11\xfd\x89\xd0\xbf\xd8\x23\x3d\x45\xba\x7e\xdc\x66\x32\xf9\x20\x80\xda\xd7\x71\x67\x50\x27\xbe\x47\xeb\x03\x97\x50\xa0\xba\x68\x50\x7f\x55\xee\x5b\x02\xab\xa9\x06\x15\x7a\x61\x0c\x5e\xd7\x99\xef\xf7\x95\x63\xc2\x3a\x0e\xd1\x37\xc5\x2e\x8a\x48\x4f\x1a\x67\x44\x6d\x78\x43\x79\x62\x49\x58\x83\x4a\x51\x2c\x04\x34\xd3\xa0\xfe\x67\xf0\x1f\x56\xde\x5d\x12\xd6\xa2\x26\x2b\x32\x81\xcf\xb4\xa8\xce\xf0\x55\x3a\x55\x75\xb4\x6e\x5a\x54\x97\x15\x91\x08\xe4\xfd\xca\x97\x4b\x34\x1d\x6a\xa5\x32\x9b\x00\x56\x95\xa8\x2e\x72\xe0\x87\x75\x28\x1d\xc8\x3b\x95\xcf\x96\xc0\xfd\x54\x87\x9a\xa4\x2c\xa4\x10\xa9\x12\xc5\xea\xda\xf4\x33\xf5\xa8\xcf\x97\xc0\x96\x20\xbf\x49\x19\x34\xae\x73\x9f\x89\xb4\xef\xa9\x1e\xd5\x33\x94\x08\x0c\x2a\xea\x16\x8d\xc7\x17\x83\xfc\xe9\xd0\x99\x26\x15\x46\x65\x17\x1d\x4a\x50\x79\x25\x4f\xfe\xeb\x98\x65\xd7\x3e\x61\x94\xa4\x36\xf3\xf7\xca\x93\xf5\xb0\x10\x36\x13\xf5\x44\xd9\x3b\x13\x6e\x22\x9a\x59\xe7\xfe\x50\xe7\xc3\x5a\x7f\x73\x86\xae\xa0\x5d\xe5\x45\x3f\x46\x27\xc7\x5b\x23\x3a\x39\x1e\xf9\x3d\xf0\x45\x43\x17\xf8\x3d\x4a\xaa\xee\x7a\x39\x24\x44\xf4\x72\xae\xba\x53\xbf\x13\x1e\x42\xf8\xbd\xc6\x4f\x55\x29\x6b\xec\x04\xbd\xd3\x38\xe5\x22\xa0\x17\x7c\x34\x9f\xcc\xe4\x97\x06\x09\x03\xf8\x70\x26\x3c\xdf\x7e\x0f\x9f\xd9\x49\x0f\x20\xf8\x56\xfb\x9e\xf1\x7d\x03\x25\x2a\x6d\xe8\xf7\xb0\x4e\x92\x43\xf8\x29\x25\x81\xe7\x66\x11\x55\x9a\x7b\x45\x79\x6e\x1e\xdc\xfe\x4d\x67\xbd\x52\xc7\xf7\x79\x6c\x14\x22\xb5\x24\x7f\x5d\xa0\x71\x61\x8d\xfa\x1f\xca\x34\xa8\x81\xf2\x20\x3f\x5d\x19\x1a\xa4\x0b\x4c\x7a\xdd\x57\x1d\xa7\xaa\xee\x2b\x90\x91\x2a\xe9\xf4\xdf\x9e\xe4\xbf\x21\xa2\x03\xff\x5b\x99\x0b\x8d\xd0\x3b\xc8\xed\x53\x82\x30\x00\x32\xd1\xa5\x74\x75\x7a\x37\xeb\xc7\xea\xea\x77\x28\x7f\x86\xb9\x84\xd9\x43\x26\xac\x0e\x2a\x2f\x72\xfb\x2e\xa9\x57\x4b\xa6\x1f\xd2\xab\x21\xbc\xc4\xf6\x0a\x6c\x07\x91\xe8\x91\x41\x85\xe7\xa7\xab\xe7\x8c\x23\xf0\x22\xeb\x38\x74\xc4\x63\xc1\xd8\xa5\xe7\x9d\x3d\xce\xbd\x05\x55\x9e\x3e\xab\xcc\xaf\x25\xcd\x5a\x16\xe4\x33\x43\x4e\xd8\x31\x5b\xe1\xe6\x10\xd8\x97\x47\x70\x50\xd4\x59\xf7\xc1\x82\xd4\x45\xc1\x72\xfe\xa0\x86\xb5\x74\x36\xb8\xa0\x29\xc8\x6d\x09\x3d\x0d\xd7\xcc\x56\xfe\x8b\xd7\x7d\x49\xeb\x1f\xf8\xdf\xe9\xef\xcb\x67\x10\x95\x60\x54\x10\x5f\x41\x98\xf8\xd5\x8d\xca\x59\x28\xc2\x2a\x8e\x2e\xff\x65\xfa\xd5\x5e\x65\x77\x3d\x8c\x81\x5c\xa2\x5f\xc1\x15\x33\x95\x67\x99\x7e\x55\x13\xe1\x65\x3a\x79\x48\xc5\x61\x57\xc9\xda\x65\x15\x32\xa7\x16\xaf\x0b\xe2\x67\x67\x87\xee\xe4\x5f\xa4\x75\x9b\xf9\x4b\xf4\xaa\x15\xb3\x20\x3f\x48\x1a\xbd\x63\x9e\xf2\x06\xb7\x83\xb5\xb5\xbf\x9e\xbe\xd4\xb9\xaa\x3a\xb8\x74\x8a\x84\xab\xbc\xe7\x95\xe7\x3f\x2a\x15\x4b\x20\x97\x4c\x54\xb8\x17\xda\x07\xe3\xf3\x63\x94\x04\x7e\x04\xbb\xe3\xd9\xd3\x18\x23\x3d\x24\x75\x51\x50\x7a\xa4\xb0\x28\x05\x4c\x58\x42\x66\x41\xb5\x41\x2e\xaf\xfd\x4d\x0a\xdc\xc2\x35\x7d\xac\x8e\x89\xb2\xff\x85\x6e\x45\xa0\x57\xc0\xe8\x20\xae\x20\x22\xf6\xfc\x98\xd0\xc7\x78\x0c\xee\x4d\xf1\xd1\x11\xea\x61\x1c\x0b\x84\xba\x24\x91\xde\x4b\x62\xa0\xcb\xf3\xf3\x2f\x09\xf9\x71\x0a\x79\x3a\x99\x74\x43\x40\xb9\x07\xbf\x37\x26\xf4\x04\x0c\xe5\xea\x3b\xe1\xfa\xa7\xe9\x56\x13\x97\xc0\x0d\x6d\x41\x5a\xc7\x06\x4d\xb7\xea\xdf\x93\x6e\xf5\x03\xb4\x84\x97\x6e\xa7\x90\x86\x32\x40\x17\x79\x26\x1b\x47\xfd\x04\xdd\xca\xa7\xe9\x56\x9f\x29\x9b\xd7\x12\x81\x72\x96\xff\xae\x7d\x56\x11\xa7\xd6\x67\xe4\xff\x42\xf7\xf9\x50\xb9\x7f\x3d\xdc\x01\xe3\x82\xdc\x1a\x70\xb5\xbf\x46\x60\x2b\x0f\x43\xf5\xff\x0e\xfe\xeb\xca\x0b\xeb\xe1\x2e\x2a\x69\xe7\xc2\x97\x21\x5c\xc8\xb5\x86\xfe\x81\x13\x74\xf0\xaf\xfd\xe9\xf0\xf5\x1a\xd6\x51\xe5\x3d\x15\xfe\x1d\xdc\xca\xd0\x88\x22\xae\xbd\xfd\x20\x37\x0b\x75\xaa\x3f\x9b\xcf\x86\x65\xad\x28\x74\x51\xb3\xba\xed\x3f\x45\x40\x1f\x51\x3e\x52\x41\x73\xa1\x50\x80\x20\x26\xbc\xe6\x3b\xf2\x67\xea\x59\x6f\x13\x68\xdb\xf9\xa4\xd0\x00\xd6\x81\x80\xb6\xea\x75\x40\xb5\xfd\x44\xc6\xf2\xba\x05\xab\x2e\x92\x90\x56\x8d\xd6\xec\x82\x72\x68\x35\xd4\xc3\xd8\x20\xff\xfc\xab\xa1\xda\xc1\xf8\x71\x28\xd1\xc3\xfb\x69\x3a\x97\x2f\xa2\x73\x7d\xac\x3c\xbc\x0a\x96\xc3\x20\xa2\x72\x85\xae\x1a\x8c\xdf\x66\x2a\x57\xa7\xf9\xfb\x2f\xd2\xb9\xde\x50\x1e\x58\x05\x0f\x50\x4a\x08\xc0\xce\xd0\xb2\x51\xdc\x28\x65\x0a\xbe\xec\x97\xc1\xd7\x53\xc2\x43\xca\x19\x15\xfe\x51\xfc\x59\xe8\x31\x02\x3e\x94\xc6\x6d\xa0\xf5\x1f\xd0\xa3\xce\x25\x0a\x5d\x24\x2f\x85\x7e\x09\x4a\x38\xa4\xbc\xbd\x92\xe8\xdc\x84\x12\xf6\x84\x4e\x56\x72\x55\xed\x37\xf3\x86\x08\x6e\xba\xeb\x5d\x02\xc6\x3f\x52\xef\xfa\xc3\x6a\x78\x30\xc8\x3d\x1e\x3a\x30\x98\x1b\x77\x80\xc2\x6b\x8e\xd4\x55\xe3\x0d\x3d\x53\x84\xaa\x6f\x85\xe9\xe1\x6d\xe5\xe6\x19\x44\xe8\x55\x05\xf9\x19\xca\x5c\x65\xef\x5c\x98\x8a\xaf\xd2\xc1\x62\x32\x8b\x33\x18\xb0\x28\x12\xce\x47\xad\x4b\x0b\x06\xa1\x27\x99\x25\xb1\x7a\x39\x7d\x5c\x7e\xe8\xe9\x19\xf8\xce\x60\x90\x7b\x2f\xb4\x6e\x2e\xbe\xf8\x51\xeb\x66\x7d\xdd\x7e\xb6\x4e\xff\x81\xf2\xfe\x0c\xa8\x82\x1a\xa2\x19\x29\x4f\xce\x85\x85\xda\xde\x63\xf3\x2f\xa0\x2f\x9d\x62\xfc\x54\x87\x8a\x04\x18\x06\x85\xca\xc5\xb9\xb0\x46\x79\x8d\xbb\xb6\x33\x4e\x3b\xe9\xdc\x6a\xf7\x8b\x1a\xef\xee\x5e\x73\x30\x44\xe7\x5c\x7f\x99\xcd\x40\xe3\xb1\xdf\x35\xc2\x9a\xd0\x9b\xfc\x46\x74\x29\x9d\xfb\xc7\xf4\xbd\x33\xaa\x73\xe3\x9b\x98\xce\x8d\x73\xbb\xea\x9c\x11\x9d\xbb\xc7\x15\xec\xae\x1a\xf7\xbb\xca\x58\x98\x04\x83\x83\xdc\xb9\x10\x99\x31\xdd\xdd\x75\xbd\xb9\x93\xce\x1d\xd6\x08\xbe\x47\xe7\xe6\x22\xca\xec\xe7\x4a\x1d\x8c\xa7\xeb\x2c\x99\x4a\x51\x10\x5f\x09\x25\xbf\x08\xae\x4e\x49\x7e\x4b\xd9\x0f\xa9\x64\x1a\x83\xf7\x28\x2f\x04\xe1\x7a\x9c\xd4\x83\xde\x6d\xa4\xda\x95\x41\x32\x01\xc6\x22\x6f\x14\x7b\xc0\x81\x06\x90\x30\xb1\x67\xb4\x13\x26\x44\xfb\x0b\x2a\x9f\xf0\x27\x28\xc9\x76\x9a\x6f\xe9\xe6\x31\x0c\xa5\x61\x8d\xa5\x3b\x9f\x8d\xea\xdb\x6c\xcd\x15\x01\x19\x08\x6f\xb4\xf7\x83\xb5\x8d\x9f\xf0\x37\x74\x9a\x23\xea\x75\x95\x1e\xb4\xac\xee\x50\x4b\xa2\x60\x2d\xb0\x21\xc8\x4d\x6d\xbf\x8f\x80\xfd\x96\x7b\xfb\xb9\x1e\xd6\x32\x7e\xa2\xfe\xa6\x5b\x26\x4e\x86\x45\x4c\xc3\x22\xb0\x95\x56\xbc\x19\xf7\xee\x71\x2f\xeb\x67\xe9\x6f\x04\x7a\x05\x5c\x46\xb4\x59\xa2\xbd\x13\xe8\xef\x42\x09\xf7\xeb\x4e\xfb\x6d\x3f\x46\xc7\x62\xfc\x40\x29\x54\xe6\xcf\x86\xd5\x60\x0e\xc2\xaa\x05\x4a\x0b\xff\x9d\xb6\x6f\xf7\x33\x74\xac\x20\x85\x34\x90\xc1\xf9\x40\x5d\x07\xed\xbc\x17\xc9\x74\x2c\x4e\xec\xba\x17\xa9\xd3\xaf\x3e\x51\x16\x6f\x85\x47\xa8\x7e\xd5\x66\xe8\x27\x4c\xee\xb2\x57\xaa\xe3\x77\xec\x4c\x44\x04\x54\x0f\x3b\xa5\x59\x51\xb1\xf1\x9d\xb2\x73\x13\x3c\x4c\xc5\xc6\xce\xd6\xb6\xf5\x79\xc2\x64\xe5\x0f\xd0\xbf\xeb\xfe\xee\x4f\x81\xad\x13\x49\xef\x29\x87\x37\x33\xd8\x78\x34\xfc\xab\xed\x8f\x04\x78\xe8\x2c\x56\xd7\x6c\xe3\x7e\x0e\x6c\xbd\x24\x7d\x41\xb9\x7b\x13\x9c\x21\xb0\xff\x8f\x73\xb4\x4b\xf9\x42\x75\xfb\xbb\x5c\x96\x5a\xef\xe4\x2e\xeb\xd5\x6c\x3c\x19\xe8\x02\x86\x36\x9a\xfc\x97\x92\xa1\x27\x94\x47\x37\xc2\x1f\xb5\xb5\xe0\x02\x61\x62\x74\xaf\x36\xba\xe7\xcb\x64\x9e\xaa\x4f\x61\x91\xeb\xd4\x5b\x5d\xf7\xfe\xb6\xc2\x33\x0c\x12\xeb\x2c\xfd\xde\x05\x81\x11\xd6\xa5\xb0\x91\xef\x09\x46\x44\x8f\xfa\xb3\x32\x79\x33\x9c\xa0\x72\xf3\xf9\xb7\xda\xdd\x65\x3c\x07\xa3\x50\x0f\x67\x22\x84\xf0\x99\x08\x29\x42\x84\x97\xd4\xa1\xbe\x56\xe6\xad\x85\xa3\x30\x99\xe8\x50\xed\xc9\x45\x7c\x79\x58\x87\xca\xea\x69\xaf\x97\xc9\x38\x3d\xd8\xee\x2b\x15\x9d\x34\xf5\x1b\xd6\xc3\xd3\x44\x53\xc7\xcb\x88\xa6\xbe\xb1\x88\xaf\x52\x1e\xc6\x35\x3f\x1f\xb6\xbe\xc7\xcf\x29\x77\x6c\x82\x73\xe0\x0f\xbe\x84\x17\xb6\x9f\x29\xe1\xe5\xd0\x56\x3a\x51\xed\x72\x5e\x46\xa7\x3b\x11\xc9\xc9\xe9\x20\x5f\xb2\xcf\x1f\xdf\x00\x2f\xd0\x3e\xf7\xb5\xbf\x5f\xc4\x07\xda\xdf\xe7\x13\x22\xf8\xe8\x74\xa6\x27\x2c\x3b\xc1\x10\x06\x7b\x49\x9d\xe9\xc4\x7a\x78\x81\xcc\x56\xda\x83\x45\xfc\xb3\xbb\x50\xa7\x73\x46\x3f\x8e\x7e\xe8\xfc\x7e\xf7\x6a\xfc\x8f\x20\x3f\xbf\x6d\xdf\x08\x7a\x01\xb6\xfb\xf9\xa7\xf0\x5e\x7c\x14\x81\xdd\xd6\xa5\x22\xcd\xfc\xaf\x72\xc5\x2a\x38\x08\xf5\x41\xee\xd1\xef\x42\x95\x95\xf8\x8f\x30\x17\x6c\x3d\x9c\xd3\xfa\x61\x3a\xd2\xe9\x4a\xff\x55\x6e\x5f\x01\x41\x98\x46\x74\xa5\xd0\xbc\x2a\xfc\xae\xa6\x2b\x95\xfc\x72\x3a\x7a\x43\x39\xb0\x88\xe8\xc9\x63\x83\x90\x06\x79\xa1\x47\xc7\xe0\x0f\x95\x87\xb9\xdf\x74\x3a\x0b\xa7\xef\xeb\x2e\x8b\x12\xdf\xd7\xd7\x2a\x58\x9c\x1e\xba\x30\x1e\x7f\x18\x7a\x8b\x5f\xdb\xf3\xf9\xad\x1f\xd5\xd7\x2a\x5b\x3f\x71\x15\x3c\xc9\x00\x56\xe1\x8b\x8c\xd6\x2b\x7f\xc2\x38\x8f\xe8\xc7\x7f\x55\x26\x4d\x87\xdd\x10\x08\x92\xc9\xe7\xed\xca\xff\xc7\xdc\x7b\xc7\x47\x71\x64\x6b\xa0\x55\x5d\x1d\x85\x50\x00\x91\x11\x88\x9c\x83\xba\x7b\x14\x00\x63\xa5\x6e\xc0\x44\x13\x2d\x0c\x86\x41\x1a\x05\x90\x34\x42\x81\x60\x8c\xc1\xd9\x5e\xe7\x9c\x73\x5c\xdb\xeb\x88\xc3\x3a\xed\xda\xc6\x69\xc1\x89\xe4\x1c\x49\x0e\xd8\x98\xe0\x6c\x6b\xde\xe9\x9a\x4f\x42\x60\xec\xbb\xf7\xbe\xf7\xc7\x83\x9f\x4e\xd5\x54\x57\xd7\x77\xea\x54\xf8\xce\x99\x99\xae\x59\x5c\xc6\x4f\x96\xfd\x3d\xf2\xbb\x8e\xff\xf3\x98\xcb\x16\x25\x87\x7f\xd8\x34\x79\x06\xbf\x2e\x98\xd9\x95\x4d\x23\x9a\x2a\x96\xf0\xb3\x94\x3b\xf7\x1c\xe5\xbb\x98\xff\x65\x5f\x83\x29\xb9\x7a\x81\xf2\xf9\xb9\x4a\xdd\xef\xd7\x9f\xa4\x6c\x54\x8e\x63\x7f\xfc\xae\xe8\xff\x6a\xfe\x6c\x6c\xfa\xe7\x22\xbe\x94\x57\x91\x3f\xd4\xb4\x2e\xcc\xeb\xa5\x53\xd8\xfa\x3b\xad\xff\xb7\x31\x7e\x61\x9e\xec\x35\xd1\xff\x96\x30\x3f\xab\x69\xa3\xfa\x0a\x3b\xea\x77\x32\xff\x37\x63\x3c\x97\xdf\x76\x2e\x1f\xd8\xf4\x6e\x29\x5f\x2b\x6e\x64\x47\x7c\x87\xf7\xd0\x67\x8e\xa6\xc6\x83\x2f\x4f\x3b\x7f\xf0\xac\x78\xb3\x17\x4c\x01\xc6\xa5\x3c\x89\x9f\x76\xae\x78\xe6\xb7\xa2\x73\xc9\xa1\xf8\x93\xef\x18\xcb\x77\x46\x5b\xb5\x76\x34\x2f\x35\xd4\xd2\x60\x4a\xf0\x21\x44\xff\xdf\xde\x3f\x57\x1d\xf4\xd6\x9f\x7f\xbf\xfa\xbf\x69\x33\x6e\xc4\xcf\x9b\x2e\xe6\xdd\x79\xfd\xb9\x4a\xd1\xef\xcf\x9c\xab\x1c\x50\xf4\xff\x0f\xda\x0c\xbc\x69\x87\xcf\x3b\x97\x0f\x6e\xda\x76\x2e\x9f\x47\x66\x64\xbc\x69\xac\x5a\xc5\x5f\xa0\xed\xad\x6d\xf0\x1d\x28\xd6\xa6\x4d\x92\x6a\x9a\x6d\x13\x82\x5f\x57\x72\x82\xe3\x41\x9c\xe6\x1f\xe1\x37\xfa\x0c\xe8\x83\x3f\x6a\xf0\x85\x99\x59\x99\x4f\x67\xca\xbf\x99\xe2\x4c\xad\xf3\xfd\x35\xf4\xef\xfe\x7e\x87\x3d\xbb\x36\x32\xaf\x63\x42\x9b\x36\xaa\x10\x49\x09\xc9\x6a\x4f\x55\xb1\x44\xb0\xe7\x5e\x50\xcc\x9e\xe4\x93\xe4\x89\x59\x29\xeb\x17\x9c\x34\xdf\x3e\x74\x90\xd0\x7f\xff\xa8\x9a\xfc\x7e\xfe\xcd\xf8\x7e\xbe\x25\xcf\x05\x31\xcd\xe0\xdc\x95\x84\xb5\xfa\x25\xba\x12\xcc\xfe\xb5\xc1\x4f\x76\xd8\x5d\x83\x13\x6a\xe6\xb7\x3e\xeb\x27\xd4\xab\xc3\x80\x0e\xd4\x07\x27\xf8\xda\xfc\x27\x05\x6f\xdc\xad\xdd\x5c\x5d\xfd\x72\xc2\x43\x1d\xff\xa2\x4d\xf3\x12\x53\x31\x4d\xae\xfd\x45\x9b\x3c\x78\xc0\x21\x14\xb4\xd9\xb4\xe5\xee\x37\x0a\x82\x46\xf9\xe9\x1d\x1f\x4a\x90\xba\x3e\xa3\x5d\xc2\x8b\xa8\xdd\x8e\xac\x3b\x2b\xca\xeb\xdb\xb9\x5b\xb7\xc4\x44\xc6\xd2\xbb\x89\xce\xc1\xd7\xfd\x3b\x27\x8b\xb4\x0b\x8b\xdb\x88\x3c\x2b\x65\xbc\x48\xa6\x80\xe6\xc2\x62\x96\x1c\x3c\x07\x1c\x3c\x64\xf0\xd1\x90\xf5\xd2\x52\x43\x52\x73\x5b\x23\xca\x1f\x1c\x69\x7e\x00\xa0\x8f\x7c\x2c\xc0\x80\x0a\xcf\x18\x95\x33\x86\xce\x9c\x54\x94\x3e\xd0\x35\x5d\xa3\x62\xe6\xd0\x19\x93\xbc\xf4\x19\xa9\xdc\x0e\xd4\xba\x72\xea\xc2\x2e\xe9\x5d\x06\xf4\x9e\xba\x80\x92\xe3\xf8\x05\x81\x86\xa2\x95\x7e\xbd\xd9\x70\x36\x33\x6f\x58\x7a\xa7\x4e\x7d\x06\x0d\x0a\x94\x1c\xd1\xbf\x6b\x46\xd7\x4b\x8a\x87\x66\x04\x9a\x66\x24\xe7\xfd\x4f\xaa\xca\xe7\x22\x0e\x9d\x4e\xd3\xae\x25\x06\x3b\xaa\xc6\x7f\xf6\x58\xcc\x9f\xf4\x41\x31\x8e\xf2\x0c\xc7\x11\x5d\x72\xfe\xf0\x34\x87\x12\x9b\xaa\x2d\xe2\xc5\xfa\x5b\xac\x0d\x4b\x65\x03\xf2\x52\x13\x93\x93\x99\xae\xb7\x4b\x4a\x4a\xb4\x2c\x71\x49\xb1\x95\x28\x1f\xba\x8e\x1f\x01\xd4\x32\x19\x45\xeb\xe7\x57\x42\xed\x9d\x0e\x5c\x71\xfa\xf5\x75\x9c\xbe\xfd\x9c\xb1\xeb\xb7\x36\xdd\xa4\xaf\x88\xbf\x70\x9a\x5e\xea\xc5\x53\xfa\x35\x1d\xa4\x71\xde\xa1\x9d\xc3\xbb\x1b\x89\x84\x93\xc6\x32\xf3\x3a\x12\x48\xdb\xe4\xe4\xb4\xb4\x0e\x49\x69\x69\x6d\xad\xb6\xed\x24\x58\x3b\x09\x86\xb3\xcb\x9a\x8d\x24\x07\xf5\xb0\xa7\x67\x9a\x9f\x98\x39\xa1\x19\xb4\x69\x7d\xfc\x41\x19\x7d\x1d\x70\x6b\x5b\x9e\x8f\x39\xe2\x19\xa4\x50\x5e\x97\x8e\x29\x29\x6a\x42\x42\x30\x79\xbb\xb7\x37\xda\x1a\x97\x14\x77\x69\x4b\x6b\x9d\x06\x2b\x78\x74\x85\x66\xd3\xd1\x06\x28\x98\xc4\x7f\xf1\x98\x52\xd3\x9a\xc0\xee\x81\xfd\xf9\xd8\x50\x3c\x17\xd2\x6e\xa0\x59\x3e\xe4\xc8\xc7\x86\x64\x6c\xa1\xf4\x97\xe7\x48\x16\xe4\xf5\x4a\x0e\x0e\x35\xd6\xdb\xb5\xa7\xad\xde\x9c\x56\x9c\x6c\x05\x47\x19\xb7\x99\x5a\xdc\x36\x39\x38\x6b\x6e\x6a\xb1\x7a\xf8\x81\xcc\x38\x01\xb7\x75\xf4\x7e\xf8\xe9\xc5\xa9\x34\x12\xf2\x39\xac\x75\xeb\xce\xe2\x43\x1e\xe3\xf7\x37\x5d\x17\x3c\x8d\xc5\xcb\x66\xf2\xb2\x2e\xc3\x9a\x66\xce\x0c\xce\x59\x88\xed\x51\x85\xfe\x64\xbb\xfe\xa2\x24\x38\xa7\x44\x39\x9f\x7d\x18\xfb\x3c\xc5\x30\x6e\x65\xef\xf0\x81\x7f\xbc\x6e\xdc\xc6\x3b\xf3\x81\x29\x46\xbc\xde\x51\xae\x3f\xc0\xd6\xfd\xd5\xf5\x96\xf6\x1f\x64\xbb\x0e\xb5\x6f\xf4\x6a\xb9\x7e\x1d\x5b\x17\x7b\x57\xe2\xaf\xe3\x97\xfe\xc5\xf5\xdb\xe8\xfe\xbf\xba\xfe\x00\xbb\xea\x2f\xaf\x3f\xc8\x9e\x0b\xae\xc7\xb6\xc5\xf6\x28\xc7\x49\xfd\x96\xd0\xf5\xfe\xca\xf9\x4f\x4b\xf4\xd8\xe3\x7c\xa0\x3c\xcf\x23\xb8\x3e\xfb\x0f\xd7\x6f\x8b\x7d\xd3\xea\xfa\x1f\xef\x7f\x20\xf6\xf0\x5f\x5e\x7f\x30\xf6\x26\xae\x7f\x47\xd7\x87\x4b\xfd\xe2\xd7\xaf\x03\xfe\xd3\xfc\xd2\x96\xeb\x0b\xff\x70\xfd\xb6\xd8\x8f\xb8\xfe\xf1\x51\xef\x7f\x20\x76\x63\xab\xfb\xff\x78\xfd\xc1\xd8\x4b\xf1\xeb\xac\x5b\x6c\x8f\xb8\x53\xea\xb7\x1c\xe3\x73\x2f\xc6\xff\x5e\x39\x3e\x7f\x76\xfd\x36\xf6\xe1\x5f\x5e\x0f\xec\xff\x57\xd7\x1f\x6c\xdd\xbe\xd4\x6f\x39\xc6\xe7\x5e\x8c\xff\x9d\x72\xfc\xfe\xec\x7a\xf3\xf8\xff\xd9\xf5\x07\xd8\x05\x7f\x79\xfd\xc1\xf8\xfc\x8a\x6d\x21\xfb\x8c\xd7\x9f\x6b\xb6\x0f\x5b\xfc\xf4\xbb\xa9\x86\xf5\x3c\x4f\x8a\xdd\xc8\x06\xe5\x75\x55\xc5\x27\x83\xf8\xc2\x41\xfc\xd8\x41\x3c\x79\x10\x1f\x94\x67\xa5\x8d\x1f\xa4\xf0\x11\x69\x3c\x8d\xa5\x2e\x0d\x85\x52\xe5\x8f\x86\x85\x70\xf6\xcb\xd1\xdb\x7a\x41\xb6\x35\xf8\x2f\xdb\x3a\xb2\x31\x2d\xf6\x33\xb5\xd5\x57\x7f\x96\x7c\x83\xf6\xf2\x77\x9b\xc6\xb0\xf3\xf2\x26\xb7\x4f\x49\x11\x6d\xda\x0c\xe9\xd7\x4f\x64\x66\x67\x77\x49\xcb\xc8\x38\x66\x6c\x42\x9c\x60\x82\x47\xdc\x8f\x2f\x1e\x3e\xca\x1d\x75\x79\xf1\x40\x37\x38\x24\x22\x83\x89\x04\xc1\x5c\xe6\x26\xf5\xe9\xd3\x6b\x6a\x71\x9f\xe4\xf4\x4e\xc7\x17\xa7\x77\xbc\x38\x85\xa7\x24\x05\xb7\x04\x27\x6b\xbd\x3e\xff\xd8\x96\xe3\xc4\x83\x33\xd1\x5b\x4e\x77\x8f\x3f\x1e\x3f\xa4\xe5\xe1\x72\xfc\x35\xff\xca\xc2\x61\xce\xc7\x08\x1e\x3c\x4e\xd8\xfe\xd0\xc3\xfc\xfd\x43\xc1\xe6\x93\xfd\x67\xbf\xee\x94\xb4\xea\x1a\x65\x74\xea\xf2\xe9\xd3\x97\xa7\x8e\xd6\xae\x2e\x7d\xf5\xde\xb1\x1d\x46\xf4\x1f\x5e\xd8\xa7\xc6\x99\x35\x83\xb6\xa9\x8d\x39\x83\x07\x8f\x1a\x35\x78\x70\x4e\xd3\x0d\x39\x83\x07\x8d\x19\x3b\x60\x70\x8e\x56\x54\x36\x63\xe0\xd0\xa1\x03\x67\x97\x6c\xbc\xbc\xeb\x55\x9d\x7e\x79\x39\x38\x00\xa0\x4b\x8f\xba\x72\xe5\xd6\x2e\xc3\xb6\x0e\x1e\x4d\x75\x82\x3b\x46\x8f\x19\x44\xe9\x51\x6d\x77\x56\xde\x71\xa9\x49\x49\x47\xda\x2e\x30\xd7\x0c\x32\xd7\x61\x36\x6c\xb1\x1d\x99\x8e\xf5\x49\x6a\x6d\xbb\x56\x86\xfb\x83\xdd\x5a\x2c\x76\xe4\xb9\xf8\x7f\x6a\xb7\x01\xc1\xe3\xa7\xc6\xff\xd5\x6e\x0f\x8e\xbd\xf7\xd5\x85\xff\xbd\xdd\x3a\x5d\xd5\xf5\xf2\xbf\xb6\x5b\xcb\x5a\x7d\xae\x79\xad\xb0\xc5\xc1\x5a\x91\xab\xa1\xa9\x65\x35\x8c\xe4\x0b\x47\xf2\x63\x47\xf2\xe4\x91\x7c\x64\x30\x83\x47\xd2\x0c\xee\xc6\xbb\x1d\x3e\x81\xff\xa2\xad\x17\xfe\xb7\x6d\x31\x0d\x6d\xc5\xc7\x73\x08\xcb\x66\x85\xec\xea\xbc\xd9\xdd\x3b\xc5\x57\x83\x3d\x74\xa8\xc8\x19\xdb\x7b\xd0\xa0\xb1\x9d\x44\x91\xd7\x3f\x25\x94\xcf\xa8\x97\x4a\xb2\x18\x9d\x3f\xa3\x78\xc4\xe8\xa3\x8f\xed\x68\x36\x9a\x75\x4d\xea\xda\x79\x6a\x71\xd7\xe4\xb4\x9e\xd3\x8a\xd3\xfe\xdb\xb1\x65\x72\x89\xc8\x33\xa4\xf1\x2b\x67\x2d\xe3\xfb\x67\x2b\x43\x60\x60\x53\x9b\x7f\x30\x69\x04\x0f\xce\xf3\x51\xfe\xec\x09\x60\xde\xf4\x87\x05\x92\xf9\xc8\xb3\x2b\x78\x8f\xca\xf0\x29\x4b\x9d\x42\x7e\xfd\xa5\x1f\x4d\xfa\x1f\xd7\xc8\xcf\x1f\x3e\x7c\x8f\xd2\xab\xcb\xb0\xdf\x6b\x4a\x1b\x1e\xdb\xf6\xc0\xbb\x03\x27\xf4\xda\xb7\xe9\xdb\xa6\x5f\xd4\x2b\x8f\x5c\x2e\x7f\x6e\xdf\xf8\x8a\xf9\xff\xb1\x7d\xb1\x82\xfe\xdf\xd9\x37\x58\x48\x5d\xff\x57\xf6\x0d\xd6\xd2\x7f\x6f\xdf\xe0\xcc\x2a\xf2\xf1\x72\x03\x0e\x0a\x3e\x31\x48\x35\xd8\x32\xa6\x12\xfb\xf6\xcb\xeb\xa4\x5c\xd2\x91\x4f\xeb\xc8\xf3\x3a\xf2\x8e\x6c\x2d\x39\x83\xca\x94\x4e\x5d\x53\x92\xfa\xf1\x21\xc1\x11\x6c\x21\x9c\xd0\x15\x9c\x45\x5f\xa4\x71\x6d\x1c\xeb\xcf\xa6\xe5\x0d\x4e\x35\x8c\xfe\x3d\x12\x3b\x27\x76\x1e\x30\xb0\x7b\xdf\x85\xc5\x3d\xbb\x77\xd7\x53\x53\xd3\xd2\xc4\xa2\xe2\x34\x35\xb9\xed\x82\xe2\x64\x61\x24\x26\x24\x2e\x28\x4e\x38\x74\x30\x31\x3b\x74\xd4\xb7\xd3\x72\x60\x3b\xce\x9d\x97\xc7\xd7\xb4\x3a\x9c\xbd\x53\x56\x5f\x79\xa2\x7e\xfc\x14\x29\x9a\xbf\x81\xb5\x43\x6a\xc1\xb2\x73\x66\x6f\x5b\x2a\x0f\x2d\xe6\x4b\x94\x46\xde\xb6\xfc\xf9\x07\xa7\xdf\x5d\xbe\x76\x6a\x41\x8f\xf6\xfe\xe0\x0b\xc5\xe3\xe7\x5f\x34\x26\xf7\xd7\x1f\x9a\xcf\x30\xbe\xa0\x60\xe6\x93\x6f\xfd\x36\xe1\xec\xd7\x1a\x7b\x1c\x3c\xbf\x53\xd7\xe7\xe2\xef\x69\x04\xbf\x7f\x71\x0d\xc5\xcf\x7d\xd8\xac\xbc\x21\xbd\xbb\x74\x21\xdf\x37\xb1\x87\xd6\x43\xeb\xdb\x4f\x63\x3d\x7b\xf5\x5c\x50\xdc\xa7\x53\xa7\xee\x9d\x95\x5e\xa2\x4b\x8f\xee\x3d\x82\x03\xcc\x13\xda\x2d\x2c\x6e\x9b\xd0\x3d\x38\x4b\xe5\xd0\xa1\xd1\xd2\x0f\x8f\x1f\x40\xdf\xdc\x95\xe6\x43\xf4\xe3\xe7\x18\x1f\xa6\x7a\xf0\xfb\x57\xad\x4e\x60\xe6\xea\x19\xeb\xf8\x6b\xf7\x2f\xbc\x7b\x1e\x54\xcf\xae\x2e\xf8\xed\xf5\x75\x4d\xd9\xd4\xaf\xab\x94\x47\x82\x1f\xba\x08\x75\xfd\xe5\x89\x8a\x9b\xe6\x4a\xc5\xf3\xa3\xe3\x56\xaa\xf7\xfd\x7a\x5d\x73\xbf\x7e\xeb\x29\xfb\x11\xdb\x83\xf1\x98\x9d\x37\x34\x18\x8f\xf4\xf8\x78\xc0\xf0\x09\xc9\xdd\xba\xf5\x59\x50\xdc\xa3\x5b\xfb\x23\x47\x86\xfd\x61\x2c\x9a\x7f\xc6\xe3\xbf\x1c\x95\x14\xd6\xab\xf7\x08\x1e\xef\x59\x56\xea\x51\x47\xa5\x69\x53\xd3\xcb\xb7\xfe\x4b\x2d\x4a\x73\x4e\x2f\xdc\xf3\x76\x7c\x60\x9a\x66\x04\x1d\x50\xf2\x31\x30\x4d\xe5\x4d\x9f\x36\xed\x72\x7e\x3b\x6b\xc8\x88\x5d\x5c\x89\xbf\x47\xb0\x87\x79\xbc\x9d\x38\x23\x7e\x76\xc1\x13\x89\xf2\xc4\xd2\x64\xeb\x69\x9e\xcf\x3a\x30\xc1\x0b\x83\x23\xd9\x71\x88\xaa\x7d\xf8\x41\xa5\xad\x0f\x40\xe2\xed\x2e\x3a\x6f\xed\xc5\x17\x9f\x75\xc6\xc5\xab\x8f\x9b\x36\xc9\xf7\x27\x4d\x99\xc4\x77\x6f\x78\x67\xeb\xeb\xaf\x6d\x7e\xe7\xa5\x27\x6e\xbd\xea\x85\xf5\xd7\xdd\xc6\x78\x2c\x95\xcd\x66\x7b\xc4\x69\x2c\x81\xf5\x7d\xc2\x60\x9a\xd6\xc6\xd0\xad\x27\x79\xde\xa3\x94\x15\x4f\xf2\x02\xc2\x4a\x25\xb4\xd7\xe3\x70\x99\x23\xb3\xe3\x66\x30\x68\xb5\xfb\x77\x35\xf5\xbb\xf3\xd6\x2f\xc7\x5f\x99\x94\x99\x99\xa4\x2c\x1d\x35\xe2\xec\xe0\x7d\x99\x26\x6a\x6f\x9f\x38\x8b\x75\x66\x23\xf2\xda\xb6\x55\x3a\x1b\xed\xdb\x77\x52\x94\x2e\x6d\xad\x94\xa0\x55\xa5\x53\x27\x7e\xa8\x55\xa7\x39\x6c\x95\xa7\x26\x67\x53\xc3\xc1\xa1\x3c\x2d\xbf\x08\x12\x1c\xfe\x90\xcc\x7b\xed\x6b\x6a\x5b\x53\x7a\xe2\x80\x33\x8f\x09\x75\xc8\xae\x99\x76\xf6\x85\x27\xae\xbc\x99\x9f\x31\x7b\x61\xe9\x89\x4b\x57\x1d\x7f\x71\xaf\x45\xf7\x77\x8b\x96\x86\xaf\xa9\xbc\x88\xb0\x0f\xb0\xf1\xdc\x10\x67\xb2\x81\x6c\x6c\x5e\xa7\x4e\x7d\xfb\x0e\x68\xd7\x43\xd5\x93\x18\xc5\xb3\x83\x06\xb4\x6b\xd7\xbe\xbd\xe8\xd1\xb5\x17\x69\xf1\x48\x1b\x9d\xba\x16\x98\xd1\xc1\x0c\x6e\x97\x8b\xe3\x62\xf0\xf3\x5e\xd2\xa6\x2d\x63\x2b\xb7\x31\xd2\x8d\xcb\x13\xce\x5b\x29\x67\x74\xe4\xc6\xbd\x17\x56\xd6\xe8\xd9\xdd\x3a\x8e\xef\xb7\x70\xda\xf8\xb9\xb3\x67\x17\xe5\x8e\x9e\x96\x97\x99\x96\x1d\x9d\x7c\xe6\xd5\x8b\x4e\xfc\x8c\x8f\x5c\x7c\x6a\xb7\xa7\x6a\xdb\xa6\x4d\x08\x4f\x99\xa8\xe9\xf9\xaa\xf0\xa6\x4c\x1e\x9b\x5e\x76\x7f\xb7\xf2\x85\x13\x17\x27\x75\x91\xe3\xfd\x26\x9b\xc5\xfb\x8b\x55\x34\x06\x49\x2c\x2f\xaf\x8b\xc9\x79\x92\xae\x28\x14\x09\xa7\xb4\x55\xd5\x64\xa6\xaa\xa6\x46\xa6\x4c\xd4\x9f\xe2\x79\x4c\x09\xac\x27\x4f\x6b\x8f\x9f\xc9\x85\x63\x6e\xda\xc1\xc5\x21\x33\x76\xe8\x13\x0a\x8e\x5f\xa6\x80\x53\xf4\xe1\xbd\x9e\x3f\xaf\xe9\x6a\x7e\xce\x92\xc8\xb7\x4a\xd3\xd7\xbc\xd3\xc1\x9b\x6f\x0e\x2b\xfd\x7f\xff\xb4\x9c\xef\x69\x5a\x15\xec\x03\x4d\x3f\x33\x9f\xfd\x22\x56\xb2\x1e\x6c\x74\x5e\x5a\xf7\x4e\x9d\xba\x5a\xa9\x42\x58\x56\x4f\xca\x92\x2b\xac\x77\xeb\x1c\x18\x2c\xc9\xd2\x5b\x0c\x26\x91\x5b\x80\xf1\x1e\x40\xf3\x39\xda\xad\x6d\xd6\xa7\xb7\xd1\x47\xfe\xaa\x52\x76\x56\xf7\x73\x2e\xbe\xe8\xb2\xb5\x73\x8d\xec\x6e\x1d\xc6\xa5\xcf\x99\x36\x73\xee\x31\xc3\x46\xf1\xc7\x9b\xae\xe8\x64\x2b\xc7\xae\xad\x59\x7d\x51\xd7\xa7\x6b\x93\xda\x9f\x50\x5a\x3a\x25\x89\x5f\x5c\xfb\x9e\x96\x40\x36\xd9\x4d\x6b\x40\xa1\x35\xd0\x99\xf5\x22\xcd\x3a\x90\x8f\xd8\x56\xef\x1e\x0c\x65\xef\x8c\xb4\xb4\x1e\x1d\x3b\x8a\xd4\xb6\x09\xc1\x8a\xe8\xd2\xb2\x22\xfe\xa0\x99\xdd\x32\x94\xfd\xe3\xe7\xf7\xb5\x1c\xb9\x2f\xa9\x27\x50\x92\x74\x4c\xe1\xca\xda\xd5\xe7\x5e\x35\xeb\xaa\x79\xc5\xb3\xdd\x0e\x99\xa1\x59\xe5\xda\x82\x45\x25\x4b\x9b\x7e\x2b\x18\xbd\x6c\xea\x04\x3e\x75\xf5\x85\x6f\x6f\x5c\xf3\x6c\xa4\xfb\x95\xb3\xba\xdd\x78\x9b\x5b\xd7\xb4\x7e\xc1\xfc\x7b\xbb\x35\x3d\x16\xd8\xee\x27\x36\x93\x77\x27\xdb\x99\x6c\x58\x5e\x1b\x4d\x3e\x04\xac\x72\x1e\xd8\xaa\x60\x9d\x6a\x9a\xc1\xf9\xa7\x79\xf8\x51\x80\x16\xa5\xa4\xb5\xe4\x2f\x4b\xd0\xe0\xbc\x95\xa3\xf4\x6d\xba\x3d\xcc\x67\x37\x5d\xaa\x5c\xbe\xab\xe0\xf7\x74\xe5\xb1\xe0\x7d\x91\xaf\xa8\xef\x1d\xa9\xef\xc1\xfb\x5a\xc3\xd8\xc4\xbc\x74\xc1\xd2\xd3\x13\x93\x3b\x75\x1a\x98\xda\x87\xa5\x92\x0d\x12\x13\x87\x8b\xe4\xe4\xae\x5d\x87\x0c\xb1\xfa\xa5\x05\x56\xc8\x60\x16\xac\x10\x18\x41\x32\x74\xcb\x3b\x34\xb4\x21\xc7\xdf\x5e\xcd\x95\xef\xd5\x18\x01\x21\x37\xff\x0a\x61\xf3\x1b\x45\xad\xf6\x0d\xe1\xb6\x64\x7f\x2b\xca\xf5\xa6\x9f\x77\xe9\x79\xe7\x1d\xef\x9d\x7a\xc6\xaa\xd5\x6b\x2a\xc7\x4d\x9b\x5c\x50\x30\x79\xca\x84\xce\xab\xc7\x8e\x1e\x3d\xf6\xd8\xb1\xca\x23\x05\xf3\x3a\x77\xae\x38\x7e\xc9\xaa\x95\xd5\xd3\x2a\x3b\x87\x4e\x2b\xad\xae\x6d\xa2\x01\x9e\x3c\xf7\xc4\x49\x93\xf8\xbb\x97\x8d\x9b\x38\x39\x2f\x3f\xbe\xa7\xb5\x1e\xcf\xdc\xbc\x34\x1a\xc4\xb6\x7a\x30\xa0\x87\x0d\x67\xa1\x1c\xce\xfc\x3f\x0e\x67\xcb\x68\xe2\x50\x98\x66\x56\x91\xbf\x10\x14\x74\x86\x07\x3a\x93\xf3\x9e\xd2\xb4\xbb\xd5\x68\xda\x2e\x46\x93\xab\x72\x34\x95\x95\x47\x8c\x26\x1f\x13\x8c\x26\x9f\x28\x39\x31\xb6\x5e\x57\x95\xdd\xfa\x4c\x26\x58\x87\x3c\x8b\x69\x5c\xe5\xca\x05\xc5\x9c\xb5\x1c\x0b\x18\xbc\x27\xad\xec\x0e\x9e\xb8\xd6\xd5\x69\xe4\x4b\x4c\x22\x9a\x5a\xa8\x8c\x68\xa7\xcb\x73\x00\x79\x6c\x9e\xba\x80\x3d\xa2\x9d\x49\x9e\xdb\xd0\xbc\x0e\x46\x02\x2d\xe7\xe0\xd0\xcb\xb4\x04\xc3\x48\x55\xf2\xcc\xf6\xe3\x15\x2b\x38\xb4\xdb\xce\x6d\x35\x47\xe5\x74\x88\xf7\x89\x36\x96\x01\xcd\x9b\x8c\x71\x87\x37\x7b\x6e\xf8\x41\xb3\xc0\xec\x3f\xb8\xf7\x80\x9e\xc7\x66\x6a\xd1\x0e\xf9\xb9\x4b\x92\x33\x4f\x32\xcc\x5e\xdd\xbb\xa6\x27\x07\x36\x0d\xce\xe5\x54\xdf\xd5\xc6\x93\xd7\x18\x3c\x15\x9a\x64\x70\x93\x08\x31\xf8\xe6\xb5\x6a\xf0\x76\x71\x96\x68\xd7\x72\x7e\xfe\xa0\xe0\xd3\x41\x4b\xe9\xa5\xbe\xfb\xeb\x72\xce\x3f\x7a\x8e\xef\xfd\xfd\xec\xa6\x5a\xd1\x7f\x9a\xfa\xd3\xaf\xa6\x3a\xef\xd7\xe7\xe3\xe3\xf4\x96\xba\x80\x7f\xa2\x6d\xa0\x36\x93\x68\x56\xa7\xa9\xbc\x8d\xae\x27\xb7\x35\x55\xfa\xcf\x83\x3e\x70\x3d\x51\xbe\x0f\xee\x6c\x1c\x82\xaf\x15\xb5\x10\x91\x7c\x1f\x57\x23\x66\x08\xd6\x99\xc1\x73\xee\x7e\xa3\xa0\x89\xef\xb8\x76\x7b\xce\x4f\x3f\x69\x1b\x3a\x3e\x94\xf0\x50\xaf\xdf\x7f\xef\x75\xfb\xed\x71\x9c\x5e\x84\x33\x12\x38\x23\xf2\x3a\x58\x49\x49\xb4\xcf\xa5\x18\x6d\x14\xfa\xaf\x05\x40\x5a\xb0\x8e\xfe\x08\x24\x0d\x26\xdf\x08\xe7\x03\x08\x2e\x00\x7b\xb3\xe0\x8d\xbb\x95\x91\x3f\xfd\x94\xb3\xfd\xda\x1d\x5a\x72\xc2\x43\x1d\x9b\xae\xb8\xfd\xf6\x00\xab\xb9\x3f\xf7\x69\x1b\xc9\x42\xdd\x59\x7e\x5e\x8f\xd4\x34\x2b\x8d\x75\x4a\x4a\xa2\x71\x49\x4f\x4b\xa5\x71\x69\x4f\xff\xbb\xb6\x09\x00\xdb\xb0\x16\x40\xfb\xd0\x17\xb2\x00\x8a\x7d\x8e\xb7\xf4\xae\x85\x9f\x68\xd0\xb0\xdb\x35\xbd\x15\xef\x2c\xbf\xf9\x98\x51\xde\x78\xef\x58\xcd\xd6\xd3\x43\x9d\xba\x0c\x1c\xa9\x2e\x88\xf7\x9c\xcf\x4b\x75\xfb\x0e\x71\x45\xcf\x22\xcd\x1c\x9c\xd2\x29\x29\xd0\xef\x63\x35\x9f\xf7\xd7\xbe\x23\xfd\x7a\xb2\xc2\xbc\xde\x5a\x8f\x1e\xac\x7d\xfb\x0c\x43\xb1\xba\x5e\x50\xdc\xde\x52\xe8\xbf\x9e\xde\xa1\x43\xd2\x05\xc5\x1d\xf2\xcc\x94\xf1\x1d\x98\x2e\x4f\x65\x97\xef\x86\xca\xef\x75\xa5\xac\x3f\x74\xa4\xfa\x61\x1a\xf6\x3b\xca\xa1\x3b\x7a\xd3\x8e\x67\x9e\x7f\x3a\x67\xc7\x0e\x3e\x77\xc8\x84\xfc\x31\x3d\xd2\xfb\xb4\x37\x46\xa4\xdc\x32\x64\x42\xc1\x98\xf4\xfe\x83\x13\x46\x24\xab\xf9\xc1\x7b\xb3\xab\x56\xed\x0b\x8e\xde\xe9\xd1\x3f\x38\x7a\xa7\x97\xfb\x60\xa0\xe7\x67\xea\x44\xde\x53\x8e\x57\x7b\x76\x4c\x5e\x0f\xae\xaa\x56\x4a\x6a\x6a\x82\x65\xa5\xa5\xa4\x58\xaa\xa5\xd2\xe4\x68\x47\x93\x23\x4f\x6f\x7b\x51\xb1\xde\x72\xd2\x90\xfc\x52\xfb\x88\x43\x46\x94\xef\x17\xcb\x79\xd2\xe9\xb0\xe8\xa1\x3b\xcd\x95\xc9\x67\x5e\xab\x1c\x97\xba\x74\xc6\x8c\xa5\xa9\xc7\x91\x6b\x1a\xcc\x98\xf5\x67\x46\xc7\x1c\x73\xcc\x98\xfa\xb5\xf1\x39\xd3\x5a\x87\x63\xf3\x7a\x06\x7b\xed\x21\x1d\x02\x53\x69\x81\x12\xda\xd1\x94\x48\xfd\x83\x16\x72\x0e\xb5\x3f\x4c\x8b\xc9\x34\x91\xba\x1f\xae\x85\x9c\x4e\x6b\x5b\xd4\x68\xd6\x61\x23\xc5\x67\x3d\x69\x67\xee\xdf\xa1\x73\xb7\xf6\xed\x3b\x27\x09\xf9\x89\x51\xaf\xce\x1d\x12\x12\x3a\x88\x4e\xf4\x3f\x3d\x25\x50\x25\x25\x08\xc5\x2e\x8a\xbf\x7d\x1d\xff\x84\x01\x13\x2b\x3e\x9d\x6d\x9a\x60\xcd\x27\x32\xa6\x1e\xa6\x49\xab\x2d\x21\xd8\x11\x68\x72\x1d\xa6\xd6\x81\x51\xf6\x31\x85\x2b\xd4\xe1\x5a\xa8\xc3\xa0\x8c\x91\xea\xc4\x66\xfd\x78\x6d\xea\xe0\xbe\xc7\x1b\x3d\x8b\x12\xda\xa5\xf6\x90\x7b\x04\xcd\xaf\x49\x72\x7e\x75\x64\x7d\xd9\xfc\xbc\x11\xdd\xba\x76\x4d\xe8\xd5\xbb\x77\x5a\x07\xd2\xb4\x5f\xaf\x5e\x5d\x59\xea\x05\xc1\x2f\x58\x74\xa5\xff\x9d\xd2\x12\x13\xb5\x0b\x8a\x13\xf3\xcc\xd4\xf1\x89\x9d\xf2\x3a\xf5\xb8\xb0\xb8\x53\x8b\xe2\x87\x26\x1c\x59\x52\x3a\xff\x23\xb0\x87\x39\xcd\x87\xec\xb5\x3f\xda\x84\xd3\x0e\xeb\xd6\xb2\xa3\xcf\xba\xa6\x2f\x57\x5f\xa0\x64\xa5\x2c\x9d\x39\xab\x36\x25\x4b\xbb\x50\xb3\x0f\x9b\x7d\xbb\x6a\x4a\x82\x8f\x6e\x2b\x2a\xe5\xfb\x7a\x4b\x5a\x9f\xe9\x9c\xd2\x5f\xdd\xf7\x74\xfc\xa4\xe2\xe0\x64\xe7\x3f\x5e\xd7\x83\xeb\xec\x68\x67\x4a\x7f\xc7\x4f\x13\x89\x47\x29\xff\x82\xdf\xa5\x7c\x1b\x9c\x1d\xdd\xb4\x26\x38\x57\xb8\x5d\x7f\xf3\xa0\x2c\xff\x52\x39\x23\x7e\xa6\xf4\x11\xe5\xdf\xb6\x94\xdf\x71\x58\xf9\x37\xcd\xe5\x47\x9c\xad\x7e\xd4\xb3\xc3\x99\xde\x34\xbe\x69\x0d\xbf\x38\xf6\x2d\x7e\xe7\x7c\x04\xc5\xec\xc7\xb2\x5e\x79\xa9\x63\x1c\xa2\x4b\x9e\x97\x7b\x4b\xae\x92\x7b\xcc\xb0\x64\x31\x20\x7e\x88\xeb\xfa\xf9\x4b\xed\xe0\x67\xae\xb5\x56\x87\xa4\x65\xb7\xca\x1b\x7f\x72\x90\x5a\x87\xd6\x75\x68\xd8\x9a\xc6\x0f\xef\xdd\x7b\xf8\xc8\x8c\x8c\x91\x5f\x0c\xcf\x90\x99\xe1\x8d\xc1\xab\x11\xbd\x68\x30\xdd\xe1\xbd\x33\x46\x8e\xa4\xe2\xe1\x19\xbd\x46\x50\x7e\xf8\x2b\xd1\x45\xf1\xca\xc1\x65\x79\xe3\x83\xf2\x87\xcb\x47\x8e\xfc\xae\xf7\xb0\x61\x54\x61\xf8\x83\xb8\x36\x9c\xd7\x34\x5d\x46\x1d\x54\x9b\x16\x34\xad\xe5\x27\x53\xbf\xe2\x9f\xf1\xf4\x0c\xfa\x24\x3f\xde\x61\x5d\x78\x5e\x97\x5b\xba\x28\x5d\xd2\xdb\x06\x87\xce\xc5\x7b\x24\x0f\x9e\xd3\xc8\x67\xfc\x4b\x9d\x17\xf0\xf1\x4d\x4f\x2a\xab\xfe\xa8\x5d\x68\xf1\xd8\xff\x51\x0f\x83\xf6\x8e\x9e\x64\xe1\x7e\x79\xed\xc9\xc7\x16\x22\xa3\x13\x4b\xe7\x79\xe9\xb7\xa4\x2b\xe9\xbd\x52\xdb\x04\x9a\x6c\x84\x26\xf1\xdd\x34\x70\xd5\xfa\x74\xf8\x4b\x7d\xde\x88\xf2\xf1\x4b\xf8\x4d\x7f\xd4\xa7\x69\x4f\xe3\xe2\xc5\x8d\x8f\xfe\x89\x4e\x0a\x9b\x1c\xdb\x23\x56\x68\x57\xb3\x21\xb4\x4d\xb0\xf6\xee\x58\x25\xf8\x61\x02\x23\xee\x8a\xf5\x50\x3a\xf5\x10\xc1\x49\xd3\xc1\x67\x8e\xe4\xbe\x2a\xd9\xc3\x85\x48\x93\xcb\x2a\x38\xb7\x74\x00\x85\x24\x49\xe2\xd7\xe1\x33\xea\xbd\xa2\xda\x74\x37\x54\x76\xfc\xac\x5e\x63\x66\x85\xf2\xc2\x79\x19\xa1\xb2\xab\xc2\x0b\xae\x59\x9c\x33\xaa\xf4\xac\x49\x43\xc7\x39\xdd\x94\xf4\x31\xc5\x63\xaa\x97\x75\x1c\xee\x8f\x30\xf4\xc4\xcc\x79\xe3\x86\xa8\x77\x8c\x9a\x3b\xb6\xd7\xe8\x9e\xfd\x46\x4c\x2b\xea\x57\x58\x34\x61\x48\xa8\x22\x7a\xca\x84\x9a\x07\x4e\xce\x0b\x55\xde\x58\x51\x79\x73\xfd\xc4\xb4\x01\xc7\x4d\x3a\xfe\xf7\x94\x49\x27\xcf\x19\xf1\xe8\x93\x63\x2a\xe6\xcd\x18\xa8\x69\x09\xa9\x39\x8b\xae\x64\xf1\x77\x0f\x58\xda\x42\xc6\x45\x49\x62\x70\x60\xc0\x74\x1a\xdb\xbe\xb1\x8b\x49\x66\xc7\x3e\x20\x99\x2b\xe5\x28\x29\xc7\xc4\xd6\x31\x21\x46\x07\x57\x45\x91\x94\xe3\xa4\x9c\x22\xe5\xec\xa0\x8e\x98\x23\xeb\xcc\x27\x99\xc6\xd2\x48\xf6\x65\x82\xae\xf6\xa5\xd6\xd2\x49\xe6\x92\x97\xdd\x97\x5a\x9b\x47\x72\x4c\xac\x88\x64\x71\xac\x82\xe4\x5c\x99\x9f\x17\x48\x63\x07\xd5\x1c\xc4\x92\xa9\xce\x20\x96\x2a\x65\x5f\xaa\x33\x82\xda\x59\x47\x32\x9b\xea\x8c\x20\xad\x02\x39\x4a\x96\x8f\x89\x39\x24\xe7\x11\xca\x08\xba\xb7\x88\x39\xb2\xa6\x43\x2d\xa4\x93\x4c\x95\xb2\x2f\x95\x87\xe8\xde\xb3\x48\xe6\x52\x9b\x21\xba\xf7\x62\x92\x63\xa4\x9c\x17\x7b\x80\x65\xd3\x5d\x1f\x90\x4c\xa6\x36\xb3\x59\x0a\xd5\xcf\xa6\x7b\x83\x7c\x7a\xec\x3a\x92\x3d\xa8\x66\x36\xb5\x33\x8f\xa4\x2d\x6b\x16\xc5\x96\x92\xf4\xa5\x1c\x2f\xe5\xa4\xd8\x93\x24\xa7\xcb\xfc\x2c\x99\x9f\x2d\xf3\x27\xc8\xfc\x5c\x99\x9f\x47\x32\x57\x62\xe5\xb2\x64\xb2\x46\xae\xc4\xca\x65\xa9\x32\x9f\x4e\x88\xb9\x84\x15\xc8\xbe\xb2\xa4\x88\xf4\xcf\xa5\xf6\x03\x39\x89\xf4\xcf\x65\xd3\x65\xf9\x2c\x99\x3f\x41\xca\x79\x74\x75\x94\x6c\x73\x14\xe9\x5f\x44\x32\x85\xb4\x1d\x45\xfa\x07\xf9\x74\xb2\xc6\x28\x6a\x33\x90\x7d\x65\xcd\x22\xea\xc5\x28\x6a\x33\x90\x93\xa8\xef\xa3\x48\xe7\x20\x3f\x4b\xe6\x4f\x90\x72\x1e\xb5\x3c\x46\x5a\x72\x8c\xd4\x73\x0c\xb5\x99\x4e\x32\x55\xe6\xd3\xa9\xe5\x31\xd4\x66\x20\xfb\xca\xf2\x22\x1a\x85\x31\xd4\x66\x20\x27\x11\xfa\x18\x6a\x33\xc8\xcf\x90\x75\x66\xca\x3a\x27\x48\x59\x4c\xe5\x13\xd8\x04\xd2\x76\x82\xb1\x83\x2d\x65\xb3\x48\xe7\x07\x48\xa6\xc4\xde\x21\x99\x4a\xf7\xce\x62\xc7\xd1\xd5\x59\x74\x75\x12\x2b\xa6\xab\xab\x48\xa6\x92\x9c\x2b\xf3\x73\x65\x7e\x9e\xcc\xcf\x0b\xf2\x62\x74\x30\xc7\xc4\x68\x31\x31\x76\x3f\xc9\xe9\x52\xce\x8e\xf5\x24\x39\xa7\xe9\x35\x92\x27\xc8\x92\xf9\x32\x1f\x89\xd5\x93\x8c\xc6\x2a\x48\xae\xa4\x7c\x1e\xcd\xe4\x9b\x48\x8e\x8b\xbd\x4e\x72\x8a\xcc\xcf\x89\x5d\x47\x72\x3e\xc9\x7c\x51\xd4\xf4\x10\xc9\x71\x31\x46\x72\x62\xec\x38\x92\x53\x64\xc9\x74\x99\x3f\x21\xd6\x89\xe4\x89\x32\x7f\x52\xcc\x21\xb9\x90\x34\xc9\x17\x61\x29\x4b\x64\x49\x59\x6c\x36\xc9\x4a\x59\xb2\x44\xca\xaa\xd8\x49\x24\x6b\xa4\x5c\x2a\xeb\x34\xc6\xba\x91\x5c\x21\xf3\xa7\xc8\x3a\xa7\x52\xbe\x40\x6a\x52\x24\x7b\x57\x24\x7b\x57\x24\x7b\x57\x24\x7b\x57\x24\x7b\x57\x24\x7b\x57\x24\x7b\x57\x24\x7b\x57\x24\x7b\x57\x24\x7b\x57\x44\x2b\xa2\xa7\xf0\xc9\x56\x09\x24\x53\x03\x29\x0a\xd9\x24\x92\x45\x4d\x2f\x92\x1c\x17\x4b\x22\x39\x45\xe6\x97\xc4\x9e\x14\xe3\x24\xd6\x38\x42\xf9\x80\xe4\x6c\x6a\x61\x1c\xe9\x50\x40\x72\x3e\xc9\x89\xd2\x56\x13\xa5\xad\x26\x4a\x5b\x4d\x94\x1a\x4e\x94\xb6\x9a\x4c\x1a\xd6\x93\x9c\x2e\xe5\xec\xd8\x5d\x24\x4f\x90\xf9\x93\x62\xeb\x48\x96\x48\x59\x26\x65\x85\x94\x8b\xa5\xac\x95\xb2\x51\xca\x15\x52\xae\x92\x72\x2d\xc9\x29\xa4\xcf\x06\x31\x45\xf6\x7d\x8a\xec\xfb\x14\xd9\xf7\x29\xb2\xef\x53\x64\xaf\xa7\x4b\xad\xa6\x4b\xad\xa6\x4b\xad\xa6\x4b\xad\xa6\x4b\xad\x66\x52\xdf\x7b\x92\x4c\x0d\x24\xd5\xf4\x49\x8e\x8b\x2d\x24\x39\x85\xf2\xb3\xc4\x32\xea\xe9\xec\x60\xed\x90\xa4\xb5\x4f\x32\x85\xca\x67\x07\x6b\x9f\x64\x7a\xec\x06\x92\x3d\x02\x29\xed\x36\x9b\x5a\x98\x47\x72\x5c\x6c\x26\xc9\x89\xc1\x5d\xd4\x4e\x1f\x92\xd3\x65\xfe\x04\x29\x4f\x94\xf2\x24\xea\xfb\x6c\xb1\x40\xca\x12\x29\x23\xa4\xcf\x6c\xb2\x40\x90\x2f\x97\xb2\x92\xfa\x38\x5b\x5a\x7e\x36\xcd\x87\x20\x1f\x95\xf9\xa5\xf2\x6a\xa3\x94\x2b\xa4\x5c\x29\xcb\x4f\x96\x75\x56\x4b\x79\xaa\x2c\x5f\x43\xf9\x39\xc1\x3a\x25\x99\xdc\xf4\x0b\xc9\x14\xea\xe9\x1c\xd2\x5f\x21\x99\x4e\x7d\x99\x43\xfa\x93\x94\x33\x79\x8e\x9c\xc9\x73\xe4\x4c\x9e\x23\x67\xf2\x1c\x39\x93\xe7\xc8\x99\x3c\x47\xce\xe4\x39\x72\x26\xcf\x91\x33\x79\x8e\x9c\xc9\x73\xe4\x4c\x9e\x43\xfa\x67\x92\x0c\xe6\xf3\x1c\x39\x9f\xe7\xc8\xf9\x3c\x47\xce\xe7\x39\x72\x3e\xcf\x91\xf3\x79\x8e\x9c\xcf\x73\xe4\x7c\x9e\x23\xe7\xf3\x1c\x39\x9f\x4f\x90\x23\x75\x02\x8d\x4e\x19\xc9\xf9\x24\x8b\x69\xac\x9f\x23\xb9\x96\xe4\x5c\xc2\x5d\x4d\xb2\x44\xca\x32\x29\x17\x93\x25\xe7\x52\x9b\x41\xbe\x51\xca\x15\x52\xae\x92\xf2\x54\x29\xd7\x92\x3c\x51\x8e\xf8\x89\x72\xc4\xe7\x4b\x6b\xcc\x97\xfd\x9d\x2f\xfb\x3b\x5f\xf6\x77\xbe\xec\xef\x7c\xd9\xdf\xf9\xd4\xdf\x40\x9e\x28\x65\xd0\xdf\xf9\xb2\xbf\xf3\x65\x7f\xe7\xcb\xfe\xce\x97\x3d\x9d\x2f\x7b\x3a\x5f\xf6\x74\xbe\xec\xe9\x7c\xd9\xd3\xf9\xb2\xa7\xf3\x65\x4f\xe7\xcb\x9e\xce\x97\x3d\x9d\x2f\x7b\x1a\xa1\xf1\xfd\x48\x54\x50\xcb\x8f\x93\x5c\x18\x7b\x88\x64\x89\xcc\x47\xa4\x2c\x93\xb2\x52\x96\x2f\x96\xf9\x25\xb1\x73\x48\x56\xc5\x5e\x22\x19\x95\x25\x4b\xa9\x17\x15\xd4\x7e\x90\x5f\x16\x5b\x4c\x72\x85\xcc\xaf\x92\xf2\x54\x29\xd7\x92\xac\x22\x94\x6f\x49\x96\x48\x59\x16\xdb\x4c\xb2\x56\xca\xa5\x52\x36\x48\xd9\x28\xe5\x0a\x59\x67\x95\x94\xa7\xca\x92\xb5\x94\xaf\x26\x0d\x03\xb9\x88\xac\x5d\x4d\x5a\x05\xf9\x25\xb1\xdd\x24\xab\x64\x3e\x1a\x7b\x8f\xe4\x72\x79\x75\xb5\x94\x6b\x48\xd6\xca\x75\x5d\x2b\xd7\x75\xad\x5c\xd7\xb5\x72\x5d\xd7\xca\x15\x5d\x2b\xf5\xaf\x25\xf4\x40\x36\x4a\xb9\x42\xca\x53\x49\xae\xa4\x7b\x37\x93\x2c\x91\xb2\x4c\xca\xa5\x52\x36\x48\xd9\x28\xe5\x0a\x29\x57\x49\x79\xaa\x94\x6b\x49\xae\xa3\x79\xbe\x93\x64\xaa\x94\xd5\xb1\x35\x24\x57\xd3\xda\x5f\x67\x7c\x42\xf2\x29\xda\xf1\xae\x13\x4f\x4b\xf9\xbc\x78\x95\x4a\x9e\x17\x6f\xca\xfc\x26\x29\x37\xc7\x26\x91\xdc\x22\xe5\x56\xba\xf7\x79\xf1\x2e\xed\x21\xcf\x8b\x8f\x65\xcd\xcf\x62\x3b\x49\x7e\x1e\xbb\x86\xe4\x2e\x59\xb2\x57\xe6\xf7\xcb\xfc\x01\xd9\xc2\x41\x29\xbf\x8f\x3d\x22\x9e\x27\x94\x49\xe2\x05\xf1\x3c\xdd\xf5\x82\x78\x89\x4a\x5e\x10\xaf\x50\xcd\x17\xc4\x46\x29\xdf\x8c\xed\x27\xb9\x49\xca\xcd\xb2\xce\x16\x5a\xc5\x2f\x10\xee\x67\x24\xb7\xc9\x3a\xef\x52\x6b\x2f\x88\x0f\xe4\xbd\x9f\xc6\x9e\x21\xb9\x53\x96\xef\x91\xf5\x0f\x52\xfe\x45\x6a\x7f\x0d\xc9\xa0\xfd\x17\x65\xfb\x2f\x52\xfb\x41\x3e\x68\xf3\x45\x6a\x73\x2e\xc9\x6d\xb2\x3c\x68\xed\x45\x6a\xed\x72\x92\x9f\xca\xfc\x4e\x59\x7e\x50\xd6\xfc\x41\xca\x9f\xa8\x64\x3d\xed\x75\x5d\x48\xa6\x4a\x19\xd8\x70\xbd\xb4\xe1\x7a\xc2\xea\x45\xf2\x25\xea\xd7\x7a\xf1\x2a\x73\x48\x6e\xa4\x75\xba\x5e\xbc\x4e\xf7\xae\xa7\x1e\x05\x75\x36\xc9\xfc\xa7\xb2\xfc\x33\x59\xb2\x9d\xf4\x59\x4f\x58\x41\xc9\xae\x58\x29\xc9\x2f\x65\xc9\x1e\x59\xf2\x8d\xcc\x7f\x2b\xe5\x5e\xd9\xf2\xbe\x00\x91\xb4\x0a\x4a\x7e\x93\xf9\xdf\xa5\x8c\x91\xce\xeb\x55\x16\xdc\x25\x47\xf3\x25\xa9\xc3\x4b\x62\x0b\xeb\x42\xf2\x63\x99\xdf\x25\xf3\x5f\x50\xfe\x65\xba\xda\x85\xe4\x46\xd2\xe7\x15\x39\xd6\xaf\x48\x0d\x5f\x21\x0d\x03\xb9\x99\xd6\xe0\x2b\x64\x9f\xed\x24\x3f\x20\xef\xfc\x15\xa9\xed\x2b\x34\xbe\xd7\x91\xdc\x45\x23\xfb\x8a\x1c\xdf\x57\x48\x93\x1b\xc4\xab\xd4\xeb\x33\x48\xbe\x42\xad\xbd\x4a\x6d\xde\x45\x72\x0b\xd5\x7f\x95\xac\xfa\x08\xc9\x4f\xa5\xdc\x29\x4b\x82\xd1\xd9\x20\xb1\x36\x48\xac\x0d\x54\xf3\x1d\x92\x5b\xe9\xae\x0d\x54\x3f\xb8\xfa\x31\xe9\xb6\x41\xce\xa8\x0d\x84\xf5\x08\xc9\x2f\x64\x7e\x2f\xa1\x6f\x90\x33\x6a\x03\xcd\xa8\xa0\xfc\x20\xf5\x77\x83\x68\xa2\xab\x1b\xa9\x85\x40\x7e\x2e\xe5\x2e\x9a\x39\x1b\xa9\xfe\xeb\x24\x83\x99\xf0\xba\xbc\xfa\x3a\x95\x07\x72\xaf\x2c\x89\x97\xff\x44\xed\xbc\x49\x63\x77\x1d\xc9\x97\xa4\x0c\xe6\xc9\x9b\xd4\x8b\x20\xbf\x89\x34\x79\x93\x34\xbc\x90\xe4\x56\x99\xdf\x46\x0c\xf8\x26\xe9\x19\xd4\xf9\x34\x56\x4d\x72\x27\xb5\xf9\x36\xcd\x0a\x46\x32\x55\xca\x74\xe2\xbb\xb7\x59\x0f\x29\x57\x93\xb5\xdf\x16\xcf\x13\xbf\xbc\x4d\xed\x97\x91\x7c\x85\x66\xf2\xdb\xd2\xfe\x6f\xcb\x19\xf2\xb6\x78\x53\xe6\x37\x49\xb9\x59\xca\xc0\x7a\x6f\x93\xce\x1f\x91\xdc\x16\x8b\x92\xfc\x94\x46\xf9\x6d\xc2\x7a\x84\x64\xd0\x8b\xb7\x65\x2f\xde\x16\x4d\x41\xfb\x34\xee\x8f\x88\x4d\xb2\x17\x9b\x64\x2f\x36\xc9\x75\xb4\x89\xda\xd9\x49\x72\x1b\x79\x02\x9b\xa4\xce\x9b\x68\x34\x83\x92\xcf\x09\x65\x93\x9c\x0f\x9b\xc4\x7e\x29\x0f\xc8\xf2\x83\xb2\xce\x4f\x32\xdf\x44\xe5\x9b\xa9\x5f\x0e\xc9\x54\x29\xab\xa9\xe5\xcd\x34\xdb\x37\x88\xcd\x12\x6b\x33\x61\xad\x21\xb9\x51\xe6\x83\x79\xbe\x99\x46\x36\x90\x5b\x69\xb7\xd9\x2c\xc7\x7d\xb3\x9c\x39\x9b\x69\x9e\x07\x75\x76\xc9\x92\x2f\x65\xc9\xd7\x52\xee\x91\xe5\xdf\xc8\xfc\x5e\xb2\xc6\x66\xf1\x9d\xac\xb3\x4f\xca\xfd\x52\x1e\x94\x75\x7e\x90\xf2\x17\x59\xf2\x9b\xcc\xff\x2e\xd1\x83\x99\xbf\x59\x5a\x60\x0b\xed\x6f\x81\x4c\x95\x32\x5d\x96\xf4\x90\xb2\x9a\xd6\xce\x16\xd2\x7c\x8d\xd8\x42\x63\xb1\x92\xe4\x4b\xc4\xc8\x5b\x68\xe6\xef\x24\xb9\x91\xd6\xf2\x16\xb9\xd7\x6d\x21\xcd\x2b\x48\x7e\x2c\xcb\x3f\x95\xe5\x9f\xcb\xbb\xb6\xcb\x7c\xb0\x6b\x6d\x11\x3b\x9b\x3e\x23\xb9\x8b\x7c\xc2\x2d\x62\xb7\x2c\xf9\x42\xca\x2f\xa5\xfc\x4a\xb6\xf3\xb5\xcc\xef\x91\x77\x7d\x23\xf3\xdf\x4a\xb9\x57\x96\x7c\x27\xf3\xfb\xa4\xdc\x2f\xdb\xf9\x81\x2c\xbc\x45\xfc\x28\x4b\x7e\x96\xf2\x17\x29\x63\x81\xa4\xde\xd1\x5d\x72\x5d\x6f\x95\x7b\xda\x56\xb9\xcf\x6c\x95\xf3\x67\xab\x9c\x3f\x5b\x69\xcd\x06\x57\xb7\xd0\x1e\xb2\x95\xc6\x3a\xa8\xf3\xa9\xac\x13\x58\x78\x9b\x5c\xe3\xdb\xa8\x8f\xd7\x90\xdc\x44\x36\xd9\x46\x3d\x9d\x44\x32\xe8\xe9\x36\xd2\x6a\x0d\xc9\x83\x54\xf2\x8e\x1c\xc1\x77\xa8\x64\xa7\x78\x5f\x1c\xa4\x96\x3f\xa0\x76\xce\x12\x1f\xd0\x8e\xbd\x46\x7c\x44\xe8\xf7\x90\x7c\x89\x58\x95\x76\x08\x59\xf2\x2a\xb5\xf6\x11\x69\xf2\x00\xc9\xd7\xa5\x0c\x56\xf7\x47\x72\x75\x7f\x44\x5a\x95\x91\xdc\x46\x2b\xe5\x23\xd2\xaa\x1b\xc9\x00\xf1\x23\x6a\xf3\x72\xf1\x91\x6c\xf3\x63\x6a\x6d\x26\xc9\x60\xdd\x7d\x2c\xd7\xc5\xc7\xd4\x5a\x50\xfe\xa6\xcc\x6f\x65\x09\x24\xb7\x91\xe6\x1f\xd3\x5d\x97\x92\xdc\x29\x6b\x06\x3b\xc9\x27\xa4\xcf\x23\x24\x83\x95\xf5\x09\xb5\xb0\x94\x64\x30\x1b\x3f\x91\xf7\x7e\x22\x6d\xf2\x09\xdd\xeb\x93\x7c\x57\xd6\xdc\x29\x4b\x76\xcb\xab\x41\x0b\x9f\x89\x3d\xac\x1d\xc9\xef\x64\xfe\x00\xcd\xed\xcf\xc8\x0e\xd7\x90\xfc\x89\xfa\xf2\xb9\xac\xff\xb9\x5c\x71\x9f\xd3\x58\x07\xf9\x3d\x52\x7e\x43\xbb\xe2\xe7\x72\x1f\xfe\x9c\xc6\x2e\x90\x3f\x49\xf9\x6b\x70\x95\xc6\xeb\x75\xb1\x5d\xee\x60\xdb\xe5\x8e\xb4\x5d\xb6\xb3\x9d\xda\x39\x48\x72\x37\xf9\x2a\xdb\x25\xfa\x76\x6a\xe7\x23\x92\x7b\x69\xbf\xda\x4e\x33\x21\xb8\x7a\x40\xd6\x3c\x18\x7b\x8a\xe4\xf7\xb2\x4e\xd0\xf2\x76\xd9\xf2\x76\x6a\x79\xa7\xd8\x21\x39\x68\x87\xe4\xa0\x1d\xd4\xf2\x75\x24\x03\x0d\x77\x50\x9b\xd7\x90\xfc\x46\xe6\x83\xfd\x61\x87\xd4\x64\x27\xed\xf9\x5d\x48\x06\x7b\xc5\x2e\x36\x9e\xf2\xbb\xc4\x67\x52\x06\x7b\xd7\x2e\x79\x75\x17\xed\x03\x74\x55\xee\x00\xbb\xc4\xf7\xb2\xe4\x07\x79\x35\x60\xbd\xdd\xb2\x17\xbb\x25\xca\x6e\x59\x7f\xb7\x6c\x7f\x37\xe9\xfc\x01\xc9\x78\x9d\x5f\xe9\xea\x17\xd4\xe6\x07\x24\x77\x4b\x19\xd4\xfc\x82\xf4\xd9\x4e\x72\x2f\xf5\xee\x0b\x6a\x7f\x2b\xc9\xef\xa9\xbf\x5f\xd0\x5d\xef\x90\xfc\x95\x2c\xf0\x35\xad\xd0\x0d\xe2\x6b\xb2\xd8\x67\x24\x3f\xa7\xd6\xbe\x96\x5e\xc4\xd7\x72\xe7\xff\x5a\x72\xcd\xd7\x72\xe7\xff\x5a\xee\x54\x5f\x8b\xe0\xfd\xc4\xaf\xa9\x9d\xa0\xe4\x27\xf2\x06\xbf\x96\x2c\xf0\x0d\xb5\xb0\x9f\x64\xb0\x77\xed\x25\x4d\x5e\x22\xb9\x4b\xe6\x83\xb1\xdb\x2b\x6d\xbe\x97\xf4\x79\x8f\x64\xd0\xdf\xbd\xb2\xb5\xbd\x72\x1c\xf7\x52\x7f\x83\x3a\x3f\x91\x26\x7b\xe3\x2d\x90\xf5\xde\x13\xfb\xa4\x95\xf6\xc9\xbe\xec\x93\x2d\xec\xa3\x16\x3e\x23\x79\x40\xe6\x0f\x4a\x19\x58\x60\x9f\xb4\xf0\x7e\x69\xdb\xfd\x72\x8f\xdd\x2f\xd1\xf7\x4b\xce\xdd\x2f\x6b\xee\x97\xb6\xdd\x2f\x6d\xbb\x5f\x5a\x60\xbf\xc4\x3a\x40\x63\x5a\x46\x32\x35\x90\xb2\x85\x03\x12\xf7\x80\x9c\xab\x07\x24\xfa\x01\x39\xf7\x0e\xc8\xb5\x79\x40\xec\x93\x25\xfb\xa5\x3c\x28\x4b\x02\xf4\x03\x72\x86\x1c\x94\xfb\xf6\x41\xb9\x6f\x1f\xa4\x9d\x30\x28\xe9\x21\x65\xc0\x47\x07\xe5\xcc\x3c\x28\xc7\xf4\x20\xa1\xac\x21\xb9\x4b\xe6\x77\x4b\xb9\x87\xb8\xf8\xa0\x9c\x45\x07\xe5\x28\x1f\x94\x76\x3e\x28\xe7\xd2\xf7\x72\x26\x7f\x2f\x35\xf9\x5e\xce\x96\xef\xe9\x2a\xd5\xa0\xbe\xbc\x26\xbe\x97\xe8\x3f\xc8\xf6\x7f\xa0\xf6\x1f\x21\x19\x8c\xe3\x0f\x72\x1c\x7f\xa0\xd6\x82\x92\xfd\x34\x2e\x3f\xc8\x79\xfe\x83\xb4\xfc\x0f\xd2\x27\xfc\x81\x5a\xb8\x8e\xe4\xaf\x32\x1f\x8c\xe6\x8f\xb2\xd7\xbf\x4b\xae\xff\x9d\xae\x96\x8a\x26\x42\xbf\x8a\xe4\x6e\xf2\x84\x9b\x48\x87\x0f\x48\x7e\x43\x9e\x76\x93\xd4\xa1\x89\xac\xfa\x90\x68\x92\x3a\xc4\xa8\xe6\x35\x24\x83\x71\x8f\x49\x6d\x63\xb2\x47\x31\x39\x6a\x31\x59\x3f\x26\xeb\xc7\x82\xf5\xa5\x26\x07\x16\x23\x99\x2a\xe5\x6a\xd6\x45\xcd\xa7\x92\x10\xc9\x54\x29\xd3\x63\xaf\x93\xec\x21\x25\xb1\x09\xc9\xd5\x74\x57\x7e\xb0\x27\x1b\xdb\x8d\xed\xb1\x0a\x63\x07\x45\x4f\x81\x9c\x1d\xbb\x98\xe4\x9c\x18\xed\x98\xb4\xbf\x55\x18\x3b\xc5\xa3\x31\x87\xe4\x33\x52\x6e\x96\xf2\xdd\xa6\x35\x24\x3f\xa0\xfc\x97\xf2\xea\x97\xf2\xea\x97\xf2\xea\x97\xf2\xea\x97\xc1\x55\xc6\x58\x0f\x5e\x13\xbc\xcf\x28\xff\xcd\x66\x0f\x20\xcf\x59\x0a\x1f\x80\xbc\xc2\x0c\x3e\x1e\x79\xc1\xba\xf1\x73\x91\x57\xa9\xce\xcb\xc8\x6b\x2c\x89\x7f\x8f\xbc\xce\x92\x95\xbe\xc8\x1b\xec\x64\x31\x18\x79\x93\xa5\xd1\xae\x19\xcf\x5b\x2c\x49\x55\x90\x4f\xe0\x35\xfa\x5e\xe4\xdb\xb0\xee\xe6\x35\xc8\x27\xb2\xe1\x56\x7b\xe4\xdb\xb2\x90\xd5\xac\x5b\x12\xeb\x9a\xd0\x95\x34\xe1\xaa\x45\xaf\xee\x97\x5a\x05\x79\xce\x32\xb8\x86\xbc\x42\xfa\xe4\x20\x2f\x58\x16\x9f\x86\xbc\x4a\x75\xee\x40\x5e\x63\xdd\xf9\x3b\xc8\xeb\xac\x87\xa2\x22\x6f\xb0\x83\x8a\x8b\xbc\xc9\x06\x8a\x3b\x91\xb7\x58\x77\xda\x13\xe3\xf9\x04\xe5\x43\x35\x15\xf9\x36\x2c\xc7\x3c\x09\xf9\x44\x36\xcf\x7c\x0c\xf9\xb6\x6c\xb1\x55\x80\x7c\x12\x73\xad\x1d\xac\x88\x55\xb2\x72\xfa\x6b\xa0\xbf\x93\x59\x84\x95\xb2\x0c\xfa\x0b\xd3\xeb\x30\xe5\x4a\x58\x94\xd5\xb2\x95\xac\x4e\xd6\xaa\xa0\xd2\x0c\x36\x90\x4a\x07\x51\x6a\xb3\x91\x2c\x93\xfe\x32\xd8\x38\xaa\x15\xa5\xeb\x55\x74\x7f\x06\x2b\xa4\x7c\x1d\xdd\x15\xc8\xb0\x6c\x37\xca\x6a\xd8\x70\x96\x20\xaf\xfc\x75\x6b\x36\xe5\xa6\x43\x8b\xf1\xf2\xee\xa1\x94\x9b\x40\xf7\x97\x50\x0b\xac\xa8\xb2\xbc\xb2\xa1\xf2\xe4\x48\x69\x46\x69\xb8\x21\x9c\x51\x12\xad\x5d\x59\x57\x59\x5e\xd1\x90\x31\xb0\x64\x50\x86\x3d\x32\x73\x64\xc6\xb8\x68\xb4\xbc\x2a\x92\x51\x18\xad\xab\x8d\xd6\x85\x1b\x2a\xa3\x35\xc3\x13\x0a\x8f\xac\x66\x67\x4c\xa7\x26\xc6\x87\x1b\x86\x66\x4c\xa8\x29\xa1\x76\x27\x91\x42\x8b\x08\xb6\xb5\xc2\x19\x6c\x86\x2c\xa9\x64\x65\x54\xa1\x72\x51\x24\xde\x5c\xc6\x8c\x48\x5d\x25\x95\x04\x5a\x96\xb3\x46\xea\x73\x98\x2a\xb1\xe9\x91\xf2\xc6\xaa\x30\x65\xf2\x59\x3d\xe9\x1a\xa1\x06\x4a\xe5\xed\x19\x6c\x18\xfd\xfd\x8f\x00\xf9\xf5\x25\x91\x9a\xd2\x48\x5d\xc6\xb0\x8c\x3f\x62\xfd\x1f\xd4\x9b\x2d\x2f\xd6\xb7\x54\xb6\xc9\x7c\x23\xe9\xff\xf0\xe0\x47\x43\x67\x47\xea\xea\x83\xba\xf6\xf0\x91\x23\x87\x67\x1e\xbd\xfd\xa3\xb6\xfe\x97\xfa\x54\x12\x5c\x86\x9c\x35\x0d\xf2\x4a\xd0\xff\x6a\x69\x9d\x25\x54\x16\xa5\x96\xfe\x6a\x6c\x33\xa8\x5e\x44\xce\xc4\x7a\xba\x12\x91\xaf\x4a\x65\xab\x41\xdb\xb3\xa8\xc6\x0c\x59\x6b\x9a\xbc\x33\xb0\x6f\x83\x44\xab\x91\xb5\x66\x1e\x05\x71\x2a\x21\x96\xd1\xfd\x25\x72\x56\x36\xd7\x2c\x91\x6d\x07\xb3\x3b\xde\x72\x94\xf2\x15\x18\xa9\xc5\x34\x9e\x75\x52\x83\x52\x79\x5f\x73\xdf\xea\x83\xb9\xd7\xca\xc6\x95\xf5\x19\xe1\x8c\x86\xba\x70\x69\xa4\x3a\x5c\xb7\x24\x23\x5a\x76\xf8\x7c\xca\xa8\x8b\x94\x57\xd6\x37\x44\xea\xa8\xb0\xb2\x26\x63\xd6\xf0\x19\xc3\x33\xa6\x85\x1b\x22\x35\x0d\x19\xe1\x9a\xd2\x8c\x99\x2d\x37\x4e\x2d\x2b\xab\x2c\x89\xc8\xc2\x92\x48\x5d\x43\x98\x2a\x47\x1b\x2a\x68\x12\x2c\x6e\xac\xab\xac\x2f\xad\x2c\x09\xd0\xea\x87\x1f\x6d\x52\x1d\x7d\x91\x1d\x9a\x46\xad\x16\x00\x23\xcb\x05\x16\x5b\x26\xed\x30\x59\x56\x0f\x5e\xd7\xc7\x6f\x99\xd1\x10\x59\x16\xc9\x98\x1c\x6e\x68\x88\xd4\x07\x95\x0b\xa8\x42\x3d\x8c\x1f\x1f\xd8\x99\xd2\x54\x51\x2a\x0d\x06\x6c\x39\x99\x2b\x30\x4e\x85\xcc\x87\xe5\xa0\x97\xca\xe6\x82\x45\x5d\x83\x3b\x17\xd1\x32\xcf\xf8\x4b\xe0\x0c\xdc\x1b\xc6\xe4\xa9\x91\x18\xcb\xd0\x9b\xe0\x9e\xa1\x98\x14\x65\x52\xd6\x4b\xdc\x1a\xc2\xc8\x90\xfa\xc5\x27\xe7\xe1\xd8\x19\x72\x30\xc3\x72\x6a\xc4\xa7\x63\x35\x5d\x6d\x90\x75\x4b\xa8\xbc\x8a\xfe\xaf\xc4\xb6\x56\x4d\xd6\x8b\x63\x2d\xc2\xc6\xb5\x5c\x6e\x83\x15\xe8\x71\xb5\x6c\x37\x83\x4d\xa1\x74\xb9\x9c\xba\x51\x39\xb9\x6a\x7a\xf5\x96\x13\xf1\x90\x55\xe2\x93\xbb\x0c\x2b\x2e\x43\xde\x5b\x4b\xf9\xa8\xec\x45\xb3\x1d\x87\xc9\x31\x0c\x7a\x12\x91\x9a\x06\xb9\xb0\xdc\x6a\x17\xd1\x1d\x55\x12\x3b\xae\x5b\x85\x9c\xc2\x61\x39\x01\x23\x98\x90\x0d\xb2\x07\xf5\xad\x26\x72\x7c\xda\x66\xc8\x5e\x04\xad\x7b\x72\xf2\x06\x1b\x6c\x04\x36\x9d\x43\x1b\xf3\xa4\xa3\xb6\x18\xb7\x60\xeb\x05\x14\x8c\x49\x95\xd4\xb7\xbe\x55\xdb\x35\x52\xdb\xd2\x96\x3e\xc6\xad\x1d\xd4\xaa\x02\x52\xbc\xc7\x55\x92\x00\x96\xb4\x8c\x4f\x99\x9c\x97\x71\x8b\x96\xca\xd6\x86\xfd\x89\xcd\xcb\xa4\x6d\x1a\x80\x1a\x95\x1a\x95\xd2\xff\xf8\x88\xc7\xe7\x56\x94\xee\x6d\x94\xe3\x11\x5f\xf4\xf1\x59\xdf\xf0\x07\xcb\x85\xa5\x7d\xa3\xb8\xaf\x56\x6e\xcd\x0d\xd0\xa5\x3a\xbe\x88\x0b\xc2\xf5\xb4\x28\x69\x09\xcf\xac\xac\x89\xd6\x0f\xcd\x58\x5e\x51\x59\x52\x91\xb1\x3c\x5c\x9f\x51\x1a\xa9\xaf\x2c\xaf\xa1\x8b\x8b\x56\x66\x1c\xbe\x24\x32\xe8\x6a\x98\x16\x7d\x4d\x4d\x74\x19\x2d\xa8\x65\x91\xa1\xb4\xc0\xcb\xea\x22\xf5\x15\x95\x35\xe5\x19\xf5\xc1\x96\x88\xbb\x33\x1a\x2a\xc2\x0d\xc1\xee\x50\x1d\x69\xa8\xab\x2c\x09\x57\x55\xad\x24\x8e\xaa\xae\xa5\xbb\x16\x11\x29\x2d\xaf\x6c\xa8\x20\xe0\xea\x48\x7d\xc6\x94\xc8\xf2\x8c\xe9\xd1\xea\x70\xcd\xbd\xc3\xe3\xaa\xd0\x26\x52\x46\xbb\x72\x46\x65\x75\x6d\x5d\x74\x99\xd4\x71\x58\x7d\x49\x5d\x24\x52\x43\x60\xe1\xd2\xf0\xa2\xca\xaa\xca\x06\x6a\xad\x22\x5c\x17\x2e\xa1\xad\x85\xf6\x97\xca\x92\x7a\xb9\x75\xd0\x8e\x91\x51\x1b\xae\x19\xe6\x35\xd6\x45\x6b\x23\xa4\xe9\x9c\x71\x93\x0e\x55\x24\x05\xe3\xdb\x4e\x7d\xb4\x6a\x19\x21\x07\xb5\x6b\x22\x91\xd2\x00\x91\xd4\x5e\x16\xa9\xa2\x9b\x08\xb8\x2a\x1a\x5d\x12\xf4\xa7\x2c\x5a\x47\x8a\x96\x36\x54\x0c\x6b\xa5\x79\x59\xb4\xa6\x81\x6e\x8d\x66\x84\x4b\x4b\xa9\xe3\x64\xad\x68\x49\x63\x75\xb0\xa1\xd1\x26\xd3\xd0\xac\x5c\xb8\xa4\x2e\x4a\xd7\x6a\xab\xc2\x0d\xd4\x4a\x75\xb0\x71\x55\xc8\x25\x5f\xcb\x46\xb1\x11\xf4\x7f\xb9\xfc\x3f\x5c\x2e\xfc\xd6\xdb\x59\x09\x36\xb3\xe1\x98\x24\x23\xe8\xc6\x86\x86\xda\x51\x23\x46\x2c\x5f\xbe\x7c\x78\x18\x7b\x5a\x09\x6d\x69\xc3\x49\xa9\x11\xff\xf7\x66\x83\x79\x52\x2b\x67\x74\xeb\xfd\xaa\x4e\xce\x8d\xa0\xcd\x6a\x9a\x33\x7f\x09\xdd\xb0\xb2\x36\x82\x99\x52\x57\x3f\xbc\xa2\xa1\xba\x2a\xce\x86\x71\xd8\xe6\x6d\xb3\xb1\xd5\x46\xdd\xbc\x94\x66\x10\xd3\x4d\x92\xac\x54\x8b\x0d\xc0\xc7\xd4\xcf\x38\xa2\x85\x60\xdb\x3b\x92\xbe\x33\xe3\xc4\x3d\x89\xe8\xa2\x26\x98\xc1\x8d\x72\x93\x0f\xc6\x72\xc6\x84\x49\x19\x53\x6b\x69\x9a\xf8\x34\x46\x19\xa8\x30\x34\xa3\x99\xe2\x33\x03\x7e\x3f\xdc\x5c\xf1\x6d\xa8\x92\x5e\x37\xc8\x8e\xd7\xcb\x45\x34\x5c\x1a\xab\x9c\xae\x4f\x25\xcd\x26\xb5\x98\x81\x26\x61\x65\x6d\x43\xfd\xf0\xfa\xca\xaa\xe1\xd1\xba\xf2\x11\x53\xfd\x49\xd2\xff\x96\xff\x62\xbd\xa8\x9f\x47\xf9\x97\x10\xff\xdd\x02\x85\x05\xbf\x7c\xa9\x91\x27\x6b\x90\xd7\x4a\x1e\x2a\xf9\xa5\x89\xe4\x83\x26\xb1\x64\x96\xc2\x52\x59\x3b\xd6\x9e\xa5\xb1\x0e\xac\x23\xeb\xc4\x3a\xb3\x2e\xac\x2b\xeb\xc6\xba\xb3\x74\xd6\x83\xf5\xa4\x3e\xf7\x62\xbd\x59\x1f\xd6\x97\xf5\x63\xfd\xd9\x00\xf2\x13\x07\xb1\xc1\x6c\x08\x59\x67\x18\xe9\x3a\x02\xde\xa2\xc3\x5c\x16\x62\x59\x2c\x9b\xe5\xb0\x5c\xea\xdf\x68\x36\x86\x1d\xc3\xc6\xb2\x63\x59\x1e\x91\x66\x01\xd1\x64\x11\x6d\x8c\x3e\x6d\x84\xe3\xc9\xfe\xc7\xb1\x89\xd4\xb3\xc9\xc1\xef\x85\x93\x1f\x71\x3c\x6d\xe9\x33\x68\x1b\x9f\x45\xd6\x9e\xc3\x4e\x60\xc5\x6c\x2e\x3b\x91\xcd\x63\xf3\xd9\x49\x6c\x01\x5b\xc8\xc2\x5c\x61\xb7\xb3\x33\xd9\x59\xec\x59\x76\x15\xfb\x82\x9d\xcd\x2e\x62\xe7\xb3\x1b\xd9\xdf\xd9\x1d\x5c\xb0\xbf\x71\x95\x9d\xc1\x2e\x67\xfb\xd9\x01\x76\x21\xf9\xf8\xe7\x72\x9d\x7d\xcc\xf6\xb1\x9b\xd8\xbd\xec\x7b\x76\x90\xfd\xc0\x6e\x63\xff\x60\xaf\xb1\x57\x28\x7e\x59\x44\x16\xbf\x84\x2c\xb5\x81\x46\xf5\x55\xf6\x1f\xf6\x26\xdb\xc8\x5e\x67\x6f\xb0\x2f\x69\x73\xda\xcc\xde\x62\x6f\xb3\x07\xc9\xf2\xdf\xb1\x4b\xd9\x36\xb6\x85\x6d\xa5\xf1\xfa\x9a\x7d\xc3\xce\x23\x7f\xa4\x92\x36\xd5\x60\x52\xd6\xb0\x5b\x68\x7c\x96\x4a\x5a\xa9\xa7\xf9\xd5\x40\x9b\xf0\x72\xf6\x15\x5b\x41\x3e\xfb\x4a\xb6\x8a\x62\xb7\x53\xd8\x93\xec\x56\xb6\x86\x9d\xca\xd6\xb2\xd3\xd8\x1e\xf6\x2d\x7b\x8a\x1b\xdc\xe4\x16\x4f\xe0\x6d\x78\x22\xfb\x9d\x35\xf1\xb6\x3c\x89\x27\xf3\x14\x16\xe3\x8c\xa7\xf2\x76\xbc\x3d\xe7\x3c\x8d\x77\xe0\x1d\x79\x27\xde\x99\x77\xe1\x5d\x79\x37\xde\x9d\xa7\xf3\x1e\xbc\x27\xfb\x89\xfd\xcc\x33\x78\x2f\xde\x9b\xf7\xe1\x7d\x79\x3f\xde\x9f\x0f\xe0\x03\xf9\x20\x3e\x98\x0f\xe1\x43\xf9\x30\x3e\x9c\x8f\x60\xbf\xb0\x77\xf8\x48\x9e\xc9\x6d\xee\x70\x97\x87\x78\x16\xcf\xe6\x39\x3c\x97\x8f\xe2\xa3\xf9\x18\x7e\x0c\x1f\xcb\x3e\x67\xdb\xf9\xb1\x3c\x8f\xe7\xf3\x02\x5e\xc8\x8b\xb8\xc7\xfd\xe0\x67\xa6\xf8\x04\x7e\x1c\x9f\xc8\x27\xf1\xc9\xec\x21\xf6\x30\x9f\xc2\xa7\xf2\x69\xfc\x78\x3e\x9d\xcf\xe0\x33\xf9\x2c\x3e\x9b\xcf\x61\xbf\xb2\xdf\xd8\x0e\xb6\x93\x9f\xc0\x8b\xf9\x5c\x7e\x22\x9f\xc7\xe7\xf3\x93\xf8\x02\xbe\x90\x87\xf9\x22\x5e\xc2\x4b\x79\x84\x97\xf1\x72\x5e\xc1\x2b\xf9\x62\xbe\x84\x57\xf1\x6a\xf6\x34\xaf\xe1\x51\x5e\xcb\x97\xb2\x5d\x6c\x37\xaf\xe3\xf5\xbc\x81\x37\xf2\x65\x7c\x39\x5f\xc1\x57\xf2\x93\xf9\x2a\x7e\x0a\x5f\xcd\x4f\xe5\x6b\xf8\x5a\x7e\x1a\x3f\x9d\x9f\xc1\xcf\x64\x77\xf1\xb3\xf8\xd9\xfc\x1c\x7e\x2e\x3f\x8f\xff\x8d\x9f\xcf\x2f\xe0\x17\xf2\x8b\xf8\xc5\xfc\x12\x7e\x29\xbf\x8c\x5f\xce\xaf\xe0\x57\xf2\xab\xf8\xd5\xfc\x1a\x7e\x2d\xbf\x8e\x5f\xcf\x6f\xe0\x37\xf2\x9b\xf8\xcd\xfc\x16\x7e\x2b\xbf\x8d\xdf\xce\xef\xe0\x77\xf2\xbb\xf8\xdd\xfc\x1e\xfe\x77\x7e\x2f\xbf\x8f\xdf\xcf\xff\xc1\x1f\xe0\x0f\xf2\x87\xf8\xc3\xfc\x11\xfe\x28\x5f\xc7\x1f\xe3\x8f\xf3\x27\xf8\x93\xfc\x9f\xfc\x29\xfe\x34\x7f\x86\x3f\xcb\x9f\xe3\xff\xe2\xff\xe6\xcf\xf3\x17\xf8\x8b\x7c\x3d\x7f\x89\xbf\xcc\x5f\xe1\xaf\xf2\xd7\xf8\x7f\xf8\x06\xbe\x91\xbf\xce\xdf\xe0\x6f\xf2\xb7\xf8\xdb\x7c\x13\xdf\xcc\xb7\xf0\xad\x7c\x1b\x7f\x87\xbf\xcb\xdf\xe3\xef\xf3\x0f\xf8\x87\xfc\x23\xfe\x31\xff\x84\x7f\xca\x3f\xe3\x9f\xf3\xed\x7c\x07\xdf\xc9\x77\xf1\xdd\xfc\x0b\xfe\x25\xff\x8a\x7f\xcd\xf7\xf0\x6f\xf8\xb7\x7c\x2f\xff\x8e\xef\xe3\xfb\xf9\x01\x7e\x90\x7f\xcf\x7f\xe0\x3f\xf2\x9f\xf8\xcf\xfc\x17\xfe\x2b\xff\x8d\xff\xce\x9b\x78\x4c\x61\x0a\x57\x14\x45\x04\x3f\xfe\xa2\xe8\x8a\xa1\x98\x8a\xa5\x24\x28\x6d\x94\x44\xa5\xad\x92\xa4\x24\x2b\x29\x4a\xaa\xd2\x4e\x69\xaf\xa4\x29\x1d\x94\x8e\x4a\x27\xa5\xb3\xd2\x45\xe9\xaa\x74\x53\xba\x2b\xe9\x4a\x0f\xa5\xa7\x92\xa1\xf4\x52\x7a\x2b\x7d\x94\xbe\x4a\x3f\xa5\xbf\x32\x40\x19\xa8\x0c\x52\x06\x2b\x43\x94\xa1\xca\x30\x65\xb8\x32\x42\x19\xa9\x64\x2a\xb6\xe2\x28\xae\x12\x52\xb2\x94\x6c\x25\x47\xc9\x55\x46\x29\xa3\x95\x31\xca\x31\xca\x58\xe5\x58\x25\x4f\xc9\x57\x0a\x94\x42\xa5\x48\xf1\x14\x5f\x19\xa7\x8c\x57\x26\x28\xc7\x29\x13\x95\x49\xca\x64\x65\x8a\x32\x55\x99\xa6\x1c\xaf\x4c\x57\x66\x28\x33\x95\x59\xca\x6c\x65\x8e\x72\x82\x52\xac\xcc\x55\x4e\x54\xe6\x29\xf3\x95\x93\x94\x05\xca\x42\x25\xac\x2c\x52\x4a\x94\x52\x25\xa2\x94\x29\xe5\x4a\x85\x52\xa9\x2c\x56\x96\x28\x55\x4a\xb5\x52\xa3\x44\x95\x5a\x65\xa9\x52\xa7\xd4\x2b\x0d\x4a\xa3\xb2\x4c\x59\xae\xac\x50\x56\x2a\x27\x2b\xab\x94\x53\x94\xd5\xca\xa9\xca\x1a\x65\xad\x72\x9a\x72\xba\x72\x86\x72\xa6\x72\x96\x72\xb6\x72\x8e\x72\xae\x72\x9e\xf2\x37\xe5\x7c\xe5\x02\xe5\x42\xe5\x22\xe5\x62\xe5\x12\xe5\x52\xe5\x32\xe5\x72\xe5\x0a\xe5\x4a\xe5\x2a\xe5\x6a\xe5\x1a\xe5\x5a\xe5\x3a\xe5\x7a\xe5\x06\xe5\x46\xe5\x26\xe5\x66\xe5\x16\xe5\x56\xe5\x36\xe5\x76\xe5\x0e\xe5\x4e\xe5\x2e\xe5\x6e\xe5\x1e\xe5\xef\xca\xbd\xca\x7d\xca\xfd\xca\x3f\x94\x07\x94\x07\x95\x87\x94\x87\x95\x47\x94\x47\x95\x75\xca\x63\xca\xe3\xca\x13\xec\x5d\xf6\x99\xf2\x24\x7b\x5f\xf9\xa7\xf2\x94\xf2\xb4\xf2\x8c\xf2\xac\xf2\x9c\xf2\x2f\xe5\xdf\xca\xf3\xca\x0b\xca\x8b\xca\x7a\xe5\x25\xe5\x65\xf6\x01\xfb\x90\x7d\xc4\x3e\x65\xef\xb1\x4f\x94\x57\x94\x57\x95\xd7\x94\xff\x28\x1b\x94\x8d\xca\xeb\xca\x1b\xca\x9b\xca\x5b\xca\xdb\xca\x26\x65\xb3\xb2\x45\xd9\xaa\x6c\x53\xde\x51\xde\x55\xde\x53\xde\x57\x3e\x50\x3e\x54\x3e\x52\x3e\x56\x3e\x51\x3e\x55\x3e\x53\x3e\x57\xb6\x2b\x3b\x94\x9d\xca\x2e\x65\xb7\xf2\x85\xf2\xa5\xf2\x95\xf2\xb5\xb2\x47\xf9\x46\xf9\x56\xd9\xab\x7c\xa7\xec\x53\xf6\x2b\x07\x94\x83\xca\xf7\xca\x0f\xca\x8f\xca\x4f\xca\xcf\xca\x2f\xca\xaf\xca\x6f\xca\xef\x4a\x93\x12\x13\x4c\x70\xa1\x08\x21\x54\xa1\x09\x5d\x18\xc2\x14\x96\x48\x10\x6d\x44\xa2\x68\x2b\x92\x44\xb2\x48\x11\xa9\xa2\x9d\x68\x2f\xd2\x44\x07\xd1\x51\x74\x12\x9d\x45\x17\xd1\x55\x74\x13\xdd\x45\xba\xe8\x21\x7a\x8a\x0c\xd1\x4b\xf4\x16\x7d\x44\x5f\xd1\x4f\xf4\x17\x03\xc4\x40\x31\x48\x0c\x16\x43\xc4\x50\x31\x4c\x0c\x17\x23\xc4\x48\x91\x29\x6c\xe1\x08\x57\x84\x44\x96\xc8\x16\x39\x22\x57\x8c\x12\xa3\xc5\x18\x71\x8c\x18\x2b\x8e\x15\x79\x22\x5f\x14\x88\x42\x51\x24\xbc\xe0\xbb\x26\x62\xbc\x98\x20\x8e\x13\x13\xc5\x24\x31\x59\x4c\x11\x53\xc5\x34\x71\xbc\x98\x2e\x66\x88\x99\x62\x96\x08\xbe\x53\x70\x82\x28\x16\x73\xc5\x89\x62\x5e\xf0\x99\xbc\x58\x20\x16\x8a\xb0\x58\x24\x4a\x44\xa9\x88\x88\x32\x51\x1e\x7c\x62\x2e\x16\x8b\x25\xa2\x4a\x54\xb3\x7b\x44\x8d\x88\x06\x9f\x32\x8b\x3a\x51\x2f\x1a\x44\xa3\x58\x26\x96\x8b\x15\x62\xa5\x38\x59\xac\x12\xa7\x88\xd5\xe2\x54\xb1\x46\xac\x65\x37\x8b\xd3\xc4\xe9\xe2\x0c\x71\xa6\x38\x4b\x9c\x2d\xce\x11\xe7\x8a\xf3\xc4\xdf\xc4\xf9\xe2\x02\x71\xa1\xb8\x48\x5c\x2c\x2e\x11\x97\x8a\xcb\xd8\xd5\xe2\x72\x71\x85\xb8\x92\x5d\x2f\xae\x12\x57\x8b\x6b\xc4\xb5\xe2\x3a\x71\xbd\xb8\x41\xdc\x28\x6e\x12\x37\x8b\x5b\xc4\xad\xe2\x36\x71\xbb\xb8\x43\xdc\x29\xee\x12\x77\x8b\x7b\xc4\xdf\xc5\xbd\xe2\x3e\x71\xbf\xf8\x87\x78\x40\x3c\x28\x1e\x12\x0f\x8b\x47\xc4\xa3\x62\x9d\x78\x4c\x3c\x2e\x9e\x10\x4f\x8a\x7f\x8a\xa7\xc4\xd3\xe2\x19\xf1\xac\x78\x4e\xfc\x4b\xfc\x5b\x3c\x2f\x5e\x10\x2f\x06\x9f\xab\x8a\x97\x83\x4f\x2a\xc5\x6b\xe2\x3f\x62\x83\xd8\x28\x5e\x17\x6f\x88\x37\xc5\x5b\xc1\xe7\x66\x62\x73\xf0\xb9\x8d\xd8\x26\xde\x11\xef\x8a\xf7\xc4\xfb\xe2\x03\xf1\x61\xf0\x39\x83\xf8\x44\x7c\x2a\x3e\x13\x9f\x8b\xed\xc1\xbb\xe4\x62\x57\xf0\xce\xb5\xf8\x52\x7c\x25\xbe\x16\x7b\xc4\x37\xe2\x5b\xb1\x57\x7c\x27\xf6\x89\xfd\xc1\xfb\xa7\xe2\x7b\xf1\x83\xf8\x51\xfc\x24\x7e\x16\xbf\x88\x5f\xc5\x6f\xe2\x77\xd1\x24\x62\x2a\x53\xb9\xaa\xa8\x42\x55\x55\x4d\xd5\x55\x43\x35\x55\x4b\x4d\x50\xdb\xa8\x89\x6a\x5b\x35\x49\x4d\x56\x53\xd4\x54\xb5\x9d\xda\x5e\x4d\x53\x3b\xa8\x1d\xd5\x4e\x6a\x67\xb5\x8b\xda\x55\xed\xa6\x76\x57\xd3\xd5\x1e\x6a\x4f\x35\x43\xed\xa5\xf6\x56\xfb\xa8\x7d\xd5\x7e\x6a\x7f\x75\x80\x3a\x50\x1d\xa4\x0e\x56\x87\xa8\x43\xd5\x61\xea\x70\x75\x84\x3a\x52\xcd\x54\x6d\xd5\x51\x5d\x35\xa4\x66\xa9\xd9\x6a\x8e\x9a\xab\x8e\x52\x47\xab\x63\xd4\x63\xd4\xb1\xea\xb1\x6a\x9e\x9a\xaf\x16\xa8\x85\x6a\x91\xea\xa9\xbe\x3a\x4e\x1d\xaf\x4e\x50\x8f\x53\x27\xaa\x93\xd4\xc9\xea\x14\x75\xaa\x3a\x4d\x3d\x5e\x9d\xae\xce\x50\x67\xaa\xb3\xd4\xd9\xea\x1c\xf5\x04\xb5\x58\x9d\xab\x9e\xa8\xce\x53\xe7\xab\x27\xa9\x0b\xd4\x85\x6a\x58\x5d\xa4\x96\xa8\xa5\x6a\x44\x2d\x53\xcb\xd5\x0a\xb5\x52\x5d\xac\x2e\x51\xab\xd4\x6a\xb5\x46\x8d\xaa\xb5\xea\x52\xb5\x4e\xad\x57\x1b\xd4\x46\x75\x99\xba\x5c\x5d\xa1\xae\x54\x4f\x56\x57\xa9\xa7\xa8\xab\xd5\x53\xd5\x35\xea\x5a\xf5\x34\xf5\x74\xf5\x0c\xf5\x4c\xf5\x2c\xf5\x6c\xf5\x1c\xf5\x5c\xf5\x3c\xf5\x6f\xea\xf9\xea\x05\xea\x85\xea\x45\xea\xc5\xea\x25\xea\xa5\xea\x65\xea\xe5\xea\x15\xea\x95\xea\x55\xea\xd5\xea\x35\xea\xb5\xea\x75\xea\xf5\xea\x0d\xea\x8d\xea\x4d\xea\xcd\xea\x2d\xea\xad\xea\x6d\xea\xed\xea\x1d\xea\x9d\xea\x5d\xea\xdd\xea\x3d\xea\xdf\xd5\x7b\xd5\xfb\xd4\xfb\xd5\x7f\xa8\x0f\xa8\x0f\xaa\x0f\xa9\x0f\xab\x8f\xa8\x8f\xaa\xeb\xd4\xc7\xd4\xc7\xd5\x27\xd4\x27\xd5\x7f\xaa\x4f\xa9\x4f\xab\xcf\xa8\xcf\xaa\xcf\xa9\xff\x52\xff\xad\x3e\xaf\xbe\xa0\xbe\xa8\xae\x57\x5f\x52\x5f\x56\x5f\x51\x5f\x55\x5f\x53\xff\xa3\x6e\x50\x37\xaa\xaf\xab\x6f\xa8\x6f\xaa\x6f\xa9\x6f\xab\x9b\xd4\xcd\xea\x16\x75\xab\xba\x4d\x7d\x47\x7d\x57\x7d\x4f\x7d\x5f\xfd\x40\xfd\x50\xfd\x48\xfd\x58\xfd\x44\xfd\x54\xfd\x4c\xfd\x5c\xdd\xae\xee\x50\x77\xaa\xbb\xd4\xdd\xea\x17\xea\x97\xea\x57\xea\xd7\xea\x1e\xf5\x1b\xf5\x5b\x75\xaf\xfa\x9d\xba\x4f\xdd\xaf\x1e\x50\x0f\xaa\xdf\xab\x3f\xa8\x3f\xaa\x3f\xa9\x3f\xab\xbf\xa8\xbf\xaa\xbf\xa9\xbf\xab\x4d\x6a\x4c\x63\x1a\x0f\x8e\x27\xd7\x54\x4d\xd3\x74\xcd\xd0\x4c\xcd\xd2\x12\xb4\x36\x5a\xa2\xd6\x56\x4b\xd2\x92\xb5\x14\x2d\x55\x6b\xa7\xb5\xd7\xd2\xb4\x0e\x5a\x47\xad\x93\xd6\x59\xeb\xa2\x75\xd5\xba\x69\xdd\xb5\x74\xad\x87\xd6\x53\xcb\xd0\x7a\x69\xbd\xb5\x3e\x5a\x5f\xad\x9f\xd6\x5f\x1b\xa0\x0d\xd4\x06\x69\x83\xb5\x21\xda\x50\x6d\x98\x36\x5c\x1b\xa1\x8d\xd4\x32\x35\x5b\x73\x34\x57\x0b\x69\x59\x5a\xb6\x96\xa3\xe5\x6a\xa3\xb4\xd1\xda\x18\xed\x18\x6d\xac\x76\xac\x96\xa7\xe5\x6b\x05\x5a\xa1\x56\xa4\x79\x9a\xaf\x8d\xd3\xc6\x6b\x13\xb4\xe3\xb4\x89\xda\x24\x6d\xb2\x36\x45\x9b\xaa\x4d\xd3\x8e\xd7\xa6\x6b\x33\xb4\x99\xda\x2c\x6d\xb6\x36\x47\x3b\x41\x2b\xd6\xe6\x6a\x27\x6a\xf3\xb4\xf9\xda\x49\xda\x02\x6d\xa1\x16\xd6\x16\x69\x25\x5a\xa9\x16\xd1\xca\xb4\x72\xad\x42\xab\xd4\x16\x6b\x4b\xb4\x2a\xad\x5a\xab\xd1\xa2\x5a\xad\xb6\x54\xab\xd3\xea\xb5\x06\xad\x51\x5b\xa6\x2d\xd7\x56\x68\x2b\xb5\x93\xb5\x55\xda\x29\xda\x6a\xed\x54\x6d\x8d\xb6\x56\x3b\x4d\x3b\x5d\x3b\x43\x3b\x53\x3b\x4b\x3b\x5b\x3b\x47\x3b\x57\x3b\x4f\xfb\x9b\x76\xbe\x76\x81\x76\xa1\x76\x91\x76\xb1\x76\x89\x76\xa9\x76\x99\x76\xb9\x76\x85\x76\xa5\x76\x95\x76\xb5\x76\x8d\x76\xad\x76\x9d\x76\xbd\x76\x83\x76\xa3\x76\x93\x76\xb3\x76\x8b\x76\xab\x76\x9b\x76\xbb\x76\x87\x76\xa7\x76\x97\x76\xb7\x76\x8f\xf6\x77\xed\x5e\xed\x3e\xed\x7e\xed\x1f\xda\x03\xda\x83\xda\x43\xda\xc3\xda\x23\xda\xa3\xda\x3a\xed\x31\xed\x71\xed\x09\xed\x49\xed\x9f\xda\x53\xda\xd3\xda\x33\xda\xb3\xda\x73\xda\xbf\xb4\x7f\x6b\xcf\x6b\x2f\x68\x2f\x6a\xeb\xb5\x97\xb4\x97\xb5\x57\xb4\x57\xb5\xd7\xb4\xff\x68\x1b\xb4\x8d\xda\xeb\xda\x1b\xda\x9b\xda\x5b\xda\xdb\xda\x26\x6d\xb3\xb6\x45\xdb\xaa\x6d\xd3\xde\xd1\xde\xd5\xde\xd3\xde\xd7\x3e\xd0\x3e\xd4\x3e\xd2\x3e\xd6\x3e\xd1\x3e\xd5\x3e\xd3\x3e\xd7\xb6\x6b\x3b\xb4\x9d\xda\x2e\x6d\xb7\xf6\x85\xf6\xa5\xf6\x95\xf6\xb5\xb6\x47\xfb\x46\xfb\x56\xdb\xab\x7d\xa7\xed\xd3\xf6\x6b\x07\xb4\x83\xda\xf7\xda\x0f\xda\x8f\xda\x4f\xda\xcf\xda\x2f\xda\xaf\xda\x6f\xda\xef\x5a\x93\x16\xd3\x99\xce\x75\x45\x0f\x8e\x3f\xd6\x74\x5d\x37\x74\x53\xb7\xf4\x04\xbd\x8d\x9e\xa8\xb7\xd5\x93\xf4\x64\x3d\x45\x4f\xd5\xdb\xe9\xed\xf5\x34\xbd\x83\xde\x51\xef\xa4\x77\xd6\xbb\xe8\x5d\xf5\x6e\x7a\x77\x3d\x5d\xef\xa1\xf7\xd4\x33\xf4\x5e\x7a\x6f\xbd\x8f\xde\x57\xef\xa7\xf7\xd7\x07\xe8\x03\xf5\x41\xfa\x60\x7d\x88\x3e\x54\x1f\xa6\x0f\xd7\x47\xe8\x23\xf5\x4c\xdd\xd6\x1d\xdd\xd5\x43\x7a\x96\x9e\xad\xe7\xe8\xb9\xfa\x28\x7d\xb4\x3e\x46\x3f\x46\x1f\xab\x1f\xab\xe7\xe9\xf9\x7a\x81\x5e\xa8\x17\xe9\x9e\xee\xeb\xe3\xf4\xf1\xfa\x04\xfd\x38\x7d\xa2\x3e\x49\x9f\xac\x4f\xd1\xa7\xea\xd3\xf4\xe3\xf5\xe9\xfa\x0c\x7d\xa6\x3e\x4b\x9f\xad\xcf\xd1\x4f\xd0\x8b\xf5\xb9\xfa\x89\xfa\x3c\x7d\xbe\x7e\x92\xbe\x40\x5f\xa8\x87\xf5\x45\x7a\x89\x5e\xaa\x47\xf4\x32\xbd\x5c\xaf\xd0\x2b\xf5\xc5\xfa\x12\xbd\x4a\xaf\xd6\x6b\xf4\xa8\x5e\xab\x2f\xd5\xeb\xf4\x7a\xbd\x41\x6f\xd4\x97\xe9\xcb\xf5\x15\xfa\x4a\xfd\x64\x7d\x95\x7e\x8a\xbe\x5a\x3f\x55\x5f\xa3\xaf\xd5\x4f\xd3\x4f\xd7\xcf\xd0\xcf\xd4\xcf\xd2\xcf\xd6\xcf\xd1\xcf\xd5\xcf\xd3\xff\xa6\x9f\xaf\x5f\xa0\x5f\xa8\x5f\xa4\x5f\xac\x5f\xa2\x5f\xaa\x5f\xa6\x5f\xae\x5f\xa1\x5f\xa9\x5f\xa5\x5f\xad\x5f\xa3\x5f\xab\x5f\xa7\x5f\xaf\xdf\xa0\xdf\xa8\xdf\xa4\xdf\xac\xdf\xa2\xdf\xaa\xdf\xa6\xdf\xae\xdf\xa1\xdf\xa9\xdf\xa5\xdf\xad\xdf\xa3\xff\x5d\xbf\x57\xbf\x4f\xbf\x5f\xff\x87\xfe\x80\xfe\xa0\xfe\x90\xfe\xb0\xfe\x88\xfe\xa8\xbe\x4e\x7f\x4c\x7f\x5c\x7f\x42\x7f\x52\xff\xa7\xfe\x94\xfe\xb4\xfe\x8c\xfe\xac\xfe\x9c\xfe\x2f\xfd\xdf\xfa\xf3\xfa\x0b\xfa\x8b\xfa\x7a\xfd\x25\xfd\x65\xfd\x15\xfd\x55\xfd\x35\xfd\x3f\xfa\x06\x7d\xa3\xfe\xba\xfe\x86\xfe\xa6\xfe\x96\xfe\xb6\xbe\x49\xdf\xac\x6f\xd1\xb7\xea\xdb\xf4\x77\xf4\x77\xf5\xf7\xf4\xf7\xf5\x0f\xf4\x0f\xf5\x8f\xf4\x8f\xf5\x4f\xf4\x4f\xf5\xcf\xf4\xcf\xf5\xed\xfa\x0e\x7d\xa7\xbe\x4b\xdf\xad\x7f\xa1\x7f\xa9\x7f\xa5\x7f\xad\xef\xd1\xbf\xd1\xbf\xd5\xf7\xea\xdf\xe9\xfb\xf4\xfd\xfa\x01\xfd\xa0\xfe\xbd\xfe\x83\xfe\xa3\xfe\x93\xfe\xb3\xfe\x8b\xfe\xab\xfe\x9b\xfe\xbb\xde\xa4\xc7\x0c\x66\x70\x23\x38\x78\x51\x35\x34\x43\x37\x0c\xc3\x34\x2c\x23\xc1\x68\x63\x24\x1a\x6d\x8d\x24\x23\xd9\x48\x31\x52\x8d\x76\x46\x7b\x23\xcd\xe8\x60\x74\x34\x3a\x19\x9d\x8d\x2e\x46\x57\xa3\x9b\xd1\xdd\x48\x37\x7a\x18\x3d\x8d\x0c\xa3\x97\xd1\xdb\xe8\x63\xf4\x35\xfa\x19\xfd\x8d\x01\xc6\x40\x63\x90\x31\xd8\x18\x62\x0c\x35\x86\x19\xc3\x8d\x11\xc6\x48\x23\xd3\xb0\x0d\xc7\x70\x8d\x90\x91\x65\x64\x1b\x39\x46\xae\x31\xca\x18\x6d\x8c\x31\x8e\x31\xc6\x1a\xc7\x1a\x79\x46\xbe\x51\x60\x14\x1a\x45\x86\x67\xf8\xc6\x38\x63\xbc\x31\xc1\x38\xce\x98\x68\x4c\x32\x26\x1b\x53\x8c\xa9\xc6\x34\xe3\x78\x63\xba\x31\xc3\x98\x69\xcc\x32\x66\x1b\x73\x8c\x13\x8c\x62\x63\xae\x71\xa2\x31\xcf\x98\x6f\x9c\x64\x2c\x30\x16\x1a\x61\x63\x91\x51\x62\x94\x1a\x11\xa3\xcc\x28\x37\x2a\x8c\x4a\x63\xb1\xb1\xc4\xa8\x32\xaa\x8d\x1a\x23\x6a\xd4\x1a\x4b\x8d\x3a\xa3\xde\x68\x30\x1a\x8d\x65\xc6\x72\x63\x85\xb1\xd2\x38\xd9\x58\x65\x9c\x62\xac\x36\x4e\x35\xd6\x18\x6b\x8d\xd3\x8c\xd3\x8d\x33\x8c\x33\x8d\xb3\x8c\xb3\x8d\x73\x8c\x73\x8d\xf3\x8c\xbf\x19\xe7\x1b\x17\x18\x17\x1a\x17\x19\x17\x1b\x97\x18\x97\x1a\x97\x19\x97\x1b\x57\x18\x57\x1a\x57\x19\x57\x1b\xd7\x18\xd7\x1a\xd7\x19\xd7\x1b\x37\x18\x37\x1a\x37\x19\x37\x1b\xb7\x18\xb7\x1a\xb7\x19\xb7\x1b\x77\x18\x77\x1a\x77\x19\x77\x1b\xf7\x18\x7f\x37\xee\x35\xee\x33\xee\x37\xfe\x61\x3c\x60\x3c\x68\x3c\x64\x3c\x6c\x3c\x62\x3c\x6a\xac\x33\x1e\x33\x1e\x37\x9e\x30\x9e\x34\xfe\x69\x3c\x65\x3c\x6d\x3c\x63\x3c\x6b\x3c\x67\xfc\xcb\xf8\xb7\xf1\xbc\xf1\x82\xf1\xa2\xb1\xde\x78\xc9\x78\xd9\x78\xc5\x78\xd5\x78\xcd\xf8\x8f\xb1\xc1\xd8\x68\xbc\x6e\xbc\x61\xbc\x69\xbc\x65\xbc\x6d\x6c\x32\x36\x1b\x5b\x8c\xad\xc6\x36\xe3\x1d\xe3\x5d\xe3\x3d\xe3\x7d\xe3\x03\xe3\x43\xe3\x23\xe3\x63\xe3\x13\xe3\x53\xe3\x33\xe3\x73\x63\xbb\xb1\xc3\xd8\x69\xec\x32\x76\x1b\x5f\x18\x5f\x1a\x5f\x19\x5f\x1b\x7b\x8c\x6f\x8c\x6f\x8d\xbd\xc6\x77\xc6\x3e\x63\xbf\x71\xc0\x38\x68\x7c\x6f\xfc\x60\xfc\x68\xfc\x64\xfc\x6c\xfc\x62\xfc\x6a\xfc\x66\xfc\x6e\x34\x19\x31\x93\xb1\x47\xd8\xa3\x26\x37\x15\x53\xb0\xc7\xd9\x13\x6c\xbd\xa9\xb2\x75\xec\x31\xf6\x92\xa9\xb1\xd3\xd9\x0b\xec\x1c\x76\x9f\xa9\x9b\x86\x69\x9a\x96\x99\x60\xb6\x61\x2f\x9b\x89\x66\x5b\x33\x89\x3d\xc7\xfe\x65\x26\x9b\x29\xec\x19\x33\xd5\x6c\x67\xb6\x37\xd3\xcc\x0e\x66\x47\xb3\x93\xd9\xd9\xec\x62\x76\x35\xbb\x99\xdd\xcd\x74\xb3\x87\xd9\xd3\xcc\x30\x7b\x99\xbd\xcd\x3e\x66\x5f\xf6\xa3\xd9\xcf\xec\x6f\x0e\x30\x07\x9a\x83\xcc\xc1\xe6\x10\x73\xa8\x39\xcc\x1c\x6e\x8e\x30\x47\x9a\x99\xa6\x6d\x3a\xa6\x6b\x86\xcc\x2c\x33\xdb\xcc\x31\x73\xcd\x51\xe6\x68\x76\x81\x39\xc6\x3c\xc6\x1c\x6b\x1e\x6b\xe6\x99\xf9\x66\x81\x59\x68\x16\x99\x9e\xe9\x9b\xe3\xcc\xf1\xe6\x04\xf3\x38\x73\xa2\x39\xc9\x9c\xcc\xae\x31\xa7\xb0\xeb\xd8\xb5\x6c\xaf\x39\x95\xbd\xc8\xee\x64\x97\x99\xd3\xcc\xe3\xd9\x0d\xec\x6e\x76\xb1\x39\x9d\x5d\xc1\xae\x34\x67\x98\x33\xcd\x59\xe6\x6c\x73\x8e\x79\x82\x59\x6c\xce\x35\x4f\x34\xe7\x99\xf3\xcd\x93\xcc\x05\xe6\x42\x33\x6c\x2e\x32\x4b\xcc\x52\x33\x62\x96\x99\xe5\x66\x85\x59\x69\x2e\x36\x97\x98\x55\x66\xb5\x59\x63\x46\xcd\x5a\x73\xa9\x59\x67\xd6\x9b\x0d\x66\xa3\xb9\xcc\x5c\x6e\xae\x30\x57\x9a\x27\x9b\xab\xcc\x53\xcc\xd5\xe6\xa9\xe6\x1a\x73\xad\x79\x9a\x79\xba\x79\x86\x79\xa6\x79\x96\x79\xb6\x79\x8e\x79\xae\x79\x9e\xf9\x37\xf3\x7c\xf3\x02\xf3\x42\xf3\x22\xf3\x62\xf6\x4f\xf3\x12\xf3\x52\xf3\x32\xf3\x72\xf3\x0a\xf3\x4a\xf3\x2a\xf3\x6a\xf3\x1a\xf3\x5a\xf3\x3a\xf3\x7a\xf3\x06\xf3\x46\xf3\x26\xf3\x66\xf3\x16\xf3\x56\xf3\x36\xf3\x76\xf3\x0e\xf3\x4e\xf3\x2e\xf3\x6e\xf3\x1e\xf3\xef\xe6\xbd\xe6\x7d\xe6\xfd\xe6\x3f\xcc\x07\xcc\x07\xcd\x87\xcc\x87\xcd\x47\xcc\x47\xcd\x75\xe6\x63\xe6\xe3\xe6\x13\xe6\x93\xe6\x3f\xcd\xa7\xcc\xa7\xcd\x67\xcc\x67\xcd\xe7\xcc\x7f\x99\xff\x36\x9f\x37\x5f\x30\x5f\x34\xd7\x9b\x2f\x99\x2f\x9b\xaf\x98\xaf\xb2\x7f\xb3\xe7\xcd\xd7\xcc\xff\x98\x1b\xcc\x8d\xe6\xeb\xe6\x1b\xe6\x9b\xe6\x5b\xe6\xdb\xe6\x26\x73\xb3\xb9\xc5\xdc\x6a\x6e\x33\xdf\x31\xdf\x35\xdf\x33\xdf\x37\x3f\x30\x3f\x34\x3f\x32\x3f\x36\x3f\x31\x3f\x35\x3f\x33\x3f\x37\xb7\x9b\x3b\xcc\x9d\xe6\x2e\x73\xb7\xf9\x85\xf9\xa5\xf9\x95\xf9\xb5\xb9\xc7\xfc\xc6\xfc\xd6\xdc\x6b\x7e\x67\xee\x33\xf7\x9b\x07\xcc\x83\xe6\xf7\xe6\x0f\xe6\x8f\xe6\x4f\xe6\xcf\xe6\x2f\xe6\xaf\xe6\x6f\xe6\xef\x66\x93\x19\xb3\x98\xc5\x2d\xc5\x12\x96\x6a\x69\x96\x6e\x19\x96\x69\x59\x56\x82\xd5\xc6\x4a\xb4\xda\x5a\x49\x56\xb2\x95\x62\xa5\x5a\xed\xac\xf6\x56\x9a\xd5\xc1\xea\x68\x75\xb2\x3a\x5b\x5d\xac\xae\x56\x37\xab\xbb\x95\x6e\xf5\xb0\x7a\x5a\x19\x56\x2f\xab\xb7\xd5\xc7\xea\x6b\xf5\xb3\xfa\x5b\x03\xac\x81\xd6\x20\x6b\xb0\x35\xc4\x1a\x6a\x0d\xb3\x86\x5b\x23\xac\x91\x56\xa6\x65\x5b\x8e\xe5\x5a\x21\x2b\xcb\xca\xb6\x72\xac\x5c\x6b\x94\x35\xda\x1a\x63\x1d\x63\x8d\xb5\x8e\xb5\xf2\xac\x7c\xab\xc0\x2a\xb4\x8a\x2c\xcf\xf2\xad\x71\xd6\x78\x6b\x82\x75\x9c\x35\xd1\x9a\x64\x4d\xb6\xa6\x58\x53\xad\x69\xd6\xf1\xd6\x74\x6b\x86\x35\xd3\x9a\x65\xcd\xb6\xe6\x58\x27\x58\xc5\xd6\x5c\xeb\x44\x6b\x9e\x35\xdf\x3a\xc9\x5a\x60\x2d\xb4\xc2\xd6\x22\xab\xc4\x2a\xb5\x22\x56\x99\x55\x6e\x55\x58\x95\xd6\x62\x6b\x89\x55\x65\x55\x5b\x35\x56\xd4\xaa\xb5\x96\x5a\x75\x56\xbd\xd5\x60\x35\x5a\xcb\xac\xe5\xd6\x0a\x6b\xa5\x75\xb2\xb5\xca\x3a\xc5\x5a\x6d\x9d\x6a\xad\xb1\xd6\x5a\xa7\x59\xa7\x5b\x67\x58\x67\x5a\x67\x59\x67\x5b\xe7\x58\xe7\x5a\xe7\x59\x7f\xb3\xce\xb7\x2e\xb0\x2e\xb4\x2e\xb2\x2e\xb6\x2e\xb1\x2e\xb5\x2e\xb3\x2e\xb7\xae\xb0\xae\xb4\xae\xb2\xae\xb6\xae\xb1\xae\xb5\xae\xb3\xae\xb7\x6e\xb0\x6e\xb4\x6e\xb2\x6e\xb6\x6e\xb1\x6e\xb5\x6e\xb3\x6e\xb7\xee\xb0\xee\xb4\xee\xb2\xee\xb6\xee\xb1\xfe\x6e\xdd\x6b\xdd\x67\xdd\x6f\xfd\xc3\x7a\xc0\x7a\xd0\x7a\xc8\x7a\xd8\x7a\xc4\x7a\xd4\x5a\x67\x3d\x66\x3d\x6e\x3d\x61\x3d\x69\xfd\xd3\x7a\xca\x7a\xda\x7a\xc6\x7a\xd6\x7a\xce\xfa\x97\xf5\x6f\xeb\x79\xeb\x05\xeb\x45\x6b\xbd\xf5\x92\xf5\xb2\xf5\x8a\xf5\xaa\xf5\x9a\xf5\x1f\x6b\x83\xb5\xd1\x7a\xdd\x7a\xc3\x7a\xd3\x7a\xcb\x7a\xdb\xda\x64\x6d\xb6\xb6\x58\x5b\xad\x6d\xd6\x3b\xd6\xbb\xd6\x7b\xd6\xfb\xd6\x07\xd6\x87\xd6\x47\xd6\xc7\xd6\x27\xd6\xa7\xd6\x67\xd6\xe7\xd6\x76\x6b\x87\xb5\xd3\xda\x65\xed\xb6\xbe\xb0\xbe\xb4\xbe\xb2\xbe\xb6\xf6\x58\xdf\x58\xdf\x5a\x7b\xad\xef\xac\x7d\xd6\x7e\xeb\x80\x75\xd0\xfa\xde\xfa\xc1\xfa\xd1\xfa\xc9\xfa\xd9\xfa\xc5\xfa\xd5\xfa\xcd\xfa\xdd\x6a\xb2\x62\x09\x2c\x81\x27\x28\x09\x22\x41\x4d\xd0\x12\xf4\x04\x23\xc1\x4c\xb0\x12\x12\x12\xda\x24\x24\x26\xb4\x4d\x48\x4a\x48\x4e\x48\x49\x48\x35\x1a\x6b\x2a\x47\x8e\xcc\x1f\x89\xb4\xc8\x8a\x2e\x8b\xd4\xd5\x97\x44\xeb\x22\xa2\xba\x31\x53\xaf\xae\x2c\x2d\x8d\x36\x18\xf9\xd5\xc1\x7b\xca\x35\x46\x38\x9e\xea\xf9\x8b\xea\x22\xcb\x22\x7a\x58\x26\x46\x7e\xb4\x3c\x5a\x13\x59\x62\x84\xe3\x69\x9b\xc2\x92\xca\xba\x92\xc6\xea\xb2\xaa\xc8\x8a\x36\x25\x87\xf2\x09\x85\xd4\x54\xb8\xa4\x24\x52\xd3\x90\x50\xd2\x92\xd5\x8b\x4a\xc2\x41\x93\xa5\xf1\xa4\x88\xda\x0f\x37\x18\x1e\x00\x23\x00\xf4\xe2\x80\x11\x99\x24\x78\x87\x1a\x8a\xb4\x64\x0d\x0f\x6a\x44\xe2\xa9\xee\xc5\x5b\x8c\xc8\xa4\xcd\xb8\x56\x4a\x95\xb7\x52\x6a\xdc\xa1\xb6\xca\x5b\xb2\x89\xe3\x4a\xa2\xd5\xd5\x61\xbc\x28\x6f\xf5\xa2\xcd\xf8\x56\xed\x54\x1c\xca\xab\xe3\x17\x85\xeb\xd4\x0a\x12\xfa\x84\x86\xca\xaa\xd2\x88\x5e\x29\x13\x63\x02\x7a\x52\x89\x9e\x4c\x88\xf7\xa4\x32\x6e\xba\x09\xd0\xb9\x32\x9e\x2a\x13\x8e\x53\x2a\x17\xb7\x39\xae\x15\xc6\xe2\x43\xf9\xc4\x89\xad\xb5\x5a\x72\xd8\x8b\xf2\xe0\x23\x8a\xaa\x70\x4d\x69\x65\x89\x3e\x29\x5c\xd2\xd8\x10\xd1\xab\x64\x92\x38\xa9\x75\xbd\xaa\x56\x2f\xf4\x49\x71\x03\x55\xc9\x44\x9d\x44\xbd\x57\xab\x48\xe8\x53\xe2\xf7\xd7\xc4\xef\x9f\xd2\xfa\xfe\x9a\xd6\xf7\x4f\x89\xdf\x5f\x13\x37\x70\x4d\xb8\x36\x5a\xdf\x50\x17\xad\xad\x88\x08\xaf\xa6\x5c\x44\x6a\xca\x8d\xa9\xe8\x7c\x14\x9d\x9f\x1a\xef\x7c\x54\x26\x6d\xa7\x56\x34\xd6\x94\x87\xeb\x1a\xab\xab\xc2\x8d\x0d\x6d\xa3\xad\x5f\xe9\xd3\xe3\x3a\xd4\xc5\x75\x98\xde\x5a\x87\xba\xd6\x3a\x4c\x8f\xeb\x50\x17\x4f\x66\xc4\xef\xaa\x97\x49\x9b\x19\xad\xcc\x58\xdf\xca\x8c\x33\x5b\xb7\xd6\xd0\xba\xb5\x99\xf1\x66\x1a\xe2\x16\x99\x19\x0c\x69\x43\x30\xa4\xb3\xe2\x43\xda\x18\x1f\xd2\x59\xe8\x55\x23\x7a\x35\x2b\xde\xab\x46\x99\x68\xb3\xea\x2a\x6b\xca\xb5\xc6\x40\xb6\x9d\x75\x58\x0f\x1b\x5b\xbf\x32\x66\x61\xe8\x1b\xb1\x6a\xe6\xb4\xd2\x76\x79\xab\x7c\x71\xab\xfc\xca\x43\x79\x7d\x6e\xbc\xaf\x27\xcb\x24\x61\xee\xa1\x69\x7c\x72\x4b\x56\xab\x8a\xd6\x94\xd7\xcb\xa5\x9d\x99\x33\x12\x69\x26\x52\x1b\xa9\x83\xd4\x45\x1a\x42\x9a\x85\x34\x1b\x69\x0e\xd2\x5c\xa4\xf9\x48\x0b\x90\x16\x22\x2d\x42\xea\x21\xf5\xe3\x69\x2e\xf0\x73\x81\x9f\x0b\xdc\x5c\xe0\xe6\x02\x37\x17\xb8\xb9\xc0\xcd\x05\x6e\x2e\x70\x73\x81\x9b\x0b\xdc\x5c\xe0\xe6\x02\x37\x17\xb8\xb9\xbe\x36\xb5\x22\x5a\x47\x81\x66\x20\xe3\x65\xf9\xe8\x73\x3e\xb0\xf3\x81\x9d\x0f\xec\x7c\x60\xe7\x03\x3b\x1f\xd8\xf9\xc0\xce\x07\x76\x3e\xb0\xf3\x81\x9d\x0f\xec\x7c\x4f\x9b\x25\x31\x1b\x0f\x61\x16\xa0\xbf\x05\xc0\x2e\x00\x76\x01\xb0\x0b\x80\x5d\x00\xec\x02\x60\x17\x00\xbb\x00\xd8\x05\xc0\x2e\x00\x76\x01\xb0\x0b\x80\x5d\x80\x7e\x17\xc0\xde\x85\xb0\x77\x21\xf0\x0b\x81\x5f\x08\xfc\x42\xe0\x17\x02\xbf\x10\xf8\x85\xc0\x2f\x04\x7e\x21\xf0\x0b\x81\x5f\x08\xfc\x42\xe0\x17\x02\xbf\x10\xf8\x85\xc0\x2f\x02\x7e\x11\xf0\x8b\x80\x5f\x04\xfc\x22\xe0\x17\x01\xbf\x08\xf8\x45\xc0\x2f\x02\x7e\x11\xf0\x8b\x80\x5f\x04\xfc\x22\xe0\x17\x01\xbf\x08\xf8\x45\xc0\xf7\x80\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x80\xef\x01\xdf\x03\xbe\x07\x7c\x0f\xf8\x1e\xf0\x3d\xe0\x7b\xc0\xf7\x81\xef\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xc0\xf7\x81\xef\xe7\x26\xe4\x07\x7b\x49\x7c\x99\x87\x5b\xb2\x46\xbe\x17\x4f\xc3\x91\xf8\x6e\x37\xb5\xbe\x2a\x5c\x5f\x11\xcf\x47\x0f\xe5\x65\x2b\xf6\xc8\x91\x48\x33\x91\xda\x48\x1d\xa4\x2e\xd2\x10\xd2\x2c\xa4\xd9\x48\x73\x90\xe6\x22\xcd\x47\x5a\x80\xb4\x10\x69\x11\x52\x0f\x69\xdc\x1a\x76\x26\xf0\x33\x81\x9f\x09\xfc\x4c\xe0\x67\x02\x3f\x13\xf8\x99\xc0\xcf\xcc\x4e\x9c\xd1\x7a\xb7\xae\x6f\xf5\x02\x35\xa0\x49\x26\x34\xc9\x84\x26\x99\xd0\x24\x13\x9a\x64\x42\x13\x1b\x9a\xd8\xd0\xc4\x86\x26\x36\x34\xb1\xa1\x89\x0d\x4d\x6c\x68\x62\xc3\x12\x36\x2c\x61\xc3\x12\x36\xf0\x6d\xe0\xdb\xc0\xb7\x81\x6f\x03\xdf\x06\xbe\x03\x7c\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x64\x59\x8b\x87\xd3\x8e\x5e\x15\xa9\xaf\x47\x09\x34\x70\xa0\x81\x03\x0d\x1c\x68\xe0\x40\x03\x07\x1a\x38\xd0\xc0\x81\x06\x2e\x34\x70\xa1\x81\x0b\x0d\x5c\x68\xe0\x42\x03\x17\x1a\xb8\xb0\x80\x0b\x0b\xb8\xc0\x77\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x21\xe0\x87\x80\x1f\x02\x7e\x08\xf8\x21\xe0\x67\x01\x3f\x0b\xf8\x59\xc0\xcf\x02\x7e\x16\xf0\xb3\x80\x9f\x05\xfc\x2c\xe0\x67\x01\x3f\x0b\xf8\x59\xc0\xcf\x02\x7e\x16\xf0\xb3\x80\x9f\x05\xfc\x2c\xe0\x67\x03\x3f\x1b\xf8\xd9\xc0\xcf\x06\x7e\x36\xf0\xb3\x81\x9f\x0d\xfc\x6c\xe0\x67\x03\x3f\x1b\xf8\xd9\xc0\xcf\x06\x7e\x36\xf0\xb3\x81\x9f\x0d\xfc\x6c\xe0\xc3\x13\xb0\xe1\x09\xd8\xf0\x04\x6c\x78\x02\x36\x3c\x01\x1b\x9e\x80\x0d\x4f\xc0\x86\x27\x60\xc3\x13\xb0\xe1\x09\xd8\xf0\x04\x6c\x78\x02\x36\x3c\x01\x1b\x9e\x80\x0d\x4f\xc0\x86\x27\x60\xc3\x13\xb0\xe1\x09\xd8\xb9\xc0\x87\x47\x60\xc3\x23\xb0\xe1\x11\xd8\xf0\x08\x6c\x78\x04\x36\x3c\x02\x1b\x1e\x81\x0d\x8f\xc0\x86\x47\x60\xc3\x23\xb0\xe1\x11\xd8\xf0\x08\xec\x5c\xe0\x23\xd8\xb1\xf3\x81\x0f\xaf\xc0\x86\x57\x60\xc3\x2b\xb0\xe1\x15\xd8\xf0\x0a\x6c\x78\x05\x36\xbc\x02\x1b\x5e\x81\x0d\xaf\xc0\x86\x57\x60\xc3\x2b\xb0\xe1\x15\xd8\xf9\xc0\xcf\x07\x7e\x01\xf0\xe1\x19\xd8\xf0\x0c\x6c\x78\x06\x36\x3c\x03\x1b\x9e\x81\x0d\xcf\xc0\x86\x67\x60\xc3\x33\xb0\xe1\x19\xd8\xf0\x0c\x6c\x78\x06\x36\x3c\x03\x1b\x9e\x81\x0d\xcf\xc0\x86\x67\x60\xc3\x33\xb0\xe1\x19\xd8\xf0\x0c\x6c\x78\x06\x36\x3c\x03\x1b\x9e\x81\x0d\x4f\xc0\x86\x07\x60\xc3\x03\xb0\xe1\x01\xd8\xf0\x00\x6c\x78\x00\x36\x3c\x00\x1b\x1e\x80\x0d\x0f\xc0\x86\x07\x60\xc3\x03\xb0\xe1\x01\xd8\xf0\x00\x6c\x78\x00\x36\x3c\x00\x1b\x8c\x6e\x83\xd1\x6d\x30\xba\x0d\x46\xb7\xc1\xe8\x36\x18\xdd\x06\xa3\xdb\x60\x74\x1b\x8c\x6e\x83\xd1\x6d\x30\xba\x0d\x46\xb7\xc1\xe8\x36\x18\xdd\x06\xa3\xdb\x60\x74\x1b\x8c\x6e\x83\xd1\x6d\x30\xba\x0d\x46\xb7\xc1\xe8\x36\x18\xdd\x06\xa3\xdb\x60\x74\x1b\x8c\x6e\x83\xd1\x6d\x30\xba\xed\x03\xdf\x07\xbe\x0f\x7c\x1f\xf8\x3e\xf0\x7d\xe0\xfb\xbe\x55\x5e\x17\x5e\x16\x21\xea\x5b\x64\x49\x4e\x0f\x72\xf2\x9a\x33\xd2\xb6\x64\x4c\xd2\xaa\xc4\x45\x1a\x42\x9a\x85\x34\x1b\x69\x4e\xdb\x8a\x68\x74\x49\x78\x51\x74\x59\xeb\xbb\xf2\x91\x16\x20\x2d\x44\x5a\x84\xd4\x43\x1a\xb7\x85\x03\x3e\x77\xc0\xe7\x0e\xf8\xdc\x01\x9f\x3b\xe0\x73\x07\x7c\xee\x80\xcf\x9d\x4c\x68\x91\x99\x83\x34\x17\x29\xf0\xc1\xe2\x0e\x58\xdc\x01\x8b\x3b\x60\x71\x07\x2c\xee\x80\xc5\x1d\xb0\xb8\x63\xdb\x89\xc4\x91\x8b\x22\x55\xd1\xe5\x87\x3a\x05\x2a\x77\x40\xe5\x0e\xa8\xdc\x01\x95\x3b\xa0\x72\x07\x54\xee\x80\xca\x1d\x50\xb9\x03\x2a\x77\x40\xe5\x0e\xa8\xdc\x01\x95\x3b\xa0\x72\x07\x54\xee\x80\xca\x1d\x50\xb9\x03\x2a\x77\x40\xe5\x8e\x03\x7c\x07\xf8\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x72\x07\x44\xee\x80\xc8\x1d\x10\xb9\x03\x22\x77\x40\xe4\x0e\x88\xdc\x01\x91\x3b\x20\x6a\x07\x44\xed\x80\x88\x1d\x10\xb1\x03\x22\x76\x40\xc4\x4e\xb6\xa7\x35\x44\x6b\xa2\xf5\x6d\x4b\x2b\x23\x75\x91\xfa\xca\x7a\xf9\x2a\x21\xbf\xaa\xb6\x22\x2c\xb3\x56\xb8\x26\xda\x10\xa9\x8a\x54\x86\x13\xbd\xda\xfa\x4a\x8a\xde\x65\xb1\xe9\x35\xe0\xfa\x84\x28\x72\x89\x53\xab\x2b\x83\xf7\x1e\xe2\x2f\x66\xb5\xaa\x9c\x30\xb5\x3a\x52\x1e\xaf\x94\x5a\x49\xd5\x0f\xc3\xd2\x24\x96\x5a\x10\x69\x08\x6b\xe3\xc2\xe4\x49\x1b\xc0\x51\xe7\x52\x91\x20\x1c\x6d\x66\x05\xe5\xd4\x00\x48\x9b\x18\xae\xad\x0d\xeb\x93\xc2\xd5\x8b\x4a\xc3\xca\xe4\x46\x65\x4a\xa3\x72\x42\xa5\x01\x64\x65\x5a\xa5\x98\x5e\x11\xd5\x66\x54\x96\x57\x87\xc5\xcc\x70\xa3\x01\x2d\xc4\xb4\x8a\x4a\x51\x48\x7f\xd3\xea\x2b\x13\x27\xb4\xd2\x20\x19\x15\x9a\x5f\x27\x84\x5b\x3a\x9e\x18\x69\xdd\xdd\x48\x73\x77\x2b\x9b\xbb\x9b\xd6\x78\xf8\xad\xf1\xce\xc8\xfb\xd5\x45\x41\x67\xca\x83\xce\x68\xa5\x91\xaa\x86\xb0\x81\xb6\xd4\x93\x83\x2e\x05\x17\x1b\x64\x97\x82\xc6\xb4\x25\xb2\x4b\x55\xf1\x2e\xd5\x34\x2a\x2b\x2a\x8d\x68\xbc\x3f\xa2\xae\x22\xaa\xd7\x07\x9d\xc9\xd4\x64\x22\x1a\xa8\x4f\xc0\x15\xb5\xd4\x9f\x12\xfa\xa3\x97\x5a\x34\x30\x70\x62\x6b\xdb\x26\x1f\xa1\x5e\x62\xb4\xf5\xe8\x34\xb6\x1e\x9d\x68\xcb\xe8\xc4\xe7\x04\x48\xd2\x01\x49\x3a\x20\x49\x07\x24\xe9\x80\x24\x1d\x90\xa4\x03\x92\x74\x40\x92\x0e\xc2\x64\x07\x61\xb2\x83\x30\xd9\x41\x98\xec\x20\x4c\x76\x10\x26\x3b\x20\x55\x07\xa4\xea\x80\x54\x1d\x90\xaa\x03\x52\x75\x40\xaa\x0e\x48\xd5\x01\xa9\x3a\x20\x55\x07\xa4\xea\x80\x54\x1d\x90\xaa\x03\x52\x75\x40\xaa\x0e\x48\xd5\x01\xa9\x3a\x20\x55\x07\xa4\xea\x80\x54\x1d\x90\xaa\x03\x52\x75\x40\xaa\x0e\x48\xd5\x01\xa9\x3a\x20\x55\x07\xa4\xea\x80\x54\x1d\x90\xaa\x03\x52\x75\x40\xaa\x0e\x48\xd5\x01\xa9\x3a\x20\x55\xc7\x8f\xe3\xbb\x08\x8c\x5d\x04\xc6\x2e\x02\x63\x17\x81\xb1\x0b\x3a\x75\x41\xa7\x2e\xe8\xd4\x05\x9d\xba\x08\x8c\x5d\x04\xc6\x2e\x88\xd4\x05\x91\xba\x20\x52\x17\x44\xea\x82\x48\x5d\x10\xa9\x0b\x22\x75\x41\xa4\x2e\x88\xd4\x05\x91\xba\x20\x52\x17\x44\xea\x82\x48\x5d\x10\xa9\x0b\x22\x75\x41\xa4\x2e\x88\xd4\x05\x91\xba\x20\x52\x17\x44\xea\x82\x48\x5d\x10\xa9\x0b\x22\x75\x41\xa4\x2e\xc2\x61\x17\xe1\xb0\x0b\x0e\x75\xc1\xa1\x2e\x38\xd4\x05\x87\xba\xe0\x50\x17\x1c\xea\x82\x43\x5d\x70\xa8\x0b\x0e\x75\xc1\xa1\x2e\x38\xd4\x05\x87\xba\xe0\x50\x17\x1c\xea\x82\x43\x5d\x70\xa8\x0b\x0e\x75\xc1\xa1\x2e\x38\xd4\x05\x87\xba\xe0\x50\x17\x1c\xea\x82\x43\x5d\x70\xa8\x0b\x0e\x75\xc1\xa1\x2e\x38\xd4\x05\x87\xba\xe0\x50\x17\x1c\xea\x82\x43\x5d\x70\xa8\x0b\x0e\x75\xc1\xa1\x2e\x38\xd4\x05\x87\xba\xe0\x50\x17\x1c\xea\x82\x43\x5d\x70\xa8\x0b\x0e\x75\xc1\xa1\x2e\x38\xd4\x05\x87\xba\xe0\x50\x17\x1c\xea\x82\x43\x5d\x70\xa8\x0b\x0e\x75\xc1\xa1\x2e\x38\xd4\x05\x87\xba\xe0\x50\x17\x1c\xea\x82\x43\x5d\x70\xa8\x0b\x0e\x75\xc1\xa1\x2e\x38\xd4\x05\x87\xba\xe0\x50\x17\x1c\xea\x82\x43\x5d\x70\xa8\x0b\x0e\x75\xc1\xa1\x2e\x38\xd4\x05\x87\xba\xe0\x50\x17\x1c\xea\x82\x43\x5d\x70\xa8\x0b\x0e\x75\xc1\xa1\x2e\x38\xd4\x05\x87\xba\x08\x86\x5d\x04\xc3\x2e\x82\x61\x17\xc1\xb0\x0b\x8e\x75\xc1\xb1\x2e\x82\x61\x17\xc1\xb0\x8b\x60\xd8\x45\x30\xec\x82\x83\x5d\x70\xb0\x0b\x0e\x76\xc1\xc1\x2e\x82\x61\x17\xc1\xb0\x8b\x60\xd8\x45\x30\xec\x22\x18\x76\x11\x0c\xbb\x08\x86\x5d\x04\xc3\x2e\x82\x61\x17\xc1\xb0\x8b\x60\xd8\x45\x30\xec\x22\x18\x76\x11\x0c\xbb\x08\x86\x5d\x04\xc3\x2e\x82\x61\x17\xc1\xb0\x8b\x60\xd8\x45\x30\xec\x22\x18\x76\x11\x0c\xbb\x08\x86\x5d\x04\xc3\x2e\x82\x61\x17\xc1\xb0\x8b\x60\xd8\x45\x30\xec\x22\x18\x76\x11\x0c\xbb\x08\x86\x5d\x04\xc3\x2e\x82\x61\x17\xc1\xb0\x8b\x60\xd8\x45\x30\xec\x22\x18\x76\x11\x0c\xbb\x08\x86\x5d\x04\xc3\x2e\x82\x61\x17\xc1\xb0\x8b\x60\xd8\x45\x30\xec\x22\x18\x76\x11\x0c\xbb\x08\x86\x5d\x04\xc3\x2e\x82\x61\x17\xc1\xb0\x8b\x60\xd8\x45\x30\xec\x22\x18\x76\x11\x0c\xbb\x08\x86\x5d\x04\xc3\x2e\x82\x61\x17\xc1\xb0\x8b\x60\xd8\x45\x30\xec\x22\x18\x76\x11\x0c\xbb\x08\x86\x5d\x04\xc3\x2e\x82\x61\x17\xc1\xb0\x8b\x60\xd8\x45\x30\xec\x22\x18\x76\x11\x0c\xbb\x08\x86\x5d\x04\xc3\x2e\xde\x26\x77\xf1\x36\xb9\x8b\xe0\xd8\xc5\xdb\xe4\x2e\x82\x64\x17\x41\xb2\x8b\x20\xd9\x45\x90\xec\x22\x48\x76\x11\x24\xbb\xe0\x7f\x17\xfc\xef\x82\xff\x5d\xf0\xbf\x0b\xfe\x77\xc1\xff\x2e\xf8\xdf\x05\xff\xbb\x45\x39\x56\xb8\xac\xb2\x32\x73\x64\x4e\xf3\xce\x04\x0f\xc0\x85\x07\xe0\xc2\x03\x70\xe1\x01\xb8\xf0\x00\x5c\x78\x00\x2e\x3c\x00\x17\x1e\x80\x0b\x0f\xc0\x85\x07\xe0\xc2\x03\x70\xe1\x01\xb8\xf0\x00\x5c\x78\x00\x2e\x3c\x00\x17\x1e\x80\x0b\x0f\xc0\x85\x07\xe0\xc2\x03\x70\xe1\x01\xb8\xf0\x00\x5c\x78\x00\x2e\x3c\x00\x17\x1e\x80\x0b\x0f\xc0\x85\x07\xe0\xc2\x03\x70\xe1\x01\xb8\xf0\x00\x5c\x78\x00\x2e\x3c\x00\x17\x1e\x80\x0b\x0f\xc0\x85\x07\xe0\xc2\x03\x70\xe1\x01\xb8\xf0\x00\x5c\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x78\x00\x21\x30\x7a\x08\x8c\x1e\x02\xa3\x87\xc0\xe8\x21\xec\x1c\x21\xec\x1c\x21\xec\x1c\x21\xec\x1c\x21\xec\x1c\x21\xec\x1c\x21\xec\x1c\x21\xec\x1c\x21\xec\x1c\x21\xec\x1c\x21\xec\x1c\x21\xec\x1c\xa1\xdc\x66\x1c\xe8\x8d\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x84\x9d\x23\x94\xef\x6b\xf5\x15\x91\x65\xe1\x04\x8a\x1d\xc2\x65\xf5\x91\xf2\x68\x55\x3c\x5b\x4b\xa2\xa2\x8d\xcc\x2e\x0d\x57\x87\x1b\xea\xb5\x8a\xca\xba\xca\xa5\x5a\x43\x3d\x79\xe5\x9a\xac\xa8\xc9\x3a\x7a\xf3\xe5\x28\x05\x02\xf1\x46\x0b\xf2\xf5\xa5\x8d\x8b\x1a\x1b\xea\xf5\xd2\x70\x79\xa4\xbe\x42\xab\x8e\x34\x44\xca\xb5\xea\xf0\xd2\x70\x99\x5a\x17\x2e\x8b\xd0\x9d\xf5\x91\xa5\x46\xf0\xac\x61\xf0\x11\x79\xbd\x4c\xcc\xfa\x28\xa1\xd6\x37\x2e\xb5\x1a\x6b\x6b\x23\x75\x0b\x82\xa2\xaa\xe8\xf2\x48\x5d\xf0\x9d\x09\xd9\x6e\x61\x56\x9b\x38\xd8\x52\x02\xae\x51\xc3\x55\x91\x32\x41\x01\x8b\x56\x5e\x59\x1d\xa9\xd2\x4a\xe9\x75\x83\x52\x11\x11\xcb\xc2\xcb\xb4\x93\xc3\x2b\x2b\x6b\x04\x85\x2a\xa2\x81\xfe\x56\x46\x4b\xcd\xb2\xca\x9a\x70\xd5\x92\x70\x99\xa0\x3f\x8d\x54\x8d\xa0\xa8\x3a\x52\x2d\xe8\x2f\xfe\xa2\xa6\xb1\x46\xd0\x9f\x5e\x4f\xd7\x97\x54\xa8\x41\x23\x86\xbc\x50\x1b\x51\x6a\x23\x09\x32\xdb\x50\x4f\xa1\x8a\x26\xa5\x58\x1a\xa5\x0e\x51\x0f\xd5\xa0\x2b\x14\xe3\x2c\xd3\x09\x7c\x59\x3c\x21\x50\x9d\xfe\x82\xa4\x3c\x88\x64\x2a\x2c\x4a\xea\x2b\xa8\x4d\x69\xa6\xcc\xa2\xf8\x5a\xa1\x34\x13\xa9\x8d\xd4\x41\xea\x22\x0d\x21\xcd\x42\x9a\x8d\x34\x07\x69\x2e\xd2\x7c\xa4\x05\x48\x0b\x91\x16\x21\xf5\x90\xfa\xf1\x34\x13\xf8\x99\xc0\xcf\x04\x7e\x26\xf0\x33\x81\x9f\x09\xfc\x4c\xe0\x67\x02\x3f\x13\xf8\x99\xc0\xcf\x04\x7e\x26\xf0\x33\x81\x9f\x09\xfc\x4c\xe0\x67\x02\xdf\x06\xbe\x0d\x7c\x1b\xf8\x36\xf0\x6d\xe0\xdb\xc0\xb7\x81\x6f\x03\xdf\x06\xbe\x0d\x7c\x1b\xf8\x36\xf0\x6d\xe0\xdb\xc0\xb7\x81\x6f\x03\xdf\x01\xbe\x03\x7c\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x00\xdf\x01\xbe\x03\x7c\x07\xf8\x0e\xf0\x1d\xe0\x3b\xc0\x77\x80\xef\x00\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\xdf\x05\xbe\x0b\x7c\x17\xf8\x2e\xf0\x5d\xe0\xbb\xc0\x77\x81\xef\x02\x3f\x04\xfc\x10\xf0\x43\xc0\x0f\x01\x3f\x04\xfc\x10\xf0\x43\xc0\x0f\x01\x3f\x04\xfc\x10\xf0\x43\xc0\x0f\x01\x3f\x04\xfc\x10\xf0\x43\xc0\x0f\x01\x3f\x0b\xf8\x59\xc0\xcf\x02\x7e\x16\xf0\xb3\x80\x9f\x05\xfc\x2c\xe0\x67\x01\x3f\x0b\xf8\x59\xc0\xcf\x02\x7e\x16\xf0\xb3\x80\x9f\x05\xfc\x2c\xe0\x67\x01\x3f\x1b\xf8\xd9\xc0\xcf\x06\x7e\x36\xf0\xb3\x81\x9f\x0d\xfc\x6c\xe0\x67\x03\x3f\x1b\xf8\xd9\xc0\xcf\x06\x7e\x36\xf0\xb3\x81\x9f\x0d\xfc\x6c\xe0\x67\x03\x3f\x07\xf8\x39\xc0\xcf\x01\x7e\x0e\xf0\x73\x80\x9f\x03\xfc\x1c\xe0\xe7\x00\x3f\x07\xf8\x39\xc0\xcf\x01\x7e\x0e\xf0\x73\x80\x9f\x03\xfc\x1c\xe0\xe7\x00\x3f\x17\xf8\xb9\xc0\xcf\x05\x7e\x2e\xf0\x73\x81\x9f\x0b\xfc\x5c\xe0\xe7\x02\x3f\x17\xf8\xb9\xc0\xcf\x05\x7e\x2e\xf0\x73\x81\x9f\x0b\xfc\x5c\xe0\xe7\x02\x3f\x1f\xf8\xf9\xc0\xcf\x07\x7e\x3e\xf0\xf3\x81\x9f\x0f\xfc\x7c\xe0\xe7\x03\x3f\x1f\xf8\xf9\xc0\xcf\x07\x7e\x3e\xf0\xf3\x81\x9f\x0f\xfc\x7c\xe0\xe7\x03\xbf\x00\xf8\x05\xc0\x2f\x00\x7e\x01\xf0\x0b\x80\x5f\x00\xfc\x02\xe0\x17\x00\xbf\x00\xf8\x05\xc0\x2f\x00\x7e\x01\xf0\x0b\x80\x5f\x00\xfc\x02\xe0\x17\x00\xbf\x10\xf8\x85\xc0\x2f\x04\x7e\x21\xf0\x0b\x81\x5f\x08\xfc\x42\xe0\x17\x02\xbf\x10\xf8\x85\xc0\x2f\x04\xbe\x0f\x9c\xb8\x4f\x96\xe9\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x2f\xdb\xd7\xe7\xc8\xcf\x3a\xf5\xe5\xf1\x64\x4e\xfc\x4b\x8e\xcb\x65\x62\xcd\x69\x7e\x83\xdd\x5a\xde\x9c\x8b\xdf\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\x81\x67\x3c\xf0\x8c\x07\x9e\xf1\xc0\x33\x1e\x78\xc6\x03\xcf\x78\xe0\x19\x0f\x3c\xe3\xe5\x7a\x56\x7e\xf3\xe7\x95\x56\xb8\x39\x97\x90\xdf\xf2\xc9\x6c\x42\xb8\x25\x9b\x92\x7f\xe8\x4b\x9f\xd2\x0c\x29\xe1\x23\x0b\x5a\xd5\x90\x66\x6b\x5d\x43\x16\xa4\xb5\xaa\xd1\xd2\x70\x5a\xf8\x28\x85\xad\xdb\x92\x9f\x2c\xb7\x6e\x4b\x16\xb4\x6f\x55\xa3\x59\xf3\xf6\xe1\x3f\x96\xb5\x89\x7f\x49\x3c\xfe\x85\xb4\x70\xab\x7c\xbc\x5c\xea\x85\x72\x99\x4f\x8e\x97\xb7\x68\x92\x1c\x3e\xfc\x35\xee\x93\x3a\xe0\x3e\x99\x4f\x8a\x97\x37\xc3\x26\x85\x0f\x7b\x69\x79\x2d\xb9\x96\xb2\x04\xef\x90\x9d\x0f\xb5\xaf\x7b\xf1\x2f\xf9\xc6\x5b\x4d\xf1\x8e\x34\x72\xe4\xc8\x02\xef\x48\xab\x47\x8e\xb4\xba\x77\x34\xab\x47\x8e\x66\x75\xef\x48\xab\x47\x8e\xb4\xba\x77\x14\xab\x47\xfe\x58\x96\x30\xe1\x50\xdf\x2a\x5b\xb2\xd6\x84\x16\x2b\x54\xb6\xe4\xa6\xb6\xe4\xa2\x2d\x77\x4f\x3d\x74\x77\xf4\x90\x76\x53\x8f\xec\x7a\xf4\xc8\x82\xa9\x47\xda\x22\x7a\xa4\x2d\xa6\x1e\xcd\x16\xd1\xa3\xd9\x62\xea\x91\xb6\x88\x1e\x69\x8b\xa9\x47\xb1\x45\xf4\x28\xb6\x90\x5f\x00\x8e\x7f\x71\x32\x7a\x28\x2b\x4b\xa5\x52\xf1\x52\x99\x4d\x92\xa5\x2d\x4a\x24\x45\x0f\x7b\x19\xbf\x47\x82\xc7\xef\x91\xd9\xb6\xb2\xb4\x19\xad\x6d\xb4\xf5\x2b\x6b\x56\x4b\xae\xb1\x45\x9f\x59\x87\x1a\x6c\x3c\x94\x9d\x75\x48\xb5\xc6\x43\xd9\x59\x87\xb4\x6c\x3c\xa4\xe5\xac\xc3\xb5\x6c\x3c\x5c\xcb\x59\x87\xb4\x6c\x3c\xa4\xe5\xac\xc3\xb4\x6c\x6c\xfd\x4a\x2f\x8e\x6f\xb3\x2b\x65\x62\x15\xb7\xe8\xbc\xb2\x45\xe7\xe2\x43\xcd\xaf\x3c\xb4\x56\x8a\xe3\x6b\x65\x65\xfc\x0b\xf1\xc1\x9e\xe6\xc3\x67\xf3\xe1\xb3\xf9\xf0\xd9\x7c\xf8\x6c\x3e\x7c\x36\x1f\x3e\x9b\x0f\x9f\xcd\x87\xcf\xe6\xc3\x67\xf3\xe1\xb3\xf9\xf0\xd9\x7c\xf8\x6c\x3e\x7c\x36\x1f\x3e\x9b\x0f\x9f\xcd\x87\xcf\xe6\xc3\x67\xf3\xe1\xb3\xf9\xf0\xd9\x7c\xf8\x6c\x3e\x7c\x36\x1f\x3e\x9b\x0f\x1f\xcd\x87\x8f\xe6\xc3\x47\xf3\xe1\xa3\xf9\xf0\xd1\x7c\xf8\x68\x3e\x7c\x32\x1f\x3e\x99\x0f\x9f\xcc\x87\x4f\xe6\xc3\x27\xf3\xe1\x93\xf9\xf0\xc9\x7c\xf8\x64\x3e\x7c\x32\x1f\x3e\x99\x0f\x9f\xcc\x87\x4f\xe6\xc3\x27\xf3\xed\x66\x3c\xf4\x0f\x3e\x99\x0f\x9f\xcc\x87\x4f\xe6\xc3\x27\xf3\xe1\x93\xf9\xf0\xc9\x7c\xf8\x64\x3e\x7c\x32\x1f\x3e\x99\x0f\x9f\xcc\x87\x4f\xe6\xc3\x27\xf3\xe1\x93\xf9\xf0\xc9\x7c\xf8\x64\x3e\x7c\x32\x1f\x3e\x99\x0f\x9f\xcc\x87\x4f\xe6\xc3\x27\xf3\xe1\x93\xf9\xf0\xc9\x7c\xf8\x64\x3e\x7c\x30\x1f\x3e\x98\x0f\x1f\xcc\x87\x0f\xe6\xc3\x07\xf3\xe1\x83\xf9\xf0\xb9\x7c\xf8\x5c\x3e\x7c\x2e\x1f\x3e\x97\x0f\x9f\xcb\x87\xcf\xe5\xc3\xe7\xf2\xe1\x73\xf9\xf0\xb5\x7c\xf8\x58\x7e\xa8\xb9\x5d\xe8\x0f\x9f\xca\x87\x4f\xe5\xc3\xa7\xf2\xe1\x53\xf9\xf0\xa9\x7c\xf8\x54\x3e\x7c\x2a\x1f\x3e\x95\x0f\x9f\xca\x87\x4f\xe5\xc3\xa7\xf2\xe1\x53\xf9\xf0\xa9\x7c\xf8\x54\x3e\x7c\x2a\x1f\x3e\x95\x0f\x9f\xca\x87\x4f\xe5\xc3\xa7\xf2\xe1\x53\xf9\xf0\xa9\x7c\xf8\x54\x3e\x7c\x2a\x1f\x3e\x95\x0f\x9f\xca\x87\x4f\xe5\xc3\xa7\xf2\xe1\x53\xf9\xf0\xa9\x7c\xf8\x54\x3e\x62\x75\x1f\xb1\xba\x8f\x58\xdd\x47\xac\xee\x23\x56\xf7\x11\xab\xfb\xf0\xa1\x7c\xf8\x50\x3e\x7c\x28\x1f\x3e\x94\x0f\x1f\xca\x87\x0f\xe5\xc3\x87\xf2\x73\x9a\xf1\xd0\x5f\xf8\x50\x3e\x7c\x28\x1f\x3e\x94\x0f\x1f\xca\x87\x0f\xe5\xc3\x87\xf2\xe1\x43\xf9\xf0\xa1\x7c\xf8\x50\x3e\x7c\x28\x1f\x3e\x94\x0f\x1f\xca\x87\x0f\xe5\x23\x56\xf7\x11\xab\xfb\x88\xd5\x7d\xc4\xea\x3e\x62\x75\x1f\xb1\xba\x8f\x58\xdd\x47\xac\xee\x23\x56\xf7\x11\xab\xfb\x88\xd5\x7d\xc4\xea\x3e\x62\x75\x1f\xb1\xba\x8f\x58\xdd\x47\xac\xee\x23\x56\xf7\x11\xab\xfb\x88\xd5\x7d\xc4\xea\x3e\x62\x75\x1f\xb1\xba\x8f\x58\xdd\x47\xac\xee\x23\x56\xf7\x11\xa3\xfb\x88\xd1\x7d\xc4\xe8\x3e\x62\x74\x1f\x31\xba\x8f\x18\xdd\x47\x8c\xee\x23\x46\xf7\x11\xa3\xfb\x88\xd1\x7d\xc4\xe8\x3e\x62\x74\x1f\x31\xba\x8f\x18\xdd\x47\x8c\xee\x23\x36\xf7\x11\x9b\xfb\x88\xcd\x7d\xc4\xe6\x3e\x62\x73\xbf\x10\xb8\x85\xc0\x2d\x04\x6e\x21\x70\x0b\x81\x5b\x04\xdc\x22\xe0\x16\x01\xb7\x08\xb8\x45\xc0\x2b\x02\x5e\x11\xf0\x8a\x80\x57\x04\xbc\x22\xe0\x15\x01\xa7\x08\x38\x45\xc0\xf1\x80\xe3\x01\xc7\x03\x8e\x07\x1c\x0f\xfd\xf3\x30\xae\x1e\x70\x3d\xe0\x7a\xc0\xf5\x80\xeb\x01\xd7\x03\xae\x87\x7e\x7a\xc0\xf7\x80\xef\x01\xdf\x07\x9e\x0f\x3c\x1f\x78\x3e\x70\x7c\xe0\xf8\xc0\xf1\x81\xe3\x03\xc7\x07\x8e\x0f\x1c\x1f\x38\xf1\xf7\x40\xec\x91\x71\x1e\xa5\x34\x13\xa9\x8d\xd4\x41\xea\x22\x0d\x21\xcd\x42\x9a\x8d\x34\x07\x69\x2e\xd2\x7c\xa4\x05\x48\x0b\x91\x16\x21\x6d\xc6\xf5\xe3\x69\x26\xf0\x32\xd1\x7e\x66\x56\x5b\x79\xca\x9d\x7c\x28\xb4\x74\x51\x55\xdb\xa5\x8d\xd1\xe0\x4c\xd5\xe0\x39\xd1\x48\x29\xea\xe0\x5e\x1b\x58\x36\xb0\x6c\x60\xd9\xc0\xb2\x81\x65\xfb\x7a\x75\x65\x8d\x7c\x54\x2f\x52\x12\xad\x41\x2b\x8e\x6b\x45\x56\x94\x54\x85\xab\x09\xc5\xaa\x0b\x97\x06\x27\x37\x46\x56\xc4\xaf\x85\x70\x67\x16\x10\xb2\x80\x90\x05\x84\x2c\x20\x64\x35\xd7\xf3\x13\xcb\xa2\x8d\x75\xf5\x8d\xb5\x91\xba\xca\x68\x5d\x62\x59\xe5\xb2\x48\xf3\x8b\xb6\xf5\xa4\x7c\x4d\xcb\xab\x48\x70\x24\x71\xf3\x2b\xab\xa5\x3c\xde\x4e\x2e\x46\x23\x17\xa3\x91\x0b\xeb\xe4\x62\x34\x72\x31\x1a\xf9\xa8\x97\x8f\x7a\xf9\xb6\x5a\x55\x59\x17\xc6\x0b\x98\x32\x3f\x4b\xaf\x8d\xd4\x47\x1a\x9a\x8b\x31\x52\xf9\xb9\x7a\x7d\x45\x64\x69\xa4\x4a\x2d\x8d\xd6\x94\xab\xc1\xf9\x91\xb8\x80\x4e\xe5\xa3\x53\xf9\x30\x73\x01\xc0\x0a\x00\x56\x00\xa5\x0a\xa0\x54\x01\x94\x2a\x00\x6e\xfc\x23\x56\x3b\x13\x53\x26\x33\xee\x12\x51\x9a\x85\x34\x5b\x4c\xad\xa8\xb6\x22\xf5\x0d\x95\xd5\xe1\x06\x0c\x6a\x66\x9c\x98\x29\xf5\xcc\x68\x4d\xa4\xa1\xa2\xb2\xae\xd4\x6a\x58\x1e\x95\x99\x7a\x8b\x8a\xa4\xe1\x2a\x12\x1b\x2a\xea\x22\xc8\xd7\xb7\x09\xec\x8c\x7c\xa2\x34\x33\x5e\xc4\x9b\xca\x71\xad\x70\x5d\x5d\x74\x79\x55\xa4\xac\xc1\x90\xb9\xc6\xda\x04\x99\xca\x73\xa1\xe3\x17\x4b\xa3\xcb\x6b\xe2\xb9\x45\x04\x66\xa1\x5a\x69\x4d\x62\x4b\x6e\x51\xbd\xf4\x39\x6d\x3c\xa6\x64\xdb\x99\xa1\x84\x68\x5d\x43\x45\xf0\x24\x65\xb8\x2a\xb1\xb2\xa6\x21\x98\x9b\xf2\xd4\xde\x36\x91\xa5\x8d\x95\xcb\x68\x1e\xd5\x94\x44\xb4\x8a\x68\x63\x7d\xa4\x2d\x4d\xdd\xaa\x68\x79\x30\xb9\x6a\xa2\x0d\x09\x41\x65\xf2\x7e\xab\x1a\x6a\x5b\xb2\x8b\xe4\x87\x77\x36\x3e\x19\xb6\xf1\x89\xb0\x8d\x4f\x72\x6d\x7c\x62\x4b\xa9\x8b\x34\x07\x29\xae\xdb\x28\xc7\xec\x0f\x39\x78\xed\xe0\x75\x08\xf7\xc7\x3d\x1d\x4a\xd1\x7e\xdc\xd3\xa1\x14\xf5\xe3\x9e\x0e\xa5\x59\x48\xb3\x91\x02\x2f\xee\xf1\x50\x9a\x8f\xb4\x00\x69\x33\x4e\x11\x52\x0f\x69\x7c\xfa\x84\xb2\x80\x9f\x05\xfc\x2c\xe0\x67\x01\x3f\x0b\xf8\x59\xc0\xcf\x02\x7e\x16\xf0\xb3\x80\x9f\x05\x7c\xac\xc9\x10\xd6\x64\x28\x58\x93\xb5\x8b\xaa\xa2\x25\x4b\x0c\x1a\xab\x20\xd5\xe2\xaf\xaa\xca\xe2\x69\x5d\x03\x5e\x37\xd4\x57\x84\x4b\x23\x9a\x94\x46\xe9\x12\x99\x5a\x65\x95\x55\x55\xb4\xd1\x44\xe3\x2b\x1f\x9f\x2f\xdb\xf8\x7c\x98\xd2\x82\x84\x78\x8d\xba\xff\x87\xbd\xef\x01\x8f\xaa\xc8\xf6\xac\x7b\xeb\x76\xd2\xdd\x09\x9d\x04\x23\x63\x7c\x08\x88\xf9\xfc\xdc\xf9\x78\x6e\x48\x42\xba\xdb\x61\x58\x24\x31\x8f\x61\x32\x2e\xcb\x44\x8c\x4c\x46\xf9\x97\x98\x60\x08\x08\x81\x41\x24\xc0\xf2\x1c\xdf\x3c\x97\x19\x1c\xc7\x71\xd9\x2c\xeb\xb2\x2e\xab\x91\x61\x79\xbc\xbc\x6c\x96\xe7\x63\xfd\x74\x46\x9d\x38\x06\x66\x1e\x44\x60\x04\x19\x44\x02\x88\xe1\x8f\x31\xfc\x91\x65\x72\xf7\x57\xa7\xaa\xbb\xab\xab\xbb\x21\xc8\x30\x3b\xb3\xdf\x7e\xf9\xea\xd4\xa9\x73\x4f\x9d\x3a\xf5\xab\x73\xeb\x56\xdd\x7b\x3b\x17\x23\x9c\xde\xb4\xa8\x7e\xd6\xa3\x4b\x16\xca\x7c\x91\x2a\xcf\x6d\x94\x79\x43\x6d\x9a\xd8\x15\x36\xc8\x68\x19\x57\xaa\x70\x29\x2d\xf7\xd5\x37\x2e\x9d\xbd\x04\x46\x9a\x04\x27\x75\xfc\x0b\x16\xd6\x34\x2a\xe1\xe2\xf9\xf5\x08\xd1\x59\x73\x6a\x10\x4b\x4b\xa3\x05\xbe\x78\x49\x63\x5a\x6d\xcd\x7c\x44\x93\x23\x88\x67\xf1\x42\xf8\xeb\xcc\x69\x58\x32\xdb\x53\x57\x33\x0b\xad\xcf\xad\x9f\x35\x1f\xd3\x59\xc6\xfc\x25\x8b\x55\x7c\xd5\x04\x34\x1e\xf3\x1a\x79\x50\x22\xd7\x84\x85\xa5\x6a\x24\x4a\xd5\x48\x94\xaa\x91\x28\x55\x23\x51\xaa\x46\xa2\x54\x8d\x44\xa9\x1a\x89\x52\x35\x12\xa5\x6a\x24\x4a\xd5\x48\x94\xaa\x91\x28\x55\x23\x51\xaa\x66\xc7\x52\x35\x3b\x96\x06\x55\x3b\x41\xd5\x4e\x50\xb5\x13\x54\xed\x04\x55\x3b\x41\xd5\x8e\x5c\x7b\x16\xaa\xfb\xda\xf7\x06\xa3\x79\x48\xe5\x61\x95\xdf\xab\xf2\x49\x2a\x2f\x55\x79\x99\xca\xef\x53\x79\xb9\xcc\xe5\x5e\x0a\xf9\x58\x99\x87\x94\xbd\x90\xb2\x17\x52\xf6\x42\xca\x9e\x5c\x6b\x96\xab\x6b\x1f\x96\x54\x65\x2a\xbf\x2f\x53\x3e\xaf\x7e\x84\x1e\xec\x67\xe1\x34\xae\xc1\x06\x5a\xfc\x73\x60\xf1\x20\xdc\x2b\x9e\xb7\x7f\xaf\x1e\x31\x45\x4f\xda\x05\x97\x56\x57\x23\xb2\xf4\xc7\x66\xc9\x03\xf4\x58\x5d\x70\x99\x91\x47\xeb\xa2\xe0\x15\x0f\xbf\x49\xaf\x69\xd6\x52\x3a\x0a\xcb\x8f\x2c\x6c\x58\xb2\x58\xfc\xcb\xd9\x0c\xf1\xe8\x5c\xbd\x09\xe0\x27\x9e\xd8\x1c\x12\xd1\xeb\x03\xea\x60\xb6\x26\x21\x81\x4f\x38\x44\xae\xfa\x05\x27\x5f\x0d\x20\xe1\xfc\x59\x0b\xeb\x1f\xf7\xcd\xae\x69\x92\xea\x19\xf4\x82\x80\xe2\xc9\x79\xc9\x7b\xeb\x6a\x24\xe3\x5b\x3a\x6b\xa9\x3a\x4c\x2f\x0e\x28\x69\x53\x44\xd1\x07\x50\x24\x17\x88\xbc\x46\xa0\x0e\x44\xb9\x0c\xea\xbb\x92\xa2\xe3\x8a\x6b\x5c\xa2\x8c\x65\xca\x57\x0a\x64\x61\x88\x7a\xa7\x40\xb9\x11\x61\x32\xe8\xa5\x02\x55\xf3\xf1\x05\xca\xb2\x5f\xc0\xa7\xd8\x18\x04\xbe\xa6\x88\xcb\x5e\x38\x2f\x5f\xbe\x40\x87\xc5\xdb\x15\x62\x38\x44\x8e\xcb\xa3\xc8\x08\x11\xf2\x8e\x86\x59\x3d\x0e\x29\x57\x8f\x43\xca\xd5\xe3\x90\x72\xf5\x38\xa4\x1c\x4b\x29\xa7\x11\x27\x2e\x5f\x58\x3f\x76\xc8\x9c\x27\x16\x61\x76\xa8\x9f\x43\x77\x01\xb3\xe9\x87\xfc\xda\x6f\x46\x73\x34\x7e\x91\x78\xbb\xbc\xc6\x4f\xb7\x3e\xee\xc6\xf8\x8e\x8d\xb1\x85\x31\xb6\xc8\x4f\xf7\x63\xa4\x42\x94\x2d\x8c\xb1\x45\x81\xe8\x6d\x11\x52\x8a\x2f\x16\xc6\x17\x8b\xfc\x74\xc7\x44\x5a\x8b\xb2\x85\x7e\xf2\x96\xa4\x59\xb1\xfb\x58\x54\x1e\x12\xb9\x13\x63\x78\x50\x1c\x63\xc7\xc5\xbc\x2d\x8e\xb1\xe3\xe2\x5b\x2e\x8e\x2f\x8e\x8b\xb5\xae\xf9\x54\x1c\x63\x35\x85\x92\x18\x1b\x8c\xb1\xa1\x38\xcf\x0a\xe3\x4a\x45\x71\xa5\xe2\xb8\xd2\xb8\xb8\x92\x66\x3b\x1c\x77\x20\x18\x57\x8a\x6f\x2c\x1c\x88\x03\xa5\x20\xbe\x38\x36\xbe\x58\x18\x5f\x2c\x8a\x2f\x16\xc7\x17\xc7\x65\xc4\xc6\xa7\x40\xe3\xc7\x6a\x7c\xa1\xc6\x53\x47\xc5\x4f\x73\xeb\xe5\xe0\x21\x1c\xc5\x4f\xac\xc4\xcf\xb0\xee\x9e\x33\x6b\xa1\x56\x1e\x6b\x94\x4b\x8d\x72\x81\x56\x0e\x1a\xf5\x8b\xe2\xca\x85\xf7\x8d\x53\xa9\xc4\x28\x07\x8d\x72\xc8\x28\x87\xb5\x72\x89\xc8\x8d\x72\x89\x51\x0e\x1a\xe5\x90\x51\x0e\x67\x68\x65\xed\x58\xd0\xb0\x1d\x4c\x72\x3c\x68\x94\x43\x46\x59\xb7\xad\xeb\x86\x0c\xdb\x21\xc3\x76\x28\x89\x7e\xc8\x28\xeb\xb6\xf5\x63\x61\xc3\x76\xd8\xb0\x1d\x36\x6c\x87\x93\xd4\xd7\x6d\x47\xf0\x2e\x89\x8c\x81\x51\x2e\x31\xca\x41\xa3\x1c\x32\xca\x11\xdb\x25\x86\xad\x64\xe5\xa0\x51\x0e\x19\x65\xdd\xb7\xa0\x51\x3f\x68\xf8\x16\x34\xec\x05\x0d\x7b\x41\xc3\x37\x5d\x37\x64\xd8\x0e\x19\xb6\x43\x49\xf4\x43\x46\x59\xb7\xad\x1f\x0b\x1b\xb6\xc3\x86\xed\xb0\x61\x3b\x9c\xa4\xbe\x6e\x3b\x82\x49\xd0\x18\xaf\xa0\x31\x5e\x41\x63\xbc\x82\xc6\x78\x05\x8d\xf1\x0a\x1a\xb6\x4a\x92\x94\x4b\x8c\x72\xd0\x28\x87\x8c\xb2\x6e\x5b\xaf\x6b\xb6\x95\xec\x78\xc8\x28\xeb\xfd\x0e\x19\xf5\x43\x46\xfd\x90\xe1\x5b\xc8\xb0\x17\x32\x7c\xd3\x8f\x85\x0d\xdb\x61\xc3\x76\xd8\xb0\x1d\x4e\x52\x5f\xb7\x1d\xf1\x3b\x64\x8c\x57\xc8\x18\xaf\x90\x31\x5e\x21\x63\xbc\x42\xc6\x78\x85\x0c\x5b\x25\x49\xca\x25\x46\x39\x68\x94\x43\x46\x59\xb7\xad\xd7\x0d\x1a\xb6\x83\x49\x8e\x07\x8d\x72\xc8\x28\xeb\xb6\x75\x5d\xb3\x1f\x66\xdb\xc9\xf4\x75\x4c\xc3\x46\xfd\xb0\x51\x3f\x6c\xd4\x0f\x1b\xbe\x85\x0d\xdf\x22\xb6\xc3\xc6\x78\x85\x8d\xf1\x0a\x1b\xe3\x15\x36\xc6\x2b\x6c\x8c\x57\xd8\xb0\x55\x92\xa4\x5c\x62\x94\x83\x46\x39\x64\x94\x75\xdb\x7a\xdd\xa0\x61\x3b\x98\xe4\x78\xd0\x28\x87\x8c\xb2\x6e\x5b\xd7\x0d\x19\xb6\x43\x86\xed\x50\x12\xfd\x90\x51\xd6\x6d\xeb\xc7\x4c\x8c\xcc\x7e\x99\xbe\xc8\xfa\x91\xd5\xf4\x23\x0b\x9a\xc4\x97\x92\x7c\x72\x9d\x0a\xa9\x5a\x99\x14\x1b\x2b\x97\x62\x63\xa5\x53\x94\xa4\x1c\xd2\xca\x63\xc5\x6a\x47\x2b\x97\x1a\xe5\xe2\x88\x7e\xe6\xec\x59\x8b\xea\x23\xff\x07\xe5\x26\x3a\x38\x69\xac\x54\x18\x2b\x8c\x16\x24\x91\x8d\x35\x64\xc5\x49\xf4\x8a\x0d\xbd\x92\x24\xf6\x4a\x92\xd8\x2b\x49\x62\xaf\xc4\xb0\x17\x4e\xe2\x5f\x38\x89\x7f\xe1\x24\xfe\x85\x93\xf8\x17\x4e\xe2\x5f\x38\x89\x7f\xe1\x24\xfe\x85\x13\xfd\x2b\x1d\x97\xe8\x5f\x9c\xcc\xd4\x2b\x4e\xa2\x67\xda\x2b\x49\x62\xaf\x24\x89\xbd\x92\x24\xf6\x92\xe1\x17\x8a\x04\x59\x12\x99\xa9\x57\x92\x44\xaf\xc4\x68\xd7\xb0\x17\x27\x33\xf5\x4a\x92\xe8\x91\x3d\xf1\xbf\x06\x9a\x6a\xe6\xd6\xd3\x0e\xcc\x7b\x5f\xe3\xa3\xb4\xf8\x8f\x30\x85\x11\xa6\xc8\xbb\xbc\x66\xd1\x02\xc1\xa5\x2f\x68\xa4\xfd\x42\x7a\xd3\xf7\xa8\xec\xa3\x7b\xa6\x82\xf3\x8a\xbb\xd4\x92\xa9\x97\x3b\xb3\xf4\xc5\xf5\xb4\xf3\xf3\xd1\xed\x53\xe2\xe8\x1e\x2a\x29\x35\xd6\x4b\x43\x19\xd1\xdb\xe3\x77\xd3\x6d\xb2\x02\x75\xaf\x18\xde\x85\xd3\x1f\xb8\xff\x1b\xe2\xd6\x68\x96\xf1\x92\x46\x96\xf1\x4a\x46\x20\xfe\xe5\x8b\x2c\xe3\x2d\x0b\x7f\xec\x95\x1d\x7f\xec\x2d\x1d\x5f\xf4\xa5\x1c\x7f\xec\x15\x9c\x6c\xda\xab\xd3\x8e\x5e\xed\xfa\x63\x82\xe8\xed\x07\x79\xb3\x63\x48\xa4\x48\xbf\xe1\xb8\x29\xba\xd1\x8f\xfd\x98\x23\x10\x95\x19\x45\xfa\x1d\x47\xb6\x76\x8b\x87\xa4\x74\x23\x45\xdd\x8c\x10\x00\x8c\xc3\xa9\x38\x6e\x52\x99\xe2\x0b\x35\xbe\x48\xf0\xce\xb7\x1f\x99\x74\x9f\xfc\x5a\xa5\x9f\xd9\x2c\x87\x59\xae\x2b\xbe\xc3\x48\xdf\x8e\x64\x6c\x19\x5b\x4d\x5f\xd5\xc9\x61\xcc\xe9\x64\x96\xf3\xae\x73\x8e\x71\xe7\xbc\x73\x1e\xfc\x05\xe7\x02\xf8\x8b\xce\x45\xf0\x5f\x38\xbf\x07\x3f\xe0\x0c\x80\x77\x1d\x58\xf0\x30\xef\x2f\x99\xe5\xed\xf4\x76\x32\xee\x7d\xd7\xfb\x39\xf8\x7e\x6f\x3f\xb3\xbd\xe7\xfc\x69\xcc\xf2\xa7\xfb\x7d\xcc\x16\xff\x7b\x13\x7c\xa6\x3f\xc0\xb8\x3f\xcb\x9f\x85\x56\x1d\xf5\x0d\x1f\x4b\x4b\x7e\x36\x9b\xbd\xc0\x1c\x4c\xb2\x0d\xec\xd6\x47\x17\xd5\x3c\xc6\x0a\xeb\x6a\x66\x2f\x62\x13\x1a\x66\x35\x35\x32\xfa\xea\xcf\xb7\xbe\x59\x36\x8a\x65\x7f\x7b\xda\x24\x50\xc6\xd0\x03\x8b\xbe\xf0\xc3\x14\xcf\xa2\xbc\x4d\x5f\xff\x89\x3b\x32\x67\xce\xfc\x85\xec\x56\xa2\xa3\xe6\x36\xd4\x3f\xca\xee\x6a\x58\x30\x47\x7c\x77\x88\x45\xfd\x11\xdf\x0b\x12\xa5\x88\x47\x69\xc0\x66\x18\x1b\xc1\xee\x84\x56\x89\x92\x16\x40\x57\x68\x14\xab\xbc\x0c\x5a\xc8\xed\x34\xb2\x61\xd9\x13\xa5\x3c\x7d\x0b\x68\x5a\xda\x5f\x0a\x9e\x1f\x01\x1d\x8a\xe4\x15\x2d\x09\x74\x3c\x99\x42\xee\x81\xbe\xb5\x81\xe5\xb1\x10\x9b\x84\xfe\x4d\x67\x33\xd9\x3c\xd6\xc4\x56\xb2\x1f\xb0\x16\xb6\x89\x6d\x65\x6f\xb0\x0f\xd8\x51\x28\xfa\xad\x5c\x6b\x84\x75\x97\x55\x68\x8d\xb7\xca\xad\xa9\xd6\x73\xc2\x8e\x3f\x93\xd9\xce\x39\xe2\x86\x44\xb9\x40\x94\xcb\x00\xd7\x4f\xed\x1d\x88\x72\x07\xa3\xdc\x87\x51\xee\x10\x71\x36\x7a\x91\xe9\x3d\x0b\xfe\x33\xef\xef\xa2\xc7\x0e\x47\xb9\x8f\x34\xad\x23\x82\xc7\xa8\xdb\x4e\x2f\xf0\xf2\x02\xa3\x5c\x8c\xb5\xed\x9c\xf0\x7b\x40\xcf\x7a\x3f\x8e\xd6\x3a\x4a\x9c\xd0\xc9\x66\xc3\xfc\x1c\x91\xd3\xef\x7c\xe6\x77\xa8\x95\x9e\xa8\xd6\xb1\x28\x77\x3c\xca\x9d\x88\x72\x9f\x44\xb9\x93\x51\xee\xd3\x28\xd7\x1b\xe5\x4e\x11\x97\x8e\x96\x6e\xa1\xaf\x7a\x16\x60\xc4\xc6\x7b\xf7\xa1\xcd\x4b\xf0\x76\x1f\xb5\x7d\xc9\xbb\x17\xf9\x17\x28\xef\xa5\xf2\x17\xde\xd3\xd4\x97\xf7\x41\x2f\x79\xbb\x41\xbf\x20\x5b\x67\x54\x6f\xd3\x9d\x4f\x9c\x4f\xc5\x87\x5c\x3d\x69\x88\x74\x2f\x46\xcd\xef\x09\x78\x02\x8c\xbe\x41\xc0\xb2\xc5\x37\x08\xd8\x50\xcf\x30\xcf\xad\x2c\x97\x22\xc7\x46\x3e\x1a\x16\xc6\x50\xac\x78\x40\x3d\xf4\x35\x83\x0c\x4f\xae\xe7\x36\x11\xab\xf4\xf5\x83\x0b\x22\xce\x20\xbf\x8d\x31\xef\x0f\xbd\x3f\x64\x23\xbc\xef\x79\x77\xb3\x91\x88\x87\x79\xa8\x93\x6d\x8d\xb6\x8b\x79\xb9\x53\xc5\x86\xb3\x7b\x10\x17\x53\xd8\x34\x36\x03\x67\xc6\x3c\xb6\x88\x2d\x67\x6b\xd8\x33\xec\x39\x44\xc7\x4b\x6c\x33\x6b\x63\xaf\xb1\x9f\xb3\x5f\xb1\xdd\x88\x92\x23\xec\x24\xeb\x63\x97\x10\x2b\x69\x56\xa6\xef\x5b\x8c\xdb\x3f\xb3\x7f\xe6\xab\xa0\x7c\xb3\xef\x9b\x94\xbf\xea\x9b\x42\x79\xab\xef\x1b\x94\xbf\xe2\xfb\x2b\xe4\x9b\xa1\x57\x4e\xf9\x66\xdf\x7d\x94\xbf\xea\x2b\xa3\xbc\xd5\x57\x4a\xf9\x2b\xbe\x7b\x91\xbf\x0a\xbd\x89\x94\x6f\xf6\xfd\x2b\xca\x5f\xf5\x4d\xa0\xbc\xd5\xf7\x75\xca\x5f\xf1\x7d\x0d\x79\x2b\xf4\xee\xa1\x7c\xb3\x2f\x4c\xf9\xab\xbe\x10\xe5\xad\xbe\x20\xe5\xaf\xf8\x4a\x90\xbf\x02\xbd\x71\x94\x6f\xf6\x15\x53\xfe\xaa\xaf\x88\xf2\x56\xdf\x64\x66\x43\x7a\x3f\xe8\xcf\x7c\xe3\x41\x5b\x7d\x93\x40\x5f\xbd\x0e\x44\xea\x15\x22\x75\x0a\x91\x47\x15\x22\xb5\x0a\x91\x1a\x85\xc8\x1c\x85\xc8\x6c\x85\xc8\x2c\x85\xc8\x4c\x85\xc8\x23\x0a\x91\xef\x2a\x44\xaa\x15\x22\xdf\x51\x88\xcc\x50\x88\x3c\xa4\x10\xa9\x52\x88\x3c\xa8\x10\x99\xae\x10\x79\x40\x21\xf1\x6d\x85\xc4\x34\x85\xc4\xbf\x51\x48\x4c\x55\x48\xfc\x6b\xca\x5f\xf1\xcd\x23\x2c\x1e\x16\x28\xf8\x2a\x41\x5f\xf1\xcd\x15\x18\x5d\x07\x22\xdf\x57\x88\x3c\xa5\x10\xf9\x6b\x85\xc8\x1a\x85\xc8\xbf\x55\x88\xac\x52\x88\xac\x54\x88\x34\x2b\x44\x56\x28\x44\x9e\x54\x88\x2c\x57\x88\x3c\xa1\x10\x59\xa6\x90\xf8\x9e\x42\x62\x89\x42\xa2\x49\x21\xb1\x58\x21\xb1\x48\xc5\xc6\xe3\x0a\x91\x05\x0a\x91\x46\x85\xc8\x7c\x85\x48\x83\x42\xe4\x31\x85\xc8\x6a\x8a\x91\xa7\x09\x97\x85\x84\xc8\x52\x11\x29\xd7\x81\xc8\x7f\x51\x88\x6c\x54\x88\xfc\x67\x85\xc8\x8b\x0a\x91\xff\xa4\x10\xd9\xa0\x10\xf9\x8f\x0a\x89\x16\x85\xc4\x7f\x50\x48\xfc\x7b\x85\xc4\x0b\x0a\x89\x9f\xaa\xd8\x78\x5e\x21\xf2\x13\x85\xc8\x8f\x15\x22\xcf\x2a\x44\xd6\x29\x44\x7e\xa4\x10\xf9\xa1\x42\xe4\xdf\x29\x44\x9e\x51\x88\xfc\xad\x42\xe4\x07\x0a\x91\xbf\x51\x88\xac\xa7\xe8\x78\x89\x10\x59\x4b\x88\x3c\x77\x9d\x88\xbc\xae\x90\xf8\x5f\x0a\x89\x1d\x0a\x89\x7f\x52\x48\xfc\xa3\x42\x62\xbb\x8a\x8d\xff\xa9\x10\xe9\x50\x88\xfc\x0f\x85\xc8\x3f\x28\x44\xda\x14\x22\x7f\xaf\x10\xd9\xa6\x10\xf9\x3b\x85\xc8\x7f\x57\x88\x6c\x51\x88\xfc\x4c\x21\xb2\x59\x21\xf2\xaa\x42\xe4\x15\x85\xc8\xcb\x0a\x91\xff\xa6\x10\xd9\xa4\x10\xf9\xaf\x0a\x91\x76\x42\xe4\x35\x8a\x94\x56\x42\x64\x2b\x21\x82\xd5\x81\xa8\x4f\xd7\xf3\x29\x62\xce\xc5\xac\x3d\x06\xd7\x8b\x89\xea\x0a\xf7\x5b\xba\x8e\xed\x07\x3d\x43\xd7\x83\xcf\xc0\x5d\x20\xae\x2f\xca\x7d\x1e\xe5\xde\x55\x7a\xf1\x73\xbd\x58\xcf\x54\xb2\xb5\x71\xeb\x99\x3b\x69\x3d\x53\x48\xeb\x99\x09\x49\xd7\x2d\xf1\xbc\x15\x27\xb7\x1f\xc3\x02\x90\x05\xc4\x7e\x14\xd7\x19\xfa\x1e\x39\xe8\xd5\xbf\x74\x98\x87\xb5\xca\x78\xac\x53\x2a\xe0\x4f\x35\x7d\xda\x74\x35\xfb\x11\xdb\x80\x15\xc6\x16\xd6\x8e\x71\x3f\xc9\xfa\xd9\x65\xcb\xb1\x32\xb1\xca\x18\x6e\xe5\x5b\x63\x2c\xb5\xb6\xb1\xbc\xb4\x62\xb1\x78\x2b\xca\xe9\xc8\xbb\xa5\x9c\x5f\x92\xb9\xf3\x2b\x99\xfb\x9f\x91\x2b\x9b\xec\x8e\x1c\x6f\xce\x8c\x9c\x2d\xb2\x94\x73\x76\x68\xdd\xd0\x93\x37\x35\xc8\xd2\x4d\x7b\x73\xef\xca\x5d\x9e\xdb\x25\x4b\x37\x67\xdf\xfc\xdc\x30\xff\xb0\xb5\xb2\xfe\xb0\xf3\x32\xcf\xdb\x2a\xf3\xe1\x33\x48\xcb\x3b\x32\x6d\x64\xd3\xc8\x5d\xa3\xee\x1a\xb5\x66\xd4\xc1\xdb\x4b\x6e\x7f\x96\xa4\x43\x6e\xef\xba\xfd\xf2\xe8\x31\xa3\xab\x47\xaf\x1d\xbd\x63\x74\xef\x1d\xc3\xef\xa8\xb8\x63\xc5\x1d\x5b\xee\x38\x98\x9f\x49\xc7\xed\xfc\xe1\xf9\x53\x80\x07\xf8\xfc\x46\xc2\xd0\x2a\x3a\x2a\xed\x16\xf5\xca\xbc\x64\xbd\xcc\xef\xa9\x92\xf9\xd7\x9f\x97\x7a\xf7\x56\xaa\xbc\x9a\xd6\x8f\xd6\xbd\xcb\x10\x27\x2f\xd8\xb0\x62\x6f\x00\x9a\x15\x38\x5f\x36\xb2\x97\x81\x5a\x1b\xdb\xce\x5e\x67\x6f\x01\xbb\xdf\xb0\xbd\xec\x20\xce\x9a\x13\xec\x34\x50\x54\xe7\x8d\x35\xd4\xba\x05\xeb\xb5\x7c\xeb\xab\x56\x81\x55\x82\x35\xdb\x24\x6b\xb2\x75\xbf\x55\x69\xcd\xb0\x66\x5a\xb5\x56\x83\xb5\xc8\x5a\x66\xad\xb4\x9e\xb2\x9e\xb1\x9e\xb5\x5e\xb0\x36\x58\x2f\x59\xad\xd6\x56\xab\xdd\x7a\xcd\x7a\xc3\x7a\xc7\xea\xb2\x76\x5b\xfb\xad\x43\xd6\x51\xeb\xa4\x75\xd6\x3a\x6f\x5d\xb6\x6d\xdb\x6b\x07\xec\x5c\xfb\x56\x7b\x94\x7d\xa7\x3d\xc6\x2e\xb4\x43\xf6\x04\xbb\xcc\x9e\x62\x4f\xb5\xa7\xdb\xd5\xf0\x75\xae\xa7\x10\x74\x3c\xd1\x35\x44\x47\x10\x95\xf2\x4e\x8d\x5f\x46\x74\xaa\xa6\x3f\x22\xc6\xbb\x33\x89\xdf\xa8\x1d\x1d\xaf\xd5\x9a\xab\xd1\xa9\x09\x72\x5d\x33\x37\x85\x3f\xba\xcd\xb9\x09\xfc\x08\x53\x1e\xe7\x4f\xae\x66\x4d\x1e\x3d\x92\xc0\xcf\x4d\xa0\xa9\x30\x19\xa1\x79\x3b\xfe\x8a\x68\xe8\x16\x12\xfb\x9e\xe8\xbf\xa6\xef\xf6\x26\xd8\x27\xf9\xc0\x1b\x58\x39\x2a\xaa\x6a\x09\x8a\xd9\x27\x6e\x5d\xf8\x2e\xe6\x96\x91\xb4\x3a\x1c\xe5\xed\xc6\x8c\x73\x97\x9f\x63\xa5\x3d\x99\xce\xbd\xcf\x98\xdc\xa1\x80\x7a\x72\x69\x27\x77\x0b\x13\xbb\x0c\xb9\x73\xc9\x51\x3a\xd8\x03\xc1\x22\x66\x11\x4f\x1a\x56\xa9\x1e\xf1\x8d\x2c\x76\x2b\x59\x1c\x0e\x8d\xe1\xd8\xdd\x58\x98\xfb\x32\x69\xa6\xb1\xec\x2a\xf2\xc7\x42\xdb\xa2\xf6\x17\x5a\x0b\xc2\xc3\x77\xd8\x8b\xa0\x5d\xd0\x1e\x8a\x1d\xd1\x18\x56\x88\x7d\xcb\x04\xcc\x2b\x53\xd8\x54\xec\x5d\xaa\x71\x6d\xa9\xa3\xef\xc9\x2e\xc7\xfc\xf2\x34\x66\x3e\xd8\xb3\xab\x40\x57\x0b\x8a\xe9\xab\x2a\x22\x91\xbc\xa4\xee\x2e\x3e\x2a\x42\x95\x7e\x99\x05\x5f\xac\x15\xc4\x17\x08\x6a\x6d\x22\xba\xd5\x7e\x9e\xa8\x90\x37\x08\xca\x47\x59\xfd\x11\x8a\x75\x78\xba\x67\x88\x27\xcb\x33\xd4\x73\xb3\xfc\x16\x18\x30\x8c\x7d\x71\x44\x7c\x6f\xa4\x1b\xeb\x7c\xd1\xaf\xfe\x58\xbf\xec\x1d\x28\x9f\x77\x76\x61\x47\x36\x5c\x9c\xe1\xd8\x61\x85\xac\x09\x56\x99\x35\x05\xbb\xac\xe9\x56\xb5\x35\xdb\xaa\xb3\x1a\xad\x26\x6b\xb9\xb5\xda\x7a\xda\x5a\x6b\x3d\x67\xad\xb7\x5e\xb4\x36\x59\x9b\xad\x6d\x56\x87\xb5\xc3\xfa\xb9\xd5\x69\xed\xb2\xba\xad\x0f\xac\xc3\xd6\x31\xab\xd7\xea\xb3\x2e\x5a\x03\xb6\x63\xfb\xed\x6c\x7b\x98\x3d\xdc\x1e\x6d\xdf\x65\xdf\x6d\x17\xdb\xf7\xd8\x13\xed\x72\xbb\xc2\x9e\x86\x3e\x3e\x6c\xcf\xb5\xe7\xd9\x0b\xed\xa5\xf6\x0a\x7b\x8d\xfd\x03\xfb\x47\xf6\xf3\x76\x8b\xbd\xd1\x7e\xd9\xde\x62\xb7\xd9\xdb\xed\xd7\xed\xb7\xec\x5f\xd9\xbf\xb1\xf7\xda\x07\xed\x23\xf6\x09\xfb\xb4\xdd\x6f\x5f\xc2\xe6\x29\x8d\x67\xf2\xa1\xfc\x16\x3e\x82\xe7\xf3\xaf\xf2\x02\x5e\xc2\xc7\xf3\x49\x7c\x32\xbf\x9f\x57\xf2\x19\x7c\x26\xaf\xe5\x0d\x7c\x11\x5f\xc6\x57\xf2\xa7\xf8\x33\xfc\x59\xfe\x02\xdf\xc0\x5f\xe2\xad\x7c\x2b\x6f\xe7\xaf\xf1\x37\xf8\x3b\xbc\x8b\xef\xe6\xfb\xf9\x21\x7e\x94\x9f\xe4\x67\xf9\x79\x7e\xd9\xb1\x1d\xaf\x13\x70\x72\x9d\x5b\x9d\x51\xce\x9d\xce\x18\xa7\xd0\x09\x39\x13\x9c\x32\x67\x8a\x33\xd5\x99\xee\x54\x3b\xb3\x9d\x3a\xa7\xd1\x69\x72\x96\x3b\xab\x9d\xa7\x9d\xb5\xce\x73\xce\x7a\xe7\x45\x67\x93\xb3\xd9\xd9\xe6\x74\x38\x3b\x28\x66\x0a\x05\x4d\xab\xc3\xd8\x6c\x17\xbc\xb5\x9d\xf8\x4a\xe2\x2b\x89\xef\x22\xbe\x4b\xf0\x76\x01\xe9\x17\x08\x9e\x1d\xa4\xb8\x3a\x48\x3a\x13\x49\x67\x22\xe9\x68\x36\x75\x9e\x9d\x25\xfd\xb3\xa6\xcd\x38\xfb\x5e\xd2\xf7\x5e\xc9\x8e\xe5\x90\xbe\x63\xfa\xa9\xfb\x16\xc7\xeb\x36\x75\x3e\x95\x8e\x26\x8f\xf3\xed\x22\xc9\x2f\x26\xf8\x93\xa2\x2f\x71\x75\x53\xe8\xa7\x94\xa7\xf2\x21\x05\x3e\xa9\x6c\xc6\xf9\x3c\x18\x3e\x05\xe6\x37\x3a\x4e\xae\x27\x36\x52\xc6\x40\xaa\x71\xbf\x8e\xb1\x46\x5f\xce\x46\xfb\xb2\xdd\x73\x30\x8a\xc3\x26\xe2\x37\x29\xfb\x07\xaf\xd6\x6e\x8a\x3e\x0e\xfe\x0a\x92\x13\xfd\xa6\xa3\xf8\xa2\x63\x37\x7d\xc9\xf1\xb7\xce\x61\xfa\x6e\xe3\x71\xe7\x82\x73\xd9\xdb\x29\xee\x06\xb2\x72\xc6\xe8\xde\xdb\x34\xa4\x2a\xa4\x87\x91\xc4\x37\xb7\xe7\x21\x2d\x44\x5a\x8a\xb4\x02\x69\x0d\xd2\x0f\x90\x7e\x84\xf4\x3c\x52\x8b\xb8\x6e\x23\x7f\x19\xf9\x31\x4f\x39\x5d\x45\x04\xdd\x2c\x28\xce\xc0\x98\x44\xd2\x8d\x82\xba\x1b\x12\xe4\x92\xe6\xc6\x49\xd6\x08\xea\xf4\x0a\x9a\x16\x20\x49\x7b\x74\x1e\xbf\xfb\xff\xcf\xe3\x5f\x6e\x1e\xa7\xbb\x97\x44\xad\xed\x1a\xad\x8c\x51\xfb\x37\xc4\x3f\x4b\x7c\x41\x8c\x5a\x25\x1a\xbd\x25\x46\x75\x9b\x3a\xc5\x8a\x39\x4a\xa5\xb5\x24\x54\x6f\x77\x75\x72\xea\xce\x8c\xd1\x94\xed\xea\x7e\x76\x69\xb4\x3f\x46\xed\xa3\xa6\x44\xc9\x77\xc4\x78\xac\x4f\x62\x72\xdd\xbe\xee\xd5\xf0\x18\x4d\xb4\x96\x58\x37\x95\x3c\x25\xce\x83\xc0\x27\xce\x4f\xdd\xb7\x14\x63\x91\x8a\x5a\xf2\x6e\x76\x95\xbb\x2b\xca\xcf\x16\xfc\x8d\x8e\x93\xb8\xd8\xd8\xa4\xd1\x41\xf4\x3d\x95\xcd\x54\xe3\x9e\x38\xd6\x92\x0e\x66\xac\xe3\xfa\xa2\xe3\xa0\xfb\xa9\xb7\x52\x99\x82\xea\xfa\xb1\xfe\x0e\x7e\x1e\xbf\xd5\x79\xd7\xd9\xe5\xec\x89\xfb\x02\xef\x91\x24\xdf\xdc\xfd\xdc\x39\xe7\xfc\xde\x71\xe5\x37\xd0\xd8\xad\x6c\x30\x33\x38\x53\x33\x38\xc3\x9e\x57\x7c\x95\x91\x31\xd1\xc7\xd7\x91\xde\x42\xfa\x15\x92\x18\xe9\xbd\x48\x62\xbc\xc4\x53\x8e\x13\xc8\x4f\x23\x89\x3e\x5f\x12\x03\x49\x6b\x6d\xb1\xab\xf8\x4b\x26\xf9\x11\x51\x49\x84\x97\x54\x1c\xbd\xeb\x2a\x3a\xa6\x3e\x8b\xd3\xbf\x82\x44\x46\xb0\x94\xbb\x47\xa2\x94\xd3\x1e\xc8\xa2\x96\x0a\xe9\xf8\x50\x50\xdb\xb9\x80\x6b\x5f\x8a\x7b\xf4\x2c\x70\xa5\xeb\x26\x2c\xda\xb0\x38\x9e\x6c\x32\xc3\xe2\xd5\xea\x26\x6f\xf1\x2a\x3e\x52\x64\x30\x8a\x09\x8b\x62\xe2\xf6\x1b\xed\x63\x92\x16\x85\x8f\x53\x94\x8f\x33\xc9\xe2\x4d\xa0\x79\xd7\x10\x99\x91\xb8\x4c\x85\xba\x3f\x99\xad\x3f\x42\xbb\x59\x57\xa9\xf7\x07\xf5\x20\xe9\x58\xfe\xdf\xf7\x20\x15\xf6\x36\xdd\x57\x8c\x45\x51\xee\x55\xa3\xe7\xca\xe7\x96\xe8\x49\xb1\xea\xc9\x94\x41\x5a\x4c\x35\x6e\xb2\x9d\xeb\xf4\x31\x45\xa4\x7f\x09\x1f\x93\xe2\x1a\xf3\x71\x0a\x6b\xd0\x7c\xbc\xf9\x4b\x8e\xdf\xd5\x63\x25\x15\xee\xc2\x83\xd9\x7f\x10\x0f\x92\xc7\xca\x95\xda\xfd\xa3\xf5\x3c\xe9\x68\xfe\x11\x7a\x9e\x6c\xec\xd5\x5d\xe5\x8d\x7f\xe2\x77\x95\xd5\x9e\x9a\x76\x97\x63\xae\xc4\xeb\x12\x45\x3b\x63\xbc\xbb\x2d\xb9\x4e\x2a\x9b\x89\x54\x1d\xed\xbc\xba\xfe\x60\xe4\x89\xfe\xc4\xd5\x1a\x9f\x82\xbf\xa2\xcd\xab\xf4\x25\x01\x8d\x54\x9a\x49\xec\x24\xf6\x5a\x7a\xb5\x51\xa3\xd2\x72\x7e\x8c\x6a\x36\x07\xbf\x96\xe4\xce\x3f\x3b\x1f\x39\xc7\xe8\x5d\x86\x00\xcd\x6d\x0c\x2b\xc5\x24\xfb\x71\x15\xbf\x2f\xfe\x69\xc7\x2f\xbf\x4c\xf7\x4b\x76\x10\x72\x2d\x82\xf2\x51\x44\x9f\xd2\x22\xf7\xd9\x98\x44\xea\x4b\x39\xcf\x8c\x51\x69\x41\x1e\xd5\x75\xac\x3a\xad\xee\x53\x9a\x7d\xad\x15\x5e\x4d\x74\x32\xd9\x39\x2a\xa8\x87\x46\x8f\x77\xcb\xfb\x43\x26\xe5\x27\xb4\xd6\x35\xff\xa5\x35\x69\x41\xf7\x47\x4a\xa4\x35\xcf\xc1\x98\x7d\x9d\xd7\x3d\x4f\x82\x49\x66\x0a\x4c\xb4\x9e\x4a\x7d\x9d\xaa\xa3\x3a\x02\x1a\x62\x57\xee\xb5\xb4\xaf\xfa\x72\x34\x86\x58\x9c\xfd\x98\xb5\xc1\xc7\xaf\xed\xbc\xef\xec\xa7\xf7\xca\xfc\x4c\x3c\x19\xfd\x73\x8c\xd9\x13\xb4\xc7\xfc\x47\xa2\x72\x27\xbb\x91\xf6\xa4\xcf\xd3\x3e\xe6\x2b\x74\x9d\x3a\x4b\x92\xd7\x88\xfe\x1d\x49\xda\x89\xef\x26\xfd\x37\x63\x3b\x56\x87\xde\x59\xe3\x6f\x50\x5d\x7a\xde\x6d\xfd\x94\x24\x72\x9f\x5b\x4d\x94\x5a\xe4\x93\x62\x7b\x55\xdb\x8d\x59\xb0\x2f\x92\x9d\x10\xe9\x1c\x26\xc9\x87\x44\xa5\x9f\x3b\x62\x16\x24\xef\x70\xcd\xe7\xbf\x25\x7e\x9f\xe9\x8f\xb4\xc9\x3f\x8d\x59\x4e\xa4\xfc\xb2\x49\xe3\x30\xf9\x69\xcc\xbe\x65\x69\x98\x5c\x11\x0d\x4e\x9e\x58\xd2\xb7\xbf\xd7\xfa\x3e\x8c\x45\x77\xfd\x49\x7a\xbd\x2f\xd6\x8a\xf2\x81\x6c\xf2\x0c\x66\xdc\x1f\x90\x2d\x12\xbd\x96\x98\xdd\xed\xf4\xc4\xc7\x2c\xf6\xc1\xf2\xfd\x01\xb9\x53\x9b\xa0\xad\x4f\x86\x45\x6b\x5c\x7d\xcd\x63\xb1\x61\x1e\xdb\xc3\x3d\x1e\x4f\x9a\xc7\xe7\xc9\xf4\x64\x7b\x6e\xf1\x76\xd1\xb3\x30\xf1\x9d\x7d\xf1\x95\xfd\x23\xde\x1e\xef\x71\xef\x29\xef\x59\xf1\xad\x74\xb4\xc6\xb1\x27\xce\x67\x5f\x15\x35\x93\xb4\x67\xd1\x1d\x57\xcb\x39\x71\x03\x2c\x9f\xbb\xc1\x96\x7b\x6f\x98\xe5\x53\x37\xcc\xf2\x99\x1b\x66\xf9\xec\x97\xb0\x2c\x22\x71\x74\x8a\x48\x94\x76\xaf\xdd\xa2\xf4\x34\x62\xf1\x2b\xa0\x69\xb4\x8a\x96\x2b\xe8\x73\x71\xe3\x37\x58\xfd\x03\x6a\x54\xae\xcd\xfe\xe0\xf5\xa5\xfd\xd3\x83\xd6\xdf\x7d\x8d\xfa\xbb\xd4\xd8\x0f\x56\xff\x84\x1a\xd1\xc1\xea\xf7\x5e\xa3\xfe\xae\x6b\xd4\xdf\x7d\x8d\xfa\x07\xae\x51\xff\xe0\x35\xea\x9f\xd3\xf4\x47\x63\x66\xb5\x11\xb9\xc3\x55\x8d\x5b\x34\x8b\x1f\xb2\xc8\x5b\x15\x96\x67\xe8\x20\xb5\xfb\x95\xb6\x15\x78\x8d\xde\xd4\x9a\x89\x75\xc4\x65\xcb\xb6\xee\xc2\x5a\xa1\x12\xeb\x83\x15\xd6\x3b\x36\xb3\xef\xb1\x97\xd9\x6b\xec\xf5\xf4\xf7\x92\xdd\x65\x1f\xe1\x21\x3e\x81\x37\xf0\x67\xec\x2e\xbe\x91\x7f\x00\xda\xef\xf8\x9d\x6c\xe7\x39\x8f\xe3\x19\xea\x19\xee\x29\xf7\x4c\xf5\x6c\xf6\x6c\xf3\x9c\x4f\xcb\x4f\x9b\x92\xd6\x94\xf6\x62\x5a\x3b\xfe\x5e\x4b\x67\xe9\x93\xd2\x57\xa4\x9f\xf6\x3a\xde\x80\x77\xbc\xf7\x61\xef\x7a\xef\x56\xef\x5b\xde\x3e\x5f\x85\xef\x69\xdf\x65\xff\x0b\xfe\x1d\xfe\x0f\xfc\x47\xfd\x27\xfd\xfd\x19\x77\x67\x54\x65\x3c\x9d\xb1\x21\xe3\x9d\x4c\x27\xf3\xce\xcc\x82\xcc\xe9\x99\x4d\x99\x2d\x99\x5d\x99\x7b\x87\x78\x87\x7c\x75\xc8\xd4\x21\x4f\x0f\x79\x6b\xc8\xa1\x40\x76\x60\x58\x60\x54\x60\x42\x60\x66\xa0\x31\xb0\x36\xf0\x5c\x60\x53\x60\x13\xd6\x46\xf9\xee\x3a\x16\x74\x0f\xb0\x30\xd2\x3d\x48\xe3\xdd\x76\xfe\x35\x77\x1d\x2f\x43\xfa\x2b\xa4\xfb\x91\xa6\xbb\x07\xf8\x83\x90\x7f\xd7\x6d\x17\xf8\x83\xfa\x18\xa7\x7a\xb7\xb1\xf0\xc0\x45\xd4\xab\x46\xbd\x32\xf6\x90\x5b\xc7\x66\x20\xaf\x76\xcb\xd2\x8f\xe2\x18\x67\x59\x38\x92\x83\x94\x8f\x23\xe9\xa8\xd3\x8e\x3a\x65\x68\xab\x0c\x75\xea\x50\xa7\x08\xba\xeb\xa0\x5b\x06\x3c\xc5\xd1\x2c\xd4\xca\x41\xca\x87\xc4\x03\xdd\xef\x43\xb7\x1a\xba\xeb\xa0\xbb\x0e\xba\x5b\x19\xc6\x0a\x5e\x66\xa1\x76\x36\x74\x72\x90\xdf\xe6\xb6\xb0\x11\x38\x9a\x0f\xcd\x42\x1c\x2b\x73\x1f\x67\xe5\x48\x93\x91\x2a\xdc\xed\x6c\x1a\xf2\x07\x90\x4f\x47\x5e\x85\x7c\x06\xf2\x6a\xa4\x80\xb4\x04\xff\xc9\x12\xf2\xdb\x60\x6d\x04\x52\x3e\xf8\x32\x78\x31\x19\xa9\x02\x3e\x4c\x43\xf9\x01\xe4\x55\x48\xd5\x90\xa9\x9a\xa8\x95\x8d\x76\x73\x90\xdf\x06\xdf\x47\x20\xe5\xe3\x68\x19\xfc\x98\x8c\x54\x01\x6f\xa7\x21\x7f\x00\x79\x15\x52\x35\x6a\x67\xc9\x5e\x52\x9b\xb7\xa9\x36\xcb\x50\xb3\x4c\xd5\x2c\x42\xcd\x22\xd4\x5c\x87\x9a\x45\xec\xdb\x90\x57\x42\x5e\x85\xf4\x10\xca\x36\xfb\x86\x7b\x20\xfd\x28\x7b\x1c\xd8\x64\xc1\x62\xb6\xbb\x0f\xad\xaf\x63\x53\x48\x5a\x81\xe3\x59\xee\x93\x90\x3c\x29\xd6\x12\x18\xb7\x6f\xba\x5b\xf8\x34\xa4\xe9\xee\x48\xfe\xe0\xc0\xbb\xbc\x0a\xfc\x77\x91\xd7\xb8\x8b\xf9\x02\xb7\x8e\x3f\xe1\x2e\x66\x1e\x8c\xf4\x8b\x18\xe9\x9d\x18\xe9\x17\x31\xca\x2d\x18\xe5\x16\x76\x33\x2f\x1b\xd8\x06\x29\x83\x8d\x29\xfc\x7e\xf0\xd3\x90\x57\xb9\x5f\xe1\xdf\x41\xfe\xb0\x5b\xc4\x67\xc2\xfe\x2c\xa4\x39\xe0\x6b\xdd\xe9\xbc\x1e\xfc\x63\x48\x0d\xee\xc3\xbc\x11\xe9\x71\xc8\x97\xb8\x7f\xc1\x97\x21\x5f\x01\xf9\x4a\xf8\x6f\x09\xfb\x2c\x63\xb0\xbe\x21\x2e\x46\x22\x6a\xb2\x5c\x3f\xfa\xe4\xe7\xa5\xac\x02\x5e\xfd\x02\x5e\x05\xe0\xd1\x2f\xd0\xda\x76\xe0\x20\x6c\x4d\x43\x7c\x4e\x47\xbd\x07\xdd\x49\xf0\x7e\x12\x0b\xc0\xfa\x62\x48\x17\x43\xfa\x32\x2c\x2f\x86\xc7\xed\xf0\xb4\x1d\x9e\xb6\xf3\x3a\xa4\x79\x48\x0b\x91\x96\x20\x2d\x43\x7a\x12\x69\x35\x46\x26\x0d\xf6\xde\x4b\xf0\x0d\x7e\x11\xe2\x23\xe1\xc7\x48\xe0\x55\x0e\x1f\x66\x02\x2f\xec\x32\xf8\x52\x44\xc2\x28\x2d\x26\xcb\x55\x4c\x6e\xc0\xa8\x6e\x90\x3e\xbb\xd5\xd0\xaf\x84\xd5\x03\xa8\x73\x07\x79\x5b\x85\xf4\x1d\xa4\x87\xe1\xdb\x23\x48\x73\x90\x6a\x80\x7d\x2d\xf2\x47\x91\xea\xe1\x0f\xfa\x07\x24\xdb\x81\xc6\x76\xa0\xb9\x18\xbe\x2e\x86\xaf\x8b\x81\xcc\x76\xbe\x1c\xf2\x66\xa4\x95\x28\xaf\x82\xdf\xc3\x55\x5c\x5d\x82\x07\xc2\x4b\x1b\x1e\x94\xc3\x83\xf2\x6b\x1a\xc7\x1a\x77\xec\xa0\xc7\x92\x53\xdc\x3c\xe8\xd6\x02\xf1\x5a\x66\x03\xc1\xd7\x81\xe0\xeb\xcc\x0f\xab\xcd\xb0\xd6\x0c\x4b\xcd\xc0\xf9\x00\x6a\x37\xa3\x76\x33\x6a\x37\x43\xab\x19\xb5\x9b\xa1\xd9\x8c\x3a\x91\x68\x1b\x26\xbc\x4f\xe1\xe9\x94\xeb\x8c\xb8\x47\xdd\x0f\x59\x0e\xea\x77\xa0\xfe\x36\xd4\xed\x40\x2f\x3b\x50\xbf\x03\xf5\xb7\xc1\xbf\x0e\xd8\xf8\x1b\xd8\x78\x1b\x38\x77\xc0\x86\x88\x89\x0e\x8c\xea\x3c\xd8\xe9\x80\xbf\x1d\xb0\xd3\x01\x7f\x3b\x58\x06\xac\x9c\x86\x85\xd3\xa8\xbd\x07\xd1\xb3\x07\xda\x7b\x78\x13\xd2\x12\xa4\x65\x90\x3f\x89\xb4\x12\xfc\x6a\xf7\x34\xf3\xa1\xbd\xd3\x7c\x36\xfa\x5f\x8f\xfc\x31\xf7\x38\xda\x38\x8d\x36\x7e\xcb\xbf\x07\x59\x33\xd2\x2a\xc4\x8c\x3f\x21\x32\x45\x54\x0a\x2f\x9a\xb4\xe8\x5c\x89\xb1\x15\x9a\x7b\xa0\xb9\x87\x5a\x8f\x6f\x79\x0f\x5a\xde\xa3\x5a\xde\x23\x22\x75\xa0\x07\x73\x4b\x0f\x9b\xef\xae\x62\xcd\xee\xce\xf4\xdf\xb9\x3b\x99\x85\xb3\xa9\x05\x48\x74\xe2\x4c\xff\x35\x70\xdf\x8d\xb4\xc7\xad\xe0\xdd\x48\xef\xbb\xab\xf8\x7e\xc4\xf9\x21\x1c\xfb\xc8\xed\xe1\x47\xdc\xf5\xfc\x18\xf8\x33\xc8\xfb\x90\x7f\x0e\xdd\x7e\xa4\x73\x6e\x1b\xac\x54\xb0\x6c\xfe\x26\xb4\xde\x76\xdb\xf8\x2f\x71\xb4\x8b\x2c\xf6\xc1\x62\x1f\x2c\xf6\xc0\xe2\x76\x58\xfc\x88\xef\x85\x7c\x3f\x6a\x1d\x80\xde\x61\x77\x07\xef\x41\xb9\x17\xc7\xfb\xe1\x4d\x00\x16\x56\x69\x16\xda\x54\xcd\x19\x5a\xad\x9f\xa0\x56\x0b\xd5\xea\xc7\xb1\xf3\x48\x17\x51\x73\x38\xce\xb3\x3c\x44\x78\x5e\xa4\x77\xb0\x74\x3b\x2c\x55\xf0\x4e\x56\x04\x4b\xb5\x7c\x27\x34\x7f\x0d\xf9\x6e\xe4\x87\x51\xfe\x08\xfc\xc7\x68\xa1\x07\xfc\x31\x77\x2e\xff\x04\x7c\x2f\xf8\x53\xc8\x4f\x23\x9d\x41\xdd\xcf\xe0\x4d\x3f\xf8\xcb\xc8\x7f\x8f\xe4\xba\x2d\x0e\x73\x6b\x09\x39\x0f\x59\xee\x66\x79\xfc\x10\xf2\x63\xc8\x4f\x30\xcc\xc5\x90\xe6\xa1\xbd\x1e\xc4\x85\xc4\x54\xb4\xb8\x13\xfd\xf8\x10\xfd\xf8\x18\xfe\xf7\x52\xcb\x47\xd0\x87\x63\xc0\x51\x60\xd9\x8f\x59\xc1\x0b\x5f\xff\x1a\xbd\xee\x41\xdd\x97\xa1\x29\x7a\x2b\xf0\x69\x8b\xe0\x03\x6c\x22\xb6\xba\xdd\x7d\x40\xf2\x65\x68\xf4\xa0\xed\x3c\x1a\x9b\x63\xd0\x3c\x81\xfc\x0c\xec\xca\xb1\x69\x83\xdd\x5a\x3e\x80\x9a\x1e\x68\x8b\xd1\x13\x5a\x7d\xd0\xd8\x49\x58\x4b\xe9\x31\xaa\x43\x12\xe0\xd8\x06\xaf\xdf\x84\x85\xb7\x91\xe4\x08\x20\x22\xd0\x42\xb7\xfb\x43\xfe\x3e\xf2\xbd\x98\xdf\xf6\x43\x7e\xd8\x9d\x0f\xbf\x7a\x70\x86\x66\xb9\x0c\xa8\x33\x86\x2b\x22\xf6\x1c\x15\xac\x19\x58\xbc\x39\x70\x09\x16\x6a\x61\x61\xbb\x42\xa3\x96\xff\x1a\xb9\xb0\xb4\x87\xac\xed\x44\xdb\x1f\xc2\xda\x02\x58\x5a\x05\x4b\x6d\x51\x3f\x06\x58\x11\x10\x6e\xa3\x48\x90\x7e\x74\x51\x8f\x7b\xa0\xfd\x1e\xb5\x7d\x40\xf4\x05\x56\x04\xe2\x7d\x48\x9f\xcb\xd8\x81\xf7\x3d\xa8\x9d\x07\x4f\xb2\x70\x86\xe7\x20\xcd\x47\x64\x37\xa3\x96\xb4\xb4\x8a\x7a\x23\xa3\xa0\x07\xed\xef\x21\x74\x65\x14\xb4\x10\x7e\x9f\x80\xff\x94\xd0\x6e\x41\x14\x88\x38\xaf\xe5\x67\x21\xff\x0c\xa9\x8f\xf0\x6c\x41\xbc\xb5\xf0\x4b\x14\x11\x2d\x5a\x44\xb4\xb1\x3b\x71\x76\xb5\xe1\xec\x6a\xc3\x0c\xdb\x86\x19\xb6\x0d\xad\x03\x0d\x68\xbc\x39\xf0\x04\x5a\x1f\x8b\x68\x10\x63\x9b\x47\x67\xd9\xfb\xb8\x92\x1d\xa2\x38\xcc\xc3\xb8\xac\x82\x07\x79\x1c\x67\x10\xef\x19\xf8\x08\x9e\xf8\xf9\x71\xf0\x27\x90\x3e\x41\x3a\x09\xfd\x4f\x91\xf7\x42\xe7\x14\xf2\xd3\x48\x67\xc0\x9f\xa5\xf8\xac\x80\x67\x7e\x78\x55\xc4\x2f\x80\xff\x02\xe9\x12\x92\xeb\x56\xc0\xab\x3c\x8a\x53\x9f\x3a\xa7\x2a\xa2\xe3\xb0\x87\x10\x9d\x0b\x34\x57\xc1\x03\x61\xb9\x85\xa5\xab\x68\x5d\x8f\x08\x6b\x83\x7f\x15\xe4\xdf\x19\x8a\x7f\xac\x20\x08\xb3\x33\x18\x71\x8b\xf7\x03\x63\x1b\xf5\xbe\x8f\x73\x7e\x15\x8d\x53\x2b\xac\xcf\xc3\x68\xaf\x82\x8d\x36\xb4\xb2\x15\x28\x6f\xd5\x22\xbf\x16\x63\x37\x1f\xad\xfd\x85\xea\xf3\x4f\xa8\xa6\x1f\xb5\x2a\x29\xca\x64\x8c\xac\x22\xdf\xde\x87\x7c\x2f\xbc\x38\xec\xfe\x38\x1a\xf9\x22\x26\xdb\x54\x44\x3d\x4e\xa3\x18\xe9\xc5\x5e\x5c\xc9\xf6\xab\x73\xe4\x38\x64\xbd\x14\xed\xbd\x6c\x28\xd0\xe9\x41\x64\xbc\x07\xef\xd7\x23\x32\xb6\xc2\xaa\xd0\x11\x51\x76\x9c\xac\xee\x04\x96\xbd\x74\x6e\x9f\x47\x42\xe4\xf3\xff\xed\xee\x04\x66\x3b\x59\x96\x9a\xeb\x7a\x54\x8d\x7e\xd4\x78\x9b\x66\xa8\x53\x88\xd9\x33\x38\x83\xfa\x20\xfb\x9c\xce\x99\xd7\x30\xf7\xf5\x68\xb5\x7b\x98\x37\x32\x0f\xa1\x76\x0b\xb5\xd7\x0b\x0f\x4e\xc9\xe8\x26\xfb\x36\xe6\x89\x3c\x11\xe7\x58\x2d\x4f\x16\x67\x2f\x13\xba\x3d\x24\xed\xc3\xd9\x23\x62\xf9\x1c\xf8\xc8\xcc\x96\xae\xce\x5c\xa9\x21\xce\x91\x3e\x5c\x25\x70\x04\x6d\xf6\x60\x74\x7b\x50\x3a\x8e\x24\x8e\x9e\xc2\x0c\x73\x06\xde\xf5\xbb\xef\xc3\xb3\x3e\x68\xed\x83\xd6\x87\x58\xcf\xcf\x07\x16\x1f\x61\xf6\x3d\x42\x7d\xda\xa9\xe6\x8a\xc8\x3c\x2e\xce\xa0\x8f\x51\x43\x9c\x45\xdb\x68\xce\xb0\xa1\xdd\x47\xe7\x53\x26\x5a\x78\x9b\xce\xb6\xe3\x6a\xa6\x3e\x85\xab\x95\xf0\x54\xd6\x13\x08\x8a\x7a\xef\x09\x6d\xf4\xf0\xb7\x98\xcb\x22\xfd\x91\xda\x1f\x29\x4d\xea\x8f\xec\x39\xf5\x3a\x72\x16\x9f\xa0\x5e\xf7\x68\xbd\xde\x47\x2d\x0f\x01\x96\xb5\xc0\xb2\x36\x8a\xd1\x71\xd2\xce\xa3\xf1\x43\x34\xf2\xcf\xd4\x1c\xd0\x4f\xe7\x7e\x11\x8d\x40\x56\xf4\xfc\xbf\x0d\xa5\x11\x48\x62\x4e\x8a\x8d\xe9\x2a\x15\x05\x62\x64\x5e\x8e\x8c\x8c\xe8\x3b\x8d\x4e\x9a\x8a\x3a\x39\x23\x9e\x03\x96\x17\xdd\x77\xc9\x6e\xa6\xb2\xd1\xa6\xe1\x27\xe6\x85\xb7\x55\x2c\xb4\x89\xeb\x20\xb4\x5b\x80\x78\x1b\x61\x28\xee\x2b\x8a\x73\xe5\x73\x92\xcf\xc5\x48\xf6\xb8\x2f\xa0\xe5\x76\xd8\x3f\x80\x96\x4f\x93\xfd\xf3\xee\x36\x19\x39\x38\xba\x5e\x8b\xce\x1e\x42\x4d\x69\xd0\xdc\xcc\xa3\x3d\x6b\x86\x5d\xb1\x02\x1e\x87\xd2\x38\xf4\x73\x27\xfa\xb9\x53\xcd\x38\x6d\xea\xba\xfe\x31\xd6\x9b\x62\xf7\x54\x87\x1d\xce\x3a\xf6\xa0\xd8\x0b\x80\xf7\xf0\x7f\xc0\x5c\xb1\x03\x69\x0f\xd2\xfe\x81\x55\x98\x4f\xb1\x1e\xc2\x9e\x95\x63\x07\x9d\xcf\xfe\x05\xfb\x97\x18\x9f\x71\x2c\xc8\xc2\xec\x1e\x36\x9e\x7d\x83\x3d\xc0\x1e\x62\x33\x58\x35\xff\x1a\x9f\xc8\xef\xe5\x93\x78\x19\xc7\x3a\x97\x7f\x93\x7f\x8b\xdf\xcf\xa7\xf1\x4a\xfe\x00\x9f\xce\x1f\xe4\x55\xfc\x21\x3e\x83\x7f\x87\x7f\x97\xd7\xf0\x3a\xec\x6a\xe7\xf3\x85\xfc\x09\x7a\x53\xf1\x9f\xf8\x9b\xfc\xe7\xfc\x17\xfc\x2d\xfe\x36\x7f\x87\xff\x92\x77\xf2\xf7\x78\x17\xc7\x5c\xc3\xff\x99\xef\xe6\x7b\x78\x37\x7f\x9f\xef\xe5\xfb\xf8\x07\xfc\x00\xff\x90\x1f\xe2\xbf\xe3\x88\x52\xfe\x31\x3f\xca\x11\xf5\xfc\x38\x3f\xc1\x3f\xe5\xa7\xf8\x19\xfe\x19\xef\xe3\x9f\xf3\x7e\x7e\x8e\x9f\xe7\x17\xf8\xef\xf9\x00\x77\x9d\x2c\xe7\xde\xf4\x8f\xd3\x8f\xa6\xf7\xa4\x7f\x82\x3e\xf8\xb1\xc6\xc9\x03\x55\x3b\xf8\x3f\x93\x3b\xfd\xfa\x93\x98\xbd\xda\x73\xa3\xee\x98\x44\xbe\x5d\x2c\x35\x9d\xfc\x04\x4d\x49\xfd\x09\x4f\xa7\x36\x69\x9a\xdd\xda\xd1\xe5\x1a\xbd\x9c\xf0\xec\x8a\x9e\xd6\x78\xd6\x6a\x47\x27\x24\xd0\xcb\x09\xbc\xe6\xb3\xe2\xb5\x67\x57\xd2\xa6\xe4\xd3\x9e\x8d\xd9\xd7\xf9\x94\x4f\xa7\xae\x88\x49\x4a\x34\xb4\xd6\xe3\x10\xd0\xfb\x7e\xc5\x5e\x2b\xcc\xa7\x69\xb4\x23\xe1\xf9\x56\xac\xc5\x6b\xb9\xd3\x2f\xdf\x2b\xd1\xee\xf4\xcb\x77\x98\xc5\xdb\xcb\x2a\x66\xbb\xfe\xb4\x63\x36\xee\xbd\xcf\x4a\xed\x89\x11\xbd\xdf\xc9\x3a\x63\x34\xee\x9d\x4e\x92\x58\x63\x88\xca\x37\x1d\x1d\x53\x47\xd9\x1c\xa3\xc9\x0b\xb4\x5a\xf2\x1d\xca\x4d\x1a\xdf\x15\x7b\xe6\x94\xea\x9d\x5a\xfd\x0d\x4e\xf5\x36\x6a\x95\xe9\x73\x12\x7f\x12\x6c\x26\x52\xfe\x54\x8c\xa6\xc4\xa4\x2a\x39\x26\xb2\x47\x0a\x93\x84\xd6\xf5\xb7\x57\xa5\x3c\xae\x47\x29\x7a\xad\xac\xe9\x6f\xa0\xf6\x6b\x16\x4c\x3a\xf8\x98\xfd\x32\xef\xc2\xe4\xa1\x85\x5a\xa4\x06\xa4\x45\x4c\xfc\x6f\x11\xc6\x56\x22\x09\xb4\x9e\x41\x12\xfe\xbd\x80\xb4\x01\xe9\x25\xa4\x56\xa4\xad\x48\xe2\xa9\x9d\x78\xa6\xf9\x06\xd2\x3b\x48\xa2\xaf\xbb\x91\xf6\x23\x1d\x42\x12\x6f\x69\x9f\x44\x12\x4f\xfa\xce\x33\xcb\xcd\xa6\xf7\x38\x07\x41\x07\xb6\x0c\x56\xd3\xa5\x5f\xd3\x46\xe9\x15\x24\x8c\xc5\x49\xa2\x54\x9d\xc7\x1d\x7f\xea\xe7\x31\xcd\x8f\xf2\x77\x38\xf2\xd7\x2f\x5d\xb1\xb9\x4f\xfe\xde\x46\xfe\xd2\x26\xf2\xdb\x15\x92\x9f\x8d\x69\x2a\xfd\xe7\x4d\x1d\xf5\xdb\xaa\xca\x98\x35\x45\xbd\x1a\x2d\x30\x79\x65\xed\xa2\x66\xa7\x2b\xa1\xad\xaa\x14\xbc\x6e\xa1\x35\xb9\x66\xe2\x7b\x16\x7a\x5b\x71\xfe\x0f\x1a\x93\x24\x68\xe8\xad\x57\xa6\xe8\xfb\x15\x7b\x1d\xf7\x7b\xdd\xce\x18\x9e\xca\x72\xab\xd1\xe2\xe0\xcf\xe3\x2b\xbf\xa1\x28\xde\xf5\xb9\x07\x69\x22\xbb\xd6\xdf\xfb\x08\x3f\xc4\x1b\x16\xed\xf4\xab\x9e\x5b\x88\x1e\x26\x49\x27\xf1\x63\x88\xd6\x69\x7c\x7f\xec\x68\x52\xba\xe6\xcf\xf7\x5a\x68\xb7\x6a\xd7\x15\x27\xc5\x75\x4e\x4a\xca\xb4\x99\xba\x8e\x24\xab\x89\xca\x67\x4d\x6b\xcd\x2b\x81\xfa\x15\x85\xf6\x7b\x14\x7a\x33\x3f\xc2\xaf\x4d\xb8\x2a\x68\xd6\x92\x5c\x0b\xf5\x5f\x36\xb4\x26\x5c\x0b\x75\x7f\x06\x71\x2d\xd4\x7f\xa5\x71\xad\x98\x28\xbe\x35\x79\xeb\x71\x08\xec\x30\xfb\x92\xaa\xd7\xaa\x95\xc4\x6b\x61\x9d\x66\x3f\xe6\xff\xff\x13\xd7\x42\x9c\x0f\xb9\xda\x5a\x23\x97\x50\xc8\xd5\xe4\x23\xa2\xb8\xd4\x29\x8c\xee\x20\x7c\x63\x47\x2b\x89\x4e\x8c\xd1\xb8\x55\xdb\x18\x92\x8f\x49\x2e\x51\x71\xb6\x82\x24\x1a\x15\xff\x83\x01\xb6\x62\xef\xb8\x88\xd6\xd2\x06\x26\x0f\x6c\x19\x58\x38\xd0\x0d\x7a\x39\xc9\x13\x5b\xfa\x05\x3a\xfe\x32\xe9\x29\x6b\xa7\x1b\x52\x4f\x5d\x19\x53\x57\xdd\xae\xaf\xbf\xf4\x6b\x91\x77\x96\xfd\x66\x17\x95\x7f\xec\x0e\xff\x3f\x01\x00\x00\xff\xff\x9c\x26\x59\xe6\x00\xed\x05\x00") + +func liberationserifRegularTtfBytes() ([]byte, error) { + return bindataRead( + _liberationserifRegularTtf, + "LiberationSerif-Regular.ttf", + ) +} + +func liberationserifRegularTtf() (*asset, error) { + bytes, err := liberationserifRegularTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "LiberationSerif-Regular.ttf", size: 388352, mode: os.FileMode(420), modTime: time.Unix(1459927770, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _readme = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x7c\x55\x7f\x6b\xdc\x46\x10\xfd\xdf\x9f\x62\x30\x85\x6b\xcb\x59\xc2\x71\x7f\x40\x20\x94\xc4\xb5\xa9\xc1\xb1\x8b\xef\x92\x50\x4a\x29\x7b\xda\xd1\x69\xf1\x4a\xab\xee\xae\x7c\x56\xfe\xe8\x67\xef\x9b\x5d\xc9\xe7\xda\x4e\x0c\xe6\xc4\x6a\xf6\xcd\x9b\x37\x6f\x46\x44\x74\x5c\xd0\xa7\x46\xc5\x45\xa0\xd8\x98\xf0\xcb\x01\xd1\x9b\xa7\x7f\x07\x38\x5c\x37\x4c\x97\x66\xc3\x5e\x45\xe3\x3a\x3a\x77\x5d\x0c\x64\x02\xd5\x78\xa0\xca\x59\xcb\x55\x7a\xb1\x6b\x4c\xd5\x90\x32\x2d\xf0\x1c\xf5\xde\xdd\x19\xcd\xa4\x5d\x35\xb4\x8c\x48\x20\x59\x35\xba\x41\xee\xb4\x3d\xb0\x36\xc6\x9a\x38\x92\x0a\x34\x04\xb5\x65\x72\x35\xad\x4d\xcb\x81\xae\x78\x47\x37\xae\x55\xdd\x92\xde\x7a\xa3\xec\x92\x4e\xdd\xe0\x0d\x7b\x79\x53\x1c\x08\x27\x7a\x55\xd0\x0d\xff\x33\x18\xcf\x02\x1e\xbe\xc4\xfd\xfb\xc4\xb2\x76\x1e\xf8\xa0\x6c\xba\x10\x15\x08\xeb\x42\x30\xe8\xdb\x26\xc6\xfe\x75\x59\x3e\xc4\x14\x01\x89\x2a\xce\xcf\x1d\xc7\xef\x72\xb2\x93\x82\x2e\xf2\xcd\x27\x79\xe4\xed\x49\x71\x4c\xbf\xb2\xd4\xe4\x39\xa0\x74\xe5\x37\x12\x98\x12\xfc\xe1\x06\xaa\x54\x47\x7c\x1f\xbd\xaa\x22\x74\x66\xaa\x8d\x45\x8d\x9b\x11\xcc\xac\x75\x3b\xd3\x6d\x45\x10\x54\xab\x5f\xe7\x4b\x44\xdf\x08\x0a\x7d\xbe\xbf\xab\xc9\x3e\x08\x7f\x24\x2c\xc3\xd1\x9f\x1f\xcf\x6e\x56\x17\xd7\x57\x7f\x15\x88\x29\xb6\x9f\x33\x85\x57\xf4\x6e\x30\x56\x53\xed\x5d\x9b\xb2\xe4\x42\x32\xe0\x69\xa3\x3a\xa9\xbf\x43\x5b\x34\x14\xab\xa2\xf3\xe3\x57\x90\x4b\x02\x19\xda\xec\x01\x33\x58\x22\x9d\x00\x9f\x31\x0f\x8f\xa8\x57\xfa\x2b\xd0\x0f\x51\xad\xba\x9d\xd8\x89\xbd\x24\x57\xcc\x86\xca\xf2\xec\x8c\xb5\xb4\x61\x52\x77\xca\x58\xb5\xb1\xc2\x9e\x16\x89\xd2\x62\x5f\x43\x91\x8b\x3f\x99\xbb\x23\xbe\x0b\x63\x88\xdc\x66\xe8\x73\xe7\xe9\x9c\xb5\xf3\x6a\x49\xa3\xb4\xc2\x0d\x28\x09\x84\x07\x04\x8f\xb3\x1b\x72\x57\x92\xab\x51\x60\xe5\xfa\x51\x2a\x93\xc3\xf5\xfa\x3c\x79\x39\x81\xfd\x5b\x16\x39\x08\xee\x80\x63\xe1\xc6\x9d\xf8\x3b\x79\x77\x49\x38\x43\x60\x39\x04\x5f\x86\x46\x79\x4e\x9e\x0a\x65\xf4\x03\xc7\xb1\xe7\x72\x2f\xc9\x2c\xa1\x9f\xa8\x1e\x25\x98\xa9\xd0\x34\x12\x85\x68\x02\xf3\xfb\xa1\xa3\xc3\xba\x3a\xaa\x54\xd5\xf0\xa1\xe0\x5b\x16\x0f\x29\x8c\x90\x1c\xe9\x62\x5f\xa6\x03\x5f\x0f\x65\x42\xf4\x66\x33\x48\x9e\xb0\xa4\xde\xb2\x0a\x4c\x08\xad\x6e\x29\x4f\x9e\x87\x49\x7b\xd7\x69\x29\x71\x1e\xcd\x44\x6b\x9a\xab\x1f\x0a\xfa\x20\x15\xfd\xcf\xe8\xf2\x66\x65\xda\x1e\x9a\x05\x96\x71\xc7\x74\x73\xcd\xc0\x7a\xdc\xeb\xdc\x3f\xf4\x49\xf5\xbd\x35\x55\x3a\x0b\xc9\x4a\x90\xd9\x47\x28\x85\xa4\x53\x9a\x1f\x0b\xac\x94\x8a\xbb\xc0\x2f\x4c\xd4\x1a\xdb\x28\xad\x19\x5a\xb9\x3a\xee\xa0\xa6\xcc\xae\xcd\xf1\x9a\x86\x4e\xa3\x54\xe9\xcf\xea\xe2\x92\xae\x7b\xce\x3b\x69\x06\x5c\x02\xe1\x23\xfb\x20\x8c\x8e\x8b\xe3\xa4\xd1\xef\x59\x08\xcf\x4a\x27\x83\xd1\xe1\xe5\xc5\xe9\xd9\xd5\xea\xec\x30\x35\x42\x73\x84\xfa\x61\xe2\xf6\x53\x91\x14\x7d\xaf\x30\x30\xf8\x07\xd4\x4b\xdb\x65\xe2\xfa\x4e\x96\x05\x53\xaf\xaa\x5b\xb5\x15\x51\x15\x75\x58\x5f\x9e\x73\xc6\x8d\x12\xc6\x60\x92\x8f\xf3\x20\xcd\x3b\x22\x9b\xb2\x51\x77\x38\x71\xc0\x1a\x7a\xad\x22\xa7\xca\xee\xa6\x02\xc2\x50\xd7\xe6\x5e\x44\x95\xd3\xf7\x18\x1a\xa1\x3f\x4d\x1b\x86\x8a\xde\xd0\x7e\xb6\x70\x28\x11\xb8\xe4\x39\xdb\x44\x2e\x69\x5c\xe9\x40\x62\x86\xdc\x7b\x20\x79\x7b\x36\x3f\xb8\x4d\x5a\xb7\x50\x03\x44\x14\xe0\xf2\x4a\x1f\xa7\x2d\x96\x7d\xb4\x33\xb1\xa1\x3a\x9a\xae\x76\xa5\x8b\xb5\xfc\x8a\xfb\x1f\xed\xd9\x08\x93\xd4\x58\x99\x51\xda\xd6\x98\x6d\x63\xd3\xde\xf0\xb2\x24\xe1\x37\x0d\x32\x89\x5d\xea\xc4\x22\x6f\xa7\x4b\xb7\x5d\x48\x78\xd6\x40\x0b\x33\x58\x2c\x79\xad\x4a\x01\x21\x35\xf2\x14\x2d\x84\x44\x6a\x96\x30\xb3\xc9\x35\xbc\xbc\x4d\xf3\xaa\x49\x93\x31\x7f\xcc\xa4\x13\x93\x1a\x92\xe9\x01\xe9\x85\x95\x93\x04\xc4\xd5\x52\xf0\xc5\x76\x4a\xcc\xb0\x78\xbe\xe0\xae\xce\x3e\xfd\xfd\x64\x33\x2f\x12\xe3\x9f\x0b\x21\xad\x8d\x7c\xa3\x9e\x9a\xe7\xb9\x2d\xdf\x7e\x58\xff\x76\x7d\xb3\xca\xb6\xb4\x48\x2c\x5f\xc5\x0a\x29\xd2\x54\x3b\x0f\x15\xfe\x0b\x00\x00\xff\xff\x2e\xc6\xb5\x78\xb9\x07\x00\x00") + +func readmeBytes() ([]byte, error) { + return bindataRead( + _readme, + "README", + ) +} + +func readme() (*asset, error) { + bytes, err := readmeBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "README", size: 1977, mode: os.FileMode(420), modTime: time.Unix(1459927767, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _todo = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x9c\x90\xcb\x4e\x42\x31\x10\x86\xd7\x9e\xa7\xf8\x13\x56\x24\xca\xc5\x0b\x82\x89\x31\x31\x31\xd1\x44\x57\x2c\x5c\x92\xa1\x1d\x4e\x27\x96\x4e\xd3\x0e\x1c\xe0\xe9\xe5\xc8\x1b\xb8\x98\xcd\x7c\x73\xfd\xde\xb9\x30\xe8\x1c\xa6\x5e\xb1\xd1\x82\xc4\x07\x43\xe1\xc8\x54\xb9\x99\x0e\xb1\xe4\xb2\x16\x4a\x68\xe3\x31\x87\xbf\x8a\x4e\x7e\x24\xb3\x17\x42\x30\xcb\xf5\x69\x3c\x5e\xef\xda\x93\xc4\x48\xa3\xc2\x3e\x90\x8d\x9c\x6e\xc7\x35\x68\xb7\x3a\x83\x91\x6b\xe5\x45\xfc\xf3\xec\xe1\x71\x7e\xbf\x68\xae\x6e\xf0\xb1\xcd\x45\xf7\x92\x5a\xd4\x40\x99\xa1\x1b\x2c\x57\xaf\x6f\xff\x98\x36\x70\x8b\x59\x73\x3b\xc4\xa7\xac\xb9\x90\x89\x26\x7c\x69\x52\x24\xed\x5f\x70\xda\x26\x39\xf5\x7b\xa8\x5e\xf2\x92\xf0\x2d\xc9\x6b\x57\x41\x39\x47\x71\x97\x9e\xc1\x7c\x36\x9d\x4c\xee\xfa\xdb\x72\xe1\xca\xc9\xe2\x11\x62\x90\x8a\x4c\xe6\xc2\x35\x3a\x46\xa0\x7d\x6f\x09\xbb\xec\xc9\x18\x27\x2e\x7a\x36\xe1\x2d\xc0\x05\x2a\xe4\x8c\x4b\xed\xf9\x46\x0e\xec\x2f\xa4\xf9\x0d\x00\x00\xff\xff\x61\xba\x0e\xae\x5e\x01\x00\x00") + +func todoBytes() ([]byte, error) { + return bindataRead( + _todo, + "TODO", + ) +} + +func todo() (*asset, error) { + bytes, err := todoBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "TODO", size: 350, mode: os.FileMode(420), modTime: time.Unix(1459927767, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +// Asset loads and returns the asset for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func Asset(name string) ([]byte, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err) + } + return a.bytes, nil + } + return nil, fmt.Errorf("Asset %s not found", name) +} + +// MustAsset is like Asset but panics when Asset would return an error. +// It simplifies safe initialization of global variables. +func MustAsset(name string) []byte { + a, err := Asset(name) + if err != nil { + panic("asset: Asset(" + name + "): " + err.Error()) + } + + return a +} + +// AssetInfo loads and returns the asset info for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func AssetInfo(name string) (os.FileInfo, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err) + } + return a.info, nil + } + return nil, fmt.Errorf("AssetInfo %s not found", name) +} + +// AssetNames returns the names of the assets. +func AssetNames() []string { + names := make([]string, 0, len(_bindata)) + for name := range _bindata { + names = append(names, name) + } + return names +} + +// _bindata is a table, holding each asset generator, mapped to its name. +var _bindata = map[string]func() (*asset, error){ + "AUTHORS": authors, + "ChangeLog": changelog, + "LICENSE": license, + "LiberationMono-Bold.ttf": liberationmonoBoldTtf, + "LiberationMono-BoldItalic.ttf": liberationmonoBolditalicTtf, + "LiberationMono-Italic.ttf": liberationmonoItalicTtf, + "LiberationMono-Regular.ttf": liberationmonoRegularTtf, + "LiberationSans-Bold.ttf": liberationsansBoldTtf, + "LiberationSans-BoldItalic.ttf": liberationsansBolditalicTtf, + "LiberationSans-Italic.ttf": liberationsansItalicTtf, + "LiberationSans-Regular.ttf": liberationsansRegularTtf, + "LiberationSerif-Bold.ttf": liberationserifBoldTtf, + "LiberationSerif-BoldItalic.ttf": liberationserifBolditalicTtf, + "LiberationSerif-Italic.ttf": liberationserifItalicTtf, + "LiberationSerif-Regular.ttf": liberationserifRegularTtf, + "README": readme, + "TODO": todo, +} + +// AssetDir returns the file names below a certain +// directory embedded in the file by go-bindata. +// For example if you run go-bindata on data/... and data contains the +// following hierarchy: +// data/ +// foo.txt +// img/ +// a.png +// b.png +// then AssetDir("data") would return []string{"foo.txt", "img"} +// AssetDir("data/img") would return []string{"a.png", "b.png"} +// AssetDir("foo.txt") and AssetDir("notexist") would return an error +// AssetDir("") will return []string{"data"}. +func AssetDir(name string) ([]string, error) { + node := _bintree + if len(name) != 0 { + cannonicalName := strings.Replace(name, "\\", "/", -1) + pathList := strings.Split(cannonicalName, "/") + for _, p := range pathList { + node = node.Children[p] + if node == nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + } + } + if node.Func != nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + rv := make([]string, 0, len(node.Children)) + for childName := range node.Children { + rv = append(rv, childName) + } + return rv, nil +} + +type bintree struct { + Func func() (*asset, error) + Children map[string]*bintree +} + +var _bintree = &bintree{nil, map[string]*bintree{ + "AUTHORS": &bintree{authors, map[string]*bintree{}}, + "ChangeLog": &bintree{changelog, map[string]*bintree{}}, + "LICENSE": &bintree{license, map[string]*bintree{}}, + "LiberationMono-Bold.ttf": &bintree{liberationmonoBoldTtf, map[string]*bintree{}}, + "LiberationMono-BoldItalic.ttf": &bintree{liberationmonoBolditalicTtf, map[string]*bintree{}}, + "LiberationMono-Italic.ttf": &bintree{liberationmonoItalicTtf, map[string]*bintree{}}, + "LiberationMono-Regular.ttf": &bintree{liberationmonoRegularTtf, map[string]*bintree{}}, + "LiberationSans-Bold.ttf": &bintree{liberationsansBoldTtf, map[string]*bintree{}}, + "LiberationSans-BoldItalic.ttf": &bintree{liberationsansBolditalicTtf, map[string]*bintree{}}, + "LiberationSans-Italic.ttf": &bintree{liberationsansItalicTtf, map[string]*bintree{}}, + "LiberationSans-Regular.ttf": &bintree{liberationsansRegularTtf, map[string]*bintree{}}, + "LiberationSerif-Bold.ttf": &bintree{liberationserifBoldTtf, map[string]*bintree{}}, + "LiberationSerif-BoldItalic.ttf": &bintree{liberationserifBolditalicTtf, map[string]*bintree{}}, + "LiberationSerif-Italic.ttf": &bintree{liberationserifItalicTtf, map[string]*bintree{}}, + "LiberationSerif-Regular.ttf": &bintree{liberationserifRegularTtf, map[string]*bintree{}}, + "README": &bintree{readme, map[string]*bintree{}}, + "TODO": &bintree{todo, map[string]*bintree{}}, +}} + +// RestoreAsset restores an asset under the given directory +func RestoreAsset(dir, name string) error { + data, err := Asset(name) + if err != nil { + return err + } + info, err := AssetInfo(name) + if err != nil { + return err + } + err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755)) + if err != nil { + return err + } + err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode()) + if err != nil { + return err + } + err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) + if err != nil { + return err + } + return nil +} + +// RestoreAssets restores an asset under the given directory recursively +func RestoreAssets(dir, name string) error { + children, err := AssetDir(name) + // File + if err != nil { + return RestoreAsset(dir, name) + } + // Dir + for _, child := range children { + err = RestoreAssets(dir, filepath.Join(name, child)) + if err != nil { + return err + } + } + return nil +} + +func _filePath(dir, name string) string { + cannonicalName := strings.Replace(name, "\\", "/", -1) + return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...) +} diff --git a/vendor/github.com/gonum/plot/vg/fonts/mk-fonts.go b/vendor/github.com/gonum/plot/vg/fonts/mk-fonts.go new file mode 100644 index 00000000..330b75f1 --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/fonts/mk-fonts.go @@ -0,0 +1,224 @@ +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build ignore + +package main + +import ( + "archive/tar" + "compress/gzip" + "io" + "io/ioutil" + "log" + "net/http" + "os" + "os/exec" + "path/filepath" + "strings" +) + +const ( + baseUrl = "https://fedorahosted.org/releases/l/i/liberation-fonts/" + fontsName = "liberation-fonts-ttf-2.00.1" +) + +func main() { + log.SetPrefix("mk-vg-fonts: ") + log.SetFlags(0) + + tmpdir, err := ioutil.TempDir("", "gonum-mk-fonts-") + if err != nil { + log.Fatalf("error creating temporary directory: %v\n", err) + } + defer os.RemoveAll(tmpdir) + + tarf, err := os.Create(filepath.Join(tmpdir, fontsName+".tar.gz")) + if err != nil { + log.Fatalf("error creating local fonts tar file: %v\n", err) + } + defer tarf.Close() + + urlSrc := baseUrl + fontsName + ".tar.gz" + log.Printf("downloading [%v]...\n", urlSrc) + resp, err := http.DefaultClient.Get(urlSrc) + if err != nil { + log.Fatalf("error getting url %v: %v\n", urlSrc, err) + } + defer resp.Body.Close() + + err = untar(tmpdir, resp.Body) + if err != nil { + log.Fatalf("error untarring: %v\n", err) + } + + fontsDir := getFontsDir() + err = exec.Command("go", "get", "github.com/jteeuwen/go-bindata/...").Run() + if err != nil { + log.Fatalf("error go-getting go-bindata: %v\n", err) + } + + fname := filepath.Join(fontsDir, "liberation_fonts_generated.go") + log.Printf("generating fonts: %v\n", fname) + cmd := exec.Command("go-bindata", "-pkg=fonts", "-o", fname, ".") + cmd.Dir = filepath.Join(tmpdir, fontsName) + cmd.Stdin = os.Stdin + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + err = cmd.Run() + if err != nil { + log.Fatalf("error generating asset-data: %v\n", err) + } + + err = prependHeaders(fname) + if err != nil { + log.Fatalf("error prepending headers to [%s]: %v\n", fname, err) + } + + cmd = exec.Command("gofmt", "-w", fname) + cmd.Dir = fontsDir + cmd.Stdin = os.Stdin + cmd.Stdout = cmd.Stdout + cmd.Stderr = cmd.Stderr + err = cmd.Run() + if err != nil { + log.Fatalf("error running gofmt on %v: %v\n", fname, err) + } +} + +func getFontsDir() string { + dir := "github.com/gonum/plot/vg" + gopath := os.Getenv("GOPATH") + if gopath == "" { + log.Fatal("no GOPATH environment variable") + } + + for _, p := range strings.Split(gopath, string(os.PathListSeparator)) { + if p == "" { + continue + } + n := filepath.Join(p, "src", dir, "fonts") + _, err := os.Stat(n) + if err != nil { + continue + } + return n + } + log.Fatal("could not find %q anywhere under $GOPATH", dir) + panic("unreachable") +} + +func untar(odir string, r io.Reader) error { + gz, err := gzip.NewReader(r) + if err != nil { + return err + } + defer gz.Close() + + tr := tar.NewReader(gz) + // Iterate through the files in the archive. + for { + hdr, err := tr.Next() + if err == io.EOF { + // end of tar archive + break + } + if err != nil { + log.Printf("error: %v\n", err) + continue + } + + switch hdr.Typeflag { + case tar.TypeDir: + dir := filepath.Join(odir, hdr.Name) + err = os.MkdirAll(dir, 0755) + if err != nil { + return err + } + continue + + case tar.TypeReg, tar.TypeRegA: + // ok + default: + log.Printf("error: %v\n", hdr.Typeflag) + return err + } + oname := filepath.Join(odir, hdr.Name) + dir := filepath.Dir(oname) + err = os.MkdirAll(dir, 0755) + if err != nil { + return err + } + + o, err := os.OpenFile( + oname, + os.O_WRONLY|os.O_CREATE, + os.FileMode(hdr.Mode), + ) + if err != nil { + return err + } + defer o.Close() + _, err = io.Copy(o, tr) + if err != nil { + return err + } + err = o.Close() + if err != nil { + return err + } + } + return nil +} + +func prependHeaders(name string) error { + src, err := os.Open(name) + if err != nil { + return err + } + defer src.Close() + + dst, err := os.Create(name + ".tmp") + if err != nil { + return err + } + defer dst.Close() + + _, err = dst.WriteString(`// Automatically generated by vg/fonts/mk-fonts.go +// DO NOT EDIT. + +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// +// Digitized data copyright (c) 2010 Google Corporation +// with Reserved Font Arimo, Tinos and Cousine. +// Copyright (c) 2012 Red Hat, Inc. +// with Reserved Font Name Liberation. +// +// This Font Software is licensed under the SIL Open Font License, +// Version 1.1. + +`) + if err != nil { + return err + } + + _, err = io.Copy(dst, src) + if err != nil { + return err + } + + err = src.Close() + if err != nil { + return err + } + + err = dst.Close() + if err != nil { + return err + } + + return os.Rename(dst.Name(), src.Name()) +} diff --git a/vendor/github.com/gonum/plot/vg/geom.go b/vendor/github.com/gonum/plot/vg/geom.go new file mode 100644 index 00000000..7dee9714 --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/geom.go @@ -0,0 +1,58 @@ +// Copyright ©2016 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package vg + +// A Point is a location in 2d space. +// +// Points are used for drawing, not for data. For +// data, see the XYer interface. +type Point struct { + X, Y Length +} + +// Dot returns the dot product of two points. +func (p Point) Dot(q Point) Length { + return p.X*q.X + p.Y*q.Y +} + +// Add returns the component-wise sum of two points. +func (p Point) Add(q Point) Point { + return Point{p.X + q.X, p.Y + q.Y} +} + +// Sub returns the component-wise difference of two points. +func (p Point) Sub(q Point) Point { + return Point{p.X - q.X, p.Y - q.Y} +} + +// Scale returns the component-wise product of a point and a scalar. +func (p Point) Scale(s Length) Point { + return Point{p.X * s, p.Y * s} +} + +// A Rectangle represents a rectangular region of 2d space. +type Rectangle struct { + Min Point + Max Point +} + +// Size returns the width and height of a Rectangle. +func (r Rectangle) Size() Point { + return Point{ + X: r.Max.X - r.Min.X, + Y: r.Max.Y - r.Min.Y, + } +} + +// Path returns the path of a Rect specified by its +// upper left corner, width and height. +func (r Rectangle) Path() (p Path) { + p.Move(r.Min) + p.Line(Point{X: r.Max.X, Y: r.Min.Y}) + p.Line(r.Max) + p.Line(Point{X: r.Min.X, Y: r.Max.Y}) + p.Close() + return +} diff --git a/vendor/github.com/gonum/plot/vg/len.go b/vendor/github.com/gonum/plot/vg/len.go new file mode 100644 index 00000000..d35c39db --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/len.go @@ -0,0 +1,68 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package vg + +import ( + "strconv" + "strings" +) + +// A Length is a unit-independent representation of length. +// Internally, the length is stored in postscript points. +type Length float64 + +// Points returns a length for the given number of points. +func Points(pt float64) Length { + return Length(pt) +} + +// Common lengths. +const ( + Inch Length = 72 + Centimeter = Inch / 2.54 + Millimeter = Centimeter / 10 +) + +// Dots returns the length in dots for the given resolution. +func (l Length) Dots(dpi float64) float64 { + return float64(l) / Inch.Points() * dpi +} + +// Points returns the length in postscript points. +func (l Length) Points() float64 { + return float64(l) +} + +// ParseLength parses a Length string. +// A Length string is a possible signed floating number with a unit. +// e.g. "42cm" "2.4in" "66pt" +// If no unit was given, ParseLength assumes it was (postscript) points. +// Currently valid units are: +// mm (millimeter) +// cm (centimeter) +// in (inch) +// pt (point) +func ParseLength(value string) (Length, error) { + var unit Length = 1 + switch { + case strings.HasSuffix(value, "in"): + value = value[:len(value)-len("in")] + unit = Inch + case strings.HasSuffix(value, "cm"): + value = value[:len(value)-len("cm")] + unit = Centimeter + case strings.HasSuffix(value, "mm"): + value = value[:len(value)-len("mm")] + unit = Millimeter + case strings.HasSuffix(value, "pt"): + value = value[:len(value)-len("pt")] + unit = 1 + } + v, err := strconv.ParseFloat(value, 64) + if err != nil { + return 0, err + } + return Length(v) * unit, nil +} diff --git a/vendor/github.com/gonum/plot/vg/vg.go b/vendor/github.com/gonum/plot/vg/vg.go new file mode 100644 index 00000000..86b03e7a --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/vg.go @@ -0,0 +1,169 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package vg defines an interface for drawing 2D vector graphics. +// This package is designed with the hope that many different +// vector graphics back-ends can conform to the interface. +package vg + +import ( + "image" + "image/color" + "io" +) + +// A Canvas is the main drawing interface for 2D vector +// graphics. The origin is in the bottom left corner. +type Canvas interface { + // SetLineWidth sets the width of stroked paths. + // If the width is not positive then stroked lines + // are not drawn. + // + // The initial line width is 1 point. + SetLineWidth(Length) + + // SetLineDash sets the dash pattern for lines. + // The pattern slice specifies the lengths of + // alternating dashes and gaps, and the offset + // specifies the distance into the dash pattern + // to start the dash. + // + // The initial dash pattern is a solid line. + SetLineDash(pattern []Length, offset Length) + + // SetColor sets the current drawing color. + // Note that fill color and stroke color are + // the same, so if you want different fill + // and stroke colors then you must set a color, + // draw fills, set a new color and then draw lines. + // + // The initial color is black. If SetColor is + // called with a nil color then black is used. + SetColor(color.Color) + + // Rotate applies a rotation transform to the + // context. The parameter is specified in + // radians. + Rotate(rad float64) + + // Translate applies a translational transform + // to the context. + Translate(pt Point) + + // Scale applies a scaling transform to the + // context. + Scale(x, y float64) + + // Push saves the current line width, the + // current dash pattern, the current + // transforms, and the current color + // onto a stack so that the state can later + // be restored by calling Pop(). + Push() + + // Pop restores the context saved by the + // corresponding call to Push(). + Pop() + + // Stroke strokes the given path. + Stroke(Path) + + // Fill fills the given path. + Fill(Path) + + // FillString fills in text at the specified + // location using the given font. + FillString(f Font, pt Point, text string) + + // DrawImage draws the image, scaled to fit + // the destination rectangle. + DrawImage(rect Rectangle, img image.Image) +} + +// CanvasSizer is a Canvas with a defined size. +type CanvasSizer interface { + Canvas + Size() (x, y Length) +} + +// CanvasWriterTo is a CanvasSizer with a WriteTo method. +type CanvasWriterTo interface { + CanvasSizer + io.WriterTo +} + +// Initialize sets all of the canvas's values to their +// initial values. +func Initialize(c Canvas) { + c.SetLineWidth(Points(1)) + c.SetLineDash([]Length{}, 0) + c.SetColor(color.Black) +} + +type Path []PathComp + +// Move moves the current location of the path to +// the given point. +func (p *Path) Move(pt Point) { + *p = append(*p, PathComp{Type: MoveComp, Pos: pt}) +} + +// Line draws a line from the current point to the +// given point. +func (p *Path) Line(pt Point) { + *p = append(*p, PathComp{Type: LineComp, Pos: pt}) +} + +// Arc adds an arc to the path defined by the center +// point of the arc's circle, the radius of the circle +// and the start and sweep angles. +func (p *Path) Arc(pt Point, rad Length, s, a float64) { + *p = append(*p, PathComp{ + Type: ArcComp, + Pos: pt, + Radius: rad, + Start: s, + Angle: a, + }) +} + +// Close closes the path by connecting the current +// location to the start location with a line. +func (p *Path) Close() { + *p = append(*p, PathComp{Type: CloseComp}) +} + +// Constants that tag the type of each path +// component. +const ( + MoveComp = iota + LineComp + ArcComp + CloseComp +) + +// A PathComp is a component of a path structure. +type PathComp struct { + // Type is the type of a particluar component. + // Based on the type, each of the following + // fields may have a different meaning or may + // be meaningless. + Type int + + // The Pos field is used as the destination + // of a MoveComp or LineComp and is the center + // point of an ArcComp. It is not used in + // the CloseComp. + Pos Point + + // Radius is only used for ArcComps, it is + // the radius of the circle defining the arc. + Radius Length + + // Start and Angle are only used for ArcComps. + // They define the start angle and sweep angle of + // the arc around the circle. The units of the + // angle are radians. + Start, Angle float64 +} diff --git a/vendor/github.com/gonum/plot/vg/vgeps/vgeps.go b/vendor/github.com/gonum/plot/vg/vgeps/vgeps.go new file mode 100644 index 00000000..2ab08521 --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/vgeps/vgeps.go @@ -0,0 +1,210 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package vgeps implements the vg.Canvas interface using +// encapsulated postscript. +package vgeps + +import ( + "bufio" + "bytes" + "fmt" + "image" + "image/color" + "io" + "math" + "time" + + "github.com/gonum/plot/vg" +) + +// DPI is the nominal resolution of drawing in EPS. +const DPI = 72 + +type Canvas struct { + stk []ctx + w, h vg.Length + buf *bytes.Buffer +} + +type ctx struct { + color color.Color + width vg.Length + dashes []vg.Length + offs vg.Length + font string + fsize vg.Length +} + +// pr is the amount of precision to use when outputting float64s. +const pr = 5 + +// New returns a new Canvas. +func New(w, h vg.Length) *Canvas { + return NewTitle(w, h, "") +} + +// NewTitle returns a new Canvas with the given title string. +func NewTitle(w, h vg.Length, title string) *Canvas { + c := &Canvas{ + stk: []ctx{ctx{}}, + w: w, + h: h, + buf: new(bytes.Buffer), + } + c.buf.WriteString("%%!PS-Adobe-3.0 EPSF-3.0\n") + c.buf.WriteString("%%Creator github.com/gonum/plot/vg/vgeps\n") + c.buf.WriteString("%%Title: " + title + "\n") + c.buf.WriteString(fmt.Sprintf("%%%%BoundingBox: 0 0 %.*g %.*g\n", + pr, w.Dots(DPI), + pr, h.Dots(DPI))) + c.buf.WriteString(fmt.Sprintf("%%%%CreationDate: %s\n", time.Now())) + c.buf.WriteString("%%Orientation: Portrait\n") + c.buf.WriteString("%%EndComments\n") + c.buf.WriteString("\n") + vg.Initialize(c) + return c +} + +func (c *Canvas) Size() (w, h vg.Length) { + return c.w, c.h +} + +// cur returns the top context on the stack. +func (e *Canvas) cur() *ctx { + return &e.stk[len(e.stk)-1] +} + +func (e *Canvas) SetLineWidth(w vg.Length) { + if e.cur().width != w { + e.cur().width = w + fmt.Fprintf(e.buf, "%.*g setlinewidth\n", pr, w.Dots(DPI)) + } +} + +func (e *Canvas) SetLineDash(dashes []vg.Length, o vg.Length) { + cur := e.cur().dashes + dashEq := len(dashes) == len(cur) + for i := 0; dashEq && i < len(dashes); i++ { + if dashes[i] != cur[i] { + dashEq = false + } + } + if !dashEq || e.cur().offs != o { + e.cur().dashes = dashes + e.cur().offs = o + e.buf.WriteString("[") + for _, d := range dashes { + fmt.Fprintf(e.buf, " %.*g", pr, d.Dots(DPI)) + } + e.buf.WriteString(" ] ") + fmt.Fprintf(e.buf, "%.*g setdash\n", pr, o.Dots(DPI)) + } +} + +func (e *Canvas) SetColor(c color.Color) { + if c == nil { + c = color.Black + } + if e.cur().color != c { + e.cur().color = c + r, g, b, _ := c.RGBA() + mx := float64(math.MaxUint16) + fmt.Fprintf(e.buf, "%.*g %.*g %.*g setrgbcolor\n", pr, float64(r)/mx, + pr, float64(g)/mx, pr, float64(b)/mx) + } +} + +func (e *Canvas) Rotate(r float64) { + fmt.Fprintf(e.buf, "%.*g rotate\n", pr, r*180/math.Pi) +} + +func (e *Canvas) Translate(pt vg.Point) { + fmt.Fprintf(e.buf, "%.*g %.*g translate\n", + pr, pt.X.Dots(DPI), pr, pt.Y.Dots(DPI)) +} + +func (e *Canvas) Scale(x, y float64) { + fmt.Fprintf(e.buf, "%.*g %.*g scale\n", pr, x, pr, y) +} + +func (e *Canvas) Push() { + e.stk = append(e.stk, *e.cur()) + e.buf.WriteString("gsave\n") +} + +func (e *Canvas) Pop() { + e.stk = e.stk[:len(e.stk)-1] + e.buf.WriteString("grestore\n") +} + +func (e *Canvas) Stroke(path vg.Path) { + if e.cur().width <= 0 { + return + } + e.trace(path) + e.buf.WriteString("stroke\n") +} + +func (e *Canvas) Fill(path vg.Path) { + e.trace(path) + e.buf.WriteString("fill\n") +} + +func (e *Canvas) trace(path vg.Path) { + e.buf.WriteString("newpath\n") + for _, comp := range path { + switch comp.Type { + case vg.MoveComp: + fmt.Fprintf(e.buf, "%.*g %.*g moveto\n", pr, comp.Pos.X, pr, comp.Pos.Y) + case vg.LineComp: + fmt.Fprintf(e.buf, "%.*g %.*g lineto\n", pr, comp.Pos.X, pr, comp.Pos.Y) + case vg.ArcComp: + end := comp.Start + comp.Angle + arcOp := "arc" + if comp.Angle < 0 { + arcOp = "arcn" + } + fmt.Fprintf(e.buf, "%.*g %.*g %.*g %.*g %.*g %s\n", pr, comp.Pos.X, pr, comp.Pos.Y, + pr, comp.Radius, pr, comp.Start*180/math.Pi, pr, + end*180/math.Pi, arcOp) + case vg.CloseComp: + e.buf.WriteString("closepath\n") + default: + panic(fmt.Sprintf("Unknown path component type: %d\n", comp.Type)) + } + } +} + +func (e *Canvas) FillString(fnt vg.Font, pt vg.Point, str string) { + if e.cur().font != fnt.Name() || e.cur().fsize != fnt.Size { + e.cur().font = fnt.Name() + e.cur().fsize = fnt.Size + fmt.Fprintf(e.buf, "/%s findfont %.*g scalefont setfont\n", + fnt.Name(), pr, fnt.Size) + } + fmt.Fprintf(e.buf, "%.*g %.*g moveto\n", pr, pt.X.Dots(DPI), pr, pt.Y.Dots(DPI)) + fmt.Fprintf(e.buf, "(%s) show\n", str) +} + +// DrawImage implements the vg.Canvas.DrawImage method. +func (c *Canvas) DrawImage(rect vg.Rectangle, img image.Image) { + // FIXME: https://github.com/gonum/plot/issues/271 + panic("vgeps: DrawImage not implemented") +} + +// WriteTo writes the canvas to an io.Writer. +func (e *Canvas) WriteTo(w io.Writer) (int64, error) { + b := bufio.NewWriter(w) + n, err := e.buf.WriteTo(b) + if err != nil { + return n, err + } + m, err := fmt.Fprintln(b, "showpage") + n += int64(m) + if err != nil { + return n, err + } + return n, b.Flush() +} diff --git a/vendor/github.com/gonum/plot/vg/vgimg/vgimg.go b/vendor/github.com/gonum/plot/vg/vgimg/vgimg.go new file mode 100644 index 00000000..3a41593b --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/vgimg/vgimg.go @@ -0,0 +1,431 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package vgimg implements the vg.Canvas interface using +// draw2d (github.com/llgcode/draw2d) +// as a backend to output raster images. +package vgimg + +import ( + "bufio" + "fmt" + "image" + "image/color" + "image/draw" + "image/jpeg" + "image/png" + "io" + + "golang.org/x/image/tiff" + + "github.com/llgcode/draw2d" + "github.com/llgcode/draw2d/draw2dimg" + + "github.com/gonum/plot/vg" +) + +// Canvas implements the vg.Canvas interface, +// drawing to an image.Image using draw2d. +type Canvas struct { + gc draw2d.GraphicContext + img draw.Image + w, h vg.Length + color []color.Color + + // dpi is the number of dots per inch for this canvas. + dpi int + + // width is the current line width. + width vg.Length +} + +const ( + // DefaultDPI is the default dot resolution for image + // drawing in dots per inch. + DefaultDPI = 96 + + // DefaultWidth and DefaultHeight are the default canvas + // dimensions. + DefaultWidth = 4 * vg.Inch + DefaultHeight = 4 * vg.Inch +) + +// New returns a new image canvas. +func New(w, h vg.Length) *Canvas { + return NewWith(UseWH(w, h)) +} + +// NewWith returns a new image canvas created according to the specified +// options. The currently accepted options are UseWH, +// UseDPI, UseImage, and UseImageWithContext. +// Each of the options specifies the size of the canvas (UseWH, UseImage), +// the resolution of the canvas (UseDPI), or both (useImageWithContext). +// If size or resolution are not specified, defaults are used. +// It panics if size and resolution are overspecified (i.e., too many options are +// passed). +func NewWith(o ...option) *Canvas { + c := new(Canvas) + var g uint32 + for _, opt := range o { + f := opt(c) + if g&f != 0 { + panic("incompatible options") + } + g |= f + } + if c.dpi == 0 { + c.dpi = DefaultDPI + } + if c.w == 0 { // h should also == 0. + if c.img == nil { + c.w = DefaultWidth + c.h = DefaultHeight + } else { + w := float64(c.img.Bounds().Max.X - c.img.Bounds().Min.X) + h := float64(c.img.Bounds().Max.Y - c.img.Bounds().Min.Y) + c.w = vg.Length(w/float64(c.dpi)) * vg.Inch + c.h = vg.Length(h/float64(c.dpi)) * vg.Inch + } + } + if c.img == nil { + w := c.w / vg.Inch * vg.Length(c.dpi) + h := c.h / vg.Inch * vg.Length(c.dpi) + c.img = draw.Image(image.NewRGBA(image.Rect(0, 0, int(w+0.5), int(h+0.5)))) + } + if c.gc == nil { + h := float64(c.img.Bounds().Max.Y - c.img.Bounds().Min.Y) + c.gc = draw2dimg.NewGraphicContext(c.img) + c.gc.SetDPI(c.dpi) + c.gc.Scale(1, -1) + c.gc.Translate(0, -h) + } + draw.Draw(c.img, c.img.Bounds(), image.White, image.ZP, draw.Src) + c.color = []color.Color{color.Black} + vg.Initialize(c) + return c +} + +// These constants are used to ensure that the options +// used when initializing a canvas are compatible with +// each other. +const ( + setsDPI = 1 << iota + setsSize +) + +type option func(*Canvas) uint32 + +// UseWH specifies the width and height of the canvas. +// The size is rounded up to the nearest pixel. +func UseWH(w, h vg.Length) option { + return func(c *Canvas) uint32 { + if w <= 0 || h <= 0 { + panic("w and h must both be > 0.") + } + c.w, c.h = w, h + return setsSize + } +} + +// UseDPI sets the dots per inch of a canvas. It should only be +// used as an option argument when initializing a new canvas. +func UseDPI(dpi int) option { + if dpi <= 0 { + panic("DPI must be > 0.") + } + return func(c *Canvas) uint32 { + c.dpi = dpi + return setsDPI + } +} + +// UseImage specifies an image to create +// the canvas from. The +// minimum point of the given image +// should probably be 0,0. +func UseImage(img draw.Image) option { + return func(c *Canvas) uint32 { + c.img = img + return setsSize + } +} + +// UseImageWithContext specifies both an image +// and a graphic context to create the canvas from. +// The minimum point of the given image +// should probably be 0,0. +func UseImageWithContext(img draw.Image, gc draw2d.GraphicContext) option { + return func(c *Canvas) uint32 { + c.img = img + c.gc = gc + c.dpi = gc.GetDPI() + return setsDPI | setsSize + } +} + +func (c *Canvas) Size() (w, h vg.Length) { + return c.w, c.h +} + +func (c *Canvas) SetLineWidth(w vg.Length) { + c.width = w + c.gc.SetLineWidth(w.Dots(c.DPI())) +} + +func (c *Canvas) SetLineDash(ds []vg.Length, offs vg.Length) { + dashes := make([]float64, len(ds)) + for i, d := range ds { + dashes[i] = d.Dots(c.DPI()) + } + c.gc.SetLineDash(dashes, offs.Dots(c.DPI())) +} + +func (c *Canvas) SetColor(clr color.Color) { + if clr == nil { + clr = color.Black + } + c.gc.SetFillColor(clr) + c.gc.SetStrokeColor(clr) + c.color[len(c.color)-1] = clr +} + +func (c *Canvas) Rotate(t float64) { + c.gc.Rotate(t) +} + +func (c *Canvas) Translate(pt vg.Point) { + c.gc.Translate(pt.X.Dots(c.DPI()), pt.Y.Dots(c.DPI())) +} + +func (c *Canvas) Scale(x, y float64) { + c.gc.Scale(x, y) +} + +func (c *Canvas) Push() { + c.color = append(c.color, c.color[len(c.color)-1]) + c.gc.Save() +} + +func (c *Canvas) Pop() { + c.color = c.color[:len(c.color)-1] + c.gc.Restore() +} + +func (c *Canvas) Stroke(p vg.Path) { + if c.width <= 0 { + return + } + c.outline(p) + c.gc.Stroke() +} + +func (c *Canvas) Fill(p vg.Path) { + c.outline(p) + c.gc.Fill() +} + +func (c *Canvas) outline(p vg.Path) { + c.gc.BeginPath() + for _, comp := range p { + switch comp.Type { + case vg.MoveComp: + c.gc.MoveTo(comp.Pos.X.Dots(c.DPI()), comp.Pos.Y.Dots(c.DPI())) + + case vg.LineComp: + c.gc.LineTo(comp.Pos.X.Dots(c.DPI()), comp.Pos.Y.Dots(c.DPI())) + + case vg.ArcComp: + c.gc.ArcTo(comp.Pos.X.Dots(c.DPI()), comp.Pos.Y.Dots(c.DPI()), + comp.Radius.Dots(c.DPI()), comp.Radius.Dots(c.DPI()), + comp.Start, comp.Angle) + + case vg.CloseComp: + c.gc.Close() + + default: + panic(fmt.Sprintf("Unknown path component: %d", comp.Type)) + } + } +} + +func (c *Canvas) DPI() float64 { + return float64(c.gc.GetDPI()) +} + +func (c *Canvas) FillString(font vg.Font, pt vg.Point, str string) { + c.gc.Save() + defer c.gc.Restore() + + data, ok := fontMap[font.Name()] + if !ok { + panic(fmt.Sprintf("Font name %s is unknown", font.Name())) + } + if !registeredFont[font.Name()] { + draw2d.RegisterFont(data, font.Font()) + registeredFont[font.Name()] = true + } + c.gc.SetFontData(data) + c.gc.SetFontSize(font.Size.Points()) + c.gc.Translate(pt.X.Dots(c.DPI()), pt.Y.Dots(c.DPI())) + c.gc.Scale(1, -1) + c.gc.FillString(str) +} + +// DrawImage implements the vg.Canvas.DrawImage method. +func (c *Canvas) DrawImage(rect vg.Rectangle, img image.Image) { + var ( + dpi = c.DPI() + min = rect.Min + xmin = min.X.Dots(dpi) + ymin = min.Y.Dots(dpi) + rsz = rect.Size() + width = rsz.X.Dots(dpi) + height = rsz.Y.Dots(dpi) + dx = float64(img.Bounds().Dx()) + dy = float64(img.Bounds().Dy()) + ) + c.gc.Save() + c.gc.Scale(1, -1) + c.gc.Translate(xmin, -ymin-height) + c.gc.Scale(width/dx, height/dy) + c.gc.DrawImage(img) + c.gc.Restore() +} + +var ( + // RegisteredFont contains the set of font names + // that have already been registered with draw2d. + registeredFont = map[string]bool{} + + // FontMap contains a mapping from vg's font + // names to draw2d.FontData for the corresponding + // font. This is needed to register the fonts with + // draw2d. + fontMap = map[string]draw2d.FontData{ + "Courier": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilyMono, + Style: draw2d.FontStyleNormal, + }, + "Courier-Bold": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilyMono, + Style: draw2d.FontStyleBold, + }, + "Courier-Oblique": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilyMono, + Style: draw2d.FontStyleItalic, + }, + "Courier-BoldOblique": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilyMono, + Style: draw2d.FontStyleItalic | draw2d.FontStyleBold, + }, + "Helvetica": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilySans, + Style: draw2d.FontStyleNormal, + }, + "Helvetica-Bold": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilySans, + Style: draw2d.FontStyleBold, + }, + "Helvetica-Oblique": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilySans, + Style: draw2d.FontStyleItalic, + }, + "Helvetica-BoldOblique": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilySans, + Style: draw2d.FontStyleItalic | draw2d.FontStyleBold, + }, + "Times-Roman": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilySerif, + Style: draw2d.FontStyleNormal, + }, + "Times-Bold": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilySerif, + Style: draw2d.FontStyleBold, + }, + "Times-Italic": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilySerif, + Style: draw2d.FontStyleItalic, + }, + "Times-BoldItalic": draw2d.FontData{ + Name: "Liberation", + Family: draw2d.FontFamilySerif, + Style: draw2d.FontStyleItalic | draw2d.FontStyleBold, + }, + } +) + +// WriterCounter implements the io.Writer interface, and counts +// the total number of bytes written. +type writerCounter struct { + io.Writer + n int64 +} + +func (w *writerCounter) Write(p []byte) (int, error) { + n, err := w.Writer.Write(p) + w.n += int64(n) + return n, err +} + +// A JpegCanvas is an image canvas with a WriteTo method +// that writes a jpeg image. +type JpegCanvas struct { + *Canvas +} + +// WriteTo implements the io.WriterTo interface, writing a jpeg image. +func (c JpegCanvas) WriteTo(w io.Writer) (int64, error) { + wc := writerCounter{Writer: w} + b := bufio.NewWriter(&wc) + if err := jpeg.Encode(b, c.img, nil); err != nil { + return wc.n, err + } + err := b.Flush() + return wc.n, err +} + +// A PngCanvas is an image canvas with a WriteTo method that +// writes a png image. +type PngCanvas struct { + *Canvas +} + +// WriteTo implements the io.WriterTo interface, writing a png image. +func (c PngCanvas) WriteTo(w io.Writer) (int64, error) { + wc := writerCounter{Writer: w} + b := bufio.NewWriter(&wc) + if err := png.Encode(b, c.img); err != nil { + return wc.n, err + } + err := b.Flush() + return wc.n, err +} + +// A TiffCanvas is an image canvas with a WriteTo method that +// writes a tiff image. +type TiffCanvas struct { + *Canvas +} + +// WriteTo implements the io.WriterTo interface, writing a tiff image. +func (c TiffCanvas) WriteTo(w io.Writer) (int64, error) { + wc := writerCounter{Writer: w} + b := bufio.NewWriter(&wc) + if err := tiff.Encode(b, c.img, nil); err != nil { + return wc.n, err + } + err := b.Flush() + return wc.n, err +} diff --git a/vendor/github.com/gonum/plot/vg/vgpdf/vgpdf.go b/vendor/github.com/gonum/plot/vg/vgpdf/vgpdf.go new file mode 100644 index 00000000..c96e2a64 --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/vgpdf/vgpdf.go @@ -0,0 +1,239 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package vgpdf implements the vg.Canvas interface +// using gopdf (bitbucket.org/zombiezen/gopdf/pdf). +package vgpdf + +import ( + "bufio" + "fmt" + "image" + "image/color" + "io" + "math" + + "bitbucket.org/zombiezen/gopdf/pdf" + "github.com/gonum/plot/vg" +) + +// DPI is the nominal resolution of drawing in PDF. +const DPI = 72 + +// Canvas implements the vg.Canvas interface, +// drawing to a PDF. +type Canvas struct { + doc *pdf.Document + w, h vg.Length + page *pdf.Canvas + lineVisible bool +} + +// New creates a new PDF Canvas. +func New(w, h vg.Length) *Canvas { + c := &Canvas{ + doc: pdf.New(), + w: w, + h: h, + lineVisible: true, + } + c.page = c.doc.NewPage(unit(w), unit(h)) + vg.Initialize(c) + return c +} + +func (c *Canvas) Size() (w, h vg.Length) { + return c.w, c.h +} + +func (c *Canvas) SetLineWidth(w vg.Length) { + c.page.SetLineWidth(unit(w)) + c.lineVisible = w > 0 +} + +func (c *Canvas) SetLineDash(dashes []vg.Length, offs vg.Length) { + ds := make([]pdf.Unit, len(dashes)) + for i, d := range dashes { + ds[i] = unit(d) + } + c.page.SetLineDash(unit(offs), ds) +} + +func (c *Canvas) SetColor(clr color.Color) { + c.page.SetStrokeColor(pdfColor(clr)) + c.page.SetColor(pdfColor(clr)) +} + +func (c *Canvas) Rotate(r float64) { + c.page.Rotate(float32(r)) +} + +func (c *Canvas) Translate(pt vg.Point) { + c.page.Translate(unit(pt.X), unit(pt.Y)) +} + +func (c *Canvas) Scale(x float64, y float64) { + c.page.Scale(float32(x), float32(y)) +} + +func (c *Canvas) Push() { + c.page.Push() +} + +func (c *Canvas) Pop() { + c.page.Pop() +} + +func (c *Canvas) Stroke(p vg.Path) { + if c.lineVisible { + c.page.Stroke(pdfPath(c, p)) + } +} + +func (c *Canvas) Fill(p vg.Path) { + c.page.Fill(pdfPath(c, p)) +} + +func (c *Canvas) FillString(fnt vg.Font, pt vg.Point, str string) { + t := new(pdf.Text) + t.SetFont(fnt.Name(), unit(fnt.Size)) + t.NextLineOffset(unit(pt.X), unit(pt.Y)) + t.Text(str) + c.page.DrawText(t) +} + +// DrawImage implements the vg.Canvas.DrawImage method. +func (c *Canvas) DrawImage(rect vg.Rectangle, img image.Image) { + r := pdf.Rectangle{ + Min: pdfPoint(rect.Min.X, rect.Min.Y), + Max: pdfPoint(rect.Max.X, rect.Max.Y), + } + c.page.DrawImage(img, r) +} + +// pdfPath returns a pdf.Path from a vg.Path. +func pdfPath(c *Canvas, path vg.Path) *pdf.Path { + p := new(pdf.Path) + for _, comp := range path { + switch comp.Type { + case vg.MoveComp: + p.Move(pdfPoint(comp.Pos.X, comp.Pos.Y)) + case vg.LineComp: + p.Line(pdfPoint(comp.Pos.X, comp.Pos.Y)) + case vg.ArcComp: + arc(p, comp) + case vg.CloseComp: + p.Close() + default: + panic(fmt.Sprintf("Unknown path component type: %d\n", comp.Type)) + } + } + return p +} + +// Approximate a circular arc using multiple +// cubic Bézier curves, one for each π/2 segment. +// +// This is from: +// http://hansmuller-flex.blogspot.com/2011/04/approximating-circular-arc-with-cubic.html +func arc(p *pdf.Path, comp vg.PathComp) { + x0 := comp.Pos.X + comp.Radius*vg.Length(math.Cos(comp.Start)) + y0 := comp.Pos.Y + comp.Radius*vg.Length(math.Sin(comp.Start)) + p.Line(pdfPoint(x0, y0)) + + a1 := comp.Start + end := a1 + comp.Angle + sign := 1.0 + if end < a1 { + sign = -1.0 + } + left := math.Abs(comp.Angle) + + // Square root of the machine epsilon for IEEE 64-bit floating + // point values. This is the equality threshold recommended + // in Numerical Recipes, if I recall correctly—it's small enough. + const epsilon = 1.4901161193847656e-08 + + for left > epsilon { + a2 := a1 + sign*math.Min(math.Pi/2, left) + partialArc(p, comp.Pos.X, comp.Pos.Y, comp.Radius, a1, a2) + left -= math.Abs(a2 - a1) + a1 = a2 + } +} + +// Approximate a circular arc of fewer than π/2 +// radians with cubic Bézier curve. +func partialArc(p *pdf.Path, x, y, r vg.Length, a1, a2 float64) { + a := (a2 - a1) / 2 + x4 := r * vg.Length(math.Cos(a)) + y4 := r * vg.Length(math.Sin(a)) + x1 := x4 + y1 := -y4 + + const k = 0.5522847498 // some magic constant + f := k * vg.Length(math.Tan(a)) + x2 := x1 + f*y4 + y2 := y1 + f*x4 + x3 := x2 + y3 := -y2 + + // Rotate and translate points into position. + ar := a + a1 + sinar := vg.Length(math.Sin(ar)) + cosar := vg.Length(math.Cos(ar)) + x2r := x2*cosar - y2*sinar + x + y2r := x2*sinar + y2*cosar + y + x3r := x3*cosar - y3*sinar + x + y3r := x3*sinar + y3*cosar + y + x4 = r*vg.Length(math.Cos(a2)) + x + y4 = r*vg.Length(math.Sin(a2)) + y + p.Curve(pdfPoint(x2r, y2r), pdfPoint(x3r, y3r), pdfPoint(x4, y4)) +} + +func pdfPoint(x, y vg.Length) pdf.Point { + return pdf.Point{X: unit(x), Y: unit(y)} +} + +func pdfColor(clr color.Color) (float32, float32, float32) { + if clr == nil { + clr = color.Black + } + r, g, b, _ := clr.RGBA() + return float32(r) / math.MaxUint16, + float32(g) / math.MaxUint16, + float32(b) / math.MaxUint16 +} + +// unit returns a pdf.Unit, converted from a vg.Length. +func unit(l vg.Length) pdf.Unit { + return pdf.Unit(l.Points()) * pdf.Pt +} + +// WriterCounter implements the io.Writer interface, and counts +// the total number of bytes written. +type writerCounter struct { + io.Writer + n int64 +} + +func (w *writerCounter) Write(p []byte) (int, error) { + n, err := w.Writer.Write(p) + w.n += int64(n) + return n, err +} + +// WriteTo writes the Canvas to an io.Writer. +// After calling Write, the canvas is closed +// and may no longer be used for drawing. +func (c *Canvas) WriteTo(w io.Writer) (int64, error) { + c.page.Close() + wc := writerCounter{Writer: w} + b := bufio.NewWriter(&wc) + if err := c.doc.Encode(b); err != nil { + return wc.n, err + } + err := b.Flush() + return wc.n, err +} diff --git a/vendor/github.com/gonum/plot/vg/vgsvg/vgsvg.go b/vendor/github.com/gonum/plot/vg/vgsvg/vgsvg.go new file mode 100644 index 00000000..57f1ec94 --- /dev/null +++ b/vendor/github.com/gonum/plot/vg/vgsvg/vgsvg.go @@ -0,0 +1,415 @@ +// Copyright ©2015 The gonum Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package vgsvg uses svgo (github.com/ajstarks/svgo) +// as a backend for vg. +package vgsvg + +import ( + "bufio" + "bytes" + "encoding/base64" + "fmt" + "image" + "image/color" + "image/png" + "io" + "math" + + svgo "github.com/ajstarks/svgo" + "github.com/gonum/plot/vg" +) + +// DPI is the resolution of drawing in SVG. This value was determined by +// a survey of Inkscape, Chrome, FireFox and gpicview, but does not appear +// to be specified. +const DPI = 90 + +// pr is the precision to use when outputting float64s. +const pr = 5 + +type Canvas struct { + svg *svgo.SVG + w, h vg.Length + buf *bytes.Buffer + ht float64 + stk []context +} + +type context struct { + color color.Color + dashArray []vg.Length + dashOffset vg.Length + lineWidth vg.Length + gEnds int +} + +func New(w, h vg.Length) *Canvas { + buf := new(bytes.Buffer) + c := &Canvas{ + svg: svgo.New(buf), + w: w, + h: h, + buf: buf, + ht: w.Points(), + stk: []context{context{}}, + } + + // This is like svg.Start, except it uses floats + // and specifies the units. + fmt.Fprintf(buf, ` + +`+"\n", + pr, w/vg.Inch, + pr, h/vg.Inch, + ) + + // Swap the origin to the bottom left. + // This must be matched with a when saving, + // before the closing . + c.svg.Gtransform(fmt.Sprintf("scale(1, -1) translate(0, -%.*g)", pr, h.Dots(DPI))) + + vg.Initialize(c) + return c +} + +func (c *Canvas) Size() (w, h vg.Length) { + return c.w, c.h +} + +func (c *Canvas) cur() *context { + return &c.stk[len(c.stk)-1] +} + +func (c *Canvas) SetLineWidth(w vg.Length) { + c.cur().lineWidth = w +} + +func (c *Canvas) SetLineDash(dashes []vg.Length, offs vg.Length) { + c.cur().dashArray = dashes + c.cur().dashOffset = offs +} + +func (c *Canvas) SetColor(clr color.Color) { + c.cur().color = clr +} + +func (c *Canvas) Rotate(rot float64) { + rot = rot * 180 / math.Pi + c.svg.Rotate(rot) + c.cur().gEnds++ +} + +func (c *Canvas) Translate(pt vg.Point) { + c.svg.Gtransform(fmt.Sprintf("translate(%.*g, %.*g)", pr, pt.X.Dots(DPI), pr, pt.Y.Dots(DPI))) + c.cur().gEnds++ +} + +func (c *Canvas) Scale(x, y float64) { + c.svg.ScaleXY(x, y) + c.cur().gEnds++ +} + +func (c *Canvas) Push() { + top := *c.cur() + top.gEnds = 0 + c.stk = append(c.stk, top) +} + +func (c *Canvas) Pop() { + for i := 0; i < c.cur().gEnds; i++ { + c.svg.Gend() + } + c.stk = c.stk[:len(c.stk)-1] +} + +func (c *Canvas) Stroke(path vg.Path) { + if c.cur().lineWidth.Dots(DPI) <= 0 { + return + } + c.svg.Path(c.pathData(path), + style(elm("fill", "#000000", "none"), + elm("stroke", "none", colorString(c.cur().color)), + elm("stroke-opacity", "1", opacityString(c.cur().color)), + elm("stroke-width", "1", "%.*g", pr, c.cur().lineWidth.Dots(DPI)), + elm("stroke-dasharray", "none", dashArrayString(c)), + elm("stroke-dashoffset", "0", "%.*g", pr, c.cur().dashOffset.Dots(DPI)))) +} + +func (c *Canvas) Fill(path vg.Path) { + c.svg.Path(c.pathData(path), + style(elm("fill", "#000000", colorString(c.cur().color)), + elm("fill-opacity", "1", opacityString(c.cur().color)))) +} + +func (c *Canvas) pathData(path vg.Path) string { + buf := new(bytes.Buffer) + var x, y float64 + for _, comp := range path { + switch comp.Type { + case vg.MoveComp: + fmt.Fprintf(buf, "M%.*g,%.*g", pr, comp.Pos.X.Dots(DPI), pr, comp.Pos.Y.Dots(DPI)) + x = comp.Pos.X.Dots(DPI) + y = comp.Pos.Y.Dots(DPI) + case vg.LineComp: + fmt.Fprintf(buf, "L%.*g,%.*g", pr, comp.Pos.X.Dots(DPI), pr, comp.Pos.Y.Dots(DPI)) + x = comp.Pos.X.Dots(DPI) + y = comp.Pos.Y.Dots(DPI) + case vg.ArcComp: + r := comp.Radius.Dots(DPI) + x0 := comp.Pos.X.Dots(DPI) + r*math.Cos(comp.Start) + y0 := comp.Pos.Y.Dots(DPI) + r*math.Sin(comp.Start) + if x0 != x || y0 != y { + fmt.Fprintf(buf, "L%.*g,%.*g", pr, x0, pr, y0) + } + if math.Abs(comp.Angle) >= 2*math.Pi { + x, y = circle(buf, c, &comp) + } else { + x, y = arc(buf, c, &comp) + } + case vg.CloseComp: + buf.WriteString("Z") + default: + panic(fmt.Sprintf("Unknown path component type: %d\n", comp.Type)) + } + } + return buf.String() +} + +// circle adds circle path data to the given writer. +// Circles must be drawn using two arcs because +// SVG disallows the start and end point of an arc +// from being at the same location. +func circle(w io.Writer, c *Canvas, comp *vg.PathComp) (x, y float64) { + angle := 2 * math.Pi + if comp.Angle < 0 { + angle = -2 * math.Pi + } + angle += remainder(comp.Angle, 2*math.Pi) + if angle >= 4*math.Pi { + panic("Impossible angle") + } + + r := comp.Radius.Dots(DPI) + x0 := comp.Pos.X.Dots(DPI) + r*math.Cos(comp.Start+angle/2) + y0 := comp.Pos.Y.Dots(DPI) + r*math.Sin(comp.Start+angle/2) + x = comp.Pos.X.Dots(DPI) + r*math.Cos(comp.Start+angle) + y = comp.Pos.Y.Dots(DPI) + r*math.Sin(comp.Start+angle) + + fmt.Fprintf(w, "A%.*g,%.*g 0 %d %d %.*g,%.*g", pr, r, pr, r, + large(angle/2), sweep(angle/2), pr, x0, pr, y0) // + fmt.Fprintf(w, "A%.*g,%.*g 0 %d %d %.*g,%.*g", pr, r, pr, r, + large(angle/2), sweep(angle/2), pr, x, pr, y) + return +} + +// remainder returns the remainder of x/y. +// We don't use math.Remainder because it +// seems to return incorrect values due to how +// IEEE defines the remainder operation… +func remainder(x, y float64) float64 { + return (x/y - math.Trunc(x/y)) * y +} + +// arc adds arc path data to the given writer. +// Arc can only be used if the arc's angle is +// less than a full circle, if it is greater then +// circle should be used instead. +func arc(w io.Writer, c *Canvas, comp *vg.PathComp) (x, y float64) { + r := comp.Radius.Dots(DPI) + x = comp.Pos.X.Dots(DPI) + r*math.Cos(comp.Start+comp.Angle) + y = comp.Pos.Y.Dots(DPI) + r*math.Sin(comp.Start+comp.Angle) + fmt.Fprintf(w, "A%.*g,%.*g 0 %d %d %.*g,%.*g", pr, r, pr, r, + large(comp.Angle), sweep(comp.Angle), pr, x, pr, y) + return +} + +// sweep returns the arc sweep flag value for +// the given angle. +func sweep(a float64) int { + if a < 0 { + return 0 + } + return 1 +} + +// large returns the arc's large flag value for +// the given angle. +func large(a float64) int { + if math.Abs(a) >= math.Pi { + return 1 + } + return 0 +} + +func (c *Canvas) FillString(font vg.Font, pt vg.Point, str string) { + fontStr, ok := fontMap[font.Name()] + if !ok { + panic(fmt.Sprintf("Unknown font: %s", font.Name())) + } + sty := style(fontStr, + elm("font-size", "medium", "%.*gpt", pr, font.Size.Points()), + elm("fill", "#000000", colorString(c.cur().color))) + if sty != "" { + sty = "\n\t" + sty + } + fmt.Fprintf(c.buf, `%s`+"\n", + pr, pt.X.Dots(DPI), pr, -pt.Y.Dots(DPI), sty, str) +} + +// DrawImage implements the vg.Canvas.DrawImage method. +func (c *Canvas) DrawImage(rect vg.Rectangle, img image.Image) { + buf := new(bytes.Buffer) + err := png.Encode(buf, img) + if err != nil { + panic(fmt.Errorf("vgsvg: error encoding image to PNG: %v\n", err)) + } + str := "data:image/jpg;base64," + base64.StdEncoding.EncodeToString(buf.Bytes()) + rsz := rect.Size() + min := rect.Min + var ( + width = rsz.X.Dots(DPI) + height = rsz.Y.Dots(DPI) + xmin = min.X.Dots(DPI) + ymin = min.Y.Dots(DPI) + ) + fmt.Fprintf( + c.buf, + ``+"\n", + xmin, + -ymin-height, + width, + height, + str, + // invert y so image is not upside-down + `transform="scale(1, -1)"`, + ) +} + +var ( + // fontMap maps Postscript-style font names to their + // corresponding SVG style string. + fontMap = map[string]string{ + "Courier": "font-family:Courier;font-weight:normal;font-style:normal", + "Courier-Bold": "font-family:Courier;font-weight:bold;font-style:normal", + "Courier-Oblique": "font-family:Courier;font-weight:normal;font-style:oblique", + "Courier-BoldOblique": "font-family:Courier;font-weight:bold;font-style:oblique", + "Helvetica": "font-family:Helvetica;font-weight:normal;font-style:normal", + "Helvetica-Bold": "font-family:Helvetica;font-weight:bold;font-style:normal", + "Helvetica-Oblique": "font-family:Helvetica;font-weight:normal;font-style:oblique", + "Helvetica-BoldOblique": "font-family:Helvetica;font-weight:bold;font-style:oblique", + "Times-Roman": "font-family:Times;font-weight:normal;font-style:normal", + "Times-Bold": "font-family:Times;font-weight:bold;font-style:normal", + "Times-Italic": "font-family:Times;font-weight:normal;font-style:italic", + "Times-BoldItalic": "font-family:Times;font-weight:bold;font-style:italic", + } +) + +// WriteTo writes the canvas to an io.Writer. +func (c *Canvas) WriteTo(w io.Writer) (int64, error) { + b := bufio.NewWriter(w) + n, err := c.buf.WriteTo(b) + if err != nil { + return n, err + } + + // Close the groups and svg in the output buffer + // so that the Canvas is not closed and can be + // used again if needed. + for i := 0; i < c.nEnds(); i++ { + m, err := fmt.Fprintln(b, "") + n += int64(m) + if err != nil { + return n, err + } + } + + m, err := fmt.Fprintln(b, "") + n += int64(m) + if err != nil { + return n, err + } + + return n, b.Flush() +} + +// nEnds returns the number of group ends +// needed before the SVG is saved. +func (c *Canvas) nEnds() int { + n := 1 // close the transform that moves the origin + for _, ctx := range c.stk { + n += ctx.gEnds + } + return n +} + +// style returns a style string composed of +// all of the given elements. If the elements +// are all empty then the empty string is +// returned. +func style(elms ...string) string { + str := "" + for _, e := range elms { + if e == "" { + continue + } + if str != "" { + str += ";" + } + str += e + } + if str == "" { + return "" + } + return "style=\"" + str + "\"" +} + +// elm returns a style element string with the +// given key and value. If the value matches +// default then the empty string is returned. +func elm(key, def, f string, vls ...interface{}) string { + value := fmt.Sprintf(f, vls...) + if value == def { + return "" + } + return key + ":" + value +} + +// dashArrayString returns a string representing the +// dash array specification. +func dashArrayString(c *Canvas) string { + str := "" + for i, d := range c.cur().dashArray { + str += fmt.Sprintf("%.*g", pr, d.Dots(DPI)) + if i < len(c.cur().dashArray)-1 { + str += "," + } + } + if str == "" { + str = "none" + } + return str +} + +// colorString returns the hexadecimal string representation of the color +func colorString(clr color.Color) string { + if clr == nil { + clr = color.Black + } + r, g, b, _a := clr.RGBA() + a := 255.0 / float64(_a) + return fmt.Sprintf("#%02X%02X%02X", int(float64(r)*a), + int(float64(g)*a), int(float64(b)*a)) +} + +// opacityString returns the opacity value of the given color. +func opacityString(clr color.Color) string { + if clr == nil { + clr = color.Black + } + _, _, _, a := clr.RGBA() + return fmt.Sprintf("%.*g", pr, float64(a)/math.MaxUint16) +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/LICENSE.txt b/vendor/github.com/grpc-ecosystem/grpc-gateway/LICENSE.txt new file mode 100644 index 00000000..36451625 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/LICENSE.txt @@ -0,0 +1,27 @@ +Copyright (c) 2015, Gengo, Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name of Gengo, Inc. nor the names of its + contributors may be used to endorse or promote products derived from this + software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/context.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/context.go new file mode 100644 index 00000000..ad425356 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/context.go @@ -0,0 +1,139 @@ +package runtime + +import ( + "fmt" + "net" + "net/http" + "strconv" + "strings" + "time" + + "golang.org/x/net/context" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" +) + +const metadataHeaderPrefix = "Grpc-Metadata-" +const metadataTrailerPrefix = "Grpc-Trailer-" +const metadataGrpcTimeout = "Grpc-Timeout" + +const xForwardedFor = "X-Forwarded-For" +const xForwardedHost = "X-Forwarded-Host" + +var ( + // DefaultContextTimeout is used for gRPC call context.WithTimeout whenever a Grpc-Timeout inbound + // header isn't present. If the value is 0 the sent `context` will not have a timeout. + DefaultContextTimeout = 0 * time.Second +) + +/* +AnnotateContext adds context information such as metadata from the request. + +At a minimum, the RemoteAddr is included in the fashion of "X-Forwarded-For", +except that the forwarded destination is not another HTTP service but rather +a gRPC service. +*/ +func AnnotateContext(ctx context.Context, req *http.Request) (context.Context, error) { + var pairs []string + timeout := DefaultContextTimeout + if tm := req.Header.Get(metadataGrpcTimeout); tm != "" { + var err error + timeout, err = timeoutDecode(tm) + if err != nil { + return nil, grpc.Errorf(codes.InvalidArgument, "invalid grpc-timeout: %s", tm) + } + } + + for key, vals := range req.Header { + for _, val := range vals { + if key == "Authorization" { + pairs = append(pairs, "authorization", val) + continue + } + if strings.HasPrefix(key, metadataHeaderPrefix) { + pairs = append(pairs, key[len(metadataHeaderPrefix):], val) + } + } + } + if host := req.Header.Get(xForwardedHost); host != "" { + pairs = append(pairs, strings.ToLower(xForwardedHost), host) + } else if req.Host != "" { + pairs = append(pairs, strings.ToLower(xForwardedHost), req.Host) + } + + if addr := req.RemoteAddr; addr != "" { + if remoteIP, _, err := net.SplitHostPort(addr); err == nil { + if fwd := req.Header.Get(xForwardedFor); fwd == "" { + pairs = append(pairs, strings.ToLower(xForwardedFor), remoteIP) + } else { + pairs = append(pairs, strings.ToLower(xForwardedFor), fmt.Sprintf("%s, %s", fwd, remoteIP)) + } + } else { + grpclog.Printf("invalid remote addr: %s", addr) + } + } + + if timeout != 0 { + ctx, _ = context.WithTimeout(ctx, timeout) + } + if len(pairs) == 0 { + return ctx, nil + } + return metadata.NewContext(ctx, metadata.Pairs(pairs...)), nil +} + +// ServerMetadata consists of metadata sent from gRPC server. +type ServerMetadata struct { + HeaderMD metadata.MD + TrailerMD metadata.MD +} + +type serverMetadataKey struct{} + +// NewServerMetadataContext creates a new context with ServerMetadata +func NewServerMetadataContext(ctx context.Context, md ServerMetadata) context.Context { + return context.WithValue(ctx, serverMetadataKey{}, md) +} + +// ServerMetadataFromContext returns the ServerMetadata in ctx +func ServerMetadataFromContext(ctx context.Context) (md ServerMetadata, ok bool) { + md, ok = ctx.Value(serverMetadataKey{}).(ServerMetadata) + return +} + +func timeoutDecode(s string) (time.Duration, error) { + size := len(s) + if size < 2 { + return 0, fmt.Errorf("timeout string is too short: %q", s) + } + d, ok := timeoutUnitToDuration(s[size-1]) + if !ok { + return 0, fmt.Errorf("timeout unit is not recognized: %q", s) + } + t, err := strconv.ParseInt(s[:size-1], 10, 64) + if err != nil { + return 0, err + } + return d * time.Duration(t), nil +} + +func timeoutUnitToDuration(u uint8) (d time.Duration, ok bool) { + switch u { + case 'H': + return time.Hour, true + case 'M': + return time.Minute, true + case 'S': + return time.Second, true + case 'm': + return time.Millisecond, true + case 'u': + return time.Microsecond, true + case 'n': + return time.Nanosecond, true + default: + } + return +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/convert.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/convert.go new file mode 100644 index 00000000..1af5cc4e --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/convert.go @@ -0,0 +1,58 @@ +package runtime + +import ( + "strconv" +) + +// String just returns the given string. +// It is just for compatibility to other types. +func String(val string) (string, error) { + return val, nil +} + +// Bool converts the given string representation of a boolean value into bool. +func Bool(val string) (bool, error) { + return strconv.ParseBool(val) +} + +// Float64 converts the given string representation into representation of a floating point number into float64. +func Float64(val string) (float64, error) { + return strconv.ParseFloat(val, 64) +} + +// Float32 converts the given string representation of a floating point number into float32. +func Float32(val string) (float32, error) { + f, err := strconv.ParseFloat(val, 32) + if err != nil { + return 0, err + } + return float32(f), nil +} + +// Int64 converts the given string representation of an integer into int64. +func Int64(val string) (int64, error) { + return strconv.ParseInt(val, 0, 64) +} + +// Int32 converts the given string representation of an integer into int32. +func Int32(val string) (int32, error) { + i, err := strconv.ParseInt(val, 0, 32) + if err != nil { + return 0, err + } + return int32(i), nil +} + +// Uint64 converts the given string representation of an integer into uint64. +func Uint64(val string) (uint64, error) { + return strconv.ParseUint(val, 0, 64) +} + +// Uint32 converts the given string representation of an integer into uint32. +func Uint32(val string) (uint32, error) { + i, err := strconv.ParseUint(val, 0, 32) + if err != nil { + return 0, err + } + return uint32(i), nil +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/doc.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/doc.go new file mode 100644 index 00000000..b6e5ddf7 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/doc.go @@ -0,0 +1,5 @@ +/* +Package runtime contains runtime helper functions used by +servers which protoc-gen-grpc-gateway generates. +*/ +package runtime diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/errors.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/errors.go new file mode 100644 index 00000000..7d7a9b22 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/errors.go @@ -0,0 +1,121 @@ +package runtime + +import ( + "io" + "net/http" + + "github.com/golang/protobuf/proto" + "golang.org/x/net/context" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" +) + +// HTTPStatusFromCode converts a gRPC error code into the corresponding HTTP response status. +func HTTPStatusFromCode(code codes.Code) int { + switch code { + case codes.OK: + return http.StatusOK + case codes.Canceled: + return http.StatusRequestTimeout + case codes.Unknown: + return http.StatusInternalServerError + case codes.InvalidArgument: + return http.StatusBadRequest + case codes.DeadlineExceeded: + return http.StatusRequestTimeout + case codes.NotFound: + return http.StatusNotFound + case codes.AlreadyExists: + return http.StatusConflict + case codes.PermissionDenied: + return http.StatusForbidden + case codes.Unauthenticated: + return http.StatusUnauthorized + case codes.ResourceExhausted: + return http.StatusForbidden + case codes.FailedPrecondition: + return http.StatusPreconditionFailed + case codes.Aborted: + return http.StatusConflict + case codes.OutOfRange: + return http.StatusBadRequest + case codes.Unimplemented: + return http.StatusNotImplemented + case codes.Internal: + return http.StatusInternalServerError + case codes.Unavailable: + return http.StatusServiceUnavailable + case codes.DataLoss: + return http.StatusInternalServerError + } + + grpclog.Printf("Unknown gRPC error code: %v", code) + return http.StatusInternalServerError +} + +var ( + // HTTPError replies to the request with the error. + // You can set a custom function to this variable to customize error format. + HTTPError = DefaultHTTPError + // OtherErrorHandler handles the following error used by the gateway: StatusMethodNotAllowed StatusNotFound and StatusBadRequest + OtherErrorHandler = DefaultOtherErrorHandler +) + +type errorBody struct { + Error string `json:"error"` + Code int `json:"code"` +} + +//Make this also conform to proto.Message for builtin JSONPb Marshaler +func (e *errorBody) Reset() { *e = errorBody{} } +func (e *errorBody) String() string { return proto.CompactTextString(e) } +func (*errorBody) ProtoMessage() {} + +// DefaultHTTPError is the default implementation of HTTPError. +// If "err" is an error from gRPC system, the function replies with the status code mapped by HTTPStatusFromCode. +// If otherwise, it replies with http.StatusInternalServerError. +// +// The response body returned by this function is a JSON object, +// which contains a member whose key is "error" and whose value is err.Error(). +func DefaultHTTPError(ctx context.Context, marshaler Marshaler, w http.ResponseWriter, _ *http.Request, err error) { + const fallback = `{"error": "failed to marshal error message"}` + + w.Header().Del("Trailer") + w.Header().Set("Content-Type", marshaler.ContentType()) + body := &errorBody{ + Error: grpc.ErrorDesc(err), + Code: int(grpc.Code(err)), + } + + buf, merr := marshaler.Marshal(body) + if merr != nil { + grpclog.Printf("Failed to marshal error message %q: %v", body, merr) + w.WriteHeader(http.StatusInternalServerError) + if _, err := io.WriteString(w, fallback); err != nil { + grpclog.Printf("Failed to write response: %v", err) + } + return + } + + md, ok := ServerMetadataFromContext(ctx) + if !ok { + grpclog.Printf("Failed to extract ServerMetadata from context") + } + + handleForwardResponseServerMetadata(w, md) + handleForwardResponseTrailerHeader(w, md) + st := HTTPStatusFromCode(grpc.Code(err)) + w.WriteHeader(st) + if _, err := w.Write(buf); err != nil { + grpclog.Printf("Failed to write response: %v", err) + } + + handleForwardResponseTrailer(w, md) +} + +// DefaultOtherErrorHandler is the default implementation of OtherErrorHandler. +// It simply writes a string representation of the given error into "w". +func DefaultOtherErrorHandler(w http.ResponseWriter, _ *http.Request, msg string, code int) { + http.Error(w, msg, code) +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/handler.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/handler.go new file mode 100644 index 00000000..bafa4285 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/handler.go @@ -0,0 +1,164 @@ +package runtime + +import ( + "fmt" + "io" + "net/http" + "net/textproto" + + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime/internal" + "golang.org/x/net/context" + "google.golang.org/grpc" + "google.golang.org/grpc/grpclog" +) + +// ForwardResponseStream forwards the stream from gRPC server to REST client. +func ForwardResponseStream(ctx context.Context, marshaler Marshaler, w http.ResponseWriter, req *http.Request, recv func() (proto.Message, error), opts ...func(context.Context, http.ResponseWriter, proto.Message) error) { + f, ok := w.(http.Flusher) + if !ok { + grpclog.Printf("Flush not supported in %T", w) + http.Error(w, "unexpected type of web server", http.StatusInternalServerError) + return + } + + md, ok := ServerMetadataFromContext(ctx) + if !ok { + grpclog.Printf("Failed to extract ServerMetadata from context") + http.Error(w, "unexpected error", http.StatusInternalServerError) + return + } + handleForwardResponseServerMetadata(w, md) + + w.Header().Set("Transfer-Encoding", "chunked") + w.Header().Set("Content-Type", marshaler.ContentType()) + if err := handleForwardResponseOptions(ctx, w, nil, opts); err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + w.WriteHeader(http.StatusOK) + f.Flush() + for { + resp, err := recv() + if err == io.EOF { + return + } + if err != nil { + handleForwardResponseStreamError(marshaler, w, err) + return + } + if err := handleForwardResponseOptions(ctx, w, resp, opts); err != nil { + handleForwardResponseStreamError(marshaler, w, err) + return + } + + buf, err := marshaler.Marshal(streamChunk(resp, nil)) + if err != nil { + grpclog.Printf("Failed to marshal response chunk: %v", err) + return + } + if _, err = fmt.Fprintf(w, "%s\n", buf); err != nil { + grpclog.Printf("Failed to send response chunk: %v", err) + return + } + f.Flush() + } +} + +func handleForwardResponseServerMetadata(w http.ResponseWriter, md ServerMetadata) { + for k, vs := range md.HeaderMD { + hKey := fmt.Sprintf("%s%s", metadataHeaderPrefix, k) + for i := range vs { + w.Header().Add(hKey, vs[i]) + } + } +} + +func handleForwardResponseTrailerHeader(w http.ResponseWriter, md ServerMetadata) { + for k := range md.TrailerMD { + tKey := textproto.CanonicalMIMEHeaderKey(fmt.Sprintf("%s%s", metadataTrailerPrefix, k)) + w.Header().Add("Trailer", tKey) + } +} + +func handleForwardResponseTrailer(w http.ResponseWriter, md ServerMetadata) { + for k, vs := range md.TrailerMD { + tKey := fmt.Sprintf("%s%s", metadataTrailerPrefix, k) + for i := range vs { + w.Header().Add(tKey, vs[i]) + } + } +} + +// ForwardResponseMessage forwards the message "resp" from gRPC server to REST client. +func ForwardResponseMessage(ctx context.Context, marshaler Marshaler, w http.ResponseWriter, req *http.Request, resp proto.Message, opts ...func(context.Context, http.ResponseWriter, proto.Message) error) { + md, ok := ServerMetadataFromContext(ctx) + if !ok { + grpclog.Printf("Failed to extract ServerMetadata from context") + } + + handleForwardResponseServerMetadata(w, md) + handleForwardResponseTrailerHeader(w, md) + w.Header().Set("Content-Type", marshaler.ContentType()) + if err := handleForwardResponseOptions(ctx, w, resp, opts); err != nil { + HTTPError(ctx, marshaler, w, req, err) + return + } + + buf, err := marshaler.Marshal(resp) + if err != nil { + grpclog.Printf("Marshal error: %v", err) + HTTPError(ctx, marshaler, w, req, err) + return + } + + if _, err = w.Write(buf); err != nil { + grpclog.Printf("Failed to write response: %v", err) + } + + handleForwardResponseTrailer(w, md) +} + +func handleForwardResponseOptions(ctx context.Context, w http.ResponseWriter, resp proto.Message, opts []func(context.Context, http.ResponseWriter, proto.Message) error) error { + if len(opts) == 0 { + return nil + } + for _, opt := range opts { + if err := opt(ctx, w, resp); err != nil { + grpclog.Printf("Error handling ForwardResponseOptions: %v", err) + return err + } + } + return nil +} + +func handleForwardResponseStreamError(marshaler Marshaler, w http.ResponseWriter, err error) { + buf, merr := marshaler.Marshal(streamChunk(nil, err)) + if merr != nil { + grpclog.Printf("Failed to marshal an error: %v", merr) + return + } + if _, werr := fmt.Fprintf(w, "%s\n", buf); werr != nil { + grpclog.Printf("Failed to notify error to client: %v", werr) + return + } +} + +func streamChunk(result proto.Message, err error) map[string]proto.Message { + if err != nil { + grpcCode := grpc.Code(err) + httpCode := HTTPStatusFromCode(grpcCode) + return map[string]proto.Message{ + "error": &internal.StreamError{ + GrpcCode: int32(grpcCode), + HttpCode: int32(httpCode), + Message: err.Error(), + HttpStatus: http.StatusText(httpCode), + }, + } + } + if result == nil { + return streamChunk(nil, fmt.Errorf("empty response")) + } + return map[string]proto.Message{"result": result} +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/internal/stream_chunk.pb.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/internal/stream_chunk.pb.go new file mode 100644 index 00000000..524e0d3c --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/internal/stream_chunk.pb.go @@ -0,0 +1,65 @@ +// Code generated by protoc-gen-go. +// source: runtime/internal/stream_chunk.proto +// DO NOT EDIT! + +/* +Package internal is a generated protocol buffer package. + +It is generated from these files: + runtime/internal/stream_chunk.proto + +It has these top-level messages: + StreamError +*/ +package internal + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +// StreamError is a response type which is returned when +// streaming rpc returns an error. +type StreamError struct { + GrpcCode int32 `protobuf:"varint,1,opt,name=grpc_code,json=grpcCode" json:"grpc_code,omitempty"` + HttpCode int32 `protobuf:"varint,2,opt,name=http_code,json=httpCode" json:"http_code,omitempty"` + Message string `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"` + HttpStatus string `protobuf:"bytes,4,opt,name=http_status,json=httpStatus" json:"http_status,omitempty"` +} + +func (m *StreamError) Reset() { *m = StreamError{} } +func (m *StreamError) String() string { return proto.CompactTextString(m) } +func (*StreamError) ProtoMessage() {} +func (*StreamError) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +func init() { + proto.RegisterType((*StreamError)(nil), "grpc.gateway.runtime.StreamError") +} + +func init() { proto.RegisterFile("runtime/internal/stream_chunk.proto", fileDescriptor0) } + +var fileDescriptor0 = []byte{ + // 180 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x52, 0x2e, 0x2a, 0xcd, 0x2b, + 0xc9, 0xcc, 0x4d, 0xd5, 0xcf, 0xcc, 0x2b, 0x49, 0x2d, 0xca, 0x4b, 0xcc, 0xd1, 0x2f, 0x2e, 0x29, + 0x4a, 0x4d, 0xcc, 0x8d, 0x4f, 0xce, 0x28, 0xcd, 0xcb, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, + 0x12, 0x49, 0x2f, 0x2a, 0x48, 0xd6, 0x4b, 0x4f, 0x2c, 0x49, 0x2d, 0x4f, 0xac, 0xd4, 0x83, 0xea, + 0x50, 0x6a, 0x62, 0xe4, 0xe2, 0x0e, 0x06, 0x2b, 0x76, 0x2d, 0x2a, 0xca, 0x2f, 0x12, 0x92, 0xe6, + 0xe2, 0x04, 0xa9, 0x8b, 0x4f, 0xce, 0x4f, 0x49, 0x95, 0x60, 0x54, 0x60, 0xd4, 0x60, 0x0d, 0xe2, + 0x00, 0x09, 0x38, 0x03, 0xf9, 0x20, 0xc9, 0x8c, 0x92, 0x92, 0x02, 0x88, 0x24, 0x13, 0x44, 0x12, + 0x24, 0x00, 0x96, 0x94, 0xe0, 0x62, 0xcf, 0x4d, 0x2d, 0x2e, 0x4e, 0x4c, 0x4f, 0x95, 0x60, 0x06, + 0x4a, 0x71, 0x06, 0xc1, 0xb8, 0x42, 0xf2, 0x5c, 0xdc, 0x60, 0x6d, 0xc5, 0x25, 0x89, 0x25, 0xa5, + 0xc5, 0x12, 0x2c, 0x60, 0x59, 0x2e, 0x90, 0x50, 0x30, 0x58, 0xc4, 0x89, 0x2b, 0x8a, 0x03, 0xe6, + 0xf2, 0x24, 0x36, 0xb0, 0x6b, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x07, 0x92, 0xb6, + 0xd4, 0x00, 0x00, 0x00, +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshal_json.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshal_json.go new file mode 100644 index 00000000..0acd2ca2 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshal_json.go @@ -0,0 +1,37 @@ +package runtime + +import ( + "encoding/json" + "io" +) + +// JSONBuiltin is a Marshaler which marshals/unmarshals into/from JSON +// with the standard "encoding/json" package of Golang. +// Although it is generally faster for simple proto messages than JSONPb, +// it does not support advanced features of protobuf, e.g. map, oneof, .... +type JSONBuiltin struct{} + +// ContentType always Returns "application/json". +func (*JSONBuiltin) ContentType() string { + return "application/json" +} + +// Marshal marshals "v" into JSON +func (j *JSONBuiltin) Marshal(v interface{}) ([]byte, error) { + return json.Marshal(v) +} + +// Unmarshal unmarshals JSON data into "v". +func (j *JSONBuiltin) Unmarshal(data []byte, v interface{}) error { + return json.Unmarshal(data, v) +} + +// NewDecoder returns a Decoder which reads JSON stream from "r". +func (j *JSONBuiltin) NewDecoder(r io.Reader) Decoder { + return json.NewDecoder(r) +} + +// NewEncoder returns an Encoder which writes JSON stream into "w". +func (j *JSONBuiltin) NewEncoder(w io.Writer) Encoder { + return json.NewEncoder(w) +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshal_jsonpb.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshal_jsonpb.go new file mode 100644 index 00000000..49f13f7f --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshal_jsonpb.go @@ -0,0 +1,184 @@ +package runtime + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "reflect" + + "github.com/golang/protobuf/jsonpb" + "github.com/golang/protobuf/proto" +) + +// JSONPb is a Marshaler which marshals/unmarshals into/from JSON +// with the "github.com/golang/protobuf/jsonpb". +// It supports fully functionality of protobuf unlike JSONBuiltin. +type JSONPb jsonpb.Marshaler + +// ContentType always returns "application/json". +func (*JSONPb) ContentType() string { + return "application/json" +} + +// Marshal marshals "v" into JSON +// Currently it can marshal only proto.Message. +// TODO(yugui) Support fields of primitive types in a message. +func (j *JSONPb) Marshal(v interface{}) ([]byte, error) { + if _, ok := v.(proto.Message); !ok { + return j.marshalNonProtoField(v) + } + + var buf bytes.Buffer + if err := j.marshalTo(&buf, v); err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +func (j *JSONPb) marshalTo(w io.Writer, v interface{}) error { + p, ok := v.(proto.Message) + if !ok { + buf, err := j.marshalNonProtoField(v) + if err != nil { + return err + } + _, err = w.Write(buf) + return err + } + return (*jsonpb.Marshaler)(j).Marshal(w, p) +} + +// marshalNonProto marshals a non-message field of a protobuf message. +// This function does not correctly marshals arbitary data structure into JSON, +// but it is only capable of marshaling non-message field values of protobuf, +// i.e. primitive types, enums; pointers to primitives or enums; maps from +// integer/string types to primitives/enums/pointers to messages. +func (j *JSONPb) marshalNonProtoField(v interface{}) ([]byte, error) { + rv := reflect.ValueOf(v) + for rv.Kind() == reflect.Ptr { + if rv.IsNil() { + return []byte("null"), nil + } + rv = rv.Elem() + } + + if rv.Kind() == reflect.Map { + m := make(map[string]*json.RawMessage) + for _, k := range rv.MapKeys() { + buf, err := j.Marshal(rv.MapIndex(k).Interface()) + if err != nil { + return nil, err + } + m[fmt.Sprintf("%v", k.Interface())] = (*json.RawMessage)(&buf) + } + if j.Indent != "" { + return json.MarshalIndent(m, "", j.Indent) + } + return json.Marshal(m) + } + if enum, ok := rv.Interface().(protoEnum); ok && !j.EnumsAsInts { + return json.Marshal(enum.String()) + } + return json.Marshal(rv.Interface()) +} + +// Unmarshal unmarshals JSON "data" into "v" +// Currently it can marshal only proto.Message. +// TODO(yugui) Support fields of primitive types in a message. +func (j *JSONPb) Unmarshal(data []byte, v interface{}) error { + return unmarshalJSONPb(data, v) +} + +// NewDecoder returns a Decoder which reads JSON stream from "r". +func (j *JSONPb) NewDecoder(r io.Reader) Decoder { + d := json.NewDecoder(r) + return DecoderFunc(func(v interface{}) error { return decodeJSONPb(d, v) }) +} + +// NewEncoder returns an Encoder which writes JSON stream into "w". +func (j *JSONPb) NewEncoder(w io.Writer) Encoder { + return EncoderFunc(func(v interface{}) error { return j.marshalTo(w, v) }) +} + +func unmarshalJSONPb(data []byte, v interface{}) error { + d := json.NewDecoder(bytes.NewReader(data)) + return decodeJSONPb(d, v) +} + +func decodeJSONPb(d *json.Decoder, v interface{}) error { + p, ok := v.(proto.Message) + if !ok { + return decodeNonProtoField(d, v) + } + unmarshaler := &jsonpb.Unmarshaler{AllowUnknownFields: true} + return unmarshaler.UnmarshalNext(d, p) +} + +func decodeNonProtoField(d *json.Decoder, v interface{}) error { + rv := reflect.ValueOf(v) + if rv.Kind() != reflect.Ptr { + return fmt.Errorf("%T is not a pointer", v) + } + for rv.Kind() == reflect.Ptr { + if rv.IsNil() { + rv.Set(reflect.New(rv.Type().Elem())) + } + if rv.Type().ConvertibleTo(typeProtoMessage) { + unmarshaler := &jsonpb.Unmarshaler{AllowUnknownFields: true} + return unmarshaler.UnmarshalNext(d, rv.Interface().(proto.Message)) + } + rv = rv.Elem() + } + if rv.Kind() == reflect.Map { + if rv.IsNil() { + rv.Set(reflect.MakeMap(rv.Type())) + } + conv, ok := convFromType[rv.Type().Key().Kind()] + if !ok { + return fmt.Errorf("unsupported type of map field key: %v", rv.Type().Key()) + } + + m := make(map[string]*json.RawMessage) + if err := d.Decode(&m); err != nil { + return err + } + for k, v := range m { + result := conv.Call([]reflect.Value{reflect.ValueOf(k)}) + if err := result[1].Interface(); err != nil { + return err.(error) + } + bk := result[0] + bv := reflect.New(rv.Type().Elem()) + if err := unmarshalJSONPb([]byte(*v), bv.Interface()); err != nil { + return err + } + rv.SetMapIndex(bk, bv.Elem()) + } + return nil + } + if _, ok := rv.Interface().(protoEnum); ok { + var repr interface{} + if err := d.Decode(&repr); err != nil { + return err + } + switch repr.(type) { + case string: + // TODO(yugui) Should use proto.StructProperties? + return fmt.Errorf("unmarshaling of symbolic enum %q not supported: %T", repr, rv.Interface()) + case float64: + rv.Set(reflect.ValueOf(int32(repr.(float64))).Convert(rv.Type())) + return nil + default: + return fmt.Errorf("cannot assign %#v into Go type %T", repr, rv.Interface()) + } + } + return d.Decode(v) +} + +type protoEnum interface { + fmt.Stringer + EnumDescriptor() ([]byte, []int) +} + +var typeProtoMessage = reflect.TypeOf((*proto.Message)(nil)).Elem() diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshaler.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshaler.go new file mode 100644 index 00000000..6d434f13 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshaler.go @@ -0,0 +1,42 @@ +package runtime + +import ( + "io" +) + +// Marshaler defines a conversion between byte sequence and gRPC payloads / fields. +type Marshaler interface { + // Marshal marshals "v" into byte sequence. + Marshal(v interface{}) ([]byte, error) + // Unmarshal unmarshals "data" into "v". + // "v" must be a pointer value. + Unmarshal(data []byte, v interface{}) error + // NewDecoder returns a Decoder which reads byte sequence from "r". + NewDecoder(r io.Reader) Decoder + // NewEncoder returns an Encoder which writes bytes sequence into "w". + NewEncoder(w io.Writer) Encoder + // ContentType returns the Content-Type which this marshaler is responsible for. + ContentType() string +} + +// Decoder decodes a byte sequence +type Decoder interface { + Decode(v interface{}) error +} + +// Encoder encodes gRPC payloads / fields into byte sequence. +type Encoder interface { + Encode(v interface{}) error +} + +// DecoderFunc adapts an decoder function into Decoder. +type DecoderFunc func(v interface{}) error + +// Decode delegates invocations to the underlying function itself. +func (f DecoderFunc) Decode(v interface{}) error { return f(v) } + +// EncoderFunc adapts an encoder function into Encoder +type EncoderFunc func(v interface{}) error + +// Encode delegates invocations to the underlying function itself. +func (f EncoderFunc) Encode(v interface{}) error { return f(v) } diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshaler_registry.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshaler_registry.go new file mode 100644 index 00000000..928f0733 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/marshaler_registry.go @@ -0,0 +1,91 @@ +package runtime + +import ( + "errors" + "net/http" +) + +// MIMEWildcard is the fallback MIME type used for requests which do not match +// a registered MIME type. +const MIMEWildcard = "*" + +var ( + acceptHeader = http.CanonicalHeaderKey("Accept") + contentTypeHeader = http.CanonicalHeaderKey("Content-Type") + + defaultMarshaler = &JSONPb{OrigName: true} +) + +// MarshalerForRequest returns the inbound/outbound marshalers for this request. +// It checks the registry on the ServeMux for the MIME type set by the Content-Type header. +// If it isn't set (or the request Content-Type is empty), checks for "*". +// If there are multiple Content-Type headers set, choose the first one that it can +// exactly match in the registry. +// Otherwise, it follows the above logic for "*"/InboundMarshaler/OutboundMarshaler. +func MarshalerForRequest(mux *ServeMux, r *http.Request) (inbound Marshaler, outbound Marshaler) { + for _, acceptVal := range r.Header[acceptHeader] { + if m, ok := mux.marshalers.mimeMap[acceptVal]; ok { + outbound = m + break + } + } + + for _, contentTypeVal := range r.Header[contentTypeHeader] { + if m, ok := mux.marshalers.mimeMap[contentTypeVal]; ok { + inbound = m + break + } + } + + if inbound == nil { + inbound = mux.marshalers.mimeMap[MIMEWildcard] + } + if outbound == nil { + outbound = inbound + } + + return inbound, outbound +} + +// marshalerRegistry is a mapping from MIME types to Marshalers. +type marshalerRegistry struct { + mimeMap map[string]Marshaler +} + +// add adds a marshaler for a case-sensitive MIME type string ("*" to match any +// MIME type). +func (m marshalerRegistry) add(mime string, marshaler Marshaler) error { + if len(mime) == 0 { + return errors.New("empty MIME type") + } + + m.mimeMap[mime] = marshaler + + return nil +} + +// makeMarshalerMIMERegistry returns a new registry of marshalers. +// It allows for a mapping of case-sensitive Content-Type MIME type string to runtime.Marshaler interfaces. +// +// For example, you could allow the client to specify the use of the runtime.JSONPb marshaler +// with a "applicaton/jsonpb" Content-Type and the use of the runtime.JSONBuiltin marshaler +// with a "application/json" Content-Type. +// "*" can be used to match any Content-Type. +// This can be attached to a ServerMux with the marshaler option. +func makeMarshalerMIMERegistry() marshalerRegistry { + return marshalerRegistry{ + mimeMap: map[string]Marshaler{ + MIMEWildcard: defaultMarshaler, + }, + } +} + +// WithMarshalerOption returns a ServeMuxOption which associates inbound and outbound +// Marshalers to a MIME type in mux. +func WithMarshalerOption(mime string, marshaler Marshaler) ServeMuxOption { + return func(mux *ServeMux) { + if err := mux.marshalers.add(mime, marshaler); err != nil { + panic(err) + } + } +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/mux.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/mux.go new file mode 100644 index 00000000..2e6c5621 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/mux.go @@ -0,0 +1,132 @@ +package runtime + +import ( + "net/http" + "strings" + + "golang.org/x/net/context" + + "github.com/golang/protobuf/proto" +) + +// A HandlerFunc handles a specific pair of path pattern and HTTP method. +type HandlerFunc func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) + +// ServeMux is a request multiplexer for grpc-gateway. +// It matches http requests to patterns and invokes the corresponding handler. +type ServeMux struct { + // handlers maps HTTP method to a list of handlers. + handlers map[string][]handler + forwardResponseOptions []func(context.Context, http.ResponseWriter, proto.Message) error + marshalers marshalerRegistry +} + +// ServeMuxOption is an option that can be given to a ServeMux on construction. +type ServeMuxOption func(*ServeMux) + +// WithForwardResponseOption returns a ServeMuxOption representing the forwardResponseOption. +// +// forwardResponseOption is an option that will be called on the relevant context.Context, +// http.ResponseWriter, and proto.Message before every forwarded response. +// +// The message may be nil in the case where just a header is being sent. +func WithForwardResponseOption(forwardResponseOption func(context.Context, http.ResponseWriter, proto.Message) error) ServeMuxOption { + return func(serveMux *ServeMux) { + serveMux.forwardResponseOptions = append(serveMux.forwardResponseOptions, forwardResponseOption) + } +} + +// NewServeMux returns a new ServeMux whose internal mapping is empty. +func NewServeMux(opts ...ServeMuxOption) *ServeMux { + serveMux := &ServeMux{ + handlers: make(map[string][]handler), + forwardResponseOptions: make([]func(context.Context, http.ResponseWriter, proto.Message) error, 0), + marshalers: makeMarshalerMIMERegistry(), + } + + for _, opt := range opts { + opt(serveMux) + } + return serveMux +} + +// Handle associates "h" to the pair of HTTP method and path pattern. +func (s *ServeMux) Handle(meth string, pat Pattern, h HandlerFunc) { + s.handlers[meth] = append(s.handlers[meth], handler{pat: pat, h: h}) +} + +// ServeHTTP dispatches the request to the first handler whose pattern matches to r.Method and r.Path. +func (s *ServeMux) ServeHTTP(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + if !strings.HasPrefix(path, "/") { + OtherErrorHandler(w, r, http.StatusText(http.StatusBadRequest), http.StatusBadRequest) + return + } + + components := strings.Split(path[1:], "/") + l := len(components) + var verb string + if idx := strings.LastIndex(components[l-1], ":"); idx == 0 { + OtherErrorHandler(w, r, http.StatusText(http.StatusNotFound), http.StatusNotFound) + return + } else if idx > 0 { + c := components[l-1] + components[l-1], verb = c[:idx], c[idx+1:] + } + + if override := r.Header.Get("X-HTTP-Method-Override"); override != "" && isPathLengthFallback(r) { + r.Method = strings.ToUpper(override) + if err := r.ParseForm(); err != nil { + OtherErrorHandler(w, r, err.Error(), http.StatusBadRequest) + return + } + } + for _, h := range s.handlers[r.Method] { + pathParams, err := h.pat.Match(components, verb) + if err != nil { + continue + } + h.h(w, r, pathParams) + return + } + + // lookup other methods to handle fallback from GET to POST and + // to determine if it is MethodNotAllowed or NotFound. + for m, handlers := range s.handlers { + if m == r.Method { + continue + } + for _, h := range handlers { + pathParams, err := h.pat.Match(components, verb) + if err != nil { + continue + } + // X-HTTP-Method-Override is optional. Always allow fallback to POST. + if isPathLengthFallback(r) { + if err := r.ParseForm(); err != nil { + OtherErrorHandler(w, r, err.Error(), http.StatusBadRequest) + return + } + h.h(w, r, pathParams) + return + } + OtherErrorHandler(w, r, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed) + return + } + } + OtherErrorHandler(w, r, http.StatusText(http.StatusNotFound), http.StatusNotFound) +} + +// GetForwardResponseOptions returns the ForwardResponseOptions associated with this ServeMux. +func (s *ServeMux) GetForwardResponseOptions() []func(context.Context, http.ResponseWriter, proto.Message) error { + return s.forwardResponseOptions +} + +func isPathLengthFallback(r *http.Request) bool { + return r.Method == "POST" && r.Header.Get("Content-Type") == "application/x-www-form-urlencoded" +} + +type handler struct { + pat Pattern + h HandlerFunc +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/pattern.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/pattern.go new file mode 100644 index 00000000..3947dbea --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/pattern.go @@ -0,0 +1,227 @@ +package runtime + +import ( + "errors" + "fmt" + "strings" + + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc/grpclog" +) + +var ( + // ErrNotMatch indicates that the given HTTP request path does not match to the pattern. + ErrNotMatch = errors.New("not match to the path pattern") + // ErrInvalidPattern indicates that the given definition of Pattern is not valid. + ErrInvalidPattern = errors.New("invalid pattern") +) + +type op struct { + code utilities.OpCode + operand int +} + +// Pattern is a template pattern of http request paths defined in third_party/googleapis/google/api/http.proto. +type Pattern struct { + // ops is a list of operations + ops []op + // pool is a constant pool indexed by the operands or vars. + pool []string + // vars is a list of variables names to be bound by this pattern + vars []string + // stacksize is the max depth of the stack + stacksize int + // tailLen is the length of the fixed-size segments after a deep wildcard + tailLen int + // verb is the VERB part of the path pattern. It is empty if the pattern does not have VERB part. + verb string +} + +// NewPattern returns a new Pattern from the given definition values. +// "ops" is a sequence of op codes. "pool" is a constant pool. +// "verb" is the verb part of the pattern. It is empty if the pattern does not have the part. +// "version" must be 1 for now. +// It returns an error if the given definition is invalid. +func NewPattern(version int, ops []int, pool []string, verb string) (Pattern, error) { + if version != 1 { + grpclog.Printf("unsupported version: %d", version) + return Pattern{}, ErrInvalidPattern + } + + l := len(ops) + if l%2 != 0 { + grpclog.Printf("odd number of ops codes: %d", l) + return Pattern{}, ErrInvalidPattern + } + + var ( + typedOps []op + stack, maxstack int + tailLen int + pushMSeen bool + vars []string + ) + for i := 0; i < l; i += 2 { + op := op{code: utilities.OpCode(ops[i]), operand: ops[i+1]} + switch op.code { + case utilities.OpNop: + continue + case utilities.OpPush: + if pushMSeen { + tailLen++ + } + stack++ + case utilities.OpPushM: + if pushMSeen { + grpclog.Printf("pushM appears twice") + return Pattern{}, ErrInvalidPattern + } + pushMSeen = true + stack++ + case utilities.OpLitPush: + if op.operand < 0 || len(pool) <= op.operand { + grpclog.Printf("negative literal index: %d", op.operand) + return Pattern{}, ErrInvalidPattern + } + if pushMSeen { + tailLen++ + } + stack++ + case utilities.OpConcatN: + if op.operand <= 0 { + grpclog.Printf("negative concat size: %d", op.operand) + return Pattern{}, ErrInvalidPattern + } + stack -= op.operand + if stack < 0 { + grpclog.Print("stack underflow") + return Pattern{}, ErrInvalidPattern + } + stack++ + case utilities.OpCapture: + if op.operand < 0 || len(pool) <= op.operand { + grpclog.Printf("variable name index out of bound: %d", op.operand) + return Pattern{}, ErrInvalidPattern + } + v := pool[op.operand] + op.operand = len(vars) + vars = append(vars, v) + stack-- + if stack < 0 { + grpclog.Printf("stack underflow") + return Pattern{}, ErrInvalidPattern + } + default: + grpclog.Printf("invalid opcode: %d", op.code) + return Pattern{}, ErrInvalidPattern + } + + if maxstack < stack { + maxstack = stack + } + typedOps = append(typedOps, op) + } + return Pattern{ + ops: typedOps, + pool: pool, + vars: vars, + stacksize: maxstack, + tailLen: tailLen, + verb: verb, + }, nil +} + +// MustPattern is a helper function which makes it easier to call NewPattern in variable initialization. +func MustPattern(p Pattern, err error) Pattern { + if err != nil { + grpclog.Fatalf("Pattern initialization failed: %v", err) + } + return p +} + +// Match examines components if it matches to the Pattern. +// If it matches, the function returns a mapping from field paths to their captured values. +// If otherwise, the function returns an error. +func (p Pattern) Match(components []string, verb string) (map[string]string, error) { + if p.verb != verb { + return nil, ErrNotMatch + } + + var pos int + stack := make([]string, 0, p.stacksize) + captured := make([]string, len(p.vars)) + l := len(components) + for _, op := range p.ops { + switch op.code { + case utilities.OpNop: + continue + case utilities.OpPush, utilities.OpLitPush: + if pos >= l { + return nil, ErrNotMatch + } + c := components[pos] + if op.code == utilities.OpLitPush { + if lit := p.pool[op.operand]; c != lit { + return nil, ErrNotMatch + } + } + stack = append(stack, c) + pos++ + case utilities.OpPushM: + end := len(components) + if end < pos+p.tailLen { + return nil, ErrNotMatch + } + end -= p.tailLen + stack = append(stack, strings.Join(components[pos:end], "/")) + pos = end + case utilities.OpConcatN: + n := op.operand + l := len(stack) - n + stack = append(stack[:l], strings.Join(stack[l:], "/")) + case utilities.OpCapture: + n := len(stack) - 1 + captured[op.operand] = stack[n] + stack = stack[:n] + } + } + if pos < l { + return nil, ErrNotMatch + } + bindings := make(map[string]string) + for i, val := range captured { + bindings[p.vars[i]] = val + } + return bindings, nil +} + +// Verb returns the verb part of the Pattern. +func (p Pattern) Verb() string { return p.verb } + +func (p Pattern) String() string { + var stack []string + for _, op := range p.ops { + switch op.code { + case utilities.OpNop: + continue + case utilities.OpPush: + stack = append(stack, "*") + case utilities.OpLitPush: + stack = append(stack, p.pool[op.operand]) + case utilities.OpPushM: + stack = append(stack, "**") + case utilities.OpConcatN: + n := op.operand + l := len(stack) - n + stack = append(stack[:l], strings.Join(stack[l:], "/")) + case utilities.OpCapture: + n := len(stack) - 1 + stack[n] = fmt.Sprintf("{%s=%s}", p.vars[op.operand], stack[n]) + } + } + segs := strings.Join(stack, "/") + if p.verb != "" { + return fmt.Sprintf("/%s:%s", segs, p.verb) + } + return "/" + segs +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/proto2_convert.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/proto2_convert.go new file mode 100644 index 00000000..a3151e2a --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/proto2_convert.go @@ -0,0 +1,80 @@ +package runtime + +import ( + "github.com/golang/protobuf/proto" +) + +// StringP returns a pointer to a string whose pointee is same as the given string value. +func StringP(val string) (*string, error) { + return proto.String(val), nil +} + +// BoolP parses the given string representation of a boolean value, +// and returns a pointer to a bool whose value is same as the parsed value. +func BoolP(val string) (*bool, error) { + b, err := Bool(val) + if err != nil { + return nil, err + } + return proto.Bool(b), nil +} + +// Float64P parses the given string representation of a floating point number, +// and returns a pointer to a float64 whose value is same as the parsed number. +func Float64P(val string) (*float64, error) { + f, err := Float64(val) + if err != nil { + return nil, err + } + return proto.Float64(f), nil +} + +// Float32P parses the given string representation of a floating point number, +// and returns a pointer to a float32 whose value is same as the parsed number. +func Float32P(val string) (*float32, error) { + f, err := Float32(val) + if err != nil { + return nil, err + } + return proto.Float32(f), nil +} + +// Int64P parses the given string representation of an integer +// and returns a pointer to a int64 whose value is same as the parsed integer. +func Int64P(val string) (*int64, error) { + i, err := Int64(val) + if err != nil { + return nil, err + } + return proto.Int64(i), nil +} + +// Int32P parses the given string representation of an integer +// and returns a pointer to a int32 whose value is same as the parsed integer. +func Int32P(val string) (*int32, error) { + i, err := Int32(val) + if err != nil { + return nil, err + } + return proto.Int32(i), err +} + +// Uint64P parses the given string representation of an integer +// and returns a pointer to a uint64 whose value is same as the parsed integer. +func Uint64P(val string) (*uint64, error) { + i, err := Uint64(val) + if err != nil { + return nil, err + } + return proto.Uint64(i), err +} + +// Uint32P parses the given string representation of an integer +// and returns a pointer to a uint32 whose value is same as the parsed integer. +func Uint32P(val string) (*uint32, error) { + i, err := Uint32(val) + if err != nil { + return nil, err + } + return proto.Uint32(i), err +} diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/query.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/query.go new file mode 100644 index 00000000..56a919a5 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/runtime/query.go @@ -0,0 +1,140 @@ +package runtime + +import ( + "fmt" + "net/url" + "reflect" + "strings" + + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc/grpclog" +) + +// PopulateQueryParameters populates "values" into "msg". +// A value is ignored if its key starts with one of the elements in "filter". +func PopulateQueryParameters(msg proto.Message, values url.Values, filter *utilities.DoubleArray) error { + for key, values := range values { + fieldPath := strings.Split(key, ".") + if filter.HasCommonPrefix(fieldPath) { + continue + } + if err := populateFieldValueFromPath(msg, fieldPath, values); err != nil { + return err + } + } + return nil +} + +// PopulateFieldFromPath sets a value in a nested Protobuf structure. +// It instantiates missing protobuf fields as it goes. +func PopulateFieldFromPath(msg proto.Message, fieldPathString string, value string) error { + fieldPath := strings.Split(fieldPathString, ".") + return populateFieldValueFromPath(msg, fieldPath, []string{value}) +} + +func populateFieldValueFromPath(msg proto.Message, fieldPath []string, values []string) error { + m := reflect.ValueOf(msg) + if m.Kind() != reflect.Ptr { + return fmt.Errorf("unexpected type %T: %v", msg, msg) + } + m = m.Elem() + for i, fieldName := range fieldPath { + isLast := i == len(fieldPath)-1 + if !isLast && m.Kind() != reflect.Struct { + return fmt.Errorf("non-aggregate type in the mid of path: %s", strings.Join(fieldPath, ".")) + } + f := fieldByProtoName(m, fieldName) + if !f.IsValid() { + grpclog.Printf("field not found in %T: %s", msg, strings.Join(fieldPath, ".")) + return nil + } + + switch f.Kind() { + case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, reflect.String, reflect.Uint32, reflect.Uint64: + m = f + case reflect.Slice: + // TODO(yugui) Support []byte + if !isLast { + return fmt.Errorf("unexpected repeated field in %s", strings.Join(fieldPath, ".")) + } + return populateRepeatedField(f, values) + case reflect.Ptr: + if f.IsNil() { + m = reflect.New(f.Type().Elem()) + f.Set(m) + } + m = f.Elem() + continue + case reflect.Struct: + m = f + continue + default: + return fmt.Errorf("unexpected type %s in %T", f.Type(), msg) + } + } + switch len(values) { + case 0: + return fmt.Errorf("no value of field: %s", strings.Join(fieldPath, ".")) + case 1: + default: + grpclog.Printf("too many field values: %s", strings.Join(fieldPath, ".")) + } + return populateField(m, values[0]) +} + +// fieldByProtoName looks up a field whose corresponding protobuf field name is "name". +// "m" must be a struct value. It returns zero reflect.Value if no such field found. +func fieldByProtoName(m reflect.Value, name string) reflect.Value { + props := proto.GetProperties(m.Type()) + for _, p := range props.Prop { + if p.OrigName == name { + return m.FieldByName(p.Name) + } + } + return reflect.Value{} +} + +func populateRepeatedField(f reflect.Value, values []string) error { + elemType := f.Type().Elem() + conv, ok := convFromType[elemType.Kind()] + if !ok { + return fmt.Errorf("unsupported field type %s", elemType) + } + f.Set(reflect.MakeSlice(f.Type(), len(values), len(values))) + for i, v := range values { + result := conv.Call([]reflect.Value{reflect.ValueOf(v)}) + if err := result[1].Interface(); err != nil { + return err.(error) + } + f.Index(i).Set(result[0]) + } + return nil +} + +func populateField(f reflect.Value, value string) error { + conv, ok := convFromType[f.Kind()] + if !ok { + return fmt.Errorf("unsupported field type %T", f) + } + result := conv.Call([]reflect.Value{reflect.ValueOf(value)}) + if err := result[1].Interface(); err != nil { + return err.(error) + } + f.Set(result[0]) + return nil +} + +var ( + convFromType = map[reflect.Kind]reflect.Value{ + reflect.String: reflect.ValueOf(String), + reflect.Bool: reflect.ValueOf(Bool), + reflect.Float64: reflect.ValueOf(Float64), + reflect.Float32: reflect.ValueOf(Float32), + reflect.Int64: reflect.ValueOf(Int64), + reflect.Int32: reflect.ValueOf(Int32), + reflect.Uint64: reflect.ValueOf(Uint64), + reflect.Uint32: reflect.ValueOf(Uint32), + // TODO(yugui) Support []byte + } +) diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/utilities/doc.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/utilities/doc.go new file mode 100644 index 00000000..cf79a4d5 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/utilities/doc.go @@ -0,0 +1,2 @@ +// Package utilities provides members for internal use in grpc-gateway. +package utilities diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/utilities/pattern.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/utilities/pattern.go new file mode 100644 index 00000000..28ad9461 --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/utilities/pattern.go @@ -0,0 +1,22 @@ +package utilities + +// An OpCode is a opcode of compiled path patterns. +type OpCode int + +// These constants are the valid values of OpCode. +const ( + // OpNop does nothing + OpNop = OpCode(iota) + // OpPush pushes a component to stack + OpPush + // OpLitPush pushes a component to stack if it matches to the literal + OpLitPush + // OpPushM concatenates the remaining components and pushes it to stack + OpPushM + // OpConcatN pops N items from stack, concatenates them and pushes it back to stack + OpConcatN + // OpCapture pops an item and binds it to the variable + OpCapture + // OpEnd is the least postive invalid opcode. + OpEnd +) diff --git a/vendor/github.com/grpc-ecosystem/grpc-gateway/utilities/trie.go b/vendor/github.com/grpc-ecosystem/grpc-gateway/utilities/trie.go new file mode 100644 index 00000000..c2b7b30d --- /dev/null +++ b/vendor/github.com/grpc-ecosystem/grpc-gateway/utilities/trie.go @@ -0,0 +1,177 @@ +package utilities + +import ( + "sort" +) + +// DoubleArray is a Double Array implementation of trie on sequences of strings. +type DoubleArray struct { + // Encoding keeps an encoding from string to int + Encoding map[string]int + // Base is the base array of Double Array + Base []int + // Check is the check array of Double Array + Check []int +} + +// NewDoubleArray builds a DoubleArray from a set of sequences of strings. +func NewDoubleArray(seqs [][]string) *DoubleArray { + da := &DoubleArray{Encoding: make(map[string]int)} + if len(seqs) == 0 { + return da + } + + encoded := registerTokens(da, seqs) + sort.Sort(byLex(encoded)) + + root := node{row: -1, col: -1, left: 0, right: len(encoded)} + addSeqs(da, encoded, 0, root) + + for i := len(da.Base); i > 0; i-- { + if da.Check[i-1] != 0 { + da.Base = da.Base[:i] + da.Check = da.Check[:i] + break + } + } + return da +} + +func registerTokens(da *DoubleArray, seqs [][]string) [][]int { + var result [][]int + for _, seq := range seqs { + var encoded []int + for _, token := range seq { + if _, ok := da.Encoding[token]; !ok { + da.Encoding[token] = len(da.Encoding) + } + encoded = append(encoded, da.Encoding[token]) + } + result = append(result, encoded) + } + for i := range result { + result[i] = append(result[i], len(da.Encoding)) + } + return result +} + +type node struct { + row, col int + left, right int +} + +func (n node) value(seqs [][]int) int { + return seqs[n.row][n.col] +} + +func (n node) children(seqs [][]int) []*node { + var result []*node + lastVal := int(-1) + last := new(node) + for i := n.left; i < n.right; i++ { + if lastVal == seqs[i][n.col+1] { + continue + } + last.right = i + last = &node{ + row: i, + col: n.col + 1, + left: i, + } + result = append(result, last) + } + last.right = n.right + return result +} + +func addSeqs(da *DoubleArray, seqs [][]int, pos int, n node) { + ensureSize(da, pos) + + children := n.children(seqs) + var i int + for i = 1; ; i++ { + ok := func() bool { + for _, child := range children { + code := child.value(seqs) + j := i + code + ensureSize(da, j) + if da.Check[j] != 0 { + return false + } + } + return true + }() + if ok { + break + } + } + da.Base[pos] = i + for _, child := range children { + code := child.value(seqs) + j := i + code + da.Check[j] = pos + 1 + } + terminator := len(da.Encoding) + for _, child := range children { + code := child.value(seqs) + if code == terminator { + continue + } + j := i + code + addSeqs(da, seqs, j, *child) + } +} + +func ensureSize(da *DoubleArray, i int) { + for i >= len(da.Base) { + da.Base = append(da.Base, make([]int, len(da.Base)+1)...) + da.Check = append(da.Check, make([]int, len(da.Check)+1)...) + } +} + +type byLex [][]int + +func (l byLex) Len() int { return len(l) } +func (l byLex) Swap(i, j int) { l[i], l[j] = l[j], l[i] } +func (l byLex) Less(i, j int) bool { + si := l[i] + sj := l[j] + var k int + for k = 0; k < len(si) && k < len(sj); k++ { + if si[k] < sj[k] { + return true + } + if si[k] > sj[k] { + return false + } + } + if k < len(sj) { + return true + } + return false +} + +// HasCommonPrefix determines if any sequence in the DoubleArray is a prefix of the given sequence. +func (da *DoubleArray) HasCommonPrefix(seq []string) bool { + if len(da.Base) == 0 { + return false + } + + var i int + for _, t := range seq { + code, ok := da.Encoding[t] + if !ok { + break + } + j := da.Base[i] + code + if len(da.Check) <= j || da.Check[j] != i+1 { + break + } + i = j + } + j := da.Base[i] + len(da.Encoding) + if len(da.Check) <= j || da.Check[j] != i+1 { + return false + } + return true +} diff --git a/vendor/github.com/gyuho/dataframe/LICENSE b/vendor/github.com/gyuho/dataframe/LICENSE new file mode 100644 index 00000000..ccba7588 --- /dev/null +++ b/vendor/github.com/gyuho/dataframe/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016 Gyu-Ho Lee + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/github.com/gyuho/dataframe/column.go b/vendor/github.com/gyuho/dataframe/column.go new file mode 100644 index 00000000..d21139e9 --- /dev/null +++ b/vendor/github.com/gyuho/dataframe/column.go @@ -0,0 +1,366 @@ +package dataframe + +import ( + "fmt" + "sort" + "sync" +) + +// Column represents column-based data. +type Column interface { + // RowNumber returns the number of rows of the Column. + RowNumber() int + + // GetHeader returns the header of the Column. + GetHeader() string + + // UpdateHeader updates the header of the Column. + UpdateHeader(header string) + + // GetValue returns the Value in the row. It returns error if the row + // is out of index range. + GetValue(row int) (Value, error) + + // SetValue overwrites the value + SetValue(row int, v Value) error + + // FindValue finds the first Value, and returns the row number. + // It returns -1 and false if the value does not exist. + FindValue(v Value) (int, bool) + + // FindLastValue finds the last Value, and returns the row number. + // It returns -1 and false if the value does not exist. + FindLastValue(v Value) (int, bool) + + // Front returns the first row Value. + Front() (Value, bool) + + // FrontNonNil returns the first non-nil Value from the first row. + FrontNonNil() (Value, bool) + + // Back returns the last row Value. + Back() (Value, bool) + + // BackNonNil returns the first non-nil Value from the last row. + BackNonNil() (Value, bool) + + // PushFront adds a Value to the front of the Column. + PushFront(v Value) int + + // PushBack appends the Value to the Column. + PushBack(v Value) int + + // DeleteRow deletes a row by index. + DeleteRow(row int) (Value, error) + + // DeleteRows deletes rows by index [start, end). + DeleteRows(start, end int) error + + // KeepRows keeps the rows by index [start, end). + KeepRows(start, end int) error + + // PopFront deletes the value at front. + PopFront() (Value, bool) + + // PopBack deletes the last value. + PopBack() (Value, bool) + + // Appends adds the Value to the Column until it reaches the target size. + Appends(v Value, targetSize int) error + + // SortByStringAscending sorts Column in string ascending order. + SortByStringAscending() + + // SortByStringDescending sorts Column in string descending order. + SortByStringDescending() + + // SortByNumberAscending sorts Column in number(float) ascending order. + SortByNumberAscending() + + // SortByNumberDescending sorts Column in number(float) descending order. + SortByNumberDescending() + + // SortByDurationAscending sorts Column in time.Duration ascending order. + SortByDurationAscending() + + // SortByDurationDescending sorts Column in time.Duration descending order. + SortByDurationDescending() +} + +type column struct { + mu sync.Mutex + header string + size int + data []Value +} + +func NewColumn(hd string) Column { + return &column{ + header: hd, + size: 0, + data: []Value{}, + } +} + +func (c *column) RowNumber() int { + c.mu.Lock() + defer c.mu.Unlock() + + return c.size +} + +func (c *column) GetHeader() string { + c.mu.Lock() + defer c.mu.Unlock() + + return c.header +} + +func (c *column) UpdateHeader(header string) { + c.mu.Lock() + defer c.mu.Unlock() + + c.header = header +} + +func (c *column) GetValue(row int) (Value, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if row > c.size-1 { + return nil, fmt.Errorf("index out of range (got %d for size %d)", row, c.size) + } + return c.data[row], nil +} + +func (c *column) SetValue(row int, v Value) error { + c.mu.Lock() + defer c.mu.Unlock() + + if row > c.size-1 { + return fmt.Errorf("index out of range (got %d for size %d)", row, c.size) + } + c.data[row] = v + return nil +} + +func (c *column) FindValue(v Value) (int, bool) { + c.mu.Lock() + defer c.mu.Unlock() + + for i := range c.data { + if c.data[i].EqualTo(v) { + return i, true + } + } + return -1, false +} + +func (c *column) FindLastValue(v Value) (int, bool) { + c.mu.Lock() + defer c.mu.Unlock() + + var idx int + for i := range c.data { + if c.data[i].EqualTo(v) { + idx = i + } + } + if idx != 0 { + return idx, true + } + return -1, false +} + +func (c *column) Front() (Value, bool) { + c.mu.Lock() + defer c.mu.Unlock() + + if c.size == 0 { + return nil, false + } + v := c.data[0] + return v, true +} + +func (c *column) FrontNonNil() (Value, bool) { + c.mu.Lock() + defer c.mu.Unlock() + + if c.size == 0 { + return nil, false + } + for _, v := range c.data { + if !v.IsNil() { + return v, true + } + } + return nil, false +} + +func (c *column) Back() (Value, bool) { + c.mu.Lock() + defer c.mu.Unlock() + + if c.size == 0 { + return nil, false + } + v := c.data[c.size-1] + return v, true +} + +func (c *column) BackNonNil() (Value, bool) { + c.mu.Lock() + defer c.mu.Unlock() + + if c.size == 0 { + return nil, false + } + for i := c.size - 1; i > 0; i-- { + v := c.data[i] + if !v.IsNil() { + return v, true + } + } + return nil, false +} + +func (c *column) PushFront(v Value) int { + c.mu.Lock() + defer c.mu.Unlock() + + temp := make([]Value, c.size+1) + temp[0] = v + copy(temp[1:], c.data) + c.data = temp + c.size++ + return c.size +} + +func (c *column) PushBack(v Value) int { + c.mu.Lock() + defer c.mu.Unlock() + + c.data = append(c.data, v) + c.size++ + return c.size +} + +func (c *column) DeleteRow(row int) (Value, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if row > c.size-1 { + return nil, fmt.Errorf("index out of range (got %d for size %d)", row, c.size) + } + v := c.data[row] + copy(c.data[row:], c.data[row+1:]) + c.data = c.data[:len(c.data)-1 : len(c.data)-1] + c.size-- + return v, nil +} + +func (c *column) DeleteRows(start, end int) error { + c.mu.Lock() + defer c.mu.Unlock() + + if start < 0 || end < 0 || start > end { + return fmt.Errorf("wrong range %d %d", start, end) + } + if start > c.size { + return fmt.Errorf("index out of range (start %d, size %d)", start, c.size) + } + if end > c.size { + return fmt.Errorf("index out of range (end %d, size %d)", end, c.size) + } + if start == end { + return nil + } + + delta := end - start + c.size = c.size - delta + var nds []Value + for i := range c.data { + if i >= start && i < end { + continue + } + nds = append(nds, c.data[i]) + } + c.data = nds + return nil +} + +func (c *column) KeepRows(start, end int) error { + c.mu.Lock() + defer c.mu.Unlock() + + if start < 0 || end < 0 || start > end { + return fmt.Errorf("wrong range %d %d", start, end) + } + if start > c.size { + return fmt.Errorf("index out of range (start %d, size %d)", start, c.size) + } + if end > c.size { + return fmt.Errorf("index out of range (end %d, size %d)", end, c.size) + } + if start == end { + return nil + } + + delta := end - start + c.size = delta + var nds []Value + for _, v := range c.data[start:end] { + nds = append(nds, v) + } + c.data = nds + return nil +} + +func (c *column) PopFront() (Value, bool) { + c.mu.Lock() + defer c.mu.Unlock() + + if c.size == 0 { + return nil, false + } + v := c.data[0] + c.data = c.data[1:len(c.data):len(c.data)] + c.size-- + return v, true +} + +func (c *column) PopBack() (Value, bool) { + c.mu.Lock() + defer c.mu.Unlock() + + if c.size == 0 { + return nil, false + } + v := c.data[c.size-1] + c.data = c.data[:len(c.data)-1 : len(c.data)-1] + c.size-- + return v, true +} + +func (c *column) Appends(v Value, targetSize int) error { + c.mu.Lock() + defer c.mu.Unlock() + + if c.size > 0 && c.size > targetSize { + return fmt.Errorf("cannot append with target size %d, which is less than the column size %d (can't overwrite)", targetSize, c.size) + } + + for i := c.size; i < targetSize; i++ { + c.data = append(c.data, v) + c.size++ + } + return nil +} + +func (c *column) SortByStringAscending() { sort.Sort(ByStringAscending(c.data)) } +func (c *column) SortByStringDescending() { sort.Sort(ByStringDescending(c.data)) } +func (c *column) SortByNumberAscending() { sort.Sort(ByNumberAscending(c.data)) } +func (c *column) SortByNumberDescending() { sort.Sort(ByNumberDescending(c.data)) } +func (c *column) SortByDurationAscending() { sort.Sort(ByDurationAscending(c.data)) } +func (c *column) SortByDurationDescending() { sort.Sort(ByDurationDescending(c.data)) } diff --git a/vendor/github.com/gyuho/dataframe/dataframe.go b/vendor/github.com/gyuho/dataframe/dataframe.go new file mode 100644 index 00000000..d7dd6c71 --- /dev/null +++ b/vendor/github.com/gyuho/dataframe/dataframe.go @@ -0,0 +1,349 @@ +package dataframe + +import ( + "encoding/csv" + "fmt" + "os" + "sync" +) + +// Frame contains data. +type Frame interface { + // GetHeader returns the slice of headers in order. Header name is unique among its Frame. + GetHeader() []string + + // AddColumn adds a Column to Frame. + AddColumn(c Column) error + + // GetColumn returns the Column by its header name. + GetColumn(header string) (Column, error) + + // GetColumns returns all Columns. + GetColumns() []Column + + // GetColumnNumber returns the number of Columns in the Frame. + GetColumnNumber() int + + // UpdateHeader updates the header name of a Column. + UpdateHeader(origHeader, newHeader string) error + + // DeleteColumn deletes the Column by its header. + DeleteColumn(header string) bool + + // ToCSV saves the Frame to a CSV file. + ToCSV(fpath string) error + + // ToRows returns the header and data slices. + ToRows() ([]string, [][]string) + + // Sort sorts the Frame. + Sort(header string, st SortType, so SortOption) error +} + +type frame struct { + mu sync.Mutex + columns []Column + headerTo map[string]int +} + +func New() Frame { + return &frame{ + columns: []Column{}, + headerTo: make(map[string]int), + } +} + +func NewFromRows(header []string, rows [][]string) (Frame, error) { + if len(rows) < 1 { + return nil, fmt.Errorf("empty row %q", rows) + } + fr := New() + headerN := len(header) + if headerN > 0 { // use this as header + // assume no header string at top + cols := make([]Column, headerN) + for i := range cols { + cols[i] = NewColumn(header[i]) + } + for _, row := range rows { + rowN := len(row) + if rowN > headerN { + return nil, fmt.Errorf("header %q is not specified correctly for %q", header, row) + } + for j, v := range row { + cols[j].PushBack(NewStringValue(v)) + } + if rowN < headerN { // fill in empty values + for k := rowN; k < headerN; k++ { + cols[k].PushBack(NewStringValue("")) + } + } + } + for _, c := range cols { + if err := fr.AddColumn(c); err != nil { + return nil, err + } + } + return fr, nil + } + // use first row as header + // assume header string at top + header = rows[0] + headerN = len(header) + cols := make([]Column, headerN) + for i := range cols { + cols[i] = NewColumn(header[i]) + } + for i, row := range rows { + if i == 0 { + continue + } + rowN := len(row) + if rowN > headerN { + return nil, fmt.Errorf("header %q is not specified correctly for %q", header, row) + } + for j, v := range row { + cols[j].PushBack(NewStringValue(v)) + } + if rowN < headerN { // fill in empty values + for k := rowN; k < headerN; k++ { + cols[k].PushBack(NewStringValue("")) + } + } + } + for _, c := range cols { + if err := fr.AddColumn(c); err != nil { + return nil, err + } + } + return fr, nil +} + +func NewFromCSV(header []string, fpath string) (Frame, error) { + f, err := os.OpenFile(fpath, os.O_RDONLY, 0444) + if err != nil { + return nil, err + } + defer f.Close() + + rd := csv.NewReader(f) + + // TODO: make this configurable + rd.FieldsPerRecord = -1 + + rows, err := rd.ReadAll() + if err != nil { + return nil, err + } + + return NewFromRows(header, rows) +} + +func (f *frame) GetHeader() []string { + f.mu.Lock() + defer f.mu.Unlock() + + rs := make([]string, len(f.headerTo)) + for k, v := range f.headerTo { + rs[v] = k + } + return rs +} + +func (f *frame) AddColumn(c Column) error { + f.mu.Lock() + defer f.mu.Unlock() + + header := c.GetHeader() + if _, ok := f.headerTo[header]; ok { + return fmt.Errorf("%q already exists", header) + } + f.columns = append(f.columns, c) + f.headerTo[header] = len(f.columns) - 1 + return nil +} + +func (f *frame) GetColumn(header string) (Column, error) { + f.mu.Lock() + defer f.mu.Unlock() + + idx, ok := f.headerTo[header] + if !ok { + return nil, fmt.Errorf("%q does not exist", header) + } + return f.columns[idx], nil +} + +func (f *frame) GetColumns() []Column { + f.mu.Lock() + defer f.mu.Unlock() + + return f.columns +} + +func (f *frame) GetColumnNumber() int { + f.mu.Lock() + defer f.mu.Unlock() + + return len(f.columns) +} + +func (f *frame) UpdateHeader(origHeader, newHeader string) error { + f.mu.Lock() + defer f.mu.Unlock() + + idx, ok := f.headerTo[origHeader] + if !ok { + return fmt.Errorf("%q does not exist", origHeader) + } + if _, ok := f.headerTo[newHeader]; ok { + return fmt.Errorf("%q already exists", newHeader) + } + f.columns[idx].UpdateHeader(newHeader) + f.headerTo[newHeader] = idx + delete(f.headerTo, origHeader) + return nil +} + +func (f *frame) DeleteColumn(header string) bool { + f.mu.Lock() + defer f.mu.Unlock() + + idx, ok := f.headerTo[header] + if !ok { + return false + } + if idx == 0 && len(f.headerTo) == 1 { + f.headerTo = make(map[string]int) + f.columns = []Column{} + return true + } + + copy(f.columns[idx:], f.columns[idx+1:]) + f.columns = f.columns[:len(f.columns)-1 : len(f.columns)-1] + + // update headerTo + f.headerTo = make(map[string]int) + for i, c := range f.columns { + f.headerTo[c.GetHeader()] = i + } + return true +} + +func (f *frame) ToRows() ([]string, [][]string) { + f.mu.Lock() + defer f.mu.Unlock() + + headers := make([]string, len(f.headerTo)) + for k, v := range f.headerTo { + headers[v] = k + } + + var rowN int + for _, col := range f.columns { + n := col.RowNumber() + if rowN < n { + rowN = n + } + } + + rows := make([][]string, rowN) + colN := len(f.columns) + for rowIdx := 0; rowIdx < rowN; rowIdx++ { + row := make([]string, colN) + for colIdx, col := range f.columns { // rowIdx * colIdx + v, err := col.GetValue(rowIdx) + var elem string + if err == nil { + elem, _ = v.ToString() + } + row[colIdx] = elem + } + rows[rowIdx] = row + } + + return headers, rows +} + +func (f *frame) ToCSV(fpath string) error { + fi, err := os.OpenFile(fpath, os.O_RDWR|os.O_TRUNC, 0777) + if err != nil { + fi, err = os.Create(fpath) + if err != nil { + return err + } + } + defer fi.Close() + + wr := csv.NewWriter(fi) + + headers, rows := f.ToRows() + if err := wr.Write(headers); err != nil { + return err + } + if err := wr.WriteAll(rows); err != nil { + return err + } + + wr.Flush() + return wr.Error() +} + +// Sort sorts the data frame. +// TODO: use tree? +func (f *frame) Sort(header string, st SortType, so SortOption) error { + f.mu.Lock() + idx, ok := f.headerTo[header] + if !ok { + f.mu.Unlock() + return fmt.Errorf("%q does not exist", header) + } + f.mu.Unlock() + + var lesses []LessFunc + switch st { + case SortType_String: + switch so { + case SortOption_Ascending: + lesses = []LessFunc{StringAscendingFunc(idx)} + + case SortOption_Descending: + lesses = []LessFunc{StringDescendingFunc(idx)} + } + + case SortType_Number: + switch so { + case SortOption_Ascending: + lesses = []LessFunc{NumberAscendingFunc(idx)} + + case SortOption_Descending: + lesses = []LessFunc{NumberDescendingFunc(idx)} + } + + case SortType_Duration: + switch so { + case SortOption_Ascending: + lesses = []LessFunc{DurationAscendingFunc(idx)} + + case SortOption_Descending: + lesses = []LessFunc{DurationDescendingFunc(idx)} + } + } + + headers, rows := f.ToRows() + SortBy( + rows, + lesses..., + ).Sort(rows) + + nf, err := NewFromRows(headers, rows) + if err != nil { + return err + } + v, ok := nf.(*frame) + if !ok { + return fmt.Errorf("cannot type assert on frame") + } + *f = *v + return nil +} diff --git a/vendor/github.com/gyuho/dataframe/doc.go b/vendor/github.com/gyuho/dataframe/doc.go new file mode 100644 index 00000000..4113d87f --- /dev/null +++ b/vendor/github.com/gyuho/dataframe/doc.go @@ -0,0 +1,2 @@ +// Package dataframe implements data frame. +package dataframe // import "github.com/gyuho/dataframe" diff --git a/vendor/github.com/gyuho/dataframe/sorter.go b/vendor/github.com/gyuho/dataframe/sorter.go new file mode 100644 index 00000000..c3281b7b --- /dev/null +++ b/vendor/github.com/gyuho/dataframe/sorter.go @@ -0,0 +1,127 @@ +package dataframe + +import ( + "sort" + "strconv" + "time" +) + +type ( + SortType int + SortOption int +) + +const ( + SortType_String SortType = iota + SortType_Number + SortType_Duration +) + +const ( + SortOption_Ascending SortOption = iota + SortOption_Descending +) + +// SortBy returns a multiSorter that sorts using the less functions +func SortBy(rows [][]string, lesses ...LessFunc) *MultiSorter { + return &MultiSorter{ + data: rows, + less: lesses, + } +} + +// LessFunc compares between two string slices. +type LessFunc func(p1, p2 *[]string) bool + +func StringAscendingFunc(idx int) func(row1, row2 *[]string) bool { + return func(row1, row2 *[]string) bool { + return (*row1)[idx] < (*row2)[idx] + } +} + +func StringDescendingFunc(idx int) func(row1, row2 *[]string) bool { + return func(row1, row2 *[]string) bool { + return (*row1)[idx] > (*row2)[idx] + } +} + +func NumberAscendingFunc(idx int) func(row1, row2 *[]string) bool { + return func(row1, row2 *[]string) bool { + v1s := (*row1)[idx] + v1, _ := strconv.ParseFloat(v1s, 64) + v2s := (*row2)[idx] + v2, _ := strconv.ParseFloat(v2s, 64) + return v1 < v2 + } +} + +func NumberDescendingFunc(idx int) func(row1, row2 *[]string) bool { + return func(row1, row2 *[]string) bool { + v1s := (*row1)[idx] + v1, _ := strconv.ParseFloat(v1s, 64) + v2s := (*row2)[idx] + v2, _ := strconv.ParseFloat(v2s, 64) + return v1 > v2 + } +} + +func DurationAscendingFunc(idx int) func(row1, row2 *[]string) bool { + return func(row1, row2 *[]string) bool { + v1s := (*row1)[idx] + v1, _ := time.ParseDuration(v1s) + v2s := (*row2)[idx] + v2, _ := time.ParseDuration(v2s) + return v1 < v2 + } +} + +func DurationDescendingFunc(idx int) func(row1, row2 *[]string) bool { + return func(row1, row2 *[]string) bool { + v1s := (*row1)[idx] + v1, _ := time.ParseDuration(v1s) + v2s := (*row2)[idx] + v2, _ := time.ParseDuration(v2s) + return v1 > v2 + } +} + +// MultiSorter implements the Sort interface, +// sorting the two dimensional string slices within. +type MultiSorter struct { + data [][]string + less []LessFunc +} + +// Sort sorts the rows according to LessFunc. +func (ms *MultiSorter) Sort(rows [][]string) { + sort.Sort(ms) +} + +// Len is part of sort.Interface. +func (ms *MultiSorter) Len() int { + return len(ms.data) +} + +// Swap is part of sort.Interface. +func (ms *MultiSorter) Swap(i, j int) { + ms.data[i], ms.data[j] = ms.data[j], ms.data[i] +} + +// Less is part of sort.Interface. +func (ms *MultiSorter) Less(i, j int) bool { + p, q := &ms.data[i], &ms.data[j] + var k int + for k = 0; k < len(ms.less)-1; k++ { + less := ms.less[k] + switch { + case less(p, q): + // p < q + return true + case less(q, p): + // p > q + return false + } + // p == q; try next comparison + } + return ms.less[k](p, q) +} diff --git a/vendor/github.com/gyuho/dataframe/value.go b/vendor/github.com/gyuho/dataframe/value.go new file mode 100644 index 00000000..9d6a666a --- /dev/null +++ b/vendor/github.com/gyuho/dataframe/value.go @@ -0,0 +1,176 @@ +package dataframe + +import ( + "fmt" + "strconv" + "time" +) + +// Value represents the value in data frame. +type Value interface { + // ToString parses Value to string. It returns false if not possible. + ToString() (string, bool) + + // ToNumber parses Value to float64. It returns false if not possible. + ToNumber() (float64, bool) + + // ToTime parses Value to time.Time based on the layout. It returns false if not possible. + ToTime(layout string) (time.Time, bool) + + // ToDuration parses Value to time.Duration. It returns false if not possible. + ToDuration() (time.Duration, bool) + + // IsNil returns true if the Value is nil. + IsNil() bool + + // EqualTo returns true if the Value is equal to v. + EqualTo(v Value) bool +} + +func NewStringValue(v interface{}) Value { + switch t := v.(type) { + case string: + return String(t) + case int: + return String(strconv.FormatInt(int64(t), 10)) + case float64: + return String(strconv.FormatFloat(t, 'f', -1, 64)) + case time.Time: + return String(t.String()) + case time.Duration: + return String(t.String()) + default: + panic(fmt.Errorf("%v is not supported", v)) + } + return nil +} + +func NewStringValueNil() Value { + return String("") +} + +type String string + +func (s String) ToString() (string, bool) { + return string(s), true +} + +func (s String) ToNumber() (float64, bool) { + f, err := strconv.ParseFloat(string(s), 64) + return f, err == nil +} + +func (s String) ToTime(layout string) (time.Time, bool) { + t, err := time.Parse(layout, string(s)) + return t, err == nil +} + +func (s String) ToDuration() (time.Duration, bool) { + d, err := time.ParseDuration(string(s)) + return d, err == nil +} + +func (s String) IsNil() bool { + return len(s) == 0 +} + +func (s String) EqualTo(v Value) bool { + tv, ok := v.(String) + return ok && s == tv +} + +type ByStringAscending []Value + +func (vs ByStringAscending) Len() int { + return len(vs) +} + +func (vs ByStringAscending) Swap(i, j int) { + vs[i], vs[j] = vs[j], vs[i] +} + +func (vs ByStringAscending) Less(i, j int) bool { + vs1, _ := vs[i].ToString() + vs2, _ := vs[j].ToString() + return vs1 < vs2 +} + +type ByStringDescending []Value + +func (vs ByStringDescending) Len() int { + return len(vs) +} + +func (vs ByStringDescending) Swap(i, j int) { + vs[i], vs[j] = vs[j], vs[i] +} + +func (vs ByStringDescending) Less(i, j int) bool { + vs1, _ := vs[i].ToString() + vs2, _ := vs[j].ToString() + return vs1 > vs2 +} + +type ByNumberAscending []Value + +func (vs ByNumberAscending) Len() int { + return len(vs) +} + +func (vs ByNumberAscending) Swap(i, j int) { + vs[i], vs[j] = vs[j], vs[i] +} + +func (vs ByNumberAscending) Less(i, j int) bool { + vs1, _ := vs[i].ToNumber() + vs2, _ := vs[j].ToNumber() + return vs1 < vs2 +} + +type ByNumberDescending []Value + +func (vs ByNumberDescending) Len() int { + return len(vs) +} + +func (vs ByNumberDescending) Swap(i, j int) { + vs[i], vs[j] = vs[j], vs[i] +} + +func (vs ByNumberDescending) Less(i, j int) bool { + vs1, _ := vs[i].ToNumber() + vs2, _ := vs[j].ToNumber() + return vs1 > vs2 +} + +type ByDurationAscending []Value + +func (vs ByDurationAscending) Len() int { + return len(vs) +} + +func (vs ByDurationAscending) Swap(i, j int) { + vs[i], vs[j] = vs[j], vs[i] +} + +func (vs ByDurationAscending) Less(i, j int) bool { + vs1, _ := vs[i].ToDuration() + vs2, _ := vs[j].ToDuration() + return vs1 < vs2 +} + +type ByDurationDescending []Value + +func (vs ByDurationDescending) Len() int { + return len(vs) +} + +func (vs ByDurationDescending) Swap(i, j int) { + vs[i], vs[j] = vs[j], vs[i] +} + +func (vs ByDurationDescending) Less(i, j int) bool { + vs1, _ := vs[i].ToDuration() + vs2, _ := vs[j].ToDuration() + return vs1 > vs2 +} diff --git a/vendor/github.com/gyuho/psn/LICENSE b/vendor/github.com/gyuho/psn/LICENSE new file mode 100644 index 00000000..4b89d066 --- /dev/null +++ b/vendor/github.com/gyuho/psn/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2016 Gyu-Ho Lee + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/vendor/github.com/gyuho/psn/doc.go b/vendor/github.com/gyuho/psn/doc.go new file mode 100644 index 00000000..0640409f --- /dev/null +++ b/vendor/github.com/gyuho/psn/doc.go @@ -0,0 +1,2 @@ +// Package psn provides utilities to investigate OS processes and sockets. +package psn diff --git a/vendor/github.com/gyuho/psn/process/analysis_linux.go b/vendor/github.com/gyuho/psn/process/analysis_linux.go new file mode 100644 index 00000000..9ad6521e --- /dev/null +++ b/vendor/github.com/gyuho/psn/process/analysis_linux.go @@ -0,0 +1,304 @@ +package process + +import ( + "encoding/csv" + "fmt" + "math" + "os" + "strconv" + "strings" + + "github.com/dustin/go-humanize" +) + +// Table represents CSV tables. +type Table struct { + // Columns maps its column name to its column index. + Columns map[string]int + ColumnSlice []string + Rows [][]string + + MinTS int64 + MaxTS int64 +} + +var ( + ColumnsPS = make(map[string]int) +) + +func init() { + for i, v := range append([]string{"unix_ts"}, ProcessTableColumns...) { + ColumnsPS[v] = i + } +} + +// ReadCSV reads a csv file for ps csv file. +// It assumes the results from one single program. +func ReadCSV(columns map[string]int, fpath string) (Table, error) { + f, err := openToRead(fpath) + if err != nil { + return Table{}, err + } + defer f.Close() + + columnSlice := make([]string, len(columns)) + for k, v := range columns { + columnSlice[v] = k + } + + rd := csv.NewReader(f) + + // in case that rows have different number of fields + rd.FieldsPerRecord = -1 + + rows, err := rd.ReadAll() + if err != nil { + return Table{}, err + } + if len(rows) > 0 && len(rows[0]) > 0 { + if rows[0][0] == columnSlice[0] { + rows = rows[1:] + } + } + min, err := strconv.ParseInt(rows[0][0], 10, 64) + if err != nil { + return Table{}, err + } + max, err := strconv.ParseInt(rows[len(rows)-1][0], 10, 64) + if err != nil { + return Table{}, err + } + return Table{ + Columns: columns, + ColumnSlice: columnSlice, + Rows: rows, + MinTS: min, + MaxTS: max, + }, nil +} + +// ReadCSVs reads multiple csv files, including only unix timestamps, +// CPU usage, and VmRSS in MB. It assumes the results from one single program. +func ReadCSVs(columns map[string]int, fpaths ...string) (Table, error) { + tbs := []Table{} + var ( + minTS int64 = math.MaxInt64 + maxTS int64 = -1 + ) + for _, fpath := range fpaths { + tb, err := ReadCSV(columns, fpath) + if err != nil { + return Table{}, err + } + tbs = append(tbs, tb) + + if minTS > tb.MinTS { + minTS = tb.MinTS + } + if maxTS < tb.MaxTS { + maxTS = tb.MaxTS + } + } + + ntb := Table{} + ntb.MinTS = minTS + ntb.MaxTS = maxTS + ntb.Columns = make(map[string]int) + ntb.Columns["unix_tx"] = 0 + for i := range fpaths { + ntb.Columns[fmt.Sprintf("cpu_%d", i+1)] = 2*i + 1 + ntb.Columns[fmt.Sprintf("memory_mb_%d", i+1)] = 2*i + 2 + } + columnSlice := make([]string, len(ntb.Columns)) + for k, v := range ntb.Columns { + columnSlice[v] = k + } + ntb.ColumnSlice = columnSlice + + cIdx, mIdx := tbs[0].Columns["CpuUsageFloat64"], tbs[0].Columns["VmRSSBytes"] + + nrows := [][]string{} + for i, tb := range tbs { + if minTS < tb.MinTS { // need to fill in top rows + // push-front from minTS to tb.MinTS-1 + rows := make([][]string, tb.MinTS-minTS) + for i := range rows { + emptyRow := append([]string{fmt.Sprintf("%d", minTS+int64(i))}, strings.Split(strings.Repeat("0.00_", len(ProcessTableColumns)), "_")...) + rows[i] = emptyRow + } + tb.Rows = append(rows, tb.Rows...) + } + if maxTS > tb.MaxTS { // need to fill in bottom rows + // push-back from tb.MaxTS+1 to maxTS + rows := make([][]string, maxTS-tb.MaxTS) + for i := range rows { + emptyRow := append([]string{fmt.Sprintf("%d", tb.MaxTS+int64(i))}, strings.Split(strings.Repeat("0.00_", len(ProcessTableColumns)), "_")...) + rows[i] = emptyRow + } + tb.Rows = append(tb.Rows, rows...) + } + + if i == 0 { + for _, row := range tb.Rows { + if row[0] == tb.ColumnSlice[0] { + continue + } + mf, _ := strconv.ParseFloat(row[mIdx], 64) + nrows = append(nrows, []string{row[0], row[cIdx], fmt.Sprintf("%.2f", mf/(1000*1000))}) // memory usage in mega-bytes + } + } else { + for rowNum := range nrows { + trow := tb.Rows[rowNum] + if trow[0] == tb.ColumnSlice[0] { + continue + } + mf, _ := strconv.ParseFloat(trow[mIdx], 64) + nrows[rowNum] = append(nrows[rowNum], []string{trow[cIdx], fmt.Sprintf("%.2f", mf/(1000*1000))}...) + } + } + } + ntb.Rows = nrows + + return ntb, nil +} + +// ToRows returns rows from the table. +func (t Table) ToRows() [][]string { + return append([][]string{t.ColumnSlice}, t.Rows...) +} + +// ToCSV saves the table to csv file. +func (t Table) ToCSV(fpath string) error { + f, err := os.OpenFile(fpath, os.O_RDWR|os.O_TRUNC, 0777) + if err != nil { + f, err = os.Create(fpath) + if err != nil { + return err + } + } + defer f.Close() + + wr := csv.NewWriter(f) + + if err := wr.Write(t.ColumnSlice); err != nil { + return err + } + + if err := wr.WriteAll(t.Rows); err != nil { + return err + } + + wr.Flush() + return wr.Error() +} + +func ReadCSVFillIn(fpath string) (Table, error) { + tb, err := ReadCSV(ColumnsPS, fpath) + if err != nil { + return Table{}, err + } + var ( + uidx = tb.Columns["unix_ts"] + tsToRow = make(map[int64][]string) + ) + for _, row := range tb.Rows { + num, err := strconv.ParseInt(row[uidx], 10, 64) + if err != nil { + return Table{}, err + } + tsToRow[num] = row + } + + var nrows [][]string + for i := tb.MinTS; i < tb.MaxTS; i++ { + r, ok := tsToRow[i] + if !ok { + row, err := getEstimate(i, tb.MinTS, tb.MaxTS, tsToRow) + if err != nil { + return tb, err + } + tsToRow[i] = row + nrows = append(nrows, row) + continue + } + nrows = append(nrows, r) + } + tb.Rows = nrows + + return tb, nil +} + +// getEstimate estimates the row when ts does not exist in table. +func getEstimate(ts, min, max int64, tsToRow map[int64][]string) ([]string, error) { + // get the nearest lower value + var lower []string + for i := ts - 1; i >= min; i-- { + row, ok := tsToRow[i] + if !ok { + continue + } + lower = row + break + } + + // get the nearest upper value + var upper []string + for i := ts + 1; i <= max; i++ { + row, ok := tsToRow[i] + if !ok { + continue + } + upper = row + break + } + + nrow := make([]string, len(lower)) + copy(nrow, lower) + nrow[0] = fmt.Sprintf("%d", ts) + + lowerCPU, err := strconv.ParseFloat(lower[ColumnsPS["CpuUsageFloat64"]], 64) + if err != nil { + return nil, err + } + lowerVmRSS, err := strconv.ParseUint(lower[ColumnsPS["VmRSSBytes"]], 10, 64) + if err != nil { + return nil, err + } + lowerVmSize, err := strconv.ParseUint(lower[ColumnsPS["VmSizeBytes"]], 10, 64) + if err != nil { + return nil, err + } + + upperCPU, err := strconv.ParseFloat(upper[ColumnsPS["CpuUsageFloat64"]], 64) + if err != nil { + return nil, err + } + upperVmRSS, err := strconv.ParseUint(upper[ColumnsPS["VmRSSBytes"]], 10, 64) + if err != nil { + return nil, err + } + upperVmSize, err := strconv.ParseUint(upper[ColumnsPS["VmSizeBytes"]], 10, 64) + if err != nil { + return nil, err + } + + cpuUsageFloat64 := (lowerCPU + upperCPU) / float64(2) + cpu := fmt.Sprintf("%3.2f %%", cpuUsageFloat64) + + avgVmRSS := (lowerVmRSS + upperVmRSS) / 2 + vmRSS := humanize.Bytes(avgVmRSS) + + avgVmSize := (lowerVmSize + upperVmSize) / 2 + vmSize := humanize.Bytes(avgVmSize) + + nrow[ColumnsPS["CPU"]] = cpu + nrow[ColumnsPS["CpuUsageFloat64"]] = fmt.Sprintf("%3.2f", cpuUsageFloat64) + + nrow[ColumnsPS["VM_RSS"]] = vmRSS + nrow[ColumnsPS["VmRSSBytes"]] = fmt.Sprintf("%d", avgVmRSS) + + nrow[ColumnsPS["VM_SIZE"]] = vmSize + nrow[ColumnsPS["VmSizeBytes"]] = fmt.Sprintf("%d", avgVmSize) + + return nrow, nil +} diff --git a/vendor/github.com/gyuho/psn/process/doc.go b/vendor/github.com/gyuho/psn/process/doc.go new file mode 100644 index 00000000..e5d1919a --- /dev/null +++ b/vendor/github.com/gyuho/psn/process/doc.go @@ -0,0 +1,2 @@ +// Package process implements process utilities (Linux ps). +package process diff --git a/vendor/github.com/gyuho/psn/process/process_generate_schema_linux.go b/vendor/github.com/gyuho/psn/process/process_generate_schema_linux.go new file mode 100644 index 00000000..31e7e037 --- /dev/null +++ b/vendor/github.com/gyuho/psn/process/process_generate_schema_linux.go @@ -0,0 +1,136 @@ +package process + +import "reflect" + +// StatList represents the proc/$PID/stat file +// specification as documented in http://man7.org/linux/man-pages/man5/proc.5.html. +var StatList = [...]struct { + Col string + Kind reflect.Kind + Humanize bool // true if humanized string is needed +}{ + {"pid", reflect.Int64, false}, // the process ID + {"comm", reflect.String, false}, // filename of the executable (originally in parentheses, automatically removed by this package) + {"state", reflect.String, false}, // One character that represents the state of the process + {"ppid", reflect.Int64, false}, // PID of the parent of this process + {"pgrp", reflect.Int64, false}, // process group ID of the process + {"session", reflect.Int64, false}, + {"tty_nr", reflect.Int64, false}, + {"tpgid", reflect.Int64, false}, // ID of the foreground process group of the controlling terminal of the process + {"flags", reflect.Uint64, false}, + {"minflt", reflect.Uint64, false}, // number of minor faults the process has made which have not required loading a memory page from disk. + {"cminflt", reflect.Uint64, false}, // number of minor faults that the process's waited-for children have made. + {"majflt", reflect.Uint64, false}, // number of major faults the process has made which have required loading a memory page from disk. + {"cmajflt", reflect.Uint64, false}, // number of major faults that the process's waited-for children have made. + {"utime", reflect.Uint64, false}, // Amount of time that this process has been scheduled in user mode, measured in clock ticks. + {"stime", reflect.Uint64, false}, // Amount of time that this process has been scheduled in kernel mode, measured in clock ticks. + {"cutime", reflect.Uint64, false}, // Amount of time that this process's waited-for children have been scheduled in user mode. + {"cstime", reflect.Uint64, false}, // Amount of time that this process's waited-for children have been scheduled in kernel mode. + {"priority", reflect.Int64, false}, + {"nice", reflect.Int64, false}, + {"num_threads", reflect.Int64, false}, + {"itrealvalue", reflect.Int64, false}, + {"starttime", reflect.Uint64, false}, // time the process started after system boot. + {"vsize", reflect.Uint64, true}, // Virtual memory size in bytes. + {"rss", reflect.Int64, true}, // Resident Set Size: number of pages the process has in real memory. + {"rsslim", reflect.Uint64, true}, + {"startcode", reflect.Uint64, false}, + {"endcode", reflect.Uint64, false}, + {"startstack", reflect.Uint64, false}, + {"kstkesp", reflect.Uint64, false}, + {"kstkeip", reflect.Uint64, false}, + {"signal", reflect.Uint64, false}, + {"blocked", reflect.Uint64, false}, + {"sigignore", reflect.Uint64, false}, + {"sigcatch", reflect.Uint64, false}, + {"wchan", reflect.Uint64, false}, + {"nswap", reflect.Uint64, false}, + {"cnswap", reflect.Uint64, false}, + {"exit_signal", reflect.Int64, false}, + {"processor", reflect.Int64, false}, // CPU number last executed on. + {"rt_priority", reflect.Uint64, false}, + {"policy", reflect.Uint64, false}, + {"delayacct_blkio_ticks", reflect.Uint64, false}, + {"guest_time", reflect.Uint64, false}, + {"cguest_time", reflect.Int64, false}, + {"start_data", reflect.Uint64, false}, + {"end_data", reflect.Uint64, false}, + {"start_brk", reflect.Uint64, false}, + {"arg_start", reflect.Uint64, false}, + {"arg_end", reflect.Uint64, false}, + {"env_start", reflect.Uint64, false}, + {"env_end", reflect.Uint64, false}, + {"exit_code", reflect.Int64, false}, +} + +// StatusListYAML represents the proc/$PID/status file +// specification as documented in http://man7.org/linux/man-pages/man5/proc.5.html. +var StatusListYAML = [...]struct { + Col string + Kind reflect.Kind + Bytes bool // true if parsing humanized string in bytes is needed +}{ + {"Name", reflect.String, false}, // Name is the command run by this process. + + // State is Current state of the process. + // One of "R (running)", "S (sleeping)", "D (disk sleep)", + // "T (stopped)", "T (tracing stop)", "Z (zombie)", or "X (dead)". + {"State", reflect.String, false}, + + {"Tgid", reflect.Int64, false}, // Tgid is thread group ID. + {"Ngid", reflect.Int64, false}, + {"Pid", reflect.Int64, false}, // Pid is process ID. + {"PPid", reflect.Int64, false}, // PPid is parent process ID, which launches the Pid. + {"TracerPid", reflect.Int64, false}, // TracerPid is PID of process tracing this process (0 if not being traced). + + {"Uid", reflect.String, false}, + {"Gid", reflect.String, false}, + + {"FDSize", reflect.Uint64, false}, // FDSize is the number of file descriptor slots currently allocated. + + {"Groups", reflect.String, false}, // Groups is supplementary group list. + + {"VmPeak", reflect.String, true}, // VmPeak is peak virtual memory usage. Vm includes physical memory and swap. + {"VmSize", reflect.String, true}, // VmSize is current virtual memory usage. VmSize is the total amount of memory required for this process. + {"VmLck", reflect.String, true}, // VmLck is current mlocked memory. + {"VmPin", reflect.String, true}, // VmPin is pinned memory size. + {"VmHWM", reflect.String, true}, // VmHWM is peak resident set size ("high water mark"). + + // VmRSS is resident set size. VmRSS is the actual + // amount in memory. Some memory can be swapped out + // to physical disk. So this is the real memory usage + // of the process. + {"VmRSS", reflect.String, true}, + + {"VmData", reflect.String, true}, // VmRSS is size of data segment. + + {"VmStk", reflect.String, true}, // VmStk is size of stack. + {"VmExe", reflect.String, true}, // VmExe is size of text segment. + {"VmLib", reflect.String, true}, // VmLib is shared library usage. + {"VmPMD", reflect.String, true}, + {"VmPTE", reflect.String, true}, // VmPTE is page table entries size. + {"VmSwap", reflect.String, true}, // VmSwap is swap space used. + + {"Threads", reflect.Uint64, false}, // Threads is the number of threads in process containing this thread (process). + + {"SigQ", reflect.String, false}, + {"SigPnd", reflect.String, false}, + {"ShdPnd", reflect.String, false}, + {"SigBlk", reflect.String, false}, + {"SigIgn", reflect.String, false}, + {"SigCgt", reflect.String, false}, + {"CapInh", reflect.String, false}, + {"CapPrm", reflect.String, false}, + {"CapEff", reflect.String, false}, + {"CapBnd", reflect.String, false}, + {"CapAmb", reflect.String, false}, + {"Seccomp", reflect.Uint64, false}, + + {"Cpus_allowed", reflect.String, false}, + {"Cpus_allowed_list", reflect.String, false}, + {"Mems_allowed", reflect.String, false}, + {"Mems_allowed_list", reflect.String, false}, + + {"voluntary_ctxt_switches", reflect.Uint64, false}, + {"nonvoluntary_ctxt_switches", reflect.Uint64, false}, +} diff --git a/vendor/github.com/gyuho/psn/process/process_generated_linux.go b/vendor/github.com/gyuho/psn/process/process_generated_linux.go new file mode 100644 index 00000000..c34875fd --- /dev/null +++ b/vendor/github.com/gyuho/psn/process/process_generated_linux.go @@ -0,0 +1,129 @@ +package process + +// updated at 2016-03-19 11:09:30.73210258 -0700 PDT + +// Process represents '/proc' in linux. +type Process struct { + Stat Stat + Status Status +} + +// Stat is 'proc/$PID/stat' in linux. +type Stat struct { + Pid int64 `column:"pid"` + Comm string `column:"comm"` + State string `column:"state"` + Ppid int64 `column:"ppid"` + Pgrp int64 `column:"pgrp"` + Session int64 `column:"session"` + TtyNr int64 `column:"tty_nr"` + Tpgid int64 `column:"tpgid"` + Flags uint64 `column:"flags"` + Minflt uint64 `column:"minflt"` + Cminflt uint64 `column:"cminflt"` + Majflt uint64 `column:"majflt"` + Cmajflt uint64 `column:"cmajflt"` + Utime uint64 `column:"utime"` + Stime uint64 `column:"stime"` + Cutime uint64 `column:"cutime"` + Cstime uint64 `column:"cstime"` + Priority int64 `column:"priority"` + Nice int64 `column:"nice"` + NumThreads int64 `column:"num_threads"` + Itrealvalue int64 `column:"itrealvalue"` + Starttime uint64 `column:"starttime"` + Vsize uint64 `column:"vsize"` + VsizeHumanize string `column:"vsize_humanized"` + Rss int64 `column:"rss"` + RssHumanize string `column:"rss_humanized"` + Rsslim uint64 `column:"rsslim"` + RsslimHumanize string `column:"rsslim_humanized"` + Startcode uint64 `column:"startcode"` + Endcode uint64 `column:"endcode"` + Startstack uint64 `column:"startstack"` + Kstkesp uint64 `column:"kstkesp"` + Kstkeip uint64 `column:"kstkeip"` + Signal uint64 `column:"signal"` + Blocked uint64 `column:"blocked"` + Sigignore uint64 `column:"sigignore"` + Sigcatch uint64 `column:"sigcatch"` + Wchan uint64 `column:"wchan"` + Nswap uint64 `column:"nswap"` + Cnswap uint64 `column:"cnswap"` + ExitSignal int64 `column:"exit_signal"` + Processor int64 `column:"processor"` + RtPriority uint64 `column:"rt_priority"` + Policy uint64 `column:"policy"` + DelayacctBlkioTicks uint64 `column:"delayacct_blkio_ticks"` + GuestTime uint64 `column:"guest_time"` + CguestTime int64 `column:"cguest_time"` + StartData uint64 `column:"start_data"` + EndData uint64 `column:"end_data"` + StartBrk uint64 `column:"start_brk"` + ArgStart uint64 `column:"arg_start"` + ArgEnd uint64 `column:"arg_end"` + EnvStart uint64 `column:"env_start"` + EnvEnd uint64 `column:"env_end"` + ExitCode int64 `column:"exit_code"` + CpuUsage float64 `column:"cpu_usage"` +} + +// Status is 'proc/$PID/status' in linux. +type Status struct { + Name string `yaml:"Name"` + State string `yaml:"State"` + Tgid int64 `yaml:"Tgid"` + Ngid int64 `yaml:"Ngid"` + Pid int64 `yaml:"Pid"` + PPid int64 `yaml:"PPid"` + TracerPid int64 `yaml:"TracerPid"` + Uid string `yaml:"Uid"` + Gid string `yaml:"Gid"` + FDSize uint64 `yaml:"FDSize"` + Groups string `yaml:"Groups"` + VmPeak string `yaml:"VmPeak"` + VmPeakBytes uint64 `yaml:"VmPeak_bytes"` + VmSize string `yaml:"VmSize"` + VmSizeBytes uint64 `yaml:"VmSize_bytes"` + VmLck string `yaml:"VmLck"` + VmLckBytes uint64 `yaml:"VmLck_bytes"` + VmPin string `yaml:"VmPin"` + VmPinBytes uint64 `yaml:"VmPin_bytes"` + VmHWM string `yaml:"VmHWM"` + VmHWMBytes uint64 `yaml:"VmHWM_bytes"` + VmRSS string `yaml:"VmRSS"` + VmRSSBytes uint64 `yaml:"VmRSS_bytes"` + VmData string `yaml:"VmData"` + VmDataBytes uint64 `yaml:"VmData_bytes"` + VmStk string `yaml:"VmStk"` + VmStkBytes uint64 `yaml:"VmStk_bytes"` + VmExe string `yaml:"VmExe"` + VmExeBytes uint64 `yaml:"VmExe_bytes"` + VmLib string `yaml:"VmLib"` + VmLibBytes uint64 `yaml:"VmLib_bytes"` + VmPMD string `yaml:"VmPMD"` + VmPMDBytes uint64 `yaml:"VmPMD_bytes"` + VmPTE string `yaml:"VmPTE"` + VmPTEBytes uint64 `yaml:"VmPTE_bytes"` + VmSwap string `yaml:"VmSwap"` + VmSwapBytes uint64 `yaml:"VmSwap_bytes"` + Threads uint64 `yaml:"Threads"` + SigQ string `yaml:"SigQ"` + SigPnd string `yaml:"SigPnd"` + ShdPnd string `yaml:"ShdPnd"` + SigBlk string `yaml:"SigBlk"` + SigIgn string `yaml:"SigIgn"` + SigCgt string `yaml:"SigCgt"` + CapInh string `yaml:"CapInh"` + CapPrm string `yaml:"CapPrm"` + CapEff string `yaml:"CapEff"` + CapBnd string `yaml:"CapBnd"` + CapAmb string `yaml:"CapAmb"` + Seccomp uint64 `yaml:"Seccomp"` + CpusAllowed string `yaml:"Cpus_allowed"` + CpusAllowedList string `yaml:"Cpus_allowed_list"` + MemsAllowed string `yaml:"Mems_allowed"` + MemsAllowedList string `yaml:"Mems_allowed_list"` + VoluntaryCtxtSwitches uint64 `yaml:"voluntary_ctxt_switches"` + NonvoluntaryCtxtSwitches uint64 `yaml:"nonvoluntary_ctxt_switches"` +} diff --git a/vendor/github.com/gyuho/psn/process/process_linux.go b/vendor/github.com/gyuho/psn/process/process_linux.go new file mode 100644 index 00000000..fa07452c --- /dev/null +++ b/vendor/github.com/gyuho/psn/process/process_linux.go @@ -0,0 +1,362 @@ +package process + +import ( + "encoding/csv" + "fmt" + "io" + "io/ioutil" + "os" + "os/exec" + "sort" + "strconv" + "strings" + "sync" + "syscall" + "time" + + "github.com/gyuho/dataframe" + "github.com/olekukonko/tablewriter" +) + +// ProcessTableColumns is columns for CSV file. +var ProcessTableColumns = []string{ + "NAME", + "STATE", + + "PID", + "PPID", + + "CPU", + "VM_RSS", + "VM_SIZE", + + "FD", + "THREADS", + + "CpuUsageFloat64", + "VmRSSBytes", + "VmSizeBytes", +} + +// List finds the status by specifying the filter. +func List(filter *Process) ([]Process, error) { + if filter != nil { + if filter.Stat.Pid != 0 && filter.Status.Pid == 0 { + filter.Status.Pid = filter.Stat.Pid + } + if filter.Stat.Pid == 0 && filter.Status.Pid != 0 { + filter.Stat.Pid = filter.Status.Pid + } + } + if filter != nil && filter.Stat.Pid != 0 && filter.Status.Pid != 0 { // no need to scan all 'proc' + stat, err := GetStat(filter.Stat.Pid) + if err != nil { + return nil, err + } + status, err := GetStatus(filter.Status.Pid) + if err != nil { + return nil, err + } + return []Process{Process{Stat: stat, Status: status}}, err + } + + // scan all 'proc's + ds, err := ioutil.ReadDir("/proc") + if err != nil { + return nil, err + } + pids := []int64{} + for _, f := range ds { + if f.IsDir() && isInt(f.Name()) { + i, err := strconv.ParseInt(f.Name(), 10, 64) + if err != nil { + return nil, err + } + pids = append(pids, i) + } + } + + donec, errc := make(chan struct{}), make(chan error) + rmap := make(map[int64]Process) + var mu sync.Mutex + + for _, pid := range pids { + go func(pid int64, filter *Process) { + stat, err := GetStat(pid) + if err != nil { + errc <- err + return + } + status, err := GetStatus(pid) + if err != nil { + errc <- err + return + } + if stat.Match(filter) && status.Match(filter) { + mu.Lock() + rmap[pid] = Process{Stat: stat, Status: status} + mu.Unlock() + } + donec <- struct{}{} + }(pid, filter) + } + + cnt := 0 + for cnt != len(pids) { + select { + case <-donec: + cnt++ + case e := <-errc: + return nil, e + } + } + + rs := []Process{} + for _, proc := range rmap { + if proc.Stat.Comm == "" && proc.Status.Name != "" { + proc.Stat.Comm = proc.Status.Name + } + if proc.Stat.Comm != "" && proc.Status.Name == "" { + proc.Status.Name = proc.Stat.Comm + } + if proc.Stat.Pid == 0 && proc.Status.Pid != 0 { + proc.Stat.Pid = proc.Status.Pid + } + if proc.Stat.Pid != 0 && proc.Status.Pid == 0 { + proc.Status.Pid = proc.Stat.Pid + } + rs = append(rs, proc) + } + return rs, nil +} + +// Match matches Stat to filter. Only supports name and PID. +func (s *Stat) Match(filter *Process) bool { + if s == nil { + return false + } + if filter == nil { + return true // no need to compare + } + name := filter.Stat.Comm + if name != "" { + if name != s.Comm { + return false + } + } + pid := filter.Stat.Pid + if pid != 0 { + if pid != s.Pid { + return false + } + } + state := filter.Stat.State + if state != "" { + if state != s.State { + return false + } + } + return true +} + +// Match matches Status to filter. Only supports name and PID. +func (s *Status) Match(filter *Process) bool { + if s == nil { + return false + } + if filter == nil { + return true // no need to compare + } + name := filter.Status.Name + if name != "" { + if name != s.Name { + return false + } + } + pid := filter.Status.Pid + if pid != 0 { + if pid != s.Pid { + return false + } + } + state := filter.Status.State + if state != "" { + if state != s.State { + return false + } + } + return true +} + +// WriteToTable writes slice of Process to ASCII table. +func WriteToTable(w io.Writer, top int, pss ...Process) { + tw := tablewriter.NewWriter(w) + tw.SetHeader(ProcessTableColumns[:9:9]) + + rows := make([][]string, len(pss)) + for i, s := range pss { + sl := make([]string, len(ProcessTableColumns)) + sl[0] = s.Status.Name + sl[1] = s.Status.State + sl[2] = fmt.Sprintf("%d", s.Status.Pid) + sl[3] = fmt.Sprintf("%d", s.Status.PPid) + sl[4] = fmt.Sprintf("%3.2f %%", s.Stat.CpuUsage) + sl[5] = s.Status.VmRSS + sl[6] = s.Status.VmSize + sl[7] = fmt.Sprintf("%d", s.Status.FDSize) + sl[8] = fmt.Sprintf("%d", s.Status.Threads) + + sl[9] = fmt.Sprintf("%3.2f", s.Stat.CpuUsage) + sl[10] = fmt.Sprintf("%d", s.Status.VmRSSBytes) + sl[11] = fmt.Sprintf("%d", s.Status.VmSizeBytes) + rows[i] = sl + } + dataframe.SortBy( + rows, + dataframe.NumberDescendingFunc(10), // VM_RSS + dataframe.NumberDescendingFunc(9), // CPU + dataframe.NumberDescendingFunc(11), // VM_SIZE + ).Sort(rows) + + if top != 0 && len(rows) > top { + rows = rows[:top:top] + } + for _, row := range rows { + tw.Append(row[:9:9]) + } + + tw.Render() +} + +var once sync.Once + +// WriteToTable writes slice of Process to a csv file. +func WriteToCSV(f *os.File, pss ...Process) error { + wr := csv.NewWriter(f) + + var werr error + writeCSVHeader := func() { + if err := wr.Write(append([]string{"unix_ts"}, ProcessTableColumns...)); err != nil { + werr = err + } + } + once.Do(writeCSVHeader) + if werr != nil { + return werr + } + + rows := make([][]string, len(pss)) + for i, s := range pss { + sl := make([]string, len(ProcessTableColumns)) + sl[0] = s.Status.Name + sl[1] = s.Status.State + sl[2] = fmt.Sprintf("%d", s.Status.Pid) + sl[3] = fmt.Sprintf("%d", s.Status.PPid) + sl[4] = fmt.Sprintf("%3.2f %%", s.Stat.CpuUsage) + sl[5] = s.Status.VmRSS + sl[6] = s.Status.VmSize + sl[7] = fmt.Sprintf("%d", s.Status.FDSize) + sl[8] = fmt.Sprintf("%d", s.Status.Threads) + + sl[9] = fmt.Sprintf("%3.2f", s.Stat.CpuUsage) + sl[10] = fmt.Sprintf("%d", s.Status.VmRSSBytes) + sl[11] = fmt.Sprintf("%d", s.Status.VmSizeBytes) + rows[i] = sl + } + dataframe.SortBy( + rows, + dataframe.NumberDescendingFunc(10), // VM_RSS + dataframe.NumberDescendingFunc(9), // CPU + dataframe.NumberDescendingFunc(11), // VM_SIZE + ).Sort(rows) + + ts := fmt.Sprintf("%d", time.Now().Unix()) + nrows := make([][]string, len(rows)) + for i, row := range rows { + nrows[i] = append([]string{ts}, row...) + } + if err := wr.WriteAll(nrows); err != nil { + return err + } + + wr.Flush() + return wr.Error() +} + +type int64Slice []int64 + +func (s int64Slice) Len() int { return len(s) } +func (s int64Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s int64Slice) Less(i, j int) bool { return s[i] < s[j] } + +// Kill kills all processes in arguments. +func Kill(w io.Writer, parent bool, pss ...Process) { + defer func() { + if err := recover(); err != nil { + fmt.Fprintln(w, "Kill:", err) + } + }() + + pidToKill := make(map[int64]string) + for _, s := range pss { + pidToKill[s.Status.Pid] = s.Status.Name + if parent && s.Status.PPid != 0 { + pidToKill[s.Status.PPid] = s.Status.Name + } + } + if len(pidToKill) == 0 { + fmt.Fprintln(w, "no PID to kill...") + return + } + + pids := []int64{} + for pid := range pidToKill { + pids = append(pids, pid) + } + sort.Sort(int64Slice(pids)) + + for _, pid := range pids { + fmt.Fprintf(w, "\nsyscall.Kill: %s [PID: %d]\n", pidToKill[pid], pid) + if err := syscall.Kill(int(pid), syscall.SIGTERM); err != nil { + fmt.Fprintf(w, "syscall.SIGTERM error (%v)\n", err) + + shell := os.Getenv("SHELL") + if len(shell) == 0 { + shell = "sh" + } + args := []string{shell, "-c", fmt.Sprintf("sudo kill -9 %d", pid)} + cmd := exec.Command(args[0], args[1:]...) + cmd.Stdout = w + cmd.Stderr = w + fmt.Fprintf(w, "Starting: %q\n", strings.Join(cmd.Args, "")) + if err := cmd.Start(); err != nil { + fmt.Fprintf(w, "error when 'sudo kill -9' (%v)\n", err) + } + if err := cmd.Wait(); err != nil { + fmt.Fprintf(w, "Start(%s) cmd.Wait returned %v\n", cmd.Path, err) + } + fmt.Fprintf(w, " Done: %q\n", strings.Join(cmd.Args, "")) + } + if err := syscall.Kill(int(pid), syscall.SIGKILL); err != nil { + fmt.Fprintf(w, "syscall.SIGKILL error (%v)\n", err) + + shell := os.Getenv("SHELL") + if len(shell) == 0 { + shell = "sh" + } + args := []string{shell, "-c", fmt.Sprintf("sudo kill -9 %d", pid)} + cmd := exec.Command(args[0], args[1:]...) + cmd.Stdout = w + cmd.Stderr = w + fmt.Fprintf(w, "Starting: %q\n", strings.Join(cmd.Args, "")) + if err := cmd.Start(); err != nil { + fmt.Fprintf(w, "error when 'sudo kill -9' (%v)\n", err) + } + if err := cmd.Wait(); err != nil { + fmt.Fprintf(w, "Start(%s) cmd.Wait returned %v\n", cmd.Path, err) + } + fmt.Fprintf(w, " Done: %q\n", strings.Join(cmd.Args, "")) + } + } + fmt.Fprintln(w) +} diff --git a/vendor/github.com/gyuho/psn/process/stat_linux.go b/vendor/github.com/gyuho/psn/process/stat_linux.go new file mode 100644 index 00000000..4ed8322e --- /dev/null +++ b/vendor/github.com/gyuho/psn/process/stat_linux.go @@ -0,0 +1,262 @@ +package process + +import ( + "bufio" + "bytes" + "fmt" + "html/template" + "io/ioutil" + "log" + "os/exec" + "reflect" + "strconv" + "strings" + "time" + + "github.com/dustin/go-humanize" +) + +// GetStat reads /proc/$PID/stat data. +func GetStat(pid int64) (Stat, error) { + var ( + s Stat + err error + ) + for i := 0; i < 3; i++ { + s, err = getStat(pid) + if err == nil { + return s, nil + } else { + log.Println(err) + } + time.Sleep(5 * time.Millisecond) + } + return s, err +} + +func getStat(pid int64) (Stat, error) { + fpath := fmt.Sprintf("/proc/%d/stat", pid) + f, err := openToRead(fpath) + if err != nil { + return Stat{}, err + } + defer f.Close() + + scanner := bufio.NewScanner(f) + st := &Stat{} + for scanner.Scan() { + txt := scanner.Text() + if len(txt) == 0 { + continue + } + + fds := strings.Fields(txt) + for i, fv := range fds { + column := ToField(StatList[i].Col) + s := reflect.ValueOf(st).Elem() + if s.Kind() == reflect.Struct { + f := s.FieldByName(column) + if f.IsValid() { + if f.CanSet() { + switch StatList[i].Kind { + case reflect.Uint64: + value, err := strconv.ParseUint(fv, 10, 64) + if err != nil { + return Stat{}, fmt.Errorf("%v when parsing %s %v", err, column, fv) + } + if !f.OverflowUint(value) { + f.SetUint(value) + if StatList[i].Humanize { + hF := s.FieldByName(column + "Humanize") + if hF.IsValid() { + if hF.CanSet() { + hF.SetString(humanize.Bytes(value)) + } + } + } + } + case reflect.Int64: + value, err := strconv.ParseInt(fv, 10, 64) + if err != nil { + return Stat{}, fmt.Errorf("%v when parsing %s %v", err, column, fv) + } + if !f.OverflowInt(value) { + f.SetInt(value) + if StatList[i].Humanize { + hF := s.FieldByName(column + "Humanize") + if hF.IsValid() { + if hF.CanSet() { + if value > 0 { + hF.SetString(humanize.Bytes(uint64(value))) + } + } + } + } + } + case reflect.String: + f.SetString(fv) + } + } + } + } + } + } + if err := scanner.Err(); err != nil { + return Stat{}, err + } + return st.update() +} + +func (s *Stat) update() (Stat, error) { + if s == nil { + return Stat{}, nil + } + if strings.HasPrefix(s.Comm, "(") { + s.Comm = s.Comm[1:] + } + if strings.HasSuffix(s.Comm, ")") { + s.Comm = s.Comm[:len(s.Comm)-1] + } + cu, err := s.getCpuUsage() + if err != nil { + return Stat{}, err + } + s.CpuUsage = cu + return *s, nil +} + +// getCpuUsage returns the average CPU usage in percentage. +// http://stackoverflow.com/questions/16726779/how-do-i-get-the-total-cpu-usage-of-an-application-from-proc-pid-stat +func (s Stat) getCpuUsage() (float64, error) { + totalSec := s.Utime + s.Stime + totalSec += s.Cutime + s.Cstime + + out, err := exec.Command("/usr/bin/getconf", "CLK_TCK").Output() + if err != nil { + return 0, err + } + ot := strings.TrimSpace(strings.Replace(string(out), "\n", "", -1)) + hertz, err := strconv.ParseUint(ot, 10, 64) + if err != nil || hertz == 0 { + return 0, err + } + + u, err := GetUptime() + if err != nil { + return 0, err + } + tookSec := u.UptimeTotal - (float64(s.Starttime) / float64(hertz)) + if hertz == 0 || tookSec == 0.0 { + return 0.0, nil + } + return 100 * ((float64(totalSec) / float64(hertz)) / float64(tookSec)), nil +} + +// Uptime describes /proc/uptime. +type Uptime struct { + UptimeTotal float64 + UptimeIdle float64 +} + +// GetUptime reads /proc/uptime. +func GetUptime() (Uptime, error) { + f, err := ioutil.ReadFile("/proc/uptime") + if err != nil { + return Uptime{}, err + } + fields := strings.Fields(strings.TrimSpace(string(f))) + u := Uptime{} + if len(fields) > 0 { + v, err := strconv.ParseFloat(fields[0], 64) + if err != nil { + return Uptime{}, err + } + u.UptimeTotal = v + } + if len(fields) > 1 { + v, err := strconv.ParseFloat(fields[1], 64) + if err != nil { + return Uptime{}, err + } + u.UptimeIdle = v + } + return u, nil +} + +const statTmpl = ` +---------------------------------------- +[/proc/{{.Pid}}/stat] + +Name: {{.Comm}} +State: {{.State}} + +Pid: {{.Pid}} +Ppid: {{.Ppid}} +NumThreads: {{.NumThreads}} + +Rss: {{.RssHumanize}} ({{.Rss}}) +Rsslim: {{.RsslimHumanize}} ({{.Rsslim}}) +Vsize: {{.VsizeHumanize}} ({{.Vsize}}) +CpuUsage: {{.CpuUsage}} % + +Starttime: {{.Starttime}} +Utime: {{.Utime}} +Stime: {{.Stime}} +Cutime: {{.Cutime}} +Cstime: {{.Cstime}} + +Session: {{.Session}} +TtyNr: {{.TtyNr}} +Tpgid: {{.Tpgid}} +Flags: {{.Flags}} + +minflt: {{.Minflt}} +cminflt: {{.Cminflt}} +majflt: {{.Majflt}} +cmajflt: {{.Cmajflt}} + +priority: {{.Priority}} +nice: {{.Nice}} +itrealvalue: {{.Itrealvalue}} + +startcode: {{.Startcode}} +endcode: {{.Endcode}} +startstack: {{.Startstack}} +lstkesp: {{.Kstkesp}} +lstkeip: {{.Kstkeip}} +signal: {{.Signal}} +blocked: {{.Blocked}} +sigignore: {{.Sigignore}} +sigcatch: {{.Sigcatch}} +wchan: {{.Wchan}} +nswap: {{.Nswap}} +cnswap: {{.Cnswap}} +exitSignal: {{.ExitSignal}} +processor: {{.Processor}} +rt_priority: {{.RtPriority}} +policy: {{.Policy}} + +delayacct_blkio_ticks: +{{.DelayacctBlkioTicks}} + +guest_time: {{.GuestTime}} +cguest_time: {{.CguestTime}} +start_data: {{.StartData}} +end_data: {{.EndData}} +start_brk: {{.StartBrk}} +arg_start: {{.ArgStart}} +arg_end: {{.ArgEnd}} +env_start: {{.EnvStart}} +env_end: {{.EnvEnd}} +exit_code: {{.ExitCode}} +---------------------------------------- +` + +func (s Stat) String() string { + tpl := template.Must(template.New("statTmpl").Parse(statTmpl)) + buf := new(bytes.Buffer) + if err := tpl.Execute(buf, s); err != nil { + log.Fatal(err) + } + return buf.String() +} diff --git a/vendor/github.com/gyuho/psn/process/status_linux.go b/vendor/github.com/gyuho/psn/process/status_linux.go new file mode 100644 index 00000000..23a59d9f --- /dev/null +++ b/vendor/github.com/gyuho/psn/process/status_linux.go @@ -0,0 +1,157 @@ +package process + +import ( + "bytes" + "fmt" + "io/ioutil" + "log" + "text/template" + "time" + + "github.com/dustin/go-humanize" + "gopkg.in/yaml.v2" +) + +// GetStatus reads /proc/$PID/status data. +func GetStatus(pid int64) (Status, error) { + var ( + s Status + err error + ) + for i := 0; i < 3; i++ { + s, err = getStatus(pid) + if err == nil { + return s, nil + } else { + log.Println(err) + } + time.Sleep(5 * time.Millisecond) + } + return s, err +} + +func getStatus(pid int64) (Status, error) { + fpath := fmt.Sprintf("/proc/%d/status", pid) + f, err := openToRead(fpath) + if err != nil { + return Status{}, err + } + defer f.Close() + + b, err := ioutil.ReadAll(f) + if err != nil { + return Status{}, err + } + rs := Status{} + if err := yaml.Unmarshal(b, &rs); err != nil { + return Status{}, err + } + u, _ := humanize.ParseBytes(rs.VmPeak) + rs.VmPeak = humanize.Bytes(u) + rs.VmPeakBytes = u + u, _ = humanize.ParseBytes(rs.VmSize) + rs.VmSize = humanize.Bytes(u) + rs.VmSizeBytes = u + u, _ = humanize.ParseBytes(rs.VmLck) + rs.VmLck = humanize.Bytes(u) + rs.VmLckBytes = u + u, _ = humanize.ParseBytes(rs.VmPin) + rs.VmPin = humanize.Bytes(u) + rs.VmPinBytes = u + u, _ = humanize.ParseBytes(rs.VmHWM) + rs.VmHWM = humanize.Bytes(u) + rs.VmHWMBytes = u + u, _ = humanize.ParseBytes(rs.VmRSS) + rs.VmRSS = humanize.Bytes(u) + rs.VmRSSBytes = u + u, _ = humanize.ParseBytes(rs.VmData) + rs.VmData = humanize.Bytes(u) + rs.VmDataBytes = u + u, _ = humanize.ParseBytes(rs.VmStk) + rs.VmStk = humanize.Bytes(u) + rs.VmStkBytes = u + u, _ = humanize.ParseBytes(rs.VmExe) + rs.VmExe = humanize.Bytes(u) + rs.VmExeBytes = u + u, _ = humanize.ParseBytes(rs.VmLib) + rs.VmLib = humanize.Bytes(u) + rs.VmLibBytes = u + u, _ = humanize.ParseBytes(rs.VmPTE) + rs.VmPTE = humanize.Bytes(u) + rs.VmPTEBytes = u + u, _ = humanize.ParseBytes(rs.VmSwap) + rs.VmSwap = humanize.Bytes(u) + rs.VmSwapBytes = u + + return rs, nil +} + +const statusTmpl = ` +---------------------------------------- +[/proc/{{.Pid}}/status] + +Name: {{.Name}} +State: {{.State}} + +Tgid: {{.Tgid}} +Ngid: {{.Ngid}} +Pid: {{.Pid}} +PPid: {{.PPid}} +TracerPid: {{.TracerPid}} + +FDSize: {{.FDSize}} + +VmPeak: {{.VmPeak}} +VmSize: {{.VmSize}} +VmLck: {{.VmLck}} +VmPin: {{.VmPin}} +VmHWM: {{.VmHWM}} +VmRSS: {{.VmRSS}} +VmData: {{.VmData}} +VmStk: {{.VmStk}} +VmExe: {{.VmExe}} +VmLib: {{.VmLib}} +VmPTE: {{.VmPTE}} +VmSwap: {{.VmSwap}} + +Threads: {{.Threads}} + +Groups: {{.Groups}} +Uid: {{.Uid}} +Gid: {{.Gid}} + +SigQ: {{.SigQ}} +SigPnd: {{.SigPnd}} +ShdPnd: {{.ShdPnd}} +SigBlk: {{.SigBlk}} +SigIgn: {{.SigIgn}} +SigCgt: {{.SigCgt}} +CapInh: {{.CapInh}} +CapPrm: {{.CapPrm}} +CapEff: {{.CapEff}} +CapBnd: {{.CapBnd}} + +Seccomp: {{.Seccomp}} + +Cpus_allowed: {{.CpusAllowed}} +Cpus_allowed_list: {{.CpusAllowedList}} + +Mems_allowed: {{.MemsAllowed}} +Mems_allowed_list: {{.MemsAllowedList}} + +voluntary_ctxt_switches: +{{.VoluntaryCtxtSwitches}} + +nonvoluntary_ctxt_switches: +{{.NonvoluntaryCtxtSwitches}} +---------------------------------------- +` + +func (s Status) String() string { + tpl := template.Must(template.New("statusTmpl").Parse(statusTmpl)) + buf := new(bytes.Buffer) + if err := tpl.Execute(buf, s); err != nil { + log.Fatal(err) + } + return buf.String() +} diff --git a/vendor/github.com/gyuho/psn/process/util.go b/vendor/github.com/gyuho/psn/process/util.go new file mode 100644 index 00000000..3a143453 --- /dev/null +++ b/vendor/github.com/gyuho/psn/process/util.go @@ -0,0 +1,55 @@ +package process + +import ( + "os" + "strconv" + "strings" +) + +func isInt(s string) bool { + _, err := strconv.Atoi(s) + return err == nil +} + +const ( + // privateFileMode grants owner to read/write a file. + privateFileMode = 0600 + + // privateDirMode grants owner to make/remove files inside the directory. + privateDirMode = 0700 +) + +func openToRead(fpath string) (*os.File, error) { + f, err := os.OpenFile(fpath, os.O_RDONLY, privateFileMode) + if err != nil { + return nil, err + } + return f, nil +} + +func openToAppend(fpath string) (*os.File, error) { + f, err := os.OpenFile(fpath, os.O_RDWR|os.O_APPEND|os.O_CREATE, privateFileMode) + if err != nil { + return nil, err + } + return f, nil +} + +func openToOverwrite(fpath string) (*os.File, error) { + f, err := os.OpenFile(fpath, os.O_RDWR|os.O_TRUNC|os.O_CREATE, privateFileMode) + if err != nil { + return nil, err + } + return f, nil +} + +func ToField(s string) string { + cs := strings.Split(s, "_") + var ss []string + for _, v := range cs { + if len(v) > 0 { + ss = append(ss, strings.Title(v)) + } + } + return strings.TrimSpace(strings.Join(ss, "")) +} diff --git a/vendor/github.com/hashicorp/consul/LICENSE b/vendor/github.com/hashicorp/consul/LICENSE new file mode 100644 index 00000000..c33dcc7c --- /dev/null +++ b/vendor/github.com/hashicorp/consul/LICENSE @@ -0,0 +1,354 @@ +Mozilla Public License, version 2.0 + +1. Definitions + +1.1. “Contributor” + + means each individual or legal entity that creates, contributes to the + creation of, or owns Covered Software. + +1.2. “Contributor Version” + + means the combination of the Contributions of others (if any) used by a + Contributor and that particular Contributor’s Contribution. + +1.3. “Contribution” + + means Covered Software of a particular Contributor. + +1.4. “Covered Software” + + means Source Code Form to which the initial Contributor has attached the + notice in Exhibit A, the Executable Form of such Source Code Form, and + Modifications of such Source Code Form, in each case including portions + thereof. + +1.5. “Incompatible With Secondary Licenses” + means + + a. that the initial Contributor has attached the notice described in + Exhibit B to the Covered Software; or + + b. that the Covered Software was made available under the terms of version + 1.1 or earlier of the License, but not also under the terms of a + Secondary License. + +1.6. “Executable Form” + + means any form of the work other than Source Code Form. + +1.7. “Larger Work” + + means a work that combines Covered Software with other material, in a separate + file or files, that is not Covered Software. + +1.8. “License” + + means this document. + +1.9. “Licensable” + + means having the right to grant, to the maximum extent possible, whether at the + time of the initial grant or subsequently, any and all of the rights conveyed by + this License. + +1.10. “Modifications” + + means any of the following: + + a. any file in Source Code Form that results from an addition to, deletion + from, or modification of the contents of Covered Software; or + + b. any new file in Source Code Form that contains any Covered Software. + +1.11. “Patent Claims” of a Contributor + + means any patent claim(s), including without limitation, method, process, + and apparatus claims, in any patent Licensable by such Contributor that + would be infringed, but for the grant of the License, by the making, + using, selling, offering for sale, having made, import, or transfer of + either its Contributions or its Contributor Version. + +1.12. “Secondary License” + + means either the GNU General Public License, Version 2.0, the GNU Lesser + General Public License, Version 2.1, the GNU Affero General Public + License, Version 3.0, or any later versions of those licenses. + +1.13. “Source Code Form” + + means the form of the work preferred for making modifications. + +1.14. “You” (or “Your”) + + means an individual or a legal entity exercising rights under this + License. For legal entities, “You” includes any entity that controls, is + controlled by, or is under common control with You. For purposes of this + definition, “control” means (a) the power, direct or indirect, to cause + the direction or management of such entity, whether by contract or + otherwise, or (b) ownership of more than fifty percent (50%) of the + outstanding shares or beneficial ownership of such entity. + + +2. License Grants and Conditions + +2.1. Grants + + Each Contributor hereby grants You a world-wide, royalty-free, + non-exclusive license: + + a. under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or as + part of a Larger Work; and + + b. under Patent Claims of such Contributor to make, use, sell, offer for + sale, have made, import, and otherwise transfer either its Contributions + or its Contributor Version. + +2.2. Effective Date + + The licenses granted in Section 2.1 with respect to any Contribution become + effective for each Contribution on the date the Contributor first distributes + such Contribution. + +2.3. Limitations on Grant Scope + + The licenses granted in this Section 2 are the only rights granted under this + License. No additional rights or licenses will be implied from the distribution + or licensing of Covered Software under this License. Notwithstanding Section + 2.1(b) above, no patent license is granted by a Contributor: + + a. for any code that a Contributor has removed from Covered Software; or + + b. for infringements caused by: (i) Your and any other third party’s + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + + c. under Patent Claims infringed by Covered Software in the absence of its + Contributions. + + This License does not grant any rights in the trademarks, service marks, or + logos of any Contributor (except as may be necessary to comply with the + notice requirements in Section 3.4). + +2.4. Subsequent Licenses + + No Contributor makes additional grants as a result of Your choice to + distribute the Covered Software under a subsequent version of this License + (see Section 10.2) or under the terms of a Secondary License (if permitted + under the terms of Section 3.3). + +2.5. Representation + + Each Contributor represents that the Contributor believes its Contributions + are its original creation(s) or it has sufficient rights to grant the + rights to its Contributions conveyed by this License. + +2.6. Fair Use + + This License is not intended to limit any rights You have under applicable + copyright doctrines of fair use, fair dealing, or other equivalents. + +2.7. Conditions + + Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in + Section 2.1. + + +3. Responsibilities + +3.1. Distribution of Source Form + + All distribution of Covered Software in Source Code Form, including any + Modifications that You create or to which You contribute, must be under the + terms of this License. You must inform recipients that the Source Code Form + of the Covered Software is governed by the terms of this License, and how + they can obtain a copy of this License. You may not attempt to alter or + restrict the recipients’ rights in the Source Code Form. + +3.2. Distribution of Executable Form + + If You distribute Covered Software in Executable Form then: + + a. such Covered Software must also be made available in Source Code Form, + as described in Section 3.1, and You must inform recipients of the + Executable Form how they can obtain a copy of such Source Code Form by + reasonable means in a timely manner, at a charge no more than the cost + of distribution to the recipient; and + + b. You may distribute such Executable Form under the terms of this License, + or sublicense it under different terms, provided that the license for + the Executable Form does not attempt to limit or alter the recipients’ + rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + + You may create and distribute a Larger Work under terms of Your choice, + provided that You also comply with the requirements of this License for the + Covered Software. If the Larger Work is a combination of Covered Software + with a work governed by one or more Secondary Licenses, and the Covered + Software is not Incompatible With Secondary Licenses, this License permits + You to additionally distribute such Covered Software under the terms of + such Secondary License(s), so that the recipient of the Larger Work may, at + their option, further distribute the Covered Software under the terms of + either this License or such Secondary License(s). + +3.4. Notices + + You may not remove or alter the substance of any license notices (including + copyright notices, patent notices, disclaimers of warranty, or limitations + of liability) contained within the Source Code Form of the Covered + Software, except that You may alter any license notices to the extent + required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + + You may choose to offer, and to charge a fee for, warranty, support, + indemnity or liability obligations to one or more recipients of Covered + Software. However, You may do so only on Your own behalf, and not on behalf + of any Contributor. You must make it absolutely clear that any such + warranty, support, indemnity, or liability obligation is offered by You + alone, and You hereby agree to indemnify every Contributor for any + liability incurred by such Contributor as a result of warranty, support, + indemnity or liability terms You offer. You may include additional + disclaimers of warranty and limitations of liability specific to any + jurisdiction. + +4. Inability to Comply Due to Statute or Regulation + + If it is impossible for You to comply with any of the terms of this License + with respect to some or all of the Covered Software due to statute, judicial + order, or regulation then You must: (a) comply with the terms of this License + to the maximum extent possible; and (b) describe the limitations and the code + they affect. Such description must be placed in a text file included with all + distributions of the Covered Software under this License. Except to the + extent prohibited by statute or regulation, such description must be + sufficiently detailed for a recipient of ordinary skill to be able to + understand it. + +5. Termination + +5.1. The rights granted under this License will terminate automatically if You + fail to comply with any of its terms. However, if You become compliant, + then the rights granted under this License from a particular Contributor + are reinstated (a) provisionally, unless and until such Contributor + explicitly and finally terminates Your grants, and (b) on an ongoing basis, + if such Contributor fails to notify You of the non-compliance by some + reasonable means prior to 60 days after You have come back into compliance. + Moreover, Your grants from a particular Contributor are reinstated on an + ongoing basis if such Contributor notifies You of the non-compliance by + some reasonable means, this is the first time You have received notice of + non-compliance with this License from such Contributor, and You become + compliant prior to 30 days after Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent + infringement claim (excluding declaratory judgment actions, counter-claims, + and cross-claims) alleging that a Contributor Version directly or + indirectly infringes any patent, then the rights granted to You by any and + all Contributors for the Covered Software under Section 2.1 of this License + shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user + license agreements (excluding distributors and resellers) which have been + validly granted by You or Your distributors under this License prior to + termination shall survive termination. + +6. Disclaimer of Warranty + + Covered Software is provided under this License on an “as is” basis, without + warranty of any kind, either expressed, implied, or statutory, including, + without limitation, warranties that the Covered Software is free of defects, + merchantable, fit for a particular purpose or non-infringing. The entire + risk as to the quality and performance of the Covered Software is with You. + Should any Covered Software prove defective in any respect, You (not any + Contributor) assume the cost of any necessary servicing, repair, or + correction. This disclaimer of warranty constitutes an essential part of this + License. No use of any Covered Software is authorized under this License + except under this disclaimer. + +7. Limitation of Liability + + Under no circumstances and under no legal theory, whether tort (including + negligence), contract, or otherwise, shall any Contributor, or anyone who + distributes Covered Software as permitted above, be liable to You for any + direct, indirect, special, incidental, or consequential damages of any + character including, without limitation, damages for lost profits, loss of + goodwill, work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses, even if such party shall have been + informed of the possibility of such damages. This limitation of liability + shall not apply to liability for death or personal injury resulting from such + party’s negligence to the extent applicable law prohibits such limitation. + Some jurisdictions do not allow the exclusion or limitation of incidental or + consequential damages, so this exclusion and limitation may not apply to You. + +8. Litigation + + Any litigation relating to this License may be brought only in the courts of + a jurisdiction where the defendant maintains its principal place of business + and such litigation shall be governed by laws of that jurisdiction, without + reference to its conflict-of-law provisions. Nothing in this Section shall + prevent a party’s ability to bring cross-claims or counter-claims. + +9. Miscellaneous + + This License represents the complete agreement concerning the subject matter + hereof. If any provision of this License is held to be unenforceable, such + provision shall be reformed only to the extent necessary to make it + enforceable. Any law or regulation which provides that the language of a + contract shall be construed against the drafter shall not be used to construe + this License against a Contributor. + + +10. Versions of the License + +10.1. New Versions + + Mozilla Foundation is the license steward. Except as provided in Section + 10.3, no one other than the license steward has the right to modify or + publish new versions of this License. Each version will be given a + distinguishing version number. + +10.2. Effect of New Versions + + You may distribute the Covered Software under the terms of the version of + the License under which You originally received the Covered Software, or + under the terms of any subsequent version published by the license + steward. + +10.3. Modified Versions + + If you create software not governed by this License, and you want to + create a new license for such software, you may create and use a modified + version of this License if you rename the license and remove any + references to the name of the license steward (except to note that such + modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses + If You choose to distribute Source Code Form that is Incompatible With + Secondary Licenses under the terms of this version of the License, the + notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice + + This Source Code Form is subject to the + terms of the Mozilla Public License, v. + 2.0. If a copy of the MPL was not + distributed with this file, You can + obtain one at + http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular file, then +You may include the notice in a location (such as a LICENSE file in a relevant +directory) where a recipient would be likely to look for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - “Incompatible With Secondary Licenses” Notice + + This Source Code Form is “Incompatible + With Secondary Licenses”, as defined by + the Mozilla Public License, v. 2.0. + diff --git a/vendor/github.com/hashicorp/consul/api/acl.go b/vendor/github.com/hashicorp/consul/api/acl.go new file mode 100644 index 00000000..c3fb0d53 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/acl.go @@ -0,0 +1,140 @@ +package api + +const ( + // ACLCLientType is the client type token + ACLClientType = "client" + + // ACLManagementType is the management type token + ACLManagementType = "management" +) + +// ACLEntry is used to represent an ACL entry +type ACLEntry struct { + CreateIndex uint64 + ModifyIndex uint64 + ID string + Name string + Type string + Rules string +} + +// ACL can be used to query the ACL endpoints +type ACL struct { + c *Client +} + +// ACL returns a handle to the ACL endpoints +func (c *Client) ACL() *ACL { + return &ACL{c} +} + +// Create is used to generate a new token with the given parameters +func (a *ACL) Create(acl *ACLEntry, q *WriteOptions) (string, *WriteMeta, error) { + r := a.c.newRequest("PUT", "/v1/acl/create") + r.setWriteOptions(q) + r.obj = acl + rtt, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return "", nil, err + } + defer resp.Body.Close() + + wm := &WriteMeta{RequestTime: rtt} + var out struct{ ID string } + if err := decodeBody(resp, &out); err != nil { + return "", nil, err + } + return out.ID, wm, nil +} + +// Update is used to update the rules of an existing token +func (a *ACL) Update(acl *ACLEntry, q *WriteOptions) (*WriteMeta, error) { + r := a.c.newRequest("PUT", "/v1/acl/update") + r.setWriteOptions(q) + r.obj = acl + rtt, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + wm := &WriteMeta{RequestTime: rtt} + return wm, nil +} + +// Destroy is used to destroy a given ACL token ID +func (a *ACL) Destroy(id string, q *WriteOptions) (*WriteMeta, error) { + r := a.c.newRequest("PUT", "/v1/acl/destroy/"+id) + r.setWriteOptions(q) + rtt, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return nil, err + } + resp.Body.Close() + + wm := &WriteMeta{RequestTime: rtt} + return wm, nil +} + +// Clone is used to return a new token cloned from an existing one +func (a *ACL) Clone(id string, q *WriteOptions) (string, *WriteMeta, error) { + r := a.c.newRequest("PUT", "/v1/acl/clone/"+id) + r.setWriteOptions(q) + rtt, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return "", nil, err + } + defer resp.Body.Close() + + wm := &WriteMeta{RequestTime: rtt} + var out struct{ ID string } + if err := decodeBody(resp, &out); err != nil { + return "", nil, err + } + return out.ID, wm, nil +} + +// Info is used to query for information about an ACL token +func (a *ACL) Info(id string, q *QueryOptions) (*ACLEntry, *QueryMeta, error) { + r := a.c.newRequest("GET", "/v1/acl/info/"+id) + r.setQueryOptions(q) + rtt, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var entries []*ACLEntry + if err := decodeBody(resp, &entries); err != nil { + return nil, nil, err + } + if len(entries) > 0 { + return entries[0], qm, nil + } + return nil, qm, nil +} + +// List is used to get all the ACL tokens +func (a *ACL) List(q *QueryOptions) ([]*ACLEntry, *QueryMeta, error) { + r := a.c.newRequest("GET", "/v1/acl/list") + r.setQueryOptions(q) + rtt, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var entries []*ACLEntry + if err := decodeBody(resp, &entries); err != nil { + return nil, nil, err + } + return entries, qm, nil +} diff --git a/vendor/github.com/hashicorp/consul/api/agent.go b/vendor/github.com/hashicorp/consul/api/agent.go new file mode 100644 index 00000000..87a6c100 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/agent.go @@ -0,0 +1,411 @@ +package api + +import ( + "fmt" +) + +// AgentCheck represents a check known to the agent +type AgentCheck struct { + Node string + CheckID string + Name string + Status string + Notes string + Output string + ServiceID string + ServiceName string +} + +// AgentService represents a service known to the agent +type AgentService struct { + ID string + Service string + Tags []string + Port int + Address string + EnableTagOverride bool +} + +// AgentMember represents a cluster member known to the agent +type AgentMember struct { + Name string + Addr string + Port uint16 + Tags map[string]string + Status int + ProtocolMin uint8 + ProtocolMax uint8 + ProtocolCur uint8 + DelegateMin uint8 + DelegateMax uint8 + DelegateCur uint8 +} + +// AgentServiceRegistration is used to register a new service +type AgentServiceRegistration struct { + ID string `json:",omitempty"` + Name string `json:",omitempty"` + Tags []string `json:",omitempty"` + Port int `json:",omitempty"` + Address string `json:",omitempty"` + EnableTagOverride bool `json:",omitempty"` + Check *AgentServiceCheck + Checks AgentServiceChecks +} + +// AgentCheckRegistration is used to register a new check +type AgentCheckRegistration struct { + ID string `json:",omitempty"` + Name string `json:",omitempty"` + Notes string `json:",omitempty"` + ServiceID string `json:",omitempty"` + AgentServiceCheck +} + +// AgentServiceCheck is used to define a node or service level check +type AgentServiceCheck struct { + Script string `json:",omitempty"` + DockerContainerID string `json:",omitempty"` + Shell string `json:",omitempty"` // Only supported for Docker. + Interval string `json:",omitempty"` + Timeout string `json:",omitempty"` + TTL string `json:",omitempty"` + HTTP string `json:",omitempty"` + TCP string `json:",omitempty"` + Status string `json:",omitempty"` + + // In Consul 0.7 and later, checks that are associated with a service + // may also contain this optional DeregisterCriticalServiceAfter field, + // which is a timeout in the same Go time format as Interval and TTL. If + // a check is in the critical state for more than this configured value, + // then its associated service (and all of its associated checks) will + // automatically be deregistered. + DeregisterCriticalServiceAfter string `json:",omitempty"` +} +type AgentServiceChecks []*AgentServiceCheck + +// Agent can be used to query the Agent endpoints +type Agent struct { + c *Client + + // cache the node name + nodeName string +} + +// Agent returns a handle to the agent endpoints +func (c *Client) Agent() *Agent { + return &Agent{c: c} +} + +// Self is used to query the agent we are speaking to for +// information about itself +func (a *Agent) Self() (map[string]map[string]interface{}, error) { + r := a.c.newRequest("GET", "/v1/agent/self") + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + var out map[string]map[string]interface{} + if err := decodeBody(resp, &out); err != nil { + return nil, err + } + return out, nil +} + +// NodeName is used to get the node name of the agent +func (a *Agent) NodeName() (string, error) { + if a.nodeName != "" { + return a.nodeName, nil + } + info, err := a.Self() + if err != nil { + return "", err + } + name := info["Config"]["NodeName"].(string) + a.nodeName = name + return name, nil +} + +// Checks returns the locally registered checks +func (a *Agent) Checks() (map[string]*AgentCheck, error) { + r := a.c.newRequest("GET", "/v1/agent/checks") + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + var out map[string]*AgentCheck + if err := decodeBody(resp, &out); err != nil { + return nil, err + } + return out, nil +} + +// Services returns the locally registered services +func (a *Agent) Services() (map[string]*AgentService, error) { + r := a.c.newRequest("GET", "/v1/agent/services") + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + var out map[string]*AgentService + if err := decodeBody(resp, &out); err != nil { + return nil, err + } + return out, nil +} + +// Members returns the known gossip members. The WAN +// flag can be used to query a server for WAN members. +func (a *Agent) Members(wan bool) ([]*AgentMember, error) { + r := a.c.newRequest("GET", "/v1/agent/members") + if wan { + r.params.Set("wan", "1") + } + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + var out []*AgentMember + if err := decodeBody(resp, &out); err != nil { + return nil, err + } + return out, nil +} + +// ServiceRegister is used to register a new service with +// the local agent +func (a *Agent) ServiceRegister(service *AgentServiceRegistration) error { + r := a.c.newRequest("PUT", "/v1/agent/service/register") + r.obj = service + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// ServiceDeregister is used to deregister a service with +// the local agent +func (a *Agent) ServiceDeregister(serviceID string) error { + r := a.c.newRequest("PUT", "/v1/agent/service/deregister/"+serviceID) + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// PassTTL is used to set a TTL check to the passing state. +// +// DEPRECATION NOTICE: This interface is deprecated in favor of UpdateTTL(). +// The client interface will be removed in 0.8 or changed to use +// UpdateTTL()'s endpoint and the server endpoints will be removed in 0.9. +func (a *Agent) PassTTL(checkID, note string) error { + return a.updateTTL(checkID, note, "pass") +} + +// WarnTTL is used to set a TTL check to the warning state. +// +// DEPRECATION NOTICE: This interface is deprecated in favor of UpdateTTL(). +// The client interface will be removed in 0.8 or changed to use +// UpdateTTL()'s endpoint and the server endpoints will be removed in 0.9. +func (a *Agent) WarnTTL(checkID, note string) error { + return a.updateTTL(checkID, note, "warn") +} + +// FailTTL is used to set a TTL check to the failing state. +// +// DEPRECATION NOTICE: This interface is deprecated in favor of UpdateTTL(). +// The client interface will be removed in 0.8 or changed to use +// UpdateTTL()'s endpoint and the server endpoints will be removed in 0.9. +func (a *Agent) FailTTL(checkID, note string) error { + return a.updateTTL(checkID, note, "fail") +} + +// updateTTL is used to update the TTL of a check. This is the internal +// method that uses the old API that's present in Consul versions prior to +// 0.6.4. Since Consul didn't have an analogous "update" API before it seemed +// ok to break this (former) UpdateTTL in favor of the new UpdateTTL below, +// but keep the old Pass/Warn/Fail methods using the old API under the hood. +// +// DEPRECATION NOTICE: This interface is deprecated in favor of UpdateTTL(). +// The client interface will be removed in 0.8 and the server endpoints will +// be removed in 0.9. +func (a *Agent) updateTTL(checkID, note, status string) error { + switch status { + case "pass": + case "warn": + case "fail": + default: + return fmt.Errorf("Invalid status: %s", status) + } + endpoint := fmt.Sprintf("/v1/agent/check/%s/%s", status, checkID) + r := a.c.newRequest("PUT", endpoint) + r.params.Set("note", note) + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// checkUpdate is the payload for a PUT for a check update. +type checkUpdate struct { + // Status is one of the api.Health* states: HealthPassing + // ("passing"), HealthWarning ("warning"), or HealthCritical + // ("critical"). + Status string + + // Output is the information to post to the UI for operators as the + // output of the process that decided to hit the TTL check. This is + // different from the note field that's associated with the check + // itself. + Output string +} + +// UpdateTTL is used to update the TTL of a check. This uses the newer API +// that was introduced in Consul 0.6.4 and later. We translate the old status +// strings for compatibility (though a newer version of Consul will still be +// required to use this API). +func (a *Agent) UpdateTTL(checkID, output, status string) error { + switch status { + case "pass", HealthPassing: + status = HealthPassing + case "warn", HealthWarning: + status = HealthWarning + case "fail", HealthCritical: + status = HealthCritical + default: + return fmt.Errorf("Invalid status: %s", status) + } + + endpoint := fmt.Sprintf("/v1/agent/check/update/%s", checkID) + r := a.c.newRequest("PUT", endpoint) + r.obj = &checkUpdate{ + Status: status, + Output: output, + } + + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// CheckRegister is used to register a new check with +// the local agent +func (a *Agent) CheckRegister(check *AgentCheckRegistration) error { + r := a.c.newRequest("PUT", "/v1/agent/check/register") + r.obj = check + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// CheckDeregister is used to deregister a check with +// the local agent +func (a *Agent) CheckDeregister(checkID string) error { + r := a.c.newRequest("PUT", "/v1/agent/check/deregister/"+checkID) + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// Join is used to instruct the agent to attempt a join to +// another cluster member +func (a *Agent) Join(addr string, wan bool) error { + r := a.c.newRequest("PUT", "/v1/agent/join/"+addr) + if wan { + r.params.Set("wan", "1") + } + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// ForceLeave is used to have the agent eject a failed node +func (a *Agent) ForceLeave(node string) error { + r := a.c.newRequest("PUT", "/v1/agent/force-leave/"+node) + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// EnableServiceMaintenance toggles service maintenance mode on +// for the given service ID. +func (a *Agent) EnableServiceMaintenance(serviceID, reason string) error { + r := a.c.newRequest("PUT", "/v1/agent/service/maintenance/"+serviceID) + r.params.Set("enable", "true") + r.params.Set("reason", reason) + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// DisableServiceMaintenance toggles service maintenance mode off +// for the given service ID. +func (a *Agent) DisableServiceMaintenance(serviceID string) error { + r := a.c.newRequest("PUT", "/v1/agent/service/maintenance/"+serviceID) + r.params.Set("enable", "false") + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// EnableNodeMaintenance toggles node maintenance mode on for the +// agent we are connected to. +func (a *Agent) EnableNodeMaintenance(reason string) error { + r := a.c.newRequest("PUT", "/v1/agent/maintenance") + r.params.Set("enable", "true") + r.params.Set("reason", reason) + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} + +// DisableNodeMaintenance toggles node maintenance mode off for the +// agent we are connected to. +func (a *Agent) DisableNodeMaintenance() error { + r := a.c.newRequest("PUT", "/v1/agent/maintenance") + r.params.Set("enable", "false") + _, resp, err := requireOK(a.c.doRequest(r)) + if err != nil { + return err + } + resp.Body.Close() + return nil +} diff --git a/vendor/github.com/hashicorp/consul/api/api.go b/vendor/github.com/hashicorp/consul/api/api.go new file mode 100644 index 00000000..dd811fde --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/api.go @@ -0,0 +1,591 @@ +package api + +import ( + "bytes" + "crypto/tls" + "crypto/x509" + "encoding/json" + "fmt" + "io" + "io/ioutil" + "log" + "net" + "net/http" + "net/url" + "os" + "strconv" + "strings" + "time" + + "github.com/hashicorp/go-cleanhttp" +) + +// QueryOptions are used to parameterize a query +type QueryOptions struct { + // Providing a datacenter overwrites the DC provided + // by the Config + Datacenter string + + // AllowStale allows any Consul server (non-leader) to service + // a read. This allows for lower latency and higher throughput + AllowStale bool + + // RequireConsistent forces the read to be fully consistent. + // This is more expensive but prevents ever performing a stale + // read. + RequireConsistent bool + + // WaitIndex is used to enable a blocking query. Waits + // until the timeout or the next index is reached + WaitIndex uint64 + + // WaitTime is used to bound the duration of a wait. + // Defaults to that of the Config, but can be overridden. + WaitTime time.Duration + + // Token is used to provide a per-request ACL token + // which overrides the agent's default token. + Token string + + // Near is used to provide a node name that will sort the results + // in ascending order based on the estimated round trip time from + // that node. Setting this to "_agent" will use the agent's node + // for the sort. + Near string +} + +// WriteOptions are used to parameterize a write +type WriteOptions struct { + // Providing a datacenter overwrites the DC provided + // by the Config + Datacenter string + + // Token is used to provide a per-request ACL token + // which overrides the agent's default token. + Token string +} + +// QueryMeta is used to return meta data about a query +type QueryMeta struct { + // LastIndex. This can be used as a WaitIndex to perform + // a blocking query + LastIndex uint64 + + // Time of last contact from the leader for the + // server servicing the request + LastContact time.Duration + + // Is there a known leader + KnownLeader bool + + // How long did the request take + RequestTime time.Duration + + // Is address translation enabled for HTTP responses on this agent + AddressTranslationEnabled bool +} + +// WriteMeta is used to return meta data about a write +type WriteMeta struct { + // How long did the request take + RequestTime time.Duration +} + +// HttpBasicAuth is used to authenticate http client with HTTP Basic Authentication +type HttpBasicAuth struct { + // Username to use for HTTP Basic Authentication + Username string + + // Password to use for HTTP Basic Authentication + Password string +} + +// Config is used to configure the creation of a client +type Config struct { + // Address is the address of the Consul server + Address string + + // Scheme is the URI scheme for the Consul server + Scheme string + + // Datacenter to use. If not provided, the default agent datacenter is used. + Datacenter string + + // HttpClient is the client to use. Default will be + // used if not provided. + HttpClient *http.Client + + // HttpAuth is the auth info to use for http access. + HttpAuth *HttpBasicAuth + + // WaitTime limits how long a Watch will block. If not provided, + // the agent default values will be used. + WaitTime time.Duration + + // Token is used to provide a per-request ACL token + // which overrides the agent's default token. + Token string +} + +// TLSConfig is used to generate a TLSClientConfig that's useful for talking to +// Consul using TLS. +type TLSConfig struct { + // Address is the optional address of the Consul server. The port, if any + // will be removed from here and this will be set to the ServerName of the + // resulting config. + Address string + + // CAFile is the optional path to the CA certificate used for Consul + // communication, defaults to the system bundle if not specified. + CAFile string + + // CertFile is the optional path to the certificate for Consul + // communication. If this is set then you need to also set KeyFile. + CertFile string + + // KeyFile is the optional path to the private key for Consul communication. + // If this is set then you need to also set CertFile. + KeyFile string + + // InsecureSkipVerify if set to true will disable TLS host verification. + InsecureSkipVerify bool +} + +// DefaultConfig returns a default configuration for the client. By default this +// will pool and reuse idle connections to Consul. If you have a long-lived +// client object, this is the desired behavior and should make the most efficient +// use of the connections to Consul. If you don't reuse a client object , which +// is not recommended, then you may notice idle connections building up over +// time. To avoid this, use the DefaultNonPooledConfig() instead. +func DefaultConfig() *Config { + return defaultConfig(cleanhttp.DefaultPooledTransport) +} + +// DefaultNonPooledConfig returns a default configuration for the client which +// does not pool connections. This isn't a recommended configuration because it +// will reconnect to Consul on every request, but this is useful to avoid the +// accumulation of idle connections if you make many client objects during the +// lifetime of your application. +func DefaultNonPooledConfig() *Config { + return defaultConfig(cleanhttp.DefaultTransport) +} + +// defaultConfig returns the default configuration for the client, using the +// given function to make the transport. +func defaultConfig(transportFn func() *http.Transport) *Config { + config := &Config{ + Address: "127.0.0.1:8500", + Scheme: "http", + HttpClient: &http.Client{ + Transport: transportFn(), + }, + } + + if addr := os.Getenv("CONSUL_HTTP_ADDR"); addr != "" { + config.Address = addr + } + + if token := os.Getenv("CONSUL_HTTP_TOKEN"); token != "" { + config.Token = token + } + + if auth := os.Getenv("CONSUL_HTTP_AUTH"); auth != "" { + var username, password string + if strings.Contains(auth, ":") { + split := strings.SplitN(auth, ":", 2) + username = split[0] + password = split[1] + } else { + username = auth + } + + config.HttpAuth = &HttpBasicAuth{ + Username: username, + Password: password, + } + } + + if ssl := os.Getenv("CONSUL_HTTP_SSL"); ssl != "" { + enabled, err := strconv.ParseBool(ssl) + if err != nil { + log.Printf("[WARN] client: could not parse CONSUL_HTTP_SSL: %s", err) + } + + if enabled { + config.Scheme = "https" + } + } + + if verify := os.Getenv("CONSUL_HTTP_SSL_VERIFY"); verify != "" { + doVerify, err := strconv.ParseBool(verify) + if err != nil { + log.Printf("[WARN] client: could not parse CONSUL_HTTP_SSL_VERIFY: %s", err) + } + + if !doVerify { + tlsClientConfig, err := SetupTLSConfig(&TLSConfig{ + InsecureSkipVerify: true, + }) + + // We don't expect this to fail given that we aren't + // parsing any of the input, but we panic just in case + // since this doesn't have an error return. + if err != nil { + panic(err) + } + + transport := transportFn() + transport.TLSClientConfig = tlsClientConfig + config.HttpClient.Transport = transport + } + } + + return config +} + +// TLSConfig is used to generate a TLSClientConfig that's useful for talking to +// Consul using TLS. +func SetupTLSConfig(tlsConfig *TLSConfig) (*tls.Config, error) { + tlsClientConfig := &tls.Config{ + InsecureSkipVerify: tlsConfig.InsecureSkipVerify, + } + + if tlsConfig.Address != "" { + server := tlsConfig.Address + hasPort := strings.LastIndex(server, ":") > strings.LastIndex(server, "]") + if hasPort { + var err error + server, _, err = net.SplitHostPort(server) + if err != nil { + return nil, err + } + } + tlsClientConfig.ServerName = server + } + + if tlsConfig.CertFile != "" && tlsConfig.KeyFile != "" { + tlsCert, err := tls.LoadX509KeyPair(tlsConfig.CertFile, tlsConfig.KeyFile) + if err != nil { + return nil, err + } + tlsClientConfig.Certificates = []tls.Certificate{tlsCert} + } + + if tlsConfig.CAFile != "" { + data, err := ioutil.ReadFile(tlsConfig.CAFile) + if err != nil { + return nil, fmt.Errorf("failed to read CA file: %v", err) + } + + caPool := x509.NewCertPool() + if !caPool.AppendCertsFromPEM(data) { + return nil, fmt.Errorf("failed to parse CA certificate") + } + tlsClientConfig.RootCAs = caPool + } + + return tlsClientConfig, nil +} + +// Client provides a client to the Consul API +type Client struct { + config Config +} + +// NewClient returns a new client +func NewClient(config *Config) (*Client, error) { + // bootstrap the config + defConfig := DefaultConfig() + + if len(config.Address) == 0 { + config.Address = defConfig.Address + } + + if len(config.Scheme) == 0 { + config.Scheme = defConfig.Scheme + } + + if config.HttpClient == nil { + config.HttpClient = defConfig.HttpClient + } + + if parts := strings.SplitN(config.Address, "unix://", 2); len(parts) == 2 { + trans := cleanhttp.DefaultTransport() + trans.Dial = func(_, _ string) (net.Conn, error) { + return net.Dial("unix", parts[1]) + } + config.HttpClient = &http.Client{ + Transport: trans, + } + config.Address = parts[1] + } + + client := &Client{ + config: *config, + } + return client, nil +} + +// request is used to help build up a request +type request struct { + config *Config + method string + url *url.URL + params url.Values + body io.Reader + header http.Header + obj interface{} +} + +// setQueryOptions is used to annotate the request with +// additional query options +func (r *request) setQueryOptions(q *QueryOptions) { + if q == nil { + return + } + if q.Datacenter != "" { + r.params.Set("dc", q.Datacenter) + } + if q.AllowStale { + r.params.Set("stale", "") + } + if q.RequireConsistent { + r.params.Set("consistent", "") + } + if q.WaitIndex != 0 { + r.params.Set("index", strconv.FormatUint(q.WaitIndex, 10)) + } + if q.WaitTime != 0 { + r.params.Set("wait", durToMsec(q.WaitTime)) + } + if q.Token != "" { + r.header.Set("X-Consul-Token", q.Token) + } + if q.Near != "" { + r.params.Set("near", q.Near) + } +} + +// durToMsec converts a duration to a millisecond specified string. If the +// user selected a positive value that rounds to 0 ms, then we will use 1 ms +// so they get a short delay, otherwise Consul will translate the 0 ms into +// a huge default delay. +func durToMsec(dur time.Duration) string { + ms := dur / time.Millisecond + if dur > 0 && ms == 0 { + ms = 1 + } + return fmt.Sprintf("%dms", ms) +} + +// serverError is a string we look for to detect 500 errors. +const serverError = "Unexpected response code: 500" + +// IsServerError returns true for 500 errors from the Consul servers, these are +// usually retryable at a later time. +func IsServerError(err error) bool { + if err == nil { + return false + } + + // TODO (slackpad) - Make a real error type here instead of using + // a string check. + return strings.Contains(err.Error(), serverError) +} + +// setWriteOptions is used to annotate the request with +// additional write options +func (r *request) setWriteOptions(q *WriteOptions) { + if q == nil { + return + } + if q.Datacenter != "" { + r.params.Set("dc", q.Datacenter) + } + if q.Token != "" { + r.header.Set("X-Consul-Token", q.Token) + } +} + +// toHTTP converts the request to an HTTP request +func (r *request) toHTTP() (*http.Request, error) { + // Encode the query parameters + r.url.RawQuery = r.params.Encode() + + // Check if we should encode the body + if r.body == nil && r.obj != nil { + if b, err := encodeBody(r.obj); err != nil { + return nil, err + } else { + r.body = b + } + } + + // Create the HTTP request + req, err := http.NewRequest(r.method, r.url.RequestURI(), r.body) + if err != nil { + return nil, err + } + + req.URL.Host = r.url.Host + req.URL.Scheme = r.url.Scheme + req.Host = r.url.Host + req.Header = r.header + + // Setup auth + if r.config.HttpAuth != nil { + req.SetBasicAuth(r.config.HttpAuth.Username, r.config.HttpAuth.Password) + } + + return req, nil +} + +// newRequest is used to create a new request +func (c *Client) newRequest(method, path string) *request { + r := &request{ + config: &c.config, + method: method, + url: &url.URL{ + Scheme: c.config.Scheme, + Host: c.config.Address, + Path: path, + }, + params: make(map[string][]string), + header: make(http.Header), + } + if c.config.Datacenter != "" { + r.params.Set("dc", c.config.Datacenter) + } + if c.config.WaitTime != 0 { + r.params.Set("wait", durToMsec(r.config.WaitTime)) + } + if c.config.Token != "" { + r.header.Set("X-Consul-Token", r.config.Token) + } + return r +} + +// doRequest runs a request with our client +func (c *Client) doRequest(r *request) (time.Duration, *http.Response, error) { + req, err := r.toHTTP() + if err != nil { + return 0, nil, err + } + start := time.Now() + resp, err := c.config.HttpClient.Do(req) + diff := time.Now().Sub(start) + return diff, resp, err +} + +// Query is used to do a GET request against an endpoint +// and deserialize the response into an interface using +// standard Consul conventions. +func (c *Client) query(endpoint string, out interface{}, q *QueryOptions) (*QueryMeta, error) { + r := c.newRequest("GET", endpoint) + r.setQueryOptions(q) + rtt, resp, err := requireOK(c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + if err := decodeBody(resp, out); err != nil { + return nil, err + } + return qm, nil +} + +// write is used to do a PUT request against an endpoint +// and serialize/deserialized using the standard Consul conventions. +func (c *Client) write(endpoint string, in, out interface{}, q *WriteOptions) (*WriteMeta, error) { + r := c.newRequest("PUT", endpoint) + r.setWriteOptions(q) + r.obj = in + rtt, resp, err := requireOK(c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + wm := &WriteMeta{RequestTime: rtt} + if out != nil { + if err := decodeBody(resp, &out); err != nil { + return nil, err + } + } + return wm, nil +} + +// parseQueryMeta is used to help parse query meta-data +func parseQueryMeta(resp *http.Response, q *QueryMeta) error { + header := resp.Header + + // Parse the X-Consul-Index + index, err := strconv.ParseUint(header.Get("X-Consul-Index"), 10, 64) + if err != nil { + return fmt.Errorf("Failed to parse X-Consul-Index: %v", err) + } + q.LastIndex = index + + // Parse the X-Consul-LastContact + last, err := strconv.ParseUint(header.Get("X-Consul-LastContact"), 10, 64) + if err != nil { + return fmt.Errorf("Failed to parse X-Consul-LastContact: %v", err) + } + q.LastContact = time.Duration(last) * time.Millisecond + + // Parse the X-Consul-KnownLeader + switch header.Get("X-Consul-KnownLeader") { + case "true": + q.KnownLeader = true + default: + q.KnownLeader = false + } + + // Parse X-Consul-Translate-Addresses + switch header.Get("X-Consul-Translate-Addresses") { + case "true": + q.AddressTranslationEnabled = true + default: + q.AddressTranslationEnabled = false + } + + return nil +} + +// decodeBody is used to JSON decode a body +func decodeBody(resp *http.Response, out interface{}) error { + dec := json.NewDecoder(resp.Body) + return dec.Decode(out) +} + +// encodeBody is used to encode a request body +func encodeBody(obj interface{}) (io.Reader, error) { + buf := bytes.NewBuffer(nil) + enc := json.NewEncoder(buf) + if err := enc.Encode(obj); err != nil { + return nil, err + } + return buf, nil +} + +// requireOK is used to wrap doRequest and check for a 200 +func requireOK(d time.Duration, resp *http.Response, e error) (time.Duration, *http.Response, error) { + if e != nil { + if resp != nil { + resp.Body.Close() + } + return d, nil, e + } + if resp.StatusCode != 200 { + var buf bytes.Buffer + io.Copy(&buf, resp.Body) + resp.Body.Close() + return d, nil, fmt.Errorf("Unexpected response code: %d (%s)", resp.StatusCode, buf.Bytes()) + } + return d, resp, nil +} diff --git a/vendor/github.com/hashicorp/consul/api/catalog.go b/vendor/github.com/hashicorp/consul/api/catalog.go new file mode 100644 index 00000000..337772ec --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/catalog.go @@ -0,0 +1,186 @@ +package api + +type Node struct { + Node string + Address string + TaggedAddresses map[string]string +} + +type CatalogService struct { + Node string + Address string + TaggedAddresses map[string]string + ServiceID string + ServiceName string + ServiceAddress string + ServiceTags []string + ServicePort int + ServiceEnableTagOverride bool +} + +type CatalogNode struct { + Node *Node + Services map[string]*AgentService +} + +type CatalogRegistration struct { + Node string + Address string + TaggedAddresses map[string]string + Datacenter string + Service *AgentService + Check *AgentCheck +} + +type CatalogDeregistration struct { + Node string + Address string + Datacenter string + ServiceID string + CheckID string +} + +// Catalog can be used to query the Catalog endpoints +type Catalog struct { + c *Client +} + +// Catalog returns a handle to the catalog endpoints +func (c *Client) Catalog() *Catalog { + return &Catalog{c} +} + +func (c *Catalog) Register(reg *CatalogRegistration, q *WriteOptions) (*WriteMeta, error) { + r := c.c.newRequest("PUT", "/v1/catalog/register") + r.setWriteOptions(q) + r.obj = reg + rtt, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return nil, err + } + resp.Body.Close() + + wm := &WriteMeta{} + wm.RequestTime = rtt + + return wm, nil +} + +func (c *Catalog) Deregister(dereg *CatalogDeregistration, q *WriteOptions) (*WriteMeta, error) { + r := c.c.newRequest("PUT", "/v1/catalog/deregister") + r.setWriteOptions(q) + r.obj = dereg + rtt, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return nil, err + } + resp.Body.Close() + + wm := &WriteMeta{} + wm.RequestTime = rtt + + return wm, nil +} + +// Datacenters is used to query for all the known datacenters +func (c *Catalog) Datacenters() ([]string, error) { + r := c.c.newRequest("GET", "/v1/catalog/datacenters") + _, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + var out []string + if err := decodeBody(resp, &out); err != nil { + return nil, err + } + return out, nil +} + +// Nodes is used to query all the known nodes +func (c *Catalog) Nodes(q *QueryOptions) ([]*Node, *QueryMeta, error) { + r := c.c.newRequest("GET", "/v1/catalog/nodes") + r.setQueryOptions(q) + rtt, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var out []*Node + if err := decodeBody(resp, &out); err != nil { + return nil, nil, err + } + return out, qm, nil +} + +// Services is used to query for all known services +func (c *Catalog) Services(q *QueryOptions) (map[string][]string, *QueryMeta, error) { + r := c.c.newRequest("GET", "/v1/catalog/services") + r.setQueryOptions(q) + rtt, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var out map[string][]string + if err := decodeBody(resp, &out); err != nil { + return nil, nil, err + } + return out, qm, nil +} + +// Service is used to query catalog entries for a given service +func (c *Catalog) Service(service, tag string, q *QueryOptions) ([]*CatalogService, *QueryMeta, error) { + r := c.c.newRequest("GET", "/v1/catalog/service/"+service) + r.setQueryOptions(q) + if tag != "" { + r.params.Set("tag", tag) + } + rtt, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var out []*CatalogService + if err := decodeBody(resp, &out); err != nil { + return nil, nil, err + } + return out, qm, nil +} + +// Node is used to query for service information about a single node +func (c *Catalog) Node(node string, q *QueryOptions) (*CatalogNode, *QueryMeta, error) { + r := c.c.newRequest("GET", "/v1/catalog/node/"+node) + r.setQueryOptions(q) + rtt, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var out *CatalogNode + if err := decodeBody(resp, &out); err != nil { + return nil, nil, err + } + return out, qm, nil +} diff --git a/vendor/github.com/hashicorp/consul/api/coordinate.go b/vendor/github.com/hashicorp/consul/api/coordinate.go new file mode 100644 index 00000000..fdff2075 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/coordinate.go @@ -0,0 +1,66 @@ +package api + +import ( + "github.com/hashicorp/serf/coordinate" +) + +// CoordinateEntry represents a node and its associated network coordinate. +type CoordinateEntry struct { + Node string + Coord *coordinate.Coordinate +} + +// CoordinateDatacenterMap represents a datacenter and its associated WAN +// nodes and their associates coordinates. +type CoordinateDatacenterMap struct { + Datacenter string + Coordinates []CoordinateEntry +} + +// Coordinate can be used to query the coordinate endpoints +type Coordinate struct { + c *Client +} + +// Coordinate returns a handle to the coordinate endpoints +func (c *Client) Coordinate() *Coordinate { + return &Coordinate{c} +} + +// Datacenters is used to return the coordinates of all the servers in the WAN +// pool. +func (c *Coordinate) Datacenters() ([]*CoordinateDatacenterMap, error) { + r := c.c.newRequest("GET", "/v1/coordinate/datacenters") + _, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + var out []*CoordinateDatacenterMap + if err := decodeBody(resp, &out); err != nil { + return nil, err + } + return out, nil +} + +// Nodes is used to return the coordinates of all the nodes in the LAN pool. +func (c *Coordinate) Nodes(q *QueryOptions) ([]*CoordinateEntry, *QueryMeta, error) { + r := c.c.newRequest("GET", "/v1/coordinate/nodes") + r.setQueryOptions(q) + rtt, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var out []*CoordinateEntry + if err := decodeBody(resp, &out); err != nil { + return nil, nil, err + } + return out, qm, nil +} diff --git a/vendor/github.com/hashicorp/consul/api/event.go b/vendor/github.com/hashicorp/consul/api/event.go new file mode 100644 index 00000000..85b5b069 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/event.go @@ -0,0 +1,104 @@ +package api + +import ( + "bytes" + "strconv" +) + +// Event can be used to query the Event endpoints +type Event struct { + c *Client +} + +// UserEvent represents an event that was fired by the user +type UserEvent struct { + ID string + Name string + Payload []byte + NodeFilter string + ServiceFilter string + TagFilter string + Version int + LTime uint64 +} + +// Event returns a handle to the event endpoints +func (c *Client) Event() *Event { + return &Event{c} +} + +// Fire is used to fire a new user event. Only the Name, Payload and Filters +// are respected. This returns the ID or an associated error. Cross DC requests +// are supported. +func (e *Event) Fire(params *UserEvent, q *WriteOptions) (string, *WriteMeta, error) { + r := e.c.newRequest("PUT", "/v1/event/fire/"+params.Name) + r.setWriteOptions(q) + if params.NodeFilter != "" { + r.params.Set("node", params.NodeFilter) + } + if params.ServiceFilter != "" { + r.params.Set("service", params.ServiceFilter) + } + if params.TagFilter != "" { + r.params.Set("tag", params.TagFilter) + } + if params.Payload != nil { + r.body = bytes.NewReader(params.Payload) + } + + rtt, resp, err := requireOK(e.c.doRequest(r)) + if err != nil { + return "", nil, err + } + defer resp.Body.Close() + + wm := &WriteMeta{RequestTime: rtt} + var out UserEvent + if err := decodeBody(resp, &out); err != nil { + return "", nil, err + } + return out.ID, wm, nil +} + +// List is used to get the most recent events an agent has received. +// This list can be optionally filtered by the name. This endpoint supports +// quasi-blocking queries. The index is not monotonic, nor does it provide provide +// LastContact or KnownLeader. +func (e *Event) List(name string, q *QueryOptions) ([]*UserEvent, *QueryMeta, error) { + r := e.c.newRequest("GET", "/v1/event/list") + r.setQueryOptions(q) + if name != "" { + r.params.Set("name", name) + } + rtt, resp, err := requireOK(e.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var entries []*UserEvent + if err := decodeBody(resp, &entries); err != nil { + return nil, nil, err + } + return entries, qm, nil +} + +// IDToIndex is a bit of a hack. This simulates the index generation to +// convert an event ID into a WaitIndex. +func (e *Event) IDToIndex(uuid string) uint64 { + lower := uuid[0:8] + uuid[9:13] + uuid[14:18] + upper := uuid[19:23] + uuid[24:36] + lowVal, err := strconv.ParseUint(lower, 16, 64) + if err != nil { + panic("Failed to convert " + lower) + } + highVal, err := strconv.ParseUint(upper, 16, 64) + if err != nil { + panic("Failed to convert " + upper) + } + return lowVal ^ highVal +} diff --git a/vendor/github.com/hashicorp/consul/api/health.go b/vendor/github.com/hashicorp/consul/api/health.go new file mode 100644 index 00000000..74da949c --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/health.go @@ -0,0 +1,144 @@ +package api + +import ( + "fmt" +) + +const ( + // HealthAny is special, and is used as a wild card, + // not as a specific state. + HealthAny = "any" + HealthPassing = "passing" + HealthWarning = "warning" + HealthCritical = "critical" +) + +// HealthCheck is used to represent a single check +type HealthCheck struct { + Node string + CheckID string + Name string + Status string + Notes string + Output string + ServiceID string + ServiceName string +} + +// ServiceEntry is used for the health service endpoint +type ServiceEntry struct { + Node *Node + Service *AgentService + Checks []*HealthCheck +} + +// Health can be used to query the Health endpoints +type Health struct { + c *Client +} + +// Health returns a handle to the health endpoints +func (c *Client) Health() *Health { + return &Health{c} +} + +// Node is used to query for checks belonging to a given node +func (h *Health) Node(node string, q *QueryOptions) ([]*HealthCheck, *QueryMeta, error) { + r := h.c.newRequest("GET", "/v1/health/node/"+node) + r.setQueryOptions(q) + rtt, resp, err := requireOK(h.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var out []*HealthCheck + if err := decodeBody(resp, &out); err != nil { + return nil, nil, err + } + return out, qm, nil +} + +// Checks is used to return the checks associated with a service +func (h *Health) Checks(service string, q *QueryOptions) ([]*HealthCheck, *QueryMeta, error) { + r := h.c.newRequest("GET", "/v1/health/checks/"+service) + r.setQueryOptions(q) + rtt, resp, err := requireOK(h.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var out []*HealthCheck + if err := decodeBody(resp, &out); err != nil { + return nil, nil, err + } + return out, qm, nil +} + +// Service is used to query health information along with service info +// for a given service. It can optionally do server-side filtering on a tag +// or nodes with passing health checks only. +func (h *Health) Service(service, tag string, passingOnly bool, q *QueryOptions) ([]*ServiceEntry, *QueryMeta, error) { + r := h.c.newRequest("GET", "/v1/health/service/"+service) + r.setQueryOptions(q) + if tag != "" { + r.params.Set("tag", tag) + } + if passingOnly { + r.params.Set(HealthPassing, "1") + } + rtt, resp, err := requireOK(h.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var out []*ServiceEntry + if err := decodeBody(resp, &out); err != nil { + return nil, nil, err + } + return out, qm, nil +} + +// State is used to retrieve all the checks in a given state. +// The wildcard "any" state can also be used for all checks. +func (h *Health) State(state string, q *QueryOptions) ([]*HealthCheck, *QueryMeta, error) { + switch state { + case HealthAny: + case HealthWarning: + case HealthCritical: + case HealthPassing: + default: + return nil, nil, fmt.Errorf("Unsupported state: %v", state) + } + r := h.c.newRequest("GET", "/v1/health/state/"+state) + r.setQueryOptions(q) + rtt, resp, err := requireOK(h.c.doRequest(r)) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + var out []*HealthCheck + if err := decodeBody(resp, &out); err != nil { + return nil, nil, err + } + return out, qm, nil +} diff --git a/vendor/github.com/hashicorp/consul/api/kv.go b/vendor/github.com/hashicorp/consul/api/kv.go new file mode 100644 index 00000000..3dac2583 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/kv.go @@ -0,0 +1,396 @@ +package api + +import ( + "bytes" + "fmt" + "io" + "net/http" + "strconv" + "strings" +) + +// KVPair is used to represent a single K/V entry +type KVPair struct { + Key string + CreateIndex uint64 + ModifyIndex uint64 + LockIndex uint64 + Flags uint64 + Value []byte + Session string +} + +// KVPairs is a list of KVPair objects +type KVPairs []*KVPair + +// KVOp constants give possible operations available in a KVTxn. +type KVOp string + +const ( + KVSet KVOp = "set" + KVDelete = "delete" + KVDeleteCAS = "delete-cas" + KVDeleteTree = "delete-tree" + KVCAS = "cas" + KVLock = "lock" + KVUnlock = "unlock" + KVGet = "get" + KVGetTree = "get-tree" + KVCheckSession = "check-session" + KVCheckIndex = "check-index" +) + +// KVTxnOp defines a single operation inside a transaction. +type KVTxnOp struct { + Verb string + Key string + Value []byte + Flags uint64 + Index uint64 + Session string +} + +// KVTxnOps defines a set of operations to be performed inside a single +// transaction. +type KVTxnOps []*KVTxnOp + +// KVTxnResponse has the outcome of a transaction. +type KVTxnResponse struct { + Results []*KVPair + Errors TxnErrors +} + +// KV is used to manipulate the K/V API +type KV struct { + c *Client +} + +// KV is used to return a handle to the K/V apis +func (c *Client) KV() *KV { + return &KV{c} +} + +// Get is used to lookup a single key +func (k *KV) Get(key string, q *QueryOptions) (*KVPair, *QueryMeta, error) { + resp, qm, err := k.getInternal(key, nil, q) + if err != nil { + return nil, nil, err + } + if resp == nil { + return nil, qm, nil + } + defer resp.Body.Close() + + var entries []*KVPair + if err := decodeBody(resp, &entries); err != nil { + return nil, nil, err + } + if len(entries) > 0 { + return entries[0], qm, nil + } + return nil, qm, nil +} + +// List is used to lookup all keys under a prefix +func (k *KV) List(prefix string, q *QueryOptions) (KVPairs, *QueryMeta, error) { + resp, qm, err := k.getInternal(prefix, map[string]string{"recurse": ""}, q) + if err != nil { + return nil, nil, err + } + if resp == nil { + return nil, qm, nil + } + defer resp.Body.Close() + + var entries []*KVPair + if err := decodeBody(resp, &entries); err != nil { + return nil, nil, err + } + return entries, qm, nil +} + +// Keys is used to list all the keys under a prefix. Optionally, +// a separator can be used to limit the responses. +func (k *KV) Keys(prefix, separator string, q *QueryOptions) ([]string, *QueryMeta, error) { + params := map[string]string{"keys": ""} + if separator != "" { + params["separator"] = separator + } + resp, qm, err := k.getInternal(prefix, params, q) + if err != nil { + return nil, nil, err + } + if resp == nil { + return nil, qm, nil + } + defer resp.Body.Close() + + var entries []string + if err := decodeBody(resp, &entries); err != nil { + return nil, nil, err + } + return entries, qm, nil +} + +func (k *KV) getInternal(key string, params map[string]string, q *QueryOptions) (*http.Response, *QueryMeta, error) { + r := k.c.newRequest("GET", "/v1/kv/"+key) + r.setQueryOptions(q) + for param, val := range params { + r.params.Set(param, val) + } + rtt, resp, err := k.c.doRequest(r) + if err != nil { + return nil, nil, err + } + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + if resp.StatusCode == 404 { + resp.Body.Close() + return nil, qm, nil + } else if resp.StatusCode != 200 { + resp.Body.Close() + return nil, nil, fmt.Errorf("Unexpected response code: %d", resp.StatusCode) + } + return resp, qm, nil +} + +// Put is used to write a new value. Only the +// Key, Flags and Value is respected. +func (k *KV) Put(p *KVPair, q *WriteOptions) (*WriteMeta, error) { + params := make(map[string]string, 1) + if p.Flags != 0 { + params["flags"] = strconv.FormatUint(p.Flags, 10) + } + _, wm, err := k.put(p.Key, params, p.Value, q) + return wm, err +} + +// CAS is used for a Check-And-Set operation. The Key, +// ModifyIndex, Flags and Value are respected. Returns true +// on success or false on failures. +func (k *KV) CAS(p *KVPair, q *WriteOptions) (bool, *WriteMeta, error) { + params := make(map[string]string, 2) + if p.Flags != 0 { + params["flags"] = strconv.FormatUint(p.Flags, 10) + } + params["cas"] = strconv.FormatUint(p.ModifyIndex, 10) + return k.put(p.Key, params, p.Value, q) +} + +// Acquire is used for a lock acquisition operation. The Key, +// Flags, Value and Session are respected. Returns true +// on success or false on failures. +func (k *KV) Acquire(p *KVPair, q *WriteOptions) (bool, *WriteMeta, error) { + params := make(map[string]string, 2) + if p.Flags != 0 { + params["flags"] = strconv.FormatUint(p.Flags, 10) + } + params["acquire"] = p.Session + return k.put(p.Key, params, p.Value, q) +} + +// Release is used for a lock release operation. The Key, +// Flags, Value and Session are respected. Returns true +// on success or false on failures. +func (k *KV) Release(p *KVPair, q *WriteOptions) (bool, *WriteMeta, error) { + params := make(map[string]string, 2) + if p.Flags != 0 { + params["flags"] = strconv.FormatUint(p.Flags, 10) + } + params["release"] = p.Session + return k.put(p.Key, params, p.Value, q) +} + +func (k *KV) put(key string, params map[string]string, body []byte, q *WriteOptions) (bool, *WriteMeta, error) { + if len(key) > 0 && key[0] == '/' { + return false, nil, fmt.Errorf("Invalid key. Key must not begin with a '/': %s", key) + } + + r := k.c.newRequest("PUT", "/v1/kv/"+key) + r.setWriteOptions(q) + for param, val := range params { + r.params.Set(param, val) + } + r.body = bytes.NewReader(body) + rtt, resp, err := requireOK(k.c.doRequest(r)) + if err != nil { + return false, nil, err + } + defer resp.Body.Close() + + qm := &WriteMeta{} + qm.RequestTime = rtt + + var buf bytes.Buffer + if _, err := io.Copy(&buf, resp.Body); err != nil { + return false, nil, fmt.Errorf("Failed to read response: %v", err) + } + res := strings.Contains(string(buf.Bytes()), "true") + return res, qm, nil +} + +// Delete is used to delete a single key +func (k *KV) Delete(key string, w *WriteOptions) (*WriteMeta, error) { + _, qm, err := k.deleteInternal(key, nil, w) + return qm, err +} + +// DeleteCAS is used for a Delete Check-And-Set operation. The Key +// and ModifyIndex are respected. Returns true on success or false on failures. +func (k *KV) DeleteCAS(p *KVPair, q *WriteOptions) (bool, *WriteMeta, error) { + params := map[string]string{ + "cas": strconv.FormatUint(p.ModifyIndex, 10), + } + return k.deleteInternal(p.Key, params, q) +} + +// DeleteTree is used to delete all keys under a prefix +func (k *KV) DeleteTree(prefix string, w *WriteOptions) (*WriteMeta, error) { + _, qm, err := k.deleteInternal(prefix, map[string]string{"recurse": ""}, w) + return qm, err +} + +func (k *KV) deleteInternal(key string, params map[string]string, q *WriteOptions) (bool, *WriteMeta, error) { + r := k.c.newRequest("DELETE", "/v1/kv/"+key) + r.setWriteOptions(q) + for param, val := range params { + r.params.Set(param, val) + } + rtt, resp, err := requireOK(k.c.doRequest(r)) + if err != nil { + return false, nil, err + } + defer resp.Body.Close() + + qm := &WriteMeta{} + qm.RequestTime = rtt + + var buf bytes.Buffer + if _, err := io.Copy(&buf, resp.Body); err != nil { + return false, nil, fmt.Errorf("Failed to read response: %v", err) + } + res := strings.Contains(string(buf.Bytes()), "true") + return res, qm, nil +} + +// TxnOp is the internal format we send to Consul. It's not specific to KV, +// though currently only KV operations are supported. +type TxnOp struct { + KV *KVTxnOp +} + +// TxnOps is a list of transaction operations. +type TxnOps []*TxnOp + +// TxnResult is the internal format we receive from Consul. +type TxnResult struct { + KV *KVPair +} + +// TxnResults is a list of TxnResult objects. +type TxnResults []*TxnResult + +// TxnError is used to return information about an operation in a transaction. +type TxnError struct { + OpIndex int + What string +} + +// TxnErrors is a list of TxnError objects. +type TxnErrors []*TxnError + +// TxnResponse is the internal format we receive from Consul. +type TxnResponse struct { + Results TxnResults + Errors TxnErrors +} + +// Txn is used to apply multiple KV operations in a single, atomic transaction. +// +// Note that Go will perform the required base64 encoding on the values +// automatically because the type is a byte slice. Transactions are defined as a +// list of operations to perform, using the KVOp constants and KVTxnOp structure +// to define operations. If any operation fails, none of the changes are applied +// to the state store. Note that this hides the internal raw transaction interface +// and munges the input and output types into KV-specific ones for ease of use. +// If there are more non-KV operations in the future we may break out a new +// transaction API client, but it will be easy to keep this KV-specific variant +// supported. +// +// Even though this is generally a write operation, we take a QueryOptions input +// and return a QueryMeta output. If the transaction contains only read ops, then +// Consul will fast-path it to a different endpoint internally which supports +// consistency controls, but not blocking. If there are write operations then +// the request will always be routed through raft and any consistency settings +// will be ignored. +// +// Here's an example: +// +// ops := KVTxnOps{ +// &KVTxnOp{ +// Verb: KVLock, +// Key: "test/lock", +// Session: "adf4238a-882b-9ddc-4a9d-5b6758e4159e", +// Value: []byte("hello"), +// }, +// &KVTxnOp{ +// Verb: KVGet, +// Key: "another/key", +// }, +// } +// ok, response, _, err := kv.Txn(&ops, nil) +// +// If there is a problem making the transaction request then an error will be +// returned. Otherwise, the ok value will be true if the transaction succeeded +// or false if it was rolled back. The response is a structured return value which +// will have the outcome of the transaction. Its Results member will have entries +// for each operation. Deleted keys will have a nil entry in the, and to save +// space, the Value of each key in the Results will be nil unless the operation +// is a KVGet. If the transaction was rolled back, the Errors member will have +// entries referencing the index of the operation that failed along with an error +// message. +func (k *KV) Txn(txn KVTxnOps, q *QueryOptions) (bool, *KVTxnResponse, *QueryMeta, error) { + r := k.c.newRequest("PUT", "/v1/txn") + r.setQueryOptions(q) + + // Convert into the internal format since this is an all-KV txn. + ops := make(TxnOps, 0, len(txn)) + for _, kvOp := range txn { + ops = append(ops, &TxnOp{KV: kvOp}) + } + r.obj = ops + rtt, resp, err := k.c.doRequest(r) + if err != nil { + return false, nil, nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + + if resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusConflict { + var txnResp TxnResponse + if err := decodeBody(resp, &txnResp); err != nil { + return false, nil, nil, err + } + + // Convert from the internal format. + kvResp := KVTxnResponse{ + Errors: txnResp.Errors, + } + for _, result := range txnResp.Results { + kvResp.Results = append(kvResp.Results, result.KV) + } + return resp.StatusCode == http.StatusOK, &kvResp, qm, nil + } + + var buf bytes.Buffer + if _, err := io.Copy(&buf, resp.Body); err != nil { + return false, nil, nil, fmt.Errorf("Failed to read response: %v", err) + } + return false, nil, nil, fmt.Errorf("Failed request: %s", buf.String()) +} diff --git a/vendor/github.com/hashicorp/consul/api/lock.go b/vendor/github.com/hashicorp/consul/api/lock.go new file mode 100644 index 00000000..08e8e793 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/lock.go @@ -0,0 +1,380 @@ +package api + +import ( + "fmt" + "sync" + "time" +) + +const ( + // DefaultLockSessionName is the Session Name we assign if none is provided + DefaultLockSessionName = "Consul API Lock" + + // DefaultLockSessionTTL is the default session TTL if no Session is provided + // when creating a new Lock. This is used because we do not have another + // other check to depend upon. + DefaultLockSessionTTL = "15s" + + // DefaultLockWaitTime is how long we block for at a time to check if lock + // acquisition is possible. This affects the minimum time it takes to cancel + // a Lock acquisition. + DefaultLockWaitTime = 15 * time.Second + + // DefaultLockRetryTime is how long we wait after a failed lock acquisition + // before attempting to do the lock again. This is so that once a lock-delay + // is in effect, we do not hot loop retrying the acquisition. + DefaultLockRetryTime = 5 * time.Second + + // DefaultMonitorRetryTime is how long we wait after a failed monitor check + // of a lock (500 response code). This allows the monitor to ride out brief + // periods of unavailability, subject to the MonitorRetries setting in the + // lock options which is by default set to 0, disabling this feature. This + // affects locks and semaphores. + DefaultMonitorRetryTime = 2 * time.Second + + // LockFlagValue is a magic flag we set to indicate a key + // is being used for a lock. It is used to detect a potential + // conflict with a semaphore. + LockFlagValue = 0x2ddccbc058a50c18 +) + +var ( + // ErrLockHeld is returned if we attempt to double lock + ErrLockHeld = fmt.Errorf("Lock already held") + + // ErrLockNotHeld is returned if we attempt to unlock a lock + // that we do not hold. + ErrLockNotHeld = fmt.Errorf("Lock not held") + + // ErrLockInUse is returned if we attempt to destroy a lock + // that is in use. + ErrLockInUse = fmt.Errorf("Lock in use") + + // ErrLockConflict is returned if the flags on a key + // used for a lock do not match expectation + ErrLockConflict = fmt.Errorf("Existing key does not match lock use") +) + +// Lock is used to implement client-side leader election. It is follows the +// algorithm as described here: https://www.consul.io/docs/guides/leader-election.html. +type Lock struct { + c *Client + opts *LockOptions + + isHeld bool + sessionRenew chan struct{} + lockSession string + l sync.Mutex +} + +// LockOptions is used to parameterize the Lock behavior. +type LockOptions struct { + Key string // Must be set and have write permissions + Value []byte // Optional, value to associate with the lock + Session string // Optional, created if not specified + SessionName string // Optional, defaults to DefaultLockSessionName + SessionTTL string // Optional, defaults to DefaultLockSessionTTL + MonitorRetries int // Optional, defaults to 0 which means no retries + MonitorRetryTime time.Duration // Optional, defaults to DefaultMonitorRetryTime + LockWaitTime time.Duration // Optional, defaults to DefaultLockWaitTime + LockTryOnce bool // Optional, defaults to false which means try forever +} + +// LockKey returns a handle to a lock struct which can be used +// to acquire and release the mutex. The key used must have +// write permissions. +func (c *Client) LockKey(key string) (*Lock, error) { + opts := &LockOptions{ + Key: key, + } + return c.LockOpts(opts) +} + +// LockOpts returns a handle to a lock struct which can be used +// to acquire and release the mutex. The key used must have +// write permissions. +func (c *Client) LockOpts(opts *LockOptions) (*Lock, error) { + if opts.Key == "" { + return nil, fmt.Errorf("missing key") + } + if opts.SessionName == "" { + opts.SessionName = DefaultLockSessionName + } + if opts.SessionTTL == "" { + opts.SessionTTL = DefaultLockSessionTTL + } else { + if _, err := time.ParseDuration(opts.SessionTTL); err != nil { + return nil, fmt.Errorf("invalid SessionTTL: %v", err) + } + } + if opts.MonitorRetryTime == 0 { + opts.MonitorRetryTime = DefaultMonitorRetryTime + } + if opts.LockWaitTime == 0 { + opts.LockWaitTime = DefaultLockWaitTime + } + l := &Lock{ + c: c, + opts: opts, + } + return l, nil +} + +// Lock attempts to acquire the lock and blocks while doing so. +// Providing a non-nil stopCh can be used to abort the lock attempt. +// Returns a channel that is closed if our lock is lost or an error. +// This channel could be closed at any time due to session invalidation, +// communication errors, operator intervention, etc. It is NOT safe to +// assume that the lock is held until Unlock() unless the Session is specifically +// created without any associated health checks. By default Consul sessions +// prefer liveness over safety and an application must be able to handle +// the lock being lost. +func (l *Lock) Lock(stopCh <-chan struct{}) (<-chan struct{}, error) { + // Hold the lock as we try to acquire + l.l.Lock() + defer l.l.Unlock() + + // Check if we already hold the lock + if l.isHeld { + return nil, ErrLockHeld + } + + // Check if we need to create a session first + l.lockSession = l.opts.Session + if l.lockSession == "" { + if s, err := l.createSession(); err != nil { + return nil, fmt.Errorf("failed to create session: %v", err) + } else { + l.sessionRenew = make(chan struct{}) + l.lockSession = s + session := l.c.Session() + go session.RenewPeriodic(l.opts.SessionTTL, s, nil, l.sessionRenew) + + // If we fail to acquire the lock, cleanup the session + defer func() { + if !l.isHeld { + close(l.sessionRenew) + l.sessionRenew = nil + } + }() + } + } + + // Setup the query options + kv := l.c.KV() + qOpts := &QueryOptions{ + WaitTime: l.opts.LockWaitTime, + } + + start := time.Now() + attempts := 0 +WAIT: + // Check if we should quit + select { + case <-stopCh: + return nil, nil + default: + } + + // Handle the one-shot mode. + if l.opts.LockTryOnce && attempts > 0 { + elapsed := time.Now().Sub(start) + if elapsed > qOpts.WaitTime { + return nil, nil + } + + qOpts.WaitTime -= elapsed + } + attempts++ + + // Look for an existing lock, blocking until not taken + pair, meta, err := kv.Get(l.opts.Key, qOpts) + if err != nil { + return nil, fmt.Errorf("failed to read lock: %v", err) + } + if pair != nil && pair.Flags != LockFlagValue { + return nil, ErrLockConflict + } + locked := false + if pair != nil && pair.Session == l.lockSession { + goto HELD + } + if pair != nil && pair.Session != "" { + qOpts.WaitIndex = meta.LastIndex + goto WAIT + } + + // Try to acquire the lock + pair = l.lockEntry(l.lockSession) + locked, _, err = kv.Acquire(pair, nil) + if err != nil { + return nil, fmt.Errorf("failed to acquire lock: %v", err) + } + + // Handle the case of not getting the lock + if !locked { + // Determine why the lock failed + qOpts.WaitIndex = 0 + pair, meta, err = kv.Get(l.opts.Key, qOpts) + if pair != nil && pair.Session != "" { + //If the session is not null, this means that a wait can safely happen + //using a long poll + qOpts.WaitIndex = meta.LastIndex + goto WAIT + } else { + // If the session is empty and the lock failed to acquire, then it means + // a lock-delay is in effect and a timed wait must be used + select { + case <-time.After(DefaultLockRetryTime): + goto WAIT + case <-stopCh: + return nil, nil + } + } + } + +HELD: + // Watch to ensure we maintain leadership + leaderCh := make(chan struct{}) + go l.monitorLock(l.lockSession, leaderCh) + + // Set that we own the lock + l.isHeld = true + + // Locked! All done + return leaderCh, nil +} + +// Unlock released the lock. It is an error to call this +// if the lock is not currently held. +func (l *Lock) Unlock() error { + // Hold the lock as we try to release + l.l.Lock() + defer l.l.Unlock() + + // Ensure the lock is actually held + if !l.isHeld { + return ErrLockNotHeld + } + + // Set that we no longer own the lock + l.isHeld = false + + // Stop the session renew + if l.sessionRenew != nil { + defer func() { + close(l.sessionRenew) + l.sessionRenew = nil + }() + } + + // Get the lock entry, and clear the lock session + lockEnt := l.lockEntry(l.lockSession) + l.lockSession = "" + + // Release the lock explicitly + kv := l.c.KV() + _, _, err := kv.Release(lockEnt, nil) + if err != nil { + return fmt.Errorf("failed to release lock: %v", err) + } + return nil +} + +// Destroy is used to cleanup the lock entry. It is not necessary +// to invoke. It will fail if the lock is in use. +func (l *Lock) Destroy() error { + // Hold the lock as we try to release + l.l.Lock() + defer l.l.Unlock() + + // Check if we already hold the lock + if l.isHeld { + return ErrLockHeld + } + + // Look for an existing lock + kv := l.c.KV() + pair, _, err := kv.Get(l.opts.Key, nil) + if err != nil { + return fmt.Errorf("failed to read lock: %v", err) + } + + // Nothing to do if the lock does not exist + if pair == nil { + return nil + } + + // Check for possible flag conflict + if pair.Flags != LockFlagValue { + return ErrLockConflict + } + + // Check if it is in use + if pair.Session != "" { + return ErrLockInUse + } + + // Attempt the delete + didRemove, _, err := kv.DeleteCAS(pair, nil) + if err != nil { + return fmt.Errorf("failed to remove lock: %v", err) + } + if !didRemove { + return ErrLockInUse + } + return nil +} + +// createSession is used to create a new managed session +func (l *Lock) createSession() (string, error) { + session := l.c.Session() + se := &SessionEntry{ + Name: l.opts.SessionName, + TTL: l.opts.SessionTTL, + } + id, _, err := session.Create(se, nil) + if err != nil { + return "", err + } + return id, nil +} + +// lockEntry returns a formatted KVPair for the lock +func (l *Lock) lockEntry(session string) *KVPair { + return &KVPair{ + Key: l.opts.Key, + Value: l.opts.Value, + Session: session, + Flags: LockFlagValue, + } +} + +// monitorLock is a long running routine to monitor a lock ownership +// It closes the stopCh if we lose our leadership. +func (l *Lock) monitorLock(session string, stopCh chan struct{}) { + defer close(stopCh) + kv := l.c.KV() + opts := &QueryOptions{RequireConsistent: true} +WAIT: + retries := l.opts.MonitorRetries +RETRY: + pair, meta, err := kv.Get(l.opts.Key, opts) + if err != nil { + // If configured we can try to ride out a brief Consul unavailability + // by doing retries. Note that we have to attempt the retry in a non- + // blocking fashion so that we have a clean place to reset the retry + // counter if service is restored. + if retries > 0 && IsServerError(err) { + time.Sleep(l.opts.MonitorRetryTime) + retries-- + opts.WaitIndex = 0 + goto RETRY + } + return + } + if pair != nil && pair.Session == session { + opts.WaitIndex = meta.LastIndex + goto WAIT + } +} diff --git a/vendor/github.com/hashicorp/consul/api/prepared_query.go b/vendor/github.com/hashicorp/consul/api/prepared_query.go new file mode 100644 index 00000000..63e741e0 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/prepared_query.go @@ -0,0 +1,194 @@ +package api + +// QueryDatacenterOptions sets options about how we fail over if there are no +// healthy nodes in the local datacenter. +type QueryDatacenterOptions struct { + // NearestN is set to the number of remote datacenters to try, based on + // network coordinates. + NearestN int + + // Datacenters is a fixed list of datacenters to try after NearestN. We + // never try a datacenter multiple times, so those are subtracted from + // this list before proceeding. + Datacenters []string +} + +// QueryDNSOptions controls settings when query results are served over DNS. +type QueryDNSOptions struct { + // TTL is the time to live for the served DNS results. + TTL string +} + +// ServiceQuery is used to query for a set of healthy nodes offering a specific +// service. +type ServiceQuery struct { + // Service is the service to query. + Service string + + // Near allows baking in the name of a node to automatically distance- + // sort from. The magic "_agent" value is supported, which sorts near + // the agent which initiated the request by default. + Near string + + // Failover controls what we do if there are no healthy nodes in the + // local datacenter. + Failover QueryDatacenterOptions + + // If OnlyPassing is true then we will only include nodes with passing + // health checks (critical AND warning checks will cause a node to be + // discarded) + OnlyPassing bool + + // Tags are a set of required and/or disallowed tags. If a tag is in + // this list it must be present. If the tag is preceded with "!" then + // it is disallowed. + Tags []string +} + +// QueryTemplate carries the arguments for creating a templated query. +type QueryTemplate struct { + // Type specifies the type of the query template. Currently only + // "name_prefix_match" is supported. This field is required. + Type string + + // Regexp allows specifying a regex pattern to match against the name + // of the query being executed. + Regexp string +} + +// PrepatedQueryDefinition defines a complete prepared query. +type PreparedQueryDefinition struct { + // ID is this UUID-based ID for the query, always generated by Consul. + ID string + + // Name is an optional friendly name for the query supplied by the + // user. NOTE - if this feature is used then it will reduce the security + // of any read ACL associated with this query/service since this name + // can be used to locate nodes with supplying any ACL. + Name string + + // Session is an optional session to tie this query's lifetime to. If + // this is omitted then the query will not expire. + Session string + + // Token is the ACL token used when the query was created, and it is + // used when a query is subsequently executed. This token, or a token + // with management privileges, must be used to change the query later. + Token string + + // Service defines a service query (leaving things open for other types + // later). + Service ServiceQuery + + // DNS has options that control how the results of this query are + // served over DNS. + DNS QueryDNSOptions + + // Template is used to pass through the arguments for creating a + // prepared query with an attached template. If a template is given, + // interpolations are possible in other struct fields. + Template QueryTemplate +} + +// PreparedQueryExecuteResponse has the results of executing a query. +type PreparedQueryExecuteResponse struct { + // Service is the service that was queried. + Service string + + // Nodes has the nodes that were output by the query. + Nodes []ServiceEntry + + // DNS has the options for serving these results over DNS. + DNS QueryDNSOptions + + // Datacenter is the datacenter that these results came from. + Datacenter string + + // Failovers is a count of how many times we had to query a remote + // datacenter. + Failovers int +} + +// PreparedQuery can be used to query the prepared query endpoints. +type PreparedQuery struct { + c *Client +} + +// PreparedQuery returns a handle to the prepared query endpoints. +func (c *Client) PreparedQuery() *PreparedQuery { + return &PreparedQuery{c} +} + +// Create makes a new prepared query. The ID of the new query is returned. +func (c *PreparedQuery) Create(query *PreparedQueryDefinition, q *WriteOptions) (string, *WriteMeta, error) { + r := c.c.newRequest("POST", "/v1/query") + r.setWriteOptions(q) + r.obj = query + rtt, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return "", nil, err + } + defer resp.Body.Close() + + wm := &WriteMeta{} + wm.RequestTime = rtt + + var out struct{ ID string } + if err := decodeBody(resp, &out); err != nil { + return "", nil, err + } + return out.ID, wm, nil +} + +// Update makes updates to an existing prepared query. +func (c *PreparedQuery) Update(query *PreparedQueryDefinition, q *WriteOptions) (*WriteMeta, error) { + return c.c.write("/v1/query/"+query.ID, query, nil, q) +} + +// List is used to fetch all the prepared queries (always requires a management +// token). +func (c *PreparedQuery) List(q *QueryOptions) ([]*PreparedQueryDefinition, *QueryMeta, error) { + var out []*PreparedQueryDefinition + qm, err := c.c.query("/v1/query", &out, q) + if err != nil { + return nil, nil, err + } + return out, qm, nil +} + +// Get is used to fetch a specific prepared query. +func (c *PreparedQuery) Get(queryID string, q *QueryOptions) ([]*PreparedQueryDefinition, *QueryMeta, error) { + var out []*PreparedQueryDefinition + qm, err := c.c.query("/v1/query/"+queryID, &out, q) + if err != nil { + return nil, nil, err + } + return out, qm, nil +} + +// Delete is used to delete a specific prepared query. +func (c *PreparedQuery) Delete(queryID string, q *QueryOptions) (*QueryMeta, error) { + r := c.c.newRequest("DELETE", "/v1/query/"+queryID) + r.setQueryOptions(q) + rtt, resp, err := requireOK(c.c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + qm := &QueryMeta{} + parseQueryMeta(resp, qm) + qm.RequestTime = rtt + return qm, nil +} + +// Execute is used to execute a specific prepared query. You can execute using +// a query ID or name. +func (c *PreparedQuery) Execute(queryIDOrName string, q *QueryOptions) (*PreparedQueryExecuteResponse, *QueryMeta, error) { + var out *PreparedQueryExecuteResponse + qm, err := c.c.query("/v1/query/"+queryIDOrName+"/execute", &out, q) + if err != nil { + return nil, nil, err + } + return out, qm, nil +} diff --git a/vendor/github.com/hashicorp/consul/api/raw.go b/vendor/github.com/hashicorp/consul/api/raw.go new file mode 100644 index 00000000..745a208c --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/raw.go @@ -0,0 +1,24 @@ +package api + +// Raw can be used to do raw queries against custom endpoints +type Raw struct { + c *Client +} + +// Raw returns a handle to query endpoints +func (c *Client) Raw() *Raw { + return &Raw{c} +} + +// Query is used to do a GET request against an endpoint +// and deserialize the response into an interface using +// standard Consul conventions. +func (raw *Raw) Query(endpoint string, out interface{}, q *QueryOptions) (*QueryMeta, error) { + return raw.c.query(endpoint, out, q) +} + +// Write is used to do a PUT request against an endpoint +// and serialize/deserialized using the standard Consul conventions. +func (raw *Raw) Write(endpoint string, in, out interface{}, q *WriteOptions) (*WriteMeta, error) { + return raw.c.write(endpoint, in, out, q) +} diff --git a/vendor/github.com/hashicorp/consul/api/semaphore.go b/vendor/github.com/hashicorp/consul/api/semaphore.go new file mode 100644 index 00000000..e6645ac1 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/semaphore.go @@ -0,0 +1,512 @@ +package api + +import ( + "encoding/json" + "fmt" + "path" + "sync" + "time" +) + +const ( + // DefaultSemaphoreSessionName is the Session Name we assign if none is provided + DefaultSemaphoreSessionName = "Consul API Semaphore" + + // DefaultSemaphoreSessionTTL is the default session TTL if no Session is provided + // when creating a new Semaphore. This is used because we do not have another + // other check to depend upon. + DefaultSemaphoreSessionTTL = "15s" + + // DefaultSemaphoreWaitTime is how long we block for at a time to check if semaphore + // acquisition is possible. This affects the minimum time it takes to cancel + // a Semaphore acquisition. + DefaultSemaphoreWaitTime = 15 * time.Second + + // DefaultSemaphoreKey is the key used within the prefix to + // use for coordination between all the contenders. + DefaultSemaphoreKey = ".lock" + + // SemaphoreFlagValue is a magic flag we set to indicate a key + // is being used for a semaphore. It is used to detect a potential + // conflict with a lock. + SemaphoreFlagValue = 0xe0f69a2baa414de0 +) + +var ( + // ErrSemaphoreHeld is returned if we attempt to double lock + ErrSemaphoreHeld = fmt.Errorf("Semaphore already held") + + // ErrSemaphoreNotHeld is returned if we attempt to unlock a semaphore + // that we do not hold. + ErrSemaphoreNotHeld = fmt.Errorf("Semaphore not held") + + // ErrSemaphoreInUse is returned if we attempt to destroy a semaphore + // that is in use. + ErrSemaphoreInUse = fmt.Errorf("Semaphore in use") + + // ErrSemaphoreConflict is returned if the flags on a key + // used for a semaphore do not match expectation + ErrSemaphoreConflict = fmt.Errorf("Existing key does not match semaphore use") +) + +// Semaphore is used to implement a distributed semaphore +// using the Consul KV primitives. +type Semaphore struct { + c *Client + opts *SemaphoreOptions + + isHeld bool + sessionRenew chan struct{} + lockSession string + l sync.Mutex +} + +// SemaphoreOptions is used to parameterize the Semaphore +type SemaphoreOptions struct { + Prefix string // Must be set and have write permissions + Limit int // Must be set, and be positive + Value []byte // Optional, value to associate with the contender entry + Session string // Optional, created if not specified + SessionName string // Optional, defaults to DefaultLockSessionName + SessionTTL string // Optional, defaults to DefaultLockSessionTTL + MonitorRetries int // Optional, defaults to 0 which means no retries + MonitorRetryTime time.Duration // Optional, defaults to DefaultMonitorRetryTime + SemaphoreWaitTime time.Duration // Optional, defaults to DefaultSemaphoreWaitTime + SemaphoreTryOnce bool // Optional, defaults to false which means try forever +} + +// semaphoreLock is written under the DefaultSemaphoreKey and +// is used to coordinate between all the contenders. +type semaphoreLock struct { + // Limit is the integer limit of holders. This is used to + // verify that all the holders agree on the value. + Limit int + + // Holders is a list of all the semaphore holders. + // It maps the session ID to true. It is used as a set effectively. + Holders map[string]bool +} + +// SemaphorePrefix is used to created a Semaphore which will operate +// at the given KV prefix and uses the given limit for the semaphore. +// The prefix must have write privileges, and the limit must be agreed +// upon by all contenders. +func (c *Client) SemaphorePrefix(prefix string, limit int) (*Semaphore, error) { + opts := &SemaphoreOptions{ + Prefix: prefix, + Limit: limit, + } + return c.SemaphoreOpts(opts) +} + +// SemaphoreOpts is used to create a Semaphore with the given options. +// The prefix must have write privileges, and the limit must be agreed +// upon by all contenders. If a Session is not provided, one will be created. +func (c *Client) SemaphoreOpts(opts *SemaphoreOptions) (*Semaphore, error) { + if opts.Prefix == "" { + return nil, fmt.Errorf("missing prefix") + } + if opts.Limit <= 0 { + return nil, fmt.Errorf("semaphore limit must be positive") + } + if opts.SessionName == "" { + opts.SessionName = DefaultSemaphoreSessionName + } + if opts.SessionTTL == "" { + opts.SessionTTL = DefaultSemaphoreSessionTTL + } else { + if _, err := time.ParseDuration(opts.SessionTTL); err != nil { + return nil, fmt.Errorf("invalid SessionTTL: %v", err) + } + } + if opts.MonitorRetryTime == 0 { + opts.MonitorRetryTime = DefaultMonitorRetryTime + } + if opts.SemaphoreWaitTime == 0 { + opts.SemaphoreWaitTime = DefaultSemaphoreWaitTime + } + s := &Semaphore{ + c: c, + opts: opts, + } + return s, nil +} + +// Acquire attempts to reserve a slot in the semaphore, blocking until +// success, interrupted via the stopCh or an error is encountered. +// Providing a non-nil stopCh can be used to abort the attempt. +// On success, a channel is returned that represents our slot. +// This channel could be closed at any time due to session invalidation, +// communication errors, operator intervention, etc. It is NOT safe to +// assume that the slot is held until Release() unless the Session is specifically +// created without any associated health checks. By default Consul sessions +// prefer liveness over safety and an application must be able to handle +// the session being lost. +func (s *Semaphore) Acquire(stopCh <-chan struct{}) (<-chan struct{}, error) { + // Hold the lock as we try to acquire + s.l.Lock() + defer s.l.Unlock() + + // Check if we already hold the semaphore + if s.isHeld { + return nil, ErrSemaphoreHeld + } + + // Check if we need to create a session first + s.lockSession = s.opts.Session + if s.lockSession == "" { + if sess, err := s.createSession(); err != nil { + return nil, fmt.Errorf("failed to create session: %v", err) + } else { + s.sessionRenew = make(chan struct{}) + s.lockSession = sess + session := s.c.Session() + go session.RenewPeriodic(s.opts.SessionTTL, sess, nil, s.sessionRenew) + + // If we fail to acquire the lock, cleanup the session + defer func() { + if !s.isHeld { + close(s.sessionRenew) + s.sessionRenew = nil + } + }() + } + } + + // Create the contender entry + kv := s.c.KV() + made, _, err := kv.Acquire(s.contenderEntry(s.lockSession), nil) + if err != nil || !made { + return nil, fmt.Errorf("failed to make contender entry: %v", err) + } + + // Setup the query options + qOpts := &QueryOptions{ + WaitTime: s.opts.SemaphoreWaitTime, + } + + start := time.Now() + attempts := 0 +WAIT: + // Check if we should quit + select { + case <-stopCh: + return nil, nil + default: + } + + // Handle the one-shot mode. + if s.opts.SemaphoreTryOnce && attempts > 0 { + elapsed := time.Now().Sub(start) + if elapsed > qOpts.WaitTime { + return nil, nil + } + + qOpts.WaitTime -= elapsed + } + attempts++ + + // Read the prefix + pairs, meta, err := kv.List(s.opts.Prefix, qOpts) + if err != nil { + return nil, fmt.Errorf("failed to read prefix: %v", err) + } + + // Decode the lock + lockPair := s.findLock(pairs) + if lockPair.Flags != SemaphoreFlagValue { + return nil, ErrSemaphoreConflict + } + lock, err := s.decodeLock(lockPair) + if err != nil { + return nil, err + } + + // Verify we agree with the limit + if lock.Limit != s.opts.Limit { + return nil, fmt.Errorf("semaphore limit conflict (lock: %d, local: %d)", + lock.Limit, s.opts.Limit) + } + + // Prune the dead holders + s.pruneDeadHolders(lock, pairs) + + // Check if the lock is held + if len(lock.Holders) >= lock.Limit { + qOpts.WaitIndex = meta.LastIndex + goto WAIT + } + + // Create a new lock with us as a holder + lock.Holders[s.lockSession] = true + newLock, err := s.encodeLock(lock, lockPair.ModifyIndex) + if err != nil { + return nil, err + } + + // Attempt the acquisition + didSet, _, err := kv.CAS(newLock, nil) + if err != nil { + return nil, fmt.Errorf("failed to update lock: %v", err) + } + if !didSet { + // Update failed, could have been a race with another contender, + // retry the operation + goto WAIT + } + + // Watch to ensure we maintain ownership of the slot + lockCh := make(chan struct{}) + go s.monitorLock(s.lockSession, lockCh) + + // Set that we own the lock + s.isHeld = true + + // Acquired! All done + return lockCh, nil +} + +// Release is used to voluntarily give up our semaphore slot. It is +// an error to call this if the semaphore has not been acquired. +func (s *Semaphore) Release() error { + // Hold the lock as we try to release + s.l.Lock() + defer s.l.Unlock() + + // Ensure the lock is actually held + if !s.isHeld { + return ErrSemaphoreNotHeld + } + + // Set that we no longer own the lock + s.isHeld = false + + // Stop the session renew + if s.sessionRenew != nil { + defer func() { + close(s.sessionRenew) + s.sessionRenew = nil + }() + } + + // Get and clear the lock session + lockSession := s.lockSession + s.lockSession = "" + + // Remove ourselves as a lock holder + kv := s.c.KV() + key := path.Join(s.opts.Prefix, DefaultSemaphoreKey) +READ: + pair, _, err := kv.Get(key, nil) + if err != nil { + return err + } + if pair == nil { + pair = &KVPair{} + } + lock, err := s.decodeLock(pair) + if err != nil { + return err + } + + // Create a new lock without us as a holder + if _, ok := lock.Holders[lockSession]; ok { + delete(lock.Holders, lockSession) + newLock, err := s.encodeLock(lock, pair.ModifyIndex) + if err != nil { + return err + } + + // Swap the locks + didSet, _, err := kv.CAS(newLock, nil) + if err != nil { + return fmt.Errorf("failed to update lock: %v", err) + } + if !didSet { + goto READ + } + } + + // Destroy the contender entry + contenderKey := path.Join(s.opts.Prefix, lockSession) + if _, err := kv.Delete(contenderKey, nil); err != nil { + return err + } + return nil +} + +// Destroy is used to cleanup the semaphore entry. It is not necessary +// to invoke. It will fail if the semaphore is in use. +func (s *Semaphore) Destroy() error { + // Hold the lock as we try to acquire + s.l.Lock() + defer s.l.Unlock() + + // Check if we already hold the semaphore + if s.isHeld { + return ErrSemaphoreHeld + } + + // List for the semaphore + kv := s.c.KV() + pairs, _, err := kv.List(s.opts.Prefix, nil) + if err != nil { + return fmt.Errorf("failed to read prefix: %v", err) + } + + // Find the lock pair, bail if it doesn't exist + lockPair := s.findLock(pairs) + if lockPair.ModifyIndex == 0 { + return nil + } + if lockPair.Flags != SemaphoreFlagValue { + return ErrSemaphoreConflict + } + + // Decode the lock + lock, err := s.decodeLock(lockPair) + if err != nil { + return err + } + + // Prune the dead holders + s.pruneDeadHolders(lock, pairs) + + // Check if there are any holders + if len(lock.Holders) > 0 { + return ErrSemaphoreInUse + } + + // Attempt the delete + didRemove, _, err := kv.DeleteCAS(lockPair, nil) + if err != nil { + return fmt.Errorf("failed to remove semaphore: %v", err) + } + if !didRemove { + return ErrSemaphoreInUse + } + return nil +} + +// createSession is used to create a new managed session +func (s *Semaphore) createSession() (string, error) { + session := s.c.Session() + se := &SessionEntry{ + Name: s.opts.SessionName, + TTL: s.opts.SessionTTL, + Behavior: SessionBehaviorDelete, + } + id, _, err := session.Create(se, nil) + if err != nil { + return "", err + } + return id, nil +} + +// contenderEntry returns a formatted KVPair for the contender +func (s *Semaphore) contenderEntry(session string) *KVPair { + return &KVPair{ + Key: path.Join(s.opts.Prefix, session), + Value: s.opts.Value, + Session: session, + Flags: SemaphoreFlagValue, + } +} + +// findLock is used to find the KV Pair which is used for coordination +func (s *Semaphore) findLock(pairs KVPairs) *KVPair { + key := path.Join(s.opts.Prefix, DefaultSemaphoreKey) + for _, pair := range pairs { + if pair.Key == key { + return pair + } + } + return &KVPair{Flags: SemaphoreFlagValue} +} + +// decodeLock is used to decode a semaphoreLock from an +// entry in Consul +func (s *Semaphore) decodeLock(pair *KVPair) (*semaphoreLock, error) { + // Handle if there is no lock + if pair == nil || pair.Value == nil { + return &semaphoreLock{ + Limit: s.opts.Limit, + Holders: make(map[string]bool), + }, nil + } + + l := &semaphoreLock{} + if err := json.Unmarshal(pair.Value, l); err != nil { + return nil, fmt.Errorf("lock decoding failed: %v", err) + } + return l, nil +} + +// encodeLock is used to encode a semaphoreLock into a KVPair +// that can be PUT +func (s *Semaphore) encodeLock(l *semaphoreLock, oldIndex uint64) (*KVPair, error) { + enc, err := json.Marshal(l) + if err != nil { + return nil, fmt.Errorf("lock encoding failed: %v", err) + } + pair := &KVPair{ + Key: path.Join(s.opts.Prefix, DefaultSemaphoreKey), + Value: enc, + Flags: SemaphoreFlagValue, + ModifyIndex: oldIndex, + } + return pair, nil +} + +// pruneDeadHolders is used to remove all the dead lock holders +func (s *Semaphore) pruneDeadHolders(lock *semaphoreLock, pairs KVPairs) { + // Gather all the live holders + alive := make(map[string]struct{}, len(pairs)) + for _, pair := range pairs { + if pair.Session != "" { + alive[pair.Session] = struct{}{} + } + } + + // Remove any holders that are dead + for holder := range lock.Holders { + if _, ok := alive[holder]; !ok { + delete(lock.Holders, holder) + } + } +} + +// monitorLock is a long running routine to monitor a semaphore ownership +// It closes the stopCh if we lose our slot. +func (s *Semaphore) monitorLock(session string, stopCh chan struct{}) { + defer close(stopCh) + kv := s.c.KV() + opts := &QueryOptions{RequireConsistent: true} +WAIT: + retries := s.opts.MonitorRetries +RETRY: + pairs, meta, err := kv.List(s.opts.Prefix, opts) + if err != nil { + // If configured we can try to ride out a brief Consul unavailability + // by doing retries. Note that we have to attempt the retry in a non- + // blocking fashion so that we have a clean place to reset the retry + // counter if service is restored. + if retries > 0 && IsServerError(err) { + time.Sleep(s.opts.MonitorRetryTime) + retries-- + opts.WaitIndex = 0 + goto RETRY + } + return + } + lockPair := s.findLock(pairs) + lock, err := s.decodeLock(lockPair) + if err != nil { + return + } + s.pruneDeadHolders(lock, pairs) + if _, ok := lock.Holders[session]; ok { + opts.WaitIndex = meta.LastIndex + goto WAIT + } +} diff --git a/vendor/github.com/hashicorp/consul/api/session.go b/vendor/github.com/hashicorp/consul/api/session.go new file mode 100644 index 00000000..36e99a38 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/session.go @@ -0,0 +1,217 @@ +package api + +import ( + "errors" + "fmt" + "time" +) + +const ( + // SessionBehaviorRelease is the default behavior and causes + // all associated locks to be released on session invalidation. + SessionBehaviorRelease = "release" + + // SessionBehaviorDelete is new in Consul 0.5 and changes the + // behavior to delete all associated locks on session invalidation. + // It can be used in a way similar to Ephemeral Nodes in ZooKeeper. + SessionBehaviorDelete = "delete" +) + +var ErrSessionExpired = errors.New("session expired") + +// SessionEntry represents a session in consul +type SessionEntry struct { + CreateIndex uint64 + ID string + Name string + Node string + Checks []string + LockDelay time.Duration + Behavior string + TTL string +} + +// Session can be used to query the Session endpoints +type Session struct { + c *Client +} + +// Session returns a handle to the session endpoints +func (c *Client) Session() *Session { + return &Session{c} +} + +// CreateNoChecks is like Create but is used specifically to create +// a session with no associated health checks. +func (s *Session) CreateNoChecks(se *SessionEntry, q *WriteOptions) (string, *WriteMeta, error) { + body := make(map[string]interface{}) + body["Checks"] = []string{} + if se != nil { + if se.Name != "" { + body["Name"] = se.Name + } + if se.Node != "" { + body["Node"] = se.Node + } + if se.LockDelay != 0 { + body["LockDelay"] = durToMsec(se.LockDelay) + } + if se.Behavior != "" { + body["Behavior"] = se.Behavior + } + if se.TTL != "" { + body["TTL"] = se.TTL + } + } + return s.create(body, q) + +} + +// Create makes a new session. Providing a session entry can +// customize the session. It can also be nil to use defaults. +func (s *Session) Create(se *SessionEntry, q *WriteOptions) (string, *WriteMeta, error) { + var obj interface{} + if se != nil { + body := make(map[string]interface{}) + obj = body + if se.Name != "" { + body["Name"] = se.Name + } + if se.Node != "" { + body["Node"] = se.Node + } + if se.LockDelay != 0 { + body["LockDelay"] = durToMsec(se.LockDelay) + } + if len(se.Checks) > 0 { + body["Checks"] = se.Checks + } + if se.Behavior != "" { + body["Behavior"] = se.Behavior + } + if se.TTL != "" { + body["TTL"] = se.TTL + } + } + return s.create(obj, q) +} + +func (s *Session) create(obj interface{}, q *WriteOptions) (string, *WriteMeta, error) { + var out struct{ ID string } + wm, err := s.c.write("/v1/session/create", obj, &out, q) + if err != nil { + return "", nil, err + } + return out.ID, wm, nil +} + +// Destroy invalidates a given session +func (s *Session) Destroy(id string, q *WriteOptions) (*WriteMeta, error) { + wm, err := s.c.write("/v1/session/destroy/"+id, nil, nil, q) + if err != nil { + return nil, err + } + return wm, nil +} + +// Renew renews the TTL on a given session +func (s *Session) Renew(id string, q *WriteOptions) (*SessionEntry, *WriteMeta, error) { + r := s.c.newRequest("PUT", "/v1/session/renew/"+id) + r.setWriteOptions(q) + rtt, resp, err := s.c.doRequest(r) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + + wm := &WriteMeta{RequestTime: rtt} + + if resp.StatusCode == 404 { + return nil, wm, nil + } else if resp.StatusCode != 200 { + return nil, nil, fmt.Errorf("Unexpected response code: %d", resp.StatusCode) + } + + var entries []*SessionEntry + if err := decodeBody(resp, &entries); err != nil { + return nil, nil, fmt.Errorf("Failed to read response: %v", err) + } + if len(entries) > 0 { + return entries[0], wm, nil + } + return nil, wm, nil +} + +// RenewPeriodic is used to periodically invoke Session.Renew on a +// session until a doneCh is closed. This is meant to be used in a long running +// goroutine to ensure a session stays valid. +func (s *Session) RenewPeriodic(initialTTL string, id string, q *WriteOptions, doneCh chan struct{}) error { + ttl, err := time.ParseDuration(initialTTL) + if err != nil { + return err + } + + waitDur := ttl / 2 + lastRenewTime := time.Now() + var lastErr error + for { + if time.Since(lastRenewTime) > ttl { + return lastErr + } + select { + case <-time.After(waitDur): + entry, _, err := s.Renew(id, q) + if err != nil { + waitDur = time.Second + lastErr = err + continue + } + if entry == nil { + return ErrSessionExpired + } + + // Handle the server updating the TTL + ttl, _ = time.ParseDuration(entry.TTL) + waitDur = ttl / 2 + lastRenewTime = time.Now() + + case <-doneCh: + // Attempt a session destroy + s.Destroy(id, q) + return nil + } + } +} + +// Info looks up a single session +func (s *Session) Info(id string, q *QueryOptions) (*SessionEntry, *QueryMeta, error) { + var entries []*SessionEntry + qm, err := s.c.query("/v1/session/info/"+id, &entries, q) + if err != nil { + return nil, nil, err + } + if len(entries) > 0 { + return entries[0], qm, nil + } + return nil, qm, nil +} + +// List gets sessions for a node +func (s *Session) Node(node string, q *QueryOptions) ([]*SessionEntry, *QueryMeta, error) { + var entries []*SessionEntry + qm, err := s.c.query("/v1/session/node/"+node, &entries, q) + if err != nil { + return nil, nil, err + } + return entries, qm, nil +} + +// List gets all active sessions +func (s *Session) List(q *QueryOptions) ([]*SessionEntry, *QueryMeta, error) { + var entries []*SessionEntry + qm, err := s.c.query("/v1/session/list", &entries, q) + if err != nil { + return nil, nil, err + } + return entries, qm, nil +} diff --git a/vendor/github.com/hashicorp/consul/api/status.go b/vendor/github.com/hashicorp/consul/api/status.go new file mode 100644 index 00000000..74ef61a6 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/api/status.go @@ -0,0 +1,43 @@ +package api + +// Status can be used to query the Status endpoints +type Status struct { + c *Client +} + +// Status returns a handle to the status endpoints +func (c *Client) Status() *Status { + return &Status{c} +} + +// Leader is used to query for a known leader +func (s *Status) Leader() (string, error) { + r := s.c.newRequest("GET", "/v1/status/leader") + _, resp, err := requireOK(s.c.doRequest(r)) + if err != nil { + return "", err + } + defer resp.Body.Close() + + var leader string + if err := decodeBody(resp, &leader); err != nil { + return "", err + } + return leader, nil +} + +// Peers is used to query for a known raft peers +func (s *Status) Peers() ([]string, error) { + r := s.c.newRequest("GET", "/v1/status/peers") + _, resp, err := requireOK(s.c.doRequest(r)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + var peers []string + if err := decodeBody(resp, &peers); err != nil { + return nil, err + } + return peers, nil +} diff --git a/vendor/github.com/hashicorp/consul/commands.go b/vendor/github.com/hashicorp/consul/commands.go new file mode 100644 index 00000000..84f0c07f --- /dev/null +++ b/vendor/github.com/hashicorp/consul/commands.go @@ -0,0 +1,156 @@ +package main + +import ( + "os" + "os/signal" + "syscall" + + "github.com/hashicorp/consul/command" + "github.com/hashicorp/consul/command/agent" + "github.com/mitchellh/cli" +) + +// Commands is the mapping of all the available Consul commands. +var Commands map[string]cli.CommandFactory + +func init() { + ui := &cli.BasicUi{Writer: os.Stdout} + + Commands = map[string]cli.CommandFactory{ + "agent": func() (cli.Command, error) { + return &agent.Command{ + Revision: GitCommit, + Version: Version, + VersionPrerelease: VersionPrerelease, + HumanVersion: GetHumanVersion(), + Ui: ui, + ShutdownCh: make(chan struct{}), + }, nil + }, + + "configtest": func() (cli.Command, error) { + return &command.ConfigTestCommand{ + Ui: ui, + }, nil + }, + + "event": func() (cli.Command, error) { + return &command.EventCommand{ + Ui: ui, + }, nil + }, + + "exec": func() (cli.Command, error) { + return &command.ExecCommand{ + ShutdownCh: makeShutdownCh(), + Ui: ui, + }, nil + }, + + "force-leave": func() (cli.Command, error) { + return &command.ForceLeaveCommand{ + Ui: ui, + }, nil + }, + + "join": func() (cli.Command, error) { + return &command.JoinCommand{ + Ui: ui, + }, nil + }, + + "keygen": func() (cli.Command, error) { + return &command.KeygenCommand{ + Ui: ui, + }, nil + }, + + "keyring": func() (cli.Command, error) { + return &command.KeyringCommand{ + Ui: ui, + }, nil + }, + + "leave": func() (cli.Command, error) { + return &command.LeaveCommand{ + Ui: ui, + }, nil + }, + + "lock": func() (cli.Command, error) { + return &command.LockCommand{ + ShutdownCh: makeShutdownCh(), + Ui: ui, + }, nil + }, + + "maint": func() (cli.Command, error) { + return &command.MaintCommand{ + Ui: ui, + }, nil + }, + + "members": func() (cli.Command, error) { + return &command.MembersCommand{ + Ui: ui, + }, nil + }, + + "monitor": func() (cli.Command, error) { + return &command.MonitorCommand{ + ShutdownCh: makeShutdownCh(), + Ui: ui, + }, nil + }, + + "info": func() (cli.Command, error) { + return &command.InfoCommand{ + Ui: ui, + }, nil + }, + + "reload": func() (cli.Command, error) { + return &command.ReloadCommand{ + Ui: ui, + }, nil + }, + + "rtt": func() (cli.Command, error) { + return &command.RTTCommand{ + Ui: ui, + }, nil + }, + + "version": func() (cli.Command, error) { + return &command.VersionCommand{ + HumanVersion: GetHumanVersion(), + Ui: ui, + }, nil + }, + + "watch": func() (cli.Command, error) { + return &command.WatchCommand{ + ShutdownCh: makeShutdownCh(), + Ui: ui, + }, nil + }, + } +} + +// makeShutdownCh returns a channel that can be used for shutdown +// notifications for commands. This channel will send a message for every +// interrupt or SIGTERM received. +func makeShutdownCh() <-chan struct{} { + resultCh := make(chan struct{}) + + signalCh := make(chan os.Signal, 4) + signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM) + go func() { + for { + <-signalCh + resultCh <- struct{}{} + } + }() + + return resultCh +} diff --git a/vendor/github.com/hashicorp/consul/main.go b/vendor/github.com/hashicorp/consul/main.go new file mode 100644 index 00000000..249e6e25 --- /dev/null +++ b/vendor/github.com/hashicorp/consul/main.go @@ -0,0 +1,53 @@ +package main + +import ( + "fmt" + "github.com/mitchellh/cli" + "io/ioutil" + "log" + "os" + + "github.com/hashicorp/consul/lib" +) + +func init() { + lib.SeedMathRand() +} + +func main() { + os.Exit(realMain()) +} + +func realMain() int { + log.SetOutput(ioutil.Discard) + + // Get the command line args. We shortcut "--version" and "-v" to + // just show the version. + args := os.Args[1:] + for _, arg := range args { + if arg == "--" { + break + } + if arg == "-v" || arg == "--version" { + newArgs := make([]string, len(args)+1) + newArgs[0] = "version" + copy(newArgs[1:], args) + args = newArgs + break + } + } + + cli := &cli.CLI{ + Args: args, + Commands: Commands, + HelpFunc: cli.BasicHelpFunc("consul"), + } + + exitCode, err := cli.Run() + if err != nil { + fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error()) + return 1 + } + + return exitCode +} diff --git a/vendor/github.com/hashicorp/consul/version.go b/vendor/github.com/hashicorp/consul/version.go new file mode 100644 index 00000000..e158f79d --- /dev/null +++ b/vendor/github.com/hashicorp/consul/version.go @@ -0,0 +1,43 @@ +package main + +import ( + "fmt" + "strings" +) + +// The git commit that was compiled. This will be filled in by the compiler. +var ( + GitCommit string + GitDescribe string +) + +// The main version number that is being run at the moment. +const Version = "0.7.0" + +// A pre-release marker for the version. If this is "" (empty string) +// then it means that it is a final release. Otherwise, this is a pre-release +// such as "dev" (in development), "beta", "rc1", etc. +const VersionPrerelease = "dev" + +// GetHumanVersion composes the parts of the version in a way that's suitable +// for displaying to humans. +func GetHumanVersion() string { + version := Version + if GitDescribe != "" { + version = GitDescribe + } + + release := VersionPrerelease + if GitDescribe == "" && release == "" { + release = "dev" + } + if release != "" { + version += fmt.Sprintf("-%s", release) + if GitCommit != "" { + version += fmt.Sprintf(" (%s)", GitCommit) + } + } + + // Strip off any single quotes added by the git information. + return strings.Replace(version, "'", "", -1) +} diff --git a/vendor/github.com/hashicorp/go-cleanhttp/LICENSE b/vendor/github.com/hashicorp/go-cleanhttp/LICENSE new file mode 100644 index 00000000..e87a115e --- /dev/null +++ b/vendor/github.com/hashicorp/go-cleanhttp/LICENSE @@ -0,0 +1,363 @@ +Mozilla Public License, version 2.0 + +1. Definitions + +1.1. "Contributor" + + means each individual or legal entity that creates, contributes to the + creation of, or owns Covered Software. + +1.2. "Contributor Version" + + means the combination of the Contributions of others (if any) used by a + Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + + means Source Code Form to which the initial Contributor has attached the + notice in Exhibit A, the Executable Form of such Source Code Form, and + Modifications of such Source Code Form, in each case including portions + thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + a. that the initial Contributor has attached the notice described in + Exhibit B to the Covered Software; or + + b. that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the terms of + a Secondary License. + +1.6. "Executable Form" + + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + + means a work that combines Covered Software with other material, in a + separate file or files, that is not Covered Software. + +1.8. "License" + + means this document. + +1.9. "Licensable" + + means having the right to grant, to the maximum extent possible, whether + at the time of the initial grant or subsequently, any and all of the + rights conveyed by this License. + +1.10. "Modifications" + + means any of the following: + + a. any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered Software; or + + b. any new file in Source Code Form that contains any Covered Software. + +1.11. "Patent Claims" of a Contributor + + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the License, + by the making, using, selling, offering for sale, having made, import, + or transfer of either its Contributions or its Contributor Version. + +1.12. "Secondary License" + + means either the GNU General Public License, Version 2.0, the GNU Lesser + General Public License, Version 2.1, the GNU Affero General Public + License, Version 3.0, or any later versions of those licenses. + +1.13. "Source Code Form" + + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that controls, is + controlled by, or is under common control with You. For purposes of this + definition, "control" means (a) the power, direct or indirect, to cause + the direction or management of such entity, whether by contract or + otherwise, or (b) ownership of more than fifty percent (50%) of the + outstanding shares or beneficial ownership of such entity. + + +2. License Grants and Conditions + +2.1. Grants + + Each Contributor hereby grants You a world-wide, royalty-free, + non-exclusive license: + + a. under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + + b. under Patent Claims of such Contributor to make, use, sell, offer for + sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + + The licenses granted in Section 2.1 with respect to any Contribution + become effective for each Contribution on the date the Contributor first + distributes such Contribution. + +2.3. Limitations on Grant Scope + + The licenses granted in this Section 2 are the only rights granted under + this License. No additional rights or licenses will be implied from the + distribution or licensing of Covered Software under this License. + Notwithstanding Section 2.1(b) above, no patent license is granted by a + Contributor: + + a. for any code that a Contributor has removed from Covered Software; or + + b. for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + + c. under Patent Claims infringed by Covered Software in the absence of + its Contributions. + + This License does not grant any rights in the trademarks, service marks, + or logos of any Contributor (except as may be necessary to comply with + the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + + No Contributor makes additional grants as a result of Your choice to + distribute the Covered Software under a subsequent version of this + License (see Section 10.2) or under the terms of a Secondary License (if + permitted under the terms of Section 3.3). + +2.5. Representation + + Each Contributor represents that the Contributor believes its + Contributions are its original creation(s) or it has sufficient rights to + grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + + This License is not intended to limit any rights You have under + applicable copyright doctrines of fair use, fair dealing, or other + equivalents. + +2.7. Conditions + + Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in + Section 2.1. + + +3. Responsibilities + +3.1. Distribution of Source Form + + All distribution of Covered Software in Source Code Form, including any + Modifications that You create or to which You contribute, must be under + the terms of this License. You must inform recipients that the Source + Code Form of the Covered Software is governed by the terms of this + License, and how they can obtain a copy of this License. You may not + attempt to alter or restrict the recipients' rights in the Source Code + Form. + +3.2. Distribution of Executable Form + + If You distribute Covered Software in Executable Form then: + + a. such Covered Software must also be made available in Source Code Form, + as described in Section 3.1, and You must inform recipients of the + Executable Form how they can obtain a copy of such Source Code Form by + reasonable means in a timely manner, at a charge no more than the cost + of distribution to the recipient; and + + b. You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter the + recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + + You may create and distribute a Larger Work under terms of Your choice, + provided that You also comply with the requirements of this License for + the Covered Software. If the Larger Work is a combination of Covered + Software with a work governed by one or more Secondary Licenses, and the + Covered Software is not Incompatible With Secondary Licenses, this + License permits You to additionally distribute such Covered Software + under the terms of such Secondary License(s), so that the recipient of + the Larger Work may, at their option, further distribute the Covered + Software under the terms of either this License or such Secondary + License(s). + +3.4. Notices + + You may not remove or alter the substance of any license notices + (including copyright notices, patent notices, disclaimers of warranty, or + limitations of liability) contained within the Source Code Form of the + Covered Software, except that You may alter any license notices to the + extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + + You may choose to offer, and to charge a fee for, warranty, support, + indemnity or liability obligations to one or more recipients of Covered + Software. However, You may do so only on Your own behalf, and not on + behalf of any Contributor. You must make it absolutely clear that any + such warranty, support, indemnity, or liability obligation is offered by + You alone, and You hereby agree to indemnify every Contributor for any + liability incurred by such Contributor as a result of warranty, support, + indemnity or liability terms You offer. You may include additional + disclaimers of warranty and limitations of liability specific to any + jurisdiction. + +4. Inability to Comply Due to Statute or Regulation + + If it is impossible for You to comply with any of the terms of this License + with respect to some or all of the Covered Software due to statute, + judicial order, or regulation then You must: (a) comply with the terms of + this License to the maximum extent possible; and (b) describe the + limitations and the code they affect. Such description must be placed in a + text file included with all distributions of the Covered Software under + this License. Except to the extent prohibited by statute or regulation, + such description must be sufficiently detailed for a recipient of ordinary + skill to be able to understand it. + +5. Termination + +5.1. The rights granted under this License will terminate automatically if You + fail to comply with any of its terms. However, if You become compliant, + then the rights granted under this License from a particular Contributor + are reinstated (a) provisionally, unless and until such Contributor + explicitly and finally terminates Your grants, and (b) on an ongoing + basis, if such Contributor fails to notify You of the non-compliance by + some reasonable means prior to 60 days after You have come back into + compliance. Moreover, Your grants from a particular Contributor are + reinstated on an ongoing basis if such Contributor notifies You of the + non-compliance by some reasonable means, this is the first time You have + received notice of non-compliance with this License from such + Contributor, and You become compliant prior to 30 days after Your receipt + of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent + infringement claim (excluding declaratory judgment actions, + counter-claims, and cross-claims) alleging that a Contributor Version + directly or indirectly infringes any patent, then the rights granted to + You by any and all Contributors for the Covered Software under Section + 2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user + license agreements (excluding distributors and resellers) which have been + validly granted by You or Your distributors under this License prior to + termination shall survive termination. + +6. Disclaimer of Warranty + + Covered Software is provided under this License on an "as is" basis, + without warranty of any kind, either expressed, implied, or statutory, + including, without limitation, warranties that the Covered Software is free + of defects, merchantable, fit for a particular purpose or non-infringing. + The entire risk as to the quality and performance of the Covered Software + is with You. Should any Covered Software prove defective in any respect, + You (not any Contributor) assume the cost of any necessary servicing, + repair, or correction. This disclaimer of warranty constitutes an essential + part of this License. No use of any Covered Software is authorized under + this License except under this disclaimer. + +7. Limitation of Liability + + Under no circumstances and under no legal theory, whether tort (including + negligence), contract, or otherwise, shall any Contributor, or anyone who + distributes Covered Software as permitted above, be liable to You for any + direct, indirect, special, incidental, or consequential damages of any + character including, without limitation, damages for lost profits, loss of + goodwill, work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses, even if such party shall have been + informed of the possibility of such damages. This limitation of liability + shall not apply to liability for death or personal injury resulting from + such party's negligence to the extent applicable law prohibits such + limitation. Some jurisdictions do not allow the exclusion or limitation of + incidental or consequential damages, so this exclusion and limitation may + not apply to You. + +8. Litigation + + Any litigation relating to this License may be brought only in the courts + of a jurisdiction where the defendant maintains its principal place of + business and such litigation shall be governed by laws of that + jurisdiction, without reference to its conflict-of-law provisions. Nothing + in this Section shall prevent a party's ability to bring cross-claims or + counter-claims. + +9. Miscellaneous + + This License represents the complete agreement concerning the subject + matter hereof. If any provision of this License is held to be + unenforceable, such provision shall be reformed only to the extent + necessary to make it enforceable. Any law or regulation which provides that + the language of a contract shall be construed against the drafter shall not + be used to construe this License against a Contributor. + + +10. Versions of the License + +10.1. New Versions + + Mozilla Foundation is the license steward. Except as provided in Section + 10.3, no one other than the license steward has the right to modify or + publish new versions of this License. Each version will be given a + distinguishing version number. + +10.2. Effect of New Versions + + You may distribute the Covered Software under the terms of the version + of the License under which You originally received the Covered Software, + or under the terms of any subsequent version published by the license + steward. + +10.3. Modified Versions + + If you create software not governed by this License, and you want to + create a new license for such software, you may create and use a + modified version of this License if you rename the license and remove + any references to the name of the license steward (except to note that + such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary + Licenses If You choose to distribute Source Code Form that is + Incompatible With Secondary Licenses under the terms of this version of + the License, the notice described in Exhibit B of this License must be + attached. + +Exhibit A - Source Code Form License Notice + + This Source Code Form is subject to the + terms of the Mozilla Public License, v. + 2.0. If a copy of the MPL was not + distributed with this file, You can + obtain one at + http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular file, +then You may include the notice in a location (such as a LICENSE file in a +relevant directory) where a recipient would be likely to look for such a +notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice + + This Source Code Form is "Incompatible + With Secondary Licenses", as defined by + the Mozilla Public License, v. 2.0. + diff --git a/vendor/github.com/hashicorp/go-cleanhttp/cleanhttp.go b/vendor/github.com/hashicorp/go-cleanhttp/cleanhttp.go new file mode 100644 index 00000000..f4596d80 --- /dev/null +++ b/vendor/github.com/hashicorp/go-cleanhttp/cleanhttp.go @@ -0,0 +1,53 @@ +package cleanhttp + +import ( + "net" + "net/http" + "time" +) + +// DefaultTransport returns a new http.Transport with the same default values +// as http.DefaultTransport, but with idle connections and keepalives disabled. +func DefaultTransport() *http.Transport { + transport := DefaultPooledTransport() + transport.DisableKeepAlives = true + transport.MaxIdleConnsPerHost = -1 + return transport +} + +// DefaultPooledTransport returns a new http.Transport with similar default +// values to http.DefaultTransport. Do not use this for transient transports as +// it can leak file descriptors over time. Only use this for transports that +// will be re-used for the same host(s). +func DefaultPooledTransport() *http.Transport { + transport := &http.Transport{ + Proxy: http.ProxyFromEnvironment, + Dial: (&net.Dialer{ + Timeout: 30 * time.Second, + KeepAlive: 30 * time.Second, + }).Dial, + TLSHandshakeTimeout: 10 * time.Second, + DisableKeepAlives: false, + MaxIdleConnsPerHost: 1, + } + return transport +} + +// DefaultClient returns a new http.Client with similar default values to +// http.Client, but with a non-shared Transport, idle connections disabled, and +// keepalives disabled. +func DefaultClient() *http.Client { + return &http.Client{ + Transport: DefaultTransport(), + } +} + +// DefaultPooledClient returns a new http.Client with the same default values +// as http.Client, but with a shared Transport. Do not use this function +// for transient clients as it can leak file descriptors over time. Only use +// this for clients that will be re-used for the same host(s). +func DefaultPooledClient() *http.Client { + return &http.Client{ + Transport: DefaultPooledTransport(), + } +} diff --git a/vendor/github.com/hashicorp/go-cleanhttp/doc.go b/vendor/github.com/hashicorp/go-cleanhttp/doc.go new file mode 100644 index 00000000..05841092 --- /dev/null +++ b/vendor/github.com/hashicorp/go-cleanhttp/doc.go @@ -0,0 +1,20 @@ +// Package cleanhttp offers convenience utilities for acquiring "clean" +// http.Transport and http.Client structs. +// +// Values set on http.DefaultClient and http.DefaultTransport affect all +// callers. This can have detrimental effects, esepcially in TLS contexts, +// where client or root certificates set to talk to multiple endpoints can end +// up displacing each other, leading to hard-to-debug issues. This package +// provides non-shared http.Client and http.Transport structs to ensure that +// the configuration will not be overwritten by other parts of the application +// or dependencies. +// +// The DefaultClient and DefaultTransport functions disable idle connections +// and keepalives. Without ensuring that idle connections are closed before +// garbage collection, short-term clients/transports can leak file descriptors, +// eventually leading to "too many open files" errors. If you will be +// connecting to the same hosts repeatedly from the same client, you can use +// DefaultPooledClient to receive a client that has connection pooling +// semantics similar to http.DefaultClient. +// +package cleanhttp diff --git a/vendor/github.com/hashicorp/serf/LICENSE b/vendor/github.com/hashicorp/serf/LICENSE new file mode 100644 index 00000000..c33dcc7c --- /dev/null +++ b/vendor/github.com/hashicorp/serf/LICENSE @@ -0,0 +1,354 @@ +Mozilla Public License, version 2.0 + +1. Definitions + +1.1. “Contributor” + + means each individual or legal entity that creates, contributes to the + creation of, or owns Covered Software. + +1.2. “Contributor Version” + + means the combination of the Contributions of others (if any) used by a + Contributor and that particular Contributor’s Contribution. + +1.3. “Contribution” + + means Covered Software of a particular Contributor. + +1.4. “Covered Software” + + means Source Code Form to which the initial Contributor has attached the + notice in Exhibit A, the Executable Form of such Source Code Form, and + Modifications of such Source Code Form, in each case including portions + thereof. + +1.5. “Incompatible With Secondary Licenses” + means + + a. that the initial Contributor has attached the notice described in + Exhibit B to the Covered Software; or + + b. that the Covered Software was made available under the terms of version + 1.1 or earlier of the License, but not also under the terms of a + Secondary License. + +1.6. “Executable Form” + + means any form of the work other than Source Code Form. + +1.7. “Larger Work” + + means a work that combines Covered Software with other material, in a separate + file or files, that is not Covered Software. + +1.8. “License” + + means this document. + +1.9. “Licensable” + + means having the right to grant, to the maximum extent possible, whether at the + time of the initial grant or subsequently, any and all of the rights conveyed by + this License. + +1.10. “Modifications” + + means any of the following: + + a. any file in Source Code Form that results from an addition to, deletion + from, or modification of the contents of Covered Software; or + + b. any new file in Source Code Form that contains any Covered Software. + +1.11. “Patent Claims” of a Contributor + + means any patent claim(s), including without limitation, method, process, + and apparatus claims, in any patent Licensable by such Contributor that + would be infringed, but for the grant of the License, by the making, + using, selling, offering for sale, having made, import, or transfer of + either its Contributions or its Contributor Version. + +1.12. “Secondary License” + + means either the GNU General Public License, Version 2.0, the GNU Lesser + General Public License, Version 2.1, the GNU Affero General Public + License, Version 3.0, or any later versions of those licenses. + +1.13. “Source Code Form” + + means the form of the work preferred for making modifications. + +1.14. “You” (or “Your”) + + means an individual or a legal entity exercising rights under this + License. For legal entities, “You” includes any entity that controls, is + controlled by, or is under common control with You. For purposes of this + definition, “control” means (a) the power, direct or indirect, to cause + the direction or management of such entity, whether by contract or + otherwise, or (b) ownership of more than fifty percent (50%) of the + outstanding shares or beneficial ownership of such entity. + + +2. License Grants and Conditions + +2.1. Grants + + Each Contributor hereby grants You a world-wide, royalty-free, + non-exclusive license: + + a. under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or as + part of a Larger Work; and + + b. under Patent Claims of such Contributor to make, use, sell, offer for + sale, have made, import, and otherwise transfer either its Contributions + or its Contributor Version. + +2.2. Effective Date + + The licenses granted in Section 2.1 with respect to any Contribution become + effective for each Contribution on the date the Contributor first distributes + such Contribution. + +2.3. Limitations on Grant Scope + + The licenses granted in this Section 2 are the only rights granted under this + License. No additional rights or licenses will be implied from the distribution + or licensing of Covered Software under this License. Notwithstanding Section + 2.1(b) above, no patent license is granted by a Contributor: + + a. for any code that a Contributor has removed from Covered Software; or + + b. for infringements caused by: (i) Your and any other third party’s + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + + c. under Patent Claims infringed by Covered Software in the absence of its + Contributions. + + This License does not grant any rights in the trademarks, service marks, or + logos of any Contributor (except as may be necessary to comply with the + notice requirements in Section 3.4). + +2.4. Subsequent Licenses + + No Contributor makes additional grants as a result of Your choice to + distribute the Covered Software under a subsequent version of this License + (see Section 10.2) or under the terms of a Secondary License (if permitted + under the terms of Section 3.3). + +2.5. Representation + + Each Contributor represents that the Contributor believes its Contributions + are its original creation(s) or it has sufficient rights to grant the + rights to its Contributions conveyed by this License. + +2.6. Fair Use + + This License is not intended to limit any rights You have under applicable + copyright doctrines of fair use, fair dealing, or other equivalents. + +2.7. Conditions + + Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in + Section 2.1. + + +3. Responsibilities + +3.1. Distribution of Source Form + + All distribution of Covered Software in Source Code Form, including any + Modifications that You create or to which You contribute, must be under the + terms of this License. You must inform recipients that the Source Code Form + of the Covered Software is governed by the terms of this License, and how + they can obtain a copy of this License. You may not attempt to alter or + restrict the recipients’ rights in the Source Code Form. + +3.2. Distribution of Executable Form + + If You distribute Covered Software in Executable Form then: + + a. such Covered Software must also be made available in Source Code Form, + as described in Section 3.1, and You must inform recipients of the + Executable Form how they can obtain a copy of such Source Code Form by + reasonable means in a timely manner, at a charge no more than the cost + of distribution to the recipient; and + + b. You may distribute such Executable Form under the terms of this License, + or sublicense it under different terms, provided that the license for + the Executable Form does not attempt to limit or alter the recipients’ + rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + + You may create and distribute a Larger Work under terms of Your choice, + provided that You also comply with the requirements of this License for the + Covered Software. If the Larger Work is a combination of Covered Software + with a work governed by one or more Secondary Licenses, and the Covered + Software is not Incompatible With Secondary Licenses, this License permits + You to additionally distribute such Covered Software under the terms of + such Secondary License(s), so that the recipient of the Larger Work may, at + their option, further distribute the Covered Software under the terms of + either this License or such Secondary License(s). + +3.4. Notices + + You may not remove or alter the substance of any license notices (including + copyright notices, patent notices, disclaimers of warranty, or limitations + of liability) contained within the Source Code Form of the Covered + Software, except that You may alter any license notices to the extent + required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + + You may choose to offer, and to charge a fee for, warranty, support, + indemnity or liability obligations to one or more recipients of Covered + Software. However, You may do so only on Your own behalf, and not on behalf + of any Contributor. You must make it absolutely clear that any such + warranty, support, indemnity, or liability obligation is offered by You + alone, and You hereby agree to indemnify every Contributor for any + liability incurred by such Contributor as a result of warranty, support, + indemnity or liability terms You offer. You may include additional + disclaimers of warranty and limitations of liability specific to any + jurisdiction. + +4. Inability to Comply Due to Statute or Regulation + + If it is impossible for You to comply with any of the terms of this License + with respect to some or all of the Covered Software due to statute, judicial + order, or regulation then You must: (a) comply with the terms of this License + to the maximum extent possible; and (b) describe the limitations and the code + they affect. Such description must be placed in a text file included with all + distributions of the Covered Software under this License. Except to the + extent prohibited by statute or regulation, such description must be + sufficiently detailed for a recipient of ordinary skill to be able to + understand it. + +5. Termination + +5.1. The rights granted under this License will terminate automatically if You + fail to comply with any of its terms. However, if You become compliant, + then the rights granted under this License from a particular Contributor + are reinstated (a) provisionally, unless and until such Contributor + explicitly and finally terminates Your grants, and (b) on an ongoing basis, + if such Contributor fails to notify You of the non-compliance by some + reasonable means prior to 60 days after You have come back into compliance. + Moreover, Your grants from a particular Contributor are reinstated on an + ongoing basis if such Contributor notifies You of the non-compliance by + some reasonable means, this is the first time You have received notice of + non-compliance with this License from such Contributor, and You become + compliant prior to 30 days after Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent + infringement claim (excluding declaratory judgment actions, counter-claims, + and cross-claims) alleging that a Contributor Version directly or + indirectly infringes any patent, then the rights granted to You by any and + all Contributors for the Covered Software under Section 2.1 of this License + shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user + license agreements (excluding distributors and resellers) which have been + validly granted by You or Your distributors under this License prior to + termination shall survive termination. + +6. Disclaimer of Warranty + + Covered Software is provided under this License on an “as is” basis, without + warranty of any kind, either expressed, implied, or statutory, including, + without limitation, warranties that the Covered Software is free of defects, + merchantable, fit for a particular purpose or non-infringing. The entire + risk as to the quality and performance of the Covered Software is with You. + Should any Covered Software prove defective in any respect, You (not any + Contributor) assume the cost of any necessary servicing, repair, or + correction. This disclaimer of warranty constitutes an essential part of this + License. No use of any Covered Software is authorized under this License + except under this disclaimer. + +7. Limitation of Liability + + Under no circumstances and under no legal theory, whether tort (including + negligence), contract, or otherwise, shall any Contributor, or anyone who + distributes Covered Software as permitted above, be liable to You for any + direct, indirect, special, incidental, or consequential damages of any + character including, without limitation, damages for lost profits, loss of + goodwill, work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses, even if such party shall have been + informed of the possibility of such damages. This limitation of liability + shall not apply to liability for death or personal injury resulting from such + party’s negligence to the extent applicable law prohibits such limitation. + Some jurisdictions do not allow the exclusion or limitation of incidental or + consequential damages, so this exclusion and limitation may not apply to You. + +8. Litigation + + Any litigation relating to this License may be brought only in the courts of + a jurisdiction where the defendant maintains its principal place of business + and such litigation shall be governed by laws of that jurisdiction, without + reference to its conflict-of-law provisions. Nothing in this Section shall + prevent a party’s ability to bring cross-claims or counter-claims. + +9. Miscellaneous + + This License represents the complete agreement concerning the subject matter + hereof. If any provision of this License is held to be unenforceable, such + provision shall be reformed only to the extent necessary to make it + enforceable. Any law or regulation which provides that the language of a + contract shall be construed against the drafter shall not be used to construe + this License against a Contributor. + + +10. Versions of the License + +10.1. New Versions + + Mozilla Foundation is the license steward. Except as provided in Section + 10.3, no one other than the license steward has the right to modify or + publish new versions of this License. Each version will be given a + distinguishing version number. + +10.2. Effect of New Versions + + You may distribute the Covered Software under the terms of the version of + the License under which You originally received the Covered Software, or + under the terms of any subsequent version published by the license + steward. + +10.3. Modified Versions + + If you create software not governed by this License, and you want to + create a new license for such software, you may create and use a modified + version of this License if you rename the license and remove any + references to the name of the license steward (except to note that such + modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses + If You choose to distribute Source Code Form that is Incompatible With + Secondary Licenses under the terms of this version of the License, the + notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice + + This Source Code Form is subject to the + terms of the Mozilla Public License, v. + 2.0. If a copy of the MPL was not + distributed with this file, You can + obtain one at + http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular file, then +You may include the notice in a location (such as a LICENSE file in a relevant +directory) where a recipient would be likely to look for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - “Incompatible With Secondary Licenses” Notice + + This Source Code Form is “Incompatible + With Secondary Licenses”, as defined by + the Mozilla Public License, v. 2.0. + diff --git a/vendor/github.com/hashicorp/serf/coordinate/client.go b/vendor/github.com/hashicorp/serf/coordinate/client.go new file mode 100644 index 00000000..613bfff8 --- /dev/null +++ b/vendor/github.com/hashicorp/serf/coordinate/client.go @@ -0,0 +1,180 @@ +package coordinate + +import ( + "fmt" + "math" + "sort" + "sync" + "time" +) + +// Client manages the estimated network coordinate for a given node, and adjusts +// it as the node observes round trip times and estimated coordinates from other +// nodes. The core algorithm is based on Vivaldi, see the documentation for Config +// for more details. +type Client struct { + // coord is the current estimate of the client's network coordinate. + coord *Coordinate + + // origin is a coordinate sitting at the origin. + origin *Coordinate + + // config contains the tuning parameters that govern the performance of + // the algorithm. + config *Config + + // adjustmentIndex is the current index into the adjustmentSamples slice. + adjustmentIndex uint + + // adjustment is used to store samples for the adjustment calculation. + adjustmentSamples []float64 + + // latencyFilterSamples is used to store the last several RTT samples, + // keyed by node name. We will use the config's LatencyFilterSamples + // value to determine how many samples we keep, per node. + latencyFilterSamples map[string][]float64 + + // mutex enables safe concurrent access to the client. + mutex sync.RWMutex +} + +// NewClient creates a new Client and verifies the configuration is valid. +func NewClient(config *Config) (*Client, error) { + if !(config.Dimensionality > 0) { + return nil, fmt.Errorf("dimensionality must be >0") + } + + return &Client{ + coord: NewCoordinate(config), + origin: NewCoordinate(config), + config: config, + adjustmentIndex: 0, + adjustmentSamples: make([]float64, config.AdjustmentWindowSize), + latencyFilterSamples: make(map[string][]float64), + }, nil +} + +// GetCoordinate returns a copy of the coordinate for this client. +func (c *Client) GetCoordinate() *Coordinate { + c.mutex.RLock() + defer c.mutex.RUnlock() + + return c.coord.Clone() +} + +// SetCoordinate forces the client's coordinate to a known state. +func (c *Client) SetCoordinate(coord *Coordinate) { + c.mutex.Lock() + defer c.mutex.Unlock() + + c.coord = coord.Clone() +} + +// ForgetNode removes any client state for the given node. +func (c *Client) ForgetNode(node string) { + c.mutex.Lock() + defer c.mutex.Unlock() + + delete(c.latencyFilterSamples, node) +} + +// latencyFilter applies a simple moving median filter with a new sample for +// a node. This assumes that the mutex has been locked already. +func (c *Client) latencyFilter(node string, rttSeconds float64) float64 { + samples, ok := c.latencyFilterSamples[node] + if !ok { + samples = make([]float64, 0, c.config.LatencyFilterSize) + } + + // Add the new sample and trim the list, if needed. + samples = append(samples, rttSeconds) + if len(samples) > int(c.config.LatencyFilterSize) { + samples = samples[1:] + } + c.latencyFilterSamples[node] = samples + + // Sort a copy of the samples and return the median. + sorted := make([]float64, len(samples)) + copy(sorted, samples) + sort.Float64s(sorted) + return sorted[len(sorted)/2] +} + +// updateVivialdi updates the Vivaldi portion of the client's coordinate. This +// assumes that the mutex has been locked already. +func (c *Client) updateVivaldi(other *Coordinate, rttSeconds float64) { + const zeroThreshold = 1.0e-6 + + dist := c.coord.DistanceTo(other).Seconds() + if rttSeconds < zeroThreshold { + rttSeconds = zeroThreshold + } + wrongness := math.Abs(dist-rttSeconds) / rttSeconds + + totalError := c.coord.Error + other.Error + if totalError < zeroThreshold { + totalError = zeroThreshold + } + weight := c.coord.Error / totalError + + c.coord.Error = c.config.VivaldiCE*weight*wrongness + c.coord.Error*(1.0-c.config.VivaldiCE*weight) + if c.coord.Error > c.config.VivaldiErrorMax { + c.coord.Error = c.config.VivaldiErrorMax + } + + delta := c.config.VivaldiCC * weight + force := delta * (rttSeconds - dist) + c.coord = c.coord.ApplyForce(c.config, force, other) +} + +// updateAdjustment updates the adjustment portion of the client's coordinate, if +// the feature is enabled. This assumes that the mutex has been locked already. +func (c *Client) updateAdjustment(other *Coordinate, rttSeconds float64) { + if c.config.AdjustmentWindowSize == 0 { + return + } + + // Note that the existing adjustment factors don't figure in to this + // calculation so we use the raw distance here. + dist := c.coord.rawDistanceTo(other) + c.adjustmentSamples[c.adjustmentIndex] = rttSeconds - dist + c.adjustmentIndex = (c.adjustmentIndex + 1) % c.config.AdjustmentWindowSize + + sum := 0.0 + for _, sample := range c.adjustmentSamples { + sum += sample + } + c.coord.Adjustment = sum / (2.0 * float64(c.config.AdjustmentWindowSize)) +} + +// updateGravity applies a small amount of gravity to pull coordinates towards +// the center of the coordinate system to combat drift. This assumes that the +// mutex is locked already. +func (c *Client) updateGravity() { + dist := c.origin.DistanceTo(c.coord).Seconds() + force := -1.0 * math.Pow(dist/c.config.GravityRho, 2.0) + c.coord = c.coord.ApplyForce(c.config, force, c.origin) +} + +// Update takes other, a coordinate for another node, and rtt, a round trip +// time observation for a ping to that node, and updates the estimated position of +// the client's coordinate. Returns the updated coordinate. +func (c *Client) Update(node string, other *Coordinate, rtt time.Duration) *Coordinate { + c.mutex.Lock() + defer c.mutex.Unlock() + + rttSeconds := c.latencyFilter(node, rtt.Seconds()) + c.updateVivaldi(other, rttSeconds) + c.updateAdjustment(other, rttSeconds) + c.updateGravity() + return c.coord.Clone() +} + +// DistanceTo returns the estimated RTT from the client's coordinate to other, the +// coordinate for another node. +func (c *Client) DistanceTo(other *Coordinate) time.Duration { + c.mutex.RLock() + defer c.mutex.RUnlock() + + return c.coord.DistanceTo(other) +} diff --git a/vendor/github.com/hashicorp/serf/coordinate/config.go b/vendor/github.com/hashicorp/serf/coordinate/config.go new file mode 100644 index 00000000..b85a8ab7 --- /dev/null +++ b/vendor/github.com/hashicorp/serf/coordinate/config.go @@ -0,0 +1,70 @@ +package coordinate + +// Config is used to set the parameters of the Vivaldi-based coordinate mapping +// algorithm. +// +// The following references are called out at various points in the documentation +// here: +// +// [1] Dabek, Frank, et al. "Vivaldi: A decentralized network coordinate system." +// ACM SIGCOMM Computer Communication Review. Vol. 34. No. 4. ACM, 2004. +// [2] Ledlie, Jonathan, Paul Gardner, and Margo I. Seltzer. "Network Coordinates +// in the Wild." NSDI. Vol. 7. 2007. +// [3] Lee, Sanghwan, et al. "On suitability of Euclidean embedding for +// host-based network coordinate systems." Networking, IEEE/ACM Transactions +// on 18.1 (2010): 27-40. +type Config struct { + // The dimensionality of the coordinate system. As discussed in [2], more + // dimensions improves the accuracy of the estimates up to a point. Per [2] + // we chose 8 dimensions plus a non-Euclidean height. + Dimensionality uint + + // VivaldiErrorMax is the default error value when a node hasn't yet made + // any observations. It also serves as an upper limit on the error value in + // case observations cause the error value to increase without bound. + VivaldiErrorMax float64 + + // VivaldiCE is a tuning factor that controls the maximum impact an + // observation can have on a node's confidence. See [1] for more details. + VivaldiCE float64 + + // VivaldiCC is a tuning factor that controls the maximum impact an + // observation can have on a node's coordinate. See [1] for more details. + VivaldiCC float64 + + // AdjustmentWindowSize is a tuning factor that determines how many samples + // we retain to calculate the adjustment factor as discussed in [3]. Setting + // this to zero disables this feature. + AdjustmentWindowSize uint + + // HeightMin is the minimum value of the height parameter. Since this + // always must be positive, it will introduce a small amount error, so + // the chosen value should be relatively small compared to "normal" + // coordinates. + HeightMin float64 + + // LatencyFilterSamples is the maximum number of samples that are retained + // per node, in order to compute a median. The intent is to ride out blips + // but still keep the delay low, since our time to probe any given node is + // pretty infrequent. See [2] for more details. + LatencyFilterSize uint + + // GravityRho is a tuning factor that sets how much gravity has an effect + // to try to re-center coordinates. See [2] for more details. + GravityRho float64 +} + +// DefaultConfig returns a Config that has some default values suitable for +// basic testing of the algorithm, but not tuned to any particular type of cluster. +func DefaultConfig() *Config { + return &Config{ + Dimensionality: 8, + VivaldiErrorMax: 1.5, + VivaldiCE: 0.25, + VivaldiCC: 0.25, + AdjustmentWindowSize: 20, + HeightMin: 10.0e-6, + LatencyFilterSize: 3, + GravityRho: 150.0, + } +} diff --git a/vendor/github.com/hashicorp/serf/coordinate/coordinate.go b/vendor/github.com/hashicorp/serf/coordinate/coordinate.go new file mode 100644 index 00000000..c9194e04 --- /dev/null +++ b/vendor/github.com/hashicorp/serf/coordinate/coordinate.go @@ -0,0 +1,183 @@ +package coordinate + +import ( + "math" + "math/rand" + "time" +) + +// Coordinate is a specialized structure for holding network coordinates for the +// Vivaldi-based coordinate mapping algorithm. All of the fields should be public +// to enable this to be serialized. All values in here are in units of seconds. +type Coordinate struct { + // Vec is the Euclidean portion of the coordinate. This is used along + // with the other fields to provide an overall distance estimate. The + // units here are seconds. + Vec []float64 + + // Err reflects the confidence in the given coordinate and is updated + // dynamically by the Vivaldi Client. This is dimensionless. + Error float64 + + // Adjustment is a distance offset computed based on a calculation over + // observations from all other nodes over a fixed window and is updated + // dynamically by the Vivaldi Client. The units here are seconds. + Adjustment float64 + + // Height is a distance offset that accounts for non-Euclidean effects + // which model the access links from nodes to the core Internet. The access + // links are usually set by bandwidth and congestion, and the core links + // usually follow distance based on geography. + Height float64 +} + +const ( + // secondsToNanoseconds is used to convert float seconds to nanoseconds. + secondsToNanoseconds = 1.0e9 + + // zeroThreshold is used to decide if two coordinates are on top of each + // other. + zeroThreshold = 1.0e-6 +) + +// ErrDimensionalityConflict will be panic-d if you try to perform operations +// with incompatible dimensions. +type DimensionalityConflictError struct{} + +// Adds the error interface. +func (e DimensionalityConflictError) Error() string { + return "coordinate dimensionality does not match" +} + +// NewCoordinate creates a new coordinate at the origin, using the given config +// to supply key initial values. +func NewCoordinate(config *Config) *Coordinate { + return &Coordinate{ + Vec: make([]float64, config.Dimensionality), + Error: config.VivaldiErrorMax, + Adjustment: 0.0, + Height: config.HeightMin, + } +} + +// Clone creates an independent copy of this coordinate. +func (c *Coordinate) Clone() *Coordinate { + vec := make([]float64, len(c.Vec)) + copy(vec, c.Vec) + return &Coordinate{ + Vec: vec, + Error: c.Error, + Adjustment: c.Adjustment, + Height: c.Height, + } +} + +// IsCompatibleWith checks to see if the two coordinates are compatible +// dimensionally. If this returns true then you are guaranteed to not get +// any runtime errors operating on them. +func (c *Coordinate) IsCompatibleWith(other *Coordinate) bool { + return len(c.Vec) == len(other.Vec) +} + +// ApplyForce returns the result of applying the force from the direction of the +// other coordinate. +func (c *Coordinate) ApplyForce(config *Config, force float64, other *Coordinate) *Coordinate { + if !c.IsCompatibleWith(other) { + panic(DimensionalityConflictError{}) + } + + ret := c.Clone() + unit, mag := unitVectorAt(c.Vec, other.Vec) + ret.Vec = add(ret.Vec, mul(unit, force)) + if mag > zeroThreshold { + ret.Height = (ret.Height+other.Height)*force/mag + ret.Height + ret.Height = math.Max(ret.Height, config.HeightMin) + } + return ret +} + +// DistanceTo returns the distance between this coordinate and the other +// coordinate, including adjustments. +func (c *Coordinate) DistanceTo(other *Coordinate) time.Duration { + if !c.IsCompatibleWith(other) { + panic(DimensionalityConflictError{}) + } + + dist := c.rawDistanceTo(other) + adjustedDist := dist + c.Adjustment + other.Adjustment + if adjustedDist > 0.0 { + dist = adjustedDist + } + return time.Duration(dist * secondsToNanoseconds) +} + +// rawDistanceTo returns the Vivaldi distance between this coordinate and the +// other coordinate in seconds, not including adjustments. This assumes the +// dimensions have already been checked to be compatible. +func (c *Coordinate) rawDistanceTo(other *Coordinate) float64 { + return magnitude(diff(c.Vec, other.Vec)) + c.Height + other.Height +} + +// add returns the sum of vec1 and vec2. This assumes the dimensions have +// already been checked to be compatible. +func add(vec1 []float64, vec2 []float64) []float64 { + ret := make([]float64, len(vec1)) + for i, _ := range ret { + ret[i] = vec1[i] + vec2[i] + } + return ret +} + +// diff returns the difference between the vec1 and vec2. This assumes the +// dimensions have already been checked to be compatible. +func diff(vec1 []float64, vec2 []float64) []float64 { + ret := make([]float64, len(vec1)) + for i, _ := range ret { + ret[i] = vec1[i] - vec2[i] + } + return ret +} + +// mul returns vec multiplied by a scalar factor. +func mul(vec []float64, factor float64) []float64 { + ret := make([]float64, len(vec)) + for i, _ := range vec { + ret[i] = vec[i] * factor + } + return ret +} + +// magnitude computes the magnitude of the vec. +func magnitude(vec []float64) float64 { + sum := 0.0 + for i, _ := range vec { + sum += vec[i] * vec[i] + } + return math.Sqrt(sum) +} + +// unitVectorAt returns a unit vector pointing at vec1 from vec2. If the two +// positions are the same then a random unit vector is returned. We also return +// the distance between the points for use in the later height calculation. +func unitVectorAt(vec1 []float64, vec2 []float64) ([]float64, float64) { + ret := diff(vec1, vec2) + + // If the coordinates aren't on top of each other we can normalize. + if mag := magnitude(ret); mag > zeroThreshold { + return mul(ret, 1.0/mag), mag + } + + // Otherwise, just return a random unit vector. + for i, _ := range ret { + ret[i] = rand.Float64() - 0.5 + } + if mag := magnitude(ret); mag > zeroThreshold { + return mul(ret, 1.0/mag), 0.0 + } + + // And finally just give up and make a unit vector along the first + // dimension. This should be exceedingly rare. + ret = make([]float64, len(ret)) + ret[0] = 1.0 + return ret, 0.0 +} diff --git a/vendor/github.com/hashicorp/serf/coordinate/phantom.go b/vendor/github.com/hashicorp/serf/coordinate/phantom.go new file mode 100644 index 00000000..6fb033c0 --- /dev/null +++ b/vendor/github.com/hashicorp/serf/coordinate/phantom.go @@ -0,0 +1,187 @@ +package coordinate + +import ( + "fmt" + "math" + "math/rand" + "time" +) + +// GenerateClients returns a slice with nodes number of clients, all with the +// given config. +func GenerateClients(nodes int, config *Config) ([]*Client, error) { + clients := make([]*Client, nodes) + for i, _ := range clients { + client, err := NewClient(config) + if err != nil { + return nil, err + } + + clients[i] = client + } + return clients, nil +} + +// GenerateLine returns a truth matrix as if all the nodes are in a straight linke +// with the given spacing between them. +func GenerateLine(nodes int, spacing time.Duration) [][]time.Duration { + truth := make([][]time.Duration, nodes) + for i := range truth { + truth[i] = make([]time.Duration, nodes) + } + + for i := 0; i < nodes; i++ { + for j := i + 1; j < nodes; j++ { + rtt := time.Duration(j-i) * spacing + truth[i][j], truth[j][i] = rtt, rtt + } + } + return truth +} + +// GenerateGrid returns a truth matrix as if all the nodes are in a two dimensional +// grid with the given spacing between them. +func GenerateGrid(nodes int, spacing time.Duration) [][]time.Duration { + truth := make([][]time.Duration, nodes) + for i := range truth { + truth[i] = make([]time.Duration, nodes) + } + + n := int(math.Sqrt(float64(nodes))) + for i := 0; i < nodes; i++ { + for j := i + 1; j < nodes; j++ { + x1, y1 := float64(i%n), float64(i/n) + x2, y2 := float64(j%n), float64(j/n) + dx, dy := x2-x1, y2-y1 + dist := math.Sqrt(dx*dx + dy*dy) + rtt := time.Duration(dist * float64(spacing)) + truth[i][j], truth[j][i] = rtt, rtt + } + } + return truth +} + +// GenerateSplit returns a truth matrix as if half the nodes are close together in +// one location and half the nodes are close together in another. The lan factor +// is used to separate the nodes locally and the wan factor represents the split +// between the two sides. +func GenerateSplit(nodes int, lan time.Duration, wan time.Duration) [][]time.Duration { + truth := make([][]time.Duration, nodes) + for i := range truth { + truth[i] = make([]time.Duration, nodes) + } + + split := nodes / 2 + for i := 0; i < nodes; i++ { + for j := i + 1; j < nodes; j++ { + rtt := lan + if (i <= split && j > split) || (i > split && j <= split) { + rtt += wan + } + truth[i][j], truth[j][i] = rtt, rtt + } + } + return truth +} + +// GenerateCircle returns a truth matrix for a set of nodes, evenly distributed +// around a circle with the given radius. The first node is at the "center" of the +// circle because it's equidistant from all the other nodes, but we place it at +// double the radius, so it should show up above all the other nodes in height. +func GenerateCircle(nodes int, radius time.Duration) [][]time.Duration { + truth := make([][]time.Duration, nodes) + for i := range truth { + truth[i] = make([]time.Duration, nodes) + } + + for i := 0; i < nodes; i++ { + for j := i + 1; j < nodes; j++ { + var rtt time.Duration + if i == 0 { + rtt = 2 * radius + } else { + t1 := 2.0 * math.Pi * float64(i) / float64(nodes) + x1, y1 := math.Cos(t1), math.Sin(t1) + t2 := 2.0 * math.Pi * float64(j) / float64(nodes) + x2, y2 := math.Cos(t2), math.Sin(t2) + dx, dy := x2-x1, y2-y1 + dist := math.Sqrt(dx*dx + dy*dy) + rtt = time.Duration(dist * float64(radius)) + } + truth[i][j], truth[j][i] = rtt, rtt + } + } + return truth +} + +// GenerateRandom returns a truth matrix for a set of nodes with normally +// distributed delays, with the given mean and deviation. The RNG is re-seeded +// so you always get the same matrix for a given size. +func GenerateRandom(nodes int, mean time.Duration, deviation time.Duration) [][]time.Duration { + rand.Seed(1) + + truth := make([][]time.Duration, nodes) + for i := range truth { + truth[i] = make([]time.Duration, nodes) + } + + for i := 0; i < nodes; i++ { + for j := i + 1; j < nodes; j++ { + rttSeconds := rand.NormFloat64()*deviation.Seconds() + mean.Seconds() + rtt := time.Duration(rttSeconds * secondsToNanoseconds) + truth[i][j], truth[j][i] = rtt, rtt + } + } + return truth +} + +// Simulate runs the given number of cycles using the given list of clients and +// truth matrix. On each cycle, each client will pick a random node and observe +// the truth RTT, updating its coordinate estimate. The RNG is re-seeded for +// each simulation run to get deterministic results (for this algorithm and the +// underlying algorithm which will use random numbers for position vectors when +// starting out with everything at the origin). +func Simulate(clients []*Client, truth [][]time.Duration, cycles int) { + rand.Seed(1) + + nodes := len(clients) + for cycle := 0; cycle < cycles; cycle++ { + for i, _ := range clients { + if j := rand.Intn(nodes); j != i { + c := clients[j].GetCoordinate() + rtt := truth[i][j] + node := fmt.Sprintf("node_%d", j) + clients[i].Update(node, c, rtt) + } + } + } +} + +// Stats is returned from the Evaluate function with a summary of the algorithm +// performance. +type Stats struct { + ErrorMax float64 + ErrorAvg float64 +} + +// Evaluate uses the coordinates of the given clients to calculate estimated +// distances and compares them with the given truth matrix, returning summary +// stats. +func Evaluate(clients []*Client, truth [][]time.Duration) (stats Stats) { + nodes := len(clients) + count := 0 + for i := 0; i < nodes; i++ { + for j := i + 1; j < nodes; j++ { + est := clients[i].DistanceTo(clients[j].GetCoordinate()).Seconds() + actual := truth[i][j].Seconds() + error := math.Abs(est-actual) / actual + stats.ErrorMax = math.Max(stats.ErrorMax, error) + stats.ErrorAvg += error + count += 1 + } + } + + stats.ErrorAvg /= float64(count) + fmt.Printf("Error avg=%9.6f max=%9.6f\n", stats.ErrorAvg, stats.ErrorMax) + return +} diff --git a/vendor/github.com/inconshreveable/mousetrap/LICENSE b/vendor/github.com/inconshreveable/mousetrap/LICENSE new file mode 100644 index 00000000..5f0d1fb6 --- /dev/null +++ b/vendor/github.com/inconshreveable/mousetrap/LICENSE @@ -0,0 +1,13 @@ +Copyright 2014 Alan Shreve + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/vendor/github.com/inconshreveable/mousetrap/trap_others.go b/vendor/github.com/inconshreveable/mousetrap/trap_others.go new file mode 100644 index 00000000..9d2d8a4b --- /dev/null +++ b/vendor/github.com/inconshreveable/mousetrap/trap_others.go @@ -0,0 +1,15 @@ +// +build !windows + +package mousetrap + +// StartedByExplorer returns true if the program was invoked by the user +// double-clicking on the executable from explorer.exe +// +// It is conservative and returns false if any of the internal calls fail. +// It does not guarantee that the program was run from a terminal. It only can tell you +// whether it was launched from explorer.exe +// +// On non-Windows platforms, it always returns false. +func StartedByExplorer() bool { + return false +} diff --git a/vendor/github.com/inconshreveable/mousetrap/trap_windows.go b/vendor/github.com/inconshreveable/mousetrap/trap_windows.go new file mode 100644 index 00000000..336142a5 --- /dev/null +++ b/vendor/github.com/inconshreveable/mousetrap/trap_windows.go @@ -0,0 +1,98 @@ +// +build windows +// +build !go1.4 + +package mousetrap + +import ( + "fmt" + "os" + "syscall" + "unsafe" +) + +const ( + // defined by the Win32 API + th32cs_snapprocess uintptr = 0x2 +) + +var ( + kernel = syscall.MustLoadDLL("kernel32.dll") + CreateToolhelp32Snapshot = kernel.MustFindProc("CreateToolhelp32Snapshot") + Process32First = kernel.MustFindProc("Process32FirstW") + Process32Next = kernel.MustFindProc("Process32NextW") +) + +// ProcessEntry32 structure defined by the Win32 API +type processEntry32 struct { + dwSize uint32 + cntUsage uint32 + th32ProcessID uint32 + th32DefaultHeapID int + th32ModuleID uint32 + cntThreads uint32 + th32ParentProcessID uint32 + pcPriClassBase int32 + dwFlags uint32 + szExeFile [syscall.MAX_PATH]uint16 +} + +func getProcessEntry(pid int) (pe *processEntry32, err error) { + snapshot, _, e1 := CreateToolhelp32Snapshot.Call(th32cs_snapprocess, uintptr(0)) + if snapshot == uintptr(syscall.InvalidHandle) { + err = fmt.Errorf("CreateToolhelp32Snapshot: %v", e1) + return + } + defer syscall.CloseHandle(syscall.Handle(snapshot)) + + var processEntry processEntry32 + processEntry.dwSize = uint32(unsafe.Sizeof(processEntry)) + ok, _, e1 := Process32First.Call(snapshot, uintptr(unsafe.Pointer(&processEntry))) + if ok == 0 { + err = fmt.Errorf("Process32First: %v", e1) + return + } + + for { + if processEntry.th32ProcessID == uint32(pid) { + pe = &processEntry + return + } + + ok, _, e1 = Process32Next.Call(snapshot, uintptr(unsafe.Pointer(&processEntry))) + if ok == 0 { + err = fmt.Errorf("Process32Next: %v", e1) + return + } + } +} + +func getppid() (pid int, err error) { + pe, err := getProcessEntry(os.Getpid()) + if err != nil { + return + } + + pid = int(pe.th32ParentProcessID) + return +} + +// StartedByExplorer returns true if the program was invoked by the user double-clicking +// on the executable from explorer.exe +// +// It is conservative and returns false if any of the internal calls fail. +// It does not guarantee that the program was run from a terminal. It only can tell you +// whether it was launched from explorer.exe +func StartedByExplorer() bool { + ppid, err := getppid() + if err != nil { + return false + } + + pe, err := getProcessEntry(ppid) + if err != nil { + return false + } + + name := syscall.UTF16ToString(pe.szExeFile[:]) + return name == "explorer.exe" +} diff --git a/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go b/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go new file mode 100644 index 00000000..9a28e57c --- /dev/null +++ b/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go @@ -0,0 +1,46 @@ +// +build windows +// +build go1.4 + +package mousetrap + +import ( + "os" + "syscall" + "unsafe" +) + +func getProcessEntry(pid int) (*syscall.ProcessEntry32, error) { + snapshot, err := syscall.CreateToolhelp32Snapshot(syscall.TH32CS_SNAPPROCESS, 0) + if err != nil { + return nil, err + } + defer syscall.CloseHandle(snapshot) + var procEntry syscall.ProcessEntry32 + procEntry.Size = uint32(unsafe.Sizeof(procEntry)) + if err = syscall.Process32First(snapshot, &procEntry); err != nil { + return nil, err + } + for { + if procEntry.ProcessID == uint32(pid) { + return &procEntry, nil + } + err = syscall.Process32Next(snapshot, &procEntry) + if err != nil { + return nil, err + } + } +} + +// StartedByExplorer returns true if the program was invoked by the user double-clicking +// on the executable from explorer.exe +// +// It is conservative and returns false if any of the internal calls fail. +// It does not guarantee that the program was run from a terminal. It only can tell you +// whether it was launched from explorer.exe +func StartedByExplorer() bool { + pe, err := getProcessEntry(os.Getppid()) + if err != nil { + return false + } + return "explorer.exe" == syscall.UTF16ToString(pe.ExeFile[:]) +} diff --git a/vendor/github.com/llgcode/draw2d/LICENSE b/vendor/github.com/llgcode/draw2d/LICENSE new file mode 100644 index 00000000..c495dbc5 --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/LICENSE @@ -0,0 +1,18 @@ +Copyright (c) 2010, Laurent Le Goff +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, +OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, +OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/vendor/github.com/llgcode/draw2d/draw2d.go b/vendor/github.com/llgcode/draw2d/draw2d.go new file mode 100644 index 00000000..92a7344f --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2d.go @@ -0,0 +1,239 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 13/12/2010 by Laurent Le Goff + +// Package draw2d is a pure go 2D vector graphics library with support +// for multiple output devices such as images (draw2d), pdf documents +// (draw2dpdf) and opengl (draw2dgl), which can also be used on the +// google app engine. It can be used as a pure go Cairo alternative. +// draw2d is released under the BSD license. +// +// Features +// +// Operations in draw2d include stroking and filling polygons, arcs, +// Bézier curves, drawing images and text rendering with truetype fonts. +// All drawing operations can be transformed by affine transformations +// (scale, rotation, translation). +// +// Package draw2d follows the conventions of http://www.w3.org/TR/2dcontext for coordinate system, angles, etc... +// +// Installation +// +// To install or update the package draw2d on your system, run: +// go get -u github.com/llgcode/draw2d +// +// Quick Start +// +// Package draw2d itself provides a graphic context that can draw vector +// graphics and text on an image canvas. The following Go code +// generates a simple drawing and saves it to an image file: +// package main +// +// import ( +// "github.com/llgcode/draw2d/draw2dimg" +// "image" +// "image/color" +// ) +// +// func main() { +// // Initialize the graphic context on an RGBA image +// dest := image.NewRGBA(image.Rect(0, 0, 297, 210.0)) +// gc := draw2dimg.NewGraphicContext(dest) +// +// // Set some properties +// gc.SetFillColor(color.RGBA{0x44, 0xff, 0x44, 0xff}) +// gc.SetStrokeColor(color.RGBA{0x44, 0x44, 0x44, 0xff}) +// gc.SetLineWidth(5) +// +// // Draw a closed shape +// gc.MoveTo(10, 10) // should always be called first for a new path +// gc.LineTo(100, 50) +// gc.QuadCurveTo(100, 10, 10, 10) +// gc.Close() +// gc.FillStroke() +// +// // Save to file +// draw2dimg.SaveToPngFile("hello.png", dest) +// } +// +// +// There are more examples here: +// https://github.com/llgcode/draw2d/tree/master/samples +// +// Drawing on pdf documents is provided by the draw2dpdf package. +// Drawing on opengl is provided by the draw2dgl package. +// See subdirectories at the bottom of this page. +// +// Testing +// +// The samples are run as tests from the root package folder `draw2d` by: +// go test ./... +// +// Or if you want to run with test coverage: +// go test -cover ./... | grep -v "no test" +// +// This will generate output by the different backends in the output folder. +// +// Acknowledgments +// +// Laurent Le Goff wrote this library, inspired by Postscript and +// HTML5 canvas. He implemented the image and opengl backend with the +// freetype-go package. Also he created a pure go Postscript +// interpreter, which can read postscript images and draw to a draw2d +// graphic context (https://github.com/llgcode/ps). Stani Michiels +// implemented the pdf backend with the gofpdf package. +// +// Packages using draw2d +// +// - https://github.com/llgcode/ps: Postscript interpreter written in Go +// +// - https://github.com/gonum/plot: drawing plots in Go +// +// - https://github.com/muesli/smartcrop: content aware image cropping +// +// - https://github.com/peterhellberg/karta: drawing Voronoi diagrams +// +// - https://github.com/vdobler/chart: basic charts in Go +package draw2d + +import "image/color" + +// FillRule defines the type for fill rules +type FillRule int + +const ( + // FillRuleEvenOdd determines the "insideness" of a point in the shape + // by drawing a ray from that point to infinity in any direction + // and counting the number of path segments from the given shape that the ray crosses. + // If this number is odd, the point is inside; if even, the point is outside. + FillRuleEvenOdd FillRule = iota + // FillRuleWinding determines the "insideness" of a point in the shape + // by drawing a ray from that point to infinity in any direction + // and then examining the places where a segment of the shape crosses the ray. + // Starting with a count of zero, add one each time a path segment crosses + // the ray from left to right and subtract one each time + // a path segment crosses the ray from right to left. After counting the crossings, + // if the result is zero then the point is outside the path. Otherwise, it is inside. + FillRuleWinding +) + +// LineCap is the style of line extremities +type LineCap int + +const ( + // RoundCap defines a rounded shape at the end of the line + RoundCap LineCap = iota + // ButtCap defines a squared shape exactly at the end of the line + ButtCap + // SquareCap defines a squared shape at the end of the line + SquareCap +) + +// LineJoin is the style of segments joint +type LineJoin int + +const ( + // BevelJoin represents cut segments joint + BevelJoin LineJoin = iota + // RoundJoin represents rounded segments joint + RoundJoin + // MiterJoin represents peaker segments joint + MiterJoin +) + +// StrokeStyle keeps stroke style attributes +// that is used by the Stroke method of a Drawer +type StrokeStyle struct { + // Color defines the color of stroke + Color color.Color + // Line width + Width float64 + // Line cap style rounded, butt or square + LineCap LineCap + // Line join style bevel, round or miter + LineJoin LineJoin + // offset of the first dash + DashOffset float64 + // array represented dash length pair values are plain dash and impair are space between dash + // if empty display plain line + Dash []float64 +} + +// SolidFillStyle define style attributes for a solid fill style +type SolidFillStyle struct { + // Color defines the line color + Color color.Color + // FillRule defines the file rule to used + FillRule FillRule +} + +// Valign Vertical Alignment of the text +type Valign int + +const ( + // ValignTop top align text + ValignTop Valign = iota + // ValignCenter centered text + ValignCenter + // ValignBottom bottom aligned text + ValignBottom + // ValignBaseline align text with the baseline of the font + ValignBaseline +) + +// Halign Horizontal Alignment of the text +type Halign int + +const ( + // HalignLeft Horizontally align to left + HalignLeft = iota + // HalignCenter Horizontally align to center + HalignCenter + // HalignRight Horizontally align to right + HalignRight +) + +// TextStyle describe text property +type TextStyle struct { + // Color defines the color of text + Color color.Color + // Size font size + Size float64 + // The font to use + Font FontData + // Horizontal Alignment of the text + Halign Halign + // Vertical Alignment of the text + Valign Valign +} + +// ScalingPolicy is a constant to define how to scale an image +type ScalingPolicy int + +const ( + // ScalingNone no scaling applied + ScalingNone ScalingPolicy = iota + // ScalingStretch the image is stretched so that its width and height are exactly the given width and height + ScalingStretch + // ScalingWidth the image is scaled so that its width is exactly the given width + ScalingWidth + // ScalingHeight the image is scaled so that its height is exactly the given height + ScalingHeight + // ScalingFit the image is scaled to the largest scale that allow the image to fit within a rectangle width x height + ScalingFit + // ScalingSameArea the image is scaled so that its area is exactly the area of the given rectangle width x height + ScalingSameArea + // ScalingFill the image is scaled to the smallest scale that allow the image to fully cover a rectangle width x height + ScalingFill +) + +// ImageScaling style attributes used to display the image +type ImageScaling struct { + // Horizontal Alignment of the image + Halign Halign + // Vertical Alignment of the image + Valign Valign + // Width Height used by scaling policy + Width, Height float64 + // ScalingPolicy defines the scaling policy to applied to the image + ScalingPolicy ScalingPolicy +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dbase/curve.go b/vendor/github.com/llgcode/draw2d/draw2dbase/curve.go new file mode 100644 index 00000000..211e107f --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dbase/curve.go @@ -0,0 +1,161 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 17/05/2011 by Laurent Le Goff + +package draw2dbase + +import ( + "math" +) + +const ( + // CurveRecursionLimit represents the maximum recursion that is really necessary to subsivide a curve into straight lines + CurveRecursionLimit = 32 +) + +// Cubic +// x1, y1, cpx1, cpy1, cpx2, cpy2, x2, y2 float64 + +// SubdivideCubic a Bezier cubic curve in 2 equivalents Bezier cubic curves. +// c1 and c2 parameters are the resulting curves +func SubdivideCubic(c, c1, c2 []float64) { + // First point of c is the first point of c1 + c1[0], c1[1] = c[0], c[1] + // Last point of c is the last point of c2 + c2[6], c2[7] = c[6], c[7] + + // Subdivide segment using midpoints + c1[2] = (c[0] + c[2]) / 2 + c1[3] = (c[1] + c[3]) / 2 + + midX := (c[2] + c[4]) / 2 + midY := (c[3] + c[5]) / 2 + + c2[4] = (c[4] + c[6]) / 2 + c2[5] = (c[5] + c[7]) / 2 + + c1[4] = (c1[2] + midX) / 2 + c1[5] = (c1[3] + midY) / 2 + + c2[2] = (midX + c2[4]) / 2 + c2[3] = (midY + c2[5]) / 2 + + c1[6] = (c1[4] + c2[2]) / 2 + c1[7] = (c1[5] + c2[3]) / 2 + + // Last Point of c1 is equal to the first point of c2 + c2[0], c2[1] = c1[6], c1[7] +} + +// TraceCubic generate lines subdividing the cubic curve using a Liner +// flattening_threshold helps determines the flattening expectation of the curve +func TraceCubic(t Liner, cubic []float64, flatteningThreshold float64) { + // Allocation curves + var curves [CurveRecursionLimit * 8]float64 + copy(curves[0:8], cubic[0:8]) + i := 0 + + // current curve + var c []float64 + + var dx, dy, d2, d3 float64 + + for i >= 0 { + c = curves[i*8:] + dx = c[6] - c[0] + dy = c[7] - c[1] + + d2 = math.Abs((c[2]-c[6])*dy - (c[3]-c[7])*dx) + d3 = math.Abs((c[4]-c[6])*dy - (c[5]-c[7])*dx) + + // if it's flat then trace a line + if (d2+d3)*(d2+d3) < flatteningThreshold*(dx*dx+dy*dy) || i == len(curves)-1 { + t.LineTo(c[6], c[7]) + i-- + } else { + // second half of bezier go lower onto the stack + SubdivideCubic(c, curves[(i+1)*8:], curves[i*8:]) + i++ + } + } +} + +// Quad +// x1, y1, cpx1, cpy2, x2, y2 float64 + +// SubdivideQuad a Bezier quad curve in 2 equivalents Bezier quad curves. +// c1 and c2 parameters are the resulting curves +func SubdivideQuad(c, c1, c2 []float64) { + // First point of c is the first point of c1 + c1[0], c1[1] = c[0], c[1] + // Last point of c is the last point of c2 + c2[4], c2[5] = c[4], c[5] + + // Subdivide segment using midpoints + c1[2] = (c[0] + c[2]) / 2 + c1[3] = (c[1] + c[3]) / 2 + c2[2] = (c[2] + c[4]) / 2 + c2[3] = (c[3] + c[5]) / 2 + c1[4] = (c1[2] + c2[2]) / 2 + c1[5] = (c1[3] + c2[3]) / 2 + c2[0], c2[1] = c1[4], c1[5] + return +} + +// TraceQuad generate lines subdividing the curve using a Liner +// flattening_threshold helps determines the flattening expectation of the curve +func TraceQuad(t Liner, quad []float64, flatteningThreshold float64) { + // Allocates curves stack + var curves [CurveRecursionLimit * 6]float64 + copy(curves[0:6], quad[0:6]) + i := 0 + // current curve + var c []float64 + var dx, dy, d float64 + + for i >= 0 { + c = curves[i*6:] + dx = c[4] - c[0] + dy = c[5] - c[1] + + d = math.Abs(((c[2]-c[4])*dy - (c[3]-c[5])*dx)) + + // if it's flat then trace a line + if (d*d) < flatteningThreshold*(dx*dx+dy*dy) || i == len(curves)-1 { + t.LineTo(c[4], c[5]) + i-- + } else { + // second half of bezier go lower onto the stack + SubdivideQuad(c, curves[(i+1)*6:], curves[i*6:]) + i++ + } + } +} + +// TraceArc trace an arc using a Liner +func TraceArc(t Liner, x, y, rx, ry, start, angle, scale float64) (lastX, lastY float64) { + end := start + angle + clockWise := true + if angle < 0 { + clockWise = false + } + ra := (math.Abs(rx) + math.Abs(ry)) / 2 + da := math.Acos(ra/(ra+0.125/scale)) * 2 + //normalize + if !clockWise { + da = -da + } + angle = start + da + var curX, curY float64 + for { + if (angle < end-da/4) != clockWise { + curX = x + math.Cos(end)*rx + curY = y + math.Sin(end)*ry + return curX, curY + } + curX = x + math.Cos(angle)*rx + curY = y + math.Sin(angle)*ry + + angle += da + t.LineTo(curX, curY) + } +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dbase/dasher.go b/vendor/github.com/llgcode/draw2d/draw2dbase/dasher.go new file mode 100644 index 00000000..6f8260c7 --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dbase/dasher.go @@ -0,0 +1,89 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 13/12/2010 by Laurent Le Goff + +package draw2dbase + +type DashVertexConverter struct { + next Flattener + x, y, distance float64 + dash []float64 + currentDash int + dashOffset float64 +} + +func NewDashConverter(dash []float64, dashOffset float64, flattener Flattener) *DashVertexConverter { + var dasher DashVertexConverter + dasher.dash = dash + dasher.currentDash = 0 + dasher.dashOffset = dashOffset + dasher.next = flattener + return &dasher +} + +func (dasher *DashVertexConverter) LineTo(x, y float64) { + dasher.lineTo(x, y) +} + +func (dasher *DashVertexConverter) MoveTo(x, y float64) { + dasher.next.MoveTo(x, y) + dasher.x, dasher.y = x, y + dasher.distance = dasher.dashOffset + dasher.currentDash = 0 +} + +func (dasher *DashVertexConverter) LineJoin() { + dasher.next.LineJoin() +} + +func (dasher *DashVertexConverter) Close() { + dasher.next.Close() +} + +func (dasher *DashVertexConverter) End() { + dasher.next.End() +} + +func (dasher *DashVertexConverter) lineTo(x, y float64) { + rest := dasher.dash[dasher.currentDash] - dasher.distance + for rest < 0 { + dasher.distance = dasher.distance - dasher.dash[dasher.currentDash] + dasher.currentDash = (dasher.currentDash + 1) % len(dasher.dash) + rest = dasher.dash[dasher.currentDash] - dasher.distance + } + d := distance(dasher.x, dasher.y, x, y) + for d >= rest { + k := rest / d + lx := dasher.x + k*(x-dasher.x) + ly := dasher.y + k*(y-dasher.y) + if dasher.currentDash%2 == 0 { + // line + dasher.next.LineTo(lx, ly) + } else { + // gap + dasher.next.End() + dasher.next.MoveTo(lx, ly) + } + d = d - rest + dasher.x, dasher.y = lx, ly + dasher.currentDash = (dasher.currentDash + 1) % len(dasher.dash) + rest = dasher.dash[dasher.currentDash] + } + dasher.distance = d + if dasher.currentDash%2 == 0 { + // line + dasher.next.LineTo(x, y) + } else { + // gap + dasher.next.End() + dasher.next.MoveTo(x, y) + } + if dasher.distance >= dasher.dash[dasher.currentDash] { + dasher.distance = dasher.distance - dasher.dash[dasher.currentDash] + dasher.currentDash = (dasher.currentDash + 1) % len(dasher.dash) + } + dasher.x, dasher.y = x, y +} + +func distance(x1, y1, x2, y2 float64) float64 { + return vectorDistance(x2-x1, y2-y1) +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dbase/demux_flattener.go b/vendor/github.com/llgcode/draw2d/draw2dbase/demux_flattener.go new file mode 100644 index 00000000..13b6c408 --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dbase/demux_flattener.go @@ -0,0 +1,35 @@ +package draw2dbase + +type DemuxFlattener struct { + Flatteners []Flattener +} + +func (dc DemuxFlattener) MoveTo(x, y float64) { + for _, flattener := range dc.Flatteners { + flattener.MoveTo(x, y) + } +} + +func (dc DemuxFlattener) LineTo(x, y float64) { + for _, flattener := range dc.Flatteners { + flattener.LineTo(x, y) + } +} + +func (dc DemuxFlattener) LineJoin() { + for _, flattener := range dc.Flatteners { + flattener.LineJoin() + } +} + +func (dc DemuxFlattener) Close() { + for _, flattener := range dc.Flatteners { + flattener.Close() + } +} + +func (dc DemuxFlattener) End() { + for _, flattener := range dc.Flatteners { + flattener.End() + } +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dbase/flattener.go b/vendor/github.com/llgcode/draw2d/draw2dbase/flattener.go new file mode 100644 index 00000000..986c7ab2 --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dbase/flattener.go @@ -0,0 +1,127 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 06/12/2010 by Laurent Le Goff + +package draw2dbase + +import ( + "github.com/llgcode/draw2d" +) + +// Liner receive segment definition +type Liner interface { + // LineTo Draw a line from the current position to the point (x, y) + LineTo(x, y float64) +} + +// Flattener receive segment definition +type Flattener interface { + // MoveTo Start a New line from the point (x, y) + MoveTo(x, y float64) + // LineTo Draw a line from the current position to the point (x, y) + LineTo(x, y float64) + // LineJoin add the most recent starting point to close the path to create a polygon + LineJoin() + // Close add the most recent starting point to close the path to create a polygon + Close() + // End mark the current line as finished so we can draw caps + End() +} + +// Flatten convert curves into straight segments keeping join segments info +func Flatten(path *draw2d.Path, flattener Flattener, scale float64) { + // First Point + var startX, startY float64 = 0, 0 + // Current Point + var x, y float64 = 0, 0 + i := 0 + for _, cmp := range path.Components { + switch cmp { + case draw2d.MoveToCmp: + x, y = path.Points[i], path.Points[i+1] + startX, startY = x, y + if i != 0 { + flattener.End() + } + flattener.MoveTo(x, y) + i += 2 + case draw2d.LineToCmp: + x, y = path.Points[i], path.Points[i+1] + flattener.LineTo(x, y) + flattener.LineJoin() + i += 2 + case draw2d.QuadCurveToCmp: + TraceQuad(flattener, path.Points[i-2:], 0.5) + x, y = path.Points[i+2], path.Points[i+3] + flattener.LineTo(x, y) + i += 4 + case draw2d.CubicCurveToCmp: + TraceCubic(flattener, path.Points[i-2:], 0.5) + x, y = path.Points[i+4], path.Points[i+5] + flattener.LineTo(x, y) + i += 6 + case draw2d.ArcToCmp: + x, y = TraceArc(flattener, path.Points[i], path.Points[i+1], path.Points[i+2], path.Points[i+3], path.Points[i+4], path.Points[i+5], scale) + flattener.LineTo(x, y) + i += 6 + case draw2d.CloseCmp: + flattener.LineTo(startX, startY) + flattener.Close() + } + } + flattener.End() +} + +// Transformer apply the Matrix transformation tr +type Transformer struct { + Tr draw2d.Matrix + Flattener Flattener +} + +func (t Transformer) MoveTo(x, y float64) { + u := x*t.Tr[0] + y*t.Tr[2] + t.Tr[4] + v := x*t.Tr[1] + y*t.Tr[3] + t.Tr[5] + t.Flattener.MoveTo(u, v) +} + +func (t Transformer) LineTo(x, y float64) { + u := x*t.Tr[0] + y*t.Tr[2] + t.Tr[4] + v := x*t.Tr[1] + y*t.Tr[3] + t.Tr[5] + t.Flattener.LineTo(u, v) +} + +func (t Transformer) LineJoin() { + t.Flattener.LineJoin() +} + +func (t Transformer) Close() { + t.Flattener.Close() +} + +func (t Transformer) End() { + t.Flattener.End() +} + +type SegmentedPath struct { + Points []float64 +} + +func (p *SegmentedPath) MoveTo(x, y float64) { + p.Points = append(p.Points, x, y) + // TODO need to mark this point as moveto +} + +func (p *SegmentedPath) LineTo(x, y float64) { + p.Points = append(p.Points, x, y) +} + +func (p *SegmentedPath) LineJoin() { + // TODO need to mark the current point as linejoin +} + +func (p *SegmentedPath) Close() { + // TODO Close +} + +func (p *SegmentedPath) End() { + // Nothing to do +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dbase/line.go b/vendor/github.com/llgcode/draw2d/draw2dbase/line.go new file mode 100644 index 00000000..a83bbc3f --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dbase/line.go @@ -0,0 +1,58 @@ +// Copyright 2011 The draw2d Authors. All rights reserved. +// created: 27/05/2011 by Laurent Le Goff + +package draw2dbase + +import ( + "image/color" + "image/draw" +) + +func abs(i int) int { + if i < 0 { + return -i + } + return i +} + +// PolylineBresenham draws a polyline to an image +func PolylineBresenham(img draw.Image, c color.Color, s ...float64) { + for i := 2; i < len(s); i += 2 { + Bresenham(img, c, int(s[i-2]+0.5), int(s[i-1]+0.5), int(s[i]+0.5), int(s[i+1]+0.5)) + } +} + +// Bresenham draws a line between (x0, y0) and (x1, y1) +func Bresenham(img draw.Image, color color.Color, x0, y0, x1, y1 int) { + dx := abs(x1 - x0) + dy := abs(y1 - y0) + var sx, sy int + if x0 < x1 { + sx = 1 + } else { + sx = -1 + } + if y0 < y1 { + sy = 1 + } else { + sy = -1 + } + err := dx - dy + + var e2 int + for { + img.Set(x0, y0, color) + if x0 == x1 && y0 == y1 { + return + } + e2 = 2 * err + if e2 > -dy { + err = err - dy + x0 = x0 + sx + } + if e2 < dx { + err = err + dx + y0 = y0 + sy + } + } +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dbase/stack_gc.go b/vendor/github.com/llgcode/draw2d/draw2dbase/stack_gc.go new file mode 100644 index 00000000..12723c7f --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dbase/stack_gc.go @@ -0,0 +1,193 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 21/11/2010 by Laurent Le Goff + +package draw2dbase + +import ( + "image" + "image/color" + + "github.com/llgcode/draw2d" + + "github.com/golang/freetype/truetype" +) + +var DefaultFontData = draw2d.FontData{Name: "luxi", Family: draw2d.FontFamilySans, Style: draw2d.FontStyleNormal} + +type StackGraphicContext struct { + Current *ContextStack +} + +type ContextStack struct { + Tr draw2d.Matrix + Path *draw2d.Path + LineWidth float64 + Dash []float64 + DashOffset float64 + StrokeColor color.Color + FillColor color.Color + FillRule draw2d.FillRule + Cap draw2d.LineCap + Join draw2d.LineJoin + FontSize float64 + FontData draw2d.FontData + + Font *truetype.Font + // fontSize and dpi are used to calculate scale. scale is the number of + // 26.6 fixed point units in 1 em. + Scale float64 + + Previous *ContextStack +} + +/** + * Create a new Graphic context from an image + */ +func NewStackGraphicContext() *StackGraphicContext { + gc := &StackGraphicContext{} + gc.Current = new(ContextStack) + gc.Current.Tr = draw2d.NewIdentityMatrix() + gc.Current.Path = new(draw2d.Path) + gc.Current.LineWidth = 1.0 + gc.Current.StrokeColor = image.Black + gc.Current.FillColor = image.White + gc.Current.Cap = draw2d.RoundCap + gc.Current.FillRule = draw2d.FillRuleEvenOdd + gc.Current.Join = draw2d.RoundJoin + gc.Current.FontSize = 10 + gc.Current.FontData = DefaultFontData + return gc +} + +func (gc *StackGraphicContext) GetMatrixTransform() draw2d.Matrix { + return gc.Current.Tr +} + +func (gc *StackGraphicContext) SetMatrixTransform(Tr draw2d.Matrix) { + gc.Current.Tr = Tr +} + +func (gc *StackGraphicContext) ComposeMatrixTransform(Tr draw2d.Matrix) { + gc.Current.Tr.Compose(Tr) +} + +func (gc *StackGraphicContext) Rotate(angle float64) { + gc.Current.Tr.Rotate(angle) +} + +func (gc *StackGraphicContext) Translate(tx, ty float64) { + gc.Current.Tr.Translate(tx, ty) +} + +func (gc *StackGraphicContext) Scale(sx, sy float64) { + gc.Current.Tr.Scale(sx, sy) +} + +func (gc *StackGraphicContext) SetStrokeColor(c color.Color) { + gc.Current.StrokeColor = c +} + +func (gc *StackGraphicContext) SetFillColor(c color.Color) { + gc.Current.FillColor = c +} + +func (gc *StackGraphicContext) SetFillRule(f draw2d.FillRule) { + gc.Current.FillRule = f +} + +func (gc *StackGraphicContext) SetLineWidth(lineWidth float64) { + gc.Current.LineWidth = lineWidth +} + +func (gc *StackGraphicContext) SetLineCap(cap draw2d.LineCap) { + gc.Current.Cap = cap +} + +func (gc *StackGraphicContext) SetLineJoin(join draw2d.LineJoin) { + gc.Current.Join = join +} + +func (gc *StackGraphicContext) SetLineDash(dash []float64, dashOffset float64) { + gc.Current.Dash = dash + gc.Current.DashOffset = dashOffset +} + +func (gc *StackGraphicContext) SetFontSize(fontSize float64) { + gc.Current.FontSize = fontSize +} + +func (gc *StackGraphicContext) GetFontSize() float64 { + return gc.Current.FontSize +} + +func (gc *StackGraphicContext) SetFontData(fontData draw2d.FontData) { + gc.Current.FontData = fontData +} + +func (gc *StackGraphicContext) GetFontData() draw2d.FontData { + return gc.Current.FontData +} + +func (gc *StackGraphicContext) BeginPath() { + gc.Current.Path.Clear() +} + +func (gc *StackGraphicContext) IsEmpty() bool { + return gc.Current.Path.IsEmpty() +} + +func (gc *StackGraphicContext) LastPoint() (float64, float64) { + return gc.Current.Path.LastPoint() +} + +func (gc *StackGraphicContext) MoveTo(x, y float64) { + gc.Current.Path.MoveTo(x, y) +} + +func (gc *StackGraphicContext) LineTo(x, y float64) { + gc.Current.Path.LineTo(x, y) +} + +func (gc *StackGraphicContext) QuadCurveTo(cx, cy, x, y float64) { + gc.Current.Path.QuadCurveTo(cx, cy, x, y) +} + +func (gc *StackGraphicContext) CubicCurveTo(cx1, cy1, cx2, cy2, x, y float64) { + gc.Current.Path.CubicCurveTo(cx1, cy1, cx2, cy2, x, y) +} + +func (gc *StackGraphicContext) ArcTo(cx, cy, rx, ry, startAngle, angle float64) { + gc.Current.Path.ArcTo(cx, cy, rx, ry, startAngle, angle) +} + +func (gc *StackGraphicContext) Close() { + gc.Current.Path.Close() +} + +func (gc *StackGraphicContext) Save() { + context := new(ContextStack) + context.FontSize = gc.Current.FontSize + context.FontData = gc.Current.FontData + context.LineWidth = gc.Current.LineWidth + context.StrokeColor = gc.Current.StrokeColor + context.FillColor = gc.Current.FillColor + context.FillRule = gc.Current.FillRule + context.Dash = gc.Current.Dash + context.DashOffset = gc.Current.DashOffset + context.Cap = gc.Current.Cap + context.Join = gc.Current.Join + context.Path = gc.Current.Path.Copy() + context.Font = gc.Current.Font + context.Scale = gc.Current.Scale + copy(context.Tr[:], gc.Current.Tr[:]) + context.Previous = gc.Current + gc.Current = context +} + +func (gc *StackGraphicContext) Restore() { + if gc.Current.Previous != nil { + oldContext := gc.Current + gc.Current = gc.Current.Previous + oldContext.Previous = nil + } +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dbase/stroker.go b/vendor/github.com/llgcode/draw2d/draw2dbase/stroker.go new file mode 100644 index 00000000..640b2280 --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dbase/stroker.go @@ -0,0 +1,90 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 13/12/2010 by Laurent Le Goff + +package draw2dbase + +import ( + "math" + + "github.com/llgcode/draw2d" +) + +type LineStroker struct { + Flattener Flattener + HalfLineWidth float64 + Cap draw2d.LineCap + Join draw2d.LineJoin + vertices []float64 + rewind []float64 + x, y, nx, ny float64 +} + +func NewLineStroker(c draw2d.LineCap, j draw2d.LineJoin, flattener Flattener) *LineStroker { + l := new(LineStroker) + l.Flattener = flattener + l.HalfLineWidth = 0.5 + l.Cap = c + l.Join = j + return l +} + +func (l *LineStroker) MoveTo(x, y float64) { + l.x, l.y = x, y +} + +func (l *LineStroker) LineTo(x, y float64) { + l.line(l.x, l.y, x, y) +} + +func (l *LineStroker) LineJoin() { + +} + +func (l *LineStroker) line(x1, y1, x2, y2 float64) { + dx := (x2 - x1) + dy := (y2 - y1) + d := vectorDistance(dx, dy) + if d != 0 { + nx := dy * l.HalfLineWidth / d + ny := -(dx * l.HalfLineWidth / d) + l.appendVertex(x1+nx, y1+ny, x2+nx, y2+ny, x1-nx, y1-ny, x2-nx, y2-ny) + l.x, l.y, l.nx, l.ny = x2, y2, nx, ny + } +} + +func (l *LineStroker) Close() { + if len(l.vertices) > 1 { + l.appendVertex(l.vertices[0], l.vertices[1], l.rewind[0], l.rewind[1]) + } +} + +func (l *LineStroker) End() { + if len(l.vertices) > 1 { + l.Flattener.MoveTo(l.vertices[0], l.vertices[1]) + for i, j := 2, 3; j < len(l.vertices); i, j = i+2, j+2 { + l.Flattener.LineTo(l.vertices[i], l.vertices[j]) + } + } + for i, j := len(l.rewind)-2, len(l.rewind)-1; j > 0; i, j = i-2, j-2 { + l.Flattener.LineTo(l.rewind[i], l.rewind[j]) + } + if len(l.vertices) > 1 { + l.Flattener.LineTo(l.vertices[0], l.vertices[1]) + } + l.Flattener.End() + // reinit vertices + l.vertices = l.vertices[0:0] + l.rewind = l.rewind[0:0] + l.x, l.y, l.nx, l.ny = 0, 0, 0, 0 + +} + +func (l *LineStroker) appendVertex(vertices ...float64) { + s := len(vertices) / 2 + l.vertices = append(l.vertices, vertices[:s]...) + l.rewind = append(l.rewind, vertices[s:]...) +} + +func vectorDistance(dx, dy float64) float64 { + return float64(math.Sqrt(dx*dx + dy*dy)) +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dimg/fileutil.go b/vendor/github.com/llgcode/draw2d/draw2dimg/fileutil.go new file mode 100644 index 00000000..b6dccb92 --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dimg/fileutil.go @@ -0,0 +1,46 @@ +package draw2dimg + +import ( + "bufio" + "image" + "image/png" + "os" +) + +// SaveToPngFile create and save an image to a file using PNG format +func SaveToPngFile(filePath string, m image.Image) error { + // Create the file + f, err := os.Create(filePath) + if err != nil { + return err + } + defer f.Close() + // Create Writer from file + b := bufio.NewWriter(f) + // Write the image into the buffer + err = png.Encode(b, m) + if err != nil { + return err + } + err = b.Flush() + if err != nil { + return err + } + return nil +} + +// LoadFromPngFile Open a png file +func LoadFromPngFile(filePath string) (image.Image, error) { + // Open file + f, err := os.OpenFile(filePath, 0, 0) + if err != nil { + return nil, err + } + defer f.Close() + b := bufio.NewReader(f) + img, err := png.Decode(b) + if err != nil { + return nil, err + } + return img, nil +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dimg/ftgc.go b/vendor/github.com/llgcode/draw2d/draw2dimg/ftgc.go new file mode 100644 index 00000000..8bedf919 --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dimg/ftgc.go @@ -0,0 +1,355 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 21/11/2010 by Laurent Le Goff + +package draw2dimg + +import ( + "errors" + "image" + "image/color" + "log" + "math" + + "github.com/llgcode/draw2d" + "github.com/llgcode/draw2d/draw2dbase" + + "github.com/golang/freetype/raster" + "github.com/golang/freetype/truetype" + + "golang.org/x/image/draw" + "golang.org/x/image/font" + "golang.org/x/image/math/f64" + "golang.org/x/image/math/fixed" +) + +// Painter implements the freetype raster.Painter and has a SetColor method like the RGBAPainter +type Painter interface { + raster.Painter + SetColor(color color.Color) +} + +// GraphicContext is the implementation of draw2d.GraphicContext for a raster image +type GraphicContext struct { + *draw2dbase.StackGraphicContext + img draw.Image + painter Painter + fillRasterizer *raster.Rasterizer + strokeRasterizer *raster.Rasterizer + glyphBuf *truetype.GlyphBuf + DPI int +} + +// ImageFilter defines the type of filter to use +type ImageFilter int + +const ( + // LinearFilter defines a linear filter + LinearFilter ImageFilter = iota + // BilinearFilter defines a bilinear filter + BilinearFilter + // BicubicFilter defines a bicubic filter + BicubicFilter +) + +// NewGraphicContext creates a new Graphic context from an image. +func NewGraphicContext(img draw.Image) *GraphicContext { + + var painter Painter + switch selectImage := img.(type) { + case *image.RGBA: + painter = raster.NewRGBAPainter(selectImage) + default: + panic("Image type not supported") + } + return NewGraphicContextWithPainter(img, painter) +} + +// NewGraphicContextWithPainter creates a new Graphic context from an image and a Painter (see Freetype-go) +func NewGraphicContextWithPainter(img draw.Image, painter Painter) *GraphicContext { + width, height := img.Bounds().Dx(), img.Bounds().Dy() + dpi := 92 + gc := &GraphicContext{ + draw2dbase.NewStackGraphicContext(), + img, + painter, + raster.NewRasterizer(width, height), + raster.NewRasterizer(width, height), + &truetype.GlyphBuf{}, + dpi, + } + return gc +} + +// GetDPI returns the resolution of the Image GraphicContext +func (gc *GraphicContext) GetDPI() int { + return gc.DPI +} + +// Clear fills the current canvas with a default transparent color +func (gc *GraphicContext) Clear() { + width, height := gc.img.Bounds().Dx(), gc.img.Bounds().Dy() + gc.ClearRect(0, 0, width, height) +} + +// ClearRect fills the current canvas with a default transparent color at the specified rectangle +func (gc *GraphicContext) ClearRect(x1, y1, x2, y2 int) { + imageColor := image.NewUniform(gc.Current.FillColor) + draw.Draw(gc.img, image.Rect(x1, y1, x2, y2), imageColor, image.ZP, draw.Over) +} + +// DrawImage draws an image into dest using an affine transformation matrix, an op and a filter +func DrawImage(src image.Image, dest draw.Image, tr draw2d.Matrix, op draw.Op, filter ImageFilter) { + var transformer draw.Transformer + switch filter { + case LinearFilter: + transformer = draw.NearestNeighbor + case BilinearFilter: + transformer = draw.BiLinear + case BicubicFilter: + transformer = draw.CatmullRom + } + transformer.Transform(dest, f64.Aff3{tr[0], tr[1], tr[4], tr[2], tr[3], tr[5]}, src, src.Bounds(), op, nil) +} + +// DrawImage draws the raster image in the current canvas +func (gc *GraphicContext) DrawImage(img image.Image) { + DrawImage(img, gc.img, gc.Current.Tr, draw.Over, BilinearFilter) +} + +// FillString draws the text at point (0, 0) +func (gc *GraphicContext) FillString(text string) (cursor float64) { + return gc.FillStringAt(text, 0, 0) +} + +// FillStringAt draws the text at the specified point (x, y) +func (gc *GraphicContext) FillStringAt(text string, x, y float64) (cursor float64) { + width := gc.CreateStringPath(text, x, y) + gc.Fill() + return width +} + +// StrokeString draws the contour of the text at point (0, 0) +func (gc *GraphicContext) StrokeString(text string) (cursor float64) { + return gc.StrokeStringAt(text, 0, 0) +} + +// StrokeStringAt draws the contour of the text at point (x, y) +func (gc *GraphicContext) StrokeStringAt(text string, x, y float64) (cursor float64) { + width := gc.CreateStringPath(text, x, y) + gc.Stroke() + return width +} + +func (gc *GraphicContext) loadCurrentFont() (*truetype.Font, error) { + font := draw2d.GetFont(gc.Current.FontData) + if font == nil { + font = draw2d.GetFont(draw2dbase.DefaultFontData) + } + if font == nil { + return nil, errors.New("No font set, and no default font available.") + } + gc.SetFont(font) + gc.SetFontSize(gc.Current.FontSize) + return font, nil +} + +// p is a truetype.Point measured in FUnits and positive Y going upwards. +// The returned value is the same thing measured in floating point and positive Y +// going downwards. + +func (gc *GraphicContext) drawGlyph(glyph truetype.Index, dx, dy float64) error { + if err := gc.glyphBuf.Load(gc.Current.Font, fixed.Int26_6(gc.Current.Scale), glyph, font.HintingNone); err != nil { + return err + } + e0 := 0 + for _, e1 := range gc.glyphBuf.Ends { + DrawContour(gc, gc.glyphBuf.Points[e0:e1], dx, dy) + e0 = e1 + } + return nil +} + +// CreateStringPath creates a path from the string s at x, y, and returns the string width. +// The text is placed so that the left edge of the em square of the first character of s +// and the baseline intersect at x, y. The majority of the affected pixels will be +// above and to the right of the point, but some may be below or to the left. +// For example, drawing a string that starts with a 'J' in an italic font may +// affect pixels below and left of the point. +func (gc *GraphicContext) CreateStringPath(s string, x, y float64) float64 { + f, err := gc.loadCurrentFont() + if err != nil { + log.Println(err) + return 0.0 + } + startx := x + prev, hasPrev := truetype.Index(0), false + for _, rune := range s { + index := f.Index(rune) + if hasPrev { + x += fUnitsToFloat64(f.Kern(fixed.Int26_6(gc.Current.Scale), prev, index)) + } + err := gc.drawGlyph(index, x, y) + if err != nil { + log.Println(err) + return startx - x + } + x += fUnitsToFloat64(f.HMetric(fixed.Int26_6(gc.Current.Scale), index).AdvanceWidth) + prev, hasPrev = index, true + } + return x - startx +} + +// GetStringBounds returns the approximate pixel bounds of the string s at x, y. +// The the left edge of the em square of the first character of s +// and the baseline intersect at 0, 0 in the returned coordinates. +// Therefore the top and left coordinates may well be negative. +func (gc *GraphicContext) GetStringBounds(s string) (left, top, right, bottom float64) { + f, err := gc.loadCurrentFont() + if err != nil { + log.Println(err) + return 0, 0, 0, 0 + } + top, left, bottom, right = 10e6, 10e6, -10e6, -10e6 + cursor := 0.0 + prev, hasPrev := truetype.Index(0), false + for _, rune := range s { + index := f.Index(rune) + if hasPrev { + cursor += fUnitsToFloat64(f.Kern(fixed.Int26_6(gc.Current.Scale), prev, index)) + } + if err := gc.glyphBuf.Load(gc.Current.Font, fixed.Int26_6(gc.Current.Scale), index, font.HintingNone); err != nil { + log.Println(err) + return 0, 0, 0, 0 + } + e0 := 0 + for _, e1 := range gc.glyphBuf.Ends { + ps := gc.glyphBuf.Points[e0:e1] + for _, p := range ps { + x, y := pointToF64Point(p) + top = math.Min(top, y) + bottom = math.Max(bottom, y) + left = math.Min(left, x+cursor) + right = math.Max(right, x+cursor) + } + } + cursor += fUnitsToFloat64(f.HMetric(fixed.Int26_6(gc.Current.Scale), index).AdvanceWidth) + prev, hasPrev = index, true + } + return left, top, right, bottom +} + +// recalc recalculates scale and bounds values from the font size, screen +// resolution and font metrics, and invalidates the glyph cache. +func (gc *GraphicContext) recalc() { + gc.Current.Scale = gc.Current.FontSize * float64(gc.DPI) * (64.0 / 72.0) +} + +// SetDPI sets the screen resolution in dots per inch. +func (gc *GraphicContext) SetDPI(dpi int) { + gc.DPI = dpi + gc.recalc() +} + +// SetFont sets the font used to draw text. +func (gc *GraphicContext) SetFont(font *truetype.Font) { + gc.Current.Font = font +} + +// SetFontSize sets the font size in points (as in ``a 12 point font''). +func (gc *GraphicContext) SetFontSize(fontSize float64) { + gc.Current.FontSize = fontSize + gc.recalc() +} + +func (gc *GraphicContext) paint(rasterizer *raster.Rasterizer, color color.Color) { + gc.painter.SetColor(color) + rasterizer.Rasterize(gc.painter) + rasterizer.Clear() + gc.Current.Path.Clear() +} + +// Stroke strokes the paths with the color specified by SetStrokeColor +func (gc *GraphicContext) Stroke(paths ...*draw2d.Path) { + paths = append(paths, gc.Current.Path) + gc.strokeRasterizer.UseNonZeroWinding = true + + stroker := draw2dbase.NewLineStroker(gc.Current.Cap, gc.Current.Join, draw2dbase.Transformer{Tr: gc.Current.Tr, Flattener: FtLineBuilder{Adder: gc.strokeRasterizer}}) + stroker.HalfLineWidth = gc.Current.LineWidth / 2 + + var liner draw2dbase.Flattener + if gc.Current.Dash != nil && len(gc.Current.Dash) > 0 { + liner = draw2dbase.NewDashConverter(gc.Current.Dash, gc.Current.DashOffset, stroker) + } else { + liner = stroker + } + for _, p := range paths { + draw2dbase.Flatten(p, liner, gc.Current.Tr.GetScale()) + } + + gc.paint(gc.strokeRasterizer, gc.Current.StrokeColor) +} + +// Fill fills the paths with the color specified by SetFillColor +func (gc *GraphicContext) Fill(paths ...*draw2d.Path) { + paths = append(paths, gc.Current.Path) + gc.fillRasterizer.UseNonZeroWinding = gc.Current.FillRule == draw2d.FillRuleWinding + + /**** first method ****/ + flattener := draw2dbase.Transformer{Tr: gc.Current.Tr, Flattener: FtLineBuilder{Adder: gc.fillRasterizer}} + for _, p := range paths { + draw2dbase.Flatten(p, flattener, gc.Current.Tr.GetScale()) + } + + gc.paint(gc.fillRasterizer, gc.Current.FillColor) +} + +// FillStroke first fills the paths and than strokes them +func (gc *GraphicContext) FillStroke(paths ...*draw2d.Path) { + paths = append(paths, gc.Current.Path) + gc.fillRasterizer.UseNonZeroWinding = gc.Current.FillRule == draw2d.FillRuleWinding + gc.strokeRasterizer.UseNonZeroWinding = true + + flattener := draw2dbase.Transformer{Tr: gc.Current.Tr, Flattener: FtLineBuilder{Adder: gc.fillRasterizer}} + + stroker := draw2dbase.NewLineStroker(gc.Current.Cap, gc.Current.Join, draw2dbase.Transformer{Tr: gc.Current.Tr, Flattener: FtLineBuilder{Adder: gc.strokeRasterizer}}) + stroker.HalfLineWidth = gc.Current.LineWidth / 2 + + var liner draw2dbase.Flattener + if gc.Current.Dash != nil && len(gc.Current.Dash) > 0 { + liner = draw2dbase.NewDashConverter(gc.Current.Dash, gc.Current.DashOffset, stroker) + } else { + liner = stroker + } + + demux := draw2dbase.DemuxFlattener{Flatteners: []draw2dbase.Flattener{flattener, liner}} + for _, p := range paths { + draw2dbase.Flatten(p, demux, gc.Current.Tr.GetScale()) + } + + // Fill + gc.paint(gc.fillRasterizer, gc.Current.FillColor) + // Stroke + gc.paint(gc.strokeRasterizer, gc.Current.StrokeColor) +} + +func toFtCap(c draw2d.LineCap) raster.Capper { + switch c { + case draw2d.RoundCap: + return raster.RoundCapper + case draw2d.ButtCap: + return raster.ButtCapper + case draw2d.SquareCap: + return raster.SquareCapper + } + return raster.RoundCapper +} + +func toFtJoin(j draw2d.LineJoin) raster.Joiner { + switch j { + case draw2d.RoundJoin: + return raster.RoundJoiner + case draw2d.BevelJoin: + return raster.BevelJoiner + } + return raster.RoundJoiner +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dimg/ftpath.go b/vendor/github.com/llgcode/draw2d/draw2dimg/ftpath.go new file mode 100644 index 00000000..785fc31c --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dimg/ftpath.go @@ -0,0 +1,30 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 13/12/2010 by Laurent Le Goff + +package draw2dimg + +import ( + "github.com/golang/freetype/raster" + "golang.org/x/image/math/fixed" +) + +type FtLineBuilder struct { + Adder raster.Adder +} + +func (liner FtLineBuilder) MoveTo(x, y float64) { + liner.Adder.Start(fixed.Point26_6{X: fixed.Int26_6(x * 64), Y: fixed.Int26_6(y * 64)}) +} + +func (liner FtLineBuilder) LineTo(x, y float64) { + liner.Adder.Add1(fixed.Point26_6{X: fixed.Int26_6(x * 64), Y: fixed.Int26_6(y * 64)}) +} + +func (liner FtLineBuilder) LineJoin() { +} + +func (liner FtLineBuilder) Close() { +} + +func (liner FtLineBuilder) End() { +} diff --git a/vendor/github.com/llgcode/draw2d/draw2dimg/text.go b/vendor/github.com/llgcode/draw2d/draw2dimg/text.go new file mode 100644 index 00000000..2fe24935 --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/draw2dimg/text.go @@ -0,0 +1,82 @@ +package draw2dimg + +import ( + "github.com/golang/freetype/truetype" + "github.com/llgcode/draw2d" + + "golang.org/x/image/math/fixed" +) + +// DrawContour draws the given closed contour at the given sub-pixel offset. +func DrawContour(path draw2d.PathBuilder, ps []truetype.Point, dx, dy float64) { + if len(ps) == 0 { + return + } + startX, startY := pointToF64Point(ps[0]) + path.MoveTo(startX+dx, startY+dy) + q0X, q0Y, on0 := startX, startY, true + for _, p := range ps[1:] { + qX, qY := pointToF64Point(p) + on := p.Flags&0x01 != 0 + if on { + if on0 { + path.LineTo(qX+dx, qY+dy) + } else { + path.QuadCurveTo(q0X+dx, q0Y+dy, qX+dx, qY+dy) + } + } else { + if on0 { + // No-op. + } else { + midX := (q0X + qX) / 2 + midY := (q0Y + qY) / 2 + path.QuadCurveTo(q0X+dx, q0Y+dy, midX+dx, midY+dy) + } + } + q0X, q0Y, on0 = qX, qY, on + } + // Close the curve. + if on0 { + path.LineTo(startX+dx, startY+dy) + } else { + path.QuadCurveTo(q0X+dx, q0Y+dy, startX+dx, startY+dy) + } +} + +func pointToF64Point(p truetype.Point) (x, y float64) { + return fUnitsToFloat64(p.X), -fUnitsToFloat64(p.Y) +} + +func fUnitsToFloat64(x fixed.Int26_6) float64 { + scaled := x << 2 + return float64(scaled/256) + float64(scaled%256)/256.0 +} + +// FontExtents contains font metric information. +type FontExtents struct { + // Ascent is the distance that the text + // extends above the baseline. + Ascent float64 + + // Descent is the distance that the text + // extends below the baseline. The descent + // is given as a negative value. + Descent float64 + + // Height is the distance from the lowest + // descending point to the highest ascending + // point. + Height float64 +} + +// Extents returns the FontExtents for a font. +// TODO needs to read this https://developer.apple.com/fonts/TrueType-Reference-Manual/RM02/Chap2.html#intro +func Extents(font *truetype.Font, size float64) FontExtents { + bounds := font.Bounds(fixed.Int26_6(font.FUnitsPerEm())) + scale := size / float64(font.FUnitsPerEm()) + return FontExtents{ + Ascent: float64(bounds.Max.Y) * scale, + Descent: float64(bounds.Min.Y) * scale, + Height: float64(bounds.Max.Y-bounds.Min.Y) * scale, + } +} diff --git a/vendor/github.com/llgcode/draw2d/font.go b/vendor/github.com/llgcode/draw2d/font.go new file mode 100644 index 00000000..cd0ec1b6 --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/font.go @@ -0,0 +1,154 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 13/12/2010 by Laurent Le Goff + +package draw2d + +import ( + "io/ioutil" + "log" + "path/filepath" + + "github.com/golang/freetype/truetype" +) + +// FontStyle defines bold and italic styles for the font +// It is possible to combine values for mixed styles, eg. +// FontData.Style = FontStyleBold | FontStyleItalic +type FontStyle byte + +const ( + FontStyleNormal FontStyle = iota + FontStyleBold + FontStyleItalic +) + +type FontFamily byte + +const ( + FontFamilySans FontFamily = iota + FontFamilySerif + FontFamilyMono +) + +type FontData struct { + Name string + Family FontFamily + Style FontStyle +} + +type FontFileNamer func(fontData FontData) string + +func FontFileName(fontData FontData) string { + fontFileName := fontData.Name + switch fontData.Family { + case FontFamilySans: + fontFileName += "s" + case FontFamilySerif: + fontFileName += "r" + case FontFamilyMono: + fontFileName += "m" + } + if fontData.Style&FontStyleBold != 0 { + fontFileName += "b" + } else { + fontFileName += "r" + } + + if fontData.Style&FontStyleItalic != 0 { + fontFileName += "i" + } + fontFileName += ".ttf" + return fontFileName +} + +func RegisterFont(fontData FontData, font *truetype.Font) { + fontCache.Store(fontData, font) +} + +func GetFont(fontData FontData) (font *truetype.Font) { + var err error + + if font, err = fontCache.Load(fontData); err != nil { + log.Println(err) + } + + return +} + +func GetFontFolder() string { + return defaultFonts.folder +} + +func SetFontFolder(folder string) { + defaultFonts.folder = filepath.Clean(folder) +} + +func SetFontNamer(fn FontFileNamer) { + defaultFonts.namer = fn +} + +// Types implementing this interface can be passed to SetFontCache to change the +// way fonts are being stored and retrieved. +type FontCache interface { + // Loads a truetype font represented by the FontData object passed as + // argument. + // The method returns an error if the font could not be loaded, either + // because it didn't exist or the resource it was loaded from was corrupted. + Load(FontData) (*truetype.Font, error) + + // Sets the truetype font that will be returned by Load when given the font + // data passed as first argument. + Store(FontData, *truetype.Font) +} + +// Changes the font cache backend used by the package. After calling this +// functionSetFontFolder and SetFontNamer will not affect anymore how fonts are +// loaded. +// To restore the default font cache, call this function passing nil as argument. +func SetFontCache(cache FontCache) { + if cache == nil { + fontCache = defaultFonts + } else { + fontCache = cache + } +} + +type defaultFontCache struct { + fonts map[string]*truetype.Font + folder string + namer FontFileNamer +} + +func (cache *defaultFontCache) Load(fontData FontData) (font *truetype.Font, err error) { + if font = cache.fonts[cache.namer(fontData)]; font != nil { + return font, nil + } + + var data []byte + var file = cache.namer(fontData) + + if data, err = ioutil.ReadFile(filepath.Join(cache.folder, file)); err != nil { + return + } + + if font, err = truetype.Parse(data); err != nil { + return + } + + cache.fonts[file] = font + return +} + +func (cache *defaultFontCache) Store(fontData FontData, font *truetype.Font) { + cache.fonts[cache.namer(fontData)] = font +} + +var ( + defaultFonts = &defaultFontCache{ + fonts: make(map[string]*truetype.Font), + folder: "../resource/font", + namer: FontFileName, + } + + fontCache FontCache = defaultFonts +) diff --git a/vendor/github.com/llgcode/draw2d/gc.go b/vendor/github.com/llgcode/draw2d/gc.go new file mode 100644 index 00000000..6266c16f --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/gc.go @@ -0,0 +1,83 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 21/11/2010 by Laurent Le Goff + +package draw2d + +import ( + "image" + "image/color" +) + +// GraphicContext describes the interface for the various backends (images, pdf, opengl, ...) +type GraphicContext interface { + // PathBuilder describes the interface for path drawing + PathBuilder + // BeginPath creates a new path + BeginPath() + // GetMatrixTransform returns the current transformation matrix + GetMatrixTransform() Matrix + // SetMatrixTransform sets the current transformation matrix + SetMatrixTransform(tr Matrix) + // ComposeMatrixTransform composes the current transformation matrix with tr + ComposeMatrixTransform(tr Matrix) + // Rotate applies a rotation to the current transformation matrix. angle is in radian. + Rotate(angle float64) + // Translate applies a translation to the current transformation matrix. + Translate(tx, ty float64) + // Scale applies a scale to the current transformation matrix. + Scale(sx, sy float64) + // SetStrokeColor sets the current stroke color + SetStrokeColor(c color.Color) + // SetFillColor sets the current fill color + SetFillColor(c color.Color) + // SetFillRule sets the current fill rule + SetFillRule(f FillRule) + // SetLineWidth sets the current line width + SetLineWidth(lineWidth float64) + // SetLineCap sets the current line cap + SetLineCap(cap LineCap) + // SetLineJoin sets the current line join + SetLineJoin(join LineJoin) + // SetLineDash sets the current dash + SetLineDash(dash []float64, dashOffset float64) + // SetFontSize sets the current font size + SetFontSize(fontSize float64) + // GetFontSize gets the current font size + GetFontSize() float64 + // SetFontData sets the current FontData + SetFontData(fontData FontData) + // GetFontData gets the current FontData + GetFontData() FontData + // DrawImage draws the raster image in the current canvas + DrawImage(image image.Image) + // Save the context and push it to the context stack + Save() + // Restore remove the current context and restore the last one + Restore() + // Clear fills the current canvas with a default transparent color + Clear() + // ClearRect fills the specified rectangle with a default transparent color + ClearRect(x1, y1, x2, y2 int) + // SetDPI sets the current DPI + SetDPI(dpi int) + // GetDPI gets the current DPI + GetDPI() int + // GetStringBounds gets pixel bounds(dimensions) of given string + GetStringBounds(s string) (left, top, right, bottom float64) + // CreateStringPath creates a path from the string s at x, y + CreateStringPath(text string, x, y float64) (cursor float64) + // FillString draws the text at point (0, 0) + FillString(text string) (cursor float64) + // FillStringAt draws the text at the specified point (x, y) + FillStringAt(text string, x, y float64) (cursor float64) + // StrokeString draws the contour of the text at point (0, 0) + StrokeString(text string) (cursor float64) + // StrokeStringAt draws the contour of the text at point (x, y) + StrokeStringAt(text string, x, y float64) (cursor float64) + // Stroke strokes the paths with the color specified by SetStrokeColor + Stroke(paths ...*Path) + // Fill fills the paths with the color specified by SetFillColor + Fill(paths ...*Path) + // FillStroke first fills the paths and than strokes them + FillStroke(paths ...*Path) +} diff --git a/vendor/github.com/llgcode/draw2d/matrix.go b/vendor/github.com/llgcode/draw2d/matrix.go new file mode 100644 index 00000000..55f5e387 --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/matrix.go @@ -0,0 +1,222 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 21/11/2010 by Laurent Le Goff + +package draw2d + +import ( + "math" +) + +// Matrix represents an affine transformation +type Matrix [6]float64 + +const ( + epsilon = 1e-6 +) + +// Determinant compute the determinant of the matrix +func (tr Matrix) Determinant() float64 { + return tr[0]*tr[3] - tr[1]*tr[2] +} + +// Transform applies the transformation matrix to points. It modify the points passed in parameter. +func (tr Matrix) Transform(points []float64) { + for i, j := 0, 1; j < len(points); i, j = i+2, j+2 { + x := points[i] + y := points[j] + points[i] = x*tr[0] + y*tr[2] + tr[4] + points[j] = x*tr[1] + y*tr[3] + tr[5] + } +} + +// TransformPoint applies the transformation matrix to point. It returns the point the transformed point. +func (tr Matrix) TransformPoint(x, y float64) (xres, yres float64) { + xres = x*tr[0] + y*tr[2] + tr[4] + yres = x*tr[1] + y*tr[3] + tr[5] + return xres, yres +} + +func minMax(x, y float64) (min, max float64) { + if x > y { + return y, x + } + return x, y +} + +// Transform applies the transformation matrix to the rectangle represented by the min and the max point of the rectangle +func (tr Matrix) TransformRectangle(x0, y0, x2, y2 float64) (nx0, ny0, nx2, ny2 float64) { + points := []float64{x0, y0, x2, y0, x2, y2, x0, y2} + tr.Transform(points) + points[0], points[2] = minMax(points[0], points[2]) + points[4], points[6] = minMax(points[4], points[6]) + points[1], points[3] = minMax(points[1], points[3]) + points[5], points[7] = minMax(points[5], points[7]) + + nx0 = math.Min(points[0], points[4]) + ny0 = math.Min(points[1], points[5]) + nx2 = math.Max(points[2], points[6]) + ny2 = math.Max(points[3], points[7]) + return nx0, ny0, nx2, ny2 +} + +// InverseTransform applies the transformation inverse matrix to the rectangle represented by the min and the max point of the rectangle +func (tr Matrix) InverseTransform(points []float64) { + d := tr.Determinant() // matrix determinant + for i, j := 0, 1; j < len(points); i, j = i+2, j+2 { + x := points[i] + y := points[j] + points[i] = ((x-tr[4])*tr[3] - (y-tr[5])*tr[2]) / d + points[j] = ((y-tr[5])*tr[0] - (x-tr[4])*tr[1]) / d + } +} + +// InverseTransformPoint applies the transformation inverse matrix to point. It returns the point the transformed point. +func (tr Matrix) InverseTransformPoint(x, y float64) (xres, yres float64) { + d := tr.Determinant() // matrix determinant + xres = ((x-tr[4])*tr[3] - (y-tr[5])*tr[2]) / d + yres = ((y-tr[5])*tr[0] - (x-tr[4])*tr[1]) / d + return xres, yres +} + +// VectorTransform applies the transformation matrix to points without using the translation parameter of the affine matrix. +// It modify the points passed in parameter. +func (tr Matrix) VectorTransform(points []float64) { + for i, j := 0, 1; j < len(points); i, j = i+2, j+2 { + x := points[i] + y := points[j] + points[i] = x*tr[0] + y*tr[2] + points[j] = x*tr[1] + y*tr[3] + } +} + +// NewIdentityMatrix creates an identity transformation matrix. +func NewIdentityMatrix() Matrix { + return Matrix{1, 0, 0, 1, 0, 0} +} + +// NewTranslationMatrix creates a transformation matrix with a translation tx and ty translation parameter +func NewTranslationMatrix(tx, ty float64) Matrix { + return Matrix{1, 0, 0, 1, tx, ty} +} + +// NewScaleMatrix creates a transformation matrix with a sx, sy scale factor +func NewScaleMatrix(sx, sy float64) Matrix { + return Matrix{sx, 0, 0, sy, 0, 0} +} + +// NewRotationMatrix creates a rotation transformation matrix. angle is in radian +func NewRotationMatrix(angle float64) Matrix { + c := math.Cos(angle) + s := math.Sin(angle) + return Matrix{c, s, -s, c, 0, 0} +} + +// NewMatrixFromRects creates a transformation matrix, combining a scale and a translation, that transform rectangle1 into rectangle2. +func NewMatrixFromRects(rectangle1, rectangle2 [4]float64) Matrix { + xScale := (rectangle2[2] - rectangle2[0]) / (rectangle1[2] - rectangle1[0]) + yScale := (rectangle2[3] - rectangle2[1]) / (rectangle1[3] - rectangle1[1]) + xOffset := rectangle2[0] - (rectangle1[0] * xScale) + yOffset := rectangle2[1] - (rectangle1[1] * yScale) + return Matrix{xScale, 0, 0, yScale, xOffset, yOffset} +} + +// Inverse computes the inverse matrix +func (tr *Matrix) Inverse() { + d := tr.Determinant() // matrix determinant + tr0, tr1, tr2, tr3, tr4, tr5 := tr[0], tr[1], tr[2], tr[3], tr[4], tr[5] + tr[0] = tr3 / d + tr[1] = -tr1 / d + tr[2] = -tr2 / d + tr[3] = tr0 / d + tr[4] = (tr2*tr5 - tr3*tr4) / d + tr[5] = (tr1*tr4 - tr0*tr5) / d +} + +func (tr Matrix) Copy() Matrix { + var result Matrix + copy(result[:], tr[:]) + return result +} + +// Compose multiplies trToConcat x tr +func (tr *Matrix) Compose(trToCompose Matrix) { + tr0, tr1, tr2, tr3, tr4, tr5 := tr[0], tr[1], tr[2], tr[3], tr[4], tr[5] + tr[0] = trToCompose[0]*tr0 + trToCompose[1]*tr2 + tr[1] = trToCompose[1]*tr3 + trToCompose[0]*tr1 + tr[2] = trToCompose[2]*tr0 + trToCompose[3]*tr2 + tr[3] = trToCompose[3]*tr3 + trToCompose[2]*tr1 + tr[4] = trToCompose[4]*tr0 + trToCompose[5]*tr2 + tr4 + tr[5] = trToCompose[5]*tr3 + trToCompose[4]*tr1 + tr5 +} + +// Scale adds a scale to the matrix +func (tr *Matrix) Scale(sx, sy float64) { + tr[0] = sx * tr[0] + tr[1] = sx * tr[1] + tr[2] = sy * tr[2] + tr[3] = sy * tr[3] +} + +// Translate adds a translation to the matrix +func (tr *Matrix) Translate(tx, ty float64) { + tr[4] = tx*tr[0] + ty*tr[2] + tr[4] + tr[5] = ty*tr[3] + tx*tr[1] + tr[5] +} + +// Rotate adds a rotation to the matrix. angle is in radian +func (tr *Matrix) Rotate(angle float64) { + c := math.Cos(angle) + s := math.Sin(angle) + t0 := c*tr[0] + s*tr[2] + t1 := s*tr[3] + c*tr[1] + t2 := c*tr[2] - s*tr[0] + t3 := c*tr[3] - s*tr[1] + tr[0] = t0 + tr[1] = t1 + tr[2] = t2 + tr[3] = t3 +} + +// GetTranslation +func (tr Matrix) GetTranslation() (x, y float64) { + return tr[4], tr[5] +} + +// GetScaling +func (tr Matrix) GetScaling() (x, y float64) { + return tr[0], tr[3] +} + +// GetScale computes a scale for the matrix +func (tr Matrix) GetScale() float64 { + x := 0.707106781*tr[0] + 0.707106781*tr[1] + y := 0.707106781*tr[2] + 0.707106781*tr[3] + return math.Sqrt(x*x + y*y) +} + +// ******************** Testing ******************** + +// Equals tests if a two transformation are equal. A tolerance is applied when comparing matrix elements. +func (tr1 Matrix) Equals(tr2 Matrix) bool { + for i := 0; i < 6; i = i + 1 { + if !fequals(tr1[i], tr2[i]) { + return false + } + } + return true +} + +// IsIdentity tests if a transformation is the identity transformation. A tolerance is applied when comparing matrix elements. +func (tr Matrix) IsIdentity() bool { + return fequals(tr[4], 0) && fequals(tr[5], 0) && tr.IsTranslation() +} + +// IsTranslation tests if a transformation is is a pure translation. A tolerance is applied when comparing matrix elements. +func (tr Matrix) IsTranslation() bool { + return fequals(tr[0], 1) && fequals(tr[1], 0) && fequals(tr[2], 0) && fequals(tr[3], 1) +} + +// fequals compares two floats. return true if the distance between the two floats is less than epsilon, false otherwise +func fequals(float1, float2 float64) bool { + return math.Abs(float1-float2) <= epsilon +} diff --git a/vendor/github.com/llgcode/draw2d/path.go b/vendor/github.com/llgcode/draw2d/path.go new file mode 100644 index 00000000..57ba3ffb --- /dev/null +++ b/vendor/github.com/llgcode/draw2d/path.go @@ -0,0 +1,189 @@ +// Copyright 2010 The draw2d Authors. All rights reserved. +// created: 21/11/2010 by Laurent Le Goff + +package draw2d + +import ( + "fmt" + "math" +) + +// PathBuilder describes the interface for path drawing. +type PathBuilder interface { + // LastPoint returns the current point of the current sub path + LastPoint() (x, y float64) + // MoveTo creates a new subpath that start at the specified point + MoveTo(x, y float64) + // LineTo adds a line to the current subpath + LineTo(x, y float64) + // QuadCurveTo adds a quadratic Bézier curve to the current subpath + QuadCurveTo(cx, cy, x, y float64) + // CubicCurveTo adds a cubic Bézier curve to the current subpath + CubicCurveTo(cx1, cy1, cx2, cy2, x, y float64) + // ArcTo adds an arc to the current subpath + ArcTo(cx, cy, rx, ry, startAngle, angle float64) + // Close creates a line from the current point to the last MoveTo + // point (if not the same) and mark the path as closed so the + // first and last lines join nicely. + Close() +} + +// PathCmp represents component of a path +type PathCmp int + +const ( + // MoveToCmp is a MoveTo component in a Path + MoveToCmp PathCmp = iota + // LineToCmp is a LineTo component in a Path + LineToCmp + // QuadCurveToCmp is a QuadCurveTo component in a Path + QuadCurveToCmp + // CubicCurveToCmp is a CubicCurveTo component in a Path + CubicCurveToCmp + // ArcToCmp is a ArcTo component in a Path + ArcToCmp + // CloseCmp is a ArcTo component in a Path + CloseCmp +) + +// Path stores points +type Path struct { + // Components is a slice of PathCmp in a Path and mark the role of each points in the Path + Components []PathCmp + // Points are combined with Components to have a specific role in the path + Points []float64 + // Last Point of the Path + x, y float64 +} + +func (p *Path) appendToPath(cmd PathCmp, points ...float64) { + p.Components = append(p.Components, cmd) + p.Points = append(p.Points, points...) +} + +// LastPoint returns the current point of the current path +func (p *Path) LastPoint() (x, y float64) { + return p.x, p.y +} + +// MoveTo starts a new path at (x, y) position +func (p *Path) MoveTo(x, y float64) { + p.appendToPath(MoveToCmp, x, y) + p.x = x + p.y = y +} + +// LineTo adds a line to the current path +func (p *Path) LineTo(x, y float64) { + if len(p.Components) == 0 { //special case when no move has been done + p.MoveTo(0, 0) + } + p.appendToPath(LineToCmp, x, y) + p.x = x + p.y = y +} + +// QuadCurveTo adds a quadratic bezier curve to the current path +func (p *Path) QuadCurveTo(cx, cy, x, y float64) { + if len(p.Components) == 0 { //special case when no move has been done + p.MoveTo(0, 0) + } + p.appendToPath(QuadCurveToCmp, cx, cy, x, y) + p.x = x + p.y = y +} + +// CubicCurveTo adds a cubic bezier curve to the current path +func (p *Path) CubicCurveTo(cx1, cy1, cx2, cy2, x, y float64) { + if len(p.Components) == 0 { //special case when no move has been done + p.MoveTo(0, 0) + } + p.appendToPath(CubicCurveToCmp, cx1, cy1, cx2, cy2, x, y) + p.x = x + p.y = y +} + +// ArcTo adds an arc to the path +func (p *Path) ArcTo(cx, cy, rx, ry, startAngle, angle float64) { + endAngle := startAngle + angle + clockWise := true + if angle < 0 { + clockWise = false + } + // normalize + if clockWise { + for endAngle < startAngle { + endAngle += math.Pi * 2.0 + } + } else { + for startAngle < endAngle { + startAngle += math.Pi * 2.0 + } + } + startX := cx + math.Cos(startAngle)*rx + startY := cy + math.Sin(startAngle)*ry + if len(p.Components) > 0 { + p.LineTo(startX, startY) + } else { + p.MoveTo(startX, startY) + } + p.appendToPath(ArcToCmp, cx, cy, rx, ry, startAngle, angle) + p.x = cx + math.Cos(endAngle)*rx + p.y = cy + math.Sin(endAngle)*ry +} + +// Close closes the current path +func (p *Path) Close() { + p.appendToPath(CloseCmp) +} + +// Copy make a clone of the current path and return it +func (p *Path) Copy() (dest *Path) { + dest = new(Path) + dest.Components = make([]PathCmp, len(p.Components)) + copy(dest.Components, p.Components) + dest.Points = make([]float64, len(p.Points)) + copy(dest.Points, p.Points) + dest.x, dest.y = p.x, p.y + return dest +} + +// Clear reset the path +func (p *Path) Clear() { + p.Components = p.Components[0:0] + p.Points = p.Points[0:0] + return +} + +// IsEmpty returns true if the path is empty +func (p *Path) IsEmpty() bool { + return len(p.Components) == 0 +} + +// String returns a debug text view of the path +func (p *Path) String() string { + s := "" + j := 0 + for _, cmd := range p.Components { + switch cmd { + case MoveToCmp: + s += fmt.Sprintf("MoveTo: %f, %f\n", p.Points[j], p.Points[j+1]) + j = j + 2 + case LineToCmp: + s += fmt.Sprintf("LineTo: %f, %f\n", p.Points[j], p.Points[j+1]) + j = j + 2 + case QuadCurveToCmp: + s += fmt.Sprintf("QuadCurveTo: %f, %f, %f, %f\n", p.Points[j], p.Points[j+1], p.Points[j+2], p.Points[j+3]) + j = j + 4 + case CubicCurveToCmp: + s += fmt.Sprintf("CubicCurveTo: %f, %f, %f, %f, %f, %f\n", p.Points[j], p.Points[j+1], p.Points[j+2], p.Points[j+3], p.Points[j+4], p.Points[j+5]) + j = j + 6 + case ArcToCmp: + s += fmt.Sprintf("ArcTo: %f, %f, %f, %f, %f, %f\n", p.Points[j], p.Points[j+1], p.Points[j+2], p.Points[j+3], p.Points[j+4], p.Points[j+5]) + j = j + 6 + case CloseCmp: + s += "Close\n" + } + } + return s +} diff --git a/vendor/github.com/mattn/go-runewidth/runewidth.go b/vendor/github.com/mattn/go-runewidth/runewidth.go new file mode 100644 index 00000000..3fbf33d5 --- /dev/null +++ b/vendor/github.com/mattn/go-runewidth/runewidth.go @@ -0,0 +1,464 @@ +package runewidth + +var EastAsianWidth = IsEastAsian() +var DefaultCondition = &Condition{EastAsianWidth} + +type interval struct { + first rune + last rune +} + +var combining = []interval{ + {0x0300, 0x036F}, {0x0483, 0x0486}, {0x0488, 0x0489}, + {0x0591, 0x05BD}, {0x05BF, 0x05BF}, {0x05C1, 0x05C2}, + {0x05C4, 0x05C5}, {0x05C7, 0x05C7}, {0x0600, 0x0603}, + {0x0610, 0x0615}, {0x064B, 0x065E}, {0x0670, 0x0670}, + {0x06D6, 0x06E4}, {0x06E7, 0x06E8}, {0x06EA, 0x06ED}, + {0x070F, 0x070F}, {0x0711, 0x0711}, {0x0730, 0x074A}, + {0x07A6, 0x07B0}, {0x07EB, 0x07F3}, {0x0901, 0x0902}, + {0x093C, 0x093C}, {0x0941, 0x0948}, {0x094D, 0x094D}, + {0x0951, 0x0954}, {0x0962, 0x0963}, {0x0981, 0x0981}, + {0x09BC, 0x09BC}, {0x09C1, 0x09C4}, {0x09CD, 0x09CD}, + {0x09E2, 0x09E3}, {0x0A01, 0x0A02}, {0x0A3C, 0x0A3C}, + {0x0A41, 0x0A42}, {0x0A47, 0x0A48}, {0x0A4B, 0x0A4D}, + {0x0A70, 0x0A71}, {0x0A81, 0x0A82}, {0x0ABC, 0x0ABC}, + {0x0AC1, 0x0AC5}, {0x0AC7, 0x0AC8}, {0x0ACD, 0x0ACD}, + {0x0AE2, 0x0AE3}, {0x0B01, 0x0B01}, {0x0B3C, 0x0B3C}, + {0x0B3F, 0x0B3F}, {0x0B41, 0x0B43}, {0x0B4D, 0x0B4D}, + {0x0B56, 0x0B56}, {0x0B82, 0x0B82}, {0x0BC0, 0x0BC0}, + {0x0BCD, 0x0BCD}, {0x0C3E, 0x0C40}, {0x0C46, 0x0C48}, + {0x0C4A, 0x0C4D}, {0x0C55, 0x0C56}, {0x0CBC, 0x0CBC}, + {0x0CBF, 0x0CBF}, {0x0CC6, 0x0CC6}, {0x0CCC, 0x0CCD}, + {0x0CE2, 0x0CE3}, {0x0D41, 0x0D43}, {0x0D4D, 0x0D4D}, + {0x0DCA, 0x0DCA}, {0x0DD2, 0x0DD4}, {0x0DD6, 0x0DD6}, + {0x0E31, 0x0E31}, {0x0E34, 0x0E3A}, {0x0E47, 0x0E4E}, + {0x0EB1, 0x0EB1}, {0x0EB4, 0x0EB9}, {0x0EBB, 0x0EBC}, + {0x0EC8, 0x0ECD}, {0x0F18, 0x0F19}, {0x0F35, 0x0F35}, + {0x0F37, 0x0F37}, {0x0F39, 0x0F39}, {0x0F71, 0x0F7E}, + {0x0F80, 0x0F84}, {0x0F86, 0x0F87}, {0x0F90, 0x0F97}, + {0x0F99, 0x0FBC}, {0x0FC6, 0x0FC6}, {0x102D, 0x1030}, + {0x1032, 0x1032}, {0x1036, 0x1037}, {0x1039, 0x1039}, + {0x1058, 0x1059}, {0x1160, 0x11FF}, {0x135F, 0x135F}, + {0x1712, 0x1714}, {0x1732, 0x1734}, {0x1752, 0x1753}, + {0x1772, 0x1773}, {0x17B4, 0x17B5}, {0x17B7, 0x17BD}, + {0x17C6, 0x17C6}, {0x17C9, 0x17D3}, {0x17DD, 0x17DD}, + {0x180B, 0x180D}, {0x18A9, 0x18A9}, {0x1920, 0x1922}, + {0x1927, 0x1928}, {0x1932, 0x1932}, {0x1939, 0x193B}, + {0x1A17, 0x1A18}, {0x1B00, 0x1B03}, {0x1B34, 0x1B34}, + {0x1B36, 0x1B3A}, {0x1B3C, 0x1B3C}, {0x1B42, 0x1B42}, + {0x1B6B, 0x1B73}, {0x1DC0, 0x1DCA}, {0x1DFE, 0x1DFF}, + {0x200B, 0x200F}, {0x202A, 0x202E}, {0x2060, 0x2063}, + {0x206A, 0x206F}, {0x20D0, 0x20EF}, {0x302A, 0x302F}, + {0x3099, 0x309A}, {0xA806, 0xA806}, {0xA80B, 0xA80B}, + {0xA825, 0xA826}, {0xFB1E, 0xFB1E}, {0xFE00, 0xFE0F}, + {0xFE20, 0xFE23}, {0xFEFF, 0xFEFF}, {0xFFF9, 0xFFFB}, + {0x10A01, 0x10A03}, {0x10A05, 0x10A06}, {0x10A0C, 0x10A0F}, + {0x10A38, 0x10A3A}, {0x10A3F, 0x10A3F}, {0x1D167, 0x1D169}, + {0x1D173, 0x1D182}, {0x1D185, 0x1D18B}, {0x1D1AA, 0x1D1AD}, + {0x1D242, 0x1D244}, {0xE0001, 0xE0001}, {0xE0020, 0xE007F}, + {0xE0100, 0xE01EF}, +} + +type ctype int + +const ( + narrow ctype = iota + ambiguous + wide + halfwidth + fullwidth + neutral +) + +type intervalType struct { + first rune + last rune + ctype ctype +} + +var ctypes = []intervalType{ + {0x0020, 0x007E, narrow}, + {0x00A1, 0x00A1, ambiguous}, + {0x00A2, 0x00A3, narrow}, + {0x00A4, 0x00A4, ambiguous}, + {0x00A5, 0x00A6, narrow}, + {0x00A7, 0x00A8, ambiguous}, + {0x00AA, 0x00AA, ambiguous}, + {0x00AC, 0x00AC, narrow}, + {0x00AD, 0x00AE, ambiguous}, + {0x00AF, 0x00AF, narrow}, + {0x00B0, 0x00B4, ambiguous}, + {0x00B6, 0x00BA, ambiguous}, + {0x00BC, 0x00BF, ambiguous}, + {0x00C6, 0x00C6, ambiguous}, + {0x00D0, 0x00D0, ambiguous}, + {0x00D7, 0x00D8, ambiguous}, + {0x00DE, 0x00E1, ambiguous}, + {0x00E6, 0x00E6, ambiguous}, + {0x00E8, 0x00EA, ambiguous}, + {0x00EC, 0x00ED, ambiguous}, + {0x00F0, 0x00F0, ambiguous}, + {0x00F2, 0x00F3, ambiguous}, + {0x00F7, 0x00FA, ambiguous}, + {0x00FC, 0x00FC, ambiguous}, + {0x00FE, 0x00FE, ambiguous}, + {0x0101, 0x0101, ambiguous}, + {0x0111, 0x0111, ambiguous}, + {0x0113, 0x0113, ambiguous}, + {0x011B, 0x011B, ambiguous}, + {0x0126, 0x0127, ambiguous}, + {0x012B, 0x012B, ambiguous}, + {0x0131, 0x0133, ambiguous}, + {0x0138, 0x0138, ambiguous}, + {0x013F, 0x0142, ambiguous}, + {0x0144, 0x0144, ambiguous}, + {0x0148, 0x014B, ambiguous}, + {0x014D, 0x014D, ambiguous}, + {0x0152, 0x0153, ambiguous}, + {0x0166, 0x0167, ambiguous}, + {0x016B, 0x016B, ambiguous}, + {0x01CE, 0x01CE, ambiguous}, + {0x01D0, 0x01D0, ambiguous}, + {0x01D2, 0x01D2, ambiguous}, + {0x01D4, 0x01D4, ambiguous}, + {0x01D6, 0x01D6, ambiguous}, + {0x01D8, 0x01D8, ambiguous}, + {0x01DA, 0x01DA, ambiguous}, + {0x01DC, 0x01DC, ambiguous}, + {0x0251, 0x0251, ambiguous}, + {0x0261, 0x0261, ambiguous}, + {0x02C4, 0x02C4, ambiguous}, + {0x02C7, 0x02C7, ambiguous}, + {0x02C9, 0x02CB, ambiguous}, + {0x02CD, 0x02CD, ambiguous}, + {0x02D0, 0x02D0, ambiguous}, + {0x02D8, 0x02DB, ambiguous}, + {0x02DD, 0x02DD, ambiguous}, + {0x02DF, 0x02DF, ambiguous}, + {0x0300, 0x036F, ambiguous}, + {0x0391, 0x03A2, ambiguous}, + {0x03A3, 0x03A9, ambiguous}, + {0x03B1, 0x03C1, ambiguous}, + {0x03C3, 0x03C9, ambiguous}, + {0x0401, 0x0401, ambiguous}, + {0x0410, 0x044F, ambiguous}, + {0x0451, 0x0451, ambiguous}, + {0x1100, 0x115F, wide}, + {0x2010, 0x2010, ambiguous}, + {0x2013, 0x2016, ambiguous}, + {0x2018, 0x2019, ambiguous}, + {0x201C, 0x201D, ambiguous}, + {0x2020, 0x2022, ambiguous}, + {0x2024, 0x2027, ambiguous}, + {0x2030, 0x2030, ambiguous}, + {0x2032, 0x2033, ambiguous}, + {0x2035, 0x2035, ambiguous}, + {0x203B, 0x203B, ambiguous}, + {0x203E, 0x203E, ambiguous}, + {0x2074, 0x2074, ambiguous}, + {0x207F, 0x207F, ambiguous}, + {0x2081, 0x2084, ambiguous}, + {0x20A9, 0x20A9, halfwidth}, + {0x20AC, 0x20AC, ambiguous}, + {0x2103, 0x2103, ambiguous}, + {0x2105, 0x2105, ambiguous}, + {0x2109, 0x2109, ambiguous}, + {0x2113, 0x2113, ambiguous}, + {0x2116, 0x2116, ambiguous}, + {0x2121, 0x2122, ambiguous}, + {0x2126, 0x2126, ambiguous}, + {0x212B, 0x212B, ambiguous}, + {0x2153, 0x2154, ambiguous}, + {0x215B, 0x215E, ambiguous}, + {0x2160, 0x216B, ambiguous}, + {0x2170, 0x2179, ambiguous}, + {0x2189, 0x218A, ambiguous}, + {0x2190, 0x2199, ambiguous}, + {0x21B8, 0x21B9, ambiguous}, + {0x21D2, 0x21D2, ambiguous}, + {0x21D4, 0x21D4, ambiguous}, + {0x21E7, 0x21E7, ambiguous}, + {0x2200, 0x2200, ambiguous}, + {0x2202, 0x2203, ambiguous}, + {0x2207, 0x2208, ambiguous}, + {0x220B, 0x220B, ambiguous}, + {0x220F, 0x220F, ambiguous}, + {0x2211, 0x2211, ambiguous}, + {0x2215, 0x2215, ambiguous}, + {0x221A, 0x221A, ambiguous}, + {0x221D, 0x2220, ambiguous}, + {0x2223, 0x2223, ambiguous}, + {0x2225, 0x2225, ambiguous}, + {0x2227, 0x222C, ambiguous}, + {0x222E, 0x222E, ambiguous}, + {0x2234, 0x2237, ambiguous}, + {0x223C, 0x223D, ambiguous}, + {0x2248, 0x2248, ambiguous}, + {0x224C, 0x224C, ambiguous}, + {0x2252, 0x2252, ambiguous}, + {0x2260, 0x2261, ambiguous}, + {0x2264, 0x2267, ambiguous}, + {0x226A, 0x226B, ambiguous}, + {0x226E, 0x226F, ambiguous}, + {0x2282, 0x2283, ambiguous}, + {0x2286, 0x2287, ambiguous}, + {0x2295, 0x2295, ambiguous}, + {0x2299, 0x2299, ambiguous}, + {0x22A5, 0x22A5, ambiguous}, + {0x22BF, 0x22BF, ambiguous}, + {0x2312, 0x2312, ambiguous}, + {0x2329, 0x232A, wide}, + {0x2460, 0x24E9, ambiguous}, + {0x24EB, 0x254B, ambiguous}, + {0x2550, 0x2573, ambiguous}, + {0x2580, 0x258F, ambiguous}, + {0x2592, 0x2595, ambiguous}, + {0x25A0, 0x25A1, ambiguous}, + {0x25A3, 0x25A9, ambiguous}, + {0x25B2, 0x25B3, ambiguous}, + {0x25B6, 0x25B7, ambiguous}, + {0x25BC, 0x25BD, ambiguous}, + {0x25C0, 0x25C1, ambiguous}, + {0x25C6, 0x25C8, ambiguous}, + {0x25CB, 0x25CB, ambiguous}, + {0x25CE, 0x25D1, ambiguous}, + {0x25E2, 0x25E5, ambiguous}, + {0x25EF, 0x25EF, ambiguous}, + {0x2605, 0x2606, ambiguous}, + {0x2609, 0x2609, ambiguous}, + {0x260E, 0x260F, ambiguous}, + {0x2614, 0x2615, ambiguous}, + {0x261C, 0x261C, ambiguous}, + {0x261E, 0x261E, ambiguous}, + {0x2640, 0x2640, ambiguous}, + {0x2642, 0x2642, ambiguous}, + {0x2660, 0x2661, ambiguous}, + {0x2663, 0x2665, ambiguous}, + {0x2667, 0x266A, ambiguous}, + {0x266C, 0x266D, ambiguous}, + {0x266F, 0x266F, ambiguous}, + {0x269E, 0x269F, ambiguous}, + {0x26BE, 0x26BF, ambiguous}, + {0x26C4, 0x26CD, ambiguous}, + {0x26CF, 0x26E1, ambiguous}, + {0x26E3, 0x26E3, ambiguous}, + {0x26E8, 0x26FF, ambiguous}, + {0x273D, 0x273D, ambiguous}, + {0x2757, 0x2757, ambiguous}, + {0x2776, 0x277F, ambiguous}, + {0x27E6, 0x27ED, narrow}, + {0x2985, 0x2986, narrow}, + {0x2B55, 0x2B59, ambiguous}, + {0x2E80, 0x2E9A, wide}, + {0x2E9B, 0x2EF4, wide}, + {0x2F00, 0x2FD6, wide}, + {0x2FF0, 0x2FFC, wide}, + {0x3000, 0x3000, fullwidth}, + {0x3001, 0x303E, wide}, + {0x3041, 0x3097, wide}, + {0x3099, 0x3100, wide}, + {0x3105, 0x312E, wide}, + {0x3131, 0x318F, wide}, + {0x3190, 0x31BB, wide}, + {0x31C0, 0x31E4, wide}, + {0x31F0, 0x321F, wide}, + {0x3220, 0x3247, wide}, + {0x3248, 0x324F, ambiguous}, + {0x3250, 0x32FF, wide}, + {0x3300, 0x4DBF, wide}, + {0x4E00, 0xA48D, wide}, + {0xA490, 0xA4C7, wide}, + {0xA960, 0xA97D, wide}, + {0xAC00, 0xD7A4, wide}, + {0xE000, 0xF8FF, ambiguous}, + {0xF900, 0xFAFF, wide}, + {0xFE00, 0xFE0F, ambiguous}, + {0xFE10, 0xFE1A, wide}, + {0xFE30, 0xFE53, wide}, + {0xFE54, 0xFE67, wide}, + {0xFE68, 0xFE6C, wide}, + {0xFF01, 0xFF60, fullwidth}, + {0xFF61, 0xFFBF, halfwidth}, + {0xFFC2, 0xFFC8, halfwidth}, + {0xFFCA, 0xFFD0, halfwidth}, + {0xFFD2, 0xFFD8, halfwidth}, + {0xFFDA, 0xFFDD, halfwidth}, + {0xFFE0, 0xFFE7, fullwidth}, + {0xFFE8, 0xFFEF, halfwidth}, + {0xFFFD, 0xFFFE, ambiguous}, + {0x1B000, 0x1B002, wide}, + {0x1F100, 0x1F10A, ambiguous}, + {0x1F110, 0x1F12D, ambiguous}, + {0x1F130, 0x1F169, ambiguous}, + {0x1F170, 0x1F19B, ambiguous}, + {0x1F200, 0x1F203, wide}, + {0x1F210, 0x1F23B, wide}, + {0x1F240, 0x1F249, wide}, + {0x1F250, 0x1F252, wide}, + {0x20000, 0x2FFFE, wide}, + {0x30000, 0x3FFFE, wide}, + {0xE0100, 0xE01F0, ambiguous}, + {0xF0000, 0xFFFFD, ambiguous}, + {0x100000, 0x10FFFE, ambiguous}, +} + +type Condition struct { + EastAsianWidth bool +} + +func NewCondition() *Condition { + return &Condition{EastAsianWidth} +} + +// RuneWidth returns the number of cells in r. +// See http://www.unicode.org/reports/tr11/ +func (c *Condition) RuneWidth(r rune) int { + if r == 0 { + return 0 + } + if r < 32 || (r >= 0x7f && r < 0xa0) { + return 1 + } + for _, iv := range combining { + if iv.first <= r && r <= iv.last { + return 0 + } + } + + if c.EastAsianWidth && IsAmbiguousWidth(r) { + return 2 + } + + if r >= 0x1100 && + (r <= 0x115f || r == 0x2329 || r == 0x232a || + (r >= 0x2e80 && r <= 0xa4cf && r != 0x303f) || + (r >= 0xac00 && r <= 0xd7a3) || + (r >= 0xf900 && r <= 0xfaff) || + (r >= 0xfe30 && r <= 0xfe6f) || + (r >= 0xff00 && r <= 0xff60) || + (r >= 0xffe0 && r <= 0xffe6) || + (r >= 0x20000 && r <= 0x2fffd) || + (r >= 0x30000 && r <= 0x3fffd)) { + return 2 + } + return 1 +} + +func (c *Condition) StringWidth(s string) (width int) { + for _, r := range []rune(s) { + width += c.RuneWidth(r) + } + return width +} + +func (c *Condition) Truncate(s string, w int, tail string) string { + if c.StringWidth(s) <= w { + return s + } + r := []rune(s) + tw := c.StringWidth(tail) + w -= tw + width := 0 + i := 0 + for ; i < len(r); i++ { + cw := c.RuneWidth(r[i]) + if width+cw > w { + break + } + width += cw + } + return string(r[0:i]) + tail +} + +func (c *Condition) Wrap(s string, w int) string { + width := 0 + out := "" + for _, r := range []rune(s) { + cw := RuneWidth(r) + if r == '\n' { + out += string(r) + width = 0 + continue + } else if width+cw > w { + out += "\n" + width = 0 + out += string(r) + width += cw + continue + } + out += string(r) + width += cw + } + return out +} + +func (c *Condition) FillLeft(s string, w int) string { + width := c.StringWidth(s) + count := w - width + if count > 0 { + b := make([]byte, count) + for i := range b { + b[i] = ' ' + } + return string(b) + s + } + return s +} + +func (c *Condition) FillRight(s string, w int) string { + width := c.StringWidth(s) + count := w - width + if count > 0 { + b := make([]byte, count) + for i := range b { + b[i] = ' ' + } + return s + string(b) + } + return s +} + +// RuneWidth returns the number of cells in r. +// See http://www.unicode.org/reports/tr11/ +func RuneWidth(r rune) int { + return DefaultCondition.RuneWidth(r) +} + +func ct(r rune) ctype { + for _, iv := range ctypes { + if iv.first <= r && r <= iv.last { + return iv.ctype + } + } + return neutral +} + +// IsAmbiguousWidth returns whether is ambiguous width or not. +func IsAmbiguousWidth(r rune) bool { + return ct(r) == ambiguous +} + +// IsAmbiguousWidth returns whether is ambiguous width or not. +func IsNeutralWidth(r rune) bool { + return ct(r) == neutral +} + +func StringWidth(s string) (width int) { + return DefaultCondition.StringWidth(s) +} + +func Truncate(s string, w int, tail string) string { + return DefaultCondition.Truncate(s, w, tail) +} + +func Wrap(s string, w int) string { + return DefaultCondition.Wrap(s, w) +} + +func FillLeft(s string, w int) string { + return DefaultCondition.FillLeft(s, w) +} + +func FillRight(s string, w int) string { + return DefaultCondition.FillRight(s, w) +} diff --git a/vendor/github.com/mattn/go-runewidth/runewidth_js.go b/vendor/github.com/mattn/go-runewidth/runewidth_js.go new file mode 100644 index 00000000..0ce32c5e --- /dev/null +++ b/vendor/github.com/mattn/go-runewidth/runewidth_js.go @@ -0,0 +1,8 @@ +// +build js + +package runewidth + +func IsEastAsian() bool { + // TODO: Implement this for the web. Detect east asian in a compatible way, and return true. + return false +} diff --git a/vendor/github.com/mattn/go-runewidth/runewidth_posix.go b/vendor/github.com/mattn/go-runewidth/runewidth_posix.go new file mode 100644 index 00000000..a4495909 --- /dev/null +++ b/vendor/github.com/mattn/go-runewidth/runewidth_posix.go @@ -0,0 +1,69 @@ +// +build !windows,!js + +package runewidth + +import ( + "os" + "regexp" + "strings" +) + +var reLoc = regexp.MustCompile(`^[a-z][a-z][a-z]?(?:_[A-Z][A-Z])?\.(.+)`) + +func IsEastAsian() bool { + locale := os.Getenv("LC_CTYPE") + if locale == "" { + locale = os.Getenv("LANG") + } + + // ignore C locale + if locale == "POSIX" || locale == "C" { + return false + } + if len(locale) > 1 && locale[0] == 'C' && (locale[1] == '.' || locale[1] == '-') { + return false + } + + charset := strings.ToLower(locale) + r := reLoc.FindStringSubmatch(locale) + if len(r) == 2 { + charset = strings.ToLower(r[1]) + } + + if strings.HasSuffix(charset, "@cjk_narrow") { + return false + } + + for pos, b := range []byte(charset) { + if b == '@' { + charset = charset[:pos] + break + } + } + + mbc_max := 1 + switch charset { + case "utf-8", "utf8": + mbc_max = 6 + case "jis": + mbc_max = 8 + case "eucjp": + mbc_max = 3 + case "euckr", "euccn": + mbc_max = 2 + case "sjis", "cp932", "cp51932", "cp936", "cp949", "cp950": + mbc_max = 2 + case "big5": + mbc_max = 2 + case "gbk", "gb2312": + mbc_max = 2 + } + + if mbc_max > 1 && (charset[0] != 'u' || + strings.HasPrefix(locale, "ja") || + strings.HasPrefix(locale, "ko") || + strings.HasPrefix(locale, "zh")) { + return true + } + return false +} diff --git a/vendor/github.com/mattn/go-runewidth/runewidth_windows.go b/vendor/github.com/mattn/go-runewidth/runewidth_windows.go new file mode 100644 index 00000000..bdd84454 --- /dev/null +++ b/vendor/github.com/mattn/go-runewidth/runewidth_windows.go @@ -0,0 +1,24 @@ +package runewidth + +import ( + "syscall" +) + +var ( + kernel32 = syscall.NewLazyDLL("kernel32") + procGetConsoleOutputCP = kernel32.NewProc("GetConsoleOutputCP") +) + +func IsEastAsian() bool { + r1, _, _ := procGetConsoleOutputCP.Call() + if r1 == 0 { + return false + } + + switch int(r1) { + case 932, 51932, 936, 949, 950: + return true + } + + return false +} diff --git a/vendor/github.com/olekukonko/tablewriter/LICENCE.md b/vendor/github.com/olekukonko/tablewriter/LICENCE.md new file mode 100644 index 00000000..1fd84842 --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/LICENCE.md @@ -0,0 +1,19 @@ +Copyright (C) 2014 by Oleku Konko + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. \ No newline at end of file diff --git a/vendor/github.com/olekukonko/tablewriter/csv.go b/vendor/github.com/olekukonko/tablewriter/csv.go new file mode 100644 index 00000000..98878303 --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/csv.go @@ -0,0 +1,52 @@ +// Copyright 2014 Oleku Konko All rights reserved. +// Use of this source code is governed by a MIT +// license that can be found in the LICENSE file. + +// This module is a Table Writer API for the Go Programming Language. +// The protocols were written in pure Go and works on windows and unix systems + +package tablewriter + +import ( + "encoding/csv" + "io" + "os" +) + +// Start A new table by importing from a CSV file +// Takes io.Writer and csv File name +func NewCSV(writer io.Writer, fileName string, hasHeader bool) (*Table, error) { + file, err := os.Open(fileName) + if err != nil { + return &Table{}, err + } + defer file.Close() + csvReader := csv.NewReader(file) + t, err := NewCSVReader(writer, csvReader, hasHeader) + return t, err +} + +// Start a New Table Writer with csv.Reader +// This enables customisation such as reader.Comma = ';' +// See http://golang.org/src/pkg/encoding/csv/reader.go?s=3213:3671#L94 +func NewCSVReader(writer io.Writer, csvReader *csv.Reader, hasHeader bool) (*Table, error) { + t := NewWriter(writer) + if hasHeader { + // Read the first row + headers, err := csvReader.Read() + if err != nil { + return &Table{}, err + } + t.SetHeader(headers) + } + for { + record, err := csvReader.Read() + if err == io.EOF { + break + } else if err != nil { + return &Table{}, err + } + t.Append(record) + } + return t, nil +} diff --git a/vendor/github.com/olekukonko/tablewriter/table.go b/vendor/github.com/olekukonko/tablewriter/table.go new file mode 100644 index 00000000..bf4d2b86 --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/table.go @@ -0,0 +1,521 @@ +// Copyright 2014 Oleku Konko All rights reserved. +// Use of this source code is governed by a MIT +// license that can be found in the LICENSE file. + +// This module is a Table Writer API for the Go Programming Language. +// The protocols were written in pure Go and works on windows and unix systems + +// Create & Generate text based table +package tablewriter + +import ( + "fmt" + "io" + "regexp" + "strings" +) + +const ( + MAX_ROW_WIDTH = 30 +) + +const ( + CENTER = "+" + ROW = "-" + COLUMN = "|" + SPACE = " " +) + +const ( + ALIGN_DEFAULT = iota + ALIGN_CENTER + ALIGN_RIGHT + ALIGN_LEFT +) + +var ( + decimal = regexp.MustCompile(`^-*\d*\.?\d*$`) + percent = regexp.MustCompile(`^-*\d*\.?\d*$%$`) +) + +type Border struct { + Left bool + Right bool + Top bool + Bottom bool +} + +type Table struct { + out io.Writer + rows [][]string + lines [][][]string + cs map[int]int + rs map[int]int + headers []string + footers []string + autoFmt bool + autoWrap bool + mW int + pCenter string + pRow string + pColumn string + tColumn int + tRow int + hAlign int + fAlign int + align int + rowLine bool + hdrLine bool + borders Border + colSize int +} + +// Start New Table +// Take io.Writer Directly +func NewWriter(writer io.Writer) *Table { + t := &Table{ + out: writer, + rows: [][]string{}, + lines: [][][]string{}, + cs: make(map[int]int), + rs: make(map[int]int), + headers: []string{}, + footers: []string{}, + autoFmt: true, + autoWrap: true, + mW: MAX_ROW_WIDTH, + pCenter: CENTER, + pRow: ROW, + pColumn: COLUMN, + tColumn: -1, + tRow: -1, + hAlign: ALIGN_DEFAULT, + fAlign: ALIGN_DEFAULT, + align: ALIGN_DEFAULT, + rowLine: false, + hdrLine: true, + borders: Border{Left: true, Right: true, Bottom: true, Top: true}, + colSize: -1} + return t +} + +// Render table output +func (t Table) Render() { + if t.borders.Top { + t.printLine(true) + } + t.printHeading() + t.printRows() + + if !t.rowLine && t.borders.Bottom { + t.printLine(true) + } + t.printFooter() + +} + +// Set table header +func (t *Table) SetHeader(keys []string) { + t.colSize = len(keys) + for i, v := range keys { + t.parseDimension(v, i, -1) + t.headers = append(t.headers, v) + } +} + +// Set table Footer +func (t *Table) SetFooter(keys []string) { + //t.colSize = len(keys) + for i, v := range keys { + t.parseDimension(v, i, -1) + t.footers = append(t.footers, v) + } +} + +// Turn header autoformatting on/off. Default is on (true). +func (t *Table) SetAutoFormatHeaders(auto bool) { + t.autoFmt = auto +} + +// Turn automatic multiline text adjustment on/off. Default is on (true). +func (t *Table) SetAutoWrapText(auto bool) { + t.autoWrap = auto +} + +// Set the Default column width +func (t *Table) SetColWidth(width int) { + t.mW = width +} + +// Set the Column Separator +func (t *Table) SetColumnSeparator(sep string) { + t.pColumn = sep +} + +// Set the Row Separator +func (t *Table) SetRowSeparator(sep string) { + t.pRow = sep +} + +// Set the center Separator +func (t *Table) SetCenterSeparator(sep string) { + t.pCenter = sep +} + +// Set Header Alignment +func (t *Table) SetHeaderAlignment(hAlign int) { + t.hAlign = hAlign +} + +// Set Footer Alignment +func (t *Table) SetFooterAlignment(fAlign int) { + t.fAlign = fAlign +} + +// Set Table Alignment +func (t *Table) SetAlignment(align int) { + t.align = align +} + +// Set Header Line +// This would enable / disable a line after the header +func (t *Table) SetHeaderLine(line bool) { + t.hdrLine = line +} + +// Set Row Line +// This would enable / disable a line on each row of the table +func (t *Table) SetRowLine(line bool) { + t.rowLine = line +} + +// Set Table Border +// This would enable / disable line around the table +func (t *Table) SetBorder(border bool) { + t.SetBorders(Border{border, border, border, border}) +} + +func (t *Table) SetBorders(border Border) { + t.borders = border +} + +// Append row to table +func (t *Table) Append(row []string) { + rowSize := len(t.headers) + if rowSize > t.colSize { + t.colSize = rowSize + } + + n := len(t.lines) + line := [][]string{} + for i, v := range row { + + // Detect string width + // Detect String height + // Break strings into words + out := t.parseDimension(v, i, n) + + // Append broken words + line = append(line, out) + } + t.lines = append(t.lines, line) +} + +// Allow Support for Bulk Append +// Eliminates repeated for loops +func (t *Table) AppendBulk(rows [][]string) { + for _, row := range rows { + t.Append(row) + } +} + +// Print line based on row width +func (t Table) printLine(nl bool) { + fmt.Fprint(t.out, t.pCenter) + for i := 0; i < len(t.cs); i++ { + v := t.cs[i] + fmt.Fprintf(t.out, "%s%s%s%s", + t.pRow, + strings.Repeat(string(t.pRow), v), + t.pRow, + t.pCenter) + } + if nl { + fmt.Fprintln(t.out) + } +} + +// Return the PadRight function if align is left, PadLeft if align is right, +// and Pad by default +func pad(align int) func(string, string, int) string { + padFunc := Pad + switch align { + case ALIGN_LEFT: + padFunc = PadRight + case ALIGN_RIGHT: + padFunc = PadLeft + } + return padFunc +} + +// Print heading information +func (t Table) printHeading() { + // Check if headers is available + if len(t.headers) < 1 { + return + } + + // Check if border is set + // Replace with space if not set + fmt.Fprint(t.out, ConditionString(t.borders.Left, t.pColumn, SPACE)) + + // Identify last column + end := len(t.cs) - 1 + + // Get pad function + padFunc := pad(t.hAlign) + + // Print Heading column + for i := 0; i <= end; i++ { + v := t.cs[i] + h := t.headers[i] + if t.autoFmt { + h = Title(h) + } + pad := ConditionString((i == end && !t.borders.Left), SPACE, t.pColumn) + fmt.Fprintf(t.out, " %s %s", + padFunc(h, SPACE, v), + pad) + } + // Next line + fmt.Fprintln(t.out) + if t.hdrLine { + t.printLine(true) + } +} + +// Print heading information +func (t Table) printFooter() { + // Check if headers is available + if len(t.footers) < 1 { + return + } + + // Only print line if border is not set + if !t.borders.Bottom { + t.printLine(true) + } + // Check if border is set + // Replace with space if not set + fmt.Fprint(t.out, ConditionString(t.borders.Bottom, t.pColumn, SPACE)) + + // Identify last column + end := len(t.cs) - 1 + + // Get pad function + padFunc := pad(t.fAlign) + + // Print Heading column + for i := 0; i <= end; i++ { + v := t.cs[i] + f := t.footers[i] + if t.autoFmt { + f = Title(f) + } + pad := ConditionString((i == end && !t.borders.Top), SPACE, t.pColumn) + + if len(t.footers[i]) == 0 { + pad = SPACE + } + fmt.Fprintf(t.out, " %s %s", + padFunc(f, SPACE, v), + pad) + } + // Next line + fmt.Fprintln(t.out) + //t.printLine(true) + + hasPrinted := false + + for i := 0; i <= end; i++ { + v := t.cs[i] + pad := t.pRow + center := t.pCenter + length := len(t.footers[i]) + + if length > 0 { + hasPrinted = true + } + + // Set center to be space if length is 0 + if length == 0 && !t.borders.Right { + center = SPACE + } + + // Print first junction + if i == 0 { + fmt.Fprint(t.out, center) + } + + // Pad With space of length is 0 + if length == 0 { + pad = SPACE + } + // Ignore left space of it has printed before + if hasPrinted || t.borders.Left { + pad = t.pRow + center = t.pCenter + } + + // Change Center start position + if center == SPACE { + if i < end && len(t.footers[i+1]) != 0 { + center = t.pCenter + } + } + + // Print the footer + fmt.Fprintf(t.out, "%s%s%s%s", + pad, + strings.Repeat(string(pad), v), + pad, + center) + + } + + fmt.Fprintln(t.out) + +} + +func (t Table) printRows() { + for i, lines := range t.lines { + t.printRow(lines, i) + } + +} + +// Print Row Information +// Adjust column alignment based on type + +func (t Table) printRow(columns [][]string, colKey int) { + // Get Maximum Height + max := t.rs[colKey] + total := len(columns) + + // TODO Fix uneven col size + // if total < t.colSize { + // for n := t.colSize - total; n < t.colSize ; n++ { + // columns = append(columns, []string{SPACE}) + // t.cs[n] = t.mW + // } + //} + + // Pad Each Height + // pads := []int{} + pads := []int{} + + for i, line := range columns { + length := len(line) + pad := max - length + pads = append(pads, pad) + for n := 0; n < pad; n++ { + columns[i] = append(columns[i], " ") + } + } + //fmt.Println(max, "\n") + for x := 0; x < max; x++ { + for y := 0; y < total; y++ { + + // Check if border is set + fmt.Fprint(t.out, ConditionString((!t.borders.Left && y == 0), SPACE, t.pColumn)) + + fmt.Fprintf(t.out, SPACE) + str := columns[y][x] + + // This would print alignment + // Default alignment would use multiple configuration + switch t.align { + case ALIGN_CENTER: // + fmt.Fprintf(t.out, "%s", Pad(str, SPACE, t.cs[y])) + case ALIGN_RIGHT: + fmt.Fprintf(t.out, "%s", PadLeft(str, SPACE, t.cs[y])) + case ALIGN_LEFT: + fmt.Fprintf(t.out, "%s", PadRight(str, SPACE, t.cs[y])) + default: + if decimal.MatchString(strings.TrimSpace(str)) || percent.MatchString(strings.TrimSpace(str)) { + fmt.Fprintf(t.out, "%s", PadLeft(str, SPACE, t.cs[y])) + } else { + fmt.Fprintf(t.out, "%s", PadRight(str, SPACE, t.cs[y])) + + // TODO Custom alignment per column + //if max == 1 || pads[y] > 0 { + // fmt.Fprintf(t.out, "%s", Pad(str, SPACE, t.cs[y])) + //} else { + // fmt.Fprintf(t.out, "%s", PadRight(str, SPACE, t.cs[y])) + //} + + } + } + fmt.Fprintf(t.out, SPACE) + } + // Check if border is set + // Replace with space if not set + fmt.Fprint(t.out, ConditionString(t.borders.Left, t.pColumn, SPACE)) + fmt.Fprintln(t.out) + } + + if t.rowLine { + t.printLine(true) + } + +} + +func (t *Table) parseDimension(str string, colKey, rowKey int) []string { + var ( + raw []string + max int + ) + w := DisplayWidth(str) + // Calculate Width + // Check if with is grater than maximum width + if w > t.mW { + w = t.mW + } + + // Check if width exists + v, ok := t.cs[colKey] + if !ok || v < w || v == 0 { + t.cs[colKey] = w + } + + if rowKey == -1 { + return raw + } + // Calculate Height + if t.autoWrap { + raw, _ = WrapString(str, t.cs[colKey]) + } else { + raw = getLines(str) + } + + for _, line := range raw { + if w := DisplayWidth(line); w > max { + max = w + } + } + + // Make sure the with is the same length as maximum word + // Important for cases where the width is smaller than maxu word + if max > t.cs[colKey] { + t.cs[colKey] = max + } + + h := len(raw) + v, ok = t.rs[rowKey] + + if !ok || v < h || v == 0 { + t.rs[rowKey] = h + } + //fmt.Printf("Raw %+v %d\n", raw, len(raw)) + return raw +} diff --git a/vendor/github.com/olekukonko/tablewriter/util.go b/vendor/github.com/olekukonko/tablewriter/util.go new file mode 100644 index 00000000..2deefbc5 --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/util.go @@ -0,0 +1,72 @@ +// Copyright 2014 Oleku Konko All rights reserved. +// Use of this source code is governed by a MIT +// license that can be found in the LICENSE file. + +// This module is a Table Writer API for the Go Programming Language. +// The protocols were written in pure Go and works on windows and unix systems + +package tablewriter + +import ( + "math" + "regexp" + "strings" + + "github.com/mattn/go-runewidth" +) + +var ansi = regexp.MustCompile("\033\\[(?:[0-9]{1,3}(?:;[0-9]{1,3})*)?[m|K]") + +func DisplayWidth(str string) int { + return runewidth.StringWidth(ansi.ReplaceAllLiteralString(str, "")) +} + +// Simple Condition for string +// Returns value based on condition +func ConditionString(cond bool, valid, inValid string) string { + if cond { + return valid + } + return inValid +} + +// Format Table Header +// Replace _ , . and spaces +func Title(name string) string { + name = strings.Replace(name, "_", " ", -1) + name = strings.Replace(name, ".", " ", -1) + name = strings.TrimSpace(name) + return strings.ToUpper(name) +} + +// Pad String +// Attempts to play string in the center +func Pad(s, pad string, width int) string { + gap := width - DisplayWidth(s) + if gap > 0 { + gapLeft := int(math.Ceil(float64(gap / 2))) + gapRight := gap - gapLeft + return strings.Repeat(string(pad), gapLeft) + s + strings.Repeat(string(pad), gapRight) + } + return s +} + +// Pad String Right position +// This would pace string at the left side fo the screen +func PadRight(s, pad string, width int) string { + gap := width - DisplayWidth(s) + if gap > 0 { + return s + strings.Repeat(string(pad), gap) + } + return s +} + +// Pad String Left position +// This would pace string at the right side fo the screen +func PadLeft(s, pad string, width int) string { + gap := width - DisplayWidth(s) + if gap > 0 { + return strings.Repeat(string(pad), gap) + s + } + return s +} diff --git a/vendor/github.com/olekukonko/tablewriter/wrap.go b/vendor/github.com/olekukonko/tablewriter/wrap.go new file mode 100644 index 00000000..f3747d9f --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/wrap.go @@ -0,0 +1,103 @@ +// Copyright 2014 Oleku Konko All rights reserved. +// Use of this source code is governed by a MIT +// license that can be found in the LICENSE file. + +// This module is a Table Writer API for the Go Programming Language. +// The protocols were written in pure Go and works on windows and unix systems + +package tablewriter + +import ( + "math" + "strings" + "unicode/utf8" +) + +var ( + nl = "\n" + sp = " " +) + +const defaultPenalty = 1e5 + +// Wrap wraps s into a paragraph of lines of length lim, with minimal +// raggedness. +func WrapString(s string, lim int) ([]string, int) { + words := strings.Split(strings.Replace(strings.TrimSpace(s), nl, sp, -1), sp) + var lines []string + max := 0 + for _, v := range words { + max = len(v) + if max > lim { + lim = max + } + } + for _, line := range WrapWords(words, 1, lim, defaultPenalty) { + lines = append(lines, strings.Join(line, sp)) + } + return lines, lim +} + +// WrapWords is the low-level line-breaking algorithm, useful if you need more +// control over the details of the text wrapping process. For most uses, +// WrapString will be sufficient and more convenient. +// +// WrapWords splits a list of words into lines with minimal "raggedness", +// treating each rune as one unit, accounting for spc units between adjacent +// words on each line, and attempting to limit lines to lim units. Raggedness +// is the total error over all lines, where error is the square of the +// difference of the length of the line and lim. Too-long lines (which only +// happen when a single word is longer than lim units) have pen penalty units +// added to the error. +func WrapWords(words []string, spc, lim, pen int) [][]string { + n := len(words) + + length := make([][]int, n) + for i := 0; i < n; i++ { + length[i] = make([]int, n) + length[i][i] = utf8.RuneCountInString(words[i]) + for j := i + 1; j < n; j++ { + length[i][j] = length[i][j-1] + spc + utf8.RuneCountInString(words[j]) + } + } + nbrk := make([]int, n) + cost := make([]int, n) + for i := range cost { + cost[i] = math.MaxInt32 + } + for i := n - 1; i >= 0; i-- { + if length[i][n-1] <= lim { + cost[i] = 0 + nbrk[i] = n + } else { + for j := i + 1; j < n; j++ { + d := lim - length[i][j-1] + c := d*d + cost[j] + if length[i][j-1] > lim { + c += pen // too-long lines get a worse penalty + } + if c < cost[i] { + cost[i] = c + nbrk[i] = j + } + } + } + } + var lines [][]string + i := 0 + for i < n { + lines = append(lines, words[i:nbrk[i]]) + i = nbrk[i] + } + return lines +} + +// getLines decomposes a multiline string into a slice of strings. +func getLines(s string) []string { + var lines []string + + for _, line := range strings.Split(strings.TrimSpace(s), nl) { + lines = append(lines, line) + } + return lines +} diff --git a/vendor/github.com/samuel/go-zookeeper/LICENSE b/vendor/github.com/samuel/go-zookeeper/LICENSE new file mode 100644 index 00000000..bc00498c --- /dev/null +++ b/vendor/github.com/samuel/go-zookeeper/LICENSE @@ -0,0 +1,25 @@ +Copyright (c) 2013, Samuel Stauffer +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +* Neither the name of the author nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/samuel/go-zookeeper/zk/conn.go b/vendor/github.com/samuel/go-zookeeper/zk/conn.go new file mode 100644 index 00000000..ed87ca5e --- /dev/null +++ b/vendor/github.com/samuel/go-zookeeper/zk/conn.go @@ -0,0 +1,910 @@ +// Package zk is a native Go client library for the ZooKeeper orchestration service. +package zk + +/* +TODO: +* make sure a ping response comes back in a reasonable time + +Possible watcher events: +* Event{Type: EventNotWatching, State: StateDisconnected, Path: path, Err: err} +*/ + +import ( + "crypto/rand" + "encoding/binary" + "errors" + "fmt" + "io" + "net" + "strconv" + "strings" + "sync" + "sync/atomic" + "time" +) + +// ErrNoServer indicates that an operation cannot be completed +// because attempts to connect to all servers in the list failed. +var ErrNoServer = errors.New("zk: could not connect to a server") + +// ErrInvalidPath indicates that an operation was being attempted on +// an invalid path. (e.g. empty path) +var ErrInvalidPath = errors.New("zk: invalid path") + +// DefaultLogger uses the stdlib log package for logging. +var DefaultLogger Logger = defaultLogger{} + +const ( + bufferSize = 1536 * 1024 + eventChanSize = 6 + sendChanSize = 16 + protectedPrefix = "_c_" +) + +type watchType int + +const ( + watchTypeData = iota + watchTypeExist = iota + watchTypeChild = iota +) + +type watchPathType struct { + path string + wType watchType +} + +type Dialer func(network, address string, timeout time.Duration) (net.Conn, error) + +// Logger is an interface that can be implemented to provide custom log output. +type Logger interface { + Printf(string, ...interface{}) +} + +type Conn struct { + lastZxid int64 + sessionID int64 + state State // must be 32-bit aligned + xid uint32 + sessionTimeoutMs int32 // session timeout in milliseconds + passwd []byte + + dialer Dialer + hostProvider HostProvider + serverMu sync.Mutex // protects server + server string // remember the address/port of the current server + conn net.Conn + eventChan chan Event + shouldQuit chan struct{} + pingInterval time.Duration + recvTimeout time.Duration + connectTimeout time.Duration + + sendChan chan *request + requests map[int32]*request // Xid -> pending request + requestsLock sync.Mutex + watchers map[watchPathType][]chan Event + watchersLock sync.Mutex + + // Debug (used by unit tests) + reconnectDelay time.Duration + + logger Logger +} + +// connOption represents a connection option. +type connOption func(c *Conn) + +type request struct { + xid int32 + opcode int32 + pkt interface{} + recvStruct interface{} + recvChan chan response + + // Because sending and receiving happen in separate go routines, there's + // a possible race condition when creating watches from outside the read + // loop. We must ensure that a watcher gets added to the list synchronously + // with the response from the server on any request that creates a watch. + // In order to not hard code the watch logic for each opcode in the recv + // loop the caller can use recvFunc to insert some synchronously code + // after a response. + recvFunc func(*request, *responseHeader, error) +} + +type response struct { + zxid int64 + err error +} + +type Event struct { + Type EventType + State State + Path string // For non-session events, the path of the watched node. + Err error + Server string // For connection events +} + +// HostProvider is used to represent a set of hosts a ZooKeeper client should connect to. +// It is an analog of the Java equivalent: +// http://svn.apache.org/viewvc/zookeeper/trunk/src/java/main/org/apache/zookeeper/client/HostProvider.java?view=markup +type HostProvider interface { + // Init is called first, with the servers specified in the connection string. + Init(servers []string) error + // Len returns the number of servers. + Len() int + // Next returns the next server to connect to. retryStart will be true if we've looped through + // all known servers without Connected() being called. + Next() (server string, retryStart bool) + // Notify the HostProvider of a successful connection. + Connected() +} + +// ConnectWithDialer establishes a new connection to a pool of zookeeper servers +// using a custom Dialer. See Connect for further information about session timeout. +// This method is deprecated and provided for compatibility: use the WithDialer option instead. +func ConnectWithDialer(servers []string, sessionTimeout time.Duration, dialer Dialer) (*Conn, <-chan Event, error) { + return Connect(servers, sessionTimeout, WithDialer(dialer)) +} + +// Connect establishes a new connection to a pool of zookeeper +// servers. The provided session timeout sets the amount of time for which +// a session is considered valid after losing connection to a server. Within +// the session timeout it's possible to reestablish a connection to a different +// server and keep the same session. This is means any ephemeral nodes and +// watches are maintained. +func Connect(servers []string, sessionTimeout time.Duration, options ...connOption) (*Conn, <-chan Event, error) { + if len(servers) == 0 { + return nil, nil, errors.New("zk: server list must not be empty") + } + + srvs := make([]string, len(servers)) + + for i, addr := range servers { + if strings.Contains(addr, ":") { + srvs[i] = addr + } else { + srvs[i] = addr + ":" + strconv.Itoa(DefaultPort) + } + } + + // Randomize the order of the servers to avoid creating hotspots + stringShuffle(srvs) + + ec := make(chan Event, eventChanSize) + conn := &Conn{ + dialer: net.DialTimeout, + hostProvider: &DNSHostProvider{}, + conn: nil, + state: StateDisconnected, + eventChan: ec, + shouldQuit: make(chan struct{}), + connectTimeout: 1 * time.Second, + sendChan: make(chan *request, sendChanSize), + requests: make(map[int32]*request), + watchers: make(map[watchPathType][]chan Event), + passwd: emptyPassword, + logger: DefaultLogger, + + // Debug + reconnectDelay: 0, + } + + // Set provided options. + for _, option := range options { + option(conn) + } + + if err := conn.hostProvider.Init(srvs); err != nil { + return nil, nil, err + } + + conn.setTimeouts(int32(sessionTimeout / time.Millisecond)) + + go func() { + conn.loop() + conn.flushRequests(ErrClosing) + conn.invalidateWatches(ErrClosing) + close(conn.eventChan) + }() + return conn, ec, nil +} + +// WithDialer returns a connection option specifying a non-default Dialer. +func WithDialer(dialer Dialer) connOption { + return func(c *Conn) { + c.dialer = dialer + } +} + +// WithHostProvider returns a connection option specifying a non-default HostProvider. +func WithHostProvider(hostProvider HostProvider) connOption { + return func(c *Conn) { + c.hostProvider = hostProvider + } +} + +func (c *Conn) Close() { + close(c.shouldQuit) + + select { + case <-c.queueRequest(opClose, &closeRequest{}, &closeResponse{}, nil): + case <-time.After(time.Second): + } +} + +// State returns the current state of the connection. +func (c *Conn) State() State { + return State(atomic.LoadInt32((*int32)(&c.state))) +} + +// SessionId returns the current session id of the connection. +func (c *Conn) SessionID() int64 { + return atomic.LoadInt64(&c.sessionID) +} + +// SetLogger sets the logger to be used for printing errors. +// Logger is an interface provided by this package. +func (c *Conn) SetLogger(l Logger) { + c.logger = l +} + +func (c *Conn) setTimeouts(sessionTimeoutMs int32) { + c.sessionTimeoutMs = sessionTimeoutMs + sessionTimeout := time.Duration(sessionTimeoutMs) * time.Millisecond + c.recvTimeout = sessionTimeout * 2 / 3 + c.pingInterval = c.recvTimeout / 2 +} + +func (c *Conn) setState(state State) { + atomic.StoreInt32((*int32)(&c.state), int32(state)) + select { + case c.eventChan <- Event{Type: EventSession, State: state, Server: c.Server()}: + default: + // panic("zk: event channel full - it must be monitored and never allowed to be full") + } +} + +func (c *Conn) connect() error { + var retryStart bool + for { + c.serverMu.Lock() + c.server, retryStart = c.hostProvider.Next() + c.serverMu.Unlock() + c.setState(StateConnecting) + if retryStart { + c.flushUnsentRequests(ErrNoServer) + select { + case <-time.After(time.Second): + // pass + case <-c.shouldQuit: + c.setState(StateDisconnected) + c.flushUnsentRequests(ErrClosing) + return ErrClosing + } + } + + zkConn, err := c.dialer("tcp", c.Server(), c.connectTimeout) + if err == nil { + c.conn = zkConn + c.setState(StateConnected) + c.logger.Printf("Connected to %s", c.Server()) + return nil + } + + c.logger.Printf("Failed to connect to %s: %+v", c.Server(), err) + } +} + +func (c *Conn) loop() { + for { + if err := c.connect(); err != nil { + // c.Close() was called + return + } + + err := c.authenticate() + switch { + case err == ErrSessionExpired: + c.logger.Printf("Authentication failed: %s", err) + c.invalidateWatches(err) + case err != nil && c.conn != nil: + c.logger.Printf("Authentication failed: %s", err) + c.conn.Close() + case err == nil: + c.logger.Printf("Authenticated: id=%d, timeout=%d", c.SessionID(), c.sessionTimeoutMs) + c.hostProvider.Connected() // mark success + closeChan := make(chan struct{}) // channel to tell send loop stop + var wg sync.WaitGroup + + wg.Add(1) + go func() { + err := c.sendLoop(c.conn, closeChan) + c.logger.Printf("Send loop terminated: err=%v", err) + c.conn.Close() // causes recv loop to EOF/exit + wg.Done() + }() + + wg.Add(1) + go func() { + err := c.recvLoop(c.conn) + c.logger.Printf("Recv loop terminated: err=%v", err) + if err == nil { + panic("zk: recvLoop should never return nil error") + } + close(closeChan) // tell send loop to exit + wg.Done() + }() + + c.sendSetWatches() + wg.Wait() + } + + c.setState(StateDisconnected) + + select { + case <-c.shouldQuit: + c.flushRequests(ErrClosing) + return + default: + } + + if err != ErrSessionExpired { + err = ErrConnectionClosed + } + c.flushRequests(err) + + if c.reconnectDelay > 0 { + select { + case <-c.shouldQuit: + return + case <-time.After(c.reconnectDelay): + } + } + } +} + +func (c *Conn) flushUnsentRequests(err error) { + for { + select { + default: + return + case req := <-c.sendChan: + req.recvChan <- response{-1, err} + } + } +} + +// Send error to all pending requests and clear request map +func (c *Conn) flushRequests(err error) { + c.requestsLock.Lock() + for _, req := range c.requests { + req.recvChan <- response{-1, err} + } + c.requests = make(map[int32]*request) + c.requestsLock.Unlock() +} + +// Send error to all watchers and clear watchers map +func (c *Conn) invalidateWatches(err error) { + c.watchersLock.Lock() + defer c.watchersLock.Unlock() + + if len(c.watchers) >= 0 { + for pathType, watchers := range c.watchers { + ev := Event{Type: EventNotWatching, State: StateDisconnected, Path: pathType.path, Err: err} + for _, ch := range watchers { + ch <- ev + close(ch) + } + } + c.watchers = make(map[watchPathType][]chan Event) + } +} + +func (c *Conn) sendSetWatches() { + c.watchersLock.Lock() + defer c.watchersLock.Unlock() + + if len(c.watchers) == 0 { + return + } + + req := &setWatchesRequest{ + RelativeZxid: c.lastZxid, + DataWatches: make([]string, 0), + ExistWatches: make([]string, 0), + ChildWatches: make([]string, 0), + } + n := 0 + for pathType, watchers := range c.watchers { + if len(watchers) == 0 { + continue + } + switch pathType.wType { + case watchTypeData: + req.DataWatches = append(req.DataWatches, pathType.path) + case watchTypeExist: + req.ExistWatches = append(req.ExistWatches, pathType.path) + case watchTypeChild: + req.ChildWatches = append(req.ChildWatches, pathType.path) + } + n++ + } + if n == 0 { + return + } + + go func() { + res := &setWatchesResponse{} + _, err := c.request(opSetWatches, req, res, nil) + if err != nil { + c.logger.Printf("Failed to set previous watches: %s", err.Error()) + } + }() +} + +func (c *Conn) authenticate() error { + buf := make([]byte, 256) + + // Encode and send a connect request. + n, err := encodePacket(buf[4:], &connectRequest{ + ProtocolVersion: protocolVersion, + LastZxidSeen: c.lastZxid, + TimeOut: c.sessionTimeoutMs, + SessionID: c.SessionID(), + Passwd: c.passwd, + }) + if err != nil { + return err + } + + binary.BigEndian.PutUint32(buf[:4], uint32(n)) + + c.conn.SetWriteDeadline(time.Now().Add(c.recvTimeout * 10)) + _, err = c.conn.Write(buf[:n+4]) + c.conn.SetWriteDeadline(time.Time{}) + if err != nil { + return err + } + + // Receive and decode a connect response. + c.conn.SetReadDeadline(time.Now().Add(c.recvTimeout * 10)) + _, err = io.ReadFull(c.conn, buf[:4]) + c.conn.SetReadDeadline(time.Time{}) + if err != nil { + return err + } + + blen := int(binary.BigEndian.Uint32(buf[:4])) + if cap(buf) < blen { + buf = make([]byte, blen) + } + + _, err = io.ReadFull(c.conn, buf[:blen]) + if err != nil { + return err + } + + r := connectResponse{} + _, err = decodePacket(buf[:blen], &r) + if err != nil { + return err + } + if r.SessionID == 0 { + atomic.StoreInt64(&c.sessionID, int64(0)) + c.passwd = emptyPassword + c.lastZxid = 0 + c.setState(StateExpired) + return ErrSessionExpired + } + + atomic.StoreInt64(&c.sessionID, r.SessionID) + c.setTimeouts(r.TimeOut) + c.passwd = r.Passwd + c.setState(StateHasSession) + + return nil +} + +func (c *Conn) sendLoop(conn net.Conn, closeChan <-chan struct{}) error { + pingTicker := time.NewTicker(c.pingInterval) + defer pingTicker.Stop() + + buf := make([]byte, bufferSize) + for { + select { + case req := <-c.sendChan: + header := &requestHeader{req.xid, req.opcode} + n, err := encodePacket(buf[4:], header) + if err != nil { + req.recvChan <- response{-1, err} + continue + } + + n2, err := encodePacket(buf[4+n:], req.pkt) + if err != nil { + req.recvChan <- response{-1, err} + continue + } + + n += n2 + + binary.BigEndian.PutUint32(buf[:4], uint32(n)) + + c.requestsLock.Lock() + select { + case <-closeChan: + req.recvChan <- response{-1, ErrConnectionClosed} + c.requestsLock.Unlock() + return ErrConnectionClosed + default: + } + c.requests[req.xid] = req + c.requestsLock.Unlock() + + conn.SetWriteDeadline(time.Now().Add(c.recvTimeout)) + _, err = conn.Write(buf[:n+4]) + conn.SetWriteDeadline(time.Time{}) + if err != nil { + req.recvChan <- response{-1, err} + conn.Close() + return err + } + case <-pingTicker.C: + n, err := encodePacket(buf[4:], &requestHeader{Xid: -2, Opcode: opPing}) + if err != nil { + panic("zk: opPing should never fail to serialize") + } + + binary.BigEndian.PutUint32(buf[:4], uint32(n)) + + conn.SetWriteDeadline(time.Now().Add(c.recvTimeout)) + _, err = conn.Write(buf[:n+4]) + conn.SetWriteDeadline(time.Time{}) + if err != nil { + conn.Close() + return err + } + case <-closeChan: + return nil + } + } +} + +func (c *Conn) recvLoop(conn net.Conn) error { + buf := make([]byte, bufferSize) + for { + // package length + conn.SetReadDeadline(time.Now().Add(c.recvTimeout)) + _, err := io.ReadFull(conn, buf[:4]) + if err != nil { + return err + } + + blen := int(binary.BigEndian.Uint32(buf[:4])) + if cap(buf) < blen { + buf = make([]byte, blen) + } + + _, err = io.ReadFull(conn, buf[:blen]) + conn.SetReadDeadline(time.Time{}) + if err != nil { + return err + } + + res := responseHeader{} + _, err = decodePacket(buf[:16], &res) + if err != nil { + return err + } + + if res.Xid == -1 { + res := &watcherEvent{} + _, err := decodePacket(buf[16:blen], res) + if err != nil { + return err + } + ev := Event{ + Type: res.Type, + State: res.State, + Path: res.Path, + Err: nil, + } + select { + case c.eventChan <- ev: + default: + } + wTypes := make([]watchType, 0, 2) + switch res.Type { + case EventNodeCreated: + wTypes = append(wTypes, watchTypeExist) + case EventNodeDeleted, EventNodeDataChanged: + wTypes = append(wTypes, watchTypeExist, watchTypeData, watchTypeChild) + case EventNodeChildrenChanged: + wTypes = append(wTypes, watchTypeChild) + } + c.watchersLock.Lock() + for _, t := range wTypes { + wpt := watchPathType{res.Path, t} + if watchers := c.watchers[wpt]; watchers != nil && len(watchers) > 0 { + for _, ch := range watchers { + ch <- ev + close(ch) + } + delete(c.watchers, wpt) + } + } + c.watchersLock.Unlock() + } else if res.Xid == -2 { + // Ping response. Ignore. + } else if res.Xid < 0 { + c.logger.Printf("Xid < 0 (%d) but not ping or watcher event", res.Xid) + } else { + if res.Zxid > 0 { + c.lastZxid = res.Zxid + } + + c.requestsLock.Lock() + req, ok := c.requests[res.Xid] + if ok { + delete(c.requests, res.Xid) + } + c.requestsLock.Unlock() + + if !ok { + c.logger.Printf("Response for unknown request with xid %d", res.Xid) + } else { + if res.Err != 0 { + err = res.Err.toError() + } else { + _, err = decodePacket(buf[16:blen], req.recvStruct) + } + if req.recvFunc != nil { + req.recvFunc(req, &res, err) + } + req.recvChan <- response{res.Zxid, err} + if req.opcode == opClose { + return io.EOF + } + } + } + } +} + +func (c *Conn) nextXid() int32 { + return int32(atomic.AddUint32(&c.xid, 1) & 0x7fffffff) +} + +func (c *Conn) addWatcher(path string, watchType watchType) <-chan Event { + c.watchersLock.Lock() + defer c.watchersLock.Unlock() + + ch := make(chan Event, 1) + wpt := watchPathType{path, watchType} + c.watchers[wpt] = append(c.watchers[wpt], ch) + return ch +} + +func (c *Conn) queueRequest(opcode int32, req interface{}, res interface{}, recvFunc func(*request, *responseHeader, error)) <-chan response { + rq := &request{ + xid: c.nextXid(), + opcode: opcode, + pkt: req, + recvStruct: res, + recvChan: make(chan response, 1), + recvFunc: recvFunc, + } + c.sendChan <- rq + return rq.recvChan +} + +func (c *Conn) request(opcode int32, req interface{}, res interface{}, recvFunc func(*request, *responseHeader, error)) (int64, error) { + r := <-c.queueRequest(opcode, req, res, recvFunc) + return r.zxid, r.err +} + +func (c *Conn) AddAuth(scheme string, auth []byte) error { + _, err := c.request(opSetAuth, &setAuthRequest{Type: 0, Scheme: scheme, Auth: auth}, &setAuthResponse{}, nil) + return err +} + +func (c *Conn) Children(path string) ([]string, *Stat, error) { + res := &getChildren2Response{} + _, err := c.request(opGetChildren2, &getChildren2Request{Path: path, Watch: false}, res, nil) + return res.Children, &res.Stat, err +} + +func (c *Conn) ChildrenW(path string) ([]string, *Stat, <-chan Event, error) { + var ech <-chan Event + res := &getChildren2Response{} + _, err := c.request(opGetChildren2, &getChildren2Request{Path: path, Watch: true}, res, func(req *request, res *responseHeader, err error) { + if err == nil { + ech = c.addWatcher(path, watchTypeChild) + } + }) + if err != nil { + return nil, nil, nil, err + } + return res.Children, &res.Stat, ech, err +} + +func (c *Conn) Get(path string) ([]byte, *Stat, error) { + res := &getDataResponse{} + _, err := c.request(opGetData, &getDataRequest{Path: path, Watch: false}, res, nil) + return res.Data, &res.Stat, err +} + +// GetW returns the contents of a znode and sets a watch +func (c *Conn) GetW(path string) ([]byte, *Stat, <-chan Event, error) { + var ech <-chan Event + res := &getDataResponse{} + _, err := c.request(opGetData, &getDataRequest{Path: path, Watch: true}, res, func(req *request, res *responseHeader, err error) { + if err == nil { + ech = c.addWatcher(path, watchTypeData) + } + }) + if err != nil { + return nil, nil, nil, err + } + return res.Data, &res.Stat, ech, err +} + +func (c *Conn) Set(path string, data []byte, version int32) (*Stat, error) { + if path == "" { + return nil, ErrInvalidPath + } + res := &setDataResponse{} + _, err := c.request(opSetData, &SetDataRequest{path, data, version}, res, nil) + return &res.Stat, err +} + +func (c *Conn) Create(path string, data []byte, flags int32, acl []ACL) (string, error) { + res := &createResponse{} + _, err := c.request(opCreate, &CreateRequest{path, data, acl, flags}, res, nil) + return res.Path, err +} + +// CreateProtectedEphemeralSequential fixes a race condition if the server crashes +// after it creates the node. On reconnect the session may still be valid so the +// ephemeral node still exists. Therefore, on reconnect we need to check if a node +// with a GUID generated on create exists. +func (c *Conn) CreateProtectedEphemeralSequential(path string, data []byte, acl []ACL) (string, error) { + var guid [16]byte + _, err := io.ReadFull(rand.Reader, guid[:16]) + if err != nil { + return "", err + } + guidStr := fmt.Sprintf("%x", guid) + + parts := strings.Split(path, "/") + parts[len(parts)-1] = fmt.Sprintf("%s%s-%s", protectedPrefix, guidStr, parts[len(parts)-1]) + rootPath := strings.Join(parts[:len(parts)-1], "/") + protectedPath := strings.Join(parts, "/") + + var newPath string + for i := 0; i < 3; i++ { + newPath, err = c.Create(protectedPath, data, FlagEphemeral|FlagSequence, acl) + switch err { + case ErrSessionExpired: + // No need to search for the node since it can't exist. Just try again. + case ErrConnectionClosed: + children, _, err := c.Children(rootPath) + if err != nil { + return "", err + } + for _, p := range children { + parts := strings.Split(p, "/") + if pth := parts[len(parts)-1]; strings.HasPrefix(pth, protectedPrefix) { + if g := pth[len(protectedPrefix) : len(protectedPrefix)+32]; g == guidStr { + return rootPath + "/" + p, nil + } + } + } + case nil: + return newPath, nil + default: + return "", err + } + } + return "", err +} + +func (c *Conn) Delete(path string, version int32) error { + _, err := c.request(opDelete, &DeleteRequest{path, version}, &deleteResponse{}, nil) + return err +} + +func (c *Conn) Exists(path string) (bool, *Stat, error) { + res := &existsResponse{} + _, err := c.request(opExists, &existsRequest{Path: path, Watch: false}, res, nil) + exists := true + if err == ErrNoNode { + exists = false + err = nil + } + return exists, &res.Stat, err +} + +func (c *Conn) ExistsW(path string) (bool, *Stat, <-chan Event, error) { + var ech <-chan Event + res := &existsResponse{} + _, err := c.request(opExists, &existsRequest{Path: path, Watch: true}, res, func(req *request, res *responseHeader, err error) { + if err == nil { + ech = c.addWatcher(path, watchTypeData) + } else if err == ErrNoNode { + ech = c.addWatcher(path, watchTypeExist) + } + }) + exists := true + if err == ErrNoNode { + exists = false + err = nil + } + if err != nil { + return false, nil, nil, err + } + return exists, &res.Stat, ech, err +} + +func (c *Conn) GetACL(path string) ([]ACL, *Stat, error) { + res := &getAclResponse{} + _, err := c.request(opGetAcl, &getAclRequest{Path: path}, res, nil) + return res.Acl, &res.Stat, err +} +func (c *Conn) SetACL(path string, acl []ACL, version int32) (*Stat, error) { + res := &setAclResponse{} + _, err := c.request(opSetAcl, &setAclRequest{Path: path, Acl: acl, Version: version}, res, nil) + return &res.Stat, err +} + +func (c *Conn) Sync(path string) (string, error) { + res := &syncResponse{} + _, err := c.request(opSync, &syncRequest{Path: path}, res, nil) + return res.Path, err +} + +type MultiResponse struct { + Stat *Stat + String string +} + +// Multi executes multiple ZooKeeper operations or none of them. The provided +// ops must be one of *CreateRequest, *DeleteRequest, *SetDataRequest, or +// *CheckVersionRequest. +func (c *Conn) Multi(ops ...interface{}) ([]MultiResponse, error) { + req := &multiRequest{ + Ops: make([]multiRequestOp, 0, len(ops)), + DoneHeader: multiHeader{Type: -1, Done: true, Err: -1}, + } + for _, op := range ops { + var opCode int32 + switch op.(type) { + case *CreateRequest: + opCode = opCreate + case *SetDataRequest: + opCode = opSetData + case *DeleteRequest: + opCode = opDelete + case *CheckVersionRequest: + opCode = opCheck + default: + return nil, fmt.Errorf("unknown operation type %T", op) + } + req.Ops = append(req.Ops, multiRequestOp{multiHeader{opCode, false, -1}, op}) + } + res := &multiResponse{} + _, err := c.request(opMulti, req, res, nil) + mr := make([]MultiResponse, len(res.Ops)) + for i, op := range res.Ops { + mr[i] = MultiResponse{Stat: op.Stat, String: op.String} + } + return mr, err +} + +// Server returns the current or last-connected server name. +func (c *Conn) Server() string { + c.serverMu.Lock() + defer c.serverMu.Unlock() + return c.server +} diff --git a/vendor/github.com/samuel/go-zookeeper/zk/constants.go b/vendor/github.com/samuel/go-zookeeper/zk/constants.go new file mode 100644 index 00000000..f9b39b90 --- /dev/null +++ b/vendor/github.com/samuel/go-zookeeper/zk/constants.go @@ -0,0 +1,240 @@ +package zk + +import ( + "errors" +) + +const ( + protocolVersion = 0 + + DefaultPort = 2181 +) + +const ( + opNotify = 0 + opCreate = 1 + opDelete = 2 + opExists = 3 + opGetData = 4 + opSetData = 5 + opGetAcl = 6 + opSetAcl = 7 + opGetChildren = 8 + opSync = 9 + opPing = 11 + opGetChildren2 = 12 + opCheck = 13 + opMulti = 14 + opClose = -11 + opSetAuth = 100 + opSetWatches = 101 + // Not in protocol, used internally + opWatcherEvent = -2 +) + +const ( + EventNodeCreated = EventType(1) + EventNodeDeleted = EventType(2) + EventNodeDataChanged = EventType(3) + EventNodeChildrenChanged = EventType(4) + + EventSession = EventType(-1) + EventNotWatching = EventType(-2) +) + +var ( + eventNames = map[EventType]string{ + EventNodeCreated: "EventNodeCreated", + EventNodeDeleted: "EventNodeDeleted", + EventNodeDataChanged: "EventNodeDataChanged", + EventNodeChildrenChanged: "EventNodeChildrenChanged", + EventSession: "EventSession", + EventNotWatching: "EventNotWatching", + } +) + +const ( + StateUnknown = State(-1) + StateDisconnected = State(0) + StateConnecting = State(1) + StateAuthFailed = State(4) + StateConnectedReadOnly = State(5) + StateSaslAuthenticated = State(6) + StateExpired = State(-112) + // StateAuthFailed = State(-113) + + StateConnected = State(100) + StateHasSession = State(101) +) + +const ( + FlagEphemeral = 1 + FlagSequence = 2 +) + +var ( + stateNames = map[State]string{ + StateUnknown: "StateUnknown", + StateDisconnected: "StateDisconnected", + StateConnectedReadOnly: "StateConnectedReadOnly", + StateSaslAuthenticated: "StateSaslAuthenticated", + StateExpired: "StateExpired", + StateAuthFailed: "StateAuthFailed", + StateConnecting: "StateConnecting", + StateConnected: "StateConnected", + StateHasSession: "StateHasSession", + } +) + +type State int32 + +func (s State) String() string { + if name := stateNames[s]; name != "" { + return name + } + return "Unknown" +} + +type ErrCode int32 + +var ( + ErrConnectionClosed = errors.New("zk: connection closed") + ErrUnknown = errors.New("zk: unknown error") + ErrAPIError = errors.New("zk: api error") + ErrNoNode = errors.New("zk: node does not exist") + ErrNoAuth = errors.New("zk: not authenticated") + ErrBadVersion = errors.New("zk: version conflict") + ErrNoChildrenForEphemerals = errors.New("zk: ephemeral nodes may not have children") + ErrNodeExists = errors.New("zk: node already exists") + ErrNotEmpty = errors.New("zk: node has children") + ErrSessionExpired = errors.New("zk: session has been expired by the server") + ErrInvalidACL = errors.New("zk: invalid ACL specified") + ErrAuthFailed = errors.New("zk: client authentication failed") + ErrClosing = errors.New("zk: zookeeper is closing") + ErrNothing = errors.New("zk: no server responsees to process") + ErrSessionMoved = errors.New("zk: session moved to another server, so operation is ignored") + + // ErrInvalidCallback = errors.New("zk: invalid callback specified") + errCodeToError = map[ErrCode]error{ + 0: nil, + errAPIError: ErrAPIError, + errNoNode: ErrNoNode, + errNoAuth: ErrNoAuth, + errBadVersion: ErrBadVersion, + errNoChildrenForEphemerals: ErrNoChildrenForEphemerals, + errNodeExists: ErrNodeExists, + errNotEmpty: ErrNotEmpty, + errSessionExpired: ErrSessionExpired, + // errInvalidCallback: ErrInvalidCallback, + errInvalidAcl: ErrInvalidACL, + errAuthFailed: ErrAuthFailed, + errClosing: ErrClosing, + errNothing: ErrNothing, + errSessionMoved: ErrSessionMoved, + } +) + +func (e ErrCode) toError() error { + if err, ok := errCodeToError[e]; ok { + return err + } + return ErrUnknown +} + +const ( + errOk = 0 + // System and server-side errors + errSystemError = -1 + errRuntimeInconsistency = -2 + errDataInconsistency = -3 + errConnectionLoss = -4 + errMarshallingError = -5 + errUnimplemented = -6 + errOperationTimeout = -7 + errBadArguments = -8 + errInvalidState = -9 + // API errors + errAPIError = ErrCode(-100) + errNoNode = ErrCode(-101) // * + errNoAuth = ErrCode(-102) + errBadVersion = ErrCode(-103) // * + errNoChildrenForEphemerals = ErrCode(-108) + errNodeExists = ErrCode(-110) // * + errNotEmpty = ErrCode(-111) + errSessionExpired = ErrCode(-112) + errInvalidCallback = ErrCode(-113) + errInvalidAcl = ErrCode(-114) + errAuthFailed = ErrCode(-115) + errClosing = ErrCode(-116) + errNothing = ErrCode(-117) + errSessionMoved = ErrCode(-118) +) + +// Constants for ACL permissions +const ( + PermRead = 1 << iota + PermWrite + PermCreate + PermDelete + PermAdmin + PermAll = 0x1f +) + +var ( + emptyPassword = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} + opNames = map[int32]string{ + opNotify: "notify", + opCreate: "create", + opDelete: "delete", + opExists: "exists", + opGetData: "getData", + opSetData: "setData", + opGetAcl: "getACL", + opSetAcl: "setACL", + opGetChildren: "getChildren", + opSync: "sync", + opPing: "ping", + opGetChildren2: "getChildren2", + opCheck: "check", + opMulti: "multi", + opClose: "close", + opSetAuth: "setAuth", + opSetWatches: "setWatches", + + opWatcherEvent: "watcherEvent", + } +) + +type EventType int32 + +func (t EventType) String() string { + if name := eventNames[t]; name != "" { + return name + } + return "Unknown" +} + +// Mode is used to build custom server modes (leader|follower|standalone). +type Mode uint8 + +func (m Mode) String() string { + if name := modeNames[m]; name != "" { + return name + } + return "unknown" +} + +const ( + ModeUnknown Mode = iota + ModeLeader Mode = iota + ModeFollower Mode = iota + ModeStandalone Mode = iota +) + +var ( + modeNames = map[Mode]string{ + ModeLeader: "leader", + ModeFollower: "follower", + ModeStandalone: "standalone", + } +) diff --git a/vendor/github.com/samuel/go-zookeeper/zk/dnshostprovider.go b/vendor/github.com/samuel/go-zookeeper/zk/dnshostprovider.go new file mode 100644 index 00000000..f4bba8d0 --- /dev/null +++ b/vendor/github.com/samuel/go-zookeeper/zk/dnshostprovider.go @@ -0,0 +1,88 @@ +package zk + +import ( + "fmt" + "net" + "sync" +) + +// DNSHostProvider is the default HostProvider. It currently matches +// the Java StaticHostProvider, resolving hosts from DNS once during +// the call to Init. It could be easily extended to re-query DNS +// periodically or if there is trouble connecting. +type DNSHostProvider struct { + mu sync.Mutex // Protects everything, so we can add asynchronous updates later. + servers []string + curr int + last int + lookupHost func(string) ([]string, error) // Override of net.LookupHost, for testing. +} + +// Init is called first, with the servers specified in the connection +// string. It uses DNS to look up addresses for each server, then +// shuffles them all together. +func (hp *DNSHostProvider) Init(servers []string) error { + hp.mu.Lock() + defer hp.mu.Unlock() + + lookupHost := hp.lookupHost + if lookupHost == nil { + lookupHost = net.LookupHost + } + + found := []string{} + for _, server := range servers { + host, port, err := net.SplitHostPort(server) + if err != nil { + return err + } + addrs, err := lookupHost(host) + if err != nil { + return err + } + for _, addr := range addrs { + found = append(found, net.JoinHostPort(addr, port)) + } + } + + if len(found) == 0 { + return fmt.Errorf("No hosts found for addresses %q", servers) + } + + // Randomize the order of the servers to avoid creating hotspots + stringShuffle(found) + + hp.servers = found + hp.curr = -1 + hp.last = -1 + + return nil +} + +// Len returns the number of servers available +func (hp *DNSHostProvider) Len() int { + hp.mu.Lock() + defer hp.mu.Unlock() + return len(hp.servers) +} + +// Next returns the next server to connect to. retryStart will be true +// if we've looped through all known servers without Connected() being +// called. +func (hp *DNSHostProvider) Next() (server string, retryStart bool) { + hp.mu.Lock() + defer hp.mu.Unlock() + hp.curr = (hp.curr + 1) % len(hp.servers) + retryStart = hp.curr == hp.last + if hp.last == -1 { + hp.last = 0 + } + return hp.servers[hp.curr], retryStart +} + +// Connected notifies the HostProvider of a successful connection. +func (hp *DNSHostProvider) Connected() { + hp.mu.Lock() + defer hp.mu.Unlock() + hp.last = hp.curr +} diff --git a/vendor/github.com/samuel/go-zookeeper/zk/flw.go b/vendor/github.com/samuel/go-zookeeper/zk/flw.go new file mode 100644 index 00000000..3e97f968 --- /dev/null +++ b/vendor/github.com/samuel/go-zookeeper/zk/flw.go @@ -0,0 +1,266 @@ +package zk + +import ( + "bufio" + "bytes" + "fmt" + "io/ioutil" + "net" + "regexp" + "strconv" + "strings" + "time" +) + +// FLWSrvr is a FourLetterWord helper function. In particular, this function pulls the srvr output +// from the zookeeper instances and parses the output. A slice of *ServerStats structs are returned +// as well as a boolean value to indicate whether this function processed successfully. +// +// If the boolean value is false there was a problem. If the *ServerStats slice is empty or nil, +// then the error happened before we started to obtain 'srvr' values. Otherwise, one of the +// servers had an issue and the "Error" value in the struct should be inspected to determine +// which server had the issue. +func FLWSrvr(servers []string, timeout time.Duration) ([]*ServerStats, bool) { + // different parts of the regular expression that are required to parse the srvr output + const ( + zrVer = `^Zookeeper version: ([A-Za-z0-9\.\-]+), built on (\d\d/\d\d/\d\d\d\d \d\d:\d\d [A-Za-z0-9:\+\-]+)` + zrLat = `^Latency min/avg/max: (\d+)/(\d+)/(\d+)` + zrNet = `^Received: (\d+).*\n^Sent: (\d+).*\n^Connections: (\d+).*\n^Outstanding: (\d+)` + zrState = `^Zxid: (0x[A-Za-z0-9]+).*\n^Mode: (\w+).*\n^Node count: (\d+)` + ) + + // build the regex from the pieces above + re, err := regexp.Compile(fmt.Sprintf(`(?m:\A%v.*\n%v.*\n%v.*\n%v)`, zrVer, zrLat, zrNet, zrState)) + if err != nil { + return nil, false + } + + imOk := true + servers = FormatServers(servers) + ss := make([]*ServerStats, len(servers)) + + for i := range ss { + response, err := fourLetterWord(servers[i], "srvr", timeout) + + if err != nil { + ss[i] = &ServerStats{Error: err} + imOk = false + continue + } + + matches := re.FindAllStringSubmatch(string(response), -1) + + if matches == nil { + err := fmt.Errorf("unable to parse fields from zookeeper response (no regex matches)") + ss[i] = &ServerStats{Error: err} + imOk = false + continue + } + + match := matches[0][1:] + + // determine current server + var srvrMode Mode + switch match[10] { + case "leader": + srvrMode = ModeLeader + case "follower": + srvrMode = ModeFollower + case "standalone": + srvrMode = ModeStandalone + default: + srvrMode = ModeUnknown + } + + buildTime, err := time.Parse("01/02/2006 15:04 MST", match[1]) + + if err != nil { + ss[i] = &ServerStats{Error: err} + imOk = false + continue + } + + parsedInt, err := strconv.ParseInt(match[9], 0, 64) + + if err != nil { + ss[i] = &ServerStats{Error: err} + imOk = false + continue + } + + // the ZxID value is an int64 with two int32s packed inside + // the high int32 is the epoch (i.e., number of leader elections) + // the low int32 is the counter + epoch := int32(parsedInt >> 32) + counter := int32(parsedInt & 0xFFFFFFFF) + + // within the regex above, these values must be numerical + // so we can avoid useless checking of the error return value + minLatency, _ := strconv.ParseInt(match[2], 0, 64) + avgLatency, _ := strconv.ParseInt(match[3], 0, 64) + maxLatency, _ := strconv.ParseInt(match[4], 0, 64) + recv, _ := strconv.ParseInt(match[5], 0, 64) + sent, _ := strconv.ParseInt(match[6], 0, 64) + cons, _ := strconv.ParseInt(match[7], 0, 64) + outs, _ := strconv.ParseInt(match[8], 0, 64) + ncnt, _ := strconv.ParseInt(match[11], 0, 64) + + ss[i] = &ServerStats{ + Sent: sent, + Received: recv, + NodeCount: ncnt, + MinLatency: minLatency, + AvgLatency: avgLatency, + MaxLatency: maxLatency, + Connections: cons, + Outstanding: outs, + Epoch: epoch, + Counter: counter, + BuildTime: buildTime, + Mode: srvrMode, + Version: match[0], + } + } + + return ss, imOk +} + +// FLWRuok is a FourLetterWord helper function. In particular, this function +// pulls the ruok output from each server. +func FLWRuok(servers []string, timeout time.Duration) []bool { + servers = FormatServers(servers) + oks := make([]bool, len(servers)) + + for i := range oks { + response, err := fourLetterWord(servers[i], "ruok", timeout) + + if err != nil { + continue + } + + if bytes.Equal(response[:4], []byte("imok")) { + oks[i] = true + } + } + return oks +} + +// FLWCons is a FourLetterWord helper function. In particular, this function +// pulls the ruok output from each server. +// +// As with FLWSrvr, the boolean value indicates whether one of the requests had +// an issue. The Clients struct has an Error value that can be checked. +func FLWCons(servers []string, timeout time.Duration) ([]*ServerClients, bool) { + const ( + zrAddr = `^ /((?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?):(?:\d+))\[\d+\]` + zrPac = `\(queued=(\d+),recved=(\d+),sent=(\d+),sid=(0x[A-Za-z0-9]+),lop=(\w+),est=(\d+),to=(\d+),` + zrSesh = `lcxid=(0x[A-Za-z0-9]+),lzxid=(0x[A-Za-z0-9]+),lresp=(\d+),llat=(\d+),minlat=(\d+),avglat=(\d+),maxlat=(\d+)\)` + ) + + re, err := regexp.Compile(fmt.Sprintf("%v%v%v", zrAddr, zrPac, zrSesh)) + if err != nil { + return nil, false + } + + servers = FormatServers(servers) + sc := make([]*ServerClients, len(servers)) + imOk := true + + for i := range sc { + response, err := fourLetterWord(servers[i], "cons", timeout) + + if err != nil { + sc[i] = &ServerClients{Error: err} + imOk = false + continue + } + + scan := bufio.NewScanner(bytes.NewReader(response)) + + var clients []*ServerClient + + for scan.Scan() { + line := scan.Bytes() + + if len(line) == 0 { + continue + } + + m := re.FindAllStringSubmatch(string(line), -1) + + if m == nil { + err := fmt.Errorf("unable to parse fields from zookeeper response (no regex matches)") + sc[i] = &ServerClients{Error: err} + imOk = false + continue + } + + match := m[0][1:] + + queued, _ := strconv.ParseInt(match[1], 0, 64) + recvd, _ := strconv.ParseInt(match[2], 0, 64) + sent, _ := strconv.ParseInt(match[3], 0, 64) + sid, _ := strconv.ParseInt(match[4], 0, 64) + est, _ := strconv.ParseInt(match[6], 0, 64) + timeout, _ := strconv.ParseInt(match[7], 0, 32) + lcxid, _ := parseInt64(match[8]) + lzxid, _ := parseInt64(match[9]) + lresp, _ := strconv.ParseInt(match[10], 0, 64) + llat, _ := strconv.ParseInt(match[11], 0, 32) + minlat, _ := strconv.ParseInt(match[12], 0, 32) + avglat, _ := strconv.ParseInt(match[13], 0, 32) + maxlat, _ := strconv.ParseInt(match[14], 0, 32) + + clients = append(clients, &ServerClient{ + Queued: queued, + Received: recvd, + Sent: sent, + SessionID: sid, + Lcxid: int64(lcxid), + Lzxid: int64(lzxid), + Timeout: int32(timeout), + LastLatency: int32(llat), + MinLatency: int32(minlat), + AvgLatency: int32(avglat), + MaxLatency: int32(maxlat), + Established: time.Unix(est, 0), + LastResponse: time.Unix(lresp, 0), + Addr: match[0], + LastOperation: match[5], + }) + } + + sc[i] = &ServerClients{Clients: clients} + } + + return sc, imOk +} + +// parseInt64 is similar to strconv.ParseInt, but it also handles hex values that represent negative numbers +func parseInt64(s string) (int64, error) { + if strings.HasPrefix(s, "0x") { + i, err := strconv.ParseUint(s, 0, 64) + return int64(i), err + } + return strconv.ParseInt(s, 0, 64) +} + +func fourLetterWord(server, command string, timeout time.Duration) ([]byte, error) { + conn, err := net.DialTimeout("tcp", server, timeout) + if err != nil { + return nil, err + } + + // the zookeeper server should automatically close this socket + // once the command has been processed, but better safe than sorry + defer conn.Close() + + conn.SetWriteDeadline(time.Now().Add(timeout)) + _, err = conn.Write([]byte(command)) + if err != nil { + return nil, err + } + + conn.SetReadDeadline(time.Now().Add(timeout)) + return ioutil.ReadAll(conn) +} diff --git a/vendor/github.com/samuel/go-zookeeper/zk/lock.go b/vendor/github.com/samuel/go-zookeeper/zk/lock.go new file mode 100644 index 00000000..f13a8b0b --- /dev/null +++ b/vendor/github.com/samuel/go-zookeeper/zk/lock.go @@ -0,0 +1,142 @@ +package zk + +import ( + "errors" + "fmt" + "strconv" + "strings" +) + +var ( + // ErrDeadlock is returned by Lock when trying to lock twice without unlocking first + ErrDeadlock = errors.New("zk: trying to acquire a lock twice") + // ErrNotLocked is returned by Unlock when trying to release a lock that has not first be acquired. + ErrNotLocked = errors.New("zk: not locked") +) + +// Lock is a mutual exclusion lock. +type Lock struct { + c *Conn + path string + acl []ACL + lockPath string + seq int +} + +// NewLock creates a new lock instance using the provided connection, path, and acl. +// The path must be a node that is only used by this lock. A lock instances starts +// unlocked until Lock() is called. +func NewLock(c *Conn, path string, acl []ACL) *Lock { + return &Lock{ + c: c, + path: path, + acl: acl, + } +} + +func parseSeq(path string) (int, error) { + parts := strings.Split(path, "-") + return strconv.Atoi(parts[len(parts)-1]) +} + +// Lock attempts to acquire the lock. It will wait to return until the lock +// is acquired or an error occurs. If this instance already has the lock +// then ErrDeadlock is returned. +func (l *Lock) Lock() error { + if l.lockPath != "" { + return ErrDeadlock + } + + prefix := fmt.Sprintf("%s/lock-", l.path) + + path := "" + var err error + for i := 0; i < 3; i++ { + path, err = l.c.CreateProtectedEphemeralSequential(prefix, []byte{}, l.acl) + if err == ErrNoNode { + // Create parent node. + parts := strings.Split(l.path, "/") + pth := "" + for _, p := range parts[1:] { + pth += "/" + p + _, err := l.c.Create(pth, []byte{}, 0, l.acl) + if err != nil && err != ErrNodeExists { + return err + } + } + } else if err == nil { + break + } else { + return err + } + } + if err != nil { + return err + } + + seq, err := parseSeq(path) + if err != nil { + return err + } + + for { + children, _, err := l.c.Children(l.path) + if err != nil { + return err + } + + lowestSeq := seq + prevSeq := 0 + prevSeqPath := "" + for _, p := range children { + s, err := parseSeq(p) + if err != nil { + return err + } + if s < lowestSeq { + lowestSeq = s + } + if s < seq && s > prevSeq { + prevSeq = s + prevSeqPath = p + } + } + + if seq == lowestSeq { + // Acquired the lock + break + } + + // Wait on the node next in line for the lock + _, _, ch, err := l.c.GetW(l.path + "/" + prevSeqPath) + if err != nil && err != ErrNoNode { + return err + } else if err != nil && err == ErrNoNode { + // try again + continue + } + + ev := <-ch + if ev.Err != nil { + return ev.Err + } + } + + l.seq = seq + l.lockPath = path + return nil +} + +// Unlock releases an acquired lock. If the lock is not currently acquired by +// this Lock instance than ErrNotLocked is returned. +func (l *Lock) Unlock() error { + if l.lockPath == "" { + return ErrNotLocked + } + if err := l.c.Delete(l.lockPath, -1); err != nil { + return err + } + l.lockPath = "" + l.seq = 0 + return nil +} diff --git a/vendor/github.com/samuel/go-zookeeper/zk/server_help.go b/vendor/github.com/samuel/go-zookeeper/zk/server_help.go new file mode 100644 index 00000000..618185a2 --- /dev/null +++ b/vendor/github.com/samuel/go-zookeeper/zk/server_help.go @@ -0,0 +1,190 @@ +package zk + +import ( + "fmt" + "io" + "io/ioutil" + "math/rand" + "os" + "path/filepath" + "strings" + "time" +) + +func init() { + rand.Seed(time.Now().UnixNano()) +} + +type TestServer struct { + Port int + Path string + Srv *Server +} + +type TestCluster struct { + Path string + Servers []TestServer +} + +func StartTestCluster(size int, stdout, stderr io.Writer) (*TestCluster, error) { + tmpPath, err := ioutil.TempDir("", "gozk") + if err != nil { + return nil, err + } + success := false + startPort := int(rand.Int31n(6000) + 10000) + cluster := &TestCluster{Path: tmpPath} + defer func() { + if !success { + cluster.Stop() + } + }() + for serverN := 0; serverN < size; serverN++ { + srvPath := filepath.Join(tmpPath, fmt.Sprintf("srv%d", serverN)) + if err := os.Mkdir(srvPath, 0700); err != nil { + return nil, err + } + port := startPort + serverN*3 + cfg := ServerConfig{ + ClientPort: port, + DataDir: srvPath, + } + for i := 0; i < size; i++ { + cfg.Servers = append(cfg.Servers, ServerConfigServer{ + ID: i + 1, + Host: "127.0.0.1", + PeerPort: startPort + i*3 + 1, + LeaderElectionPort: startPort + i*3 + 2, + }) + } + cfgPath := filepath.Join(srvPath, "zoo.cfg") + fi, err := os.Create(cfgPath) + if err != nil { + return nil, err + } + err = cfg.Marshall(fi) + fi.Close() + if err != nil { + return nil, err + } + + fi, err = os.Create(filepath.Join(srvPath, "myid")) + if err != nil { + return nil, err + } + _, err = fmt.Fprintf(fi, "%d\n", serverN+1) + fi.Close() + if err != nil { + return nil, err + } + + srv := &Server{ + ConfigPath: cfgPath, + Stdout: stdout, + Stderr: stderr, + } + if err := srv.Start(); err != nil { + return nil, err + } + cluster.Servers = append(cluster.Servers, TestServer{ + Path: srvPath, + Port: cfg.ClientPort, + Srv: srv, + }) + } + if err := cluster.waitForStart(10, time.Second); err != nil { + return nil, err + } + success = true + return cluster, nil +} + +func (ts *TestCluster) Connect(idx int) (*Conn, error) { + zk, _, err := Connect([]string{fmt.Sprintf("127.0.0.1:%d", ts.Servers[idx].Port)}, time.Second*15) + return zk, err +} + +func (ts *TestCluster) ConnectAll() (*Conn, <-chan Event, error) { + return ts.ConnectAllTimeout(time.Second * 15) +} + +func (ts *TestCluster) ConnectAllTimeout(sessionTimeout time.Duration) (*Conn, <-chan Event, error) { + hosts := make([]string, len(ts.Servers)) + for i, srv := range ts.Servers { + hosts[i] = fmt.Sprintf("127.0.0.1:%d", srv.Port) + } + zk, ch, err := Connect(hosts, sessionTimeout) + return zk, ch, err +} + +func (ts *TestCluster) Stop() error { + for _, srv := range ts.Servers { + srv.Srv.Stop() + } + defer os.RemoveAll(ts.Path) + return ts.waitForStop(5, time.Second) +} + +// waitForStart blocks until the cluster is up +func (ts *TestCluster) waitForStart(maxRetry int, interval time.Duration) error { + // verify that the servers are up with SRVR + serverAddrs := make([]string, len(ts.Servers)) + for i, s := range ts.Servers { + serverAddrs[i] = fmt.Sprintf("127.0.0.1:%d", s.Port) + } + + for i := 0; i < maxRetry; i++ { + _, ok := FLWSrvr(serverAddrs, time.Second) + if ok { + return nil + } + time.Sleep(interval) + } + return fmt.Errorf("unable to verify health of servers") +} + +// waitForStop blocks until the cluster is down +func (ts *TestCluster) waitForStop(maxRetry int, interval time.Duration) error { + // verify that the servers are up with RUOK + serverAddrs := make([]string, len(ts.Servers)) + for i, s := range ts.Servers { + serverAddrs[i] = fmt.Sprintf("127.0.0.1:%d", s.Port) + } + + var success bool + for i := 0; i < maxRetry && !success; i++ { + success = true + for _, ok := range FLWRuok(serverAddrs, time.Second) { + if ok { + success = false + } + } + if !success { + time.Sleep(interval) + } + } + if !success { + return fmt.Errorf("unable to verify servers are down") + } + return nil +} + +func (tc *TestCluster) StartServer(server string) { + for _, s := range tc.Servers { + if strings.HasSuffix(server, fmt.Sprintf(":%d", s.Port)) { + s.Srv.Start() + return + } + } + panic(fmt.Sprintf("Unknown server: %s", server)) +} + +func (tc *TestCluster) StopServer(server string) { + for _, s := range tc.Servers { + if strings.HasSuffix(server, fmt.Sprintf(":%d", s.Port)) { + s.Srv.Stop() + return + } + } + panic(fmt.Sprintf("Unknown server: %s", server)) +} diff --git a/vendor/github.com/samuel/go-zookeeper/zk/server_java.go b/vendor/github.com/samuel/go-zookeeper/zk/server_java.go new file mode 100644 index 00000000..e553ec1d --- /dev/null +++ b/vendor/github.com/samuel/go-zookeeper/zk/server_java.go @@ -0,0 +1,136 @@ +package zk + +import ( + "fmt" + "io" + "os" + "os/exec" + "path/filepath" +) + +type ErrMissingServerConfigField string + +func (e ErrMissingServerConfigField) Error() string { + return fmt.Sprintf("zk: missing server config field '%s'", string(e)) +} + +const ( + DefaultServerTickTime = 2000 + DefaultServerInitLimit = 10 + DefaultServerSyncLimit = 5 + DefaultServerAutoPurgeSnapRetainCount = 3 + DefaultPeerPort = 2888 + DefaultLeaderElectionPort = 3888 +) + +type ServerConfigServer struct { + ID int + Host string + PeerPort int + LeaderElectionPort int +} + +type ServerConfig struct { + TickTime int // Number of milliseconds of each tick + InitLimit int // Number of ticks that the initial synchronization phase can take + SyncLimit int // Number of ticks that can pass between sending a request and getting an acknowledgement + DataDir string // Direcrory where the snapshot is stored + ClientPort int // Port at which clients will connect + AutoPurgeSnapRetainCount int // Number of snapshots to retain in dataDir + AutoPurgePurgeInterval int // Purge task internal in hours (0 to disable auto purge) + Servers []ServerConfigServer +} + +func (sc ServerConfig) Marshall(w io.Writer) error { + if sc.DataDir == "" { + return ErrMissingServerConfigField("dataDir") + } + fmt.Fprintf(w, "dataDir=%s\n", sc.DataDir) + if sc.TickTime <= 0 { + sc.TickTime = DefaultServerTickTime + } + fmt.Fprintf(w, "tickTime=%d\n", sc.TickTime) + if sc.InitLimit <= 0 { + sc.InitLimit = DefaultServerInitLimit + } + fmt.Fprintf(w, "initLimit=%d\n", sc.InitLimit) + if sc.SyncLimit <= 0 { + sc.SyncLimit = DefaultServerSyncLimit + } + fmt.Fprintf(w, "syncLimit=%d\n", sc.SyncLimit) + if sc.ClientPort <= 0 { + sc.ClientPort = DefaultPort + } + fmt.Fprintf(w, "clientPort=%d\n", sc.ClientPort) + if sc.AutoPurgePurgeInterval > 0 { + if sc.AutoPurgeSnapRetainCount <= 0 { + sc.AutoPurgeSnapRetainCount = DefaultServerAutoPurgeSnapRetainCount + } + fmt.Fprintf(w, "autopurge.snapRetainCount=%d\n", sc.AutoPurgeSnapRetainCount) + fmt.Fprintf(w, "autopurge.purgeInterval=%d\n", sc.AutoPurgePurgeInterval) + } + if len(sc.Servers) > 0 { + for _, srv := range sc.Servers { + if srv.PeerPort <= 0 { + srv.PeerPort = DefaultPeerPort + } + if srv.LeaderElectionPort <= 0 { + srv.LeaderElectionPort = DefaultLeaderElectionPort + } + fmt.Fprintf(w, "server.%d=%s:%d:%d\n", srv.ID, srv.Host, srv.PeerPort, srv.LeaderElectionPort) + } + } + return nil +} + +var jarSearchPaths = []string{ + "zookeeper-*/contrib/fatjar/zookeeper-*-fatjar.jar", + "../zookeeper-*/contrib/fatjar/zookeeper-*-fatjar.jar", + "/usr/share/java/zookeeper-*.jar", + "/usr/local/zookeeper-*/contrib/fatjar/zookeeper-*-fatjar.jar", + "/usr/local/Cellar/zookeeper/*/libexec/contrib/fatjar/zookeeper-*-fatjar.jar", +} + +func findZookeeperFatJar() string { + var paths []string + zkPath := os.Getenv("ZOOKEEPER_PATH") + if zkPath == "" { + paths = jarSearchPaths + } else { + paths = []string{filepath.Join(zkPath, "contrib/fatjar/zookeeper-*-fatjar.jar")} + } + for _, path := range paths { + matches, _ := filepath.Glob(path) + // TODO: could sort by version and pick latest + if len(matches) > 0 { + return matches[0] + } + } + return "" +} + +type Server struct { + JarPath string + ConfigPath string + Stdout, Stderr io.Writer + + cmd *exec.Cmd +} + +func (srv *Server) Start() error { + if srv.JarPath == "" { + srv.JarPath = findZookeeperFatJar() + if srv.JarPath == "" { + return fmt.Errorf("zk: unable to find server jar") + } + } + srv.cmd = exec.Command("java", "-jar", srv.JarPath, "server", srv.ConfigPath) + srv.cmd.Stdout = srv.Stdout + srv.cmd.Stderr = srv.Stderr + return srv.cmd.Start() +} + +func (srv *Server) Stop() error { + srv.cmd.Process.Signal(os.Kill) + return srv.cmd.Wait() +} diff --git a/vendor/github.com/samuel/go-zookeeper/zk/structs.go b/vendor/github.com/samuel/go-zookeeper/zk/structs.go new file mode 100644 index 00000000..02cd3f35 --- /dev/null +++ b/vendor/github.com/samuel/go-zookeeper/zk/structs.go @@ -0,0 +1,600 @@ +package zk + +import ( + "encoding/binary" + "errors" + "log" + "reflect" + "runtime" + "time" +) + +var ( + ErrUnhandledFieldType = errors.New("zk: unhandled field type") + ErrPtrExpected = errors.New("zk: encode/decode expect a non-nil pointer to struct") + ErrShortBuffer = errors.New("zk: buffer too small") +) + +type defaultLogger struct{} + +func (defaultLogger) Printf(format string, a ...interface{}) { + log.Printf(format, a...) +} + +type ACL struct { + Perms int32 + Scheme string + ID string +} + +type Stat struct { + Czxid int64 // The zxid of the change that caused this znode to be created. + Mzxid int64 // The zxid of the change that last modified this znode. + Ctime int64 // The time in milliseconds from epoch when this znode was created. + Mtime int64 // The time in milliseconds from epoch when this znode was last modified. + Version int32 // The number of changes to the data of this znode. + Cversion int32 // The number of changes to the children of this znode. + Aversion int32 // The number of changes to the ACL of this znode. + EphemeralOwner int64 // The session id of the owner of this znode if the znode is an ephemeral node. If it is not an ephemeral node, it will be zero. + DataLength int32 // The length of the data field of this znode. + NumChildren int32 // The number of children of this znode. + Pzxid int64 // last modified children +} + +// ServerClient is the information for a single Zookeeper client and its session. +// This is used to parse/extract the output fo the `cons` command. +type ServerClient struct { + Queued int64 + Received int64 + Sent int64 + SessionID int64 + Lcxid int64 + Lzxid int64 + Timeout int32 + LastLatency int32 + MinLatency int32 + AvgLatency int32 + MaxLatency int32 + Established time.Time + LastResponse time.Time + Addr string + LastOperation string // maybe? + Error error +} + +// ServerClients is a struct for the FLWCons() function. It's used to provide +// the list of Clients. +// +// This is needed because FLWCons() takes multiple servers. +type ServerClients struct { + Clients []*ServerClient + Error error +} + +// ServerStats is the information pulled from the Zookeeper `stat` command. +type ServerStats struct { + Sent int64 + Received int64 + NodeCount int64 + MinLatency int64 + AvgLatency int64 + MaxLatency int64 + Connections int64 + Outstanding int64 + Epoch int32 + Counter int32 + BuildTime time.Time + Mode Mode + Version string + Error error +} + +type requestHeader struct { + Xid int32 + Opcode int32 +} + +type responseHeader struct { + Xid int32 + Zxid int64 + Err ErrCode +} + +type multiHeader struct { + Type int32 + Done bool + Err ErrCode +} + +type auth struct { + Type int32 + Scheme string + Auth []byte +} + +// Generic request structs + +type pathRequest struct { + Path string +} + +type PathVersionRequest struct { + Path string + Version int32 +} + +type pathWatchRequest struct { + Path string + Watch bool +} + +type pathResponse struct { + Path string +} + +type statResponse struct { + Stat Stat +} + +// + +type CheckVersionRequest PathVersionRequest +type closeRequest struct{} +type closeResponse struct{} + +type connectRequest struct { + ProtocolVersion int32 + LastZxidSeen int64 + TimeOut int32 + SessionID int64 + Passwd []byte +} + +type connectResponse struct { + ProtocolVersion int32 + TimeOut int32 + SessionID int64 + Passwd []byte +} + +type CreateRequest struct { + Path string + Data []byte + Acl []ACL + Flags int32 +} + +type createResponse pathResponse +type DeleteRequest PathVersionRequest +type deleteResponse struct{} + +type errorResponse struct { + Err int32 +} + +type existsRequest pathWatchRequest +type existsResponse statResponse +type getAclRequest pathRequest + +type getAclResponse struct { + Acl []ACL + Stat Stat +} + +type getChildrenRequest pathRequest + +type getChildrenResponse struct { + Children []string +} + +type getChildren2Request pathWatchRequest + +type getChildren2Response struct { + Children []string + Stat Stat +} + +type getDataRequest pathWatchRequest + +type getDataResponse struct { + Data []byte + Stat Stat +} + +type getMaxChildrenRequest pathRequest + +type getMaxChildrenResponse struct { + Max int32 +} + +type getSaslRequest struct { + Token []byte +} + +type pingRequest struct{} +type pingResponse struct{} + +type setAclRequest struct { + Path string + Acl []ACL + Version int32 +} + +type setAclResponse statResponse + +type SetDataRequest struct { + Path string + Data []byte + Version int32 +} + +type setDataResponse statResponse + +type setMaxChildren struct { + Path string + Max int32 +} + +type setSaslRequest struct { + Token string +} + +type setSaslResponse struct { + Token string +} + +type setWatchesRequest struct { + RelativeZxid int64 + DataWatches []string + ExistWatches []string + ChildWatches []string +} + +type setWatchesResponse struct{} + +type syncRequest pathRequest +type syncResponse pathResponse + +type setAuthRequest auth +type setAuthResponse struct{} + +type multiRequestOp struct { + Header multiHeader + Op interface{} +} +type multiRequest struct { + Ops []multiRequestOp + DoneHeader multiHeader +} +type multiResponseOp struct { + Header multiHeader + String string + Stat *Stat +} +type multiResponse struct { + Ops []multiResponseOp + DoneHeader multiHeader +} + +func (r *multiRequest) Encode(buf []byte) (int, error) { + total := 0 + for _, op := range r.Ops { + op.Header.Done = false + n, err := encodePacketValue(buf[total:], reflect.ValueOf(op)) + if err != nil { + return total, err + } + total += n + } + r.DoneHeader.Done = true + n, err := encodePacketValue(buf[total:], reflect.ValueOf(r.DoneHeader)) + if err != nil { + return total, err + } + total += n + + return total, nil +} + +func (r *multiRequest) Decode(buf []byte) (int, error) { + r.Ops = make([]multiRequestOp, 0) + r.DoneHeader = multiHeader{-1, true, -1} + total := 0 + for { + header := &multiHeader{} + n, err := decodePacketValue(buf[total:], reflect.ValueOf(header)) + if err != nil { + return total, err + } + total += n + if header.Done { + r.DoneHeader = *header + break + } + + req := requestStructForOp(header.Type) + if req == nil { + return total, ErrAPIError + } + n, err = decodePacketValue(buf[total:], reflect.ValueOf(req)) + if err != nil { + return total, err + } + total += n + r.Ops = append(r.Ops, multiRequestOp{*header, req}) + } + return total, nil +} + +func (r *multiResponse) Decode(buf []byte) (int, error) { + r.Ops = make([]multiResponseOp, 0) + r.DoneHeader = multiHeader{-1, true, -1} + total := 0 + for { + header := &multiHeader{} + n, err := decodePacketValue(buf[total:], reflect.ValueOf(header)) + if err != nil { + return total, err + } + total += n + if header.Done { + r.DoneHeader = *header + break + } + + res := multiResponseOp{Header: *header} + var w reflect.Value + switch header.Type { + default: + return total, ErrAPIError + case opCreate: + w = reflect.ValueOf(&res.String) + case opSetData: + res.Stat = new(Stat) + w = reflect.ValueOf(res.Stat) + case opCheck, opDelete: + } + if w.IsValid() { + n, err := decodePacketValue(buf[total:], w) + if err != nil { + return total, err + } + total += n + } + r.Ops = append(r.Ops, res) + } + return total, nil +} + +type watcherEvent struct { + Type EventType + State State + Path string +} + +type decoder interface { + Decode(buf []byte) (int, error) +} + +type encoder interface { + Encode(buf []byte) (int, error) +} + +func decodePacket(buf []byte, st interface{}) (n int, err error) { + defer func() { + if r := recover(); r != nil { + if e, ok := r.(runtime.Error); ok && e.Error() == "runtime error: slice bounds out of range" { + err = ErrShortBuffer + } else { + panic(r) + } + } + }() + + v := reflect.ValueOf(st) + if v.Kind() != reflect.Ptr || v.IsNil() { + return 0, ErrPtrExpected + } + return decodePacketValue(buf, v) +} + +func decodePacketValue(buf []byte, v reflect.Value) (int, error) { + rv := v + kind := v.Kind() + if kind == reflect.Ptr { + if v.IsNil() { + v.Set(reflect.New(v.Type().Elem())) + } + v = v.Elem() + kind = v.Kind() + } + + n := 0 + switch kind { + default: + return n, ErrUnhandledFieldType + case reflect.Struct: + if de, ok := rv.Interface().(decoder); ok { + return de.Decode(buf) + } else if de, ok := v.Interface().(decoder); ok { + return de.Decode(buf) + } else { + for i := 0; i < v.NumField(); i++ { + field := v.Field(i) + n2, err := decodePacketValue(buf[n:], field) + n += n2 + if err != nil { + return n, err + } + } + } + case reflect.Bool: + v.SetBool(buf[n] != 0) + n++ + case reflect.Int32: + v.SetInt(int64(binary.BigEndian.Uint32(buf[n : n+4]))) + n += 4 + case reflect.Int64: + v.SetInt(int64(binary.BigEndian.Uint64(buf[n : n+8]))) + n += 8 + case reflect.String: + ln := int(binary.BigEndian.Uint32(buf[n : n+4])) + v.SetString(string(buf[n+4 : n+4+ln])) + n += 4 + ln + case reflect.Slice: + switch v.Type().Elem().Kind() { + default: + count := int(binary.BigEndian.Uint32(buf[n : n+4])) + n += 4 + values := reflect.MakeSlice(v.Type(), count, count) + v.Set(values) + for i := 0; i < count; i++ { + n2, err := decodePacketValue(buf[n:], values.Index(i)) + n += n2 + if err != nil { + return n, err + } + } + case reflect.Uint8: + ln := int(int32(binary.BigEndian.Uint32(buf[n : n+4]))) + if ln < 0 { + n += 4 + v.SetBytes(nil) + } else { + bytes := make([]byte, ln) + copy(bytes, buf[n+4:n+4+ln]) + v.SetBytes(bytes) + n += 4 + ln + } + } + } + return n, nil +} + +func encodePacket(buf []byte, st interface{}) (n int, err error) { + defer func() { + if r := recover(); r != nil { + if e, ok := r.(runtime.Error); ok && e.Error() == "runtime error: slice bounds out of range" { + err = ErrShortBuffer + } else { + panic(r) + } + } + }() + + v := reflect.ValueOf(st) + if v.Kind() != reflect.Ptr || v.IsNil() { + return 0, ErrPtrExpected + } + return encodePacketValue(buf, v) +} + +func encodePacketValue(buf []byte, v reflect.Value) (int, error) { + rv := v + for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface { + v = v.Elem() + } + + n := 0 + switch v.Kind() { + default: + return n, ErrUnhandledFieldType + case reflect.Struct: + if en, ok := rv.Interface().(encoder); ok { + return en.Encode(buf) + } else if en, ok := v.Interface().(encoder); ok { + return en.Encode(buf) + } else { + for i := 0; i < v.NumField(); i++ { + field := v.Field(i) + n2, err := encodePacketValue(buf[n:], field) + n += n2 + if err != nil { + return n, err + } + } + } + case reflect.Bool: + if v.Bool() { + buf[n] = 1 + } else { + buf[n] = 0 + } + n++ + case reflect.Int32: + binary.BigEndian.PutUint32(buf[n:n+4], uint32(v.Int())) + n += 4 + case reflect.Int64: + binary.BigEndian.PutUint64(buf[n:n+8], uint64(v.Int())) + n += 8 + case reflect.String: + str := v.String() + binary.BigEndian.PutUint32(buf[n:n+4], uint32(len(str))) + copy(buf[n+4:n+4+len(str)], []byte(str)) + n += 4 + len(str) + case reflect.Slice: + switch v.Type().Elem().Kind() { + default: + count := v.Len() + startN := n + n += 4 + for i := 0; i < count; i++ { + n2, err := encodePacketValue(buf[n:], v.Index(i)) + n += n2 + if err != nil { + return n, err + } + } + binary.BigEndian.PutUint32(buf[startN:startN+4], uint32(count)) + case reflect.Uint8: + if v.IsNil() { + binary.BigEndian.PutUint32(buf[n:n+4], uint32(0xffffffff)) + n += 4 + } else { + bytes := v.Bytes() + binary.BigEndian.PutUint32(buf[n:n+4], uint32(len(bytes))) + copy(buf[n+4:n+4+len(bytes)], bytes) + n += 4 + len(bytes) + } + } + } + return n, nil +} + +func requestStructForOp(op int32) interface{} { + switch op { + case opClose: + return &closeRequest{} + case opCreate: + return &CreateRequest{} + case opDelete: + return &DeleteRequest{} + case opExists: + return &existsRequest{} + case opGetAcl: + return &getAclRequest{} + case opGetChildren: + return &getChildrenRequest{} + case opGetChildren2: + return &getChildren2Request{} + case opGetData: + return &getDataRequest{} + case opPing: + return &pingRequest{} + case opSetAcl: + return &setAclRequest{} + case opSetData: + return &SetDataRequest{} + case opSetWatches: + return &setWatchesRequest{} + case opSync: + return &syncRequest{} + case opSetAuth: + return &setAuthRequest{} + case opCheck: + return &CheckVersionRequest{} + case opMulti: + return &multiRequest{} + } + return nil +} diff --git a/vendor/github.com/samuel/go-zookeeper/zk/util.go b/vendor/github.com/samuel/go-zookeeper/zk/util.go new file mode 100644 index 00000000..769bbe87 --- /dev/null +++ b/vendor/github.com/samuel/go-zookeeper/zk/util.go @@ -0,0 +1,54 @@ +package zk + +import ( + "crypto/sha1" + "encoding/base64" + "fmt" + "math/rand" + "strconv" + "strings" +) + +// AuthACL produces an ACL list containing a single ACL which uses the +// provided permissions, with the scheme "auth", and ID "", which is used +// by ZooKeeper to represent any authenticated user. +func AuthACL(perms int32) []ACL { + return []ACL{{perms, "auth", ""}} +} + +// WorldACL produces an ACL list containing a single ACL which uses the +// provided permissions, with the scheme "world", and ID "anyone", which +// is used by ZooKeeper to represent any user at all. +func WorldACL(perms int32) []ACL { + return []ACL{{perms, "world", "anyone"}} +} + +func DigestACL(perms int32, user, password string) []ACL { + userPass := []byte(fmt.Sprintf("%s:%s", user, password)) + h := sha1.New() + if n, err := h.Write(userPass); err != nil || n != len(userPass) { + panic("SHA1 failed") + } + digest := base64.StdEncoding.EncodeToString(h.Sum(nil)) + return []ACL{{perms, "digest", fmt.Sprintf("%s:%s", user, digest)}} +} + +// FormatServers takes a slice of addresses, and makes sure they are in a format +// that resembles :. If the server has no port provided, the +// DefaultPort constant is added to the end. +func FormatServers(servers []string) []string { + for i := range servers { + if !strings.Contains(servers[i], ":") { + servers[i] = servers[i] + ":" + strconv.Itoa(DefaultPort) + } + } + return servers +} + +// stringShuffle performs a Fisher-Yates shuffle on a slice of strings +func stringShuffle(s []string) { + for i := len(s) - 1; i > 0; i-- { + j := rand.Intn(i + 1) + s[i], s[j] = s[j], s[i] + } +} diff --git a/vendor/github.com/spf13/cobra/LICENSE.txt b/vendor/github.com/spf13/cobra/LICENSE.txt new file mode 100644 index 00000000..298f0e26 --- /dev/null +++ b/vendor/github.com/spf13/cobra/LICENSE.txt @@ -0,0 +1,174 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. diff --git a/vendor/github.com/spf13/cobra/bash_completions.go b/vendor/github.com/spf13/cobra/bash_completions.go new file mode 100644 index 00000000..c9b43d98 --- /dev/null +++ b/vendor/github.com/spf13/cobra/bash_completions.go @@ -0,0 +1,643 @@ +package cobra + +import ( + "fmt" + "io" + "os" + "sort" + "strings" + + "github.com/spf13/pflag" +) + +const ( + BashCompFilenameExt = "cobra_annotation_bash_completion_filename_extensions" + BashCompCustom = "cobra_annotation_bash_completion_custom" + BashCompOneRequiredFlag = "cobra_annotation_bash_completion_one_required_flag" + BashCompSubdirsInDir = "cobra_annotation_bash_completion_subdirs_in_dir" +) + +func preamble(out io.Writer, name string) error { + _, err := fmt.Fprintf(out, "# bash completion for %-36s -*- shell-script -*-\n", name) + if err != nil { + return err + } + _, err = fmt.Fprint(out, ` +__debug() +{ + if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then + echo "$*" >> "${BASH_COMP_DEBUG_FILE}" + fi +} + +# Homebrew on Macs have version 1.3 of bash-completion which doesn't include +# _init_completion. This is a very minimal version of that function. +__my_init_completion() +{ + COMPREPLY=() + _get_comp_words_by_ref "$@" cur prev words cword +} + +__index_of_word() +{ + local w word=$1 + shift + index=0 + for w in "$@"; do + [[ $w = "$word" ]] && return + index=$((index+1)) + done + index=-1 +} + +__contains_word() +{ + local w word=$1; shift + for w in "$@"; do + [[ $w = "$word" ]] && return + done + return 1 +} + +__handle_reply() +{ + __debug "${FUNCNAME[0]}" + case $cur in + -*) + if [[ $(type -t compopt) = "builtin" ]]; then + compopt -o nospace + fi + local allflags + if [ ${#must_have_one_flag[@]} -ne 0 ]; then + allflags=("${must_have_one_flag[@]}") + else + allflags=("${flags[*]} ${two_word_flags[*]}") + fi + COMPREPLY=( $(compgen -W "${allflags[*]}" -- "$cur") ) + if [[ $(type -t compopt) = "builtin" ]]; then + [[ "${COMPREPLY[0]}" == *= ]] || compopt +o nospace + fi + + # complete after --flag=abc + if [[ $cur == *=* ]]; then + if [[ $(type -t compopt) = "builtin" ]]; then + compopt +o nospace + fi + + local index flag + flag="${cur%%=*}" + __index_of_word "${flag}" "${flags_with_completion[@]}" + if [[ ${index} -ge 0 ]]; then + COMPREPLY=() + PREFIX="" + cur="${cur#*=}" + ${flags_completion[${index}]} + if [ -n "${ZSH_VERSION}" ]; then + # zfs completion needs --flag= prefix + eval "COMPREPLY=( \"\${COMPREPLY[@]/#/${flag}=}\" )" + fi + fi + fi + return 0; + ;; + esac + + # check if we are handling a flag with special work handling + local index + __index_of_word "${prev}" "${flags_with_completion[@]}" + if [[ ${index} -ge 0 ]]; then + ${flags_completion[${index}]} + return + fi + + # we are parsing a flag and don't have a special handler, no completion + if [[ ${cur} != "${words[cword]}" ]]; then + return + fi + + local completions + completions=("${commands[@]}") + if [[ ${#must_have_one_noun[@]} -ne 0 ]]; then + completions=("${must_have_one_noun[@]}") + fi + if [[ ${#must_have_one_flag[@]} -ne 0 ]]; then + completions+=("${must_have_one_flag[@]}") + fi + COMPREPLY=( $(compgen -W "${completions[*]}" -- "$cur") ) + + if [[ ${#COMPREPLY[@]} -eq 0 && ${#noun_aliases[@]} -gt 0 && ${#must_have_one_noun[@]} -ne 0 ]]; then + COMPREPLY=( $(compgen -W "${noun_aliases[*]}" -- "$cur") ) + fi + + if [[ ${#COMPREPLY[@]} -eq 0 ]]; then + declare -F __custom_func >/dev/null && __custom_func + fi + + __ltrim_colon_completions "$cur" +} + +# The arguments should be in the form "ext1|ext2|extn" +__handle_filename_extension_flag() +{ + local ext="$1" + _filedir "@(${ext})" +} + +__handle_subdirs_in_dir_flag() +{ + local dir="$1" + pushd "${dir}" >/dev/null 2>&1 && _filedir -d && popd >/dev/null 2>&1 +} + +__handle_flag() +{ + __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}" + + # if a command required a flag, and we found it, unset must_have_one_flag() + local flagname=${words[c]} + local flagvalue + # if the word contained an = + if [[ ${words[c]} == *"="* ]]; then + flagvalue=${flagname#*=} # take in as flagvalue after the = + flagname=${flagname%%=*} # strip everything after the = + flagname="${flagname}=" # but put the = back + fi + __debug "${FUNCNAME[0]}: looking for ${flagname}" + if __contains_word "${flagname}" "${must_have_one_flag[@]}"; then + must_have_one_flag=() + fi + + # if you set a flag which only applies to this command, don't show subcommands + if __contains_word "${flagname}" "${local_nonpersistent_flags[@]}"; then + commands=() + fi + + # keep flag value with flagname as flaghash + if [ -n "${flagvalue}" ] ; then + flaghash[${flagname}]=${flagvalue} + elif [ -n "${words[ $((c+1)) ]}" ] ; then + flaghash[${flagname}]=${words[ $((c+1)) ]} + else + flaghash[${flagname}]="true" # pad "true" for bool flag + fi + + # skip the argument to a two word flag + if __contains_word "${words[c]}" "${two_word_flags[@]}"; then + c=$((c+1)) + # if we are looking for a flags value, don't show commands + if [[ $c -eq $cword ]]; then + commands=() + fi + fi + + c=$((c+1)) + +} + +__handle_noun() +{ + __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}" + + if __contains_word "${words[c]}" "${must_have_one_noun[@]}"; then + must_have_one_noun=() + elif __contains_word "${words[c]}" "${noun_aliases[@]}"; then + must_have_one_noun=() + fi + + nouns+=("${words[c]}") + c=$((c+1)) +} + +__handle_command() +{ + __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}" + + local next_command + if [[ -n ${last_command} ]]; then + next_command="_${last_command}_${words[c]//:/__}" + else + if [[ $c -eq 0 ]]; then + next_command="_$(basename "${words[c]//:/__}")" + else + next_command="_${words[c]//:/__}" + fi + fi + c=$((c+1)) + __debug "${FUNCNAME[0]}: looking for ${next_command}" + declare -F $next_command >/dev/null && $next_command +} + +__handle_word() +{ + if [[ $c -ge $cword ]]; then + __handle_reply + return + fi + __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}" + if [[ "${words[c]}" == -* ]]; then + __handle_flag + elif __contains_word "${words[c]}" "${commands[@]}"; then + __handle_command + elif [[ $c -eq 0 ]] && __contains_word "$(basename "${words[c]}")" "${commands[@]}"; then + __handle_command + else + __handle_noun + fi + __handle_word +} + +`) + return err +} + +func postscript(w io.Writer, name string) error { + name = strings.Replace(name, ":", "__", -1) + _, err := fmt.Fprintf(w, "__start_%s()\n", name) + if err != nil { + return err + } + _, err = fmt.Fprintf(w, `{ + local cur prev words cword + declare -A flaghash 2>/dev/null || : + if declare -F _init_completion >/dev/null 2>&1; then + _init_completion -s || return + else + __my_init_completion -n "=" || return + fi + + local c=0 + local flags=() + local two_word_flags=() + local local_nonpersistent_flags=() + local flags_with_completion=() + local flags_completion=() + local commands=("%s") + local must_have_one_flag=() + local must_have_one_noun=() + local last_command + local nouns=() + + __handle_word +} + +`, name) + if err != nil { + return err + } + _, err = fmt.Fprintf(w, `if [[ $(type -t compopt) = "builtin" ]]; then + complete -o default -F __start_%s %s +else + complete -o default -o nospace -F __start_%s %s +fi + +`, name, name, name, name) + if err != nil { + return err + } + _, err = fmt.Fprintf(w, "# ex: ts=4 sw=4 et filetype=sh\n") + return err +} + +func writeCommands(cmd *Command, w io.Writer) error { + if _, err := fmt.Fprintf(w, " commands=()\n"); err != nil { + return err + } + for _, c := range cmd.Commands() { + if !c.IsAvailableCommand() || c == cmd.helpCommand { + continue + } + if _, err := fmt.Fprintf(w, " commands+=(%q)\n", c.Name()); err != nil { + return err + } + } + _, err := fmt.Fprintf(w, "\n") + return err +} + +func writeFlagHandler(name string, annotations map[string][]string, w io.Writer) error { + for key, value := range annotations { + switch key { + case BashCompFilenameExt: + _, err := fmt.Fprintf(w, " flags_with_completion+=(%q)\n", name) + if err != nil { + return err + } + + if len(value) > 0 { + ext := "__handle_filename_extension_flag " + strings.Join(value, "|") + _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext) + } else { + ext := "_filedir" + _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext) + } + if err != nil { + return err + } + case BashCompCustom: + _, err := fmt.Fprintf(w, " flags_with_completion+=(%q)\n", name) + if err != nil { + return err + } + if len(value) > 0 { + handlers := strings.Join(value, "; ") + _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", handlers) + } else { + _, err = fmt.Fprintf(w, " flags_completion+=(:)\n") + } + if err != nil { + return err + } + case BashCompSubdirsInDir: + _, err := fmt.Fprintf(w, " flags_with_completion+=(%q)\n", name) + + if len(value) == 1 { + ext := "__handle_subdirs_in_dir_flag " + value[0] + _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext) + } else { + ext := "_filedir -d" + _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext) + } + if err != nil { + return err + } + } + } + return nil +} + +func writeShortFlag(flag *pflag.Flag, w io.Writer) error { + b := (len(flag.NoOptDefVal) > 0) + name := flag.Shorthand + format := " " + if !b { + format += "two_word_" + } + format += "flags+=(\"-%s\")\n" + if _, err := fmt.Fprintf(w, format, name); err != nil { + return err + } + return writeFlagHandler("-"+name, flag.Annotations, w) +} + +func writeFlag(flag *pflag.Flag, w io.Writer) error { + b := (len(flag.NoOptDefVal) > 0) + name := flag.Name + format := " flags+=(\"--%s" + if !b { + format += "=" + } + format += "\")\n" + if _, err := fmt.Fprintf(w, format, name); err != nil { + return err + } + return writeFlagHandler("--"+name, flag.Annotations, w) +} + +func writeLocalNonPersistentFlag(flag *pflag.Flag, w io.Writer) error { + b := (len(flag.NoOptDefVal) > 0) + name := flag.Name + format := " local_nonpersistent_flags+=(\"--%s" + if !b { + format += "=" + } + format += "\")\n" + if _, err := fmt.Fprintf(w, format, name); err != nil { + return err + } + return nil +} + +func writeFlags(cmd *Command, w io.Writer) error { + _, err := fmt.Fprintf(w, ` flags=() + two_word_flags=() + local_nonpersistent_flags=() + flags_with_completion=() + flags_completion=() + +`) + if err != nil { + return err + } + localNonPersistentFlags := cmd.LocalNonPersistentFlags() + var visitErr error + cmd.NonInheritedFlags().VisitAll(func(flag *pflag.Flag) { + if nonCompletableFlag(flag) { + return + } + if err := writeFlag(flag, w); err != nil { + visitErr = err + return + } + if len(flag.Shorthand) > 0 { + if err := writeShortFlag(flag, w); err != nil { + visitErr = err + return + } + } + if localNonPersistentFlags.Lookup(flag.Name) != nil { + if err := writeLocalNonPersistentFlag(flag, w); err != nil { + visitErr = err + return + } + } + }) + if visitErr != nil { + return visitErr + } + cmd.InheritedFlags().VisitAll(func(flag *pflag.Flag) { + if nonCompletableFlag(flag) { + return + } + if err := writeFlag(flag, w); err != nil { + visitErr = err + return + } + if len(flag.Shorthand) > 0 { + if err := writeShortFlag(flag, w); err != nil { + visitErr = err + return + } + } + }) + if visitErr != nil { + return visitErr + } + + _, err = fmt.Fprintf(w, "\n") + return err +} + +func writeRequiredFlag(cmd *Command, w io.Writer) error { + if _, err := fmt.Fprintf(w, " must_have_one_flag=()\n"); err != nil { + return err + } + flags := cmd.NonInheritedFlags() + var visitErr error + flags.VisitAll(func(flag *pflag.Flag) { + if nonCompletableFlag(flag) { + return + } + for key := range flag.Annotations { + switch key { + case BashCompOneRequiredFlag: + format := " must_have_one_flag+=(\"--%s" + b := (flag.Value.Type() == "bool") + if !b { + format += "=" + } + format += "\")\n" + if _, err := fmt.Fprintf(w, format, flag.Name); err != nil { + visitErr = err + return + } + + if len(flag.Shorthand) > 0 { + if _, err := fmt.Fprintf(w, " must_have_one_flag+=(\"-%s\")\n", flag.Shorthand); err != nil { + visitErr = err + return + } + } + } + } + }) + return visitErr +} + +func writeRequiredNouns(cmd *Command, w io.Writer) error { + if _, err := fmt.Fprintf(w, " must_have_one_noun=()\n"); err != nil { + return err + } + sort.Sort(sort.StringSlice(cmd.ValidArgs)) + for _, value := range cmd.ValidArgs { + if _, err := fmt.Fprintf(w, " must_have_one_noun+=(%q)\n", value); err != nil { + return err + } + } + return nil +} + +func writeArgAliases(cmd *Command, w io.Writer) error { + if _, err := fmt.Fprintf(w, " noun_aliases=()\n"); err != nil { + return err + } + sort.Sort(sort.StringSlice(cmd.ArgAliases)) + for _, value := range cmd.ArgAliases { + if _, err := fmt.Fprintf(w, " noun_aliases+=(%q)\n", value); err != nil { + return err + } + } + return nil +} + +func gen(cmd *Command, w io.Writer) error { + for _, c := range cmd.Commands() { + if !c.IsAvailableCommand() || c == cmd.helpCommand { + continue + } + if err := gen(c, w); err != nil { + return err + } + } + commandName := cmd.CommandPath() + commandName = strings.Replace(commandName, " ", "_", -1) + commandName = strings.Replace(commandName, ":", "__", -1) + if _, err := fmt.Fprintf(w, "_%s()\n{\n", commandName); err != nil { + return err + } + if _, err := fmt.Fprintf(w, " last_command=%q\n", commandName); err != nil { + return err + } + if err := writeCommands(cmd, w); err != nil { + return err + } + if err := writeFlags(cmd, w); err != nil { + return err + } + if err := writeRequiredFlag(cmd, w); err != nil { + return err + } + if err := writeRequiredNouns(cmd, w); err != nil { + return err + } + if err := writeArgAliases(cmd, w); err != nil { + return err + } + if _, err := fmt.Fprintf(w, "}\n\n"); err != nil { + return err + } + return nil +} + +func (cmd *Command) GenBashCompletion(w io.Writer) error { + if err := preamble(w, cmd.Name()); err != nil { + return err + } + if len(cmd.BashCompletionFunction) > 0 { + if _, err := fmt.Fprintf(w, "%s\n", cmd.BashCompletionFunction); err != nil { + return err + } + } + if err := gen(cmd, w); err != nil { + return err + } + return postscript(w, cmd.Name()) +} + +func nonCompletableFlag(flag *pflag.Flag) bool { + return flag.Hidden || len(flag.Deprecated) > 0 +} + +func (cmd *Command) GenBashCompletionFile(filename string) error { + outFile, err := os.Create(filename) + if err != nil { + return err + } + defer outFile.Close() + + return cmd.GenBashCompletion(outFile) +} + +// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag, if it exists. +func (cmd *Command) MarkFlagRequired(name string) error { + return MarkFlagRequired(cmd.Flags(), name) +} + +// MarkPersistentFlagRequired adds the BashCompOneRequiredFlag annotation to the named persistent flag, if it exists. +func (cmd *Command) MarkPersistentFlagRequired(name string) error { + return MarkFlagRequired(cmd.PersistentFlags(), name) +} + +// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag in the flag set, if it exists. +func MarkFlagRequired(flags *pflag.FlagSet, name string) error { + return flags.SetAnnotation(name, BashCompOneRequiredFlag, []string{"true"}) +} + +// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag, if it exists. +// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided. +func (cmd *Command) MarkFlagFilename(name string, extensions ...string) error { + return MarkFlagFilename(cmd.Flags(), name, extensions...) +} + +// MarkFlagCustom adds the BashCompCustom annotation to the named flag, if it exists. +// Generated bash autocompletion will call the bash function f for the flag. +func (cmd *Command) MarkFlagCustom(name string, f string) error { + return MarkFlagCustom(cmd.Flags(), name, f) +} + +// MarkPersistentFlagFilename adds the BashCompFilenameExt annotation to the named persistent flag, if it exists. +// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided. +func (cmd *Command) MarkPersistentFlagFilename(name string, extensions ...string) error { + return MarkFlagFilename(cmd.PersistentFlags(), name, extensions...) +} + +// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag in the flag set, if it exists. +// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided. +func MarkFlagFilename(flags *pflag.FlagSet, name string, extensions ...string) error { + return flags.SetAnnotation(name, BashCompFilenameExt, extensions) +} + +// MarkFlagCustom adds the BashCompCustom annotation to the named flag in the flag set, if it exists. +// Generated bash autocompletion will call the bash function f for the flag. +func MarkFlagCustom(flags *pflag.FlagSet, name string, f string) error { + return flags.SetAnnotation(name, BashCompCustom, []string{f}) +} diff --git a/vendor/github.com/spf13/cobra/cobra.go b/vendor/github.com/spf13/cobra/cobra.go new file mode 100644 index 00000000..93a2c0f3 --- /dev/null +++ b/vendor/github.com/spf13/cobra/cobra.go @@ -0,0 +1,175 @@ +// Copyright © 2013 Steve Francia . +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Commands similar to git, go tools and other modern CLI tools +// inspired by go, go-Commander, gh and subcommand + +package cobra + +import ( + "fmt" + "io" + "reflect" + "strconv" + "strings" + "text/template" + "unicode" +) + +var templateFuncs = template.FuncMap{ + "trim": strings.TrimSpace, + "trimRightSpace": trimRightSpace, + "appendIfNotPresent": appendIfNotPresent, + "rpad": rpad, + "gt": Gt, + "eq": Eq, +} + +var initializers []func() + +// automatic prefix matching can be a dangerous thing to automatically enable in CLI tools. +// Set this to true to enable it +var EnablePrefixMatching = false + +//EnableCommandSorting controls sorting of the slice of commands, which is turned on by default. +//To disable sorting, set it to false. +var EnableCommandSorting = true + +//AddTemplateFunc adds a template function that's available to Usage and Help +//template generation. +func AddTemplateFunc(name string, tmplFunc interface{}) { + templateFuncs[name] = tmplFunc +} + +//AddTemplateFuncs adds multiple template functions availalble to Usage and +//Help template generation. +func AddTemplateFuncs(tmplFuncs template.FuncMap) { + for k, v := range tmplFuncs { + templateFuncs[k] = v + } +} + +//OnInitialize takes a series of func() arguments and appends them to a slice of func(). +func OnInitialize(y ...func()) { + for _, x := range y { + initializers = append(initializers, x) + } +} + +//Gt takes two types and checks whether the first type is greater than the second. In case of types Arrays, Chans, +//Maps and Slices, Gt will compare their lengths. Ints are compared directly while strings are first parsed as +//ints and then compared. +func Gt(a interface{}, b interface{}) bool { + var left, right int64 + av := reflect.ValueOf(a) + + switch av.Kind() { + case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: + left = int64(av.Len()) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + left = av.Int() + case reflect.String: + left, _ = strconv.ParseInt(av.String(), 10, 64) + } + + bv := reflect.ValueOf(b) + + switch bv.Kind() { + case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: + right = int64(bv.Len()) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + right = bv.Int() + case reflect.String: + right, _ = strconv.ParseInt(bv.String(), 10, 64) + } + + return left > right +} + +//Eq takes two types and checks whether they are equal. Supported types are int and string. Unsupported types will panic. +func Eq(a interface{}, b interface{}) bool { + av := reflect.ValueOf(a) + bv := reflect.ValueOf(b) + + switch av.Kind() { + case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: + panic("Eq called on unsupported type") + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return av.Int() == bv.Int() + case reflect.String: + return av.String() == bv.String() + } + return false +} + +func trimRightSpace(s string) string { + return strings.TrimRightFunc(s, unicode.IsSpace) +} + +// appendIfNotPresent will append stringToAppend to the end of s, but only if it's not yet present in s +func appendIfNotPresent(s, stringToAppend string) string { + if strings.Contains(s, stringToAppend) { + return s + } + return s + " " + stringToAppend +} + +//rpad adds padding to the right of a string +func rpad(s string, padding int) string { + template := fmt.Sprintf("%%-%ds", padding) + return fmt.Sprintf(template, s) +} + +// tmpl executes the given template text on data, writing the result to w. +func tmpl(w io.Writer, text string, data interface{}) error { + t := template.New("top") + t.Funcs(templateFuncs) + template.Must(t.Parse(text)) + return t.Execute(w, data) +} + +// ld compares two strings and returns the levenshtein distance between them +func ld(s, t string, ignoreCase bool) int { + if ignoreCase { + s = strings.ToLower(s) + t = strings.ToLower(t) + } + d := make([][]int, len(s)+1) + for i := range d { + d[i] = make([]int, len(t)+1) + } + for i := range d { + d[i][0] = i + } + for j := range d[0] { + d[0][j] = j + } + for j := 1; j <= len(t); j++ { + for i := 1; i <= len(s); i++ { + if s[i-1] == t[j-1] { + d[i][j] = d[i-1][j-1] + } else { + min := d[i-1][j] + if d[i][j-1] < min { + min = d[i][j-1] + } + if d[i-1][j-1] < min { + min = d[i-1][j-1] + } + d[i][j] = min + 1 + } + } + + } + return d[len(s)][len(t)] +} diff --git a/vendor/github.com/spf13/cobra/command.go b/vendor/github.com/spf13/cobra/command.go new file mode 100644 index 00000000..9521036f --- /dev/null +++ b/vendor/github.com/spf13/cobra/command.go @@ -0,0 +1,1256 @@ +// Copyright © 2013 Steve Francia . +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//Package cobra is a commander providing a simple interface to create powerful modern CLI interfaces. +//In addition to providing an interface, Cobra simultaneously provides a controller to organize your application code. +package cobra + +import ( + "bytes" + "fmt" + "io" + "os" + "path/filepath" + "sort" + "strings" + + flag "github.com/spf13/pflag" +) + +// Command is just that, a command for your application. +// eg. 'go run' ... 'run' is the command. Cobra requires +// you to define the usage and description as part of your command +// definition to ensure usability. +type Command struct { + // Name is the command name, usually the executable's name. + name string + // The one-line usage message. + Use string + // An array of aliases that can be used instead of the first word in Use. + Aliases []string + // An array of command names for which this command will be suggested - similar to aliases but only suggests. + SuggestFor []string + // The short description shown in the 'help' output. + Short string + // The long message shown in the 'help ' output. + Long string + // Examples of how to use the command + Example string + // List of all valid non-flag arguments that are accepted in bash completions + ValidArgs []string + // List of aliases for ValidArgs. These are not suggested to the user in the bash + // completion, but accepted if entered manually. + ArgAliases []string + // Custom functions used by the bash autocompletion generator + BashCompletionFunction string + // Is this command deprecated and should print this string when used? + Deprecated string + // Is this command hidden and should NOT show up in the list of available commands? + Hidden bool + // Full set of flags + flags *flag.FlagSet + // Set of flags childrens of this command will inherit + pflags *flag.FlagSet + // Flags that are declared specifically by this command (not inherited). + lflags *flag.FlagSet + // SilenceErrors is an option to quiet errors down stream + SilenceErrors bool + // Silence Usage is an option to silence usage when an error occurs. + SilenceUsage bool + // The *Run functions are executed in the following order: + // * PersistentPreRun() + // * PreRun() + // * Run() + // * PostRun() + // * PersistentPostRun() + // All functions get the same args, the arguments after the command name + // PersistentPreRun: children of this command will inherit and execute + PersistentPreRun func(cmd *Command, args []string) + // PersistentPreRunE: PersistentPreRun but returns an error + PersistentPreRunE func(cmd *Command, args []string) error + // PreRun: children of this command will not inherit. + PreRun func(cmd *Command, args []string) + // PreRunE: PreRun but returns an error + PreRunE func(cmd *Command, args []string) error + // Run: Typically the actual work function. Most commands will only implement this + Run func(cmd *Command, args []string) + // RunE: Run but returns an error + RunE func(cmd *Command, args []string) error + // PostRun: run after the Run command. + PostRun func(cmd *Command, args []string) + // PostRunE: PostRun but returns an error + PostRunE func(cmd *Command, args []string) error + // PersistentPostRun: children of this command will inherit and execute after PostRun + PersistentPostRun func(cmd *Command, args []string) + // PersistentPostRunE: PersistentPostRun but returns an error + PersistentPostRunE func(cmd *Command, args []string) error + // DisableAutoGenTag remove + DisableAutoGenTag bool + // Commands is the list of commands supported by this program. + commands []*Command + // Parent Command for this command + parent *Command + // max lengths of commands' string lengths for use in padding + commandsMaxUseLen int + commandsMaxCommandPathLen int + commandsMaxNameLen int + // is commands slice are sorted or not + commandsAreSorted bool + + flagErrorBuf *bytes.Buffer + + args []string // actual args parsed from flags + output *io.Writer // out writer if set in SetOutput(w) + usageFunc func(*Command) error // Usage can be defined by application + usageTemplate string // Can be defined by Application + helpTemplate string // Can be defined by Application + helpFunc func(*Command, []string) // Help can be defined by application + helpCommand *Command // The help command + // The global normalization function that we can use on every pFlag set and children commands + globNormFunc func(f *flag.FlagSet, name string) flag.NormalizedName + + // Disable the suggestions based on Levenshtein distance that go along with 'unknown command' messages + DisableSuggestions bool + // If displaying suggestions, allows to set the minimum levenshtein distance to display, must be > 0 + SuggestionsMinimumDistance int + + // Disable the flag parsing. If this is true all flags will be passed to the command as arguments. + DisableFlagParsing bool +} + +// os.Args[1:] by default, if desired, can be overridden +// particularly useful when testing. +func (c *Command) SetArgs(a []string) { + c.args = a +} + +// SetOutput sets the destination for usage and error messages. +// If output is nil, os.Stderr is used. +func (c *Command) SetOutput(output io.Writer) { + c.output = &output +} + +// Usage can be defined by application +func (c *Command) SetUsageFunc(f func(*Command) error) { + c.usageFunc = f +} + +// Can be defined by Application +func (c *Command) SetUsageTemplate(s string) { + c.usageTemplate = s +} + +// Can be defined by Application +func (c *Command) SetHelpFunc(f func(*Command, []string)) { + c.helpFunc = f +} + +func (c *Command) SetHelpCommand(cmd *Command) { + c.helpCommand = cmd +} + +// Can be defined by Application +func (c *Command) SetHelpTemplate(s string) { + c.helpTemplate = s +} + +// SetGlobalNormalizationFunc sets a normalization function to all flag sets and also to child commands. +// The user should not have a cyclic dependency on commands. +func (c *Command) SetGlobalNormalizationFunc(n func(f *flag.FlagSet, name string) flag.NormalizedName) { + c.Flags().SetNormalizeFunc(n) + c.PersistentFlags().SetNormalizeFunc(n) + c.globNormFunc = n + + for _, command := range c.commands { + command.SetGlobalNormalizationFunc(n) + } +} + +func (c *Command) OutOrStdout() io.Writer { + return c.getOut(os.Stdout) +} + +func (c *Command) OutOrStderr() io.Writer { + return c.getOut(os.Stderr) +} + +func (c *Command) getOut(def io.Writer) io.Writer { + if c.output != nil { + return *c.output + } + if c.HasParent() { + return c.parent.getOut(def) + } + return def +} + +// UsageFunc returns either the function set by SetUsageFunc for this command +// or a parent, or it returns a default usage function +func (c *Command) UsageFunc() (f func(*Command) error) { + if c.usageFunc != nil { + return c.usageFunc + } + + if c.HasParent() { + return c.parent.UsageFunc() + } + return func(c *Command) error { + c.mergePersistentFlags() + err := tmpl(c.OutOrStderr(), c.UsageTemplate(), c) + if err != nil { + c.Println(err) + } + return err + } +} + +// Output the usage for the command +// Used when a user provides invalid input +// Can be defined by user by overriding UsageFunc +func (c *Command) Usage() error { + return c.UsageFunc()(c) +} + +// HelpFunc returns either the function set by SetHelpFunc for this command +// or a parent, or it returns a function with default help behavior +func (c *Command) HelpFunc() func(*Command, []string) { + cmd := c + for cmd != nil { + if cmd.helpFunc != nil { + return cmd.helpFunc + } + cmd = cmd.parent + } + return func(*Command, []string) { + c.mergePersistentFlags() + err := tmpl(c.OutOrStdout(), c.HelpTemplate(), c) + if err != nil { + c.Println(err) + } + } +} + +// Output the help for the command +// Used when a user calls help [command] +// Can be defined by user by overriding HelpFunc +func (c *Command) Help() error { + c.HelpFunc()(c, []string{}) + return nil +} + +func (c *Command) UsageString() string { + tmpOutput := c.output + bb := new(bytes.Buffer) + c.SetOutput(bb) + c.Usage() + c.output = tmpOutput + return bb.String() +} + +var minUsagePadding = 25 + +func (c *Command) UsagePadding() int { + if c.parent == nil || minUsagePadding > c.parent.commandsMaxUseLen { + return minUsagePadding + } + return c.parent.commandsMaxUseLen +} + +var minCommandPathPadding = 11 + +// +func (c *Command) CommandPathPadding() int { + if c.parent == nil || minCommandPathPadding > c.parent.commandsMaxCommandPathLen { + return minCommandPathPadding + } + return c.parent.commandsMaxCommandPathLen +} + +var minNamePadding = 11 + +func (c *Command) NamePadding() int { + if c.parent == nil || minNamePadding > c.parent.commandsMaxNameLen { + return minNamePadding + } + return c.parent.commandsMaxNameLen +} + +func (c *Command) UsageTemplate() string { + if c.usageTemplate != "" { + return c.usageTemplate + } + + if c.HasParent() { + return c.parent.UsageTemplate() + } + return `Usage:{{if .Runnable}} + {{if .HasAvailableFlags}}{{appendIfNotPresent .UseLine "[flags]"}}{{else}}{{.UseLine}}{{end}}{{end}}{{if .HasAvailableSubCommands}} + {{ .CommandPath}} [command]{{end}}{{if gt .Aliases 0}} + +Aliases: + {{.NameAndAliases}} +{{end}}{{if .HasExample}} + +Examples: +{{ .Example }}{{end}}{{ if .HasAvailableSubCommands}} + +Available Commands:{{range .Commands}}{{if .IsAvailableCommand}} + {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasAvailableLocalFlags}} + +Flags: +{{.LocalFlags.FlagUsages | trimRightSpace}}{{end}}{{ if .HasAvailableInheritedFlags}} + +Global Flags: +{{.InheritedFlags.FlagUsages | trimRightSpace}}{{end}}{{if .HasHelpSubCommands}} + +Additional help topics:{{range .Commands}}{{if .IsHelpCommand}} + {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasAvailableSubCommands }} + +Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}} +` +} + +func (c *Command) HelpTemplate() string { + if c.helpTemplate != "" { + return c.helpTemplate + } + + if c.HasParent() { + return c.parent.HelpTemplate() + } + return `{{with or .Long .Short }}{{. | trim}} + +{{end}}{{if or .Runnable .HasSubCommands}}{{.UsageString}}{{end}}` +} + +// Really only used when casting a command to a commander +func (c *Command) resetChildrensParents() { + for _, x := range c.commands { + x.parent = c + } +} + +// Test if the named flag is a boolean flag. +func isBooleanFlag(name string, f *flag.FlagSet) bool { + flag := f.Lookup(name) + if flag == nil { + return false + } + return flag.Value.Type() == "bool" +} + +// Test if the named flag is a boolean flag. +func isBooleanShortFlag(name string, f *flag.FlagSet) bool { + result := false + f.VisitAll(func(f *flag.Flag) { + if f.Shorthand == name && f.Value.Type() == "bool" { + result = true + } + }) + return result +} + +func stripFlags(args []string, c *Command) []string { + if len(args) < 1 { + return args + } + c.mergePersistentFlags() + + commands := []string{} + + inQuote := false + inFlag := false + for _, y := range args { + if !inQuote { + switch { + case strings.HasPrefix(y, "\""): + inQuote = true + case strings.Contains(y, "=\""): + inQuote = true + case strings.HasPrefix(y, "--") && !strings.Contains(y, "="): + // TODO: this isn't quite right, we should really check ahead for 'true' or 'false' + inFlag = !isBooleanFlag(y[2:], c.Flags()) + case strings.HasPrefix(y, "-") && !strings.Contains(y, "=") && len(y) == 2 && !isBooleanShortFlag(y[1:], c.Flags()): + inFlag = true + case inFlag: + inFlag = false + case y == "": + // strip empty commands, as the go tests expect this to be ok.... + case !strings.HasPrefix(y, "-"): + commands = append(commands, y) + inFlag = false + } + } + + if strings.HasSuffix(y, "\"") && !strings.HasSuffix(y, "\\\"") { + inQuote = false + } + } + + return commands +} + +// argsMinusFirstX removes only the first x from args. Otherwise, commands that look like +// openshift admin policy add-role-to-user admin my-user, lose the admin argument (arg[4]). +func argsMinusFirstX(args []string, x string) []string { + for i, y := range args { + if x == y { + ret := []string{} + ret = append(ret, args[:i]...) + ret = append(ret, args[i+1:]...) + return ret + } + } + return args +} + +// find the target command given the args and command tree +// Meant to be run on the highest node. Only searches down. +func (c *Command) Find(args []string) (*Command, []string, error) { + if c == nil { + return nil, nil, fmt.Errorf("Called find() on a nil Command") + } + + var innerfind func(*Command, []string) (*Command, []string) + + innerfind = func(c *Command, innerArgs []string) (*Command, []string) { + argsWOflags := stripFlags(innerArgs, c) + if len(argsWOflags) == 0 { + return c, innerArgs + } + nextSubCmd := argsWOflags[0] + matches := make([]*Command, 0) + for _, cmd := range c.commands { + if cmd.Name() == nextSubCmd || cmd.HasAlias(nextSubCmd) { // exact name or alias match + return innerfind(cmd, argsMinusFirstX(innerArgs, nextSubCmd)) + } + if EnablePrefixMatching { + if strings.HasPrefix(cmd.Name(), nextSubCmd) { // prefix match + matches = append(matches, cmd) + } + for _, x := range cmd.Aliases { + if strings.HasPrefix(x, nextSubCmd) { + matches = append(matches, cmd) + } + } + } + } + + // only accept a single prefix match - multiple matches would be ambiguous + if len(matches) == 1 { + return innerfind(matches[0], argsMinusFirstX(innerArgs, argsWOflags[0])) + } + + return c, innerArgs + } + + commandFound, a := innerfind(c, args) + argsWOflags := stripFlags(a, commandFound) + + // no subcommand, always take args + if !commandFound.HasSubCommands() { + return commandFound, a, nil + } + + // root command with subcommands, do subcommand checking + if commandFound == c && len(argsWOflags) > 0 { + suggestionsString := "" + if !c.DisableSuggestions { + if c.SuggestionsMinimumDistance <= 0 { + c.SuggestionsMinimumDistance = 2 + } + if suggestions := c.SuggestionsFor(argsWOflags[0]); len(suggestions) > 0 { + suggestionsString += "\n\nDid you mean this?\n" + for _, s := range suggestions { + suggestionsString += fmt.Sprintf("\t%v\n", s) + } + } + } + return commandFound, a, fmt.Errorf("unknown command %q for %q%s", argsWOflags[0], commandFound.CommandPath(), suggestionsString) + } + + return commandFound, a, nil +} + +func (c *Command) SuggestionsFor(typedName string) []string { + suggestions := []string{} + for _, cmd := range c.commands { + if cmd.IsAvailableCommand() { + levenshteinDistance := ld(typedName, cmd.Name(), true) + suggestByLevenshtein := levenshteinDistance <= c.SuggestionsMinimumDistance + suggestByPrefix := strings.HasPrefix(strings.ToLower(cmd.Name()), strings.ToLower(typedName)) + if suggestByLevenshtein || suggestByPrefix { + suggestions = append(suggestions, cmd.Name()) + } + for _, explicitSuggestion := range cmd.SuggestFor { + if strings.EqualFold(typedName, explicitSuggestion) { + suggestions = append(suggestions, cmd.Name()) + } + } + } + } + return suggestions +} + +func (c *Command) VisitParents(fn func(*Command)) { + var traverse func(*Command) *Command + + traverse = func(x *Command) *Command { + if x != c { + fn(x) + } + if x.HasParent() { + return traverse(x.parent) + } + return x + } + traverse(c) +} + +func (c *Command) Root() *Command { + var findRoot func(*Command) *Command + + findRoot = func(x *Command) *Command { + if x.HasParent() { + return findRoot(x.parent) + } + return x + } + + return findRoot(c) +} + +// ArgsLenAtDash will return the length of f.Args at the moment when a -- was +// found during arg parsing. This allows your program to know which args were +// before the -- and which came after. (Description from +// https://godoc.org/github.com/spf13/pflag#FlagSet.ArgsLenAtDash). +func (c *Command) ArgsLenAtDash() int { + return c.Flags().ArgsLenAtDash() +} + +func (c *Command) execute(a []string) (err error) { + if c == nil { + return fmt.Errorf("Called Execute() on a nil Command") + } + + if len(c.Deprecated) > 0 { + c.Printf("Command %q is deprecated, %s\n", c.Name(), c.Deprecated) + } + + // initialize help flag as the last point possible to allow for user + // overriding + c.initHelpFlag() + + err = c.ParseFlags(a) + if err != nil { + return err + } + // If help is called, regardless of other flags, return we want help + // Also say we need help if the command isn't runnable. + helpVal, err := c.Flags().GetBool("help") + if err != nil { + // should be impossible to get here as we always declare a help + // flag in initHelpFlag() + c.Println("\"help\" flag declared as non-bool. Please correct your code") + return err + } + + if helpVal || !c.Runnable() { + return flag.ErrHelp + } + + c.preRun() + + argWoFlags := c.Flags().Args() + if c.DisableFlagParsing { + argWoFlags = a + } + + for p := c; p != nil; p = p.Parent() { + if p.PersistentPreRunE != nil { + if err := p.PersistentPreRunE(c, argWoFlags); err != nil { + return err + } + break + } else if p.PersistentPreRun != nil { + p.PersistentPreRun(c, argWoFlags) + break + } + } + if c.PreRunE != nil { + if err := c.PreRunE(c, argWoFlags); err != nil { + return err + } + } else if c.PreRun != nil { + c.PreRun(c, argWoFlags) + } + + if c.RunE != nil { + if err := c.RunE(c, argWoFlags); err != nil { + return err + } + } else { + c.Run(c, argWoFlags) + } + if c.PostRunE != nil { + if err := c.PostRunE(c, argWoFlags); err != nil { + return err + } + } else if c.PostRun != nil { + c.PostRun(c, argWoFlags) + } + for p := c; p != nil; p = p.Parent() { + if p.PersistentPostRunE != nil { + if err := p.PersistentPostRunE(c, argWoFlags); err != nil { + return err + } + break + } else if p.PersistentPostRun != nil { + p.PersistentPostRun(c, argWoFlags) + break + } + } + + return nil +} + +func (c *Command) preRun() { + for _, x := range initializers { + x() + } +} + +func (c *Command) errorMsgFromParse() string { + s := c.flagErrorBuf.String() + + x := strings.Split(s, "\n") + + if len(x) > 0 { + return x[0] + } + return "" +} + +// Call execute to use the args (os.Args[1:] by default) +// and run through the command tree finding appropriate matches +// for commands and then corresponding flags. +func (c *Command) Execute() error { + _, err := c.ExecuteC() + return err +} + +func (c *Command) ExecuteC() (cmd *Command, err error) { + + // Regardless of what command execute is called on, run on Root only + if c.HasParent() { + return c.Root().ExecuteC() + } + + // windows hook + if preExecHookFn != nil { + preExecHookFn(c) + } + + // initialize help as the last point possible to allow for user + // overriding + c.initHelpCmd() + + var args []string + + // Workaround FAIL with "go test -v" or "cobra.test -test.v", see #155 + if c.args == nil && filepath.Base(os.Args[0]) != "cobra.test" { + args = os.Args[1:] + } else { + args = c.args + } + + cmd, flags, err := c.Find(args) + if err != nil { + // If found parse to a subcommand and then failed, talk about the subcommand + if cmd != nil { + c = cmd + } + if !c.SilenceErrors { + c.Println("Error:", err.Error()) + c.Printf("Run '%v --help' for usage.\n", c.CommandPath()) + } + return c, err + } + err = cmd.execute(flags) + if err != nil { + // Always show help if requested, even if SilenceErrors is in + // effect + if err == flag.ErrHelp { + cmd.HelpFunc()(cmd, args) + return cmd, nil + } + + // If root command has SilentErrors flagged, + // all subcommands should respect it + if !cmd.SilenceErrors && !c.SilenceErrors { + c.Println("Error:", err.Error()) + } + + // If root command has SilentUsage flagged, + // all subcommands should respect it + if !cmd.SilenceUsage && !c.SilenceUsage { + c.Println(cmd.UsageString()) + } + return cmd, err + } + return cmd, nil +} + +func (c *Command) initHelpFlag() { + if c.Flags().Lookup("help") == nil { + c.Flags().BoolP("help", "h", false, "help for "+c.Name()) + } +} + +func (c *Command) initHelpCmd() { + if c.helpCommand == nil { + if !c.HasSubCommands() { + return + } + + c.helpCommand = &Command{ + Use: "help [command]", + Short: "Help about any command", + Long: `Help provides help for any command in the application. + Simply type ` + c.Name() + ` help [path to command] for full details.`, + PersistentPreRun: func(cmd *Command, args []string) {}, + PersistentPostRun: func(cmd *Command, args []string) {}, + + Run: func(c *Command, args []string) { + cmd, _, e := c.Root().Find(args) + if cmd == nil || e != nil { + c.Printf("Unknown help topic %#q.", args) + c.Root().Usage() + } else { + cmd.Help() + } + }, + } + } + c.AddCommand(c.helpCommand) +} + +// Used for testing +func (c *Command) ResetCommands() { + c.commands = nil + c.helpCommand = nil +} + +// Sorts commands by their names +type commandSorterByName []*Command + +func (c commandSorterByName) Len() int { return len(c) } +func (c commandSorterByName) Swap(i, j int) { c[i], c[j] = c[j], c[i] } +func (c commandSorterByName) Less(i, j int) bool { return c[i].Name() < c[j].Name() } + +// Commands returns a sorted slice of child commands. +func (c *Command) Commands() []*Command { + // do not sort commands if it already sorted or sorting was disabled + if EnableCommandSorting && !c.commandsAreSorted { + sort.Sort(commandSorterByName(c.commands)) + c.commandsAreSorted = true + } + return c.commands +} + +// AddCommand adds one or more commands to this parent command. +func (c *Command) AddCommand(cmds ...*Command) { + for i, x := range cmds { + if cmds[i] == c { + panic("Command can't be a child of itself") + } + cmds[i].parent = c + // update max lengths + usageLen := len(x.Use) + if usageLen > c.commandsMaxUseLen { + c.commandsMaxUseLen = usageLen + } + commandPathLen := len(x.CommandPath()) + if commandPathLen > c.commandsMaxCommandPathLen { + c.commandsMaxCommandPathLen = commandPathLen + } + nameLen := len(x.Name()) + if nameLen > c.commandsMaxNameLen { + c.commandsMaxNameLen = nameLen + } + // If global normalization function exists, update all children + if c.globNormFunc != nil { + x.SetGlobalNormalizationFunc(c.globNormFunc) + } + c.commands = append(c.commands, x) + c.commandsAreSorted = false + } +} + +// RemoveCommand removes one or more commands from a parent command. +func (c *Command) RemoveCommand(cmds ...*Command) { + commands := []*Command{} +main: + for _, command := range c.commands { + for _, cmd := range cmds { + if command == cmd { + command.parent = nil + continue main + } + } + commands = append(commands, command) + } + c.commands = commands + // recompute all lengths + c.commandsMaxUseLen = 0 + c.commandsMaxCommandPathLen = 0 + c.commandsMaxNameLen = 0 + for _, command := range c.commands { + usageLen := len(command.Use) + if usageLen > c.commandsMaxUseLen { + c.commandsMaxUseLen = usageLen + } + commandPathLen := len(command.CommandPath()) + if commandPathLen > c.commandsMaxCommandPathLen { + c.commandsMaxCommandPathLen = commandPathLen + } + nameLen := len(command.Name()) + if nameLen > c.commandsMaxNameLen { + c.commandsMaxNameLen = nameLen + } + } +} + +// Print is a convenience method to Print to the defined output, fallback to Stderr if not set +func (c *Command) Print(i ...interface{}) { + fmt.Fprint(c.OutOrStderr(), i...) +} + +// Println is a convenience method to Println to the defined output, fallback to Stderr if not set +func (c *Command) Println(i ...interface{}) { + str := fmt.Sprintln(i...) + c.Print(str) +} + +// Printf is a convenience method to Printf to the defined output, fallback to Stderr if not set +func (c *Command) Printf(format string, i ...interface{}) { + str := fmt.Sprintf(format, i...) + c.Print(str) +} + +// CommandPath returns the full path to this command. +func (c *Command) CommandPath() string { + str := c.Name() + x := c + for x.HasParent() { + str = x.parent.Name() + " " + str + x = x.parent + } + return str +} + +//The full usage for a given command (including parents) +func (c *Command) UseLine() string { + str := "" + if c.HasParent() { + str = c.parent.CommandPath() + " " + } + return str + c.Use +} + +// For use in determining which flags have been assigned to which commands +// and which persist +func (c *Command) DebugFlags() { + c.Println("DebugFlags called on", c.Name()) + var debugflags func(*Command) + + debugflags = func(x *Command) { + if x.HasFlags() || x.HasPersistentFlags() { + c.Println(x.Name()) + } + if x.HasFlags() { + x.flags.VisitAll(func(f *flag.Flag) { + if x.HasPersistentFlags() { + if x.persistentFlag(f.Name) == nil { + c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [L]") + } else { + c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [LP]") + } + } else { + c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [L]") + } + }) + } + if x.HasPersistentFlags() { + x.pflags.VisitAll(func(f *flag.Flag) { + if x.HasFlags() { + if x.flags.Lookup(f.Name) == nil { + c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [P]") + } + } else { + c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [P]") + } + }) + } + c.Println(x.flagErrorBuf) + if x.HasSubCommands() { + for _, y := range x.commands { + debugflags(y) + } + } + } + + debugflags(c) +} + +// Name returns the command's name: the first word in the use line. +func (c *Command) Name() string { + if c.name != "" { + return c.name + } + name := c.Use + i := strings.Index(name, " ") + if i >= 0 { + name = name[:i] + } + return name +} + +// HasAlias determines if a given string is an alias of the command. +func (c *Command) HasAlias(s string) bool { + for _, a := range c.Aliases { + if a == s { + return true + } + } + return false +} + +func (c *Command) NameAndAliases() string { + return strings.Join(append([]string{c.Name()}, c.Aliases...), ", ") +} + +func (c *Command) HasExample() bool { + return len(c.Example) > 0 +} + +// Runnable determines if the command is itself runnable +func (c *Command) Runnable() bool { + return c.Run != nil || c.RunE != nil +} + +// HasSubCommands determines if the command has children commands +func (c *Command) HasSubCommands() bool { + return len(c.commands) > 0 +} + +// IsAvailableCommand determines if a command is available as a non-help command +// (this includes all non deprecated/hidden commands) +func (c *Command) IsAvailableCommand() bool { + if len(c.Deprecated) != 0 || c.Hidden { + return false + } + + if c.HasParent() && c.Parent().helpCommand == c { + return false + } + + if c.Runnable() || c.HasAvailableSubCommands() { + return true + } + + return false +} + +// IsHelpCommand determines if a command is a 'help' command; a help command is +// determined by the fact that it is NOT runnable/hidden/deprecated, and has no +// sub commands that are runnable/hidden/deprecated +func (c *Command) IsHelpCommand() bool { + + // if a command is runnable, deprecated, or hidden it is not a 'help' command + if c.Runnable() || len(c.Deprecated) != 0 || c.Hidden { + return false + } + + // if any non-help sub commands are found, the command is not a 'help' command + for _, sub := range c.commands { + if !sub.IsHelpCommand() { + return false + } + } + + // the command either has no sub commands, or no non-help sub commands + return true +} + +// HasHelpSubCommands determines if a command has any available 'help' sub commands +// that need to be shown in the usage/help default template under 'additional help +// topics' +func (c *Command) HasHelpSubCommands() bool { + + // return true on the first found available 'help' sub command + for _, sub := range c.commands { + if sub.IsHelpCommand() { + return true + } + } + + // the command either has no sub commands, or no available 'help' sub commands + return false +} + +// HasAvailableSubCommands determines if a command has available sub commands that +// need to be shown in the usage/help default template under 'available commands' +func (c *Command) HasAvailableSubCommands() bool { + + // return true on the first found available (non deprecated/help/hidden) + // sub command + for _, sub := range c.commands { + if sub.IsAvailableCommand() { + return true + } + } + + // the command either has no sub comamnds, or no available (non deprecated/help/hidden) + // sub commands + return false +} + +// Determine if the command is a child command +func (c *Command) HasParent() bool { + return c.parent != nil +} + +// GlobalNormalizationFunc returns the global normalization function or nil if doesn't exists +func (c *Command) GlobalNormalizationFunc() func(f *flag.FlagSet, name string) flag.NormalizedName { + return c.globNormFunc +} + +// Get the complete FlagSet that applies to this command (local and persistent declared here and by all parents) +func (c *Command) Flags() *flag.FlagSet { + if c.flags == nil { + c.flags = flag.NewFlagSet(c.Name(), flag.ContinueOnError) + if c.flagErrorBuf == nil { + c.flagErrorBuf = new(bytes.Buffer) + } + c.flags.SetOutput(c.flagErrorBuf) + } + return c.flags +} + +// LocalNonPersistentFlags are flags specific to this command which will NOT persist to subcommands +func (c *Command) LocalNonPersistentFlags() *flag.FlagSet { + persistentFlags := c.PersistentFlags() + + out := flag.NewFlagSet(c.Name(), flag.ContinueOnError) + c.LocalFlags().VisitAll(func(f *flag.Flag) { + if persistentFlags.Lookup(f.Name) == nil { + out.AddFlag(f) + } + }) + return out +} + +// Get the local FlagSet specifically set in the current command +func (c *Command) LocalFlags() *flag.FlagSet { + c.mergePersistentFlags() + + local := flag.NewFlagSet(c.Name(), flag.ContinueOnError) + c.lflags.VisitAll(func(f *flag.Flag) { + local.AddFlag(f) + }) + if !c.HasParent() { + flag.CommandLine.VisitAll(func(f *flag.Flag) { + if local.Lookup(f.Name) == nil { + local.AddFlag(f) + } + }) + } + return local +} + +// All Flags which were inherited from parents commands +func (c *Command) InheritedFlags() *flag.FlagSet { + c.mergePersistentFlags() + + inherited := flag.NewFlagSet(c.Name(), flag.ContinueOnError) + local := c.LocalFlags() + + var rmerge func(x *Command) + + rmerge = func(x *Command) { + if x.HasPersistentFlags() { + x.PersistentFlags().VisitAll(func(f *flag.Flag) { + if inherited.Lookup(f.Name) == nil && local.Lookup(f.Name) == nil { + inherited.AddFlag(f) + } + }) + } + if x.HasParent() { + rmerge(x.parent) + } + } + + if c.HasParent() { + rmerge(c.parent) + } + + return inherited +} + +// All Flags which were not inherited from parent commands +func (c *Command) NonInheritedFlags() *flag.FlagSet { + return c.LocalFlags() +} + +// Get the Persistent FlagSet specifically set in the current command +func (c *Command) PersistentFlags() *flag.FlagSet { + if c.pflags == nil { + c.pflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError) + if c.flagErrorBuf == nil { + c.flagErrorBuf = new(bytes.Buffer) + } + c.pflags.SetOutput(c.flagErrorBuf) + } + return c.pflags +} + +// For use in testing +func (c *Command) ResetFlags() { + c.flagErrorBuf = new(bytes.Buffer) + c.flagErrorBuf.Reset() + c.flags = flag.NewFlagSet(c.Name(), flag.ContinueOnError) + c.flags.SetOutput(c.flagErrorBuf) + c.pflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError) + c.pflags.SetOutput(c.flagErrorBuf) +} + +// Does the command contain any flags (local plus persistent from the entire structure) +func (c *Command) HasFlags() bool { + return c.Flags().HasFlags() +} + +// Does the command contain persistent flags +func (c *Command) HasPersistentFlags() bool { + return c.PersistentFlags().HasFlags() +} + +// Does the command has flags specifically declared locally +func (c *Command) HasLocalFlags() bool { + return c.LocalFlags().HasFlags() +} + +// Does the command have flags inherited from its parent command +func (c *Command) HasInheritedFlags() bool { + return c.InheritedFlags().HasFlags() +} + +// Does the command contain any flags (local plus persistent from the entire +// structure) which are not hidden or deprecated +func (c *Command) HasAvailableFlags() bool { + return c.Flags().HasAvailableFlags() +} + +// Does the command contain persistent flags which are not hidden or deprecated +func (c *Command) HasAvailablePersistentFlags() bool { + return c.PersistentFlags().HasAvailableFlags() +} + +// Does the command has flags specifically declared locally which are not hidden +// or deprecated +func (c *Command) HasAvailableLocalFlags() bool { + return c.LocalFlags().HasAvailableFlags() +} + +// Does the command have flags inherited from its parent command which are +// not hidden or deprecated +func (c *Command) HasAvailableInheritedFlags() bool { + return c.InheritedFlags().HasAvailableFlags() +} + +// Flag climbs up the command tree looking for matching flag +func (c *Command) Flag(name string) (flag *flag.Flag) { + flag = c.Flags().Lookup(name) + + if flag == nil { + flag = c.persistentFlag(name) + } + + return +} + +// recursively find matching persistent flag +func (c *Command) persistentFlag(name string) (flag *flag.Flag) { + if c.HasPersistentFlags() { + flag = c.PersistentFlags().Lookup(name) + } + + if flag == nil && c.HasParent() { + flag = c.parent.persistentFlag(name) + } + return +} + +// ParseFlags parses persistent flag tree & local flags +func (c *Command) ParseFlags(args []string) (err error) { + if c.DisableFlagParsing { + return nil + } + c.mergePersistentFlags() + err = c.Flags().Parse(args) + return +} + +// Parent returns a commands parent command +func (c *Command) Parent() *Command { + return c.parent +} + +func (c *Command) mergePersistentFlags() { + var rmerge func(x *Command) + + // Save the set of local flags + if c.lflags == nil { + c.lflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError) + if c.flagErrorBuf == nil { + c.flagErrorBuf = new(bytes.Buffer) + } + c.lflags.SetOutput(c.flagErrorBuf) + addtolocal := func(f *flag.Flag) { + c.lflags.AddFlag(f) + } + c.Flags().VisitAll(addtolocal) + c.PersistentFlags().VisitAll(addtolocal) + } + rmerge = func(x *Command) { + if !x.HasParent() { + flag.CommandLine.VisitAll(func(f *flag.Flag) { + if x.PersistentFlags().Lookup(f.Name) == nil { + x.PersistentFlags().AddFlag(f) + } + }) + } + if x.HasPersistentFlags() { + x.PersistentFlags().VisitAll(func(f *flag.Flag) { + if c.Flags().Lookup(f.Name) == nil { + c.Flags().AddFlag(f) + } + }) + } + if x.HasParent() { + rmerge(x.parent) + } + } + + rmerge(c) +} diff --git a/vendor/github.com/spf13/cobra/command_notwin.go b/vendor/github.com/spf13/cobra/command_notwin.go new file mode 100644 index 00000000..6159c1cc --- /dev/null +++ b/vendor/github.com/spf13/cobra/command_notwin.go @@ -0,0 +1,5 @@ +// +build !windows + +package cobra + +var preExecHookFn func(*Command) diff --git a/vendor/github.com/spf13/cobra/command_win.go b/vendor/github.com/spf13/cobra/command_win.go new file mode 100644 index 00000000..4b0eaa1b --- /dev/null +++ b/vendor/github.com/spf13/cobra/command_win.go @@ -0,0 +1,26 @@ +// +build windows + +package cobra + +import ( + "os" + "time" + + "github.com/inconshreveable/mousetrap" +) + +var preExecHookFn = preExecHook + +// enables an information splash screen on Windows if the CLI is started from explorer.exe. +var MousetrapHelpText string = `This is a command line tool + +You need to open cmd.exe and run it from there. +` + +func preExecHook(c *Command) { + if mousetrap.StartedByExplorer() { + c.Print(MousetrapHelpText) + time.Sleep(5 * time.Second) + os.Exit(1) + } +} diff --git a/vendor/github.com/spf13/pflag/LICENSE b/vendor/github.com/spf13/pflag/LICENSE new file mode 100644 index 00000000..63ed1cfe --- /dev/null +++ b/vendor/github.com/spf13/pflag/LICENSE @@ -0,0 +1,28 @@ +Copyright (c) 2012 Alex Ogier. All rights reserved. +Copyright (c) 2012 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/spf13/pflag/bool.go b/vendor/github.com/spf13/pflag/bool.go new file mode 100644 index 00000000..d272e40b --- /dev/null +++ b/vendor/github.com/spf13/pflag/bool.go @@ -0,0 +1,97 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// optional interface to indicate boolean flags that can be +// supplied without "=value" text +type boolFlag interface { + Value + IsBoolFlag() bool +} + +// -- bool Value +type boolValue bool + +func newBoolValue(val bool, p *bool) *boolValue { + *p = val + return (*boolValue)(p) +} + +func (b *boolValue) Set(s string) error { + v, err := strconv.ParseBool(s) + *b = boolValue(v) + return err +} + +func (b *boolValue) Type() string { + return "bool" +} + +func (b *boolValue) String() string { return fmt.Sprintf("%v", *b) } + +func (b *boolValue) IsBoolFlag() bool { return true } + +func boolConv(sval string) (interface{}, error) { + return strconv.ParseBool(sval) +} + +// GetBool return the bool value of a flag with the given name +func (f *FlagSet) GetBool(name string) (bool, error) { + val, err := f.getFlagType(name, "bool", boolConv) + if err != nil { + return false, err + } + return val.(bool), nil +} + +// BoolVar defines a bool flag with specified name, default value, and usage string. +// The argument p points to a bool variable in which to store the value of the flag. +func (f *FlagSet) BoolVar(p *bool, name string, value bool, usage string) { + f.BoolVarP(p, name, "", value, usage) +} + +// BoolVarP is like BoolVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) BoolVarP(p *bool, name, shorthand string, value bool, usage string) { + flag := f.VarPF(newBoolValue(value, p), name, shorthand, usage) + flag.NoOptDefVal = "true" +} + +// BoolVar defines a bool flag with specified name, default value, and usage string. +// The argument p points to a bool variable in which to store the value of the flag. +func BoolVar(p *bool, name string, value bool, usage string) { + BoolVarP(p, name, "", value, usage) +} + +// BoolVarP is like BoolVar, but accepts a shorthand letter that can be used after a single dash. +func BoolVarP(p *bool, name, shorthand string, value bool, usage string) { + flag := CommandLine.VarPF(newBoolValue(value, p), name, shorthand, usage) + flag.NoOptDefVal = "true" +} + +// Bool defines a bool flag with specified name, default value, and usage string. +// The return value is the address of a bool variable that stores the value of the flag. +func (f *FlagSet) Bool(name string, value bool, usage string) *bool { + return f.BoolP(name, "", value, usage) +} + +// BoolP is like Bool, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) BoolP(name, shorthand string, value bool, usage string) *bool { + p := new(bool) + f.BoolVarP(p, name, shorthand, value, usage) + return p +} + +// Bool defines a bool flag with specified name, default value, and usage string. +// The return value is the address of a bool variable that stores the value of the flag. +func Bool(name string, value bool, usage string) *bool { + return BoolP(name, "", value, usage) +} + +// BoolP is like Bool, but accepts a shorthand letter that can be used after a single dash. +func BoolP(name, shorthand string, value bool, usage string) *bool { + b := CommandLine.BoolP(name, shorthand, value, usage) + return b +} diff --git a/vendor/github.com/spf13/pflag/count.go b/vendor/github.com/spf13/pflag/count.go new file mode 100644 index 00000000..7b1f142e --- /dev/null +++ b/vendor/github.com/spf13/pflag/count.go @@ -0,0 +1,97 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- count Value +type countValue int + +func newCountValue(val int, p *int) *countValue { + *p = val + return (*countValue)(p) +} + +func (i *countValue) Set(s string) error { + v, err := strconv.ParseInt(s, 0, 64) + // -1 means that no specific value was passed, so increment + if v == -1 { + *i = countValue(*i + 1) + } else { + *i = countValue(v) + } + return err +} + +func (i *countValue) Type() string { + return "count" +} + +func (i *countValue) String() string { return fmt.Sprintf("%v", *i) } + +func countConv(sval string) (interface{}, error) { + i, err := strconv.Atoi(sval) + if err != nil { + return nil, err + } + return i, nil +} + +// GetCount return the int value of a flag with the given name +func (f *FlagSet) GetCount(name string) (int, error) { + val, err := f.getFlagType(name, "count", countConv) + if err != nil { + return 0, err + } + return val.(int), nil +} + +// CountVar defines a count flag with specified name, default value, and usage string. +// The argument p points to an int variable in which to store the value of the flag. +// A count flag will add 1 to its value evey time it is found on the command line +func (f *FlagSet) CountVar(p *int, name string, usage string) { + f.CountVarP(p, name, "", usage) +} + +// CountVarP is like CountVar only take a shorthand for the flag name. +func (f *FlagSet) CountVarP(p *int, name, shorthand string, usage string) { + flag := f.VarPF(newCountValue(0, p), name, shorthand, usage) + flag.NoOptDefVal = "-1" +} + +// CountVar like CountVar only the flag is placed on the CommandLine instead of a given flag set +func CountVar(p *int, name string, usage string) { + CommandLine.CountVar(p, name, usage) +} + +// CountVarP is like CountVar only take a shorthand for the flag name. +func CountVarP(p *int, name, shorthand string, usage string) { + CommandLine.CountVarP(p, name, shorthand, usage) +} + +// Count defines a count flag with specified name, default value, and usage string. +// The return value is the address of an int variable that stores the value of the flag. +// A count flag will add 1 to its value evey time it is found on the command line +func (f *FlagSet) Count(name string, usage string) *int { + p := new(int) + f.CountVarP(p, name, "", usage) + return p +} + +// CountP is like Count only takes a shorthand for the flag name. +func (f *FlagSet) CountP(name, shorthand string, usage string) *int { + p := new(int) + f.CountVarP(p, name, shorthand, usage) + return p +} + +// Count like Count only the flag is placed on the CommandLine isntead of a given flag set +func Count(name string, usage string) *int { + return CommandLine.CountP(name, "", usage) +} + +// CountP is like Count only takes a shorthand for the flag name. +func CountP(name, shorthand string, usage string) *int { + return CommandLine.CountP(name, shorthand, usage) +} diff --git a/vendor/github.com/spf13/pflag/duration.go b/vendor/github.com/spf13/pflag/duration.go new file mode 100644 index 00000000..e9debef8 --- /dev/null +++ b/vendor/github.com/spf13/pflag/duration.go @@ -0,0 +1,86 @@ +package pflag + +import ( + "time" +) + +// -- time.Duration Value +type durationValue time.Duration + +func newDurationValue(val time.Duration, p *time.Duration) *durationValue { + *p = val + return (*durationValue)(p) +} + +func (d *durationValue) Set(s string) error { + v, err := time.ParseDuration(s) + *d = durationValue(v) + return err +} + +func (d *durationValue) Type() string { + return "duration" +} + +func (d *durationValue) String() string { return (*time.Duration)(d).String() } + +func durationConv(sval string) (interface{}, error) { + return time.ParseDuration(sval) +} + +// GetDuration return the duration value of a flag with the given name +func (f *FlagSet) GetDuration(name string) (time.Duration, error) { + val, err := f.getFlagType(name, "duration", durationConv) + if err != nil { + return 0, err + } + return val.(time.Duration), nil +} + +// DurationVar defines a time.Duration flag with specified name, default value, and usage string. +// The argument p points to a time.Duration variable in which to store the value of the flag. +func (f *FlagSet) DurationVar(p *time.Duration, name string, value time.Duration, usage string) { + f.VarP(newDurationValue(value, p), name, "", usage) +} + +// DurationVarP is like DurationVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) { + f.VarP(newDurationValue(value, p), name, shorthand, usage) +} + +// DurationVar defines a time.Duration flag with specified name, default value, and usage string. +// The argument p points to a time.Duration variable in which to store the value of the flag. +func DurationVar(p *time.Duration, name string, value time.Duration, usage string) { + CommandLine.VarP(newDurationValue(value, p), name, "", usage) +} + +// DurationVarP is like DurationVar, but accepts a shorthand letter that can be used after a single dash. +func DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) { + CommandLine.VarP(newDurationValue(value, p), name, shorthand, usage) +} + +// Duration defines a time.Duration flag with specified name, default value, and usage string. +// The return value is the address of a time.Duration variable that stores the value of the flag. +func (f *FlagSet) Duration(name string, value time.Duration, usage string) *time.Duration { + p := new(time.Duration) + f.DurationVarP(p, name, "", value, usage) + return p +} + +// DurationP is like Duration, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration { + p := new(time.Duration) + f.DurationVarP(p, name, shorthand, value, usage) + return p +} + +// Duration defines a time.Duration flag with specified name, default value, and usage string. +// The return value is the address of a time.Duration variable that stores the value of the flag. +func Duration(name string, value time.Duration, usage string) *time.Duration { + return CommandLine.DurationP(name, "", value, usage) +} + +// DurationP is like Duration, but accepts a shorthand letter that can be used after a single dash. +func DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration { + return CommandLine.DurationP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/flag.go b/vendor/github.com/spf13/pflag/flag.go new file mode 100644 index 00000000..eb143d79 --- /dev/null +++ b/vendor/github.com/spf13/pflag/flag.go @@ -0,0 +1,937 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package pflag is a drop-in replacement for Go's flag package, implementing +POSIX/GNU-style --flags. + +pflag is compatible with the GNU extensions to the POSIX recommendations +for command-line options. See +http://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html + +Usage: + +pflag is a drop-in replacement of Go's native flag package. If you import +pflag under the name "flag" then all code should continue to function +with no changes. + + import flag "github.com/ogier/pflag" + + There is one exception to this: if you directly instantiate the Flag struct +there is one more field "Shorthand" that you will need to set. +Most code never instantiates this struct directly, and instead uses +functions such as String(), BoolVar(), and Var(), and is therefore +unaffected. + +Define flags using flag.String(), Bool(), Int(), etc. + +This declares an integer flag, -flagname, stored in the pointer ip, with type *int. + var ip = flag.Int("flagname", 1234, "help message for flagname") +If you like, you can bind the flag to a variable using the Var() functions. + var flagvar int + func init() { + flag.IntVar(&flagvar, "flagname", 1234, "help message for flagname") + } +Or you can create custom flags that satisfy the Value interface (with +pointer receivers) and couple them to flag parsing by + flag.Var(&flagVal, "name", "help message for flagname") +For such flags, the default value is just the initial value of the variable. + +After all flags are defined, call + flag.Parse() +to parse the command line into the defined flags. + +Flags may then be used directly. If you're using the flags themselves, +they are all pointers; if you bind to variables, they're values. + fmt.Println("ip has value ", *ip) + fmt.Println("flagvar has value ", flagvar) + +After parsing, the arguments after the flag are available as the +slice flag.Args() or individually as flag.Arg(i). +The arguments are indexed from 0 through flag.NArg()-1. + +The pflag package also defines some new functions that are not in flag, +that give one-letter shorthands for flags. You can use these by appending +'P' to the name of any function that defines a flag. + var ip = flag.IntP("flagname", "f", 1234, "help message") + var flagvar bool + func init() { + flag.BoolVarP("boolname", "b", true, "help message") + } + flag.VarP(&flagVar, "varname", "v", 1234, "help message") +Shorthand letters can be used with single dashes on the command line. +Boolean shorthand flags can be combined with other shorthand flags. + +Command line flag syntax: + --flag // boolean flags only + --flag=x + +Unlike the flag package, a single dash before an option means something +different than a double dash. Single dashes signify a series of shorthand +letters for flags. All but the last shorthand letter must be boolean flags. + // boolean flags + -f + -abc + // non-boolean flags + -n 1234 + -Ifile + // mixed + -abcs "hello" + -abcn1234 + +Flag parsing stops after the terminator "--". Unlike the flag package, +flags can be interspersed with arguments anywhere on the command line +before this terminator. + +Integer flags accept 1234, 0664, 0x1234 and may be negative. +Boolean flags (in their long form) accept 1, 0, t, f, true, false, +TRUE, FALSE, True, False. +Duration flags accept any input valid for time.ParseDuration. + +The default set of command-line flags is controlled by +top-level functions. The FlagSet type allows one to define +independent sets of flags, such as to implement subcommands +in a command-line interface. The methods of FlagSet are +analogous to the top-level functions for the command-line +flag set. +*/ +package pflag + +import ( + "bytes" + "errors" + "fmt" + "io" + "os" + "sort" + "strings" +) + +// ErrHelp is the error returned if the flag -help is invoked but no such flag is defined. +var ErrHelp = errors.New("pflag: help requested") + +// ErrorHandling defines how to handle flag parsing errors. +type ErrorHandling int + +const ( + // ContinueOnError will return an err from Parse() if an error is found + ContinueOnError ErrorHandling = iota + // ExitOnError will call os.Exit(2) if an error is found when parsing + ExitOnError + // PanicOnError will panic() if an error is found when parsing flags + PanicOnError +) + +// NormalizedName is a flag name that has been normalized according to rules +// for the FlagSet (e.g. making '-' and '_' equivalent). +type NormalizedName string + +// A FlagSet represents a set of defined flags. +type FlagSet struct { + // Usage is the function called when an error occurs while parsing flags. + // The field is a function (not a method) that may be changed to point to + // a custom error handler. + Usage func() + + name string + parsed bool + actual map[NormalizedName]*Flag + formal map[NormalizedName]*Flag + shorthands map[byte]*Flag + args []string // arguments after flags + argsLenAtDash int // len(args) when a '--' was located when parsing, or -1 if no -- + exitOnError bool // does the program exit if there's an error? + errorHandling ErrorHandling + output io.Writer // nil means stderr; use out() accessor + interspersed bool // allow interspersed option/non-option args + normalizeNameFunc func(f *FlagSet, name string) NormalizedName +} + +// A Flag represents the state of a flag. +type Flag struct { + Name string // name as it appears on command line + Shorthand string // one-letter abbreviated flag + Usage string // help message + Value Value // value as set + DefValue string // default value (as text); for usage message + Changed bool // If the user set the value (or if left to default) + NoOptDefVal string //default value (as text); if the flag is on the command line without any options + Deprecated string // If this flag is deprecated, this string is the new or now thing to use + Hidden bool // used by cobra.Command to allow flags to be hidden from help/usage text + ShorthandDeprecated string // If the shorthand of this flag is deprecated, this string is the new or now thing to use + Annotations map[string][]string // used by cobra.Command bash autocomple code +} + +// Value is the interface to the dynamic value stored in a flag. +// (The default value is represented as a string.) +type Value interface { + String() string + Set(string) error + Type() string +} + +// sortFlags returns the flags as a slice in lexicographical sorted order. +func sortFlags(flags map[NormalizedName]*Flag) []*Flag { + list := make(sort.StringSlice, len(flags)) + i := 0 + for k := range flags { + list[i] = string(k) + i++ + } + list.Sort() + result := make([]*Flag, len(list)) + for i, name := range list { + result[i] = flags[NormalizedName(name)] + } + return result +} + +// SetNormalizeFunc allows you to add a function which can translate flag names. +// Flags added to the FlagSet will be translated and then when anything tries to +// look up the flag that will also be translated. So it would be possible to create +// a flag named "getURL" and have it translated to "geturl". A user could then pass +// "--getUrl" which may also be translated to "geturl" and everything will work. +func (f *FlagSet) SetNormalizeFunc(n func(f *FlagSet, name string) NormalizedName) { + f.normalizeNameFunc = n + for k, v := range f.formal { + delete(f.formal, k) + nname := f.normalizeFlagName(string(k)) + f.formal[nname] = v + v.Name = string(nname) + } +} + +// GetNormalizeFunc returns the previously set NormalizeFunc of a function which +// does no translation, if not set previously. +func (f *FlagSet) GetNormalizeFunc() func(f *FlagSet, name string) NormalizedName { + if f.normalizeNameFunc != nil { + return f.normalizeNameFunc + } + return func(f *FlagSet, name string) NormalizedName { return NormalizedName(name) } +} + +func (f *FlagSet) normalizeFlagName(name string) NormalizedName { + n := f.GetNormalizeFunc() + return n(f, name) +} + +func (f *FlagSet) out() io.Writer { + if f.output == nil { + return os.Stderr + } + return f.output +} + +// SetOutput sets the destination for usage and error messages. +// If output is nil, os.Stderr is used. +func (f *FlagSet) SetOutput(output io.Writer) { + f.output = output +} + +// VisitAll visits the flags in lexicographical order, calling fn for each. +// It visits all flags, even those not set. +func (f *FlagSet) VisitAll(fn func(*Flag)) { + for _, flag := range sortFlags(f.formal) { + fn(flag) + } +} + +// HasFlags returns a bool to indicate if the FlagSet has any flags definied. +func (f *FlagSet) HasFlags() bool { + return len(f.formal) > 0 +} + +// HasAvailableFlags returns a bool to indicate if the FlagSet has any flags +// definied that are not hidden or deprecated. +func (f *FlagSet) HasAvailableFlags() bool { + for _, flag := range f.formal { + if !flag.Hidden && len(flag.Deprecated) == 0 { + return true + } + } + return false +} + +// VisitAll visits the command-line flags in lexicographical order, calling +// fn for each. It visits all flags, even those not set. +func VisitAll(fn func(*Flag)) { + CommandLine.VisitAll(fn) +} + +// Visit visits the flags in lexicographical order, calling fn for each. +// It visits only those flags that have been set. +func (f *FlagSet) Visit(fn func(*Flag)) { + for _, flag := range sortFlags(f.actual) { + fn(flag) + } +} + +// Visit visits the command-line flags in lexicographical order, calling fn +// for each. It visits only those flags that have been set. +func Visit(fn func(*Flag)) { + CommandLine.Visit(fn) +} + +// Lookup returns the Flag structure of the named flag, returning nil if none exists. +func (f *FlagSet) Lookup(name string) *Flag { + return f.lookup(f.normalizeFlagName(name)) +} + +// lookup returns the Flag structure of the named flag, returning nil if none exists. +func (f *FlagSet) lookup(name NormalizedName) *Flag { + return f.formal[name] +} + +// func to return a given type for a given flag name +func (f *FlagSet) getFlagType(name string, ftype string, convFunc func(sval string) (interface{}, error)) (interface{}, error) { + flag := f.Lookup(name) + if flag == nil { + err := fmt.Errorf("flag accessed but not defined: %s", name) + return nil, err + } + + if flag.Value.Type() != ftype { + err := fmt.Errorf("trying to get %s value of flag of type %s", ftype, flag.Value.Type()) + return nil, err + } + + sval := flag.Value.String() + result, err := convFunc(sval) + if err != nil { + return nil, err + } + return result, nil +} + +// ArgsLenAtDash will return the length of f.Args at the moment when a -- was +// found during arg parsing. This allows your program to know which args were +// before the -- and which came after. +func (f *FlagSet) ArgsLenAtDash() int { + return f.argsLenAtDash +} + +// MarkDeprecated indicated that a flag is deprecated in your program. It will +// continue to function but will not show up in help or usage messages. Using +// this flag will also print the given usageMessage. +func (f *FlagSet) MarkDeprecated(name string, usageMessage string) error { + flag := f.Lookup(name) + if flag == nil { + return fmt.Errorf("flag %q does not exist", name) + } + if len(usageMessage) == 0 { + return fmt.Errorf("deprecated message for flag %q must be set", name) + } + flag.Deprecated = usageMessage + return nil +} + +// MarkShorthandDeprecated will mark the shorthand of a flag deprecated in your +// program. It will continue to function but will not show up in help or usage +// messages. Using this flag will also print the given usageMessage. +func (f *FlagSet) MarkShorthandDeprecated(name string, usageMessage string) error { + flag := f.Lookup(name) + if flag == nil { + return fmt.Errorf("flag %q does not exist", name) + } + if len(usageMessage) == 0 { + return fmt.Errorf("deprecated message for flag %q must be set", name) + } + flag.ShorthandDeprecated = usageMessage + return nil +} + +// MarkHidden sets a flag to 'hidden' in your program. It will continue to +// function but will not show up in help or usage messages. +func (f *FlagSet) MarkHidden(name string) error { + flag := f.Lookup(name) + if flag == nil { + return fmt.Errorf("flag %q does not exist", name) + } + flag.Hidden = true + return nil +} + +// Lookup returns the Flag structure of the named command-line flag, +// returning nil if none exists. +func Lookup(name string) *Flag { + return CommandLine.Lookup(name) +} + +// Set sets the value of the named flag. +func (f *FlagSet) Set(name, value string) error { + normalName := f.normalizeFlagName(name) + flag, ok := f.formal[normalName] + if !ok { + return fmt.Errorf("no such flag -%v", name) + } + err := flag.Value.Set(value) + if err != nil { + return err + } + if f.actual == nil { + f.actual = make(map[NormalizedName]*Flag) + } + f.actual[normalName] = flag + flag.Changed = true + if len(flag.Deprecated) > 0 { + fmt.Fprintf(os.Stderr, "Flag --%s has been deprecated, %s\n", flag.Name, flag.Deprecated) + } + return nil +} + +// SetAnnotation allows one to set arbitrary annotations on a flag in the FlagSet. +// This is sometimes used by spf13/cobra programs which want to generate additional +// bash completion information. +func (f *FlagSet) SetAnnotation(name, key string, values []string) error { + normalName := f.normalizeFlagName(name) + flag, ok := f.formal[normalName] + if !ok { + return fmt.Errorf("no such flag -%v", name) + } + if flag.Annotations == nil { + flag.Annotations = map[string][]string{} + } + flag.Annotations[key] = values + return nil +} + +// Changed returns true if the flag was explicitly set during Parse() and false +// otherwise +func (f *FlagSet) Changed(name string) bool { + flag := f.Lookup(name) + // If a flag doesn't exist, it wasn't changed.... + if flag == nil { + return false + } + return flag.Changed +} + +// Set sets the value of the named command-line flag. +func Set(name, value string) error { + return CommandLine.Set(name, value) +} + +// PrintDefaults prints, to standard error unless configured +// otherwise, the default values of all defined flags in the set. +func (f *FlagSet) PrintDefaults() { + usages := f.FlagUsages() + fmt.Fprintf(f.out(), "%s", usages) +} + +// defaultIsZeroValue returns true if the default value for this flag represents +// a zero value. +func (f *Flag) defaultIsZeroValue() bool { + switch f.Value.(type) { + case boolFlag: + return f.DefValue == "false" + case *durationValue: + // Beginning in Go 1.7, duration zero values are "0s" + return f.DefValue == "0" || f.DefValue == "0s" + case *intValue, *int8Value, *int32Value, *int64Value, *uintValue, *uint8Value, *uint16Value, *uint32Value, *uint64Value, *countValue, *float32Value, *float64Value: + return f.DefValue == "0" + case *stringValue: + return f.DefValue == "" + case *ipValue, *ipMaskValue, *ipNetValue: + return f.DefValue == "" + case *intSliceValue, *stringSliceValue: + return f.DefValue == "[]" + default: + return true + } +} + +// UnquoteUsage extracts a back-quoted name from the usage +// string for a flag and returns it and the un-quoted usage. +// Given "a `name` to show" it returns ("name", "a name to show"). +// If there are no back quotes, the name is an educated guess of the +// type of the flag's value, or the empty string if the flag is boolean. +func UnquoteUsage(flag *Flag) (name string, usage string) { + // Look for a back-quoted name, but avoid the strings package. + usage = flag.Usage + for i := 0; i < len(usage); i++ { + if usage[i] == '`' { + for j := i + 1; j < len(usage); j++ { + if usage[j] == '`' { + name = usage[i+1 : j] + usage = usage[:i] + name + usage[j+1:] + return name, usage + } + } + break // Only one back quote; use type name. + } + } + + name = flag.Value.Type() + switch name { + case "bool": + name = "" + case "float64": + name = "float" + case "int64": + name = "int" + case "uint64": + name = "uint" + } + + return +} + +// FlagUsages Returns a string containing the usage information for all flags in +// the FlagSet +func (f *FlagSet) FlagUsages() string { + x := new(bytes.Buffer) + + lines := make([]string, 0, len(f.formal)) + + maxlen := 0 + f.VisitAll(func(flag *Flag) { + if len(flag.Deprecated) > 0 || flag.Hidden { + return + } + + line := "" + if len(flag.Shorthand) > 0 && len(flag.ShorthandDeprecated) == 0 { + line = fmt.Sprintf(" -%s, --%s", flag.Shorthand, flag.Name) + } else { + line = fmt.Sprintf(" --%s", flag.Name) + } + + varname, usage := UnquoteUsage(flag) + if len(varname) > 0 { + line += " " + varname + } + if len(flag.NoOptDefVal) > 0 { + switch flag.Value.Type() { + case "string": + line += fmt.Sprintf("[=%q]", flag.NoOptDefVal) + case "bool": + if flag.NoOptDefVal != "true" { + line += fmt.Sprintf("[=%s]", flag.NoOptDefVal) + } + default: + line += fmt.Sprintf("[=%s]", flag.NoOptDefVal) + } + } + + // This special character will be replaced with spacing once the + // correct alignment is calculated + line += "\x00" + if len(line) > maxlen { + maxlen = len(line) + } + + line += usage + if !flag.defaultIsZeroValue() { + if flag.Value.Type() == "string" { + line += fmt.Sprintf(" (default %q)", flag.DefValue) + } else { + line += fmt.Sprintf(" (default %s)", flag.DefValue) + } + } + + lines = append(lines, line) + }) + + for _, line := range lines { + sidx := strings.Index(line, "\x00") + spacing := strings.Repeat(" ", maxlen-sidx) + fmt.Fprintln(x, line[:sidx], spacing, line[sidx+1:]) + } + + return x.String() +} + +// PrintDefaults prints to standard error the default values of all defined command-line flags. +func PrintDefaults() { + CommandLine.PrintDefaults() +} + +// defaultUsage is the default function to print a usage message. +func defaultUsage(f *FlagSet) { + fmt.Fprintf(f.out(), "Usage of %s:\n", f.name) + f.PrintDefaults() +} + +// NOTE: Usage is not just defaultUsage(CommandLine) +// because it serves (via godoc flag Usage) as the example +// for how to write your own usage function. + +// Usage prints to standard error a usage message documenting all defined command-line flags. +// The function is a variable that may be changed to point to a custom function. +// By default it prints a simple header and calls PrintDefaults; for details about the +// format of the output and how to control it, see the documentation for PrintDefaults. +var Usage = func() { + fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0]) + PrintDefaults() +} + +// NFlag returns the number of flags that have been set. +func (f *FlagSet) NFlag() int { return len(f.actual) } + +// NFlag returns the number of command-line flags that have been set. +func NFlag() int { return len(CommandLine.actual) } + +// Arg returns the i'th argument. Arg(0) is the first remaining argument +// after flags have been processed. +func (f *FlagSet) Arg(i int) string { + if i < 0 || i >= len(f.args) { + return "" + } + return f.args[i] +} + +// Arg returns the i'th command-line argument. Arg(0) is the first remaining argument +// after flags have been processed. +func Arg(i int) string { + return CommandLine.Arg(i) +} + +// NArg is the number of arguments remaining after flags have been processed. +func (f *FlagSet) NArg() int { return len(f.args) } + +// NArg is the number of arguments remaining after flags have been processed. +func NArg() int { return len(CommandLine.args) } + +// Args returns the non-flag arguments. +func (f *FlagSet) Args() []string { return f.args } + +// Args returns the non-flag command-line arguments. +func Args() []string { return CommandLine.args } + +// Var defines a flag with the specified name and usage string. The type and +// value of the flag are represented by the first argument, of type Value, which +// typically holds a user-defined implementation of Value. For instance, the +// caller could create a flag that turns a comma-separated string into a slice +// of strings by giving the slice the methods of Value; in particular, Set would +// decompose the comma-separated string into the slice. +func (f *FlagSet) Var(value Value, name string, usage string) { + f.VarP(value, name, "", usage) +} + +// VarPF is like VarP, but returns the flag created +func (f *FlagSet) VarPF(value Value, name, shorthand, usage string) *Flag { + // Remember the default value as a string; it won't change. + flag := &Flag{ + Name: name, + Shorthand: shorthand, + Usage: usage, + Value: value, + DefValue: value.String(), + } + f.AddFlag(flag) + return flag +} + +// VarP is like Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) VarP(value Value, name, shorthand, usage string) { + _ = f.VarPF(value, name, shorthand, usage) +} + +// AddFlag will add the flag to the FlagSet +func (f *FlagSet) AddFlag(flag *Flag) { + // Call normalizeFlagName function only once + normalizedFlagName := f.normalizeFlagName(flag.Name) + + _, alreadythere := f.formal[normalizedFlagName] + if alreadythere { + msg := fmt.Sprintf("%s flag redefined: %s", f.name, flag.Name) + fmt.Fprintln(f.out(), msg) + panic(msg) // Happens only if flags are declared with identical names + } + if f.formal == nil { + f.formal = make(map[NormalizedName]*Flag) + } + + flag.Name = string(normalizedFlagName) + f.formal[normalizedFlagName] = flag + + if len(flag.Shorthand) == 0 { + return + } + if len(flag.Shorthand) > 1 { + fmt.Fprintf(f.out(), "%s shorthand more than ASCII character: %s\n", f.name, flag.Shorthand) + panic("shorthand is more than one character") + } + if f.shorthands == nil { + f.shorthands = make(map[byte]*Flag) + } + c := flag.Shorthand[0] + old, alreadythere := f.shorthands[c] + if alreadythere { + fmt.Fprintf(f.out(), "%s shorthand reused: %q for %s already used for %s\n", f.name, c, flag.Name, old.Name) + panic("shorthand redefinition") + } + f.shorthands[c] = flag +} + +// AddFlagSet adds one FlagSet to another. If a flag is already present in f +// the flag from newSet will be ignored +func (f *FlagSet) AddFlagSet(newSet *FlagSet) { + if newSet == nil { + return + } + newSet.VisitAll(func(flag *Flag) { + if f.Lookup(flag.Name) == nil { + f.AddFlag(flag) + } + }) +} + +// Var defines a flag with the specified name and usage string. The type and +// value of the flag are represented by the first argument, of type Value, which +// typically holds a user-defined implementation of Value. For instance, the +// caller could create a flag that turns a comma-separated string into a slice +// of strings by giving the slice the methods of Value; in particular, Set would +// decompose the comma-separated string into the slice. +func Var(value Value, name string, usage string) { + CommandLine.VarP(value, name, "", usage) +} + +// VarP is like Var, but accepts a shorthand letter that can be used after a single dash. +func VarP(value Value, name, shorthand, usage string) { + CommandLine.VarP(value, name, shorthand, usage) +} + +// failf prints to standard error a formatted error and usage message and +// returns the error. +func (f *FlagSet) failf(format string, a ...interface{}) error { + err := fmt.Errorf(format, a...) + fmt.Fprintln(f.out(), err) + f.usage() + return err +} + +// usage calls the Usage method for the flag set, or the usage function if +// the flag set is CommandLine. +func (f *FlagSet) usage() { + if f == CommandLine { + Usage() + } else if f.Usage == nil { + defaultUsage(f) + } else { + f.Usage() + } +} + +func (f *FlagSet) setFlag(flag *Flag, value string, origArg string) error { + if err := flag.Value.Set(value); err != nil { + return f.failf("invalid argument %q for %s: %v", value, origArg, err) + } + // mark as visited for Visit() + if f.actual == nil { + f.actual = make(map[NormalizedName]*Flag) + } + f.actual[f.normalizeFlagName(flag.Name)] = flag + flag.Changed = true + if len(flag.Deprecated) > 0 { + fmt.Fprintf(os.Stderr, "Flag --%s has been deprecated, %s\n", flag.Name, flag.Deprecated) + } + if len(flag.ShorthandDeprecated) > 0 && containsShorthand(origArg, flag.Shorthand) { + fmt.Fprintf(os.Stderr, "Flag shorthand -%s has been deprecated, %s\n", flag.Shorthand, flag.ShorthandDeprecated) + } + return nil +} + +func containsShorthand(arg, shorthand string) bool { + // filter out flags -- + if strings.HasPrefix(arg, "-") { + return false + } + arg = strings.SplitN(arg, "=", 2)[0] + return strings.Contains(arg, shorthand) +} + +func (f *FlagSet) parseLongArg(s string, args []string) (a []string, err error) { + a = args + name := s[2:] + if len(name) == 0 || name[0] == '-' || name[0] == '=' { + err = f.failf("bad flag syntax: %s", s) + return + } + split := strings.SplitN(name, "=", 2) + name = split[0] + flag, alreadythere := f.formal[f.normalizeFlagName(name)] + if !alreadythere { + if name == "help" { // special case for nice help message. + f.usage() + return a, ErrHelp + } + err = f.failf("unknown flag: --%s", name) + return + } + var value string + if len(split) == 2 { + // '--flag=arg' + value = split[1] + } else if len(flag.NoOptDefVal) > 0 { + // '--flag' (arg was optional) + value = flag.NoOptDefVal + } else if len(a) > 0 { + // '--flag arg' + value = a[0] + a = a[1:] + } else { + // '--flag' (arg was required) + err = f.failf("flag needs an argument: %s", s) + return + } + err = f.setFlag(flag, value, s) + return +} + +func (f *FlagSet) parseSingleShortArg(shorthands string, args []string) (outShorts string, outArgs []string, err error) { + if strings.HasPrefix(shorthands, "test.") { + return + } + outArgs = args + outShorts = shorthands[1:] + c := shorthands[0] + + flag, alreadythere := f.shorthands[c] + if !alreadythere { + if c == 'h' { // special case for nice help message. + f.usage() + err = ErrHelp + return + } + //TODO continue on error + err = f.failf("unknown shorthand flag: %q in -%s", c, shorthands) + return + } + var value string + if len(shorthands) > 2 && shorthands[1] == '=' { + value = shorthands[2:] + outShorts = "" + } else if len(flag.NoOptDefVal) > 0 { + value = flag.NoOptDefVal + } else if len(shorthands) > 1 { + value = shorthands[1:] + outShorts = "" + } else if len(args) > 0 { + value = args[0] + outArgs = args[1:] + } else { + err = f.failf("flag needs an argument: %q in -%s", c, shorthands) + return + } + err = f.setFlag(flag, value, shorthands) + return +} + +func (f *FlagSet) parseShortArg(s string, args []string) (a []string, err error) { + a = args + shorthands := s[1:] + + for len(shorthands) > 0 { + shorthands, a, err = f.parseSingleShortArg(shorthands, args) + if err != nil { + return + } + } + + return +} + +func (f *FlagSet) parseArgs(args []string) (err error) { + for len(args) > 0 { + s := args[0] + args = args[1:] + if len(s) == 0 || s[0] != '-' || len(s) == 1 { + if !f.interspersed { + f.args = append(f.args, s) + f.args = append(f.args, args...) + return nil + } + f.args = append(f.args, s) + continue + } + + if s[1] == '-' { + if len(s) == 2 { // "--" terminates the flags + f.argsLenAtDash = len(f.args) + f.args = append(f.args, args...) + break + } + args, err = f.parseLongArg(s, args) + } else { + args, err = f.parseShortArg(s, args) + } + if err != nil { + return + } + } + return +} + +// Parse parses flag definitions from the argument list, which should not +// include the command name. Must be called after all flags in the FlagSet +// are defined and before flags are accessed by the program. +// The return value will be ErrHelp if -help was set but not defined. +func (f *FlagSet) Parse(arguments []string) error { + f.parsed = true + f.args = make([]string, 0, len(arguments)) + err := f.parseArgs(arguments) + if err != nil { + switch f.errorHandling { + case ContinueOnError: + return err + case ExitOnError: + os.Exit(2) + case PanicOnError: + panic(err) + } + } + return nil +} + +// Parsed reports whether f.Parse has been called. +func (f *FlagSet) Parsed() bool { + return f.parsed +} + +// Parse parses the command-line flags from os.Args[1:]. Must be called +// after all flags are defined and before flags are accessed by the program. +func Parse() { + // Ignore errors; CommandLine is set for ExitOnError. + CommandLine.Parse(os.Args[1:]) +} + +// SetInterspersed sets whether to support interspersed option/non-option arguments. +func SetInterspersed(interspersed bool) { + CommandLine.SetInterspersed(interspersed) +} + +// Parsed returns true if the command-line flags have been parsed. +func Parsed() bool { + return CommandLine.Parsed() +} + +// CommandLine is the default set of command-line flags, parsed from os.Args. +var CommandLine = NewFlagSet(os.Args[0], ExitOnError) + +// NewFlagSet returns a new, empty flag set with the specified name and +// error handling property. +func NewFlagSet(name string, errorHandling ErrorHandling) *FlagSet { + f := &FlagSet{ + name: name, + errorHandling: errorHandling, + argsLenAtDash: -1, + interspersed: true, + } + return f +} + +// SetInterspersed sets whether to support interspersed option/non-option arguments. +func (f *FlagSet) SetInterspersed(interspersed bool) { + f.interspersed = interspersed +} + +// Init sets the name and error handling property for a flag set. +// By default, the zero FlagSet uses an empty name and the +// ContinueOnError error handling policy. +func (f *FlagSet) Init(name string, errorHandling ErrorHandling) { + f.name = name + f.errorHandling = errorHandling + f.argsLenAtDash = -1 +} diff --git a/vendor/github.com/spf13/pflag/float32.go b/vendor/github.com/spf13/pflag/float32.go new file mode 100644 index 00000000..7683fae1 --- /dev/null +++ b/vendor/github.com/spf13/pflag/float32.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- float32 Value +type float32Value float32 + +func newFloat32Value(val float32, p *float32) *float32Value { + *p = val + return (*float32Value)(p) +} + +func (f *float32Value) Set(s string) error { + v, err := strconv.ParseFloat(s, 32) + *f = float32Value(v) + return err +} + +func (f *float32Value) Type() string { + return "float32" +} + +func (f *float32Value) String() string { return fmt.Sprintf("%v", *f) } + +func float32Conv(sval string) (interface{}, error) { + v, err := strconv.ParseFloat(sval, 32) + if err != nil { + return 0, err + } + return float32(v), nil +} + +// GetFloat32 return the float32 value of a flag with the given name +func (f *FlagSet) GetFloat32(name string) (float32, error) { + val, err := f.getFlagType(name, "float32", float32Conv) + if err != nil { + return 0, err + } + return val.(float32), nil +} + +// Float32Var defines a float32 flag with specified name, default value, and usage string. +// The argument p points to a float32 variable in which to store the value of the flag. +func (f *FlagSet) Float32Var(p *float32, name string, value float32, usage string) { + f.VarP(newFloat32Value(value, p), name, "", usage) +} + +// Float32VarP is like Float32Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Float32VarP(p *float32, name, shorthand string, value float32, usage string) { + f.VarP(newFloat32Value(value, p), name, shorthand, usage) +} + +// Float32Var defines a float32 flag with specified name, default value, and usage string. +// The argument p points to a float32 variable in which to store the value of the flag. +func Float32Var(p *float32, name string, value float32, usage string) { + CommandLine.VarP(newFloat32Value(value, p), name, "", usage) +} + +// Float32VarP is like Float32Var, but accepts a shorthand letter that can be used after a single dash. +func Float32VarP(p *float32, name, shorthand string, value float32, usage string) { + CommandLine.VarP(newFloat32Value(value, p), name, shorthand, usage) +} + +// Float32 defines a float32 flag with specified name, default value, and usage string. +// The return value is the address of a float32 variable that stores the value of the flag. +func (f *FlagSet) Float32(name string, value float32, usage string) *float32 { + p := new(float32) + f.Float32VarP(p, name, "", value, usage) + return p +} + +// Float32P is like Float32, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Float32P(name, shorthand string, value float32, usage string) *float32 { + p := new(float32) + f.Float32VarP(p, name, shorthand, value, usage) + return p +} + +// Float32 defines a float32 flag with specified name, default value, and usage string. +// The return value is the address of a float32 variable that stores the value of the flag. +func Float32(name string, value float32, usage string) *float32 { + return CommandLine.Float32P(name, "", value, usage) +} + +// Float32P is like Float32, but accepts a shorthand letter that can be used after a single dash. +func Float32P(name, shorthand string, value float32, usage string) *float32 { + return CommandLine.Float32P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/float64.go b/vendor/github.com/spf13/pflag/float64.go new file mode 100644 index 00000000..50fbf8cc --- /dev/null +++ b/vendor/github.com/spf13/pflag/float64.go @@ -0,0 +1,87 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- float64 Value +type float64Value float64 + +func newFloat64Value(val float64, p *float64) *float64Value { + *p = val + return (*float64Value)(p) +} + +func (f *float64Value) Set(s string) error { + v, err := strconv.ParseFloat(s, 64) + *f = float64Value(v) + return err +} + +func (f *float64Value) Type() string { + return "float64" +} + +func (f *float64Value) String() string { return fmt.Sprintf("%v", *f) } + +func float64Conv(sval string) (interface{}, error) { + return strconv.ParseFloat(sval, 64) +} + +// GetFloat64 return the float64 value of a flag with the given name +func (f *FlagSet) GetFloat64(name string) (float64, error) { + val, err := f.getFlagType(name, "float64", float64Conv) + if err != nil { + return 0, err + } + return val.(float64), nil +} + +// Float64Var defines a float64 flag with specified name, default value, and usage string. +// The argument p points to a float64 variable in which to store the value of the flag. +func (f *FlagSet) Float64Var(p *float64, name string, value float64, usage string) { + f.VarP(newFloat64Value(value, p), name, "", usage) +} + +// Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Float64VarP(p *float64, name, shorthand string, value float64, usage string) { + f.VarP(newFloat64Value(value, p), name, shorthand, usage) +} + +// Float64Var defines a float64 flag with specified name, default value, and usage string. +// The argument p points to a float64 variable in which to store the value of the flag. +func Float64Var(p *float64, name string, value float64, usage string) { + CommandLine.VarP(newFloat64Value(value, p), name, "", usage) +} + +// Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash. +func Float64VarP(p *float64, name, shorthand string, value float64, usage string) { + CommandLine.VarP(newFloat64Value(value, p), name, shorthand, usage) +} + +// Float64 defines a float64 flag with specified name, default value, and usage string. +// The return value is the address of a float64 variable that stores the value of the flag. +func (f *FlagSet) Float64(name string, value float64, usage string) *float64 { + p := new(float64) + f.Float64VarP(p, name, "", value, usage) + return p +} + +// Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Float64P(name, shorthand string, value float64, usage string) *float64 { + p := new(float64) + f.Float64VarP(p, name, shorthand, value, usage) + return p +} + +// Float64 defines a float64 flag with specified name, default value, and usage string. +// The return value is the address of a float64 variable that stores the value of the flag. +func Float64(name string, value float64, usage string) *float64 { + return CommandLine.Float64P(name, "", value, usage) +} + +// Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash. +func Float64P(name, shorthand string, value float64, usage string) *float64 { + return CommandLine.Float64P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/golangflag.go b/vendor/github.com/spf13/pflag/golangflag.go new file mode 100644 index 00000000..b056147f --- /dev/null +++ b/vendor/github.com/spf13/pflag/golangflag.go @@ -0,0 +1,104 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package pflag + +import ( + goflag "flag" + "fmt" + "reflect" + "strings" +) + +var _ = fmt.Print + +// flagValueWrapper implements pflag.Value around a flag.Value. The main +// difference here is the addition of the Type method that returns a string +// name of the type. As this is generally unknown, we approximate that with +// reflection. +type flagValueWrapper struct { + inner goflag.Value + flagType string +} + +// We are just copying the boolFlag interface out of goflag as that is what +// they use to decide if a flag should get "true" when no arg is given. +type goBoolFlag interface { + goflag.Value + IsBoolFlag() bool +} + +func wrapFlagValue(v goflag.Value) Value { + // If the flag.Value happens to also be a pflag.Value, just use it directly. + if pv, ok := v.(Value); ok { + return pv + } + + pv := &flagValueWrapper{ + inner: v, + } + + t := reflect.TypeOf(v) + if t.Kind() == reflect.Interface || t.Kind() == reflect.Ptr { + t = t.Elem() + } + + pv.flagType = strings.TrimSuffix(t.Name(), "Value") + return pv +} + +func (v *flagValueWrapper) String() string { + return v.inner.String() +} + +func (v *flagValueWrapper) Set(s string) error { + return v.inner.Set(s) +} + +func (v *flagValueWrapper) Type() string { + return v.flagType +} + +// PFlagFromGoFlag will return a *pflag.Flag given a *flag.Flag +// If the *flag.Flag.Name was a single character (ex: `v`) it will be accessiblei +// with both `-v` and `--v` in flags. If the golang flag was more than a single +// character (ex: `verbose`) it will only be accessible via `--verbose` +func PFlagFromGoFlag(goflag *goflag.Flag) *Flag { + // Remember the default value as a string; it won't change. + flag := &Flag{ + Name: goflag.Name, + Usage: goflag.Usage, + Value: wrapFlagValue(goflag.Value), + // Looks like golang flags don't set DefValue correctly :-( + //DefValue: goflag.DefValue, + DefValue: goflag.Value.String(), + } + // Ex: if the golang flag was -v, allow both -v and --v to work + if len(flag.Name) == 1 { + flag.Shorthand = flag.Name + } + if fv, ok := goflag.Value.(goBoolFlag); ok && fv.IsBoolFlag() { + flag.NoOptDefVal = "true" + } + return flag +} + +// AddGoFlag will add the given *flag.Flag to the pflag.FlagSet +func (f *FlagSet) AddGoFlag(goflag *goflag.Flag) { + if f.Lookup(goflag.Name) != nil { + return + } + newflag := PFlagFromGoFlag(goflag) + f.AddFlag(newflag) +} + +// AddGoFlagSet will add the given *flag.FlagSet to the pflag.FlagSet +func (f *FlagSet) AddGoFlagSet(newSet *goflag.FlagSet) { + if newSet == nil { + return + } + newSet.VisitAll(func(goflag *goflag.Flag) { + f.AddGoFlag(goflag) + }) +} diff --git a/vendor/github.com/spf13/pflag/int.go b/vendor/github.com/spf13/pflag/int.go new file mode 100644 index 00000000..b6560368 --- /dev/null +++ b/vendor/github.com/spf13/pflag/int.go @@ -0,0 +1,87 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- int Value +type intValue int + +func newIntValue(val int, p *int) *intValue { + *p = val + return (*intValue)(p) +} + +func (i *intValue) Set(s string) error { + v, err := strconv.ParseInt(s, 0, 64) + *i = intValue(v) + return err +} + +func (i *intValue) Type() string { + return "int" +} + +func (i *intValue) String() string { return fmt.Sprintf("%v", *i) } + +func intConv(sval string) (interface{}, error) { + return strconv.Atoi(sval) +} + +// GetInt return the int value of a flag with the given name +func (f *FlagSet) GetInt(name string) (int, error) { + val, err := f.getFlagType(name, "int", intConv) + if err != nil { + return 0, err + } + return val.(int), nil +} + +// IntVar defines an int flag with specified name, default value, and usage string. +// The argument p points to an int variable in which to store the value of the flag. +func (f *FlagSet) IntVar(p *int, name string, value int, usage string) { + f.VarP(newIntValue(value, p), name, "", usage) +} + +// IntVarP is like IntVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IntVarP(p *int, name, shorthand string, value int, usage string) { + f.VarP(newIntValue(value, p), name, shorthand, usage) +} + +// IntVar defines an int flag with specified name, default value, and usage string. +// The argument p points to an int variable in which to store the value of the flag. +func IntVar(p *int, name string, value int, usage string) { + CommandLine.VarP(newIntValue(value, p), name, "", usage) +} + +// IntVarP is like IntVar, but accepts a shorthand letter that can be used after a single dash. +func IntVarP(p *int, name, shorthand string, value int, usage string) { + CommandLine.VarP(newIntValue(value, p), name, shorthand, usage) +} + +// Int defines an int flag with specified name, default value, and usage string. +// The return value is the address of an int variable that stores the value of the flag. +func (f *FlagSet) Int(name string, value int, usage string) *int { + p := new(int) + f.IntVarP(p, name, "", value, usage) + return p +} + +// IntP is like Int, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IntP(name, shorthand string, value int, usage string) *int { + p := new(int) + f.IntVarP(p, name, shorthand, value, usage) + return p +} + +// Int defines an int flag with specified name, default value, and usage string. +// The return value is the address of an int variable that stores the value of the flag. +func Int(name string, value int, usage string) *int { + return CommandLine.IntP(name, "", value, usage) +} + +// IntP is like Int, but accepts a shorthand letter that can be used after a single dash. +func IntP(name, shorthand string, value int, usage string) *int { + return CommandLine.IntP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/int32.go b/vendor/github.com/spf13/pflag/int32.go new file mode 100644 index 00000000..41659a9a --- /dev/null +++ b/vendor/github.com/spf13/pflag/int32.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- int32 Value +type int32Value int32 + +func newInt32Value(val int32, p *int32) *int32Value { + *p = val + return (*int32Value)(p) +} + +func (i *int32Value) Set(s string) error { + v, err := strconv.ParseInt(s, 0, 32) + *i = int32Value(v) + return err +} + +func (i *int32Value) Type() string { + return "int32" +} + +func (i *int32Value) String() string { return fmt.Sprintf("%v", *i) } + +func int32Conv(sval string) (interface{}, error) { + v, err := strconv.ParseInt(sval, 0, 32) + if err != nil { + return 0, err + } + return int32(v), nil +} + +// GetInt32 return the int32 value of a flag with the given name +func (f *FlagSet) GetInt32(name string) (int32, error) { + val, err := f.getFlagType(name, "int32", int32Conv) + if err != nil { + return 0, err + } + return val.(int32), nil +} + +// Int32Var defines an int32 flag with specified name, default value, and usage string. +// The argument p points to an int32 variable in which to store the value of the flag. +func (f *FlagSet) Int32Var(p *int32, name string, value int32, usage string) { + f.VarP(newInt32Value(value, p), name, "", usage) +} + +// Int32VarP is like Int32Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int32VarP(p *int32, name, shorthand string, value int32, usage string) { + f.VarP(newInt32Value(value, p), name, shorthand, usage) +} + +// Int32Var defines an int32 flag with specified name, default value, and usage string. +// The argument p points to an int32 variable in which to store the value of the flag. +func Int32Var(p *int32, name string, value int32, usage string) { + CommandLine.VarP(newInt32Value(value, p), name, "", usage) +} + +// Int32VarP is like Int32Var, but accepts a shorthand letter that can be used after a single dash. +func Int32VarP(p *int32, name, shorthand string, value int32, usage string) { + CommandLine.VarP(newInt32Value(value, p), name, shorthand, usage) +} + +// Int32 defines an int32 flag with specified name, default value, and usage string. +// The return value is the address of an int32 variable that stores the value of the flag. +func (f *FlagSet) Int32(name string, value int32, usage string) *int32 { + p := new(int32) + f.Int32VarP(p, name, "", value, usage) + return p +} + +// Int32P is like Int32, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int32P(name, shorthand string, value int32, usage string) *int32 { + p := new(int32) + f.Int32VarP(p, name, shorthand, value, usage) + return p +} + +// Int32 defines an int32 flag with specified name, default value, and usage string. +// The return value is the address of an int32 variable that stores the value of the flag. +func Int32(name string, value int32, usage string) *int32 { + return CommandLine.Int32P(name, "", value, usage) +} + +// Int32P is like Int32, but accepts a shorthand letter that can be used after a single dash. +func Int32P(name, shorthand string, value int32, usage string) *int32 { + return CommandLine.Int32P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/int64.go b/vendor/github.com/spf13/pflag/int64.go new file mode 100644 index 00000000..6e67e380 --- /dev/null +++ b/vendor/github.com/spf13/pflag/int64.go @@ -0,0 +1,87 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- int64 Value +type int64Value int64 + +func newInt64Value(val int64, p *int64) *int64Value { + *p = val + return (*int64Value)(p) +} + +func (i *int64Value) Set(s string) error { + v, err := strconv.ParseInt(s, 0, 64) + *i = int64Value(v) + return err +} + +func (i *int64Value) Type() string { + return "int64" +} + +func (i *int64Value) String() string { return fmt.Sprintf("%v", *i) } + +func int64Conv(sval string) (interface{}, error) { + return strconv.ParseInt(sval, 0, 64) +} + +// GetInt64 return the int64 value of a flag with the given name +func (f *FlagSet) GetInt64(name string) (int64, error) { + val, err := f.getFlagType(name, "int64", int64Conv) + if err != nil { + return 0, err + } + return val.(int64), nil +} + +// Int64Var defines an int64 flag with specified name, default value, and usage string. +// The argument p points to an int64 variable in which to store the value of the flag. +func (f *FlagSet) Int64Var(p *int64, name string, value int64, usage string) { + f.VarP(newInt64Value(value, p), name, "", usage) +} + +// Int64VarP is like Int64Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int64VarP(p *int64, name, shorthand string, value int64, usage string) { + f.VarP(newInt64Value(value, p), name, shorthand, usage) +} + +// Int64Var defines an int64 flag with specified name, default value, and usage string. +// The argument p points to an int64 variable in which to store the value of the flag. +func Int64Var(p *int64, name string, value int64, usage string) { + CommandLine.VarP(newInt64Value(value, p), name, "", usage) +} + +// Int64VarP is like Int64Var, but accepts a shorthand letter that can be used after a single dash. +func Int64VarP(p *int64, name, shorthand string, value int64, usage string) { + CommandLine.VarP(newInt64Value(value, p), name, shorthand, usage) +} + +// Int64 defines an int64 flag with specified name, default value, and usage string. +// The return value is the address of an int64 variable that stores the value of the flag. +func (f *FlagSet) Int64(name string, value int64, usage string) *int64 { + p := new(int64) + f.Int64VarP(p, name, "", value, usage) + return p +} + +// Int64P is like Int64, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int64P(name, shorthand string, value int64, usage string) *int64 { + p := new(int64) + f.Int64VarP(p, name, shorthand, value, usage) + return p +} + +// Int64 defines an int64 flag with specified name, default value, and usage string. +// The return value is the address of an int64 variable that stores the value of the flag. +func Int64(name string, value int64, usage string) *int64 { + return CommandLine.Int64P(name, "", value, usage) +} + +// Int64P is like Int64, but accepts a shorthand letter that can be used after a single dash. +func Int64P(name, shorthand string, value int64, usage string) *int64 { + return CommandLine.Int64P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/int8.go b/vendor/github.com/spf13/pflag/int8.go new file mode 100644 index 00000000..400db21f --- /dev/null +++ b/vendor/github.com/spf13/pflag/int8.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- int8 Value +type int8Value int8 + +func newInt8Value(val int8, p *int8) *int8Value { + *p = val + return (*int8Value)(p) +} + +func (i *int8Value) Set(s string) error { + v, err := strconv.ParseInt(s, 0, 8) + *i = int8Value(v) + return err +} + +func (i *int8Value) Type() string { + return "int8" +} + +func (i *int8Value) String() string { return fmt.Sprintf("%v", *i) } + +func int8Conv(sval string) (interface{}, error) { + v, err := strconv.ParseInt(sval, 0, 8) + if err != nil { + return 0, err + } + return int8(v), nil +} + +// GetInt8 return the int8 value of a flag with the given name +func (f *FlagSet) GetInt8(name string) (int8, error) { + val, err := f.getFlagType(name, "int8", int8Conv) + if err != nil { + return 0, err + } + return val.(int8), nil +} + +// Int8Var defines an int8 flag with specified name, default value, and usage string. +// The argument p points to an int8 variable in which to store the value of the flag. +func (f *FlagSet) Int8Var(p *int8, name string, value int8, usage string) { + f.VarP(newInt8Value(value, p), name, "", usage) +} + +// Int8VarP is like Int8Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int8VarP(p *int8, name, shorthand string, value int8, usage string) { + f.VarP(newInt8Value(value, p), name, shorthand, usage) +} + +// Int8Var defines an int8 flag with specified name, default value, and usage string. +// The argument p points to an int8 variable in which to store the value of the flag. +func Int8Var(p *int8, name string, value int8, usage string) { + CommandLine.VarP(newInt8Value(value, p), name, "", usage) +} + +// Int8VarP is like Int8Var, but accepts a shorthand letter that can be used after a single dash. +func Int8VarP(p *int8, name, shorthand string, value int8, usage string) { + CommandLine.VarP(newInt8Value(value, p), name, shorthand, usage) +} + +// Int8 defines an int8 flag with specified name, default value, and usage string. +// The return value is the address of an int8 variable that stores the value of the flag. +func (f *FlagSet) Int8(name string, value int8, usage string) *int8 { + p := new(int8) + f.Int8VarP(p, name, "", value, usage) + return p +} + +// Int8P is like Int8, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int8P(name, shorthand string, value int8, usage string) *int8 { + p := new(int8) + f.Int8VarP(p, name, shorthand, value, usage) + return p +} + +// Int8 defines an int8 flag with specified name, default value, and usage string. +// The return value is the address of an int8 variable that stores the value of the flag. +func Int8(name string, value int8, usage string) *int8 { + return CommandLine.Int8P(name, "", value, usage) +} + +// Int8P is like Int8, but accepts a shorthand letter that can be used after a single dash. +func Int8P(name, shorthand string, value int8, usage string) *int8 { + return CommandLine.Int8P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/int_slice.go b/vendor/github.com/spf13/pflag/int_slice.go new file mode 100644 index 00000000..1e7c9edd --- /dev/null +++ b/vendor/github.com/spf13/pflag/int_slice.go @@ -0,0 +1,128 @@ +package pflag + +import ( + "fmt" + "strconv" + "strings" +) + +// -- intSlice Value +type intSliceValue struct { + value *[]int + changed bool +} + +func newIntSliceValue(val []int, p *[]int) *intSliceValue { + isv := new(intSliceValue) + isv.value = p + *isv.value = val + return isv +} + +func (s *intSliceValue) Set(val string) error { + ss := strings.Split(val, ",") + out := make([]int, len(ss)) + for i, d := range ss { + var err error + out[i], err = strconv.Atoi(d) + if err != nil { + return err + } + + } + if !s.changed { + *s.value = out + } else { + *s.value = append(*s.value, out...) + } + s.changed = true + return nil +} + +func (s *intSliceValue) Type() string { + return "intSlice" +} + +func (s *intSliceValue) String() string { + out := make([]string, len(*s.value)) + for i, d := range *s.value { + out[i] = fmt.Sprintf("%d", d) + } + return "[" + strings.Join(out, ",") + "]" +} + +func intSliceConv(val string) (interface{}, error) { + val = strings.Trim(val, "[]") + // Empty string would cause a slice with one (empty) entry + if len(val) == 0 { + return []int{}, nil + } + ss := strings.Split(val, ",") + out := make([]int, len(ss)) + for i, d := range ss { + var err error + out[i], err = strconv.Atoi(d) + if err != nil { + return nil, err + } + + } + return out, nil +} + +// GetIntSlice return the []int value of a flag with the given name +func (f *FlagSet) GetIntSlice(name string) ([]int, error) { + val, err := f.getFlagType(name, "intSlice", intSliceConv) + if err != nil { + return []int{}, err + } + return val.([]int), nil +} + +// IntSliceVar defines a intSlice flag with specified name, default value, and usage string. +// The argument p points to a []int variable in which to store the value of the flag. +func (f *FlagSet) IntSliceVar(p *[]int, name string, value []int, usage string) { + f.VarP(newIntSliceValue(value, p), name, "", usage) +} + +// IntSliceVarP is like IntSliceVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IntSliceVarP(p *[]int, name, shorthand string, value []int, usage string) { + f.VarP(newIntSliceValue(value, p), name, shorthand, usage) +} + +// IntSliceVar defines a int[] flag with specified name, default value, and usage string. +// The argument p points to a int[] variable in which to store the value of the flag. +func IntSliceVar(p *[]int, name string, value []int, usage string) { + CommandLine.VarP(newIntSliceValue(value, p), name, "", usage) +} + +// IntSliceVarP is like IntSliceVar, but accepts a shorthand letter that can be used after a single dash. +func IntSliceVarP(p *[]int, name, shorthand string, value []int, usage string) { + CommandLine.VarP(newIntSliceValue(value, p), name, shorthand, usage) +} + +// IntSlice defines a []int flag with specified name, default value, and usage string. +// The return value is the address of a []int variable that stores the value of the flag. +func (f *FlagSet) IntSlice(name string, value []int, usage string) *[]int { + p := []int{} + f.IntSliceVarP(&p, name, "", value, usage) + return &p +} + +// IntSliceP is like IntSlice, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IntSliceP(name, shorthand string, value []int, usage string) *[]int { + p := []int{} + f.IntSliceVarP(&p, name, shorthand, value, usage) + return &p +} + +// IntSlice defines a []int flag with specified name, default value, and usage string. +// The return value is the address of a []int variable that stores the value of the flag. +func IntSlice(name string, value []int, usage string) *[]int { + return CommandLine.IntSliceP(name, "", value, usage) +} + +// IntSliceP is like IntSlice, but accepts a shorthand letter that can be used after a single dash. +func IntSliceP(name, shorthand string, value []int, usage string) *[]int { + return CommandLine.IntSliceP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/ip.go b/vendor/github.com/spf13/pflag/ip.go new file mode 100644 index 00000000..88a17430 --- /dev/null +++ b/vendor/github.com/spf13/pflag/ip.go @@ -0,0 +1,96 @@ +package pflag + +import ( + "fmt" + "net" + "strings" +) + +var _ = strings.TrimSpace + +// -- net.IP value +type ipValue net.IP + +func newIPValue(val net.IP, p *net.IP) *ipValue { + *p = val + return (*ipValue)(p) +} + +func (i *ipValue) String() string { return net.IP(*i).String() } +func (i *ipValue) Set(s string) error { + ip := net.ParseIP(strings.TrimSpace(s)) + if ip == nil { + return fmt.Errorf("failed to parse IP: %q", s) + } + *i = ipValue(ip) + return nil +} + +func (i *ipValue) Type() string { + return "ip" +} + +func ipConv(sval string) (interface{}, error) { + ip := net.ParseIP(sval) + if ip != nil { + return ip, nil + } + return nil, fmt.Errorf("invalid string being converted to IP address: %s", sval) +} + +// GetIP return the net.IP value of a flag with the given name +func (f *FlagSet) GetIP(name string) (net.IP, error) { + val, err := f.getFlagType(name, "ip", ipConv) + if err != nil { + return nil, err + } + return val.(net.IP), nil +} + +// IPVar defines an net.IP flag with specified name, default value, and usage string. +// The argument p points to an net.IP variable in which to store the value of the flag. +func (f *FlagSet) IPVar(p *net.IP, name string, value net.IP, usage string) { + f.VarP(newIPValue(value, p), name, "", usage) +} + +// IPVarP is like IPVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) { + f.VarP(newIPValue(value, p), name, shorthand, usage) +} + +// IPVar defines an net.IP flag with specified name, default value, and usage string. +// The argument p points to an net.IP variable in which to store the value of the flag. +func IPVar(p *net.IP, name string, value net.IP, usage string) { + CommandLine.VarP(newIPValue(value, p), name, "", usage) +} + +// IPVarP is like IPVar, but accepts a shorthand letter that can be used after a single dash. +func IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) { + CommandLine.VarP(newIPValue(value, p), name, shorthand, usage) +} + +// IP defines an net.IP flag with specified name, default value, and usage string. +// The return value is the address of an net.IP variable that stores the value of the flag. +func (f *FlagSet) IP(name string, value net.IP, usage string) *net.IP { + p := new(net.IP) + f.IPVarP(p, name, "", value, usage) + return p +} + +// IPP is like IP, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPP(name, shorthand string, value net.IP, usage string) *net.IP { + p := new(net.IP) + f.IPVarP(p, name, shorthand, value, usage) + return p +} + +// IP defines an net.IP flag with specified name, default value, and usage string. +// The return value is the address of an net.IP variable that stores the value of the flag. +func IP(name string, value net.IP, usage string) *net.IP { + return CommandLine.IPP(name, "", value, usage) +} + +// IPP is like IP, but accepts a shorthand letter that can be used after a single dash. +func IPP(name, shorthand string, value net.IP, usage string) *net.IP { + return CommandLine.IPP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/ipmask.go b/vendor/github.com/spf13/pflag/ipmask.go new file mode 100644 index 00000000..5bd44bd2 --- /dev/null +++ b/vendor/github.com/spf13/pflag/ipmask.go @@ -0,0 +1,122 @@ +package pflag + +import ( + "fmt" + "net" + "strconv" +) + +// -- net.IPMask value +type ipMaskValue net.IPMask + +func newIPMaskValue(val net.IPMask, p *net.IPMask) *ipMaskValue { + *p = val + return (*ipMaskValue)(p) +} + +func (i *ipMaskValue) String() string { return net.IPMask(*i).String() } +func (i *ipMaskValue) Set(s string) error { + ip := ParseIPv4Mask(s) + if ip == nil { + return fmt.Errorf("failed to parse IP mask: %q", s) + } + *i = ipMaskValue(ip) + return nil +} + +func (i *ipMaskValue) Type() string { + return "ipMask" +} + +// ParseIPv4Mask written in IP form (e.g. 255.255.255.0). +// This function should really belong to the net package. +func ParseIPv4Mask(s string) net.IPMask { + mask := net.ParseIP(s) + if mask == nil { + if len(s) != 8 { + return nil + } + // net.IPMask.String() actually outputs things like ffffff00 + // so write a horrible parser for that as well :-( + m := []int{} + for i := 0; i < 4; i++ { + b := "0x" + s[2*i:2*i+2] + d, err := strconv.ParseInt(b, 0, 0) + if err != nil { + return nil + } + m = append(m, int(d)) + } + s := fmt.Sprintf("%d.%d.%d.%d", m[0], m[1], m[2], m[3]) + mask = net.ParseIP(s) + if mask == nil { + return nil + } + } + return net.IPv4Mask(mask[12], mask[13], mask[14], mask[15]) +} + +func parseIPv4Mask(sval string) (interface{}, error) { + mask := ParseIPv4Mask(sval) + if mask == nil { + return nil, fmt.Errorf("unable to parse %s as net.IPMask", sval) + } + return mask, nil +} + +// GetIPv4Mask return the net.IPv4Mask value of a flag with the given name +func (f *FlagSet) GetIPv4Mask(name string) (net.IPMask, error) { + val, err := f.getFlagType(name, "ipMask", parseIPv4Mask) + if err != nil { + return nil, err + } + return val.(net.IPMask), nil +} + +// IPMaskVar defines an net.IPMask flag with specified name, default value, and usage string. +// The argument p points to an net.IPMask variable in which to store the value of the flag. +func (f *FlagSet) IPMaskVar(p *net.IPMask, name string, value net.IPMask, usage string) { + f.VarP(newIPMaskValue(value, p), name, "", usage) +} + +// IPMaskVarP is like IPMaskVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) { + f.VarP(newIPMaskValue(value, p), name, shorthand, usage) +} + +// IPMaskVar defines an net.IPMask flag with specified name, default value, and usage string. +// The argument p points to an net.IPMask variable in which to store the value of the flag. +func IPMaskVar(p *net.IPMask, name string, value net.IPMask, usage string) { + CommandLine.VarP(newIPMaskValue(value, p), name, "", usage) +} + +// IPMaskVarP is like IPMaskVar, but accepts a shorthand letter that can be used after a single dash. +func IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) { + CommandLine.VarP(newIPMaskValue(value, p), name, shorthand, usage) +} + +// IPMask defines an net.IPMask flag with specified name, default value, and usage string. +// The return value is the address of an net.IPMask variable that stores the value of the flag. +func (f *FlagSet) IPMask(name string, value net.IPMask, usage string) *net.IPMask { + p := new(net.IPMask) + f.IPMaskVarP(p, name, "", value, usage) + return p +} + +// IPMaskP is like IPMask, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask { + p := new(net.IPMask) + f.IPMaskVarP(p, name, shorthand, value, usage) + return p +} + +// IPMask defines an net.IPMask flag with specified name, default value, and usage string. +// The return value is the address of an net.IPMask variable that stores the value of the flag. +func IPMask(name string, value net.IPMask, usage string) *net.IPMask { + return CommandLine.IPMaskP(name, "", value, usage) +} + +// IPMaskP is like IP, but accepts a shorthand letter that can be used after a single dash. +func IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask { + return CommandLine.IPMaskP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/ipnet.go b/vendor/github.com/spf13/pflag/ipnet.go new file mode 100644 index 00000000..149b764b --- /dev/null +++ b/vendor/github.com/spf13/pflag/ipnet.go @@ -0,0 +1,100 @@ +package pflag + +import ( + "fmt" + "net" + "strings" +) + +// IPNet adapts net.IPNet for use as a flag. +type ipNetValue net.IPNet + +func (ipnet ipNetValue) String() string { + n := net.IPNet(ipnet) + return n.String() +} + +func (ipnet *ipNetValue) Set(value string) error { + _, n, err := net.ParseCIDR(strings.TrimSpace(value)) + if err != nil { + return err + } + *ipnet = ipNetValue(*n) + return nil +} + +func (*ipNetValue) Type() string { + return "ipNet" +} + +var _ = strings.TrimSpace + +func newIPNetValue(val net.IPNet, p *net.IPNet) *ipNetValue { + *p = val + return (*ipNetValue)(p) +} + +func ipNetConv(sval string) (interface{}, error) { + _, n, err := net.ParseCIDR(strings.TrimSpace(sval)) + if err == nil { + return *n, nil + } + return nil, fmt.Errorf("invalid string being converted to IPNet: %s", sval) +} + +// GetIPNet return the net.IPNet value of a flag with the given name +func (f *FlagSet) GetIPNet(name string) (net.IPNet, error) { + val, err := f.getFlagType(name, "ipNet", ipNetConv) + if err != nil { + return net.IPNet{}, err + } + return val.(net.IPNet), nil +} + +// IPNetVar defines an net.IPNet flag with specified name, default value, and usage string. +// The argument p points to an net.IPNet variable in which to store the value of the flag. +func (f *FlagSet) IPNetVar(p *net.IPNet, name string, value net.IPNet, usage string) { + f.VarP(newIPNetValue(value, p), name, "", usage) +} + +// IPNetVarP is like IPNetVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPNetVarP(p *net.IPNet, name, shorthand string, value net.IPNet, usage string) { + f.VarP(newIPNetValue(value, p), name, shorthand, usage) +} + +// IPNetVar defines an net.IPNet flag with specified name, default value, and usage string. +// The argument p points to an net.IPNet variable in which to store the value of the flag. +func IPNetVar(p *net.IPNet, name string, value net.IPNet, usage string) { + CommandLine.VarP(newIPNetValue(value, p), name, "", usage) +} + +// IPNetVarP is like IPNetVar, but accepts a shorthand letter that can be used after a single dash. +func IPNetVarP(p *net.IPNet, name, shorthand string, value net.IPNet, usage string) { + CommandLine.VarP(newIPNetValue(value, p), name, shorthand, usage) +} + +// IPNet defines an net.IPNet flag with specified name, default value, and usage string. +// The return value is the address of an net.IPNet variable that stores the value of the flag. +func (f *FlagSet) IPNet(name string, value net.IPNet, usage string) *net.IPNet { + p := new(net.IPNet) + f.IPNetVarP(p, name, "", value, usage) + return p +} + +// IPNetP is like IPNet, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPNetP(name, shorthand string, value net.IPNet, usage string) *net.IPNet { + p := new(net.IPNet) + f.IPNetVarP(p, name, shorthand, value, usage) + return p +} + +// IPNet defines an net.IPNet flag with specified name, default value, and usage string. +// The return value is the address of an net.IPNet variable that stores the value of the flag. +func IPNet(name string, value net.IPNet, usage string) *net.IPNet { + return CommandLine.IPNetP(name, "", value, usage) +} + +// IPNetP is like IPNet, but accepts a shorthand letter that can be used after a single dash. +func IPNetP(name, shorthand string, value net.IPNet, usage string) *net.IPNet { + return CommandLine.IPNetP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/string.go b/vendor/github.com/spf13/pflag/string.go new file mode 100644 index 00000000..e296136e --- /dev/null +++ b/vendor/github.com/spf13/pflag/string.go @@ -0,0 +1,82 @@ +package pflag + +import "fmt" + +// -- string Value +type stringValue string + +func newStringValue(val string, p *string) *stringValue { + *p = val + return (*stringValue)(p) +} + +func (s *stringValue) Set(val string) error { + *s = stringValue(val) + return nil +} +func (s *stringValue) Type() string { + return "string" +} + +func (s *stringValue) String() string { return fmt.Sprintf("%s", *s) } + +func stringConv(sval string) (interface{}, error) { + return sval, nil +} + +// GetString return the string value of a flag with the given name +func (f *FlagSet) GetString(name string) (string, error) { + val, err := f.getFlagType(name, "string", stringConv) + if err != nil { + return "", err + } + return val.(string), nil +} + +// StringVar defines a string flag with specified name, default value, and usage string. +// The argument p points to a string variable in which to store the value of the flag. +func (f *FlagSet) StringVar(p *string, name string, value string, usage string) { + f.VarP(newStringValue(value, p), name, "", usage) +} + +// StringVarP is like StringVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) StringVarP(p *string, name, shorthand string, value string, usage string) { + f.VarP(newStringValue(value, p), name, shorthand, usage) +} + +// StringVar defines a string flag with specified name, default value, and usage string. +// The argument p points to a string variable in which to store the value of the flag. +func StringVar(p *string, name string, value string, usage string) { + CommandLine.VarP(newStringValue(value, p), name, "", usage) +} + +// StringVarP is like StringVar, but accepts a shorthand letter that can be used after a single dash. +func StringVarP(p *string, name, shorthand string, value string, usage string) { + CommandLine.VarP(newStringValue(value, p), name, shorthand, usage) +} + +// String defines a string flag with specified name, default value, and usage string. +// The return value is the address of a string variable that stores the value of the flag. +func (f *FlagSet) String(name string, value string, usage string) *string { + p := new(string) + f.StringVarP(p, name, "", value, usage) + return p +} + +// StringP is like String, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) StringP(name, shorthand string, value string, usage string) *string { + p := new(string) + f.StringVarP(p, name, shorthand, value, usage) + return p +} + +// String defines a string flag with specified name, default value, and usage string. +// The return value is the address of a string variable that stores the value of the flag. +func String(name string, value string, usage string) *string { + return CommandLine.StringP(name, "", value, usage) +} + +// StringP is like String, but accepts a shorthand letter that can be used after a single dash. +func StringP(name, shorthand string, value string, usage string) *string { + return CommandLine.StringP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/string_slice.go b/vendor/github.com/spf13/pflag/string_slice.go new file mode 100644 index 00000000..927a4408 --- /dev/null +++ b/vendor/github.com/spf13/pflag/string_slice.go @@ -0,0 +1,124 @@ +package pflag + +import ( + "bytes" + "encoding/csv" + "fmt" + "strings" +) + +var _ = fmt.Fprint + +// -- stringSlice Value +type stringSliceValue struct { + value *[]string + changed bool +} + +func newStringSliceValue(val []string, p *[]string) *stringSliceValue { + ssv := new(stringSliceValue) + ssv.value = p + *ssv.value = val + return ssv +} + +func readAsCSV(val string) ([]string, error) { + if val == "" { + return []string{}, nil + } + stringReader := strings.NewReader(val) + csvReader := csv.NewReader(stringReader) + return csvReader.Read() +} + +func (s *stringSliceValue) Set(val string) error { + v, err := readAsCSV(val) + if err != nil { + return err + } + if !s.changed { + *s.value = v + } else { + *s.value = append(*s.value, v...) + } + s.changed = true + return nil +} + +func (s *stringSliceValue) Type() string { + return "stringSlice" +} + +func (s *stringSliceValue) String() string { + b := &bytes.Buffer{} + w := csv.NewWriter(b) + w.Write(*s.value) + w.Flush() + return "[" + strings.TrimSuffix(b.String(), fmt.Sprintln()) + "]" +} + +func stringSliceConv(sval string) (interface{}, error) { + sval = strings.Trim(sval, "[]") + // An empty string would cause a slice with one (empty) string + if len(sval) == 0 { + return []string{}, nil + } + return readAsCSV(sval) +} + +// GetStringSlice return the []string value of a flag with the given name +func (f *FlagSet) GetStringSlice(name string) ([]string, error) { + val, err := f.getFlagType(name, "stringSlice", stringSliceConv) + if err != nil { + return []string{}, err + } + return val.([]string), nil +} + +// StringSliceVar defines a string flag with specified name, default value, and usage string. +// The argument p points to a []string variable in which to store the value of the flag. +func (f *FlagSet) StringSliceVar(p *[]string, name string, value []string, usage string) { + f.VarP(newStringSliceValue(value, p), name, "", usage) +} + +// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) { + f.VarP(newStringSliceValue(value, p), name, shorthand, usage) +} + +// StringSliceVar defines a string flag with specified name, default value, and usage string. +// The argument p points to a []string variable in which to store the value of the flag. +func StringSliceVar(p *[]string, name string, value []string, usage string) { + CommandLine.VarP(newStringSliceValue(value, p), name, "", usage) +} + +// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash. +func StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) { + CommandLine.VarP(newStringSliceValue(value, p), name, shorthand, usage) +} + +// StringSlice defines a string flag with specified name, default value, and usage string. +// The return value is the address of a []string variable that stores the value of the flag. +func (f *FlagSet) StringSlice(name string, value []string, usage string) *[]string { + p := []string{} + f.StringSliceVarP(&p, name, "", value, usage) + return &p +} + +// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) StringSliceP(name, shorthand string, value []string, usage string) *[]string { + p := []string{} + f.StringSliceVarP(&p, name, shorthand, value, usage) + return &p +} + +// StringSlice defines a string flag with specified name, default value, and usage string. +// The return value is the address of a []string variable that stores the value of the flag. +func StringSlice(name string, value []string, usage string) *[]string { + return CommandLine.StringSliceP(name, "", value, usage) +} + +// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash. +func StringSliceP(name, shorthand string, value []string, usage string) *[]string { + return CommandLine.StringSliceP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/uint.go b/vendor/github.com/spf13/pflag/uint.go new file mode 100644 index 00000000..e142b499 --- /dev/null +++ b/vendor/github.com/spf13/pflag/uint.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- uint Value +type uintValue uint + +func newUintValue(val uint, p *uint) *uintValue { + *p = val + return (*uintValue)(p) +} + +func (i *uintValue) Set(s string) error { + v, err := strconv.ParseUint(s, 0, 64) + *i = uintValue(v) + return err +} + +func (i *uintValue) Type() string { + return "uint" +} + +func (i *uintValue) String() string { return fmt.Sprintf("%v", *i) } + +func uintConv(sval string) (interface{}, error) { + v, err := strconv.ParseUint(sval, 0, 0) + if err != nil { + return 0, err + } + return uint(v), nil +} + +// GetUint return the uint value of a flag with the given name +func (f *FlagSet) GetUint(name string) (uint, error) { + val, err := f.getFlagType(name, "uint", uintConv) + if err != nil { + return 0, err + } + return val.(uint), nil +} + +// UintVar defines a uint flag with specified name, default value, and usage string. +// The argument p points to a uint variable in which to store the value of the flag. +func (f *FlagSet) UintVar(p *uint, name string, value uint, usage string) { + f.VarP(newUintValue(value, p), name, "", usage) +} + +// UintVarP is like UintVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) UintVarP(p *uint, name, shorthand string, value uint, usage string) { + f.VarP(newUintValue(value, p), name, shorthand, usage) +} + +// UintVar defines a uint flag with specified name, default value, and usage string. +// The argument p points to a uint variable in which to store the value of the flag. +func UintVar(p *uint, name string, value uint, usage string) { + CommandLine.VarP(newUintValue(value, p), name, "", usage) +} + +// UintVarP is like UintVar, but accepts a shorthand letter that can be used after a single dash. +func UintVarP(p *uint, name, shorthand string, value uint, usage string) { + CommandLine.VarP(newUintValue(value, p), name, shorthand, usage) +} + +// Uint defines a uint flag with specified name, default value, and usage string. +// The return value is the address of a uint variable that stores the value of the flag. +func (f *FlagSet) Uint(name string, value uint, usage string) *uint { + p := new(uint) + f.UintVarP(p, name, "", value, usage) + return p +} + +// UintP is like Uint, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) UintP(name, shorthand string, value uint, usage string) *uint { + p := new(uint) + f.UintVarP(p, name, shorthand, value, usage) + return p +} + +// Uint defines a uint flag with specified name, default value, and usage string. +// The return value is the address of a uint variable that stores the value of the flag. +func Uint(name string, value uint, usage string) *uint { + return CommandLine.UintP(name, "", value, usage) +} + +// UintP is like Uint, but accepts a shorthand letter that can be used after a single dash. +func UintP(name, shorthand string, value uint, usage string) *uint { + return CommandLine.UintP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/uint16.go b/vendor/github.com/spf13/pflag/uint16.go new file mode 100644 index 00000000..5c96c19d --- /dev/null +++ b/vendor/github.com/spf13/pflag/uint16.go @@ -0,0 +1,89 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- uint16 value +type uint16Value uint16 + +func newUint16Value(val uint16, p *uint16) *uint16Value { + *p = val + return (*uint16Value)(p) +} +func (i *uint16Value) String() string { return fmt.Sprintf("%d", *i) } +func (i *uint16Value) Set(s string) error { + v, err := strconv.ParseUint(s, 0, 16) + *i = uint16Value(v) + return err +} + +func (i *uint16Value) Type() string { + return "uint16" +} + +func uint16Conv(sval string) (interface{}, error) { + v, err := strconv.ParseUint(sval, 0, 16) + if err != nil { + return 0, err + } + return uint16(v), nil +} + +// GetUint16 return the uint16 value of a flag with the given name +func (f *FlagSet) GetUint16(name string) (uint16, error) { + val, err := f.getFlagType(name, "uint16", uint16Conv) + if err != nil { + return 0, err + } + return val.(uint16), nil +} + +// Uint16Var defines a uint flag with specified name, default value, and usage string. +// The argument p points to a uint variable in which to store the value of the flag. +func (f *FlagSet) Uint16Var(p *uint16, name string, value uint16, usage string) { + f.VarP(newUint16Value(value, p), name, "", usage) +} + +// Uint16VarP is like Uint16Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) { + f.VarP(newUint16Value(value, p), name, shorthand, usage) +} + +// Uint16Var defines a uint flag with specified name, default value, and usage string. +// The argument p points to a uint variable in which to store the value of the flag. +func Uint16Var(p *uint16, name string, value uint16, usage string) { + CommandLine.VarP(newUint16Value(value, p), name, "", usage) +} + +// Uint16VarP is like Uint16Var, but accepts a shorthand letter that can be used after a single dash. +func Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) { + CommandLine.VarP(newUint16Value(value, p), name, shorthand, usage) +} + +// Uint16 defines a uint flag with specified name, default value, and usage string. +// The return value is the address of a uint variable that stores the value of the flag. +func (f *FlagSet) Uint16(name string, value uint16, usage string) *uint16 { + p := new(uint16) + f.Uint16VarP(p, name, "", value, usage) + return p +} + +// Uint16P is like Uint16, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint16P(name, shorthand string, value uint16, usage string) *uint16 { + p := new(uint16) + f.Uint16VarP(p, name, shorthand, value, usage) + return p +} + +// Uint16 defines a uint flag with specified name, default value, and usage string. +// The return value is the address of a uint variable that stores the value of the flag. +func Uint16(name string, value uint16, usage string) *uint16 { + return CommandLine.Uint16P(name, "", value, usage) +} + +// Uint16P is like Uint16, but accepts a shorthand letter that can be used after a single dash. +func Uint16P(name, shorthand string, value uint16, usage string) *uint16 { + return CommandLine.Uint16P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/uint32.go b/vendor/github.com/spf13/pflag/uint32.go new file mode 100644 index 00000000..294fcaa3 --- /dev/null +++ b/vendor/github.com/spf13/pflag/uint32.go @@ -0,0 +1,89 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- uint16 value +type uint32Value uint32 + +func newUint32Value(val uint32, p *uint32) *uint32Value { + *p = val + return (*uint32Value)(p) +} +func (i *uint32Value) String() string { return fmt.Sprintf("%d", *i) } +func (i *uint32Value) Set(s string) error { + v, err := strconv.ParseUint(s, 0, 32) + *i = uint32Value(v) + return err +} + +func (i *uint32Value) Type() string { + return "uint32" +} + +func uint32Conv(sval string) (interface{}, error) { + v, err := strconv.ParseUint(sval, 0, 32) + if err != nil { + return 0, err + } + return uint32(v), nil +} + +// GetUint32 return the uint32 value of a flag with the given name +func (f *FlagSet) GetUint32(name string) (uint32, error) { + val, err := f.getFlagType(name, "uint32", uint32Conv) + if err != nil { + return 0, err + } + return val.(uint32), nil +} + +// Uint32Var defines a uint32 flag with specified name, default value, and usage string. +// The argument p points to a uint32 variable in which to store the value of the flag. +func (f *FlagSet) Uint32Var(p *uint32, name string, value uint32, usage string) { + f.VarP(newUint32Value(value, p), name, "", usage) +} + +// Uint32VarP is like Uint32Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint32VarP(p *uint32, name, shorthand string, value uint32, usage string) { + f.VarP(newUint32Value(value, p), name, shorthand, usage) +} + +// Uint32Var defines a uint32 flag with specified name, default value, and usage string. +// The argument p points to a uint32 variable in which to store the value of the flag. +func Uint32Var(p *uint32, name string, value uint32, usage string) { + CommandLine.VarP(newUint32Value(value, p), name, "", usage) +} + +// Uint32VarP is like Uint32Var, but accepts a shorthand letter that can be used after a single dash. +func Uint32VarP(p *uint32, name, shorthand string, value uint32, usage string) { + CommandLine.VarP(newUint32Value(value, p), name, shorthand, usage) +} + +// Uint32 defines a uint32 flag with specified name, default value, and usage string. +// The return value is the address of a uint32 variable that stores the value of the flag. +func (f *FlagSet) Uint32(name string, value uint32, usage string) *uint32 { + p := new(uint32) + f.Uint32VarP(p, name, "", value, usage) + return p +} + +// Uint32P is like Uint32, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint32P(name, shorthand string, value uint32, usage string) *uint32 { + p := new(uint32) + f.Uint32VarP(p, name, shorthand, value, usage) + return p +} + +// Uint32 defines a uint32 flag with specified name, default value, and usage string. +// The return value is the address of a uint32 variable that stores the value of the flag. +func Uint32(name string, value uint32, usage string) *uint32 { + return CommandLine.Uint32P(name, "", value, usage) +} + +// Uint32P is like Uint32, but accepts a shorthand letter that can be used after a single dash. +func Uint32P(name, shorthand string, value uint32, usage string) *uint32 { + return CommandLine.Uint32P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/uint64.go b/vendor/github.com/spf13/pflag/uint64.go new file mode 100644 index 00000000..c6818850 --- /dev/null +++ b/vendor/github.com/spf13/pflag/uint64.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- uint64 Value +type uint64Value uint64 + +func newUint64Value(val uint64, p *uint64) *uint64Value { + *p = val + return (*uint64Value)(p) +} + +func (i *uint64Value) Set(s string) error { + v, err := strconv.ParseUint(s, 0, 64) + *i = uint64Value(v) + return err +} + +func (i *uint64Value) Type() string { + return "uint64" +} + +func (i *uint64Value) String() string { return fmt.Sprintf("%v", *i) } + +func uint64Conv(sval string) (interface{}, error) { + v, err := strconv.ParseUint(sval, 0, 64) + if err != nil { + return 0, err + } + return uint64(v), nil +} + +// GetUint64 return the uint64 value of a flag with the given name +func (f *FlagSet) GetUint64(name string) (uint64, error) { + val, err := f.getFlagType(name, "uint64", uint64Conv) + if err != nil { + return 0, err + } + return val.(uint64), nil +} + +// Uint64Var defines a uint64 flag with specified name, default value, and usage string. +// The argument p points to a uint64 variable in which to store the value of the flag. +func (f *FlagSet) Uint64Var(p *uint64, name string, value uint64, usage string) { + f.VarP(newUint64Value(value, p), name, "", usage) +} + +// Uint64VarP is like Uint64Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint64VarP(p *uint64, name, shorthand string, value uint64, usage string) { + f.VarP(newUint64Value(value, p), name, shorthand, usage) +} + +// Uint64Var defines a uint64 flag with specified name, default value, and usage string. +// The argument p points to a uint64 variable in which to store the value of the flag. +func Uint64Var(p *uint64, name string, value uint64, usage string) { + CommandLine.VarP(newUint64Value(value, p), name, "", usage) +} + +// Uint64VarP is like Uint64Var, but accepts a shorthand letter that can be used after a single dash. +func Uint64VarP(p *uint64, name, shorthand string, value uint64, usage string) { + CommandLine.VarP(newUint64Value(value, p), name, shorthand, usage) +} + +// Uint64 defines a uint64 flag with specified name, default value, and usage string. +// The return value is the address of a uint64 variable that stores the value of the flag. +func (f *FlagSet) Uint64(name string, value uint64, usage string) *uint64 { + p := new(uint64) + f.Uint64VarP(p, name, "", value, usage) + return p +} + +// Uint64P is like Uint64, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint64P(name, shorthand string, value uint64, usage string) *uint64 { + p := new(uint64) + f.Uint64VarP(p, name, shorthand, value, usage) + return p +} + +// Uint64 defines a uint64 flag with specified name, default value, and usage string. +// The return value is the address of a uint64 variable that stores the value of the flag. +func Uint64(name string, value uint64, usage string) *uint64 { + return CommandLine.Uint64P(name, "", value, usage) +} + +// Uint64P is like Uint64, but accepts a shorthand letter that can be used after a single dash. +func Uint64P(name, shorthand string, value uint64, usage string) *uint64 { + return CommandLine.Uint64P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/uint8.go b/vendor/github.com/spf13/pflag/uint8.go new file mode 100644 index 00000000..26db418a --- /dev/null +++ b/vendor/github.com/spf13/pflag/uint8.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- uint8 Value +type uint8Value uint8 + +func newUint8Value(val uint8, p *uint8) *uint8Value { + *p = val + return (*uint8Value)(p) +} + +func (i *uint8Value) Set(s string) error { + v, err := strconv.ParseUint(s, 0, 8) + *i = uint8Value(v) + return err +} + +func (i *uint8Value) Type() string { + return "uint8" +} + +func (i *uint8Value) String() string { return fmt.Sprintf("%v", *i) } + +func uint8Conv(sval string) (interface{}, error) { + v, err := strconv.ParseUint(sval, 0, 8) + if err != nil { + return 0, err + } + return uint8(v), nil +} + +// GetUint8 return the uint8 value of a flag with the given name +func (f *FlagSet) GetUint8(name string) (uint8, error) { + val, err := f.getFlagType(name, "uint8", uint8Conv) + if err != nil { + return 0, err + } + return val.(uint8), nil +} + +// Uint8Var defines a uint8 flag with specified name, default value, and usage string. +// The argument p points to a uint8 variable in which to store the value of the flag. +func (f *FlagSet) Uint8Var(p *uint8, name string, value uint8, usage string) { + f.VarP(newUint8Value(value, p), name, "", usage) +} + +// Uint8VarP is like Uint8Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint8VarP(p *uint8, name, shorthand string, value uint8, usage string) { + f.VarP(newUint8Value(value, p), name, shorthand, usage) +} + +// Uint8Var defines a uint8 flag with specified name, default value, and usage string. +// The argument p points to a uint8 variable in which to store the value of the flag. +func Uint8Var(p *uint8, name string, value uint8, usage string) { + CommandLine.VarP(newUint8Value(value, p), name, "", usage) +} + +// Uint8VarP is like Uint8Var, but accepts a shorthand letter that can be used after a single dash. +func Uint8VarP(p *uint8, name, shorthand string, value uint8, usage string) { + CommandLine.VarP(newUint8Value(value, p), name, shorthand, usage) +} + +// Uint8 defines a uint8 flag with specified name, default value, and usage string. +// The return value is the address of a uint8 variable that stores the value of the flag. +func (f *FlagSet) Uint8(name string, value uint8, usage string) *uint8 { + p := new(uint8) + f.Uint8VarP(p, name, "", value, usage) + return p +} + +// Uint8P is like Uint8, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint8P(name, shorthand string, value uint8, usage string) *uint8 { + p := new(uint8) + f.Uint8VarP(p, name, shorthand, value, usage) + return p +} + +// Uint8 defines a uint8 flag with specified name, default value, and usage string. +// The return value is the address of a uint8 variable that stores the value of the flag. +func Uint8(name string, value uint8, usage string) *uint8 { + return CommandLine.Uint8P(name, "", value, usage) +} + +// Uint8P is like Uint8, but accepts a shorthand letter that can be used after a single dash. +func Uint8P(name, shorthand string, value uint8, usage string) *uint8 { + return CommandLine.Uint8P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/ugorji/go/LICENSE b/vendor/github.com/ugorji/go/LICENSE new file mode 100644 index 00000000..95a0f054 --- /dev/null +++ b/vendor/github.com/ugorji/go/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2012-2015 Ugorji Nwoke. +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/github.com/ugorji/go/codec/0doc.go b/vendor/github.com/ugorji/go/codec/0doc.go new file mode 100644 index 00000000..209f9eba --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/0doc.go @@ -0,0 +1,199 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +/* +High Performance, Feature-Rich Idiomatic Go codec/encoding library for +binc, msgpack, cbor, json. + +Supported Serialization formats are: + + - msgpack: https://github.com/msgpack/msgpack + - binc: http://github.com/ugorji/binc + - cbor: http://cbor.io http://tools.ietf.org/html/rfc7049 + - json: http://json.org http://tools.ietf.org/html/rfc7159 + - simple: + +To install: + + go get github.com/ugorji/go/codec + +This package understands the 'unsafe' tag, to allow using unsafe semantics: + + - When decoding into a struct, you need to read the field name as a string + so you can find the struct field it is mapped to. + Using `unsafe` will bypass the allocation and copying overhead of []byte->string conversion. + +To install using unsafe, pass the 'unsafe' tag: + + go get -tags=unsafe github.com/ugorji/go/codec + +For detailed usage information, read the primer at http://ugorji.net/blog/go-codec-primer . + +The idiomatic Go support is as seen in other encoding packages in +the standard library (ie json, xml, gob, etc). + +Rich Feature Set includes: + + - Simple but extremely powerful and feature-rich API + - Very High Performance. + Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X. + - Multiple conversions: + Package coerces types where appropriate + e.g. decode an int in the stream into a float, etc. + - Corner Cases: + Overflows, nil maps/slices, nil values in streams are handled correctly + - Standard field renaming via tags + - Support for omitting empty fields during an encoding + - Encoding from any value and decoding into pointer to any value + (struct, slice, map, primitives, pointers, interface{}, etc) + - Extensions to support efficient encoding/decoding of any named types + - Support encoding.(Binary|Text)(M|Unm)arshaler interfaces + - Decoding without a schema (into a interface{}). + Includes Options to configure what specific map or slice type to use + when decoding an encoded list or map into a nil interface{} + - Encode a struct as an array, and decode struct from an array in the data stream + - Comprehensive support for anonymous fields + - Fast (no-reflection) encoding/decoding of common maps and slices + - Code-generation for faster performance. + - Support binary (e.g. messagepack, cbor) and text (e.g. json) formats + - Support indefinite-length formats to enable true streaming + (for formats which support it e.g. json, cbor) + - Support canonical encoding, where a value is ALWAYS encoded as same sequence of bytes. + This mostly applies to maps, where iteration order is non-deterministic. + - NIL in data stream decoded as zero value + - Never silently skip data when decoding. + User decides whether to return an error or silently skip data when keys or indexes + in the data stream do not map to fields in the struct. + - Detect and error when encoding a cyclic reference (instead of stack overflow shutdown) + - Encode/Decode from/to chan types (for iterative streaming support) + - Drop-in replacement for encoding/json. `json:` key in struct tag supported. + - Provides a RPC Server and Client Codec for net/rpc communication protocol. + - Handle unique idiosyncrasies of codecs e.g. + - For messagepack, configure how ambiguities in handling raw bytes are resolved + - For messagepack, provide rpc server/client codec to support + msgpack-rpc protocol defined at: + https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md + +Extension Support + +Users can register a function to handle the encoding or decoding of +their custom types. + +There are no restrictions on what the custom type can be. Some examples: + + type BisSet []int + type BitSet64 uint64 + type UUID string + type MyStructWithUnexportedFields struct { a int; b bool; c []int; } + type GifImage struct { ... } + +As an illustration, MyStructWithUnexportedFields would normally be +encoded as an empty map because it has no exported fields, while UUID +would be encoded as a string. However, with extension support, you can +encode any of these however you like. + +RPC + +RPC Client and Server Codecs are implemented, so the codecs can be used +with the standard net/rpc package. + +Usage + +The Handle is SAFE for concurrent READ, but NOT SAFE for concurrent modification. + +The Encoder and Decoder are NOT safe for concurrent use. + +Consequently, the usage model is basically: + + - Create and initialize the Handle before any use. + Once created, DO NOT modify it. + - Multiple Encoders or Decoders can now use the Handle concurrently. + They only read information off the Handle (never write). + - However, each Encoder or Decoder MUST not be used concurrently + - To re-use an Encoder/Decoder, call Reset(...) on it first. + This allows you use state maintained on the Encoder/Decoder. + +Sample usage model: + + // create and configure Handle + var ( + bh codec.BincHandle + mh codec.MsgpackHandle + ch codec.CborHandle + ) + + mh.MapType = reflect.TypeOf(map[string]interface{}(nil)) + + // configure extensions + // e.g. for msgpack, define functions and enable Time support for tag 1 + // mh.SetExt(reflect.TypeOf(time.Time{}), 1, myExt) + + // create and use decoder/encoder + var ( + r io.Reader + w io.Writer + b []byte + h = &bh // or mh to use msgpack + ) + + dec = codec.NewDecoder(r, h) + dec = codec.NewDecoderBytes(b, h) + err = dec.Decode(&v) + + enc = codec.NewEncoder(w, h) + enc = codec.NewEncoderBytes(&b, h) + err = enc.Encode(v) + + //RPC Server + go func() { + for { + conn, err := listener.Accept() + rpcCodec := codec.GoRpc.ServerCodec(conn, h) + //OR rpcCodec := codec.MsgpackSpecRpc.ServerCodec(conn, h) + rpc.ServeCodec(rpcCodec) + } + }() + + //RPC Communication (client side) + conn, err = net.Dial("tcp", "localhost:5555") + rpcCodec := codec.GoRpc.ClientCodec(conn, h) + //OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h) + client := rpc.NewClientWithCodec(rpcCodec) + +*/ +package codec + +// Benefits of go-codec: +// +// - encoding/json always reads whole file into memory first. +// This makes it unsuitable for parsing very large files. +// - encoding/xml cannot parse into a map[string]interface{} +// I found this out on reading https://github.com/clbanning/mxj + +// TODO: +// +// - optimization for codecgen: +// if len of entity is <= 3 words, then support a value receiver for encode. +// - (En|De)coder should store an error when it occurs. +// Until reset, subsequent calls return that error that was stored. +// This means that free panics must go away. +// All errors must be raised through errorf method. +// - Decoding using a chan is good, but incurs concurrency costs. +// This is because there's no fast way to use a channel without it +// having to switch goroutines constantly. +// Callback pattern is still the best. Maybe consider supporting something like: +// type X struct { +// Name string +// Ys []Y +// Ys chan <- Y +// Ys func(Y) -> call this function for each entry +// } +// - Consider adding a isZeroer interface { isZero() bool } +// It is used within isEmpty, for omitEmpty support. +// - Consider making Handle used AS-IS within the encoding/decoding session. +// This means that we don't cache Handle information within the (En|De)coder, +// except we really need it at Reset(...) +// - Consider adding math/big support +// - Consider reducing the size of the generated functions: +// Maybe use one loop, and put the conditionals in the loop. +// for ... { if cLen > 0 { if j == cLen { break } } else if dd.CheckBreak() { break } } diff --git a/vendor/github.com/ugorji/go/codec/binc.go b/vendor/github.com/ugorji/go/codec/binc.go new file mode 100644 index 00000000..f392eb53 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/binc.go @@ -0,0 +1,922 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "math" + "reflect" + "time" +) + +const bincDoPrune = true // No longer needed. Needed before as C lib did not support pruning. + +// vd as low 4 bits (there are 16 slots) +const ( + bincVdSpecial byte = iota + bincVdPosInt + bincVdNegInt + bincVdFloat + + bincVdString + bincVdByteArray + bincVdArray + bincVdMap + + bincVdTimestamp + bincVdSmallInt + bincVdUnicodeOther + bincVdSymbol + + bincVdDecimal + _ // open slot + _ // open slot + bincVdCustomExt = 0x0f +) + +const ( + bincSpNil byte = iota + bincSpFalse + bincSpTrue + bincSpNan + bincSpPosInf + bincSpNegInf + bincSpZeroFloat + bincSpZero + bincSpNegOne +) + +const ( + bincFlBin16 byte = iota + bincFlBin32 + _ // bincFlBin32e + bincFlBin64 + _ // bincFlBin64e + // others not currently supported +) + +type bincEncDriver struct { + e *Encoder + w encWriter + m map[string]uint16 // symbols + b [scratchByteArrayLen]byte + s uint16 // symbols sequencer + encNoSeparator +} + +func (e *bincEncDriver) IsBuiltinType(rt uintptr) bool { + return rt == timeTypId +} + +func (e *bincEncDriver) EncodeBuiltin(rt uintptr, v interface{}) { + if rt == timeTypId { + var bs []byte + switch x := v.(type) { + case time.Time: + bs = encodeTime(x) + case *time.Time: + bs = encodeTime(*x) + default: + e.e.errorf("binc error encoding builtin: expect time.Time, received %T", v) + } + e.w.writen1(bincVdTimestamp<<4 | uint8(len(bs))) + e.w.writeb(bs) + } +} + +func (e *bincEncDriver) EncodeNil() { + e.w.writen1(bincVdSpecial<<4 | bincSpNil) +} + +func (e *bincEncDriver) EncodeBool(b bool) { + if b { + e.w.writen1(bincVdSpecial<<4 | bincSpTrue) + } else { + e.w.writen1(bincVdSpecial<<4 | bincSpFalse) + } +} + +func (e *bincEncDriver) EncodeFloat32(f float32) { + if f == 0 { + e.w.writen1(bincVdSpecial<<4 | bincSpZeroFloat) + return + } + e.w.writen1(bincVdFloat<<4 | bincFlBin32) + bigenHelper{e.b[:4], e.w}.writeUint32(math.Float32bits(f)) +} + +func (e *bincEncDriver) EncodeFloat64(f float64) { + if f == 0 { + e.w.writen1(bincVdSpecial<<4 | bincSpZeroFloat) + return + } + bigen.PutUint64(e.b[:8], math.Float64bits(f)) + if bincDoPrune { + i := 7 + for ; i >= 0 && (e.b[i] == 0); i-- { + } + i++ + if i <= 6 { + e.w.writen1(bincVdFloat<<4 | 0x8 | bincFlBin64) + e.w.writen1(byte(i)) + e.w.writeb(e.b[:i]) + return + } + } + e.w.writen1(bincVdFloat<<4 | bincFlBin64) + e.w.writeb(e.b[:8]) +} + +func (e *bincEncDriver) encIntegerPrune(bd byte, pos bool, v uint64, lim uint8) { + if lim == 4 { + bigen.PutUint32(e.b[:lim], uint32(v)) + } else { + bigen.PutUint64(e.b[:lim], v) + } + if bincDoPrune { + i := pruneSignExt(e.b[:lim], pos) + e.w.writen1(bd | lim - 1 - byte(i)) + e.w.writeb(e.b[i:lim]) + } else { + e.w.writen1(bd | lim - 1) + e.w.writeb(e.b[:lim]) + } +} + +func (e *bincEncDriver) EncodeInt(v int64) { + const nbd byte = bincVdNegInt << 4 + if v >= 0 { + e.encUint(bincVdPosInt<<4, true, uint64(v)) + } else if v == -1 { + e.w.writen1(bincVdSpecial<<4 | bincSpNegOne) + } else { + e.encUint(bincVdNegInt<<4, false, uint64(-v)) + } +} + +func (e *bincEncDriver) EncodeUint(v uint64) { + e.encUint(bincVdPosInt<<4, true, v) +} + +func (e *bincEncDriver) encUint(bd byte, pos bool, v uint64) { + if v == 0 { + e.w.writen1(bincVdSpecial<<4 | bincSpZero) + } else if pos && v >= 1 && v <= 16 { + e.w.writen1(bincVdSmallInt<<4 | byte(v-1)) + } else if v <= math.MaxUint8 { + e.w.writen2(bd|0x0, byte(v)) + } else if v <= math.MaxUint16 { + e.w.writen1(bd | 0x01) + bigenHelper{e.b[:2], e.w}.writeUint16(uint16(v)) + } else if v <= math.MaxUint32 { + e.encIntegerPrune(bd, pos, v, 4) + } else { + e.encIntegerPrune(bd, pos, v, 8) + } +} + +func (e *bincEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, _ *Encoder) { + bs := ext.WriteExt(rv) + if bs == nil { + e.EncodeNil() + return + } + e.encodeExtPreamble(uint8(xtag), len(bs)) + e.w.writeb(bs) +} + +func (e *bincEncDriver) EncodeRawExt(re *RawExt, _ *Encoder) { + e.encodeExtPreamble(uint8(re.Tag), len(re.Data)) + e.w.writeb(re.Data) +} + +func (e *bincEncDriver) encodeExtPreamble(xtag byte, length int) { + e.encLen(bincVdCustomExt<<4, uint64(length)) + e.w.writen1(xtag) +} + +func (e *bincEncDriver) EncodeArrayStart(length int) { + e.encLen(bincVdArray<<4, uint64(length)) +} + +func (e *bincEncDriver) EncodeMapStart(length int) { + e.encLen(bincVdMap<<4, uint64(length)) +} + +func (e *bincEncDriver) EncodeString(c charEncoding, v string) { + l := uint64(len(v)) + e.encBytesLen(c, l) + if l > 0 { + e.w.writestr(v) + } +} + +func (e *bincEncDriver) EncodeSymbol(v string) { + // if WriteSymbolsNoRefs { + // e.encodeString(c_UTF8, v) + // return + // } + + //symbols only offer benefit when string length > 1. + //This is because strings with length 1 take only 2 bytes to store + //(bd with embedded length, and single byte for string val). + + l := len(v) + if l == 0 { + e.encBytesLen(c_UTF8, 0) + return + } else if l == 1 { + e.encBytesLen(c_UTF8, 1) + e.w.writen1(v[0]) + return + } + if e.m == nil { + e.m = make(map[string]uint16, 16) + } + ui, ok := e.m[v] + if ok { + if ui <= math.MaxUint8 { + e.w.writen2(bincVdSymbol<<4, byte(ui)) + } else { + e.w.writen1(bincVdSymbol<<4 | 0x8) + bigenHelper{e.b[:2], e.w}.writeUint16(ui) + } + } else { + e.s++ + ui = e.s + //ui = uint16(atomic.AddUint32(&e.s, 1)) + e.m[v] = ui + var lenprec uint8 + if l <= math.MaxUint8 { + // lenprec = 0 + } else if l <= math.MaxUint16 { + lenprec = 1 + } else if int64(l) <= math.MaxUint32 { + lenprec = 2 + } else { + lenprec = 3 + } + if ui <= math.MaxUint8 { + e.w.writen2(bincVdSymbol<<4|0x0|0x4|lenprec, byte(ui)) + } else { + e.w.writen1(bincVdSymbol<<4 | 0x8 | 0x4 | lenprec) + bigenHelper{e.b[:2], e.w}.writeUint16(ui) + } + if lenprec == 0 { + e.w.writen1(byte(l)) + } else if lenprec == 1 { + bigenHelper{e.b[:2], e.w}.writeUint16(uint16(l)) + } else if lenprec == 2 { + bigenHelper{e.b[:4], e.w}.writeUint32(uint32(l)) + } else { + bigenHelper{e.b[:8], e.w}.writeUint64(uint64(l)) + } + e.w.writestr(v) + } +} + +func (e *bincEncDriver) EncodeStringBytes(c charEncoding, v []byte) { + l := uint64(len(v)) + e.encBytesLen(c, l) + if l > 0 { + e.w.writeb(v) + } +} + +func (e *bincEncDriver) encBytesLen(c charEncoding, length uint64) { + //TODO: support bincUnicodeOther (for now, just use string or bytearray) + if c == c_RAW { + e.encLen(bincVdByteArray<<4, length) + } else { + e.encLen(bincVdString<<4, length) + } +} + +func (e *bincEncDriver) encLen(bd byte, l uint64) { + if l < 12 { + e.w.writen1(bd | uint8(l+4)) + } else { + e.encLenNumber(bd, l) + } +} + +func (e *bincEncDriver) encLenNumber(bd byte, v uint64) { + if v <= math.MaxUint8 { + e.w.writen2(bd, byte(v)) + } else if v <= math.MaxUint16 { + e.w.writen1(bd | 0x01) + bigenHelper{e.b[:2], e.w}.writeUint16(uint16(v)) + } else if v <= math.MaxUint32 { + e.w.writen1(bd | 0x02) + bigenHelper{e.b[:4], e.w}.writeUint32(uint32(v)) + } else { + e.w.writen1(bd | 0x03) + bigenHelper{e.b[:8], e.w}.writeUint64(uint64(v)) + } +} + +//------------------------------------ + +type bincDecSymbol struct { + s string + b []byte + i uint16 +} + +type bincDecDriver struct { + d *Decoder + h *BincHandle + r decReader + br bool // bytes reader + bdRead bool + bd byte + vd byte + vs byte + noStreamingCodec + decNoSeparator + b [scratchByteArrayLen]byte + + // linear searching on this slice is ok, + // because we typically expect < 32 symbols in each stream. + s []bincDecSymbol +} + +func (d *bincDecDriver) readNextBd() { + d.bd = d.r.readn1() + d.vd = d.bd >> 4 + d.vs = d.bd & 0x0f + d.bdRead = true +} + +func (d *bincDecDriver) ContainerType() (vt valueType) { + if d.vd == bincVdSpecial && d.vs == bincSpNil { + return valueTypeNil + } else if d.vd == bincVdByteArray { + return valueTypeBytes + } else if d.vd == bincVdString { + return valueTypeString + } else if d.vd == bincVdArray { + return valueTypeArray + } else if d.vd == bincVdMap { + return valueTypeMap + } else { + // d.d.errorf("isContainerType: unsupported parameter: %v", vt) + } + return valueTypeUnset +} + +func (d *bincDecDriver) TryDecodeAsNil() bool { + if !d.bdRead { + d.readNextBd() + } + if d.bd == bincVdSpecial<<4|bincSpNil { + d.bdRead = false + return true + } + return false +} + +func (d *bincDecDriver) IsBuiltinType(rt uintptr) bool { + return rt == timeTypId +} + +func (d *bincDecDriver) DecodeBuiltin(rt uintptr, v interface{}) { + if !d.bdRead { + d.readNextBd() + } + if rt == timeTypId { + if d.vd != bincVdTimestamp { + d.d.errorf("Invalid d.vd. Expecting 0x%x. Received: 0x%x", bincVdTimestamp, d.vd) + return + } + tt, err := decodeTime(d.r.readx(int(d.vs))) + if err != nil { + panic(err) + } + var vt *time.Time = v.(*time.Time) + *vt = tt + d.bdRead = false + } +} + +func (d *bincDecDriver) decFloatPre(vs, defaultLen byte) { + if vs&0x8 == 0 { + d.r.readb(d.b[0:defaultLen]) + } else { + l := d.r.readn1() + if l > 8 { + d.d.errorf("At most 8 bytes used to represent float. Received: %v bytes", l) + return + } + for i := l; i < 8; i++ { + d.b[i] = 0 + } + d.r.readb(d.b[0:l]) + } +} + +func (d *bincDecDriver) decFloat() (f float64) { + //if true { f = math.Float64frombits(bigen.Uint64(d.r.readx(8))); break; } + if x := d.vs & 0x7; x == bincFlBin32 { + d.decFloatPre(d.vs, 4) + f = float64(math.Float32frombits(bigen.Uint32(d.b[0:4]))) + } else if x == bincFlBin64 { + d.decFloatPre(d.vs, 8) + f = math.Float64frombits(bigen.Uint64(d.b[0:8])) + } else { + d.d.errorf("only float32 and float64 are supported. d.vd: 0x%x, d.vs: 0x%x", d.vd, d.vs) + return + } + return +} + +func (d *bincDecDriver) decUint() (v uint64) { + // need to inline the code (interface conversion and type assertion expensive) + switch d.vs { + case 0: + v = uint64(d.r.readn1()) + case 1: + d.r.readb(d.b[6:8]) + v = uint64(bigen.Uint16(d.b[6:8])) + case 2: + d.b[4] = 0 + d.r.readb(d.b[5:8]) + v = uint64(bigen.Uint32(d.b[4:8])) + case 3: + d.r.readb(d.b[4:8]) + v = uint64(bigen.Uint32(d.b[4:8])) + case 4, 5, 6: + lim := int(7 - d.vs) + d.r.readb(d.b[lim:8]) + for i := 0; i < lim; i++ { + d.b[i] = 0 + } + v = uint64(bigen.Uint64(d.b[:8])) + case 7: + d.r.readb(d.b[:8]) + v = uint64(bigen.Uint64(d.b[:8])) + default: + d.d.errorf("unsigned integers with greater than 64 bits of precision not supported") + return + } + return +} + +func (d *bincDecDriver) decCheckInteger() (ui uint64, neg bool) { + if !d.bdRead { + d.readNextBd() + } + vd, vs := d.vd, d.vs + if vd == bincVdPosInt { + ui = d.decUint() + } else if vd == bincVdNegInt { + ui = d.decUint() + neg = true + } else if vd == bincVdSmallInt { + ui = uint64(d.vs) + 1 + } else if vd == bincVdSpecial { + if vs == bincSpZero { + //i = 0 + } else if vs == bincSpNegOne { + neg = true + ui = 1 + } else { + d.d.errorf("numeric decode fails for special value: d.vs: 0x%x", d.vs) + return + } + } else { + d.d.errorf("number can only be decoded from uint or int values. d.bd: 0x%x, d.vd: 0x%x", d.bd, d.vd) + return + } + return +} + +func (d *bincDecDriver) DecodeInt(bitsize uint8) (i int64) { + ui, neg := d.decCheckInteger() + i, overflow := chkOvf.SignedInt(ui) + if overflow { + d.d.errorf("simple: overflow converting %v to signed integer", ui) + return + } + if neg { + i = -i + } + if chkOvf.Int(i, bitsize) { + d.d.errorf("binc: overflow integer: %v", i) + return + } + d.bdRead = false + return +} + +func (d *bincDecDriver) DecodeUint(bitsize uint8) (ui uint64) { + ui, neg := d.decCheckInteger() + if neg { + d.d.errorf("Assigning negative signed value to unsigned type") + return + } + if chkOvf.Uint(ui, bitsize) { + d.d.errorf("binc: overflow integer: %v", ui) + return + } + d.bdRead = false + return +} + +func (d *bincDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) { + if !d.bdRead { + d.readNextBd() + } + vd, vs := d.vd, d.vs + if vd == bincVdSpecial { + d.bdRead = false + if vs == bincSpNan { + return math.NaN() + } else if vs == bincSpPosInf { + return math.Inf(1) + } else if vs == bincSpZeroFloat || vs == bincSpZero { + return + } else if vs == bincSpNegInf { + return math.Inf(-1) + } else { + d.d.errorf("Invalid d.vs decoding float where d.vd=bincVdSpecial: %v", d.vs) + return + } + } else if vd == bincVdFloat { + f = d.decFloat() + } else { + f = float64(d.DecodeInt(64)) + } + if chkOverflow32 && chkOvf.Float32(f) { + d.d.errorf("binc: float32 overflow: %v", f) + return + } + d.bdRead = false + return +} + +// bool can be decoded from bool only (single byte). +func (d *bincDecDriver) DecodeBool() (b bool) { + if !d.bdRead { + d.readNextBd() + } + if bd := d.bd; bd == (bincVdSpecial | bincSpFalse) { + // b = false + } else if bd == (bincVdSpecial | bincSpTrue) { + b = true + } else { + d.d.errorf("Invalid single-byte value for bool: %s: %x", msgBadDesc, d.bd) + return + } + d.bdRead = false + return +} + +func (d *bincDecDriver) ReadMapStart() (length int) { + if d.vd != bincVdMap { + d.d.errorf("Invalid d.vd for map. Expecting 0x%x. Got: 0x%x", bincVdMap, d.vd) + return + } + length = d.decLen() + d.bdRead = false + return +} + +func (d *bincDecDriver) ReadArrayStart() (length int) { + if d.vd != bincVdArray { + d.d.errorf("Invalid d.vd for array. Expecting 0x%x. Got: 0x%x", bincVdArray, d.vd) + return + } + length = d.decLen() + d.bdRead = false + return +} + +func (d *bincDecDriver) decLen() int { + if d.vs > 3 { + return int(d.vs - 4) + } + return int(d.decLenNumber()) +} + +func (d *bincDecDriver) decLenNumber() (v uint64) { + if x := d.vs; x == 0 { + v = uint64(d.r.readn1()) + } else if x == 1 { + d.r.readb(d.b[6:8]) + v = uint64(bigen.Uint16(d.b[6:8])) + } else if x == 2 { + d.r.readb(d.b[4:8]) + v = uint64(bigen.Uint32(d.b[4:8])) + } else { + d.r.readb(d.b[:8]) + v = bigen.Uint64(d.b[:8]) + } + return +} + +func (d *bincDecDriver) decStringAndBytes(bs []byte, withString, zerocopy bool) (bs2 []byte, s string) { + if !d.bdRead { + d.readNextBd() + } + if d.bd == bincVdSpecial<<4|bincSpNil { + d.bdRead = false + return + } + var slen int = -1 + // var ok bool + switch d.vd { + case bincVdString, bincVdByteArray: + slen = d.decLen() + if zerocopy { + if d.br { + bs2 = d.r.readx(slen) + } else if len(bs) == 0 { + bs2 = decByteSlice(d.r, slen, d.b[:]) + } else { + bs2 = decByteSlice(d.r, slen, bs) + } + } else { + bs2 = decByteSlice(d.r, slen, bs) + } + if withString { + s = string(bs2) + } + case bincVdSymbol: + // zerocopy doesn't apply for symbols, + // as the values must be stored in a table for later use. + // + //from vs: extract numSymbolBytes, containsStringVal, strLenPrecision, + //extract symbol + //if containsStringVal, read it and put in map + //else look in map for string value + var symbol uint16 + vs := d.vs + if vs&0x8 == 0 { + symbol = uint16(d.r.readn1()) + } else { + symbol = uint16(bigen.Uint16(d.r.readx(2))) + } + if d.s == nil { + d.s = make([]bincDecSymbol, 0, 16) + } + + if vs&0x4 == 0 { + for i := range d.s { + j := &d.s[i] + if j.i == symbol { + bs2 = j.b + if withString { + if j.s == "" && bs2 != nil { + j.s = string(bs2) + } + s = j.s + } + break + } + } + } else { + switch vs & 0x3 { + case 0: + slen = int(d.r.readn1()) + case 1: + slen = int(bigen.Uint16(d.r.readx(2))) + case 2: + slen = int(bigen.Uint32(d.r.readx(4))) + case 3: + slen = int(bigen.Uint64(d.r.readx(8))) + } + // since using symbols, do not store any part of + // the parameter bs in the map, as it might be a shared buffer. + // bs2 = decByteSlice(d.r, slen, bs) + bs2 = decByteSlice(d.r, slen, nil) + if withString { + s = string(bs2) + } + d.s = append(d.s, bincDecSymbol{i: symbol, s: s, b: bs2}) + } + default: + d.d.errorf("Invalid d.vd. Expecting string:0x%x, bytearray:0x%x or symbol: 0x%x. Got: 0x%x", + bincVdString, bincVdByteArray, bincVdSymbol, d.vd) + return + } + d.bdRead = false + return +} + +func (d *bincDecDriver) DecodeString() (s string) { + // DecodeBytes does not accommodate symbols, whose impl stores string version in map. + // Use decStringAndBytes directly. + // return string(d.DecodeBytes(d.b[:], true, true)) + _, s = d.decStringAndBytes(d.b[:], true, true) + return +} + +func (d *bincDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) { + if isstring { + bsOut, _ = d.decStringAndBytes(bs, false, zerocopy) + return + } + if !d.bdRead { + d.readNextBd() + } + if d.bd == bincVdSpecial<<4|bincSpNil { + d.bdRead = false + return nil + } + var clen int + if d.vd == bincVdString || d.vd == bincVdByteArray { + clen = d.decLen() + } else { + d.d.errorf("Invalid d.vd for bytes. Expecting string:0x%x or bytearray:0x%x. Got: 0x%x", + bincVdString, bincVdByteArray, d.vd) + return + } + d.bdRead = false + if zerocopy { + if d.br { + return d.r.readx(clen) + } else if len(bs) == 0 { + bs = d.b[:] + } + } + return decByteSlice(d.r, clen, bs) +} + +func (d *bincDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) { + if xtag > 0xff { + d.d.errorf("decodeExt: tag must be <= 0xff; got: %v", xtag) + return + } + realxtag1, xbs := d.decodeExtV(ext != nil, uint8(xtag)) + realxtag = uint64(realxtag1) + if ext == nil { + re := rv.(*RawExt) + re.Tag = realxtag + re.Data = detachZeroCopyBytes(d.br, re.Data, xbs) + } else { + ext.ReadExt(rv, xbs) + } + return +} + +func (d *bincDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs []byte) { + if !d.bdRead { + d.readNextBd() + } + if d.vd == bincVdCustomExt { + l := d.decLen() + xtag = d.r.readn1() + if verifyTag && xtag != tag { + d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", xtag, tag) + return + } + xbs = d.r.readx(l) + } else if d.vd == bincVdByteArray { + xbs = d.DecodeBytes(nil, false, true) + } else { + d.d.errorf("Invalid d.vd for extensions (Expecting extensions or byte array). Got: 0x%x", d.vd) + return + } + d.bdRead = false + return +} + +func (d *bincDecDriver) DecodeNaked() { + if !d.bdRead { + d.readNextBd() + } + + n := &d.d.n + var decodeFurther bool + + switch d.vd { + case bincVdSpecial: + switch d.vs { + case bincSpNil: + n.v = valueTypeNil + case bincSpFalse: + n.v = valueTypeBool + n.b = false + case bincSpTrue: + n.v = valueTypeBool + n.b = true + case bincSpNan: + n.v = valueTypeFloat + n.f = math.NaN() + case bincSpPosInf: + n.v = valueTypeFloat + n.f = math.Inf(1) + case bincSpNegInf: + n.v = valueTypeFloat + n.f = math.Inf(-1) + case bincSpZeroFloat: + n.v = valueTypeFloat + n.f = float64(0) + case bincSpZero: + n.v = valueTypeUint + n.u = uint64(0) // int8(0) + case bincSpNegOne: + n.v = valueTypeInt + n.i = int64(-1) // int8(-1) + default: + d.d.errorf("decodeNaked: Unrecognized special value 0x%x", d.vs) + } + case bincVdSmallInt: + n.v = valueTypeUint + n.u = uint64(int8(d.vs)) + 1 // int8(d.vs) + 1 + case bincVdPosInt: + n.v = valueTypeUint + n.u = d.decUint() + case bincVdNegInt: + n.v = valueTypeInt + n.i = -(int64(d.decUint())) + case bincVdFloat: + n.v = valueTypeFloat + n.f = d.decFloat() + case bincVdSymbol: + n.v = valueTypeSymbol + n.s = d.DecodeString() + case bincVdString: + n.v = valueTypeString + n.s = d.DecodeString() + case bincVdByteArray: + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) + case bincVdTimestamp: + n.v = valueTypeTimestamp + tt, err := decodeTime(d.r.readx(int(d.vs))) + if err != nil { + panic(err) + } + n.t = tt + case bincVdCustomExt: + n.v = valueTypeExt + l := d.decLen() + n.u = uint64(d.r.readn1()) + n.l = d.r.readx(l) + case bincVdArray: + n.v = valueTypeArray + decodeFurther = true + case bincVdMap: + n.v = valueTypeMap + decodeFurther = true + default: + d.d.errorf("decodeNaked: Unrecognized d.vd: 0x%x", d.vd) + } + + if !decodeFurther { + d.bdRead = false + } + if n.v == valueTypeUint && d.h.SignedInteger { + n.v = valueTypeInt + n.i = int64(n.u) + } + return +} + +//------------------------------------ + +//BincHandle is a Handle for the Binc Schema-Free Encoding Format +//defined at https://github.com/ugorji/binc . +// +//BincHandle currently supports all Binc features with the following EXCEPTIONS: +// - only integers up to 64 bits of precision are supported. +// big integers are unsupported. +// - Only IEEE 754 binary32 and binary64 floats are supported (ie Go float32 and float64 types). +// extended precision and decimal IEEE 754 floats are unsupported. +// - Only UTF-8 strings supported. +// Unicode_Other Binc types (UTF16, UTF32) are currently unsupported. +// +//Note that these EXCEPTIONS are temporary and full support is possible and may happen soon. +type BincHandle struct { + BasicHandle + binaryEncodingType +} + +func (h *BincHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) { + return h.SetExt(rt, tag, &setExtWrapper{b: ext}) +} + +func (h *BincHandle) newEncDriver(e *Encoder) encDriver { + return &bincEncDriver{e: e, w: e.w} +} + +func (h *BincHandle) newDecDriver(d *Decoder) decDriver { + return &bincDecDriver{d: d, r: d.r, h: h, br: d.bytes} +} + +func (e *bincEncDriver) reset() { + e.w = e.e.w + e.s = 0 + e.m = nil +} + +func (d *bincDecDriver) reset() { + d.r = d.d.r + d.s = nil + d.bd, d.bdRead, d.vd, d.vs = 0, false, 0, 0 +} + +var _ decDriver = (*bincDecDriver)(nil) +var _ encDriver = (*bincEncDriver)(nil) diff --git a/vendor/github.com/ugorji/go/codec/cbor.go b/vendor/github.com/ugorji/go/codec/cbor.go new file mode 100644 index 00000000..a224cd3a --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/cbor.go @@ -0,0 +1,585 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "math" + "reflect" +) + +const ( + cborMajorUint byte = iota + cborMajorNegInt + cborMajorBytes + cborMajorText + cborMajorArray + cborMajorMap + cborMajorTag + cborMajorOther +) + +const ( + cborBdFalse byte = 0xf4 + iota + cborBdTrue + cborBdNil + cborBdUndefined + cborBdExt + cborBdFloat16 + cborBdFloat32 + cborBdFloat64 +) + +const ( + cborBdIndefiniteBytes byte = 0x5f + cborBdIndefiniteString = 0x7f + cborBdIndefiniteArray = 0x9f + cborBdIndefiniteMap = 0xbf + cborBdBreak = 0xff +) + +const ( + CborStreamBytes byte = 0x5f + CborStreamString = 0x7f + CborStreamArray = 0x9f + CborStreamMap = 0xbf + CborStreamBreak = 0xff +) + +const ( + cborBaseUint byte = 0x00 + cborBaseNegInt = 0x20 + cborBaseBytes = 0x40 + cborBaseString = 0x60 + cborBaseArray = 0x80 + cborBaseMap = 0xa0 + cborBaseTag = 0xc0 + cborBaseSimple = 0xe0 +) + +// ------------------- + +type cborEncDriver struct { + noBuiltInTypes + encNoSeparator + e *Encoder + w encWriter + h *CborHandle + x [8]byte +} + +func (e *cborEncDriver) EncodeNil() { + e.w.writen1(cborBdNil) +} + +func (e *cborEncDriver) EncodeBool(b bool) { + if b { + e.w.writen1(cborBdTrue) + } else { + e.w.writen1(cborBdFalse) + } +} + +func (e *cborEncDriver) EncodeFloat32(f float32) { + e.w.writen1(cborBdFloat32) + bigenHelper{e.x[:4], e.w}.writeUint32(math.Float32bits(f)) +} + +func (e *cborEncDriver) EncodeFloat64(f float64) { + e.w.writen1(cborBdFloat64) + bigenHelper{e.x[:8], e.w}.writeUint64(math.Float64bits(f)) +} + +func (e *cborEncDriver) encUint(v uint64, bd byte) { + if v <= 0x17 { + e.w.writen1(byte(v) + bd) + } else if v <= math.MaxUint8 { + e.w.writen2(bd+0x18, uint8(v)) + } else if v <= math.MaxUint16 { + e.w.writen1(bd + 0x19) + bigenHelper{e.x[:2], e.w}.writeUint16(uint16(v)) + } else if v <= math.MaxUint32 { + e.w.writen1(bd + 0x1a) + bigenHelper{e.x[:4], e.w}.writeUint32(uint32(v)) + } else { // if v <= math.MaxUint64 { + e.w.writen1(bd + 0x1b) + bigenHelper{e.x[:8], e.w}.writeUint64(v) + } +} + +func (e *cborEncDriver) EncodeInt(v int64) { + if v < 0 { + e.encUint(uint64(-1-v), cborBaseNegInt) + } else { + e.encUint(uint64(v), cborBaseUint) + } +} + +func (e *cborEncDriver) EncodeUint(v uint64) { + e.encUint(v, cborBaseUint) +} + +func (e *cborEncDriver) encLen(bd byte, length int) { + e.encUint(uint64(length), bd) +} + +func (e *cborEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Encoder) { + e.encUint(uint64(xtag), cborBaseTag) + if v := ext.ConvertExt(rv); v == nil { + e.EncodeNil() + } else { + en.encode(v) + } +} + +func (e *cborEncDriver) EncodeRawExt(re *RawExt, en *Encoder) { + e.encUint(uint64(re.Tag), cborBaseTag) + if re.Data != nil { + en.encode(re.Data) + } else if re.Value == nil { + e.EncodeNil() + } else { + en.encode(re.Value) + } +} + +func (e *cborEncDriver) EncodeArrayStart(length int) { + e.encLen(cborBaseArray, length) +} + +func (e *cborEncDriver) EncodeMapStart(length int) { + e.encLen(cborBaseMap, length) +} + +func (e *cborEncDriver) EncodeString(c charEncoding, v string) { + e.encLen(cborBaseString, len(v)) + e.w.writestr(v) +} + +func (e *cborEncDriver) EncodeSymbol(v string) { + e.EncodeString(c_UTF8, v) +} + +func (e *cborEncDriver) EncodeStringBytes(c charEncoding, v []byte) { + if c == c_RAW { + e.encLen(cborBaseBytes, len(v)) + } else { + e.encLen(cborBaseString, len(v)) + } + e.w.writeb(v) +} + +// ---------------------- + +type cborDecDriver struct { + d *Decoder + h *CborHandle + r decReader + b [scratchByteArrayLen]byte + br bool // bytes reader + bdRead bool + bd byte + noBuiltInTypes + decNoSeparator +} + +func (d *cborDecDriver) readNextBd() { + d.bd = d.r.readn1() + d.bdRead = true +} + +func (d *cborDecDriver) ContainerType() (vt valueType) { + if d.bd == cborBdNil { + return valueTypeNil + } else if d.bd == cborBdIndefiniteBytes || (d.bd >= cborBaseBytes && d.bd < cborBaseString) { + return valueTypeBytes + } else if d.bd == cborBdIndefiniteString || (d.bd >= cborBaseString && d.bd < cborBaseArray) { + return valueTypeString + } else if d.bd == cborBdIndefiniteArray || (d.bd >= cborBaseArray && d.bd < cborBaseMap) { + return valueTypeArray + } else if d.bd == cborBdIndefiniteMap || (d.bd >= cborBaseMap && d.bd < cborBaseTag) { + return valueTypeMap + } else { + // d.d.errorf("isContainerType: unsupported parameter: %v", vt) + } + return valueTypeUnset +} + +func (d *cborDecDriver) TryDecodeAsNil() bool { + if !d.bdRead { + d.readNextBd() + } + // treat Nil and Undefined as nil values + if d.bd == cborBdNil || d.bd == cborBdUndefined { + d.bdRead = false + return true + } + return false +} + +func (d *cborDecDriver) CheckBreak() bool { + if !d.bdRead { + d.readNextBd() + } + if d.bd == cborBdBreak { + d.bdRead = false + return true + } + return false +} + +func (d *cborDecDriver) decUint() (ui uint64) { + v := d.bd & 0x1f + if v <= 0x17 { + ui = uint64(v) + } else { + if v == 0x18 { + ui = uint64(d.r.readn1()) + } else if v == 0x19 { + ui = uint64(bigen.Uint16(d.r.readx(2))) + } else if v == 0x1a { + ui = uint64(bigen.Uint32(d.r.readx(4))) + } else if v == 0x1b { + ui = uint64(bigen.Uint64(d.r.readx(8))) + } else { + d.d.errorf("decUint: Invalid descriptor: %v", d.bd) + return + } + } + return +} + +func (d *cborDecDriver) decCheckInteger() (neg bool) { + if !d.bdRead { + d.readNextBd() + } + major := d.bd >> 5 + if major == cborMajorUint { + } else if major == cborMajorNegInt { + neg = true + } else { + d.d.errorf("invalid major: %v (bd: %v)", major, d.bd) + return + } + return +} + +func (d *cborDecDriver) DecodeInt(bitsize uint8) (i int64) { + neg := d.decCheckInteger() + ui := d.decUint() + // check if this number can be converted to an int without overflow + var overflow bool + if neg { + if i, overflow = chkOvf.SignedInt(ui + 1); overflow { + d.d.errorf("cbor: overflow converting %v to signed integer", ui+1) + return + } + i = -i + } else { + if i, overflow = chkOvf.SignedInt(ui); overflow { + d.d.errorf("cbor: overflow converting %v to signed integer", ui) + return + } + } + if chkOvf.Int(i, bitsize) { + d.d.errorf("cbor: overflow integer: %v", i) + return + } + d.bdRead = false + return +} + +func (d *cborDecDriver) DecodeUint(bitsize uint8) (ui uint64) { + if d.decCheckInteger() { + d.d.errorf("Assigning negative signed value to unsigned type") + return + } + ui = d.decUint() + if chkOvf.Uint(ui, bitsize) { + d.d.errorf("cbor: overflow integer: %v", ui) + return + } + d.bdRead = false + return +} + +func (d *cborDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) { + if !d.bdRead { + d.readNextBd() + } + if bd := d.bd; bd == cborBdFloat16 { + f = float64(math.Float32frombits(halfFloatToFloatBits(bigen.Uint16(d.r.readx(2))))) + } else if bd == cborBdFloat32 { + f = float64(math.Float32frombits(bigen.Uint32(d.r.readx(4)))) + } else if bd == cborBdFloat64 { + f = math.Float64frombits(bigen.Uint64(d.r.readx(8))) + } else if bd >= cborBaseUint && bd < cborBaseBytes { + f = float64(d.DecodeInt(64)) + } else { + d.d.errorf("Float only valid from float16/32/64: Invalid descriptor: %v", bd) + return + } + if chkOverflow32 && chkOvf.Float32(f) { + d.d.errorf("cbor: float32 overflow: %v", f) + return + } + d.bdRead = false + return +} + +// bool can be decoded from bool only (single byte). +func (d *cborDecDriver) DecodeBool() (b bool) { + if !d.bdRead { + d.readNextBd() + } + if bd := d.bd; bd == cborBdTrue { + b = true + } else if bd == cborBdFalse { + } else { + d.d.errorf("Invalid single-byte value for bool: %s: %x", msgBadDesc, d.bd) + return + } + d.bdRead = false + return +} + +func (d *cborDecDriver) ReadMapStart() (length int) { + d.bdRead = false + if d.bd == cborBdIndefiniteMap { + return -1 + } + return d.decLen() +} + +func (d *cborDecDriver) ReadArrayStart() (length int) { + d.bdRead = false + if d.bd == cborBdIndefiniteArray { + return -1 + } + return d.decLen() +} + +func (d *cborDecDriver) decLen() int { + return int(d.decUint()) +} + +func (d *cborDecDriver) decAppendIndefiniteBytes(bs []byte) []byte { + d.bdRead = false + for { + if d.CheckBreak() { + break + } + if major := d.bd >> 5; major != cborMajorBytes && major != cborMajorText { + d.d.errorf("cbor: expect bytes or string major type in indefinite string/bytes; got: %v, byte: %v", major, d.bd) + return nil + } + n := d.decLen() + oldLen := len(bs) + newLen := oldLen + n + if newLen > cap(bs) { + bs2 := make([]byte, newLen, 2*cap(bs)+n) + copy(bs2, bs) + bs = bs2 + } else { + bs = bs[:newLen] + } + d.r.readb(bs[oldLen:newLen]) + // bs = append(bs, d.r.readn()...) + d.bdRead = false + } + d.bdRead = false + return bs +} + +func (d *cborDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) { + if !d.bdRead { + d.readNextBd() + } + if d.bd == cborBdNil || d.bd == cborBdUndefined { + d.bdRead = false + return nil + } + if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString { + if bs == nil { + return d.decAppendIndefiniteBytes(nil) + } + return d.decAppendIndefiniteBytes(bs[:0]) + } + clen := d.decLen() + d.bdRead = false + if zerocopy { + if d.br { + return d.r.readx(clen) + } else if len(bs) == 0 { + bs = d.b[:] + } + } + return decByteSlice(d.r, clen, bs) +} + +func (d *cborDecDriver) DecodeString() (s string) { + return string(d.DecodeBytes(d.b[:], true, true)) +} + +func (d *cborDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) { + if !d.bdRead { + d.readNextBd() + } + u := d.decUint() + d.bdRead = false + realxtag = u + if ext == nil { + re := rv.(*RawExt) + re.Tag = realxtag + d.d.decode(&re.Value) + } else if xtag != realxtag { + d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", realxtag, xtag) + return + } else { + var v interface{} + d.d.decode(&v) + ext.UpdateExt(rv, v) + } + d.bdRead = false + return +} + +func (d *cborDecDriver) DecodeNaked() { + if !d.bdRead { + d.readNextBd() + } + + n := &d.d.n + var decodeFurther bool + + switch d.bd { + case cborBdNil: + n.v = valueTypeNil + case cborBdFalse: + n.v = valueTypeBool + n.b = false + case cborBdTrue: + n.v = valueTypeBool + n.b = true + case cborBdFloat16, cborBdFloat32: + n.v = valueTypeFloat + n.f = d.DecodeFloat(true) + case cborBdFloat64: + n.v = valueTypeFloat + n.f = d.DecodeFloat(false) + case cborBdIndefiniteBytes: + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) + case cborBdIndefiniteString: + n.v = valueTypeString + n.s = d.DecodeString() + case cborBdIndefiniteArray: + n.v = valueTypeArray + decodeFurther = true + case cborBdIndefiniteMap: + n.v = valueTypeMap + decodeFurther = true + default: + switch { + case d.bd >= cborBaseUint && d.bd < cborBaseNegInt: + if d.h.SignedInteger { + n.v = valueTypeInt + n.i = d.DecodeInt(64) + } else { + n.v = valueTypeUint + n.u = d.DecodeUint(64) + } + case d.bd >= cborBaseNegInt && d.bd < cborBaseBytes: + n.v = valueTypeInt + n.i = d.DecodeInt(64) + case d.bd >= cborBaseBytes && d.bd < cborBaseString: + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) + case d.bd >= cborBaseString && d.bd < cborBaseArray: + n.v = valueTypeString + n.s = d.DecodeString() + case d.bd >= cborBaseArray && d.bd < cborBaseMap: + n.v = valueTypeArray + decodeFurther = true + case d.bd >= cborBaseMap && d.bd < cborBaseTag: + n.v = valueTypeMap + decodeFurther = true + case d.bd >= cborBaseTag && d.bd < cborBaseSimple: + n.v = valueTypeExt + n.u = d.decUint() + n.l = nil + // d.bdRead = false + // d.d.decode(&re.Value) // handled by decode itself. + // decodeFurther = true + default: + d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd) + return + } + } + + if !decodeFurther { + d.bdRead = false + } + return +} + +// ------------------------- + +// CborHandle is a Handle for the CBOR encoding format, +// defined at http://tools.ietf.org/html/rfc7049 and documented further at http://cbor.io . +// +// CBOR is comprehensively supported, including support for: +// - indefinite-length arrays/maps/bytes/strings +// - (extension) tags in range 0..0xffff (0 .. 65535) +// - half, single and double-precision floats +// - all numbers (1, 2, 4 and 8-byte signed and unsigned integers) +// - nil, true, false, ... +// - arrays and maps, bytes and text strings +// +// None of the optional extensions (with tags) defined in the spec are supported out-of-the-box. +// Users can implement them as needed (using SetExt), including spec-documented ones: +// - timestamp, BigNum, BigFloat, Decimals, Encoded Text (e.g. URL, regexp, base64, MIME Message), etc. +// +// To encode with indefinite lengths (streaming), users will use +// (Must)Encode methods of *Encoder, along with writing CborStreamXXX constants. +// +// For example, to encode "one-byte" as an indefinite length string: +// var buf bytes.Buffer +// e := NewEncoder(&buf, new(CborHandle)) +// buf.WriteByte(CborStreamString) +// e.MustEncode("one-") +// e.MustEncode("byte") +// buf.WriteByte(CborStreamBreak) +// encodedBytes := buf.Bytes() +// var vv interface{} +// NewDecoderBytes(buf.Bytes(), new(CborHandle)).MustDecode(&vv) +// // Now, vv contains the same string "one-byte" +// +type CborHandle struct { + binaryEncodingType + BasicHandle +} + +func (h *CborHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) { + return h.SetExt(rt, tag, &setExtWrapper{i: ext}) +} + +func (h *CborHandle) newEncDriver(e *Encoder) encDriver { + return &cborEncDriver{e: e, w: e.w, h: h} +} + +func (h *CborHandle) newDecDriver(d *Decoder) decDriver { + return &cborDecDriver{d: d, r: d.r, h: h, br: d.bytes} +} + +func (e *cborEncDriver) reset() { + e.w = e.e.w +} + +func (d *cborDecDriver) reset() { + d.r = d.d.r + d.bd, d.bdRead = 0, false +} + +var _ decDriver = (*cborDecDriver)(nil) +var _ encDriver = (*cborEncDriver)(nil) diff --git a/vendor/github.com/ugorji/go/codec/decode.go b/vendor/github.com/ugorji/go/codec/decode.go new file mode 100644 index 00000000..c7a9a4d9 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/decode.go @@ -0,0 +1,2019 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "encoding" + "errors" + "fmt" + "io" + "reflect" + "time" +) + +// Some tagging information for error messages. +const ( + msgBadDesc = "Unrecognized descriptor byte" + msgDecCannotExpandArr = "cannot expand go array from %v to stream length: %v" +) + +var ( + onlyMapOrArrayCanDecodeIntoStructErr = errors.New("only encoded map or array can be decoded into a struct") + cannotDecodeIntoNilErr = errors.New("cannot decode into nil") +) + +// decReader abstracts the reading source, allowing implementations that can +// read from an io.Reader or directly off a byte slice with zero-copying. +type decReader interface { + unreadn1() + + // readx will use the implementation scratch buffer if possible i.e. n < len(scratchbuf), OR + // just return a view of the []byte being decoded from. + // Ensure you call detachZeroCopyBytes later if this needs to be sent outside codec control. + readx(n int) []byte + readb([]byte) + readn1() uint8 + readn1eof() (v uint8, eof bool) + numread() int // number of bytes read + track() + stopTrack() []byte +} + +type decReaderByteScanner interface { + io.Reader + io.ByteScanner +} + +type decDriver interface { + // this will check if the next token is a break. + CheckBreak() bool + TryDecodeAsNil() bool + // vt is one of: Bytes, String, Nil, Slice or Map. Return unSet if not known. + ContainerType() (vt valueType) + IsBuiltinType(rt uintptr) bool + DecodeBuiltin(rt uintptr, v interface{}) + + // DecodeNaked will decode primitives (number, bool, string, []byte) and RawExt. + // For maps and arrays, it will not do the decoding in-band, but will signal + // the decoder, so that is done later, by setting the decNaked.valueType field. + // + // Note: Numbers are decoded as int64, uint64, float64 only (no smaller sized number types). + // for extensions, DecodeNaked must read the tag and the []byte if it exists. + // if the []byte is not read, then kInterfaceNaked will treat it as a Handle + // that stores the subsequent value in-band, and complete reading the RawExt. + // + // extensions should also use readx to decode them, for efficiency. + // kInterface will extract the detached byte slice if it has to pass it outside its realm. + DecodeNaked() + DecodeInt(bitsize uint8) (i int64) + DecodeUint(bitsize uint8) (ui uint64) + DecodeFloat(chkOverflow32 bool) (f float64) + DecodeBool() (b bool) + // DecodeString can also decode symbols. + // It looks redundant as DecodeBytes is available. + // However, some codecs (e.g. binc) support symbols and can + // return a pre-stored string value, meaning that it can bypass + // the cost of []byte->string conversion. + DecodeString() (s string) + + // DecodeBytes may be called directly, without going through reflection. + // Consequently, it must be designed to handle possible nil. + DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) + + // decodeExt will decode into a *RawExt or into an extension. + DecodeExt(v interface{}, xtag uint64, ext Ext) (realxtag uint64) + // decodeExt(verifyTag bool, tag byte) (xtag byte, xbs []byte) + ReadMapStart() int + ReadArrayStart() int + + reset() + uncacheRead() +} + +type decNoSeparator struct{} + +func (_ decNoSeparator) ReadEnd() {} +func (_ decNoSeparator) uncacheRead() {} + +type DecodeOptions struct { + // MapType specifies type to use during schema-less decoding of a map in the stream. + // If nil, we use map[interface{}]interface{} + MapType reflect.Type + + // SliceType specifies type to use during schema-less decoding of an array in the stream. + // If nil, we use []interface{} + SliceType reflect.Type + + // MaxInitLen defines the initial length that we "make" a collection (slice, chan or map) with. + // If 0 or negative, we default to a sensible value based on the size of an element in the collection. + // + // For example, when decoding, a stream may say that it has MAX_UINT elements. + // We should not auto-matically provision a slice of that length, to prevent Out-Of-Memory crash. + // Instead, we provision up to MaxInitLen, fill that up, and start appending after that. + MaxInitLen int + + // If ErrorIfNoField, return an error when decoding a map + // from a codec stream into a struct, and no matching struct field is found. + ErrorIfNoField bool + + // If ErrorIfNoArrayExpand, return an error when decoding a slice/array that cannot be expanded. + // For example, the stream contains an array of 8 items, but you are decoding into a [4]T array, + // or you are decoding into a slice of length 4 which is non-addressable (and so cannot be set). + ErrorIfNoArrayExpand bool + + // If SignedInteger, use the int64 during schema-less decoding of unsigned values (not uint64). + SignedInteger bool + + // MapValueReset controls how we decode into a map value. + // + // By default, we MAY retrieve the mapping for a key, and then decode into that. + // However, especially with big maps, that retrieval may be expensive and unnecessary + // if the stream already contains all that is necessary to recreate the value. + // + // If true, we will never retrieve the previous mapping, + // but rather decode into a new value and set that in the map. + // + // If false, we will retrieve the previous mapping if necessary e.g. + // the previous mapping is a pointer, or is a struct or array with pre-set state, + // or is an interface. + MapValueReset bool + + // InterfaceReset controls how we decode into an interface. + // + // By default, when we see a field that is an interface{...}, + // or a map with interface{...} value, we will attempt decoding into the + // "contained" value. + // + // However, this prevents us from reading a string into an interface{} + // that formerly contained a number. + // + // If true, we will decode into a new "blank" value, and set that in the interface. + // If false, we will decode into whatever is contained in the interface. + InterfaceReset bool + + // InternString controls interning of strings during decoding. + // + // Some handles, e.g. json, typically will read map keys as strings. + // If the set of keys are finite, it may help reduce allocation to + // look them up from a map (than to allocate them afresh). + // + // Note: Handles will be smart when using the intern functionality. + // So everything will not be interned. + InternString bool +} + +// ------------------------------------ + +// ioDecByteScanner implements Read(), ReadByte(...), UnreadByte(...) methods +// of io.Reader, io.ByteScanner. +type ioDecByteScanner struct { + r io.Reader + l byte // last byte + ls byte // last byte status. 0: init-canDoNothing, 1: canRead, 2: canUnread + b [1]byte // tiny buffer for reading single bytes +} + +func (z *ioDecByteScanner) Read(p []byte) (n int, err error) { + var firstByte bool + if z.ls == 1 { + z.ls = 2 + p[0] = z.l + if len(p) == 1 { + n = 1 + return + } + firstByte = true + p = p[1:] + } + n, err = z.r.Read(p) + if n > 0 { + if err == io.EOF && n == len(p) { + err = nil // read was successful, so postpone EOF (till next time) + } + z.l = p[n-1] + z.ls = 2 + } + if firstByte { + n++ + } + return +} + +func (z *ioDecByteScanner) ReadByte() (c byte, err error) { + n, err := z.Read(z.b[:]) + if n == 1 { + c = z.b[0] + if err == io.EOF { + err = nil // read was successful, so postpone EOF (till next time) + } + } + return +} + +func (z *ioDecByteScanner) UnreadByte() (err error) { + x := z.ls + if x == 0 { + err = errors.New("cannot unread - nothing has been read") + } else if x == 1 { + err = errors.New("cannot unread - last byte has not been read") + } else if x == 2 { + z.ls = 1 + } + return +} + +// ioDecReader is a decReader that reads off an io.Reader +type ioDecReader struct { + br decReaderByteScanner + // temp byte array re-used internally for efficiency during read. + // shares buffer with Decoder, so we keep size of struct within 8 words. + x *[scratchByteArrayLen]byte + bs ioDecByteScanner + n int // num read + tr []byte // tracking bytes read + trb bool +} + +func (z *ioDecReader) numread() int { + return z.n +} + +func (z *ioDecReader) readx(n int) (bs []byte) { + if n <= 0 { + return + } + if n < len(z.x) { + bs = z.x[:n] + } else { + bs = make([]byte, n) + } + if _, err := io.ReadAtLeast(z.br, bs, n); err != nil { + panic(err) + } + z.n += len(bs) + if z.trb { + z.tr = append(z.tr, bs...) + } + return +} + +func (z *ioDecReader) readb(bs []byte) { + if len(bs) == 0 { + return + } + n, err := io.ReadAtLeast(z.br, bs, len(bs)) + z.n += n + if err != nil { + panic(err) + } + if z.trb { + z.tr = append(z.tr, bs...) + } +} + +func (z *ioDecReader) readn1() (b uint8) { + b, err := z.br.ReadByte() + if err != nil { + panic(err) + } + z.n++ + if z.trb { + z.tr = append(z.tr, b) + } + return b +} + +func (z *ioDecReader) readn1eof() (b uint8, eof bool) { + b, err := z.br.ReadByte() + if err == nil { + z.n++ + if z.trb { + z.tr = append(z.tr, b) + } + } else if err == io.EOF { + eof = true + } else { + panic(err) + } + return +} + +func (z *ioDecReader) unreadn1() { + err := z.br.UnreadByte() + if err != nil { + panic(err) + } + z.n-- + if z.trb { + if l := len(z.tr) - 1; l >= 0 { + z.tr = z.tr[:l] + } + } +} + +func (z *ioDecReader) track() { + if z.tr != nil { + z.tr = z.tr[:0] + } + z.trb = true +} + +func (z *ioDecReader) stopTrack() (bs []byte) { + z.trb = false + return z.tr +} + +// ------------------------------------ + +var bytesDecReaderCannotUnreadErr = errors.New("cannot unread last byte read") + +// bytesDecReader is a decReader that reads off a byte slice with zero copying +type bytesDecReader struct { + b []byte // data + c int // cursor + a int // available + t int // track start +} + +func (z *bytesDecReader) reset(in []byte) { + z.b = in + z.a = len(in) + z.c = 0 + z.t = 0 +} + +func (z *bytesDecReader) numread() int { + return z.c +} + +func (z *bytesDecReader) unreadn1() { + if z.c == 0 || len(z.b) == 0 { + panic(bytesDecReaderCannotUnreadErr) + } + z.c-- + z.a++ + return +} + +func (z *bytesDecReader) readx(n int) (bs []byte) { + // slicing from a non-constant start position is more expensive, + // as more computation is required to decipher the pointer start position. + // However, we do it only once, and it's better than reslicing both z.b and return value. + + if n <= 0 { + } else if z.a == 0 { + panic(io.EOF) + } else if n > z.a { + panic(io.ErrUnexpectedEOF) + } else { + c0 := z.c + z.c = c0 + n + z.a = z.a - n + bs = z.b[c0:z.c] + } + return +} + +func (z *bytesDecReader) readn1() (v uint8) { + if z.a == 0 { + panic(io.EOF) + } + v = z.b[z.c] + z.c++ + z.a-- + return +} + +func (z *bytesDecReader) readn1eof() (v uint8, eof bool) { + if z.a == 0 { + eof = true + return + } + v = z.b[z.c] + z.c++ + z.a-- + return +} + +func (z *bytesDecReader) readb(bs []byte) { + copy(bs, z.readx(len(bs))) +} + +func (z *bytesDecReader) track() { + z.t = z.c +} + +func (z *bytesDecReader) stopTrack() (bs []byte) { + return z.b[z.t:z.c] +} + +// ------------------------------------ + +type decFnInfo struct { + d *Decoder + ti *typeInfo + xfFn Ext + xfTag uint64 + seq seqType +} + +// ---------------------------------------- + +type decFn struct { + i decFnInfo + f func(*decFnInfo, reflect.Value) +} + +func (f *decFnInfo) builtin(rv reflect.Value) { + f.d.d.DecodeBuiltin(f.ti.rtid, rv.Addr().Interface()) +} + +func (f *decFnInfo) rawExt(rv reflect.Value) { + f.d.d.DecodeExt(rv.Addr().Interface(), 0, nil) +} + +func (f *decFnInfo) ext(rv reflect.Value) { + f.d.d.DecodeExt(rv.Addr().Interface(), f.xfTag, f.xfFn) +} + +func (f *decFnInfo) getValueForUnmarshalInterface(rv reflect.Value, indir int8) (v interface{}) { + if indir == -1 { + v = rv.Addr().Interface() + } else if indir == 0 { + v = rv.Interface() + } else { + for j := int8(0); j < indir; j++ { + if rv.IsNil() { + rv.Set(reflect.New(rv.Type().Elem())) + } + rv = rv.Elem() + } + v = rv.Interface() + } + return +} + +func (f *decFnInfo) selferUnmarshal(rv reflect.Value) { + f.getValueForUnmarshalInterface(rv, f.ti.csIndir).(Selfer).CodecDecodeSelf(f.d) +} + +func (f *decFnInfo) binaryUnmarshal(rv reflect.Value) { + bm := f.getValueForUnmarshalInterface(rv, f.ti.bunmIndir).(encoding.BinaryUnmarshaler) + xbs := f.d.d.DecodeBytes(nil, false, true) + if fnerr := bm.UnmarshalBinary(xbs); fnerr != nil { + panic(fnerr) + } +} + +func (f *decFnInfo) textUnmarshal(rv reflect.Value) { + tm := f.getValueForUnmarshalInterface(rv, f.ti.tunmIndir).(encoding.TextUnmarshaler) + fnerr := tm.UnmarshalText(f.d.d.DecodeBytes(f.d.b[:], true, true)) + if fnerr != nil { + panic(fnerr) + } +} + +func (f *decFnInfo) jsonUnmarshal(rv reflect.Value) { + tm := f.getValueForUnmarshalInterface(rv, f.ti.junmIndir).(jsonUnmarshaler) + // bs := f.d.d.DecodeBytes(f.d.b[:], true, true) + // grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself. + fnerr := tm.UnmarshalJSON(f.d.nextValueBytes()) + if fnerr != nil { + panic(fnerr) + } +} + +func (f *decFnInfo) kErr(rv reflect.Value) { + f.d.errorf("no decoding function defined for kind %v", rv.Kind()) +} + +func (f *decFnInfo) kString(rv reflect.Value) { + rv.SetString(f.d.d.DecodeString()) +} + +func (f *decFnInfo) kBool(rv reflect.Value) { + rv.SetBool(f.d.d.DecodeBool()) +} + +func (f *decFnInfo) kInt(rv reflect.Value) { + rv.SetInt(f.d.d.DecodeInt(intBitsize)) +} + +func (f *decFnInfo) kInt64(rv reflect.Value) { + rv.SetInt(f.d.d.DecodeInt(64)) +} + +func (f *decFnInfo) kInt32(rv reflect.Value) { + rv.SetInt(f.d.d.DecodeInt(32)) +} + +func (f *decFnInfo) kInt8(rv reflect.Value) { + rv.SetInt(f.d.d.DecodeInt(8)) +} + +func (f *decFnInfo) kInt16(rv reflect.Value) { + rv.SetInt(f.d.d.DecodeInt(16)) +} + +func (f *decFnInfo) kFloat32(rv reflect.Value) { + rv.SetFloat(f.d.d.DecodeFloat(true)) +} + +func (f *decFnInfo) kFloat64(rv reflect.Value) { + rv.SetFloat(f.d.d.DecodeFloat(false)) +} + +func (f *decFnInfo) kUint8(rv reflect.Value) { + rv.SetUint(f.d.d.DecodeUint(8)) +} + +func (f *decFnInfo) kUint64(rv reflect.Value) { + rv.SetUint(f.d.d.DecodeUint(64)) +} + +func (f *decFnInfo) kUint(rv reflect.Value) { + rv.SetUint(f.d.d.DecodeUint(uintBitsize)) +} + +func (f *decFnInfo) kUintptr(rv reflect.Value) { + rv.SetUint(f.d.d.DecodeUint(uintBitsize)) +} + +func (f *decFnInfo) kUint32(rv reflect.Value) { + rv.SetUint(f.d.d.DecodeUint(32)) +} + +func (f *decFnInfo) kUint16(rv reflect.Value) { + rv.SetUint(f.d.d.DecodeUint(16)) +} + +// func (f *decFnInfo) kPtr(rv reflect.Value) { +// debugf(">>>>>>> ??? decode kPtr called - shouldn't get called") +// if rv.IsNil() { +// rv.Set(reflect.New(rv.Type().Elem())) +// } +// f.d.decodeValue(rv.Elem()) +// } + +// var kIntfCtr uint64 + +func (f *decFnInfo) kInterfaceNaked() (rvn reflect.Value) { + // nil interface: + // use some hieristics to decode it appropriately + // based on the detected next value in the stream. + d := f.d + d.d.DecodeNaked() + n := &d.n + if n.v == valueTypeNil { + return + } + // We cannot decode non-nil stream value into nil interface with methods (e.g. io.Reader). + // if num := f.ti.rt.NumMethod(); num > 0 { + if f.ti.numMeth > 0 { + d.errorf("cannot decode non-nil codec value into nil %v (%v methods)", f.ti.rt, f.ti.numMeth) + return + } + // var useRvn bool + switch n.v { + case valueTypeMap: + // if d.h.MapType == nil || d.h.MapType == mapIntfIntfTyp { + // } else if d.h.MapType == mapStrIntfTyp { // for json performance + // } + if d.mtid == 0 || d.mtid == mapIntfIntfTypId { + l := len(n.ms) + n.ms = append(n.ms, nil) + var v2 interface{} = &n.ms[l] + d.decode(v2) + rvn = reflect.ValueOf(v2).Elem() + n.ms = n.ms[:l] + } else if d.mtid == mapStrIntfTypId { // for json performance + l := len(n.ns) + n.ns = append(n.ns, nil) + var v2 interface{} = &n.ns[l] + d.decode(v2) + rvn = reflect.ValueOf(v2).Elem() + n.ns = n.ns[:l] + } else { + rvn = reflect.New(d.h.MapType).Elem() + d.decodeValue(rvn, nil) + } + case valueTypeArray: + // if d.h.SliceType == nil || d.h.SliceType == intfSliceTyp { + if d.stid == 0 || d.stid == intfSliceTypId { + l := len(n.ss) + n.ss = append(n.ss, nil) + var v2 interface{} = &n.ss[l] + d.decode(v2) + rvn = reflect.ValueOf(v2).Elem() + n.ss = n.ss[:l] + } else { + rvn = reflect.New(d.h.SliceType).Elem() + d.decodeValue(rvn, nil) + } + case valueTypeExt: + var v interface{} + tag, bytes := n.u, n.l // calling decode below might taint the values + if bytes == nil { + l := len(n.is) + n.is = append(n.is, nil) + v2 := &n.is[l] + d.decode(v2) + v = *v2 + n.is = n.is[:l] + } + bfn := d.h.getExtForTag(tag) + if bfn == nil { + var re RawExt + re.Tag = tag + re.Data = detachZeroCopyBytes(d.bytes, nil, bytes) + rvn = reflect.ValueOf(re) + } else { + rvnA := reflect.New(bfn.rt) + rvn = rvnA.Elem() + if bytes != nil { + bfn.ext.ReadExt(rvnA.Interface(), bytes) + } else { + bfn.ext.UpdateExt(rvnA.Interface(), v) + } + } + case valueTypeNil: + // no-op + case valueTypeInt: + rvn = reflect.ValueOf(&n.i).Elem() + case valueTypeUint: + rvn = reflect.ValueOf(&n.u).Elem() + case valueTypeFloat: + rvn = reflect.ValueOf(&n.f).Elem() + case valueTypeBool: + rvn = reflect.ValueOf(&n.b).Elem() + case valueTypeString, valueTypeSymbol: + rvn = reflect.ValueOf(&n.s).Elem() + case valueTypeBytes: + rvn = reflect.ValueOf(&n.l).Elem() + case valueTypeTimestamp: + rvn = reflect.ValueOf(&n.t).Elem() + default: + panic(fmt.Errorf("kInterfaceNaked: unexpected valueType: %d", n.v)) + } + return +} + +func (f *decFnInfo) kInterface(rv reflect.Value) { + // debugf("\t===> kInterface") + + // Note: + // A consequence of how kInterface works, is that + // if an interface already contains something, we try + // to decode into what was there before. + // We do not replace with a generic value (as got from decodeNaked). + + var rvn reflect.Value + if rv.IsNil() { + rvn = f.kInterfaceNaked() + if rvn.IsValid() { + rv.Set(rvn) + } + } else if f.d.h.InterfaceReset { + rvn = f.kInterfaceNaked() + if rvn.IsValid() { + rv.Set(rvn) + } else { + // reset to zero value based on current type in there. + rv.Set(reflect.Zero(rv.Elem().Type())) + } + } else { + rvn = rv.Elem() + // Note: interface{} is settable, but underlying type may not be. + // Consequently, we have to set the reflect.Value directly. + // if underlying type is settable (e.g. ptr or interface), + // we just decode into it. + // Else we create a settable value, decode into it, and set on the interface. + if rvn.CanSet() { + f.d.decodeValue(rvn, nil) + } else { + rvn2 := reflect.New(rvn.Type()).Elem() + rvn2.Set(rvn) + f.d.decodeValue(rvn2, nil) + rv.Set(rvn2) + } + } +} + +func (f *decFnInfo) kStruct(rv reflect.Value) { + fti := f.ti + d := f.d + dd := d.d + cr := d.cr + ctyp := dd.ContainerType() + if ctyp == valueTypeMap { + containerLen := dd.ReadMapStart() + if containerLen == 0 { + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return + } + tisfi := fti.sfi + hasLen := containerLen >= 0 + if hasLen { + for j := 0; j < containerLen; j++ { + // rvkencname := dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapKey) + } + rvkencname := stringView(dd.DecodeBytes(f.d.b[:], true, true)) + // rvksi := ti.getForEncName(rvkencname) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if k := fti.indexForEncName(rvkencname); k > -1 { + si := tisfi[k] + if dd.TryDecodeAsNil() { + si.setToZeroValue(rv) + } else { + d.decodeValue(si.field(rv, true), nil) + } + } else { + d.structFieldNotFound(-1, rvkencname) + } + } + } else { + for j := 0; !dd.CheckBreak(); j++ { + // rvkencname := dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapKey) + } + rvkencname := stringView(dd.DecodeBytes(f.d.b[:], true, true)) + // rvksi := ti.getForEncName(rvkencname) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if k := fti.indexForEncName(rvkencname); k > -1 { + si := tisfi[k] + if dd.TryDecodeAsNil() { + si.setToZeroValue(rv) + } else { + d.decodeValue(si.field(rv, true), nil) + } + } else { + d.structFieldNotFound(-1, rvkencname) + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + } else if ctyp == valueTypeArray { + containerLen := dd.ReadArrayStart() + if containerLen == 0 { + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } + return + } + // Not much gain from doing it two ways for array. + // Arrays are not used as much for structs. + hasLen := containerLen >= 0 + for j, si := range fti.sfip { + if hasLen { + if j == containerLen { + break + } + } else if dd.CheckBreak() { + break + } + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + if dd.TryDecodeAsNil() { + si.setToZeroValue(rv) + } else { + d.decodeValue(si.field(rv, true), nil) + } + } + if containerLen > len(fti.sfip) { + // read remaining values and throw away + for j := len(fti.sfip); j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + d.structFieldNotFound(j, "") + } + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } + } else { + f.d.error(onlyMapOrArrayCanDecodeIntoStructErr) + return + } +} + +func (f *decFnInfo) kSlice(rv reflect.Value) { + // A slice can be set from a map or array in stream. + // This way, the order can be kept (as order is lost with map). + ti := f.ti + d := f.d + dd := d.d + rtelem0 := ti.rt.Elem() + ctyp := dd.ContainerType() + if ctyp == valueTypeBytes || ctyp == valueTypeString { + // you can only decode bytes or string in the stream into a slice or array of bytes + if !(ti.rtid == uint8SliceTypId || rtelem0.Kind() == reflect.Uint8) { + f.d.errorf("bytes or string in the stream must be decoded into a slice or array of bytes, not %v", ti.rt) + } + if f.seq == seqTypeChan { + bs2 := dd.DecodeBytes(nil, false, true) + ch := rv.Interface().(chan<- byte) + for _, b := range bs2 { + ch <- b + } + } else { + rvbs := rv.Bytes() + bs2 := dd.DecodeBytes(rvbs, false, false) + if rvbs == nil && bs2 != nil || rvbs != nil && bs2 == nil || len(bs2) != len(rvbs) { + if rv.CanSet() { + rv.SetBytes(bs2) + } else { + copy(rvbs, bs2) + } + } + } + return + } + + // array := f.seq == seqTypeChan + + slh, containerLenS := d.decSliceHelperStart() // only expects valueType(Array|Map) + + // // an array can never return a nil slice. so no need to check f.array here. + if containerLenS == 0 { + if f.seq == seqTypeSlice { + if rv.IsNil() { + rv.Set(reflect.MakeSlice(ti.rt, 0, 0)) + } else { + rv.SetLen(0) + } + } else if f.seq == seqTypeChan { + if rv.IsNil() { + rv.Set(reflect.MakeChan(ti.rt, 0)) + } + } + slh.End() + return + } + + rtelem := rtelem0 + for rtelem.Kind() == reflect.Ptr { + rtelem = rtelem.Elem() + } + fn := d.getDecFn(rtelem, true, true) + + var rv0, rv9 reflect.Value + rv0 = rv + rvChanged := false + + // for j := 0; j < containerLenS; j++ { + var rvlen int + if containerLenS > 0 { // hasLen + if f.seq == seqTypeChan { + if rv.IsNil() { + rvlen, _ = decInferLen(containerLenS, f.d.h.MaxInitLen, int(rtelem0.Size())) + rv.Set(reflect.MakeChan(ti.rt, rvlen)) + } + // handle chan specially: + for j := 0; j < containerLenS; j++ { + rv9 = reflect.New(rtelem0).Elem() + slh.ElemContainerState(j) + d.decodeValue(rv9, fn) + rv.Send(rv9) + } + } else { // slice or array + var truncated bool // says len of sequence is not same as expected number of elements + numToRead := containerLenS // if truncated, reset numToRead + + rvcap := rv.Cap() + rvlen = rv.Len() + if containerLenS > rvcap { + if f.seq == seqTypeArray { + d.arrayCannotExpand(rvlen, containerLenS) + } else { + oldRvlenGtZero := rvlen > 0 + rvlen, truncated = decInferLen(containerLenS, f.d.h.MaxInitLen, int(rtelem0.Size())) + if truncated { + if rvlen <= rvcap { + rv.SetLen(rvlen) + } else { + rv = reflect.MakeSlice(ti.rt, rvlen, rvlen) + rvChanged = true + } + } else { + rv = reflect.MakeSlice(ti.rt, rvlen, rvlen) + rvChanged = true + } + if rvChanged && oldRvlenGtZero && !isImmutableKind(rtelem0.Kind()) { + reflect.Copy(rv, rv0) // only copy up to length NOT cap i.e. rv0.Slice(0, rvcap) + } + rvcap = rvlen + } + numToRead = rvlen + } else if containerLenS != rvlen { + if f.seq == seqTypeSlice { + rv.SetLen(containerLenS) + rvlen = containerLenS + } + } + j := 0 + // we read up to the numToRead + for ; j < numToRead; j++ { + slh.ElemContainerState(j) + d.decodeValue(rv.Index(j), fn) + } + + // if slice, expand and read up to containerLenS (or EOF) iff truncated + // if array, swallow all the rest. + + if f.seq == seqTypeArray { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } else if truncated { // slice was truncated, as chan NOT in this block + for ; j < containerLenS; j++ { + rv = expandSliceValue(rv, 1) + rv9 = rv.Index(j) + if resetSliceElemToZeroValue { + rv9.Set(reflect.Zero(rtelem0)) + } + slh.ElemContainerState(j) + d.decodeValue(rv9, fn) + } + } + } + } else { + rvlen = rv.Len() + j := 0 + for ; !dd.CheckBreak(); j++ { + if f.seq == seqTypeChan { + slh.ElemContainerState(j) + rv9 = reflect.New(rtelem0).Elem() + d.decodeValue(rv9, fn) + rv.Send(rv9) + } else { + // if indefinite, etc, then expand the slice if necessary + var decodeIntoBlank bool + if j >= rvlen { + if f.seq == seqTypeArray { + d.arrayCannotExpand(rvlen, j+1) + decodeIntoBlank = true + } else { // if f.seq == seqTypeSlice + // rv = reflect.Append(rv, reflect.Zero(rtelem0)) // uses append logic, plus varargs + rv = expandSliceValue(rv, 1) + rv9 = rv.Index(j) + // rv.Index(rv.Len() - 1).Set(reflect.Zero(rtelem0)) + if resetSliceElemToZeroValue { + rv9.Set(reflect.Zero(rtelem0)) + } + rvlen++ + rvChanged = true + } + } else { // slice or array + rv9 = rv.Index(j) + } + slh.ElemContainerState(j) + if decodeIntoBlank { + d.swallow() + } else { // seqTypeSlice + d.decodeValue(rv9, fn) + } + } + } + if f.seq == seqTypeSlice { + if j < rvlen { + rv.SetLen(j) + } else if j == 0 && rv.IsNil() { + rv = reflect.MakeSlice(ti.rt, 0, 0) + rvChanged = true + } + } + } + slh.End() + + if rvChanged { + rv0.Set(rv) + } +} + +func (f *decFnInfo) kArray(rv reflect.Value) { + // f.d.decodeValue(rv.Slice(0, rv.Len())) + f.kSlice(rv.Slice(0, rv.Len())) +} + +func (f *decFnInfo) kMap(rv reflect.Value) { + d := f.d + dd := d.d + containerLen := dd.ReadMapStart() + cr := d.cr + ti := f.ti + if rv.IsNil() { + rv.Set(reflect.MakeMap(ti.rt)) + } + + if containerLen == 0 { + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return + } + + ktype, vtype := ti.rt.Key(), ti.rt.Elem() + ktypeId := reflect.ValueOf(ktype).Pointer() + vtypeKind := vtype.Kind() + var keyFn, valFn *decFn + var xtyp reflect.Type + for xtyp = ktype; xtyp.Kind() == reflect.Ptr; xtyp = xtyp.Elem() { + } + keyFn = d.getDecFn(xtyp, true, true) + for xtyp = vtype; xtyp.Kind() == reflect.Ptr; xtyp = xtyp.Elem() { + } + valFn = d.getDecFn(xtyp, true, true) + var mapGet, mapSet bool + if !f.d.h.MapValueReset { + // if pointer, mapGet = true + // if interface, mapGet = true if !DecodeNakedAlways (else false) + // if builtin, mapGet = false + // else mapGet = true + if vtypeKind == reflect.Ptr { + mapGet = true + } else if vtypeKind == reflect.Interface { + if !f.d.h.InterfaceReset { + mapGet = true + } + } else if !isImmutableKind(vtypeKind) { + mapGet = true + } + } + + var rvk, rvv, rvz reflect.Value + + // for j := 0; j < containerLen; j++ { + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + rvk = reflect.New(ktype).Elem() + if cr != nil { + cr.sendContainerState(containerMapKey) + } + d.decodeValue(rvk, keyFn) + + // special case if a byte array. + if ktypeId == intfTypId { + rvk = rvk.Elem() + if rvk.Type() == uint8SliceTyp { + rvk = reflect.ValueOf(d.string(rvk.Bytes())) + } + } + mapSet = true // set to false if u do a get, and its a pointer, and exists + if mapGet { + rvv = rv.MapIndex(rvk) + if rvv.IsValid() { + if vtypeKind == reflect.Ptr { + mapSet = false + } + } else { + if rvz.IsValid() { + rvz.Set(reflect.Zero(vtype)) + } else { + rvz = reflect.New(vtype).Elem() + } + rvv = rvz + } + } else { + if rvz.IsValid() { + rvz.Set(reflect.Zero(vtype)) + } else { + rvz = reflect.New(vtype).Elem() + } + rvv = rvz + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + d.decodeValue(rvv, valFn) + if mapSet { + rv.SetMapIndex(rvk, rvv) + } + } + } else { + for j := 0; !dd.CheckBreak(); j++ { + rvk = reflect.New(ktype).Elem() + if cr != nil { + cr.sendContainerState(containerMapKey) + } + d.decodeValue(rvk, keyFn) + + // special case if a byte array. + if ktypeId == intfTypId { + rvk = rvk.Elem() + if rvk.Type() == uint8SliceTyp { + rvk = reflect.ValueOf(d.string(rvk.Bytes())) + } + } + mapSet = true // set to false if u do a get, and its a pointer, and exists + if mapGet { + rvv = rv.MapIndex(rvk) + if rvv.IsValid() { + if vtypeKind == reflect.Ptr { + mapSet = false + } + } else { + if rvz.IsValid() { + rvz.Set(reflect.Zero(vtype)) + } else { + rvz = reflect.New(vtype).Elem() + } + rvv = rvz + } + } else { + if rvz.IsValid() { + rvz.Set(reflect.Zero(vtype)) + } else { + rvz = reflect.New(vtype).Elem() + } + rvv = rvz + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + d.decodeValue(rvv, valFn) + if mapSet { + rv.SetMapIndex(rvk, rvv) + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +type decRtidFn struct { + rtid uintptr + fn decFn +} + +// decNaked is used to keep track of the primitives decoded. +// Without it, we would have to decode each primitive and wrap it +// in an interface{}, causing an allocation. +// In this model, the primitives are decoded in a "pseudo-atomic" fashion, +// so we can rest assured that no other decoding happens while these +// primitives are being decoded. +// +// maps and arrays are not handled by this mechanism. +// However, RawExt is, and we accommodate for extensions that decode +// RawExt from DecodeNaked, but need to decode the value subsequently. +// kInterfaceNaked and swallow, which call DecodeNaked, handle this caveat. +// +// However, decNaked also keeps some arrays of default maps and slices +// used in DecodeNaked. This way, we can get a pointer to it +// without causing a new heap allocation. +// +// kInterfaceNaked will ensure that there is no allocation for the common +// uses. +type decNaked struct { + // r RawExt // used for RawExt, uint, []byte. + u uint64 + i int64 + f float64 + l []byte + s string + t time.Time + b bool + v valueType + + // stacks for reducing allocation + is []interface{} + ms []map[interface{}]interface{} + ns []map[string]interface{} + ss [][]interface{} + // rs []RawExt + + // keep arrays at the bottom? Chance is that they are not used much. + ia [4]interface{} + ma [4]map[interface{}]interface{} + na [4]map[string]interface{} + sa [4][]interface{} + // ra [2]RawExt +} + +func (n *decNaked) reset() { + if n.ss != nil { + n.ss = n.ss[:0] + } + if n.is != nil { + n.is = n.is[:0] + } + if n.ms != nil { + n.ms = n.ms[:0] + } + if n.ns != nil { + n.ns = n.ns[:0] + } +} + +// A Decoder reads and decodes an object from an input stream in the codec format. +type Decoder struct { + // hopefully, reduce derefencing cost by laying the decReader inside the Decoder. + // Try to put things that go together to fit within a cache line (8 words). + + d decDriver + // NOTE: Decoder shouldn't call it's read methods, + // as the handler MAY need to do some coordination. + r decReader + // sa [initCollectionCap]decRtidFn + h *BasicHandle + hh Handle + + be bool // is binary encoding + bytes bool // is bytes reader + js bool // is json handle + + rb bytesDecReader + ri ioDecReader + cr containerStateRecv + + s []decRtidFn + f map[uintptr]*decFn + + // _ uintptr // for alignment purposes, so next one starts from a cache line + + // cache the mapTypeId and sliceTypeId for faster comparisons + mtid uintptr + stid uintptr + + n decNaked + b [scratchByteArrayLen]byte + is map[string]string // used for interning strings +} + +// NewDecoder returns a Decoder for decoding a stream of bytes from an io.Reader. +// +// For efficiency, Users are encouraged to pass in a memory buffered reader +// (eg bufio.Reader, bytes.Buffer). +func NewDecoder(r io.Reader, h Handle) *Decoder { + d := newDecoder(h) + d.Reset(r) + return d +} + +// NewDecoderBytes returns a Decoder which efficiently decodes directly +// from a byte slice with zero copying. +func NewDecoderBytes(in []byte, h Handle) *Decoder { + d := newDecoder(h) + d.ResetBytes(in) + return d +} + +func newDecoder(h Handle) *Decoder { + d := &Decoder{hh: h, h: h.getBasicHandle(), be: h.isBinary()} + n := &d.n + // n.rs = n.ra[:0] + n.ms = n.ma[:0] + n.is = n.ia[:0] + n.ns = n.na[:0] + n.ss = n.sa[:0] + _, d.js = h.(*JsonHandle) + if d.h.InternString { + d.is = make(map[string]string, 32) + } + d.d = h.newDecDriver(d) + d.cr, _ = d.d.(containerStateRecv) + // d.d = h.newDecDriver(decReaderT{true, &d.rb, &d.ri}) + return d +} + +func (d *Decoder) resetCommon() { + d.n.reset() + d.d.reset() + // reset all things which were cached from the Handle, + // but could be changed. + d.mtid, d.stid = 0, 0 + if d.h.MapType != nil { + d.mtid = reflect.ValueOf(d.h.MapType).Pointer() + } + if d.h.SliceType != nil { + d.stid = reflect.ValueOf(d.h.SliceType).Pointer() + } +} + +func (d *Decoder) Reset(r io.Reader) { + d.ri.x = &d.b + // d.s = d.sa[:0] + d.ri.bs.r = r + var ok bool + d.ri.br, ok = r.(decReaderByteScanner) + if !ok { + d.ri.br = &d.ri.bs + } + d.r = &d.ri + d.resetCommon() +} + +func (d *Decoder) ResetBytes(in []byte) { + // d.s = d.sa[:0] + d.rb.reset(in) + d.r = &d.rb + d.resetCommon() +} + +// func (d *Decoder) sendContainerState(c containerState) { +// if d.cr != nil { +// d.cr.sendContainerState(c) +// } +// } + +// Decode decodes the stream from reader and stores the result in the +// value pointed to by v. v cannot be a nil pointer. v can also be +// a reflect.Value of a pointer. +// +// Note that a pointer to a nil interface is not a nil pointer. +// If you do not know what type of stream it is, pass in a pointer to a nil interface. +// We will decode and store a value in that nil interface. +// +// Sample usages: +// // Decoding into a non-nil typed value +// var f float32 +// err = codec.NewDecoder(r, handle).Decode(&f) +// +// // Decoding into nil interface +// var v interface{} +// dec := codec.NewDecoder(r, handle) +// err = dec.Decode(&v) +// +// When decoding into a nil interface{}, we will decode into an appropriate value based +// on the contents of the stream: +// - Numbers are decoded as float64, int64 or uint64. +// - Other values are decoded appropriately depending on the type: +// bool, string, []byte, time.Time, etc +// - Extensions are decoded as RawExt (if no ext function registered for the tag) +// Configurations exist on the Handle to override defaults +// (e.g. for MapType, SliceType and how to decode raw bytes). +// +// When decoding into a non-nil interface{} value, the mode of encoding is based on the +// type of the value. When a value is seen: +// - If an extension is registered for it, call that extension function +// - If it implements BinaryUnmarshaler, call its UnmarshalBinary(data []byte) error +// - Else decode it based on its reflect.Kind +// +// There are some special rules when decoding into containers (slice/array/map/struct). +// Decode will typically use the stream contents to UPDATE the container. +// - A map can be decoded from a stream map, by updating matching keys. +// - A slice can be decoded from a stream array, +// by updating the first n elements, where n is length of the stream. +// - A slice can be decoded from a stream map, by decoding as if +// it contains a sequence of key-value pairs. +// - A struct can be decoded from a stream map, by updating matching fields. +// - A struct can be decoded from a stream array, +// by updating fields as they occur in the struct (by index). +// +// When decoding a stream map or array with length of 0 into a nil map or slice, +// we reset the destination map or slice to a zero-length value. +// +// However, when decoding a stream nil, we reset the destination container +// to its "zero" value (e.g. nil for slice/map, etc). +// +func (d *Decoder) Decode(v interface{}) (err error) { + defer panicToErr(&err) + d.decode(v) + return +} + +// this is not a smart swallow, as it allocates objects and does unnecessary work. +func (d *Decoder) swallowViaHammer() { + var blank interface{} + d.decodeValue(reflect.ValueOf(&blank).Elem(), nil) +} + +func (d *Decoder) swallow() { + // smarter decode that just swallows the content + dd := d.d + if dd.TryDecodeAsNil() { + return + } + cr := d.cr + switch dd.ContainerType() { + case valueTypeMap: + containerLen := dd.ReadMapStart() + clenGtEqualZero := containerLen >= 0 + for j := 0; ; j++ { + if clenGtEqualZero { + if j >= containerLen { + break + } + } else if dd.CheckBreak() { + break + } + if cr != nil { + cr.sendContainerState(containerMapKey) + } + d.swallow() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + d.swallow() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + case valueTypeArray: + containerLenS := dd.ReadArrayStart() + clenGtEqualZero := containerLenS >= 0 + for j := 0; ; j++ { + if clenGtEqualZero { + if j >= containerLenS { + break + } + } else if dd.CheckBreak() { + break + } + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + d.swallow() + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } + case valueTypeBytes: + dd.DecodeBytes(d.b[:], false, true) + case valueTypeString: + dd.DecodeBytes(d.b[:], true, true) + // dd.DecodeStringAsBytes(d.b[:]) + default: + // these are all primitives, which we can get from decodeNaked + // if RawExt using Value, complete the processing. + dd.DecodeNaked() + if n := &d.n; n.v == valueTypeExt && n.l == nil { + l := len(n.is) + n.is = append(n.is, nil) + v2 := &n.is[l] + d.decode(v2) + n.is = n.is[:l] + } + } +} + +// MustDecode is like Decode, but panics if unable to Decode. +// This provides insight to the code location that triggered the error. +func (d *Decoder) MustDecode(v interface{}) { + d.decode(v) +} + +func (d *Decoder) decode(iv interface{}) { + // if ics, ok := iv.(Selfer); ok { + // ics.CodecDecodeSelf(d) + // return + // } + + if d.d.TryDecodeAsNil() { + switch v := iv.(type) { + case nil: + case *string: + *v = "" + case *bool: + *v = false + case *int: + *v = 0 + case *int8: + *v = 0 + case *int16: + *v = 0 + case *int32: + *v = 0 + case *int64: + *v = 0 + case *uint: + *v = 0 + case *uint8: + *v = 0 + case *uint16: + *v = 0 + case *uint32: + *v = 0 + case *uint64: + *v = 0 + case *float32: + *v = 0 + case *float64: + *v = 0 + case *[]uint8: + *v = nil + case reflect.Value: + if v.Kind() != reflect.Ptr || v.IsNil() { + d.errNotValidPtrValue(v) + } + // d.chkPtrValue(v) + v = v.Elem() + if v.IsValid() { + v.Set(reflect.Zero(v.Type())) + } + default: + rv := reflect.ValueOf(iv) + if rv.Kind() != reflect.Ptr || rv.IsNil() { + d.errNotValidPtrValue(rv) + } + // d.chkPtrValue(rv) + rv = rv.Elem() + if rv.IsValid() { + rv.Set(reflect.Zero(rv.Type())) + } + } + return + } + + switch v := iv.(type) { + case nil: + d.error(cannotDecodeIntoNilErr) + return + + case Selfer: + v.CodecDecodeSelf(d) + + case reflect.Value: + if v.Kind() != reflect.Ptr || v.IsNil() { + d.errNotValidPtrValue(v) + } + // d.chkPtrValue(v) + d.decodeValueNotNil(v.Elem(), nil) + + case *string: + *v = d.d.DecodeString() + case *bool: + *v = d.d.DecodeBool() + case *int: + *v = int(d.d.DecodeInt(intBitsize)) + case *int8: + *v = int8(d.d.DecodeInt(8)) + case *int16: + *v = int16(d.d.DecodeInt(16)) + case *int32: + *v = int32(d.d.DecodeInt(32)) + case *int64: + *v = d.d.DecodeInt(64) + case *uint: + *v = uint(d.d.DecodeUint(uintBitsize)) + case *uint8: + *v = uint8(d.d.DecodeUint(8)) + case *uint16: + *v = uint16(d.d.DecodeUint(16)) + case *uint32: + *v = uint32(d.d.DecodeUint(32)) + case *uint64: + *v = d.d.DecodeUint(64) + case *float32: + *v = float32(d.d.DecodeFloat(true)) + case *float64: + *v = d.d.DecodeFloat(false) + case *[]uint8: + *v = d.d.DecodeBytes(*v, false, false) + + case *interface{}: + d.decodeValueNotNil(reflect.ValueOf(iv).Elem(), nil) + + default: + if !fastpathDecodeTypeSwitch(iv, d) { + d.decodeI(iv, true, false, false, false) + } + } +} + +func (d *Decoder) preDecodeValue(rv reflect.Value, tryNil bool) (rv2 reflect.Value, proceed bool) { + if tryNil && d.d.TryDecodeAsNil() { + // No need to check if a ptr, recursively, to determine + // whether to set value to nil. + // Just always set value to its zero type. + if rv.IsValid() { // rv.CanSet() // always settable, except it's invalid + rv.Set(reflect.Zero(rv.Type())) + } + return + } + + // If stream is not containing a nil value, then we can deref to the base + // non-pointer value, and decode into that. + for rv.Kind() == reflect.Ptr { + if rv.IsNil() { + rv.Set(reflect.New(rv.Type().Elem())) + } + rv = rv.Elem() + } + return rv, true +} + +func (d *Decoder) decodeI(iv interface{}, checkPtr, tryNil, checkFastpath, checkCodecSelfer bool) { + rv := reflect.ValueOf(iv) + if checkPtr { + if rv.Kind() != reflect.Ptr || rv.IsNil() { + d.errNotValidPtrValue(rv) + } + // d.chkPtrValue(rv) + } + rv, proceed := d.preDecodeValue(rv, tryNil) + if proceed { + fn := d.getDecFn(rv.Type(), checkFastpath, checkCodecSelfer) + fn.f(&fn.i, rv) + } +} + +func (d *Decoder) decodeValue(rv reflect.Value, fn *decFn) { + if rv, proceed := d.preDecodeValue(rv, true); proceed { + if fn == nil { + fn = d.getDecFn(rv.Type(), true, true) + } + fn.f(&fn.i, rv) + } +} + +func (d *Decoder) decodeValueNotNil(rv reflect.Value, fn *decFn) { + if rv, proceed := d.preDecodeValue(rv, false); proceed { + if fn == nil { + fn = d.getDecFn(rv.Type(), true, true) + } + fn.f(&fn.i, rv) + } +} + +func (d *Decoder) getDecFn(rt reflect.Type, checkFastpath, checkCodecSelfer bool) (fn *decFn) { + rtid := reflect.ValueOf(rt).Pointer() + + // retrieve or register a focus'ed function for this type + // to eliminate need to do the retrieval multiple times + + // if d.f == nil && d.s == nil { debugf("---->Creating new dec f map for type: %v\n", rt) } + var ok bool + if useMapForCodecCache { + fn, ok = d.f[rtid] + } else { + for i := range d.s { + v := &(d.s[i]) + if v.rtid == rtid { + fn, ok = &(v.fn), true + break + } + } + } + if ok { + return + } + + if useMapForCodecCache { + if d.f == nil { + d.f = make(map[uintptr]*decFn, initCollectionCap) + } + fn = new(decFn) + d.f[rtid] = fn + } else { + if d.s == nil { + d.s = make([]decRtidFn, 0, initCollectionCap) + } + d.s = append(d.s, decRtidFn{rtid: rtid}) + fn = &(d.s[len(d.s)-1]).fn + } + + // debugf("\tCreating new dec fn for type: %v\n", rt) + ti := d.h.getTypeInfo(rtid, rt) + fi := &(fn.i) + fi.d = d + fi.ti = ti + + // An extension can be registered for any type, regardless of the Kind + // (e.g. type BitSet int64, type MyStruct { / * unexported fields * / }, type X []int, etc. + // + // We can't check if it's an extension byte here first, because the user may have + // registered a pointer or non-pointer type, meaning we may have to recurse first + // before matching a mapped type, even though the extension byte is already detected. + // + // NOTE: if decoding into a nil interface{}, we return a non-nil + // value except even if the container registers a length of 0. + if checkCodecSelfer && ti.cs { + fn.f = (*decFnInfo).selferUnmarshal + } else if rtid == rawExtTypId { + fn.f = (*decFnInfo).rawExt + } else if d.d.IsBuiltinType(rtid) { + fn.f = (*decFnInfo).builtin + } else if xfFn := d.h.getExt(rtid); xfFn != nil { + fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext + fn.f = (*decFnInfo).ext + } else if supportMarshalInterfaces && d.be && ti.bunm { + fn.f = (*decFnInfo).binaryUnmarshal + } else if supportMarshalInterfaces && !d.be && d.js && ti.junm { + //If JSON, we should check JSONUnmarshal before textUnmarshal + fn.f = (*decFnInfo).jsonUnmarshal + } else if supportMarshalInterfaces && !d.be && ti.tunm { + fn.f = (*decFnInfo).textUnmarshal + } else { + rk := rt.Kind() + if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) { + if rt.PkgPath() == "" { + if idx := fastpathAV.index(rtid); idx != -1 { + fn.f = fastpathAV[idx].decfn + } + } else { + // use mapping for underlying type if there + ok = false + var rtu reflect.Type + if rk == reflect.Map { + rtu = reflect.MapOf(rt.Key(), rt.Elem()) + } else { + rtu = reflect.SliceOf(rt.Elem()) + } + rtuid := reflect.ValueOf(rtu).Pointer() + if idx := fastpathAV.index(rtuid); idx != -1 { + xfnf := fastpathAV[idx].decfn + xrt := fastpathAV[idx].rt + fn.f = func(xf *decFnInfo, xrv reflect.Value) { + // xfnf(xf, xrv.Convert(xrt)) + xfnf(xf, xrv.Addr().Convert(reflect.PtrTo(xrt)).Elem()) + } + } + } + } + if fn.f == nil { + switch rk { + case reflect.String: + fn.f = (*decFnInfo).kString + case reflect.Bool: + fn.f = (*decFnInfo).kBool + case reflect.Int: + fn.f = (*decFnInfo).kInt + case reflect.Int64: + fn.f = (*decFnInfo).kInt64 + case reflect.Int32: + fn.f = (*decFnInfo).kInt32 + case reflect.Int8: + fn.f = (*decFnInfo).kInt8 + case reflect.Int16: + fn.f = (*decFnInfo).kInt16 + case reflect.Float32: + fn.f = (*decFnInfo).kFloat32 + case reflect.Float64: + fn.f = (*decFnInfo).kFloat64 + case reflect.Uint8: + fn.f = (*decFnInfo).kUint8 + case reflect.Uint64: + fn.f = (*decFnInfo).kUint64 + case reflect.Uint: + fn.f = (*decFnInfo).kUint + case reflect.Uint32: + fn.f = (*decFnInfo).kUint32 + case reflect.Uint16: + fn.f = (*decFnInfo).kUint16 + // case reflect.Ptr: + // fn.f = (*decFnInfo).kPtr + case reflect.Uintptr: + fn.f = (*decFnInfo).kUintptr + case reflect.Interface: + fn.f = (*decFnInfo).kInterface + case reflect.Struct: + fn.f = (*decFnInfo).kStruct + case reflect.Chan: + fi.seq = seqTypeChan + fn.f = (*decFnInfo).kSlice + case reflect.Slice: + fi.seq = seqTypeSlice + fn.f = (*decFnInfo).kSlice + case reflect.Array: + fi.seq = seqTypeArray + fn.f = (*decFnInfo).kArray + case reflect.Map: + fn.f = (*decFnInfo).kMap + default: + fn.f = (*decFnInfo).kErr + } + } + } + + return +} + +func (d *Decoder) structFieldNotFound(index int, rvkencname string) { + // NOTE: rvkencname may be a stringView, so don't pass it to another function. + if d.h.ErrorIfNoField { + if index >= 0 { + d.errorf("no matching struct field found when decoding stream array at index %v", index) + return + } else if rvkencname != "" { + d.errorf("no matching struct field found when decoding stream map with key " + rvkencname) + return + } + } + d.swallow() +} + +func (d *Decoder) arrayCannotExpand(sliceLen, streamLen int) { + if d.h.ErrorIfNoArrayExpand { + d.errorf("cannot expand array len during decode from %v to %v", sliceLen, streamLen) + } +} + +func (d *Decoder) chkPtrValue(rv reflect.Value) { + // We can only decode into a non-nil pointer + if rv.Kind() == reflect.Ptr && !rv.IsNil() { + return + } + d.errNotValidPtrValue(rv) +} + +func (d *Decoder) errNotValidPtrValue(rv reflect.Value) { + if !rv.IsValid() { + d.error(cannotDecodeIntoNilErr) + return + } + if !rv.CanInterface() { + d.errorf("cannot decode into a value without an interface: %v", rv) + return + } + rvi := rv.Interface() + d.errorf("cannot decode into non-pointer or nil pointer. Got: %v, %T, %v", rv.Kind(), rvi, rvi) +} + +func (d *Decoder) error(err error) { + panic(err) +} + +func (d *Decoder) errorf(format string, params ...interface{}) { + params2 := make([]interface{}, len(params)+1) + params2[0] = d.r.numread() + copy(params2[1:], params) + err := fmt.Errorf("[pos %d]: "+format, params2...) + panic(err) +} + +func (d *Decoder) string(v []byte) (s string) { + if d.is != nil { + s, ok := d.is[string(v)] // no allocation here. + if !ok { + s = string(v) + d.is[s] = s + } + return s + } + return string(v) // don't return stringView, as we need a real string here. +} + +func (d *Decoder) intern(s string) { + if d.is != nil { + d.is[s] = s + } +} + +// nextValueBytes returns the next value in the stream as a set of bytes. +func (d *Decoder) nextValueBytes() []byte { + d.d.uncacheRead() + d.r.track() + d.swallow() + return d.r.stopTrack() +} + +// -------------------------------------------------- + +// decSliceHelper assists when decoding into a slice, from a map or an array in the stream. +// A slice can be set from a map or array in stream. This supports the MapBySlice interface. +type decSliceHelper struct { + d *Decoder + // ct valueType + array bool +} + +func (d *Decoder) decSliceHelperStart() (x decSliceHelper, clen int) { + dd := d.d + ctyp := dd.ContainerType() + if ctyp == valueTypeArray { + x.array = true + clen = dd.ReadArrayStart() + } else if ctyp == valueTypeMap { + clen = dd.ReadMapStart() * 2 + } else { + d.errorf("only encoded map or array can be decoded into a slice (%d)", ctyp) + } + // x.ct = ctyp + x.d = d + return +} + +func (x decSliceHelper) End() { + cr := x.d.cr + if cr == nil { + return + } + if x.array { + cr.sendContainerState(containerArrayEnd) + } else { + cr.sendContainerState(containerMapEnd) + } +} + +func (x decSliceHelper) ElemContainerState(index int) { + cr := x.d.cr + if cr == nil { + return + } + if x.array { + cr.sendContainerState(containerArrayElem) + } else { + if index%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } +} + +func decByteSlice(r decReader, clen int, bs []byte) (bsOut []byte) { + if clen == 0 { + return zeroByteSlice + } + if len(bs) == clen { + bsOut = bs + } else if cap(bs) >= clen { + bsOut = bs[:clen] + } else { + bsOut = make([]byte, clen) + } + r.readb(bsOut) + return +} + +func detachZeroCopyBytes(isBytesReader bool, dest []byte, in []byte) (out []byte) { + if xlen := len(in); xlen > 0 { + if isBytesReader || xlen <= scratchByteArrayLen { + if cap(dest) >= xlen { + out = dest[:xlen] + } else { + out = make([]byte, xlen) + } + copy(out, in) + return + } + } + return in +} + +// decInferLen will infer a sensible length, given the following: +// - clen: length wanted. +// - maxlen: max length to be returned. +// if <= 0, it is unset, and we infer it based on the unit size +// - unit: number of bytes for each element of the collection +func decInferLen(clen, maxlen, unit int) (rvlen int, truncated bool) { + // handle when maxlen is not set i.e. <= 0 + if clen <= 0 { + return + } + if maxlen <= 0 { + // no maxlen defined. Use maximum of 256K memory, with a floor of 4K items. + // maxlen = 256 * 1024 / unit + // if maxlen < (4 * 1024) { + // maxlen = 4 * 1024 + // } + if unit < (256 / 4) { + maxlen = 256 * 1024 / unit + } else { + maxlen = 4 * 1024 + } + } + if clen > maxlen { + rvlen = maxlen + truncated = true + } else { + rvlen = clen + } + return + // if clen <= 0 { + // rvlen = 0 + // } else if maxlen > 0 && clen > maxlen { + // rvlen = maxlen + // truncated = true + // } else { + // rvlen = clen + // } + // return +} + +// // implement overall decReader wrapping both, for possible use inline: +// type decReaderT struct { +// bytes bool +// rb *bytesDecReader +// ri *ioDecReader +// } +// +// // implement *Decoder as a decReader. +// // Using decReaderT (defined just above) caused performance degradation +// // possibly because of constant copying the value, +// // and some value->interface conversion causing allocation. +// func (d *Decoder) unreadn1() { +// if d.bytes { +// d.rb.unreadn1() +// } else { +// d.ri.unreadn1() +// } +// } +// ... for other methods of decReader. +// Testing showed that performance improvement was negligible. diff --git a/vendor/github.com/ugorji/go/codec/encode.go b/vendor/github.com/ugorji/go/codec/encode.go new file mode 100644 index 00000000..e3e3bc26 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/encode.go @@ -0,0 +1,1428 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "encoding" + "fmt" + "io" + "reflect" + "sort" + "sync" +) + +const ( + defEncByteBufSize = 1 << 6 // 4:16, 6:64, 8:256, 10:1024 +) + +// AsSymbolFlag defines what should be encoded as symbols. +type AsSymbolFlag uint8 + +const ( + // AsSymbolDefault is default. + // Currently, this means only encode struct field names as symbols. + // The default is subject to change. + AsSymbolDefault AsSymbolFlag = iota + + // AsSymbolAll means encode anything which could be a symbol as a symbol. + AsSymbolAll = 0xfe + + // AsSymbolNone means do not encode anything as a symbol. + AsSymbolNone = 1 << iota + + // AsSymbolMapStringKeys means encode keys in map[string]XXX as symbols. + AsSymbolMapStringKeysFlag + + // AsSymbolStructFieldName means encode struct field names as symbols. + AsSymbolStructFieldNameFlag +) + +// encWriter abstracts writing to a byte array or to an io.Writer. +type encWriter interface { + writeb([]byte) + writestr(string) + writen1(byte) + writen2(byte, byte) + atEndOfEncode() +} + +// encDriver abstracts the actual codec (binc vs msgpack, etc) +type encDriver interface { + IsBuiltinType(rt uintptr) bool + EncodeBuiltin(rt uintptr, v interface{}) + EncodeNil() + EncodeInt(i int64) + EncodeUint(i uint64) + EncodeBool(b bool) + EncodeFloat32(f float32) + EncodeFloat64(f float64) + // encodeExtPreamble(xtag byte, length int) + EncodeRawExt(re *RawExt, e *Encoder) + EncodeExt(v interface{}, xtag uint64, ext Ext, e *Encoder) + EncodeArrayStart(length int) + EncodeMapStart(length int) + EncodeString(c charEncoding, v string) + EncodeSymbol(v string) + EncodeStringBytes(c charEncoding, v []byte) + //TODO + //encBignum(f *big.Int) + //encStringRunes(c charEncoding, v []rune) + + reset() +} + +type encDriverAsis interface { + EncodeAsis(v []byte) +} + +type encNoSeparator struct{} + +func (_ encNoSeparator) EncodeEnd() {} + +type ioEncWriterWriter interface { + WriteByte(c byte) error + WriteString(s string) (n int, err error) + Write(p []byte) (n int, err error) +} + +type ioEncStringWriter interface { + WriteString(s string) (n int, err error) +} + +type EncodeOptions struct { + // Encode a struct as an array, and not as a map + StructToArray bool + + // Canonical representation means that encoding a value will always result in the same + // sequence of bytes. + // + // This only affects maps, as the iteration order for maps is random. + // + // The implementation MAY use the natural sort order for the map keys if possible: + // + // - If there is a natural sort order (ie for number, bool, string or []byte keys), + // then the map keys are first sorted in natural order and then written + // with corresponding map values to the strema. + // - If there is no natural sort order, then the map keys will first be + // encoded into []byte, and then sorted, + // before writing the sorted keys and the corresponding map values to the stream. + // + Canonical bool + + // CheckCircularRef controls whether we check for circular references + // and error fast during an encode. + // + // If enabled, an error is received if a pointer to a struct + // references itself either directly or through one of its fields (iteratively). + // + // This is opt-in, as there may be a performance hit to checking circular references. + CheckCircularRef bool + + // RecursiveEmptyCheck controls whether we descend into interfaces, structs and pointers + // when checking if a value is empty. + // + // Note that this may make OmitEmpty more expensive, as it incurs a lot more reflect calls. + RecursiveEmptyCheck bool + + // AsSymbols defines what should be encoded as symbols. + // + // Encoding as symbols can reduce the encoded size significantly. + // + // However, during decoding, each string to be encoded as a symbol must + // be checked to see if it has been seen before. Consequently, encoding time + // will increase if using symbols, because string comparisons has a clear cost. + // + // Sample values: + // AsSymbolNone + // AsSymbolAll + // AsSymbolMapStringKeys + // AsSymbolMapStringKeysFlag | AsSymbolStructFieldNameFlag + AsSymbols AsSymbolFlag +} + +// --------------------------------------------- + +type simpleIoEncWriterWriter struct { + w io.Writer + bw io.ByteWriter + sw ioEncStringWriter + bs [1]byte +} + +func (o *simpleIoEncWriterWriter) WriteByte(c byte) (err error) { + if o.bw != nil { + return o.bw.WriteByte(c) + } + // _, err = o.w.Write([]byte{c}) + o.bs[0] = c + _, err = o.w.Write(o.bs[:]) + return +} + +func (o *simpleIoEncWriterWriter) WriteString(s string) (n int, err error) { + if o.sw != nil { + return o.sw.WriteString(s) + } + // return o.w.Write([]byte(s)) + return o.w.Write(bytesView(s)) +} + +func (o *simpleIoEncWriterWriter) Write(p []byte) (n int, err error) { + return o.w.Write(p) +} + +// ---------------------------------------- + +// ioEncWriter implements encWriter and can write to an io.Writer implementation +type ioEncWriter struct { + w ioEncWriterWriter + s simpleIoEncWriterWriter + // x [8]byte // temp byte array re-used internally for efficiency +} + +func (z *ioEncWriter) writeb(bs []byte) { + if len(bs) == 0 { + return + } + n, err := z.w.Write(bs) + if err != nil { + panic(err) + } + if n != len(bs) { + panic(fmt.Errorf("incorrect num bytes written. Expecting: %v, Wrote: %v", len(bs), n)) + } +} + +func (z *ioEncWriter) writestr(s string) { + n, err := z.w.WriteString(s) + if err != nil { + panic(err) + } + if n != len(s) { + panic(fmt.Errorf("incorrect num bytes written. Expecting: %v, Wrote: %v", len(s), n)) + } +} + +func (z *ioEncWriter) writen1(b byte) { + if err := z.w.WriteByte(b); err != nil { + panic(err) + } +} + +func (z *ioEncWriter) writen2(b1 byte, b2 byte) { + z.writen1(b1) + z.writen1(b2) +} + +func (z *ioEncWriter) atEndOfEncode() {} + +// ---------------------------------------- + +// bytesEncWriter implements encWriter and can write to an byte slice. +// It is used by Marshal function. +type bytesEncWriter struct { + b []byte + c int // cursor + out *[]byte // write out on atEndOfEncode +} + +func (z *bytesEncWriter) writeb(s []byte) { + if len(s) > 0 { + c := z.grow(len(s)) + copy(z.b[c:], s) + } +} + +func (z *bytesEncWriter) writestr(s string) { + if len(s) > 0 { + c := z.grow(len(s)) + copy(z.b[c:], s) + } +} + +func (z *bytesEncWriter) writen1(b1 byte) { + c := z.grow(1) + z.b[c] = b1 +} + +func (z *bytesEncWriter) writen2(b1 byte, b2 byte) { + c := z.grow(2) + z.b[c+1] = b2 + z.b[c] = b1 +} + +func (z *bytesEncWriter) atEndOfEncode() { + *(z.out) = z.b[:z.c] +} + +func (z *bytesEncWriter) grow(n int) (oldcursor int) { + oldcursor = z.c + z.c = oldcursor + n + if z.c > len(z.b) { + if z.c > cap(z.b) { + // appendslice logic (if cap < 1024, *2, else *1.25): more expensive. many copy calls. + // bytes.Buffer model (2*cap + n): much better + // bs := make([]byte, 2*cap(z.b)+n) + bs := make([]byte, growCap(cap(z.b), 1, n)) + copy(bs, z.b[:oldcursor]) + z.b = bs + } else { + z.b = z.b[:cap(z.b)] + } + } + return +} + +// --------------------------------------------- + +type encFnInfo struct { + e *Encoder + ti *typeInfo + xfFn Ext + xfTag uint64 + seq seqType +} + +func (f *encFnInfo) builtin(rv reflect.Value) { + f.e.e.EncodeBuiltin(f.ti.rtid, rv.Interface()) +} + +func (f *encFnInfo) rawExt(rv reflect.Value) { + // rev := rv.Interface().(RawExt) + // f.e.e.EncodeRawExt(&rev, f.e) + var re *RawExt + if rv.CanAddr() { + re = rv.Addr().Interface().(*RawExt) + } else { + rev := rv.Interface().(RawExt) + re = &rev + } + f.e.e.EncodeRawExt(re, f.e) +} + +func (f *encFnInfo) ext(rv reflect.Value) { + // if this is a struct|array and it was addressable, then pass the address directly (not the value) + if k := rv.Kind(); (k == reflect.Struct || k == reflect.Array) && rv.CanAddr() { + rv = rv.Addr() + } + f.e.e.EncodeExt(rv.Interface(), f.xfTag, f.xfFn, f.e) +} + +func (f *encFnInfo) getValueForMarshalInterface(rv reflect.Value, indir int8) (v interface{}, proceed bool) { + if indir == 0 { + v = rv.Interface() + } else if indir == -1 { + // If a non-pointer was passed to Encode(), then that value is not addressable. + // Take addr if addressable, else copy value to an addressable value. + if rv.CanAddr() { + v = rv.Addr().Interface() + } else { + rv2 := reflect.New(rv.Type()) + rv2.Elem().Set(rv) + v = rv2.Interface() + // fmt.Printf("rv.Type: %v, rv2.Type: %v, v: %v\n", rv.Type(), rv2.Type(), v) + } + } else { + for j := int8(0); j < indir; j++ { + if rv.IsNil() { + f.e.e.EncodeNil() + return + } + rv = rv.Elem() + } + v = rv.Interface() + } + return v, true +} + +func (f *encFnInfo) selferMarshal(rv reflect.Value) { + if v, proceed := f.getValueForMarshalInterface(rv, f.ti.csIndir); proceed { + v.(Selfer).CodecEncodeSelf(f.e) + } +} + +func (f *encFnInfo) binaryMarshal(rv reflect.Value) { + if v, proceed := f.getValueForMarshalInterface(rv, f.ti.bmIndir); proceed { + bs, fnerr := v.(encoding.BinaryMarshaler).MarshalBinary() + f.e.marshal(bs, fnerr, false, c_RAW) + } +} + +func (f *encFnInfo) textMarshal(rv reflect.Value) { + if v, proceed := f.getValueForMarshalInterface(rv, f.ti.tmIndir); proceed { + // debugf(">>>> encoding.TextMarshaler: %T", rv.Interface()) + bs, fnerr := v.(encoding.TextMarshaler).MarshalText() + f.e.marshal(bs, fnerr, false, c_UTF8) + } +} + +func (f *encFnInfo) jsonMarshal(rv reflect.Value) { + if v, proceed := f.getValueForMarshalInterface(rv, f.ti.jmIndir); proceed { + bs, fnerr := v.(jsonMarshaler).MarshalJSON() + f.e.marshal(bs, fnerr, true, c_UTF8) + } +} + +func (f *encFnInfo) kBool(rv reflect.Value) { + f.e.e.EncodeBool(rv.Bool()) +} + +func (f *encFnInfo) kString(rv reflect.Value) { + f.e.e.EncodeString(c_UTF8, rv.String()) +} + +func (f *encFnInfo) kFloat64(rv reflect.Value) { + f.e.e.EncodeFloat64(rv.Float()) +} + +func (f *encFnInfo) kFloat32(rv reflect.Value) { + f.e.e.EncodeFloat32(float32(rv.Float())) +} + +func (f *encFnInfo) kInt(rv reflect.Value) { + f.e.e.EncodeInt(rv.Int()) +} + +func (f *encFnInfo) kUint(rv reflect.Value) { + f.e.e.EncodeUint(rv.Uint()) +} + +func (f *encFnInfo) kInvalid(rv reflect.Value) { + f.e.e.EncodeNil() +} + +func (f *encFnInfo) kErr(rv reflect.Value) { + f.e.errorf("unsupported kind %s, for %#v", rv.Kind(), rv) +} + +func (f *encFnInfo) kSlice(rv reflect.Value) { + ti := f.ti + // array may be non-addressable, so we have to manage with care + // (don't call rv.Bytes, rv.Slice, etc). + // E.g. type struct S{B [2]byte}; + // Encode(S{}) will bomb on "panic: slice of unaddressable array". + e := f.e + if f.seq != seqTypeArray { + if rv.IsNil() { + e.e.EncodeNil() + return + } + // If in this method, then there was no extension function defined. + // So it's okay to treat as []byte. + if ti.rtid == uint8SliceTypId { + e.e.EncodeStringBytes(c_RAW, rv.Bytes()) + return + } + } + cr := e.cr + rtelem := ti.rt.Elem() + l := rv.Len() + if ti.rtid == uint8SliceTypId || rtelem.Kind() == reflect.Uint8 { + switch f.seq { + case seqTypeArray: + // if l == 0 { e.e.encodeStringBytes(c_RAW, nil) } else + if rv.CanAddr() { + e.e.EncodeStringBytes(c_RAW, rv.Slice(0, l).Bytes()) + } else { + var bs []byte + if l <= cap(e.b) { + bs = e.b[:l] + } else { + bs = make([]byte, l) + } + reflect.Copy(reflect.ValueOf(bs), rv) + // TODO: Test that reflect.Copy works instead of manual one-by-one + // for i := 0; i < l; i++ { + // bs[i] = byte(rv.Index(i).Uint()) + // } + e.e.EncodeStringBytes(c_RAW, bs) + } + case seqTypeSlice: + e.e.EncodeStringBytes(c_RAW, rv.Bytes()) + case seqTypeChan: + bs := e.b[:0] + // do not use range, so that the number of elements encoded + // does not change, and encoding does not hang waiting on someone to close chan. + // for b := range rv.Interface().(<-chan byte) { + // bs = append(bs, b) + // } + ch := rv.Interface().(<-chan byte) + for i := 0; i < l; i++ { + bs = append(bs, <-ch) + } + e.e.EncodeStringBytes(c_RAW, bs) + } + return + } + + if ti.mbs { + if l%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", l) + return + } + e.e.EncodeMapStart(l / 2) + } else { + e.e.EncodeArrayStart(l) + } + + if l > 0 { + for rtelem.Kind() == reflect.Ptr { + rtelem = rtelem.Elem() + } + // if kind is reflect.Interface, do not pre-determine the + // encoding type, because preEncodeValue may break it down to + // a concrete type and kInterface will bomb. + var fn *encFn + if rtelem.Kind() != reflect.Interface { + rtelemid := reflect.ValueOf(rtelem).Pointer() + fn = e.getEncFn(rtelemid, rtelem, true, true) + } + // TODO: Consider perf implication of encoding odd index values as symbols if type is string + for j := 0; j < l; j++ { + if cr != nil { + if ti.mbs { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } else { + cr.sendContainerState(containerArrayElem) + } + } + if f.seq == seqTypeChan { + if rv2, ok2 := rv.Recv(); ok2 { + e.encodeValue(rv2, fn) + } else { + e.encode(nil) // WE HAVE TO DO SOMETHING, so nil if nothing received. + } + } else { + e.encodeValue(rv.Index(j), fn) + } + } + } + + if cr != nil { + if ti.mbs { + cr.sendContainerState(containerMapEnd) + } else { + cr.sendContainerState(containerArrayEnd) + } + } +} + +func (f *encFnInfo) kStruct(rv reflect.Value) { + fti := f.ti + e := f.e + cr := e.cr + tisfi := fti.sfip + toMap := !(fti.toArray || e.h.StructToArray) + newlen := len(fti.sfi) + + // Use sync.Pool to reduce allocating slices unnecessarily. + // The cost of sync.Pool is less than the cost of new allocation. + pool, poolv, fkvs := encStructPoolGet(newlen) + + // if toMap, use the sorted array. If toArray, use unsorted array (to match sequence in struct) + if toMap { + tisfi = fti.sfi + } + newlen = 0 + var kv stringRv + recur := e.h.RecursiveEmptyCheck + for _, si := range tisfi { + kv.r = si.field(rv, false) + if toMap { + if si.omitEmpty && isEmptyValue(kv.r, recur, recur) { + continue + } + kv.v = si.encName + } else { + // use the zero value. + // if a reference or struct, set to nil (so you do not output too much) + if si.omitEmpty && isEmptyValue(kv.r, recur, recur) { + switch kv.r.Kind() { + case reflect.Struct, reflect.Interface, reflect.Ptr, reflect.Array, reflect.Map, reflect.Slice: + kv.r = reflect.Value{} //encode as nil + } + } + } + fkvs[newlen] = kv + newlen++ + } + + // debugf(">>>> kStruct: newlen: %v", newlen) + // sep := !e.be + ee := e.e //don't dereference every time + + if toMap { + ee.EncodeMapStart(newlen) + // asSymbols := e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0 + asSymbols := e.h.AsSymbols == AsSymbolDefault || e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0 + for j := 0; j < newlen; j++ { + kv = fkvs[j] + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(kv.v) + } else { + ee.EncodeString(c_UTF8, kv.v) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encodeValue(kv.r, nil) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + } else { + ee.EncodeArrayStart(newlen) + for j := 0; j < newlen; j++ { + kv = fkvs[j] + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + e.encodeValue(kv.r, nil) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } + } + + // do not use defer. Instead, use explicit pool return at end of function. + // defer has a cost we are trying to avoid. + // If there is a panic and these slices are not returned, it is ok. + if pool != nil { + pool.Put(poolv) + } +} + +// func (f *encFnInfo) kPtr(rv reflect.Value) { +// debugf(">>>>>>> ??? encode kPtr called - shouldn't get called") +// if rv.IsNil() { +// f.e.e.encodeNil() +// return +// } +// f.e.encodeValue(rv.Elem()) +// } + +// func (f *encFnInfo) kInterface(rv reflect.Value) { +// println("kInterface called") +// debug.PrintStack() +// if rv.IsNil() { +// f.e.e.EncodeNil() +// return +// } +// f.e.encodeValue(rv.Elem(), nil) +// } + +func (f *encFnInfo) kMap(rv reflect.Value) { + ee := f.e.e + if rv.IsNil() { + ee.EncodeNil() + return + } + + l := rv.Len() + ee.EncodeMapStart(l) + e := f.e + cr := e.cr + if l == 0 { + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return + } + var asSymbols bool + // determine the underlying key and val encFn's for the map. + // This eliminates some work which is done for each loop iteration i.e. + // rv.Type(), ref.ValueOf(rt).Pointer(), then check map/list for fn. + // + // However, if kind is reflect.Interface, do not pre-determine the + // encoding type, because preEncodeValue may break it down to + // a concrete type and kInterface will bomb. + var keyFn, valFn *encFn + ti := f.ti + rtkey := ti.rt.Key() + rtval := ti.rt.Elem() + rtkeyid := reflect.ValueOf(rtkey).Pointer() + // keyTypeIsString := f.ti.rt.Key().Kind() == reflect.String + var keyTypeIsString = rtkeyid == stringTypId + if keyTypeIsString { + asSymbols = e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + } else { + for rtkey.Kind() == reflect.Ptr { + rtkey = rtkey.Elem() + } + if rtkey.Kind() != reflect.Interface { + rtkeyid = reflect.ValueOf(rtkey).Pointer() + keyFn = e.getEncFn(rtkeyid, rtkey, true, true) + } + } + for rtval.Kind() == reflect.Ptr { + rtval = rtval.Elem() + } + if rtval.Kind() != reflect.Interface { + rtvalid := reflect.ValueOf(rtval).Pointer() + valFn = e.getEncFn(rtvalid, rtval, true, true) + } + mks := rv.MapKeys() + // for j, lmks := 0, len(mks); j < lmks; j++ { + + if e.h.Canonical { + e.kMapCanonical(rtkeyid, rtkey, rv, mks, valFn, asSymbols) + } else { + for j := range mks { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if keyTypeIsString { + if asSymbols { + ee.EncodeSymbol(mks[j].String()) + } else { + ee.EncodeString(c_UTF8, mks[j].String()) + } + } else { + e.encodeValue(mks[j], keyFn) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encodeValue(rv.MapIndex(mks[j]), valFn) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect.Value, mks []reflect.Value, valFn *encFn, asSymbols bool) { + ee := e.e + cr := e.cr + // we previously did out-of-band if an extension was registered. + // This is not necessary, as the natural kind is sufficient for ordering. + + if rtkeyid == uint8SliceTypId { + mksv := make([]bytesRv, len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Bytes() + } + sort.Sort(bytesRvSlice(mksv)) + for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeStringBytes(c_RAW, mksv[i].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encodeValue(rv.MapIndex(mksv[i].r), valFn) + } + } else { + switch rtkey.Kind() { + case reflect.Bool: + mksv := make([]boolRv, len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Bool() + } + sort.Sort(boolRvSlice(mksv)) + for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(mksv[i].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encodeValue(rv.MapIndex(mksv[i].r), valFn) + } + case reflect.String: + mksv := make([]stringRv, len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.String() + } + sort.Sort(stringRvSlice(mksv)) + for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(mksv[i].v) + } else { + ee.EncodeString(c_UTF8, mksv[i].v) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encodeValue(rv.MapIndex(mksv[i].r), valFn) + } + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr: + mksv := make([]uintRv, len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Uint() + } + sort.Sort(uintRvSlice(mksv)) + for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(mksv[i].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encodeValue(rv.MapIndex(mksv[i].r), valFn) + } + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + mksv := make([]intRv, len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Int() + } + sort.Sort(intRvSlice(mksv)) + for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(mksv[i].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encodeValue(rv.MapIndex(mksv[i].r), valFn) + } + case reflect.Float32: + mksv := make([]floatRv, len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Float() + } + sort.Sort(floatRvSlice(mksv)) + for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(mksv[i].v)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encodeValue(rv.MapIndex(mksv[i].r), valFn) + } + case reflect.Float64: + mksv := make([]floatRv, len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Float() + } + sort.Sort(floatRvSlice(mksv)) + for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(mksv[i].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encodeValue(rv.MapIndex(mksv[i].r), valFn) + } + default: + // out-of-band + // first encode each key to a []byte first, then sort them, then record + var mksv []byte = make([]byte, 0, len(mks)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + mksbv := make([]bytesRv, len(mks)) + for i, k := range mks { + v := &mksbv[i] + l := len(mksv) + e2.MustEncode(k) + v.r = k + v.v = mksv[l:] + // fmt.Printf(">>>>> %s\n", mksv[l:]) + } + sort.Sort(bytesRvSlice(mksbv)) + for j := range mksbv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(mksbv[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encodeValue(rv.MapIndex(mksbv[j].r), valFn) + } + } + } +} + +// -------------------------------------------------- + +// encFn encapsulates the captured variables and the encode function. +// This way, we only do some calculations one times, and pass to the +// code block that should be called (encapsulated in a function) +// instead of executing the checks every time. +type encFn struct { + i encFnInfo + f func(*encFnInfo, reflect.Value) +} + +// -------------------------------------------------- + +type encRtidFn struct { + rtid uintptr + fn encFn +} + +// An Encoder writes an object to an output stream in the codec format. +type Encoder struct { + // hopefully, reduce derefencing cost by laying the encWriter inside the Encoder + e encDriver + // NOTE: Encoder shouldn't call it's write methods, + // as the handler MAY need to do some coordination. + w encWriter + s []encRtidFn + ci set + be bool // is binary encoding + js bool // is json handle + + wi ioEncWriter + wb bytesEncWriter + + h *BasicHandle + hh Handle + + cr containerStateRecv + as encDriverAsis + + f map[uintptr]*encFn + b [scratchByteArrayLen]byte +} + +// NewEncoder returns an Encoder for encoding into an io.Writer. +// +// For efficiency, Users are encouraged to pass in a memory buffered writer +// (eg bufio.Writer, bytes.Buffer). +func NewEncoder(w io.Writer, h Handle) *Encoder { + e := newEncoder(h) + e.Reset(w) + return e +} + +// NewEncoderBytes returns an encoder for encoding directly and efficiently +// into a byte slice, using zero-copying to temporary slices. +// +// It will potentially replace the output byte slice pointed to. +// After encoding, the out parameter contains the encoded contents. +func NewEncoderBytes(out *[]byte, h Handle) *Encoder { + e := newEncoder(h) + e.ResetBytes(out) + return e +} + +func newEncoder(h Handle) *Encoder { + e := &Encoder{hh: h, h: h.getBasicHandle(), be: h.isBinary()} + _, e.js = h.(*JsonHandle) + e.e = h.newEncDriver(e) + e.as, _ = e.e.(encDriverAsis) + e.cr, _ = e.e.(containerStateRecv) + return e +} + +// Reset the Encoder with a new output stream. +// +// This accommodates using the state of the Encoder, +// where it has "cached" information about sub-engines. +func (e *Encoder) Reset(w io.Writer) { + ww, ok := w.(ioEncWriterWriter) + if ok { + e.wi.w = ww + } else { + sww := &e.wi.s + sww.w = w + sww.bw, _ = w.(io.ByteWriter) + sww.sw, _ = w.(ioEncStringWriter) + e.wi.w = sww + //ww = bufio.NewWriterSize(w, defEncByteBufSize) + } + e.w = &e.wi + e.e.reset() +} + +func (e *Encoder) ResetBytes(out *[]byte) { + in := *out + if in == nil { + in = make([]byte, defEncByteBufSize) + } + e.wb.b, e.wb.out, e.wb.c = in, out, 0 + e.w = &e.wb + e.e.reset() +} + +// func (e *Encoder) sendContainerState(c containerState) { +// if e.cr != nil { +// e.cr.sendContainerState(c) +// } +// } + +// Encode writes an object into a stream. +// +// Encoding can be configured via the struct tag for the fields. +// The "codec" key in struct field's tag value is the key name, +// followed by an optional comma and options. +// Note that the "json" key is used in the absence of the "codec" key. +// +// To set an option on all fields (e.g. omitempty on all fields), you +// can create a field called _struct, and set flags on it. +// +// Struct values "usually" encode as maps. Each exported struct field is encoded unless: +// - the field's tag is "-", OR +// - the field is empty (empty or the zero value) and its tag specifies the "omitempty" option. +// +// When encoding as a map, the first string in the tag (before the comma) +// is the map key string to use when encoding. +// +// However, struct values may encode as arrays. This happens when: +// - StructToArray Encode option is set, OR +// - the tag on the _struct field sets the "toarray" option +// +// Values with types that implement MapBySlice are encoded as stream maps. +// +// The empty values (for omitempty option) are false, 0, any nil pointer +// or interface value, and any array, slice, map, or string of length zero. +// +// Anonymous fields are encoded inline except: +// - the struct tag specifies a replacement name (first value) +// - the field is of an interface type +// +// Examples: +// +// // NOTE: 'json:' can be used as struct tag key, in place 'codec:' below. +// type MyStruct struct { +// _struct bool `codec:",omitempty"` //set omitempty for every field +// Field1 string `codec:"-"` //skip this field +// Field2 int `codec:"myName"` //Use key "myName" in encode stream +// Field3 int32 `codec:",omitempty"` //use key "Field3". Omit if empty. +// Field4 bool `codec:"f4,omitempty"` //use key "f4". Omit if empty. +// io.Reader //use key "Reader". +// MyStruct `codec:"my1" //use key "my1". +// MyStruct //inline it +// ... +// } +// +// type MyStruct struct { +// _struct bool `codec:",omitempty,toarray"` //set omitempty for every field +// //and encode struct as an array +// } +// +// The mode of encoding is based on the type of the value. When a value is seen: +// - If a Selfer, call its CodecEncodeSelf method +// - If an extension is registered for it, call that extension function +// - If it implements encoding.(Binary|Text|JSON)Marshaler, call its Marshal(Binary|Text|JSON) method +// - Else encode it based on its reflect.Kind +// +// Note that struct field names and keys in map[string]XXX will be treated as symbols. +// Some formats support symbols (e.g. binc) and will properly encode the string +// only once in the stream, and use a tag to refer to it thereafter. +func (e *Encoder) Encode(v interface{}) (err error) { + defer panicToErr(&err) + e.encode(v) + e.w.atEndOfEncode() + return +} + +// MustEncode is like Encode, but panics if unable to Encode. +// This provides insight to the code location that triggered the error. +func (e *Encoder) MustEncode(v interface{}) { + e.encode(v) + e.w.atEndOfEncode() +} + +// comment out these (Must)Write methods. They were only put there to support cbor. +// However, users already have access to the streams, and can write directly. +// +// // Write allows users write to the Encoder stream directly. +// func (e *Encoder) Write(bs []byte) (err error) { +// defer panicToErr(&err) +// e.w.writeb(bs) +// return +// } +// // MustWrite is like write, but panics if unable to Write. +// func (e *Encoder) MustWrite(bs []byte) { +// e.w.writeb(bs) +// } + +func (e *Encoder) encode(iv interface{}) { + // if ics, ok := iv.(Selfer); ok { + // ics.CodecEncodeSelf(e) + // return + // } + + switch v := iv.(type) { + case nil: + e.e.EncodeNil() + case Selfer: + v.CodecEncodeSelf(e) + + case reflect.Value: + e.encodeValue(v, nil) + + case string: + e.e.EncodeString(c_UTF8, v) + case bool: + e.e.EncodeBool(v) + case int: + e.e.EncodeInt(int64(v)) + case int8: + e.e.EncodeInt(int64(v)) + case int16: + e.e.EncodeInt(int64(v)) + case int32: + e.e.EncodeInt(int64(v)) + case int64: + e.e.EncodeInt(v) + case uint: + e.e.EncodeUint(uint64(v)) + case uint8: + e.e.EncodeUint(uint64(v)) + case uint16: + e.e.EncodeUint(uint64(v)) + case uint32: + e.e.EncodeUint(uint64(v)) + case uint64: + e.e.EncodeUint(v) + case float32: + e.e.EncodeFloat32(v) + case float64: + e.e.EncodeFloat64(v) + + case []uint8: + e.e.EncodeStringBytes(c_RAW, v) + + case *string: + e.e.EncodeString(c_UTF8, *v) + case *bool: + e.e.EncodeBool(*v) + case *int: + e.e.EncodeInt(int64(*v)) + case *int8: + e.e.EncodeInt(int64(*v)) + case *int16: + e.e.EncodeInt(int64(*v)) + case *int32: + e.e.EncodeInt(int64(*v)) + case *int64: + e.e.EncodeInt(*v) + case *uint: + e.e.EncodeUint(uint64(*v)) + case *uint8: + e.e.EncodeUint(uint64(*v)) + case *uint16: + e.e.EncodeUint(uint64(*v)) + case *uint32: + e.e.EncodeUint(uint64(*v)) + case *uint64: + e.e.EncodeUint(*v) + case *float32: + e.e.EncodeFloat32(*v) + case *float64: + e.e.EncodeFloat64(*v) + + case *[]uint8: + e.e.EncodeStringBytes(c_RAW, *v) + + default: + const checkCodecSelfer1 = true // in case T is passed, where *T is a Selfer, still checkCodecSelfer + if !fastpathEncodeTypeSwitch(iv, e) { + e.encodeI(iv, false, checkCodecSelfer1) + } + } +} + +func (e *Encoder) preEncodeValue(rv reflect.Value) (rv2 reflect.Value, sptr uintptr, proceed bool) { + // use a goto statement instead of a recursive function for ptr/interface. +TOP: + switch rv.Kind() { + case reflect.Ptr: + if rv.IsNil() { + e.e.EncodeNil() + return + } + rv = rv.Elem() + if e.h.CheckCircularRef && rv.Kind() == reflect.Struct { + // TODO: Movable pointers will be an issue here. Future problem. + sptr = rv.UnsafeAddr() + break TOP + } + goto TOP + case reflect.Interface: + if rv.IsNil() { + e.e.EncodeNil() + return + } + rv = rv.Elem() + goto TOP + case reflect.Slice, reflect.Map: + if rv.IsNil() { + e.e.EncodeNil() + return + } + case reflect.Invalid, reflect.Func: + e.e.EncodeNil() + return + } + + proceed = true + rv2 = rv + return +} + +func (e *Encoder) doEncodeValue(rv reflect.Value, fn *encFn, sptr uintptr, + checkFastpath, checkCodecSelfer bool) { + if sptr != 0 { + if (&e.ci).add(sptr) { + e.errorf("circular reference found: # %d", sptr) + } + } + if fn == nil { + rt := rv.Type() + rtid := reflect.ValueOf(rt).Pointer() + // fn = e.getEncFn(rtid, rt, true, true) + fn = e.getEncFn(rtid, rt, checkFastpath, checkCodecSelfer) + } + fn.f(&fn.i, rv) + if sptr != 0 { + (&e.ci).remove(sptr) + } +} + +func (e *Encoder) encodeI(iv interface{}, checkFastpath, checkCodecSelfer bool) { + if rv, sptr, proceed := e.preEncodeValue(reflect.ValueOf(iv)); proceed { + e.doEncodeValue(rv, nil, sptr, checkFastpath, checkCodecSelfer) + } +} + +func (e *Encoder) encodeValue(rv reflect.Value, fn *encFn) { + // if a valid fn is passed, it MUST BE for the dereferenced type of rv + if rv, sptr, proceed := e.preEncodeValue(rv); proceed { + e.doEncodeValue(rv, fn, sptr, true, true) + } +} + +func (e *Encoder) getEncFn(rtid uintptr, rt reflect.Type, checkFastpath, checkCodecSelfer bool) (fn *encFn) { + // rtid := reflect.ValueOf(rt).Pointer() + var ok bool + if useMapForCodecCache { + fn, ok = e.f[rtid] + } else { + for i := range e.s { + v := &(e.s[i]) + if v.rtid == rtid { + fn, ok = &(v.fn), true + break + } + } + } + if ok { + return + } + + if useMapForCodecCache { + if e.f == nil { + e.f = make(map[uintptr]*encFn, initCollectionCap) + } + fn = new(encFn) + e.f[rtid] = fn + } else { + if e.s == nil { + e.s = make([]encRtidFn, 0, initCollectionCap) + } + e.s = append(e.s, encRtidFn{rtid: rtid}) + fn = &(e.s[len(e.s)-1]).fn + } + + ti := e.h.getTypeInfo(rtid, rt) + fi := &(fn.i) + fi.e = e + fi.ti = ti + + if checkCodecSelfer && ti.cs { + fn.f = (*encFnInfo).selferMarshal + } else if rtid == rawExtTypId { + fn.f = (*encFnInfo).rawExt + } else if e.e.IsBuiltinType(rtid) { + fn.f = (*encFnInfo).builtin + } else if xfFn := e.h.getExt(rtid); xfFn != nil { + fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext + fn.f = (*encFnInfo).ext + } else if supportMarshalInterfaces && e.be && ti.bm { + fn.f = (*encFnInfo).binaryMarshal + } else if supportMarshalInterfaces && !e.be && e.js && ti.jm { + //If JSON, we should check JSONMarshal before textMarshal + fn.f = (*encFnInfo).jsonMarshal + } else if supportMarshalInterfaces && !e.be && ti.tm { + fn.f = (*encFnInfo).textMarshal + } else { + rk := rt.Kind() + if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) { + if rt.PkgPath() == "" { // un-named slice or map + if idx := fastpathAV.index(rtid); idx != -1 { + fn.f = fastpathAV[idx].encfn + } + } else { + ok = false + // use mapping for underlying type if there + var rtu reflect.Type + if rk == reflect.Map { + rtu = reflect.MapOf(rt.Key(), rt.Elem()) + } else { + rtu = reflect.SliceOf(rt.Elem()) + } + rtuid := reflect.ValueOf(rtu).Pointer() + if idx := fastpathAV.index(rtuid); idx != -1 { + xfnf := fastpathAV[idx].encfn + xrt := fastpathAV[idx].rt + fn.f = func(xf *encFnInfo, xrv reflect.Value) { + xfnf(xf, xrv.Convert(xrt)) + } + } + } + } + if fn.f == nil { + switch rk { + case reflect.Bool: + fn.f = (*encFnInfo).kBool + case reflect.String: + fn.f = (*encFnInfo).kString + case reflect.Float64: + fn.f = (*encFnInfo).kFloat64 + case reflect.Float32: + fn.f = (*encFnInfo).kFloat32 + case reflect.Int, reflect.Int8, reflect.Int64, reflect.Int32, reflect.Int16: + fn.f = (*encFnInfo).kInt + case reflect.Uint8, reflect.Uint64, reflect.Uint, reflect.Uint32, reflect.Uint16, reflect.Uintptr: + fn.f = (*encFnInfo).kUint + case reflect.Invalid: + fn.f = (*encFnInfo).kInvalid + case reflect.Chan: + fi.seq = seqTypeChan + fn.f = (*encFnInfo).kSlice + case reflect.Slice: + fi.seq = seqTypeSlice + fn.f = (*encFnInfo).kSlice + case reflect.Array: + fi.seq = seqTypeArray + fn.f = (*encFnInfo).kSlice + case reflect.Struct: + fn.f = (*encFnInfo).kStruct + // reflect.Ptr and reflect.Interface are handled already by preEncodeValue + // case reflect.Ptr: + // fn.f = (*encFnInfo).kPtr + // case reflect.Interface: + // fn.f = (*encFnInfo).kInterface + case reflect.Map: + fn.f = (*encFnInfo).kMap + default: + fn.f = (*encFnInfo).kErr + } + } + } + + return +} + +func (e *Encoder) marshal(bs []byte, fnerr error, asis bool, c charEncoding) { + if fnerr != nil { + panic(fnerr) + } + if bs == nil { + e.e.EncodeNil() + } else if asis { + e.asis(bs) + } else { + e.e.EncodeStringBytes(c, bs) + } +} + +func (e *Encoder) asis(v []byte) { + if e.as == nil { + e.w.writeb(v) + } else { + e.as.EncodeAsis(v) + } +} + +func (e *Encoder) errorf(format string, params ...interface{}) { + err := fmt.Errorf(format, params...) + panic(err) +} + +// ---------------------------------------- + +const encStructPoolLen = 5 + +// encStructPool is an array of sync.Pool. +// Each element of the array pools one of encStructPool(8|16|32|64). +// It allows the re-use of slices up to 64 in length. +// A performance cost of encoding structs was collecting +// which values were empty and should be omitted. +// We needed slices of reflect.Value and string to collect them. +// This shared pool reduces the amount of unnecessary creation we do. +// The cost is that of locking sometimes, but sync.Pool is efficient +// enough to reduce thread contention. +var encStructPool [encStructPoolLen]sync.Pool + +func init() { + encStructPool[0].New = func() interface{} { return new([8]stringRv) } + encStructPool[1].New = func() interface{} { return new([16]stringRv) } + encStructPool[2].New = func() interface{} { return new([32]stringRv) } + encStructPool[3].New = func() interface{} { return new([64]stringRv) } + encStructPool[4].New = func() interface{} { return new([128]stringRv) } +} + +func encStructPoolGet(newlen int) (p *sync.Pool, v interface{}, s []stringRv) { + // if encStructPoolLen != 5 { // constant chec, so removed at build time. + // panic(errors.New("encStructPoolLen must be equal to 4")) // defensive, in case it is changed + // } + // idxpool := newlen / 8 + if newlen <= 8 { + p = &encStructPool[0] + v = p.Get() + s = v.(*[8]stringRv)[:newlen] + } else if newlen <= 16 { + p = &encStructPool[1] + v = p.Get() + s = v.(*[16]stringRv)[:newlen] + } else if newlen <= 32 { + p = &encStructPool[2] + v = p.Get() + s = v.(*[32]stringRv)[:newlen] + } else if newlen <= 64 { + p = &encStructPool[3] + v = p.Get() + s = v.(*[64]stringRv)[:newlen] + } else if newlen <= 128 { + p = &encStructPool[4] + v = p.Get() + s = v.(*[128]stringRv)[:newlen] + } else { + s = make([]stringRv, newlen) + } + return +} + +// ---------------------------------------- + +// func encErr(format string, params ...interface{}) { +// doPanic(msgTagEnc, format, params...) +// } diff --git a/vendor/github.com/ugorji/go/codec/fast-path.generated.go b/vendor/github.com/ugorji/go/codec/fast-path.generated.go new file mode 100644 index 00000000..f2e5d2dc --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/fast-path.generated.go @@ -0,0 +1,39352 @@ +// +build !notfastpath + +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +// ************************************************************ +// DO NOT EDIT. +// THIS FILE IS AUTO-GENERATED from fast-path.go.tmpl +// ************************************************************ + +package codec + +// Fast path functions try to create a fast path encode or decode implementation +// for common maps and slices. +// +// We define the functions and register then in this single file +// so as not to pollute the encode.go and decode.go, and create a dependency in there. +// This file can be omitted without causing a build failure. +// +// The advantage of fast paths is: +// - Many calls bypass reflection altogether +// +// Currently support +// - slice of all builtin types, +// - map of all builtin types to string or interface value +// - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8) +// This should provide adequate "typical" implementations. +// +// Note that fast track decode functions must handle values for which an address cannot be obtained. +// For example: +// m2 := map[string]int{} +// p2 := []interface{}{m2} +// // decoding into p2 will bomb if fast track functions do not treat like unaddressable. +// + +import ( + "reflect" + "sort" +) + +const fastpathEnabled = true + +const fastpathCheckNilFalse = false // for reflect +const fastpathCheckNilTrue = true // for type switch + +type fastpathT struct{} + +var fastpathTV fastpathT + +type fastpathE struct { + rtid uintptr + rt reflect.Type + encfn func(*encFnInfo, reflect.Value) + decfn func(*decFnInfo, reflect.Value) +} + +type fastpathA [271]fastpathE + +func (x *fastpathA) index(rtid uintptr) int { + // use binary search to grab the index (adapted from sort/search.go) + h, i, j := 0, 0, 271 // len(x) + for i < j { + h = i + (j-i)/2 + if x[h].rtid < rtid { + i = h + 1 + } else { + j = h + } + } + if i < 271 && x[i].rtid == rtid { + return i + } + return -1 +} + +type fastpathAslice []fastpathE + +func (x fastpathAslice) Len() int { return len(x) } +func (x fastpathAslice) Less(i, j int) bool { return x[i].rtid < x[j].rtid } +func (x fastpathAslice) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +var fastpathAV fastpathA + +// due to possible initialization loop error, make fastpath in an init() +func init() { + i := 0 + fn := func(v interface{}, fe func(*encFnInfo, reflect.Value), fd func(*decFnInfo, reflect.Value)) (f fastpathE) { + xrt := reflect.TypeOf(v) + xptr := reflect.ValueOf(xrt).Pointer() + fastpathAV[i] = fastpathE{xptr, xrt, fe, fd} + i++ + return + } + + fn([]interface{}(nil), (*encFnInfo).fastpathEncSliceIntfR, (*decFnInfo).fastpathDecSliceIntfR) + fn([]string(nil), (*encFnInfo).fastpathEncSliceStringR, (*decFnInfo).fastpathDecSliceStringR) + fn([]float32(nil), (*encFnInfo).fastpathEncSliceFloat32R, (*decFnInfo).fastpathDecSliceFloat32R) + fn([]float64(nil), (*encFnInfo).fastpathEncSliceFloat64R, (*decFnInfo).fastpathDecSliceFloat64R) + fn([]uint(nil), (*encFnInfo).fastpathEncSliceUintR, (*decFnInfo).fastpathDecSliceUintR) + fn([]uint16(nil), (*encFnInfo).fastpathEncSliceUint16R, (*decFnInfo).fastpathDecSliceUint16R) + fn([]uint32(nil), (*encFnInfo).fastpathEncSliceUint32R, (*decFnInfo).fastpathDecSliceUint32R) + fn([]uint64(nil), (*encFnInfo).fastpathEncSliceUint64R, (*decFnInfo).fastpathDecSliceUint64R) + fn([]uintptr(nil), (*encFnInfo).fastpathEncSliceUintptrR, (*decFnInfo).fastpathDecSliceUintptrR) + fn([]int(nil), (*encFnInfo).fastpathEncSliceIntR, (*decFnInfo).fastpathDecSliceIntR) + fn([]int8(nil), (*encFnInfo).fastpathEncSliceInt8R, (*decFnInfo).fastpathDecSliceInt8R) + fn([]int16(nil), (*encFnInfo).fastpathEncSliceInt16R, (*decFnInfo).fastpathDecSliceInt16R) + fn([]int32(nil), (*encFnInfo).fastpathEncSliceInt32R, (*decFnInfo).fastpathDecSliceInt32R) + fn([]int64(nil), (*encFnInfo).fastpathEncSliceInt64R, (*decFnInfo).fastpathDecSliceInt64R) + fn([]bool(nil), (*encFnInfo).fastpathEncSliceBoolR, (*decFnInfo).fastpathDecSliceBoolR) + + fn(map[interface{}]interface{}(nil), (*encFnInfo).fastpathEncMapIntfIntfR, (*decFnInfo).fastpathDecMapIntfIntfR) + fn(map[interface{}]string(nil), (*encFnInfo).fastpathEncMapIntfStringR, (*decFnInfo).fastpathDecMapIntfStringR) + fn(map[interface{}]uint(nil), (*encFnInfo).fastpathEncMapIntfUintR, (*decFnInfo).fastpathDecMapIntfUintR) + fn(map[interface{}]uint8(nil), (*encFnInfo).fastpathEncMapIntfUint8R, (*decFnInfo).fastpathDecMapIntfUint8R) + fn(map[interface{}]uint16(nil), (*encFnInfo).fastpathEncMapIntfUint16R, (*decFnInfo).fastpathDecMapIntfUint16R) + fn(map[interface{}]uint32(nil), (*encFnInfo).fastpathEncMapIntfUint32R, (*decFnInfo).fastpathDecMapIntfUint32R) + fn(map[interface{}]uint64(nil), (*encFnInfo).fastpathEncMapIntfUint64R, (*decFnInfo).fastpathDecMapIntfUint64R) + fn(map[interface{}]uintptr(nil), (*encFnInfo).fastpathEncMapIntfUintptrR, (*decFnInfo).fastpathDecMapIntfUintptrR) + fn(map[interface{}]int(nil), (*encFnInfo).fastpathEncMapIntfIntR, (*decFnInfo).fastpathDecMapIntfIntR) + fn(map[interface{}]int8(nil), (*encFnInfo).fastpathEncMapIntfInt8R, (*decFnInfo).fastpathDecMapIntfInt8R) + fn(map[interface{}]int16(nil), (*encFnInfo).fastpathEncMapIntfInt16R, (*decFnInfo).fastpathDecMapIntfInt16R) + fn(map[interface{}]int32(nil), (*encFnInfo).fastpathEncMapIntfInt32R, (*decFnInfo).fastpathDecMapIntfInt32R) + fn(map[interface{}]int64(nil), (*encFnInfo).fastpathEncMapIntfInt64R, (*decFnInfo).fastpathDecMapIntfInt64R) + fn(map[interface{}]float32(nil), (*encFnInfo).fastpathEncMapIntfFloat32R, (*decFnInfo).fastpathDecMapIntfFloat32R) + fn(map[interface{}]float64(nil), (*encFnInfo).fastpathEncMapIntfFloat64R, (*decFnInfo).fastpathDecMapIntfFloat64R) + fn(map[interface{}]bool(nil), (*encFnInfo).fastpathEncMapIntfBoolR, (*decFnInfo).fastpathDecMapIntfBoolR) + fn(map[string]interface{}(nil), (*encFnInfo).fastpathEncMapStringIntfR, (*decFnInfo).fastpathDecMapStringIntfR) + fn(map[string]string(nil), (*encFnInfo).fastpathEncMapStringStringR, (*decFnInfo).fastpathDecMapStringStringR) + fn(map[string]uint(nil), (*encFnInfo).fastpathEncMapStringUintR, (*decFnInfo).fastpathDecMapStringUintR) + fn(map[string]uint8(nil), (*encFnInfo).fastpathEncMapStringUint8R, (*decFnInfo).fastpathDecMapStringUint8R) + fn(map[string]uint16(nil), (*encFnInfo).fastpathEncMapStringUint16R, (*decFnInfo).fastpathDecMapStringUint16R) + fn(map[string]uint32(nil), (*encFnInfo).fastpathEncMapStringUint32R, (*decFnInfo).fastpathDecMapStringUint32R) + fn(map[string]uint64(nil), (*encFnInfo).fastpathEncMapStringUint64R, (*decFnInfo).fastpathDecMapStringUint64R) + fn(map[string]uintptr(nil), (*encFnInfo).fastpathEncMapStringUintptrR, (*decFnInfo).fastpathDecMapStringUintptrR) + fn(map[string]int(nil), (*encFnInfo).fastpathEncMapStringIntR, (*decFnInfo).fastpathDecMapStringIntR) + fn(map[string]int8(nil), (*encFnInfo).fastpathEncMapStringInt8R, (*decFnInfo).fastpathDecMapStringInt8R) + fn(map[string]int16(nil), (*encFnInfo).fastpathEncMapStringInt16R, (*decFnInfo).fastpathDecMapStringInt16R) + fn(map[string]int32(nil), (*encFnInfo).fastpathEncMapStringInt32R, (*decFnInfo).fastpathDecMapStringInt32R) + fn(map[string]int64(nil), (*encFnInfo).fastpathEncMapStringInt64R, (*decFnInfo).fastpathDecMapStringInt64R) + fn(map[string]float32(nil), (*encFnInfo).fastpathEncMapStringFloat32R, (*decFnInfo).fastpathDecMapStringFloat32R) + fn(map[string]float64(nil), (*encFnInfo).fastpathEncMapStringFloat64R, (*decFnInfo).fastpathDecMapStringFloat64R) + fn(map[string]bool(nil), (*encFnInfo).fastpathEncMapStringBoolR, (*decFnInfo).fastpathDecMapStringBoolR) + fn(map[float32]interface{}(nil), (*encFnInfo).fastpathEncMapFloat32IntfR, (*decFnInfo).fastpathDecMapFloat32IntfR) + fn(map[float32]string(nil), (*encFnInfo).fastpathEncMapFloat32StringR, (*decFnInfo).fastpathDecMapFloat32StringR) + fn(map[float32]uint(nil), (*encFnInfo).fastpathEncMapFloat32UintR, (*decFnInfo).fastpathDecMapFloat32UintR) + fn(map[float32]uint8(nil), (*encFnInfo).fastpathEncMapFloat32Uint8R, (*decFnInfo).fastpathDecMapFloat32Uint8R) + fn(map[float32]uint16(nil), (*encFnInfo).fastpathEncMapFloat32Uint16R, (*decFnInfo).fastpathDecMapFloat32Uint16R) + fn(map[float32]uint32(nil), (*encFnInfo).fastpathEncMapFloat32Uint32R, (*decFnInfo).fastpathDecMapFloat32Uint32R) + fn(map[float32]uint64(nil), (*encFnInfo).fastpathEncMapFloat32Uint64R, (*decFnInfo).fastpathDecMapFloat32Uint64R) + fn(map[float32]uintptr(nil), (*encFnInfo).fastpathEncMapFloat32UintptrR, (*decFnInfo).fastpathDecMapFloat32UintptrR) + fn(map[float32]int(nil), (*encFnInfo).fastpathEncMapFloat32IntR, (*decFnInfo).fastpathDecMapFloat32IntR) + fn(map[float32]int8(nil), (*encFnInfo).fastpathEncMapFloat32Int8R, (*decFnInfo).fastpathDecMapFloat32Int8R) + fn(map[float32]int16(nil), (*encFnInfo).fastpathEncMapFloat32Int16R, (*decFnInfo).fastpathDecMapFloat32Int16R) + fn(map[float32]int32(nil), (*encFnInfo).fastpathEncMapFloat32Int32R, (*decFnInfo).fastpathDecMapFloat32Int32R) + fn(map[float32]int64(nil), (*encFnInfo).fastpathEncMapFloat32Int64R, (*decFnInfo).fastpathDecMapFloat32Int64R) + fn(map[float32]float32(nil), (*encFnInfo).fastpathEncMapFloat32Float32R, (*decFnInfo).fastpathDecMapFloat32Float32R) + fn(map[float32]float64(nil), (*encFnInfo).fastpathEncMapFloat32Float64R, (*decFnInfo).fastpathDecMapFloat32Float64R) + fn(map[float32]bool(nil), (*encFnInfo).fastpathEncMapFloat32BoolR, (*decFnInfo).fastpathDecMapFloat32BoolR) + fn(map[float64]interface{}(nil), (*encFnInfo).fastpathEncMapFloat64IntfR, (*decFnInfo).fastpathDecMapFloat64IntfR) + fn(map[float64]string(nil), (*encFnInfo).fastpathEncMapFloat64StringR, (*decFnInfo).fastpathDecMapFloat64StringR) + fn(map[float64]uint(nil), (*encFnInfo).fastpathEncMapFloat64UintR, (*decFnInfo).fastpathDecMapFloat64UintR) + fn(map[float64]uint8(nil), (*encFnInfo).fastpathEncMapFloat64Uint8R, (*decFnInfo).fastpathDecMapFloat64Uint8R) + fn(map[float64]uint16(nil), (*encFnInfo).fastpathEncMapFloat64Uint16R, (*decFnInfo).fastpathDecMapFloat64Uint16R) + fn(map[float64]uint32(nil), (*encFnInfo).fastpathEncMapFloat64Uint32R, (*decFnInfo).fastpathDecMapFloat64Uint32R) + fn(map[float64]uint64(nil), (*encFnInfo).fastpathEncMapFloat64Uint64R, (*decFnInfo).fastpathDecMapFloat64Uint64R) + fn(map[float64]uintptr(nil), (*encFnInfo).fastpathEncMapFloat64UintptrR, (*decFnInfo).fastpathDecMapFloat64UintptrR) + fn(map[float64]int(nil), (*encFnInfo).fastpathEncMapFloat64IntR, (*decFnInfo).fastpathDecMapFloat64IntR) + fn(map[float64]int8(nil), (*encFnInfo).fastpathEncMapFloat64Int8R, (*decFnInfo).fastpathDecMapFloat64Int8R) + fn(map[float64]int16(nil), (*encFnInfo).fastpathEncMapFloat64Int16R, (*decFnInfo).fastpathDecMapFloat64Int16R) + fn(map[float64]int32(nil), (*encFnInfo).fastpathEncMapFloat64Int32R, (*decFnInfo).fastpathDecMapFloat64Int32R) + fn(map[float64]int64(nil), (*encFnInfo).fastpathEncMapFloat64Int64R, (*decFnInfo).fastpathDecMapFloat64Int64R) + fn(map[float64]float32(nil), (*encFnInfo).fastpathEncMapFloat64Float32R, (*decFnInfo).fastpathDecMapFloat64Float32R) + fn(map[float64]float64(nil), (*encFnInfo).fastpathEncMapFloat64Float64R, (*decFnInfo).fastpathDecMapFloat64Float64R) + fn(map[float64]bool(nil), (*encFnInfo).fastpathEncMapFloat64BoolR, (*decFnInfo).fastpathDecMapFloat64BoolR) + fn(map[uint]interface{}(nil), (*encFnInfo).fastpathEncMapUintIntfR, (*decFnInfo).fastpathDecMapUintIntfR) + fn(map[uint]string(nil), (*encFnInfo).fastpathEncMapUintStringR, (*decFnInfo).fastpathDecMapUintStringR) + fn(map[uint]uint(nil), (*encFnInfo).fastpathEncMapUintUintR, (*decFnInfo).fastpathDecMapUintUintR) + fn(map[uint]uint8(nil), (*encFnInfo).fastpathEncMapUintUint8R, (*decFnInfo).fastpathDecMapUintUint8R) + fn(map[uint]uint16(nil), (*encFnInfo).fastpathEncMapUintUint16R, (*decFnInfo).fastpathDecMapUintUint16R) + fn(map[uint]uint32(nil), (*encFnInfo).fastpathEncMapUintUint32R, (*decFnInfo).fastpathDecMapUintUint32R) + fn(map[uint]uint64(nil), (*encFnInfo).fastpathEncMapUintUint64R, (*decFnInfo).fastpathDecMapUintUint64R) + fn(map[uint]uintptr(nil), (*encFnInfo).fastpathEncMapUintUintptrR, (*decFnInfo).fastpathDecMapUintUintptrR) + fn(map[uint]int(nil), (*encFnInfo).fastpathEncMapUintIntR, (*decFnInfo).fastpathDecMapUintIntR) + fn(map[uint]int8(nil), (*encFnInfo).fastpathEncMapUintInt8R, (*decFnInfo).fastpathDecMapUintInt8R) + fn(map[uint]int16(nil), (*encFnInfo).fastpathEncMapUintInt16R, (*decFnInfo).fastpathDecMapUintInt16R) + fn(map[uint]int32(nil), (*encFnInfo).fastpathEncMapUintInt32R, (*decFnInfo).fastpathDecMapUintInt32R) + fn(map[uint]int64(nil), (*encFnInfo).fastpathEncMapUintInt64R, (*decFnInfo).fastpathDecMapUintInt64R) + fn(map[uint]float32(nil), (*encFnInfo).fastpathEncMapUintFloat32R, (*decFnInfo).fastpathDecMapUintFloat32R) + fn(map[uint]float64(nil), (*encFnInfo).fastpathEncMapUintFloat64R, (*decFnInfo).fastpathDecMapUintFloat64R) + fn(map[uint]bool(nil), (*encFnInfo).fastpathEncMapUintBoolR, (*decFnInfo).fastpathDecMapUintBoolR) + fn(map[uint8]interface{}(nil), (*encFnInfo).fastpathEncMapUint8IntfR, (*decFnInfo).fastpathDecMapUint8IntfR) + fn(map[uint8]string(nil), (*encFnInfo).fastpathEncMapUint8StringR, (*decFnInfo).fastpathDecMapUint8StringR) + fn(map[uint8]uint(nil), (*encFnInfo).fastpathEncMapUint8UintR, (*decFnInfo).fastpathDecMapUint8UintR) + fn(map[uint8]uint8(nil), (*encFnInfo).fastpathEncMapUint8Uint8R, (*decFnInfo).fastpathDecMapUint8Uint8R) + fn(map[uint8]uint16(nil), (*encFnInfo).fastpathEncMapUint8Uint16R, (*decFnInfo).fastpathDecMapUint8Uint16R) + fn(map[uint8]uint32(nil), (*encFnInfo).fastpathEncMapUint8Uint32R, (*decFnInfo).fastpathDecMapUint8Uint32R) + fn(map[uint8]uint64(nil), (*encFnInfo).fastpathEncMapUint8Uint64R, (*decFnInfo).fastpathDecMapUint8Uint64R) + fn(map[uint8]uintptr(nil), (*encFnInfo).fastpathEncMapUint8UintptrR, (*decFnInfo).fastpathDecMapUint8UintptrR) + fn(map[uint8]int(nil), (*encFnInfo).fastpathEncMapUint8IntR, (*decFnInfo).fastpathDecMapUint8IntR) + fn(map[uint8]int8(nil), (*encFnInfo).fastpathEncMapUint8Int8R, (*decFnInfo).fastpathDecMapUint8Int8R) + fn(map[uint8]int16(nil), (*encFnInfo).fastpathEncMapUint8Int16R, (*decFnInfo).fastpathDecMapUint8Int16R) + fn(map[uint8]int32(nil), (*encFnInfo).fastpathEncMapUint8Int32R, (*decFnInfo).fastpathDecMapUint8Int32R) + fn(map[uint8]int64(nil), (*encFnInfo).fastpathEncMapUint8Int64R, (*decFnInfo).fastpathDecMapUint8Int64R) + fn(map[uint8]float32(nil), (*encFnInfo).fastpathEncMapUint8Float32R, (*decFnInfo).fastpathDecMapUint8Float32R) + fn(map[uint8]float64(nil), (*encFnInfo).fastpathEncMapUint8Float64R, (*decFnInfo).fastpathDecMapUint8Float64R) + fn(map[uint8]bool(nil), (*encFnInfo).fastpathEncMapUint8BoolR, (*decFnInfo).fastpathDecMapUint8BoolR) + fn(map[uint16]interface{}(nil), (*encFnInfo).fastpathEncMapUint16IntfR, (*decFnInfo).fastpathDecMapUint16IntfR) + fn(map[uint16]string(nil), (*encFnInfo).fastpathEncMapUint16StringR, (*decFnInfo).fastpathDecMapUint16StringR) + fn(map[uint16]uint(nil), (*encFnInfo).fastpathEncMapUint16UintR, (*decFnInfo).fastpathDecMapUint16UintR) + fn(map[uint16]uint8(nil), (*encFnInfo).fastpathEncMapUint16Uint8R, (*decFnInfo).fastpathDecMapUint16Uint8R) + fn(map[uint16]uint16(nil), (*encFnInfo).fastpathEncMapUint16Uint16R, (*decFnInfo).fastpathDecMapUint16Uint16R) + fn(map[uint16]uint32(nil), (*encFnInfo).fastpathEncMapUint16Uint32R, (*decFnInfo).fastpathDecMapUint16Uint32R) + fn(map[uint16]uint64(nil), (*encFnInfo).fastpathEncMapUint16Uint64R, (*decFnInfo).fastpathDecMapUint16Uint64R) + fn(map[uint16]uintptr(nil), (*encFnInfo).fastpathEncMapUint16UintptrR, (*decFnInfo).fastpathDecMapUint16UintptrR) + fn(map[uint16]int(nil), (*encFnInfo).fastpathEncMapUint16IntR, (*decFnInfo).fastpathDecMapUint16IntR) + fn(map[uint16]int8(nil), (*encFnInfo).fastpathEncMapUint16Int8R, (*decFnInfo).fastpathDecMapUint16Int8R) + fn(map[uint16]int16(nil), (*encFnInfo).fastpathEncMapUint16Int16R, (*decFnInfo).fastpathDecMapUint16Int16R) + fn(map[uint16]int32(nil), (*encFnInfo).fastpathEncMapUint16Int32R, (*decFnInfo).fastpathDecMapUint16Int32R) + fn(map[uint16]int64(nil), (*encFnInfo).fastpathEncMapUint16Int64R, (*decFnInfo).fastpathDecMapUint16Int64R) + fn(map[uint16]float32(nil), (*encFnInfo).fastpathEncMapUint16Float32R, (*decFnInfo).fastpathDecMapUint16Float32R) + fn(map[uint16]float64(nil), (*encFnInfo).fastpathEncMapUint16Float64R, (*decFnInfo).fastpathDecMapUint16Float64R) + fn(map[uint16]bool(nil), (*encFnInfo).fastpathEncMapUint16BoolR, (*decFnInfo).fastpathDecMapUint16BoolR) + fn(map[uint32]interface{}(nil), (*encFnInfo).fastpathEncMapUint32IntfR, (*decFnInfo).fastpathDecMapUint32IntfR) + fn(map[uint32]string(nil), (*encFnInfo).fastpathEncMapUint32StringR, (*decFnInfo).fastpathDecMapUint32StringR) + fn(map[uint32]uint(nil), (*encFnInfo).fastpathEncMapUint32UintR, (*decFnInfo).fastpathDecMapUint32UintR) + fn(map[uint32]uint8(nil), (*encFnInfo).fastpathEncMapUint32Uint8R, (*decFnInfo).fastpathDecMapUint32Uint8R) + fn(map[uint32]uint16(nil), (*encFnInfo).fastpathEncMapUint32Uint16R, (*decFnInfo).fastpathDecMapUint32Uint16R) + fn(map[uint32]uint32(nil), (*encFnInfo).fastpathEncMapUint32Uint32R, (*decFnInfo).fastpathDecMapUint32Uint32R) + fn(map[uint32]uint64(nil), (*encFnInfo).fastpathEncMapUint32Uint64R, (*decFnInfo).fastpathDecMapUint32Uint64R) + fn(map[uint32]uintptr(nil), (*encFnInfo).fastpathEncMapUint32UintptrR, (*decFnInfo).fastpathDecMapUint32UintptrR) + fn(map[uint32]int(nil), (*encFnInfo).fastpathEncMapUint32IntR, (*decFnInfo).fastpathDecMapUint32IntR) + fn(map[uint32]int8(nil), (*encFnInfo).fastpathEncMapUint32Int8R, (*decFnInfo).fastpathDecMapUint32Int8R) + fn(map[uint32]int16(nil), (*encFnInfo).fastpathEncMapUint32Int16R, (*decFnInfo).fastpathDecMapUint32Int16R) + fn(map[uint32]int32(nil), (*encFnInfo).fastpathEncMapUint32Int32R, (*decFnInfo).fastpathDecMapUint32Int32R) + fn(map[uint32]int64(nil), (*encFnInfo).fastpathEncMapUint32Int64R, (*decFnInfo).fastpathDecMapUint32Int64R) + fn(map[uint32]float32(nil), (*encFnInfo).fastpathEncMapUint32Float32R, (*decFnInfo).fastpathDecMapUint32Float32R) + fn(map[uint32]float64(nil), (*encFnInfo).fastpathEncMapUint32Float64R, (*decFnInfo).fastpathDecMapUint32Float64R) + fn(map[uint32]bool(nil), (*encFnInfo).fastpathEncMapUint32BoolR, (*decFnInfo).fastpathDecMapUint32BoolR) + fn(map[uint64]interface{}(nil), (*encFnInfo).fastpathEncMapUint64IntfR, (*decFnInfo).fastpathDecMapUint64IntfR) + fn(map[uint64]string(nil), (*encFnInfo).fastpathEncMapUint64StringR, (*decFnInfo).fastpathDecMapUint64StringR) + fn(map[uint64]uint(nil), (*encFnInfo).fastpathEncMapUint64UintR, (*decFnInfo).fastpathDecMapUint64UintR) + fn(map[uint64]uint8(nil), (*encFnInfo).fastpathEncMapUint64Uint8R, (*decFnInfo).fastpathDecMapUint64Uint8R) + fn(map[uint64]uint16(nil), (*encFnInfo).fastpathEncMapUint64Uint16R, (*decFnInfo).fastpathDecMapUint64Uint16R) + fn(map[uint64]uint32(nil), (*encFnInfo).fastpathEncMapUint64Uint32R, (*decFnInfo).fastpathDecMapUint64Uint32R) + fn(map[uint64]uint64(nil), (*encFnInfo).fastpathEncMapUint64Uint64R, (*decFnInfo).fastpathDecMapUint64Uint64R) + fn(map[uint64]uintptr(nil), (*encFnInfo).fastpathEncMapUint64UintptrR, (*decFnInfo).fastpathDecMapUint64UintptrR) + fn(map[uint64]int(nil), (*encFnInfo).fastpathEncMapUint64IntR, (*decFnInfo).fastpathDecMapUint64IntR) + fn(map[uint64]int8(nil), (*encFnInfo).fastpathEncMapUint64Int8R, (*decFnInfo).fastpathDecMapUint64Int8R) + fn(map[uint64]int16(nil), (*encFnInfo).fastpathEncMapUint64Int16R, (*decFnInfo).fastpathDecMapUint64Int16R) + fn(map[uint64]int32(nil), (*encFnInfo).fastpathEncMapUint64Int32R, (*decFnInfo).fastpathDecMapUint64Int32R) + fn(map[uint64]int64(nil), (*encFnInfo).fastpathEncMapUint64Int64R, (*decFnInfo).fastpathDecMapUint64Int64R) + fn(map[uint64]float32(nil), (*encFnInfo).fastpathEncMapUint64Float32R, (*decFnInfo).fastpathDecMapUint64Float32R) + fn(map[uint64]float64(nil), (*encFnInfo).fastpathEncMapUint64Float64R, (*decFnInfo).fastpathDecMapUint64Float64R) + fn(map[uint64]bool(nil), (*encFnInfo).fastpathEncMapUint64BoolR, (*decFnInfo).fastpathDecMapUint64BoolR) + fn(map[uintptr]interface{}(nil), (*encFnInfo).fastpathEncMapUintptrIntfR, (*decFnInfo).fastpathDecMapUintptrIntfR) + fn(map[uintptr]string(nil), (*encFnInfo).fastpathEncMapUintptrStringR, (*decFnInfo).fastpathDecMapUintptrStringR) + fn(map[uintptr]uint(nil), (*encFnInfo).fastpathEncMapUintptrUintR, (*decFnInfo).fastpathDecMapUintptrUintR) + fn(map[uintptr]uint8(nil), (*encFnInfo).fastpathEncMapUintptrUint8R, (*decFnInfo).fastpathDecMapUintptrUint8R) + fn(map[uintptr]uint16(nil), (*encFnInfo).fastpathEncMapUintptrUint16R, (*decFnInfo).fastpathDecMapUintptrUint16R) + fn(map[uintptr]uint32(nil), (*encFnInfo).fastpathEncMapUintptrUint32R, (*decFnInfo).fastpathDecMapUintptrUint32R) + fn(map[uintptr]uint64(nil), (*encFnInfo).fastpathEncMapUintptrUint64R, (*decFnInfo).fastpathDecMapUintptrUint64R) + fn(map[uintptr]uintptr(nil), (*encFnInfo).fastpathEncMapUintptrUintptrR, (*decFnInfo).fastpathDecMapUintptrUintptrR) + fn(map[uintptr]int(nil), (*encFnInfo).fastpathEncMapUintptrIntR, (*decFnInfo).fastpathDecMapUintptrIntR) + fn(map[uintptr]int8(nil), (*encFnInfo).fastpathEncMapUintptrInt8R, (*decFnInfo).fastpathDecMapUintptrInt8R) + fn(map[uintptr]int16(nil), (*encFnInfo).fastpathEncMapUintptrInt16R, (*decFnInfo).fastpathDecMapUintptrInt16R) + fn(map[uintptr]int32(nil), (*encFnInfo).fastpathEncMapUintptrInt32R, (*decFnInfo).fastpathDecMapUintptrInt32R) + fn(map[uintptr]int64(nil), (*encFnInfo).fastpathEncMapUintptrInt64R, (*decFnInfo).fastpathDecMapUintptrInt64R) + fn(map[uintptr]float32(nil), (*encFnInfo).fastpathEncMapUintptrFloat32R, (*decFnInfo).fastpathDecMapUintptrFloat32R) + fn(map[uintptr]float64(nil), (*encFnInfo).fastpathEncMapUintptrFloat64R, (*decFnInfo).fastpathDecMapUintptrFloat64R) + fn(map[uintptr]bool(nil), (*encFnInfo).fastpathEncMapUintptrBoolR, (*decFnInfo).fastpathDecMapUintptrBoolR) + fn(map[int]interface{}(nil), (*encFnInfo).fastpathEncMapIntIntfR, (*decFnInfo).fastpathDecMapIntIntfR) + fn(map[int]string(nil), (*encFnInfo).fastpathEncMapIntStringR, (*decFnInfo).fastpathDecMapIntStringR) + fn(map[int]uint(nil), (*encFnInfo).fastpathEncMapIntUintR, (*decFnInfo).fastpathDecMapIntUintR) + fn(map[int]uint8(nil), (*encFnInfo).fastpathEncMapIntUint8R, (*decFnInfo).fastpathDecMapIntUint8R) + fn(map[int]uint16(nil), (*encFnInfo).fastpathEncMapIntUint16R, (*decFnInfo).fastpathDecMapIntUint16R) + fn(map[int]uint32(nil), (*encFnInfo).fastpathEncMapIntUint32R, (*decFnInfo).fastpathDecMapIntUint32R) + fn(map[int]uint64(nil), (*encFnInfo).fastpathEncMapIntUint64R, (*decFnInfo).fastpathDecMapIntUint64R) + fn(map[int]uintptr(nil), (*encFnInfo).fastpathEncMapIntUintptrR, (*decFnInfo).fastpathDecMapIntUintptrR) + fn(map[int]int(nil), (*encFnInfo).fastpathEncMapIntIntR, (*decFnInfo).fastpathDecMapIntIntR) + fn(map[int]int8(nil), (*encFnInfo).fastpathEncMapIntInt8R, (*decFnInfo).fastpathDecMapIntInt8R) + fn(map[int]int16(nil), (*encFnInfo).fastpathEncMapIntInt16R, (*decFnInfo).fastpathDecMapIntInt16R) + fn(map[int]int32(nil), (*encFnInfo).fastpathEncMapIntInt32R, (*decFnInfo).fastpathDecMapIntInt32R) + fn(map[int]int64(nil), (*encFnInfo).fastpathEncMapIntInt64R, (*decFnInfo).fastpathDecMapIntInt64R) + fn(map[int]float32(nil), (*encFnInfo).fastpathEncMapIntFloat32R, (*decFnInfo).fastpathDecMapIntFloat32R) + fn(map[int]float64(nil), (*encFnInfo).fastpathEncMapIntFloat64R, (*decFnInfo).fastpathDecMapIntFloat64R) + fn(map[int]bool(nil), (*encFnInfo).fastpathEncMapIntBoolR, (*decFnInfo).fastpathDecMapIntBoolR) + fn(map[int8]interface{}(nil), (*encFnInfo).fastpathEncMapInt8IntfR, (*decFnInfo).fastpathDecMapInt8IntfR) + fn(map[int8]string(nil), (*encFnInfo).fastpathEncMapInt8StringR, (*decFnInfo).fastpathDecMapInt8StringR) + fn(map[int8]uint(nil), (*encFnInfo).fastpathEncMapInt8UintR, (*decFnInfo).fastpathDecMapInt8UintR) + fn(map[int8]uint8(nil), (*encFnInfo).fastpathEncMapInt8Uint8R, (*decFnInfo).fastpathDecMapInt8Uint8R) + fn(map[int8]uint16(nil), (*encFnInfo).fastpathEncMapInt8Uint16R, (*decFnInfo).fastpathDecMapInt8Uint16R) + fn(map[int8]uint32(nil), (*encFnInfo).fastpathEncMapInt8Uint32R, (*decFnInfo).fastpathDecMapInt8Uint32R) + fn(map[int8]uint64(nil), (*encFnInfo).fastpathEncMapInt8Uint64R, (*decFnInfo).fastpathDecMapInt8Uint64R) + fn(map[int8]uintptr(nil), (*encFnInfo).fastpathEncMapInt8UintptrR, (*decFnInfo).fastpathDecMapInt8UintptrR) + fn(map[int8]int(nil), (*encFnInfo).fastpathEncMapInt8IntR, (*decFnInfo).fastpathDecMapInt8IntR) + fn(map[int8]int8(nil), (*encFnInfo).fastpathEncMapInt8Int8R, (*decFnInfo).fastpathDecMapInt8Int8R) + fn(map[int8]int16(nil), (*encFnInfo).fastpathEncMapInt8Int16R, (*decFnInfo).fastpathDecMapInt8Int16R) + fn(map[int8]int32(nil), (*encFnInfo).fastpathEncMapInt8Int32R, (*decFnInfo).fastpathDecMapInt8Int32R) + fn(map[int8]int64(nil), (*encFnInfo).fastpathEncMapInt8Int64R, (*decFnInfo).fastpathDecMapInt8Int64R) + fn(map[int8]float32(nil), (*encFnInfo).fastpathEncMapInt8Float32R, (*decFnInfo).fastpathDecMapInt8Float32R) + fn(map[int8]float64(nil), (*encFnInfo).fastpathEncMapInt8Float64R, (*decFnInfo).fastpathDecMapInt8Float64R) + fn(map[int8]bool(nil), (*encFnInfo).fastpathEncMapInt8BoolR, (*decFnInfo).fastpathDecMapInt8BoolR) + fn(map[int16]interface{}(nil), (*encFnInfo).fastpathEncMapInt16IntfR, (*decFnInfo).fastpathDecMapInt16IntfR) + fn(map[int16]string(nil), (*encFnInfo).fastpathEncMapInt16StringR, (*decFnInfo).fastpathDecMapInt16StringR) + fn(map[int16]uint(nil), (*encFnInfo).fastpathEncMapInt16UintR, (*decFnInfo).fastpathDecMapInt16UintR) + fn(map[int16]uint8(nil), (*encFnInfo).fastpathEncMapInt16Uint8R, (*decFnInfo).fastpathDecMapInt16Uint8R) + fn(map[int16]uint16(nil), (*encFnInfo).fastpathEncMapInt16Uint16R, (*decFnInfo).fastpathDecMapInt16Uint16R) + fn(map[int16]uint32(nil), (*encFnInfo).fastpathEncMapInt16Uint32R, (*decFnInfo).fastpathDecMapInt16Uint32R) + fn(map[int16]uint64(nil), (*encFnInfo).fastpathEncMapInt16Uint64R, (*decFnInfo).fastpathDecMapInt16Uint64R) + fn(map[int16]uintptr(nil), (*encFnInfo).fastpathEncMapInt16UintptrR, (*decFnInfo).fastpathDecMapInt16UintptrR) + fn(map[int16]int(nil), (*encFnInfo).fastpathEncMapInt16IntR, (*decFnInfo).fastpathDecMapInt16IntR) + fn(map[int16]int8(nil), (*encFnInfo).fastpathEncMapInt16Int8R, (*decFnInfo).fastpathDecMapInt16Int8R) + fn(map[int16]int16(nil), (*encFnInfo).fastpathEncMapInt16Int16R, (*decFnInfo).fastpathDecMapInt16Int16R) + fn(map[int16]int32(nil), (*encFnInfo).fastpathEncMapInt16Int32R, (*decFnInfo).fastpathDecMapInt16Int32R) + fn(map[int16]int64(nil), (*encFnInfo).fastpathEncMapInt16Int64R, (*decFnInfo).fastpathDecMapInt16Int64R) + fn(map[int16]float32(nil), (*encFnInfo).fastpathEncMapInt16Float32R, (*decFnInfo).fastpathDecMapInt16Float32R) + fn(map[int16]float64(nil), (*encFnInfo).fastpathEncMapInt16Float64R, (*decFnInfo).fastpathDecMapInt16Float64R) + fn(map[int16]bool(nil), (*encFnInfo).fastpathEncMapInt16BoolR, (*decFnInfo).fastpathDecMapInt16BoolR) + fn(map[int32]interface{}(nil), (*encFnInfo).fastpathEncMapInt32IntfR, (*decFnInfo).fastpathDecMapInt32IntfR) + fn(map[int32]string(nil), (*encFnInfo).fastpathEncMapInt32StringR, (*decFnInfo).fastpathDecMapInt32StringR) + fn(map[int32]uint(nil), (*encFnInfo).fastpathEncMapInt32UintR, (*decFnInfo).fastpathDecMapInt32UintR) + fn(map[int32]uint8(nil), (*encFnInfo).fastpathEncMapInt32Uint8R, (*decFnInfo).fastpathDecMapInt32Uint8R) + fn(map[int32]uint16(nil), (*encFnInfo).fastpathEncMapInt32Uint16R, (*decFnInfo).fastpathDecMapInt32Uint16R) + fn(map[int32]uint32(nil), (*encFnInfo).fastpathEncMapInt32Uint32R, (*decFnInfo).fastpathDecMapInt32Uint32R) + fn(map[int32]uint64(nil), (*encFnInfo).fastpathEncMapInt32Uint64R, (*decFnInfo).fastpathDecMapInt32Uint64R) + fn(map[int32]uintptr(nil), (*encFnInfo).fastpathEncMapInt32UintptrR, (*decFnInfo).fastpathDecMapInt32UintptrR) + fn(map[int32]int(nil), (*encFnInfo).fastpathEncMapInt32IntR, (*decFnInfo).fastpathDecMapInt32IntR) + fn(map[int32]int8(nil), (*encFnInfo).fastpathEncMapInt32Int8R, (*decFnInfo).fastpathDecMapInt32Int8R) + fn(map[int32]int16(nil), (*encFnInfo).fastpathEncMapInt32Int16R, (*decFnInfo).fastpathDecMapInt32Int16R) + fn(map[int32]int32(nil), (*encFnInfo).fastpathEncMapInt32Int32R, (*decFnInfo).fastpathDecMapInt32Int32R) + fn(map[int32]int64(nil), (*encFnInfo).fastpathEncMapInt32Int64R, (*decFnInfo).fastpathDecMapInt32Int64R) + fn(map[int32]float32(nil), (*encFnInfo).fastpathEncMapInt32Float32R, (*decFnInfo).fastpathDecMapInt32Float32R) + fn(map[int32]float64(nil), (*encFnInfo).fastpathEncMapInt32Float64R, (*decFnInfo).fastpathDecMapInt32Float64R) + fn(map[int32]bool(nil), (*encFnInfo).fastpathEncMapInt32BoolR, (*decFnInfo).fastpathDecMapInt32BoolR) + fn(map[int64]interface{}(nil), (*encFnInfo).fastpathEncMapInt64IntfR, (*decFnInfo).fastpathDecMapInt64IntfR) + fn(map[int64]string(nil), (*encFnInfo).fastpathEncMapInt64StringR, (*decFnInfo).fastpathDecMapInt64StringR) + fn(map[int64]uint(nil), (*encFnInfo).fastpathEncMapInt64UintR, (*decFnInfo).fastpathDecMapInt64UintR) + fn(map[int64]uint8(nil), (*encFnInfo).fastpathEncMapInt64Uint8R, (*decFnInfo).fastpathDecMapInt64Uint8R) + fn(map[int64]uint16(nil), (*encFnInfo).fastpathEncMapInt64Uint16R, (*decFnInfo).fastpathDecMapInt64Uint16R) + fn(map[int64]uint32(nil), (*encFnInfo).fastpathEncMapInt64Uint32R, (*decFnInfo).fastpathDecMapInt64Uint32R) + fn(map[int64]uint64(nil), (*encFnInfo).fastpathEncMapInt64Uint64R, (*decFnInfo).fastpathDecMapInt64Uint64R) + fn(map[int64]uintptr(nil), (*encFnInfo).fastpathEncMapInt64UintptrR, (*decFnInfo).fastpathDecMapInt64UintptrR) + fn(map[int64]int(nil), (*encFnInfo).fastpathEncMapInt64IntR, (*decFnInfo).fastpathDecMapInt64IntR) + fn(map[int64]int8(nil), (*encFnInfo).fastpathEncMapInt64Int8R, (*decFnInfo).fastpathDecMapInt64Int8R) + fn(map[int64]int16(nil), (*encFnInfo).fastpathEncMapInt64Int16R, (*decFnInfo).fastpathDecMapInt64Int16R) + fn(map[int64]int32(nil), (*encFnInfo).fastpathEncMapInt64Int32R, (*decFnInfo).fastpathDecMapInt64Int32R) + fn(map[int64]int64(nil), (*encFnInfo).fastpathEncMapInt64Int64R, (*decFnInfo).fastpathDecMapInt64Int64R) + fn(map[int64]float32(nil), (*encFnInfo).fastpathEncMapInt64Float32R, (*decFnInfo).fastpathDecMapInt64Float32R) + fn(map[int64]float64(nil), (*encFnInfo).fastpathEncMapInt64Float64R, (*decFnInfo).fastpathDecMapInt64Float64R) + fn(map[int64]bool(nil), (*encFnInfo).fastpathEncMapInt64BoolR, (*decFnInfo).fastpathDecMapInt64BoolR) + fn(map[bool]interface{}(nil), (*encFnInfo).fastpathEncMapBoolIntfR, (*decFnInfo).fastpathDecMapBoolIntfR) + fn(map[bool]string(nil), (*encFnInfo).fastpathEncMapBoolStringR, (*decFnInfo).fastpathDecMapBoolStringR) + fn(map[bool]uint(nil), (*encFnInfo).fastpathEncMapBoolUintR, (*decFnInfo).fastpathDecMapBoolUintR) + fn(map[bool]uint8(nil), (*encFnInfo).fastpathEncMapBoolUint8R, (*decFnInfo).fastpathDecMapBoolUint8R) + fn(map[bool]uint16(nil), (*encFnInfo).fastpathEncMapBoolUint16R, (*decFnInfo).fastpathDecMapBoolUint16R) + fn(map[bool]uint32(nil), (*encFnInfo).fastpathEncMapBoolUint32R, (*decFnInfo).fastpathDecMapBoolUint32R) + fn(map[bool]uint64(nil), (*encFnInfo).fastpathEncMapBoolUint64R, (*decFnInfo).fastpathDecMapBoolUint64R) + fn(map[bool]uintptr(nil), (*encFnInfo).fastpathEncMapBoolUintptrR, (*decFnInfo).fastpathDecMapBoolUintptrR) + fn(map[bool]int(nil), (*encFnInfo).fastpathEncMapBoolIntR, (*decFnInfo).fastpathDecMapBoolIntR) + fn(map[bool]int8(nil), (*encFnInfo).fastpathEncMapBoolInt8R, (*decFnInfo).fastpathDecMapBoolInt8R) + fn(map[bool]int16(nil), (*encFnInfo).fastpathEncMapBoolInt16R, (*decFnInfo).fastpathDecMapBoolInt16R) + fn(map[bool]int32(nil), (*encFnInfo).fastpathEncMapBoolInt32R, (*decFnInfo).fastpathDecMapBoolInt32R) + fn(map[bool]int64(nil), (*encFnInfo).fastpathEncMapBoolInt64R, (*decFnInfo).fastpathDecMapBoolInt64R) + fn(map[bool]float32(nil), (*encFnInfo).fastpathEncMapBoolFloat32R, (*decFnInfo).fastpathDecMapBoolFloat32R) + fn(map[bool]float64(nil), (*encFnInfo).fastpathEncMapBoolFloat64R, (*decFnInfo).fastpathDecMapBoolFloat64R) + fn(map[bool]bool(nil), (*encFnInfo).fastpathEncMapBoolBoolR, (*decFnInfo).fastpathDecMapBoolBoolR) + + sort.Sort(fastpathAslice(fastpathAV[:])) +} + +// -- encode + +// -- -- fast path type switch +func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool { + switch v := iv.(type) { + + case []interface{}: + fastpathTV.EncSliceIntfV(v, fastpathCheckNilTrue, e) + case *[]interface{}: + fastpathTV.EncSliceIntfV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]interface{}: + fastpathTV.EncMapIntfIntfV(v, fastpathCheckNilTrue, e) + case *map[interface{}]interface{}: + fastpathTV.EncMapIntfIntfV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]string: + fastpathTV.EncMapIntfStringV(v, fastpathCheckNilTrue, e) + case *map[interface{}]string: + fastpathTV.EncMapIntfStringV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uint: + fastpathTV.EncMapIntfUintV(v, fastpathCheckNilTrue, e) + case *map[interface{}]uint: + fastpathTV.EncMapIntfUintV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uint8: + fastpathTV.EncMapIntfUint8V(v, fastpathCheckNilTrue, e) + case *map[interface{}]uint8: + fastpathTV.EncMapIntfUint8V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uint16: + fastpathTV.EncMapIntfUint16V(v, fastpathCheckNilTrue, e) + case *map[interface{}]uint16: + fastpathTV.EncMapIntfUint16V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uint32: + fastpathTV.EncMapIntfUint32V(v, fastpathCheckNilTrue, e) + case *map[interface{}]uint32: + fastpathTV.EncMapIntfUint32V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uint64: + fastpathTV.EncMapIntfUint64V(v, fastpathCheckNilTrue, e) + case *map[interface{}]uint64: + fastpathTV.EncMapIntfUint64V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uintptr: + fastpathTV.EncMapIntfUintptrV(v, fastpathCheckNilTrue, e) + case *map[interface{}]uintptr: + fastpathTV.EncMapIntfUintptrV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]int: + fastpathTV.EncMapIntfIntV(v, fastpathCheckNilTrue, e) + case *map[interface{}]int: + fastpathTV.EncMapIntfIntV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]int8: + fastpathTV.EncMapIntfInt8V(v, fastpathCheckNilTrue, e) + case *map[interface{}]int8: + fastpathTV.EncMapIntfInt8V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]int16: + fastpathTV.EncMapIntfInt16V(v, fastpathCheckNilTrue, e) + case *map[interface{}]int16: + fastpathTV.EncMapIntfInt16V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]int32: + fastpathTV.EncMapIntfInt32V(v, fastpathCheckNilTrue, e) + case *map[interface{}]int32: + fastpathTV.EncMapIntfInt32V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]int64: + fastpathTV.EncMapIntfInt64V(v, fastpathCheckNilTrue, e) + case *map[interface{}]int64: + fastpathTV.EncMapIntfInt64V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]float32: + fastpathTV.EncMapIntfFloat32V(v, fastpathCheckNilTrue, e) + case *map[interface{}]float32: + fastpathTV.EncMapIntfFloat32V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]float64: + fastpathTV.EncMapIntfFloat64V(v, fastpathCheckNilTrue, e) + case *map[interface{}]float64: + fastpathTV.EncMapIntfFloat64V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]bool: + fastpathTV.EncMapIntfBoolV(v, fastpathCheckNilTrue, e) + case *map[interface{}]bool: + fastpathTV.EncMapIntfBoolV(*v, fastpathCheckNilTrue, e) + + case []string: + fastpathTV.EncSliceStringV(v, fastpathCheckNilTrue, e) + case *[]string: + fastpathTV.EncSliceStringV(*v, fastpathCheckNilTrue, e) + + case map[string]interface{}: + fastpathTV.EncMapStringIntfV(v, fastpathCheckNilTrue, e) + case *map[string]interface{}: + fastpathTV.EncMapStringIntfV(*v, fastpathCheckNilTrue, e) + + case map[string]string: + fastpathTV.EncMapStringStringV(v, fastpathCheckNilTrue, e) + case *map[string]string: + fastpathTV.EncMapStringStringV(*v, fastpathCheckNilTrue, e) + + case map[string]uint: + fastpathTV.EncMapStringUintV(v, fastpathCheckNilTrue, e) + case *map[string]uint: + fastpathTV.EncMapStringUintV(*v, fastpathCheckNilTrue, e) + + case map[string]uint8: + fastpathTV.EncMapStringUint8V(v, fastpathCheckNilTrue, e) + case *map[string]uint8: + fastpathTV.EncMapStringUint8V(*v, fastpathCheckNilTrue, e) + + case map[string]uint16: + fastpathTV.EncMapStringUint16V(v, fastpathCheckNilTrue, e) + case *map[string]uint16: + fastpathTV.EncMapStringUint16V(*v, fastpathCheckNilTrue, e) + + case map[string]uint32: + fastpathTV.EncMapStringUint32V(v, fastpathCheckNilTrue, e) + case *map[string]uint32: + fastpathTV.EncMapStringUint32V(*v, fastpathCheckNilTrue, e) + + case map[string]uint64: + fastpathTV.EncMapStringUint64V(v, fastpathCheckNilTrue, e) + case *map[string]uint64: + fastpathTV.EncMapStringUint64V(*v, fastpathCheckNilTrue, e) + + case map[string]uintptr: + fastpathTV.EncMapStringUintptrV(v, fastpathCheckNilTrue, e) + case *map[string]uintptr: + fastpathTV.EncMapStringUintptrV(*v, fastpathCheckNilTrue, e) + + case map[string]int: + fastpathTV.EncMapStringIntV(v, fastpathCheckNilTrue, e) + case *map[string]int: + fastpathTV.EncMapStringIntV(*v, fastpathCheckNilTrue, e) + + case map[string]int8: + fastpathTV.EncMapStringInt8V(v, fastpathCheckNilTrue, e) + case *map[string]int8: + fastpathTV.EncMapStringInt8V(*v, fastpathCheckNilTrue, e) + + case map[string]int16: + fastpathTV.EncMapStringInt16V(v, fastpathCheckNilTrue, e) + case *map[string]int16: + fastpathTV.EncMapStringInt16V(*v, fastpathCheckNilTrue, e) + + case map[string]int32: + fastpathTV.EncMapStringInt32V(v, fastpathCheckNilTrue, e) + case *map[string]int32: + fastpathTV.EncMapStringInt32V(*v, fastpathCheckNilTrue, e) + + case map[string]int64: + fastpathTV.EncMapStringInt64V(v, fastpathCheckNilTrue, e) + case *map[string]int64: + fastpathTV.EncMapStringInt64V(*v, fastpathCheckNilTrue, e) + + case map[string]float32: + fastpathTV.EncMapStringFloat32V(v, fastpathCheckNilTrue, e) + case *map[string]float32: + fastpathTV.EncMapStringFloat32V(*v, fastpathCheckNilTrue, e) + + case map[string]float64: + fastpathTV.EncMapStringFloat64V(v, fastpathCheckNilTrue, e) + case *map[string]float64: + fastpathTV.EncMapStringFloat64V(*v, fastpathCheckNilTrue, e) + + case map[string]bool: + fastpathTV.EncMapStringBoolV(v, fastpathCheckNilTrue, e) + case *map[string]bool: + fastpathTV.EncMapStringBoolV(*v, fastpathCheckNilTrue, e) + + case []float32: + fastpathTV.EncSliceFloat32V(v, fastpathCheckNilTrue, e) + case *[]float32: + fastpathTV.EncSliceFloat32V(*v, fastpathCheckNilTrue, e) + + case map[float32]interface{}: + fastpathTV.EncMapFloat32IntfV(v, fastpathCheckNilTrue, e) + case *map[float32]interface{}: + fastpathTV.EncMapFloat32IntfV(*v, fastpathCheckNilTrue, e) + + case map[float32]string: + fastpathTV.EncMapFloat32StringV(v, fastpathCheckNilTrue, e) + case *map[float32]string: + fastpathTV.EncMapFloat32StringV(*v, fastpathCheckNilTrue, e) + + case map[float32]uint: + fastpathTV.EncMapFloat32UintV(v, fastpathCheckNilTrue, e) + case *map[float32]uint: + fastpathTV.EncMapFloat32UintV(*v, fastpathCheckNilTrue, e) + + case map[float32]uint8: + fastpathTV.EncMapFloat32Uint8V(v, fastpathCheckNilTrue, e) + case *map[float32]uint8: + fastpathTV.EncMapFloat32Uint8V(*v, fastpathCheckNilTrue, e) + + case map[float32]uint16: + fastpathTV.EncMapFloat32Uint16V(v, fastpathCheckNilTrue, e) + case *map[float32]uint16: + fastpathTV.EncMapFloat32Uint16V(*v, fastpathCheckNilTrue, e) + + case map[float32]uint32: + fastpathTV.EncMapFloat32Uint32V(v, fastpathCheckNilTrue, e) + case *map[float32]uint32: + fastpathTV.EncMapFloat32Uint32V(*v, fastpathCheckNilTrue, e) + + case map[float32]uint64: + fastpathTV.EncMapFloat32Uint64V(v, fastpathCheckNilTrue, e) + case *map[float32]uint64: + fastpathTV.EncMapFloat32Uint64V(*v, fastpathCheckNilTrue, e) + + case map[float32]uintptr: + fastpathTV.EncMapFloat32UintptrV(v, fastpathCheckNilTrue, e) + case *map[float32]uintptr: + fastpathTV.EncMapFloat32UintptrV(*v, fastpathCheckNilTrue, e) + + case map[float32]int: + fastpathTV.EncMapFloat32IntV(v, fastpathCheckNilTrue, e) + case *map[float32]int: + fastpathTV.EncMapFloat32IntV(*v, fastpathCheckNilTrue, e) + + case map[float32]int8: + fastpathTV.EncMapFloat32Int8V(v, fastpathCheckNilTrue, e) + case *map[float32]int8: + fastpathTV.EncMapFloat32Int8V(*v, fastpathCheckNilTrue, e) + + case map[float32]int16: + fastpathTV.EncMapFloat32Int16V(v, fastpathCheckNilTrue, e) + case *map[float32]int16: + fastpathTV.EncMapFloat32Int16V(*v, fastpathCheckNilTrue, e) + + case map[float32]int32: + fastpathTV.EncMapFloat32Int32V(v, fastpathCheckNilTrue, e) + case *map[float32]int32: + fastpathTV.EncMapFloat32Int32V(*v, fastpathCheckNilTrue, e) + + case map[float32]int64: + fastpathTV.EncMapFloat32Int64V(v, fastpathCheckNilTrue, e) + case *map[float32]int64: + fastpathTV.EncMapFloat32Int64V(*v, fastpathCheckNilTrue, e) + + case map[float32]float32: + fastpathTV.EncMapFloat32Float32V(v, fastpathCheckNilTrue, e) + case *map[float32]float32: + fastpathTV.EncMapFloat32Float32V(*v, fastpathCheckNilTrue, e) + + case map[float32]float64: + fastpathTV.EncMapFloat32Float64V(v, fastpathCheckNilTrue, e) + case *map[float32]float64: + fastpathTV.EncMapFloat32Float64V(*v, fastpathCheckNilTrue, e) + + case map[float32]bool: + fastpathTV.EncMapFloat32BoolV(v, fastpathCheckNilTrue, e) + case *map[float32]bool: + fastpathTV.EncMapFloat32BoolV(*v, fastpathCheckNilTrue, e) + + case []float64: + fastpathTV.EncSliceFloat64V(v, fastpathCheckNilTrue, e) + case *[]float64: + fastpathTV.EncSliceFloat64V(*v, fastpathCheckNilTrue, e) + + case map[float64]interface{}: + fastpathTV.EncMapFloat64IntfV(v, fastpathCheckNilTrue, e) + case *map[float64]interface{}: + fastpathTV.EncMapFloat64IntfV(*v, fastpathCheckNilTrue, e) + + case map[float64]string: + fastpathTV.EncMapFloat64StringV(v, fastpathCheckNilTrue, e) + case *map[float64]string: + fastpathTV.EncMapFloat64StringV(*v, fastpathCheckNilTrue, e) + + case map[float64]uint: + fastpathTV.EncMapFloat64UintV(v, fastpathCheckNilTrue, e) + case *map[float64]uint: + fastpathTV.EncMapFloat64UintV(*v, fastpathCheckNilTrue, e) + + case map[float64]uint8: + fastpathTV.EncMapFloat64Uint8V(v, fastpathCheckNilTrue, e) + case *map[float64]uint8: + fastpathTV.EncMapFloat64Uint8V(*v, fastpathCheckNilTrue, e) + + case map[float64]uint16: + fastpathTV.EncMapFloat64Uint16V(v, fastpathCheckNilTrue, e) + case *map[float64]uint16: + fastpathTV.EncMapFloat64Uint16V(*v, fastpathCheckNilTrue, e) + + case map[float64]uint32: + fastpathTV.EncMapFloat64Uint32V(v, fastpathCheckNilTrue, e) + case *map[float64]uint32: + fastpathTV.EncMapFloat64Uint32V(*v, fastpathCheckNilTrue, e) + + case map[float64]uint64: + fastpathTV.EncMapFloat64Uint64V(v, fastpathCheckNilTrue, e) + case *map[float64]uint64: + fastpathTV.EncMapFloat64Uint64V(*v, fastpathCheckNilTrue, e) + + case map[float64]uintptr: + fastpathTV.EncMapFloat64UintptrV(v, fastpathCheckNilTrue, e) + case *map[float64]uintptr: + fastpathTV.EncMapFloat64UintptrV(*v, fastpathCheckNilTrue, e) + + case map[float64]int: + fastpathTV.EncMapFloat64IntV(v, fastpathCheckNilTrue, e) + case *map[float64]int: + fastpathTV.EncMapFloat64IntV(*v, fastpathCheckNilTrue, e) + + case map[float64]int8: + fastpathTV.EncMapFloat64Int8V(v, fastpathCheckNilTrue, e) + case *map[float64]int8: + fastpathTV.EncMapFloat64Int8V(*v, fastpathCheckNilTrue, e) + + case map[float64]int16: + fastpathTV.EncMapFloat64Int16V(v, fastpathCheckNilTrue, e) + case *map[float64]int16: + fastpathTV.EncMapFloat64Int16V(*v, fastpathCheckNilTrue, e) + + case map[float64]int32: + fastpathTV.EncMapFloat64Int32V(v, fastpathCheckNilTrue, e) + case *map[float64]int32: + fastpathTV.EncMapFloat64Int32V(*v, fastpathCheckNilTrue, e) + + case map[float64]int64: + fastpathTV.EncMapFloat64Int64V(v, fastpathCheckNilTrue, e) + case *map[float64]int64: + fastpathTV.EncMapFloat64Int64V(*v, fastpathCheckNilTrue, e) + + case map[float64]float32: + fastpathTV.EncMapFloat64Float32V(v, fastpathCheckNilTrue, e) + case *map[float64]float32: + fastpathTV.EncMapFloat64Float32V(*v, fastpathCheckNilTrue, e) + + case map[float64]float64: + fastpathTV.EncMapFloat64Float64V(v, fastpathCheckNilTrue, e) + case *map[float64]float64: + fastpathTV.EncMapFloat64Float64V(*v, fastpathCheckNilTrue, e) + + case map[float64]bool: + fastpathTV.EncMapFloat64BoolV(v, fastpathCheckNilTrue, e) + case *map[float64]bool: + fastpathTV.EncMapFloat64BoolV(*v, fastpathCheckNilTrue, e) + + case []uint: + fastpathTV.EncSliceUintV(v, fastpathCheckNilTrue, e) + case *[]uint: + fastpathTV.EncSliceUintV(*v, fastpathCheckNilTrue, e) + + case map[uint]interface{}: + fastpathTV.EncMapUintIntfV(v, fastpathCheckNilTrue, e) + case *map[uint]interface{}: + fastpathTV.EncMapUintIntfV(*v, fastpathCheckNilTrue, e) + + case map[uint]string: + fastpathTV.EncMapUintStringV(v, fastpathCheckNilTrue, e) + case *map[uint]string: + fastpathTV.EncMapUintStringV(*v, fastpathCheckNilTrue, e) + + case map[uint]uint: + fastpathTV.EncMapUintUintV(v, fastpathCheckNilTrue, e) + case *map[uint]uint: + fastpathTV.EncMapUintUintV(*v, fastpathCheckNilTrue, e) + + case map[uint]uint8: + fastpathTV.EncMapUintUint8V(v, fastpathCheckNilTrue, e) + case *map[uint]uint8: + fastpathTV.EncMapUintUint8V(*v, fastpathCheckNilTrue, e) + + case map[uint]uint16: + fastpathTV.EncMapUintUint16V(v, fastpathCheckNilTrue, e) + case *map[uint]uint16: + fastpathTV.EncMapUintUint16V(*v, fastpathCheckNilTrue, e) + + case map[uint]uint32: + fastpathTV.EncMapUintUint32V(v, fastpathCheckNilTrue, e) + case *map[uint]uint32: + fastpathTV.EncMapUintUint32V(*v, fastpathCheckNilTrue, e) + + case map[uint]uint64: + fastpathTV.EncMapUintUint64V(v, fastpathCheckNilTrue, e) + case *map[uint]uint64: + fastpathTV.EncMapUintUint64V(*v, fastpathCheckNilTrue, e) + + case map[uint]uintptr: + fastpathTV.EncMapUintUintptrV(v, fastpathCheckNilTrue, e) + case *map[uint]uintptr: + fastpathTV.EncMapUintUintptrV(*v, fastpathCheckNilTrue, e) + + case map[uint]int: + fastpathTV.EncMapUintIntV(v, fastpathCheckNilTrue, e) + case *map[uint]int: + fastpathTV.EncMapUintIntV(*v, fastpathCheckNilTrue, e) + + case map[uint]int8: + fastpathTV.EncMapUintInt8V(v, fastpathCheckNilTrue, e) + case *map[uint]int8: + fastpathTV.EncMapUintInt8V(*v, fastpathCheckNilTrue, e) + + case map[uint]int16: + fastpathTV.EncMapUintInt16V(v, fastpathCheckNilTrue, e) + case *map[uint]int16: + fastpathTV.EncMapUintInt16V(*v, fastpathCheckNilTrue, e) + + case map[uint]int32: + fastpathTV.EncMapUintInt32V(v, fastpathCheckNilTrue, e) + case *map[uint]int32: + fastpathTV.EncMapUintInt32V(*v, fastpathCheckNilTrue, e) + + case map[uint]int64: + fastpathTV.EncMapUintInt64V(v, fastpathCheckNilTrue, e) + case *map[uint]int64: + fastpathTV.EncMapUintInt64V(*v, fastpathCheckNilTrue, e) + + case map[uint]float32: + fastpathTV.EncMapUintFloat32V(v, fastpathCheckNilTrue, e) + case *map[uint]float32: + fastpathTV.EncMapUintFloat32V(*v, fastpathCheckNilTrue, e) + + case map[uint]float64: + fastpathTV.EncMapUintFloat64V(v, fastpathCheckNilTrue, e) + case *map[uint]float64: + fastpathTV.EncMapUintFloat64V(*v, fastpathCheckNilTrue, e) + + case map[uint]bool: + fastpathTV.EncMapUintBoolV(v, fastpathCheckNilTrue, e) + case *map[uint]bool: + fastpathTV.EncMapUintBoolV(*v, fastpathCheckNilTrue, e) + + case map[uint8]interface{}: + fastpathTV.EncMapUint8IntfV(v, fastpathCheckNilTrue, e) + case *map[uint8]interface{}: + fastpathTV.EncMapUint8IntfV(*v, fastpathCheckNilTrue, e) + + case map[uint8]string: + fastpathTV.EncMapUint8StringV(v, fastpathCheckNilTrue, e) + case *map[uint8]string: + fastpathTV.EncMapUint8StringV(*v, fastpathCheckNilTrue, e) + + case map[uint8]uint: + fastpathTV.EncMapUint8UintV(v, fastpathCheckNilTrue, e) + case *map[uint8]uint: + fastpathTV.EncMapUint8UintV(*v, fastpathCheckNilTrue, e) + + case map[uint8]uint8: + fastpathTV.EncMapUint8Uint8V(v, fastpathCheckNilTrue, e) + case *map[uint8]uint8: + fastpathTV.EncMapUint8Uint8V(*v, fastpathCheckNilTrue, e) + + case map[uint8]uint16: + fastpathTV.EncMapUint8Uint16V(v, fastpathCheckNilTrue, e) + case *map[uint8]uint16: + fastpathTV.EncMapUint8Uint16V(*v, fastpathCheckNilTrue, e) + + case map[uint8]uint32: + fastpathTV.EncMapUint8Uint32V(v, fastpathCheckNilTrue, e) + case *map[uint8]uint32: + fastpathTV.EncMapUint8Uint32V(*v, fastpathCheckNilTrue, e) + + case map[uint8]uint64: + fastpathTV.EncMapUint8Uint64V(v, fastpathCheckNilTrue, e) + case *map[uint8]uint64: + fastpathTV.EncMapUint8Uint64V(*v, fastpathCheckNilTrue, e) + + case map[uint8]uintptr: + fastpathTV.EncMapUint8UintptrV(v, fastpathCheckNilTrue, e) + case *map[uint8]uintptr: + fastpathTV.EncMapUint8UintptrV(*v, fastpathCheckNilTrue, e) + + case map[uint8]int: + fastpathTV.EncMapUint8IntV(v, fastpathCheckNilTrue, e) + case *map[uint8]int: + fastpathTV.EncMapUint8IntV(*v, fastpathCheckNilTrue, e) + + case map[uint8]int8: + fastpathTV.EncMapUint8Int8V(v, fastpathCheckNilTrue, e) + case *map[uint8]int8: + fastpathTV.EncMapUint8Int8V(*v, fastpathCheckNilTrue, e) + + case map[uint8]int16: + fastpathTV.EncMapUint8Int16V(v, fastpathCheckNilTrue, e) + case *map[uint8]int16: + fastpathTV.EncMapUint8Int16V(*v, fastpathCheckNilTrue, e) + + case map[uint8]int32: + fastpathTV.EncMapUint8Int32V(v, fastpathCheckNilTrue, e) + case *map[uint8]int32: + fastpathTV.EncMapUint8Int32V(*v, fastpathCheckNilTrue, e) + + case map[uint8]int64: + fastpathTV.EncMapUint8Int64V(v, fastpathCheckNilTrue, e) + case *map[uint8]int64: + fastpathTV.EncMapUint8Int64V(*v, fastpathCheckNilTrue, e) + + case map[uint8]float32: + fastpathTV.EncMapUint8Float32V(v, fastpathCheckNilTrue, e) + case *map[uint8]float32: + fastpathTV.EncMapUint8Float32V(*v, fastpathCheckNilTrue, e) + + case map[uint8]float64: + fastpathTV.EncMapUint8Float64V(v, fastpathCheckNilTrue, e) + case *map[uint8]float64: + fastpathTV.EncMapUint8Float64V(*v, fastpathCheckNilTrue, e) + + case map[uint8]bool: + fastpathTV.EncMapUint8BoolV(v, fastpathCheckNilTrue, e) + case *map[uint8]bool: + fastpathTV.EncMapUint8BoolV(*v, fastpathCheckNilTrue, e) + + case []uint16: + fastpathTV.EncSliceUint16V(v, fastpathCheckNilTrue, e) + case *[]uint16: + fastpathTV.EncSliceUint16V(*v, fastpathCheckNilTrue, e) + + case map[uint16]interface{}: + fastpathTV.EncMapUint16IntfV(v, fastpathCheckNilTrue, e) + case *map[uint16]interface{}: + fastpathTV.EncMapUint16IntfV(*v, fastpathCheckNilTrue, e) + + case map[uint16]string: + fastpathTV.EncMapUint16StringV(v, fastpathCheckNilTrue, e) + case *map[uint16]string: + fastpathTV.EncMapUint16StringV(*v, fastpathCheckNilTrue, e) + + case map[uint16]uint: + fastpathTV.EncMapUint16UintV(v, fastpathCheckNilTrue, e) + case *map[uint16]uint: + fastpathTV.EncMapUint16UintV(*v, fastpathCheckNilTrue, e) + + case map[uint16]uint8: + fastpathTV.EncMapUint16Uint8V(v, fastpathCheckNilTrue, e) + case *map[uint16]uint8: + fastpathTV.EncMapUint16Uint8V(*v, fastpathCheckNilTrue, e) + + case map[uint16]uint16: + fastpathTV.EncMapUint16Uint16V(v, fastpathCheckNilTrue, e) + case *map[uint16]uint16: + fastpathTV.EncMapUint16Uint16V(*v, fastpathCheckNilTrue, e) + + case map[uint16]uint32: + fastpathTV.EncMapUint16Uint32V(v, fastpathCheckNilTrue, e) + case *map[uint16]uint32: + fastpathTV.EncMapUint16Uint32V(*v, fastpathCheckNilTrue, e) + + case map[uint16]uint64: + fastpathTV.EncMapUint16Uint64V(v, fastpathCheckNilTrue, e) + case *map[uint16]uint64: + fastpathTV.EncMapUint16Uint64V(*v, fastpathCheckNilTrue, e) + + case map[uint16]uintptr: + fastpathTV.EncMapUint16UintptrV(v, fastpathCheckNilTrue, e) + case *map[uint16]uintptr: + fastpathTV.EncMapUint16UintptrV(*v, fastpathCheckNilTrue, e) + + case map[uint16]int: + fastpathTV.EncMapUint16IntV(v, fastpathCheckNilTrue, e) + case *map[uint16]int: + fastpathTV.EncMapUint16IntV(*v, fastpathCheckNilTrue, e) + + case map[uint16]int8: + fastpathTV.EncMapUint16Int8V(v, fastpathCheckNilTrue, e) + case *map[uint16]int8: + fastpathTV.EncMapUint16Int8V(*v, fastpathCheckNilTrue, e) + + case map[uint16]int16: + fastpathTV.EncMapUint16Int16V(v, fastpathCheckNilTrue, e) + case *map[uint16]int16: + fastpathTV.EncMapUint16Int16V(*v, fastpathCheckNilTrue, e) + + case map[uint16]int32: + fastpathTV.EncMapUint16Int32V(v, fastpathCheckNilTrue, e) + case *map[uint16]int32: + fastpathTV.EncMapUint16Int32V(*v, fastpathCheckNilTrue, e) + + case map[uint16]int64: + fastpathTV.EncMapUint16Int64V(v, fastpathCheckNilTrue, e) + case *map[uint16]int64: + fastpathTV.EncMapUint16Int64V(*v, fastpathCheckNilTrue, e) + + case map[uint16]float32: + fastpathTV.EncMapUint16Float32V(v, fastpathCheckNilTrue, e) + case *map[uint16]float32: + fastpathTV.EncMapUint16Float32V(*v, fastpathCheckNilTrue, e) + + case map[uint16]float64: + fastpathTV.EncMapUint16Float64V(v, fastpathCheckNilTrue, e) + case *map[uint16]float64: + fastpathTV.EncMapUint16Float64V(*v, fastpathCheckNilTrue, e) + + case map[uint16]bool: + fastpathTV.EncMapUint16BoolV(v, fastpathCheckNilTrue, e) + case *map[uint16]bool: + fastpathTV.EncMapUint16BoolV(*v, fastpathCheckNilTrue, e) + + case []uint32: + fastpathTV.EncSliceUint32V(v, fastpathCheckNilTrue, e) + case *[]uint32: + fastpathTV.EncSliceUint32V(*v, fastpathCheckNilTrue, e) + + case map[uint32]interface{}: + fastpathTV.EncMapUint32IntfV(v, fastpathCheckNilTrue, e) + case *map[uint32]interface{}: + fastpathTV.EncMapUint32IntfV(*v, fastpathCheckNilTrue, e) + + case map[uint32]string: + fastpathTV.EncMapUint32StringV(v, fastpathCheckNilTrue, e) + case *map[uint32]string: + fastpathTV.EncMapUint32StringV(*v, fastpathCheckNilTrue, e) + + case map[uint32]uint: + fastpathTV.EncMapUint32UintV(v, fastpathCheckNilTrue, e) + case *map[uint32]uint: + fastpathTV.EncMapUint32UintV(*v, fastpathCheckNilTrue, e) + + case map[uint32]uint8: + fastpathTV.EncMapUint32Uint8V(v, fastpathCheckNilTrue, e) + case *map[uint32]uint8: + fastpathTV.EncMapUint32Uint8V(*v, fastpathCheckNilTrue, e) + + case map[uint32]uint16: + fastpathTV.EncMapUint32Uint16V(v, fastpathCheckNilTrue, e) + case *map[uint32]uint16: + fastpathTV.EncMapUint32Uint16V(*v, fastpathCheckNilTrue, e) + + case map[uint32]uint32: + fastpathTV.EncMapUint32Uint32V(v, fastpathCheckNilTrue, e) + case *map[uint32]uint32: + fastpathTV.EncMapUint32Uint32V(*v, fastpathCheckNilTrue, e) + + case map[uint32]uint64: + fastpathTV.EncMapUint32Uint64V(v, fastpathCheckNilTrue, e) + case *map[uint32]uint64: + fastpathTV.EncMapUint32Uint64V(*v, fastpathCheckNilTrue, e) + + case map[uint32]uintptr: + fastpathTV.EncMapUint32UintptrV(v, fastpathCheckNilTrue, e) + case *map[uint32]uintptr: + fastpathTV.EncMapUint32UintptrV(*v, fastpathCheckNilTrue, e) + + case map[uint32]int: + fastpathTV.EncMapUint32IntV(v, fastpathCheckNilTrue, e) + case *map[uint32]int: + fastpathTV.EncMapUint32IntV(*v, fastpathCheckNilTrue, e) + + case map[uint32]int8: + fastpathTV.EncMapUint32Int8V(v, fastpathCheckNilTrue, e) + case *map[uint32]int8: + fastpathTV.EncMapUint32Int8V(*v, fastpathCheckNilTrue, e) + + case map[uint32]int16: + fastpathTV.EncMapUint32Int16V(v, fastpathCheckNilTrue, e) + case *map[uint32]int16: + fastpathTV.EncMapUint32Int16V(*v, fastpathCheckNilTrue, e) + + case map[uint32]int32: + fastpathTV.EncMapUint32Int32V(v, fastpathCheckNilTrue, e) + case *map[uint32]int32: + fastpathTV.EncMapUint32Int32V(*v, fastpathCheckNilTrue, e) + + case map[uint32]int64: + fastpathTV.EncMapUint32Int64V(v, fastpathCheckNilTrue, e) + case *map[uint32]int64: + fastpathTV.EncMapUint32Int64V(*v, fastpathCheckNilTrue, e) + + case map[uint32]float32: + fastpathTV.EncMapUint32Float32V(v, fastpathCheckNilTrue, e) + case *map[uint32]float32: + fastpathTV.EncMapUint32Float32V(*v, fastpathCheckNilTrue, e) + + case map[uint32]float64: + fastpathTV.EncMapUint32Float64V(v, fastpathCheckNilTrue, e) + case *map[uint32]float64: + fastpathTV.EncMapUint32Float64V(*v, fastpathCheckNilTrue, e) + + case map[uint32]bool: + fastpathTV.EncMapUint32BoolV(v, fastpathCheckNilTrue, e) + case *map[uint32]bool: + fastpathTV.EncMapUint32BoolV(*v, fastpathCheckNilTrue, e) + + case []uint64: + fastpathTV.EncSliceUint64V(v, fastpathCheckNilTrue, e) + case *[]uint64: + fastpathTV.EncSliceUint64V(*v, fastpathCheckNilTrue, e) + + case map[uint64]interface{}: + fastpathTV.EncMapUint64IntfV(v, fastpathCheckNilTrue, e) + case *map[uint64]interface{}: + fastpathTV.EncMapUint64IntfV(*v, fastpathCheckNilTrue, e) + + case map[uint64]string: + fastpathTV.EncMapUint64StringV(v, fastpathCheckNilTrue, e) + case *map[uint64]string: + fastpathTV.EncMapUint64StringV(*v, fastpathCheckNilTrue, e) + + case map[uint64]uint: + fastpathTV.EncMapUint64UintV(v, fastpathCheckNilTrue, e) + case *map[uint64]uint: + fastpathTV.EncMapUint64UintV(*v, fastpathCheckNilTrue, e) + + case map[uint64]uint8: + fastpathTV.EncMapUint64Uint8V(v, fastpathCheckNilTrue, e) + case *map[uint64]uint8: + fastpathTV.EncMapUint64Uint8V(*v, fastpathCheckNilTrue, e) + + case map[uint64]uint16: + fastpathTV.EncMapUint64Uint16V(v, fastpathCheckNilTrue, e) + case *map[uint64]uint16: + fastpathTV.EncMapUint64Uint16V(*v, fastpathCheckNilTrue, e) + + case map[uint64]uint32: + fastpathTV.EncMapUint64Uint32V(v, fastpathCheckNilTrue, e) + case *map[uint64]uint32: + fastpathTV.EncMapUint64Uint32V(*v, fastpathCheckNilTrue, e) + + case map[uint64]uint64: + fastpathTV.EncMapUint64Uint64V(v, fastpathCheckNilTrue, e) + case *map[uint64]uint64: + fastpathTV.EncMapUint64Uint64V(*v, fastpathCheckNilTrue, e) + + case map[uint64]uintptr: + fastpathTV.EncMapUint64UintptrV(v, fastpathCheckNilTrue, e) + case *map[uint64]uintptr: + fastpathTV.EncMapUint64UintptrV(*v, fastpathCheckNilTrue, e) + + case map[uint64]int: + fastpathTV.EncMapUint64IntV(v, fastpathCheckNilTrue, e) + case *map[uint64]int: + fastpathTV.EncMapUint64IntV(*v, fastpathCheckNilTrue, e) + + case map[uint64]int8: + fastpathTV.EncMapUint64Int8V(v, fastpathCheckNilTrue, e) + case *map[uint64]int8: + fastpathTV.EncMapUint64Int8V(*v, fastpathCheckNilTrue, e) + + case map[uint64]int16: + fastpathTV.EncMapUint64Int16V(v, fastpathCheckNilTrue, e) + case *map[uint64]int16: + fastpathTV.EncMapUint64Int16V(*v, fastpathCheckNilTrue, e) + + case map[uint64]int32: + fastpathTV.EncMapUint64Int32V(v, fastpathCheckNilTrue, e) + case *map[uint64]int32: + fastpathTV.EncMapUint64Int32V(*v, fastpathCheckNilTrue, e) + + case map[uint64]int64: + fastpathTV.EncMapUint64Int64V(v, fastpathCheckNilTrue, e) + case *map[uint64]int64: + fastpathTV.EncMapUint64Int64V(*v, fastpathCheckNilTrue, e) + + case map[uint64]float32: + fastpathTV.EncMapUint64Float32V(v, fastpathCheckNilTrue, e) + case *map[uint64]float32: + fastpathTV.EncMapUint64Float32V(*v, fastpathCheckNilTrue, e) + + case map[uint64]float64: + fastpathTV.EncMapUint64Float64V(v, fastpathCheckNilTrue, e) + case *map[uint64]float64: + fastpathTV.EncMapUint64Float64V(*v, fastpathCheckNilTrue, e) + + case map[uint64]bool: + fastpathTV.EncMapUint64BoolV(v, fastpathCheckNilTrue, e) + case *map[uint64]bool: + fastpathTV.EncMapUint64BoolV(*v, fastpathCheckNilTrue, e) + + case []uintptr: + fastpathTV.EncSliceUintptrV(v, fastpathCheckNilTrue, e) + case *[]uintptr: + fastpathTV.EncSliceUintptrV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]interface{}: + fastpathTV.EncMapUintptrIntfV(v, fastpathCheckNilTrue, e) + case *map[uintptr]interface{}: + fastpathTV.EncMapUintptrIntfV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]string: + fastpathTV.EncMapUintptrStringV(v, fastpathCheckNilTrue, e) + case *map[uintptr]string: + fastpathTV.EncMapUintptrStringV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uint: + fastpathTV.EncMapUintptrUintV(v, fastpathCheckNilTrue, e) + case *map[uintptr]uint: + fastpathTV.EncMapUintptrUintV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uint8: + fastpathTV.EncMapUintptrUint8V(v, fastpathCheckNilTrue, e) + case *map[uintptr]uint8: + fastpathTV.EncMapUintptrUint8V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uint16: + fastpathTV.EncMapUintptrUint16V(v, fastpathCheckNilTrue, e) + case *map[uintptr]uint16: + fastpathTV.EncMapUintptrUint16V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uint32: + fastpathTV.EncMapUintptrUint32V(v, fastpathCheckNilTrue, e) + case *map[uintptr]uint32: + fastpathTV.EncMapUintptrUint32V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uint64: + fastpathTV.EncMapUintptrUint64V(v, fastpathCheckNilTrue, e) + case *map[uintptr]uint64: + fastpathTV.EncMapUintptrUint64V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uintptr: + fastpathTV.EncMapUintptrUintptrV(v, fastpathCheckNilTrue, e) + case *map[uintptr]uintptr: + fastpathTV.EncMapUintptrUintptrV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]int: + fastpathTV.EncMapUintptrIntV(v, fastpathCheckNilTrue, e) + case *map[uintptr]int: + fastpathTV.EncMapUintptrIntV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]int8: + fastpathTV.EncMapUintptrInt8V(v, fastpathCheckNilTrue, e) + case *map[uintptr]int8: + fastpathTV.EncMapUintptrInt8V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]int16: + fastpathTV.EncMapUintptrInt16V(v, fastpathCheckNilTrue, e) + case *map[uintptr]int16: + fastpathTV.EncMapUintptrInt16V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]int32: + fastpathTV.EncMapUintptrInt32V(v, fastpathCheckNilTrue, e) + case *map[uintptr]int32: + fastpathTV.EncMapUintptrInt32V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]int64: + fastpathTV.EncMapUintptrInt64V(v, fastpathCheckNilTrue, e) + case *map[uintptr]int64: + fastpathTV.EncMapUintptrInt64V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]float32: + fastpathTV.EncMapUintptrFloat32V(v, fastpathCheckNilTrue, e) + case *map[uintptr]float32: + fastpathTV.EncMapUintptrFloat32V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]float64: + fastpathTV.EncMapUintptrFloat64V(v, fastpathCheckNilTrue, e) + case *map[uintptr]float64: + fastpathTV.EncMapUintptrFloat64V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]bool: + fastpathTV.EncMapUintptrBoolV(v, fastpathCheckNilTrue, e) + case *map[uintptr]bool: + fastpathTV.EncMapUintptrBoolV(*v, fastpathCheckNilTrue, e) + + case []int: + fastpathTV.EncSliceIntV(v, fastpathCheckNilTrue, e) + case *[]int: + fastpathTV.EncSliceIntV(*v, fastpathCheckNilTrue, e) + + case map[int]interface{}: + fastpathTV.EncMapIntIntfV(v, fastpathCheckNilTrue, e) + case *map[int]interface{}: + fastpathTV.EncMapIntIntfV(*v, fastpathCheckNilTrue, e) + + case map[int]string: + fastpathTV.EncMapIntStringV(v, fastpathCheckNilTrue, e) + case *map[int]string: + fastpathTV.EncMapIntStringV(*v, fastpathCheckNilTrue, e) + + case map[int]uint: + fastpathTV.EncMapIntUintV(v, fastpathCheckNilTrue, e) + case *map[int]uint: + fastpathTV.EncMapIntUintV(*v, fastpathCheckNilTrue, e) + + case map[int]uint8: + fastpathTV.EncMapIntUint8V(v, fastpathCheckNilTrue, e) + case *map[int]uint8: + fastpathTV.EncMapIntUint8V(*v, fastpathCheckNilTrue, e) + + case map[int]uint16: + fastpathTV.EncMapIntUint16V(v, fastpathCheckNilTrue, e) + case *map[int]uint16: + fastpathTV.EncMapIntUint16V(*v, fastpathCheckNilTrue, e) + + case map[int]uint32: + fastpathTV.EncMapIntUint32V(v, fastpathCheckNilTrue, e) + case *map[int]uint32: + fastpathTV.EncMapIntUint32V(*v, fastpathCheckNilTrue, e) + + case map[int]uint64: + fastpathTV.EncMapIntUint64V(v, fastpathCheckNilTrue, e) + case *map[int]uint64: + fastpathTV.EncMapIntUint64V(*v, fastpathCheckNilTrue, e) + + case map[int]uintptr: + fastpathTV.EncMapIntUintptrV(v, fastpathCheckNilTrue, e) + case *map[int]uintptr: + fastpathTV.EncMapIntUintptrV(*v, fastpathCheckNilTrue, e) + + case map[int]int: + fastpathTV.EncMapIntIntV(v, fastpathCheckNilTrue, e) + case *map[int]int: + fastpathTV.EncMapIntIntV(*v, fastpathCheckNilTrue, e) + + case map[int]int8: + fastpathTV.EncMapIntInt8V(v, fastpathCheckNilTrue, e) + case *map[int]int8: + fastpathTV.EncMapIntInt8V(*v, fastpathCheckNilTrue, e) + + case map[int]int16: + fastpathTV.EncMapIntInt16V(v, fastpathCheckNilTrue, e) + case *map[int]int16: + fastpathTV.EncMapIntInt16V(*v, fastpathCheckNilTrue, e) + + case map[int]int32: + fastpathTV.EncMapIntInt32V(v, fastpathCheckNilTrue, e) + case *map[int]int32: + fastpathTV.EncMapIntInt32V(*v, fastpathCheckNilTrue, e) + + case map[int]int64: + fastpathTV.EncMapIntInt64V(v, fastpathCheckNilTrue, e) + case *map[int]int64: + fastpathTV.EncMapIntInt64V(*v, fastpathCheckNilTrue, e) + + case map[int]float32: + fastpathTV.EncMapIntFloat32V(v, fastpathCheckNilTrue, e) + case *map[int]float32: + fastpathTV.EncMapIntFloat32V(*v, fastpathCheckNilTrue, e) + + case map[int]float64: + fastpathTV.EncMapIntFloat64V(v, fastpathCheckNilTrue, e) + case *map[int]float64: + fastpathTV.EncMapIntFloat64V(*v, fastpathCheckNilTrue, e) + + case map[int]bool: + fastpathTV.EncMapIntBoolV(v, fastpathCheckNilTrue, e) + case *map[int]bool: + fastpathTV.EncMapIntBoolV(*v, fastpathCheckNilTrue, e) + + case []int8: + fastpathTV.EncSliceInt8V(v, fastpathCheckNilTrue, e) + case *[]int8: + fastpathTV.EncSliceInt8V(*v, fastpathCheckNilTrue, e) + + case map[int8]interface{}: + fastpathTV.EncMapInt8IntfV(v, fastpathCheckNilTrue, e) + case *map[int8]interface{}: + fastpathTV.EncMapInt8IntfV(*v, fastpathCheckNilTrue, e) + + case map[int8]string: + fastpathTV.EncMapInt8StringV(v, fastpathCheckNilTrue, e) + case *map[int8]string: + fastpathTV.EncMapInt8StringV(*v, fastpathCheckNilTrue, e) + + case map[int8]uint: + fastpathTV.EncMapInt8UintV(v, fastpathCheckNilTrue, e) + case *map[int8]uint: + fastpathTV.EncMapInt8UintV(*v, fastpathCheckNilTrue, e) + + case map[int8]uint8: + fastpathTV.EncMapInt8Uint8V(v, fastpathCheckNilTrue, e) + case *map[int8]uint8: + fastpathTV.EncMapInt8Uint8V(*v, fastpathCheckNilTrue, e) + + case map[int8]uint16: + fastpathTV.EncMapInt8Uint16V(v, fastpathCheckNilTrue, e) + case *map[int8]uint16: + fastpathTV.EncMapInt8Uint16V(*v, fastpathCheckNilTrue, e) + + case map[int8]uint32: + fastpathTV.EncMapInt8Uint32V(v, fastpathCheckNilTrue, e) + case *map[int8]uint32: + fastpathTV.EncMapInt8Uint32V(*v, fastpathCheckNilTrue, e) + + case map[int8]uint64: + fastpathTV.EncMapInt8Uint64V(v, fastpathCheckNilTrue, e) + case *map[int8]uint64: + fastpathTV.EncMapInt8Uint64V(*v, fastpathCheckNilTrue, e) + + case map[int8]uintptr: + fastpathTV.EncMapInt8UintptrV(v, fastpathCheckNilTrue, e) + case *map[int8]uintptr: + fastpathTV.EncMapInt8UintptrV(*v, fastpathCheckNilTrue, e) + + case map[int8]int: + fastpathTV.EncMapInt8IntV(v, fastpathCheckNilTrue, e) + case *map[int8]int: + fastpathTV.EncMapInt8IntV(*v, fastpathCheckNilTrue, e) + + case map[int8]int8: + fastpathTV.EncMapInt8Int8V(v, fastpathCheckNilTrue, e) + case *map[int8]int8: + fastpathTV.EncMapInt8Int8V(*v, fastpathCheckNilTrue, e) + + case map[int8]int16: + fastpathTV.EncMapInt8Int16V(v, fastpathCheckNilTrue, e) + case *map[int8]int16: + fastpathTV.EncMapInt8Int16V(*v, fastpathCheckNilTrue, e) + + case map[int8]int32: + fastpathTV.EncMapInt8Int32V(v, fastpathCheckNilTrue, e) + case *map[int8]int32: + fastpathTV.EncMapInt8Int32V(*v, fastpathCheckNilTrue, e) + + case map[int8]int64: + fastpathTV.EncMapInt8Int64V(v, fastpathCheckNilTrue, e) + case *map[int8]int64: + fastpathTV.EncMapInt8Int64V(*v, fastpathCheckNilTrue, e) + + case map[int8]float32: + fastpathTV.EncMapInt8Float32V(v, fastpathCheckNilTrue, e) + case *map[int8]float32: + fastpathTV.EncMapInt8Float32V(*v, fastpathCheckNilTrue, e) + + case map[int8]float64: + fastpathTV.EncMapInt8Float64V(v, fastpathCheckNilTrue, e) + case *map[int8]float64: + fastpathTV.EncMapInt8Float64V(*v, fastpathCheckNilTrue, e) + + case map[int8]bool: + fastpathTV.EncMapInt8BoolV(v, fastpathCheckNilTrue, e) + case *map[int8]bool: + fastpathTV.EncMapInt8BoolV(*v, fastpathCheckNilTrue, e) + + case []int16: + fastpathTV.EncSliceInt16V(v, fastpathCheckNilTrue, e) + case *[]int16: + fastpathTV.EncSliceInt16V(*v, fastpathCheckNilTrue, e) + + case map[int16]interface{}: + fastpathTV.EncMapInt16IntfV(v, fastpathCheckNilTrue, e) + case *map[int16]interface{}: + fastpathTV.EncMapInt16IntfV(*v, fastpathCheckNilTrue, e) + + case map[int16]string: + fastpathTV.EncMapInt16StringV(v, fastpathCheckNilTrue, e) + case *map[int16]string: + fastpathTV.EncMapInt16StringV(*v, fastpathCheckNilTrue, e) + + case map[int16]uint: + fastpathTV.EncMapInt16UintV(v, fastpathCheckNilTrue, e) + case *map[int16]uint: + fastpathTV.EncMapInt16UintV(*v, fastpathCheckNilTrue, e) + + case map[int16]uint8: + fastpathTV.EncMapInt16Uint8V(v, fastpathCheckNilTrue, e) + case *map[int16]uint8: + fastpathTV.EncMapInt16Uint8V(*v, fastpathCheckNilTrue, e) + + case map[int16]uint16: + fastpathTV.EncMapInt16Uint16V(v, fastpathCheckNilTrue, e) + case *map[int16]uint16: + fastpathTV.EncMapInt16Uint16V(*v, fastpathCheckNilTrue, e) + + case map[int16]uint32: + fastpathTV.EncMapInt16Uint32V(v, fastpathCheckNilTrue, e) + case *map[int16]uint32: + fastpathTV.EncMapInt16Uint32V(*v, fastpathCheckNilTrue, e) + + case map[int16]uint64: + fastpathTV.EncMapInt16Uint64V(v, fastpathCheckNilTrue, e) + case *map[int16]uint64: + fastpathTV.EncMapInt16Uint64V(*v, fastpathCheckNilTrue, e) + + case map[int16]uintptr: + fastpathTV.EncMapInt16UintptrV(v, fastpathCheckNilTrue, e) + case *map[int16]uintptr: + fastpathTV.EncMapInt16UintptrV(*v, fastpathCheckNilTrue, e) + + case map[int16]int: + fastpathTV.EncMapInt16IntV(v, fastpathCheckNilTrue, e) + case *map[int16]int: + fastpathTV.EncMapInt16IntV(*v, fastpathCheckNilTrue, e) + + case map[int16]int8: + fastpathTV.EncMapInt16Int8V(v, fastpathCheckNilTrue, e) + case *map[int16]int8: + fastpathTV.EncMapInt16Int8V(*v, fastpathCheckNilTrue, e) + + case map[int16]int16: + fastpathTV.EncMapInt16Int16V(v, fastpathCheckNilTrue, e) + case *map[int16]int16: + fastpathTV.EncMapInt16Int16V(*v, fastpathCheckNilTrue, e) + + case map[int16]int32: + fastpathTV.EncMapInt16Int32V(v, fastpathCheckNilTrue, e) + case *map[int16]int32: + fastpathTV.EncMapInt16Int32V(*v, fastpathCheckNilTrue, e) + + case map[int16]int64: + fastpathTV.EncMapInt16Int64V(v, fastpathCheckNilTrue, e) + case *map[int16]int64: + fastpathTV.EncMapInt16Int64V(*v, fastpathCheckNilTrue, e) + + case map[int16]float32: + fastpathTV.EncMapInt16Float32V(v, fastpathCheckNilTrue, e) + case *map[int16]float32: + fastpathTV.EncMapInt16Float32V(*v, fastpathCheckNilTrue, e) + + case map[int16]float64: + fastpathTV.EncMapInt16Float64V(v, fastpathCheckNilTrue, e) + case *map[int16]float64: + fastpathTV.EncMapInt16Float64V(*v, fastpathCheckNilTrue, e) + + case map[int16]bool: + fastpathTV.EncMapInt16BoolV(v, fastpathCheckNilTrue, e) + case *map[int16]bool: + fastpathTV.EncMapInt16BoolV(*v, fastpathCheckNilTrue, e) + + case []int32: + fastpathTV.EncSliceInt32V(v, fastpathCheckNilTrue, e) + case *[]int32: + fastpathTV.EncSliceInt32V(*v, fastpathCheckNilTrue, e) + + case map[int32]interface{}: + fastpathTV.EncMapInt32IntfV(v, fastpathCheckNilTrue, e) + case *map[int32]interface{}: + fastpathTV.EncMapInt32IntfV(*v, fastpathCheckNilTrue, e) + + case map[int32]string: + fastpathTV.EncMapInt32StringV(v, fastpathCheckNilTrue, e) + case *map[int32]string: + fastpathTV.EncMapInt32StringV(*v, fastpathCheckNilTrue, e) + + case map[int32]uint: + fastpathTV.EncMapInt32UintV(v, fastpathCheckNilTrue, e) + case *map[int32]uint: + fastpathTV.EncMapInt32UintV(*v, fastpathCheckNilTrue, e) + + case map[int32]uint8: + fastpathTV.EncMapInt32Uint8V(v, fastpathCheckNilTrue, e) + case *map[int32]uint8: + fastpathTV.EncMapInt32Uint8V(*v, fastpathCheckNilTrue, e) + + case map[int32]uint16: + fastpathTV.EncMapInt32Uint16V(v, fastpathCheckNilTrue, e) + case *map[int32]uint16: + fastpathTV.EncMapInt32Uint16V(*v, fastpathCheckNilTrue, e) + + case map[int32]uint32: + fastpathTV.EncMapInt32Uint32V(v, fastpathCheckNilTrue, e) + case *map[int32]uint32: + fastpathTV.EncMapInt32Uint32V(*v, fastpathCheckNilTrue, e) + + case map[int32]uint64: + fastpathTV.EncMapInt32Uint64V(v, fastpathCheckNilTrue, e) + case *map[int32]uint64: + fastpathTV.EncMapInt32Uint64V(*v, fastpathCheckNilTrue, e) + + case map[int32]uintptr: + fastpathTV.EncMapInt32UintptrV(v, fastpathCheckNilTrue, e) + case *map[int32]uintptr: + fastpathTV.EncMapInt32UintptrV(*v, fastpathCheckNilTrue, e) + + case map[int32]int: + fastpathTV.EncMapInt32IntV(v, fastpathCheckNilTrue, e) + case *map[int32]int: + fastpathTV.EncMapInt32IntV(*v, fastpathCheckNilTrue, e) + + case map[int32]int8: + fastpathTV.EncMapInt32Int8V(v, fastpathCheckNilTrue, e) + case *map[int32]int8: + fastpathTV.EncMapInt32Int8V(*v, fastpathCheckNilTrue, e) + + case map[int32]int16: + fastpathTV.EncMapInt32Int16V(v, fastpathCheckNilTrue, e) + case *map[int32]int16: + fastpathTV.EncMapInt32Int16V(*v, fastpathCheckNilTrue, e) + + case map[int32]int32: + fastpathTV.EncMapInt32Int32V(v, fastpathCheckNilTrue, e) + case *map[int32]int32: + fastpathTV.EncMapInt32Int32V(*v, fastpathCheckNilTrue, e) + + case map[int32]int64: + fastpathTV.EncMapInt32Int64V(v, fastpathCheckNilTrue, e) + case *map[int32]int64: + fastpathTV.EncMapInt32Int64V(*v, fastpathCheckNilTrue, e) + + case map[int32]float32: + fastpathTV.EncMapInt32Float32V(v, fastpathCheckNilTrue, e) + case *map[int32]float32: + fastpathTV.EncMapInt32Float32V(*v, fastpathCheckNilTrue, e) + + case map[int32]float64: + fastpathTV.EncMapInt32Float64V(v, fastpathCheckNilTrue, e) + case *map[int32]float64: + fastpathTV.EncMapInt32Float64V(*v, fastpathCheckNilTrue, e) + + case map[int32]bool: + fastpathTV.EncMapInt32BoolV(v, fastpathCheckNilTrue, e) + case *map[int32]bool: + fastpathTV.EncMapInt32BoolV(*v, fastpathCheckNilTrue, e) + + case []int64: + fastpathTV.EncSliceInt64V(v, fastpathCheckNilTrue, e) + case *[]int64: + fastpathTV.EncSliceInt64V(*v, fastpathCheckNilTrue, e) + + case map[int64]interface{}: + fastpathTV.EncMapInt64IntfV(v, fastpathCheckNilTrue, e) + case *map[int64]interface{}: + fastpathTV.EncMapInt64IntfV(*v, fastpathCheckNilTrue, e) + + case map[int64]string: + fastpathTV.EncMapInt64StringV(v, fastpathCheckNilTrue, e) + case *map[int64]string: + fastpathTV.EncMapInt64StringV(*v, fastpathCheckNilTrue, e) + + case map[int64]uint: + fastpathTV.EncMapInt64UintV(v, fastpathCheckNilTrue, e) + case *map[int64]uint: + fastpathTV.EncMapInt64UintV(*v, fastpathCheckNilTrue, e) + + case map[int64]uint8: + fastpathTV.EncMapInt64Uint8V(v, fastpathCheckNilTrue, e) + case *map[int64]uint8: + fastpathTV.EncMapInt64Uint8V(*v, fastpathCheckNilTrue, e) + + case map[int64]uint16: + fastpathTV.EncMapInt64Uint16V(v, fastpathCheckNilTrue, e) + case *map[int64]uint16: + fastpathTV.EncMapInt64Uint16V(*v, fastpathCheckNilTrue, e) + + case map[int64]uint32: + fastpathTV.EncMapInt64Uint32V(v, fastpathCheckNilTrue, e) + case *map[int64]uint32: + fastpathTV.EncMapInt64Uint32V(*v, fastpathCheckNilTrue, e) + + case map[int64]uint64: + fastpathTV.EncMapInt64Uint64V(v, fastpathCheckNilTrue, e) + case *map[int64]uint64: + fastpathTV.EncMapInt64Uint64V(*v, fastpathCheckNilTrue, e) + + case map[int64]uintptr: + fastpathTV.EncMapInt64UintptrV(v, fastpathCheckNilTrue, e) + case *map[int64]uintptr: + fastpathTV.EncMapInt64UintptrV(*v, fastpathCheckNilTrue, e) + + case map[int64]int: + fastpathTV.EncMapInt64IntV(v, fastpathCheckNilTrue, e) + case *map[int64]int: + fastpathTV.EncMapInt64IntV(*v, fastpathCheckNilTrue, e) + + case map[int64]int8: + fastpathTV.EncMapInt64Int8V(v, fastpathCheckNilTrue, e) + case *map[int64]int8: + fastpathTV.EncMapInt64Int8V(*v, fastpathCheckNilTrue, e) + + case map[int64]int16: + fastpathTV.EncMapInt64Int16V(v, fastpathCheckNilTrue, e) + case *map[int64]int16: + fastpathTV.EncMapInt64Int16V(*v, fastpathCheckNilTrue, e) + + case map[int64]int32: + fastpathTV.EncMapInt64Int32V(v, fastpathCheckNilTrue, e) + case *map[int64]int32: + fastpathTV.EncMapInt64Int32V(*v, fastpathCheckNilTrue, e) + + case map[int64]int64: + fastpathTV.EncMapInt64Int64V(v, fastpathCheckNilTrue, e) + case *map[int64]int64: + fastpathTV.EncMapInt64Int64V(*v, fastpathCheckNilTrue, e) + + case map[int64]float32: + fastpathTV.EncMapInt64Float32V(v, fastpathCheckNilTrue, e) + case *map[int64]float32: + fastpathTV.EncMapInt64Float32V(*v, fastpathCheckNilTrue, e) + + case map[int64]float64: + fastpathTV.EncMapInt64Float64V(v, fastpathCheckNilTrue, e) + case *map[int64]float64: + fastpathTV.EncMapInt64Float64V(*v, fastpathCheckNilTrue, e) + + case map[int64]bool: + fastpathTV.EncMapInt64BoolV(v, fastpathCheckNilTrue, e) + case *map[int64]bool: + fastpathTV.EncMapInt64BoolV(*v, fastpathCheckNilTrue, e) + + case []bool: + fastpathTV.EncSliceBoolV(v, fastpathCheckNilTrue, e) + case *[]bool: + fastpathTV.EncSliceBoolV(*v, fastpathCheckNilTrue, e) + + case map[bool]interface{}: + fastpathTV.EncMapBoolIntfV(v, fastpathCheckNilTrue, e) + case *map[bool]interface{}: + fastpathTV.EncMapBoolIntfV(*v, fastpathCheckNilTrue, e) + + case map[bool]string: + fastpathTV.EncMapBoolStringV(v, fastpathCheckNilTrue, e) + case *map[bool]string: + fastpathTV.EncMapBoolStringV(*v, fastpathCheckNilTrue, e) + + case map[bool]uint: + fastpathTV.EncMapBoolUintV(v, fastpathCheckNilTrue, e) + case *map[bool]uint: + fastpathTV.EncMapBoolUintV(*v, fastpathCheckNilTrue, e) + + case map[bool]uint8: + fastpathTV.EncMapBoolUint8V(v, fastpathCheckNilTrue, e) + case *map[bool]uint8: + fastpathTV.EncMapBoolUint8V(*v, fastpathCheckNilTrue, e) + + case map[bool]uint16: + fastpathTV.EncMapBoolUint16V(v, fastpathCheckNilTrue, e) + case *map[bool]uint16: + fastpathTV.EncMapBoolUint16V(*v, fastpathCheckNilTrue, e) + + case map[bool]uint32: + fastpathTV.EncMapBoolUint32V(v, fastpathCheckNilTrue, e) + case *map[bool]uint32: + fastpathTV.EncMapBoolUint32V(*v, fastpathCheckNilTrue, e) + + case map[bool]uint64: + fastpathTV.EncMapBoolUint64V(v, fastpathCheckNilTrue, e) + case *map[bool]uint64: + fastpathTV.EncMapBoolUint64V(*v, fastpathCheckNilTrue, e) + + case map[bool]uintptr: + fastpathTV.EncMapBoolUintptrV(v, fastpathCheckNilTrue, e) + case *map[bool]uintptr: + fastpathTV.EncMapBoolUintptrV(*v, fastpathCheckNilTrue, e) + + case map[bool]int: + fastpathTV.EncMapBoolIntV(v, fastpathCheckNilTrue, e) + case *map[bool]int: + fastpathTV.EncMapBoolIntV(*v, fastpathCheckNilTrue, e) + + case map[bool]int8: + fastpathTV.EncMapBoolInt8V(v, fastpathCheckNilTrue, e) + case *map[bool]int8: + fastpathTV.EncMapBoolInt8V(*v, fastpathCheckNilTrue, e) + + case map[bool]int16: + fastpathTV.EncMapBoolInt16V(v, fastpathCheckNilTrue, e) + case *map[bool]int16: + fastpathTV.EncMapBoolInt16V(*v, fastpathCheckNilTrue, e) + + case map[bool]int32: + fastpathTV.EncMapBoolInt32V(v, fastpathCheckNilTrue, e) + case *map[bool]int32: + fastpathTV.EncMapBoolInt32V(*v, fastpathCheckNilTrue, e) + + case map[bool]int64: + fastpathTV.EncMapBoolInt64V(v, fastpathCheckNilTrue, e) + case *map[bool]int64: + fastpathTV.EncMapBoolInt64V(*v, fastpathCheckNilTrue, e) + + case map[bool]float32: + fastpathTV.EncMapBoolFloat32V(v, fastpathCheckNilTrue, e) + case *map[bool]float32: + fastpathTV.EncMapBoolFloat32V(*v, fastpathCheckNilTrue, e) + + case map[bool]float64: + fastpathTV.EncMapBoolFloat64V(v, fastpathCheckNilTrue, e) + case *map[bool]float64: + fastpathTV.EncMapBoolFloat64V(*v, fastpathCheckNilTrue, e) + + case map[bool]bool: + fastpathTV.EncMapBoolBoolV(v, fastpathCheckNilTrue, e) + case *map[bool]bool: + fastpathTV.EncMapBoolBoolV(*v, fastpathCheckNilTrue, e) + + default: + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) + return false + } + return true +} + +func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { + switch v := iv.(type) { + + case []interface{}: + fastpathTV.EncSliceIntfV(v, fastpathCheckNilTrue, e) + case *[]interface{}: + fastpathTV.EncSliceIntfV(*v, fastpathCheckNilTrue, e) + + case []string: + fastpathTV.EncSliceStringV(v, fastpathCheckNilTrue, e) + case *[]string: + fastpathTV.EncSliceStringV(*v, fastpathCheckNilTrue, e) + + case []float32: + fastpathTV.EncSliceFloat32V(v, fastpathCheckNilTrue, e) + case *[]float32: + fastpathTV.EncSliceFloat32V(*v, fastpathCheckNilTrue, e) + + case []float64: + fastpathTV.EncSliceFloat64V(v, fastpathCheckNilTrue, e) + case *[]float64: + fastpathTV.EncSliceFloat64V(*v, fastpathCheckNilTrue, e) + + case []uint: + fastpathTV.EncSliceUintV(v, fastpathCheckNilTrue, e) + case *[]uint: + fastpathTV.EncSliceUintV(*v, fastpathCheckNilTrue, e) + + case []uint16: + fastpathTV.EncSliceUint16V(v, fastpathCheckNilTrue, e) + case *[]uint16: + fastpathTV.EncSliceUint16V(*v, fastpathCheckNilTrue, e) + + case []uint32: + fastpathTV.EncSliceUint32V(v, fastpathCheckNilTrue, e) + case *[]uint32: + fastpathTV.EncSliceUint32V(*v, fastpathCheckNilTrue, e) + + case []uint64: + fastpathTV.EncSliceUint64V(v, fastpathCheckNilTrue, e) + case *[]uint64: + fastpathTV.EncSliceUint64V(*v, fastpathCheckNilTrue, e) + + case []uintptr: + fastpathTV.EncSliceUintptrV(v, fastpathCheckNilTrue, e) + case *[]uintptr: + fastpathTV.EncSliceUintptrV(*v, fastpathCheckNilTrue, e) + + case []int: + fastpathTV.EncSliceIntV(v, fastpathCheckNilTrue, e) + case *[]int: + fastpathTV.EncSliceIntV(*v, fastpathCheckNilTrue, e) + + case []int8: + fastpathTV.EncSliceInt8V(v, fastpathCheckNilTrue, e) + case *[]int8: + fastpathTV.EncSliceInt8V(*v, fastpathCheckNilTrue, e) + + case []int16: + fastpathTV.EncSliceInt16V(v, fastpathCheckNilTrue, e) + case *[]int16: + fastpathTV.EncSliceInt16V(*v, fastpathCheckNilTrue, e) + + case []int32: + fastpathTV.EncSliceInt32V(v, fastpathCheckNilTrue, e) + case *[]int32: + fastpathTV.EncSliceInt32V(*v, fastpathCheckNilTrue, e) + + case []int64: + fastpathTV.EncSliceInt64V(v, fastpathCheckNilTrue, e) + case *[]int64: + fastpathTV.EncSliceInt64V(*v, fastpathCheckNilTrue, e) + + case []bool: + fastpathTV.EncSliceBoolV(v, fastpathCheckNilTrue, e) + case *[]bool: + fastpathTV.EncSliceBoolV(*v, fastpathCheckNilTrue, e) + + default: + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) + return false + } + return true +} + +func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool { + switch v := iv.(type) { + + case map[interface{}]interface{}: + fastpathTV.EncMapIntfIntfV(v, fastpathCheckNilTrue, e) + case *map[interface{}]interface{}: + fastpathTV.EncMapIntfIntfV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]string: + fastpathTV.EncMapIntfStringV(v, fastpathCheckNilTrue, e) + case *map[interface{}]string: + fastpathTV.EncMapIntfStringV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uint: + fastpathTV.EncMapIntfUintV(v, fastpathCheckNilTrue, e) + case *map[interface{}]uint: + fastpathTV.EncMapIntfUintV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uint8: + fastpathTV.EncMapIntfUint8V(v, fastpathCheckNilTrue, e) + case *map[interface{}]uint8: + fastpathTV.EncMapIntfUint8V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uint16: + fastpathTV.EncMapIntfUint16V(v, fastpathCheckNilTrue, e) + case *map[interface{}]uint16: + fastpathTV.EncMapIntfUint16V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uint32: + fastpathTV.EncMapIntfUint32V(v, fastpathCheckNilTrue, e) + case *map[interface{}]uint32: + fastpathTV.EncMapIntfUint32V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uint64: + fastpathTV.EncMapIntfUint64V(v, fastpathCheckNilTrue, e) + case *map[interface{}]uint64: + fastpathTV.EncMapIntfUint64V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]uintptr: + fastpathTV.EncMapIntfUintptrV(v, fastpathCheckNilTrue, e) + case *map[interface{}]uintptr: + fastpathTV.EncMapIntfUintptrV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]int: + fastpathTV.EncMapIntfIntV(v, fastpathCheckNilTrue, e) + case *map[interface{}]int: + fastpathTV.EncMapIntfIntV(*v, fastpathCheckNilTrue, e) + + case map[interface{}]int8: + fastpathTV.EncMapIntfInt8V(v, fastpathCheckNilTrue, e) + case *map[interface{}]int8: + fastpathTV.EncMapIntfInt8V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]int16: + fastpathTV.EncMapIntfInt16V(v, fastpathCheckNilTrue, e) + case *map[interface{}]int16: + fastpathTV.EncMapIntfInt16V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]int32: + fastpathTV.EncMapIntfInt32V(v, fastpathCheckNilTrue, e) + case *map[interface{}]int32: + fastpathTV.EncMapIntfInt32V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]int64: + fastpathTV.EncMapIntfInt64V(v, fastpathCheckNilTrue, e) + case *map[interface{}]int64: + fastpathTV.EncMapIntfInt64V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]float32: + fastpathTV.EncMapIntfFloat32V(v, fastpathCheckNilTrue, e) + case *map[interface{}]float32: + fastpathTV.EncMapIntfFloat32V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]float64: + fastpathTV.EncMapIntfFloat64V(v, fastpathCheckNilTrue, e) + case *map[interface{}]float64: + fastpathTV.EncMapIntfFloat64V(*v, fastpathCheckNilTrue, e) + + case map[interface{}]bool: + fastpathTV.EncMapIntfBoolV(v, fastpathCheckNilTrue, e) + case *map[interface{}]bool: + fastpathTV.EncMapIntfBoolV(*v, fastpathCheckNilTrue, e) + + case map[string]interface{}: + fastpathTV.EncMapStringIntfV(v, fastpathCheckNilTrue, e) + case *map[string]interface{}: + fastpathTV.EncMapStringIntfV(*v, fastpathCheckNilTrue, e) + + case map[string]string: + fastpathTV.EncMapStringStringV(v, fastpathCheckNilTrue, e) + case *map[string]string: + fastpathTV.EncMapStringStringV(*v, fastpathCheckNilTrue, e) + + case map[string]uint: + fastpathTV.EncMapStringUintV(v, fastpathCheckNilTrue, e) + case *map[string]uint: + fastpathTV.EncMapStringUintV(*v, fastpathCheckNilTrue, e) + + case map[string]uint8: + fastpathTV.EncMapStringUint8V(v, fastpathCheckNilTrue, e) + case *map[string]uint8: + fastpathTV.EncMapStringUint8V(*v, fastpathCheckNilTrue, e) + + case map[string]uint16: + fastpathTV.EncMapStringUint16V(v, fastpathCheckNilTrue, e) + case *map[string]uint16: + fastpathTV.EncMapStringUint16V(*v, fastpathCheckNilTrue, e) + + case map[string]uint32: + fastpathTV.EncMapStringUint32V(v, fastpathCheckNilTrue, e) + case *map[string]uint32: + fastpathTV.EncMapStringUint32V(*v, fastpathCheckNilTrue, e) + + case map[string]uint64: + fastpathTV.EncMapStringUint64V(v, fastpathCheckNilTrue, e) + case *map[string]uint64: + fastpathTV.EncMapStringUint64V(*v, fastpathCheckNilTrue, e) + + case map[string]uintptr: + fastpathTV.EncMapStringUintptrV(v, fastpathCheckNilTrue, e) + case *map[string]uintptr: + fastpathTV.EncMapStringUintptrV(*v, fastpathCheckNilTrue, e) + + case map[string]int: + fastpathTV.EncMapStringIntV(v, fastpathCheckNilTrue, e) + case *map[string]int: + fastpathTV.EncMapStringIntV(*v, fastpathCheckNilTrue, e) + + case map[string]int8: + fastpathTV.EncMapStringInt8V(v, fastpathCheckNilTrue, e) + case *map[string]int8: + fastpathTV.EncMapStringInt8V(*v, fastpathCheckNilTrue, e) + + case map[string]int16: + fastpathTV.EncMapStringInt16V(v, fastpathCheckNilTrue, e) + case *map[string]int16: + fastpathTV.EncMapStringInt16V(*v, fastpathCheckNilTrue, e) + + case map[string]int32: + fastpathTV.EncMapStringInt32V(v, fastpathCheckNilTrue, e) + case *map[string]int32: + fastpathTV.EncMapStringInt32V(*v, fastpathCheckNilTrue, e) + + case map[string]int64: + fastpathTV.EncMapStringInt64V(v, fastpathCheckNilTrue, e) + case *map[string]int64: + fastpathTV.EncMapStringInt64V(*v, fastpathCheckNilTrue, e) + + case map[string]float32: + fastpathTV.EncMapStringFloat32V(v, fastpathCheckNilTrue, e) + case *map[string]float32: + fastpathTV.EncMapStringFloat32V(*v, fastpathCheckNilTrue, e) + + case map[string]float64: + fastpathTV.EncMapStringFloat64V(v, fastpathCheckNilTrue, e) + case *map[string]float64: + fastpathTV.EncMapStringFloat64V(*v, fastpathCheckNilTrue, e) + + case map[string]bool: + fastpathTV.EncMapStringBoolV(v, fastpathCheckNilTrue, e) + case *map[string]bool: + fastpathTV.EncMapStringBoolV(*v, fastpathCheckNilTrue, e) + + case map[float32]interface{}: + fastpathTV.EncMapFloat32IntfV(v, fastpathCheckNilTrue, e) + case *map[float32]interface{}: + fastpathTV.EncMapFloat32IntfV(*v, fastpathCheckNilTrue, e) + + case map[float32]string: + fastpathTV.EncMapFloat32StringV(v, fastpathCheckNilTrue, e) + case *map[float32]string: + fastpathTV.EncMapFloat32StringV(*v, fastpathCheckNilTrue, e) + + case map[float32]uint: + fastpathTV.EncMapFloat32UintV(v, fastpathCheckNilTrue, e) + case *map[float32]uint: + fastpathTV.EncMapFloat32UintV(*v, fastpathCheckNilTrue, e) + + case map[float32]uint8: + fastpathTV.EncMapFloat32Uint8V(v, fastpathCheckNilTrue, e) + case *map[float32]uint8: + fastpathTV.EncMapFloat32Uint8V(*v, fastpathCheckNilTrue, e) + + case map[float32]uint16: + fastpathTV.EncMapFloat32Uint16V(v, fastpathCheckNilTrue, e) + case *map[float32]uint16: + fastpathTV.EncMapFloat32Uint16V(*v, fastpathCheckNilTrue, e) + + case map[float32]uint32: + fastpathTV.EncMapFloat32Uint32V(v, fastpathCheckNilTrue, e) + case *map[float32]uint32: + fastpathTV.EncMapFloat32Uint32V(*v, fastpathCheckNilTrue, e) + + case map[float32]uint64: + fastpathTV.EncMapFloat32Uint64V(v, fastpathCheckNilTrue, e) + case *map[float32]uint64: + fastpathTV.EncMapFloat32Uint64V(*v, fastpathCheckNilTrue, e) + + case map[float32]uintptr: + fastpathTV.EncMapFloat32UintptrV(v, fastpathCheckNilTrue, e) + case *map[float32]uintptr: + fastpathTV.EncMapFloat32UintptrV(*v, fastpathCheckNilTrue, e) + + case map[float32]int: + fastpathTV.EncMapFloat32IntV(v, fastpathCheckNilTrue, e) + case *map[float32]int: + fastpathTV.EncMapFloat32IntV(*v, fastpathCheckNilTrue, e) + + case map[float32]int8: + fastpathTV.EncMapFloat32Int8V(v, fastpathCheckNilTrue, e) + case *map[float32]int8: + fastpathTV.EncMapFloat32Int8V(*v, fastpathCheckNilTrue, e) + + case map[float32]int16: + fastpathTV.EncMapFloat32Int16V(v, fastpathCheckNilTrue, e) + case *map[float32]int16: + fastpathTV.EncMapFloat32Int16V(*v, fastpathCheckNilTrue, e) + + case map[float32]int32: + fastpathTV.EncMapFloat32Int32V(v, fastpathCheckNilTrue, e) + case *map[float32]int32: + fastpathTV.EncMapFloat32Int32V(*v, fastpathCheckNilTrue, e) + + case map[float32]int64: + fastpathTV.EncMapFloat32Int64V(v, fastpathCheckNilTrue, e) + case *map[float32]int64: + fastpathTV.EncMapFloat32Int64V(*v, fastpathCheckNilTrue, e) + + case map[float32]float32: + fastpathTV.EncMapFloat32Float32V(v, fastpathCheckNilTrue, e) + case *map[float32]float32: + fastpathTV.EncMapFloat32Float32V(*v, fastpathCheckNilTrue, e) + + case map[float32]float64: + fastpathTV.EncMapFloat32Float64V(v, fastpathCheckNilTrue, e) + case *map[float32]float64: + fastpathTV.EncMapFloat32Float64V(*v, fastpathCheckNilTrue, e) + + case map[float32]bool: + fastpathTV.EncMapFloat32BoolV(v, fastpathCheckNilTrue, e) + case *map[float32]bool: + fastpathTV.EncMapFloat32BoolV(*v, fastpathCheckNilTrue, e) + + case map[float64]interface{}: + fastpathTV.EncMapFloat64IntfV(v, fastpathCheckNilTrue, e) + case *map[float64]interface{}: + fastpathTV.EncMapFloat64IntfV(*v, fastpathCheckNilTrue, e) + + case map[float64]string: + fastpathTV.EncMapFloat64StringV(v, fastpathCheckNilTrue, e) + case *map[float64]string: + fastpathTV.EncMapFloat64StringV(*v, fastpathCheckNilTrue, e) + + case map[float64]uint: + fastpathTV.EncMapFloat64UintV(v, fastpathCheckNilTrue, e) + case *map[float64]uint: + fastpathTV.EncMapFloat64UintV(*v, fastpathCheckNilTrue, e) + + case map[float64]uint8: + fastpathTV.EncMapFloat64Uint8V(v, fastpathCheckNilTrue, e) + case *map[float64]uint8: + fastpathTV.EncMapFloat64Uint8V(*v, fastpathCheckNilTrue, e) + + case map[float64]uint16: + fastpathTV.EncMapFloat64Uint16V(v, fastpathCheckNilTrue, e) + case *map[float64]uint16: + fastpathTV.EncMapFloat64Uint16V(*v, fastpathCheckNilTrue, e) + + case map[float64]uint32: + fastpathTV.EncMapFloat64Uint32V(v, fastpathCheckNilTrue, e) + case *map[float64]uint32: + fastpathTV.EncMapFloat64Uint32V(*v, fastpathCheckNilTrue, e) + + case map[float64]uint64: + fastpathTV.EncMapFloat64Uint64V(v, fastpathCheckNilTrue, e) + case *map[float64]uint64: + fastpathTV.EncMapFloat64Uint64V(*v, fastpathCheckNilTrue, e) + + case map[float64]uintptr: + fastpathTV.EncMapFloat64UintptrV(v, fastpathCheckNilTrue, e) + case *map[float64]uintptr: + fastpathTV.EncMapFloat64UintptrV(*v, fastpathCheckNilTrue, e) + + case map[float64]int: + fastpathTV.EncMapFloat64IntV(v, fastpathCheckNilTrue, e) + case *map[float64]int: + fastpathTV.EncMapFloat64IntV(*v, fastpathCheckNilTrue, e) + + case map[float64]int8: + fastpathTV.EncMapFloat64Int8V(v, fastpathCheckNilTrue, e) + case *map[float64]int8: + fastpathTV.EncMapFloat64Int8V(*v, fastpathCheckNilTrue, e) + + case map[float64]int16: + fastpathTV.EncMapFloat64Int16V(v, fastpathCheckNilTrue, e) + case *map[float64]int16: + fastpathTV.EncMapFloat64Int16V(*v, fastpathCheckNilTrue, e) + + case map[float64]int32: + fastpathTV.EncMapFloat64Int32V(v, fastpathCheckNilTrue, e) + case *map[float64]int32: + fastpathTV.EncMapFloat64Int32V(*v, fastpathCheckNilTrue, e) + + case map[float64]int64: + fastpathTV.EncMapFloat64Int64V(v, fastpathCheckNilTrue, e) + case *map[float64]int64: + fastpathTV.EncMapFloat64Int64V(*v, fastpathCheckNilTrue, e) + + case map[float64]float32: + fastpathTV.EncMapFloat64Float32V(v, fastpathCheckNilTrue, e) + case *map[float64]float32: + fastpathTV.EncMapFloat64Float32V(*v, fastpathCheckNilTrue, e) + + case map[float64]float64: + fastpathTV.EncMapFloat64Float64V(v, fastpathCheckNilTrue, e) + case *map[float64]float64: + fastpathTV.EncMapFloat64Float64V(*v, fastpathCheckNilTrue, e) + + case map[float64]bool: + fastpathTV.EncMapFloat64BoolV(v, fastpathCheckNilTrue, e) + case *map[float64]bool: + fastpathTV.EncMapFloat64BoolV(*v, fastpathCheckNilTrue, e) + + case map[uint]interface{}: + fastpathTV.EncMapUintIntfV(v, fastpathCheckNilTrue, e) + case *map[uint]interface{}: + fastpathTV.EncMapUintIntfV(*v, fastpathCheckNilTrue, e) + + case map[uint]string: + fastpathTV.EncMapUintStringV(v, fastpathCheckNilTrue, e) + case *map[uint]string: + fastpathTV.EncMapUintStringV(*v, fastpathCheckNilTrue, e) + + case map[uint]uint: + fastpathTV.EncMapUintUintV(v, fastpathCheckNilTrue, e) + case *map[uint]uint: + fastpathTV.EncMapUintUintV(*v, fastpathCheckNilTrue, e) + + case map[uint]uint8: + fastpathTV.EncMapUintUint8V(v, fastpathCheckNilTrue, e) + case *map[uint]uint8: + fastpathTV.EncMapUintUint8V(*v, fastpathCheckNilTrue, e) + + case map[uint]uint16: + fastpathTV.EncMapUintUint16V(v, fastpathCheckNilTrue, e) + case *map[uint]uint16: + fastpathTV.EncMapUintUint16V(*v, fastpathCheckNilTrue, e) + + case map[uint]uint32: + fastpathTV.EncMapUintUint32V(v, fastpathCheckNilTrue, e) + case *map[uint]uint32: + fastpathTV.EncMapUintUint32V(*v, fastpathCheckNilTrue, e) + + case map[uint]uint64: + fastpathTV.EncMapUintUint64V(v, fastpathCheckNilTrue, e) + case *map[uint]uint64: + fastpathTV.EncMapUintUint64V(*v, fastpathCheckNilTrue, e) + + case map[uint]uintptr: + fastpathTV.EncMapUintUintptrV(v, fastpathCheckNilTrue, e) + case *map[uint]uintptr: + fastpathTV.EncMapUintUintptrV(*v, fastpathCheckNilTrue, e) + + case map[uint]int: + fastpathTV.EncMapUintIntV(v, fastpathCheckNilTrue, e) + case *map[uint]int: + fastpathTV.EncMapUintIntV(*v, fastpathCheckNilTrue, e) + + case map[uint]int8: + fastpathTV.EncMapUintInt8V(v, fastpathCheckNilTrue, e) + case *map[uint]int8: + fastpathTV.EncMapUintInt8V(*v, fastpathCheckNilTrue, e) + + case map[uint]int16: + fastpathTV.EncMapUintInt16V(v, fastpathCheckNilTrue, e) + case *map[uint]int16: + fastpathTV.EncMapUintInt16V(*v, fastpathCheckNilTrue, e) + + case map[uint]int32: + fastpathTV.EncMapUintInt32V(v, fastpathCheckNilTrue, e) + case *map[uint]int32: + fastpathTV.EncMapUintInt32V(*v, fastpathCheckNilTrue, e) + + case map[uint]int64: + fastpathTV.EncMapUintInt64V(v, fastpathCheckNilTrue, e) + case *map[uint]int64: + fastpathTV.EncMapUintInt64V(*v, fastpathCheckNilTrue, e) + + case map[uint]float32: + fastpathTV.EncMapUintFloat32V(v, fastpathCheckNilTrue, e) + case *map[uint]float32: + fastpathTV.EncMapUintFloat32V(*v, fastpathCheckNilTrue, e) + + case map[uint]float64: + fastpathTV.EncMapUintFloat64V(v, fastpathCheckNilTrue, e) + case *map[uint]float64: + fastpathTV.EncMapUintFloat64V(*v, fastpathCheckNilTrue, e) + + case map[uint]bool: + fastpathTV.EncMapUintBoolV(v, fastpathCheckNilTrue, e) + case *map[uint]bool: + fastpathTV.EncMapUintBoolV(*v, fastpathCheckNilTrue, e) + + case map[uint8]interface{}: + fastpathTV.EncMapUint8IntfV(v, fastpathCheckNilTrue, e) + case *map[uint8]interface{}: + fastpathTV.EncMapUint8IntfV(*v, fastpathCheckNilTrue, e) + + case map[uint8]string: + fastpathTV.EncMapUint8StringV(v, fastpathCheckNilTrue, e) + case *map[uint8]string: + fastpathTV.EncMapUint8StringV(*v, fastpathCheckNilTrue, e) + + case map[uint8]uint: + fastpathTV.EncMapUint8UintV(v, fastpathCheckNilTrue, e) + case *map[uint8]uint: + fastpathTV.EncMapUint8UintV(*v, fastpathCheckNilTrue, e) + + case map[uint8]uint8: + fastpathTV.EncMapUint8Uint8V(v, fastpathCheckNilTrue, e) + case *map[uint8]uint8: + fastpathTV.EncMapUint8Uint8V(*v, fastpathCheckNilTrue, e) + + case map[uint8]uint16: + fastpathTV.EncMapUint8Uint16V(v, fastpathCheckNilTrue, e) + case *map[uint8]uint16: + fastpathTV.EncMapUint8Uint16V(*v, fastpathCheckNilTrue, e) + + case map[uint8]uint32: + fastpathTV.EncMapUint8Uint32V(v, fastpathCheckNilTrue, e) + case *map[uint8]uint32: + fastpathTV.EncMapUint8Uint32V(*v, fastpathCheckNilTrue, e) + + case map[uint8]uint64: + fastpathTV.EncMapUint8Uint64V(v, fastpathCheckNilTrue, e) + case *map[uint8]uint64: + fastpathTV.EncMapUint8Uint64V(*v, fastpathCheckNilTrue, e) + + case map[uint8]uintptr: + fastpathTV.EncMapUint8UintptrV(v, fastpathCheckNilTrue, e) + case *map[uint8]uintptr: + fastpathTV.EncMapUint8UintptrV(*v, fastpathCheckNilTrue, e) + + case map[uint8]int: + fastpathTV.EncMapUint8IntV(v, fastpathCheckNilTrue, e) + case *map[uint8]int: + fastpathTV.EncMapUint8IntV(*v, fastpathCheckNilTrue, e) + + case map[uint8]int8: + fastpathTV.EncMapUint8Int8V(v, fastpathCheckNilTrue, e) + case *map[uint8]int8: + fastpathTV.EncMapUint8Int8V(*v, fastpathCheckNilTrue, e) + + case map[uint8]int16: + fastpathTV.EncMapUint8Int16V(v, fastpathCheckNilTrue, e) + case *map[uint8]int16: + fastpathTV.EncMapUint8Int16V(*v, fastpathCheckNilTrue, e) + + case map[uint8]int32: + fastpathTV.EncMapUint8Int32V(v, fastpathCheckNilTrue, e) + case *map[uint8]int32: + fastpathTV.EncMapUint8Int32V(*v, fastpathCheckNilTrue, e) + + case map[uint8]int64: + fastpathTV.EncMapUint8Int64V(v, fastpathCheckNilTrue, e) + case *map[uint8]int64: + fastpathTV.EncMapUint8Int64V(*v, fastpathCheckNilTrue, e) + + case map[uint8]float32: + fastpathTV.EncMapUint8Float32V(v, fastpathCheckNilTrue, e) + case *map[uint8]float32: + fastpathTV.EncMapUint8Float32V(*v, fastpathCheckNilTrue, e) + + case map[uint8]float64: + fastpathTV.EncMapUint8Float64V(v, fastpathCheckNilTrue, e) + case *map[uint8]float64: + fastpathTV.EncMapUint8Float64V(*v, fastpathCheckNilTrue, e) + + case map[uint8]bool: + fastpathTV.EncMapUint8BoolV(v, fastpathCheckNilTrue, e) + case *map[uint8]bool: + fastpathTV.EncMapUint8BoolV(*v, fastpathCheckNilTrue, e) + + case map[uint16]interface{}: + fastpathTV.EncMapUint16IntfV(v, fastpathCheckNilTrue, e) + case *map[uint16]interface{}: + fastpathTV.EncMapUint16IntfV(*v, fastpathCheckNilTrue, e) + + case map[uint16]string: + fastpathTV.EncMapUint16StringV(v, fastpathCheckNilTrue, e) + case *map[uint16]string: + fastpathTV.EncMapUint16StringV(*v, fastpathCheckNilTrue, e) + + case map[uint16]uint: + fastpathTV.EncMapUint16UintV(v, fastpathCheckNilTrue, e) + case *map[uint16]uint: + fastpathTV.EncMapUint16UintV(*v, fastpathCheckNilTrue, e) + + case map[uint16]uint8: + fastpathTV.EncMapUint16Uint8V(v, fastpathCheckNilTrue, e) + case *map[uint16]uint8: + fastpathTV.EncMapUint16Uint8V(*v, fastpathCheckNilTrue, e) + + case map[uint16]uint16: + fastpathTV.EncMapUint16Uint16V(v, fastpathCheckNilTrue, e) + case *map[uint16]uint16: + fastpathTV.EncMapUint16Uint16V(*v, fastpathCheckNilTrue, e) + + case map[uint16]uint32: + fastpathTV.EncMapUint16Uint32V(v, fastpathCheckNilTrue, e) + case *map[uint16]uint32: + fastpathTV.EncMapUint16Uint32V(*v, fastpathCheckNilTrue, e) + + case map[uint16]uint64: + fastpathTV.EncMapUint16Uint64V(v, fastpathCheckNilTrue, e) + case *map[uint16]uint64: + fastpathTV.EncMapUint16Uint64V(*v, fastpathCheckNilTrue, e) + + case map[uint16]uintptr: + fastpathTV.EncMapUint16UintptrV(v, fastpathCheckNilTrue, e) + case *map[uint16]uintptr: + fastpathTV.EncMapUint16UintptrV(*v, fastpathCheckNilTrue, e) + + case map[uint16]int: + fastpathTV.EncMapUint16IntV(v, fastpathCheckNilTrue, e) + case *map[uint16]int: + fastpathTV.EncMapUint16IntV(*v, fastpathCheckNilTrue, e) + + case map[uint16]int8: + fastpathTV.EncMapUint16Int8V(v, fastpathCheckNilTrue, e) + case *map[uint16]int8: + fastpathTV.EncMapUint16Int8V(*v, fastpathCheckNilTrue, e) + + case map[uint16]int16: + fastpathTV.EncMapUint16Int16V(v, fastpathCheckNilTrue, e) + case *map[uint16]int16: + fastpathTV.EncMapUint16Int16V(*v, fastpathCheckNilTrue, e) + + case map[uint16]int32: + fastpathTV.EncMapUint16Int32V(v, fastpathCheckNilTrue, e) + case *map[uint16]int32: + fastpathTV.EncMapUint16Int32V(*v, fastpathCheckNilTrue, e) + + case map[uint16]int64: + fastpathTV.EncMapUint16Int64V(v, fastpathCheckNilTrue, e) + case *map[uint16]int64: + fastpathTV.EncMapUint16Int64V(*v, fastpathCheckNilTrue, e) + + case map[uint16]float32: + fastpathTV.EncMapUint16Float32V(v, fastpathCheckNilTrue, e) + case *map[uint16]float32: + fastpathTV.EncMapUint16Float32V(*v, fastpathCheckNilTrue, e) + + case map[uint16]float64: + fastpathTV.EncMapUint16Float64V(v, fastpathCheckNilTrue, e) + case *map[uint16]float64: + fastpathTV.EncMapUint16Float64V(*v, fastpathCheckNilTrue, e) + + case map[uint16]bool: + fastpathTV.EncMapUint16BoolV(v, fastpathCheckNilTrue, e) + case *map[uint16]bool: + fastpathTV.EncMapUint16BoolV(*v, fastpathCheckNilTrue, e) + + case map[uint32]interface{}: + fastpathTV.EncMapUint32IntfV(v, fastpathCheckNilTrue, e) + case *map[uint32]interface{}: + fastpathTV.EncMapUint32IntfV(*v, fastpathCheckNilTrue, e) + + case map[uint32]string: + fastpathTV.EncMapUint32StringV(v, fastpathCheckNilTrue, e) + case *map[uint32]string: + fastpathTV.EncMapUint32StringV(*v, fastpathCheckNilTrue, e) + + case map[uint32]uint: + fastpathTV.EncMapUint32UintV(v, fastpathCheckNilTrue, e) + case *map[uint32]uint: + fastpathTV.EncMapUint32UintV(*v, fastpathCheckNilTrue, e) + + case map[uint32]uint8: + fastpathTV.EncMapUint32Uint8V(v, fastpathCheckNilTrue, e) + case *map[uint32]uint8: + fastpathTV.EncMapUint32Uint8V(*v, fastpathCheckNilTrue, e) + + case map[uint32]uint16: + fastpathTV.EncMapUint32Uint16V(v, fastpathCheckNilTrue, e) + case *map[uint32]uint16: + fastpathTV.EncMapUint32Uint16V(*v, fastpathCheckNilTrue, e) + + case map[uint32]uint32: + fastpathTV.EncMapUint32Uint32V(v, fastpathCheckNilTrue, e) + case *map[uint32]uint32: + fastpathTV.EncMapUint32Uint32V(*v, fastpathCheckNilTrue, e) + + case map[uint32]uint64: + fastpathTV.EncMapUint32Uint64V(v, fastpathCheckNilTrue, e) + case *map[uint32]uint64: + fastpathTV.EncMapUint32Uint64V(*v, fastpathCheckNilTrue, e) + + case map[uint32]uintptr: + fastpathTV.EncMapUint32UintptrV(v, fastpathCheckNilTrue, e) + case *map[uint32]uintptr: + fastpathTV.EncMapUint32UintptrV(*v, fastpathCheckNilTrue, e) + + case map[uint32]int: + fastpathTV.EncMapUint32IntV(v, fastpathCheckNilTrue, e) + case *map[uint32]int: + fastpathTV.EncMapUint32IntV(*v, fastpathCheckNilTrue, e) + + case map[uint32]int8: + fastpathTV.EncMapUint32Int8V(v, fastpathCheckNilTrue, e) + case *map[uint32]int8: + fastpathTV.EncMapUint32Int8V(*v, fastpathCheckNilTrue, e) + + case map[uint32]int16: + fastpathTV.EncMapUint32Int16V(v, fastpathCheckNilTrue, e) + case *map[uint32]int16: + fastpathTV.EncMapUint32Int16V(*v, fastpathCheckNilTrue, e) + + case map[uint32]int32: + fastpathTV.EncMapUint32Int32V(v, fastpathCheckNilTrue, e) + case *map[uint32]int32: + fastpathTV.EncMapUint32Int32V(*v, fastpathCheckNilTrue, e) + + case map[uint32]int64: + fastpathTV.EncMapUint32Int64V(v, fastpathCheckNilTrue, e) + case *map[uint32]int64: + fastpathTV.EncMapUint32Int64V(*v, fastpathCheckNilTrue, e) + + case map[uint32]float32: + fastpathTV.EncMapUint32Float32V(v, fastpathCheckNilTrue, e) + case *map[uint32]float32: + fastpathTV.EncMapUint32Float32V(*v, fastpathCheckNilTrue, e) + + case map[uint32]float64: + fastpathTV.EncMapUint32Float64V(v, fastpathCheckNilTrue, e) + case *map[uint32]float64: + fastpathTV.EncMapUint32Float64V(*v, fastpathCheckNilTrue, e) + + case map[uint32]bool: + fastpathTV.EncMapUint32BoolV(v, fastpathCheckNilTrue, e) + case *map[uint32]bool: + fastpathTV.EncMapUint32BoolV(*v, fastpathCheckNilTrue, e) + + case map[uint64]interface{}: + fastpathTV.EncMapUint64IntfV(v, fastpathCheckNilTrue, e) + case *map[uint64]interface{}: + fastpathTV.EncMapUint64IntfV(*v, fastpathCheckNilTrue, e) + + case map[uint64]string: + fastpathTV.EncMapUint64StringV(v, fastpathCheckNilTrue, e) + case *map[uint64]string: + fastpathTV.EncMapUint64StringV(*v, fastpathCheckNilTrue, e) + + case map[uint64]uint: + fastpathTV.EncMapUint64UintV(v, fastpathCheckNilTrue, e) + case *map[uint64]uint: + fastpathTV.EncMapUint64UintV(*v, fastpathCheckNilTrue, e) + + case map[uint64]uint8: + fastpathTV.EncMapUint64Uint8V(v, fastpathCheckNilTrue, e) + case *map[uint64]uint8: + fastpathTV.EncMapUint64Uint8V(*v, fastpathCheckNilTrue, e) + + case map[uint64]uint16: + fastpathTV.EncMapUint64Uint16V(v, fastpathCheckNilTrue, e) + case *map[uint64]uint16: + fastpathTV.EncMapUint64Uint16V(*v, fastpathCheckNilTrue, e) + + case map[uint64]uint32: + fastpathTV.EncMapUint64Uint32V(v, fastpathCheckNilTrue, e) + case *map[uint64]uint32: + fastpathTV.EncMapUint64Uint32V(*v, fastpathCheckNilTrue, e) + + case map[uint64]uint64: + fastpathTV.EncMapUint64Uint64V(v, fastpathCheckNilTrue, e) + case *map[uint64]uint64: + fastpathTV.EncMapUint64Uint64V(*v, fastpathCheckNilTrue, e) + + case map[uint64]uintptr: + fastpathTV.EncMapUint64UintptrV(v, fastpathCheckNilTrue, e) + case *map[uint64]uintptr: + fastpathTV.EncMapUint64UintptrV(*v, fastpathCheckNilTrue, e) + + case map[uint64]int: + fastpathTV.EncMapUint64IntV(v, fastpathCheckNilTrue, e) + case *map[uint64]int: + fastpathTV.EncMapUint64IntV(*v, fastpathCheckNilTrue, e) + + case map[uint64]int8: + fastpathTV.EncMapUint64Int8V(v, fastpathCheckNilTrue, e) + case *map[uint64]int8: + fastpathTV.EncMapUint64Int8V(*v, fastpathCheckNilTrue, e) + + case map[uint64]int16: + fastpathTV.EncMapUint64Int16V(v, fastpathCheckNilTrue, e) + case *map[uint64]int16: + fastpathTV.EncMapUint64Int16V(*v, fastpathCheckNilTrue, e) + + case map[uint64]int32: + fastpathTV.EncMapUint64Int32V(v, fastpathCheckNilTrue, e) + case *map[uint64]int32: + fastpathTV.EncMapUint64Int32V(*v, fastpathCheckNilTrue, e) + + case map[uint64]int64: + fastpathTV.EncMapUint64Int64V(v, fastpathCheckNilTrue, e) + case *map[uint64]int64: + fastpathTV.EncMapUint64Int64V(*v, fastpathCheckNilTrue, e) + + case map[uint64]float32: + fastpathTV.EncMapUint64Float32V(v, fastpathCheckNilTrue, e) + case *map[uint64]float32: + fastpathTV.EncMapUint64Float32V(*v, fastpathCheckNilTrue, e) + + case map[uint64]float64: + fastpathTV.EncMapUint64Float64V(v, fastpathCheckNilTrue, e) + case *map[uint64]float64: + fastpathTV.EncMapUint64Float64V(*v, fastpathCheckNilTrue, e) + + case map[uint64]bool: + fastpathTV.EncMapUint64BoolV(v, fastpathCheckNilTrue, e) + case *map[uint64]bool: + fastpathTV.EncMapUint64BoolV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]interface{}: + fastpathTV.EncMapUintptrIntfV(v, fastpathCheckNilTrue, e) + case *map[uintptr]interface{}: + fastpathTV.EncMapUintptrIntfV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]string: + fastpathTV.EncMapUintptrStringV(v, fastpathCheckNilTrue, e) + case *map[uintptr]string: + fastpathTV.EncMapUintptrStringV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uint: + fastpathTV.EncMapUintptrUintV(v, fastpathCheckNilTrue, e) + case *map[uintptr]uint: + fastpathTV.EncMapUintptrUintV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uint8: + fastpathTV.EncMapUintptrUint8V(v, fastpathCheckNilTrue, e) + case *map[uintptr]uint8: + fastpathTV.EncMapUintptrUint8V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uint16: + fastpathTV.EncMapUintptrUint16V(v, fastpathCheckNilTrue, e) + case *map[uintptr]uint16: + fastpathTV.EncMapUintptrUint16V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uint32: + fastpathTV.EncMapUintptrUint32V(v, fastpathCheckNilTrue, e) + case *map[uintptr]uint32: + fastpathTV.EncMapUintptrUint32V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uint64: + fastpathTV.EncMapUintptrUint64V(v, fastpathCheckNilTrue, e) + case *map[uintptr]uint64: + fastpathTV.EncMapUintptrUint64V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]uintptr: + fastpathTV.EncMapUintptrUintptrV(v, fastpathCheckNilTrue, e) + case *map[uintptr]uintptr: + fastpathTV.EncMapUintptrUintptrV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]int: + fastpathTV.EncMapUintptrIntV(v, fastpathCheckNilTrue, e) + case *map[uintptr]int: + fastpathTV.EncMapUintptrIntV(*v, fastpathCheckNilTrue, e) + + case map[uintptr]int8: + fastpathTV.EncMapUintptrInt8V(v, fastpathCheckNilTrue, e) + case *map[uintptr]int8: + fastpathTV.EncMapUintptrInt8V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]int16: + fastpathTV.EncMapUintptrInt16V(v, fastpathCheckNilTrue, e) + case *map[uintptr]int16: + fastpathTV.EncMapUintptrInt16V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]int32: + fastpathTV.EncMapUintptrInt32V(v, fastpathCheckNilTrue, e) + case *map[uintptr]int32: + fastpathTV.EncMapUintptrInt32V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]int64: + fastpathTV.EncMapUintptrInt64V(v, fastpathCheckNilTrue, e) + case *map[uintptr]int64: + fastpathTV.EncMapUintptrInt64V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]float32: + fastpathTV.EncMapUintptrFloat32V(v, fastpathCheckNilTrue, e) + case *map[uintptr]float32: + fastpathTV.EncMapUintptrFloat32V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]float64: + fastpathTV.EncMapUintptrFloat64V(v, fastpathCheckNilTrue, e) + case *map[uintptr]float64: + fastpathTV.EncMapUintptrFloat64V(*v, fastpathCheckNilTrue, e) + + case map[uintptr]bool: + fastpathTV.EncMapUintptrBoolV(v, fastpathCheckNilTrue, e) + case *map[uintptr]bool: + fastpathTV.EncMapUintptrBoolV(*v, fastpathCheckNilTrue, e) + + case map[int]interface{}: + fastpathTV.EncMapIntIntfV(v, fastpathCheckNilTrue, e) + case *map[int]interface{}: + fastpathTV.EncMapIntIntfV(*v, fastpathCheckNilTrue, e) + + case map[int]string: + fastpathTV.EncMapIntStringV(v, fastpathCheckNilTrue, e) + case *map[int]string: + fastpathTV.EncMapIntStringV(*v, fastpathCheckNilTrue, e) + + case map[int]uint: + fastpathTV.EncMapIntUintV(v, fastpathCheckNilTrue, e) + case *map[int]uint: + fastpathTV.EncMapIntUintV(*v, fastpathCheckNilTrue, e) + + case map[int]uint8: + fastpathTV.EncMapIntUint8V(v, fastpathCheckNilTrue, e) + case *map[int]uint8: + fastpathTV.EncMapIntUint8V(*v, fastpathCheckNilTrue, e) + + case map[int]uint16: + fastpathTV.EncMapIntUint16V(v, fastpathCheckNilTrue, e) + case *map[int]uint16: + fastpathTV.EncMapIntUint16V(*v, fastpathCheckNilTrue, e) + + case map[int]uint32: + fastpathTV.EncMapIntUint32V(v, fastpathCheckNilTrue, e) + case *map[int]uint32: + fastpathTV.EncMapIntUint32V(*v, fastpathCheckNilTrue, e) + + case map[int]uint64: + fastpathTV.EncMapIntUint64V(v, fastpathCheckNilTrue, e) + case *map[int]uint64: + fastpathTV.EncMapIntUint64V(*v, fastpathCheckNilTrue, e) + + case map[int]uintptr: + fastpathTV.EncMapIntUintptrV(v, fastpathCheckNilTrue, e) + case *map[int]uintptr: + fastpathTV.EncMapIntUintptrV(*v, fastpathCheckNilTrue, e) + + case map[int]int: + fastpathTV.EncMapIntIntV(v, fastpathCheckNilTrue, e) + case *map[int]int: + fastpathTV.EncMapIntIntV(*v, fastpathCheckNilTrue, e) + + case map[int]int8: + fastpathTV.EncMapIntInt8V(v, fastpathCheckNilTrue, e) + case *map[int]int8: + fastpathTV.EncMapIntInt8V(*v, fastpathCheckNilTrue, e) + + case map[int]int16: + fastpathTV.EncMapIntInt16V(v, fastpathCheckNilTrue, e) + case *map[int]int16: + fastpathTV.EncMapIntInt16V(*v, fastpathCheckNilTrue, e) + + case map[int]int32: + fastpathTV.EncMapIntInt32V(v, fastpathCheckNilTrue, e) + case *map[int]int32: + fastpathTV.EncMapIntInt32V(*v, fastpathCheckNilTrue, e) + + case map[int]int64: + fastpathTV.EncMapIntInt64V(v, fastpathCheckNilTrue, e) + case *map[int]int64: + fastpathTV.EncMapIntInt64V(*v, fastpathCheckNilTrue, e) + + case map[int]float32: + fastpathTV.EncMapIntFloat32V(v, fastpathCheckNilTrue, e) + case *map[int]float32: + fastpathTV.EncMapIntFloat32V(*v, fastpathCheckNilTrue, e) + + case map[int]float64: + fastpathTV.EncMapIntFloat64V(v, fastpathCheckNilTrue, e) + case *map[int]float64: + fastpathTV.EncMapIntFloat64V(*v, fastpathCheckNilTrue, e) + + case map[int]bool: + fastpathTV.EncMapIntBoolV(v, fastpathCheckNilTrue, e) + case *map[int]bool: + fastpathTV.EncMapIntBoolV(*v, fastpathCheckNilTrue, e) + + case map[int8]interface{}: + fastpathTV.EncMapInt8IntfV(v, fastpathCheckNilTrue, e) + case *map[int8]interface{}: + fastpathTV.EncMapInt8IntfV(*v, fastpathCheckNilTrue, e) + + case map[int8]string: + fastpathTV.EncMapInt8StringV(v, fastpathCheckNilTrue, e) + case *map[int8]string: + fastpathTV.EncMapInt8StringV(*v, fastpathCheckNilTrue, e) + + case map[int8]uint: + fastpathTV.EncMapInt8UintV(v, fastpathCheckNilTrue, e) + case *map[int8]uint: + fastpathTV.EncMapInt8UintV(*v, fastpathCheckNilTrue, e) + + case map[int8]uint8: + fastpathTV.EncMapInt8Uint8V(v, fastpathCheckNilTrue, e) + case *map[int8]uint8: + fastpathTV.EncMapInt8Uint8V(*v, fastpathCheckNilTrue, e) + + case map[int8]uint16: + fastpathTV.EncMapInt8Uint16V(v, fastpathCheckNilTrue, e) + case *map[int8]uint16: + fastpathTV.EncMapInt8Uint16V(*v, fastpathCheckNilTrue, e) + + case map[int8]uint32: + fastpathTV.EncMapInt8Uint32V(v, fastpathCheckNilTrue, e) + case *map[int8]uint32: + fastpathTV.EncMapInt8Uint32V(*v, fastpathCheckNilTrue, e) + + case map[int8]uint64: + fastpathTV.EncMapInt8Uint64V(v, fastpathCheckNilTrue, e) + case *map[int8]uint64: + fastpathTV.EncMapInt8Uint64V(*v, fastpathCheckNilTrue, e) + + case map[int8]uintptr: + fastpathTV.EncMapInt8UintptrV(v, fastpathCheckNilTrue, e) + case *map[int8]uintptr: + fastpathTV.EncMapInt8UintptrV(*v, fastpathCheckNilTrue, e) + + case map[int8]int: + fastpathTV.EncMapInt8IntV(v, fastpathCheckNilTrue, e) + case *map[int8]int: + fastpathTV.EncMapInt8IntV(*v, fastpathCheckNilTrue, e) + + case map[int8]int8: + fastpathTV.EncMapInt8Int8V(v, fastpathCheckNilTrue, e) + case *map[int8]int8: + fastpathTV.EncMapInt8Int8V(*v, fastpathCheckNilTrue, e) + + case map[int8]int16: + fastpathTV.EncMapInt8Int16V(v, fastpathCheckNilTrue, e) + case *map[int8]int16: + fastpathTV.EncMapInt8Int16V(*v, fastpathCheckNilTrue, e) + + case map[int8]int32: + fastpathTV.EncMapInt8Int32V(v, fastpathCheckNilTrue, e) + case *map[int8]int32: + fastpathTV.EncMapInt8Int32V(*v, fastpathCheckNilTrue, e) + + case map[int8]int64: + fastpathTV.EncMapInt8Int64V(v, fastpathCheckNilTrue, e) + case *map[int8]int64: + fastpathTV.EncMapInt8Int64V(*v, fastpathCheckNilTrue, e) + + case map[int8]float32: + fastpathTV.EncMapInt8Float32V(v, fastpathCheckNilTrue, e) + case *map[int8]float32: + fastpathTV.EncMapInt8Float32V(*v, fastpathCheckNilTrue, e) + + case map[int8]float64: + fastpathTV.EncMapInt8Float64V(v, fastpathCheckNilTrue, e) + case *map[int8]float64: + fastpathTV.EncMapInt8Float64V(*v, fastpathCheckNilTrue, e) + + case map[int8]bool: + fastpathTV.EncMapInt8BoolV(v, fastpathCheckNilTrue, e) + case *map[int8]bool: + fastpathTV.EncMapInt8BoolV(*v, fastpathCheckNilTrue, e) + + case map[int16]interface{}: + fastpathTV.EncMapInt16IntfV(v, fastpathCheckNilTrue, e) + case *map[int16]interface{}: + fastpathTV.EncMapInt16IntfV(*v, fastpathCheckNilTrue, e) + + case map[int16]string: + fastpathTV.EncMapInt16StringV(v, fastpathCheckNilTrue, e) + case *map[int16]string: + fastpathTV.EncMapInt16StringV(*v, fastpathCheckNilTrue, e) + + case map[int16]uint: + fastpathTV.EncMapInt16UintV(v, fastpathCheckNilTrue, e) + case *map[int16]uint: + fastpathTV.EncMapInt16UintV(*v, fastpathCheckNilTrue, e) + + case map[int16]uint8: + fastpathTV.EncMapInt16Uint8V(v, fastpathCheckNilTrue, e) + case *map[int16]uint8: + fastpathTV.EncMapInt16Uint8V(*v, fastpathCheckNilTrue, e) + + case map[int16]uint16: + fastpathTV.EncMapInt16Uint16V(v, fastpathCheckNilTrue, e) + case *map[int16]uint16: + fastpathTV.EncMapInt16Uint16V(*v, fastpathCheckNilTrue, e) + + case map[int16]uint32: + fastpathTV.EncMapInt16Uint32V(v, fastpathCheckNilTrue, e) + case *map[int16]uint32: + fastpathTV.EncMapInt16Uint32V(*v, fastpathCheckNilTrue, e) + + case map[int16]uint64: + fastpathTV.EncMapInt16Uint64V(v, fastpathCheckNilTrue, e) + case *map[int16]uint64: + fastpathTV.EncMapInt16Uint64V(*v, fastpathCheckNilTrue, e) + + case map[int16]uintptr: + fastpathTV.EncMapInt16UintptrV(v, fastpathCheckNilTrue, e) + case *map[int16]uintptr: + fastpathTV.EncMapInt16UintptrV(*v, fastpathCheckNilTrue, e) + + case map[int16]int: + fastpathTV.EncMapInt16IntV(v, fastpathCheckNilTrue, e) + case *map[int16]int: + fastpathTV.EncMapInt16IntV(*v, fastpathCheckNilTrue, e) + + case map[int16]int8: + fastpathTV.EncMapInt16Int8V(v, fastpathCheckNilTrue, e) + case *map[int16]int8: + fastpathTV.EncMapInt16Int8V(*v, fastpathCheckNilTrue, e) + + case map[int16]int16: + fastpathTV.EncMapInt16Int16V(v, fastpathCheckNilTrue, e) + case *map[int16]int16: + fastpathTV.EncMapInt16Int16V(*v, fastpathCheckNilTrue, e) + + case map[int16]int32: + fastpathTV.EncMapInt16Int32V(v, fastpathCheckNilTrue, e) + case *map[int16]int32: + fastpathTV.EncMapInt16Int32V(*v, fastpathCheckNilTrue, e) + + case map[int16]int64: + fastpathTV.EncMapInt16Int64V(v, fastpathCheckNilTrue, e) + case *map[int16]int64: + fastpathTV.EncMapInt16Int64V(*v, fastpathCheckNilTrue, e) + + case map[int16]float32: + fastpathTV.EncMapInt16Float32V(v, fastpathCheckNilTrue, e) + case *map[int16]float32: + fastpathTV.EncMapInt16Float32V(*v, fastpathCheckNilTrue, e) + + case map[int16]float64: + fastpathTV.EncMapInt16Float64V(v, fastpathCheckNilTrue, e) + case *map[int16]float64: + fastpathTV.EncMapInt16Float64V(*v, fastpathCheckNilTrue, e) + + case map[int16]bool: + fastpathTV.EncMapInt16BoolV(v, fastpathCheckNilTrue, e) + case *map[int16]bool: + fastpathTV.EncMapInt16BoolV(*v, fastpathCheckNilTrue, e) + + case map[int32]interface{}: + fastpathTV.EncMapInt32IntfV(v, fastpathCheckNilTrue, e) + case *map[int32]interface{}: + fastpathTV.EncMapInt32IntfV(*v, fastpathCheckNilTrue, e) + + case map[int32]string: + fastpathTV.EncMapInt32StringV(v, fastpathCheckNilTrue, e) + case *map[int32]string: + fastpathTV.EncMapInt32StringV(*v, fastpathCheckNilTrue, e) + + case map[int32]uint: + fastpathTV.EncMapInt32UintV(v, fastpathCheckNilTrue, e) + case *map[int32]uint: + fastpathTV.EncMapInt32UintV(*v, fastpathCheckNilTrue, e) + + case map[int32]uint8: + fastpathTV.EncMapInt32Uint8V(v, fastpathCheckNilTrue, e) + case *map[int32]uint8: + fastpathTV.EncMapInt32Uint8V(*v, fastpathCheckNilTrue, e) + + case map[int32]uint16: + fastpathTV.EncMapInt32Uint16V(v, fastpathCheckNilTrue, e) + case *map[int32]uint16: + fastpathTV.EncMapInt32Uint16V(*v, fastpathCheckNilTrue, e) + + case map[int32]uint32: + fastpathTV.EncMapInt32Uint32V(v, fastpathCheckNilTrue, e) + case *map[int32]uint32: + fastpathTV.EncMapInt32Uint32V(*v, fastpathCheckNilTrue, e) + + case map[int32]uint64: + fastpathTV.EncMapInt32Uint64V(v, fastpathCheckNilTrue, e) + case *map[int32]uint64: + fastpathTV.EncMapInt32Uint64V(*v, fastpathCheckNilTrue, e) + + case map[int32]uintptr: + fastpathTV.EncMapInt32UintptrV(v, fastpathCheckNilTrue, e) + case *map[int32]uintptr: + fastpathTV.EncMapInt32UintptrV(*v, fastpathCheckNilTrue, e) + + case map[int32]int: + fastpathTV.EncMapInt32IntV(v, fastpathCheckNilTrue, e) + case *map[int32]int: + fastpathTV.EncMapInt32IntV(*v, fastpathCheckNilTrue, e) + + case map[int32]int8: + fastpathTV.EncMapInt32Int8V(v, fastpathCheckNilTrue, e) + case *map[int32]int8: + fastpathTV.EncMapInt32Int8V(*v, fastpathCheckNilTrue, e) + + case map[int32]int16: + fastpathTV.EncMapInt32Int16V(v, fastpathCheckNilTrue, e) + case *map[int32]int16: + fastpathTV.EncMapInt32Int16V(*v, fastpathCheckNilTrue, e) + + case map[int32]int32: + fastpathTV.EncMapInt32Int32V(v, fastpathCheckNilTrue, e) + case *map[int32]int32: + fastpathTV.EncMapInt32Int32V(*v, fastpathCheckNilTrue, e) + + case map[int32]int64: + fastpathTV.EncMapInt32Int64V(v, fastpathCheckNilTrue, e) + case *map[int32]int64: + fastpathTV.EncMapInt32Int64V(*v, fastpathCheckNilTrue, e) + + case map[int32]float32: + fastpathTV.EncMapInt32Float32V(v, fastpathCheckNilTrue, e) + case *map[int32]float32: + fastpathTV.EncMapInt32Float32V(*v, fastpathCheckNilTrue, e) + + case map[int32]float64: + fastpathTV.EncMapInt32Float64V(v, fastpathCheckNilTrue, e) + case *map[int32]float64: + fastpathTV.EncMapInt32Float64V(*v, fastpathCheckNilTrue, e) + + case map[int32]bool: + fastpathTV.EncMapInt32BoolV(v, fastpathCheckNilTrue, e) + case *map[int32]bool: + fastpathTV.EncMapInt32BoolV(*v, fastpathCheckNilTrue, e) + + case map[int64]interface{}: + fastpathTV.EncMapInt64IntfV(v, fastpathCheckNilTrue, e) + case *map[int64]interface{}: + fastpathTV.EncMapInt64IntfV(*v, fastpathCheckNilTrue, e) + + case map[int64]string: + fastpathTV.EncMapInt64StringV(v, fastpathCheckNilTrue, e) + case *map[int64]string: + fastpathTV.EncMapInt64StringV(*v, fastpathCheckNilTrue, e) + + case map[int64]uint: + fastpathTV.EncMapInt64UintV(v, fastpathCheckNilTrue, e) + case *map[int64]uint: + fastpathTV.EncMapInt64UintV(*v, fastpathCheckNilTrue, e) + + case map[int64]uint8: + fastpathTV.EncMapInt64Uint8V(v, fastpathCheckNilTrue, e) + case *map[int64]uint8: + fastpathTV.EncMapInt64Uint8V(*v, fastpathCheckNilTrue, e) + + case map[int64]uint16: + fastpathTV.EncMapInt64Uint16V(v, fastpathCheckNilTrue, e) + case *map[int64]uint16: + fastpathTV.EncMapInt64Uint16V(*v, fastpathCheckNilTrue, e) + + case map[int64]uint32: + fastpathTV.EncMapInt64Uint32V(v, fastpathCheckNilTrue, e) + case *map[int64]uint32: + fastpathTV.EncMapInt64Uint32V(*v, fastpathCheckNilTrue, e) + + case map[int64]uint64: + fastpathTV.EncMapInt64Uint64V(v, fastpathCheckNilTrue, e) + case *map[int64]uint64: + fastpathTV.EncMapInt64Uint64V(*v, fastpathCheckNilTrue, e) + + case map[int64]uintptr: + fastpathTV.EncMapInt64UintptrV(v, fastpathCheckNilTrue, e) + case *map[int64]uintptr: + fastpathTV.EncMapInt64UintptrV(*v, fastpathCheckNilTrue, e) + + case map[int64]int: + fastpathTV.EncMapInt64IntV(v, fastpathCheckNilTrue, e) + case *map[int64]int: + fastpathTV.EncMapInt64IntV(*v, fastpathCheckNilTrue, e) + + case map[int64]int8: + fastpathTV.EncMapInt64Int8V(v, fastpathCheckNilTrue, e) + case *map[int64]int8: + fastpathTV.EncMapInt64Int8V(*v, fastpathCheckNilTrue, e) + + case map[int64]int16: + fastpathTV.EncMapInt64Int16V(v, fastpathCheckNilTrue, e) + case *map[int64]int16: + fastpathTV.EncMapInt64Int16V(*v, fastpathCheckNilTrue, e) + + case map[int64]int32: + fastpathTV.EncMapInt64Int32V(v, fastpathCheckNilTrue, e) + case *map[int64]int32: + fastpathTV.EncMapInt64Int32V(*v, fastpathCheckNilTrue, e) + + case map[int64]int64: + fastpathTV.EncMapInt64Int64V(v, fastpathCheckNilTrue, e) + case *map[int64]int64: + fastpathTV.EncMapInt64Int64V(*v, fastpathCheckNilTrue, e) + + case map[int64]float32: + fastpathTV.EncMapInt64Float32V(v, fastpathCheckNilTrue, e) + case *map[int64]float32: + fastpathTV.EncMapInt64Float32V(*v, fastpathCheckNilTrue, e) + + case map[int64]float64: + fastpathTV.EncMapInt64Float64V(v, fastpathCheckNilTrue, e) + case *map[int64]float64: + fastpathTV.EncMapInt64Float64V(*v, fastpathCheckNilTrue, e) + + case map[int64]bool: + fastpathTV.EncMapInt64BoolV(v, fastpathCheckNilTrue, e) + case *map[int64]bool: + fastpathTV.EncMapInt64BoolV(*v, fastpathCheckNilTrue, e) + + case map[bool]interface{}: + fastpathTV.EncMapBoolIntfV(v, fastpathCheckNilTrue, e) + case *map[bool]interface{}: + fastpathTV.EncMapBoolIntfV(*v, fastpathCheckNilTrue, e) + + case map[bool]string: + fastpathTV.EncMapBoolStringV(v, fastpathCheckNilTrue, e) + case *map[bool]string: + fastpathTV.EncMapBoolStringV(*v, fastpathCheckNilTrue, e) + + case map[bool]uint: + fastpathTV.EncMapBoolUintV(v, fastpathCheckNilTrue, e) + case *map[bool]uint: + fastpathTV.EncMapBoolUintV(*v, fastpathCheckNilTrue, e) + + case map[bool]uint8: + fastpathTV.EncMapBoolUint8V(v, fastpathCheckNilTrue, e) + case *map[bool]uint8: + fastpathTV.EncMapBoolUint8V(*v, fastpathCheckNilTrue, e) + + case map[bool]uint16: + fastpathTV.EncMapBoolUint16V(v, fastpathCheckNilTrue, e) + case *map[bool]uint16: + fastpathTV.EncMapBoolUint16V(*v, fastpathCheckNilTrue, e) + + case map[bool]uint32: + fastpathTV.EncMapBoolUint32V(v, fastpathCheckNilTrue, e) + case *map[bool]uint32: + fastpathTV.EncMapBoolUint32V(*v, fastpathCheckNilTrue, e) + + case map[bool]uint64: + fastpathTV.EncMapBoolUint64V(v, fastpathCheckNilTrue, e) + case *map[bool]uint64: + fastpathTV.EncMapBoolUint64V(*v, fastpathCheckNilTrue, e) + + case map[bool]uintptr: + fastpathTV.EncMapBoolUintptrV(v, fastpathCheckNilTrue, e) + case *map[bool]uintptr: + fastpathTV.EncMapBoolUintptrV(*v, fastpathCheckNilTrue, e) + + case map[bool]int: + fastpathTV.EncMapBoolIntV(v, fastpathCheckNilTrue, e) + case *map[bool]int: + fastpathTV.EncMapBoolIntV(*v, fastpathCheckNilTrue, e) + + case map[bool]int8: + fastpathTV.EncMapBoolInt8V(v, fastpathCheckNilTrue, e) + case *map[bool]int8: + fastpathTV.EncMapBoolInt8V(*v, fastpathCheckNilTrue, e) + + case map[bool]int16: + fastpathTV.EncMapBoolInt16V(v, fastpathCheckNilTrue, e) + case *map[bool]int16: + fastpathTV.EncMapBoolInt16V(*v, fastpathCheckNilTrue, e) + + case map[bool]int32: + fastpathTV.EncMapBoolInt32V(v, fastpathCheckNilTrue, e) + case *map[bool]int32: + fastpathTV.EncMapBoolInt32V(*v, fastpathCheckNilTrue, e) + + case map[bool]int64: + fastpathTV.EncMapBoolInt64V(v, fastpathCheckNilTrue, e) + case *map[bool]int64: + fastpathTV.EncMapBoolInt64V(*v, fastpathCheckNilTrue, e) + + case map[bool]float32: + fastpathTV.EncMapBoolFloat32V(v, fastpathCheckNilTrue, e) + case *map[bool]float32: + fastpathTV.EncMapBoolFloat32V(*v, fastpathCheckNilTrue, e) + + case map[bool]float64: + fastpathTV.EncMapBoolFloat64V(v, fastpathCheckNilTrue, e) + case *map[bool]float64: + fastpathTV.EncMapBoolFloat64V(*v, fastpathCheckNilTrue, e) + + case map[bool]bool: + fastpathTV.EncMapBoolBoolV(v, fastpathCheckNilTrue, e) + case *map[bool]bool: + fastpathTV.EncMapBoolBoolV(*v, fastpathCheckNilTrue, e) + + default: + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) + return false + } + return true +} + +// -- -- fast path functions + +func (f *encFnInfo) fastpathEncSliceIntfR(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceIntfV(rv.Interface().([]interface{}), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceIntfV(rv.Interface().([]interface{}), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceIntfV(v []interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + e.encode(v2) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceIntfV(v []interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + e.encode(v2) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceStringR(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceStringV(v []string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeString(c_UTF8, v2) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceStringV(v []string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeString(c_UTF8, v2) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceFloat32R(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceFloat32V(v []float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeFloat32(v2) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceFloat32V(v []float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeFloat32(v2) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceFloat64R(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceFloat64V(v []float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeFloat64(v2) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceFloat64V(v []float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeFloat64(v2) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceUintR(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceUintV(v []uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeUint(uint64(v2)) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceUintV(v []uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeUint(uint64(v2)) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceUint16R(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceUint16V(v []uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeUint(uint64(v2)) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceUint16V(v []uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeUint(uint64(v2)) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceUint32R(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceUint32V(v []uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeUint(uint64(v2)) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceUint32V(v []uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeUint(uint64(v2)) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceUint64R(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceUint64V(v []uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeUint(uint64(v2)) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceUint64V(v []uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeUint(uint64(v2)) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceUintptrR(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + e.encode(v2) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + e.encode(v2) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceIntR(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceIntV(v []int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeInt(int64(v2)) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceIntV(v []int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeInt(int64(v2)) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceInt8R(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceInt8V(v []int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeInt(int64(v2)) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceInt8V(v []int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeInt(int64(v2)) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceInt16R(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceInt16V(v []int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeInt(int64(v2)) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceInt16V(v []int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeInt(int64(v2)) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceInt32R(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceInt32V(v []int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeInt(int64(v2)) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceInt32V(v []int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeInt(int64(v2)) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceInt64R(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceInt64V(v []int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeInt(int64(v2)) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceInt64V(v []int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeInt(int64(v2)) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncSliceBoolR(rv reflect.Value) { + if f.ti.mbs { + fastpathTV.EncAsMapSliceBoolV(rv.Interface().([]bool), fastpathCheckNilFalse, f.e) + } else { + fastpathTV.EncSliceBoolV(rv.Interface().([]bool), fastpathCheckNilFalse, f.e) + } +} +func (_ fastpathT) EncSliceBoolV(v []bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeArrayStart(len(v)) + for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } + ee.EncodeBool(v2) + } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } +} + +func (_ fastpathT) EncAsMapSliceBoolV(v []bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + if len(v)%2 == 1 { + e.errorf("mapBySlice requires even slice length, but got %v", len(v)) + return + } + ee.EncodeMapStart(len(v) / 2) + for j, v2 := range v { + if cr != nil { + if j%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } + ee.EncodeBool(v2) + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfIntfR(rv reflect.Value) { + fastpathTV.EncMapIntfIntfV(rv.Interface().(map[interface{}]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfStringR(rv reflect.Value) { + fastpathTV.EncMapIntfStringV(rv.Interface().(map[interface{}]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfUintR(rv reflect.Value) { + fastpathTV.EncMapIntfUintV(rv.Interface().(map[interface{}]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfUint8R(rv reflect.Value) { + fastpathTV.EncMapIntfUint8V(rv.Interface().(map[interface{}]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfUint16R(rv reflect.Value) { + fastpathTV.EncMapIntfUint16V(rv.Interface().(map[interface{}]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfUint32R(rv reflect.Value) { + fastpathTV.EncMapIntfUint32V(rv.Interface().(map[interface{}]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfUint64R(rv reflect.Value) { + fastpathTV.EncMapIntfUint64V(rv.Interface().(map[interface{}]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfUintptrR(rv reflect.Value) { + fastpathTV.EncMapIntfUintptrV(rv.Interface().(map[interface{}]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfIntR(rv reflect.Value) { + fastpathTV.EncMapIntfIntV(rv.Interface().(map[interface{}]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfInt8R(rv reflect.Value) { + fastpathTV.EncMapIntfInt8V(rv.Interface().(map[interface{}]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfInt16R(rv reflect.Value) { + fastpathTV.EncMapIntfInt16V(rv.Interface().(map[interface{}]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfInt32R(rv reflect.Value) { + fastpathTV.EncMapIntfInt32V(rv.Interface().(map[interface{}]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfInt64R(rv reflect.Value) { + fastpathTV.EncMapIntfInt64V(rv.Interface().(map[interface{}]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfFloat32R(rv reflect.Value) { + fastpathTV.EncMapIntfFloat32V(rv.Interface().(map[interface{}]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfFloat64R(rv reflect.Value) { + fastpathTV.EncMapIntfFloat64V(rv.Interface().(map[interface{}]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntfBoolR(rv reflect.Value) { + fastpathTV.EncMapIntfBoolV(rv.Interface().(map[interface{}]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding + e2 := NewEncoderBytes(&mksv, e.hh) + v2 := make([]bytesI, len(v)) + var i, l int + var vp *bytesI + for k2, _ := range v { + l = len(mksv) + e2.MustEncode(k2) + vp = &v2[i] + vp.v = mksv[l:] + vp.i = k2 + i++ + } + sort.Sort(bytesISlice(v2)) + for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[v2[j].i]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringIntfR(rv reflect.Value) { + fastpathTV.EncMapStringIntfV(rv.Interface().(map[string]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[string(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringStringR(rv reflect.Value) { + fastpathTV.EncMapStringStringV(rv.Interface().(map[string]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringStringV(v map[string]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[string(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringUintR(rv reflect.Value) { + fastpathTV.EncMapStringUintV(rv.Interface().(map[string]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringUintV(v map[string]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[string(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringUint8R(rv reflect.Value) { + fastpathTV.EncMapStringUint8V(rv.Interface().(map[string]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[string(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringUint16R(rv reflect.Value) { + fastpathTV.EncMapStringUint16V(rv.Interface().(map[string]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[string(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringUint32R(rv reflect.Value) { + fastpathTV.EncMapStringUint32V(rv.Interface().(map[string]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[string(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringUint64R(rv reflect.Value) { + fastpathTV.EncMapStringUint64V(rv.Interface().(map[string]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[string(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringUintptrR(rv reflect.Value) { + fastpathTV.EncMapStringUintptrV(rv.Interface().(map[string]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[string(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringIntR(rv reflect.Value) { + fastpathTV.EncMapStringIntV(rv.Interface().(map[string]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringIntV(v map[string]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[string(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringInt8R(rv reflect.Value) { + fastpathTV.EncMapStringInt8V(rv.Interface().(map[string]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringInt8V(v map[string]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[string(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringInt16R(rv reflect.Value) { + fastpathTV.EncMapStringInt16V(rv.Interface().(map[string]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringInt16V(v map[string]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[string(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringInt32R(rv reflect.Value) { + fastpathTV.EncMapStringInt32V(rv.Interface().(map[string]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringInt32V(v map[string]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[string(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringInt64R(rv reflect.Value) { + fastpathTV.EncMapStringInt64V(rv.Interface().(map[string]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringInt64V(v map[string]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[string(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringFloat32R(rv reflect.Value) { + fastpathTV.EncMapStringFloat32V(rv.Interface().(map[string]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[string(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringFloat64R(rv reflect.Value) { + fastpathTV.EncMapStringFloat64V(rv.Interface().(map[string]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[string(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapStringBoolR(rv reflect.Value) { + fastpathTV.EncMapStringBoolV(rv.Interface().(map[string]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapStringBoolV(v map[string]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0 + if e.h.Canonical { + v2 := make([]string, len(v)) + var i int + for k, _ := range v { + v2[i] = string(k) + i++ + } + sort.Sort(stringSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[string(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + if asSymbols { + ee.EncodeSymbol(k2) + } else { + ee.EncodeString(c_UTF8, k2) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32IntfR(rv reflect.Value) { + fastpathTV.EncMapFloat32IntfV(rv.Interface().(map[float32]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[float32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32StringR(rv reflect.Value) { + fastpathTV.EncMapFloat32StringV(rv.Interface().(map[float32]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[float32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32UintR(rv reflect.Value) { + fastpathTV.EncMapFloat32UintV(rv.Interface().(map[float32]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[float32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32Uint8R(rv reflect.Value) { + fastpathTV.EncMapFloat32Uint8V(rv.Interface().(map[float32]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[float32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32Uint16R(rv reflect.Value) { + fastpathTV.EncMapFloat32Uint16V(rv.Interface().(map[float32]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[float32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32Uint32R(rv reflect.Value) { + fastpathTV.EncMapFloat32Uint32V(rv.Interface().(map[float32]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[float32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32Uint64R(rv reflect.Value) { + fastpathTV.EncMapFloat32Uint64V(rv.Interface().(map[float32]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[float32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32UintptrR(rv reflect.Value) { + fastpathTV.EncMapFloat32UintptrV(rv.Interface().(map[float32]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[float32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32IntR(rv reflect.Value) { + fastpathTV.EncMapFloat32IntV(rv.Interface().(map[float32]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[float32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32Int8R(rv reflect.Value) { + fastpathTV.EncMapFloat32Int8V(rv.Interface().(map[float32]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[float32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32Int16R(rv reflect.Value) { + fastpathTV.EncMapFloat32Int16V(rv.Interface().(map[float32]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[float32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32Int32R(rv reflect.Value) { + fastpathTV.EncMapFloat32Int32V(rv.Interface().(map[float32]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[float32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32Int64R(rv reflect.Value) { + fastpathTV.EncMapFloat32Int64V(rv.Interface().(map[float32]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[float32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32Float32R(rv reflect.Value) { + fastpathTV.EncMapFloat32Float32V(rv.Interface().(map[float32]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[float32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32Float64R(rv reflect.Value) { + fastpathTV.EncMapFloat32Float64V(rv.Interface().(map[float32]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[float32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat32BoolR(rv reflect.Value) { + fastpathTV.EncMapFloat32BoolV(rv.Interface().(map[float32]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[float32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64IntfR(rv reflect.Value) { + fastpathTV.EncMapFloat64IntfV(rv.Interface().(map[float64]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[float64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64StringR(rv reflect.Value) { + fastpathTV.EncMapFloat64StringV(rv.Interface().(map[float64]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[float64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64UintR(rv reflect.Value) { + fastpathTV.EncMapFloat64UintV(rv.Interface().(map[float64]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[float64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64Uint8R(rv reflect.Value) { + fastpathTV.EncMapFloat64Uint8V(rv.Interface().(map[float64]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[float64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64Uint16R(rv reflect.Value) { + fastpathTV.EncMapFloat64Uint16V(rv.Interface().(map[float64]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[float64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64Uint32R(rv reflect.Value) { + fastpathTV.EncMapFloat64Uint32V(rv.Interface().(map[float64]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[float64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64Uint64R(rv reflect.Value) { + fastpathTV.EncMapFloat64Uint64V(rv.Interface().(map[float64]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[float64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64UintptrR(rv reflect.Value) { + fastpathTV.EncMapFloat64UintptrV(rv.Interface().(map[float64]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[float64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64IntR(rv reflect.Value) { + fastpathTV.EncMapFloat64IntV(rv.Interface().(map[float64]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[float64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64Int8R(rv reflect.Value) { + fastpathTV.EncMapFloat64Int8V(rv.Interface().(map[float64]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[float64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64Int16R(rv reflect.Value) { + fastpathTV.EncMapFloat64Int16V(rv.Interface().(map[float64]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[float64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64Int32R(rv reflect.Value) { + fastpathTV.EncMapFloat64Int32V(rv.Interface().(map[float64]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[float64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64Int64R(rv reflect.Value) { + fastpathTV.EncMapFloat64Int64V(rv.Interface().(map[float64]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[float64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64Float32R(rv reflect.Value) { + fastpathTV.EncMapFloat64Float32V(rv.Interface().(map[float64]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[float64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64Float64R(rv reflect.Value) { + fastpathTV.EncMapFloat64Float64V(rv.Interface().(map[float64]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[float64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapFloat64BoolR(rv reflect.Value) { + fastpathTV.EncMapFloat64BoolV(rv.Interface().(map[float64]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]float64, len(v)) + var i int + for k, _ := range v { + v2[i] = float64(k) + i++ + } + sort.Sort(floatSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[float64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintIntfR(rv reflect.Value) { + fastpathTV.EncMapUintIntfV(rv.Interface().(map[uint]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uint(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintStringR(rv reflect.Value) { + fastpathTV.EncMapUintStringV(rv.Interface().(map[uint]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintStringV(v map[uint]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[uint(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintUintR(rv reflect.Value) { + fastpathTV.EncMapUintUintV(rv.Interface().(map[uint]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintUintV(v map[uint]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintUint8R(rv reflect.Value) { + fastpathTV.EncMapUintUint8V(rv.Interface().(map[uint]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintUint16R(rv reflect.Value) { + fastpathTV.EncMapUintUint16V(rv.Interface().(map[uint]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintUint32R(rv reflect.Value) { + fastpathTV.EncMapUintUint32V(rv.Interface().(map[uint]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintUint64R(rv reflect.Value) { + fastpathTV.EncMapUintUint64V(rv.Interface().(map[uint]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintUintptrR(rv reflect.Value) { + fastpathTV.EncMapUintUintptrV(rv.Interface().(map[uint]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uint(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintIntR(rv reflect.Value) { + fastpathTV.EncMapUintIntV(rv.Interface().(map[uint]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintIntV(v map[uint]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintInt8R(rv reflect.Value) { + fastpathTV.EncMapUintInt8V(rv.Interface().(map[uint]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintInt16R(rv reflect.Value) { + fastpathTV.EncMapUintInt16V(rv.Interface().(map[uint]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintInt32R(rv reflect.Value) { + fastpathTV.EncMapUintInt32V(rv.Interface().(map[uint]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintInt64R(rv reflect.Value) { + fastpathTV.EncMapUintInt64V(rv.Interface().(map[uint]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintFloat32R(rv reflect.Value) { + fastpathTV.EncMapUintFloat32V(rv.Interface().(map[uint]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[uint(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintFloat64R(rv reflect.Value) { + fastpathTV.EncMapUintFloat64V(rv.Interface().(map[uint]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[uint(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintBoolR(rv reflect.Value) { + fastpathTV.EncMapUintBoolV(rv.Interface().(map[uint]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[uint(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8IntfR(rv reflect.Value) { + fastpathTV.EncMapUint8IntfV(rv.Interface().(map[uint8]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uint8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8StringR(rv reflect.Value) { + fastpathTV.EncMapUint8StringV(rv.Interface().(map[uint8]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[uint8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8UintR(rv reflect.Value) { + fastpathTV.EncMapUint8UintV(rv.Interface().(map[uint8]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8Uint8R(rv reflect.Value) { + fastpathTV.EncMapUint8Uint8V(rv.Interface().(map[uint8]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8Uint16R(rv reflect.Value) { + fastpathTV.EncMapUint8Uint16V(rv.Interface().(map[uint8]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8Uint32R(rv reflect.Value) { + fastpathTV.EncMapUint8Uint32V(rv.Interface().(map[uint8]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8Uint64R(rv reflect.Value) { + fastpathTV.EncMapUint8Uint64V(rv.Interface().(map[uint8]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8UintptrR(rv reflect.Value) { + fastpathTV.EncMapUint8UintptrV(rv.Interface().(map[uint8]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uint8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8IntR(rv reflect.Value) { + fastpathTV.EncMapUint8IntV(rv.Interface().(map[uint8]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8Int8R(rv reflect.Value) { + fastpathTV.EncMapUint8Int8V(rv.Interface().(map[uint8]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8Int16R(rv reflect.Value) { + fastpathTV.EncMapUint8Int16V(rv.Interface().(map[uint8]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8Int32R(rv reflect.Value) { + fastpathTV.EncMapUint8Int32V(rv.Interface().(map[uint8]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8Int64R(rv reflect.Value) { + fastpathTV.EncMapUint8Int64V(rv.Interface().(map[uint8]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8Float32R(rv reflect.Value) { + fastpathTV.EncMapUint8Float32V(rv.Interface().(map[uint8]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[uint8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8Float64R(rv reflect.Value) { + fastpathTV.EncMapUint8Float64V(rv.Interface().(map[uint8]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[uint8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint8BoolR(rv reflect.Value) { + fastpathTV.EncMapUint8BoolV(rv.Interface().(map[uint8]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[uint8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16IntfR(rv reflect.Value) { + fastpathTV.EncMapUint16IntfV(rv.Interface().(map[uint16]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uint16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16StringR(rv reflect.Value) { + fastpathTV.EncMapUint16StringV(rv.Interface().(map[uint16]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[uint16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16UintR(rv reflect.Value) { + fastpathTV.EncMapUint16UintV(rv.Interface().(map[uint16]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16Uint8R(rv reflect.Value) { + fastpathTV.EncMapUint16Uint8V(rv.Interface().(map[uint16]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16Uint16R(rv reflect.Value) { + fastpathTV.EncMapUint16Uint16V(rv.Interface().(map[uint16]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16Uint32R(rv reflect.Value) { + fastpathTV.EncMapUint16Uint32V(rv.Interface().(map[uint16]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16Uint64R(rv reflect.Value) { + fastpathTV.EncMapUint16Uint64V(rv.Interface().(map[uint16]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16UintptrR(rv reflect.Value) { + fastpathTV.EncMapUint16UintptrV(rv.Interface().(map[uint16]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uint16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16IntR(rv reflect.Value) { + fastpathTV.EncMapUint16IntV(rv.Interface().(map[uint16]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16Int8R(rv reflect.Value) { + fastpathTV.EncMapUint16Int8V(rv.Interface().(map[uint16]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16Int16R(rv reflect.Value) { + fastpathTV.EncMapUint16Int16V(rv.Interface().(map[uint16]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16Int32R(rv reflect.Value) { + fastpathTV.EncMapUint16Int32V(rv.Interface().(map[uint16]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16Int64R(rv reflect.Value) { + fastpathTV.EncMapUint16Int64V(rv.Interface().(map[uint16]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16Float32R(rv reflect.Value) { + fastpathTV.EncMapUint16Float32V(rv.Interface().(map[uint16]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[uint16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16Float64R(rv reflect.Value) { + fastpathTV.EncMapUint16Float64V(rv.Interface().(map[uint16]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[uint16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint16BoolR(rv reflect.Value) { + fastpathTV.EncMapUint16BoolV(rv.Interface().(map[uint16]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[uint16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32IntfR(rv reflect.Value) { + fastpathTV.EncMapUint32IntfV(rv.Interface().(map[uint32]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uint32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32StringR(rv reflect.Value) { + fastpathTV.EncMapUint32StringV(rv.Interface().(map[uint32]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[uint32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32UintR(rv reflect.Value) { + fastpathTV.EncMapUint32UintV(rv.Interface().(map[uint32]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32Uint8R(rv reflect.Value) { + fastpathTV.EncMapUint32Uint8V(rv.Interface().(map[uint32]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32Uint16R(rv reflect.Value) { + fastpathTV.EncMapUint32Uint16V(rv.Interface().(map[uint32]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32Uint32R(rv reflect.Value) { + fastpathTV.EncMapUint32Uint32V(rv.Interface().(map[uint32]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32Uint64R(rv reflect.Value) { + fastpathTV.EncMapUint32Uint64V(rv.Interface().(map[uint32]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32UintptrR(rv reflect.Value) { + fastpathTV.EncMapUint32UintptrV(rv.Interface().(map[uint32]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uint32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32IntR(rv reflect.Value) { + fastpathTV.EncMapUint32IntV(rv.Interface().(map[uint32]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32Int8R(rv reflect.Value) { + fastpathTV.EncMapUint32Int8V(rv.Interface().(map[uint32]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32Int16R(rv reflect.Value) { + fastpathTV.EncMapUint32Int16V(rv.Interface().(map[uint32]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32Int32R(rv reflect.Value) { + fastpathTV.EncMapUint32Int32V(rv.Interface().(map[uint32]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32Int64R(rv reflect.Value) { + fastpathTV.EncMapUint32Int64V(rv.Interface().(map[uint32]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32Float32R(rv reflect.Value) { + fastpathTV.EncMapUint32Float32V(rv.Interface().(map[uint32]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[uint32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32Float64R(rv reflect.Value) { + fastpathTV.EncMapUint32Float64V(rv.Interface().(map[uint32]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[uint32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint32BoolR(rv reflect.Value) { + fastpathTV.EncMapUint32BoolV(rv.Interface().(map[uint32]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[uint32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64IntfR(rv reflect.Value) { + fastpathTV.EncMapUint64IntfV(rv.Interface().(map[uint64]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uint64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64StringR(rv reflect.Value) { + fastpathTV.EncMapUint64StringV(rv.Interface().(map[uint64]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[uint64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64UintR(rv reflect.Value) { + fastpathTV.EncMapUint64UintV(rv.Interface().(map[uint64]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64Uint8R(rv reflect.Value) { + fastpathTV.EncMapUint64Uint8V(rv.Interface().(map[uint64]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64Uint16R(rv reflect.Value) { + fastpathTV.EncMapUint64Uint16V(rv.Interface().(map[uint64]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64Uint32R(rv reflect.Value) { + fastpathTV.EncMapUint64Uint32V(rv.Interface().(map[uint64]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64Uint64R(rv reflect.Value) { + fastpathTV.EncMapUint64Uint64V(rv.Interface().(map[uint64]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uint64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64UintptrR(rv reflect.Value) { + fastpathTV.EncMapUint64UintptrV(rv.Interface().(map[uint64]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uint64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64IntR(rv reflect.Value) { + fastpathTV.EncMapUint64IntV(rv.Interface().(map[uint64]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64Int8R(rv reflect.Value) { + fastpathTV.EncMapUint64Int8V(rv.Interface().(map[uint64]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64Int16R(rv reflect.Value) { + fastpathTV.EncMapUint64Int16V(rv.Interface().(map[uint64]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64Int32R(rv reflect.Value) { + fastpathTV.EncMapUint64Int32V(rv.Interface().(map[uint64]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64Int64R(rv reflect.Value) { + fastpathTV.EncMapUint64Int64V(rv.Interface().(map[uint64]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uint64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64Float32R(rv reflect.Value) { + fastpathTV.EncMapUint64Float32V(rv.Interface().(map[uint64]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[uint64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64Float64R(rv reflect.Value) { + fastpathTV.EncMapUint64Float64V(rv.Interface().(map[uint64]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[uint64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUint64BoolR(rv reflect.Value) { + fastpathTV.EncMapUint64BoolV(rv.Interface().(map[uint64]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[uint64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrIntfR(rv reflect.Value) { + fastpathTV.EncMapUintptrIntfV(rv.Interface().(map[uintptr]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uintptr(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrStringR(rv reflect.Value) { + fastpathTV.EncMapUintptrStringV(rv.Interface().(map[uintptr]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[uintptr(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrUintR(rv reflect.Value) { + fastpathTV.EncMapUintptrUintV(rv.Interface().(map[uintptr]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uintptr(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrUint8R(rv reflect.Value) { + fastpathTV.EncMapUintptrUint8V(rv.Interface().(map[uintptr]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uintptr(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrUint16R(rv reflect.Value) { + fastpathTV.EncMapUintptrUint16V(rv.Interface().(map[uintptr]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uintptr(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrUint32R(rv reflect.Value) { + fastpathTV.EncMapUintptrUint32V(rv.Interface().(map[uintptr]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uintptr(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrUint64R(rv reflect.Value) { + fastpathTV.EncMapUintptrUint64V(rv.Interface().(map[uintptr]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[uintptr(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrUintptrR(rv reflect.Value) { + fastpathTV.EncMapUintptrUintptrV(rv.Interface().(map[uintptr]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[uintptr(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrIntR(rv reflect.Value) { + fastpathTV.EncMapUintptrIntV(rv.Interface().(map[uintptr]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uintptr(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrInt8R(rv reflect.Value) { + fastpathTV.EncMapUintptrInt8V(rv.Interface().(map[uintptr]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uintptr(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrInt16R(rv reflect.Value) { + fastpathTV.EncMapUintptrInt16V(rv.Interface().(map[uintptr]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uintptr(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrInt32R(rv reflect.Value) { + fastpathTV.EncMapUintptrInt32V(rv.Interface().(map[uintptr]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uintptr(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrInt64R(rv reflect.Value) { + fastpathTV.EncMapUintptrInt64V(rv.Interface().(map[uintptr]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[uintptr(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrFloat32R(rv reflect.Value) { + fastpathTV.EncMapUintptrFloat32V(rv.Interface().(map[uintptr]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[uintptr(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrFloat64R(rv reflect.Value) { + fastpathTV.EncMapUintptrFloat64V(rv.Interface().(map[uintptr]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[uintptr(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapUintptrBoolR(rv reflect.Value) { + fastpathTV.EncMapUintptrBoolV(rv.Interface().(map[uintptr]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]uint64, len(v)) + var i int + for k, _ := range v { + v2[i] = uint64(k) + i++ + } + sort.Sort(uintSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[uintptr(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntIntfR(rv reflect.Value) { + fastpathTV.EncMapIntIntfV(rv.Interface().(map[int]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[int(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntStringR(rv reflect.Value) { + fastpathTV.EncMapIntStringV(rv.Interface().(map[int]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntStringV(v map[int]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[int(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntUintR(rv reflect.Value) { + fastpathTV.EncMapIntUintV(rv.Interface().(map[int]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntUintV(v map[int]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntUint8R(rv reflect.Value) { + fastpathTV.EncMapIntUint8V(rv.Interface().(map[int]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntUint16R(rv reflect.Value) { + fastpathTV.EncMapIntUint16V(rv.Interface().(map[int]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntUint32R(rv reflect.Value) { + fastpathTV.EncMapIntUint32V(rv.Interface().(map[int]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntUint64R(rv reflect.Value) { + fastpathTV.EncMapIntUint64V(rv.Interface().(map[int]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntUintptrR(rv reflect.Value) { + fastpathTV.EncMapIntUintptrV(rv.Interface().(map[int]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[int(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntIntR(rv reflect.Value) { + fastpathTV.EncMapIntIntV(rv.Interface().(map[int]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntIntV(v map[int]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntInt8R(rv reflect.Value) { + fastpathTV.EncMapIntInt8V(rv.Interface().(map[int]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntInt8V(v map[int]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntInt16R(rv reflect.Value) { + fastpathTV.EncMapIntInt16V(rv.Interface().(map[int]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntInt16V(v map[int]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntInt32R(rv reflect.Value) { + fastpathTV.EncMapIntInt32V(rv.Interface().(map[int]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntInt32V(v map[int]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntInt64R(rv reflect.Value) { + fastpathTV.EncMapIntInt64V(rv.Interface().(map[int]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntInt64V(v map[int]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntFloat32R(rv reflect.Value) { + fastpathTV.EncMapIntFloat32V(rv.Interface().(map[int]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[int(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntFloat64R(rv reflect.Value) { + fastpathTV.EncMapIntFloat64V(rv.Interface().(map[int]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[int(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapIntBoolR(rv reflect.Value) { + fastpathTV.EncMapIntBoolV(rv.Interface().(map[int]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapIntBoolV(v map[int]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[int(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8IntfR(rv reflect.Value) { + fastpathTV.EncMapInt8IntfV(rv.Interface().(map[int8]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[int8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8StringR(rv reflect.Value) { + fastpathTV.EncMapInt8StringV(rv.Interface().(map[int8]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8StringV(v map[int8]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[int8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8UintR(rv reflect.Value) { + fastpathTV.EncMapInt8UintV(rv.Interface().(map[int8]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8Uint8R(rv reflect.Value) { + fastpathTV.EncMapInt8Uint8V(rv.Interface().(map[int8]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8Uint16R(rv reflect.Value) { + fastpathTV.EncMapInt8Uint16V(rv.Interface().(map[int8]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8Uint32R(rv reflect.Value) { + fastpathTV.EncMapInt8Uint32V(rv.Interface().(map[int8]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8Uint64R(rv reflect.Value) { + fastpathTV.EncMapInt8Uint64V(rv.Interface().(map[int8]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8UintptrR(rv reflect.Value) { + fastpathTV.EncMapInt8UintptrV(rv.Interface().(map[int8]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[int8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8IntR(rv reflect.Value) { + fastpathTV.EncMapInt8IntV(rv.Interface().(map[int8]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8IntV(v map[int8]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8Int8R(rv reflect.Value) { + fastpathTV.EncMapInt8Int8V(rv.Interface().(map[int8]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8Int16R(rv reflect.Value) { + fastpathTV.EncMapInt8Int16V(rv.Interface().(map[int8]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8Int32R(rv reflect.Value) { + fastpathTV.EncMapInt8Int32V(rv.Interface().(map[int8]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8Int64R(rv reflect.Value) { + fastpathTV.EncMapInt8Int64V(rv.Interface().(map[int8]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int8(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8Float32R(rv reflect.Value) { + fastpathTV.EncMapInt8Float32V(rv.Interface().(map[int8]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[int8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8Float64R(rv reflect.Value) { + fastpathTV.EncMapInt8Float64V(rv.Interface().(map[int8]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[int8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt8BoolR(rv reflect.Value) { + fastpathTV.EncMapInt8BoolV(rv.Interface().(map[int8]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[int8(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16IntfR(rv reflect.Value) { + fastpathTV.EncMapInt16IntfV(rv.Interface().(map[int16]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[int16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16StringR(rv reflect.Value) { + fastpathTV.EncMapInt16StringV(rv.Interface().(map[int16]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16StringV(v map[int16]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[int16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16UintR(rv reflect.Value) { + fastpathTV.EncMapInt16UintV(rv.Interface().(map[int16]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16Uint8R(rv reflect.Value) { + fastpathTV.EncMapInt16Uint8V(rv.Interface().(map[int16]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16Uint16R(rv reflect.Value) { + fastpathTV.EncMapInt16Uint16V(rv.Interface().(map[int16]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16Uint32R(rv reflect.Value) { + fastpathTV.EncMapInt16Uint32V(rv.Interface().(map[int16]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16Uint64R(rv reflect.Value) { + fastpathTV.EncMapInt16Uint64V(rv.Interface().(map[int16]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16UintptrR(rv reflect.Value) { + fastpathTV.EncMapInt16UintptrV(rv.Interface().(map[int16]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[int16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16IntR(rv reflect.Value) { + fastpathTV.EncMapInt16IntV(rv.Interface().(map[int16]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16IntV(v map[int16]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16Int8R(rv reflect.Value) { + fastpathTV.EncMapInt16Int8V(rv.Interface().(map[int16]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16Int16R(rv reflect.Value) { + fastpathTV.EncMapInt16Int16V(rv.Interface().(map[int16]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16Int32R(rv reflect.Value) { + fastpathTV.EncMapInt16Int32V(rv.Interface().(map[int16]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16Int64R(rv reflect.Value) { + fastpathTV.EncMapInt16Int64V(rv.Interface().(map[int16]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int16(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16Float32R(rv reflect.Value) { + fastpathTV.EncMapInt16Float32V(rv.Interface().(map[int16]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[int16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16Float64R(rv reflect.Value) { + fastpathTV.EncMapInt16Float64V(rv.Interface().(map[int16]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[int16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt16BoolR(rv reflect.Value) { + fastpathTV.EncMapInt16BoolV(rv.Interface().(map[int16]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[int16(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32IntfR(rv reflect.Value) { + fastpathTV.EncMapInt32IntfV(rv.Interface().(map[int32]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[int32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32StringR(rv reflect.Value) { + fastpathTV.EncMapInt32StringV(rv.Interface().(map[int32]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32StringV(v map[int32]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[int32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32UintR(rv reflect.Value) { + fastpathTV.EncMapInt32UintV(rv.Interface().(map[int32]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32Uint8R(rv reflect.Value) { + fastpathTV.EncMapInt32Uint8V(rv.Interface().(map[int32]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32Uint16R(rv reflect.Value) { + fastpathTV.EncMapInt32Uint16V(rv.Interface().(map[int32]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32Uint32R(rv reflect.Value) { + fastpathTV.EncMapInt32Uint32V(rv.Interface().(map[int32]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32Uint64R(rv reflect.Value) { + fastpathTV.EncMapInt32Uint64V(rv.Interface().(map[int32]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32UintptrR(rv reflect.Value) { + fastpathTV.EncMapInt32UintptrV(rv.Interface().(map[int32]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[int32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32IntR(rv reflect.Value) { + fastpathTV.EncMapInt32IntV(rv.Interface().(map[int32]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32IntV(v map[int32]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32Int8R(rv reflect.Value) { + fastpathTV.EncMapInt32Int8V(rv.Interface().(map[int32]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32Int16R(rv reflect.Value) { + fastpathTV.EncMapInt32Int16V(rv.Interface().(map[int32]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32Int32R(rv reflect.Value) { + fastpathTV.EncMapInt32Int32V(rv.Interface().(map[int32]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32Int64R(rv reflect.Value) { + fastpathTV.EncMapInt32Int64V(rv.Interface().(map[int32]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int32(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32Float32R(rv reflect.Value) { + fastpathTV.EncMapInt32Float32V(rv.Interface().(map[int32]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[int32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32Float64R(rv reflect.Value) { + fastpathTV.EncMapInt32Float64V(rv.Interface().(map[int32]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[int32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt32BoolR(rv reflect.Value) { + fastpathTV.EncMapInt32BoolV(rv.Interface().(map[int32]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[int32(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64IntfR(rv reflect.Value) { + fastpathTV.EncMapInt64IntfV(rv.Interface().(map[int64]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[int64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64StringR(rv reflect.Value) { + fastpathTV.EncMapInt64StringV(rv.Interface().(map[int64]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64StringV(v map[int64]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[int64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64UintR(rv reflect.Value) { + fastpathTV.EncMapInt64UintV(rv.Interface().(map[int64]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64Uint8R(rv reflect.Value) { + fastpathTV.EncMapInt64Uint8V(rv.Interface().(map[int64]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64Uint16R(rv reflect.Value) { + fastpathTV.EncMapInt64Uint16V(rv.Interface().(map[int64]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64Uint32R(rv reflect.Value) { + fastpathTV.EncMapInt64Uint32V(rv.Interface().(map[int64]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64Uint64R(rv reflect.Value) { + fastpathTV.EncMapInt64Uint64V(rv.Interface().(map[int64]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[int64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64UintptrR(rv reflect.Value) { + fastpathTV.EncMapInt64UintptrV(rv.Interface().(map[int64]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[int64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64IntR(rv reflect.Value) { + fastpathTV.EncMapInt64IntV(rv.Interface().(map[int64]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64IntV(v map[int64]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64Int8R(rv reflect.Value) { + fastpathTV.EncMapInt64Int8V(rv.Interface().(map[int64]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64Int16R(rv reflect.Value) { + fastpathTV.EncMapInt64Int16V(rv.Interface().(map[int64]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64Int32R(rv reflect.Value) { + fastpathTV.EncMapInt64Int32V(rv.Interface().(map[int64]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64Int64R(rv reflect.Value) { + fastpathTV.EncMapInt64Int64V(rv.Interface().(map[int64]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[int64(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64Float32R(rv reflect.Value) { + fastpathTV.EncMapInt64Float32V(rv.Interface().(map[int64]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[int64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64Float64R(rv reflect.Value) { + fastpathTV.EncMapInt64Float64V(rv.Interface().(map[int64]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[int64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapInt64BoolR(rv reflect.Value) { + fastpathTV.EncMapInt64BoolV(rv.Interface().(map[int64]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]int64, len(v)) + var i int + for k, _ := range v { + v2[i] = int64(k) + i++ + } + sort.Sort(intSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[int64(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolIntfR(rv reflect.Value) { + fastpathTV.EncMapBoolIntfV(rv.Interface().(map[bool]interface{}), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[bool(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolStringR(rv reflect.Value) { + fastpathTV.EncMapBoolStringV(rv.Interface().(map[bool]string), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolStringV(v map[bool]string, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v[bool(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeString(c_UTF8, v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolUintR(rv reflect.Value) { + fastpathTV.EncMapBoolUintV(rv.Interface().(map[bool]uint), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[bool(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolUint8R(rv reflect.Value) { + fastpathTV.EncMapBoolUint8V(rv.Interface().(map[bool]uint8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[bool(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolUint16R(rv reflect.Value) { + fastpathTV.EncMapBoolUint16V(rv.Interface().(map[bool]uint16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[bool(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolUint32R(rv reflect.Value) { + fastpathTV.EncMapBoolUint32V(rv.Interface().(map[bool]uint32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[bool(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolUint64R(rv reflect.Value) { + fastpathTV.EncMapBoolUint64V(rv.Interface().(map[bool]uint64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v[bool(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeUint(uint64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolUintptrR(rv reflect.Value) { + fastpathTV.EncMapBoolUintptrV(rv.Interface().(map[bool]uintptr), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v[bool(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + e.encode(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolIntR(rv reflect.Value) { + fastpathTV.EncMapBoolIntV(rv.Interface().(map[bool]int), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolIntV(v map[bool]int, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[bool(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolInt8R(rv reflect.Value) { + fastpathTV.EncMapBoolInt8V(rv.Interface().(map[bool]int8), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[bool(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolInt16R(rv reflect.Value) { + fastpathTV.EncMapBoolInt16V(rv.Interface().(map[bool]int16), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[bool(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolInt32R(rv reflect.Value) { + fastpathTV.EncMapBoolInt32V(rv.Interface().(map[bool]int32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[bool(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolInt64R(rv reflect.Value) { + fastpathTV.EncMapBoolInt64V(rv.Interface().(map[bool]int64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v[bool(k2)])) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeInt(int64(v2)) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolFloat32R(rv reflect.Value) { + fastpathTV.EncMapBoolFloat32V(rv.Interface().(map[bool]float32), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v[bool(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat32(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolFloat64R(rv reflect.Value) { + fastpathTV.EncMapBoolFloat64V(rv.Interface().(map[bool]float64), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v[bool(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeFloat64(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +func (f *encFnInfo) fastpathEncMapBoolBoolR(rv reflect.Value) { + fastpathTV.EncMapBoolBoolV(rv.Interface().(map[bool]bool), fastpathCheckNilFalse, f.e) +} +func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, checkNil bool, e *Encoder) { + ee := e.e + cr := e.cr + if checkNil && v == nil { + ee.EncodeNil() + return + } + ee.EncodeMapStart(len(v)) + if e.h.Canonical { + v2 := make([]bool, len(v)) + var i int + for k, _ := range v { + v2[i] = bool(k) + i++ + } + sort.Sort(boolSlice(v2)) + for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v[bool(k2)]) + } + } else { + for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + ee.EncodeBool(v2) + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } +} + +// -- decode + +// -- -- fast path type switch +func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool { + switch v := iv.(type) { + + case []interface{}: + fastpathTV.DecSliceIntfV(v, fastpathCheckNilFalse, false, d) + case *[]interface{}: + v2, changed2 := fastpathTV.DecSliceIntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]interface{}: + fastpathTV.DecMapIntfIntfV(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]interface{}: + v2, changed2 := fastpathTV.DecMapIntfIntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]string: + fastpathTV.DecMapIntfStringV(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]string: + v2, changed2 := fastpathTV.DecMapIntfStringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]uint: + fastpathTV.DecMapIntfUintV(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]uint: + v2, changed2 := fastpathTV.DecMapIntfUintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]uint8: + fastpathTV.DecMapIntfUint8V(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]uint8: + v2, changed2 := fastpathTV.DecMapIntfUint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]uint16: + fastpathTV.DecMapIntfUint16V(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]uint16: + v2, changed2 := fastpathTV.DecMapIntfUint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]uint32: + fastpathTV.DecMapIntfUint32V(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]uint32: + v2, changed2 := fastpathTV.DecMapIntfUint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]uint64: + fastpathTV.DecMapIntfUint64V(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]uint64: + v2, changed2 := fastpathTV.DecMapIntfUint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]uintptr: + fastpathTV.DecMapIntfUintptrV(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]uintptr: + v2, changed2 := fastpathTV.DecMapIntfUintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]int: + fastpathTV.DecMapIntfIntV(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]int: + v2, changed2 := fastpathTV.DecMapIntfIntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]int8: + fastpathTV.DecMapIntfInt8V(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]int8: + v2, changed2 := fastpathTV.DecMapIntfInt8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]int16: + fastpathTV.DecMapIntfInt16V(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]int16: + v2, changed2 := fastpathTV.DecMapIntfInt16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]int32: + fastpathTV.DecMapIntfInt32V(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]int32: + v2, changed2 := fastpathTV.DecMapIntfInt32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]int64: + fastpathTV.DecMapIntfInt64V(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]int64: + v2, changed2 := fastpathTV.DecMapIntfInt64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]float32: + fastpathTV.DecMapIntfFloat32V(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]float32: + v2, changed2 := fastpathTV.DecMapIntfFloat32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]float64: + fastpathTV.DecMapIntfFloat64V(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]float64: + v2, changed2 := fastpathTV.DecMapIntfFloat64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[interface{}]bool: + fastpathTV.DecMapIntfBoolV(v, fastpathCheckNilFalse, false, d) + case *map[interface{}]bool: + v2, changed2 := fastpathTV.DecMapIntfBoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []string: + fastpathTV.DecSliceStringV(v, fastpathCheckNilFalse, false, d) + case *[]string: + v2, changed2 := fastpathTV.DecSliceStringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]interface{}: + fastpathTV.DecMapStringIntfV(v, fastpathCheckNilFalse, false, d) + case *map[string]interface{}: + v2, changed2 := fastpathTV.DecMapStringIntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]string: + fastpathTV.DecMapStringStringV(v, fastpathCheckNilFalse, false, d) + case *map[string]string: + v2, changed2 := fastpathTV.DecMapStringStringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]uint: + fastpathTV.DecMapStringUintV(v, fastpathCheckNilFalse, false, d) + case *map[string]uint: + v2, changed2 := fastpathTV.DecMapStringUintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]uint8: + fastpathTV.DecMapStringUint8V(v, fastpathCheckNilFalse, false, d) + case *map[string]uint8: + v2, changed2 := fastpathTV.DecMapStringUint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]uint16: + fastpathTV.DecMapStringUint16V(v, fastpathCheckNilFalse, false, d) + case *map[string]uint16: + v2, changed2 := fastpathTV.DecMapStringUint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]uint32: + fastpathTV.DecMapStringUint32V(v, fastpathCheckNilFalse, false, d) + case *map[string]uint32: + v2, changed2 := fastpathTV.DecMapStringUint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]uint64: + fastpathTV.DecMapStringUint64V(v, fastpathCheckNilFalse, false, d) + case *map[string]uint64: + v2, changed2 := fastpathTV.DecMapStringUint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]uintptr: + fastpathTV.DecMapStringUintptrV(v, fastpathCheckNilFalse, false, d) + case *map[string]uintptr: + v2, changed2 := fastpathTV.DecMapStringUintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]int: + fastpathTV.DecMapStringIntV(v, fastpathCheckNilFalse, false, d) + case *map[string]int: + v2, changed2 := fastpathTV.DecMapStringIntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]int8: + fastpathTV.DecMapStringInt8V(v, fastpathCheckNilFalse, false, d) + case *map[string]int8: + v2, changed2 := fastpathTV.DecMapStringInt8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]int16: + fastpathTV.DecMapStringInt16V(v, fastpathCheckNilFalse, false, d) + case *map[string]int16: + v2, changed2 := fastpathTV.DecMapStringInt16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]int32: + fastpathTV.DecMapStringInt32V(v, fastpathCheckNilFalse, false, d) + case *map[string]int32: + v2, changed2 := fastpathTV.DecMapStringInt32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]int64: + fastpathTV.DecMapStringInt64V(v, fastpathCheckNilFalse, false, d) + case *map[string]int64: + v2, changed2 := fastpathTV.DecMapStringInt64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]float32: + fastpathTV.DecMapStringFloat32V(v, fastpathCheckNilFalse, false, d) + case *map[string]float32: + v2, changed2 := fastpathTV.DecMapStringFloat32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]float64: + fastpathTV.DecMapStringFloat64V(v, fastpathCheckNilFalse, false, d) + case *map[string]float64: + v2, changed2 := fastpathTV.DecMapStringFloat64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[string]bool: + fastpathTV.DecMapStringBoolV(v, fastpathCheckNilFalse, false, d) + case *map[string]bool: + v2, changed2 := fastpathTV.DecMapStringBoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []float32: + fastpathTV.DecSliceFloat32V(v, fastpathCheckNilFalse, false, d) + case *[]float32: + v2, changed2 := fastpathTV.DecSliceFloat32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]interface{}: + fastpathTV.DecMapFloat32IntfV(v, fastpathCheckNilFalse, false, d) + case *map[float32]interface{}: + v2, changed2 := fastpathTV.DecMapFloat32IntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]string: + fastpathTV.DecMapFloat32StringV(v, fastpathCheckNilFalse, false, d) + case *map[float32]string: + v2, changed2 := fastpathTV.DecMapFloat32StringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]uint: + fastpathTV.DecMapFloat32UintV(v, fastpathCheckNilFalse, false, d) + case *map[float32]uint: + v2, changed2 := fastpathTV.DecMapFloat32UintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]uint8: + fastpathTV.DecMapFloat32Uint8V(v, fastpathCheckNilFalse, false, d) + case *map[float32]uint8: + v2, changed2 := fastpathTV.DecMapFloat32Uint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]uint16: + fastpathTV.DecMapFloat32Uint16V(v, fastpathCheckNilFalse, false, d) + case *map[float32]uint16: + v2, changed2 := fastpathTV.DecMapFloat32Uint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]uint32: + fastpathTV.DecMapFloat32Uint32V(v, fastpathCheckNilFalse, false, d) + case *map[float32]uint32: + v2, changed2 := fastpathTV.DecMapFloat32Uint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]uint64: + fastpathTV.DecMapFloat32Uint64V(v, fastpathCheckNilFalse, false, d) + case *map[float32]uint64: + v2, changed2 := fastpathTV.DecMapFloat32Uint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]uintptr: + fastpathTV.DecMapFloat32UintptrV(v, fastpathCheckNilFalse, false, d) + case *map[float32]uintptr: + v2, changed2 := fastpathTV.DecMapFloat32UintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]int: + fastpathTV.DecMapFloat32IntV(v, fastpathCheckNilFalse, false, d) + case *map[float32]int: + v2, changed2 := fastpathTV.DecMapFloat32IntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]int8: + fastpathTV.DecMapFloat32Int8V(v, fastpathCheckNilFalse, false, d) + case *map[float32]int8: + v2, changed2 := fastpathTV.DecMapFloat32Int8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]int16: + fastpathTV.DecMapFloat32Int16V(v, fastpathCheckNilFalse, false, d) + case *map[float32]int16: + v2, changed2 := fastpathTV.DecMapFloat32Int16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]int32: + fastpathTV.DecMapFloat32Int32V(v, fastpathCheckNilFalse, false, d) + case *map[float32]int32: + v2, changed2 := fastpathTV.DecMapFloat32Int32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]int64: + fastpathTV.DecMapFloat32Int64V(v, fastpathCheckNilFalse, false, d) + case *map[float32]int64: + v2, changed2 := fastpathTV.DecMapFloat32Int64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]float32: + fastpathTV.DecMapFloat32Float32V(v, fastpathCheckNilFalse, false, d) + case *map[float32]float32: + v2, changed2 := fastpathTV.DecMapFloat32Float32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]float64: + fastpathTV.DecMapFloat32Float64V(v, fastpathCheckNilFalse, false, d) + case *map[float32]float64: + v2, changed2 := fastpathTV.DecMapFloat32Float64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float32]bool: + fastpathTV.DecMapFloat32BoolV(v, fastpathCheckNilFalse, false, d) + case *map[float32]bool: + v2, changed2 := fastpathTV.DecMapFloat32BoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []float64: + fastpathTV.DecSliceFloat64V(v, fastpathCheckNilFalse, false, d) + case *[]float64: + v2, changed2 := fastpathTV.DecSliceFloat64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]interface{}: + fastpathTV.DecMapFloat64IntfV(v, fastpathCheckNilFalse, false, d) + case *map[float64]interface{}: + v2, changed2 := fastpathTV.DecMapFloat64IntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]string: + fastpathTV.DecMapFloat64StringV(v, fastpathCheckNilFalse, false, d) + case *map[float64]string: + v2, changed2 := fastpathTV.DecMapFloat64StringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]uint: + fastpathTV.DecMapFloat64UintV(v, fastpathCheckNilFalse, false, d) + case *map[float64]uint: + v2, changed2 := fastpathTV.DecMapFloat64UintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]uint8: + fastpathTV.DecMapFloat64Uint8V(v, fastpathCheckNilFalse, false, d) + case *map[float64]uint8: + v2, changed2 := fastpathTV.DecMapFloat64Uint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]uint16: + fastpathTV.DecMapFloat64Uint16V(v, fastpathCheckNilFalse, false, d) + case *map[float64]uint16: + v2, changed2 := fastpathTV.DecMapFloat64Uint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]uint32: + fastpathTV.DecMapFloat64Uint32V(v, fastpathCheckNilFalse, false, d) + case *map[float64]uint32: + v2, changed2 := fastpathTV.DecMapFloat64Uint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]uint64: + fastpathTV.DecMapFloat64Uint64V(v, fastpathCheckNilFalse, false, d) + case *map[float64]uint64: + v2, changed2 := fastpathTV.DecMapFloat64Uint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]uintptr: + fastpathTV.DecMapFloat64UintptrV(v, fastpathCheckNilFalse, false, d) + case *map[float64]uintptr: + v2, changed2 := fastpathTV.DecMapFloat64UintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]int: + fastpathTV.DecMapFloat64IntV(v, fastpathCheckNilFalse, false, d) + case *map[float64]int: + v2, changed2 := fastpathTV.DecMapFloat64IntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]int8: + fastpathTV.DecMapFloat64Int8V(v, fastpathCheckNilFalse, false, d) + case *map[float64]int8: + v2, changed2 := fastpathTV.DecMapFloat64Int8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]int16: + fastpathTV.DecMapFloat64Int16V(v, fastpathCheckNilFalse, false, d) + case *map[float64]int16: + v2, changed2 := fastpathTV.DecMapFloat64Int16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]int32: + fastpathTV.DecMapFloat64Int32V(v, fastpathCheckNilFalse, false, d) + case *map[float64]int32: + v2, changed2 := fastpathTV.DecMapFloat64Int32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]int64: + fastpathTV.DecMapFloat64Int64V(v, fastpathCheckNilFalse, false, d) + case *map[float64]int64: + v2, changed2 := fastpathTV.DecMapFloat64Int64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]float32: + fastpathTV.DecMapFloat64Float32V(v, fastpathCheckNilFalse, false, d) + case *map[float64]float32: + v2, changed2 := fastpathTV.DecMapFloat64Float32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]float64: + fastpathTV.DecMapFloat64Float64V(v, fastpathCheckNilFalse, false, d) + case *map[float64]float64: + v2, changed2 := fastpathTV.DecMapFloat64Float64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[float64]bool: + fastpathTV.DecMapFloat64BoolV(v, fastpathCheckNilFalse, false, d) + case *map[float64]bool: + v2, changed2 := fastpathTV.DecMapFloat64BoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []uint: + fastpathTV.DecSliceUintV(v, fastpathCheckNilFalse, false, d) + case *[]uint: + v2, changed2 := fastpathTV.DecSliceUintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]interface{}: + fastpathTV.DecMapUintIntfV(v, fastpathCheckNilFalse, false, d) + case *map[uint]interface{}: + v2, changed2 := fastpathTV.DecMapUintIntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]string: + fastpathTV.DecMapUintStringV(v, fastpathCheckNilFalse, false, d) + case *map[uint]string: + v2, changed2 := fastpathTV.DecMapUintStringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]uint: + fastpathTV.DecMapUintUintV(v, fastpathCheckNilFalse, false, d) + case *map[uint]uint: + v2, changed2 := fastpathTV.DecMapUintUintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]uint8: + fastpathTV.DecMapUintUint8V(v, fastpathCheckNilFalse, false, d) + case *map[uint]uint8: + v2, changed2 := fastpathTV.DecMapUintUint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]uint16: + fastpathTV.DecMapUintUint16V(v, fastpathCheckNilFalse, false, d) + case *map[uint]uint16: + v2, changed2 := fastpathTV.DecMapUintUint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]uint32: + fastpathTV.DecMapUintUint32V(v, fastpathCheckNilFalse, false, d) + case *map[uint]uint32: + v2, changed2 := fastpathTV.DecMapUintUint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]uint64: + fastpathTV.DecMapUintUint64V(v, fastpathCheckNilFalse, false, d) + case *map[uint]uint64: + v2, changed2 := fastpathTV.DecMapUintUint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]uintptr: + fastpathTV.DecMapUintUintptrV(v, fastpathCheckNilFalse, false, d) + case *map[uint]uintptr: + v2, changed2 := fastpathTV.DecMapUintUintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]int: + fastpathTV.DecMapUintIntV(v, fastpathCheckNilFalse, false, d) + case *map[uint]int: + v2, changed2 := fastpathTV.DecMapUintIntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]int8: + fastpathTV.DecMapUintInt8V(v, fastpathCheckNilFalse, false, d) + case *map[uint]int8: + v2, changed2 := fastpathTV.DecMapUintInt8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]int16: + fastpathTV.DecMapUintInt16V(v, fastpathCheckNilFalse, false, d) + case *map[uint]int16: + v2, changed2 := fastpathTV.DecMapUintInt16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]int32: + fastpathTV.DecMapUintInt32V(v, fastpathCheckNilFalse, false, d) + case *map[uint]int32: + v2, changed2 := fastpathTV.DecMapUintInt32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]int64: + fastpathTV.DecMapUintInt64V(v, fastpathCheckNilFalse, false, d) + case *map[uint]int64: + v2, changed2 := fastpathTV.DecMapUintInt64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]float32: + fastpathTV.DecMapUintFloat32V(v, fastpathCheckNilFalse, false, d) + case *map[uint]float32: + v2, changed2 := fastpathTV.DecMapUintFloat32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]float64: + fastpathTV.DecMapUintFloat64V(v, fastpathCheckNilFalse, false, d) + case *map[uint]float64: + v2, changed2 := fastpathTV.DecMapUintFloat64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint]bool: + fastpathTV.DecMapUintBoolV(v, fastpathCheckNilFalse, false, d) + case *map[uint]bool: + v2, changed2 := fastpathTV.DecMapUintBoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]interface{}: + fastpathTV.DecMapUint8IntfV(v, fastpathCheckNilFalse, false, d) + case *map[uint8]interface{}: + v2, changed2 := fastpathTV.DecMapUint8IntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]string: + fastpathTV.DecMapUint8StringV(v, fastpathCheckNilFalse, false, d) + case *map[uint8]string: + v2, changed2 := fastpathTV.DecMapUint8StringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]uint: + fastpathTV.DecMapUint8UintV(v, fastpathCheckNilFalse, false, d) + case *map[uint8]uint: + v2, changed2 := fastpathTV.DecMapUint8UintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]uint8: + fastpathTV.DecMapUint8Uint8V(v, fastpathCheckNilFalse, false, d) + case *map[uint8]uint8: + v2, changed2 := fastpathTV.DecMapUint8Uint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]uint16: + fastpathTV.DecMapUint8Uint16V(v, fastpathCheckNilFalse, false, d) + case *map[uint8]uint16: + v2, changed2 := fastpathTV.DecMapUint8Uint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]uint32: + fastpathTV.DecMapUint8Uint32V(v, fastpathCheckNilFalse, false, d) + case *map[uint8]uint32: + v2, changed2 := fastpathTV.DecMapUint8Uint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]uint64: + fastpathTV.DecMapUint8Uint64V(v, fastpathCheckNilFalse, false, d) + case *map[uint8]uint64: + v2, changed2 := fastpathTV.DecMapUint8Uint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]uintptr: + fastpathTV.DecMapUint8UintptrV(v, fastpathCheckNilFalse, false, d) + case *map[uint8]uintptr: + v2, changed2 := fastpathTV.DecMapUint8UintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]int: + fastpathTV.DecMapUint8IntV(v, fastpathCheckNilFalse, false, d) + case *map[uint8]int: + v2, changed2 := fastpathTV.DecMapUint8IntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]int8: + fastpathTV.DecMapUint8Int8V(v, fastpathCheckNilFalse, false, d) + case *map[uint8]int8: + v2, changed2 := fastpathTV.DecMapUint8Int8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]int16: + fastpathTV.DecMapUint8Int16V(v, fastpathCheckNilFalse, false, d) + case *map[uint8]int16: + v2, changed2 := fastpathTV.DecMapUint8Int16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]int32: + fastpathTV.DecMapUint8Int32V(v, fastpathCheckNilFalse, false, d) + case *map[uint8]int32: + v2, changed2 := fastpathTV.DecMapUint8Int32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]int64: + fastpathTV.DecMapUint8Int64V(v, fastpathCheckNilFalse, false, d) + case *map[uint8]int64: + v2, changed2 := fastpathTV.DecMapUint8Int64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]float32: + fastpathTV.DecMapUint8Float32V(v, fastpathCheckNilFalse, false, d) + case *map[uint8]float32: + v2, changed2 := fastpathTV.DecMapUint8Float32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]float64: + fastpathTV.DecMapUint8Float64V(v, fastpathCheckNilFalse, false, d) + case *map[uint8]float64: + v2, changed2 := fastpathTV.DecMapUint8Float64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint8]bool: + fastpathTV.DecMapUint8BoolV(v, fastpathCheckNilFalse, false, d) + case *map[uint8]bool: + v2, changed2 := fastpathTV.DecMapUint8BoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []uint16: + fastpathTV.DecSliceUint16V(v, fastpathCheckNilFalse, false, d) + case *[]uint16: + v2, changed2 := fastpathTV.DecSliceUint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]interface{}: + fastpathTV.DecMapUint16IntfV(v, fastpathCheckNilFalse, false, d) + case *map[uint16]interface{}: + v2, changed2 := fastpathTV.DecMapUint16IntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]string: + fastpathTV.DecMapUint16StringV(v, fastpathCheckNilFalse, false, d) + case *map[uint16]string: + v2, changed2 := fastpathTV.DecMapUint16StringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]uint: + fastpathTV.DecMapUint16UintV(v, fastpathCheckNilFalse, false, d) + case *map[uint16]uint: + v2, changed2 := fastpathTV.DecMapUint16UintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]uint8: + fastpathTV.DecMapUint16Uint8V(v, fastpathCheckNilFalse, false, d) + case *map[uint16]uint8: + v2, changed2 := fastpathTV.DecMapUint16Uint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]uint16: + fastpathTV.DecMapUint16Uint16V(v, fastpathCheckNilFalse, false, d) + case *map[uint16]uint16: + v2, changed2 := fastpathTV.DecMapUint16Uint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]uint32: + fastpathTV.DecMapUint16Uint32V(v, fastpathCheckNilFalse, false, d) + case *map[uint16]uint32: + v2, changed2 := fastpathTV.DecMapUint16Uint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]uint64: + fastpathTV.DecMapUint16Uint64V(v, fastpathCheckNilFalse, false, d) + case *map[uint16]uint64: + v2, changed2 := fastpathTV.DecMapUint16Uint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]uintptr: + fastpathTV.DecMapUint16UintptrV(v, fastpathCheckNilFalse, false, d) + case *map[uint16]uintptr: + v2, changed2 := fastpathTV.DecMapUint16UintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]int: + fastpathTV.DecMapUint16IntV(v, fastpathCheckNilFalse, false, d) + case *map[uint16]int: + v2, changed2 := fastpathTV.DecMapUint16IntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]int8: + fastpathTV.DecMapUint16Int8V(v, fastpathCheckNilFalse, false, d) + case *map[uint16]int8: + v2, changed2 := fastpathTV.DecMapUint16Int8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]int16: + fastpathTV.DecMapUint16Int16V(v, fastpathCheckNilFalse, false, d) + case *map[uint16]int16: + v2, changed2 := fastpathTV.DecMapUint16Int16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]int32: + fastpathTV.DecMapUint16Int32V(v, fastpathCheckNilFalse, false, d) + case *map[uint16]int32: + v2, changed2 := fastpathTV.DecMapUint16Int32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]int64: + fastpathTV.DecMapUint16Int64V(v, fastpathCheckNilFalse, false, d) + case *map[uint16]int64: + v2, changed2 := fastpathTV.DecMapUint16Int64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]float32: + fastpathTV.DecMapUint16Float32V(v, fastpathCheckNilFalse, false, d) + case *map[uint16]float32: + v2, changed2 := fastpathTV.DecMapUint16Float32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]float64: + fastpathTV.DecMapUint16Float64V(v, fastpathCheckNilFalse, false, d) + case *map[uint16]float64: + v2, changed2 := fastpathTV.DecMapUint16Float64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint16]bool: + fastpathTV.DecMapUint16BoolV(v, fastpathCheckNilFalse, false, d) + case *map[uint16]bool: + v2, changed2 := fastpathTV.DecMapUint16BoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []uint32: + fastpathTV.DecSliceUint32V(v, fastpathCheckNilFalse, false, d) + case *[]uint32: + v2, changed2 := fastpathTV.DecSliceUint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]interface{}: + fastpathTV.DecMapUint32IntfV(v, fastpathCheckNilFalse, false, d) + case *map[uint32]interface{}: + v2, changed2 := fastpathTV.DecMapUint32IntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]string: + fastpathTV.DecMapUint32StringV(v, fastpathCheckNilFalse, false, d) + case *map[uint32]string: + v2, changed2 := fastpathTV.DecMapUint32StringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]uint: + fastpathTV.DecMapUint32UintV(v, fastpathCheckNilFalse, false, d) + case *map[uint32]uint: + v2, changed2 := fastpathTV.DecMapUint32UintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]uint8: + fastpathTV.DecMapUint32Uint8V(v, fastpathCheckNilFalse, false, d) + case *map[uint32]uint8: + v2, changed2 := fastpathTV.DecMapUint32Uint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]uint16: + fastpathTV.DecMapUint32Uint16V(v, fastpathCheckNilFalse, false, d) + case *map[uint32]uint16: + v2, changed2 := fastpathTV.DecMapUint32Uint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]uint32: + fastpathTV.DecMapUint32Uint32V(v, fastpathCheckNilFalse, false, d) + case *map[uint32]uint32: + v2, changed2 := fastpathTV.DecMapUint32Uint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]uint64: + fastpathTV.DecMapUint32Uint64V(v, fastpathCheckNilFalse, false, d) + case *map[uint32]uint64: + v2, changed2 := fastpathTV.DecMapUint32Uint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]uintptr: + fastpathTV.DecMapUint32UintptrV(v, fastpathCheckNilFalse, false, d) + case *map[uint32]uintptr: + v2, changed2 := fastpathTV.DecMapUint32UintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]int: + fastpathTV.DecMapUint32IntV(v, fastpathCheckNilFalse, false, d) + case *map[uint32]int: + v2, changed2 := fastpathTV.DecMapUint32IntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]int8: + fastpathTV.DecMapUint32Int8V(v, fastpathCheckNilFalse, false, d) + case *map[uint32]int8: + v2, changed2 := fastpathTV.DecMapUint32Int8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]int16: + fastpathTV.DecMapUint32Int16V(v, fastpathCheckNilFalse, false, d) + case *map[uint32]int16: + v2, changed2 := fastpathTV.DecMapUint32Int16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]int32: + fastpathTV.DecMapUint32Int32V(v, fastpathCheckNilFalse, false, d) + case *map[uint32]int32: + v2, changed2 := fastpathTV.DecMapUint32Int32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]int64: + fastpathTV.DecMapUint32Int64V(v, fastpathCheckNilFalse, false, d) + case *map[uint32]int64: + v2, changed2 := fastpathTV.DecMapUint32Int64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]float32: + fastpathTV.DecMapUint32Float32V(v, fastpathCheckNilFalse, false, d) + case *map[uint32]float32: + v2, changed2 := fastpathTV.DecMapUint32Float32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]float64: + fastpathTV.DecMapUint32Float64V(v, fastpathCheckNilFalse, false, d) + case *map[uint32]float64: + v2, changed2 := fastpathTV.DecMapUint32Float64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint32]bool: + fastpathTV.DecMapUint32BoolV(v, fastpathCheckNilFalse, false, d) + case *map[uint32]bool: + v2, changed2 := fastpathTV.DecMapUint32BoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []uint64: + fastpathTV.DecSliceUint64V(v, fastpathCheckNilFalse, false, d) + case *[]uint64: + v2, changed2 := fastpathTV.DecSliceUint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]interface{}: + fastpathTV.DecMapUint64IntfV(v, fastpathCheckNilFalse, false, d) + case *map[uint64]interface{}: + v2, changed2 := fastpathTV.DecMapUint64IntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]string: + fastpathTV.DecMapUint64StringV(v, fastpathCheckNilFalse, false, d) + case *map[uint64]string: + v2, changed2 := fastpathTV.DecMapUint64StringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]uint: + fastpathTV.DecMapUint64UintV(v, fastpathCheckNilFalse, false, d) + case *map[uint64]uint: + v2, changed2 := fastpathTV.DecMapUint64UintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]uint8: + fastpathTV.DecMapUint64Uint8V(v, fastpathCheckNilFalse, false, d) + case *map[uint64]uint8: + v2, changed2 := fastpathTV.DecMapUint64Uint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]uint16: + fastpathTV.DecMapUint64Uint16V(v, fastpathCheckNilFalse, false, d) + case *map[uint64]uint16: + v2, changed2 := fastpathTV.DecMapUint64Uint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]uint32: + fastpathTV.DecMapUint64Uint32V(v, fastpathCheckNilFalse, false, d) + case *map[uint64]uint32: + v2, changed2 := fastpathTV.DecMapUint64Uint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]uint64: + fastpathTV.DecMapUint64Uint64V(v, fastpathCheckNilFalse, false, d) + case *map[uint64]uint64: + v2, changed2 := fastpathTV.DecMapUint64Uint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]uintptr: + fastpathTV.DecMapUint64UintptrV(v, fastpathCheckNilFalse, false, d) + case *map[uint64]uintptr: + v2, changed2 := fastpathTV.DecMapUint64UintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]int: + fastpathTV.DecMapUint64IntV(v, fastpathCheckNilFalse, false, d) + case *map[uint64]int: + v2, changed2 := fastpathTV.DecMapUint64IntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]int8: + fastpathTV.DecMapUint64Int8V(v, fastpathCheckNilFalse, false, d) + case *map[uint64]int8: + v2, changed2 := fastpathTV.DecMapUint64Int8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]int16: + fastpathTV.DecMapUint64Int16V(v, fastpathCheckNilFalse, false, d) + case *map[uint64]int16: + v2, changed2 := fastpathTV.DecMapUint64Int16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]int32: + fastpathTV.DecMapUint64Int32V(v, fastpathCheckNilFalse, false, d) + case *map[uint64]int32: + v2, changed2 := fastpathTV.DecMapUint64Int32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]int64: + fastpathTV.DecMapUint64Int64V(v, fastpathCheckNilFalse, false, d) + case *map[uint64]int64: + v2, changed2 := fastpathTV.DecMapUint64Int64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]float32: + fastpathTV.DecMapUint64Float32V(v, fastpathCheckNilFalse, false, d) + case *map[uint64]float32: + v2, changed2 := fastpathTV.DecMapUint64Float32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]float64: + fastpathTV.DecMapUint64Float64V(v, fastpathCheckNilFalse, false, d) + case *map[uint64]float64: + v2, changed2 := fastpathTV.DecMapUint64Float64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uint64]bool: + fastpathTV.DecMapUint64BoolV(v, fastpathCheckNilFalse, false, d) + case *map[uint64]bool: + v2, changed2 := fastpathTV.DecMapUint64BoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []uintptr: + fastpathTV.DecSliceUintptrV(v, fastpathCheckNilFalse, false, d) + case *[]uintptr: + v2, changed2 := fastpathTV.DecSliceUintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]interface{}: + fastpathTV.DecMapUintptrIntfV(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]interface{}: + v2, changed2 := fastpathTV.DecMapUintptrIntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]string: + fastpathTV.DecMapUintptrStringV(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]string: + v2, changed2 := fastpathTV.DecMapUintptrStringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]uint: + fastpathTV.DecMapUintptrUintV(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]uint: + v2, changed2 := fastpathTV.DecMapUintptrUintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]uint8: + fastpathTV.DecMapUintptrUint8V(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]uint8: + v2, changed2 := fastpathTV.DecMapUintptrUint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]uint16: + fastpathTV.DecMapUintptrUint16V(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]uint16: + v2, changed2 := fastpathTV.DecMapUintptrUint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]uint32: + fastpathTV.DecMapUintptrUint32V(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]uint32: + v2, changed2 := fastpathTV.DecMapUintptrUint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]uint64: + fastpathTV.DecMapUintptrUint64V(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]uint64: + v2, changed2 := fastpathTV.DecMapUintptrUint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]uintptr: + fastpathTV.DecMapUintptrUintptrV(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]uintptr: + v2, changed2 := fastpathTV.DecMapUintptrUintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]int: + fastpathTV.DecMapUintptrIntV(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]int: + v2, changed2 := fastpathTV.DecMapUintptrIntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]int8: + fastpathTV.DecMapUintptrInt8V(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]int8: + v2, changed2 := fastpathTV.DecMapUintptrInt8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]int16: + fastpathTV.DecMapUintptrInt16V(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]int16: + v2, changed2 := fastpathTV.DecMapUintptrInt16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]int32: + fastpathTV.DecMapUintptrInt32V(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]int32: + v2, changed2 := fastpathTV.DecMapUintptrInt32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]int64: + fastpathTV.DecMapUintptrInt64V(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]int64: + v2, changed2 := fastpathTV.DecMapUintptrInt64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]float32: + fastpathTV.DecMapUintptrFloat32V(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]float32: + v2, changed2 := fastpathTV.DecMapUintptrFloat32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]float64: + fastpathTV.DecMapUintptrFloat64V(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]float64: + v2, changed2 := fastpathTV.DecMapUintptrFloat64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[uintptr]bool: + fastpathTV.DecMapUintptrBoolV(v, fastpathCheckNilFalse, false, d) + case *map[uintptr]bool: + v2, changed2 := fastpathTV.DecMapUintptrBoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []int: + fastpathTV.DecSliceIntV(v, fastpathCheckNilFalse, false, d) + case *[]int: + v2, changed2 := fastpathTV.DecSliceIntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]interface{}: + fastpathTV.DecMapIntIntfV(v, fastpathCheckNilFalse, false, d) + case *map[int]interface{}: + v2, changed2 := fastpathTV.DecMapIntIntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]string: + fastpathTV.DecMapIntStringV(v, fastpathCheckNilFalse, false, d) + case *map[int]string: + v2, changed2 := fastpathTV.DecMapIntStringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]uint: + fastpathTV.DecMapIntUintV(v, fastpathCheckNilFalse, false, d) + case *map[int]uint: + v2, changed2 := fastpathTV.DecMapIntUintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]uint8: + fastpathTV.DecMapIntUint8V(v, fastpathCheckNilFalse, false, d) + case *map[int]uint8: + v2, changed2 := fastpathTV.DecMapIntUint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]uint16: + fastpathTV.DecMapIntUint16V(v, fastpathCheckNilFalse, false, d) + case *map[int]uint16: + v2, changed2 := fastpathTV.DecMapIntUint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]uint32: + fastpathTV.DecMapIntUint32V(v, fastpathCheckNilFalse, false, d) + case *map[int]uint32: + v2, changed2 := fastpathTV.DecMapIntUint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]uint64: + fastpathTV.DecMapIntUint64V(v, fastpathCheckNilFalse, false, d) + case *map[int]uint64: + v2, changed2 := fastpathTV.DecMapIntUint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]uintptr: + fastpathTV.DecMapIntUintptrV(v, fastpathCheckNilFalse, false, d) + case *map[int]uintptr: + v2, changed2 := fastpathTV.DecMapIntUintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]int: + fastpathTV.DecMapIntIntV(v, fastpathCheckNilFalse, false, d) + case *map[int]int: + v2, changed2 := fastpathTV.DecMapIntIntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]int8: + fastpathTV.DecMapIntInt8V(v, fastpathCheckNilFalse, false, d) + case *map[int]int8: + v2, changed2 := fastpathTV.DecMapIntInt8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]int16: + fastpathTV.DecMapIntInt16V(v, fastpathCheckNilFalse, false, d) + case *map[int]int16: + v2, changed2 := fastpathTV.DecMapIntInt16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]int32: + fastpathTV.DecMapIntInt32V(v, fastpathCheckNilFalse, false, d) + case *map[int]int32: + v2, changed2 := fastpathTV.DecMapIntInt32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]int64: + fastpathTV.DecMapIntInt64V(v, fastpathCheckNilFalse, false, d) + case *map[int]int64: + v2, changed2 := fastpathTV.DecMapIntInt64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]float32: + fastpathTV.DecMapIntFloat32V(v, fastpathCheckNilFalse, false, d) + case *map[int]float32: + v2, changed2 := fastpathTV.DecMapIntFloat32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]float64: + fastpathTV.DecMapIntFloat64V(v, fastpathCheckNilFalse, false, d) + case *map[int]float64: + v2, changed2 := fastpathTV.DecMapIntFloat64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int]bool: + fastpathTV.DecMapIntBoolV(v, fastpathCheckNilFalse, false, d) + case *map[int]bool: + v2, changed2 := fastpathTV.DecMapIntBoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []int8: + fastpathTV.DecSliceInt8V(v, fastpathCheckNilFalse, false, d) + case *[]int8: + v2, changed2 := fastpathTV.DecSliceInt8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]interface{}: + fastpathTV.DecMapInt8IntfV(v, fastpathCheckNilFalse, false, d) + case *map[int8]interface{}: + v2, changed2 := fastpathTV.DecMapInt8IntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]string: + fastpathTV.DecMapInt8StringV(v, fastpathCheckNilFalse, false, d) + case *map[int8]string: + v2, changed2 := fastpathTV.DecMapInt8StringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]uint: + fastpathTV.DecMapInt8UintV(v, fastpathCheckNilFalse, false, d) + case *map[int8]uint: + v2, changed2 := fastpathTV.DecMapInt8UintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]uint8: + fastpathTV.DecMapInt8Uint8V(v, fastpathCheckNilFalse, false, d) + case *map[int8]uint8: + v2, changed2 := fastpathTV.DecMapInt8Uint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]uint16: + fastpathTV.DecMapInt8Uint16V(v, fastpathCheckNilFalse, false, d) + case *map[int8]uint16: + v2, changed2 := fastpathTV.DecMapInt8Uint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]uint32: + fastpathTV.DecMapInt8Uint32V(v, fastpathCheckNilFalse, false, d) + case *map[int8]uint32: + v2, changed2 := fastpathTV.DecMapInt8Uint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]uint64: + fastpathTV.DecMapInt8Uint64V(v, fastpathCheckNilFalse, false, d) + case *map[int8]uint64: + v2, changed2 := fastpathTV.DecMapInt8Uint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]uintptr: + fastpathTV.DecMapInt8UintptrV(v, fastpathCheckNilFalse, false, d) + case *map[int8]uintptr: + v2, changed2 := fastpathTV.DecMapInt8UintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]int: + fastpathTV.DecMapInt8IntV(v, fastpathCheckNilFalse, false, d) + case *map[int8]int: + v2, changed2 := fastpathTV.DecMapInt8IntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]int8: + fastpathTV.DecMapInt8Int8V(v, fastpathCheckNilFalse, false, d) + case *map[int8]int8: + v2, changed2 := fastpathTV.DecMapInt8Int8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]int16: + fastpathTV.DecMapInt8Int16V(v, fastpathCheckNilFalse, false, d) + case *map[int8]int16: + v2, changed2 := fastpathTV.DecMapInt8Int16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]int32: + fastpathTV.DecMapInt8Int32V(v, fastpathCheckNilFalse, false, d) + case *map[int8]int32: + v2, changed2 := fastpathTV.DecMapInt8Int32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]int64: + fastpathTV.DecMapInt8Int64V(v, fastpathCheckNilFalse, false, d) + case *map[int8]int64: + v2, changed2 := fastpathTV.DecMapInt8Int64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]float32: + fastpathTV.DecMapInt8Float32V(v, fastpathCheckNilFalse, false, d) + case *map[int8]float32: + v2, changed2 := fastpathTV.DecMapInt8Float32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]float64: + fastpathTV.DecMapInt8Float64V(v, fastpathCheckNilFalse, false, d) + case *map[int8]float64: + v2, changed2 := fastpathTV.DecMapInt8Float64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int8]bool: + fastpathTV.DecMapInt8BoolV(v, fastpathCheckNilFalse, false, d) + case *map[int8]bool: + v2, changed2 := fastpathTV.DecMapInt8BoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []int16: + fastpathTV.DecSliceInt16V(v, fastpathCheckNilFalse, false, d) + case *[]int16: + v2, changed2 := fastpathTV.DecSliceInt16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]interface{}: + fastpathTV.DecMapInt16IntfV(v, fastpathCheckNilFalse, false, d) + case *map[int16]interface{}: + v2, changed2 := fastpathTV.DecMapInt16IntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]string: + fastpathTV.DecMapInt16StringV(v, fastpathCheckNilFalse, false, d) + case *map[int16]string: + v2, changed2 := fastpathTV.DecMapInt16StringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]uint: + fastpathTV.DecMapInt16UintV(v, fastpathCheckNilFalse, false, d) + case *map[int16]uint: + v2, changed2 := fastpathTV.DecMapInt16UintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]uint8: + fastpathTV.DecMapInt16Uint8V(v, fastpathCheckNilFalse, false, d) + case *map[int16]uint8: + v2, changed2 := fastpathTV.DecMapInt16Uint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]uint16: + fastpathTV.DecMapInt16Uint16V(v, fastpathCheckNilFalse, false, d) + case *map[int16]uint16: + v2, changed2 := fastpathTV.DecMapInt16Uint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]uint32: + fastpathTV.DecMapInt16Uint32V(v, fastpathCheckNilFalse, false, d) + case *map[int16]uint32: + v2, changed2 := fastpathTV.DecMapInt16Uint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]uint64: + fastpathTV.DecMapInt16Uint64V(v, fastpathCheckNilFalse, false, d) + case *map[int16]uint64: + v2, changed2 := fastpathTV.DecMapInt16Uint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]uintptr: + fastpathTV.DecMapInt16UintptrV(v, fastpathCheckNilFalse, false, d) + case *map[int16]uintptr: + v2, changed2 := fastpathTV.DecMapInt16UintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]int: + fastpathTV.DecMapInt16IntV(v, fastpathCheckNilFalse, false, d) + case *map[int16]int: + v2, changed2 := fastpathTV.DecMapInt16IntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]int8: + fastpathTV.DecMapInt16Int8V(v, fastpathCheckNilFalse, false, d) + case *map[int16]int8: + v2, changed2 := fastpathTV.DecMapInt16Int8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]int16: + fastpathTV.DecMapInt16Int16V(v, fastpathCheckNilFalse, false, d) + case *map[int16]int16: + v2, changed2 := fastpathTV.DecMapInt16Int16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]int32: + fastpathTV.DecMapInt16Int32V(v, fastpathCheckNilFalse, false, d) + case *map[int16]int32: + v2, changed2 := fastpathTV.DecMapInt16Int32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]int64: + fastpathTV.DecMapInt16Int64V(v, fastpathCheckNilFalse, false, d) + case *map[int16]int64: + v2, changed2 := fastpathTV.DecMapInt16Int64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]float32: + fastpathTV.DecMapInt16Float32V(v, fastpathCheckNilFalse, false, d) + case *map[int16]float32: + v2, changed2 := fastpathTV.DecMapInt16Float32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]float64: + fastpathTV.DecMapInt16Float64V(v, fastpathCheckNilFalse, false, d) + case *map[int16]float64: + v2, changed2 := fastpathTV.DecMapInt16Float64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int16]bool: + fastpathTV.DecMapInt16BoolV(v, fastpathCheckNilFalse, false, d) + case *map[int16]bool: + v2, changed2 := fastpathTV.DecMapInt16BoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []int32: + fastpathTV.DecSliceInt32V(v, fastpathCheckNilFalse, false, d) + case *[]int32: + v2, changed2 := fastpathTV.DecSliceInt32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]interface{}: + fastpathTV.DecMapInt32IntfV(v, fastpathCheckNilFalse, false, d) + case *map[int32]interface{}: + v2, changed2 := fastpathTV.DecMapInt32IntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]string: + fastpathTV.DecMapInt32StringV(v, fastpathCheckNilFalse, false, d) + case *map[int32]string: + v2, changed2 := fastpathTV.DecMapInt32StringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]uint: + fastpathTV.DecMapInt32UintV(v, fastpathCheckNilFalse, false, d) + case *map[int32]uint: + v2, changed2 := fastpathTV.DecMapInt32UintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]uint8: + fastpathTV.DecMapInt32Uint8V(v, fastpathCheckNilFalse, false, d) + case *map[int32]uint8: + v2, changed2 := fastpathTV.DecMapInt32Uint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]uint16: + fastpathTV.DecMapInt32Uint16V(v, fastpathCheckNilFalse, false, d) + case *map[int32]uint16: + v2, changed2 := fastpathTV.DecMapInt32Uint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]uint32: + fastpathTV.DecMapInt32Uint32V(v, fastpathCheckNilFalse, false, d) + case *map[int32]uint32: + v2, changed2 := fastpathTV.DecMapInt32Uint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]uint64: + fastpathTV.DecMapInt32Uint64V(v, fastpathCheckNilFalse, false, d) + case *map[int32]uint64: + v2, changed2 := fastpathTV.DecMapInt32Uint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]uintptr: + fastpathTV.DecMapInt32UintptrV(v, fastpathCheckNilFalse, false, d) + case *map[int32]uintptr: + v2, changed2 := fastpathTV.DecMapInt32UintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]int: + fastpathTV.DecMapInt32IntV(v, fastpathCheckNilFalse, false, d) + case *map[int32]int: + v2, changed2 := fastpathTV.DecMapInt32IntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]int8: + fastpathTV.DecMapInt32Int8V(v, fastpathCheckNilFalse, false, d) + case *map[int32]int8: + v2, changed2 := fastpathTV.DecMapInt32Int8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]int16: + fastpathTV.DecMapInt32Int16V(v, fastpathCheckNilFalse, false, d) + case *map[int32]int16: + v2, changed2 := fastpathTV.DecMapInt32Int16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]int32: + fastpathTV.DecMapInt32Int32V(v, fastpathCheckNilFalse, false, d) + case *map[int32]int32: + v2, changed2 := fastpathTV.DecMapInt32Int32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]int64: + fastpathTV.DecMapInt32Int64V(v, fastpathCheckNilFalse, false, d) + case *map[int32]int64: + v2, changed2 := fastpathTV.DecMapInt32Int64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]float32: + fastpathTV.DecMapInt32Float32V(v, fastpathCheckNilFalse, false, d) + case *map[int32]float32: + v2, changed2 := fastpathTV.DecMapInt32Float32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]float64: + fastpathTV.DecMapInt32Float64V(v, fastpathCheckNilFalse, false, d) + case *map[int32]float64: + v2, changed2 := fastpathTV.DecMapInt32Float64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int32]bool: + fastpathTV.DecMapInt32BoolV(v, fastpathCheckNilFalse, false, d) + case *map[int32]bool: + v2, changed2 := fastpathTV.DecMapInt32BoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []int64: + fastpathTV.DecSliceInt64V(v, fastpathCheckNilFalse, false, d) + case *[]int64: + v2, changed2 := fastpathTV.DecSliceInt64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]interface{}: + fastpathTV.DecMapInt64IntfV(v, fastpathCheckNilFalse, false, d) + case *map[int64]interface{}: + v2, changed2 := fastpathTV.DecMapInt64IntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]string: + fastpathTV.DecMapInt64StringV(v, fastpathCheckNilFalse, false, d) + case *map[int64]string: + v2, changed2 := fastpathTV.DecMapInt64StringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]uint: + fastpathTV.DecMapInt64UintV(v, fastpathCheckNilFalse, false, d) + case *map[int64]uint: + v2, changed2 := fastpathTV.DecMapInt64UintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]uint8: + fastpathTV.DecMapInt64Uint8V(v, fastpathCheckNilFalse, false, d) + case *map[int64]uint8: + v2, changed2 := fastpathTV.DecMapInt64Uint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]uint16: + fastpathTV.DecMapInt64Uint16V(v, fastpathCheckNilFalse, false, d) + case *map[int64]uint16: + v2, changed2 := fastpathTV.DecMapInt64Uint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]uint32: + fastpathTV.DecMapInt64Uint32V(v, fastpathCheckNilFalse, false, d) + case *map[int64]uint32: + v2, changed2 := fastpathTV.DecMapInt64Uint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]uint64: + fastpathTV.DecMapInt64Uint64V(v, fastpathCheckNilFalse, false, d) + case *map[int64]uint64: + v2, changed2 := fastpathTV.DecMapInt64Uint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]uintptr: + fastpathTV.DecMapInt64UintptrV(v, fastpathCheckNilFalse, false, d) + case *map[int64]uintptr: + v2, changed2 := fastpathTV.DecMapInt64UintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]int: + fastpathTV.DecMapInt64IntV(v, fastpathCheckNilFalse, false, d) + case *map[int64]int: + v2, changed2 := fastpathTV.DecMapInt64IntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]int8: + fastpathTV.DecMapInt64Int8V(v, fastpathCheckNilFalse, false, d) + case *map[int64]int8: + v2, changed2 := fastpathTV.DecMapInt64Int8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]int16: + fastpathTV.DecMapInt64Int16V(v, fastpathCheckNilFalse, false, d) + case *map[int64]int16: + v2, changed2 := fastpathTV.DecMapInt64Int16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]int32: + fastpathTV.DecMapInt64Int32V(v, fastpathCheckNilFalse, false, d) + case *map[int64]int32: + v2, changed2 := fastpathTV.DecMapInt64Int32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]int64: + fastpathTV.DecMapInt64Int64V(v, fastpathCheckNilFalse, false, d) + case *map[int64]int64: + v2, changed2 := fastpathTV.DecMapInt64Int64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]float32: + fastpathTV.DecMapInt64Float32V(v, fastpathCheckNilFalse, false, d) + case *map[int64]float32: + v2, changed2 := fastpathTV.DecMapInt64Float32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]float64: + fastpathTV.DecMapInt64Float64V(v, fastpathCheckNilFalse, false, d) + case *map[int64]float64: + v2, changed2 := fastpathTV.DecMapInt64Float64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[int64]bool: + fastpathTV.DecMapInt64BoolV(v, fastpathCheckNilFalse, false, d) + case *map[int64]bool: + v2, changed2 := fastpathTV.DecMapInt64BoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case []bool: + fastpathTV.DecSliceBoolV(v, fastpathCheckNilFalse, false, d) + case *[]bool: + v2, changed2 := fastpathTV.DecSliceBoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]interface{}: + fastpathTV.DecMapBoolIntfV(v, fastpathCheckNilFalse, false, d) + case *map[bool]interface{}: + v2, changed2 := fastpathTV.DecMapBoolIntfV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]string: + fastpathTV.DecMapBoolStringV(v, fastpathCheckNilFalse, false, d) + case *map[bool]string: + v2, changed2 := fastpathTV.DecMapBoolStringV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]uint: + fastpathTV.DecMapBoolUintV(v, fastpathCheckNilFalse, false, d) + case *map[bool]uint: + v2, changed2 := fastpathTV.DecMapBoolUintV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]uint8: + fastpathTV.DecMapBoolUint8V(v, fastpathCheckNilFalse, false, d) + case *map[bool]uint8: + v2, changed2 := fastpathTV.DecMapBoolUint8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]uint16: + fastpathTV.DecMapBoolUint16V(v, fastpathCheckNilFalse, false, d) + case *map[bool]uint16: + v2, changed2 := fastpathTV.DecMapBoolUint16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]uint32: + fastpathTV.DecMapBoolUint32V(v, fastpathCheckNilFalse, false, d) + case *map[bool]uint32: + v2, changed2 := fastpathTV.DecMapBoolUint32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]uint64: + fastpathTV.DecMapBoolUint64V(v, fastpathCheckNilFalse, false, d) + case *map[bool]uint64: + v2, changed2 := fastpathTV.DecMapBoolUint64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]uintptr: + fastpathTV.DecMapBoolUintptrV(v, fastpathCheckNilFalse, false, d) + case *map[bool]uintptr: + v2, changed2 := fastpathTV.DecMapBoolUintptrV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]int: + fastpathTV.DecMapBoolIntV(v, fastpathCheckNilFalse, false, d) + case *map[bool]int: + v2, changed2 := fastpathTV.DecMapBoolIntV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]int8: + fastpathTV.DecMapBoolInt8V(v, fastpathCheckNilFalse, false, d) + case *map[bool]int8: + v2, changed2 := fastpathTV.DecMapBoolInt8V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]int16: + fastpathTV.DecMapBoolInt16V(v, fastpathCheckNilFalse, false, d) + case *map[bool]int16: + v2, changed2 := fastpathTV.DecMapBoolInt16V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]int32: + fastpathTV.DecMapBoolInt32V(v, fastpathCheckNilFalse, false, d) + case *map[bool]int32: + v2, changed2 := fastpathTV.DecMapBoolInt32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]int64: + fastpathTV.DecMapBoolInt64V(v, fastpathCheckNilFalse, false, d) + case *map[bool]int64: + v2, changed2 := fastpathTV.DecMapBoolInt64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]float32: + fastpathTV.DecMapBoolFloat32V(v, fastpathCheckNilFalse, false, d) + case *map[bool]float32: + v2, changed2 := fastpathTV.DecMapBoolFloat32V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]float64: + fastpathTV.DecMapBoolFloat64V(v, fastpathCheckNilFalse, false, d) + case *map[bool]float64: + v2, changed2 := fastpathTV.DecMapBoolFloat64V(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + case map[bool]bool: + fastpathTV.DecMapBoolBoolV(v, fastpathCheckNilFalse, false, d) + case *map[bool]bool: + v2, changed2 := fastpathTV.DecMapBoolBoolV(*v, fastpathCheckNilFalse, true, d) + if changed2 { + *v = v2 + } + + default: + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) + return false + } + return true +} + +// -- -- fast path functions + +func (f *decFnInfo) fastpathDecSliceIntfR(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]interface{}) + v, changed := fastpathTV.DecSliceIntfV(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]interface{}) + fastpathTV.DecSliceIntfV(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceIntfX(vp *[]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecSliceIntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool, d *Decoder) (_ []interface{}, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []interface{}{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 16) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]interface{}, xlen) + } + } else { + v = make([]interface{}, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + d.decode(&v[j]) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, nil) + slh.ElemContainerState(j) + d.decode(&v[j]) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []interface{}{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]interface{}, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, nil) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + d.decode(&v[j]) + + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceStringR(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]string) + v, changed := fastpathTV.DecSliceStringV(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]string) + fastpathTV.DecSliceStringV(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceStringX(vp *[]string, checkNil bool, d *Decoder) { + v, changed := f.DecSliceStringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d *Decoder) (_ []string, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []string{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 16) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]string, xlen) + } + } else { + v = make([]string, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = dd.DecodeString() + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, "") + slh.ElemContainerState(j) + v[j] = dd.DecodeString() + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []string{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]string, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, "") + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = dd.DecodeString() + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceFloat32R(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]float32) + v, changed := fastpathTV.DecSliceFloat32V(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]float32) + fastpathTV.DecSliceFloat32V(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceFloat32X(vp *[]float32, checkNil bool, d *Decoder) { + v, changed := f.DecSliceFloat32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool, d *Decoder) (_ []float32, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []float32{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]float32, xlen) + } + } else { + v = make([]float32, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = float32(dd.DecodeFloat(true)) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = float32(dd.DecodeFloat(true)) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []float32{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]float32, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = float32(dd.DecodeFloat(true)) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceFloat64R(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]float64) + v, changed := fastpathTV.DecSliceFloat64V(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]float64) + fastpathTV.DecSliceFloat64V(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceFloat64X(vp *[]float64, checkNil bool, d *Decoder) { + v, changed := f.DecSliceFloat64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool, d *Decoder) (_ []float64, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []float64{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]float64, xlen) + } + } else { + v = make([]float64, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = dd.DecodeFloat(false) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = dd.DecodeFloat(false) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []float64{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]float64, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = dd.DecodeFloat(false) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceUintR(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]uint) + v, changed := fastpathTV.DecSliceUintV(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]uint) + fastpathTV.DecSliceUintV(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceUintX(vp *[]uint, checkNil bool, d *Decoder) { + v, changed := f.DecSliceUintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d *Decoder) (_ []uint, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []uint{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]uint, xlen) + } + } else { + v = make([]uint, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = uint(dd.DecodeUint(uintBitsize)) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = uint(dd.DecodeUint(uintBitsize)) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []uint{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]uint, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = uint(dd.DecodeUint(uintBitsize)) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceUint16R(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]uint16) + v, changed := fastpathTV.DecSliceUint16V(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]uint16) + fastpathTV.DecSliceUint16V(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceUint16X(vp *[]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecSliceUint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d *Decoder) (_ []uint16, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []uint16{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 2) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]uint16, xlen) + } + } else { + v = make([]uint16, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = uint16(dd.DecodeUint(16)) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = uint16(dd.DecodeUint(16)) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []uint16{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]uint16, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = uint16(dd.DecodeUint(16)) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceUint32R(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]uint32) + v, changed := fastpathTV.DecSliceUint32V(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]uint32) + fastpathTV.DecSliceUint32V(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceUint32X(vp *[]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecSliceUint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d *Decoder) (_ []uint32, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []uint32{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]uint32, xlen) + } + } else { + v = make([]uint32, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = uint32(dd.DecodeUint(32)) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = uint32(dd.DecodeUint(32)) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []uint32{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]uint32, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = uint32(dd.DecodeUint(32)) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceUint64R(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]uint64) + v, changed := fastpathTV.DecSliceUint64V(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]uint64) + fastpathTV.DecSliceUint64V(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceUint64X(vp *[]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecSliceUint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d *Decoder) (_ []uint64, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []uint64{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]uint64, xlen) + } + } else { + v = make([]uint64, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = dd.DecodeUint(64) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = dd.DecodeUint(64) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []uint64{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]uint64, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = dd.DecodeUint(64) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceUintptrR(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]uintptr) + v, changed := fastpathTV.DecSliceUintptrV(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]uintptr) + fastpathTV.DecSliceUintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecSliceUintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool, d *Decoder) (_ []uintptr, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []uintptr{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]uintptr, xlen) + } + } else { + v = make([]uintptr, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = uintptr(dd.DecodeUint(uintBitsize)) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = uintptr(dd.DecodeUint(uintBitsize)) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []uintptr{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]uintptr, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = uintptr(dd.DecodeUint(uintBitsize)) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceIntR(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]int) + v, changed := fastpathTV.DecSliceIntV(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]int) + fastpathTV.DecSliceIntV(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceIntX(vp *[]int, checkNil bool, d *Decoder) { + v, changed := f.DecSliceIntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d *Decoder) (_ []int, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []int{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]int, xlen) + } + } else { + v = make([]int, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = int(dd.DecodeInt(intBitsize)) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = int(dd.DecodeInt(intBitsize)) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []int{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]int, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = int(dd.DecodeInt(intBitsize)) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceInt8R(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]int8) + v, changed := fastpathTV.DecSliceInt8V(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]int8) + fastpathTV.DecSliceInt8V(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceInt8X(vp *[]int8, checkNil bool, d *Decoder) { + v, changed := f.DecSliceInt8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d *Decoder) (_ []int8, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []int8{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 1) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]int8, xlen) + } + } else { + v = make([]int8, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = int8(dd.DecodeInt(8)) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = int8(dd.DecodeInt(8)) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []int8{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]int8, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = int8(dd.DecodeInt(8)) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceInt16R(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]int16) + v, changed := fastpathTV.DecSliceInt16V(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]int16) + fastpathTV.DecSliceInt16V(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceInt16X(vp *[]int16, checkNil bool, d *Decoder) { + v, changed := f.DecSliceInt16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d *Decoder) (_ []int16, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []int16{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 2) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]int16, xlen) + } + } else { + v = make([]int16, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = int16(dd.DecodeInt(16)) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = int16(dd.DecodeInt(16)) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []int16{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]int16, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = int16(dd.DecodeInt(16)) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceInt32R(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]int32) + v, changed := fastpathTV.DecSliceInt32V(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]int32) + fastpathTV.DecSliceInt32V(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceInt32X(vp *[]int32, checkNil bool, d *Decoder) { + v, changed := f.DecSliceInt32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d *Decoder) (_ []int32, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []int32{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]int32, xlen) + } + } else { + v = make([]int32, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = int32(dd.DecodeInt(32)) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = int32(dd.DecodeInt(32)) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []int32{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]int32, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = int32(dd.DecodeInt(32)) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceInt64R(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]int64) + v, changed := fastpathTV.DecSliceInt64V(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]int64) + fastpathTV.DecSliceInt64V(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceInt64X(vp *[]int64, checkNil bool, d *Decoder) { + v, changed := f.DecSliceInt64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d *Decoder) (_ []int64, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []int64{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]int64, xlen) + } + } else { + v = make([]int64, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = dd.DecodeInt(64) + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, 0) + slh.ElemContainerState(j) + v[j] = dd.DecodeInt(64) + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []int64{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]int64, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, 0) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = dd.DecodeInt(64) + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecSliceBoolR(rv reflect.Value) { + array := f.seq == seqTypeArray + if !array && rv.CanAddr() { + vp := rv.Addr().Interface().(*[]bool) + v, changed := fastpathTV.DecSliceBoolV(*vp, fastpathCheckNilFalse, !array, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().([]bool) + fastpathTV.DecSliceBoolV(v, fastpathCheckNilFalse, false, f.d) + } +} + +func (f fastpathT) DecSliceBoolX(vp *[]bool, checkNil bool, d *Decoder) { + v, changed := f.DecSliceBoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d *Decoder) (_ []bool, changed bool) { + dd := d.d + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + slh, containerLenS := d.decSliceHelperStart() + if containerLenS == 0 { + if canChange { + if v == nil { + v = []bool{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + + if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool + if containerLenS > cap(v) { + if canChange { + var xlen int + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 1) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]bool, xlen) + } + } else { + v = make([]bool, xlen) + } + changed = true + } else { + d.arrayCannotExpand(len(v), containerLenS) + } + x2read = len(v) + } else if containerLenS != len(v) { + if canChange { + v = v[:containerLenS] + changed = true + } + } + j := 0 + for ; j < x2read; j++ { + slh.ElemContainerState(j) + v[j] = dd.DecodeBool() + } + if xtrunc { + for ; j < containerLenS; j++ { + v = append(v, false) + slh.ElemContainerState(j) + v[j] = dd.DecodeBool() + } + } else if !canChange { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) + d.swallow() + } + } + } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []bool{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return v, changed + } + if cap(v) == 0 { + v = make([]bool, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { + if j >= len(v) { + if canChange { + v = append(v, false) + changed = true + } else { + d.arrayCannotExpand(len(v), j+1) + } + } + slh.ElemContainerState(j) + if j < len(v) { + v[j] = dd.DecodeBool() + } else { + d.swallow() + } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true + } + } + slh.End() + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfIntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]interface{}) + v, changed := fastpathTV.DecMapIntfIntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]interface{}) + fastpathTV.DecMapIntfIntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfIntfX(vp *map[interface{}]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfIntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 32) + v = make(map[interface{}]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk interface{} + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfStringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]string) + v, changed := fastpathTV.DecMapIntfStringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]string) + fastpathTV.DecMapIntfStringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfStringX(vp *map[interface{}]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfStringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 32) + v = make(map[interface{}]string, xlen) + changed = true + } + + var mk interface{} + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfUintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]uint) + v, changed := fastpathTV.DecMapIntfUintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]uint) + fastpathTV.DecMapIntfUintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfUintX(vp *map[interface{}]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfUintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[interface{}]uint, xlen) + changed = true + } + + var mk interface{} + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfUint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]uint8) + v, changed := fastpathTV.DecMapIntfUint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]uint8) + fastpathTV.DecMapIntfUint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfUint8X(vp *map[interface{}]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfUint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[interface{}]uint8, xlen) + changed = true + } + + var mk interface{} + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfUint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]uint16) + v, changed := fastpathTV.DecMapIntfUint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]uint16) + fastpathTV.DecMapIntfUint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfUint16X(vp *map[interface{}]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfUint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18) + v = make(map[interface{}]uint16, xlen) + changed = true + } + + var mk interface{} + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfUint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]uint32) + v, changed := fastpathTV.DecMapIntfUint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]uint32) + fastpathTV.DecMapIntfUint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfUint32X(vp *map[interface{}]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfUint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[interface{}]uint32, xlen) + changed = true + } + + var mk interface{} + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfUint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]uint64) + v, changed := fastpathTV.DecMapIntfUint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]uint64) + fastpathTV.DecMapIntfUint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfUint64X(vp *map[interface{}]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfUint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[interface{}]uint64, xlen) + changed = true + } + + var mk interface{} + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfUintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]uintptr) + v, changed := fastpathTV.DecMapIntfUintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]uintptr) + fastpathTV.DecMapIntfUintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfUintptrX(vp *map[interface{}]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfUintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[interface{}]uintptr, xlen) + changed = true + } + + var mk interface{} + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfIntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]int) + v, changed := fastpathTV.DecMapIntfIntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]int) + fastpathTV.DecMapIntfIntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfIntX(vp *map[interface{}]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfIntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[interface{}]int, xlen) + changed = true + } + + var mk interface{} + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfInt8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]int8) + v, changed := fastpathTV.DecMapIntfInt8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]int8) + fastpathTV.DecMapIntfInt8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfInt8X(vp *map[interface{}]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfInt8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[interface{}]int8, xlen) + changed = true + } + + var mk interface{} + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfInt16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]int16) + v, changed := fastpathTV.DecMapIntfInt16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]int16) + fastpathTV.DecMapIntfInt16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfInt16X(vp *map[interface{}]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfInt16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18) + v = make(map[interface{}]int16, xlen) + changed = true + } + + var mk interface{} + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfInt32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]int32) + v, changed := fastpathTV.DecMapIntfInt32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]int32) + fastpathTV.DecMapIntfInt32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfInt32X(vp *map[interface{}]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfInt32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[interface{}]int32, xlen) + changed = true + } + + var mk interface{} + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfInt64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]int64) + v, changed := fastpathTV.DecMapIntfInt64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]int64) + fastpathTV.DecMapIntfInt64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfInt64X(vp *map[interface{}]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfInt64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[interface{}]int64, xlen) + changed = true + } + + var mk interface{} + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfFloat32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]float32) + v, changed := fastpathTV.DecMapIntfFloat32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]float32) + fastpathTV.DecMapIntfFloat32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfFloat32X(vp *map[interface{}]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfFloat32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[interface{}]float32, xlen) + changed = true + } + + var mk interface{} + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfFloat64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]float64) + v, changed := fastpathTV.DecMapIntfFloat64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]float64) + fastpathTV.DecMapIntfFloat64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfFloat64X(vp *map[interface{}]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfFloat64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[interface{}]float64, xlen) + changed = true + } + + var mk interface{} + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntfBoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[interface{}]bool) + v, changed := fastpathTV.DecMapIntfBoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[interface{}]bool) + fastpathTV.DecMapIntfBoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntfBoolX(vp *map[interface{}]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntfBoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[interface{}]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[interface{}]bool, xlen) + changed = true + } + + var mk interface{} + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = nil + d.decode(&mk) + if bv, bok := mk.([]byte); bok { + mk = d.string(bv) + } + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringIntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]interface{}) + v, changed := fastpathTV.DecMapStringIntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]interface{}) + fastpathTV.DecMapStringIntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringIntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[string]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 32) + v = make(map[string]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk string + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringStringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]string) + v, changed := fastpathTV.DecMapStringStringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]string) + fastpathTV.DecMapStringStringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringStringX(vp *map[string]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringStringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringStringV(v map[string]string, checkNil bool, canChange bool, + d *Decoder) (_ map[string]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 32) + v = make(map[string]string, xlen) + changed = true + } + + var mk string + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringUintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]uint) + v, changed := fastpathTV.DecMapStringUintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]uint) + fastpathTV.DecMapStringUintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringUintX(vp *map[string]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringUintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringUintV(v map[string]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[string]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[string]uint, xlen) + changed = true + } + + var mk string + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringUint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]uint8) + v, changed := fastpathTV.DecMapStringUint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]uint8) + fastpathTV.DecMapStringUint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringUint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[string]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[string]uint8, xlen) + changed = true + } + + var mk string + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringUint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]uint16) + v, changed := fastpathTV.DecMapStringUint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]uint16) + fastpathTV.DecMapStringUint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringUint16X(vp *map[string]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringUint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[string]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18) + v = make(map[string]uint16, xlen) + changed = true + } + + var mk string + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringUint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]uint32) + v, changed := fastpathTV.DecMapStringUint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]uint32) + fastpathTV.DecMapStringUint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringUint32X(vp *map[string]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringUint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[string]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[string]uint32, xlen) + changed = true + } + + var mk string + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringUint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]uint64) + v, changed := fastpathTV.DecMapStringUint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]uint64) + fastpathTV.DecMapStringUint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringUint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[string]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[string]uint64, xlen) + changed = true + } + + var mk string + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringUintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]uintptr) + v, changed := fastpathTV.DecMapStringUintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]uintptr) + fastpathTV.DecMapStringUintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringUintptrX(vp *map[string]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringUintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[string]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[string]uintptr, xlen) + changed = true + } + + var mk string + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringIntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]int) + v, changed := fastpathTV.DecMapStringIntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]int) + fastpathTV.DecMapStringIntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringIntX(vp *map[string]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringIntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringIntV(v map[string]int, checkNil bool, canChange bool, + d *Decoder) (_ map[string]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[string]int, xlen) + changed = true + } + + var mk string + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringInt8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]int8) + v, changed := fastpathTV.DecMapStringInt8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]int8) + fastpathTV.DecMapStringInt8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringInt8X(vp *map[string]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringInt8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringInt8V(v map[string]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[string]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[string]int8, xlen) + changed = true + } + + var mk string + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringInt16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]int16) + v, changed := fastpathTV.DecMapStringInt16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]int16) + fastpathTV.DecMapStringInt16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringInt16X(vp *map[string]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringInt16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringInt16V(v map[string]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[string]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18) + v = make(map[string]int16, xlen) + changed = true + } + + var mk string + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringInt32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]int32) + v, changed := fastpathTV.DecMapStringInt32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]int32) + fastpathTV.DecMapStringInt32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringInt32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringInt32V(v map[string]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[string]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[string]int32, xlen) + changed = true + } + + var mk string + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringInt64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]int64) + v, changed := fastpathTV.DecMapStringInt64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]int64) + fastpathTV.DecMapStringInt64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringInt64X(vp *map[string]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringInt64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringInt64V(v map[string]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[string]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[string]int64, xlen) + changed = true + } + + var mk string + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringFloat32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]float32) + v, changed := fastpathTV.DecMapStringFloat32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]float32) + fastpathTV.DecMapStringFloat32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringFloat32X(vp *map[string]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringFloat32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[string]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[string]float32, xlen) + changed = true + } + + var mk string + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringFloat64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]float64) + v, changed := fastpathTV.DecMapStringFloat64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]float64) + fastpathTV.DecMapStringFloat64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringFloat64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[string]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[string]float64, xlen) + changed = true + } + + var mk string + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapStringBoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[string]bool) + v, changed := fastpathTV.DecMapStringBoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[string]bool) + fastpathTV.DecMapStringBoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapStringBoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapStringBoolV(v map[string]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[string]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[string]bool, xlen) + changed = true + } + + var mk string + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32IntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]interface{}) + v, changed := fastpathTV.DecMapFloat32IntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]interface{}) + fastpathTV.DecMapFloat32IntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32IntfX(vp *map[float32]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32IntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[float32]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk float32 + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32StringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]string) + v, changed := fastpathTV.DecMapFloat32StringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]string) + fastpathTV.DecMapFloat32StringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32StringX(vp *map[float32]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32StringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[float32]string, xlen) + changed = true + } + + var mk float32 + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32UintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]uint) + v, changed := fastpathTV.DecMapFloat32UintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]uint) + fastpathTV.DecMapFloat32UintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32UintX(vp *map[float32]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32UintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[float32]uint, xlen) + changed = true + } + + var mk float32 + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32Uint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]uint8) + v, changed := fastpathTV.DecMapFloat32Uint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]uint8) + fastpathTV.DecMapFloat32Uint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32Uint8X(vp *map[float32]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32Uint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[float32]uint8, xlen) + changed = true + } + + var mk float32 + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32Uint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]uint16) + v, changed := fastpathTV.DecMapFloat32Uint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]uint16) + fastpathTV.DecMapFloat32Uint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32Uint16X(vp *map[float32]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32Uint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[float32]uint16, xlen) + changed = true + } + + var mk float32 + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32Uint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]uint32) + v, changed := fastpathTV.DecMapFloat32Uint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]uint32) + fastpathTV.DecMapFloat32Uint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32Uint32X(vp *map[float32]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32Uint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8) + v = make(map[float32]uint32, xlen) + changed = true + } + + var mk float32 + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32Uint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]uint64) + v, changed := fastpathTV.DecMapFloat32Uint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]uint64) + fastpathTV.DecMapFloat32Uint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32Uint64X(vp *map[float32]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32Uint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[float32]uint64, xlen) + changed = true + } + + var mk float32 + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32UintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]uintptr) + v, changed := fastpathTV.DecMapFloat32UintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]uintptr) + fastpathTV.DecMapFloat32UintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32UintptrX(vp *map[float32]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32UintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[float32]uintptr, xlen) + changed = true + } + + var mk float32 + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32IntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]int) + v, changed := fastpathTV.DecMapFloat32IntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]int) + fastpathTV.DecMapFloat32IntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32IntX(vp *map[float32]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32IntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[float32]int, xlen) + changed = true + } + + var mk float32 + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32Int8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]int8) + v, changed := fastpathTV.DecMapFloat32Int8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]int8) + fastpathTV.DecMapFloat32Int8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32Int8X(vp *map[float32]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32Int8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[float32]int8, xlen) + changed = true + } + + var mk float32 + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32Int16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]int16) + v, changed := fastpathTV.DecMapFloat32Int16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]int16) + fastpathTV.DecMapFloat32Int16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32Int16X(vp *map[float32]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32Int16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[float32]int16, xlen) + changed = true + } + + var mk float32 + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32Int32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]int32) + v, changed := fastpathTV.DecMapFloat32Int32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]int32) + fastpathTV.DecMapFloat32Int32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32Int32X(vp *map[float32]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32Int32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8) + v = make(map[float32]int32, xlen) + changed = true + } + + var mk float32 + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32Int64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]int64) + v, changed := fastpathTV.DecMapFloat32Int64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]int64) + fastpathTV.DecMapFloat32Int64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32Int64X(vp *map[float32]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32Int64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[float32]int64, xlen) + changed = true + } + + var mk float32 + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32Float32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]float32) + v, changed := fastpathTV.DecMapFloat32Float32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]float32) + fastpathTV.DecMapFloat32Float32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32Float32X(vp *map[float32]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32Float32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8) + v = make(map[float32]float32, xlen) + changed = true + } + + var mk float32 + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32Float64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]float64) + v, changed := fastpathTV.DecMapFloat32Float64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]float64) + fastpathTV.DecMapFloat32Float64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32Float64X(vp *map[float32]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32Float64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[float32]float64, xlen) + changed = true + } + + var mk float32 + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat32BoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float32]bool) + v, changed := fastpathTV.DecMapFloat32BoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float32]bool) + fastpathTV.DecMapFloat32BoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat32BoolX(vp *map[float32]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat32BoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[float32]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[float32]bool, xlen) + changed = true + } + + var mk float32 + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64IntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]interface{}) + v, changed := fastpathTV.DecMapFloat64IntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]interface{}) + fastpathTV.DecMapFloat64IntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64IntfX(vp *map[float64]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64IntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[float64]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk float64 + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64StringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]string) + v, changed := fastpathTV.DecMapFloat64StringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]string) + fastpathTV.DecMapFloat64StringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64StringX(vp *map[float64]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64StringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[float64]string, xlen) + changed = true + } + + var mk float64 + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64UintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]uint) + v, changed := fastpathTV.DecMapFloat64UintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]uint) + fastpathTV.DecMapFloat64UintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64UintX(vp *map[float64]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64UintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[float64]uint, xlen) + changed = true + } + + var mk float64 + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64Uint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]uint8) + v, changed := fastpathTV.DecMapFloat64Uint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]uint8) + fastpathTV.DecMapFloat64Uint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64Uint8X(vp *map[float64]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64Uint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[float64]uint8, xlen) + changed = true + } + + var mk float64 + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64Uint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]uint16) + v, changed := fastpathTV.DecMapFloat64Uint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]uint16) + fastpathTV.DecMapFloat64Uint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64Uint16X(vp *map[float64]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64Uint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[float64]uint16, xlen) + changed = true + } + + var mk float64 + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64Uint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]uint32) + v, changed := fastpathTV.DecMapFloat64Uint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]uint32) + fastpathTV.DecMapFloat64Uint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64Uint32X(vp *map[float64]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64Uint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[float64]uint32, xlen) + changed = true + } + + var mk float64 + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64Uint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]uint64) + v, changed := fastpathTV.DecMapFloat64Uint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]uint64) + fastpathTV.DecMapFloat64Uint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64Uint64X(vp *map[float64]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64Uint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[float64]uint64, xlen) + changed = true + } + + var mk float64 + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64UintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]uintptr) + v, changed := fastpathTV.DecMapFloat64UintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]uintptr) + fastpathTV.DecMapFloat64UintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64UintptrX(vp *map[float64]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64UintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[float64]uintptr, xlen) + changed = true + } + + var mk float64 + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64IntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]int) + v, changed := fastpathTV.DecMapFloat64IntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]int) + fastpathTV.DecMapFloat64IntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64IntX(vp *map[float64]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64IntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[float64]int, xlen) + changed = true + } + + var mk float64 + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64Int8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]int8) + v, changed := fastpathTV.DecMapFloat64Int8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]int8) + fastpathTV.DecMapFloat64Int8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64Int8X(vp *map[float64]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64Int8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[float64]int8, xlen) + changed = true + } + + var mk float64 + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64Int16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]int16) + v, changed := fastpathTV.DecMapFloat64Int16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]int16) + fastpathTV.DecMapFloat64Int16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64Int16X(vp *map[float64]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64Int16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[float64]int16, xlen) + changed = true + } + + var mk float64 + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64Int32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]int32) + v, changed := fastpathTV.DecMapFloat64Int32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]int32) + fastpathTV.DecMapFloat64Int32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64Int32X(vp *map[float64]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64Int32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[float64]int32, xlen) + changed = true + } + + var mk float64 + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64Int64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]int64) + v, changed := fastpathTV.DecMapFloat64Int64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]int64) + fastpathTV.DecMapFloat64Int64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64Int64X(vp *map[float64]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64Int64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[float64]int64, xlen) + changed = true + } + + var mk float64 + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64Float32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]float32) + v, changed := fastpathTV.DecMapFloat64Float32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]float32) + fastpathTV.DecMapFloat64Float32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64Float32X(vp *map[float64]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64Float32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[float64]float32, xlen) + changed = true + } + + var mk float64 + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64Float64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]float64) + v, changed := fastpathTV.DecMapFloat64Float64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]float64) + fastpathTV.DecMapFloat64Float64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64Float64X(vp *map[float64]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64Float64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[float64]float64, xlen) + changed = true + } + + var mk float64 + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapFloat64BoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[float64]bool) + v, changed := fastpathTV.DecMapFloat64BoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[float64]bool) + fastpathTV.DecMapFloat64BoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapFloat64BoolX(vp *map[float64]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapFloat64BoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[float64]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[float64]bool, xlen) + changed = true + } + + var mk float64 + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintIntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]interface{}) + v, changed := fastpathTV.DecMapUintIntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]interface{}) + fastpathTV.DecMapUintIntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintIntfX(vp *map[uint]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintIntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[uint]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk uint + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintStringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]string) + v, changed := fastpathTV.DecMapUintStringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]string) + fastpathTV.DecMapUintStringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintStringX(vp *map[uint]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintStringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintStringV(v map[uint]string, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[uint]string, xlen) + changed = true + } + + var mk uint + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintUintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]uint) + v, changed := fastpathTV.DecMapUintUintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]uint) + fastpathTV.DecMapUintUintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintUintX(vp *map[uint]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintUintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintUintV(v map[uint]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint]uint, xlen) + changed = true + } + + var mk uint + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintUint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]uint8) + v, changed := fastpathTV.DecMapUintUint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]uint8) + fastpathTV.DecMapUintUint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintUint8X(vp *map[uint]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintUint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint]uint8, xlen) + changed = true + } + + var mk uint + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintUint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]uint16) + v, changed := fastpathTV.DecMapUintUint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]uint16) + fastpathTV.DecMapUintUint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintUint16X(vp *map[uint]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintUint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uint]uint16, xlen) + changed = true + } + + var mk uint + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintUint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]uint32) + v, changed := fastpathTV.DecMapUintUint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]uint32) + fastpathTV.DecMapUintUint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintUint32X(vp *map[uint]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintUint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint]uint32, xlen) + changed = true + } + + var mk uint + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintUint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]uint64) + v, changed := fastpathTV.DecMapUintUint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]uint64) + fastpathTV.DecMapUintUint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintUint64X(vp *map[uint]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintUint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint]uint64, xlen) + changed = true + } + + var mk uint + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintUintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]uintptr) + v, changed := fastpathTV.DecMapUintUintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]uintptr) + fastpathTV.DecMapUintUintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintUintptrX(vp *map[uint]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintUintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint]uintptr, xlen) + changed = true + } + + var mk uint + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintIntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]int) + v, changed := fastpathTV.DecMapUintIntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]int) + fastpathTV.DecMapUintIntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintIntX(vp *map[uint]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintIntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintIntV(v map[uint]int, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint]int, xlen) + changed = true + } + + var mk uint + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintInt8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]int8) + v, changed := fastpathTV.DecMapUintInt8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]int8) + fastpathTV.DecMapUintInt8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintInt8X(vp *map[uint]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintInt8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint]int8, xlen) + changed = true + } + + var mk uint + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintInt16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]int16) + v, changed := fastpathTV.DecMapUintInt16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]int16) + fastpathTV.DecMapUintInt16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintInt16X(vp *map[uint]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintInt16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uint]int16, xlen) + changed = true + } + + var mk uint + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintInt32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]int32) + v, changed := fastpathTV.DecMapUintInt32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]int32) + fastpathTV.DecMapUintInt32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintInt32X(vp *map[uint]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintInt32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint]int32, xlen) + changed = true + } + + var mk uint + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintInt64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]int64) + v, changed := fastpathTV.DecMapUintInt64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]int64) + fastpathTV.DecMapUintInt64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintInt64X(vp *map[uint]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintInt64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint]int64, xlen) + changed = true + } + + var mk uint + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintFloat32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]float32) + v, changed := fastpathTV.DecMapUintFloat32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]float32) + fastpathTV.DecMapUintFloat32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintFloat32X(vp *map[uint]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintFloat32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint]float32, xlen) + changed = true + } + + var mk uint + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintFloat64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]float64) + v, changed := fastpathTV.DecMapUintFloat64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]float64) + fastpathTV.DecMapUintFloat64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintFloat64X(vp *map[uint]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintFloat64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint]float64, xlen) + changed = true + } + + var mk uint + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintBoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint]bool) + v, changed := fastpathTV.DecMapUintBoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint]bool) + fastpathTV.DecMapUintBoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintBoolX(vp *map[uint]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintBoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[uint]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint]bool, xlen) + changed = true + } + + var mk uint + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8IntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]interface{}) + v, changed := fastpathTV.DecMapUint8IntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]interface{}) + fastpathTV.DecMapUint8IntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8IntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[uint8]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk uint8 + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8StringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]string) + v, changed := fastpathTV.DecMapUint8StringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]string) + fastpathTV.DecMapUint8StringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8StringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[uint8]string, xlen) + changed = true + } + + var mk uint8 + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8UintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]uint) + v, changed := fastpathTV.DecMapUint8UintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]uint) + fastpathTV.DecMapUint8UintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8UintX(vp *map[uint8]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8UintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint8]uint, xlen) + changed = true + } + + var mk uint8 + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8Uint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]uint8) + v, changed := fastpathTV.DecMapUint8Uint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]uint8) + fastpathTV.DecMapUint8Uint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8Uint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2) + v = make(map[uint8]uint8, xlen) + changed = true + } + + var mk uint8 + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8Uint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]uint16) + v, changed := fastpathTV.DecMapUint8Uint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]uint16) + fastpathTV.DecMapUint8Uint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8Uint16X(vp *map[uint8]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8Uint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[uint8]uint16, xlen) + changed = true + } + + var mk uint8 + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8Uint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]uint32) + v, changed := fastpathTV.DecMapUint8Uint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]uint32) + fastpathTV.DecMapUint8Uint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8Uint32X(vp *map[uint8]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8Uint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[uint8]uint32, xlen) + changed = true + } + + var mk uint8 + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8Uint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]uint64) + v, changed := fastpathTV.DecMapUint8Uint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]uint64) + fastpathTV.DecMapUint8Uint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8Uint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint8]uint64, xlen) + changed = true + } + + var mk uint8 + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8UintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]uintptr) + v, changed := fastpathTV.DecMapUint8UintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]uintptr) + fastpathTV.DecMapUint8UintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8UintptrX(vp *map[uint8]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8UintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint8]uintptr, xlen) + changed = true + } + + var mk uint8 + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8IntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]int) + v, changed := fastpathTV.DecMapUint8IntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]int) + fastpathTV.DecMapUint8IntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8IntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint8]int, xlen) + changed = true + } + + var mk uint8 + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8Int8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]int8) + v, changed := fastpathTV.DecMapUint8Int8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]int8) + fastpathTV.DecMapUint8Int8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8Int8X(vp *map[uint8]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8Int8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2) + v = make(map[uint8]int8, xlen) + changed = true + } + + var mk uint8 + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8Int16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]int16) + v, changed := fastpathTV.DecMapUint8Int16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]int16) + fastpathTV.DecMapUint8Int16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8Int16X(vp *map[uint8]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8Int16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[uint8]int16, xlen) + changed = true + } + + var mk uint8 + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8Int32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]int32) + v, changed := fastpathTV.DecMapUint8Int32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]int32) + fastpathTV.DecMapUint8Int32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8Int32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[uint8]int32, xlen) + changed = true + } + + var mk uint8 + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8Int64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]int64) + v, changed := fastpathTV.DecMapUint8Int64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]int64) + fastpathTV.DecMapUint8Int64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8Int64X(vp *map[uint8]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8Int64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint8]int64, xlen) + changed = true + } + + var mk uint8 + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8Float32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]float32) + v, changed := fastpathTV.DecMapUint8Float32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]float32) + fastpathTV.DecMapUint8Float32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8Float32X(vp *map[uint8]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8Float32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[uint8]float32, xlen) + changed = true + } + + var mk uint8 + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8Float64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]float64) + v, changed := fastpathTV.DecMapUint8Float64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]float64) + fastpathTV.DecMapUint8Float64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8Float64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint8]float64, xlen) + changed = true + } + + var mk uint8 + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint8BoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint8]bool) + v, changed := fastpathTV.DecMapUint8BoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint8]bool) + fastpathTV.DecMapUint8BoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint8BoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[uint8]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2) + v = make(map[uint8]bool, xlen) + changed = true + } + + var mk uint8 + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16IntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]interface{}) + v, changed := fastpathTV.DecMapUint16IntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]interface{}) + fastpathTV.DecMapUint16IntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16IntfX(vp *map[uint16]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16IntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18) + v = make(map[uint16]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk uint16 + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16StringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]string) + v, changed := fastpathTV.DecMapUint16StringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]string) + fastpathTV.DecMapUint16StringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16StringX(vp *map[uint16]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16StringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18) + v = make(map[uint16]string, xlen) + changed = true + } + + var mk uint16 + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16UintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]uint) + v, changed := fastpathTV.DecMapUint16UintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]uint) + fastpathTV.DecMapUint16UintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16UintX(vp *map[uint16]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16UintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uint16]uint, xlen) + changed = true + } + + var mk uint16 + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16Uint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]uint8) + v, changed := fastpathTV.DecMapUint16Uint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]uint8) + fastpathTV.DecMapUint16Uint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16Uint8X(vp *map[uint16]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16Uint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[uint16]uint8, xlen) + changed = true + } + + var mk uint16 + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16Uint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]uint16) + v, changed := fastpathTV.DecMapUint16Uint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]uint16) + fastpathTV.DecMapUint16Uint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16Uint16X(vp *map[uint16]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16Uint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 4) + v = make(map[uint16]uint16, xlen) + changed = true + } + + var mk uint16 + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16Uint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]uint32) + v, changed := fastpathTV.DecMapUint16Uint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]uint32) + fastpathTV.DecMapUint16Uint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16Uint32X(vp *map[uint16]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16Uint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[uint16]uint32, xlen) + changed = true + } + + var mk uint16 + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16Uint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]uint64) + v, changed := fastpathTV.DecMapUint16Uint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]uint64) + fastpathTV.DecMapUint16Uint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16Uint64X(vp *map[uint16]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16Uint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uint16]uint64, xlen) + changed = true + } + + var mk uint16 + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16UintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]uintptr) + v, changed := fastpathTV.DecMapUint16UintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]uintptr) + fastpathTV.DecMapUint16UintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16UintptrX(vp *map[uint16]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16UintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uint16]uintptr, xlen) + changed = true + } + + var mk uint16 + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16IntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]int) + v, changed := fastpathTV.DecMapUint16IntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]int) + fastpathTV.DecMapUint16IntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16IntX(vp *map[uint16]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16IntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uint16]int, xlen) + changed = true + } + + var mk uint16 + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16Int8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]int8) + v, changed := fastpathTV.DecMapUint16Int8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]int8) + fastpathTV.DecMapUint16Int8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16Int8X(vp *map[uint16]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16Int8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[uint16]int8, xlen) + changed = true + } + + var mk uint16 + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16Int16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]int16) + v, changed := fastpathTV.DecMapUint16Int16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]int16) + fastpathTV.DecMapUint16Int16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16Int16X(vp *map[uint16]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16Int16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 4) + v = make(map[uint16]int16, xlen) + changed = true + } + + var mk uint16 + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16Int32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]int32) + v, changed := fastpathTV.DecMapUint16Int32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]int32) + fastpathTV.DecMapUint16Int32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16Int32X(vp *map[uint16]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16Int32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[uint16]int32, xlen) + changed = true + } + + var mk uint16 + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16Int64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]int64) + v, changed := fastpathTV.DecMapUint16Int64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]int64) + fastpathTV.DecMapUint16Int64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16Int64X(vp *map[uint16]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16Int64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uint16]int64, xlen) + changed = true + } + + var mk uint16 + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16Float32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]float32) + v, changed := fastpathTV.DecMapUint16Float32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]float32) + fastpathTV.DecMapUint16Float32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16Float32X(vp *map[uint16]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16Float32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[uint16]float32, xlen) + changed = true + } + + var mk uint16 + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16Float64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]float64) + v, changed := fastpathTV.DecMapUint16Float64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]float64) + fastpathTV.DecMapUint16Float64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16Float64X(vp *map[uint16]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16Float64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uint16]float64, xlen) + changed = true + } + + var mk uint16 + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint16BoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint16]bool) + v, changed := fastpathTV.DecMapUint16BoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint16]bool) + fastpathTV.DecMapUint16BoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint16BoolX(vp *map[uint16]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint16BoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[uint16]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[uint16]bool, xlen) + changed = true + } + + var mk uint16 + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32IntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]interface{}) + v, changed := fastpathTV.DecMapUint32IntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]interface{}) + fastpathTV.DecMapUint32IntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32IntfX(vp *map[uint32]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32IntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[uint32]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk uint32 + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32StringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]string) + v, changed := fastpathTV.DecMapUint32StringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]string) + fastpathTV.DecMapUint32StringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32StringX(vp *map[uint32]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32StringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[uint32]string, xlen) + changed = true + } + + var mk uint32 + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32UintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]uint) + v, changed := fastpathTV.DecMapUint32UintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]uint) + fastpathTV.DecMapUint32UintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32UintX(vp *map[uint32]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32UintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint32]uint, xlen) + changed = true + } + + var mk uint32 + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32Uint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]uint8) + v, changed := fastpathTV.DecMapUint32Uint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]uint8) + fastpathTV.DecMapUint32Uint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32Uint8X(vp *map[uint32]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32Uint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[uint32]uint8, xlen) + changed = true + } + + var mk uint32 + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32Uint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]uint16) + v, changed := fastpathTV.DecMapUint32Uint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]uint16) + fastpathTV.DecMapUint32Uint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32Uint16X(vp *map[uint32]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32Uint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[uint32]uint16, xlen) + changed = true + } + + var mk uint32 + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32Uint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]uint32) + v, changed := fastpathTV.DecMapUint32Uint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]uint32) + fastpathTV.DecMapUint32Uint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32Uint32X(vp *map[uint32]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32Uint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8) + v = make(map[uint32]uint32, xlen) + changed = true + } + + var mk uint32 + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32Uint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]uint64) + v, changed := fastpathTV.DecMapUint32Uint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]uint64) + fastpathTV.DecMapUint32Uint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32Uint64X(vp *map[uint32]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32Uint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint32]uint64, xlen) + changed = true + } + + var mk uint32 + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32UintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]uintptr) + v, changed := fastpathTV.DecMapUint32UintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]uintptr) + fastpathTV.DecMapUint32UintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32UintptrX(vp *map[uint32]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32UintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint32]uintptr, xlen) + changed = true + } + + var mk uint32 + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32IntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]int) + v, changed := fastpathTV.DecMapUint32IntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]int) + fastpathTV.DecMapUint32IntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32IntX(vp *map[uint32]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32IntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint32]int, xlen) + changed = true + } + + var mk uint32 + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32Int8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]int8) + v, changed := fastpathTV.DecMapUint32Int8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]int8) + fastpathTV.DecMapUint32Int8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32Int8X(vp *map[uint32]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32Int8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[uint32]int8, xlen) + changed = true + } + + var mk uint32 + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32Int16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]int16) + v, changed := fastpathTV.DecMapUint32Int16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]int16) + fastpathTV.DecMapUint32Int16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32Int16X(vp *map[uint32]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32Int16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[uint32]int16, xlen) + changed = true + } + + var mk uint32 + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32Int32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]int32) + v, changed := fastpathTV.DecMapUint32Int32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]int32) + fastpathTV.DecMapUint32Int32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32Int32X(vp *map[uint32]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32Int32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8) + v = make(map[uint32]int32, xlen) + changed = true + } + + var mk uint32 + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32Int64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]int64) + v, changed := fastpathTV.DecMapUint32Int64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]int64) + fastpathTV.DecMapUint32Int64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32Int64X(vp *map[uint32]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32Int64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint32]int64, xlen) + changed = true + } + + var mk uint32 + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32Float32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]float32) + v, changed := fastpathTV.DecMapUint32Float32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]float32) + fastpathTV.DecMapUint32Float32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32Float32X(vp *map[uint32]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32Float32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8) + v = make(map[uint32]float32, xlen) + changed = true + } + + var mk uint32 + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32Float64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]float64) + v, changed := fastpathTV.DecMapUint32Float64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]float64) + fastpathTV.DecMapUint32Float64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32Float64X(vp *map[uint32]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32Float64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint32]float64, xlen) + changed = true + } + + var mk uint32 + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint32BoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint32]bool) + v, changed := fastpathTV.DecMapUint32BoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint32]bool) + fastpathTV.DecMapUint32BoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint32BoolX(vp *map[uint32]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint32BoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[uint32]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[uint32]bool, xlen) + changed = true + } + + var mk uint32 + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64IntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]interface{}) + v, changed := fastpathTV.DecMapUint64IntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]interface{}) + fastpathTV.DecMapUint64IntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64IntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[uint64]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk uint64 + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64StringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]string) + v, changed := fastpathTV.DecMapUint64StringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]string) + fastpathTV.DecMapUint64StringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64StringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[uint64]string, xlen) + changed = true + } + + var mk uint64 + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64UintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]uint) + v, changed := fastpathTV.DecMapUint64UintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]uint) + fastpathTV.DecMapUint64UintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64UintX(vp *map[uint64]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64UintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint64]uint, xlen) + changed = true + } + + var mk uint64 + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64Uint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]uint8) + v, changed := fastpathTV.DecMapUint64Uint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]uint8) + fastpathTV.DecMapUint64Uint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64Uint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint64]uint8, xlen) + changed = true + } + + var mk uint64 + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64Uint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]uint16) + v, changed := fastpathTV.DecMapUint64Uint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]uint16) + fastpathTV.DecMapUint64Uint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64Uint16X(vp *map[uint64]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64Uint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uint64]uint16, xlen) + changed = true + } + + var mk uint64 + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64Uint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]uint32) + v, changed := fastpathTV.DecMapUint64Uint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]uint32) + fastpathTV.DecMapUint64Uint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64Uint32X(vp *map[uint64]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64Uint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint64]uint32, xlen) + changed = true + } + + var mk uint64 + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64Uint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]uint64) + v, changed := fastpathTV.DecMapUint64Uint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]uint64) + fastpathTV.DecMapUint64Uint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64Uint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint64]uint64, xlen) + changed = true + } + + var mk uint64 + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64UintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]uintptr) + v, changed := fastpathTV.DecMapUint64UintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]uintptr) + fastpathTV.DecMapUint64UintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64UintptrX(vp *map[uint64]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64UintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint64]uintptr, xlen) + changed = true + } + + var mk uint64 + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64IntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]int) + v, changed := fastpathTV.DecMapUint64IntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]int) + fastpathTV.DecMapUint64IntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64IntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint64]int, xlen) + changed = true + } + + var mk uint64 + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64Int8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]int8) + v, changed := fastpathTV.DecMapUint64Int8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]int8) + fastpathTV.DecMapUint64Int8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64Int8X(vp *map[uint64]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64Int8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint64]int8, xlen) + changed = true + } + + var mk uint64 + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64Int16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]int16) + v, changed := fastpathTV.DecMapUint64Int16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]int16) + fastpathTV.DecMapUint64Int16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64Int16X(vp *map[uint64]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64Int16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uint64]int16, xlen) + changed = true + } + + var mk uint64 + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64Int32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]int32) + v, changed := fastpathTV.DecMapUint64Int32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]int32) + fastpathTV.DecMapUint64Int32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64Int32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint64]int32, xlen) + changed = true + } + + var mk uint64 + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64Int64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]int64) + v, changed := fastpathTV.DecMapUint64Int64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]int64) + fastpathTV.DecMapUint64Int64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64Int64X(vp *map[uint64]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64Int64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint64]int64, xlen) + changed = true + } + + var mk uint64 + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64Float32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]float32) + v, changed := fastpathTV.DecMapUint64Float32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]float32) + fastpathTV.DecMapUint64Float32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64Float32X(vp *map[uint64]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64Float32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uint64]float32, xlen) + changed = true + } + + var mk uint64 + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64Float64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]float64) + v, changed := fastpathTV.DecMapUint64Float64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]float64) + fastpathTV.DecMapUint64Float64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64Float64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uint64]float64, xlen) + changed = true + } + + var mk uint64 + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUint64BoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uint64]bool) + v, changed := fastpathTV.DecMapUint64BoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uint64]bool) + fastpathTV.DecMapUint64BoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapUint64BoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[uint64]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uint64]bool, xlen) + changed = true + } + + var mk uint64 + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrIntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]interface{}) + v, changed := fastpathTV.DecMapUintptrIntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]interface{}) + fastpathTV.DecMapUintptrIntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrIntfX(vp *map[uintptr]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrIntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[uintptr]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk uintptr + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrStringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]string) + v, changed := fastpathTV.DecMapUintptrStringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]string) + fastpathTV.DecMapUintptrStringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrStringX(vp *map[uintptr]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrStringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[uintptr]string, xlen) + changed = true + } + + var mk uintptr + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrUintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]uint) + v, changed := fastpathTV.DecMapUintptrUintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]uint) + fastpathTV.DecMapUintptrUintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrUintX(vp *map[uintptr]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrUintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uintptr]uint, xlen) + changed = true + } + + var mk uintptr + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrUint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]uint8) + v, changed := fastpathTV.DecMapUintptrUint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]uint8) + fastpathTV.DecMapUintptrUint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrUint8X(vp *map[uintptr]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrUint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uintptr]uint8, xlen) + changed = true + } + + var mk uintptr + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrUint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]uint16) + v, changed := fastpathTV.DecMapUintptrUint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]uint16) + fastpathTV.DecMapUintptrUint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrUint16X(vp *map[uintptr]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrUint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uintptr]uint16, xlen) + changed = true + } + + var mk uintptr + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrUint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]uint32) + v, changed := fastpathTV.DecMapUintptrUint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]uint32) + fastpathTV.DecMapUintptrUint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrUint32X(vp *map[uintptr]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrUint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uintptr]uint32, xlen) + changed = true + } + + var mk uintptr + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrUint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]uint64) + v, changed := fastpathTV.DecMapUintptrUint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]uint64) + fastpathTV.DecMapUintptrUint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrUint64X(vp *map[uintptr]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrUint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uintptr]uint64, xlen) + changed = true + } + + var mk uintptr + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrUintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]uintptr) + v, changed := fastpathTV.DecMapUintptrUintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]uintptr) + fastpathTV.DecMapUintptrUintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrUintptrX(vp *map[uintptr]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrUintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uintptr]uintptr, xlen) + changed = true + } + + var mk uintptr + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrIntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]int) + v, changed := fastpathTV.DecMapUintptrIntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]int) + fastpathTV.DecMapUintptrIntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrIntX(vp *map[uintptr]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrIntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uintptr]int, xlen) + changed = true + } + + var mk uintptr + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrInt8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]int8) + v, changed := fastpathTV.DecMapUintptrInt8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]int8) + fastpathTV.DecMapUintptrInt8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrInt8X(vp *map[uintptr]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrInt8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uintptr]int8, xlen) + changed = true + } + + var mk uintptr + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrInt16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]int16) + v, changed := fastpathTV.DecMapUintptrInt16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]int16) + fastpathTV.DecMapUintptrInt16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrInt16X(vp *map[uintptr]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrInt16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[uintptr]int16, xlen) + changed = true + } + + var mk uintptr + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrInt32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]int32) + v, changed := fastpathTV.DecMapUintptrInt32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]int32) + fastpathTV.DecMapUintptrInt32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrInt32X(vp *map[uintptr]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrInt32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uintptr]int32, xlen) + changed = true + } + + var mk uintptr + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrInt64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]int64) + v, changed := fastpathTV.DecMapUintptrInt64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]int64) + fastpathTV.DecMapUintptrInt64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrInt64X(vp *map[uintptr]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrInt64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uintptr]int64, xlen) + changed = true + } + + var mk uintptr + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrFloat32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]float32) + v, changed := fastpathTV.DecMapUintptrFloat32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]float32) + fastpathTV.DecMapUintptrFloat32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrFloat32X(vp *map[uintptr]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrFloat32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[uintptr]float32, xlen) + changed = true + } + + var mk uintptr + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrFloat64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]float64) + v, changed := fastpathTV.DecMapUintptrFloat64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]float64) + fastpathTV.DecMapUintptrFloat64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrFloat64X(vp *map[uintptr]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrFloat64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[uintptr]float64, xlen) + changed = true + } + + var mk uintptr + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapUintptrBoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[uintptr]bool) + v, changed := fastpathTV.DecMapUintptrBoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[uintptr]bool) + fastpathTV.DecMapUintptrBoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapUintptrBoolX(vp *map[uintptr]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapUintptrBoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[uintptr]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[uintptr]bool, xlen) + changed = true + } + + var mk uintptr + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntIntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]interface{}) + v, changed := fastpathTV.DecMapIntIntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]interface{}) + fastpathTV.DecMapIntIntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntIntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[int]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[int]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk int + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntStringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]string) + v, changed := fastpathTV.DecMapIntStringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]string) + fastpathTV.DecMapIntStringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntStringX(vp *map[int]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntStringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntStringV(v map[int]string, checkNil bool, canChange bool, + d *Decoder) (_ map[int]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[int]string, xlen) + changed = true + } + + var mk int + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntUintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]uint) + v, changed := fastpathTV.DecMapIntUintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]uint) + fastpathTV.DecMapIntUintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntUintX(vp *map[int]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntUintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntUintV(v map[int]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[int]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int]uint, xlen) + changed = true + } + + var mk int + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntUint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]uint8) + v, changed := fastpathTV.DecMapIntUint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]uint8) + fastpathTV.DecMapIntUint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntUint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[int]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int]uint8, xlen) + changed = true + } + + var mk int + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntUint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]uint16) + v, changed := fastpathTV.DecMapIntUint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]uint16) + fastpathTV.DecMapIntUint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntUint16X(vp *map[int]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntUint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[int]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[int]uint16, xlen) + changed = true + } + + var mk int + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntUint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]uint32) + v, changed := fastpathTV.DecMapIntUint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]uint32) + fastpathTV.DecMapIntUint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntUint32X(vp *map[int]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntUint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[int]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int]uint32, xlen) + changed = true + } + + var mk int + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntUint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]uint64) + v, changed := fastpathTV.DecMapIntUint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]uint64) + fastpathTV.DecMapIntUint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntUint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[int]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int]uint64, xlen) + changed = true + } + + var mk int + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntUintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]uintptr) + v, changed := fastpathTV.DecMapIntUintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]uintptr) + fastpathTV.DecMapIntUintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntUintptrX(vp *map[int]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntUintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[int]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int]uintptr, xlen) + changed = true + } + + var mk int + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntIntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]int) + v, changed := fastpathTV.DecMapIntIntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]int) + fastpathTV.DecMapIntIntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntIntX(vp *map[int]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntIntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntIntV(v map[int]int, checkNil bool, canChange bool, + d *Decoder) (_ map[int]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int]int, xlen) + changed = true + } + + var mk int + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntInt8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]int8) + v, changed := fastpathTV.DecMapIntInt8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]int8) + fastpathTV.DecMapIntInt8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntInt8X(vp *map[int]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntInt8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntInt8V(v map[int]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[int]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int]int8, xlen) + changed = true + } + + var mk int + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntInt16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]int16) + v, changed := fastpathTV.DecMapIntInt16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]int16) + fastpathTV.DecMapIntInt16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntInt16X(vp *map[int]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntInt16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntInt16V(v map[int]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[int]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[int]int16, xlen) + changed = true + } + + var mk int + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntInt32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]int32) + v, changed := fastpathTV.DecMapIntInt32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]int32) + fastpathTV.DecMapIntInt32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntInt32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntInt32V(v map[int]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[int]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int]int32, xlen) + changed = true + } + + var mk int + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntInt64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]int64) + v, changed := fastpathTV.DecMapIntInt64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]int64) + fastpathTV.DecMapIntInt64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntInt64X(vp *map[int]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntInt64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntInt64V(v map[int]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[int]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int]int64, xlen) + changed = true + } + + var mk int + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntFloat32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]float32) + v, changed := fastpathTV.DecMapIntFloat32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]float32) + fastpathTV.DecMapIntFloat32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntFloat32X(vp *map[int]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntFloat32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[int]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int]float32, xlen) + changed = true + } + + var mk int + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntFloat64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]float64) + v, changed := fastpathTV.DecMapIntFloat64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]float64) + fastpathTV.DecMapIntFloat64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntFloat64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[int]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int]float64, xlen) + changed = true + } + + var mk int + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapIntBoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int]bool) + v, changed := fastpathTV.DecMapIntBoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int]bool) + fastpathTV.DecMapIntBoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapIntBoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapIntBoolV(v map[int]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[int]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int]bool, xlen) + changed = true + } + + var mk int + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8IntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]interface{}) + v, changed := fastpathTV.DecMapInt8IntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]interface{}) + fastpathTV.DecMapInt8IntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8IntfX(vp *map[int8]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8IntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[int8]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk int8 + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8StringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]string) + v, changed := fastpathTV.DecMapInt8StringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]string) + fastpathTV.DecMapInt8StringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8StringX(vp *map[int8]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8StringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8StringV(v map[int8]string, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[int8]string, xlen) + changed = true + } + + var mk int8 + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8UintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]uint) + v, changed := fastpathTV.DecMapInt8UintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]uint) + fastpathTV.DecMapInt8UintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8UintX(vp *map[int8]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8UintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int8]uint, xlen) + changed = true + } + + var mk int8 + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8Uint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]uint8) + v, changed := fastpathTV.DecMapInt8Uint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]uint8) + fastpathTV.DecMapInt8Uint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8Uint8X(vp *map[int8]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8Uint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2) + v = make(map[int8]uint8, xlen) + changed = true + } + + var mk int8 + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8Uint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]uint16) + v, changed := fastpathTV.DecMapInt8Uint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]uint16) + fastpathTV.DecMapInt8Uint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8Uint16X(vp *map[int8]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8Uint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[int8]uint16, xlen) + changed = true + } + + var mk int8 + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8Uint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]uint32) + v, changed := fastpathTV.DecMapInt8Uint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]uint32) + fastpathTV.DecMapInt8Uint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8Uint32X(vp *map[int8]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8Uint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[int8]uint32, xlen) + changed = true + } + + var mk int8 + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8Uint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]uint64) + v, changed := fastpathTV.DecMapInt8Uint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]uint64) + fastpathTV.DecMapInt8Uint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8Uint64X(vp *map[int8]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8Uint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int8]uint64, xlen) + changed = true + } + + var mk int8 + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8UintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]uintptr) + v, changed := fastpathTV.DecMapInt8UintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]uintptr) + fastpathTV.DecMapInt8UintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8UintptrX(vp *map[int8]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8UintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int8]uintptr, xlen) + changed = true + } + + var mk int8 + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8IntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]int) + v, changed := fastpathTV.DecMapInt8IntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]int) + fastpathTV.DecMapInt8IntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8IntX(vp *map[int8]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8IntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8IntV(v map[int8]int, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int8]int, xlen) + changed = true + } + + var mk int8 + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8Int8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]int8) + v, changed := fastpathTV.DecMapInt8Int8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]int8) + fastpathTV.DecMapInt8Int8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8Int8X(vp *map[int8]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8Int8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2) + v = make(map[int8]int8, xlen) + changed = true + } + + var mk int8 + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8Int16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]int16) + v, changed := fastpathTV.DecMapInt8Int16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]int16) + fastpathTV.DecMapInt8Int16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8Int16X(vp *map[int8]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8Int16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[int8]int16, xlen) + changed = true + } + + var mk int8 + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8Int32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]int32) + v, changed := fastpathTV.DecMapInt8Int32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]int32) + fastpathTV.DecMapInt8Int32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8Int32X(vp *map[int8]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8Int32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[int8]int32, xlen) + changed = true + } + + var mk int8 + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8Int64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]int64) + v, changed := fastpathTV.DecMapInt8Int64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]int64) + fastpathTV.DecMapInt8Int64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8Int64X(vp *map[int8]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8Int64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int8]int64, xlen) + changed = true + } + + var mk int8 + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8Float32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]float32) + v, changed := fastpathTV.DecMapInt8Float32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]float32) + fastpathTV.DecMapInt8Float32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8Float32X(vp *map[int8]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8Float32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[int8]float32, xlen) + changed = true + } + + var mk int8 + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8Float64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]float64) + v, changed := fastpathTV.DecMapInt8Float64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]float64) + fastpathTV.DecMapInt8Float64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8Float64X(vp *map[int8]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8Float64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int8]float64, xlen) + changed = true + } + + var mk int8 + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt8BoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int8]bool) + v, changed := fastpathTV.DecMapInt8BoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int8]bool) + fastpathTV.DecMapInt8BoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt8BoolX(vp *map[int8]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt8BoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[int8]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2) + v = make(map[int8]bool, xlen) + changed = true + } + + var mk int8 + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16IntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]interface{}) + v, changed := fastpathTV.DecMapInt16IntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]interface{}) + fastpathTV.DecMapInt16IntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16IntfX(vp *map[int16]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16IntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18) + v = make(map[int16]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk int16 + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16StringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]string) + v, changed := fastpathTV.DecMapInt16StringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]string) + fastpathTV.DecMapInt16StringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16StringX(vp *map[int16]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16StringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16StringV(v map[int16]string, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18) + v = make(map[int16]string, xlen) + changed = true + } + + var mk int16 + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16UintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]uint) + v, changed := fastpathTV.DecMapInt16UintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]uint) + fastpathTV.DecMapInt16UintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16UintX(vp *map[int16]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16UintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[int16]uint, xlen) + changed = true + } + + var mk int16 + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16Uint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]uint8) + v, changed := fastpathTV.DecMapInt16Uint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]uint8) + fastpathTV.DecMapInt16Uint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16Uint8X(vp *map[int16]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16Uint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[int16]uint8, xlen) + changed = true + } + + var mk int16 + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16Uint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]uint16) + v, changed := fastpathTV.DecMapInt16Uint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]uint16) + fastpathTV.DecMapInt16Uint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16Uint16X(vp *map[int16]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16Uint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 4) + v = make(map[int16]uint16, xlen) + changed = true + } + + var mk int16 + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16Uint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]uint32) + v, changed := fastpathTV.DecMapInt16Uint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]uint32) + fastpathTV.DecMapInt16Uint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16Uint32X(vp *map[int16]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16Uint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[int16]uint32, xlen) + changed = true + } + + var mk int16 + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16Uint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]uint64) + v, changed := fastpathTV.DecMapInt16Uint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]uint64) + fastpathTV.DecMapInt16Uint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16Uint64X(vp *map[int16]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16Uint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[int16]uint64, xlen) + changed = true + } + + var mk int16 + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16UintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]uintptr) + v, changed := fastpathTV.DecMapInt16UintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]uintptr) + fastpathTV.DecMapInt16UintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16UintptrX(vp *map[int16]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16UintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[int16]uintptr, xlen) + changed = true + } + + var mk int16 + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16IntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]int) + v, changed := fastpathTV.DecMapInt16IntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]int) + fastpathTV.DecMapInt16IntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16IntX(vp *map[int16]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16IntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16IntV(v map[int16]int, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[int16]int, xlen) + changed = true + } + + var mk int16 + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16Int8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]int8) + v, changed := fastpathTV.DecMapInt16Int8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]int8) + fastpathTV.DecMapInt16Int8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16Int8X(vp *map[int16]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16Int8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[int16]int8, xlen) + changed = true + } + + var mk int16 + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16Int16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]int16) + v, changed := fastpathTV.DecMapInt16Int16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]int16) + fastpathTV.DecMapInt16Int16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16Int16X(vp *map[int16]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16Int16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 4) + v = make(map[int16]int16, xlen) + changed = true + } + + var mk int16 + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16Int32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]int32) + v, changed := fastpathTV.DecMapInt16Int32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]int32) + fastpathTV.DecMapInt16Int32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16Int32X(vp *map[int16]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16Int32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[int16]int32, xlen) + changed = true + } + + var mk int16 + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16Int64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]int64) + v, changed := fastpathTV.DecMapInt16Int64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]int64) + fastpathTV.DecMapInt16Int64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16Int64X(vp *map[int16]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16Int64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[int16]int64, xlen) + changed = true + } + + var mk int16 + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16Float32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]float32) + v, changed := fastpathTV.DecMapInt16Float32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]float32) + fastpathTV.DecMapInt16Float32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16Float32X(vp *map[int16]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16Float32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[int16]float32, xlen) + changed = true + } + + var mk int16 + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16Float64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]float64) + v, changed := fastpathTV.DecMapInt16Float64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]float64) + fastpathTV.DecMapInt16Float64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16Float64X(vp *map[int16]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16Float64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[int16]float64, xlen) + changed = true + } + + var mk int16 + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt16BoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int16]bool) + v, changed := fastpathTV.DecMapInt16BoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int16]bool) + fastpathTV.DecMapInt16BoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt16BoolX(vp *map[int16]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt16BoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[int16]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[int16]bool, xlen) + changed = true + } + + var mk int16 + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32IntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]interface{}) + v, changed := fastpathTV.DecMapInt32IntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]interface{}) + fastpathTV.DecMapInt32IntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32IntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[int32]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk int32 + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32StringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]string) + v, changed := fastpathTV.DecMapInt32StringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]string) + fastpathTV.DecMapInt32StringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32StringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32StringV(v map[int32]string, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20) + v = make(map[int32]string, xlen) + changed = true + } + + var mk int32 + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32UintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]uint) + v, changed := fastpathTV.DecMapInt32UintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]uint) + fastpathTV.DecMapInt32UintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32UintX(vp *map[int32]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32UintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int32]uint, xlen) + changed = true + } + + var mk int32 + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32Uint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]uint8) + v, changed := fastpathTV.DecMapInt32Uint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]uint8) + fastpathTV.DecMapInt32Uint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32Uint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[int32]uint8, xlen) + changed = true + } + + var mk int32 + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32Uint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]uint16) + v, changed := fastpathTV.DecMapInt32Uint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]uint16) + fastpathTV.DecMapInt32Uint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32Uint16X(vp *map[int32]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32Uint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[int32]uint16, xlen) + changed = true + } + + var mk int32 + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32Uint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]uint32) + v, changed := fastpathTV.DecMapInt32Uint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]uint32) + fastpathTV.DecMapInt32Uint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32Uint32X(vp *map[int32]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32Uint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8) + v = make(map[int32]uint32, xlen) + changed = true + } + + var mk int32 + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32Uint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]uint64) + v, changed := fastpathTV.DecMapInt32Uint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]uint64) + fastpathTV.DecMapInt32Uint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32Uint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int32]uint64, xlen) + changed = true + } + + var mk int32 + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32UintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]uintptr) + v, changed := fastpathTV.DecMapInt32UintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]uintptr) + fastpathTV.DecMapInt32UintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32UintptrX(vp *map[int32]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32UintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int32]uintptr, xlen) + changed = true + } + + var mk int32 + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32IntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]int) + v, changed := fastpathTV.DecMapInt32IntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]int) + fastpathTV.DecMapInt32IntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32IntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32IntV(v map[int32]int, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int32]int, xlen) + changed = true + } + + var mk int32 + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32Int8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]int8) + v, changed := fastpathTV.DecMapInt32Int8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]int8) + fastpathTV.DecMapInt32Int8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32Int8X(vp *map[int32]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32Int8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[int32]int8, xlen) + changed = true + } + + var mk int32 + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32Int16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]int16) + v, changed := fastpathTV.DecMapInt32Int16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]int16) + fastpathTV.DecMapInt32Int16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32Int16X(vp *map[int32]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32Int16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6) + v = make(map[int32]int16, xlen) + changed = true + } + + var mk int32 + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32Int32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]int32) + v, changed := fastpathTV.DecMapInt32Int32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]int32) + fastpathTV.DecMapInt32Int32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32Int32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8) + v = make(map[int32]int32, xlen) + changed = true + } + + var mk int32 + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32Int64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]int64) + v, changed := fastpathTV.DecMapInt32Int64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]int64) + fastpathTV.DecMapInt32Int64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32Int64X(vp *map[int32]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32Int64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int32]int64, xlen) + changed = true + } + + var mk int32 + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32Float32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]float32) + v, changed := fastpathTV.DecMapInt32Float32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]float32) + fastpathTV.DecMapInt32Float32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32Float32X(vp *map[int32]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32Float32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8) + v = make(map[int32]float32, xlen) + changed = true + } + + var mk int32 + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32Float64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]float64) + v, changed := fastpathTV.DecMapInt32Float64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]float64) + fastpathTV.DecMapInt32Float64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32Float64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int32]float64, xlen) + changed = true + } + + var mk int32 + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt32BoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int32]bool) + v, changed := fastpathTV.DecMapInt32BoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int32]bool) + fastpathTV.DecMapInt32BoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt32BoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[int32]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[int32]bool, xlen) + changed = true + } + + var mk int32 + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64IntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]interface{}) + v, changed := fastpathTV.DecMapInt64IntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]interface{}) + fastpathTV.DecMapInt64IntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64IntfX(vp *map[int64]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64IntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[int64]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk int64 + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64StringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]string) + v, changed := fastpathTV.DecMapInt64StringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]string) + fastpathTV.DecMapInt64StringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64StringX(vp *map[int64]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64StringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64StringV(v map[int64]string, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24) + v = make(map[int64]string, xlen) + changed = true + } + + var mk int64 + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64UintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]uint) + v, changed := fastpathTV.DecMapInt64UintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]uint) + fastpathTV.DecMapInt64UintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64UintX(vp *map[int64]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64UintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int64]uint, xlen) + changed = true + } + + var mk int64 + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64Uint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]uint8) + v, changed := fastpathTV.DecMapInt64Uint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]uint8) + fastpathTV.DecMapInt64Uint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64Uint8X(vp *map[int64]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64Uint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int64]uint8, xlen) + changed = true + } + + var mk int64 + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64Uint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]uint16) + v, changed := fastpathTV.DecMapInt64Uint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]uint16) + fastpathTV.DecMapInt64Uint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64Uint16X(vp *map[int64]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64Uint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[int64]uint16, xlen) + changed = true + } + + var mk int64 + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64Uint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]uint32) + v, changed := fastpathTV.DecMapInt64Uint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]uint32) + fastpathTV.DecMapInt64Uint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64Uint32X(vp *map[int64]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64Uint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int64]uint32, xlen) + changed = true + } + + var mk int64 + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64Uint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]uint64) + v, changed := fastpathTV.DecMapInt64Uint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]uint64) + fastpathTV.DecMapInt64Uint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64Uint64X(vp *map[int64]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64Uint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int64]uint64, xlen) + changed = true + } + + var mk int64 + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64UintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]uintptr) + v, changed := fastpathTV.DecMapInt64UintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]uintptr) + fastpathTV.DecMapInt64UintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64UintptrX(vp *map[int64]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64UintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int64]uintptr, xlen) + changed = true + } + + var mk int64 + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64IntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]int) + v, changed := fastpathTV.DecMapInt64IntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]int) + fastpathTV.DecMapInt64IntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64IntX(vp *map[int64]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64IntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64IntV(v map[int64]int, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int64]int, xlen) + changed = true + } + + var mk int64 + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64Int8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]int8) + v, changed := fastpathTV.DecMapInt64Int8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]int8) + fastpathTV.DecMapInt64Int8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64Int8X(vp *map[int64]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64Int8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int64]int8, xlen) + changed = true + } + + var mk int64 + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64Int16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]int16) + v, changed := fastpathTV.DecMapInt64Int16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]int16) + fastpathTV.DecMapInt64Int16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64Int16X(vp *map[int64]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64Int16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10) + v = make(map[int64]int16, xlen) + changed = true + } + + var mk int64 + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64Int32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]int32) + v, changed := fastpathTV.DecMapInt64Int32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]int32) + fastpathTV.DecMapInt64Int32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64Int32X(vp *map[int64]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64Int32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int64]int32, xlen) + changed = true + } + + var mk int64 + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64Int64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]int64) + v, changed := fastpathTV.DecMapInt64Int64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]int64) + fastpathTV.DecMapInt64Int64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64Int64X(vp *map[int64]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64Int64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int64]int64, xlen) + changed = true + } + + var mk int64 + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64Float32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]float32) + v, changed := fastpathTV.DecMapInt64Float32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]float32) + fastpathTV.DecMapInt64Float32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64Float32X(vp *map[int64]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64Float32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12) + v = make(map[int64]float32, xlen) + changed = true + } + + var mk int64 + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64Float64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]float64) + v, changed := fastpathTV.DecMapInt64Float64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]float64) + fastpathTV.DecMapInt64Float64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64Float64X(vp *map[int64]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64Float64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16) + v = make(map[int64]float64, xlen) + changed = true + } + + var mk int64 + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapInt64BoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[int64]bool) + v, changed := fastpathTV.DecMapInt64BoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[int64]bool) + fastpathTV.DecMapInt64BoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapInt64BoolX(vp *map[int64]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapInt64BoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[int64]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[int64]bool, xlen) + changed = true + } + + var mk int64 + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolIntfR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]interface{}) + v, changed := fastpathTV.DecMapBoolIntfV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]interface{}) + fastpathTV.DecMapBoolIntfV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolIntfX(vp *map[bool]interface{}, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolIntfV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]interface{}, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[bool]interface{}, xlen) + changed = true + } + mapGet := !d.h.MapValueReset && !d.h.InterfaceReset + var mk bool + var mv interface{} + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + if mapGet { + mv = v[mk] + } else { + mv = nil + } + d.decode(&mv) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolStringR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]string) + v, changed := fastpathTV.DecMapBoolStringV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]string) + fastpathTV.DecMapBoolStringV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolStringX(vp *map[bool]string, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolStringV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolStringV(v map[bool]string, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]string, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17) + v = make(map[bool]string, xlen) + changed = true + } + + var mk bool + var mv string + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeString() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolUintR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]uint) + v, changed := fastpathTV.DecMapBoolUintV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]uint) + fastpathTV.DecMapBoolUintV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolUintX(vp *map[bool]uint, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolUintV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]uint, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[bool]uint, xlen) + changed = true + } + + var mk bool + var mv uint + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolUint8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]uint8) + v, changed := fastpathTV.DecMapBoolUint8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]uint8) + fastpathTV.DecMapBoolUint8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolUint8X(vp *map[bool]uint8, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolUint8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]uint8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2) + v = make(map[bool]uint8, xlen) + changed = true + } + + var mk bool + var mv uint8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint8(dd.DecodeUint(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolUint16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]uint16) + v, changed := fastpathTV.DecMapBoolUint16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]uint16) + fastpathTV.DecMapBoolUint16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolUint16X(vp *map[bool]uint16, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolUint16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]uint16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[bool]uint16, xlen) + changed = true + } + + var mk bool + var mv uint16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint16(dd.DecodeUint(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolUint32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]uint32) + v, changed := fastpathTV.DecMapBoolUint32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]uint32) + fastpathTV.DecMapBoolUint32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolUint32X(vp *map[bool]uint32, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolUint32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]uint32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[bool]uint32, xlen) + changed = true + } + + var mk bool + var mv uint32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uint32(dd.DecodeUint(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolUint64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]uint64) + v, changed := fastpathTV.DecMapBoolUint64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]uint64) + fastpathTV.DecMapBoolUint64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolUint64X(vp *map[bool]uint64, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolUint64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]uint64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[bool]uint64, xlen) + changed = true + } + + var mk bool + var mv uint64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeUint(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolUintptrR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]uintptr) + v, changed := fastpathTV.DecMapBoolUintptrV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]uintptr) + fastpathTV.DecMapBoolUintptrV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolUintptrX(vp *map[bool]uintptr, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolUintptrV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]uintptr, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[bool]uintptr, xlen) + changed = true + } + + var mk bool + var mv uintptr + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = uintptr(dd.DecodeUint(uintBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolIntR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]int) + v, changed := fastpathTV.DecMapBoolIntV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]int) + fastpathTV.DecMapBoolIntV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolIntX(vp *map[bool]int, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolIntV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolIntV(v map[bool]int, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]int, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[bool]int, xlen) + changed = true + } + + var mk bool + var mv int + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int(dd.DecodeInt(intBitsize)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolInt8R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]int8) + v, changed := fastpathTV.DecMapBoolInt8V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]int8) + fastpathTV.DecMapBoolInt8V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolInt8X(vp *map[bool]int8, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolInt8V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]int8, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2) + v = make(map[bool]int8, xlen) + changed = true + } + + var mk bool + var mv int8 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int8(dd.DecodeInt(8)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolInt16R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]int16) + v, changed := fastpathTV.DecMapBoolInt16V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]int16) + fastpathTV.DecMapBoolInt16V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolInt16X(vp *map[bool]int16, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolInt16V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]int16, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3) + v = make(map[bool]int16, xlen) + changed = true + } + + var mk bool + var mv int16 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int16(dd.DecodeInt(16)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolInt32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]int32) + v, changed := fastpathTV.DecMapBoolInt32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]int32) + fastpathTV.DecMapBoolInt32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolInt32X(vp *map[bool]int32, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolInt32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]int32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[bool]int32, xlen) + changed = true + } + + var mk bool + var mv int32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = int32(dd.DecodeInt(32)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolInt64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]int64) + v, changed := fastpathTV.DecMapBoolInt64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]int64) + fastpathTV.DecMapBoolInt64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolInt64X(vp *map[bool]int64, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolInt64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]int64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[bool]int64, xlen) + changed = true + } + + var mk bool + var mv int64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeInt(64) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolFloat32R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]float32) + v, changed := fastpathTV.DecMapBoolFloat32V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]float32) + fastpathTV.DecMapBoolFloat32V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolFloat32X(vp *map[bool]float32, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolFloat32V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]float32, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5) + v = make(map[bool]float32, xlen) + changed = true + } + + var mk bool + var mv float32 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = float32(dd.DecodeFloat(true)) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolFloat64R(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]float64) + v, changed := fastpathTV.DecMapBoolFloat64V(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]float64) + fastpathTV.DecMapBoolFloat64V(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolFloat64X(vp *map[bool]float64, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolFloat64V(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]float64, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9) + v = make(map[bool]float64, xlen) + changed = true + } + + var mk bool + var mv float64 + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeFloat(false) + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} + +func (f *decFnInfo) fastpathDecMapBoolBoolR(rv reflect.Value) { + if rv.CanAddr() { + vp := rv.Addr().Interface().(*map[bool]bool) + v, changed := fastpathTV.DecMapBoolBoolV(*vp, fastpathCheckNilFalse, true, f.d) + if changed { + *vp = v + } + } else { + v := rv.Interface().(map[bool]bool) + fastpathTV.DecMapBoolBoolV(v, fastpathCheckNilFalse, false, f.d) + } +} +func (f fastpathT) DecMapBoolBoolX(vp *map[bool]bool, checkNil bool, d *Decoder) { + v, changed := f.DecMapBoolBoolV(*vp, checkNil, true, d) + if changed { + *vp = v + } +} +func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, checkNil bool, canChange bool, + d *Decoder) (_ map[bool]bool, changed bool) { + dd := d.d + cr := d.cr + + if checkNil && dd.TryDecodeAsNil() { + if v != nil { + changed = true + } + return nil, changed + } + + containerLen := dd.ReadMapStart() + if canChange && v == nil { + xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2) + v = make(map[bool]bool, xlen) + changed = true + } + + var mk bool + var mv bool + if containerLen > 0 { + for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } else if containerLen < 0 { + for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } + mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } + mv = dd.DecodeBool() + if v != nil { + v[mk] = mv + } + } + } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + return v, changed +} diff --git a/vendor/github.com/ugorji/go/codec/fast-path.not.go b/vendor/github.com/ugorji/go/codec/fast-path.not.go new file mode 100644 index 00000000..63e59114 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/fast-path.not.go @@ -0,0 +1,34 @@ +// +build notfastpath + +package codec + +import "reflect" + +const fastpathEnabled = false + +// The generated fast-path code is very large, and adds a few seconds to the build time. +// This causes test execution, execution of small tools which use codec, etc +// to take a long time. +// +// To mitigate, we now support the notfastpath tag. +// This tag disables fastpath during build, allowing for faster build, test execution, +// short-program runs, etc. + +func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool { return false } +func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool { return false } +func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { return false } +func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool { return false } + +type fastpathT struct{} +type fastpathE struct { + rtid uintptr + rt reflect.Type + encfn func(*encFnInfo, reflect.Value) + decfn func(*decFnInfo, reflect.Value) +} +type fastpathA [0]fastpathE + +func (x fastpathA) index(rtid uintptr) int { return -1 } + +var fastpathAV fastpathA +var fastpathTV fastpathT diff --git a/vendor/github.com/ugorji/go/codec/gen-helper.generated.go b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go new file mode 100644 index 00000000..6ee80e46 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go @@ -0,0 +1,233 @@ +// //+build ignore + +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +// ************************************************************ +// DO NOT EDIT. +// THIS FILE IS AUTO-GENERATED from gen-helper.go.tmpl +// ************************************************************ + +package codec + +import ( + "encoding" + "reflect" +) + +// This file is used to generate helper code for codecgen. +// The values here i.e. genHelper(En|De)coder are not to be used directly by +// library users. They WILL change continuously and without notice. +// +// To help enforce this, we create an unexported type with exported members. +// The only way to get the type is via the one exported type that we control (somewhat). +// +// When static codecs are created for types, they will use this value +// to perform encoding or decoding of primitives or known slice or map types. + +// GenHelperEncoder is exported so that it can be used externally by codecgen. +// Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE. +func GenHelperEncoder(e *Encoder) (genHelperEncoder, encDriver) { + return genHelperEncoder{e: e}, e.e +} + +// GenHelperDecoder is exported so that it can be used externally by codecgen. +// Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE. +func GenHelperDecoder(d *Decoder) (genHelperDecoder, decDriver) { + return genHelperDecoder{d: d}, d.d +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +type genHelperEncoder struct { + e *Encoder + F fastpathT +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +type genHelperDecoder struct { + d *Decoder + F fastpathT +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) EncBasicHandle() *BasicHandle { + return f.e.h +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) EncBinary() bool { + return f.e.be // f.e.hh.isBinaryEncoding() +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) EncFallback(iv interface{}) { + // println(">>>>>>>>> EncFallback") + f.e.encodeI(iv, false, false) +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) EncTextMarshal(iv encoding.TextMarshaler) { + bs, fnerr := iv.MarshalText() + f.e.marshal(bs, fnerr, false, c_UTF8) +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) { + bs, fnerr := iv.MarshalJSON() + f.e.marshal(bs, fnerr, true, c_UTF8) +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) { + bs, fnerr := iv.MarshalBinary() + f.e.marshal(bs, fnerr, false, c_RAW) +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) TimeRtidIfBinc() uintptr { + if _, ok := f.e.hh.(*BincHandle); ok { + return timeTypId + } + return 0 +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) IsJSONHandle() bool { + return f.e.js +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) HasExtensions() bool { + return len(f.e.h.extHandle) != 0 +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) EncExt(v interface{}) (r bool) { + rt := reflect.TypeOf(v) + if rt.Kind() == reflect.Ptr { + rt = rt.Elem() + } + rtid := reflect.ValueOf(rt).Pointer() + if xfFn := f.e.h.getExt(rtid); xfFn != nil { + f.e.e.EncodeExt(v, xfFn.tag, xfFn.ext, f.e) + return true + } + return false +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) EncSendContainerState(c containerState) { + if f.e.cr != nil { + f.e.cr.sendContainerState(c) + } +} + +// ---------------- DECODER FOLLOWS ----------------- + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecBasicHandle() *BasicHandle { + return f.d.h +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecBinary() bool { + return f.d.be // f.d.hh.isBinaryEncoding() +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecSwallow() { + f.d.swallow() +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecScratchBuffer() []byte { + return f.d.b[:] +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecFallback(iv interface{}, chkPtr bool) { + // println(">>>>>>>>> DecFallback") + f.d.decodeI(iv, chkPtr, false, false, false) +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecSliceHelperStart() (decSliceHelper, int) { + return f.d.decSliceHelperStart() +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecStructFieldNotFound(index int, name string) { + f.d.structFieldNotFound(index, name) +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecArrayCannotExpand(sliceLen, streamLen int) { + f.d.arrayCannotExpand(sliceLen, streamLen) +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) { + fnerr := tm.UnmarshalText(f.d.d.DecodeBytes(f.d.b[:], true, true)) + if fnerr != nil { + panic(fnerr) + } +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) { + // bs := f.dd.DecodeBytes(f.d.b[:], true, true) + // grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself. + fnerr := tm.UnmarshalJSON(f.d.nextValueBytes()) + if fnerr != nil { + panic(fnerr) + } +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecBinaryUnmarshal(bm encoding.BinaryUnmarshaler) { + fnerr := bm.UnmarshalBinary(f.d.d.DecodeBytes(nil, false, true)) + if fnerr != nil { + panic(fnerr) + } +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) TimeRtidIfBinc() uintptr { + if _, ok := f.d.hh.(*BincHandle); ok { + return timeTypId + } + return 0 +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) IsJSONHandle() bool { + return f.d.js +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) HasExtensions() bool { + return len(f.d.h.extHandle) != 0 +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecExt(v interface{}) (r bool) { + rt := reflect.TypeOf(v).Elem() + rtid := reflect.ValueOf(rt).Pointer() + if xfFn := f.d.h.getExt(rtid); xfFn != nil { + f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext) + return true + } + return false +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int, truncated bool) { + return decInferLen(clen, maxlen, unit) +} + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecSendContainerState(c containerState) { + if f.d.cr != nil { + f.d.cr.sendContainerState(c) + } +} diff --git a/vendor/github.com/ugorji/go/codec/gen.generated.go b/vendor/github.com/ugorji/go/codec/gen.generated.go new file mode 100644 index 00000000..2ace97b7 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/gen.generated.go @@ -0,0 +1,175 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +// DO NOT EDIT. THIS FILE IS AUTO-GENERATED FROM gen-dec-(map|array).go.tmpl + +const genDecMapTmpl = ` +{{var "v"}} := *{{ .Varname }} +{{var "l"}} := r.ReadMapStart() +{{var "bh"}} := z.DecBasicHandle() +if {{var "v"}} == nil { + {{var "rl"}}, _ := z.DecInferLen({{var "l"}}, {{var "bh"}}.MaxInitLen, {{ .Size }}) + {{var "v"}} = make(map[{{ .KTyp }}]{{ .Typ }}, {{var "rl"}}) + *{{ .Varname }} = {{var "v"}} +} +var {{var "mk"}} {{ .KTyp }} +var {{var "mv"}} {{ .Typ }} +var {{var "mg"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool +if {{var "bh"}}.MapValueReset { + {{if decElemKindPtr}}{{var "mg"}} = true + {{else if decElemKindIntf}}if !{{var "bh"}}.InterfaceReset { {{var "mg"}} = true } + {{else if not decElemKindImmutable}}{{var "mg"}} = true + {{end}} } +if {{var "l"}} > 0 { +for {{var "j"}} := 0; {{var "j"}} < {{var "l"}}; {{var "j"}}++ { + z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) + {{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }} +{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} { + {{var "mk"}} = string({{var "bv"}}) + }{{ end }}{{if decElemKindPtr}} + {{var "ms"}} = true{{end}} + if {{var "mg"}} { + {{if decElemKindPtr}}{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{var "mk"}}] + if {{var "mok"}} { + {{var "ms"}} = false + } {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}} + } {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}} + z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }}) + {{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }} + if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil { + {{var "v"}}[{{var "mk"}}] = {{var "mv"}} + } +} +} else if {{var "l"}} < 0 { +for {{var "j"}} := 0; !r.CheckBreak(); {{var "j"}}++ { + z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) + {{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }} +{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} { + {{var "mk"}} = string({{var "bv"}}) + }{{ end }}{{if decElemKindPtr}} + {{var "ms"}} = true {{ end }} + if {{var "mg"}} { + {{if decElemKindPtr}}{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{var "mk"}}] + if {{var "mok"}} { + {{var "ms"}} = false + } {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}} + } {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}} + z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }}) + {{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }} + if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil { + {{var "v"}}[{{var "mk"}}] = {{var "mv"}} + } +} +} // else len==0: TODO: Should we clear map entries? +z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }}) +` + +const genDecListTmpl = ` +{{var "v"}} := {{if not isArray}}*{{end}}{{ .Varname }} +{{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}}{{if not isArray}} +var {{var "c"}} bool {{/* // changed */}} +_ = {{var "c"}}{{end}} +if {{var "l"}} == 0 { + {{if isSlice }}if {{var "v"}} == nil { + {{var "v"}} = []{{ .Typ }}{} + {{var "c"}} = true + } else if len({{var "v"}}) != 0 { + {{var "v"}} = {{var "v"}}[:0] + {{var "c"}} = true + } {{end}} {{if isChan }}if {{var "v"}} == nil { + {{var "v"}} = make({{ .CTyp }}, 0) + {{var "c"}} = true + } {{end}} +} else if {{var "l"}} > 0 { + {{if isChan }}if {{var "v"}} == nil { + {{var "rl"}}, _ = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }}) + {{var "v"}} = make({{ .CTyp }}, {{var "rl"}}) + {{var "c"}} = true + } + for {{var "r"}} := 0; {{var "r"}} < {{var "l"}}; {{var "r"}}++ { + {{var "h"}}.ElemContainerState({{var "r"}}) + var {{var "t"}} {{ .Typ }} + {{ $x := printf "%st%s" .TempVar .Rand }}{{ decLineVar $x }} + {{var "v"}} <- {{var "t"}} + } + {{ else }} var {{var "rr"}}, {{var "rl"}} int {{/* // num2read, length of slice/array/chan */}} + var {{var "rt"}} bool {{/* truncated */}} + _, _ = {{var "rl"}}, {{var "rt"}} + {{var "rr"}} = {{var "l"}} // len({{var "v"}}) + if {{var "l"}} > cap({{var "v"}}) { + {{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "l"}}) + {{ else }}{{if not .Immutable }} + {{var "rg"}} := len({{var "v"}}) > 0 + {{var "v2"}} := {{var "v"}} {{end}} + {{var "rl"}}, {{var "rt"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }}) + if {{var "rt"}} { + if {{var "rl"}} <= cap({{var "v"}}) { + {{var "v"}} = {{var "v"}}[:{{var "rl"}}] + } else { + {{var "v"}} = make([]{{ .Typ }}, {{var "rl"}}) + } + } else { + {{var "v"}} = make([]{{ .Typ }}, {{var "rl"}}) + } + {{var "c"}} = true + {{var "rr"}} = len({{var "v"}}) {{if not .Immutable }} + if {{var "rg"}} { copy({{var "v"}}, {{var "v2"}}) } {{end}} {{end}}{{/* end not Immutable, isArray */}} + } {{if isSlice }} else if {{var "l"}} != len({{var "v"}}) { + {{var "v"}} = {{var "v"}}[:{{var "l"}}] + {{var "c"}} = true + } {{end}} {{/* end isSlice:47 */}} + {{var "j"}} := 0 + for ; {{var "j"}} < {{var "rr"}} ; {{var "j"}}++ { + {{var "h"}}.ElemContainerState({{var "j"}}) + {{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }} + } + {{if isArray }}for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ { + {{var "h"}}.ElemContainerState({{var "j"}}) + z.DecSwallow() + } + {{ else }}if {{var "rt"}} { + for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ { + {{var "v"}} = append({{var "v"}}, {{ zero}}) + {{var "h"}}.ElemContainerState({{var "j"}}) + {{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }} + } + } {{end}} {{/* end isArray:56 */}} + {{end}} {{/* end isChan:16 */}} +} else { {{/* len < 0 */}} + {{var "j"}} := 0 + for ; !r.CheckBreak(); {{var "j"}}++ { + {{if isChan }} + {{var "h"}}.ElemContainerState({{var "j"}}) + var {{var "t"}} {{ .Typ }} + {{ $x := printf "%st%s" .TempVar .Rand }}{{ decLineVar $x }} + {{var "v"}} <- {{var "t"}} + {{ else }} + if {{var "j"}} >= len({{var "v"}}) { + {{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "j"}}+1) + {{ else }}{{var "v"}} = append({{var "v"}}, {{zero}})// var {{var "z"}} {{ .Typ }} + {{var "c"}} = true {{end}} + } + {{var "h"}}.ElemContainerState({{var "j"}}) + if {{var "j"}} < len({{var "v"}}) { + {{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }} + } else { + z.DecSwallow() + } + {{end}} + } + {{if isSlice }}if {{var "j"}} < len({{var "v"}}) { + {{var "v"}} = {{var "v"}}[:{{var "j"}}] + {{var "c"}} = true + } else if {{var "j"}} == 0 && {{var "v"}} == nil { + {{var "v"}} = []{{ .Typ }}{} + {{var "c"}} = true + }{{end}} +} +{{var "h"}}.End() +{{if not isArray }}if {{var "c"}} { + *{{ .Varname }} = {{var "v"}} +}{{end}} +` + diff --git a/vendor/github.com/ugorji/go/codec/gen.go b/vendor/github.com/ugorji/go/codec/gen.go new file mode 100644 index 00000000..e3998444 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/gen.go @@ -0,0 +1,1995 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "bytes" + "encoding/base64" + "errors" + "fmt" + "go/format" + "io" + "io/ioutil" + "math/rand" + "reflect" + "regexp" + "sort" + "strconv" + "strings" + "sync" + "text/template" + "time" + "unicode" + "unicode/utf8" +) + +// --------------------------------------------------- +// codecgen supports the full cycle of reflection-based codec: +// - RawExt +// - Builtins +// - Extensions +// - (Binary|Text|JSON)(Unm|M)arshal +// - generic by-kind +// +// This means that, for dynamic things, we MUST use reflection to at least get the reflect.Type. +// In those areas, we try to only do reflection or interface-conversion when NECESSARY: +// - Extensions, only if Extensions are configured. +// +// However, codecgen doesn't support the following: +// - Canonical option. (codecgen IGNORES it currently) +// This is just because it has not been implemented. +// +// During encode/decode, Selfer takes precedence. +// A type implementing Selfer will know how to encode/decode itself statically. +// +// The following field types are supported: +// array: [n]T +// slice: []T +// map: map[K]V +// primitive: [u]int[n], float(32|64), bool, string +// struct +// +// --------------------------------------------------- +// Note that a Selfer cannot call (e|d).(En|De)code on itself, +// as this will cause a circular reference, as (En|De)code will call Selfer methods. +// Any type that implements Selfer must implement completely and not fallback to (En|De)code. +// +// In addition, code in this file manages the generation of fast-path implementations of +// encode/decode of slices/maps of primitive keys/values. +// +// Users MUST re-generate their implementations whenever the code shape changes. +// The generated code will panic if it was generated with a version older than the supporting library. +// --------------------------------------------------- +// +// codec framework is very feature rich. +// When encoding or decoding into an interface, it depends on the runtime type of the interface. +// The type of the interface may be a named type, an extension, etc. +// Consequently, we fallback to runtime codec for encoding/decoding interfaces. +// In addition, we fallback for any value which cannot be guaranteed at runtime. +// This allows us support ANY value, including any named types, specifically those which +// do not implement our interfaces (e.g. Selfer). +// +// This explains some slowness compared to other code generation codecs (e.g. msgp). +// This reduction in speed is only seen when your refers to interfaces, +// e.g. type T struct { A interface{}; B []interface{}; C map[string]interface{} } +// +// codecgen will panic if the file was generated with an old version of the library in use. +// +// Note: +// It was a conscious decision to have gen.go always explicitly call EncodeNil or TryDecodeAsNil. +// This way, there isn't a function call overhead just to see that we should not enter a block of code. + +// GenVersion is the current version of codecgen. +// +// NOTE: Increment this value each time codecgen changes fundamentally. +// Fundamental changes are: +// - helper methods change (signature change, new ones added, some removed, etc) +// - codecgen command line changes +// +// v1: Initial Version +// v2: +// v3: Changes for Kubernetes: +// changes in signature of some unpublished helper methods and codecgen cmdline arguments. +// v4: Removed separator support from (en|de)cDriver, and refactored codec(gen) +// v5: changes to support faster json decoding. Let encoder/decoder maintain state of collections. +const GenVersion = 5 + +const ( + genCodecPkg = "codec1978" + genTempVarPfx = "yy" + genTopLevelVarName = "x" + + // ignore canBeNil parameter, and always set to true. + // This is because nil can appear anywhere, so we should always check. + genAnythingCanBeNil = true + + // if genUseOneFunctionForDecStructMap, make a single codecDecodeSelferFromMap function; + // else make codecDecodeSelferFromMap{LenPrefix,CheckBreak} so that conditionals + // are not executed a lot. + // + // From testing, it didn't make much difference in runtime, so keep as true (one function only) + genUseOneFunctionForDecStructMap = true +) + +type genStructMapStyle uint8 + +const ( + genStructMapStyleConsolidated genStructMapStyle = iota + genStructMapStyleLenPrefix + genStructMapStyleCheckBreak +) + +var ( + genAllTypesSamePkgErr = errors.New("All types must be in the same package") + genExpectArrayOrMapErr = errors.New("unexpected type. Expecting array/map/slice") + genBase64enc = base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789__") + genQNameRegex = regexp.MustCompile(`[A-Za-z_.]+`) + genCheckVendor bool +) + +// genRunner holds some state used during a Gen run. +type genRunner struct { + w io.Writer // output + c uint64 // counter used for generating varsfx + t []reflect.Type // list of types to run selfer on + + tc reflect.Type // currently running selfer on this type + te map[uintptr]bool // types for which the encoder has been created + td map[uintptr]bool // types for which the decoder has been created + cp string // codec import path + + im map[string]reflect.Type // imports to add + imn map[string]string // package names of imports to add + imc uint64 // counter for import numbers + + is map[reflect.Type]struct{} // types seen during import search + bp string // base PkgPath, for which we are generating for + + cpfx string // codec package prefix + unsafe bool // is unsafe to be used in generated code? + + tm map[reflect.Type]struct{} // types for which enc/dec must be generated + ts []reflect.Type // types for which enc/dec must be generated + + xs string // top level variable/constant suffix + hn string // fn helper type name + + ti *TypeInfos + // rr *rand.Rand // random generator for file-specific types +} + +// Gen will write a complete go file containing Selfer implementations for each +// type passed. All the types must be in the same package. +// +// Library users: *DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.* +func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeInfos, typ ...reflect.Type) { + // trim out all types which already implement Selfer + typ2 := make([]reflect.Type, 0, len(typ)) + for _, t := range typ { + if reflect.PtrTo(t).Implements(selferTyp) || t.Implements(selferTyp) { + continue + } + typ2 = append(typ2, t) + } + typ = typ2 + + if len(typ) == 0 { + return + } + x := genRunner{ + unsafe: useUnsafe, + w: w, + t: typ, + te: make(map[uintptr]bool), + td: make(map[uintptr]bool), + im: make(map[string]reflect.Type), + imn: make(map[string]string), + is: make(map[reflect.Type]struct{}), + tm: make(map[reflect.Type]struct{}), + ts: []reflect.Type{}, + bp: genImportPath(typ[0]), + xs: uid, + ti: ti, + } + if x.ti == nil { + x.ti = defTypeInfos + } + if x.xs == "" { + rr := rand.New(rand.NewSource(time.Now().UnixNano())) + x.xs = strconv.FormatInt(rr.Int63n(9999), 10) + } + + // gather imports first: + x.cp = genImportPath(reflect.TypeOf(x)) + x.imn[x.cp] = genCodecPkg + for _, t := range typ { + // fmt.Printf("###########: PkgPath: '%v', Name: '%s'\n", genImportPath(t), t.Name()) + if genImportPath(t) != x.bp { + panic(genAllTypesSamePkgErr) + } + x.genRefPkgs(t) + } + if buildTags != "" { + x.line("//+build " + buildTags) + x.line("") + } + x.line(` + +// ************************************************************ +// DO NOT EDIT. +// THIS FILE IS AUTO-GENERATED BY codecgen. +// ************************************************************ + +`) + x.line("package " + pkgName) + x.line("") + x.line("import (") + if x.cp != x.bp { + x.cpfx = genCodecPkg + "." + x.linef("%s \"%s\"", genCodecPkg, x.cp) + } + // use a sorted set of im keys, so that we can get consistent output + imKeys := make([]string, 0, len(x.im)) + for k, _ := range x.im { + imKeys = append(imKeys, k) + } + sort.Strings(imKeys) + for _, k := range imKeys { // for k, _ := range x.im { + x.linef("%s \"%s\"", x.imn[k], k) + } + // add required packages + for _, k := range [...]string{"reflect", "unsafe", "runtime", "fmt", "errors"} { + if _, ok := x.im[k]; !ok { + if k == "unsafe" && !x.unsafe { + continue + } + x.line("\"" + k + "\"") + } + } + x.line(")") + x.line("") + + x.line("const (") + x.linef("// ----- content types ----") + x.linef("codecSelferC_UTF8%s = %v", x.xs, int64(c_UTF8)) + x.linef("codecSelferC_RAW%s = %v", x.xs, int64(c_RAW)) + x.linef("// ----- value types used ----") + x.linef("codecSelferValueTypeArray%s = %v", x.xs, int64(valueTypeArray)) + x.linef("codecSelferValueTypeMap%s = %v", x.xs, int64(valueTypeMap)) + x.linef("// ----- containerStateValues ----") + x.linef("codecSelfer_containerMapKey%s = %v", x.xs, int64(containerMapKey)) + x.linef("codecSelfer_containerMapValue%s = %v", x.xs, int64(containerMapValue)) + x.linef("codecSelfer_containerMapEnd%s = %v", x.xs, int64(containerMapEnd)) + x.linef("codecSelfer_containerArrayElem%s = %v", x.xs, int64(containerArrayElem)) + x.linef("codecSelfer_containerArrayEnd%s = %v", x.xs, int64(containerArrayEnd)) + x.line(")") + x.line("var (") + x.line("codecSelferBitsize" + x.xs + " = uint8(reflect.TypeOf(uint(0)).Bits())") + x.line("codecSelferOnlyMapOrArrayEncodeToStructErr" + x.xs + " = errors.New(`only encoded map or array can be decoded into a struct`)") + x.line(")") + x.line("") + + if x.unsafe { + x.line("type codecSelferUnsafeString" + x.xs + " struct { Data uintptr; Len int}") + x.line("") + } + x.hn = "codecSelfer" + x.xs + x.line("type " + x.hn + " struct{}") + x.line("") + + x.varsfxreset() + x.line("func init() {") + x.linef("if %sGenVersion != %v {", x.cpfx, GenVersion) + x.line("_, file, _, _ := runtime.Caller(0)") + x.line(`err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v", `) + x.linef(`%v, %sGenVersion, file)`, GenVersion, x.cpfx) + x.line("panic(err)") + x.linef("}") + x.line("if false { // reference the types, but skip this branch at build/run time") + var n int + // for k, t := range x.im { + for _, k := range imKeys { + t := x.im[k] + x.linef("var v%v %s.%s", n, x.imn[k], t.Name()) + n++ + } + if x.unsafe { + x.linef("var v%v unsafe.Pointer", n) + n++ + } + if n > 0 { + x.out("_") + for i := 1; i < n; i++ { + x.out(", _") + } + x.out(" = v0") + for i := 1; i < n; i++ { + x.outf(", v%v", i) + } + } + x.line("} ") // close if false + x.line("}") // close init + x.line("") + + // generate rest of type info + for _, t := range typ { + x.tc = t + x.selfer(true) + x.selfer(false) + } + + for _, t := range x.ts { + rtid := reflect.ValueOf(t).Pointer() + // generate enc functions for all these slice/map types. + x.varsfxreset() + x.linef("func (x %s) enc%s(v %s%s, e *%sEncoder) {", x.hn, x.genMethodNameT(t), x.arr2str(t, "*"), x.genTypeName(t), x.cpfx) + x.genRequiredMethodVars(true) + switch t.Kind() { + case reflect.Array, reflect.Slice, reflect.Chan: + x.encListFallback("v", t) + case reflect.Map: + x.encMapFallback("v", t) + default: + panic(genExpectArrayOrMapErr) + } + x.line("}") + x.line("") + + // generate dec functions for all these slice/map types. + x.varsfxreset() + x.linef("func (x %s) dec%s(v *%s, d *%sDecoder) {", x.hn, x.genMethodNameT(t), x.genTypeName(t), x.cpfx) + x.genRequiredMethodVars(false) + switch t.Kind() { + case reflect.Array, reflect.Slice, reflect.Chan: + x.decListFallback("v", rtid, t) + case reflect.Map: + x.decMapFallback("v", rtid, t) + default: + panic(genExpectArrayOrMapErr) + } + x.line("}") + x.line("") + } + + x.line("") +} + +func (x *genRunner) checkForSelfer(t reflect.Type, varname string) bool { + // return varname != genTopLevelVarName && t != x.tc + // the only time we checkForSelfer is if we are not at the TOP of the generated code. + return varname != genTopLevelVarName +} + +func (x *genRunner) arr2str(t reflect.Type, s string) string { + if t.Kind() == reflect.Array { + return s + } + return "" +} + +func (x *genRunner) genRequiredMethodVars(encode bool) { + x.line("var h " + x.hn) + if encode { + x.line("z, r := " + x.cpfx + "GenHelperEncoder(e)") + } else { + x.line("z, r := " + x.cpfx + "GenHelperDecoder(d)") + } + x.line("_, _, _ = h, z, r") +} + +func (x *genRunner) genRefPkgs(t reflect.Type) { + if _, ok := x.is[t]; ok { + return + } + // fmt.Printf(">>>>>>: PkgPath: '%v', Name: '%s'\n", genImportPath(t), t.Name()) + x.is[t] = struct{}{} + tpkg, tname := genImportPath(t), t.Name() + if tpkg != "" && tpkg != x.bp && tpkg != x.cp && tname != "" && tname[0] >= 'A' && tname[0] <= 'Z' { + if _, ok := x.im[tpkg]; !ok { + x.im[tpkg] = t + if idx := strings.LastIndex(tpkg, "/"); idx < 0 { + x.imn[tpkg] = tpkg + } else { + x.imc++ + x.imn[tpkg] = "pkg" + strconv.FormatUint(x.imc, 10) + "_" + genGoIdentifier(tpkg[idx+1:], false) + } + } + } + switch t.Kind() { + case reflect.Array, reflect.Slice, reflect.Ptr, reflect.Chan: + x.genRefPkgs(t.Elem()) + case reflect.Map: + x.genRefPkgs(t.Elem()) + x.genRefPkgs(t.Key()) + case reflect.Struct: + for i := 0; i < t.NumField(); i++ { + if fname := t.Field(i).Name; fname != "" && fname[0] >= 'A' && fname[0] <= 'Z' { + x.genRefPkgs(t.Field(i).Type) + } + } + } +} + +func (x *genRunner) line(s string) { + x.out(s) + if len(s) == 0 || s[len(s)-1] != '\n' { + x.out("\n") + } +} + +func (x *genRunner) varsfx() string { + x.c++ + return strconv.FormatUint(x.c, 10) +} + +func (x *genRunner) varsfxreset() { + x.c = 0 +} + +func (x *genRunner) out(s string) { + if _, err := io.WriteString(x.w, s); err != nil { + panic(err) + } +} + +func (x *genRunner) linef(s string, params ...interface{}) { + x.line(fmt.Sprintf(s, params...)) +} + +func (x *genRunner) outf(s string, params ...interface{}) { + x.out(fmt.Sprintf(s, params...)) +} + +func (x *genRunner) genTypeName(t reflect.Type) (n string) { + // defer func() { fmt.Printf(">>>> ####: genTypeName: t: %v, name: '%s'\n", t, n) }() + + // if the type has a PkgPath, which doesn't match the current package, + // then include it. + // We cannot depend on t.String() because it includes current package, + // or t.PkgPath because it includes full import path, + // + var ptrPfx string + for t.Kind() == reflect.Ptr { + ptrPfx += "*" + t = t.Elem() + } + if tn := t.Name(); tn != "" { + return ptrPfx + x.genTypeNamePrim(t) + } + switch t.Kind() { + case reflect.Map: + return ptrPfx + "map[" + x.genTypeName(t.Key()) + "]" + x.genTypeName(t.Elem()) + case reflect.Slice: + return ptrPfx + "[]" + x.genTypeName(t.Elem()) + case reflect.Array: + return ptrPfx + "[" + strconv.FormatInt(int64(t.Len()), 10) + "]" + x.genTypeName(t.Elem()) + case reflect.Chan: + return ptrPfx + t.ChanDir().String() + " " + x.genTypeName(t.Elem()) + default: + if t == intfTyp { + return ptrPfx + "interface{}" + } else { + return ptrPfx + x.genTypeNamePrim(t) + } + } +} + +func (x *genRunner) genTypeNamePrim(t reflect.Type) (n string) { + if t.Name() == "" { + return t.String() + } else if genImportPath(t) == "" || genImportPath(t) == genImportPath(x.tc) { + return t.Name() + } else { + return x.imn[genImportPath(t)] + "." + t.Name() + // return t.String() // best way to get the package name inclusive + } +} + +func (x *genRunner) genZeroValueR(t reflect.Type) string { + // if t is a named type, w + switch t.Kind() { + case reflect.Ptr, reflect.Interface, reflect.Chan, reflect.Func, + reflect.Slice, reflect.Map, reflect.Invalid: + return "nil" + case reflect.Bool: + return "false" + case reflect.String: + return `""` + case reflect.Struct, reflect.Array: + return x.genTypeName(t) + "{}" + default: // all numbers + return "0" + } +} + +func (x *genRunner) genMethodNameT(t reflect.Type) (s string) { + return genMethodNameT(t, x.tc) +} + +func (x *genRunner) selfer(encode bool) { + t := x.tc + t0 := t + // always make decode use a pointer receiver, + // and structs always use a ptr receiver (encode|decode) + isptr := !encode || t.Kind() == reflect.Struct + x.varsfxreset() + fnSigPfx := "func (x " + if isptr { + fnSigPfx += "*" + } + fnSigPfx += x.genTypeName(t) + + x.out(fnSigPfx) + if isptr { + t = reflect.PtrTo(t) + } + if encode { + x.line(") CodecEncodeSelf(e *" + x.cpfx + "Encoder) {") + x.genRequiredMethodVars(true) + // x.enc(genTopLevelVarName, t) + x.encVar(genTopLevelVarName, t) + } else { + x.line(") CodecDecodeSelf(d *" + x.cpfx + "Decoder) {") + x.genRequiredMethodVars(false) + // do not use decVar, as there is no need to check TryDecodeAsNil + // or way to elegantly handle that, and also setting it to a + // non-nil value doesn't affect the pointer passed. + // x.decVar(genTopLevelVarName, t, false) + x.dec(genTopLevelVarName, t0) + } + x.line("}") + x.line("") + + if encode || t0.Kind() != reflect.Struct { + return + } + + // write is containerMap + if genUseOneFunctionForDecStructMap { + x.out(fnSigPfx) + x.line(") codecDecodeSelfFromMap(l int, d *" + x.cpfx + "Decoder) {") + x.genRequiredMethodVars(false) + x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, genStructMapStyleConsolidated) + x.line("}") + x.line("") + } else { + x.out(fnSigPfx) + x.line(") codecDecodeSelfFromMapLenPrefix(l int, d *" + x.cpfx + "Decoder) {") + x.genRequiredMethodVars(false) + x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, genStructMapStyleLenPrefix) + x.line("}") + x.line("") + + x.out(fnSigPfx) + x.line(") codecDecodeSelfFromMapCheckBreak(l int, d *" + x.cpfx + "Decoder) {") + x.genRequiredMethodVars(false) + x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, genStructMapStyleCheckBreak) + x.line("}") + x.line("") + } + + // write containerArray + x.out(fnSigPfx) + x.line(") codecDecodeSelfFromArray(l int, d *" + x.cpfx + "Decoder) {") + x.genRequiredMethodVars(false) + x.decStructArray(genTopLevelVarName, "l", "return", reflect.ValueOf(t0).Pointer(), t0) + x.line("}") + x.line("") + +} + +// used for chan, array, slice, map +func (x *genRunner) xtraSM(varname string, encode bool, t reflect.Type) { + if encode { + x.linef("h.enc%s((%s%s)(%s), e)", x.genMethodNameT(t), x.arr2str(t, "*"), x.genTypeName(t), varname) + } else { + x.linef("h.dec%s((*%s)(%s), d)", x.genMethodNameT(t), x.genTypeName(t), varname) + } + x.registerXtraT(t) +} + +func (x *genRunner) registerXtraT(t reflect.Type) { + // recursively register the types + if _, ok := x.tm[t]; ok { + return + } + var tkey reflect.Type + switch t.Kind() { + case reflect.Chan, reflect.Slice, reflect.Array: + case reflect.Map: + tkey = t.Key() + default: + return + } + x.tm[t] = struct{}{} + x.ts = append(x.ts, t) + // check if this refers to any xtra types eg. a slice of array: add the array + x.registerXtraT(t.Elem()) + if tkey != nil { + x.registerXtraT(tkey) + } +} + +// encVar will encode a variable. +// The parameter, t, is the reflect.Type of the variable itself +func (x *genRunner) encVar(varname string, t reflect.Type) { + // fmt.Printf(">>>>>> varname: %s, t: %v\n", varname, t) + var checkNil bool + switch t.Kind() { + case reflect.Ptr, reflect.Interface, reflect.Slice, reflect.Map, reflect.Chan: + checkNil = true + } + if checkNil { + x.linef("if %s == nil { r.EncodeNil() } else { ", varname) + } + switch t.Kind() { + case reflect.Ptr: + switch t.Elem().Kind() { + case reflect.Struct, reflect.Array: + x.enc(varname, genNonPtr(t)) + default: + i := x.varsfx() + x.line(genTempVarPfx + i + " := *" + varname) + x.enc(genTempVarPfx+i, genNonPtr(t)) + } + case reflect.Struct, reflect.Array: + i := x.varsfx() + x.line(genTempVarPfx + i + " := &" + varname) + x.enc(genTempVarPfx+i, t) + default: + x.enc(varname, t) + } + + if checkNil { + x.line("}") + } + +} + +// enc will encode a variable (varname) of type t, +// except t is of kind reflect.Struct or reflect.Array, wherein varname is of type ptrTo(T) (to prevent copying) +func (x *genRunner) enc(varname string, t reflect.Type) { + rtid := reflect.ValueOf(t).Pointer() + // We call CodecEncodeSelf if one of the following are honored: + // - the type already implements Selfer, call that + // - the type has a Selfer implementation just created, use that + // - the type is in the list of the ones we will generate for, but it is not currently being generated + + mi := x.varsfx() + tptr := reflect.PtrTo(t) + tk := t.Kind() + if x.checkForSelfer(t, varname) { + if tk == reflect.Array || tk == reflect.Struct { // varname is of type *T + if tptr.Implements(selferTyp) || t.Implements(selferTyp) { + x.line(varname + ".CodecEncodeSelf(e)") + return + } + } else { // varname is of type T + if t.Implements(selferTyp) { + x.line(varname + ".CodecEncodeSelf(e)") + return + } else if tptr.Implements(selferTyp) { + x.linef("%ssf%s := &%s", genTempVarPfx, mi, varname) + x.linef("%ssf%s.CodecEncodeSelf(e)", genTempVarPfx, mi) + return + } + } + + if _, ok := x.te[rtid]; ok { + x.line(varname + ".CodecEncodeSelf(e)") + return + } + } + + inlist := false + for _, t0 := range x.t { + if t == t0 { + inlist = true + if x.checkForSelfer(t, varname) { + x.line(varname + ".CodecEncodeSelf(e)") + return + } + break + } + } + + var rtidAdded bool + if t == x.tc { + x.te[rtid] = true + rtidAdded = true + } + + // check if + // - type is RawExt + // - the type implements (Text|JSON|Binary)(Unm|M)arshal + x.linef("%sm%s := z.EncBinary()", genTempVarPfx, mi) + x.linef("_ = %sm%s", genTempVarPfx, mi) + x.line("if false {") //start if block + defer func() { x.line("}") }() //end if block + + if t == rawExtTyp { + x.linef("} else { r.EncodeRawExt(%v, e)", varname) + return + } + // HACK: Support for Builtins. + // Currently, only Binc supports builtins, and the only builtin type is time.Time. + // Have a method that returns the rtid for time.Time if Handle is Binc. + if t == timeTyp { + vrtid := genTempVarPfx + "m" + x.varsfx() + x.linef("} else if %s := z.TimeRtidIfBinc(); %s != 0 { ", vrtid, vrtid) + x.linef("r.EncodeBuiltin(%s, %s)", vrtid, varname) + } + // only check for extensions if the type is named, and has a packagePath. + if genImportPath(t) != "" && t.Name() != "" { + // first check if extensions are configued, before doing the interface conversion + x.linef("} else if z.HasExtensions() && z.EncExt(%s) {", varname) + } + if tk == reflect.Array || tk == reflect.Struct { // varname is of type *T + if t.Implements(binaryMarshalerTyp) || tptr.Implements(binaryMarshalerTyp) { + x.linef("} else if %sm%s { z.EncBinaryMarshal(%v) ", genTempVarPfx, mi, varname) + } + if t.Implements(jsonMarshalerTyp) || tptr.Implements(jsonMarshalerTyp) { + x.linef("} else if !%sm%s && z.IsJSONHandle() { z.EncJSONMarshal(%v) ", genTempVarPfx, mi, varname) + } else if t.Implements(textMarshalerTyp) || tptr.Implements(textMarshalerTyp) { + x.linef("} else if !%sm%s { z.EncTextMarshal(%v) ", genTempVarPfx, mi, varname) + } + } else { // varname is of type T + if t.Implements(binaryMarshalerTyp) { + x.linef("} else if %sm%s { z.EncBinaryMarshal(%v) ", genTempVarPfx, mi, varname) + } else if tptr.Implements(binaryMarshalerTyp) { + x.linef("} else if %sm%s { z.EncBinaryMarshal(&%v) ", genTempVarPfx, mi, varname) + } + if t.Implements(jsonMarshalerTyp) { + x.linef("} else if !%sm%s && z.IsJSONHandle() { z.EncJSONMarshal(%v) ", genTempVarPfx, mi, varname) + } else if tptr.Implements(jsonMarshalerTyp) { + x.linef("} else if !%sm%s && z.IsJSONHandle() { z.EncJSONMarshal(&%v) ", genTempVarPfx, mi, varname) + } else if t.Implements(textMarshalerTyp) { + x.linef("} else if !%sm%s { z.EncTextMarshal(%v) ", genTempVarPfx, mi, varname) + } else if tptr.Implements(textMarshalerTyp) { + x.linef("} else if !%sm%s { z.EncTextMarshal(&%v) ", genTempVarPfx, mi, varname) + } + } + x.line("} else {") + + switch t.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + x.line("r.EncodeInt(int64(" + varname + "))") + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + x.line("r.EncodeUint(uint64(" + varname + "))") + case reflect.Float32: + x.line("r.EncodeFloat32(float32(" + varname + "))") + case reflect.Float64: + x.line("r.EncodeFloat64(float64(" + varname + "))") + case reflect.Bool: + x.line("r.EncodeBool(bool(" + varname + "))") + case reflect.String: + x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + ", string(" + varname + "))") + case reflect.Chan: + x.xtraSM(varname, true, t) + // x.encListFallback(varname, rtid, t) + case reflect.Array: + x.xtraSM(varname, true, t) + case reflect.Slice: + // if nil, call dedicated function + // if a []uint8, call dedicated function + // if a known fastpath slice, call dedicated function + // else write encode function in-line. + // - if elements are primitives or Selfers, call dedicated function on each member. + // - else call Encoder.encode(XXX) on it. + if rtid == uint8SliceTypId { + x.line("r.EncodeStringBytes(codecSelferC_RAW" + x.xs + ", []byte(" + varname + "))") + } else if fastpathAV.index(rtid) != -1 { + g := x.newGenV(t) + x.line("z.F." + g.MethodNamePfx("Enc", false) + "V(" + varname + ", false, e)") + } else { + x.xtraSM(varname, true, t) + // x.encListFallback(varname, rtid, t) + } + case reflect.Map: + // if nil, call dedicated function + // if a known fastpath map, call dedicated function + // else write encode function in-line. + // - if elements are primitives or Selfers, call dedicated function on each member. + // - else call Encoder.encode(XXX) on it. + // x.line("if " + varname + " == nil { \nr.EncodeNil()\n } else { ") + if fastpathAV.index(rtid) != -1 { + g := x.newGenV(t) + x.line("z.F." + g.MethodNamePfx("Enc", false) + "V(" + varname + ", false, e)") + } else { + x.xtraSM(varname, true, t) + // x.encMapFallback(varname, rtid, t) + } + case reflect.Struct: + if !inlist { + delete(x.te, rtid) + x.line("z.EncFallback(" + varname + ")") + break + } + x.encStruct(varname, rtid, t) + default: + if rtidAdded { + delete(x.te, rtid) + } + x.line("z.EncFallback(" + varname + ")") + } +} + +func (x *genRunner) encZero(t reflect.Type) { + switch t.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + x.line("r.EncodeInt(0)") + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + x.line("r.EncodeUint(0)") + case reflect.Float32: + x.line("r.EncodeFloat32(0)") + case reflect.Float64: + x.line("r.EncodeFloat64(0)") + case reflect.Bool: + x.line("r.EncodeBool(false)") + case reflect.String: + x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + `, "")`) + default: + x.line("r.EncodeNil()") + } +} + +func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) { + // Use knowledge from structfieldinfo (mbs, encodable fields. Ignore omitempty. ) + // replicate code in kStruct i.e. for each field, deref type to non-pointer, and call x.enc on it + + // if t === type currently running selfer on, do for all + ti := x.ti.get(rtid, t) + i := x.varsfx() + sepVarname := genTempVarPfx + "sep" + i + numfieldsvar := genTempVarPfx + "q" + i + ti2arrayvar := genTempVarPfx + "r" + i + struct2arrvar := genTempVarPfx + "2arr" + i + + x.line(sepVarname + " := !z.EncBinary()") + x.linef("%s := z.EncBasicHandle().StructToArray", struct2arrvar) + tisfi := ti.sfip // always use sequence from file. decStruct expects same thing. + // due to omitEmpty, we need to calculate the + // number of non-empty things we write out first. + // This is required as we need to pre-determine the size of the container, + // to support length-prefixing. + x.linef("var %s [%v]bool", numfieldsvar, len(tisfi)) + x.linef("_, _, _ = %s, %s, %s", sepVarname, numfieldsvar, struct2arrvar) + x.linef("const %s bool = %v", ti2arrayvar, ti.toArray) + nn := 0 + for j, si := range tisfi { + if !si.omitEmpty { + nn++ + continue + } + var t2 reflect.StructField + var omitline string + if si.i != -1 { + t2 = t.Field(int(si.i)) + } else { + t2typ := t + varname3 := varname + for _, ix := range si.is { + for t2typ.Kind() == reflect.Ptr { + t2typ = t2typ.Elem() + } + t2 = t2typ.Field(ix) + t2typ = t2.Type + varname3 = varname3 + "." + t2.Name + if t2typ.Kind() == reflect.Ptr { + omitline += varname3 + " != nil && " + } + } + } + // never check omitEmpty on a struct type, as it may contain uncomparable map/slice/etc. + // also, for maps/slices/arrays, check if len ! 0 (not if == zero value) + switch t2.Type.Kind() { + case reflect.Struct: + omitline += " true" + case reflect.Map, reflect.Slice, reflect.Array, reflect.Chan: + omitline += "len(" + varname + "." + t2.Name + ") != 0" + default: + omitline += varname + "." + t2.Name + " != " + x.genZeroValueR(t2.Type) + } + x.linef("%s[%v] = %s", numfieldsvar, j, omitline) + } + x.linef("var %snn%s int", genTempVarPfx, i) + x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray { + x.line("r.EncodeArrayStart(" + strconv.FormatInt(int64(len(tisfi)), 10) + ")") + x.linef("} else {") // if not ti.toArray + x.linef("%snn%s = %v", genTempVarPfx, i, nn) + x.linef("for _, b := range %s { if b { %snn%s++ } }", numfieldsvar, genTempVarPfx, i) + x.linef("r.EncodeMapStart(%snn%s)", genTempVarPfx, i) + x.linef("%snn%s = %v", genTempVarPfx, i, 0) + // x.line("r.EncodeMapStart(" + strconv.FormatInt(int64(len(tisfi)), 10) + ")") + x.line("}") // close if not StructToArray + + for j, si := range tisfi { + i := x.varsfx() + isNilVarName := genTempVarPfx + "n" + i + var labelUsed bool + var t2 reflect.StructField + if si.i != -1 { + t2 = t.Field(int(si.i)) + } else { + t2typ := t + varname3 := varname + for _, ix := range si.is { + // fmt.Printf("%%%% %v, ix: %v\n", t2typ, ix) + for t2typ.Kind() == reflect.Ptr { + t2typ = t2typ.Elem() + } + t2 = t2typ.Field(ix) + t2typ = t2.Type + varname3 = varname3 + "." + t2.Name + if t2typ.Kind() == reflect.Ptr { + if !labelUsed { + x.line("var " + isNilVarName + " bool") + } + x.line("if " + varname3 + " == nil { " + isNilVarName + " = true ") + x.line("goto LABEL" + i) + x.line("}") + labelUsed = true + // "varname3 = new(" + x.genTypeName(t3.Elem()) + ") }") + } + } + // t2 = t.FieldByIndex(si.is) + } + if labelUsed { + x.line("LABEL" + i + ":") + } + // if the type of the field is a Selfer, or one of the ones + + x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray + if labelUsed { + x.line("if " + isNilVarName + " { r.EncodeNil() } else { ") + } + x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs) + if si.omitEmpty { + x.linef("if %s[%v] {", numfieldsvar, j) + } + x.encVar(varname+"."+t2.Name, t2.Type) + if si.omitEmpty { + x.linef("} else {") + x.encZero(t2.Type) + x.linef("}") + } + if labelUsed { + x.line("}") + } + + x.linef("} else {") // if not ti.toArray + + if si.omitEmpty { + x.linef("if %s[%v] {", numfieldsvar, j) + } + x.linef("z.EncSendContainerState(codecSelfer_containerMapKey%s)", x.xs) + x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + ", string(\"" + si.encName + "\"))") + x.linef("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs) + if labelUsed { + x.line("if " + isNilVarName + " { r.EncodeNil() } else { ") + x.encVar(varname+"."+t2.Name, t2.Type) + x.line("}") + } else { + x.encVar(varname+"."+t2.Name, t2.Type) + } + if si.omitEmpty { + x.line("}") + } + x.linef("} ") // end if/else ti.toArray + } + x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray { + x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs) + x.line("} else {") + x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs) + x.line("}") + +} + +func (x *genRunner) encListFallback(varname string, t reflect.Type) { + i := x.varsfx() + g := genTempVarPfx + x.line("r.EncodeArrayStart(len(" + varname + "))") + if t.Kind() == reflect.Chan { + x.linef("for %si%s, %si2%s := 0, len(%s); %si%s < %si2%s; %si%s++ {", g, i, g, i, varname, g, i, g, i, g, i) + x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs) + x.linef("%sv%s := <-%s", g, i, varname) + } else { + // x.linef("for %si%s, %sv%s := range %s {", genTempVarPfx, i, genTempVarPfx, i, varname) + x.linef("for _, %sv%s := range %s {", genTempVarPfx, i, varname) + x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs) + } + x.encVar(genTempVarPfx+"v"+i, t.Elem()) + x.line("}") + x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs) +} + +func (x *genRunner) encMapFallback(varname string, t reflect.Type) { + // TODO: expand this to handle canonical. + i := x.varsfx() + x.line("r.EncodeMapStart(len(" + varname + "))") + x.linef("for %sk%s, %sv%s := range %s {", genTempVarPfx, i, genTempVarPfx, i, varname) + // x.line("for " + genTempVarPfx + "k" + i + ", " + genTempVarPfx + "v" + i + " := range " + varname + " {") + x.linef("z.EncSendContainerState(codecSelfer_containerMapKey%s)", x.xs) + x.encVar(genTempVarPfx+"k"+i, t.Key()) + x.linef("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs) + x.encVar(genTempVarPfx+"v"+i, t.Elem()) + x.line("}") + x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs) +} + +func (x *genRunner) decVar(varname string, t reflect.Type, canBeNil bool) { + // We only encode as nil if a nillable value. + // This removes some of the wasted checks for TryDecodeAsNil. + // We need to think about this more, to see what happens if omitempty, etc + // cause a nil value to be stored when something is expected. + // This could happen when decoding from a struct encoded as an array. + // For that, decVar should be called with canNil=true, to force true as its value. + i := x.varsfx() + if !canBeNil { + canBeNil = genAnythingCanBeNil || !genIsImmutable(t) + } + if canBeNil { + x.line("if r.TryDecodeAsNil() {") + if t.Kind() == reflect.Ptr { + x.line("if " + varname + " != nil { ") + + // if varname is a field of a struct (has a dot in it), + // then just set it to nil + if strings.IndexByte(varname, '.') != -1 { + x.line(varname + " = nil") + } else { + x.line("*" + varname + " = " + x.genZeroValueR(t.Elem())) + } + x.line("}") + } else { + x.line(varname + " = " + x.genZeroValueR(t)) + } + x.line("} else {") + } else { + x.line("// cannot be nil") + } + if t.Kind() != reflect.Ptr { + if x.decTryAssignPrimitive(varname, t) { + x.line(genTempVarPfx + "v" + i + " := &" + varname) + x.dec(genTempVarPfx+"v"+i, t) + } + } else { + x.linef("if %s == nil { %s = new(%s) }", varname, varname, x.genTypeName(t.Elem())) + // Ensure we set underlying ptr to a non-nil value (so we can deref to it later). + // There's a chance of a **T in here which is nil. + var ptrPfx string + for t = t.Elem(); t.Kind() == reflect.Ptr; t = t.Elem() { + ptrPfx += "*" + x.linef("if %s%s == nil { %s%s = new(%s)}", + ptrPfx, varname, ptrPfx, varname, x.genTypeName(t)) + } + // if varname has [ in it, then create temp variable for this ptr thingie + if strings.Index(varname, "[") >= 0 { + varname2 := genTempVarPfx + "w" + i + x.line(varname2 + " := " + varname) + varname = varname2 + } + + if ptrPfx == "" { + x.dec(varname, t) + } else { + x.line(genTempVarPfx + "z" + i + " := " + ptrPfx + varname) + x.dec(genTempVarPfx+"z"+i, t) + } + + } + + if canBeNil { + x.line("} ") + } +} + +// dec will decode a variable (varname) of type ptrTo(t). +// t is always a basetype (i.e. not of kind reflect.Ptr). +func (x *genRunner) dec(varname string, t reflect.Type) { + // assumptions: + // - the varname is to a pointer already. No need to take address of it + // - t is always a baseType T (not a *T, etc). + rtid := reflect.ValueOf(t).Pointer() + tptr := reflect.PtrTo(t) + if x.checkForSelfer(t, varname) { + if t.Implements(selferTyp) || tptr.Implements(selferTyp) { + x.line(varname + ".CodecDecodeSelf(d)") + return + } + if _, ok := x.td[rtid]; ok { + x.line(varname + ".CodecDecodeSelf(d)") + return + } + } + + inlist := false + for _, t0 := range x.t { + if t == t0 { + inlist = true + if x.checkForSelfer(t, varname) { + x.line(varname + ".CodecDecodeSelf(d)") + return + } + break + } + } + + var rtidAdded bool + if t == x.tc { + x.td[rtid] = true + rtidAdded = true + } + + // check if + // - type is RawExt + // - the type implements (Text|JSON|Binary)(Unm|M)arshal + mi := x.varsfx() + x.linef("%sm%s := z.DecBinary()", genTempVarPfx, mi) + x.linef("_ = %sm%s", genTempVarPfx, mi) + x.line("if false {") //start if block + defer func() { x.line("}") }() //end if block + + if t == rawExtTyp { + x.linef("} else { r.DecodeExt(%v, 0, nil)", varname) + return + } + + // HACK: Support for Builtins. + // Currently, only Binc supports builtins, and the only builtin type is time.Time. + // Have a method that returns the rtid for time.Time if Handle is Binc. + if t == timeTyp { + vrtid := genTempVarPfx + "m" + x.varsfx() + x.linef("} else if %s := z.TimeRtidIfBinc(); %s != 0 { ", vrtid, vrtid) + x.linef("r.DecodeBuiltin(%s, %s)", vrtid, varname) + } + // only check for extensions if the type is named, and has a packagePath. + if genImportPath(t) != "" && t.Name() != "" { + // first check if extensions are configued, before doing the interface conversion + x.linef("} else if z.HasExtensions() && z.DecExt(%s) {", varname) + } + + if t.Implements(binaryUnmarshalerTyp) || tptr.Implements(binaryUnmarshalerTyp) { + x.linef("} else if %sm%s { z.DecBinaryUnmarshal(%v) ", genTempVarPfx, mi, varname) + } + if t.Implements(jsonUnmarshalerTyp) || tptr.Implements(jsonUnmarshalerTyp) { + x.linef("} else if !%sm%s && z.IsJSONHandle() { z.DecJSONUnmarshal(%v)", genTempVarPfx, mi, varname) + } else if t.Implements(textUnmarshalerTyp) || tptr.Implements(textUnmarshalerTyp) { + x.linef("} else if !%sm%s { z.DecTextUnmarshal(%v)", genTempVarPfx, mi, varname) + } + + x.line("} else {") + + // Since these are pointers, we cannot share, and have to use them one by one + switch t.Kind() { + case reflect.Int: + x.line("*((*int)(" + varname + ")) = int(r.DecodeInt(codecSelferBitsize" + x.xs + "))") + // x.line("z.DecInt((*int)(" + varname + "))") + case reflect.Int8: + x.line("*((*int8)(" + varname + ")) = int8(r.DecodeInt(8))") + // x.line("z.DecInt8((*int8)(" + varname + "))") + case reflect.Int16: + x.line("*((*int16)(" + varname + ")) = int16(r.DecodeInt(16))") + // x.line("z.DecInt16((*int16)(" + varname + "))") + case reflect.Int32: + x.line("*((*int32)(" + varname + ")) = int32(r.DecodeInt(32))") + // x.line("z.DecInt32((*int32)(" + varname + "))") + case reflect.Int64: + x.line("*((*int64)(" + varname + ")) = int64(r.DecodeInt(64))") + // x.line("z.DecInt64((*int64)(" + varname + "))") + + case reflect.Uint: + x.line("*((*uint)(" + varname + ")) = uint(r.DecodeUint(codecSelferBitsize" + x.xs + "))") + // x.line("z.DecUint((*uint)(" + varname + "))") + case reflect.Uint8: + x.line("*((*uint8)(" + varname + ")) = uint8(r.DecodeUint(8))") + // x.line("z.DecUint8((*uint8)(" + varname + "))") + case reflect.Uint16: + x.line("*((*uint16)(" + varname + ")) = uint16(r.DecodeUint(16))") + //x.line("z.DecUint16((*uint16)(" + varname + "))") + case reflect.Uint32: + x.line("*((*uint32)(" + varname + ")) = uint32(r.DecodeUint(32))") + //x.line("z.DecUint32((*uint32)(" + varname + "))") + case reflect.Uint64: + x.line("*((*uint64)(" + varname + ")) = uint64(r.DecodeUint(64))") + //x.line("z.DecUint64((*uint64)(" + varname + "))") + case reflect.Uintptr: + x.line("*((*uintptr)(" + varname + ")) = uintptr(r.DecodeUint(codecSelferBitsize" + x.xs + "))") + + case reflect.Float32: + x.line("*((*float32)(" + varname + ")) = float32(r.DecodeFloat(true))") + //x.line("z.DecFloat32((*float32)(" + varname + "))") + case reflect.Float64: + x.line("*((*float64)(" + varname + ")) = float64(r.DecodeFloat(false))") + // x.line("z.DecFloat64((*float64)(" + varname + "))") + + case reflect.Bool: + x.line("*((*bool)(" + varname + ")) = r.DecodeBool()") + // x.line("z.DecBool((*bool)(" + varname + "))") + case reflect.String: + x.line("*((*string)(" + varname + ")) = r.DecodeString()") + // x.line("z.DecString((*string)(" + varname + "))") + case reflect.Array, reflect.Chan: + x.xtraSM(varname, false, t) + // x.decListFallback(varname, rtid, true, t) + case reflect.Slice: + // if a []uint8, call dedicated function + // if a known fastpath slice, call dedicated function + // else write encode function in-line. + // - if elements are primitives or Selfers, call dedicated function on each member. + // - else call Encoder.encode(XXX) on it. + if rtid == uint8SliceTypId { + x.line("*" + varname + " = r.DecodeBytes(*(*[]byte)(" + varname + "), false, false)") + } else if fastpathAV.index(rtid) != -1 { + g := x.newGenV(t) + x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", false, d)") + } else { + x.xtraSM(varname, false, t) + // x.decListFallback(varname, rtid, false, t) + } + case reflect.Map: + // if a known fastpath map, call dedicated function + // else write encode function in-line. + // - if elements are primitives or Selfers, call dedicated function on each member. + // - else call Encoder.encode(XXX) on it. + if fastpathAV.index(rtid) != -1 { + g := x.newGenV(t) + x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", false, d)") + } else { + x.xtraSM(varname, false, t) + // x.decMapFallback(varname, rtid, t) + } + case reflect.Struct: + if inlist { + x.decStruct(varname, rtid, t) + } else { + // delete(x.td, rtid) + x.line("z.DecFallback(" + varname + ", false)") + } + default: + if rtidAdded { + delete(x.te, rtid) + } + x.line("z.DecFallback(" + varname + ", true)") + } +} + +func (x *genRunner) decTryAssignPrimitive(varname string, t reflect.Type) (tryAsPtr bool) { + // This should only be used for exact primitives (ie un-named types). + // Named types may be implementations of Selfer, Unmarshaler, etc. + // They should be handled by dec(...) + + if t.Name() != "" { + tryAsPtr = true + return + } + + switch t.Kind() { + case reflect.Int: + x.linef("%s = r.DecodeInt(codecSelferBitsize%s)", varname, x.xs) + case reflect.Int8: + x.linef("%s = r.DecodeInt(8)", varname) + case reflect.Int16: + x.linef("%s = r.DecodeInt(16)", varname) + case reflect.Int32: + x.linef("%s = r.DecodeInt(32)", varname) + case reflect.Int64: + x.linef("%s = r.DecodeInt(64)", varname) + + case reflect.Uint: + x.linef("%s = r.DecodeUint(codecSelferBitsize%s)", varname, x.xs) + case reflect.Uint8: + x.linef("%s = r.DecodeUint(8)", varname) + case reflect.Uint16: + x.linef("%s = r.DecodeUint(16)", varname) + case reflect.Uint32: + x.linef("%s = r.DecodeUint(32)", varname) + case reflect.Uint64: + x.linef("%s = r.DecodeUint(64)", varname) + case reflect.Uintptr: + x.linef("%s = r.DecodeUint(codecSelferBitsize%s)", varname, x.xs) + + case reflect.Float32: + x.linef("%s = r.DecodeFloat(true)", varname) + case reflect.Float64: + x.linef("%s = r.DecodeFloat(false)", varname) + + case reflect.Bool: + x.linef("%s = r.DecodeBool()", varname) + case reflect.String: + x.linef("%s = r.DecodeString()", varname) + default: + tryAsPtr = true + } + return +} + +func (x *genRunner) decListFallback(varname string, rtid uintptr, t reflect.Type) { + type tstruc struct { + TempVar string + Rand string + Varname string + CTyp string + Typ string + Immutable bool + Size int + } + telem := t.Elem() + ts := tstruc{genTempVarPfx, x.varsfx(), varname, x.genTypeName(t), x.genTypeName(telem), genIsImmutable(telem), int(telem.Size())} + + funcs := make(template.FuncMap) + + funcs["decLineVar"] = func(varname string) string { + x.decVar(varname, telem, false) + return "" + } + funcs["decLine"] = func(pfx string) string { + x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(telem), false) + return "" + } + funcs["var"] = func(s string) string { + return ts.TempVar + s + ts.Rand + } + funcs["zero"] = func() string { + return x.genZeroValueR(telem) + } + funcs["isArray"] = func() bool { + return t.Kind() == reflect.Array + } + funcs["isSlice"] = func() bool { + return t.Kind() == reflect.Slice + } + funcs["isChan"] = func() bool { + return t.Kind() == reflect.Chan + } + tm, err := template.New("").Funcs(funcs).Parse(genDecListTmpl) + if err != nil { + panic(err) + } + if err = tm.Execute(x.w, &ts); err != nil { + panic(err) + } +} + +func (x *genRunner) decMapFallback(varname string, rtid uintptr, t reflect.Type) { + type tstruc struct { + TempVar string + Sfx string + Rand string + Varname string + KTyp string + Typ string + Size int + } + telem := t.Elem() + tkey := t.Key() + ts := tstruc{ + genTempVarPfx, x.xs, x.varsfx(), varname, x.genTypeName(tkey), + x.genTypeName(telem), int(telem.Size() + tkey.Size()), + } + + funcs := make(template.FuncMap) + funcs["decElemZero"] = func() string { + return x.genZeroValueR(telem) + } + funcs["decElemKindImmutable"] = func() bool { + return genIsImmutable(telem) + } + funcs["decElemKindPtr"] = func() bool { + return telem.Kind() == reflect.Ptr + } + funcs["decElemKindIntf"] = func() bool { + return telem.Kind() == reflect.Interface + } + funcs["decLineVarK"] = func(varname string) string { + x.decVar(varname, tkey, false) + return "" + } + funcs["decLineVar"] = func(varname string) string { + x.decVar(varname, telem, false) + return "" + } + funcs["decLineK"] = func(pfx string) string { + x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(tkey), false) + return "" + } + funcs["decLine"] = func(pfx string) string { + x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(telem), false) + return "" + } + funcs["var"] = func(s string) string { + return ts.TempVar + s + ts.Rand + } + + tm, err := template.New("").Funcs(funcs).Parse(genDecMapTmpl) + if err != nil { + panic(err) + } + if err = tm.Execute(x.w, &ts); err != nil { + panic(err) + } +} + +func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintptr, t reflect.Type) { + ti := x.ti.get(rtid, t) + tisfi := ti.sfip // always use sequence from file. decStruct expects same thing. + x.line("switch (" + kName + ") {") + for _, si := range tisfi { + x.line("case \"" + si.encName + "\":") + var t2 reflect.StructField + if si.i != -1 { + t2 = t.Field(int(si.i)) + } else { + //we must accommodate anonymous fields, where the embedded field is a nil pointer in the value. + // t2 = t.FieldByIndex(si.is) + t2typ := t + varname3 := varname + for _, ix := range si.is { + for t2typ.Kind() == reflect.Ptr { + t2typ = t2typ.Elem() + } + t2 = t2typ.Field(ix) + t2typ = t2.Type + varname3 = varname3 + "." + t2.Name + if t2typ.Kind() == reflect.Ptr { + x.linef("if %s == nil { %s = new(%s) }", varname3, varname3, x.genTypeName(t2typ.Elem())) + } + } + } + x.decVar(varname+"."+t2.Name, t2.Type, false) + } + x.line("default:") + // pass the slice here, so that the string will not escape, and maybe save allocation + x.line("z.DecStructFieldNotFound(-1, " + kName + ")") + x.line("} // end switch " + kName) +} + +func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t reflect.Type, style genStructMapStyle) { + tpfx := genTempVarPfx + i := x.varsfx() + kName := tpfx + "s" + i + + // We thought to use ReadStringAsBytes, as go compiler might optimize the copy out. + // However, using that was more expensive, as it seems that the switch expression + // is evaluated each time. + // + // We could depend on decodeString using a temporary/shared buffer internally. + // However, this model of creating a byte array, and using explicitly is faster, + // and allows optional use of unsafe []byte->string conversion without alloc. + + // Also, ensure that the slice array doesn't escape. + // That will help escape analysis prevent allocation when it gets better. + + // x.line("var " + kName + "Arr = [32]byte{} // default string to decode into") + // x.line("var " + kName + "Slc = " + kName + "Arr[:] // default slice to decode into") + // use the scratch buffer to avoid allocation (most field names are < 32). + + x.line("var " + kName + "Slc = z.DecScratchBuffer() // default slice to decode into") + + x.line("_ = " + kName + "Slc") + switch style { + case genStructMapStyleLenPrefix: + x.linef("for %sj%s := 0; %sj%s < %s; %sj%s++ {", tpfx, i, tpfx, i, lenvarname, tpfx, i) + case genStructMapStyleCheckBreak: + x.linef("for %sj%s := 0; !r.CheckBreak(); %sj%s++ {", tpfx, i, tpfx, i) + default: // 0, otherwise. + x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length + x.linef("for %sj%s := 0; ; %sj%s++ {", tpfx, i, tpfx, i) + x.linef("if %shl%s { if %sj%s >= %s { break }", tpfx, i, tpfx, i, lenvarname) + x.line("} else { if r.CheckBreak() { break }; }") + } + x.linef("z.DecSendContainerState(codecSelfer_containerMapKey%s)", x.xs) + x.line(kName + "Slc = r.DecodeBytes(" + kName + "Slc, true, true)") + // let string be scoped to this loop alone, so it doesn't escape. + if x.unsafe { + x.line(kName + "SlcHdr := codecSelferUnsafeString" + x.xs + "{uintptr(unsafe.Pointer(&" + + kName + "Slc[0])), len(" + kName + "Slc)}") + x.line(kName + " := *(*string)(unsafe.Pointer(&" + kName + "SlcHdr))") + } else { + x.line(kName + " := string(" + kName + "Slc)") + } + x.linef("z.DecSendContainerState(codecSelfer_containerMapValue%s)", x.xs) + x.decStructMapSwitch(kName, varname, rtid, t) + + x.line("} // end for " + tpfx + "j" + i) + x.linef("z.DecSendContainerState(codecSelfer_containerMapEnd%s)", x.xs) +} + +func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid uintptr, t reflect.Type) { + tpfx := genTempVarPfx + i := x.varsfx() + ti := x.ti.get(rtid, t) + tisfi := ti.sfip // always use sequence from file. decStruct expects same thing. + x.linef("var %sj%s int", tpfx, i) + x.linef("var %sb%s bool", tpfx, i) // break + x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length + for _, si := range tisfi { + var t2 reflect.StructField + if si.i != -1 { + t2 = t.Field(int(si.i)) + } else { + //we must accommodate anonymous fields, where the embedded field is a nil pointer in the value. + // t2 = t.FieldByIndex(si.is) + t2typ := t + varname3 := varname + for _, ix := range si.is { + for t2typ.Kind() == reflect.Ptr { + t2typ = t2typ.Elem() + } + t2 = t2typ.Field(ix) + t2typ = t2.Type + varname3 = varname3 + "." + t2.Name + if t2typ.Kind() == reflect.Ptr { + x.linef("if %s == nil { %s = new(%s) }", varname3, varname3, x.genTypeName(t2typ.Elem())) + } + } + } + + x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = r.CheckBreak() }", + tpfx, i, tpfx, i, tpfx, i, + tpfx, i, lenvarname, tpfx, i) + x.linef("if %sb%s { z.DecSendContainerState(codecSelfer_containerArrayEnd%s); %s }", + tpfx, i, x.xs, breakString) + x.linef("z.DecSendContainerState(codecSelfer_containerArrayElem%s)", x.xs) + x.decVar(varname+"."+t2.Name, t2.Type, true) + } + // read remaining values and throw away. + x.line("for {") + x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = r.CheckBreak() }", + tpfx, i, tpfx, i, tpfx, i, + tpfx, i, lenvarname, tpfx, i) + x.linef("if %sb%s { break }", tpfx, i) + x.linef("z.DecSendContainerState(codecSelfer_containerArrayElem%s)", x.xs) + x.linef(`z.DecStructFieldNotFound(%sj%s - 1, "")`, tpfx, i) + x.line("}") + x.linef("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs) +} + +func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) { + // if container is map + i := x.varsfx() + x.linef("%sct%s := r.ContainerType()", genTempVarPfx, i) + x.linef("if %sct%s == codecSelferValueTypeMap%s {", genTempVarPfx, i, x.xs) + x.line(genTempVarPfx + "l" + i + " := r.ReadMapStart()") + x.linef("if %sl%s == 0 {", genTempVarPfx, i) + x.linef("z.DecSendContainerState(codecSelfer_containerMapEnd%s)", x.xs) + if genUseOneFunctionForDecStructMap { + x.line("} else { ") + x.linef("x.codecDecodeSelfFromMap(%sl%s, d)", genTempVarPfx, i) + } else { + x.line("} else if " + genTempVarPfx + "l" + i + " > 0 { ") + x.line("x.codecDecodeSelfFromMapLenPrefix(" + genTempVarPfx + "l" + i + ", d)") + x.line("} else {") + x.line("x.codecDecodeSelfFromMapCheckBreak(" + genTempVarPfx + "l" + i + ", d)") + } + x.line("}") + + // else if container is array + x.linef("} else if %sct%s == codecSelferValueTypeArray%s {", genTempVarPfx, i, x.xs) + x.line(genTempVarPfx + "l" + i + " := r.ReadArrayStart()") + x.linef("if %sl%s == 0 {", genTempVarPfx, i) + x.linef("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs) + x.line("} else { ") + x.linef("x.codecDecodeSelfFromArray(%sl%s, d)", genTempVarPfx, i) + x.line("}") + // else panic + x.line("} else { ") + x.line("panic(codecSelferOnlyMapOrArrayEncodeToStructErr" + x.xs + ")") + x.line("} ") +} + +// -------- + +type genV struct { + // genV is either a primitive (Primitive != "") or a map (MapKey != "") or a slice + MapKey string + Elem string + Primitive string + Size int +} + +func (x *genRunner) newGenV(t reflect.Type) (v genV) { + switch t.Kind() { + case reflect.Slice, reflect.Array: + te := t.Elem() + v.Elem = x.genTypeName(te) + v.Size = int(te.Size()) + case reflect.Map: + te, tk := t.Elem(), t.Key() + v.Elem = x.genTypeName(te) + v.MapKey = x.genTypeName(tk) + v.Size = int(te.Size() + tk.Size()) + default: + panic("unexpected type for newGenV. Requires map or slice type") + } + return +} + +func (x *genV) MethodNamePfx(prefix string, prim bool) string { + var name []byte + if prefix != "" { + name = append(name, prefix...) + } + if prim { + name = append(name, genTitleCaseName(x.Primitive)...) + } else { + if x.MapKey == "" { + name = append(name, "Slice"...) + } else { + name = append(name, "Map"...) + name = append(name, genTitleCaseName(x.MapKey)...) + } + name = append(name, genTitleCaseName(x.Elem)...) + } + return string(name) + +} + +// genImportPath returns import path of a non-predeclared named typed, or an empty string otherwise. +// +// This handles the misbehaviour that occurs when 1.5-style vendoring is enabled, +// where PkgPath returns the full path, including the vendoring pre-fix that should have been stripped. +// We strip it here. +func genImportPath(t reflect.Type) (s string) { + s = t.PkgPath() + if genCheckVendor { + // HACK: Misbehaviour occurs in go 1.5. May have to re-visit this later. + // if s contains /vendor/ OR startsWith vendor/, then return everything after it. + const vendorStart = "vendor/" + const vendorInline = "/vendor/" + if i := strings.LastIndex(s, vendorInline); i >= 0 { + s = s[i+len(vendorInline):] + } else if strings.HasPrefix(s, vendorStart) { + s = s[len(vendorStart):] + } + } + return +} + +// A go identifier is (letter|_)[letter|number|_]* +func genGoIdentifier(s string, checkFirstChar bool) string { + b := make([]byte, 0, len(s)) + t := make([]byte, 4) + var n int + for i, r := range s { + if checkFirstChar && i == 0 && !unicode.IsLetter(r) { + b = append(b, '_') + } + // r must be unicode_letter, unicode_digit or _ + if unicode.IsLetter(r) || unicode.IsDigit(r) { + n = utf8.EncodeRune(t, r) + b = append(b, t[:n]...) + } else { + b = append(b, '_') + } + } + return string(b) +} + +func genNonPtr(t reflect.Type) reflect.Type { + for t.Kind() == reflect.Ptr { + t = t.Elem() + } + return t +} + +func genTitleCaseName(s string) string { + switch s { + case "interface{}", "interface {}": + return "Intf" + default: + return strings.ToUpper(s[0:1]) + s[1:] + } +} + +func genMethodNameT(t reflect.Type, tRef reflect.Type) (n string) { + var ptrPfx string + for t.Kind() == reflect.Ptr { + ptrPfx += "Ptrto" + t = t.Elem() + } + tstr := t.String() + if tn := t.Name(); tn != "" { + if tRef != nil && genImportPath(t) == genImportPath(tRef) { + return ptrPfx + tn + } else { + if genQNameRegex.MatchString(tstr) { + return ptrPfx + strings.Replace(tstr, ".", "_", 1000) + } else { + return ptrPfx + genCustomTypeName(tstr) + } + } + } + switch t.Kind() { + case reflect.Map: + return ptrPfx + "Map" + genMethodNameT(t.Key(), tRef) + genMethodNameT(t.Elem(), tRef) + case reflect.Slice: + return ptrPfx + "Slice" + genMethodNameT(t.Elem(), tRef) + case reflect.Array: + return ptrPfx + "Array" + strconv.FormatInt(int64(t.Len()), 10) + genMethodNameT(t.Elem(), tRef) + case reflect.Chan: + var cx string + switch t.ChanDir() { + case reflect.SendDir: + cx = "ChanSend" + case reflect.RecvDir: + cx = "ChanRecv" + default: + cx = "Chan" + } + return ptrPfx + cx + genMethodNameT(t.Elem(), tRef) + default: + if t == intfTyp { + return ptrPfx + "Interface" + } else { + if tRef != nil && genImportPath(t) == genImportPath(tRef) { + if t.Name() != "" { + return ptrPfx + t.Name() + } else { + return ptrPfx + genCustomTypeName(tstr) + } + } else { + // best way to get the package name inclusive + // return ptrPfx + strings.Replace(tstr, ".", "_", 1000) + // return ptrPfx + genBase64enc.EncodeToString([]byte(tstr)) + if t.Name() != "" && genQNameRegex.MatchString(tstr) { + return ptrPfx + strings.Replace(tstr, ".", "_", 1000) + } else { + return ptrPfx + genCustomTypeName(tstr) + } + } + } + } +} + +// genCustomNameForType base64encodes the t.String() value in such a way +// that it can be used within a function name. +func genCustomTypeName(tstr string) string { + len2 := genBase64enc.EncodedLen(len(tstr)) + bufx := make([]byte, len2) + genBase64enc.Encode(bufx, []byte(tstr)) + for i := len2 - 1; i >= 0; i-- { + if bufx[i] == '=' { + len2-- + } else { + break + } + } + return string(bufx[:len2]) +} + +func genIsImmutable(t reflect.Type) (v bool) { + return isImmutableKind(t.Kind()) +} + +type genInternal struct { + Values []genV + Unsafe bool +} + +func (x genInternal) FastpathLen() (l int) { + for _, v := range x.Values { + if v.Primitive == "" { + l++ + } + } + return +} + +func genInternalZeroValue(s string) string { + switch s { + case "interface{}", "interface {}": + return "nil" + case "bool": + return "false" + case "string": + return `""` + default: + return "0" + } +} + +func genInternalEncCommandAsString(s string, vname string) string { + switch s { + case "uint", "uint8", "uint16", "uint32", "uint64": + return "ee.EncodeUint(uint64(" + vname + "))" + case "int", "int8", "int16", "int32", "int64": + return "ee.EncodeInt(int64(" + vname + "))" + case "string": + return "ee.EncodeString(c_UTF8, " + vname + ")" + case "float32": + return "ee.EncodeFloat32(" + vname + ")" + case "float64": + return "ee.EncodeFloat64(" + vname + ")" + case "bool": + return "ee.EncodeBool(" + vname + ")" + case "symbol": + return "ee.EncodeSymbol(" + vname + ")" + default: + return "e.encode(" + vname + ")" + } +} + +func genInternalDecCommandAsString(s string) string { + switch s { + case "uint": + return "uint(dd.DecodeUint(uintBitsize))" + case "uint8": + return "uint8(dd.DecodeUint(8))" + case "uint16": + return "uint16(dd.DecodeUint(16))" + case "uint32": + return "uint32(dd.DecodeUint(32))" + case "uint64": + return "dd.DecodeUint(64)" + case "uintptr": + return "uintptr(dd.DecodeUint(uintBitsize))" + case "int": + return "int(dd.DecodeInt(intBitsize))" + case "int8": + return "int8(dd.DecodeInt(8))" + case "int16": + return "int16(dd.DecodeInt(16))" + case "int32": + return "int32(dd.DecodeInt(32))" + case "int64": + return "dd.DecodeInt(64)" + + case "string": + return "dd.DecodeString()" + case "float32": + return "float32(dd.DecodeFloat(true))" + case "float64": + return "dd.DecodeFloat(false)" + case "bool": + return "dd.DecodeBool()" + default: + panic(errors.New("gen internal: unknown type for decode: " + s)) + } +} + +func genInternalSortType(s string, elem bool) string { + for _, v := range [...]string{"int", "uint", "float", "bool", "string"} { + if strings.HasPrefix(s, v) { + if elem { + if v == "int" || v == "uint" || v == "float" { + return v + "64" + } else { + return v + } + } + return v + "Slice" + } + } + panic("sorttype: unexpected type: " + s) +} + +// var genInternalMu sync.Mutex +var genInternalV genInternal +var genInternalTmplFuncs template.FuncMap +var genInternalOnce sync.Once + +func genInternalInit() { + types := [...]string{ + "interface{}", + "string", + "float32", + "float64", + "uint", + "uint8", + "uint16", + "uint32", + "uint64", + "uintptr", + "int", + "int8", + "int16", + "int32", + "int64", + "bool", + } + // keep as slice, so it is in specific iteration order. + // Initial order was uint64, string, interface{}, int, int64 + mapvaltypes := [...]string{ + "interface{}", + "string", + "uint", + "uint8", + "uint16", + "uint32", + "uint64", + "uintptr", + "int", + "int8", + "int16", + "int32", + "int64", + "float32", + "float64", + "bool", + } + wordSizeBytes := int(intBitsize) / 8 + + mapvaltypes2 := map[string]int{ + "interface{}": 2 * wordSizeBytes, + "string": 2 * wordSizeBytes, + "uint": 1 * wordSizeBytes, + "uint8": 1, + "uint16": 2, + "uint32": 4, + "uint64": 8, + "uintptr": 1 * wordSizeBytes, + "int": 1 * wordSizeBytes, + "int8": 1, + "int16": 2, + "int32": 4, + "int64": 8, + "float32": 4, + "float64": 8, + "bool": 1, + } + var gt genInternal + + // For each slice or map type, there must be a (symmetrical) Encode and Decode fast-path function + for _, s := range types { + gt.Values = append(gt.Values, genV{Primitive: s, Size: mapvaltypes2[s]}) + if s != "uint8" { // do not generate fast path for slice of bytes. Treat specially already. + gt.Values = append(gt.Values, genV{Elem: s, Size: mapvaltypes2[s]}) + } + if _, ok := mapvaltypes2[s]; !ok { + gt.Values = append(gt.Values, genV{MapKey: s, Elem: s, Size: 2 * mapvaltypes2[s]}) + } + for _, ms := range mapvaltypes { + gt.Values = append(gt.Values, genV{MapKey: s, Elem: ms, Size: mapvaltypes2[s] + mapvaltypes2[ms]}) + } + } + + funcs := make(template.FuncMap) + // funcs["haspfx"] = strings.HasPrefix + funcs["encmd"] = genInternalEncCommandAsString + funcs["decmd"] = genInternalDecCommandAsString + funcs["zerocmd"] = genInternalZeroValue + funcs["hasprefix"] = strings.HasPrefix + funcs["sorttype"] = genInternalSortType + + genInternalV = gt + genInternalTmplFuncs = funcs +} + +// genInternalGoFile is used to generate source files from templates. +// It is run by the program author alone. +// Unfortunately, it has to be exported so that it can be called from a command line tool. +// *** DO NOT USE *** +func genInternalGoFile(r io.Reader, w io.Writer, safe bool) (err error) { + genInternalOnce.Do(genInternalInit) + + gt := genInternalV + gt.Unsafe = !safe + + t := template.New("").Funcs(genInternalTmplFuncs) + + tmplstr, err := ioutil.ReadAll(r) + if err != nil { + return + } + + if t, err = t.Parse(string(tmplstr)); err != nil { + return + } + + var out bytes.Buffer + err = t.Execute(&out, gt) + if err != nil { + return + } + + bout, err := format.Source(out.Bytes()) + if err != nil { + w.Write(out.Bytes()) // write out if error, so we can still see. + // w.Write(bout) // write out if error, as much as possible, so we can still see. + return + } + w.Write(bout) + return +} diff --git a/vendor/github.com/ugorji/go/codec/gen_15.go b/vendor/github.com/ugorji/go/codec/gen_15.go new file mode 100644 index 00000000..ab76c310 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/gen_15.go @@ -0,0 +1,12 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +// +build go1.5,!go1.6 + +package codec + +import "os" + +func init() { + genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") == "1" +} diff --git a/vendor/github.com/ugorji/go/codec/gen_16.go b/vendor/github.com/ugorji/go/codec/gen_16.go new file mode 100644 index 00000000..87c04e2e --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/gen_16.go @@ -0,0 +1,12 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +// +build go1.6 + +package codec + +import "os" + +func init() { + genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") != "0" +} diff --git a/vendor/github.com/ugorji/go/codec/helper.go b/vendor/github.com/ugorji/go/codec/helper.go new file mode 100644 index 00000000..a012c8b2 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/helper.go @@ -0,0 +1,1302 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +// Contains code shared by both encode and decode. + +// Some shared ideas around encoding/decoding +// ------------------------------------------ +// +// If an interface{} is passed, we first do a type assertion to see if it is +// a primitive type or a map/slice of primitive types, and use a fastpath to handle it. +// +// If we start with a reflect.Value, we are already in reflect.Value land and +// will try to grab the function for the underlying Type and directly call that function. +// This is more performant than calling reflect.Value.Interface(). +// +// This still helps us bypass many layers of reflection, and give best performance. +// +// Containers +// ------------ +// Containers in the stream are either associative arrays (key-value pairs) or +// regular arrays (indexed by incrementing integers). +// +// Some streams support indefinite-length containers, and use a breaking +// byte-sequence to denote that the container has come to an end. +// +// Some streams also are text-based, and use explicit separators to denote the +// end/beginning of different values. +// +// During encode, we use a high-level condition to determine how to iterate through +// the container. That decision is based on whether the container is text-based (with +// separators) or binary (without separators). If binary, we do not even call the +// encoding of separators. +// +// During decode, we use a different high-level condition to determine how to iterate +// through the containers. That decision is based on whether the stream contained +// a length prefix, or if it used explicit breaks. If length-prefixed, we assume that +// it has to be binary, and we do not even try to read separators. +// +// The only codec that may suffer (slightly) is cbor, and only when decoding indefinite-length. +// It may suffer because we treat it like a text-based codec, and read separators. +// However, this read is a no-op and the cost is insignificant. +// +// Philosophy +// ------------ +// On decode, this codec will update containers appropriately: +// - If struct, update fields from stream into fields of struct. +// If field in stream not found in struct, handle appropriately (based on option). +// If a struct field has no corresponding value in the stream, leave it AS IS. +// If nil in stream, set value to nil/zero value. +// - If map, update map from stream. +// If the stream value is NIL, set the map to nil. +// - if slice, try to update up to length of array in stream. +// if container len is less than stream array length, +// and container cannot be expanded, handled (based on option). +// This means you can decode 4-element stream array into 1-element array. +// +// ------------------------------------ +// On encode, user can specify omitEmpty. This means that the value will be omitted +// if the zero value. The problem may occur during decode, where omitted values do not affect +// the value being decoded into. This means that if decoding into a struct with an +// int field with current value=5, and the field is omitted in the stream, then after +// decoding, the value will still be 5 (not 0). +// omitEmpty only works if you guarantee that you always decode into zero-values. +// +// ------------------------------------ +// We could have truncated a map to remove keys not available in the stream, +// or set values in the struct which are not in the stream to their zero values. +// We decided against it because there is no efficient way to do it. +// We may introduce it as an option later. +// However, that will require enabling it for both runtime and code generation modes. +// +// To support truncate, we need to do 2 passes over the container: +// map +// - first collect all keys (e.g. in k1) +// - for each key in stream, mark k1 that the key should not be removed +// - after updating map, do second pass and call delete for all keys in k1 which are not marked +// struct: +// - for each field, track the *typeInfo s1 +// - iterate through all s1, and for each one not marked, set value to zero +// - this involves checking the possible anonymous fields which are nil ptrs. +// too much work. +// +// ------------------------------------------ +// Error Handling is done within the library using panic. +// +// This way, the code doesn't have to keep checking if an error has happened, +// and we don't have to keep sending the error value along with each call +// or storing it in the En|Decoder and checking it constantly along the way. +// +// The disadvantage is that small functions which use panics cannot be inlined. +// The code accounts for that by only using panics behind an interface; +// since interface calls cannot be inlined, this is irrelevant. +// +// We considered storing the error is En|Decoder. +// - once it has its err field set, it cannot be used again. +// - panicing will be optional, controlled by const flag. +// - code should always check error first and return early. +// We eventually decided against it as it makes the code clumsier to always +// check for these error conditions. + +import ( + "bytes" + "encoding" + "encoding/binary" + "errors" + "fmt" + "math" + "reflect" + "sort" + "strings" + "sync" + "time" +) + +const ( + scratchByteArrayLen = 32 + initCollectionCap = 32 // 32 is defensive. 16 is preferred. + + // Support encoding.(Binary|Text)(Unm|M)arshaler. + // This constant flag will enable or disable it. + supportMarshalInterfaces = true + + // Each Encoder or Decoder uses a cache of functions based on conditionals, + // so that the conditionals are not run every time. + // + // Either a map or a slice is used to keep track of the functions. + // The map is more natural, but has a higher cost than a slice/array. + // This flag (useMapForCodecCache) controls which is used. + // + // From benchmarks, slices with linear search perform better with < 32 entries. + // We have typically seen a high threshold of about 24 entries. + useMapForCodecCache = false + + // for debugging, set this to false, to catch panic traces. + // Note that this will always cause rpc tests to fail, since they need io.EOF sent via panic. + recoverPanicToErr = true + + // if resetSliceElemToZeroValue, then on decoding a slice, reset the element to a zero value first. + // Only concern is that, if the slice already contained some garbage, we will decode into that garbage. + // The chances of this are slim, so leave this "optimization". + // TODO: should this be true, to ensure that we always decode into a "zero" "empty" value? + resetSliceElemToZeroValue bool = false +) + +var ( + oneByteArr = [1]byte{0} + zeroByteSlice = oneByteArr[:0:0] +) + +type charEncoding uint8 + +const ( + c_RAW charEncoding = iota + c_UTF8 + c_UTF16LE + c_UTF16BE + c_UTF32LE + c_UTF32BE +) + +// valueType is the stream type +type valueType uint8 + +const ( + valueTypeUnset valueType = iota + valueTypeNil + valueTypeInt + valueTypeUint + valueTypeFloat + valueTypeBool + valueTypeString + valueTypeSymbol + valueTypeBytes + valueTypeMap + valueTypeArray + valueTypeTimestamp + valueTypeExt + + // valueTypeInvalid = 0xff +) + +type seqType uint8 + +const ( + _ seqType = iota + seqTypeArray + seqTypeSlice + seqTypeChan +) + +// note that containerMapStart and containerArraySend are not sent. +// This is because the ReadXXXStart and EncodeXXXStart already does these. +type containerState uint8 + +const ( + _ containerState = iota + + containerMapStart // slot left open, since Driver method already covers it + containerMapKey + containerMapValue + containerMapEnd + containerArrayStart // slot left open, since Driver methods already cover it + containerArrayElem + containerArrayEnd +) + +// sfiIdx used for tracking where a fieldName is seen in a []*structFieldInfo +type sfiIdx struct { + fieldName string + index int +} + +// do not recurse if a containing type refers to an embedded type +// which refers back to its containing type (via a pointer). +// The second time this back-reference happens, break out, +// so as not to cause an infinite loop. +const rgetMaxRecursion = 2 + +// Anecdotally, we believe most types have <= 12 fields. +// Java's PMD rules set TooManyFields threshold to 15. +const rgetPoolTArrayLen = 12 + +type rgetT struct { + fNames []string + encNames []string + etypes []uintptr + sfis []*structFieldInfo +} + +type rgetPoolT struct { + fNames [rgetPoolTArrayLen]string + encNames [rgetPoolTArrayLen]string + etypes [rgetPoolTArrayLen]uintptr + sfis [rgetPoolTArrayLen]*structFieldInfo + sfiidx [rgetPoolTArrayLen]sfiIdx +} + +var rgetPool = sync.Pool{ + New: func() interface{} { return new(rgetPoolT) }, +} + +type containerStateRecv interface { + sendContainerState(containerState) +} + +// mirror json.Marshaler and json.Unmarshaler here, +// so we don't import the encoding/json package +type jsonMarshaler interface { + MarshalJSON() ([]byte, error) +} +type jsonUnmarshaler interface { + UnmarshalJSON([]byte) error +} + +var ( + bigen = binary.BigEndian + structInfoFieldName = "_struct" + + mapStrIntfTyp = reflect.TypeOf(map[string]interface{}(nil)) + mapIntfIntfTyp = reflect.TypeOf(map[interface{}]interface{}(nil)) + intfSliceTyp = reflect.TypeOf([]interface{}(nil)) + intfTyp = intfSliceTyp.Elem() + + stringTyp = reflect.TypeOf("") + timeTyp = reflect.TypeOf(time.Time{}) + rawExtTyp = reflect.TypeOf(RawExt{}) + uint8SliceTyp = reflect.TypeOf([]uint8(nil)) + + mapBySliceTyp = reflect.TypeOf((*MapBySlice)(nil)).Elem() + + binaryMarshalerTyp = reflect.TypeOf((*encoding.BinaryMarshaler)(nil)).Elem() + binaryUnmarshalerTyp = reflect.TypeOf((*encoding.BinaryUnmarshaler)(nil)).Elem() + + textMarshalerTyp = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem() + textUnmarshalerTyp = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem() + + jsonMarshalerTyp = reflect.TypeOf((*jsonMarshaler)(nil)).Elem() + jsonUnmarshalerTyp = reflect.TypeOf((*jsonUnmarshaler)(nil)).Elem() + + selferTyp = reflect.TypeOf((*Selfer)(nil)).Elem() + + uint8SliceTypId = reflect.ValueOf(uint8SliceTyp).Pointer() + rawExtTypId = reflect.ValueOf(rawExtTyp).Pointer() + intfTypId = reflect.ValueOf(intfTyp).Pointer() + timeTypId = reflect.ValueOf(timeTyp).Pointer() + stringTypId = reflect.ValueOf(stringTyp).Pointer() + + mapStrIntfTypId = reflect.ValueOf(mapStrIntfTyp).Pointer() + mapIntfIntfTypId = reflect.ValueOf(mapIntfIntfTyp).Pointer() + intfSliceTypId = reflect.ValueOf(intfSliceTyp).Pointer() + // mapBySliceTypId = reflect.ValueOf(mapBySliceTyp).Pointer() + + intBitsize uint8 = uint8(reflect.TypeOf(int(0)).Bits()) + uintBitsize uint8 = uint8(reflect.TypeOf(uint(0)).Bits()) + + bsAll0x00 = []byte{0, 0, 0, 0, 0, 0, 0, 0} + bsAll0xff = []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} + + chkOvf checkOverflow + + noFieldNameToStructFieldInfoErr = errors.New("no field name passed to parseStructFieldInfo") +) + +var defTypeInfos = NewTypeInfos([]string{"codec", "json"}) + +// Selfer defines methods by which a value can encode or decode itself. +// +// Any type which implements Selfer will be able to encode or decode itself. +// Consequently, during (en|de)code, this takes precedence over +// (text|binary)(M|Unm)arshal or extension support. +type Selfer interface { + CodecEncodeSelf(*Encoder) + CodecDecodeSelf(*Decoder) +} + +// MapBySlice represents a slice which should be encoded as a map in the stream. +// The slice contains a sequence of key-value pairs. +// This affords storing a map in a specific sequence in the stream. +// +// The support of MapBySlice affords the following: +// - A slice type which implements MapBySlice will be encoded as a map +// - A slice can be decoded from a map in the stream +type MapBySlice interface { + MapBySlice() +} + +// WARNING: DO NOT USE DIRECTLY. EXPORTED FOR GODOC BENEFIT. WILL BE REMOVED. +// +// BasicHandle encapsulates the common options and extension functions. +type BasicHandle struct { + // TypeInfos is used to get the type info for any type. + // + // If not configured, the default TypeInfos is used, which uses struct tag keys: codec, json + TypeInfos *TypeInfos + + extHandle + EncodeOptions + DecodeOptions +} + +func (x *BasicHandle) getBasicHandle() *BasicHandle { + return x +} + +func (x *BasicHandle) getTypeInfo(rtid uintptr, rt reflect.Type) (pti *typeInfo) { + if x.TypeInfos != nil { + return x.TypeInfos.get(rtid, rt) + } + return defTypeInfos.get(rtid, rt) +} + +// Handle is the interface for a specific encoding format. +// +// Typically, a Handle is pre-configured before first time use, +// and not modified while in use. Such a pre-configured Handle +// is safe for concurrent access. +type Handle interface { + getBasicHandle() *BasicHandle + newEncDriver(w *Encoder) encDriver + newDecDriver(r *Decoder) decDriver + isBinary() bool +} + +// RawExt represents raw unprocessed extension data. +// Some codecs will decode extension data as a *RawExt if there is no registered extension for the tag. +// +// Only one of Data or Value is nil. If Data is nil, then the content of the RawExt is in the Value. +type RawExt struct { + Tag uint64 + // Data is the []byte which represents the raw ext. If Data is nil, ext is exposed in Value. + // Data is used by codecs (e.g. binc, msgpack, simple) which do custom serialization of the types + Data []byte + // Value represents the extension, if Data is nil. + // Value is used by codecs (e.g. cbor) which use the format to do custom serialization of the types. + Value interface{} +} + +// BytesExt handles custom (de)serialization of types to/from []byte. +// It is used by codecs (e.g. binc, msgpack, simple) which do custom serialization of the types. +type BytesExt interface { + // WriteExt converts a value to a []byte. + // + // Note: v *may* be a pointer to the extension type, if the extension type was a struct or array. + WriteExt(v interface{}) []byte + + // ReadExt updates a value from a []byte. + ReadExt(dst interface{}, src []byte) +} + +// InterfaceExt handles custom (de)serialization of types to/from another interface{} value. +// The Encoder or Decoder will then handle the further (de)serialization of that known type. +// +// It is used by codecs (e.g. cbor, json) which use the format to do custom serialization of the types. +type InterfaceExt interface { + // ConvertExt converts a value into a simpler interface for easy encoding e.g. convert time.Time to int64. + // + // Note: v *may* be a pointer to the extension type, if the extension type was a struct or array. + ConvertExt(v interface{}) interface{} + + // UpdateExt updates a value from a simpler interface for easy decoding e.g. convert int64 to time.Time. + UpdateExt(dst interface{}, src interface{}) +} + +// Ext handles custom (de)serialization of custom types / extensions. +type Ext interface { + BytesExt + InterfaceExt +} + +// addExtWrapper is a wrapper implementation to support former AddExt exported method. +type addExtWrapper struct { + encFn func(reflect.Value) ([]byte, error) + decFn func(reflect.Value, []byte) error +} + +func (x addExtWrapper) WriteExt(v interface{}) []byte { + bs, err := x.encFn(reflect.ValueOf(v)) + if err != nil { + panic(err) + } + return bs +} + +func (x addExtWrapper) ReadExt(v interface{}, bs []byte) { + if err := x.decFn(reflect.ValueOf(v), bs); err != nil { + panic(err) + } +} + +func (x addExtWrapper) ConvertExt(v interface{}) interface{} { + return x.WriteExt(v) +} + +func (x addExtWrapper) UpdateExt(dest interface{}, v interface{}) { + x.ReadExt(dest, v.([]byte)) +} + +type setExtWrapper struct { + b BytesExt + i InterfaceExt +} + +func (x *setExtWrapper) WriteExt(v interface{}) []byte { + if x.b == nil { + panic("BytesExt.WriteExt is not supported") + } + return x.b.WriteExt(v) +} + +func (x *setExtWrapper) ReadExt(v interface{}, bs []byte) { + if x.b == nil { + panic("BytesExt.WriteExt is not supported") + + } + x.b.ReadExt(v, bs) +} + +func (x *setExtWrapper) ConvertExt(v interface{}) interface{} { + if x.i == nil { + panic("InterfaceExt.ConvertExt is not supported") + + } + return x.i.ConvertExt(v) +} + +func (x *setExtWrapper) UpdateExt(dest interface{}, v interface{}) { + if x.i == nil { + panic("InterfaceExxt.UpdateExt is not supported") + + } + x.i.UpdateExt(dest, v) +} + +// type errorString string +// func (x errorString) Error() string { return string(x) } + +type binaryEncodingType struct{} + +func (_ binaryEncodingType) isBinary() bool { return true } + +type textEncodingType struct{} + +func (_ textEncodingType) isBinary() bool { return false } + +// noBuiltInTypes is embedded into many types which do not support builtins +// e.g. msgpack, simple, cbor. +type noBuiltInTypes struct{} + +func (_ noBuiltInTypes) IsBuiltinType(rt uintptr) bool { return false } +func (_ noBuiltInTypes) EncodeBuiltin(rt uintptr, v interface{}) {} +func (_ noBuiltInTypes) DecodeBuiltin(rt uintptr, v interface{}) {} + +type noStreamingCodec struct{} + +func (_ noStreamingCodec) CheckBreak() bool { return false } + +// bigenHelper. +// Users must already slice the x completely, because we will not reslice. +type bigenHelper struct { + x []byte // must be correctly sliced to appropriate len. slicing is a cost. + w encWriter +} + +func (z bigenHelper) writeUint16(v uint16) { + bigen.PutUint16(z.x, v) + z.w.writeb(z.x) +} + +func (z bigenHelper) writeUint32(v uint32) { + bigen.PutUint32(z.x, v) + z.w.writeb(z.x) +} + +func (z bigenHelper) writeUint64(v uint64) { + bigen.PutUint64(z.x, v) + z.w.writeb(z.x) +} + +type extTypeTagFn struct { + rtid uintptr + rt reflect.Type + tag uint64 + ext Ext +} + +type extHandle []extTypeTagFn + +// DEPRECATED: Use SetBytesExt or SetInterfaceExt on the Handle instead. +// +// AddExt registes an encode and decode function for a reflect.Type. +// AddExt internally calls SetExt. +// To deregister an Ext, call AddExt with nil encfn and/or nil decfn. +func (o *extHandle) AddExt( + rt reflect.Type, tag byte, + encfn func(reflect.Value) ([]byte, error), decfn func(reflect.Value, []byte) error, +) (err error) { + if encfn == nil || decfn == nil { + return o.SetExt(rt, uint64(tag), nil) + } + return o.SetExt(rt, uint64(tag), addExtWrapper{encfn, decfn}) +} + +// DEPRECATED: Use SetBytesExt or SetInterfaceExt on the Handle instead. +// +// Note that the type must be a named type, and specifically not +// a pointer or Interface. An error is returned if that is not honored. +// +// To Deregister an ext, call SetExt with nil Ext +func (o *extHandle) SetExt(rt reflect.Type, tag uint64, ext Ext) (err error) { + // o is a pointer, because we may need to initialize it + if rt.PkgPath() == "" || rt.Kind() == reflect.Interface { + err = fmt.Errorf("codec.Handle.AddExt: Takes named type, not a pointer or interface: %T", + reflect.Zero(rt).Interface()) + return + } + + rtid := reflect.ValueOf(rt).Pointer() + for _, v := range *o { + if v.rtid == rtid { + v.tag, v.ext = tag, ext + return + } + } + + if *o == nil { + *o = make([]extTypeTagFn, 0, 4) + } + *o = append(*o, extTypeTagFn{rtid, rt, tag, ext}) + return +} + +func (o extHandle) getExt(rtid uintptr) *extTypeTagFn { + var v *extTypeTagFn + for i := range o { + v = &o[i] + if v.rtid == rtid { + return v + } + } + return nil +} + +func (o extHandle) getExtForTag(tag uint64) *extTypeTagFn { + var v *extTypeTagFn + for i := range o { + v = &o[i] + if v.tag == tag { + return v + } + } + return nil +} + +type structFieldInfo struct { + encName string // encode name + fieldName string // field name + + // only one of 'i' or 'is' can be set. If 'i' is -1, then 'is' has been set. + + is []int // (recursive/embedded) field index in struct + i int16 // field index in struct + omitEmpty bool + toArray bool // if field is _struct, is the toArray set? +} + +// func (si *structFieldInfo) isZero() bool { +// return si.encName == "" && len(si.is) == 0 && si.i == 0 && !si.omitEmpty && !si.toArray +// } + +// rv returns the field of the struct. +// If anonymous, it returns an Invalid +func (si *structFieldInfo) field(v reflect.Value, update bool) (rv2 reflect.Value) { + if si.i != -1 { + v = v.Field(int(si.i)) + return v + } + // replicate FieldByIndex + for _, x := range si.is { + for v.Kind() == reflect.Ptr { + if v.IsNil() { + if !update { + return + } + v.Set(reflect.New(v.Type().Elem())) + } + v = v.Elem() + } + v = v.Field(x) + } + return v +} + +func (si *structFieldInfo) setToZeroValue(v reflect.Value) { + if si.i != -1 { + v = v.Field(int(si.i)) + v.Set(reflect.Zero(v.Type())) + // v.Set(reflect.New(v.Type()).Elem()) + // v.Set(reflect.New(v.Type())) + } else { + // replicate FieldByIndex + for _, x := range si.is { + for v.Kind() == reflect.Ptr { + if v.IsNil() { + return + } + v = v.Elem() + } + v = v.Field(x) + } + v.Set(reflect.Zero(v.Type())) + } +} + +func parseStructFieldInfo(fname string, stag string) *structFieldInfo { + // if fname == "" { + // panic(noFieldNameToStructFieldInfoErr) + // } + si := structFieldInfo{ + encName: fname, + } + + if stag != "" { + for i, s := range strings.Split(stag, ",") { + if i == 0 { + if s != "" { + si.encName = s + } + } else { + if s == "omitempty" { + si.omitEmpty = true + } else if s == "toarray" { + si.toArray = true + } + } + } + } + // si.encNameBs = []byte(si.encName) + return &si +} + +type sfiSortedByEncName []*structFieldInfo + +func (p sfiSortedByEncName) Len() int { + return len(p) +} + +func (p sfiSortedByEncName) Less(i, j int) bool { + return p[i].encName < p[j].encName +} + +func (p sfiSortedByEncName) Swap(i, j int) { + p[i], p[j] = p[j], p[i] +} + +// typeInfo keeps information about each type referenced in the encode/decode sequence. +// +// During an encode/decode sequence, we work as below: +// - If base is a built in type, en/decode base value +// - If base is registered as an extension, en/decode base value +// - If type is binary(M/Unm)arshaler, call Binary(M/Unm)arshal method +// - If type is text(M/Unm)arshaler, call Text(M/Unm)arshal method +// - Else decode appropriately based on the reflect.Kind +type typeInfo struct { + sfi []*structFieldInfo // sorted. Used when enc/dec struct to map. + sfip []*structFieldInfo // unsorted. Used when enc/dec struct to array. + + rt reflect.Type + rtid uintptr + + numMeth uint16 // number of methods + + // baseId gives pointer to the base reflect.Type, after deferencing + // the pointers. E.g. base type of ***time.Time is time.Time. + base reflect.Type + baseId uintptr + baseIndir int8 // number of indirections to get to base + + mbs bool // base type (T or *T) is a MapBySlice + + bm bool // base type (T or *T) is a binaryMarshaler + bunm bool // base type (T or *T) is a binaryUnmarshaler + bmIndir int8 // number of indirections to get to binaryMarshaler type + bunmIndir int8 // number of indirections to get to binaryUnmarshaler type + + tm bool // base type (T or *T) is a textMarshaler + tunm bool // base type (T or *T) is a textUnmarshaler + tmIndir int8 // number of indirections to get to textMarshaler type + tunmIndir int8 // number of indirections to get to textUnmarshaler type + + jm bool // base type (T or *T) is a jsonMarshaler + junm bool // base type (T or *T) is a jsonUnmarshaler + jmIndir int8 // number of indirections to get to jsonMarshaler type + junmIndir int8 // number of indirections to get to jsonUnmarshaler type + + cs bool // base type (T or *T) is a Selfer + csIndir int8 // number of indirections to get to Selfer type + + toArray bool // whether this (struct) type should be encoded as an array +} + +func (ti *typeInfo) indexForEncName(name string) int { + // NOTE: name may be a stringView, so don't pass it to another function. + //tisfi := ti.sfi + const binarySearchThreshold = 16 + if sfilen := len(ti.sfi); sfilen < binarySearchThreshold { + // linear search. faster than binary search in my testing up to 16-field structs. + for i, si := range ti.sfi { + if si.encName == name { + return i + } + } + } else { + // binary search. adapted from sort/search.go. + h, i, j := 0, 0, sfilen + for i < j { + h = i + (j-i)/2 + if ti.sfi[h].encName < name { + i = h + 1 + } else { + j = h + } + } + if i < sfilen && ti.sfi[i].encName == name { + return i + } + } + return -1 +} + +// TypeInfos caches typeInfo for each type on first inspection. +// +// It is configured with a set of tag keys, which are used to get +// configuration for the type. +type TypeInfos struct { + infos map[uintptr]*typeInfo + mu sync.RWMutex + tags []string +} + +// NewTypeInfos creates a TypeInfos given a set of struct tags keys. +// +// This allows users customize the struct tag keys which contain configuration +// of their types. +func NewTypeInfos(tags []string) *TypeInfos { + return &TypeInfos{tags: tags, infos: make(map[uintptr]*typeInfo, 64)} +} + +func (x *TypeInfos) structTag(t reflect.StructTag) (s string) { + // check for tags: codec, json, in that order. + // this allows seamless support for many configured structs. + for _, x := range x.tags { + s = t.Get(x) + if s != "" { + return s + } + } + return +} + +func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) { + var ok bool + x.mu.RLock() + pti, ok = x.infos[rtid] + x.mu.RUnlock() + if ok { + return + } + + // do not hold lock while computing this. + // it may lead to duplication, but that's ok. + ti := typeInfo{rt: rt, rtid: rtid} + ti.numMeth = uint16(rt.NumMethod()) + + var indir int8 + if ok, indir = implementsIntf(rt, binaryMarshalerTyp); ok { + ti.bm, ti.bmIndir = true, indir + } + if ok, indir = implementsIntf(rt, binaryUnmarshalerTyp); ok { + ti.bunm, ti.bunmIndir = true, indir + } + if ok, indir = implementsIntf(rt, textMarshalerTyp); ok { + ti.tm, ti.tmIndir = true, indir + } + if ok, indir = implementsIntf(rt, textUnmarshalerTyp); ok { + ti.tunm, ti.tunmIndir = true, indir + } + if ok, indir = implementsIntf(rt, jsonMarshalerTyp); ok { + ti.jm, ti.jmIndir = true, indir + } + if ok, indir = implementsIntf(rt, jsonUnmarshalerTyp); ok { + ti.junm, ti.junmIndir = true, indir + } + if ok, indir = implementsIntf(rt, selferTyp); ok { + ti.cs, ti.csIndir = true, indir + } + if ok, _ = implementsIntf(rt, mapBySliceTyp); ok { + ti.mbs = true + } + + pt := rt + var ptIndir int8 + // for ; pt.Kind() == reflect.Ptr; pt, ptIndir = pt.Elem(), ptIndir+1 { } + for pt.Kind() == reflect.Ptr { + pt = pt.Elem() + ptIndir++ + } + if ptIndir == 0 { + ti.base = rt + ti.baseId = rtid + } else { + ti.base = pt + ti.baseId = reflect.ValueOf(pt).Pointer() + ti.baseIndir = ptIndir + } + + if rt.Kind() == reflect.Struct { + var omitEmpty bool + if f, ok := rt.FieldByName(structInfoFieldName); ok { + siInfo := parseStructFieldInfo(structInfoFieldName, x.structTag(f.Tag)) + ti.toArray = siInfo.toArray + omitEmpty = siInfo.omitEmpty + } + pi := rgetPool.Get() + pv := pi.(*rgetPoolT) + pv.etypes[0] = ti.baseId + vv := rgetT{pv.fNames[:0], pv.encNames[:0], pv.etypes[:1], pv.sfis[:0]} + x.rget(rt, rtid, omitEmpty, nil, &vv) + ti.sfip, ti.sfi = rgetResolveSFI(vv.sfis, pv.sfiidx[:0]) + rgetPool.Put(pi) + } + // sfi = sfip + + x.mu.Lock() + if pti, ok = x.infos[rtid]; !ok { + pti = &ti + x.infos[rtid] = pti + } + x.mu.Unlock() + return +} + +func (x *TypeInfos) rget(rt reflect.Type, rtid uintptr, omitEmpty bool, + indexstack []int, pv *rgetT, +) { + // Read up fields and store how to access the value. + // + // It uses go's rules for message selectors, + // which say that the field with the shallowest depth is selected. + // + // Note: we consciously use slices, not a map, to simulate a set. + // Typically, types have < 16 fields, + // and iteration using equals is faster than maps there + +LOOP: + for j, jlen := 0, rt.NumField(); j < jlen; j++ { + f := rt.Field(j) + fkind := f.Type.Kind() + // skip if a func type, or is unexported, or structTag value == "-" + switch fkind { + case reflect.Func, reflect.Complex64, reflect.Complex128, reflect.UnsafePointer: + continue LOOP + } + + // if r1, _ := utf8.DecodeRuneInString(f.Name); + // r1 == utf8.RuneError || !unicode.IsUpper(r1) { + if f.PkgPath != "" && !f.Anonymous { // unexported, not embedded + continue + } + stag := x.structTag(f.Tag) + if stag == "-" { + continue + } + var si *structFieldInfo + // if anonymous and no struct tag (or it's blank), + // and a struct (or pointer to struct), inline it. + if f.Anonymous && fkind != reflect.Interface { + doInline := stag == "" + if !doInline { + si = parseStructFieldInfo("", stag) + doInline = si.encName == "" + // doInline = si.isZero() + } + if doInline { + ft := f.Type + for ft.Kind() == reflect.Ptr { + ft = ft.Elem() + } + if ft.Kind() == reflect.Struct { + // if etypes contains this, don't call rget again (as fields are already seen here) + ftid := reflect.ValueOf(ft).Pointer() + // We cannot recurse forever, but we need to track other field depths. + // So - we break if we see a type twice (not the first time). + // This should be sufficient to handle an embedded type that refers to its + // owning type, which then refers to its embedded type. + processIt := true + numk := 0 + for _, k := range pv.etypes { + if k == ftid { + numk++ + if numk == rgetMaxRecursion { + processIt = false + break + } + } + } + if processIt { + pv.etypes = append(pv.etypes, ftid) + indexstack2 := make([]int, len(indexstack)+1) + copy(indexstack2, indexstack) + indexstack2[len(indexstack)] = j + // indexstack2 := append(append(make([]int, 0, len(indexstack)+4), indexstack...), j) + x.rget(ft, ftid, omitEmpty, indexstack2, pv) + } + continue + } + } + } + + // after the anonymous dance: if an unexported field, skip + if f.PkgPath != "" { // unexported + continue + } + + if f.Name == "" { + panic(noFieldNameToStructFieldInfoErr) + } + + pv.fNames = append(pv.fNames, f.Name) + + if si == nil { + si = parseStructFieldInfo(f.Name, stag) + } else if si.encName == "" { + si.encName = f.Name + } + si.fieldName = f.Name + + pv.encNames = append(pv.encNames, si.encName) + + // si.ikind = int(f.Type.Kind()) + if len(indexstack) == 0 { + si.i = int16(j) + } else { + si.i = -1 + si.is = make([]int, len(indexstack)+1) + copy(si.is, indexstack) + si.is[len(indexstack)] = j + // si.is = append(append(make([]int, 0, len(indexstack)+4), indexstack...), j) + } + + if omitEmpty { + si.omitEmpty = true + } + pv.sfis = append(pv.sfis, si) + } +} + +// resolves the struct field info get from a call to rget2. +// Returns a trimmed, unsorted and sorted []*structFieldInfo. +func rgetResolveSFI(x []*structFieldInfo, pv []sfiIdx) (y, z []*structFieldInfo) { + var n int + for i, v := range x { + xf := v.fieldName + var found bool + for _, k := range pv { + if k.fieldName == xf { + if len(v.is) < len(x[k.index].is) { + x[k.index] = nil + k.index = i + n++ + } + found = true + break + } + } + if !found { + pv = append(pv, sfiIdx{xf, i}) + } + } + + // remove all the nils + y = make([]*structFieldInfo, len(x)-n) + n = 0 + for _, v := range x { + if v == nil { + continue + } + y[n] = v + n++ + } + + z = make([]*structFieldInfo, len(y)) + copy(z, y) + sort.Sort(sfiSortedByEncName(z)) + return +} + +func panicToErr(err *error) { + if recoverPanicToErr { + if x := recover(); x != nil { + //debug.PrintStack() + panicValToErr(x, err) + } + } +} + +// func doPanic(tag string, format string, params ...interface{}) { +// params2 := make([]interface{}, len(params)+1) +// params2[0] = tag +// copy(params2[1:], params) +// panic(fmt.Errorf("%s: "+format, params2...)) +// } + +func isImmutableKind(k reflect.Kind) (v bool) { + return false || + k == reflect.Int || + k == reflect.Int8 || + k == reflect.Int16 || + k == reflect.Int32 || + k == reflect.Int64 || + k == reflect.Uint || + k == reflect.Uint8 || + k == reflect.Uint16 || + k == reflect.Uint32 || + k == reflect.Uint64 || + k == reflect.Uintptr || + k == reflect.Float32 || + k == reflect.Float64 || + k == reflect.Bool || + k == reflect.String +} + +// these functions must be inlinable, and not call anybody +type checkOverflow struct{} + +func (_ checkOverflow) Float32(f float64) (overflow bool) { + if f < 0 { + f = -f + } + return math.MaxFloat32 < f && f <= math.MaxFloat64 +} + +func (_ checkOverflow) Uint(v uint64, bitsize uint8) (overflow bool) { + if bitsize == 0 || bitsize >= 64 || v == 0 { + return + } + if trunc := (v << (64 - bitsize)) >> (64 - bitsize); v != trunc { + overflow = true + } + return +} + +func (_ checkOverflow) Int(v int64, bitsize uint8) (overflow bool) { + if bitsize == 0 || bitsize >= 64 || v == 0 { + return + } + if trunc := (v << (64 - bitsize)) >> (64 - bitsize); v != trunc { + overflow = true + } + return +} + +func (_ checkOverflow) SignedInt(v uint64) (i int64, overflow bool) { + //e.g. -127 to 128 for int8 + pos := (v >> 63) == 0 + ui2 := v & 0x7fffffffffffffff + if pos { + if ui2 > math.MaxInt64 { + overflow = true + return + } + } else { + if ui2 > math.MaxInt64-1 { + overflow = true + return + } + } + i = int64(v) + return +} + +// ------------------ SORT ----------------- + +func isNaN(f float64) bool { return f != f } + +// ----------------------- + +type intSlice []int64 +type uintSlice []uint64 +type floatSlice []float64 +type boolSlice []bool +type stringSlice []string +type bytesSlice [][]byte + +func (p intSlice) Len() int { return len(p) } +func (p intSlice) Less(i, j int) bool { return p[i] < p[j] } +func (p intSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +func (p uintSlice) Len() int { return len(p) } +func (p uintSlice) Less(i, j int) bool { return p[i] < p[j] } +func (p uintSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +func (p floatSlice) Len() int { return len(p) } +func (p floatSlice) Less(i, j int) bool { + return p[i] < p[j] || isNaN(p[i]) && !isNaN(p[j]) +} +func (p floatSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +func (p stringSlice) Len() int { return len(p) } +func (p stringSlice) Less(i, j int) bool { return p[i] < p[j] } +func (p stringSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +func (p bytesSlice) Len() int { return len(p) } +func (p bytesSlice) Less(i, j int) bool { return bytes.Compare(p[i], p[j]) == -1 } +func (p bytesSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +func (p boolSlice) Len() int { return len(p) } +func (p boolSlice) Less(i, j int) bool { return !p[i] && p[j] } +func (p boolSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +// --------------------- + +type intRv struct { + v int64 + r reflect.Value +} +type intRvSlice []intRv +type uintRv struct { + v uint64 + r reflect.Value +} +type uintRvSlice []uintRv +type floatRv struct { + v float64 + r reflect.Value +} +type floatRvSlice []floatRv +type boolRv struct { + v bool + r reflect.Value +} +type boolRvSlice []boolRv +type stringRv struct { + v string + r reflect.Value +} +type stringRvSlice []stringRv +type bytesRv struct { + v []byte + r reflect.Value +} +type bytesRvSlice []bytesRv + +func (p intRvSlice) Len() int { return len(p) } +func (p intRvSlice) Less(i, j int) bool { return p[i].v < p[j].v } +func (p intRvSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +func (p uintRvSlice) Len() int { return len(p) } +func (p uintRvSlice) Less(i, j int) bool { return p[i].v < p[j].v } +func (p uintRvSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +func (p floatRvSlice) Len() int { return len(p) } +func (p floatRvSlice) Less(i, j int) bool { + return p[i].v < p[j].v || isNaN(p[i].v) && !isNaN(p[j].v) +} +func (p floatRvSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +func (p stringRvSlice) Len() int { return len(p) } +func (p stringRvSlice) Less(i, j int) bool { return p[i].v < p[j].v } +func (p stringRvSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +func (p bytesRvSlice) Len() int { return len(p) } +func (p bytesRvSlice) Less(i, j int) bool { return bytes.Compare(p[i].v, p[j].v) == -1 } +func (p bytesRvSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +func (p boolRvSlice) Len() int { return len(p) } +func (p boolRvSlice) Less(i, j int) bool { return !p[i].v && p[j].v } +func (p boolRvSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +// ----------------- + +type bytesI struct { + v []byte + i interface{} +} + +type bytesISlice []bytesI + +func (p bytesISlice) Len() int { return len(p) } +func (p bytesISlice) Less(i, j int) bool { return bytes.Compare(p[i].v, p[j].v) == -1 } +func (p bytesISlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +// ----------------- + +type set []uintptr + +func (s *set) add(v uintptr) (exists bool) { + // e.ci is always nil, or len >= 1 + // defer func() { fmt.Printf("$$$$$$$$$$$ cirRef Add: %v, exists: %v\n", v, exists) }() + x := *s + if x == nil { + x = make([]uintptr, 1, 8) + x[0] = v + *s = x + return + } + // typically, length will be 1. make this perform. + if len(x) == 1 { + if j := x[0]; j == 0 { + x[0] = v + } else if j == v { + exists = true + } else { + x = append(x, v) + *s = x + } + return + } + // check if it exists + for _, j := range x { + if j == v { + exists = true + return + } + } + // try to replace a "deleted" slot + for i, j := range x { + if j == 0 { + x[i] = v + return + } + } + // if unable to replace deleted slot, just append it. + x = append(x, v) + *s = x + return +} + +func (s *set) remove(v uintptr) (exists bool) { + // defer func() { fmt.Printf("$$$$$$$$$$$ cirRef Rm: %v, exists: %v\n", v, exists) }() + x := *s + if len(x) == 0 { + return + } + if len(x) == 1 { + if x[0] == v { + x[0] = 0 + } + return + } + for i, j := range x { + if j == v { + exists = true + x[i] = 0 // set it to 0, as way to delete it. + // copy(x[i:], x[i+1:]) + // x = x[:len(x)-1] + return + } + } + return +} diff --git a/vendor/github.com/ugorji/go/codec/helper_internal.go b/vendor/github.com/ugorji/go/codec/helper_internal.go new file mode 100644 index 00000000..5d0727f7 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/helper_internal.go @@ -0,0 +1,242 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +// All non-std package dependencies live in this file, +// so porting to different environment is easy (just update functions). + +import ( + "errors" + "fmt" + "math" + "reflect" +) + +func panicValToErr(panicVal interface{}, err *error) { + if panicVal == nil { + return + } + // case nil + switch xerr := panicVal.(type) { + case error: + *err = xerr + case string: + *err = errors.New(xerr) + default: + *err = fmt.Errorf("%v", panicVal) + } + return +} + +func hIsEmptyValue(v reflect.Value, deref, checkStruct bool) bool { + switch v.Kind() { + case reflect.Invalid: + return true + case reflect.Array, reflect.Map, reflect.Slice, reflect.String: + return v.Len() == 0 + case reflect.Bool: + return !v.Bool() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.Interface, reflect.Ptr: + if deref { + if v.IsNil() { + return true + } + return hIsEmptyValue(v.Elem(), deref, checkStruct) + } else { + return v.IsNil() + } + case reflect.Struct: + if !checkStruct { + return false + } + // return true if all fields are empty. else return false. + // we cannot use equality check, because some fields may be maps/slices/etc + // and consequently the structs are not comparable. + // return v.Interface() == reflect.Zero(v.Type()).Interface() + for i, n := 0, v.NumField(); i < n; i++ { + if !hIsEmptyValue(v.Field(i), deref, checkStruct) { + return false + } + } + return true + } + return false +} + +func isEmptyValue(v reflect.Value, deref, checkStruct bool) bool { + return hIsEmptyValue(v, deref, checkStruct) +} + +func pruneSignExt(v []byte, pos bool) (n int) { + if len(v) < 2 { + } else if pos && v[0] == 0 { + for ; v[n] == 0 && n+1 < len(v) && (v[n+1]&(1<<7) == 0); n++ { + } + } else if !pos && v[0] == 0xff { + for ; v[n] == 0xff && n+1 < len(v) && (v[n+1]&(1<<7) != 0); n++ { + } + } + return +} + +func implementsIntf(typ, iTyp reflect.Type) (success bool, indir int8) { + if typ == nil { + return + } + rt := typ + // The type might be a pointer and we need to keep + // dereferencing to the base type until we find an implementation. + for { + if rt.Implements(iTyp) { + return true, indir + } + if p := rt; p.Kind() == reflect.Ptr { + indir++ + if indir >= math.MaxInt8 { // insane number of indirections + return false, 0 + } + rt = p.Elem() + continue + } + break + } + // No luck yet, but if this is a base type (non-pointer), the pointer might satisfy. + if typ.Kind() != reflect.Ptr { + // Not a pointer, but does the pointer work? + if reflect.PtrTo(typ).Implements(iTyp) { + return true, -1 + } + } + return false, 0 +} + +// validate that this function is correct ... +// culled from OGRE (Object-Oriented Graphics Rendering Engine) +// function: halfToFloatI (http://stderr.org/doc/ogre-doc/api/OgreBitwise_8h-source.html) +func halfFloatToFloatBits(yy uint16) (d uint32) { + y := uint32(yy) + s := (y >> 15) & 0x01 + e := (y >> 10) & 0x1f + m := y & 0x03ff + + if e == 0 { + if m == 0 { // plu or minus 0 + return s << 31 + } else { // Denormalized number -- renormalize it + for (m & 0x00000400) == 0 { + m <<= 1 + e -= 1 + } + e += 1 + const zz uint32 = 0x0400 + m &= ^zz + } + } else if e == 31 { + if m == 0 { // Inf + return (s << 31) | 0x7f800000 + } else { // NaN + return (s << 31) | 0x7f800000 | (m << 13) + } + } + e = e + (127 - 15) + m = m << 13 + return (s << 31) | (e << 23) | m +} + +// GrowCap will return a new capacity for a slice, given the following: +// - oldCap: current capacity +// - unit: in-memory size of an element +// - num: number of elements to add +func growCap(oldCap, unit, num int) (newCap int) { + // appendslice logic (if cap < 1024, *2, else *1.25): + // leads to many copy calls, especially when copying bytes. + // bytes.Buffer model (2*cap + n): much better for bytes. + // smarter way is to take the byte-size of the appended element(type) into account + + // maintain 3 thresholds: + // t1: if cap <= t1, newcap = 2x + // t2: if cap <= t2, newcap = 1.75x + // t3: if cap <= t3, newcap = 1.5x + // else newcap = 1.25x + // + // t1, t2, t3 >= 1024 always. + // i.e. if unit size >= 16, then always do 2x or 1.25x (ie t1, t2, t3 are all same) + // + // With this, appending for bytes increase by: + // 100% up to 4K + // 75% up to 8K + // 50% up to 16K + // 25% beyond that + + // unit can be 0 e.g. for struct{}{}; handle that appropriately + var t1, t2, t3 int // thresholds + if unit <= 1 { + t1, t2, t3 = 4*1024, 8*1024, 16*1024 + } else if unit < 16 { + t3 = 16 / unit * 1024 + t1 = t3 * 1 / 4 + t2 = t3 * 2 / 4 + } else { + t1, t2, t3 = 1024, 1024, 1024 + } + + var x int // temporary variable + + // x is multiplier here: one of 5, 6, 7 or 8; incr of 25%, 50%, 75% or 100% respectively + if oldCap <= t1 { // [0,t1] + x = 8 + } else if oldCap > t3 { // (t3,infinity] + x = 5 + } else if oldCap <= t2 { // (t1,t2] + x = 7 + } else { // (t2,t3] + x = 6 + } + newCap = x * oldCap / 4 + + if num > 0 { + newCap += num + } + + // ensure newCap is a multiple of 64 (if it is > 64) or 16. + if newCap > 64 { + if x = newCap % 64; x != 0 { + x = newCap / 64 + newCap = 64 * (x + 1) + } + } else { + if x = newCap % 16; x != 0 { + x = newCap / 16 + newCap = 16 * (x + 1) + } + } + return +} + +func expandSliceValue(s reflect.Value, num int) reflect.Value { + if num <= 0 { + return s + } + l0 := s.Len() + l1 := l0 + num // new slice length + if l1 < l0 { + panic("ExpandSlice: slice overflow") + } + c0 := s.Cap() + if l1 <= c0 { + return s.Slice(0, l1) + } + st := s.Type() + c1 := growCap(c0, int(st.Elem().Size()), num) + s2 := reflect.MakeSlice(st, l1, c1) + // println("expandslicevalue: cap-old: ", c0, ", cap-new: ", c1, ", len-new: ", l1) + reflect.Copy(s2, s) + return s2 +} diff --git a/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go new file mode 100644 index 00000000..7c2ffc0f --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go @@ -0,0 +1,20 @@ +//+build !unsafe + +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +// stringView returns a view of the []byte as a string. +// In unsafe mode, it doesn't incur allocation and copying caused by conversion. +// In regular safe mode, it is an allocation and copy. +func stringView(v []byte) string { + return string(v) +} + +// bytesView returns a view of the string as a []byte. +// In unsafe mode, it doesn't incur allocation and copying caused by conversion. +// In regular safe mode, it is an allocation and copy. +func bytesView(v string) []byte { + return []byte(v) +} diff --git a/vendor/github.com/ugorji/go/codec/helper_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_unsafe.go new file mode 100644 index 00000000..2928e4f7 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/helper_unsafe.go @@ -0,0 +1,49 @@ +//+build unsafe + +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "unsafe" +) + +// This file has unsafe variants of some helper methods. + +type unsafeString struct { + Data uintptr + Len int +} + +type unsafeSlice struct { + Data uintptr + Len int + Cap int +} + +// stringView returns a view of the []byte as a string. +// In unsafe mode, it doesn't incur allocation and copying caused by conversion. +// In regular safe mode, it is an allocation and copy. +func stringView(v []byte) string { + if len(v) == 0 { + return "" + } + + bx := (*unsafeSlice)(unsafe.Pointer(&v)) + sx := unsafeString{bx.Data, bx.Len} + return *(*string)(unsafe.Pointer(&sx)) +} + +// bytesView returns a view of the string as a []byte. +// In unsafe mode, it doesn't incur allocation and copying caused by conversion. +// In regular safe mode, it is an allocation and copy. +func bytesView(v string) []byte { + if len(v) == 0 { + return zeroByteSlice + } + + sx := (*unsafeString)(unsafe.Pointer(&v)) + bx := unsafeSlice{sx.Data, sx.Len, sx.Len} + return *(*[]byte)(unsafe.Pointer(&bx)) +} diff --git a/vendor/github.com/ugorji/go/codec/json.go b/vendor/github.com/ugorji/go/codec/json.go new file mode 100644 index 00000000..a04dfcb9 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/json.go @@ -0,0 +1,1213 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +// By default, this json support uses base64 encoding for bytes, because you cannot +// store and read any arbitrary string in json (only unicode). +// However, the user can configre how to encode/decode bytes. +// +// This library specifically supports UTF-8 for encoding and decoding only. +// +// Note that the library will happily encode/decode things which are not valid +// json e.g. a map[int64]string. We do it for consistency. With valid json, +// we will encode and decode appropriately. +// Users can specify their map type if necessary to force it. +// +// Note: +// - we cannot use strconv.Quote and strconv.Unquote because json quotes/unquotes differently. +// We implement it here. +// - Also, strconv.ParseXXX for floats and integers +// - only works on strings resulting in unnecessary allocation and []byte-string conversion. +// - it does a lot of redundant checks, because json numbers are simpler that what it supports. +// - We parse numbers (floats and integers) directly here. +// We only delegate parsing floats if it is a hairy float which could cause a loss of precision. +// In that case, we delegate to strconv.ParseFloat. +// +// Note: +// - encode does not beautify. There is no whitespace when encoding. +// - rpc calls which take single integer arguments or write single numeric arguments will need care. + +// Top-level methods of json(End|Dec)Driver (which are implementations of (en|de)cDriver +// MUST not call one-another. + +import ( + "bytes" + "encoding/base64" + "fmt" + "reflect" + "strconv" + "unicode/utf16" + "unicode/utf8" +) + +//-------------------------------- + +var ( + jsonLiterals = [...]byte{'t', 'r', 'u', 'e', 'f', 'a', 'l', 's', 'e', 'n', 'u', 'l', 'l'} + + jsonFloat64Pow10 = [...]float64{ + 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, + 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, + 1e20, 1e21, 1e22, + } + + jsonUint64Pow10 = [...]uint64{ + 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, + 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, + } + + // jsonTabs and jsonSpaces are used as caches for indents + jsonTabs, jsonSpaces string +) + +const ( + // jsonUnreadAfterDecNum controls whether we unread after decoding a number. + // + // instead of unreading, just update d.tok (iff it's not a whitespace char) + // However, doing this means that we may HOLD onto some data which belongs to another stream. + // Thus, it is safest to unread the data when done. + // keep behind a constant flag for now. + jsonUnreadAfterDecNum = true + + // If !jsonValidateSymbols, decoding will be faster, by skipping some checks: + // - If we see first character of null, false or true, + // do not validate subsequent characters. + // - e.g. if we see a n, assume null and skip next 3 characters, + // and do not validate they are ull. + // P.S. Do not expect a significant decoding boost from this. + jsonValidateSymbols = true + + // if jsonTruncateMantissa, truncate mantissa if trailing 0's. + // This is important because it could allow some floats to be decoded without + // deferring to strconv.ParseFloat. + jsonTruncateMantissa = true + + // if mantissa >= jsonNumUintCutoff before multiplying by 10, this is an overflow + jsonNumUintCutoff = (1<<64-1)/uint64(10) + 1 // cutoff64(base) + + // if mantissa >= jsonNumUintMaxVal, this is an overflow + jsonNumUintMaxVal = 1< 1<<53 || v < -(1<<53)) { + e.w.writen1('"') + e.w.writeb(strconv.AppendInt(e.b[:0], v, 10)) + e.w.writen1('"') + return + } + e.w.writeb(strconv.AppendInt(e.b[:0], v, 10)) +} + +func (e *jsonEncDriver) EncodeUint(v uint64) { + if x := e.h.IntegerAsString; x == 'A' || x == 'L' && v > 1<<53 { + e.w.writen1('"') + e.w.writeb(strconv.AppendUint(e.b[:0], v, 10)) + e.w.writen1('"') + return + } + e.w.writeb(strconv.AppendUint(e.b[:0], v, 10)) +} + +func (e *jsonEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Encoder) { + if v := ext.ConvertExt(rv); v == nil { + e.w.writeb(jsonLiterals[9:13]) // null // e.EncodeNil() + } else { + en.encode(v) + } +} + +func (e *jsonEncDriver) EncodeRawExt(re *RawExt, en *Encoder) { + // only encodes re.Value (never re.Data) + if re.Value == nil { + e.w.writeb(jsonLiterals[9:13]) // null // e.EncodeNil() + } else { + en.encode(re.Value) + } +} + +func (e *jsonEncDriver) EncodeArrayStart(length int) { + if e.d { + e.dl++ + } + e.w.writen1('[') + e.c = containerArrayStart +} + +func (e *jsonEncDriver) EncodeMapStart(length int) { + if e.d { + e.dl++ + } + e.w.writen1('{') + e.c = containerMapStart +} + +func (e *jsonEncDriver) EncodeString(c charEncoding, v string) { + // e.w.writestr(strconv.Quote(v)) + e.quoteStr(v) +} + +func (e *jsonEncDriver) EncodeSymbol(v string) { + // e.EncodeString(c_UTF8, v) + e.quoteStr(v) +} + +func (e *jsonEncDriver) EncodeStringBytes(c charEncoding, v []byte) { + // if encoding raw bytes and RawBytesExt is configured, use it to encode + if c == c_RAW && e.se.i != nil { + e.EncodeExt(v, 0, &e.se, e.e) + return + } + if c == c_RAW { + slen := base64.StdEncoding.EncodedLen(len(v)) + if cap(e.bs) >= slen { + e.bs = e.bs[:slen] + } else { + e.bs = make([]byte, slen) + } + base64.StdEncoding.Encode(e.bs, v) + e.w.writen1('"') + e.w.writeb(e.bs) + e.w.writen1('"') + } else { + // e.EncodeString(c, string(v)) + e.quoteStr(stringView(v)) + } +} + +func (e *jsonEncDriver) EncodeAsis(v []byte) { + e.w.writeb(v) +} + +func (e *jsonEncDriver) quoteStr(s string) { + // adapted from std pkg encoding/json + const hex = "0123456789abcdef" + w := e.w + w.writen1('"') + start := 0 + for i := 0; i < len(s); { + if b := s[i]; b < utf8.RuneSelf { + if 0x20 <= b && b != '\\' && b != '"' && b != '<' && b != '>' && b != '&' { + i++ + continue + } + if start < i { + w.writestr(s[start:i]) + } + switch b { + case '\\', '"': + w.writen2('\\', b) + case '\n': + w.writen2('\\', 'n') + case '\r': + w.writen2('\\', 'r') + case '\b': + w.writen2('\\', 'b') + case '\f': + w.writen2('\\', 'f') + case '\t': + w.writen2('\\', 't') + default: + // encode all bytes < 0x20 (except \r, \n). + // also encode < > & to prevent security holes when served to some browsers. + w.writestr(`\u00`) + w.writen2(hex[b>>4], hex[b&0xF]) + } + i++ + start = i + continue + } + c, size := utf8.DecodeRuneInString(s[i:]) + if c == utf8.RuneError && size == 1 { + if start < i { + w.writestr(s[start:i]) + } + w.writestr(`\ufffd`) + i += size + start = i + continue + } + // U+2028 is LINE SEPARATOR. U+2029 is PARAGRAPH SEPARATOR. + // Both technically valid JSON, but bomb on JSONP, so fix here. + if c == '\u2028' || c == '\u2029' { + if start < i { + w.writestr(s[start:i]) + } + w.writestr(`\u202`) + w.writen1(hex[c&0xF]) + i += size + start = i + continue + } + i += size + } + if start < len(s) { + w.writestr(s[start:]) + } + w.writen1('"') +} + +//-------------------------------- + +type jsonNum struct { + // bytes []byte // may have [+-.eE0-9] + mantissa uint64 // where mantissa ends, and maybe dot begins. + exponent int16 // exponent value. + manOverflow bool + neg bool // started with -. No initial sign in the bytes above. + dot bool // has dot + explicitExponent bool // explicit exponent +} + +func (x *jsonNum) reset() { + x.manOverflow = false + x.neg = false + x.dot = false + x.explicitExponent = false + x.mantissa = 0 + x.exponent = 0 +} + +// uintExp is called only if exponent > 0. +func (x *jsonNum) uintExp() (n uint64, overflow bool) { + n = x.mantissa + e := x.exponent + if e >= int16(len(jsonUint64Pow10)) { + overflow = true + return + } + n *= jsonUint64Pow10[e] + if n < x.mantissa || n > jsonNumUintMaxVal { + overflow = true + return + } + return + // for i := int16(0); i < e; i++ { + // if n >= jsonNumUintCutoff { + // overflow = true + // return + // } + // n *= 10 + // } + // return +} + +// these constants are only used withn floatVal. +// They are brought out, so that floatVal can be inlined. +const ( + jsonUint64MantissaBits = 52 + jsonMaxExponent = int16(len(jsonFloat64Pow10)) - 1 +) + +func (x *jsonNum) floatVal() (f float64, parseUsingStrConv bool) { + // We do not want to lose precision. + // Consequently, we will delegate to strconv.ParseFloat if any of the following happen: + // - There are more digits than in math.MaxUint64: 18446744073709551615 (20 digits) + // We expect up to 99.... (19 digits) + // - The mantissa cannot fit into a 52 bits of uint64 + // - The exponent is beyond our scope ie beyong 22. + parseUsingStrConv = x.manOverflow || + x.exponent > jsonMaxExponent || + (x.exponent < 0 && -(x.exponent) > jsonMaxExponent) || + x.mantissa>>jsonUint64MantissaBits != 0 + + if parseUsingStrConv { + return + } + + // all good. so handle parse here. + f = float64(x.mantissa) + // fmt.Printf(".Float: uint64 value: %v, float: %v\n", m, f) + if x.neg { + f = -f + } + if x.exponent > 0 { + f *= jsonFloat64Pow10[x.exponent] + } else if x.exponent < 0 { + f /= jsonFloat64Pow10[-x.exponent] + } + return +} + +type jsonDecDriver struct { + noBuiltInTypes + d *Decoder + h *JsonHandle + r decReader + + c containerState + // tok is used to store the token read right after skipWhiteSpace. + tok uint8 + + bstr [8]byte // scratch used for string \UXXX parsing + b [64]byte // scratch, used for parsing strings or numbers + b2 [64]byte // scratch, used only for decodeBytes (after base64) + bs []byte // scratch. Initialized from b. Used for parsing strings or numbers. + + se setExtWrapper + + n jsonNum +} + +func jsonIsWS(b byte) bool { + return b == ' ' || b == '\t' || b == '\r' || b == '\n' +} + +// // This will skip whitespace characters and return the next byte to read. +// // The next byte determines what the value will be one of. +// func (d *jsonDecDriver) skipWhitespace() { +// // fast-path: do not enter loop. Just check first (in case no whitespace). +// b := d.r.readn1() +// if jsonIsWS(b) { +// r := d.r +// for b = r.readn1(); jsonIsWS(b); b = r.readn1() { +// } +// } +// d.tok = b +// } + +func (d *jsonDecDriver) uncacheRead() { + if d.tok != 0 { + d.r.unreadn1() + d.tok = 0 + } +} + +func (d *jsonDecDriver) sendContainerState(c containerState) { + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + var xc uint8 // char expected + if c == containerMapKey { + if d.c != containerMapStart { + xc = ',' + } + } else if c == containerMapValue { + xc = ':' + } else if c == containerMapEnd { + xc = '}' + } else if c == containerArrayElem { + if d.c != containerArrayStart { + xc = ',' + } + } else if c == containerArrayEnd { + xc = ']' + } + if xc != 0 { + if d.tok != xc { + d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok) + } + d.tok = 0 + } + d.c = c +} + +func (d *jsonDecDriver) CheckBreak() bool { + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + if d.tok == '}' || d.tok == ']' { + // d.tok = 0 // only checking, not consuming + return true + } + return false +} + +func (d *jsonDecDriver) readStrIdx(fromIdx, toIdx uint8) { + bs := d.r.readx(int(toIdx - fromIdx)) + d.tok = 0 + if jsonValidateSymbols { + if !bytes.Equal(bs, jsonLiterals[fromIdx:toIdx]) { + d.d.errorf("json: expecting %s: got %s", jsonLiterals[fromIdx:toIdx], bs) + return + } + } +} + +func (d *jsonDecDriver) TryDecodeAsNil() bool { + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + if d.tok == 'n' { + d.readStrIdx(10, 13) // ull + return true + } + return false +} + +func (d *jsonDecDriver) DecodeBool() bool { + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + if d.tok == 'f' { + d.readStrIdx(5, 9) // alse + return false + } + if d.tok == 't' { + d.readStrIdx(1, 4) // rue + return true + } + d.d.errorf("json: decode bool: got first char %c", d.tok) + return false // "unreachable" +} + +func (d *jsonDecDriver) ReadMapStart() int { + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + if d.tok != '{' { + d.d.errorf("json: expect char '%c' but got char '%c'", '{', d.tok) + } + d.tok = 0 + d.c = containerMapStart + return -1 +} + +func (d *jsonDecDriver) ReadArrayStart() int { + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + if d.tok != '[' { + d.d.errorf("json: expect char '%c' but got char '%c'", '[', d.tok) + } + d.tok = 0 + d.c = containerArrayStart + return -1 +} + +func (d *jsonDecDriver) ContainerType() (vt valueType) { + // check container type by checking the first char + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + if b := d.tok; b == '{' { + return valueTypeMap + } else if b == '[' { + return valueTypeArray + } else if b == 'n' { + return valueTypeNil + } else if b == '"' { + return valueTypeString + } + return valueTypeUnset + // d.d.errorf("isContainerType: unsupported parameter: %v", vt) + // return false // "unreachable" +} + +func (d *jsonDecDriver) decNum(storeBytes bool) { + // If it is has a . or an e|E, decode as a float; else decode as an int. + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + b := d.tok + var str bool + if b == '"' { + str = true + b = d.r.readn1() + } + if !(b == '+' || b == '-' || b == '.' || (b >= '0' && b <= '9')) { + d.d.errorf("json: decNum: got first char '%c'", b) + return + } + d.tok = 0 + + const cutoff = (1<<64-1)/uint64(10) + 1 // cutoff64(base) + const jsonNumUintMaxVal = 1<= jsonNumUintCutoff { + n.manOverflow = true + break + } + v := uint64(b - '0') + n.mantissa *= 10 + if v != 0 { + n1 := n.mantissa + v + if n1 < n.mantissa || n1 > jsonNumUintMaxVal { + n.manOverflow = true // n+v overflows + break + } + n.mantissa = n1 + } + case 6: + state = 7 + fallthrough + case 7: + if !(b == '0' && e == 0) { + e = e*10 + int16(b-'0') + } + default: + break LOOP + } + case '"': + if str { + if storeBytes { + d.bs = append(d.bs, '"') + } + b, eof = r.readn1eof() + } + break LOOP + default: + break LOOP + } + if storeBytes { + d.bs = append(d.bs, b) + } + b, eof = r.readn1eof() + } + + if jsonTruncateMantissa && n.mantissa != 0 { + for n.mantissa%10 == 0 { + n.mantissa /= 10 + n.exponent++ + } + } + + if e != 0 { + if eNeg { + n.exponent -= e + } else { + n.exponent += e + } + } + + // d.n = n + + if !eof { + if jsonUnreadAfterDecNum { + r.unreadn1() + } else { + if !jsonIsWS(b) { + d.tok = b + } + } + } + // fmt.Printf("1: n: bytes: %s, neg: %v, dot: %v, exponent: %v, mantissaEndIndex: %v\n", + // n.bytes, n.neg, n.dot, n.exponent, n.mantissaEndIndex) + return +} + +func (d *jsonDecDriver) DecodeInt(bitsize uint8) (i int64) { + d.decNum(false) + n := &d.n + if n.manOverflow { + d.d.errorf("json: overflow integer after: %v", n.mantissa) + return + } + var u uint64 + if n.exponent == 0 { + u = n.mantissa + } else if n.exponent < 0 { + d.d.errorf("json: fractional integer") + return + } else if n.exponent > 0 { + var overflow bool + if u, overflow = n.uintExp(); overflow { + d.d.errorf("json: overflow integer") + return + } + } + i = int64(u) + if n.neg { + i = -i + } + if chkOvf.Int(i, bitsize) { + d.d.errorf("json: overflow %v bits: %s", bitsize, d.bs) + return + } + // fmt.Printf("DecodeInt: %v\n", i) + return +} + +// floatVal MUST only be called after a decNum, as d.bs now contains the bytes of the number +func (d *jsonDecDriver) floatVal() (f float64) { + f, useStrConv := d.n.floatVal() + if useStrConv { + var err error + if f, err = strconv.ParseFloat(stringView(d.bs), 64); err != nil { + panic(fmt.Errorf("parse float: %s, %v", d.bs, err)) + } + if d.n.neg { + f = -f + } + } + return +} + +func (d *jsonDecDriver) DecodeUint(bitsize uint8) (u uint64) { + d.decNum(false) + n := &d.n + if n.neg { + d.d.errorf("json: unsigned integer cannot be negative") + return + } + if n.manOverflow { + d.d.errorf("json: overflow integer after: %v", n.mantissa) + return + } + if n.exponent == 0 { + u = n.mantissa + } else if n.exponent < 0 { + d.d.errorf("json: fractional integer") + return + } else if n.exponent > 0 { + var overflow bool + if u, overflow = n.uintExp(); overflow { + d.d.errorf("json: overflow integer") + return + } + } + if chkOvf.Uint(u, bitsize) { + d.d.errorf("json: overflow %v bits: %s", bitsize, d.bs) + return + } + // fmt.Printf("DecodeUint: %v\n", u) + return +} + +func (d *jsonDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) { + d.decNum(true) + f = d.floatVal() + if chkOverflow32 && chkOvf.Float32(f) { + d.d.errorf("json: overflow float32: %v, %s", f, d.bs) + return + } + return +} + +func (d *jsonDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) { + if ext == nil { + re := rv.(*RawExt) + re.Tag = xtag + d.d.decode(&re.Value) + } else { + var v interface{} + d.d.decode(&v) + ext.UpdateExt(rv, v) + } + return +} + +func (d *jsonDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) { + // if decoding into raw bytes, and the RawBytesExt is configured, use it to decode. + if !isstring && d.se.i != nil { + bsOut = bs + d.DecodeExt(&bsOut, 0, &d.se) + return + } + d.appendStringAsBytes() + // if isstring, then just return the bytes, even if it is using the scratch buffer. + // the bytes will be converted to a string as needed. + if isstring { + return d.bs + } + bs0 := d.bs + slen := base64.StdEncoding.DecodedLen(len(bs0)) + if slen <= cap(bs) { + bsOut = bs[:slen] + } else if zerocopy && slen <= cap(d.b2) { + bsOut = d.b2[:slen] + } else { + bsOut = make([]byte, slen) + } + slen2, err := base64.StdEncoding.Decode(bsOut, bs0) + if err != nil { + d.d.errorf("json: error decoding base64 binary '%s': %v", bs0, err) + return nil + } + if slen != slen2 { + bsOut = bsOut[:slen2] + } + return +} + +func (d *jsonDecDriver) DecodeString() (s string) { + d.appendStringAsBytes() + // if x := d.s.sc; x != nil && x.so && x.st == '}' { // map key + if d.c == containerMapKey { + return d.d.string(d.bs) + } + return string(d.bs) +} + +func (d *jsonDecDriver) appendStringAsBytes() { + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + if d.tok != '"' { + d.d.errorf("json: expect char '%c' but got char '%c'", '"', d.tok) + } + d.tok = 0 + + v := d.bs[:0] + var c uint8 + r := d.r + for { + c = r.readn1() + if c == '"' { + break + } else if c == '\\' { + c = r.readn1() + switch c { + case '"', '\\', '/', '\'': + v = append(v, c) + case 'b': + v = append(v, '\b') + case 'f': + v = append(v, '\f') + case 'n': + v = append(v, '\n') + case 'r': + v = append(v, '\r') + case 't': + v = append(v, '\t') + case 'u': + rr := d.jsonU4(false) + // fmt.Printf("$$$$$$$$$: is surrogate: %v\n", utf16.IsSurrogate(rr)) + if utf16.IsSurrogate(rr) { + rr = utf16.DecodeRune(rr, d.jsonU4(true)) + } + w2 := utf8.EncodeRune(d.bstr[:], rr) + v = append(v, d.bstr[:w2]...) + default: + d.d.errorf("json: unsupported escaped value: %c", c) + } + } else { + v = append(v, c) + } + } + d.bs = v +} + +func (d *jsonDecDriver) jsonU4(checkSlashU bool) rune { + r := d.r + if checkSlashU && !(r.readn1() == '\\' && r.readn1() == 'u') { + d.d.errorf(`json: unquoteStr: invalid unicode sequence. Expecting \u`) + return 0 + } + // u, _ := strconv.ParseUint(string(d.bstr[:4]), 16, 64) + var u uint32 + for i := 0; i < 4; i++ { + v := r.readn1() + if '0' <= v && v <= '9' { + v = v - '0' + } else if 'a' <= v && v <= 'z' { + v = v - 'a' + 10 + } else if 'A' <= v && v <= 'Z' { + v = v - 'A' + 10 + } else { + d.d.errorf(`json: unquoteStr: invalid hex char in \u unicode sequence: %q`, v) + return 0 + } + u = u*16 + uint32(v) + } + return rune(u) +} + +func (d *jsonDecDriver) DecodeNaked() { + z := &d.d.n + // var decodeFurther bool + + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + switch d.tok { + case 'n': + d.readStrIdx(10, 13) // ull + z.v = valueTypeNil + case 'f': + d.readStrIdx(5, 9) // alse + z.v = valueTypeBool + z.b = false + case 't': + d.readStrIdx(1, 4) // rue + z.v = valueTypeBool + z.b = true + case '{': + z.v = valueTypeMap + // d.tok = 0 // don't consume. kInterfaceNaked will call ReadMapStart + // decodeFurther = true + case '[': + z.v = valueTypeArray + // d.tok = 0 // don't consume. kInterfaceNaked will call ReadArrayStart + // decodeFurther = true + case '"': + z.v = valueTypeString + z.s = d.DecodeString() + default: // number + d.decNum(true) + n := &d.n + // if the string had a any of [.eE], then decode as float. + switch { + case n.explicitExponent, n.dot, n.exponent < 0, n.manOverflow: + z.v = valueTypeFloat + z.f = d.floatVal() + case n.exponent == 0: + u := n.mantissa + switch { + case n.neg: + z.v = valueTypeInt + z.i = -int64(u) + case d.h.SignedInteger: + z.v = valueTypeInt + z.i = int64(u) + default: + z.v = valueTypeUint + z.u = u + } + default: + u, overflow := n.uintExp() + switch { + case overflow: + z.v = valueTypeFloat + z.f = d.floatVal() + case n.neg: + z.v = valueTypeInt + z.i = -int64(u) + case d.h.SignedInteger: + z.v = valueTypeInt + z.i = int64(u) + default: + z.v = valueTypeUint + z.u = u + } + } + // fmt.Printf("DecodeNaked: Number: %T, %v\n", v, v) + } + // if decodeFurther { + // d.s.sc.retryRead() + // } + return +} + +//---------------------- + +// JsonHandle is a handle for JSON encoding format. +// +// Json is comprehensively supported: +// - decodes numbers into interface{} as int, uint or float64 +// - configurable way to encode/decode []byte . +// by default, encodes and decodes []byte using base64 Std Encoding +// - UTF-8 support for encoding and decoding +// +// It has better performance than the json library in the standard library, +// by leveraging the performance improvements of the codec library and +// minimizing allocations. +// +// In addition, it doesn't read more bytes than necessary during a decode, which allows +// reading multiple values from a stream containing json and non-json content. +// For example, a user can read a json value, then a cbor value, then a msgpack value, +// all from the same stream in sequence. +type JsonHandle struct { + textEncodingType + BasicHandle + // RawBytesExt, if configured, is used to encode and decode raw bytes in a custom way. + // If not configured, raw bytes are encoded to/from base64 text. + RawBytesExt InterfaceExt + + // Indent indicates how a value is encoded. + // - If positive, indent by that number of spaces. + // - If negative, indent by that number of tabs. + Indent int8 + + // IntegerAsString controls how integers (signed and unsigned) are encoded. + // + // Per the JSON Spec, JSON numbers are 64-bit floating point numbers. + // Consequently, integers > 2^53 cannot be represented as a JSON number without losing precision. + // This can be mitigated by configuring how to encode integers. + // + // IntegerAsString interpretes the following values: + // - if 'L', then encode integers > 2^53 as a json string. + // - if 'A', then encode all integers as a json string + // containing the exact integer representation as a decimal. + // - else encode all integers as a json number (default) + IntegerAsString uint8 +} + +func (h *JsonHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) { + return h.SetExt(rt, tag, &setExtWrapper{i: ext}) +} + +func (h *JsonHandle) newEncDriver(e *Encoder) encDriver { + hd := jsonEncDriver{e: e, h: h} + hd.bs = hd.b[:0] + + hd.reset() + + return &hd +} + +func (h *JsonHandle) newDecDriver(d *Decoder) decDriver { + // d := jsonDecDriver{r: r.(*bytesDecReader), h: h} + hd := jsonDecDriver{d: d, h: h} + hd.bs = hd.b[:0] + hd.reset() + return &hd +} + +func (e *jsonEncDriver) reset() { + e.w = e.e.w + e.se.i = e.h.RawBytesExt + if e.bs != nil { + e.bs = e.bs[:0] + } + e.d, e.dt, e.dl, e.ds = false, false, 0, "" + e.c = 0 + if e.h.Indent > 0 { + e.d = true + e.ds = jsonSpaces[:e.h.Indent] + } else if e.h.Indent < 0 { + e.d = true + e.dt = true + e.ds = jsonTabs[:-(e.h.Indent)] + } +} + +func (d *jsonDecDriver) reset() { + d.r = d.d.r + d.se.i = d.h.RawBytesExt + if d.bs != nil { + d.bs = d.bs[:0] + } + d.c, d.tok = 0, 0 + d.n.reset() +} + +var jsonEncodeTerminate = []byte{' '} + +func (h *JsonHandle) rpcEncodeTerminate() []byte { + return jsonEncodeTerminate +} + +var _ decDriver = (*jsonDecDriver)(nil) +var _ encDriver = (*jsonEncDriver)(nil) diff --git a/vendor/github.com/ugorji/go/codec/msgpack.go b/vendor/github.com/ugorji/go/codec/msgpack.go new file mode 100644 index 00000000..f9f87236 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/msgpack.go @@ -0,0 +1,845 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +/* +MSGPACK + +Msgpack-c implementation powers the c, c++, python, ruby, etc libraries. +We need to maintain compatibility with it and how it encodes integer values +without caring about the type. + +For compatibility with behaviour of msgpack-c reference implementation: + - Go intX (>0) and uintX + IS ENCODED AS + msgpack +ve fixnum, unsigned + - Go intX (<0) + IS ENCODED AS + msgpack -ve fixnum, signed + +*/ +package codec + +import ( + "fmt" + "io" + "math" + "net/rpc" + "reflect" +) + +const ( + mpPosFixNumMin byte = 0x00 + mpPosFixNumMax = 0x7f + mpFixMapMin = 0x80 + mpFixMapMax = 0x8f + mpFixArrayMin = 0x90 + mpFixArrayMax = 0x9f + mpFixStrMin = 0xa0 + mpFixStrMax = 0xbf + mpNil = 0xc0 + _ = 0xc1 + mpFalse = 0xc2 + mpTrue = 0xc3 + mpFloat = 0xca + mpDouble = 0xcb + mpUint8 = 0xcc + mpUint16 = 0xcd + mpUint32 = 0xce + mpUint64 = 0xcf + mpInt8 = 0xd0 + mpInt16 = 0xd1 + mpInt32 = 0xd2 + mpInt64 = 0xd3 + + // extensions below + mpBin8 = 0xc4 + mpBin16 = 0xc5 + mpBin32 = 0xc6 + mpExt8 = 0xc7 + mpExt16 = 0xc8 + mpExt32 = 0xc9 + mpFixExt1 = 0xd4 + mpFixExt2 = 0xd5 + mpFixExt4 = 0xd6 + mpFixExt8 = 0xd7 + mpFixExt16 = 0xd8 + + mpStr8 = 0xd9 // new + mpStr16 = 0xda + mpStr32 = 0xdb + + mpArray16 = 0xdc + mpArray32 = 0xdd + + mpMap16 = 0xde + mpMap32 = 0xdf + + mpNegFixNumMin = 0xe0 + mpNegFixNumMax = 0xff +) + +// MsgpackSpecRpcMultiArgs is a special type which signifies to the MsgpackSpecRpcCodec +// that the backend RPC service takes multiple arguments, which have been arranged +// in sequence in the slice. +// +// The Codec then passes it AS-IS to the rpc service (without wrapping it in an +// array of 1 element). +type MsgpackSpecRpcMultiArgs []interface{} + +// A MsgpackContainer type specifies the different types of msgpackContainers. +type msgpackContainerType struct { + fixCutoff int + bFixMin, b8, b16, b32 byte + hasFixMin, has8, has8Always bool +} + +var ( + msgpackContainerStr = msgpackContainerType{32, mpFixStrMin, mpStr8, mpStr16, mpStr32, true, true, false} + msgpackContainerBin = msgpackContainerType{0, 0, mpBin8, mpBin16, mpBin32, false, true, true} + msgpackContainerList = msgpackContainerType{16, mpFixArrayMin, 0, mpArray16, mpArray32, true, false, false} + msgpackContainerMap = msgpackContainerType{16, mpFixMapMin, 0, mpMap16, mpMap32, true, false, false} +) + +//--------------------------------------------- + +type msgpackEncDriver struct { + noBuiltInTypes + encNoSeparator + e *Encoder + w encWriter + h *MsgpackHandle + x [8]byte +} + +func (e *msgpackEncDriver) EncodeNil() { + e.w.writen1(mpNil) +} + +func (e *msgpackEncDriver) EncodeInt(i int64) { + if i >= 0 { + e.EncodeUint(uint64(i)) + } else if i >= -32 { + e.w.writen1(byte(i)) + } else if i >= math.MinInt8 { + e.w.writen2(mpInt8, byte(i)) + } else if i >= math.MinInt16 { + e.w.writen1(mpInt16) + bigenHelper{e.x[:2], e.w}.writeUint16(uint16(i)) + } else if i >= math.MinInt32 { + e.w.writen1(mpInt32) + bigenHelper{e.x[:4], e.w}.writeUint32(uint32(i)) + } else { + e.w.writen1(mpInt64) + bigenHelper{e.x[:8], e.w}.writeUint64(uint64(i)) + } +} + +func (e *msgpackEncDriver) EncodeUint(i uint64) { + if i <= math.MaxInt8 { + e.w.writen1(byte(i)) + } else if i <= math.MaxUint8 { + e.w.writen2(mpUint8, byte(i)) + } else if i <= math.MaxUint16 { + e.w.writen1(mpUint16) + bigenHelper{e.x[:2], e.w}.writeUint16(uint16(i)) + } else if i <= math.MaxUint32 { + e.w.writen1(mpUint32) + bigenHelper{e.x[:4], e.w}.writeUint32(uint32(i)) + } else { + e.w.writen1(mpUint64) + bigenHelper{e.x[:8], e.w}.writeUint64(uint64(i)) + } +} + +func (e *msgpackEncDriver) EncodeBool(b bool) { + if b { + e.w.writen1(mpTrue) + } else { + e.w.writen1(mpFalse) + } +} + +func (e *msgpackEncDriver) EncodeFloat32(f float32) { + e.w.writen1(mpFloat) + bigenHelper{e.x[:4], e.w}.writeUint32(math.Float32bits(f)) +} + +func (e *msgpackEncDriver) EncodeFloat64(f float64) { + e.w.writen1(mpDouble) + bigenHelper{e.x[:8], e.w}.writeUint64(math.Float64bits(f)) +} + +func (e *msgpackEncDriver) EncodeExt(v interface{}, xtag uint64, ext Ext, _ *Encoder) { + bs := ext.WriteExt(v) + if bs == nil { + e.EncodeNil() + return + } + if e.h.WriteExt { + e.encodeExtPreamble(uint8(xtag), len(bs)) + e.w.writeb(bs) + } else { + e.EncodeStringBytes(c_RAW, bs) + } +} + +func (e *msgpackEncDriver) EncodeRawExt(re *RawExt, _ *Encoder) { + e.encodeExtPreamble(uint8(re.Tag), len(re.Data)) + e.w.writeb(re.Data) +} + +func (e *msgpackEncDriver) encodeExtPreamble(xtag byte, l int) { + if l == 1 { + e.w.writen2(mpFixExt1, xtag) + } else if l == 2 { + e.w.writen2(mpFixExt2, xtag) + } else if l == 4 { + e.w.writen2(mpFixExt4, xtag) + } else if l == 8 { + e.w.writen2(mpFixExt8, xtag) + } else if l == 16 { + e.w.writen2(mpFixExt16, xtag) + } else if l < 256 { + e.w.writen2(mpExt8, byte(l)) + e.w.writen1(xtag) + } else if l < 65536 { + e.w.writen1(mpExt16) + bigenHelper{e.x[:2], e.w}.writeUint16(uint16(l)) + e.w.writen1(xtag) + } else { + e.w.writen1(mpExt32) + bigenHelper{e.x[:4], e.w}.writeUint32(uint32(l)) + e.w.writen1(xtag) + } +} + +func (e *msgpackEncDriver) EncodeArrayStart(length int) { + e.writeContainerLen(msgpackContainerList, length) +} + +func (e *msgpackEncDriver) EncodeMapStart(length int) { + e.writeContainerLen(msgpackContainerMap, length) +} + +func (e *msgpackEncDriver) EncodeString(c charEncoding, s string) { + if c == c_RAW && e.h.WriteExt { + e.writeContainerLen(msgpackContainerBin, len(s)) + } else { + e.writeContainerLen(msgpackContainerStr, len(s)) + } + if len(s) > 0 { + e.w.writestr(s) + } +} + +func (e *msgpackEncDriver) EncodeSymbol(v string) { + e.EncodeString(c_UTF8, v) +} + +func (e *msgpackEncDriver) EncodeStringBytes(c charEncoding, bs []byte) { + if c == c_RAW && e.h.WriteExt { + e.writeContainerLen(msgpackContainerBin, len(bs)) + } else { + e.writeContainerLen(msgpackContainerStr, len(bs)) + } + if len(bs) > 0 { + e.w.writeb(bs) + } +} + +func (e *msgpackEncDriver) writeContainerLen(ct msgpackContainerType, l int) { + if ct.hasFixMin && l < ct.fixCutoff { + e.w.writen1(ct.bFixMin | byte(l)) + } else if ct.has8 && l < 256 && (ct.has8Always || e.h.WriteExt) { + e.w.writen2(ct.b8, uint8(l)) + } else if l < 65536 { + e.w.writen1(ct.b16) + bigenHelper{e.x[:2], e.w}.writeUint16(uint16(l)) + } else { + e.w.writen1(ct.b32) + bigenHelper{e.x[:4], e.w}.writeUint32(uint32(l)) + } +} + +//--------------------------------------------- + +type msgpackDecDriver struct { + d *Decoder + r decReader // *Decoder decReader decReaderT + h *MsgpackHandle + b [scratchByteArrayLen]byte + bd byte + bdRead bool + br bool // bytes reader + noBuiltInTypes + noStreamingCodec + decNoSeparator +} + +// Note: This returns either a primitive (int, bool, etc) for non-containers, +// or a containerType, or a specific type denoting nil or extension. +// It is called when a nil interface{} is passed, leaving it up to the DecDriver +// to introspect the stream and decide how best to decode. +// It deciphers the value by looking at the stream first. +func (d *msgpackDecDriver) DecodeNaked() { + if !d.bdRead { + d.readNextBd() + } + bd := d.bd + n := &d.d.n + var decodeFurther bool + + switch bd { + case mpNil: + n.v = valueTypeNil + d.bdRead = false + case mpFalse: + n.v = valueTypeBool + n.b = false + case mpTrue: + n.v = valueTypeBool + n.b = true + + case mpFloat: + n.v = valueTypeFloat + n.f = float64(math.Float32frombits(bigen.Uint32(d.r.readx(4)))) + case mpDouble: + n.v = valueTypeFloat + n.f = math.Float64frombits(bigen.Uint64(d.r.readx(8))) + + case mpUint8: + n.v = valueTypeUint + n.u = uint64(d.r.readn1()) + case mpUint16: + n.v = valueTypeUint + n.u = uint64(bigen.Uint16(d.r.readx(2))) + case mpUint32: + n.v = valueTypeUint + n.u = uint64(bigen.Uint32(d.r.readx(4))) + case mpUint64: + n.v = valueTypeUint + n.u = uint64(bigen.Uint64(d.r.readx(8))) + + case mpInt8: + n.v = valueTypeInt + n.i = int64(int8(d.r.readn1())) + case mpInt16: + n.v = valueTypeInt + n.i = int64(int16(bigen.Uint16(d.r.readx(2)))) + case mpInt32: + n.v = valueTypeInt + n.i = int64(int32(bigen.Uint32(d.r.readx(4)))) + case mpInt64: + n.v = valueTypeInt + n.i = int64(int64(bigen.Uint64(d.r.readx(8)))) + + default: + switch { + case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax: + // positive fixnum (always signed) + n.v = valueTypeInt + n.i = int64(int8(bd)) + case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax: + // negative fixnum + n.v = valueTypeInt + n.i = int64(int8(bd)) + case bd == mpStr8, bd == mpStr16, bd == mpStr32, bd >= mpFixStrMin && bd <= mpFixStrMax: + if d.h.RawToString { + n.v = valueTypeString + n.s = d.DecodeString() + } else { + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) + } + case bd == mpBin8, bd == mpBin16, bd == mpBin32: + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) + case bd == mpArray16, bd == mpArray32, bd >= mpFixArrayMin && bd <= mpFixArrayMax: + n.v = valueTypeArray + decodeFurther = true + case bd == mpMap16, bd == mpMap32, bd >= mpFixMapMin && bd <= mpFixMapMax: + n.v = valueTypeMap + decodeFurther = true + case bd >= mpFixExt1 && bd <= mpFixExt16, bd >= mpExt8 && bd <= mpExt32: + n.v = valueTypeExt + clen := d.readExtLen() + n.u = uint64(d.r.readn1()) + n.l = d.r.readx(clen) + default: + d.d.errorf("Nil-Deciphered DecodeValue: %s: hex: %x, dec: %d", msgBadDesc, bd, bd) + } + } + if !decodeFurther { + d.bdRead = false + } + if n.v == valueTypeUint && d.h.SignedInteger { + n.v = valueTypeInt + n.i = int64(n.u) + } + return +} + +// int can be decoded from msgpack type: intXXX or uintXXX +func (d *msgpackDecDriver) DecodeInt(bitsize uint8) (i int64) { + if !d.bdRead { + d.readNextBd() + } + switch d.bd { + case mpUint8: + i = int64(uint64(d.r.readn1())) + case mpUint16: + i = int64(uint64(bigen.Uint16(d.r.readx(2)))) + case mpUint32: + i = int64(uint64(bigen.Uint32(d.r.readx(4)))) + case mpUint64: + i = int64(bigen.Uint64(d.r.readx(8))) + case mpInt8: + i = int64(int8(d.r.readn1())) + case mpInt16: + i = int64(int16(bigen.Uint16(d.r.readx(2)))) + case mpInt32: + i = int64(int32(bigen.Uint32(d.r.readx(4)))) + case mpInt64: + i = int64(bigen.Uint64(d.r.readx(8))) + default: + switch { + case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax: + i = int64(int8(d.bd)) + case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax: + i = int64(int8(d.bd)) + default: + d.d.errorf("Unhandled single-byte unsigned integer value: %s: %x", msgBadDesc, d.bd) + return + } + } + // check overflow (logic adapted from std pkg reflect/value.go OverflowUint() + if bitsize > 0 { + if trunc := (i << (64 - bitsize)) >> (64 - bitsize); i != trunc { + d.d.errorf("Overflow int value: %v", i) + return + } + } + d.bdRead = false + return +} + +// uint can be decoded from msgpack type: intXXX or uintXXX +func (d *msgpackDecDriver) DecodeUint(bitsize uint8) (ui uint64) { + if !d.bdRead { + d.readNextBd() + } + switch d.bd { + case mpUint8: + ui = uint64(d.r.readn1()) + case mpUint16: + ui = uint64(bigen.Uint16(d.r.readx(2))) + case mpUint32: + ui = uint64(bigen.Uint32(d.r.readx(4))) + case mpUint64: + ui = bigen.Uint64(d.r.readx(8)) + case mpInt8: + if i := int64(int8(d.r.readn1())); i >= 0 { + ui = uint64(i) + } else { + d.d.errorf("Assigning negative signed value: %v, to unsigned type", i) + return + } + case mpInt16: + if i := int64(int16(bigen.Uint16(d.r.readx(2)))); i >= 0 { + ui = uint64(i) + } else { + d.d.errorf("Assigning negative signed value: %v, to unsigned type", i) + return + } + case mpInt32: + if i := int64(int32(bigen.Uint32(d.r.readx(4)))); i >= 0 { + ui = uint64(i) + } else { + d.d.errorf("Assigning negative signed value: %v, to unsigned type", i) + return + } + case mpInt64: + if i := int64(bigen.Uint64(d.r.readx(8))); i >= 0 { + ui = uint64(i) + } else { + d.d.errorf("Assigning negative signed value: %v, to unsigned type", i) + return + } + default: + switch { + case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax: + ui = uint64(d.bd) + case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax: + d.d.errorf("Assigning negative signed value: %v, to unsigned type", int(d.bd)) + return + default: + d.d.errorf("Unhandled single-byte unsigned integer value: %s: %x", msgBadDesc, d.bd) + return + } + } + // check overflow (logic adapted from std pkg reflect/value.go OverflowUint() + if bitsize > 0 { + if trunc := (ui << (64 - bitsize)) >> (64 - bitsize); ui != trunc { + d.d.errorf("Overflow uint value: %v", ui) + return + } + } + d.bdRead = false + return +} + +// float can either be decoded from msgpack type: float, double or intX +func (d *msgpackDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) { + if !d.bdRead { + d.readNextBd() + } + if d.bd == mpFloat { + f = float64(math.Float32frombits(bigen.Uint32(d.r.readx(4)))) + } else if d.bd == mpDouble { + f = math.Float64frombits(bigen.Uint64(d.r.readx(8))) + } else { + f = float64(d.DecodeInt(0)) + } + if chkOverflow32 && chkOvf.Float32(f) { + d.d.errorf("msgpack: float32 overflow: %v", f) + return + } + d.bdRead = false + return +} + +// bool can be decoded from bool, fixnum 0 or 1. +func (d *msgpackDecDriver) DecodeBool() (b bool) { + if !d.bdRead { + d.readNextBd() + } + if d.bd == mpFalse || d.bd == 0 { + // b = false + } else if d.bd == mpTrue || d.bd == 1 { + b = true + } else { + d.d.errorf("Invalid single-byte value for bool: %s: %x", msgBadDesc, d.bd) + return + } + d.bdRead = false + return +} + +func (d *msgpackDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) { + if !d.bdRead { + d.readNextBd() + } + var clen int + // ignore isstring. Expect that the bytes may be found from msgpackContainerStr or msgpackContainerBin + if bd := d.bd; bd == mpBin8 || bd == mpBin16 || bd == mpBin32 { + clen = d.readContainerLen(msgpackContainerBin) + } else { + clen = d.readContainerLen(msgpackContainerStr) + } + // println("DecodeBytes: clen: ", clen) + d.bdRead = false + // bytes may be nil, so handle it. if nil, clen=-1. + if clen < 0 { + return nil + } + if zerocopy { + if d.br { + return d.r.readx(clen) + } else if len(bs) == 0 { + bs = d.b[:] + } + } + return decByteSlice(d.r, clen, bs) +} + +func (d *msgpackDecDriver) DecodeString() (s string) { + return string(d.DecodeBytes(d.b[:], true, true)) +} + +func (d *msgpackDecDriver) readNextBd() { + d.bd = d.r.readn1() + d.bdRead = true +} + +func (d *msgpackDecDriver) ContainerType() (vt valueType) { + bd := d.bd + if bd == mpNil { + return valueTypeNil + } else if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 || + (!d.h.RawToString && + (bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || (bd >= mpFixStrMin && bd <= mpFixStrMax))) { + return valueTypeBytes + } else if d.h.RawToString && + (bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || (bd >= mpFixStrMin && bd <= mpFixStrMax)) { + return valueTypeString + } else if bd == mpArray16 || bd == mpArray32 || (bd >= mpFixArrayMin && bd <= mpFixArrayMax) { + return valueTypeArray + } else if bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) { + return valueTypeMap + } else { + // d.d.errorf("isContainerType: unsupported parameter: %v", vt) + } + return valueTypeUnset +} + +func (d *msgpackDecDriver) TryDecodeAsNil() (v bool) { + if !d.bdRead { + d.readNextBd() + } + if d.bd == mpNil { + d.bdRead = false + v = true + } + return +} + +func (d *msgpackDecDriver) readContainerLen(ct msgpackContainerType) (clen int) { + bd := d.bd + if bd == mpNil { + clen = -1 // to represent nil + } else if bd == ct.b8 { + clen = int(d.r.readn1()) + } else if bd == ct.b16 { + clen = int(bigen.Uint16(d.r.readx(2))) + } else if bd == ct.b32 { + clen = int(bigen.Uint32(d.r.readx(4))) + } else if (ct.bFixMin & bd) == ct.bFixMin { + clen = int(ct.bFixMin ^ bd) + } else { + d.d.errorf("readContainerLen: %s: hex: %x, decimal: %d", msgBadDesc, bd, bd) + return + } + d.bdRead = false + return +} + +func (d *msgpackDecDriver) ReadMapStart() int { + return d.readContainerLen(msgpackContainerMap) +} + +func (d *msgpackDecDriver) ReadArrayStart() int { + return d.readContainerLen(msgpackContainerList) +} + +func (d *msgpackDecDriver) readExtLen() (clen int) { + switch d.bd { + case mpNil: + clen = -1 // to represent nil + case mpFixExt1: + clen = 1 + case mpFixExt2: + clen = 2 + case mpFixExt4: + clen = 4 + case mpFixExt8: + clen = 8 + case mpFixExt16: + clen = 16 + case mpExt8: + clen = int(d.r.readn1()) + case mpExt16: + clen = int(bigen.Uint16(d.r.readx(2))) + case mpExt32: + clen = int(bigen.Uint32(d.r.readx(4))) + default: + d.d.errorf("decoding ext bytes: found unexpected byte: %x", d.bd) + return + } + return +} + +func (d *msgpackDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) { + if xtag > 0xff { + d.d.errorf("decodeExt: tag must be <= 0xff; got: %v", xtag) + return + } + realxtag1, xbs := d.decodeExtV(ext != nil, uint8(xtag)) + realxtag = uint64(realxtag1) + if ext == nil { + re := rv.(*RawExt) + re.Tag = realxtag + re.Data = detachZeroCopyBytes(d.br, re.Data, xbs) + } else { + ext.ReadExt(rv, xbs) + } + return +} + +func (d *msgpackDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs []byte) { + if !d.bdRead { + d.readNextBd() + } + xbd := d.bd + if xbd == mpBin8 || xbd == mpBin16 || xbd == mpBin32 { + xbs = d.DecodeBytes(nil, false, true) + } else if xbd == mpStr8 || xbd == mpStr16 || xbd == mpStr32 || + (xbd >= mpFixStrMin && xbd <= mpFixStrMax) { + xbs = d.DecodeBytes(nil, true, true) + } else { + clen := d.readExtLen() + xtag = d.r.readn1() + if verifyTag && xtag != tag { + d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", xtag, tag) + return + } + xbs = d.r.readx(clen) + } + d.bdRead = false + return +} + +//-------------------------------------------------- + +//MsgpackHandle is a Handle for the Msgpack Schema-Free Encoding Format. +type MsgpackHandle struct { + BasicHandle + + // RawToString controls how raw bytes are decoded into a nil interface{}. + RawToString bool + + // WriteExt flag supports encoding configured extensions with extension tags. + // It also controls whether other elements of the new spec are encoded (ie Str8). + // + // With WriteExt=false, configured extensions are serialized as raw bytes + // and Str8 is not encoded. + // + // A stream can still be decoded into a typed value, provided an appropriate value + // is provided, but the type cannot be inferred from the stream. If no appropriate + // type is provided (e.g. decoding into a nil interface{}), you get back + // a []byte or string based on the setting of RawToString. + WriteExt bool + binaryEncodingType +} + +func (h *MsgpackHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) { + return h.SetExt(rt, tag, &setExtWrapper{b: ext}) +} + +func (h *MsgpackHandle) newEncDriver(e *Encoder) encDriver { + return &msgpackEncDriver{e: e, w: e.w, h: h} +} + +func (h *MsgpackHandle) newDecDriver(d *Decoder) decDriver { + return &msgpackDecDriver{d: d, r: d.r, h: h, br: d.bytes} +} + +func (e *msgpackEncDriver) reset() { + e.w = e.e.w +} + +func (d *msgpackDecDriver) reset() { + d.r = d.d.r + d.bd, d.bdRead = 0, false +} + +//-------------------------------------------------- + +type msgpackSpecRpcCodec struct { + rpcCodec +} + +// /////////////// Spec RPC Codec /////////////////// +func (c *msgpackSpecRpcCodec) WriteRequest(r *rpc.Request, body interface{}) error { + // WriteRequest can write to both a Go service, and other services that do + // not abide by the 1 argument rule of a Go service. + // We discriminate based on if the body is a MsgpackSpecRpcMultiArgs + var bodyArr []interface{} + if m, ok := body.(MsgpackSpecRpcMultiArgs); ok { + bodyArr = ([]interface{})(m) + } else { + bodyArr = []interface{}{body} + } + r2 := []interface{}{0, uint32(r.Seq), r.ServiceMethod, bodyArr} + return c.write(r2, nil, false, true) +} + +func (c *msgpackSpecRpcCodec) WriteResponse(r *rpc.Response, body interface{}) error { + var moe interface{} + if r.Error != "" { + moe = r.Error + } + if moe != nil && body != nil { + body = nil + } + r2 := []interface{}{1, uint32(r.Seq), moe, body} + return c.write(r2, nil, false, true) +} + +func (c *msgpackSpecRpcCodec) ReadResponseHeader(r *rpc.Response) error { + return c.parseCustomHeader(1, &r.Seq, &r.Error) +} + +func (c *msgpackSpecRpcCodec) ReadRequestHeader(r *rpc.Request) error { + return c.parseCustomHeader(0, &r.Seq, &r.ServiceMethod) +} + +func (c *msgpackSpecRpcCodec) ReadRequestBody(body interface{}) error { + if body == nil { // read and discard + return c.read(nil) + } + bodyArr := []interface{}{body} + return c.read(&bodyArr) +} + +func (c *msgpackSpecRpcCodec) parseCustomHeader(expectTypeByte byte, msgid *uint64, methodOrError *string) (err error) { + + if c.isClosed() { + return io.EOF + } + + // We read the response header by hand + // so that the body can be decoded on its own from the stream at a later time. + + const fia byte = 0x94 //four item array descriptor value + // Not sure why the panic of EOF is swallowed above. + // if bs1 := c.dec.r.readn1(); bs1 != fia { + // err = fmt.Errorf("Unexpected value for array descriptor: Expecting %v. Received %v", fia, bs1) + // return + // } + var b byte + b, err = c.br.ReadByte() + if err != nil { + return + } + if b != fia { + err = fmt.Errorf("Unexpected value for array descriptor: Expecting %v. Received %v", fia, b) + return + } + + if err = c.read(&b); err != nil { + return + } + if b != expectTypeByte { + err = fmt.Errorf("Unexpected byte descriptor in header. Expecting %v. Received %v", expectTypeByte, b) + return + } + if err = c.read(msgid); err != nil { + return + } + if err = c.read(methodOrError); err != nil { + return + } + return +} + +//-------------------------------------------------- + +// msgpackSpecRpc is the implementation of Rpc that uses custom communication protocol +// as defined in the msgpack spec at https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md +type msgpackSpecRpc struct{} + +// MsgpackSpecRpc implements Rpc using the communication protocol defined in +// the msgpack spec at https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md . +// Its methods (ServerCodec and ClientCodec) return values that implement RpcCodecBuffered. +var MsgpackSpecRpc msgpackSpecRpc + +func (x msgpackSpecRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec { + return &msgpackSpecRpcCodec{newRPCCodec(conn, h)} +} + +func (x msgpackSpecRpc) ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec { + return &msgpackSpecRpcCodec{newRPCCodec(conn, h)} +} + +var _ decDriver = (*msgpackDecDriver)(nil) +var _ encDriver = (*msgpackEncDriver)(nil) diff --git a/vendor/github.com/ugorji/go/codec/noop.go b/vendor/github.com/ugorji/go/codec/noop.go new file mode 100644 index 00000000..cfee3d08 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/noop.go @@ -0,0 +1,213 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "math/rand" + "time" +) + +// NoopHandle returns a no-op handle. It basically does nothing. +// It is only useful for benchmarking, as it gives an idea of the +// overhead from the codec framework. +// +// LIBRARY USERS: *** DO NOT USE *** +func NoopHandle(slen int) *noopHandle { + h := noopHandle{} + h.rand = rand.New(rand.NewSource(time.Now().UnixNano())) + h.B = make([][]byte, slen) + h.S = make([]string, slen) + for i := 0; i < len(h.S); i++ { + b := make([]byte, i+1) + for j := 0; j < len(b); j++ { + b[j] = 'a' + byte(i) + } + h.B[i] = b + h.S[i] = string(b) + } + return &h +} + +// noopHandle does nothing. +// It is used to simulate the overhead of the codec framework. +type noopHandle struct { + BasicHandle + binaryEncodingType + noopDrv // noopDrv is unexported here, so we can get a copy of it when needed. +} + +type noopDrv struct { + d *Decoder + e *Encoder + i int + S []string + B [][]byte + mks []bool // stack. if map (true), else if array (false) + mk bool // top of stack. what container are we on? map or array? + ct valueType // last response for IsContainerType. + cb int // counter for ContainerType + rand *rand.Rand +} + +func (h *noopDrv) r(v int) int { return h.rand.Intn(v) } +func (h *noopDrv) m(v int) int { h.i++; return h.i % v } + +func (h *noopDrv) newEncDriver(e *Encoder) encDriver { h.e = e; return h } +func (h *noopDrv) newDecDriver(d *Decoder) decDriver { h.d = d; return h } + +func (h *noopDrv) reset() {} +func (h *noopDrv) uncacheRead() {} + +// --- encDriver + +// stack functions (for map and array) +func (h *noopDrv) start(b bool) { + // println("start", len(h.mks)+1) + h.mks = append(h.mks, b) + h.mk = b +} +func (h *noopDrv) end() { + // println("end: ", len(h.mks)-1) + h.mks = h.mks[:len(h.mks)-1] + if len(h.mks) > 0 { + h.mk = h.mks[len(h.mks)-1] + } else { + h.mk = false + } +} + +func (h *noopDrv) EncodeBuiltin(rt uintptr, v interface{}) {} +func (h *noopDrv) EncodeNil() {} +func (h *noopDrv) EncodeInt(i int64) {} +func (h *noopDrv) EncodeUint(i uint64) {} +func (h *noopDrv) EncodeBool(b bool) {} +func (h *noopDrv) EncodeFloat32(f float32) {} +func (h *noopDrv) EncodeFloat64(f float64) {} +func (h *noopDrv) EncodeRawExt(re *RawExt, e *Encoder) {} +func (h *noopDrv) EncodeArrayStart(length int) { h.start(true) } +func (h *noopDrv) EncodeMapStart(length int) { h.start(false) } +func (h *noopDrv) EncodeEnd() { h.end() } + +func (h *noopDrv) EncodeString(c charEncoding, v string) {} +func (h *noopDrv) EncodeSymbol(v string) {} +func (h *noopDrv) EncodeStringBytes(c charEncoding, v []byte) {} + +func (h *noopDrv) EncodeExt(rv interface{}, xtag uint64, ext Ext, e *Encoder) {} + +// ---- decDriver +func (h *noopDrv) initReadNext() {} +func (h *noopDrv) CheckBreak() bool { return false } +func (h *noopDrv) IsBuiltinType(rt uintptr) bool { return false } +func (h *noopDrv) DecodeBuiltin(rt uintptr, v interface{}) {} +func (h *noopDrv) DecodeInt(bitsize uint8) (i int64) { return int64(h.m(15)) } +func (h *noopDrv) DecodeUint(bitsize uint8) (ui uint64) { return uint64(h.m(35)) } +func (h *noopDrv) DecodeFloat(chkOverflow32 bool) (f float64) { return float64(h.m(95)) } +func (h *noopDrv) DecodeBool() (b bool) { return h.m(2) == 0 } +func (h *noopDrv) DecodeString() (s string) { return h.S[h.m(8)] } + +// func (h *noopDrv) DecodeStringAsBytes(bs []byte) []byte { return h.DecodeBytes(bs) } + +func (h *noopDrv) DecodeBytes(bs []byte, isstring, zerocopy bool) []byte { return h.B[h.m(len(h.B))] } + +func (h *noopDrv) ReadEnd() { h.end() } + +// toggle map/slice +func (h *noopDrv) ReadMapStart() int { h.start(true); return h.m(10) } +func (h *noopDrv) ReadArrayStart() int { h.start(false); return h.m(10) } + +func (h *noopDrv) ContainerType() (vt valueType) { + // return h.m(2) == 0 + // handle kStruct, which will bomb is it calls this and doesn't get back a map or array. + // consequently, if the return value is not map or array, reset it to one of them based on h.m(7) % 2 + // for kstruct: at least one out of every 2 times, return one of valueTypeMap or Array (else kstruct bombs) + // however, every 10th time it is called, we just return something else. + var vals = [...]valueType{valueTypeArray, valueTypeMap} + // ------------ TAKE ------------ + // if h.cb%2 == 0 { + // if h.ct == valueTypeMap || h.ct == valueTypeArray { + // } else { + // h.ct = vals[h.m(2)] + // } + // } else if h.cb%5 == 0 { + // h.ct = valueType(h.m(8)) + // } else { + // h.ct = vals[h.m(2)] + // } + // ------------ TAKE ------------ + // if h.cb%16 == 0 { + // h.ct = valueType(h.cb % 8) + // } else { + // h.ct = vals[h.cb%2] + // } + h.ct = vals[h.cb%2] + h.cb++ + return h.ct + + // if h.ct == valueTypeNil || h.ct == valueTypeString || h.ct == valueTypeBytes { + // return h.ct + // } + // return valueTypeUnset + // TODO: may need to tweak this so it works. + // if h.ct == valueTypeMap && vt == valueTypeArray || h.ct == valueTypeArray && vt == valueTypeMap { + // h.cb = !h.cb + // h.ct = vt + // return h.cb + // } + // // go in a loop and check it. + // h.ct = vt + // h.cb = h.m(7) == 0 + // return h.cb +} +func (h *noopDrv) TryDecodeAsNil() bool { + if h.mk { + return false + } else { + return h.m(8) == 0 + } +} +func (h *noopDrv) DecodeExt(rv interface{}, xtag uint64, ext Ext) uint64 { + return 0 +} + +func (h *noopDrv) DecodeNaked() { + // use h.r (random) not h.m() because h.m() could cause the same value to be given. + var sk int + if h.mk { + // if mapkey, do not support values of nil OR bytes, array, map or rawext + sk = h.r(7) + 1 + } else { + sk = h.r(12) + } + n := &h.d.n + switch sk { + case 0: + n.v = valueTypeNil + case 1: + n.v, n.b = valueTypeBool, false + case 2: + n.v, n.b = valueTypeBool, true + case 3: + n.v, n.i = valueTypeInt, h.DecodeInt(64) + case 4: + n.v, n.u = valueTypeUint, h.DecodeUint(64) + case 5: + n.v, n.f = valueTypeFloat, h.DecodeFloat(true) + case 6: + n.v, n.f = valueTypeFloat, h.DecodeFloat(false) + case 7: + n.v, n.s = valueTypeString, h.DecodeString() + case 8: + n.v, n.l = valueTypeBytes, h.B[h.m(len(h.B))] + case 9: + n.v = valueTypeArray + case 10: + n.v = valueTypeMap + default: + n.v = valueTypeExt + n.u = h.DecodeUint(64) + n.l = h.B[h.m(len(h.B))] + } + h.ct = n.v + return +} diff --git a/vendor/github.com/ugorji/go/codec/prebuild.go b/vendor/github.com/ugorji/go/codec/prebuild.go new file mode 100644 index 00000000..2353263e --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/prebuild.go @@ -0,0 +1,3 @@ +package codec + +//go:generate bash prebuild.sh diff --git a/vendor/github.com/ugorji/go/codec/rpc.go b/vendor/github.com/ugorji/go/codec/rpc.go new file mode 100644 index 00000000..8062bed3 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/rpc.go @@ -0,0 +1,180 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "bufio" + "io" + "net/rpc" + "sync" +) + +// rpcEncodeTerminator allows a handler specify a []byte terminator to send after each Encode. +// +// Some codecs like json need to put a space after each encoded value, to serve as a +// delimiter for things like numbers (else json codec will continue reading till EOF). +type rpcEncodeTerminator interface { + rpcEncodeTerminate() []byte +} + +// Rpc provides a rpc Server or Client Codec for rpc communication. +type Rpc interface { + ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec + ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec +} + +// RpcCodecBuffered allows access to the underlying bufio.Reader/Writer +// used by the rpc connection. It accommodates use-cases where the connection +// should be used by rpc and non-rpc functions, e.g. streaming a file after +// sending an rpc response. +type RpcCodecBuffered interface { + BufferedReader() *bufio.Reader + BufferedWriter() *bufio.Writer +} + +// ------------------------------------- + +// rpcCodec defines the struct members and common methods. +type rpcCodec struct { + rwc io.ReadWriteCloser + dec *Decoder + enc *Encoder + bw *bufio.Writer + br *bufio.Reader + mu sync.Mutex + h Handle + + cls bool + clsmu sync.RWMutex +} + +func newRPCCodec(conn io.ReadWriteCloser, h Handle) rpcCodec { + bw := bufio.NewWriter(conn) + br := bufio.NewReader(conn) + return rpcCodec{ + rwc: conn, + bw: bw, + br: br, + enc: NewEncoder(bw, h), + dec: NewDecoder(br, h), + h: h, + } +} + +func (c *rpcCodec) BufferedReader() *bufio.Reader { + return c.br +} + +func (c *rpcCodec) BufferedWriter() *bufio.Writer { + return c.bw +} + +func (c *rpcCodec) write(obj1, obj2 interface{}, writeObj2, doFlush bool) (err error) { + if c.isClosed() { + return io.EOF + } + if err = c.enc.Encode(obj1); err != nil { + return + } + t, tOk := c.h.(rpcEncodeTerminator) + if tOk { + c.bw.Write(t.rpcEncodeTerminate()) + } + if writeObj2 { + if err = c.enc.Encode(obj2); err != nil { + return + } + if tOk { + c.bw.Write(t.rpcEncodeTerminate()) + } + } + if doFlush { + return c.bw.Flush() + } + return +} + +func (c *rpcCodec) read(obj interface{}) (err error) { + if c.isClosed() { + return io.EOF + } + //If nil is passed in, we should still attempt to read content to nowhere. + if obj == nil { + var obj2 interface{} + return c.dec.Decode(&obj2) + } + return c.dec.Decode(obj) +} + +func (c *rpcCodec) isClosed() bool { + c.clsmu.RLock() + x := c.cls + c.clsmu.RUnlock() + return x +} + +func (c *rpcCodec) Close() error { + if c.isClosed() { + return io.EOF + } + c.clsmu.Lock() + c.cls = true + c.clsmu.Unlock() + return c.rwc.Close() +} + +func (c *rpcCodec) ReadResponseBody(body interface{}) error { + return c.read(body) +} + +// ------------------------------------- + +type goRpcCodec struct { + rpcCodec +} + +func (c *goRpcCodec) WriteRequest(r *rpc.Request, body interface{}) error { + // Must protect for concurrent access as per API + c.mu.Lock() + defer c.mu.Unlock() + return c.write(r, body, true, true) +} + +func (c *goRpcCodec) WriteResponse(r *rpc.Response, body interface{}) error { + c.mu.Lock() + defer c.mu.Unlock() + return c.write(r, body, true, true) +} + +func (c *goRpcCodec) ReadResponseHeader(r *rpc.Response) error { + return c.read(r) +} + +func (c *goRpcCodec) ReadRequestHeader(r *rpc.Request) error { + return c.read(r) +} + +func (c *goRpcCodec) ReadRequestBody(body interface{}) error { + return c.read(body) +} + +// ------------------------------------- + +// goRpc is the implementation of Rpc that uses the communication protocol +// as defined in net/rpc package. +type goRpc struct{} + +// GoRpc implements Rpc using the communication protocol defined in net/rpc package. +// Its methods (ServerCodec and ClientCodec) return values that implement RpcCodecBuffered. +var GoRpc goRpc + +func (x goRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec { + return &goRpcCodec{newRPCCodec(conn, h)} +} + +func (x goRpc) ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec { + return &goRpcCodec{newRPCCodec(conn, h)} +} + +var _ RpcCodecBuffered = (*rpcCodec)(nil) // ensure *rpcCodec implements RpcCodecBuffered diff --git a/vendor/github.com/ugorji/go/codec/simple.go b/vendor/github.com/ugorji/go/codec/simple.go new file mode 100644 index 00000000..9619b2bf --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/simple.go @@ -0,0 +1,519 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "math" + "reflect" +) + +const ( + _ uint8 = iota + simpleVdNil = 1 + simpleVdFalse = 2 + simpleVdTrue = 3 + simpleVdFloat32 = 4 + simpleVdFloat64 = 5 + + // each lasts for 4 (ie n, n+1, n+2, n+3) + simpleVdPosInt = 8 + simpleVdNegInt = 12 + + // containers: each lasts for 4 (ie n, n+1, n+2, ... n+7) + simpleVdString = 216 + simpleVdByteArray = 224 + simpleVdArray = 232 + simpleVdMap = 240 + simpleVdExt = 248 +) + +type simpleEncDriver struct { + noBuiltInTypes + encNoSeparator + e *Encoder + h *SimpleHandle + w encWriter + b [8]byte +} + +func (e *simpleEncDriver) EncodeNil() { + e.w.writen1(simpleVdNil) +} + +func (e *simpleEncDriver) EncodeBool(b bool) { + if b { + e.w.writen1(simpleVdTrue) + } else { + e.w.writen1(simpleVdFalse) + } +} + +func (e *simpleEncDriver) EncodeFloat32(f float32) { + e.w.writen1(simpleVdFloat32) + bigenHelper{e.b[:4], e.w}.writeUint32(math.Float32bits(f)) +} + +func (e *simpleEncDriver) EncodeFloat64(f float64) { + e.w.writen1(simpleVdFloat64) + bigenHelper{e.b[:8], e.w}.writeUint64(math.Float64bits(f)) +} + +func (e *simpleEncDriver) EncodeInt(v int64) { + if v < 0 { + e.encUint(uint64(-v), simpleVdNegInt) + } else { + e.encUint(uint64(v), simpleVdPosInt) + } +} + +func (e *simpleEncDriver) EncodeUint(v uint64) { + e.encUint(v, simpleVdPosInt) +} + +func (e *simpleEncDriver) encUint(v uint64, bd uint8) { + if v <= math.MaxUint8 { + e.w.writen2(bd, uint8(v)) + } else if v <= math.MaxUint16 { + e.w.writen1(bd + 1) + bigenHelper{e.b[:2], e.w}.writeUint16(uint16(v)) + } else if v <= math.MaxUint32 { + e.w.writen1(bd + 2) + bigenHelper{e.b[:4], e.w}.writeUint32(uint32(v)) + } else { // if v <= math.MaxUint64 { + e.w.writen1(bd + 3) + bigenHelper{e.b[:8], e.w}.writeUint64(v) + } +} + +func (e *simpleEncDriver) encLen(bd byte, length int) { + if length == 0 { + e.w.writen1(bd) + } else if length <= math.MaxUint8 { + e.w.writen1(bd + 1) + e.w.writen1(uint8(length)) + } else if length <= math.MaxUint16 { + e.w.writen1(bd + 2) + bigenHelper{e.b[:2], e.w}.writeUint16(uint16(length)) + } else if int64(length) <= math.MaxUint32 { + e.w.writen1(bd + 3) + bigenHelper{e.b[:4], e.w}.writeUint32(uint32(length)) + } else { + e.w.writen1(bd + 4) + bigenHelper{e.b[:8], e.w}.writeUint64(uint64(length)) + } +} + +func (e *simpleEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, _ *Encoder) { + bs := ext.WriteExt(rv) + if bs == nil { + e.EncodeNil() + return + } + e.encodeExtPreamble(uint8(xtag), len(bs)) + e.w.writeb(bs) +} + +func (e *simpleEncDriver) EncodeRawExt(re *RawExt, _ *Encoder) { + e.encodeExtPreamble(uint8(re.Tag), len(re.Data)) + e.w.writeb(re.Data) +} + +func (e *simpleEncDriver) encodeExtPreamble(xtag byte, length int) { + e.encLen(simpleVdExt, length) + e.w.writen1(xtag) +} + +func (e *simpleEncDriver) EncodeArrayStart(length int) { + e.encLen(simpleVdArray, length) +} + +func (e *simpleEncDriver) EncodeMapStart(length int) { + e.encLen(simpleVdMap, length) +} + +func (e *simpleEncDriver) EncodeString(c charEncoding, v string) { + e.encLen(simpleVdString, len(v)) + e.w.writestr(v) +} + +func (e *simpleEncDriver) EncodeSymbol(v string) { + e.EncodeString(c_UTF8, v) +} + +func (e *simpleEncDriver) EncodeStringBytes(c charEncoding, v []byte) { + e.encLen(simpleVdByteArray, len(v)) + e.w.writeb(v) +} + +//------------------------------------ + +type simpleDecDriver struct { + d *Decoder + h *SimpleHandle + r decReader + bdRead bool + bd byte + br bool // bytes reader + noBuiltInTypes + noStreamingCodec + decNoSeparator + b [scratchByteArrayLen]byte +} + +func (d *simpleDecDriver) readNextBd() { + d.bd = d.r.readn1() + d.bdRead = true +} + +func (d *simpleDecDriver) ContainerType() (vt valueType) { + if d.bd == simpleVdNil { + return valueTypeNil + } else if d.bd == simpleVdByteArray || d.bd == simpleVdByteArray+1 || + d.bd == simpleVdByteArray+2 || d.bd == simpleVdByteArray+3 || d.bd == simpleVdByteArray+4 { + return valueTypeBytes + } else if d.bd == simpleVdString || d.bd == simpleVdString+1 || + d.bd == simpleVdString+2 || d.bd == simpleVdString+3 || d.bd == simpleVdString+4 { + return valueTypeString + } else if d.bd == simpleVdArray || d.bd == simpleVdArray+1 || + d.bd == simpleVdArray+2 || d.bd == simpleVdArray+3 || d.bd == simpleVdArray+4 { + return valueTypeArray + } else if d.bd == simpleVdMap || d.bd == simpleVdMap+1 || + d.bd == simpleVdMap+2 || d.bd == simpleVdMap+3 || d.bd == simpleVdMap+4 { + return valueTypeMap + } else { + // d.d.errorf("isContainerType: unsupported parameter: %v", vt) + } + return valueTypeUnset +} + +func (d *simpleDecDriver) TryDecodeAsNil() bool { + if !d.bdRead { + d.readNextBd() + } + if d.bd == simpleVdNil { + d.bdRead = false + return true + } + return false +} + +func (d *simpleDecDriver) decCheckInteger() (ui uint64, neg bool) { + if !d.bdRead { + d.readNextBd() + } + switch d.bd { + case simpleVdPosInt: + ui = uint64(d.r.readn1()) + case simpleVdPosInt + 1: + ui = uint64(bigen.Uint16(d.r.readx(2))) + case simpleVdPosInt + 2: + ui = uint64(bigen.Uint32(d.r.readx(4))) + case simpleVdPosInt + 3: + ui = uint64(bigen.Uint64(d.r.readx(8))) + case simpleVdNegInt: + ui = uint64(d.r.readn1()) + neg = true + case simpleVdNegInt + 1: + ui = uint64(bigen.Uint16(d.r.readx(2))) + neg = true + case simpleVdNegInt + 2: + ui = uint64(bigen.Uint32(d.r.readx(4))) + neg = true + case simpleVdNegInt + 3: + ui = uint64(bigen.Uint64(d.r.readx(8))) + neg = true + default: + d.d.errorf("decIntAny: Integer only valid from pos/neg integer1..8. Invalid descriptor: %v", d.bd) + return + } + // don't do this check, because callers may only want the unsigned value. + // if ui > math.MaxInt64 { + // d.d.errorf("decIntAny: Integer out of range for signed int64: %v", ui) + // return + // } + return +} + +func (d *simpleDecDriver) DecodeInt(bitsize uint8) (i int64) { + ui, neg := d.decCheckInteger() + i, overflow := chkOvf.SignedInt(ui) + if overflow { + d.d.errorf("simple: overflow converting %v to signed integer", ui) + return + } + if neg { + i = -i + } + if chkOvf.Int(i, bitsize) { + d.d.errorf("simple: overflow integer: %v", i) + return + } + d.bdRead = false + return +} + +func (d *simpleDecDriver) DecodeUint(bitsize uint8) (ui uint64) { + ui, neg := d.decCheckInteger() + if neg { + d.d.errorf("Assigning negative signed value to unsigned type") + return + } + if chkOvf.Uint(ui, bitsize) { + d.d.errorf("simple: overflow integer: %v", ui) + return + } + d.bdRead = false + return +} + +func (d *simpleDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) { + if !d.bdRead { + d.readNextBd() + } + if d.bd == simpleVdFloat32 { + f = float64(math.Float32frombits(bigen.Uint32(d.r.readx(4)))) + } else if d.bd == simpleVdFloat64 { + f = math.Float64frombits(bigen.Uint64(d.r.readx(8))) + } else { + if d.bd >= simpleVdPosInt && d.bd <= simpleVdNegInt+3 { + f = float64(d.DecodeInt(64)) + } else { + d.d.errorf("Float only valid from float32/64: Invalid descriptor: %v", d.bd) + return + } + } + if chkOverflow32 && chkOvf.Float32(f) { + d.d.errorf("msgpack: float32 overflow: %v", f) + return + } + d.bdRead = false + return +} + +// bool can be decoded from bool only (single byte). +func (d *simpleDecDriver) DecodeBool() (b bool) { + if !d.bdRead { + d.readNextBd() + } + if d.bd == simpleVdTrue { + b = true + } else if d.bd == simpleVdFalse { + } else { + d.d.errorf("Invalid single-byte value for bool: %s: %x", msgBadDesc, d.bd) + return + } + d.bdRead = false + return +} + +func (d *simpleDecDriver) ReadMapStart() (length int) { + d.bdRead = false + return d.decLen() +} + +func (d *simpleDecDriver) ReadArrayStart() (length int) { + d.bdRead = false + return d.decLen() +} + +func (d *simpleDecDriver) decLen() int { + switch d.bd % 8 { + case 0: + return 0 + case 1: + return int(d.r.readn1()) + case 2: + return int(bigen.Uint16(d.r.readx(2))) + case 3: + ui := uint64(bigen.Uint32(d.r.readx(4))) + if chkOvf.Uint(ui, intBitsize) { + d.d.errorf("simple: overflow integer: %v", ui) + return 0 + } + return int(ui) + case 4: + ui := bigen.Uint64(d.r.readx(8)) + if chkOvf.Uint(ui, intBitsize) { + d.d.errorf("simple: overflow integer: %v", ui) + return 0 + } + return int(ui) + } + d.d.errorf("decLen: Cannot read length: bd%8 must be in range 0..4. Got: %d", d.bd%8) + return -1 +} + +func (d *simpleDecDriver) DecodeString() (s string) { + return string(d.DecodeBytes(d.b[:], true, true)) +} + +func (d *simpleDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) { + if !d.bdRead { + d.readNextBd() + } + if d.bd == simpleVdNil { + d.bdRead = false + return + } + clen := d.decLen() + d.bdRead = false + if zerocopy { + if d.br { + return d.r.readx(clen) + } else if len(bs) == 0 { + bs = d.b[:] + } + } + return decByteSlice(d.r, clen, bs) +} + +func (d *simpleDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) { + if xtag > 0xff { + d.d.errorf("decodeExt: tag must be <= 0xff; got: %v", xtag) + return + } + realxtag1, xbs := d.decodeExtV(ext != nil, uint8(xtag)) + realxtag = uint64(realxtag1) + if ext == nil { + re := rv.(*RawExt) + re.Tag = realxtag + re.Data = detachZeroCopyBytes(d.br, re.Data, xbs) + } else { + ext.ReadExt(rv, xbs) + } + return +} + +func (d *simpleDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs []byte) { + if !d.bdRead { + d.readNextBd() + } + switch d.bd { + case simpleVdExt, simpleVdExt + 1, simpleVdExt + 2, simpleVdExt + 3, simpleVdExt + 4: + l := d.decLen() + xtag = d.r.readn1() + if verifyTag && xtag != tag { + d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", xtag, tag) + return + } + xbs = d.r.readx(l) + case simpleVdByteArray, simpleVdByteArray + 1, simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4: + xbs = d.DecodeBytes(nil, false, true) + default: + d.d.errorf("Invalid d.bd for extensions (Expecting extensions or byte array). Got: 0x%x", d.bd) + return + } + d.bdRead = false + return +} + +func (d *simpleDecDriver) DecodeNaked() { + if !d.bdRead { + d.readNextBd() + } + + n := &d.d.n + var decodeFurther bool + + switch d.bd { + case simpleVdNil: + n.v = valueTypeNil + case simpleVdFalse: + n.v = valueTypeBool + n.b = false + case simpleVdTrue: + n.v = valueTypeBool + n.b = true + case simpleVdPosInt, simpleVdPosInt + 1, simpleVdPosInt + 2, simpleVdPosInt + 3: + if d.h.SignedInteger { + n.v = valueTypeInt + n.i = d.DecodeInt(64) + } else { + n.v = valueTypeUint + n.u = d.DecodeUint(64) + } + case simpleVdNegInt, simpleVdNegInt + 1, simpleVdNegInt + 2, simpleVdNegInt + 3: + n.v = valueTypeInt + n.i = d.DecodeInt(64) + case simpleVdFloat32: + n.v = valueTypeFloat + n.f = d.DecodeFloat(true) + case simpleVdFloat64: + n.v = valueTypeFloat + n.f = d.DecodeFloat(false) + case simpleVdString, simpleVdString + 1, simpleVdString + 2, simpleVdString + 3, simpleVdString + 4: + n.v = valueTypeString + n.s = d.DecodeString() + case simpleVdByteArray, simpleVdByteArray + 1, simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4: + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) + case simpleVdExt, simpleVdExt + 1, simpleVdExt + 2, simpleVdExt + 3, simpleVdExt + 4: + n.v = valueTypeExt + l := d.decLen() + n.u = uint64(d.r.readn1()) + n.l = d.r.readx(l) + case simpleVdArray, simpleVdArray + 1, simpleVdArray + 2, simpleVdArray + 3, simpleVdArray + 4: + n.v = valueTypeArray + decodeFurther = true + case simpleVdMap, simpleVdMap + 1, simpleVdMap + 2, simpleVdMap + 3, simpleVdMap + 4: + n.v = valueTypeMap + decodeFurther = true + default: + d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd) + } + + if !decodeFurther { + d.bdRead = false + } + return +} + +//------------------------------------ + +// SimpleHandle is a Handle for a very simple encoding format. +// +// simple is a simplistic codec similar to binc, but not as compact. +// - Encoding of a value is always preceded by the descriptor byte (bd) +// - True, false, nil are encoded fully in 1 byte (the descriptor) +// - Integers (intXXX, uintXXX) are encoded in 1, 2, 4 or 8 bytes (plus a descriptor byte). +// There are positive (uintXXX and intXXX >= 0) and negative (intXXX < 0) integers. +// - Floats are encoded in 4 or 8 bytes (plus a descriptor byte) +// - Lenght of containers (strings, bytes, array, map, extensions) +// are encoded in 0, 1, 2, 4 or 8 bytes. +// Zero-length containers have no length encoded. +// For others, the number of bytes is given by pow(2, bd%3) +// - maps are encoded as [bd] [length] [[key][value]]... +// - arrays are encoded as [bd] [length] [value]... +// - extensions are encoded as [bd] [length] [tag] [byte]... +// - strings/bytearrays are encoded as [bd] [length] [byte]... +// +// The full spec will be published soon. +type SimpleHandle struct { + BasicHandle + binaryEncodingType +} + +func (h *SimpleHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) { + return h.SetExt(rt, tag, &setExtWrapper{b: ext}) +} + +func (h *SimpleHandle) newEncDriver(e *Encoder) encDriver { + return &simpleEncDriver{e: e, w: e.w, h: h} +} + +func (h *SimpleHandle) newDecDriver(d *Decoder) decDriver { + return &simpleDecDriver{d: d, r: d.r, h: h, br: d.bytes} +} + +func (e *simpleEncDriver) reset() { + e.w = e.e.w +} + +func (d *simpleDecDriver) reset() { + d.r = d.d.r + d.bd, d.bdRead = 0, false +} + +var _ decDriver = (*simpleDecDriver)(nil) +var _ encDriver = (*simpleEncDriver)(nil) diff --git a/vendor/github.com/ugorji/go/codec/time.go b/vendor/github.com/ugorji/go/codec/time.go new file mode 100644 index 00000000..718b731e --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/time.go @@ -0,0 +1,233 @@ +// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "fmt" + "reflect" + "time" +) + +var ( + timeDigits = [...]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'} + timeExtEncFn = func(rv reflect.Value) (bs []byte, err error) { + defer panicToErr(&err) + bs = timeExt{}.WriteExt(rv.Interface()) + return + } + timeExtDecFn = func(rv reflect.Value, bs []byte) (err error) { + defer panicToErr(&err) + timeExt{}.ReadExt(rv.Interface(), bs) + return + } +) + +type timeExt struct{} + +func (x timeExt) WriteExt(v interface{}) (bs []byte) { + switch v2 := v.(type) { + case time.Time: + bs = encodeTime(v2) + case *time.Time: + bs = encodeTime(*v2) + default: + panic(fmt.Errorf("unsupported format for time conversion: expecting time.Time; got %T", v2)) + } + return +} +func (x timeExt) ReadExt(v interface{}, bs []byte) { + tt, err := decodeTime(bs) + if err != nil { + panic(err) + } + *(v.(*time.Time)) = tt +} + +func (x timeExt) ConvertExt(v interface{}) interface{} { + return x.WriteExt(v) +} +func (x timeExt) UpdateExt(v interface{}, src interface{}) { + x.ReadExt(v, src.([]byte)) +} + +// EncodeTime encodes a time.Time as a []byte, including +// information on the instant in time and UTC offset. +// +// Format Description +// +// A timestamp is composed of 3 components: +// +// - secs: signed integer representing seconds since unix epoch +// - nsces: unsigned integer representing fractional seconds as a +// nanosecond offset within secs, in the range 0 <= nsecs < 1e9 +// - tz: signed integer representing timezone offset in minutes east of UTC, +// and a dst (daylight savings time) flag +// +// When encoding a timestamp, the first byte is the descriptor, which +// defines which components are encoded and how many bytes are used to +// encode secs and nsecs components. *If secs/nsecs is 0 or tz is UTC, it +// is not encoded in the byte array explicitly*. +// +// Descriptor 8 bits are of the form `A B C DDD EE`: +// A: Is secs component encoded? 1 = true +// B: Is nsecs component encoded? 1 = true +// C: Is tz component encoded? 1 = true +// DDD: Number of extra bytes for secs (range 0-7). +// If A = 1, secs encoded in DDD+1 bytes. +// If A = 0, secs is not encoded, and is assumed to be 0. +// If A = 1, then we need at least 1 byte to encode secs. +// DDD says the number of extra bytes beyond that 1. +// E.g. if DDD=0, then secs is represented in 1 byte. +// if DDD=2, then secs is represented in 3 bytes. +// EE: Number of extra bytes for nsecs (range 0-3). +// If B = 1, nsecs encoded in EE+1 bytes (similar to secs/DDD above) +// +// Following the descriptor bytes, subsequent bytes are: +// +// secs component encoded in `DDD + 1` bytes (if A == 1) +// nsecs component encoded in `EE + 1` bytes (if B == 1) +// tz component encoded in 2 bytes (if C == 1) +// +// secs and nsecs components are integers encoded in a BigEndian +// 2-complement encoding format. +// +// tz component is encoded as 2 bytes (16 bits). Most significant bit 15 to +// Least significant bit 0 are described below: +// +// Timezone offset has a range of -12:00 to +14:00 (ie -720 to +840 minutes). +// Bit 15 = have\_dst: set to 1 if we set the dst flag. +// Bit 14 = dst\_on: set to 1 if dst is in effect at the time, or 0 if not. +// Bits 13..0 = timezone offset in minutes. It is a signed integer in Big Endian format. +// +func encodeTime(t time.Time) []byte { + //t := rv.Interface().(time.Time) + tsecs, tnsecs := t.Unix(), t.Nanosecond() + var ( + bd byte + btmp [8]byte + bs [16]byte + i int = 1 + ) + l := t.Location() + if l == time.UTC { + l = nil + } + if tsecs != 0 { + bd = bd | 0x80 + bigen.PutUint64(btmp[:], uint64(tsecs)) + f := pruneSignExt(btmp[:], tsecs >= 0) + bd = bd | (byte(7-f) << 2) + copy(bs[i:], btmp[f:]) + i = i + (8 - f) + } + if tnsecs != 0 { + bd = bd | 0x40 + bigen.PutUint32(btmp[:4], uint32(tnsecs)) + f := pruneSignExt(btmp[:4], true) + bd = bd | byte(3-f) + copy(bs[i:], btmp[f:4]) + i = i + (4 - f) + } + if l != nil { + bd = bd | 0x20 + // Note that Go Libs do not give access to dst flag. + _, zoneOffset := t.Zone() + //zoneName, zoneOffset := t.Zone() + zoneOffset /= 60 + z := uint16(zoneOffset) + bigen.PutUint16(btmp[:2], z) + // clear dst flags + bs[i] = btmp[0] & 0x3f + bs[i+1] = btmp[1] + i = i + 2 + } + bs[0] = bd + return bs[0:i] +} + +// DecodeTime decodes a []byte into a time.Time. +func decodeTime(bs []byte) (tt time.Time, err error) { + bd := bs[0] + var ( + tsec int64 + tnsec uint32 + tz uint16 + i byte = 1 + i2 byte + n byte + ) + if bd&(1<<7) != 0 { + var btmp [8]byte + n = ((bd >> 2) & 0x7) + 1 + i2 = i + n + copy(btmp[8-n:], bs[i:i2]) + //if first bit of bs[i] is set, then fill btmp[0..8-n] with 0xff (ie sign extend it) + if bs[i]&(1<<7) != 0 { + copy(btmp[0:8-n], bsAll0xff) + //for j,k := byte(0), 8-n; j < k; j++ { btmp[j] = 0xff } + } + i = i2 + tsec = int64(bigen.Uint64(btmp[:])) + } + if bd&(1<<6) != 0 { + var btmp [4]byte + n = (bd & 0x3) + 1 + i2 = i + n + copy(btmp[4-n:], bs[i:i2]) + i = i2 + tnsec = bigen.Uint32(btmp[:]) + } + if bd&(1<<5) == 0 { + tt = time.Unix(tsec, int64(tnsec)).UTC() + return + } + // In stdlib time.Parse, when a date is parsed without a zone name, it uses "" as zone name. + // However, we need name here, so it can be shown when time is printed. + // Zone name is in form: UTC-08:00. + // Note that Go Libs do not give access to dst flag, so we ignore dst bits + + i2 = i + 2 + tz = bigen.Uint16(bs[i:i2]) + i = i2 + // sign extend sign bit into top 2 MSB (which were dst bits): + if tz&(1<<13) == 0 { // positive + tz = tz & 0x3fff //clear 2 MSBs: dst bits + } else { // negative + tz = tz | 0xc000 //set 2 MSBs: dst bits + //tzname[3] = '-' (TODO: verify. this works here) + } + tzint := int16(tz) + if tzint == 0 { + tt = time.Unix(tsec, int64(tnsec)).UTC() + } else { + // For Go Time, do not use a descriptive timezone. + // It's unnecessary, and makes it harder to do a reflect.DeepEqual. + // The Offset already tells what the offset should be, if not on UTC and unknown zone name. + // var zoneName = timeLocUTCName(tzint) + tt = time.Unix(tsec, int64(tnsec)).In(time.FixedZone("", int(tzint)*60)) + } + return +} + +func timeLocUTCName(tzint int16) string { + if tzint == 0 { + return "UTC" + } + var tzname = []byte("UTC+00:00") + //tzname := fmt.Sprintf("UTC%s%02d:%02d", tzsign, tz/60, tz%60) //perf issue using Sprintf. inline below. + //tzhr, tzmin := tz/60, tz%60 //faster if u convert to int first + var tzhr, tzmin int16 + if tzint < 0 { + tzname[3] = '-' // (TODO: verify. this works here) + tzhr, tzmin = -tzint/60, (-tzint)%60 + } else { + tzhr, tzmin = tzint/60, tzint%60 + } + tzname[4] = timeDigits[tzhr/10] + tzname[5] = timeDigits[tzhr%10] + tzname[7] = timeDigits[tzmin/10] + tzname[8] = timeDigits[tzmin%10] + return string(tzname) + //return time.FixedZone(string(tzname), int(tzint)*60) +} diff --git a/vendor/golang.org/x/image/LICENSE b/vendor/golang.org/x/image/LICENSE new file mode 100644 index 00000000..6a66aea5 --- /dev/null +++ b/vendor/golang.org/x/image/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2009 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/golang.org/x/image/PATENTS b/vendor/golang.org/x/image/PATENTS new file mode 100644 index 00000000..73309904 --- /dev/null +++ b/vendor/golang.org/x/image/PATENTS @@ -0,0 +1,22 @@ +Additional IP Rights Grant (Patents) + +"This implementation" means the copyrightable works distributed by +Google as part of the Go project. + +Google hereby grants to You a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable (except as stated in this section) +patent license to make, have made, use, offer to sell, sell, import, +transfer and otherwise run, modify and propagate the contents of this +implementation of Go, where such license applies only to those patent +claims, both currently owned or controlled by Google and acquired in +the future, licensable by Google that are necessarily infringed by this +implementation of Go. This grant does not include claims that would be +infringed only as a consequence of further modification of this +implementation. If you or your agent or exclusive licensee institute or +order or agree to the institution of patent litigation against any +entity (including a cross-claim or counterclaim in a lawsuit) alleging +that this implementation of Go or any code incorporated within this +implementation of Go constitutes direct or contributory patent +infringement, or inducement of patent infringement, then any patent +rights granted to you under this License for this implementation of Go +shall terminate as of the date such litigation is filed. diff --git a/vendor/golang.org/x/image/draw/draw.go b/vendor/golang.org/x/image/draw/draw.go new file mode 100644 index 00000000..b92e3c7f --- /dev/null +++ b/vendor/golang.org/x/image/draw/draw.go @@ -0,0 +1,79 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package draw provides image composition functions. +// +// See "The Go image/draw package" for an introduction to this package: +// http://golang.org/doc/articles/image_draw.html +// +// This package is a superset of and a drop-in replacement for the image/draw +// package in the standard library. +package draw + +// This file just contains the API exported by the image/draw package in the +// standard library. Other files in this package provide additional features. + +import ( + "image" + "image/color" + "image/draw" +) + +// Draw calls DrawMask with a nil mask. +func Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point, op Op) { + draw.Draw(dst, r, src, sp, draw.Op(op)) +} + +// DrawMask aligns r.Min in dst with sp in src and mp in mask and then +// replaces the rectangle r in dst with the result of a Porter-Duff +// composition. A nil mask is treated as opaque. +func DrawMask(dst Image, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op) { + draw.DrawMask(dst, r, src, sp, mask, mp, draw.Op(op)) +} + +// Drawer contains the Draw method. +type Drawer interface { + // Draw aligns r.Min in dst with sp in src and then replaces the + // rectangle r in dst with the result of drawing src on dst. + Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point) +} + +// FloydSteinberg is a Drawer that is the Src Op with Floyd-Steinberg error +// diffusion. +var FloydSteinberg Drawer = floydSteinberg{} + +type floydSteinberg struct{} + +func (floydSteinberg) Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point) { + draw.FloydSteinberg.Draw(dst, r, src, sp) +} + +// Image is an image.Image with a Set method to change a single pixel. +type Image interface { + image.Image + Set(x, y int, c color.Color) +} + +// Op is a Porter-Duff compositing operator. +type Op int + +const ( + // Over specifies ``(src in mask) over dst''. + Over Op = Op(draw.Over) + // Src specifies ``src in mask''. + Src Op = Op(draw.Src) +) + +// Draw implements the Drawer interface by calling the Draw function with +// this Op. +func (op Op) Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point) { + (draw.Op(op)).Draw(dst, r, src, sp) +} + +// Quantizer produces a palette for an image. +type Quantizer interface { + // Quantize appends up to cap(p) - len(p) colors to p and returns the + // updated palette suitable for converting m to a paletted image. + Quantize(p color.Palette, m image.Image) color.Palette +} diff --git a/vendor/golang.org/x/image/draw/gen.go b/vendor/golang.org/x/image/draw/gen.go new file mode 100644 index 00000000..0fed4743 --- /dev/null +++ b/vendor/golang.org/x/image/draw/gen.go @@ -0,0 +1,1403 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build ignore + +package main + +import ( + "bytes" + "flag" + "fmt" + "go/format" + "io/ioutil" + "log" + "os" + "strings" +) + +var debug = flag.Bool("debug", false, "") + +func main() { + flag.Parse() + + w := new(bytes.Buffer) + w.WriteString("// generated by \"go run gen.go\". DO NOT EDIT.\n\n" + + "package draw\n\nimport (\n" + + "\"image\"\n" + + "\"image/color\"\n" + + "\"math\"\n" + + "\n" + + "\"golang.org/x/image/math/f64\"\n" + + ")\n") + + gen(w, "nnInterpolator", codeNNScaleLeaf, codeNNTransformLeaf) + gen(w, "ablInterpolator", codeABLScaleLeaf, codeABLTransformLeaf) + genKernel(w) + + if *debug { + os.Stdout.Write(w.Bytes()) + return + } + out, err := format.Source(w.Bytes()) + if err != nil { + log.Fatal(err) + } + if err := ioutil.WriteFile("impl.go", out, 0660); err != nil { + log.Fatal(err) + } +} + +var ( + // dsTypes are the (dst image type, src image type) pairs to generate + // scale_DType_SType implementations for. The last element in the slice + // should be the fallback pair ("Image", "image.Image"). + // + // TODO: add *image.CMYK src type after Go 1.5 is released. + // An *image.CMYK is also alwaysOpaque. + dsTypes = []struct{ dType, sType string }{ + {"*image.RGBA", "*image.Gray"}, + {"*image.RGBA", "*image.NRGBA"}, + {"*image.RGBA", "*image.RGBA"}, + {"*image.RGBA", "*image.YCbCr"}, + {"*image.RGBA", "image.Image"}, + {"Image", "image.Image"}, + } + dTypes, sTypes []string + sTypesForDType = map[string][]string{} + subsampleRatios = []string{ + "444", + "422", + "420", + "440", + } + ops = []string{"Over", "Src"} + // alwaysOpaque are those image.Image implementations that are always + // opaque. For these types, Over is equivalent to the faster Src, in the + // absence of a source mask. + alwaysOpaque = map[string]bool{ + "*image.Gray": true, + "*image.YCbCr": true, + } +) + +func init() { + dTypesSeen := map[string]bool{} + sTypesSeen := map[string]bool{} + for _, t := range dsTypes { + if !sTypesSeen[t.sType] { + sTypesSeen[t.sType] = true + sTypes = append(sTypes, t.sType) + } + if !dTypesSeen[t.dType] { + dTypesSeen[t.dType] = true + dTypes = append(dTypes, t.dType) + } + sTypesForDType[t.dType] = append(sTypesForDType[t.dType], t.sType) + } + sTypesForDType["anyDType"] = sTypes +} + +type data struct { + dType string + sType string + sratio string + receiver string + op string +} + +func gen(w *bytes.Buffer, receiver string, codes ...string) { + expn(w, codeRoot, &data{receiver: receiver}) + for _, code := range codes { + for _, t := range dsTypes { + for _, op := range ops { + if op == "Over" && alwaysOpaque[t.sType] { + continue + } + expn(w, code, &data{ + dType: t.dType, + sType: t.sType, + receiver: receiver, + op: op, + }) + } + } + } +} + +func genKernel(w *bytes.Buffer) { + expn(w, codeKernelRoot, &data{}) + for _, sType := range sTypes { + expn(w, codeKernelScaleLeafX, &data{ + sType: sType, + }) + } + for _, dType := range dTypes { + for _, op := range ops { + expn(w, codeKernelScaleLeafY, &data{ + dType: dType, + op: op, + }) + } + } + for _, t := range dsTypes { + for _, op := range ops { + if op == "Over" && alwaysOpaque[t.sType] { + continue + } + expn(w, codeKernelTransformLeaf, &data{ + dType: t.dType, + sType: t.sType, + op: op, + }) + } + } +} + +func expn(w *bytes.Buffer, code string, d *data) { + if d.sType == "*image.YCbCr" && d.sratio == "" { + for _, sratio := range subsampleRatios { + e := *d + e.sratio = sratio + expn(w, code, &e) + } + return + } + + for _, line := range strings.Split(code, "\n") { + line = expnLine(line, d) + if line == ";" { + continue + } + fmt.Fprintln(w, line) + } +} + +func expnLine(line string, d *data) string { + for { + i := strings.IndexByte(line, '$') + if i < 0 { + break + } + prefix, s := line[:i], line[i+1:] + + i = len(s) + for j, c := range s { + if !('A' <= c && c <= 'Z' || 'a' <= c && c <= 'z') { + i = j + break + } + } + dollar, suffix := s[:i], s[i:] + + e := expnDollar(prefix, dollar, suffix, d) + if e == "" { + log.Fatalf("couldn't expand %q", line) + } + line = e + } + return line +} + +// expnDollar expands a "$foo" fragment in a line of generated code. It returns +// the empty string if there was a problem. It returns ";" if the generated +// code is a no-op. +func expnDollar(prefix, dollar, suffix string, d *data) string { + switch dollar { + case "dType": + return prefix + d.dType + suffix + case "dTypeRN": + return prefix + relName(d.dType) + suffix + case "sratio": + return prefix + d.sratio + suffix + case "sType": + return prefix + d.sType + suffix + case "sTypeRN": + return prefix + relName(d.sType) + suffix + case "receiver": + return prefix + d.receiver + suffix + case "op": + return prefix + d.op + suffix + + case "switch": + return expnSwitch("", "", true, suffix) + case "switchD": + return expnSwitch("", "", false, suffix) + case "switchS": + return expnSwitch("", "anyDType", false, suffix) + + case "preOuter": + switch d.dType { + default: + return ";" + case "Image": + s := "" + if d.sType == "image.Image" { + s = "srcMask, smp := opts.SrcMask, opts.SrcMaskP\n" + } + return s + + "dstMask, dmp := opts.DstMask, opts.DstMaskP\n" + + "dstColorRGBA64 := &color.RGBA64{}\n" + + "dstColor := color.Color(dstColorRGBA64)" + } + + case "preInner": + switch d.dType { + default: + return ";" + case "*image.RGBA": + return "d := " + pixOffset("dst", "dr.Min.X+adr.Min.X", "dr.Min.Y+int(dy)", "*4", "*dst.Stride") + } + + case "preKernelOuter": + switch d.sType { + default: + return ";" + case "image.Image": + return "srcMask, smp := opts.SrcMask, opts.SrcMaskP" + } + + case "preKernelInner": + switch d.dType { + default: + return ";" + case "*image.RGBA": + return "d := " + pixOffset("dst", "dr.Min.X+int(dx)", "dr.Min.Y+adr.Min.Y", "*4", "*dst.Stride") + } + + case "blend": + args, _ := splitArgs(suffix) + if len(args) != 4 { + return "" + } + switch d.sType { + default: + return argf(args, ""+ + "$3r = $0*$1r + $2*$3r\n"+ + "$3g = $0*$1g + $2*$3g\n"+ + "$3b = $0*$1b + $2*$3b\n"+ + "$3a = $0*$1a + $2*$3a", + ) + case "*image.Gray": + return argf(args, ""+ + "$3r = $0*$1r + $2*$3r", + ) + case "*image.YCbCr": + return argf(args, ""+ + "$3r = $0*$1r + $2*$3r\n"+ + "$3g = $0*$1g + $2*$3g\n"+ + "$3b = $0*$1b + $2*$3b", + ) + } + + case "clampToAlpha": + if alwaysOpaque[d.sType] { + return ";" + } + // Go uses alpha-premultiplied color. The naive computation can lead to + // invalid colors, e.g. red > alpha, when some weights are negative. + return ` + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + ` + + case "convFtou": + args, _ := splitArgs(suffix) + if len(args) != 2 { + return "" + } + + switch d.sType { + default: + return argf(args, ""+ + "$0r := uint32($1r)\n"+ + "$0g := uint32($1g)\n"+ + "$0b := uint32($1b)\n"+ + "$0a := uint32($1a)", + ) + case "*image.Gray": + return argf(args, ""+ + "$0r := uint32($1r)", + ) + case "*image.YCbCr": + return argf(args, ""+ + "$0r := uint32($1r)\n"+ + "$0g := uint32($1g)\n"+ + "$0b := uint32($1b)", + ) + } + + case "outputu": + args, _ := splitArgs(suffix) + if len(args) != 3 { + return "" + } + + switch d.op { + case "Over": + switch d.dType { + default: + log.Fatalf("bad dType %q", d.dType) + case "Image": + return argf(args, ""+ + "qr, qg, qb, qa := dst.At($0, $1).RGBA()\n"+ + "if dstMask != nil {\n"+ + " _, _, _, ma := dstMask.At(dmp.X + $0, dmp.Y + $1).RGBA()\n"+ + " $2r = $2r * ma / 0xffff\n"+ + " $2g = $2g * ma / 0xffff\n"+ + " $2b = $2b * ma / 0xffff\n"+ + " $2a = $2a * ma / 0xffff\n"+ + "}\n"+ + "$2a1 := 0xffff - $2a\n"+ + "dstColorRGBA64.R = uint16(qr*$2a1/0xffff + $2r)\n"+ + "dstColorRGBA64.G = uint16(qg*$2a1/0xffff + $2g)\n"+ + "dstColorRGBA64.B = uint16(qb*$2a1/0xffff + $2b)\n"+ + "dstColorRGBA64.A = uint16(qa*$2a1/0xffff + $2a)\n"+ + "dst.Set($0, $1, dstColor)", + ) + case "*image.RGBA": + return argf(args, ""+ + "$2a1 := (0xffff - $2a) * 0x101\n"+ + "dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*$2a1/0xffff + $2r) >> 8)\n"+ + "dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*$2a1/0xffff + $2g) >> 8)\n"+ + "dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*$2a1/0xffff + $2b) >> 8)\n"+ + "dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*$2a1/0xffff + $2a) >> 8)", + ) + } + + case "Src": + switch d.dType { + default: + log.Fatalf("bad dType %q", d.dType) + case "Image": + return argf(args, ""+ + "if dstMask != nil {\n"+ + " qr, qg, qb, qa := dst.At($0, $1).RGBA()\n"+ + " _, _, _, ma := dstMask.At(dmp.X + $0, dmp.Y + $1).RGBA()\n"+ + " pr = pr * ma / 0xffff\n"+ + " pg = pg * ma / 0xffff\n"+ + " pb = pb * ma / 0xffff\n"+ + " pa = pa * ma / 0xffff\n"+ + " $2a1 := 0xffff - ma\n"+ // Note that this is ma, not $2a. + " dstColorRGBA64.R = uint16(qr*$2a1/0xffff + $2r)\n"+ + " dstColorRGBA64.G = uint16(qg*$2a1/0xffff + $2g)\n"+ + " dstColorRGBA64.B = uint16(qb*$2a1/0xffff + $2b)\n"+ + " dstColorRGBA64.A = uint16(qa*$2a1/0xffff + $2a)\n"+ + " dst.Set($0, $1, dstColor)\n"+ + "} else {\n"+ + " dstColorRGBA64.R = uint16($2r)\n"+ + " dstColorRGBA64.G = uint16($2g)\n"+ + " dstColorRGBA64.B = uint16($2b)\n"+ + " dstColorRGBA64.A = uint16($2a)\n"+ + " dst.Set($0, $1, dstColor)\n"+ + "}", + ) + case "*image.RGBA": + switch d.sType { + default: + return argf(args, ""+ + "dst.Pix[d+0] = uint8($2r >> 8)\n"+ + "dst.Pix[d+1] = uint8($2g >> 8)\n"+ + "dst.Pix[d+2] = uint8($2b >> 8)\n"+ + "dst.Pix[d+3] = uint8($2a >> 8)", + ) + case "*image.Gray": + return argf(args, ""+ + "out := uint8($2r >> 8)\n"+ + "dst.Pix[d+0] = out\n"+ + "dst.Pix[d+1] = out\n"+ + "dst.Pix[d+2] = out\n"+ + "dst.Pix[d+3] = 0xff", + ) + case "*image.YCbCr": + return argf(args, ""+ + "dst.Pix[d+0] = uint8($2r >> 8)\n"+ + "dst.Pix[d+1] = uint8($2g >> 8)\n"+ + "dst.Pix[d+2] = uint8($2b >> 8)\n"+ + "dst.Pix[d+3] = 0xff", + ) + } + } + } + + case "outputf": + args, _ := splitArgs(suffix) + if len(args) != 5 { + return "" + } + ret := "" + + switch d.op { + case "Over": + switch d.dType { + default: + log.Fatalf("bad dType %q", d.dType) + case "Image": + ret = argf(args, ""+ + "qr, qg, qb, qa := dst.At($0, $1).RGBA()\n"+ + "$3r0 := uint32($2($3r * $4))\n"+ + "$3g0 := uint32($2($3g * $4))\n"+ + "$3b0 := uint32($2($3b * $4))\n"+ + "$3a0 := uint32($2($3a * $4))\n"+ + "if dstMask != nil {\n"+ + " _, _, _, ma := dstMask.At(dmp.X + $0, dmp.Y + $1).RGBA()\n"+ + " $3r0 = $3r0 * ma / 0xffff\n"+ + " $3g0 = $3g0 * ma / 0xffff\n"+ + " $3b0 = $3b0 * ma / 0xffff\n"+ + " $3a0 = $3a0 * ma / 0xffff\n"+ + "}\n"+ + "$3a1 := 0xffff - $3a0\n"+ + "dstColorRGBA64.R = uint16(qr*$3a1/0xffff + $3r0)\n"+ + "dstColorRGBA64.G = uint16(qg*$3a1/0xffff + $3g0)\n"+ + "dstColorRGBA64.B = uint16(qb*$3a1/0xffff + $3b0)\n"+ + "dstColorRGBA64.A = uint16(qa*$3a1/0xffff + $3a0)\n"+ + "dst.Set($0, $1, dstColor)", + ) + case "*image.RGBA": + ret = argf(args, ""+ + "$3r0 := uint32($2($3r * $4))\n"+ + "$3g0 := uint32($2($3g * $4))\n"+ + "$3b0 := uint32($2($3b * $4))\n"+ + "$3a0 := uint32($2($3a * $4))\n"+ + "$3a1 := (0xffff - uint32($3a0)) * 0x101\n"+ + "dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*$3a1/0xffff + $3r0) >> 8)\n"+ + "dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*$3a1/0xffff + $3g0) >> 8)\n"+ + "dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*$3a1/0xffff + $3b0) >> 8)\n"+ + "dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*$3a1/0xffff + $3a0) >> 8)", + ) + } + + case "Src": + switch d.dType { + default: + log.Fatalf("bad dType %q", d.dType) + case "Image": + ret = argf(args, ""+ + "if dstMask != nil {\n"+ + " qr, qg, qb, qa := dst.At($0, $1).RGBA()\n"+ + " _, _, _, ma := dstMask.At(dmp.X + $0, dmp.Y + $1).RGBA()\n"+ + " pr := uint32($2($3r * $4)) * ma / 0xffff\n"+ + " pg := uint32($2($3g * $4)) * ma / 0xffff\n"+ + " pb := uint32($2($3b * $4)) * ma / 0xffff\n"+ + " pa := uint32($2($3a * $4)) * ma / 0xffff\n"+ + " pa1 := 0xffff - ma\n"+ // Note that this is ma, not pa. + " dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr)\n"+ + " dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg)\n"+ + " dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb)\n"+ + " dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa)\n"+ + " dst.Set($0, $1, dstColor)\n"+ + "} else {\n"+ + " dstColorRGBA64.R = $2($3r * $4)\n"+ + " dstColorRGBA64.G = $2($3g * $4)\n"+ + " dstColorRGBA64.B = $2($3b * $4)\n"+ + " dstColorRGBA64.A = $2($3a * $4)\n"+ + " dst.Set($0, $1, dstColor)\n"+ + "}", + ) + case "*image.RGBA": + switch d.sType { + default: + ret = argf(args, ""+ + "dst.Pix[d+0] = uint8($2($3r * $4) >> 8)\n"+ + "dst.Pix[d+1] = uint8($2($3g * $4) >> 8)\n"+ + "dst.Pix[d+2] = uint8($2($3b * $4) >> 8)\n"+ + "dst.Pix[d+3] = uint8($2($3a * $4) >> 8)", + ) + case "*image.Gray": + ret = argf(args, ""+ + "out := uint8($2($3r * $4) >> 8)\n"+ + "dst.Pix[d+0] = out\n"+ + "dst.Pix[d+1] = out\n"+ + "dst.Pix[d+2] = out\n"+ + "dst.Pix[d+3] = 0xff", + ) + case "*image.YCbCr": + ret = argf(args, ""+ + "dst.Pix[d+0] = uint8($2($3r * $4) >> 8)\n"+ + "dst.Pix[d+1] = uint8($2($3g * $4) >> 8)\n"+ + "dst.Pix[d+2] = uint8($2($3b * $4) >> 8)\n"+ + "dst.Pix[d+3] = 0xff", + ) + } + } + } + + return strings.Replace(ret, " * 1)", ")", -1) + + case "srcf", "srcu": + lhs, eqOp := splitEq(prefix) + if lhs == "" { + return "" + } + args, extra := splitArgs(suffix) + if len(args) != 2 { + return "" + } + + tmp := "" + if dollar == "srcf" { + tmp = "u" + } + + // TODO: there's no need to multiply by 0x101 in the switch below if + // the next thing we're going to do is shift right by 8. + + buf := new(bytes.Buffer) + switch d.sType { + default: + log.Fatalf("bad sType %q", d.sType) + case "image.Image": + fmt.Fprintf(buf, ""+ + "%sr%s, %sg%s, %sb%s, %sa%s := src.At(%s, %s).RGBA()\n", + lhs, tmp, lhs, tmp, lhs, tmp, lhs, tmp, args[0], args[1], + ) + if d.dType == "" || d.dType == "Image" { + fmt.Fprintf(buf, ""+ + "if srcMask != nil {\n"+ + " _, _, _, ma := srcMask.At(smp.X+%s, smp.Y+%s).RGBA()\n"+ + " %sr%s = %sr%s * ma / 0xffff\n"+ + " %sg%s = %sg%s * ma / 0xffff\n"+ + " %sb%s = %sb%s * ma / 0xffff\n"+ + " %sa%s = %sa%s * ma / 0xffff\n"+ + "}\n", + args[0], args[1], + lhs, tmp, lhs, tmp, + lhs, tmp, lhs, tmp, + lhs, tmp, lhs, tmp, + lhs, tmp, lhs, tmp, + ) + } + case "*image.Gray": + fmt.Fprintf(buf, ""+ + "%si := %s\n"+ + "%sr%s := uint32(src.Pix[%si]) * 0x101\n", + lhs, pixOffset("src", args[0], args[1], "", "*src.Stride"), + lhs, tmp, lhs, + ) + case "*image.NRGBA": + fmt.Fprintf(buf, ""+ + "%si := %s\n"+ + "%sa%s := uint32(src.Pix[%si+3]) * 0x101\n"+ + "%sr%s := uint32(src.Pix[%si+0]) * %sa%s / 0xff\n"+ + "%sg%s := uint32(src.Pix[%si+1]) * %sa%s / 0xff\n"+ + "%sb%s := uint32(src.Pix[%si+2]) * %sa%s / 0xff\n", + lhs, pixOffset("src", args[0], args[1], "*4", "*src.Stride"), + lhs, tmp, lhs, + lhs, tmp, lhs, lhs, tmp, + lhs, tmp, lhs, lhs, tmp, + lhs, tmp, lhs, lhs, tmp, + ) + case "*image.RGBA": + fmt.Fprintf(buf, ""+ + "%si := %s\n"+ + "%sr%s := uint32(src.Pix[%si+0]) * 0x101\n"+ + "%sg%s := uint32(src.Pix[%si+1]) * 0x101\n"+ + "%sb%s := uint32(src.Pix[%si+2]) * 0x101\n"+ + "%sa%s := uint32(src.Pix[%si+3]) * 0x101\n", + lhs, pixOffset("src", args[0], args[1], "*4", "*src.Stride"), + lhs, tmp, lhs, + lhs, tmp, lhs, + lhs, tmp, lhs, + lhs, tmp, lhs, + ) + case "*image.YCbCr": + fmt.Fprintf(buf, ""+ + "%si := %s\n"+ + "%sj := %s\n"+ + "%s\n", + lhs, pixOffset("src", args[0], args[1], "", "*src.YStride"), + lhs, cOffset(args[0], args[1], d.sratio), + ycbcrToRGB(lhs, tmp), + ) + } + + if dollar == "srcf" { + switch d.sType { + default: + fmt.Fprintf(buf, ""+ + "%sr %s float64(%sru)%s\n"+ + "%sg %s float64(%sgu)%s\n"+ + "%sb %s float64(%sbu)%s\n"+ + "%sa %s float64(%sau)%s\n", + lhs, eqOp, lhs, extra, + lhs, eqOp, lhs, extra, + lhs, eqOp, lhs, extra, + lhs, eqOp, lhs, extra, + ) + case "*image.Gray": + fmt.Fprintf(buf, ""+ + "%sr %s float64(%sru)%s\n", + lhs, eqOp, lhs, extra, + ) + case "*image.YCbCr": + fmt.Fprintf(buf, ""+ + "%sr %s float64(%sru)%s\n"+ + "%sg %s float64(%sgu)%s\n"+ + "%sb %s float64(%sbu)%s\n", + lhs, eqOp, lhs, extra, + lhs, eqOp, lhs, extra, + lhs, eqOp, lhs, extra, + ) + } + } + + return strings.TrimSpace(buf.String()) + + case "tweakD": + if d.dType == "*image.RGBA" { + return "d += dst.Stride" + } + return ";" + + case "tweakDx": + if d.dType == "*image.RGBA" { + return strings.Replace(prefix, "dx++", "dx, d = dx+1, d+4", 1) + } + return prefix + + case "tweakDy": + if d.dType == "*image.RGBA" { + return strings.Replace(prefix, "for dy, s", "for _, s", 1) + } + return prefix + + case "tweakP": + switch d.sType { + case "*image.Gray": + if strings.HasPrefix(strings.TrimSpace(prefix), "pa * ") { + return "1," + } + return "pr," + case "*image.YCbCr": + if strings.HasPrefix(strings.TrimSpace(prefix), "pa * ") { + return "1," + } + } + return prefix + + case "tweakPr": + if d.sType == "*image.Gray" { + return "pr *= s.invTotalWeightFFFF" + } + return ";" + + case "tweakVarP": + switch d.sType { + case "*image.Gray": + return strings.Replace(prefix, "var pr, pg, pb, pa", "var pr", 1) + case "*image.YCbCr": + return strings.Replace(prefix, "var pr, pg, pb, pa", "var pr, pg, pb", 1) + } + return prefix + } + return "" +} + +func expnSwitch(op, dType string, expandBoth bool, template string) string { + if op == "" && dType != "anyDType" { + lines := []string{"switch op {"} + for _, op = range ops { + lines = append(lines, + fmt.Sprintf("case %s:", op), + expnSwitch(op, dType, expandBoth, template), + ) + } + lines = append(lines, "}") + return strings.Join(lines, "\n") + } + + switchVar := "dst" + if dType != "" { + switchVar = "src" + } + lines := []string{fmt.Sprintf("switch %s := %s.(type) {", switchVar, switchVar)} + + fallback, values := "Image", dTypes + if dType != "" { + fallback, values = "image.Image", sTypesForDType[dType] + } + for _, v := range values { + if dType != "" { + // v is the sType. Skip those always-opaque sTypes, where Over is + // equivalent to Src. + if op == "Over" && alwaysOpaque[v] { + continue + } + } + + if v == fallback { + lines = append(lines, "default:") + } else { + lines = append(lines, fmt.Sprintf("case %s:", v)) + } + + if dType != "" { + if v == "*image.YCbCr" { + lines = append(lines, expnSwitchYCbCr(op, dType, template)) + } else { + lines = append(lines, expnLine(template, &data{dType: dType, sType: v, op: op})) + } + } else if !expandBoth { + lines = append(lines, expnLine(template, &data{dType: v, op: op})) + } else { + lines = append(lines, expnSwitch(op, v, false, template)) + } + } + + lines = append(lines, "}") + return strings.Join(lines, "\n") +} + +func expnSwitchYCbCr(op, dType, template string) string { + lines := []string{ + "switch src.SubsampleRatio {", + "default:", + expnLine(template, &data{dType: dType, sType: "image.Image", op: op}), + } + for _, sratio := range subsampleRatios { + lines = append(lines, + fmt.Sprintf("case image.YCbCrSubsampleRatio%s:", sratio), + expnLine(template, &data{dType: dType, sType: "*image.YCbCr", sratio: sratio, op: op}), + ) + } + lines = append(lines, "}") + return strings.Join(lines, "\n") +} + +func argf(args []string, s string) string { + if len(args) > 9 { + panic("too many args") + } + for i, a := range args { + old := fmt.Sprintf("$%d", i) + s = strings.Replace(s, old, a, -1) + } + return s +} + +func pixOffset(m, x, y, xstride, ystride string) string { + return fmt.Sprintf("(%s-%s.Rect.Min.Y)%s + (%s-%s.Rect.Min.X)%s", y, m, ystride, x, m, xstride) +} + +func cOffset(x, y, sratio string) string { + switch sratio { + case "444": + return fmt.Sprintf("( %s - src.Rect.Min.Y )*src.CStride + ( %s - src.Rect.Min.X )", y, x) + case "422": + return fmt.Sprintf("( %s - src.Rect.Min.Y )*src.CStride + ((%s)/2 - src.Rect.Min.X/2)", y, x) + case "420": + return fmt.Sprintf("((%s)/2 - src.Rect.Min.Y/2)*src.CStride + ((%s)/2 - src.Rect.Min.X/2)", y, x) + case "440": + return fmt.Sprintf("((%s)/2 - src.Rect.Min.Y/2)*src.CStride + ( %s - src.Rect.Min.X )", y, x) + } + return fmt.Sprintf("unsupported sratio %q", sratio) +} + +func ycbcrToRGB(lhs, tmp string) string { + s := ` + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + $yy1 := int(src.Y[$i]) * 0x10100 + $cb1 := int(src.Cb[$j]) - 128 + $cr1 := int(src.Cr[$j]) - 128 + $r@ := ($yy1 + 91881*$cr1) >> 8 + $g@ := ($yy1 - 22554*$cb1 - 46802*$cr1) >> 8 + $b@ := ($yy1 + 116130*$cb1) >> 8 + if $r@ < 0 { + $r@ = 0 + } else if $r@ > 0xffff { + $r@ = 0xffff + } + if $g@ < 0 { + $g@ = 0 + } else if $g@ > 0xffff { + $g@ = 0xffff + } + if $b@ < 0 { + $b@ = 0 + } else if $b@ > 0xffff { + $b@ = 0xffff + } + ` + s = strings.Replace(s, "$", lhs, -1) + s = strings.Replace(s, "@", tmp, -1) + return s +} + +func split(s, sep string) (string, string) { + if i := strings.Index(s, sep); i >= 0 { + return strings.TrimSpace(s[:i]), strings.TrimSpace(s[i+len(sep):]) + } + return "", "" +} + +func splitEq(s string) (lhs, eqOp string) { + s = strings.TrimSpace(s) + if lhs, _ = split(s, ":="); lhs != "" { + return lhs, ":=" + } + if lhs, _ = split(s, "+="); lhs != "" { + return lhs, "+=" + } + return "", "" +} + +func splitArgs(s string) (args []string, extra string) { + s = strings.TrimSpace(s) + if s == "" || s[0] != '[' { + return nil, "" + } + s = s[1:] + + i := strings.IndexByte(s, ']') + if i < 0 { + return nil, "" + } + args, extra = strings.Split(s[:i], ","), s[i+1:] + for i := range args { + args[i] = strings.TrimSpace(args[i]) + } + return args, extra +} + +func relName(s string) string { + if i := strings.LastIndex(s, "."); i >= 0 { + return s[i+1:] + } + return s +} + +const ( + codeRoot = ` + func (z $receiver) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { + // Try to simplify a Scale to a Copy. + if dr.Size() == sr.Size() { + Copy(dst, dr.Min, src, sr, op, opts) + return + } + + var o Options + if opts != nil { + o = *opts + } + + // adr is the affected destination pixels. + adr := dst.Bounds().Intersect(dr) + adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) + if adr.Empty() || sr.Empty() { + return + } + // Make adr relative to dr.Min. + adr = adr.Sub(dr.Min) + if op == Over && o.SrcMask == nil && opaque(src) { + op = Src + } + + // sr is the source pixels. If it extends beyond the src bounds, + // we cannot use the type-specific fast paths, as they access + // the Pix fields directly without bounds checking. + // + // Similarly, the fast paths assume that the masks are nil. + if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { + switch op { + case Over: + z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o) + case Src: + z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o) + } + } else if _, ok := src.(*image.Uniform); ok { + Draw(dst, dr, src, src.Bounds().Min, op) + } else { + $switch z.scale_$dTypeRN_$sTypeRN$sratio_$op(dst, dr, adr, src, sr, &o) + } + } + + func (z $receiver) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) { + // Try to simplify a Transform to a Copy. + if s2d[0] == 1 && s2d[1] == 0 && s2d[3] == 0 && s2d[4] == 1 { + dx := int(s2d[2]) + dy := int(s2d[5]) + if float64(dx) == s2d[2] && float64(dy) == s2d[5] { + Copy(dst, image.Point{X: sr.Min.X + dx, Y: sr.Min.X + dy}, src, sr, op, opts) + return + } + } + + var o Options + if opts != nil { + o = *opts + } + + dr := transformRect(&s2d, &sr) + // adr is the affected destination pixels. + adr := dst.Bounds().Intersect(dr) + adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) + if adr.Empty() || sr.Empty() { + return + } + if op == Over && o.SrcMask == nil && opaque(src) { + op = Src + } + + d2s := invert(&s2d) + // bias is a translation of the mapping from dst coordinates to src + // coordinates such that the latter temporarily have non-negative X + // and Y coordinates. This allows us to write int(f) instead of + // int(math.Floor(f)), since "round to zero" and "round down" are + // equivalent when f >= 0, but the former is much cheaper. The X-- + // and Y-- are because the TransformLeaf methods have a "sx -= 0.5" + // adjustment. + bias := transformRect(&d2s, &adr).Min + bias.X-- + bias.Y-- + d2s[2] -= float64(bias.X) + d2s[5] -= float64(bias.Y) + // Make adr relative to dr.Min. + adr = adr.Sub(dr.Min) + // sr is the source pixels. If it extends beyond the src bounds, + // we cannot use the type-specific fast paths, as they access + // the Pix fields directly without bounds checking. + // + // Similarly, the fast paths assume that the masks are nil. + if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { + switch op { + case Over: + z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + case Src: + z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + } + } else if u, ok := src.(*image.Uniform); ok { + transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op) + } else { + $switch z.transform_$dTypeRN_$sTypeRN$sratio_$op(dst, dr, adr, &d2s, src, sr, bias, &o) + } + } + ` + + codeNNScaleLeaf = ` + func (nnInterpolator) scale_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, src $sType, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + $preOuter + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + $preInner + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $tweakDx + sx := (2*uint64(dx) + 1) * sw / dw2 + p := $srcu[sr.Min.X + int(sx), sr.Min.Y + int(sy)] + $outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), p] + } + } + } + ` + + codeNNTransformLeaf = ` + func (nnInterpolator) transform_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point, opts *Options) { + $preOuter + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y + int(dy)) + 0.5 + $preInner + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $tweakDx + dxf := float64(dr.Min.X + int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf + d2s[1]*dyf + d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf + d2s[4]*dyf + d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + p := $srcu[sx0, sy0] + $outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), p] + } + } + } + ` + + codeABLScaleLeaf = ` + func (ablInterpolator) scale_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, src $sType, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw - 1, sh - 1 + $preOuter + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + $preInner + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $tweakDx + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00 := $srcf[sr.Min.X + int(sx0), sr.Min.Y + int(sy0)] + s10 := $srcf[sr.Min.X + int(sx1), sr.Min.Y + int(sy0)] + $blend[xFrac1, s00, xFrac0, s10] + s01 := $srcf[sr.Min.X + int(sx0), sr.Min.Y + int(sy1)] + s11 := $srcf[sr.Min.X + int(sx1), sr.Min.Y + int(sy1)] + $blend[xFrac1, s01, xFrac0, s11] + $blend[yFrac1, s10, yFrac0, s11] + $convFtou[p, s11] + $outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), p] + } + } + } + ` + + codeABLTransformLeaf = ` + func (ablInterpolator) transform_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point, opts *Options) { + $preOuter + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y + int(dy)) + 0.5 + $preInner + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $tweakDx + dxf := float64(dr.Min.X + int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00 := $srcf[sx0, sy0] + s10 := $srcf[sx1, sy0] + $blend[xFrac1, s00, xFrac0, s10] + s01 := $srcf[sx0, sy1] + s11 := $srcf[sx1, sy1] + $blend[xFrac1, s01, xFrac0, s11] + $blend[yFrac1, s10, yFrac0, s11] + $convFtou[p, s11] + $outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), p] + } + } + } + ` + + codeKernelRoot = ` + func (z *kernelScaler) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { + if z.dw != int32(dr.Dx()) || z.dh != int32(dr.Dy()) || z.sw != int32(sr.Dx()) || z.sh != int32(sr.Dy()) { + z.kernel.Scale(dst, dr, src, sr, op, opts) + return + } + + var o Options + if opts != nil { + o = *opts + } + + // adr is the affected destination pixels. + adr := dst.Bounds().Intersect(dr) + adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) + if adr.Empty() || sr.Empty() { + return + } + // Make adr relative to dr.Min. + adr = adr.Sub(dr.Min) + if op == Over && o.SrcMask == nil && opaque(src) { + op = Src + } + + if _, ok := src.(*image.Uniform); ok && o.DstMask == nil && o.SrcMask == nil && sr.In(src.Bounds()) { + Draw(dst, dr, src, src.Bounds().Min, op) + return + } + + // Create a temporary buffer: + // scaleX distributes the source image's columns over the temporary image. + // scaleY distributes the temporary image's rows over the destination image. + var tmp [][4]float64 + if z.pool.New != nil { + tmpp := z.pool.Get().(*[][4]float64) + defer z.pool.Put(tmpp) + tmp = *tmpp + } else { + tmp = z.makeTmpBuf() + } + + // sr is the source pixels. If it extends beyond the src bounds, + // we cannot use the type-specific fast paths, as they access + // the Pix fields directly without bounds checking. + // + // Similarly, the fast paths assume that the masks are nil. + if o.SrcMask != nil || !sr.In(src.Bounds()) { + z.scaleX_Image(tmp, src, sr, &o) + } else { + $switchS z.scaleX_$sTypeRN$sratio(tmp, src, sr, &o) + } + + if o.DstMask != nil { + switch op { + case Over: + z.scaleY_Image_Over(dst, dr, adr, tmp, &o) + case Src: + z.scaleY_Image_Src(dst, dr, adr, tmp, &o) + } + } else { + $switchD z.scaleY_$dTypeRN_$op(dst, dr, adr, tmp, &o) + } + } + + func (q *Kernel) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) { + var o Options + if opts != nil { + o = *opts + } + + dr := transformRect(&s2d, &sr) + // adr is the affected destination pixels. + adr := dst.Bounds().Intersect(dr) + adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) + if adr.Empty() || sr.Empty() { + return + } + if op == Over && o.SrcMask == nil && opaque(src) { + op = Src + } + d2s := invert(&s2d) + // bias is a translation of the mapping from dst coordinates to src + // coordinates such that the latter temporarily have non-negative X + // and Y coordinates. This allows us to write int(f) instead of + // int(math.Floor(f)), since "round to zero" and "round down" are + // equivalent when f >= 0, but the former is much cheaper. The X-- + // and Y-- are because the TransformLeaf methods have a "sx -= 0.5" + // adjustment. + bias := transformRect(&d2s, &adr).Min + bias.X-- + bias.Y-- + d2s[2] -= float64(bias.X) + d2s[5] -= float64(bias.Y) + // Make adr relative to dr.Min. + adr = adr.Sub(dr.Min) + + if u, ok := src.(*image.Uniform); ok && o.DstMask != nil && o.SrcMask != nil && sr.In(src.Bounds()) { + transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op) + return + } + + xscale := abs(d2s[0]) + if s := abs(d2s[1]); xscale < s { + xscale = s + } + yscale := abs(d2s[3]) + if s := abs(d2s[4]); yscale < s { + yscale = s + } + + // sr is the source pixels. If it extends beyond the src bounds, + // we cannot use the type-specific fast paths, as they access + // the Pix fields directly without bounds checking. + // + // Similarly, the fast paths assume that the masks are nil. + if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { + switch op { + case Over: + q.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + case Src: + q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + } + } else { + $switch q.transform_$dTypeRN_$sTypeRN$sratio_$op(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + } + } + ` + + codeKernelScaleLeafX = ` + func (z *kernelScaler) scaleX_$sTypeRN$sratio(tmp [][4]float64, src $sType, sr image.Rectangle, opts *Options) { + t := 0 + $preKernelOuter + for y := int32(0); y < z.sh; y++ { + for _, s := range z.horizontal.sources { + var pr, pg, pb, pa float64 $tweakVarP + for _, c := range z.horizontal.contribs[s.i:s.j] { + p += $srcf[sr.Min.X + int(c.coord), sr.Min.Y + int(y)] * c.weight + } + $tweakPr + tmp[t] = [4]float64{ + pr * s.invTotalWeightFFFF, $tweakP + pg * s.invTotalWeightFFFF, $tweakP + pb * s.invTotalWeightFFFF, $tweakP + pa * s.invTotalWeightFFFF, $tweakP + } + t++ + } + } + } + ` + + codeKernelScaleLeafY = ` + func (z *kernelScaler) scaleY_$dTypeRN_$op(dst $dType, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) { + $preOuter + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + $preKernelInner + for dy, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { $tweakDy + var pr, pg, pb, pa float64 + for _, c := range z.vertical.contribs[s.i:s.j] { + p := &tmp[c.coord*z.dw+dx] + pr += p[0] * c.weight + pg += p[1] * c.weight + pb += p[2] * c.weight + pa += p[3] * c.weight + } + $clampToAlpha + $outputf[dr.Min.X + int(dx), dr.Min.Y + int(adr.Min.Y + dy), ftou, p, s.invTotalWeight] + $tweakD + } + } + } + ` + + codeKernelTransformLeaf = ` + func (q *Kernel) transform_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1 + 2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1 + 2*int(math.Ceil(yHalfWidth))) + + $preOuter + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y + int(dy)) + 0.5 + $preInner + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $tweakDx + dxf := float64(dr.Min.X + int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx - ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky - iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb, pa float64 $tweakVarP + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky - iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx - ix] * yWeight; w != 0 { + p += $srcf[kx, ky] * w + } + } + } + } + $clampToAlpha + $outputf[dr.Min.X + int(dx), dr.Min.Y + int(dy), fffftou, p, 1] + } + } + } + ` +) diff --git a/vendor/golang.org/x/image/draw/impl.go b/vendor/golang.org/x/image/draw/impl.go new file mode 100644 index 00000000..d6484d73 --- /dev/null +++ b/vendor/golang.org/x/image/draw/impl.go @@ -0,0 +1,6668 @@ +// generated by "go run gen.go". DO NOT EDIT. + +package draw + +import ( + "image" + "image/color" + "math" + + "golang.org/x/image/math/f64" +) + +func (z nnInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { + // Try to simplify a Scale to a Copy. + if dr.Size() == sr.Size() { + Copy(dst, dr.Min, src, sr, op, opts) + return + } + + var o Options + if opts != nil { + o = *opts + } + + // adr is the affected destination pixels. + adr := dst.Bounds().Intersect(dr) + adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) + if adr.Empty() || sr.Empty() { + return + } + // Make adr relative to dr.Min. + adr = adr.Sub(dr.Min) + if op == Over && o.SrcMask == nil && opaque(src) { + op = Src + } + + // sr is the source pixels. If it extends beyond the src bounds, + // we cannot use the type-specific fast paths, as they access + // the Pix fields directly without bounds checking. + // + // Similarly, the fast paths assume that the masks are nil. + if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { + switch op { + case Over: + z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o) + case Src: + z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o) + } + } else if _, ok := src.(*image.Uniform); ok { + Draw(dst, dr, src, src.Bounds().Min, op) + } else { + switch op { + case Over: + switch dst := dst.(type) { + case *image.RGBA: + switch src := src.(type) { + case *image.NRGBA: + z.scale_RGBA_NRGBA_Over(dst, dr, adr, src, sr, &o) + case *image.RGBA: + z.scale_RGBA_RGBA_Over(dst, dr, adr, src, sr, &o) + default: + z.scale_RGBA_Image_Over(dst, dr, adr, src, sr, &o) + } + default: + switch src := src.(type) { + default: + z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o) + } + } + case Src: + switch dst := dst.(type) { + case *image.RGBA: + switch src := src.(type) { + case *image.Gray: + z.scale_RGBA_Gray_Src(dst, dr, adr, src, sr, &o) + case *image.NRGBA: + z.scale_RGBA_NRGBA_Src(dst, dr, adr, src, sr, &o) + case *image.RGBA: + z.scale_RGBA_RGBA_Src(dst, dr, adr, src, sr, &o) + case *image.YCbCr: + switch src.SubsampleRatio { + default: + z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o) + case image.YCbCrSubsampleRatio444: + z.scale_RGBA_YCbCr444_Src(dst, dr, adr, src, sr, &o) + case image.YCbCrSubsampleRatio422: + z.scale_RGBA_YCbCr422_Src(dst, dr, adr, src, sr, &o) + case image.YCbCrSubsampleRatio420: + z.scale_RGBA_YCbCr420_Src(dst, dr, adr, src, sr, &o) + case image.YCbCrSubsampleRatio440: + z.scale_RGBA_YCbCr440_Src(dst, dr, adr, src, sr, &o) + } + default: + z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o) + } + default: + switch src := src.(type) { + default: + z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o) + } + } + } + } +} + +func (z nnInterpolator) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) { + // Try to simplify a Transform to a Copy. + if s2d[0] == 1 && s2d[1] == 0 && s2d[3] == 0 && s2d[4] == 1 { + dx := int(s2d[2]) + dy := int(s2d[5]) + if float64(dx) == s2d[2] && float64(dy) == s2d[5] { + Copy(dst, image.Point{X: sr.Min.X + dx, Y: sr.Min.X + dy}, src, sr, op, opts) + return + } + } + + var o Options + if opts != nil { + o = *opts + } + + dr := transformRect(&s2d, &sr) + // adr is the affected destination pixels. + adr := dst.Bounds().Intersect(dr) + adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) + if adr.Empty() || sr.Empty() { + return + } + if op == Over && o.SrcMask == nil && opaque(src) { + op = Src + } + + d2s := invert(&s2d) + // bias is a translation of the mapping from dst coordinates to src + // coordinates such that the latter temporarily have non-negative X + // and Y coordinates. This allows us to write int(f) instead of + // int(math.Floor(f)), since "round to zero" and "round down" are + // equivalent when f >= 0, but the former is much cheaper. The X-- + // and Y-- are because the TransformLeaf methods have a "sx -= 0.5" + // adjustment. + bias := transformRect(&d2s, &adr).Min + bias.X-- + bias.Y-- + d2s[2] -= float64(bias.X) + d2s[5] -= float64(bias.Y) + // Make adr relative to dr.Min. + adr = adr.Sub(dr.Min) + // sr is the source pixels. If it extends beyond the src bounds, + // we cannot use the type-specific fast paths, as they access + // the Pix fields directly without bounds checking. + // + // Similarly, the fast paths assume that the masks are nil. + if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { + switch op { + case Over: + z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + case Src: + z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + } + } else if u, ok := src.(*image.Uniform); ok { + transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op) + } else { + switch op { + case Over: + switch dst := dst.(type) { + case *image.RGBA: + switch src := src.(type) { + case *image.NRGBA: + z.transform_RGBA_NRGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + case *image.RGBA: + z.transform_RGBA_RGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + default: + z.transform_RGBA_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + } + default: + switch src := src.(type) { + default: + z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + } + } + case Src: + switch dst := dst.(type) { + case *image.RGBA: + switch src := src.(type) { + case *image.Gray: + z.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case *image.NRGBA: + z.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case *image.RGBA: + z.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case *image.YCbCr: + switch src.SubsampleRatio { + default: + z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case image.YCbCrSubsampleRatio444: + z.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case image.YCbCrSubsampleRatio422: + z.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case image.YCbCrSubsampleRatio420: + z.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case image.YCbCrSubsampleRatio440: + z.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + } + default: + z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + } + default: + switch src := src.(type) { + default: + z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + } + } + } + } +} + +func (nnInterpolator) scale_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx) - src.Rect.Min.X) + pr := uint32(src.Pix[pi]) * 0x101 + out := uint8(pr >> 8) + dst.Pix[d+0] = out + dst.Pix[d+1] = out + dst.Pix[d+2] = out + dst.Pix[d+3] = 0xff + } + } +} + +func (nnInterpolator) scale_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx)-src.Rect.Min.X)*4 + pa := uint32(src.Pix[pi+3]) * 0x101 + pr := uint32(src.Pix[pi+0]) * pa / 0xff + pg := uint32(src.Pix[pi+1]) * pa / 0xff + pb := uint32(src.Pix[pi+2]) * pa / 0xff + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (nnInterpolator) scale_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx)-src.Rect.Min.X)*4 + pa := uint32(src.Pix[pi+3]) * 0x101 + pr := uint32(src.Pix[pi+0]) * pa / 0xff + pg := uint32(src.Pix[pi+1]) * pa / 0xff + pb := uint32(src.Pix[pi+2]) * pa / 0xff + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (nnInterpolator) scale_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx)-src.Rect.Min.X)*4 + pr := uint32(src.Pix[pi+0]) * 0x101 + pg := uint32(src.Pix[pi+1]) * 0x101 + pb := uint32(src.Pix[pi+2]) * 0x101 + pa := uint32(src.Pix[pi+3]) * 0x101 + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (nnInterpolator) scale_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx)-src.Rect.Min.X)*4 + pr := uint32(src.Pix[pi+0]) * 0x101 + pg := uint32(src.Pix[pi+1]) * 0x101 + pb := uint32(src.Pix[pi+2]) * 0x101 + pa := uint32(src.Pix[pi+3]) * 0x101 + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (nnInterpolator) scale_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx) - src.Rect.Min.X) + pj := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(sx) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pr := (pyy1 + 91881*pcr1) >> 8 + pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pb := (pyy1 + 116130*pcb1) >> 8 + if pr < 0 { + pr = 0 + } else if pr > 0xffff { + pr = 0xffff + } + if pg < 0 { + pg = 0 + } else if pg > 0xffff { + pg = 0xffff + } + if pb < 0 { + pb = 0 + } else if pb > 0xffff { + pb = 0xffff + } + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (nnInterpolator) scale_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx) - src.Rect.Min.X) + pj := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(sx))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pr := (pyy1 + 91881*pcr1) >> 8 + pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pb := (pyy1 + 116130*pcb1) >> 8 + if pr < 0 { + pr = 0 + } else if pr > 0xffff { + pr = 0xffff + } + if pg < 0 { + pg = 0 + } else if pg > 0xffff { + pg = 0xffff + } + if pb < 0 { + pb = 0 + } else if pb > 0xffff { + pb = 0xffff + } + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (nnInterpolator) scale_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx) - src.Rect.Min.X) + pj := ((sr.Min.Y+int(sy))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(sx))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pr := (pyy1 + 91881*pcr1) >> 8 + pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pb := (pyy1 + 116130*pcb1) >> 8 + if pr < 0 { + pr = 0 + } else if pr > 0xffff { + pr = 0xffff + } + if pg < 0 { + pg = 0 + } else if pg > 0xffff { + pg = 0xffff + } + if pb < 0 { + pb = 0 + } else if pb > 0xffff { + pb = 0xffff + } + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (nnInterpolator) scale_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx) - src.Rect.Min.X) + pj := ((sr.Min.Y+int(sy))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(sx) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pr := (pyy1 + 91881*pcr1) >> 8 + pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pb := (pyy1 + 116130*pcb1) >> 8 + if pr < 0 { + pr = 0 + } else if pr > 0xffff { + pr = 0xffff + } + if pg < 0 { + pg = 0 + } else if pg > 0xffff { + pg = 0xffff + } + if pb < 0 { + pb = 0 + } else if pb > 0xffff { + pb = 0xffff + } + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (nnInterpolator) scale_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (nnInterpolator) scale_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (2*uint64(dx) + 1) * sw / dw2 + pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (nnInterpolator) scale_Image_Image_Over(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + srcMask, smp := opts.SrcMask, opts.SrcMaskP + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + sx := (2*uint64(dx) + 1) * sw / dw2 + pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx), smp.Y+sr.Min.Y+int(sy)).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + } + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + if dstMask != nil { + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + } + pa1 := 0xffff - pa + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } +} + +func (nnInterpolator) scale_Image_Image_Src(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) + srcMask, smp := opts.SrcMask, opts.SrcMaskP + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (2*uint64(dy) + 1) * sh / dh2 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + sx := (2*uint64(dx) + 1) * sw / dw2 + pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx), smp.Y+sr.Min.Y+int(sy)).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + } + if dstMask != nil { + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + pa1 := 0xffff - ma + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } else { + dstColorRGBA64.R = uint16(pr) + dstColorRGBA64.G = uint16(pg) + dstColorRGBA64.B = uint16(pb) + dstColorRGBA64.A = uint16(pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } + } +} + +func (nnInterpolator) transform_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0 - src.Rect.Min.X) + pr := uint32(src.Pix[pi]) * 0x101 + out := uint8(pr >> 8) + dst.Pix[d+0] = out + dst.Pix[d+1] = out + dst.Pix[d+2] = out + dst.Pix[d+3] = 0xff + } + } +} + +func (nnInterpolator) transform_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + pa := uint32(src.Pix[pi+3]) * 0x101 + pr := uint32(src.Pix[pi+0]) * pa / 0xff + pg := uint32(src.Pix[pi+1]) * pa / 0xff + pb := uint32(src.Pix[pi+2]) * pa / 0xff + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (nnInterpolator) transform_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + pa := uint32(src.Pix[pi+3]) * 0x101 + pr := uint32(src.Pix[pi+0]) * pa / 0xff + pg := uint32(src.Pix[pi+1]) * pa / 0xff + pb := uint32(src.Pix[pi+2]) * pa / 0xff + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (nnInterpolator) transform_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + pr := uint32(src.Pix[pi+0]) * 0x101 + pg := uint32(src.Pix[pi+1]) * 0x101 + pb := uint32(src.Pix[pi+2]) * 0x101 + pa := uint32(src.Pix[pi+3]) * 0x101 + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (nnInterpolator) transform_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + pr := uint32(src.Pix[pi+0]) * 0x101 + pg := uint32(src.Pix[pi+1]) * 0x101 + pb := uint32(src.Pix[pi+2]) * 0x101 + pa := uint32(src.Pix[pi+3]) * 0x101 + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (nnInterpolator) transform_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pi := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + pj := (sy0-src.Rect.Min.Y)*src.CStride + (sx0 - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pr := (pyy1 + 91881*pcr1) >> 8 + pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pb := (pyy1 + 116130*pcb1) >> 8 + if pr < 0 { + pr = 0 + } else if pr > 0xffff { + pr = 0xffff + } + if pg < 0 { + pg = 0 + } else if pg > 0xffff { + pg = 0xffff + } + if pb < 0 { + pb = 0 + } else if pb > 0xffff { + pb = 0xffff + } + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (nnInterpolator) transform_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pi := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + pj := (sy0-src.Rect.Min.Y)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pr := (pyy1 + 91881*pcr1) >> 8 + pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pb := (pyy1 + 116130*pcb1) >> 8 + if pr < 0 { + pr = 0 + } else if pr > 0xffff { + pr = 0xffff + } + if pg < 0 { + pg = 0 + } else if pg > 0xffff { + pg = 0xffff + } + if pb < 0 { + pb = 0 + } else if pb > 0xffff { + pb = 0xffff + } + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (nnInterpolator) transform_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pi := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + pj := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pr := (pyy1 + 91881*pcr1) >> 8 + pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pb := (pyy1 + 116130*pcb1) >> 8 + if pr < 0 { + pr = 0 + } else if pr > 0xffff { + pr = 0xffff + } + if pg < 0 { + pg = 0 + } else if pg > 0xffff { + pg = 0xffff + } + if pb < 0 { + pb = 0 + } else if pb > 0xffff { + pb = 0xffff + } + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (nnInterpolator) transform_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pi := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + pj := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + (sx0 - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pr := (pyy1 + 91881*pcr1) >> 8 + pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pb := (pyy1 + 116130*pcb1) >> 8 + if pr < 0 { + pr = 0 + } else if pr > 0xffff { + pr = 0xffff + } + if pg < 0 { + pg = 0 + } else if pg > 0xffff { + pg = 0xffff + } + if pb < 0 { + pb = 0 + } else if pb > 0xffff { + pb = 0xffff + } + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (nnInterpolator) transform_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pr, pg, pb, pa := src.At(sx0, sy0).RGBA() + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (nnInterpolator) transform_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pr, pg, pb, pa := src.At(sx0, sy0).RGBA() + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (nnInterpolator) transform_Image_Image_Over(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { + srcMask, smp := opts.SrcMask, opts.SrcMaskP + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pr, pg, pb, pa := src.At(sx0, sy0).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy0).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + } + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + if dstMask != nil { + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + } + pa1 := 0xffff - pa + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } +} + +func (nnInterpolator) transform_Image_Image_Src(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { + srcMask, smp := opts.SrcMask, opts.SrcMaskP + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + pr, pg, pb, pa := src.At(sx0, sy0).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy0).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + } + if dstMask != nil { + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + pa1 := 0xffff - ma + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } else { + dstColorRGBA64.R = uint16(pr) + dstColorRGBA64.G = uint16(pg) + dstColorRGBA64.B = uint16(pb) + dstColorRGBA64.A = uint16(pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } + } +} + +func (z ablInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { + // Try to simplify a Scale to a Copy. + if dr.Size() == sr.Size() { + Copy(dst, dr.Min, src, sr, op, opts) + return + } + + var o Options + if opts != nil { + o = *opts + } + + // adr is the affected destination pixels. + adr := dst.Bounds().Intersect(dr) + adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) + if adr.Empty() || sr.Empty() { + return + } + // Make adr relative to dr.Min. + adr = adr.Sub(dr.Min) + if op == Over && o.SrcMask == nil && opaque(src) { + op = Src + } + + // sr is the source pixels. If it extends beyond the src bounds, + // we cannot use the type-specific fast paths, as they access + // the Pix fields directly without bounds checking. + // + // Similarly, the fast paths assume that the masks are nil. + if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { + switch op { + case Over: + z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o) + case Src: + z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o) + } + } else if _, ok := src.(*image.Uniform); ok { + Draw(dst, dr, src, src.Bounds().Min, op) + } else { + switch op { + case Over: + switch dst := dst.(type) { + case *image.RGBA: + switch src := src.(type) { + case *image.NRGBA: + z.scale_RGBA_NRGBA_Over(dst, dr, adr, src, sr, &o) + case *image.RGBA: + z.scale_RGBA_RGBA_Over(dst, dr, adr, src, sr, &o) + default: + z.scale_RGBA_Image_Over(dst, dr, adr, src, sr, &o) + } + default: + switch src := src.(type) { + default: + z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o) + } + } + case Src: + switch dst := dst.(type) { + case *image.RGBA: + switch src := src.(type) { + case *image.Gray: + z.scale_RGBA_Gray_Src(dst, dr, adr, src, sr, &o) + case *image.NRGBA: + z.scale_RGBA_NRGBA_Src(dst, dr, adr, src, sr, &o) + case *image.RGBA: + z.scale_RGBA_RGBA_Src(dst, dr, adr, src, sr, &o) + case *image.YCbCr: + switch src.SubsampleRatio { + default: + z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o) + case image.YCbCrSubsampleRatio444: + z.scale_RGBA_YCbCr444_Src(dst, dr, adr, src, sr, &o) + case image.YCbCrSubsampleRatio422: + z.scale_RGBA_YCbCr422_Src(dst, dr, adr, src, sr, &o) + case image.YCbCrSubsampleRatio420: + z.scale_RGBA_YCbCr420_Src(dst, dr, adr, src, sr, &o) + case image.YCbCrSubsampleRatio440: + z.scale_RGBA_YCbCr440_Src(dst, dr, adr, src, sr, &o) + } + default: + z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o) + } + default: + switch src := src.(type) { + default: + z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o) + } + } + } + } +} + +func (z ablInterpolator) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) { + // Try to simplify a Transform to a Copy. + if s2d[0] == 1 && s2d[1] == 0 && s2d[3] == 0 && s2d[4] == 1 { + dx := int(s2d[2]) + dy := int(s2d[5]) + if float64(dx) == s2d[2] && float64(dy) == s2d[5] { + Copy(dst, image.Point{X: sr.Min.X + dx, Y: sr.Min.X + dy}, src, sr, op, opts) + return + } + } + + var o Options + if opts != nil { + o = *opts + } + + dr := transformRect(&s2d, &sr) + // adr is the affected destination pixels. + adr := dst.Bounds().Intersect(dr) + adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) + if adr.Empty() || sr.Empty() { + return + } + if op == Over && o.SrcMask == nil && opaque(src) { + op = Src + } + + d2s := invert(&s2d) + // bias is a translation of the mapping from dst coordinates to src + // coordinates such that the latter temporarily have non-negative X + // and Y coordinates. This allows us to write int(f) instead of + // int(math.Floor(f)), since "round to zero" and "round down" are + // equivalent when f >= 0, but the former is much cheaper. The X-- + // and Y-- are because the TransformLeaf methods have a "sx -= 0.5" + // adjustment. + bias := transformRect(&d2s, &adr).Min + bias.X-- + bias.Y-- + d2s[2] -= float64(bias.X) + d2s[5] -= float64(bias.Y) + // Make adr relative to dr.Min. + adr = adr.Sub(dr.Min) + // sr is the source pixels. If it extends beyond the src bounds, + // we cannot use the type-specific fast paths, as they access + // the Pix fields directly without bounds checking. + // + // Similarly, the fast paths assume that the masks are nil. + if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { + switch op { + case Over: + z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + case Src: + z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + } + } else if u, ok := src.(*image.Uniform); ok { + transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op) + } else { + switch op { + case Over: + switch dst := dst.(type) { + case *image.RGBA: + switch src := src.(type) { + case *image.NRGBA: + z.transform_RGBA_NRGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + case *image.RGBA: + z.transform_RGBA_RGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + default: + z.transform_RGBA_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + } + default: + switch src := src.(type) { + default: + z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) + } + } + case Src: + switch dst := dst.(type) { + case *image.RGBA: + switch src := src.(type) { + case *image.Gray: + z.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case *image.NRGBA: + z.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case *image.RGBA: + z.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case *image.YCbCr: + switch src.SubsampleRatio { + default: + z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case image.YCbCrSubsampleRatio444: + z.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case image.YCbCrSubsampleRatio422: + z.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case image.YCbCrSubsampleRatio420: + z.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + case image.YCbCrSubsampleRatio440: + z.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + } + default: + z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + } + default: + switch src := src.(type) { + default: + z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) + } + } + } + } +} + +func (ablInterpolator) scale_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + s00ru := uint32(src.Pix[s00i]) * 0x101 + s00r := float64(s00ru) + s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + s10ru := uint32(src.Pix[s10i]) * 0x101 + s10r := float64(s10ru) + s10r = xFrac1*s00r + xFrac0*s10r + s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + s01ru := uint32(src.Pix[s01i]) * 0x101 + s01r := float64(s01ru) + s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + s11ru := uint32(src.Pix[s11i]) * 0x101 + s11r := float64(s11ru) + s11r = xFrac1*s01r + xFrac0*s11r + s11r = yFrac1*s10r + yFrac0*s11r + pr := uint32(s11r) + out := uint8(pr >> 8) + dst.Pix[d+0] = out + dst.Pix[d+1] = out + dst.Pix[d+2] = out + dst.Pix[d+3] = 0xff + } + } +} + +func (ablInterpolator) scale_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 + s00au := uint32(src.Pix[s00i+3]) * 0x101 + s00ru := uint32(src.Pix[s00i+0]) * s00au / 0xff + s00gu := uint32(src.Pix[s00i+1]) * s00au / 0xff + s00bu := uint32(src.Pix[s00i+2]) * s00au / 0xff + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 + s10au := uint32(src.Pix[s10i+3]) * 0x101 + s10ru := uint32(src.Pix[s10i+0]) * s10au / 0xff + s10gu := uint32(src.Pix[s10i+1]) * s10au / 0xff + s10bu := uint32(src.Pix[s10i+2]) * s10au / 0xff + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 + s01au := uint32(src.Pix[s01i+3]) * 0x101 + s01ru := uint32(src.Pix[s01i+0]) * s01au / 0xff + s01gu := uint32(src.Pix[s01i+1]) * s01au / 0xff + s01bu := uint32(src.Pix[s01i+2]) * s01au / 0xff + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 + s11au := uint32(src.Pix[s11i+3]) * 0x101 + s11ru := uint32(src.Pix[s11i+0]) * s11au / 0xff + s11gu := uint32(src.Pix[s11i+1]) * s11au / 0xff + s11bu := uint32(src.Pix[s11i+2]) * s11au / 0xff + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (ablInterpolator) scale_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 + s00au := uint32(src.Pix[s00i+3]) * 0x101 + s00ru := uint32(src.Pix[s00i+0]) * s00au / 0xff + s00gu := uint32(src.Pix[s00i+1]) * s00au / 0xff + s00bu := uint32(src.Pix[s00i+2]) * s00au / 0xff + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 + s10au := uint32(src.Pix[s10i+3]) * 0x101 + s10ru := uint32(src.Pix[s10i+0]) * s10au / 0xff + s10gu := uint32(src.Pix[s10i+1]) * s10au / 0xff + s10bu := uint32(src.Pix[s10i+2]) * s10au / 0xff + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 + s01au := uint32(src.Pix[s01i+3]) * 0x101 + s01ru := uint32(src.Pix[s01i+0]) * s01au / 0xff + s01gu := uint32(src.Pix[s01i+1]) * s01au / 0xff + s01bu := uint32(src.Pix[s01i+2]) * s01au / 0xff + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 + s11au := uint32(src.Pix[s11i+3]) * 0x101 + s11ru := uint32(src.Pix[s11i+0]) * s11au / 0xff + s11gu := uint32(src.Pix[s11i+1]) * s11au / 0xff + s11bu := uint32(src.Pix[s11i+2]) * s11au / 0xff + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (ablInterpolator) scale_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 + s00ru := uint32(src.Pix[s00i+0]) * 0x101 + s00gu := uint32(src.Pix[s00i+1]) * 0x101 + s00bu := uint32(src.Pix[s00i+2]) * 0x101 + s00au := uint32(src.Pix[s00i+3]) * 0x101 + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 + s10ru := uint32(src.Pix[s10i+0]) * 0x101 + s10gu := uint32(src.Pix[s10i+1]) * 0x101 + s10bu := uint32(src.Pix[s10i+2]) * 0x101 + s10au := uint32(src.Pix[s10i+3]) * 0x101 + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 + s01ru := uint32(src.Pix[s01i+0]) * 0x101 + s01gu := uint32(src.Pix[s01i+1]) * 0x101 + s01bu := uint32(src.Pix[s01i+2]) * 0x101 + s01au := uint32(src.Pix[s01i+3]) * 0x101 + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 + s11ru := uint32(src.Pix[s11i+0]) * 0x101 + s11gu := uint32(src.Pix[s11i+1]) * 0x101 + s11bu := uint32(src.Pix[s11i+2]) * 0x101 + s11au := uint32(src.Pix[s11i+3]) * 0x101 + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (ablInterpolator) scale_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 + s00ru := uint32(src.Pix[s00i+0]) * 0x101 + s00gu := uint32(src.Pix[s00i+1]) * 0x101 + s00bu := uint32(src.Pix[s00i+2]) * 0x101 + s00au := uint32(src.Pix[s00i+3]) * 0x101 + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 + s10ru := uint32(src.Pix[s10i+0]) * 0x101 + s10gu := uint32(src.Pix[s10i+1]) * 0x101 + s10bu := uint32(src.Pix[s10i+2]) * 0x101 + s10au := uint32(src.Pix[s10i+3]) * 0x101 + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 + s01ru := uint32(src.Pix[s01i+0]) * 0x101 + s01gu := uint32(src.Pix[s01i+1]) * 0x101 + s01bu := uint32(src.Pix[s01i+2]) * 0x101 + s01au := uint32(src.Pix[s01i+3]) * 0x101 + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 + s11ru := uint32(src.Pix[s11i+0]) * 0x101 + s11gu := uint32(src.Pix[s11i+1]) * 0x101 + s11bu := uint32(src.Pix[s11i+2]) * 0x101 + s11au := uint32(src.Pix[s11i+3]) * 0x101 + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (ablInterpolator) scale_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + s00j := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s00yy1 := int(src.Y[s00i]) * 0x10100 + s00cb1 := int(src.Cb[s00j]) - 128 + s00cr1 := int(src.Cr[s00j]) - 128 + s00ru := (s00yy1 + 91881*s00cr1) >> 8 + s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 + s00bu := (s00yy1 + 116130*s00cb1) >> 8 + if s00ru < 0 { + s00ru = 0 + } else if s00ru > 0xffff { + s00ru = 0xffff + } + if s00gu < 0 { + s00gu = 0 + } else if s00gu > 0xffff { + s00gu = 0xffff + } + if s00bu < 0 { + s00bu = 0 + } else if s00bu > 0xffff { + s00bu = 0xffff + } + + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + s10j := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s10yy1 := int(src.Y[s10i]) * 0x10100 + s10cb1 := int(src.Cb[s10j]) - 128 + s10cr1 := int(src.Cr[s10j]) - 128 + s10ru := (s10yy1 + 91881*s10cr1) >> 8 + s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 + s10bu := (s10yy1 + 116130*s10cb1) >> 8 + if s10ru < 0 { + s10ru = 0 + } else if s10ru > 0xffff { + s10ru = 0xffff + } + if s10gu < 0 { + s10gu = 0 + } else if s10gu > 0xffff { + s10gu = 0xffff + } + if s10bu < 0 { + s10bu = 0 + } else if s10bu > 0xffff { + s10bu = 0xffff + } + + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + s01j := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s01yy1 := int(src.Y[s01i]) * 0x10100 + s01cb1 := int(src.Cb[s01j]) - 128 + s01cr1 := int(src.Cr[s01j]) - 128 + s01ru := (s01yy1 + 91881*s01cr1) >> 8 + s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 + s01bu := (s01yy1 + 116130*s01cb1) >> 8 + if s01ru < 0 { + s01ru = 0 + } else if s01ru > 0xffff { + s01ru = 0xffff + } + if s01gu < 0 { + s01gu = 0 + } else if s01gu > 0xffff { + s01gu = 0xffff + } + if s01bu < 0 { + s01bu = 0 + } else if s01bu > 0xffff { + s01bu = 0xffff + } + + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + s11j := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s11yy1 := int(src.Y[s11i]) * 0x10100 + s11cb1 := int(src.Cb[s11j]) - 128 + s11cr1 := int(src.Cr[s11j]) - 128 + s11ru := (s11yy1 + 91881*s11cr1) >> 8 + s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 + s11bu := (s11yy1 + 116130*s11cb1) >> 8 + if s11ru < 0 { + s11ru = 0 + } else if s11ru > 0xffff { + s11ru = 0xffff + } + if s11gu < 0 { + s11gu = 0 + } else if s11gu > 0xffff { + s11gu = 0xffff + } + if s11bu < 0 { + s11bu = 0 + } else if s11bu > 0xffff { + s11bu = 0xffff + } + + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (ablInterpolator) scale_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + s00j := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(sx0))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s00yy1 := int(src.Y[s00i]) * 0x10100 + s00cb1 := int(src.Cb[s00j]) - 128 + s00cr1 := int(src.Cr[s00j]) - 128 + s00ru := (s00yy1 + 91881*s00cr1) >> 8 + s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 + s00bu := (s00yy1 + 116130*s00cb1) >> 8 + if s00ru < 0 { + s00ru = 0 + } else if s00ru > 0xffff { + s00ru = 0xffff + } + if s00gu < 0 { + s00gu = 0 + } else if s00gu > 0xffff { + s00gu = 0xffff + } + if s00bu < 0 { + s00bu = 0 + } else if s00bu > 0xffff { + s00bu = 0xffff + } + + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + s10j := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(sx1))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s10yy1 := int(src.Y[s10i]) * 0x10100 + s10cb1 := int(src.Cb[s10j]) - 128 + s10cr1 := int(src.Cr[s10j]) - 128 + s10ru := (s10yy1 + 91881*s10cr1) >> 8 + s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 + s10bu := (s10yy1 + 116130*s10cb1) >> 8 + if s10ru < 0 { + s10ru = 0 + } else if s10ru > 0xffff { + s10ru = 0xffff + } + if s10gu < 0 { + s10gu = 0 + } else if s10gu > 0xffff { + s10gu = 0xffff + } + if s10bu < 0 { + s10bu = 0 + } else if s10bu > 0xffff { + s10bu = 0xffff + } + + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + s01j := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(sx0))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s01yy1 := int(src.Y[s01i]) * 0x10100 + s01cb1 := int(src.Cb[s01j]) - 128 + s01cr1 := int(src.Cr[s01j]) - 128 + s01ru := (s01yy1 + 91881*s01cr1) >> 8 + s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 + s01bu := (s01yy1 + 116130*s01cb1) >> 8 + if s01ru < 0 { + s01ru = 0 + } else if s01ru > 0xffff { + s01ru = 0xffff + } + if s01gu < 0 { + s01gu = 0 + } else if s01gu > 0xffff { + s01gu = 0xffff + } + if s01bu < 0 { + s01bu = 0 + } else if s01bu > 0xffff { + s01bu = 0xffff + } + + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + s11j := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(sx1))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s11yy1 := int(src.Y[s11i]) * 0x10100 + s11cb1 := int(src.Cb[s11j]) - 128 + s11cr1 := int(src.Cr[s11j]) - 128 + s11ru := (s11yy1 + 91881*s11cr1) >> 8 + s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 + s11bu := (s11yy1 + 116130*s11cb1) >> 8 + if s11ru < 0 { + s11ru = 0 + } else if s11ru > 0xffff { + s11ru = 0xffff + } + if s11gu < 0 { + s11gu = 0 + } else if s11gu > 0xffff { + s11gu = 0xffff + } + if s11bu < 0 { + s11bu = 0 + } else if s11bu > 0xffff { + s11bu = 0xffff + } + + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (ablInterpolator) scale_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + s00j := ((sr.Min.Y+int(sy0))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(sx0))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s00yy1 := int(src.Y[s00i]) * 0x10100 + s00cb1 := int(src.Cb[s00j]) - 128 + s00cr1 := int(src.Cr[s00j]) - 128 + s00ru := (s00yy1 + 91881*s00cr1) >> 8 + s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 + s00bu := (s00yy1 + 116130*s00cb1) >> 8 + if s00ru < 0 { + s00ru = 0 + } else if s00ru > 0xffff { + s00ru = 0xffff + } + if s00gu < 0 { + s00gu = 0 + } else if s00gu > 0xffff { + s00gu = 0xffff + } + if s00bu < 0 { + s00bu = 0 + } else if s00bu > 0xffff { + s00bu = 0xffff + } + + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + s10j := ((sr.Min.Y+int(sy0))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(sx1))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s10yy1 := int(src.Y[s10i]) * 0x10100 + s10cb1 := int(src.Cb[s10j]) - 128 + s10cr1 := int(src.Cr[s10j]) - 128 + s10ru := (s10yy1 + 91881*s10cr1) >> 8 + s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 + s10bu := (s10yy1 + 116130*s10cb1) >> 8 + if s10ru < 0 { + s10ru = 0 + } else if s10ru > 0xffff { + s10ru = 0xffff + } + if s10gu < 0 { + s10gu = 0 + } else if s10gu > 0xffff { + s10gu = 0xffff + } + if s10bu < 0 { + s10bu = 0 + } else if s10bu > 0xffff { + s10bu = 0xffff + } + + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + s01j := ((sr.Min.Y+int(sy1))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(sx0))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s01yy1 := int(src.Y[s01i]) * 0x10100 + s01cb1 := int(src.Cb[s01j]) - 128 + s01cr1 := int(src.Cr[s01j]) - 128 + s01ru := (s01yy1 + 91881*s01cr1) >> 8 + s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 + s01bu := (s01yy1 + 116130*s01cb1) >> 8 + if s01ru < 0 { + s01ru = 0 + } else if s01ru > 0xffff { + s01ru = 0xffff + } + if s01gu < 0 { + s01gu = 0 + } else if s01gu > 0xffff { + s01gu = 0xffff + } + if s01bu < 0 { + s01bu = 0 + } else if s01bu > 0xffff { + s01bu = 0xffff + } + + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + s11j := ((sr.Min.Y+int(sy1))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(sx1))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s11yy1 := int(src.Y[s11i]) * 0x10100 + s11cb1 := int(src.Cb[s11j]) - 128 + s11cr1 := int(src.Cr[s11j]) - 128 + s11ru := (s11yy1 + 91881*s11cr1) >> 8 + s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 + s11bu := (s11yy1 + 116130*s11cb1) >> 8 + if s11ru < 0 { + s11ru = 0 + } else if s11ru > 0xffff { + s11ru = 0xffff + } + if s11gu < 0 { + s11gu = 0 + } else if s11gu > 0xffff { + s11gu = 0xffff + } + if s11bu < 0 { + s11bu = 0 + } else if s11bu > 0xffff { + s11bu = 0xffff + } + + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (ablInterpolator) scale_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + s00j := ((sr.Min.Y+int(sy0))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s00yy1 := int(src.Y[s00i]) * 0x10100 + s00cb1 := int(src.Cb[s00j]) - 128 + s00cr1 := int(src.Cr[s00j]) - 128 + s00ru := (s00yy1 + 91881*s00cr1) >> 8 + s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 + s00bu := (s00yy1 + 116130*s00cb1) >> 8 + if s00ru < 0 { + s00ru = 0 + } else if s00ru > 0xffff { + s00ru = 0xffff + } + if s00gu < 0 { + s00gu = 0 + } else if s00gu > 0xffff { + s00gu = 0xffff + } + if s00bu < 0 { + s00bu = 0 + } else if s00bu > 0xffff { + s00bu = 0xffff + } + + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + s10j := ((sr.Min.Y+int(sy0))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s10yy1 := int(src.Y[s10i]) * 0x10100 + s10cb1 := int(src.Cb[s10j]) - 128 + s10cr1 := int(src.Cr[s10j]) - 128 + s10ru := (s10yy1 + 91881*s10cr1) >> 8 + s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 + s10bu := (s10yy1 + 116130*s10cb1) >> 8 + if s10ru < 0 { + s10ru = 0 + } else if s10ru > 0xffff { + s10ru = 0xffff + } + if s10gu < 0 { + s10gu = 0 + } else if s10gu > 0xffff { + s10gu = 0xffff + } + if s10bu < 0 { + s10bu = 0 + } else if s10bu > 0xffff { + s10bu = 0xffff + } + + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + s01j := ((sr.Min.Y+int(sy1))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s01yy1 := int(src.Y[s01i]) * 0x10100 + s01cb1 := int(src.Cb[s01j]) - 128 + s01cr1 := int(src.Cr[s01j]) - 128 + s01ru := (s01yy1 + 91881*s01cr1) >> 8 + s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 + s01bu := (s01yy1 + 116130*s01cb1) >> 8 + if s01ru < 0 { + s01ru = 0 + } else if s01ru > 0xffff { + s01ru = 0xffff + } + if s01gu < 0 { + s01gu = 0 + } else if s01gu > 0xffff { + s01gu = 0xffff + } + if s01bu < 0 { + s01bu = 0 + } else if s01bu > 0xffff { + s01bu = 0xffff + } + + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + s11j := ((sr.Min.Y+int(sy1))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s11yy1 := int(src.Y[s11i]) * 0x10100 + s11cb1 := int(src.Cb[s11j]) - 128 + s11cr1 := int(src.Cr[s11j]) - 128 + s11ru := (s11yy1 + 91881*s11cr1) >> 8 + s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 + s11bu := (s11yy1 + 116130*s11cb1) >> 8 + if s11ru < 0 { + s11ru = 0 + } else if s11ru > 0xffff { + s11ru = 0xffff + } + if s11gu < 0 { + s11gu = 0 + } else if s11gu > 0xffff { + s11gu = 0xffff + } + if s11bu < 0 { + s11bu = 0 + } else if s11bu > 0xffff { + s11bu = 0xffff + } + + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (ablInterpolator) scale_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (ablInterpolator) scale_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (ablInterpolator) scale_Image_Image_Over(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + srcMask, smp := opts.SrcMask, opts.SrcMaskP + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx0), smp.Y+sr.Min.Y+int(sy0)).RGBA() + s00ru = s00ru * ma / 0xffff + s00gu = s00gu * ma / 0xffff + s00bu = s00bu * ma / 0xffff + s00au = s00au * ma / 0xffff + } + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx1), smp.Y+sr.Min.Y+int(sy0)).RGBA() + s10ru = s10ru * ma / 0xffff + s10gu = s10gu * ma / 0xffff + s10bu = s10bu * ma / 0xffff + s10au = s10au * ma / 0xffff + } + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx0), smp.Y+sr.Min.Y+int(sy1)).RGBA() + s01ru = s01ru * ma / 0xffff + s01gu = s01gu * ma / 0xffff + s01bu = s01bu * ma / 0xffff + s01au = s01au * ma / 0xffff + } + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx1), smp.Y+sr.Min.Y+int(sy1)).RGBA() + s11ru = s11ru * ma / 0xffff + s11gu = s11gu * ma / 0xffff + s11bu = s11bu * ma / 0xffff + s11au = s11au * ma / 0xffff + } + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + if dstMask != nil { + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + } + pa1 := 0xffff - pa + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } +} + +func (ablInterpolator) scale_Image_Image_Src(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) + swMinus1, shMinus1 := sw-1, sh-1 + srcMask, smp := opts.SrcMask, opts.SrcMaskP + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + sy := (float64(dy)+0.5)*yscale - 0.5 + // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if + // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for + // sx, below. + sy0 := int32(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy1 := sy0 + 1 + if sy < 0 { + sy0, sy1 = 0, 0 + yFrac0, yFrac1 = 0, 1 + } else if sy1 > shMinus1 { + sy0, sy1 = shMinus1, shMinus1 + yFrac0, yFrac1 = 1, 0 + } + + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + sx := (float64(dx)+0.5)*xscale - 0.5 + sx0 := int32(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx1 := sx0 + 1 + if sx < 0 { + sx0, sx1 = 0, 0 + xFrac0, xFrac1 = 0, 1 + } else if sx1 > swMinus1 { + sx0, sx1 = swMinus1, swMinus1 + xFrac0, xFrac1 = 1, 0 + } + + s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx0), smp.Y+sr.Min.Y+int(sy0)).RGBA() + s00ru = s00ru * ma / 0xffff + s00gu = s00gu * ma / 0xffff + s00bu = s00bu * ma / 0xffff + s00au = s00au * ma / 0xffff + } + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx1), smp.Y+sr.Min.Y+int(sy0)).RGBA() + s10ru = s10ru * ma / 0xffff + s10gu = s10gu * ma / 0xffff + s10bu = s10bu * ma / 0xffff + s10au = s10au * ma / 0xffff + } + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx0), smp.Y+sr.Min.Y+int(sy1)).RGBA() + s01ru = s01ru * ma / 0xffff + s01gu = s01gu * ma / 0xffff + s01bu = s01bu * ma / 0xffff + s01au = s01au * ma / 0xffff + } + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx1), smp.Y+sr.Min.Y+int(sy1)).RGBA() + s11ru = s11ru * ma / 0xffff + s11gu = s11gu * ma / 0xffff + s11bu = s11bu * ma / 0xffff + s11au = s11au * ma / 0xffff + } + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + if dstMask != nil { + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + pa1 := 0xffff - ma + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } else { + dstColorRGBA64.R = uint16(pr) + dstColorRGBA64.G = uint16(pg) + dstColorRGBA64.B = uint16(pb) + dstColorRGBA64.A = uint16(pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } + } +} + +func (ablInterpolator) transform_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00i := (sy0-src.Rect.Min.Y)*src.Stride + (sx0 - src.Rect.Min.X) + s00ru := uint32(src.Pix[s00i]) * 0x101 + s00r := float64(s00ru) + s10i := (sy0-src.Rect.Min.Y)*src.Stride + (sx1 - src.Rect.Min.X) + s10ru := uint32(src.Pix[s10i]) * 0x101 + s10r := float64(s10ru) + s10r = xFrac1*s00r + xFrac0*s10r + s01i := (sy1-src.Rect.Min.Y)*src.Stride + (sx0 - src.Rect.Min.X) + s01ru := uint32(src.Pix[s01i]) * 0x101 + s01r := float64(s01ru) + s11i := (sy1-src.Rect.Min.Y)*src.Stride + (sx1 - src.Rect.Min.X) + s11ru := uint32(src.Pix[s11i]) * 0x101 + s11r := float64(s11ru) + s11r = xFrac1*s01r + xFrac0*s11r + s11r = yFrac1*s10r + yFrac0*s11r + pr := uint32(s11r) + out := uint8(pr >> 8) + dst.Pix[d+0] = out + dst.Pix[d+1] = out + dst.Pix[d+2] = out + dst.Pix[d+3] = 0xff + } + } +} + +func (ablInterpolator) transform_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00i := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + s00au := uint32(src.Pix[s00i+3]) * 0x101 + s00ru := uint32(src.Pix[s00i+0]) * s00au / 0xff + s00gu := uint32(src.Pix[s00i+1]) * s00au / 0xff + s00bu := uint32(src.Pix[s00i+2]) * s00au / 0xff + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10i := (sy0-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 + s10au := uint32(src.Pix[s10i+3]) * 0x101 + s10ru := uint32(src.Pix[s10i+0]) * s10au / 0xff + s10gu := uint32(src.Pix[s10i+1]) * s10au / 0xff + s10bu := uint32(src.Pix[s10i+2]) * s10au / 0xff + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01i := (sy1-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + s01au := uint32(src.Pix[s01i+3]) * 0x101 + s01ru := uint32(src.Pix[s01i+0]) * s01au / 0xff + s01gu := uint32(src.Pix[s01i+1]) * s01au / 0xff + s01bu := uint32(src.Pix[s01i+2]) * s01au / 0xff + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11i := (sy1-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 + s11au := uint32(src.Pix[s11i+3]) * 0x101 + s11ru := uint32(src.Pix[s11i+0]) * s11au / 0xff + s11gu := uint32(src.Pix[s11i+1]) * s11au / 0xff + s11bu := uint32(src.Pix[s11i+2]) * s11au / 0xff + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (ablInterpolator) transform_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00i := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + s00au := uint32(src.Pix[s00i+3]) * 0x101 + s00ru := uint32(src.Pix[s00i+0]) * s00au / 0xff + s00gu := uint32(src.Pix[s00i+1]) * s00au / 0xff + s00bu := uint32(src.Pix[s00i+2]) * s00au / 0xff + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10i := (sy0-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 + s10au := uint32(src.Pix[s10i+3]) * 0x101 + s10ru := uint32(src.Pix[s10i+0]) * s10au / 0xff + s10gu := uint32(src.Pix[s10i+1]) * s10au / 0xff + s10bu := uint32(src.Pix[s10i+2]) * s10au / 0xff + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01i := (sy1-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + s01au := uint32(src.Pix[s01i+3]) * 0x101 + s01ru := uint32(src.Pix[s01i+0]) * s01au / 0xff + s01gu := uint32(src.Pix[s01i+1]) * s01au / 0xff + s01bu := uint32(src.Pix[s01i+2]) * s01au / 0xff + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11i := (sy1-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 + s11au := uint32(src.Pix[s11i+3]) * 0x101 + s11ru := uint32(src.Pix[s11i+0]) * s11au / 0xff + s11gu := uint32(src.Pix[s11i+1]) * s11au / 0xff + s11bu := uint32(src.Pix[s11i+2]) * s11au / 0xff + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (ablInterpolator) transform_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00i := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + s00ru := uint32(src.Pix[s00i+0]) * 0x101 + s00gu := uint32(src.Pix[s00i+1]) * 0x101 + s00bu := uint32(src.Pix[s00i+2]) * 0x101 + s00au := uint32(src.Pix[s00i+3]) * 0x101 + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10i := (sy0-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 + s10ru := uint32(src.Pix[s10i+0]) * 0x101 + s10gu := uint32(src.Pix[s10i+1]) * 0x101 + s10bu := uint32(src.Pix[s10i+2]) * 0x101 + s10au := uint32(src.Pix[s10i+3]) * 0x101 + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01i := (sy1-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + s01ru := uint32(src.Pix[s01i+0]) * 0x101 + s01gu := uint32(src.Pix[s01i+1]) * 0x101 + s01bu := uint32(src.Pix[s01i+2]) * 0x101 + s01au := uint32(src.Pix[s01i+3]) * 0x101 + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11i := (sy1-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 + s11ru := uint32(src.Pix[s11i+0]) * 0x101 + s11gu := uint32(src.Pix[s11i+1]) * 0x101 + s11bu := uint32(src.Pix[s11i+2]) * 0x101 + s11au := uint32(src.Pix[s11i+3]) * 0x101 + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (ablInterpolator) transform_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00i := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + s00ru := uint32(src.Pix[s00i+0]) * 0x101 + s00gu := uint32(src.Pix[s00i+1]) * 0x101 + s00bu := uint32(src.Pix[s00i+2]) * 0x101 + s00au := uint32(src.Pix[s00i+3]) * 0x101 + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10i := (sy0-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 + s10ru := uint32(src.Pix[s10i+0]) * 0x101 + s10gu := uint32(src.Pix[s10i+1]) * 0x101 + s10bu := uint32(src.Pix[s10i+2]) * 0x101 + s10au := uint32(src.Pix[s10i+3]) * 0x101 + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01i := (sy1-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 + s01ru := uint32(src.Pix[s01i+0]) * 0x101 + s01gu := uint32(src.Pix[s01i+1]) * 0x101 + s01bu := uint32(src.Pix[s01i+2]) * 0x101 + s01au := uint32(src.Pix[s01i+3]) * 0x101 + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11i := (sy1-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 + s11ru := uint32(src.Pix[s11i+0]) * 0x101 + s11gu := uint32(src.Pix[s11i+1]) * 0x101 + s11bu := uint32(src.Pix[s11i+2]) * 0x101 + s11au := uint32(src.Pix[s11i+3]) * 0x101 + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (ablInterpolator) transform_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00i := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + s00j := (sy0-src.Rect.Min.Y)*src.CStride + (sx0 - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s00yy1 := int(src.Y[s00i]) * 0x10100 + s00cb1 := int(src.Cb[s00j]) - 128 + s00cr1 := int(src.Cr[s00j]) - 128 + s00ru := (s00yy1 + 91881*s00cr1) >> 8 + s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 + s00bu := (s00yy1 + 116130*s00cb1) >> 8 + if s00ru < 0 { + s00ru = 0 + } else if s00ru > 0xffff { + s00ru = 0xffff + } + if s00gu < 0 { + s00gu = 0 + } else if s00gu > 0xffff { + s00gu = 0xffff + } + if s00bu < 0 { + s00bu = 0 + } else if s00bu > 0xffff { + s00bu = 0xffff + } + + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s10i := (sy0-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) + s10j := (sy0-src.Rect.Min.Y)*src.CStride + (sx1 - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s10yy1 := int(src.Y[s10i]) * 0x10100 + s10cb1 := int(src.Cb[s10j]) - 128 + s10cr1 := int(src.Cr[s10j]) - 128 + s10ru := (s10yy1 + 91881*s10cr1) >> 8 + s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 + s10bu := (s10yy1 + 116130*s10cb1) >> 8 + if s10ru < 0 { + s10ru = 0 + } else if s10ru > 0xffff { + s10ru = 0xffff + } + if s10gu < 0 { + s10gu = 0 + } else if s10gu > 0xffff { + s10gu = 0xffff + } + if s10bu < 0 { + s10bu = 0 + } else if s10bu > 0xffff { + s10bu = 0xffff + } + + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s01i := (sy1-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + s01j := (sy1-src.Rect.Min.Y)*src.CStride + (sx0 - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s01yy1 := int(src.Y[s01i]) * 0x10100 + s01cb1 := int(src.Cb[s01j]) - 128 + s01cr1 := int(src.Cr[s01j]) - 128 + s01ru := (s01yy1 + 91881*s01cr1) >> 8 + s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 + s01bu := (s01yy1 + 116130*s01cb1) >> 8 + if s01ru < 0 { + s01ru = 0 + } else if s01ru > 0xffff { + s01ru = 0xffff + } + if s01gu < 0 { + s01gu = 0 + } else if s01gu > 0xffff { + s01gu = 0xffff + } + if s01bu < 0 { + s01bu = 0 + } else if s01bu > 0xffff { + s01bu = 0xffff + } + + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s11i := (sy1-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) + s11j := (sy1-src.Rect.Min.Y)*src.CStride + (sx1 - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s11yy1 := int(src.Y[s11i]) * 0x10100 + s11cb1 := int(src.Cb[s11j]) - 128 + s11cr1 := int(src.Cr[s11j]) - 128 + s11ru := (s11yy1 + 91881*s11cr1) >> 8 + s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 + s11bu := (s11yy1 + 116130*s11cb1) >> 8 + if s11ru < 0 { + s11ru = 0 + } else if s11ru > 0xffff { + s11ru = 0xffff + } + if s11gu < 0 { + s11gu = 0 + } else if s11gu > 0xffff { + s11gu = 0xffff + } + if s11bu < 0 { + s11bu = 0 + } else if s11bu > 0xffff { + s11bu = 0xffff + } + + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (ablInterpolator) transform_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00i := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + s00j := (sy0-src.Rect.Min.Y)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s00yy1 := int(src.Y[s00i]) * 0x10100 + s00cb1 := int(src.Cb[s00j]) - 128 + s00cr1 := int(src.Cr[s00j]) - 128 + s00ru := (s00yy1 + 91881*s00cr1) >> 8 + s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 + s00bu := (s00yy1 + 116130*s00cb1) >> 8 + if s00ru < 0 { + s00ru = 0 + } else if s00ru > 0xffff { + s00ru = 0xffff + } + if s00gu < 0 { + s00gu = 0 + } else if s00gu > 0xffff { + s00gu = 0xffff + } + if s00bu < 0 { + s00bu = 0 + } else if s00bu > 0xffff { + s00bu = 0xffff + } + + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s10i := (sy0-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) + s10j := (sy0-src.Rect.Min.Y)*src.CStride + ((sx1)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s10yy1 := int(src.Y[s10i]) * 0x10100 + s10cb1 := int(src.Cb[s10j]) - 128 + s10cr1 := int(src.Cr[s10j]) - 128 + s10ru := (s10yy1 + 91881*s10cr1) >> 8 + s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 + s10bu := (s10yy1 + 116130*s10cb1) >> 8 + if s10ru < 0 { + s10ru = 0 + } else if s10ru > 0xffff { + s10ru = 0xffff + } + if s10gu < 0 { + s10gu = 0 + } else if s10gu > 0xffff { + s10gu = 0xffff + } + if s10bu < 0 { + s10bu = 0 + } else if s10bu > 0xffff { + s10bu = 0xffff + } + + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s01i := (sy1-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + s01j := (sy1-src.Rect.Min.Y)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s01yy1 := int(src.Y[s01i]) * 0x10100 + s01cb1 := int(src.Cb[s01j]) - 128 + s01cr1 := int(src.Cr[s01j]) - 128 + s01ru := (s01yy1 + 91881*s01cr1) >> 8 + s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 + s01bu := (s01yy1 + 116130*s01cb1) >> 8 + if s01ru < 0 { + s01ru = 0 + } else if s01ru > 0xffff { + s01ru = 0xffff + } + if s01gu < 0 { + s01gu = 0 + } else if s01gu > 0xffff { + s01gu = 0xffff + } + if s01bu < 0 { + s01bu = 0 + } else if s01bu > 0xffff { + s01bu = 0xffff + } + + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s11i := (sy1-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) + s11j := (sy1-src.Rect.Min.Y)*src.CStride + ((sx1)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s11yy1 := int(src.Y[s11i]) * 0x10100 + s11cb1 := int(src.Cb[s11j]) - 128 + s11cr1 := int(src.Cr[s11j]) - 128 + s11ru := (s11yy1 + 91881*s11cr1) >> 8 + s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 + s11bu := (s11yy1 + 116130*s11cb1) >> 8 + if s11ru < 0 { + s11ru = 0 + } else if s11ru > 0xffff { + s11ru = 0xffff + } + if s11gu < 0 { + s11gu = 0 + } else if s11gu > 0xffff { + s11gu = 0xffff + } + if s11bu < 0 { + s11bu = 0 + } else if s11bu > 0xffff { + s11bu = 0xffff + } + + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (ablInterpolator) transform_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00i := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + s00j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s00yy1 := int(src.Y[s00i]) * 0x10100 + s00cb1 := int(src.Cb[s00j]) - 128 + s00cr1 := int(src.Cr[s00j]) - 128 + s00ru := (s00yy1 + 91881*s00cr1) >> 8 + s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 + s00bu := (s00yy1 + 116130*s00cb1) >> 8 + if s00ru < 0 { + s00ru = 0 + } else if s00ru > 0xffff { + s00ru = 0xffff + } + if s00gu < 0 { + s00gu = 0 + } else if s00gu > 0xffff { + s00gu = 0xffff + } + if s00bu < 0 { + s00bu = 0 + } else if s00bu > 0xffff { + s00bu = 0xffff + } + + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s10i := (sy0-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) + s10j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + ((sx1)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s10yy1 := int(src.Y[s10i]) * 0x10100 + s10cb1 := int(src.Cb[s10j]) - 128 + s10cr1 := int(src.Cr[s10j]) - 128 + s10ru := (s10yy1 + 91881*s10cr1) >> 8 + s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 + s10bu := (s10yy1 + 116130*s10cb1) >> 8 + if s10ru < 0 { + s10ru = 0 + } else if s10ru > 0xffff { + s10ru = 0xffff + } + if s10gu < 0 { + s10gu = 0 + } else if s10gu > 0xffff { + s10gu = 0xffff + } + if s10bu < 0 { + s10bu = 0 + } else if s10bu > 0xffff { + s10bu = 0xffff + } + + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s01i := (sy1-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + s01j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s01yy1 := int(src.Y[s01i]) * 0x10100 + s01cb1 := int(src.Cb[s01j]) - 128 + s01cr1 := int(src.Cr[s01j]) - 128 + s01ru := (s01yy1 + 91881*s01cr1) >> 8 + s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 + s01bu := (s01yy1 + 116130*s01cb1) >> 8 + if s01ru < 0 { + s01ru = 0 + } else if s01ru > 0xffff { + s01ru = 0xffff + } + if s01gu < 0 { + s01gu = 0 + } else if s01gu > 0xffff { + s01gu = 0xffff + } + if s01bu < 0 { + s01bu = 0 + } else if s01bu > 0xffff { + s01bu = 0xffff + } + + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s11i := (sy1-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) + s11j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + ((sx1)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s11yy1 := int(src.Y[s11i]) * 0x10100 + s11cb1 := int(src.Cb[s11j]) - 128 + s11cr1 := int(src.Cr[s11j]) - 128 + s11ru := (s11yy1 + 91881*s11cr1) >> 8 + s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 + s11bu := (s11yy1 + 116130*s11cb1) >> 8 + if s11ru < 0 { + s11ru = 0 + } else if s11ru > 0xffff { + s11ru = 0xffff + } + if s11gu < 0 { + s11gu = 0 + } else if s11gu > 0xffff { + s11gu = 0xffff + } + if s11bu < 0 { + s11bu = 0 + } else if s11bu > 0xffff { + s11bu = 0xffff + } + + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (ablInterpolator) transform_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00i := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + s00j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + (sx0 - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s00yy1 := int(src.Y[s00i]) * 0x10100 + s00cb1 := int(src.Cb[s00j]) - 128 + s00cr1 := int(src.Cr[s00j]) - 128 + s00ru := (s00yy1 + 91881*s00cr1) >> 8 + s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 + s00bu := (s00yy1 + 116130*s00cb1) >> 8 + if s00ru < 0 { + s00ru = 0 + } else if s00ru > 0xffff { + s00ru = 0xffff + } + if s00gu < 0 { + s00gu = 0 + } else if s00gu > 0xffff { + s00gu = 0xffff + } + if s00bu < 0 { + s00bu = 0 + } else if s00bu > 0xffff { + s00bu = 0xffff + } + + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s10i := (sy0-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) + s10j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + (sx1 - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s10yy1 := int(src.Y[s10i]) * 0x10100 + s10cb1 := int(src.Cb[s10j]) - 128 + s10cr1 := int(src.Cr[s10j]) - 128 + s10ru := (s10yy1 + 91881*s10cr1) >> 8 + s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 + s10bu := (s10yy1 + 116130*s10cb1) >> 8 + if s10ru < 0 { + s10ru = 0 + } else if s10ru > 0xffff { + s10ru = 0xffff + } + if s10gu < 0 { + s10gu = 0 + } else if s10gu > 0xffff { + s10gu = 0xffff + } + if s10bu < 0 { + s10bu = 0 + } else if s10bu > 0xffff { + s10bu = 0xffff + } + + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s01i := (sy1-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) + s01j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + (sx0 - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s01yy1 := int(src.Y[s01i]) * 0x10100 + s01cb1 := int(src.Cb[s01j]) - 128 + s01cr1 := int(src.Cr[s01j]) - 128 + s01ru := (s01yy1 + 91881*s01cr1) >> 8 + s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 + s01bu := (s01yy1 + 116130*s01cb1) >> 8 + if s01ru < 0 { + s01ru = 0 + } else if s01ru > 0xffff { + s01ru = 0xffff + } + if s01gu < 0 { + s01gu = 0 + } else if s01gu > 0xffff { + s01gu = 0xffff + } + if s01bu < 0 { + s01bu = 0 + } else if s01bu > 0xffff { + s01bu = 0xffff + } + + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s11i := (sy1-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) + s11j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + (sx1 - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + s11yy1 := int(src.Y[s11i]) * 0x10100 + s11cb1 := int(src.Cb[s11j]) - 128 + s11cr1 := int(src.Cr[s11j]) - 128 + s11ru := (s11yy1 + 91881*s11cr1) >> 8 + s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 + s11bu := (s11yy1 + 116130*s11cb1) >> 8 + if s11ru < 0 { + s11ru = 0 + } else if s11ru > 0xffff { + s11ru = 0xffff + } + if s11gu < 0 { + s11gu = 0 + } else if s11gu > 0xffff { + s11gu = 0xffff + } + if s11bu < 0 { + s11bu = 0 + } else if s11bu > 0xffff { + s11bu = 0xffff + } + + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (ablInterpolator) transform_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA() + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA() + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA() + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA() + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + pa1 := (0xffff - pa) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } +} + +func (ablInterpolator) transform_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA() + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA() + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA() + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA() + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + dst.Pix[d+0] = uint8(pr >> 8) + dst.Pix[d+1] = uint8(pg >> 8) + dst.Pix[d+2] = uint8(pb >> 8) + dst.Pix[d+3] = uint8(pa >> 8) + } + } +} + +func (ablInterpolator) transform_Image_Image_Over(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { + srcMask, smp := opts.SrcMask, opts.SrcMaskP + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy0).RGBA() + s00ru = s00ru * ma / 0xffff + s00gu = s00gu * ma / 0xffff + s00bu = s00bu * ma / 0xffff + s00au = s00au * ma / 0xffff + } + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sx1, smp.Y+sy0).RGBA() + s10ru = s10ru * ma / 0xffff + s10gu = s10gu * ma / 0xffff + s10bu = s10bu * ma / 0xffff + s10au = s10au * ma / 0xffff + } + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy1).RGBA() + s01ru = s01ru * ma / 0xffff + s01gu = s01gu * ma / 0xffff + s01bu = s01bu * ma / 0xffff + s01au = s01au * ma / 0xffff + } + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sx1, smp.Y+sy1).RGBA() + s11ru = s11ru * ma / 0xffff + s11gu = s11gu * ma / 0xffff + s11bu = s11bu * ma / 0xffff + s11au = s11au * ma / 0xffff + } + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + if dstMask != nil { + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + } + pa1 := 0xffff - pa + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } +} + +func (ablInterpolator) transform_Image_Image_Src(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { + srcMask, smp := opts.SrcMask, opts.SrcMaskP + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + sx -= 0.5 + sx0 := int(sx) + xFrac0 := sx - float64(sx0) + xFrac1 := 1 - xFrac0 + sx0 += bias.X + sx1 := sx0 + 1 + if sx0 < sr.Min.X { + sx0, sx1 = sr.Min.X, sr.Min.X + xFrac0, xFrac1 = 0, 1 + } else if sx1 >= sr.Max.X { + sx0, sx1 = sr.Max.X-1, sr.Max.X-1 + xFrac0, xFrac1 = 1, 0 + } + + sy -= 0.5 + sy0 := int(sy) + yFrac0 := sy - float64(sy0) + yFrac1 := 1 - yFrac0 + sy0 += bias.Y + sy1 := sy0 + 1 + if sy0 < sr.Min.Y { + sy0, sy1 = sr.Min.Y, sr.Min.Y + yFrac0, yFrac1 = 0, 1 + } else if sy1 >= sr.Max.Y { + sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 + yFrac0, yFrac1 = 1, 0 + } + + s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy0).RGBA() + s00ru = s00ru * ma / 0xffff + s00gu = s00gu * ma / 0xffff + s00bu = s00bu * ma / 0xffff + s00au = s00au * ma / 0xffff + } + s00r := float64(s00ru) + s00g := float64(s00gu) + s00b := float64(s00bu) + s00a := float64(s00au) + s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sx1, smp.Y+sy0).RGBA() + s10ru = s10ru * ma / 0xffff + s10gu = s10gu * ma / 0xffff + s10bu = s10bu * ma / 0xffff + s10au = s10au * ma / 0xffff + } + s10r := float64(s10ru) + s10g := float64(s10gu) + s10b := float64(s10bu) + s10a := float64(s10au) + s10r = xFrac1*s00r + xFrac0*s10r + s10g = xFrac1*s00g + xFrac0*s10g + s10b = xFrac1*s00b + xFrac0*s10b + s10a = xFrac1*s00a + xFrac0*s10a + s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy1).RGBA() + s01ru = s01ru * ma / 0xffff + s01gu = s01gu * ma / 0xffff + s01bu = s01bu * ma / 0xffff + s01au = s01au * ma / 0xffff + } + s01r := float64(s01ru) + s01g := float64(s01gu) + s01b := float64(s01bu) + s01a := float64(s01au) + s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sx1, smp.Y+sy1).RGBA() + s11ru = s11ru * ma / 0xffff + s11gu = s11gu * ma / 0xffff + s11bu = s11bu * ma / 0xffff + s11au = s11au * ma / 0xffff + } + s11r := float64(s11ru) + s11g := float64(s11gu) + s11b := float64(s11bu) + s11a := float64(s11au) + s11r = xFrac1*s01r + xFrac0*s11r + s11g = xFrac1*s01g + xFrac0*s11g + s11b = xFrac1*s01b + xFrac0*s11b + s11a = xFrac1*s01a + xFrac0*s11a + s11r = yFrac1*s10r + yFrac0*s11r + s11g = yFrac1*s10g + yFrac0*s11g + s11b = yFrac1*s10b + yFrac0*s11b + s11a = yFrac1*s10a + yFrac0*s11a + pr := uint32(s11r) + pg := uint32(s11g) + pb := uint32(s11b) + pa := uint32(s11a) + if dstMask != nil { + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() + pr = pr * ma / 0xffff + pg = pg * ma / 0xffff + pb = pb * ma / 0xffff + pa = pa * ma / 0xffff + pa1 := 0xffff - ma + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } else { + dstColorRGBA64.R = uint16(pr) + dstColorRGBA64.G = uint16(pg) + dstColorRGBA64.B = uint16(pb) + dstColorRGBA64.A = uint16(pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } + } +} + +func (z *kernelScaler) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { + if z.dw != int32(dr.Dx()) || z.dh != int32(dr.Dy()) || z.sw != int32(sr.Dx()) || z.sh != int32(sr.Dy()) { + z.kernel.Scale(dst, dr, src, sr, op, opts) + return + } + + var o Options + if opts != nil { + o = *opts + } + + // adr is the affected destination pixels. + adr := dst.Bounds().Intersect(dr) + adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) + if adr.Empty() || sr.Empty() { + return + } + // Make adr relative to dr.Min. + adr = adr.Sub(dr.Min) + if op == Over && o.SrcMask == nil && opaque(src) { + op = Src + } + + if _, ok := src.(*image.Uniform); ok && o.DstMask == nil && o.SrcMask == nil && sr.In(src.Bounds()) { + Draw(dst, dr, src, src.Bounds().Min, op) + return + } + + // Create a temporary buffer: + // scaleX distributes the source image's columns over the temporary image. + // scaleY distributes the temporary image's rows over the destination image. + var tmp [][4]float64 + if z.pool.New != nil { + tmpp := z.pool.Get().(*[][4]float64) + defer z.pool.Put(tmpp) + tmp = *tmpp + } else { + tmp = z.makeTmpBuf() + } + + // sr is the source pixels. If it extends beyond the src bounds, + // we cannot use the type-specific fast paths, as they access + // the Pix fields directly without bounds checking. + // + // Similarly, the fast paths assume that the masks are nil. + if o.SrcMask != nil || !sr.In(src.Bounds()) { + z.scaleX_Image(tmp, src, sr, &o) + } else { + switch src := src.(type) { + case *image.Gray: + z.scaleX_Gray(tmp, src, sr, &o) + case *image.NRGBA: + z.scaleX_NRGBA(tmp, src, sr, &o) + case *image.RGBA: + z.scaleX_RGBA(tmp, src, sr, &o) + case *image.YCbCr: + switch src.SubsampleRatio { + default: + z.scaleX_Image(tmp, src, sr, &o) + case image.YCbCrSubsampleRatio444: + z.scaleX_YCbCr444(tmp, src, sr, &o) + case image.YCbCrSubsampleRatio422: + z.scaleX_YCbCr422(tmp, src, sr, &o) + case image.YCbCrSubsampleRatio420: + z.scaleX_YCbCr420(tmp, src, sr, &o) + case image.YCbCrSubsampleRatio440: + z.scaleX_YCbCr440(tmp, src, sr, &o) + } + default: + z.scaleX_Image(tmp, src, sr, &o) + } + } + + if o.DstMask != nil { + switch op { + case Over: + z.scaleY_Image_Over(dst, dr, adr, tmp, &o) + case Src: + z.scaleY_Image_Src(dst, dr, adr, tmp, &o) + } + } else { + switch op { + case Over: + switch dst := dst.(type) { + case *image.RGBA: + z.scaleY_RGBA_Over(dst, dr, adr, tmp, &o) + default: + z.scaleY_Image_Over(dst, dr, adr, tmp, &o) + } + case Src: + switch dst := dst.(type) { + case *image.RGBA: + z.scaleY_RGBA_Src(dst, dr, adr, tmp, &o) + default: + z.scaleY_Image_Src(dst, dr, adr, tmp, &o) + } + } + } +} + +func (q *Kernel) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) { + var o Options + if opts != nil { + o = *opts + } + + dr := transformRect(&s2d, &sr) + // adr is the affected destination pixels. + adr := dst.Bounds().Intersect(dr) + adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) + if adr.Empty() || sr.Empty() { + return + } + if op == Over && o.SrcMask == nil && opaque(src) { + op = Src + } + d2s := invert(&s2d) + // bias is a translation of the mapping from dst coordinates to src + // coordinates such that the latter temporarily have non-negative X + // and Y coordinates. This allows us to write int(f) instead of + // int(math.Floor(f)), since "round to zero" and "round down" are + // equivalent when f >= 0, but the former is much cheaper. The X-- + // and Y-- are because the TransformLeaf methods have a "sx -= 0.5" + // adjustment. + bias := transformRect(&d2s, &adr).Min + bias.X-- + bias.Y-- + d2s[2] -= float64(bias.X) + d2s[5] -= float64(bias.Y) + // Make adr relative to dr.Min. + adr = adr.Sub(dr.Min) + + if u, ok := src.(*image.Uniform); ok && o.DstMask != nil && o.SrcMask != nil && sr.In(src.Bounds()) { + transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op) + return + } + + xscale := abs(d2s[0]) + if s := abs(d2s[1]); xscale < s { + xscale = s + } + yscale := abs(d2s[3]) + if s := abs(d2s[4]); yscale < s { + yscale = s + } + + // sr is the source pixels. If it extends beyond the src bounds, + // we cannot use the type-specific fast paths, as they access + // the Pix fields directly without bounds checking. + // + // Similarly, the fast paths assume that the masks are nil. + if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { + switch op { + case Over: + q.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + case Src: + q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + } + } else { + switch op { + case Over: + switch dst := dst.(type) { + case *image.RGBA: + switch src := src.(type) { + case *image.NRGBA: + q.transform_RGBA_NRGBA_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + case *image.RGBA: + q.transform_RGBA_RGBA_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + default: + q.transform_RGBA_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + } + default: + switch src := src.(type) { + default: + q.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + } + } + case Src: + switch dst := dst.(type) { + case *image.RGBA: + switch src := src.(type) { + case *image.Gray: + q.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + case *image.NRGBA: + q.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + case *image.RGBA: + q.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + case *image.YCbCr: + switch src.SubsampleRatio { + default: + q.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + case image.YCbCrSubsampleRatio444: + q.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + case image.YCbCrSubsampleRatio422: + q.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + case image.YCbCrSubsampleRatio420: + q.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + case image.YCbCrSubsampleRatio440: + q.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + } + default: + q.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + } + default: + switch src := src.(type) { + default: + q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) + } + } + } + } +} + +func (z *kernelScaler) scaleX_Gray(tmp [][4]float64, src *image.Gray, sr image.Rectangle, opts *Options) { + t := 0 + for y := int32(0); y < z.sh; y++ { + for _, s := range z.horizontal.sources { + var pr float64 + for _, c := range z.horizontal.contribs[s.i:s.j] { + pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) + pru := uint32(src.Pix[pi]) * 0x101 + pr += float64(pru) * c.weight + } + pr *= s.invTotalWeightFFFF + tmp[t] = [4]float64{ + pr, + pr, + pr, + 1, + } + t++ + } + } +} + +func (z *kernelScaler) scaleX_NRGBA(tmp [][4]float64, src *image.NRGBA, sr image.Rectangle, opts *Options) { + t := 0 + for y := int32(0); y < z.sh; y++ { + for _, s := range z.horizontal.sources { + var pr, pg, pb, pa float64 + for _, c := range z.horizontal.contribs[s.i:s.j] { + pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(c.coord)-src.Rect.Min.X)*4 + pau := uint32(src.Pix[pi+3]) * 0x101 + pru := uint32(src.Pix[pi+0]) * pau / 0xff + pgu := uint32(src.Pix[pi+1]) * pau / 0xff + pbu := uint32(src.Pix[pi+2]) * pau / 0xff + pr += float64(pru) * c.weight + pg += float64(pgu) * c.weight + pb += float64(pbu) * c.weight + pa += float64(pau) * c.weight + } + tmp[t] = [4]float64{ + pr * s.invTotalWeightFFFF, + pg * s.invTotalWeightFFFF, + pb * s.invTotalWeightFFFF, + pa * s.invTotalWeightFFFF, + } + t++ + } + } +} + +func (z *kernelScaler) scaleX_RGBA(tmp [][4]float64, src *image.RGBA, sr image.Rectangle, opts *Options) { + t := 0 + for y := int32(0); y < z.sh; y++ { + for _, s := range z.horizontal.sources { + var pr, pg, pb, pa float64 + for _, c := range z.horizontal.contribs[s.i:s.j] { + pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(c.coord)-src.Rect.Min.X)*4 + pru := uint32(src.Pix[pi+0]) * 0x101 + pgu := uint32(src.Pix[pi+1]) * 0x101 + pbu := uint32(src.Pix[pi+2]) * 0x101 + pau := uint32(src.Pix[pi+3]) * 0x101 + pr += float64(pru) * c.weight + pg += float64(pgu) * c.weight + pb += float64(pbu) * c.weight + pa += float64(pau) * c.weight + } + tmp[t] = [4]float64{ + pr * s.invTotalWeightFFFF, + pg * s.invTotalWeightFFFF, + pb * s.invTotalWeightFFFF, + pa * s.invTotalWeightFFFF, + } + t++ + } + } +} + +func (z *kernelScaler) scaleX_YCbCr444(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) { + t := 0 + for y := int32(0); y < z.sh; y++ { + for _, s := range z.horizontal.sources { + var pr, pg, pb float64 + for _, c := range z.horizontal.contribs[s.i:s.j] { + pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) + pj := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pru := (pyy1 + 91881*pcr1) >> 8 + pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pbu := (pyy1 + 116130*pcb1) >> 8 + if pru < 0 { + pru = 0 + } else if pru > 0xffff { + pru = 0xffff + } + if pgu < 0 { + pgu = 0 + } else if pgu > 0xffff { + pgu = 0xffff + } + if pbu < 0 { + pbu = 0 + } else if pbu > 0xffff { + pbu = 0xffff + } + + pr += float64(pru) * c.weight + pg += float64(pgu) * c.weight + pb += float64(pbu) * c.weight + } + tmp[t] = [4]float64{ + pr * s.invTotalWeightFFFF, + pg * s.invTotalWeightFFFF, + pb * s.invTotalWeightFFFF, + 1, + } + t++ + } + } +} + +func (z *kernelScaler) scaleX_YCbCr422(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) { + t := 0 + for y := int32(0); y < z.sh; y++ { + for _, s := range z.horizontal.sources { + var pr, pg, pb float64 + for _, c := range z.horizontal.contribs[s.i:s.j] { + pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) + pj := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(c.coord))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pru := (pyy1 + 91881*pcr1) >> 8 + pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pbu := (pyy1 + 116130*pcb1) >> 8 + if pru < 0 { + pru = 0 + } else if pru > 0xffff { + pru = 0xffff + } + if pgu < 0 { + pgu = 0 + } else if pgu > 0xffff { + pgu = 0xffff + } + if pbu < 0 { + pbu = 0 + } else if pbu > 0xffff { + pbu = 0xffff + } + + pr += float64(pru) * c.weight + pg += float64(pgu) * c.weight + pb += float64(pbu) * c.weight + } + tmp[t] = [4]float64{ + pr * s.invTotalWeightFFFF, + pg * s.invTotalWeightFFFF, + pb * s.invTotalWeightFFFF, + 1, + } + t++ + } + } +} + +func (z *kernelScaler) scaleX_YCbCr420(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) { + t := 0 + for y := int32(0); y < z.sh; y++ { + for _, s := range z.horizontal.sources { + var pr, pg, pb float64 + for _, c := range z.horizontal.contribs[s.i:s.j] { + pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) + pj := ((sr.Min.Y+int(y))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(c.coord))/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pru := (pyy1 + 91881*pcr1) >> 8 + pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pbu := (pyy1 + 116130*pcb1) >> 8 + if pru < 0 { + pru = 0 + } else if pru > 0xffff { + pru = 0xffff + } + if pgu < 0 { + pgu = 0 + } else if pgu > 0xffff { + pgu = 0xffff + } + if pbu < 0 { + pbu = 0 + } else if pbu > 0xffff { + pbu = 0xffff + } + + pr += float64(pru) * c.weight + pg += float64(pgu) * c.weight + pb += float64(pbu) * c.weight + } + tmp[t] = [4]float64{ + pr * s.invTotalWeightFFFF, + pg * s.invTotalWeightFFFF, + pb * s.invTotalWeightFFFF, + 1, + } + t++ + } + } +} + +func (z *kernelScaler) scaleX_YCbCr440(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) { + t := 0 + for y := int32(0); y < z.sh; y++ { + for _, s := range z.horizontal.sources { + var pr, pg, pb float64 + for _, c := range z.horizontal.contribs[s.i:s.j] { + pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) + pj := ((sr.Min.Y+int(y))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pru := (pyy1 + 91881*pcr1) >> 8 + pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pbu := (pyy1 + 116130*pcb1) >> 8 + if pru < 0 { + pru = 0 + } else if pru > 0xffff { + pru = 0xffff + } + if pgu < 0 { + pgu = 0 + } else if pgu > 0xffff { + pgu = 0xffff + } + if pbu < 0 { + pbu = 0 + } else if pbu > 0xffff { + pbu = 0xffff + } + + pr += float64(pru) * c.weight + pg += float64(pgu) * c.weight + pb += float64(pbu) * c.weight + } + tmp[t] = [4]float64{ + pr * s.invTotalWeightFFFF, + pg * s.invTotalWeightFFFF, + pb * s.invTotalWeightFFFF, + 1, + } + t++ + } + } +} + +func (z *kernelScaler) scaleX_Image(tmp [][4]float64, src image.Image, sr image.Rectangle, opts *Options) { + t := 0 + srcMask, smp := opts.SrcMask, opts.SrcMaskP + for y := int32(0); y < z.sh; y++ { + for _, s := range z.horizontal.sources { + var pr, pg, pb, pa float64 + for _, c := range z.horizontal.contribs[s.i:s.j] { + pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(c.coord), smp.Y+sr.Min.Y+int(y)).RGBA() + pru = pru * ma / 0xffff + pgu = pgu * ma / 0xffff + pbu = pbu * ma / 0xffff + pau = pau * ma / 0xffff + } + pr += float64(pru) * c.weight + pg += float64(pgu) * c.weight + pb += float64(pbu) * c.weight + pa += float64(pau) * c.weight + } + tmp[t] = [4]float64{ + pr * s.invTotalWeightFFFF, + pg * s.invTotalWeightFFFF, + pb * s.invTotalWeightFFFF, + pa * s.invTotalWeightFFFF, + } + t++ + } + } +} + +func (z *kernelScaler) scaleY_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) { + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + d := (dr.Min.Y+adr.Min.Y-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+int(dx)-dst.Rect.Min.X)*4 + for _, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { + var pr, pg, pb, pa float64 + for _, c := range z.vertical.contribs[s.i:s.j] { + p := &tmp[c.coord*z.dw+dx] + pr += p[0] * c.weight + pg += p[1] * c.weight + pb += p[2] * c.weight + pa += p[3] * c.weight + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + pr0 := uint32(ftou(pr * s.invTotalWeight)) + pg0 := uint32(ftou(pg * s.invTotalWeight)) + pb0 := uint32(ftou(pb * s.invTotalWeight)) + pa0 := uint32(ftou(pa * s.invTotalWeight)) + pa1 := (0xffff - uint32(pa0)) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr0) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg0) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb0) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa0) >> 8) + d += dst.Stride + } + } +} + +func (z *kernelScaler) scaleY_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) { + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + d := (dr.Min.Y+adr.Min.Y-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+int(dx)-dst.Rect.Min.X)*4 + for _, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { + var pr, pg, pb, pa float64 + for _, c := range z.vertical.contribs[s.i:s.j] { + p := &tmp[c.coord*z.dw+dx] + pr += p[0] * c.weight + pg += p[1] * c.weight + pb += p[2] * c.weight + pa += p[3] * c.weight + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + dst.Pix[d+0] = uint8(ftou(pr*s.invTotalWeight) >> 8) + dst.Pix[d+1] = uint8(ftou(pg*s.invTotalWeight) >> 8) + dst.Pix[d+2] = uint8(ftou(pb*s.invTotalWeight) >> 8) + dst.Pix[d+3] = uint8(ftou(pa*s.invTotalWeight) >> 8) + d += dst.Stride + } + } +} + +func (z *kernelScaler) scaleY_Image_Over(dst Image, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) { + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + for dy, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { + var pr, pg, pb, pa float64 + for _, c := range z.vertical.contribs[s.i:s.j] { + p := &tmp[c.coord*z.dw+dx] + pr += p[0] * c.weight + pg += p[1] * c.weight + pb += p[2] * c.weight + pa += p[3] * c.weight + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy)).RGBA() + pr0 := uint32(ftou(pr * s.invTotalWeight)) + pg0 := uint32(ftou(pg * s.invTotalWeight)) + pb0 := uint32(ftou(pb * s.invTotalWeight)) + pa0 := uint32(ftou(pa * s.invTotalWeight)) + if dstMask != nil { + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(adr.Min.Y+dy)).RGBA() + pr0 = pr0 * ma / 0xffff + pg0 = pg0 * ma / 0xffff + pb0 = pb0 * ma / 0xffff + pa0 = pa0 * ma / 0xffff + } + pa1 := 0xffff - pa0 + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr0) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg0) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb0) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa0) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy), dstColor) + } + } +} + +func (z *kernelScaler) scaleY_Image_Src(dst Image, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) { + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + for dy, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { + var pr, pg, pb, pa float64 + for _, c := range z.vertical.contribs[s.i:s.j] { + p := &tmp[c.coord*z.dw+dx] + pr += p[0] * c.weight + pg += p[1] * c.weight + pb += p[2] * c.weight + pa += p[3] * c.weight + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + if dstMask != nil { + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy)).RGBA() + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(adr.Min.Y+dy)).RGBA() + pr := uint32(ftou(pr*s.invTotalWeight)) * ma / 0xffff + pg := uint32(ftou(pg*s.invTotalWeight)) * ma / 0xffff + pb := uint32(ftou(pb*s.invTotalWeight)) * ma / 0xffff + pa := uint32(ftou(pa*s.invTotalWeight)) * ma / 0xffff + pa1 := 0xffff - ma + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy), dstColor) + } else { + dstColorRGBA64.R = ftou(pr * s.invTotalWeight) + dstColorRGBA64.G = ftou(pg * s.invTotalWeight) + dstColorRGBA64.B = ftou(pb * s.invTotalWeight) + dstColorRGBA64.A = ftou(pa * s.invTotalWeight) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy), dstColor) + } + } + } +} + +func (q *Kernel) transform_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pi := (ky-src.Rect.Min.Y)*src.Stride + (kx - src.Rect.Min.X) + pru := uint32(src.Pix[pi]) * 0x101 + pr += float64(pru) * w + } + } + } + } + out := uint8(fffftou(pr) >> 8) + dst.Pix[d+0] = out + dst.Pix[d+1] = out + dst.Pix[d+2] = out + dst.Pix[d+3] = 0xff + } + } +} + +func (q *Kernel) transform_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb, pa float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pi := (ky-src.Rect.Min.Y)*src.Stride + (kx-src.Rect.Min.X)*4 + pau := uint32(src.Pix[pi+3]) * 0x101 + pru := uint32(src.Pix[pi+0]) * pau / 0xff + pgu := uint32(src.Pix[pi+1]) * pau / 0xff + pbu := uint32(src.Pix[pi+2]) * pau / 0xff + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + pa += float64(pau) * w + } + } + } + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + pr0 := uint32(fffftou(pr)) + pg0 := uint32(fffftou(pg)) + pb0 := uint32(fffftou(pb)) + pa0 := uint32(fffftou(pa)) + pa1 := (0xffff - uint32(pa0)) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr0) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg0) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb0) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa0) >> 8) + } + } +} + +func (q *Kernel) transform_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb, pa float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pi := (ky-src.Rect.Min.Y)*src.Stride + (kx-src.Rect.Min.X)*4 + pau := uint32(src.Pix[pi+3]) * 0x101 + pru := uint32(src.Pix[pi+0]) * pau / 0xff + pgu := uint32(src.Pix[pi+1]) * pau / 0xff + pbu := uint32(src.Pix[pi+2]) * pau / 0xff + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + pa += float64(pau) * w + } + } + } + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + dst.Pix[d+0] = uint8(fffftou(pr) >> 8) + dst.Pix[d+1] = uint8(fffftou(pg) >> 8) + dst.Pix[d+2] = uint8(fffftou(pb) >> 8) + dst.Pix[d+3] = uint8(fffftou(pa) >> 8) + } + } +} + +func (q *Kernel) transform_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb, pa float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pi := (ky-src.Rect.Min.Y)*src.Stride + (kx-src.Rect.Min.X)*4 + pru := uint32(src.Pix[pi+0]) * 0x101 + pgu := uint32(src.Pix[pi+1]) * 0x101 + pbu := uint32(src.Pix[pi+2]) * 0x101 + pau := uint32(src.Pix[pi+3]) * 0x101 + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + pa += float64(pau) * w + } + } + } + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + pr0 := uint32(fffftou(pr)) + pg0 := uint32(fffftou(pg)) + pb0 := uint32(fffftou(pb)) + pa0 := uint32(fffftou(pa)) + pa1 := (0xffff - uint32(pa0)) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr0) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg0) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb0) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa0) >> 8) + } + } +} + +func (q *Kernel) transform_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb, pa float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pi := (ky-src.Rect.Min.Y)*src.Stride + (kx-src.Rect.Min.X)*4 + pru := uint32(src.Pix[pi+0]) * 0x101 + pgu := uint32(src.Pix[pi+1]) * 0x101 + pbu := uint32(src.Pix[pi+2]) * 0x101 + pau := uint32(src.Pix[pi+3]) * 0x101 + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + pa += float64(pau) * w + } + } + } + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + dst.Pix[d+0] = uint8(fffftou(pr) >> 8) + dst.Pix[d+1] = uint8(fffftou(pg) >> 8) + dst.Pix[d+2] = uint8(fffftou(pb) >> 8) + dst.Pix[d+3] = uint8(fffftou(pa) >> 8) + } + } +} + +func (q *Kernel) transform_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pi := (ky-src.Rect.Min.Y)*src.YStride + (kx - src.Rect.Min.X) + pj := (ky-src.Rect.Min.Y)*src.CStride + (kx - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pru := (pyy1 + 91881*pcr1) >> 8 + pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pbu := (pyy1 + 116130*pcb1) >> 8 + if pru < 0 { + pru = 0 + } else if pru > 0xffff { + pru = 0xffff + } + if pgu < 0 { + pgu = 0 + } else if pgu > 0xffff { + pgu = 0xffff + } + if pbu < 0 { + pbu = 0 + } else if pbu > 0xffff { + pbu = 0xffff + } + + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + } + } + } + } + dst.Pix[d+0] = uint8(fffftou(pr) >> 8) + dst.Pix[d+1] = uint8(fffftou(pg) >> 8) + dst.Pix[d+2] = uint8(fffftou(pb) >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (q *Kernel) transform_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pi := (ky-src.Rect.Min.Y)*src.YStride + (kx - src.Rect.Min.X) + pj := (ky-src.Rect.Min.Y)*src.CStride + ((kx)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pru := (pyy1 + 91881*pcr1) >> 8 + pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pbu := (pyy1 + 116130*pcb1) >> 8 + if pru < 0 { + pru = 0 + } else if pru > 0xffff { + pru = 0xffff + } + if pgu < 0 { + pgu = 0 + } else if pgu > 0xffff { + pgu = 0xffff + } + if pbu < 0 { + pbu = 0 + } else if pbu > 0xffff { + pbu = 0xffff + } + + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + } + } + } + } + dst.Pix[d+0] = uint8(fffftou(pr) >> 8) + dst.Pix[d+1] = uint8(fffftou(pg) >> 8) + dst.Pix[d+2] = uint8(fffftou(pb) >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (q *Kernel) transform_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pi := (ky-src.Rect.Min.Y)*src.YStride + (kx - src.Rect.Min.X) + pj := ((ky)/2-src.Rect.Min.Y/2)*src.CStride + ((kx)/2 - src.Rect.Min.X/2) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pru := (pyy1 + 91881*pcr1) >> 8 + pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pbu := (pyy1 + 116130*pcb1) >> 8 + if pru < 0 { + pru = 0 + } else if pru > 0xffff { + pru = 0xffff + } + if pgu < 0 { + pgu = 0 + } else if pgu > 0xffff { + pgu = 0xffff + } + if pbu < 0 { + pbu = 0 + } else if pbu > 0xffff { + pbu = 0xffff + } + + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + } + } + } + } + dst.Pix[d+0] = uint8(fffftou(pr) >> 8) + dst.Pix[d+1] = uint8(fffftou(pg) >> 8) + dst.Pix[d+2] = uint8(fffftou(pb) >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (q *Kernel) transform_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pi := (ky-src.Rect.Min.Y)*src.YStride + (kx - src.Rect.Min.X) + pj := ((ky)/2-src.Rect.Min.Y/2)*src.CStride + (kx - src.Rect.Min.X) + + // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. + pyy1 := int(src.Y[pi]) * 0x10100 + pcb1 := int(src.Cb[pj]) - 128 + pcr1 := int(src.Cr[pj]) - 128 + pru := (pyy1 + 91881*pcr1) >> 8 + pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 + pbu := (pyy1 + 116130*pcb1) >> 8 + if pru < 0 { + pru = 0 + } else if pru > 0xffff { + pru = 0xffff + } + if pgu < 0 { + pgu = 0 + } else if pgu > 0xffff { + pgu = 0xffff + } + if pbu < 0 { + pbu = 0 + } else if pbu > 0xffff { + pbu = 0xffff + } + + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + } + } + } + } + dst.Pix[d+0] = uint8(fffftou(pr) >> 8) + dst.Pix[d+1] = uint8(fffftou(pg) >> 8) + dst.Pix[d+2] = uint8(fffftou(pb) >> 8) + dst.Pix[d+3] = 0xff + } + } +} + +func (q *Kernel) transform_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb, pa float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pru, pgu, pbu, pau := src.At(kx, ky).RGBA() + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + pa += float64(pau) * w + } + } + } + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + pr0 := uint32(fffftou(pr)) + pg0 := uint32(fffftou(pg)) + pb0 := uint32(fffftou(pb)) + pa0 := uint32(fffftou(pa)) + pa1 := (0xffff - uint32(pa0)) * 0x101 + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr0) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg0) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb0) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa0) >> 8) + } + } +} + +func (q *Kernel) transform_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb, pa float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pru, pgu, pbu, pau := src.At(kx, ky).RGBA() + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + pa += float64(pau) * w + } + } + } + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + dst.Pix[d+0] = uint8(fffftou(pr) >> 8) + dst.Pix[d+1] = uint8(fffftou(pg) >> 8) + dst.Pix[d+2] = uint8(fffftou(pb) >> 8) + dst.Pix[d+3] = uint8(fffftou(pa) >> 8) + } + } +} + +func (q *Kernel) transform_Image_Image_Over(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + srcMask, smp := opts.SrcMask, opts.SrcMaskP + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb, pa float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pru, pgu, pbu, pau := src.At(kx, ky).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+kx, smp.Y+ky).RGBA() + pru = pru * ma / 0xffff + pgu = pgu * ma / 0xffff + pbu = pbu * ma / 0xffff + pau = pau * ma / 0xffff + } + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + pa += float64(pau) * w + } + } + } + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + pr0 := uint32(fffftou(pr)) + pg0 := uint32(fffftou(pg)) + pb0 := uint32(fffftou(pb)) + pa0 := uint32(fffftou(pa)) + if dstMask != nil { + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() + pr0 = pr0 * ma / 0xffff + pg0 = pg0 * ma / 0xffff + pb0 = pb0 * ma / 0xffff + pa0 = pa0 * ma / 0xffff + } + pa1 := 0xffff - pa0 + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr0) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg0) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb0) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa0) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } +} + +func (q *Kernel) transform_Image_Image_Src(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + xHalfWidth, xKernelArgScale := q.Support, 1.0 + if xscale > 1 { + xHalfWidth *= xscale + xKernelArgScale = 1 / xscale + } + yHalfWidth, yKernelArgScale := q.Support, 1.0 + if yscale > 1 { + yHalfWidth *= yscale + yKernelArgScale = 1 / yscale + } + + xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) + yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) + + srcMask, smp := opts.SrcMask, opts.SrcMaskP + dstMask, dmp := opts.DstMask, opts.DstMaskP + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] + sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] + if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { + continue + } + + // TODO: adjust the bias so that we can use int(f) instead + // of math.Floor(f) and math.Ceil(f). + sx += float64(bias.X) + sx -= 0.5 + ix := int(math.Floor(sx - xHalfWidth)) + if ix < sr.Min.X { + ix = sr.Min.X + } + jx := int(math.Ceil(sx + xHalfWidth)) + if jx > sr.Max.X { + jx = sr.Max.X + } + + totalXWeight := 0.0 + for kx := ix; kx < jx; kx++ { + xWeight := 0.0 + if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { + xWeight = q.At(t) + } + xWeights[kx-ix] = xWeight + totalXWeight += xWeight + } + for x := range xWeights[:jx-ix] { + xWeights[x] /= totalXWeight + } + + sy += float64(bias.Y) + sy -= 0.5 + iy := int(math.Floor(sy - yHalfWidth)) + if iy < sr.Min.Y { + iy = sr.Min.Y + } + jy := int(math.Ceil(sy + yHalfWidth)) + if jy > sr.Max.Y { + jy = sr.Max.Y + } + + totalYWeight := 0.0 + for ky := iy; ky < jy; ky++ { + yWeight := 0.0 + if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { + yWeight = q.At(t) + } + yWeights[ky-iy] = yWeight + totalYWeight += yWeight + } + for y := range yWeights[:jy-iy] { + yWeights[y] /= totalYWeight + } + + var pr, pg, pb, pa float64 + for ky := iy; ky < jy; ky++ { + if yWeight := yWeights[ky-iy]; yWeight != 0 { + for kx := ix; kx < jx; kx++ { + if w := xWeights[kx-ix] * yWeight; w != 0 { + pru, pgu, pbu, pau := src.At(kx, ky).RGBA() + if srcMask != nil { + _, _, _, ma := srcMask.At(smp.X+kx, smp.Y+ky).RGBA() + pru = pru * ma / 0xffff + pgu = pgu * ma / 0xffff + pbu = pbu * ma / 0xffff + pau = pau * ma / 0xffff + } + pr += float64(pru) * w + pg += float64(pgu) * w + pb += float64(pbu) * w + pa += float64(pau) * w + } + } + } + } + + if pr > pa { + pr = pa + } + if pg > pa { + pg = pa + } + if pb > pa { + pb = pa + } + + if dstMask != nil { + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() + pr := uint32(fffftou(pr)) * ma / 0xffff + pg := uint32(fffftou(pg)) * ma / 0xffff + pb := uint32(fffftou(pb)) * ma / 0xffff + pa := uint32(fffftou(pa)) * ma / 0xffff + pa1 := 0xffff - ma + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } else { + dstColorRGBA64.R = fffftou(pr) + dstColorRGBA64.G = fffftou(pg) + dstColorRGBA64.B = fffftou(pb) + dstColorRGBA64.A = fffftou(pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } + } +} diff --git a/vendor/golang.org/x/image/draw/scale.go b/vendor/golang.org/x/image/draw/scale.go new file mode 100644 index 00000000..98ab404e --- /dev/null +++ b/vendor/golang.org/x/image/draw/scale.go @@ -0,0 +1,527 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:generate go run gen.go + +package draw + +import ( + "image" + "image/color" + "math" + "sync" + + "golang.org/x/image/math/f64" +) + +// Copy copies the part of the source image defined by src and sr and writes +// the result of a Porter-Duff composition to the part of the destination image +// defined by dst and the translation of sr so that sr.Min translates to dp. +func Copy(dst Image, dp image.Point, src image.Image, sr image.Rectangle, op Op, opts *Options) { + var o Options + if opts != nil { + o = *opts + } + dr := sr.Add(dp.Sub(sr.Min)) + if o.DstMask == nil { + DrawMask(dst, dr, src, sr.Min, o.SrcMask, o.SrcMaskP.Add(sr.Min), op) + } else { + NearestNeighbor.Scale(dst, dr, src, sr, op, opts) + } +} + +// Scaler scales the part of the source image defined by src and sr and writes +// the result of a Porter-Duff composition to the part of the destination image +// defined by dst and dr. +// +// A Scaler is safe to use concurrently. +type Scaler interface { + Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) +} + +// Transformer transforms the part of the source image defined by src and sr +// and writes the result of a Porter-Duff composition to the part of the +// destination image defined by dst and the affine transform m applied to sr. +// +// For example, if m is the matrix +// +// m00 m01 m02 +// m10 m11 m12 +// +// then the src-space point (sx, sy) maps to the dst-space point +// (m00*sx + m01*sy + m02, m10*sx + m11*sy + m12). +// +// A Transformer is safe to use concurrently. +type Transformer interface { + Transform(dst Image, m f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) +} + +// Options are optional parameters to Copy, Scale and Transform. +// +// A nil *Options means to use the default (zero) values of each field. +type Options struct { + // Masks limit what parts of the dst image are drawn to and what parts of + // the src image are drawn from. + // + // A dst or src mask image having a zero alpha (transparent) pixel value in + // the respective coordinate space means that that dst pixel is entirely + // unaffected or that src pixel is considered transparent black. A full + // alpha (opaque) value means that the dst pixel is maximally affected or + // the src pixel contributes maximally. The default values, nil, are + // equivalent to fully opaque, infinitely large mask images. + // + // The DstMask is otherwise known as a clip mask, and its pixels map 1:1 to + // the dst image's pixels. DstMaskP in DstMask space corresponds to + // image.Point{X:0, Y:0} in dst space. For example, when limiting + // repainting to a 'dirty rectangle', use that image.Rectangle and a zero + // image.Point as the DstMask and DstMaskP. + // + // The SrcMask's pixels map 1:1 to the src image's pixels. SrcMaskP in + // SrcMask space corresponds to image.Point{X:0, Y:0} in src space. For + // example, when drawing font glyphs in a uniform color, use an + // *image.Uniform as the src, and use the glyph atlas image and the + // per-glyph offset as SrcMask and SrcMaskP: + // Copy(dst, dp, image.NewUniform(color), image.Rect(0, 0, glyphWidth, glyphHeight), &Options{ + // SrcMask: glyphAtlas, + // SrcMaskP: glyphOffset, + // }) + DstMask image.Image + DstMaskP image.Point + SrcMask image.Image + SrcMaskP image.Point + + // TODO: a smooth vs sharp edges option, for arbitrary rotations? +} + +// Interpolator is an interpolation algorithm, when dst and src pixels don't +// have a 1:1 correspondence. +// +// Of the interpolators provided by this package: +// - NearestNeighbor is fast but usually looks worst. +// - CatmullRom is slow but usually looks best. +// - ApproxBiLinear has reasonable speed and quality. +// +// The time taken depends on the size of dr. For kernel interpolators, the +// speed also depends on the size of sr, and so are often slower than +// non-kernel interpolators, especially when scaling down. +type Interpolator interface { + Scaler + Transformer +} + +// Kernel is an interpolator that blends source pixels weighted by a symmetric +// kernel function. +type Kernel struct { + // Support is the kernel support and must be >= 0. At(t) is assumed to be + // zero when t >= Support. + Support float64 + // At is the kernel function. It will only be called with t in the + // range [0, Support). + At func(t float64) float64 +} + +// Scale implements the Scaler interface. +func (q *Kernel) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { + q.newScaler(dr.Dx(), dr.Dy(), sr.Dx(), sr.Dy(), false).Scale(dst, dr, src, sr, op, opts) +} + +// NewScaler returns a Scaler that is optimized for scaling multiple times with +// the same fixed destination and source width and height. +func (q *Kernel) NewScaler(dw, dh, sw, sh int) Scaler { + return q.newScaler(dw, dh, sw, sh, true) +} + +func (q *Kernel) newScaler(dw, dh, sw, sh int, usePool bool) Scaler { + z := &kernelScaler{ + kernel: q, + dw: int32(dw), + dh: int32(dh), + sw: int32(sw), + sh: int32(sh), + horizontal: newDistrib(q, int32(dw), int32(sw)), + vertical: newDistrib(q, int32(dh), int32(sh)), + } + if usePool { + z.pool.New = func() interface{} { + tmp := z.makeTmpBuf() + return &tmp + } + } + return z +} + +var ( + // NearestNeighbor is the nearest neighbor interpolator. It is very fast, + // but usually gives very low quality results. When scaling up, the result + // will look 'blocky'. + NearestNeighbor = Interpolator(nnInterpolator{}) + + // ApproxBiLinear is a mixture of the nearest neighbor and bi-linear + // interpolators. It is fast, but usually gives medium quality results. + // + // It implements bi-linear interpolation when upscaling and a bi-linear + // blend of the 4 nearest neighbor pixels when downscaling. This yields + // nicer quality than nearest neighbor interpolation when upscaling, but + // the time taken is independent of the number of source pixels, unlike the + // bi-linear interpolator. When downscaling a large image, the performance + // difference can be significant. + ApproxBiLinear = Interpolator(ablInterpolator{}) + + // BiLinear is the tent kernel. It is slow, but usually gives high quality + // results. + BiLinear = &Kernel{1, func(t float64) float64 { + return 1 - t + }} + + // CatmullRom is the Catmull-Rom kernel. It is very slow, but usually gives + // very high quality results. + // + // It is an instance of the more general cubic BC-spline kernel with parameters + // B=0 and C=0.5. See Mitchell and Netravali, "Reconstruction Filters in + // Computer Graphics", Computer Graphics, Vol. 22, No. 4, pp. 221-228. + CatmullRom = &Kernel{2, func(t float64) float64 { + if t < 1 { + return (1.5*t-2.5)*t*t + 1 + } + return ((-0.5*t+2.5)*t-4)*t + 2 + }} + + // TODO: a Kaiser-Bessel kernel? +) + +type nnInterpolator struct{} + +type ablInterpolator struct{} + +type kernelScaler struct { + kernel *Kernel + dw, dh, sw, sh int32 + horizontal, vertical distrib + pool sync.Pool +} + +func (z *kernelScaler) makeTmpBuf() [][4]float64 { + return make([][4]float64, z.dw*z.sh) +} + +// source is a range of contribs, their inverse total weight, and that ITW +// divided by 0xffff. +type source struct { + i, j int32 + invTotalWeight float64 + invTotalWeightFFFF float64 +} + +// contrib is the weight of a column or row. +type contrib struct { + coord int32 + weight float64 +} + +// distrib measures how source pixels are distributed over destination pixels. +type distrib struct { + // sources are what contribs each column or row in the source image owns, + // and the total weight of those contribs. + sources []source + // contribs are the contributions indexed by sources[s].i and sources[s].j. + contribs []contrib +} + +// newDistrib returns a distrib that distributes sw source columns (or rows) +// over dw destination columns (or rows). +func newDistrib(q *Kernel, dw, sw int32) distrib { + scale := float64(sw) / float64(dw) + halfWidth, kernelArgScale := q.Support, 1.0 + // When shrinking, broaden the effective kernel support so that we still + // visit every source pixel. + if scale > 1 { + halfWidth *= scale + kernelArgScale = 1 / scale + } + + // Make the sources slice, one source for each column or row, and temporarily + // appropriate its elements' fields so that invTotalWeight is the scaled + // coordinate of the source column or row, and i and j are the lower and + // upper bounds of the range of destination columns or rows affected by the + // source column or row. + n, sources := int32(0), make([]source, dw) + for x := range sources { + center := (float64(x)+0.5)*scale - 0.5 + i := int32(math.Floor(center - halfWidth)) + if i < 0 { + i = 0 + } + j := int32(math.Ceil(center + halfWidth)) + if j > sw { + j = sw + if j < i { + j = i + } + } + sources[x] = source{i: i, j: j, invTotalWeight: center} + n += j - i + } + + contribs := make([]contrib, 0, n) + for k, b := range sources { + totalWeight := 0.0 + l := int32(len(contribs)) + for coord := b.i; coord < b.j; coord++ { + t := abs((b.invTotalWeight - float64(coord)) * kernelArgScale) + if t >= q.Support { + continue + } + weight := q.At(t) + if weight == 0 { + continue + } + totalWeight += weight + contribs = append(contribs, contrib{coord, weight}) + } + totalWeight = 1 / totalWeight + sources[k] = source{ + i: l, + j: int32(len(contribs)), + invTotalWeight: totalWeight, + invTotalWeightFFFF: totalWeight / 0xffff, + } + } + + return distrib{sources, contribs} +} + +// abs is like math.Abs, but it doesn't care about negative zero, infinities or +// NaNs. +func abs(f float64) float64 { + if f < 0 { + f = -f + } + return f +} + +// ftou converts the range [0.0, 1.0] to [0, 0xffff]. +func ftou(f float64) uint16 { + i := int32(0xffff*f + 0.5) + if i > 0xffff { + return 0xffff + } + if i > 0 { + return uint16(i) + } + return 0 +} + +// fffftou converts the range [0.0, 65535.0] to [0, 0xffff]. +func fffftou(f float64) uint16 { + i := int32(f + 0.5) + if i > 0xffff { + return 0xffff + } + if i > 0 { + return uint16(i) + } + return 0 +} + +// invert returns the inverse of m. +// +// TODO: move this into the f64 package, once we work out the convention for +// matrix methods in that package: do they modify the receiver, take a dst +// pointer argument, or return a new value? +func invert(m *f64.Aff3) f64.Aff3 { + m00 := +m[3*1+1] + m01 := -m[3*0+1] + m02 := +m[3*1+2]*m[3*0+1] - m[3*1+1]*m[3*0+2] + m10 := -m[3*1+0] + m11 := +m[3*0+0] + m12 := +m[3*1+0]*m[3*0+2] - m[3*1+2]*m[3*0+0] + + det := m00*m11 - m10*m01 + + return f64.Aff3{ + m00 / det, + m01 / det, + m02 / det, + m10 / det, + m11 / det, + m12 / det, + } +} + +func matMul(p, q *f64.Aff3) f64.Aff3 { + return f64.Aff3{ + p[3*0+0]*q[3*0+0] + p[3*0+1]*q[3*1+0], + p[3*0+0]*q[3*0+1] + p[3*0+1]*q[3*1+1], + p[3*0+0]*q[3*0+2] + p[3*0+1]*q[3*1+2] + p[3*0+2], + p[3*1+0]*q[3*0+0] + p[3*1+1]*q[3*1+0], + p[3*1+0]*q[3*0+1] + p[3*1+1]*q[3*1+1], + p[3*1+0]*q[3*0+2] + p[3*1+1]*q[3*1+2] + p[3*1+2], + } +} + +// transformRect returns a rectangle dr that contains sr transformed by s2d. +func transformRect(s2d *f64.Aff3, sr *image.Rectangle) (dr image.Rectangle) { + ps := [...]image.Point{ + {sr.Min.X, sr.Min.Y}, + {sr.Max.X, sr.Min.Y}, + {sr.Min.X, sr.Max.Y}, + {sr.Max.X, sr.Max.Y}, + } + for i, p := range ps { + sxf := float64(p.X) + syf := float64(p.Y) + dx := int(math.Floor(s2d[0]*sxf + s2d[1]*syf + s2d[2])) + dy := int(math.Floor(s2d[3]*sxf + s2d[4]*syf + s2d[5])) + + // The +1 adjustments below are because an image.Rectangle is inclusive + // on the low end but exclusive on the high end. + + if i == 0 { + dr = image.Rectangle{ + Min: image.Point{dx + 0, dy + 0}, + Max: image.Point{dx + 1, dy + 1}, + } + continue + } + + if dr.Min.X > dx { + dr.Min.X = dx + } + dx++ + if dr.Max.X < dx { + dr.Max.X = dx + } + + if dr.Min.Y > dy { + dr.Min.Y = dy + } + dy++ + if dr.Max.Y < dy { + dr.Max.Y = dy + } + } + return dr +} + +func clipAffectedDestRect(adr image.Rectangle, dstMask image.Image, dstMaskP image.Point) (image.Rectangle, image.Image) { + if dstMask == nil { + return adr, nil + } + // TODO: enable this fast path once Go 1.5 is released, where an + // image.Rectangle implements image.Image. + // if r, ok := dstMask.(image.Rectangle); ok { + // return adr.Intersect(r.Sub(dstMaskP)), nil + // } + // TODO: clip to dstMask.Bounds() if the color model implies that out-of-bounds means 0 alpha? + return adr, dstMask +} + +func transform_Uniform(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Uniform, sr image.Rectangle, bias image.Point, op Op) { + switch op { + case Over: + switch dst := dst.(type) { + case *image.RGBA: + pr, pg, pb, pa := src.C.RGBA() + pa1 := (0xffff - pa) * 0x101 + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8) + dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8) + dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8) + dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8) + } + } + + default: + pr, pg, pb, pa := src.C.RGBA() + pa1 := 0xffff - pa + dstColorRGBA64 := &color.RGBA64{} + dstColor := color.Color(dstColorRGBA64) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() + dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr) + dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg) + dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb) + dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } + } + + case Src: + switch dst := dst.(type) { + case *image.RGBA: + pr, pg, pb, pa := src.C.RGBA() + pr8 := uint8(pr >> 8) + pg8 := uint8(pg >> 8) + pb8 := uint8(pb >> 8) + pa8 := uint8(pa >> 8) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + dst.Pix[d+0] = pr8 + dst.Pix[d+1] = pg8 + dst.Pix[d+2] = pb8 + dst.Pix[d+3] = pa8 + } + } + + default: + pr, pg, pb, pa := src.C.RGBA() + dstColorRGBA64 := &color.RGBA64{ + uint16(pr), + uint16(pg), + uint16(pb), + uint16(pa), + } + dstColor := color.Color(dstColorRGBA64) + + for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { + dyf := float64(dr.Min.Y+int(dy)) + 0.5 + for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { + dxf := float64(dr.Min.X+int(dx)) + 0.5 + sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X + sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y + if !(image.Point{sx0, sy0}).In(sr) { + continue + } + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) + } + } + } + } +} + +func opaque(m image.Image) bool { + o, ok := m.(interface { + Opaque() bool + }) + return ok && o.Opaque() +} diff --git a/vendor/golang.org/x/image/font/font.go b/vendor/golang.org/x/image/font/font.go new file mode 100644 index 00000000..a0a66d29 --- /dev/null +++ b/vendor/golang.org/x/image/font/font.go @@ -0,0 +1,281 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package font defines an interface for font faces, for drawing text on an +// image. +// +// Other packages provide font face implementations. For example, a truetype +// package would provide one based on .ttf font files. +package font // import "golang.org/x/image/font" + +import ( + "image" + "image/draw" + "io" + "unicode/utf8" + + "golang.org/x/image/math/fixed" +) + +// TODO: who is responsible for caches (glyph images, glyph indices, kerns)? +// The Drawer or the Face? + +// Face is a font face. Its glyphs are often derived from a font file, such as +// "Comic_Sans_MS.ttf", but a face has a specific size, style, weight and +// hinting. For example, the 12pt and 18pt versions of Comic Sans are two +// different faces, even if derived from the same font file. +// +// A Face is not safe for concurrent use by multiple goroutines, as its methods +// may re-use implementation-specific caches and mask image buffers. +// +// To create a Face, look to other packages that implement specific font file +// formats. +type Face interface { + io.Closer + + // Glyph returns the draw.DrawMask parameters (dr, mask, maskp) to draw r's + // glyph at the sub-pixel destination location dot, and that glyph's + // advance width. + // + // It returns !ok if the face does not contain a glyph for r. + // + // The contents of the mask image returned by one Glyph call may change + // after the next Glyph call. Callers that want to cache the mask must make + // a copy. + Glyph(dot fixed.Point26_6, r rune) ( + dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool) + + // GlyphBounds returns the bounding box of r's glyph, drawn at a dot equal + // to the origin, and that glyph's advance width. + // + // It returns !ok if the face does not contain a glyph for r. + // + // The glyph's ascent and descent equal -bounds.Min.Y and +bounds.Max.Y. A + // visual depiction of what these metrics are is at + // https://developer.apple.com/library/mac/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png + GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) + + // GlyphAdvance returns the advance width of r's glyph. + // + // It returns !ok if the face does not contain a glyph for r. + GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) + + // Kern returns the horizontal adjustment for the kerning pair (r0, r1). A + // positive kern means to move the glyphs further apart. + Kern(r0, r1 rune) fixed.Int26_6 + + // Metrics returns the metrics for this Face. + Metrics() Metrics + + // TODO: ColoredGlyph for various emoji? + // TODO: Ligatures? Shaping? +} + +// Metrics holds the metrics for a Face. A visual depiction is at +// https://developer.apple.com/library/mac/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png +type Metrics struct { + // Height is the recommended amount of vertical space between two lines of + // text. + Height fixed.Int26_6 + + // Ascent is the distance from the top of a line to its baseline. + Ascent fixed.Int26_6 + + // Descent is the distance from the bottom of a line to its baseline. The + // value is typically positive, even though a descender goes below the + // baseline. + Descent fixed.Int26_6 +} + +// Drawer draws text on a destination image. +// +// A Drawer is not safe for concurrent use by multiple goroutines, since its +// Face is not. +type Drawer struct { + // Dst is the destination image. + Dst draw.Image + // Src is the source image. + Src image.Image + // Face provides the glyph mask images. + Face Face + // Dot is the baseline location to draw the next glyph. The majority of the + // affected pixels will be above and to the right of the dot, but some may + // be below or to the left. For example, drawing a 'j' in an italic face + // may affect pixels below and to the left of the dot. + Dot fixed.Point26_6 + + // TODO: Clip image.Image? + // TODO: SrcP image.Point for Src images other than *image.Uniform? How + // does it get updated during DrawString? +} + +// TODO: should DrawString return the last rune drawn, so the next DrawString +// call can kern beforehand? Or should that be the responsibility of the caller +// if they really want to do that, since they have to explicitly shift d.Dot +// anyway? What if ligatures span more than two runes? What if grapheme +// clusters span multiple runes? +// +// TODO: do we assume that the input is in any particular Unicode Normalization +// Form? +// +// TODO: have DrawRunes(s []rune)? DrawRuneReader(io.RuneReader)?? If we take +// io.RuneReader, we can't assume that we can rewind the stream. +// +// TODO: how does this work with line breaking: drawing text up until a +// vertical line? Should DrawString return the number of runes drawn? + +// DrawBytes draws s at the dot and advances the dot's location. +func (d *Drawer) DrawBytes(s []byte) { + prevC := rune(-1) + for len(s) > 0 { + c, size := utf8.DecodeRune(s) + s = s[size:] + if prevC >= 0 { + d.Dot.X += d.Face.Kern(prevC, c) + } + dr, mask, maskp, advance, ok := d.Face.Glyph(d.Dot, c) + if !ok { + // TODO: is falling back on the U+FFFD glyph the responsibility of + // the Drawer or the Face? + // TODO: set prevC = '\ufffd'? + continue + } + draw.DrawMask(d.Dst, dr, d.Src, image.Point{}, mask, maskp, draw.Over) + d.Dot.X += advance + prevC = c + } +} + +// DrawString draws s at the dot and advances the dot's location. +func (d *Drawer) DrawString(s string) { + prevC := rune(-1) + for _, c := range s { + if prevC >= 0 { + d.Dot.X += d.Face.Kern(prevC, c) + } + dr, mask, maskp, advance, ok := d.Face.Glyph(d.Dot, c) + if !ok { + // TODO: is falling back on the U+FFFD glyph the responsibility of + // the Drawer or the Face? + // TODO: set prevC = '\ufffd'? + continue + } + draw.DrawMask(d.Dst, dr, d.Src, image.Point{}, mask, maskp, draw.Over) + d.Dot.X += advance + prevC = c + } +} + +// MeasureBytes returns how far dot would advance by drawing s. +func (d *Drawer) MeasureBytes(s []byte) (advance fixed.Int26_6) { + return MeasureBytes(d.Face, s) +} + +// MeasureString returns how far dot would advance by drawing s. +func (d *Drawer) MeasureString(s string) (advance fixed.Int26_6) { + return MeasureString(d.Face, s) +} + +// MeasureBytes returns how far dot would advance by drawing s with f. +func MeasureBytes(f Face, s []byte) (advance fixed.Int26_6) { + prevC := rune(-1) + for len(s) > 0 { + c, size := utf8.DecodeRune(s) + s = s[size:] + if prevC >= 0 { + advance += f.Kern(prevC, c) + } + a, ok := f.GlyphAdvance(c) + if !ok { + // TODO: is falling back on the U+FFFD glyph the responsibility of + // the Drawer or the Face? + // TODO: set prevC = '\ufffd'? + continue + } + advance += a + prevC = c + } + return advance +} + +// MeasureString returns how far dot would advance by drawing s with f. +func MeasureString(f Face, s string) (advance fixed.Int26_6) { + prevC := rune(-1) + for _, c := range s { + if prevC >= 0 { + advance += f.Kern(prevC, c) + } + a, ok := f.GlyphAdvance(c) + if !ok { + // TODO: is falling back on the U+FFFD glyph the responsibility of + // the Drawer or the Face? + // TODO: set prevC = '\ufffd'? + continue + } + advance += a + prevC = c + } + return advance +} + +// Hinting selects how to quantize a vector font's glyph nodes. +// +// Not all fonts support hinting. +type Hinting int + +const ( + HintingNone Hinting = iota + HintingVertical + HintingFull +) + +// Stretch selects a normal, condensed, or expanded face. +// +// Not all fonts support stretches. +type Stretch int + +const ( + StretchUltraCondensed Stretch = -4 + StretchExtraCondensed Stretch = -3 + StretchCondensed Stretch = -2 + StretchSemiCondensed Stretch = -1 + StretchNormal Stretch = +0 + StretchSemiExpanded Stretch = +1 + StretchExpanded Stretch = +2 + StretchExtraExpanded Stretch = +3 + StretchUltraExpanded Stretch = +4 +) + +// Style selects a normal, italic, or oblique face. +// +// Not all fonts support styles. +type Style int + +const ( + StyleNormal Style = iota + StyleItalic + StyleOblique +) + +// Weight selects a normal, light or bold face. +// +// Not all fonts support weights. +// +// The named Weight constants (e.g. WeightBold) correspond to CSS' common +// weight names (e.g. "Bold"), but the numerical values differ, so that in Go, +// the zero value means to use a normal weight. For the CSS names and values, +// see https://developer.mozilla.org/en/docs/Web/CSS/font-weight +type Weight int + +const ( + WeightThin Weight = -3 // CSS font-weight value 100. + WeightExtraLight Weight = -2 // CSS font-weight value 200. + WeightLight Weight = -1 // CSS font-weight value 300. + WeightNormal Weight = +0 // CSS font-weight value 400. + WeightMedium Weight = +1 // CSS font-weight value 500. + WeightSemiBold Weight = +2 // CSS font-weight value 600. + WeightBold Weight = +3 // CSS font-weight value 700. + WeightExtraBold Weight = +4 // CSS font-weight value 800. + WeightBlack Weight = +5 // CSS font-weight value 900. +) diff --git a/vendor/golang.org/x/image/math/f64/f64.go b/vendor/golang.org/x/image/math/f64/f64.go new file mode 100644 index 00000000..a1f7fc0e --- /dev/null +++ b/vendor/golang.org/x/image/math/f64/f64.go @@ -0,0 +1,37 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package f64 implements float64 vector and matrix types. +package f64 // import "golang.org/x/image/math/f64" + +// Vec2 is a 2-element vector. +type Vec2 [2]float64 + +// Vec3 is a 3-element vector. +type Vec3 [3]float64 + +// Vec4 is a 4-element vector. +type Vec4 [4]float64 + +// Mat3 is a 3x3 matrix in row major order. +// +// m[3*r + c] is the element in the r'th row and c'th column. +type Mat3 [9]float64 + +// Mat4 is a 4x4 matrix in row major order. +// +// m[4*r + c] is the element in the r'th row and c'th column. +type Mat4 [16]float64 + +// Aff3 is a 3x3 affine transformation matrix in row major order, where the +// bottom row is implicitly [0 0 1]. +// +// m[3*r + c] is the element in the r'th row and c'th column. +type Aff3 [6]float64 + +// Aff4 is a 4x4 affine transformation matrix in row major order, where the +// bottom row is implicitly [0 0 0 1]. +// +// m[4*r + c] is the element in the r'th row and c'th column. +type Aff4 [12]float64 diff --git a/vendor/golang.org/x/image/math/fixed/fixed.go b/vendor/golang.org/x/image/math/fixed/fixed.go new file mode 100644 index 00000000..df3540a3 --- /dev/null +++ b/vendor/golang.org/x/image/math/fixed/fixed.go @@ -0,0 +1,202 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package fixed implements fixed-point integer types. +package fixed // import "golang.org/x/image/math/fixed" + +import ( + "fmt" +) + +// TODO: implement fmt.Formatter for %f and %g. + +// I returns the integer value i as an Int26_6. +// +// For example, passing the integer value 2 yields Int26_6(128). +func I(i int) Int26_6 { + return Int26_6(i << 6) +} + +// Int26_6 is a signed 26.6 fixed-point number. +// +// The integer part ranges from -33554432 to 33554431, inclusive. The +// fractional part has 6 bits of precision. +// +// For example, the number one-and-a-quarter is Int26_6(1<<6 + 1<<4). +type Int26_6 int32 + +// String returns a human-readable representation of a 26.6 fixed-point number. +// +// For example, the number one-and-a-quarter becomes "1:16". +func (x Int26_6) String() string { + const shift, mask = 6, 1<<6 - 1 + if x >= 0 { + return fmt.Sprintf("%d:%02d", int32(x>>shift), int32(x&mask)) + } + x = -x + if x >= 0 { + return fmt.Sprintf("-%d:%02d", int32(x>>shift), int32(x&mask)) + } + return "-33554432:00" // The minimum value is -(1<<25). +} + +// Floor returns the greatest integer value less than or equal to x. +// +// Its return type is int, not Int26_6. +func (x Int26_6) Floor() int { return int((x + 0x00) >> 6) } + +// Round returns the nearest integer value to x. Ties are rounded up. +// +// Its return type is int, not Int26_6. +func (x Int26_6) Round() int { return int((x + 0x20) >> 6) } + +// Ceil returns the least integer value greater than or equal to x. +// +// Its return type is int, not Int26_6. +func (x Int26_6) Ceil() int { return int((x + 0x3f) >> 6) } + +// Int52_12 is a signed 52.12 fixed-point number. +// +// The integer part ranges from -2251799813685248 to 2251799813685247, +// inclusive. The fractional part has 12 bits of precision. +// +// For example, the number one-and-a-quarter is Int52_12(1<<12 + 1<<10). +type Int52_12 int64 + +// String returns a human-readable representation of a 52.12 fixed-point +// number. +// +// For example, the number one-and-a-quarter becomes "1:1024". +func (x Int52_12) String() string { + const shift, mask = 12, 1<<12 - 1 + if x >= 0 { + return fmt.Sprintf("%d:%04d", int64(x>>shift), int64(x&mask)) + } + x = -x + if x >= 0 { + return fmt.Sprintf("-%d:%04d", int64(x>>shift), int64(x&mask)) + } + return "-2251799813685248:0000" // The minimum value is -(1<<51). +} + +// Floor returns the greatest integer value less than or equal to x. +// +// Its return type is int, not Int52_12. +func (x Int52_12) Floor() int { return int((x + 0x000) >> 12) } + +// Round returns the nearest integer value to x. Ties are rounded up. +// +// Its return type is int, not Int52_12. +func (x Int52_12) Round() int { return int((x + 0x800) >> 12) } + +// Ceil returns the least integer value greater than or equal to x. +// +// Its return type is int, not Int52_12. +func (x Int52_12) Ceil() int { return int((x + 0xfff) >> 12) } + +// P returns the integer values x and y as a Point26_6. +// +// For example, passing the integer values (2, -3) yields Point26_6{128, -192}. +func P(x, y int) Point26_6 { + return Point26_6{Int26_6(x << 6), Int26_6(y << 6)} +} + +// Point26_6 is a 26.6 fixed-point coordinate pair. +// +// It is analogous to the image.Point type in the standard library. +type Point26_6 struct { + X, Y Int26_6 +} + +// Add returns the vector p+q. +func (p Point26_6) Add(q Point26_6) Point26_6 { + return Point26_6{p.X + q.X, p.Y + q.Y} +} + +// Sub returns the vector p-q. +func (p Point26_6) Sub(q Point26_6) Point26_6 { + return Point26_6{p.X - q.X, p.Y - q.Y} +} + +// Mul returns the vector p*k. +func (p Point26_6) Mul(k Int26_6) Point26_6 { + return Point26_6{p.X * k / 64, p.Y * k / 64} +} + +// Div returns the vector p/k. +func (p Point26_6) Div(k Int26_6) Point26_6 { + return Point26_6{p.X * 64 / k, p.Y * 64 / k} +} + +// Point52_12 is a 52.12 fixed-point coordinate pair. +// +// It is analogous to the image.Point type in the standard library. +type Point52_12 struct { + X, Y Int52_12 +} + +// Add returns the vector p+q. +func (p Point52_12) Add(q Point52_12) Point52_12 { + return Point52_12{p.X + q.X, p.Y + q.Y} +} + +// Sub returns the vector p-q. +func (p Point52_12) Sub(q Point52_12) Point52_12 { + return Point52_12{p.X - q.X, p.Y - q.Y} +} + +// Mul returns the vector p*k. +func (p Point52_12) Mul(k Int52_12) Point52_12 { + return Point52_12{p.X * k / 4096, p.Y * k / 4096} +} + +// Div returns the vector p/k. +func (p Point52_12) Div(k Int52_12) Point52_12 { + return Point52_12{p.X * 4096 / k, p.Y * 4096 / k} +} + +// R returns the integer values minX, minY, maxX, maxY as a Rectangle26_6. +// +// For example, passing the integer values (0, 1, 2, 3) yields +// Rectangle26_6{Point26_6{0, 64}, Point26_6{128, 192}}. +// +// Like the image.Rect function in the standard library, the returned rectangle +// has minimum and maximum coordinates swapped if necessary so that it is +// well-formed. +func R(minX, minY, maxX, maxY int) Rectangle26_6 { + if minX > maxX { + minX, maxX = maxX, minX + } + if minY > maxY { + minY, maxY = maxY, minY + } + return Rectangle26_6{ + Point26_6{ + Int26_6(minX << 6), + Int26_6(minY << 6), + }, + Point26_6{ + Int26_6(maxX << 6), + Int26_6(maxY << 6), + }, + } +} + +// Rectangle26_6 is a 26.6 fixed-point coordinate rectangle. The Min bound is +// inclusive and the Max bound is exclusive. It is well-formed if Min.X <= +// Max.X and likewise for Y. +// +// It is analogous to the image.Rectangle type in the standard library. +type Rectangle26_6 struct { + Min, Max Point26_6 +} + +// Rectangle52_12 is a 52.12 fixed-point coordinate rectangle. The Min bound is +// inclusive and the Max bound is exclusive. It is well-formed if Min.X <= +// Max.X and likewise for Y. +// +// It is analogous to the image.Rectangle type in the standard library. +type Rectangle52_12 struct { + Min, Max Point52_12 +} diff --git a/vendor/golang.org/x/image/tiff/buffer.go b/vendor/golang.org/x/image/tiff/buffer.go new file mode 100644 index 00000000..d1801be4 --- /dev/null +++ b/vendor/golang.org/x/image/tiff/buffer.go @@ -0,0 +1,69 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package tiff + +import "io" + +// buffer buffers an io.Reader to satisfy io.ReaderAt. +type buffer struct { + r io.Reader + buf []byte +} + +// fill reads data from b.r until the buffer contains at least end bytes. +func (b *buffer) fill(end int) error { + m := len(b.buf) + if end > m { + if end > cap(b.buf) { + newcap := 1024 + for newcap < end { + newcap *= 2 + } + newbuf := make([]byte, end, newcap) + copy(newbuf, b.buf) + b.buf = newbuf + } else { + b.buf = b.buf[:end] + } + if n, err := io.ReadFull(b.r, b.buf[m:end]); err != nil { + end = m + n + b.buf = b.buf[:end] + return err + } + } + return nil +} + +func (b *buffer) ReadAt(p []byte, off int64) (int, error) { + o := int(off) + end := o + len(p) + if int64(end) != off+int64(len(p)) { + return 0, io.ErrUnexpectedEOF + } + + err := b.fill(end) + return copy(p, b.buf[o:end]), err +} + +// Slice returns a slice of the underlying buffer. The slice contains +// n bytes starting at offset off. +func (b *buffer) Slice(off, n int) ([]byte, error) { + end := off + n + if err := b.fill(end); err != nil { + return nil, err + } + return b.buf[off:end], nil +} + +// newReaderAt converts an io.Reader into an io.ReaderAt. +func newReaderAt(r io.Reader) io.ReaderAt { + if ra, ok := r.(io.ReaderAt); ok { + return ra + } + return &buffer{ + r: r, + buf: make([]byte, 0, 1024), + } +} diff --git a/vendor/golang.org/x/image/tiff/compress.go b/vendor/golang.org/x/image/tiff/compress.go new file mode 100644 index 00000000..3f176f00 --- /dev/null +++ b/vendor/golang.org/x/image/tiff/compress.go @@ -0,0 +1,58 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package tiff + +import ( + "bufio" + "io" +) + +type byteReader interface { + io.Reader + io.ByteReader +} + +// unpackBits decodes the PackBits-compressed data in src and returns the +// uncompressed data. +// +// The PackBits compression format is described in section 9 (p. 42) +// of the TIFF spec. +func unpackBits(r io.Reader) ([]byte, error) { + buf := make([]byte, 128) + dst := make([]byte, 0, 1024) + br, ok := r.(byteReader) + if !ok { + br = bufio.NewReader(r) + } + + for { + b, err := br.ReadByte() + if err != nil { + if err == io.EOF { + return dst, nil + } + return nil, err + } + code := int(int8(b)) + switch { + case code >= 0: + n, err := io.ReadFull(br, buf[:code+1]) + if err != nil { + return nil, err + } + dst = append(dst, buf[:n]...) + case code == -128: + // No-op. + default: + if b, err = br.ReadByte(); err != nil { + return nil, err + } + for j := 0; j < 1-code; j++ { + buf[j] = b + } + dst = append(dst, buf[:1-code]...) + } + } +} diff --git a/vendor/golang.org/x/image/tiff/consts.go b/vendor/golang.org/x/image/tiff/consts.go new file mode 100644 index 00000000..3c51a70b --- /dev/null +++ b/vendor/golang.org/x/image/tiff/consts.go @@ -0,0 +1,133 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package tiff + +// A tiff image file contains one or more images. The metadata +// of each image is contained in an Image File Directory (IFD), +// which contains entries of 12 bytes each and is described +// on page 14-16 of the specification. An IFD entry consists of +// +// - a tag, which describes the signification of the entry, +// - the data type and length of the entry, +// - the data itself or a pointer to it if it is more than 4 bytes. +// +// The presence of a length means that each IFD is effectively an array. + +const ( + leHeader = "II\x2A\x00" // Header for little-endian files. + beHeader = "MM\x00\x2A" // Header for big-endian files. + + ifdLen = 12 // Length of an IFD entry in bytes. +) + +// Data types (p. 14-16 of the spec). +const ( + dtByte = 1 + dtASCII = 2 + dtShort = 3 + dtLong = 4 + dtRational = 5 +) + +// The length of one instance of each data type in bytes. +var lengths = [...]uint32{0, 1, 1, 2, 4, 8} + +// Tags (see p. 28-41 of the spec). +const ( + tImageWidth = 256 + tImageLength = 257 + tBitsPerSample = 258 + tCompression = 259 + tPhotometricInterpretation = 262 + + tStripOffsets = 273 + tSamplesPerPixel = 277 + tRowsPerStrip = 278 + tStripByteCounts = 279 + + tTileWidth = 322 + tTileLength = 323 + tTileOffsets = 324 + tTileByteCounts = 325 + + tXResolution = 282 + tYResolution = 283 + tResolutionUnit = 296 + + tPredictor = 317 + tColorMap = 320 + tExtraSamples = 338 + tSampleFormat = 339 +) + +// Compression types (defined in various places in the spec and supplements). +const ( + cNone = 1 + cCCITT = 2 + cG3 = 3 // Group 3 Fax. + cG4 = 4 // Group 4 Fax. + cLZW = 5 + cJPEGOld = 6 // Superseded by cJPEG. + cJPEG = 7 + cDeflate = 8 // zlib compression. + cPackBits = 32773 + cDeflateOld = 32946 // Superseded by cDeflate. +) + +// Photometric interpretation values (see p. 37 of the spec). +const ( + pWhiteIsZero = 0 + pBlackIsZero = 1 + pRGB = 2 + pPaletted = 3 + pTransMask = 4 // transparency mask + pCMYK = 5 + pYCbCr = 6 + pCIELab = 8 +) + +// Values for the tPredictor tag (page 64-65 of the spec). +const ( + prNone = 1 + prHorizontal = 2 +) + +// Values for the tResolutionUnit tag (page 18). +const ( + resNone = 1 + resPerInch = 2 // Dots per inch. + resPerCM = 3 // Dots per centimeter. +) + +// imageMode represents the mode of the image. +type imageMode int + +const ( + mBilevel imageMode = iota + mPaletted + mGray + mGrayInvert + mRGB + mRGBA + mNRGBA +) + +// CompressionType describes the type of compression used in Options. +type CompressionType int + +const ( + Uncompressed CompressionType = iota + Deflate +) + +// specValue returns the compression type constant from the TIFF spec that +// is equivalent to c. +func (c CompressionType) specValue() uint32 { + switch c { + case Deflate: + return cDeflate + } + return cNone +} diff --git a/vendor/golang.org/x/image/tiff/lzw/reader.go b/vendor/golang.org/x/image/tiff/lzw/reader.go new file mode 100644 index 00000000..ad35819f --- /dev/null +++ b/vendor/golang.org/x/image/tiff/lzw/reader.go @@ -0,0 +1,277 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package lzw implements the Lempel-Ziv-Welch compressed data format, +// described in T. A. Welch, ``A Technique for High-Performance Data +// Compression'', Computer, 17(6) (June 1984), pp 8-19. +// +// In particular, it implements LZW as used by the TIFF file format, including +// an "off by one" algorithmic difference when compared to standard LZW. +package lzw // import "golang.org/x/image/tiff/lzw" + +/* +This file was branched from src/pkg/compress/lzw/reader.go in the +standard library. Differences from the original are marked with "NOTE". + +The tif_lzw.c file in the libtiff C library has this comment: + +---- +The 5.0 spec describes a different algorithm than Aldus +implements. Specifically, Aldus does code length transitions +one code earlier than should be done (for real LZW). +Earlier versions of this library implemented the correct +LZW algorithm, but emitted codes in a bit order opposite +to the TIFF spec. Thus, to maintain compatibility w/ Aldus +we interpret MSB-LSB ordered codes to be images written w/ +old versions of this library, but otherwise adhere to the +Aldus "off by one" algorithm. +---- + +The Go code doesn't read (invalid) TIFF files written by old versions of +libtiff, but the LZW algorithm in this package still differs from the one in +Go's standard package library to accomodate this "off by one" in valid TIFFs. +*/ + +import ( + "bufio" + "errors" + "fmt" + "io" +) + +// Order specifies the bit ordering in an LZW data stream. +type Order int + +const ( + // LSB means Least Significant Bits first, as used in the GIF file format. + LSB Order = iota + // MSB means Most Significant Bits first, as used in the TIFF and PDF + // file formats. + MSB +) + +const ( + maxWidth = 12 + decoderInvalidCode = 0xffff + flushBuffer = 1 << maxWidth +) + +// decoder is the state from which the readXxx method converts a byte +// stream into a code stream. +type decoder struct { + r io.ByteReader + bits uint32 + nBits uint + width uint + read func(*decoder) (uint16, error) // readLSB or readMSB + litWidth int // width in bits of literal codes + err error + + // The first 1<= 1<>= d.width + d.nBits -= d.width + return code, nil +} + +// readMSB returns the next code for "Most Significant Bits first" data. +func (d *decoder) readMSB() (uint16, error) { + for d.nBits < d.width { + x, err := d.r.ReadByte() + if err != nil { + return 0, err + } + d.bits |= uint32(x) << (24 - d.nBits) + d.nBits += 8 + } + code := uint16(d.bits >> (32 - d.width)) + d.bits <<= d.width + d.nBits -= d.width + return code, nil +} + +func (d *decoder) Read(b []byte) (int, error) { + for { + if len(d.toRead) > 0 { + n := copy(b, d.toRead) + d.toRead = d.toRead[n:] + return n, nil + } + if d.err != nil { + return 0, d.err + } + d.decode() + } +} + +// decode decompresses bytes from r and leaves them in d.toRead. +// read specifies how to decode bytes into codes. +// litWidth is the width in bits of literal codes. +func (d *decoder) decode() { + // Loop over the code stream, converting codes into decompressed bytes. + for { + code, err := d.read(d) + if err != nil { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + d.err = err + d.flush() + return + } + switch { + case code < d.clear: + // We have a literal code. + d.output[d.o] = uint8(code) + d.o++ + if d.last != decoderInvalidCode { + // Save what the hi code expands to. + d.suffix[d.hi] = uint8(code) + d.prefix[d.hi] = d.last + } + case code == d.clear: + d.width = 1 + uint(d.litWidth) + d.hi = d.eof + d.overflow = 1 << d.width + d.last = decoderInvalidCode + continue + case code == d.eof: + d.flush() + d.err = io.EOF + return + case code <= d.hi: + c, i := code, len(d.output)-1 + if code == d.hi { + // code == hi is a special case which expands to the last expansion + // followed by the head of the last expansion. To find the head, we walk + // the prefix chain until we find a literal code. + c = d.last + for c >= d.clear { + c = d.prefix[c] + } + d.output[i] = uint8(c) + i-- + c = d.last + } + // Copy the suffix chain into output and then write that to w. + for c >= d.clear { + d.output[i] = d.suffix[c] + i-- + c = d.prefix[c] + } + d.output[i] = uint8(c) + d.o += copy(d.output[d.o:], d.output[i:]) + if d.last != decoderInvalidCode { + // Save what the hi code expands to. + d.suffix[d.hi] = uint8(c) + d.prefix[d.hi] = d.last + } + default: + d.err = errors.New("lzw: invalid code") + d.flush() + return + } + d.last, d.hi = code, d.hi+1 + if d.hi+1 >= d.overflow { // NOTE: the "+1" is where TIFF's LZW differs from the standard algorithm. + if d.width == maxWidth { + d.last = decoderInvalidCode + } else { + d.width++ + d.overflow <<= 1 + } + } + if d.o >= flushBuffer { + d.flush() + return + } + } +} + +func (d *decoder) flush() { + d.toRead = d.output[:d.o] + d.o = 0 +} + +var errClosed = errors.New("lzw: reader/writer is closed") + +func (d *decoder) Close() error { + d.err = errClosed // in case any Reads come along + return nil +} + +// NewReader creates a new io.ReadCloser. +// Reads from the returned io.ReadCloser read and decompress data from r. +// If r does not also implement io.ByteReader, +// the decompressor may read more data than necessary from r. +// It is the caller's responsibility to call Close on the ReadCloser when +// finished reading. +// The number of bits to use for literal codes, litWidth, must be in the +// range [2,8] and is typically 8. It must equal the litWidth +// used during compression. +func NewReader(r io.Reader, order Order, litWidth int) io.ReadCloser { + d := new(decoder) + switch order { + case LSB: + d.read = (*decoder).readLSB + case MSB: + d.read = (*decoder).readMSB + default: + d.err = errors.New("lzw: unknown order") + return d + } + if litWidth < 2 || 8 < litWidth { + d.err = fmt.Errorf("lzw: litWidth %d out of range", litWidth) + return d + } + if br, ok := r.(io.ByteReader); ok { + d.r = br + } else { + d.r = bufio.NewReader(r) + } + d.litWidth = litWidth + d.width = 1 + uint(litWidth) + d.clear = uint16(1) << uint(litWidth) + d.eof, d.hi = d.clear+1, d.clear+1 + d.overflow = uint16(1) << d.width + d.last = decoderInvalidCode + + return d +} diff --git a/vendor/golang.org/x/image/tiff/reader.go b/vendor/golang.org/x/image/tiff/reader.go new file mode 100644 index 00000000..df39e828 --- /dev/null +++ b/vendor/golang.org/x/image/tiff/reader.go @@ -0,0 +1,681 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package tiff implements a TIFF image decoder and encoder. +// +// The TIFF specification is at http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf +package tiff // import "golang.org/x/image/tiff" + +import ( + "compress/zlib" + "encoding/binary" + "fmt" + "image" + "image/color" + "io" + "io/ioutil" + "math" + + "golang.org/x/image/tiff/lzw" +) + +// A FormatError reports that the input is not a valid TIFF image. +type FormatError string + +func (e FormatError) Error() string { + return "tiff: invalid format: " + string(e) +} + +// An UnsupportedError reports that the input uses a valid but +// unimplemented feature. +type UnsupportedError string + +func (e UnsupportedError) Error() string { + return "tiff: unsupported feature: " + string(e) +} + +// An InternalError reports that an internal error was encountered. +type InternalError string + +func (e InternalError) Error() string { + return "tiff: internal error: " + string(e) +} + +var errNoPixels = FormatError("not enough pixel data") + +type decoder struct { + r io.ReaderAt + byteOrder binary.ByteOrder + config image.Config + mode imageMode + bpp uint + features map[int][]uint + palette []color.Color + + buf []byte + off int // Current offset in buf. + v uint32 // Buffer value for reading with arbitrary bit depths. + nbits uint // Remaining number of bits in v. +} + +// firstVal returns the first uint of the features entry with the given tag, +// or 0 if the tag does not exist. +func (d *decoder) firstVal(tag int) uint { + f := d.features[tag] + if len(f) == 0 { + return 0 + } + return f[0] +} + +// ifdUint decodes the IFD entry in p, which must be of the Byte, Short +// or Long type, and returns the decoded uint values. +func (d *decoder) ifdUint(p []byte) (u []uint, err error) { + var raw []byte + if len(p) < ifdLen { + return nil, FormatError("bad IFD entry") + } + + datatype := d.byteOrder.Uint16(p[2:4]) + if dt := int(datatype); dt <= 0 || dt >= len(lengths) { + return nil, UnsupportedError("IFD entry datatype") + } + + count := d.byteOrder.Uint32(p[4:8]) + if count > math.MaxInt32/lengths[datatype] { + return nil, FormatError("IFD data too large") + } + if datalen := lengths[datatype] * count; datalen > 4 { + // The IFD contains a pointer to the real value. + raw = make([]byte, datalen) + _, err = d.r.ReadAt(raw, int64(d.byteOrder.Uint32(p[8:12]))) + } else { + raw = p[8 : 8+datalen] + } + if err != nil { + return nil, err + } + + u = make([]uint, count) + switch datatype { + case dtByte: + for i := uint32(0); i < count; i++ { + u[i] = uint(raw[i]) + } + case dtShort: + for i := uint32(0); i < count; i++ { + u[i] = uint(d.byteOrder.Uint16(raw[2*i : 2*(i+1)])) + } + case dtLong: + for i := uint32(0); i < count; i++ { + u[i] = uint(d.byteOrder.Uint32(raw[4*i : 4*(i+1)])) + } + default: + return nil, UnsupportedError("data type") + } + return u, nil +} + +// parseIFD decides whether the the IFD entry in p is "interesting" and +// stows away the data in the decoder. +func (d *decoder) parseIFD(p []byte) error { + tag := d.byteOrder.Uint16(p[0:2]) + switch tag { + case tBitsPerSample, + tExtraSamples, + tPhotometricInterpretation, + tCompression, + tPredictor, + tStripOffsets, + tStripByteCounts, + tRowsPerStrip, + tTileWidth, + tTileLength, + tTileOffsets, + tTileByteCounts, + tImageLength, + tImageWidth: + val, err := d.ifdUint(p) + if err != nil { + return err + } + d.features[int(tag)] = val + case tColorMap: + val, err := d.ifdUint(p) + if err != nil { + return err + } + numcolors := len(val) / 3 + if len(val)%3 != 0 || numcolors <= 0 || numcolors > 256 { + return FormatError("bad ColorMap length") + } + d.palette = make([]color.Color, numcolors) + for i := 0; i < numcolors; i++ { + d.palette[i] = color.RGBA64{ + uint16(val[i]), + uint16(val[i+numcolors]), + uint16(val[i+2*numcolors]), + 0xffff, + } + } + case tSampleFormat: + // Page 27 of the spec: If the SampleFormat is present and + // the value is not 1 [= unsigned integer data], a Baseline + // TIFF reader that cannot handle the SampleFormat value + // must terminate the import process gracefully. + val, err := d.ifdUint(p) + if err != nil { + return err + } + for _, v := range val { + if v != 1 { + return UnsupportedError("sample format") + } + } + } + return nil +} + +// readBits reads n bits from the internal buffer starting at the current offset. +func (d *decoder) readBits(n uint) (v uint32, ok bool) { + for d.nbits < n { + d.v <<= 8 + if d.off >= len(d.buf) { + return 0, false + } + d.v |= uint32(d.buf[d.off]) + d.off++ + d.nbits += 8 + } + d.nbits -= n + rv := d.v >> d.nbits + d.v &^= rv << d.nbits + return rv, true +} + +// flushBits discards the unread bits in the buffer used by readBits. +// It is used at the end of a line. +func (d *decoder) flushBits() { + d.v = 0 + d.nbits = 0 +} + +// minInt returns the smaller of x or y. +func minInt(a, b int) int { + if a <= b { + return a + } + return b +} + +// decode decodes the raw data of an image. +// It reads from d.buf and writes the strip or tile into dst. +func (d *decoder) decode(dst image.Image, xmin, ymin, xmax, ymax int) error { + d.off = 0 + + // Apply horizontal predictor if necessary. + // In this case, p contains the color difference to the preceding pixel. + // See page 64-65 of the spec. + if d.firstVal(tPredictor) == prHorizontal { + switch d.bpp { + case 16: + var off int + n := 2 * len(d.features[tBitsPerSample]) // bytes per sample times samples per pixel + for y := ymin; y < ymax; y++ { + off += n + for x := 0; x < (xmax-xmin-1)*n; x += 2 { + if off+2 > len(d.buf) { + return errNoPixels + } + v0 := d.byteOrder.Uint16(d.buf[off-n : off-n+2]) + v1 := d.byteOrder.Uint16(d.buf[off : off+2]) + d.byteOrder.PutUint16(d.buf[off:off+2], v1+v0) + off += 2 + } + } + case 8: + var off int + n := 1 * len(d.features[tBitsPerSample]) // bytes per sample times samples per pixel + for y := ymin; y < ymax; y++ { + off += n + for x := 0; x < (xmax-xmin-1)*n; x++ { + if off >= len(d.buf) { + return errNoPixels + } + d.buf[off] += d.buf[off-n] + off++ + } + } + case 1: + return UnsupportedError("horizontal predictor with 1 BitsPerSample") + } + } + + rMaxX := minInt(xmax, dst.Bounds().Max.X) + rMaxY := minInt(ymax, dst.Bounds().Max.Y) + switch d.mode { + case mGray, mGrayInvert: + if d.bpp == 16 { + img := dst.(*image.Gray16) + for y := ymin; y < rMaxY; y++ { + for x := xmin; x < rMaxX; x++ { + if d.off+2 > len(d.buf) { + return errNoPixels + } + v := d.byteOrder.Uint16(d.buf[d.off : d.off+2]) + d.off += 2 + if d.mode == mGrayInvert { + v = 0xffff - v + } + img.SetGray16(x, y, color.Gray16{v}) + } + } + } else { + img := dst.(*image.Gray) + max := uint32((1 << d.bpp) - 1) + for y := ymin; y < rMaxY; y++ { + for x := xmin; x < rMaxX; x++ { + v, ok := d.readBits(d.bpp) + if !ok { + return errNoPixels + } + v = v * 0xff / max + if d.mode == mGrayInvert { + v = 0xff - v + } + img.SetGray(x, y, color.Gray{uint8(v)}) + } + d.flushBits() + } + } + case mPaletted: + img := dst.(*image.Paletted) + for y := ymin; y < rMaxY; y++ { + for x := xmin; x < rMaxX; x++ { + v, ok := d.readBits(d.bpp) + if !ok { + return errNoPixels + } + img.SetColorIndex(x, y, uint8(v)) + } + d.flushBits() + } + case mRGB: + if d.bpp == 16 { + img := dst.(*image.RGBA64) + for y := ymin; y < rMaxY; y++ { + for x := xmin; x < rMaxX; x++ { + if d.off+6 > len(d.buf) { + return errNoPixels + } + r := d.byteOrder.Uint16(d.buf[d.off+0 : d.off+2]) + g := d.byteOrder.Uint16(d.buf[d.off+2 : d.off+4]) + b := d.byteOrder.Uint16(d.buf[d.off+4 : d.off+6]) + d.off += 6 + img.SetRGBA64(x, y, color.RGBA64{r, g, b, 0xffff}) + } + } + } else { + img := dst.(*image.RGBA) + for y := ymin; y < rMaxY; y++ { + min := img.PixOffset(xmin, y) + max := img.PixOffset(rMaxX, y) + off := (y - ymin) * (xmax - xmin) * 3 + for i := min; i < max; i += 4 { + if off+3 > len(d.buf) { + return errNoPixels + } + img.Pix[i+0] = d.buf[off+0] + img.Pix[i+1] = d.buf[off+1] + img.Pix[i+2] = d.buf[off+2] + img.Pix[i+3] = 0xff + off += 3 + } + } + } + case mNRGBA: + if d.bpp == 16 { + img := dst.(*image.NRGBA64) + for y := ymin; y < rMaxY; y++ { + for x := xmin; x < rMaxX; x++ { + if d.off+8 > len(d.buf) { + return errNoPixels + } + r := d.byteOrder.Uint16(d.buf[d.off+0 : d.off+2]) + g := d.byteOrder.Uint16(d.buf[d.off+2 : d.off+4]) + b := d.byteOrder.Uint16(d.buf[d.off+4 : d.off+6]) + a := d.byteOrder.Uint16(d.buf[d.off+6 : d.off+8]) + d.off += 8 + img.SetNRGBA64(x, y, color.NRGBA64{r, g, b, a}) + } + } + } else { + img := dst.(*image.NRGBA) + for y := ymin; y < rMaxY; y++ { + min := img.PixOffset(xmin, y) + max := img.PixOffset(rMaxX, y) + i0, i1 := (y-ymin)*(xmax-xmin)*4, (y-ymin+1)*(xmax-xmin)*4 + if i1 > len(d.buf) { + return errNoPixels + } + copy(img.Pix[min:max], d.buf[i0:i1]) + } + } + case mRGBA: + if d.bpp == 16 { + img := dst.(*image.RGBA64) + for y := ymin; y < rMaxY; y++ { + for x := xmin; x < rMaxX; x++ { + if d.off+8 > len(d.buf) { + return errNoPixels + } + r := d.byteOrder.Uint16(d.buf[d.off+0 : d.off+2]) + g := d.byteOrder.Uint16(d.buf[d.off+2 : d.off+4]) + b := d.byteOrder.Uint16(d.buf[d.off+4 : d.off+6]) + a := d.byteOrder.Uint16(d.buf[d.off+6 : d.off+8]) + d.off += 8 + img.SetRGBA64(x, y, color.RGBA64{r, g, b, a}) + } + } + } else { + img := dst.(*image.RGBA) + for y := ymin; y < rMaxY; y++ { + min := img.PixOffset(xmin, y) + max := img.PixOffset(rMaxX, y) + i0, i1 := (y-ymin)*(xmax-xmin)*4, (y-ymin+1)*(xmax-xmin)*4 + if i1 > len(d.buf) { + return errNoPixels + } + copy(img.Pix[min:max], d.buf[i0:i1]) + } + } + } + + return nil +} + +func newDecoder(r io.Reader) (*decoder, error) { + d := &decoder{ + r: newReaderAt(r), + features: make(map[int][]uint), + } + + p := make([]byte, 8) + if _, err := d.r.ReadAt(p, 0); err != nil { + return nil, err + } + switch string(p[0:4]) { + case leHeader: + d.byteOrder = binary.LittleEndian + case beHeader: + d.byteOrder = binary.BigEndian + default: + return nil, FormatError("malformed header") + } + + ifdOffset := int64(d.byteOrder.Uint32(p[4:8])) + + // The first two bytes contain the number of entries (12 bytes each). + if _, err := d.r.ReadAt(p[0:2], ifdOffset); err != nil { + return nil, err + } + numItems := int(d.byteOrder.Uint16(p[0:2])) + + // All IFD entries are read in one chunk. + p = make([]byte, ifdLen*numItems) + if _, err := d.r.ReadAt(p, ifdOffset+2); err != nil { + return nil, err + } + + for i := 0; i < len(p); i += ifdLen { + if err := d.parseIFD(p[i : i+ifdLen]); err != nil { + return nil, err + } + } + + d.config.Width = int(d.firstVal(tImageWidth)) + d.config.Height = int(d.firstVal(tImageLength)) + + if _, ok := d.features[tBitsPerSample]; !ok { + return nil, FormatError("BitsPerSample tag missing") + } + d.bpp = d.firstVal(tBitsPerSample) + switch d.bpp { + case 0: + return nil, FormatError("BitsPerSample must not be 0") + case 1, 8, 16: + // Nothing to do, these are accepted by this implementation. + default: + return nil, UnsupportedError(fmt.Sprintf("BitsPerSample of %v", d.bpp)) + } + + // Determine the image mode. + switch d.firstVal(tPhotometricInterpretation) { + case pRGB: + if d.bpp == 16 { + for _, b := range d.features[tBitsPerSample] { + if b != 16 { + return nil, FormatError("wrong number of samples for 16bit RGB") + } + } + } else { + for _, b := range d.features[tBitsPerSample] { + if b != 8 { + return nil, FormatError("wrong number of samples for 8bit RGB") + } + } + } + // RGB images normally have 3 samples per pixel. + // If there are more, ExtraSamples (p. 31-32 of the spec) + // gives their meaning (usually an alpha channel). + // + // This implementation does not support extra samples + // of an unspecified type. + switch len(d.features[tBitsPerSample]) { + case 3: + d.mode = mRGB + if d.bpp == 16 { + d.config.ColorModel = color.RGBA64Model + } else { + d.config.ColorModel = color.RGBAModel + } + case 4: + switch d.firstVal(tExtraSamples) { + case 1: + d.mode = mRGBA + if d.bpp == 16 { + d.config.ColorModel = color.RGBA64Model + } else { + d.config.ColorModel = color.RGBAModel + } + case 2: + d.mode = mNRGBA + if d.bpp == 16 { + d.config.ColorModel = color.NRGBA64Model + } else { + d.config.ColorModel = color.NRGBAModel + } + default: + return nil, FormatError("wrong number of samples for RGB") + } + default: + return nil, FormatError("wrong number of samples for RGB") + } + case pPaletted: + d.mode = mPaletted + d.config.ColorModel = color.Palette(d.palette) + case pWhiteIsZero: + d.mode = mGrayInvert + if d.bpp == 16 { + d.config.ColorModel = color.Gray16Model + } else { + d.config.ColorModel = color.GrayModel + } + case pBlackIsZero: + d.mode = mGray + if d.bpp == 16 { + d.config.ColorModel = color.Gray16Model + } else { + d.config.ColorModel = color.GrayModel + } + default: + return nil, UnsupportedError("color model") + } + + return d, nil +} + +// DecodeConfig returns the color model and dimensions of a TIFF image without +// decoding the entire image. +func DecodeConfig(r io.Reader) (image.Config, error) { + d, err := newDecoder(r) + if err != nil { + return image.Config{}, err + } + return d.config, nil +} + +// Decode reads a TIFF image from r and returns it as an image.Image. +// The type of Image returned depends on the contents of the TIFF. +func Decode(r io.Reader) (img image.Image, err error) { + d, err := newDecoder(r) + if err != nil { + return + } + + blockPadding := false + blockWidth := d.config.Width + blockHeight := d.config.Height + blocksAcross := 1 + blocksDown := 1 + + if d.config.Width == 0 { + blocksAcross = 0 + } + if d.config.Height == 0 { + blocksDown = 0 + } + + var blockOffsets, blockCounts []uint + + if int(d.firstVal(tTileWidth)) != 0 { + blockPadding = true + + blockWidth = int(d.firstVal(tTileWidth)) + blockHeight = int(d.firstVal(tTileLength)) + + if blockWidth != 0 { + blocksAcross = (d.config.Width + blockWidth - 1) / blockWidth + } + if blockHeight != 0 { + blocksDown = (d.config.Height + blockHeight - 1) / blockHeight + } + + blockCounts = d.features[tTileByteCounts] + blockOffsets = d.features[tTileOffsets] + + } else { + if int(d.firstVal(tRowsPerStrip)) != 0 { + blockHeight = int(d.firstVal(tRowsPerStrip)) + } + + if blockHeight != 0 { + blocksDown = (d.config.Height + blockHeight - 1) / blockHeight + } + + blockOffsets = d.features[tStripOffsets] + blockCounts = d.features[tStripByteCounts] + } + + // Check if we have the right number of strips/tiles, offsets and counts. + if n := blocksAcross * blocksDown; len(blockOffsets) < n || len(blockCounts) < n { + return nil, FormatError("inconsistent header") + } + + imgRect := image.Rect(0, 0, d.config.Width, d.config.Height) + switch d.mode { + case mGray, mGrayInvert: + if d.bpp == 16 { + img = image.NewGray16(imgRect) + } else { + img = image.NewGray(imgRect) + } + case mPaletted: + img = image.NewPaletted(imgRect, d.palette) + case mNRGBA: + if d.bpp == 16 { + img = image.NewNRGBA64(imgRect) + } else { + img = image.NewNRGBA(imgRect) + } + case mRGB, mRGBA: + if d.bpp == 16 { + img = image.NewRGBA64(imgRect) + } else { + img = image.NewRGBA(imgRect) + } + } + + for i := 0; i < blocksAcross; i++ { + blkW := blockWidth + if !blockPadding && i == blocksAcross-1 && d.config.Width%blockWidth != 0 { + blkW = d.config.Width % blockWidth + } + for j := 0; j < blocksDown; j++ { + blkH := blockHeight + if !blockPadding && j == blocksDown-1 && d.config.Height%blockHeight != 0 { + blkH = d.config.Height % blockHeight + } + offset := int64(blockOffsets[j*blocksAcross+i]) + n := int64(blockCounts[j*blocksAcross+i]) + switch d.firstVal(tCompression) { + + // According to the spec, Compression does not have a default value, + // but some tools interpret a missing Compression value as none so we do + // the same. + case cNone, 0: + if b, ok := d.r.(*buffer); ok { + d.buf, err = b.Slice(int(offset), int(n)) + } else { + d.buf = make([]byte, n) + _, err = d.r.ReadAt(d.buf, offset) + } + case cLZW: + r := lzw.NewReader(io.NewSectionReader(d.r, offset, n), lzw.MSB, 8) + d.buf, err = ioutil.ReadAll(r) + r.Close() + case cDeflate, cDeflateOld: + var r io.ReadCloser + r, err = zlib.NewReader(io.NewSectionReader(d.r, offset, n)) + if err != nil { + return nil, err + } + d.buf, err = ioutil.ReadAll(r) + r.Close() + case cPackBits: + d.buf, err = unpackBits(io.NewSectionReader(d.r, offset, n)) + default: + err = UnsupportedError(fmt.Sprintf("compression value %d", d.firstVal(tCompression))) + } + if err != nil { + return nil, err + } + + xmin := i * blockWidth + ymin := j * blockHeight + xmax := xmin + blkW + ymax := ymin + blkH + err = d.decode(img, xmin, ymin, xmax, ymax) + if err != nil { + return nil, err + } + } + } + return +} + +func init() { + image.RegisterFormat("tiff", leHeader, Decode, DecodeConfig) + image.RegisterFormat("tiff", beHeader, Decode, DecodeConfig) +} diff --git a/vendor/golang.org/x/image/tiff/writer.go b/vendor/golang.org/x/image/tiff/writer.go new file mode 100644 index 00000000..c8a01cea --- /dev/null +++ b/vendor/golang.org/x/image/tiff/writer.go @@ -0,0 +1,438 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package tiff + +import ( + "bytes" + "compress/zlib" + "encoding/binary" + "image" + "io" + "sort" +) + +// The TIFF format allows to choose the order of the different elements freely. +// The basic structure of a TIFF file written by this package is: +// +// 1. Header (8 bytes). +// 2. Image data. +// 3. Image File Directory (IFD). +// 4. "Pointer area" for larger entries in the IFD. + +// We only write little-endian TIFF files. +var enc = binary.LittleEndian + +// An ifdEntry is a single entry in an Image File Directory. +// A value of type dtRational is composed of two 32-bit values, +// thus data contains two uints (numerator and denominator) for a single number. +type ifdEntry struct { + tag int + datatype int + data []uint32 +} + +func (e ifdEntry) putData(p []byte) { + for _, d := range e.data { + switch e.datatype { + case dtByte, dtASCII: + p[0] = byte(d) + p = p[1:] + case dtShort: + enc.PutUint16(p, uint16(d)) + p = p[2:] + case dtLong, dtRational: + enc.PutUint32(p, uint32(d)) + p = p[4:] + } + } +} + +type byTag []ifdEntry + +func (d byTag) Len() int { return len(d) } +func (d byTag) Less(i, j int) bool { return d[i].tag < d[j].tag } +func (d byTag) Swap(i, j int) { d[i], d[j] = d[j], d[i] } + +func encodeGray(w io.Writer, pix []uint8, dx, dy, stride int, predictor bool) error { + if !predictor { + return writePix(w, pix, dy, dx, stride) + } + buf := make([]byte, dx) + for y := 0; y < dy; y++ { + min := y*stride + 0 + max := y*stride + dx + off := 0 + var v0 uint8 + for i := min; i < max; i++ { + v1 := pix[i] + buf[off] = v1 - v0 + v0 = v1 + off++ + } + if _, err := w.Write(buf); err != nil { + return err + } + } + return nil +} + +func encodeGray16(w io.Writer, pix []uint8, dx, dy, stride int, predictor bool) error { + buf := make([]byte, dx*2) + for y := 0; y < dy; y++ { + min := y*stride + 0 + max := y*stride + dx*2 + off := 0 + var v0 uint16 + for i := min; i < max; i += 2 { + // An image.Gray16's Pix is in big-endian order. + v1 := uint16(pix[i])<<8 | uint16(pix[i+1]) + if predictor { + v0, v1 = v1, v1-v0 + } + // We only write little-endian TIFF files. + buf[off+0] = byte(v1) + buf[off+1] = byte(v1 >> 8) + off += 2 + } + if _, err := w.Write(buf); err != nil { + return err + } + } + return nil +} + +func encodeRGBA(w io.Writer, pix []uint8, dx, dy, stride int, predictor bool) error { + if !predictor { + return writePix(w, pix, dy, dx*4, stride) + } + buf := make([]byte, dx*4) + for y := 0; y < dy; y++ { + min := y*stride + 0 + max := y*stride + dx*4 + off := 0 + var r0, g0, b0, a0 uint8 + for i := min; i < max; i += 4 { + r1, g1, b1, a1 := pix[i+0], pix[i+1], pix[i+2], pix[i+3] + buf[off+0] = r1 - r0 + buf[off+1] = g1 - g0 + buf[off+2] = b1 - b0 + buf[off+3] = a1 - a0 + off += 4 + r0, g0, b0, a0 = r1, g1, b1, a1 + } + if _, err := w.Write(buf); err != nil { + return err + } + } + return nil +} + +func encodeRGBA64(w io.Writer, pix []uint8, dx, dy, stride int, predictor bool) error { + buf := make([]byte, dx*8) + for y := 0; y < dy; y++ { + min := y*stride + 0 + max := y*stride + dx*8 + off := 0 + var r0, g0, b0, a0 uint16 + for i := min; i < max; i += 8 { + // An image.RGBA64's Pix is in big-endian order. + r1 := uint16(pix[i+0])<<8 | uint16(pix[i+1]) + g1 := uint16(pix[i+2])<<8 | uint16(pix[i+3]) + b1 := uint16(pix[i+4])<<8 | uint16(pix[i+5]) + a1 := uint16(pix[i+6])<<8 | uint16(pix[i+7]) + if predictor { + r0, r1 = r1, r1-r0 + g0, g1 = g1, g1-g0 + b0, b1 = b1, b1-b0 + a0, a1 = a1, a1-a0 + } + // We only write little-endian TIFF files. + buf[off+0] = byte(r1) + buf[off+1] = byte(r1 >> 8) + buf[off+2] = byte(g1) + buf[off+3] = byte(g1 >> 8) + buf[off+4] = byte(b1) + buf[off+5] = byte(b1 >> 8) + buf[off+6] = byte(a1) + buf[off+7] = byte(a1 >> 8) + off += 8 + } + if _, err := w.Write(buf); err != nil { + return err + } + } + return nil +} + +func encode(w io.Writer, m image.Image, predictor bool) error { + bounds := m.Bounds() + buf := make([]byte, 4*bounds.Dx()) + for y := bounds.Min.Y; y < bounds.Max.Y; y++ { + off := 0 + if predictor { + var r0, g0, b0, a0 uint8 + for x := bounds.Min.X; x < bounds.Max.X; x++ { + r, g, b, a := m.At(x, y).RGBA() + r1 := uint8(r >> 8) + g1 := uint8(g >> 8) + b1 := uint8(b >> 8) + a1 := uint8(a >> 8) + buf[off+0] = r1 - r0 + buf[off+1] = g1 - g0 + buf[off+2] = b1 - b0 + buf[off+3] = a1 - a0 + off += 4 + r0, g0, b0, a0 = r1, g1, b1, a1 + } + } else { + for x := bounds.Min.X; x < bounds.Max.X; x++ { + r, g, b, a := m.At(x, y).RGBA() + buf[off+0] = uint8(r >> 8) + buf[off+1] = uint8(g >> 8) + buf[off+2] = uint8(b >> 8) + buf[off+3] = uint8(a >> 8) + off += 4 + } + } + if _, err := w.Write(buf); err != nil { + return err + } + } + return nil +} + +// writePix writes the internal byte array of an image to w. It is less general +// but much faster then encode. writePix is used when pix directly +// corresponds to one of the TIFF image types. +func writePix(w io.Writer, pix []byte, nrows, length, stride int) error { + if length == stride { + _, err := w.Write(pix[:nrows*length]) + return err + } + for ; nrows > 0; nrows-- { + if _, err := w.Write(pix[:length]); err != nil { + return err + } + pix = pix[stride:] + } + return nil +} + +func writeIFD(w io.Writer, ifdOffset int, d []ifdEntry) error { + var buf [ifdLen]byte + // Make space for "pointer area" containing IFD entry data + // longer than 4 bytes. + parea := make([]byte, 1024) + pstart := ifdOffset + ifdLen*len(d) + 6 + var o int // Current offset in parea. + + // The IFD has to be written with the tags in ascending order. + sort.Sort(byTag(d)) + + // Write the number of entries in this IFD. + if err := binary.Write(w, enc, uint16(len(d))); err != nil { + return err + } + for _, ent := range d { + enc.PutUint16(buf[0:2], uint16(ent.tag)) + enc.PutUint16(buf[2:4], uint16(ent.datatype)) + count := uint32(len(ent.data)) + if ent.datatype == dtRational { + count /= 2 + } + enc.PutUint32(buf[4:8], count) + datalen := int(count * lengths[ent.datatype]) + if datalen <= 4 { + ent.putData(buf[8:12]) + } else { + if (o + datalen) > len(parea) { + newlen := len(parea) + 1024 + for (o + datalen) > newlen { + newlen += 1024 + } + newarea := make([]byte, newlen) + copy(newarea, parea) + parea = newarea + } + ent.putData(parea[o : o+datalen]) + enc.PutUint32(buf[8:12], uint32(pstart+o)) + o += datalen + } + if _, err := w.Write(buf[:]); err != nil { + return err + } + } + // The IFD ends with the offset of the next IFD in the file, + // or zero if it is the last one (page 14). + if err := binary.Write(w, enc, uint32(0)); err != nil { + return err + } + _, err := w.Write(parea[:o]) + return err +} + +// Options are the encoding parameters. +type Options struct { + // Compression is the type of compression used. + Compression CompressionType + // Predictor determines whether a differencing predictor is used; + // if true, instead of each pixel's color, the color difference to the + // preceding one is saved. This improves the compression for certain + // types of images and compressors. For example, it works well for + // photos with Deflate compression. + Predictor bool +} + +// Encode writes the image m to w. opt determines the options used for +// encoding, such as the compression type. If opt is nil, an uncompressed +// image is written. +func Encode(w io.Writer, m image.Image, opt *Options) error { + d := m.Bounds().Size() + + compression := uint32(cNone) + predictor := false + if opt != nil { + compression = opt.Compression.specValue() + // The predictor field is only used with LZW. See page 64 of the spec. + predictor = opt.Predictor && compression == cLZW + } + + _, err := io.WriteString(w, leHeader) + if err != nil { + return err + } + + // Compressed data is written into a buffer first, so that we + // know the compressed size. + var buf bytes.Buffer + // dst holds the destination for the pixel data of the image -- + // either w or a writer to buf. + var dst io.Writer + // imageLen is the length of the pixel data in bytes. + // The offset of the IFD is imageLen + 8 header bytes. + var imageLen int + + switch compression { + case cNone: + dst = w + // Write IFD offset before outputting pixel data. + switch m.(type) { + case *image.Paletted: + imageLen = d.X * d.Y * 1 + case *image.Gray: + imageLen = d.X * d.Y * 1 + case *image.Gray16: + imageLen = d.X * d.Y * 2 + case *image.RGBA64: + imageLen = d.X * d.Y * 8 + case *image.NRGBA64: + imageLen = d.X * d.Y * 8 + default: + imageLen = d.X * d.Y * 4 + } + err = binary.Write(w, enc, uint32(imageLen+8)) + if err != nil { + return err + } + case cDeflate: + dst = zlib.NewWriter(&buf) + } + + pr := uint32(prNone) + photometricInterpretation := uint32(pRGB) + samplesPerPixel := uint32(4) + bitsPerSample := []uint32{8, 8, 8, 8} + extraSamples := uint32(0) + colorMap := []uint32{} + + if predictor { + pr = prHorizontal + } + switch m := m.(type) { + case *image.Paletted: + photometricInterpretation = pPaletted + samplesPerPixel = 1 + bitsPerSample = []uint32{8} + colorMap = make([]uint32, 256*3) + for i := 0; i < 256 && i < len(m.Palette); i++ { + r, g, b, _ := m.Palette[i].RGBA() + colorMap[i+0*256] = uint32(r) + colorMap[i+1*256] = uint32(g) + colorMap[i+2*256] = uint32(b) + } + err = encodeGray(dst, m.Pix, d.X, d.Y, m.Stride, predictor) + case *image.Gray: + photometricInterpretation = pBlackIsZero + samplesPerPixel = 1 + bitsPerSample = []uint32{8} + err = encodeGray(dst, m.Pix, d.X, d.Y, m.Stride, predictor) + case *image.Gray16: + photometricInterpretation = pBlackIsZero + samplesPerPixel = 1 + bitsPerSample = []uint32{16} + err = encodeGray16(dst, m.Pix, d.X, d.Y, m.Stride, predictor) + case *image.NRGBA: + extraSamples = 2 // Unassociated alpha. + err = encodeRGBA(dst, m.Pix, d.X, d.Y, m.Stride, predictor) + case *image.NRGBA64: + extraSamples = 2 // Unassociated alpha. + bitsPerSample = []uint32{16, 16, 16, 16} + err = encodeRGBA64(dst, m.Pix, d.X, d.Y, m.Stride, predictor) + case *image.RGBA: + extraSamples = 1 // Associated alpha. + err = encodeRGBA(dst, m.Pix, d.X, d.Y, m.Stride, predictor) + case *image.RGBA64: + extraSamples = 1 // Associated alpha. + bitsPerSample = []uint32{16, 16, 16, 16} + err = encodeRGBA64(dst, m.Pix, d.X, d.Y, m.Stride, predictor) + default: + extraSamples = 1 // Associated alpha. + err = encode(dst, m, predictor) + } + if err != nil { + return err + } + + if compression != cNone { + if err = dst.(io.Closer).Close(); err != nil { + return err + } + imageLen = buf.Len() + if err = binary.Write(w, enc, uint32(imageLen+8)); err != nil { + return err + } + if _, err = buf.WriteTo(w); err != nil { + return err + } + } + + ifd := []ifdEntry{ + {tImageWidth, dtShort, []uint32{uint32(d.X)}}, + {tImageLength, dtShort, []uint32{uint32(d.Y)}}, + {tBitsPerSample, dtShort, bitsPerSample}, + {tCompression, dtShort, []uint32{compression}}, + {tPhotometricInterpretation, dtShort, []uint32{photometricInterpretation}}, + {tStripOffsets, dtLong, []uint32{8}}, + {tSamplesPerPixel, dtShort, []uint32{samplesPerPixel}}, + {tRowsPerStrip, dtShort, []uint32{uint32(d.Y)}}, + {tStripByteCounts, dtLong, []uint32{uint32(imageLen)}}, + // There is currently no support for storing the image + // resolution, so give a bogus value of 72x72 dpi. + {tXResolution, dtRational, []uint32{72, 1}}, + {tYResolution, dtRational, []uint32{72, 1}}, + {tResolutionUnit, dtShort, []uint32{resPerInch}}, + } + if pr != prNone { + ifd = append(ifd, ifdEntry{tPredictor, dtShort, []uint32{pr}}) + } + if len(colorMap) != 0 { + ifd = append(ifd, ifdEntry{tColorMap, dtShort, colorMap}) + } + if extraSamples > 0 { + ifd = append(ifd, ifdEntry{tExtraSamples, dtShort, []uint32{extraSamples}}) + } + + return writeIFD(w, imageLen+8, ifd) +} diff --git a/vendor/golang.org/x/net/LICENSE b/vendor/golang.org/x/net/LICENSE new file mode 100644 index 00000000..6a66aea5 --- /dev/null +++ b/vendor/golang.org/x/net/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2009 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/golang.org/x/net/PATENTS b/vendor/golang.org/x/net/PATENTS new file mode 100644 index 00000000..73309904 --- /dev/null +++ b/vendor/golang.org/x/net/PATENTS @@ -0,0 +1,22 @@ +Additional IP Rights Grant (Patents) + +"This implementation" means the copyrightable works distributed by +Google as part of the Go project. + +Google hereby grants to You a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable (except as stated in this section) +patent license to make, have made, use, offer to sell, sell, import, +transfer and otherwise run, modify and propagate the contents of this +implementation of Go, where such license applies only to those patent +claims, both currently owned or controlled by Google and acquired in +the future, licensable by Google that are necessarily infringed by this +implementation of Go. This grant does not include claims that would be +infringed only as a consequence of further modification of this +implementation. If you or your agent or exclusive licensee institute or +order or agree to the institution of patent litigation against any +entity (including a cross-claim or counterclaim in a lawsuit) alleging +that this implementation of Go or any code incorporated within this +implementation of Go constitutes direct or contributory patent +infringement, or inducement of patent infringement, then any patent +rights granted to you under this License for this implementation of Go +shall terminate as of the date such litigation is filed. diff --git a/vendor/golang.org/x/net/context/context.go b/vendor/golang.org/x/net/context/context.go new file mode 100644 index 00000000..134654cf --- /dev/null +++ b/vendor/golang.org/x/net/context/context.go @@ -0,0 +1,156 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package context defines the Context type, which carries deadlines, +// cancelation signals, and other request-scoped values across API boundaries +// and between processes. +// +// Incoming requests to a server should create a Context, and outgoing calls to +// servers should accept a Context. The chain of function calls between must +// propagate the Context, optionally replacing it with a modified copy created +// using WithDeadline, WithTimeout, WithCancel, or WithValue. +// +// Programs that use Contexts should follow these rules to keep interfaces +// consistent across packages and enable static analysis tools to check context +// propagation: +// +// Do not store Contexts inside a struct type; instead, pass a Context +// explicitly to each function that needs it. The Context should be the first +// parameter, typically named ctx: +// +// func DoSomething(ctx context.Context, arg Arg) error { +// // ... use ctx ... +// } +// +// Do not pass a nil Context, even if a function permits it. Pass context.TODO +// if you are unsure about which Context to use. +// +// Use context Values only for request-scoped data that transits processes and +// APIs, not for passing optional parameters to functions. +// +// The same Context may be passed to functions running in different goroutines; +// Contexts are safe for simultaneous use by multiple goroutines. +// +// See http://blog.golang.org/context for example code for a server that uses +// Contexts. +package context // import "golang.org/x/net/context" + +import "time" + +// A Context carries a deadline, a cancelation signal, and other values across +// API boundaries. +// +// Context's methods may be called by multiple goroutines simultaneously. +type Context interface { + // Deadline returns the time when work done on behalf of this context + // should be canceled. Deadline returns ok==false when no deadline is + // set. Successive calls to Deadline return the same results. + Deadline() (deadline time.Time, ok bool) + + // Done returns a channel that's closed when work done on behalf of this + // context should be canceled. Done may return nil if this context can + // never be canceled. Successive calls to Done return the same value. + // + // WithCancel arranges for Done to be closed when cancel is called; + // WithDeadline arranges for Done to be closed when the deadline + // expires; WithTimeout arranges for Done to be closed when the timeout + // elapses. + // + // Done is provided for use in select statements: + // + // // Stream generates values with DoSomething and sends them to out + // // until DoSomething returns an error or ctx.Done is closed. + // func Stream(ctx context.Context, out chan<- Value) error { + // for { + // v, err := DoSomething(ctx) + // if err != nil { + // return err + // } + // select { + // case <-ctx.Done(): + // return ctx.Err() + // case out <- v: + // } + // } + // } + // + // See http://blog.golang.org/pipelines for more examples of how to use + // a Done channel for cancelation. + Done() <-chan struct{} + + // Err returns a non-nil error value after Done is closed. Err returns + // Canceled if the context was canceled or DeadlineExceeded if the + // context's deadline passed. No other values for Err are defined. + // After Done is closed, successive calls to Err return the same value. + Err() error + + // Value returns the value associated with this context for key, or nil + // if no value is associated with key. Successive calls to Value with + // the same key returns the same result. + // + // Use context values only for request-scoped data that transits + // processes and API boundaries, not for passing optional parameters to + // functions. + // + // A key identifies a specific value in a Context. Functions that wish + // to store values in Context typically allocate a key in a global + // variable then use that key as the argument to context.WithValue and + // Context.Value. A key can be any type that supports equality; + // packages should define keys as an unexported type to avoid + // collisions. + // + // Packages that define a Context key should provide type-safe accessors + // for the values stores using that key: + // + // // Package user defines a User type that's stored in Contexts. + // package user + // + // import "golang.org/x/net/context" + // + // // User is the type of value stored in the Contexts. + // type User struct {...} + // + // // key is an unexported type for keys defined in this package. + // // This prevents collisions with keys defined in other packages. + // type key int + // + // // userKey is the key for user.User values in Contexts. It is + // // unexported; clients use user.NewContext and user.FromContext + // // instead of using this key directly. + // var userKey key = 0 + // + // // NewContext returns a new Context that carries value u. + // func NewContext(ctx context.Context, u *User) context.Context { + // return context.WithValue(ctx, userKey, u) + // } + // + // // FromContext returns the User value stored in ctx, if any. + // func FromContext(ctx context.Context) (*User, bool) { + // u, ok := ctx.Value(userKey).(*User) + // return u, ok + // } + Value(key interface{}) interface{} +} + +// Background returns a non-nil, empty Context. It is never canceled, has no +// values, and has no deadline. It is typically used by the main function, +// initialization, and tests, and as the top-level Context for incoming +// requests. +func Background() Context { + return background +} + +// TODO returns a non-nil, empty Context. Code should use context.TODO when +// it's unclear which Context to use or it is not yet available (because the +// surrounding function has not yet been extended to accept a Context +// parameter). TODO is recognized by static analysis tools that determine +// whether Contexts are propagated correctly in a program. +func TODO() Context { + return todo +} + +// A CancelFunc tells an operation to abandon its work. +// A CancelFunc does not wait for the work to stop. +// After the first call, subsequent calls to a CancelFunc do nothing. +type CancelFunc func() diff --git a/vendor/golang.org/x/net/context/ctxhttp/ctxhttp.go b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp.go new file mode 100644 index 00000000..606cf1f9 --- /dev/null +++ b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp.go @@ -0,0 +1,74 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build go1.7 + +// Package ctxhttp provides helper functions for performing context-aware HTTP requests. +package ctxhttp // import "golang.org/x/net/context/ctxhttp" + +import ( + "io" + "net/http" + "net/url" + "strings" + + "golang.org/x/net/context" +) + +// Do sends an HTTP request with the provided http.Client and returns +// an HTTP response. +// +// If the client is nil, http.DefaultClient is used. +// +// The provided ctx must be non-nil. If it is canceled or times out, +// ctx.Err() will be returned. +func Do(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) { + if client == nil { + client = http.DefaultClient + } + resp, err := client.Do(req.WithContext(ctx)) + // If we got an error, and the context has been canceled, + // the context's error is probably more useful. + if err != nil { + select { + case <-ctx.Done(): + err = ctx.Err() + default: + } + } + return resp, err +} + +// Get issues a GET request via the Do function. +func Get(ctx context.Context, client *http.Client, url string) (*http.Response, error) { + req, err := http.NewRequest("GET", url, nil) + if err != nil { + return nil, err + } + return Do(ctx, client, req) +} + +// Head issues a HEAD request via the Do function. +func Head(ctx context.Context, client *http.Client, url string) (*http.Response, error) { + req, err := http.NewRequest("HEAD", url, nil) + if err != nil { + return nil, err + } + return Do(ctx, client, req) +} + +// Post issues a POST request via the Do function. +func Post(ctx context.Context, client *http.Client, url string, bodyType string, body io.Reader) (*http.Response, error) { + req, err := http.NewRequest("POST", url, body) + if err != nil { + return nil, err + } + req.Header.Set("Content-Type", bodyType) + return Do(ctx, client, req) +} + +// PostForm issues a POST request via the Do function. +func PostForm(ctx context.Context, client *http.Client, url string, data url.Values) (*http.Response, error) { + return Post(ctx, client, url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode())) +} diff --git a/vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17.go b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17.go new file mode 100644 index 00000000..926870cc --- /dev/null +++ b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17.go @@ -0,0 +1,147 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build !go1.7 + +package ctxhttp // import "golang.org/x/net/context/ctxhttp" + +import ( + "io" + "net/http" + "net/url" + "strings" + + "golang.org/x/net/context" +) + +func nop() {} + +var ( + testHookContextDoneBeforeHeaders = nop + testHookDoReturned = nop + testHookDidBodyClose = nop +) + +// Do sends an HTTP request with the provided http.Client and returns an HTTP response. +// If the client is nil, http.DefaultClient is used. +// If the context is canceled or times out, ctx.Err() will be returned. +func Do(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) { + if client == nil { + client = http.DefaultClient + } + + // TODO(djd): Respect any existing value of req.Cancel. + cancel := make(chan struct{}) + req.Cancel = cancel + + type responseAndError struct { + resp *http.Response + err error + } + result := make(chan responseAndError, 1) + + // Make local copies of test hooks closed over by goroutines below. + // Prevents data races in tests. + testHookDoReturned := testHookDoReturned + testHookDidBodyClose := testHookDidBodyClose + + go func() { + resp, err := client.Do(req) + testHookDoReturned() + result <- responseAndError{resp, err} + }() + + var resp *http.Response + + select { + case <-ctx.Done(): + testHookContextDoneBeforeHeaders() + close(cancel) + // Clean up after the goroutine calling client.Do: + go func() { + if r := <-result; r.resp != nil { + testHookDidBodyClose() + r.resp.Body.Close() + } + }() + return nil, ctx.Err() + case r := <-result: + var err error + resp, err = r.resp, r.err + if err != nil { + return resp, err + } + } + + c := make(chan struct{}) + go func() { + select { + case <-ctx.Done(): + close(cancel) + case <-c: + // The response's Body is closed. + } + }() + resp.Body = ¬ifyingReader{resp.Body, c} + + return resp, nil +} + +// Get issues a GET request via the Do function. +func Get(ctx context.Context, client *http.Client, url string) (*http.Response, error) { + req, err := http.NewRequest("GET", url, nil) + if err != nil { + return nil, err + } + return Do(ctx, client, req) +} + +// Head issues a HEAD request via the Do function. +func Head(ctx context.Context, client *http.Client, url string) (*http.Response, error) { + req, err := http.NewRequest("HEAD", url, nil) + if err != nil { + return nil, err + } + return Do(ctx, client, req) +} + +// Post issues a POST request via the Do function. +func Post(ctx context.Context, client *http.Client, url string, bodyType string, body io.Reader) (*http.Response, error) { + req, err := http.NewRequest("POST", url, body) + if err != nil { + return nil, err + } + req.Header.Set("Content-Type", bodyType) + return Do(ctx, client, req) +} + +// PostForm issues a POST request via the Do function. +func PostForm(ctx context.Context, client *http.Client, url string, data url.Values) (*http.Response, error) { + return Post(ctx, client, url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode())) +} + +// notifyingReader is an io.ReadCloser that closes the notify channel after +// Close is called or a Read fails on the underlying ReadCloser. +type notifyingReader struct { + io.ReadCloser + notify chan<- struct{} +} + +func (r *notifyingReader) Read(p []byte) (int, error) { + n, err := r.ReadCloser.Read(p) + if err != nil && r.notify != nil { + close(r.notify) + r.notify = nil + } + return n, err +} + +func (r *notifyingReader) Close() error { + err := r.ReadCloser.Close() + if r.notify != nil { + close(r.notify) + r.notify = nil + } + return err +} diff --git a/vendor/golang.org/x/net/context/go17.go b/vendor/golang.org/x/net/context/go17.go new file mode 100644 index 00000000..f8cda19a --- /dev/null +++ b/vendor/golang.org/x/net/context/go17.go @@ -0,0 +1,72 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build go1.7 + +package context + +import ( + "context" // standard library's context, as of Go 1.7 + "time" +) + +var ( + todo = context.TODO() + background = context.Background() +) + +// Canceled is the error returned by Context.Err when the context is canceled. +var Canceled = context.Canceled + +// DeadlineExceeded is the error returned by Context.Err when the context's +// deadline passes. +var DeadlineExceeded = context.DeadlineExceeded + +// WithCancel returns a copy of parent with a new Done channel. The returned +// context's Done channel is closed when the returned cancel function is called +// or when the parent context's Done channel is closed, whichever happens first. +// +// Canceling this context releases resources associated with it, so code should +// call cancel as soon as the operations running in this Context complete. +func WithCancel(parent Context) (ctx Context, cancel CancelFunc) { + ctx, f := context.WithCancel(parent) + return ctx, CancelFunc(f) +} + +// WithDeadline returns a copy of the parent context with the deadline adjusted +// to be no later than d. If the parent's deadline is already earlier than d, +// WithDeadline(parent, d) is semantically equivalent to parent. The returned +// context's Done channel is closed when the deadline expires, when the returned +// cancel function is called, or when the parent context's Done channel is +// closed, whichever happens first. +// +// Canceling this context releases resources associated with it, so code should +// call cancel as soon as the operations running in this Context complete. +func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) { + ctx, f := context.WithDeadline(parent, deadline) + return ctx, CancelFunc(f) +} + +// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)). +// +// Canceling this context releases resources associated with it, so code should +// call cancel as soon as the operations running in this Context complete: +// +// func slowOperationWithTimeout(ctx context.Context) (Result, error) { +// ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond) +// defer cancel() // releases resources if slowOperation completes before timeout elapses +// return slowOperation(ctx) +// } +func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) { + return WithDeadline(parent, time.Now().Add(timeout)) +} + +// WithValue returns a copy of parent in which the value associated with key is +// val. +// +// Use context Values only for request-scoped data that transits processes and +// APIs, not for passing optional parameters to functions. +func WithValue(parent Context, key interface{}, val interface{}) Context { + return context.WithValue(parent, key, val) +} diff --git a/vendor/golang.org/x/net/context/pre_go17.go b/vendor/golang.org/x/net/context/pre_go17.go new file mode 100644 index 00000000..5a30acab --- /dev/null +++ b/vendor/golang.org/x/net/context/pre_go17.go @@ -0,0 +1,300 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build !go1.7 + +package context + +import ( + "errors" + "fmt" + "sync" + "time" +) + +// An emptyCtx is never canceled, has no values, and has no deadline. It is not +// struct{}, since vars of this type must have distinct addresses. +type emptyCtx int + +func (*emptyCtx) Deadline() (deadline time.Time, ok bool) { + return +} + +func (*emptyCtx) Done() <-chan struct{} { + return nil +} + +func (*emptyCtx) Err() error { + return nil +} + +func (*emptyCtx) Value(key interface{}) interface{} { + return nil +} + +func (e *emptyCtx) String() string { + switch e { + case background: + return "context.Background" + case todo: + return "context.TODO" + } + return "unknown empty Context" +} + +var ( + background = new(emptyCtx) + todo = new(emptyCtx) +) + +// Canceled is the error returned by Context.Err when the context is canceled. +var Canceled = errors.New("context canceled") + +// DeadlineExceeded is the error returned by Context.Err when the context's +// deadline passes. +var DeadlineExceeded = errors.New("context deadline exceeded") + +// WithCancel returns a copy of parent with a new Done channel. The returned +// context's Done channel is closed when the returned cancel function is called +// or when the parent context's Done channel is closed, whichever happens first. +// +// Canceling this context releases resources associated with it, so code should +// call cancel as soon as the operations running in this Context complete. +func WithCancel(parent Context) (ctx Context, cancel CancelFunc) { + c := newCancelCtx(parent) + propagateCancel(parent, c) + return c, func() { c.cancel(true, Canceled) } +} + +// newCancelCtx returns an initialized cancelCtx. +func newCancelCtx(parent Context) *cancelCtx { + return &cancelCtx{ + Context: parent, + done: make(chan struct{}), + } +} + +// propagateCancel arranges for child to be canceled when parent is. +func propagateCancel(parent Context, child canceler) { + if parent.Done() == nil { + return // parent is never canceled + } + if p, ok := parentCancelCtx(parent); ok { + p.mu.Lock() + if p.err != nil { + // parent has already been canceled + child.cancel(false, p.err) + } else { + if p.children == nil { + p.children = make(map[canceler]bool) + } + p.children[child] = true + } + p.mu.Unlock() + } else { + go func() { + select { + case <-parent.Done(): + child.cancel(false, parent.Err()) + case <-child.Done(): + } + }() + } +} + +// parentCancelCtx follows a chain of parent references until it finds a +// *cancelCtx. This function understands how each of the concrete types in this +// package represents its parent. +func parentCancelCtx(parent Context) (*cancelCtx, bool) { + for { + switch c := parent.(type) { + case *cancelCtx: + return c, true + case *timerCtx: + return c.cancelCtx, true + case *valueCtx: + parent = c.Context + default: + return nil, false + } + } +} + +// removeChild removes a context from its parent. +func removeChild(parent Context, child canceler) { + p, ok := parentCancelCtx(parent) + if !ok { + return + } + p.mu.Lock() + if p.children != nil { + delete(p.children, child) + } + p.mu.Unlock() +} + +// A canceler is a context type that can be canceled directly. The +// implementations are *cancelCtx and *timerCtx. +type canceler interface { + cancel(removeFromParent bool, err error) + Done() <-chan struct{} +} + +// A cancelCtx can be canceled. When canceled, it also cancels any children +// that implement canceler. +type cancelCtx struct { + Context + + done chan struct{} // closed by the first cancel call. + + mu sync.Mutex + children map[canceler]bool // set to nil by the first cancel call + err error // set to non-nil by the first cancel call +} + +func (c *cancelCtx) Done() <-chan struct{} { + return c.done +} + +func (c *cancelCtx) Err() error { + c.mu.Lock() + defer c.mu.Unlock() + return c.err +} + +func (c *cancelCtx) String() string { + return fmt.Sprintf("%v.WithCancel", c.Context) +} + +// cancel closes c.done, cancels each of c's children, and, if +// removeFromParent is true, removes c from its parent's children. +func (c *cancelCtx) cancel(removeFromParent bool, err error) { + if err == nil { + panic("context: internal error: missing cancel error") + } + c.mu.Lock() + if c.err != nil { + c.mu.Unlock() + return // already canceled + } + c.err = err + close(c.done) + for child := range c.children { + // NOTE: acquiring the child's lock while holding parent's lock. + child.cancel(false, err) + } + c.children = nil + c.mu.Unlock() + + if removeFromParent { + removeChild(c.Context, c) + } +} + +// WithDeadline returns a copy of the parent context with the deadline adjusted +// to be no later than d. If the parent's deadline is already earlier than d, +// WithDeadline(parent, d) is semantically equivalent to parent. The returned +// context's Done channel is closed when the deadline expires, when the returned +// cancel function is called, or when the parent context's Done channel is +// closed, whichever happens first. +// +// Canceling this context releases resources associated with it, so code should +// call cancel as soon as the operations running in this Context complete. +func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) { + if cur, ok := parent.Deadline(); ok && cur.Before(deadline) { + // The current deadline is already sooner than the new one. + return WithCancel(parent) + } + c := &timerCtx{ + cancelCtx: newCancelCtx(parent), + deadline: deadline, + } + propagateCancel(parent, c) + d := deadline.Sub(time.Now()) + if d <= 0 { + c.cancel(true, DeadlineExceeded) // deadline has already passed + return c, func() { c.cancel(true, Canceled) } + } + c.mu.Lock() + defer c.mu.Unlock() + if c.err == nil { + c.timer = time.AfterFunc(d, func() { + c.cancel(true, DeadlineExceeded) + }) + } + return c, func() { c.cancel(true, Canceled) } +} + +// A timerCtx carries a timer and a deadline. It embeds a cancelCtx to +// implement Done and Err. It implements cancel by stopping its timer then +// delegating to cancelCtx.cancel. +type timerCtx struct { + *cancelCtx + timer *time.Timer // Under cancelCtx.mu. + + deadline time.Time +} + +func (c *timerCtx) Deadline() (deadline time.Time, ok bool) { + return c.deadline, true +} + +func (c *timerCtx) String() string { + return fmt.Sprintf("%v.WithDeadline(%s [%s])", c.cancelCtx.Context, c.deadline, c.deadline.Sub(time.Now())) +} + +func (c *timerCtx) cancel(removeFromParent bool, err error) { + c.cancelCtx.cancel(false, err) + if removeFromParent { + // Remove this timerCtx from its parent cancelCtx's children. + removeChild(c.cancelCtx.Context, c) + } + c.mu.Lock() + if c.timer != nil { + c.timer.Stop() + c.timer = nil + } + c.mu.Unlock() +} + +// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)). +// +// Canceling this context releases resources associated with it, so code should +// call cancel as soon as the operations running in this Context complete: +// +// func slowOperationWithTimeout(ctx context.Context) (Result, error) { +// ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond) +// defer cancel() // releases resources if slowOperation completes before timeout elapses +// return slowOperation(ctx) +// } +func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) { + return WithDeadline(parent, time.Now().Add(timeout)) +} + +// WithValue returns a copy of parent in which the value associated with key is +// val. +// +// Use context Values only for request-scoped data that transits processes and +// APIs, not for passing optional parameters to functions. +func WithValue(parent Context, key interface{}, val interface{}) Context { + return &valueCtx{parent, key, val} +} + +// A valueCtx carries a key-value pair. It implements Value for that key and +// delegates all other calls to the embedded Context. +type valueCtx struct { + Context + key, val interface{} +} + +func (c *valueCtx) String() string { + return fmt.Sprintf("%v.WithValue(%#v, %#v)", c.Context, c.key, c.val) +} + +func (c *valueCtx) Value(key interface{}) interface{} { + if c.key == key { + return c.val + } + return c.Context.Value(key) +} diff --git a/vendor/golang.org/x/net/http2/client_conn_pool.go b/vendor/golang.org/x/net/http2/client_conn_pool.go new file mode 100644 index 00000000..b1394125 --- /dev/null +++ b/vendor/golang.org/x/net/http2/client_conn_pool.go @@ -0,0 +1,256 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Transport code's client connection pooling. + +package http2 + +import ( + "crypto/tls" + "net/http" + "sync" +) + +// ClientConnPool manages a pool of HTTP/2 client connections. +type ClientConnPool interface { + GetClientConn(req *http.Request, addr string) (*ClientConn, error) + MarkDead(*ClientConn) +} + +// clientConnPoolIdleCloser is the interface implemented by ClientConnPool +// implementations which can close their idle connections. +type clientConnPoolIdleCloser interface { + ClientConnPool + closeIdleConnections() +} + +var ( + _ clientConnPoolIdleCloser = (*clientConnPool)(nil) + _ clientConnPoolIdleCloser = noDialClientConnPool{} +) + +// TODO: use singleflight for dialing and addConnCalls? +type clientConnPool struct { + t *Transport + + mu sync.Mutex // TODO: maybe switch to RWMutex + // TODO: add support for sharing conns based on cert names + // (e.g. share conn for googleapis.com and appspot.com) + conns map[string][]*ClientConn // key is host:port + dialing map[string]*dialCall // currently in-flight dials + keys map[*ClientConn][]string + addConnCalls map[string]*addConnCall // in-flight addConnIfNeede calls +} + +func (p *clientConnPool) GetClientConn(req *http.Request, addr string) (*ClientConn, error) { + return p.getClientConn(req, addr, dialOnMiss) +} + +const ( + dialOnMiss = true + noDialOnMiss = false +) + +func (p *clientConnPool) getClientConn(req *http.Request, addr string, dialOnMiss bool) (*ClientConn, error) { + if isConnectionCloseRequest(req) && dialOnMiss { + // It gets its own connection. + const singleUse = true + cc, err := p.t.dialClientConn(addr, singleUse) + if err != nil { + return nil, err + } + return cc, nil + } + p.mu.Lock() + for _, cc := range p.conns[addr] { + if cc.CanTakeNewRequest() { + p.mu.Unlock() + return cc, nil + } + } + if !dialOnMiss { + p.mu.Unlock() + return nil, ErrNoCachedConn + } + call := p.getStartDialLocked(addr) + p.mu.Unlock() + <-call.done + return call.res, call.err +} + +// dialCall is an in-flight Transport dial call to a host. +type dialCall struct { + p *clientConnPool + done chan struct{} // closed when done + res *ClientConn // valid after done is closed + err error // valid after done is closed +} + +// requires p.mu is held. +func (p *clientConnPool) getStartDialLocked(addr string) *dialCall { + if call, ok := p.dialing[addr]; ok { + // A dial is already in-flight. Don't start another. + return call + } + call := &dialCall{p: p, done: make(chan struct{})} + if p.dialing == nil { + p.dialing = make(map[string]*dialCall) + } + p.dialing[addr] = call + go call.dial(addr) + return call +} + +// run in its own goroutine. +func (c *dialCall) dial(addr string) { + const singleUse = false // shared conn + c.res, c.err = c.p.t.dialClientConn(addr, singleUse) + close(c.done) + + c.p.mu.Lock() + delete(c.p.dialing, addr) + if c.err == nil { + c.p.addConnLocked(addr, c.res) + } + c.p.mu.Unlock() +} + +// addConnIfNeeded makes a NewClientConn out of c if a connection for key doesn't +// already exist. It coalesces concurrent calls with the same key. +// This is used by the http1 Transport code when it creates a new connection. Because +// the http1 Transport doesn't de-dup TCP dials to outbound hosts (because it doesn't know +// the protocol), it can get into a situation where it has multiple TLS connections. +// This code decides which ones live or die. +// The return value used is whether c was used. +// c is never closed. +func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c *tls.Conn) (used bool, err error) { + p.mu.Lock() + for _, cc := range p.conns[key] { + if cc.CanTakeNewRequest() { + p.mu.Unlock() + return false, nil + } + } + call, dup := p.addConnCalls[key] + if !dup { + if p.addConnCalls == nil { + p.addConnCalls = make(map[string]*addConnCall) + } + call = &addConnCall{ + p: p, + done: make(chan struct{}), + } + p.addConnCalls[key] = call + go call.run(t, key, c) + } + p.mu.Unlock() + + <-call.done + if call.err != nil { + return false, call.err + } + return !dup, nil +} + +type addConnCall struct { + p *clientConnPool + done chan struct{} // closed when done + err error +} + +func (c *addConnCall) run(t *Transport, key string, tc *tls.Conn) { + cc, err := t.NewClientConn(tc) + + p := c.p + p.mu.Lock() + if err != nil { + c.err = err + } else { + p.addConnLocked(key, cc) + } + delete(p.addConnCalls, key) + p.mu.Unlock() + close(c.done) +} + +func (p *clientConnPool) addConn(key string, cc *ClientConn) { + p.mu.Lock() + p.addConnLocked(key, cc) + p.mu.Unlock() +} + +// p.mu must be held +func (p *clientConnPool) addConnLocked(key string, cc *ClientConn) { + for _, v := range p.conns[key] { + if v == cc { + return + } + } + if p.conns == nil { + p.conns = make(map[string][]*ClientConn) + } + if p.keys == nil { + p.keys = make(map[*ClientConn][]string) + } + p.conns[key] = append(p.conns[key], cc) + p.keys[cc] = append(p.keys[cc], key) +} + +func (p *clientConnPool) MarkDead(cc *ClientConn) { + p.mu.Lock() + defer p.mu.Unlock() + for _, key := range p.keys[cc] { + vv, ok := p.conns[key] + if !ok { + continue + } + newList := filterOutClientConn(vv, cc) + if len(newList) > 0 { + p.conns[key] = newList + } else { + delete(p.conns, key) + } + } + delete(p.keys, cc) +} + +func (p *clientConnPool) closeIdleConnections() { + p.mu.Lock() + defer p.mu.Unlock() + // TODO: don't close a cc if it was just added to the pool + // milliseconds ago and has never been used. There's currently + // a small race window with the HTTP/1 Transport's integration + // where it can add an idle conn just before using it, and + // somebody else can concurrently call CloseIdleConns and + // break some caller's RoundTrip. + for _, vv := range p.conns { + for _, cc := range vv { + cc.closeIfIdle() + } + } +} + +func filterOutClientConn(in []*ClientConn, exclude *ClientConn) []*ClientConn { + out := in[:0] + for _, v := range in { + if v != exclude { + out = append(out, v) + } + } + // If we filtered it out, zero out the last item to prevent + // the GC from seeing it. + if len(in) != len(out) { + in[len(in)-1] = nil + } + return out +} + +// noDialClientConnPool is an implementation of http2.ClientConnPool +// which never dials. We let the HTTP/1.1 client dial and use its TLS +// connection instead. +type noDialClientConnPool struct{ *clientConnPool } + +func (p noDialClientConnPool) GetClientConn(req *http.Request, addr string) (*ClientConn, error) { + return p.getClientConn(req, addr, noDialOnMiss) +} diff --git a/vendor/golang.org/x/net/http2/configure_transport.go b/vendor/golang.org/x/net/http2/configure_transport.go new file mode 100644 index 00000000..4f720f53 --- /dev/null +++ b/vendor/golang.org/x/net/http2/configure_transport.go @@ -0,0 +1,80 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build go1.6 + +package http2 + +import ( + "crypto/tls" + "fmt" + "net/http" +) + +func configureTransport(t1 *http.Transport) (*Transport, error) { + connPool := new(clientConnPool) + t2 := &Transport{ + ConnPool: noDialClientConnPool{connPool}, + t1: t1, + } + connPool.t = t2 + if err := registerHTTPSProtocol(t1, noDialH2RoundTripper{t2}); err != nil { + return nil, err + } + if t1.TLSClientConfig == nil { + t1.TLSClientConfig = new(tls.Config) + } + if !strSliceContains(t1.TLSClientConfig.NextProtos, "h2") { + t1.TLSClientConfig.NextProtos = append([]string{"h2"}, t1.TLSClientConfig.NextProtos...) + } + if !strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") { + t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1") + } + upgradeFn := func(authority string, c *tls.Conn) http.RoundTripper { + addr := authorityAddr("https", authority) + if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil { + go c.Close() + return erringRoundTripper{err} + } else if !used { + // Turns out we don't need this c. + // For example, two goroutines made requests to the same host + // at the same time, both kicking off TCP dials. (since protocol + // was unknown) + go c.Close() + } + return t2 + } + if m := t1.TLSNextProto; len(m) == 0 { + t1.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{ + "h2": upgradeFn, + } + } else { + m["h2"] = upgradeFn + } + return t2, nil +} + +// registerHTTPSProtocol calls Transport.RegisterProtocol but +// convering panics into errors. +func registerHTTPSProtocol(t *http.Transport, rt http.RoundTripper) (err error) { + defer func() { + if e := recover(); e != nil { + err = fmt.Errorf("%v", e) + } + }() + t.RegisterProtocol("https", rt) + return nil +} + +// noDialH2RoundTripper is a RoundTripper which only tries to complete the request +// if there's already has a cached connection to the host. +type noDialH2RoundTripper struct{ t *Transport } + +func (rt noDialH2RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) { + res, err := rt.t.RoundTrip(req) + if err == ErrNoCachedConn { + return nil, http.ErrSkipAltProtocol + } + return res, err +} diff --git a/vendor/golang.org/x/net/http2/errors.go b/vendor/golang.org/x/net/http2/errors.go new file mode 100644 index 00000000..20fd7626 --- /dev/null +++ b/vendor/golang.org/x/net/http2/errors.go @@ -0,0 +1,130 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package http2 + +import ( + "errors" + "fmt" +) + +// An ErrCode is an unsigned 32-bit error code as defined in the HTTP/2 spec. +type ErrCode uint32 + +const ( + ErrCodeNo ErrCode = 0x0 + ErrCodeProtocol ErrCode = 0x1 + ErrCodeInternal ErrCode = 0x2 + ErrCodeFlowControl ErrCode = 0x3 + ErrCodeSettingsTimeout ErrCode = 0x4 + ErrCodeStreamClosed ErrCode = 0x5 + ErrCodeFrameSize ErrCode = 0x6 + ErrCodeRefusedStream ErrCode = 0x7 + ErrCodeCancel ErrCode = 0x8 + ErrCodeCompression ErrCode = 0x9 + ErrCodeConnect ErrCode = 0xa + ErrCodeEnhanceYourCalm ErrCode = 0xb + ErrCodeInadequateSecurity ErrCode = 0xc + ErrCodeHTTP11Required ErrCode = 0xd +) + +var errCodeName = map[ErrCode]string{ + ErrCodeNo: "NO_ERROR", + ErrCodeProtocol: "PROTOCOL_ERROR", + ErrCodeInternal: "INTERNAL_ERROR", + ErrCodeFlowControl: "FLOW_CONTROL_ERROR", + ErrCodeSettingsTimeout: "SETTINGS_TIMEOUT", + ErrCodeStreamClosed: "STREAM_CLOSED", + ErrCodeFrameSize: "FRAME_SIZE_ERROR", + ErrCodeRefusedStream: "REFUSED_STREAM", + ErrCodeCancel: "CANCEL", + ErrCodeCompression: "COMPRESSION_ERROR", + ErrCodeConnect: "CONNECT_ERROR", + ErrCodeEnhanceYourCalm: "ENHANCE_YOUR_CALM", + ErrCodeInadequateSecurity: "INADEQUATE_SECURITY", + ErrCodeHTTP11Required: "HTTP_1_1_REQUIRED", +} + +func (e ErrCode) String() string { + if s, ok := errCodeName[e]; ok { + return s + } + return fmt.Sprintf("unknown error code 0x%x", uint32(e)) +} + +// ConnectionError is an error that results in the termination of the +// entire connection. +type ConnectionError ErrCode + +func (e ConnectionError) Error() string { return fmt.Sprintf("connection error: %s", ErrCode(e)) } + +// StreamError is an error that only affects one stream within an +// HTTP/2 connection. +type StreamError struct { + StreamID uint32 + Code ErrCode + Cause error // optional additional detail +} + +func streamError(id uint32, code ErrCode) StreamError { + return StreamError{StreamID: id, Code: code} +} + +func (e StreamError) Error() string { + if e.Cause != nil { + return fmt.Sprintf("stream error: stream ID %d; %v; %v", e.StreamID, e.Code, e.Cause) + } + return fmt.Sprintf("stream error: stream ID %d; %v", e.StreamID, e.Code) +} + +// 6.9.1 The Flow Control Window +// "If a sender receives a WINDOW_UPDATE that causes a flow control +// window to exceed this maximum it MUST terminate either the stream +// or the connection, as appropriate. For streams, [...]; for the +// connection, a GOAWAY frame with a FLOW_CONTROL_ERROR code." +type goAwayFlowError struct{} + +func (goAwayFlowError) Error() string { return "connection exceeded flow control window size" } + +// connErrorReason wraps a ConnectionError with an informative error about why it occurs. + +// Errors of this type are only returned by the frame parser functions +// and converted into ConnectionError(ErrCodeProtocol). +type connError struct { + Code ErrCode + Reason string +} + +func (e connError) Error() string { + return fmt.Sprintf("http2: connection error: %v: %v", e.Code, e.Reason) +} + +type pseudoHeaderError string + +func (e pseudoHeaderError) Error() string { + return fmt.Sprintf("invalid pseudo-header %q", string(e)) +} + +type duplicatePseudoHeaderError string + +func (e duplicatePseudoHeaderError) Error() string { + return fmt.Sprintf("duplicate pseudo-header %q", string(e)) +} + +type headerFieldNameError string + +func (e headerFieldNameError) Error() string { + return fmt.Sprintf("invalid header field name %q", string(e)) +} + +type headerFieldValueError string + +func (e headerFieldValueError) Error() string { + return fmt.Sprintf("invalid header field value %q", string(e)) +} + +var ( + errMixPseudoHeaderTypes = errors.New("mix of request and response pseudo headers") + errPseudoAfterRegular = errors.New("pseudo header field after regular") +) diff --git a/vendor/golang.org/x/net/http2/fixed_buffer.go b/vendor/golang.org/x/net/http2/fixed_buffer.go new file mode 100644 index 00000000..47da0f0b --- /dev/null +++ b/vendor/golang.org/x/net/http2/fixed_buffer.go @@ -0,0 +1,60 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package http2 + +import ( + "errors" +) + +// fixedBuffer is an io.ReadWriter backed by a fixed size buffer. +// It never allocates, but moves old data as new data is written. +type fixedBuffer struct { + buf []byte + r, w int +} + +var ( + errReadEmpty = errors.New("read from empty fixedBuffer") + errWriteFull = errors.New("write on full fixedBuffer") +) + +// Read copies bytes from the buffer into p. +// It is an error to read when no data is available. +func (b *fixedBuffer) Read(p []byte) (n int, err error) { + if b.r == b.w { + return 0, errReadEmpty + } + n = copy(p, b.buf[b.r:b.w]) + b.r += n + if b.r == b.w { + b.r = 0 + b.w = 0 + } + return n, nil +} + +// Len returns the number of bytes of the unread portion of the buffer. +func (b *fixedBuffer) Len() int { + return b.w - b.r +} + +// Write copies bytes from p into the buffer. +// It is an error to write more data than the buffer can hold. +func (b *fixedBuffer) Write(p []byte) (n int, err error) { + // Slide existing data to beginning. + if b.r > 0 && len(p) > len(b.buf)-b.w { + copy(b.buf, b.buf[b.r:b.w]) + b.w -= b.r + b.r = 0 + } + + // Write new data. + n = copy(b.buf[b.w:], p) + b.w += n + if n < len(p) { + err = errWriteFull + } + return n, err +} diff --git a/vendor/golang.org/x/net/http2/flow.go b/vendor/golang.org/x/net/http2/flow.go new file mode 100644 index 00000000..957de254 --- /dev/null +++ b/vendor/golang.org/x/net/http2/flow.go @@ -0,0 +1,50 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Flow control + +package http2 + +// flow is the flow control window's size. +type flow struct { + // n is the number of DATA bytes we're allowed to send. + // A flow is kept both on a conn and a per-stream. + n int32 + + // conn points to the shared connection-level flow that is + // shared by all streams on that conn. It is nil for the flow + // that's on the conn directly. + conn *flow +} + +func (f *flow) setConnFlow(cf *flow) { f.conn = cf } + +func (f *flow) available() int32 { + n := f.n + if f.conn != nil && f.conn.n < n { + n = f.conn.n + } + return n +} + +func (f *flow) take(n int32) { + if n > f.available() { + panic("internal error: took too much") + } + f.n -= n + if f.conn != nil { + f.conn.n -= n + } +} + +// add adds n bytes (positive or negative) to the flow control window. +// It returns false if the sum would exceed 2^31-1. +func (f *flow) add(n int32) bool { + remain := (1<<31 - 1) - f.n + if n > remain { + return false + } + f.n += n + return true +} diff --git a/vendor/golang.org/x/net/http2/frame.go b/vendor/golang.org/x/net/http2/frame.go new file mode 100644 index 00000000..c9b09bb6 --- /dev/null +++ b/vendor/golang.org/x/net/http2/frame.go @@ -0,0 +1,1539 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package http2 + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "io" + "log" + "strings" + "sync" + + "golang.org/x/net/http2/hpack" + "golang.org/x/net/lex/httplex" +) + +const frameHeaderLen = 9 + +var padZeros = make([]byte, 255) // zeros for padding + +// A FrameType is a registered frame type as defined in +// http://http2.github.io/http2-spec/#rfc.section.11.2 +type FrameType uint8 + +const ( + FrameData FrameType = 0x0 + FrameHeaders FrameType = 0x1 + FramePriority FrameType = 0x2 + FrameRSTStream FrameType = 0x3 + FrameSettings FrameType = 0x4 + FramePushPromise FrameType = 0x5 + FramePing FrameType = 0x6 + FrameGoAway FrameType = 0x7 + FrameWindowUpdate FrameType = 0x8 + FrameContinuation FrameType = 0x9 +) + +var frameName = map[FrameType]string{ + FrameData: "DATA", + FrameHeaders: "HEADERS", + FramePriority: "PRIORITY", + FrameRSTStream: "RST_STREAM", + FrameSettings: "SETTINGS", + FramePushPromise: "PUSH_PROMISE", + FramePing: "PING", + FrameGoAway: "GOAWAY", + FrameWindowUpdate: "WINDOW_UPDATE", + FrameContinuation: "CONTINUATION", +} + +func (t FrameType) String() string { + if s, ok := frameName[t]; ok { + return s + } + return fmt.Sprintf("UNKNOWN_FRAME_TYPE_%d", uint8(t)) +} + +// Flags is a bitmask of HTTP/2 flags. +// The meaning of flags varies depending on the frame type. +type Flags uint8 + +// Has reports whether f contains all (0 or more) flags in v. +func (f Flags) Has(v Flags) bool { + return (f & v) == v +} + +// Frame-specific FrameHeader flag bits. +const ( + // Data Frame + FlagDataEndStream Flags = 0x1 + FlagDataPadded Flags = 0x8 + + // Headers Frame + FlagHeadersEndStream Flags = 0x1 + FlagHeadersEndHeaders Flags = 0x4 + FlagHeadersPadded Flags = 0x8 + FlagHeadersPriority Flags = 0x20 + + // Settings Frame + FlagSettingsAck Flags = 0x1 + + // Ping Frame + FlagPingAck Flags = 0x1 + + // Continuation Frame + FlagContinuationEndHeaders Flags = 0x4 + + FlagPushPromiseEndHeaders Flags = 0x4 + FlagPushPromisePadded Flags = 0x8 +) + +var flagName = map[FrameType]map[Flags]string{ + FrameData: { + FlagDataEndStream: "END_STREAM", + FlagDataPadded: "PADDED", + }, + FrameHeaders: { + FlagHeadersEndStream: "END_STREAM", + FlagHeadersEndHeaders: "END_HEADERS", + FlagHeadersPadded: "PADDED", + FlagHeadersPriority: "PRIORITY", + }, + FrameSettings: { + FlagSettingsAck: "ACK", + }, + FramePing: { + FlagPingAck: "ACK", + }, + FrameContinuation: { + FlagContinuationEndHeaders: "END_HEADERS", + }, + FramePushPromise: { + FlagPushPromiseEndHeaders: "END_HEADERS", + FlagPushPromisePadded: "PADDED", + }, +} + +// a frameParser parses a frame given its FrameHeader and payload +// bytes. The length of payload will always equal fh.Length (which +// might be 0). +type frameParser func(fh FrameHeader, payload []byte) (Frame, error) + +var frameParsers = map[FrameType]frameParser{ + FrameData: parseDataFrame, + FrameHeaders: parseHeadersFrame, + FramePriority: parsePriorityFrame, + FrameRSTStream: parseRSTStreamFrame, + FrameSettings: parseSettingsFrame, + FramePushPromise: parsePushPromise, + FramePing: parsePingFrame, + FrameGoAway: parseGoAwayFrame, + FrameWindowUpdate: parseWindowUpdateFrame, + FrameContinuation: parseContinuationFrame, +} + +func typeFrameParser(t FrameType) frameParser { + if f := frameParsers[t]; f != nil { + return f + } + return parseUnknownFrame +} + +// A FrameHeader is the 9 byte header of all HTTP/2 frames. +// +// See http://http2.github.io/http2-spec/#FrameHeader +type FrameHeader struct { + valid bool // caller can access []byte fields in the Frame + + // Type is the 1 byte frame type. There are ten standard frame + // types, but extension frame types may be written by WriteRawFrame + // and will be returned by ReadFrame (as UnknownFrame). + Type FrameType + + // Flags are the 1 byte of 8 potential bit flags per frame. + // They are specific to the frame type. + Flags Flags + + // Length is the length of the frame, not including the 9 byte header. + // The maximum size is one byte less than 16MB (uint24), but only + // frames up to 16KB are allowed without peer agreement. + Length uint32 + + // StreamID is which stream this frame is for. Certain frames + // are not stream-specific, in which case this field is 0. + StreamID uint32 +} + +// Header returns h. It exists so FrameHeaders can be embedded in other +// specific frame types and implement the Frame interface. +func (h FrameHeader) Header() FrameHeader { return h } + +func (h FrameHeader) String() string { + var buf bytes.Buffer + buf.WriteString("[FrameHeader ") + h.writeDebug(&buf) + buf.WriteByte(']') + return buf.String() +} + +func (h FrameHeader) writeDebug(buf *bytes.Buffer) { + buf.WriteString(h.Type.String()) + if h.Flags != 0 { + buf.WriteString(" flags=") + set := 0 + for i := uint8(0); i < 8; i++ { + if h.Flags&(1< 1 { + buf.WriteByte('|') + } + name := flagName[h.Type][Flags(1<>24), + byte(streamID>>16), + byte(streamID>>8), + byte(streamID)) +} + +func (f *Framer) endWrite() error { + // Now that we know the final size, fill in the FrameHeader in + // the space previously reserved for it. Abuse append. + length := len(f.wbuf) - frameHeaderLen + if length >= (1 << 24) { + return ErrFrameTooLarge + } + _ = append(f.wbuf[:0], + byte(length>>16), + byte(length>>8), + byte(length)) + if logFrameWrites { + f.logWrite() + } + + n, err := f.w.Write(f.wbuf) + if err == nil && n != len(f.wbuf) { + err = io.ErrShortWrite + } + return err +} + +func (f *Framer) logWrite() { + if f.debugFramer == nil { + f.debugFramerBuf = new(bytes.Buffer) + f.debugFramer = NewFramer(nil, f.debugFramerBuf) + f.debugFramer.logReads = false // we log it ourselves, saying "wrote" below + // Let us read anything, even if we accidentally wrote it + // in the wrong order: + f.debugFramer.AllowIllegalReads = true + } + f.debugFramerBuf.Write(f.wbuf) + fr, err := f.debugFramer.ReadFrame() + if err != nil { + log.Printf("http2: Framer %p: failed to decode just-written frame", f) + return + } + log.Printf("http2: Framer %p: wrote %v", f, summarizeFrame(fr)) +} + +func (f *Framer) writeByte(v byte) { f.wbuf = append(f.wbuf, v) } +func (f *Framer) writeBytes(v []byte) { f.wbuf = append(f.wbuf, v...) } +func (f *Framer) writeUint16(v uint16) { f.wbuf = append(f.wbuf, byte(v>>8), byte(v)) } +func (f *Framer) writeUint32(v uint32) { + f.wbuf = append(f.wbuf, byte(v>>24), byte(v>>16), byte(v>>8), byte(v)) +} + +const ( + minMaxFrameSize = 1 << 14 + maxFrameSize = 1<<24 - 1 +) + +// NewFramer returns a Framer that writes frames to w and reads them from r. +func NewFramer(w io.Writer, r io.Reader) *Framer { + fr := &Framer{ + w: w, + r: r, + logReads: logFrameReads, + } + fr.getReadBuf = func(size uint32) []byte { + if cap(fr.readBuf) >= int(size) { + return fr.readBuf[:size] + } + fr.readBuf = make([]byte, size) + return fr.readBuf + } + fr.SetMaxReadFrameSize(maxFrameSize) + return fr +} + +// SetMaxReadFrameSize sets the maximum size of a frame +// that will be read by a subsequent call to ReadFrame. +// It is the caller's responsibility to advertise this +// limit with a SETTINGS frame. +func (fr *Framer) SetMaxReadFrameSize(v uint32) { + if v > maxFrameSize { + v = maxFrameSize + } + fr.maxReadSize = v +} + +// ErrorDetail returns a more detailed error of the last error +// returned by Framer.ReadFrame. For instance, if ReadFrame +// returns a StreamError with code PROTOCOL_ERROR, ErrorDetail +// will say exactly what was invalid. ErrorDetail is not guaranteed +// to return a non-nil value and like the rest of the http2 package, +// its return value is not protected by an API compatibility promise. +// ErrorDetail is reset after the next call to ReadFrame. +func (fr *Framer) ErrorDetail() error { + return fr.errDetail +} + +// ErrFrameTooLarge is returned from Framer.ReadFrame when the peer +// sends a frame that is larger than declared with SetMaxReadFrameSize. +var ErrFrameTooLarge = errors.New("http2: frame too large") + +// terminalReadFrameError reports whether err is an unrecoverable +// error from ReadFrame and no other frames should be read. +func terminalReadFrameError(err error) bool { + if _, ok := err.(StreamError); ok { + return false + } + return err != nil +} + +// ReadFrame reads a single frame. The returned Frame is only valid +// until the next call to ReadFrame. +// +// If the frame is larger than previously set with SetMaxReadFrameSize, the +// returned error is ErrFrameTooLarge. Other errors may be of type +// ConnectionError, StreamError, or anything else from the underlying +// reader. +func (fr *Framer) ReadFrame() (Frame, error) { + fr.errDetail = nil + if fr.lastFrame != nil { + fr.lastFrame.invalidate() + } + fh, err := readFrameHeader(fr.headerBuf[:], fr.r) + if err != nil { + return nil, err + } + if fh.Length > fr.maxReadSize { + return nil, ErrFrameTooLarge + } + payload := fr.getReadBuf(fh.Length) + if _, err := io.ReadFull(fr.r, payload); err != nil { + return nil, err + } + f, err := typeFrameParser(fh.Type)(fh, payload) + if err != nil { + if ce, ok := err.(connError); ok { + return nil, fr.connError(ce.Code, ce.Reason) + } + return nil, err + } + if err := fr.checkFrameOrder(f); err != nil { + return nil, err + } + if fr.logReads { + log.Printf("http2: Framer %p: read %v", fr, summarizeFrame(f)) + } + if fh.Type == FrameHeaders && fr.ReadMetaHeaders != nil { + return fr.readMetaFrame(f.(*HeadersFrame)) + } + return f, nil +} + +// connError returns ConnectionError(code) but first +// stashes away a public reason to the caller can optionally relay it +// to the peer before hanging up on them. This might help others debug +// their implementations. +func (fr *Framer) connError(code ErrCode, reason string) error { + fr.errDetail = errors.New(reason) + return ConnectionError(code) +} + +// checkFrameOrder reports an error if f is an invalid frame to return +// next from ReadFrame. Mostly it checks whether HEADERS and +// CONTINUATION frames are contiguous. +func (fr *Framer) checkFrameOrder(f Frame) error { + last := fr.lastFrame + fr.lastFrame = f + if fr.AllowIllegalReads { + return nil + } + + fh := f.Header() + if fr.lastHeaderStream != 0 { + if fh.Type != FrameContinuation { + return fr.connError(ErrCodeProtocol, + fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d", + fh.Type, fh.StreamID, + last.Header().Type, fr.lastHeaderStream)) + } + if fh.StreamID != fr.lastHeaderStream { + return fr.connError(ErrCodeProtocol, + fmt.Sprintf("got CONTINUATION for stream %d; expected stream %d", + fh.StreamID, fr.lastHeaderStream)) + } + } else if fh.Type == FrameContinuation { + return fr.connError(ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID)) + } + + switch fh.Type { + case FrameHeaders, FrameContinuation: + if fh.Flags.Has(FlagHeadersEndHeaders) { + fr.lastHeaderStream = 0 + } else { + fr.lastHeaderStream = fh.StreamID + } + } + + return nil +} + +// A DataFrame conveys arbitrary, variable-length sequences of octets +// associated with a stream. +// See http://http2.github.io/http2-spec/#rfc.section.6.1 +type DataFrame struct { + FrameHeader + data []byte +} + +func (f *DataFrame) StreamEnded() bool { + return f.FrameHeader.Flags.Has(FlagDataEndStream) +} + +// Data returns the frame's data octets, not including any padding +// size byte or padding suffix bytes. +// The caller must not retain the returned memory past the next +// call to ReadFrame. +func (f *DataFrame) Data() []byte { + f.checkValid() + return f.data +} + +func parseDataFrame(fh FrameHeader, payload []byte) (Frame, error) { + if fh.StreamID == 0 { + // DATA frames MUST be associated with a stream. If a + // DATA frame is received whose stream identifier + // field is 0x0, the recipient MUST respond with a + // connection error (Section 5.4.1) of type + // PROTOCOL_ERROR. + return nil, connError{ErrCodeProtocol, "DATA frame with stream ID 0"} + } + f := &DataFrame{ + FrameHeader: fh, + } + var padSize byte + if fh.Flags.Has(FlagDataPadded) { + var err error + payload, padSize, err = readByte(payload) + if err != nil { + return nil, err + } + } + if int(padSize) > len(payload) { + // If the length of the padding is greater than the + // length of the frame payload, the recipient MUST + // treat this as a connection error. + // Filed: https://github.com/http2/http2-spec/issues/610 + return nil, connError{ErrCodeProtocol, "pad size larger than data payload"} + } + f.data = payload[:len(payload)-int(padSize)] + return f, nil +} + +var ( + errStreamID = errors.New("invalid stream ID") + errDepStreamID = errors.New("invalid dependent stream ID") + errPadLength = errors.New("pad length too large") +) + +func validStreamIDOrZero(streamID uint32) bool { + return streamID&(1<<31) == 0 +} + +func validStreamID(streamID uint32) bool { + return streamID != 0 && streamID&(1<<31) == 0 +} + +// WriteData writes a DATA frame. +// +// It will perform exactly one Write to the underlying Writer. +// It is the caller's responsibility not to violate the maximum frame size +// and to not call other Write methods concurrently. +func (f *Framer) WriteData(streamID uint32, endStream bool, data []byte) error { + return f.WriteDataPadded(streamID, endStream, data, nil) +} + +// WriteData writes a DATA frame with optional padding. +// +// If pad is nil, the padding bit is not sent. +// The length of pad must not exceed 255 bytes. +// +// It will perform exactly one Write to the underlying Writer. +// It is the caller's responsibility not to violate the maximum frame size +// and to not call other Write methods concurrently. +func (f *Framer) WriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error { + if !validStreamID(streamID) && !f.AllowIllegalWrites { + return errStreamID + } + if len(pad) > 255 { + return errPadLength + } + var flags Flags + if endStream { + flags |= FlagDataEndStream + } + if pad != nil { + flags |= FlagDataPadded + } + f.startWrite(FrameData, flags, streamID) + if pad != nil { + f.wbuf = append(f.wbuf, byte(len(pad))) + } + f.wbuf = append(f.wbuf, data...) + f.wbuf = append(f.wbuf, pad...) + return f.endWrite() +} + +// A SettingsFrame conveys configuration parameters that affect how +// endpoints communicate, such as preferences and constraints on peer +// behavior. +// +// See http://http2.github.io/http2-spec/#SETTINGS +type SettingsFrame struct { + FrameHeader + p []byte +} + +func parseSettingsFrame(fh FrameHeader, p []byte) (Frame, error) { + if fh.Flags.Has(FlagSettingsAck) && fh.Length > 0 { + // When this (ACK 0x1) bit is set, the payload of the + // SETTINGS frame MUST be empty. Receipt of a + // SETTINGS frame with the ACK flag set and a length + // field value other than 0 MUST be treated as a + // connection error (Section 5.4.1) of type + // FRAME_SIZE_ERROR. + return nil, ConnectionError(ErrCodeFrameSize) + } + if fh.StreamID != 0 { + // SETTINGS frames always apply to a connection, + // never a single stream. The stream identifier for a + // SETTINGS frame MUST be zero (0x0). If an endpoint + // receives a SETTINGS frame whose stream identifier + // field is anything other than 0x0, the endpoint MUST + // respond with a connection error (Section 5.4.1) of + // type PROTOCOL_ERROR. + return nil, ConnectionError(ErrCodeProtocol) + } + if len(p)%6 != 0 { + // Expecting even number of 6 byte settings. + return nil, ConnectionError(ErrCodeFrameSize) + } + f := &SettingsFrame{FrameHeader: fh, p: p} + if v, ok := f.Value(SettingInitialWindowSize); ok && v > (1<<31)-1 { + // Values above the maximum flow control window size of 2^31 - 1 MUST + // be treated as a connection error (Section 5.4.1) of type + // FLOW_CONTROL_ERROR. + return nil, ConnectionError(ErrCodeFlowControl) + } + return f, nil +} + +func (f *SettingsFrame) IsAck() bool { + return f.FrameHeader.Flags.Has(FlagSettingsAck) +} + +func (f *SettingsFrame) Value(s SettingID) (v uint32, ok bool) { + f.checkValid() + buf := f.p + for len(buf) > 0 { + settingID := SettingID(binary.BigEndian.Uint16(buf[:2])) + if settingID == s { + return binary.BigEndian.Uint32(buf[2:6]), true + } + buf = buf[6:] + } + return 0, false +} + +// ForeachSetting runs fn for each setting. +// It stops and returns the first error. +func (f *SettingsFrame) ForeachSetting(fn func(Setting) error) error { + f.checkValid() + buf := f.p + for len(buf) > 0 { + if err := fn(Setting{ + SettingID(binary.BigEndian.Uint16(buf[:2])), + binary.BigEndian.Uint32(buf[2:6]), + }); err != nil { + return err + } + buf = buf[6:] + } + return nil +} + +// WriteSettings writes a SETTINGS frame with zero or more settings +// specified and the ACK bit not set. +// +// It will perform exactly one Write to the underlying Writer. +// It is the caller's responsibility to not call other Write methods concurrently. +func (f *Framer) WriteSettings(settings ...Setting) error { + f.startWrite(FrameSettings, 0, 0) + for _, s := range settings { + f.writeUint16(uint16(s.ID)) + f.writeUint32(s.Val) + } + return f.endWrite() +} + +// WriteSettings writes an empty SETTINGS frame with the ACK bit set. +// +// It will perform exactly one Write to the underlying Writer. +// It is the caller's responsibility to not call other Write methods concurrently. +func (f *Framer) WriteSettingsAck() error { + f.startWrite(FrameSettings, FlagSettingsAck, 0) + return f.endWrite() +} + +// A PingFrame is a mechanism for measuring a minimal round trip time +// from the sender, as well as determining whether an idle connection +// is still functional. +// See http://http2.github.io/http2-spec/#rfc.section.6.7 +type PingFrame struct { + FrameHeader + Data [8]byte +} + +func (f *PingFrame) IsAck() bool { return f.Flags.Has(FlagPingAck) } + +func parsePingFrame(fh FrameHeader, payload []byte) (Frame, error) { + if len(payload) != 8 { + return nil, ConnectionError(ErrCodeFrameSize) + } + if fh.StreamID != 0 { + return nil, ConnectionError(ErrCodeProtocol) + } + f := &PingFrame{FrameHeader: fh} + copy(f.Data[:], payload) + return f, nil +} + +func (f *Framer) WritePing(ack bool, data [8]byte) error { + var flags Flags + if ack { + flags = FlagPingAck + } + f.startWrite(FramePing, flags, 0) + f.writeBytes(data[:]) + return f.endWrite() +} + +// A GoAwayFrame informs the remote peer to stop creating streams on this connection. +// See http://http2.github.io/http2-spec/#rfc.section.6.8 +type GoAwayFrame struct { + FrameHeader + LastStreamID uint32 + ErrCode ErrCode + debugData []byte +} + +// DebugData returns any debug data in the GOAWAY frame. Its contents +// are not defined. +// The caller must not retain the returned memory past the next +// call to ReadFrame. +func (f *GoAwayFrame) DebugData() []byte { + f.checkValid() + return f.debugData +} + +func parseGoAwayFrame(fh FrameHeader, p []byte) (Frame, error) { + if fh.StreamID != 0 { + return nil, ConnectionError(ErrCodeProtocol) + } + if len(p) < 8 { + return nil, ConnectionError(ErrCodeFrameSize) + } + return &GoAwayFrame{ + FrameHeader: fh, + LastStreamID: binary.BigEndian.Uint32(p[:4]) & (1<<31 - 1), + ErrCode: ErrCode(binary.BigEndian.Uint32(p[4:8])), + debugData: p[8:], + }, nil +} + +func (f *Framer) WriteGoAway(maxStreamID uint32, code ErrCode, debugData []byte) error { + f.startWrite(FrameGoAway, 0, 0) + f.writeUint32(maxStreamID & (1<<31 - 1)) + f.writeUint32(uint32(code)) + f.writeBytes(debugData) + return f.endWrite() +} + +// An UnknownFrame is the frame type returned when the frame type is unknown +// or no specific frame type parser exists. +type UnknownFrame struct { + FrameHeader + p []byte +} + +// Payload returns the frame's payload (after the header). It is not +// valid to call this method after a subsequent call to +// Framer.ReadFrame, nor is it valid to retain the returned slice. +// The memory is owned by the Framer and is invalidated when the next +// frame is read. +func (f *UnknownFrame) Payload() []byte { + f.checkValid() + return f.p +} + +func parseUnknownFrame(fh FrameHeader, p []byte) (Frame, error) { + return &UnknownFrame{fh, p}, nil +} + +// A WindowUpdateFrame is used to implement flow control. +// See http://http2.github.io/http2-spec/#rfc.section.6.9 +type WindowUpdateFrame struct { + FrameHeader + Increment uint32 // never read with high bit set +} + +func parseWindowUpdateFrame(fh FrameHeader, p []byte) (Frame, error) { + if len(p) != 4 { + return nil, ConnectionError(ErrCodeFrameSize) + } + inc := binary.BigEndian.Uint32(p[:4]) & 0x7fffffff // mask off high reserved bit + if inc == 0 { + // A receiver MUST treat the receipt of a + // WINDOW_UPDATE frame with an flow control window + // increment of 0 as a stream error (Section 5.4.2) of + // type PROTOCOL_ERROR; errors on the connection flow + // control window MUST be treated as a connection + // error (Section 5.4.1). + if fh.StreamID == 0 { + return nil, ConnectionError(ErrCodeProtocol) + } + return nil, streamError(fh.StreamID, ErrCodeProtocol) + } + return &WindowUpdateFrame{ + FrameHeader: fh, + Increment: inc, + }, nil +} + +// WriteWindowUpdate writes a WINDOW_UPDATE frame. +// The increment value must be between 1 and 2,147,483,647, inclusive. +// If the Stream ID is zero, the window update applies to the +// connection as a whole. +func (f *Framer) WriteWindowUpdate(streamID, incr uint32) error { + // "The legal range for the increment to the flow control window is 1 to 2^31-1 (2,147,483,647) octets." + if (incr < 1 || incr > 2147483647) && !f.AllowIllegalWrites { + return errors.New("illegal window increment value") + } + f.startWrite(FrameWindowUpdate, 0, streamID) + f.writeUint32(incr) + return f.endWrite() +} + +// A HeadersFrame is used to open a stream and additionally carries a +// header block fragment. +type HeadersFrame struct { + FrameHeader + + // Priority is set if FlagHeadersPriority is set in the FrameHeader. + Priority PriorityParam + + headerFragBuf []byte // not owned +} + +func (f *HeadersFrame) HeaderBlockFragment() []byte { + f.checkValid() + return f.headerFragBuf +} + +func (f *HeadersFrame) HeadersEnded() bool { + return f.FrameHeader.Flags.Has(FlagHeadersEndHeaders) +} + +func (f *HeadersFrame) StreamEnded() bool { + return f.FrameHeader.Flags.Has(FlagHeadersEndStream) +} + +func (f *HeadersFrame) HasPriority() bool { + return f.FrameHeader.Flags.Has(FlagHeadersPriority) +} + +func parseHeadersFrame(fh FrameHeader, p []byte) (_ Frame, err error) { + hf := &HeadersFrame{ + FrameHeader: fh, + } + if fh.StreamID == 0 { + // HEADERS frames MUST be associated with a stream. If a HEADERS frame + // is received whose stream identifier field is 0x0, the recipient MUST + // respond with a connection error (Section 5.4.1) of type + // PROTOCOL_ERROR. + return nil, connError{ErrCodeProtocol, "HEADERS frame with stream ID 0"} + } + var padLength uint8 + if fh.Flags.Has(FlagHeadersPadded) { + if p, padLength, err = readByte(p); err != nil { + return + } + } + if fh.Flags.Has(FlagHeadersPriority) { + var v uint32 + p, v, err = readUint32(p) + if err != nil { + return nil, err + } + hf.Priority.StreamDep = v & 0x7fffffff + hf.Priority.Exclusive = (v != hf.Priority.StreamDep) // high bit was set + p, hf.Priority.Weight, err = readByte(p) + if err != nil { + return nil, err + } + } + if len(p)-int(padLength) <= 0 { + return nil, streamError(fh.StreamID, ErrCodeProtocol) + } + hf.headerFragBuf = p[:len(p)-int(padLength)] + return hf, nil +} + +// HeadersFrameParam are the parameters for writing a HEADERS frame. +type HeadersFrameParam struct { + // StreamID is the required Stream ID to initiate. + StreamID uint32 + // BlockFragment is part (or all) of a Header Block. + BlockFragment []byte + + // EndStream indicates that the header block is the last that + // the endpoint will send for the identified stream. Setting + // this flag causes the stream to enter one of "half closed" + // states. + EndStream bool + + // EndHeaders indicates that this frame contains an entire + // header block and is not followed by any + // CONTINUATION frames. + EndHeaders bool + + // PadLength is the optional number of bytes of zeros to add + // to this frame. + PadLength uint8 + + // Priority, if non-zero, includes stream priority information + // in the HEADER frame. + Priority PriorityParam +} + +// WriteHeaders writes a single HEADERS frame. +// +// This is a low-level header writing method. Encoding headers and +// splitting them into any necessary CONTINUATION frames is handled +// elsewhere. +// +// It will perform exactly one Write to the underlying Writer. +// It is the caller's responsibility to not call other Write methods concurrently. +func (f *Framer) WriteHeaders(p HeadersFrameParam) error { + if !validStreamID(p.StreamID) && !f.AllowIllegalWrites { + return errStreamID + } + var flags Flags + if p.PadLength != 0 { + flags |= FlagHeadersPadded + } + if p.EndStream { + flags |= FlagHeadersEndStream + } + if p.EndHeaders { + flags |= FlagHeadersEndHeaders + } + if !p.Priority.IsZero() { + flags |= FlagHeadersPriority + } + f.startWrite(FrameHeaders, flags, p.StreamID) + if p.PadLength != 0 { + f.writeByte(p.PadLength) + } + if !p.Priority.IsZero() { + v := p.Priority.StreamDep + if !validStreamIDOrZero(v) && !f.AllowIllegalWrites { + return errDepStreamID + } + if p.Priority.Exclusive { + v |= 1 << 31 + } + f.writeUint32(v) + f.writeByte(p.Priority.Weight) + } + f.wbuf = append(f.wbuf, p.BlockFragment...) + f.wbuf = append(f.wbuf, padZeros[:p.PadLength]...) + return f.endWrite() +} + +// A PriorityFrame specifies the sender-advised priority of a stream. +// See http://http2.github.io/http2-spec/#rfc.section.6.3 +type PriorityFrame struct { + FrameHeader + PriorityParam +} + +// PriorityParam are the stream prioritzation parameters. +type PriorityParam struct { + // StreamDep is a 31-bit stream identifier for the + // stream that this stream depends on. Zero means no + // dependency. + StreamDep uint32 + + // Exclusive is whether the dependency is exclusive. + Exclusive bool + + // Weight is the stream's zero-indexed weight. It should be + // set together with StreamDep, or neither should be set. Per + // the spec, "Add one to the value to obtain a weight between + // 1 and 256." + Weight uint8 +} + +func (p PriorityParam) IsZero() bool { + return p == PriorityParam{} +} + +func parsePriorityFrame(fh FrameHeader, payload []byte) (Frame, error) { + if fh.StreamID == 0 { + return nil, connError{ErrCodeProtocol, "PRIORITY frame with stream ID 0"} + } + if len(payload) != 5 { + return nil, connError{ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))} + } + v := binary.BigEndian.Uint32(payload[:4]) + streamID := v & 0x7fffffff // mask off high bit + return &PriorityFrame{ + FrameHeader: fh, + PriorityParam: PriorityParam{ + Weight: payload[4], + StreamDep: streamID, + Exclusive: streamID != v, // was high bit set? + }, + }, nil +} + +// WritePriority writes a PRIORITY frame. +// +// It will perform exactly one Write to the underlying Writer. +// It is the caller's responsibility to not call other Write methods concurrently. +func (f *Framer) WritePriority(streamID uint32, p PriorityParam) error { + if !validStreamID(streamID) && !f.AllowIllegalWrites { + return errStreamID + } + if !validStreamIDOrZero(p.StreamDep) { + return errDepStreamID + } + f.startWrite(FramePriority, 0, streamID) + v := p.StreamDep + if p.Exclusive { + v |= 1 << 31 + } + f.writeUint32(v) + f.writeByte(p.Weight) + return f.endWrite() +} + +// A RSTStreamFrame allows for abnormal termination of a stream. +// See http://http2.github.io/http2-spec/#rfc.section.6.4 +type RSTStreamFrame struct { + FrameHeader + ErrCode ErrCode +} + +func parseRSTStreamFrame(fh FrameHeader, p []byte) (Frame, error) { + if len(p) != 4 { + return nil, ConnectionError(ErrCodeFrameSize) + } + if fh.StreamID == 0 { + return nil, ConnectionError(ErrCodeProtocol) + } + return &RSTStreamFrame{fh, ErrCode(binary.BigEndian.Uint32(p[:4]))}, nil +} + +// WriteRSTStream writes a RST_STREAM frame. +// +// It will perform exactly one Write to the underlying Writer. +// It is the caller's responsibility to not call other Write methods concurrently. +func (f *Framer) WriteRSTStream(streamID uint32, code ErrCode) error { + if !validStreamID(streamID) && !f.AllowIllegalWrites { + return errStreamID + } + f.startWrite(FrameRSTStream, 0, streamID) + f.writeUint32(uint32(code)) + return f.endWrite() +} + +// A ContinuationFrame is used to continue a sequence of header block fragments. +// See http://http2.github.io/http2-spec/#rfc.section.6.10 +type ContinuationFrame struct { + FrameHeader + headerFragBuf []byte +} + +func parseContinuationFrame(fh FrameHeader, p []byte) (Frame, error) { + if fh.StreamID == 0 { + return nil, connError{ErrCodeProtocol, "CONTINUATION frame with stream ID 0"} + } + return &ContinuationFrame{fh, p}, nil +} + +func (f *ContinuationFrame) HeaderBlockFragment() []byte { + f.checkValid() + return f.headerFragBuf +} + +func (f *ContinuationFrame) HeadersEnded() bool { + return f.FrameHeader.Flags.Has(FlagContinuationEndHeaders) +} + +// WriteContinuation writes a CONTINUATION frame. +// +// It will perform exactly one Write to the underlying Writer. +// It is the caller's responsibility to not call other Write methods concurrently. +func (f *Framer) WriteContinuation(streamID uint32, endHeaders bool, headerBlockFragment []byte) error { + if !validStreamID(streamID) && !f.AllowIllegalWrites { + return errStreamID + } + var flags Flags + if endHeaders { + flags |= FlagContinuationEndHeaders + } + f.startWrite(FrameContinuation, flags, streamID) + f.wbuf = append(f.wbuf, headerBlockFragment...) + return f.endWrite() +} + +// A PushPromiseFrame is used to initiate a server stream. +// See http://http2.github.io/http2-spec/#rfc.section.6.6 +type PushPromiseFrame struct { + FrameHeader + PromiseID uint32 + headerFragBuf []byte // not owned +} + +func (f *PushPromiseFrame) HeaderBlockFragment() []byte { + f.checkValid() + return f.headerFragBuf +} + +func (f *PushPromiseFrame) HeadersEnded() bool { + return f.FrameHeader.Flags.Has(FlagPushPromiseEndHeaders) +} + +func parsePushPromise(fh FrameHeader, p []byte) (_ Frame, err error) { + pp := &PushPromiseFrame{ + FrameHeader: fh, + } + if pp.StreamID == 0 { + // PUSH_PROMISE frames MUST be associated with an existing, + // peer-initiated stream. The stream identifier of a + // PUSH_PROMISE frame indicates the stream it is associated + // with. If the stream identifier field specifies the value + // 0x0, a recipient MUST respond with a connection error + // (Section 5.4.1) of type PROTOCOL_ERROR. + return nil, ConnectionError(ErrCodeProtocol) + } + // The PUSH_PROMISE frame includes optional padding. + // Padding fields and flags are identical to those defined for DATA frames + var padLength uint8 + if fh.Flags.Has(FlagPushPromisePadded) { + if p, padLength, err = readByte(p); err != nil { + return + } + } + + p, pp.PromiseID, err = readUint32(p) + if err != nil { + return + } + pp.PromiseID = pp.PromiseID & (1<<31 - 1) + + if int(padLength) > len(p) { + // like the DATA frame, error out if padding is longer than the body. + return nil, ConnectionError(ErrCodeProtocol) + } + pp.headerFragBuf = p[:len(p)-int(padLength)] + return pp, nil +} + +// PushPromiseParam are the parameters for writing a PUSH_PROMISE frame. +type PushPromiseParam struct { + // StreamID is the required Stream ID to initiate. + StreamID uint32 + + // PromiseID is the required Stream ID which this + // Push Promises + PromiseID uint32 + + // BlockFragment is part (or all) of a Header Block. + BlockFragment []byte + + // EndHeaders indicates that this frame contains an entire + // header block and is not followed by any + // CONTINUATION frames. + EndHeaders bool + + // PadLength is the optional number of bytes of zeros to add + // to this frame. + PadLength uint8 +} + +// WritePushPromise writes a single PushPromise Frame. +// +// As with Header Frames, This is the low level call for writing +// individual frames. Continuation frames are handled elsewhere. +// +// It will perform exactly one Write to the underlying Writer. +// It is the caller's responsibility to not call other Write methods concurrently. +func (f *Framer) WritePushPromise(p PushPromiseParam) error { + if !validStreamID(p.StreamID) && !f.AllowIllegalWrites { + return errStreamID + } + var flags Flags + if p.PadLength != 0 { + flags |= FlagPushPromisePadded + } + if p.EndHeaders { + flags |= FlagPushPromiseEndHeaders + } + f.startWrite(FramePushPromise, flags, p.StreamID) + if p.PadLength != 0 { + f.writeByte(p.PadLength) + } + if !validStreamID(p.PromiseID) && !f.AllowIllegalWrites { + return errStreamID + } + f.writeUint32(p.PromiseID) + f.wbuf = append(f.wbuf, p.BlockFragment...) + f.wbuf = append(f.wbuf, padZeros[:p.PadLength]...) + return f.endWrite() +} + +// WriteRawFrame writes a raw frame. This can be used to write +// extension frames unknown to this package. +func (f *Framer) WriteRawFrame(t FrameType, flags Flags, streamID uint32, payload []byte) error { + f.startWrite(t, flags, streamID) + f.writeBytes(payload) + return f.endWrite() +} + +func readByte(p []byte) (remain []byte, b byte, err error) { + if len(p) == 0 { + return nil, 0, io.ErrUnexpectedEOF + } + return p[1:], p[0], nil +} + +func readUint32(p []byte) (remain []byte, v uint32, err error) { + if len(p) < 4 { + return nil, 0, io.ErrUnexpectedEOF + } + return p[4:], binary.BigEndian.Uint32(p[:4]), nil +} + +type streamEnder interface { + StreamEnded() bool +} + +type headersEnder interface { + HeadersEnded() bool +} + +type headersOrContinuation interface { + headersEnder + HeaderBlockFragment() []byte +} + +// A MetaHeadersFrame is the representation of one HEADERS frame and +// zero or more contiguous CONTINUATION frames and the decoding of +// their HPACK-encoded contents. +// +// This type of frame does not appear on the wire and is only returned +// by the Framer when Framer.ReadMetaHeaders is set. +type MetaHeadersFrame struct { + *HeadersFrame + + // Fields are the fields contained in the HEADERS and + // CONTINUATION frames. The underlying slice is owned by the + // Framer and must not be retained after the next call to + // ReadFrame. + // + // Fields are guaranteed to be in the correct http2 order and + // not have unknown pseudo header fields or invalid header + // field names or values. Required pseudo header fields may be + // missing, however. Use the MetaHeadersFrame.Pseudo accessor + // method access pseudo headers. + Fields []hpack.HeaderField + + // Truncated is whether the max header list size limit was hit + // and Fields is incomplete. The hpack decoder state is still + // valid, however. + Truncated bool +} + +// PseudoValue returns the given pseudo header field's value. +// The provided pseudo field should not contain the leading colon. +func (mh *MetaHeadersFrame) PseudoValue(pseudo string) string { + for _, hf := range mh.Fields { + if !hf.IsPseudo() { + return "" + } + if hf.Name[1:] == pseudo { + return hf.Value + } + } + return "" +} + +// RegularFields returns the regular (non-pseudo) header fields of mh. +// The caller does not own the returned slice. +func (mh *MetaHeadersFrame) RegularFields() []hpack.HeaderField { + for i, hf := range mh.Fields { + if !hf.IsPseudo() { + return mh.Fields[i:] + } + } + return nil +} + +// PseudoFields returns the pseudo header fields of mh. +// The caller does not own the returned slice. +func (mh *MetaHeadersFrame) PseudoFields() []hpack.HeaderField { + for i, hf := range mh.Fields { + if !hf.IsPseudo() { + return mh.Fields[:i] + } + } + return mh.Fields +} + +func (mh *MetaHeadersFrame) checkPseudos() error { + var isRequest, isResponse bool + pf := mh.PseudoFields() + for i, hf := range pf { + switch hf.Name { + case ":method", ":path", ":scheme", ":authority": + isRequest = true + case ":status": + isResponse = true + default: + return pseudoHeaderError(hf.Name) + } + // Check for duplicates. + // This would be a bad algorithm, but N is 4. + // And this doesn't allocate. + for _, hf2 := range pf[:i] { + if hf.Name == hf2.Name { + return duplicatePseudoHeaderError(hf.Name) + } + } + } + if isRequest && isResponse { + return errMixPseudoHeaderTypes + } + return nil +} + +func (fr *Framer) maxHeaderStringLen() int { + v := fr.maxHeaderListSize() + if uint32(int(v)) == v { + return int(v) + } + // They had a crazy big number for MaxHeaderBytes anyway, + // so give them unlimited header lengths: + return 0 +} + +// readMetaFrame returns 0 or more CONTINUATION frames from fr and +// merge them into into the provided hf and returns a MetaHeadersFrame +// with the decoded hpack values. +func (fr *Framer) readMetaFrame(hf *HeadersFrame) (*MetaHeadersFrame, error) { + if fr.AllowIllegalReads { + return nil, errors.New("illegal use of AllowIllegalReads with ReadMetaHeaders") + } + mh := &MetaHeadersFrame{ + HeadersFrame: hf, + } + var remainSize = fr.maxHeaderListSize() + var sawRegular bool + + var invalid error // pseudo header field errors + hdec := fr.ReadMetaHeaders + hdec.SetEmitEnabled(true) + hdec.SetMaxStringLength(fr.maxHeaderStringLen()) + hdec.SetEmitFunc(func(hf hpack.HeaderField) { + if VerboseLogs && logFrameReads { + log.Printf("http2: decoded hpack field %+v", hf) + } + if !httplex.ValidHeaderFieldValue(hf.Value) { + invalid = headerFieldValueError(hf.Value) + } + isPseudo := strings.HasPrefix(hf.Name, ":") + if isPseudo { + if sawRegular { + invalid = errPseudoAfterRegular + } + } else { + sawRegular = true + if !validWireHeaderFieldName(hf.Name) { + invalid = headerFieldNameError(hf.Name) + } + } + + if invalid != nil { + hdec.SetEmitEnabled(false) + return + } + + size := hf.Size() + if size > remainSize { + hdec.SetEmitEnabled(false) + mh.Truncated = true + return + } + remainSize -= size + + mh.Fields = append(mh.Fields, hf) + }) + // Lose reference to MetaHeadersFrame: + defer hdec.SetEmitFunc(func(hf hpack.HeaderField) {}) + + var hc headersOrContinuation = hf + for { + frag := hc.HeaderBlockFragment() + if _, err := hdec.Write(frag); err != nil { + return nil, ConnectionError(ErrCodeCompression) + } + + if hc.HeadersEnded() { + break + } + if f, err := fr.ReadFrame(); err != nil { + return nil, err + } else { + hc = f.(*ContinuationFrame) // guaranteed by checkFrameOrder + } + } + + mh.HeadersFrame.headerFragBuf = nil + mh.HeadersFrame.invalidate() + + if err := hdec.Close(); err != nil { + return nil, ConnectionError(ErrCodeCompression) + } + if invalid != nil { + fr.errDetail = invalid + if VerboseLogs { + log.Printf("http2: invalid header: %v", invalid) + } + return nil, StreamError{mh.StreamID, ErrCodeProtocol, invalid} + } + if err := mh.checkPseudos(); err != nil { + fr.errDetail = err + if VerboseLogs { + log.Printf("http2: invalid pseudo headers: %v", err) + } + return nil, StreamError{mh.StreamID, ErrCodeProtocol, err} + } + return mh, nil +} + +func summarizeFrame(f Frame) string { + var buf bytes.Buffer + f.Header().writeDebug(&buf) + switch f := f.(type) { + case *SettingsFrame: + n := 0 + f.ForeachSetting(func(s Setting) error { + n++ + if n == 1 { + buf.WriteString(", settings:") + } + fmt.Fprintf(&buf, " %v=%v,", s.ID, s.Val) + return nil + }) + if n > 0 { + buf.Truncate(buf.Len() - 1) // remove trailing comma + } + case *DataFrame: + data := f.Data() + const max = 256 + if len(data) > max { + data = data[:max] + } + fmt.Fprintf(&buf, " data=%q", data) + if len(f.Data()) > max { + fmt.Fprintf(&buf, " (%d bytes omitted)", len(f.Data())-max) + } + case *WindowUpdateFrame: + if f.StreamID == 0 { + buf.WriteString(" (conn)") + } + fmt.Fprintf(&buf, " incr=%v", f.Increment) + case *PingFrame: + fmt.Fprintf(&buf, " ping=%q", f.Data[:]) + case *GoAwayFrame: + fmt.Fprintf(&buf, " LastStreamID=%v ErrCode=%v Debug=%q", + f.LastStreamID, f.ErrCode, f.debugData) + case *RSTStreamFrame: + fmt.Fprintf(&buf, " ErrCode=%v", f.ErrCode) + } + return buf.String() +} diff --git a/vendor/golang.org/x/net/http2/go16.go b/vendor/golang.org/x/net/http2/go16.go new file mode 100644 index 00000000..2b72855f --- /dev/null +++ b/vendor/golang.org/x/net/http2/go16.go @@ -0,0 +1,43 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build go1.6 + +package http2 + +import ( + "crypto/tls" + "net/http" + "time" +) + +func transportExpectContinueTimeout(t1 *http.Transport) time.Duration { + return t1.ExpectContinueTimeout +} + +// isBadCipher reports whether the cipher is blacklisted by the HTTP/2 spec. +func isBadCipher(cipher uint16) bool { + switch cipher { + case tls.TLS_RSA_WITH_RC4_128_SHA, + tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA, + tls.TLS_RSA_WITH_AES_128_CBC_SHA, + tls.TLS_RSA_WITH_AES_256_CBC_SHA, + tls.TLS_RSA_WITH_AES_128_GCM_SHA256, + tls.TLS_RSA_WITH_AES_256_GCM_SHA384, + tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, + tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, + tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, + tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA, + tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, + tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, + tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA: + // Reject cipher suites from Appendix A. + // "This list includes those cipher suites that do not + // offer an ephemeral key exchange and those that are + // based on the TLS null, stream or block cipher type" + return true + default: + return false + } +} diff --git a/vendor/golang.org/x/net/http2/go17.go b/vendor/golang.org/x/net/http2/go17.go new file mode 100644 index 00000000..730319dd --- /dev/null +++ b/vendor/golang.org/x/net/http2/go17.go @@ -0,0 +1,94 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build go1.7 + +package http2 + +import ( + "context" + "net" + "net/http" + "net/http/httptrace" + "time" +) + +type contextContext interface { + context.Context +} + +func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx contextContext, cancel func()) { + ctx, cancel = context.WithCancel(context.Background()) + ctx = context.WithValue(ctx, http.LocalAddrContextKey, c.LocalAddr()) + if hs := opts.baseConfig(); hs != nil { + ctx = context.WithValue(ctx, http.ServerContextKey, hs) + } + return +} + +func contextWithCancel(ctx contextContext) (_ contextContext, cancel func()) { + return context.WithCancel(ctx) +} + +func requestWithContext(req *http.Request, ctx contextContext) *http.Request { + return req.WithContext(ctx) +} + +type clientTrace httptrace.ClientTrace + +func reqContext(r *http.Request) context.Context { return r.Context() } + +func setResponseUncompressed(res *http.Response) { res.Uncompressed = true } + +func traceGotConn(req *http.Request, cc *ClientConn) { + trace := httptrace.ContextClientTrace(req.Context()) + if trace == nil || trace.GotConn == nil { + return + } + ci := httptrace.GotConnInfo{Conn: cc.tconn} + cc.mu.Lock() + ci.Reused = cc.nextStreamID > 1 + ci.WasIdle = len(cc.streams) == 0 && ci.Reused + if ci.WasIdle && !cc.lastActive.IsZero() { + ci.IdleTime = time.Now().Sub(cc.lastActive) + } + cc.mu.Unlock() + + trace.GotConn(ci) +} + +func traceWroteHeaders(trace *clientTrace) { + if trace != nil && trace.WroteHeaders != nil { + trace.WroteHeaders() + } +} + +func traceGot100Continue(trace *clientTrace) { + if trace != nil && trace.Got100Continue != nil { + trace.Got100Continue() + } +} + +func traceWait100Continue(trace *clientTrace) { + if trace != nil && trace.Wait100Continue != nil { + trace.Wait100Continue() + } +} + +func traceWroteRequest(trace *clientTrace, err error) { + if trace != nil && trace.WroteRequest != nil { + trace.WroteRequest(httptrace.WroteRequestInfo{Err: err}) + } +} + +func traceFirstResponseByte(trace *clientTrace) { + if trace != nil && trace.GotFirstResponseByte != nil { + trace.GotFirstResponseByte() + } +} + +func requestTrace(req *http.Request) *clientTrace { + trace := httptrace.ContextClientTrace(req.Context()) + return (*clientTrace)(trace) +} diff --git a/vendor/golang.org/x/net/http2/gotrack.go b/vendor/golang.org/x/net/http2/gotrack.go new file mode 100644 index 00000000..9933c9f8 --- /dev/null +++ b/vendor/golang.org/x/net/http2/gotrack.go @@ -0,0 +1,170 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Defensive debug-only utility to track that functions run on the +// goroutine that they're supposed to. + +package http2 + +import ( + "bytes" + "errors" + "fmt" + "os" + "runtime" + "strconv" + "sync" +) + +var DebugGoroutines = os.Getenv("DEBUG_HTTP2_GOROUTINES") == "1" + +type goroutineLock uint64 + +func newGoroutineLock() goroutineLock { + if !DebugGoroutines { + return 0 + } + return goroutineLock(curGoroutineID()) +} + +func (g goroutineLock) check() { + if !DebugGoroutines { + return + } + if curGoroutineID() != uint64(g) { + panic("running on the wrong goroutine") + } +} + +func (g goroutineLock) checkNotOn() { + if !DebugGoroutines { + return + } + if curGoroutineID() == uint64(g) { + panic("running on the wrong goroutine") + } +} + +var goroutineSpace = []byte("goroutine ") + +func curGoroutineID() uint64 { + bp := littleBuf.Get().(*[]byte) + defer littleBuf.Put(bp) + b := *bp + b = b[:runtime.Stack(b, false)] + // Parse the 4707 out of "goroutine 4707 [" + b = bytes.TrimPrefix(b, goroutineSpace) + i := bytes.IndexByte(b, ' ') + if i < 0 { + panic(fmt.Sprintf("No space found in %q", b)) + } + b = b[:i] + n, err := parseUintBytes(b, 10, 64) + if err != nil { + panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err)) + } + return n +} + +var littleBuf = sync.Pool{ + New: func() interface{} { + buf := make([]byte, 64) + return &buf + }, +} + +// parseUintBytes is like strconv.ParseUint, but using a []byte. +func parseUintBytes(s []byte, base int, bitSize int) (n uint64, err error) { + var cutoff, maxVal uint64 + + if bitSize == 0 { + bitSize = int(strconv.IntSize) + } + + s0 := s + switch { + case len(s) < 1: + err = strconv.ErrSyntax + goto Error + + case 2 <= base && base <= 36: + // valid base; nothing to do + + case base == 0: + // Look for octal, hex prefix. + switch { + case s[0] == '0' && len(s) > 1 && (s[1] == 'x' || s[1] == 'X'): + base = 16 + s = s[2:] + if len(s) < 1 { + err = strconv.ErrSyntax + goto Error + } + case s[0] == '0': + base = 8 + default: + base = 10 + } + + default: + err = errors.New("invalid base " + strconv.Itoa(base)) + goto Error + } + + n = 0 + cutoff = cutoff64(base) + maxVal = 1<= base { + n = 0 + err = strconv.ErrSyntax + goto Error + } + + if n >= cutoff { + // n*base overflows + n = 1<<64 - 1 + err = strconv.ErrRange + goto Error + } + n *= uint64(base) + + n1 := n + uint64(v) + if n1 < n || n1 > maxVal { + // n+v overflows + n = 1<<64 - 1 + err = strconv.ErrRange + goto Error + } + n = n1 + } + + return n, nil + +Error: + return n, &strconv.NumError{Func: "ParseUint", Num: string(s0), Err: err} +} + +// Return the first number n such that n*base >= 1<<64. +func cutoff64(base int) uint64 { + if base < 2 { + return 0 + } + return (1<<64-1)/uint64(base) + 1 +} diff --git a/vendor/golang.org/x/net/http2/headermap.go b/vendor/golang.org/x/net/http2/headermap.go new file mode 100644 index 00000000..c2805f6a --- /dev/null +++ b/vendor/golang.org/x/net/http2/headermap.go @@ -0,0 +1,78 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package http2 + +import ( + "net/http" + "strings" +) + +var ( + commonLowerHeader = map[string]string{} // Go-Canonical-Case -> lower-case + commonCanonHeader = map[string]string{} // lower-case -> Go-Canonical-Case +) + +func init() { + for _, v := range []string{ + "accept", + "accept-charset", + "accept-encoding", + "accept-language", + "accept-ranges", + "age", + "access-control-allow-origin", + "allow", + "authorization", + "cache-control", + "content-disposition", + "content-encoding", + "content-language", + "content-length", + "content-location", + "content-range", + "content-type", + "cookie", + "date", + "etag", + "expect", + "expires", + "from", + "host", + "if-match", + "if-modified-since", + "if-none-match", + "if-unmodified-since", + "last-modified", + "link", + "location", + "max-forwards", + "proxy-authenticate", + "proxy-authorization", + "range", + "referer", + "refresh", + "retry-after", + "server", + "set-cookie", + "strict-transport-security", + "trailer", + "transfer-encoding", + "user-agent", + "vary", + "via", + "www-authenticate", + } { + chk := http.CanonicalHeaderKey(v) + commonLowerHeader[chk] = v + commonCanonHeader[v] = chk + } +} + +func lowerHeader(v string) string { + if s, ok := commonLowerHeader[v]; ok { + return s + } + return strings.ToLower(v) +} diff --git a/vendor/golang.org/x/net/http2/hpack/encode.go b/vendor/golang.org/x/net/http2/hpack/encode.go new file mode 100644 index 00000000..f9bb0339 --- /dev/null +++ b/vendor/golang.org/x/net/http2/hpack/encode.go @@ -0,0 +1,251 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package hpack + +import ( + "io" +) + +const ( + uint32Max = ^uint32(0) + initialHeaderTableSize = 4096 +) + +type Encoder struct { + dynTab dynamicTable + // minSize is the minimum table size set by + // SetMaxDynamicTableSize after the previous Header Table Size + // Update. + minSize uint32 + // maxSizeLimit is the maximum table size this encoder + // supports. This will protect the encoder from too large + // size. + maxSizeLimit uint32 + // tableSizeUpdate indicates whether "Header Table Size + // Update" is required. + tableSizeUpdate bool + w io.Writer + buf []byte +} + +// NewEncoder returns a new Encoder which performs HPACK encoding. An +// encoded data is written to w. +func NewEncoder(w io.Writer) *Encoder { + e := &Encoder{ + minSize: uint32Max, + maxSizeLimit: initialHeaderTableSize, + tableSizeUpdate: false, + w: w, + } + e.dynTab.setMaxSize(initialHeaderTableSize) + return e +} + +// WriteField encodes f into a single Write to e's underlying Writer. +// This function may also produce bytes for "Header Table Size Update" +// if necessary. If produced, it is done before encoding f. +func (e *Encoder) WriteField(f HeaderField) error { + e.buf = e.buf[:0] + + if e.tableSizeUpdate { + e.tableSizeUpdate = false + if e.minSize < e.dynTab.maxSize { + e.buf = appendTableSize(e.buf, e.minSize) + } + e.minSize = uint32Max + e.buf = appendTableSize(e.buf, e.dynTab.maxSize) + } + + idx, nameValueMatch := e.searchTable(f) + if nameValueMatch { + e.buf = appendIndexed(e.buf, idx) + } else { + indexing := e.shouldIndex(f) + if indexing { + e.dynTab.add(f) + } + + if idx == 0 { + e.buf = appendNewName(e.buf, f, indexing) + } else { + e.buf = appendIndexedName(e.buf, f, idx, indexing) + } + } + n, err := e.w.Write(e.buf) + if err == nil && n != len(e.buf) { + err = io.ErrShortWrite + } + return err +} + +// searchTable searches f in both stable and dynamic header tables. +// The static header table is searched first. Only when there is no +// exact match for both name and value, the dynamic header table is +// then searched. If there is no match, i is 0. If both name and value +// match, i is the matched index and nameValueMatch becomes true. If +// only name matches, i points to that index and nameValueMatch +// becomes false. +func (e *Encoder) searchTable(f HeaderField) (i uint64, nameValueMatch bool) { + for idx, hf := range staticTable { + if !constantTimeStringCompare(hf.Name, f.Name) { + continue + } + if i == 0 { + i = uint64(idx + 1) + } + if f.Sensitive { + continue + } + if !constantTimeStringCompare(hf.Value, f.Value) { + continue + } + i = uint64(idx + 1) + nameValueMatch = true + return + } + + j, nameValueMatch := e.dynTab.search(f) + if nameValueMatch || (i == 0 && j != 0) { + i = j + uint64(len(staticTable)) + } + return +} + +// SetMaxDynamicTableSize changes the dynamic header table size to v. +// The actual size is bounded by the value passed to +// SetMaxDynamicTableSizeLimit. +func (e *Encoder) SetMaxDynamicTableSize(v uint32) { + if v > e.maxSizeLimit { + v = e.maxSizeLimit + } + if v < e.minSize { + e.minSize = v + } + e.tableSizeUpdate = true + e.dynTab.setMaxSize(v) +} + +// SetMaxDynamicTableSizeLimit changes the maximum value that can be +// specified in SetMaxDynamicTableSize to v. By default, it is set to +// 4096, which is the same size of the default dynamic header table +// size described in HPACK specification. If the current maximum +// dynamic header table size is strictly greater than v, "Header Table +// Size Update" will be done in the next WriteField call and the +// maximum dynamic header table size is truncated to v. +func (e *Encoder) SetMaxDynamicTableSizeLimit(v uint32) { + e.maxSizeLimit = v + if e.dynTab.maxSize > v { + e.tableSizeUpdate = true + e.dynTab.setMaxSize(v) + } +} + +// shouldIndex reports whether f should be indexed. +func (e *Encoder) shouldIndex(f HeaderField) bool { + return !f.Sensitive && f.Size() <= e.dynTab.maxSize +} + +// appendIndexed appends index i, as encoded in "Indexed Header Field" +// representation, to dst and returns the extended buffer. +func appendIndexed(dst []byte, i uint64) []byte { + first := len(dst) + dst = appendVarInt(dst, 7, i) + dst[first] |= 0x80 + return dst +} + +// appendNewName appends f, as encoded in one of "Literal Header field +// - New Name" representation variants, to dst and returns the +// extended buffer. +// +// If f.Sensitive is true, "Never Indexed" representation is used. If +// f.Sensitive is false and indexing is true, "Inremental Indexing" +// representation is used. +func appendNewName(dst []byte, f HeaderField, indexing bool) []byte { + dst = append(dst, encodeTypeByte(indexing, f.Sensitive)) + dst = appendHpackString(dst, f.Name) + return appendHpackString(dst, f.Value) +} + +// appendIndexedName appends f and index i referring indexed name +// entry, as encoded in one of "Literal Header field - Indexed Name" +// representation variants, to dst and returns the extended buffer. +// +// If f.Sensitive is true, "Never Indexed" representation is used. If +// f.Sensitive is false and indexing is true, "Incremental Indexing" +// representation is used. +func appendIndexedName(dst []byte, f HeaderField, i uint64, indexing bool) []byte { + first := len(dst) + var n byte + if indexing { + n = 6 + } else { + n = 4 + } + dst = appendVarInt(dst, n, i) + dst[first] |= encodeTypeByte(indexing, f.Sensitive) + return appendHpackString(dst, f.Value) +} + +// appendTableSize appends v, as encoded in "Header Table Size Update" +// representation, to dst and returns the extended buffer. +func appendTableSize(dst []byte, v uint32) []byte { + first := len(dst) + dst = appendVarInt(dst, 5, uint64(v)) + dst[first] |= 0x20 + return dst +} + +// appendVarInt appends i, as encoded in variable integer form using n +// bit prefix, to dst and returns the extended buffer. +// +// See +// http://http2.github.io/http2-spec/compression.html#integer.representation +func appendVarInt(dst []byte, n byte, i uint64) []byte { + k := uint64((1 << n) - 1) + if i < k { + return append(dst, byte(i)) + } + dst = append(dst, byte(k)) + i -= k + for ; i >= 128; i >>= 7 { + dst = append(dst, byte(0x80|(i&0x7f))) + } + return append(dst, byte(i)) +} + +// appendHpackString appends s, as encoded in "String Literal" +// representation, to dst and returns the the extended buffer. +// +// s will be encoded in Huffman codes only when it produces strictly +// shorter byte string. +func appendHpackString(dst []byte, s string) []byte { + huffmanLength := HuffmanEncodeLength(s) + if huffmanLength < uint64(len(s)) { + first := len(dst) + dst = appendVarInt(dst, 7, huffmanLength) + dst = AppendHuffmanString(dst, s) + dst[first] |= 0x80 + } else { + dst = appendVarInt(dst, 7, uint64(len(s))) + dst = append(dst, s...) + } + return dst +} + +// encodeTypeByte returns type byte. If sensitive is true, type byte +// for "Never Indexed" representation is returned. If sensitive is +// false and indexing is true, type byte for "Incremental Indexing" +// representation is returned. Otherwise, type byte for "Without +// Indexing" is returned. +func encodeTypeByte(indexing, sensitive bool) byte { + if sensitive { + return 0x10 + } + if indexing { + return 0x40 + } + return 0 +} diff --git a/vendor/golang.org/x/net/http2/hpack/hpack.go b/vendor/golang.org/x/net/http2/hpack/hpack.go new file mode 100644 index 00000000..8aa197ad --- /dev/null +++ b/vendor/golang.org/x/net/http2/hpack/hpack.go @@ -0,0 +1,542 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package hpack implements HPACK, a compression format for +// efficiently representing HTTP header fields in the context of HTTP/2. +// +// See http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09 +package hpack + +import ( + "bytes" + "errors" + "fmt" +) + +// A DecodingError is something the spec defines as a decoding error. +type DecodingError struct { + Err error +} + +func (de DecodingError) Error() string { + return fmt.Sprintf("decoding error: %v", de.Err) +} + +// An InvalidIndexError is returned when an encoder references a table +// entry before the static table or after the end of the dynamic table. +type InvalidIndexError int + +func (e InvalidIndexError) Error() string { + return fmt.Sprintf("invalid indexed representation index %d", int(e)) +} + +// A HeaderField is a name-value pair. Both the name and value are +// treated as opaque sequences of octets. +type HeaderField struct { + Name, Value string + + // Sensitive means that this header field should never be + // indexed. + Sensitive bool +} + +// IsPseudo reports whether the header field is an http2 pseudo header. +// That is, it reports whether it starts with a colon. +// It is not otherwise guaranteed to be a valid pseudo header field, +// though. +func (hf HeaderField) IsPseudo() bool { + return len(hf.Name) != 0 && hf.Name[0] == ':' +} + +func (hf HeaderField) String() string { + var suffix string + if hf.Sensitive { + suffix = " (sensitive)" + } + return fmt.Sprintf("header field %q = %q%s", hf.Name, hf.Value, suffix) +} + +// Size returns the size of an entry per RFC 7540 section 5.2. +func (hf HeaderField) Size() uint32 { + // http://http2.github.io/http2-spec/compression.html#rfc.section.4.1 + // "The size of the dynamic table is the sum of the size of + // its entries. The size of an entry is the sum of its name's + // length in octets (as defined in Section 5.2), its value's + // length in octets (see Section 5.2), plus 32. The size of + // an entry is calculated using the length of the name and + // value without any Huffman encoding applied." + + // This can overflow if somebody makes a large HeaderField + // Name and/or Value by hand, but we don't care, because that + // won't happen on the wire because the encoding doesn't allow + // it. + return uint32(len(hf.Name) + len(hf.Value) + 32) +} + +// A Decoder is the decoding context for incremental processing of +// header blocks. +type Decoder struct { + dynTab dynamicTable + emit func(f HeaderField) + + emitEnabled bool // whether calls to emit are enabled + maxStrLen int // 0 means unlimited + + // buf is the unparsed buffer. It's only written to + // saveBuf if it was truncated in the middle of a header + // block. Because it's usually not owned, we can only + // process it under Write. + buf []byte // not owned; only valid during Write + + // saveBuf is previous data passed to Write which we weren't able + // to fully parse before. Unlike buf, we own this data. + saveBuf bytes.Buffer +} + +// NewDecoder returns a new decoder with the provided maximum dynamic +// table size. The emitFunc will be called for each valid field +// parsed, in the same goroutine as calls to Write, before Write returns. +func NewDecoder(maxDynamicTableSize uint32, emitFunc func(f HeaderField)) *Decoder { + d := &Decoder{ + emit: emitFunc, + emitEnabled: true, + } + d.dynTab.allowedMaxSize = maxDynamicTableSize + d.dynTab.setMaxSize(maxDynamicTableSize) + return d +} + +// ErrStringLength is returned by Decoder.Write when the max string length +// (as configured by Decoder.SetMaxStringLength) would be violated. +var ErrStringLength = errors.New("hpack: string too long") + +// SetMaxStringLength sets the maximum size of a HeaderField name or +// value string. If a string exceeds this length (even after any +// decompression), Write will return ErrStringLength. +// A value of 0 means unlimited and is the default from NewDecoder. +func (d *Decoder) SetMaxStringLength(n int) { + d.maxStrLen = n +} + +// SetEmitFunc changes the callback used when new header fields +// are decoded. +// It must be non-nil. It does not affect EmitEnabled. +func (d *Decoder) SetEmitFunc(emitFunc func(f HeaderField)) { + d.emit = emitFunc +} + +// SetEmitEnabled controls whether the emitFunc provided to NewDecoder +// should be called. The default is true. +// +// This facility exists to let servers enforce MAX_HEADER_LIST_SIZE +// while still decoding and keeping in-sync with decoder state, but +// without doing unnecessary decompression or generating unnecessary +// garbage for header fields past the limit. +func (d *Decoder) SetEmitEnabled(v bool) { d.emitEnabled = v } + +// EmitEnabled reports whether calls to the emitFunc provided to NewDecoder +// are currently enabled. The default is true. +func (d *Decoder) EmitEnabled() bool { return d.emitEnabled } + +// TODO: add method *Decoder.Reset(maxSize, emitFunc) to let callers re-use Decoders and their +// underlying buffers for garbage reasons. + +func (d *Decoder) SetMaxDynamicTableSize(v uint32) { + d.dynTab.setMaxSize(v) +} + +// SetAllowedMaxDynamicTableSize sets the upper bound that the encoded +// stream (via dynamic table size updates) may set the maximum size +// to. +func (d *Decoder) SetAllowedMaxDynamicTableSize(v uint32) { + d.dynTab.allowedMaxSize = v +} + +type dynamicTable struct { + // ents is the FIFO described at + // http://http2.github.io/http2-spec/compression.html#rfc.section.2.3.2 + // The newest (low index) is append at the end, and items are + // evicted from the front. + ents []HeaderField + size uint32 + maxSize uint32 // current maxSize + allowedMaxSize uint32 // maxSize may go up to this, inclusive +} + +func (dt *dynamicTable) setMaxSize(v uint32) { + dt.maxSize = v + dt.evict() +} + +// TODO: change dynamicTable to be a struct with a slice and a size int field, +// per http://http2.github.io/http2-spec/compression.html#rfc.section.4.1: +// +// +// Then make add increment the size. maybe the max size should move from Decoder to +// dynamicTable and add should return an ok bool if there was enough space. +// +// Later we'll need a remove operation on dynamicTable. + +func (dt *dynamicTable) add(f HeaderField) { + dt.ents = append(dt.ents, f) + dt.size += f.Size() + dt.evict() +} + +// If we're too big, evict old stuff (front of the slice) +func (dt *dynamicTable) evict() { + base := dt.ents // keep base pointer of slice + for dt.size > dt.maxSize { + dt.size -= dt.ents[0].Size() + dt.ents = dt.ents[1:] + } + + // Shift slice contents down if we evicted things. + if len(dt.ents) != len(base) { + copy(base, dt.ents) + dt.ents = base[:len(dt.ents)] + } +} + +// constantTimeStringCompare compares string a and b in a constant +// time manner. +func constantTimeStringCompare(a, b string) bool { + if len(a) != len(b) { + return false + } + + c := byte(0) + + for i := 0; i < len(a); i++ { + c |= a[i] ^ b[i] + } + + return c == 0 +} + +// Search searches f in the table. The return value i is 0 if there is +// no name match. If there is name match or name/value match, i is the +// index of that entry (1-based). If both name and value match, +// nameValueMatch becomes true. +func (dt *dynamicTable) search(f HeaderField) (i uint64, nameValueMatch bool) { + l := len(dt.ents) + for j := l - 1; j >= 0; j-- { + ent := dt.ents[j] + if !constantTimeStringCompare(ent.Name, f.Name) { + continue + } + if i == 0 { + i = uint64(l - j) + } + if f.Sensitive { + continue + } + if !constantTimeStringCompare(ent.Value, f.Value) { + continue + } + i = uint64(l - j) + nameValueMatch = true + return + } + return +} + +func (d *Decoder) maxTableIndex() int { + return len(d.dynTab.ents) + len(staticTable) +} + +func (d *Decoder) at(i uint64) (hf HeaderField, ok bool) { + if i < 1 { + return + } + if i > uint64(d.maxTableIndex()) { + return + } + if i <= uint64(len(staticTable)) { + return staticTable[i-1], true + } + dents := d.dynTab.ents + return dents[len(dents)-(int(i)-len(staticTable))], true +} + +// Decode decodes an entire block. +// +// TODO: remove this method and make it incremental later? This is +// easier for debugging now. +func (d *Decoder) DecodeFull(p []byte) ([]HeaderField, error) { + var hf []HeaderField + saveFunc := d.emit + defer func() { d.emit = saveFunc }() + d.emit = func(f HeaderField) { hf = append(hf, f) } + if _, err := d.Write(p); err != nil { + return nil, err + } + if err := d.Close(); err != nil { + return nil, err + } + return hf, nil +} + +func (d *Decoder) Close() error { + if d.saveBuf.Len() > 0 { + d.saveBuf.Reset() + return DecodingError{errors.New("truncated headers")} + } + return nil +} + +func (d *Decoder) Write(p []byte) (n int, err error) { + if len(p) == 0 { + // Prevent state machine CPU attacks (making us redo + // work up to the point of finding out we don't have + // enough data) + return + } + // Only copy the data if we have to. Optimistically assume + // that p will contain a complete header block. + if d.saveBuf.Len() == 0 { + d.buf = p + } else { + d.saveBuf.Write(p) + d.buf = d.saveBuf.Bytes() + d.saveBuf.Reset() + } + + for len(d.buf) > 0 { + err = d.parseHeaderFieldRepr() + if err == errNeedMore { + // Extra paranoia, making sure saveBuf won't + // get too large. All the varint and string + // reading code earlier should already catch + // overlong things and return ErrStringLength, + // but keep this as a last resort. + const varIntOverhead = 8 // conservative + if d.maxStrLen != 0 && int64(len(d.buf)) > 2*(int64(d.maxStrLen)+varIntOverhead) { + return 0, ErrStringLength + } + d.saveBuf.Write(d.buf) + return len(p), nil + } + if err != nil { + break + } + } + return len(p), err +} + +// errNeedMore is an internal sentinel error value that means the +// buffer is truncated and we need to read more data before we can +// continue parsing. +var errNeedMore = errors.New("need more data") + +type indexType int + +const ( + indexedTrue indexType = iota + indexedFalse + indexedNever +) + +func (v indexType) indexed() bool { return v == indexedTrue } +func (v indexType) sensitive() bool { return v == indexedNever } + +// returns errNeedMore if there isn't enough data available. +// any other error is fatal. +// consumes d.buf iff it returns nil. +// precondition: must be called with len(d.buf) > 0 +func (d *Decoder) parseHeaderFieldRepr() error { + b := d.buf[0] + switch { + case b&128 != 0: + // Indexed representation. + // High bit set? + // http://http2.github.io/http2-spec/compression.html#rfc.section.6.1 + return d.parseFieldIndexed() + case b&192 == 64: + // 6.2.1 Literal Header Field with Incremental Indexing + // 0b10xxxxxx: top two bits are 10 + // http://http2.github.io/http2-spec/compression.html#rfc.section.6.2.1 + return d.parseFieldLiteral(6, indexedTrue) + case b&240 == 0: + // 6.2.2 Literal Header Field without Indexing + // 0b0000xxxx: top four bits are 0000 + // http://http2.github.io/http2-spec/compression.html#rfc.section.6.2.2 + return d.parseFieldLiteral(4, indexedFalse) + case b&240 == 16: + // 6.2.3 Literal Header Field never Indexed + // 0b0001xxxx: top four bits are 0001 + // http://http2.github.io/http2-spec/compression.html#rfc.section.6.2.3 + return d.parseFieldLiteral(4, indexedNever) + case b&224 == 32: + // 6.3 Dynamic Table Size Update + // Top three bits are '001'. + // http://http2.github.io/http2-spec/compression.html#rfc.section.6.3 + return d.parseDynamicTableSizeUpdate() + } + + return DecodingError{errors.New("invalid encoding")} +} + +// (same invariants and behavior as parseHeaderFieldRepr) +func (d *Decoder) parseFieldIndexed() error { + buf := d.buf + idx, buf, err := readVarInt(7, buf) + if err != nil { + return err + } + hf, ok := d.at(idx) + if !ok { + return DecodingError{InvalidIndexError(idx)} + } + d.buf = buf + return d.callEmit(HeaderField{Name: hf.Name, Value: hf.Value}) +} + +// (same invariants and behavior as parseHeaderFieldRepr) +func (d *Decoder) parseFieldLiteral(n uint8, it indexType) error { + buf := d.buf + nameIdx, buf, err := readVarInt(n, buf) + if err != nil { + return err + } + + var hf HeaderField + wantStr := d.emitEnabled || it.indexed() + if nameIdx > 0 { + ihf, ok := d.at(nameIdx) + if !ok { + return DecodingError{InvalidIndexError(nameIdx)} + } + hf.Name = ihf.Name + } else { + hf.Name, buf, err = d.readString(buf, wantStr) + if err != nil { + return err + } + } + hf.Value, buf, err = d.readString(buf, wantStr) + if err != nil { + return err + } + d.buf = buf + if it.indexed() { + d.dynTab.add(hf) + } + hf.Sensitive = it.sensitive() + return d.callEmit(hf) +} + +func (d *Decoder) callEmit(hf HeaderField) error { + if d.maxStrLen != 0 { + if len(hf.Name) > d.maxStrLen || len(hf.Value) > d.maxStrLen { + return ErrStringLength + } + } + if d.emitEnabled { + d.emit(hf) + } + return nil +} + +// (same invariants and behavior as parseHeaderFieldRepr) +func (d *Decoder) parseDynamicTableSizeUpdate() error { + buf := d.buf + size, buf, err := readVarInt(5, buf) + if err != nil { + return err + } + if size > uint64(d.dynTab.allowedMaxSize) { + return DecodingError{errors.New("dynamic table size update too large")} + } + d.dynTab.setMaxSize(uint32(size)) + d.buf = buf + return nil +} + +var errVarintOverflow = DecodingError{errors.New("varint integer overflow")} + +// readVarInt reads an unsigned variable length integer off the +// beginning of p. n is the parameter as described in +// http://http2.github.io/http2-spec/compression.html#rfc.section.5.1. +// +// n must always be between 1 and 8. +// +// The returned remain buffer is either a smaller suffix of p, or err != nil. +// The error is errNeedMore if p doesn't contain a complete integer. +func readVarInt(n byte, p []byte) (i uint64, remain []byte, err error) { + if n < 1 || n > 8 { + panic("bad n") + } + if len(p) == 0 { + return 0, p, errNeedMore + } + i = uint64(p[0]) + if n < 8 { + i &= (1 << uint64(n)) - 1 + } + if i < (1< 0 { + b := p[0] + p = p[1:] + i += uint64(b&127) << m + if b&128 == 0 { + return i, p, nil + } + m += 7 + if m >= 63 { // TODO: proper overflow check. making this up. + return 0, origP, errVarintOverflow + } + } + return 0, origP, errNeedMore +} + +// readString decodes an hpack string from p. +// +// wantStr is whether s will be used. If false, decompression and +// []byte->string garbage are skipped if s will be ignored +// anyway. This does mean that huffman decoding errors for non-indexed +// strings past the MAX_HEADER_LIST_SIZE are ignored, but the server +// is returning an error anyway, and because they're not indexed, the error +// won't affect the decoding state. +func (d *Decoder) readString(p []byte, wantStr bool) (s string, remain []byte, err error) { + if len(p) == 0 { + return "", p, errNeedMore + } + isHuff := p[0]&128 != 0 + strLen, p, err := readVarInt(7, p) + if err != nil { + return "", p, err + } + if d.maxStrLen != 0 && strLen > uint64(d.maxStrLen) { + return "", nil, ErrStringLength + } + if uint64(len(p)) < strLen { + return "", p, errNeedMore + } + if !isHuff { + if wantStr { + s = string(p[:strLen]) + } + return s, p[strLen:], nil + } + + if wantStr { + buf := bufPool.Get().(*bytes.Buffer) + buf.Reset() // don't trust others + defer bufPool.Put(buf) + if err := huffmanDecode(buf, d.maxStrLen, p[:strLen]); err != nil { + buf.Reset() + return "", nil, err + } + s = buf.String() + buf.Reset() // be nice to GC + } + return s, p[strLen:], nil +} diff --git a/vendor/golang.org/x/net/http2/hpack/huffman.go b/vendor/golang.org/x/net/http2/hpack/huffman.go new file mode 100644 index 00000000..8850e394 --- /dev/null +++ b/vendor/golang.org/x/net/http2/hpack/huffman.go @@ -0,0 +1,212 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package hpack + +import ( + "bytes" + "errors" + "io" + "sync" +) + +var bufPool = sync.Pool{ + New: func() interface{} { return new(bytes.Buffer) }, +} + +// HuffmanDecode decodes the string in v and writes the expanded +// result to w, returning the number of bytes written to w and the +// Write call's return value. At most one Write call is made. +func HuffmanDecode(w io.Writer, v []byte) (int, error) { + buf := bufPool.Get().(*bytes.Buffer) + buf.Reset() + defer bufPool.Put(buf) + if err := huffmanDecode(buf, 0, v); err != nil { + return 0, err + } + return w.Write(buf.Bytes()) +} + +// HuffmanDecodeToString decodes the string in v. +func HuffmanDecodeToString(v []byte) (string, error) { + buf := bufPool.Get().(*bytes.Buffer) + buf.Reset() + defer bufPool.Put(buf) + if err := huffmanDecode(buf, 0, v); err != nil { + return "", err + } + return buf.String(), nil +} + +// ErrInvalidHuffman is returned for errors found decoding +// Huffman-encoded strings. +var ErrInvalidHuffman = errors.New("hpack: invalid Huffman-encoded data") + +// huffmanDecode decodes v to buf. +// If maxLen is greater than 0, attempts to write more to buf than +// maxLen bytes will return ErrStringLength. +func huffmanDecode(buf *bytes.Buffer, maxLen int, v []byte) error { + n := rootHuffmanNode + // cur is the bit buffer that has not been fed into n. + // cbits is the number of low order bits in cur that are valid. + // sbits is the number of bits of the symbol prefix being decoded. + cur, cbits, sbits := uint(0), uint8(0), uint8(0) + for _, b := range v { + cur = cur<<8 | uint(b) + cbits += 8 + sbits += 8 + for cbits >= 8 { + idx := byte(cur >> (cbits - 8)) + n = n.children[idx] + if n == nil { + return ErrInvalidHuffman + } + if n.children == nil { + if maxLen != 0 && buf.Len() == maxLen { + return ErrStringLength + } + buf.WriteByte(n.sym) + cbits -= n.codeLen + n = rootHuffmanNode + sbits = cbits + } else { + cbits -= 8 + } + } + } + for cbits > 0 { + n = n.children[byte(cur<<(8-cbits))] + if n == nil { + return ErrInvalidHuffman + } + if n.children != nil || n.codeLen > cbits { + break + } + if maxLen != 0 && buf.Len() == maxLen { + return ErrStringLength + } + buf.WriteByte(n.sym) + cbits -= n.codeLen + n = rootHuffmanNode + sbits = cbits + } + if sbits > 7 { + // Either there was an incomplete symbol, or overlong padding. + // Both are decoding errors per RFC 7541 section 5.2. + return ErrInvalidHuffman + } + if mask := uint(1< 8 { + codeLen -= 8 + i := uint8(code >> codeLen) + if cur.children[i] == nil { + cur.children[i] = newInternalNode() + } + cur = cur.children[i] + } + shift := 8 - codeLen + start, end := int(uint8(code<> (nbits - rembits)) + dst[len(dst)-1] |= t + } + + return dst +} + +// HuffmanEncodeLength returns the number of bytes required to encode +// s in Huffman codes. The result is round up to byte boundary. +func HuffmanEncodeLength(s string) uint64 { + n := uint64(0) + for i := 0; i < len(s); i++ { + n += uint64(huffmanCodeLen[s[i]]) + } + return (n + 7) / 8 +} + +// appendByteToHuffmanCode appends Huffman code for c to dst and +// returns the extended buffer and the remaining bits in the last +// element. The appending is not byte aligned and the remaining bits +// in the last element of dst is given in rembits. +func appendByteToHuffmanCode(dst []byte, rembits uint8, c byte) ([]byte, uint8) { + code := huffmanCodes[c] + nbits := huffmanCodeLen[c] + + for { + if rembits > nbits { + t := uint8(code << (rembits - nbits)) + dst[len(dst)-1] |= t + rembits -= nbits + break + } + + t := uint8(code >> (nbits - rembits)) + dst[len(dst)-1] |= t + + nbits -= rembits + rembits = 8 + + if nbits == 0 { + break + } + + dst = append(dst, 0) + } + + return dst, rembits +} diff --git a/vendor/golang.org/x/net/http2/hpack/tables.go b/vendor/golang.org/x/net/http2/hpack/tables.go new file mode 100644 index 00000000..b9283a02 --- /dev/null +++ b/vendor/golang.org/x/net/http2/hpack/tables.go @@ -0,0 +1,352 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package hpack + +func pair(name, value string) HeaderField { + return HeaderField{Name: name, Value: value} +} + +// http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-07#appendix-B +var staticTable = [...]HeaderField{ + pair(":authority", ""), // index 1 (1-based) + pair(":method", "GET"), + pair(":method", "POST"), + pair(":path", "/"), + pair(":path", "/index.html"), + pair(":scheme", "http"), + pair(":scheme", "https"), + pair(":status", "200"), + pair(":status", "204"), + pair(":status", "206"), + pair(":status", "304"), + pair(":status", "400"), + pair(":status", "404"), + pair(":status", "500"), + pair("accept-charset", ""), + pair("accept-encoding", "gzip, deflate"), + pair("accept-language", ""), + pair("accept-ranges", ""), + pair("accept", ""), + pair("access-control-allow-origin", ""), + pair("age", ""), + pair("allow", ""), + pair("authorization", ""), + pair("cache-control", ""), + pair("content-disposition", ""), + pair("content-encoding", ""), + pair("content-language", ""), + pair("content-length", ""), + pair("content-location", ""), + pair("content-range", ""), + pair("content-type", ""), + pair("cookie", ""), + pair("date", ""), + pair("etag", ""), + pair("expect", ""), + pair("expires", ""), + pair("from", ""), + pair("host", ""), + pair("if-match", ""), + pair("if-modified-since", ""), + pair("if-none-match", ""), + pair("if-range", ""), + pair("if-unmodified-since", ""), + pair("last-modified", ""), + pair("link", ""), + pair("location", ""), + pair("max-forwards", ""), + pair("proxy-authenticate", ""), + pair("proxy-authorization", ""), + pair("range", ""), + pair("referer", ""), + pair("refresh", ""), + pair("retry-after", ""), + pair("server", ""), + pair("set-cookie", ""), + pair("strict-transport-security", ""), + pair("transfer-encoding", ""), + pair("user-agent", ""), + pair("vary", ""), + pair("via", ""), + pair("www-authenticate", ""), +} + +var huffmanCodes = [256]uint32{ + 0x1ff8, + 0x7fffd8, + 0xfffffe2, + 0xfffffe3, + 0xfffffe4, + 0xfffffe5, + 0xfffffe6, + 0xfffffe7, + 0xfffffe8, + 0xffffea, + 0x3ffffffc, + 0xfffffe9, + 0xfffffea, + 0x3ffffffd, + 0xfffffeb, + 0xfffffec, + 0xfffffed, + 0xfffffee, + 0xfffffef, + 0xffffff0, + 0xffffff1, + 0xffffff2, + 0x3ffffffe, + 0xffffff3, + 0xffffff4, + 0xffffff5, + 0xffffff6, + 0xffffff7, + 0xffffff8, + 0xffffff9, + 0xffffffa, + 0xffffffb, + 0x14, + 0x3f8, + 0x3f9, + 0xffa, + 0x1ff9, + 0x15, + 0xf8, + 0x7fa, + 0x3fa, + 0x3fb, + 0xf9, + 0x7fb, + 0xfa, + 0x16, + 0x17, + 0x18, + 0x0, + 0x1, + 0x2, + 0x19, + 0x1a, + 0x1b, + 0x1c, + 0x1d, + 0x1e, + 0x1f, + 0x5c, + 0xfb, + 0x7ffc, + 0x20, + 0xffb, + 0x3fc, + 0x1ffa, + 0x21, + 0x5d, + 0x5e, + 0x5f, + 0x60, + 0x61, + 0x62, + 0x63, + 0x64, + 0x65, + 0x66, + 0x67, + 0x68, + 0x69, + 0x6a, + 0x6b, + 0x6c, + 0x6d, + 0x6e, + 0x6f, + 0x70, + 0x71, + 0x72, + 0xfc, + 0x73, + 0xfd, + 0x1ffb, + 0x7fff0, + 0x1ffc, + 0x3ffc, + 0x22, + 0x7ffd, + 0x3, + 0x23, + 0x4, + 0x24, + 0x5, + 0x25, + 0x26, + 0x27, + 0x6, + 0x74, + 0x75, + 0x28, + 0x29, + 0x2a, + 0x7, + 0x2b, + 0x76, + 0x2c, + 0x8, + 0x9, + 0x2d, + 0x77, + 0x78, + 0x79, + 0x7a, + 0x7b, + 0x7ffe, + 0x7fc, + 0x3ffd, + 0x1ffd, + 0xffffffc, + 0xfffe6, + 0x3fffd2, + 0xfffe7, + 0xfffe8, + 0x3fffd3, + 0x3fffd4, + 0x3fffd5, + 0x7fffd9, + 0x3fffd6, + 0x7fffda, + 0x7fffdb, + 0x7fffdc, + 0x7fffdd, + 0x7fffde, + 0xffffeb, + 0x7fffdf, + 0xffffec, + 0xffffed, + 0x3fffd7, + 0x7fffe0, + 0xffffee, + 0x7fffe1, + 0x7fffe2, + 0x7fffe3, + 0x7fffe4, + 0x1fffdc, + 0x3fffd8, + 0x7fffe5, + 0x3fffd9, + 0x7fffe6, + 0x7fffe7, + 0xffffef, + 0x3fffda, + 0x1fffdd, + 0xfffe9, + 0x3fffdb, + 0x3fffdc, + 0x7fffe8, + 0x7fffe9, + 0x1fffde, + 0x7fffea, + 0x3fffdd, + 0x3fffde, + 0xfffff0, + 0x1fffdf, + 0x3fffdf, + 0x7fffeb, + 0x7fffec, + 0x1fffe0, + 0x1fffe1, + 0x3fffe0, + 0x1fffe2, + 0x7fffed, + 0x3fffe1, + 0x7fffee, + 0x7fffef, + 0xfffea, + 0x3fffe2, + 0x3fffe3, + 0x3fffe4, + 0x7ffff0, + 0x3fffe5, + 0x3fffe6, + 0x7ffff1, + 0x3ffffe0, + 0x3ffffe1, + 0xfffeb, + 0x7fff1, + 0x3fffe7, + 0x7ffff2, + 0x3fffe8, + 0x1ffffec, + 0x3ffffe2, + 0x3ffffe3, + 0x3ffffe4, + 0x7ffffde, + 0x7ffffdf, + 0x3ffffe5, + 0xfffff1, + 0x1ffffed, + 0x7fff2, + 0x1fffe3, + 0x3ffffe6, + 0x7ffffe0, + 0x7ffffe1, + 0x3ffffe7, + 0x7ffffe2, + 0xfffff2, + 0x1fffe4, + 0x1fffe5, + 0x3ffffe8, + 0x3ffffe9, + 0xffffffd, + 0x7ffffe3, + 0x7ffffe4, + 0x7ffffe5, + 0xfffec, + 0xfffff3, + 0xfffed, + 0x1fffe6, + 0x3fffe9, + 0x1fffe7, + 0x1fffe8, + 0x7ffff3, + 0x3fffea, + 0x3fffeb, + 0x1ffffee, + 0x1ffffef, + 0xfffff4, + 0xfffff5, + 0x3ffffea, + 0x7ffff4, + 0x3ffffeb, + 0x7ffffe6, + 0x3ffffec, + 0x3ffffed, + 0x7ffffe7, + 0x7ffffe8, + 0x7ffffe9, + 0x7ffffea, + 0x7ffffeb, + 0xffffffe, + 0x7ffffec, + 0x7ffffed, + 0x7ffffee, + 0x7ffffef, + 0x7fffff0, + 0x3ffffee, +} + +var huffmanCodeLen = [256]uint8{ + 13, 23, 28, 28, 28, 28, 28, 28, 28, 24, 30, 28, 28, 30, 28, 28, + 28, 28, 28, 28, 28, 28, 30, 28, 28, 28, 28, 28, 28, 28, 28, 28, + 6, 10, 10, 12, 13, 6, 8, 11, 10, 10, 8, 11, 8, 6, 6, 6, + 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 8, 15, 6, 12, 10, + 13, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, 13, 19, 13, 14, 6, + 15, 5, 6, 5, 6, 5, 6, 6, 6, 5, 7, 7, 6, 6, 6, 5, + 6, 7, 6, 5, 5, 6, 7, 7, 7, 7, 7, 15, 11, 14, 13, 28, + 20, 22, 20, 20, 22, 22, 22, 23, 22, 23, 23, 23, 23, 23, 24, 23, + 24, 24, 22, 23, 24, 23, 23, 23, 23, 21, 22, 23, 22, 23, 23, 24, + 22, 21, 20, 22, 22, 23, 23, 21, 23, 22, 22, 24, 21, 22, 23, 23, + 21, 21, 22, 21, 23, 22, 23, 23, 20, 22, 22, 22, 23, 22, 22, 23, + 26, 26, 20, 19, 22, 23, 22, 25, 26, 26, 26, 27, 27, 26, 24, 25, + 19, 21, 26, 27, 27, 26, 27, 24, 21, 21, 26, 26, 28, 27, 27, 27, + 20, 24, 20, 21, 22, 21, 21, 23, 22, 22, 25, 25, 24, 24, 26, 23, + 26, 27, 26, 26, 27, 27, 27, 27, 27, 28, 27, 27, 27, 27, 27, 26, +} diff --git a/vendor/golang.org/x/net/http2/http2.go b/vendor/golang.org/x/net/http2/http2.go new file mode 100644 index 00000000..f06e87b3 --- /dev/null +++ b/vendor/golang.org/x/net/http2/http2.go @@ -0,0 +1,352 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package http2 implements the HTTP/2 protocol. +// +// This package is low-level and intended to be used directly by very +// few people. Most users will use it indirectly through the automatic +// use by the net/http package (from Go 1.6 and later). +// For use in earlier Go versions see ConfigureServer. (Transport support +// requires Go 1.6 or later) +// +// See https://http2.github.io/ for more information on HTTP/2. +// +// See https://http2.golang.org/ for a test server running this code. +// +package http2 // import "golang.org/x/net/http2" + +import ( + "bufio" + "crypto/tls" + "errors" + "fmt" + "io" + "net/http" + "os" + "sort" + "strconv" + "strings" + "sync" + + "golang.org/x/net/lex/httplex" +) + +var ( + VerboseLogs bool + logFrameWrites bool + logFrameReads bool +) + +func init() { + e := os.Getenv("GODEBUG") + if strings.Contains(e, "http2debug=1") { + VerboseLogs = true + } + if strings.Contains(e, "http2debug=2") { + VerboseLogs = true + logFrameWrites = true + logFrameReads = true + } +} + +const ( + // ClientPreface is the string that must be sent by new + // connections from clients. + ClientPreface = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" + + // SETTINGS_MAX_FRAME_SIZE default + // http://http2.github.io/http2-spec/#rfc.section.6.5.2 + initialMaxFrameSize = 16384 + + // NextProtoTLS is the NPN/ALPN protocol negotiated during + // HTTP/2's TLS setup. + NextProtoTLS = "h2" + + // http://http2.github.io/http2-spec/#SettingValues + initialHeaderTableSize = 4096 + + initialWindowSize = 65535 // 6.9.2 Initial Flow Control Window Size + + defaultMaxReadFrameSize = 1 << 20 +) + +var ( + clientPreface = []byte(ClientPreface) +) + +type streamState int + +const ( + stateIdle streamState = iota + stateOpen + stateHalfClosedLocal + stateHalfClosedRemote + stateResvLocal + stateResvRemote + stateClosed +) + +var stateName = [...]string{ + stateIdle: "Idle", + stateOpen: "Open", + stateHalfClosedLocal: "HalfClosedLocal", + stateHalfClosedRemote: "HalfClosedRemote", + stateResvLocal: "ResvLocal", + stateResvRemote: "ResvRemote", + stateClosed: "Closed", +} + +func (st streamState) String() string { + return stateName[st] +} + +// Setting is a setting parameter: which setting it is, and its value. +type Setting struct { + // ID is which setting is being set. + // See http://http2.github.io/http2-spec/#SettingValues + ID SettingID + + // Val is the value. + Val uint32 +} + +func (s Setting) String() string { + return fmt.Sprintf("[%v = %d]", s.ID, s.Val) +} + +// Valid reports whether the setting is valid. +func (s Setting) Valid() error { + // Limits and error codes from 6.5.2 Defined SETTINGS Parameters + switch s.ID { + case SettingEnablePush: + if s.Val != 1 && s.Val != 0 { + return ConnectionError(ErrCodeProtocol) + } + case SettingInitialWindowSize: + if s.Val > 1<<31-1 { + return ConnectionError(ErrCodeFlowControl) + } + case SettingMaxFrameSize: + if s.Val < 16384 || s.Val > 1<<24-1 { + return ConnectionError(ErrCodeProtocol) + } + } + return nil +} + +// A SettingID is an HTTP/2 setting as defined in +// http://http2.github.io/http2-spec/#iana-settings +type SettingID uint16 + +const ( + SettingHeaderTableSize SettingID = 0x1 + SettingEnablePush SettingID = 0x2 + SettingMaxConcurrentStreams SettingID = 0x3 + SettingInitialWindowSize SettingID = 0x4 + SettingMaxFrameSize SettingID = 0x5 + SettingMaxHeaderListSize SettingID = 0x6 +) + +var settingName = map[SettingID]string{ + SettingHeaderTableSize: "HEADER_TABLE_SIZE", + SettingEnablePush: "ENABLE_PUSH", + SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", + SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", + SettingMaxFrameSize: "MAX_FRAME_SIZE", + SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", +} + +func (s SettingID) String() string { + if v, ok := settingName[s]; ok { + return v + } + return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s)) +} + +var ( + errInvalidHeaderFieldName = errors.New("http2: invalid header field name") + errInvalidHeaderFieldValue = errors.New("http2: invalid header field value") +) + +// validWireHeaderFieldName reports whether v is a valid header field +// name (key). See httplex.ValidHeaderName for the base rules. +// +// Further, http2 says: +// "Just as in HTTP/1.x, header field names are strings of ASCII +// characters that are compared in a case-insensitive +// fashion. However, header field names MUST be converted to +// lowercase prior to their encoding in HTTP/2. " +func validWireHeaderFieldName(v string) bool { + if len(v) == 0 { + return false + } + for _, r := range v { + if !httplex.IsTokenRune(r) { + return false + } + if 'A' <= r && r <= 'Z' { + return false + } + } + return true +} + +var httpCodeStringCommon = map[int]string{} // n -> strconv.Itoa(n) + +func init() { + for i := 100; i <= 999; i++ { + if v := http.StatusText(i); v != "" { + httpCodeStringCommon[i] = strconv.Itoa(i) + } + } +} + +func httpCodeString(code int) string { + if s, ok := httpCodeStringCommon[code]; ok { + return s + } + return strconv.Itoa(code) +} + +// from pkg io +type stringWriter interface { + WriteString(s string) (n int, err error) +} + +// A gate lets two goroutines coordinate their activities. +type gate chan struct{} + +func (g gate) Done() { g <- struct{}{} } +func (g gate) Wait() { <-g } + +// A closeWaiter is like a sync.WaitGroup but only goes 1 to 0 (open to closed). +type closeWaiter chan struct{} + +// Init makes a closeWaiter usable. +// It exists because so a closeWaiter value can be placed inside a +// larger struct and have the Mutex and Cond's memory in the same +// allocation. +func (cw *closeWaiter) Init() { + *cw = make(chan struct{}) +} + +// Close marks the closeWaiter as closed and unblocks any waiters. +func (cw closeWaiter) Close() { + close(cw) +} + +// Wait waits for the closeWaiter to become closed. +func (cw closeWaiter) Wait() { + <-cw +} + +// bufferedWriter is a buffered writer that writes to w. +// Its buffered writer is lazily allocated as needed, to minimize +// idle memory usage with many connections. +type bufferedWriter struct { + w io.Writer // immutable + bw *bufio.Writer // non-nil when data is buffered +} + +func newBufferedWriter(w io.Writer) *bufferedWriter { + return &bufferedWriter{w: w} +} + +var bufWriterPool = sync.Pool{ + New: func() interface{} { + // TODO: pick something better? this is a bit under + // (3 x typical 1500 byte MTU) at least. + return bufio.NewWriterSize(nil, 4<<10) + }, +} + +func (w *bufferedWriter) Write(p []byte) (n int, err error) { + if w.bw == nil { + bw := bufWriterPool.Get().(*bufio.Writer) + bw.Reset(w.w) + w.bw = bw + } + return w.bw.Write(p) +} + +func (w *bufferedWriter) Flush() error { + bw := w.bw + if bw == nil { + return nil + } + err := bw.Flush() + bw.Reset(nil) + bufWriterPool.Put(bw) + w.bw = nil + return err +} + +func mustUint31(v int32) uint32 { + if v < 0 || v > 2147483647 { + panic("out of range") + } + return uint32(v) +} + +// bodyAllowedForStatus reports whether a given response status code +// permits a body. See RFC 2616, section 4.4. +func bodyAllowedForStatus(status int) bool { + switch { + case status >= 100 && status <= 199: + return false + case status == 204: + return false + case status == 304: + return false + } + return true +} + +type httpError struct { + msg string + timeout bool +} + +func (e *httpError) Error() string { return e.msg } +func (e *httpError) Timeout() bool { return e.timeout } +func (e *httpError) Temporary() bool { return true } + +var errTimeout error = &httpError{msg: "http2: timeout awaiting response headers", timeout: true} + +type connectionStater interface { + ConnectionState() tls.ConnectionState +} + +var sorterPool = sync.Pool{New: func() interface{} { return new(sorter) }} + +type sorter struct { + v []string // owned by sorter +} + +func (s *sorter) Len() int { return len(s.v) } +func (s *sorter) Swap(i, j int) { s.v[i], s.v[j] = s.v[j], s.v[i] } +func (s *sorter) Less(i, j int) bool { return s.v[i] < s.v[j] } + +// Keys returns the sorted keys of h. +// +// The returned slice is only valid until s used again or returned to +// its pool. +func (s *sorter) Keys(h http.Header) []string { + keys := s.v[:0] + for k := range h { + keys = append(keys, k) + } + s.v = keys + sort.Sort(s) + return keys +} + +func (s *sorter) SortStrings(ss []string) { + // Our sorter works on s.v, which sorter owners, so + // stash it away while we sort the user's buffer. + save := s.v + s.v = ss + sort.Sort(s) + s.v = save +} diff --git a/vendor/golang.org/x/net/http2/not_go16.go b/vendor/golang.org/x/net/http2/not_go16.go new file mode 100644 index 00000000..efd2e128 --- /dev/null +++ b/vendor/golang.org/x/net/http2/not_go16.go @@ -0,0 +1,46 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build !go1.6 + +package http2 + +import ( + "crypto/tls" + "net/http" + "time" +) + +func configureTransport(t1 *http.Transport) (*Transport, error) { + return nil, errTransportVersion +} + +func transportExpectContinueTimeout(t1 *http.Transport) time.Duration { + return 0 + +} + +// isBadCipher reports whether the cipher is blacklisted by the HTTP/2 spec. +func isBadCipher(cipher uint16) bool { + switch cipher { + case tls.TLS_RSA_WITH_RC4_128_SHA, + tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA, + tls.TLS_RSA_WITH_AES_128_CBC_SHA, + tls.TLS_RSA_WITH_AES_256_CBC_SHA, + tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, + tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, + tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, + tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA, + tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, + tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, + tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA: + // Reject cipher suites from Appendix A. + // "This list includes those cipher suites that do not + // offer an ephemeral key exchange and those that are + // based on the TLS null, stream or block cipher type" + return true + default: + return false + } +} diff --git a/vendor/golang.org/x/net/http2/not_go17.go b/vendor/golang.org/x/net/http2/not_go17.go new file mode 100644 index 00000000..28df0c16 --- /dev/null +++ b/vendor/golang.org/x/net/http2/not_go17.go @@ -0,0 +1,51 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build !go1.7 + +package http2 + +import ( + "net" + "net/http" +) + +type contextContext interface{} + +type fakeContext struct{} + +func (fakeContext) Done() <-chan struct{} { return nil } +func (fakeContext) Err() error { panic("should not be called") } + +func reqContext(r *http.Request) fakeContext { + return fakeContext{} +} + +func setResponseUncompressed(res *http.Response) { + // Nothing. +} + +type clientTrace struct{} + +func requestTrace(*http.Request) *clientTrace { return nil } +func traceGotConn(*http.Request, *ClientConn) {} +func traceFirstResponseByte(*clientTrace) {} +func traceWroteHeaders(*clientTrace) {} +func traceWroteRequest(*clientTrace, error) {} +func traceGot100Continue(trace *clientTrace) {} +func traceWait100Continue(trace *clientTrace) {} + +func nop() {} + +func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx contextContext, cancel func()) { + return nil, nop +} + +func contextWithCancel(ctx contextContext) (_ contextContext, cancel func()) { + return ctx, nop +} + +func requestWithContext(req *http.Request, ctx contextContext) *http.Request { + return req +} diff --git a/vendor/golang.org/x/net/http2/pipe.go b/vendor/golang.org/x/net/http2/pipe.go new file mode 100644 index 00000000..53b7a1da --- /dev/null +++ b/vendor/golang.org/x/net/http2/pipe.go @@ -0,0 +1,153 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package http2 + +import ( + "errors" + "io" + "sync" +) + +// pipe is a goroutine-safe io.Reader/io.Writer pair. It's like +// io.Pipe except there are no PipeReader/PipeWriter halves, and the +// underlying buffer is an interface. (io.Pipe is always unbuffered) +type pipe struct { + mu sync.Mutex + c sync.Cond // c.L lazily initialized to &p.mu + b pipeBuffer + err error // read error once empty. non-nil means closed. + breakErr error // immediate read error (caller doesn't see rest of b) + donec chan struct{} // closed on error + readFn func() // optional code to run in Read before error +} + +type pipeBuffer interface { + Len() int + io.Writer + io.Reader +} + +func (p *pipe) Len() int { + p.mu.Lock() + defer p.mu.Unlock() + return p.b.Len() +} + +// Read waits until data is available and copies bytes +// from the buffer into p. +func (p *pipe) Read(d []byte) (n int, err error) { + p.mu.Lock() + defer p.mu.Unlock() + if p.c.L == nil { + p.c.L = &p.mu + } + for { + if p.breakErr != nil { + return 0, p.breakErr + } + if p.b.Len() > 0 { + return p.b.Read(d) + } + if p.err != nil { + if p.readFn != nil { + p.readFn() // e.g. copy trailers + p.readFn = nil // not sticky like p.err + } + return 0, p.err + } + p.c.Wait() + } +} + +var errClosedPipeWrite = errors.New("write on closed buffer") + +// Write copies bytes from p into the buffer and wakes a reader. +// It is an error to write more data than the buffer can hold. +func (p *pipe) Write(d []byte) (n int, err error) { + p.mu.Lock() + defer p.mu.Unlock() + if p.c.L == nil { + p.c.L = &p.mu + } + defer p.c.Signal() + if p.err != nil { + return 0, errClosedPipeWrite + } + return p.b.Write(d) +} + +// CloseWithError causes the next Read (waking up a current blocked +// Read if needed) to return the provided err after all data has been +// read. +// +// The error must be non-nil. +func (p *pipe) CloseWithError(err error) { p.closeWithError(&p.err, err, nil) } + +// BreakWithError causes the next Read (waking up a current blocked +// Read if needed) to return the provided err immediately, without +// waiting for unread data. +func (p *pipe) BreakWithError(err error) { p.closeWithError(&p.breakErr, err, nil) } + +// closeWithErrorAndCode is like CloseWithError but also sets some code to run +// in the caller's goroutine before returning the error. +func (p *pipe) closeWithErrorAndCode(err error, fn func()) { p.closeWithError(&p.err, err, fn) } + +func (p *pipe) closeWithError(dst *error, err error, fn func()) { + if err == nil { + panic("err must be non-nil") + } + p.mu.Lock() + defer p.mu.Unlock() + if p.c.L == nil { + p.c.L = &p.mu + } + defer p.c.Signal() + if *dst != nil { + // Already been done. + return + } + p.readFn = fn + *dst = err + p.closeDoneLocked() +} + +// requires p.mu be held. +func (p *pipe) closeDoneLocked() { + if p.donec == nil { + return + } + // Close if unclosed. This isn't racy since we always + // hold p.mu while closing. + select { + case <-p.donec: + default: + close(p.donec) + } +} + +// Err returns the error (if any) first set by BreakWithError or CloseWithError. +func (p *pipe) Err() error { + p.mu.Lock() + defer p.mu.Unlock() + if p.breakErr != nil { + return p.breakErr + } + return p.err +} + +// Done returns a channel which is closed if and when this pipe is closed +// with CloseWithError. +func (p *pipe) Done() <-chan struct{} { + p.mu.Lock() + defer p.mu.Unlock() + if p.donec == nil { + p.donec = make(chan struct{}) + if p.err != nil || p.breakErr != nil { + // Already hit an error. + p.closeDoneLocked() + } + } + return p.donec +} diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go new file mode 100644 index 00000000..8206fa79 --- /dev/null +++ b/vendor/golang.org/x/net/http2/server.go @@ -0,0 +1,2292 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// TODO: replace all <-sc.doneServing with reads from the stream's cw +// instead, and make sure that on close we close all open +// streams. then remove doneServing? + +// TODO: re-audit GOAWAY support. Consider each incoming frame type and +// whether it should be ignored during graceful shutdown. + +// TODO: disconnect idle clients. GFE seems to do 4 minutes. make +// configurable? or maximum number of idle clients and remove the +// oldest? + +// TODO: turn off the serve goroutine when idle, so +// an idle conn only has the readFrames goroutine active. (which could +// also be optimized probably to pin less memory in crypto/tls). This +// would involve tracking when the serve goroutine is active (atomic +// int32 read/CAS probably?) and starting it up when frames arrive, +// and shutting it down when all handlers exit. the occasional PING +// packets could use time.AfterFunc to call sc.wakeStartServeLoop() +// (which is a no-op if already running) and then queue the PING write +// as normal. The serve loop would then exit in most cases (if no +// Handlers running) and not be woken up again until the PING packet +// returns. + +// TODO (maybe): add a mechanism for Handlers to going into +// half-closed-local mode (rw.(io.Closer) test?) but not exit their +// handler, and continue to be able to read from the +// Request.Body. This would be a somewhat semantic change from HTTP/1 +// (or at least what we expose in net/http), so I'd probably want to +// add it there too. For now, this package says that returning from +// the Handler ServeHTTP function means you're both done reading and +// done writing, without a way to stop just one or the other. + +package http2 + +import ( + "bufio" + "bytes" + "crypto/tls" + "errors" + "fmt" + "io" + "log" + "net" + "net/http" + "net/textproto" + "net/url" + "os" + "reflect" + "runtime" + "strconv" + "strings" + "sync" + "time" + + "golang.org/x/net/http2/hpack" +) + +const ( + prefaceTimeout = 10 * time.Second + firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway + handlerChunkWriteSize = 4 << 10 + defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to? +) + +var ( + errClientDisconnected = errors.New("client disconnected") + errClosedBody = errors.New("body closed by handler") + errHandlerComplete = errors.New("http2: request body closed due to handler exiting") + errStreamClosed = errors.New("http2: stream closed") +) + +var responseWriterStatePool = sync.Pool{ + New: func() interface{} { + rws := &responseWriterState{} + rws.bw = bufio.NewWriterSize(chunkWriter{rws}, handlerChunkWriteSize) + return rws + }, +} + +// Test hooks. +var ( + testHookOnConn func() + testHookGetServerConn func(*serverConn) + testHookOnPanicMu *sync.Mutex // nil except in tests + testHookOnPanic func(sc *serverConn, panicVal interface{}) (rePanic bool) +) + +// Server is an HTTP/2 server. +type Server struct { + // MaxHandlers limits the number of http.Handler ServeHTTP goroutines + // which may run at a time over all connections. + // Negative or zero no limit. + // TODO: implement + MaxHandlers int + + // MaxConcurrentStreams optionally specifies the number of + // concurrent streams that each client may have open at a + // time. This is unrelated to the number of http.Handler goroutines + // which may be active globally, which is MaxHandlers. + // If zero, MaxConcurrentStreams defaults to at least 100, per + // the HTTP/2 spec's recommendations. + MaxConcurrentStreams uint32 + + // MaxReadFrameSize optionally specifies the largest frame + // this server is willing to read. A valid value is between + // 16k and 16M, inclusive. If zero or otherwise invalid, a + // default value is used. + MaxReadFrameSize uint32 + + // PermitProhibitedCipherSuites, if true, permits the use of + // cipher suites prohibited by the HTTP/2 spec. + PermitProhibitedCipherSuites bool +} + +func (s *Server) maxReadFrameSize() uint32 { + if v := s.MaxReadFrameSize; v >= minMaxFrameSize && v <= maxFrameSize { + return v + } + return defaultMaxReadFrameSize +} + +func (s *Server) maxConcurrentStreams() uint32 { + if v := s.MaxConcurrentStreams; v > 0 { + return v + } + return defaultMaxStreams +} + +// ConfigureServer adds HTTP/2 support to a net/http Server. +// +// The configuration conf may be nil. +// +// ConfigureServer must be called before s begins serving. +func ConfigureServer(s *http.Server, conf *Server) error { + if conf == nil { + conf = new(Server) + } + + if s.TLSConfig == nil { + s.TLSConfig = new(tls.Config) + } else if s.TLSConfig.CipherSuites != nil { + // If they already provided a CipherSuite list, return + // an error if it has a bad order or is missing + // ECDHE_RSA_WITH_AES_128_GCM_SHA256. + const requiredCipher = tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 + haveRequired := false + sawBad := false + for i, cs := range s.TLSConfig.CipherSuites { + if cs == requiredCipher { + haveRequired = true + } + if isBadCipher(cs) { + sawBad = true + } else if sawBad { + return fmt.Errorf("http2: TLSConfig.CipherSuites index %d contains an HTTP/2-approved cipher suite (%#04x), but it comes after unapproved cipher suites. With this configuration, clients that don't support previous, approved cipher suites may be given an unapproved one and reject the connection.", i, cs) + } + } + if !haveRequired { + return fmt.Errorf("http2: TLSConfig.CipherSuites is missing HTTP/2-required TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256") + } + } + + // Note: not setting MinVersion to tls.VersionTLS12, + // as we don't want to interfere with HTTP/1.1 traffic + // on the user's server. We enforce TLS 1.2 later once + // we accept a connection. Ideally this should be done + // during next-proto selection, but using TLS <1.2 with + // HTTP/2 is still the client's bug. + + s.TLSConfig.PreferServerCipherSuites = true + + haveNPN := false + for _, p := range s.TLSConfig.NextProtos { + if p == NextProtoTLS { + haveNPN = true + break + } + } + if !haveNPN { + s.TLSConfig.NextProtos = append(s.TLSConfig.NextProtos, NextProtoTLS) + } + // h2-14 is temporary (as of 2015-03-05) while we wait for all browsers + // to switch to "h2". + s.TLSConfig.NextProtos = append(s.TLSConfig.NextProtos, "h2-14") + + if s.TLSNextProto == nil { + s.TLSNextProto = map[string]func(*http.Server, *tls.Conn, http.Handler){} + } + protoHandler := func(hs *http.Server, c *tls.Conn, h http.Handler) { + if testHookOnConn != nil { + testHookOnConn() + } + conf.ServeConn(c, &ServeConnOpts{ + Handler: h, + BaseConfig: hs, + }) + } + s.TLSNextProto[NextProtoTLS] = protoHandler + s.TLSNextProto["h2-14"] = protoHandler // temporary; see above. + return nil +} + +// ServeConnOpts are options for the Server.ServeConn method. +type ServeConnOpts struct { + // BaseConfig optionally sets the base configuration + // for values. If nil, defaults are used. + BaseConfig *http.Server + + // Handler specifies which handler to use for processing + // requests. If nil, BaseConfig.Handler is used. If BaseConfig + // or BaseConfig.Handler is nil, http.DefaultServeMux is used. + Handler http.Handler +} + +func (o *ServeConnOpts) baseConfig() *http.Server { + if o != nil && o.BaseConfig != nil { + return o.BaseConfig + } + return new(http.Server) +} + +func (o *ServeConnOpts) handler() http.Handler { + if o != nil { + if o.Handler != nil { + return o.Handler + } + if o.BaseConfig != nil && o.BaseConfig.Handler != nil { + return o.BaseConfig.Handler + } + } + return http.DefaultServeMux +} + +// ServeConn serves HTTP/2 requests on the provided connection and +// blocks until the connection is no longer readable. +// +// ServeConn starts speaking HTTP/2 assuming that c has not had any +// reads or writes. It writes its initial settings frame and expects +// to be able to read the preface and settings frame from the +// client. If c has a ConnectionState method like a *tls.Conn, the +// ConnectionState is used to verify the TLS ciphersuite and to set +// the Request.TLS field in Handlers. +// +// ServeConn does not support h2c by itself. Any h2c support must be +// implemented in terms of providing a suitably-behaving net.Conn. +// +// The opts parameter is optional. If nil, default values are used. +func (s *Server) ServeConn(c net.Conn, opts *ServeConnOpts) { + baseCtx, cancel := serverConnBaseContext(c, opts) + defer cancel() + + sc := &serverConn{ + srv: s, + hs: opts.baseConfig(), + conn: c, + baseCtx: baseCtx, + remoteAddrStr: c.RemoteAddr().String(), + bw: newBufferedWriter(c), + handler: opts.handler(), + streams: make(map[uint32]*stream), + readFrameCh: make(chan readFrameResult), + wantWriteFrameCh: make(chan frameWriteMsg, 8), + wroteFrameCh: make(chan frameWriteResult, 1), // buffered; one send in writeFrameAsync + bodyReadCh: make(chan bodyReadMsg), // buffering doesn't matter either way + doneServing: make(chan struct{}), + advMaxStreams: s.maxConcurrentStreams(), + writeSched: writeScheduler{ + maxFrameSize: initialMaxFrameSize, + }, + initialWindowSize: initialWindowSize, + headerTableSize: initialHeaderTableSize, + serveG: newGoroutineLock(), + pushEnabled: true, + } + + sc.flow.add(initialWindowSize) + sc.inflow.add(initialWindowSize) + sc.hpackEncoder = hpack.NewEncoder(&sc.headerWriteBuf) + + fr := NewFramer(sc.bw, c) + fr.ReadMetaHeaders = hpack.NewDecoder(initialHeaderTableSize, nil) + fr.MaxHeaderListSize = sc.maxHeaderListSize() + fr.SetMaxReadFrameSize(s.maxReadFrameSize()) + sc.framer = fr + + if tc, ok := c.(connectionStater); ok { + sc.tlsState = new(tls.ConnectionState) + *sc.tlsState = tc.ConnectionState() + // 9.2 Use of TLS Features + // An implementation of HTTP/2 over TLS MUST use TLS + // 1.2 or higher with the restrictions on feature set + // and cipher suite described in this section. Due to + // implementation limitations, it might not be + // possible to fail TLS negotiation. An endpoint MUST + // immediately terminate an HTTP/2 connection that + // does not meet the TLS requirements described in + // this section with a connection error (Section + // 5.4.1) of type INADEQUATE_SECURITY. + if sc.tlsState.Version < tls.VersionTLS12 { + sc.rejectConn(ErrCodeInadequateSecurity, "TLS version too low") + return + } + + if sc.tlsState.ServerName == "" { + // Client must use SNI, but we don't enforce that anymore, + // since it was causing problems when connecting to bare IP + // addresses during development. + // + // TODO: optionally enforce? Or enforce at the time we receive + // a new request, and verify the the ServerName matches the :authority? + // But that precludes proxy situations, perhaps. + // + // So for now, do nothing here again. + } + + if !s.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) { + // "Endpoints MAY choose to generate a connection error + // (Section 5.4.1) of type INADEQUATE_SECURITY if one of + // the prohibited cipher suites are negotiated." + // + // We choose that. In my opinion, the spec is weak + // here. It also says both parties must support at least + // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 so there's no + // excuses here. If we really must, we could allow an + // "AllowInsecureWeakCiphers" option on the server later. + // Let's see how it plays out first. + sc.rejectConn(ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite)) + return + } + } + + if hook := testHookGetServerConn; hook != nil { + hook(sc) + } + sc.serve() +} + +func (sc *serverConn) rejectConn(err ErrCode, debug string) { + sc.vlogf("http2: server rejecting conn: %v, %s", err, debug) + // ignoring errors. hanging up anyway. + sc.framer.WriteGoAway(0, err, []byte(debug)) + sc.bw.Flush() + sc.conn.Close() +} + +type serverConn struct { + // Immutable: + srv *Server + hs *http.Server + conn net.Conn + bw *bufferedWriter // writing to conn + handler http.Handler + baseCtx contextContext + framer *Framer + doneServing chan struct{} // closed when serverConn.serve ends + readFrameCh chan readFrameResult // written by serverConn.readFrames + wantWriteFrameCh chan frameWriteMsg // from handlers -> serve + wroteFrameCh chan frameWriteResult // from writeFrameAsync -> serve, tickles more frame writes + bodyReadCh chan bodyReadMsg // from handlers -> serve + testHookCh chan func(int) // code to run on the serve loop + flow flow // conn-wide (not stream-specific) outbound flow control + inflow flow // conn-wide inbound flow control + tlsState *tls.ConnectionState // shared by all handlers, like net/http + remoteAddrStr string + + // Everything following is owned by the serve loop; use serveG.check(): + serveG goroutineLock // used to verify funcs are on serve() + pushEnabled bool + sawFirstSettings bool // got the initial SETTINGS frame after the preface + needToSendSettingsAck bool + unackedSettings int // how many SETTINGS have we sent without ACKs? + clientMaxStreams uint32 // SETTINGS_MAX_CONCURRENT_STREAMS from client (our PUSH_PROMISE limit) + advMaxStreams uint32 // our SETTINGS_MAX_CONCURRENT_STREAMS advertised the client + curOpenStreams uint32 // client's number of open streams + maxStreamID uint32 // max ever seen + streams map[uint32]*stream + initialWindowSize int32 + headerTableSize uint32 + peerMaxHeaderListSize uint32 // zero means unknown (default) + canonHeader map[string]string // http2-lower-case -> Go-Canonical-Case + writingFrame bool // started write goroutine but haven't heard back on wroteFrameCh + needsFrameFlush bool // last frame write wasn't a flush + writeSched writeScheduler + inGoAway bool // we've started to or sent GOAWAY + needToSendGoAway bool // we need to schedule a GOAWAY frame write + goAwayCode ErrCode + shutdownTimerCh <-chan time.Time // nil until used + shutdownTimer *time.Timer // nil until used + freeRequestBodyBuf []byte // if non-nil, a free initialWindowSize buffer for getRequestBodyBuf + + // Owned by the writeFrameAsync goroutine: + headerWriteBuf bytes.Buffer + hpackEncoder *hpack.Encoder +} + +func (sc *serverConn) maxHeaderListSize() uint32 { + n := sc.hs.MaxHeaderBytes + if n <= 0 { + n = http.DefaultMaxHeaderBytes + } + // http2's count is in a slightly different unit and includes 32 bytes per pair. + // So, take the net/http.Server value and pad it up a bit, assuming 10 headers. + const perFieldOverhead = 32 // per http2 spec + const typicalHeaders = 10 // conservative + return uint32(n + typicalHeaders*perFieldOverhead) +} + +// stream represents a stream. This is the minimal metadata needed by +// the serve goroutine. Most of the actual stream state is owned by +// the http.Handler's goroutine in the responseWriter. Because the +// responseWriter's responseWriterState is recycled at the end of a +// handler, this struct intentionally has no pointer to the +// *responseWriter{,State} itself, as the Handler ending nils out the +// responseWriter's state field. +type stream struct { + // immutable: + sc *serverConn + id uint32 + body *pipe // non-nil if expecting DATA frames + cw closeWaiter // closed wait stream transitions to closed state + ctx contextContext + cancelCtx func() + + // owned by serverConn's serve loop: + bodyBytes int64 // body bytes seen so far + declBodyBytes int64 // or -1 if undeclared + flow flow // limits writing from Handler to client + inflow flow // what the client is allowed to POST/etc to us + parent *stream // or nil + numTrailerValues int64 + weight uint8 + state streamState + sentReset bool // only true once detached from streams map + gotReset bool // only true once detacted from streams map + gotTrailerHeader bool // HEADER frame for trailers was seen + wroteHeaders bool // whether we wrote headers (not status 100) + reqBuf []byte + + trailer http.Header // accumulated trailers + reqTrailer http.Header // handler's Request.Trailer +} + +func (sc *serverConn) Framer() *Framer { return sc.framer } +func (sc *serverConn) CloseConn() error { return sc.conn.Close() } +func (sc *serverConn) Flush() error { return sc.bw.Flush() } +func (sc *serverConn) HeaderEncoder() (*hpack.Encoder, *bytes.Buffer) { + return sc.hpackEncoder, &sc.headerWriteBuf +} + +func (sc *serverConn) state(streamID uint32) (streamState, *stream) { + sc.serveG.check() + // http://http2.github.io/http2-spec/#rfc.section.5.1 + if st, ok := sc.streams[streamID]; ok { + return st.state, st + } + // "The first use of a new stream identifier implicitly closes all + // streams in the "idle" state that might have been initiated by + // that peer with a lower-valued stream identifier. For example, if + // a client sends a HEADERS frame on stream 7 without ever sending a + // frame on stream 5, then stream 5 transitions to the "closed" + // state when the first frame for stream 7 is sent or received." + if streamID <= sc.maxStreamID { + return stateClosed, nil + } + return stateIdle, nil +} + +// setConnState calls the net/http ConnState hook for this connection, if configured. +// Note that the net/http package does StateNew and StateClosed for us. +// There is currently no plan for StateHijacked or hijacking HTTP/2 connections. +func (sc *serverConn) setConnState(state http.ConnState) { + if sc.hs.ConnState != nil { + sc.hs.ConnState(sc.conn, state) + } +} + +func (sc *serverConn) vlogf(format string, args ...interface{}) { + if VerboseLogs { + sc.logf(format, args...) + } +} + +func (sc *serverConn) logf(format string, args ...interface{}) { + if lg := sc.hs.ErrorLog; lg != nil { + lg.Printf(format, args...) + } else { + log.Printf(format, args...) + } +} + +// errno returns v's underlying uintptr, else 0. +// +// TODO: remove this helper function once http2 can use build +// tags. See comment in isClosedConnError. +func errno(v error) uintptr { + if rv := reflect.ValueOf(v); rv.Kind() == reflect.Uintptr { + return uintptr(rv.Uint()) + } + return 0 +} + +// isClosedConnError reports whether err is an error from use of a closed +// network connection. +func isClosedConnError(err error) bool { + if err == nil { + return false + } + + // TODO: remove this string search and be more like the Windows + // case below. That might involve modifying the standard library + // to return better error types. + str := err.Error() + if strings.Contains(str, "use of closed network connection") { + return true + } + + // TODO(bradfitz): x/tools/cmd/bundle doesn't really support + // build tags, so I can't make an http2_windows.go file with + // Windows-specific stuff. Fix that and move this, once we + // have a way to bundle this into std's net/http somehow. + if runtime.GOOS == "windows" { + if oe, ok := err.(*net.OpError); ok && oe.Op == "read" { + if se, ok := oe.Err.(*os.SyscallError); ok && se.Syscall == "wsarecv" { + const WSAECONNABORTED = 10053 + const WSAECONNRESET = 10054 + if n := errno(se.Err); n == WSAECONNRESET || n == WSAECONNABORTED { + return true + } + } + } + } + return false +} + +func (sc *serverConn) condlogf(err error, format string, args ...interface{}) { + if err == nil { + return + } + if err == io.EOF || err == io.ErrUnexpectedEOF || isClosedConnError(err) { + // Boring, expected errors. + sc.vlogf(format, args...) + } else { + sc.logf(format, args...) + } +} + +func (sc *serverConn) canonicalHeader(v string) string { + sc.serveG.check() + cv, ok := commonCanonHeader[v] + if ok { + return cv + } + cv, ok = sc.canonHeader[v] + if ok { + return cv + } + if sc.canonHeader == nil { + sc.canonHeader = make(map[string]string) + } + cv = http.CanonicalHeaderKey(v) + sc.canonHeader[v] = cv + return cv +} + +type readFrameResult struct { + f Frame // valid until readMore is called + err error + + // readMore should be called once the consumer no longer needs or + // retains f. After readMore, f is invalid and more frames can be + // read. + readMore func() +} + +// readFrames is the loop that reads incoming frames. +// It takes care to only read one frame at a time, blocking until the +// consumer is done with the frame. +// It's run on its own goroutine. +func (sc *serverConn) readFrames() { + gate := make(gate) + gateDone := gate.Done + for { + f, err := sc.framer.ReadFrame() + select { + case sc.readFrameCh <- readFrameResult{f, err, gateDone}: + case <-sc.doneServing: + return + } + select { + case <-gate: + case <-sc.doneServing: + return + } + if terminalReadFrameError(err) { + return + } + } +} + +// frameWriteResult is the message passed from writeFrameAsync to the serve goroutine. +type frameWriteResult struct { + wm frameWriteMsg // what was written (or attempted) + err error // result of the writeFrame call +} + +// writeFrameAsync runs in its own goroutine and writes a single frame +// and then reports when it's done. +// At most one goroutine can be running writeFrameAsync at a time per +// serverConn. +func (sc *serverConn) writeFrameAsync(wm frameWriteMsg) { + err := wm.write.writeFrame(sc) + sc.wroteFrameCh <- frameWriteResult{wm, err} +} + +func (sc *serverConn) closeAllStreamsOnConnClose() { + sc.serveG.check() + for _, st := range sc.streams { + sc.closeStream(st, errClientDisconnected) + } +} + +func (sc *serverConn) stopShutdownTimer() { + sc.serveG.check() + if t := sc.shutdownTimer; t != nil { + t.Stop() + } +} + +func (sc *serverConn) notePanic() { + // Note: this is for serverConn.serve panicking, not http.Handler code. + if testHookOnPanicMu != nil { + testHookOnPanicMu.Lock() + defer testHookOnPanicMu.Unlock() + } + if testHookOnPanic != nil { + if e := recover(); e != nil { + if testHookOnPanic(sc, e) { + panic(e) + } + } + } +} + +func (sc *serverConn) serve() { + sc.serveG.check() + defer sc.notePanic() + defer sc.conn.Close() + defer sc.closeAllStreamsOnConnClose() + defer sc.stopShutdownTimer() + defer close(sc.doneServing) // unblocks handlers trying to send + + if VerboseLogs { + sc.vlogf("http2: server connection from %v on %p", sc.conn.RemoteAddr(), sc.hs) + } + + sc.writeFrame(frameWriteMsg{ + write: writeSettings{ + {SettingMaxFrameSize, sc.srv.maxReadFrameSize()}, + {SettingMaxConcurrentStreams, sc.advMaxStreams}, + {SettingMaxHeaderListSize, sc.maxHeaderListSize()}, + + // TODO: more actual settings, notably + // SettingInitialWindowSize, but then we also + // want to bump up the conn window size the + // same amount here right after the settings + }, + }) + sc.unackedSettings++ + + if err := sc.readPreface(); err != nil { + sc.condlogf(err, "http2: server: error reading preface from client %v: %v", sc.conn.RemoteAddr(), err) + return + } + // Now that we've got the preface, get us out of the + // "StateNew" state. We can't go directly to idle, though. + // Active means we read some data and anticipate a request. We'll + // do another Active when we get a HEADERS frame. + sc.setConnState(http.StateActive) + sc.setConnState(http.StateIdle) + + go sc.readFrames() // closed by defer sc.conn.Close above + + settingsTimer := time.NewTimer(firstSettingsTimeout) + loopNum := 0 + for { + loopNum++ + select { + case wm := <-sc.wantWriteFrameCh: + sc.writeFrame(wm) + case res := <-sc.wroteFrameCh: + sc.wroteFrame(res) + case res := <-sc.readFrameCh: + if !sc.processFrameFromReader(res) { + return + } + res.readMore() + if settingsTimer.C != nil { + settingsTimer.Stop() + settingsTimer.C = nil + } + case m := <-sc.bodyReadCh: + sc.noteBodyRead(m.st, m.n) + case <-settingsTimer.C: + sc.logf("timeout waiting for SETTINGS frames from %v", sc.conn.RemoteAddr()) + return + case <-sc.shutdownTimerCh: + sc.vlogf("GOAWAY close timer fired; closing conn from %v", sc.conn.RemoteAddr()) + return + case fn := <-sc.testHookCh: + fn(loopNum) + } + } +} + +// readPreface reads the ClientPreface greeting from the peer +// or returns an error on timeout or an invalid greeting. +func (sc *serverConn) readPreface() error { + errc := make(chan error, 1) + go func() { + // Read the client preface + buf := make([]byte, len(ClientPreface)) + if _, err := io.ReadFull(sc.conn, buf); err != nil { + errc <- err + } else if !bytes.Equal(buf, clientPreface) { + errc <- fmt.Errorf("bogus greeting %q", buf) + } else { + errc <- nil + } + }() + timer := time.NewTimer(prefaceTimeout) // TODO: configurable on *Server? + defer timer.Stop() + select { + case <-timer.C: + return errors.New("timeout waiting for client preface") + case err := <-errc: + if err == nil { + if VerboseLogs { + sc.vlogf("http2: server: client %v said hello", sc.conn.RemoteAddr()) + } + } + return err + } +} + +var errChanPool = sync.Pool{ + New: func() interface{} { return make(chan error, 1) }, +} + +var writeDataPool = sync.Pool{ + New: func() interface{} { return new(writeData) }, +} + +// writeDataFromHandler writes DATA response frames from a handler on +// the given stream. +func (sc *serverConn) writeDataFromHandler(stream *stream, data []byte, endStream bool) error { + ch := errChanPool.Get().(chan error) + writeArg := writeDataPool.Get().(*writeData) + *writeArg = writeData{stream.id, data, endStream} + err := sc.writeFrameFromHandler(frameWriteMsg{ + write: writeArg, + stream: stream, + done: ch, + }) + if err != nil { + return err + } + var frameWriteDone bool // the frame write is done (successfully or not) + select { + case err = <-ch: + frameWriteDone = true + case <-sc.doneServing: + return errClientDisconnected + case <-stream.cw: + // If both ch and stream.cw were ready (as might + // happen on the final Write after an http.Handler + // ends), prefer the write result. Otherwise this + // might just be us successfully closing the stream. + // The writeFrameAsync and serve goroutines guarantee + // that the ch send will happen before the stream.cw + // close. + select { + case err = <-ch: + frameWriteDone = true + default: + return errStreamClosed + } + } + errChanPool.Put(ch) + if frameWriteDone { + writeDataPool.Put(writeArg) + } + return err +} + +// writeFrameFromHandler sends wm to sc.wantWriteFrameCh, but aborts +// if the connection has gone away. +// +// This must not be run from the serve goroutine itself, else it might +// deadlock writing to sc.wantWriteFrameCh (which is only mildly +// buffered and is read by serve itself). If you're on the serve +// goroutine, call writeFrame instead. +func (sc *serverConn) writeFrameFromHandler(wm frameWriteMsg) error { + sc.serveG.checkNotOn() // NOT + select { + case sc.wantWriteFrameCh <- wm: + return nil + case <-sc.doneServing: + // Serve loop is gone. + // Client has closed their connection to the server. + return errClientDisconnected + } +} + +// writeFrame schedules a frame to write and sends it if there's nothing +// already being written. +// +// There is no pushback here (the serve goroutine never blocks). It's +// the http.Handlers that block, waiting for their previous frames to +// make it onto the wire +// +// If you're not on the serve goroutine, use writeFrameFromHandler instead. +func (sc *serverConn) writeFrame(wm frameWriteMsg) { + sc.serveG.check() + + var ignoreWrite bool + + // Don't send a 100-continue response if we've already sent headers. + // See golang.org/issue/14030. + switch wm.write.(type) { + case *writeResHeaders: + wm.stream.wroteHeaders = true + case write100ContinueHeadersFrame: + if wm.stream.wroteHeaders { + ignoreWrite = true + } + } + + if !ignoreWrite { + sc.writeSched.add(wm) + } + sc.scheduleFrameWrite() +} + +// startFrameWrite starts a goroutine to write wm (in a separate +// goroutine since that might block on the network), and updates the +// serve goroutine's state about the world, updated from info in wm. +func (sc *serverConn) startFrameWrite(wm frameWriteMsg) { + sc.serveG.check() + if sc.writingFrame { + panic("internal error: can only be writing one frame at a time") + } + + st := wm.stream + if st != nil { + switch st.state { + case stateHalfClosedLocal: + panic("internal error: attempt to send frame on half-closed-local stream") + case stateClosed: + if st.sentReset || st.gotReset { + // Skip this frame. + sc.scheduleFrameWrite() + return + } + panic(fmt.Sprintf("internal error: attempt to send a write %v on a closed stream", wm)) + } + } + + sc.writingFrame = true + sc.needsFrameFlush = true + go sc.writeFrameAsync(wm) +} + +// errHandlerPanicked is the error given to any callers blocked in a read from +// Request.Body when the main goroutine panics. Since most handlers read in the +// the main ServeHTTP goroutine, this will show up rarely. +var errHandlerPanicked = errors.New("http2: handler panicked") + +// wroteFrame is called on the serve goroutine with the result of +// whatever happened on writeFrameAsync. +func (sc *serverConn) wroteFrame(res frameWriteResult) { + sc.serveG.check() + if !sc.writingFrame { + panic("internal error: expected to be already writing a frame") + } + sc.writingFrame = false + + wm := res.wm + st := wm.stream + + closeStream := endsStream(wm.write) + + if _, ok := wm.write.(handlerPanicRST); ok { + sc.closeStream(st, errHandlerPanicked) + } + + // Reply (if requested) to the blocked ServeHTTP goroutine. + if ch := wm.done; ch != nil { + select { + case ch <- res.err: + default: + panic(fmt.Sprintf("unbuffered done channel passed in for type %T", wm.write)) + } + } + wm.write = nil // prevent use (assume it's tainted after wm.done send) + + if closeStream { + if st == nil { + panic("internal error: expecting non-nil stream") + } + switch st.state { + case stateOpen: + // Here we would go to stateHalfClosedLocal in + // theory, but since our handler is done and + // the net/http package provides no mechanism + // for finishing writing to a ResponseWriter + // while still reading data (see possible TODO + // at top of this file), we go into closed + // state here anyway, after telling the peer + // we're hanging up on them. + st.state = stateHalfClosedLocal // won't last long, but necessary for closeStream via resetStream + errCancel := streamError(st.id, ErrCodeCancel) + sc.resetStream(errCancel) + case stateHalfClosedRemote: + sc.closeStream(st, errHandlerComplete) + } + } + + sc.scheduleFrameWrite() +} + +// scheduleFrameWrite tickles the frame writing scheduler. +// +// If a frame is already being written, nothing happens. This will be called again +// when the frame is done being written. +// +// If a frame isn't being written we need to send one, the best frame +// to send is selected, preferring first things that aren't +// stream-specific (e.g. ACKing settings), and then finding the +// highest priority stream. +// +// If a frame isn't being written and there's nothing else to send, we +// flush the write buffer. +func (sc *serverConn) scheduleFrameWrite() { + sc.serveG.check() + if sc.writingFrame { + return + } + if sc.needToSendGoAway { + sc.needToSendGoAway = false + sc.startFrameWrite(frameWriteMsg{ + write: &writeGoAway{ + maxStreamID: sc.maxStreamID, + code: sc.goAwayCode, + }, + }) + return + } + if sc.needToSendSettingsAck { + sc.needToSendSettingsAck = false + sc.startFrameWrite(frameWriteMsg{write: writeSettingsAck{}}) + return + } + if !sc.inGoAway { + if wm, ok := sc.writeSched.take(); ok { + sc.startFrameWrite(wm) + return + } + } + if sc.needsFrameFlush { + sc.startFrameWrite(frameWriteMsg{write: flushFrameWriter{}}) + sc.needsFrameFlush = false // after startFrameWrite, since it sets this true + return + } +} + +func (sc *serverConn) goAway(code ErrCode) { + sc.serveG.check() + if sc.inGoAway { + return + } + if code != ErrCodeNo { + sc.shutDownIn(250 * time.Millisecond) + } else { + // TODO: configurable + sc.shutDownIn(1 * time.Second) + } + sc.inGoAway = true + sc.needToSendGoAway = true + sc.goAwayCode = code + sc.scheduleFrameWrite() +} + +func (sc *serverConn) shutDownIn(d time.Duration) { + sc.serveG.check() + sc.shutdownTimer = time.NewTimer(d) + sc.shutdownTimerCh = sc.shutdownTimer.C +} + +func (sc *serverConn) resetStream(se StreamError) { + sc.serveG.check() + sc.writeFrame(frameWriteMsg{write: se}) + if st, ok := sc.streams[se.StreamID]; ok { + st.sentReset = true + sc.closeStream(st, se) + } +} + +// processFrameFromReader processes the serve loop's read from readFrameCh from the +// frame-reading goroutine. +// processFrameFromReader returns whether the connection should be kept open. +func (sc *serverConn) processFrameFromReader(res readFrameResult) bool { + sc.serveG.check() + err := res.err + if err != nil { + if err == ErrFrameTooLarge { + sc.goAway(ErrCodeFrameSize) + return true // goAway will close the loop + } + clientGone := err == io.EOF || err == io.ErrUnexpectedEOF || isClosedConnError(err) + if clientGone { + // TODO: could we also get into this state if + // the peer does a half close + // (e.g. CloseWrite) because they're done + // sending frames but they're still wanting + // our open replies? Investigate. + // TODO: add CloseWrite to crypto/tls.Conn first + // so we have a way to test this? I suppose + // just for testing we could have a non-TLS mode. + return false + } + } else { + f := res.f + if VerboseLogs { + sc.vlogf("http2: server read frame %v", summarizeFrame(f)) + } + err = sc.processFrame(f) + if err == nil { + return true + } + } + + switch ev := err.(type) { + case StreamError: + sc.resetStream(ev) + return true + case goAwayFlowError: + sc.goAway(ErrCodeFlowControl) + return true + case ConnectionError: + sc.logf("http2: server connection error from %v: %v", sc.conn.RemoteAddr(), ev) + sc.goAway(ErrCode(ev)) + return true // goAway will handle shutdown + default: + if res.err != nil { + sc.vlogf("http2: server closing client connection; error reading frame from client %s: %v", sc.conn.RemoteAddr(), err) + } else { + sc.logf("http2: server closing client connection: %v", err) + } + return false + } +} + +func (sc *serverConn) processFrame(f Frame) error { + sc.serveG.check() + + // First frame received must be SETTINGS. + if !sc.sawFirstSettings { + if _, ok := f.(*SettingsFrame); !ok { + return ConnectionError(ErrCodeProtocol) + } + sc.sawFirstSettings = true + } + + switch f := f.(type) { + case *SettingsFrame: + return sc.processSettings(f) + case *MetaHeadersFrame: + return sc.processHeaders(f) + case *WindowUpdateFrame: + return sc.processWindowUpdate(f) + case *PingFrame: + return sc.processPing(f) + case *DataFrame: + return sc.processData(f) + case *RSTStreamFrame: + return sc.processResetStream(f) + case *PriorityFrame: + return sc.processPriority(f) + case *PushPromiseFrame: + // A client cannot push. Thus, servers MUST treat the receipt of a PUSH_PROMISE + // frame as a connection error (Section 5.4.1) of type PROTOCOL_ERROR. + return ConnectionError(ErrCodeProtocol) + default: + sc.vlogf("http2: server ignoring frame: %v", f.Header()) + return nil + } +} + +func (sc *serverConn) processPing(f *PingFrame) error { + sc.serveG.check() + if f.IsAck() { + // 6.7 PING: " An endpoint MUST NOT respond to PING frames + // containing this flag." + return nil + } + if f.StreamID != 0 { + // "PING frames are not associated with any individual + // stream. If a PING frame is received with a stream + // identifier field value other than 0x0, the recipient MUST + // respond with a connection error (Section 5.4.1) of type + // PROTOCOL_ERROR." + return ConnectionError(ErrCodeProtocol) + } + sc.writeFrame(frameWriteMsg{write: writePingAck{f}}) + return nil +} + +func (sc *serverConn) processWindowUpdate(f *WindowUpdateFrame) error { + sc.serveG.check() + switch { + case f.StreamID != 0: // stream-level flow control + st := sc.streams[f.StreamID] + if st == nil { + // "WINDOW_UPDATE can be sent by a peer that has sent a + // frame bearing the END_STREAM flag. This means that a + // receiver could receive a WINDOW_UPDATE frame on a "half + // closed (remote)" or "closed" stream. A receiver MUST + // NOT treat this as an error, see Section 5.1." + return nil + } + if !st.flow.add(int32(f.Increment)) { + return streamError(f.StreamID, ErrCodeFlowControl) + } + default: // connection-level flow control + if !sc.flow.add(int32(f.Increment)) { + return goAwayFlowError{} + } + } + sc.scheduleFrameWrite() + return nil +} + +func (sc *serverConn) processResetStream(f *RSTStreamFrame) error { + sc.serveG.check() + + state, st := sc.state(f.StreamID) + if state == stateIdle { + // 6.4 "RST_STREAM frames MUST NOT be sent for a + // stream in the "idle" state. If a RST_STREAM frame + // identifying an idle stream is received, the + // recipient MUST treat this as a connection error + // (Section 5.4.1) of type PROTOCOL_ERROR. + return ConnectionError(ErrCodeProtocol) + } + if st != nil { + st.gotReset = true + st.cancelCtx() + sc.closeStream(st, streamError(f.StreamID, f.ErrCode)) + } + return nil +} + +func (sc *serverConn) closeStream(st *stream, err error) { + sc.serveG.check() + if st.state == stateIdle || st.state == stateClosed { + panic(fmt.Sprintf("invariant; can't close stream in state %v", st.state)) + } + st.state = stateClosed + sc.curOpenStreams-- + if sc.curOpenStreams == 0 { + sc.setConnState(http.StateIdle) + } + delete(sc.streams, st.id) + if p := st.body; p != nil { + // Return any buffered unread bytes worth of conn-level flow control. + // See golang.org/issue/16481 + sc.sendWindowUpdate(nil, p.Len()) + + p.CloseWithError(err) + } + st.cw.Close() // signals Handler's CloseNotifier, unblocks writes, etc + sc.writeSched.forgetStream(st.id) + if st.reqBuf != nil { + // Stash this request body buffer (64k) away for reuse + // by a future POST/PUT/etc. + // + // TODO(bradfitz): share on the server? sync.Pool? + // Server requires locks and might hurt contention. + // sync.Pool might work, or might be worse, depending + // on goroutine CPU migrations. (get and put on + // separate CPUs). Maybe a mix of strategies. But + // this is an easy win for now. + sc.freeRequestBodyBuf = st.reqBuf + } +} + +func (sc *serverConn) processSettings(f *SettingsFrame) error { + sc.serveG.check() + if f.IsAck() { + sc.unackedSettings-- + if sc.unackedSettings < 0 { + // Why is the peer ACKing settings we never sent? + // The spec doesn't mention this case, but + // hang up on them anyway. + return ConnectionError(ErrCodeProtocol) + } + return nil + } + if err := f.ForeachSetting(sc.processSetting); err != nil { + return err + } + sc.needToSendSettingsAck = true + sc.scheduleFrameWrite() + return nil +} + +func (sc *serverConn) processSetting(s Setting) error { + sc.serveG.check() + if err := s.Valid(); err != nil { + return err + } + if VerboseLogs { + sc.vlogf("http2: server processing setting %v", s) + } + switch s.ID { + case SettingHeaderTableSize: + sc.headerTableSize = s.Val + sc.hpackEncoder.SetMaxDynamicTableSize(s.Val) + case SettingEnablePush: + sc.pushEnabled = s.Val != 0 + case SettingMaxConcurrentStreams: + sc.clientMaxStreams = s.Val + case SettingInitialWindowSize: + return sc.processSettingInitialWindowSize(s.Val) + case SettingMaxFrameSize: + sc.writeSched.maxFrameSize = s.Val + case SettingMaxHeaderListSize: + sc.peerMaxHeaderListSize = s.Val + default: + // Unknown setting: "An endpoint that receives a SETTINGS + // frame with any unknown or unsupported identifier MUST + // ignore that setting." + if VerboseLogs { + sc.vlogf("http2: server ignoring unknown setting %v", s) + } + } + return nil +} + +func (sc *serverConn) processSettingInitialWindowSize(val uint32) error { + sc.serveG.check() + // Note: val already validated to be within range by + // processSetting's Valid call. + + // "A SETTINGS frame can alter the initial flow control window + // size for all current streams. When the value of + // SETTINGS_INITIAL_WINDOW_SIZE changes, a receiver MUST + // adjust the size of all stream flow control windows that it + // maintains by the difference between the new value and the + // old value." + old := sc.initialWindowSize + sc.initialWindowSize = int32(val) + growth := sc.initialWindowSize - old // may be negative + for _, st := range sc.streams { + if !st.flow.add(growth) { + // 6.9.2 Initial Flow Control Window Size + // "An endpoint MUST treat a change to + // SETTINGS_INITIAL_WINDOW_SIZE that causes any flow + // control window to exceed the maximum size as a + // connection error (Section 5.4.1) of type + // FLOW_CONTROL_ERROR." + return ConnectionError(ErrCodeFlowControl) + } + } + return nil +} + +func (sc *serverConn) processData(f *DataFrame) error { + sc.serveG.check() + data := f.Data() + + // "If a DATA frame is received whose stream is not in "open" + // or "half closed (local)" state, the recipient MUST respond + // with a stream error (Section 5.4.2) of type STREAM_CLOSED." + id := f.Header().StreamID + st, ok := sc.streams[id] + if !ok || st.state != stateOpen || st.gotTrailerHeader { + // This includes sending a RST_STREAM if the stream is + // in stateHalfClosedLocal (which currently means that + // the http.Handler returned, so it's done reading & + // done writing). Try to stop the client from sending + // more DATA. + + // But still enforce their connection-level flow control, + // and return any flow control bytes since we're not going + // to consume them. + if sc.inflow.available() < int32(f.Length) { + return streamError(id, ErrCodeFlowControl) + } + // Deduct the flow control from inflow, since we're + // going to immediately add it back in + // sendWindowUpdate, which also schedules sending the + // frames. + sc.inflow.take(int32(f.Length)) + sc.sendWindowUpdate(nil, int(f.Length)) // conn-level + + return streamError(id, ErrCodeStreamClosed) + } + if st.body == nil { + panic("internal error: should have a body in this state") + } + + // Sender sending more than they'd declared? + if st.declBodyBytes != -1 && st.bodyBytes+int64(len(data)) > st.declBodyBytes { + st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes)) + return streamError(id, ErrCodeStreamClosed) + } + if f.Length > 0 { + // Check whether the client has flow control quota. + if st.inflow.available() < int32(f.Length) { + return streamError(id, ErrCodeFlowControl) + } + st.inflow.take(int32(f.Length)) + + if len(data) > 0 { + wrote, err := st.body.Write(data) + if err != nil { + return streamError(id, ErrCodeStreamClosed) + } + if wrote != len(data) { + panic("internal error: bad Writer") + } + st.bodyBytes += int64(len(data)) + } + + // Return any padded flow control now, since we won't + // refund it later on body reads. + if pad := int32(f.Length) - int32(len(data)); pad > 0 { + sc.sendWindowUpdate32(nil, pad) + sc.sendWindowUpdate32(st, pad) + } + } + if f.StreamEnded() { + st.endStream() + } + return nil +} + +// endStream closes a Request.Body's pipe. It is called when a DATA +// frame says a request body is over (or after trailers). +func (st *stream) endStream() { + sc := st.sc + sc.serveG.check() + + if st.declBodyBytes != -1 && st.declBodyBytes != st.bodyBytes { + st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes", + st.declBodyBytes, st.bodyBytes)) + } else { + st.body.closeWithErrorAndCode(io.EOF, st.copyTrailersToHandlerRequest) + st.body.CloseWithError(io.EOF) + } + st.state = stateHalfClosedRemote +} + +// copyTrailersToHandlerRequest is run in the Handler's goroutine in +// its Request.Body.Read just before it gets io.EOF. +func (st *stream) copyTrailersToHandlerRequest() { + for k, vv := range st.trailer { + if _, ok := st.reqTrailer[k]; ok { + // Only copy it over it was pre-declared. + st.reqTrailer[k] = vv + } + } +} + +func (sc *serverConn) processHeaders(f *MetaHeadersFrame) error { + sc.serveG.check() + id := f.Header().StreamID + if sc.inGoAway { + // Ignore. + return nil + } + // http://http2.github.io/http2-spec/#rfc.section.5.1.1 + // Streams initiated by a client MUST use odd-numbered stream + // identifiers. [...] An endpoint that receives an unexpected + // stream identifier MUST respond with a connection error + // (Section 5.4.1) of type PROTOCOL_ERROR. + if id%2 != 1 { + return ConnectionError(ErrCodeProtocol) + } + // A HEADERS frame can be used to create a new stream or + // send a trailer for an open one. If we already have a stream + // open, let it process its own HEADERS frame (trailers at this + // point, if it's valid). + st := sc.streams[f.Header().StreamID] + if st != nil { + return st.processTrailerHeaders(f) + } + + // [...] The identifier of a newly established stream MUST be + // numerically greater than all streams that the initiating + // endpoint has opened or reserved. [...] An endpoint that + // receives an unexpected stream identifier MUST respond with + // a connection error (Section 5.4.1) of type PROTOCOL_ERROR. + if id <= sc.maxStreamID { + return ConnectionError(ErrCodeProtocol) + } + sc.maxStreamID = id + + ctx, cancelCtx := contextWithCancel(sc.baseCtx) + st = &stream{ + sc: sc, + id: id, + state: stateOpen, + ctx: ctx, + cancelCtx: cancelCtx, + } + if f.StreamEnded() { + st.state = stateHalfClosedRemote + } + st.cw.Init() + + st.flow.conn = &sc.flow // link to conn-level counter + st.flow.add(sc.initialWindowSize) + st.inflow.conn = &sc.inflow // link to conn-level counter + st.inflow.add(initialWindowSize) // TODO: update this when we send a higher initial window size in the initial settings + + sc.streams[id] = st + if f.HasPriority() { + adjustStreamPriority(sc.streams, st.id, f.Priority) + } + sc.curOpenStreams++ + if sc.curOpenStreams == 1 { + sc.setConnState(http.StateActive) + } + if sc.curOpenStreams > sc.advMaxStreams { + // "Endpoints MUST NOT exceed the limit set by their + // peer. An endpoint that receives a HEADERS frame + // that causes their advertised concurrent stream + // limit to be exceeded MUST treat this as a stream + // error (Section 5.4.2) of type PROTOCOL_ERROR or + // REFUSED_STREAM." + if sc.unackedSettings == 0 { + // They should know better. + return streamError(st.id, ErrCodeProtocol) + } + // Assume it's a network race, where they just haven't + // received our last SETTINGS update. But actually + // this can't happen yet, because we don't yet provide + // a way for users to adjust server parameters at + // runtime. + return streamError(st.id, ErrCodeRefusedStream) + } + + rw, req, err := sc.newWriterAndRequest(st, f) + if err != nil { + return err + } + st.reqTrailer = req.Trailer + if st.reqTrailer != nil { + st.trailer = make(http.Header) + } + st.body = req.Body.(*requestBody).pipe // may be nil + st.declBodyBytes = req.ContentLength + + handler := sc.handler.ServeHTTP + if f.Truncated { + // Their header list was too long. Send a 431 error. + handler = handleHeaderListTooLong + } else if err := checkValidHTTP2Request(req); err != nil { + handler = new400Handler(err) + } + + go sc.runHandler(rw, req, handler) + return nil +} + +func (st *stream) processTrailerHeaders(f *MetaHeadersFrame) error { + sc := st.sc + sc.serveG.check() + if st.gotTrailerHeader { + return ConnectionError(ErrCodeProtocol) + } + st.gotTrailerHeader = true + if !f.StreamEnded() { + return streamError(st.id, ErrCodeProtocol) + } + + if len(f.PseudoFields()) > 0 { + return streamError(st.id, ErrCodeProtocol) + } + if st.trailer != nil { + for _, hf := range f.RegularFields() { + key := sc.canonicalHeader(hf.Name) + if !ValidTrailerHeader(key) { + // TODO: send more details to the peer somehow. But http2 has + // no way to send debug data at a stream level. Discuss with + // HTTP folk. + return streamError(st.id, ErrCodeProtocol) + } + st.trailer[key] = append(st.trailer[key], hf.Value) + } + } + st.endStream() + return nil +} + +func (sc *serverConn) processPriority(f *PriorityFrame) error { + adjustStreamPriority(sc.streams, f.StreamID, f.PriorityParam) + return nil +} + +func adjustStreamPriority(streams map[uint32]*stream, streamID uint32, priority PriorityParam) { + st, ok := streams[streamID] + if !ok { + // TODO: not quite correct (this streamID might + // already exist in the dep tree, but be closed), but + // close enough for now. + return + } + st.weight = priority.Weight + parent := streams[priority.StreamDep] // might be nil + if parent == st { + // if client tries to set this stream to be the parent of itself + // ignore and keep going + return + } + + // section 5.3.3: If a stream is made dependent on one of its + // own dependencies, the formerly dependent stream is first + // moved to be dependent on the reprioritized stream's previous + // parent. The moved dependency retains its weight. + for piter := parent; piter != nil; piter = piter.parent { + if piter == st { + parent.parent = st.parent + break + } + } + st.parent = parent + if priority.Exclusive && (st.parent != nil || priority.StreamDep == 0) { + for _, openStream := range streams { + if openStream != st && openStream.parent == st.parent { + openStream.parent = st + } + } + } +} + +func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*responseWriter, *http.Request, error) { + sc.serveG.check() + + method := f.PseudoValue("method") + path := f.PseudoValue("path") + scheme := f.PseudoValue("scheme") + authority := f.PseudoValue("authority") + + isConnect := method == "CONNECT" + if isConnect { + if path != "" || scheme != "" || authority == "" { + return nil, nil, streamError(f.StreamID, ErrCodeProtocol) + } + } else if method == "" || path == "" || + (scheme != "https" && scheme != "http") { + // See 8.1.2.6 Malformed Requests and Responses: + // + // Malformed requests or responses that are detected + // MUST be treated as a stream error (Section 5.4.2) + // of type PROTOCOL_ERROR." + // + // 8.1.2.3 Request Pseudo-Header Fields + // "All HTTP/2 requests MUST include exactly one valid + // value for the :method, :scheme, and :path + // pseudo-header fields" + return nil, nil, streamError(f.StreamID, ErrCodeProtocol) + } + + bodyOpen := !f.StreamEnded() + if method == "HEAD" && bodyOpen { + // HEAD requests can't have bodies + return nil, nil, streamError(f.StreamID, ErrCodeProtocol) + } + var tlsState *tls.ConnectionState // nil if not scheme https + + if scheme == "https" { + tlsState = sc.tlsState + } + + header := make(http.Header) + for _, hf := range f.RegularFields() { + header.Add(sc.canonicalHeader(hf.Name), hf.Value) + } + + if authority == "" { + authority = header.Get("Host") + } + needsContinue := header.Get("Expect") == "100-continue" + if needsContinue { + header.Del("Expect") + } + // Merge Cookie headers into one "; "-delimited value. + if cookies := header["Cookie"]; len(cookies) > 1 { + header.Set("Cookie", strings.Join(cookies, "; ")) + } + + // Setup Trailers + var trailer http.Header + for _, v := range header["Trailer"] { + for _, key := range strings.Split(v, ",") { + key = http.CanonicalHeaderKey(strings.TrimSpace(key)) + switch key { + case "Transfer-Encoding", "Trailer", "Content-Length": + // Bogus. (copy of http1 rules) + // Ignore. + default: + if trailer == nil { + trailer = make(http.Header) + } + trailer[key] = nil + } + } + } + delete(header, "Trailer") + + body := &requestBody{ + conn: sc, + stream: st, + needsContinue: needsContinue, + } + var url_ *url.URL + var requestURI string + if isConnect { + url_ = &url.URL{Host: authority} + requestURI = authority // mimic HTTP/1 server behavior + } else { + var err error + url_, err = url.ParseRequestURI(path) + if err != nil { + return nil, nil, streamError(f.StreamID, ErrCodeProtocol) + } + requestURI = path + } + req := &http.Request{ + Method: method, + URL: url_, + RemoteAddr: sc.remoteAddrStr, + Header: header, + RequestURI: requestURI, + Proto: "HTTP/2.0", + ProtoMajor: 2, + ProtoMinor: 0, + TLS: tlsState, + Host: authority, + Body: body, + Trailer: trailer, + } + req = requestWithContext(req, st.ctx) + if bodyOpen { + // Disabled, per golang.org/issue/14960: + // st.reqBuf = sc.getRequestBodyBuf() + // TODO: remove this 64k of garbage per request (again, but without a data race): + buf := make([]byte, initialWindowSize) + + body.pipe = &pipe{ + b: &fixedBuffer{buf: buf}, + } + + if vv, ok := header["Content-Length"]; ok { + req.ContentLength, _ = strconv.ParseInt(vv[0], 10, 64) + } else { + req.ContentLength = -1 + } + } + + rws := responseWriterStatePool.Get().(*responseWriterState) + bwSave := rws.bw + *rws = responseWriterState{} // zero all the fields + rws.conn = sc + rws.bw = bwSave + rws.bw.Reset(chunkWriter{rws}) + rws.stream = st + rws.req = req + rws.body = body + + rw := &responseWriter{rws: rws} + return rw, req, nil +} + +func (sc *serverConn) getRequestBodyBuf() []byte { + sc.serveG.check() + if buf := sc.freeRequestBodyBuf; buf != nil { + sc.freeRequestBodyBuf = nil + return buf + } + return make([]byte, initialWindowSize) +} + +// Run on its own goroutine. +func (sc *serverConn) runHandler(rw *responseWriter, req *http.Request, handler func(http.ResponseWriter, *http.Request)) { + didPanic := true + defer func() { + rw.rws.stream.cancelCtx() + if didPanic { + e := recover() + // Same as net/http: + const size = 64 << 10 + buf := make([]byte, size) + buf = buf[:runtime.Stack(buf, false)] + sc.writeFrameFromHandler(frameWriteMsg{ + write: handlerPanicRST{rw.rws.stream.id}, + stream: rw.rws.stream, + }) + sc.logf("http2: panic serving %v: %v\n%s", sc.conn.RemoteAddr(), e, buf) + return + } + rw.handlerDone() + }() + handler(rw, req) + didPanic = false +} + +func handleHeaderListTooLong(w http.ResponseWriter, r *http.Request) { + // 10.5.1 Limits on Header Block Size: + // .. "A server that receives a larger header block than it is + // willing to handle can send an HTTP 431 (Request Header Fields Too + // Large) status code" + const statusRequestHeaderFieldsTooLarge = 431 // only in Go 1.6+ + w.WriteHeader(statusRequestHeaderFieldsTooLarge) + io.WriteString(w, "

HTTP Error 431

Request Header Field(s) Too Large

") +} + +// called from handler goroutines. +// h may be nil. +func (sc *serverConn) writeHeaders(st *stream, headerData *writeResHeaders) error { + sc.serveG.checkNotOn() // NOT on + var errc chan error + if headerData.h != nil { + // If there's a header map (which we don't own), so we have to block on + // waiting for this frame to be written, so an http.Flush mid-handler + // writes out the correct value of keys, before a handler later potentially + // mutates it. + errc = errChanPool.Get().(chan error) + } + if err := sc.writeFrameFromHandler(frameWriteMsg{ + write: headerData, + stream: st, + done: errc, + }); err != nil { + return err + } + if errc != nil { + select { + case err := <-errc: + errChanPool.Put(errc) + return err + case <-sc.doneServing: + return errClientDisconnected + case <-st.cw: + return errStreamClosed + } + } + return nil +} + +// called from handler goroutines. +func (sc *serverConn) write100ContinueHeaders(st *stream) { + sc.writeFrameFromHandler(frameWriteMsg{ + write: write100ContinueHeadersFrame{st.id}, + stream: st, + }) +} + +// A bodyReadMsg tells the server loop that the http.Handler read n +// bytes of the DATA from the client on the given stream. +type bodyReadMsg struct { + st *stream + n int +} + +// called from handler goroutines. +// Notes that the handler for the given stream ID read n bytes of its body +// and schedules flow control tokens to be sent. +func (sc *serverConn) noteBodyReadFromHandler(st *stream, n int) { + sc.serveG.checkNotOn() // NOT on + select { + case sc.bodyReadCh <- bodyReadMsg{st, n}: + case <-sc.doneServing: + } +} + +func (sc *serverConn) noteBodyRead(st *stream, n int) { + sc.serveG.check() + sc.sendWindowUpdate(nil, n) // conn-level + if st.state != stateHalfClosedRemote && st.state != stateClosed { + // Don't send this WINDOW_UPDATE if the stream is closed + // remotely. + sc.sendWindowUpdate(st, n) + } +} + +// st may be nil for conn-level +func (sc *serverConn) sendWindowUpdate(st *stream, n int) { + sc.serveG.check() + // "The legal range for the increment to the flow control + // window is 1 to 2^31-1 (2,147,483,647) octets." + // A Go Read call on 64-bit machines could in theory read + // a larger Read than this. Very unlikely, but we handle it here + // rather than elsewhere for now. + const maxUint31 = 1<<31 - 1 + for n >= maxUint31 { + sc.sendWindowUpdate32(st, maxUint31) + n -= maxUint31 + } + sc.sendWindowUpdate32(st, int32(n)) +} + +// st may be nil for conn-level +func (sc *serverConn) sendWindowUpdate32(st *stream, n int32) { + sc.serveG.check() + if n == 0 { + return + } + if n < 0 { + panic("negative update") + } + var streamID uint32 + if st != nil { + streamID = st.id + } + sc.writeFrame(frameWriteMsg{ + write: writeWindowUpdate{streamID: streamID, n: uint32(n)}, + stream: st, + }) + var ok bool + if st == nil { + ok = sc.inflow.add(n) + } else { + ok = st.inflow.add(n) + } + if !ok { + panic("internal error; sent too many window updates without decrements?") + } +} + +type requestBody struct { + stream *stream + conn *serverConn + closed bool + pipe *pipe // non-nil if we have a HTTP entity message body + needsContinue bool // need to send a 100-continue +} + +func (b *requestBody) Close() error { + if b.pipe != nil { + b.pipe.BreakWithError(errClosedBody) + } + b.closed = true + return nil +} + +func (b *requestBody) Read(p []byte) (n int, err error) { + if b.needsContinue { + b.needsContinue = false + b.conn.write100ContinueHeaders(b.stream) + } + if b.pipe == nil { + return 0, io.EOF + } + n, err = b.pipe.Read(p) + if n > 0 { + b.conn.noteBodyReadFromHandler(b.stream, n) + } + return +} + +// responseWriter is the http.ResponseWriter implementation. It's +// intentionally small (1 pointer wide) to minimize garbage. The +// responseWriterState pointer inside is zeroed at the end of a +// request (in handlerDone) and calls on the responseWriter thereafter +// simply crash (caller's mistake), but the much larger responseWriterState +// and buffers are reused between multiple requests. +type responseWriter struct { + rws *responseWriterState +} + +// Optional http.ResponseWriter interfaces implemented. +var ( + _ http.CloseNotifier = (*responseWriter)(nil) + _ http.Flusher = (*responseWriter)(nil) + _ stringWriter = (*responseWriter)(nil) +) + +type responseWriterState struct { + // immutable within a request: + stream *stream + req *http.Request + body *requestBody // to close at end of request, if DATA frames didn't + conn *serverConn + + // TODO: adjust buffer writing sizes based on server config, frame size updates from peer, etc + bw *bufio.Writer // writing to a chunkWriter{this *responseWriterState} + + // mutated by http.Handler goroutine: + handlerHeader http.Header // nil until called + snapHeader http.Header // snapshot of handlerHeader at WriteHeader time + trailers []string // set in writeChunk + status int // status code passed to WriteHeader + wroteHeader bool // WriteHeader called (explicitly or implicitly). Not necessarily sent to user yet. + sentHeader bool // have we sent the header frame? + handlerDone bool // handler has finished + + sentContentLen int64 // non-zero if handler set a Content-Length header + wroteBytes int64 + + closeNotifierMu sync.Mutex // guards closeNotifierCh + closeNotifierCh chan bool // nil until first used +} + +type chunkWriter struct{ rws *responseWriterState } + +func (cw chunkWriter) Write(p []byte) (n int, err error) { return cw.rws.writeChunk(p) } + +func (rws *responseWriterState) hasTrailers() bool { return len(rws.trailers) != 0 } + +// declareTrailer is called for each Trailer header when the +// response header is written. It notes that a header will need to be +// written in the trailers at the end of the response. +func (rws *responseWriterState) declareTrailer(k string) { + k = http.CanonicalHeaderKey(k) + if !ValidTrailerHeader(k) { + // Forbidden by RFC 2616 14.40. + rws.conn.logf("ignoring invalid trailer %q", k) + return + } + if !strSliceContains(rws.trailers, k) { + rws.trailers = append(rws.trailers, k) + } +} + +// writeChunk writes chunks from the bufio.Writer. But because +// bufio.Writer may bypass its chunking, sometimes p may be +// arbitrarily large. +// +// writeChunk is also responsible (on the first chunk) for sending the +// HEADER response. +func (rws *responseWriterState) writeChunk(p []byte) (n int, err error) { + if !rws.wroteHeader { + rws.writeHeader(200) + } + + isHeadResp := rws.req.Method == "HEAD" + if !rws.sentHeader { + rws.sentHeader = true + var ctype, clen string + if clen = rws.snapHeader.Get("Content-Length"); clen != "" { + rws.snapHeader.Del("Content-Length") + clen64, err := strconv.ParseInt(clen, 10, 64) + if err == nil && clen64 >= 0 { + rws.sentContentLen = clen64 + } else { + clen = "" + } + } + if clen == "" && rws.handlerDone && bodyAllowedForStatus(rws.status) && (len(p) > 0 || !isHeadResp) { + clen = strconv.Itoa(len(p)) + } + _, hasContentType := rws.snapHeader["Content-Type"] + if !hasContentType && bodyAllowedForStatus(rws.status) { + ctype = http.DetectContentType(p) + } + var date string + if _, ok := rws.snapHeader["Date"]; !ok { + // TODO(bradfitz): be faster here, like net/http? measure. + date = time.Now().UTC().Format(http.TimeFormat) + } + + for _, v := range rws.snapHeader["Trailer"] { + foreachHeaderElement(v, rws.declareTrailer) + } + + endStream := (rws.handlerDone && !rws.hasTrailers() && len(p) == 0) || isHeadResp + err = rws.conn.writeHeaders(rws.stream, &writeResHeaders{ + streamID: rws.stream.id, + httpResCode: rws.status, + h: rws.snapHeader, + endStream: endStream, + contentType: ctype, + contentLength: clen, + date: date, + }) + if err != nil { + return 0, err + } + if endStream { + return 0, nil + } + } + if isHeadResp { + return len(p), nil + } + if len(p) == 0 && !rws.handlerDone { + return 0, nil + } + + if rws.handlerDone { + rws.promoteUndeclaredTrailers() + } + + endStream := rws.handlerDone && !rws.hasTrailers() + if len(p) > 0 || endStream { + // only send a 0 byte DATA frame if we're ending the stream. + if err := rws.conn.writeDataFromHandler(rws.stream, p, endStream); err != nil { + return 0, err + } + } + + if rws.handlerDone && rws.hasTrailers() { + err = rws.conn.writeHeaders(rws.stream, &writeResHeaders{ + streamID: rws.stream.id, + h: rws.handlerHeader, + trailers: rws.trailers, + endStream: true, + }) + return len(p), err + } + return len(p), nil +} + +// TrailerPrefix is a magic prefix for ResponseWriter.Header map keys +// that, if present, signals that the map entry is actually for +// the response trailers, and not the response headers. The prefix +// is stripped after the ServeHTTP call finishes and the values are +// sent in the trailers. +// +// This mechanism is intended only for trailers that are not known +// prior to the headers being written. If the set of trailers is fixed +// or known before the header is written, the normal Go trailers mechanism +// is preferred: +// https://golang.org/pkg/net/http/#ResponseWriter +// https://golang.org/pkg/net/http/#example_ResponseWriter_trailers +const TrailerPrefix = "Trailer:" + +// promoteUndeclaredTrailers permits http.Handlers to set trailers +// after the header has already been flushed. Because the Go +// ResponseWriter interface has no way to set Trailers (only the +// Header), and because we didn't want to expand the ResponseWriter +// interface, and because nobody used trailers, and because RFC 2616 +// says you SHOULD (but not must) predeclare any trailers in the +// header, the official ResponseWriter rules said trailers in Go must +// be predeclared, and then we reuse the same ResponseWriter.Header() +// map to mean both Headers and Trailers. When it's time to write the +// Trailers, we pick out the fields of Headers that were declared as +// trailers. That worked for a while, until we found the first major +// user of Trailers in the wild: gRPC (using them only over http2), +// and gRPC libraries permit setting trailers mid-stream without +// predeclarnig them. So: change of plans. We still permit the old +// way, but we also permit this hack: if a Header() key begins with +// "Trailer:", the suffix of that key is a Trailer. Because ':' is an +// invalid token byte anyway, there is no ambiguity. (And it's already +// filtered out) It's mildly hacky, but not terrible. +// +// This method runs after the Handler is done and promotes any Header +// fields to be trailers. +func (rws *responseWriterState) promoteUndeclaredTrailers() { + for k, vv := range rws.handlerHeader { + if !strings.HasPrefix(k, TrailerPrefix) { + continue + } + trailerKey := strings.TrimPrefix(k, TrailerPrefix) + rws.declareTrailer(trailerKey) + rws.handlerHeader[http.CanonicalHeaderKey(trailerKey)] = vv + } + + if len(rws.trailers) > 1 { + sorter := sorterPool.Get().(*sorter) + sorter.SortStrings(rws.trailers) + sorterPool.Put(sorter) + } +} + +func (w *responseWriter) Flush() { + rws := w.rws + if rws == nil { + panic("Header called after Handler finished") + } + if rws.bw.Buffered() > 0 { + if err := rws.bw.Flush(); err != nil { + // Ignore the error. The frame writer already knows. + return + } + } else { + // The bufio.Writer won't call chunkWriter.Write + // (writeChunk with zero bytes, so we have to do it + // ourselves to force the HTTP response header and/or + // final DATA frame (with END_STREAM) to be sent. + rws.writeChunk(nil) + } +} + +func (w *responseWriter) CloseNotify() <-chan bool { + rws := w.rws + if rws == nil { + panic("CloseNotify called after Handler finished") + } + rws.closeNotifierMu.Lock() + ch := rws.closeNotifierCh + if ch == nil { + ch = make(chan bool, 1) + rws.closeNotifierCh = ch + go func() { + rws.stream.cw.Wait() // wait for close + ch <- true + }() + } + rws.closeNotifierMu.Unlock() + return ch +} + +func (w *responseWriter) Header() http.Header { + rws := w.rws + if rws == nil { + panic("Header called after Handler finished") + } + if rws.handlerHeader == nil { + rws.handlerHeader = make(http.Header) + } + return rws.handlerHeader +} + +func (w *responseWriter) WriteHeader(code int) { + rws := w.rws + if rws == nil { + panic("WriteHeader called after Handler finished") + } + rws.writeHeader(code) +} + +func (rws *responseWriterState) writeHeader(code int) { + if !rws.wroteHeader { + rws.wroteHeader = true + rws.status = code + if len(rws.handlerHeader) > 0 { + rws.snapHeader = cloneHeader(rws.handlerHeader) + } + } +} + +func cloneHeader(h http.Header) http.Header { + h2 := make(http.Header, len(h)) + for k, vv := range h { + vv2 := make([]string, len(vv)) + copy(vv2, vv) + h2[k] = vv2 + } + return h2 +} + +// The Life Of A Write is like this: +// +// * Handler calls w.Write or w.WriteString -> +// * -> rws.bw (*bufio.Writer) -> +// * (Handler migth call Flush) +// * -> chunkWriter{rws} +// * -> responseWriterState.writeChunk(p []byte) +// * -> responseWriterState.writeChunk (most of the magic; see comment there) +func (w *responseWriter) Write(p []byte) (n int, err error) { + return w.write(len(p), p, "") +} + +func (w *responseWriter) WriteString(s string) (n int, err error) { + return w.write(len(s), nil, s) +} + +// either dataB or dataS is non-zero. +func (w *responseWriter) write(lenData int, dataB []byte, dataS string) (n int, err error) { + rws := w.rws + if rws == nil { + panic("Write called after Handler finished") + } + if !rws.wroteHeader { + w.WriteHeader(200) + } + if !bodyAllowedForStatus(rws.status) { + return 0, http.ErrBodyNotAllowed + } + rws.wroteBytes += int64(len(dataB)) + int64(len(dataS)) // only one can be set + if rws.sentContentLen != 0 && rws.wroteBytes > rws.sentContentLen { + // TODO: send a RST_STREAM + return 0, errors.New("http2: handler wrote more than declared Content-Length") + } + + if dataB != nil { + return rws.bw.Write(dataB) + } else { + return rws.bw.WriteString(dataS) + } +} + +func (w *responseWriter) handlerDone() { + rws := w.rws + rws.handlerDone = true + w.Flush() + w.rws = nil + responseWriterStatePool.Put(rws) +} + +// foreachHeaderElement splits v according to the "#rule" construction +// in RFC 2616 section 2.1 and calls fn for each non-empty element. +func foreachHeaderElement(v string, fn func(string)) { + v = textproto.TrimString(v) + if v == "" { + return + } + if !strings.Contains(v, ",") { + fn(v) + return + } + for _, f := range strings.Split(v, ",") { + if f = textproto.TrimString(f); f != "" { + fn(f) + } + } +} + +// From http://httpwg.org/specs/rfc7540.html#rfc.section.8.1.2.2 +var connHeaders = []string{ + "Connection", + "Keep-Alive", + "Proxy-Connection", + "Transfer-Encoding", + "Upgrade", +} + +// checkValidHTTP2Request checks whether req is a valid HTTP/2 request, +// per RFC 7540 Section 8.1.2.2. +// The returned error is reported to users. +func checkValidHTTP2Request(req *http.Request) error { + for _, h := range connHeaders { + if _, ok := req.Header[h]; ok { + return fmt.Errorf("request header %q is not valid in HTTP/2", h) + } + } + te := req.Header["Te"] + if len(te) > 0 && (len(te) > 1 || (te[0] != "trailers" && te[0] != "")) { + return errors.New(`request header "TE" may only be "trailers" in HTTP/2`) + } + return nil +} + +func new400Handler(err error) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + http.Error(w, err.Error(), http.StatusBadRequest) + } +} + +// ValidTrailerHeader reports whether name is a valid header field name to appear +// in trailers. +// See: http://tools.ietf.org/html/rfc7230#section-4.1.2 +func ValidTrailerHeader(name string) bool { + name = http.CanonicalHeaderKey(name) + if strings.HasPrefix(name, "If-") || badTrailer[name] { + return false + } + return true +} + +var badTrailer = map[string]bool{ + "Authorization": true, + "Cache-Control": true, + "Connection": true, + "Content-Encoding": true, + "Content-Length": true, + "Content-Range": true, + "Content-Type": true, + "Expect": true, + "Host": true, + "Keep-Alive": true, + "Max-Forwards": true, + "Pragma": true, + "Proxy-Authenticate": true, + "Proxy-Authorization": true, + "Proxy-Connection": true, + "Range": true, + "Realm": true, + "Te": true, + "Trailer": true, + "Transfer-Encoding": true, + "Www-Authenticate": true, +} diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go new file mode 100644 index 00000000..ccb885ff --- /dev/null +++ b/vendor/golang.org/x/net/http2/transport.go @@ -0,0 +1,1978 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Transport code. + +package http2 + +import ( + "bufio" + "bytes" + "compress/gzip" + "crypto/tls" + "errors" + "fmt" + "io" + "io/ioutil" + "log" + "math" + "net" + "net/http" + "sort" + "strconv" + "strings" + "sync" + "time" + + "golang.org/x/net/http2/hpack" + "golang.org/x/net/lex/httplex" +) + +const ( + // transportDefaultConnFlow is how many connection-level flow control + // tokens we give the server at start-up, past the default 64k. + transportDefaultConnFlow = 1 << 30 + + // transportDefaultStreamFlow is how many stream-level flow + // control tokens we announce to the peer, and how many bytes + // we buffer per stream. + transportDefaultStreamFlow = 4 << 20 + + // transportDefaultStreamMinRefresh is the minimum number of bytes we'll send + // a stream-level WINDOW_UPDATE for at a time. + transportDefaultStreamMinRefresh = 4 << 10 + + defaultUserAgent = "Go-http-client/2.0" +) + +// Transport is an HTTP/2 Transport. +// +// A Transport internally caches connections to servers. It is safe +// for concurrent use by multiple goroutines. +type Transport struct { + // DialTLS specifies an optional dial function for creating + // TLS connections for requests. + // + // If DialTLS is nil, tls.Dial is used. + // + // If the returned net.Conn has a ConnectionState method like tls.Conn, + // it will be used to set http.Response.TLS. + DialTLS func(network, addr string, cfg *tls.Config) (net.Conn, error) + + // TLSClientConfig specifies the TLS configuration to use with + // tls.Client. If nil, the default configuration is used. + TLSClientConfig *tls.Config + + // ConnPool optionally specifies an alternate connection pool to use. + // If nil, the default is used. + ConnPool ClientConnPool + + // DisableCompression, if true, prevents the Transport from + // requesting compression with an "Accept-Encoding: gzip" + // request header when the Request contains no existing + // Accept-Encoding value. If the Transport requests gzip on + // its own and gets a gzipped response, it's transparently + // decoded in the Response.Body. However, if the user + // explicitly requested gzip it is not automatically + // uncompressed. + DisableCompression bool + + // AllowHTTP, if true, permits HTTP/2 requests using the insecure, + // plain-text "http" scheme. Note that this does not enable h2c support. + AllowHTTP bool + + // MaxHeaderListSize is the http2 SETTINGS_MAX_HEADER_LIST_SIZE to + // send in the initial settings frame. It is how many bytes + // of response headers are allow. Unlike the http2 spec, zero here + // means to use a default limit (currently 10MB). If you actually + // want to advertise an ulimited value to the peer, Transport + // interprets the highest possible value here (0xffffffff or 1<<32-1) + // to mean no limit. + MaxHeaderListSize uint32 + + // t1, if non-nil, is the standard library Transport using + // this transport. Its settings are used (but not its + // RoundTrip method, etc). + t1 *http.Transport + + connPoolOnce sync.Once + connPoolOrDef ClientConnPool // non-nil version of ConnPool +} + +func (t *Transport) maxHeaderListSize() uint32 { + if t.MaxHeaderListSize == 0 { + return 10 << 20 + } + if t.MaxHeaderListSize == 0xffffffff { + return 0 + } + return t.MaxHeaderListSize +} + +func (t *Transport) disableCompression() bool { + return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression) +} + +var errTransportVersion = errors.New("http2: ConfigureTransport is only supported starting at Go 1.6") + +// ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2. +// It requires Go 1.6 or later and returns an error if the net/http package is too old +// or if t1 has already been HTTP/2-enabled. +func ConfigureTransport(t1 *http.Transport) error { + _, err := configureTransport(t1) // in configure_transport.go (go1.6) or not_go16.go + return err +} + +func (t *Transport) connPool() ClientConnPool { + t.connPoolOnce.Do(t.initConnPool) + return t.connPoolOrDef +} + +func (t *Transport) initConnPool() { + if t.ConnPool != nil { + t.connPoolOrDef = t.ConnPool + } else { + t.connPoolOrDef = &clientConnPool{t: t} + } +} + +// ClientConn is the state of a single HTTP/2 client connection to an +// HTTP/2 server. +type ClientConn struct { + t *Transport + tconn net.Conn // usually *tls.Conn, except specialized impls + tlsState *tls.ConnectionState // nil only for specialized impls + singleUse bool // whether being used for a single http.Request + + // readLoop goroutine fields: + readerDone chan struct{} // closed on error + readerErr error // set before readerDone is closed + + mu sync.Mutex // guards following + cond *sync.Cond // hold mu; broadcast on flow/closed changes + flow flow // our conn-level flow control quota (cs.flow is per stream) + inflow flow // peer's conn-level flow control + closed bool + wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back + goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received + goAwayDebug string // goAway frame's debug data, retained as a string + streams map[uint32]*clientStream // client-initiated + nextStreamID uint32 + bw *bufio.Writer + br *bufio.Reader + fr *Framer + lastActive time.Time + // Settings from peer: (also guarded by mu) + maxFrameSize uint32 + maxConcurrentStreams uint32 + initialWindowSize uint32 + + hbuf bytes.Buffer // HPACK encoder writes into this + henc *hpack.Encoder + freeBuf [][]byte + + wmu sync.Mutex // held while writing; acquire AFTER mu if holding both + werr error // first write error that has occurred +} + +// clientStream is the state for a single HTTP/2 stream. One of these +// is created for each Transport.RoundTrip call. +type clientStream struct { + cc *ClientConn + req *http.Request + trace *clientTrace // or nil + ID uint32 + resc chan resAndError + bufPipe pipe // buffered pipe with the flow-controlled response payload + requestedGzip bool + on100 func() // optional code to run if get a 100 continue response + + flow flow // guarded by cc.mu + inflow flow // guarded by cc.mu + bytesRemain int64 // -1 means unknown; owned by transportResponseBody.Read + readErr error // sticky read error; owned by transportResponseBody.Read + stopReqBody error // if non-nil, stop writing req body; guarded by cc.mu + + peerReset chan struct{} // closed on peer reset + resetErr error // populated before peerReset is closed + + done chan struct{} // closed when stream remove from cc.streams map; close calls guarded by cc.mu + + // owned by clientConnReadLoop: + firstByte bool // got the first response byte + pastHeaders bool // got first MetaHeadersFrame (actual headers) + pastTrailers bool // got optional second MetaHeadersFrame (trailers) + + trailer http.Header // accumulated trailers + resTrailer *http.Header // client's Response.Trailer +} + +// awaitRequestCancel runs in its own goroutine and waits for the user +// to cancel a RoundTrip request, its context to expire, or for the +// request to be done (any way it might be removed from the cc.streams +// map: peer reset, successful completion, TCP connection breakage, +// etc) +func (cs *clientStream) awaitRequestCancel(req *http.Request) { + ctx := reqContext(req) + if req.Cancel == nil && ctx.Done() == nil { + return + } + select { + case <-req.Cancel: + cs.bufPipe.CloseWithError(errRequestCanceled) + cs.cc.writeStreamReset(cs.ID, ErrCodeCancel, nil) + case <-ctx.Done(): + cs.bufPipe.CloseWithError(ctx.Err()) + cs.cc.writeStreamReset(cs.ID, ErrCodeCancel, nil) + case <-cs.done: + } +} + +// checkResetOrDone reports any error sent in a RST_STREAM frame by the +// server, or errStreamClosed if the stream is complete. +func (cs *clientStream) checkResetOrDone() error { + select { + case <-cs.peerReset: + return cs.resetErr + case <-cs.done: + return errStreamClosed + default: + return nil + } +} + +func (cs *clientStream) abortRequestBodyWrite(err error) { + if err == nil { + panic("nil error") + } + cc := cs.cc + cc.mu.Lock() + cs.stopReqBody = err + cc.cond.Broadcast() + cc.mu.Unlock() +} + +type stickyErrWriter struct { + w io.Writer + err *error +} + +func (sew stickyErrWriter) Write(p []byte) (n int, err error) { + if *sew.err != nil { + return 0, *sew.err + } + n, err = sew.w.Write(p) + *sew.err = err + return +} + +var ErrNoCachedConn = errors.New("http2: no cached connection was available") + +// RoundTripOpt are options for the Transport.RoundTripOpt method. +type RoundTripOpt struct { + // OnlyCachedConn controls whether RoundTripOpt may + // create a new TCP connection. If set true and + // no cached connection is available, RoundTripOpt + // will return ErrNoCachedConn. + OnlyCachedConn bool +} + +func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) { + return t.RoundTripOpt(req, RoundTripOpt{}) +} + +// authorityAddr returns a given authority (a host/IP, or host:port / ip:port) +// and returns a host:port. The port 443 is added if needed. +func authorityAddr(scheme string, authority string) (addr string) { + if _, _, err := net.SplitHostPort(authority); err == nil { + return authority + } + port := "443" + if scheme == "http" { + port = "80" + } + return net.JoinHostPort(authority, port) +} + +// RoundTripOpt is like RoundTrip, but takes options. +func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) { + if !(req.URL.Scheme == "https" || (req.URL.Scheme == "http" && t.AllowHTTP)) { + return nil, errors.New("http2: unsupported scheme") + } + + addr := authorityAddr(req.URL.Scheme, req.URL.Host) + for { + cc, err := t.connPool().GetClientConn(req, addr) + if err != nil { + t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err) + return nil, err + } + traceGotConn(req, cc) + res, err := cc.RoundTrip(req) + if shouldRetryRequest(req, err) { + continue + } + if err != nil { + t.vlogf("RoundTrip failure: %v", err) + return nil, err + } + return res, nil + } +} + +// CloseIdleConnections closes any connections which were previously +// connected from previous requests but are now sitting idle. +// It does not interrupt any connections currently in use. +func (t *Transport) CloseIdleConnections() { + if cp, ok := t.connPool().(clientConnPoolIdleCloser); ok { + cp.closeIdleConnections() + } +} + +var ( + errClientConnClosed = errors.New("http2: client conn is closed") + errClientConnUnusable = errors.New("http2: client conn not usable") +) + +func shouldRetryRequest(req *http.Request, err error) bool { + // TODO: retry GET requests (no bodies) more aggressively, if shutdown + // before response. + return err == errClientConnUnusable +} + +func (t *Transport) dialClientConn(addr string, singleUse bool) (*ClientConn, error) { + host, _, err := net.SplitHostPort(addr) + if err != nil { + return nil, err + } + tconn, err := t.dialTLS()("tcp", addr, t.newTLSConfig(host)) + if err != nil { + return nil, err + } + return t.newClientConn(tconn, singleUse) +} + +func (t *Transport) newTLSConfig(host string) *tls.Config { + cfg := new(tls.Config) + if t.TLSClientConfig != nil { + *cfg = *t.TLSClientConfig + } + if !strSliceContains(cfg.NextProtos, NextProtoTLS) { + cfg.NextProtos = append([]string{NextProtoTLS}, cfg.NextProtos...) + } + if cfg.ServerName == "" { + cfg.ServerName = host + } + return cfg +} + +func (t *Transport) dialTLS() func(string, string, *tls.Config) (net.Conn, error) { + if t.DialTLS != nil { + return t.DialTLS + } + return t.dialTLSDefault +} + +func (t *Transport) dialTLSDefault(network, addr string, cfg *tls.Config) (net.Conn, error) { + cn, err := tls.Dial(network, addr, cfg) + if err != nil { + return nil, err + } + if err := cn.Handshake(); err != nil { + return nil, err + } + if !cfg.InsecureSkipVerify { + if err := cn.VerifyHostname(cfg.ServerName); err != nil { + return nil, err + } + } + state := cn.ConnectionState() + if p := state.NegotiatedProtocol; p != NextProtoTLS { + return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, NextProtoTLS) + } + if !state.NegotiatedProtocolIsMutual { + return nil, errors.New("http2: could not negotiate protocol mutually") + } + return cn, nil +} + +// disableKeepAlives reports whether connections should be closed as +// soon as possible after handling the first request. +func (t *Transport) disableKeepAlives() bool { + return t.t1 != nil && t.t1.DisableKeepAlives +} + +func (t *Transport) expectContinueTimeout() time.Duration { + if t.t1 == nil { + return 0 + } + return transportExpectContinueTimeout(t.t1) +} + +func (t *Transport) NewClientConn(c net.Conn) (*ClientConn, error) { + return t.newClientConn(c, false) +} + +func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, error) { + cc := &ClientConn{ + t: t, + tconn: c, + readerDone: make(chan struct{}), + nextStreamID: 1, + maxFrameSize: 16 << 10, // spec default + initialWindowSize: 65535, // spec default + maxConcurrentStreams: 1000, // "infinite", per spec. 1000 seems good enough. + streams: make(map[uint32]*clientStream), + singleUse: singleUse, + wantSettingsAck: true, + } + if VerboseLogs { + t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr()) + } + + cc.cond = sync.NewCond(&cc.mu) + cc.flow.add(int32(initialWindowSize)) + + // TODO: adjust this writer size to account for frame size + + // MTU + crypto/tls record padding. + cc.bw = bufio.NewWriter(stickyErrWriter{c, &cc.werr}) + cc.br = bufio.NewReader(c) + cc.fr = NewFramer(cc.bw, cc.br) + cc.fr.ReadMetaHeaders = hpack.NewDecoder(initialHeaderTableSize, nil) + cc.fr.MaxHeaderListSize = t.maxHeaderListSize() + + // TODO: SetMaxDynamicTableSize, SetMaxDynamicTableSizeLimit on + // henc in response to SETTINGS frames? + cc.henc = hpack.NewEncoder(&cc.hbuf) + + if cs, ok := c.(connectionStater); ok { + state := cs.ConnectionState() + cc.tlsState = &state + } + + initialSettings := []Setting{ + {ID: SettingEnablePush, Val: 0}, + {ID: SettingInitialWindowSize, Val: transportDefaultStreamFlow}, + } + if max := t.maxHeaderListSize(); max != 0 { + initialSettings = append(initialSettings, Setting{ID: SettingMaxHeaderListSize, Val: max}) + } + + cc.bw.Write(clientPreface) + cc.fr.WriteSettings(initialSettings...) + cc.fr.WriteWindowUpdate(0, transportDefaultConnFlow) + cc.inflow.add(transportDefaultConnFlow + initialWindowSize) + cc.bw.Flush() + if cc.werr != nil { + return nil, cc.werr + } + + go cc.readLoop() + return cc, nil +} + +func (cc *ClientConn) setGoAway(f *GoAwayFrame) { + cc.mu.Lock() + defer cc.mu.Unlock() + + old := cc.goAway + cc.goAway = f + + // Merge the previous and current GoAway error frames. + if cc.goAwayDebug == "" { + cc.goAwayDebug = string(f.DebugData()) + } + if old != nil && old.ErrCode != ErrCodeNo { + cc.goAway.ErrCode = old.ErrCode + } +} + +func (cc *ClientConn) CanTakeNewRequest() bool { + cc.mu.Lock() + defer cc.mu.Unlock() + return cc.canTakeNewRequestLocked() +} + +func (cc *ClientConn) canTakeNewRequestLocked() bool { + if cc.singleUse && cc.nextStreamID > 1 { + return false + } + return cc.goAway == nil && !cc.closed && + int64(len(cc.streams)+1) < int64(cc.maxConcurrentStreams) && + cc.nextStreamID < math.MaxInt32 +} + +func (cc *ClientConn) closeIfIdle() { + cc.mu.Lock() + if len(cc.streams) > 0 { + cc.mu.Unlock() + return + } + cc.closed = true + nextID := cc.nextStreamID + // TODO: do clients send GOAWAY too? maybe? Just Close: + cc.mu.Unlock() + + if VerboseLogs { + cc.vlogf("http2: Transport closing idle conn %p (forSingleUse=%v, maxStream=%v)", cc, cc.singleUse, nextID-2) + } + cc.tconn.Close() +} + +const maxAllocFrameSize = 512 << 10 + +// frameBuffer returns a scratch buffer suitable for writing DATA frames. +// They're capped at the min of the peer's max frame size or 512KB +// (kinda arbitrarily), but definitely capped so we don't allocate 4GB +// bufers. +func (cc *ClientConn) frameScratchBuffer() []byte { + cc.mu.Lock() + size := cc.maxFrameSize + if size > maxAllocFrameSize { + size = maxAllocFrameSize + } + for i, buf := range cc.freeBuf { + if len(buf) >= int(size) { + cc.freeBuf[i] = nil + cc.mu.Unlock() + return buf[:size] + } + } + cc.mu.Unlock() + return make([]byte, size) +} + +func (cc *ClientConn) putFrameScratchBuffer(buf []byte) { + cc.mu.Lock() + defer cc.mu.Unlock() + const maxBufs = 4 // arbitrary; 4 concurrent requests per conn? investigate. + if len(cc.freeBuf) < maxBufs { + cc.freeBuf = append(cc.freeBuf, buf) + return + } + for i, old := range cc.freeBuf { + if old == nil { + cc.freeBuf[i] = buf + return + } + } + // forget about it. +} + +// errRequestCanceled is a copy of net/http's errRequestCanceled because it's not +// exported. At least they'll be DeepEqual for h1-vs-h2 comparisons tests. +var errRequestCanceled = errors.New("net/http: request canceled") + +func commaSeparatedTrailers(req *http.Request) (string, error) { + keys := make([]string, 0, len(req.Trailer)) + for k := range req.Trailer { + k = http.CanonicalHeaderKey(k) + switch k { + case "Transfer-Encoding", "Trailer", "Content-Length": + return "", &badStringError{"invalid Trailer key", k} + } + keys = append(keys, k) + } + if len(keys) > 0 { + sort.Strings(keys) + // TODO: could do better allocation-wise here, but trailers are rare, + // so being lazy for now. + return strings.Join(keys, ","), nil + } + return "", nil +} + +func (cc *ClientConn) responseHeaderTimeout() time.Duration { + if cc.t.t1 != nil { + return cc.t.t1.ResponseHeaderTimeout + } + // No way to do this (yet?) with just an http2.Transport. Probably + // no need. Request.Cancel this is the new way. We only need to support + // this for compatibility with the old http.Transport fields when + // we're doing transparent http2. + return 0 +} + +// checkConnHeaders checks whether req has any invalid connection-level headers. +// per RFC 7540 section 8.1.2.2: Connection-Specific Header Fields. +// Certain headers are special-cased as okay but not transmitted later. +func checkConnHeaders(req *http.Request) error { + if v := req.Header.Get("Upgrade"); v != "" { + return errors.New("http2: invalid Upgrade request header") + } + if v := req.Header.Get("Transfer-Encoding"); (v != "" && v != "chunked") || len(req.Header["Transfer-Encoding"]) > 1 { + return errors.New("http2: invalid Transfer-Encoding request header") + } + if v := req.Header.Get("Connection"); (v != "" && v != "close" && v != "keep-alive") || len(req.Header["Connection"]) > 1 { + return errors.New("http2: invalid Connection request header") + } + return nil +} + +func bodyAndLength(req *http.Request) (body io.Reader, contentLen int64) { + body = req.Body + if body == nil { + return nil, 0 + } + if req.ContentLength != 0 { + return req.Body, req.ContentLength + } + + // We have a body but a zero content length. Test to see if + // it's actually zero or just unset. + var buf [1]byte + n, rerr := body.Read(buf[:]) + if rerr != nil && rerr != io.EOF { + return errorReader{rerr}, -1 + } + if n == 1 { + // Oh, guess there is data in this Body Reader after all. + // The ContentLength field just wasn't set. + // Stitch the Body back together again, re-attaching our + // consumed byte. + if rerr == io.EOF { + return bytes.NewReader(buf[:]), 1 + } + return io.MultiReader(bytes.NewReader(buf[:]), body), -1 + } + // Body is actually zero bytes. + return nil, 0 +} + +func (cc *ClientConn) RoundTrip(req *http.Request) (*http.Response, error) { + if err := checkConnHeaders(req); err != nil { + return nil, err + } + + trailers, err := commaSeparatedTrailers(req) + if err != nil { + return nil, err + } + hasTrailers := trailers != "" + + body, contentLen := bodyAndLength(req) + hasBody := body != nil + + cc.mu.Lock() + cc.lastActive = time.Now() + if cc.closed || !cc.canTakeNewRequestLocked() { + cc.mu.Unlock() + return nil, errClientConnUnusable + } + + // TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere? + var requestedGzip bool + if !cc.t.disableCompression() && + req.Header.Get("Accept-Encoding") == "" && + req.Header.Get("Range") == "" && + req.Method != "HEAD" { + // Request gzip only, not deflate. Deflate is ambiguous and + // not as universally supported anyway. + // See: http://www.gzip.org/zlib/zlib_faq.html#faq38 + // + // Note that we don't request this for HEAD requests, + // due to a bug in nginx: + // http://trac.nginx.org/nginx/ticket/358 + // https://golang.org/issue/5522 + // + // We don't request gzip if the request is for a range, since + // auto-decoding a portion of a gzipped document will just fail + // anyway. See https://golang.org/issue/8923 + requestedGzip = true + } + + // we send: HEADERS{1}, CONTINUATION{0,} + DATA{0,} (DATA is + // sent by writeRequestBody below, along with any Trailers, + // again in form HEADERS{1}, CONTINUATION{0,}) + hdrs, err := cc.encodeHeaders(req, requestedGzip, trailers, contentLen) + if err != nil { + cc.mu.Unlock() + return nil, err + } + + cs := cc.newStream() + cs.req = req + cs.trace = requestTrace(req) + cs.requestedGzip = requestedGzip + bodyWriter := cc.t.getBodyWriterState(cs, body) + cs.on100 = bodyWriter.on100 + + cc.wmu.Lock() + endStream := !hasBody && !hasTrailers + werr := cc.writeHeaders(cs.ID, endStream, hdrs) + cc.wmu.Unlock() + traceWroteHeaders(cs.trace) + cc.mu.Unlock() + + if werr != nil { + if hasBody { + req.Body.Close() // per RoundTripper contract + bodyWriter.cancel() + } + cc.forgetStreamID(cs.ID) + // Don't bother sending a RST_STREAM (our write already failed; + // no need to keep writing) + traceWroteRequest(cs.trace, werr) + return nil, werr + } + + var respHeaderTimer <-chan time.Time + if hasBody { + bodyWriter.scheduleBodyWrite() + } else { + traceWroteRequest(cs.trace, nil) + if d := cc.responseHeaderTimeout(); d != 0 { + timer := time.NewTimer(d) + defer timer.Stop() + respHeaderTimer = timer.C + } + } + + readLoopResCh := cs.resc + bodyWritten := false + ctx := reqContext(req) + + handleReadLoopResponse := func(re resAndError) (*http.Response, error) { + res := re.res + if re.err != nil || res.StatusCode > 299 { + // On error or status code 3xx, 4xx, 5xx, etc abort any + // ongoing write, assuming that the server doesn't care + // about our request body. If the server replied with 1xx or + // 2xx, however, then assume the server DOES potentially + // want our body (e.g. full-duplex streaming: + // golang.org/issue/13444). If it turns out the server + // doesn't, they'll RST_STREAM us soon enough. This is a + // heuristic to avoid adding knobs to Transport. Hopefully + // we can keep it. + bodyWriter.cancel() + cs.abortRequestBodyWrite(errStopReqBodyWrite) + } + if re.err != nil { + cc.forgetStreamID(cs.ID) + return nil, re.err + } + res.Request = req + res.TLS = cc.tlsState + return res, nil + } + + for { + select { + case re := <-readLoopResCh: + return handleReadLoopResponse(re) + case <-respHeaderTimer: + cc.forgetStreamID(cs.ID) + if !hasBody || bodyWritten { + cc.writeStreamReset(cs.ID, ErrCodeCancel, nil) + } else { + bodyWriter.cancel() + cs.abortRequestBodyWrite(errStopReqBodyWriteAndCancel) + } + return nil, errTimeout + case <-ctx.Done(): + cc.forgetStreamID(cs.ID) + if !hasBody || bodyWritten { + cc.writeStreamReset(cs.ID, ErrCodeCancel, nil) + } else { + bodyWriter.cancel() + cs.abortRequestBodyWrite(errStopReqBodyWriteAndCancel) + } + return nil, ctx.Err() + case <-req.Cancel: + cc.forgetStreamID(cs.ID) + if !hasBody || bodyWritten { + cc.writeStreamReset(cs.ID, ErrCodeCancel, nil) + } else { + bodyWriter.cancel() + cs.abortRequestBodyWrite(errStopReqBodyWriteAndCancel) + } + return nil, errRequestCanceled + case <-cs.peerReset: + // processResetStream already removed the + // stream from the streams map; no need for + // forgetStreamID. + return nil, cs.resetErr + case err := <-bodyWriter.resc: + // Prefer the read loop's response, if available. Issue 16102. + select { + case re := <-readLoopResCh: + return handleReadLoopResponse(re) + default: + } + if err != nil { + return nil, err + } + bodyWritten = true + if d := cc.responseHeaderTimeout(); d != 0 { + timer := time.NewTimer(d) + defer timer.Stop() + respHeaderTimer = timer.C + } + } + } +} + +// requires cc.wmu be held +func (cc *ClientConn) writeHeaders(streamID uint32, endStream bool, hdrs []byte) error { + first := true // first frame written (HEADERS is first, then CONTINUATION) + frameSize := int(cc.maxFrameSize) + for len(hdrs) > 0 && cc.werr == nil { + chunk := hdrs + if len(chunk) > frameSize { + chunk = chunk[:frameSize] + } + hdrs = hdrs[len(chunk):] + endHeaders := len(hdrs) == 0 + if first { + cc.fr.WriteHeaders(HeadersFrameParam{ + StreamID: streamID, + BlockFragment: chunk, + EndStream: endStream, + EndHeaders: endHeaders, + }) + first = false + } else { + cc.fr.WriteContinuation(streamID, endHeaders, chunk) + } + } + // TODO(bradfitz): this Flush could potentially block (as + // could the WriteHeaders call(s) above), which means they + // wouldn't respond to Request.Cancel being readable. That's + // rare, but this should probably be in a goroutine. + cc.bw.Flush() + return cc.werr +} + +// internal error values; they don't escape to callers +var ( + // abort request body write; don't send cancel + errStopReqBodyWrite = errors.New("http2: aborting request body write") + + // abort request body write, but send stream reset of cancel. + errStopReqBodyWriteAndCancel = errors.New("http2: canceling request") +) + +func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) (err error) { + cc := cs.cc + sentEnd := false // whether we sent the final DATA frame w/ END_STREAM + buf := cc.frameScratchBuffer() + defer cc.putFrameScratchBuffer(buf) + + defer func() { + traceWroteRequest(cs.trace, err) + // TODO: write h12Compare test showing whether + // Request.Body is closed by the Transport, + // and in multiple cases: server replies <=299 and >299 + // while still writing request body + cerr := bodyCloser.Close() + if err == nil { + err = cerr + } + }() + + req := cs.req + hasTrailers := req.Trailer != nil + + var sawEOF bool + for !sawEOF { + n, err := body.Read(buf) + if err == io.EOF { + sawEOF = true + err = nil + } else if err != nil { + return err + } + + remain := buf[:n] + for len(remain) > 0 && err == nil { + var allowed int32 + allowed, err = cs.awaitFlowControl(len(remain)) + switch { + case err == errStopReqBodyWrite: + return err + case err == errStopReqBodyWriteAndCancel: + cc.writeStreamReset(cs.ID, ErrCodeCancel, nil) + return err + case err != nil: + return err + } + cc.wmu.Lock() + data := remain[:allowed] + remain = remain[allowed:] + sentEnd = sawEOF && len(remain) == 0 && !hasTrailers + err = cc.fr.WriteData(cs.ID, sentEnd, data) + if err == nil { + // TODO(bradfitz): this flush is for latency, not bandwidth. + // Most requests won't need this. Make this opt-in or + // opt-out? Use some heuristic on the body type? Nagel-like + // timers? Based on 'n'? Only last chunk of this for loop, + // unless flow control tokens are low? For now, always. + // If we change this, see comment below. + err = cc.bw.Flush() + } + cc.wmu.Unlock() + } + if err != nil { + return err + } + } + + if sentEnd { + // Already sent END_STREAM (which implies we have no + // trailers) and flushed, because currently all + // WriteData frames above get a flush. So we're done. + return nil + } + + var trls []byte + if hasTrailers { + cc.mu.Lock() + defer cc.mu.Unlock() + trls = cc.encodeTrailers(req) + } + + cc.wmu.Lock() + defer cc.wmu.Unlock() + + // Two ways to send END_STREAM: either with trailers, or + // with an empty DATA frame. + if len(trls) > 0 { + err = cc.writeHeaders(cs.ID, true, trls) + } else { + err = cc.fr.WriteData(cs.ID, true, nil) + } + if ferr := cc.bw.Flush(); ferr != nil && err == nil { + err = ferr + } + return err +} + +// awaitFlowControl waits for [1, min(maxBytes, cc.cs.maxFrameSize)] flow +// control tokens from the server. +// It returns either the non-zero number of tokens taken or an error +// if the stream is dead. +func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) { + cc := cs.cc + cc.mu.Lock() + defer cc.mu.Unlock() + for { + if cc.closed { + return 0, errClientConnClosed + } + if cs.stopReqBody != nil { + return 0, cs.stopReqBody + } + if err := cs.checkResetOrDone(); err != nil { + return 0, err + } + if a := cs.flow.available(); a > 0 { + take := a + if int(take) > maxBytes { + + take = int32(maxBytes) // can't truncate int; take is int32 + } + if take > int32(cc.maxFrameSize) { + take = int32(cc.maxFrameSize) + } + cs.flow.take(take) + return take, nil + } + cc.cond.Wait() + } +} + +type badStringError struct { + what string + str string +} + +func (e *badStringError) Error() string { return fmt.Sprintf("%s %q", e.what, e.str) } + +// requires cc.mu be held. +func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) { + cc.hbuf.Reset() + + host := req.Host + if host == "" { + host = req.URL.Host + } + + // Check for any invalid headers and return an error before we + // potentially pollute our hpack state. (We want to be able to + // continue to reuse the hpack encoder for future requests) + for k, vv := range req.Header { + if !httplex.ValidHeaderFieldName(k) { + return nil, fmt.Errorf("invalid HTTP header name %q", k) + } + for _, v := range vv { + if !httplex.ValidHeaderFieldValue(v) { + return nil, fmt.Errorf("invalid HTTP header value %q for header %q", v, k) + } + } + } + + // 8.1.2.3 Request Pseudo-Header Fields + // The :path pseudo-header field includes the path and query parts of the + // target URI (the path-absolute production and optionally a '?' character + // followed by the query production (see Sections 3.3 and 3.4 of + // [RFC3986]). + cc.writeHeader(":authority", host) + cc.writeHeader(":method", req.Method) + if req.Method != "CONNECT" { + cc.writeHeader(":path", req.URL.RequestURI()) + cc.writeHeader(":scheme", "https") + } + if trailers != "" { + cc.writeHeader("trailer", trailers) + } + + var didUA bool + for k, vv := range req.Header { + lowKey := strings.ToLower(k) + switch lowKey { + case "host", "content-length": + // Host is :authority, already sent. + // Content-Length is automatic, set below. + continue + case "connection", "proxy-connection", "transfer-encoding", "upgrade", "keep-alive": + // Per 8.1.2.2 Connection-Specific Header + // Fields, don't send connection-specific + // fields. We have already checked if any + // are error-worthy so just ignore the rest. + continue + case "user-agent": + // Match Go's http1 behavior: at most one + // User-Agent. If set to nil or empty string, + // then omit it. Otherwise if not mentioned, + // include the default (below). + didUA = true + if len(vv) < 1 { + continue + } + vv = vv[:1] + if vv[0] == "" { + continue + } + } + for _, v := range vv { + cc.writeHeader(lowKey, v) + } + } + if shouldSendReqContentLength(req.Method, contentLength) { + cc.writeHeader("content-length", strconv.FormatInt(contentLength, 10)) + } + if addGzipHeader { + cc.writeHeader("accept-encoding", "gzip") + } + if !didUA { + cc.writeHeader("user-agent", defaultUserAgent) + } + return cc.hbuf.Bytes(), nil +} + +// shouldSendReqContentLength reports whether the http2.Transport should send +// a "content-length" request header. This logic is basically a copy of the net/http +// transferWriter.shouldSendContentLength. +// The contentLength is the corrected contentLength (so 0 means actually 0, not unknown). +// -1 means unknown. +func shouldSendReqContentLength(method string, contentLength int64) bool { + if contentLength > 0 { + return true + } + if contentLength < 0 { + return false + } + // For zero bodies, whether we send a content-length depends on the method. + // It also kinda doesn't matter for http2 either way, with END_STREAM. + switch method { + case "POST", "PUT", "PATCH": + return true + default: + return false + } +} + +// requires cc.mu be held. +func (cc *ClientConn) encodeTrailers(req *http.Request) []byte { + cc.hbuf.Reset() + for k, vv := range req.Trailer { + // Transfer-Encoding, etc.. have already been filter at the + // start of RoundTrip + lowKey := strings.ToLower(k) + for _, v := range vv { + cc.writeHeader(lowKey, v) + } + } + return cc.hbuf.Bytes() +} + +func (cc *ClientConn) writeHeader(name, value string) { + if VerboseLogs { + log.Printf("http2: Transport encoding header %q = %q", name, value) + } + cc.henc.WriteField(hpack.HeaderField{Name: name, Value: value}) +} + +type resAndError struct { + res *http.Response + err error +} + +// requires cc.mu be held. +func (cc *ClientConn) newStream() *clientStream { + cs := &clientStream{ + cc: cc, + ID: cc.nextStreamID, + resc: make(chan resAndError, 1), + peerReset: make(chan struct{}), + done: make(chan struct{}), + } + cs.flow.add(int32(cc.initialWindowSize)) + cs.flow.setConnFlow(&cc.flow) + cs.inflow.add(transportDefaultStreamFlow) + cs.inflow.setConnFlow(&cc.inflow) + cc.nextStreamID += 2 + cc.streams[cs.ID] = cs + return cs +} + +func (cc *ClientConn) forgetStreamID(id uint32) { + cc.streamByID(id, true) +} + +func (cc *ClientConn) streamByID(id uint32, andRemove bool) *clientStream { + cc.mu.Lock() + defer cc.mu.Unlock() + cs := cc.streams[id] + if andRemove && cs != nil && !cc.closed { + cc.lastActive = time.Now() + delete(cc.streams, id) + close(cs.done) + cc.cond.Broadcast() // wake up checkResetOrDone via clientStream.awaitFlowControl + } + return cs +} + +// clientConnReadLoop is the state owned by the clientConn's frame-reading readLoop. +type clientConnReadLoop struct { + cc *ClientConn + activeRes map[uint32]*clientStream // keyed by streamID + closeWhenIdle bool +} + +// readLoop runs in its own goroutine and reads and dispatches frames. +func (cc *ClientConn) readLoop() { + rl := &clientConnReadLoop{ + cc: cc, + activeRes: make(map[uint32]*clientStream), + } + + defer rl.cleanup() + cc.readerErr = rl.run() + if ce, ok := cc.readerErr.(ConnectionError); ok { + cc.wmu.Lock() + cc.fr.WriteGoAway(0, ErrCode(ce), nil) + cc.wmu.Unlock() + } +} + +// GoAwayError is returned by the Transport when the server closes the +// TCP connection after sending a GOAWAY frame. +type GoAwayError struct { + LastStreamID uint32 + ErrCode ErrCode + DebugData string +} + +func (e GoAwayError) Error() string { + return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q", + e.LastStreamID, e.ErrCode, e.DebugData) +} + +func isEOFOrNetReadError(err error) bool { + if err == io.EOF { + return true + } + ne, ok := err.(*net.OpError) + return ok && ne.Op == "read" +} + +func (rl *clientConnReadLoop) cleanup() { + cc := rl.cc + defer cc.tconn.Close() + defer cc.t.connPool().MarkDead(cc) + defer close(cc.readerDone) + + // Close any response bodies if the server closes prematurely. + // TODO: also do this if we've written the headers but not + // gotten a response yet. + err := cc.readerErr + cc.mu.Lock() + if cc.goAway != nil && isEOFOrNetReadError(err) { + err = GoAwayError{ + LastStreamID: cc.goAway.LastStreamID, + ErrCode: cc.goAway.ErrCode, + DebugData: cc.goAwayDebug, + } + } else if err == io.EOF { + err = io.ErrUnexpectedEOF + } + for _, cs := range rl.activeRes { + cs.bufPipe.CloseWithError(err) + } + for _, cs := range cc.streams { + select { + case cs.resc <- resAndError{err: err}: + default: + } + close(cs.done) + } + cc.closed = true + cc.cond.Broadcast() + cc.mu.Unlock() +} + +func (rl *clientConnReadLoop) run() error { + cc := rl.cc + rl.closeWhenIdle = cc.t.disableKeepAlives() || cc.singleUse + gotReply := false // ever saw a HEADERS reply + gotSettings := false + for { + f, err := cc.fr.ReadFrame() + if err != nil { + cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err) + } + if se, ok := err.(StreamError); ok { + if cs := cc.streamByID(se.StreamID, true /*ended; remove it*/); cs != nil { + cs.cc.writeStreamReset(cs.ID, se.Code, err) + if se.Cause == nil { + se.Cause = cc.fr.errDetail + } + rl.endStreamError(cs, se) + } + continue + } else if err != nil { + return err + } + if VerboseLogs { + cc.vlogf("http2: Transport received %s", summarizeFrame(f)) + } + if !gotSettings { + if _, ok := f.(*SettingsFrame); !ok { + cc.logf("protocol error: received %T before a SETTINGS frame", f) + return ConnectionError(ErrCodeProtocol) + } + gotSettings = true + } + maybeIdle := false // whether frame might transition us to idle + + switch f := f.(type) { + case *MetaHeadersFrame: + err = rl.processHeaders(f) + maybeIdle = true + gotReply = true + case *DataFrame: + err = rl.processData(f) + maybeIdle = true + case *GoAwayFrame: + err = rl.processGoAway(f) + maybeIdle = true + case *RSTStreamFrame: + err = rl.processResetStream(f) + maybeIdle = true + case *SettingsFrame: + err = rl.processSettings(f) + case *PushPromiseFrame: + err = rl.processPushPromise(f) + case *WindowUpdateFrame: + err = rl.processWindowUpdate(f) + case *PingFrame: + err = rl.processPing(f) + default: + cc.logf("Transport: unhandled response frame type %T", f) + } + if err != nil { + if VerboseLogs { + cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, summarizeFrame(f), err) + } + return err + } + if rl.closeWhenIdle && gotReply && maybeIdle && len(rl.activeRes) == 0 { + cc.closeIfIdle() + } + } +} + +func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error { + cc := rl.cc + cs := cc.streamByID(f.StreamID, f.StreamEnded()) + if cs == nil { + // We'd get here if we canceled a request while the + // server had its response still in flight. So if this + // was just something we canceled, ignore it. + return nil + } + if !cs.firstByte { + if cs.trace != nil { + // TODO(bradfitz): move first response byte earlier, + // when we first read the 9 byte header, not waiting + // until all the HEADERS+CONTINUATION frames have been + // merged. This works for now. + traceFirstResponseByte(cs.trace) + } + cs.firstByte = true + } + if !cs.pastHeaders { + cs.pastHeaders = true + } else { + return rl.processTrailers(cs, f) + } + + res, err := rl.handleResponse(cs, f) + if err != nil { + if _, ok := err.(ConnectionError); ok { + return err + } + // Any other error type is a stream error. + cs.cc.writeStreamReset(f.StreamID, ErrCodeProtocol, err) + cs.resc <- resAndError{err: err} + return nil // return nil from process* funcs to keep conn alive + } + if res == nil { + // (nil, nil) special case. See handleResponse docs. + return nil + } + if res.Body != noBody { + rl.activeRes[cs.ID] = cs + } + cs.resTrailer = &res.Trailer + cs.resc <- resAndError{res: res} + return nil +} + +// may return error types nil, or ConnectionError. Any other error value +// is a StreamError of type ErrCodeProtocol. The returned error in that case +// is the detail. +// +// As a special case, handleResponse may return (nil, nil) to skip the +// frame (currently only used for 100 expect continue). This special +// case is going away after Issue 13851 is fixed. +func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFrame) (*http.Response, error) { + if f.Truncated { + return nil, errResponseHeaderListSize + } + + status := f.PseudoValue("status") + if status == "" { + return nil, errors.New("missing status pseudo header") + } + statusCode, err := strconv.Atoi(status) + if err != nil { + return nil, errors.New("malformed non-numeric status pseudo header") + } + + if statusCode == 100 { + traceGot100Continue(cs.trace) + if cs.on100 != nil { + cs.on100() // forces any write delay timer to fire + } + cs.pastHeaders = false // do it all again + return nil, nil + } + + header := make(http.Header) + res := &http.Response{ + Proto: "HTTP/2.0", + ProtoMajor: 2, + Header: header, + StatusCode: statusCode, + Status: status + " " + http.StatusText(statusCode), + } + for _, hf := range f.RegularFields() { + key := http.CanonicalHeaderKey(hf.Name) + if key == "Trailer" { + t := res.Trailer + if t == nil { + t = make(http.Header) + res.Trailer = t + } + foreachHeaderElement(hf.Value, func(v string) { + t[http.CanonicalHeaderKey(v)] = nil + }) + } else { + header[key] = append(header[key], hf.Value) + } + } + + streamEnded := f.StreamEnded() + isHead := cs.req.Method == "HEAD" + if !streamEnded || isHead { + res.ContentLength = -1 + if clens := res.Header["Content-Length"]; len(clens) == 1 { + if clen64, err := strconv.ParseInt(clens[0], 10, 64); err == nil { + res.ContentLength = clen64 + } else { + // TODO: care? unlike http/1, it won't mess up our framing, so it's + // more safe smuggling-wise to ignore. + } + } else if len(clens) > 1 { + // TODO: care? unlike http/1, it won't mess up our framing, so it's + // more safe smuggling-wise to ignore. + } + } + + if streamEnded || isHead { + res.Body = noBody + return res, nil + } + + buf := new(bytes.Buffer) // TODO(bradfitz): recycle this garbage + cs.bufPipe = pipe{b: buf} + cs.bytesRemain = res.ContentLength + res.Body = transportResponseBody{cs} + go cs.awaitRequestCancel(cs.req) + + if cs.requestedGzip && res.Header.Get("Content-Encoding") == "gzip" { + res.Header.Del("Content-Encoding") + res.Header.Del("Content-Length") + res.ContentLength = -1 + res.Body = &gzipReader{body: res.Body} + setResponseUncompressed(res) + } + return res, nil +} + +func (rl *clientConnReadLoop) processTrailers(cs *clientStream, f *MetaHeadersFrame) error { + if cs.pastTrailers { + // Too many HEADERS frames for this stream. + return ConnectionError(ErrCodeProtocol) + } + cs.pastTrailers = true + if !f.StreamEnded() { + // We expect that any headers for trailers also + // has END_STREAM. + return ConnectionError(ErrCodeProtocol) + } + if len(f.PseudoFields()) > 0 { + // No pseudo header fields are defined for trailers. + // TODO: ConnectionError might be overly harsh? Check. + return ConnectionError(ErrCodeProtocol) + } + + trailer := make(http.Header) + for _, hf := range f.RegularFields() { + key := http.CanonicalHeaderKey(hf.Name) + trailer[key] = append(trailer[key], hf.Value) + } + cs.trailer = trailer + + rl.endStream(cs) + return nil +} + +// transportResponseBody is the concrete type of Transport.RoundTrip's +// Response.Body. It is an io.ReadCloser. On Read, it reads from cs.body. +// On Close it sends RST_STREAM if EOF wasn't already seen. +type transportResponseBody struct { + cs *clientStream +} + +func (b transportResponseBody) Read(p []byte) (n int, err error) { + cs := b.cs + cc := cs.cc + + if cs.readErr != nil { + return 0, cs.readErr + } + n, err = b.cs.bufPipe.Read(p) + if cs.bytesRemain != -1 { + if int64(n) > cs.bytesRemain { + n = int(cs.bytesRemain) + if err == nil { + err = errors.New("net/http: server replied with more than declared Content-Length; truncated") + cc.writeStreamReset(cs.ID, ErrCodeProtocol, err) + } + cs.readErr = err + return int(cs.bytesRemain), err + } + cs.bytesRemain -= int64(n) + if err == io.EOF && cs.bytesRemain > 0 { + err = io.ErrUnexpectedEOF + cs.readErr = err + return n, err + } + } + if n == 0 { + // No flow control tokens to send back. + return + } + + cc.mu.Lock() + defer cc.mu.Unlock() + + var connAdd, streamAdd int32 + // Check the conn-level first, before the stream-level. + if v := cc.inflow.available(); v < transportDefaultConnFlow/2 { + connAdd = transportDefaultConnFlow - v + cc.inflow.add(connAdd) + } + if err == nil { // No need to refresh if the stream is over or failed. + // Consider any buffered body data (read from the conn but not + // consumed by the client) when computing flow control for this + // stream. + v := int(cs.inflow.available()) + cs.bufPipe.Len() + if v < transportDefaultStreamFlow-transportDefaultStreamMinRefresh { + streamAdd = int32(transportDefaultStreamFlow - v) + cs.inflow.add(streamAdd) + } + } + if connAdd != 0 || streamAdd != 0 { + cc.wmu.Lock() + defer cc.wmu.Unlock() + if connAdd != 0 { + cc.fr.WriteWindowUpdate(0, mustUint31(connAdd)) + } + if streamAdd != 0 { + cc.fr.WriteWindowUpdate(cs.ID, mustUint31(streamAdd)) + } + cc.bw.Flush() + } + return +} + +var errClosedResponseBody = errors.New("http2: response body closed") + +func (b transportResponseBody) Close() error { + cs := b.cs + cc := cs.cc + + serverSentStreamEnd := cs.bufPipe.Err() == io.EOF + unread := cs.bufPipe.Len() + + if unread > 0 || !serverSentStreamEnd { + cc.mu.Lock() + cc.wmu.Lock() + if !serverSentStreamEnd { + cc.fr.WriteRSTStream(cs.ID, ErrCodeCancel) + } + // Return connection-level flow control. + if unread > 0 { + cc.inflow.add(int32(unread)) + cc.fr.WriteWindowUpdate(0, uint32(unread)) + } + cc.bw.Flush() + cc.wmu.Unlock() + cc.mu.Unlock() + } + + cs.bufPipe.BreakWithError(errClosedResponseBody) + return nil +} + +func (rl *clientConnReadLoop) processData(f *DataFrame) error { + cc := rl.cc + cs := cc.streamByID(f.StreamID, f.StreamEnded()) + data := f.Data() + if cs == nil { + cc.mu.Lock() + neverSent := cc.nextStreamID + cc.mu.Unlock() + if f.StreamID >= neverSent { + // We never asked for this. + cc.logf("http2: Transport received unsolicited DATA frame; closing connection") + return ConnectionError(ErrCodeProtocol) + } + // We probably did ask for this, but canceled. Just ignore it. + // TODO: be stricter here? only silently ignore things which + // we canceled, but not things which were closed normally + // by the peer? Tough without accumulating too much state. + + // But at least return their flow control: + if f.Length > 0 { + cc.mu.Lock() + cc.inflow.add(int32(f.Length)) + cc.mu.Unlock() + + cc.wmu.Lock() + cc.fr.WriteWindowUpdate(0, uint32(f.Length)) + cc.bw.Flush() + cc.wmu.Unlock() + } + return nil + } + if f.Length > 0 { + if len(data) > 0 && cs.bufPipe.b == nil { + // Data frame after it's already closed? + cc.logf("http2: Transport received DATA frame for closed stream; closing connection") + return ConnectionError(ErrCodeProtocol) + } + + // Check connection-level flow control. + cc.mu.Lock() + if cs.inflow.available() >= int32(f.Length) { + cs.inflow.take(int32(f.Length)) + } else { + cc.mu.Unlock() + return ConnectionError(ErrCodeFlowControl) + } + // Return any padded flow control now, since we won't + // refund it later on body reads. + if pad := int32(f.Length) - int32(len(data)); pad > 0 { + cs.inflow.add(pad) + cc.inflow.add(pad) + cc.wmu.Lock() + cc.fr.WriteWindowUpdate(0, uint32(pad)) + cc.fr.WriteWindowUpdate(cs.ID, uint32(pad)) + cc.bw.Flush() + cc.wmu.Unlock() + } + cc.mu.Unlock() + + if len(data) > 0 { + if _, err := cs.bufPipe.Write(data); err != nil { + rl.endStreamError(cs, err) + return err + } + } + } + + if f.StreamEnded() { + rl.endStream(cs) + } + return nil +} + +var errInvalidTrailers = errors.New("http2: invalid trailers") + +func (rl *clientConnReadLoop) endStream(cs *clientStream) { + // TODO: check that any declared content-length matches, like + // server.go's (*stream).endStream method. + rl.endStreamError(cs, nil) +} + +func (rl *clientConnReadLoop) endStreamError(cs *clientStream, err error) { + var code func() + if err == nil { + err = io.EOF + code = cs.copyTrailers + } + cs.bufPipe.closeWithErrorAndCode(err, code) + delete(rl.activeRes, cs.ID) + if isConnectionCloseRequest(cs.req) { + rl.closeWhenIdle = true + } + + select { + case cs.resc <- resAndError{err: err}: + default: + } +} + +func (cs *clientStream) copyTrailers() { + for k, vv := range cs.trailer { + t := cs.resTrailer + if *t == nil { + *t = make(http.Header) + } + (*t)[k] = vv + } +} + +func (rl *clientConnReadLoop) processGoAway(f *GoAwayFrame) error { + cc := rl.cc + cc.t.connPool().MarkDead(cc) + if f.ErrCode != 0 { + // TODO: deal with GOAWAY more. particularly the error code + cc.vlogf("transport got GOAWAY with error code = %v", f.ErrCode) + } + cc.setGoAway(f) + return nil +} + +func (rl *clientConnReadLoop) processSettings(f *SettingsFrame) error { + cc := rl.cc + cc.mu.Lock() + defer cc.mu.Unlock() + + if f.IsAck() { + if cc.wantSettingsAck { + cc.wantSettingsAck = false + return nil + } + return ConnectionError(ErrCodeProtocol) + } + + err := f.ForeachSetting(func(s Setting) error { + switch s.ID { + case SettingMaxFrameSize: + cc.maxFrameSize = s.Val + case SettingMaxConcurrentStreams: + cc.maxConcurrentStreams = s.Val + case SettingInitialWindowSize: + // Values above the maximum flow-control + // window size of 2^31-1 MUST be treated as a + // connection error (Section 5.4.1) of type + // FLOW_CONTROL_ERROR. + if s.Val > math.MaxInt32 { + return ConnectionError(ErrCodeFlowControl) + } + + // Adjust flow control of currently-open + // frames by the difference of the old initial + // window size and this one. + delta := int32(s.Val) - int32(cc.initialWindowSize) + for _, cs := range cc.streams { + cs.flow.add(delta) + } + cc.cond.Broadcast() + + cc.initialWindowSize = s.Val + default: + // TODO(bradfitz): handle more settings? SETTINGS_HEADER_TABLE_SIZE probably. + cc.vlogf("Unhandled Setting: %v", s) + } + return nil + }) + if err != nil { + return err + } + + cc.wmu.Lock() + defer cc.wmu.Unlock() + + cc.fr.WriteSettingsAck() + cc.bw.Flush() + return cc.werr +} + +func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { + cc := rl.cc + cs := cc.streamByID(f.StreamID, false) + if f.StreamID != 0 && cs == nil { + return nil + } + + cc.mu.Lock() + defer cc.mu.Unlock() + + fl := &cc.flow + if cs != nil { + fl = &cs.flow + } + if !fl.add(int32(f.Increment)) { + return ConnectionError(ErrCodeFlowControl) + } + cc.cond.Broadcast() + return nil +} + +func (rl *clientConnReadLoop) processResetStream(f *RSTStreamFrame) error { + cs := rl.cc.streamByID(f.StreamID, true) + if cs == nil { + // TODO: return error if server tries to RST_STEAM an idle stream + return nil + } + select { + case <-cs.peerReset: + // Already reset. + // This is the only goroutine + // which closes this, so there + // isn't a race. + default: + err := streamError(cs.ID, f.ErrCode) + cs.resetErr = err + close(cs.peerReset) + cs.bufPipe.CloseWithError(err) + cs.cc.cond.Broadcast() // wake up checkResetOrDone via clientStream.awaitFlowControl + } + delete(rl.activeRes, cs.ID) + return nil +} + +func (rl *clientConnReadLoop) processPing(f *PingFrame) error { + if f.IsAck() { + // 6.7 PING: " An endpoint MUST NOT respond to PING frames + // containing this flag." + return nil + } + cc := rl.cc + cc.wmu.Lock() + defer cc.wmu.Unlock() + if err := cc.fr.WritePing(true, f.Data); err != nil { + return err + } + return cc.bw.Flush() +} + +func (rl *clientConnReadLoop) processPushPromise(f *PushPromiseFrame) error { + // We told the peer we don't want them. + // Spec says: + // "PUSH_PROMISE MUST NOT be sent if the SETTINGS_ENABLE_PUSH + // setting of the peer endpoint is set to 0. An endpoint that + // has set this setting and has received acknowledgement MUST + // treat the receipt of a PUSH_PROMISE frame as a connection + // error (Section 5.4.1) of type PROTOCOL_ERROR." + return ConnectionError(ErrCodeProtocol) +} + +func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, err error) { + // TODO: map err to more interesting error codes, once the + // HTTP community comes up with some. But currently for + // RST_STREAM there's no equivalent to GOAWAY frame's debug + // data, and the error codes are all pretty vague ("cancel"). + cc.wmu.Lock() + cc.fr.WriteRSTStream(streamID, code) + cc.bw.Flush() + cc.wmu.Unlock() +} + +var ( + errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit") + errPseudoTrailers = errors.New("http2: invalid pseudo header in trailers") +) + +func (cc *ClientConn) logf(format string, args ...interface{}) { + cc.t.logf(format, args...) +} + +func (cc *ClientConn) vlogf(format string, args ...interface{}) { + cc.t.vlogf(format, args...) +} + +func (t *Transport) vlogf(format string, args ...interface{}) { + if VerboseLogs { + t.logf(format, args...) + } +} + +func (t *Transport) logf(format string, args ...interface{}) { + log.Printf(format, args...) +} + +var noBody io.ReadCloser = ioutil.NopCloser(bytes.NewReader(nil)) + +func strSliceContains(ss []string, s string) bool { + for _, v := range ss { + if v == s { + return true + } + } + return false +} + +type erringRoundTripper struct{ err error } + +func (rt erringRoundTripper) RoundTrip(*http.Request) (*http.Response, error) { return nil, rt.err } + +// gzipReader wraps a response body so it can lazily +// call gzip.NewReader on the first call to Read +type gzipReader struct { + body io.ReadCloser // underlying Response.Body + zr *gzip.Reader // lazily-initialized gzip reader + zerr error // sticky error +} + +func (gz *gzipReader) Read(p []byte) (n int, err error) { + if gz.zerr != nil { + return 0, gz.zerr + } + if gz.zr == nil { + gz.zr, err = gzip.NewReader(gz.body) + if err != nil { + gz.zerr = err + return 0, err + } + } + return gz.zr.Read(p) +} + +func (gz *gzipReader) Close() error { + return gz.body.Close() +} + +type errorReader struct{ err error } + +func (r errorReader) Read(p []byte) (int, error) { return 0, r.err } + +// bodyWriterState encapsulates various state around the Transport's writing +// of the request body, particularly regarding doing delayed writes of the body +// when the request contains "Expect: 100-continue". +type bodyWriterState struct { + cs *clientStream + timer *time.Timer // if non-nil, we're doing a delayed write + fnonce *sync.Once // to call fn with + fn func() // the code to run in the goroutine, writing the body + resc chan error // result of fn's execution + delay time.Duration // how long we should delay a delayed write for +} + +func (t *Transport) getBodyWriterState(cs *clientStream, body io.Reader) (s bodyWriterState) { + s.cs = cs + if body == nil { + return + } + resc := make(chan error, 1) + s.resc = resc + s.fn = func() { + resc <- cs.writeRequestBody(body, cs.req.Body) + } + s.delay = t.expectContinueTimeout() + if s.delay == 0 || + !httplex.HeaderValuesContainsToken( + cs.req.Header["Expect"], + "100-continue") { + return + } + s.fnonce = new(sync.Once) + + // Arm the timer with a very large duration, which we'll + // intentionally lower later. It has to be large now because + // we need a handle to it before writing the headers, but the + // s.delay value is defined to not start until after the + // request headers were written. + const hugeDuration = 365 * 24 * time.Hour + s.timer = time.AfterFunc(hugeDuration, func() { + s.fnonce.Do(s.fn) + }) + return +} + +func (s bodyWriterState) cancel() { + if s.timer != nil { + s.timer.Stop() + } +} + +func (s bodyWriterState) on100() { + if s.timer == nil { + // If we didn't do a delayed write, ignore the server's + // bogus 100 continue response. + return + } + s.timer.Stop() + go func() { s.fnonce.Do(s.fn) }() +} + +// scheduleBodyWrite starts writing the body, either immediately (in +// the common case) or after the delay timeout. It should not be +// called until after the headers have been written. +func (s bodyWriterState) scheduleBodyWrite() { + if s.timer == nil { + // We're not doing a delayed write (see + // getBodyWriterState), so just start the writing + // goroutine immediately. + go s.fn() + return + } + traceWait100Continue(s.cs.trace) + if s.timer.Stop() { + s.timer.Reset(s.delay) + } +} + +// isConnectionCloseRequest reports whether req should use its own +// connection for a single request and then close the connection. +func isConnectionCloseRequest(req *http.Request) bool { + return req.Close || httplex.HeaderValuesContainsToken(req.Header["Connection"], "close") +} diff --git a/vendor/golang.org/x/net/http2/write.go b/vendor/golang.org/x/net/http2/write.go new file mode 100644 index 00000000..27ef0dd4 --- /dev/null +++ b/vendor/golang.org/x/net/http2/write.go @@ -0,0 +1,264 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package http2 + +import ( + "bytes" + "fmt" + "log" + "net/http" + "time" + + "golang.org/x/net/http2/hpack" + "golang.org/x/net/lex/httplex" +) + +// writeFramer is implemented by any type that is used to write frames. +type writeFramer interface { + writeFrame(writeContext) error +} + +// writeContext is the interface needed by the various frame writer +// types below. All the writeFrame methods below are scheduled via the +// frame writing scheduler (see writeScheduler in writesched.go). +// +// This interface is implemented by *serverConn. +// +// TODO: decide whether to a) use this in the client code (which didn't +// end up using this yet, because it has a simpler design, not +// currently implementing priorities), or b) delete this and +// make the server code a bit more concrete. +type writeContext interface { + Framer() *Framer + Flush() error + CloseConn() error + // HeaderEncoder returns an HPACK encoder that writes to the + // returned buffer. + HeaderEncoder() (*hpack.Encoder, *bytes.Buffer) +} + +// endsStream reports whether the given frame writer w will locally +// close the stream. +func endsStream(w writeFramer) bool { + switch v := w.(type) { + case *writeData: + return v.endStream + case *writeResHeaders: + return v.endStream + case nil: + // This can only happen if the caller reuses w after it's + // been intentionally nil'ed out to prevent use. Keep this + // here to catch future refactoring breaking it. + panic("endsStream called on nil writeFramer") + } + return false +} + +type flushFrameWriter struct{} + +func (flushFrameWriter) writeFrame(ctx writeContext) error { + return ctx.Flush() +} + +type writeSettings []Setting + +func (s writeSettings) writeFrame(ctx writeContext) error { + return ctx.Framer().WriteSettings([]Setting(s)...) +} + +type writeGoAway struct { + maxStreamID uint32 + code ErrCode +} + +func (p *writeGoAway) writeFrame(ctx writeContext) error { + err := ctx.Framer().WriteGoAway(p.maxStreamID, p.code, nil) + if p.code != 0 { + ctx.Flush() // ignore error: we're hanging up on them anyway + time.Sleep(50 * time.Millisecond) + ctx.CloseConn() + } + return err +} + +type writeData struct { + streamID uint32 + p []byte + endStream bool +} + +func (w *writeData) String() string { + return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream) +} + +func (w *writeData) writeFrame(ctx writeContext) error { + return ctx.Framer().WriteData(w.streamID, w.endStream, w.p) +} + +// handlerPanicRST is the message sent from handler goroutines when +// the handler panics. +type handlerPanicRST struct { + StreamID uint32 +} + +func (hp handlerPanicRST) writeFrame(ctx writeContext) error { + return ctx.Framer().WriteRSTStream(hp.StreamID, ErrCodeInternal) +} + +func (se StreamError) writeFrame(ctx writeContext) error { + return ctx.Framer().WriteRSTStream(se.StreamID, se.Code) +} + +type writePingAck struct{ pf *PingFrame } + +func (w writePingAck) writeFrame(ctx writeContext) error { + return ctx.Framer().WritePing(true, w.pf.Data) +} + +type writeSettingsAck struct{} + +func (writeSettingsAck) writeFrame(ctx writeContext) error { + return ctx.Framer().WriteSettingsAck() +} + +// writeResHeaders is a request to write a HEADERS and 0+ CONTINUATION frames +// for HTTP response headers or trailers from a server handler. +type writeResHeaders struct { + streamID uint32 + httpResCode int // 0 means no ":status" line + h http.Header // may be nil + trailers []string // if non-nil, which keys of h to write. nil means all. + endStream bool + + date string + contentType string + contentLength string +} + +func encKV(enc *hpack.Encoder, k, v string) { + if VerboseLogs { + log.Printf("http2: server encoding header %q = %q", k, v) + } + enc.WriteField(hpack.HeaderField{Name: k, Value: v}) +} + +func (w *writeResHeaders) writeFrame(ctx writeContext) error { + enc, buf := ctx.HeaderEncoder() + buf.Reset() + + if w.httpResCode != 0 { + encKV(enc, ":status", httpCodeString(w.httpResCode)) + } + + encodeHeaders(enc, w.h, w.trailers) + + if w.contentType != "" { + encKV(enc, "content-type", w.contentType) + } + if w.contentLength != "" { + encKV(enc, "content-length", w.contentLength) + } + if w.date != "" { + encKV(enc, "date", w.date) + } + + headerBlock := buf.Bytes() + if len(headerBlock) == 0 && w.trailers == nil { + panic("unexpected empty hpack") + } + + // For now we're lazy and just pick the minimum MAX_FRAME_SIZE + // that all peers must support (16KB). Later we could care + // more and send larger frames if the peer advertised it, but + // there's little point. Most headers are small anyway (so we + // generally won't have CONTINUATION frames), and extra frames + // only waste 9 bytes anyway. + const maxFrameSize = 16384 + + first := true + for len(headerBlock) > 0 { + frag := headerBlock + if len(frag) > maxFrameSize { + frag = frag[:maxFrameSize] + } + headerBlock = headerBlock[len(frag):] + endHeaders := len(headerBlock) == 0 + var err error + if first { + first = false + err = ctx.Framer().WriteHeaders(HeadersFrameParam{ + StreamID: w.streamID, + BlockFragment: frag, + EndStream: w.endStream, + EndHeaders: endHeaders, + }) + } else { + err = ctx.Framer().WriteContinuation(w.streamID, endHeaders, frag) + } + if err != nil { + return err + } + } + return nil +} + +type write100ContinueHeadersFrame struct { + streamID uint32 +} + +func (w write100ContinueHeadersFrame) writeFrame(ctx writeContext) error { + enc, buf := ctx.HeaderEncoder() + buf.Reset() + encKV(enc, ":status", "100") + return ctx.Framer().WriteHeaders(HeadersFrameParam{ + StreamID: w.streamID, + BlockFragment: buf.Bytes(), + EndStream: false, + EndHeaders: true, + }) +} + +type writeWindowUpdate struct { + streamID uint32 // or 0 for conn-level + n uint32 +} + +func (wu writeWindowUpdate) writeFrame(ctx writeContext) error { + return ctx.Framer().WriteWindowUpdate(wu.streamID, wu.n) +} + +func encodeHeaders(enc *hpack.Encoder, h http.Header, keys []string) { + if keys == nil { + sorter := sorterPool.Get().(*sorter) + // Using defer here, since the returned keys from the + // sorter.Keys method is only valid until the sorter + // is returned: + defer sorterPool.Put(sorter) + keys = sorter.Keys(h) + } + for _, k := range keys { + vv := h[k] + k = lowerHeader(k) + if !validWireHeaderFieldName(k) { + // Skip it as backup paranoia. Per + // golang.org/issue/14048, these should + // already be rejected at a higher level. + continue + } + isTE := k == "transfer-encoding" + for _, v := range vv { + if !httplex.ValidHeaderFieldValue(v) { + // TODO: return an error? golang.org/issue/14048 + // For now just omit it. + continue + } + // TODO: more of "8.1.2.2 Connection-Specific Header Fields" + if isTE && v != "trailers" { + continue + } + encKV(enc, k, v) + } + } +} diff --git a/vendor/golang.org/x/net/http2/writesched.go b/vendor/golang.org/x/net/http2/writesched.go new file mode 100644 index 00000000..c24316ce --- /dev/null +++ b/vendor/golang.org/x/net/http2/writesched.go @@ -0,0 +1,283 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package http2 + +import "fmt" + +// frameWriteMsg is a request to write a frame. +type frameWriteMsg struct { + // write is the interface value that does the writing, once the + // writeScheduler (below) has decided to select this frame + // to write. The write functions are all defined in write.go. + write writeFramer + + stream *stream // used for prioritization. nil for non-stream frames. + + // done, if non-nil, must be a buffered channel with space for + // 1 message and is sent the return value from write (or an + // earlier error) when the frame has been written. + done chan error +} + +// for debugging only: +func (wm frameWriteMsg) String() string { + var streamID uint32 + if wm.stream != nil { + streamID = wm.stream.id + } + var des string + if s, ok := wm.write.(fmt.Stringer); ok { + des = s.String() + } else { + des = fmt.Sprintf("%T", wm.write) + } + return fmt.Sprintf("[frameWriteMsg stream=%d, ch=%v, type: %v]", streamID, wm.done != nil, des) +} + +// writeScheduler tracks pending frames to write, priorities, and decides +// the next one to use. It is not thread-safe. +type writeScheduler struct { + // zero are frames not associated with a specific stream. + // They're sent before any stream-specific freams. + zero writeQueue + + // maxFrameSize is the maximum size of a DATA frame + // we'll write. Must be non-zero and between 16K-16M. + maxFrameSize uint32 + + // sq contains the stream-specific queues, keyed by stream ID. + // when a stream is idle, it's deleted from the map. + sq map[uint32]*writeQueue + + // canSend is a slice of memory that's reused between frame + // scheduling decisions to hold the list of writeQueues (from sq) + // which have enough flow control data to send. After canSend is + // built, the best is selected. + canSend []*writeQueue + + // pool of empty queues for reuse. + queuePool []*writeQueue +} + +func (ws *writeScheduler) putEmptyQueue(q *writeQueue) { + if len(q.s) != 0 { + panic("queue must be empty") + } + ws.queuePool = append(ws.queuePool, q) +} + +func (ws *writeScheduler) getEmptyQueue() *writeQueue { + ln := len(ws.queuePool) + if ln == 0 { + return new(writeQueue) + } + q := ws.queuePool[ln-1] + ws.queuePool = ws.queuePool[:ln-1] + return q +} + +func (ws *writeScheduler) empty() bool { return ws.zero.empty() && len(ws.sq) == 0 } + +func (ws *writeScheduler) add(wm frameWriteMsg) { + st := wm.stream + if st == nil { + ws.zero.push(wm) + } else { + ws.streamQueue(st.id).push(wm) + } +} + +func (ws *writeScheduler) streamQueue(streamID uint32) *writeQueue { + if q, ok := ws.sq[streamID]; ok { + return q + } + if ws.sq == nil { + ws.sq = make(map[uint32]*writeQueue) + } + q := ws.getEmptyQueue() + ws.sq[streamID] = q + return q +} + +// take returns the most important frame to write and removes it from the scheduler. +// It is illegal to call this if the scheduler is empty or if there are no connection-level +// flow control bytes available. +func (ws *writeScheduler) take() (wm frameWriteMsg, ok bool) { + if ws.maxFrameSize == 0 { + panic("internal error: ws.maxFrameSize not initialized or invalid") + } + + // If there any frames not associated with streams, prefer those first. + // These are usually SETTINGS, etc. + if !ws.zero.empty() { + return ws.zero.shift(), true + } + if len(ws.sq) == 0 { + return + } + + // Next, prioritize frames on streams that aren't DATA frames (no cost). + for id, q := range ws.sq { + if q.firstIsNoCost() { + return ws.takeFrom(id, q) + } + } + + // Now, all that remains are DATA frames with non-zero bytes to + // send. So pick the best one. + if len(ws.canSend) != 0 { + panic("should be empty") + } + for _, q := range ws.sq { + if n := ws.streamWritableBytes(q); n > 0 { + ws.canSend = append(ws.canSend, q) + } + } + if len(ws.canSend) == 0 { + return + } + defer ws.zeroCanSend() + + // TODO: find the best queue + q := ws.canSend[0] + + return ws.takeFrom(q.streamID(), q) +} + +// zeroCanSend is defered from take. +func (ws *writeScheduler) zeroCanSend() { + for i := range ws.canSend { + ws.canSend[i] = nil + } + ws.canSend = ws.canSend[:0] +} + +// streamWritableBytes returns the number of DATA bytes we could write +// from the given queue's stream, if this stream/queue were +// selected. It is an error to call this if q's head isn't a +// *writeData. +func (ws *writeScheduler) streamWritableBytes(q *writeQueue) int32 { + wm := q.head() + ret := wm.stream.flow.available() // max we can write + if ret == 0 { + return 0 + } + if int32(ws.maxFrameSize) < ret { + ret = int32(ws.maxFrameSize) + } + if ret == 0 { + panic("internal error: ws.maxFrameSize not initialized or invalid") + } + wd := wm.write.(*writeData) + if len(wd.p) < int(ret) { + ret = int32(len(wd.p)) + } + return ret +} + +func (ws *writeScheduler) takeFrom(id uint32, q *writeQueue) (wm frameWriteMsg, ok bool) { + wm = q.head() + // If the first item in this queue costs flow control tokens + // and we don't have enough, write as much as we can. + if wd, ok := wm.write.(*writeData); ok && len(wd.p) > 0 { + allowed := wm.stream.flow.available() // max we can write + if allowed == 0 { + // No quota available. Caller can try the next stream. + return frameWriteMsg{}, false + } + if int32(ws.maxFrameSize) < allowed { + allowed = int32(ws.maxFrameSize) + } + // TODO: further restrict the allowed size, because even if + // the peer says it's okay to write 16MB data frames, we might + // want to write smaller ones to properly weight competing + // streams' priorities. + + if len(wd.p) > int(allowed) { + wm.stream.flow.take(allowed) + chunk := wd.p[:allowed] + wd.p = wd.p[allowed:] + // Make up a new write message of a valid size, rather + // than shifting one off the queue. + return frameWriteMsg{ + stream: wm.stream, + write: &writeData{ + streamID: wd.streamID, + p: chunk, + // even if the original had endStream set, there + // arebytes remaining because len(wd.p) > allowed, + // so we know endStream is false: + endStream: false, + }, + // our caller is blocking on the final DATA frame, not + // these intermediates, so no need to wait: + done: nil, + }, true + } + wm.stream.flow.take(int32(len(wd.p))) + } + + q.shift() + if q.empty() { + ws.putEmptyQueue(q) + delete(ws.sq, id) + } + return wm, true +} + +func (ws *writeScheduler) forgetStream(id uint32) { + q, ok := ws.sq[id] + if !ok { + return + } + delete(ws.sq, id) + + // But keep it for others later. + for i := range q.s { + q.s[i] = frameWriteMsg{} + } + q.s = q.s[:0] + ws.putEmptyQueue(q) +} + +type writeQueue struct { + s []frameWriteMsg +} + +// streamID returns the stream ID for a non-empty stream-specific queue. +func (q *writeQueue) streamID() uint32 { return q.s[0].stream.id } + +func (q *writeQueue) empty() bool { return len(q.s) == 0 } + +func (q *writeQueue) push(wm frameWriteMsg) { + q.s = append(q.s, wm) +} + +// head returns the next item that would be removed by shift. +func (q *writeQueue) head() frameWriteMsg { + if len(q.s) == 0 { + panic("invalid use of queue") + } + return q.s[0] +} + +func (q *writeQueue) shift() frameWriteMsg { + if len(q.s) == 0 { + panic("invalid use of queue") + } + wm := q.s[0] + // TODO: less copy-happy queue. + copy(q.s, q.s[1:]) + q.s[len(q.s)-1] = frameWriteMsg{} + q.s = q.s[:len(q.s)-1] + return wm +} + +func (q *writeQueue) firstIsNoCost() bool { + if df, ok := q.s[0].write.(*writeData); ok { + return len(df.p) == 0 + } + return true +} diff --git a/vendor/golang.org/x/net/internal/timeseries/timeseries.go b/vendor/golang.org/x/net/internal/timeseries/timeseries.go new file mode 100644 index 00000000..1119f344 --- /dev/null +++ b/vendor/golang.org/x/net/internal/timeseries/timeseries.go @@ -0,0 +1,525 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package timeseries implements a time series structure for stats collection. +package timeseries // import "golang.org/x/net/internal/timeseries" + +import ( + "fmt" + "log" + "time" +) + +const ( + timeSeriesNumBuckets = 64 + minuteHourSeriesNumBuckets = 60 +) + +var timeSeriesResolutions = []time.Duration{ + 1 * time.Second, + 10 * time.Second, + 1 * time.Minute, + 10 * time.Minute, + 1 * time.Hour, + 6 * time.Hour, + 24 * time.Hour, // 1 day + 7 * 24 * time.Hour, // 1 week + 4 * 7 * 24 * time.Hour, // 4 weeks + 16 * 7 * 24 * time.Hour, // 16 weeks +} + +var minuteHourSeriesResolutions = []time.Duration{ + 1 * time.Second, + 1 * time.Minute, +} + +// An Observable is a kind of data that can be aggregated in a time series. +type Observable interface { + Multiply(ratio float64) // Multiplies the data in self by a given ratio + Add(other Observable) // Adds the data from a different observation to self + Clear() // Clears the observation so it can be reused. + CopyFrom(other Observable) // Copies the contents of a given observation to self +} + +// Float attaches the methods of Observable to a float64. +type Float float64 + +// NewFloat returns a Float. +func NewFloat() Observable { + f := Float(0) + return &f +} + +// String returns the float as a string. +func (f *Float) String() string { return fmt.Sprintf("%g", f.Value()) } + +// Value returns the float's value. +func (f *Float) Value() float64 { return float64(*f) } + +func (f *Float) Multiply(ratio float64) { *f *= Float(ratio) } + +func (f *Float) Add(other Observable) { + o := other.(*Float) + *f += *o +} + +func (f *Float) Clear() { *f = 0 } + +func (f *Float) CopyFrom(other Observable) { + o := other.(*Float) + *f = *o +} + +// A Clock tells the current time. +type Clock interface { + Time() time.Time +} + +type defaultClock int + +var defaultClockInstance defaultClock + +func (defaultClock) Time() time.Time { return time.Now() } + +// Information kept per level. Each level consists of a circular list of +// observations. The start of the level may be derived from end and the +// len(buckets) * sizeInMillis. +type tsLevel struct { + oldest int // index to oldest bucketed Observable + newest int // index to newest bucketed Observable + end time.Time // end timestamp for this level + size time.Duration // duration of the bucketed Observable + buckets []Observable // collections of observations + provider func() Observable // used for creating new Observable +} + +func (l *tsLevel) Clear() { + l.oldest = 0 + l.newest = len(l.buckets) - 1 + l.end = time.Time{} + for i := range l.buckets { + if l.buckets[i] != nil { + l.buckets[i].Clear() + l.buckets[i] = nil + } + } +} + +func (l *tsLevel) InitLevel(size time.Duration, numBuckets int, f func() Observable) { + l.size = size + l.provider = f + l.buckets = make([]Observable, numBuckets) +} + +// Keeps a sequence of levels. Each level is responsible for storing data at +// a given resolution. For example, the first level stores data at a one +// minute resolution while the second level stores data at a one hour +// resolution. + +// Each level is represented by a sequence of buckets. Each bucket spans an +// interval equal to the resolution of the level. New observations are added +// to the last bucket. +type timeSeries struct { + provider func() Observable // make more Observable + numBuckets int // number of buckets in each level + levels []*tsLevel // levels of bucketed Observable + lastAdd time.Time // time of last Observable tracked + total Observable // convenient aggregation of all Observable + clock Clock // Clock for getting current time + pending Observable // observations not yet bucketed + pendingTime time.Time // what time are we keeping in pending + dirty bool // if there are pending observations +} + +// init initializes a level according to the supplied criteria. +func (ts *timeSeries) init(resolutions []time.Duration, f func() Observable, numBuckets int, clock Clock) { + ts.provider = f + ts.numBuckets = numBuckets + ts.clock = clock + ts.levels = make([]*tsLevel, len(resolutions)) + + for i := range resolutions { + if i > 0 && resolutions[i-1] >= resolutions[i] { + log.Print("timeseries: resolutions must be monotonically increasing") + break + } + newLevel := new(tsLevel) + newLevel.InitLevel(resolutions[i], ts.numBuckets, ts.provider) + ts.levels[i] = newLevel + } + + ts.Clear() +} + +// Clear removes all observations from the time series. +func (ts *timeSeries) Clear() { + ts.lastAdd = time.Time{} + ts.total = ts.resetObservation(ts.total) + ts.pending = ts.resetObservation(ts.pending) + ts.pendingTime = time.Time{} + ts.dirty = false + + for i := range ts.levels { + ts.levels[i].Clear() + } +} + +// Add records an observation at the current time. +func (ts *timeSeries) Add(observation Observable) { + ts.AddWithTime(observation, ts.clock.Time()) +} + +// AddWithTime records an observation at the specified time. +func (ts *timeSeries) AddWithTime(observation Observable, t time.Time) { + + smallBucketDuration := ts.levels[0].size + + if t.After(ts.lastAdd) { + ts.lastAdd = t + } + + if t.After(ts.pendingTime) { + ts.advance(t) + ts.mergePendingUpdates() + ts.pendingTime = ts.levels[0].end + ts.pending.CopyFrom(observation) + ts.dirty = true + } else if t.After(ts.pendingTime.Add(-1 * smallBucketDuration)) { + // The observation is close enough to go into the pending bucket. + // This compensates for clock skewing and small scheduling delays + // by letting the update stay in the fast path. + ts.pending.Add(observation) + ts.dirty = true + } else { + ts.mergeValue(observation, t) + } +} + +// mergeValue inserts the observation at the specified time in the past into all levels. +func (ts *timeSeries) mergeValue(observation Observable, t time.Time) { + for _, level := range ts.levels { + index := (ts.numBuckets - 1) - int(level.end.Sub(t)/level.size) + if 0 <= index && index < ts.numBuckets { + bucketNumber := (level.oldest + index) % ts.numBuckets + if level.buckets[bucketNumber] == nil { + level.buckets[bucketNumber] = level.provider() + } + level.buckets[bucketNumber].Add(observation) + } + } + ts.total.Add(observation) +} + +// mergePendingUpdates applies the pending updates into all levels. +func (ts *timeSeries) mergePendingUpdates() { + if ts.dirty { + ts.mergeValue(ts.pending, ts.pendingTime) + ts.pending = ts.resetObservation(ts.pending) + ts.dirty = false + } +} + +// advance cycles the buckets at each level until the latest bucket in +// each level can hold the time specified. +func (ts *timeSeries) advance(t time.Time) { + if !t.After(ts.levels[0].end) { + return + } + for i := 0; i < len(ts.levels); i++ { + level := ts.levels[i] + if !level.end.Before(t) { + break + } + + // If the time is sufficiently far, just clear the level and advance + // directly. + if !t.Before(level.end.Add(level.size * time.Duration(ts.numBuckets))) { + for _, b := range level.buckets { + ts.resetObservation(b) + } + level.end = time.Unix(0, (t.UnixNano()/level.size.Nanoseconds())*level.size.Nanoseconds()) + } + + for t.After(level.end) { + level.end = level.end.Add(level.size) + level.newest = level.oldest + level.oldest = (level.oldest + 1) % ts.numBuckets + ts.resetObservation(level.buckets[level.newest]) + } + + t = level.end + } +} + +// Latest returns the sum of the num latest buckets from the level. +func (ts *timeSeries) Latest(level, num int) Observable { + now := ts.clock.Time() + if ts.levels[0].end.Before(now) { + ts.advance(now) + } + + ts.mergePendingUpdates() + + result := ts.provider() + l := ts.levels[level] + index := l.newest + + for i := 0; i < num; i++ { + if l.buckets[index] != nil { + result.Add(l.buckets[index]) + } + if index == 0 { + index = ts.numBuckets + } + index-- + } + + return result +} + +// LatestBuckets returns a copy of the num latest buckets from level. +func (ts *timeSeries) LatestBuckets(level, num int) []Observable { + if level < 0 || level > len(ts.levels) { + log.Print("timeseries: bad level argument: ", level) + return nil + } + if num < 0 || num >= ts.numBuckets { + log.Print("timeseries: bad num argument: ", num) + return nil + } + + results := make([]Observable, num) + now := ts.clock.Time() + if ts.levels[0].end.Before(now) { + ts.advance(now) + } + + ts.mergePendingUpdates() + + l := ts.levels[level] + index := l.newest + + for i := 0; i < num; i++ { + result := ts.provider() + results[i] = result + if l.buckets[index] != nil { + result.CopyFrom(l.buckets[index]) + } + + if index == 0 { + index = ts.numBuckets + } + index -= 1 + } + return results +} + +// ScaleBy updates observations by scaling by factor. +func (ts *timeSeries) ScaleBy(factor float64) { + for _, l := range ts.levels { + for i := 0; i < ts.numBuckets; i++ { + l.buckets[i].Multiply(factor) + } + } + + ts.total.Multiply(factor) + ts.pending.Multiply(factor) +} + +// Range returns the sum of observations added over the specified time range. +// If start or finish times don't fall on bucket boundaries of the same +// level, then return values are approximate answers. +func (ts *timeSeries) Range(start, finish time.Time) Observable { + return ts.ComputeRange(start, finish, 1)[0] +} + +// Recent returns the sum of observations from the last delta. +func (ts *timeSeries) Recent(delta time.Duration) Observable { + now := ts.clock.Time() + return ts.Range(now.Add(-delta), now) +} + +// Total returns the total of all observations. +func (ts *timeSeries) Total() Observable { + ts.mergePendingUpdates() + return ts.total +} + +// ComputeRange computes a specified number of values into a slice using +// the observations recorded over the specified time period. The return +// values are approximate if the start or finish times don't fall on the +// bucket boundaries at the same level or if the number of buckets spanning +// the range is not an integral multiple of num. +func (ts *timeSeries) ComputeRange(start, finish time.Time, num int) []Observable { + if start.After(finish) { + log.Printf("timeseries: start > finish, %v>%v", start, finish) + return nil + } + + if num < 0 { + log.Printf("timeseries: num < 0, %v", num) + return nil + } + + results := make([]Observable, num) + + for _, l := range ts.levels { + if !start.Before(l.end.Add(-l.size * time.Duration(ts.numBuckets))) { + ts.extract(l, start, finish, num, results) + return results + } + } + + // Failed to find a level that covers the desired range. So just + // extract from the last level, even if it doesn't cover the entire + // desired range. + ts.extract(ts.levels[len(ts.levels)-1], start, finish, num, results) + + return results +} + +// RecentList returns the specified number of values in slice over the most +// recent time period of the specified range. +func (ts *timeSeries) RecentList(delta time.Duration, num int) []Observable { + if delta < 0 { + return nil + } + now := ts.clock.Time() + return ts.ComputeRange(now.Add(-delta), now, num) +} + +// extract returns a slice of specified number of observations from a given +// level over a given range. +func (ts *timeSeries) extract(l *tsLevel, start, finish time.Time, num int, results []Observable) { + ts.mergePendingUpdates() + + srcInterval := l.size + dstInterval := finish.Sub(start) / time.Duration(num) + dstStart := start + srcStart := l.end.Add(-srcInterval * time.Duration(ts.numBuckets)) + + srcIndex := 0 + + // Where should scanning start? + if dstStart.After(srcStart) { + advance := dstStart.Sub(srcStart) / srcInterval + srcIndex += int(advance) + srcStart = srcStart.Add(advance * srcInterval) + } + + // The i'th value is computed as show below. + // interval = (finish/start)/num + // i'th value = sum of observation in range + // [ start + i * interval, + // start + (i + 1) * interval ) + for i := 0; i < num; i++ { + results[i] = ts.resetObservation(results[i]) + dstEnd := dstStart.Add(dstInterval) + for srcIndex < ts.numBuckets && srcStart.Before(dstEnd) { + srcEnd := srcStart.Add(srcInterval) + if srcEnd.After(ts.lastAdd) { + srcEnd = ts.lastAdd + } + + if !srcEnd.Before(dstStart) { + srcValue := l.buckets[(srcIndex+l.oldest)%ts.numBuckets] + if !srcStart.Before(dstStart) && !srcEnd.After(dstEnd) { + // dst completely contains src. + if srcValue != nil { + results[i].Add(srcValue) + } + } else { + // dst partially overlaps src. + overlapStart := maxTime(srcStart, dstStart) + overlapEnd := minTime(srcEnd, dstEnd) + base := srcEnd.Sub(srcStart) + fraction := overlapEnd.Sub(overlapStart).Seconds() / base.Seconds() + + used := ts.provider() + if srcValue != nil { + used.CopyFrom(srcValue) + } + used.Multiply(fraction) + results[i].Add(used) + } + + if srcEnd.After(dstEnd) { + break + } + } + srcIndex++ + srcStart = srcStart.Add(srcInterval) + } + dstStart = dstStart.Add(dstInterval) + } +} + +// resetObservation clears the content so the struct may be reused. +func (ts *timeSeries) resetObservation(observation Observable) Observable { + if observation == nil { + observation = ts.provider() + } else { + observation.Clear() + } + return observation +} + +// TimeSeries tracks data at granularities from 1 second to 16 weeks. +type TimeSeries struct { + timeSeries +} + +// NewTimeSeries creates a new TimeSeries using the function provided for creating new Observable. +func NewTimeSeries(f func() Observable) *TimeSeries { + return NewTimeSeriesWithClock(f, defaultClockInstance) +} + +// NewTimeSeriesWithClock creates a new TimeSeries using the function provided for creating new Observable and the clock for +// assigning timestamps. +func NewTimeSeriesWithClock(f func() Observable, clock Clock) *TimeSeries { + ts := new(TimeSeries) + ts.timeSeries.init(timeSeriesResolutions, f, timeSeriesNumBuckets, clock) + return ts +} + +// MinuteHourSeries tracks data at granularities of 1 minute and 1 hour. +type MinuteHourSeries struct { + timeSeries +} + +// NewMinuteHourSeries creates a new MinuteHourSeries using the function provided for creating new Observable. +func NewMinuteHourSeries(f func() Observable) *MinuteHourSeries { + return NewMinuteHourSeriesWithClock(f, defaultClockInstance) +} + +// NewMinuteHourSeriesWithClock creates a new MinuteHourSeries using the function provided for creating new Observable and the clock for +// assigning timestamps. +func NewMinuteHourSeriesWithClock(f func() Observable, clock Clock) *MinuteHourSeries { + ts := new(MinuteHourSeries) + ts.timeSeries.init(minuteHourSeriesResolutions, f, + minuteHourSeriesNumBuckets, clock) + return ts +} + +func (ts *MinuteHourSeries) Minute() Observable { + return ts.timeSeries.Latest(0, 60) +} + +func (ts *MinuteHourSeries) Hour() Observable { + return ts.timeSeries.Latest(1, 60) +} + +func minTime(a, b time.Time) time.Time { + if a.Before(b) { + return a + } + return b +} + +func maxTime(a, b time.Time) time.Time { + if a.After(b) { + return a + } + return b +} diff --git a/vendor/golang.org/x/net/lex/httplex/httplex.go b/vendor/golang.org/x/net/lex/httplex/httplex.go new file mode 100644 index 00000000..bd0ec24f --- /dev/null +++ b/vendor/golang.org/x/net/lex/httplex/httplex.go @@ -0,0 +1,312 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package httplex contains rules around lexical matters of various +// HTTP-related specifications. +// +// This package is shared by the standard library (which vendors it) +// and x/net/http2. It comes with no API stability promise. +package httplex + +import ( + "strings" + "unicode/utf8" +) + +var isTokenTable = [127]bool{ + '!': true, + '#': true, + '$': true, + '%': true, + '&': true, + '\'': true, + '*': true, + '+': true, + '-': true, + '.': true, + '0': true, + '1': true, + '2': true, + '3': true, + '4': true, + '5': true, + '6': true, + '7': true, + '8': true, + '9': true, + 'A': true, + 'B': true, + 'C': true, + 'D': true, + 'E': true, + 'F': true, + 'G': true, + 'H': true, + 'I': true, + 'J': true, + 'K': true, + 'L': true, + 'M': true, + 'N': true, + 'O': true, + 'P': true, + 'Q': true, + 'R': true, + 'S': true, + 'T': true, + 'U': true, + 'W': true, + 'V': true, + 'X': true, + 'Y': true, + 'Z': true, + '^': true, + '_': true, + '`': true, + 'a': true, + 'b': true, + 'c': true, + 'd': true, + 'e': true, + 'f': true, + 'g': true, + 'h': true, + 'i': true, + 'j': true, + 'k': true, + 'l': true, + 'm': true, + 'n': true, + 'o': true, + 'p': true, + 'q': true, + 'r': true, + 's': true, + 't': true, + 'u': true, + 'v': true, + 'w': true, + 'x': true, + 'y': true, + 'z': true, + '|': true, + '~': true, +} + +func IsTokenRune(r rune) bool { + i := int(r) + return i < len(isTokenTable) && isTokenTable[i] +} + +func isNotToken(r rune) bool { + return !IsTokenRune(r) +} + +// HeaderValuesContainsToken reports whether any string in values +// contains the provided token, ASCII case-insensitively. +func HeaderValuesContainsToken(values []string, token string) bool { + for _, v := range values { + if headerValueContainsToken(v, token) { + return true + } + } + return false +} + +// isOWS reports whether b is an optional whitespace byte, as defined +// by RFC 7230 section 3.2.3. +func isOWS(b byte) bool { return b == ' ' || b == '\t' } + +// trimOWS returns x with all optional whitespace removes from the +// beginning and end. +func trimOWS(x string) string { + // TODO: consider using strings.Trim(x, " \t") instead, + // if and when it's fast enough. See issue 10292. + // But this ASCII-only code will probably always beat UTF-8 + // aware code. + for len(x) > 0 && isOWS(x[0]) { + x = x[1:] + } + for len(x) > 0 && isOWS(x[len(x)-1]) { + x = x[:len(x)-1] + } + return x +} + +// headerValueContainsToken reports whether v (assumed to be a +// 0#element, in the ABNF extension described in RFC 7230 section 7) +// contains token amongst its comma-separated tokens, ASCII +// case-insensitively. +func headerValueContainsToken(v string, token string) bool { + v = trimOWS(v) + if comma := strings.IndexByte(v, ','); comma != -1 { + return tokenEqual(trimOWS(v[:comma]), token) || headerValueContainsToken(v[comma+1:], token) + } + return tokenEqual(v, token) +} + +// lowerASCII returns the ASCII lowercase version of b. +func lowerASCII(b byte) byte { + if 'A' <= b && b <= 'Z' { + return b + ('a' - 'A') + } + return b +} + +// tokenEqual reports whether t1 and t2 are equal, ASCII case-insensitively. +func tokenEqual(t1, t2 string) bool { + if len(t1) != len(t2) { + return false + } + for i, b := range t1 { + if b >= utf8.RuneSelf { + // No UTF-8 or non-ASCII allowed in tokens. + return false + } + if lowerASCII(byte(b)) != lowerASCII(t2[i]) { + return false + } + } + return true +} + +// isLWS reports whether b is linear white space, according +// to http://www.w3.org/Protocols/rfc2616/rfc2616-sec2.html#sec2.2 +// LWS = [CRLF] 1*( SP | HT ) +func isLWS(b byte) bool { return b == ' ' || b == '\t' } + +// isCTL reports whether b is a control byte, according +// to http://www.w3.org/Protocols/rfc2616/rfc2616-sec2.html#sec2.2 +// CTL = +func isCTL(b byte) bool { + const del = 0x7f // a CTL + return b < ' ' || b == del +} + +// ValidHeaderFieldName reports whether v is a valid HTTP/1.x header name. +// HTTP/2 imposes the additional restriction that uppercase ASCII +// letters are not allowed. +// +// RFC 7230 says: +// header-field = field-name ":" OWS field-value OWS +// field-name = token +// token = 1*tchar +// tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." / +// "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA +func ValidHeaderFieldName(v string) bool { + if len(v) == 0 { + return false + } + for _, r := range v { + if !IsTokenRune(r) { + return false + } + } + return true +} + +// ValidHostHeader reports whether h is a valid host header. +func ValidHostHeader(h string) bool { + // The latest spec is actually this: + // + // http://tools.ietf.org/html/rfc7230#section-5.4 + // Host = uri-host [ ":" port ] + // + // Where uri-host is: + // http://tools.ietf.org/html/rfc3986#section-3.2.2 + // + // But we're going to be much more lenient for now and just + // search for any byte that's not a valid byte in any of those + // expressions. + for i := 0; i < len(h); i++ { + if !validHostByte[h[i]] { + return false + } + } + return true +} + +// See the validHostHeader comment. +var validHostByte = [256]bool{ + '0': true, '1': true, '2': true, '3': true, '4': true, '5': true, '6': true, '7': true, + '8': true, '9': true, + + 'a': true, 'b': true, 'c': true, 'd': true, 'e': true, 'f': true, 'g': true, 'h': true, + 'i': true, 'j': true, 'k': true, 'l': true, 'm': true, 'n': true, 'o': true, 'p': true, + 'q': true, 'r': true, 's': true, 't': true, 'u': true, 'v': true, 'w': true, 'x': true, + 'y': true, 'z': true, + + 'A': true, 'B': true, 'C': true, 'D': true, 'E': true, 'F': true, 'G': true, 'H': true, + 'I': true, 'J': true, 'K': true, 'L': true, 'M': true, 'N': true, 'O': true, 'P': true, + 'Q': true, 'R': true, 'S': true, 'T': true, 'U': true, 'V': true, 'W': true, 'X': true, + 'Y': true, 'Z': true, + + '!': true, // sub-delims + '$': true, // sub-delims + '%': true, // pct-encoded (and used in IPv6 zones) + '&': true, // sub-delims + '(': true, // sub-delims + ')': true, // sub-delims + '*': true, // sub-delims + '+': true, // sub-delims + ',': true, // sub-delims + '-': true, // unreserved + '.': true, // unreserved + ':': true, // IPv6address + Host expression's optional port + ';': true, // sub-delims + '=': true, // sub-delims + '[': true, + '\'': true, // sub-delims + ']': true, + '_': true, // unreserved + '~': true, // unreserved +} + +// ValidHeaderFieldValue reports whether v is a valid "field-value" according to +// http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2 : +// +// message-header = field-name ":" [ field-value ] +// field-value = *( field-content | LWS ) +// field-content = +// +// http://www.w3.org/Protocols/rfc2616/rfc2616-sec2.html#sec2.2 : +// +// TEXT = +// LWS = [CRLF] 1*( SP | HT ) +// CTL = +// +// RFC 7230 says: +// field-value = *( field-content / obs-fold ) +// obj-fold = N/A to http2, and deprecated +// field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ] +// field-vchar = VCHAR / obs-text +// obs-text = %x80-FF +// VCHAR = "any visible [USASCII] character" +// +// http2 further says: "Similarly, HTTP/2 allows header field values +// that are not valid. While most of the values that can be encoded +// will not alter header field parsing, carriage return (CR, ASCII +// 0xd), line feed (LF, ASCII 0xa), and the zero character (NUL, ASCII +// 0x0) might be exploited by an attacker if they are translated +// verbatim. Any request or response that contains a character not +// permitted in a header field value MUST be treated as malformed +// (Section 8.1.2.6). Valid characters are defined by the +// field-content ABNF rule in Section 3.2 of [RFC7230]." +// +// This function does not (yet?) properly handle the rejection of +// strings that begin or end with SP or HTAB. +func ValidHeaderFieldValue(v string) bool { + for i := 0; i < len(v); i++ { + b := v[i] + if isCTL(b) && !isLWS(b) { + return false + } + } + return true +} diff --git a/vendor/golang.org/x/net/trace/events.go b/vendor/golang.org/x/net/trace/events.go new file mode 100644 index 00000000..e66c7e32 --- /dev/null +++ b/vendor/golang.org/x/net/trace/events.go @@ -0,0 +1,524 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package trace + +import ( + "bytes" + "fmt" + "html/template" + "io" + "log" + "net/http" + "runtime" + "sort" + "strconv" + "strings" + "sync" + "sync/atomic" + "text/tabwriter" + "time" +) + +var eventsTmpl = template.Must(template.New("events").Funcs(template.FuncMap{ + "elapsed": elapsed, + "trimSpace": strings.TrimSpace, +}).Parse(eventsHTML)) + +const maxEventsPerLog = 100 + +type bucket struct { + MaxErrAge time.Duration + String string +} + +var buckets = []bucket{ + {0, "total"}, + {10 * time.Second, "errs<10s"}, + {1 * time.Minute, "errs<1m"}, + {10 * time.Minute, "errs<10m"}, + {1 * time.Hour, "errs<1h"}, + {10 * time.Hour, "errs<10h"}, + {24000 * time.Hour, "errors"}, +} + +// RenderEvents renders the HTML page typically served at /debug/events. +// It does not do any auth checking; see AuthRequest for the default auth check +// used by the handler registered on http.DefaultServeMux. +// req may be nil. +func RenderEvents(w http.ResponseWriter, req *http.Request, sensitive bool) { + now := time.Now() + data := &struct { + Families []string // family names + Buckets []bucket + Counts [][]int // eventLog count per family/bucket + + // Set when a bucket has been selected. + Family string + Bucket int + EventLogs eventLogs + Expanded bool + }{ + Buckets: buckets, + } + + data.Families = make([]string, 0, len(families)) + famMu.RLock() + for name := range families { + data.Families = append(data.Families, name) + } + famMu.RUnlock() + sort.Strings(data.Families) + + // Count the number of eventLogs in each family for each error age. + data.Counts = make([][]int, len(data.Families)) + for i, name := range data.Families { + // TODO(sameer): move this loop under the family lock. + f := getEventFamily(name) + data.Counts[i] = make([]int, len(data.Buckets)) + for j, b := range data.Buckets { + data.Counts[i][j] = f.Count(now, b.MaxErrAge) + } + } + + if req != nil { + var ok bool + data.Family, data.Bucket, ok = parseEventsArgs(req) + if !ok { + // No-op + } else { + data.EventLogs = getEventFamily(data.Family).Copy(now, buckets[data.Bucket].MaxErrAge) + } + if data.EventLogs != nil { + defer data.EventLogs.Free() + sort.Sort(data.EventLogs) + } + if exp, err := strconv.ParseBool(req.FormValue("exp")); err == nil { + data.Expanded = exp + } + } + + famMu.RLock() + defer famMu.RUnlock() + if err := eventsTmpl.Execute(w, data); err != nil { + log.Printf("net/trace: Failed executing template: %v", err) + } +} + +func parseEventsArgs(req *http.Request) (fam string, b int, ok bool) { + fam, bStr := req.FormValue("fam"), req.FormValue("b") + if fam == "" || bStr == "" { + return "", 0, false + } + b, err := strconv.Atoi(bStr) + if err != nil || b < 0 || b >= len(buckets) { + return "", 0, false + } + return fam, b, true +} + +// An EventLog provides a log of events associated with a specific object. +type EventLog interface { + // Printf formats its arguments with fmt.Sprintf and adds the + // result to the event log. + Printf(format string, a ...interface{}) + + // Errorf is like Printf, but it marks this event as an error. + Errorf(format string, a ...interface{}) + + // Finish declares that this event log is complete. + // The event log should not be used after calling this method. + Finish() +} + +// NewEventLog returns a new EventLog with the specified family name +// and title. +func NewEventLog(family, title string) EventLog { + el := newEventLog() + el.ref() + el.Family, el.Title = family, title + el.Start = time.Now() + el.events = make([]logEntry, 0, maxEventsPerLog) + el.stack = make([]uintptr, 32) + n := runtime.Callers(2, el.stack) + el.stack = el.stack[:n] + + getEventFamily(family).add(el) + return el +} + +func (el *eventLog) Finish() { + getEventFamily(el.Family).remove(el) + el.unref() // matches ref in New +} + +var ( + famMu sync.RWMutex + families = make(map[string]*eventFamily) // family name => family +) + +func getEventFamily(fam string) *eventFamily { + famMu.Lock() + defer famMu.Unlock() + f := families[fam] + if f == nil { + f = &eventFamily{} + families[fam] = f + } + return f +} + +type eventFamily struct { + mu sync.RWMutex + eventLogs eventLogs +} + +func (f *eventFamily) add(el *eventLog) { + f.mu.Lock() + f.eventLogs = append(f.eventLogs, el) + f.mu.Unlock() +} + +func (f *eventFamily) remove(el *eventLog) { + f.mu.Lock() + defer f.mu.Unlock() + for i, el0 := range f.eventLogs { + if el == el0 { + copy(f.eventLogs[i:], f.eventLogs[i+1:]) + f.eventLogs = f.eventLogs[:len(f.eventLogs)-1] + return + } + } +} + +func (f *eventFamily) Count(now time.Time, maxErrAge time.Duration) (n int) { + f.mu.RLock() + defer f.mu.RUnlock() + for _, el := range f.eventLogs { + if el.hasRecentError(now, maxErrAge) { + n++ + } + } + return +} + +func (f *eventFamily) Copy(now time.Time, maxErrAge time.Duration) (els eventLogs) { + f.mu.RLock() + defer f.mu.RUnlock() + els = make(eventLogs, 0, len(f.eventLogs)) + for _, el := range f.eventLogs { + if el.hasRecentError(now, maxErrAge) { + el.ref() + els = append(els, el) + } + } + return +} + +type eventLogs []*eventLog + +// Free calls unref on each element of the list. +func (els eventLogs) Free() { + for _, el := range els { + el.unref() + } +} + +// eventLogs may be sorted in reverse chronological order. +func (els eventLogs) Len() int { return len(els) } +func (els eventLogs) Less(i, j int) bool { return els[i].Start.After(els[j].Start) } +func (els eventLogs) Swap(i, j int) { els[i], els[j] = els[j], els[i] } + +// A logEntry is a timestamped log entry in an event log. +type logEntry struct { + When time.Time + Elapsed time.Duration // since previous event in log + NewDay bool // whether this event is on a different day to the previous event + What string + IsErr bool +} + +// WhenString returns a string representation of the elapsed time of the event. +// It will include the date if midnight was crossed. +func (e logEntry) WhenString() string { + if e.NewDay { + return e.When.Format("2006/01/02 15:04:05.000000") + } + return e.When.Format("15:04:05.000000") +} + +// An eventLog represents an active event log. +type eventLog struct { + // Family is the top-level grouping of event logs to which this belongs. + Family string + + // Title is the title of this event log. + Title string + + // Timing information. + Start time.Time + + // Call stack where this event log was created. + stack []uintptr + + // Append-only sequence of events. + // + // TODO(sameer): change this to a ring buffer to avoid the array copy + // when we hit maxEventsPerLog. + mu sync.RWMutex + events []logEntry + LastErrorTime time.Time + discarded int + + refs int32 // how many buckets this is in +} + +func (el *eventLog) reset() { + // Clear all but the mutex. Mutexes may not be copied, even when unlocked. + el.Family = "" + el.Title = "" + el.Start = time.Time{} + el.stack = nil + el.events = nil + el.LastErrorTime = time.Time{} + el.discarded = 0 + el.refs = 0 +} + +func (el *eventLog) hasRecentError(now time.Time, maxErrAge time.Duration) bool { + if maxErrAge == 0 { + return true + } + el.mu.RLock() + defer el.mu.RUnlock() + return now.Sub(el.LastErrorTime) < maxErrAge +} + +// delta returns the elapsed time since the last event or the log start, +// and whether it spans midnight. +// L >= el.mu +func (el *eventLog) delta(t time.Time) (time.Duration, bool) { + if len(el.events) == 0 { + return t.Sub(el.Start), false + } + prev := el.events[len(el.events)-1].When + return t.Sub(prev), prev.Day() != t.Day() + +} + +func (el *eventLog) Printf(format string, a ...interface{}) { + el.printf(false, format, a...) +} + +func (el *eventLog) Errorf(format string, a ...interface{}) { + el.printf(true, format, a...) +} + +func (el *eventLog) printf(isErr bool, format string, a ...interface{}) { + e := logEntry{When: time.Now(), IsErr: isErr, What: fmt.Sprintf(format, a...)} + el.mu.Lock() + e.Elapsed, e.NewDay = el.delta(e.When) + if len(el.events) < maxEventsPerLog { + el.events = append(el.events, e) + } else { + // Discard the oldest event. + if el.discarded == 0 { + // el.discarded starts at two to count for the event it + // is replacing, plus the next one that we are about to + // drop. + el.discarded = 2 + } else { + el.discarded++ + } + // TODO(sameer): if this causes allocations on a critical path, + // change eventLog.What to be a fmt.Stringer, as in trace.go. + el.events[0].What = fmt.Sprintf("(%d events discarded)", el.discarded) + // The timestamp of the discarded meta-event should be + // the time of the last event it is representing. + el.events[0].When = el.events[1].When + copy(el.events[1:], el.events[2:]) + el.events[maxEventsPerLog-1] = e + } + if e.IsErr { + el.LastErrorTime = e.When + } + el.mu.Unlock() +} + +func (el *eventLog) ref() { + atomic.AddInt32(&el.refs, 1) +} + +func (el *eventLog) unref() { + if atomic.AddInt32(&el.refs, -1) == 0 { + freeEventLog(el) + } +} + +func (el *eventLog) When() string { + return el.Start.Format("2006/01/02 15:04:05.000000") +} + +func (el *eventLog) ElapsedTime() string { + elapsed := time.Since(el.Start) + return fmt.Sprintf("%.6f", elapsed.Seconds()) +} + +func (el *eventLog) Stack() string { + buf := new(bytes.Buffer) + tw := tabwriter.NewWriter(buf, 1, 8, 1, '\t', 0) + printStackRecord(tw, el.stack) + tw.Flush() + return buf.String() +} + +// printStackRecord prints the function + source line information +// for a single stack trace. +// Adapted from runtime/pprof/pprof.go. +func printStackRecord(w io.Writer, stk []uintptr) { + for _, pc := range stk { + f := runtime.FuncForPC(pc) + if f == nil { + continue + } + file, line := f.FileLine(pc) + name := f.Name() + // Hide runtime.goexit and any runtime functions at the beginning. + if strings.HasPrefix(name, "runtime.") { + continue + } + fmt.Fprintf(w, "# %s\t%s:%d\n", name, file, line) + } +} + +func (el *eventLog) Events() []logEntry { + el.mu.RLock() + defer el.mu.RUnlock() + return el.events +} + +// freeEventLogs is a freelist of *eventLog +var freeEventLogs = make(chan *eventLog, 1000) + +// newEventLog returns a event log ready to use. +func newEventLog() *eventLog { + select { + case el := <-freeEventLogs: + return el + default: + return new(eventLog) + } +} + +// freeEventLog adds el to freeEventLogs if there's room. +// This is non-blocking. +func freeEventLog(el *eventLog) { + el.reset() + select { + case freeEventLogs <- el: + default: + } +} + +const eventsHTML = ` + + + events + + + + +

/debug/events

+ + + {{range $i, $fam := .Families}} + + + + {{range $j, $bucket := $.Buckets}} + {{$n := index $.Counts $i $j}} + + {{end}} + + {{end}} +
{{$fam}} + {{if $n}}{{end}} + [{{$n}} {{$bucket.String}}] + {{if $n}}{{end}} +
+ +{{if $.EventLogs}} +
+

Family: {{$.Family}}

+ +{{if $.Expanded}}{{end}} +[Summary]{{if $.Expanded}}{{end}} + +{{if not $.Expanded}}{{end}} +[Expanded]{{if not $.Expanded}}{{end}} + + + + {{range $el := $.EventLogs}} + + + + + {{if $.Expanded}} + + + + + + {{range $el.Events}} + + + + + + {{end}} + {{end}} + {{end}} +
WhenElapsed
{{$el.When}}{{$el.ElapsedTime}}{{$el.Title}} + 
{{$el.Stack|trimSpace}}
{{.WhenString}}{{elapsed .Elapsed}}.{{if .IsErr}}E{{else}}.{{end}}. {{.What}}
+{{end}} + + +` diff --git a/vendor/golang.org/x/net/trace/histogram.go b/vendor/golang.org/x/net/trace/histogram.go new file mode 100644 index 00000000..bb42aa53 --- /dev/null +++ b/vendor/golang.org/x/net/trace/histogram.go @@ -0,0 +1,356 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package trace + +// This file implements histogramming for RPC statistics collection. + +import ( + "bytes" + "fmt" + "html/template" + "log" + "math" + + "golang.org/x/net/internal/timeseries" +) + +const ( + bucketCount = 38 +) + +// histogram keeps counts of values in buckets that are spaced +// out in powers of 2: 0-1, 2-3, 4-7... +// histogram implements timeseries.Observable +type histogram struct { + sum int64 // running total of measurements + sumOfSquares float64 // square of running total + buckets []int64 // bucketed values for histogram + value int // holds a single value as an optimization + valueCount int64 // number of values recorded for single value +} + +// AddMeasurement records a value measurement observation to the histogram. +func (h *histogram) addMeasurement(value int64) { + // TODO: assert invariant + h.sum += value + h.sumOfSquares += float64(value) * float64(value) + + bucketIndex := getBucket(value) + + if h.valueCount == 0 || (h.valueCount > 0 && h.value == bucketIndex) { + h.value = bucketIndex + h.valueCount++ + } else { + h.allocateBuckets() + h.buckets[bucketIndex]++ + } +} + +func (h *histogram) allocateBuckets() { + if h.buckets == nil { + h.buckets = make([]int64, bucketCount) + h.buckets[h.value] = h.valueCount + h.value = 0 + h.valueCount = -1 + } +} + +func log2(i int64) int { + n := 0 + for ; i >= 0x100; i >>= 8 { + n += 8 + } + for ; i > 0; i >>= 1 { + n += 1 + } + return n +} + +func getBucket(i int64) (index int) { + index = log2(i) - 1 + if index < 0 { + index = 0 + } + if index >= bucketCount { + index = bucketCount - 1 + } + return +} + +// Total returns the number of recorded observations. +func (h *histogram) total() (total int64) { + if h.valueCount >= 0 { + total = h.valueCount + } + for _, val := range h.buckets { + total += int64(val) + } + return +} + +// Average returns the average value of recorded observations. +func (h *histogram) average() float64 { + t := h.total() + if t == 0 { + return 0 + } + return float64(h.sum) / float64(t) +} + +// Variance returns the variance of recorded observations. +func (h *histogram) variance() float64 { + t := float64(h.total()) + if t == 0 { + return 0 + } + s := float64(h.sum) / t + return h.sumOfSquares/t - s*s +} + +// StandardDeviation returns the standard deviation of recorded observations. +func (h *histogram) standardDeviation() float64 { + return math.Sqrt(h.variance()) +} + +// PercentileBoundary estimates the value that the given fraction of recorded +// observations are less than. +func (h *histogram) percentileBoundary(percentile float64) int64 { + total := h.total() + + // Corner cases (make sure result is strictly less than Total()) + if total == 0 { + return 0 + } else if total == 1 { + return int64(h.average()) + } + + percentOfTotal := round(float64(total) * percentile) + var runningTotal int64 + + for i := range h.buckets { + value := h.buckets[i] + runningTotal += value + if runningTotal == percentOfTotal { + // We hit an exact bucket boundary. If the next bucket has data, it is a + // good estimate of the value. If the bucket is empty, we interpolate the + // midpoint between the next bucket's boundary and the next non-zero + // bucket. If the remaining buckets are all empty, then we use the + // boundary for the next bucket as the estimate. + j := uint8(i + 1) + min := bucketBoundary(j) + if runningTotal < total { + for h.buckets[j] == 0 { + j++ + } + } + max := bucketBoundary(j) + return min + round(float64(max-min)/2) + } else if runningTotal > percentOfTotal { + // The value is in this bucket. Interpolate the value. + delta := runningTotal - percentOfTotal + percentBucket := float64(value-delta) / float64(value) + bucketMin := bucketBoundary(uint8(i)) + nextBucketMin := bucketBoundary(uint8(i + 1)) + bucketSize := nextBucketMin - bucketMin + return bucketMin + round(percentBucket*float64(bucketSize)) + } + } + return bucketBoundary(bucketCount - 1) +} + +// Median returns the estimated median of the observed values. +func (h *histogram) median() int64 { + return h.percentileBoundary(0.5) +} + +// Add adds other to h. +func (h *histogram) Add(other timeseries.Observable) { + o := other.(*histogram) + if o.valueCount == 0 { + // Other histogram is empty + } else if h.valueCount >= 0 && o.valueCount > 0 && h.value == o.value { + // Both have a single bucketed value, aggregate them + h.valueCount += o.valueCount + } else { + // Two different values necessitate buckets in this histogram + h.allocateBuckets() + if o.valueCount >= 0 { + h.buckets[o.value] += o.valueCount + } else { + for i := range h.buckets { + h.buckets[i] += o.buckets[i] + } + } + } + h.sumOfSquares += o.sumOfSquares + h.sum += o.sum +} + +// Clear resets the histogram to an empty state, removing all observed values. +func (h *histogram) Clear() { + h.buckets = nil + h.value = 0 + h.valueCount = 0 + h.sum = 0 + h.sumOfSquares = 0 +} + +// CopyFrom copies from other, which must be a *histogram, into h. +func (h *histogram) CopyFrom(other timeseries.Observable) { + o := other.(*histogram) + if o.valueCount == -1 { + h.allocateBuckets() + copy(h.buckets, o.buckets) + } + h.sum = o.sum + h.sumOfSquares = o.sumOfSquares + h.value = o.value + h.valueCount = o.valueCount +} + +// Multiply scales the histogram by the specified ratio. +func (h *histogram) Multiply(ratio float64) { + if h.valueCount == -1 { + for i := range h.buckets { + h.buckets[i] = int64(float64(h.buckets[i]) * ratio) + } + } else { + h.valueCount = int64(float64(h.valueCount) * ratio) + } + h.sum = int64(float64(h.sum) * ratio) + h.sumOfSquares = h.sumOfSquares * ratio +} + +// New creates a new histogram. +func (h *histogram) New() timeseries.Observable { + r := new(histogram) + r.Clear() + return r +} + +func (h *histogram) String() string { + return fmt.Sprintf("%d, %f, %d, %d, %v", + h.sum, h.sumOfSquares, h.value, h.valueCount, h.buckets) +} + +// round returns the closest int64 to the argument +func round(in float64) int64 { + return int64(math.Floor(in + 0.5)) +} + +// bucketBoundary returns the first value in the bucket. +func bucketBoundary(bucket uint8) int64 { + if bucket == 0 { + return 0 + } + return 1 << bucket +} + +// bucketData holds data about a specific bucket for use in distTmpl. +type bucketData struct { + Lower, Upper int64 + N int64 + Pct, CumulativePct float64 + GraphWidth int +} + +// data holds data about a Distribution for use in distTmpl. +type data struct { + Buckets []*bucketData + Count, Median int64 + Mean, StandardDeviation float64 +} + +// maxHTMLBarWidth is the maximum width of the HTML bar for visualizing buckets. +const maxHTMLBarWidth = 350.0 + +// newData returns data representing h for use in distTmpl. +func (h *histogram) newData() *data { + // Force the allocation of buckets to simplify the rendering implementation + h.allocateBuckets() + // We scale the bars on the right so that the largest bar is + // maxHTMLBarWidth pixels in width. + maxBucket := int64(0) + for _, n := range h.buckets { + if n > maxBucket { + maxBucket = n + } + } + total := h.total() + barsizeMult := maxHTMLBarWidth / float64(maxBucket) + var pctMult float64 + if total == 0 { + pctMult = 1.0 + } else { + pctMult = 100.0 / float64(total) + } + + buckets := make([]*bucketData, len(h.buckets)) + runningTotal := int64(0) + for i, n := range h.buckets { + if n == 0 { + continue + } + runningTotal += n + var upperBound int64 + if i < bucketCount-1 { + upperBound = bucketBoundary(uint8(i + 1)) + } else { + upperBound = math.MaxInt64 + } + buckets[i] = &bucketData{ + Lower: bucketBoundary(uint8(i)), + Upper: upperBound, + N: n, + Pct: float64(n) * pctMult, + CumulativePct: float64(runningTotal) * pctMult, + GraphWidth: int(float64(n) * barsizeMult), + } + } + return &data{ + Buckets: buckets, + Count: total, + Median: h.median(), + Mean: h.average(), + StandardDeviation: h.standardDeviation(), + } +} + +func (h *histogram) html() template.HTML { + buf := new(bytes.Buffer) + if err := distTmpl.Execute(buf, h.newData()); err != nil { + buf.Reset() + log.Printf("net/trace: couldn't execute template: %v", err) + } + return template.HTML(buf.String()) +} + +// Input: data +var distTmpl = template.Must(template.New("distTmpl").Parse(` + + + + + + + +
Count: {{.Count}}Mean: {{printf "%.0f" .Mean}}StdDev: {{printf "%.0f" .StandardDeviation}}Median: {{.Median}}
+
+ +{{range $b := .Buckets}} +{{if $b}} + + + + + + + + + +{{end}} +{{end}} +
[{{.Lower}},{{.Upper}}){{.N}}{{printf "%#.3f" .Pct}}%{{printf "%#.3f" .CumulativePct}}%
+`)) diff --git a/vendor/golang.org/x/net/trace/trace.go b/vendor/golang.org/x/net/trace/trace.go new file mode 100644 index 00000000..d860fccf --- /dev/null +++ b/vendor/golang.org/x/net/trace/trace.go @@ -0,0 +1,1063 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package trace implements tracing of requests and long-lived objects. +It exports HTTP interfaces on /debug/requests and /debug/events. + +A trace.Trace provides tracing for short-lived objects, usually requests. +A request handler might be implemented like this: + + func fooHandler(w http.ResponseWriter, req *http.Request) { + tr := trace.New("mypkg.Foo", req.URL.Path) + defer tr.Finish() + ... + tr.LazyPrintf("some event %q happened", str) + ... + if err := somethingImportant(); err != nil { + tr.LazyPrintf("somethingImportant failed: %v", err) + tr.SetError() + } + } + +The /debug/requests HTTP endpoint organizes the traces by family, +errors, and duration. It also provides histogram of request duration +for each family. + +A trace.EventLog provides tracing for long-lived objects, such as RPC +connections. + + // A Fetcher fetches URL paths for a single domain. + type Fetcher struct { + domain string + events trace.EventLog + } + + func NewFetcher(domain string) *Fetcher { + return &Fetcher{ + domain, + trace.NewEventLog("mypkg.Fetcher", domain), + } + } + + func (f *Fetcher) Fetch(path string) (string, error) { + resp, err := http.Get("http://" + f.domain + "/" + path) + if err != nil { + f.events.Errorf("Get(%q) = %v", path, err) + return "", err + } + f.events.Printf("Get(%q) = %s", path, resp.Status) + ... + } + + func (f *Fetcher) Close() error { + f.events.Finish() + return nil + } + +The /debug/events HTTP endpoint organizes the event logs by family and +by time since the last error. The expanded view displays recent log +entries and the log's call stack. +*/ +package trace // import "golang.org/x/net/trace" + +import ( + "bytes" + "fmt" + "html/template" + "io" + "log" + "net" + "net/http" + "runtime" + "sort" + "strconv" + "sync" + "sync/atomic" + "time" + + "golang.org/x/net/context" + "golang.org/x/net/internal/timeseries" +) + +// DebugUseAfterFinish controls whether to debug uses of Trace values after finishing. +// FOR DEBUGGING ONLY. This will slow down the program. +var DebugUseAfterFinish = false + +// AuthRequest determines whether a specific request is permitted to load the +// /debug/requests or /debug/events pages. +// +// It returns two bools; the first indicates whether the page may be viewed at all, +// and the second indicates whether sensitive events will be shown. +// +// AuthRequest may be replaced by a program to customise its authorisation requirements. +// +// The default AuthRequest function returns (true, true) if and only if the request +// comes from localhost/127.0.0.1/[::1]. +var AuthRequest = func(req *http.Request) (any, sensitive bool) { + // RemoteAddr is commonly in the form "IP" or "IP:port". + // If it is in the form "IP:port", split off the port. + host, _, err := net.SplitHostPort(req.RemoteAddr) + if err != nil { + host = req.RemoteAddr + } + switch host { + case "localhost", "127.0.0.1", "::1": + return true, true + default: + return false, false + } +} + +func init() { + http.HandleFunc("/debug/requests", func(w http.ResponseWriter, req *http.Request) { + any, sensitive := AuthRequest(req) + if !any { + http.Error(w, "not allowed", http.StatusUnauthorized) + return + } + w.Header().Set("Content-Type", "text/html; charset=utf-8") + Render(w, req, sensitive) + }) + http.HandleFunc("/debug/events", func(w http.ResponseWriter, req *http.Request) { + any, sensitive := AuthRequest(req) + if !any { + http.Error(w, "not allowed", http.StatusUnauthorized) + return + } + w.Header().Set("Content-Type", "text/html; charset=utf-8") + RenderEvents(w, req, sensitive) + }) +} + +// Render renders the HTML page typically served at /debug/requests. +// It does not do any auth checking; see AuthRequest for the default auth check +// used by the handler registered on http.DefaultServeMux. +// req may be nil. +func Render(w io.Writer, req *http.Request, sensitive bool) { + data := &struct { + Families []string + ActiveTraceCount map[string]int + CompletedTraces map[string]*family + + // Set when a bucket has been selected. + Traces traceList + Family string + Bucket int + Expanded bool + Traced bool + Active bool + ShowSensitive bool // whether to show sensitive events + + Histogram template.HTML + HistogramWindow string // e.g. "last minute", "last hour", "all time" + + // If non-zero, the set of traces is a partial set, + // and this is the total number. + Total int + }{ + CompletedTraces: completedTraces, + } + + data.ShowSensitive = sensitive + if req != nil { + // Allow show_sensitive=0 to force hiding of sensitive data for testing. + // This only goes one way; you can't use show_sensitive=1 to see things. + if req.FormValue("show_sensitive") == "0" { + data.ShowSensitive = false + } + + if exp, err := strconv.ParseBool(req.FormValue("exp")); err == nil { + data.Expanded = exp + } + if exp, err := strconv.ParseBool(req.FormValue("rtraced")); err == nil { + data.Traced = exp + } + } + + completedMu.RLock() + data.Families = make([]string, 0, len(completedTraces)) + for fam := range completedTraces { + data.Families = append(data.Families, fam) + } + completedMu.RUnlock() + sort.Strings(data.Families) + + // We are careful here to minimize the time spent locking activeMu, + // since that lock is required every time an RPC starts and finishes. + data.ActiveTraceCount = make(map[string]int, len(data.Families)) + activeMu.RLock() + for fam, s := range activeTraces { + data.ActiveTraceCount[fam] = s.Len() + } + activeMu.RUnlock() + + var ok bool + data.Family, data.Bucket, ok = parseArgs(req) + switch { + case !ok: + // No-op + case data.Bucket == -1: + data.Active = true + n := data.ActiveTraceCount[data.Family] + data.Traces = getActiveTraces(data.Family) + if len(data.Traces) < n { + data.Total = n + } + case data.Bucket < bucketsPerFamily: + if b := lookupBucket(data.Family, data.Bucket); b != nil { + data.Traces = b.Copy(data.Traced) + } + default: + if f := getFamily(data.Family, false); f != nil { + var obs timeseries.Observable + f.LatencyMu.RLock() + switch o := data.Bucket - bucketsPerFamily; o { + case 0: + obs = f.Latency.Minute() + data.HistogramWindow = "last minute" + case 1: + obs = f.Latency.Hour() + data.HistogramWindow = "last hour" + case 2: + obs = f.Latency.Total() + data.HistogramWindow = "all time" + } + f.LatencyMu.RUnlock() + if obs != nil { + data.Histogram = obs.(*histogram).html() + } + } + } + + if data.Traces != nil { + defer data.Traces.Free() + sort.Sort(data.Traces) + } + + completedMu.RLock() + defer completedMu.RUnlock() + if err := pageTmpl.ExecuteTemplate(w, "Page", data); err != nil { + log.Printf("net/trace: Failed executing template: %v", err) + } +} + +func parseArgs(req *http.Request) (fam string, b int, ok bool) { + if req == nil { + return "", 0, false + } + fam, bStr := req.FormValue("fam"), req.FormValue("b") + if fam == "" || bStr == "" { + return "", 0, false + } + b, err := strconv.Atoi(bStr) + if err != nil || b < -1 { + return "", 0, false + } + + return fam, b, true +} + +func lookupBucket(fam string, b int) *traceBucket { + f := getFamily(fam, false) + if f == nil || b < 0 || b >= len(f.Buckets) { + return nil + } + return f.Buckets[b] +} + +type contextKeyT string + +var contextKey = contextKeyT("golang.org/x/net/trace.Trace") + +// NewContext returns a copy of the parent context +// and associates it with a Trace. +func NewContext(ctx context.Context, tr Trace) context.Context { + return context.WithValue(ctx, contextKey, tr) +} + +// FromContext returns the Trace bound to the context, if any. +func FromContext(ctx context.Context) (tr Trace, ok bool) { + tr, ok = ctx.Value(contextKey).(Trace) + return +} + +// Trace represents an active request. +type Trace interface { + // LazyLog adds x to the event log. It will be evaluated each time the + // /debug/requests page is rendered. Any memory referenced by x will be + // pinned until the trace is finished and later discarded. + LazyLog(x fmt.Stringer, sensitive bool) + + // LazyPrintf evaluates its arguments with fmt.Sprintf each time the + // /debug/requests page is rendered. Any memory referenced by a will be + // pinned until the trace is finished and later discarded. + LazyPrintf(format string, a ...interface{}) + + // SetError declares that this trace resulted in an error. + SetError() + + // SetRecycler sets a recycler for the trace. + // f will be called for each event passed to LazyLog at a time when + // it is no longer required, whether while the trace is still active + // and the event is discarded, or when a completed trace is discarded. + SetRecycler(f func(interface{})) + + // SetTraceInfo sets the trace info for the trace. + // This is currently unused. + SetTraceInfo(traceID, spanID uint64) + + // SetMaxEvents sets the maximum number of events that will be stored + // in the trace. This has no effect if any events have already been + // added to the trace. + SetMaxEvents(m int) + + // Finish declares that this trace is complete. + // The trace should not be used after calling this method. + Finish() +} + +type lazySprintf struct { + format string + a []interface{} +} + +func (l *lazySprintf) String() string { + return fmt.Sprintf(l.format, l.a...) +} + +// New returns a new Trace with the specified family and title. +func New(family, title string) Trace { + tr := newTrace() + tr.ref() + tr.Family, tr.Title = family, title + tr.Start = time.Now() + tr.events = make([]event, 0, maxEventsPerTrace) + + activeMu.RLock() + s := activeTraces[tr.Family] + activeMu.RUnlock() + if s == nil { + activeMu.Lock() + s = activeTraces[tr.Family] // check again + if s == nil { + s = new(traceSet) + activeTraces[tr.Family] = s + } + activeMu.Unlock() + } + s.Add(tr) + + // Trigger allocation of the completed trace structure for this family. + // This will cause the family to be present in the request page during + // the first trace of this family. We don't care about the return value, + // nor is there any need for this to run inline, so we execute it in its + // own goroutine, but only if the family isn't allocated yet. + completedMu.RLock() + if _, ok := completedTraces[tr.Family]; !ok { + go allocFamily(tr.Family) + } + completedMu.RUnlock() + + return tr +} + +func (tr *trace) Finish() { + tr.Elapsed = time.Now().Sub(tr.Start) + if DebugUseAfterFinish { + buf := make([]byte, 4<<10) // 4 KB should be enough + n := runtime.Stack(buf, false) + tr.finishStack = buf[:n] + } + + activeMu.RLock() + m := activeTraces[tr.Family] + activeMu.RUnlock() + m.Remove(tr) + + f := getFamily(tr.Family, true) + for _, b := range f.Buckets { + if b.Cond.match(tr) { + b.Add(tr) + } + } + // Add a sample of elapsed time as microseconds to the family's timeseries + h := new(histogram) + h.addMeasurement(tr.Elapsed.Nanoseconds() / 1e3) + f.LatencyMu.Lock() + f.Latency.Add(h) + f.LatencyMu.Unlock() + + tr.unref() // matches ref in New +} + +const ( + bucketsPerFamily = 9 + tracesPerBucket = 10 + maxActiveTraces = 20 // Maximum number of active traces to show. + maxEventsPerTrace = 10 + numHistogramBuckets = 38 +) + +var ( + // The active traces. + activeMu sync.RWMutex + activeTraces = make(map[string]*traceSet) // family -> traces + + // Families of completed traces. + completedMu sync.RWMutex + completedTraces = make(map[string]*family) // family -> traces +) + +type traceSet struct { + mu sync.RWMutex + m map[*trace]bool + + // We could avoid the entire map scan in FirstN by having a slice of all the traces + // ordered by start time, and an index into that from the trace struct, with a periodic + // repack of the slice after enough traces finish; we could also use a skip list or similar. + // However, that would shift some of the expense from /debug/requests time to RPC time, + // which is probably the wrong trade-off. +} + +func (ts *traceSet) Len() int { + ts.mu.RLock() + defer ts.mu.RUnlock() + return len(ts.m) +} + +func (ts *traceSet) Add(tr *trace) { + ts.mu.Lock() + if ts.m == nil { + ts.m = make(map[*trace]bool) + } + ts.m[tr] = true + ts.mu.Unlock() +} + +func (ts *traceSet) Remove(tr *trace) { + ts.mu.Lock() + delete(ts.m, tr) + ts.mu.Unlock() +} + +// FirstN returns the first n traces ordered by time. +func (ts *traceSet) FirstN(n int) traceList { + ts.mu.RLock() + defer ts.mu.RUnlock() + + if n > len(ts.m) { + n = len(ts.m) + } + trl := make(traceList, 0, n) + + // Fast path for when no selectivity is needed. + if n == len(ts.m) { + for tr := range ts.m { + tr.ref() + trl = append(trl, tr) + } + sort.Sort(trl) + return trl + } + + // Pick the oldest n traces. + // This is inefficient. See the comment in the traceSet struct. + for tr := range ts.m { + // Put the first n traces into trl in the order they occur. + // When we have n, sort trl, and thereafter maintain its order. + if len(trl) < n { + tr.ref() + trl = append(trl, tr) + if len(trl) == n { + // This is guaranteed to happen exactly once during this loop. + sort.Sort(trl) + } + continue + } + if tr.Start.After(trl[n-1].Start) { + continue + } + + // Find where to insert this one. + tr.ref() + i := sort.Search(n, func(i int) bool { return trl[i].Start.After(tr.Start) }) + trl[n-1].unref() + copy(trl[i+1:], trl[i:]) + trl[i] = tr + } + + return trl +} + +func getActiveTraces(fam string) traceList { + activeMu.RLock() + s := activeTraces[fam] + activeMu.RUnlock() + if s == nil { + return nil + } + return s.FirstN(maxActiveTraces) +} + +func getFamily(fam string, allocNew bool) *family { + completedMu.RLock() + f := completedTraces[fam] + completedMu.RUnlock() + if f == nil && allocNew { + f = allocFamily(fam) + } + return f +} + +func allocFamily(fam string) *family { + completedMu.Lock() + defer completedMu.Unlock() + f := completedTraces[fam] + if f == nil { + f = newFamily() + completedTraces[fam] = f + } + return f +} + +// family represents a set of trace buckets and associated latency information. +type family struct { + // traces may occur in multiple buckets. + Buckets [bucketsPerFamily]*traceBucket + + // latency time series + LatencyMu sync.RWMutex + Latency *timeseries.MinuteHourSeries +} + +func newFamily() *family { + return &family{ + Buckets: [bucketsPerFamily]*traceBucket{ + {Cond: minCond(0)}, + {Cond: minCond(50 * time.Millisecond)}, + {Cond: minCond(100 * time.Millisecond)}, + {Cond: minCond(200 * time.Millisecond)}, + {Cond: minCond(500 * time.Millisecond)}, + {Cond: minCond(1 * time.Second)}, + {Cond: minCond(10 * time.Second)}, + {Cond: minCond(100 * time.Second)}, + {Cond: errorCond{}}, + }, + Latency: timeseries.NewMinuteHourSeries(func() timeseries.Observable { return new(histogram) }), + } +} + +// traceBucket represents a size-capped bucket of historic traces, +// along with a condition for a trace to belong to the bucket. +type traceBucket struct { + Cond cond + + // Ring buffer implementation of a fixed-size FIFO queue. + mu sync.RWMutex + buf [tracesPerBucket]*trace + start int // < tracesPerBucket + length int // <= tracesPerBucket +} + +func (b *traceBucket) Add(tr *trace) { + b.mu.Lock() + defer b.mu.Unlock() + + i := b.start + b.length + if i >= tracesPerBucket { + i -= tracesPerBucket + } + if b.length == tracesPerBucket { + // "Remove" an element from the bucket. + b.buf[i].unref() + b.start++ + if b.start == tracesPerBucket { + b.start = 0 + } + } + b.buf[i] = tr + if b.length < tracesPerBucket { + b.length++ + } + tr.ref() +} + +// Copy returns a copy of the traces in the bucket. +// If tracedOnly is true, only the traces with trace information will be returned. +// The logs will be ref'd before returning; the caller should call +// the Free method when it is done with them. +// TODO(dsymonds): keep track of traced requests in separate buckets. +func (b *traceBucket) Copy(tracedOnly bool) traceList { + b.mu.RLock() + defer b.mu.RUnlock() + + trl := make(traceList, 0, b.length) + for i, x := 0, b.start; i < b.length; i++ { + tr := b.buf[x] + if !tracedOnly || tr.spanID != 0 { + tr.ref() + trl = append(trl, tr) + } + x++ + if x == b.length { + x = 0 + } + } + return trl +} + +func (b *traceBucket) Empty() bool { + b.mu.RLock() + defer b.mu.RUnlock() + return b.length == 0 +} + +// cond represents a condition on a trace. +type cond interface { + match(t *trace) bool + String() string +} + +type minCond time.Duration + +func (m minCond) match(t *trace) bool { return t.Elapsed >= time.Duration(m) } +func (m minCond) String() string { return fmt.Sprintf("≥%gs", time.Duration(m).Seconds()) } + +type errorCond struct{} + +func (e errorCond) match(t *trace) bool { return t.IsError } +func (e errorCond) String() string { return "errors" } + +type traceList []*trace + +// Free calls unref on each element of the list. +func (trl traceList) Free() { + for _, t := range trl { + t.unref() + } +} + +// traceList may be sorted in reverse chronological order. +func (trl traceList) Len() int { return len(trl) } +func (trl traceList) Less(i, j int) bool { return trl[i].Start.After(trl[j].Start) } +func (trl traceList) Swap(i, j int) { trl[i], trl[j] = trl[j], trl[i] } + +// An event is a timestamped log entry in a trace. +type event struct { + When time.Time + Elapsed time.Duration // since previous event in trace + NewDay bool // whether this event is on a different day to the previous event + Recyclable bool // whether this event was passed via LazyLog + What interface{} // string or fmt.Stringer + Sensitive bool // whether this event contains sensitive information +} + +// WhenString returns a string representation of the elapsed time of the event. +// It will include the date if midnight was crossed. +func (e event) WhenString() string { + if e.NewDay { + return e.When.Format("2006/01/02 15:04:05.000000") + } + return e.When.Format("15:04:05.000000") +} + +// discarded represents a number of discarded events. +// It is stored as *discarded to make it easier to update in-place. +type discarded int + +func (d *discarded) String() string { + return fmt.Sprintf("(%d events discarded)", int(*d)) +} + +// trace represents an active or complete request, +// either sent or received by this program. +type trace struct { + // Family is the top-level grouping of traces to which this belongs. + Family string + + // Title is the title of this trace. + Title string + + // Timing information. + Start time.Time + Elapsed time.Duration // zero while active + + // Trace information if non-zero. + traceID uint64 + spanID uint64 + + // Whether this trace resulted in an error. + IsError bool + + // Append-only sequence of events (modulo discards). + mu sync.RWMutex + events []event + + refs int32 // how many buckets this is in + recycler func(interface{}) + disc discarded // scratch space to avoid allocation + + finishStack []byte // where finish was called, if DebugUseAfterFinish is set +} + +func (tr *trace) reset() { + // Clear all but the mutex. Mutexes may not be copied, even when unlocked. + tr.Family = "" + tr.Title = "" + tr.Start = time.Time{} + tr.Elapsed = 0 + tr.traceID = 0 + tr.spanID = 0 + tr.IsError = false + tr.events = nil + tr.refs = 0 + tr.recycler = nil + tr.disc = 0 + tr.finishStack = nil +} + +// delta returns the elapsed time since the last event or the trace start, +// and whether it spans midnight. +// L >= tr.mu +func (tr *trace) delta(t time.Time) (time.Duration, bool) { + if len(tr.events) == 0 { + return t.Sub(tr.Start), false + } + prev := tr.events[len(tr.events)-1].When + return t.Sub(prev), prev.Day() != t.Day() +} + +func (tr *trace) addEvent(x interface{}, recyclable, sensitive bool) { + if DebugUseAfterFinish && tr.finishStack != nil { + buf := make([]byte, 4<<10) // 4 KB should be enough + n := runtime.Stack(buf, false) + log.Printf("net/trace: trace used after finish:\nFinished at:\n%s\nUsed at:\n%s", tr.finishStack, buf[:n]) + } + + /* + NOTE TO DEBUGGERS + + If you are here because your program panicked in this code, + it is almost definitely the fault of code using this package, + and very unlikely to be the fault of this code. + + The most likely scenario is that some code elsewhere is using + a requestz.Trace after its Finish method is called. + You can temporarily set the DebugUseAfterFinish var + to help discover where that is; do not leave that var set, + since it makes this package much less efficient. + */ + + e := event{When: time.Now(), What: x, Recyclable: recyclable, Sensitive: sensitive} + tr.mu.Lock() + e.Elapsed, e.NewDay = tr.delta(e.When) + if len(tr.events) < cap(tr.events) { + tr.events = append(tr.events, e) + } else { + // Discard the middle events. + di := int((cap(tr.events) - 1) / 2) + if d, ok := tr.events[di].What.(*discarded); ok { + (*d)++ + } else { + // disc starts at two to count for the event it is replacing, + // plus the next one that we are about to drop. + tr.disc = 2 + if tr.recycler != nil && tr.events[di].Recyclable { + go tr.recycler(tr.events[di].What) + } + tr.events[di].What = &tr.disc + } + // The timestamp of the discarded meta-event should be + // the time of the last event it is representing. + tr.events[di].When = tr.events[di+1].When + + if tr.recycler != nil && tr.events[di+1].Recyclable { + go tr.recycler(tr.events[di+1].What) + } + copy(tr.events[di+1:], tr.events[di+2:]) + tr.events[cap(tr.events)-1] = e + } + tr.mu.Unlock() +} + +func (tr *trace) LazyLog(x fmt.Stringer, sensitive bool) { + tr.addEvent(x, true, sensitive) +} + +func (tr *trace) LazyPrintf(format string, a ...interface{}) { + tr.addEvent(&lazySprintf{format, a}, false, false) +} + +func (tr *trace) SetError() { tr.IsError = true } + +func (tr *trace) SetRecycler(f func(interface{})) { + tr.recycler = f +} + +func (tr *trace) SetTraceInfo(traceID, spanID uint64) { + tr.traceID, tr.spanID = traceID, spanID +} + +func (tr *trace) SetMaxEvents(m int) { + // Always keep at least three events: first, discarded count, last. + if len(tr.events) == 0 && m > 3 { + tr.events = make([]event, 0, m) + } +} + +func (tr *trace) ref() { + atomic.AddInt32(&tr.refs, 1) +} + +func (tr *trace) unref() { + if atomic.AddInt32(&tr.refs, -1) == 0 { + if tr.recycler != nil { + // freeTrace clears tr, so we hold tr.recycler and tr.events here. + go func(f func(interface{}), es []event) { + for _, e := range es { + if e.Recyclable { + f(e.What) + } + } + }(tr.recycler, tr.events) + } + + freeTrace(tr) + } +} + +func (tr *trace) When() string { + return tr.Start.Format("2006/01/02 15:04:05.000000") +} + +func (tr *trace) ElapsedTime() string { + t := tr.Elapsed + if t == 0 { + // Active trace. + t = time.Since(tr.Start) + } + return fmt.Sprintf("%.6f", t.Seconds()) +} + +func (tr *trace) Events() []event { + tr.mu.RLock() + defer tr.mu.RUnlock() + return tr.events +} + +var traceFreeList = make(chan *trace, 1000) // TODO(dsymonds): Use sync.Pool? + +// newTrace returns a trace ready to use. +func newTrace() *trace { + select { + case tr := <-traceFreeList: + return tr + default: + return new(trace) + } +} + +// freeTrace adds tr to traceFreeList if there's room. +// This is non-blocking. +func freeTrace(tr *trace) { + if DebugUseAfterFinish { + return // never reuse + } + tr.reset() + select { + case traceFreeList <- tr: + default: + } +} + +func elapsed(d time.Duration) string { + b := []byte(fmt.Sprintf("%.6f", d.Seconds())) + + // For subsecond durations, blank all zeros before decimal point, + // and all zeros between the decimal point and the first non-zero digit. + if d < time.Second { + dot := bytes.IndexByte(b, '.') + for i := 0; i < dot; i++ { + b[i] = ' ' + } + for i := dot + 1; i < len(b); i++ { + if b[i] == '0' { + b[i] = ' ' + } else { + break + } + } + } + + return string(b) +} + +var pageTmpl = template.Must(template.New("Page").Funcs(template.FuncMap{ + "elapsed": elapsed, + "add": func(a, b int) int { return a + b }, +}).Parse(pageHTML)) + +const pageHTML = ` +{{template "Prolog" .}} +{{template "StatusTable" .}} +{{template "Epilog" .}} + +{{define "Prolog"}} + + + /debug/requests + + + + +

/debug/requests

+{{end}} {{/* end of Prolog */}} + +{{define "StatusTable"}} + + {{range $fam := .Families}} + + + + {{$n := index $.ActiveTraceCount $fam}} + + + {{$f := index $.CompletedTraces $fam}} + {{range $i, $b := $f.Buckets}} + {{$empty := $b.Empty}} + + {{end}} + + {{$nb := len $f.Buckets}} + + + + + + {{end}} +
{{$fam}} + {{if $n}}{{end}} + [{{$n}} active] + {{if $n}}{{end}} + + {{if not $empty}}{{end}} + [{{.Cond}}] + {{if not $empty}}{{end}} + + [minute] + + [hour] + + [total] +
+{{end}} {{/* end of StatusTable */}} + +{{define "Epilog"}} +{{if $.Traces}} +
+

Family: {{$.Family}}

+ +{{if or $.Expanded $.Traced}} + [Normal/Summary] +{{else}} + [Normal/Summary] +{{end}} + +{{if or (not $.Expanded) $.Traced}} + [Normal/Expanded] +{{else}} + [Normal/Expanded] +{{end}} + +{{if not $.Active}} + {{if or $.Expanded (not $.Traced)}} + [Traced/Summary] + {{else}} + [Traced/Summary] + {{end}} + {{if or (not $.Expanded) (not $.Traced)}} + [Traced/Expanded] + {{else}} + [Traced/Expanded] + {{end}} +{{end}} + +{{if $.Total}} +

Showing {{len $.Traces}} of {{$.Total}} traces.

+{{end}} + + + + + {{range $tr := $.Traces}} + + + + + {{/* TODO: include traceID/spanID */}} + + {{if $.Expanded}} + {{range $tr.Events}} + + + + + + {{end}} + {{end}} + {{end}} +
+ {{if $.Active}}Active{{else}}Completed{{end}} Requests +
WhenElapsed (s)
{{$tr.When}}{{$tr.ElapsedTime}}{{$tr.Title}}
{{.WhenString}}{{elapsed .Elapsed}}{{if or $.ShowSensitive (not .Sensitive)}}... {{.What}}{{else}}[redacted]{{end}}
+{{end}} {{/* if $.Traces */}} + +{{if $.Histogram}} +

Latency (µs) of {{$.Family}} over {{$.HistogramWindow}}

+{{$.Histogram}} +{{end}} {{/* if $.Histogram */}} + + + +{{end}} {{/* end of Epilog */}} +` diff --git a/vendor/golang.org/x/oauth2/LICENSE b/vendor/golang.org/x/oauth2/LICENSE new file mode 100644 index 00000000..d02f24fd --- /dev/null +++ b/vendor/golang.org/x/oauth2/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2009 The oauth2 Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/golang.org/x/oauth2/client_appengine.go b/vendor/golang.org/x/oauth2/client_appengine.go new file mode 100644 index 00000000..8962c49d --- /dev/null +++ b/vendor/golang.org/x/oauth2/client_appengine.go @@ -0,0 +1,25 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build appengine + +// App Engine hooks. + +package oauth2 + +import ( + "net/http" + + "golang.org/x/net/context" + "golang.org/x/oauth2/internal" + "google.golang.org/appengine/urlfetch" +) + +func init() { + internal.RegisterContextClientFunc(contextClientAppEngine) +} + +func contextClientAppEngine(ctx context.Context) (*http.Client, error) { + return urlfetch.Client(ctx), nil +} diff --git a/vendor/golang.org/x/oauth2/google/appengine.go b/vendor/golang.org/x/oauth2/google/appengine.go new file mode 100644 index 00000000..dc993efb --- /dev/null +++ b/vendor/golang.org/x/oauth2/google/appengine.go @@ -0,0 +1,86 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package google + +import ( + "sort" + "strings" + "sync" + "time" + + "golang.org/x/net/context" + "golang.org/x/oauth2" +) + +// Set at init time by appenginevm_hook.go. If true, we are on App Engine Managed VMs. +var appengineVM bool + +// Set at init time by appengine_hook.go. If nil, we're not on App Engine. +var appengineTokenFunc func(c context.Context, scopes ...string) (token string, expiry time.Time, err error) + +// AppEngineTokenSource returns a token source that fetches tokens +// issued to the current App Engine application's service account. +// If you are implementing a 3-legged OAuth 2.0 flow on App Engine +// that involves user accounts, see oauth2.Config instead. +// +// The provided context must have come from appengine.NewContext. +func AppEngineTokenSource(ctx context.Context, scope ...string) oauth2.TokenSource { + if appengineTokenFunc == nil { + panic("google: AppEngineTokenSource can only be used on App Engine.") + } + scopes := append([]string{}, scope...) + sort.Strings(scopes) + return &appEngineTokenSource{ + ctx: ctx, + scopes: scopes, + key: strings.Join(scopes, " "), + } +} + +// aeTokens helps the fetched tokens to be reused until their expiration. +var ( + aeTokensMu sync.Mutex + aeTokens = make(map[string]*tokenLock) // key is space-separated scopes +) + +type tokenLock struct { + mu sync.Mutex // guards t; held while fetching or updating t + t *oauth2.Token +} + +type appEngineTokenSource struct { + ctx context.Context + scopes []string + key string // to aeTokens map; space-separated scopes +} + +func (ts *appEngineTokenSource) Token() (*oauth2.Token, error) { + if appengineTokenFunc == nil { + panic("google: AppEngineTokenSource can only be used on App Engine.") + } + + aeTokensMu.Lock() + tok, ok := aeTokens[ts.key] + if !ok { + tok = &tokenLock{} + aeTokens[ts.key] = tok + } + aeTokensMu.Unlock() + + tok.mu.Lock() + defer tok.mu.Unlock() + if tok.t.Valid() { + return tok.t, nil + } + access, exp, err := appengineTokenFunc(ts.ctx, ts.scopes...) + if err != nil { + return nil, err + } + tok.t = &oauth2.Token{ + AccessToken: access, + Expiry: exp, + } + return tok.t, nil +} diff --git a/vendor/golang.org/x/oauth2/google/appengine_hook.go b/vendor/golang.org/x/oauth2/google/appengine_hook.go new file mode 100644 index 00000000..4f42c8b3 --- /dev/null +++ b/vendor/golang.org/x/oauth2/google/appengine_hook.go @@ -0,0 +1,13 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build appengine + +package google + +import "google.golang.org/appengine" + +func init() { + appengineTokenFunc = appengine.AccessToken +} diff --git a/vendor/golang.org/x/oauth2/google/appenginevm_hook.go b/vendor/golang.org/x/oauth2/google/appenginevm_hook.go new file mode 100644 index 00000000..633611cc --- /dev/null +++ b/vendor/golang.org/x/oauth2/google/appenginevm_hook.go @@ -0,0 +1,14 @@ +// Copyright 2015 The oauth2 Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build appenginevm + +package google + +import "google.golang.org/appengine" + +func init() { + appengineVM = true + appengineTokenFunc = appengine.AccessToken +} diff --git a/vendor/golang.org/x/oauth2/google/default.go b/vendor/golang.org/x/oauth2/google/default.go new file mode 100644 index 00000000..565d731c --- /dev/null +++ b/vendor/golang.org/x/oauth2/google/default.go @@ -0,0 +1,155 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package google + +import ( + "encoding/json" + "errors" + "fmt" + "io/ioutil" + "net/http" + "os" + "path/filepath" + "runtime" + + "cloud.google.com/go/compute/metadata" + "golang.org/x/net/context" + "golang.org/x/oauth2" + "golang.org/x/oauth2/jwt" +) + +// DefaultClient returns an HTTP Client that uses the +// DefaultTokenSource to obtain authentication credentials. +// +// This client should be used when developing services +// that run on Google App Engine or Google Compute Engine +// and use "Application Default Credentials." +// +// For more details, see: +// https://developers.google.com/accounts/docs/application-default-credentials +// +func DefaultClient(ctx context.Context, scope ...string) (*http.Client, error) { + ts, err := DefaultTokenSource(ctx, scope...) + if err != nil { + return nil, err + } + return oauth2.NewClient(ctx, ts), nil +} + +// DefaultTokenSource is a token source that uses +// "Application Default Credentials". +// +// It looks for credentials in the following places, +// preferring the first location found: +// +// 1. A JSON file whose path is specified by the +// GOOGLE_APPLICATION_CREDENTIALS environment variable. +// 2. A JSON file in a location known to the gcloud command-line tool. +// On Windows, this is %APPDATA%/gcloud/application_default_credentials.json. +// On other systems, $HOME/.config/gcloud/application_default_credentials.json. +// 3. On Google App Engine it uses the appengine.AccessToken function. +// 4. On Google Compute Engine and Google App Engine Managed VMs, it fetches +// credentials from the metadata server. +// (In this final case any provided scopes are ignored.) +// +// For more details, see: +// https://developers.google.com/accounts/docs/application-default-credentials +// +func DefaultTokenSource(ctx context.Context, scope ...string) (oauth2.TokenSource, error) { + // First, try the environment variable. + const envVar = "GOOGLE_APPLICATION_CREDENTIALS" + if filename := os.Getenv(envVar); filename != "" { + ts, err := tokenSourceFromFile(ctx, filename, scope) + if err != nil { + return nil, fmt.Errorf("google: error getting credentials using %v environment variable: %v", envVar, err) + } + return ts, nil + } + + // Second, try a well-known file. + filename := wellKnownFile() + _, err := os.Stat(filename) + if err == nil { + ts, err2 := tokenSourceFromFile(ctx, filename, scope) + if err2 == nil { + return ts, nil + } + err = err2 + } else if os.IsNotExist(err) { + err = nil // ignore this error + } + if err != nil { + return nil, fmt.Errorf("google: error getting credentials using well-known file (%v): %v", filename, err) + } + + // Third, if we're on Google App Engine use those credentials. + if appengineTokenFunc != nil && !appengineVM { + return AppEngineTokenSource(ctx, scope...), nil + } + + // Fourth, if we're on Google Compute Engine use the metadata server. + if metadata.OnGCE() { + return ComputeTokenSource(""), nil + } + + // None are found; return helpful error. + const url = "https://developers.google.com/accounts/docs/application-default-credentials" + return nil, fmt.Errorf("google: could not find default credentials. See %v for more information.", url) +} + +func wellKnownFile() string { + const f = "application_default_credentials.json" + if runtime.GOOS == "windows" { + return filepath.Join(os.Getenv("APPDATA"), "gcloud", f) + } + return filepath.Join(guessUnixHomeDir(), ".config", "gcloud", f) +} + +func tokenSourceFromFile(ctx context.Context, filename string, scopes []string) (oauth2.TokenSource, error) { + b, err := ioutil.ReadFile(filename) + if err != nil { + return nil, err + } + var d struct { + // Common fields + Type string + ClientID string `json:"client_id"` + + // User Credential fields + ClientSecret string `json:"client_secret"` + RefreshToken string `json:"refresh_token"` + + // Service Account fields + ClientEmail string `json:"client_email"` + PrivateKeyID string `json:"private_key_id"` + PrivateKey string `json:"private_key"` + } + if err := json.Unmarshal(b, &d); err != nil { + return nil, err + } + switch d.Type { + case "authorized_user": + cfg := &oauth2.Config{ + ClientID: d.ClientID, + ClientSecret: d.ClientSecret, + Scopes: append([]string{}, scopes...), // copy + Endpoint: Endpoint, + } + tok := &oauth2.Token{RefreshToken: d.RefreshToken} + return cfg.TokenSource(ctx, tok), nil + case "service_account": + cfg := &jwt.Config{ + Email: d.ClientEmail, + PrivateKey: []byte(d.PrivateKey), + Scopes: append([]string{}, scopes...), // copy + TokenURL: JWTTokenURL, + } + return cfg.TokenSource(ctx), nil + case "": + return nil, errors.New("missing 'type' field in credentials") + default: + return nil, fmt.Errorf("unknown credential type: %q", d.Type) + } +} diff --git a/vendor/golang.org/x/oauth2/google/google.go b/vendor/golang.org/x/oauth2/google/google.go new file mode 100644 index 00000000..82399b09 --- /dev/null +++ b/vendor/golang.org/x/oauth2/google/google.go @@ -0,0 +1,149 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package google provides support for making OAuth2 authorized and +// authenticated HTTP requests to Google APIs. +// It supports the Web server flow, client-side credentials, service accounts, +// Google Compute Engine service accounts, and Google App Engine service +// accounts. +// +// For more information, please read +// https://developers.google.com/accounts/docs/OAuth2 +// and +// https://developers.google.com/accounts/docs/application-default-credentials. +package google // import "golang.org/x/oauth2/google" + +import ( + "encoding/json" + "errors" + "fmt" + "strings" + "time" + + "cloud.google.com/go/compute/metadata" + "golang.org/x/oauth2" + "golang.org/x/oauth2/jwt" +) + +// Endpoint is Google's OAuth 2.0 endpoint. +var Endpoint = oauth2.Endpoint{ + AuthURL: "https://accounts.google.com/o/oauth2/auth", + TokenURL: "https://accounts.google.com/o/oauth2/token", +} + +// JWTTokenURL is Google's OAuth 2.0 token URL to use with the JWT flow. +const JWTTokenURL = "https://accounts.google.com/o/oauth2/token" + +// ConfigFromJSON uses a Google Developers Console client_credentials.json +// file to construct a config. +// client_credentials.json can be downloaded from +// https://console.developers.google.com, under "Credentials". Download the Web +// application credentials in the JSON format and provide the contents of the +// file as jsonKey. +func ConfigFromJSON(jsonKey []byte, scope ...string) (*oauth2.Config, error) { + type cred struct { + ClientID string `json:"client_id"` + ClientSecret string `json:"client_secret"` + RedirectURIs []string `json:"redirect_uris"` + AuthURI string `json:"auth_uri"` + TokenURI string `json:"token_uri"` + } + var j struct { + Web *cred `json:"web"` + Installed *cred `json:"installed"` + } + if err := json.Unmarshal(jsonKey, &j); err != nil { + return nil, err + } + var c *cred + switch { + case j.Web != nil: + c = j.Web + case j.Installed != nil: + c = j.Installed + default: + return nil, fmt.Errorf("oauth2/google: no credentials found") + } + if len(c.RedirectURIs) < 1 { + return nil, errors.New("oauth2/google: missing redirect URL in the client_credentials.json") + } + return &oauth2.Config{ + ClientID: c.ClientID, + ClientSecret: c.ClientSecret, + RedirectURL: c.RedirectURIs[0], + Scopes: scope, + Endpoint: oauth2.Endpoint{ + AuthURL: c.AuthURI, + TokenURL: c.TokenURI, + }, + }, nil +} + +// JWTConfigFromJSON uses a Google Developers service account JSON key file to read +// the credentials that authorize and authenticate the requests. +// Create a service account on "Credentials" for your project at +// https://console.developers.google.com to download a JSON key file. +func JWTConfigFromJSON(jsonKey []byte, scope ...string) (*jwt.Config, error) { + var key struct { + Email string `json:"client_email"` + PrivateKey string `json:"private_key"` + PrivateKeyID string `json:"private_key_id"` + } + if err := json.Unmarshal(jsonKey, &key); err != nil { + return nil, err + } + config := &jwt.Config{ + Email: key.Email, + PrivateKey: []byte(key.PrivateKey), + PrivateKeyID: key.PrivateKeyID, + Scopes: scope, + TokenURL: JWTTokenURL, + } + return config, nil +} + +// ComputeTokenSource returns a token source that fetches access tokens +// from Google Compute Engine (GCE)'s metadata server. It's only valid to use +// this token source if your program is running on a GCE instance. +// If no account is specified, "default" is used. +// Further information about retrieving access tokens from the GCE metadata +// server can be found at https://cloud.google.com/compute/docs/authentication. +func ComputeTokenSource(account string) oauth2.TokenSource { + return oauth2.ReuseTokenSource(nil, computeSource{account: account}) +} + +type computeSource struct { + account string +} + +func (cs computeSource) Token() (*oauth2.Token, error) { + if !metadata.OnGCE() { + return nil, errors.New("oauth2/google: can't get a token from the metadata service; not running on GCE") + } + acct := cs.account + if acct == "" { + acct = "default" + } + tokenJSON, err := metadata.Get("instance/service-accounts/" + acct + "/token") + if err != nil { + return nil, err + } + var res struct { + AccessToken string `json:"access_token"` + ExpiresInSec int `json:"expires_in"` + TokenType string `json:"token_type"` + } + err = json.NewDecoder(strings.NewReader(tokenJSON)).Decode(&res) + if err != nil { + return nil, fmt.Errorf("oauth2/google: invalid token JSON from metadata: %v", err) + } + if res.ExpiresInSec == 0 || res.AccessToken == "" { + return nil, fmt.Errorf("oauth2/google: incomplete token received from metadata") + } + return &oauth2.Token{ + AccessToken: res.AccessToken, + TokenType: res.TokenType, + Expiry: time.Now().Add(time.Duration(res.ExpiresInSec) * time.Second), + }, nil +} diff --git a/vendor/golang.org/x/oauth2/google/jwt.go b/vendor/golang.org/x/oauth2/google/jwt.go new file mode 100644 index 00000000..b0fdb3a8 --- /dev/null +++ b/vendor/golang.org/x/oauth2/google/jwt.go @@ -0,0 +1,74 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package google + +import ( + "crypto/rsa" + "fmt" + "time" + + "golang.org/x/oauth2" + "golang.org/x/oauth2/internal" + "golang.org/x/oauth2/jws" +) + +// JWTAccessTokenSourceFromJSON uses a Google Developers service account JSON +// key file to read the credentials that authorize and authenticate the +// requests, and returns a TokenSource that does not use any OAuth2 flow but +// instead creates a JWT and sends that as the access token. +// The audience is typically a URL that specifies the scope of the credentials. +// +// Note that this is not a standard OAuth flow, but rather an +// optimization supported by a few Google services. +// Unless you know otherwise, you should use JWTConfigFromJSON instead. +func JWTAccessTokenSourceFromJSON(jsonKey []byte, audience string) (oauth2.TokenSource, error) { + cfg, err := JWTConfigFromJSON(jsonKey) + if err != nil { + return nil, fmt.Errorf("google: could not parse JSON key: %v", err) + } + pk, err := internal.ParseKey(cfg.PrivateKey) + if err != nil { + return nil, fmt.Errorf("google: could not parse key: %v", err) + } + ts := &jwtAccessTokenSource{ + email: cfg.Email, + audience: audience, + pk: pk, + pkID: cfg.PrivateKeyID, + } + tok, err := ts.Token() + if err != nil { + return nil, err + } + return oauth2.ReuseTokenSource(tok, ts), nil +} + +type jwtAccessTokenSource struct { + email, audience string + pk *rsa.PrivateKey + pkID string +} + +func (ts *jwtAccessTokenSource) Token() (*oauth2.Token, error) { + iat := time.Now() + exp := iat.Add(time.Hour) + cs := &jws.ClaimSet{ + Iss: ts.email, + Sub: ts.email, + Aud: ts.audience, + Iat: iat.Unix(), + Exp: exp.Unix(), + } + hdr := &jws.Header{ + Algorithm: "RS256", + Typ: "JWT", + KeyID: string(ts.pkID), + } + msg, err := jws.Encode(hdr, cs, ts.pk) + if err != nil { + return nil, fmt.Errorf("google: could not encode JWT: %v", err) + } + return &oauth2.Token{AccessToken: msg, TokenType: "Bearer", Expiry: exp}, nil +} diff --git a/vendor/golang.org/x/oauth2/google/sdk.go b/vendor/golang.org/x/oauth2/google/sdk.go new file mode 100644 index 00000000..d29a3bb9 --- /dev/null +++ b/vendor/golang.org/x/oauth2/google/sdk.go @@ -0,0 +1,168 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package google + +import ( + "encoding/json" + "errors" + "fmt" + "net/http" + "os" + "os/user" + "path/filepath" + "runtime" + "strings" + "time" + + "golang.org/x/net/context" + "golang.org/x/oauth2" + "golang.org/x/oauth2/internal" +) + +type sdkCredentials struct { + Data []struct { + Credential struct { + ClientID string `json:"client_id"` + ClientSecret string `json:"client_secret"` + AccessToken string `json:"access_token"` + RefreshToken string `json:"refresh_token"` + TokenExpiry *time.Time `json:"token_expiry"` + } `json:"credential"` + Key struct { + Account string `json:"account"` + Scope string `json:"scope"` + } `json:"key"` + } +} + +// An SDKConfig provides access to tokens from an account already +// authorized via the Google Cloud SDK. +type SDKConfig struct { + conf oauth2.Config + initialToken *oauth2.Token +} + +// NewSDKConfig creates an SDKConfig for the given Google Cloud SDK +// account. If account is empty, the account currently active in +// Google Cloud SDK properties is used. +// Google Cloud SDK credentials must be created by running `gcloud auth` +// before using this function. +// The Google Cloud SDK is available at https://cloud.google.com/sdk/. +func NewSDKConfig(account string) (*SDKConfig, error) { + configPath, err := sdkConfigPath() + if err != nil { + return nil, fmt.Errorf("oauth2/google: error getting SDK config path: %v", err) + } + credentialsPath := filepath.Join(configPath, "credentials") + f, err := os.Open(credentialsPath) + if err != nil { + return nil, fmt.Errorf("oauth2/google: failed to load SDK credentials: %v", err) + } + defer f.Close() + + var c sdkCredentials + if err := json.NewDecoder(f).Decode(&c); err != nil { + return nil, fmt.Errorf("oauth2/google: failed to decode SDK credentials from %q: %v", credentialsPath, err) + } + if len(c.Data) == 0 { + return nil, fmt.Errorf("oauth2/google: no credentials found in %q, run `gcloud auth login` to create one", credentialsPath) + } + if account == "" { + propertiesPath := filepath.Join(configPath, "properties") + f, err := os.Open(propertiesPath) + if err != nil { + return nil, fmt.Errorf("oauth2/google: failed to load SDK properties: %v", err) + } + defer f.Close() + ini, err := internal.ParseINI(f) + if err != nil { + return nil, fmt.Errorf("oauth2/google: failed to parse SDK properties %q: %v", propertiesPath, err) + } + core, ok := ini["core"] + if !ok { + return nil, fmt.Errorf("oauth2/google: failed to find [core] section in %v", ini) + } + active, ok := core["account"] + if !ok { + return nil, fmt.Errorf("oauth2/google: failed to find %q attribute in %v", "account", core) + } + account = active + } + + for _, d := range c.Data { + if account == "" || d.Key.Account == account { + if d.Credential.AccessToken == "" && d.Credential.RefreshToken == "" { + return nil, fmt.Errorf("oauth2/google: no token available for account %q", account) + } + var expiry time.Time + if d.Credential.TokenExpiry != nil { + expiry = *d.Credential.TokenExpiry + } + return &SDKConfig{ + conf: oauth2.Config{ + ClientID: d.Credential.ClientID, + ClientSecret: d.Credential.ClientSecret, + Scopes: strings.Split(d.Key.Scope, " "), + Endpoint: Endpoint, + RedirectURL: "oob", + }, + initialToken: &oauth2.Token{ + AccessToken: d.Credential.AccessToken, + RefreshToken: d.Credential.RefreshToken, + Expiry: expiry, + }, + }, nil + } + } + return nil, fmt.Errorf("oauth2/google: no such credentials for account %q", account) +} + +// Client returns an HTTP client using Google Cloud SDK credentials to +// authorize requests. The token will auto-refresh as necessary. The +// underlying http.RoundTripper will be obtained using the provided +// context. The returned client and its Transport should not be +// modified. +func (c *SDKConfig) Client(ctx context.Context) *http.Client { + return &http.Client{ + Transport: &oauth2.Transport{ + Source: c.TokenSource(ctx), + }, + } +} + +// TokenSource returns an oauth2.TokenSource that retrieve tokens from +// Google Cloud SDK credentials using the provided context. +// It will returns the current access token stored in the credentials, +// and refresh it when it expires, but it won't update the credentials +// with the new access token. +func (c *SDKConfig) TokenSource(ctx context.Context) oauth2.TokenSource { + return c.conf.TokenSource(ctx, c.initialToken) +} + +// Scopes are the OAuth 2.0 scopes the current account is authorized for. +func (c *SDKConfig) Scopes() []string { + return c.conf.Scopes +} + +// sdkConfigPath tries to guess where the gcloud config is located. +// It can be overridden during tests. +var sdkConfigPath = func() (string, error) { + if runtime.GOOS == "windows" { + return filepath.Join(os.Getenv("APPDATA"), "gcloud"), nil + } + homeDir := guessUnixHomeDir() + if homeDir == "" { + return "", errors.New("unable to get current user home directory: os/user lookup failed; $HOME is empty") + } + return filepath.Join(homeDir, ".config", "gcloud"), nil +} + +func guessUnixHomeDir() string { + usr, err := user.Current() + if err == nil { + return usr.HomeDir + } + return os.Getenv("HOME") +} diff --git a/vendor/golang.org/x/oauth2/internal/oauth2.go b/vendor/golang.org/x/oauth2/internal/oauth2.go new file mode 100644 index 00000000..fbe1028d --- /dev/null +++ b/vendor/golang.org/x/oauth2/internal/oauth2.go @@ -0,0 +1,76 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package internal contains support packages for oauth2 package. +package internal + +import ( + "bufio" + "crypto/rsa" + "crypto/x509" + "encoding/pem" + "errors" + "fmt" + "io" + "strings" +) + +// ParseKey converts the binary contents of a private key file +// to an *rsa.PrivateKey. It detects whether the private key is in a +// PEM container or not. If so, it extracts the the private key +// from PEM container before conversion. It only supports PEM +// containers with no passphrase. +func ParseKey(key []byte) (*rsa.PrivateKey, error) { + block, _ := pem.Decode(key) + if block != nil { + key = block.Bytes + } + parsedKey, err := x509.ParsePKCS8PrivateKey(key) + if err != nil { + parsedKey, err = x509.ParsePKCS1PrivateKey(key) + if err != nil { + return nil, fmt.Errorf("private key should be a PEM or plain PKSC1 or PKCS8; parse error: %v", err) + } + } + parsed, ok := parsedKey.(*rsa.PrivateKey) + if !ok { + return nil, errors.New("private key is invalid") + } + return parsed, nil +} + +func ParseINI(ini io.Reader) (map[string]map[string]string, error) { + result := map[string]map[string]string{ + "": map[string]string{}, // root section + } + scanner := bufio.NewScanner(ini) + currentSection := "" + for scanner.Scan() { + line := strings.TrimSpace(scanner.Text()) + if strings.HasPrefix(line, ";") { + // comment. + continue + } + if strings.HasPrefix(line, "[") && strings.HasSuffix(line, "]") { + currentSection = strings.TrimSpace(line[1 : len(line)-1]) + result[currentSection] = map[string]string{} + continue + } + parts := strings.SplitN(line, "=", 2) + if len(parts) == 2 && parts[0] != "" { + result[currentSection][strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1]) + } + } + if err := scanner.Err(); err != nil { + return nil, fmt.Errorf("error scanning ini: %v", err) + } + return result, nil +} + +func CondVal(v string) []string { + if v == "" { + return nil + } + return []string{v} +} diff --git a/vendor/golang.org/x/oauth2/internal/token.go b/vendor/golang.org/x/oauth2/internal/token.go new file mode 100644 index 00000000..18328a0d --- /dev/null +++ b/vendor/golang.org/x/oauth2/internal/token.go @@ -0,0 +1,225 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package internal contains support packages for oauth2 package. +package internal + +import ( + "encoding/json" + "fmt" + "io" + "io/ioutil" + "mime" + "net/http" + "net/url" + "strconv" + "strings" + "time" + + "golang.org/x/net/context" +) + +// Token represents the crendentials used to authorize +// the requests to access protected resources on the OAuth 2.0 +// provider's backend. +// +// This type is a mirror of oauth2.Token and exists to break +// an otherwise-circular dependency. Other internal packages +// should convert this Token into an oauth2.Token before use. +type Token struct { + // AccessToken is the token that authorizes and authenticates + // the requests. + AccessToken string + + // TokenType is the type of token. + // The Type method returns either this or "Bearer", the default. + TokenType string + + // RefreshToken is a token that's used by the application + // (as opposed to the user) to refresh the access token + // if it expires. + RefreshToken string + + // Expiry is the optional expiration time of the access token. + // + // If zero, TokenSource implementations will reuse the same + // token forever and RefreshToken or equivalent + // mechanisms for that TokenSource will not be used. + Expiry time.Time + + // Raw optionally contains extra metadata from the server + // when updating a token. + Raw interface{} +} + +// tokenJSON is the struct representing the HTTP response from OAuth2 +// providers returning a token in JSON form. +type tokenJSON struct { + AccessToken string `json:"access_token"` + TokenType string `json:"token_type"` + RefreshToken string `json:"refresh_token"` + ExpiresIn expirationTime `json:"expires_in"` // at least PayPal returns string, while most return number + Expires expirationTime `json:"expires"` // broken Facebook spelling of expires_in +} + +func (e *tokenJSON) expiry() (t time.Time) { + if v := e.ExpiresIn; v != 0 { + return time.Now().Add(time.Duration(v) * time.Second) + } + if v := e.Expires; v != 0 { + return time.Now().Add(time.Duration(v) * time.Second) + } + return +} + +type expirationTime int32 + +func (e *expirationTime) UnmarshalJSON(b []byte) error { + var n json.Number + err := json.Unmarshal(b, &n) + if err != nil { + return err + } + i, err := n.Int64() + if err != nil { + return err + } + *e = expirationTime(i) + return nil +} + +var brokenAuthHeaderProviders = []string{ + "https://accounts.google.com/", + "https://api.dropbox.com/", + "https://api.dropboxapi.com/", + "https://api.instagram.com/", + "https://api.netatmo.net/", + "https://api.odnoklassniki.ru/", + "https://api.pushbullet.com/", + "https://api.soundcloud.com/", + "https://api.twitch.tv/", + "https://app.box.com/", + "https://connect.stripe.com/", + "https://login.microsoftonline.com/", + "https://login.salesforce.com/", + "https://oauth.sandbox.trainingpeaks.com/", + "https://oauth.trainingpeaks.com/", + "https://oauth.vk.com/", + "https://openapi.baidu.com/", + "https://slack.com/", + "https://test-sandbox.auth.corp.google.com", + "https://test.salesforce.com/", + "https://user.gini.net/", + "https://www.douban.com/", + "https://www.googleapis.com/", + "https://www.linkedin.com/", + "https://www.strava.com/oauth/", + "https://www.wunderlist.com/oauth/", + "https://api.patreon.com/", +} + +func RegisterBrokenAuthHeaderProvider(tokenURL string) { + brokenAuthHeaderProviders = append(brokenAuthHeaderProviders, tokenURL) +} + +// providerAuthHeaderWorks reports whether the OAuth2 server identified by the tokenURL +// implements the OAuth2 spec correctly +// See https://code.google.com/p/goauth2/issues/detail?id=31 for background. +// In summary: +// - Reddit only accepts client secret in the Authorization header +// - Dropbox accepts either it in URL param or Auth header, but not both. +// - Google only accepts URL param (not spec compliant?), not Auth header +// - Stripe only accepts client secret in Auth header with Bearer method, not Basic +func providerAuthHeaderWorks(tokenURL string) bool { + for _, s := range brokenAuthHeaderProviders { + if strings.HasPrefix(tokenURL, s) { + // Some sites fail to implement the OAuth2 spec fully. + return false + } + } + + // Assume the provider implements the spec properly + // otherwise. We can add more exceptions as they're + // discovered. We will _not_ be adding configurable hooks + // to this package to let users select server bugs. + return true +} + +func RetrieveToken(ctx context.Context, clientID, clientSecret, tokenURL string, v url.Values) (*Token, error) { + hc, err := ContextClient(ctx) + if err != nil { + return nil, err + } + v.Set("client_id", clientID) + bustedAuth := !providerAuthHeaderWorks(tokenURL) + if bustedAuth && clientSecret != "" { + v.Set("client_secret", clientSecret) + } + req, err := http.NewRequest("POST", tokenURL, strings.NewReader(v.Encode())) + if err != nil { + return nil, err + } + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + if !bustedAuth { + req.SetBasicAuth(clientID, clientSecret) + } + r, err := hc.Do(req) + if err != nil { + return nil, err + } + defer r.Body.Close() + body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1<<20)) + if err != nil { + return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err) + } + if code := r.StatusCode; code < 200 || code > 299 { + return nil, fmt.Errorf("oauth2: cannot fetch token: %v\nResponse: %s", r.Status, body) + } + + var token *Token + content, _, _ := mime.ParseMediaType(r.Header.Get("Content-Type")) + switch content { + case "application/x-www-form-urlencoded", "text/plain": + vals, err := url.ParseQuery(string(body)) + if err != nil { + return nil, err + } + token = &Token{ + AccessToken: vals.Get("access_token"), + TokenType: vals.Get("token_type"), + RefreshToken: vals.Get("refresh_token"), + Raw: vals, + } + e := vals.Get("expires_in") + if e == "" { + // TODO(jbd): Facebook's OAuth2 implementation is broken and + // returns expires_in field in expires. Remove the fallback to expires, + // when Facebook fixes their implementation. + e = vals.Get("expires") + } + expires, _ := strconv.Atoi(e) + if expires != 0 { + token.Expiry = time.Now().Add(time.Duration(expires) * time.Second) + } + default: + var tj tokenJSON + if err = json.Unmarshal(body, &tj); err != nil { + return nil, err + } + token = &Token{ + AccessToken: tj.AccessToken, + TokenType: tj.TokenType, + RefreshToken: tj.RefreshToken, + Expiry: tj.expiry(), + Raw: make(map[string]interface{}), + } + json.Unmarshal(body, &token.Raw) // no error checks for optional fields + } + // Don't overwrite `RefreshToken` with an empty value + // if this was a token refreshing request. + if token.RefreshToken == "" { + token.RefreshToken = v.Get("refresh_token") + } + return token, nil +} diff --git a/vendor/golang.org/x/oauth2/internal/transport.go b/vendor/golang.org/x/oauth2/internal/transport.go new file mode 100644 index 00000000..f1f173e3 --- /dev/null +++ b/vendor/golang.org/x/oauth2/internal/transport.go @@ -0,0 +1,69 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package internal contains support packages for oauth2 package. +package internal + +import ( + "net/http" + + "golang.org/x/net/context" +) + +// HTTPClient is the context key to use with golang.org/x/net/context's +// WithValue function to associate an *http.Client value with a context. +var HTTPClient ContextKey + +// ContextKey is just an empty struct. It exists so HTTPClient can be +// an immutable public variable with a unique type. It's immutable +// because nobody else can create a ContextKey, being unexported. +type ContextKey struct{} + +// ContextClientFunc is a func which tries to return an *http.Client +// given a Context value. If it returns an error, the search stops +// with that error. If it returns (nil, nil), the search continues +// down the list of registered funcs. +type ContextClientFunc func(context.Context) (*http.Client, error) + +var contextClientFuncs []ContextClientFunc + +func RegisterContextClientFunc(fn ContextClientFunc) { + contextClientFuncs = append(contextClientFuncs, fn) +} + +func ContextClient(ctx context.Context) (*http.Client, error) { + if ctx != nil { + if hc, ok := ctx.Value(HTTPClient).(*http.Client); ok { + return hc, nil + } + } + for _, fn := range contextClientFuncs { + c, err := fn(ctx) + if err != nil { + return nil, err + } + if c != nil { + return c, nil + } + } + return http.DefaultClient, nil +} + +func ContextTransport(ctx context.Context) http.RoundTripper { + hc, err := ContextClient(ctx) + // This is a rare error case (somebody using nil on App Engine). + if err != nil { + return ErrorTransport{err} + } + return hc.Transport +} + +// ErrorTransport returns the specified error on RoundTrip. +// This RoundTripper should be used in rare error cases where +// error handling can be postponed to response handling time. +type ErrorTransport struct{ Err error } + +func (t ErrorTransport) RoundTrip(*http.Request) (*http.Response, error) { + return nil, t.Err +} diff --git a/vendor/golang.org/x/oauth2/jws/jws.go b/vendor/golang.org/x/oauth2/jws/jws.go new file mode 100644 index 00000000..c6bb7f62 --- /dev/null +++ b/vendor/golang.org/x/oauth2/jws/jws.go @@ -0,0 +1,174 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package jws provides encoding and decoding utilities for +// signed JWS messages. +package jws // import "golang.org/x/oauth2/jws" + +import ( + "bytes" + "crypto" + "crypto/rand" + "crypto/rsa" + "crypto/sha256" + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "strings" + "time" +) + +// ClaimSet contains information about the JWT signature including the +// permissions being requested (scopes), the target of the token, the issuer, +// the time the token was issued, and the lifetime of the token. +type ClaimSet struct { + Iss string `json:"iss"` // email address of the client_id of the application making the access token request + Scope string `json:"scope,omitempty"` // space-delimited list of the permissions the application requests + Aud string `json:"aud"` // descriptor of the intended target of the assertion (Optional). + Exp int64 `json:"exp"` // the expiration time of the assertion (seconds since Unix epoch) + Iat int64 `json:"iat"` // the time the assertion was issued (seconds since Unix epoch) + Typ string `json:"typ,omitempty"` // token type (Optional). + + // Email for which the application is requesting delegated access (Optional). + Sub string `json:"sub,omitempty"` + + // The old name of Sub. Client keeps setting Prn to be + // complaint with legacy OAuth 2.0 providers. (Optional) + Prn string `json:"prn,omitempty"` + + // See http://tools.ietf.org/html/draft-jones-json-web-token-10#section-4.3 + // This array is marshalled using custom code (see (c *ClaimSet) encode()). + PrivateClaims map[string]interface{} `json:"-"` +} + +func (c *ClaimSet) encode() (string, error) { + // Reverting time back for machines whose time is not perfectly in sync. + // If client machine's time is in the future according + // to Google servers, an access token will not be issued. + now := time.Now().Add(-10 * time.Second) + if c.Iat == 0 { + c.Iat = now.Unix() + } + if c.Exp == 0 { + c.Exp = now.Add(time.Hour).Unix() + } + if c.Exp < c.Iat { + return "", fmt.Errorf("jws: invalid Exp = %v; must be later than Iat = %v", c.Exp, c.Iat) + } + + b, err := json.Marshal(c) + if err != nil { + return "", err + } + + if len(c.PrivateClaims) == 0 { + return base64.RawURLEncoding.EncodeToString(b), nil + } + + // Marshal private claim set and then append it to b. + prv, err := json.Marshal(c.PrivateClaims) + if err != nil { + return "", fmt.Errorf("jws: invalid map of private claims %v", c.PrivateClaims) + } + + // Concatenate public and private claim JSON objects. + if !bytes.HasSuffix(b, []byte{'}'}) { + return "", fmt.Errorf("jws: invalid JSON %s", b) + } + if !bytes.HasPrefix(prv, []byte{'{'}) { + return "", fmt.Errorf("jws: invalid JSON %s", prv) + } + b[len(b)-1] = ',' // Replace closing curly brace with a comma. + b = append(b, prv[1:]...) // Append private claims. + return base64.RawURLEncoding.EncodeToString(b), nil +} + +// Header represents the header for the signed JWS payloads. +type Header struct { + // The algorithm used for signature. + Algorithm string `json:"alg"` + + // Represents the token type. + Typ string `json:"typ"` + + // The optional hint of which key is being used. + KeyID string `json:"kid,omitempty"` +} + +func (h *Header) encode() (string, error) { + b, err := json.Marshal(h) + if err != nil { + return "", err + } + return base64.RawURLEncoding.EncodeToString(b), nil +} + +// Decode decodes a claim set from a JWS payload. +func Decode(payload string) (*ClaimSet, error) { + // decode returned id token to get expiry + s := strings.Split(payload, ".") + if len(s) < 2 { + // TODO(jbd): Provide more context about the error. + return nil, errors.New("jws: invalid token received") + } + decoded, err := base64.RawURLEncoding.DecodeString(s[1]) + if err != nil { + return nil, err + } + c := &ClaimSet{} + err = json.NewDecoder(bytes.NewBuffer(decoded)).Decode(c) + return c, err +} + +// Signer returns a signature for the given data. +type Signer func(data []byte) (sig []byte, err error) + +// EncodeWithSigner encodes a header and claim set with the provided signer. +func EncodeWithSigner(header *Header, c *ClaimSet, sg Signer) (string, error) { + head, err := header.encode() + if err != nil { + return "", err + } + cs, err := c.encode() + if err != nil { + return "", err + } + ss := fmt.Sprintf("%s.%s", head, cs) + sig, err := sg([]byte(ss)) + if err != nil { + return "", err + } + return fmt.Sprintf("%s.%s", ss, base64.RawURLEncoding.EncodeToString(sig)), nil +} + +// Encode encodes a signed JWS with provided header and claim set. +// This invokes EncodeWithSigner using crypto/rsa.SignPKCS1v15 with the given RSA private key. +func Encode(header *Header, c *ClaimSet, key *rsa.PrivateKey) (string, error) { + sg := func(data []byte) (sig []byte, err error) { + h := sha256.New() + h.Write(data) + return rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, h.Sum(nil)) + } + return EncodeWithSigner(header, c, sg) +} + +// Verify tests whether the provided JWT token's signature was produced by the private key +// associated with the supplied public key. +func Verify(token string, key *rsa.PublicKey) error { + parts := strings.Split(token, ".") + if len(parts) != 3 { + return errors.New("jws: invalid token received, token must have 3 parts") + } + + signedContent := parts[0] + "." + parts[1] + signatureString, err := base64.RawURLEncoding.DecodeString(parts[2]) + if err != nil { + return err + } + + h := sha256.New() + h.Write([]byte(signedContent)) + return rsa.VerifyPKCS1v15(key, crypto.SHA256, h.Sum(nil), []byte(signatureString)) +} diff --git a/vendor/golang.org/x/oauth2/jwt/jwt.go b/vendor/golang.org/x/oauth2/jwt/jwt.go new file mode 100644 index 00000000..f4b9523e --- /dev/null +++ b/vendor/golang.org/x/oauth2/jwt/jwt.go @@ -0,0 +1,157 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package jwt implements the OAuth 2.0 JSON Web Token flow, commonly +// known as "two-legged OAuth 2.0". +// +// See: https://tools.ietf.org/html/draft-ietf-oauth-jwt-bearer-12 +package jwt + +import ( + "encoding/json" + "fmt" + "io" + "io/ioutil" + "net/http" + "net/url" + "strings" + "time" + + "golang.org/x/net/context" + "golang.org/x/oauth2" + "golang.org/x/oauth2/internal" + "golang.org/x/oauth2/jws" +) + +var ( + defaultGrantType = "urn:ietf:params:oauth:grant-type:jwt-bearer" + defaultHeader = &jws.Header{Algorithm: "RS256", Typ: "JWT"} +) + +// Config is the configuration for using JWT to fetch tokens, +// commonly known as "two-legged OAuth 2.0". +type Config struct { + // Email is the OAuth client identifier used when communicating with + // the configured OAuth provider. + Email string + + // PrivateKey contains the contents of an RSA private key or the + // contents of a PEM file that contains a private key. The provided + // private key is used to sign JWT payloads. + // PEM containers with a passphrase are not supported. + // Use the following command to convert a PKCS 12 file into a PEM. + // + // $ openssl pkcs12 -in key.p12 -out key.pem -nodes + // + PrivateKey []byte + + // PrivateKeyID contains an optional hint indicating which key is being + // used. + PrivateKeyID string + + // Subject is the optional user to impersonate. + Subject string + + // Scopes optionally specifies a list of requested permission scopes. + Scopes []string + + // TokenURL is the endpoint required to complete the 2-legged JWT flow. + TokenURL string + + // Expires optionally specifies how long the token is valid for. + Expires time.Duration +} + +// TokenSource returns a JWT TokenSource using the configuration +// in c and the HTTP client from the provided context. +func (c *Config) TokenSource(ctx context.Context) oauth2.TokenSource { + return oauth2.ReuseTokenSource(nil, jwtSource{ctx, c}) +} + +// Client returns an HTTP client wrapping the context's +// HTTP transport and adding Authorization headers with tokens +// obtained from c. +// +// The returned client and its Transport should not be modified. +func (c *Config) Client(ctx context.Context) *http.Client { + return oauth2.NewClient(ctx, c.TokenSource(ctx)) +} + +// jwtSource is a source that always does a signed JWT request for a token. +// It should typically be wrapped with a reuseTokenSource. +type jwtSource struct { + ctx context.Context + conf *Config +} + +func (js jwtSource) Token() (*oauth2.Token, error) { + pk, err := internal.ParseKey(js.conf.PrivateKey) + if err != nil { + return nil, err + } + hc := oauth2.NewClient(js.ctx, nil) + claimSet := &jws.ClaimSet{ + Iss: js.conf.Email, + Scope: strings.Join(js.conf.Scopes, " "), + Aud: js.conf.TokenURL, + } + if subject := js.conf.Subject; subject != "" { + claimSet.Sub = subject + // prn is the old name of sub. Keep setting it + // to be compatible with legacy OAuth 2.0 providers. + claimSet.Prn = subject + } + if t := js.conf.Expires; t > 0 { + claimSet.Exp = time.Now().Add(t).Unix() + } + payload, err := jws.Encode(defaultHeader, claimSet, pk) + if err != nil { + return nil, err + } + v := url.Values{} + v.Set("grant_type", defaultGrantType) + v.Set("assertion", payload) + resp, err := hc.PostForm(js.conf.TokenURL, v) + if err != nil { + return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err) + } + defer resp.Body.Close() + body, err := ioutil.ReadAll(io.LimitReader(resp.Body, 1<<20)) + if err != nil { + return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err) + } + if c := resp.StatusCode; c < 200 || c > 299 { + return nil, fmt.Errorf("oauth2: cannot fetch token: %v\nResponse: %s", resp.Status, body) + } + // tokenRes is the JSON response body. + var tokenRes struct { + AccessToken string `json:"access_token"` + TokenType string `json:"token_type"` + IDToken string `json:"id_token"` + ExpiresIn int64 `json:"expires_in"` // relative seconds from now + } + if err := json.Unmarshal(body, &tokenRes); err != nil { + return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err) + } + token := &oauth2.Token{ + AccessToken: tokenRes.AccessToken, + TokenType: tokenRes.TokenType, + } + raw := make(map[string]interface{}) + json.Unmarshal(body, &raw) // no error checks for optional fields + token = token.WithExtra(raw) + + if secs := tokenRes.ExpiresIn; secs > 0 { + token.Expiry = time.Now().Add(time.Duration(secs) * time.Second) + } + if v := tokenRes.IDToken; v != "" { + // decode returned id token to get expiry + claimSet, err := jws.Decode(v) + if err != nil { + return nil, fmt.Errorf("oauth2: error decoding JWT token: %v", err) + } + token.Expiry = time.Unix(claimSet.Exp, 0) + } + return token, nil +} diff --git a/vendor/golang.org/x/oauth2/oauth2.go b/vendor/golang.org/x/oauth2/oauth2.go new file mode 100644 index 00000000..0505263b --- /dev/null +++ b/vendor/golang.org/x/oauth2/oauth2.go @@ -0,0 +1,339 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package oauth2 provides support for making +// OAuth2 authorized and authenticated HTTP requests. +// It can additionally grant authorization with Bearer JWT. +package oauth2 // import "golang.org/x/oauth2" + +import ( + "bytes" + "errors" + "net/http" + "net/url" + "strings" + "sync" + + "golang.org/x/net/context" + "golang.org/x/oauth2/internal" +) + +// NoContext is the default context you should supply if not using +// your own context.Context (see https://golang.org/x/net/context). +var NoContext = context.TODO() + +// RegisterBrokenAuthHeaderProvider registers an OAuth2 server +// identified by the tokenURL prefix as an OAuth2 implementation +// which doesn't support the HTTP Basic authentication +// scheme to authenticate with the authorization server. +// Once a server is registered, credentials (client_id and client_secret) +// will be passed as query parameters rather than being present +// in the Authorization header. +// See https://code.google.com/p/goauth2/issues/detail?id=31 for background. +func RegisterBrokenAuthHeaderProvider(tokenURL string) { + internal.RegisterBrokenAuthHeaderProvider(tokenURL) +} + +// Config describes a typical 3-legged OAuth2 flow, with both the +// client application information and the server's endpoint URLs. +// For the client credentials 2-legged OAuth2 flow, see the clientcredentials +// package (https://golang.org/x/oauth2/clientcredentials). +type Config struct { + // ClientID is the application's ID. + ClientID string + + // ClientSecret is the application's secret. + ClientSecret string + + // Endpoint contains the resource server's token endpoint + // URLs. These are constants specific to each server and are + // often available via site-specific packages, such as + // google.Endpoint or github.Endpoint. + Endpoint Endpoint + + // RedirectURL is the URL to redirect users going through + // the OAuth flow, after the resource owner's URLs. + RedirectURL string + + // Scope specifies optional requested permissions. + Scopes []string +} + +// A TokenSource is anything that can return a token. +type TokenSource interface { + // Token returns a token or an error. + // Token must be safe for concurrent use by multiple goroutines. + // The returned Token must not be modified. + Token() (*Token, error) +} + +// Endpoint contains the OAuth 2.0 provider's authorization and token +// endpoint URLs. +type Endpoint struct { + AuthURL string + TokenURL string +} + +var ( + // AccessTypeOnline and AccessTypeOffline are options passed + // to the Options.AuthCodeURL method. They modify the + // "access_type" field that gets sent in the URL returned by + // AuthCodeURL. + // + // Online is the default if neither is specified. If your + // application needs to refresh access tokens when the user + // is not present at the browser, then use offline. This will + // result in your application obtaining a refresh token the + // first time your application exchanges an authorization + // code for a user. + AccessTypeOnline AuthCodeOption = SetAuthURLParam("access_type", "online") + AccessTypeOffline AuthCodeOption = SetAuthURLParam("access_type", "offline") + + // ApprovalForce forces the users to view the consent dialog + // and confirm the permissions request at the URL returned + // from AuthCodeURL, even if they've already done so. + ApprovalForce AuthCodeOption = SetAuthURLParam("approval_prompt", "force") +) + +// An AuthCodeOption is passed to Config.AuthCodeURL. +type AuthCodeOption interface { + setValue(url.Values) +} + +type setParam struct{ k, v string } + +func (p setParam) setValue(m url.Values) { m.Set(p.k, p.v) } + +// SetAuthURLParam builds an AuthCodeOption which passes key/value parameters +// to a provider's authorization endpoint. +func SetAuthURLParam(key, value string) AuthCodeOption { + return setParam{key, value} +} + +// AuthCodeURL returns a URL to OAuth 2.0 provider's consent page +// that asks for permissions for the required scopes explicitly. +// +// State is a token to protect the user from CSRF attacks. You must +// always provide a non-zero string and validate that it matches the +// the state query parameter on your redirect callback. +// See http://tools.ietf.org/html/rfc6749#section-10.12 for more info. +// +// Opts may include AccessTypeOnline or AccessTypeOffline, as well +// as ApprovalForce. +func (c *Config) AuthCodeURL(state string, opts ...AuthCodeOption) string { + var buf bytes.Buffer + buf.WriteString(c.Endpoint.AuthURL) + v := url.Values{ + "response_type": {"code"}, + "client_id": {c.ClientID}, + "redirect_uri": internal.CondVal(c.RedirectURL), + "scope": internal.CondVal(strings.Join(c.Scopes, " ")), + "state": internal.CondVal(state), + } + for _, opt := range opts { + opt.setValue(v) + } + if strings.Contains(c.Endpoint.AuthURL, "?") { + buf.WriteByte('&') + } else { + buf.WriteByte('?') + } + buf.WriteString(v.Encode()) + return buf.String() +} + +// PasswordCredentialsToken converts a resource owner username and password +// pair into a token. +// +// Per the RFC, this grant type should only be used "when there is a high +// degree of trust between the resource owner and the client (e.g., the client +// is part of the device operating system or a highly privileged application), +// and when other authorization grant types are not available." +// See https://tools.ietf.org/html/rfc6749#section-4.3 for more info. +// +// The HTTP client to use is derived from the context. +// If nil, http.DefaultClient is used. +func (c *Config) PasswordCredentialsToken(ctx context.Context, username, password string) (*Token, error) { + return retrieveToken(ctx, c, url.Values{ + "grant_type": {"password"}, + "username": {username}, + "password": {password}, + "scope": internal.CondVal(strings.Join(c.Scopes, " ")), + }) +} + +// Exchange converts an authorization code into a token. +// +// It is used after a resource provider redirects the user back +// to the Redirect URI (the URL obtained from AuthCodeURL). +// +// The HTTP client to use is derived from the context. +// If a client is not provided via the context, http.DefaultClient is used. +// +// The code will be in the *http.Request.FormValue("code"). Before +// calling Exchange, be sure to validate FormValue("state"). +func (c *Config) Exchange(ctx context.Context, code string) (*Token, error) { + return retrieveToken(ctx, c, url.Values{ + "grant_type": {"authorization_code"}, + "code": {code}, + "redirect_uri": internal.CondVal(c.RedirectURL), + "scope": internal.CondVal(strings.Join(c.Scopes, " ")), + }) +} + +// Client returns an HTTP client using the provided token. +// The token will auto-refresh as necessary. The underlying +// HTTP transport will be obtained using the provided context. +// The returned client and its Transport should not be modified. +func (c *Config) Client(ctx context.Context, t *Token) *http.Client { + return NewClient(ctx, c.TokenSource(ctx, t)) +} + +// TokenSource returns a TokenSource that returns t until t expires, +// automatically refreshing it as necessary using the provided context. +// +// Most users will use Config.Client instead. +func (c *Config) TokenSource(ctx context.Context, t *Token) TokenSource { + tkr := &tokenRefresher{ + ctx: ctx, + conf: c, + } + if t != nil { + tkr.refreshToken = t.RefreshToken + } + return &reuseTokenSource{ + t: t, + new: tkr, + } +} + +// tokenRefresher is a TokenSource that makes "grant_type"=="refresh_token" +// HTTP requests to renew a token using a RefreshToken. +type tokenRefresher struct { + ctx context.Context // used to get HTTP requests + conf *Config + refreshToken string +} + +// WARNING: Token is not safe for concurrent access, as it +// updates the tokenRefresher's refreshToken field. +// Within this package, it is used by reuseTokenSource which +// synchronizes calls to this method with its own mutex. +func (tf *tokenRefresher) Token() (*Token, error) { + if tf.refreshToken == "" { + return nil, errors.New("oauth2: token expired and refresh token is not set") + } + + tk, err := retrieveToken(tf.ctx, tf.conf, url.Values{ + "grant_type": {"refresh_token"}, + "refresh_token": {tf.refreshToken}, + }) + + if err != nil { + return nil, err + } + if tf.refreshToken != tk.RefreshToken { + tf.refreshToken = tk.RefreshToken + } + return tk, err +} + +// reuseTokenSource is a TokenSource that holds a single token in memory +// and validates its expiry before each call to retrieve it with +// Token. If it's expired, it will be auto-refreshed using the +// new TokenSource. +type reuseTokenSource struct { + new TokenSource // called when t is expired. + + mu sync.Mutex // guards t + t *Token +} + +// Token returns the current token if it's still valid, else will +// refresh the current token (using r.Context for HTTP client +// information) and return the new one. +func (s *reuseTokenSource) Token() (*Token, error) { + s.mu.Lock() + defer s.mu.Unlock() + if s.t.Valid() { + return s.t, nil + } + t, err := s.new.Token() + if err != nil { + return nil, err + } + s.t = t + return t, nil +} + +// StaticTokenSource returns a TokenSource that always returns the same token. +// Because the provided token t is never refreshed, StaticTokenSource is only +// useful for tokens that never expire. +func StaticTokenSource(t *Token) TokenSource { + return staticTokenSource{t} +} + +// staticTokenSource is a TokenSource that always returns the same Token. +type staticTokenSource struct { + t *Token +} + +func (s staticTokenSource) Token() (*Token, error) { + return s.t, nil +} + +// HTTPClient is the context key to use with golang.org/x/net/context's +// WithValue function to associate an *http.Client value with a context. +var HTTPClient internal.ContextKey + +// NewClient creates an *http.Client from a Context and TokenSource. +// The returned client is not valid beyond the lifetime of the context. +// +// As a special case, if src is nil, a non-OAuth2 client is returned +// using the provided context. This exists to support related OAuth2 +// packages. +func NewClient(ctx context.Context, src TokenSource) *http.Client { + if src == nil { + c, err := internal.ContextClient(ctx) + if err != nil { + return &http.Client{Transport: internal.ErrorTransport{Err: err}} + } + return c + } + return &http.Client{ + Transport: &Transport{ + Base: internal.ContextTransport(ctx), + Source: ReuseTokenSource(nil, src), + }, + } +} + +// ReuseTokenSource returns a TokenSource which repeatedly returns the +// same token as long as it's valid, starting with t. +// When its cached token is invalid, a new token is obtained from src. +// +// ReuseTokenSource is typically used to reuse tokens from a cache +// (such as a file on disk) between runs of a program, rather than +// obtaining new tokens unnecessarily. +// +// The initial token t may be nil, in which case the TokenSource is +// wrapped in a caching version if it isn't one already. This also +// means it's always safe to wrap ReuseTokenSource around any other +// TokenSource without adverse effects. +func ReuseTokenSource(t *Token, src TokenSource) TokenSource { + // Don't wrap a reuseTokenSource in itself. That would work, + // but cause an unnecessary number of mutex operations. + // Just build the equivalent one. + if rt, ok := src.(*reuseTokenSource); ok { + if t == nil { + // Just use it directly. + return rt + } + src = rt.new + } + return &reuseTokenSource{ + t: t, + new: src, + } +} diff --git a/vendor/golang.org/x/oauth2/token.go b/vendor/golang.org/x/oauth2/token.go new file mode 100644 index 00000000..7a3167f1 --- /dev/null +++ b/vendor/golang.org/x/oauth2/token.go @@ -0,0 +1,158 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package oauth2 + +import ( + "net/http" + "net/url" + "strconv" + "strings" + "time" + + "golang.org/x/net/context" + "golang.org/x/oauth2/internal" +) + +// expiryDelta determines how earlier a token should be considered +// expired than its actual expiration time. It is used to avoid late +// expirations due to client-server time mismatches. +const expiryDelta = 10 * time.Second + +// Token represents the crendentials used to authorize +// the requests to access protected resources on the OAuth 2.0 +// provider's backend. +// +// Most users of this package should not access fields of Token +// directly. They're exported mostly for use by related packages +// implementing derivative OAuth2 flows. +type Token struct { + // AccessToken is the token that authorizes and authenticates + // the requests. + AccessToken string `json:"access_token"` + + // TokenType is the type of token. + // The Type method returns either this or "Bearer", the default. + TokenType string `json:"token_type,omitempty"` + + // RefreshToken is a token that's used by the application + // (as opposed to the user) to refresh the access token + // if it expires. + RefreshToken string `json:"refresh_token,omitempty"` + + // Expiry is the optional expiration time of the access token. + // + // If zero, TokenSource implementations will reuse the same + // token forever and RefreshToken or equivalent + // mechanisms for that TokenSource will not be used. + Expiry time.Time `json:"expiry,omitempty"` + + // raw optionally contains extra metadata from the server + // when updating a token. + raw interface{} +} + +// Type returns t.TokenType if non-empty, else "Bearer". +func (t *Token) Type() string { + if strings.EqualFold(t.TokenType, "bearer") { + return "Bearer" + } + if strings.EqualFold(t.TokenType, "mac") { + return "MAC" + } + if strings.EqualFold(t.TokenType, "basic") { + return "Basic" + } + if t.TokenType != "" { + return t.TokenType + } + return "Bearer" +} + +// SetAuthHeader sets the Authorization header to r using the access +// token in t. +// +// This method is unnecessary when using Transport or an HTTP Client +// returned by this package. +func (t *Token) SetAuthHeader(r *http.Request) { + r.Header.Set("Authorization", t.Type()+" "+t.AccessToken) +} + +// WithExtra returns a new Token that's a clone of t, but using the +// provided raw extra map. This is only intended for use by packages +// implementing derivative OAuth2 flows. +func (t *Token) WithExtra(extra interface{}) *Token { + t2 := new(Token) + *t2 = *t + t2.raw = extra + return t2 +} + +// Extra returns an extra field. +// Extra fields are key-value pairs returned by the server as a +// part of the token retrieval response. +func (t *Token) Extra(key string) interface{} { + if raw, ok := t.raw.(map[string]interface{}); ok { + return raw[key] + } + + vals, ok := t.raw.(url.Values) + if !ok { + return nil + } + + v := vals.Get(key) + switch s := strings.TrimSpace(v); strings.Count(s, ".") { + case 0: // Contains no "."; try to parse as int + if i, err := strconv.ParseInt(s, 10, 64); err == nil { + return i + } + case 1: // Contains a single "."; try to parse as float + if f, err := strconv.ParseFloat(s, 64); err == nil { + return f + } + } + + return v +} + +// expired reports whether the token is expired. +// t must be non-nil. +func (t *Token) expired() bool { + if t.Expiry.IsZero() { + return false + } + return t.Expiry.Add(-expiryDelta).Before(time.Now()) +} + +// Valid reports whether t is non-nil, has an AccessToken, and is not expired. +func (t *Token) Valid() bool { + return t != nil && t.AccessToken != "" && !t.expired() +} + +// tokenFromInternal maps an *internal.Token struct into +// a *Token struct. +func tokenFromInternal(t *internal.Token) *Token { + if t == nil { + return nil + } + return &Token{ + AccessToken: t.AccessToken, + TokenType: t.TokenType, + RefreshToken: t.RefreshToken, + Expiry: t.Expiry, + raw: t.Raw, + } +} + +// retrieveToken takes a *Config and uses that to retrieve an *internal.Token. +// This token is then mapped from *internal.Token into an *oauth2.Token which is returned along +// with an error.. +func retrieveToken(ctx context.Context, c *Config, v url.Values) (*Token, error) { + tk, err := internal.RetrieveToken(ctx, c.ClientID, c.ClientSecret, c.Endpoint.TokenURL, v) + if err != nil { + return nil, err + } + return tokenFromInternal(tk), nil +} diff --git a/vendor/golang.org/x/oauth2/transport.go b/vendor/golang.org/x/oauth2/transport.go new file mode 100644 index 00000000..92ac7e25 --- /dev/null +++ b/vendor/golang.org/x/oauth2/transport.go @@ -0,0 +1,132 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package oauth2 + +import ( + "errors" + "io" + "net/http" + "sync" +) + +// Transport is an http.RoundTripper that makes OAuth 2.0 HTTP requests, +// wrapping a base RoundTripper and adding an Authorization header +// with a token from the supplied Sources. +// +// Transport is a low-level mechanism. Most code will use the +// higher-level Config.Client method instead. +type Transport struct { + // Source supplies the token to add to outgoing requests' + // Authorization headers. + Source TokenSource + + // Base is the base RoundTripper used to make HTTP requests. + // If nil, http.DefaultTransport is used. + Base http.RoundTripper + + mu sync.Mutex // guards modReq + modReq map[*http.Request]*http.Request // original -> modified +} + +// RoundTrip authorizes and authenticates the request with an +// access token. If no token exists or token is expired, +// tries to refresh/fetch a new token. +func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) { + if t.Source == nil { + return nil, errors.New("oauth2: Transport's Source is nil") + } + token, err := t.Source.Token() + if err != nil { + return nil, err + } + + req2 := cloneRequest(req) // per RoundTripper contract + token.SetAuthHeader(req2) + t.setModReq(req, req2) + res, err := t.base().RoundTrip(req2) + if err != nil { + t.setModReq(req, nil) + return nil, err + } + res.Body = &onEOFReader{ + rc: res.Body, + fn: func() { t.setModReq(req, nil) }, + } + return res, nil +} + +// CancelRequest cancels an in-flight request by closing its connection. +func (t *Transport) CancelRequest(req *http.Request) { + type canceler interface { + CancelRequest(*http.Request) + } + if cr, ok := t.base().(canceler); ok { + t.mu.Lock() + modReq := t.modReq[req] + delete(t.modReq, req) + t.mu.Unlock() + cr.CancelRequest(modReq) + } +} + +func (t *Transport) base() http.RoundTripper { + if t.Base != nil { + return t.Base + } + return http.DefaultTransport +} + +func (t *Transport) setModReq(orig, mod *http.Request) { + t.mu.Lock() + defer t.mu.Unlock() + if t.modReq == nil { + t.modReq = make(map[*http.Request]*http.Request) + } + if mod == nil { + delete(t.modReq, orig) + } else { + t.modReq[orig] = mod + } +} + +// cloneRequest returns a clone of the provided *http.Request. +// The clone is a shallow copy of the struct and its Header map. +func cloneRequest(r *http.Request) *http.Request { + // shallow copy of the struct + r2 := new(http.Request) + *r2 = *r + // deep copy of the Header + r2.Header = make(http.Header, len(r.Header)) + for k, s := range r.Header { + r2.Header[k] = append([]string(nil), s...) + } + return r2 +} + +type onEOFReader struct { + rc io.ReadCloser + fn func() +} + +func (r *onEOFReader) Read(p []byte) (n int, err error) { + n, err = r.rc.Read(p) + if err == io.EOF { + r.runFunc() + } + return +} + +func (r *onEOFReader) Close() error { + err := r.rc.Close() + r.runFunc() + return err +} + +func (r *onEOFReader) runFunc() { + if fn := r.fn; fn != nil { + fn() + r.fn = nil + } +} diff --git a/vendor/google.golang.org/api/LICENSE b/vendor/google.golang.org/api/LICENSE new file mode 100644 index 00000000..263aa7a0 --- /dev/null +++ b/vendor/google.golang.org/api/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2011 Google Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/google.golang.org/api/gensupport/backoff.go b/vendor/google.golang.org/api/gensupport/backoff.go new file mode 100644 index 00000000..13561404 --- /dev/null +++ b/vendor/google.golang.org/api/gensupport/backoff.go @@ -0,0 +1,46 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gensupport + +import ( + "math/rand" + "time" +) + +type BackoffStrategy interface { + // Pause returns the duration of the next pause and true if the operation should be + // retried, or false if no further retries should be attempted. + Pause() (time.Duration, bool) + + // Reset restores the strategy to its initial state. + Reset() +} + +// ExponentialBackoff performs exponential backoff as per https://en.wikipedia.org/wiki/Exponential_backoff. +// The initial pause time is given by Base. +// Once the total pause time exceeds Max, Pause will indicate no further retries. +type ExponentialBackoff struct { + Base time.Duration + Max time.Duration + total time.Duration + n uint +} + +func (eb *ExponentialBackoff) Pause() (time.Duration, bool) { + if eb.total > eb.Max { + return 0, false + } + + // The next pause is selected from randomly from [0, 2^n * Base). + d := time.Duration(rand.Int63n((1 << eb.n) * int64(eb.Base))) + eb.total += d + eb.n++ + return d, true +} + +func (eb *ExponentialBackoff) Reset() { + eb.n = 0 + eb.total = 0 +} diff --git a/vendor/google.golang.org/api/gensupport/buffer.go b/vendor/google.golang.org/api/gensupport/buffer.go new file mode 100644 index 00000000..99210491 --- /dev/null +++ b/vendor/google.golang.org/api/gensupport/buffer.go @@ -0,0 +1,77 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gensupport + +import ( + "bytes" + "io" + + "google.golang.org/api/googleapi" +) + +// MediaBuffer buffers data from an io.Reader to support uploading media in retryable chunks. +type MediaBuffer struct { + media io.Reader + + chunk []byte // The current chunk which is pending upload. The capacity is the chunk size. + err error // Any error generated when populating chunk by reading media. + + // The absolute position of chunk in the underlying media. + off int64 +} + +func NewMediaBuffer(media io.Reader, chunkSize int) *MediaBuffer { + return &MediaBuffer{media: media, chunk: make([]byte, 0, chunkSize)} +} + +// Chunk returns the current buffered chunk, the offset in the underlying media +// from which the chunk is drawn, and the size of the chunk. +// Successive calls to Chunk return the same chunk between calls to Next. +func (mb *MediaBuffer) Chunk() (chunk io.Reader, off int64, size int, err error) { + // There may already be data in chunk if Next has not been called since the previous call to Chunk. + if mb.err == nil && len(mb.chunk) == 0 { + mb.err = mb.loadChunk() + } + return bytes.NewReader(mb.chunk), mb.off, len(mb.chunk), mb.err +} + +// loadChunk will read from media into chunk, up to the capacity of chunk. +func (mb *MediaBuffer) loadChunk() error { + bufSize := cap(mb.chunk) + mb.chunk = mb.chunk[:bufSize] + + read := 0 + var err error + for err == nil && read < bufSize { + var n int + n, err = mb.media.Read(mb.chunk[read:]) + read += n + } + mb.chunk = mb.chunk[:read] + return err +} + +// Next advances to the next chunk, which will be returned by the next call to Chunk. +// Calls to Next without a corresponding prior call to Chunk will have no effect. +func (mb *MediaBuffer) Next() { + mb.off += int64(len(mb.chunk)) + mb.chunk = mb.chunk[0:0] +} + +type readerTyper struct { + io.Reader + googleapi.ContentTyper +} + +// ReaderAtToReader adapts a ReaderAt to be used as a Reader. +// If ra implements googleapi.ContentTyper, then the returned reader +// will also implement googleapi.ContentTyper, delegating to ra. +func ReaderAtToReader(ra io.ReaderAt, size int64) io.Reader { + r := io.NewSectionReader(ra, 0, size) + if typer, ok := ra.(googleapi.ContentTyper); ok { + return readerTyper{r, typer} + } + return r +} diff --git a/vendor/google.golang.org/api/gensupport/doc.go b/vendor/google.golang.org/api/gensupport/doc.go new file mode 100644 index 00000000..752c4b41 --- /dev/null +++ b/vendor/google.golang.org/api/gensupport/doc.go @@ -0,0 +1,10 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package gensupport is an internal implementation detail used by code +// generated by the google-api-go-generator tool. +// +// This package may be modified at any time without regard for backwards +// compatibility. It should not be used directly by API users. +package gensupport diff --git a/vendor/google.golang.org/api/gensupport/json.go b/vendor/google.golang.org/api/gensupport/json.go new file mode 100644 index 00000000..dd7bcd2e --- /dev/null +++ b/vendor/google.golang.org/api/gensupport/json.go @@ -0,0 +1,172 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gensupport + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" +) + +// MarshalJSON returns a JSON encoding of schema containing only selected fields. +// A field is selected if: +// * it has a non-empty value, or +// * its field name is present in forceSendFields, and +// * it is not a nil pointer or nil interface. +// The JSON key for each selected field is taken from the field's json: struct tag. +func MarshalJSON(schema interface{}, forceSendFields []string) ([]byte, error) { + if len(forceSendFields) == 0 { + return json.Marshal(schema) + } + + mustInclude := make(map[string]struct{}) + for _, f := range forceSendFields { + mustInclude[f] = struct{}{} + } + + dataMap, err := schemaToMap(schema, mustInclude) + if err != nil { + return nil, err + } + return json.Marshal(dataMap) +} + +func schemaToMap(schema interface{}, mustInclude map[string]struct{}) (map[string]interface{}, error) { + m := make(map[string]interface{}) + s := reflect.ValueOf(schema) + st := s.Type() + + for i := 0; i < s.NumField(); i++ { + jsonTag := st.Field(i).Tag.Get("json") + if jsonTag == "" { + continue + } + tag, err := parseJSONTag(jsonTag) + if err != nil { + return nil, err + } + if tag.ignore { + continue + } + + v := s.Field(i) + f := st.Field(i) + if !includeField(v, f, mustInclude) { + continue + } + + // nil maps are treated as empty maps. + if f.Type.Kind() == reflect.Map && v.IsNil() { + m[tag.apiName] = map[string]string{} + continue + } + + // nil slices are treated as empty slices. + if f.Type.Kind() == reflect.Slice && v.IsNil() { + m[tag.apiName] = []bool{} + continue + } + + if tag.stringFormat { + m[tag.apiName] = formatAsString(v, f.Type.Kind()) + } else { + m[tag.apiName] = v.Interface() + } + } + return m, nil +} + +// formatAsString returns a string representation of v, dereferencing it first if possible. +func formatAsString(v reflect.Value, kind reflect.Kind) string { + if kind == reflect.Ptr && !v.IsNil() { + v = v.Elem() + } + + return fmt.Sprintf("%v", v.Interface()) +} + +// jsonTag represents a restricted version of the struct tag format used by encoding/json. +// It is used to describe the JSON encoding of fields in a Schema struct. +type jsonTag struct { + apiName string + stringFormat bool + ignore bool +} + +// parseJSONTag parses a restricted version of the struct tag format used by encoding/json. +// The format of the tag must match that generated by the Schema.writeSchemaStruct method +// in the api generator. +func parseJSONTag(val string) (jsonTag, error) { + if val == "-" { + return jsonTag{ignore: true}, nil + } + + var tag jsonTag + + i := strings.Index(val, ",") + if i == -1 || val[:i] == "" { + return tag, fmt.Errorf("malformed json tag: %s", val) + } + + tag = jsonTag{ + apiName: val[:i], + } + + switch val[i+1:] { + case "omitempty": + case "omitempty,string": + tag.stringFormat = true + default: + return tag, fmt.Errorf("malformed json tag: %s", val) + } + + return tag, nil +} + +// Reports whether the struct field "f" with value "v" should be included in JSON output. +func includeField(v reflect.Value, f reflect.StructField, mustInclude map[string]struct{}) bool { + // The regular JSON encoding of a nil pointer is "null", which means "delete this field". + // Therefore, we could enable field deletion by honoring pointer fields' presence in the mustInclude set. + // However, many fields are not pointers, so there would be no way to delete these fields. + // Rather than partially supporting field deletion, we ignore mustInclude for nil pointer fields. + // Deletion will be handled by a separate mechanism. + if f.Type.Kind() == reflect.Ptr && v.IsNil() { + return false + } + + // The "any" type is represented as an interface{}. If this interface + // is nil, there is no reasonable representation to send. We ignore + // these fields, for the same reasons as given above for pointers. + if f.Type.Kind() == reflect.Interface && v.IsNil() { + return false + } + + _, ok := mustInclude[f.Name] + return ok || !isEmptyValue(v) +} + +// isEmptyValue reports whether v is the empty value for its type. This +// implementation is based on that of the encoding/json package, but its +// correctness does not depend on it being identical. What's important is that +// this function return false in situations where v should not be sent as part +// of a PATCH operation. +func isEmptyValue(v reflect.Value) bool { + switch v.Kind() { + case reflect.Array, reflect.Map, reflect.Slice, reflect.String: + return v.Len() == 0 + case reflect.Bool: + return !v.Bool() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.Interface, reflect.Ptr: + return v.IsNil() + } + return false +} diff --git a/vendor/google.golang.org/api/gensupport/media.go b/vendor/google.golang.org/api/gensupport/media.go new file mode 100644 index 00000000..c6410e89 --- /dev/null +++ b/vendor/google.golang.org/api/gensupport/media.go @@ -0,0 +1,199 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gensupport + +import ( + "fmt" + "io" + "io/ioutil" + "mime/multipart" + "net/http" + "net/textproto" + + "google.golang.org/api/googleapi" +) + +const sniffBuffSize = 512 + +func newContentSniffer(r io.Reader) *contentSniffer { + return &contentSniffer{r: r} +} + +// contentSniffer wraps a Reader, and reports the content type determined by sniffing up to 512 bytes from the Reader. +type contentSniffer struct { + r io.Reader + start []byte // buffer for the sniffed bytes. + err error // set to any error encountered while reading bytes to be sniffed. + + ctype string // set on first sniff. + sniffed bool // set to true on first sniff. +} + +func (cs *contentSniffer) Read(p []byte) (n int, err error) { + // Ensure that the content type is sniffed before any data is consumed from Reader. + _, _ = cs.ContentType() + + if len(cs.start) > 0 { + n := copy(p, cs.start) + cs.start = cs.start[n:] + return n, nil + } + + // We may have read some bytes into start while sniffing, even if the read ended in an error. + // We should first return those bytes, then the error. + if cs.err != nil { + return 0, cs.err + } + + // Now we have handled all bytes that were buffered while sniffing. Now just delegate to the underlying reader. + return cs.r.Read(p) +} + +// ContentType returns the sniffed content type, and whether the content type was succesfully sniffed. +func (cs *contentSniffer) ContentType() (string, bool) { + if cs.sniffed { + return cs.ctype, cs.ctype != "" + } + cs.sniffed = true + // If ReadAll hits EOF, it returns err==nil. + cs.start, cs.err = ioutil.ReadAll(io.LimitReader(cs.r, sniffBuffSize)) + + // Don't try to detect the content type based on possibly incomplete data. + if cs.err != nil { + return "", false + } + + cs.ctype = http.DetectContentType(cs.start) + return cs.ctype, true +} + +// DetermineContentType determines the content type of the supplied reader. +// If the content type is already known, it can be specified via ctype. +// Otherwise, the content of media will be sniffed to determine the content type. +// If media implements googleapi.ContentTyper (deprecated), this will be used +// instead of sniffing the content. +// After calling DetectContentType the caller must not perform further reads on +// media, but rather read from the Reader that is returned. +func DetermineContentType(media io.Reader, ctype string) (io.Reader, string) { + // Note: callers could avoid calling DetectContentType if ctype != "", + // but doing the check inside this function reduces the amount of + // generated code. + if ctype != "" { + return media, ctype + } + + // For backwards compatability, allow clients to set content + // type by providing a ContentTyper for media. + if typer, ok := media.(googleapi.ContentTyper); ok { + return media, typer.ContentType() + } + + sniffer := newContentSniffer(media) + if ctype, ok := sniffer.ContentType(); ok { + return sniffer, ctype + } + // If content type could not be sniffed, reads from sniffer will eventually fail with an error. + return sniffer, "" +} + +type typeReader struct { + io.Reader + typ string +} + +// multipartReader combines the contents of multiple readers to creat a multipart/related HTTP body. +// Close must be called if reads from the multipartReader are abandoned before reaching EOF. +type multipartReader struct { + pr *io.PipeReader + pipeOpen bool + ctype string +} + +func newMultipartReader(parts []typeReader) *multipartReader { + mp := &multipartReader{pipeOpen: true} + var pw *io.PipeWriter + mp.pr, pw = io.Pipe() + mpw := multipart.NewWriter(pw) + mp.ctype = "multipart/related; boundary=" + mpw.Boundary() + go func() { + for _, part := range parts { + w, err := mpw.CreatePart(typeHeader(part.typ)) + if err != nil { + mpw.Close() + pw.CloseWithError(fmt.Errorf("googleapi: CreatePart failed: %v", err)) + return + } + _, err = io.Copy(w, part.Reader) + if err != nil { + mpw.Close() + pw.CloseWithError(fmt.Errorf("googleapi: Copy failed: %v", err)) + return + } + } + + mpw.Close() + pw.Close() + }() + return mp +} + +func (mp *multipartReader) Read(data []byte) (n int, err error) { + return mp.pr.Read(data) +} + +func (mp *multipartReader) Close() error { + if !mp.pipeOpen { + return nil + } + mp.pipeOpen = false + return mp.pr.Close() +} + +// CombineBodyMedia combines a json body with media content to create a multipart/related HTTP body. +// It returns a ReadCloser containing the combined body, and the overall "multipart/related" content type, with random boundary. +// +// The caller must call Close on the returned ReadCloser if reads are abandoned before reaching EOF. +func CombineBodyMedia(body io.Reader, bodyContentType string, media io.Reader, mediaContentType string) (io.ReadCloser, string) { + mp := newMultipartReader([]typeReader{ + {body, bodyContentType}, + {media, mediaContentType}, + }) + return mp, mp.ctype +} + +func typeHeader(contentType string) textproto.MIMEHeader { + h := make(textproto.MIMEHeader) + if contentType != "" { + h.Set("Content-Type", contentType) + } + return h +} + +// PrepareUpload determines whether the data in the supplied reader should be +// uploaded in a single request, or in sequential chunks. +// chunkSize is the size of the chunk that media should be split into. +// If chunkSize is non-zero and the contents of media do not fit in a single +// chunk (or there is an error reading media), then media will be returned as a +// MediaBuffer. Otherwise, media will be returned as a Reader. +// +// After PrepareUpload has been called, media should no longer be used: the +// media content should be accessed via one of the return values. +func PrepareUpload(media io.Reader, chunkSize int) (io.Reader, *MediaBuffer) { + if chunkSize == 0 { // do not chunk + return media, nil + } + + mb := NewMediaBuffer(media, chunkSize) + rdr, _, _, err := mb.Chunk() + + if err == io.EOF { // we can upload this in a single request + return rdr, nil + } + // err might be a non-EOF error. If it is, the next call to mb.Chunk will + // return the same error. Returning a MediaBuffer ensures that this error + // will be handled at some point. + + return nil, mb +} diff --git a/vendor/google.golang.org/api/gensupport/params.go b/vendor/google.golang.org/api/gensupport/params.go new file mode 100644 index 00000000..3b3c7439 --- /dev/null +++ b/vendor/google.golang.org/api/gensupport/params.go @@ -0,0 +1,50 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gensupport + +import ( + "net/url" + + "google.golang.org/api/googleapi" +) + +// URLParams is a simplified replacement for url.Values +// that safely builds up URL parameters for encoding. +type URLParams map[string][]string + +// Get returns the first value for the given key, or "". +func (u URLParams) Get(key string) string { + vs := u[key] + if len(vs) == 0 { + return "" + } + return vs[0] +} + +// Set sets the key to value. +// It replaces any existing values. +func (u URLParams) Set(key, value string) { + u[key] = []string{value} +} + +// SetMulti sets the key to an array of values. +// It replaces any existing values. +// Note that values must not be modified after calling SetMulti +// so the caller is responsible for making a copy if necessary. +func (u URLParams) SetMulti(key string, values []string) { + u[key] = values +} + +// Encode encodes the values into ``URL encoded'' form +// ("bar=baz&foo=quux") sorted by key. +func (u URLParams) Encode() string { + return url.Values(u).Encode() +} + +func SetOptions(u URLParams, opts ...googleapi.CallOption) { + for _, o := range opts { + u.Set(o.Get()) + } +} diff --git a/vendor/google.golang.org/api/gensupport/resumable.go b/vendor/google.golang.org/api/gensupport/resumable.go new file mode 100644 index 00000000..695e365a --- /dev/null +++ b/vendor/google.golang.org/api/gensupport/resumable.go @@ -0,0 +1,199 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gensupport + +import ( + "fmt" + "io" + "net/http" + "sync" + "time" + + "golang.org/x/net/context" +) + +const ( + // statusResumeIncomplete is the code returned by the Google uploader + // when the transfer is not yet complete. + statusResumeIncomplete = 308 + + // statusTooManyRequests is returned by the storage API if the + // per-project limits have been temporarily exceeded. The request + // should be retried. + // https://cloud.google.com/storage/docs/json_api/v1/status-codes#standardcodes + statusTooManyRequests = 429 +) + +// ResumableUpload is used by the generated APIs to provide resumable uploads. +// It is not used by developers directly. +type ResumableUpload struct { + Client *http.Client + // URI is the resumable resource destination provided by the server after specifying "&uploadType=resumable". + URI string + UserAgent string // User-Agent for header of the request + // Media is the object being uploaded. + Media *MediaBuffer + // MediaType defines the media type, e.g. "image/jpeg". + MediaType string + + mu sync.Mutex // guards progress + progress int64 // number of bytes uploaded so far + + // Callback is an optional function that will be periodically called with the cumulative number of bytes uploaded. + Callback func(int64) + + // If not specified, a default exponential backoff strategy will be used. + Backoff BackoffStrategy +} + +// Progress returns the number of bytes uploaded at this point. +func (rx *ResumableUpload) Progress() int64 { + rx.mu.Lock() + defer rx.mu.Unlock() + return rx.progress +} + +// doUploadRequest performs a single HTTP request to upload data. +// off specifies the offset in rx.Media from which data is drawn. +// size is the number of bytes in data. +// final specifies whether data is the final chunk to be uploaded. +func (rx *ResumableUpload) doUploadRequest(ctx context.Context, data io.Reader, off, size int64, final bool) (*http.Response, error) { + req, err := http.NewRequest("POST", rx.URI, data) + if err != nil { + return nil, err + } + + req.ContentLength = size + var contentRange string + if final { + if size == 0 { + contentRange = fmt.Sprintf("bytes */%v", off) + } else { + contentRange = fmt.Sprintf("bytes %v-%v/%v", off, off+size-1, off+size) + } + } else { + contentRange = fmt.Sprintf("bytes %v-%v/*", off, off+size-1) + } + req.Header.Set("Content-Range", contentRange) + req.Header.Set("Content-Type", rx.MediaType) + req.Header.Set("User-Agent", rx.UserAgent) + return SendRequest(ctx, rx.Client, req) + +} + +// reportProgress calls a user-supplied callback to report upload progress. +// If old==updated, the callback is not called. +func (rx *ResumableUpload) reportProgress(old, updated int64) { + if updated-old == 0 { + return + } + rx.mu.Lock() + rx.progress = updated + rx.mu.Unlock() + if rx.Callback != nil { + rx.Callback(updated) + } +} + +// transferChunk performs a single HTTP request to upload a single chunk from rx.Media. +func (rx *ResumableUpload) transferChunk(ctx context.Context) (*http.Response, error) { + chunk, off, size, err := rx.Media.Chunk() + + done := err == io.EOF + if !done && err != nil { + return nil, err + } + + res, err := rx.doUploadRequest(ctx, chunk, off, int64(size), done) + if err != nil { + return res, err + } + + if res.StatusCode == statusResumeIncomplete || res.StatusCode == http.StatusOK { + rx.reportProgress(off, off+int64(size)) + } + + if res.StatusCode == statusResumeIncomplete { + rx.Media.Next() + } + return res, nil +} + +func contextDone(ctx context.Context) bool { + select { + case <-ctx.Done(): + return true + default: + return false + } +} + +// Upload starts the process of a resumable upload with a cancellable context. +// It retries using the provided back off strategy until cancelled or the +// strategy indicates to stop retrying. +// It is called from the auto-generated API code and is not visible to the user. +// Before sending an HTTP request, Upload calls any registered hook functions, +// and calls the returned functions after the request returns (see send.go). +// rx is private to the auto-generated API code. +// Exactly one of resp or err will be nil. If resp is non-nil, the caller must call resp.Body.Close. +func (rx *ResumableUpload) Upload(ctx context.Context) (resp *http.Response, err error) { + var pause time.Duration + backoff := rx.Backoff + if backoff == nil { + backoff = DefaultBackoffStrategy() + } + + for { + // Ensure that we return in the case of cancelled context, even if pause is 0. + if contextDone(ctx) { + return nil, ctx.Err() + } + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-time.After(pause): + } + + resp, err = rx.transferChunk(ctx) + + var status int + if resp != nil { + status = resp.StatusCode + } + + // Check if we should retry the request. + if shouldRetry(status, err) { + var retry bool + pause, retry = backoff.Pause() + if retry { + if resp != nil && resp.Body != nil { + resp.Body.Close() + } + continue + } + } + + // If the chunk was uploaded successfully, but there's still + // more to go, upload the next chunk without any delay. + if status == statusResumeIncomplete { + pause = 0 + backoff.Reset() + resp.Body.Close() + continue + } + + // It's possible for err and resp to both be non-nil here, but we expose a simpler + // contract to our callers: exactly one of resp and err will be non-nil. This means + // that any response body must be closed here before returning a non-nil error. + if err != nil { + if resp != nil && resp.Body != nil { + resp.Body.Close() + } + return nil, err + } + + return resp, nil + } +} diff --git a/vendor/google.golang.org/api/gensupport/retry.go b/vendor/google.golang.org/api/gensupport/retry.go new file mode 100644 index 00000000..7f83d1da --- /dev/null +++ b/vendor/google.golang.org/api/gensupport/retry.go @@ -0,0 +1,77 @@ +package gensupport + +import ( + "io" + "net" + "net/http" + "time" + + "golang.org/x/net/context" +) + +// Retry invokes the given function, retrying it multiple times if the connection failed or +// the HTTP status response indicates the request should be attempted again. ctx may be nil. +func Retry(ctx context.Context, f func() (*http.Response, error), backoff BackoffStrategy) (*http.Response, error) { + for { + resp, err := f() + + var status int + if resp != nil { + status = resp.StatusCode + } + + // Return if we shouldn't retry. + pause, retry := backoff.Pause() + if !shouldRetry(status, err) || !retry { + return resp, err + } + + // Ensure the response body is closed, if any. + if resp != nil && resp.Body != nil { + resp.Body.Close() + } + + // Pause, but still listen to ctx.Done if context is not nil. + var done <-chan struct{} + if ctx != nil { + done = ctx.Done() + } + select { + case <-done: + return nil, ctx.Err() + case <-time.After(pause): + } + } +} + +// DefaultBackoffStrategy returns a default strategy to use for retrying failed upload requests. +func DefaultBackoffStrategy() BackoffStrategy { + return &ExponentialBackoff{ + Base: 250 * time.Millisecond, + Max: 16 * time.Second, + } +} + +// shouldRetry returns true if the HTTP response / error indicates that the +// request should be attempted again. +func shouldRetry(status int, err error) bool { + // Retry for 5xx response codes. + if 500 <= status && status < 600 { + return true + } + + // Retry on statusTooManyRequests{ + if status == statusTooManyRequests { + return true + } + + // Retry on unexpected EOFs and temporary network errors. + if err == io.ErrUnexpectedEOF { + return true + } + if err, ok := err.(net.Error); ok { + return err.Temporary() + } + + return false +} diff --git a/vendor/google.golang.org/api/gensupport/send.go b/vendor/google.golang.org/api/gensupport/send.go new file mode 100644 index 00000000..3d22f638 --- /dev/null +++ b/vendor/google.golang.org/api/gensupport/send.go @@ -0,0 +1,55 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gensupport + +import ( + "net/http" + + "golang.org/x/net/context" + "golang.org/x/net/context/ctxhttp" +) + +// Hook is the type of a function that is called once before each HTTP request +// that is sent by a generated API. It returns a function that is called after +// the request returns. +// Hooks are not called if the context is nil. +type Hook func(ctx context.Context, req *http.Request) func(resp *http.Response) + +var hooks []Hook + +// RegisterHook registers a Hook to be called before each HTTP request by a +// generated API. Hooks are called in the order they are registered. Each +// hook can return a function; if it is non-nil, it is called after the HTTP +// request returns. These functions are called in the reverse order. +// RegisterHook should not be called concurrently with itself or SendRequest. +func RegisterHook(h Hook) { + hooks = append(hooks, h) +} + +// SendRequest sends a single HTTP request using the given client. +// If ctx is non-nil, it calls all hooks, then sends the request with +// ctxhttp.Do, then calls any functions returned by the hooks in reverse order. +func SendRequest(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) { + if ctx == nil { + return client.Do(req) + } + // Call hooks in order of registration, store returned funcs. + post := make([]func(resp *http.Response), len(hooks)) + for i, h := range hooks { + fn := h(ctx, req) + post[i] = fn + } + + // Send request. + resp, err := ctxhttp.Do(ctx, client, req) + + // Call returned funcs in reverse order. + for i := len(post) - 1; i >= 0; i-- { + if fn := post[i]; fn != nil { + fn(resp) + } + } + return resp, err +} diff --git a/vendor/google.golang.org/api/googleapi/googleapi.go b/vendor/google.golang.org/api/googleapi/googleapi.go new file mode 100644 index 00000000..67ee7768 --- /dev/null +++ b/vendor/google.golang.org/api/googleapi/googleapi.go @@ -0,0 +1,432 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package googleapi contains the common code shared by all Google API +// libraries. +package googleapi // import "google.golang.org/api/googleapi" + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "io/ioutil" + "net/http" + "net/url" + "strings" + + "google.golang.org/api/googleapi/internal/uritemplates" +) + +// ContentTyper is an interface for Readers which know (or would like +// to override) their Content-Type. If a media body doesn't implement +// ContentTyper, the type is sniffed from the content using +// http.DetectContentType. +type ContentTyper interface { + ContentType() string +} + +// A SizeReaderAt is a ReaderAt with a Size method. +// An io.SectionReader implements SizeReaderAt. +type SizeReaderAt interface { + io.ReaderAt + Size() int64 +} + +// ServerResponse is embedded in each Do response and +// provides the HTTP status code and header sent by the server. +type ServerResponse struct { + // HTTPStatusCode is the server's response status code. + // When using a resource method's Do call, this will always be in the 2xx range. + HTTPStatusCode int + // Header contains the response header fields from the server. + Header http.Header +} + +const ( + Version = "0.5" + + // UserAgent is the header string used to identify this package. + UserAgent = "google-api-go-client/" + Version + + // The default chunk size to use for resumable uplods if not specified by the user. + DefaultUploadChunkSize = 8 * 1024 * 1024 + + // The minimum chunk size that can be used for resumable uploads. All + // user-specified chunk sizes must be multiple of this value. + MinUploadChunkSize = 256 * 1024 +) + +// Error contains an error response from the server. +type Error struct { + // Code is the HTTP response status code and will always be populated. + Code int `json:"code"` + // Message is the server response message and is only populated when + // explicitly referenced by the JSON server response. + Message string `json:"message"` + // Body is the raw response returned by the server. + // It is often but not always JSON, depending on how the request fails. + Body string + // Header contains the response header fields from the server. + Header http.Header + + Errors []ErrorItem +} + +// ErrorItem is a detailed error code & message from the Google API frontend. +type ErrorItem struct { + // Reason is the typed error code. For example: "some_example". + Reason string `json:"reason"` + // Message is the human-readable description of the error. + Message string `json:"message"` +} + +func (e *Error) Error() string { + if len(e.Errors) == 0 && e.Message == "" { + return fmt.Sprintf("googleapi: got HTTP response code %d with body: %v", e.Code, e.Body) + } + var buf bytes.Buffer + fmt.Fprintf(&buf, "googleapi: Error %d: ", e.Code) + if e.Message != "" { + fmt.Fprintf(&buf, "%s", e.Message) + } + if len(e.Errors) == 0 { + return strings.TrimSpace(buf.String()) + } + if len(e.Errors) == 1 && e.Errors[0].Message == e.Message { + fmt.Fprintf(&buf, ", %s", e.Errors[0].Reason) + return buf.String() + } + fmt.Fprintln(&buf, "\nMore details:") + for _, v := range e.Errors { + fmt.Fprintf(&buf, "Reason: %s, Message: %s\n", v.Reason, v.Message) + } + return buf.String() +} + +type errorReply struct { + Error *Error `json:"error"` +} + +// CheckResponse returns an error (of type *Error) if the response +// status code is not 2xx. +func CheckResponse(res *http.Response) error { + if res.StatusCode >= 200 && res.StatusCode <= 299 { + return nil + } + slurp, err := ioutil.ReadAll(res.Body) + if err == nil { + jerr := new(errorReply) + err = json.Unmarshal(slurp, jerr) + if err == nil && jerr.Error != nil { + if jerr.Error.Code == 0 { + jerr.Error.Code = res.StatusCode + } + jerr.Error.Body = string(slurp) + return jerr.Error + } + } + return &Error{ + Code: res.StatusCode, + Body: string(slurp), + Header: res.Header, + } +} + +// IsNotModified reports whether err is the result of the +// server replying with http.StatusNotModified. +// Such error values are sometimes returned by "Do" methods +// on calls when If-None-Match is used. +func IsNotModified(err error) bool { + if err == nil { + return false + } + ae, ok := err.(*Error) + return ok && ae.Code == http.StatusNotModified +} + +// CheckMediaResponse returns an error (of type *Error) if the response +// status code is not 2xx. Unlike CheckResponse it does not assume the +// body is a JSON error document. +func CheckMediaResponse(res *http.Response) error { + if res.StatusCode >= 200 && res.StatusCode <= 299 { + return nil + } + slurp, _ := ioutil.ReadAll(io.LimitReader(res.Body, 1<<20)) + res.Body.Close() + return &Error{ + Code: res.StatusCode, + Body: string(slurp), + } +} + +type MarshalStyle bool + +var WithDataWrapper = MarshalStyle(true) +var WithoutDataWrapper = MarshalStyle(false) + +func (wrap MarshalStyle) JSONReader(v interface{}) (io.Reader, error) { + buf := new(bytes.Buffer) + if wrap { + buf.Write([]byte(`{"data": `)) + } + err := json.NewEncoder(buf).Encode(v) + if err != nil { + return nil, err + } + if wrap { + buf.Write([]byte(`}`)) + } + return buf, nil +} + +// endingWithErrorReader from r until it returns an error. If the +// final error from r is io.EOF and e is non-nil, e is used instead. +type endingWithErrorReader struct { + r io.Reader + e error +} + +func (er endingWithErrorReader) Read(p []byte) (n int, err error) { + n, err = er.r.Read(p) + if err == io.EOF && er.e != nil { + err = er.e + } + return +} + +// countingWriter counts the number of bytes it receives to write, but +// discards them. +type countingWriter struct { + n *int64 +} + +func (w countingWriter) Write(p []byte) (int, error) { + *w.n += int64(len(p)) + return len(p), nil +} + +// ProgressUpdater is a function that is called upon every progress update of a resumable upload. +// This is the only part of a resumable upload (from googleapi) that is usable by the developer. +// The remaining usable pieces of resumable uploads is exposed in each auto-generated API. +type ProgressUpdater func(current, total int64) + +type MediaOption interface { + setOptions(o *MediaOptions) +} + +type contentTypeOption string + +func (ct contentTypeOption) setOptions(o *MediaOptions) { + o.ContentType = string(ct) + if o.ContentType == "" { + o.ForceEmptyContentType = true + } +} + +// ContentType returns a MediaOption which sets the Content-Type header for media uploads. +// If ctype is empty, the Content-Type header will be omitted. +func ContentType(ctype string) MediaOption { + return contentTypeOption(ctype) +} + +type chunkSizeOption int + +func (cs chunkSizeOption) setOptions(o *MediaOptions) { + size := int(cs) + if size%MinUploadChunkSize != 0 { + size += MinUploadChunkSize - (size % MinUploadChunkSize) + } + o.ChunkSize = size +} + +// ChunkSize returns a MediaOption which sets the chunk size for media uploads. +// size will be rounded up to the nearest multiple of 256K. +// Media which contains fewer than size bytes will be uploaded in a single request. +// Media which contains size bytes or more will be uploaded in separate chunks. +// If size is zero, media will be uploaded in a single request. +func ChunkSize(size int) MediaOption { + return chunkSizeOption(size) +} + +// MediaOptions stores options for customizing media upload. It is not used by developers directly. +type MediaOptions struct { + ContentType string + ForceEmptyContentType bool + + ChunkSize int +} + +// ProcessMediaOptions stores options from opts in a MediaOptions. +// It is not used by developers directly. +func ProcessMediaOptions(opts []MediaOption) *MediaOptions { + mo := &MediaOptions{ChunkSize: DefaultUploadChunkSize} + for _, o := range opts { + o.setOptions(mo) + } + return mo +} + +func ResolveRelative(basestr, relstr string) string { + u, _ := url.Parse(basestr) + rel, _ := url.Parse(relstr) + u = u.ResolveReference(rel) + us := u.String() + us = strings.Replace(us, "%7B", "{", -1) + us = strings.Replace(us, "%7D", "}", -1) + return us +} + +// has4860Fix is whether this Go environment contains the fix for +// http://golang.org/issue/4860 +var has4860Fix bool + +// init initializes has4860Fix by checking the behavior of the net/http package. +func init() { + r := http.Request{ + URL: &url.URL{ + Scheme: "http", + Opaque: "//opaque", + }, + } + b := &bytes.Buffer{} + r.Write(b) + has4860Fix = bytes.HasPrefix(b.Bytes(), []byte("GET http")) +} + +// SetOpaque sets u.Opaque from u.Path such that HTTP requests to it +// don't alter any hex-escaped characters in u.Path. +func SetOpaque(u *url.URL) { + u.Opaque = "//" + u.Host + u.Path + if !has4860Fix { + u.Opaque = u.Scheme + ":" + u.Opaque + } +} + +// Expand subsitutes any {encoded} strings in the URL passed in using +// the map supplied. +// +// This calls SetOpaque to avoid encoding of the parameters in the URL path. +func Expand(u *url.URL, expansions map[string]string) { + expanded, err := uritemplates.Expand(u.Path, expansions) + if err == nil { + u.Path = expanded + SetOpaque(u) + } +} + +// CloseBody is used to close res.Body. +// Prior to calling Close, it also tries to Read a small amount to see an EOF. +// Not seeing an EOF can prevent HTTP Transports from reusing connections. +func CloseBody(res *http.Response) { + if res == nil || res.Body == nil { + return + } + // Justification for 3 byte reads: two for up to "\r\n" after + // a JSON/XML document, and then 1 to see EOF if we haven't yet. + // TODO(bradfitz): detect Go 1.3+ and skip these reads. + // See https://codereview.appspot.com/58240043 + // and https://codereview.appspot.com/49570044 + buf := make([]byte, 1) + for i := 0; i < 3; i++ { + _, err := res.Body.Read(buf) + if err != nil { + break + } + } + res.Body.Close() + +} + +// VariantType returns the type name of the given variant. +// If the map doesn't contain the named key or the value is not a []interface{}, "" is returned. +// This is used to support "variant" APIs that can return one of a number of different types. +func VariantType(t map[string]interface{}) string { + s, _ := t["type"].(string) + return s +} + +// ConvertVariant uses the JSON encoder/decoder to fill in the struct 'dst' with the fields found in variant 'v'. +// This is used to support "variant" APIs that can return one of a number of different types. +// It reports whether the conversion was successful. +func ConvertVariant(v map[string]interface{}, dst interface{}) bool { + var buf bytes.Buffer + err := json.NewEncoder(&buf).Encode(v) + if err != nil { + return false + } + return json.Unmarshal(buf.Bytes(), dst) == nil +} + +// A Field names a field to be retrieved with a partial response. +// See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// +// Partial responses can dramatically reduce the amount of data that must be sent to your application. +// In order to request partial responses, you can specify the full list of fields +// that your application needs by adding the Fields option to your request. +// +// Field strings use camelCase with leading lower-case characters to identify fields within the response. +// +// For example, if your response has a "NextPageToken" and a slice of "Items" with "Id" fields, +// you could request just those fields like this: +// +// svc.Events.List().Fields("nextPageToken", "items/id").Do() +// +// or if you were also interested in each Item's "Updated" field, you can combine them like this: +// +// svc.Events.List().Fields("nextPageToken", "items(id,updated)").Do() +// +// More information about field formatting can be found here: +// https://developers.google.com/+/api/#fields-syntax +// +// Another way to find field names is through the Google API explorer: +// https://developers.google.com/apis-explorer/#p/ +type Field string + +// CombineFields combines fields into a single string. +func CombineFields(s []Field) string { + r := make([]string, len(s)) + for i, v := range s { + r[i] = string(v) + } + return strings.Join(r, ",") +} + +// A CallOption is an optional argument to an API call. +// It should be treated as an opaque value by users of Google APIs. +// +// A CallOption is something that configures an API call in a way that is +// not specific to that API; for instance, controlling the quota user for +// an API call is common across many APIs, and is thus a CallOption. +type CallOption interface { + Get() (key, value string) +} + +// QuotaUser returns a CallOption that will set the quota user for a call. +// The quota user can be used by server-side applications to control accounting. +// It can be an arbitrary string up to 40 characters, and will override UserIP +// if both are provided. +func QuotaUser(u string) CallOption { return quotaUser(u) } + +type quotaUser string + +func (q quotaUser) Get() (string, string) { return "quotaUser", string(q) } + +// UserIP returns a CallOption that will set the "userIp" parameter of a call. +// This should be the IP address of the originating request. +func UserIP(ip string) CallOption { return userIP(ip) } + +type userIP string + +func (i userIP) Get() (string, string) { return "userIp", string(i) } + +// Trace returns a CallOption that enables diagnostic tracing for a call. +// traceToken is an ID supplied by Google support. +func Trace(traceToken string) CallOption { return traceTok(traceToken) } + +type traceTok string + +func (t traceTok) Get() (string, string) { return "trace", "token:" + string(t) } + +// TODO: Fields too diff --git a/vendor/google.golang.org/api/googleapi/internal/uritemplates/LICENSE b/vendor/google.golang.org/api/googleapi/internal/uritemplates/LICENSE new file mode 100644 index 00000000..de9c88cb --- /dev/null +++ b/vendor/google.golang.org/api/googleapi/internal/uritemplates/LICENSE @@ -0,0 +1,18 @@ +Copyright (c) 2013 Joshua Tacoma + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/google.golang.org/api/googleapi/internal/uritemplates/uritemplates.go b/vendor/google.golang.org/api/googleapi/internal/uritemplates/uritemplates.go new file mode 100644 index 00000000..7c103ba1 --- /dev/null +++ b/vendor/google.golang.org/api/googleapi/internal/uritemplates/uritemplates.go @@ -0,0 +1,220 @@ +// Copyright 2013 Joshua Tacoma. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package uritemplates is a level 3 implementation of RFC 6570 (URI +// Template, http://tools.ietf.org/html/rfc6570). +// uritemplates does not support composite values (in Go: slices or maps) +// and so does not qualify as a level 4 implementation. +package uritemplates + +import ( + "bytes" + "errors" + "regexp" + "strconv" + "strings" +) + +var ( + unreserved = regexp.MustCompile("[^A-Za-z0-9\\-._~]") + reserved = regexp.MustCompile("[^A-Za-z0-9\\-._~:/?#[\\]@!$&'()*+,;=]") + validname = regexp.MustCompile("^([A-Za-z0-9_\\.]|%[0-9A-Fa-f][0-9A-Fa-f])+$") + hex = []byte("0123456789ABCDEF") +) + +func pctEncode(src []byte) []byte { + dst := make([]byte, len(src)*3) + for i, b := range src { + buf := dst[i*3 : i*3+3] + buf[0] = 0x25 + buf[1] = hex[b/16] + buf[2] = hex[b%16] + } + return dst +} + +func escape(s string, allowReserved bool) string { + if allowReserved { + return string(reserved.ReplaceAllFunc([]byte(s), pctEncode)) + } + return string(unreserved.ReplaceAllFunc([]byte(s), pctEncode)) +} + +// A uriTemplate is a parsed representation of a URI template. +type uriTemplate struct { + raw string + parts []templatePart +} + +// parse parses a URI template string into a uriTemplate object. +func parse(rawTemplate string) (*uriTemplate, error) { + split := strings.Split(rawTemplate, "{") + parts := make([]templatePart, len(split)*2-1) + for i, s := range split { + if i == 0 { + if strings.Contains(s, "}") { + return nil, errors.New("unexpected }") + } + parts[i].raw = s + continue + } + subsplit := strings.Split(s, "}") + if len(subsplit) != 2 { + return nil, errors.New("malformed template") + } + expression := subsplit[0] + var err error + parts[i*2-1], err = parseExpression(expression) + if err != nil { + return nil, err + } + parts[i*2].raw = subsplit[1] + } + return &uriTemplate{ + raw: rawTemplate, + parts: parts, + }, nil +} + +type templatePart struct { + raw string + terms []templateTerm + first string + sep string + named bool + ifemp string + allowReserved bool +} + +type templateTerm struct { + name string + explode bool + truncate int +} + +func parseExpression(expression string) (result templatePart, err error) { + switch expression[0] { + case '+': + result.sep = "," + result.allowReserved = true + expression = expression[1:] + case '.': + result.first = "." + result.sep = "." + expression = expression[1:] + case '/': + result.first = "/" + result.sep = "/" + expression = expression[1:] + case ';': + result.first = ";" + result.sep = ";" + result.named = true + expression = expression[1:] + case '?': + result.first = "?" + result.sep = "&" + result.named = true + result.ifemp = "=" + expression = expression[1:] + case '&': + result.first = "&" + result.sep = "&" + result.named = true + result.ifemp = "=" + expression = expression[1:] + case '#': + result.first = "#" + result.sep = "," + result.allowReserved = true + expression = expression[1:] + default: + result.sep = "," + } + rawterms := strings.Split(expression, ",") + result.terms = make([]templateTerm, len(rawterms)) + for i, raw := range rawterms { + result.terms[i], err = parseTerm(raw) + if err != nil { + break + } + } + return result, err +} + +func parseTerm(term string) (result templateTerm, err error) { + // TODO(djd): Remove "*" suffix parsing once we check that no APIs have + // mistakenly used that attribute. + if strings.HasSuffix(term, "*") { + result.explode = true + term = term[:len(term)-1] + } + split := strings.Split(term, ":") + if len(split) == 1 { + result.name = term + } else if len(split) == 2 { + result.name = split[0] + var parsed int64 + parsed, err = strconv.ParseInt(split[1], 10, 0) + result.truncate = int(parsed) + } else { + err = errors.New("multiple colons in same term") + } + if !validname.MatchString(result.name) { + err = errors.New("not a valid name: " + result.name) + } + if result.explode && result.truncate > 0 { + err = errors.New("both explode and prefix modifers on same term") + } + return result, err +} + +// Expand expands a URI template with a set of values to produce a string. +func (t *uriTemplate) Expand(values map[string]string) string { + var buf bytes.Buffer + for _, p := range t.parts { + p.expand(&buf, values) + } + return buf.String() +} + +func (tp *templatePart) expand(buf *bytes.Buffer, values map[string]string) { + if len(tp.raw) > 0 { + buf.WriteString(tp.raw) + return + } + var first = true + for _, term := range tp.terms { + value, exists := values[term.name] + if !exists { + continue + } + if first { + buf.WriteString(tp.first) + first = false + } else { + buf.WriteString(tp.sep) + } + tp.expandString(buf, term, value) + } +} + +func (tp *templatePart) expandName(buf *bytes.Buffer, name string, empty bool) { + if tp.named { + buf.WriteString(name) + if empty { + buf.WriteString(tp.ifemp) + } else { + buf.WriteString("=") + } + } +} + +func (tp *templatePart) expandString(buf *bytes.Buffer, t templateTerm, s string) { + if len(s) > t.truncate && t.truncate > 0 { + s = s[:t.truncate] + } + tp.expandName(buf, t.name, len(s) == 0) + buf.WriteString(escape(s, tp.allowReserved)) +} diff --git a/vendor/google.golang.org/api/googleapi/internal/uritemplates/utils.go b/vendor/google.golang.org/api/googleapi/internal/uritemplates/utils.go new file mode 100644 index 00000000..eff260a6 --- /dev/null +++ b/vendor/google.golang.org/api/googleapi/internal/uritemplates/utils.go @@ -0,0 +1,13 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package uritemplates + +func Expand(path string, values map[string]string) (string, error) { + template, err := parse(path) + if err != nil { + return "", err + } + return template.Expand(values), nil +} diff --git a/vendor/google.golang.org/api/googleapi/types.go b/vendor/google.golang.org/api/googleapi/types.go new file mode 100644 index 00000000..a02b4b07 --- /dev/null +++ b/vendor/google.golang.org/api/googleapi/types.go @@ -0,0 +1,182 @@ +// Copyright 2013 Google Inc. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package googleapi + +import ( + "encoding/json" + "strconv" +) + +// Int64s is a slice of int64s that marshal as quoted strings in JSON. +type Int64s []int64 + +func (q *Int64s) UnmarshalJSON(raw []byte) error { + *q = (*q)[:0] + var ss []string + if err := json.Unmarshal(raw, &ss); err != nil { + return err + } + for _, s := range ss { + v, err := strconv.ParseInt(s, 10, 64) + if err != nil { + return err + } + *q = append(*q, int64(v)) + } + return nil +} + +// Int32s is a slice of int32s that marshal as quoted strings in JSON. +type Int32s []int32 + +func (q *Int32s) UnmarshalJSON(raw []byte) error { + *q = (*q)[:0] + var ss []string + if err := json.Unmarshal(raw, &ss); err != nil { + return err + } + for _, s := range ss { + v, err := strconv.ParseInt(s, 10, 32) + if err != nil { + return err + } + *q = append(*q, int32(v)) + } + return nil +} + +// Uint64s is a slice of uint64s that marshal as quoted strings in JSON. +type Uint64s []uint64 + +func (q *Uint64s) UnmarshalJSON(raw []byte) error { + *q = (*q)[:0] + var ss []string + if err := json.Unmarshal(raw, &ss); err != nil { + return err + } + for _, s := range ss { + v, err := strconv.ParseUint(s, 10, 64) + if err != nil { + return err + } + *q = append(*q, uint64(v)) + } + return nil +} + +// Uint32s is a slice of uint32s that marshal as quoted strings in JSON. +type Uint32s []uint32 + +func (q *Uint32s) UnmarshalJSON(raw []byte) error { + *q = (*q)[:0] + var ss []string + if err := json.Unmarshal(raw, &ss); err != nil { + return err + } + for _, s := range ss { + v, err := strconv.ParseUint(s, 10, 32) + if err != nil { + return err + } + *q = append(*q, uint32(v)) + } + return nil +} + +// Float64s is a slice of float64s that marshal as quoted strings in JSON. +type Float64s []float64 + +func (q *Float64s) UnmarshalJSON(raw []byte) error { + *q = (*q)[:0] + var ss []string + if err := json.Unmarshal(raw, &ss); err != nil { + return err + } + for _, s := range ss { + v, err := strconv.ParseFloat(s, 64) + if err != nil { + return err + } + *q = append(*q, float64(v)) + } + return nil +} + +func quotedList(n int, fn func(dst []byte, i int) []byte) ([]byte, error) { + dst := make([]byte, 0, 2+n*10) // somewhat arbitrary + dst = append(dst, '[') + for i := 0; i < n; i++ { + if i > 0 { + dst = append(dst, ',') + } + dst = append(dst, '"') + dst = fn(dst, i) + dst = append(dst, '"') + } + dst = append(dst, ']') + return dst, nil +} + +func (s Int64s) MarshalJSON() ([]byte, error) { + return quotedList(len(s), func(dst []byte, i int) []byte { + return strconv.AppendInt(dst, s[i], 10) + }) +} + +func (s Int32s) MarshalJSON() ([]byte, error) { + return quotedList(len(s), func(dst []byte, i int) []byte { + return strconv.AppendInt(dst, int64(s[i]), 10) + }) +} + +func (s Uint64s) MarshalJSON() ([]byte, error) { + return quotedList(len(s), func(dst []byte, i int) []byte { + return strconv.AppendUint(dst, s[i], 10) + }) +} + +func (s Uint32s) MarshalJSON() ([]byte, error) { + return quotedList(len(s), func(dst []byte, i int) []byte { + return strconv.AppendUint(dst, uint64(s[i]), 10) + }) +} + +func (s Float64s) MarshalJSON() ([]byte, error) { + return quotedList(len(s), func(dst []byte, i int) []byte { + return strconv.AppendFloat(dst, s[i], 'g', -1, 64) + }) +} + +/* + * Helper routines for simplifying the creation of optional fields of basic type. + */ + +// Bool is a helper routine that allocates a new bool value +// to store v and returns a pointer to it. +func Bool(v bool) *bool { return &v } + +// Int32 is a helper routine that allocates a new int32 value +// to store v and returns a pointer to it. +func Int32(v int32) *int32 { return &v } + +// Int64 is a helper routine that allocates a new int64 value +// to store v and returns a pointer to it. +func Int64(v int64) *int64 { return &v } + +// Float64 is a helper routine that allocates a new float64 value +// to store v and returns a pointer to it. +func Float64(v float64) *float64 { return &v } + +// Uint32 is a helper routine that allocates a new uint32 value +// to store v and returns a pointer to it. +func Uint32(v uint32) *uint32 { return &v } + +// Uint64 is a helper routine that allocates a new uint64 value +// to store v and returns a pointer to it. +func Uint64(v uint64) *uint64 { return &v } + +// String is a helper routine that allocates a new string value +// to store v and returns a pointer to it. +func String(v string) *string { return &v } diff --git a/vendor/google.golang.org/api/internal/pool.go b/vendor/google.golang.org/api/internal/pool.go new file mode 100644 index 00000000..4150feb6 --- /dev/null +++ b/vendor/google.golang.org/api/internal/pool.go @@ -0,0 +1,59 @@ +// Copyright 2016 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package internal + +import ( + "errors" + "google.golang.org/grpc/naming" +) + +// PoolResolver provides a fixed list of addresses to load balance between +// and does not provide further updates. +type PoolResolver struct { + poolSize int + dialOpt *DialSettings + ch chan []*naming.Update +} + +// NewPoolResolver returns a PoolResolver +// This is an EXPERIMENTAL API and may be changed or removed in the future. +func NewPoolResolver(size int, o *DialSettings) *PoolResolver { + return &PoolResolver{poolSize: size, dialOpt: o} +} + +// Resolve returns a Watcher for the endpoint defined by the DialSettings +// provided to NewPoolResolver. +func (r *PoolResolver) Resolve(target string) (naming.Watcher, error) { + if r.dialOpt.Endpoint == "" { + return nil, errors.New("No endpoint configured") + } + addrs := make([]*naming.Update, 0, r.poolSize) + for i := 0; i < r.poolSize; i++ { + addrs = append(addrs, &naming.Update{Op: naming.Add, Addr: r.dialOpt.Endpoint, Metadata: i}) + } + r.ch = make(chan []*naming.Update, 1) + r.ch <- addrs + return r, nil +} + +// Next returns a static list of updates on the first call, +// and blocks indefinitely until Close is called on subsequent calls. +func (r *PoolResolver) Next() ([]*naming.Update, error) { + return <-r.ch, nil +} + +func (r *PoolResolver) Close() { + close(r.ch) +} diff --git a/vendor/google.golang.org/api/internal/settings.go b/vendor/google.golang.org/api/internal/settings.go new file mode 100644 index 00000000..eb9300c7 --- /dev/null +++ b/vendor/google.golang.org/api/internal/settings.go @@ -0,0 +1,21 @@ +// Package internal supports the options and transport packages. +package internal + +import ( + "net/http" + + "golang.org/x/oauth2" + "google.golang.org/grpc" +) + +// DialSettings holds information needed to establish a connection with a +// Google API service. +type DialSettings struct { + Endpoint string + Scopes []string + TokenSource oauth2.TokenSource + UserAgent string + HTTPClient *http.Client + GRPCDialOpts []grpc.DialOption + GRPCConn *grpc.ClientConn +} diff --git a/vendor/google.golang.org/api/option/option.go b/vendor/google.golang.org/api/option/option.go new file mode 100644 index 00000000..556a6dfd --- /dev/null +++ b/vendor/google.golang.org/api/option/option.go @@ -0,0 +1,117 @@ +// Package option contains options for Google API clients. +package option + +import ( + "net/http" + + "golang.org/x/oauth2" + "google.golang.org/api/internal" + "google.golang.org/grpc" +) + +// A ClientOption is an option for a Google API client. +type ClientOption interface { + Apply(*internal.DialSettings) +} + +// WithTokenSource returns a ClientOption that specifies an OAuth2 token +// source to be used as the basis for authentication. +func WithTokenSource(s oauth2.TokenSource) ClientOption { + return withTokenSource{s} +} + +type withTokenSource struct{ ts oauth2.TokenSource } + +func (w withTokenSource) Apply(o *internal.DialSettings) { + o.TokenSource = w.ts +} + +// WithEndpoint returns a ClientOption that overrides the default endpoint +// to be used for a service. +func WithEndpoint(url string) ClientOption { + return withEndpoint(url) +} + +type withEndpoint string + +func (w withEndpoint) Apply(o *internal.DialSettings) { + o.Endpoint = string(w) +} + +// WithScopes returns a ClientOption that overrides the default OAuth2 scopes +// to be used for a service. +func WithScopes(scope ...string) ClientOption { + return withScopes(scope) +} + +type withScopes []string + +func (w withScopes) Apply(o *internal.DialSettings) { + s := make([]string, len(w)) + copy(s, w) + o.Scopes = s +} + +// WithUserAgent returns a ClientOption that sets the User-Agent. +func WithUserAgent(ua string) ClientOption { + return withUA(ua) +} + +type withUA string + +func (w withUA) Apply(o *internal.DialSettings) { o.UserAgent = string(w) } + +// WithHTTPClient returns a ClientOption that specifies the HTTP client to use +// as the basis of communications. This option may only be used with services +// that support HTTP as their communication transport. When used, the +// WithHTTPClient option takes precedent over all other supplied options. +func WithHTTPClient(client *http.Client) ClientOption { + return withHTTPClient{client} +} + +type withHTTPClient struct{ client *http.Client } + +func (w withHTTPClient) Apply(o *internal.DialSettings) { + o.HTTPClient = w.client +} + +// WithGRPCConn returns a ClientOption that specifies the gRPC client +// connection to use as the basis of communications. This option many only be +// used with services that support gRPC as their communication transport. When +// used, the WithGRPCConn option takes precedent over all other supplied +// options. +func WithGRPCConn(conn *grpc.ClientConn) ClientOption { + return withGRPCConn{conn} +} + +type withGRPCConn struct{ conn *grpc.ClientConn } + +func (w withGRPCConn) Apply(o *internal.DialSettings) { + o.GRPCConn = w.conn +} + +// WithGRPCDialOption returns a ClientOption that appends a new grpc.DialOption +// to an underlying gRPC dial. It does not work with WithGRPCConn. +func WithGRPCDialOption(opt grpc.DialOption) ClientOption { + return withGRPCDialOption{opt} +} + +type withGRPCDialOption struct{ opt grpc.DialOption } + +func (w withGRPCDialOption) Apply(o *internal.DialSettings) { + o.GRPCDialOpts = append(o.GRPCDialOpts, w.opt) +} + +// WithGRPCConnectionPool returns a ClientOption that creates a pool of gRPC +// connections that requests will be balanced between. +// This is an EXPERIMENTAL API and may be changed or removed in the future. +func WithGRPCConnectionPool(size int) ClientOption { + return withGRPCConnectionPool(size) +} + +type withGRPCConnectionPool int + +func (w withGRPCConnectionPool) Apply(o *internal.DialSettings) { + balancer := grpc.RoundRobin(internal.NewPoolResolver(int(w), o)) + o.GRPCDialOpts = append(o.GRPCDialOpts, grpc.WithBalancer(balancer)) +} diff --git a/vendor/google.golang.org/api/storage/v1/storage-gen.go b/vendor/google.golang.org/api/storage/v1/storage-gen.go new file mode 100644 index 00000000..346751b7 --- /dev/null +++ b/vendor/google.golang.org/api/storage/v1/storage-gen.go @@ -0,0 +1,7750 @@ +// Package storage provides access to the Cloud Storage JSON API. +// +// See https://developers.google.com/storage/docs/json_api/ +// +// Usage example: +// +// import "google.golang.org/api/storage/v1" +// ... +// storageService, err := storage.New(oauthHttpClient) +package storage // import "google.golang.org/api/storage/v1" + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + context "golang.org/x/net/context" + ctxhttp "golang.org/x/net/context/ctxhttp" + gensupport "google.golang.org/api/gensupport" + googleapi "google.golang.org/api/googleapi" + "io" + "net/http" + "net/url" + "strconv" + "strings" +) + +// Always reference these packages, just in case the auto-generated code +// below doesn't. +var _ = bytes.NewBuffer +var _ = strconv.Itoa +var _ = fmt.Sprintf +var _ = json.NewDecoder +var _ = io.Copy +var _ = url.Parse +var _ = gensupport.MarshalJSON +var _ = googleapi.Version +var _ = errors.New +var _ = strings.Replace +var _ = context.Canceled +var _ = ctxhttp.Do + +const apiId = "storage:v1" +const apiName = "storage" +const apiVersion = "v1" +const basePath = "https://www.googleapis.com/storage/v1/" + +// OAuth2 scopes used by this API. +const ( + // View and manage your data across Google Cloud Platform services + CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform" + + // View your data across Google Cloud Platform services + CloudPlatformReadOnlyScope = "https://www.googleapis.com/auth/cloud-platform.read-only" + + // Manage your data and permissions in Google Cloud Storage + DevstorageFullControlScope = "https://www.googleapis.com/auth/devstorage.full_control" + + // View your data in Google Cloud Storage + DevstorageReadOnlyScope = "https://www.googleapis.com/auth/devstorage.read_only" + + // Manage your data in Google Cloud Storage + DevstorageReadWriteScope = "https://www.googleapis.com/auth/devstorage.read_write" +) + +func New(client *http.Client) (*Service, error) { + if client == nil { + return nil, errors.New("client is nil") + } + s := &Service{client: client, BasePath: basePath} + s.BucketAccessControls = NewBucketAccessControlsService(s) + s.Buckets = NewBucketsService(s) + s.Channels = NewChannelsService(s) + s.DefaultObjectAccessControls = NewDefaultObjectAccessControlsService(s) + s.ObjectAccessControls = NewObjectAccessControlsService(s) + s.Objects = NewObjectsService(s) + return s, nil +} + +type Service struct { + client *http.Client + BasePath string // API endpoint base URL + UserAgent string // optional additional User-Agent fragment + + BucketAccessControls *BucketAccessControlsService + + Buckets *BucketsService + + Channels *ChannelsService + + DefaultObjectAccessControls *DefaultObjectAccessControlsService + + ObjectAccessControls *ObjectAccessControlsService + + Objects *ObjectsService +} + +func (s *Service) userAgent() string { + if s.UserAgent == "" { + return googleapi.UserAgent + } + return googleapi.UserAgent + " " + s.UserAgent +} + +func NewBucketAccessControlsService(s *Service) *BucketAccessControlsService { + rs := &BucketAccessControlsService{s: s} + return rs +} + +type BucketAccessControlsService struct { + s *Service +} + +func NewBucketsService(s *Service) *BucketsService { + rs := &BucketsService{s: s} + return rs +} + +type BucketsService struct { + s *Service +} + +func NewChannelsService(s *Service) *ChannelsService { + rs := &ChannelsService{s: s} + return rs +} + +type ChannelsService struct { + s *Service +} + +func NewDefaultObjectAccessControlsService(s *Service) *DefaultObjectAccessControlsService { + rs := &DefaultObjectAccessControlsService{s: s} + return rs +} + +type DefaultObjectAccessControlsService struct { + s *Service +} + +func NewObjectAccessControlsService(s *Service) *ObjectAccessControlsService { + rs := &ObjectAccessControlsService{s: s} + return rs +} + +type ObjectAccessControlsService struct { + s *Service +} + +func NewObjectsService(s *Service) *ObjectsService { + rs := &ObjectsService{s: s} + return rs +} + +type ObjectsService struct { + s *Service +} + +// Bucket: A bucket. +type Bucket struct { + // Acl: Access controls on the bucket. + Acl []*BucketAccessControl `json:"acl,omitempty"` + + // Cors: The bucket's Cross-Origin Resource Sharing (CORS) + // configuration. + Cors []*BucketCors `json:"cors,omitempty"` + + // DefaultObjectAcl: Default access controls to apply to new objects + // when no ACL is provided. + DefaultObjectAcl []*ObjectAccessControl `json:"defaultObjectAcl,omitempty"` + + // Encryption: Encryption configuration used by default for newly + // inserted objects, when no encryption config is specified. + Encryption *BucketEncryption `json:"encryption,omitempty"` + + // Etag: HTTP 1.1 Entity tag for the bucket. + Etag string `json:"etag,omitempty"` + + // Id: The ID of the bucket. + Id string `json:"id,omitempty"` + + // Kind: The kind of item this is. For buckets, this is always + // storage#bucket. + Kind string `json:"kind,omitempty"` + + // Lifecycle: The bucket's lifecycle configuration. See lifecycle + // management for more information. + Lifecycle *BucketLifecycle `json:"lifecycle,omitempty"` + + // Location: The location of the bucket. Object data for objects in the + // bucket resides in physical storage within this region. Defaults to + // US. See the developer's guide for the authoritative list. + Location string `json:"location,omitempty"` + + // Logging: The bucket's logging configuration, which defines the + // destination bucket and optional name prefix for the current bucket's + // logs. + Logging *BucketLogging `json:"logging,omitempty"` + + // Metageneration: The metadata generation of this bucket. + Metageneration int64 `json:"metageneration,omitempty,string"` + + // Name: The name of the bucket. + Name string `json:"name,omitempty"` + + // Owner: The owner of the bucket. This is always the project team's + // owner group. + Owner *BucketOwner `json:"owner,omitempty"` + + // ProjectNumber: The project number of the project the bucket belongs + // to. + ProjectNumber uint64 `json:"projectNumber,omitempty,string"` + + // SelfLink: The URI of this bucket. + SelfLink string `json:"selfLink,omitempty"` + + // StorageClass: The bucket's storage class. This defines how objects in + // the bucket are stored and determines the SLA and the cost of storage. + // Values include STANDARD, NEARLINE and DURABLE_REDUCED_AVAILABILITY. + // Defaults to STANDARD. For more information, see storage classes. + StorageClass string `json:"storageClass,omitempty"` + + // TimeCreated: The creation time of the bucket in RFC 3339 format. + TimeCreated string `json:"timeCreated,omitempty"` + + // Updated: The modification time of the bucket in RFC 3339 format. + Updated string `json:"updated,omitempty"` + + // Versioning: The bucket's versioning configuration. + Versioning *BucketVersioning `json:"versioning,omitempty"` + + // Website: The bucket's website configuration, controlling how the + // service behaves when accessing bucket contents as a web site. See the + // Static Website Examples for more information. + Website *BucketWebsite `json:"website,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Acl") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *Bucket) MarshalJSON() ([]byte, error) { + type noMethod Bucket + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +type BucketCors struct { + // MaxAgeSeconds: The value, in seconds, to return in the + // Access-Control-Max-Age header used in preflight responses. + MaxAgeSeconds int64 `json:"maxAgeSeconds,omitempty"` + + // Method: The list of HTTP methods on which to include CORS response + // headers, (GET, OPTIONS, POST, etc) Note: "*" is permitted in the list + // of methods, and means "any method". + Method []string `json:"method,omitempty"` + + // Origin: The list of Origins eligible to receive CORS response + // headers. Note: "*" is permitted in the list of origins, and means + // "any Origin". + Origin []string `json:"origin,omitempty"` + + // ResponseHeader: The list of HTTP headers other than the simple + // response headers to give permission for the user-agent to share + // across domains. + ResponseHeader []string `json:"responseHeader,omitempty"` + + // ForceSendFields is a list of field names (e.g. "MaxAgeSeconds") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketCors) MarshalJSON() ([]byte, error) { + type noMethod BucketCors + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketEncryption: Encryption configuration used by default for newly +// inserted objects, when no encryption config is specified. +type BucketEncryption struct { + DefaultKmsKeyName string `json:"default_kms_key_name,omitempty"` + + // ForceSendFields is a list of field names (e.g. "DefaultKmsKeyName") + // to unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketEncryption) MarshalJSON() ([]byte, error) { + type noMethod BucketEncryption + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketLifecycle: The bucket's lifecycle configuration. See lifecycle +// management for more information. +type BucketLifecycle struct { + // Rule: A lifecycle management rule, which is made of an action to take + // and the condition(s) under which the action will be taken. + Rule []*BucketLifecycleRule `json:"rule,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Rule") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketLifecycle) MarshalJSON() ([]byte, error) { + type noMethod BucketLifecycle + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +type BucketLifecycleRule struct { + // Action: The action to take. + Action *BucketLifecycleRuleAction `json:"action,omitempty"` + + // Condition: The condition(s) under which the action will be taken. + Condition *BucketLifecycleRuleCondition `json:"condition,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Action") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketLifecycleRule) MarshalJSON() ([]byte, error) { + type noMethod BucketLifecycleRule + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketLifecycleRuleAction: The action to take. +type BucketLifecycleRuleAction struct { + // Type: Type of the action. Currently, only Delete is supported. + Type string `json:"type,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Type") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketLifecycleRuleAction) MarshalJSON() ([]byte, error) { + type noMethod BucketLifecycleRuleAction + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketLifecycleRuleCondition: The condition(s) under which the action +// will be taken. +type BucketLifecycleRuleCondition struct { + // Age: Age of an object (in days). This condition is satisfied when an + // object reaches the specified age. + Age int64 `json:"age,omitempty"` + + // CreatedBefore: A date in RFC 3339 format with only the date part (for + // instance, "2013-01-15"). This condition is satisfied when an object + // is created before midnight of the specified date in UTC. + CreatedBefore string `json:"createdBefore,omitempty"` + + // IsLive: Relevant only for versioned objects. If the value is true, + // this condition matches live objects; if the value is false, it + // matches archived objects. + IsLive bool `json:"isLive,omitempty"` + + // NumNewerVersions: Relevant only for versioned objects. If the value + // is N, this condition is satisfied when there are at least N versions + // (including the live version) newer than this version of the object. + NumNewerVersions int64 `json:"numNewerVersions,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Age") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketLifecycleRuleCondition) MarshalJSON() ([]byte, error) { + type noMethod BucketLifecycleRuleCondition + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketLogging: The bucket's logging configuration, which defines the +// destination bucket and optional name prefix for the current bucket's +// logs. +type BucketLogging struct { + // LogBucket: The destination bucket where the current bucket's logs + // should be placed. + LogBucket string `json:"logBucket,omitempty"` + + // LogObjectPrefix: A prefix for log object names. + LogObjectPrefix string `json:"logObjectPrefix,omitempty"` + + // ForceSendFields is a list of field names (e.g. "LogBucket") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketLogging) MarshalJSON() ([]byte, error) { + type noMethod BucketLogging + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketOwner: The owner of the bucket. This is always the project +// team's owner group. +type BucketOwner struct { + // Entity: The entity, in the form project-owner-projectId. + Entity string `json:"entity,omitempty"` + + // EntityId: The ID for the entity. + EntityId string `json:"entityId,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Entity") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketOwner) MarshalJSON() ([]byte, error) { + type noMethod BucketOwner + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketVersioning: The bucket's versioning configuration. +type BucketVersioning struct { + // Enabled: While set to true, versioning is fully enabled for this + // bucket. + Enabled bool `json:"enabled,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Enabled") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketVersioning) MarshalJSON() ([]byte, error) { + type noMethod BucketVersioning + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketWebsite: The bucket's website configuration, controlling how +// the service behaves when accessing bucket contents as a web site. See +// the Static Website Examples for more information. +type BucketWebsite struct { + // MainPageSuffix: If the requested object path is missing, the service + // will ensure the path has a trailing '/', append this suffix, and + // attempt to retrieve the resulting object. This allows the creation of + // index.html objects to represent directory pages. + MainPageSuffix string `json:"mainPageSuffix,omitempty"` + + // NotFoundPage: If the requested object path is missing, and any + // mainPageSuffix object is missing, if applicable, the service will + // return the named object from this bucket as the content for a 404 Not + // Found result. + NotFoundPage string `json:"notFoundPage,omitempty"` + + // ForceSendFields is a list of field names (e.g. "MainPageSuffix") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketWebsite) MarshalJSON() ([]byte, error) { + type noMethod BucketWebsite + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketAccessControl: An access-control entry. +type BucketAccessControl struct { + // Bucket: The name of the bucket. + Bucket string `json:"bucket,omitempty"` + + // Domain: The domain associated with the entity, if any. + Domain string `json:"domain,omitempty"` + + // Email: The email address associated with the entity, if any. + Email string `json:"email,omitempty"` + + // Entity: The entity holding the permission, in one of the following + // forms: + // - user-userId + // - user-email + // - group-groupId + // - group-email + // - domain-domain + // - project-team-projectId + // - allUsers + // - allAuthenticatedUsers Examples: + // - The user liz@example.com would be user-liz@example.com. + // - The group example@googlegroups.com would be + // group-example@googlegroups.com. + // - To refer to all members of the Google Apps for Business domain + // example.com, the entity would be domain-example.com. + Entity string `json:"entity,omitempty"` + + // EntityId: The ID for the entity, if any. + EntityId string `json:"entityId,omitempty"` + + // Etag: HTTP 1.1 Entity tag for the access-control entry. + Etag string `json:"etag,omitempty"` + + // Id: The ID of the access-control entry. + Id string `json:"id,omitempty"` + + // Kind: The kind of item this is. For bucket access control entries, + // this is always storage#bucketAccessControl. + Kind string `json:"kind,omitempty"` + + // ProjectTeam: The project team associated with the entity, if any. + ProjectTeam *BucketAccessControlProjectTeam `json:"projectTeam,omitempty"` + + // Role: The access permission for the entity. + Role string `json:"role,omitempty"` + + // SelfLink: The link to this access-control entry. + SelfLink string `json:"selfLink,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Bucket") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketAccessControl) MarshalJSON() ([]byte, error) { + type noMethod BucketAccessControl + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketAccessControlProjectTeam: The project team associated with the +// entity, if any. +type BucketAccessControlProjectTeam struct { + // ProjectNumber: The project number. + ProjectNumber string `json:"projectNumber,omitempty"` + + // Team: The team. + Team string `json:"team,omitempty"` + + // ForceSendFields is a list of field names (e.g. "ProjectNumber") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketAccessControlProjectTeam) MarshalJSON() ([]byte, error) { + type noMethod BucketAccessControlProjectTeam + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// BucketAccessControls: An access-control list. +type BucketAccessControls struct { + // Items: The list of items. + Items []*BucketAccessControl `json:"items,omitempty"` + + // Kind: The kind of item this is. For lists of bucket access control + // entries, this is always storage#bucketAccessControls. + Kind string `json:"kind,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Items") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *BucketAccessControls) MarshalJSON() ([]byte, error) { + type noMethod BucketAccessControls + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// Buckets: A list of buckets. +type Buckets struct { + // Items: The list of items. + Items []*Bucket `json:"items,omitempty"` + + // Kind: The kind of item this is. For lists of buckets, this is always + // storage#buckets. + Kind string `json:"kind,omitempty"` + + // NextPageToken: The continuation token, used to page through large + // result sets. Provide this value in a subsequent request to return the + // next page of results. + NextPageToken string `json:"nextPageToken,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Items") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *Buckets) MarshalJSON() ([]byte, error) { + type noMethod Buckets + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// Channel: An notification channel used to watch for resource changes. +type Channel struct { + // Address: The address where notifications are delivered for this + // channel. + Address string `json:"address,omitempty"` + + // Expiration: Date and time of notification channel expiration, + // expressed as a Unix timestamp, in milliseconds. Optional. + Expiration int64 `json:"expiration,omitempty,string"` + + // Id: A UUID or similar unique string that identifies this channel. + Id string `json:"id,omitempty"` + + // Kind: Identifies this as a notification channel used to watch for + // changes to a resource. Value: the fixed string "api#channel". + Kind string `json:"kind,omitempty"` + + // Params: Additional parameters controlling delivery channel behavior. + // Optional. + Params map[string]string `json:"params,omitempty"` + + // Payload: A Boolean value to indicate whether payload is wanted. + // Optional. + Payload bool `json:"payload,omitempty"` + + // ResourceId: An opaque ID that identifies the resource being watched + // on this channel. Stable across different API versions. + ResourceId string `json:"resourceId,omitempty"` + + // ResourceUri: A version-specific identifier for the watched resource. + ResourceUri string `json:"resourceUri,omitempty"` + + // Token: An arbitrary string delivered to the target address with each + // notification delivered over this channel. Optional. + Token string `json:"token,omitempty"` + + // Type: The type of delivery mechanism used for this channel. + Type string `json:"type,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Address") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *Channel) MarshalJSON() ([]byte, error) { + type noMethod Channel + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// ComposeRequest: A Compose request. +type ComposeRequest struct { + // Destination: Properties of the resulting object. + Destination *Object `json:"destination,omitempty"` + + // Kind: The kind of item this is. + Kind string `json:"kind,omitempty"` + + // SourceObjects: The list of source objects that will be concatenated + // into a single object. + SourceObjects []*ComposeRequestSourceObjects `json:"sourceObjects,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Destination") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *ComposeRequest) MarshalJSON() ([]byte, error) { + type noMethod ComposeRequest + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +type ComposeRequestSourceObjects struct { + // Generation: The generation of this object to use as the source. + Generation int64 `json:"generation,omitempty,string"` + + // Name: The source object's name. The source object's bucket is + // implicitly the destination bucket. + Name string `json:"name,omitempty"` + + // ObjectPreconditions: Conditions that must be met for this operation + // to execute. + ObjectPreconditions *ComposeRequestSourceObjectsObjectPreconditions `json:"objectPreconditions,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Generation") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *ComposeRequestSourceObjects) MarshalJSON() ([]byte, error) { + type noMethod ComposeRequestSourceObjects + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// ComposeRequestSourceObjectsObjectPreconditions: Conditions that must +// be met for this operation to execute. +type ComposeRequestSourceObjectsObjectPreconditions struct { + // IfGenerationMatch: Only perform the composition if the generation of + // the source object that would be used matches this value. If this + // value and a generation are both specified, they must be the same + // value or the call will fail. + IfGenerationMatch int64 `json:"ifGenerationMatch,omitempty,string"` + + // ForceSendFields is a list of field names (e.g. "IfGenerationMatch") + // to unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *ComposeRequestSourceObjectsObjectPreconditions) MarshalJSON() ([]byte, error) { + type noMethod ComposeRequestSourceObjectsObjectPreconditions + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// Object: An object. +type Object struct { + // Acl: Access controls on the object. + Acl []*ObjectAccessControl `json:"acl,omitempty"` + + // Bucket: The name of the bucket containing this object. + Bucket string `json:"bucket,omitempty"` + + // CacheControl: Cache-Control directive for the object data. If + // omitted, and the object is accessible to all anonymous users, the + // default will be public, max-age=3600. + CacheControl string `json:"cacheControl,omitempty"` + + // ComponentCount: Number of underlying components that make up this + // object. Components are accumulated by compose operations. + ComponentCount int64 `json:"componentCount,omitempty"` + + // ContentDisposition: Content-Disposition of the object data. + ContentDisposition string `json:"contentDisposition,omitempty"` + + // ContentEncoding: Content-Encoding of the object data. + ContentEncoding string `json:"contentEncoding,omitempty"` + + // ContentLanguage: Content-Language of the object data. + ContentLanguage string `json:"contentLanguage,omitempty"` + + // ContentType: Content-Type of the object data. If contentType is not + // specified, object downloads will be served as + // application/octet-stream. + ContentType string `json:"contentType,omitempty"` + + // Crc32c: CRC32c checksum, as described in RFC 4960, Appendix B; + // encoded using base64 in big-endian byte order. For more information + // about using the CRC32c checksum, see Hashes and ETags: Best + // Practices. + Crc32c string `json:"crc32c,omitempty"` + + // CustomerEncryption: Metadata of customer-supplied encryption key, if + // the object is encrypted by such a key. + CustomerEncryption *ObjectCustomerEncryption `json:"customerEncryption,omitempty"` + + // Etag: HTTP 1.1 Entity tag for the object. + Etag string `json:"etag,omitempty"` + + // Generation: The content generation of this object. Used for object + // versioning. + Generation int64 `json:"generation,omitempty,string"` + + // Id: The ID of the object. + Id string `json:"id,omitempty"` + + // Kind: The kind of item this is. For objects, this is always + // storage#object. + Kind string `json:"kind,omitempty"` + + // KmsKeyName: Cloud KMS Key used to encrypt this object, if the object + // is encrypted by such a key. + KmsKeyName string `json:"kmsKeyName,omitempty"` + + // Md5Hash: MD5 hash of the data; encoded using base64. For more + // information about using the MD5 hash, see Hashes and ETags: Best + // Practices. + Md5Hash string `json:"md5Hash,omitempty"` + + // MediaLink: Media download link. + MediaLink string `json:"mediaLink,omitempty"` + + // Metadata: User-provided metadata, in key/value pairs. + Metadata map[string]string `json:"metadata,omitempty"` + + // Metageneration: The version of the metadata for this object at this + // generation. Used for preconditions and for detecting changes in + // metadata. A metageneration number is only meaningful in the context + // of a particular generation of a particular object. + Metageneration int64 `json:"metageneration,omitempty,string"` + + // Name: The name of this object. Required if not specified by URL + // parameter. + Name string `json:"name,omitempty"` + + // Owner: The owner of the object. This will always be the uploader of + // the object. + Owner *ObjectOwner `json:"owner,omitempty"` + + // SelfLink: The link to this object. + SelfLink string `json:"selfLink,omitempty"` + + // Size: Content-Length of the data in bytes. + Size uint64 `json:"size,omitempty,string"` + + // StorageClass: Storage class of the object. + StorageClass string `json:"storageClass,omitempty"` + + // TimeCreated: The creation time of the object in RFC 3339 format. + TimeCreated string `json:"timeCreated,omitempty"` + + // TimeDeleted: The deletion time of the object in RFC 3339 format. Will + // be returned if and only if this version of the object has been + // deleted. + TimeDeleted string `json:"timeDeleted,omitempty"` + + // Updated: The modification time of the object metadata in RFC 3339 + // format. + Updated string `json:"updated,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Acl") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *Object) MarshalJSON() ([]byte, error) { + type noMethod Object + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// ObjectCustomerEncryption: Metadata of customer-supplied encryption +// key, if the object is encrypted by such a key. +type ObjectCustomerEncryption struct { + // EncryptionAlgorithm: The encryption algorithm. + EncryptionAlgorithm string `json:"encryptionAlgorithm,omitempty"` + + // KeySha256: SHA256 hash value of the encryption key. + KeySha256 string `json:"keySha256,omitempty"` + + // ForceSendFields is a list of field names (e.g. "EncryptionAlgorithm") + // to unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *ObjectCustomerEncryption) MarshalJSON() ([]byte, error) { + type noMethod ObjectCustomerEncryption + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// ObjectOwner: The owner of the object. This will always be the +// uploader of the object. +type ObjectOwner struct { + // Entity: The entity, in the form user-userId. + Entity string `json:"entity,omitempty"` + + // EntityId: The ID for the entity. + EntityId string `json:"entityId,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Entity") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *ObjectOwner) MarshalJSON() ([]byte, error) { + type noMethod ObjectOwner + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// ObjectAccessControl: An access-control entry. +type ObjectAccessControl struct { + // Bucket: The name of the bucket. + Bucket string `json:"bucket,omitempty"` + + // Domain: The domain associated with the entity, if any. + Domain string `json:"domain,omitempty"` + + // Email: The email address associated with the entity, if any. + Email string `json:"email,omitempty"` + + // Entity: The entity holding the permission, in one of the following + // forms: + // - user-userId + // - user-email + // - group-groupId + // - group-email + // - domain-domain + // - project-team-projectId + // - allUsers + // - allAuthenticatedUsers Examples: + // - The user liz@example.com would be user-liz@example.com. + // - The group example@googlegroups.com would be + // group-example@googlegroups.com. + // - To refer to all members of the Google Apps for Business domain + // example.com, the entity would be domain-example.com. + Entity string `json:"entity,omitempty"` + + // EntityId: The ID for the entity, if any. + EntityId string `json:"entityId,omitempty"` + + // Etag: HTTP 1.1 Entity tag for the access-control entry. + Etag string `json:"etag,omitempty"` + + // Generation: The content generation of the object. + Generation int64 `json:"generation,omitempty,string"` + + // Id: The ID of the access-control entry. + Id string `json:"id,omitempty"` + + // Kind: The kind of item this is. For object access control entries, + // this is always storage#objectAccessControl. + Kind string `json:"kind,omitempty"` + + // Object: The name of the object. + Object string `json:"object,omitempty"` + + // ProjectTeam: The project team associated with the entity, if any. + ProjectTeam *ObjectAccessControlProjectTeam `json:"projectTeam,omitempty"` + + // Role: The access permission for the entity. + Role string `json:"role,omitempty"` + + // SelfLink: The link to this access-control entry. + SelfLink string `json:"selfLink,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Bucket") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *ObjectAccessControl) MarshalJSON() ([]byte, error) { + type noMethod ObjectAccessControl + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// ObjectAccessControlProjectTeam: The project team associated with the +// entity, if any. +type ObjectAccessControlProjectTeam struct { + // ProjectNumber: The project number. + ProjectNumber string `json:"projectNumber,omitempty"` + + // Team: The team. + Team string `json:"team,omitempty"` + + // ForceSendFields is a list of field names (e.g. "ProjectNumber") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *ObjectAccessControlProjectTeam) MarshalJSON() ([]byte, error) { + type noMethod ObjectAccessControlProjectTeam + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// ObjectAccessControls: An access-control list. +type ObjectAccessControls struct { + // Items: The list of items. + Items []interface{} `json:"items,omitempty"` + + // Kind: The kind of item this is. For lists of object access control + // entries, this is always storage#objectAccessControls. + Kind string `json:"kind,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Items") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *ObjectAccessControls) MarshalJSON() ([]byte, error) { + type noMethod ObjectAccessControls + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// Objects: A list of objects. +type Objects struct { + // Items: The list of items. + Items []*Object `json:"items,omitempty"` + + // Kind: The kind of item this is. For lists of objects, this is always + // storage#objects. + Kind string `json:"kind,omitempty"` + + // NextPageToken: The continuation token, used to page through large + // result sets. Provide this value in a subsequent request to return the + // next page of results. + NextPageToken string `json:"nextPageToken,omitempty"` + + // Prefixes: The list of prefixes of objects matching-but-not-listed up + // to and including the requested delimiter. + Prefixes []string `json:"prefixes,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Items") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *Objects) MarshalJSON() ([]byte, error) { + type noMethod Objects + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// RewriteResponse: A rewrite response. +type RewriteResponse struct { + // Done: true if the copy is finished; otherwise, false if the copy is + // in progress. This property is always present in the response. + Done bool `json:"done,omitempty"` + + // Kind: The kind of item this is. + Kind string `json:"kind,omitempty"` + + // ObjectSize: The total size of the object being copied in bytes. This + // property is always present in the response. + ObjectSize uint64 `json:"objectSize,omitempty,string"` + + // Resource: A resource containing the metadata for the copied-to + // object. This property is present in the response only when copying + // completes. + Resource *Object `json:"resource,omitempty"` + + // RewriteToken: A token to use in subsequent requests to continue + // copying data. This token is present in the response only when there + // is more data to copy. + RewriteToken string `json:"rewriteToken,omitempty"` + + // TotalBytesRewritten: The total bytes written so far, which can be + // used to provide a waiting user with a progress indicator. This + // property is always present in the response. + TotalBytesRewritten uint64 `json:"totalBytesRewritten,omitempty,string"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Done") to + // unconditionally include in API requests. By default, fields with + // empty values are omitted from API requests. However, any non-pointer, + // non-interface field appearing in ForceSendFields will be sent to the + // server regardless of whether the field is empty or not. This may be + // used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` +} + +func (s *RewriteResponse) MarshalJSON() ([]byte, error) { + type noMethod RewriteResponse + raw := noMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields) +} + +// method id "storage.bucketAccessControls.delete": + +type BucketAccessControlsDeleteCall struct { + s *Service + bucket string + entity string + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Delete: Permanently deletes the ACL entry for the specified entity on +// the specified bucket. +func (r *BucketAccessControlsService) Delete(bucket string, entity string) *BucketAccessControlsDeleteCall { + c := &BucketAccessControlsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.entity = entity + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketAccessControlsDeleteCall) Fields(s ...googleapi.Field) *BucketAccessControlsDeleteCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketAccessControlsDeleteCall) Context(ctx context.Context) *BucketAccessControlsDeleteCall { + c.ctx_ = ctx + return c +} + +func (c *BucketAccessControlsDeleteCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("DELETE", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.bucketAccessControls.delete" call. +func (c *BucketAccessControlsDeleteCall) Do(opts ...googleapi.CallOption) error { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if err != nil { + return err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return err + } + return nil + // { + // "description": "Permanently deletes the ACL entry for the specified entity on the specified bucket.", + // "httpMethod": "DELETE", + // "id": "storage.bucketAccessControls.delete", + // "parameterOrder": [ + // "bucket", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/acl/{entity}", + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.bucketAccessControls.get": + +type BucketAccessControlsGetCall struct { + s *Service + bucket string + entity string + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context +} + +// Get: Returns the ACL entry for the specified entity on the specified +// bucket. +func (r *BucketAccessControlsService) Get(bucket string, entity string) *BucketAccessControlsGetCall { + c := &BucketAccessControlsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.entity = entity + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketAccessControlsGetCall) Fields(s ...googleapi.Field) *BucketAccessControlsGetCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *BucketAccessControlsGetCall) IfNoneMatch(entityTag string) *BucketAccessControlsGetCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketAccessControlsGetCall) Context(ctx context.Context) *BucketAccessControlsGetCall { + c.ctx_ = ctx + return c +} + +func (c *BucketAccessControlsGetCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("GET", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.bucketAccessControls.get" call. +// Exactly one of *BucketAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *BucketAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *BucketAccessControlsGetCall) Do(opts ...googleapi.CallOption) (*BucketAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &BucketAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Returns the ACL entry for the specified entity on the specified bucket.", + // "httpMethod": "GET", + // "id": "storage.bucketAccessControls.get", + // "parameterOrder": [ + // "bucket", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/acl/{entity}", + // "response": { + // "$ref": "BucketAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.bucketAccessControls.insert": + +type BucketAccessControlsInsertCall struct { + s *Service + bucket string + bucketaccesscontrol *BucketAccessControl + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Insert: Creates a new ACL entry on the specified bucket. +func (r *BucketAccessControlsService) Insert(bucket string, bucketaccesscontrol *BucketAccessControl) *BucketAccessControlsInsertCall { + c := &BucketAccessControlsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.bucketaccesscontrol = bucketaccesscontrol + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketAccessControlsInsertCall) Fields(s ...googleapi.Field) *BucketAccessControlsInsertCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketAccessControlsInsertCall) Context(ctx context.Context) *BucketAccessControlsInsertCall { + c.ctx_ = ctx + return c +} + +func (c *BucketAccessControlsInsertCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucketaccesscontrol) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("POST", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.bucketAccessControls.insert" call. +// Exactly one of *BucketAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *BucketAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *BucketAccessControlsInsertCall) Do(opts ...googleapi.CallOption) (*BucketAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &BucketAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Creates a new ACL entry on the specified bucket.", + // "httpMethod": "POST", + // "id": "storage.bucketAccessControls.insert", + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/acl", + // "request": { + // "$ref": "BucketAccessControl" + // }, + // "response": { + // "$ref": "BucketAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.bucketAccessControls.list": + +type BucketAccessControlsListCall struct { + s *Service + bucket string + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context +} + +// List: Retrieves ACL entries on the specified bucket. +func (r *BucketAccessControlsService) List(bucket string) *BucketAccessControlsListCall { + c := &BucketAccessControlsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketAccessControlsListCall) Fields(s ...googleapi.Field) *BucketAccessControlsListCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *BucketAccessControlsListCall) IfNoneMatch(entityTag string) *BucketAccessControlsListCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketAccessControlsListCall) Context(ctx context.Context) *BucketAccessControlsListCall { + c.ctx_ = ctx + return c +} + +func (c *BucketAccessControlsListCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("GET", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.bucketAccessControls.list" call. +// Exactly one of *BucketAccessControls or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *BucketAccessControls.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *BucketAccessControlsListCall) Do(opts ...googleapi.CallOption) (*BucketAccessControls, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &BucketAccessControls{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Retrieves ACL entries on the specified bucket.", + // "httpMethod": "GET", + // "id": "storage.bucketAccessControls.list", + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/acl", + // "response": { + // "$ref": "BucketAccessControls" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.bucketAccessControls.patch": + +type BucketAccessControlsPatchCall struct { + s *Service + bucket string + entity string + bucketaccesscontrol *BucketAccessControl + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Patch: Updates an ACL entry on the specified bucket. This method +// supports patch semantics. +func (r *BucketAccessControlsService) Patch(bucket string, entity string, bucketaccesscontrol *BucketAccessControl) *BucketAccessControlsPatchCall { + c := &BucketAccessControlsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.entity = entity + c.bucketaccesscontrol = bucketaccesscontrol + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketAccessControlsPatchCall) Fields(s ...googleapi.Field) *BucketAccessControlsPatchCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketAccessControlsPatchCall) Context(ctx context.Context) *BucketAccessControlsPatchCall { + c.ctx_ = ctx + return c +} + +func (c *BucketAccessControlsPatchCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucketaccesscontrol) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("PATCH", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.bucketAccessControls.patch" call. +// Exactly one of *BucketAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *BucketAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *BucketAccessControlsPatchCall) Do(opts ...googleapi.CallOption) (*BucketAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &BucketAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates an ACL entry on the specified bucket. This method supports patch semantics.", + // "httpMethod": "PATCH", + // "id": "storage.bucketAccessControls.patch", + // "parameterOrder": [ + // "bucket", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/acl/{entity}", + // "request": { + // "$ref": "BucketAccessControl" + // }, + // "response": { + // "$ref": "BucketAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.bucketAccessControls.update": + +type BucketAccessControlsUpdateCall struct { + s *Service + bucket string + entity string + bucketaccesscontrol *BucketAccessControl + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Update: Updates an ACL entry on the specified bucket. +func (r *BucketAccessControlsService) Update(bucket string, entity string, bucketaccesscontrol *BucketAccessControl) *BucketAccessControlsUpdateCall { + c := &BucketAccessControlsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.entity = entity + c.bucketaccesscontrol = bucketaccesscontrol + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketAccessControlsUpdateCall) Fields(s ...googleapi.Field) *BucketAccessControlsUpdateCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketAccessControlsUpdateCall) Context(ctx context.Context) *BucketAccessControlsUpdateCall { + c.ctx_ = ctx + return c +} + +func (c *BucketAccessControlsUpdateCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucketaccesscontrol) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("PUT", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.bucketAccessControls.update" call. +// Exactly one of *BucketAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *BucketAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *BucketAccessControlsUpdateCall) Do(opts ...googleapi.CallOption) (*BucketAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &BucketAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates an ACL entry on the specified bucket.", + // "httpMethod": "PUT", + // "id": "storage.bucketAccessControls.update", + // "parameterOrder": [ + // "bucket", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/acl/{entity}", + // "request": { + // "$ref": "BucketAccessControl" + // }, + // "response": { + // "$ref": "BucketAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.buckets.delete": + +type BucketsDeleteCall struct { + s *Service + bucket string + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Delete: Permanently deletes an empty bucket. +func (r *BucketsService) Delete(bucket string) *BucketsDeleteCall { + c := &BucketsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": If set, only deletes the bucket if its +// metageneration matches this value. +func (c *BucketsDeleteCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *BucketsDeleteCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": If set, only deletes the bucket if its +// metageneration does not match this value. +func (c *BucketsDeleteCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *BucketsDeleteCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketsDeleteCall) Fields(s ...googleapi.Field) *BucketsDeleteCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketsDeleteCall) Context(ctx context.Context) *BucketsDeleteCall { + c.ctx_ = ctx + return c +} + +func (c *BucketsDeleteCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("DELETE", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.buckets.delete" call. +func (c *BucketsDeleteCall) Do(opts ...googleapi.CallOption) error { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if err != nil { + return err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return err + } + return nil + // { + // "description": "Permanently deletes an empty bucket.", + // "httpMethod": "DELETE", + // "id": "storage.buckets.delete", + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "If set, only deletes the bucket if its metageneration matches this value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "If set, only deletes the bucket if its metageneration does not match this value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b/{bucket}", + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ] + // } + +} + +// method id "storage.buckets.get": + +type BucketsGetCall struct { + s *Service + bucket string + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context +} + +// Get: Returns metadata for the specified bucket. +func (r *BucketsService) Get(bucket string) *BucketsGetCall { + c := &BucketsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the return of the bucket metadata +// conditional on whether the bucket's current metageneration matches +// the given value. +func (c *BucketsGetCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *BucketsGetCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": Makes the return of the bucket metadata +// conditional on whether the bucket's current metageneration does not +// match the given value. +func (c *BucketsGetCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *BucketsGetCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to noAcl. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit owner, acl and defaultObjectAcl properties. +func (c *BucketsGetCall) Projection(projection string) *BucketsGetCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketsGetCall) Fields(s ...googleapi.Field) *BucketsGetCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *BucketsGetCall) IfNoneMatch(entityTag string) *BucketsGetCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketsGetCall) Context(ctx context.Context) *BucketsGetCall { + c.ctx_ = ctx + return c +} + +func (c *BucketsGetCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("GET", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.buckets.get" call. +// Exactly one of *Bucket or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Bucket.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *BucketsGetCall) Do(opts ...googleapi.CallOption) (*Bucket, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Bucket{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Returns metadata for the specified bucket.", + // "httpMethod": "GET", + // "id": "storage.buckets.get", + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to noAcl.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit owner, acl and defaultObjectAcl properties." + // ], + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b/{bucket}", + // "response": { + // "$ref": "Bucket" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/cloud-platform.read-only", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_only", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ] + // } + +} + +// method id "storage.buckets.insert": + +type BucketsInsertCall struct { + s *Service + bucket *Bucket + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Insert: Creates a new bucket. +func (r *BucketsService) Insert(projectid string, bucket *Bucket) *BucketsInsertCall { + c := &BucketsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.urlParams_.Set("project", projectid) + c.bucket = bucket + return c +} + +// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a +// predefined set of access controls to this bucket. +// +// Possible values: +// "authenticatedRead" - Project team owners get OWNER access, and +// allAuthenticatedUsers get READER access. +// "private" - Project team owners get OWNER access. +// "projectPrivate" - Project team members get access according to +// their roles. +// "publicRead" - Project team owners get OWNER access, and allUsers +// get READER access. +// "publicReadWrite" - Project team owners get OWNER access, and +// allUsers get WRITER access. +func (c *BucketsInsertCall) PredefinedAcl(predefinedAcl string) *BucketsInsertCall { + c.urlParams_.Set("predefinedAcl", predefinedAcl) + return c +} + +// PredefinedDefaultObjectAcl sets the optional parameter +// "predefinedDefaultObjectAcl": Apply a predefined set of default +// object access controls to this bucket. +// +// Possible values: +// "authenticatedRead" - Object owner gets OWNER access, and +// allAuthenticatedUsers get READER access. +// "bucketOwnerFullControl" - Object owner gets OWNER access, and +// project team owners get OWNER access. +// "bucketOwnerRead" - Object owner gets OWNER access, and project +// team owners get READER access. +// "private" - Object owner gets OWNER access. +// "projectPrivate" - Object owner gets OWNER access, and project team +// members get access according to their roles. +// "publicRead" - Object owner gets OWNER access, and allUsers get +// READER access. +func (c *BucketsInsertCall) PredefinedDefaultObjectAcl(predefinedDefaultObjectAcl string) *BucketsInsertCall { + c.urlParams_.Set("predefinedDefaultObjectAcl", predefinedDefaultObjectAcl) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to noAcl, unless the bucket resource +// specifies acl or defaultObjectAcl properties, when it defaults to +// full. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit owner, acl and defaultObjectAcl properties. +func (c *BucketsInsertCall) Projection(projection string) *BucketsInsertCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketsInsertCall) Fields(s ...googleapi.Field) *BucketsInsertCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketsInsertCall) Context(ctx context.Context) *BucketsInsertCall { + c.ctx_ = ctx + return c +} + +func (c *BucketsInsertCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucket) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("POST", urls, body) + req.Header = reqHeaders + googleapi.SetOpaque(req.URL) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.buckets.insert" call. +// Exactly one of *Bucket or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Bucket.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *BucketsInsertCall) Do(opts ...googleapi.CallOption) (*Bucket, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Bucket{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Creates a new bucket.", + // "httpMethod": "POST", + // "id": "storage.buckets.insert", + // "parameterOrder": [ + // "project" + // ], + // "parameters": { + // "predefinedAcl": { + // "description": "Apply a predefined set of access controls to this bucket.", + // "enum": [ + // "authenticatedRead", + // "private", + // "projectPrivate", + // "publicRead", + // "publicReadWrite" + // ], + // "enumDescriptions": [ + // "Project team owners get OWNER access, and allAuthenticatedUsers get READER access.", + // "Project team owners get OWNER access.", + // "Project team members get access according to their roles.", + // "Project team owners get OWNER access, and allUsers get READER access.", + // "Project team owners get OWNER access, and allUsers get WRITER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "predefinedDefaultObjectAcl": { + // "description": "Apply a predefined set of default object access controls to this bucket.", + // "enum": [ + // "authenticatedRead", + // "bucketOwnerFullControl", + // "bucketOwnerRead", + // "private", + // "projectPrivate", + // "publicRead" + // ], + // "enumDescriptions": [ + // "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.", + // "Object owner gets OWNER access, and project team owners get OWNER access.", + // "Object owner gets OWNER access, and project team owners get READER access.", + // "Object owner gets OWNER access.", + // "Object owner gets OWNER access, and project team members get access according to their roles.", + // "Object owner gets OWNER access, and allUsers get READER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "project": { + // "description": "A valid API project identifier.", + // "location": "query", + // "required": true, + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to noAcl, unless the bucket resource specifies acl or defaultObjectAcl properties, when it defaults to full.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit owner, acl and defaultObjectAcl properties." + // ], + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b", + // "request": { + // "$ref": "Bucket" + // }, + // "response": { + // "$ref": "Bucket" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ] + // } + +} + +// method id "storage.buckets.list": + +type BucketsListCall struct { + s *Service + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context +} + +// List: Retrieves a list of buckets for a given project. +func (r *BucketsService) List(projectid string) *BucketsListCall { + c := &BucketsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.urlParams_.Set("project", projectid) + return c +} + +// MaxResults sets the optional parameter "maxResults": Maximum number +// of buckets to return. +func (c *BucketsListCall) MaxResults(maxResults int64) *BucketsListCall { + c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) + return c +} + +// PageToken sets the optional parameter "pageToken": A +// previously-returned page token representing part of the larger set of +// results to view. +func (c *BucketsListCall) PageToken(pageToken string) *BucketsListCall { + c.urlParams_.Set("pageToken", pageToken) + return c +} + +// Prefix sets the optional parameter "prefix": Filter results to +// buckets whose names begin with this prefix. +func (c *BucketsListCall) Prefix(prefix string) *BucketsListCall { + c.urlParams_.Set("prefix", prefix) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to noAcl. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit owner, acl and defaultObjectAcl properties. +func (c *BucketsListCall) Projection(projection string) *BucketsListCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketsListCall) Fields(s ...googleapi.Field) *BucketsListCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *BucketsListCall) IfNoneMatch(entityTag string) *BucketsListCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketsListCall) Context(ctx context.Context) *BucketsListCall { + c.ctx_ = ctx + return c +} + +func (c *BucketsListCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("GET", urls, body) + req.Header = reqHeaders + googleapi.SetOpaque(req.URL) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.buckets.list" call. +// Exactly one of *Buckets or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Buckets.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *BucketsListCall) Do(opts ...googleapi.CallOption) (*Buckets, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Buckets{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Retrieves a list of buckets for a given project.", + // "httpMethod": "GET", + // "id": "storage.buckets.list", + // "parameterOrder": [ + // "project" + // ], + // "parameters": { + // "maxResults": { + // "description": "Maximum number of buckets to return.", + // "format": "uint32", + // "location": "query", + // "minimum": "0", + // "type": "integer" + // }, + // "pageToken": { + // "description": "A previously-returned page token representing part of the larger set of results to view.", + // "location": "query", + // "type": "string" + // }, + // "prefix": { + // "description": "Filter results to buckets whose names begin with this prefix.", + // "location": "query", + // "type": "string" + // }, + // "project": { + // "description": "A valid API project identifier.", + // "location": "query", + // "required": true, + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to noAcl.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit owner, acl and defaultObjectAcl properties." + // ], + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b", + // "response": { + // "$ref": "Buckets" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/cloud-platform.read-only", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_only", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ] + // } + +} + +// Pages invokes f for each page of results. +// A non-nil error returned from f will halt the iteration. +// The provided context supersedes any context provided to the Context method. +func (c *BucketsListCall) Pages(ctx context.Context, f func(*Buckets) error) error { + c.ctx_ = ctx + defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point + for { + x, err := c.Do() + if err != nil { + return err + } + if err := f(x); err != nil { + return err + } + if x.NextPageToken == "" { + return nil + } + c.PageToken(x.NextPageToken) + } +} + +// method id "storage.buckets.patch": + +type BucketsPatchCall struct { + s *Service + bucket string + bucket2 *Bucket + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Patch: Updates a bucket. This method supports patch semantics. +func (r *BucketsService) Patch(bucket string, bucket2 *Bucket) *BucketsPatchCall { + c := &BucketsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.bucket2 = bucket2 + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the return of the bucket metadata +// conditional on whether the bucket's current metageneration matches +// the given value. +func (c *BucketsPatchCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *BucketsPatchCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": Makes the return of the bucket metadata +// conditional on whether the bucket's current metageneration does not +// match the given value. +func (c *BucketsPatchCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *BucketsPatchCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a +// predefined set of access controls to this bucket. +// +// Possible values: +// "authenticatedRead" - Project team owners get OWNER access, and +// allAuthenticatedUsers get READER access. +// "private" - Project team owners get OWNER access. +// "projectPrivate" - Project team members get access according to +// their roles. +// "publicRead" - Project team owners get OWNER access, and allUsers +// get READER access. +// "publicReadWrite" - Project team owners get OWNER access, and +// allUsers get WRITER access. +func (c *BucketsPatchCall) PredefinedAcl(predefinedAcl string) *BucketsPatchCall { + c.urlParams_.Set("predefinedAcl", predefinedAcl) + return c +} + +// PredefinedDefaultObjectAcl sets the optional parameter +// "predefinedDefaultObjectAcl": Apply a predefined set of default +// object access controls to this bucket. +// +// Possible values: +// "authenticatedRead" - Object owner gets OWNER access, and +// allAuthenticatedUsers get READER access. +// "bucketOwnerFullControl" - Object owner gets OWNER access, and +// project team owners get OWNER access. +// "bucketOwnerRead" - Object owner gets OWNER access, and project +// team owners get READER access. +// "private" - Object owner gets OWNER access. +// "projectPrivate" - Object owner gets OWNER access, and project team +// members get access according to their roles. +// "publicRead" - Object owner gets OWNER access, and allUsers get +// READER access. +func (c *BucketsPatchCall) PredefinedDefaultObjectAcl(predefinedDefaultObjectAcl string) *BucketsPatchCall { + c.urlParams_.Set("predefinedDefaultObjectAcl", predefinedDefaultObjectAcl) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to full. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit owner, acl and defaultObjectAcl properties. +func (c *BucketsPatchCall) Projection(projection string) *BucketsPatchCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketsPatchCall) Fields(s ...googleapi.Field) *BucketsPatchCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketsPatchCall) Context(ctx context.Context) *BucketsPatchCall { + c.ctx_ = ctx + return c +} + +func (c *BucketsPatchCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucket2) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("PATCH", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.buckets.patch" call. +// Exactly one of *Bucket or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Bucket.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *BucketsPatchCall) Do(opts ...googleapi.CallOption) (*Bucket, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Bucket{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates a bucket. This method supports patch semantics.", + // "httpMethod": "PATCH", + // "id": "storage.buckets.patch", + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "predefinedAcl": { + // "description": "Apply a predefined set of access controls to this bucket.", + // "enum": [ + // "authenticatedRead", + // "private", + // "projectPrivate", + // "publicRead", + // "publicReadWrite" + // ], + // "enumDescriptions": [ + // "Project team owners get OWNER access, and allAuthenticatedUsers get READER access.", + // "Project team owners get OWNER access.", + // "Project team members get access according to their roles.", + // "Project team owners get OWNER access, and allUsers get READER access.", + // "Project team owners get OWNER access, and allUsers get WRITER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "predefinedDefaultObjectAcl": { + // "description": "Apply a predefined set of default object access controls to this bucket.", + // "enum": [ + // "authenticatedRead", + // "bucketOwnerFullControl", + // "bucketOwnerRead", + // "private", + // "projectPrivate", + // "publicRead" + // ], + // "enumDescriptions": [ + // "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.", + // "Object owner gets OWNER access, and project team owners get OWNER access.", + // "Object owner gets OWNER access, and project team owners get READER access.", + // "Object owner gets OWNER access.", + // "Object owner gets OWNER access, and project team members get access according to their roles.", + // "Object owner gets OWNER access, and allUsers get READER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to full.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit owner, acl and defaultObjectAcl properties." + // ], + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b/{bucket}", + // "request": { + // "$ref": "Bucket" + // }, + // "response": { + // "$ref": "Bucket" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.buckets.update": + +type BucketsUpdateCall struct { + s *Service + bucket string + bucket2 *Bucket + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Update: Updates a bucket. +func (r *BucketsService) Update(bucket string, bucket2 *Bucket) *BucketsUpdateCall { + c := &BucketsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.bucket2 = bucket2 + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the return of the bucket metadata +// conditional on whether the bucket's current metageneration matches +// the given value. +func (c *BucketsUpdateCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *BucketsUpdateCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": Makes the return of the bucket metadata +// conditional on whether the bucket's current metageneration does not +// match the given value. +func (c *BucketsUpdateCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *BucketsUpdateCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a +// predefined set of access controls to this bucket. +// +// Possible values: +// "authenticatedRead" - Project team owners get OWNER access, and +// allAuthenticatedUsers get READER access. +// "private" - Project team owners get OWNER access. +// "projectPrivate" - Project team members get access according to +// their roles. +// "publicRead" - Project team owners get OWNER access, and allUsers +// get READER access. +// "publicReadWrite" - Project team owners get OWNER access, and +// allUsers get WRITER access. +func (c *BucketsUpdateCall) PredefinedAcl(predefinedAcl string) *BucketsUpdateCall { + c.urlParams_.Set("predefinedAcl", predefinedAcl) + return c +} + +// PredefinedDefaultObjectAcl sets the optional parameter +// "predefinedDefaultObjectAcl": Apply a predefined set of default +// object access controls to this bucket. +// +// Possible values: +// "authenticatedRead" - Object owner gets OWNER access, and +// allAuthenticatedUsers get READER access. +// "bucketOwnerFullControl" - Object owner gets OWNER access, and +// project team owners get OWNER access. +// "bucketOwnerRead" - Object owner gets OWNER access, and project +// team owners get READER access. +// "private" - Object owner gets OWNER access. +// "projectPrivate" - Object owner gets OWNER access, and project team +// members get access according to their roles. +// "publicRead" - Object owner gets OWNER access, and allUsers get +// READER access. +func (c *BucketsUpdateCall) PredefinedDefaultObjectAcl(predefinedDefaultObjectAcl string) *BucketsUpdateCall { + c.urlParams_.Set("predefinedDefaultObjectAcl", predefinedDefaultObjectAcl) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to full. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit owner, acl and defaultObjectAcl properties. +func (c *BucketsUpdateCall) Projection(projection string) *BucketsUpdateCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *BucketsUpdateCall) Fields(s ...googleapi.Field) *BucketsUpdateCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *BucketsUpdateCall) Context(ctx context.Context) *BucketsUpdateCall { + c.ctx_ = ctx + return c +} + +func (c *BucketsUpdateCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucket2) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("PUT", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.buckets.update" call. +// Exactly one of *Bucket or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Bucket.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *BucketsUpdateCall) Do(opts ...googleapi.CallOption) (*Bucket, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Bucket{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates a bucket.", + // "httpMethod": "PUT", + // "id": "storage.buckets.update", + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "predefinedAcl": { + // "description": "Apply a predefined set of access controls to this bucket.", + // "enum": [ + // "authenticatedRead", + // "private", + // "projectPrivate", + // "publicRead", + // "publicReadWrite" + // ], + // "enumDescriptions": [ + // "Project team owners get OWNER access, and allAuthenticatedUsers get READER access.", + // "Project team owners get OWNER access.", + // "Project team members get access according to their roles.", + // "Project team owners get OWNER access, and allUsers get READER access.", + // "Project team owners get OWNER access, and allUsers get WRITER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "predefinedDefaultObjectAcl": { + // "description": "Apply a predefined set of default object access controls to this bucket.", + // "enum": [ + // "authenticatedRead", + // "bucketOwnerFullControl", + // "bucketOwnerRead", + // "private", + // "projectPrivate", + // "publicRead" + // ], + // "enumDescriptions": [ + // "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.", + // "Object owner gets OWNER access, and project team owners get OWNER access.", + // "Object owner gets OWNER access, and project team owners get READER access.", + // "Object owner gets OWNER access.", + // "Object owner gets OWNER access, and project team members get access according to their roles.", + // "Object owner gets OWNER access, and allUsers get READER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to full.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit owner, acl and defaultObjectAcl properties." + // ], + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b/{bucket}", + // "request": { + // "$ref": "Bucket" + // }, + // "response": { + // "$ref": "Bucket" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.channels.stop": + +type ChannelsStopCall struct { + s *Service + channel *Channel + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Stop: Stop watching resources through this channel +func (r *ChannelsService) Stop(channel *Channel) *ChannelsStopCall { + c := &ChannelsStopCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.channel = channel + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ChannelsStopCall) Fields(s ...googleapi.Field) *ChannelsStopCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ChannelsStopCall) Context(ctx context.Context) *ChannelsStopCall { + c.ctx_ = ctx + return c +} + +func (c *ChannelsStopCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.channel) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "channels/stop") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("POST", urls, body) + req.Header = reqHeaders + googleapi.SetOpaque(req.URL) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.channels.stop" call. +func (c *ChannelsStopCall) Do(opts ...googleapi.CallOption) error { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if err != nil { + return err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return err + } + return nil + // { + // "description": "Stop watching resources through this channel", + // "httpMethod": "POST", + // "id": "storage.channels.stop", + // "path": "channels/stop", + // "request": { + // "$ref": "Channel", + // "parameterName": "resource" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/cloud-platform.read-only", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_only", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ] + // } + +} + +// method id "storage.defaultObjectAccessControls.delete": + +type DefaultObjectAccessControlsDeleteCall struct { + s *Service + bucket string + entity string + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Delete: Permanently deletes the default object ACL entry for the +// specified entity on the specified bucket. +func (r *DefaultObjectAccessControlsService) Delete(bucket string, entity string) *DefaultObjectAccessControlsDeleteCall { + c := &DefaultObjectAccessControlsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.entity = entity + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *DefaultObjectAccessControlsDeleteCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsDeleteCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *DefaultObjectAccessControlsDeleteCall) Context(ctx context.Context) *DefaultObjectAccessControlsDeleteCall { + c.ctx_ = ctx + return c +} + +func (c *DefaultObjectAccessControlsDeleteCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("DELETE", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.defaultObjectAccessControls.delete" call. +func (c *DefaultObjectAccessControlsDeleteCall) Do(opts ...googleapi.CallOption) error { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if err != nil { + return err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return err + } + return nil + // { + // "description": "Permanently deletes the default object ACL entry for the specified entity on the specified bucket.", + // "httpMethod": "DELETE", + // "id": "storage.defaultObjectAccessControls.delete", + // "parameterOrder": [ + // "bucket", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/defaultObjectAcl/{entity}", + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.defaultObjectAccessControls.get": + +type DefaultObjectAccessControlsGetCall struct { + s *Service + bucket string + entity string + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context +} + +// Get: Returns the default object ACL entry for the specified entity on +// the specified bucket. +func (r *DefaultObjectAccessControlsService) Get(bucket string, entity string) *DefaultObjectAccessControlsGetCall { + c := &DefaultObjectAccessControlsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.entity = entity + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *DefaultObjectAccessControlsGetCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsGetCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *DefaultObjectAccessControlsGetCall) IfNoneMatch(entityTag string) *DefaultObjectAccessControlsGetCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *DefaultObjectAccessControlsGetCall) Context(ctx context.Context) *DefaultObjectAccessControlsGetCall { + c.ctx_ = ctx + return c +} + +func (c *DefaultObjectAccessControlsGetCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("GET", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.defaultObjectAccessControls.get" call. +// Exactly one of *ObjectAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ObjectAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *DefaultObjectAccessControlsGetCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &ObjectAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Returns the default object ACL entry for the specified entity on the specified bucket.", + // "httpMethod": "GET", + // "id": "storage.defaultObjectAccessControls.get", + // "parameterOrder": [ + // "bucket", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/defaultObjectAcl/{entity}", + // "response": { + // "$ref": "ObjectAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.defaultObjectAccessControls.insert": + +type DefaultObjectAccessControlsInsertCall struct { + s *Service + bucket string + objectaccesscontrol *ObjectAccessControl + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Insert: Creates a new default object ACL entry on the specified +// bucket. +func (r *DefaultObjectAccessControlsService) Insert(bucket string, objectaccesscontrol *ObjectAccessControl) *DefaultObjectAccessControlsInsertCall { + c := &DefaultObjectAccessControlsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.objectaccesscontrol = objectaccesscontrol + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *DefaultObjectAccessControlsInsertCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsInsertCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *DefaultObjectAccessControlsInsertCall) Context(ctx context.Context) *DefaultObjectAccessControlsInsertCall { + c.ctx_ = ctx + return c +} + +func (c *DefaultObjectAccessControlsInsertCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("POST", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.defaultObjectAccessControls.insert" call. +// Exactly one of *ObjectAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ObjectAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *DefaultObjectAccessControlsInsertCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &ObjectAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Creates a new default object ACL entry on the specified bucket.", + // "httpMethod": "POST", + // "id": "storage.defaultObjectAccessControls.insert", + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/defaultObjectAcl", + // "request": { + // "$ref": "ObjectAccessControl" + // }, + // "response": { + // "$ref": "ObjectAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.defaultObjectAccessControls.list": + +type DefaultObjectAccessControlsListCall struct { + s *Service + bucket string + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context +} + +// List: Retrieves default object ACL entries on the specified bucket. +func (r *DefaultObjectAccessControlsService) List(bucket string) *DefaultObjectAccessControlsListCall { + c := &DefaultObjectAccessControlsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": If present, only return default ACL listing +// if the bucket's current metageneration matches this value. +func (c *DefaultObjectAccessControlsListCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *DefaultObjectAccessControlsListCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": If present, only return default ACL +// listing if the bucket's current metageneration does not match the +// given value. +func (c *DefaultObjectAccessControlsListCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *DefaultObjectAccessControlsListCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *DefaultObjectAccessControlsListCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsListCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *DefaultObjectAccessControlsListCall) IfNoneMatch(entityTag string) *DefaultObjectAccessControlsListCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *DefaultObjectAccessControlsListCall) Context(ctx context.Context) *DefaultObjectAccessControlsListCall { + c.ctx_ = ctx + return c +} + +func (c *DefaultObjectAccessControlsListCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("GET", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.defaultObjectAccessControls.list" call. +// Exactly one of *ObjectAccessControls or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ObjectAccessControls.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *DefaultObjectAccessControlsListCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControls, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &ObjectAccessControls{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Retrieves default object ACL entries on the specified bucket.", + // "httpMethod": "GET", + // "id": "storage.defaultObjectAccessControls.list", + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "If present, only return default ACL listing if the bucket's current metageneration matches this value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "If present, only return default ACL listing if the bucket's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b/{bucket}/defaultObjectAcl", + // "response": { + // "$ref": "ObjectAccessControls" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.defaultObjectAccessControls.patch": + +type DefaultObjectAccessControlsPatchCall struct { + s *Service + bucket string + entity string + objectaccesscontrol *ObjectAccessControl + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Patch: Updates a default object ACL entry on the specified bucket. +// This method supports patch semantics. +func (r *DefaultObjectAccessControlsService) Patch(bucket string, entity string, objectaccesscontrol *ObjectAccessControl) *DefaultObjectAccessControlsPatchCall { + c := &DefaultObjectAccessControlsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.entity = entity + c.objectaccesscontrol = objectaccesscontrol + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *DefaultObjectAccessControlsPatchCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsPatchCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *DefaultObjectAccessControlsPatchCall) Context(ctx context.Context) *DefaultObjectAccessControlsPatchCall { + c.ctx_ = ctx + return c +} + +func (c *DefaultObjectAccessControlsPatchCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("PATCH", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.defaultObjectAccessControls.patch" call. +// Exactly one of *ObjectAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ObjectAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *DefaultObjectAccessControlsPatchCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &ObjectAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates a default object ACL entry on the specified bucket. This method supports patch semantics.", + // "httpMethod": "PATCH", + // "id": "storage.defaultObjectAccessControls.patch", + // "parameterOrder": [ + // "bucket", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/defaultObjectAcl/{entity}", + // "request": { + // "$ref": "ObjectAccessControl" + // }, + // "response": { + // "$ref": "ObjectAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.defaultObjectAccessControls.update": + +type DefaultObjectAccessControlsUpdateCall struct { + s *Service + bucket string + entity string + objectaccesscontrol *ObjectAccessControl + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Update: Updates a default object ACL entry on the specified bucket. +func (r *DefaultObjectAccessControlsService) Update(bucket string, entity string, objectaccesscontrol *ObjectAccessControl) *DefaultObjectAccessControlsUpdateCall { + c := &DefaultObjectAccessControlsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.entity = entity + c.objectaccesscontrol = objectaccesscontrol + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *DefaultObjectAccessControlsUpdateCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsUpdateCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *DefaultObjectAccessControlsUpdateCall) Context(ctx context.Context) *DefaultObjectAccessControlsUpdateCall { + c.ctx_ = ctx + return c +} + +func (c *DefaultObjectAccessControlsUpdateCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("PUT", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.defaultObjectAccessControls.update" call. +// Exactly one of *ObjectAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ObjectAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *DefaultObjectAccessControlsUpdateCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &ObjectAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates a default object ACL entry on the specified bucket.", + // "httpMethod": "PUT", + // "id": "storage.defaultObjectAccessControls.update", + // "parameterOrder": [ + // "bucket", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/defaultObjectAcl/{entity}", + // "request": { + // "$ref": "ObjectAccessControl" + // }, + // "response": { + // "$ref": "ObjectAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.objectAccessControls.delete": + +type ObjectAccessControlsDeleteCall struct { + s *Service + bucket string + object string + entity string + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Delete: Permanently deletes the ACL entry for the specified entity on +// the specified object. +func (r *ObjectAccessControlsService) Delete(bucket string, object string, entity string) *ObjectAccessControlsDeleteCall { + c := &ObjectAccessControlsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + c.entity = entity + return c +} + +// Generation sets the optional parameter "generation": If present, +// selects a specific revision of this object (as opposed to the latest +// version, the default). +func (c *ObjectAccessControlsDeleteCall) Generation(generation int64) *ObjectAccessControlsDeleteCall { + c.urlParams_.Set("generation", fmt.Sprint(generation)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectAccessControlsDeleteCall) Fields(s ...googleapi.Field) *ObjectAccessControlsDeleteCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectAccessControlsDeleteCall) Context(ctx context.Context) *ObjectAccessControlsDeleteCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectAccessControlsDeleteCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("DELETE", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "object": c.object, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objectAccessControls.delete" call. +func (c *ObjectAccessControlsDeleteCall) Do(opts ...googleapi.CallOption) error { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if err != nil { + return err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return err + } + return nil + // { + // "description": "Permanently deletes the ACL entry for the specified entity on the specified object.", + // "httpMethod": "DELETE", + // "id": "storage.objectAccessControls.delete", + // "parameterOrder": [ + // "bucket", + // "object", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "generation": { + // "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "object": { + // "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o/{object}/acl/{entity}", + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.objectAccessControls.get": + +type ObjectAccessControlsGetCall struct { + s *Service + bucket string + object string + entity string + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context +} + +// Get: Returns the ACL entry for the specified entity on the specified +// object. +func (r *ObjectAccessControlsService) Get(bucket string, object string, entity string) *ObjectAccessControlsGetCall { + c := &ObjectAccessControlsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + c.entity = entity + return c +} + +// Generation sets the optional parameter "generation": If present, +// selects a specific revision of this object (as opposed to the latest +// version, the default). +func (c *ObjectAccessControlsGetCall) Generation(generation int64) *ObjectAccessControlsGetCall { + c.urlParams_.Set("generation", fmt.Sprint(generation)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectAccessControlsGetCall) Fields(s ...googleapi.Field) *ObjectAccessControlsGetCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *ObjectAccessControlsGetCall) IfNoneMatch(entityTag string) *ObjectAccessControlsGetCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectAccessControlsGetCall) Context(ctx context.Context) *ObjectAccessControlsGetCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectAccessControlsGetCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("GET", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "object": c.object, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objectAccessControls.get" call. +// Exactly one of *ObjectAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ObjectAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *ObjectAccessControlsGetCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &ObjectAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Returns the ACL entry for the specified entity on the specified object.", + // "httpMethod": "GET", + // "id": "storage.objectAccessControls.get", + // "parameterOrder": [ + // "bucket", + // "object", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "generation": { + // "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "object": { + // "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o/{object}/acl/{entity}", + // "response": { + // "$ref": "ObjectAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.objectAccessControls.insert": + +type ObjectAccessControlsInsertCall struct { + s *Service + bucket string + object string + objectaccesscontrol *ObjectAccessControl + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Insert: Creates a new ACL entry on the specified object. +func (r *ObjectAccessControlsService) Insert(bucket string, object string, objectaccesscontrol *ObjectAccessControl) *ObjectAccessControlsInsertCall { + c := &ObjectAccessControlsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + c.objectaccesscontrol = objectaccesscontrol + return c +} + +// Generation sets the optional parameter "generation": If present, +// selects a specific revision of this object (as opposed to the latest +// version, the default). +func (c *ObjectAccessControlsInsertCall) Generation(generation int64) *ObjectAccessControlsInsertCall { + c.urlParams_.Set("generation", fmt.Sprint(generation)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectAccessControlsInsertCall) Fields(s ...googleapi.Field) *ObjectAccessControlsInsertCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectAccessControlsInsertCall) Context(ctx context.Context) *ObjectAccessControlsInsertCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectAccessControlsInsertCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("POST", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "object": c.object, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objectAccessControls.insert" call. +// Exactly one of *ObjectAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ObjectAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *ObjectAccessControlsInsertCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &ObjectAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Creates a new ACL entry on the specified object.", + // "httpMethod": "POST", + // "id": "storage.objectAccessControls.insert", + // "parameterOrder": [ + // "bucket", + // "object" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "generation": { + // "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "object": { + // "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o/{object}/acl", + // "request": { + // "$ref": "ObjectAccessControl" + // }, + // "response": { + // "$ref": "ObjectAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.objectAccessControls.list": + +type ObjectAccessControlsListCall struct { + s *Service + bucket string + object string + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context +} + +// List: Retrieves ACL entries on the specified object. +func (r *ObjectAccessControlsService) List(bucket string, object string) *ObjectAccessControlsListCall { + c := &ObjectAccessControlsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + return c +} + +// Generation sets the optional parameter "generation": If present, +// selects a specific revision of this object (as opposed to the latest +// version, the default). +func (c *ObjectAccessControlsListCall) Generation(generation int64) *ObjectAccessControlsListCall { + c.urlParams_.Set("generation", fmt.Sprint(generation)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectAccessControlsListCall) Fields(s ...googleapi.Field) *ObjectAccessControlsListCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *ObjectAccessControlsListCall) IfNoneMatch(entityTag string) *ObjectAccessControlsListCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectAccessControlsListCall) Context(ctx context.Context) *ObjectAccessControlsListCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectAccessControlsListCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("GET", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "object": c.object, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objectAccessControls.list" call. +// Exactly one of *ObjectAccessControls or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ObjectAccessControls.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *ObjectAccessControlsListCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControls, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &ObjectAccessControls{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Retrieves ACL entries on the specified object.", + // "httpMethod": "GET", + // "id": "storage.objectAccessControls.list", + // "parameterOrder": [ + // "bucket", + // "object" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "generation": { + // "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "object": { + // "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o/{object}/acl", + // "response": { + // "$ref": "ObjectAccessControls" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.objectAccessControls.patch": + +type ObjectAccessControlsPatchCall struct { + s *Service + bucket string + object string + entity string + objectaccesscontrol *ObjectAccessControl + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Patch: Updates an ACL entry on the specified object. This method +// supports patch semantics. +func (r *ObjectAccessControlsService) Patch(bucket string, object string, entity string, objectaccesscontrol *ObjectAccessControl) *ObjectAccessControlsPatchCall { + c := &ObjectAccessControlsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + c.entity = entity + c.objectaccesscontrol = objectaccesscontrol + return c +} + +// Generation sets the optional parameter "generation": If present, +// selects a specific revision of this object (as opposed to the latest +// version, the default). +func (c *ObjectAccessControlsPatchCall) Generation(generation int64) *ObjectAccessControlsPatchCall { + c.urlParams_.Set("generation", fmt.Sprint(generation)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectAccessControlsPatchCall) Fields(s ...googleapi.Field) *ObjectAccessControlsPatchCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectAccessControlsPatchCall) Context(ctx context.Context) *ObjectAccessControlsPatchCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectAccessControlsPatchCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("PATCH", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "object": c.object, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objectAccessControls.patch" call. +// Exactly one of *ObjectAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ObjectAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *ObjectAccessControlsPatchCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &ObjectAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates an ACL entry on the specified object. This method supports patch semantics.", + // "httpMethod": "PATCH", + // "id": "storage.objectAccessControls.patch", + // "parameterOrder": [ + // "bucket", + // "object", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "generation": { + // "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "object": { + // "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o/{object}/acl/{entity}", + // "request": { + // "$ref": "ObjectAccessControl" + // }, + // "response": { + // "$ref": "ObjectAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.objectAccessControls.update": + +type ObjectAccessControlsUpdateCall struct { + s *Service + bucket string + object string + entity string + objectaccesscontrol *ObjectAccessControl + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Update: Updates an ACL entry on the specified object. +func (r *ObjectAccessControlsService) Update(bucket string, object string, entity string, objectaccesscontrol *ObjectAccessControl) *ObjectAccessControlsUpdateCall { + c := &ObjectAccessControlsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + c.entity = entity + c.objectaccesscontrol = objectaccesscontrol + return c +} + +// Generation sets the optional parameter "generation": If present, +// selects a specific revision of this object (as opposed to the latest +// version, the default). +func (c *ObjectAccessControlsUpdateCall) Generation(generation int64) *ObjectAccessControlsUpdateCall { + c.urlParams_.Set("generation", fmt.Sprint(generation)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectAccessControlsUpdateCall) Fields(s ...googleapi.Field) *ObjectAccessControlsUpdateCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectAccessControlsUpdateCall) Context(ctx context.Context) *ObjectAccessControlsUpdateCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectAccessControlsUpdateCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl/{entity}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("PUT", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "object": c.object, + "entity": c.entity, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objectAccessControls.update" call. +// Exactly one of *ObjectAccessControl or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ObjectAccessControl.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *ObjectAccessControlsUpdateCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &ObjectAccessControl{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates an ACL entry on the specified object.", + // "httpMethod": "PUT", + // "id": "storage.objectAccessControls.update", + // "parameterOrder": [ + // "bucket", + // "object", + // "entity" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of a bucket.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "entity": { + // "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "generation": { + // "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "object": { + // "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o/{object}/acl/{entity}", + // "request": { + // "$ref": "ObjectAccessControl" + // }, + // "response": { + // "$ref": "ObjectAccessControl" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.objects.compose": + +type ObjectsComposeCall struct { + s *Service + destinationBucket string + destinationObject string + composerequest *ComposeRequest + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Compose: Concatenates a list of existing objects into a new object in +// the same bucket. +func (r *ObjectsService) Compose(destinationBucket string, destinationObject string, composerequest *ComposeRequest) *ObjectsComposeCall { + c := &ObjectsComposeCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.destinationBucket = destinationBucket + c.destinationObject = destinationObject + c.composerequest = composerequest + return c +} + +// DestinationPredefinedAcl sets the optional parameter +// "destinationPredefinedAcl": Apply a predefined set of access controls +// to the destination object. +// +// Possible values: +// "authenticatedRead" - Object owner gets OWNER access, and +// allAuthenticatedUsers get READER access. +// "bucketOwnerFullControl" - Object owner gets OWNER access, and +// project team owners get OWNER access. +// "bucketOwnerRead" - Object owner gets OWNER access, and project +// team owners get READER access. +// "private" - Object owner gets OWNER access. +// "projectPrivate" - Object owner gets OWNER access, and project team +// members get access according to their roles. +// "publicRead" - Object owner gets OWNER access, and allUsers get +// READER access. +func (c *ObjectsComposeCall) DestinationPredefinedAcl(destinationPredefinedAcl string) *ObjectsComposeCall { + c.urlParams_.Set("destinationPredefinedAcl", destinationPredefinedAcl) + return c +} + +// IfGenerationMatch sets the optional parameter "ifGenerationMatch": +// Makes the operation conditional on whether the object's current +// generation matches the given value. +func (c *ObjectsComposeCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsComposeCall { + c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch)) + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the operation conditional on whether +// the object's current metageneration matches the given value. +func (c *ObjectsComposeCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsComposeCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// KmsKeyName sets the optional parameter "kmsKeyName": Resource name of +// the Cloud KMS key, of the form +// projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, +// that will be used to encrypt the object. Overrides the object +// metadata's kms_key_name value, if any. +func (c *ObjectsComposeCall) KmsKeyName(kmsKeyName string) *ObjectsComposeCall { + c.urlParams_.Set("kmsKeyName", kmsKeyName) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectsComposeCall) Fields(s ...googleapi.Field) *ObjectsComposeCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do and Download +// methods. Any pending HTTP request will be aborted if the provided +// context is canceled. +func (c *ObjectsComposeCall) Context(ctx context.Context) *ObjectsComposeCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectsComposeCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.composerequest) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{destinationBucket}/o/{destinationObject}/compose") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("POST", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "destinationBucket": c.destinationBucket, + "destinationObject": c.destinationObject, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Download fetches the API endpoint's "media" value, instead of the normal +// API response value. If the returned error is nil, the Response is guaranteed to +// have a 2xx status code. Callers must close the Response.Body as usual. +func (c *ObjectsComposeCall) Download(opts ...googleapi.CallOption) (*http.Response, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("media") + if err != nil { + return nil, err + } + if err := googleapi.CheckMediaResponse(res); err != nil { + res.Body.Close() + return nil, err + } + return res, nil +} + +// Do executes the "storage.objects.compose" call. +// Exactly one of *Object or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Object.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *ObjectsComposeCall) Do(opts ...googleapi.CallOption) (*Object, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Object{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Concatenates a list of existing objects into a new object in the same bucket.", + // "httpMethod": "POST", + // "id": "storage.objects.compose", + // "parameterOrder": [ + // "destinationBucket", + // "destinationObject" + // ], + // "parameters": { + // "destinationBucket": { + // "description": "Name of the bucket in which to store the new object.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "destinationObject": { + // "description": "Name of the new object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "destinationPredefinedAcl": { + // "description": "Apply a predefined set of access controls to the destination object.", + // "enum": [ + // "authenticatedRead", + // "bucketOwnerFullControl", + // "bucketOwnerRead", + // "private", + // "projectPrivate", + // "publicRead" + // ], + // "enumDescriptions": [ + // "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.", + // "Object owner gets OWNER access, and project team owners get OWNER access.", + // "Object owner gets OWNER access, and project team owners get READER access.", + // "Object owner gets OWNER access.", + // "Object owner gets OWNER access, and project team members get access according to their roles.", + // "Object owner gets OWNER access, and allUsers get READER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "ifGenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current generation matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "kmsKeyName": { + // "description": "Resource name of the Cloud KMS key, of the form projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, that will be used to encrypt the object. Overrides the object metadata's kms_key_name value, if any.", + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b/{destinationBucket}/o/{destinationObject}/compose", + // "request": { + // "$ref": "ComposeRequest" + // }, + // "response": { + // "$ref": "Object" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ], + // "supportsMediaDownload": true, + // "useMediaDownloadService": true + // } + +} + +// method id "storage.objects.copy": + +type ObjectsCopyCall struct { + s *Service + sourceBucket string + sourceObject string + destinationBucket string + destinationObject string + object *Object + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Copy: Copies a source object to a destination object. Optionally +// overrides metadata. +func (r *ObjectsService) Copy(sourceBucket string, sourceObject string, destinationBucket string, destinationObject string, object *Object) *ObjectsCopyCall { + c := &ObjectsCopyCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.sourceBucket = sourceBucket + c.sourceObject = sourceObject + c.destinationBucket = destinationBucket + c.destinationObject = destinationObject + c.object = object + return c +} + +// DestinationPredefinedAcl sets the optional parameter +// "destinationPredefinedAcl": Apply a predefined set of access controls +// to the destination object. +// +// Possible values: +// "authenticatedRead" - Object owner gets OWNER access, and +// allAuthenticatedUsers get READER access. +// "bucketOwnerFullControl" - Object owner gets OWNER access, and +// project team owners get OWNER access. +// "bucketOwnerRead" - Object owner gets OWNER access, and project +// team owners get READER access. +// "private" - Object owner gets OWNER access. +// "projectPrivate" - Object owner gets OWNER access, and project team +// members get access according to their roles. +// "publicRead" - Object owner gets OWNER access, and allUsers get +// READER access. +func (c *ObjectsCopyCall) DestinationPredefinedAcl(destinationPredefinedAcl string) *ObjectsCopyCall { + c.urlParams_.Set("destinationPredefinedAcl", destinationPredefinedAcl) + return c +} + +// IfGenerationMatch sets the optional parameter "ifGenerationMatch": +// Makes the operation conditional on whether the destination object's +// current generation matches the given value. +func (c *ObjectsCopyCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsCopyCall { + c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch)) + return c +} + +// IfGenerationNotMatch sets the optional parameter +// "ifGenerationNotMatch": Makes the operation conditional on whether +// the destination object's current generation does not match the given +// value. +func (c *ObjectsCopyCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsCopyCall { + c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch)) + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the operation conditional on whether +// the destination object's current metageneration matches the given +// value. +func (c *ObjectsCopyCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsCopyCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": Makes the operation conditional on +// whether the destination object's current metageneration does not +// match the given value. +func (c *ObjectsCopyCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsCopyCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// IfSourceGenerationMatch sets the optional parameter +// "ifSourceGenerationMatch": Makes the operation conditional on whether +// the source object's generation matches the given value. +func (c *ObjectsCopyCall) IfSourceGenerationMatch(ifSourceGenerationMatch int64) *ObjectsCopyCall { + c.urlParams_.Set("ifSourceGenerationMatch", fmt.Sprint(ifSourceGenerationMatch)) + return c +} + +// IfSourceGenerationNotMatch sets the optional parameter +// "ifSourceGenerationNotMatch": Makes the operation conditional on +// whether the source object's generation does not match the given +// value. +func (c *ObjectsCopyCall) IfSourceGenerationNotMatch(ifSourceGenerationNotMatch int64) *ObjectsCopyCall { + c.urlParams_.Set("ifSourceGenerationNotMatch", fmt.Sprint(ifSourceGenerationNotMatch)) + return c +} + +// IfSourceMetagenerationMatch sets the optional parameter +// "ifSourceMetagenerationMatch": Makes the operation conditional on +// whether the source object's current metageneration matches the given +// value. +func (c *ObjectsCopyCall) IfSourceMetagenerationMatch(ifSourceMetagenerationMatch int64) *ObjectsCopyCall { + c.urlParams_.Set("ifSourceMetagenerationMatch", fmt.Sprint(ifSourceMetagenerationMatch)) + return c +} + +// IfSourceMetagenerationNotMatch sets the optional parameter +// "ifSourceMetagenerationNotMatch": Makes the operation conditional on +// whether the source object's current metageneration does not match the +// given value. +func (c *ObjectsCopyCall) IfSourceMetagenerationNotMatch(ifSourceMetagenerationNotMatch int64) *ObjectsCopyCall { + c.urlParams_.Set("ifSourceMetagenerationNotMatch", fmt.Sprint(ifSourceMetagenerationNotMatch)) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to noAcl, unless the object resource +// specifies the acl property, when it defaults to full. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit the owner, acl property. +func (c *ObjectsCopyCall) Projection(projection string) *ObjectsCopyCall { + c.urlParams_.Set("projection", projection) + return c +} + +// SourceGeneration sets the optional parameter "sourceGeneration": If +// present, selects a specific revision of the source object (as opposed +// to the latest version, the default). +func (c *ObjectsCopyCall) SourceGeneration(sourceGeneration int64) *ObjectsCopyCall { + c.urlParams_.Set("sourceGeneration", fmt.Sprint(sourceGeneration)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectsCopyCall) Fields(s ...googleapi.Field) *ObjectsCopyCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do and Download +// methods. Any pending HTTP request will be aborted if the provided +// context is canceled. +func (c *ObjectsCopyCall) Context(ctx context.Context) *ObjectsCopyCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectsCopyCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.object) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{sourceBucket}/o/{sourceObject}/copyTo/b/{destinationBucket}/o/{destinationObject}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("POST", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "sourceBucket": c.sourceBucket, + "sourceObject": c.sourceObject, + "destinationBucket": c.destinationBucket, + "destinationObject": c.destinationObject, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Download fetches the API endpoint's "media" value, instead of the normal +// API response value. If the returned error is nil, the Response is guaranteed to +// have a 2xx status code. Callers must close the Response.Body as usual. +func (c *ObjectsCopyCall) Download(opts ...googleapi.CallOption) (*http.Response, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("media") + if err != nil { + return nil, err + } + if err := googleapi.CheckMediaResponse(res); err != nil { + res.Body.Close() + return nil, err + } + return res, nil +} + +// Do executes the "storage.objects.copy" call. +// Exactly one of *Object or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Object.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *ObjectsCopyCall) Do(opts ...googleapi.CallOption) (*Object, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Object{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Copies a source object to a destination object. Optionally overrides metadata.", + // "httpMethod": "POST", + // "id": "storage.objects.copy", + // "parameterOrder": [ + // "sourceBucket", + // "sourceObject", + // "destinationBucket", + // "destinationObject" + // ], + // "parameters": { + // "destinationBucket": { + // "description": "Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any.For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "destinationObject": { + // "description": "Name of the new object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "destinationPredefinedAcl": { + // "description": "Apply a predefined set of access controls to the destination object.", + // "enum": [ + // "authenticatedRead", + // "bucketOwnerFullControl", + // "bucketOwnerRead", + // "private", + // "projectPrivate", + // "publicRead" + // ], + // "enumDescriptions": [ + // "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.", + // "Object owner gets OWNER access, and project team owners get OWNER access.", + // "Object owner gets OWNER access, and project team owners get READER access.", + // "Object owner gets OWNER access.", + // "Object owner gets OWNER access, and project team members get access according to their roles.", + // "Object owner gets OWNER access, and allUsers get READER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "ifGenerationMatch": { + // "description": "Makes the operation conditional on whether the destination object's current generation matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationNotMatch": { + // "description": "Makes the operation conditional on whether the destination object's current generation does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the operation conditional on whether the destination object's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "Makes the operation conditional on whether the destination object's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifSourceGenerationMatch": { + // "description": "Makes the operation conditional on whether the source object's generation matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifSourceGenerationNotMatch": { + // "description": "Makes the operation conditional on whether the source object's generation does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifSourceMetagenerationMatch": { + // "description": "Makes the operation conditional on whether the source object's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifSourceMetagenerationNotMatch": { + // "description": "Makes the operation conditional on whether the source object's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit the owner, acl property." + // ], + // "location": "query", + // "type": "string" + // }, + // "sourceBucket": { + // "description": "Name of the bucket in which to find the source object.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "sourceGeneration": { + // "description": "If present, selects a specific revision of the source object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "sourceObject": { + // "description": "Name of the source object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{sourceBucket}/o/{sourceObject}/copyTo/b/{destinationBucket}/o/{destinationObject}", + // "request": { + // "$ref": "Object" + // }, + // "response": { + // "$ref": "Object" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ], + // "supportsMediaDownload": true, + // "useMediaDownloadService": true + // } + +} + +// method id "storage.objects.delete": + +type ObjectsDeleteCall struct { + s *Service + bucket string + object string + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Delete: Deletes an object and its metadata. Deletions are permanent +// if versioning is not enabled for the bucket, or if the generation +// parameter is used. +func (r *ObjectsService) Delete(bucket string, object string) *ObjectsDeleteCall { + c := &ObjectsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + return c +} + +// Generation sets the optional parameter "generation": If present, +// permanently deletes a specific revision of this object (as opposed to +// the latest version, the default). +func (c *ObjectsDeleteCall) Generation(generation int64) *ObjectsDeleteCall { + c.urlParams_.Set("generation", fmt.Sprint(generation)) + return c +} + +// IfGenerationMatch sets the optional parameter "ifGenerationMatch": +// Makes the operation conditional on whether the object's current +// generation matches the given value. +func (c *ObjectsDeleteCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsDeleteCall { + c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch)) + return c +} + +// IfGenerationNotMatch sets the optional parameter +// "ifGenerationNotMatch": Makes the operation conditional on whether +// the object's current generation does not match the given value. +func (c *ObjectsDeleteCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsDeleteCall { + c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch)) + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the operation conditional on whether +// the object's current metageneration matches the given value. +func (c *ObjectsDeleteCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsDeleteCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": Makes the operation conditional on +// whether the object's current metageneration does not match the given +// value. +func (c *ObjectsDeleteCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsDeleteCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectsDeleteCall) Fields(s ...googleapi.Field) *ObjectsDeleteCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectsDeleteCall) Context(ctx context.Context) *ObjectsDeleteCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectsDeleteCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("DELETE", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "object": c.object, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objects.delete" call. +func (c *ObjectsDeleteCall) Do(opts ...googleapi.CallOption) error { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if err != nil { + return err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return err + } + return nil + // { + // "description": "Deletes an object and its metadata. Deletions are permanent if versioning is not enabled for the bucket, or if the generation parameter is used.", + // "httpMethod": "DELETE", + // "id": "storage.objects.delete", + // "parameterOrder": [ + // "bucket", + // "object" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of the bucket in which the object resides.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "generation": { + // "description": "If present, permanently deletes a specific revision of this object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current generation matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationNotMatch": { + // "description": "Makes the operation conditional on whether the object's current generation does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "object": { + // "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o/{object}", + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ] + // } + +} + +// method id "storage.objects.get": + +type ObjectsGetCall struct { + s *Service + bucket string + object string + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context +} + +// Get: Retrieves an object or its metadata. +func (r *ObjectsService) Get(bucket string, object string) *ObjectsGetCall { + c := &ObjectsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + return c +} + +// Generation sets the optional parameter "generation": If present, +// selects a specific revision of this object (as opposed to the latest +// version, the default). +func (c *ObjectsGetCall) Generation(generation int64) *ObjectsGetCall { + c.urlParams_.Set("generation", fmt.Sprint(generation)) + return c +} + +// IfGenerationMatch sets the optional parameter "ifGenerationMatch": +// Makes the operation conditional on whether the object's generation +// matches the given value. +func (c *ObjectsGetCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsGetCall { + c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch)) + return c +} + +// IfGenerationNotMatch sets the optional parameter +// "ifGenerationNotMatch": Makes the operation conditional on whether +// the object's generation does not match the given value. +func (c *ObjectsGetCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsGetCall { + c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch)) + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the operation conditional on whether +// the object's current metageneration matches the given value. +func (c *ObjectsGetCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsGetCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": Makes the operation conditional on +// whether the object's current metageneration does not match the given +// value. +func (c *ObjectsGetCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsGetCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to noAcl. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit the owner, acl property. +func (c *ObjectsGetCall) Projection(projection string) *ObjectsGetCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectsGetCall) Fields(s ...googleapi.Field) *ObjectsGetCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *ObjectsGetCall) IfNoneMatch(entityTag string) *ObjectsGetCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do and Download +// methods. Any pending HTTP request will be aborted if the provided +// context is canceled. +func (c *ObjectsGetCall) Context(ctx context.Context) *ObjectsGetCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectsGetCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("GET", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "object": c.object, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Download fetches the API endpoint's "media" value, instead of the normal +// API response value. If the returned error is nil, the Response is guaranteed to +// have a 2xx status code. Callers must close the Response.Body as usual. +func (c *ObjectsGetCall) Download(opts ...googleapi.CallOption) (*http.Response, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("media") + if err != nil { + return nil, err + } + if err := googleapi.CheckMediaResponse(res); err != nil { + res.Body.Close() + return nil, err + } + return res, nil +} + +// Do executes the "storage.objects.get" call. +// Exactly one of *Object or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Object.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *ObjectsGetCall) Do(opts ...googleapi.CallOption) (*Object, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Object{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Retrieves an object or its metadata.", + // "httpMethod": "GET", + // "id": "storage.objects.get", + // "parameterOrder": [ + // "bucket", + // "object" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of the bucket in which the object resides.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "generation": { + // "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationMatch": { + // "description": "Makes the operation conditional on whether the object's generation matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationNotMatch": { + // "description": "Makes the operation conditional on whether the object's generation does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "object": { + // "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to noAcl.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit the owner, acl property." + // ], + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o/{object}", + // "response": { + // "$ref": "Object" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/cloud-platform.read-only", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_only", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ], + // "supportsMediaDownload": true, + // "useMediaDownloadService": true + // } + +} + +// method id "storage.objects.insert": + +type ObjectsInsertCall struct { + s *Service + bucket string + object *Object + urlParams_ gensupport.URLParams + media_ io.Reader + mediaBuffer_ *gensupport.MediaBuffer + mediaType_ string + mediaSize_ int64 // mediaSize, if known. Used only for calls to progressUpdater_. + progressUpdater_ googleapi.ProgressUpdater + ctx_ context.Context +} + +// Insert: Stores a new object and metadata. +func (r *ObjectsService) Insert(bucket string, object *Object) *ObjectsInsertCall { + c := &ObjectsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + return c +} + +// ContentEncoding sets the optional parameter "contentEncoding": If +// set, sets the contentEncoding property of the final object to this +// value. Setting this parameter is equivalent to setting the +// contentEncoding metadata property. This can be useful when uploading +// an object with uploadType=media to indicate the encoding of the +// content being uploaded. +func (c *ObjectsInsertCall) ContentEncoding(contentEncoding string) *ObjectsInsertCall { + c.urlParams_.Set("contentEncoding", contentEncoding) + return c +} + +// IfGenerationMatch sets the optional parameter "ifGenerationMatch": +// Makes the operation conditional on whether the object's current +// generation matches the given value. +func (c *ObjectsInsertCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsInsertCall { + c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch)) + return c +} + +// IfGenerationNotMatch sets the optional parameter +// "ifGenerationNotMatch": Makes the operation conditional on whether +// the object's current generation does not match the given value. +func (c *ObjectsInsertCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsInsertCall { + c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch)) + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the operation conditional on whether +// the object's current metageneration matches the given value. +func (c *ObjectsInsertCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsInsertCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": Makes the operation conditional on +// whether the object's current metageneration does not match the given +// value. +func (c *ObjectsInsertCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsInsertCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// KmsKeyName sets the optional parameter "kmsKeyName": Resource name of +// the Cloud KMS key, of the form +// projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, +// that will be used to encrypt the object. Overrides the object +// metadata's kms_key_name value, if any. +func (c *ObjectsInsertCall) KmsKeyName(kmsKeyName string) *ObjectsInsertCall { + c.urlParams_.Set("kmsKeyName", kmsKeyName) + return c +} + +// Name sets the optional parameter "name": Name of the object. Required +// when the object metadata is not otherwise provided. Overrides the +// object metadata's name value, if any. For information about how to +// URL encode object names to be path safe, see Encoding URI Path Parts. +func (c *ObjectsInsertCall) Name(name string) *ObjectsInsertCall { + c.urlParams_.Set("name", name) + return c +} + +// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a +// predefined set of access controls to this object. +// +// Possible values: +// "authenticatedRead" - Object owner gets OWNER access, and +// allAuthenticatedUsers get READER access. +// "bucketOwnerFullControl" - Object owner gets OWNER access, and +// project team owners get OWNER access. +// "bucketOwnerRead" - Object owner gets OWNER access, and project +// team owners get READER access. +// "private" - Object owner gets OWNER access. +// "projectPrivate" - Object owner gets OWNER access, and project team +// members get access according to their roles. +// "publicRead" - Object owner gets OWNER access, and allUsers get +// READER access. +func (c *ObjectsInsertCall) PredefinedAcl(predefinedAcl string) *ObjectsInsertCall { + c.urlParams_.Set("predefinedAcl", predefinedAcl) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to noAcl, unless the object resource +// specifies the acl property, when it defaults to full. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit the owner, acl property. +func (c *ObjectsInsertCall) Projection(projection string) *ObjectsInsertCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Media specifies the media to upload in one or more chunks. The chunk +// size may be controlled by supplying a MediaOption generated by +// googleapi.ChunkSize. The chunk size defaults to +// googleapi.DefaultUploadChunkSize.The Content-Type header used in the +// upload request will be determined by sniffing the contents of r, +// unless a MediaOption generated by googleapi.ContentType is +// supplied. +// At most one of Media and ResumableMedia may be set. +func (c *ObjectsInsertCall) Media(r io.Reader, options ...googleapi.MediaOption) *ObjectsInsertCall { + if ct := c.object.ContentType; ct != "" { + options = append([]googleapi.MediaOption{googleapi.ContentType(ct)}, options...) + } + opts := googleapi.ProcessMediaOptions(options) + chunkSize := opts.ChunkSize + if !opts.ForceEmptyContentType { + r, c.mediaType_ = gensupport.DetermineContentType(r, opts.ContentType) + } + c.media_, c.mediaBuffer_ = gensupport.PrepareUpload(r, chunkSize) + return c +} + +// ResumableMedia specifies the media to upload in chunks and can be +// canceled with ctx. +// +// Deprecated: use Media instead. +// +// At most one of Media and ResumableMedia may be set. mediaType +// identifies the MIME media type of the upload, such as "image/png". If +// mediaType is "", it will be auto-detected. The provided ctx will +// supersede any context previously provided to the Context method. +func (c *ObjectsInsertCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *ObjectsInsertCall { + c.ctx_ = ctx + rdr := gensupport.ReaderAtToReader(r, size) + rdr, c.mediaType_ = gensupport.DetermineContentType(rdr, mediaType) + c.mediaBuffer_ = gensupport.NewMediaBuffer(rdr, googleapi.DefaultUploadChunkSize) + c.media_ = nil + c.mediaSize_ = size + return c +} + +// ProgressUpdater provides a callback function that will be called +// after every chunk. It should be a low-latency function in order to +// not slow down the upload operation. This should only be called when +// using ResumableMedia (as opposed to Media). +func (c *ObjectsInsertCall) ProgressUpdater(pu googleapi.ProgressUpdater) *ObjectsInsertCall { + c.progressUpdater_ = pu + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectsInsertCall) Fields(s ...googleapi.Field) *ObjectsInsertCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +// This context will supersede any context previously provided to the +// ResumableMedia method. +func (c *ObjectsInsertCall) Context(ctx context.Context) *ObjectsInsertCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectsInsertCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.object) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o") + if c.media_ != nil || c.mediaBuffer_ != nil { + urls = strings.Replace(urls, "https://www.googleapis.com/", "https://www.googleapis.com/upload/", 1) + protocol := "multipart" + if c.mediaBuffer_ != nil { + protocol = "resumable" + } + c.urlParams_.Set("uploadType", protocol) + } + if body == nil { + body = new(bytes.Buffer) + reqHeaders.Set("Content-Type", "application/json") + } + if c.media_ != nil { + combined, ctype := gensupport.CombineBodyMedia(body, "application/json", c.media_, c.mediaType_) + defer combined.Close() + reqHeaders.Set("Content-Type", ctype) + body = combined + } + if c.mediaBuffer_ != nil && c.mediaType_ != "" { + reqHeaders.Set("X-Upload-Content-Type", c.mediaType_) + } + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("POST", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objects.insert" call. +// Exactly one of *Object or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Object.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *ObjectsInsertCall) Do(opts ...googleapi.CallOption) (*Object, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + if c.mediaBuffer_ != nil { + loc := res.Header.Get("Location") + rx := &gensupport.ResumableUpload{ + Client: c.s.client, + UserAgent: c.s.userAgent(), + URI: loc, + Media: c.mediaBuffer_, + MediaType: c.mediaType_, + Callback: func(curr int64) { + if c.progressUpdater_ != nil { + c.progressUpdater_(curr, c.mediaSize_) + } + }, + } + ctx := c.ctx_ + if ctx == nil { + ctx = context.TODO() + } + res, err = rx.Upload(ctx) + if err != nil { + return nil, err + } + defer res.Body.Close() + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + } + ret := &Object{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Stores a new object and metadata.", + // "httpMethod": "POST", + // "id": "storage.objects.insert", + // "mediaUpload": { + // "accept": [ + // "*/*" + // ], + // "protocols": { + // "resumable": { + // "multipart": true, + // "path": "/resumable/upload/storage/v1/b/{bucket}/o" + // }, + // "simple": { + // "multipart": true, + // "path": "/upload/storage/v1/b/{bucket}/o" + // } + // } + // }, + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "contentEncoding": { + // "description": "If set, sets the contentEncoding property of the final object to this value. Setting this parameter is equivalent to setting the contentEncoding metadata property. This can be useful when uploading an object with uploadType=media to indicate the encoding of the content being uploaded.", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current generation matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationNotMatch": { + // "description": "Makes the operation conditional on whether the object's current generation does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "kmsKeyName": { + // "description": "Resource name of the Cloud KMS key, of the form projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, that will be used to encrypt the object. Overrides the object metadata's kms_key_name value, if any.", + // "location": "query", + // "type": "string" + // }, + // "name": { + // "description": "Name of the object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "query", + // "type": "string" + // }, + // "predefinedAcl": { + // "description": "Apply a predefined set of access controls to this object.", + // "enum": [ + // "authenticatedRead", + // "bucketOwnerFullControl", + // "bucketOwnerRead", + // "private", + // "projectPrivate", + // "publicRead" + // ], + // "enumDescriptions": [ + // "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.", + // "Object owner gets OWNER access, and project team owners get OWNER access.", + // "Object owner gets OWNER access, and project team owners get READER access.", + // "Object owner gets OWNER access.", + // "Object owner gets OWNER access, and project team members get access according to their roles.", + // "Object owner gets OWNER access, and allUsers get READER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit the owner, acl property." + // ], + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o", + // "request": { + // "$ref": "Object" + // }, + // "response": { + // "$ref": "Object" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ], + // "supportsMediaDownload": true, + // "supportsMediaUpload": true, + // "useMediaDownloadService": true + // } + +} + +// method id "storage.objects.list": + +type ObjectsListCall struct { + s *Service + bucket string + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context +} + +// List: Retrieves a list of objects matching the criteria. +func (r *ObjectsService) List(bucket string) *ObjectsListCall { + c := &ObjectsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + return c +} + +// Delimiter sets the optional parameter "delimiter": Returns results in +// a directory-like mode. items will contain only objects whose names, +// aside from the prefix, do not contain delimiter. Objects whose names, +// aside from the prefix, contain delimiter will have their name, +// truncated after the delimiter, returned in prefixes. Duplicate +// prefixes are omitted. +func (c *ObjectsListCall) Delimiter(delimiter string) *ObjectsListCall { + c.urlParams_.Set("delimiter", delimiter) + return c +} + +// MaxResults sets the optional parameter "maxResults": Maximum number +// of items plus prefixes to return. As duplicate prefixes are omitted, +// fewer total results may be returned than requested. The default value +// of this parameter is 1,000 items. +func (c *ObjectsListCall) MaxResults(maxResults int64) *ObjectsListCall { + c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) + return c +} + +// PageToken sets the optional parameter "pageToken": A +// previously-returned page token representing part of the larger set of +// results to view. +func (c *ObjectsListCall) PageToken(pageToken string) *ObjectsListCall { + c.urlParams_.Set("pageToken", pageToken) + return c +} + +// Prefix sets the optional parameter "prefix": Filter results to +// objects whose names begin with this prefix. +func (c *ObjectsListCall) Prefix(prefix string) *ObjectsListCall { + c.urlParams_.Set("prefix", prefix) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to noAcl. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit the owner, acl property. +func (c *ObjectsListCall) Projection(projection string) *ObjectsListCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Versions sets the optional parameter "versions": If true, lists all +// versions of an object as distinct results. The default is false. For +// more information, see Object Versioning. +func (c *ObjectsListCall) Versions(versions bool) *ObjectsListCall { + c.urlParams_.Set("versions", fmt.Sprint(versions)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectsListCall) Fields(s ...googleapi.Field) *ObjectsListCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *ObjectsListCall) IfNoneMatch(entityTag string) *ObjectsListCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectsListCall) Context(ctx context.Context) *ObjectsListCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectsListCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("GET", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objects.list" call. +// Exactly one of *Objects or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Objects.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *ObjectsListCall) Do(opts ...googleapi.CallOption) (*Objects, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Objects{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Retrieves a list of objects matching the criteria.", + // "httpMethod": "GET", + // "id": "storage.objects.list", + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of the bucket in which to look for objects.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "delimiter": { + // "description": "Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted.", + // "location": "query", + // "type": "string" + // }, + // "maxResults": { + // "description": "Maximum number of items plus prefixes to return. As duplicate prefixes are omitted, fewer total results may be returned than requested. The default value of this parameter is 1,000 items.", + // "format": "uint32", + // "location": "query", + // "minimum": "0", + // "type": "integer" + // }, + // "pageToken": { + // "description": "A previously-returned page token representing part of the larger set of results to view.", + // "location": "query", + // "type": "string" + // }, + // "prefix": { + // "description": "Filter results to objects whose names begin with this prefix.", + // "location": "query", + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to noAcl.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit the owner, acl property." + // ], + // "location": "query", + // "type": "string" + // }, + // "versions": { + // "description": "If true, lists all versions of an object as distinct results. The default is false. For more information, see Object Versioning.", + // "location": "query", + // "type": "boolean" + // } + // }, + // "path": "b/{bucket}/o", + // "response": { + // "$ref": "Objects" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/cloud-platform.read-only", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_only", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ], + // "supportsSubscription": true + // } + +} + +// Pages invokes f for each page of results. +// A non-nil error returned from f will halt the iteration. +// The provided context supersedes any context provided to the Context method. +func (c *ObjectsListCall) Pages(ctx context.Context, f func(*Objects) error) error { + c.ctx_ = ctx + defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point + for { + x, err := c.Do() + if err != nil { + return err + } + if err := f(x); err != nil { + return err + } + if x.NextPageToken == "" { + return nil + } + c.PageToken(x.NextPageToken) + } +} + +// method id "storage.objects.patch": + +type ObjectsPatchCall struct { + s *Service + bucket string + object string + object2 *Object + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Patch: Updates an object's metadata. This method supports patch +// semantics. +func (r *ObjectsService) Patch(bucket string, object string, object2 *Object) *ObjectsPatchCall { + c := &ObjectsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + c.object2 = object2 + return c +} + +// Generation sets the optional parameter "generation": If present, +// selects a specific revision of this object (as opposed to the latest +// version, the default). +func (c *ObjectsPatchCall) Generation(generation int64) *ObjectsPatchCall { + c.urlParams_.Set("generation", fmt.Sprint(generation)) + return c +} + +// IfGenerationMatch sets the optional parameter "ifGenerationMatch": +// Makes the operation conditional on whether the object's current +// generation matches the given value. +func (c *ObjectsPatchCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsPatchCall { + c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch)) + return c +} + +// IfGenerationNotMatch sets the optional parameter +// "ifGenerationNotMatch": Makes the operation conditional on whether +// the object's current generation does not match the given value. +func (c *ObjectsPatchCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsPatchCall { + c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch)) + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the operation conditional on whether +// the object's current metageneration matches the given value. +func (c *ObjectsPatchCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsPatchCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": Makes the operation conditional on +// whether the object's current metageneration does not match the given +// value. +func (c *ObjectsPatchCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsPatchCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a +// predefined set of access controls to this object. +// +// Possible values: +// "authenticatedRead" - Object owner gets OWNER access, and +// allAuthenticatedUsers get READER access. +// "bucketOwnerFullControl" - Object owner gets OWNER access, and +// project team owners get OWNER access. +// "bucketOwnerRead" - Object owner gets OWNER access, and project +// team owners get READER access. +// "private" - Object owner gets OWNER access. +// "projectPrivate" - Object owner gets OWNER access, and project team +// members get access according to their roles. +// "publicRead" - Object owner gets OWNER access, and allUsers get +// READER access. +func (c *ObjectsPatchCall) PredefinedAcl(predefinedAcl string) *ObjectsPatchCall { + c.urlParams_.Set("predefinedAcl", predefinedAcl) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to full. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit the owner, acl property. +func (c *ObjectsPatchCall) Projection(projection string) *ObjectsPatchCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectsPatchCall) Fields(s ...googleapi.Field) *ObjectsPatchCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectsPatchCall) Context(ctx context.Context) *ObjectsPatchCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectsPatchCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.object2) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("PATCH", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "object": c.object, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objects.patch" call. +// Exactly one of *Object or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Object.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *ObjectsPatchCall) Do(opts ...googleapi.CallOption) (*Object, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Object{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates an object's metadata. This method supports patch semantics.", + // "httpMethod": "PATCH", + // "id": "storage.objects.patch", + // "parameterOrder": [ + // "bucket", + // "object" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of the bucket in which the object resides.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "generation": { + // "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current generation matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationNotMatch": { + // "description": "Makes the operation conditional on whether the object's current generation does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "object": { + // "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "predefinedAcl": { + // "description": "Apply a predefined set of access controls to this object.", + // "enum": [ + // "authenticatedRead", + // "bucketOwnerFullControl", + // "bucketOwnerRead", + // "private", + // "projectPrivate", + // "publicRead" + // ], + // "enumDescriptions": [ + // "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.", + // "Object owner gets OWNER access, and project team owners get OWNER access.", + // "Object owner gets OWNER access, and project team owners get READER access.", + // "Object owner gets OWNER access.", + // "Object owner gets OWNER access, and project team members get access according to their roles.", + // "Object owner gets OWNER access, and allUsers get READER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to full.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit the owner, acl property." + // ], + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o/{object}", + // "request": { + // "$ref": "Object" + // }, + // "response": { + // "$ref": "Object" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ] + // } + +} + +// method id "storage.objects.rewrite": + +type ObjectsRewriteCall struct { + s *Service + sourceBucket string + sourceObject string + destinationBucket string + destinationObject string + object *Object + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Rewrite: Rewrites a source object to a destination object. Optionally +// overrides metadata. +func (r *ObjectsService) Rewrite(sourceBucket string, sourceObject string, destinationBucket string, destinationObject string, object *Object) *ObjectsRewriteCall { + c := &ObjectsRewriteCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.sourceBucket = sourceBucket + c.sourceObject = sourceObject + c.destinationBucket = destinationBucket + c.destinationObject = destinationObject + c.object = object + return c +} + +// DestinationKmsKeyName sets the optional parameter +// "destinationKmsKeyName": Resource name of the Cloud KMS key, of the +// form +// projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, +// that will be used to encrypt the object. Overrides the object +// metadata's kms_key_name value, if any. +func (c *ObjectsRewriteCall) DestinationKmsKeyName(destinationKmsKeyName string) *ObjectsRewriteCall { + c.urlParams_.Set("destinationKmsKeyName", destinationKmsKeyName) + return c +} + +// DestinationPredefinedAcl sets the optional parameter +// "destinationPredefinedAcl": Apply a predefined set of access controls +// to the destination object. +// +// Possible values: +// "authenticatedRead" - Object owner gets OWNER access, and +// allAuthenticatedUsers get READER access. +// "bucketOwnerFullControl" - Object owner gets OWNER access, and +// project team owners get OWNER access. +// "bucketOwnerRead" - Object owner gets OWNER access, and project +// team owners get READER access. +// "private" - Object owner gets OWNER access. +// "projectPrivate" - Object owner gets OWNER access, and project team +// members get access according to their roles. +// "publicRead" - Object owner gets OWNER access, and allUsers get +// READER access. +func (c *ObjectsRewriteCall) DestinationPredefinedAcl(destinationPredefinedAcl string) *ObjectsRewriteCall { + c.urlParams_.Set("destinationPredefinedAcl", destinationPredefinedAcl) + return c +} + +// IfGenerationMatch sets the optional parameter "ifGenerationMatch": +// Makes the operation conditional on whether the destination object's +// current generation matches the given value. +func (c *ObjectsRewriteCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsRewriteCall { + c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch)) + return c +} + +// IfGenerationNotMatch sets the optional parameter +// "ifGenerationNotMatch": Makes the operation conditional on whether +// the destination object's current generation does not match the given +// value. +func (c *ObjectsRewriteCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsRewriteCall { + c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch)) + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the operation conditional on whether +// the destination object's current metageneration matches the given +// value. +func (c *ObjectsRewriteCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsRewriteCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": Makes the operation conditional on +// whether the destination object's current metageneration does not +// match the given value. +func (c *ObjectsRewriteCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsRewriteCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// IfSourceGenerationMatch sets the optional parameter +// "ifSourceGenerationMatch": Makes the operation conditional on whether +// the source object's generation matches the given value. +func (c *ObjectsRewriteCall) IfSourceGenerationMatch(ifSourceGenerationMatch int64) *ObjectsRewriteCall { + c.urlParams_.Set("ifSourceGenerationMatch", fmt.Sprint(ifSourceGenerationMatch)) + return c +} + +// IfSourceGenerationNotMatch sets the optional parameter +// "ifSourceGenerationNotMatch": Makes the operation conditional on +// whether the source object's generation does not match the given +// value. +func (c *ObjectsRewriteCall) IfSourceGenerationNotMatch(ifSourceGenerationNotMatch int64) *ObjectsRewriteCall { + c.urlParams_.Set("ifSourceGenerationNotMatch", fmt.Sprint(ifSourceGenerationNotMatch)) + return c +} + +// IfSourceMetagenerationMatch sets the optional parameter +// "ifSourceMetagenerationMatch": Makes the operation conditional on +// whether the source object's current metageneration matches the given +// value. +func (c *ObjectsRewriteCall) IfSourceMetagenerationMatch(ifSourceMetagenerationMatch int64) *ObjectsRewriteCall { + c.urlParams_.Set("ifSourceMetagenerationMatch", fmt.Sprint(ifSourceMetagenerationMatch)) + return c +} + +// IfSourceMetagenerationNotMatch sets the optional parameter +// "ifSourceMetagenerationNotMatch": Makes the operation conditional on +// whether the source object's current metageneration does not match the +// given value. +func (c *ObjectsRewriteCall) IfSourceMetagenerationNotMatch(ifSourceMetagenerationNotMatch int64) *ObjectsRewriteCall { + c.urlParams_.Set("ifSourceMetagenerationNotMatch", fmt.Sprint(ifSourceMetagenerationNotMatch)) + return c +} + +// MaxBytesRewrittenPerCall sets the optional parameter +// "maxBytesRewrittenPerCall": The maximum number of bytes that will be +// rewritten per rewrite request. Most callers shouldn't need to specify +// this parameter - it is primarily in place to support testing. If +// specified the value must be an integral multiple of 1 MiB (1048576). +// Also, this only applies to requests where the source and destination +// span locations and/or storage classes. Finally, this value must not +// change across rewrite calls else you'll get an error that the +// rewriteToken is invalid. +func (c *ObjectsRewriteCall) MaxBytesRewrittenPerCall(maxBytesRewrittenPerCall int64) *ObjectsRewriteCall { + c.urlParams_.Set("maxBytesRewrittenPerCall", fmt.Sprint(maxBytesRewrittenPerCall)) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to noAcl, unless the object resource +// specifies the acl property, when it defaults to full. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit the owner, acl property. +func (c *ObjectsRewriteCall) Projection(projection string) *ObjectsRewriteCall { + c.urlParams_.Set("projection", projection) + return c +} + +// RewriteToken sets the optional parameter "rewriteToken": Include this +// field (from the previous rewrite response) on each rewrite request +// after the first one, until the rewrite response 'done' flag is true. +// Calls that provide a rewriteToken can omit all other request fields, +// but if included those fields must match the values provided in the +// first rewrite request. +func (c *ObjectsRewriteCall) RewriteToken(rewriteToken string) *ObjectsRewriteCall { + c.urlParams_.Set("rewriteToken", rewriteToken) + return c +} + +// SourceGeneration sets the optional parameter "sourceGeneration": If +// present, selects a specific revision of the source object (as opposed +// to the latest version, the default). +func (c *ObjectsRewriteCall) SourceGeneration(sourceGeneration int64) *ObjectsRewriteCall { + c.urlParams_.Set("sourceGeneration", fmt.Sprint(sourceGeneration)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectsRewriteCall) Fields(s ...googleapi.Field) *ObjectsRewriteCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectsRewriteCall) Context(ctx context.Context) *ObjectsRewriteCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectsRewriteCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.object) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{sourceBucket}/o/{sourceObject}/rewriteTo/b/{destinationBucket}/o/{destinationObject}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("POST", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "sourceBucket": c.sourceBucket, + "sourceObject": c.sourceObject, + "destinationBucket": c.destinationBucket, + "destinationObject": c.destinationObject, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objects.rewrite" call. +// Exactly one of *RewriteResponse or error will be non-nil. Any non-2xx +// status code is an error. Response headers are in either +// *RewriteResponse.ServerResponse.Header or (if a response was returned +// at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *ObjectsRewriteCall) Do(opts ...googleapi.CallOption) (*RewriteResponse, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &RewriteResponse{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Rewrites a source object to a destination object. Optionally overrides metadata.", + // "httpMethod": "POST", + // "id": "storage.objects.rewrite", + // "parameterOrder": [ + // "sourceBucket", + // "sourceObject", + // "destinationBucket", + // "destinationObject" + // ], + // "parameters": { + // "destinationBucket": { + // "description": "Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "destinationKmsKeyName": { + // "description": "Resource name of the Cloud KMS key, of the form projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, that will be used to encrypt the object. Overrides the object metadata's kms_key_name value, if any.", + // "location": "query", + // "type": "string" + // }, + // "destinationObject": { + // "description": "Name of the new object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "destinationPredefinedAcl": { + // "description": "Apply a predefined set of access controls to the destination object.", + // "enum": [ + // "authenticatedRead", + // "bucketOwnerFullControl", + // "bucketOwnerRead", + // "private", + // "projectPrivate", + // "publicRead" + // ], + // "enumDescriptions": [ + // "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.", + // "Object owner gets OWNER access, and project team owners get OWNER access.", + // "Object owner gets OWNER access, and project team owners get READER access.", + // "Object owner gets OWNER access.", + // "Object owner gets OWNER access, and project team members get access according to their roles.", + // "Object owner gets OWNER access, and allUsers get READER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "ifGenerationMatch": { + // "description": "Makes the operation conditional on whether the destination object's current generation matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationNotMatch": { + // "description": "Makes the operation conditional on whether the destination object's current generation does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the operation conditional on whether the destination object's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "Makes the operation conditional on whether the destination object's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifSourceGenerationMatch": { + // "description": "Makes the operation conditional on whether the source object's generation matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifSourceGenerationNotMatch": { + // "description": "Makes the operation conditional on whether the source object's generation does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifSourceMetagenerationMatch": { + // "description": "Makes the operation conditional on whether the source object's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifSourceMetagenerationNotMatch": { + // "description": "Makes the operation conditional on whether the source object's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "maxBytesRewrittenPerCall": { + // "description": "The maximum number of bytes that will be rewritten per rewrite request. Most callers shouldn't need to specify this parameter - it is primarily in place to support testing. If specified the value must be an integral multiple of 1 MiB (1048576). Also, this only applies to requests where the source and destination span locations and/or storage classes. Finally, this value must not change across rewrite calls else you'll get an error that the rewriteToken is invalid.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit the owner, acl property." + // ], + // "location": "query", + // "type": "string" + // }, + // "rewriteToken": { + // "description": "Include this field (from the previous rewrite response) on each rewrite request after the first one, until the rewrite response 'done' flag is true. Calls that provide a rewriteToken can omit all other request fields, but if included those fields must match the values provided in the first rewrite request.", + // "location": "query", + // "type": "string" + // }, + // "sourceBucket": { + // "description": "Name of the bucket in which to find the source object.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "sourceGeneration": { + // "description": "If present, selects a specific revision of the source object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "sourceObject": { + // "description": "Name of the source object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // } + // }, + // "path": "b/{sourceBucket}/o/{sourceObject}/rewriteTo/b/{destinationBucket}/o/{destinationObject}", + // "request": { + // "$ref": "Object" + // }, + // "response": { + // "$ref": "RewriteResponse" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ] + // } + +} + +// method id "storage.objects.update": + +type ObjectsUpdateCall struct { + s *Service + bucket string + object string + object2 *Object + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// Update: Updates an object's metadata. +func (r *ObjectsService) Update(bucket string, object string, object2 *Object) *ObjectsUpdateCall { + c := &ObjectsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.object = object + c.object2 = object2 + return c +} + +// Generation sets the optional parameter "generation": If present, +// selects a specific revision of this object (as opposed to the latest +// version, the default). +func (c *ObjectsUpdateCall) Generation(generation int64) *ObjectsUpdateCall { + c.urlParams_.Set("generation", fmt.Sprint(generation)) + return c +} + +// IfGenerationMatch sets the optional parameter "ifGenerationMatch": +// Makes the operation conditional on whether the object's current +// generation matches the given value. +func (c *ObjectsUpdateCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsUpdateCall { + c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch)) + return c +} + +// IfGenerationNotMatch sets the optional parameter +// "ifGenerationNotMatch": Makes the operation conditional on whether +// the object's current generation does not match the given value. +func (c *ObjectsUpdateCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsUpdateCall { + c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch)) + return c +} + +// IfMetagenerationMatch sets the optional parameter +// "ifMetagenerationMatch": Makes the operation conditional on whether +// the object's current metageneration matches the given value. +func (c *ObjectsUpdateCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsUpdateCall { + c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch)) + return c +} + +// IfMetagenerationNotMatch sets the optional parameter +// "ifMetagenerationNotMatch": Makes the operation conditional on +// whether the object's current metageneration does not match the given +// value. +func (c *ObjectsUpdateCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsUpdateCall { + c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch)) + return c +} + +// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a +// predefined set of access controls to this object. +// +// Possible values: +// "authenticatedRead" - Object owner gets OWNER access, and +// allAuthenticatedUsers get READER access. +// "bucketOwnerFullControl" - Object owner gets OWNER access, and +// project team owners get OWNER access. +// "bucketOwnerRead" - Object owner gets OWNER access, and project +// team owners get READER access. +// "private" - Object owner gets OWNER access. +// "projectPrivate" - Object owner gets OWNER access, and project team +// members get access according to their roles. +// "publicRead" - Object owner gets OWNER access, and allUsers get +// READER access. +func (c *ObjectsUpdateCall) PredefinedAcl(predefinedAcl string) *ObjectsUpdateCall { + c.urlParams_.Set("predefinedAcl", predefinedAcl) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to full. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit the owner, acl property. +func (c *ObjectsUpdateCall) Projection(projection string) *ObjectsUpdateCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectsUpdateCall) Fields(s ...googleapi.Field) *ObjectsUpdateCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do and Download +// methods. Any pending HTTP request will be aborted if the provided +// context is canceled. +func (c *ObjectsUpdateCall) Context(ctx context.Context) *ObjectsUpdateCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectsUpdateCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.object2) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("PUT", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + "object": c.object, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Download fetches the API endpoint's "media" value, instead of the normal +// API response value. If the returned error is nil, the Response is guaranteed to +// have a 2xx status code. Callers must close the Response.Body as usual. +func (c *ObjectsUpdateCall) Download(opts ...googleapi.CallOption) (*http.Response, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("media") + if err != nil { + return nil, err + } + if err := googleapi.CheckMediaResponse(res); err != nil { + res.Body.Close() + return nil, err + } + return res, nil +} + +// Do executes the "storage.objects.update" call. +// Exactly one of *Object or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Object.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *ObjectsUpdateCall) Do(opts ...googleapi.CallOption) (*Object, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Object{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates an object's metadata.", + // "httpMethod": "PUT", + // "id": "storage.objects.update", + // "parameterOrder": [ + // "bucket", + // "object" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of the bucket in which the object resides.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "generation": { + // "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current generation matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifGenerationNotMatch": { + // "description": "Makes the operation conditional on whether the object's current generation does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "ifMetagenerationNotMatch": { + // "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.", + // "format": "int64", + // "location": "query", + // "type": "string" + // }, + // "object": { + // "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "predefinedAcl": { + // "description": "Apply a predefined set of access controls to this object.", + // "enum": [ + // "authenticatedRead", + // "bucketOwnerFullControl", + // "bucketOwnerRead", + // "private", + // "projectPrivate", + // "publicRead" + // ], + // "enumDescriptions": [ + // "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.", + // "Object owner gets OWNER access, and project team owners get OWNER access.", + // "Object owner gets OWNER access, and project team owners get READER access.", + // "Object owner gets OWNER access.", + // "Object owner gets OWNER access, and project team members get access according to their roles.", + // "Object owner gets OWNER access, and allUsers get READER access." + // ], + // "location": "query", + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to full.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit the owner, acl property." + // ], + // "location": "query", + // "type": "string" + // } + // }, + // "path": "b/{bucket}/o/{object}", + // "request": { + // "$ref": "Object" + // }, + // "response": { + // "$ref": "Object" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/devstorage.full_control" + // ], + // "supportsMediaDownload": true, + // "useMediaDownloadService": true + // } + +} + +// method id "storage.objects.watchAll": + +type ObjectsWatchAllCall struct { + s *Service + bucket string + channel *Channel + urlParams_ gensupport.URLParams + ctx_ context.Context +} + +// WatchAll: Watch for changes on all objects in a bucket. +func (r *ObjectsService) WatchAll(bucket string, channel *Channel) *ObjectsWatchAllCall { + c := &ObjectsWatchAllCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.bucket = bucket + c.channel = channel + return c +} + +// Delimiter sets the optional parameter "delimiter": Returns results in +// a directory-like mode. items will contain only objects whose names, +// aside from the prefix, do not contain delimiter. Objects whose names, +// aside from the prefix, contain delimiter will have their name, +// truncated after the delimiter, returned in prefixes. Duplicate +// prefixes are omitted. +func (c *ObjectsWatchAllCall) Delimiter(delimiter string) *ObjectsWatchAllCall { + c.urlParams_.Set("delimiter", delimiter) + return c +} + +// MaxResults sets the optional parameter "maxResults": Maximum number +// of items plus prefixes to return. As duplicate prefixes are omitted, +// fewer total results may be returned than requested. The default value +// of this parameter is 1,000 items. +func (c *ObjectsWatchAllCall) MaxResults(maxResults int64) *ObjectsWatchAllCall { + c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) + return c +} + +// PageToken sets the optional parameter "pageToken": A +// previously-returned page token representing part of the larger set of +// results to view. +func (c *ObjectsWatchAllCall) PageToken(pageToken string) *ObjectsWatchAllCall { + c.urlParams_.Set("pageToken", pageToken) + return c +} + +// Prefix sets the optional parameter "prefix": Filter results to +// objects whose names begin with this prefix. +func (c *ObjectsWatchAllCall) Prefix(prefix string) *ObjectsWatchAllCall { + c.urlParams_.Set("prefix", prefix) + return c +} + +// Projection sets the optional parameter "projection": Set of +// properties to return. Defaults to noAcl. +// +// Possible values: +// "full" - Include all properties. +// "noAcl" - Omit the owner, acl property. +func (c *ObjectsWatchAllCall) Projection(projection string) *ObjectsWatchAllCall { + c.urlParams_.Set("projection", projection) + return c +} + +// Versions sets the optional parameter "versions": If true, lists all +// versions of an object as distinct results. The default is false. For +// more information, see Object Versioning. +func (c *ObjectsWatchAllCall) Versions(versions bool) *ObjectsWatchAllCall { + c.urlParams_.Set("versions", fmt.Sprint(versions)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *ObjectsWatchAllCall) Fields(s ...googleapi.Field) *ObjectsWatchAllCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *ObjectsWatchAllCall) Context(ctx context.Context) *ObjectsWatchAllCall { + c.ctx_ = ctx + return c +} + +func (c *ObjectsWatchAllCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.channel) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/watch") + urls += "?" + c.urlParams_.Encode() + req, _ := http.NewRequest("POST", urls, body) + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "bucket": c.bucket, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "storage.objects.watchAll" call. +// Exactly one of *Channel or error will be non-nil. Any non-2xx status +// code is an error. Response headers are in either +// *Channel.ServerResponse.Header or (if a response was returned at all) +// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to +// check whether the returned error was because http.StatusNotModified +// was returned. +func (c *ObjectsWatchAllCall) Do(opts ...googleapi.CallOption) (*Channel, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + } + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, err + } + ret := &Channel{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := json.NewDecoder(res.Body).Decode(target); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Watch for changes on all objects in a bucket.", + // "httpMethod": "POST", + // "id": "storage.objects.watchAll", + // "parameterOrder": [ + // "bucket" + // ], + // "parameters": { + // "bucket": { + // "description": "Name of the bucket in which to look for objects.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "delimiter": { + // "description": "Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted.", + // "location": "query", + // "type": "string" + // }, + // "maxResults": { + // "description": "Maximum number of items plus prefixes to return. As duplicate prefixes are omitted, fewer total results may be returned than requested. The default value of this parameter is 1,000 items.", + // "format": "uint32", + // "location": "query", + // "minimum": "0", + // "type": "integer" + // }, + // "pageToken": { + // "description": "A previously-returned page token representing part of the larger set of results to view.", + // "location": "query", + // "type": "string" + // }, + // "prefix": { + // "description": "Filter results to objects whose names begin with this prefix.", + // "location": "query", + // "type": "string" + // }, + // "projection": { + // "description": "Set of properties to return. Defaults to noAcl.", + // "enum": [ + // "full", + // "noAcl" + // ], + // "enumDescriptions": [ + // "Include all properties.", + // "Omit the owner, acl property." + // ], + // "location": "query", + // "type": "string" + // }, + // "versions": { + // "description": "If true, lists all versions of an object as distinct results. The default is false. For more information, see Object Versioning.", + // "location": "query", + // "type": "boolean" + // } + // }, + // "path": "b/{bucket}/o/watch", + // "request": { + // "$ref": "Channel", + // "parameterName": "resource" + // }, + // "response": { + // "$ref": "Channel" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/cloud-platform.read-only", + // "https://www.googleapis.com/auth/devstorage.full_control", + // "https://www.googleapis.com/auth/devstorage.read_only", + // "https://www.googleapis.com/auth/devstorage.read_write" + // ], + // "supportsSubscription": true + // } + +} diff --git a/vendor/google.golang.org/api/transport/dial.go b/vendor/google.golang.org/api/transport/dial.go new file mode 100644 index 00000000..9b8a9045 --- /dev/null +++ b/vendor/google.golang.org/api/transport/dial.go @@ -0,0 +1,97 @@ +// Copyright 2015 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package transport supports network connections to HTTP and GRPC servers. +// This package is not intended for use by end developers. Use the +// google.golang.org/api/option package to configure API clients. +package transport + +import ( + "errors" + "fmt" + "net/http" + + "golang.org/x/net/context" + "golang.org/x/oauth2" + "golang.org/x/oauth2/google" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials" + "google.golang.org/grpc/credentials/oauth" + + "google.golang.org/api/internal" + "google.golang.org/api/option" +) + +// NewHTTPClient returns an HTTP client for use communicating with a Google cloud +// service, configured with the given ClientOptions. It also returns the endpoint +// for the service as specified in the options. +func NewHTTPClient(ctx context.Context, opts ...option.ClientOption) (*http.Client, string, error) { + var o internal.DialSettings + for _, opt := range opts { + opt.Apply(&o) + } + if o.GRPCConn != nil { + return nil, "", errors.New("unsupported gRPC connection specified") + } + // TODO(djd): Set UserAgent on all outgoing requests. + if o.HTTPClient != nil { + return o.HTTPClient, o.Endpoint, nil + } + if o.TokenSource == nil { + var err error + o.TokenSource, err = google.DefaultTokenSource(ctx, o.Scopes...) + if err != nil { + return nil, "", fmt.Errorf("google.DefaultTokenSource: %v", err) + } + } + return oauth2.NewClient(ctx, o.TokenSource), o.Endpoint, nil +} + +// Set at init time by dial_appengine.go. If nil, we're not on App Engine. +var appengineDialerHook func(context.Context) grpc.DialOption + +// DialGRPC returns a GRPC connection for use communicating with a Google cloud +// service, configured with the given ClientOptions. +func DialGRPC(ctx context.Context, opts ...option.ClientOption) (*grpc.ClientConn, error) { + var o internal.DialSettings + for _, opt := range opts { + opt.Apply(&o) + } + if o.HTTPClient != nil { + return nil, errors.New("unsupported HTTP client specified") + } + if o.GRPCConn != nil { + return o.GRPCConn, nil + } + if o.TokenSource == nil { + var err error + o.TokenSource, err = google.DefaultTokenSource(ctx, o.Scopes...) + if err != nil { + return nil, fmt.Errorf("google.DefaultTokenSource: %v", err) + } + } + grpcOpts := []grpc.DialOption{ + grpc.WithPerRPCCredentials(oauth.TokenSource{o.TokenSource}), + grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, "")), + } + if appengineDialerHook != nil { + // Use the Socket API on App Engine. + grpcOpts = append(grpcOpts, appengineDialerHook(ctx)) + } + grpcOpts = append(grpcOpts, o.GRPCDialOpts...) + if o.UserAgent != "" { + grpcOpts = append(grpcOpts, grpc.WithUserAgent(o.UserAgent)) + } + return grpc.Dial(o.Endpoint, grpcOpts...) +} diff --git a/vendor/google.golang.org/api/transport/dial_appengine.go b/vendor/google.golang.org/api/transport/dial_appengine.go new file mode 100644 index 00000000..201244d2 --- /dev/null +++ b/vendor/google.golang.org/api/transport/dial_appengine.go @@ -0,0 +1,34 @@ +// Copyright 2016 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build appengine + +package transport + +import ( + "net" + "time" + + "golang.org/x/net/context" + "google.golang.org/appengine/socket" + "google.golang.org/grpc" +) + +func init() { + appengineDialerHook = func(ctx context.Context) grpc.DialOption { + return grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) { + return socket.DialTimeout(ctx, "tcp", addr, timeout) + }) + } +} diff --git a/vendor/google.golang.org/appengine/LICENSE b/vendor/google.golang.org/appengine/LICENSE new file mode 100644 index 00000000..d6456956 --- /dev/null +++ b/vendor/google.golang.org/appengine/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/google.golang.org/appengine/appengine.go b/vendor/google.golang.org/appengine/appengine.go new file mode 100644 index 00000000..475cf2e3 --- /dev/null +++ b/vendor/google.golang.org/appengine/appengine.go @@ -0,0 +1,112 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// Package appengine provides basic functionality for Google App Engine. +// +// For more information on how to write Go apps for Google App Engine, see: +// https://cloud.google.com/appengine/docs/go/ +package appengine // import "google.golang.org/appengine" + +import ( + "net/http" + + "github.com/golang/protobuf/proto" + "golang.org/x/net/context" + + "google.golang.org/appengine/internal" +) + +// The gophers party all night; the rabbits provide the beats. + +// Main is the principal entry point for an app running in App Engine. +// +// On App Engine Flexible it installs a trivial health checker if one isn't +// already registered, and starts listening on port 8080 (overridden by the +// $PORT environment variable). +// +// See https://cloud.google.com/appengine/docs/flexible/custom-runtimes#health_check_requests +// for details on how to do your own health checking. +// +// Main is not yet supported on App Engine Standard. +// +// Main never returns. +// +// Main is designed so that the app's main package looks like this: +// +// package main +// +// import ( +// "google.golang.org/appengine" +// +// _ "myapp/package0" +// _ "myapp/package1" +// ) +// +// func main() { +// appengine.Main() +// } +// +// The "myapp/packageX" packages are expected to register HTTP handlers +// in their init functions. +func Main() { + internal.Main() +} + +// IsDevAppServer reports whether the App Engine app is running in the +// development App Server. +func IsDevAppServer() bool { + return internal.IsDevAppServer() +} + +// NewContext returns a context for an in-flight HTTP request. +// This function is cheap. +func NewContext(req *http.Request) context.Context { + return WithContext(context.Background(), req) +} + +// WithContext returns a copy of the parent context +// and associates it with an in-flight HTTP request. +// This function is cheap. +func WithContext(parent context.Context, req *http.Request) context.Context { + return internal.WithContext(parent, req) +} + +// TODO(dsymonds): Add a Call function here? Otherwise other packages can't access internal.Call. + +// BlobKey is a key for a blobstore blob. +// +// Conceptually, this type belongs in the blobstore package, but it lives in +// the appengine package to avoid a circular dependency: blobstore depends on +// datastore, and datastore needs to refer to the BlobKey type. +type BlobKey string + +// GeoPoint represents a location as latitude/longitude in degrees. +type GeoPoint struct { + Lat, Lng float64 +} + +// Valid returns whether a GeoPoint is within [-90, 90] latitude and [-180, 180] longitude. +func (g GeoPoint) Valid() bool { + return -90 <= g.Lat && g.Lat <= 90 && -180 <= g.Lng && g.Lng <= 180 +} + +// APICallFunc defines a function type for handling an API call. +// See WithCallOverride. +type APICallFunc func(ctx context.Context, service, method string, in, out proto.Message) error + +// WithAPICallFunc returns a copy of the parent context +// that will cause API calls to invoke f instead of their normal operation. +// +// This is intended for advanced users only. +func WithAPICallFunc(ctx context.Context, f APICallFunc) context.Context { + return internal.WithCallOverride(ctx, internal.CallOverrideFunc(f)) +} + +// APICall performs an API call. +// +// This is not intended for general use; it is exported for use in conjunction +// with WithAPICallFunc. +func APICall(ctx context.Context, service, method string, in, out proto.Message) error { + return internal.Call(ctx, service, method, in, out) +} diff --git a/vendor/google.golang.org/appengine/appengine_vm.go b/vendor/google.golang.org/appengine/appengine_vm.go new file mode 100644 index 00000000..f4b645aa --- /dev/null +++ b/vendor/google.golang.org/appengine/appengine_vm.go @@ -0,0 +1,20 @@ +// Copyright 2015 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// +build !appengine + +package appengine + +import ( + "golang.org/x/net/context" + + "google.golang.org/appengine/internal" +) + +// BackgroundContext returns a context not associated with a request. +// This should only be used when not servicing a request. +// This only works in App Engine "flexible environment". +func BackgroundContext() context.Context { + return internal.BackgroundContext() +} diff --git a/vendor/google.golang.org/appengine/errors.go b/vendor/google.golang.org/appengine/errors.go new file mode 100644 index 00000000..16d0772e --- /dev/null +++ b/vendor/google.golang.org/appengine/errors.go @@ -0,0 +1,46 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// This file provides error functions for common API failure modes. + +package appengine + +import ( + "fmt" + + "google.golang.org/appengine/internal" +) + +// IsOverQuota reports whether err represents an API call failure +// due to insufficient available quota. +func IsOverQuota(err error) bool { + callErr, ok := err.(*internal.CallError) + return ok && callErr.Code == 4 +} + +// MultiError is returned by batch operations when there are errors with +// particular elements. Errors will be in a one-to-one correspondence with +// the input elements; successful elements will have a nil entry. +type MultiError []error + +func (m MultiError) Error() string { + s, n := "", 0 + for _, e := range m { + if e != nil { + if n == 0 { + s = e.Error() + } + n++ + } + } + switch n { + case 0: + return "(0 errors)" + case 1: + return s + case 2: + return s + " (and 1 other error)" + } + return fmt.Sprintf("%s (and %d other errors)", s, n-1) +} diff --git a/vendor/google.golang.org/appengine/identity.go b/vendor/google.golang.org/appengine/identity.go new file mode 100644 index 00000000..b8dcf8f3 --- /dev/null +++ b/vendor/google.golang.org/appengine/identity.go @@ -0,0 +1,142 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +package appengine + +import ( + "time" + + "golang.org/x/net/context" + + "google.golang.org/appengine/internal" + pb "google.golang.org/appengine/internal/app_identity" + modpb "google.golang.org/appengine/internal/modules" +) + +// AppID returns the application ID for the current application. +// The string will be a plain application ID (e.g. "appid"), with a +// domain prefix for custom domain deployments (e.g. "example.com:appid"). +func AppID(c context.Context) string { return internal.AppID(c) } + +// DefaultVersionHostname returns the standard hostname of the default version +// of the current application (e.g. "my-app.appspot.com"). This is suitable for +// use in constructing URLs. +func DefaultVersionHostname(c context.Context) string { + return internal.DefaultVersionHostname(c) +} + +// ModuleName returns the module name of the current instance. +func ModuleName(c context.Context) string { + return internal.ModuleName(c) +} + +// ModuleHostname returns a hostname of a module instance. +// If module is the empty string, it refers to the module of the current instance. +// If version is empty, it refers to the version of the current instance if valid, +// or the default version of the module of the current instance. +// If instance is empty, ModuleHostname returns the load-balancing hostname. +func ModuleHostname(c context.Context, module, version, instance string) (string, error) { + req := &modpb.GetHostnameRequest{} + if module != "" { + req.Module = &module + } + if version != "" { + req.Version = &version + } + if instance != "" { + req.Instance = &instance + } + res := &modpb.GetHostnameResponse{} + if err := internal.Call(c, "modules", "GetHostname", req, res); err != nil { + return "", err + } + return *res.Hostname, nil +} + +// VersionID returns the version ID for the current application. +// It will be of the form "X.Y", where X is specified in app.yaml, +// and Y is a number generated when each version of the app is uploaded. +// It does not include a module name. +func VersionID(c context.Context) string { return internal.VersionID(c) } + +// InstanceID returns a mostly-unique identifier for this instance. +func InstanceID() string { return internal.InstanceID() } + +// Datacenter returns an identifier for the datacenter that the instance is running in. +func Datacenter(c context.Context) string { return internal.Datacenter(c) } + +// ServerSoftware returns the App Engine release version. +// In production, it looks like "Google App Engine/X.Y.Z". +// In the development appserver, it looks like "Development/X.Y". +func ServerSoftware() string { return internal.ServerSoftware() } + +// RequestID returns a string that uniquely identifies the request. +func RequestID(c context.Context) string { return internal.RequestID(c) } + +// AccessToken generates an OAuth2 access token for the specified scopes on +// behalf of service account of this application. This token will expire after +// the returned time. +func AccessToken(c context.Context, scopes ...string) (token string, expiry time.Time, err error) { + req := &pb.GetAccessTokenRequest{Scope: scopes} + res := &pb.GetAccessTokenResponse{} + + err = internal.Call(c, "app_identity_service", "GetAccessToken", req, res) + if err != nil { + return "", time.Time{}, err + } + return res.GetAccessToken(), time.Unix(res.GetExpirationTime(), 0), nil +} + +// Certificate represents a public certificate for the app. +type Certificate struct { + KeyName string + Data []byte // PEM-encoded X.509 certificate +} + +// PublicCertificates retrieves the public certificates for the app. +// They can be used to verify a signature returned by SignBytes. +func PublicCertificates(c context.Context) ([]Certificate, error) { + req := &pb.GetPublicCertificateForAppRequest{} + res := &pb.GetPublicCertificateForAppResponse{} + if err := internal.Call(c, "app_identity_service", "GetPublicCertificatesForApp", req, res); err != nil { + return nil, err + } + var cs []Certificate + for _, pc := range res.PublicCertificateList { + cs = append(cs, Certificate{ + KeyName: pc.GetKeyName(), + Data: []byte(pc.GetX509CertificatePem()), + }) + } + return cs, nil +} + +// ServiceAccount returns a string representing the service account name, in +// the form of an email address (typically app_id@appspot.gserviceaccount.com). +func ServiceAccount(c context.Context) (string, error) { + req := &pb.GetServiceAccountNameRequest{} + res := &pb.GetServiceAccountNameResponse{} + + err := internal.Call(c, "app_identity_service", "GetServiceAccountName", req, res) + if err != nil { + return "", err + } + return res.GetServiceAccountName(), err +} + +// SignBytes signs bytes using a private key unique to your application. +func SignBytes(c context.Context, bytes []byte) (keyName string, signature []byte, err error) { + req := &pb.SignForAppRequest{BytesToSign: bytes} + res := &pb.SignForAppResponse{} + + if err := internal.Call(c, "app_identity_service", "SignForApp", req, res); err != nil { + return "", nil, err + } + return res.GetKeyName(), res.GetSignatureBytes(), nil +} + +func init() { + internal.RegisterErrorCodeMap("app_identity_service", pb.AppIdentityServiceError_ErrorCode_name) + internal.RegisterErrorCodeMap("modules", modpb.ModulesServiceError_ErrorCode_name) +} diff --git a/vendor/google.golang.org/appengine/internal/api.go b/vendor/google.golang.org/appengine/internal/api.go new file mode 100644 index 00000000..ec5aa59b --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/api.go @@ -0,0 +1,646 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// +build !appengine + +package internal + +import ( + "bytes" + "errors" + "fmt" + "io/ioutil" + "log" + "net" + "net/http" + "net/url" + "os" + "runtime" + "strconv" + "strings" + "sync" + "sync/atomic" + "time" + + "github.com/golang/protobuf/proto" + netcontext "golang.org/x/net/context" + + basepb "google.golang.org/appengine/internal/base" + logpb "google.golang.org/appengine/internal/log" + remotepb "google.golang.org/appengine/internal/remote_api" +) + +const ( + apiPath = "/rpc_http" +) + +var ( + // Incoming headers. + ticketHeader = http.CanonicalHeaderKey("X-AppEngine-API-Ticket") + dapperHeader = http.CanonicalHeaderKey("X-Google-DapperTraceInfo") + traceHeader = http.CanonicalHeaderKey("X-Cloud-Trace-Context") + curNamespaceHeader = http.CanonicalHeaderKey("X-AppEngine-Current-Namespace") + userIPHeader = http.CanonicalHeaderKey("X-AppEngine-User-IP") + remoteAddrHeader = http.CanonicalHeaderKey("X-AppEngine-Remote-Addr") + + // Outgoing headers. + apiEndpointHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Endpoint") + apiEndpointHeaderValue = []string{"app-engine-apis"} + apiMethodHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Method") + apiMethodHeaderValue = []string{"/VMRemoteAPI.CallRemoteAPI"} + apiDeadlineHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Deadline") + apiContentType = http.CanonicalHeaderKey("Content-Type") + apiContentTypeValue = []string{"application/octet-stream"} + logFlushHeader = http.CanonicalHeaderKey("X-AppEngine-Log-Flush-Count") + + apiHTTPClient = &http.Client{ + Transport: &http.Transport{ + Proxy: http.ProxyFromEnvironment, + Dial: limitDial, + }, + } +) + +func apiURL() *url.URL { + host, port := "appengine.googleapis.internal", "10001" + if h := os.Getenv("API_HOST"); h != "" { + host = h + } + if p := os.Getenv("API_PORT"); p != "" { + port = p + } + return &url.URL{ + Scheme: "http", + Host: host + ":" + port, + Path: apiPath, + } +} + +func handleHTTP(w http.ResponseWriter, r *http.Request) { + c := &context{ + req: r, + outHeader: w.Header(), + apiURL: apiURL(), + } + stopFlushing := make(chan int) + + ctxs.Lock() + ctxs.m[r] = c + ctxs.Unlock() + defer func() { + ctxs.Lock() + delete(ctxs.m, r) + ctxs.Unlock() + }() + + // Patch up RemoteAddr so it looks reasonable. + if addr := r.Header.Get(userIPHeader); addr != "" { + r.RemoteAddr = addr + } else if addr = r.Header.Get(remoteAddrHeader); addr != "" { + r.RemoteAddr = addr + } else { + // Should not normally reach here, but pick a sensible default anyway. + r.RemoteAddr = "127.0.0.1" + } + // The address in the headers will most likely be of these forms: + // 123.123.123.123 + // 2001:db8::1 + // net/http.Request.RemoteAddr is specified to be in "IP:port" form. + if _, _, err := net.SplitHostPort(r.RemoteAddr); err != nil { + // Assume the remote address is only a host; add a default port. + r.RemoteAddr = net.JoinHostPort(r.RemoteAddr, "80") + } + + // Start goroutine responsible for flushing app logs. + // This is done after adding c to ctx.m (and stopped before removing it) + // because flushing logs requires making an API call. + go c.logFlusher(stopFlushing) + + executeRequestSafely(c, r) + c.outHeader = nil // make sure header changes aren't respected any more + + stopFlushing <- 1 // any logging beyond this point will be dropped + + // Flush any pending logs asynchronously. + c.pendingLogs.Lock() + flushes := c.pendingLogs.flushes + if len(c.pendingLogs.lines) > 0 { + flushes++ + } + c.pendingLogs.Unlock() + go c.flushLog(false) + w.Header().Set(logFlushHeader, strconv.Itoa(flushes)) + + // Avoid nil Write call if c.Write is never called. + if c.outCode != 0 { + w.WriteHeader(c.outCode) + } + if c.outBody != nil { + w.Write(c.outBody) + } +} + +func executeRequestSafely(c *context, r *http.Request) { + defer func() { + if x := recover(); x != nil { + logf(c, 4, "%s", renderPanic(x)) // 4 == critical + c.outCode = 500 + } + }() + + http.DefaultServeMux.ServeHTTP(c, r) +} + +func renderPanic(x interface{}) string { + buf := make([]byte, 16<<10) // 16 KB should be plenty + buf = buf[:runtime.Stack(buf, false)] + + // Remove the first few stack frames: + // this func + // the recover closure in the caller + // That will root the stack trace at the site of the panic. + const ( + skipStart = "internal.renderPanic" + skipFrames = 2 + ) + start := bytes.Index(buf, []byte(skipStart)) + p := start + for i := 0; i < skipFrames*2 && p+1 < len(buf); i++ { + p = bytes.IndexByte(buf[p+1:], '\n') + p + 1 + if p < 0 { + break + } + } + if p >= 0 { + // buf[start:p+1] is the block to remove. + // Copy buf[p+1:] over buf[start:] and shrink buf. + copy(buf[start:], buf[p+1:]) + buf = buf[:len(buf)-(p+1-start)] + } + + // Add panic heading. + head := fmt.Sprintf("panic: %v\n\n", x) + if len(head) > len(buf) { + // Extremely unlikely to happen. + return head + } + copy(buf[len(head):], buf) + copy(buf, head) + + return string(buf) +} + +var ctxs = struct { + sync.Mutex + m map[*http.Request]*context + bg *context // background context, lazily initialized + // dec is used by tests to decorate the netcontext.Context returned + // for a given request. This allows tests to add overrides (such as + // WithAppIDOverride) to the context. The map is nil outside tests. + dec map[*http.Request]func(netcontext.Context) netcontext.Context +}{ + m: make(map[*http.Request]*context), +} + +// context represents the context of an in-flight HTTP request. +// It implements the appengine.Context and http.ResponseWriter interfaces. +type context struct { + req *http.Request + + outCode int + outHeader http.Header + outBody []byte + + pendingLogs struct { + sync.Mutex + lines []*logpb.UserAppLogLine + flushes int + } + + apiURL *url.URL +} + +var contextKey = "holds a *context" + +func fromContext(ctx netcontext.Context) *context { + c, _ := ctx.Value(&contextKey).(*context) + return c +} + +func withContext(parent netcontext.Context, c *context) netcontext.Context { + ctx := netcontext.WithValue(parent, &contextKey, c) + if ns := c.req.Header.Get(curNamespaceHeader); ns != "" { + ctx = withNamespace(ctx, ns) + } + return ctx +} + +func toContext(c *context) netcontext.Context { + return withContext(netcontext.Background(), c) +} + +func IncomingHeaders(ctx netcontext.Context) http.Header { + if c := fromContext(ctx); c != nil { + return c.req.Header + } + return nil +} + +func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context { + ctxs.Lock() + c := ctxs.m[req] + d := ctxs.dec[req] + ctxs.Unlock() + + if d != nil { + parent = d(parent) + } + + if c == nil { + // Someone passed in an http.Request that is not in-flight. + // We panic here rather than panicking at a later point + // so that stack traces will be more sensible. + log.Panic("appengine: NewContext passed an unknown http.Request") + } + return withContext(parent, c) +} + +func BackgroundContext() netcontext.Context { + ctxs.Lock() + defer ctxs.Unlock() + + if ctxs.bg != nil { + return toContext(ctxs.bg) + } + + // Compute background security ticket. + appID := partitionlessAppID() + escAppID := strings.Replace(strings.Replace(appID, ":", "_", -1), ".", "_", -1) + majVersion := VersionID(nil) + if i := strings.Index(majVersion, "."); i > 0 { + majVersion = majVersion[:i] + } + ticket := fmt.Sprintf("%s/%s.%s.%s", escAppID, ModuleName(nil), majVersion, InstanceID()) + + ctxs.bg = &context{ + req: &http.Request{ + Header: http.Header{ + ticketHeader: []string{ticket}, + }, + }, + apiURL: apiURL(), + } + + // TODO(dsymonds): Wire up the shutdown handler to do a final flush. + go ctxs.bg.logFlusher(make(chan int)) + + return toContext(ctxs.bg) +} + +// RegisterTestRequest registers the HTTP request req for testing, such that +// any API calls are sent to the provided URL. It returns a closure to delete +// the registration. +// It should only be used by aetest package. +func RegisterTestRequest(req *http.Request, apiURL *url.URL, decorate func(netcontext.Context) netcontext.Context) func() { + c := &context{ + req: req, + apiURL: apiURL, + } + ctxs.Lock() + defer ctxs.Unlock() + if _, ok := ctxs.m[req]; ok { + log.Panic("req already associated with context") + } + if _, ok := ctxs.dec[req]; ok { + log.Panic("req already associated with context") + } + if ctxs.dec == nil { + ctxs.dec = make(map[*http.Request]func(netcontext.Context) netcontext.Context) + } + ctxs.m[req] = c + ctxs.dec[req] = decorate + + return func() { + ctxs.Lock() + delete(ctxs.m, req) + delete(ctxs.dec, req) + ctxs.Unlock() + } +} + +var errTimeout = &CallError{ + Detail: "Deadline exceeded", + Code: int32(remotepb.RpcError_CANCELLED), + Timeout: true, +} + +func (c *context) Header() http.Header { return c.outHeader } + +// Copied from $GOROOT/src/pkg/net/http/transfer.go. Some response status +// codes do not permit a response body (nor response entity headers such as +// Content-Length, Content-Type, etc). +func bodyAllowedForStatus(status int) bool { + switch { + case status >= 100 && status <= 199: + return false + case status == 204: + return false + case status == 304: + return false + } + return true +} + +func (c *context) Write(b []byte) (int, error) { + if c.outCode == 0 { + c.WriteHeader(http.StatusOK) + } + if len(b) > 0 && !bodyAllowedForStatus(c.outCode) { + return 0, http.ErrBodyNotAllowed + } + c.outBody = append(c.outBody, b...) + return len(b), nil +} + +func (c *context) WriteHeader(code int) { + if c.outCode != 0 { + logf(c, 3, "WriteHeader called multiple times on request.") // error level + return + } + c.outCode = code +} + +func (c *context) post(body []byte, timeout time.Duration) (b []byte, err error) { + hreq := &http.Request{ + Method: "POST", + URL: c.apiURL, + Header: http.Header{ + apiEndpointHeader: apiEndpointHeaderValue, + apiMethodHeader: apiMethodHeaderValue, + apiContentType: apiContentTypeValue, + apiDeadlineHeader: []string{strconv.FormatFloat(timeout.Seconds(), 'f', -1, 64)}, + }, + Body: ioutil.NopCloser(bytes.NewReader(body)), + ContentLength: int64(len(body)), + Host: c.apiURL.Host, + } + if info := c.req.Header.Get(dapperHeader); info != "" { + hreq.Header.Set(dapperHeader, info) + } + if info := c.req.Header.Get(traceHeader); info != "" { + hreq.Header.Set(traceHeader, info) + } + + tr := apiHTTPClient.Transport.(*http.Transport) + + var timedOut int32 // atomic; set to 1 if timed out + t := time.AfterFunc(timeout, func() { + atomic.StoreInt32(&timedOut, 1) + tr.CancelRequest(hreq) + }) + defer t.Stop() + defer func() { + // Check if timeout was exceeded. + if atomic.LoadInt32(&timedOut) != 0 { + err = errTimeout + } + }() + + hresp, err := apiHTTPClient.Do(hreq) + if err != nil { + return nil, &CallError{ + Detail: fmt.Sprintf("service bridge HTTP failed: %v", err), + Code: int32(remotepb.RpcError_UNKNOWN), + } + } + defer hresp.Body.Close() + hrespBody, err := ioutil.ReadAll(hresp.Body) + if hresp.StatusCode != 200 { + return nil, &CallError{ + Detail: fmt.Sprintf("service bridge returned HTTP %d (%q)", hresp.StatusCode, hrespBody), + Code: int32(remotepb.RpcError_UNKNOWN), + } + } + if err != nil { + return nil, &CallError{ + Detail: fmt.Sprintf("service bridge response bad: %v", err), + Code: int32(remotepb.RpcError_UNKNOWN), + } + } + return hrespBody, nil +} + +func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error { + if ns := NamespaceFromContext(ctx); ns != "" { + if fn, ok := NamespaceMods[service]; ok { + fn(in, ns) + } + } + + if f, ctx, ok := callOverrideFromContext(ctx); ok { + return f(ctx, service, method, in, out) + } + + // Handle already-done contexts quickly. + select { + case <-ctx.Done(): + return ctx.Err() + default: + } + + c := fromContext(ctx) + if c == nil { + // Give a good error message rather than a panic lower down. + return errors.New("not an App Engine context") + } + + // Apply transaction modifications if we're in a transaction. + if t := transactionFromContext(ctx); t != nil { + if t.finished { + return errors.New("transaction context has expired") + } + applyTransaction(in, &t.transaction) + } + + // Default RPC timeout is 60s. + timeout := 60 * time.Second + if deadline, ok := ctx.Deadline(); ok { + timeout = deadline.Sub(time.Now()) + } + + data, err := proto.Marshal(in) + if err != nil { + return err + } + + ticket := c.req.Header.Get(ticketHeader) + req := &remotepb.Request{ + ServiceName: &service, + Method: &method, + Request: data, + RequestId: &ticket, + } + hreqBody, err := proto.Marshal(req) + if err != nil { + return err + } + + hrespBody, err := c.post(hreqBody, timeout) + if err != nil { + return err + } + + res := &remotepb.Response{} + if err := proto.Unmarshal(hrespBody, res); err != nil { + return err + } + if res.RpcError != nil { + ce := &CallError{ + Detail: res.RpcError.GetDetail(), + Code: *res.RpcError.Code, + } + switch remotepb.RpcError_ErrorCode(ce.Code) { + case remotepb.RpcError_CANCELLED, remotepb.RpcError_DEADLINE_EXCEEDED: + ce.Timeout = true + } + return ce + } + if res.ApplicationError != nil { + return &APIError{ + Service: *req.ServiceName, + Detail: res.ApplicationError.GetDetail(), + Code: *res.ApplicationError.Code, + } + } + if res.Exception != nil || res.JavaException != nil { + // This shouldn't happen, but let's be defensive. + return &CallError{ + Detail: "service bridge returned exception", + Code: int32(remotepb.RpcError_UNKNOWN), + } + } + return proto.Unmarshal(res.Response, out) +} + +func (c *context) Request() *http.Request { + return c.req +} + +func (c *context) addLogLine(ll *logpb.UserAppLogLine) { + // Truncate long log lines. + // TODO(dsymonds): Check if this is still necessary. + const lim = 8 << 10 + if len(*ll.Message) > lim { + suffix := fmt.Sprintf("...(length %d)", len(*ll.Message)) + ll.Message = proto.String((*ll.Message)[:lim-len(suffix)] + suffix) + } + + c.pendingLogs.Lock() + c.pendingLogs.lines = append(c.pendingLogs.lines, ll) + c.pendingLogs.Unlock() +} + +var logLevelName = map[int64]string{ + 0: "DEBUG", + 1: "INFO", + 2: "WARNING", + 3: "ERROR", + 4: "CRITICAL", +} + +func logf(c *context, level int64, format string, args ...interface{}) { + s := fmt.Sprintf(format, args...) + s = strings.TrimRight(s, "\n") // Remove any trailing newline characters. + c.addLogLine(&logpb.UserAppLogLine{ + TimestampUsec: proto.Int64(time.Now().UnixNano() / 1e3), + Level: &level, + Message: &s, + }) + log.Print(logLevelName[level] + ": " + s) +} + +// flushLog attempts to flush any pending logs to the appserver. +// It should not be called concurrently. +func (c *context) flushLog(force bool) (flushed bool) { + c.pendingLogs.Lock() + // Grab up to 30 MB. We can get away with up to 32 MB, but let's be cautious. + n, rem := 0, 30<<20 + for ; n < len(c.pendingLogs.lines); n++ { + ll := c.pendingLogs.lines[n] + // Each log line will require about 3 bytes of overhead. + nb := proto.Size(ll) + 3 + if nb > rem { + break + } + rem -= nb + } + lines := c.pendingLogs.lines[:n] + c.pendingLogs.lines = c.pendingLogs.lines[n:] + c.pendingLogs.Unlock() + + if len(lines) == 0 && !force { + // Nothing to flush. + return false + } + + rescueLogs := false + defer func() { + if rescueLogs { + c.pendingLogs.Lock() + c.pendingLogs.lines = append(lines, c.pendingLogs.lines...) + c.pendingLogs.Unlock() + } + }() + + buf, err := proto.Marshal(&logpb.UserAppLogGroup{ + LogLine: lines, + }) + if err != nil { + log.Printf("internal.flushLog: marshaling UserAppLogGroup: %v", err) + rescueLogs = true + return false + } + + req := &logpb.FlushRequest{ + Logs: buf, + } + res := &basepb.VoidProto{} + c.pendingLogs.Lock() + c.pendingLogs.flushes++ + c.pendingLogs.Unlock() + if err := Call(toContext(c), "logservice", "Flush", req, res); err != nil { + log.Printf("internal.flushLog: Flush RPC: %v", err) + rescueLogs = true + return false + } + return true +} + +const ( + // Log flushing parameters. + flushInterval = 1 * time.Second + forceFlushInterval = 60 * time.Second +) + +func (c *context) logFlusher(stop <-chan int) { + lastFlush := time.Now() + tick := time.NewTicker(flushInterval) + for { + select { + case <-stop: + // Request finished. + tick.Stop() + return + case <-tick.C: + force := time.Now().Sub(lastFlush) > forceFlushInterval + if c.flushLog(force) { + lastFlush = time.Now() + } + } + } +} + +func ContextForTesting(req *http.Request) netcontext.Context { + return toContext(&context{req: req}) +} diff --git a/vendor/google.golang.org/appengine/internal/api_classic.go b/vendor/google.golang.org/appengine/internal/api_classic.go new file mode 100644 index 00000000..597f66e6 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/api_classic.go @@ -0,0 +1,159 @@ +// Copyright 2015 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// +build appengine + +package internal + +import ( + "errors" + "fmt" + "net/http" + "time" + + "appengine" + "appengine_internal" + basepb "appengine_internal/base" + + "github.com/golang/protobuf/proto" + netcontext "golang.org/x/net/context" +) + +var contextKey = "holds an appengine.Context" + +func fromContext(ctx netcontext.Context) appengine.Context { + c, _ := ctx.Value(&contextKey).(appengine.Context) + return c +} + +// This is only for classic App Engine adapters. +func ClassicContextFromContext(ctx netcontext.Context) appengine.Context { + return fromContext(ctx) +} + +func withContext(parent netcontext.Context, c appengine.Context) netcontext.Context { + ctx := netcontext.WithValue(parent, &contextKey, c) + + s := &basepb.StringProto{} + c.Call("__go__", "GetNamespace", &basepb.VoidProto{}, s, nil) + if ns := s.GetValue(); ns != "" { + ctx = NamespacedContext(ctx, ns) + } + + return ctx +} + +func IncomingHeaders(ctx netcontext.Context) http.Header { + if c := fromContext(ctx); c != nil { + if req, ok := c.Request().(*http.Request); ok { + return req.Header + } + } + return nil +} + +func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context { + c := appengine.NewContext(req) + return withContext(parent, c) +} + +type testingContext struct { + appengine.Context + + req *http.Request +} + +func (t *testingContext) FullyQualifiedAppID() string { return "dev~testcontext" } +func (t *testingContext) Call(service, method string, _, _ appengine_internal.ProtoMessage, _ *appengine_internal.CallOptions) error { + if service == "__go__" && method == "GetNamespace" { + return nil + } + return fmt.Errorf("testingContext: unsupported Call") +} +func (t *testingContext) Request() interface{} { return t.req } + +func ContextForTesting(req *http.Request) netcontext.Context { + return withContext(netcontext.Background(), &testingContext{req: req}) +} + +func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error { + if ns := NamespaceFromContext(ctx); ns != "" { + if fn, ok := NamespaceMods[service]; ok { + fn(in, ns) + } + } + + if f, ctx, ok := callOverrideFromContext(ctx); ok { + return f(ctx, service, method, in, out) + } + + // Handle already-done contexts quickly. + select { + case <-ctx.Done(): + return ctx.Err() + default: + } + + c := fromContext(ctx) + if c == nil { + // Give a good error message rather than a panic lower down. + return errors.New("not an App Engine context") + } + + // Apply transaction modifications if we're in a transaction. + if t := transactionFromContext(ctx); t != nil { + if t.finished { + return errors.New("transaction context has expired") + } + applyTransaction(in, &t.transaction) + } + + var opts *appengine_internal.CallOptions + if d, ok := ctx.Deadline(); ok { + opts = &appengine_internal.CallOptions{ + Timeout: d.Sub(time.Now()), + } + } + + err := c.Call(service, method, in, out, opts) + switch v := err.(type) { + case *appengine_internal.APIError: + return &APIError{ + Service: v.Service, + Detail: v.Detail, + Code: v.Code, + } + case *appengine_internal.CallError: + return &CallError{ + Detail: v.Detail, + Code: v.Code, + Timeout: v.Timeout, + } + } + return err +} + +func handleHTTP(w http.ResponseWriter, r *http.Request) { + panic("handleHTTP called; this should be impossible") +} + +func logf(c appengine.Context, level int64, format string, args ...interface{}) { + var fn func(format string, args ...interface{}) + switch level { + case 0: + fn = c.Debugf + case 1: + fn = c.Infof + case 2: + fn = c.Warningf + case 3: + fn = c.Errorf + case 4: + fn = c.Criticalf + default: + // This shouldn't happen. + fn = c.Criticalf + } + fn(format, args...) +} diff --git a/vendor/google.golang.org/appengine/internal/api_common.go b/vendor/google.golang.org/appengine/internal/api_common.go new file mode 100644 index 00000000..2db33a77 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/api_common.go @@ -0,0 +1,86 @@ +// Copyright 2015 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +package internal + +import ( + "github.com/golang/protobuf/proto" + netcontext "golang.org/x/net/context" +) + +type CallOverrideFunc func(ctx netcontext.Context, service, method string, in, out proto.Message) error + +var callOverrideKey = "holds []CallOverrideFunc" + +func WithCallOverride(ctx netcontext.Context, f CallOverrideFunc) netcontext.Context { + // We avoid appending to any existing call override + // so we don't risk overwriting a popped stack below. + var cofs []CallOverrideFunc + if uf, ok := ctx.Value(&callOverrideKey).([]CallOverrideFunc); ok { + cofs = append(cofs, uf...) + } + cofs = append(cofs, f) + return netcontext.WithValue(ctx, &callOverrideKey, cofs) +} + +func callOverrideFromContext(ctx netcontext.Context) (CallOverrideFunc, netcontext.Context, bool) { + cofs, _ := ctx.Value(&callOverrideKey).([]CallOverrideFunc) + if len(cofs) == 0 { + return nil, nil, false + } + // We found a list of overrides; grab the last, and reconstitute a + // context that will hide it. + f := cofs[len(cofs)-1] + ctx = netcontext.WithValue(ctx, &callOverrideKey, cofs[:len(cofs)-1]) + return f, ctx, true +} + +type logOverrideFunc func(level int64, format string, args ...interface{}) + +var logOverrideKey = "holds a logOverrideFunc" + +func WithLogOverride(ctx netcontext.Context, f logOverrideFunc) netcontext.Context { + return netcontext.WithValue(ctx, &logOverrideKey, f) +} + +var appIDOverrideKey = "holds a string, being the full app ID" + +func WithAppIDOverride(ctx netcontext.Context, appID string) netcontext.Context { + return netcontext.WithValue(ctx, &appIDOverrideKey, appID) +} + +var namespaceKey = "holds the namespace string" + +func withNamespace(ctx netcontext.Context, ns string) netcontext.Context { + return netcontext.WithValue(ctx, &namespaceKey, ns) +} + +func NamespaceFromContext(ctx netcontext.Context) string { + // If there's no namespace, return the empty string. + ns, _ := ctx.Value(&namespaceKey).(string) + return ns +} + +// FullyQualifiedAppID returns the fully-qualified application ID. +// This may contain a partition prefix (e.g. "s~" for High Replication apps), +// or a domain prefix (e.g. "example.com:"). +func FullyQualifiedAppID(ctx netcontext.Context) string { + if id, ok := ctx.Value(&appIDOverrideKey).(string); ok { + return id + } + return fullyQualifiedAppID(ctx) +} + +func Logf(ctx netcontext.Context, level int64, format string, args ...interface{}) { + if f, ok := ctx.Value(&logOverrideKey).(logOverrideFunc); ok { + f(level, format, args...) + return + } + logf(fromContext(ctx), level, format, args...) +} + +// NamespacedContext wraps a Context to support namespaces. +func NamespacedContext(ctx netcontext.Context, namespace string) netcontext.Context { + return withNamespace(ctx, namespace) +} diff --git a/vendor/google.golang.org/appengine/internal/app_id.go b/vendor/google.golang.org/appengine/internal/app_id.go new file mode 100644 index 00000000..11df8c07 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/app_id.go @@ -0,0 +1,28 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +package internal + +import ( + "strings" +) + +func parseFullAppID(appid string) (partition, domain, displayID string) { + if i := strings.Index(appid, "~"); i != -1 { + partition, appid = appid[:i], appid[i+1:] + } + if i := strings.Index(appid, ":"); i != -1 { + domain, appid = appid[:i], appid[i+1:] + } + return partition, domain, appid +} + +// appID returns "appid" or "domain.com:appid". +func appID(fullAppID string) string { + _, dom, dis := parseFullAppID(fullAppID) + if dom != "" { + return dom + ":" + dis + } + return dis +} diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go new file mode 100644 index 00000000..87d9701b --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go @@ -0,0 +1,296 @@ +// Code generated by protoc-gen-go. +// source: google.golang.org/appengine/internal/app_identity/app_identity_service.proto +// DO NOT EDIT! + +/* +Package app_identity is a generated protocol buffer package. + +It is generated from these files: + google.golang.org/appengine/internal/app_identity/app_identity_service.proto + +It has these top-level messages: + AppIdentityServiceError + SignForAppRequest + SignForAppResponse + GetPublicCertificateForAppRequest + PublicCertificate + GetPublicCertificateForAppResponse + GetServiceAccountNameRequest + GetServiceAccountNameResponse + GetAccessTokenRequest + GetAccessTokenResponse + GetDefaultGcsBucketNameRequest + GetDefaultGcsBucketNameResponse +*/ +package app_identity + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type AppIdentityServiceError_ErrorCode int32 + +const ( + AppIdentityServiceError_SUCCESS AppIdentityServiceError_ErrorCode = 0 + AppIdentityServiceError_UNKNOWN_SCOPE AppIdentityServiceError_ErrorCode = 9 + AppIdentityServiceError_BLOB_TOO_LARGE AppIdentityServiceError_ErrorCode = 1000 + AppIdentityServiceError_DEADLINE_EXCEEDED AppIdentityServiceError_ErrorCode = 1001 + AppIdentityServiceError_NOT_A_VALID_APP AppIdentityServiceError_ErrorCode = 1002 + AppIdentityServiceError_UNKNOWN_ERROR AppIdentityServiceError_ErrorCode = 1003 + AppIdentityServiceError_NOT_ALLOWED AppIdentityServiceError_ErrorCode = 1005 + AppIdentityServiceError_NOT_IMPLEMENTED AppIdentityServiceError_ErrorCode = 1006 +) + +var AppIdentityServiceError_ErrorCode_name = map[int32]string{ + 0: "SUCCESS", + 9: "UNKNOWN_SCOPE", + 1000: "BLOB_TOO_LARGE", + 1001: "DEADLINE_EXCEEDED", + 1002: "NOT_A_VALID_APP", + 1003: "UNKNOWN_ERROR", + 1005: "NOT_ALLOWED", + 1006: "NOT_IMPLEMENTED", +} +var AppIdentityServiceError_ErrorCode_value = map[string]int32{ + "SUCCESS": 0, + "UNKNOWN_SCOPE": 9, + "BLOB_TOO_LARGE": 1000, + "DEADLINE_EXCEEDED": 1001, + "NOT_A_VALID_APP": 1002, + "UNKNOWN_ERROR": 1003, + "NOT_ALLOWED": 1005, + "NOT_IMPLEMENTED": 1006, +} + +func (x AppIdentityServiceError_ErrorCode) Enum() *AppIdentityServiceError_ErrorCode { + p := new(AppIdentityServiceError_ErrorCode) + *p = x + return p +} +func (x AppIdentityServiceError_ErrorCode) String() string { + return proto.EnumName(AppIdentityServiceError_ErrorCode_name, int32(x)) +} +func (x *AppIdentityServiceError_ErrorCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AppIdentityServiceError_ErrorCode_value, data, "AppIdentityServiceError_ErrorCode") + if err != nil { + return err + } + *x = AppIdentityServiceError_ErrorCode(value) + return nil +} + +type AppIdentityServiceError struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *AppIdentityServiceError) Reset() { *m = AppIdentityServiceError{} } +func (m *AppIdentityServiceError) String() string { return proto.CompactTextString(m) } +func (*AppIdentityServiceError) ProtoMessage() {} + +type SignForAppRequest struct { + BytesToSign []byte `protobuf:"bytes,1,opt,name=bytes_to_sign" json:"bytes_to_sign,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SignForAppRequest) Reset() { *m = SignForAppRequest{} } +func (m *SignForAppRequest) String() string { return proto.CompactTextString(m) } +func (*SignForAppRequest) ProtoMessage() {} + +func (m *SignForAppRequest) GetBytesToSign() []byte { + if m != nil { + return m.BytesToSign + } + return nil +} + +type SignForAppResponse struct { + KeyName *string `protobuf:"bytes,1,opt,name=key_name" json:"key_name,omitempty"` + SignatureBytes []byte `protobuf:"bytes,2,opt,name=signature_bytes" json:"signature_bytes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SignForAppResponse) Reset() { *m = SignForAppResponse{} } +func (m *SignForAppResponse) String() string { return proto.CompactTextString(m) } +func (*SignForAppResponse) ProtoMessage() {} + +func (m *SignForAppResponse) GetKeyName() string { + if m != nil && m.KeyName != nil { + return *m.KeyName + } + return "" +} + +func (m *SignForAppResponse) GetSignatureBytes() []byte { + if m != nil { + return m.SignatureBytes + } + return nil +} + +type GetPublicCertificateForAppRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetPublicCertificateForAppRequest) Reset() { *m = GetPublicCertificateForAppRequest{} } +func (m *GetPublicCertificateForAppRequest) String() string { return proto.CompactTextString(m) } +func (*GetPublicCertificateForAppRequest) ProtoMessage() {} + +type PublicCertificate struct { + KeyName *string `protobuf:"bytes,1,opt,name=key_name" json:"key_name,omitempty"` + X509CertificatePem *string `protobuf:"bytes,2,opt,name=x509_certificate_pem" json:"x509_certificate_pem,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PublicCertificate) Reset() { *m = PublicCertificate{} } +func (m *PublicCertificate) String() string { return proto.CompactTextString(m) } +func (*PublicCertificate) ProtoMessage() {} + +func (m *PublicCertificate) GetKeyName() string { + if m != nil && m.KeyName != nil { + return *m.KeyName + } + return "" +} + +func (m *PublicCertificate) GetX509CertificatePem() string { + if m != nil && m.X509CertificatePem != nil { + return *m.X509CertificatePem + } + return "" +} + +type GetPublicCertificateForAppResponse struct { + PublicCertificateList []*PublicCertificate `protobuf:"bytes,1,rep,name=public_certificate_list" json:"public_certificate_list,omitempty"` + MaxClientCacheTimeInSecond *int64 `protobuf:"varint,2,opt,name=max_client_cache_time_in_second" json:"max_client_cache_time_in_second,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetPublicCertificateForAppResponse) Reset() { *m = GetPublicCertificateForAppResponse{} } +func (m *GetPublicCertificateForAppResponse) String() string { return proto.CompactTextString(m) } +func (*GetPublicCertificateForAppResponse) ProtoMessage() {} + +func (m *GetPublicCertificateForAppResponse) GetPublicCertificateList() []*PublicCertificate { + if m != nil { + return m.PublicCertificateList + } + return nil +} + +func (m *GetPublicCertificateForAppResponse) GetMaxClientCacheTimeInSecond() int64 { + if m != nil && m.MaxClientCacheTimeInSecond != nil { + return *m.MaxClientCacheTimeInSecond + } + return 0 +} + +type GetServiceAccountNameRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetServiceAccountNameRequest) Reset() { *m = GetServiceAccountNameRequest{} } +func (m *GetServiceAccountNameRequest) String() string { return proto.CompactTextString(m) } +func (*GetServiceAccountNameRequest) ProtoMessage() {} + +type GetServiceAccountNameResponse struct { + ServiceAccountName *string `protobuf:"bytes,1,opt,name=service_account_name" json:"service_account_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetServiceAccountNameResponse) Reset() { *m = GetServiceAccountNameResponse{} } +func (m *GetServiceAccountNameResponse) String() string { return proto.CompactTextString(m) } +func (*GetServiceAccountNameResponse) ProtoMessage() {} + +func (m *GetServiceAccountNameResponse) GetServiceAccountName() string { + if m != nil && m.ServiceAccountName != nil { + return *m.ServiceAccountName + } + return "" +} + +type GetAccessTokenRequest struct { + Scope []string `protobuf:"bytes,1,rep,name=scope" json:"scope,omitempty"` + ServiceAccountId *int64 `protobuf:"varint,2,opt,name=service_account_id" json:"service_account_id,omitempty"` + ServiceAccountName *string `protobuf:"bytes,3,opt,name=service_account_name" json:"service_account_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetAccessTokenRequest) Reset() { *m = GetAccessTokenRequest{} } +func (m *GetAccessTokenRequest) String() string { return proto.CompactTextString(m) } +func (*GetAccessTokenRequest) ProtoMessage() {} + +func (m *GetAccessTokenRequest) GetScope() []string { + if m != nil { + return m.Scope + } + return nil +} + +func (m *GetAccessTokenRequest) GetServiceAccountId() int64 { + if m != nil && m.ServiceAccountId != nil { + return *m.ServiceAccountId + } + return 0 +} + +func (m *GetAccessTokenRequest) GetServiceAccountName() string { + if m != nil && m.ServiceAccountName != nil { + return *m.ServiceAccountName + } + return "" +} + +type GetAccessTokenResponse struct { + AccessToken *string `protobuf:"bytes,1,opt,name=access_token" json:"access_token,omitempty"` + ExpirationTime *int64 `protobuf:"varint,2,opt,name=expiration_time" json:"expiration_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetAccessTokenResponse) Reset() { *m = GetAccessTokenResponse{} } +func (m *GetAccessTokenResponse) String() string { return proto.CompactTextString(m) } +func (*GetAccessTokenResponse) ProtoMessage() {} + +func (m *GetAccessTokenResponse) GetAccessToken() string { + if m != nil && m.AccessToken != nil { + return *m.AccessToken + } + return "" +} + +func (m *GetAccessTokenResponse) GetExpirationTime() int64 { + if m != nil && m.ExpirationTime != nil { + return *m.ExpirationTime + } + return 0 +} + +type GetDefaultGcsBucketNameRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetDefaultGcsBucketNameRequest) Reset() { *m = GetDefaultGcsBucketNameRequest{} } +func (m *GetDefaultGcsBucketNameRequest) String() string { return proto.CompactTextString(m) } +func (*GetDefaultGcsBucketNameRequest) ProtoMessage() {} + +type GetDefaultGcsBucketNameResponse struct { + DefaultGcsBucketName *string `protobuf:"bytes,1,opt,name=default_gcs_bucket_name" json:"default_gcs_bucket_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetDefaultGcsBucketNameResponse) Reset() { *m = GetDefaultGcsBucketNameResponse{} } +func (m *GetDefaultGcsBucketNameResponse) String() string { return proto.CompactTextString(m) } +func (*GetDefaultGcsBucketNameResponse) ProtoMessage() {} + +func (m *GetDefaultGcsBucketNameResponse) GetDefaultGcsBucketName() string { + if m != nil && m.DefaultGcsBucketName != nil { + return *m.DefaultGcsBucketName + } + return "" +} + +func init() { +} diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.pb.go b/vendor/google.golang.org/appengine/internal/base/api_base.pb.go new file mode 100644 index 00000000..36a19565 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/base/api_base.pb.go @@ -0,0 +1,133 @@ +// Code generated by protoc-gen-go. +// source: google.golang.org/appengine/internal/base/api_base.proto +// DO NOT EDIT! + +/* +Package base is a generated protocol buffer package. + +It is generated from these files: + google.golang.org/appengine/internal/base/api_base.proto + +It has these top-level messages: + StringProto + Integer32Proto + Integer64Proto + BoolProto + DoubleProto + BytesProto + VoidProto +*/ +package base + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type StringProto struct { + Value *string `protobuf:"bytes,1,req,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StringProto) Reset() { *m = StringProto{} } +func (m *StringProto) String() string { return proto.CompactTextString(m) } +func (*StringProto) ProtoMessage() {} + +func (m *StringProto) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type Integer32Proto struct { + Value *int32 `protobuf:"varint,1,req,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Integer32Proto) Reset() { *m = Integer32Proto{} } +func (m *Integer32Proto) String() string { return proto.CompactTextString(m) } +func (*Integer32Proto) ProtoMessage() {} + +func (m *Integer32Proto) GetValue() int32 { + if m != nil && m.Value != nil { + return *m.Value + } + return 0 +} + +type Integer64Proto struct { + Value *int64 `protobuf:"varint,1,req,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Integer64Proto) Reset() { *m = Integer64Proto{} } +func (m *Integer64Proto) String() string { return proto.CompactTextString(m) } +func (*Integer64Proto) ProtoMessage() {} + +func (m *Integer64Proto) GetValue() int64 { + if m != nil && m.Value != nil { + return *m.Value + } + return 0 +} + +type BoolProto struct { + Value *bool `protobuf:"varint,1,req,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BoolProto) Reset() { *m = BoolProto{} } +func (m *BoolProto) String() string { return proto.CompactTextString(m) } +func (*BoolProto) ProtoMessage() {} + +func (m *BoolProto) GetValue() bool { + if m != nil && m.Value != nil { + return *m.Value + } + return false +} + +type DoubleProto struct { + Value *float64 `protobuf:"fixed64,1,req,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DoubleProto) Reset() { *m = DoubleProto{} } +func (m *DoubleProto) String() string { return proto.CompactTextString(m) } +func (*DoubleProto) ProtoMessage() {} + +func (m *DoubleProto) GetValue() float64 { + if m != nil && m.Value != nil { + return *m.Value + } + return 0 +} + +type BytesProto struct { + Value []byte `protobuf:"bytes,1,req,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BytesProto) Reset() { *m = BytesProto{} } +func (m *BytesProto) String() string { return proto.CompactTextString(m) } +func (*BytesProto) ProtoMessage() {} + +func (m *BytesProto) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +type VoidProto struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *VoidProto) Reset() { *m = VoidProto{} } +func (m *VoidProto) String() string { return proto.CompactTextString(m) } +func (*VoidProto) ProtoMessage() {} diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go new file mode 100644 index 00000000..8613cb73 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go @@ -0,0 +1,2778 @@ +// Code generated by protoc-gen-go. +// source: google.golang.org/appengine/internal/datastore/datastore_v3.proto +// DO NOT EDIT! + +/* +Package datastore is a generated protocol buffer package. + +It is generated from these files: + google.golang.org/appengine/internal/datastore/datastore_v3.proto + +It has these top-level messages: + Action + PropertyValue + Property + Path + Reference + User + EntityProto + CompositeProperty + Index + CompositeIndex + IndexPostfix + IndexPosition + Snapshot + InternalHeader + Transaction + Query + CompiledQuery + CompiledCursor + Cursor + Error + Cost + GetRequest + GetResponse + PutRequest + PutResponse + TouchRequest + TouchResponse + DeleteRequest + DeleteResponse + NextRequest + QueryResult + AllocateIdsRequest + AllocateIdsResponse + CompositeIndices + AddActionsRequest + AddActionsResponse + BeginTransactionRequest + CommitResponse +*/ +package datastore + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Property_Meaning int32 + +const ( + Property_NO_MEANING Property_Meaning = 0 + Property_BLOB Property_Meaning = 14 + Property_TEXT Property_Meaning = 15 + Property_BYTESTRING Property_Meaning = 16 + Property_ATOM_CATEGORY Property_Meaning = 1 + Property_ATOM_LINK Property_Meaning = 2 + Property_ATOM_TITLE Property_Meaning = 3 + Property_ATOM_CONTENT Property_Meaning = 4 + Property_ATOM_SUMMARY Property_Meaning = 5 + Property_ATOM_AUTHOR Property_Meaning = 6 + Property_GD_WHEN Property_Meaning = 7 + Property_GD_EMAIL Property_Meaning = 8 + Property_GEORSS_POINT Property_Meaning = 9 + Property_GD_IM Property_Meaning = 10 + Property_GD_PHONENUMBER Property_Meaning = 11 + Property_GD_POSTALADDRESS Property_Meaning = 12 + Property_GD_RATING Property_Meaning = 13 + Property_BLOBKEY Property_Meaning = 17 + Property_ENTITY_PROTO Property_Meaning = 19 + Property_INDEX_VALUE Property_Meaning = 18 +) + +var Property_Meaning_name = map[int32]string{ + 0: "NO_MEANING", + 14: "BLOB", + 15: "TEXT", + 16: "BYTESTRING", + 1: "ATOM_CATEGORY", + 2: "ATOM_LINK", + 3: "ATOM_TITLE", + 4: "ATOM_CONTENT", + 5: "ATOM_SUMMARY", + 6: "ATOM_AUTHOR", + 7: "GD_WHEN", + 8: "GD_EMAIL", + 9: "GEORSS_POINT", + 10: "GD_IM", + 11: "GD_PHONENUMBER", + 12: "GD_POSTALADDRESS", + 13: "GD_RATING", + 17: "BLOBKEY", + 19: "ENTITY_PROTO", + 18: "INDEX_VALUE", +} +var Property_Meaning_value = map[string]int32{ + "NO_MEANING": 0, + "BLOB": 14, + "TEXT": 15, + "BYTESTRING": 16, + "ATOM_CATEGORY": 1, + "ATOM_LINK": 2, + "ATOM_TITLE": 3, + "ATOM_CONTENT": 4, + "ATOM_SUMMARY": 5, + "ATOM_AUTHOR": 6, + "GD_WHEN": 7, + "GD_EMAIL": 8, + "GEORSS_POINT": 9, + "GD_IM": 10, + "GD_PHONENUMBER": 11, + "GD_POSTALADDRESS": 12, + "GD_RATING": 13, + "BLOBKEY": 17, + "ENTITY_PROTO": 19, + "INDEX_VALUE": 18, +} + +func (x Property_Meaning) Enum() *Property_Meaning { + p := new(Property_Meaning) + *p = x + return p +} +func (x Property_Meaning) String() string { + return proto.EnumName(Property_Meaning_name, int32(x)) +} +func (x *Property_Meaning) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Property_Meaning_value, data, "Property_Meaning") + if err != nil { + return err + } + *x = Property_Meaning(value) + return nil +} + +type Property_FtsTokenizationOption int32 + +const ( + Property_HTML Property_FtsTokenizationOption = 1 + Property_ATOM Property_FtsTokenizationOption = 2 +) + +var Property_FtsTokenizationOption_name = map[int32]string{ + 1: "HTML", + 2: "ATOM", +} +var Property_FtsTokenizationOption_value = map[string]int32{ + "HTML": 1, + "ATOM": 2, +} + +func (x Property_FtsTokenizationOption) Enum() *Property_FtsTokenizationOption { + p := new(Property_FtsTokenizationOption) + *p = x + return p +} +func (x Property_FtsTokenizationOption) String() string { + return proto.EnumName(Property_FtsTokenizationOption_name, int32(x)) +} +func (x *Property_FtsTokenizationOption) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Property_FtsTokenizationOption_value, data, "Property_FtsTokenizationOption") + if err != nil { + return err + } + *x = Property_FtsTokenizationOption(value) + return nil +} + +type EntityProto_Kind int32 + +const ( + EntityProto_GD_CONTACT EntityProto_Kind = 1 + EntityProto_GD_EVENT EntityProto_Kind = 2 + EntityProto_GD_MESSAGE EntityProto_Kind = 3 +) + +var EntityProto_Kind_name = map[int32]string{ + 1: "GD_CONTACT", + 2: "GD_EVENT", + 3: "GD_MESSAGE", +} +var EntityProto_Kind_value = map[string]int32{ + "GD_CONTACT": 1, + "GD_EVENT": 2, + "GD_MESSAGE": 3, +} + +func (x EntityProto_Kind) Enum() *EntityProto_Kind { + p := new(EntityProto_Kind) + *p = x + return p +} +func (x EntityProto_Kind) String() string { + return proto.EnumName(EntityProto_Kind_name, int32(x)) +} +func (x *EntityProto_Kind) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EntityProto_Kind_value, data, "EntityProto_Kind") + if err != nil { + return err + } + *x = EntityProto_Kind(value) + return nil +} + +type Index_Property_Direction int32 + +const ( + Index_Property_ASCENDING Index_Property_Direction = 1 + Index_Property_DESCENDING Index_Property_Direction = 2 +) + +var Index_Property_Direction_name = map[int32]string{ + 1: "ASCENDING", + 2: "DESCENDING", +} +var Index_Property_Direction_value = map[string]int32{ + "ASCENDING": 1, + "DESCENDING": 2, +} + +func (x Index_Property_Direction) Enum() *Index_Property_Direction { + p := new(Index_Property_Direction) + *p = x + return p +} +func (x Index_Property_Direction) String() string { + return proto.EnumName(Index_Property_Direction_name, int32(x)) +} +func (x *Index_Property_Direction) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Index_Property_Direction_value, data, "Index_Property_Direction") + if err != nil { + return err + } + *x = Index_Property_Direction(value) + return nil +} + +type CompositeIndex_State int32 + +const ( + CompositeIndex_WRITE_ONLY CompositeIndex_State = 1 + CompositeIndex_READ_WRITE CompositeIndex_State = 2 + CompositeIndex_DELETED CompositeIndex_State = 3 + CompositeIndex_ERROR CompositeIndex_State = 4 +) + +var CompositeIndex_State_name = map[int32]string{ + 1: "WRITE_ONLY", + 2: "READ_WRITE", + 3: "DELETED", + 4: "ERROR", +} +var CompositeIndex_State_value = map[string]int32{ + "WRITE_ONLY": 1, + "READ_WRITE": 2, + "DELETED": 3, + "ERROR": 4, +} + +func (x CompositeIndex_State) Enum() *CompositeIndex_State { + p := new(CompositeIndex_State) + *p = x + return p +} +func (x CompositeIndex_State) String() string { + return proto.EnumName(CompositeIndex_State_name, int32(x)) +} +func (x *CompositeIndex_State) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CompositeIndex_State_value, data, "CompositeIndex_State") + if err != nil { + return err + } + *x = CompositeIndex_State(value) + return nil +} + +type Snapshot_Status int32 + +const ( + Snapshot_INACTIVE Snapshot_Status = 0 + Snapshot_ACTIVE Snapshot_Status = 1 +) + +var Snapshot_Status_name = map[int32]string{ + 0: "INACTIVE", + 1: "ACTIVE", +} +var Snapshot_Status_value = map[string]int32{ + "INACTIVE": 0, + "ACTIVE": 1, +} + +func (x Snapshot_Status) Enum() *Snapshot_Status { + p := new(Snapshot_Status) + *p = x + return p +} +func (x Snapshot_Status) String() string { + return proto.EnumName(Snapshot_Status_name, int32(x)) +} +func (x *Snapshot_Status) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Snapshot_Status_value, data, "Snapshot_Status") + if err != nil { + return err + } + *x = Snapshot_Status(value) + return nil +} + +type Query_Hint int32 + +const ( + Query_ORDER_FIRST Query_Hint = 1 + Query_ANCESTOR_FIRST Query_Hint = 2 + Query_FILTER_FIRST Query_Hint = 3 +) + +var Query_Hint_name = map[int32]string{ + 1: "ORDER_FIRST", + 2: "ANCESTOR_FIRST", + 3: "FILTER_FIRST", +} +var Query_Hint_value = map[string]int32{ + "ORDER_FIRST": 1, + "ANCESTOR_FIRST": 2, + "FILTER_FIRST": 3, +} + +func (x Query_Hint) Enum() *Query_Hint { + p := new(Query_Hint) + *p = x + return p +} +func (x Query_Hint) String() string { + return proto.EnumName(Query_Hint_name, int32(x)) +} +func (x *Query_Hint) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Query_Hint_value, data, "Query_Hint") + if err != nil { + return err + } + *x = Query_Hint(value) + return nil +} + +type Query_Filter_Operator int32 + +const ( + Query_Filter_LESS_THAN Query_Filter_Operator = 1 + Query_Filter_LESS_THAN_OR_EQUAL Query_Filter_Operator = 2 + Query_Filter_GREATER_THAN Query_Filter_Operator = 3 + Query_Filter_GREATER_THAN_OR_EQUAL Query_Filter_Operator = 4 + Query_Filter_EQUAL Query_Filter_Operator = 5 + Query_Filter_IN Query_Filter_Operator = 6 + Query_Filter_EXISTS Query_Filter_Operator = 7 +) + +var Query_Filter_Operator_name = map[int32]string{ + 1: "LESS_THAN", + 2: "LESS_THAN_OR_EQUAL", + 3: "GREATER_THAN", + 4: "GREATER_THAN_OR_EQUAL", + 5: "EQUAL", + 6: "IN", + 7: "EXISTS", +} +var Query_Filter_Operator_value = map[string]int32{ + "LESS_THAN": 1, + "LESS_THAN_OR_EQUAL": 2, + "GREATER_THAN": 3, + "GREATER_THAN_OR_EQUAL": 4, + "EQUAL": 5, + "IN": 6, + "EXISTS": 7, +} + +func (x Query_Filter_Operator) Enum() *Query_Filter_Operator { + p := new(Query_Filter_Operator) + *p = x + return p +} +func (x Query_Filter_Operator) String() string { + return proto.EnumName(Query_Filter_Operator_name, int32(x)) +} +func (x *Query_Filter_Operator) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Query_Filter_Operator_value, data, "Query_Filter_Operator") + if err != nil { + return err + } + *x = Query_Filter_Operator(value) + return nil +} + +type Query_Order_Direction int32 + +const ( + Query_Order_ASCENDING Query_Order_Direction = 1 + Query_Order_DESCENDING Query_Order_Direction = 2 +) + +var Query_Order_Direction_name = map[int32]string{ + 1: "ASCENDING", + 2: "DESCENDING", +} +var Query_Order_Direction_value = map[string]int32{ + "ASCENDING": 1, + "DESCENDING": 2, +} + +func (x Query_Order_Direction) Enum() *Query_Order_Direction { + p := new(Query_Order_Direction) + *p = x + return p +} +func (x Query_Order_Direction) String() string { + return proto.EnumName(Query_Order_Direction_name, int32(x)) +} +func (x *Query_Order_Direction) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Query_Order_Direction_value, data, "Query_Order_Direction") + if err != nil { + return err + } + *x = Query_Order_Direction(value) + return nil +} + +type Error_ErrorCode int32 + +const ( + Error_BAD_REQUEST Error_ErrorCode = 1 + Error_CONCURRENT_TRANSACTION Error_ErrorCode = 2 + Error_INTERNAL_ERROR Error_ErrorCode = 3 + Error_NEED_INDEX Error_ErrorCode = 4 + Error_TIMEOUT Error_ErrorCode = 5 + Error_PERMISSION_DENIED Error_ErrorCode = 6 + Error_BIGTABLE_ERROR Error_ErrorCode = 7 + Error_COMMITTED_BUT_STILL_APPLYING Error_ErrorCode = 8 + Error_CAPABILITY_DISABLED Error_ErrorCode = 9 + Error_TRY_ALTERNATE_BACKEND Error_ErrorCode = 10 + Error_SAFE_TIME_TOO_OLD Error_ErrorCode = 11 +) + +var Error_ErrorCode_name = map[int32]string{ + 1: "BAD_REQUEST", + 2: "CONCURRENT_TRANSACTION", + 3: "INTERNAL_ERROR", + 4: "NEED_INDEX", + 5: "TIMEOUT", + 6: "PERMISSION_DENIED", + 7: "BIGTABLE_ERROR", + 8: "COMMITTED_BUT_STILL_APPLYING", + 9: "CAPABILITY_DISABLED", + 10: "TRY_ALTERNATE_BACKEND", + 11: "SAFE_TIME_TOO_OLD", +} +var Error_ErrorCode_value = map[string]int32{ + "BAD_REQUEST": 1, + "CONCURRENT_TRANSACTION": 2, + "INTERNAL_ERROR": 3, + "NEED_INDEX": 4, + "TIMEOUT": 5, + "PERMISSION_DENIED": 6, + "BIGTABLE_ERROR": 7, + "COMMITTED_BUT_STILL_APPLYING": 8, + "CAPABILITY_DISABLED": 9, + "TRY_ALTERNATE_BACKEND": 10, + "SAFE_TIME_TOO_OLD": 11, +} + +func (x Error_ErrorCode) Enum() *Error_ErrorCode { + p := new(Error_ErrorCode) + *p = x + return p +} +func (x Error_ErrorCode) String() string { + return proto.EnumName(Error_ErrorCode_name, int32(x)) +} +func (x *Error_ErrorCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Error_ErrorCode_value, data, "Error_ErrorCode") + if err != nil { + return err + } + *x = Error_ErrorCode(value) + return nil +} + +type PutRequest_AutoIdPolicy int32 + +const ( + PutRequest_CURRENT PutRequest_AutoIdPolicy = 0 + PutRequest_SEQUENTIAL PutRequest_AutoIdPolicy = 1 +) + +var PutRequest_AutoIdPolicy_name = map[int32]string{ + 0: "CURRENT", + 1: "SEQUENTIAL", +} +var PutRequest_AutoIdPolicy_value = map[string]int32{ + "CURRENT": 0, + "SEQUENTIAL": 1, +} + +func (x PutRequest_AutoIdPolicy) Enum() *PutRequest_AutoIdPolicy { + p := new(PutRequest_AutoIdPolicy) + *p = x + return p +} +func (x PutRequest_AutoIdPolicy) String() string { + return proto.EnumName(PutRequest_AutoIdPolicy_name, int32(x)) +} +func (x *PutRequest_AutoIdPolicy) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(PutRequest_AutoIdPolicy_value, data, "PutRequest_AutoIdPolicy") + if err != nil { + return err + } + *x = PutRequest_AutoIdPolicy(value) + return nil +} + +type Action struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Action) Reset() { *m = Action{} } +func (m *Action) String() string { return proto.CompactTextString(m) } +func (*Action) ProtoMessage() {} + +type PropertyValue struct { + Int64Value *int64 `protobuf:"varint,1,opt,name=int64Value" json:"int64Value,omitempty"` + BooleanValue *bool `protobuf:"varint,2,opt,name=booleanValue" json:"booleanValue,omitempty"` + StringValue *string `protobuf:"bytes,3,opt,name=stringValue" json:"stringValue,omitempty"` + DoubleValue *float64 `protobuf:"fixed64,4,opt,name=doubleValue" json:"doubleValue,omitempty"` + Pointvalue *PropertyValue_PointValue `protobuf:"group,5,opt,name=PointValue" json:"pointvalue,omitempty"` + Uservalue *PropertyValue_UserValue `protobuf:"group,8,opt,name=UserValue" json:"uservalue,omitempty"` + Referencevalue *PropertyValue_ReferenceValue `protobuf:"group,12,opt,name=ReferenceValue" json:"referencevalue,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PropertyValue) Reset() { *m = PropertyValue{} } +func (m *PropertyValue) String() string { return proto.CompactTextString(m) } +func (*PropertyValue) ProtoMessage() {} + +func (m *PropertyValue) GetInt64Value() int64 { + if m != nil && m.Int64Value != nil { + return *m.Int64Value + } + return 0 +} + +func (m *PropertyValue) GetBooleanValue() bool { + if m != nil && m.BooleanValue != nil { + return *m.BooleanValue + } + return false +} + +func (m *PropertyValue) GetStringValue() string { + if m != nil && m.StringValue != nil { + return *m.StringValue + } + return "" +} + +func (m *PropertyValue) GetDoubleValue() float64 { + if m != nil && m.DoubleValue != nil { + return *m.DoubleValue + } + return 0 +} + +func (m *PropertyValue) GetPointvalue() *PropertyValue_PointValue { + if m != nil { + return m.Pointvalue + } + return nil +} + +func (m *PropertyValue) GetUservalue() *PropertyValue_UserValue { + if m != nil { + return m.Uservalue + } + return nil +} + +func (m *PropertyValue) GetReferencevalue() *PropertyValue_ReferenceValue { + if m != nil { + return m.Referencevalue + } + return nil +} + +type PropertyValue_PointValue struct { + X *float64 `protobuf:"fixed64,6,req,name=x" json:"x,omitempty"` + Y *float64 `protobuf:"fixed64,7,req,name=y" json:"y,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PropertyValue_PointValue) Reset() { *m = PropertyValue_PointValue{} } +func (m *PropertyValue_PointValue) String() string { return proto.CompactTextString(m) } +func (*PropertyValue_PointValue) ProtoMessage() {} + +func (m *PropertyValue_PointValue) GetX() float64 { + if m != nil && m.X != nil { + return *m.X + } + return 0 +} + +func (m *PropertyValue_PointValue) GetY() float64 { + if m != nil && m.Y != nil { + return *m.Y + } + return 0 +} + +type PropertyValue_UserValue struct { + Email *string `protobuf:"bytes,9,req,name=email" json:"email,omitempty"` + AuthDomain *string `protobuf:"bytes,10,req,name=auth_domain" json:"auth_domain,omitempty"` + Nickname *string `protobuf:"bytes,11,opt,name=nickname" json:"nickname,omitempty"` + FederatedIdentity *string `protobuf:"bytes,21,opt,name=federated_identity" json:"federated_identity,omitempty"` + FederatedProvider *string `protobuf:"bytes,22,opt,name=federated_provider" json:"federated_provider,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PropertyValue_UserValue) Reset() { *m = PropertyValue_UserValue{} } +func (m *PropertyValue_UserValue) String() string { return proto.CompactTextString(m) } +func (*PropertyValue_UserValue) ProtoMessage() {} + +func (m *PropertyValue_UserValue) GetEmail() string { + if m != nil && m.Email != nil { + return *m.Email + } + return "" +} + +func (m *PropertyValue_UserValue) GetAuthDomain() string { + if m != nil && m.AuthDomain != nil { + return *m.AuthDomain + } + return "" +} + +func (m *PropertyValue_UserValue) GetNickname() string { + if m != nil && m.Nickname != nil { + return *m.Nickname + } + return "" +} + +func (m *PropertyValue_UserValue) GetFederatedIdentity() string { + if m != nil && m.FederatedIdentity != nil { + return *m.FederatedIdentity + } + return "" +} + +func (m *PropertyValue_UserValue) GetFederatedProvider() string { + if m != nil && m.FederatedProvider != nil { + return *m.FederatedProvider + } + return "" +} + +type PropertyValue_ReferenceValue struct { + App *string `protobuf:"bytes,13,req,name=app" json:"app,omitempty"` + NameSpace *string `protobuf:"bytes,20,opt,name=name_space" json:"name_space,omitempty"` + Pathelement []*PropertyValue_ReferenceValue_PathElement `protobuf:"group,14,rep,name=PathElement" json:"pathelement,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PropertyValue_ReferenceValue) Reset() { *m = PropertyValue_ReferenceValue{} } +func (m *PropertyValue_ReferenceValue) String() string { return proto.CompactTextString(m) } +func (*PropertyValue_ReferenceValue) ProtoMessage() {} + +func (m *PropertyValue_ReferenceValue) GetApp() string { + if m != nil && m.App != nil { + return *m.App + } + return "" +} + +func (m *PropertyValue_ReferenceValue) GetNameSpace() string { + if m != nil && m.NameSpace != nil { + return *m.NameSpace + } + return "" +} + +func (m *PropertyValue_ReferenceValue) GetPathelement() []*PropertyValue_ReferenceValue_PathElement { + if m != nil { + return m.Pathelement + } + return nil +} + +type PropertyValue_ReferenceValue_PathElement struct { + Type *string `protobuf:"bytes,15,req,name=type" json:"type,omitempty"` + Id *int64 `protobuf:"varint,16,opt,name=id" json:"id,omitempty"` + Name *string `protobuf:"bytes,17,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PropertyValue_ReferenceValue_PathElement) Reset() { + *m = PropertyValue_ReferenceValue_PathElement{} +} +func (m *PropertyValue_ReferenceValue_PathElement) String() string { return proto.CompactTextString(m) } +func (*PropertyValue_ReferenceValue_PathElement) ProtoMessage() {} + +func (m *PropertyValue_ReferenceValue_PathElement) GetType() string { + if m != nil && m.Type != nil { + return *m.Type + } + return "" +} + +func (m *PropertyValue_ReferenceValue_PathElement) GetId() int64 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *PropertyValue_ReferenceValue_PathElement) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type Property struct { + Meaning *Property_Meaning `protobuf:"varint,1,opt,name=meaning,enum=appengine.Property_Meaning,def=0" json:"meaning,omitempty"` + MeaningUri *string `protobuf:"bytes,2,opt,name=meaning_uri" json:"meaning_uri,omitempty"` + Name *string `protobuf:"bytes,3,req,name=name" json:"name,omitempty"` + Value *PropertyValue `protobuf:"bytes,5,req,name=value" json:"value,omitempty"` + Multiple *bool `protobuf:"varint,4,req,name=multiple" json:"multiple,omitempty"` + Searchable *bool `protobuf:"varint,6,opt,name=searchable,def=0" json:"searchable,omitempty"` + FtsTokenizationOption *Property_FtsTokenizationOption `protobuf:"varint,8,opt,name=fts_tokenization_option,enum=appengine.Property_FtsTokenizationOption" json:"fts_tokenization_option,omitempty"` + Locale *string `protobuf:"bytes,9,opt,name=locale,def=en" json:"locale,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Property) Reset() { *m = Property{} } +func (m *Property) String() string { return proto.CompactTextString(m) } +func (*Property) ProtoMessage() {} + +const Default_Property_Meaning Property_Meaning = Property_NO_MEANING +const Default_Property_Searchable bool = false +const Default_Property_Locale string = "en" + +func (m *Property) GetMeaning() Property_Meaning { + if m != nil && m.Meaning != nil { + return *m.Meaning + } + return Default_Property_Meaning +} + +func (m *Property) GetMeaningUri() string { + if m != nil && m.MeaningUri != nil { + return *m.MeaningUri + } + return "" +} + +func (m *Property) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *Property) GetValue() *PropertyValue { + if m != nil { + return m.Value + } + return nil +} + +func (m *Property) GetMultiple() bool { + if m != nil && m.Multiple != nil { + return *m.Multiple + } + return false +} + +func (m *Property) GetSearchable() bool { + if m != nil && m.Searchable != nil { + return *m.Searchable + } + return Default_Property_Searchable +} + +func (m *Property) GetFtsTokenizationOption() Property_FtsTokenizationOption { + if m != nil && m.FtsTokenizationOption != nil { + return *m.FtsTokenizationOption + } + return Property_HTML +} + +func (m *Property) GetLocale() string { + if m != nil && m.Locale != nil { + return *m.Locale + } + return Default_Property_Locale +} + +type Path struct { + Element []*Path_Element `protobuf:"group,1,rep,name=Element" json:"element,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Path) Reset() { *m = Path{} } +func (m *Path) String() string { return proto.CompactTextString(m) } +func (*Path) ProtoMessage() {} + +func (m *Path) GetElement() []*Path_Element { + if m != nil { + return m.Element + } + return nil +} + +type Path_Element struct { + Type *string `protobuf:"bytes,2,req,name=type" json:"type,omitempty"` + Id *int64 `protobuf:"varint,3,opt,name=id" json:"id,omitempty"` + Name *string `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Path_Element) Reset() { *m = Path_Element{} } +func (m *Path_Element) String() string { return proto.CompactTextString(m) } +func (*Path_Element) ProtoMessage() {} + +func (m *Path_Element) GetType() string { + if m != nil && m.Type != nil { + return *m.Type + } + return "" +} + +func (m *Path_Element) GetId() int64 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *Path_Element) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type Reference struct { + App *string `protobuf:"bytes,13,req,name=app" json:"app,omitempty"` + NameSpace *string `protobuf:"bytes,20,opt,name=name_space" json:"name_space,omitempty"` + Path *Path `protobuf:"bytes,14,req,name=path" json:"path,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Reference) Reset() { *m = Reference{} } +func (m *Reference) String() string { return proto.CompactTextString(m) } +func (*Reference) ProtoMessage() {} + +func (m *Reference) GetApp() string { + if m != nil && m.App != nil { + return *m.App + } + return "" +} + +func (m *Reference) GetNameSpace() string { + if m != nil && m.NameSpace != nil { + return *m.NameSpace + } + return "" +} + +func (m *Reference) GetPath() *Path { + if m != nil { + return m.Path + } + return nil +} + +type User struct { + Email *string `protobuf:"bytes,1,req,name=email" json:"email,omitempty"` + AuthDomain *string `protobuf:"bytes,2,req,name=auth_domain" json:"auth_domain,omitempty"` + Nickname *string `protobuf:"bytes,3,opt,name=nickname" json:"nickname,omitempty"` + FederatedIdentity *string `protobuf:"bytes,6,opt,name=federated_identity" json:"federated_identity,omitempty"` + FederatedProvider *string `protobuf:"bytes,7,opt,name=federated_provider" json:"federated_provider,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *User) Reset() { *m = User{} } +func (m *User) String() string { return proto.CompactTextString(m) } +func (*User) ProtoMessage() {} + +func (m *User) GetEmail() string { + if m != nil && m.Email != nil { + return *m.Email + } + return "" +} + +func (m *User) GetAuthDomain() string { + if m != nil && m.AuthDomain != nil { + return *m.AuthDomain + } + return "" +} + +func (m *User) GetNickname() string { + if m != nil && m.Nickname != nil { + return *m.Nickname + } + return "" +} + +func (m *User) GetFederatedIdentity() string { + if m != nil && m.FederatedIdentity != nil { + return *m.FederatedIdentity + } + return "" +} + +func (m *User) GetFederatedProvider() string { + if m != nil && m.FederatedProvider != nil { + return *m.FederatedProvider + } + return "" +} + +type EntityProto struct { + Key *Reference `protobuf:"bytes,13,req,name=key" json:"key,omitempty"` + EntityGroup *Path `protobuf:"bytes,16,req,name=entity_group" json:"entity_group,omitempty"` + Owner *User `protobuf:"bytes,17,opt,name=owner" json:"owner,omitempty"` + Kind *EntityProto_Kind `protobuf:"varint,4,opt,name=kind,enum=appengine.EntityProto_Kind" json:"kind,omitempty"` + KindUri *string `protobuf:"bytes,5,opt,name=kind_uri" json:"kind_uri,omitempty"` + Property []*Property `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"` + RawProperty []*Property `protobuf:"bytes,15,rep,name=raw_property" json:"raw_property,omitempty"` + Rank *int32 `protobuf:"varint,18,opt,name=rank" json:"rank,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EntityProto) Reset() { *m = EntityProto{} } +func (m *EntityProto) String() string { return proto.CompactTextString(m) } +func (*EntityProto) ProtoMessage() {} + +func (m *EntityProto) GetKey() *Reference { + if m != nil { + return m.Key + } + return nil +} + +func (m *EntityProto) GetEntityGroup() *Path { + if m != nil { + return m.EntityGroup + } + return nil +} + +func (m *EntityProto) GetOwner() *User { + if m != nil { + return m.Owner + } + return nil +} + +func (m *EntityProto) GetKind() EntityProto_Kind { + if m != nil && m.Kind != nil { + return *m.Kind + } + return EntityProto_GD_CONTACT +} + +func (m *EntityProto) GetKindUri() string { + if m != nil && m.KindUri != nil { + return *m.KindUri + } + return "" +} + +func (m *EntityProto) GetProperty() []*Property { + if m != nil { + return m.Property + } + return nil +} + +func (m *EntityProto) GetRawProperty() []*Property { + if m != nil { + return m.RawProperty + } + return nil +} + +func (m *EntityProto) GetRank() int32 { + if m != nil && m.Rank != nil { + return *m.Rank + } + return 0 +} + +type CompositeProperty struct { + IndexId *int64 `protobuf:"varint,1,req,name=index_id" json:"index_id,omitempty"` + Value []string `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompositeProperty) Reset() { *m = CompositeProperty{} } +func (m *CompositeProperty) String() string { return proto.CompactTextString(m) } +func (*CompositeProperty) ProtoMessage() {} + +func (m *CompositeProperty) GetIndexId() int64 { + if m != nil && m.IndexId != nil { + return *m.IndexId + } + return 0 +} + +func (m *CompositeProperty) GetValue() []string { + if m != nil { + return m.Value + } + return nil +} + +type Index struct { + EntityType *string `protobuf:"bytes,1,req,name=entity_type" json:"entity_type,omitempty"` + Ancestor *bool `protobuf:"varint,5,req,name=ancestor" json:"ancestor,omitempty"` + Property []*Index_Property `protobuf:"group,2,rep,name=Property" json:"property,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Index) Reset() { *m = Index{} } +func (m *Index) String() string { return proto.CompactTextString(m) } +func (*Index) ProtoMessage() {} + +func (m *Index) GetEntityType() string { + if m != nil && m.EntityType != nil { + return *m.EntityType + } + return "" +} + +func (m *Index) GetAncestor() bool { + if m != nil && m.Ancestor != nil { + return *m.Ancestor + } + return false +} + +func (m *Index) GetProperty() []*Index_Property { + if m != nil { + return m.Property + } + return nil +} + +type Index_Property struct { + Name *string `protobuf:"bytes,3,req,name=name" json:"name,omitempty"` + Direction *Index_Property_Direction `protobuf:"varint,4,opt,name=direction,enum=appengine.Index_Property_Direction,def=1" json:"direction,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Index_Property) Reset() { *m = Index_Property{} } +func (m *Index_Property) String() string { return proto.CompactTextString(m) } +func (*Index_Property) ProtoMessage() {} + +const Default_Index_Property_Direction Index_Property_Direction = Index_Property_ASCENDING + +func (m *Index_Property) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *Index_Property) GetDirection() Index_Property_Direction { + if m != nil && m.Direction != nil { + return *m.Direction + } + return Default_Index_Property_Direction +} + +type CompositeIndex struct { + AppId *string `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"` + Id *int64 `protobuf:"varint,2,req,name=id" json:"id,omitempty"` + Definition *Index `protobuf:"bytes,3,req,name=definition" json:"definition,omitempty"` + State *CompositeIndex_State `protobuf:"varint,4,req,name=state,enum=appengine.CompositeIndex_State" json:"state,omitempty"` + OnlyUseIfRequired *bool `protobuf:"varint,6,opt,name=only_use_if_required,def=0" json:"only_use_if_required,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompositeIndex) Reset() { *m = CompositeIndex{} } +func (m *CompositeIndex) String() string { return proto.CompactTextString(m) } +func (*CompositeIndex) ProtoMessage() {} + +const Default_CompositeIndex_OnlyUseIfRequired bool = false + +func (m *CompositeIndex) GetAppId() string { + if m != nil && m.AppId != nil { + return *m.AppId + } + return "" +} + +func (m *CompositeIndex) GetId() int64 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *CompositeIndex) GetDefinition() *Index { + if m != nil { + return m.Definition + } + return nil +} + +func (m *CompositeIndex) GetState() CompositeIndex_State { + if m != nil && m.State != nil { + return *m.State + } + return CompositeIndex_WRITE_ONLY +} + +func (m *CompositeIndex) GetOnlyUseIfRequired() bool { + if m != nil && m.OnlyUseIfRequired != nil { + return *m.OnlyUseIfRequired + } + return Default_CompositeIndex_OnlyUseIfRequired +} + +type IndexPostfix struct { + IndexValue []*IndexPostfix_IndexValue `protobuf:"bytes,1,rep,name=index_value" json:"index_value,omitempty"` + Key *Reference `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"` + Before *bool `protobuf:"varint,3,opt,name=before,def=1" json:"before,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *IndexPostfix) Reset() { *m = IndexPostfix{} } +func (m *IndexPostfix) String() string { return proto.CompactTextString(m) } +func (*IndexPostfix) ProtoMessage() {} + +const Default_IndexPostfix_Before bool = true + +func (m *IndexPostfix) GetIndexValue() []*IndexPostfix_IndexValue { + if m != nil { + return m.IndexValue + } + return nil +} + +func (m *IndexPostfix) GetKey() *Reference { + if m != nil { + return m.Key + } + return nil +} + +func (m *IndexPostfix) GetBefore() bool { + if m != nil && m.Before != nil { + return *m.Before + } + return Default_IndexPostfix_Before +} + +type IndexPostfix_IndexValue struct { + PropertyName *string `protobuf:"bytes,1,req,name=property_name" json:"property_name,omitempty"` + Value *PropertyValue `protobuf:"bytes,2,req,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *IndexPostfix_IndexValue) Reset() { *m = IndexPostfix_IndexValue{} } +func (m *IndexPostfix_IndexValue) String() string { return proto.CompactTextString(m) } +func (*IndexPostfix_IndexValue) ProtoMessage() {} + +func (m *IndexPostfix_IndexValue) GetPropertyName() string { + if m != nil && m.PropertyName != nil { + return *m.PropertyName + } + return "" +} + +func (m *IndexPostfix_IndexValue) GetValue() *PropertyValue { + if m != nil { + return m.Value + } + return nil +} + +type IndexPosition struct { + Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` + Before *bool `protobuf:"varint,2,opt,name=before,def=1" json:"before,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *IndexPosition) Reset() { *m = IndexPosition{} } +func (m *IndexPosition) String() string { return proto.CompactTextString(m) } +func (*IndexPosition) ProtoMessage() {} + +const Default_IndexPosition_Before bool = true + +func (m *IndexPosition) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *IndexPosition) GetBefore() bool { + if m != nil && m.Before != nil { + return *m.Before + } + return Default_IndexPosition_Before +} + +type Snapshot struct { + Ts *int64 `protobuf:"varint,1,req,name=ts" json:"ts,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Snapshot) Reset() { *m = Snapshot{} } +func (m *Snapshot) String() string { return proto.CompactTextString(m) } +func (*Snapshot) ProtoMessage() {} + +func (m *Snapshot) GetTs() int64 { + if m != nil && m.Ts != nil { + return *m.Ts + } + return 0 +} + +type InternalHeader struct { + Qos *string `protobuf:"bytes,1,opt,name=qos" json:"qos,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *InternalHeader) Reset() { *m = InternalHeader{} } +func (m *InternalHeader) String() string { return proto.CompactTextString(m) } +func (*InternalHeader) ProtoMessage() {} + +func (m *InternalHeader) GetQos() string { + if m != nil && m.Qos != nil { + return *m.Qos + } + return "" +} + +type Transaction struct { + Header *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"` + Handle *uint64 `protobuf:"fixed64,1,req,name=handle" json:"handle,omitempty"` + App *string `protobuf:"bytes,2,req,name=app" json:"app,omitempty"` + MarkChanges *bool `protobuf:"varint,3,opt,name=mark_changes,def=0" json:"mark_changes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Transaction) Reset() { *m = Transaction{} } +func (m *Transaction) String() string { return proto.CompactTextString(m) } +func (*Transaction) ProtoMessage() {} + +const Default_Transaction_MarkChanges bool = false + +func (m *Transaction) GetHeader() *InternalHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *Transaction) GetHandle() uint64 { + if m != nil && m.Handle != nil { + return *m.Handle + } + return 0 +} + +func (m *Transaction) GetApp() string { + if m != nil && m.App != nil { + return *m.App + } + return "" +} + +func (m *Transaction) GetMarkChanges() bool { + if m != nil && m.MarkChanges != nil { + return *m.MarkChanges + } + return Default_Transaction_MarkChanges +} + +type Query struct { + Header *InternalHeader `protobuf:"bytes,39,opt,name=header" json:"header,omitempty"` + App *string `protobuf:"bytes,1,req,name=app" json:"app,omitempty"` + NameSpace *string `protobuf:"bytes,29,opt,name=name_space" json:"name_space,omitempty"` + Kind *string `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"` + Ancestor *Reference `protobuf:"bytes,17,opt,name=ancestor" json:"ancestor,omitempty"` + Filter []*Query_Filter `protobuf:"group,4,rep,name=Filter" json:"filter,omitempty"` + SearchQuery *string `protobuf:"bytes,8,opt,name=search_query" json:"search_query,omitempty"` + Order []*Query_Order `protobuf:"group,9,rep,name=Order" json:"order,omitempty"` + Hint *Query_Hint `protobuf:"varint,18,opt,name=hint,enum=appengine.Query_Hint" json:"hint,omitempty"` + Count *int32 `protobuf:"varint,23,opt,name=count" json:"count,omitempty"` + Offset *int32 `protobuf:"varint,12,opt,name=offset,def=0" json:"offset,omitempty"` + Limit *int32 `protobuf:"varint,16,opt,name=limit" json:"limit,omitempty"` + CompiledCursor *CompiledCursor `protobuf:"bytes,30,opt,name=compiled_cursor" json:"compiled_cursor,omitempty"` + EndCompiledCursor *CompiledCursor `protobuf:"bytes,31,opt,name=end_compiled_cursor" json:"end_compiled_cursor,omitempty"` + CompositeIndex []*CompositeIndex `protobuf:"bytes,19,rep,name=composite_index" json:"composite_index,omitempty"` + RequirePerfectPlan *bool `protobuf:"varint,20,opt,name=require_perfect_plan,def=0" json:"require_perfect_plan,omitempty"` + KeysOnly *bool `protobuf:"varint,21,opt,name=keys_only,def=0" json:"keys_only,omitempty"` + Transaction *Transaction `protobuf:"bytes,22,opt,name=transaction" json:"transaction,omitempty"` + Compile *bool `protobuf:"varint,25,opt,name=compile,def=0" json:"compile,omitempty"` + FailoverMs *int64 `protobuf:"varint,26,opt,name=failover_ms" json:"failover_ms,omitempty"` + Strong *bool `protobuf:"varint,32,opt,name=strong" json:"strong,omitempty"` + PropertyName []string `protobuf:"bytes,33,rep,name=property_name" json:"property_name,omitempty"` + GroupByPropertyName []string `protobuf:"bytes,34,rep,name=group_by_property_name" json:"group_by_property_name,omitempty"` + Distinct *bool `protobuf:"varint,24,opt,name=distinct" json:"distinct,omitempty"` + MinSafeTimeSeconds *int64 `protobuf:"varint,35,opt,name=min_safe_time_seconds" json:"min_safe_time_seconds,omitempty"` + SafeReplicaName []string `protobuf:"bytes,36,rep,name=safe_replica_name" json:"safe_replica_name,omitempty"` + PersistOffset *bool `protobuf:"varint,37,opt,name=persist_offset,def=0" json:"persist_offset,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Query) Reset() { *m = Query{} } +func (m *Query) String() string { return proto.CompactTextString(m) } +func (*Query) ProtoMessage() {} + +const Default_Query_Offset int32 = 0 +const Default_Query_RequirePerfectPlan bool = false +const Default_Query_KeysOnly bool = false +const Default_Query_Compile bool = false +const Default_Query_PersistOffset bool = false + +func (m *Query) GetHeader() *InternalHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *Query) GetApp() string { + if m != nil && m.App != nil { + return *m.App + } + return "" +} + +func (m *Query) GetNameSpace() string { + if m != nil && m.NameSpace != nil { + return *m.NameSpace + } + return "" +} + +func (m *Query) GetKind() string { + if m != nil && m.Kind != nil { + return *m.Kind + } + return "" +} + +func (m *Query) GetAncestor() *Reference { + if m != nil { + return m.Ancestor + } + return nil +} + +func (m *Query) GetFilter() []*Query_Filter { + if m != nil { + return m.Filter + } + return nil +} + +func (m *Query) GetSearchQuery() string { + if m != nil && m.SearchQuery != nil { + return *m.SearchQuery + } + return "" +} + +func (m *Query) GetOrder() []*Query_Order { + if m != nil { + return m.Order + } + return nil +} + +func (m *Query) GetHint() Query_Hint { + if m != nil && m.Hint != nil { + return *m.Hint + } + return Query_ORDER_FIRST +} + +func (m *Query) GetCount() int32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *Query) GetOffset() int32 { + if m != nil && m.Offset != nil { + return *m.Offset + } + return Default_Query_Offset +} + +func (m *Query) GetLimit() int32 { + if m != nil && m.Limit != nil { + return *m.Limit + } + return 0 +} + +func (m *Query) GetCompiledCursor() *CompiledCursor { + if m != nil { + return m.CompiledCursor + } + return nil +} + +func (m *Query) GetEndCompiledCursor() *CompiledCursor { + if m != nil { + return m.EndCompiledCursor + } + return nil +} + +func (m *Query) GetCompositeIndex() []*CompositeIndex { + if m != nil { + return m.CompositeIndex + } + return nil +} + +func (m *Query) GetRequirePerfectPlan() bool { + if m != nil && m.RequirePerfectPlan != nil { + return *m.RequirePerfectPlan + } + return Default_Query_RequirePerfectPlan +} + +func (m *Query) GetKeysOnly() bool { + if m != nil && m.KeysOnly != nil { + return *m.KeysOnly + } + return Default_Query_KeysOnly +} + +func (m *Query) GetTransaction() *Transaction { + if m != nil { + return m.Transaction + } + return nil +} + +func (m *Query) GetCompile() bool { + if m != nil && m.Compile != nil { + return *m.Compile + } + return Default_Query_Compile +} + +func (m *Query) GetFailoverMs() int64 { + if m != nil && m.FailoverMs != nil { + return *m.FailoverMs + } + return 0 +} + +func (m *Query) GetStrong() bool { + if m != nil && m.Strong != nil { + return *m.Strong + } + return false +} + +func (m *Query) GetPropertyName() []string { + if m != nil { + return m.PropertyName + } + return nil +} + +func (m *Query) GetGroupByPropertyName() []string { + if m != nil { + return m.GroupByPropertyName + } + return nil +} + +func (m *Query) GetDistinct() bool { + if m != nil && m.Distinct != nil { + return *m.Distinct + } + return false +} + +func (m *Query) GetMinSafeTimeSeconds() int64 { + if m != nil && m.MinSafeTimeSeconds != nil { + return *m.MinSafeTimeSeconds + } + return 0 +} + +func (m *Query) GetSafeReplicaName() []string { + if m != nil { + return m.SafeReplicaName + } + return nil +} + +func (m *Query) GetPersistOffset() bool { + if m != nil && m.PersistOffset != nil { + return *m.PersistOffset + } + return Default_Query_PersistOffset +} + +type Query_Filter struct { + Op *Query_Filter_Operator `protobuf:"varint,6,req,name=op,enum=appengine.Query_Filter_Operator" json:"op,omitempty"` + Property []*Property `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Query_Filter) Reset() { *m = Query_Filter{} } +func (m *Query_Filter) String() string { return proto.CompactTextString(m) } +func (*Query_Filter) ProtoMessage() {} + +func (m *Query_Filter) GetOp() Query_Filter_Operator { + if m != nil && m.Op != nil { + return *m.Op + } + return Query_Filter_LESS_THAN +} + +func (m *Query_Filter) GetProperty() []*Property { + if m != nil { + return m.Property + } + return nil +} + +type Query_Order struct { + Property *string `protobuf:"bytes,10,req,name=property" json:"property,omitempty"` + Direction *Query_Order_Direction `protobuf:"varint,11,opt,name=direction,enum=appengine.Query_Order_Direction,def=1" json:"direction,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Query_Order) Reset() { *m = Query_Order{} } +func (m *Query_Order) String() string { return proto.CompactTextString(m) } +func (*Query_Order) ProtoMessage() {} + +const Default_Query_Order_Direction Query_Order_Direction = Query_Order_ASCENDING + +func (m *Query_Order) GetProperty() string { + if m != nil && m.Property != nil { + return *m.Property + } + return "" +} + +func (m *Query_Order) GetDirection() Query_Order_Direction { + if m != nil && m.Direction != nil { + return *m.Direction + } + return Default_Query_Order_Direction +} + +type CompiledQuery struct { + Primaryscan *CompiledQuery_PrimaryScan `protobuf:"group,1,req,name=PrimaryScan" json:"primaryscan,omitempty"` + Mergejoinscan []*CompiledQuery_MergeJoinScan `protobuf:"group,7,rep,name=MergeJoinScan" json:"mergejoinscan,omitempty"` + IndexDef *Index `protobuf:"bytes,21,opt,name=index_def" json:"index_def,omitempty"` + Offset *int32 `protobuf:"varint,10,opt,name=offset,def=0" json:"offset,omitempty"` + Limit *int32 `protobuf:"varint,11,opt,name=limit" json:"limit,omitempty"` + KeysOnly *bool `protobuf:"varint,12,req,name=keys_only" json:"keys_only,omitempty"` + PropertyName []string `protobuf:"bytes,24,rep,name=property_name" json:"property_name,omitempty"` + DistinctInfixSize *int32 `protobuf:"varint,25,opt,name=distinct_infix_size" json:"distinct_infix_size,omitempty"` + Entityfilter *CompiledQuery_EntityFilter `protobuf:"group,13,opt,name=EntityFilter" json:"entityfilter,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompiledQuery) Reset() { *m = CompiledQuery{} } +func (m *CompiledQuery) String() string { return proto.CompactTextString(m) } +func (*CompiledQuery) ProtoMessage() {} + +const Default_CompiledQuery_Offset int32 = 0 + +func (m *CompiledQuery) GetPrimaryscan() *CompiledQuery_PrimaryScan { + if m != nil { + return m.Primaryscan + } + return nil +} + +func (m *CompiledQuery) GetMergejoinscan() []*CompiledQuery_MergeJoinScan { + if m != nil { + return m.Mergejoinscan + } + return nil +} + +func (m *CompiledQuery) GetIndexDef() *Index { + if m != nil { + return m.IndexDef + } + return nil +} + +func (m *CompiledQuery) GetOffset() int32 { + if m != nil && m.Offset != nil { + return *m.Offset + } + return Default_CompiledQuery_Offset +} + +func (m *CompiledQuery) GetLimit() int32 { + if m != nil && m.Limit != nil { + return *m.Limit + } + return 0 +} + +func (m *CompiledQuery) GetKeysOnly() bool { + if m != nil && m.KeysOnly != nil { + return *m.KeysOnly + } + return false +} + +func (m *CompiledQuery) GetPropertyName() []string { + if m != nil { + return m.PropertyName + } + return nil +} + +func (m *CompiledQuery) GetDistinctInfixSize() int32 { + if m != nil && m.DistinctInfixSize != nil { + return *m.DistinctInfixSize + } + return 0 +} + +func (m *CompiledQuery) GetEntityfilter() *CompiledQuery_EntityFilter { + if m != nil { + return m.Entityfilter + } + return nil +} + +type CompiledQuery_PrimaryScan struct { + IndexName *string `protobuf:"bytes,2,opt,name=index_name" json:"index_name,omitempty"` + StartKey *string `protobuf:"bytes,3,opt,name=start_key" json:"start_key,omitempty"` + StartInclusive *bool `protobuf:"varint,4,opt,name=start_inclusive" json:"start_inclusive,omitempty"` + EndKey *string `protobuf:"bytes,5,opt,name=end_key" json:"end_key,omitempty"` + EndInclusive *bool `protobuf:"varint,6,opt,name=end_inclusive" json:"end_inclusive,omitempty"` + StartPostfixValue []string `protobuf:"bytes,22,rep,name=start_postfix_value" json:"start_postfix_value,omitempty"` + EndPostfixValue []string `protobuf:"bytes,23,rep,name=end_postfix_value" json:"end_postfix_value,omitempty"` + EndUnappliedLogTimestampUs *int64 `protobuf:"varint,19,opt,name=end_unapplied_log_timestamp_us" json:"end_unapplied_log_timestamp_us,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompiledQuery_PrimaryScan) Reset() { *m = CompiledQuery_PrimaryScan{} } +func (m *CompiledQuery_PrimaryScan) String() string { return proto.CompactTextString(m) } +func (*CompiledQuery_PrimaryScan) ProtoMessage() {} + +func (m *CompiledQuery_PrimaryScan) GetIndexName() string { + if m != nil && m.IndexName != nil { + return *m.IndexName + } + return "" +} + +func (m *CompiledQuery_PrimaryScan) GetStartKey() string { + if m != nil && m.StartKey != nil { + return *m.StartKey + } + return "" +} + +func (m *CompiledQuery_PrimaryScan) GetStartInclusive() bool { + if m != nil && m.StartInclusive != nil { + return *m.StartInclusive + } + return false +} + +func (m *CompiledQuery_PrimaryScan) GetEndKey() string { + if m != nil && m.EndKey != nil { + return *m.EndKey + } + return "" +} + +func (m *CompiledQuery_PrimaryScan) GetEndInclusive() bool { + if m != nil && m.EndInclusive != nil { + return *m.EndInclusive + } + return false +} + +func (m *CompiledQuery_PrimaryScan) GetStartPostfixValue() []string { + if m != nil { + return m.StartPostfixValue + } + return nil +} + +func (m *CompiledQuery_PrimaryScan) GetEndPostfixValue() []string { + if m != nil { + return m.EndPostfixValue + } + return nil +} + +func (m *CompiledQuery_PrimaryScan) GetEndUnappliedLogTimestampUs() int64 { + if m != nil && m.EndUnappliedLogTimestampUs != nil { + return *m.EndUnappliedLogTimestampUs + } + return 0 +} + +type CompiledQuery_MergeJoinScan struct { + IndexName *string `protobuf:"bytes,8,req,name=index_name" json:"index_name,omitempty"` + PrefixValue []string `protobuf:"bytes,9,rep,name=prefix_value" json:"prefix_value,omitempty"` + ValuePrefix *bool `protobuf:"varint,20,opt,name=value_prefix,def=0" json:"value_prefix,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompiledQuery_MergeJoinScan) Reset() { *m = CompiledQuery_MergeJoinScan{} } +func (m *CompiledQuery_MergeJoinScan) String() string { return proto.CompactTextString(m) } +func (*CompiledQuery_MergeJoinScan) ProtoMessage() {} + +const Default_CompiledQuery_MergeJoinScan_ValuePrefix bool = false + +func (m *CompiledQuery_MergeJoinScan) GetIndexName() string { + if m != nil && m.IndexName != nil { + return *m.IndexName + } + return "" +} + +func (m *CompiledQuery_MergeJoinScan) GetPrefixValue() []string { + if m != nil { + return m.PrefixValue + } + return nil +} + +func (m *CompiledQuery_MergeJoinScan) GetValuePrefix() bool { + if m != nil && m.ValuePrefix != nil { + return *m.ValuePrefix + } + return Default_CompiledQuery_MergeJoinScan_ValuePrefix +} + +type CompiledQuery_EntityFilter struct { + Distinct *bool `protobuf:"varint,14,opt,name=distinct,def=0" json:"distinct,omitempty"` + Kind *string `protobuf:"bytes,17,opt,name=kind" json:"kind,omitempty"` + Ancestor *Reference `protobuf:"bytes,18,opt,name=ancestor" json:"ancestor,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompiledQuery_EntityFilter) Reset() { *m = CompiledQuery_EntityFilter{} } +func (m *CompiledQuery_EntityFilter) String() string { return proto.CompactTextString(m) } +func (*CompiledQuery_EntityFilter) ProtoMessage() {} + +const Default_CompiledQuery_EntityFilter_Distinct bool = false + +func (m *CompiledQuery_EntityFilter) GetDistinct() bool { + if m != nil && m.Distinct != nil { + return *m.Distinct + } + return Default_CompiledQuery_EntityFilter_Distinct +} + +func (m *CompiledQuery_EntityFilter) GetKind() string { + if m != nil && m.Kind != nil { + return *m.Kind + } + return "" +} + +func (m *CompiledQuery_EntityFilter) GetAncestor() *Reference { + if m != nil { + return m.Ancestor + } + return nil +} + +type CompiledCursor struct { + Position *CompiledCursor_Position `protobuf:"group,2,opt,name=Position" json:"position,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompiledCursor) Reset() { *m = CompiledCursor{} } +func (m *CompiledCursor) String() string { return proto.CompactTextString(m) } +func (*CompiledCursor) ProtoMessage() {} + +func (m *CompiledCursor) GetPosition() *CompiledCursor_Position { + if m != nil { + return m.Position + } + return nil +} + +type CompiledCursor_Position struct { + StartKey *string `protobuf:"bytes,27,opt,name=start_key" json:"start_key,omitempty"` + Indexvalue []*CompiledCursor_Position_IndexValue `protobuf:"group,29,rep,name=IndexValue" json:"indexvalue,omitempty"` + Key *Reference `protobuf:"bytes,32,opt,name=key" json:"key,omitempty"` + StartInclusive *bool `protobuf:"varint,28,opt,name=start_inclusive,def=1" json:"start_inclusive,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompiledCursor_Position) Reset() { *m = CompiledCursor_Position{} } +func (m *CompiledCursor_Position) String() string { return proto.CompactTextString(m) } +func (*CompiledCursor_Position) ProtoMessage() {} + +const Default_CompiledCursor_Position_StartInclusive bool = true + +func (m *CompiledCursor_Position) GetStartKey() string { + if m != nil && m.StartKey != nil { + return *m.StartKey + } + return "" +} + +func (m *CompiledCursor_Position) GetIndexvalue() []*CompiledCursor_Position_IndexValue { + if m != nil { + return m.Indexvalue + } + return nil +} + +func (m *CompiledCursor_Position) GetKey() *Reference { + if m != nil { + return m.Key + } + return nil +} + +func (m *CompiledCursor_Position) GetStartInclusive() bool { + if m != nil && m.StartInclusive != nil { + return *m.StartInclusive + } + return Default_CompiledCursor_Position_StartInclusive +} + +type CompiledCursor_Position_IndexValue struct { + Property *string `protobuf:"bytes,30,opt,name=property" json:"property,omitempty"` + Value *PropertyValue `protobuf:"bytes,31,req,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompiledCursor_Position_IndexValue) Reset() { *m = CompiledCursor_Position_IndexValue{} } +func (m *CompiledCursor_Position_IndexValue) String() string { return proto.CompactTextString(m) } +func (*CompiledCursor_Position_IndexValue) ProtoMessage() {} + +func (m *CompiledCursor_Position_IndexValue) GetProperty() string { + if m != nil && m.Property != nil { + return *m.Property + } + return "" +} + +func (m *CompiledCursor_Position_IndexValue) GetValue() *PropertyValue { + if m != nil { + return m.Value + } + return nil +} + +type Cursor struct { + Cursor *uint64 `protobuf:"fixed64,1,req,name=cursor" json:"cursor,omitempty"` + App *string `protobuf:"bytes,2,opt,name=app" json:"app,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Cursor) Reset() { *m = Cursor{} } +func (m *Cursor) String() string { return proto.CompactTextString(m) } +func (*Cursor) ProtoMessage() {} + +func (m *Cursor) GetCursor() uint64 { + if m != nil && m.Cursor != nil { + return *m.Cursor + } + return 0 +} + +func (m *Cursor) GetApp() string { + if m != nil && m.App != nil { + return *m.App + } + return "" +} + +type Error struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Error) Reset() { *m = Error{} } +func (m *Error) String() string { return proto.CompactTextString(m) } +func (*Error) ProtoMessage() {} + +type Cost struct { + IndexWrites *int32 `protobuf:"varint,1,opt,name=index_writes" json:"index_writes,omitempty"` + IndexWriteBytes *int32 `protobuf:"varint,2,opt,name=index_write_bytes" json:"index_write_bytes,omitempty"` + EntityWrites *int32 `protobuf:"varint,3,opt,name=entity_writes" json:"entity_writes,omitempty"` + EntityWriteBytes *int32 `protobuf:"varint,4,opt,name=entity_write_bytes" json:"entity_write_bytes,omitempty"` + Commitcost *Cost_CommitCost `protobuf:"group,5,opt,name=CommitCost" json:"commitcost,omitempty"` + ApproximateStorageDelta *int32 `protobuf:"varint,8,opt,name=approximate_storage_delta" json:"approximate_storage_delta,omitempty"` + IdSequenceUpdates *int32 `protobuf:"varint,9,opt,name=id_sequence_updates" json:"id_sequence_updates,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Cost) Reset() { *m = Cost{} } +func (m *Cost) String() string { return proto.CompactTextString(m) } +func (*Cost) ProtoMessage() {} + +func (m *Cost) GetIndexWrites() int32 { + if m != nil && m.IndexWrites != nil { + return *m.IndexWrites + } + return 0 +} + +func (m *Cost) GetIndexWriteBytes() int32 { + if m != nil && m.IndexWriteBytes != nil { + return *m.IndexWriteBytes + } + return 0 +} + +func (m *Cost) GetEntityWrites() int32 { + if m != nil && m.EntityWrites != nil { + return *m.EntityWrites + } + return 0 +} + +func (m *Cost) GetEntityWriteBytes() int32 { + if m != nil && m.EntityWriteBytes != nil { + return *m.EntityWriteBytes + } + return 0 +} + +func (m *Cost) GetCommitcost() *Cost_CommitCost { + if m != nil { + return m.Commitcost + } + return nil +} + +func (m *Cost) GetApproximateStorageDelta() int32 { + if m != nil && m.ApproximateStorageDelta != nil { + return *m.ApproximateStorageDelta + } + return 0 +} + +func (m *Cost) GetIdSequenceUpdates() int32 { + if m != nil && m.IdSequenceUpdates != nil { + return *m.IdSequenceUpdates + } + return 0 +} + +type Cost_CommitCost struct { + RequestedEntityPuts *int32 `protobuf:"varint,6,opt,name=requested_entity_puts" json:"requested_entity_puts,omitempty"` + RequestedEntityDeletes *int32 `protobuf:"varint,7,opt,name=requested_entity_deletes" json:"requested_entity_deletes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Cost_CommitCost) Reset() { *m = Cost_CommitCost{} } +func (m *Cost_CommitCost) String() string { return proto.CompactTextString(m) } +func (*Cost_CommitCost) ProtoMessage() {} + +func (m *Cost_CommitCost) GetRequestedEntityPuts() int32 { + if m != nil && m.RequestedEntityPuts != nil { + return *m.RequestedEntityPuts + } + return 0 +} + +func (m *Cost_CommitCost) GetRequestedEntityDeletes() int32 { + if m != nil && m.RequestedEntityDeletes != nil { + return *m.RequestedEntityDeletes + } + return 0 +} + +type GetRequest struct { + Header *InternalHeader `protobuf:"bytes,6,opt,name=header" json:"header,omitempty"` + Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"` + Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"` + FailoverMs *int64 `protobuf:"varint,3,opt,name=failover_ms" json:"failover_ms,omitempty"` + Strong *bool `protobuf:"varint,4,opt,name=strong" json:"strong,omitempty"` + AllowDeferred *bool `protobuf:"varint,5,opt,name=allow_deferred,def=0" json:"allow_deferred,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetRequest) Reset() { *m = GetRequest{} } +func (m *GetRequest) String() string { return proto.CompactTextString(m) } +func (*GetRequest) ProtoMessage() {} + +const Default_GetRequest_AllowDeferred bool = false + +func (m *GetRequest) GetHeader() *InternalHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *GetRequest) GetKey() []*Reference { + if m != nil { + return m.Key + } + return nil +} + +func (m *GetRequest) GetTransaction() *Transaction { + if m != nil { + return m.Transaction + } + return nil +} + +func (m *GetRequest) GetFailoverMs() int64 { + if m != nil && m.FailoverMs != nil { + return *m.FailoverMs + } + return 0 +} + +func (m *GetRequest) GetStrong() bool { + if m != nil && m.Strong != nil { + return *m.Strong + } + return false +} + +func (m *GetRequest) GetAllowDeferred() bool { + if m != nil && m.AllowDeferred != nil { + return *m.AllowDeferred + } + return Default_GetRequest_AllowDeferred +} + +type GetResponse struct { + Entity []*GetResponse_Entity `protobuf:"group,1,rep,name=Entity" json:"entity,omitempty"` + Deferred []*Reference `protobuf:"bytes,5,rep,name=deferred" json:"deferred,omitempty"` + InOrder *bool `protobuf:"varint,6,opt,name=in_order,def=1" json:"in_order,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetResponse) Reset() { *m = GetResponse{} } +func (m *GetResponse) String() string { return proto.CompactTextString(m) } +func (*GetResponse) ProtoMessage() {} + +const Default_GetResponse_InOrder bool = true + +func (m *GetResponse) GetEntity() []*GetResponse_Entity { + if m != nil { + return m.Entity + } + return nil +} + +func (m *GetResponse) GetDeferred() []*Reference { + if m != nil { + return m.Deferred + } + return nil +} + +func (m *GetResponse) GetInOrder() bool { + if m != nil && m.InOrder != nil { + return *m.InOrder + } + return Default_GetResponse_InOrder +} + +type GetResponse_Entity struct { + Entity *EntityProto `protobuf:"bytes,2,opt,name=entity" json:"entity,omitempty"` + Key *Reference `protobuf:"bytes,4,opt,name=key" json:"key,omitempty"` + Version *int64 `protobuf:"varint,3,opt,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetResponse_Entity) Reset() { *m = GetResponse_Entity{} } +func (m *GetResponse_Entity) String() string { return proto.CompactTextString(m) } +func (*GetResponse_Entity) ProtoMessage() {} + +func (m *GetResponse_Entity) GetEntity() *EntityProto { + if m != nil { + return m.Entity + } + return nil +} + +func (m *GetResponse_Entity) GetKey() *Reference { + if m != nil { + return m.Key + } + return nil +} + +func (m *GetResponse_Entity) GetVersion() int64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +type PutRequest struct { + Header *InternalHeader `protobuf:"bytes,11,opt,name=header" json:"header,omitempty"` + Entity []*EntityProto `protobuf:"bytes,1,rep,name=entity" json:"entity,omitempty"` + Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"` + CompositeIndex []*CompositeIndex `protobuf:"bytes,3,rep,name=composite_index" json:"composite_index,omitempty"` + Trusted *bool `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"` + Force *bool `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"` + MarkChanges *bool `protobuf:"varint,8,opt,name=mark_changes,def=0" json:"mark_changes,omitempty"` + Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"` + AutoIdPolicy *PutRequest_AutoIdPolicy `protobuf:"varint,10,opt,name=auto_id_policy,enum=appengine.PutRequest_AutoIdPolicy,def=0" json:"auto_id_policy,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PutRequest) Reset() { *m = PutRequest{} } +func (m *PutRequest) String() string { return proto.CompactTextString(m) } +func (*PutRequest) ProtoMessage() {} + +const Default_PutRequest_Trusted bool = false +const Default_PutRequest_Force bool = false +const Default_PutRequest_MarkChanges bool = false +const Default_PutRequest_AutoIdPolicy PutRequest_AutoIdPolicy = PutRequest_CURRENT + +func (m *PutRequest) GetHeader() *InternalHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *PutRequest) GetEntity() []*EntityProto { + if m != nil { + return m.Entity + } + return nil +} + +func (m *PutRequest) GetTransaction() *Transaction { + if m != nil { + return m.Transaction + } + return nil +} + +func (m *PutRequest) GetCompositeIndex() []*CompositeIndex { + if m != nil { + return m.CompositeIndex + } + return nil +} + +func (m *PutRequest) GetTrusted() bool { + if m != nil && m.Trusted != nil { + return *m.Trusted + } + return Default_PutRequest_Trusted +} + +func (m *PutRequest) GetForce() bool { + if m != nil && m.Force != nil { + return *m.Force + } + return Default_PutRequest_Force +} + +func (m *PutRequest) GetMarkChanges() bool { + if m != nil && m.MarkChanges != nil { + return *m.MarkChanges + } + return Default_PutRequest_MarkChanges +} + +func (m *PutRequest) GetSnapshot() []*Snapshot { + if m != nil { + return m.Snapshot + } + return nil +} + +func (m *PutRequest) GetAutoIdPolicy() PutRequest_AutoIdPolicy { + if m != nil && m.AutoIdPolicy != nil { + return *m.AutoIdPolicy + } + return Default_PutRequest_AutoIdPolicy +} + +type PutResponse struct { + Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"` + Cost *Cost `protobuf:"bytes,2,opt,name=cost" json:"cost,omitempty"` + Version []int64 `protobuf:"varint,3,rep,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PutResponse) Reset() { *m = PutResponse{} } +func (m *PutResponse) String() string { return proto.CompactTextString(m) } +func (*PutResponse) ProtoMessage() {} + +func (m *PutResponse) GetKey() []*Reference { + if m != nil { + return m.Key + } + return nil +} + +func (m *PutResponse) GetCost() *Cost { + if m != nil { + return m.Cost + } + return nil +} + +func (m *PutResponse) GetVersion() []int64 { + if m != nil { + return m.Version + } + return nil +} + +type TouchRequest struct { + Header *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"` + Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"` + CompositeIndex []*CompositeIndex `protobuf:"bytes,2,rep,name=composite_index" json:"composite_index,omitempty"` + Force *bool `protobuf:"varint,3,opt,name=force,def=0" json:"force,omitempty"` + Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TouchRequest) Reset() { *m = TouchRequest{} } +func (m *TouchRequest) String() string { return proto.CompactTextString(m) } +func (*TouchRequest) ProtoMessage() {} + +const Default_TouchRequest_Force bool = false + +func (m *TouchRequest) GetHeader() *InternalHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *TouchRequest) GetKey() []*Reference { + if m != nil { + return m.Key + } + return nil +} + +func (m *TouchRequest) GetCompositeIndex() []*CompositeIndex { + if m != nil { + return m.CompositeIndex + } + return nil +} + +func (m *TouchRequest) GetForce() bool { + if m != nil && m.Force != nil { + return *m.Force + } + return Default_TouchRequest_Force +} + +func (m *TouchRequest) GetSnapshot() []*Snapshot { + if m != nil { + return m.Snapshot + } + return nil +} + +type TouchResponse struct { + Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TouchResponse) Reset() { *m = TouchResponse{} } +func (m *TouchResponse) String() string { return proto.CompactTextString(m) } +func (*TouchResponse) ProtoMessage() {} + +func (m *TouchResponse) GetCost() *Cost { + if m != nil { + return m.Cost + } + return nil +} + +type DeleteRequest struct { + Header *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"` + Key []*Reference `protobuf:"bytes,6,rep,name=key" json:"key,omitempty"` + Transaction *Transaction `protobuf:"bytes,5,opt,name=transaction" json:"transaction,omitempty"` + Trusted *bool `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"` + Force *bool `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"` + MarkChanges *bool `protobuf:"varint,8,opt,name=mark_changes,def=0" json:"mark_changes,omitempty"` + Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeleteRequest) Reset() { *m = DeleteRequest{} } +func (m *DeleteRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteRequest) ProtoMessage() {} + +const Default_DeleteRequest_Trusted bool = false +const Default_DeleteRequest_Force bool = false +const Default_DeleteRequest_MarkChanges bool = false + +func (m *DeleteRequest) GetHeader() *InternalHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *DeleteRequest) GetKey() []*Reference { + if m != nil { + return m.Key + } + return nil +} + +func (m *DeleteRequest) GetTransaction() *Transaction { + if m != nil { + return m.Transaction + } + return nil +} + +func (m *DeleteRequest) GetTrusted() bool { + if m != nil && m.Trusted != nil { + return *m.Trusted + } + return Default_DeleteRequest_Trusted +} + +func (m *DeleteRequest) GetForce() bool { + if m != nil && m.Force != nil { + return *m.Force + } + return Default_DeleteRequest_Force +} + +func (m *DeleteRequest) GetMarkChanges() bool { + if m != nil && m.MarkChanges != nil { + return *m.MarkChanges + } + return Default_DeleteRequest_MarkChanges +} + +func (m *DeleteRequest) GetSnapshot() []*Snapshot { + if m != nil { + return m.Snapshot + } + return nil +} + +type DeleteResponse struct { + Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"` + Version []int64 `protobuf:"varint,3,rep,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeleteResponse) Reset() { *m = DeleteResponse{} } +func (m *DeleteResponse) String() string { return proto.CompactTextString(m) } +func (*DeleteResponse) ProtoMessage() {} + +func (m *DeleteResponse) GetCost() *Cost { + if m != nil { + return m.Cost + } + return nil +} + +func (m *DeleteResponse) GetVersion() []int64 { + if m != nil { + return m.Version + } + return nil +} + +type NextRequest struct { + Header *InternalHeader `protobuf:"bytes,5,opt,name=header" json:"header,omitempty"` + Cursor *Cursor `protobuf:"bytes,1,req,name=cursor" json:"cursor,omitempty"` + Count *int32 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"` + Offset *int32 `protobuf:"varint,4,opt,name=offset,def=0" json:"offset,omitempty"` + Compile *bool `protobuf:"varint,3,opt,name=compile,def=0" json:"compile,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NextRequest) Reset() { *m = NextRequest{} } +func (m *NextRequest) String() string { return proto.CompactTextString(m) } +func (*NextRequest) ProtoMessage() {} + +const Default_NextRequest_Offset int32 = 0 +const Default_NextRequest_Compile bool = false + +func (m *NextRequest) GetHeader() *InternalHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *NextRequest) GetCursor() *Cursor { + if m != nil { + return m.Cursor + } + return nil +} + +func (m *NextRequest) GetCount() int32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *NextRequest) GetOffset() int32 { + if m != nil && m.Offset != nil { + return *m.Offset + } + return Default_NextRequest_Offset +} + +func (m *NextRequest) GetCompile() bool { + if m != nil && m.Compile != nil { + return *m.Compile + } + return Default_NextRequest_Compile +} + +type QueryResult struct { + Cursor *Cursor `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"` + Result []*EntityProto `protobuf:"bytes,2,rep,name=result" json:"result,omitempty"` + SkippedResults *int32 `protobuf:"varint,7,opt,name=skipped_results" json:"skipped_results,omitempty"` + MoreResults *bool `protobuf:"varint,3,req,name=more_results" json:"more_results,omitempty"` + KeysOnly *bool `protobuf:"varint,4,opt,name=keys_only" json:"keys_only,omitempty"` + IndexOnly *bool `protobuf:"varint,9,opt,name=index_only" json:"index_only,omitempty"` + SmallOps *bool `protobuf:"varint,10,opt,name=small_ops" json:"small_ops,omitempty"` + CompiledQuery *CompiledQuery `protobuf:"bytes,5,opt,name=compiled_query" json:"compiled_query,omitempty"` + CompiledCursor *CompiledCursor `protobuf:"bytes,6,opt,name=compiled_cursor" json:"compiled_cursor,omitempty"` + Index []*CompositeIndex `protobuf:"bytes,8,rep,name=index" json:"index,omitempty"` + Version []int64 `protobuf:"varint,11,rep,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *QueryResult) Reset() { *m = QueryResult{} } +func (m *QueryResult) String() string { return proto.CompactTextString(m) } +func (*QueryResult) ProtoMessage() {} + +func (m *QueryResult) GetCursor() *Cursor { + if m != nil { + return m.Cursor + } + return nil +} + +func (m *QueryResult) GetResult() []*EntityProto { + if m != nil { + return m.Result + } + return nil +} + +func (m *QueryResult) GetSkippedResults() int32 { + if m != nil && m.SkippedResults != nil { + return *m.SkippedResults + } + return 0 +} + +func (m *QueryResult) GetMoreResults() bool { + if m != nil && m.MoreResults != nil { + return *m.MoreResults + } + return false +} + +func (m *QueryResult) GetKeysOnly() bool { + if m != nil && m.KeysOnly != nil { + return *m.KeysOnly + } + return false +} + +func (m *QueryResult) GetIndexOnly() bool { + if m != nil && m.IndexOnly != nil { + return *m.IndexOnly + } + return false +} + +func (m *QueryResult) GetSmallOps() bool { + if m != nil && m.SmallOps != nil { + return *m.SmallOps + } + return false +} + +func (m *QueryResult) GetCompiledQuery() *CompiledQuery { + if m != nil { + return m.CompiledQuery + } + return nil +} + +func (m *QueryResult) GetCompiledCursor() *CompiledCursor { + if m != nil { + return m.CompiledCursor + } + return nil +} + +func (m *QueryResult) GetIndex() []*CompositeIndex { + if m != nil { + return m.Index + } + return nil +} + +func (m *QueryResult) GetVersion() []int64 { + if m != nil { + return m.Version + } + return nil +} + +type AllocateIdsRequest struct { + Header *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"` + ModelKey *Reference `protobuf:"bytes,1,opt,name=model_key" json:"model_key,omitempty"` + Size *int64 `protobuf:"varint,2,opt,name=size" json:"size,omitempty"` + Max *int64 `protobuf:"varint,3,opt,name=max" json:"max,omitempty"` + Reserve []*Reference `protobuf:"bytes,5,rep,name=reserve" json:"reserve,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllocateIdsRequest) Reset() { *m = AllocateIdsRequest{} } +func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) } +func (*AllocateIdsRequest) ProtoMessage() {} + +func (m *AllocateIdsRequest) GetHeader() *InternalHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *AllocateIdsRequest) GetModelKey() *Reference { + if m != nil { + return m.ModelKey + } + return nil +} + +func (m *AllocateIdsRequest) GetSize() int64 { + if m != nil && m.Size != nil { + return *m.Size + } + return 0 +} + +func (m *AllocateIdsRequest) GetMax() int64 { + if m != nil && m.Max != nil { + return *m.Max + } + return 0 +} + +func (m *AllocateIdsRequest) GetReserve() []*Reference { + if m != nil { + return m.Reserve + } + return nil +} + +type AllocateIdsResponse struct { + Start *int64 `protobuf:"varint,1,req,name=start" json:"start,omitempty"` + End *int64 `protobuf:"varint,2,req,name=end" json:"end,omitempty"` + Cost *Cost `protobuf:"bytes,3,opt,name=cost" json:"cost,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllocateIdsResponse) Reset() { *m = AllocateIdsResponse{} } +func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) } +func (*AllocateIdsResponse) ProtoMessage() {} + +func (m *AllocateIdsResponse) GetStart() int64 { + if m != nil && m.Start != nil { + return *m.Start + } + return 0 +} + +func (m *AllocateIdsResponse) GetEnd() int64 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +func (m *AllocateIdsResponse) GetCost() *Cost { + if m != nil { + return m.Cost + } + return nil +} + +type CompositeIndices struct { + Index []*CompositeIndex `protobuf:"bytes,1,rep,name=index" json:"index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompositeIndices) Reset() { *m = CompositeIndices{} } +func (m *CompositeIndices) String() string { return proto.CompactTextString(m) } +func (*CompositeIndices) ProtoMessage() {} + +func (m *CompositeIndices) GetIndex() []*CompositeIndex { + if m != nil { + return m.Index + } + return nil +} + +type AddActionsRequest struct { + Header *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"` + Transaction *Transaction `protobuf:"bytes,1,req,name=transaction" json:"transaction,omitempty"` + Action []*Action `protobuf:"bytes,2,rep,name=action" json:"action,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AddActionsRequest) Reset() { *m = AddActionsRequest{} } +func (m *AddActionsRequest) String() string { return proto.CompactTextString(m) } +func (*AddActionsRequest) ProtoMessage() {} + +func (m *AddActionsRequest) GetHeader() *InternalHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *AddActionsRequest) GetTransaction() *Transaction { + if m != nil { + return m.Transaction + } + return nil +} + +func (m *AddActionsRequest) GetAction() []*Action { + if m != nil { + return m.Action + } + return nil +} + +type AddActionsResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *AddActionsResponse) Reset() { *m = AddActionsResponse{} } +func (m *AddActionsResponse) String() string { return proto.CompactTextString(m) } +func (*AddActionsResponse) ProtoMessage() {} + +type BeginTransactionRequest struct { + Header *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"` + App *string `protobuf:"bytes,1,req,name=app" json:"app,omitempty"` + AllowMultipleEg *bool `protobuf:"varint,2,opt,name=allow_multiple_eg,def=0" json:"allow_multiple_eg,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BeginTransactionRequest) Reset() { *m = BeginTransactionRequest{} } +func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) } +func (*BeginTransactionRequest) ProtoMessage() {} + +const Default_BeginTransactionRequest_AllowMultipleEg bool = false + +func (m *BeginTransactionRequest) GetHeader() *InternalHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *BeginTransactionRequest) GetApp() string { + if m != nil && m.App != nil { + return *m.App + } + return "" +} + +func (m *BeginTransactionRequest) GetAllowMultipleEg() bool { + if m != nil && m.AllowMultipleEg != nil { + return *m.AllowMultipleEg + } + return Default_BeginTransactionRequest_AllowMultipleEg +} + +type CommitResponse struct { + Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"` + Version []*CommitResponse_Version `protobuf:"group,3,rep,name=Version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CommitResponse) Reset() { *m = CommitResponse{} } +func (m *CommitResponse) String() string { return proto.CompactTextString(m) } +func (*CommitResponse) ProtoMessage() {} + +func (m *CommitResponse) GetCost() *Cost { + if m != nil { + return m.Cost + } + return nil +} + +func (m *CommitResponse) GetVersion() []*CommitResponse_Version { + if m != nil { + return m.Version + } + return nil +} + +type CommitResponse_Version struct { + RootEntityKey *Reference `protobuf:"bytes,4,req,name=root_entity_key" json:"root_entity_key,omitempty"` + Version *int64 `protobuf:"varint,5,req,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CommitResponse_Version) Reset() { *m = CommitResponse_Version{} } +func (m *CommitResponse_Version) String() string { return proto.CompactTextString(m) } +func (*CommitResponse_Version) ProtoMessage() {} + +func (m *CommitResponse_Version) GetRootEntityKey() *Reference { + if m != nil { + return m.RootEntityKey + } + return nil +} + +func (m *CommitResponse_Version) GetVersion() int64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func init() { +} diff --git a/vendor/google.golang.org/appengine/internal/identity.go b/vendor/google.golang.org/appengine/internal/identity.go new file mode 100644 index 00000000..d538701a --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/identity.go @@ -0,0 +1,14 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +package internal + +import netcontext "golang.org/x/net/context" + +// These functions are implementations of the wrapper functions +// in ../appengine/identity.go. See that file for commentary. + +func AppID(c netcontext.Context) string { + return appID(FullyQualifiedAppID(c)) +} diff --git a/vendor/google.golang.org/appengine/internal/identity_classic.go b/vendor/google.golang.org/appengine/internal/identity_classic.go new file mode 100644 index 00000000..e6b9227c --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/identity_classic.go @@ -0,0 +1,27 @@ +// Copyright 2015 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// +build appengine + +package internal + +import ( + "appengine" + + netcontext "golang.org/x/net/context" +) + +func DefaultVersionHostname(ctx netcontext.Context) string { + return appengine.DefaultVersionHostname(fromContext(ctx)) +} + +func RequestID(ctx netcontext.Context) string { return appengine.RequestID(fromContext(ctx)) } +func Datacenter(_ netcontext.Context) string { return appengine.Datacenter() } +func ServerSoftware() string { return appengine.ServerSoftware() } +func ModuleName(ctx netcontext.Context) string { return appengine.ModuleName(fromContext(ctx)) } +func VersionID(ctx netcontext.Context) string { return appengine.VersionID(fromContext(ctx)) } +func InstanceID() string { return appengine.InstanceID() } +func IsDevAppServer() bool { return appengine.IsDevAppServer() } + +func fullyQualifiedAppID(ctx netcontext.Context) string { return fromContext(ctx).FullyQualifiedAppID() } diff --git a/vendor/google.golang.org/appengine/internal/identity_vm.go b/vendor/google.golang.org/appengine/internal/identity_vm.go new file mode 100644 index 00000000..ebe68b78 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/identity_vm.go @@ -0,0 +1,97 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// +build !appengine + +package internal + +import ( + "net/http" + "os" + + netcontext "golang.org/x/net/context" +) + +// These functions are implementations of the wrapper functions +// in ../appengine/identity.go. See that file for commentary. + +const ( + hDefaultVersionHostname = "X-AppEngine-Default-Version-Hostname" + hRequestLogId = "X-AppEngine-Request-Log-Id" + hDatacenter = "X-AppEngine-Datacenter" +) + +func ctxHeaders(ctx netcontext.Context) http.Header { + return fromContext(ctx).Request().Header +} + +func DefaultVersionHostname(ctx netcontext.Context) string { + return ctxHeaders(ctx).Get(hDefaultVersionHostname) +} + +func RequestID(ctx netcontext.Context) string { + return ctxHeaders(ctx).Get(hRequestLogId) +} + +func Datacenter(ctx netcontext.Context) string { + return ctxHeaders(ctx).Get(hDatacenter) +} + +func ServerSoftware() string { + // TODO(dsymonds): Remove fallback when we've verified this. + if s := os.Getenv("SERVER_SOFTWARE"); s != "" { + return s + } + return "Google App Engine/1.x.x" +} + +// TODO(dsymonds): Remove the metadata fetches. + +func ModuleName(_ netcontext.Context) string { + if s := os.Getenv("GAE_MODULE_NAME"); s != "" { + return s + } + return string(mustGetMetadata("instance/attributes/gae_backend_name")) +} + +func VersionID(_ netcontext.Context) string { + if s1, s2 := os.Getenv("GAE_MODULE_VERSION"), os.Getenv("GAE_MINOR_VERSION"); s1 != "" && s2 != "" { + return s1 + "." + s2 + } + return string(mustGetMetadata("instance/attributes/gae_backend_version")) + "." + string(mustGetMetadata("instance/attributes/gae_backend_minor_version")) +} + +func InstanceID() string { + if s := os.Getenv("GAE_MODULE_INSTANCE"); s != "" { + return s + } + return string(mustGetMetadata("instance/attributes/gae_backend_instance")) +} + +func partitionlessAppID() string { + // gae_project has everything except the partition prefix. + appID := os.Getenv("GAE_LONG_APP_ID") + if appID == "" { + appID = string(mustGetMetadata("instance/attributes/gae_project")) + } + return appID +} + +func fullyQualifiedAppID(_ netcontext.Context) string { + appID := partitionlessAppID() + + part := os.Getenv("GAE_PARTITION") + if part == "" { + part = string(mustGetMetadata("instance/attributes/gae_partition")) + } + + if part != "" { + appID = part + "~" + appID + } + return appID +} + +func IsDevAppServer() bool { + return os.Getenv("RUN_WITH_DEVAPPSERVER") != "" +} diff --git a/vendor/google.golang.org/appengine/internal/internal.go b/vendor/google.golang.org/appengine/internal/internal.go new file mode 100644 index 00000000..051ea398 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/internal.go @@ -0,0 +1,110 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// Package internal provides support for package appengine. +// +// Programs should not use this package directly. Its API is not stable. +// Use packages appengine and appengine/* instead. +package internal + +import ( + "fmt" + + "github.com/golang/protobuf/proto" + + remotepb "google.golang.org/appengine/internal/remote_api" +) + +// errorCodeMaps is a map of service name to the error code map for the service. +var errorCodeMaps = make(map[string]map[int32]string) + +// RegisterErrorCodeMap is called from API implementations to register their +// error code map. This should only be called from init functions. +func RegisterErrorCodeMap(service string, m map[int32]string) { + errorCodeMaps[service] = m +} + +type timeoutCodeKey struct { + service string + code int32 +} + +// timeoutCodes is the set of service+code pairs that represent timeouts. +var timeoutCodes = make(map[timeoutCodeKey]bool) + +func RegisterTimeoutErrorCode(service string, code int32) { + timeoutCodes[timeoutCodeKey{service, code}] = true +} + +// APIError is the type returned by appengine.Context's Call method +// when an API call fails in an API-specific way. This may be, for instance, +// a taskqueue API call failing with TaskQueueServiceError::UNKNOWN_QUEUE. +type APIError struct { + Service string + Detail string + Code int32 // API-specific error code +} + +func (e *APIError) Error() string { + if e.Code == 0 { + if e.Detail == "" { + return "APIError " + } + return e.Detail + } + s := fmt.Sprintf("API error %d", e.Code) + if m, ok := errorCodeMaps[e.Service]; ok { + s += " (" + e.Service + ": " + m[e.Code] + ")" + } else { + // Shouldn't happen, but provide a bit more detail if it does. + s = e.Service + " " + s + } + if e.Detail != "" { + s += ": " + e.Detail + } + return s +} + +func (e *APIError) IsTimeout() bool { + return timeoutCodes[timeoutCodeKey{e.Service, e.Code}] +} + +// CallError is the type returned by appengine.Context's Call method when an +// API call fails in a generic way, such as RpcError::CAPABILITY_DISABLED. +type CallError struct { + Detail string + Code int32 + // TODO: Remove this if we get a distinguishable error code. + Timeout bool +} + +func (e *CallError) Error() string { + var msg string + switch remotepb.RpcError_ErrorCode(e.Code) { + case remotepb.RpcError_UNKNOWN: + return e.Detail + case remotepb.RpcError_OVER_QUOTA: + msg = "Over quota" + case remotepb.RpcError_CAPABILITY_DISABLED: + msg = "Capability disabled" + case remotepb.RpcError_CANCELLED: + msg = "Canceled" + default: + msg = fmt.Sprintf("Call error %d", e.Code) + } + s := msg + ": " + e.Detail + if e.Timeout { + s += " (timeout)" + } + return s +} + +func (e *CallError) IsTimeout() bool { + return e.Timeout +} + +// NamespaceMods is a map from API service to a function that will mutate an RPC request to attach a namespace. +// The function should be prepared to be called on the same message more than once; it should only modify the +// RPC request the first time. +var NamespaceMods = make(map[string]func(m proto.Message, namespace string)) diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.pb.go b/vendor/google.golang.org/appengine/internal/log/log_service.pb.go new file mode 100644 index 00000000..20c595be --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/log/log_service.pb.go @@ -0,0 +1,899 @@ +// Code generated by protoc-gen-go. +// source: google.golang.org/appengine/internal/log/log_service.proto +// DO NOT EDIT! + +/* +Package log is a generated protocol buffer package. + +It is generated from these files: + google.golang.org/appengine/internal/log/log_service.proto + +It has these top-level messages: + LogServiceError + UserAppLogLine + UserAppLogGroup + FlushRequest + SetStatusRequest + LogOffset + LogLine + RequestLog + LogModuleVersion + LogReadRequest + LogReadResponse + LogUsageRecord + LogUsageRequest + LogUsageResponse +*/ +package log + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type LogServiceError_ErrorCode int32 + +const ( + LogServiceError_OK LogServiceError_ErrorCode = 0 + LogServiceError_INVALID_REQUEST LogServiceError_ErrorCode = 1 + LogServiceError_STORAGE_ERROR LogServiceError_ErrorCode = 2 +) + +var LogServiceError_ErrorCode_name = map[int32]string{ + 0: "OK", + 1: "INVALID_REQUEST", + 2: "STORAGE_ERROR", +} +var LogServiceError_ErrorCode_value = map[string]int32{ + "OK": 0, + "INVALID_REQUEST": 1, + "STORAGE_ERROR": 2, +} + +func (x LogServiceError_ErrorCode) Enum() *LogServiceError_ErrorCode { + p := new(LogServiceError_ErrorCode) + *p = x + return p +} +func (x LogServiceError_ErrorCode) String() string { + return proto.EnumName(LogServiceError_ErrorCode_name, int32(x)) +} +func (x *LogServiceError_ErrorCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(LogServiceError_ErrorCode_value, data, "LogServiceError_ErrorCode") + if err != nil { + return err + } + *x = LogServiceError_ErrorCode(value) + return nil +} + +type LogServiceError struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *LogServiceError) Reset() { *m = LogServiceError{} } +func (m *LogServiceError) String() string { return proto.CompactTextString(m) } +func (*LogServiceError) ProtoMessage() {} + +type UserAppLogLine struct { + TimestampUsec *int64 `protobuf:"varint,1,req,name=timestamp_usec" json:"timestamp_usec,omitempty"` + Level *int64 `protobuf:"varint,2,req,name=level" json:"level,omitempty"` + Message *string `protobuf:"bytes,3,req,name=message" json:"message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UserAppLogLine) Reset() { *m = UserAppLogLine{} } +func (m *UserAppLogLine) String() string { return proto.CompactTextString(m) } +func (*UserAppLogLine) ProtoMessage() {} + +func (m *UserAppLogLine) GetTimestampUsec() int64 { + if m != nil && m.TimestampUsec != nil { + return *m.TimestampUsec + } + return 0 +} + +func (m *UserAppLogLine) GetLevel() int64 { + if m != nil && m.Level != nil { + return *m.Level + } + return 0 +} + +func (m *UserAppLogLine) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +type UserAppLogGroup struct { + LogLine []*UserAppLogLine `protobuf:"bytes,2,rep,name=log_line" json:"log_line,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UserAppLogGroup) Reset() { *m = UserAppLogGroup{} } +func (m *UserAppLogGroup) String() string { return proto.CompactTextString(m) } +func (*UserAppLogGroup) ProtoMessage() {} + +func (m *UserAppLogGroup) GetLogLine() []*UserAppLogLine { + if m != nil { + return m.LogLine + } + return nil +} + +type FlushRequest struct { + Logs []byte `protobuf:"bytes,1,opt,name=logs" json:"logs,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FlushRequest) Reset() { *m = FlushRequest{} } +func (m *FlushRequest) String() string { return proto.CompactTextString(m) } +func (*FlushRequest) ProtoMessage() {} + +func (m *FlushRequest) GetLogs() []byte { + if m != nil { + return m.Logs + } + return nil +} + +type SetStatusRequest struct { + Status *string `protobuf:"bytes,1,req,name=status" json:"status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SetStatusRequest) Reset() { *m = SetStatusRequest{} } +func (m *SetStatusRequest) String() string { return proto.CompactTextString(m) } +func (*SetStatusRequest) ProtoMessage() {} + +func (m *SetStatusRequest) GetStatus() string { + if m != nil && m.Status != nil { + return *m.Status + } + return "" +} + +type LogOffset struct { + RequestId []byte `protobuf:"bytes,1,opt,name=request_id" json:"request_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *LogOffset) Reset() { *m = LogOffset{} } +func (m *LogOffset) String() string { return proto.CompactTextString(m) } +func (*LogOffset) ProtoMessage() {} + +func (m *LogOffset) GetRequestId() []byte { + if m != nil { + return m.RequestId + } + return nil +} + +type LogLine struct { + Time *int64 `protobuf:"varint,1,req,name=time" json:"time,omitempty"` + Level *int32 `protobuf:"varint,2,req,name=level" json:"level,omitempty"` + LogMessage *string `protobuf:"bytes,3,req,name=log_message" json:"log_message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *LogLine) Reset() { *m = LogLine{} } +func (m *LogLine) String() string { return proto.CompactTextString(m) } +func (*LogLine) ProtoMessage() {} + +func (m *LogLine) GetTime() int64 { + if m != nil && m.Time != nil { + return *m.Time + } + return 0 +} + +func (m *LogLine) GetLevel() int32 { + if m != nil && m.Level != nil { + return *m.Level + } + return 0 +} + +func (m *LogLine) GetLogMessage() string { + if m != nil && m.LogMessage != nil { + return *m.LogMessage + } + return "" +} + +type RequestLog struct { + AppId *string `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"` + ModuleId *string `protobuf:"bytes,37,opt,name=module_id,def=default" json:"module_id,omitempty"` + VersionId *string `protobuf:"bytes,2,req,name=version_id" json:"version_id,omitempty"` + RequestId []byte `protobuf:"bytes,3,req,name=request_id" json:"request_id,omitempty"` + Offset *LogOffset `protobuf:"bytes,35,opt,name=offset" json:"offset,omitempty"` + Ip *string `protobuf:"bytes,4,req,name=ip" json:"ip,omitempty"` + Nickname *string `protobuf:"bytes,5,opt,name=nickname" json:"nickname,omitempty"` + StartTime *int64 `protobuf:"varint,6,req,name=start_time" json:"start_time,omitempty"` + EndTime *int64 `protobuf:"varint,7,req,name=end_time" json:"end_time,omitempty"` + Latency *int64 `protobuf:"varint,8,req,name=latency" json:"latency,omitempty"` + Mcycles *int64 `protobuf:"varint,9,req,name=mcycles" json:"mcycles,omitempty"` + Method *string `protobuf:"bytes,10,req,name=method" json:"method,omitempty"` + Resource *string `protobuf:"bytes,11,req,name=resource" json:"resource,omitempty"` + HttpVersion *string `protobuf:"bytes,12,req,name=http_version" json:"http_version,omitempty"` + Status *int32 `protobuf:"varint,13,req,name=status" json:"status,omitempty"` + ResponseSize *int64 `protobuf:"varint,14,req,name=response_size" json:"response_size,omitempty"` + Referrer *string `protobuf:"bytes,15,opt,name=referrer" json:"referrer,omitempty"` + UserAgent *string `protobuf:"bytes,16,opt,name=user_agent" json:"user_agent,omitempty"` + UrlMapEntry *string `protobuf:"bytes,17,req,name=url_map_entry" json:"url_map_entry,omitempty"` + Combined *string `protobuf:"bytes,18,req,name=combined" json:"combined,omitempty"` + ApiMcycles *int64 `protobuf:"varint,19,opt,name=api_mcycles" json:"api_mcycles,omitempty"` + Host *string `protobuf:"bytes,20,opt,name=host" json:"host,omitempty"` + Cost *float64 `protobuf:"fixed64,21,opt,name=cost" json:"cost,omitempty"` + TaskQueueName *string `protobuf:"bytes,22,opt,name=task_queue_name" json:"task_queue_name,omitempty"` + TaskName *string `protobuf:"bytes,23,opt,name=task_name" json:"task_name,omitempty"` + WasLoadingRequest *bool `protobuf:"varint,24,opt,name=was_loading_request" json:"was_loading_request,omitempty"` + PendingTime *int64 `protobuf:"varint,25,opt,name=pending_time" json:"pending_time,omitempty"` + ReplicaIndex *int32 `protobuf:"varint,26,opt,name=replica_index,def=-1" json:"replica_index,omitempty"` + Finished *bool `protobuf:"varint,27,opt,name=finished,def=1" json:"finished,omitempty"` + CloneKey []byte `protobuf:"bytes,28,opt,name=clone_key" json:"clone_key,omitempty"` + Line []*LogLine `protobuf:"bytes,29,rep,name=line" json:"line,omitempty"` + LinesIncomplete *bool `protobuf:"varint,36,opt,name=lines_incomplete" json:"lines_incomplete,omitempty"` + AppEngineRelease []byte `protobuf:"bytes,38,opt,name=app_engine_release" json:"app_engine_release,omitempty"` + ExitReason *int32 `protobuf:"varint,30,opt,name=exit_reason" json:"exit_reason,omitempty"` + WasThrottledForTime *bool `protobuf:"varint,31,opt,name=was_throttled_for_time" json:"was_throttled_for_time,omitempty"` + WasThrottledForRequests *bool `protobuf:"varint,32,opt,name=was_throttled_for_requests" json:"was_throttled_for_requests,omitempty"` + ThrottledTime *int64 `protobuf:"varint,33,opt,name=throttled_time" json:"throttled_time,omitempty"` + ServerName []byte `protobuf:"bytes,34,opt,name=server_name" json:"server_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RequestLog) Reset() { *m = RequestLog{} } +func (m *RequestLog) String() string { return proto.CompactTextString(m) } +func (*RequestLog) ProtoMessage() {} + +const Default_RequestLog_ModuleId string = "default" +const Default_RequestLog_ReplicaIndex int32 = -1 +const Default_RequestLog_Finished bool = true + +func (m *RequestLog) GetAppId() string { + if m != nil && m.AppId != nil { + return *m.AppId + } + return "" +} + +func (m *RequestLog) GetModuleId() string { + if m != nil && m.ModuleId != nil { + return *m.ModuleId + } + return Default_RequestLog_ModuleId +} + +func (m *RequestLog) GetVersionId() string { + if m != nil && m.VersionId != nil { + return *m.VersionId + } + return "" +} + +func (m *RequestLog) GetRequestId() []byte { + if m != nil { + return m.RequestId + } + return nil +} + +func (m *RequestLog) GetOffset() *LogOffset { + if m != nil { + return m.Offset + } + return nil +} + +func (m *RequestLog) GetIp() string { + if m != nil && m.Ip != nil { + return *m.Ip + } + return "" +} + +func (m *RequestLog) GetNickname() string { + if m != nil && m.Nickname != nil { + return *m.Nickname + } + return "" +} + +func (m *RequestLog) GetStartTime() int64 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *RequestLog) GetEndTime() int64 { + if m != nil && m.EndTime != nil { + return *m.EndTime + } + return 0 +} + +func (m *RequestLog) GetLatency() int64 { + if m != nil && m.Latency != nil { + return *m.Latency + } + return 0 +} + +func (m *RequestLog) GetMcycles() int64 { + if m != nil && m.Mcycles != nil { + return *m.Mcycles + } + return 0 +} + +func (m *RequestLog) GetMethod() string { + if m != nil && m.Method != nil { + return *m.Method + } + return "" +} + +func (m *RequestLog) GetResource() string { + if m != nil && m.Resource != nil { + return *m.Resource + } + return "" +} + +func (m *RequestLog) GetHttpVersion() string { + if m != nil && m.HttpVersion != nil { + return *m.HttpVersion + } + return "" +} + +func (m *RequestLog) GetStatus() int32 { + if m != nil && m.Status != nil { + return *m.Status + } + return 0 +} + +func (m *RequestLog) GetResponseSize() int64 { + if m != nil && m.ResponseSize != nil { + return *m.ResponseSize + } + return 0 +} + +func (m *RequestLog) GetReferrer() string { + if m != nil && m.Referrer != nil { + return *m.Referrer + } + return "" +} + +func (m *RequestLog) GetUserAgent() string { + if m != nil && m.UserAgent != nil { + return *m.UserAgent + } + return "" +} + +func (m *RequestLog) GetUrlMapEntry() string { + if m != nil && m.UrlMapEntry != nil { + return *m.UrlMapEntry + } + return "" +} + +func (m *RequestLog) GetCombined() string { + if m != nil && m.Combined != nil { + return *m.Combined + } + return "" +} + +func (m *RequestLog) GetApiMcycles() int64 { + if m != nil && m.ApiMcycles != nil { + return *m.ApiMcycles + } + return 0 +} + +func (m *RequestLog) GetHost() string { + if m != nil && m.Host != nil { + return *m.Host + } + return "" +} + +func (m *RequestLog) GetCost() float64 { + if m != nil && m.Cost != nil { + return *m.Cost + } + return 0 +} + +func (m *RequestLog) GetTaskQueueName() string { + if m != nil && m.TaskQueueName != nil { + return *m.TaskQueueName + } + return "" +} + +func (m *RequestLog) GetTaskName() string { + if m != nil && m.TaskName != nil { + return *m.TaskName + } + return "" +} + +func (m *RequestLog) GetWasLoadingRequest() bool { + if m != nil && m.WasLoadingRequest != nil { + return *m.WasLoadingRequest + } + return false +} + +func (m *RequestLog) GetPendingTime() int64 { + if m != nil && m.PendingTime != nil { + return *m.PendingTime + } + return 0 +} + +func (m *RequestLog) GetReplicaIndex() int32 { + if m != nil && m.ReplicaIndex != nil { + return *m.ReplicaIndex + } + return Default_RequestLog_ReplicaIndex +} + +func (m *RequestLog) GetFinished() bool { + if m != nil && m.Finished != nil { + return *m.Finished + } + return Default_RequestLog_Finished +} + +func (m *RequestLog) GetCloneKey() []byte { + if m != nil { + return m.CloneKey + } + return nil +} + +func (m *RequestLog) GetLine() []*LogLine { + if m != nil { + return m.Line + } + return nil +} + +func (m *RequestLog) GetLinesIncomplete() bool { + if m != nil && m.LinesIncomplete != nil { + return *m.LinesIncomplete + } + return false +} + +func (m *RequestLog) GetAppEngineRelease() []byte { + if m != nil { + return m.AppEngineRelease + } + return nil +} + +func (m *RequestLog) GetExitReason() int32 { + if m != nil && m.ExitReason != nil { + return *m.ExitReason + } + return 0 +} + +func (m *RequestLog) GetWasThrottledForTime() bool { + if m != nil && m.WasThrottledForTime != nil { + return *m.WasThrottledForTime + } + return false +} + +func (m *RequestLog) GetWasThrottledForRequests() bool { + if m != nil && m.WasThrottledForRequests != nil { + return *m.WasThrottledForRequests + } + return false +} + +func (m *RequestLog) GetThrottledTime() int64 { + if m != nil && m.ThrottledTime != nil { + return *m.ThrottledTime + } + return 0 +} + +func (m *RequestLog) GetServerName() []byte { + if m != nil { + return m.ServerName + } + return nil +} + +type LogModuleVersion struct { + ModuleId *string `protobuf:"bytes,1,opt,name=module_id,def=default" json:"module_id,omitempty"` + VersionId *string `protobuf:"bytes,2,opt,name=version_id" json:"version_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *LogModuleVersion) Reset() { *m = LogModuleVersion{} } +func (m *LogModuleVersion) String() string { return proto.CompactTextString(m) } +func (*LogModuleVersion) ProtoMessage() {} + +const Default_LogModuleVersion_ModuleId string = "default" + +func (m *LogModuleVersion) GetModuleId() string { + if m != nil && m.ModuleId != nil { + return *m.ModuleId + } + return Default_LogModuleVersion_ModuleId +} + +func (m *LogModuleVersion) GetVersionId() string { + if m != nil && m.VersionId != nil { + return *m.VersionId + } + return "" +} + +type LogReadRequest struct { + AppId *string `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"` + VersionId []string `protobuf:"bytes,2,rep,name=version_id" json:"version_id,omitempty"` + ModuleVersion []*LogModuleVersion `protobuf:"bytes,19,rep,name=module_version" json:"module_version,omitempty"` + StartTime *int64 `protobuf:"varint,3,opt,name=start_time" json:"start_time,omitempty"` + EndTime *int64 `protobuf:"varint,4,opt,name=end_time" json:"end_time,omitempty"` + Offset *LogOffset `protobuf:"bytes,5,opt,name=offset" json:"offset,omitempty"` + RequestId [][]byte `protobuf:"bytes,6,rep,name=request_id" json:"request_id,omitempty"` + MinimumLogLevel *int32 `protobuf:"varint,7,opt,name=minimum_log_level" json:"minimum_log_level,omitempty"` + IncludeIncomplete *bool `protobuf:"varint,8,opt,name=include_incomplete" json:"include_incomplete,omitempty"` + Count *int64 `protobuf:"varint,9,opt,name=count" json:"count,omitempty"` + CombinedLogRegex *string `protobuf:"bytes,14,opt,name=combined_log_regex" json:"combined_log_regex,omitempty"` + HostRegex *string `protobuf:"bytes,15,opt,name=host_regex" json:"host_regex,omitempty"` + ReplicaIndex *int32 `protobuf:"varint,16,opt,name=replica_index" json:"replica_index,omitempty"` + IncludeAppLogs *bool `protobuf:"varint,10,opt,name=include_app_logs" json:"include_app_logs,omitempty"` + AppLogsPerRequest *int32 `protobuf:"varint,17,opt,name=app_logs_per_request" json:"app_logs_per_request,omitempty"` + IncludeHost *bool `protobuf:"varint,11,opt,name=include_host" json:"include_host,omitempty"` + IncludeAll *bool `protobuf:"varint,12,opt,name=include_all" json:"include_all,omitempty"` + CacheIterator *bool `protobuf:"varint,13,opt,name=cache_iterator" json:"cache_iterator,omitempty"` + NumShards *int32 `protobuf:"varint,18,opt,name=num_shards" json:"num_shards,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *LogReadRequest) Reset() { *m = LogReadRequest{} } +func (m *LogReadRequest) String() string { return proto.CompactTextString(m) } +func (*LogReadRequest) ProtoMessage() {} + +func (m *LogReadRequest) GetAppId() string { + if m != nil && m.AppId != nil { + return *m.AppId + } + return "" +} + +func (m *LogReadRequest) GetVersionId() []string { + if m != nil { + return m.VersionId + } + return nil +} + +func (m *LogReadRequest) GetModuleVersion() []*LogModuleVersion { + if m != nil { + return m.ModuleVersion + } + return nil +} + +func (m *LogReadRequest) GetStartTime() int64 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *LogReadRequest) GetEndTime() int64 { + if m != nil && m.EndTime != nil { + return *m.EndTime + } + return 0 +} + +func (m *LogReadRequest) GetOffset() *LogOffset { + if m != nil { + return m.Offset + } + return nil +} + +func (m *LogReadRequest) GetRequestId() [][]byte { + if m != nil { + return m.RequestId + } + return nil +} + +func (m *LogReadRequest) GetMinimumLogLevel() int32 { + if m != nil && m.MinimumLogLevel != nil { + return *m.MinimumLogLevel + } + return 0 +} + +func (m *LogReadRequest) GetIncludeIncomplete() bool { + if m != nil && m.IncludeIncomplete != nil { + return *m.IncludeIncomplete + } + return false +} + +func (m *LogReadRequest) GetCount() int64 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *LogReadRequest) GetCombinedLogRegex() string { + if m != nil && m.CombinedLogRegex != nil { + return *m.CombinedLogRegex + } + return "" +} + +func (m *LogReadRequest) GetHostRegex() string { + if m != nil && m.HostRegex != nil { + return *m.HostRegex + } + return "" +} + +func (m *LogReadRequest) GetReplicaIndex() int32 { + if m != nil && m.ReplicaIndex != nil { + return *m.ReplicaIndex + } + return 0 +} + +func (m *LogReadRequest) GetIncludeAppLogs() bool { + if m != nil && m.IncludeAppLogs != nil { + return *m.IncludeAppLogs + } + return false +} + +func (m *LogReadRequest) GetAppLogsPerRequest() int32 { + if m != nil && m.AppLogsPerRequest != nil { + return *m.AppLogsPerRequest + } + return 0 +} + +func (m *LogReadRequest) GetIncludeHost() bool { + if m != nil && m.IncludeHost != nil { + return *m.IncludeHost + } + return false +} + +func (m *LogReadRequest) GetIncludeAll() bool { + if m != nil && m.IncludeAll != nil { + return *m.IncludeAll + } + return false +} + +func (m *LogReadRequest) GetCacheIterator() bool { + if m != nil && m.CacheIterator != nil { + return *m.CacheIterator + } + return false +} + +func (m *LogReadRequest) GetNumShards() int32 { + if m != nil && m.NumShards != nil { + return *m.NumShards + } + return 0 +} + +type LogReadResponse struct { + Log []*RequestLog `protobuf:"bytes,1,rep,name=log" json:"log,omitempty"` + Offset *LogOffset `protobuf:"bytes,2,opt,name=offset" json:"offset,omitempty"` + LastEndTime *int64 `protobuf:"varint,3,opt,name=last_end_time" json:"last_end_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *LogReadResponse) Reset() { *m = LogReadResponse{} } +func (m *LogReadResponse) String() string { return proto.CompactTextString(m) } +func (*LogReadResponse) ProtoMessage() {} + +func (m *LogReadResponse) GetLog() []*RequestLog { + if m != nil { + return m.Log + } + return nil +} + +func (m *LogReadResponse) GetOffset() *LogOffset { + if m != nil { + return m.Offset + } + return nil +} + +func (m *LogReadResponse) GetLastEndTime() int64 { + if m != nil && m.LastEndTime != nil { + return *m.LastEndTime + } + return 0 +} + +type LogUsageRecord struct { + VersionId *string `protobuf:"bytes,1,opt,name=version_id" json:"version_id,omitempty"` + StartTime *int32 `protobuf:"varint,2,opt,name=start_time" json:"start_time,omitempty"` + EndTime *int32 `protobuf:"varint,3,opt,name=end_time" json:"end_time,omitempty"` + Count *int64 `protobuf:"varint,4,opt,name=count" json:"count,omitempty"` + TotalSize *int64 `protobuf:"varint,5,opt,name=total_size" json:"total_size,omitempty"` + Records *int32 `protobuf:"varint,6,opt,name=records" json:"records,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *LogUsageRecord) Reset() { *m = LogUsageRecord{} } +func (m *LogUsageRecord) String() string { return proto.CompactTextString(m) } +func (*LogUsageRecord) ProtoMessage() {} + +func (m *LogUsageRecord) GetVersionId() string { + if m != nil && m.VersionId != nil { + return *m.VersionId + } + return "" +} + +func (m *LogUsageRecord) GetStartTime() int32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *LogUsageRecord) GetEndTime() int32 { + if m != nil && m.EndTime != nil { + return *m.EndTime + } + return 0 +} + +func (m *LogUsageRecord) GetCount() int64 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *LogUsageRecord) GetTotalSize() int64 { + if m != nil && m.TotalSize != nil { + return *m.TotalSize + } + return 0 +} + +func (m *LogUsageRecord) GetRecords() int32 { + if m != nil && m.Records != nil { + return *m.Records + } + return 0 +} + +type LogUsageRequest struct { + AppId *string `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"` + VersionId []string `protobuf:"bytes,2,rep,name=version_id" json:"version_id,omitempty"` + StartTime *int32 `protobuf:"varint,3,opt,name=start_time" json:"start_time,omitempty"` + EndTime *int32 `protobuf:"varint,4,opt,name=end_time" json:"end_time,omitempty"` + ResolutionHours *uint32 `protobuf:"varint,5,opt,name=resolution_hours,def=1" json:"resolution_hours,omitempty"` + CombineVersions *bool `protobuf:"varint,6,opt,name=combine_versions" json:"combine_versions,omitempty"` + UsageVersion *int32 `protobuf:"varint,7,opt,name=usage_version" json:"usage_version,omitempty"` + VersionsOnly *bool `protobuf:"varint,8,opt,name=versions_only" json:"versions_only,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *LogUsageRequest) Reset() { *m = LogUsageRequest{} } +func (m *LogUsageRequest) String() string { return proto.CompactTextString(m) } +func (*LogUsageRequest) ProtoMessage() {} + +const Default_LogUsageRequest_ResolutionHours uint32 = 1 + +func (m *LogUsageRequest) GetAppId() string { + if m != nil && m.AppId != nil { + return *m.AppId + } + return "" +} + +func (m *LogUsageRequest) GetVersionId() []string { + if m != nil { + return m.VersionId + } + return nil +} + +func (m *LogUsageRequest) GetStartTime() int32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *LogUsageRequest) GetEndTime() int32 { + if m != nil && m.EndTime != nil { + return *m.EndTime + } + return 0 +} + +func (m *LogUsageRequest) GetResolutionHours() uint32 { + if m != nil && m.ResolutionHours != nil { + return *m.ResolutionHours + } + return Default_LogUsageRequest_ResolutionHours +} + +func (m *LogUsageRequest) GetCombineVersions() bool { + if m != nil && m.CombineVersions != nil { + return *m.CombineVersions + } + return false +} + +func (m *LogUsageRequest) GetUsageVersion() int32 { + if m != nil && m.UsageVersion != nil { + return *m.UsageVersion + } + return 0 +} + +func (m *LogUsageRequest) GetVersionsOnly() bool { + if m != nil && m.VersionsOnly != nil { + return *m.VersionsOnly + } + return false +} + +type LogUsageResponse struct { + Usage []*LogUsageRecord `protobuf:"bytes,1,rep,name=usage" json:"usage,omitempty"` + Summary *LogUsageRecord `protobuf:"bytes,2,opt,name=summary" json:"summary,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *LogUsageResponse) Reset() { *m = LogUsageResponse{} } +func (m *LogUsageResponse) String() string { return proto.CompactTextString(m) } +func (*LogUsageResponse) ProtoMessage() {} + +func (m *LogUsageResponse) GetUsage() []*LogUsageRecord { + if m != nil { + return m.Usage + } + return nil +} + +func (m *LogUsageResponse) GetSummary() *LogUsageRecord { + if m != nil { + return m.Summary + } + return nil +} + +func init() { +} diff --git a/vendor/google.golang.org/appengine/internal/main.go b/vendor/google.golang.org/appengine/internal/main.go new file mode 100644 index 00000000..49036163 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/main.go @@ -0,0 +1,15 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// +build appengine + +package internal + +import ( + "appengine_internal" +) + +func Main() { + appengine_internal.Main() +} diff --git a/vendor/google.golang.org/appengine/internal/main_vm.go b/vendor/google.golang.org/appengine/internal/main_vm.go new file mode 100644 index 00000000..57331ad1 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/main_vm.go @@ -0,0 +1,44 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// +build !appengine + +package internal + +import ( + "io" + "log" + "net/http" + "net/url" + "os" +) + +func Main() { + installHealthChecker(http.DefaultServeMux) + + port := "8080" + if s := os.Getenv("PORT"); s != "" { + port = s + } + + if err := http.ListenAndServe(":"+port, http.HandlerFunc(handleHTTP)); err != nil { + log.Fatalf("http.ListenAndServe: %v", err) + } +} + +func installHealthChecker(mux *http.ServeMux) { + // If no health check handler has been installed by this point, add a trivial one. + const healthPath = "/_ah/health" + hreq := &http.Request{ + Method: "GET", + URL: &url.URL{ + Path: healthPath, + }, + } + if _, pat := mux.Handler(hreq); pat != healthPath { + mux.HandleFunc(healthPath, func(w http.ResponseWriter, r *http.Request) { + io.WriteString(w, "ok") + }) + } +} diff --git a/vendor/google.golang.org/appengine/internal/metadata.go b/vendor/google.golang.org/appengine/internal/metadata.go new file mode 100644 index 00000000..9cc1f71d --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/metadata.go @@ -0,0 +1,61 @@ +// Copyright 2014 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +package internal + +// This file has code for accessing metadata. +// +// References: +// https://cloud.google.com/compute/docs/metadata + +import ( + "fmt" + "io/ioutil" + "log" + "net/http" + "net/url" +) + +const ( + metadataHost = "metadata" + metadataPath = "/computeMetadata/v1/" +) + +var ( + metadataRequestHeaders = http.Header{ + "Metadata-Flavor": []string{"Google"}, + } +) + +// TODO(dsymonds): Do we need to support default values, like Python? +func mustGetMetadata(key string) []byte { + b, err := getMetadata(key) + if err != nil { + log.Fatalf("Metadata fetch failed: %v", err) + } + return b +} + +func getMetadata(key string) ([]byte, error) { + // TODO(dsymonds): May need to use url.Parse to support keys with query args. + req := &http.Request{ + Method: "GET", + URL: &url.URL{ + Scheme: "http", + Host: metadataHost, + Path: metadataPath + key, + }, + Header: metadataRequestHeaders, + Host: metadataHost, + } + resp, err := http.DefaultClient.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + if resp.StatusCode != 200 { + return nil, fmt.Errorf("metadata server returned HTTP %d", resp.StatusCode) + } + return ioutil.ReadAll(resp.Body) +} diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go b/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go new file mode 100644 index 00000000..a0145ed3 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go @@ -0,0 +1,375 @@ +// Code generated by protoc-gen-go. +// source: google.golang.org/appengine/internal/modules/modules_service.proto +// DO NOT EDIT! + +/* +Package modules is a generated protocol buffer package. + +It is generated from these files: + google.golang.org/appengine/internal/modules/modules_service.proto + +It has these top-level messages: + ModulesServiceError + GetModulesRequest + GetModulesResponse + GetVersionsRequest + GetVersionsResponse + GetDefaultVersionRequest + GetDefaultVersionResponse + GetNumInstancesRequest + GetNumInstancesResponse + SetNumInstancesRequest + SetNumInstancesResponse + StartModuleRequest + StartModuleResponse + StopModuleRequest + StopModuleResponse + GetHostnameRequest + GetHostnameResponse +*/ +package modules + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type ModulesServiceError_ErrorCode int32 + +const ( + ModulesServiceError_OK ModulesServiceError_ErrorCode = 0 + ModulesServiceError_INVALID_MODULE ModulesServiceError_ErrorCode = 1 + ModulesServiceError_INVALID_VERSION ModulesServiceError_ErrorCode = 2 + ModulesServiceError_INVALID_INSTANCES ModulesServiceError_ErrorCode = 3 + ModulesServiceError_TRANSIENT_ERROR ModulesServiceError_ErrorCode = 4 + ModulesServiceError_UNEXPECTED_STATE ModulesServiceError_ErrorCode = 5 +) + +var ModulesServiceError_ErrorCode_name = map[int32]string{ + 0: "OK", + 1: "INVALID_MODULE", + 2: "INVALID_VERSION", + 3: "INVALID_INSTANCES", + 4: "TRANSIENT_ERROR", + 5: "UNEXPECTED_STATE", +} +var ModulesServiceError_ErrorCode_value = map[string]int32{ + "OK": 0, + "INVALID_MODULE": 1, + "INVALID_VERSION": 2, + "INVALID_INSTANCES": 3, + "TRANSIENT_ERROR": 4, + "UNEXPECTED_STATE": 5, +} + +func (x ModulesServiceError_ErrorCode) Enum() *ModulesServiceError_ErrorCode { + p := new(ModulesServiceError_ErrorCode) + *p = x + return p +} +func (x ModulesServiceError_ErrorCode) String() string { + return proto.EnumName(ModulesServiceError_ErrorCode_name, int32(x)) +} +func (x *ModulesServiceError_ErrorCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ModulesServiceError_ErrorCode_value, data, "ModulesServiceError_ErrorCode") + if err != nil { + return err + } + *x = ModulesServiceError_ErrorCode(value) + return nil +} + +type ModulesServiceError struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *ModulesServiceError) Reset() { *m = ModulesServiceError{} } +func (m *ModulesServiceError) String() string { return proto.CompactTextString(m) } +func (*ModulesServiceError) ProtoMessage() {} + +type GetModulesRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetModulesRequest) Reset() { *m = GetModulesRequest{} } +func (m *GetModulesRequest) String() string { return proto.CompactTextString(m) } +func (*GetModulesRequest) ProtoMessage() {} + +type GetModulesResponse struct { + Module []string `protobuf:"bytes,1,rep,name=module" json:"module,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetModulesResponse) Reset() { *m = GetModulesResponse{} } +func (m *GetModulesResponse) String() string { return proto.CompactTextString(m) } +func (*GetModulesResponse) ProtoMessage() {} + +func (m *GetModulesResponse) GetModule() []string { + if m != nil { + return m.Module + } + return nil +} + +type GetVersionsRequest struct { + Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetVersionsRequest) Reset() { *m = GetVersionsRequest{} } +func (m *GetVersionsRequest) String() string { return proto.CompactTextString(m) } +func (*GetVersionsRequest) ProtoMessage() {} + +func (m *GetVersionsRequest) GetModule() string { + if m != nil && m.Module != nil { + return *m.Module + } + return "" +} + +type GetVersionsResponse struct { + Version []string `protobuf:"bytes,1,rep,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetVersionsResponse) Reset() { *m = GetVersionsResponse{} } +func (m *GetVersionsResponse) String() string { return proto.CompactTextString(m) } +func (*GetVersionsResponse) ProtoMessage() {} + +func (m *GetVersionsResponse) GetVersion() []string { + if m != nil { + return m.Version + } + return nil +} + +type GetDefaultVersionRequest struct { + Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetDefaultVersionRequest) Reset() { *m = GetDefaultVersionRequest{} } +func (m *GetDefaultVersionRequest) String() string { return proto.CompactTextString(m) } +func (*GetDefaultVersionRequest) ProtoMessage() {} + +func (m *GetDefaultVersionRequest) GetModule() string { + if m != nil && m.Module != nil { + return *m.Module + } + return "" +} + +type GetDefaultVersionResponse struct { + Version *string `protobuf:"bytes,1,req,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetDefaultVersionResponse) Reset() { *m = GetDefaultVersionResponse{} } +func (m *GetDefaultVersionResponse) String() string { return proto.CompactTextString(m) } +func (*GetDefaultVersionResponse) ProtoMessage() {} + +func (m *GetDefaultVersionResponse) GetVersion() string { + if m != nil && m.Version != nil { + return *m.Version + } + return "" +} + +type GetNumInstancesRequest struct { + Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` + Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetNumInstancesRequest) Reset() { *m = GetNumInstancesRequest{} } +func (m *GetNumInstancesRequest) String() string { return proto.CompactTextString(m) } +func (*GetNumInstancesRequest) ProtoMessage() {} + +func (m *GetNumInstancesRequest) GetModule() string { + if m != nil && m.Module != nil { + return *m.Module + } + return "" +} + +func (m *GetNumInstancesRequest) GetVersion() string { + if m != nil && m.Version != nil { + return *m.Version + } + return "" +} + +type GetNumInstancesResponse struct { + Instances *int64 `protobuf:"varint,1,req,name=instances" json:"instances,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetNumInstancesResponse) Reset() { *m = GetNumInstancesResponse{} } +func (m *GetNumInstancesResponse) String() string { return proto.CompactTextString(m) } +func (*GetNumInstancesResponse) ProtoMessage() {} + +func (m *GetNumInstancesResponse) GetInstances() int64 { + if m != nil && m.Instances != nil { + return *m.Instances + } + return 0 +} + +type SetNumInstancesRequest struct { + Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` + Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` + Instances *int64 `protobuf:"varint,3,req,name=instances" json:"instances,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SetNumInstancesRequest) Reset() { *m = SetNumInstancesRequest{} } +func (m *SetNumInstancesRequest) String() string { return proto.CompactTextString(m) } +func (*SetNumInstancesRequest) ProtoMessage() {} + +func (m *SetNumInstancesRequest) GetModule() string { + if m != nil && m.Module != nil { + return *m.Module + } + return "" +} + +func (m *SetNumInstancesRequest) GetVersion() string { + if m != nil && m.Version != nil { + return *m.Version + } + return "" +} + +func (m *SetNumInstancesRequest) GetInstances() int64 { + if m != nil && m.Instances != nil { + return *m.Instances + } + return 0 +} + +type SetNumInstancesResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *SetNumInstancesResponse) Reset() { *m = SetNumInstancesResponse{} } +func (m *SetNumInstancesResponse) String() string { return proto.CompactTextString(m) } +func (*SetNumInstancesResponse) ProtoMessage() {} + +type StartModuleRequest struct { + Module *string `protobuf:"bytes,1,req,name=module" json:"module,omitempty"` + Version *string `protobuf:"bytes,2,req,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StartModuleRequest) Reset() { *m = StartModuleRequest{} } +func (m *StartModuleRequest) String() string { return proto.CompactTextString(m) } +func (*StartModuleRequest) ProtoMessage() {} + +func (m *StartModuleRequest) GetModule() string { + if m != nil && m.Module != nil { + return *m.Module + } + return "" +} + +func (m *StartModuleRequest) GetVersion() string { + if m != nil && m.Version != nil { + return *m.Version + } + return "" +} + +type StartModuleResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *StartModuleResponse) Reset() { *m = StartModuleResponse{} } +func (m *StartModuleResponse) String() string { return proto.CompactTextString(m) } +func (*StartModuleResponse) ProtoMessage() {} + +type StopModuleRequest struct { + Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` + Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StopModuleRequest) Reset() { *m = StopModuleRequest{} } +func (m *StopModuleRequest) String() string { return proto.CompactTextString(m) } +func (*StopModuleRequest) ProtoMessage() {} + +func (m *StopModuleRequest) GetModule() string { + if m != nil && m.Module != nil { + return *m.Module + } + return "" +} + +func (m *StopModuleRequest) GetVersion() string { + if m != nil && m.Version != nil { + return *m.Version + } + return "" +} + +type StopModuleResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *StopModuleResponse) Reset() { *m = StopModuleResponse{} } +func (m *StopModuleResponse) String() string { return proto.CompactTextString(m) } +func (*StopModuleResponse) ProtoMessage() {} + +type GetHostnameRequest struct { + Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` + Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` + Instance *string `protobuf:"bytes,3,opt,name=instance" json:"instance,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetHostnameRequest) Reset() { *m = GetHostnameRequest{} } +func (m *GetHostnameRequest) String() string { return proto.CompactTextString(m) } +func (*GetHostnameRequest) ProtoMessage() {} + +func (m *GetHostnameRequest) GetModule() string { + if m != nil && m.Module != nil { + return *m.Module + } + return "" +} + +func (m *GetHostnameRequest) GetVersion() string { + if m != nil && m.Version != nil { + return *m.Version + } + return "" +} + +func (m *GetHostnameRequest) GetInstance() string { + if m != nil && m.Instance != nil { + return *m.Instance + } + return "" +} + +type GetHostnameResponse struct { + Hostname *string `protobuf:"bytes,1,req,name=hostname" json:"hostname,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetHostnameResponse) Reset() { *m = GetHostnameResponse{} } +func (m *GetHostnameResponse) String() string { return proto.CompactTextString(m) } +func (*GetHostnameResponse) ProtoMessage() {} + +func (m *GetHostnameResponse) GetHostname() string { + if m != nil && m.Hostname != nil { + return *m.Hostname + } + return "" +} + +func init() { +} diff --git a/vendor/google.golang.org/appengine/internal/net.go b/vendor/google.golang.org/appengine/internal/net.go new file mode 100644 index 00000000..3b94cf0c --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/net.go @@ -0,0 +1,56 @@ +// Copyright 2014 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +package internal + +// This file implements a network dialer that limits the number of concurrent connections. +// It is only used for API calls. + +import ( + "log" + "net" + "runtime" + "sync" + "time" +) + +var limitSem = make(chan int, 100) // TODO(dsymonds): Use environment variable. + +func limitRelease() { + // non-blocking + select { + case <-limitSem: + default: + // This should not normally happen. + log.Print("appengine: unbalanced limitSem release!") + } +} + +func limitDial(network, addr string) (net.Conn, error) { + limitSem <- 1 + + // Dial with a timeout in case the API host is MIA. + // The connection should normally be very fast. + conn, err := net.DialTimeout(network, addr, 500*time.Millisecond) + if err != nil { + limitRelease() + return nil, err + } + lc := &limitConn{Conn: conn} + runtime.SetFinalizer(lc, (*limitConn).Close) // shouldn't usually be required + return lc, nil +} + +type limitConn struct { + close sync.Once + net.Conn +} + +func (lc *limitConn) Close() error { + defer lc.close.Do(func() { + limitRelease() + runtime.SetFinalizer(lc, nil) + }) + return lc.Conn.Close() +} diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go new file mode 100644 index 00000000..526bd39e --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go @@ -0,0 +1,231 @@ +// Code generated by protoc-gen-go. +// source: google.golang.org/appengine/internal/remote_api/remote_api.proto +// DO NOT EDIT! + +/* +Package remote_api is a generated protocol buffer package. + +It is generated from these files: + google.golang.org/appengine/internal/remote_api/remote_api.proto + +It has these top-level messages: + Request + ApplicationError + RpcError + Response +*/ +package remote_api + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type RpcError_ErrorCode int32 + +const ( + RpcError_UNKNOWN RpcError_ErrorCode = 0 + RpcError_CALL_NOT_FOUND RpcError_ErrorCode = 1 + RpcError_PARSE_ERROR RpcError_ErrorCode = 2 + RpcError_SECURITY_VIOLATION RpcError_ErrorCode = 3 + RpcError_OVER_QUOTA RpcError_ErrorCode = 4 + RpcError_REQUEST_TOO_LARGE RpcError_ErrorCode = 5 + RpcError_CAPABILITY_DISABLED RpcError_ErrorCode = 6 + RpcError_FEATURE_DISABLED RpcError_ErrorCode = 7 + RpcError_BAD_REQUEST RpcError_ErrorCode = 8 + RpcError_RESPONSE_TOO_LARGE RpcError_ErrorCode = 9 + RpcError_CANCELLED RpcError_ErrorCode = 10 + RpcError_REPLAY_ERROR RpcError_ErrorCode = 11 + RpcError_DEADLINE_EXCEEDED RpcError_ErrorCode = 12 +) + +var RpcError_ErrorCode_name = map[int32]string{ + 0: "UNKNOWN", + 1: "CALL_NOT_FOUND", + 2: "PARSE_ERROR", + 3: "SECURITY_VIOLATION", + 4: "OVER_QUOTA", + 5: "REQUEST_TOO_LARGE", + 6: "CAPABILITY_DISABLED", + 7: "FEATURE_DISABLED", + 8: "BAD_REQUEST", + 9: "RESPONSE_TOO_LARGE", + 10: "CANCELLED", + 11: "REPLAY_ERROR", + 12: "DEADLINE_EXCEEDED", +} +var RpcError_ErrorCode_value = map[string]int32{ + "UNKNOWN": 0, + "CALL_NOT_FOUND": 1, + "PARSE_ERROR": 2, + "SECURITY_VIOLATION": 3, + "OVER_QUOTA": 4, + "REQUEST_TOO_LARGE": 5, + "CAPABILITY_DISABLED": 6, + "FEATURE_DISABLED": 7, + "BAD_REQUEST": 8, + "RESPONSE_TOO_LARGE": 9, + "CANCELLED": 10, + "REPLAY_ERROR": 11, + "DEADLINE_EXCEEDED": 12, +} + +func (x RpcError_ErrorCode) Enum() *RpcError_ErrorCode { + p := new(RpcError_ErrorCode) + *p = x + return p +} +func (x RpcError_ErrorCode) String() string { + return proto.EnumName(RpcError_ErrorCode_name, int32(x)) +} +func (x *RpcError_ErrorCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(RpcError_ErrorCode_value, data, "RpcError_ErrorCode") + if err != nil { + return err + } + *x = RpcError_ErrorCode(value) + return nil +} + +type Request struct { + ServiceName *string `protobuf:"bytes,2,req,name=service_name" json:"service_name,omitempty"` + Method *string `protobuf:"bytes,3,req,name=method" json:"method,omitempty"` + Request []byte `protobuf:"bytes,4,req,name=request" json:"request,omitempty"` + RequestId *string `protobuf:"bytes,5,opt,name=request_id" json:"request_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Request) Reset() { *m = Request{} } +func (m *Request) String() string { return proto.CompactTextString(m) } +func (*Request) ProtoMessage() {} + +func (m *Request) GetServiceName() string { + if m != nil && m.ServiceName != nil { + return *m.ServiceName + } + return "" +} + +func (m *Request) GetMethod() string { + if m != nil && m.Method != nil { + return *m.Method + } + return "" +} + +func (m *Request) GetRequest() []byte { + if m != nil { + return m.Request + } + return nil +} + +func (m *Request) GetRequestId() string { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return "" +} + +type ApplicationError struct { + Code *int32 `protobuf:"varint,1,req,name=code" json:"code,omitempty"` + Detail *string `protobuf:"bytes,2,req,name=detail" json:"detail,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ApplicationError) Reset() { *m = ApplicationError{} } +func (m *ApplicationError) String() string { return proto.CompactTextString(m) } +func (*ApplicationError) ProtoMessage() {} + +func (m *ApplicationError) GetCode() int32 { + if m != nil && m.Code != nil { + return *m.Code + } + return 0 +} + +func (m *ApplicationError) GetDetail() string { + if m != nil && m.Detail != nil { + return *m.Detail + } + return "" +} + +type RpcError struct { + Code *int32 `protobuf:"varint,1,req,name=code" json:"code,omitempty"` + Detail *string `protobuf:"bytes,2,opt,name=detail" json:"detail,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RpcError) Reset() { *m = RpcError{} } +func (m *RpcError) String() string { return proto.CompactTextString(m) } +func (*RpcError) ProtoMessage() {} + +func (m *RpcError) GetCode() int32 { + if m != nil && m.Code != nil { + return *m.Code + } + return 0 +} + +func (m *RpcError) GetDetail() string { + if m != nil && m.Detail != nil { + return *m.Detail + } + return "" +} + +type Response struct { + Response []byte `protobuf:"bytes,1,opt,name=response" json:"response,omitempty"` + Exception []byte `protobuf:"bytes,2,opt,name=exception" json:"exception,omitempty"` + ApplicationError *ApplicationError `protobuf:"bytes,3,opt,name=application_error" json:"application_error,omitempty"` + JavaException []byte `protobuf:"bytes,4,opt,name=java_exception" json:"java_exception,omitempty"` + RpcError *RpcError `protobuf:"bytes,5,opt,name=rpc_error" json:"rpc_error,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Response) Reset() { *m = Response{} } +func (m *Response) String() string { return proto.CompactTextString(m) } +func (*Response) ProtoMessage() {} + +func (m *Response) GetResponse() []byte { + if m != nil { + return m.Response + } + return nil +} + +func (m *Response) GetException() []byte { + if m != nil { + return m.Exception + } + return nil +} + +func (m *Response) GetApplicationError() *ApplicationError { + if m != nil { + return m.ApplicationError + } + return nil +} + +func (m *Response) GetJavaException() []byte { + if m != nil { + return m.JavaException + } + return nil +} + +func (m *Response) GetRpcError() *RpcError { + if m != nil { + return m.RpcError + } + return nil +} + +func init() { +} diff --git a/vendor/google.golang.org/appengine/internal/socket/socket_service.pb.go b/vendor/google.golang.org/appengine/internal/socket/socket_service.pb.go new file mode 100644 index 00000000..60628ec9 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/socket/socket_service.pb.go @@ -0,0 +1,1858 @@ +// Code generated by protoc-gen-go. +// source: google.golang.org/appengine/internal/socket/socket_service.proto +// DO NOT EDIT! + +/* +Package socket is a generated protocol buffer package. + +It is generated from these files: + google.golang.org/appengine/internal/socket/socket_service.proto + +It has these top-level messages: + RemoteSocketServiceError + AddressPort + CreateSocketRequest + CreateSocketReply + BindRequest + BindReply + GetSocketNameRequest + GetSocketNameReply + GetPeerNameRequest + GetPeerNameReply + SocketOption + SetSocketOptionsRequest + SetSocketOptionsReply + GetSocketOptionsRequest + GetSocketOptionsReply + ConnectRequest + ConnectReply + ListenRequest + ListenReply + AcceptRequest + AcceptReply + ShutDownRequest + ShutDownReply + CloseRequest + CloseReply + SendRequest + SendReply + ReceiveRequest + ReceiveReply + PollEvent + PollRequest + PollReply + ResolveRequest + ResolveReply +*/ +package socket + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type RemoteSocketServiceError_ErrorCode int32 + +const ( + RemoteSocketServiceError_SYSTEM_ERROR RemoteSocketServiceError_ErrorCode = 1 + RemoteSocketServiceError_GAI_ERROR RemoteSocketServiceError_ErrorCode = 2 + RemoteSocketServiceError_FAILURE RemoteSocketServiceError_ErrorCode = 4 + RemoteSocketServiceError_PERMISSION_DENIED RemoteSocketServiceError_ErrorCode = 5 + RemoteSocketServiceError_INVALID_REQUEST RemoteSocketServiceError_ErrorCode = 6 + RemoteSocketServiceError_SOCKET_CLOSED RemoteSocketServiceError_ErrorCode = 7 +) + +var RemoteSocketServiceError_ErrorCode_name = map[int32]string{ + 1: "SYSTEM_ERROR", + 2: "GAI_ERROR", + 4: "FAILURE", + 5: "PERMISSION_DENIED", + 6: "INVALID_REQUEST", + 7: "SOCKET_CLOSED", +} +var RemoteSocketServiceError_ErrorCode_value = map[string]int32{ + "SYSTEM_ERROR": 1, + "GAI_ERROR": 2, + "FAILURE": 4, + "PERMISSION_DENIED": 5, + "INVALID_REQUEST": 6, + "SOCKET_CLOSED": 7, +} + +func (x RemoteSocketServiceError_ErrorCode) Enum() *RemoteSocketServiceError_ErrorCode { + p := new(RemoteSocketServiceError_ErrorCode) + *p = x + return p +} +func (x RemoteSocketServiceError_ErrorCode) String() string { + return proto.EnumName(RemoteSocketServiceError_ErrorCode_name, int32(x)) +} +func (x *RemoteSocketServiceError_ErrorCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(RemoteSocketServiceError_ErrorCode_value, data, "RemoteSocketServiceError_ErrorCode") + if err != nil { + return err + } + *x = RemoteSocketServiceError_ErrorCode(value) + return nil +} + +type RemoteSocketServiceError_SystemError int32 + +const ( + RemoteSocketServiceError_SYS_SUCCESS RemoteSocketServiceError_SystemError = 0 + RemoteSocketServiceError_SYS_EPERM RemoteSocketServiceError_SystemError = 1 + RemoteSocketServiceError_SYS_ENOENT RemoteSocketServiceError_SystemError = 2 + RemoteSocketServiceError_SYS_ESRCH RemoteSocketServiceError_SystemError = 3 + RemoteSocketServiceError_SYS_EINTR RemoteSocketServiceError_SystemError = 4 + RemoteSocketServiceError_SYS_EIO RemoteSocketServiceError_SystemError = 5 + RemoteSocketServiceError_SYS_ENXIO RemoteSocketServiceError_SystemError = 6 + RemoteSocketServiceError_SYS_E2BIG RemoteSocketServiceError_SystemError = 7 + RemoteSocketServiceError_SYS_ENOEXEC RemoteSocketServiceError_SystemError = 8 + RemoteSocketServiceError_SYS_EBADF RemoteSocketServiceError_SystemError = 9 + RemoteSocketServiceError_SYS_ECHILD RemoteSocketServiceError_SystemError = 10 + RemoteSocketServiceError_SYS_EAGAIN RemoteSocketServiceError_SystemError = 11 + RemoteSocketServiceError_SYS_EWOULDBLOCK RemoteSocketServiceError_SystemError = 11 + RemoteSocketServiceError_SYS_ENOMEM RemoteSocketServiceError_SystemError = 12 + RemoteSocketServiceError_SYS_EACCES RemoteSocketServiceError_SystemError = 13 + RemoteSocketServiceError_SYS_EFAULT RemoteSocketServiceError_SystemError = 14 + RemoteSocketServiceError_SYS_ENOTBLK RemoteSocketServiceError_SystemError = 15 + RemoteSocketServiceError_SYS_EBUSY RemoteSocketServiceError_SystemError = 16 + RemoteSocketServiceError_SYS_EEXIST RemoteSocketServiceError_SystemError = 17 + RemoteSocketServiceError_SYS_EXDEV RemoteSocketServiceError_SystemError = 18 + RemoteSocketServiceError_SYS_ENODEV RemoteSocketServiceError_SystemError = 19 + RemoteSocketServiceError_SYS_ENOTDIR RemoteSocketServiceError_SystemError = 20 + RemoteSocketServiceError_SYS_EISDIR RemoteSocketServiceError_SystemError = 21 + RemoteSocketServiceError_SYS_EINVAL RemoteSocketServiceError_SystemError = 22 + RemoteSocketServiceError_SYS_ENFILE RemoteSocketServiceError_SystemError = 23 + RemoteSocketServiceError_SYS_EMFILE RemoteSocketServiceError_SystemError = 24 + RemoteSocketServiceError_SYS_ENOTTY RemoteSocketServiceError_SystemError = 25 + RemoteSocketServiceError_SYS_ETXTBSY RemoteSocketServiceError_SystemError = 26 + RemoteSocketServiceError_SYS_EFBIG RemoteSocketServiceError_SystemError = 27 + RemoteSocketServiceError_SYS_ENOSPC RemoteSocketServiceError_SystemError = 28 + RemoteSocketServiceError_SYS_ESPIPE RemoteSocketServiceError_SystemError = 29 + RemoteSocketServiceError_SYS_EROFS RemoteSocketServiceError_SystemError = 30 + RemoteSocketServiceError_SYS_EMLINK RemoteSocketServiceError_SystemError = 31 + RemoteSocketServiceError_SYS_EPIPE RemoteSocketServiceError_SystemError = 32 + RemoteSocketServiceError_SYS_EDOM RemoteSocketServiceError_SystemError = 33 + RemoteSocketServiceError_SYS_ERANGE RemoteSocketServiceError_SystemError = 34 + RemoteSocketServiceError_SYS_EDEADLK RemoteSocketServiceError_SystemError = 35 + RemoteSocketServiceError_SYS_EDEADLOCK RemoteSocketServiceError_SystemError = 35 + RemoteSocketServiceError_SYS_ENAMETOOLONG RemoteSocketServiceError_SystemError = 36 + RemoteSocketServiceError_SYS_ENOLCK RemoteSocketServiceError_SystemError = 37 + RemoteSocketServiceError_SYS_ENOSYS RemoteSocketServiceError_SystemError = 38 + RemoteSocketServiceError_SYS_ENOTEMPTY RemoteSocketServiceError_SystemError = 39 + RemoteSocketServiceError_SYS_ELOOP RemoteSocketServiceError_SystemError = 40 + RemoteSocketServiceError_SYS_ENOMSG RemoteSocketServiceError_SystemError = 42 + RemoteSocketServiceError_SYS_EIDRM RemoteSocketServiceError_SystemError = 43 + RemoteSocketServiceError_SYS_ECHRNG RemoteSocketServiceError_SystemError = 44 + RemoteSocketServiceError_SYS_EL2NSYNC RemoteSocketServiceError_SystemError = 45 + RemoteSocketServiceError_SYS_EL3HLT RemoteSocketServiceError_SystemError = 46 + RemoteSocketServiceError_SYS_EL3RST RemoteSocketServiceError_SystemError = 47 + RemoteSocketServiceError_SYS_ELNRNG RemoteSocketServiceError_SystemError = 48 + RemoteSocketServiceError_SYS_EUNATCH RemoteSocketServiceError_SystemError = 49 + RemoteSocketServiceError_SYS_ENOCSI RemoteSocketServiceError_SystemError = 50 + RemoteSocketServiceError_SYS_EL2HLT RemoteSocketServiceError_SystemError = 51 + RemoteSocketServiceError_SYS_EBADE RemoteSocketServiceError_SystemError = 52 + RemoteSocketServiceError_SYS_EBADR RemoteSocketServiceError_SystemError = 53 + RemoteSocketServiceError_SYS_EXFULL RemoteSocketServiceError_SystemError = 54 + RemoteSocketServiceError_SYS_ENOANO RemoteSocketServiceError_SystemError = 55 + RemoteSocketServiceError_SYS_EBADRQC RemoteSocketServiceError_SystemError = 56 + RemoteSocketServiceError_SYS_EBADSLT RemoteSocketServiceError_SystemError = 57 + RemoteSocketServiceError_SYS_EBFONT RemoteSocketServiceError_SystemError = 59 + RemoteSocketServiceError_SYS_ENOSTR RemoteSocketServiceError_SystemError = 60 + RemoteSocketServiceError_SYS_ENODATA RemoteSocketServiceError_SystemError = 61 + RemoteSocketServiceError_SYS_ETIME RemoteSocketServiceError_SystemError = 62 + RemoteSocketServiceError_SYS_ENOSR RemoteSocketServiceError_SystemError = 63 + RemoteSocketServiceError_SYS_ENONET RemoteSocketServiceError_SystemError = 64 + RemoteSocketServiceError_SYS_ENOPKG RemoteSocketServiceError_SystemError = 65 + RemoteSocketServiceError_SYS_EREMOTE RemoteSocketServiceError_SystemError = 66 + RemoteSocketServiceError_SYS_ENOLINK RemoteSocketServiceError_SystemError = 67 + RemoteSocketServiceError_SYS_EADV RemoteSocketServiceError_SystemError = 68 + RemoteSocketServiceError_SYS_ESRMNT RemoteSocketServiceError_SystemError = 69 + RemoteSocketServiceError_SYS_ECOMM RemoteSocketServiceError_SystemError = 70 + RemoteSocketServiceError_SYS_EPROTO RemoteSocketServiceError_SystemError = 71 + RemoteSocketServiceError_SYS_EMULTIHOP RemoteSocketServiceError_SystemError = 72 + RemoteSocketServiceError_SYS_EDOTDOT RemoteSocketServiceError_SystemError = 73 + RemoteSocketServiceError_SYS_EBADMSG RemoteSocketServiceError_SystemError = 74 + RemoteSocketServiceError_SYS_EOVERFLOW RemoteSocketServiceError_SystemError = 75 + RemoteSocketServiceError_SYS_ENOTUNIQ RemoteSocketServiceError_SystemError = 76 + RemoteSocketServiceError_SYS_EBADFD RemoteSocketServiceError_SystemError = 77 + RemoteSocketServiceError_SYS_EREMCHG RemoteSocketServiceError_SystemError = 78 + RemoteSocketServiceError_SYS_ELIBACC RemoteSocketServiceError_SystemError = 79 + RemoteSocketServiceError_SYS_ELIBBAD RemoteSocketServiceError_SystemError = 80 + RemoteSocketServiceError_SYS_ELIBSCN RemoteSocketServiceError_SystemError = 81 + RemoteSocketServiceError_SYS_ELIBMAX RemoteSocketServiceError_SystemError = 82 + RemoteSocketServiceError_SYS_ELIBEXEC RemoteSocketServiceError_SystemError = 83 + RemoteSocketServiceError_SYS_EILSEQ RemoteSocketServiceError_SystemError = 84 + RemoteSocketServiceError_SYS_ERESTART RemoteSocketServiceError_SystemError = 85 + RemoteSocketServiceError_SYS_ESTRPIPE RemoteSocketServiceError_SystemError = 86 + RemoteSocketServiceError_SYS_EUSERS RemoteSocketServiceError_SystemError = 87 + RemoteSocketServiceError_SYS_ENOTSOCK RemoteSocketServiceError_SystemError = 88 + RemoteSocketServiceError_SYS_EDESTADDRREQ RemoteSocketServiceError_SystemError = 89 + RemoteSocketServiceError_SYS_EMSGSIZE RemoteSocketServiceError_SystemError = 90 + RemoteSocketServiceError_SYS_EPROTOTYPE RemoteSocketServiceError_SystemError = 91 + RemoteSocketServiceError_SYS_ENOPROTOOPT RemoteSocketServiceError_SystemError = 92 + RemoteSocketServiceError_SYS_EPROTONOSUPPORT RemoteSocketServiceError_SystemError = 93 + RemoteSocketServiceError_SYS_ESOCKTNOSUPPORT RemoteSocketServiceError_SystemError = 94 + RemoteSocketServiceError_SYS_EOPNOTSUPP RemoteSocketServiceError_SystemError = 95 + RemoteSocketServiceError_SYS_ENOTSUP RemoteSocketServiceError_SystemError = 95 + RemoteSocketServiceError_SYS_EPFNOSUPPORT RemoteSocketServiceError_SystemError = 96 + RemoteSocketServiceError_SYS_EAFNOSUPPORT RemoteSocketServiceError_SystemError = 97 + RemoteSocketServiceError_SYS_EADDRINUSE RemoteSocketServiceError_SystemError = 98 + RemoteSocketServiceError_SYS_EADDRNOTAVAIL RemoteSocketServiceError_SystemError = 99 + RemoteSocketServiceError_SYS_ENETDOWN RemoteSocketServiceError_SystemError = 100 + RemoteSocketServiceError_SYS_ENETUNREACH RemoteSocketServiceError_SystemError = 101 + RemoteSocketServiceError_SYS_ENETRESET RemoteSocketServiceError_SystemError = 102 + RemoteSocketServiceError_SYS_ECONNABORTED RemoteSocketServiceError_SystemError = 103 + RemoteSocketServiceError_SYS_ECONNRESET RemoteSocketServiceError_SystemError = 104 + RemoteSocketServiceError_SYS_ENOBUFS RemoteSocketServiceError_SystemError = 105 + RemoteSocketServiceError_SYS_EISCONN RemoteSocketServiceError_SystemError = 106 + RemoteSocketServiceError_SYS_ENOTCONN RemoteSocketServiceError_SystemError = 107 + RemoteSocketServiceError_SYS_ESHUTDOWN RemoteSocketServiceError_SystemError = 108 + RemoteSocketServiceError_SYS_ETOOMANYREFS RemoteSocketServiceError_SystemError = 109 + RemoteSocketServiceError_SYS_ETIMEDOUT RemoteSocketServiceError_SystemError = 110 + RemoteSocketServiceError_SYS_ECONNREFUSED RemoteSocketServiceError_SystemError = 111 + RemoteSocketServiceError_SYS_EHOSTDOWN RemoteSocketServiceError_SystemError = 112 + RemoteSocketServiceError_SYS_EHOSTUNREACH RemoteSocketServiceError_SystemError = 113 + RemoteSocketServiceError_SYS_EALREADY RemoteSocketServiceError_SystemError = 114 + RemoteSocketServiceError_SYS_EINPROGRESS RemoteSocketServiceError_SystemError = 115 + RemoteSocketServiceError_SYS_ESTALE RemoteSocketServiceError_SystemError = 116 + RemoteSocketServiceError_SYS_EUCLEAN RemoteSocketServiceError_SystemError = 117 + RemoteSocketServiceError_SYS_ENOTNAM RemoteSocketServiceError_SystemError = 118 + RemoteSocketServiceError_SYS_ENAVAIL RemoteSocketServiceError_SystemError = 119 + RemoteSocketServiceError_SYS_EISNAM RemoteSocketServiceError_SystemError = 120 + RemoteSocketServiceError_SYS_EREMOTEIO RemoteSocketServiceError_SystemError = 121 + RemoteSocketServiceError_SYS_EDQUOT RemoteSocketServiceError_SystemError = 122 + RemoteSocketServiceError_SYS_ENOMEDIUM RemoteSocketServiceError_SystemError = 123 + RemoteSocketServiceError_SYS_EMEDIUMTYPE RemoteSocketServiceError_SystemError = 124 + RemoteSocketServiceError_SYS_ECANCELED RemoteSocketServiceError_SystemError = 125 + RemoteSocketServiceError_SYS_ENOKEY RemoteSocketServiceError_SystemError = 126 + RemoteSocketServiceError_SYS_EKEYEXPIRED RemoteSocketServiceError_SystemError = 127 + RemoteSocketServiceError_SYS_EKEYREVOKED RemoteSocketServiceError_SystemError = 128 + RemoteSocketServiceError_SYS_EKEYREJECTED RemoteSocketServiceError_SystemError = 129 + RemoteSocketServiceError_SYS_EOWNERDEAD RemoteSocketServiceError_SystemError = 130 + RemoteSocketServiceError_SYS_ENOTRECOVERABLE RemoteSocketServiceError_SystemError = 131 + RemoteSocketServiceError_SYS_ERFKILL RemoteSocketServiceError_SystemError = 132 +) + +var RemoteSocketServiceError_SystemError_name = map[int32]string{ + 0: "SYS_SUCCESS", + 1: "SYS_EPERM", + 2: "SYS_ENOENT", + 3: "SYS_ESRCH", + 4: "SYS_EINTR", + 5: "SYS_EIO", + 6: "SYS_ENXIO", + 7: "SYS_E2BIG", + 8: "SYS_ENOEXEC", + 9: "SYS_EBADF", + 10: "SYS_ECHILD", + 11: "SYS_EAGAIN", + // Duplicate value: 11: "SYS_EWOULDBLOCK", + 12: "SYS_ENOMEM", + 13: "SYS_EACCES", + 14: "SYS_EFAULT", + 15: "SYS_ENOTBLK", + 16: "SYS_EBUSY", + 17: "SYS_EEXIST", + 18: "SYS_EXDEV", + 19: "SYS_ENODEV", + 20: "SYS_ENOTDIR", + 21: "SYS_EISDIR", + 22: "SYS_EINVAL", + 23: "SYS_ENFILE", + 24: "SYS_EMFILE", + 25: "SYS_ENOTTY", + 26: "SYS_ETXTBSY", + 27: "SYS_EFBIG", + 28: "SYS_ENOSPC", + 29: "SYS_ESPIPE", + 30: "SYS_EROFS", + 31: "SYS_EMLINK", + 32: "SYS_EPIPE", + 33: "SYS_EDOM", + 34: "SYS_ERANGE", + 35: "SYS_EDEADLK", + // Duplicate value: 35: "SYS_EDEADLOCK", + 36: "SYS_ENAMETOOLONG", + 37: "SYS_ENOLCK", + 38: "SYS_ENOSYS", + 39: "SYS_ENOTEMPTY", + 40: "SYS_ELOOP", + 42: "SYS_ENOMSG", + 43: "SYS_EIDRM", + 44: "SYS_ECHRNG", + 45: "SYS_EL2NSYNC", + 46: "SYS_EL3HLT", + 47: "SYS_EL3RST", + 48: "SYS_ELNRNG", + 49: "SYS_EUNATCH", + 50: "SYS_ENOCSI", + 51: "SYS_EL2HLT", + 52: "SYS_EBADE", + 53: "SYS_EBADR", + 54: "SYS_EXFULL", + 55: "SYS_ENOANO", + 56: "SYS_EBADRQC", + 57: "SYS_EBADSLT", + 59: "SYS_EBFONT", + 60: "SYS_ENOSTR", + 61: "SYS_ENODATA", + 62: "SYS_ETIME", + 63: "SYS_ENOSR", + 64: "SYS_ENONET", + 65: "SYS_ENOPKG", + 66: "SYS_EREMOTE", + 67: "SYS_ENOLINK", + 68: "SYS_EADV", + 69: "SYS_ESRMNT", + 70: "SYS_ECOMM", + 71: "SYS_EPROTO", + 72: "SYS_EMULTIHOP", + 73: "SYS_EDOTDOT", + 74: "SYS_EBADMSG", + 75: "SYS_EOVERFLOW", + 76: "SYS_ENOTUNIQ", + 77: "SYS_EBADFD", + 78: "SYS_EREMCHG", + 79: "SYS_ELIBACC", + 80: "SYS_ELIBBAD", + 81: "SYS_ELIBSCN", + 82: "SYS_ELIBMAX", + 83: "SYS_ELIBEXEC", + 84: "SYS_EILSEQ", + 85: "SYS_ERESTART", + 86: "SYS_ESTRPIPE", + 87: "SYS_EUSERS", + 88: "SYS_ENOTSOCK", + 89: "SYS_EDESTADDRREQ", + 90: "SYS_EMSGSIZE", + 91: "SYS_EPROTOTYPE", + 92: "SYS_ENOPROTOOPT", + 93: "SYS_EPROTONOSUPPORT", + 94: "SYS_ESOCKTNOSUPPORT", + 95: "SYS_EOPNOTSUPP", + // Duplicate value: 95: "SYS_ENOTSUP", + 96: "SYS_EPFNOSUPPORT", + 97: "SYS_EAFNOSUPPORT", + 98: "SYS_EADDRINUSE", + 99: "SYS_EADDRNOTAVAIL", + 100: "SYS_ENETDOWN", + 101: "SYS_ENETUNREACH", + 102: "SYS_ENETRESET", + 103: "SYS_ECONNABORTED", + 104: "SYS_ECONNRESET", + 105: "SYS_ENOBUFS", + 106: "SYS_EISCONN", + 107: "SYS_ENOTCONN", + 108: "SYS_ESHUTDOWN", + 109: "SYS_ETOOMANYREFS", + 110: "SYS_ETIMEDOUT", + 111: "SYS_ECONNREFUSED", + 112: "SYS_EHOSTDOWN", + 113: "SYS_EHOSTUNREACH", + 114: "SYS_EALREADY", + 115: "SYS_EINPROGRESS", + 116: "SYS_ESTALE", + 117: "SYS_EUCLEAN", + 118: "SYS_ENOTNAM", + 119: "SYS_ENAVAIL", + 120: "SYS_EISNAM", + 121: "SYS_EREMOTEIO", + 122: "SYS_EDQUOT", + 123: "SYS_ENOMEDIUM", + 124: "SYS_EMEDIUMTYPE", + 125: "SYS_ECANCELED", + 126: "SYS_ENOKEY", + 127: "SYS_EKEYEXPIRED", + 128: "SYS_EKEYREVOKED", + 129: "SYS_EKEYREJECTED", + 130: "SYS_EOWNERDEAD", + 131: "SYS_ENOTRECOVERABLE", + 132: "SYS_ERFKILL", +} +var RemoteSocketServiceError_SystemError_value = map[string]int32{ + "SYS_SUCCESS": 0, + "SYS_EPERM": 1, + "SYS_ENOENT": 2, + "SYS_ESRCH": 3, + "SYS_EINTR": 4, + "SYS_EIO": 5, + "SYS_ENXIO": 6, + "SYS_E2BIG": 7, + "SYS_ENOEXEC": 8, + "SYS_EBADF": 9, + "SYS_ECHILD": 10, + "SYS_EAGAIN": 11, + "SYS_EWOULDBLOCK": 11, + "SYS_ENOMEM": 12, + "SYS_EACCES": 13, + "SYS_EFAULT": 14, + "SYS_ENOTBLK": 15, + "SYS_EBUSY": 16, + "SYS_EEXIST": 17, + "SYS_EXDEV": 18, + "SYS_ENODEV": 19, + "SYS_ENOTDIR": 20, + "SYS_EISDIR": 21, + "SYS_EINVAL": 22, + "SYS_ENFILE": 23, + "SYS_EMFILE": 24, + "SYS_ENOTTY": 25, + "SYS_ETXTBSY": 26, + "SYS_EFBIG": 27, + "SYS_ENOSPC": 28, + "SYS_ESPIPE": 29, + "SYS_EROFS": 30, + "SYS_EMLINK": 31, + "SYS_EPIPE": 32, + "SYS_EDOM": 33, + "SYS_ERANGE": 34, + "SYS_EDEADLK": 35, + "SYS_EDEADLOCK": 35, + "SYS_ENAMETOOLONG": 36, + "SYS_ENOLCK": 37, + "SYS_ENOSYS": 38, + "SYS_ENOTEMPTY": 39, + "SYS_ELOOP": 40, + "SYS_ENOMSG": 42, + "SYS_EIDRM": 43, + "SYS_ECHRNG": 44, + "SYS_EL2NSYNC": 45, + "SYS_EL3HLT": 46, + "SYS_EL3RST": 47, + "SYS_ELNRNG": 48, + "SYS_EUNATCH": 49, + "SYS_ENOCSI": 50, + "SYS_EL2HLT": 51, + "SYS_EBADE": 52, + "SYS_EBADR": 53, + "SYS_EXFULL": 54, + "SYS_ENOANO": 55, + "SYS_EBADRQC": 56, + "SYS_EBADSLT": 57, + "SYS_EBFONT": 59, + "SYS_ENOSTR": 60, + "SYS_ENODATA": 61, + "SYS_ETIME": 62, + "SYS_ENOSR": 63, + "SYS_ENONET": 64, + "SYS_ENOPKG": 65, + "SYS_EREMOTE": 66, + "SYS_ENOLINK": 67, + "SYS_EADV": 68, + "SYS_ESRMNT": 69, + "SYS_ECOMM": 70, + "SYS_EPROTO": 71, + "SYS_EMULTIHOP": 72, + "SYS_EDOTDOT": 73, + "SYS_EBADMSG": 74, + "SYS_EOVERFLOW": 75, + "SYS_ENOTUNIQ": 76, + "SYS_EBADFD": 77, + "SYS_EREMCHG": 78, + "SYS_ELIBACC": 79, + "SYS_ELIBBAD": 80, + "SYS_ELIBSCN": 81, + "SYS_ELIBMAX": 82, + "SYS_ELIBEXEC": 83, + "SYS_EILSEQ": 84, + "SYS_ERESTART": 85, + "SYS_ESTRPIPE": 86, + "SYS_EUSERS": 87, + "SYS_ENOTSOCK": 88, + "SYS_EDESTADDRREQ": 89, + "SYS_EMSGSIZE": 90, + "SYS_EPROTOTYPE": 91, + "SYS_ENOPROTOOPT": 92, + "SYS_EPROTONOSUPPORT": 93, + "SYS_ESOCKTNOSUPPORT": 94, + "SYS_EOPNOTSUPP": 95, + "SYS_ENOTSUP": 95, + "SYS_EPFNOSUPPORT": 96, + "SYS_EAFNOSUPPORT": 97, + "SYS_EADDRINUSE": 98, + "SYS_EADDRNOTAVAIL": 99, + "SYS_ENETDOWN": 100, + "SYS_ENETUNREACH": 101, + "SYS_ENETRESET": 102, + "SYS_ECONNABORTED": 103, + "SYS_ECONNRESET": 104, + "SYS_ENOBUFS": 105, + "SYS_EISCONN": 106, + "SYS_ENOTCONN": 107, + "SYS_ESHUTDOWN": 108, + "SYS_ETOOMANYREFS": 109, + "SYS_ETIMEDOUT": 110, + "SYS_ECONNREFUSED": 111, + "SYS_EHOSTDOWN": 112, + "SYS_EHOSTUNREACH": 113, + "SYS_EALREADY": 114, + "SYS_EINPROGRESS": 115, + "SYS_ESTALE": 116, + "SYS_EUCLEAN": 117, + "SYS_ENOTNAM": 118, + "SYS_ENAVAIL": 119, + "SYS_EISNAM": 120, + "SYS_EREMOTEIO": 121, + "SYS_EDQUOT": 122, + "SYS_ENOMEDIUM": 123, + "SYS_EMEDIUMTYPE": 124, + "SYS_ECANCELED": 125, + "SYS_ENOKEY": 126, + "SYS_EKEYEXPIRED": 127, + "SYS_EKEYREVOKED": 128, + "SYS_EKEYREJECTED": 129, + "SYS_EOWNERDEAD": 130, + "SYS_ENOTRECOVERABLE": 131, + "SYS_ERFKILL": 132, +} + +func (x RemoteSocketServiceError_SystemError) Enum() *RemoteSocketServiceError_SystemError { + p := new(RemoteSocketServiceError_SystemError) + *p = x + return p +} +func (x RemoteSocketServiceError_SystemError) String() string { + return proto.EnumName(RemoteSocketServiceError_SystemError_name, int32(x)) +} +func (x *RemoteSocketServiceError_SystemError) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(RemoteSocketServiceError_SystemError_value, data, "RemoteSocketServiceError_SystemError") + if err != nil { + return err + } + *x = RemoteSocketServiceError_SystemError(value) + return nil +} + +type CreateSocketRequest_SocketFamily int32 + +const ( + CreateSocketRequest_IPv4 CreateSocketRequest_SocketFamily = 1 + CreateSocketRequest_IPv6 CreateSocketRequest_SocketFamily = 2 +) + +var CreateSocketRequest_SocketFamily_name = map[int32]string{ + 1: "IPv4", + 2: "IPv6", +} +var CreateSocketRequest_SocketFamily_value = map[string]int32{ + "IPv4": 1, + "IPv6": 2, +} + +func (x CreateSocketRequest_SocketFamily) Enum() *CreateSocketRequest_SocketFamily { + p := new(CreateSocketRequest_SocketFamily) + *p = x + return p +} +func (x CreateSocketRequest_SocketFamily) String() string { + return proto.EnumName(CreateSocketRequest_SocketFamily_name, int32(x)) +} +func (x *CreateSocketRequest_SocketFamily) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CreateSocketRequest_SocketFamily_value, data, "CreateSocketRequest_SocketFamily") + if err != nil { + return err + } + *x = CreateSocketRequest_SocketFamily(value) + return nil +} + +type CreateSocketRequest_SocketProtocol int32 + +const ( + CreateSocketRequest_TCP CreateSocketRequest_SocketProtocol = 1 + CreateSocketRequest_UDP CreateSocketRequest_SocketProtocol = 2 +) + +var CreateSocketRequest_SocketProtocol_name = map[int32]string{ + 1: "TCP", + 2: "UDP", +} +var CreateSocketRequest_SocketProtocol_value = map[string]int32{ + "TCP": 1, + "UDP": 2, +} + +func (x CreateSocketRequest_SocketProtocol) Enum() *CreateSocketRequest_SocketProtocol { + p := new(CreateSocketRequest_SocketProtocol) + *p = x + return p +} +func (x CreateSocketRequest_SocketProtocol) String() string { + return proto.EnumName(CreateSocketRequest_SocketProtocol_name, int32(x)) +} +func (x *CreateSocketRequest_SocketProtocol) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CreateSocketRequest_SocketProtocol_value, data, "CreateSocketRequest_SocketProtocol") + if err != nil { + return err + } + *x = CreateSocketRequest_SocketProtocol(value) + return nil +} + +type SocketOption_SocketOptionLevel int32 + +const ( + SocketOption_SOCKET_SOL_IP SocketOption_SocketOptionLevel = 0 + SocketOption_SOCKET_SOL_SOCKET SocketOption_SocketOptionLevel = 1 + SocketOption_SOCKET_SOL_TCP SocketOption_SocketOptionLevel = 6 + SocketOption_SOCKET_SOL_UDP SocketOption_SocketOptionLevel = 17 +) + +var SocketOption_SocketOptionLevel_name = map[int32]string{ + 0: "SOCKET_SOL_IP", + 1: "SOCKET_SOL_SOCKET", + 6: "SOCKET_SOL_TCP", + 17: "SOCKET_SOL_UDP", +} +var SocketOption_SocketOptionLevel_value = map[string]int32{ + "SOCKET_SOL_IP": 0, + "SOCKET_SOL_SOCKET": 1, + "SOCKET_SOL_TCP": 6, + "SOCKET_SOL_UDP": 17, +} + +func (x SocketOption_SocketOptionLevel) Enum() *SocketOption_SocketOptionLevel { + p := new(SocketOption_SocketOptionLevel) + *p = x + return p +} +func (x SocketOption_SocketOptionLevel) String() string { + return proto.EnumName(SocketOption_SocketOptionLevel_name, int32(x)) +} +func (x *SocketOption_SocketOptionLevel) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(SocketOption_SocketOptionLevel_value, data, "SocketOption_SocketOptionLevel") + if err != nil { + return err + } + *x = SocketOption_SocketOptionLevel(value) + return nil +} + +type SocketOption_SocketOptionName int32 + +const ( + SocketOption_SOCKET_SO_DEBUG SocketOption_SocketOptionName = 1 + SocketOption_SOCKET_SO_REUSEADDR SocketOption_SocketOptionName = 2 + SocketOption_SOCKET_SO_TYPE SocketOption_SocketOptionName = 3 + SocketOption_SOCKET_SO_ERROR SocketOption_SocketOptionName = 4 + SocketOption_SOCKET_SO_DONTROUTE SocketOption_SocketOptionName = 5 + SocketOption_SOCKET_SO_BROADCAST SocketOption_SocketOptionName = 6 + SocketOption_SOCKET_SO_SNDBUF SocketOption_SocketOptionName = 7 + SocketOption_SOCKET_SO_RCVBUF SocketOption_SocketOptionName = 8 + SocketOption_SOCKET_SO_KEEPALIVE SocketOption_SocketOptionName = 9 + SocketOption_SOCKET_SO_OOBINLINE SocketOption_SocketOptionName = 10 + SocketOption_SOCKET_SO_LINGER SocketOption_SocketOptionName = 13 + SocketOption_SOCKET_SO_RCVTIMEO SocketOption_SocketOptionName = 20 + SocketOption_SOCKET_SO_SNDTIMEO SocketOption_SocketOptionName = 21 + SocketOption_SOCKET_IP_TOS SocketOption_SocketOptionName = 1 + SocketOption_SOCKET_IP_TTL SocketOption_SocketOptionName = 2 + SocketOption_SOCKET_IP_HDRINCL SocketOption_SocketOptionName = 3 + SocketOption_SOCKET_IP_OPTIONS SocketOption_SocketOptionName = 4 + SocketOption_SOCKET_TCP_NODELAY SocketOption_SocketOptionName = 1 + SocketOption_SOCKET_TCP_MAXSEG SocketOption_SocketOptionName = 2 + SocketOption_SOCKET_TCP_CORK SocketOption_SocketOptionName = 3 + SocketOption_SOCKET_TCP_KEEPIDLE SocketOption_SocketOptionName = 4 + SocketOption_SOCKET_TCP_KEEPINTVL SocketOption_SocketOptionName = 5 + SocketOption_SOCKET_TCP_KEEPCNT SocketOption_SocketOptionName = 6 + SocketOption_SOCKET_TCP_SYNCNT SocketOption_SocketOptionName = 7 + SocketOption_SOCKET_TCP_LINGER2 SocketOption_SocketOptionName = 8 + SocketOption_SOCKET_TCP_DEFER_ACCEPT SocketOption_SocketOptionName = 9 + SocketOption_SOCKET_TCP_WINDOW_CLAMP SocketOption_SocketOptionName = 10 + SocketOption_SOCKET_TCP_INFO SocketOption_SocketOptionName = 11 + SocketOption_SOCKET_TCP_QUICKACK SocketOption_SocketOptionName = 12 +) + +var SocketOption_SocketOptionName_name = map[int32]string{ + 1: "SOCKET_SO_DEBUG", + 2: "SOCKET_SO_REUSEADDR", + 3: "SOCKET_SO_TYPE", + 4: "SOCKET_SO_ERROR", + 5: "SOCKET_SO_DONTROUTE", + 6: "SOCKET_SO_BROADCAST", + 7: "SOCKET_SO_SNDBUF", + 8: "SOCKET_SO_RCVBUF", + 9: "SOCKET_SO_KEEPALIVE", + 10: "SOCKET_SO_OOBINLINE", + 13: "SOCKET_SO_LINGER", + 20: "SOCKET_SO_RCVTIMEO", + 21: "SOCKET_SO_SNDTIMEO", + // Duplicate value: 1: "SOCKET_IP_TOS", + // Duplicate value: 2: "SOCKET_IP_TTL", + // Duplicate value: 3: "SOCKET_IP_HDRINCL", + // Duplicate value: 4: "SOCKET_IP_OPTIONS", + // Duplicate value: 1: "SOCKET_TCP_NODELAY", + // Duplicate value: 2: "SOCKET_TCP_MAXSEG", + // Duplicate value: 3: "SOCKET_TCP_CORK", + // Duplicate value: 4: "SOCKET_TCP_KEEPIDLE", + // Duplicate value: 5: "SOCKET_TCP_KEEPINTVL", + // Duplicate value: 6: "SOCKET_TCP_KEEPCNT", + // Duplicate value: 7: "SOCKET_TCP_SYNCNT", + // Duplicate value: 8: "SOCKET_TCP_LINGER2", + // Duplicate value: 9: "SOCKET_TCP_DEFER_ACCEPT", + // Duplicate value: 10: "SOCKET_TCP_WINDOW_CLAMP", + 11: "SOCKET_TCP_INFO", + 12: "SOCKET_TCP_QUICKACK", +} +var SocketOption_SocketOptionName_value = map[string]int32{ + "SOCKET_SO_DEBUG": 1, + "SOCKET_SO_REUSEADDR": 2, + "SOCKET_SO_TYPE": 3, + "SOCKET_SO_ERROR": 4, + "SOCKET_SO_DONTROUTE": 5, + "SOCKET_SO_BROADCAST": 6, + "SOCKET_SO_SNDBUF": 7, + "SOCKET_SO_RCVBUF": 8, + "SOCKET_SO_KEEPALIVE": 9, + "SOCKET_SO_OOBINLINE": 10, + "SOCKET_SO_LINGER": 13, + "SOCKET_SO_RCVTIMEO": 20, + "SOCKET_SO_SNDTIMEO": 21, + "SOCKET_IP_TOS": 1, + "SOCKET_IP_TTL": 2, + "SOCKET_IP_HDRINCL": 3, + "SOCKET_IP_OPTIONS": 4, + "SOCKET_TCP_NODELAY": 1, + "SOCKET_TCP_MAXSEG": 2, + "SOCKET_TCP_CORK": 3, + "SOCKET_TCP_KEEPIDLE": 4, + "SOCKET_TCP_KEEPINTVL": 5, + "SOCKET_TCP_KEEPCNT": 6, + "SOCKET_TCP_SYNCNT": 7, + "SOCKET_TCP_LINGER2": 8, + "SOCKET_TCP_DEFER_ACCEPT": 9, + "SOCKET_TCP_WINDOW_CLAMP": 10, + "SOCKET_TCP_INFO": 11, + "SOCKET_TCP_QUICKACK": 12, +} + +func (x SocketOption_SocketOptionName) Enum() *SocketOption_SocketOptionName { + p := new(SocketOption_SocketOptionName) + *p = x + return p +} +func (x SocketOption_SocketOptionName) String() string { + return proto.EnumName(SocketOption_SocketOptionName_name, int32(x)) +} +func (x *SocketOption_SocketOptionName) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(SocketOption_SocketOptionName_value, data, "SocketOption_SocketOptionName") + if err != nil { + return err + } + *x = SocketOption_SocketOptionName(value) + return nil +} + +type ShutDownRequest_How int32 + +const ( + ShutDownRequest_SOCKET_SHUT_RD ShutDownRequest_How = 1 + ShutDownRequest_SOCKET_SHUT_WR ShutDownRequest_How = 2 + ShutDownRequest_SOCKET_SHUT_RDWR ShutDownRequest_How = 3 +) + +var ShutDownRequest_How_name = map[int32]string{ + 1: "SOCKET_SHUT_RD", + 2: "SOCKET_SHUT_WR", + 3: "SOCKET_SHUT_RDWR", +} +var ShutDownRequest_How_value = map[string]int32{ + "SOCKET_SHUT_RD": 1, + "SOCKET_SHUT_WR": 2, + "SOCKET_SHUT_RDWR": 3, +} + +func (x ShutDownRequest_How) Enum() *ShutDownRequest_How { + p := new(ShutDownRequest_How) + *p = x + return p +} +func (x ShutDownRequest_How) String() string { + return proto.EnumName(ShutDownRequest_How_name, int32(x)) +} +func (x *ShutDownRequest_How) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ShutDownRequest_How_value, data, "ShutDownRequest_How") + if err != nil { + return err + } + *x = ShutDownRequest_How(value) + return nil +} + +type ReceiveRequest_Flags int32 + +const ( + ReceiveRequest_MSG_OOB ReceiveRequest_Flags = 1 + ReceiveRequest_MSG_PEEK ReceiveRequest_Flags = 2 +) + +var ReceiveRequest_Flags_name = map[int32]string{ + 1: "MSG_OOB", + 2: "MSG_PEEK", +} +var ReceiveRequest_Flags_value = map[string]int32{ + "MSG_OOB": 1, + "MSG_PEEK": 2, +} + +func (x ReceiveRequest_Flags) Enum() *ReceiveRequest_Flags { + p := new(ReceiveRequest_Flags) + *p = x + return p +} +func (x ReceiveRequest_Flags) String() string { + return proto.EnumName(ReceiveRequest_Flags_name, int32(x)) +} +func (x *ReceiveRequest_Flags) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ReceiveRequest_Flags_value, data, "ReceiveRequest_Flags") + if err != nil { + return err + } + *x = ReceiveRequest_Flags(value) + return nil +} + +type PollEvent_PollEventFlag int32 + +const ( + PollEvent_SOCKET_POLLNONE PollEvent_PollEventFlag = 0 + PollEvent_SOCKET_POLLIN PollEvent_PollEventFlag = 1 + PollEvent_SOCKET_POLLPRI PollEvent_PollEventFlag = 2 + PollEvent_SOCKET_POLLOUT PollEvent_PollEventFlag = 4 + PollEvent_SOCKET_POLLERR PollEvent_PollEventFlag = 8 + PollEvent_SOCKET_POLLHUP PollEvent_PollEventFlag = 16 + PollEvent_SOCKET_POLLNVAL PollEvent_PollEventFlag = 32 + PollEvent_SOCKET_POLLRDNORM PollEvent_PollEventFlag = 64 + PollEvent_SOCKET_POLLRDBAND PollEvent_PollEventFlag = 128 + PollEvent_SOCKET_POLLWRNORM PollEvent_PollEventFlag = 256 + PollEvent_SOCKET_POLLWRBAND PollEvent_PollEventFlag = 512 + PollEvent_SOCKET_POLLMSG PollEvent_PollEventFlag = 1024 + PollEvent_SOCKET_POLLREMOVE PollEvent_PollEventFlag = 4096 + PollEvent_SOCKET_POLLRDHUP PollEvent_PollEventFlag = 8192 +) + +var PollEvent_PollEventFlag_name = map[int32]string{ + 0: "SOCKET_POLLNONE", + 1: "SOCKET_POLLIN", + 2: "SOCKET_POLLPRI", + 4: "SOCKET_POLLOUT", + 8: "SOCKET_POLLERR", + 16: "SOCKET_POLLHUP", + 32: "SOCKET_POLLNVAL", + 64: "SOCKET_POLLRDNORM", + 128: "SOCKET_POLLRDBAND", + 256: "SOCKET_POLLWRNORM", + 512: "SOCKET_POLLWRBAND", + 1024: "SOCKET_POLLMSG", + 4096: "SOCKET_POLLREMOVE", + 8192: "SOCKET_POLLRDHUP", +} +var PollEvent_PollEventFlag_value = map[string]int32{ + "SOCKET_POLLNONE": 0, + "SOCKET_POLLIN": 1, + "SOCKET_POLLPRI": 2, + "SOCKET_POLLOUT": 4, + "SOCKET_POLLERR": 8, + "SOCKET_POLLHUP": 16, + "SOCKET_POLLNVAL": 32, + "SOCKET_POLLRDNORM": 64, + "SOCKET_POLLRDBAND": 128, + "SOCKET_POLLWRNORM": 256, + "SOCKET_POLLWRBAND": 512, + "SOCKET_POLLMSG": 1024, + "SOCKET_POLLREMOVE": 4096, + "SOCKET_POLLRDHUP": 8192, +} + +func (x PollEvent_PollEventFlag) Enum() *PollEvent_PollEventFlag { + p := new(PollEvent_PollEventFlag) + *p = x + return p +} +func (x PollEvent_PollEventFlag) String() string { + return proto.EnumName(PollEvent_PollEventFlag_name, int32(x)) +} +func (x *PollEvent_PollEventFlag) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(PollEvent_PollEventFlag_value, data, "PollEvent_PollEventFlag") + if err != nil { + return err + } + *x = PollEvent_PollEventFlag(value) + return nil +} + +type ResolveReply_ErrorCode int32 + +const ( + ResolveReply_SOCKET_EAI_ADDRFAMILY ResolveReply_ErrorCode = 1 + ResolveReply_SOCKET_EAI_AGAIN ResolveReply_ErrorCode = 2 + ResolveReply_SOCKET_EAI_BADFLAGS ResolveReply_ErrorCode = 3 + ResolveReply_SOCKET_EAI_FAIL ResolveReply_ErrorCode = 4 + ResolveReply_SOCKET_EAI_FAMILY ResolveReply_ErrorCode = 5 + ResolveReply_SOCKET_EAI_MEMORY ResolveReply_ErrorCode = 6 + ResolveReply_SOCKET_EAI_NODATA ResolveReply_ErrorCode = 7 + ResolveReply_SOCKET_EAI_NONAME ResolveReply_ErrorCode = 8 + ResolveReply_SOCKET_EAI_SERVICE ResolveReply_ErrorCode = 9 + ResolveReply_SOCKET_EAI_SOCKTYPE ResolveReply_ErrorCode = 10 + ResolveReply_SOCKET_EAI_SYSTEM ResolveReply_ErrorCode = 11 + ResolveReply_SOCKET_EAI_BADHINTS ResolveReply_ErrorCode = 12 + ResolveReply_SOCKET_EAI_PROTOCOL ResolveReply_ErrorCode = 13 + ResolveReply_SOCKET_EAI_OVERFLOW ResolveReply_ErrorCode = 14 + ResolveReply_SOCKET_EAI_MAX ResolveReply_ErrorCode = 15 +) + +var ResolveReply_ErrorCode_name = map[int32]string{ + 1: "SOCKET_EAI_ADDRFAMILY", + 2: "SOCKET_EAI_AGAIN", + 3: "SOCKET_EAI_BADFLAGS", + 4: "SOCKET_EAI_FAIL", + 5: "SOCKET_EAI_FAMILY", + 6: "SOCKET_EAI_MEMORY", + 7: "SOCKET_EAI_NODATA", + 8: "SOCKET_EAI_NONAME", + 9: "SOCKET_EAI_SERVICE", + 10: "SOCKET_EAI_SOCKTYPE", + 11: "SOCKET_EAI_SYSTEM", + 12: "SOCKET_EAI_BADHINTS", + 13: "SOCKET_EAI_PROTOCOL", + 14: "SOCKET_EAI_OVERFLOW", + 15: "SOCKET_EAI_MAX", +} +var ResolveReply_ErrorCode_value = map[string]int32{ + "SOCKET_EAI_ADDRFAMILY": 1, + "SOCKET_EAI_AGAIN": 2, + "SOCKET_EAI_BADFLAGS": 3, + "SOCKET_EAI_FAIL": 4, + "SOCKET_EAI_FAMILY": 5, + "SOCKET_EAI_MEMORY": 6, + "SOCKET_EAI_NODATA": 7, + "SOCKET_EAI_NONAME": 8, + "SOCKET_EAI_SERVICE": 9, + "SOCKET_EAI_SOCKTYPE": 10, + "SOCKET_EAI_SYSTEM": 11, + "SOCKET_EAI_BADHINTS": 12, + "SOCKET_EAI_PROTOCOL": 13, + "SOCKET_EAI_OVERFLOW": 14, + "SOCKET_EAI_MAX": 15, +} + +func (x ResolveReply_ErrorCode) Enum() *ResolveReply_ErrorCode { + p := new(ResolveReply_ErrorCode) + *p = x + return p +} +func (x ResolveReply_ErrorCode) String() string { + return proto.EnumName(ResolveReply_ErrorCode_name, int32(x)) +} +func (x *ResolveReply_ErrorCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ResolveReply_ErrorCode_value, data, "ResolveReply_ErrorCode") + if err != nil { + return err + } + *x = ResolveReply_ErrorCode(value) + return nil +} + +type RemoteSocketServiceError struct { + SystemError *int32 `protobuf:"varint,1,opt,name=system_error,def=0" json:"system_error,omitempty"` + ErrorDetail *string `protobuf:"bytes,2,opt,name=error_detail" json:"error_detail,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RemoteSocketServiceError) Reset() { *m = RemoteSocketServiceError{} } +func (m *RemoteSocketServiceError) String() string { return proto.CompactTextString(m) } +func (*RemoteSocketServiceError) ProtoMessage() {} + +const Default_RemoteSocketServiceError_SystemError int32 = 0 + +func (m *RemoteSocketServiceError) GetSystemError() int32 { + if m != nil && m.SystemError != nil { + return *m.SystemError + } + return Default_RemoteSocketServiceError_SystemError +} + +func (m *RemoteSocketServiceError) GetErrorDetail() string { + if m != nil && m.ErrorDetail != nil { + return *m.ErrorDetail + } + return "" +} + +type AddressPort struct { + Port *int32 `protobuf:"varint,1,req,name=port" json:"port,omitempty"` + PackedAddress []byte `protobuf:"bytes,2,opt,name=packed_address" json:"packed_address,omitempty"` + HostnameHint *string `protobuf:"bytes,3,opt,name=hostname_hint" json:"hostname_hint,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AddressPort) Reset() { *m = AddressPort{} } +func (m *AddressPort) String() string { return proto.CompactTextString(m) } +func (*AddressPort) ProtoMessage() {} + +func (m *AddressPort) GetPort() int32 { + if m != nil && m.Port != nil { + return *m.Port + } + return 0 +} + +func (m *AddressPort) GetPackedAddress() []byte { + if m != nil { + return m.PackedAddress + } + return nil +} + +func (m *AddressPort) GetHostnameHint() string { + if m != nil && m.HostnameHint != nil { + return *m.HostnameHint + } + return "" +} + +type CreateSocketRequest struct { + Family *CreateSocketRequest_SocketFamily `protobuf:"varint,1,req,name=family,enum=appengine.CreateSocketRequest_SocketFamily" json:"family,omitempty"` + Protocol *CreateSocketRequest_SocketProtocol `protobuf:"varint,2,req,name=protocol,enum=appengine.CreateSocketRequest_SocketProtocol" json:"protocol,omitempty"` + SocketOptions []*SocketOption `protobuf:"bytes,3,rep,name=socket_options" json:"socket_options,omitempty"` + ProxyExternalIp *AddressPort `protobuf:"bytes,4,opt,name=proxy_external_ip" json:"proxy_external_ip,omitempty"` + ListenBacklog *int32 `protobuf:"varint,5,opt,name=listen_backlog,def=0" json:"listen_backlog,omitempty"` + RemoteIp *AddressPort `protobuf:"bytes,6,opt,name=remote_ip" json:"remote_ip,omitempty"` + AppId *string `protobuf:"bytes,9,opt,name=app_id" json:"app_id,omitempty"` + ProjectId *int64 `protobuf:"varint,10,opt,name=project_id" json:"project_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CreateSocketRequest) Reset() { *m = CreateSocketRequest{} } +func (m *CreateSocketRequest) String() string { return proto.CompactTextString(m) } +func (*CreateSocketRequest) ProtoMessage() {} + +const Default_CreateSocketRequest_ListenBacklog int32 = 0 + +func (m *CreateSocketRequest) GetFamily() CreateSocketRequest_SocketFamily { + if m != nil && m.Family != nil { + return *m.Family + } + return CreateSocketRequest_IPv4 +} + +func (m *CreateSocketRequest) GetProtocol() CreateSocketRequest_SocketProtocol { + if m != nil && m.Protocol != nil { + return *m.Protocol + } + return CreateSocketRequest_TCP +} + +func (m *CreateSocketRequest) GetSocketOptions() []*SocketOption { + if m != nil { + return m.SocketOptions + } + return nil +} + +func (m *CreateSocketRequest) GetProxyExternalIp() *AddressPort { + if m != nil { + return m.ProxyExternalIp + } + return nil +} + +func (m *CreateSocketRequest) GetListenBacklog() int32 { + if m != nil && m.ListenBacklog != nil { + return *m.ListenBacklog + } + return Default_CreateSocketRequest_ListenBacklog +} + +func (m *CreateSocketRequest) GetRemoteIp() *AddressPort { + if m != nil { + return m.RemoteIp + } + return nil +} + +func (m *CreateSocketRequest) GetAppId() string { + if m != nil && m.AppId != nil { + return *m.AppId + } + return "" +} + +func (m *CreateSocketRequest) GetProjectId() int64 { + if m != nil && m.ProjectId != nil { + return *m.ProjectId + } + return 0 +} + +type CreateSocketReply struct { + SocketDescriptor *string `protobuf:"bytes,1,opt,name=socket_descriptor" json:"socket_descriptor,omitempty"` + ServerAddress *AddressPort `protobuf:"bytes,3,opt,name=server_address" json:"server_address,omitempty"` + ProxyExternalIp *AddressPort `protobuf:"bytes,4,opt,name=proxy_external_ip" json:"proxy_external_ip,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CreateSocketReply) Reset() { *m = CreateSocketReply{} } +func (m *CreateSocketReply) String() string { return proto.CompactTextString(m) } +func (*CreateSocketReply) ProtoMessage() {} + +var extRange_CreateSocketReply = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*CreateSocketReply) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_CreateSocketReply +} +func (m *CreateSocketReply) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +func (m *CreateSocketReply) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *CreateSocketReply) GetServerAddress() *AddressPort { + if m != nil { + return m.ServerAddress + } + return nil +} + +func (m *CreateSocketReply) GetProxyExternalIp() *AddressPort { + if m != nil { + return m.ProxyExternalIp + } + return nil +} + +type BindRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + ProxyExternalIp *AddressPort `protobuf:"bytes,2,req,name=proxy_external_ip" json:"proxy_external_ip,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BindRequest) Reset() { *m = BindRequest{} } +func (m *BindRequest) String() string { return proto.CompactTextString(m) } +func (*BindRequest) ProtoMessage() {} + +func (m *BindRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *BindRequest) GetProxyExternalIp() *AddressPort { + if m != nil { + return m.ProxyExternalIp + } + return nil +} + +type BindReply struct { + ProxyExternalIp *AddressPort `protobuf:"bytes,1,opt,name=proxy_external_ip" json:"proxy_external_ip,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BindReply) Reset() { *m = BindReply{} } +func (m *BindReply) String() string { return proto.CompactTextString(m) } +func (*BindReply) ProtoMessage() {} + +func (m *BindReply) GetProxyExternalIp() *AddressPort { + if m != nil { + return m.ProxyExternalIp + } + return nil +} + +type GetSocketNameRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetSocketNameRequest) Reset() { *m = GetSocketNameRequest{} } +func (m *GetSocketNameRequest) String() string { return proto.CompactTextString(m) } +func (*GetSocketNameRequest) ProtoMessage() {} + +func (m *GetSocketNameRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +type GetSocketNameReply struct { + ProxyExternalIp *AddressPort `protobuf:"bytes,2,opt,name=proxy_external_ip" json:"proxy_external_ip,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetSocketNameReply) Reset() { *m = GetSocketNameReply{} } +func (m *GetSocketNameReply) String() string { return proto.CompactTextString(m) } +func (*GetSocketNameReply) ProtoMessage() {} + +func (m *GetSocketNameReply) GetProxyExternalIp() *AddressPort { + if m != nil { + return m.ProxyExternalIp + } + return nil +} + +type GetPeerNameRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetPeerNameRequest) Reset() { *m = GetPeerNameRequest{} } +func (m *GetPeerNameRequest) String() string { return proto.CompactTextString(m) } +func (*GetPeerNameRequest) ProtoMessage() {} + +func (m *GetPeerNameRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +type GetPeerNameReply struct { + PeerIp *AddressPort `protobuf:"bytes,2,opt,name=peer_ip" json:"peer_ip,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetPeerNameReply) Reset() { *m = GetPeerNameReply{} } +func (m *GetPeerNameReply) String() string { return proto.CompactTextString(m) } +func (*GetPeerNameReply) ProtoMessage() {} + +func (m *GetPeerNameReply) GetPeerIp() *AddressPort { + if m != nil { + return m.PeerIp + } + return nil +} + +type SocketOption struct { + Level *SocketOption_SocketOptionLevel `protobuf:"varint,1,req,name=level,enum=appengine.SocketOption_SocketOptionLevel" json:"level,omitempty"` + Option *SocketOption_SocketOptionName `protobuf:"varint,2,req,name=option,enum=appengine.SocketOption_SocketOptionName" json:"option,omitempty"` + Value []byte `protobuf:"bytes,3,req,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SocketOption) Reset() { *m = SocketOption{} } +func (m *SocketOption) String() string { return proto.CompactTextString(m) } +func (*SocketOption) ProtoMessage() {} + +func (m *SocketOption) GetLevel() SocketOption_SocketOptionLevel { + if m != nil && m.Level != nil { + return *m.Level + } + return SocketOption_SOCKET_SOL_IP +} + +func (m *SocketOption) GetOption() SocketOption_SocketOptionName { + if m != nil && m.Option != nil { + return *m.Option + } + return SocketOption_SOCKET_SO_DEBUG +} + +func (m *SocketOption) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +type SetSocketOptionsRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + Options []*SocketOption `protobuf:"bytes,2,rep,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SetSocketOptionsRequest) Reset() { *m = SetSocketOptionsRequest{} } +func (m *SetSocketOptionsRequest) String() string { return proto.CompactTextString(m) } +func (*SetSocketOptionsRequest) ProtoMessage() {} + +func (m *SetSocketOptionsRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *SetSocketOptionsRequest) GetOptions() []*SocketOption { + if m != nil { + return m.Options + } + return nil +} + +type SetSocketOptionsReply struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *SetSocketOptionsReply) Reset() { *m = SetSocketOptionsReply{} } +func (m *SetSocketOptionsReply) String() string { return proto.CompactTextString(m) } +func (*SetSocketOptionsReply) ProtoMessage() {} + +type GetSocketOptionsRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + Options []*SocketOption `protobuf:"bytes,2,rep,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetSocketOptionsRequest) Reset() { *m = GetSocketOptionsRequest{} } +func (m *GetSocketOptionsRequest) String() string { return proto.CompactTextString(m) } +func (*GetSocketOptionsRequest) ProtoMessage() {} + +func (m *GetSocketOptionsRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *GetSocketOptionsRequest) GetOptions() []*SocketOption { + if m != nil { + return m.Options + } + return nil +} + +type GetSocketOptionsReply struct { + Options []*SocketOption `protobuf:"bytes,2,rep,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetSocketOptionsReply) Reset() { *m = GetSocketOptionsReply{} } +func (m *GetSocketOptionsReply) String() string { return proto.CompactTextString(m) } +func (*GetSocketOptionsReply) ProtoMessage() {} + +func (m *GetSocketOptionsReply) GetOptions() []*SocketOption { + if m != nil { + return m.Options + } + return nil +} + +type ConnectRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + RemoteIp *AddressPort `protobuf:"bytes,2,req,name=remote_ip" json:"remote_ip,omitempty"` + TimeoutSeconds *float64 `protobuf:"fixed64,3,opt,name=timeout_seconds,def=-1" json:"timeout_seconds,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ConnectRequest) Reset() { *m = ConnectRequest{} } +func (m *ConnectRequest) String() string { return proto.CompactTextString(m) } +func (*ConnectRequest) ProtoMessage() {} + +const Default_ConnectRequest_TimeoutSeconds float64 = -1 + +func (m *ConnectRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *ConnectRequest) GetRemoteIp() *AddressPort { + if m != nil { + return m.RemoteIp + } + return nil +} + +func (m *ConnectRequest) GetTimeoutSeconds() float64 { + if m != nil && m.TimeoutSeconds != nil { + return *m.TimeoutSeconds + } + return Default_ConnectRequest_TimeoutSeconds +} + +type ConnectReply struct { + ProxyExternalIp *AddressPort `protobuf:"bytes,1,opt,name=proxy_external_ip" json:"proxy_external_ip,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ConnectReply) Reset() { *m = ConnectReply{} } +func (m *ConnectReply) String() string { return proto.CompactTextString(m) } +func (*ConnectReply) ProtoMessage() {} + +var extRange_ConnectReply = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*ConnectReply) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_ConnectReply +} +func (m *ConnectReply) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +func (m *ConnectReply) GetProxyExternalIp() *AddressPort { + if m != nil { + return m.ProxyExternalIp + } + return nil +} + +type ListenRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + Backlog *int32 `protobuf:"varint,2,req,name=backlog" json:"backlog,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ListenRequest) Reset() { *m = ListenRequest{} } +func (m *ListenRequest) String() string { return proto.CompactTextString(m) } +func (*ListenRequest) ProtoMessage() {} + +func (m *ListenRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *ListenRequest) GetBacklog() int32 { + if m != nil && m.Backlog != nil { + return *m.Backlog + } + return 0 +} + +type ListenReply struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *ListenReply) Reset() { *m = ListenReply{} } +func (m *ListenReply) String() string { return proto.CompactTextString(m) } +func (*ListenReply) ProtoMessage() {} + +type AcceptRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + TimeoutSeconds *float64 `protobuf:"fixed64,2,opt,name=timeout_seconds,def=-1" json:"timeout_seconds,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AcceptRequest) Reset() { *m = AcceptRequest{} } +func (m *AcceptRequest) String() string { return proto.CompactTextString(m) } +func (*AcceptRequest) ProtoMessage() {} + +const Default_AcceptRequest_TimeoutSeconds float64 = -1 + +func (m *AcceptRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *AcceptRequest) GetTimeoutSeconds() float64 { + if m != nil && m.TimeoutSeconds != nil { + return *m.TimeoutSeconds + } + return Default_AcceptRequest_TimeoutSeconds +} + +type AcceptReply struct { + NewSocketDescriptor []byte `protobuf:"bytes,2,opt,name=new_socket_descriptor" json:"new_socket_descriptor,omitempty"` + RemoteAddress *AddressPort `protobuf:"bytes,3,opt,name=remote_address" json:"remote_address,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AcceptReply) Reset() { *m = AcceptReply{} } +func (m *AcceptReply) String() string { return proto.CompactTextString(m) } +func (*AcceptReply) ProtoMessage() {} + +func (m *AcceptReply) GetNewSocketDescriptor() []byte { + if m != nil { + return m.NewSocketDescriptor + } + return nil +} + +func (m *AcceptReply) GetRemoteAddress() *AddressPort { + if m != nil { + return m.RemoteAddress + } + return nil +} + +type ShutDownRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + How *ShutDownRequest_How `protobuf:"varint,2,req,name=how,enum=appengine.ShutDownRequest_How" json:"how,omitempty"` + SendOffset *int64 `protobuf:"varint,3,req,name=send_offset" json:"send_offset,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ShutDownRequest) Reset() { *m = ShutDownRequest{} } +func (m *ShutDownRequest) String() string { return proto.CompactTextString(m) } +func (*ShutDownRequest) ProtoMessage() {} + +func (m *ShutDownRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *ShutDownRequest) GetHow() ShutDownRequest_How { + if m != nil && m.How != nil { + return *m.How + } + return ShutDownRequest_SOCKET_SHUT_RD +} + +func (m *ShutDownRequest) GetSendOffset() int64 { + if m != nil && m.SendOffset != nil { + return *m.SendOffset + } + return 0 +} + +type ShutDownReply struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *ShutDownReply) Reset() { *m = ShutDownReply{} } +func (m *ShutDownReply) String() string { return proto.CompactTextString(m) } +func (*ShutDownReply) ProtoMessage() {} + +type CloseRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + SendOffset *int64 `protobuf:"varint,2,opt,name=send_offset,def=-1" json:"send_offset,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CloseRequest) Reset() { *m = CloseRequest{} } +func (m *CloseRequest) String() string { return proto.CompactTextString(m) } +func (*CloseRequest) ProtoMessage() {} + +const Default_CloseRequest_SendOffset int64 = -1 + +func (m *CloseRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *CloseRequest) GetSendOffset() int64 { + if m != nil && m.SendOffset != nil { + return *m.SendOffset + } + return Default_CloseRequest_SendOffset +} + +type CloseReply struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CloseReply) Reset() { *m = CloseReply{} } +func (m *CloseReply) String() string { return proto.CompactTextString(m) } +func (*CloseReply) ProtoMessage() {} + +type SendRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + Data []byte `protobuf:"bytes,2,req,name=data" json:"data,omitempty"` + StreamOffset *int64 `protobuf:"varint,3,req,name=stream_offset" json:"stream_offset,omitempty"` + Flags *int32 `protobuf:"varint,4,opt,name=flags,def=0" json:"flags,omitempty"` + SendTo *AddressPort `protobuf:"bytes,5,opt,name=send_to" json:"send_to,omitempty"` + TimeoutSeconds *float64 `protobuf:"fixed64,6,opt,name=timeout_seconds,def=-1" json:"timeout_seconds,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SendRequest) Reset() { *m = SendRequest{} } +func (m *SendRequest) String() string { return proto.CompactTextString(m) } +func (*SendRequest) ProtoMessage() {} + +const Default_SendRequest_Flags int32 = 0 +const Default_SendRequest_TimeoutSeconds float64 = -1 + +func (m *SendRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *SendRequest) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func (m *SendRequest) GetStreamOffset() int64 { + if m != nil && m.StreamOffset != nil { + return *m.StreamOffset + } + return 0 +} + +func (m *SendRequest) GetFlags() int32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return Default_SendRequest_Flags +} + +func (m *SendRequest) GetSendTo() *AddressPort { + if m != nil { + return m.SendTo + } + return nil +} + +func (m *SendRequest) GetTimeoutSeconds() float64 { + if m != nil && m.TimeoutSeconds != nil { + return *m.TimeoutSeconds + } + return Default_SendRequest_TimeoutSeconds +} + +type SendReply struct { + DataSent *int32 `protobuf:"varint,1,opt,name=data_sent" json:"data_sent,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SendReply) Reset() { *m = SendReply{} } +func (m *SendReply) String() string { return proto.CompactTextString(m) } +func (*SendReply) ProtoMessage() {} + +func (m *SendReply) GetDataSent() int32 { + if m != nil && m.DataSent != nil { + return *m.DataSent + } + return 0 +} + +type ReceiveRequest struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + DataSize *int32 `protobuf:"varint,2,req,name=data_size" json:"data_size,omitempty"` + Flags *int32 `protobuf:"varint,3,opt,name=flags,def=0" json:"flags,omitempty"` + TimeoutSeconds *float64 `protobuf:"fixed64,5,opt,name=timeout_seconds,def=-1" json:"timeout_seconds,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReceiveRequest) Reset() { *m = ReceiveRequest{} } +func (m *ReceiveRequest) String() string { return proto.CompactTextString(m) } +func (*ReceiveRequest) ProtoMessage() {} + +const Default_ReceiveRequest_Flags int32 = 0 +const Default_ReceiveRequest_TimeoutSeconds float64 = -1 + +func (m *ReceiveRequest) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *ReceiveRequest) GetDataSize() int32 { + if m != nil && m.DataSize != nil { + return *m.DataSize + } + return 0 +} + +func (m *ReceiveRequest) GetFlags() int32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return Default_ReceiveRequest_Flags +} + +func (m *ReceiveRequest) GetTimeoutSeconds() float64 { + if m != nil && m.TimeoutSeconds != nil { + return *m.TimeoutSeconds + } + return Default_ReceiveRequest_TimeoutSeconds +} + +type ReceiveReply struct { + StreamOffset *int64 `protobuf:"varint,2,opt,name=stream_offset" json:"stream_offset,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"` + ReceivedFrom *AddressPort `protobuf:"bytes,4,opt,name=received_from" json:"received_from,omitempty"` + BufferSize *int32 `protobuf:"varint,5,opt,name=buffer_size" json:"buffer_size,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReceiveReply) Reset() { *m = ReceiveReply{} } +func (m *ReceiveReply) String() string { return proto.CompactTextString(m) } +func (*ReceiveReply) ProtoMessage() {} + +func (m *ReceiveReply) GetStreamOffset() int64 { + if m != nil && m.StreamOffset != nil { + return *m.StreamOffset + } + return 0 +} + +func (m *ReceiveReply) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func (m *ReceiveReply) GetReceivedFrom() *AddressPort { + if m != nil { + return m.ReceivedFrom + } + return nil +} + +func (m *ReceiveReply) GetBufferSize() int32 { + if m != nil && m.BufferSize != nil { + return *m.BufferSize + } + return 0 +} + +type PollEvent struct { + SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"` + RequestedEvents *int32 `protobuf:"varint,2,req,name=requested_events" json:"requested_events,omitempty"` + ObservedEvents *int32 `protobuf:"varint,3,req,name=observed_events" json:"observed_events,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PollEvent) Reset() { *m = PollEvent{} } +func (m *PollEvent) String() string { return proto.CompactTextString(m) } +func (*PollEvent) ProtoMessage() {} + +func (m *PollEvent) GetSocketDescriptor() string { + if m != nil && m.SocketDescriptor != nil { + return *m.SocketDescriptor + } + return "" +} + +func (m *PollEvent) GetRequestedEvents() int32 { + if m != nil && m.RequestedEvents != nil { + return *m.RequestedEvents + } + return 0 +} + +func (m *PollEvent) GetObservedEvents() int32 { + if m != nil && m.ObservedEvents != nil { + return *m.ObservedEvents + } + return 0 +} + +type PollRequest struct { + Events []*PollEvent `protobuf:"bytes,1,rep,name=events" json:"events,omitempty"` + TimeoutSeconds *float64 `protobuf:"fixed64,2,opt,name=timeout_seconds,def=-1" json:"timeout_seconds,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PollRequest) Reset() { *m = PollRequest{} } +func (m *PollRequest) String() string { return proto.CompactTextString(m) } +func (*PollRequest) ProtoMessage() {} + +const Default_PollRequest_TimeoutSeconds float64 = -1 + +func (m *PollRequest) GetEvents() []*PollEvent { + if m != nil { + return m.Events + } + return nil +} + +func (m *PollRequest) GetTimeoutSeconds() float64 { + if m != nil && m.TimeoutSeconds != nil { + return *m.TimeoutSeconds + } + return Default_PollRequest_TimeoutSeconds +} + +type PollReply struct { + Events []*PollEvent `protobuf:"bytes,2,rep,name=events" json:"events,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PollReply) Reset() { *m = PollReply{} } +func (m *PollReply) String() string { return proto.CompactTextString(m) } +func (*PollReply) ProtoMessage() {} + +func (m *PollReply) GetEvents() []*PollEvent { + if m != nil { + return m.Events + } + return nil +} + +type ResolveRequest struct { + Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"` + AddressFamilies []CreateSocketRequest_SocketFamily `protobuf:"varint,2,rep,name=address_families,enum=appengine.CreateSocketRequest_SocketFamily" json:"address_families,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ResolveRequest) Reset() { *m = ResolveRequest{} } +func (m *ResolveRequest) String() string { return proto.CompactTextString(m) } +func (*ResolveRequest) ProtoMessage() {} + +func (m *ResolveRequest) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *ResolveRequest) GetAddressFamilies() []CreateSocketRequest_SocketFamily { + if m != nil { + return m.AddressFamilies + } + return nil +} + +type ResolveReply struct { + PackedAddress [][]byte `protobuf:"bytes,2,rep,name=packed_address" json:"packed_address,omitempty"` + CanonicalName *string `protobuf:"bytes,3,opt,name=canonical_name" json:"canonical_name,omitempty"` + Aliases []string `protobuf:"bytes,4,rep,name=aliases" json:"aliases,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ResolveReply) Reset() { *m = ResolveReply{} } +func (m *ResolveReply) String() string { return proto.CompactTextString(m) } +func (*ResolveReply) ProtoMessage() {} + +func (m *ResolveReply) GetPackedAddress() [][]byte { + if m != nil { + return m.PackedAddress + } + return nil +} + +func (m *ResolveReply) GetCanonicalName() string { + if m != nil && m.CanonicalName != nil { + return *m.CanonicalName + } + return "" +} + +func (m *ResolveReply) GetAliases() []string { + if m != nil { + return m.Aliases + } + return nil +} + +func init() { +} diff --git a/vendor/google.golang.org/appengine/internal/transaction.go b/vendor/google.golang.org/appengine/internal/transaction.go new file mode 100644 index 00000000..28a6d181 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/transaction.go @@ -0,0 +1,107 @@ +// Copyright 2014 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +package internal + +// This file implements hooks for applying datastore transactions. + +import ( + "errors" + "reflect" + + "github.com/golang/protobuf/proto" + netcontext "golang.org/x/net/context" + + basepb "google.golang.org/appengine/internal/base" + pb "google.golang.org/appengine/internal/datastore" +) + +var transactionSetters = make(map[reflect.Type]reflect.Value) + +// RegisterTransactionSetter registers a function that sets transaction information +// in a protocol buffer message. f should be a function with two arguments, +// the first being a protocol buffer type, and the second being *datastore.Transaction. +func RegisterTransactionSetter(f interface{}) { + v := reflect.ValueOf(f) + transactionSetters[v.Type().In(0)] = v +} + +// applyTransaction applies the transaction t to message pb +// by using the relevant setter passed to RegisterTransactionSetter. +func applyTransaction(pb proto.Message, t *pb.Transaction) { + v := reflect.ValueOf(pb) + if f, ok := transactionSetters[v.Type()]; ok { + f.Call([]reflect.Value{v, reflect.ValueOf(t)}) + } +} + +var transactionKey = "used for *Transaction" + +func transactionFromContext(ctx netcontext.Context) *transaction { + t, _ := ctx.Value(&transactionKey).(*transaction) + return t +} + +func withTransaction(ctx netcontext.Context, t *transaction) netcontext.Context { + return netcontext.WithValue(ctx, &transactionKey, t) +} + +type transaction struct { + transaction pb.Transaction + finished bool +} + +var ErrConcurrentTransaction = errors.New("internal: concurrent transaction") + +func RunTransactionOnce(c netcontext.Context, f func(netcontext.Context) error, xg bool) error { + if transactionFromContext(c) != nil { + return errors.New("nested transactions are not supported") + } + + // Begin the transaction. + t := &transaction{} + req := &pb.BeginTransactionRequest{ + App: proto.String(FullyQualifiedAppID(c)), + } + if xg { + req.AllowMultipleEg = proto.Bool(true) + } + if err := Call(c, "datastore_v3", "BeginTransaction", req, &t.transaction); err != nil { + return err + } + + // Call f, rolling back the transaction if f returns a non-nil error, or panics. + // The panic is not recovered. + defer func() { + if t.finished { + return + } + t.finished = true + // Ignore the error return value, since we are already returning a non-nil + // error (or we're panicking). + Call(c, "datastore_v3", "Rollback", &t.transaction, &basepb.VoidProto{}) + }() + if err := f(withTransaction(c, t)); err != nil { + return err + } + t.finished = true + + // Commit the transaction. + res := &pb.CommitResponse{} + err := Call(c, "datastore_v3", "Commit", &t.transaction, res) + if ae, ok := err.(*APIError); ok { + /* TODO: restore this conditional + if appengine.IsDevAppServer() { + */ + // The Python Dev AppServer raises an ApplicationError with error code 2 (which is + // Error.CONCURRENT_TRANSACTION) and message "Concurrency exception.". + if ae.Code == int32(pb.Error_BAD_REQUEST) && ae.Detail == "ApplicationError: 2 Concurrency exception." { + return ErrConcurrentTransaction + } + if ae.Code == int32(pb.Error_CONCURRENT_TRANSACTION) { + return ErrConcurrentTransaction + } + } + return err +} diff --git a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go new file mode 100644 index 00000000..af463fbb --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go @@ -0,0 +1,355 @@ +// Code generated by protoc-gen-go. +// source: google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto +// DO NOT EDIT! + +/* +Package urlfetch is a generated protocol buffer package. + +It is generated from these files: + google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto + +It has these top-level messages: + URLFetchServiceError + URLFetchRequest + URLFetchResponse +*/ +package urlfetch + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type URLFetchServiceError_ErrorCode int32 + +const ( + URLFetchServiceError_OK URLFetchServiceError_ErrorCode = 0 + URLFetchServiceError_INVALID_URL URLFetchServiceError_ErrorCode = 1 + URLFetchServiceError_FETCH_ERROR URLFetchServiceError_ErrorCode = 2 + URLFetchServiceError_UNSPECIFIED_ERROR URLFetchServiceError_ErrorCode = 3 + URLFetchServiceError_RESPONSE_TOO_LARGE URLFetchServiceError_ErrorCode = 4 + URLFetchServiceError_DEADLINE_EXCEEDED URLFetchServiceError_ErrorCode = 5 + URLFetchServiceError_SSL_CERTIFICATE_ERROR URLFetchServiceError_ErrorCode = 6 + URLFetchServiceError_DNS_ERROR URLFetchServiceError_ErrorCode = 7 + URLFetchServiceError_CLOSED URLFetchServiceError_ErrorCode = 8 + URLFetchServiceError_INTERNAL_TRANSIENT_ERROR URLFetchServiceError_ErrorCode = 9 + URLFetchServiceError_TOO_MANY_REDIRECTS URLFetchServiceError_ErrorCode = 10 + URLFetchServiceError_MALFORMED_REPLY URLFetchServiceError_ErrorCode = 11 + URLFetchServiceError_CONNECTION_ERROR URLFetchServiceError_ErrorCode = 12 +) + +var URLFetchServiceError_ErrorCode_name = map[int32]string{ + 0: "OK", + 1: "INVALID_URL", + 2: "FETCH_ERROR", + 3: "UNSPECIFIED_ERROR", + 4: "RESPONSE_TOO_LARGE", + 5: "DEADLINE_EXCEEDED", + 6: "SSL_CERTIFICATE_ERROR", + 7: "DNS_ERROR", + 8: "CLOSED", + 9: "INTERNAL_TRANSIENT_ERROR", + 10: "TOO_MANY_REDIRECTS", + 11: "MALFORMED_REPLY", + 12: "CONNECTION_ERROR", +} +var URLFetchServiceError_ErrorCode_value = map[string]int32{ + "OK": 0, + "INVALID_URL": 1, + "FETCH_ERROR": 2, + "UNSPECIFIED_ERROR": 3, + "RESPONSE_TOO_LARGE": 4, + "DEADLINE_EXCEEDED": 5, + "SSL_CERTIFICATE_ERROR": 6, + "DNS_ERROR": 7, + "CLOSED": 8, + "INTERNAL_TRANSIENT_ERROR": 9, + "TOO_MANY_REDIRECTS": 10, + "MALFORMED_REPLY": 11, + "CONNECTION_ERROR": 12, +} + +func (x URLFetchServiceError_ErrorCode) Enum() *URLFetchServiceError_ErrorCode { + p := new(URLFetchServiceError_ErrorCode) + *p = x + return p +} +func (x URLFetchServiceError_ErrorCode) String() string { + return proto.EnumName(URLFetchServiceError_ErrorCode_name, int32(x)) +} +func (x *URLFetchServiceError_ErrorCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(URLFetchServiceError_ErrorCode_value, data, "URLFetchServiceError_ErrorCode") + if err != nil { + return err + } + *x = URLFetchServiceError_ErrorCode(value) + return nil +} + +type URLFetchRequest_RequestMethod int32 + +const ( + URLFetchRequest_GET URLFetchRequest_RequestMethod = 1 + URLFetchRequest_POST URLFetchRequest_RequestMethod = 2 + URLFetchRequest_HEAD URLFetchRequest_RequestMethod = 3 + URLFetchRequest_PUT URLFetchRequest_RequestMethod = 4 + URLFetchRequest_DELETE URLFetchRequest_RequestMethod = 5 + URLFetchRequest_PATCH URLFetchRequest_RequestMethod = 6 +) + +var URLFetchRequest_RequestMethod_name = map[int32]string{ + 1: "GET", + 2: "POST", + 3: "HEAD", + 4: "PUT", + 5: "DELETE", + 6: "PATCH", +} +var URLFetchRequest_RequestMethod_value = map[string]int32{ + "GET": 1, + "POST": 2, + "HEAD": 3, + "PUT": 4, + "DELETE": 5, + "PATCH": 6, +} + +func (x URLFetchRequest_RequestMethod) Enum() *URLFetchRequest_RequestMethod { + p := new(URLFetchRequest_RequestMethod) + *p = x + return p +} +func (x URLFetchRequest_RequestMethod) String() string { + return proto.EnumName(URLFetchRequest_RequestMethod_name, int32(x)) +} +func (x *URLFetchRequest_RequestMethod) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(URLFetchRequest_RequestMethod_value, data, "URLFetchRequest_RequestMethod") + if err != nil { + return err + } + *x = URLFetchRequest_RequestMethod(value) + return nil +} + +type URLFetchServiceError struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *URLFetchServiceError) Reset() { *m = URLFetchServiceError{} } +func (m *URLFetchServiceError) String() string { return proto.CompactTextString(m) } +func (*URLFetchServiceError) ProtoMessage() {} + +type URLFetchRequest struct { + Method *URLFetchRequest_RequestMethod `protobuf:"varint,1,req,name=Method,enum=appengine.URLFetchRequest_RequestMethod" json:"Method,omitempty"` + Url *string `protobuf:"bytes,2,req,name=Url" json:"Url,omitempty"` + Header []*URLFetchRequest_Header `protobuf:"group,3,rep,name=Header" json:"header,omitempty"` + Payload []byte `protobuf:"bytes,6,opt,name=Payload" json:"Payload,omitempty"` + FollowRedirects *bool `protobuf:"varint,7,opt,name=FollowRedirects,def=1" json:"FollowRedirects,omitempty"` + Deadline *float64 `protobuf:"fixed64,8,opt,name=Deadline" json:"Deadline,omitempty"` + MustValidateServerCertificate *bool `protobuf:"varint,9,opt,name=MustValidateServerCertificate,def=1" json:"MustValidateServerCertificate,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *URLFetchRequest) Reset() { *m = URLFetchRequest{} } +func (m *URLFetchRequest) String() string { return proto.CompactTextString(m) } +func (*URLFetchRequest) ProtoMessage() {} + +const Default_URLFetchRequest_FollowRedirects bool = true +const Default_URLFetchRequest_MustValidateServerCertificate bool = true + +func (m *URLFetchRequest) GetMethod() URLFetchRequest_RequestMethod { + if m != nil && m.Method != nil { + return *m.Method + } + return URLFetchRequest_GET +} + +func (m *URLFetchRequest) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *URLFetchRequest) GetHeader() []*URLFetchRequest_Header { + if m != nil { + return m.Header + } + return nil +} + +func (m *URLFetchRequest) GetPayload() []byte { + if m != nil { + return m.Payload + } + return nil +} + +func (m *URLFetchRequest) GetFollowRedirects() bool { + if m != nil && m.FollowRedirects != nil { + return *m.FollowRedirects + } + return Default_URLFetchRequest_FollowRedirects +} + +func (m *URLFetchRequest) GetDeadline() float64 { + if m != nil && m.Deadline != nil { + return *m.Deadline + } + return 0 +} + +func (m *URLFetchRequest) GetMustValidateServerCertificate() bool { + if m != nil && m.MustValidateServerCertificate != nil { + return *m.MustValidateServerCertificate + } + return Default_URLFetchRequest_MustValidateServerCertificate +} + +type URLFetchRequest_Header struct { + Key *string `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"` + Value *string `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *URLFetchRequest_Header) Reset() { *m = URLFetchRequest_Header{} } +func (m *URLFetchRequest_Header) String() string { return proto.CompactTextString(m) } +func (*URLFetchRequest_Header) ProtoMessage() {} + +func (m *URLFetchRequest_Header) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *URLFetchRequest_Header) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type URLFetchResponse struct { + Content []byte `protobuf:"bytes,1,opt,name=Content" json:"Content,omitempty"` + StatusCode *int32 `protobuf:"varint,2,req,name=StatusCode" json:"StatusCode,omitempty"` + Header []*URLFetchResponse_Header `protobuf:"group,3,rep,name=Header" json:"header,omitempty"` + ContentWasTruncated *bool `protobuf:"varint,6,opt,name=ContentWasTruncated,def=0" json:"ContentWasTruncated,omitempty"` + ExternalBytesSent *int64 `protobuf:"varint,7,opt,name=ExternalBytesSent" json:"ExternalBytesSent,omitempty"` + ExternalBytesReceived *int64 `protobuf:"varint,8,opt,name=ExternalBytesReceived" json:"ExternalBytesReceived,omitempty"` + FinalUrl *string `protobuf:"bytes,9,opt,name=FinalUrl" json:"FinalUrl,omitempty"` + ApiCpuMilliseconds *int64 `protobuf:"varint,10,opt,name=ApiCpuMilliseconds,def=0" json:"ApiCpuMilliseconds,omitempty"` + ApiBytesSent *int64 `protobuf:"varint,11,opt,name=ApiBytesSent,def=0" json:"ApiBytesSent,omitempty"` + ApiBytesReceived *int64 `protobuf:"varint,12,opt,name=ApiBytesReceived,def=0" json:"ApiBytesReceived,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *URLFetchResponse) Reset() { *m = URLFetchResponse{} } +func (m *URLFetchResponse) String() string { return proto.CompactTextString(m) } +func (*URLFetchResponse) ProtoMessage() {} + +const Default_URLFetchResponse_ContentWasTruncated bool = false +const Default_URLFetchResponse_ApiCpuMilliseconds int64 = 0 +const Default_URLFetchResponse_ApiBytesSent int64 = 0 +const Default_URLFetchResponse_ApiBytesReceived int64 = 0 + +func (m *URLFetchResponse) GetContent() []byte { + if m != nil { + return m.Content + } + return nil +} + +func (m *URLFetchResponse) GetStatusCode() int32 { + if m != nil && m.StatusCode != nil { + return *m.StatusCode + } + return 0 +} + +func (m *URLFetchResponse) GetHeader() []*URLFetchResponse_Header { + if m != nil { + return m.Header + } + return nil +} + +func (m *URLFetchResponse) GetContentWasTruncated() bool { + if m != nil && m.ContentWasTruncated != nil { + return *m.ContentWasTruncated + } + return Default_URLFetchResponse_ContentWasTruncated +} + +func (m *URLFetchResponse) GetExternalBytesSent() int64 { + if m != nil && m.ExternalBytesSent != nil { + return *m.ExternalBytesSent + } + return 0 +} + +func (m *URLFetchResponse) GetExternalBytesReceived() int64 { + if m != nil && m.ExternalBytesReceived != nil { + return *m.ExternalBytesReceived + } + return 0 +} + +func (m *URLFetchResponse) GetFinalUrl() string { + if m != nil && m.FinalUrl != nil { + return *m.FinalUrl + } + return "" +} + +func (m *URLFetchResponse) GetApiCpuMilliseconds() int64 { + if m != nil && m.ApiCpuMilliseconds != nil { + return *m.ApiCpuMilliseconds + } + return Default_URLFetchResponse_ApiCpuMilliseconds +} + +func (m *URLFetchResponse) GetApiBytesSent() int64 { + if m != nil && m.ApiBytesSent != nil { + return *m.ApiBytesSent + } + return Default_URLFetchResponse_ApiBytesSent +} + +func (m *URLFetchResponse) GetApiBytesReceived() int64 { + if m != nil && m.ApiBytesReceived != nil { + return *m.ApiBytesReceived + } + return Default_URLFetchResponse_ApiBytesReceived +} + +type URLFetchResponse_Header struct { + Key *string `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"` + Value *string `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *URLFetchResponse_Header) Reset() { *m = URLFetchResponse_Header{} } +func (m *URLFetchResponse_Header) String() string { return proto.CompactTextString(m) } +func (*URLFetchResponse_Header) ProtoMessage() {} + +func (m *URLFetchResponse_Header) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *URLFetchResponse_Header) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +func init() { +} diff --git a/vendor/google.golang.org/appengine/namespace.go b/vendor/google.golang.org/appengine/namespace.go new file mode 100644 index 00000000..21860ca0 --- /dev/null +++ b/vendor/google.golang.org/appengine/namespace.go @@ -0,0 +1,25 @@ +// Copyright 2012 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +package appengine + +import ( + "fmt" + "regexp" + + "golang.org/x/net/context" + + "google.golang.org/appengine/internal" +) + +// Namespace returns a replacement context that operates within the given namespace. +func Namespace(c context.Context, namespace string) (context.Context, error) { + if !validNamespace.MatchString(namespace) { + return nil, fmt.Errorf("appengine: namespace %q does not match /%s/", namespace, validNamespace) + } + return internal.NamespacedContext(c, namespace), nil +} + +// validNamespace matches valid namespace names. +var validNamespace = regexp.MustCompile(`^[0-9A-Za-z._-]{0,100}$`) diff --git a/vendor/google.golang.org/appengine/socket/doc.go b/vendor/google.golang.org/appengine/socket/doc.go new file mode 100644 index 00000000..3de46df8 --- /dev/null +++ b/vendor/google.golang.org/appengine/socket/doc.go @@ -0,0 +1,10 @@ +// Copyright 2012 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// Package socket provides outbound network sockets. +// +// This package is only required in the classic App Engine environment. +// Applications running only in App Engine "flexible environment" should +// use the standard library's net package. +package socket diff --git a/vendor/google.golang.org/appengine/socket/socket_classic.go b/vendor/google.golang.org/appengine/socket/socket_classic.go new file mode 100644 index 00000000..0ad50e2d --- /dev/null +++ b/vendor/google.golang.org/appengine/socket/socket_classic.go @@ -0,0 +1,290 @@ +// Copyright 2012 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// +build appengine + +package socket + +import ( + "fmt" + "io" + "net" + "strconv" + "time" + + "github.com/golang/protobuf/proto" + "golang.org/x/net/context" + "google.golang.org/appengine/internal" + + pb "google.golang.org/appengine/internal/socket" +) + +// Dial connects to the address addr on the network protocol. +// The address format is host:port, where host may be a hostname or an IP address. +// Known protocols are "tcp" and "udp". +// The returned connection satisfies net.Conn, and is valid while ctx is valid; +// if the connection is to be used after ctx becomes invalid, invoke SetContext +// with the new context. +func Dial(ctx context.Context, protocol, addr string) (*Conn, error) { + return DialTimeout(ctx, protocol, addr, 0) +} + +var ipFamilies = []pb.CreateSocketRequest_SocketFamily{ + pb.CreateSocketRequest_IPv4, + pb.CreateSocketRequest_IPv6, +} + +// DialTimeout is like Dial but takes a timeout. +// The timeout includes name resolution, if required. +func DialTimeout(ctx context.Context, protocol, addr string, timeout time.Duration) (*Conn, error) { + dialCtx := ctx // Used for dialing and name resolution, but not stored in the *Conn. + if timeout > 0 { + var cancel context.CancelFunc + dialCtx, cancel = context.WithTimeout(ctx, timeout) + defer cancel() + } + + host, portStr, err := net.SplitHostPort(addr) + if err != nil { + return nil, err + } + port, err := strconv.Atoi(portStr) + if err != nil { + return nil, fmt.Errorf("socket: bad port %q: %v", portStr, err) + } + + var prot pb.CreateSocketRequest_SocketProtocol + switch protocol { + case "tcp": + prot = pb.CreateSocketRequest_TCP + case "udp": + prot = pb.CreateSocketRequest_UDP + default: + return nil, fmt.Errorf("socket: unknown protocol %q", protocol) + } + + packedAddrs, resolved, err := resolve(dialCtx, ipFamilies, host) + if err != nil { + return nil, fmt.Errorf("socket: failed resolving %q: %v", host, err) + } + if len(packedAddrs) == 0 { + return nil, fmt.Errorf("no addresses for %q", host) + } + + packedAddr := packedAddrs[0] // use first address + fam := pb.CreateSocketRequest_IPv4 + if len(packedAddr) == net.IPv6len { + fam = pb.CreateSocketRequest_IPv6 + } + + req := &pb.CreateSocketRequest{ + Family: fam.Enum(), + Protocol: prot.Enum(), + RemoteIp: &pb.AddressPort{ + Port: proto.Int32(int32(port)), + PackedAddress: packedAddr, + }, + } + if resolved { + req.RemoteIp.HostnameHint = &host + } + res := &pb.CreateSocketReply{} + if err := internal.Call(dialCtx, "remote_socket", "CreateSocket", req, res); err != nil { + return nil, err + } + + return &Conn{ + ctx: ctx, + desc: res.GetSocketDescriptor(), + prot: prot, + local: res.ProxyExternalIp, + remote: req.RemoteIp, + }, nil +} + +// LookupIP returns the given host's IP addresses. +func LookupIP(ctx context.Context, host string) (addrs []net.IP, err error) { + packedAddrs, _, err := resolve(ctx, ipFamilies, host) + if err != nil { + return nil, fmt.Errorf("socket: failed resolving %q: %v", host, err) + } + addrs = make([]net.IP, len(packedAddrs)) + for i, pa := range packedAddrs { + addrs[i] = net.IP(pa) + } + return addrs, nil +} + +func resolve(ctx context.Context, fams []pb.CreateSocketRequest_SocketFamily, host string) ([][]byte, bool, error) { + // Check if it's an IP address. + if ip := net.ParseIP(host); ip != nil { + if ip := ip.To4(); ip != nil { + return [][]byte{ip}, false, nil + } + return [][]byte{ip}, false, nil + } + + req := &pb.ResolveRequest{ + Name: &host, + AddressFamilies: fams, + } + res := &pb.ResolveReply{} + if err := internal.Call(ctx, "remote_socket", "Resolve", req, res); err != nil { + // XXX: need to map to pb.ResolveReply_ErrorCode? + return nil, false, err + } + return res.PackedAddress, true, nil +} + +// withDeadline is like context.WithDeadline, except it ignores the zero deadline. +func withDeadline(parent context.Context, deadline time.Time) (context.Context, context.CancelFunc) { + if deadline.IsZero() { + return parent, func() {} + } + return context.WithDeadline(parent, deadline) +} + +// Conn represents a socket connection. +// It implements net.Conn. +type Conn struct { + ctx context.Context + desc string + offset int64 + + prot pb.CreateSocketRequest_SocketProtocol + local, remote *pb.AddressPort + + readDeadline, writeDeadline time.Time // optional +} + +// SetContext sets the context that is used by this Conn. +// It is usually used only when using a Conn that was created in a different context, +// such as when a connection is created during a warmup request but used while +// servicing a user request. +func (cn *Conn) SetContext(ctx context.Context) { + cn.ctx = ctx +} + +func (cn *Conn) Read(b []byte) (n int, err error) { + const maxRead = 1 << 20 + if len(b) > maxRead { + b = b[:maxRead] + } + + req := &pb.ReceiveRequest{ + SocketDescriptor: &cn.desc, + DataSize: proto.Int32(int32(len(b))), + } + res := &pb.ReceiveReply{} + if !cn.readDeadline.IsZero() { + req.TimeoutSeconds = proto.Float64(cn.readDeadline.Sub(time.Now()).Seconds()) + } + ctx, cancel := withDeadline(cn.ctx, cn.readDeadline) + defer cancel() + if err := internal.Call(ctx, "remote_socket", "Receive", req, res); err != nil { + return 0, err + } + if len(res.Data) == 0 { + return 0, io.EOF + } + if len(res.Data) > len(b) { + return 0, fmt.Errorf("socket: internal error: read too much data: %d > %d", len(res.Data), len(b)) + } + return copy(b, res.Data), nil +} + +func (cn *Conn) Write(b []byte) (n int, err error) { + const lim = 1 << 20 // max per chunk + + for n < len(b) { + chunk := b[n:] + if len(chunk) > lim { + chunk = chunk[:lim] + } + + req := &pb.SendRequest{ + SocketDescriptor: &cn.desc, + Data: chunk, + StreamOffset: &cn.offset, + } + res := &pb.SendReply{} + if !cn.writeDeadline.IsZero() { + req.TimeoutSeconds = proto.Float64(cn.writeDeadline.Sub(time.Now()).Seconds()) + } + ctx, cancel := withDeadline(cn.ctx, cn.writeDeadline) + defer cancel() + if err = internal.Call(ctx, "remote_socket", "Send", req, res); err != nil { + // assume zero bytes were sent in this RPC + break + } + n += int(res.GetDataSent()) + cn.offset += int64(res.GetDataSent()) + } + + return +} + +func (cn *Conn) Close() error { + req := &pb.CloseRequest{ + SocketDescriptor: &cn.desc, + } + res := &pb.CloseReply{} + if err := internal.Call(cn.ctx, "remote_socket", "Close", req, res); err != nil { + return err + } + cn.desc = "CLOSED" + return nil +} + +func addr(prot pb.CreateSocketRequest_SocketProtocol, ap *pb.AddressPort) net.Addr { + if ap == nil { + return nil + } + switch prot { + case pb.CreateSocketRequest_TCP: + return &net.TCPAddr{ + IP: net.IP(ap.PackedAddress), + Port: int(*ap.Port), + } + case pb.CreateSocketRequest_UDP: + return &net.UDPAddr{ + IP: net.IP(ap.PackedAddress), + Port: int(*ap.Port), + } + } + panic("unknown protocol " + prot.String()) +} + +func (cn *Conn) LocalAddr() net.Addr { return addr(cn.prot, cn.local) } +func (cn *Conn) RemoteAddr() net.Addr { return addr(cn.prot, cn.remote) } + +func (cn *Conn) SetDeadline(t time.Time) error { + cn.readDeadline = t + cn.writeDeadline = t + return nil +} + +func (cn *Conn) SetReadDeadline(t time.Time) error { + cn.readDeadline = t + return nil +} + +func (cn *Conn) SetWriteDeadline(t time.Time) error { + cn.writeDeadline = t + return nil +} + +// KeepAlive signals that the connection is still in use. +// It may be called to prevent the socket being closed due to inactivity. +func (cn *Conn) KeepAlive() error { + req := &pb.GetSocketNameRequest{ + SocketDescriptor: &cn.desc, + } + res := &pb.GetSocketNameReply{} + return internal.Call(cn.ctx, "remote_socket", "GetSocketName", req, res) +} + +func init() { + internal.RegisterErrorCodeMap("remote_socket", pb.RemoteSocketServiceError_ErrorCode_name) +} diff --git a/vendor/google.golang.org/appengine/socket/socket_vm.go b/vendor/google.golang.org/appengine/socket/socket_vm.go new file mode 100644 index 00000000..c804169a --- /dev/null +++ b/vendor/google.golang.org/appengine/socket/socket_vm.go @@ -0,0 +1,64 @@ +// Copyright 2015 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// +build !appengine + +package socket + +import ( + "net" + "time" + + "golang.org/x/net/context" +) + +// Dial connects to the address addr on the network protocol. +// The address format is host:port, where host may be a hostname or an IP address. +// Known protocols are "tcp" and "udp". +// The returned connection satisfies net.Conn, and is valid while ctx is valid; +// if the connection is to be used after ctx becomes invalid, invoke SetContext +// with the new context. +func Dial(ctx context.Context, protocol, addr string) (*Conn, error) { + conn, err := net.Dial(protocol, addr) + if err != nil { + return nil, err + } + return &Conn{conn}, nil +} + +// DialTimeout is like Dial but takes a timeout. +// The timeout includes name resolution, if required. +func DialTimeout(ctx context.Context, protocol, addr string, timeout time.Duration) (*Conn, error) { + conn, err := net.DialTimeout(protocol, addr, timeout) + if err != nil { + return nil, err + } + return &Conn{conn}, nil +} + +// LookupIP returns the given host's IP addresses. +func LookupIP(ctx context.Context, host string) (addrs []net.IP, err error) { + return net.LookupIP(host) +} + +// Conn represents a socket connection. +// It implements net.Conn. +type Conn struct { + net.Conn +} + +// SetContext sets the context that is used by this Conn. +// It is usually used only when using a Conn that was created in a different context, +// such as when a connection is created during a warmup request but used while +// servicing a user request. +func (cn *Conn) SetContext(ctx context.Context) { + // This function is not required in App Engine "flexible environment". +} + +// KeepAlive signals that the connection is still in use. +// It may be called to prevent the socket being closed due to inactivity. +func (cn *Conn) KeepAlive() error { + // This function is not required in App Engine "flexible environment". + return nil +} diff --git a/vendor/google.golang.org/appengine/timeout.go b/vendor/google.golang.org/appengine/timeout.go new file mode 100644 index 00000000..05642a99 --- /dev/null +++ b/vendor/google.golang.org/appengine/timeout.go @@ -0,0 +1,20 @@ +// Copyright 2013 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +package appengine + +import "golang.org/x/net/context" + +// IsTimeoutError reports whether err is a timeout error. +func IsTimeoutError(err error) bool { + if err == context.DeadlineExceeded { + return true + } + if t, ok := err.(interface { + IsTimeout() bool + }); ok { + return t.IsTimeout() + } + return false +} diff --git a/vendor/google.golang.org/appengine/urlfetch/urlfetch.go b/vendor/google.golang.org/appengine/urlfetch/urlfetch.go new file mode 100644 index 00000000..6ffe1e6d --- /dev/null +++ b/vendor/google.golang.org/appengine/urlfetch/urlfetch.go @@ -0,0 +1,210 @@ +// Copyright 2011 Google Inc. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// Package urlfetch provides an http.RoundTripper implementation +// for fetching URLs via App Engine's urlfetch service. +package urlfetch // import "google.golang.org/appengine/urlfetch" + +import ( + "errors" + "fmt" + "io" + "io/ioutil" + "net/http" + "net/url" + "strconv" + "strings" + "time" + + "github.com/golang/protobuf/proto" + "golang.org/x/net/context" + + "google.golang.org/appengine/internal" + pb "google.golang.org/appengine/internal/urlfetch" +) + +// Transport is an implementation of http.RoundTripper for +// App Engine. Users should generally create an http.Client using +// this transport and use the Client rather than using this transport +// directly. +type Transport struct { + Context context.Context + + // Controls whether the application checks the validity of SSL certificates + // over HTTPS connections. A value of false (the default) instructs the + // application to send a request to the server only if the certificate is + // valid and signed by a trusted certificate authority (CA), and also + // includes a hostname that matches the certificate. A value of true + // instructs the application to perform no certificate validation. + AllowInvalidServerCertificate bool +} + +// Verify statically that *Transport implements http.RoundTripper. +var _ http.RoundTripper = (*Transport)(nil) + +// Client returns an *http.Client using a default urlfetch Transport. This +// client will have the default deadline of 5 seconds, and will check the +// validity of SSL certificates. +// +// Any deadline of the provided context will be used for requests through this client; +// if the client does not have a deadline then a 5 second default is used. +func Client(ctx context.Context) *http.Client { + return &http.Client{ + Transport: &Transport{ + Context: ctx, + }, + } +} + +type bodyReader struct { + content []byte + truncated bool + closed bool +} + +// ErrTruncatedBody is the error returned after the final Read() from a +// response's Body if the body has been truncated by App Engine's proxy. +var ErrTruncatedBody = errors.New("urlfetch: truncated body") + +func statusCodeToText(code int) string { + if t := http.StatusText(code); t != "" { + return t + } + return strconv.Itoa(code) +} + +func (br *bodyReader) Read(p []byte) (n int, err error) { + if br.closed { + if br.truncated { + return 0, ErrTruncatedBody + } + return 0, io.EOF + } + n = copy(p, br.content) + if n > 0 { + br.content = br.content[n:] + return + } + if br.truncated { + br.closed = true + return 0, ErrTruncatedBody + } + return 0, io.EOF +} + +func (br *bodyReader) Close() error { + br.closed = true + br.content = nil + return nil +} + +// A map of the URL Fetch-accepted methods that take a request body. +var methodAcceptsRequestBody = map[string]bool{ + "POST": true, + "PUT": true, + "PATCH": true, +} + +// urlString returns a valid string given a URL. This function is necessary because +// the String method of URL doesn't correctly handle URLs with non-empty Opaque values. +// See http://code.google.com/p/go/issues/detail?id=4860. +func urlString(u *url.URL) string { + if u.Opaque == "" || strings.HasPrefix(u.Opaque, "//") { + return u.String() + } + aux := *u + aux.Opaque = "//" + aux.Host + aux.Opaque + return aux.String() +} + +// RoundTrip issues a single HTTP request and returns its response. Per the +// http.RoundTripper interface, RoundTrip only returns an error if there +// was an unsupported request or the URL Fetch proxy fails. +// Note that HTTP response codes such as 5xx, 403, 404, etc are not +// errors as far as the transport is concerned and will be returned +// with err set to nil. +func (t *Transport) RoundTrip(req *http.Request) (res *http.Response, err error) { + methNum, ok := pb.URLFetchRequest_RequestMethod_value[req.Method] + if !ok { + return nil, fmt.Errorf("urlfetch: unsupported HTTP method %q", req.Method) + } + + method := pb.URLFetchRequest_RequestMethod(methNum) + + freq := &pb.URLFetchRequest{ + Method: &method, + Url: proto.String(urlString(req.URL)), + FollowRedirects: proto.Bool(false), // http.Client's responsibility + MustValidateServerCertificate: proto.Bool(!t.AllowInvalidServerCertificate), + } + if deadline, ok := t.Context.Deadline(); ok { + freq.Deadline = proto.Float64(deadline.Sub(time.Now()).Seconds()) + } + + for k, vals := range req.Header { + for _, val := range vals { + freq.Header = append(freq.Header, &pb.URLFetchRequest_Header{ + Key: proto.String(k), + Value: proto.String(val), + }) + } + } + if methodAcceptsRequestBody[req.Method] && req.Body != nil { + // Avoid a []byte copy if req.Body has a Bytes method. + switch b := req.Body.(type) { + case interface { + Bytes() []byte + }: + freq.Payload = b.Bytes() + default: + freq.Payload, err = ioutil.ReadAll(req.Body) + if err != nil { + return nil, err + } + } + } + + fres := &pb.URLFetchResponse{} + if err := internal.Call(t.Context, "urlfetch", "Fetch", freq, fres); err != nil { + return nil, err + } + + res = &http.Response{} + res.StatusCode = int(*fres.StatusCode) + res.Status = fmt.Sprintf("%d %s", res.StatusCode, statusCodeToText(res.StatusCode)) + res.Header = make(http.Header) + res.Request = req + + // Faked: + res.ProtoMajor = 1 + res.ProtoMinor = 1 + res.Proto = "HTTP/1.1" + res.Close = true + + for _, h := range fres.Header { + hkey := http.CanonicalHeaderKey(*h.Key) + hval := *h.Value + if hkey == "Content-Length" { + // Will get filled in below for all but HEAD requests. + if req.Method == "HEAD" { + res.ContentLength, _ = strconv.ParseInt(hval, 10, 64) + } + continue + } + res.Header.Add(hkey, hval) + } + + if req.Method != "HEAD" { + res.ContentLength = int64(len(fres.Content)) + } + + truncated := fres.GetContentWasTruncated() + res.Body = &bodyReader{content: fres.Content, truncated: truncated} + return +} + +func init() { + internal.RegisterErrorCodeMap("urlfetch", pb.URLFetchServiceError_ErrorCode_name) + internal.RegisterTimeoutErrorCode("urlfetch", int32(pb.URLFetchServiceError_DEADLINE_EXCEEDED)) +} diff --git a/vendor/google.golang.org/cloud/LICENSE b/vendor/google.golang.org/cloud/LICENSE new file mode 100644 index 00000000..a4c5efd8 --- /dev/null +++ b/vendor/google.golang.org/cloud/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2014 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/google.golang.org/cloud/cloud.go b/vendor/google.golang.org/cloud/cloud.go new file mode 100644 index 00000000..98be1f45 --- /dev/null +++ b/vendor/google.golang.org/cloud/cloud.go @@ -0,0 +1,56 @@ +// Copyright 2014 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package cloud contains Google Cloud Platform APIs related types +// and common functions. +package cloud // import "google.golang.org/cloud" + +import ( + "net/http" + + "golang.org/x/net/context" + "google.golang.org/cloud/internal" +) + +// NewContext returns a new context that uses the provided http.Client. +// Provided http.Client is responsible to authorize and authenticate +// the requests made to the Google Cloud APIs. +// It mutates the client's original Transport to append the cloud +// package's user-agent to the outgoing requests. +// You can obtain the project ID from the Google Developers Console, +// https://console.developers.google.com. +func NewContext(projID string, c *http.Client) context.Context { + if c == nil { + panic("invalid nil *http.Client passed to NewContext") + } + return WithContext(context.Background(), projID, c) +} + +// WithContext returns a new context in a similar way NewContext does, +// but initiates the new context with the specified parent. +func WithContext(parent context.Context, projID string, c *http.Client) context.Context { + // TODO(bradfitz): delete internal.Transport. It's too wrappy for what it does. + // Do User-Agent some other way. + if c == nil { + panic("invalid nil *http.Client passed to WithContext") + } + if _, ok := c.Transport.(*internal.Transport); !ok { + base := c.Transport + if base == nil { + base = http.DefaultTransport + } + c.Transport = &internal.Transport{Base: base} + } + return internal.WithContext(parent, projID, c) +} diff --git a/vendor/google.golang.org/cloud/internal/cloud.go b/vendor/google.golang.org/cloud/internal/cloud.go new file mode 100644 index 00000000..59428803 --- /dev/null +++ b/vendor/google.golang.org/cloud/internal/cloud.go @@ -0,0 +1,128 @@ +// Copyright 2014 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package internal provides support for the cloud packages. +// +// Users should not import this package directly. +package internal + +import ( + "fmt" + "net/http" + "sync" + + "golang.org/x/net/context" +) + +type contextKey struct{} + +func WithContext(parent context.Context, projID string, c *http.Client) context.Context { + if c == nil { + panic("nil *http.Client passed to WithContext") + } + if projID == "" { + panic("empty project ID passed to WithContext") + } + return context.WithValue(parent, contextKey{}, &cloudContext{ + ProjectID: projID, + HTTPClient: c, + }) +} + +const userAgent = "gcloud-golang/0.1" + +type cloudContext struct { + ProjectID string + HTTPClient *http.Client + + mu sync.Mutex // guards svc + svc map[string]interface{} // e.g. "storage" => *rawStorage.Service +} + +// Service returns the result of the fill function if it's never been +// called before for the given name (which is assumed to be an API +// service name, like "datastore"). If it has already been cached, the fill +// func is not run. +// It's safe for concurrent use by multiple goroutines. +func Service(ctx context.Context, name string, fill func(*http.Client) interface{}) interface{} { + return cc(ctx).service(name, fill) +} + +func (c *cloudContext) service(name string, fill func(*http.Client) interface{}) interface{} { + c.mu.Lock() + defer c.mu.Unlock() + + if c.svc == nil { + c.svc = make(map[string]interface{}) + } else if v, ok := c.svc[name]; ok { + return v + } + v := fill(c.HTTPClient) + c.svc[name] = v + return v +} + +// Transport is an http.RoundTripper that appends +// Google Cloud client's user-agent to the original +// request's user-agent header. +type Transport struct { + // Base is the actual http.RoundTripper + // requests will use. It must not be nil. + Base http.RoundTripper +} + +// RoundTrip appends a user-agent to the existing user-agent +// header and delegates the request to the base http.RoundTripper. +func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) { + req = cloneRequest(req) + ua := req.Header.Get("User-Agent") + if ua == "" { + ua = userAgent + } else { + ua = fmt.Sprintf("%s %s", ua, userAgent) + } + req.Header.Set("User-Agent", ua) + return t.Base.RoundTrip(req) +} + +// cloneRequest returns a clone of the provided *http.Request. +// The clone is a shallow copy of the struct and its Header map. +func cloneRequest(r *http.Request) *http.Request { + // shallow copy of the struct + r2 := new(http.Request) + *r2 = *r + // deep copy of the Header + r2.Header = make(http.Header) + for k, s := range r.Header { + r2.Header[k] = s + } + return r2 +} + +func ProjID(ctx context.Context) string { + return cc(ctx).ProjectID +} + +func HTTPClient(ctx context.Context) *http.Client { + return cc(ctx).HTTPClient +} + +// cc returns the internal *cloudContext (cc) state for a context.Context. +// It panics if the user did it wrong. +func cc(ctx context.Context) *cloudContext { + if c, ok := ctx.Value(contextKey{}).(*cloudContext); ok { + return c + } + panic("invalid context.Context type; it should be created with cloud.NewContext") +} diff --git a/vendor/google.golang.org/cloud/internal/transport/dial.go b/vendor/google.golang.org/cloud/internal/transport/dial.go new file mode 100644 index 00000000..f554953f --- /dev/null +++ b/vendor/google.golang.org/cloud/internal/transport/dial.go @@ -0,0 +1,61 @@ +// Copyright 2015 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package transport + +import ( + "fmt" + "net/http" + + "golang.org/x/net/context" + "google.golang.org/api/option" + "google.golang.org/api/transport" + "google.golang.org/cloud" + "google.golang.org/grpc" +) + +// ErrHTTP is returned when on a non-200 HTTP response. +type ErrHTTP struct { + StatusCode int + Body []byte + err error +} + +func (e *ErrHTTP) Error() string { + if e.err == nil { + return fmt.Sprintf("error during call, http status code: %v %s", e.StatusCode, e.Body) + } + return e.err.Error() +} + +// NewHTTPClient returns an HTTP client for use communicating with a Google cloud +// service, configured with the given ClientOptions. It also returns the endpoint +// for the service as specified in the options. +func NewHTTPClient(ctx context.Context, opt ...cloud.ClientOption) (*http.Client, string, error) { + o := make([]option.ClientOption, 0, len(opt)) + for _, opt := range opt { + o = append(o, opt.Resolve()) + } + return transport.NewHTTPClient(ctx, o...) +} + +// DialGRPC returns a GRPC connection for use communicating with a Google cloud +// service, configured with the given ClientOptions. +func DialGRPC(ctx context.Context, opt ...cloud.ClientOption) (*grpc.ClientConn, error) { + o := make([]option.ClientOption, 0, len(opt)) + for _, opt := range opt { + o = append(o, opt.Resolve()) + } + return transport.DialGRPC(ctx, o...) +} diff --git a/vendor/google.golang.org/cloud/option.go b/vendor/google.golang.org/cloud/option.go new file mode 100644 index 00000000..c012c73e --- /dev/null +++ b/vendor/google.golang.org/cloud/option.go @@ -0,0 +1,88 @@ +// Copyright 2015 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cloud + +import ( + "net/http" + + "golang.org/x/oauth2" + "google.golang.org/api/option" + "google.golang.org/grpc" +) + +// ClientOption is used when construct clients for each cloud service. +type ClientOption interface { + // Resolve returns the equivalent option from the + // google.golang.org/api/option package. + Resolve() option.ClientOption +} + +type wrapOpt struct { + o option.ClientOption +} + +func (w wrapOpt) Resolve() option.ClientOption { + return w.o +} + +// WithTokenSource returns a ClientOption that specifies an OAuth2 token +// source to be used as the basis for authentication. +func WithTokenSource(s oauth2.TokenSource) ClientOption { + return wrapOpt{option.WithTokenSource(s)} +} + +// WithEndpoint returns a ClientOption that overrides the default endpoint +// to be used for a service. +func WithEndpoint(url string) ClientOption { + return wrapOpt{option.WithEndpoint(url)} +} + +// WithScopes returns a ClientOption that overrides the default OAuth2 scopes +// to be used for a service. +func WithScopes(scope ...string) ClientOption { + return wrapOpt{option.WithScopes(scope...)} +} + +// WithUserAgent returns a ClientOption that sets the User-Agent. +func WithUserAgent(ua string) ClientOption { + return wrapOpt{option.WithUserAgent(ua)} +} + +// WithBaseHTTP returns a ClientOption that specifies the HTTP client to +// use as the basis of communications. This option may only be used with +// services that support HTTP as their communication transport. +func WithBaseHTTP(client *http.Client) ClientOption { + return wrapOpt{option.WithHTTPClient(client)} +} + +// WithBaseGRPC returns a ClientOption that specifies the gRPC client +// connection to use as the basis of communications. This option many only be +// used with services that support gRPC as their communication transport. +func WithBaseGRPC(conn *grpc.ClientConn) ClientOption { + return wrapOpt{option.WithGRPCConn(conn)} +} + +// WithGRPCDialOption returns a ClientOption that appends a new grpc.DialOption +// to an underlying gRPC dial. It does not work with WithBaseGRPC. +func WithGRPCDialOption(o grpc.DialOption) ClientOption { + return wrapOpt{option.WithGRPCDialOption(o)} +} + +// WithGRPCConnectionPool returns a ClientOption that creates a pool of gRPC +// connections that requests will be balanced between. +// This is an EXPERIMENTAL API and may be changed or removed in the future. +func WithGRPCConnectionPool(size int) ClientOption { + return wrapOpt{option.WithGRPCConnectionPool(size)} +} diff --git a/vendor/google.golang.org/cloud/storage/acl.go b/vendor/google.golang.org/cloud/storage/acl.go new file mode 100644 index 00000000..e4d968b0 --- /dev/null +++ b/vendor/google.golang.org/cloud/storage/acl.go @@ -0,0 +1,198 @@ +// Copyright 2014 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package storage + +import ( + "fmt" + + "golang.org/x/net/context" + raw "google.golang.org/api/storage/v1" +) + +// ACLRole is the level of access to grant. +type ACLRole string + +const ( + RoleOwner ACLRole = "OWNER" + RoleReader ACLRole = "READER" +) + +// ACLEntity refers to a user or group. +// They are sometimes referred to as grantees. +// +// It could be in the form of: +// "user-", "user-", "group-", "group-", +// "domain-" and "project-team-". +// +// Or one of the predefined constants: AllUsers, AllAuthenticatedUsers. +type ACLEntity string + +const ( + AllUsers ACLEntity = "allUsers" + AllAuthenticatedUsers ACLEntity = "allAuthenticatedUsers" +) + +// ACLRule represents a grant for a role to an entity (user, group or team) for a Google Cloud Storage object or bucket. +type ACLRule struct { + Entity ACLEntity + Role ACLRole +} + +// ACLHandle provides operations on an access control list for a Google Cloud Storage bucket or object. +type ACLHandle struct { + c *Client + bucket string + object string + isDefault bool +} + +// Delete permanently deletes the ACL entry for the given entity. +func (a *ACLHandle) Delete(ctx context.Context, entity ACLEntity) error { + if a.object != "" { + return a.objectDelete(ctx, entity) + } + if a.isDefault { + return a.bucketDefaultDelete(ctx, entity) + } + return a.bucketDelete(ctx, entity) +} + +// Set sets the permission level for the given entity. +func (a *ACLHandle) Set(ctx context.Context, entity ACLEntity, role ACLRole) error { + if a.object != "" { + return a.objectSet(ctx, entity, role) + } + if a.isDefault { + return a.bucketDefaultSet(ctx, entity, role) + } + return a.bucketSet(ctx, entity, role) +} + +// List retrieves ACL entries. +func (a *ACLHandle) List(ctx context.Context) ([]ACLRule, error) { + if a.object != "" { + return a.objectList(ctx) + } + if a.isDefault { + return a.bucketDefaultList(ctx) + } + return a.bucketList(ctx) +} + +func (a *ACLHandle) bucketDefaultList(ctx context.Context) ([]ACLRule, error) { + acls, err := a.c.raw.DefaultObjectAccessControls.List(a.bucket).Context(ctx).Do() + if err != nil { + return nil, fmt.Errorf("storage: error listing default object ACL for bucket %q: %v", a.bucket, err) + } + return toACLRules(acls.Items), nil +} + +func (a *ACLHandle) bucketDefaultSet(ctx context.Context, entity ACLEntity, role ACLRole) error { + acl := &raw.ObjectAccessControl{ + Bucket: a.bucket, + Entity: string(entity), + Role: string(role), + } + _, err := a.c.raw.DefaultObjectAccessControls.Update(a.bucket, string(entity), acl).Context(ctx).Do() + if err != nil { + return fmt.Errorf("storage: error updating default ACL entry for bucket %q, entity %q: %v", a.bucket, entity, err) + } + return nil +} + +func (a *ACLHandle) bucketDefaultDelete(ctx context.Context, entity ACLEntity) error { + err := a.c.raw.DefaultObjectAccessControls.Delete(a.bucket, string(entity)).Context(ctx).Do() + if err != nil { + return fmt.Errorf("storage: error deleting default ACL entry for bucket %q, entity %q: %v", a.bucket, entity, err) + } + return nil +} + +func (a *ACLHandle) bucketList(ctx context.Context) ([]ACLRule, error) { + acls, err := a.c.raw.BucketAccessControls.List(a.bucket).Context(ctx).Do() + if err != nil { + return nil, fmt.Errorf("storage: error listing bucket ACL for bucket %q: %v", a.bucket, err) + } + r := make([]ACLRule, len(acls.Items)) + for i, v := range acls.Items { + r[i].Entity = ACLEntity(v.Entity) + r[i].Role = ACLRole(v.Role) + } + return r, nil +} + +func (a *ACLHandle) bucketSet(ctx context.Context, entity ACLEntity, role ACLRole) error { + acl := &raw.BucketAccessControl{ + Bucket: a.bucket, + Entity: string(entity), + Role: string(role), + } + _, err := a.c.raw.BucketAccessControls.Update(a.bucket, string(entity), acl).Context(ctx).Do() + if err != nil { + return fmt.Errorf("storage: error updating bucket ACL entry for bucket %q, entity %q: %v", a.bucket, entity, err) + } + return nil +} + +func (a *ACLHandle) bucketDelete(ctx context.Context, entity ACLEntity) error { + err := a.c.raw.BucketAccessControls.Delete(a.bucket, string(entity)).Context(ctx).Do() + if err != nil { + return fmt.Errorf("storage: error deleting bucket ACL entry for bucket %q, entity %q: %v", a.bucket, entity, err) + } + return nil +} + +func (a *ACLHandle) objectList(ctx context.Context) ([]ACLRule, error) { + acls, err := a.c.raw.ObjectAccessControls.List(a.bucket, a.object).Context(ctx).Do() + if err != nil { + return nil, fmt.Errorf("storage: error listing object ACL for bucket %q, file %q: %v", a.bucket, a.object, err) + } + return toACLRules(acls.Items), nil +} + +func (a *ACLHandle) objectSet(ctx context.Context, entity ACLEntity, role ACLRole) error { + acl := &raw.ObjectAccessControl{ + Bucket: a.bucket, + Entity: string(entity), + Role: string(role), + } + _, err := a.c.raw.ObjectAccessControls.Update(a.bucket, a.object, string(entity), acl).Context(ctx).Do() + if err != nil { + return fmt.Errorf("storage: error updating object ACL entry for bucket %q, file %q, entity %q: %v", a.bucket, a.object, entity, err) + } + return nil +} + +func (a *ACLHandle) objectDelete(ctx context.Context, entity ACLEntity) error { + err := a.c.raw.ObjectAccessControls.Delete(a.bucket, a.object, string(entity)).Context(ctx).Do() + if err != nil { + return fmt.Errorf("storage: error deleting object ACL entry for bucket %q, file %q, entity %q: %v", a.bucket, a.object, entity, err) + } + return nil +} + +func toACLRules(items []interface{}) []ACLRule { + r := make([]ACLRule, 0, len(items)) + for _, v := range items { + if m, ok := v.(map[string]interface{}); ok { + entity, ok1 := m["entity"].(string) + role, ok2 := m["role"].(string) + if ok1 && ok2 { + r = append(r, ACLRule{Entity: ACLEntity(entity), Role: ACLRole(role)}) + } + } + } + return r +} diff --git a/vendor/google.golang.org/cloud/storage/reader.go b/vendor/google.golang.org/cloud/storage/reader.go new file mode 100644 index 00000000..9e21648e --- /dev/null +++ b/vendor/google.golang.org/cloud/storage/reader.go @@ -0,0 +1,55 @@ +// Copyright 2016 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package storage + +import ( + "io" +) + +// Reader reads a Cloud Storage object. +type Reader struct { + body io.ReadCloser + remain, size int64 + contentType string +} + +func (r *Reader) Close() error { + return r.body.Close() +} + +func (r *Reader) Read(p []byte) (int, error) { + n, err := r.body.Read(p) + if r.remain != -1 { + r.remain -= int64(n) + } + return n, err +} + +// Size returns the size of the object in bytes. +// The returned value is always the same and is not affected by +// calls to Read or Close. +func (r *Reader) Size() int64 { + return r.size +} + +// Remain returns the number of bytes left to read, or -1 if unknown. +func (r *Reader) Remain() int64 { + return r.remain +} + +// ContentType returns the content type of the object. +func (r *Reader) ContentType() string { + return r.contentType +} diff --git a/vendor/google.golang.org/cloud/storage/storage.go b/vendor/google.golang.org/cloud/storage/storage.go new file mode 100644 index 00000000..85dca803 --- /dev/null +++ b/vendor/google.golang.org/cloud/storage/storage.go @@ -0,0 +1,1204 @@ +// Copyright 2014 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package storage contains a Google Cloud Storage client. +// +// This package is experimental and may make backwards-incompatible changes. +package storage // import "google.golang.org/cloud/storage" + +import ( + "bytes" + "crypto" + "crypto/rand" + "crypto/rsa" + "crypto/sha256" + "crypto/x509" + "encoding/base64" + "encoding/pem" + "errors" + "fmt" + "io" + "io/ioutil" + "net/http" + "net/url" + "reflect" + "strconv" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/cloud" + "google.golang.org/cloud/internal/transport" + + "golang.org/x/net/context" + "google.golang.org/api/googleapi" + raw "google.golang.org/api/storage/v1" +) + +var ( + ErrBucketNotExist = errors.New("storage: bucket doesn't exist") + ErrObjectNotExist = errors.New("storage: object doesn't exist") + + // Done is returned by iterators in this package when they have no more items. + Done = errors.New("storage: no more results") +) + +const userAgent = "gcloud-golang-storage/20151204" + +const ( + // ScopeFullControl grants permissions to manage your + // data and permissions in Google Cloud Storage. + ScopeFullControl = raw.DevstorageFullControlScope + + // ScopeReadOnly grants permissions to + // view your data in Google Cloud Storage. + ScopeReadOnly = raw.DevstorageReadOnlyScope + + // ScopeReadWrite grants permissions to manage your + // data in Google Cloud Storage. + ScopeReadWrite = raw.DevstorageReadWriteScope +) + +// AdminClient is a client type for performing admin operations on a project's +// buckets. +// +// Deprecated: Client has all of AdminClient's methods. +type AdminClient struct { + c *Client + projectID string +} + +// NewAdminClient creates a new AdminClient for a given project. +// +// Deprecated: use NewClient instead. +func NewAdminClient(ctx context.Context, projectID string, opts ...cloud.ClientOption) (*AdminClient, error) { + c, err := NewClient(ctx, opts...) + if err != nil { + return nil, err + } + return &AdminClient{ + c: c, + projectID: projectID, + }, nil +} + +// Close closes the AdminClient. +func (c *AdminClient) Close() error { + return c.c.Close() +} + +// Create creates a Bucket in the project. +// If attrs is nil the API defaults will be used. +// +// Deprecated: use BucketHandle.Create instead. +func (c *AdminClient) CreateBucket(ctx context.Context, bucketName string, attrs *BucketAttrs) error { + return c.c.Bucket(bucketName).Create(ctx, c.projectID, attrs) +} + +// Delete deletes a Bucket in the project. +// +// Deprecated: use BucketHandle.Delete instead. +func (c *AdminClient) DeleteBucket(ctx context.Context, bucketName string) error { + return c.c.Bucket(bucketName).Delete(ctx) +} + +// Client is a client for interacting with Google Cloud Storage. +type Client struct { + hc *http.Client + raw *raw.Service +} + +// NewClient creates a new Google Cloud Storage client. +// The default scope is ScopeFullControl. To use a different scope, like ScopeReadOnly, use cloud.WithScopes. +func NewClient(ctx context.Context, opts ...cloud.ClientOption) (*Client, error) { + o := []cloud.ClientOption{ + cloud.WithScopes(ScopeFullControl), + cloud.WithUserAgent(userAgent), + } + opts = append(o, opts...) + hc, _, err := transport.NewHTTPClient(ctx, opts...) + if err != nil { + return nil, fmt.Errorf("dialing: %v", err) + } + rawService, err := raw.New(hc) + if err != nil { + return nil, fmt.Errorf("storage client: %v", err) + } + return &Client{ + hc: hc, + raw: rawService, + }, nil +} + +// Close closes the Client. +func (c *Client) Close() error { + c.hc = nil + return nil +} + +// BucketHandle provides operations on a Google Cloud Storage bucket. +// Use Client.Bucket to get a handle. +type BucketHandle struct { + acl *ACLHandle + defaultObjectACL *ACLHandle + + c *Client + name string +} + +// Bucket returns a BucketHandle, which provides operations on the named bucket. +// This call does not perform any network operations. +// +// name must contain only lowercase letters, numbers, dashes, underscores, and +// dots. The full specification for valid bucket names can be found at: +// https://cloud.google.com/storage/docs/bucket-naming +func (c *Client) Bucket(name string) *BucketHandle { + return &BucketHandle{ + c: c, + name: name, + acl: &ACLHandle{ + c: c, + bucket: name, + }, + defaultObjectACL: &ACLHandle{ + c: c, + bucket: name, + isDefault: true, + }, + } +} + +// Create creates the Bucket in the project. +// If attrs is nil the API defaults will be used. +func (b *BucketHandle) Create(ctx context.Context, projectID string, attrs *BucketAttrs) error { + var bkt *raw.Bucket + if attrs != nil { + bkt = attrs.toRawBucket() + } else { + bkt = &raw.Bucket{} + } + bkt.Name = b.name + req := b.c.raw.Buckets.Insert(projectID, bkt) + _, err := req.Context(ctx).Do() + return err +} + +// Delete deletes the Bucket. +func (b *BucketHandle) Delete(ctx context.Context) error { + req := b.c.raw.Buckets.Delete(b.name) + return req.Context(ctx).Do() +} + +// ACL returns an ACLHandle, which provides access to the bucket's access control list. +// This controls who can list, create or overwrite the objects in a bucket. +// This call does not perform any network operations. +func (c *BucketHandle) ACL() *ACLHandle { + return c.acl +} + +// DefaultObjectACL returns an ACLHandle, which provides access to the bucket's default object ACLs. +// These ACLs are applied to newly created objects in this bucket that do not have a defined ACL. +// This call does not perform any network operations. +func (c *BucketHandle) DefaultObjectACL() *ACLHandle { + return c.defaultObjectACL +} + +// Object returns an ObjectHandle, which provides operations on the named object. +// This call does not perform any network operations. +// +// name must consist entirely of valid UTF-8-encoded runes. The full specification +// for valid object names can be found at: +// https://cloud.google.com/storage/docs/bucket-naming +func (b *BucketHandle) Object(name string) *ObjectHandle { + return &ObjectHandle{ + c: b.c, + bucket: b.name, + object: name, + acl: &ACLHandle{ + c: b.c, + bucket: b.name, + object: name, + }, + } +} + +// TODO(jbd): Add storage.buckets.list. +// TODO(jbd): Add storage.buckets.update. + +// TODO(jbd): Add storage.objects.watch. + +// Attrs returns the metadata for the bucket. +func (b *BucketHandle) Attrs(ctx context.Context) (*BucketAttrs, error) { + resp, err := b.c.raw.Buckets.Get(b.name).Projection("full").Context(ctx).Do() + if e, ok := err.(*googleapi.Error); ok && e.Code == http.StatusNotFound { + return nil, ErrBucketNotExist + } + if err != nil { + return nil, err + } + return newBucket(resp), nil +} + +// List lists objects from the bucket. You can specify a query +// to filter the results. If q is nil, no filtering is applied. +// +// Deprecated. Use BucketHandle.Objects instead. +func (b *BucketHandle) List(ctx context.Context, q *Query) (*ObjectList, error) { + it := b.Objects(ctx, q) + attrs, pres, err := it.NextPage() + if err != nil && err != Done { + return nil, err + } + objects := &ObjectList{ + Results: attrs, + Prefixes: pres, + } + if it.NextPageToken() != "" { + objects.Next = &it.query + } + return objects, nil +} + +func (b *BucketHandle) Objects(ctx context.Context, q *Query) *ObjectIterator { + it := &ObjectIterator{ + ctx: ctx, + bucket: b, + } + if q != nil { + it.query = *q + } + return it +} + +type ObjectIterator struct { + ctx context.Context + bucket *BucketHandle + query Query + pageSize int32 + objs []*ObjectAttrs + prefixes []string + err error +} + +// Next returns the next result. Its second return value is Done if there are +// no more results. Once Next returns Done, all subsequent calls will return +// Done. +// +// Internally, Next retrieves results in bulk. You can call SetPageSize as a +// performance hint to affect how many results are retrieved in a single RPC. +// +// SetPageToken should not be called when using Next. +// +// Next and NextPage should not be used with the same iterator. +// +// If Query.Delimiter is non-empty, Next returns an error. Use NextPage when using delimiters. +func (it *ObjectIterator) Next() (*ObjectAttrs, error) { + if it.query.Delimiter != "" { + return nil, errors.New("cannot use ObjectIterator.Next with a delimiter") + } + for len(it.objs) == 0 { // "for", not "if", to handle empty pages + if it.err != nil { + return nil, it.err + } + it.nextPage() + if it.err != nil { + it.objs = nil + return nil, it.err + } + if it.query.Cursor == "" { + it.err = Done + } + } + o := it.objs[0] + it.objs = it.objs[1:] + return o, nil +} + +const DefaultPageSize = 1000 + +// NextPage returns the next page of results, both objects (as *ObjectAttrs) +// and prefixes. Prefixes will be nil if query.Delimiter is empty. +// +// NextPage will return exactly the number of results (the total of objects and +// prefixes) specified by the last call to SetPageSize, unless there are not +// enough results available. If no page size was specified, it uses +// DefaultPageSize. +// +// NextPage may return a second return value of Done along with the last page +// of results. +// +// After NextPage returns Done, all subsequent calls to NextPage will return +// (nil, Done). +// +// Next and NextPage should not be used with the same iterator. +func (it *ObjectIterator) NextPage() (objs []*ObjectAttrs, prefixes []string, err error) { + defer it.SetPageSize(it.pageSize) // restore value at entry + if it.pageSize <= 0 { + it.pageSize = DefaultPageSize + } + for len(objs)+len(prefixes) < int(it.pageSize) { + it.pageSize -= int32(len(objs) + len(prefixes)) + it.nextPage() + if it.err != nil { + return nil, nil, it.err + } + objs = append(objs, it.objs...) + prefixes = append(prefixes, it.prefixes...) + if it.query.Cursor == "" { + it.err = Done + return objs, prefixes, it.err + } + } + return objs, prefixes, it.err +} + +// nextPage gets the next page of results by making a single call to the underlying method. +// It sets it.objs, it.prefixes, it.query.Cursor, and it.err. It never sets it.err to Done. +func (it *ObjectIterator) nextPage() { + if it.err != nil { + return + } + req := it.bucket.c.raw.Objects.List(it.bucket.name) + req.Projection("full") + req.Delimiter(it.query.Delimiter) + req.Prefix(it.query.Prefix) + req.Versions(it.query.Versions) + req.PageToken(it.query.Cursor) + if it.pageSize > 0 { + req.MaxResults(int64(it.pageSize)) + } + resp, err := req.Context(it.ctx).Do() + if err != nil { + it.err = err + return + } + it.query.Cursor = resp.NextPageToken + it.objs = nil + for _, item := range resp.Items { + it.objs = append(it.objs, newObject(item)) + } + it.prefixes = resp.Prefixes +} + +// SetPageSize sets the page size for all subsequent calls to NextPage. +// NextPage will return exactly this many items if they are present. +func (it *ObjectIterator) SetPageSize(pageSize int32) { + it.pageSize = pageSize +} + +// SetPageToken sets the page token for the next call to NextPage, to resume +// the iteration from a previous point. +func (it *ObjectIterator) SetPageToken(t string) { + it.query.Cursor = t +} + +// NextPageToken returns a page token that can be used with SetPageToken to +// resume iteration from the next page. It returns the empty string if there +// are no more pages. For an example, see SetPageToken. +func (it *ObjectIterator) NextPageToken() string { + return it.query.Cursor +} + +// SignedURLOptions allows you to restrict the access to the signed URL. +type SignedURLOptions struct { + // GoogleAccessID represents the authorizer of the signed URL generation. + // It is typically the Google service account client email address from + // the Google Developers Console in the form of "xxx@developer.gserviceaccount.com". + // Required. + GoogleAccessID string + + // PrivateKey is the Google service account private key. It is obtainable + // from the Google Developers Console. + // At https://console.developers.google.com/project//apiui/credential, + // create a service account client ID or reuse one of your existing service account + // credentials. Click on the "Generate new P12 key" to generate and download + // a new private key. Once you download the P12 file, use the following command + // to convert it into a PEM file. + // + // $ openssl pkcs12 -in key.p12 -passin pass:notasecret -out key.pem -nodes + // + // Provide the contents of the PEM file as a byte slice. + // Exactly one of PrivateKey or SignBytes must be non-nil. + PrivateKey []byte + + // SignBytes is a function for implementing custom signing. + // If your application is running on Google App Engine, you can use appengine's internal signing function: + // ctx := appengine.NewContext(request) + // acc, _ := appengine.ServiceAccount(ctx) + // url, err := SignedURL("bucket", "object", &SignedURLOptions{ + // GoogleAccessID: acc, + // SignBytes: func(b []byte) ([]byte, error) { + // _, signedBytes, err := appengine.SignBytes(ctx, b) + // return signedBytes, err + // }, + // // etc. + // }) + // + // Exactly one of PrivateKey or SignBytes must be non-nil. + SignBytes func([]byte) ([]byte, error) + + // Method is the HTTP method to be used with the signed URL. + // Signed URLs can be used with GET, HEAD, PUT, and DELETE requests. + // Required. + Method string + + // Expires is the expiration time on the signed URL. It must be + // a datetime in the future. + // Required. + Expires time.Time + + // ContentType is the content type header the client must provide + // to use the generated signed URL. + // Optional. + ContentType string + + // Headers is a list of extention headers the client must provide + // in order to use the generated signed URL. + // Optional. + Headers []string + + // MD5 is the base64 encoded MD5 checksum of the file. + // If provided, the client should provide the exact value on the request + // header in order to use the signed URL. + // Optional. + MD5 []byte +} + +// SignedURL returns a URL for the specified object. Signed URLs allow +// the users access to a restricted resource for a limited time without having a +// Google account or signing in. For more information about the signed +// URLs, see https://cloud.google.com/storage/docs/accesscontrol#Signed-URLs. +func SignedURL(bucket, name string, opts *SignedURLOptions) (string, error) { + if opts == nil { + return "", errors.New("storage: missing required SignedURLOptions") + } + if opts.GoogleAccessID == "" { + return "", errors.New("storage: missing required GoogleAccessID") + } + if (opts.PrivateKey == nil) == (opts.SignBytes == nil) { + return "", errors.New("storage: exactly one of PrivateKey or SignedBytes must be set") + } + if opts.Method == "" { + return "", errors.New("storage: missing required method option") + } + if opts.Expires.IsZero() { + return "", errors.New("storage: missing required expires option") + } + + signBytes := opts.SignBytes + if opts.PrivateKey != nil { + key, err := parseKey(opts.PrivateKey) + if err != nil { + return "", err + } + signBytes = func(b []byte) ([]byte, error) { + sum := sha256.Sum256(b) + return rsa.SignPKCS1v15( + rand.Reader, + key, + crypto.SHA256, + sum[:], + ) + } + } else { + signBytes = opts.SignBytes + } + + u := &url.URL{ + Path: fmt.Sprintf("/%s/%s", bucket, name), + } + + buf := &bytes.Buffer{} + fmt.Fprintf(buf, "%s\n", opts.Method) + fmt.Fprintf(buf, "%s\n", opts.MD5) + fmt.Fprintf(buf, "%s\n", opts.ContentType) + fmt.Fprintf(buf, "%d\n", opts.Expires.Unix()) + fmt.Fprintf(buf, "%s", strings.Join(opts.Headers, "\n")) + fmt.Fprintf(buf, "%s", u.String()) + + b, err := signBytes(buf.Bytes()) + if err != nil { + return "", err + } + encoded := base64.StdEncoding.EncodeToString(b) + u.Scheme = "https" + u.Host = "storage.googleapis.com" + q := u.Query() + q.Set("GoogleAccessId", opts.GoogleAccessID) + q.Set("Expires", fmt.Sprintf("%d", opts.Expires.Unix())) + q.Set("Signature", string(encoded)) + u.RawQuery = q.Encode() + return u.String(), nil +} + +// ObjectHandle provides operations on an object in a Google Cloud Storage bucket. +// Use BucketHandle.Object to get a handle. +type ObjectHandle struct { + c *Client + bucket string + object string + + acl *ACLHandle + conds []Condition +} + +// ACL provides access to the object's access control list. +// This controls who can read and write this object. +// This call does not perform any network operations. +func (o *ObjectHandle) ACL() *ACLHandle { + return o.acl +} + +// WithConditions returns a copy of o using the provided conditions. +func (o *ObjectHandle) WithConditions(conds ...Condition) *ObjectHandle { + o2 := *o + o2.conds = conds + return &o2 +} + +// Attrs returns meta information about the object. +// ErrObjectNotExist will be returned if the object is not found. +func (o *ObjectHandle) Attrs(ctx context.Context) (*ObjectAttrs, error) { + if !utf8.ValidString(o.object) { + return nil, fmt.Errorf("storage: object name %q is not valid UTF-8", o.object) + } + call := o.c.raw.Objects.Get(o.bucket, o.object).Projection("full").Context(ctx) + if err := applyConds("Attrs", o.conds, call); err != nil { + return nil, err + } + obj, err := call.Do() + if e, ok := err.(*googleapi.Error); ok && e.Code == http.StatusNotFound { + return nil, ErrObjectNotExist + } + if err != nil { + return nil, err + } + return newObject(obj), nil +} + +// Update updates an object with the provided attributes. +// All zero-value attributes are ignored. +// ErrObjectNotExist will be returned if the object is not found. +func (o *ObjectHandle) Update(ctx context.Context, attrs ObjectAttrs) (*ObjectAttrs, error) { + if !utf8.ValidString(o.object) { + return nil, fmt.Errorf("storage: object name %q is not valid UTF-8", o.object) + } + call := o.c.raw.Objects.Patch(o.bucket, o.object, attrs.toRawObject(o.bucket)).Projection("full").Context(ctx) + if err := applyConds("Update", o.conds, call); err != nil { + return nil, err + } + obj, err := call.Do() + if e, ok := err.(*googleapi.Error); ok && e.Code == http.StatusNotFound { + return nil, ErrObjectNotExist + } + if err != nil { + return nil, err + } + return newObject(obj), nil +} + +// Delete deletes the single specified object. +func (o *ObjectHandle) Delete(ctx context.Context) error { + if !utf8.ValidString(o.object) { + return fmt.Errorf("storage: object name %q is not valid UTF-8", o.object) + } + call := o.c.raw.Objects.Delete(o.bucket, o.object).Context(ctx) + if err := applyConds("Delete", o.conds, call); err != nil { + return err + } + err := call.Do() + switch e := err.(type) { + case nil: + return nil + case *googleapi.Error: + if e.Code == http.StatusNotFound { + return ErrObjectNotExist + } + } + return err +} + +// CopyTo copies the object to the given dst. +// The copied object's attributes are overwritten by attrs if non-nil. +func (o *ObjectHandle) CopyTo(ctx context.Context, dst *ObjectHandle, attrs *ObjectAttrs) (*ObjectAttrs, error) { + // TODO(djd): move bucket/object name validation to a single helper func. + if o.bucket == "" || dst.bucket == "" { + return nil, errors.New("storage: the source and destination bucket names must both be non-empty") + } + if o.object == "" || dst.object == "" { + return nil, errors.New("storage: the source and destination object names must both be non-empty") + } + if !utf8.ValidString(o.object) { + return nil, fmt.Errorf("storage: object name %q is not valid UTF-8", o.object) + } + if !utf8.ValidString(dst.object) { + return nil, fmt.Errorf("storage: dst name %q is not valid UTF-8", dst.object) + } + var rawObject *raw.Object + if attrs != nil { + attrs.Name = dst.object + if attrs.ContentType == "" { + return nil, errors.New("storage: attrs.ContentType must be non-empty") + } + rawObject = attrs.toRawObject(dst.bucket) + } + call := o.c.raw.Objects.Copy(o.bucket, o.object, dst.bucket, dst.object, rawObject).Projection("full").Context(ctx) + if err := applyConds("CopyTo destination", dst.conds, call); err != nil { + return nil, err + } + if err := applyConds("CopyTo source", toSourceConds(o.conds), call); err != nil { + return nil, err + } + obj, err := call.Do() + if err != nil { + return nil, err + } + return newObject(obj), nil +} + +// NewReader creates a new Reader to read the contents of the +// object. +// ErrObjectNotExist will be returned if the object is not found. +func (o *ObjectHandle) NewReader(ctx context.Context) (*Reader, error) { + return o.NewRangeReader(ctx, 0, -1) +} + +// NewRangeReader reads part of an object, reading at most length bytes +// starting at the given offset. If length is negative, the object is read +// until the end. +func (o *ObjectHandle) NewRangeReader(ctx context.Context, offset, length int64) (*Reader, error) { + if !utf8.ValidString(o.object) { + return nil, fmt.Errorf("storage: object name %q is not valid UTF-8", o.object) + } + if offset < 0 { + return nil, fmt.Errorf("storage: invalid offset %d < 0", offset) + } + u := &url.URL{ + Scheme: "https", + Host: "storage.googleapis.com", + Path: fmt.Sprintf("/%s/%s", o.bucket, o.object), + } + verb := "GET" + if length == 0 { + verb = "HEAD" + } + req, err := http.NewRequest(verb, u.String(), nil) + if err != nil { + return nil, err + } + if err := applyConds("NewReader", o.conds, objectsGetCall{req}); err != nil { + return nil, err + } + if length < 0 && offset > 0 { + req.Header.Set("Range", fmt.Sprintf("bytes=%d-", offset)) + } else if length > 0 { + req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", offset, offset+length-1)) + } + res, err := o.c.hc.Do(req) + if err != nil { + return nil, err + } + if res.StatusCode == http.StatusNotFound { + res.Body.Close() + return nil, ErrObjectNotExist + } + if res.StatusCode < 200 || res.StatusCode > 299 { + body, _ := ioutil.ReadAll(res.Body) + res.Body.Close() + return nil, &googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + Body: string(body), + } + } + if offset > 0 && length != 0 && res.StatusCode != http.StatusPartialContent { + res.Body.Close() + return nil, errors.New("storage: partial request not satisfied") + } + clHeader := res.Header.Get("X-Goog-Stored-Content-Length") + cl, err := strconv.ParseInt(clHeader, 10, 64) + if err != nil { + return nil, fmt.Errorf("storage: can't parse content length %q: %v", clHeader, err) + } + remain := res.ContentLength + body := res.Body + if length == 0 { + remain = 0 + body.Close() + body = emptyBody + } + return &Reader{ + body: body, + size: cl, + remain: remain, + contentType: res.Header.Get("Content-Type"), + }, nil +} + +var emptyBody = ioutil.NopCloser(strings.NewReader("")) + +// NewWriter returns a storage Writer that writes to the GCS object +// associated with this ObjectHandle. +// +// A new object will be created if an object with this name already exists. +// Otherwise any previous object with the same name will be replaced. +// The object will not be available (and any previous object will remain) +// until Close has been called. +// +// Attributes can be set on the object by modifying the returned Writer's +// ObjectAttrs field before the first call to Write. If no ContentType +// attribute is specified, the content type will be automatically sniffed +// using net/http.DetectContentType. +// +// It is the caller's responsibility to call Close when writing is done. +func (o *ObjectHandle) NewWriter(ctx context.Context) *Writer { + return &Writer{ + ctx: ctx, + o: o, + donec: make(chan struct{}), + ObjectAttrs: ObjectAttrs{Name: o.object}, + } +} + +// parseKey converts the binary contents of a private key file +// to an *rsa.PrivateKey. It detects whether the private key is in a +// PEM container or not. If so, it extracts the the private key +// from PEM container before conversion. It only supports PEM +// containers with no passphrase. +func parseKey(key []byte) (*rsa.PrivateKey, error) { + if block, _ := pem.Decode(key); block != nil { + key = block.Bytes + } + parsedKey, err := x509.ParsePKCS8PrivateKey(key) + if err != nil { + parsedKey, err = x509.ParsePKCS1PrivateKey(key) + if err != nil { + return nil, err + } + } + parsed, ok := parsedKey.(*rsa.PrivateKey) + if !ok { + return nil, errors.New("oauth2: private key is invalid") + } + return parsed, nil +} + +// BucketAttrs represents the metadata for a Google Cloud Storage bucket. +type BucketAttrs struct { + // Name is the name of the bucket. + Name string + + // ACL is the list of access control rules on the bucket. + ACL []ACLRule + + // DefaultObjectACL is the list of access controls to + // apply to new objects when no object ACL is provided. + DefaultObjectACL []ACLRule + + // Location is the location of the bucket. It defaults to "US". + Location string + + // MetaGeneration is the metadata generation of the bucket. + MetaGeneration int64 + + // StorageClass is the storage class of the bucket. This defines + // how objects in the bucket are stored and determines the SLA + // and the cost of storage. Typical values are "STANDARD" and + // "DURABLE_REDUCED_AVAILABILITY". Defaults to "STANDARD". + StorageClass string + + // Created is the creation time of the bucket. + Created time.Time +} + +func newBucket(b *raw.Bucket) *BucketAttrs { + if b == nil { + return nil + } + bucket := &BucketAttrs{ + Name: b.Name, + Location: b.Location, + MetaGeneration: b.Metageneration, + StorageClass: b.StorageClass, + Created: convertTime(b.TimeCreated), + } + acl := make([]ACLRule, len(b.Acl)) + for i, rule := range b.Acl { + acl[i] = ACLRule{ + Entity: ACLEntity(rule.Entity), + Role: ACLRole(rule.Role), + } + } + bucket.ACL = acl + objACL := make([]ACLRule, len(b.DefaultObjectAcl)) + for i, rule := range b.DefaultObjectAcl { + objACL[i] = ACLRule{ + Entity: ACLEntity(rule.Entity), + Role: ACLRole(rule.Role), + } + } + bucket.DefaultObjectACL = objACL + return bucket +} + +func toRawObjectACL(oldACL []ACLRule) []*raw.ObjectAccessControl { + var acl []*raw.ObjectAccessControl + if len(oldACL) > 0 { + acl = make([]*raw.ObjectAccessControl, len(oldACL)) + for i, rule := range oldACL { + acl[i] = &raw.ObjectAccessControl{ + Entity: string(rule.Entity), + Role: string(rule.Role), + } + } + } + return acl +} + +// toRawBucket copies the editable attribute from b to the raw library's Bucket type. +func (b *BucketAttrs) toRawBucket() *raw.Bucket { + var acl []*raw.BucketAccessControl + if len(b.ACL) > 0 { + acl = make([]*raw.BucketAccessControl, len(b.ACL)) + for i, rule := range b.ACL { + acl[i] = &raw.BucketAccessControl{ + Entity: string(rule.Entity), + Role: string(rule.Role), + } + } + } + dACL := toRawObjectACL(b.DefaultObjectACL) + return &raw.Bucket{ + Name: b.Name, + DefaultObjectAcl: dACL, + Location: b.Location, + StorageClass: b.StorageClass, + Acl: acl, + } +} + +// toRawObject copies the editable attributes from o to the raw library's Object type. +func (o ObjectAttrs) toRawObject(bucket string) *raw.Object { + acl := toRawObjectACL(o.ACL) + return &raw.Object{ + Bucket: bucket, + Name: o.Name, + ContentType: o.ContentType, + ContentEncoding: o.ContentEncoding, + ContentLanguage: o.ContentLanguage, + CacheControl: o.CacheControl, + ContentDisposition: o.ContentDisposition, + Acl: acl, + Metadata: o.Metadata, + } +} + +// ObjectAttrs represents the metadata for a Google Cloud Storage (GCS) object. +type ObjectAttrs struct { + // Bucket is the name of the bucket containing this GCS object. + // This field is read-only. + Bucket string + + // Name is the name of the object within the bucket. + // This field is read-only. + Name string + + // ContentType is the MIME type of the object's content. + ContentType string + + // ContentLanguage is the content language of the object's content. + ContentLanguage string + + // CacheControl is the Cache-Control header to be sent in the response + // headers when serving the object data. + CacheControl string + + // ACL is the list of access control rules for the object. + ACL []ACLRule + + // Owner is the owner of the object. This field is read-only. + // + // If non-zero, it is in the form of "user-". + Owner string + + // Size is the length of the object's content. This field is read-only. + Size int64 + + // ContentEncoding is the encoding of the object's content. + ContentEncoding string + + // ContentDisposition is the optional Content-Disposition header of the object + // sent in the response headers. + ContentDisposition string + + // MD5 is the MD5 hash of the object's content. This field is read-only. + MD5 []byte + + // CRC32C is the CRC32 checksum of the object's content using + // the Castagnoli93 polynomial. This field is read-only. + CRC32C uint32 + + // MediaLink is an URL to the object's content. This field is read-only. + MediaLink string + + // Metadata represents user-provided metadata, in key/value pairs. + // It can be nil if no metadata is provided. + Metadata map[string]string + + // Generation is the generation number of the object's content. + // This field is read-only. + Generation int64 + + // MetaGeneration is the version of the metadata for this + // object at this generation. This field is used for preconditions + // and for detecting changes in metadata. A metageneration number + // is only meaningful in the context of a particular generation + // of a particular object. This field is read-only. + MetaGeneration int64 + + // StorageClass is the storage class of the bucket. + // This value defines how objects in the bucket are stored and + // determines the SLA and the cost of storage. Typical values are + // "STANDARD" and "DURABLE_REDUCED_AVAILABILITY". + // It defaults to "STANDARD". This field is read-only. + StorageClass string + + // Created is the time the object was created. This field is read-only. + Created time.Time + + // Deleted is the time the object was deleted. + // If not deleted, it is the zero value. This field is read-only. + Deleted time.Time + + // Updated is the creation or modification time of the object. + // For buckets with versioning enabled, changing an object's + // metadata does not change this property. This field is read-only. + Updated time.Time +} + +// convertTime converts a time in RFC3339 format to time.Time. +// If any error occurs in parsing, the zero-value time.Time is silently returned. +func convertTime(t string) time.Time { + var r time.Time + if t != "" { + r, _ = time.Parse(time.RFC3339, t) + } + return r +} + +func newObject(o *raw.Object) *ObjectAttrs { + if o == nil { + return nil + } + acl := make([]ACLRule, len(o.Acl)) + for i, rule := range o.Acl { + acl[i] = ACLRule{ + Entity: ACLEntity(rule.Entity), + Role: ACLRole(rule.Role), + } + } + owner := "" + if o.Owner != nil { + owner = o.Owner.Entity + } + md5, _ := base64.StdEncoding.DecodeString(o.Md5Hash) + var crc32c uint32 + d, err := base64.StdEncoding.DecodeString(o.Crc32c) + if err == nil && len(d) == 4 { + crc32c = uint32(d[0])<<24 + uint32(d[1])<<16 + uint32(d[2])<<8 + uint32(d[3]) + } + return &ObjectAttrs{ + Bucket: o.Bucket, + Name: o.Name, + ContentType: o.ContentType, + ContentLanguage: o.ContentLanguage, + CacheControl: o.CacheControl, + ACL: acl, + Owner: owner, + ContentEncoding: o.ContentEncoding, + Size: int64(o.Size), + MD5: md5, + CRC32C: crc32c, + MediaLink: o.MediaLink, + Metadata: o.Metadata, + Generation: o.Generation, + MetaGeneration: o.Metageneration, + StorageClass: o.StorageClass, + Created: convertTime(o.TimeCreated), + Deleted: convertTime(o.TimeDeleted), + Updated: convertTime(o.Updated), + } +} + +// Query represents a query to filter objects from a bucket. +type Query struct { + // Delimiter returns results in a directory-like fashion. + // Results will contain only objects whose names, aside from the + // prefix, do not contain delimiter. Objects whose names, + // aside from the prefix, contain delimiter will have their name, + // truncated after the delimiter, returned in prefixes. + // Duplicate prefixes are omitted. + // Optional. + Delimiter string + + // Prefix is the prefix filter to query objects + // whose names begin with this prefix. + // Optional. + Prefix string + + // Versions indicates whether multiple versions of the same + // object will be included in the results. + Versions bool + + // Cursor is a previously-returned page token + // representing part of the larger set of results to view. + // Optional. + Cursor string + + // MaxResults is the maximum number of items plus prefixes + // to return. As duplicate prefixes are omitted, + // fewer total results may be returned than requested. + // The default page limit is used if it is negative or zero. + // + // Deprecated. Use ObjectIterator.SetPageSize. + MaxResults int +} + +// ObjectList represents a list of objects returned from a bucket List call. +type ObjectList struct { + // Results represent a list of object results. + Results []*ObjectAttrs + + // Next is the continuation query to retrieve more + // results with the same filtering criteria. If there + // are no more results to retrieve, it is nil. + Next *Query + + // Prefixes represents prefixes of objects + // matching-but-not-listed up to and including + // the requested delimiter. + Prefixes []string +} + +// contentTyper implements ContentTyper to enable an +// io.ReadCloser to specify its MIME type. +type contentTyper struct { + io.Reader + t string +} + +func (c *contentTyper) ContentType() string { + return c.t +} + +// A Condition constrains methods to act on specific generations of +// resources. +// +// Not all conditions or combinations of conditions are applicable to +// all methods. +type Condition interface { + // method is the high-level ObjectHandle method name, for + // error messages. call is the call object to modify. + modifyCall(method string, call interface{}) error +} + +// applyConds modifies the provided call using the conditions in conds. +// call is something that quacks like a *raw.WhateverCall. +func applyConds(method string, conds []Condition, call interface{}) error { + for _, cond := range conds { + if err := cond.modifyCall(method, call); err != nil { + return err + } + } + return nil +} + +// toSourceConds returns a slice of Conditions derived from Conds that instead +// function on the equivalent Source methods of a call. +func toSourceConds(conds []Condition) []Condition { + out := make([]Condition, 0, len(conds)) + for _, c := range conds { + switch c := c.(type) { + case genCond: + var m string + if strings.HasPrefix(c.method, "If") { + m = "IfSource" + c.method[2:] + } else { + m = "Source" + c.method + } + out = append(out, genCond{method: m, val: c.val}) + default: + // NOTE(djd): If the message from unsupportedCond becomes + // confusing, we'll need to find a way for Conditions to + // identify themselves. + out = append(out, unsupportedCond{}) + } + } + return out +} + +func Generation(gen int64) Condition { return genCond{"Generation", gen} } +func IfGenerationMatch(gen int64) Condition { return genCond{"IfGenerationMatch", gen} } +func IfGenerationNotMatch(gen int64) Condition { return genCond{"IfGenerationNotMatch", gen} } +func IfMetaGenerationMatch(gen int64) Condition { return genCond{"IfMetagenerationMatch", gen} } +func IfMetaGenerationNotMatch(gen int64) Condition { return genCond{"IfMetagenerationNotMatch", gen} } + +type genCond struct { + method string + val int64 +} + +func (g genCond) modifyCall(srcMethod string, call interface{}) error { + rv := reflect.ValueOf(call) + meth := rv.MethodByName(g.method) + if !meth.IsValid() { + return fmt.Errorf("%s: condition %s not supported", srcMethod, g.method) + } + meth.Call([]reflect.Value{reflect.ValueOf(g.val)}) + return nil +} + +type unsupportedCond struct{} + +func (unsupportedCond) modifyCall(srcMethod string, call interface{}) error { + return fmt.Errorf("%s: condition not supported", srcMethod) +} + +func appendParam(req *http.Request, k, v string) { + sep := "" + if req.URL.RawQuery != "" { + sep = "&" + } + req.URL.RawQuery += sep + url.QueryEscape(k) + "=" + url.QueryEscape(v) +} + +// objectsGetCall wraps an *http.Request for an object fetch call, but adds the methods +// that modifyCall searches for by name. (the same names as the raw, auto-generated API) +type objectsGetCall struct{ req *http.Request } + +func (c objectsGetCall) Generation(gen int64) { + appendParam(c.req, "generation", fmt.Sprint(gen)) +} +func (c objectsGetCall) IfGenerationMatch(gen int64) { + appendParam(c.req, "ifGenerationMatch", fmt.Sprint(gen)) +} +func (c objectsGetCall) IfGenerationNotMatch(gen int64) { + appendParam(c.req, "ifGenerationNotMatch", fmt.Sprint(gen)) +} +func (c objectsGetCall) IfMetagenerationMatch(gen int64) { + appendParam(c.req, "ifMetagenerationMatch", fmt.Sprint(gen)) +} +func (c objectsGetCall) IfMetagenerationNotMatch(gen int64) { + appendParam(c.req, "ifMetagenerationNotMatch", fmt.Sprint(gen)) +} diff --git a/vendor/google.golang.org/cloud/storage/writer.go b/vendor/google.golang.org/cloud/storage/writer.go new file mode 100644 index 00000000..60937c07 --- /dev/null +++ b/vendor/google.golang.org/cloud/storage/writer.go @@ -0,0 +1,129 @@ +// Copyright 2014 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package storage + +import ( + "fmt" + "io" + "unicode/utf8" + + "golang.org/x/net/context" + "google.golang.org/api/googleapi" + raw "google.golang.org/api/storage/v1" +) + +// A Writer writes a Cloud Storage object. +type Writer struct { + // ObjectAttrs are optional attributes to set on the object. Any attributes + // must be initialized before the first Write call. Nil or zero-valued + // attributes are ignored. + ObjectAttrs + + ctx context.Context + o *ObjectHandle + + opened bool + pw *io.PipeWriter + + donec chan struct{} // closed after err and obj are set. + err error + obj *ObjectAttrs +} + +func (w *Writer) open() error { + attrs := w.ObjectAttrs + // Check the developer didn't change the object Name (this is unfortunate, but + // we don't want to store an object under the wrong name). + if attrs.Name != w.o.object { + return fmt.Errorf("storage: Writer.Name %q does not match object name %q", attrs.Name, w.o.object) + } + if !utf8.ValidString(attrs.Name) { + return fmt.Errorf("storage: object name %q is not valid UTF-8", attrs.Name) + } + pr, pw := io.Pipe() + w.pw = pw + w.opened = true + + var mediaOpts []googleapi.MediaOption + if c := attrs.ContentType; c != "" { + mediaOpts = append(mediaOpts, googleapi.ContentType(c)) + } + + go func() { + defer close(w.donec) + + call := w.o.c.raw.Objects.Insert(w.o.bucket, attrs.toRawObject(w.o.bucket)). + Media(pr, mediaOpts...). + Projection("full"). + Context(w.ctx) + + var resp *raw.Object + err := applyConds("NewWriter", w.o.conds, call) + if err == nil { + resp, err = call.Do() + } + if err != nil { + w.err = err + pr.CloseWithError(w.err) + return + } + w.obj = newObject(resp) + }() + return nil +} + +// Write appends to w. +func (w *Writer) Write(p []byte) (n int, err error) { + if w.err != nil { + return 0, w.err + } + if !w.opened { + if err := w.open(); err != nil { + return 0, err + } + } + return w.pw.Write(p) +} + +// Close completes the write operation and flushes any buffered data. +// If Close doesn't return an error, metadata about the written object +// can be retrieved by calling Object. +func (w *Writer) Close() error { + if !w.opened { + if err := w.open(); err != nil { + return err + } + } + if err := w.pw.Close(); err != nil { + return err + } + <-w.donec + return w.err +} + +// CloseWithError aborts the write operation with the provided error. +// CloseWithError always returns nil. +func (w *Writer) CloseWithError(err error) error { + if !w.opened { + return nil + } + return w.pw.CloseWithError(err) +} + +// ObjectAttrs returns metadata about a successfully-written object. +// It's only valid to call it after Close returns nil. +func (w *Writer) Attrs() *ObjectAttrs { + return w.obj +} diff --git a/vendor/google.golang.org/grpc/LICENSE b/vendor/google.golang.org/grpc/LICENSE new file mode 100644 index 00000000..f4988b45 --- /dev/null +++ b/vendor/google.golang.org/grpc/LICENSE @@ -0,0 +1,28 @@ +Copyright 2014, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/google.golang.org/grpc/PATENTS b/vendor/google.golang.org/grpc/PATENTS new file mode 100644 index 00000000..69b47959 --- /dev/null +++ b/vendor/google.golang.org/grpc/PATENTS @@ -0,0 +1,22 @@ +Additional IP Rights Grant (Patents) + +"This implementation" means the copyrightable works distributed by +Google as part of the gRPC project. + +Google hereby grants to You a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable (except as stated in this section) +patent license to make, have made, use, offer to sell, sell, import, +transfer and otherwise run, modify and propagate the contents of this +implementation of gRPC, where such license applies only to those patent +claims, both currently owned or controlled by Google and acquired in +the future, licensable by Google that are necessarily infringed by this +implementation of gRPC. This grant does not include claims that would be +infringed only as a consequence of further modification of this +implementation. If you or your agent or exclusive licensee institute or +order or agree to the institution of patent litigation against any +entity (including a cross-claim or counterclaim in a lawsuit) alleging +that this implementation of gRPC or any code incorporated within this +implementation of gRPC constitutes direct or contributory patent +infringement, or inducement of patent infringement, then any patent +rights granted to you under this License for this implementation of gRPC +shall terminate as of the date such litigation is filed. diff --git a/vendor/google.golang.org/grpc/backoff.go b/vendor/google.golang.org/grpc/backoff.go new file mode 100644 index 00000000..52f4f10f --- /dev/null +++ b/vendor/google.golang.org/grpc/backoff.go @@ -0,0 +1,80 @@ +package grpc + +import ( + "math/rand" + "time" +) + +// DefaultBackoffConfig uses values specified for backoff in +// https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md. +var ( + DefaultBackoffConfig = BackoffConfig{ + MaxDelay: 120 * time.Second, + baseDelay: 1.0 * time.Second, + factor: 1.6, + jitter: 0.2, + } +) + +// backoffStrategy defines the methodology for backing off after a grpc +// connection failure. +// +// This is unexported until the gRPC project decides whether or not to allow +// alternative backoff strategies. Once a decision is made, this type and its +// method may be exported. +type backoffStrategy interface { + // backoff returns the amount of time to wait before the next retry given + // the number of consecutive failures. + backoff(retries int) time.Duration +} + +// BackoffConfig defines the parameters for the default gRPC backoff strategy. +type BackoffConfig struct { + // MaxDelay is the upper bound of backoff delay. + MaxDelay time.Duration + + // TODO(stevvooe): The following fields are not exported, as allowing + // changes would violate the current gRPC specification for backoff. If + // gRPC decides to allow more interesting backoff strategies, these fields + // may be opened up in the future. + + // baseDelay is the amount of time to wait before retrying after the first + // failure. + baseDelay time.Duration + + // factor is applied to the backoff after each retry. + factor float64 + + // jitter provides a range to randomize backoff delays. + jitter float64 +} + +func setDefaults(bc *BackoffConfig) { + md := bc.MaxDelay + *bc = DefaultBackoffConfig + + if md > 0 { + bc.MaxDelay = md + } +} + +func (bc BackoffConfig) backoff(retries int) (t time.Duration) { + if retries == 0 { + return bc.baseDelay + } + backoff, max := float64(bc.baseDelay), float64(bc.MaxDelay) + for backoff < max && retries > 0 { + backoff *= bc.factor + retries-- + } + if backoff > max { + backoff = max + } + // Randomize backoff delays so that if a cluster of requests start at + // the same time, they won't operate in lockstep. + backoff *= 1 + bc.jitter*(rand.Float64()*2-1) + if backoff < 0 { + return 0 + } + return time.Duration(backoff) +} diff --git a/vendor/google.golang.org/grpc/balancer.go b/vendor/google.golang.org/grpc/balancer.go new file mode 100644 index 00000000..419e2146 --- /dev/null +++ b/vendor/google.golang.org/grpc/balancer.go @@ -0,0 +1,385 @@ +/* + * + * Copyright 2016, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package grpc + +import ( + "fmt" + "sync" + + "golang.org/x/net/context" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/naming" +) + +// Address represents a server the client connects to. +// This is the EXPERIMENTAL API and may be changed or extended in the future. +type Address struct { + // Addr is the server address on which a connection will be established. + Addr string + // Metadata is the information associated with Addr, which may be used + // to make load balancing decision. + Metadata interface{} +} + +// BalancerGetOptions configures a Get call. +// This is the EXPERIMENTAL API and may be changed or extended in the future. +type BalancerGetOptions struct { + // BlockingWait specifies whether Get should block when there is no + // connected address. + BlockingWait bool +} + +// Balancer chooses network addresses for RPCs. +// This is the EXPERIMENTAL API and may be changed or extended in the future. +type Balancer interface { + // Start does the initialization work to bootstrap a Balancer. For example, + // this function may start the name resolution and watch the updates. It will + // be called when dialing. + Start(target string) error + // Up informs the Balancer that gRPC has a connection to the server at + // addr. It returns down which is called once the connection to addr gets + // lost or closed. + // TODO: It is not clear how to construct and take advantage the meaningful error + // parameter for down. Need realistic demands to guide. + Up(addr Address) (down func(error)) + // Get gets the address of a server for the RPC corresponding to ctx. + // i) If it returns a connected address, gRPC internals issues the RPC on the + // connection to this address; + // ii) If it returns an address on which the connection is under construction + // (initiated by Notify(...)) but not connected, gRPC internals + // * fails RPC if the RPC is fail-fast and connection is in the TransientFailure or + // Shutdown state; + // or + // * issues RPC on the connection otherwise. + // iii) If it returns an address on which the connection does not exist, gRPC + // internals treats it as an error and will fail the corresponding RPC. + // + // Therefore, the following is the recommended rule when writing a custom Balancer. + // If opts.BlockingWait is true, it should return a connected address or + // block if there is no connected address. It should respect the timeout or + // cancellation of ctx when blocking. If opts.BlockingWait is false (for fail-fast + // RPCs), it should return an address it has notified via Notify(...) immediately + // instead of blocking. + // + // The function returns put which is called once the rpc has completed or failed. + // put can collect and report RPC stats to a remote load balancer. + // + // This function should only return the errors Balancer cannot recover by itself. + // gRPC internals will fail the RPC if an error is returned. + Get(ctx context.Context, opts BalancerGetOptions) (addr Address, put func(), err error) + // Notify returns a channel that is used by gRPC internals to watch the addresses + // gRPC needs to connect. The addresses might be from a name resolver or remote + // load balancer. gRPC internals will compare it with the existing connected + // addresses. If the address Balancer notified is not in the existing connected + // addresses, gRPC starts to connect the address. If an address in the existing + // connected addresses is not in the notification list, the corresponding connection + // is shutdown gracefully. Otherwise, there are no operations to take. Note that + // the Address slice must be the full list of the Addresses which should be connected. + // It is NOT delta. + Notify() <-chan []Address + // Close shuts down the balancer. + Close() error +} + +// downErr implements net.Error. It is constructed by gRPC internals and passed to the down +// call of Balancer. +type downErr struct { + timeout bool + temporary bool + desc string +} + +func (e downErr) Error() string { return e.desc } +func (e downErr) Timeout() bool { return e.timeout } +func (e downErr) Temporary() bool { return e.temporary } + +func downErrorf(timeout, temporary bool, format string, a ...interface{}) downErr { + return downErr{ + timeout: timeout, + temporary: temporary, + desc: fmt.Sprintf(format, a...), + } +} + +// RoundRobin returns a Balancer that selects addresses round-robin. It uses r to watch +// the name resolution updates and updates the addresses available correspondingly. +func RoundRobin(r naming.Resolver) Balancer { + return &roundRobin{r: r} +} + +type addrInfo struct { + addr Address + connected bool +} + +type roundRobin struct { + r naming.Resolver + w naming.Watcher + addrs []*addrInfo // all the addresses the client should potentially connect + mu sync.Mutex + addrCh chan []Address // the channel to notify gRPC internals the list of addresses the client should connect to. + next int // index of the next address to return for Get() + waitCh chan struct{} // the channel to block when there is no connected address available + done bool // The Balancer is closed. +} + +func (rr *roundRobin) watchAddrUpdates() error { + updates, err := rr.w.Next() + if err != nil { + grpclog.Printf("grpc: the naming watcher stops working due to %v.\n", err) + return err + } + rr.mu.Lock() + defer rr.mu.Unlock() + for _, update := range updates { + addr := Address{ + Addr: update.Addr, + Metadata: update.Metadata, + } + switch update.Op { + case naming.Add: + var exist bool + for _, v := range rr.addrs { + if addr == v.addr { + exist = true + grpclog.Println("grpc: The name resolver wanted to add an existing address: ", addr) + break + } + } + if exist { + continue + } + rr.addrs = append(rr.addrs, &addrInfo{addr: addr}) + case naming.Delete: + for i, v := range rr.addrs { + if addr == v.addr { + copy(rr.addrs[i:], rr.addrs[i+1:]) + rr.addrs = rr.addrs[:len(rr.addrs)-1] + break + } + } + default: + grpclog.Println("Unknown update.Op ", update.Op) + } + } + // Make a copy of rr.addrs and write it onto rr.addrCh so that gRPC internals gets notified. + open := make([]Address, len(rr.addrs)) + for i, v := range rr.addrs { + open[i] = v.addr + } + if rr.done { + return ErrClientConnClosing + } + rr.addrCh <- open + return nil +} + +func (rr *roundRobin) Start(target string) error { + if rr.r == nil { + // If there is no name resolver installed, it is not needed to + // do name resolution. In this case, target is added into rr.addrs + // as the only address available and rr.addrCh stays nil. + rr.addrs = append(rr.addrs, &addrInfo{addr: Address{Addr: target}}) + return nil + } + w, err := rr.r.Resolve(target) + if err != nil { + return err + } + rr.w = w + rr.addrCh = make(chan []Address) + go func() { + for { + if err := rr.watchAddrUpdates(); err != nil { + return + } + } + }() + return nil +} + +// Up sets the connected state of addr and sends notification if there are pending +// Get() calls. +func (rr *roundRobin) Up(addr Address) func(error) { + rr.mu.Lock() + defer rr.mu.Unlock() + var cnt int + for _, a := range rr.addrs { + if a.addr == addr { + if a.connected { + return nil + } + a.connected = true + } + if a.connected { + cnt++ + } + } + // addr is only one which is connected. Notify the Get() callers who are blocking. + if cnt == 1 && rr.waitCh != nil { + close(rr.waitCh) + rr.waitCh = nil + } + return func(err error) { + rr.down(addr, err) + } +} + +// down unsets the connected state of addr. +func (rr *roundRobin) down(addr Address, err error) { + rr.mu.Lock() + defer rr.mu.Unlock() + for _, a := range rr.addrs { + if addr == a.addr { + a.connected = false + break + } + } +} + +// Get returns the next addr in the rotation. +func (rr *roundRobin) Get(ctx context.Context, opts BalancerGetOptions) (addr Address, put func(), err error) { + var ch chan struct{} + rr.mu.Lock() + if rr.done { + rr.mu.Unlock() + err = ErrClientConnClosing + return + } + + if len(rr.addrs) > 0 { + if rr.next >= len(rr.addrs) { + rr.next = 0 + } + next := rr.next + for { + a := rr.addrs[next] + next = (next + 1) % len(rr.addrs) + if a.connected { + addr = a.addr + rr.next = next + rr.mu.Unlock() + return + } + if next == rr.next { + // Has iterated all the possible address but none is connected. + break + } + } + } + if !opts.BlockingWait { + if len(rr.addrs) == 0 { + rr.mu.Unlock() + err = fmt.Errorf("there is no address available") + return + } + // Returns the next addr on rr.addrs for failfast RPCs. + addr = rr.addrs[rr.next].addr + rr.next++ + rr.mu.Unlock() + return + } + // Wait on rr.waitCh for non-failfast RPCs. + if rr.waitCh == nil { + ch = make(chan struct{}) + rr.waitCh = ch + } else { + ch = rr.waitCh + } + rr.mu.Unlock() + for { + select { + case <-ctx.Done(): + err = ctx.Err() + return + case <-ch: + rr.mu.Lock() + if rr.done { + rr.mu.Unlock() + err = ErrClientConnClosing + return + } + + if len(rr.addrs) > 0 { + if rr.next >= len(rr.addrs) { + rr.next = 0 + } + next := rr.next + for { + a := rr.addrs[next] + next = (next + 1) % len(rr.addrs) + if a.connected { + addr = a.addr + rr.next = next + rr.mu.Unlock() + return + } + if next == rr.next { + // Has iterated all the possible address but none is connected. + break + } + } + } + // The newly added addr got removed by Down() again. + if rr.waitCh == nil { + ch = make(chan struct{}) + rr.waitCh = ch + } else { + ch = rr.waitCh + } + rr.mu.Unlock() + } + } +} + +func (rr *roundRobin) Notify() <-chan []Address { + return rr.addrCh +} + +func (rr *roundRobin) Close() error { + rr.mu.Lock() + defer rr.mu.Unlock() + rr.done = true + if rr.w != nil { + rr.w.Close() + } + if rr.waitCh != nil { + close(rr.waitCh) + rr.waitCh = nil + } + if rr.addrCh != nil { + close(rr.addrCh) + } + return nil +} diff --git a/vendor/google.golang.org/grpc/call.go b/vendor/google.golang.org/grpc/call.go new file mode 100644 index 00000000..fea07998 --- /dev/null +++ b/vendor/google.golang.org/grpc/call.go @@ -0,0 +1,226 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package grpc + +import ( + "bytes" + "io" + "math" + "time" + + "golang.org/x/net/context" + "golang.org/x/net/trace" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/transport" +) + +// recvResponse receives and parses an RPC response. +// On error, it returns the error and indicates whether the call should be retried. +// +// TODO(zhaoq): Check whether the received message sequence is valid. +func recvResponse(dopts dialOptions, t transport.ClientTransport, c *callInfo, stream *transport.Stream, reply interface{}) error { + // Try to acquire header metadata from the server if there is any. + var err error + defer func() { + if err != nil { + if _, ok := err.(transport.ConnectionError); !ok { + t.CloseStream(stream, err) + } + } + }() + c.headerMD, err = stream.Header() + if err != nil { + return err + } + p := &parser{r: stream} + for { + if err = recv(p, dopts.codec, stream, dopts.dc, reply, math.MaxInt32); err != nil { + if err == io.EOF { + break + } + return err + } + } + c.trailerMD = stream.Trailer() + return nil +} + +// sendRequest writes out various information of an RPC such as Context and Message. +func sendRequest(ctx context.Context, codec Codec, compressor Compressor, callHdr *transport.CallHdr, t transport.ClientTransport, args interface{}, opts *transport.Options) (_ *transport.Stream, err error) { + stream, err := t.NewStream(ctx, callHdr) + if err != nil { + return nil, err + } + defer func() { + if err != nil { + // If err is connection error, t will be closed, no need to close stream here. + if _, ok := err.(transport.ConnectionError); !ok { + t.CloseStream(stream, err) + } + } + }() + var cbuf *bytes.Buffer + if compressor != nil { + cbuf = new(bytes.Buffer) + } + outBuf, err := encode(codec, args, compressor, cbuf) + if err != nil { + return nil, transport.StreamErrorf(codes.Internal, "grpc: %v", err) + } + err = t.Write(stream, outBuf, opts) + // t.NewStream(...) could lead to an early rejection of the RPC (e.g., the service/method + // does not exist.) so that t.Write could get io.EOF from wait(...). Leave the following + // recvResponse to get the final status. + if err != nil && err != io.EOF { + return nil, err + } + // Sent successfully. + return stream, nil +} + +// Invoke sends the RPC request on the wire and returns after response is received. +// Invoke is called by generated code. Also users can call Invoke directly when it +// is really needed in their use cases. +func Invoke(ctx context.Context, method string, args, reply interface{}, cc *ClientConn, opts ...CallOption) (err error) { + c := defaultCallInfo + for _, o := range opts { + if err := o.before(&c); err != nil { + return toRPCErr(err) + } + } + defer func() { + for _, o := range opts { + o.after(&c) + } + }() + if EnableTracing { + c.traceInfo.tr = trace.New("grpc.Sent."+methodFamily(method), method) + defer c.traceInfo.tr.Finish() + c.traceInfo.firstLine.client = true + if deadline, ok := ctx.Deadline(); ok { + c.traceInfo.firstLine.deadline = deadline.Sub(time.Now()) + } + c.traceInfo.tr.LazyLog(&c.traceInfo.firstLine, false) + // TODO(dsymonds): Arrange for c.traceInfo.firstLine.remoteAddr to be set. + defer func() { + if err != nil { + c.traceInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true) + c.traceInfo.tr.SetError() + } + }() + } + topts := &transport.Options{ + Last: true, + Delay: false, + } + for { + var ( + err error + t transport.ClientTransport + stream *transport.Stream + // Record the put handler from Balancer.Get(...). It is called once the + // RPC has completed or failed. + put func() + ) + // TODO(zhaoq): Need a formal spec of fail-fast. + callHdr := &transport.CallHdr{ + Host: cc.authority, + Method: method, + } + if cc.dopts.cp != nil { + callHdr.SendCompress = cc.dopts.cp.Type() + } + gopts := BalancerGetOptions{ + BlockingWait: !c.failFast, + } + t, put, err = cc.getTransport(ctx, gopts) + if err != nil { + // TODO(zhaoq): Probably revisit the error handling. + if _, ok := err.(*rpcError); ok { + return err + } + if err == errConnClosing || err == errConnUnavailable { + if c.failFast { + return Errorf(codes.Unavailable, "%v", err) + } + continue + } + // All the other errors are treated as Internal errors. + return Errorf(codes.Internal, "%v", err) + } + if c.traceInfo.tr != nil { + c.traceInfo.tr.LazyLog(&payload{sent: true, msg: args}, true) + } + stream, err = sendRequest(ctx, cc.dopts.codec, cc.dopts.cp, callHdr, t, args, topts) + if err != nil { + if put != nil { + put() + put = nil + } + // Retry a non-failfast RPC when + // i) there is a connection error; or + // ii) the server started to drain before this RPC was initiated. + if _, ok := err.(transport.ConnectionError); ok || err == transport.ErrStreamDrain { + if c.failFast { + return toRPCErr(err) + } + continue + } + return toRPCErr(err) + } + err = recvResponse(cc.dopts, t, &c, stream, reply) + if err != nil { + if put != nil { + put() + put = nil + } + if _, ok := err.(transport.ConnectionError); ok || err == transport.ErrStreamDrain { + if c.failFast { + return toRPCErr(err) + } + continue + } + return toRPCErr(err) + } + if c.traceInfo.tr != nil { + c.traceInfo.tr.LazyLog(&payload{sent: false, msg: reply}, true) + } + t.CloseStream(stream, nil) + if put != nil { + put() + put = nil + } + return Errorf(stream.StatusCode(), "%s", stream.StatusDesc()) + } +} diff --git a/vendor/google.golang.org/grpc/clientconn.go b/vendor/google.golang.org/grpc/clientconn.go new file mode 100644 index 00000000..27e74e6f --- /dev/null +++ b/vendor/google.golang.org/grpc/clientconn.go @@ -0,0 +1,845 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package grpc + +import ( + "errors" + "fmt" + "net" + "strings" + "sync" + "time" + + "golang.org/x/net/context" + "golang.org/x/net/trace" + "google.golang.org/grpc/credentials" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/transport" +) + +var ( + // ErrClientConnClosing indicates that the operation is illegal because + // the ClientConn is closing. + ErrClientConnClosing = errors.New("grpc: the client connection is closing") + // ErrClientConnTimeout indicates that the ClientConn cannot establish the + // underlying connections within the specified timeout. + ErrClientConnTimeout = errors.New("grpc: timed out when dialing") + + // errNoTransportSecurity indicates that there is no transport security + // being set for ClientConn. Users should either set one or explicitly + // call WithInsecure DialOption to disable security. + errNoTransportSecurity = errors.New("grpc: no transport security set (use grpc.WithInsecure() explicitly or set credentials)") + // errTransportCredentialsMissing indicates that users want to transmit security + // information (e.g., oauth2 token) which requires secure connection on an insecure + // connection. + errTransportCredentialsMissing = errors.New("grpc: the credentials require transport level security (use grpc.WithTransportCredentials() to set)") + // errCredentialsConflict indicates that grpc.WithTransportCredentials() + // and grpc.WithInsecure() are both called for a connection. + errCredentialsConflict = errors.New("grpc: transport credentials are set for an insecure connection (grpc.WithTransportCredentials() and grpc.WithInsecure() are both called)") + // errNetworkIO indicates that the connection is down due to some network I/O error. + errNetworkIO = errors.New("grpc: failed with network I/O error") + // errConnDrain indicates that the connection starts to be drained and does not accept any new RPCs. + errConnDrain = errors.New("grpc: the connection is drained") + // errConnClosing indicates that the connection is closing. + errConnClosing = errors.New("grpc: the connection is closing") + // errConnUnavailable indicates that the connection is unavailable. + errConnUnavailable = errors.New("grpc: the connection is unavailable") + errNoAddr = errors.New("grpc: there is no address available to dial") + // minimum time to give a connection to complete + minConnectTimeout = 20 * time.Second +) + +// dialOptions configure a Dial call. dialOptions are set by the DialOption +// values passed to Dial. +type dialOptions struct { + codec Codec + cp Compressor + dc Decompressor + bs backoffStrategy + balancer Balancer + block bool + insecure bool + timeout time.Duration + copts transport.ConnectOptions +} + +// DialOption configures how we set up the connection. +type DialOption func(*dialOptions) + +// WithCodec returns a DialOption which sets a codec for message marshaling and unmarshaling. +func WithCodec(c Codec) DialOption { + return func(o *dialOptions) { + o.codec = c + } +} + +// WithCompressor returns a DialOption which sets a CompressorGenerator for generating message +// compressor. +func WithCompressor(cp Compressor) DialOption { + return func(o *dialOptions) { + o.cp = cp + } +} + +// WithDecompressor returns a DialOption which sets a DecompressorGenerator for generating +// message decompressor. +func WithDecompressor(dc Decompressor) DialOption { + return func(o *dialOptions) { + o.dc = dc + } +} + +// WithBalancer returns a DialOption which sets a load balancer. +func WithBalancer(b Balancer) DialOption { + return func(o *dialOptions) { + o.balancer = b + } +} + +// WithBackoffMaxDelay configures the dialer to use the provided maximum delay +// when backing off after failed connection attempts. +func WithBackoffMaxDelay(md time.Duration) DialOption { + return WithBackoffConfig(BackoffConfig{MaxDelay: md}) +} + +// WithBackoffConfig configures the dialer to use the provided backoff +// parameters after connection failures. +// +// Use WithBackoffMaxDelay until more parameters on BackoffConfig are opened up +// for use. +func WithBackoffConfig(b BackoffConfig) DialOption { + // Set defaults to ensure that provided BackoffConfig is valid and + // unexported fields get default values. + setDefaults(&b) + return withBackoff(b) +} + +// withBackoff sets the backoff strategy used for retries after a +// failed connection attempt. +// +// This can be exported if arbitrary backoff strategies are allowed by gRPC. +func withBackoff(bs backoffStrategy) DialOption { + return func(o *dialOptions) { + o.bs = bs + } +} + +// WithBlock returns a DialOption which makes caller of Dial blocks until the underlying +// connection is up. Without this, Dial returns immediately and connecting the server +// happens in background. +func WithBlock() DialOption { + return func(o *dialOptions) { + o.block = true + } +} + +// WithInsecure returns a DialOption which disables transport security for this ClientConn. +// Note that transport security is required unless WithInsecure is set. +func WithInsecure() DialOption { + return func(o *dialOptions) { + o.insecure = true + } +} + +// WithTransportCredentials returns a DialOption which configures a +// connection level security credentials (e.g., TLS/SSL). +func WithTransportCredentials(creds credentials.TransportCredentials) DialOption { + return func(o *dialOptions) { + o.copts.TransportCredentials = creds + } +} + +// WithPerRPCCredentials returns a DialOption which sets +// credentials which will place auth state on each outbound RPC. +func WithPerRPCCredentials(creds credentials.PerRPCCredentials) DialOption { + return func(o *dialOptions) { + o.copts.PerRPCCredentials = append(o.copts.PerRPCCredentials, creds) + } +} + +// WithTimeout returns a DialOption that configures a timeout for dialing a ClientConn +// initially. This is valid if and only if WithBlock() is present. +func WithTimeout(d time.Duration) DialOption { + return func(o *dialOptions) { + o.timeout = d + } +} + +// WithDialer returns a DialOption that specifies a function to use for dialing network addresses. +func WithDialer(f func(string, time.Duration) (net.Conn, error)) DialOption { + return func(o *dialOptions) { + o.copts.Dialer = func(ctx context.Context, addr string) (net.Conn, error) { + if deadline, ok := ctx.Deadline(); ok { + return f(addr, deadline.Sub(time.Now())) + } + return f(addr, 0) + } + } +} + +// WithUserAgent returns a DialOption that specifies a user agent string for all the RPCs. +func WithUserAgent(s string) DialOption { + return func(o *dialOptions) { + o.copts.UserAgent = s + } +} + +// Dial creates a client connection to the given target. +func Dial(target string, opts ...DialOption) (*ClientConn, error) { + return DialContext(context.Background(), target, opts...) +} + +// DialContext creates a client connection to the given target +// using the supplied context. +func DialContext(ctx context.Context, target string, opts ...DialOption) (*ClientConn, error) { + cc := &ClientConn{ + target: target, + conns: make(map[Address]*addrConn), + } + cc.ctx, cc.cancel = context.WithCancel(ctx) + for _, opt := range opts { + opt(&cc.dopts) + } + + // Set defaults. + if cc.dopts.codec == nil { + cc.dopts.codec = protoCodec{} + } + if cc.dopts.bs == nil { + cc.dopts.bs = DefaultBackoffConfig + } + + var ( + ok bool + addrs []Address + ) + if cc.dopts.balancer == nil { + // Connect to target directly if balancer is nil. + addrs = append(addrs, Address{Addr: target}) + } else { + if err := cc.dopts.balancer.Start(target); err != nil { + return nil, err + } + ch := cc.dopts.balancer.Notify() + if ch == nil { + // There is no name resolver installed. + addrs = append(addrs, Address{Addr: target}) + } else { + addrs, ok = <-ch + if !ok || len(addrs) == 0 { + return nil, errNoAddr + } + } + } + waitC := make(chan error, 1) + go func() { + for _, a := range addrs { + if err := cc.resetAddrConn(a, false, nil); err != nil { + waitC <- err + return + } + } + close(waitC) + }() + var timeoutCh <-chan time.Time + if cc.dopts.timeout > 0 { + timeoutCh = time.After(cc.dopts.timeout) + } + select { + case err := <-waitC: + if err != nil { + cc.Close() + return nil, err + } + case <-cc.ctx.Done(): + cc.Close() + return nil, cc.ctx.Err() + case <-timeoutCh: + cc.Close() + return nil, ErrClientConnTimeout + } + // If balancer is nil or balancer.Notify() is nil, ok will be false here. + // The lbWatcher goroutine will not be created. + if ok { + go cc.lbWatcher() + } + colonPos := strings.LastIndex(target, ":") + if colonPos == -1 { + colonPos = len(target) + } + cc.authority = target[:colonPos] + return cc, nil +} + +// ConnectivityState indicates the state of a client connection. +type ConnectivityState int + +const ( + // Idle indicates the ClientConn is idle. + Idle ConnectivityState = iota + // Connecting indicates the ClienConn is connecting. + Connecting + // Ready indicates the ClientConn is ready for work. + Ready + // TransientFailure indicates the ClientConn has seen a failure but expects to recover. + TransientFailure + // Shutdown indicates the ClientConn has started shutting down. + Shutdown +) + +func (s ConnectivityState) String() string { + switch s { + case Idle: + return "IDLE" + case Connecting: + return "CONNECTING" + case Ready: + return "READY" + case TransientFailure: + return "TRANSIENT_FAILURE" + case Shutdown: + return "SHUTDOWN" + default: + panic(fmt.Sprintf("unknown connectivity state: %d", s)) + } +} + +// ClientConn represents a client connection to an RPC server. +type ClientConn struct { + ctx context.Context + cancel context.CancelFunc + + target string + authority string + dopts dialOptions + + mu sync.RWMutex + conns map[Address]*addrConn +} + +func (cc *ClientConn) lbWatcher() { + for addrs := range cc.dopts.balancer.Notify() { + var ( + add []Address // Addresses need to setup connections. + del []*addrConn // Connections need to tear down. + ) + cc.mu.Lock() + for _, a := range addrs { + if _, ok := cc.conns[a]; !ok { + add = append(add, a) + } + } + for k, c := range cc.conns { + var keep bool + for _, a := range addrs { + if k == a { + keep = true + break + } + } + if !keep { + del = append(del, c) + delete(cc.conns, c.addr) + } + } + cc.mu.Unlock() + for _, a := range add { + cc.resetAddrConn(a, true, nil) + } + for _, c := range del { + c.tearDown(errConnDrain) + } + } +} + +// resetAddrConn creates an addrConn for addr and adds it to cc.conns. +// If there is an old addrConn for addr, it will be torn down, using tearDownErr as the reason. +// If tearDownErr is nil, errConnDrain will be used instead. +func (cc *ClientConn) resetAddrConn(addr Address, skipWait bool, tearDownErr error) error { + ac := &addrConn{ + cc: cc, + addr: addr, + dopts: cc.dopts, + } + ac.ctx, ac.cancel = context.WithCancel(cc.ctx) + ac.stateCV = sync.NewCond(&ac.mu) + if EnableTracing { + ac.events = trace.NewEventLog("grpc.ClientConn", ac.addr.Addr) + } + if !ac.dopts.insecure { + if ac.dopts.copts.TransportCredentials == nil { + return errNoTransportSecurity + } + } else { + if ac.dopts.copts.TransportCredentials != nil { + return errCredentialsConflict + } + for _, cd := range ac.dopts.copts.PerRPCCredentials { + if cd.RequireTransportSecurity() { + return errTransportCredentialsMissing + } + } + } + // Track ac in cc. This needs to be done before any getTransport(...) is called. + cc.mu.Lock() + if cc.conns == nil { + cc.mu.Unlock() + return ErrClientConnClosing + } + stale := cc.conns[ac.addr] + cc.conns[ac.addr] = ac + cc.mu.Unlock() + if stale != nil { + // There is an addrConn alive on ac.addr already. This could be due to + // 1) a buggy Balancer notifies duplicated Addresses; + // 2) goaway was received, a new ac will replace the old ac. + // The old ac should be deleted from cc.conns, but the + // underlying transport should drain rather than close. + if tearDownErr == nil { + // tearDownErr is nil if resetAddrConn is called by + // 1) Dial + // 2) lbWatcher + // In both cases, the stale ac should drain, not close. + stale.tearDown(errConnDrain) + } else { + stale.tearDown(tearDownErr) + } + } + // skipWait may overwrite the decision in ac.dopts.block. + if ac.dopts.block && !skipWait { + if err := ac.resetTransport(false); err != nil { + if err != errConnClosing { + // Tear down ac and delete it from cc.conns. + cc.mu.Lock() + delete(cc.conns, ac.addr) + cc.mu.Unlock() + ac.tearDown(err) + } + if e, ok := err.(transport.ConnectionError); ok && !e.Temporary() { + return e.Origin() + } + return err + } + // Start to monitor the error status of transport. + go ac.transportMonitor() + } else { + // Start a goroutine connecting to the server asynchronously. + go func() { + if err := ac.resetTransport(false); err != nil { + grpclog.Printf("Failed to dial %s: %v; please retry.", ac.addr.Addr, err) + if err != errConnClosing { + // Keep this ac in cc.conns, to get the reason it's torn down. + ac.tearDown(err) + } + return + } + ac.transportMonitor() + }() + } + return nil +} + +func (cc *ClientConn) getTransport(ctx context.Context, opts BalancerGetOptions) (transport.ClientTransport, func(), error) { + var ( + ac *addrConn + ok bool + put func() + ) + if cc.dopts.balancer == nil { + // If balancer is nil, there should be only one addrConn available. + cc.mu.RLock() + if cc.conns == nil { + cc.mu.RUnlock() + return nil, nil, toRPCErr(ErrClientConnClosing) + } + for _, ac = range cc.conns { + // Break after the first iteration to get the first addrConn. + ok = true + break + } + cc.mu.RUnlock() + } else { + var ( + addr Address + err error + ) + addr, put, err = cc.dopts.balancer.Get(ctx, opts) + if err != nil { + return nil, nil, toRPCErr(err) + } + cc.mu.RLock() + if cc.conns == nil { + cc.mu.RUnlock() + return nil, nil, toRPCErr(ErrClientConnClosing) + } + ac, ok = cc.conns[addr] + cc.mu.RUnlock() + } + if !ok { + if put != nil { + put() + } + return nil, nil, errConnClosing + } + t, err := ac.wait(ctx, cc.dopts.balancer != nil, !opts.BlockingWait) + if err != nil { + if put != nil { + put() + } + return nil, nil, err + } + return t, put, nil +} + +// Close tears down the ClientConn and all underlying connections. +func (cc *ClientConn) Close() error { + cc.cancel() + + cc.mu.Lock() + if cc.conns == nil { + cc.mu.Unlock() + return ErrClientConnClosing + } + conns := cc.conns + cc.conns = nil + cc.mu.Unlock() + if cc.dopts.balancer != nil { + cc.dopts.balancer.Close() + } + for _, ac := range conns { + ac.tearDown(ErrClientConnClosing) + } + return nil +} + +// addrConn is a network connection to a given address. +type addrConn struct { + ctx context.Context + cancel context.CancelFunc + + cc *ClientConn + addr Address + dopts dialOptions + events trace.EventLog + + mu sync.Mutex + state ConnectivityState + stateCV *sync.Cond + down func(error) // the handler called when a connection is down. + // ready is closed and becomes nil when a new transport is up or failed + // due to timeout. + ready chan struct{} + transport transport.ClientTransport + + // The reason this addrConn is torn down. + tearDownErr error +} + +// printf records an event in ac's event log, unless ac has been closed. +// REQUIRES ac.mu is held. +func (ac *addrConn) printf(format string, a ...interface{}) { + if ac.events != nil { + ac.events.Printf(format, a...) + } +} + +// errorf records an error in ac's event log, unless ac has been closed. +// REQUIRES ac.mu is held. +func (ac *addrConn) errorf(format string, a ...interface{}) { + if ac.events != nil { + ac.events.Errorf(format, a...) + } +} + +// getState returns the connectivity state of the Conn +func (ac *addrConn) getState() ConnectivityState { + ac.mu.Lock() + defer ac.mu.Unlock() + return ac.state +} + +// waitForStateChange blocks until the state changes to something other than the sourceState. +func (ac *addrConn) waitForStateChange(ctx context.Context, sourceState ConnectivityState) (ConnectivityState, error) { + ac.mu.Lock() + defer ac.mu.Unlock() + if sourceState != ac.state { + return ac.state, nil + } + done := make(chan struct{}) + var err error + go func() { + select { + case <-ctx.Done(): + ac.mu.Lock() + err = ctx.Err() + ac.stateCV.Broadcast() + ac.mu.Unlock() + case <-done: + } + }() + defer close(done) + for sourceState == ac.state { + ac.stateCV.Wait() + if err != nil { + return ac.state, err + } + } + return ac.state, nil +} + +func (ac *addrConn) resetTransport(closeTransport bool) error { + for retries := 0; ; retries++ { + ac.mu.Lock() + ac.printf("connecting") + if ac.state == Shutdown { + // ac.tearDown(...) has been invoked. + ac.mu.Unlock() + return errConnClosing + } + if ac.down != nil { + ac.down(downErrorf(false, true, "%v", errNetworkIO)) + ac.down = nil + } + ac.state = Connecting + ac.stateCV.Broadcast() + t := ac.transport + ac.mu.Unlock() + if closeTransport && t != nil { + t.Close() + } + sleepTime := ac.dopts.bs.backoff(retries) + timeout := minConnectTimeout + if timeout < sleepTime { + timeout = sleepTime + } + ctx, cancel := context.WithTimeout(ac.ctx, timeout) + connectTime := time.Now() + newTransport, err := transport.NewClientTransport(ctx, ac.addr.Addr, ac.dopts.copts) + if err != nil { + cancel() + + if e, ok := err.(transport.ConnectionError); ok && !e.Temporary() { + return err + } + grpclog.Printf("grpc: addrConn.resetTransport failed to create client transport: %v; Reconnecting to %q", err, ac.addr) + ac.mu.Lock() + if ac.state == Shutdown { + // ac.tearDown(...) has been invoked. + ac.mu.Unlock() + return errConnClosing + } + ac.errorf("transient failure: %v", err) + ac.state = TransientFailure + ac.stateCV.Broadcast() + if ac.ready != nil { + close(ac.ready) + ac.ready = nil + } + ac.mu.Unlock() + closeTransport = false + select { + case <-time.After(sleepTime - time.Since(connectTime)): + case <-ac.ctx.Done(): + return ac.ctx.Err() + } + continue + } + ac.mu.Lock() + ac.printf("ready") + if ac.state == Shutdown { + // ac.tearDown(...) has been invoked. + ac.mu.Unlock() + newTransport.Close() + return errConnClosing + } + ac.state = Ready + ac.stateCV.Broadcast() + ac.transport = newTransport + if ac.ready != nil { + close(ac.ready) + ac.ready = nil + } + if ac.cc.dopts.balancer != nil { + ac.down = ac.cc.dopts.balancer.Up(ac.addr) + } + ac.mu.Unlock() + return nil + } +} + +// Run in a goroutine to track the error in transport and create the +// new transport if an error happens. It returns when the channel is closing. +func (ac *addrConn) transportMonitor() { + for { + ac.mu.Lock() + t := ac.transport + ac.mu.Unlock() + select { + // This is needed to detect the teardown when + // the addrConn is idle (i.e., no RPC in flight). + case <-ac.ctx.Done(): + select { + case <-t.Error(): + t.Close() + default: + } + return + case <-t.GoAway(): + // If GoAway happens without any network I/O error, ac is closed without shutting down the + // underlying transport (the transport will be closed when all the pending RPCs finished or + // failed.). + // If GoAway and some network I/O error happen concurrently, ac and its underlying transport + // are closed. + // In both cases, a new ac is created. + select { + case <-t.Error(): + ac.cc.resetAddrConn(ac.addr, true, errNetworkIO) + default: + ac.cc.resetAddrConn(ac.addr, true, errConnDrain) + } + return + case <-t.Error(): + select { + case <-ac.ctx.Done(): + t.Close() + return + case <-t.GoAway(): + ac.cc.resetAddrConn(ac.addr, true, errNetworkIO) + return + default: + } + ac.mu.Lock() + if ac.state == Shutdown { + // ac has been shutdown. + ac.mu.Unlock() + return + } + ac.state = TransientFailure + ac.stateCV.Broadcast() + ac.mu.Unlock() + if err := ac.resetTransport(true); err != nil { + ac.mu.Lock() + ac.printf("transport exiting: %v", err) + ac.mu.Unlock() + grpclog.Printf("grpc: addrConn.transportMonitor exits due to: %v", err) + if err != errConnClosing { + // Keep this ac in cc.conns, to get the reason it's torn down. + ac.tearDown(err) + } + return + } + } + } +} + +// wait blocks until i) the new transport is up or ii) ctx is done or iii) ac is closed or +// iv) transport is in TransientFailure and there's no balancer/failfast is true. +func (ac *addrConn) wait(ctx context.Context, hasBalancer, failfast bool) (transport.ClientTransport, error) { + for { + ac.mu.Lock() + switch { + case ac.state == Shutdown: + if failfast || !hasBalancer { + // RPC is failfast or balancer is nil. This RPC should fail with ac.tearDownErr. + err := ac.tearDownErr + ac.mu.Unlock() + return nil, err + } + ac.mu.Unlock() + return nil, errConnClosing + case ac.state == Ready: + ct := ac.transport + ac.mu.Unlock() + return ct, nil + case ac.state == TransientFailure: + if failfast || hasBalancer { + ac.mu.Unlock() + return nil, errConnUnavailable + } + } + ready := ac.ready + if ready == nil { + ready = make(chan struct{}) + ac.ready = ready + } + ac.mu.Unlock() + select { + case <-ctx.Done(): + return nil, toRPCErr(ctx.Err()) + // Wait until the new transport is ready or failed. + case <-ready: + } + } +} + +// tearDown starts to tear down the addrConn. +// TODO(zhaoq): Make this synchronous to avoid unbounded memory consumption in +// some edge cases (e.g., the caller opens and closes many addrConn's in a +// tight loop. +// tearDown doesn't remove ac from ac.cc.conns. +func (ac *addrConn) tearDown(err error) { + ac.cancel() + + ac.mu.Lock() + defer ac.mu.Unlock() + if ac.down != nil { + ac.down(downErrorf(false, false, "%v", err)) + ac.down = nil + } + if err == errConnDrain && ac.transport != nil { + // GracefulClose(...) may be executed multiple times when + // i) receiving multiple GoAway frames from the server; or + // ii) there are concurrent name resolver/Balancer triggered + // address removal and GoAway. + ac.transport.GracefulClose() + } + if ac.state == Shutdown { + return + } + ac.state = Shutdown + ac.tearDownErr = err + ac.stateCV.Broadcast() + if ac.events != nil { + ac.events.Finish() + ac.events = nil + } + if ac.ready != nil { + close(ac.ready) + ac.ready = nil + } + if ac.transport != nil && err != errConnDrain { + ac.transport.Close() + } + return +} diff --git a/vendor/google.golang.org/grpc/codes/code_string.go b/vendor/google.golang.org/grpc/codes/code_string.go new file mode 100644 index 00000000..e6762d08 --- /dev/null +++ b/vendor/google.golang.org/grpc/codes/code_string.go @@ -0,0 +1,16 @@ +// generated by stringer -type=Code; DO NOT EDIT + +package codes + +import "fmt" + +const _Code_name = "OKCanceledUnknownInvalidArgumentDeadlineExceededNotFoundAlreadyExistsPermissionDeniedResourceExhaustedFailedPreconditionAbortedOutOfRangeUnimplementedInternalUnavailableDataLossUnauthenticated" + +var _Code_index = [...]uint8{0, 2, 10, 17, 32, 48, 56, 69, 85, 102, 120, 127, 137, 150, 158, 169, 177, 192} + +func (i Code) String() string { + if i+1 >= Code(len(_Code_index)) { + return fmt.Sprintf("Code(%d)", i) + } + return _Code_name[_Code_index[i]:_Code_index[i+1]] +} diff --git a/vendor/google.golang.org/grpc/codes/codes.go b/vendor/google.golang.org/grpc/codes/codes.go new file mode 100644 index 00000000..e14b464a --- /dev/null +++ b/vendor/google.golang.org/grpc/codes/codes.go @@ -0,0 +1,159 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +// Package codes defines the canonical error codes used by gRPC. It is +// consistent across various languages. +package codes // import "google.golang.org/grpc/codes" + +// A Code is an unsigned 32-bit error code as defined in the gRPC spec. +type Code uint32 + +//go:generate stringer -type=Code + +const ( + // OK is returned on success. + OK Code = 0 + + // Canceled indicates the operation was cancelled (typically by the caller). + Canceled Code = 1 + + // Unknown error. An example of where this error may be returned is + // if a Status value received from another address space belongs to + // an error-space that is not known in this address space. Also + // errors raised by APIs that do not return enough error information + // may be converted to this error. + Unknown Code = 2 + + // InvalidArgument indicates client specified an invalid argument. + // Note that this differs from FailedPrecondition. It indicates arguments + // that are problematic regardless of the state of the system + // (e.g., a malformed file name). + InvalidArgument Code = 3 + + // DeadlineExceeded means operation expired before completion. + // For operations that change the state of the system, this error may be + // returned even if the operation has completed successfully. For + // example, a successful response from a server could have been delayed + // long enough for the deadline to expire. + DeadlineExceeded Code = 4 + + // NotFound means some requested entity (e.g., file or directory) was + // not found. + NotFound Code = 5 + + // AlreadyExists means an attempt to create an entity failed because one + // already exists. + AlreadyExists Code = 6 + + // PermissionDenied indicates the caller does not have permission to + // execute the specified operation. It must not be used for rejections + // caused by exhausting some resource (use ResourceExhausted + // instead for those errors). It must not be + // used if the caller cannot be identified (use Unauthenticated + // instead for those errors). + PermissionDenied Code = 7 + + // Unauthenticated indicates the request does not have valid + // authentication credentials for the operation. + Unauthenticated Code = 16 + + // ResourceExhausted indicates some resource has been exhausted, perhaps + // a per-user quota, or perhaps the entire file system is out of space. + ResourceExhausted Code = 8 + + // FailedPrecondition indicates operation was rejected because the + // system is not in a state required for the operation's execution. + // For example, directory to be deleted may be non-empty, an rmdir + // operation is applied to a non-directory, etc. + // + // A litmus test that may help a service implementor in deciding + // between FailedPrecondition, Aborted, and Unavailable: + // (a) Use Unavailable if the client can retry just the failing call. + // (b) Use Aborted if the client should retry at a higher-level + // (e.g., restarting a read-modify-write sequence). + // (c) Use FailedPrecondition if the client should not retry until + // the system state has been explicitly fixed. E.g., if an "rmdir" + // fails because the directory is non-empty, FailedPrecondition + // should be returned since the client should not retry unless + // they have first fixed up the directory by deleting files from it. + // (d) Use FailedPrecondition if the client performs conditional + // REST Get/Update/Delete on a resource and the resource on the + // server does not match the condition. E.g., conflicting + // read-modify-write on the same resource. + FailedPrecondition Code = 9 + + // Aborted indicates the operation was aborted, typically due to a + // concurrency issue like sequencer check failures, transaction aborts, + // etc. + // + // See litmus test above for deciding between FailedPrecondition, + // Aborted, and Unavailable. + Aborted Code = 10 + + // OutOfRange means operation was attempted past the valid range. + // E.g., seeking or reading past end of file. + // + // Unlike InvalidArgument, this error indicates a problem that may + // be fixed if the system state changes. For example, a 32-bit file + // system will generate InvalidArgument if asked to read at an + // offset that is not in the range [0,2^32-1], but it will generate + // OutOfRange if asked to read from an offset past the current + // file size. + // + // There is a fair bit of overlap between FailedPrecondition and + // OutOfRange. We recommend using OutOfRange (the more specific + // error) when it applies so that callers who are iterating through + // a space can easily look for an OutOfRange error to detect when + // they are done. + OutOfRange Code = 11 + + // Unimplemented indicates operation is not implemented or not + // supported/enabled in this service. + Unimplemented Code = 12 + + // Internal errors. Means some invariants expected by underlying + // system has been broken. If you see one of these errors, + // something is very broken. + Internal Code = 13 + + // Unavailable indicates the service is currently unavailable. + // This is a most likely a transient condition and may be corrected + // by retrying with a backoff. + // + // See litmus test above for deciding between FailedPrecondition, + // Aborted, and Unavailable. + Unavailable Code = 14 + + // DataLoss indicates unrecoverable data loss or corruption. + DataLoss Code = 15 +) diff --git a/vendor/google.golang.org/grpc/credentials/credentials.go b/vendor/google.golang.org/grpc/credentials/credentials.go new file mode 100644 index 00000000..3f17b706 --- /dev/null +++ b/vendor/google.golang.org/grpc/credentials/credentials.go @@ -0,0 +1,213 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +// Package credentials implements various credentials supported by gRPC library, +// which encapsulate all the state needed by a client to authenticate with a +// server and make various assertions, e.g., about the client's identity, role, +// or whether it is authorized to make a particular call. +package credentials // import "google.golang.org/grpc/credentials" + +import ( + "crypto/tls" + "crypto/x509" + "fmt" + "io/ioutil" + "net" + "strings" + + "golang.org/x/net/context" +) + +var ( + // alpnProtoStr are the specified application level protocols for gRPC. + alpnProtoStr = []string{"h2"} +) + +// PerRPCCredentials defines the common interface for the credentials which need to +// attach security information to every RPC (e.g., oauth2). +type PerRPCCredentials interface { + // GetRequestMetadata gets the current request metadata, refreshing + // tokens if required. This should be called by the transport layer on + // each request, and the data should be populated in headers or other + // context. uri is the URI of the entry point for the request. When + // supported by the underlying implementation, ctx can be used for + // timeout and cancellation. + // TODO(zhaoq): Define the set of the qualified keys instead of leaving + // it as an arbitrary string. + GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) + // RequireTransportSecurity indicates whether the credentials requires + // transport security. + RequireTransportSecurity() bool +} + +// ProtocolInfo provides information regarding the gRPC wire protocol version, +// security protocol, security protocol version in use, etc. +type ProtocolInfo struct { + // ProtocolVersion is the gRPC wire protocol version. + ProtocolVersion string + // SecurityProtocol is the security protocol in use. + SecurityProtocol string + // SecurityVersion is the security protocol version. + SecurityVersion string +} + +// AuthInfo defines the common interface for the auth information the users are interested in. +type AuthInfo interface { + AuthType() string +} + +// TransportCredentials defines the common interface for all the live gRPC wire +// protocols and supported transport security protocols (e.g., TLS, SSL). +type TransportCredentials interface { + // ClientHandshake does the authentication handshake specified by the corresponding + // authentication protocol on rawConn for clients. It returns the authenticated + // connection and the corresponding auth information about the connection. + // Implementations must use the provided context to implement timely cancellation. + ClientHandshake(context.Context, string, net.Conn) (net.Conn, AuthInfo, error) + // ServerHandshake does the authentication handshake for servers. It returns + // the authenticated connection and the corresponding auth information about + // the connection. + ServerHandshake(net.Conn) (net.Conn, AuthInfo, error) + // Info provides the ProtocolInfo of this TransportCredentials. + Info() ProtocolInfo +} + +// TLSInfo contains the auth information for a TLS authenticated connection. +// It implements the AuthInfo interface. +type TLSInfo struct { + State tls.ConnectionState +} + +// AuthType returns the type of TLSInfo as a string. +func (t TLSInfo) AuthType() string { + return "tls" +} + +// tlsCreds is the credentials required for authenticating a connection using TLS. +type tlsCreds struct { + // TLS configuration + config *tls.Config +} + +func (c tlsCreds) Info() ProtocolInfo { + return ProtocolInfo{ + SecurityProtocol: "tls", + SecurityVersion: "1.2", + } +} + +// GetRequestMetadata returns nil, nil since TLS credentials does not have +// metadata. +func (c *tlsCreds) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) { + return nil, nil +} + +func (c *tlsCreds) RequireTransportSecurity() bool { + return true +} + +func (c *tlsCreds) ClientHandshake(ctx context.Context, addr string, rawConn net.Conn) (_ net.Conn, _ AuthInfo, err error) { + // use local cfg to avoid clobbering ServerName if using multiple endpoints + cfg := cloneTLSConfig(c.config) + if cfg.ServerName == "" { + colonPos := strings.LastIndex(addr, ":") + if colonPos == -1 { + colonPos = len(addr) + } + cfg.ServerName = addr[:colonPos] + } + conn := tls.Client(rawConn, cfg) + errChannel := make(chan error, 1) + go func() { + errChannel <- conn.Handshake() + }() + select { + case err := <-errChannel: + if err != nil { + return nil, nil, err + } + case <-ctx.Done(): + return nil, nil, ctx.Err() + } + // TODO(zhaoq): Omit the auth info for client now. It is more for + // information than anything else. + return conn, nil, nil +} + +func (c *tlsCreds) ServerHandshake(rawConn net.Conn) (net.Conn, AuthInfo, error) { + conn := tls.Server(rawConn, c.config) + if err := conn.Handshake(); err != nil { + return nil, nil, err + } + return conn, TLSInfo{conn.ConnectionState()}, nil +} + +// NewTLS uses c to construct a TransportCredentials based on TLS. +func NewTLS(c *tls.Config) TransportCredentials { + tc := &tlsCreds{cloneTLSConfig(c)} + tc.config.NextProtos = alpnProtoStr + return tc +} + +// NewClientTLSFromCert constructs a TLS from the input certificate for client. +func NewClientTLSFromCert(cp *x509.CertPool, serverName string) TransportCredentials { + return NewTLS(&tls.Config{ServerName: serverName, RootCAs: cp}) +} + +// NewClientTLSFromFile constructs a TLS from the input certificate file for client. +func NewClientTLSFromFile(certFile, serverName string) (TransportCredentials, error) { + b, err := ioutil.ReadFile(certFile) + if err != nil { + return nil, err + } + cp := x509.NewCertPool() + if !cp.AppendCertsFromPEM(b) { + return nil, fmt.Errorf("credentials: failed to append certificates") + } + return NewTLS(&tls.Config{ServerName: serverName, RootCAs: cp}), nil +} + +// NewServerTLSFromCert constructs a TLS from the input certificate for server. +func NewServerTLSFromCert(cert *tls.Certificate) TransportCredentials { + return NewTLS(&tls.Config{Certificates: []tls.Certificate{*cert}}) +} + +// NewServerTLSFromFile constructs a TLS from the input certificate file and key +// file for server. +func NewServerTLSFromFile(certFile, keyFile string) (TransportCredentials, error) { + cert, err := tls.LoadX509KeyPair(certFile, keyFile) + if err != nil { + return nil, err + } + return NewTLS(&tls.Config{Certificates: []tls.Certificate{cert}}), nil +} diff --git a/vendor/google.golang.org/grpc/credentials/credentials_util_go17.go b/vendor/google.golang.org/grpc/credentials/credentials_util_go17.go new file mode 100644 index 00000000..9647b9ec --- /dev/null +++ b/vendor/google.golang.org/grpc/credentials/credentials_util_go17.go @@ -0,0 +1,76 @@ +// +build go1.7 + +/* + * + * Copyright 2016, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package credentials + +import ( + "crypto/tls" +) + +// cloneTLSConfig returns a shallow clone of the exported +// fields of cfg, ignoring the unexported sync.Once, which +// contains a mutex and must not be copied. +// +// If cfg is nil, a new zero tls.Config is returned. +// +// TODO replace this function with official clone function. +func cloneTLSConfig(cfg *tls.Config) *tls.Config { + if cfg == nil { + return &tls.Config{} + } + return &tls.Config{ + Rand: cfg.Rand, + Time: cfg.Time, + Certificates: cfg.Certificates, + NameToCertificate: cfg.NameToCertificate, + GetCertificate: cfg.GetCertificate, + RootCAs: cfg.RootCAs, + NextProtos: cfg.NextProtos, + ServerName: cfg.ServerName, + ClientAuth: cfg.ClientAuth, + ClientCAs: cfg.ClientCAs, + InsecureSkipVerify: cfg.InsecureSkipVerify, + CipherSuites: cfg.CipherSuites, + PreferServerCipherSuites: cfg.PreferServerCipherSuites, + SessionTicketsDisabled: cfg.SessionTicketsDisabled, + SessionTicketKey: cfg.SessionTicketKey, + ClientSessionCache: cfg.ClientSessionCache, + MinVersion: cfg.MinVersion, + MaxVersion: cfg.MaxVersion, + CurvePreferences: cfg.CurvePreferences, + DynamicRecordSizingDisabled: cfg.DynamicRecordSizingDisabled, + Renegotiation: cfg.Renegotiation, + } +} diff --git a/vendor/google.golang.org/grpc/credentials/credentials_util_pre_go17.go b/vendor/google.golang.org/grpc/credentials/credentials_util_pre_go17.go new file mode 100644 index 00000000..09b8d12c --- /dev/null +++ b/vendor/google.golang.org/grpc/credentials/credentials_util_pre_go17.go @@ -0,0 +1,74 @@ +// +build !go1.7 + +/* + * + * Copyright 2016, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package credentials + +import ( + "crypto/tls" +) + +// cloneTLSConfig returns a shallow clone of the exported +// fields of cfg, ignoring the unexported sync.Once, which +// contains a mutex and must not be copied. +// +// If cfg is nil, a new zero tls.Config is returned. +// +// TODO replace this function with official clone function. +func cloneTLSConfig(cfg *tls.Config) *tls.Config { + if cfg == nil { + return &tls.Config{} + } + return &tls.Config{ + Rand: cfg.Rand, + Time: cfg.Time, + Certificates: cfg.Certificates, + NameToCertificate: cfg.NameToCertificate, + GetCertificate: cfg.GetCertificate, + RootCAs: cfg.RootCAs, + NextProtos: cfg.NextProtos, + ServerName: cfg.ServerName, + ClientAuth: cfg.ClientAuth, + ClientCAs: cfg.ClientCAs, + InsecureSkipVerify: cfg.InsecureSkipVerify, + CipherSuites: cfg.CipherSuites, + PreferServerCipherSuites: cfg.PreferServerCipherSuites, + SessionTicketsDisabled: cfg.SessionTicketsDisabled, + SessionTicketKey: cfg.SessionTicketKey, + ClientSessionCache: cfg.ClientSessionCache, + MinVersion: cfg.MinVersion, + MaxVersion: cfg.MaxVersion, + CurvePreferences: cfg.CurvePreferences, + } +} diff --git a/vendor/google.golang.org/grpc/credentials/oauth/oauth.go b/vendor/google.golang.org/grpc/credentials/oauth/oauth.go new file mode 100644 index 00000000..8e68c4d7 --- /dev/null +++ b/vendor/google.golang.org/grpc/credentials/oauth/oauth.go @@ -0,0 +1,180 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +// Package oauth implements gRPC credentials using OAuth. +package oauth + +import ( + "fmt" + "io/ioutil" + + "golang.org/x/net/context" + "golang.org/x/oauth2" + "golang.org/x/oauth2/google" + "golang.org/x/oauth2/jwt" + "google.golang.org/grpc/credentials" +) + +// TokenSource supplies PerRPCCredentials from an oauth2.TokenSource. +type TokenSource struct { + oauth2.TokenSource +} + +// GetRequestMetadata gets the request metadata as a map from a TokenSource. +func (ts TokenSource) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) { + token, err := ts.Token() + if err != nil { + return nil, err + } + return map[string]string{ + "authorization": token.Type() + " " + token.AccessToken, + }, nil +} + +// RequireTransportSecurity indicates whether the credentails requires transport security. +func (ts TokenSource) RequireTransportSecurity() bool { + return true +} + +type jwtAccess struct { + jsonKey []byte +} + +// NewJWTAccessFromFile creates PerRPCCredentials from the given keyFile. +func NewJWTAccessFromFile(keyFile string) (credentials.PerRPCCredentials, error) { + jsonKey, err := ioutil.ReadFile(keyFile) + if err != nil { + return nil, fmt.Errorf("credentials: failed to read the service account key file: %v", err) + } + return NewJWTAccessFromKey(jsonKey) +} + +// NewJWTAccessFromKey creates PerRPCCredentials from the given jsonKey. +func NewJWTAccessFromKey(jsonKey []byte) (credentials.PerRPCCredentials, error) { + return jwtAccess{jsonKey}, nil +} + +func (j jwtAccess) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) { + ts, err := google.JWTAccessTokenSourceFromJSON(j.jsonKey, uri[0]) + if err != nil { + return nil, err + } + token, err := ts.Token() + if err != nil { + return nil, err + } + return map[string]string{ + "authorization": token.TokenType + " " + token.AccessToken, + }, nil +} + +func (j jwtAccess) RequireTransportSecurity() bool { + return true +} + +// oauthAccess supplies PerRPCCredentials from a given token. +type oauthAccess struct { + token oauth2.Token +} + +// NewOauthAccess constructs the PerRPCCredentials using a given token. +func NewOauthAccess(token *oauth2.Token) credentials.PerRPCCredentials { + return oauthAccess{token: *token} +} + +func (oa oauthAccess) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) { + return map[string]string{ + "authorization": oa.token.TokenType + " " + oa.token.AccessToken, + }, nil +} + +func (oa oauthAccess) RequireTransportSecurity() bool { + return true +} + +// NewComputeEngine constructs the PerRPCCredentials that fetches access tokens from +// Google Compute Engine (GCE)'s metadata server. It is only valid to use this +// if your program is running on a GCE instance. +// TODO(dsymonds): Deprecate and remove this. +func NewComputeEngine() credentials.PerRPCCredentials { + return TokenSource{google.ComputeTokenSource("")} +} + +// serviceAccount represents PerRPCCredentials via JWT signing key. +type serviceAccount struct { + config *jwt.Config +} + +func (s serviceAccount) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) { + token, err := s.config.TokenSource(ctx).Token() + if err != nil { + return nil, err + } + return map[string]string{ + "authorization": token.TokenType + " " + token.AccessToken, + }, nil +} + +func (s serviceAccount) RequireTransportSecurity() bool { + return true +} + +// NewServiceAccountFromKey constructs the PerRPCCredentials using the JSON key slice +// from a Google Developers service account. +func NewServiceAccountFromKey(jsonKey []byte, scope ...string) (credentials.PerRPCCredentials, error) { + config, err := google.JWTConfigFromJSON(jsonKey, scope...) + if err != nil { + return nil, err + } + return serviceAccount{config: config}, nil +} + +// NewServiceAccountFromFile constructs the PerRPCCredentials using the JSON key file +// of a Google Developers service account. +func NewServiceAccountFromFile(keyFile string, scope ...string) (credentials.PerRPCCredentials, error) { + jsonKey, err := ioutil.ReadFile(keyFile) + if err != nil { + return nil, fmt.Errorf("credentials: failed to read the service account key file: %v", err) + } + return NewServiceAccountFromKey(jsonKey, scope...) +} + +// NewApplicationDefault returns "Application Default Credentials". For more +// detail, see https://developers.google.com/accounts/docs/application-default-credentials. +func NewApplicationDefault(ctx context.Context, scope ...string) (credentials.PerRPCCredentials, error) { + t, err := google.DefaultTokenSource(ctx, scope...) + if err != nil { + return nil, err + } + return TokenSource{t}, nil +} diff --git a/vendor/google.golang.org/grpc/doc.go b/vendor/google.golang.org/grpc/doc.go new file mode 100644 index 00000000..a35f2188 --- /dev/null +++ b/vendor/google.golang.org/grpc/doc.go @@ -0,0 +1,6 @@ +/* +Package grpc implements an RPC system called gRPC. + +See www.grpc.io for more information about gRPC. +*/ +package grpc // import "google.golang.org/grpc" diff --git a/vendor/google.golang.org/grpc/grpclog/logger.go b/vendor/google.golang.org/grpc/grpclog/logger.go new file mode 100644 index 00000000..3b293307 --- /dev/null +++ b/vendor/google.golang.org/grpc/grpclog/logger.go @@ -0,0 +1,93 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +/* +Package grpclog defines logging for grpc. +*/ +package grpclog // import "google.golang.org/grpc/grpclog" + +import ( + "log" + "os" +) + +// Use golang's standard logger by default. +// Access is not mutex-protected: do not modify except in init() +// functions. +var logger Logger = log.New(os.Stderr, "", log.LstdFlags) + +// Logger mimics golang's standard Logger as an interface. +type Logger interface { + Fatal(args ...interface{}) + Fatalf(format string, args ...interface{}) + Fatalln(args ...interface{}) + Print(args ...interface{}) + Printf(format string, args ...interface{}) + Println(args ...interface{}) +} + +// SetLogger sets the logger that is used in grpc. Call only from +// init() functions. +func SetLogger(l Logger) { + logger = l +} + +// Fatal is equivalent to Print() followed by a call to os.Exit() with a non-zero exit code. +func Fatal(args ...interface{}) { + logger.Fatal(args...) +} + +// Fatalf is equivalent to Printf() followed by a call to os.Exit() with a non-zero exit code. +func Fatalf(format string, args ...interface{}) { + logger.Fatalf(format, args...) +} + +// Fatalln is equivalent to Println() followed by a call to os.Exit()) with a non-zero exit code. +func Fatalln(args ...interface{}) { + logger.Fatalln(args...) +} + +// Print prints to the logger. Arguments are handled in the manner of fmt.Print. +func Print(args ...interface{}) { + logger.Print(args...) +} + +// Printf prints to the logger. Arguments are handled in the manner of fmt.Printf. +func Printf(format string, args ...interface{}) { + logger.Printf(format, args...) +} + +// Println prints to the logger. Arguments are handled in the manner of fmt.Println. +func Println(args ...interface{}) { + logger.Println(args...) +} diff --git a/vendor/google.golang.org/grpc/interceptor.go b/vendor/google.golang.org/grpc/interceptor.go new file mode 100644 index 00000000..588f59e5 --- /dev/null +++ b/vendor/google.golang.org/grpc/interceptor.go @@ -0,0 +1,74 @@ +/* + * + * Copyright 2016, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package grpc + +import ( + "golang.org/x/net/context" +) + +// UnaryServerInfo consists of various information about a unary RPC on +// server side. All per-rpc information may be mutated by the interceptor. +type UnaryServerInfo struct { + // Server is the service implementation the user provides. This is read-only. + Server interface{} + // FullMethod is the full RPC method string, i.e., /package.service/method. + FullMethod string +} + +// UnaryHandler defines the handler invoked by UnaryServerInterceptor to complete the normal +// execution of a unary RPC. +type UnaryHandler func(ctx context.Context, req interface{}) (interface{}, error) + +// UnaryServerInterceptor provides a hook to intercept the execution of a unary RPC on the server. info +// contains all the information of this RPC the interceptor can operate on. And handler is the wrapper +// of the service method implementation. It is the responsibility of the interceptor to invoke handler +// to complete the RPC. +type UnaryServerInterceptor func(ctx context.Context, req interface{}, info *UnaryServerInfo, handler UnaryHandler) (resp interface{}, err error) + +// StreamServerInfo consists of various information about a streaming RPC on +// server side. All per-rpc information may be mutated by the interceptor. +type StreamServerInfo struct { + // FullMethod is the full RPC method string, i.e., /package.service/method. + FullMethod string + // IsClientStream indicates whether the RPC is a client streaming RPC. + IsClientStream bool + // IsServerStream indicates whether the RPC is a server streaming RPC. + IsServerStream bool +} + +// StreamServerInterceptor provides a hook to intercept the execution of a streaming RPC on the server. +// info contains all the information of this RPC the interceptor can operate on. And handler is the +// service method implementation. It is the responsibility of the interceptor to invoke handler to +// complete the RPC. +type StreamServerInterceptor func(srv interface{}, ss ServerStream, info *StreamServerInfo, handler StreamHandler) error diff --git a/vendor/google.golang.org/grpc/internal/internal.go b/vendor/google.golang.org/grpc/internal/internal.go new file mode 100644 index 00000000..5489143a --- /dev/null +++ b/vendor/google.golang.org/grpc/internal/internal.go @@ -0,0 +1,49 @@ +/* + * Copyright 2016, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +// Package internal contains gRPC-internal code for testing, to avoid polluting +// the godoc of the top-level grpc package. +package internal + +// TestingCloseConns closes all existing transports but keeps +// grpcServer.lis accepting new connections. +// +// The provided grpcServer must be of type *grpc.Server. It is untyped +// for circular dependency reasons. +var TestingCloseConns func(grpcServer interface{}) + +// TestingUseHandlerImpl enables the http.Handler-based server implementation. +// It must be called before Serve and requires TLS credentials. +// +// The provided grpcServer must be of type *grpc.Server. It is untyped +// for circular dependency reasons. +var TestingUseHandlerImpl func(grpcServer interface{}) diff --git a/vendor/google.golang.org/grpc/metadata/metadata.go b/vendor/google.golang.org/grpc/metadata/metadata.go new file mode 100644 index 00000000..954c0f77 --- /dev/null +++ b/vendor/google.golang.org/grpc/metadata/metadata.go @@ -0,0 +1,140 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +// Package metadata define the structure of the metadata supported by gRPC library. +package metadata // import "google.golang.org/grpc/metadata" + +import ( + "encoding/base64" + "fmt" + "strings" + + "golang.org/x/net/context" +) + +const ( + binHdrSuffix = "-bin" +) + +// encodeKeyValue encodes key and value qualified for transmission via gRPC. +// Transmitting binary headers violates HTTP/2 spec. +// TODO(zhaoq): Maybe check if k is ASCII also. +func encodeKeyValue(k, v string) (string, string) { + k = strings.ToLower(k) + if strings.HasSuffix(k, binHdrSuffix) { + val := base64.StdEncoding.EncodeToString([]byte(v)) + v = string(val) + } + return k, v +} + +// DecodeKeyValue returns the original key and value corresponding to the +// encoded data in k, v. +// If k is a binary header and v contains comma, v is split on comma before decoded, +// and the decoded v will be joined with comma before returned. +func DecodeKeyValue(k, v string) (string, string, error) { + if !strings.HasSuffix(k, binHdrSuffix) { + return k, v, nil + } + vvs := strings.Split(v, ",") + for i, vv := range vvs { + val, err := base64.StdEncoding.DecodeString(vv) + if err != nil { + return "", "", err + } + vvs[i] = string(val) + } + return k, strings.Join(vvs, ","), nil +} + +// MD is a mapping from metadata keys to values. Users should use the following +// two convenience functions New and Pairs to generate MD. +type MD map[string][]string + +// New creates a MD from given key-value map. +func New(m map[string]string) MD { + md := MD{} + for k, v := range m { + key, val := encodeKeyValue(k, v) + md[key] = append(md[key], val) + } + return md +} + +// Pairs returns an MD formed by the mapping of key, value ... +// Pairs panics if len(kv) is odd. +func Pairs(kv ...string) MD { + if len(kv)%2 == 1 { + panic(fmt.Sprintf("metadata: Pairs got the odd number of input pairs for metadata: %d", len(kv))) + } + md := MD{} + var k string + for i, s := range kv { + if i%2 == 0 { + k = s + continue + } + key, val := encodeKeyValue(k, s) + md[key] = append(md[key], val) + } + return md +} + +// Len returns the number of items in md. +func (md MD) Len() int { + return len(md) +} + +// Copy returns a copy of md. +func (md MD) Copy() MD { + out := MD{} + for k, v := range md { + for _, i := range v { + out[k] = append(out[k], i) + } + } + return out +} + +type mdKey struct{} + +// NewContext creates a new context with md attached. +func NewContext(ctx context.Context, md MD) context.Context { + return context.WithValue(ctx, mdKey{}, md) +} + +// FromContext returns the MD in ctx if it exists. +func FromContext(ctx context.Context) (md MD, ok bool) { + md, ok = ctx.Value(mdKey{}).(MD) + return +} diff --git a/vendor/google.golang.org/grpc/naming/naming.go b/vendor/google.golang.org/grpc/naming/naming.go new file mode 100644 index 00000000..c2e0871e --- /dev/null +++ b/vendor/google.golang.org/grpc/naming/naming.go @@ -0,0 +1,74 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +// Package naming defines the naming API and related data structures for gRPC. +// The interface is EXPERIMENTAL and may be suject to change. +package naming + +// Operation defines the corresponding operations for a name resolution change. +type Operation uint8 + +const ( + // Add indicates a new address is added. + Add Operation = iota + // Delete indicates an exisiting address is deleted. + Delete +) + +// Update defines a name resolution update. Notice that it is not valid having both +// empty string Addr and nil Metadata in an Update. +type Update struct { + // Op indicates the operation of the update. + Op Operation + // Addr is the updated address. It is empty string if there is no address update. + Addr string + // Metadata is the updated metadata. It is nil if there is no metadata update. + // Metadata is not required for a custom naming implementation. + Metadata interface{} +} + +// Resolver creates a Watcher for a target to track its resolution changes. +type Resolver interface { + // Resolve creates a Watcher for target. + Resolve(target string) (Watcher, error) +} + +// Watcher watches for the updates on the specified target. +type Watcher interface { + // Next blocks until an update or error happens. It may return one or more + // updates. The first call should get the full set of the results. It should + // return an error if and only if Watcher cannot recover. + Next() ([]*Update, error) + // Close closes the Watcher. + Close() +} diff --git a/vendor/google.golang.org/grpc/peer/peer.go b/vendor/google.golang.org/grpc/peer/peer.go new file mode 100644 index 00000000..bfa6205b --- /dev/null +++ b/vendor/google.golang.org/grpc/peer/peer.go @@ -0,0 +1,65 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +// Package peer defines various peer information associated with RPCs and +// corresponding utils. +package peer + +import ( + "net" + + "golang.org/x/net/context" + "google.golang.org/grpc/credentials" +) + +// Peer contains the information of the peer for an RPC. +type Peer struct { + // Addr is the peer address. + Addr net.Addr + // AuthInfo is the authentication information of the transport. + // It is nil if there is no transport security being used. + AuthInfo credentials.AuthInfo +} + +type peerKey struct{} + +// NewContext creates a new context with peer information attached. +func NewContext(ctx context.Context, p *Peer) context.Context { + return context.WithValue(ctx, peerKey{}, p) +} + +// FromContext returns the peer information in ctx if it exists. +func FromContext(ctx context.Context) (p *Peer, ok bool) { + p, ok = ctx.Value(peerKey{}).(*Peer) + return +} diff --git a/vendor/google.golang.org/grpc/rpc_util.go b/vendor/google.golang.org/grpc/rpc_util.go new file mode 100644 index 00000000..35ac9cc7 --- /dev/null +++ b/vendor/google.golang.org/grpc/rpc_util.go @@ -0,0 +1,457 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package grpc + +import ( + "bytes" + "compress/gzip" + "encoding/binary" + "fmt" + "io" + "io/ioutil" + "math" + "os" + + "github.com/golang/protobuf/proto" + "golang.org/x/net/context" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/transport" +) + +// Codec defines the interface gRPC uses to encode and decode messages. +type Codec interface { + // Marshal returns the wire format of v. + Marshal(v interface{}) ([]byte, error) + // Unmarshal parses the wire format into v. + Unmarshal(data []byte, v interface{}) error + // String returns the name of the Codec implementation. The returned + // string will be used as part of content type in transmission. + String() string +} + +// protoCodec is a Codec implementation with protobuf. It is the default codec for gRPC. +type protoCodec struct{} + +func (protoCodec) Marshal(v interface{}) ([]byte, error) { + return proto.Marshal(v.(proto.Message)) +} + +func (protoCodec) Unmarshal(data []byte, v interface{}) error { + return proto.Unmarshal(data, v.(proto.Message)) +} + +func (protoCodec) String() string { + return "proto" +} + +// Compressor defines the interface gRPC uses to compress a message. +type Compressor interface { + // Do compresses p into w. + Do(w io.Writer, p []byte) error + // Type returns the compression algorithm the Compressor uses. + Type() string +} + +// NewGZIPCompressor creates a Compressor based on GZIP. +func NewGZIPCompressor() Compressor { + return &gzipCompressor{} +} + +type gzipCompressor struct { +} + +func (c *gzipCompressor) Do(w io.Writer, p []byte) error { + z := gzip.NewWriter(w) + if _, err := z.Write(p); err != nil { + return err + } + return z.Close() +} + +func (c *gzipCompressor) Type() string { + return "gzip" +} + +// Decompressor defines the interface gRPC uses to decompress a message. +type Decompressor interface { + // Do reads the data from r and uncompress them. + Do(r io.Reader) ([]byte, error) + // Type returns the compression algorithm the Decompressor uses. + Type() string +} + +type gzipDecompressor struct { +} + +// NewGZIPDecompressor creates a Decompressor based on GZIP. +func NewGZIPDecompressor() Decompressor { + return &gzipDecompressor{} +} + +func (d *gzipDecompressor) Do(r io.Reader) ([]byte, error) { + z, err := gzip.NewReader(r) + if err != nil { + return nil, err + } + defer z.Close() + return ioutil.ReadAll(z) +} + +func (d *gzipDecompressor) Type() string { + return "gzip" +} + +// callInfo contains all related configuration and information about an RPC. +type callInfo struct { + failFast bool + headerMD metadata.MD + trailerMD metadata.MD + traceInfo traceInfo // in trace.go +} + +var defaultCallInfo = callInfo{failFast: true} + +// CallOption configures a Call before it starts or extracts information from +// a Call after it completes. +type CallOption interface { + // before is called before the call is sent to any server. If before + // returns a non-nil error, the RPC fails with that error. + before(*callInfo) error + + // after is called after the call has completed. after cannot return an + // error, so any failures should be reported via output parameters. + after(*callInfo) +} + +type beforeCall func(c *callInfo) error + +func (o beforeCall) before(c *callInfo) error { return o(c) } +func (o beforeCall) after(c *callInfo) {} + +type afterCall func(c *callInfo) + +func (o afterCall) before(c *callInfo) error { return nil } +func (o afterCall) after(c *callInfo) { o(c) } + +// Header returns a CallOptions that retrieves the header metadata +// for a unary RPC. +func Header(md *metadata.MD) CallOption { + return afterCall(func(c *callInfo) { + *md = c.headerMD + }) +} + +// Trailer returns a CallOptions that retrieves the trailer metadata +// for a unary RPC. +func Trailer(md *metadata.MD) CallOption { + return afterCall(func(c *callInfo) { + *md = c.trailerMD + }) +} + +// FailFast configures the action to take when an RPC is attempted on broken +// connections or unreachable servers. If failfast is true, the RPC will fail +// immediately. Otherwise, the RPC client will block the call until a +// connection is available (or the call is canceled or times out) and will retry +// the call if it fails due to a transient error. Please refer to +// https://github.com/grpc/grpc/blob/master/doc/fail_fast.md +func FailFast(failFast bool) CallOption { + return beforeCall(func(c *callInfo) error { + c.failFast = failFast + return nil + }) +} + +// The format of the payload: compressed or not? +type payloadFormat uint8 + +const ( + compressionNone payloadFormat = iota // no compression + compressionMade +) + +// parser reads complete gRPC messages from the underlying reader. +type parser struct { + // r is the underlying reader. + // See the comment on recvMsg for the permissible + // error types. + r io.Reader + + // The header of a gRPC message. Find more detail + // at http://www.grpc.io/docs/guides/wire.html. + header [5]byte +} + +// recvMsg reads a complete gRPC message from the stream. +// +// It returns the message and its payload (compression/encoding) +// format. The caller owns the returned msg memory. +// +// If there is an error, possible values are: +// * io.EOF, when no messages remain +// * io.ErrUnexpectedEOF +// * of type transport.ConnectionError +// * of type transport.StreamError +// No other error values or types must be returned, which also means +// that the underlying io.Reader must not return an incompatible +// error. +func (p *parser) recvMsg(maxMsgSize int) (pf payloadFormat, msg []byte, err error) { + if _, err := io.ReadFull(p.r, p.header[:]); err != nil { + return 0, nil, err + } + + pf = payloadFormat(p.header[0]) + length := binary.BigEndian.Uint32(p.header[1:]) + + if length == 0 { + return pf, nil, nil + } + if length > uint32(maxMsgSize) { + return 0, nil, Errorf(codes.Internal, "grpc: received message length %d exceeding the max size %d", length, maxMsgSize) + } + // TODO(bradfitz,zhaoq): garbage. reuse buffer after proto decoding instead + // of making it for each message: + msg = make([]byte, int(length)) + if _, err := io.ReadFull(p.r, msg); err != nil { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + return 0, nil, err + } + return pf, msg, nil +} + +// encode serializes msg and prepends the message header. If msg is nil, it +// generates the message header of 0 message length. +func encode(c Codec, msg interface{}, cp Compressor, cbuf *bytes.Buffer) ([]byte, error) { + var b []byte + var length uint + if msg != nil { + var err error + // TODO(zhaoq): optimize to reduce memory alloc and copying. + b, err = c.Marshal(msg) + if err != nil { + return nil, err + } + if cp != nil { + if err := cp.Do(cbuf, b); err != nil { + return nil, err + } + b = cbuf.Bytes() + } + length = uint(len(b)) + } + if length > math.MaxUint32 { + return nil, Errorf(codes.InvalidArgument, "grpc: message too large (%d bytes)", length) + } + + const ( + payloadLen = 1 + sizeLen = 4 + ) + + var buf = make([]byte, payloadLen+sizeLen+len(b)) + + // Write payload format + if cp == nil { + buf[0] = byte(compressionNone) + } else { + buf[0] = byte(compressionMade) + } + // Write length of b into buf + binary.BigEndian.PutUint32(buf[1:], uint32(length)) + // Copy encoded msg to buf + copy(buf[5:], b) + + return buf, nil +} + +func checkRecvPayload(pf payloadFormat, recvCompress string, dc Decompressor) error { + switch pf { + case compressionNone: + case compressionMade: + if dc == nil || recvCompress != dc.Type() { + return transport.StreamErrorf(codes.Unimplemented, "grpc: Decompressor is not installed for grpc-encoding %q", recvCompress) + } + default: + return transport.StreamErrorf(codes.Internal, "grpc: received unexpected payload format %d", pf) + } + return nil +} + +func recv(p *parser, c Codec, s *transport.Stream, dc Decompressor, m interface{}, maxMsgSize int) error { + pf, d, err := p.recvMsg(maxMsgSize) + if err != nil { + return err + } + if err := checkRecvPayload(pf, s.RecvCompress(), dc); err != nil { + return err + } + if pf == compressionMade { + d, err = dc.Do(bytes.NewReader(d)) + if err != nil { + return Errorf(codes.Internal, "grpc: failed to decompress the received message %v", err) + } + } + if len(d) > maxMsgSize { + // TODO: Revisit the error code. Currently keep it consistent with java + // implementation. + return Errorf(codes.Internal, "grpc: received a message of %d bytes exceeding %d limit", len(d), maxMsgSize) + } + if err := c.Unmarshal(d, m); err != nil { + return Errorf(codes.Internal, "grpc: failed to unmarshal the received message %v", err) + } + return nil +} + +// rpcError defines the status from an RPC. +type rpcError struct { + code codes.Code + desc string +} + +func (e *rpcError) Error() string { + return fmt.Sprintf("rpc error: code = %d desc = %s", e.code, e.desc) +} + +// Code returns the error code for err if it was produced by the rpc system. +// Otherwise, it returns codes.Unknown. +func Code(err error) codes.Code { + if err == nil { + return codes.OK + } + if e, ok := err.(*rpcError); ok { + return e.code + } + return codes.Unknown +} + +// ErrorDesc returns the error description of err if it was produced by the rpc system. +// Otherwise, it returns err.Error() or empty string when err is nil. +func ErrorDesc(err error) string { + if err == nil { + return "" + } + if e, ok := err.(*rpcError); ok { + return e.desc + } + return err.Error() +} + +// Errorf returns an error containing an error code and a description; +// Errorf returns nil if c is OK. +func Errorf(c codes.Code, format string, a ...interface{}) error { + if c == codes.OK { + return nil + } + return &rpcError{ + code: c, + desc: fmt.Sprintf(format, a...), + } +} + +// toRPCErr converts an error into a rpcError. +func toRPCErr(err error) error { + switch e := err.(type) { + case *rpcError: + return err + case transport.StreamError: + return &rpcError{ + code: e.Code, + desc: e.Desc, + } + case transport.ConnectionError: + return &rpcError{ + code: codes.Internal, + desc: e.Desc, + } + default: + switch err { + case context.DeadlineExceeded: + return &rpcError{ + code: codes.DeadlineExceeded, + desc: err.Error(), + } + case context.Canceled: + return &rpcError{ + code: codes.Canceled, + desc: err.Error(), + } + case ErrClientConnClosing: + return &rpcError{ + code: codes.FailedPrecondition, + desc: err.Error(), + } + } + + } + return Errorf(codes.Unknown, "%v", err) +} + +// convertCode converts a standard Go error into its canonical code. Note that +// this is only used to translate the error returned by the server applications. +func convertCode(err error) codes.Code { + switch err { + case nil: + return codes.OK + case io.EOF: + return codes.OutOfRange + case io.ErrClosedPipe, io.ErrNoProgress, io.ErrShortBuffer, io.ErrShortWrite, io.ErrUnexpectedEOF: + return codes.FailedPrecondition + case os.ErrInvalid: + return codes.InvalidArgument + case context.Canceled: + return codes.Canceled + case context.DeadlineExceeded: + return codes.DeadlineExceeded + } + switch { + case os.IsExist(err): + return codes.AlreadyExists + case os.IsNotExist(err): + return codes.NotFound + case os.IsPermission(err): + return codes.PermissionDenied + } + return codes.Unknown +} + +// SupportPackageIsVersion3 is referenced from generated protocol buffer files +// to assert that that code is compatible with this version of the grpc package. +// +// This constant may be renamed in the future if a change in the generated code +// requires a synchronised update of grpc-go and protoc-gen-go. This constant +// should not be referenced from any other code. +const SupportPackageIsVersion3 = true diff --git a/vendor/google.golang.org/grpc/server.go b/vendor/google.golang.org/grpc/server.go new file mode 100644 index 00000000..1ed8aac9 --- /dev/null +++ b/vendor/google.golang.org/grpc/server.go @@ -0,0 +1,894 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package grpc + +import ( + "bytes" + "errors" + "fmt" + "io" + "net" + "net/http" + "reflect" + "runtime" + "strings" + "sync" + "time" + + "golang.org/x/net/context" + "golang.org/x/net/http2" + "golang.org/x/net/trace" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/credentials" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/internal" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/transport" +) + +type methodHandler func(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor UnaryServerInterceptor) (interface{}, error) + +// MethodDesc represents an RPC service's method specification. +type MethodDesc struct { + MethodName string + Handler methodHandler +} + +// ServiceDesc represents an RPC service's specification. +type ServiceDesc struct { + ServiceName string + // The pointer to the service interface. Used to check whether the user + // provided implementation satisfies the interface requirements. + HandlerType interface{} + Methods []MethodDesc + Streams []StreamDesc + Metadata interface{} +} + +// service consists of the information of the server serving this service and +// the methods in this service. +type service struct { + server interface{} // the server for service methods + md map[string]*MethodDesc + sd map[string]*StreamDesc + mdata interface{} +} + +// Server is a gRPC server to serve RPC requests. +type Server struct { + opts options + + mu sync.Mutex // guards following + lis map[net.Listener]bool + conns map[io.Closer]bool + drain bool + // A CondVar to let GracefulStop() blocks until all the pending RPCs are finished + // and all the transport goes away. + cv *sync.Cond + m map[string]*service // service name -> service info + events trace.EventLog +} + +type options struct { + creds credentials.TransportCredentials + codec Codec + cp Compressor + dc Decompressor + maxMsgSize int + unaryInt UnaryServerInterceptor + streamInt StreamServerInterceptor + maxConcurrentStreams uint32 + useHandlerImpl bool // use http.Handler-based server +} + +var defaultMaxMsgSize = 1024 * 1024 * 4 // use 4MB as the default message size limit + +// A ServerOption sets options. +type ServerOption func(*options) + +// CustomCodec returns a ServerOption that sets a codec for message marshaling and unmarshaling. +func CustomCodec(codec Codec) ServerOption { + return func(o *options) { + o.codec = codec + } +} + +// RPCCompressor returns a ServerOption that sets a compressor for outbound messages. +func RPCCompressor(cp Compressor) ServerOption { + return func(o *options) { + o.cp = cp + } +} + +// RPCDecompressor returns a ServerOption that sets a decompressor for inbound messages. +func RPCDecompressor(dc Decompressor) ServerOption { + return func(o *options) { + o.dc = dc + } +} + +// MaxMsgSize returns a ServerOption to set the max message size in bytes for inbound mesages. +// If this is not set, gRPC uses the default 4MB. +func MaxMsgSize(m int) ServerOption { + return func(o *options) { + o.maxMsgSize = m + } +} + +// MaxConcurrentStreams returns a ServerOption that will apply a limit on the number +// of concurrent streams to each ServerTransport. +func MaxConcurrentStreams(n uint32) ServerOption { + return func(o *options) { + o.maxConcurrentStreams = n + } +} + +// Creds returns a ServerOption that sets credentials for server connections. +func Creds(c credentials.TransportCredentials) ServerOption { + return func(o *options) { + o.creds = c + } +} + +// UnaryInterceptor returns a ServerOption that sets the UnaryServerInterceptor for the +// server. Only one unary interceptor can be installed. The construction of multiple +// interceptors (e.g., chaining) can be implemented at the caller. +func UnaryInterceptor(i UnaryServerInterceptor) ServerOption { + return func(o *options) { + if o.unaryInt != nil { + panic("The unary server interceptor has been set.") + } + o.unaryInt = i + } +} + +// StreamInterceptor returns a ServerOption that sets the StreamServerInterceptor for the +// server. Only one stream interceptor can be installed. +func StreamInterceptor(i StreamServerInterceptor) ServerOption { + return func(o *options) { + if o.streamInt != nil { + panic("The stream server interceptor has been set.") + } + o.streamInt = i + } +} + +// NewServer creates a gRPC server which has no service registered and has not +// started to accept requests yet. +func NewServer(opt ...ServerOption) *Server { + var opts options + opts.maxMsgSize = defaultMaxMsgSize + for _, o := range opt { + o(&opts) + } + if opts.codec == nil { + // Set the default codec. + opts.codec = protoCodec{} + } + s := &Server{ + lis: make(map[net.Listener]bool), + opts: opts, + conns: make(map[io.Closer]bool), + m: make(map[string]*service), + } + s.cv = sync.NewCond(&s.mu) + if EnableTracing { + _, file, line, _ := runtime.Caller(1) + s.events = trace.NewEventLog("grpc.Server", fmt.Sprintf("%s:%d", file, line)) + } + return s +} + +// printf records an event in s's event log, unless s has been stopped. +// REQUIRES s.mu is held. +func (s *Server) printf(format string, a ...interface{}) { + if s.events != nil { + s.events.Printf(format, a...) + } +} + +// errorf records an error in s's event log, unless s has been stopped. +// REQUIRES s.mu is held. +func (s *Server) errorf(format string, a ...interface{}) { + if s.events != nil { + s.events.Errorf(format, a...) + } +} + +// RegisterService register a service and its implementation to the gRPC +// server. Called from the IDL generated code. This must be called before +// invoking Serve. +func (s *Server) RegisterService(sd *ServiceDesc, ss interface{}) { + ht := reflect.TypeOf(sd.HandlerType).Elem() + st := reflect.TypeOf(ss) + if !st.Implements(ht) { + grpclog.Fatalf("grpc: Server.RegisterService found the handler of type %v that does not satisfy %v", st, ht) + } + s.register(sd, ss) +} + +func (s *Server) register(sd *ServiceDesc, ss interface{}) { + s.mu.Lock() + defer s.mu.Unlock() + s.printf("RegisterService(%q)", sd.ServiceName) + if _, ok := s.m[sd.ServiceName]; ok { + grpclog.Fatalf("grpc: Server.RegisterService found duplicate service registration for %q", sd.ServiceName) + } + srv := &service{ + server: ss, + md: make(map[string]*MethodDesc), + sd: make(map[string]*StreamDesc), + mdata: sd.Metadata, + } + for i := range sd.Methods { + d := &sd.Methods[i] + srv.md[d.MethodName] = d + } + for i := range sd.Streams { + d := &sd.Streams[i] + srv.sd[d.StreamName] = d + } + s.m[sd.ServiceName] = srv +} + +// MethodInfo contains the information of an RPC including its method name and type. +type MethodInfo struct { + // Name is the method name only, without the service name or package name. + Name string + // IsClientStream indicates whether the RPC is a client streaming RPC. + IsClientStream bool + // IsServerStream indicates whether the RPC is a server streaming RPC. + IsServerStream bool +} + +// ServiceInfo contains unary RPC method info, streaming RPC methid info and metadata for a service. +type ServiceInfo struct { + Methods []MethodInfo + // Metadata is the metadata specified in ServiceDesc when registering service. + Metadata interface{} +} + +// GetServiceInfo returns a map from service names to ServiceInfo. +// Service names include the package names, in the form of .. +func (s *Server) GetServiceInfo() map[string]ServiceInfo { + ret := make(map[string]ServiceInfo) + for n, srv := range s.m { + methods := make([]MethodInfo, 0, len(srv.md)+len(srv.sd)) + for m := range srv.md { + methods = append(methods, MethodInfo{ + Name: m, + IsClientStream: false, + IsServerStream: false, + }) + } + for m, d := range srv.sd { + methods = append(methods, MethodInfo{ + Name: m, + IsClientStream: d.ClientStreams, + IsServerStream: d.ServerStreams, + }) + } + + ret[n] = ServiceInfo{ + Methods: methods, + Metadata: srv.mdata, + } + } + return ret +} + +var ( + // ErrServerStopped indicates that the operation is now illegal because of + // the server being stopped. + ErrServerStopped = errors.New("grpc: the server has been stopped") +) + +func (s *Server) useTransportAuthenticator(rawConn net.Conn) (net.Conn, credentials.AuthInfo, error) { + if s.opts.creds == nil { + return rawConn, nil, nil + } + return s.opts.creds.ServerHandshake(rawConn) +} + +// Serve accepts incoming connections on the listener lis, creating a new +// ServerTransport and service goroutine for each. The service goroutines +// read gRPC requests and then call the registered handlers to reply to them. +// Service returns when lis.Accept fails. lis will be closed when +// this method returns. +func (s *Server) Serve(lis net.Listener) error { + s.mu.Lock() + s.printf("serving") + if s.lis == nil { + s.mu.Unlock() + lis.Close() + return ErrServerStopped + } + s.lis[lis] = true + s.mu.Unlock() + defer func() { + s.mu.Lock() + if s.lis != nil && s.lis[lis] { + lis.Close() + delete(s.lis, lis) + } + s.mu.Unlock() + }() + for { + rawConn, err := lis.Accept() + if err != nil { + s.mu.Lock() + s.printf("done serving; Accept = %v", err) + s.mu.Unlock() + return err + } + // Start a new goroutine to deal with rawConn + // so we don't stall this Accept loop goroutine. + go s.handleRawConn(rawConn) + } +} + +// handleRawConn is run in its own goroutine and handles a just-accepted +// connection that has not had any I/O performed on it yet. +func (s *Server) handleRawConn(rawConn net.Conn) { + conn, authInfo, err := s.useTransportAuthenticator(rawConn) + if err != nil { + s.mu.Lock() + s.errorf("ServerHandshake(%q) failed: %v", rawConn.RemoteAddr(), err) + s.mu.Unlock() + grpclog.Printf("grpc: Server.Serve failed to complete security handshake from %q: %v", rawConn.RemoteAddr(), err) + rawConn.Close() + return + } + + s.mu.Lock() + if s.conns == nil { + s.mu.Unlock() + conn.Close() + return + } + s.mu.Unlock() + + if s.opts.useHandlerImpl { + s.serveUsingHandler(conn) + } else { + s.serveNewHTTP2Transport(conn, authInfo) + } +} + +// serveNewHTTP2Transport sets up a new http/2 transport (using the +// gRPC http2 server transport in transport/http2_server.go) and +// serves streams on it. +// This is run in its own goroutine (it does network I/O in +// transport.NewServerTransport). +func (s *Server) serveNewHTTP2Transport(c net.Conn, authInfo credentials.AuthInfo) { + st, err := transport.NewServerTransport("http2", c, s.opts.maxConcurrentStreams, authInfo) + if err != nil { + s.mu.Lock() + s.errorf("NewServerTransport(%q) failed: %v", c.RemoteAddr(), err) + s.mu.Unlock() + c.Close() + grpclog.Println("grpc: Server.Serve failed to create ServerTransport: ", err) + return + } + if !s.addConn(st) { + st.Close() + return + } + s.serveStreams(st) +} + +func (s *Server) serveStreams(st transport.ServerTransport) { + defer s.removeConn(st) + defer st.Close() + var wg sync.WaitGroup + st.HandleStreams(func(stream *transport.Stream) { + wg.Add(1) + go func() { + defer wg.Done() + s.handleStream(st, stream, s.traceInfo(st, stream)) + }() + }) + wg.Wait() +} + +var _ http.Handler = (*Server)(nil) + +// serveUsingHandler is called from handleRawConn when s is configured +// to handle requests via the http.Handler interface. It sets up a +// net/http.Server to handle the just-accepted conn. The http.Server +// is configured to route all incoming requests (all HTTP/2 streams) +// to ServeHTTP, which creates a new ServerTransport for each stream. +// serveUsingHandler blocks until conn closes. +// +// This codepath is only used when Server.TestingUseHandlerImpl has +// been configured. This lets the end2end tests exercise the ServeHTTP +// method as one of the environment types. +// +// conn is the *tls.Conn that's already been authenticated. +func (s *Server) serveUsingHandler(conn net.Conn) { + if !s.addConn(conn) { + conn.Close() + return + } + defer s.removeConn(conn) + h2s := &http2.Server{ + MaxConcurrentStreams: s.opts.maxConcurrentStreams, + } + h2s.ServeConn(conn, &http2.ServeConnOpts{ + Handler: s, + }) +} + +func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { + st, err := transport.NewServerHandlerTransport(w, r) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + if !s.addConn(st) { + st.Close() + return + } + defer s.removeConn(st) + s.serveStreams(st) +} + +// traceInfo returns a traceInfo and associates it with stream, if tracing is enabled. +// If tracing is not enabled, it returns nil. +func (s *Server) traceInfo(st transport.ServerTransport, stream *transport.Stream) (trInfo *traceInfo) { + if !EnableTracing { + return nil + } + trInfo = &traceInfo{ + tr: trace.New("grpc.Recv."+methodFamily(stream.Method()), stream.Method()), + } + trInfo.firstLine.client = false + trInfo.firstLine.remoteAddr = st.RemoteAddr() + stream.TraceContext(trInfo.tr) + if dl, ok := stream.Context().Deadline(); ok { + trInfo.firstLine.deadline = dl.Sub(time.Now()) + } + return trInfo +} + +func (s *Server) addConn(c io.Closer) bool { + s.mu.Lock() + defer s.mu.Unlock() + if s.conns == nil || s.drain { + return false + } + s.conns[c] = true + return true +} + +func (s *Server) removeConn(c io.Closer) { + s.mu.Lock() + defer s.mu.Unlock() + if s.conns != nil { + delete(s.conns, c) + s.cv.Signal() + } +} + +func (s *Server) sendResponse(t transport.ServerTransport, stream *transport.Stream, msg interface{}, cp Compressor, opts *transport.Options) error { + var cbuf *bytes.Buffer + if cp != nil { + cbuf = new(bytes.Buffer) + } + p, err := encode(s.opts.codec, msg, cp, cbuf) + if err != nil { + // This typically indicates a fatal issue (e.g., memory + // corruption or hardware faults) the application program + // cannot handle. + // + // TODO(zhaoq): There exist other options also such as only closing the + // faulty stream locally and remotely (Other streams can keep going). Find + // the optimal option. + grpclog.Fatalf("grpc: Server failed to encode response %v", err) + } + return t.Write(stream, p, opts) +} + +func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.Stream, srv *service, md *MethodDesc, trInfo *traceInfo) (err error) { + if trInfo != nil { + defer trInfo.tr.Finish() + trInfo.firstLine.client = false + trInfo.tr.LazyLog(&trInfo.firstLine, false) + defer func() { + if err != nil && err != io.EOF { + trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true) + trInfo.tr.SetError() + } + }() + } + if s.opts.cp != nil { + // NOTE: this needs to be ahead of all handling, https://github.com/grpc/grpc-go/issues/686. + stream.SetSendCompress(s.opts.cp.Type()) + } + p := &parser{r: stream} + for { + pf, req, err := p.recvMsg(s.opts.maxMsgSize) + if err == io.EOF { + // The entire stream is done (for unary RPC only). + return err + } + if err == io.ErrUnexpectedEOF { + err = transport.StreamError{Code: codes.Internal, Desc: "io.ErrUnexpectedEOF"} + } + if err != nil { + switch err := err.(type) { + case *rpcError: + if err := t.WriteStatus(stream, err.code, err.desc); err != nil { + grpclog.Printf("grpc: Server.processUnaryRPC failed to write status %v", err) + } + case transport.ConnectionError: + // Nothing to do here. + case transport.StreamError: + if err := t.WriteStatus(stream, err.Code, err.Desc); err != nil { + grpclog.Printf("grpc: Server.processUnaryRPC failed to write status %v", err) + } + default: + panic(fmt.Sprintf("grpc: Unexpected error (%T) from recvMsg: %v", err, err)) + } + return err + } + + if err := checkRecvPayload(pf, stream.RecvCompress(), s.opts.dc); err != nil { + switch err := err.(type) { + case transport.StreamError: + if err := t.WriteStatus(stream, err.Code, err.Desc); err != nil { + grpclog.Printf("grpc: Server.processUnaryRPC failed to write status %v", err) + } + default: + if err := t.WriteStatus(stream, codes.Internal, err.Error()); err != nil { + grpclog.Printf("grpc: Server.processUnaryRPC failed to write status %v", err) + } + + } + return err + } + statusCode := codes.OK + statusDesc := "" + df := func(v interface{}) error { + if pf == compressionMade { + var err error + req, err = s.opts.dc.Do(bytes.NewReader(req)) + if err != nil { + if err := t.WriteStatus(stream, codes.Internal, err.Error()); err != nil { + grpclog.Printf("grpc: Server.processUnaryRPC failed to write status %v", err) + } + return err + } + } + if len(req) > s.opts.maxMsgSize { + // TODO: Revisit the error code. Currently keep it consistent with + // java implementation. + statusCode = codes.Internal + statusDesc = fmt.Sprintf("grpc: server received a message of %d bytes exceeding %d limit", len(req), s.opts.maxMsgSize) + } + if err := s.opts.codec.Unmarshal(req, v); err != nil { + return err + } + if trInfo != nil { + trInfo.tr.LazyLog(&payload{sent: false, msg: v}, true) + } + return nil + } + reply, appErr := md.Handler(srv.server, stream.Context(), df, s.opts.unaryInt) + if appErr != nil { + if err, ok := appErr.(*rpcError); ok { + statusCode = err.code + statusDesc = err.desc + } else { + statusCode = convertCode(appErr) + statusDesc = appErr.Error() + } + if trInfo != nil && statusCode != codes.OK { + trInfo.tr.LazyLog(stringer(statusDesc), true) + trInfo.tr.SetError() + } + if err := t.WriteStatus(stream, statusCode, statusDesc); err != nil { + grpclog.Printf("grpc: Server.processUnaryRPC failed to write status: %v", err) + return err + } + return nil + } + if trInfo != nil { + trInfo.tr.LazyLog(stringer("OK"), false) + } + opts := &transport.Options{ + Last: true, + Delay: false, + } + if err := s.sendResponse(t, stream, reply, s.opts.cp, opts); err != nil { + switch err := err.(type) { + case transport.ConnectionError: + // Nothing to do here. + case transport.StreamError: + statusCode = err.Code + statusDesc = err.Desc + default: + statusCode = codes.Unknown + statusDesc = err.Error() + } + return err + } + if trInfo != nil { + trInfo.tr.LazyLog(&payload{sent: true, msg: reply}, true) + } + return t.WriteStatus(stream, statusCode, statusDesc) + } +} + +func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transport.Stream, srv *service, sd *StreamDesc, trInfo *traceInfo) (err error) { + if s.opts.cp != nil { + stream.SetSendCompress(s.opts.cp.Type()) + } + ss := &serverStream{ + t: t, + s: stream, + p: &parser{r: stream}, + codec: s.opts.codec, + cp: s.opts.cp, + dc: s.opts.dc, + maxMsgSize: s.opts.maxMsgSize, + trInfo: trInfo, + } + if ss.cp != nil { + ss.cbuf = new(bytes.Buffer) + } + if trInfo != nil { + trInfo.tr.LazyLog(&trInfo.firstLine, false) + defer func() { + ss.mu.Lock() + if err != nil && err != io.EOF { + ss.trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true) + ss.trInfo.tr.SetError() + } + ss.trInfo.tr.Finish() + ss.trInfo.tr = nil + ss.mu.Unlock() + }() + } + var appErr error + if s.opts.streamInt == nil { + appErr = sd.Handler(srv.server, ss) + } else { + info := &StreamServerInfo{ + FullMethod: stream.Method(), + IsClientStream: sd.ClientStreams, + IsServerStream: sd.ServerStreams, + } + appErr = s.opts.streamInt(srv.server, ss, info, sd.Handler) + } + if appErr != nil { + if err, ok := appErr.(*rpcError); ok { + ss.statusCode = err.code + ss.statusDesc = err.desc + } else if err, ok := appErr.(transport.StreamError); ok { + ss.statusCode = err.Code + ss.statusDesc = err.Desc + } else { + ss.statusCode = convertCode(appErr) + ss.statusDesc = appErr.Error() + } + } + if trInfo != nil { + ss.mu.Lock() + if ss.statusCode != codes.OK { + ss.trInfo.tr.LazyLog(stringer(ss.statusDesc), true) + ss.trInfo.tr.SetError() + } else { + ss.trInfo.tr.LazyLog(stringer("OK"), false) + } + ss.mu.Unlock() + } + return t.WriteStatus(ss.s, ss.statusCode, ss.statusDesc) + +} + +func (s *Server) handleStream(t transport.ServerTransport, stream *transport.Stream, trInfo *traceInfo) { + sm := stream.Method() + if sm != "" && sm[0] == '/' { + sm = sm[1:] + } + pos := strings.LastIndex(sm, "/") + if pos == -1 { + if trInfo != nil { + trInfo.tr.LazyLog(&fmtStringer{"Malformed method name %q", []interface{}{sm}}, true) + trInfo.tr.SetError() + } + if err := t.WriteStatus(stream, codes.InvalidArgument, fmt.Sprintf("malformed method name: %q", stream.Method())); err != nil { + if trInfo != nil { + trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true) + trInfo.tr.SetError() + } + grpclog.Printf("grpc: Server.handleStream failed to write status: %v", err) + } + if trInfo != nil { + trInfo.tr.Finish() + } + return + } + service := sm[:pos] + method := sm[pos+1:] + srv, ok := s.m[service] + if !ok { + if trInfo != nil { + trInfo.tr.LazyLog(&fmtStringer{"Unknown service %v", []interface{}{service}}, true) + trInfo.tr.SetError() + } + if err := t.WriteStatus(stream, codes.Unimplemented, fmt.Sprintf("unknown service %v", service)); err != nil { + if trInfo != nil { + trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true) + trInfo.tr.SetError() + } + grpclog.Printf("grpc: Server.handleStream failed to write status: %v", err) + } + if trInfo != nil { + trInfo.tr.Finish() + } + return + } + // Unary RPC or Streaming RPC? + if md, ok := srv.md[method]; ok { + s.processUnaryRPC(t, stream, srv, md, trInfo) + return + } + if sd, ok := srv.sd[method]; ok { + s.processStreamingRPC(t, stream, srv, sd, trInfo) + return + } + if trInfo != nil { + trInfo.tr.LazyLog(&fmtStringer{"Unknown method %v", []interface{}{method}}, true) + trInfo.tr.SetError() + } + if err := t.WriteStatus(stream, codes.Unimplemented, fmt.Sprintf("unknown method %v", method)); err != nil { + if trInfo != nil { + trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true) + trInfo.tr.SetError() + } + grpclog.Printf("grpc: Server.handleStream failed to write status: %v", err) + } + if trInfo != nil { + trInfo.tr.Finish() + } +} + +// Stop stops the gRPC server. It immediately closes all open +// connections and listeners. +// It cancels all active RPCs on the server side and the corresponding +// pending RPCs on the client side will get notified by connection +// errors. +func (s *Server) Stop() { + s.mu.Lock() + listeners := s.lis + s.lis = nil + st := s.conns + s.conns = nil + // interrupt GracefulStop if Stop and GracefulStop are called concurrently. + s.cv.Signal() + s.mu.Unlock() + + for lis := range listeners { + lis.Close() + } + for c := range st { + c.Close() + } + + s.mu.Lock() + if s.events != nil { + s.events.Finish() + s.events = nil + } + s.mu.Unlock() +} + +// GracefulStop stops the gRPC server gracefully. It stops the server to accept new +// connections and RPCs and blocks until all the pending RPCs are finished. +func (s *Server) GracefulStop() { + s.mu.Lock() + defer s.mu.Unlock() + if s.drain == true || s.conns == nil { + return + } + s.drain = true + for lis := range s.lis { + lis.Close() + } + s.lis = nil + for c := range s.conns { + c.(transport.ServerTransport).Drain() + } + for len(s.conns) != 0 { + s.cv.Wait() + } + s.conns = nil + if s.events != nil { + s.events.Finish() + s.events = nil + } +} + +func init() { + internal.TestingCloseConns = func(arg interface{}) { + arg.(*Server).testingCloseConns() + } + internal.TestingUseHandlerImpl = func(arg interface{}) { + arg.(*Server).opts.useHandlerImpl = true + } +} + +// testingCloseConns closes all existing transports but keeps s.lis +// accepting new connections. +func (s *Server) testingCloseConns() { + s.mu.Lock() + for c := range s.conns { + c.Close() + delete(s.conns, c) + } + s.mu.Unlock() +} + +// SendHeader sends header metadata. It may be called at most once from a unary +// RPC handler. The ctx is the RPC handler's Context or one derived from it. +func SendHeader(ctx context.Context, md metadata.MD) error { + if md.Len() == 0 { + return nil + } + stream, ok := transport.StreamFromContext(ctx) + if !ok { + return fmt.Errorf("grpc: failed to fetch the stream from the context %v", ctx) + } + t := stream.ServerTransport() + if t == nil { + grpclog.Fatalf("grpc: SendHeader: %v has no ServerTransport to send header metadata.", stream) + } + return t.WriteHeader(stream, md) +} + +// SetTrailer sets the trailer metadata that will be sent when an RPC returns. +// It may be called at most once from a unary RPC handler. The ctx is the RPC +// handler's Context or one derived from it. +func SetTrailer(ctx context.Context, md metadata.MD) error { + if md.Len() == 0 { + return nil + } + stream, ok := transport.StreamFromContext(ctx) + if !ok { + return fmt.Errorf("grpc: failed to fetch the stream from the context %v", ctx) + } + return stream.SetTrailer(md) +} diff --git a/vendor/google.golang.org/grpc/stream.go b/vendor/google.golang.org/grpc/stream.go new file mode 100644 index 00000000..51df3f01 --- /dev/null +++ b/vendor/google.golang.org/grpc/stream.go @@ -0,0 +1,493 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package grpc + +import ( + "bytes" + "errors" + "io" + "math" + "sync" + "time" + + "golang.org/x/net/context" + "golang.org/x/net/trace" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/transport" +) + +// StreamHandler defines the handler called by gRPC server to complete the +// execution of a streaming RPC. +type StreamHandler func(srv interface{}, stream ServerStream) error + +// StreamDesc represents a streaming RPC service's method specification. +type StreamDesc struct { + StreamName string + Handler StreamHandler + + // At least one of these is true. + ServerStreams bool + ClientStreams bool +} + +// Stream defines the common interface a client or server stream has to satisfy. +type Stream interface { + // Context returns the context for this stream. + Context() context.Context + // SendMsg blocks until it sends m, the stream is done or the stream + // breaks. + // On error, it aborts the stream and returns an RPC status on client + // side. On server side, it simply returns the error to the caller. + // SendMsg is called by generated code. Also Users can call SendMsg + // directly when it is really needed in their use cases. + SendMsg(m interface{}) error + // RecvMsg blocks until it receives a message or the stream is + // done. On client side, it returns io.EOF when the stream is done. On + // any other error, it aborts the stream and returns an RPC status. On + // server side, it simply returns the error to the caller. + RecvMsg(m interface{}) error +} + +// ClientStream defines the interface a client stream has to satisfy. +type ClientStream interface { + // Header returns the header metadata received from the server if there + // is any. It blocks if the metadata is not ready to read. + Header() (metadata.MD, error) + // Trailer returns the trailer metadata from the server, if there is any. + // It must only be called after stream.CloseAndRecv has returned, or + // stream.Recv has returned a non-nil error (including io.EOF). + Trailer() metadata.MD + // CloseSend closes the send direction of the stream. It closes the stream + // when non-nil error is met. + CloseSend() error + Stream +} + +// NewClientStream creates a new Stream for the client side. This is called +// by generated code. +func NewClientStream(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption) (_ ClientStream, err error) { + var ( + t transport.ClientTransport + s *transport.Stream + put func() + ) + c := defaultCallInfo + for _, o := range opts { + if err := o.before(&c); err != nil { + return nil, toRPCErr(err) + } + } + callHdr := &transport.CallHdr{ + Host: cc.authority, + Method: method, + Flush: desc.ServerStreams && desc.ClientStreams, + } + if cc.dopts.cp != nil { + callHdr.SendCompress = cc.dopts.cp.Type() + } + var trInfo traceInfo + if EnableTracing { + trInfo.tr = trace.New("grpc.Sent."+methodFamily(method), method) + trInfo.firstLine.client = true + if deadline, ok := ctx.Deadline(); ok { + trInfo.firstLine.deadline = deadline.Sub(time.Now()) + } + trInfo.tr.LazyLog(&trInfo.firstLine, false) + ctx = trace.NewContext(ctx, trInfo.tr) + defer func() { + if err != nil { + // Need to call tr.finish() if error is returned. + // Because tr will not be returned to caller. + trInfo.tr.LazyPrintf("RPC: [%v]", err) + trInfo.tr.SetError() + trInfo.tr.Finish() + } + }() + } + gopts := BalancerGetOptions{ + BlockingWait: !c.failFast, + } + for { + t, put, err = cc.getTransport(ctx, gopts) + if err != nil { + // TODO(zhaoq): Probably revisit the error handling. + if _, ok := err.(*rpcError); ok { + return nil, err + } + if err == errConnClosing || err == errConnUnavailable { + if c.failFast { + return nil, Errorf(codes.Unavailable, "%v", err) + } + continue + } + // All the other errors are treated as Internal errors. + return nil, Errorf(codes.Internal, "%v", err) + } + + s, err = t.NewStream(ctx, callHdr) + if err != nil { + if put != nil { + put() + put = nil + } + if _, ok := err.(transport.ConnectionError); ok || err == transport.ErrStreamDrain { + if c.failFast { + return nil, toRPCErr(err) + } + continue + } + return nil, toRPCErr(err) + } + break + } + cs := &clientStream{ + opts: opts, + c: c, + desc: desc, + codec: cc.dopts.codec, + cp: cc.dopts.cp, + dc: cc.dopts.dc, + + put: put, + t: t, + s: s, + p: &parser{r: s}, + + tracing: EnableTracing, + trInfo: trInfo, + } + if cc.dopts.cp != nil { + cs.cbuf = new(bytes.Buffer) + } + // Listen on ctx.Done() to detect cancellation and s.Done() to detect normal termination + // when there is no pending I/O operations on this stream. + go func() { + select { + case <-t.Error(): + // Incur transport error, simply exit. + case <-s.Done(): + // TODO: The trace of the RPC is terminated here when there is no pending + // I/O, which is probably not the optimal solution. + if s.StatusCode() == codes.OK { + cs.finish(nil) + } else { + cs.finish(Errorf(s.StatusCode(), "%s", s.StatusDesc())) + } + cs.closeTransportStream(nil) + case <-s.GoAway(): + cs.finish(errConnDrain) + cs.closeTransportStream(errConnDrain) + case <-s.Context().Done(): + err := s.Context().Err() + cs.finish(err) + cs.closeTransportStream(transport.ContextErr(err)) + } + }() + return cs, nil +} + +// clientStream implements a client side Stream. +type clientStream struct { + opts []CallOption + c callInfo + t transport.ClientTransport + s *transport.Stream + p *parser + desc *StreamDesc + codec Codec + cp Compressor + cbuf *bytes.Buffer + dc Decompressor + + tracing bool // set to EnableTracing when the clientStream is created. + + mu sync.Mutex + put func() + closed bool + // trInfo.tr is set when the clientStream is created (if EnableTracing is true), + // and is set to nil when the clientStream's finish method is called. + trInfo traceInfo +} + +func (cs *clientStream) Context() context.Context { + return cs.s.Context() +} + +func (cs *clientStream) Header() (metadata.MD, error) { + m, err := cs.s.Header() + if err != nil { + if _, ok := err.(transport.ConnectionError); !ok { + cs.closeTransportStream(err) + } + } + return m, err +} + +func (cs *clientStream) Trailer() metadata.MD { + return cs.s.Trailer() +} + +func (cs *clientStream) SendMsg(m interface{}) (err error) { + if cs.tracing { + cs.mu.Lock() + if cs.trInfo.tr != nil { + cs.trInfo.tr.LazyLog(&payload{sent: true, msg: m}, true) + } + cs.mu.Unlock() + } + defer func() { + if err != nil { + cs.finish(err) + } + if err == nil { + return + } + if err == io.EOF { + // Specialize the process for server streaming. SendMesg is only called + // once when creating the stream object. io.EOF needs to be skipped when + // the rpc is early finished (before the stream object is created.). + // TODO: It is probably better to move this into the generated code. + if !cs.desc.ClientStreams && cs.desc.ServerStreams { + err = nil + } + return + } + if _, ok := err.(transport.ConnectionError); !ok { + cs.closeTransportStream(err) + } + err = toRPCErr(err) + }() + out, err := encode(cs.codec, m, cs.cp, cs.cbuf) + defer func() { + if cs.cbuf != nil { + cs.cbuf.Reset() + } + }() + if err != nil { + return transport.StreamErrorf(codes.Internal, "grpc: %v", err) + } + return cs.t.Write(cs.s, out, &transport.Options{Last: false}) +} + +func (cs *clientStream) RecvMsg(m interface{}) (err error) { + err = recv(cs.p, cs.codec, cs.s, cs.dc, m, math.MaxInt32) + defer func() { + // err != nil indicates the termination of the stream. + if err != nil { + cs.finish(err) + } + }() + if err == nil { + if cs.tracing { + cs.mu.Lock() + if cs.trInfo.tr != nil { + cs.trInfo.tr.LazyLog(&payload{sent: false, msg: m}, true) + } + cs.mu.Unlock() + } + if !cs.desc.ClientStreams || cs.desc.ServerStreams { + return + } + // Special handling for client streaming rpc. + err = recv(cs.p, cs.codec, cs.s, cs.dc, m, math.MaxInt32) + cs.closeTransportStream(err) + if err == nil { + return toRPCErr(errors.New("grpc: client streaming protocol violation: get , want ")) + } + if err == io.EOF { + if cs.s.StatusCode() == codes.OK { + cs.finish(err) + return nil + } + return Errorf(cs.s.StatusCode(), "%s", cs.s.StatusDesc()) + } + return toRPCErr(err) + } + if _, ok := err.(transport.ConnectionError); !ok { + cs.closeTransportStream(err) + } + if err == io.EOF { + if cs.s.StatusCode() == codes.OK { + // Returns io.EOF to indicate the end of the stream. + return + } + return Errorf(cs.s.StatusCode(), "%s", cs.s.StatusDesc()) + } + return toRPCErr(err) +} + +func (cs *clientStream) CloseSend() (err error) { + err = cs.t.Write(cs.s, nil, &transport.Options{Last: true}) + defer func() { + if err != nil { + cs.finish(err) + } + }() + if err == nil || err == io.EOF { + return nil + } + if _, ok := err.(transport.ConnectionError); !ok { + cs.closeTransportStream(err) + } + err = toRPCErr(err) + return +} + +func (cs *clientStream) closeTransportStream(err error) { + cs.mu.Lock() + if cs.closed { + cs.mu.Unlock() + return + } + cs.closed = true + cs.mu.Unlock() + cs.t.CloseStream(cs.s, err) +} + +func (cs *clientStream) finish(err error) { + cs.mu.Lock() + defer cs.mu.Unlock() + for _, o := range cs.opts { + o.after(&cs.c) + } + if cs.put != nil { + cs.put() + cs.put = nil + } + if !cs.tracing { + return + } + if cs.trInfo.tr != nil { + if err == nil || err == io.EOF { + cs.trInfo.tr.LazyPrintf("RPC: [OK]") + } else { + cs.trInfo.tr.LazyPrintf("RPC: [%v]", err) + cs.trInfo.tr.SetError() + } + cs.trInfo.tr.Finish() + cs.trInfo.tr = nil + } +} + +// ServerStream defines the interface a server stream has to satisfy. +type ServerStream interface { + // SendHeader sends the header metadata. It should not be called + // after SendProto. It fails if called multiple times or if + // called after SendProto. + SendHeader(metadata.MD) error + // SetTrailer sets the trailer metadata which will be sent with the + // RPC status. + SetTrailer(metadata.MD) + Stream +} + +// serverStream implements a server side Stream. +type serverStream struct { + t transport.ServerTransport + s *transport.Stream + p *parser + codec Codec + cp Compressor + dc Decompressor + cbuf *bytes.Buffer + maxMsgSize int + statusCode codes.Code + statusDesc string + trInfo *traceInfo + + mu sync.Mutex // protects trInfo.tr after the service handler runs. +} + +func (ss *serverStream) Context() context.Context { + return ss.s.Context() +} + +func (ss *serverStream) SendHeader(md metadata.MD) error { + return ss.t.WriteHeader(ss.s, md) +} + +func (ss *serverStream) SetTrailer(md metadata.MD) { + if md.Len() == 0 { + return + } + ss.s.SetTrailer(md) + return +} + +func (ss *serverStream) SendMsg(m interface{}) (err error) { + defer func() { + if ss.trInfo != nil { + ss.mu.Lock() + if ss.trInfo.tr != nil { + if err == nil { + ss.trInfo.tr.LazyLog(&payload{sent: true, msg: m}, true) + } else { + ss.trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true) + ss.trInfo.tr.SetError() + } + } + ss.mu.Unlock() + } + }() + out, err := encode(ss.codec, m, ss.cp, ss.cbuf) + defer func() { + if ss.cbuf != nil { + ss.cbuf.Reset() + } + }() + if err != nil { + err = transport.StreamErrorf(codes.Internal, "grpc: %v", err) + return err + } + return ss.t.Write(ss.s, out, &transport.Options{Last: false}) +} + +func (ss *serverStream) RecvMsg(m interface{}) (err error) { + defer func() { + if ss.trInfo != nil { + ss.mu.Lock() + if ss.trInfo.tr != nil { + if err == nil { + ss.trInfo.tr.LazyLog(&payload{sent: false, msg: m}, true) + } else if err != io.EOF { + ss.trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true) + ss.trInfo.tr.SetError() + } + } + ss.mu.Unlock() + } + }() + return recv(ss.p, ss.codec, ss.s, ss.dc, m, ss.maxMsgSize) +} diff --git a/vendor/google.golang.org/grpc/trace.go b/vendor/google.golang.org/grpc/trace.go new file mode 100644 index 00000000..f6747e1d --- /dev/null +++ b/vendor/google.golang.org/grpc/trace.go @@ -0,0 +1,119 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package grpc + +import ( + "bytes" + "fmt" + "io" + "net" + "strings" + "time" + + "golang.org/x/net/trace" +) + +// EnableTracing controls whether to trace RPCs using the golang.org/x/net/trace package. +// This should only be set before any RPCs are sent or received by this program. +var EnableTracing = true + +// methodFamily returns the trace family for the given method. +// It turns "/pkg.Service/GetFoo" into "pkg.Service". +func methodFamily(m string) string { + m = strings.TrimPrefix(m, "/") // remove leading slash + if i := strings.Index(m, "/"); i >= 0 { + m = m[:i] // remove everything from second slash + } + if i := strings.LastIndex(m, "."); i >= 0 { + m = m[i+1:] // cut down to last dotted component + } + return m +} + +// traceInfo contains tracing information for an RPC. +type traceInfo struct { + tr trace.Trace + firstLine firstLine +} + +// firstLine is the first line of an RPC trace. +type firstLine struct { + client bool // whether this is a client (outgoing) RPC + remoteAddr net.Addr + deadline time.Duration // may be zero +} + +func (f *firstLine) String() string { + var line bytes.Buffer + io.WriteString(&line, "RPC: ") + if f.client { + io.WriteString(&line, "to") + } else { + io.WriteString(&line, "from") + } + fmt.Fprintf(&line, " %v deadline:", f.remoteAddr) + if f.deadline != 0 { + fmt.Fprint(&line, f.deadline) + } else { + io.WriteString(&line, "none") + } + return line.String() +} + +// payload represents an RPC request or response payload. +type payload struct { + sent bool // whether this is an outgoing payload + msg interface{} // e.g. a proto.Message + // TODO(dsymonds): add stringifying info to codec, and limit how much we hold here? +} + +func (p payload) String() string { + if p.sent { + return fmt.Sprintf("sent: %v", p.msg) + } + return fmt.Sprintf("recv: %v", p.msg) +} + +type fmtStringer struct { + format string + a []interface{} +} + +func (f *fmtStringer) String() string { + return fmt.Sprintf(f.format, f.a...) +} + +type stringer string + +func (s stringer) String() string { return string(s) } diff --git a/vendor/google.golang.org/grpc/transport/control.go b/vendor/google.golang.org/grpc/transport/control.go new file mode 100644 index 00000000..4ef0830b --- /dev/null +++ b/vendor/google.golang.org/grpc/transport/control.go @@ -0,0 +1,215 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package transport + +import ( + "fmt" + "sync" + + "golang.org/x/net/http2" +) + +const ( + // The default value of flow control window size in HTTP2 spec. + defaultWindowSize = 65535 + // The initial window size for flow control. + initialWindowSize = defaultWindowSize // for an RPC + initialConnWindowSize = defaultWindowSize * 16 // for a connection +) + +// The following defines various control items which could flow through +// the control buffer of transport. They represent different aspects of +// control tasks, e.g., flow control, settings, streaming resetting, etc. +type windowUpdate struct { + streamID uint32 + increment uint32 +} + +func (*windowUpdate) item() {} + +type settings struct { + ack bool + ss []http2.Setting +} + +func (*settings) item() {} + +type resetStream struct { + streamID uint32 + code http2.ErrCode +} + +func (*resetStream) item() {} + +type goAway struct { +} + +func (*goAway) item() {} + +type flushIO struct { +} + +func (*flushIO) item() {} + +type ping struct { + ack bool + data [8]byte +} + +func (*ping) item() {} + +// quotaPool is a pool which accumulates the quota and sends it to acquire() +// when it is available. +type quotaPool struct { + c chan int + + mu sync.Mutex + quota int +} + +// newQuotaPool creates a quotaPool which has quota q available to consume. +func newQuotaPool(q int) *quotaPool { + qb := "aPool{ + c: make(chan int, 1), + } + if q > 0 { + qb.c <- q + } else { + qb.quota = q + } + return qb +} + +// add adds n to the available quota and tries to send it on acquire. +func (qb *quotaPool) add(n int) { + qb.mu.Lock() + defer qb.mu.Unlock() + qb.quota += n + if qb.quota <= 0 { + return + } + select { + case qb.c <- qb.quota: + qb.quota = 0 + default: + } +} + +// cancel cancels the pending quota sent on acquire, if any. +func (qb *quotaPool) cancel() { + qb.mu.Lock() + defer qb.mu.Unlock() + select { + case n := <-qb.c: + qb.quota += n + default: + } +} + +// reset cancels the pending quota sent on acquired, incremented by v and sends +// it back on acquire. +func (qb *quotaPool) reset(v int) { + qb.mu.Lock() + defer qb.mu.Unlock() + select { + case n := <-qb.c: + qb.quota += n + default: + } + qb.quota += v + if qb.quota <= 0 { + return + } + select { + case qb.c <- qb.quota: + qb.quota = 0 + default: + } +} + +// acquire returns the channel on which available quota amounts are sent. +func (qb *quotaPool) acquire() <-chan int { + return qb.c +} + +// inFlow deals with inbound flow control +type inFlow struct { + // The inbound flow control limit for pending data. + limit uint32 + + mu sync.Mutex + // pendingData is the overall data which have been received but not been + // consumed by applications. + pendingData uint32 + // The amount of data the application has consumed but grpc has not sent + // window update for them. Used to reduce window update frequency. + pendingUpdate uint32 +} + +// onData is invoked when some data frame is received. It updates pendingData. +func (f *inFlow) onData(n uint32) error { + f.mu.Lock() + defer f.mu.Unlock() + f.pendingData += n + if f.pendingData+f.pendingUpdate > f.limit { + return fmt.Errorf("received %d-bytes data exceeding the limit %d bytes", f.pendingData+f.pendingUpdate, f.limit) + } + return nil +} + +// onRead is invoked when the application reads the data. It returns the window size +// to be sent to the peer. +func (f *inFlow) onRead(n uint32) uint32 { + f.mu.Lock() + defer f.mu.Unlock() + if f.pendingData == 0 { + return 0 + } + f.pendingData -= n + f.pendingUpdate += n + if f.pendingUpdate >= f.limit/4 { + wu := f.pendingUpdate + f.pendingUpdate = 0 + return wu + } + return 0 +} + +func (f *inFlow) resetPendingData() uint32 { + f.mu.Lock() + defer f.mu.Unlock() + n := f.pendingData + f.pendingData = 0 + return n +} diff --git a/vendor/google.golang.org/grpc/transport/go16.go b/vendor/google.golang.org/grpc/transport/go16.go new file mode 100644 index 00000000..ee1c46ba --- /dev/null +++ b/vendor/google.golang.org/grpc/transport/go16.go @@ -0,0 +1,46 @@ +// +build go1.6,!go1.7 + +/* + * Copyright 2016, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package transport + +import ( + "net" + + "golang.org/x/net/context" +) + +// dialContext connects to the address on the named network. +func dialContext(ctx context.Context, network, address string) (net.Conn, error) { + return (&net.Dialer{Cancel: ctx.Done()}).Dial(network, address) +} diff --git a/vendor/google.golang.org/grpc/transport/go17.go b/vendor/google.golang.org/grpc/transport/go17.go new file mode 100644 index 00000000..356f13ff --- /dev/null +++ b/vendor/google.golang.org/grpc/transport/go17.go @@ -0,0 +1,46 @@ +// +build go1.7 + +/* + * Copyright 2016, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package transport + +import ( + "net" + + "golang.org/x/net/context" +) + +// dialContext connects to the address on the named network. +func dialContext(ctx context.Context, network, address string) (net.Conn, error) { + return (&net.Dialer{}).DialContext(ctx, network, address) +} diff --git a/vendor/google.golang.org/grpc/transport/handler_server.go b/vendor/google.golang.org/grpc/transport/handler_server.go new file mode 100644 index 00000000..30e21ac0 --- /dev/null +++ b/vendor/google.golang.org/grpc/transport/handler_server.go @@ -0,0 +1,397 @@ +/* + * Copyright 2016, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +// This file is the implementation of a gRPC server using HTTP/2 which +// uses the standard Go http2 Server implementation (via the +// http.Handler interface), rather than speaking low-level HTTP/2 +// frames itself. It is the implementation of *grpc.Server.ServeHTTP. + +package transport + +import ( + "errors" + "fmt" + "io" + "net" + "net/http" + "strings" + "sync" + "time" + + "golang.org/x/net/context" + "golang.org/x/net/http2" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/credentials" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/peer" +) + +// NewServerHandlerTransport returns a ServerTransport handling gRPC +// from inside an http.Handler. It requires that the http Server +// supports HTTP/2. +func NewServerHandlerTransport(w http.ResponseWriter, r *http.Request) (ServerTransport, error) { + if r.ProtoMajor != 2 { + return nil, errors.New("gRPC requires HTTP/2") + } + if r.Method != "POST" { + return nil, errors.New("invalid gRPC request method") + } + if !validContentType(r.Header.Get("Content-Type")) { + return nil, errors.New("invalid gRPC request content-type") + } + if _, ok := w.(http.Flusher); !ok { + return nil, errors.New("gRPC requires a ResponseWriter supporting http.Flusher") + } + if _, ok := w.(http.CloseNotifier); !ok { + return nil, errors.New("gRPC requires a ResponseWriter supporting http.CloseNotifier") + } + + st := &serverHandlerTransport{ + rw: w, + req: r, + closedCh: make(chan struct{}), + writes: make(chan func()), + } + + if v := r.Header.Get("grpc-timeout"); v != "" { + to, err := decodeTimeout(v) + if err != nil { + return nil, StreamErrorf(codes.Internal, "malformed time-out: %v", err) + } + st.timeoutSet = true + st.timeout = to + } + + var metakv []string + if r.Host != "" { + metakv = append(metakv, ":authority", r.Host) + } + for k, vv := range r.Header { + k = strings.ToLower(k) + if isReservedHeader(k) && !isWhitelistedPseudoHeader(k) { + continue + } + for _, v := range vv { + if k == "user-agent" { + // user-agent is special. Copying logic of http_util.go. + if i := strings.LastIndex(v, " "); i == -1 { + // There is no application user agent string being set + continue + } else { + v = v[:i] + } + } + metakv = append(metakv, k, v) + } + } + st.headerMD = metadata.Pairs(metakv...) + + return st, nil +} + +// serverHandlerTransport is an implementation of ServerTransport +// which replies to exactly one gRPC request (exactly one HTTP request), +// using the net/http.Handler interface. This http.Handler is guaranteed +// at this point to be speaking over HTTP/2, so it's able to speak valid +// gRPC. +type serverHandlerTransport struct { + rw http.ResponseWriter + req *http.Request + timeoutSet bool + timeout time.Duration + didCommonHeaders bool + + headerMD metadata.MD + + closeOnce sync.Once + closedCh chan struct{} // closed on Close + + // writes is a channel of code to run serialized in the + // ServeHTTP (HandleStreams) goroutine. The channel is closed + // when WriteStatus is called. + writes chan func() +} + +func (ht *serverHandlerTransport) Close() error { + ht.closeOnce.Do(ht.closeCloseChanOnce) + return nil +} + +func (ht *serverHandlerTransport) closeCloseChanOnce() { close(ht.closedCh) } + +func (ht *serverHandlerTransport) RemoteAddr() net.Addr { return strAddr(ht.req.RemoteAddr) } + +// strAddr is a net.Addr backed by either a TCP "ip:port" string, or +// the empty string if unknown. +type strAddr string + +func (a strAddr) Network() string { + if a != "" { + // Per the documentation on net/http.Request.RemoteAddr, if this is + // set, it's set to the IP:port of the peer (hence, TCP): + // https://golang.org/pkg/net/http/#Request + // + // If we want to support Unix sockets later, we can + // add our own grpc-specific convention within the + // grpc codebase to set RemoteAddr to a different + // format, or probably better: we can attach it to the + // context and use that from serverHandlerTransport.RemoteAddr. + return "tcp" + } + return "" +} + +func (a strAddr) String() string { return string(a) } + +// do runs fn in the ServeHTTP goroutine. +func (ht *serverHandlerTransport) do(fn func()) error { + select { + case ht.writes <- fn: + return nil + case <-ht.closedCh: + return ErrConnClosing + } +} + +func (ht *serverHandlerTransport) WriteStatus(s *Stream, statusCode codes.Code, statusDesc string) error { + err := ht.do(func() { + ht.writeCommonHeaders(s) + + // And flush, in case no header or body has been sent yet. + // This forces a separation of headers and trailers if this is the + // first call (for example, in end2end tests's TestNoService). + ht.rw.(http.Flusher).Flush() + + h := ht.rw.Header() + h.Set("Grpc-Status", fmt.Sprintf("%d", statusCode)) + if statusDesc != "" { + h.Set("Grpc-Message", encodeGrpcMessage(statusDesc)) + } + if md := s.Trailer(); len(md) > 0 { + for k, vv := range md { + // Clients don't tolerate reading restricted headers after some non restricted ones were sent. + if isReservedHeader(k) { + continue + } + for _, v := range vv { + // http2 ResponseWriter mechanism to + // send undeclared Trailers after the + // headers have possibly been written. + h.Add(http2.TrailerPrefix+k, v) + } + } + } + }) + close(ht.writes) + return err +} + +// writeCommonHeaders sets common headers on the first write +// call (Write, WriteHeader, or WriteStatus). +func (ht *serverHandlerTransport) writeCommonHeaders(s *Stream) { + if ht.didCommonHeaders { + return + } + ht.didCommonHeaders = true + + h := ht.rw.Header() + h["Date"] = nil // suppress Date to make tests happy; TODO: restore + h.Set("Content-Type", "application/grpc") + + // Predeclare trailers we'll set later in WriteStatus (after the body). + // This is a SHOULD in the HTTP RFC, and the way you add (known) + // Trailers per the net/http.ResponseWriter contract. + // See https://golang.org/pkg/net/http/#ResponseWriter + // and https://golang.org/pkg/net/http/#example_ResponseWriter_trailers + h.Add("Trailer", "Grpc-Status") + h.Add("Trailer", "Grpc-Message") + + if s.sendCompress != "" { + h.Set("Grpc-Encoding", s.sendCompress) + } +} + +func (ht *serverHandlerTransport) Write(s *Stream, data []byte, opts *Options) error { + return ht.do(func() { + ht.writeCommonHeaders(s) + ht.rw.Write(data) + if !opts.Delay { + ht.rw.(http.Flusher).Flush() + } + }) +} + +func (ht *serverHandlerTransport) WriteHeader(s *Stream, md metadata.MD) error { + return ht.do(func() { + ht.writeCommonHeaders(s) + h := ht.rw.Header() + for k, vv := range md { + // Clients don't tolerate reading restricted headers after some non restricted ones were sent. + if isReservedHeader(k) { + continue + } + for _, v := range vv { + h.Add(k, v) + } + } + ht.rw.WriteHeader(200) + ht.rw.(http.Flusher).Flush() + }) +} + +func (ht *serverHandlerTransport) HandleStreams(startStream func(*Stream)) { + // With this transport type there will be exactly 1 stream: this HTTP request. + + var ctx context.Context + var cancel context.CancelFunc + if ht.timeoutSet { + ctx, cancel = context.WithTimeout(context.Background(), ht.timeout) + } else { + ctx, cancel = context.WithCancel(context.Background()) + } + + // requestOver is closed when either the request's context is done + // or the status has been written via WriteStatus. + requestOver := make(chan struct{}) + + // clientGone receives a single value if peer is gone, either + // because the underlying connection is dead or because the + // peer sends an http2 RST_STREAM. + clientGone := ht.rw.(http.CloseNotifier).CloseNotify() + go func() { + select { + case <-requestOver: + return + case <-ht.closedCh: + case <-clientGone: + } + cancel() + }() + + req := ht.req + + s := &Stream{ + id: 0, // irrelevant + windowHandler: func(int) {}, // nothing + cancel: cancel, + buf: newRecvBuffer(), + st: ht, + method: req.URL.Path, + recvCompress: req.Header.Get("grpc-encoding"), + } + pr := &peer.Peer{ + Addr: ht.RemoteAddr(), + } + if req.TLS != nil { + pr.AuthInfo = credentials.TLSInfo{State: *req.TLS} + } + ctx = metadata.NewContext(ctx, ht.headerMD) + ctx = peer.NewContext(ctx, pr) + s.ctx = newContextWithStream(ctx, s) + s.dec = &recvBufferReader{ctx: s.ctx, recv: s.buf} + + // readerDone is closed when the Body.Read-ing goroutine exits. + readerDone := make(chan struct{}) + go func() { + defer close(readerDone) + + // TODO: minimize garbage, optimize recvBuffer code/ownership + const readSize = 8196 + for buf := make([]byte, readSize); ; { + n, err := req.Body.Read(buf) + if n > 0 { + s.buf.put(&recvMsg{data: buf[:n:n]}) + buf = buf[n:] + } + if err != nil { + s.buf.put(&recvMsg{err: mapRecvMsgError(err)}) + return + } + if len(buf) == 0 { + buf = make([]byte, readSize) + } + } + }() + + // startStream is provided by the *grpc.Server's serveStreams. + // It starts a goroutine serving s and exits immediately. + // The goroutine that is started is the one that then calls + // into ht, calling WriteHeader, Write, WriteStatus, Close, etc. + startStream(s) + + ht.runStream() + close(requestOver) + + // Wait for reading goroutine to finish. + req.Body.Close() + <-readerDone +} + +func (ht *serverHandlerTransport) runStream() { + for { + select { + case fn, ok := <-ht.writes: + if !ok { + return + } + fn() + case <-ht.closedCh: + return + } + } +} + +func (ht *serverHandlerTransport) Drain() { + panic("Drain() is not implemented") +} + +// mapRecvMsgError returns the non-nil err into the appropriate +// error value as expected by callers of *grpc.parser.recvMsg. +// In particular, in can only be: +// * io.EOF +// * io.ErrUnexpectedEOF +// * of type transport.ConnectionError +// * of type transport.StreamError +func mapRecvMsgError(err error) error { + if err == io.EOF || err == io.ErrUnexpectedEOF { + return err + } + if se, ok := err.(http2.StreamError); ok { + if code, ok := http2ErrConvTab[se.Code]; ok { + return StreamError{ + Code: code, + Desc: se.Error(), + } + } + } + return ConnectionError{Desc: err.Error()} +} diff --git a/vendor/google.golang.org/grpc/transport/http2_client.go b/vendor/google.golang.org/grpc/transport/http2_client.go new file mode 100644 index 00000000..5819cb8a --- /dev/null +++ b/vendor/google.golang.org/grpc/transport/http2_client.go @@ -0,0 +1,1027 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package transport + +import ( + "bytes" + "fmt" + "io" + "math" + "net" + "strings" + "sync" + "time" + + "golang.org/x/net/context" + "golang.org/x/net/http2" + "golang.org/x/net/http2/hpack" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/credentials" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/peer" +) + +// http2Client implements the ClientTransport interface with HTTP2. +type http2Client struct { + target string // server name/addr + userAgent string + conn net.Conn // underlying communication channel + authInfo credentials.AuthInfo // auth info about the connection + nextID uint32 // the next stream ID to be used + + // writableChan synchronizes write access to the transport. + // A writer acquires the write lock by sending a value on writableChan + // and releases it by receiving from writableChan. + writableChan chan int + // shutdownChan is closed when Close is called. + // Blocking operations should select on shutdownChan to avoid + // blocking forever after Close. + // TODO(zhaoq): Maybe have a channel context? + shutdownChan chan struct{} + // errorChan is closed to notify the I/O error to the caller. + errorChan chan struct{} + // goAway is closed to notify the upper layer (i.e., addrConn.transportMonitor) + // that the server sent GoAway on this transport. + goAway chan struct{} + + framer *framer + hBuf *bytes.Buffer // the buffer for HPACK encoding + hEnc *hpack.Encoder // HPACK encoder + + // controlBuf delivers all the control related tasks (e.g., window + // updates, reset streams, and various settings) to the controller. + controlBuf *recvBuffer + fc *inFlow + // sendQuotaPool provides flow control to outbound message. + sendQuotaPool *quotaPool + // streamsQuota limits the max number of concurrent streams. + streamsQuota *quotaPool + + // The scheme used: https if TLS is on, http otherwise. + scheme string + + creds []credentials.PerRPCCredentials + + mu sync.Mutex // guard the following variables + state transportState // the state of underlying connection + activeStreams map[uint32]*Stream + // The max number of concurrent streams + maxStreams int + // the per-stream outbound flow control window size set by the peer. + streamSendQuota uint32 + // goAwayID records the Last-Stream-ID in the GoAway frame from the server. + goAwayID uint32 + // prevGoAway ID records the Last-Stream-ID in the previous GOAway frame. + prevGoAwayID uint32 +} + +func dial(fn func(context.Context, string) (net.Conn, error), ctx context.Context, addr string) (net.Conn, error) { + if fn != nil { + return fn(ctx, addr) + } + return dialContext(ctx, "tcp", addr) +} + +// newHTTP2Client constructs a connected ClientTransport to addr based on HTTP2 +// and starts to receive messages on it. Non-nil error returns if construction +// fails. +func newHTTP2Client(ctx context.Context, addr string, opts ConnectOptions) (_ ClientTransport, err error) { + scheme := "http" + conn, connErr := dial(opts.Dialer, ctx, addr) + if connErr != nil { + return nil, ConnectionErrorf(true, connErr, "transport: %v", connErr) + } + // Any further errors will close the underlying connection + defer func(conn net.Conn) { + if err != nil { + conn.Close() + } + }(conn) + var authInfo credentials.AuthInfo + if creds := opts.TransportCredentials; creds != nil { + scheme = "https" + conn, authInfo, connErr = creds.ClientHandshake(ctx, addr, conn) + } + if connErr != nil { + // Credentials handshake error is not a temporary error (unless the error + // was the connection closing). + return nil, ConnectionErrorf(connErr == io.EOF, connErr, "transport: %v", connErr) + } + ua := primaryUA + if opts.UserAgent != "" { + ua = opts.UserAgent + " " + ua + } + var buf bytes.Buffer + t := &http2Client{ + target: addr, + userAgent: ua, + conn: conn, + authInfo: authInfo, + // The client initiated stream id is odd starting from 1. + nextID: 1, + writableChan: make(chan int, 1), + shutdownChan: make(chan struct{}), + errorChan: make(chan struct{}), + goAway: make(chan struct{}), + framer: newFramer(conn), + hBuf: &buf, + hEnc: hpack.NewEncoder(&buf), + controlBuf: newRecvBuffer(), + fc: &inFlow{limit: initialConnWindowSize}, + sendQuotaPool: newQuotaPool(defaultWindowSize), + scheme: scheme, + state: reachable, + activeStreams: make(map[uint32]*Stream), + creds: opts.PerRPCCredentials, + maxStreams: math.MaxInt32, + streamSendQuota: defaultWindowSize, + } + // Start the reader goroutine for incoming message. Each transport has + // a dedicated goroutine which reads HTTP2 frame from network. Then it + // dispatches the frame to the corresponding stream entity. + go t.reader() + // Send connection preface to server. + n, err := t.conn.Write(clientPreface) + if err != nil { + t.Close() + return nil, ConnectionErrorf(true, err, "transport: %v", err) + } + if n != len(clientPreface) { + t.Close() + return nil, ConnectionErrorf(true, err, "transport: preface mismatch, wrote %d bytes; want %d", n, len(clientPreface)) + } + if initialWindowSize != defaultWindowSize { + err = t.framer.writeSettings(true, http2.Setting{ + ID: http2.SettingInitialWindowSize, + Val: uint32(initialWindowSize), + }) + } else { + err = t.framer.writeSettings(true) + } + if err != nil { + t.Close() + return nil, ConnectionErrorf(true, err, "transport: %v", err) + } + // Adjust the connection flow control window if needed. + if delta := uint32(initialConnWindowSize - defaultWindowSize); delta > 0 { + if err := t.framer.writeWindowUpdate(true, 0, delta); err != nil { + t.Close() + return nil, ConnectionErrorf(true, err, "transport: %v", err) + } + } + go t.controller() + t.writableChan <- 0 + return t, nil +} + +func (t *http2Client) newStream(ctx context.Context, callHdr *CallHdr) *Stream { + // TODO(zhaoq): Handle uint32 overflow of Stream.id. + s := &Stream{ + id: t.nextID, + done: make(chan struct{}), + goAway: make(chan struct{}), + method: callHdr.Method, + sendCompress: callHdr.SendCompress, + buf: newRecvBuffer(), + fc: &inFlow{limit: initialWindowSize}, + sendQuotaPool: newQuotaPool(int(t.streamSendQuota)), + headerChan: make(chan struct{}), + } + t.nextID += 2 + s.windowHandler = func(n int) { + t.updateWindow(s, uint32(n)) + } + // Make a stream be able to cancel the pending operations by itself. + s.ctx, s.cancel = context.WithCancel(ctx) + s.dec = &recvBufferReader{ + ctx: s.ctx, + goAway: s.goAway, + recv: s.buf, + } + return s +} + +// NewStream creates a stream and register it into the transport as "active" +// streams. +func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (_ *Stream, err error) { + // Record the timeout value on the context. + var timeout time.Duration + if dl, ok := ctx.Deadline(); ok { + timeout = dl.Sub(time.Now()) + } + select { + case <-ctx.Done(): + return nil, ContextErr(ctx.Err()) + default: + } + pr := &peer.Peer{ + Addr: t.conn.RemoteAddr(), + } + // Attach Auth info if there is any. + if t.authInfo != nil { + pr.AuthInfo = t.authInfo + } + ctx = peer.NewContext(ctx, pr) + authData := make(map[string]string) + for _, c := range t.creds { + // Construct URI required to get auth request metadata. + var port string + if pos := strings.LastIndex(t.target, ":"); pos != -1 { + // Omit port if it is the default one. + if t.target[pos+1:] != "443" { + port = ":" + t.target[pos+1:] + } + } + pos := strings.LastIndex(callHdr.Method, "/") + if pos == -1 { + return nil, StreamErrorf(codes.InvalidArgument, "transport: malformed method name: %q", callHdr.Method) + } + audience := "https://" + callHdr.Host + port + callHdr.Method[:pos] + data, err := c.GetRequestMetadata(ctx, audience) + if err != nil { + return nil, StreamErrorf(codes.InvalidArgument, "transport: %v", err) + } + for k, v := range data { + authData[k] = v + } + } + t.mu.Lock() + if t.activeStreams == nil { + t.mu.Unlock() + return nil, ErrConnClosing + } + if t.state == draining { + t.mu.Unlock() + return nil, ErrStreamDrain + } + if t.state != reachable { + t.mu.Unlock() + return nil, ErrConnClosing + } + checkStreamsQuota := t.streamsQuota != nil + t.mu.Unlock() + if checkStreamsQuota { + sq, err := wait(ctx, nil, nil, t.shutdownChan, t.streamsQuota.acquire()) + if err != nil { + return nil, err + } + // Returns the quota balance back. + if sq > 1 { + t.streamsQuota.add(sq - 1) + } + } + if _, err := wait(ctx, nil, nil, t.shutdownChan, t.writableChan); err != nil { + // Return the quota back now because there is no stream returned to the caller. + if _, ok := err.(StreamError); ok && checkStreamsQuota { + t.streamsQuota.add(1) + } + return nil, err + } + t.mu.Lock() + if t.state == draining { + t.mu.Unlock() + if checkStreamsQuota { + t.streamsQuota.add(1) + } + // Need to make t writable again so that the rpc in flight can still proceed. + t.writableChan <- 0 + return nil, ErrStreamDrain + } + if t.state != reachable { + t.mu.Unlock() + return nil, ErrConnClosing + } + s := t.newStream(ctx, callHdr) + t.activeStreams[s.id] = s + + // This stream is not counted when applySetings(...) initialize t.streamsQuota. + // Reset t.streamsQuota to the right value. + var reset bool + if !checkStreamsQuota && t.streamsQuota != nil { + reset = true + } + t.mu.Unlock() + if reset { + t.streamsQuota.reset(-1) + } + + // HPACK encodes various headers. Note that once WriteField(...) is + // called, the corresponding headers/continuation frame has to be sent + // because hpack.Encoder is stateful. + t.hBuf.Reset() + t.hEnc.WriteField(hpack.HeaderField{Name: ":method", Value: "POST"}) + t.hEnc.WriteField(hpack.HeaderField{Name: ":scheme", Value: t.scheme}) + t.hEnc.WriteField(hpack.HeaderField{Name: ":path", Value: callHdr.Method}) + t.hEnc.WriteField(hpack.HeaderField{Name: ":authority", Value: callHdr.Host}) + t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"}) + t.hEnc.WriteField(hpack.HeaderField{Name: "user-agent", Value: t.userAgent}) + t.hEnc.WriteField(hpack.HeaderField{Name: "te", Value: "trailers"}) + + if callHdr.SendCompress != "" { + t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-encoding", Value: callHdr.SendCompress}) + } + if timeout > 0 { + t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-timeout", Value: encodeTimeout(timeout)}) + } + for k, v := range authData { + // Capital header names are illegal in HTTP/2. + k = strings.ToLower(k) + t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: v}) + } + var ( + hasMD bool + endHeaders bool + ) + if md, ok := metadata.FromContext(ctx); ok { + hasMD = true + for k, v := range md { + // HTTP doesn't allow you to set pseudoheaders after non pseudoheaders were set. + if isReservedHeader(k) { + continue + } + for _, entry := range v { + t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: entry}) + } + } + } + first := true + // Sends the headers in a single batch even when they span multiple frames. + for !endHeaders { + size := t.hBuf.Len() + if size > http2MaxFrameLen { + size = http2MaxFrameLen + } else { + endHeaders = true + } + var flush bool + if endHeaders && (hasMD || callHdr.Flush) { + flush = true + } + if first { + // Sends a HeadersFrame to server to start a new stream. + p := http2.HeadersFrameParam{ + StreamID: s.id, + BlockFragment: t.hBuf.Next(size), + EndStream: false, + EndHeaders: endHeaders, + } + // Do a force flush for the buffered frames iff it is the last headers frame + // and there is header metadata to be sent. Otherwise, there is flushing until + // the corresponding data frame is written. + err = t.framer.writeHeaders(flush, p) + first = false + } else { + // Sends Continuation frames for the leftover headers. + err = t.framer.writeContinuation(flush, s.id, endHeaders, t.hBuf.Next(size)) + } + if err != nil { + t.notifyError(err) + return nil, ConnectionErrorf(true, err, "transport: %v", err) + } + } + t.writableChan <- 0 + return s, nil +} + +// CloseStream clears the footprint of a stream when the stream is not needed any more. +// This must not be executed in reader's goroutine. +func (t *http2Client) CloseStream(s *Stream, err error) { + var updateStreams bool + t.mu.Lock() + if t.activeStreams == nil { + t.mu.Unlock() + return + } + if t.streamsQuota != nil { + updateStreams = true + } + delete(t.activeStreams, s.id) + if t.state == draining && len(t.activeStreams) == 0 { + // The transport is draining and s is the last live stream on t. + t.mu.Unlock() + t.Close() + return + } + t.mu.Unlock() + if updateStreams { + t.streamsQuota.add(1) + } + s.mu.Lock() + if q := s.fc.resetPendingData(); q > 0 { + if n := t.fc.onRead(q); n > 0 { + t.controlBuf.put(&windowUpdate{0, n}) + } + } + if s.state == streamDone { + s.mu.Unlock() + return + } + if !s.headerDone { + close(s.headerChan) + s.headerDone = true + } + s.state = streamDone + s.mu.Unlock() + if _, ok := err.(StreamError); ok { + t.controlBuf.put(&resetStream{s.id, http2.ErrCodeCancel}) + } +} + +// Close kicks off the shutdown process of the transport. This should be called +// only once on a transport. Once it is called, the transport should not be +// accessed any more. +func (t *http2Client) Close() (err error) { + t.mu.Lock() + if t.state == closing { + t.mu.Unlock() + return + } + if t.state == reachable || t.state == draining { + close(t.errorChan) + } + t.state = closing + t.mu.Unlock() + close(t.shutdownChan) + err = t.conn.Close() + t.mu.Lock() + streams := t.activeStreams + t.activeStreams = nil + t.mu.Unlock() + // Notify all active streams. + for _, s := range streams { + s.mu.Lock() + if !s.headerDone { + close(s.headerChan) + s.headerDone = true + } + s.mu.Unlock() + s.write(recvMsg{err: ErrConnClosing}) + } + return +} + +func (t *http2Client) GracefulClose() error { + t.mu.Lock() + switch t.state { + case unreachable: + // The server may close the connection concurrently. t is not available for + // any streams. Close it now. + t.mu.Unlock() + t.Close() + return nil + case closing: + t.mu.Unlock() + return nil + } + // Notify the streams which were initiated after the server sent GOAWAY. + select { + case <-t.goAway: + n := t.prevGoAwayID + if n == 0 && t.nextID > 1 { + n = t.nextID - 2 + } + m := t.goAwayID + 2 + if m == 2 { + m = 1 + } + for i := m; i <= n; i += 2 { + if s, ok := t.activeStreams[i]; ok { + close(s.goAway) + } + } + default: + } + if t.state == draining { + t.mu.Unlock() + return nil + } + t.state = draining + active := len(t.activeStreams) + t.mu.Unlock() + if active == 0 { + return t.Close() + } + return nil +} + +// Write formats the data into HTTP2 data frame(s) and sends it out. The caller +// should proceed only if Write returns nil. +// TODO(zhaoq): opts.Delay is ignored in this implementation. Support it later +// if it improves the performance. +func (t *http2Client) Write(s *Stream, data []byte, opts *Options) error { + r := bytes.NewBuffer(data) + for { + var p []byte + if r.Len() > 0 { + size := http2MaxFrameLen + s.sendQuotaPool.add(0) + // Wait until the stream has some quota to send the data. + sq, err := wait(s.ctx, s.done, s.goAway, t.shutdownChan, s.sendQuotaPool.acquire()) + if err != nil { + return err + } + t.sendQuotaPool.add(0) + // Wait until the transport has some quota to send the data. + tq, err := wait(s.ctx, s.done, s.goAway, t.shutdownChan, t.sendQuotaPool.acquire()) + if err != nil { + if _, ok := err.(StreamError); ok || err == io.EOF { + t.sendQuotaPool.cancel() + } + return err + } + if sq < size { + size = sq + } + if tq < size { + size = tq + } + p = r.Next(size) + ps := len(p) + if ps < sq { + // Overbooked stream quota. Return it back. + s.sendQuotaPool.add(sq - ps) + } + if ps < tq { + // Overbooked transport quota. Return it back. + t.sendQuotaPool.add(tq - ps) + } + } + var ( + endStream bool + forceFlush bool + ) + if opts.Last && r.Len() == 0 { + endStream = true + } + // Indicate there is a writer who is about to write a data frame. + t.framer.adjustNumWriters(1) + // Got some quota. Try to acquire writing privilege on the transport. + if _, err := wait(s.ctx, s.done, s.goAway, t.shutdownChan, t.writableChan); err != nil { + if _, ok := err.(StreamError); ok || err == io.EOF { + // Return the connection quota back. + t.sendQuotaPool.add(len(p)) + } + if t.framer.adjustNumWriters(-1) == 0 { + // This writer is the last one in this batch and has the + // responsibility to flush the buffered frames. It queues + // a flush request to controlBuf instead of flushing directly + // in order to avoid the race with other writing or flushing. + t.controlBuf.put(&flushIO{}) + } + return err + } + select { + case <-s.ctx.Done(): + t.sendQuotaPool.add(len(p)) + if t.framer.adjustNumWriters(-1) == 0 { + t.controlBuf.put(&flushIO{}) + } + t.writableChan <- 0 + return ContextErr(s.ctx.Err()) + default: + } + if r.Len() == 0 && t.framer.adjustNumWriters(0) == 1 { + // Do a force flush iff this is last frame for the entire gRPC message + // and the caller is the only writer at this moment. + forceFlush = true + } + // If WriteData fails, all the pending streams will be handled + // by http2Client.Close(). No explicit CloseStream() needs to be + // invoked. + if err := t.framer.writeData(forceFlush, s.id, endStream, p); err != nil { + t.notifyError(err) + return ConnectionErrorf(true, err, "transport: %v", err) + } + if t.framer.adjustNumWriters(-1) == 0 { + t.framer.flushWrite() + } + t.writableChan <- 0 + if r.Len() == 0 { + break + } + } + if !opts.Last { + return nil + } + s.mu.Lock() + if s.state != streamDone { + s.state = streamWriteDone + } + s.mu.Unlock() + return nil +} + +func (t *http2Client) getStream(f http2.Frame) (*Stream, bool) { + t.mu.Lock() + defer t.mu.Unlock() + s, ok := t.activeStreams[f.Header().StreamID] + return s, ok +} + +// updateWindow adjusts the inbound quota for the stream and the transport. +// Window updates will deliver to the controller for sending when +// the cumulative quota exceeds the corresponding threshold. +func (t *http2Client) updateWindow(s *Stream, n uint32) { + s.mu.Lock() + defer s.mu.Unlock() + if s.state == streamDone { + return + } + if w := t.fc.onRead(n); w > 0 { + t.controlBuf.put(&windowUpdate{0, w}) + } + if w := s.fc.onRead(n); w > 0 { + t.controlBuf.put(&windowUpdate{s.id, w}) + } +} + +func (t *http2Client) handleData(f *http2.DataFrame) { + size := len(f.Data()) + if err := t.fc.onData(uint32(size)); err != nil { + t.notifyError(ConnectionErrorf(true, err, "%v", err)) + return + } + // Select the right stream to dispatch. + s, ok := t.getStream(f) + if !ok { + if w := t.fc.onRead(uint32(size)); w > 0 { + t.controlBuf.put(&windowUpdate{0, w}) + } + return + } + if size > 0 { + s.mu.Lock() + if s.state == streamDone { + s.mu.Unlock() + // The stream has been closed. Release the corresponding quota. + if w := t.fc.onRead(uint32(size)); w > 0 { + t.controlBuf.put(&windowUpdate{0, w}) + } + return + } + if err := s.fc.onData(uint32(size)); err != nil { + s.state = streamDone + s.statusCode = codes.Internal + s.statusDesc = err.Error() + close(s.done) + s.mu.Unlock() + s.write(recvMsg{err: io.EOF}) + t.controlBuf.put(&resetStream{s.id, http2.ErrCodeFlowControl}) + return + } + s.mu.Unlock() + // TODO(bradfitz, zhaoq): A copy is required here because there is no + // guarantee f.Data() is consumed before the arrival of next frame. + // Can this copy be eliminated? + data := make([]byte, size) + copy(data, f.Data()) + s.write(recvMsg{data: data}) + } + // The server has closed the stream without sending trailers. Record that + // the read direction is closed, and set the status appropriately. + if f.FrameHeader.Flags.Has(http2.FlagDataEndStream) { + s.mu.Lock() + if s.state == streamDone { + s.mu.Unlock() + return + } + s.state = streamDone + s.statusCode = codes.Internal + s.statusDesc = "server closed the stream without sending trailers" + close(s.done) + s.mu.Unlock() + s.write(recvMsg{err: io.EOF}) + } +} + +func (t *http2Client) handleRSTStream(f *http2.RSTStreamFrame) { + s, ok := t.getStream(f) + if !ok { + return + } + s.mu.Lock() + if s.state == streamDone { + s.mu.Unlock() + return + } + s.state = streamDone + if !s.headerDone { + close(s.headerChan) + s.headerDone = true + } + s.statusCode, ok = http2ErrConvTab[http2.ErrCode(f.ErrCode)] + if !ok { + grpclog.Println("transport: http2Client.handleRSTStream found no mapped gRPC status for the received http2 error ", f.ErrCode) + s.statusCode = codes.Unknown + } + s.statusDesc = fmt.Sprintf("stream terminated by RST_STREAM with error code: %d", f.ErrCode) + close(s.done) + s.mu.Unlock() + s.write(recvMsg{err: io.EOF}) +} + +func (t *http2Client) handleSettings(f *http2.SettingsFrame) { + if f.IsAck() { + return + } + var ss []http2.Setting + f.ForeachSetting(func(s http2.Setting) error { + ss = append(ss, s) + return nil + }) + // The settings will be applied once the ack is sent. + t.controlBuf.put(&settings{ack: true, ss: ss}) +} + +func (t *http2Client) handlePing(f *http2.PingFrame) { + pingAck := &ping{ack: true} + copy(pingAck.data[:], f.Data[:]) + t.controlBuf.put(pingAck) +} + +func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) { + t.mu.Lock() + if t.state == reachable || t.state == draining { + if f.LastStreamID > 0 && f.LastStreamID%2 != 1 { + t.mu.Unlock() + t.notifyError(ConnectionErrorf(true, nil, "received illegal http2 GOAWAY frame: stream ID %d is even", f.LastStreamID)) + return + } + select { + case <-t.goAway: + id := t.goAwayID + // t.goAway has been closed (i.e.,multiple GoAways). + if id < f.LastStreamID { + t.mu.Unlock() + t.notifyError(ConnectionErrorf(true, nil, "received illegal http2 GOAWAY frame: previously recv GOAWAY frame with LastStramID %d, currently recv %d", id, f.LastStreamID)) + return + } + t.prevGoAwayID = id + t.goAwayID = f.LastStreamID + t.mu.Unlock() + return + default: + } + t.goAwayID = f.LastStreamID + close(t.goAway) + } + t.mu.Unlock() +} + +func (t *http2Client) handleWindowUpdate(f *http2.WindowUpdateFrame) { + id := f.Header().StreamID + incr := f.Increment + if id == 0 { + t.sendQuotaPool.add(int(incr)) + return + } + if s, ok := t.getStream(f); ok { + s.sendQuotaPool.add(int(incr)) + } +} + +// operateHeaders takes action on the decoded headers. +func (t *http2Client) operateHeaders(frame *http2.MetaHeadersFrame) { + s, ok := t.getStream(frame) + if !ok { + return + } + var state decodeState + for _, hf := range frame.Fields { + state.processHeaderField(hf) + } + if state.err != nil { + s.write(recvMsg{err: state.err}) + // Something wrong. Stops reading even when there is remaining. + return + } + + endStream := frame.StreamEnded() + + s.mu.Lock() + if !endStream { + s.recvCompress = state.encoding + } + if !s.headerDone { + if !endStream && len(state.mdata) > 0 { + s.header = state.mdata + } + close(s.headerChan) + s.headerDone = true + } + if !endStream || s.state == streamDone { + s.mu.Unlock() + return + } + + if len(state.mdata) > 0 { + s.trailer = state.mdata + } + s.statusCode = state.statusCode + s.statusDesc = state.statusDesc + close(s.done) + s.state = streamDone + s.mu.Unlock() + s.write(recvMsg{err: io.EOF}) +} + +func handleMalformedHTTP2(s *Stream, err error) { + s.mu.Lock() + if !s.headerDone { + close(s.headerChan) + s.headerDone = true + } + s.mu.Unlock() + s.write(recvMsg{err: err}) +} + +// reader runs as a separate goroutine in charge of reading data from network +// connection. +// +// TODO(zhaoq): currently one reader per transport. Investigate whether this is +// optimal. +// TODO(zhaoq): Check the validity of the incoming frame sequence. +func (t *http2Client) reader() { + // Check the validity of server preface. + frame, err := t.framer.readFrame() + if err != nil { + t.notifyError(err) + return + } + sf, ok := frame.(*http2.SettingsFrame) + if !ok { + t.notifyError(err) + return + } + t.handleSettings(sf) + + // loop to keep reading incoming messages on this transport. + for { + frame, err := t.framer.readFrame() + if err != nil { + // Abort an active stream if the http2.Framer returns a + // http2.StreamError. This can happen only if the server's response + // is malformed http2. + if se, ok := err.(http2.StreamError); ok { + t.mu.Lock() + s := t.activeStreams[se.StreamID] + t.mu.Unlock() + if s != nil { + // use error detail to provide better err message + handleMalformedHTTP2(s, StreamErrorf(http2ErrConvTab[se.Code], "%v", t.framer.errorDetail())) + } + continue + } else { + // Transport error. + t.notifyError(err) + return + } + } + switch frame := frame.(type) { + case *http2.MetaHeadersFrame: + t.operateHeaders(frame) + case *http2.DataFrame: + t.handleData(frame) + case *http2.RSTStreamFrame: + t.handleRSTStream(frame) + case *http2.SettingsFrame: + t.handleSettings(frame) + case *http2.PingFrame: + t.handlePing(frame) + case *http2.GoAwayFrame: + t.handleGoAway(frame) + case *http2.WindowUpdateFrame: + t.handleWindowUpdate(frame) + default: + grpclog.Printf("transport: http2Client.reader got unhandled frame type %v.", frame) + } + } +} + +func (t *http2Client) applySettings(ss []http2.Setting) { + for _, s := range ss { + switch s.ID { + case http2.SettingMaxConcurrentStreams: + // TODO(zhaoq): This is a hack to avoid significant refactoring of the + // code to deal with the unrealistic int32 overflow. Probably will try + // to find a better way to handle this later. + if s.Val > math.MaxInt32 { + s.Val = math.MaxInt32 + } + t.mu.Lock() + reset := t.streamsQuota != nil + if !reset { + t.streamsQuota = newQuotaPool(int(s.Val) - len(t.activeStreams)) + } + ms := t.maxStreams + t.maxStreams = int(s.Val) + t.mu.Unlock() + if reset { + t.streamsQuota.reset(int(s.Val) - ms) + } + case http2.SettingInitialWindowSize: + t.mu.Lock() + for _, stream := range t.activeStreams { + // Adjust the sending quota for each stream. + stream.sendQuotaPool.reset(int(s.Val - t.streamSendQuota)) + } + t.streamSendQuota = s.Val + t.mu.Unlock() + } + } +} + +// controller running in a separate goroutine takes charge of sending control +// frames (e.g., window update, reset stream, setting, etc.) to the server. +func (t *http2Client) controller() { + for { + select { + case i := <-t.controlBuf.get(): + t.controlBuf.load() + select { + case <-t.writableChan: + switch i := i.(type) { + case *windowUpdate: + t.framer.writeWindowUpdate(true, i.streamID, i.increment) + case *settings: + if i.ack { + t.framer.writeSettingsAck(true) + t.applySettings(i.ss) + } else { + t.framer.writeSettings(true, i.ss...) + } + case *resetStream: + t.framer.writeRSTStream(true, i.streamID, i.code) + case *flushIO: + t.framer.flushWrite() + case *ping: + t.framer.writePing(true, i.ack, i.data) + default: + grpclog.Printf("transport: http2Client.controller got unexpected item type %v\n", i) + } + t.writableChan <- 0 + continue + case <-t.shutdownChan: + return + } + case <-t.shutdownChan: + return + } + } +} + +func (t *http2Client) Error() <-chan struct{} { + return t.errorChan +} + +func (t *http2Client) GoAway() <-chan struct{} { + return t.goAway +} + +func (t *http2Client) notifyError(err error) { + t.mu.Lock() + // make sure t.errorChan is closed only once. + if t.state == draining { + t.mu.Unlock() + t.Close() + return + } + if t.state == reachable { + t.state = unreachable + close(t.errorChan) + grpclog.Printf("transport: http2Client.notifyError got notified that the client transport was broken %v.", err) + } + t.mu.Unlock() +} diff --git a/vendor/google.golang.org/grpc/transport/http2_server.go b/vendor/google.golang.org/grpc/transport/http2_server.go new file mode 100644 index 00000000..16010d55 --- /dev/null +++ b/vendor/google.golang.org/grpc/transport/http2_server.go @@ -0,0 +1,774 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package transport + +import ( + "bytes" + "errors" + "io" + "math" + "net" + "strconv" + "sync" + + "golang.org/x/net/context" + "golang.org/x/net/http2" + "golang.org/x/net/http2/hpack" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/credentials" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/peer" +) + +// ErrIllegalHeaderWrite indicates that setting header is illegal because of +// the stream's state. +var ErrIllegalHeaderWrite = errors.New("transport: the stream is done or WriteHeader was already called") + +// http2Server implements the ServerTransport interface with HTTP2. +type http2Server struct { + conn net.Conn + maxStreamID uint32 // max stream ID ever seen + authInfo credentials.AuthInfo // auth info about the connection + // writableChan synchronizes write access to the transport. + // A writer acquires the write lock by receiving a value on writableChan + // and releases it by sending on writableChan. + writableChan chan int + // shutdownChan is closed when Close is called. + // Blocking operations should select on shutdownChan to avoid + // blocking forever after Close. + shutdownChan chan struct{} + framer *framer + hBuf *bytes.Buffer // the buffer for HPACK encoding + hEnc *hpack.Encoder // HPACK encoder + + // The max number of concurrent streams. + maxStreams uint32 + // controlBuf delivers all the control related tasks (e.g., window + // updates, reset streams, and various settings) to the controller. + controlBuf *recvBuffer + fc *inFlow + // sendQuotaPool provides flow control to outbound message. + sendQuotaPool *quotaPool + + mu sync.Mutex // guard the following + state transportState + activeStreams map[uint32]*Stream + // the per-stream outbound flow control window size set by the peer. + streamSendQuota uint32 +} + +// newHTTP2Server constructs a ServerTransport based on HTTP2. ConnectionError is +// returned if something goes wrong. +func newHTTP2Server(conn net.Conn, maxStreams uint32, authInfo credentials.AuthInfo) (_ ServerTransport, err error) { + framer := newFramer(conn) + // Send initial settings as connection preface to client. + var settings []http2.Setting + // TODO(zhaoq): Have a better way to signal "no limit" because 0 is + // permitted in the HTTP2 spec. + if maxStreams == 0 { + maxStreams = math.MaxUint32 + } else { + settings = append(settings, http2.Setting{ + ID: http2.SettingMaxConcurrentStreams, + Val: maxStreams, + }) + } + if initialWindowSize != defaultWindowSize { + settings = append(settings, http2.Setting{ + ID: http2.SettingInitialWindowSize, + Val: uint32(initialWindowSize)}) + } + if err := framer.writeSettings(true, settings...); err != nil { + return nil, ConnectionErrorf(true, err, "transport: %v", err) + } + // Adjust the connection flow control window if needed. + if delta := uint32(initialConnWindowSize - defaultWindowSize); delta > 0 { + if err := framer.writeWindowUpdate(true, 0, delta); err != nil { + return nil, ConnectionErrorf(true, err, "transport: %v", err) + } + } + var buf bytes.Buffer + t := &http2Server{ + conn: conn, + authInfo: authInfo, + framer: framer, + hBuf: &buf, + hEnc: hpack.NewEncoder(&buf), + maxStreams: maxStreams, + controlBuf: newRecvBuffer(), + fc: &inFlow{limit: initialConnWindowSize}, + sendQuotaPool: newQuotaPool(defaultWindowSize), + state: reachable, + writableChan: make(chan int, 1), + shutdownChan: make(chan struct{}), + activeStreams: make(map[uint32]*Stream), + streamSendQuota: defaultWindowSize, + } + go t.controller() + t.writableChan <- 0 + return t, nil +} + +// operateHeader takes action on the decoded headers. +func (t *http2Server) operateHeaders(frame *http2.MetaHeadersFrame, handle func(*Stream)) (close bool) { + buf := newRecvBuffer() + s := &Stream{ + id: frame.Header().StreamID, + st: t, + buf: buf, + fc: &inFlow{limit: initialWindowSize}, + } + + var state decodeState + for _, hf := range frame.Fields { + state.processHeaderField(hf) + } + if err := state.err; err != nil { + if se, ok := err.(StreamError); ok { + t.controlBuf.put(&resetStream{s.id, statusCodeConvTab[se.Code]}) + } + return + } + + if frame.StreamEnded() { + // s is just created by the caller. No lock needed. + s.state = streamReadDone + } + s.recvCompress = state.encoding + if state.timeoutSet { + s.ctx, s.cancel = context.WithTimeout(context.TODO(), state.timeout) + } else { + s.ctx, s.cancel = context.WithCancel(context.TODO()) + } + pr := &peer.Peer{ + Addr: t.conn.RemoteAddr(), + } + // Attach Auth info if there is any. + if t.authInfo != nil { + pr.AuthInfo = t.authInfo + } + s.ctx = peer.NewContext(s.ctx, pr) + // Cache the current stream to the context so that the server application + // can find out. Required when the server wants to send some metadata + // back to the client (unary call only). + s.ctx = newContextWithStream(s.ctx, s) + // Attach the received metadata to the context. + if len(state.mdata) > 0 { + s.ctx = metadata.NewContext(s.ctx, state.mdata) + } + + s.dec = &recvBufferReader{ + ctx: s.ctx, + recv: s.buf, + } + s.recvCompress = state.encoding + s.method = state.method + t.mu.Lock() + if t.state != reachable { + t.mu.Unlock() + return + } + if uint32(len(t.activeStreams)) >= t.maxStreams { + t.mu.Unlock() + t.controlBuf.put(&resetStream{s.id, http2.ErrCodeRefusedStream}) + return + } + if s.id%2 != 1 || s.id <= t.maxStreamID { + t.mu.Unlock() + // illegal gRPC stream id. + grpclog.Println("transport: http2Server.HandleStreams received an illegal stream id: ", s.id) + return true + } + t.maxStreamID = s.id + s.sendQuotaPool = newQuotaPool(int(t.streamSendQuota)) + t.activeStreams[s.id] = s + t.mu.Unlock() + s.windowHandler = func(n int) { + t.updateWindow(s, uint32(n)) + } + handle(s) + return +} + +// HandleStreams receives incoming streams using the given handler. This is +// typically run in a separate goroutine. +func (t *http2Server) HandleStreams(handle func(*Stream)) { + // Check the validity of client preface. + preface := make([]byte, len(clientPreface)) + if _, err := io.ReadFull(t.conn, preface); err != nil { + grpclog.Printf("transport: http2Server.HandleStreams failed to receive the preface from client: %v", err) + t.Close() + return + } + if !bytes.Equal(preface, clientPreface) { + grpclog.Printf("transport: http2Server.HandleStreams received bogus greeting from client: %q", preface) + t.Close() + return + } + + frame, err := t.framer.readFrame() + if err == io.EOF || err == io.ErrUnexpectedEOF { + t.Close() + return + } + if err != nil { + grpclog.Printf("transport: http2Server.HandleStreams failed to read frame: %v", err) + t.Close() + return + } + sf, ok := frame.(*http2.SettingsFrame) + if !ok { + grpclog.Printf("transport: http2Server.HandleStreams saw invalid preface type %T from client", frame) + t.Close() + return + } + t.handleSettings(sf) + + for { + frame, err := t.framer.readFrame() + if err != nil { + if se, ok := err.(http2.StreamError); ok { + t.mu.Lock() + s := t.activeStreams[se.StreamID] + t.mu.Unlock() + if s != nil { + t.closeStream(s) + } + t.controlBuf.put(&resetStream{se.StreamID, se.Code}) + continue + } + if err == io.EOF || err == io.ErrUnexpectedEOF { + t.Close() + return + } + grpclog.Printf("transport: http2Server.HandleStreams failed to read frame: %v", err) + t.Close() + return + } + switch frame := frame.(type) { + case *http2.MetaHeadersFrame: + if t.operateHeaders(frame, handle) { + t.Close() + break + } + case *http2.DataFrame: + t.handleData(frame) + case *http2.RSTStreamFrame: + t.handleRSTStream(frame) + case *http2.SettingsFrame: + t.handleSettings(frame) + case *http2.PingFrame: + t.handlePing(frame) + case *http2.WindowUpdateFrame: + t.handleWindowUpdate(frame) + case *http2.GoAwayFrame: + // TODO: Handle GoAway from the client appropriately. + default: + grpclog.Printf("transport: http2Server.HandleStreams found unhandled frame type %v.", frame) + } + } +} + +func (t *http2Server) getStream(f http2.Frame) (*Stream, bool) { + t.mu.Lock() + defer t.mu.Unlock() + if t.activeStreams == nil { + // The transport is closing. + return nil, false + } + s, ok := t.activeStreams[f.Header().StreamID] + if !ok { + // The stream is already done. + return nil, false + } + return s, true +} + +// updateWindow adjusts the inbound quota for the stream and the transport. +// Window updates will deliver to the controller for sending when +// the cumulative quota exceeds the corresponding threshold. +func (t *http2Server) updateWindow(s *Stream, n uint32) { + s.mu.Lock() + defer s.mu.Unlock() + if s.state == streamDone { + return + } + if w := t.fc.onRead(n); w > 0 { + t.controlBuf.put(&windowUpdate{0, w}) + } + if w := s.fc.onRead(n); w > 0 { + t.controlBuf.put(&windowUpdate{s.id, w}) + } +} + +func (t *http2Server) handleData(f *http2.DataFrame) { + size := len(f.Data()) + if err := t.fc.onData(uint32(size)); err != nil { + grpclog.Printf("transport: http2Server %v", err) + t.Close() + return + } + // Select the right stream to dispatch. + s, ok := t.getStream(f) + if !ok { + if w := t.fc.onRead(uint32(size)); w > 0 { + t.controlBuf.put(&windowUpdate{0, w}) + } + return + } + if size > 0 { + s.mu.Lock() + if s.state == streamDone { + s.mu.Unlock() + // The stream has been closed. Release the corresponding quota. + if w := t.fc.onRead(uint32(size)); w > 0 { + t.controlBuf.put(&windowUpdate{0, w}) + } + return + } + if err := s.fc.onData(uint32(size)); err != nil { + s.mu.Unlock() + t.closeStream(s) + t.controlBuf.put(&resetStream{s.id, http2.ErrCodeFlowControl}) + return + } + s.mu.Unlock() + // TODO(bradfitz, zhaoq): A copy is required here because there is no + // guarantee f.Data() is consumed before the arrival of next frame. + // Can this copy be eliminated? + data := make([]byte, size) + copy(data, f.Data()) + s.write(recvMsg{data: data}) + } + if f.Header().Flags.Has(http2.FlagDataEndStream) { + // Received the end of stream from the client. + s.mu.Lock() + if s.state != streamDone { + s.state = streamReadDone + } + s.mu.Unlock() + s.write(recvMsg{err: io.EOF}) + } +} + +func (t *http2Server) handleRSTStream(f *http2.RSTStreamFrame) { + s, ok := t.getStream(f) + if !ok { + return + } + t.closeStream(s) +} + +func (t *http2Server) handleSettings(f *http2.SettingsFrame) { + if f.IsAck() { + return + } + var ss []http2.Setting + f.ForeachSetting(func(s http2.Setting) error { + ss = append(ss, s) + return nil + }) + // The settings will be applied once the ack is sent. + t.controlBuf.put(&settings{ack: true, ss: ss}) +} + +func (t *http2Server) handlePing(f *http2.PingFrame) { + pingAck := &ping{ack: true} + copy(pingAck.data[:], f.Data[:]) + t.controlBuf.put(pingAck) +} + +func (t *http2Server) handleWindowUpdate(f *http2.WindowUpdateFrame) { + id := f.Header().StreamID + incr := f.Increment + if id == 0 { + t.sendQuotaPool.add(int(incr)) + return + } + if s, ok := t.getStream(f); ok { + s.sendQuotaPool.add(int(incr)) + } +} + +func (t *http2Server) writeHeaders(s *Stream, b *bytes.Buffer, endStream bool) error { + first := true + endHeaders := false + var err error + // Sends the headers in a single batch. + for !endHeaders { + size := t.hBuf.Len() + if size > http2MaxFrameLen { + size = http2MaxFrameLen + } else { + endHeaders = true + } + if first { + p := http2.HeadersFrameParam{ + StreamID: s.id, + BlockFragment: b.Next(size), + EndStream: endStream, + EndHeaders: endHeaders, + } + err = t.framer.writeHeaders(endHeaders, p) + first = false + } else { + err = t.framer.writeContinuation(endHeaders, s.id, endHeaders, b.Next(size)) + } + if err != nil { + t.Close() + return ConnectionErrorf(true, err, "transport: %v", err) + } + } + return nil +} + +// WriteHeader sends the header metedata md back to the client. +func (t *http2Server) WriteHeader(s *Stream, md metadata.MD) error { + s.mu.Lock() + if s.headerOk || s.state == streamDone { + s.mu.Unlock() + return ErrIllegalHeaderWrite + } + s.headerOk = true + s.mu.Unlock() + if _, err := wait(s.ctx, nil, nil, t.shutdownChan, t.writableChan); err != nil { + return err + } + t.hBuf.Reset() + t.hEnc.WriteField(hpack.HeaderField{Name: ":status", Value: "200"}) + t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"}) + if s.sendCompress != "" { + t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-encoding", Value: s.sendCompress}) + } + for k, v := range md { + if isReservedHeader(k) { + // Clients don't tolerate reading restricted headers after some non restricted ones were sent. + continue + } + for _, entry := range v { + t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: entry}) + } + } + if err := t.writeHeaders(s, t.hBuf, false); err != nil { + return err + } + t.writableChan <- 0 + return nil +} + +// WriteStatus sends stream status to the client and terminates the stream. +// There is no further I/O operations being able to perform on this stream. +// TODO(zhaoq): Now it indicates the end of entire stream. Revisit if early +// OK is adopted. +func (t *http2Server) WriteStatus(s *Stream, statusCode codes.Code, statusDesc string) error { + var headersSent bool + s.mu.Lock() + if s.state == streamDone { + s.mu.Unlock() + return nil + } + if s.headerOk { + headersSent = true + } + s.mu.Unlock() + if _, err := wait(s.ctx, nil, nil, t.shutdownChan, t.writableChan); err != nil { + return err + } + t.hBuf.Reset() + if !headersSent { + t.hEnc.WriteField(hpack.HeaderField{Name: ":status", Value: "200"}) + t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"}) + } + t.hEnc.WriteField( + hpack.HeaderField{ + Name: "grpc-status", + Value: strconv.Itoa(int(statusCode)), + }) + t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-message", Value: encodeGrpcMessage(statusDesc)}) + // Attach the trailer metadata. + for k, v := range s.trailer { + // Clients don't tolerate reading restricted headers after some non restricted ones were sent. + if isReservedHeader(k) { + continue + } + for _, entry := range v { + t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: entry}) + } + } + if err := t.writeHeaders(s, t.hBuf, true); err != nil { + t.Close() + return err + } + t.closeStream(s) + t.writableChan <- 0 + return nil +} + +// Write converts the data into HTTP2 data frame and sends it out. Non-nil error +// is returns if it fails (e.g., framing error, transport error). +func (t *http2Server) Write(s *Stream, data []byte, opts *Options) error { + // TODO(zhaoq): Support multi-writers for a single stream. + var writeHeaderFrame bool + s.mu.Lock() + if s.state == streamDone { + s.mu.Unlock() + return StreamErrorf(codes.Unknown, "the stream has been done") + } + if !s.headerOk { + writeHeaderFrame = true + s.headerOk = true + } + s.mu.Unlock() + if writeHeaderFrame { + if _, err := wait(s.ctx, nil, nil, t.shutdownChan, t.writableChan); err != nil { + return err + } + t.hBuf.Reset() + t.hEnc.WriteField(hpack.HeaderField{Name: ":status", Value: "200"}) + t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"}) + if s.sendCompress != "" { + t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-encoding", Value: s.sendCompress}) + } + p := http2.HeadersFrameParam{ + StreamID: s.id, + BlockFragment: t.hBuf.Bytes(), + EndHeaders: true, + } + if err := t.framer.writeHeaders(false, p); err != nil { + t.Close() + return ConnectionErrorf(true, err, "transport: %v", err) + } + t.writableChan <- 0 + } + r := bytes.NewBuffer(data) + for { + if r.Len() == 0 { + return nil + } + size := http2MaxFrameLen + s.sendQuotaPool.add(0) + // Wait until the stream has some quota to send the data. + sq, err := wait(s.ctx, nil, nil, t.shutdownChan, s.sendQuotaPool.acquire()) + if err != nil { + return err + } + t.sendQuotaPool.add(0) + // Wait until the transport has some quota to send the data. + tq, err := wait(s.ctx, nil, nil, t.shutdownChan, t.sendQuotaPool.acquire()) + if err != nil { + if _, ok := err.(StreamError); ok { + t.sendQuotaPool.cancel() + } + return err + } + if sq < size { + size = sq + } + if tq < size { + size = tq + } + p := r.Next(size) + ps := len(p) + if ps < sq { + // Overbooked stream quota. Return it back. + s.sendQuotaPool.add(sq - ps) + } + if ps < tq { + // Overbooked transport quota. Return it back. + t.sendQuotaPool.add(tq - ps) + } + t.framer.adjustNumWriters(1) + // Got some quota. Try to acquire writing privilege on the + // transport. + if _, err := wait(s.ctx, nil, nil, t.shutdownChan, t.writableChan); err != nil { + if _, ok := err.(StreamError); ok { + // Return the connection quota back. + t.sendQuotaPool.add(ps) + } + if t.framer.adjustNumWriters(-1) == 0 { + // This writer is the last one in this batch and has the + // responsibility to flush the buffered frames. It queues + // a flush request to controlBuf instead of flushing directly + // in order to avoid the race with other writing or flushing. + t.controlBuf.put(&flushIO{}) + } + return err + } + select { + case <-s.ctx.Done(): + t.sendQuotaPool.add(ps) + if t.framer.adjustNumWriters(-1) == 0 { + t.controlBuf.put(&flushIO{}) + } + t.writableChan <- 0 + return ContextErr(s.ctx.Err()) + default: + } + var forceFlush bool + if r.Len() == 0 && t.framer.adjustNumWriters(0) == 1 && !opts.Last { + forceFlush = true + } + if err := t.framer.writeData(forceFlush, s.id, false, p); err != nil { + t.Close() + return ConnectionErrorf(true, err, "transport: %v", err) + } + if t.framer.adjustNumWriters(-1) == 0 { + t.framer.flushWrite() + } + t.writableChan <- 0 + } + +} + +func (t *http2Server) applySettings(ss []http2.Setting) { + for _, s := range ss { + if s.ID == http2.SettingInitialWindowSize { + t.mu.Lock() + defer t.mu.Unlock() + for _, stream := range t.activeStreams { + stream.sendQuotaPool.reset(int(s.Val - t.streamSendQuota)) + } + t.streamSendQuota = s.Val + } + + } +} + +// controller running in a separate goroutine takes charge of sending control +// frames (e.g., window update, reset stream, setting, etc.) to the server. +func (t *http2Server) controller() { + for { + select { + case i := <-t.controlBuf.get(): + t.controlBuf.load() + select { + case <-t.writableChan: + switch i := i.(type) { + case *windowUpdate: + t.framer.writeWindowUpdate(true, i.streamID, i.increment) + case *settings: + if i.ack { + t.framer.writeSettingsAck(true) + t.applySettings(i.ss) + } else { + t.framer.writeSettings(true, i.ss...) + } + case *resetStream: + t.framer.writeRSTStream(true, i.streamID, i.code) + case *goAway: + t.mu.Lock() + if t.state == closing { + t.mu.Unlock() + // The transport is closing. + return + } + sid := t.maxStreamID + t.state = draining + t.mu.Unlock() + t.framer.writeGoAway(true, sid, http2.ErrCodeNo, nil) + case *flushIO: + t.framer.flushWrite() + case *ping: + t.framer.writePing(true, i.ack, i.data) + default: + grpclog.Printf("transport: http2Server.controller got unexpected item type %v\n", i) + } + t.writableChan <- 0 + continue + case <-t.shutdownChan: + return + } + case <-t.shutdownChan: + return + } + } +} + +// Close starts shutting down the http2Server transport. +// TODO(zhaoq): Now the destruction is not blocked on any pending streams. This +// could cause some resource issue. Revisit this later. +func (t *http2Server) Close() (err error) { + t.mu.Lock() + if t.state == closing { + t.mu.Unlock() + return errors.New("transport: Close() was already called") + } + t.state = closing + streams := t.activeStreams + t.activeStreams = nil + t.mu.Unlock() + close(t.shutdownChan) + err = t.conn.Close() + // Cancel all active streams. + for _, s := range streams { + s.cancel() + } + return +} + +// closeStream clears the footprint of a stream when the stream is not needed +// any more. +func (t *http2Server) closeStream(s *Stream) { + t.mu.Lock() + delete(t.activeStreams, s.id) + if t.state == draining && len(t.activeStreams) == 0 { + defer t.Close() + } + t.mu.Unlock() + // In case stream sending and receiving are invoked in separate + // goroutines (e.g., bi-directional streaming), cancel needs to be + // called to interrupt the potential blocking on other goroutines. + s.cancel() + s.mu.Lock() + if q := s.fc.resetPendingData(); q > 0 { + if w := t.fc.onRead(q); w > 0 { + t.controlBuf.put(&windowUpdate{0, w}) + } + } + if s.state == streamDone { + s.mu.Unlock() + return + } + s.state = streamDone + s.mu.Unlock() +} + +func (t *http2Server) RemoteAddr() net.Addr { + return t.conn.RemoteAddr() +} + +func (t *http2Server) Drain() { + t.controlBuf.put(&goAway{}) +} diff --git a/vendor/google.golang.org/grpc/transport/http_util.go b/vendor/google.golang.org/grpc/transport/http_util.go new file mode 100644 index 00000000..79da5126 --- /dev/null +++ b/vendor/google.golang.org/grpc/transport/http_util.go @@ -0,0 +1,510 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package transport + +import ( + "bufio" + "bytes" + "fmt" + "io" + "net" + "strconv" + "strings" + "sync/atomic" + "time" + + "golang.org/x/net/http2" + "golang.org/x/net/http2/hpack" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" +) + +const ( + // The primary user agent + primaryUA = "grpc-go/1.0" + // http2MaxFrameLen specifies the max length of a HTTP2 frame. + http2MaxFrameLen = 16384 // 16KB frame + // http://http2.github.io/http2-spec/#SettingValues + http2InitHeaderTableSize = 4096 + // http2IOBufSize specifies the buffer size for sending frames. + http2IOBufSize = 32 * 1024 +) + +var ( + clientPreface = []byte(http2.ClientPreface) + http2ErrConvTab = map[http2.ErrCode]codes.Code{ + http2.ErrCodeNo: codes.Internal, + http2.ErrCodeProtocol: codes.Internal, + http2.ErrCodeInternal: codes.Internal, + http2.ErrCodeFlowControl: codes.ResourceExhausted, + http2.ErrCodeSettingsTimeout: codes.Internal, + http2.ErrCodeStreamClosed: codes.Internal, + http2.ErrCodeFrameSize: codes.Internal, + http2.ErrCodeRefusedStream: codes.Unavailable, + http2.ErrCodeCancel: codes.Canceled, + http2.ErrCodeCompression: codes.Internal, + http2.ErrCodeConnect: codes.Internal, + http2.ErrCodeEnhanceYourCalm: codes.ResourceExhausted, + http2.ErrCodeInadequateSecurity: codes.PermissionDenied, + http2.ErrCodeHTTP11Required: codes.FailedPrecondition, + } + statusCodeConvTab = map[codes.Code]http2.ErrCode{ + codes.Internal: http2.ErrCodeInternal, + codes.Canceled: http2.ErrCodeCancel, + codes.Unavailable: http2.ErrCodeRefusedStream, + codes.ResourceExhausted: http2.ErrCodeEnhanceYourCalm, + codes.PermissionDenied: http2.ErrCodeInadequateSecurity, + } +) + +// Records the states during HPACK decoding. Must be reset once the +// decoding of the entire headers are finished. +type decodeState struct { + err error // first error encountered decoding + + encoding string + // statusCode caches the stream status received from the trailer + // the server sent. Client side only. + statusCode codes.Code + statusDesc string + // Server side only fields. + timeoutSet bool + timeout time.Duration + method string + // key-value metadata map from the peer. + mdata map[string][]string +} + +// isReservedHeader checks whether hdr belongs to HTTP2 headers +// reserved by gRPC protocol. Any other headers are classified as the +// user-specified metadata. +func isReservedHeader(hdr string) bool { + if hdr != "" && hdr[0] == ':' { + return true + } + switch hdr { + case "content-type", + "grpc-message-type", + "grpc-encoding", + "grpc-message", + "grpc-status", + "grpc-timeout", + "te": + return true + default: + return false + } +} + +// isWhitelistedPseudoHeader checks whether hdr belongs to HTTP2 pseudoheaders +// that should be propagated into metadata visible to users. +func isWhitelistedPseudoHeader(hdr string) bool { + switch hdr { + case ":authority": + return true + default: + return false + } +} + +func (d *decodeState) setErr(err error) { + if d.err == nil { + d.err = err + } +} + +func validContentType(t string) bool { + e := "application/grpc" + if !strings.HasPrefix(t, e) { + return false + } + // Support variations on the content-type + // (e.g. "application/grpc+blah", "application/grpc;blah"). + if len(t) > len(e) && t[len(e)] != '+' && t[len(e)] != ';' { + return false + } + return true +} + +func (d *decodeState) processHeaderField(f hpack.HeaderField) { + switch f.Name { + case "content-type": + if !validContentType(f.Value) { + d.setErr(StreamErrorf(codes.FailedPrecondition, "transport: received the unexpected content-type %q", f.Value)) + return + } + case "grpc-encoding": + d.encoding = f.Value + case "grpc-status": + code, err := strconv.Atoi(f.Value) + if err != nil { + d.setErr(StreamErrorf(codes.Internal, "transport: malformed grpc-status: %v", err)) + return + } + d.statusCode = codes.Code(code) + case "grpc-message": + d.statusDesc = decodeGrpcMessage(f.Value) + case "grpc-timeout": + d.timeoutSet = true + var err error + d.timeout, err = decodeTimeout(f.Value) + if err != nil { + d.setErr(StreamErrorf(codes.Internal, "transport: malformed time-out: %v", err)) + return + } + case ":path": + d.method = f.Value + default: + if !isReservedHeader(f.Name) || isWhitelistedPseudoHeader(f.Name) { + if f.Name == "user-agent" { + i := strings.LastIndex(f.Value, " ") + if i == -1 { + // There is no application user agent string being set. + return + } + // Extract the application user agent string. + f.Value = f.Value[:i] + } + if d.mdata == nil { + d.mdata = make(map[string][]string) + } + k, v, err := metadata.DecodeKeyValue(f.Name, f.Value) + if err != nil { + grpclog.Printf("Failed to decode (%q, %q): %v", f.Name, f.Value, err) + return + } + d.mdata[k] = append(d.mdata[k], v) + } + } +} + +type timeoutUnit uint8 + +const ( + hour timeoutUnit = 'H' + minute timeoutUnit = 'M' + second timeoutUnit = 'S' + millisecond timeoutUnit = 'm' + microsecond timeoutUnit = 'u' + nanosecond timeoutUnit = 'n' +) + +func timeoutUnitToDuration(u timeoutUnit) (d time.Duration, ok bool) { + switch u { + case hour: + return time.Hour, true + case minute: + return time.Minute, true + case second: + return time.Second, true + case millisecond: + return time.Millisecond, true + case microsecond: + return time.Microsecond, true + case nanosecond: + return time.Nanosecond, true + default: + } + return +} + +const maxTimeoutValue int64 = 100000000 - 1 + +// div does integer division and round-up the result. Note that this is +// equivalent to (d+r-1)/r but has less chance to overflow. +func div(d, r time.Duration) int64 { + if m := d % r; m > 0 { + return int64(d/r + 1) + } + return int64(d / r) +} + +// TODO(zhaoq): It is the simplistic and not bandwidth efficient. Improve it. +func encodeTimeout(t time.Duration) string { + if d := div(t, time.Nanosecond); d <= maxTimeoutValue { + return strconv.FormatInt(d, 10) + "n" + } + if d := div(t, time.Microsecond); d <= maxTimeoutValue { + return strconv.FormatInt(d, 10) + "u" + } + if d := div(t, time.Millisecond); d <= maxTimeoutValue { + return strconv.FormatInt(d, 10) + "m" + } + if d := div(t, time.Second); d <= maxTimeoutValue { + return strconv.FormatInt(d, 10) + "S" + } + if d := div(t, time.Minute); d <= maxTimeoutValue { + return strconv.FormatInt(d, 10) + "M" + } + // Note that maxTimeoutValue * time.Hour > MaxInt64. + return strconv.FormatInt(div(t, time.Hour), 10) + "H" +} + +func decodeTimeout(s string) (time.Duration, error) { + size := len(s) + if size < 2 { + return 0, fmt.Errorf("transport: timeout string is too short: %q", s) + } + unit := timeoutUnit(s[size-1]) + d, ok := timeoutUnitToDuration(unit) + if !ok { + return 0, fmt.Errorf("transport: timeout unit is not recognized: %q", s) + } + t, err := strconv.ParseInt(s[:size-1], 10, 64) + if err != nil { + return 0, err + } + return d * time.Duration(t), nil +} + +const ( + spaceByte = ' ' + tildaByte = '~' + percentByte = '%' +) + +// encodeGrpcMessage is used to encode status code in header field +// "grpc-message". +// It checks to see if each individual byte in msg is an +// allowable byte, and then either percent encoding or passing it through. +// When percent encoding, the byte is converted into hexadecimal notation +// with a '%' prepended. +func encodeGrpcMessage(msg string) string { + if msg == "" { + return "" + } + lenMsg := len(msg) + for i := 0; i < lenMsg; i++ { + c := msg[i] + if !(c >= spaceByte && c < tildaByte && c != percentByte) { + return encodeGrpcMessageUnchecked(msg) + } + } + return msg +} + +func encodeGrpcMessageUnchecked(msg string) string { + var buf bytes.Buffer + lenMsg := len(msg) + for i := 0; i < lenMsg; i++ { + c := msg[i] + if c >= spaceByte && c < tildaByte && c != percentByte { + buf.WriteByte(c) + } else { + buf.WriteString(fmt.Sprintf("%%%02X", c)) + } + } + return buf.String() +} + +// decodeGrpcMessage decodes the msg encoded by encodeGrpcMessage. +func decodeGrpcMessage(msg string) string { + if msg == "" { + return "" + } + lenMsg := len(msg) + for i := 0; i < lenMsg; i++ { + if msg[i] == percentByte && i+2 < lenMsg { + return decodeGrpcMessageUnchecked(msg) + } + } + return msg +} + +func decodeGrpcMessageUnchecked(msg string) string { + var buf bytes.Buffer + lenMsg := len(msg) + for i := 0; i < lenMsg; i++ { + c := msg[i] + if c == percentByte && i+2 < lenMsg { + parsed, err := strconv.ParseInt(msg[i+1:i+3], 16, 8) + if err != nil { + buf.WriteByte(c) + } else { + buf.WriteByte(byte(parsed)) + i += 2 + } + } else { + buf.WriteByte(c) + } + } + return buf.String() +} + +type framer struct { + numWriters int32 + reader io.Reader + writer *bufio.Writer + fr *http2.Framer +} + +func newFramer(conn net.Conn) *framer { + f := &framer{ + reader: bufio.NewReaderSize(conn, http2IOBufSize), + writer: bufio.NewWriterSize(conn, http2IOBufSize), + } + f.fr = http2.NewFramer(f.writer, f.reader) + f.fr.ReadMetaHeaders = hpack.NewDecoder(http2InitHeaderTableSize, nil) + return f +} + +func (f *framer) adjustNumWriters(i int32) int32 { + return atomic.AddInt32(&f.numWriters, i) +} + +// The following writeXXX functions can only be called when the caller gets +// unblocked from writableChan channel (i.e., owns the privilege to write). + +func (f *framer) writeContinuation(forceFlush bool, streamID uint32, endHeaders bool, headerBlockFragment []byte) error { + if err := f.fr.WriteContinuation(streamID, endHeaders, headerBlockFragment); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) writeData(forceFlush bool, streamID uint32, endStream bool, data []byte) error { + if err := f.fr.WriteData(streamID, endStream, data); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) writeGoAway(forceFlush bool, maxStreamID uint32, code http2.ErrCode, debugData []byte) error { + if err := f.fr.WriteGoAway(maxStreamID, code, debugData); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) writeHeaders(forceFlush bool, p http2.HeadersFrameParam) error { + if err := f.fr.WriteHeaders(p); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) writePing(forceFlush, ack bool, data [8]byte) error { + if err := f.fr.WritePing(ack, data); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) writePriority(forceFlush bool, streamID uint32, p http2.PriorityParam) error { + if err := f.fr.WritePriority(streamID, p); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) writePushPromise(forceFlush bool, p http2.PushPromiseParam) error { + if err := f.fr.WritePushPromise(p); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) writeRSTStream(forceFlush bool, streamID uint32, code http2.ErrCode) error { + if err := f.fr.WriteRSTStream(streamID, code); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) writeSettings(forceFlush bool, settings ...http2.Setting) error { + if err := f.fr.WriteSettings(settings...); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) writeSettingsAck(forceFlush bool) error { + if err := f.fr.WriteSettingsAck(); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) writeWindowUpdate(forceFlush bool, streamID, incr uint32) error { + if err := f.fr.WriteWindowUpdate(streamID, incr); err != nil { + return err + } + if forceFlush { + return f.writer.Flush() + } + return nil +} + +func (f *framer) flushWrite() error { + return f.writer.Flush() +} + +func (f *framer) readFrame() (http2.Frame, error) { + return f.fr.ReadFrame() +} + +func (f *framer) errorDetail() error { + return f.fr.ErrorDetail() +} diff --git a/vendor/google.golang.org/grpc/transport/pre_go16.go b/vendor/google.golang.org/grpc/transport/pre_go16.go new file mode 100644 index 00000000..33d91c17 --- /dev/null +++ b/vendor/google.golang.org/grpc/transport/pre_go16.go @@ -0,0 +1,51 @@ +// +build !go1.6 + +/* + * Copyright 2016, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +package transport + +import ( + "net" + "time" + + "golang.org/x/net/context" +) + +// dialContext connects to the address on the named network. +func dialContext(ctx context.Context, network, address string) (net.Conn, error) { + var dialer net.Dialer + if deadline, ok := ctx.Deadline(); ok { + dialer.Timeout = deadline.Sub(time.Now()) + } + return dialer.Dial(network, address) +} diff --git a/vendor/google.golang.org/grpc/transport/transport.go b/vendor/google.golang.org/grpc/transport/transport.go new file mode 100644 index 00000000..d59e5113 --- /dev/null +++ b/vendor/google.golang.org/grpc/transport/transport.go @@ -0,0 +1,578 @@ +/* + * + * Copyright 2014, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +/* +Package transport defines and implements message oriented communication channel +to complete various transactions (e.g., an RPC). +*/ +package transport // import "google.golang.org/grpc/transport" + +import ( + "bytes" + "errors" + "fmt" + "io" + "net" + "sync" + + "golang.org/x/net/context" + "golang.org/x/net/trace" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/credentials" + "google.golang.org/grpc/metadata" +) + +// recvMsg represents the received msg from the transport. All transport +// protocol specific info has been removed. +type recvMsg struct { + data []byte + // nil: received some data + // io.EOF: stream is completed. data is nil. + // other non-nil error: transport failure. data is nil. + err error +} + +func (*recvMsg) item() {} + +// All items in an out of a recvBuffer should be the same type. +type item interface { + item() +} + +// recvBuffer is an unbounded channel of item. +type recvBuffer struct { + c chan item + mu sync.Mutex + backlog []item +} + +func newRecvBuffer() *recvBuffer { + b := &recvBuffer{ + c: make(chan item, 1), + } + return b +} + +func (b *recvBuffer) put(r item) { + b.mu.Lock() + defer b.mu.Unlock() + if len(b.backlog) == 0 { + select { + case b.c <- r: + return + default: + } + } + b.backlog = append(b.backlog, r) +} + +func (b *recvBuffer) load() { + b.mu.Lock() + defer b.mu.Unlock() + if len(b.backlog) > 0 { + select { + case b.c <- b.backlog[0]: + b.backlog = b.backlog[1:] + default: + } + } +} + +// get returns the channel that receives an item in the buffer. +// +// Upon receipt of an item, the caller should call load to send another +// item onto the channel if there is any. +func (b *recvBuffer) get() <-chan item { + return b.c +} + +// recvBufferReader implements io.Reader interface to read the data from +// recvBuffer. +type recvBufferReader struct { + ctx context.Context + goAway chan struct{} + recv *recvBuffer + last *bytes.Reader // Stores the remaining data in the previous calls. + err error +} + +// Read reads the next len(p) bytes from last. If last is drained, it tries to +// read additional data from recv. It blocks if there no additional data available +// in recv. If Read returns any non-nil error, it will continue to return that error. +func (r *recvBufferReader) Read(p []byte) (n int, err error) { + if r.err != nil { + return 0, r.err + } + defer func() { r.err = err }() + if r.last != nil && r.last.Len() > 0 { + // Read remaining data left in last call. + return r.last.Read(p) + } + select { + case <-r.ctx.Done(): + return 0, ContextErr(r.ctx.Err()) + case <-r.goAway: + return 0, ErrStreamDrain + case i := <-r.recv.get(): + r.recv.load() + m := i.(*recvMsg) + if m.err != nil { + return 0, m.err + } + r.last = bytes.NewReader(m.data) + return r.last.Read(p) + } +} + +type streamState uint8 + +const ( + streamActive streamState = iota + streamWriteDone // EndStream sent + streamReadDone // EndStream received + streamDone // the entire stream is finished. +) + +// Stream represents an RPC in the transport layer. +type Stream struct { + id uint32 + // nil for client side Stream. + st ServerTransport + // ctx is the associated context of the stream. + ctx context.Context + cancel context.CancelFunc + // done is closed when the final status arrives. + done chan struct{} + // goAway is closed when the server sent GoAways signal before this stream was initiated. + goAway chan struct{} + // method records the associated RPC method of the stream. + method string + recvCompress string + sendCompress string + buf *recvBuffer + dec io.Reader + fc *inFlow + recvQuota uint32 + // The accumulated inbound quota pending for window update. + updateQuota uint32 + // The handler to control the window update procedure for both this + // particular stream and the associated transport. + windowHandler func(int) + + sendQuotaPool *quotaPool + // Close headerChan to indicate the end of reception of header metadata. + headerChan chan struct{} + // header caches the received header metadata. + header metadata.MD + // The key-value map of trailer metadata. + trailer metadata.MD + + mu sync.RWMutex // guard the following + // headerOK becomes true from the first header is about to send. + headerOk bool + state streamState + // true iff headerChan is closed. Used to avoid closing headerChan + // multiple times. + headerDone bool + // the status received from the server. + statusCode codes.Code + statusDesc string +} + +// RecvCompress returns the compression algorithm applied to the inbound +// message. It is empty string if there is no compression applied. +func (s *Stream) RecvCompress() string { + return s.recvCompress +} + +// SetSendCompress sets the compression algorithm to the stream. +func (s *Stream) SetSendCompress(str string) { + s.sendCompress = str +} + +// Done returns a chanel which is closed when it receives the final status +// from the server. +func (s *Stream) Done() <-chan struct{} { + return s.done +} + +// GoAway returns a channel which is closed when the server sent GoAways signal +// before this stream was initiated. +func (s *Stream) GoAway() <-chan struct{} { + return s.goAway +} + +// Header acquires the key-value pairs of header metadata once it +// is available. It blocks until i) the metadata is ready or ii) there is no +// header metadata or iii) the stream is cancelled/expired. +func (s *Stream) Header() (metadata.MD, error) { + select { + case <-s.ctx.Done(): + return nil, ContextErr(s.ctx.Err()) + case <-s.goAway: + return nil, ErrStreamDrain + case <-s.headerChan: + return s.header.Copy(), nil + } +} + +// Trailer returns the cached trailer metedata. Note that if it is not called +// after the entire stream is done, it could return an empty MD. Client +// side only. +func (s *Stream) Trailer() metadata.MD { + s.mu.RLock() + defer s.mu.RUnlock() + return s.trailer.Copy() +} + +// ServerTransport returns the underlying ServerTransport for the stream. +// The client side stream always returns nil. +func (s *Stream) ServerTransport() ServerTransport { + return s.st +} + +// Context returns the context of the stream. +func (s *Stream) Context() context.Context { + return s.ctx +} + +// TraceContext recreates the context of s with a trace.Trace. +func (s *Stream) TraceContext(tr trace.Trace) { + s.ctx = trace.NewContext(s.ctx, tr) +} + +// Method returns the method for the stream. +func (s *Stream) Method() string { + return s.method +} + +// StatusCode returns statusCode received from the server. +func (s *Stream) StatusCode() codes.Code { + return s.statusCode +} + +// StatusDesc returns statusDesc received from the server. +func (s *Stream) StatusDesc() string { + return s.statusDesc +} + +// ErrIllegalTrailerSet indicates that the trailer has already been set or it +// is too late to do so. +var ErrIllegalTrailerSet = errors.New("transport: trailer has been set") + +// SetTrailer sets the trailer metadata which will be sent with the RPC status +// by the server. This can only be called at most once. Server side only. +func (s *Stream) SetTrailer(md metadata.MD) error { + s.mu.Lock() + defer s.mu.Unlock() + if s.trailer != nil { + return ErrIllegalTrailerSet + } + s.trailer = md.Copy() + return nil +} + +func (s *Stream) write(m recvMsg) { + s.buf.put(&m) +} + +// Read reads all the data available for this Stream from the transport and +// passes them into the decoder, which converts them into a gRPC message stream. +// The error is io.EOF when the stream is done or another non-nil error if +// the stream broke. +func (s *Stream) Read(p []byte) (n int, err error) { + n, err = s.dec.Read(p) + if err != nil { + return + } + s.windowHandler(n) + return +} + +// The key to save transport.Stream in the context. +type streamKey struct{} + +// newContextWithStream creates a new context from ctx and attaches stream +// to it. +func newContextWithStream(ctx context.Context, stream *Stream) context.Context { + return context.WithValue(ctx, streamKey{}, stream) +} + +// StreamFromContext returns the stream saved in ctx. +func StreamFromContext(ctx context.Context) (s *Stream, ok bool) { + s, ok = ctx.Value(streamKey{}).(*Stream) + return +} + +// state of transport +type transportState int + +const ( + reachable transportState = iota + unreachable + closing + draining +) + +// NewServerTransport creates a ServerTransport with conn or non-nil error +// if it fails. +func NewServerTransport(protocol string, conn net.Conn, maxStreams uint32, authInfo credentials.AuthInfo) (ServerTransport, error) { + return newHTTP2Server(conn, maxStreams, authInfo) +} + +// ConnectOptions covers all relevant options for dialing a server. +type ConnectOptions struct { + // UserAgent is the application user agent. + UserAgent string + // Dialer specifies how to dial a network address. + Dialer func(context.Context, string) (net.Conn, error) + // PerRPCCredentials stores the PerRPCCredentials required to issue RPCs. + PerRPCCredentials []credentials.PerRPCCredentials + // TransportCredentials stores the Authenticator required to setup a client connection. + TransportCredentials credentials.TransportCredentials +} + +// NewClientTransport establishes the transport with the required ConnectOptions +// and returns it to the caller. +func NewClientTransport(ctx context.Context, target string, opts ConnectOptions) (ClientTransport, error) { + return newHTTP2Client(ctx, target, opts) +} + +// Options provides additional hints and information for message +// transmission. +type Options struct { + // Last indicates whether this write is the last piece for + // this stream. + Last bool + + // Delay is a hint to the transport implementation for whether + // the data could be buffered for a batching write. The + // Transport implementation may ignore the hint. + Delay bool +} + +// CallHdr carries the information of a particular RPC. +type CallHdr struct { + // Host specifies the peer's host. + Host string + + // Method specifies the operation to perform. + Method string + + // RecvCompress specifies the compression algorithm applied on + // inbound messages. + RecvCompress string + + // SendCompress specifies the compression algorithm applied on + // outbound message. + SendCompress string + + // Flush indicates whether a new stream command should be sent + // to the peer without waiting for the first data. This is + // only a hint. The transport may modify the flush decision + // for performance purposes. + Flush bool +} + +// ClientTransport is the common interface for all gRPC client-side transport +// implementations. +type ClientTransport interface { + // Close tears down this transport. Once it returns, the transport + // should not be accessed any more. The caller must make sure this + // is called only once. + Close() error + + // GracefulClose starts to tear down the transport. It stops accepting + // new RPCs and wait the completion of the pending RPCs. + GracefulClose() error + + // Write sends the data for the given stream. A nil stream indicates + // the write is to be performed on the transport as a whole. + Write(s *Stream, data []byte, opts *Options) error + + // NewStream creates a Stream for an RPC. + NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error) + + // CloseStream clears the footprint of a stream when the stream is + // not needed any more. The err indicates the error incurred when + // CloseStream is called. Must be called when a stream is finished + // unless the associated transport is closing. + CloseStream(stream *Stream, err error) + + // Error returns a channel that is closed when some I/O error + // happens. Typically the caller should have a goroutine to monitor + // this in order to take action (e.g., close the current transport + // and create a new one) in error case. It should not return nil + // once the transport is initiated. + Error() <-chan struct{} + + // GoAway returns a channel that is closed when ClientTranspor + // receives the draining signal from the server (e.g., GOAWAY frame in + // HTTP/2). + GoAway() <-chan struct{} +} + +// ServerTransport is the common interface for all gRPC server-side transport +// implementations. +// +// Methods may be called concurrently from multiple goroutines, but +// Write methods for a given Stream will be called serially. +type ServerTransport interface { + // HandleStreams receives incoming streams using the given handler. + HandleStreams(func(*Stream)) + + // WriteHeader sends the header metadata for the given stream. + // WriteHeader may not be called on all streams. + WriteHeader(s *Stream, md metadata.MD) error + + // Write sends the data for the given stream. + // Write may not be called on all streams. + Write(s *Stream, data []byte, opts *Options) error + + // WriteStatus sends the status of a stream to the client. + // WriteStatus is the final call made on a stream and always + // occurs. + WriteStatus(s *Stream, statusCode codes.Code, statusDesc string) error + + // Close tears down the transport. Once it is called, the transport + // should not be accessed any more. All the pending streams and their + // handlers will be terminated asynchronously. + Close() error + + // RemoteAddr returns the remote network address. + RemoteAddr() net.Addr + + // Drain notifies the client this ServerTransport stops accepting new RPCs. + Drain() +} + +// StreamErrorf creates an StreamError with the specified error code and description. +func StreamErrorf(c codes.Code, format string, a ...interface{}) StreamError { + return StreamError{ + Code: c, + Desc: fmt.Sprintf(format, a...), + } +} + +// ConnectionErrorf creates an ConnectionError with the specified error description. +func ConnectionErrorf(temp bool, e error, format string, a ...interface{}) ConnectionError { + return ConnectionError{ + Desc: fmt.Sprintf(format, a...), + temp: temp, + err: e, + } +} + +// ConnectionError is an error that results in the termination of the +// entire connection and the retry of all the active streams. +type ConnectionError struct { + Desc string + temp bool + err error +} + +func (e ConnectionError) Error() string { + return fmt.Sprintf("connection error: desc = %q", e.Desc) +} + +// Temporary indicates if this connection error is temporary or fatal. +func (e ConnectionError) Temporary() bool { + return e.temp +} + +// Origin returns the original error of this connection error. +func (e ConnectionError) Origin() error { + // Never return nil error here. + // If the original error is nil, return itself. + if e.err == nil { + return e + } + return e.err +} + +var ( + // ErrConnClosing indicates that the transport is closing. + ErrConnClosing = ConnectionError{Desc: "transport is closing", temp: true} + // ErrStreamDrain indicates that the stream is rejected by the server because + // the server stops accepting new RPCs. + ErrStreamDrain = StreamErrorf(codes.Unavailable, "the server stops accepting new RPCs") +) + +// StreamError is an error that only affects one stream within a connection. +type StreamError struct { + Code codes.Code + Desc string +} + +func (e StreamError) Error() string { + return fmt.Sprintf("stream error: code = %d desc = %q", e.Code, e.Desc) +} + +// ContextErr converts the error from context package into a StreamError. +func ContextErr(err error) StreamError { + switch err { + case context.DeadlineExceeded: + return StreamErrorf(codes.DeadlineExceeded, "%v", err) + case context.Canceled: + return StreamErrorf(codes.Canceled, "%v", err) + } + panic(fmt.Sprintf("Unexpected error from context packet: %v", err)) +} + +// wait blocks until it can receive from ctx.Done, closing, or proceed. +// If it receives from ctx.Done, it returns 0, the StreamError for ctx.Err. +// If it receives from done, it returns 0, io.EOF if ctx is not done; otherwise +// it return the StreamError for ctx.Err. +// If it receives from goAway, it returns 0, ErrStreamDrain. +// If it receives from closing, it returns 0, ErrConnClosing. +// If it receives from proceed, it returns the received integer, nil. +func wait(ctx context.Context, done, goAway, closing <-chan struct{}, proceed <-chan int) (int, error) { + select { + case <-ctx.Done(): + return 0, ContextErr(ctx.Err()) + case <-done: + // User cancellation has precedence. + select { + case <-ctx.Done(): + return 0, ContextErr(ctx.Err()) + default: + } + return 0, io.EOF + case <-goAway: + return 0, ErrStreamDrain + case <-closing: + return 0, ErrConnClosing + case i := <-proceed: + return i, nil + } +} diff --git a/vendor/gopkg.in/yaml.v2/LICENSE b/vendor/gopkg.in/yaml.v2/LICENSE new file mode 100644 index 00000000..866d74a7 --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/LICENSE @@ -0,0 +1,13 @@ +Copyright 2011-2016 Canonical Ltd. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/vendor/gopkg.in/yaml.v2/LICENSE.libyaml b/vendor/gopkg.in/yaml.v2/LICENSE.libyaml new file mode 100644 index 00000000..8da58fbf --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/LICENSE.libyaml @@ -0,0 +1,31 @@ +The following files were ported to Go from C files of libyaml, and thus +are still covered by their original copyright and license: + + apic.go + emitterc.go + parserc.go + readerc.go + scannerc.go + writerc.go + yamlh.go + yamlprivateh.go + +Copyright (c) 2006 Kirill Simonov + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/gopkg.in/yaml.v2/apic.go b/vendor/gopkg.in/yaml.v2/apic.go new file mode 100644 index 00000000..95ec014e --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/apic.go @@ -0,0 +1,742 @@ +package yaml + +import ( + "io" + "os" +) + +func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) { + //fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens)) + + // Check if we can move the queue at the beginning of the buffer. + if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) { + if parser.tokens_head != len(parser.tokens) { + copy(parser.tokens, parser.tokens[parser.tokens_head:]) + } + parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head] + parser.tokens_head = 0 + } + parser.tokens = append(parser.tokens, *token) + if pos < 0 { + return + } + copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:]) + parser.tokens[parser.tokens_head+pos] = *token +} + +// Create a new parser object. +func yaml_parser_initialize(parser *yaml_parser_t) bool { + *parser = yaml_parser_t{ + raw_buffer: make([]byte, 0, input_raw_buffer_size), + buffer: make([]byte, 0, input_buffer_size), + } + return true +} + +// Destroy a parser object. +func yaml_parser_delete(parser *yaml_parser_t) { + *parser = yaml_parser_t{} +} + +// String read handler. +func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) { + if parser.input_pos == len(parser.input) { + return 0, io.EOF + } + n = copy(buffer, parser.input[parser.input_pos:]) + parser.input_pos += n + return n, nil +} + +// File read handler. +func yaml_file_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) { + return parser.input_file.Read(buffer) +} + +// Set a string input. +func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) { + if parser.read_handler != nil { + panic("must set the input source only once") + } + parser.read_handler = yaml_string_read_handler + parser.input = input + parser.input_pos = 0 +} + +// Set a file input. +func yaml_parser_set_input_file(parser *yaml_parser_t, file *os.File) { + if parser.read_handler != nil { + panic("must set the input source only once") + } + parser.read_handler = yaml_file_read_handler + parser.input_file = file +} + +// Set the source encoding. +func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) { + if parser.encoding != yaml_ANY_ENCODING { + panic("must set the encoding only once") + } + parser.encoding = encoding +} + +// Create a new emitter object. +func yaml_emitter_initialize(emitter *yaml_emitter_t) bool { + *emitter = yaml_emitter_t{ + buffer: make([]byte, output_buffer_size), + raw_buffer: make([]byte, 0, output_raw_buffer_size), + states: make([]yaml_emitter_state_t, 0, initial_stack_size), + events: make([]yaml_event_t, 0, initial_queue_size), + } + return true +} + +// Destroy an emitter object. +func yaml_emitter_delete(emitter *yaml_emitter_t) { + *emitter = yaml_emitter_t{} +} + +// String write handler. +func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error { + *emitter.output_buffer = append(*emitter.output_buffer, buffer...) + return nil +} + +// File write handler. +func yaml_file_write_handler(emitter *yaml_emitter_t, buffer []byte) error { + _, err := emitter.output_file.Write(buffer) + return err +} + +// Set a string output. +func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) { + if emitter.write_handler != nil { + panic("must set the output target only once") + } + emitter.write_handler = yaml_string_write_handler + emitter.output_buffer = output_buffer +} + +// Set a file output. +func yaml_emitter_set_output_file(emitter *yaml_emitter_t, file io.Writer) { + if emitter.write_handler != nil { + panic("must set the output target only once") + } + emitter.write_handler = yaml_file_write_handler + emitter.output_file = file +} + +// Set the output encoding. +func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) { + if emitter.encoding != yaml_ANY_ENCODING { + panic("must set the output encoding only once") + } + emitter.encoding = encoding +} + +// Set the canonical output style. +func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) { + emitter.canonical = canonical +} + +//// Set the indentation increment. +func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) { + if indent < 2 || indent > 9 { + indent = 2 + } + emitter.best_indent = indent +} + +// Set the preferred line width. +func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) { + if width < 0 { + width = -1 + } + emitter.best_width = width +} + +// Set if unescaped non-ASCII characters are allowed. +func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) { + emitter.unicode = unicode +} + +// Set the preferred line break character. +func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) { + emitter.line_break = line_break +} + +///* +// * Destroy a token object. +// */ +// +//YAML_DECLARE(void) +//yaml_token_delete(yaml_token_t *token) +//{ +// assert(token); // Non-NULL token object expected. +// +// switch (token.type) +// { +// case YAML_TAG_DIRECTIVE_TOKEN: +// yaml_free(token.data.tag_directive.handle); +// yaml_free(token.data.tag_directive.prefix); +// break; +// +// case YAML_ALIAS_TOKEN: +// yaml_free(token.data.alias.value); +// break; +// +// case YAML_ANCHOR_TOKEN: +// yaml_free(token.data.anchor.value); +// break; +// +// case YAML_TAG_TOKEN: +// yaml_free(token.data.tag.handle); +// yaml_free(token.data.tag.suffix); +// break; +// +// case YAML_SCALAR_TOKEN: +// yaml_free(token.data.scalar.value); +// break; +// +// default: +// break; +// } +// +// memset(token, 0, sizeof(yaml_token_t)); +//} +// +///* +// * Check if a string is a valid UTF-8 sequence. +// * +// * Check 'reader.c' for more details on UTF-8 encoding. +// */ +// +//static int +//yaml_check_utf8(yaml_char_t *start, size_t length) +//{ +// yaml_char_t *end = start+length; +// yaml_char_t *pointer = start; +// +// while (pointer < end) { +// unsigned char octet; +// unsigned int width; +// unsigned int value; +// size_t k; +// +// octet = pointer[0]; +// width = (octet & 0x80) == 0x00 ? 1 : +// (octet & 0xE0) == 0xC0 ? 2 : +// (octet & 0xF0) == 0xE0 ? 3 : +// (octet & 0xF8) == 0xF0 ? 4 : 0; +// value = (octet & 0x80) == 0x00 ? octet & 0x7F : +// (octet & 0xE0) == 0xC0 ? octet & 0x1F : +// (octet & 0xF0) == 0xE0 ? octet & 0x0F : +// (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; +// if (!width) return 0; +// if (pointer+width > end) return 0; +// for (k = 1; k < width; k ++) { +// octet = pointer[k]; +// if ((octet & 0xC0) != 0x80) return 0; +// value = (value << 6) + (octet & 0x3F); +// } +// if (!((width == 1) || +// (width == 2 && value >= 0x80) || +// (width == 3 && value >= 0x800) || +// (width == 4 && value >= 0x10000))) return 0; +// +// pointer += width; +// } +// +// return 1; +//} +// + +// Create STREAM-START. +func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) bool { + *event = yaml_event_t{ + typ: yaml_STREAM_START_EVENT, + encoding: encoding, + } + return true +} + +// Create STREAM-END. +func yaml_stream_end_event_initialize(event *yaml_event_t) bool { + *event = yaml_event_t{ + typ: yaml_STREAM_END_EVENT, + } + return true +} + +// Create DOCUMENT-START. +func yaml_document_start_event_initialize(event *yaml_event_t, version_directive *yaml_version_directive_t, + tag_directives []yaml_tag_directive_t, implicit bool) bool { + *event = yaml_event_t{ + typ: yaml_DOCUMENT_START_EVENT, + version_directive: version_directive, + tag_directives: tag_directives, + implicit: implicit, + } + return true +} + +// Create DOCUMENT-END. +func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) bool { + *event = yaml_event_t{ + typ: yaml_DOCUMENT_END_EVENT, + implicit: implicit, + } + return true +} + +///* +// * Create ALIAS. +// */ +// +//YAML_DECLARE(int) +//yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t) +//{ +// mark yaml_mark_t = { 0, 0, 0 } +// anchor_copy *yaml_char_t = NULL +// +// assert(event) // Non-NULL event object is expected. +// assert(anchor) // Non-NULL anchor is expected. +// +// if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0 +// +// anchor_copy = yaml_strdup(anchor) +// if (!anchor_copy) +// return 0 +// +// ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark) +// +// return 1 +//} + +// Create SCALAR. +func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool { + *event = yaml_event_t{ + typ: yaml_SCALAR_EVENT, + anchor: anchor, + tag: tag, + value: value, + implicit: plain_implicit, + quoted_implicit: quoted_implicit, + style: yaml_style_t(style), + } + return true +} + +// Create SEQUENCE-START. +func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool { + *event = yaml_event_t{ + typ: yaml_SEQUENCE_START_EVENT, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(style), + } + return true +} + +// Create SEQUENCE-END. +func yaml_sequence_end_event_initialize(event *yaml_event_t) bool { + *event = yaml_event_t{ + typ: yaml_SEQUENCE_END_EVENT, + } + return true +} + +// Create MAPPING-START. +func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) bool { + *event = yaml_event_t{ + typ: yaml_MAPPING_START_EVENT, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(style), + } + return true +} + +// Create MAPPING-END. +func yaml_mapping_end_event_initialize(event *yaml_event_t) bool { + *event = yaml_event_t{ + typ: yaml_MAPPING_END_EVENT, + } + return true +} + +// Destroy an event object. +func yaml_event_delete(event *yaml_event_t) { + *event = yaml_event_t{} +} + +///* +// * Create a document object. +// */ +// +//YAML_DECLARE(int) +//yaml_document_initialize(document *yaml_document_t, +// version_directive *yaml_version_directive_t, +// tag_directives_start *yaml_tag_directive_t, +// tag_directives_end *yaml_tag_directive_t, +// start_implicit int, end_implicit int) +//{ +// struct { +// error yaml_error_type_t +// } context +// struct { +// start *yaml_node_t +// end *yaml_node_t +// top *yaml_node_t +// } nodes = { NULL, NULL, NULL } +// version_directive_copy *yaml_version_directive_t = NULL +// struct { +// start *yaml_tag_directive_t +// end *yaml_tag_directive_t +// top *yaml_tag_directive_t +// } tag_directives_copy = { NULL, NULL, NULL } +// value yaml_tag_directive_t = { NULL, NULL } +// mark yaml_mark_t = { 0, 0, 0 } +// +// assert(document) // Non-NULL document object is expected. +// assert((tag_directives_start && tag_directives_end) || +// (tag_directives_start == tag_directives_end)) +// // Valid tag directives are expected. +// +// if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error +// +// if (version_directive) { +// version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t)) +// if (!version_directive_copy) goto error +// version_directive_copy.major = version_directive.major +// version_directive_copy.minor = version_directive.minor +// } +// +// if (tag_directives_start != tag_directives_end) { +// tag_directive *yaml_tag_directive_t +// if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE)) +// goto error +// for (tag_directive = tag_directives_start +// tag_directive != tag_directives_end; tag_directive ++) { +// assert(tag_directive.handle) +// assert(tag_directive.prefix) +// if (!yaml_check_utf8(tag_directive.handle, +// strlen((char *)tag_directive.handle))) +// goto error +// if (!yaml_check_utf8(tag_directive.prefix, +// strlen((char *)tag_directive.prefix))) +// goto error +// value.handle = yaml_strdup(tag_directive.handle) +// value.prefix = yaml_strdup(tag_directive.prefix) +// if (!value.handle || !value.prefix) goto error +// if (!PUSH(&context, tag_directives_copy, value)) +// goto error +// value.handle = NULL +// value.prefix = NULL +// } +// } +// +// DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy, +// tag_directives_copy.start, tag_directives_copy.top, +// start_implicit, end_implicit, mark, mark) +// +// return 1 +// +//error: +// STACK_DEL(&context, nodes) +// yaml_free(version_directive_copy) +// while (!STACK_EMPTY(&context, tag_directives_copy)) { +// value yaml_tag_directive_t = POP(&context, tag_directives_copy) +// yaml_free(value.handle) +// yaml_free(value.prefix) +// } +// STACK_DEL(&context, tag_directives_copy) +// yaml_free(value.handle) +// yaml_free(value.prefix) +// +// return 0 +//} +// +///* +// * Destroy a document object. +// */ +// +//YAML_DECLARE(void) +//yaml_document_delete(document *yaml_document_t) +//{ +// struct { +// error yaml_error_type_t +// } context +// tag_directive *yaml_tag_directive_t +// +// context.error = YAML_NO_ERROR // Eliminate a compliler warning. +// +// assert(document) // Non-NULL document object is expected. +// +// while (!STACK_EMPTY(&context, document.nodes)) { +// node yaml_node_t = POP(&context, document.nodes) +// yaml_free(node.tag) +// switch (node.type) { +// case YAML_SCALAR_NODE: +// yaml_free(node.data.scalar.value) +// break +// case YAML_SEQUENCE_NODE: +// STACK_DEL(&context, node.data.sequence.items) +// break +// case YAML_MAPPING_NODE: +// STACK_DEL(&context, node.data.mapping.pairs) +// break +// default: +// assert(0) // Should not happen. +// } +// } +// STACK_DEL(&context, document.nodes) +// +// yaml_free(document.version_directive) +// for (tag_directive = document.tag_directives.start +// tag_directive != document.tag_directives.end +// tag_directive++) { +// yaml_free(tag_directive.handle) +// yaml_free(tag_directive.prefix) +// } +// yaml_free(document.tag_directives.start) +// +// memset(document, 0, sizeof(yaml_document_t)) +//} +// +///** +// * Get a document node. +// */ +// +//YAML_DECLARE(yaml_node_t *) +//yaml_document_get_node(document *yaml_document_t, index int) +//{ +// assert(document) // Non-NULL document object is expected. +// +// if (index > 0 && document.nodes.start + index <= document.nodes.top) { +// return document.nodes.start + index - 1 +// } +// return NULL +//} +// +///** +// * Get the root object. +// */ +// +//YAML_DECLARE(yaml_node_t *) +//yaml_document_get_root_node(document *yaml_document_t) +//{ +// assert(document) // Non-NULL document object is expected. +// +// if (document.nodes.top != document.nodes.start) { +// return document.nodes.start +// } +// return NULL +//} +// +///* +// * Add a scalar node to a document. +// */ +// +//YAML_DECLARE(int) +//yaml_document_add_scalar(document *yaml_document_t, +// tag *yaml_char_t, value *yaml_char_t, length int, +// style yaml_scalar_style_t) +//{ +// struct { +// error yaml_error_type_t +// } context +// mark yaml_mark_t = { 0, 0, 0 } +// tag_copy *yaml_char_t = NULL +// value_copy *yaml_char_t = NULL +// node yaml_node_t +// +// assert(document) // Non-NULL document object is expected. +// assert(value) // Non-NULL value is expected. +// +// if (!tag) { +// tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG +// } +// +// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error +// tag_copy = yaml_strdup(tag) +// if (!tag_copy) goto error +// +// if (length < 0) { +// length = strlen((char *)value) +// } +// +// if (!yaml_check_utf8(value, length)) goto error +// value_copy = yaml_malloc(length+1) +// if (!value_copy) goto error +// memcpy(value_copy, value, length) +// value_copy[length] = '\0' +// +// SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark) +// if (!PUSH(&context, document.nodes, node)) goto error +// +// return document.nodes.top - document.nodes.start +// +//error: +// yaml_free(tag_copy) +// yaml_free(value_copy) +// +// return 0 +//} +// +///* +// * Add a sequence node to a document. +// */ +// +//YAML_DECLARE(int) +//yaml_document_add_sequence(document *yaml_document_t, +// tag *yaml_char_t, style yaml_sequence_style_t) +//{ +// struct { +// error yaml_error_type_t +// } context +// mark yaml_mark_t = { 0, 0, 0 } +// tag_copy *yaml_char_t = NULL +// struct { +// start *yaml_node_item_t +// end *yaml_node_item_t +// top *yaml_node_item_t +// } items = { NULL, NULL, NULL } +// node yaml_node_t +// +// assert(document) // Non-NULL document object is expected. +// +// if (!tag) { +// tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG +// } +// +// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error +// tag_copy = yaml_strdup(tag) +// if (!tag_copy) goto error +// +// if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error +// +// SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end, +// style, mark, mark) +// if (!PUSH(&context, document.nodes, node)) goto error +// +// return document.nodes.top - document.nodes.start +// +//error: +// STACK_DEL(&context, items) +// yaml_free(tag_copy) +// +// return 0 +//} +// +///* +// * Add a mapping node to a document. +// */ +// +//YAML_DECLARE(int) +//yaml_document_add_mapping(document *yaml_document_t, +// tag *yaml_char_t, style yaml_mapping_style_t) +//{ +// struct { +// error yaml_error_type_t +// } context +// mark yaml_mark_t = { 0, 0, 0 } +// tag_copy *yaml_char_t = NULL +// struct { +// start *yaml_node_pair_t +// end *yaml_node_pair_t +// top *yaml_node_pair_t +// } pairs = { NULL, NULL, NULL } +// node yaml_node_t +// +// assert(document) // Non-NULL document object is expected. +// +// if (!tag) { +// tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG +// } +// +// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error +// tag_copy = yaml_strdup(tag) +// if (!tag_copy) goto error +// +// if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error +// +// MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end, +// style, mark, mark) +// if (!PUSH(&context, document.nodes, node)) goto error +// +// return document.nodes.top - document.nodes.start +// +//error: +// STACK_DEL(&context, pairs) +// yaml_free(tag_copy) +// +// return 0 +//} +// +///* +// * Append an item to a sequence node. +// */ +// +//YAML_DECLARE(int) +//yaml_document_append_sequence_item(document *yaml_document_t, +// sequence int, item int) +//{ +// struct { +// error yaml_error_type_t +// } context +// +// assert(document) // Non-NULL document is required. +// assert(sequence > 0 +// && document.nodes.start + sequence <= document.nodes.top) +// // Valid sequence id is required. +// assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE) +// // A sequence node is required. +// assert(item > 0 && document.nodes.start + item <= document.nodes.top) +// // Valid item id is required. +// +// if (!PUSH(&context, +// document.nodes.start[sequence-1].data.sequence.items, item)) +// return 0 +// +// return 1 +//} +// +///* +// * Append a pair of a key and a value to a mapping node. +// */ +// +//YAML_DECLARE(int) +//yaml_document_append_mapping_pair(document *yaml_document_t, +// mapping int, key int, value int) +//{ +// struct { +// error yaml_error_type_t +// } context +// +// pair yaml_node_pair_t +// +// assert(document) // Non-NULL document is required. +// assert(mapping > 0 +// && document.nodes.start + mapping <= document.nodes.top) +// // Valid mapping id is required. +// assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE) +// // A mapping node is required. +// assert(key > 0 && document.nodes.start + key <= document.nodes.top) +// // Valid key id is required. +// assert(value > 0 && document.nodes.start + value <= document.nodes.top) +// // Valid value id is required. +// +// pair.key = key +// pair.value = value +// +// if (!PUSH(&context, +// document.nodes.start[mapping-1].data.mapping.pairs, pair)) +// return 0 +// +// return 1 +//} +// +// diff --git a/vendor/gopkg.in/yaml.v2/decode.go b/vendor/gopkg.in/yaml.v2/decode.go new file mode 100644 index 00000000..085cddc4 --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/decode.go @@ -0,0 +1,683 @@ +package yaml + +import ( + "encoding" + "encoding/base64" + "fmt" + "math" + "reflect" + "strconv" + "time" +) + +const ( + documentNode = 1 << iota + mappingNode + sequenceNode + scalarNode + aliasNode +) + +type node struct { + kind int + line, column int + tag string + value string + implicit bool + children []*node + anchors map[string]*node +} + +// ---------------------------------------------------------------------------- +// Parser, produces a node tree out of a libyaml event stream. + +type parser struct { + parser yaml_parser_t + event yaml_event_t + doc *node +} + +func newParser(b []byte) *parser { + p := parser{} + if !yaml_parser_initialize(&p.parser) { + panic("failed to initialize YAML emitter") + } + + if len(b) == 0 { + b = []byte{'\n'} + } + + yaml_parser_set_input_string(&p.parser, b) + + p.skip() + if p.event.typ != yaml_STREAM_START_EVENT { + panic("expected stream start event, got " + strconv.Itoa(int(p.event.typ))) + } + p.skip() + return &p +} + +func (p *parser) destroy() { + if p.event.typ != yaml_NO_EVENT { + yaml_event_delete(&p.event) + } + yaml_parser_delete(&p.parser) +} + +func (p *parser) skip() { + if p.event.typ != yaml_NO_EVENT { + if p.event.typ == yaml_STREAM_END_EVENT { + failf("attempted to go past the end of stream; corrupted value?") + } + yaml_event_delete(&p.event) + } + if !yaml_parser_parse(&p.parser, &p.event) { + p.fail() + } +} + +func (p *parser) fail() { + var where string + var line int + if p.parser.problem_mark.line != 0 { + line = p.parser.problem_mark.line + } else if p.parser.context_mark.line != 0 { + line = p.parser.context_mark.line + } + if line != 0 { + where = "line " + strconv.Itoa(line) + ": " + } + var msg string + if len(p.parser.problem) > 0 { + msg = p.parser.problem + } else { + msg = "unknown problem parsing YAML content" + } + failf("%s%s", where, msg) +} + +func (p *parser) anchor(n *node, anchor []byte) { + if anchor != nil { + p.doc.anchors[string(anchor)] = n + } +} + +func (p *parser) parse() *node { + switch p.event.typ { + case yaml_SCALAR_EVENT: + return p.scalar() + case yaml_ALIAS_EVENT: + return p.alias() + case yaml_MAPPING_START_EVENT: + return p.mapping() + case yaml_SEQUENCE_START_EVENT: + return p.sequence() + case yaml_DOCUMENT_START_EVENT: + return p.document() + case yaml_STREAM_END_EVENT: + // Happens when attempting to decode an empty buffer. + return nil + default: + panic("attempted to parse unknown event: " + strconv.Itoa(int(p.event.typ))) + } + panic("unreachable") +} + +func (p *parser) node(kind int) *node { + return &node{ + kind: kind, + line: p.event.start_mark.line, + column: p.event.start_mark.column, + } +} + +func (p *parser) document() *node { + n := p.node(documentNode) + n.anchors = make(map[string]*node) + p.doc = n + p.skip() + n.children = append(n.children, p.parse()) + if p.event.typ != yaml_DOCUMENT_END_EVENT { + panic("expected end of document event but got " + strconv.Itoa(int(p.event.typ))) + } + p.skip() + return n +} + +func (p *parser) alias() *node { + n := p.node(aliasNode) + n.value = string(p.event.anchor) + p.skip() + return n +} + +func (p *parser) scalar() *node { + n := p.node(scalarNode) + n.value = string(p.event.value) + n.tag = string(p.event.tag) + n.implicit = p.event.implicit + p.anchor(n, p.event.anchor) + p.skip() + return n +} + +func (p *parser) sequence() *node { + n := p.node(sequenceNode) + p.anchor(n, p.event.anchor) + p.skip() + for p.event.typ != yaml_SEQUENCE_END_EVENT { + n.children = append(n.children, p.parse()) + } + p.skip() + return n +} + +func (p *parser) mapping() *node { + n := p.node(mappingNode) + p.anchor(n, p.event.anchor) + p.skip() + for p.event.typ != yaml_MAPPING_END_EVENT { + n.children = append(n.children, p.parse(), p.parse()) + } + p.skip() + return n +} + +// ---------------------------------------------------------------------------- +// Decoder, unmarshals a node into a provided value. + +type decoder struct { + doc *node + aliases map[string]bool + mapType reflect.Type + terrors []string +} + +var ( + mapItemType = reflect.TypeOf(MapItem{}) + durationType = reflect.TypeOf(time.Duration(0)) + defaultMapType = reflect.TypeOf(map[interface{}]interface{}{}) + ifaceType = defaultMapType.Elem() +) + +func newDecoder() *decoder { + d := &decoder{mapType: defaultMapType} + d.aliases = make(map[string]bool) + return d +} + +func (d *decoder) terror(n *node, tag string, out reflect.Value) { + if n.tag != "" { + tag = n.tag + } + value := n.value + if tag != yaml_SEQ_TAG && tag != yaml_MAP_TAG { + if len(value) > 10 { + value = " `" + value[:7] + "...`" + } else { + value = " `" + value + "`" + } + } + d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type())) +} + +func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) { + terrlen := len(d.terrors) + err := u.UnmarshalYAML(func(v interface{}) (err error) { + defer handleErr(&err) + d.unmarshal(n, reflect.ValueOf(v)) + if len(d.terrors) > terrlen { + issues := d.terrors[terrlen:] + d.terrors = d.terrors[:terrlen] + return &TypeError{issues} + } + return nil + }) + if e, ok := err.(*TypeError); ok { + d.terrors = append(d.terrors, e.Errors...) + return false + } + if err != nil { + fail(err) + } + return true +} + +// d.prepare initializes and dereferences pointers and calls UnmarshalYAML +// if a value is found to implement it. +// It returns the initialized and dereferenced out value, whether +// unmarshalling was already done by UnmarshalYAML, and if so whether +// its types unmarshalled appropriately. +// +// If n holds a null value, prepare returns before doing anything. +func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) { + if n.tag == yaml_NULL_TAG || n.kind == scalarNode && n.tag == "" && (n.value == "null" || n.value == "") { + return out, false, false + } + again := true + for again { + again = false + if out.Kind() == reflect.Ptr { + if out.IsNil() { + out.Set(reflect.New(out.Type().Elem())) + } + out = out.Elem() + again = true + } + if out.CanAddr() { + if u, ok := out.Addr().Interface().(Unmarshaler); ok { + good = d.callUnmarshaler(n, u) + return out, true, good + } + } + } + return out, false, false +} + +func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) { + switch n.kind { + case documentNode: + return d.document(n, out) + case aliasNode: + return d.alias(n, out) + } + out, unmarshaled, good := d.prepare(n, out) + if unmarshaled { + return good + } + switch n.kind { + case scalarNode: + good = d.scalar(n, out) + case mappingNode: + good = d.mapping(n, out) + case sequenceNode: + good = d.sequence(n, out) + default: + panic("internal error: unknown node kind: " + strconv.Itoa(n.kind)) + } + return good +} + +func (d *decoder) document(n *node, out reflect.Value) (good bool) { + if len(n.children) == 1 { + d.doc = n + d.unmarshal(n.children[0], out) + return true + } + return false +} + +func (d *decoder) alias(n *node, out reflect.Value) (good bool) { + an, ok := d.doc.anchors[n.value] + if !ok { + failf("unknown anchor '%s' referenced", n.value) + } + if d.aliases[n.value] { + failf("anchor '%s' value contains itself", n.value) + } + d.aliases[n.value] = true + good = d.unmarshal(an, out) + delete(d.aliases, n.value) + return good +} + +var zeroValue reflect.Value + +func resetMap(out reflect.Value) { + for _, k := range out.MapKeys() { + out.SetMapIndex(k, zeroValue) + } +} + +func (d *decoder) scalar(n *node, out reflect.Value) (good bool) { + var tag string + var resolved interface{} + if n.tag == "" && !n.implicit { + tag = yaml_STR_TAG + resolved = n.value + } else { + tag, resolved = resolve(n.tag, n.value) + if tag == yaml_BINARY_TAG { + data, err := base64.StdEncoding.DecodeString(resolved.(string)) + if err != nil { + failf("!!binary value contains invalid base64 data") + } + resolved = string(data) + } + } + if resolved == nil { + if out.Kind() == reflect.Map && !out.CanAddr() { + resetMap(out) + } else { + out.Set(reflect.Zero(out.Type())) + } + return true + } + if s, ok := resolved.(string); ok && out.CanAddr() { + if u, ok := out.Addr().Interface().(encoding.TextUnmarshaler); ok { + err := u.UnmarshalText([]byte(s)) + if err != nil { + fail(err) + } + return true + } + } + switch out.Kind() { + case reflect.String: + if tag == yaml_BINARY_TAG { + out.SetString(resolved.(string)) + good = true + } else if resolved != nil { + out.SetString(n.value) + good = true + } + case reflect.Interface: + if resolved == nil { + out.Set(reflect.Zero(out.Type())) + } else { + out.Set(reflect.ValueOf(resolved)) + } + good = true + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + switch resolved := resolved.(type) { + case int: + if !out.OverflowInt(int64(resolved)) { + out.SetInt(int64(resolved)) + good = true + } + case int64: + if !out.OverflowInt(resolved) { + out.SetInt(resolved) + good = true + } + case uint64: + if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) { + out.SetInt(int64(resolved)) + good = true + } + case float64: + if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) { + out.SetInt(int64(resolved)) + good = true + } + case string: + if out.Type() == durationType { + d, err := time.ParseDuration(resolved) + if err == nil { + out.SetInt(int64(d)) + good = true + } + } + } + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + switch resolved := resolved.(type) { + case int: + if resolved >= 0 && !out.OverflowUint(uint64(resolved)) { + out.SetUint(uint64(resolved)) + good = true + } + case int64: + if resolved >= 0 && !out.OverflowUint(uint64(resolved)) { + out.SetUint(uint64(resolved)) + good = true + } + case uint64: + if !out.OverflowUint(uint64(resolved)) { + out.SetUint(uint64(resolved)) + good = true + } + case float64: + if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) { + out.SetUint(uint64(resolved)) + good = true + } + } + case reflect.Bool: + switch resolved := resolved.(type) { + case bool: + out.SetBool(resolved) + good = true + } + case reflect.Float32, reflect.Float64: + switch resolved := resolved.(type) { + case int: + out.SetFloat(float64(resolved)) + good = true + case int64: + out.SetFloat(float64(resolved)) + good = true + case uint64: + out.SetFloat(float64(resolved)) + good = true + case float64: + out.SetFloat(resolved) + good = true + } + case reflect.Ptr: + if out.Type().Elem() == reflect.TypeOf(resolved) { + // TODO DOes this make sense? When is out a Ptr except when decoding a nil value? + elem := reflect.New(out.Type().Elem()) + elem.Elem().Set(reflect.ValueOf(resolved)) + out.Set(elem) + good = true + } + } + if !good { + d.terror(n, tag, out) + } + return good +} + +func settableValueOf(i interface{}) reflect.Value { + v := reflect.ValueOf(i) + sv := reflect.New(v.Type()).Elem() + sv.Set(v) + return sv +} + +func (d *decoder) sequence(n *node, out reflect.Value) (good bool) { + l := len(n.children) + + var iface reflect.Value + switch out.Kind() { + case reflect.Slice: + out.Set(reflect.MakeSlice(out.Type(), l, l)) + case reflect.Interface: + // No type hints. Will have to use a generic sequence. + iface = out + out = settableValueOf(make([]interface{}, l)) + default: + d.terror(n, yaml_SEQ_TAG, out) + return false + } + et := out.Type().Elem() + + j := 0 + for i := 0; i < l; i++ { + e := reflect.New(et).Elem() + if ok := d.unmarshal(n.children[i], e); ok { + out.Index(j).Set(e) + j++ + } + } + out.Set(out.Slice(0, j)) + if iface.IsValid() { + iface.Set(out) + } + return true +} + +func (d *decoder) mapping(n *node, out reflect.Value) (good bool) { + switch out.Kind() { + case reflect.Struct: + return d.mappingStruct(n, out) + case reflect.Slice: + return d.mappingSlice(n, out) + case reflect.Map: + // okay + case reflect.Interface: + if d.mapType.Kind() == reflect.Map { + iface := out + out = reflect.MakeMap(d.mapType) + iface.Set(out) + } else { + slicev := reflect.New(d.mapType).Elem() + if !d.mappingSlice(n, slicev) { + return false + } + out.Set(slicev) + return true + } + default: + d.terror(n, yaml_MAP_TAG, out) + return false + } + outt := out.Type() + kt := outt.Key() + et := outt.Elem() + + mapType := d.mapType + if outt.Key() == ifaceType && outt.Elem() == ifaceType { + d.mapType = outt + } + + if out.IsNil() { + out.Set(reflect.MakeMap(outt)) + } + l := len(n.children) + for i := 0; i < l; i += 2 { + if isMerge(n.children[i]) { + d.merge(n.children[i+1], out) + continue + } + k := reflect.New(kt).Elem() + if d.unmarshal(n.children[i], k) { + kkind := k.Kind() + if kkind == reflect.Interface { + kkind = k.Elem().Kind() + } + if kkind == reflect.Map || kkind == reflect.Slice { + failf("invalid map key: %#v", k.Interface()) + } + e := reflect.New(et).Elem() + if d.unmarshal(n.children[i+1], e) { + out.SetMapIndex(k, e) + } + } + } + d.mapType = mapType + return true +} + +func (d *decoder) mappingSlice(n *node, out reflect.Value) (good bool) { + outt := out.Type() + if outt.Elem() != mapItemType { + d.terror(n, yaml_MAP_TAG, out) + return false + } + + mapType := d.mapType + d.mapType = outt + + var slice []MapItem + var l = len(n.children) + for i := 0; i < l; i += 2 { + if isMerge(n.children[i]) { + d.merge(n.children[i+1], out) + continue + } + item := MapItem{} + k := reflect.ValueOf(&item.Key).Elem() + if d.unmarshal(n.children[i], k) { + v := reflect.ValueOf(&item.Value).Elem() + if d.unmarshal(n.children[i+1], v) { + slice = append(slice, item) + } + } + } + out.Set(reflect.ValueOf(slice)) + d.mapType = mapType + return true +} + +func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) { + sinfo, err := getStructInfo(out.Type()) + if err != nil { + panic(err) + } + name := settableValueOf("") + l := len(n.children) + + var inlineMap reflect.Value + var elemType reflect.Type + if sinfo.InlineMap != -1 { + inlineMap = out.Field(sinfo.InlineMap) + inlineMap.Set(reflect.New(inlineMap.Type()).Elem()) + elemType = inlineMap.Type().Elem() + } + + for i := 0; i < l; i += 2 { + ni := n.children[i] + if isMerge(ni) { + d.merge(n.children[i+1], out) + continue + } + if !d.unmarshal(ni, name) { + continue + } + if info, ok := sinfo.FieldsMap[name.String()]; ok { + var field reflect.Value + if info.Inline == nil { + field = out.Field(info.Num) + } else { + field = out.FieldByIndex(info.Inline) + } + d.unmarshal(n.children[i+1], field) + } else if sinfo.InlineMap != -1 { + if inlineMap.IsNil() { + inlineMap.Set(reflect.MakeMap(inlineMap.Type())) + } + value := reflect.New(elemType).Elem() + d.unmarshal(n.children[i+1], value) + inlineMap.SetMapIndex(name, value) + } + } + return true +} + +func failWantMap() { + failf("map merge requires map or sequence of maps as the value") +} + +func (d *decoder) merge(n *node, out reflect.Value) { + switch n.kind { + case mappingNode: + d.unmarshal(n, out) + case aliasNode: + an, ok := d.doc.anchors[n.value] + if ok && an.kind != mappingNode { + failWantMap() + } + d.unmarshal(n, out) + case sequenceNode: + // Step backwards as earlier nodes take precedence. + for i := len(n.children) - 1; i >= 0; i-- { + ni := n.children[i] + if ni.kind == aliasNode { + an, ok := d.doc.anchors[ni.value] + if ok && an.kind != mappingNode { + failWantMap() + } + } else if ni.kind != mappingNode { + failWantMap() + } + d.unmarshal(ni, out) + } + default: + failWantMap() + } +} + +func isMerge(n *node) bool { + return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG) +} diff --git a/vendor/gopkg.in/yaml.v2/emitterc.go b/vendor/gopkg.in/yaml.v2/emitterc.go new file mode 100644 index 00000000..2befd553 --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/emitterc.go @@ -0,0 +1,1685 @@ +package yaml + +import ( + "bytes" +) + +// Flush the buffer if needed. +func flush(emitter *yaml_emitter_t) bool { + if emitter.buffer_pos+5 >= len(emitter.buffer) { + return yaml_emitter_flush(emitter) + } + return true +} + +// Put a character to the output buffer. +func put(emitter *yaml_emitter_t, value byte) bool { + if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) { + return false + } + emitter.buffer[emitter.buffer_pos] = value + emitter.buffer_pos++ + emitter.column++ + return true +} + +// Put a line break to the output buffer. +func put_break(emitter *yaml_emitter_t) bool { + if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) { + return false + } + switch emitter.line_break { + case yaml_CR_BREAK: + emitter.buffer[emitter.buffer_pos] = '\r' + emitter.buffer_pos += 1 + case yaml_LN_BREAK: + emitter.buffer[emitter.buffer_pos] = '\n' + emitter.buffer_pos += 1 + case yaml_CRLN_BREAK: + emitter.buffer[emitter.buffer_pos+0] = '\r' + emitter.buffer[emitter.buffer_pos+1] = '\n' + emitter.buffer_pos += 2 + default: + panic("unknown line break setting") + } + emitter.column = 0 + emitter.line++ + return true +} + +// Copy a character from a string into buffer. +func write(emitter *yaml_emitter_t, s []byte, i *int) bool { + if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) { + return false + } + p := emitter.buffer_pos + w := width(s[*i]) + switch w { + case 4: + emitter.buffer[p+3] = s[*i+3] + fallthrough + case 3: + emitter.buffer[p+2] = s[*i+2] + fallthrough + case 2: + emitter.buffer[p+1] = s[*i+1] + fallthrough + case 1: + emitter.buffer[p+0] = s[*i+0] + default: + panic("unknown character width") + } + emitter.column++ + emitter.buffer_pos += w + *i += w + return true +} + +// Write a whole string into buffer. +func write_all(emitter *yaml_emitter_t, s []byte) bool { + for i := 0; i < len(s); { + if !write(emitter, s, &i) { + return false + } + } + return true +} + +// Copy a line break character from a string into buffer. +func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool { + if s[*i] == '\n' { + if !put_break(emitter) { + return false + } + *i++ + } else { + if !write(emitter, s, i) { + return false + } + emitter.column = 0 + emitter.line++ + } + return true +} + +// Set an emitter error and return false. +func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool { + emitter.error = yaml_EMITTER_ERROR + emitter.problem = problem + return false +} + +// Emit an event. +func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool { + emitter.events = append(emitter.events, *event) + for !yaml_emitter_need_more_events(emitter) { + event := &emitter.events[emitter.events_head] + if !yaml_emitter_analyze_event(emitter, event) { + return false + } + if !yaml_emitter_state_machine(emitter, event) { + return false + } + yaml_event_delete(event) + emitter.events_head++ + } + return true +} + +// Check if we need to accumulate more events before emitting. +// +// We accumulate extra +// - 1 event for DOCUMENT-START +// - 2 events for SEQUENCE-START +// - 3 events for MAPPING-START +// +func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool { + if emitter.events_head == len(emitter.events) { + return true + } + var accumulate int + switch emitter.events[emitter.events_head].typ { + case yaml_DOCUMENT_START_EVENT: + accumulate = 1 + break + case yaml_SEQUENCE_START_EVENT: + accumulate = 2 + break + case yaml_MAPPING_START_EVENT: + accumulate = 3 + break + default: + return false + } + if len(emitter.events)-emitter.events_head > accumulate { + return false + } + var level int + for i := emitter.events_head; i < len(emitter.events); i++ { + switch emitter.events[i].typ { + case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT: + level++ + case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT: + level-- + } + if level == 0 { + return false + } + } + return true +} + +// Append a directive to the directives stack. +func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, value *yaml_tag_directive_t, allow_duplicates bool) bool { + for i := 0; i < len(emitter.tag_directives); i++ { + if bytes.Equal(value.handle, emitter.tag_directives[i].handle) { + if allow_duplicates { + return true + } + return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive") + } + } + + // [Go] Do we actually need to copy this given garbage collection + // and the lack of deallocating destructors? + tag_copy := yaml_tag_directive_t{ + handle: make([]byte, len(value.handle)), + prefix: make([]byte, len(value.prefix)), + } + copy(tag_copy.handle, value.handle) + copy(tag_copy.prefix, value.prefix) + emitter.tag_directives = append(emitter.tag_directives, tag_copy) + return true +} + +// Increase the indentation level. +func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool { + emitter.indents = append(emitter.indents, emitter.indent) + if emitter.indent < 0 { + if flow { + emitter.indent = emitter.best_indent + } else { + emitter.indent = 0 + } + } else if !indentless { + emitter.indent += emitter.best_indent + } + return true +} + +// State dispatcher. +func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool { + switch emitter.state { + default: + case yaml_EMIT_STREAM_START_STATE: + return yaml_emitter_emit_stream_start(emitter, event) + + case yaml_EMIT_FIRST_DOCUMENT_START_STATE: + return yaml_emitter_emit_document_start(emitter, event, true) + + case yaml_EMIT_DOCUMENT_START_STATE: + return yaml_emitter_emit_document_start(emitter, event, false) + + case yaml_EMIT_DOCUMENT_CONTENT_STATE: + return yaml_emitter_emit_document_content(emitter, event) + + case yaml_EMIT_DOCUMENT_END_STATE: + return yaml_emitter_emit_document_end(emitter, event) + + case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE: + return yaml_emitter_emit_flow_sequence_item(emitter, event, true) + + case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE: + return yaml_emitter_emit_flow_sequence_item(emitter, event, false) + + case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE: + return yaml_emitter_emit_flow_mapping_key(emitter, event, true) + + case yaml_EMIT_FLOW_MAPPING_KEY_STATE: + return yaml_emitter_emit_flow_mapping_key(emitter, event, false) + + case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE: + return yaml_emitter_emit_flow_mapping_value(emitter, event, true) + + case yaml_EMIT_FLOW_MAPPING_VALUE_STATE: + return yaml_emitter_emit_flow_mapping_value(emitter, event, false) + + case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE: + return yaml_emitter_emit_block_sequence_item(emitter, event, true) + + case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE: + return yaml_emitter_emit_block_sequence_item(emitter, event, false) + + case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE: + return yaml_emitter_emit_block_mapping_key(emitter, event, true) + + case yaml_EMIT_BLOCK_MAPPING_KEY_STATE: + return yaml_emitter_emit_block_mapping_key(emitter, event, false) + + case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE: + return yaml_emitter_emit_block_mapping_value(emitter, event, true) + + case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE: + return yaml_emitter_emit_block_mapping_value(emitter, event, false) + + case yaml_EMIT_END_STATE: + return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END") + } + panic("invalid emitter state") +} + +// Expect STREAM-START. +func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool { + if event.typ != yaml_STREAM_START_EVENT { + return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START") + } + if emitter.encoding == yaml_ANY_ENCODING { + emitter.encoding = event.encoding + if emitter.encoding == yaml_ANY_ENCODING { + emitter.encoding = yaml_UTF8_ENCODING + } + } + if emitter.best_indent < 2 || emitter.best_indent > 9 { + emitter.best_indent = 2 + } + if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 { + emitter.best_width = 80 + } + if emitter.best_width < 0 { + emitter.best_width = 1<<31 - 1 + } + if emitter.line_break == yaml_ANY_BREAK { + emitter.line_break = yaml_LN_BREAK + } + + emitter.indent = -1 + emitter.line = 0 + emitter.column = 0 + emitter.whitespace = true + emitter.indention = true + + if emitter.encoding != yaml_UTF8_ENCODING { + if !yaml_emitter_write_bom(emitter) { + return false + } + } + emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE + return true +} + +// Expect DOCUMENT-START or STREAM-END. +func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { + + if event.typ == yaml_DOCUMENT_START_EVENT { + + if event.version_directive != nil { + if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) { + return false + } + } + + for i := 0; i < len(event.tag_directives); i++ { + tag_directive := &event.tag_directives[i] + if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) { + return false + } + if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) { + return false + } + } + + for i := 0; i < len(default_tag_directives); i++ { + tag_directive := &default_tag_directives[i] + if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) { + return false + } + } + + implicit := event.implicit + if !first || emitter.canonical { + implicit = false + } + + if emitter.open_ended && (event.version_directive != nil || len(event.tag_directives) > 0) { + if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + + if event.version_directive != nil { + implicit = false + if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) { + return false + } + if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + + if len(event.tag_directives) > 0 { + implicit = false + for i := 0; i < len(event.tag_directives); i++ { + tag_directive := &event.tag_directives[i] + if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) { + return false + } + if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) { + return false + } + if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + } + + if yaml_emitter_check_empty_document(emitter) { + implicit = false + } + if !implicit { + if !yaml_emitter_write_indent(emitter) { + return false + } + if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) { + return false + } + if emitter.canonical { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + } + + emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE + return true + } + + if event.typ == yaml_STREAM_END_EVENT { + if emitter.open_ended { + if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !yaml_emitter_flush(emitter) { + return false + } + emitter.state = yaml_EMIT_END_STATE + return true + } + + return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END") +} + +// Expect the root node. +func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool { + emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE) + return yaml_emitter_emit_node(emitter, event, true, false, false, false) +} + +// Expect DOCUMENT-END. +func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool { + if event.typ != yaml_DOCUMENT_END_EVENT { + return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END") + } + if !yaml_emitter_write_indent(emitter) { + return false + } + if !event.implicit { + // [Go] Allocate the slice elsewhere. + if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !yaml_emitter_flush(emitter) { + return false + } + emitter.state = yaml_EMIT_DOCUMENT_START_STATE + emitter.tag_directives = emitter.tag_directives[:0] + return true +} + +// Expect a flow item node. +func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { + if first { + if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) { + return false + } + if !yaml_emitter_increase_indent(emitter, true, false) { + return false + } + emitter.flow_level++ + } + + if event.typ == yaml_SEQUENCE_END_EVENT { + emitter.flow_level-- + emitter.indent = emitter.indents[len(emitter.indents)-1] + emitter.indents = emitter.indents[:len(emitter.indents)-1] + if emitter.canonical && !first { + if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) { + return false + } + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + + return true + } + + if !first { + if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) { + return false + } + } + + if emitter.canonical || emitter.column > emitter.best_width { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE) + return yaml_emitter_emit_node(emitter, event, false, true, false, false) +} + +// Expect a flow key node. +func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { + if first { + if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) { + return false + } + if !yaml_emitter_increase_indent(emitter, true, false) { + return false + } + emitter.flow_level++ + } + + if event.typ == yaml_MAPPING_END_EVENT { + emitter.flow_level-- + emitter.indent = emitter.indents[len(emitter.indents)-1] + emitter.indents = emitter.indents[:len(emitter.indents)-1] + if emitter.canonical && !first { + if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) { + return false + } + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) { + return false + } + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + return true + } + + if !first { + if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) { + return false + } + } + if emitter.canonical || emitter.column > emitter.best_width { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + + if !emitter.canonical && yaml_emitter_check_simple_key(emitter) { + emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE) + return yaml_emitter_emit_node(emitter, event, false, false, true, true) + } + if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) { + return false + } + emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE) + return yaml_emitter_emit_node(emitter, event, false, false, true, false) +} + +// Expect a flow value node. +func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool { + if simple { + if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) { + return false + } + } else { + if emitter.canonical || emitter.column > emitter.best_width { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) { + return false + } + } + emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE) + return yaml_emitter_emit_node(emitter, event, false, false, true, false) +} + +// Expect a block item node. +func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { + if first { + if !yaml_emitter_increase_indent(emitter, false, emitter.mapping_context && !emitter.indention) { + return false + } + } + if event.typ == yaml_SEQUENCE_END_EVENT { + emitter.indent = emitter.indents[len(emitter.indents)-1] + emitter.indents = emitter.indents[:len(emitter.indents)-1] + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + return true + } + if !yaml_emitter_write_indent(emitter) { + return false + } + if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) { + return false + } + emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE) + return yaml_emitter_emit_node(emitter, event, false, true, false, false) +} + +// Expect a block key node. +func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { + if first { + if !yaml_emitter_increase_indent(emitter, false, false) { + return false + } + } + if event.typ == yaml_MAPPING_END_EVENT { + emitter.indent = emitter.indents[len(emitter.indents)-1] + emitter.indents = emitter.indents[:len(emitter.indents)-1] + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + return true + } + if !yaml_emitter_write_indent(emitter) { + return false + } + if yaml_emitter_check_simple_key(emitter) { + emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE) + return yaml_emitter_emit_node(emitter, event, false, false, true, true) + } + if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) { + return false + } + emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE) + return yaml_emitter_emit_node(emitter, event, false, false, true, false) +} + +// Expect a block value node. +func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool { + if simple { + if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) { + return false + } + } else { + if !yaml_emitter_write_indent(emitter) { + return false + } + if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) { + return false + } + } + emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE) + return yaml_emitter_emit_node(emitter, event, false, false, true, false) +} + +// Expect a node. +func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t, + root bool, sequence bool, mapping bool, simple_key bool) bool { + + emitter.root_context = root + emitter.sequence_context = sequence + emitter.mapping_context = mapping + emitter.simple_key_context = simple_key + + switch event.typ { + case yaml_ALIAS_EVENT: + return yaml_emitter_emit_alias(emitter, event) + case yaml_SCALAR_EVENT: + return yaml_emitter_emit_scalar(emitter, event) + case yaml_SEQUENCE_START_EVENT: + return yaml_emitter_emit_sequence_start(emitter, event) + case yaml_MAPPING_START_EVENT: + return yaml_emitter_emit_mapping_start(emitter, event) + default: + return yaml_emitter_set_emitter_error(emitter, + "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS") + } + return false +} + +// Expect ALIAS. +func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool { + if !yaml_emitter_process_anchor(emitter) { + return false + } + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + return true +} + +// Expect SCALAR. +func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool { + if !yaml_emitter_select_scalar_style(emitter, event) { + return false + } + if !yaml_emitter_process_anchor(emitter) { + return false + } + if !yaml_emitter_process_tag(emitter) { + return false + } + if !yaml_emitter_increase_indent(emitter, true, false) { + return false + } + if !yaml_emitter_process_scalar(emitter) { + return false + } + emitter.indent = emitter.indents[len(emitter.indents)-1] + emitter.indents = emitter.indents[:len(emitter.indents)-1] + emitter.state = emitter.states[len(emitter.states)-1] + emitter.states = emitter.states[:len(emitter.states)-1] + return true +} + +// Expect SEQUENCE-START. +func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool { + if !yaml_emitter_process_anchor(emitter) { + return false + } + if !yaml_emitter_process_tag(emitter) { + return false + } + if emitter.flow_level > 0 || emitter.canonical || event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE || + yaml_emitter_check_empty_sequence(emitter) { + emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE + } else { + emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE + } + return true +} + +// Expect MAPPING-START. +func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool { + if !yaml_emitter_process_anchor(emitter) { + return false + } + if !yaml_emitter_process_tag(emitter) { + return false + } + if emitter.flow_level > 0 || emitter.canonical || event.mapping_style() == yaml_FLOW_MAPPING_STYLE || + yaml_emitter_check_empty_mapping(emitter) { + emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE + } else { + emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE + } + return true +} + +// Check if the document content is an empty scalar. +func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool { + return false // [Go] Huh? +} + +// Check if the next events represent an empty sequence. +func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool { + if len(emitter.events)-emitter.events_head < 2 { + return false + } + return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT && + emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT +} + +// Check if the next events represent an empty mapping. +func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool { + if len(emitter.events)-emitter.events_head < 2 { + return false + } + return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT && + emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT +} + +// Check if the next node can be expressed as a simple key. +func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool { + length := 0 + switch emitter.events[emitter.events_head].typ { + case yaml_ALIAS_EVENT: + length += len(emitter.anchor_data.anchor) + case yaml_SCALAR_EVENT: + if emitter.scalar_data.multiline { + return false + } + length += len(emitter.anchor_data.anchor) + + len(emitter.tag_data.handle) + + len(emitter.tag_data.suffix) + + len(emitter.scalar_data.value) + case yaml_SEQUENCE_START_EVENT: + if !yaml_emitter_check_empty_sequence(emitter) { + return false + } + length += len(emitter.anchor_data.anchor) + + len(emitter.tag_data.handle) + + len(emitter.tag_data.suffix) + case yaml_MAPPING_START_EVENT: + if !yaml_emitter_check_empty_mapping(emitter) { + return false + } + length += len(emitter.anchor_data.anchor) + + len(emitter.tag_data.handle) + + len(emitter.tag_data.suffix) + default: + return false + } + return length <= 128 +} + +// Determine an acceptable scalar style. +func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool { + + no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 + if no_tag && !event.implicit && !event.quoted_implicit { + return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified") + } + + style := event.scalar_style() + if style == yaml_ANY_SCALAR_STYLE { + style = yaml_PLAIN_SCALAR_STYLE + } + if emitter.canonical { + style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } + if emitter.simple_key_context && emitter.scalar_data.multiline { + style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } + + if style == yaml_PLAIN_SCALAR_STYLE { + if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed || + emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed { + style = yaml_SINGLE_QUOTED_SCALAR_STYLE + } + if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 || emitter.simple_key_context) { + style = yaml_SINGLE_QUOTED_SCALAR_STYLE + } + if no_tag && !event.implicit { + style = yaml_SINGLE_QUOTED_SCALAR_STYLE + } + } + if style == yaml_SINGLE_QUOTED_SCALAR_STYLE { + if !emitter.scalar_data.single_quoted_allowed { + style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } + } + if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE { + if !emitter.scalar_data.block_allowed || emitter.flow_level > 0 || emitter.simple_key_context { + style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } + } + + if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE { + emitter.tag_data.handle = []byte{'!'} + } + emitter.scalar_data.style = style + return true +} + +// Write an achor. +func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool { + if emitter.anchor_data.anchor == nil { + return true + } + c := []byte{'&'} + if emitter.anchor_data.alias { + c[0] = '*' + } + if !yaml_emitter_write_indicator(emitter, c, true, false, false) { + return false + } + return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor) +} + +// Write a tag. +func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool { + if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 { + return true + } + if len(emitter.tag_data.handle) > 0 { + if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) { + return false + } + if len(emitter.tag_data.suffix) > 0 { + if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) { + return false + } + } + } else { + // [Go] Allocate these slices elsewhere. + if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) { + return false + } + if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) { + return false + } + if !yaml_emitter_write_indicator(emitter, []byte{'>'}, false, false, false) { + return false + } + } + return true +} + +// Write a scalar. +func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool { + switch emitter.scalar_data.style { + case yaml_PLAIN_SCALAR_STYLE: + return yaml_emitter_write_plain_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context) + + case yaml_SINGLE_QUOTED_SCALAR_STYLE: + return yaml_emitter_write_single_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context) + + case yaml_DOUBLE_QUOTED_SCALAR_STYLE: + return yaml_emitter_write_double_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context) + + case yaml_LITERAL_SCALAR_STYLE: + return yaml_emitter_write_literal_scalar(emitter, emitter.scalar_data.value) + + case yaml_FOLDED_SCALAR_STYLE: + return yaml_emitter_write_folded_scalar(emitter, emitter.scalar_data.value) + } + panic("unknown scalar style") +} + +// Check if a %YAML directive is valid. +func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool { + if version_directive.major != 1 || version_directive.minor != 1 { + return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive") + } + return true +} + +// Check if a %TAG directive is valid. +func yaml_emitter_analyze_tag_directive(emitter *yaml_emitter_t, tag_directive *yaml_tag_directive_t) bool { + handle := tag_directive.handle + prefix := tag_directive.prefix + if len(handle) == 0 { + return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty") + } + if handle[0] != '!' { + return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'") + } + if handle[len(handle)-1] != '!' { + return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'") + } + for i := 1; i < len(handle)-1; i += width(handle[i]) { + if !is_alpha(handle, i) { + return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only") + } + } + if len(prefix) == 0 { + return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty") + } + return true +} + +// Check if an anchor is valid. +func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, anchor []byte, alias bool) bool { + if len(anchor) == 0 { + problem := "anchor value must not be empty" + if alias { + problem = "alias value must not be empty" + } + return yaml_emitter_set_emitter_error(emitter, problem) + } + for i := 0; i < len(anchor); i += width(anchor[i]) { + if !is_alpha(anchor, i) { + problem := "anchor value must contain alphanumerical characters only" + if alias { + problem = "alias value must contain alphanumerical characters only" + } + return yaml_emitter_set_emitter_error(emitter, problem) + } + } + emitter.anchor_data.anchor = anchor + emitter.anchor_data.alias = alias + return true +} + +// Check if a tag is valid. +func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool { + if len(tag) == 0 { + return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty") + } + for i := 0; i < len(emitter.tag_directives); i++ { + tag_directive := &emitter.tag_directives[i] + if bytes.HasPrefix(tag, tag_directive.prefix) { + emitter.tag_data.handle = tag_directive.handle + emitter.tag_data.suffix = tag[len(tag_directive.prefix):] + return true + } + } + emitter.tag_data.suffix = tag + return true +} + +// Check if a scalar is valid. +func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool { + var ( + block_indicators = false + flow_indicators = false + line_breaks = false + special_characters = false + + leading_space = false + leading_break = false + trailing_space = false + trailing_break = false + break_space = false + space_break = false + + preceeded_by_whitespace = false + followed_by_whitespace = false + previous_space = false + previous_break = false + ) + + emitter.scalar_data.value = value + + if len(value) == 0 { + emitter.scalar_data.multiline = false + emitter.scalar_data.flow_plain_allowed = false + emitter.scalar_data.block_plain_allowed = true + emitter.scalar_data.single_quoted_allowed = true + emitter.scalar_data.block_allowed = false + return true + } + + if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') || (value[0] == '.' && value[1] == '.' && value[2] == '.')) { + block_indicators = true + flow_indicators = true + } + + preceeded_by_whitespace = true + for i, w := 0, 0; i < len(value); i += w { + w = width(value[i]) + followed_by_whitespace = i+w >= len(value) || is_blank(value, i+w) + + if i == 0 { + switch value[i] { + case '#', ',', '[', ']', '{', '}', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`': + flow_indicators = true + block_indicators = true + case '?', ':': + flow_indicators = true + if followed_by_whitespace { + block_indicators = true + } + case '-': + if followed_by_whitespace { + flow_indicators = true + block_indicators = true + } + } + } else { + switch value[i] { + case ',', '?', '[', ']', '{', '}': + flow_indicators = true + case ':': + flow_indicators = true + if followed_by_whitespace { + block_indicators = true + } + case '#': + if preceeded_by_whitespace { + flow_indicators = true + block_indicators = true + } + } + } + + if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode { + special_characters = true + } + if is_space(value, i) { + if i == 0 { + leading_space = true + } + if i+width(value[i]) == len(value) { + trailing_space = true + } + if previous_break { + break_space = true + } + previous_space = true + previous_break = false + } else if is_break(value, i) { + line_breaks = true + if i == 0 { + leading_break = true + } + if i+width(value[i]) == len(value) { + trailing_break = true + } + if previous_space { + space_break = true + } + previous_space = false + previous_break = true + } else { + previous_space = false + previous_break = false + } + + // [Go]: Why 'z'? Couldn't be the end of the string as that's the loop condition. + preceeded_by_whitespace = is_blankz(value, i) + } + + emitter.scalar_data.multiline = line_breaks + emitter.scalar_data.flow_plain_allowed = true + emitter.scalar_data.block_plain_allowed = true + emitter.scalar_data.single_quoted_allowed = true + emitter.scalar_data.block_allowed = true + + if leading_space || leading_break || trailing_space || trailing_break { + emitter.scalar_data.flow_plain_allowed = false + emitter.scalar_data.block_plain_allowed = false + } + if trailing_space { + emitter.scalar_data.block_allowed = false + } + if break_space { + emitter.scalar_data.flow_plain_allowed = false + emitter.scalar_data.block_plain_allowed = false + emitter.scalar_data.single_quoted_allowed = false + } + if space_break || special_characters { + emitter.scalar_data.flow_plain_allowed = false + emitter.scalar_data.block_plain_allowed = false + emitter.scalar_data.single_quoted_allowed = false + emitter.scalar_data.block_allowed = false + } + if line_breaks { + emitter.scalar_data.flow_plain_allowed = false + emitter.scalar_data.block_plain_allowed = false + } + if flow_indicators { + emitter.scalar_data.flow_plain_allowed = false + } + if block_indicators { + emitter.scalar_data.block_plain_allowed = false + } + return true +} + +// Check if the event data is valid. +func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bool { + + emitter.anchor_data.anchor = nil + emitter.tag_data.handle = nil + emitter.tag_data.suffix = nil + emitter.scalar_data.value = nil + + switch event.typ { + case yaml_ALIAS_EVENT: + if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) { + return false + } + + case yaml_SCALAR_EVENT: + if len(event.anchor) > 0 { + if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) { + return false + } + } + if len(event.tag) > 0 && (emitter.canonical || (!event.implicit && !event.quoted_implicit)) { + if !yaml_emitter_analyze_tag(emitter, event.tag) { + return false + } + } + if !yaml_emitter_analyze_scalar(emitter, event.value) { + return false + } + + case yaml_SEQUENCE_START_EVENT: + if len(event.anchor) > 0 { + if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) { + return false + } + } + if len(event.tag) > 0 && (emitter.canonical || !event.implicit) { + if !yaml_emitter_analyze_tag(emitter, event.tag) { + return false + } + } + + case yaml_MAPPING_START_EVENT: + if len(event.anchor) > 0 { + if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) { + return false + } + } + if len(event.tag) > 0 && (emitter.canonical || !event.implicit) { + if !yaml_emitter_analyze_tag(emitter, event.tag) { + return false + } + } + } + return true +} + +// Write the BOM character. +func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool { + if !flush(emitter) { + return false + } + pos := emitter.buffer_pos + emitter.buffer[pos+0] = '\xEF' + emitter.buffer[pos+1] = '\xBB' + emitter.buffer[pos+2] = '\xBF' + emitter.buffer_pos += 3 + return true +} + +func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool { + indent := emitter.indent + if indent < 0 { + indent = 0 + } + if !emitter.indention || emitter.column > indent || (emitter.column == indent && !emitter.whitespace) { + if !put_break(emitter) { + return false + } + } + for emitter.column < indent { + if !put(emitter, ' ') { + return false + } + } + emitter.whitespace = true + emitter.indention = true + return true +} + +func yaml_emitter_write_indicator(emitter *yaml_emitter_t, indicator []byte, need_whitespace, is_whitespace, is_indention bool) bool { + if need_whitespace && !emitter.whitespace { + if !put(emitter, ' ') { + return false + } + } + if !write_all(emitter, indicator) { + return false + } + emitter.whitespace = is_whitespace + emitter.indention = (emitter.indention && is_indention) + emitter.open_ended = false + return true +} + +func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool { + if !write_all(emitter, value) { + return false + } + emitter.whitespace = false + emitter.indention = false + return true +} + +func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool { + if !emitter.whitespace { + if !put(emitter, ' ') { + return false + } + } + if !write_all(emitter, value) { + return false + } + emitter.whitespace = false + emitter.indention = false + return true +} + +func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_whitespace bool) bool { + if need_whitespace && !emitter.whitespace { + if !put(emitter, ' ') { + return false + } + } + for i := 0; i < len(value); { + var must_write bool + switch value[i] { + case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')', '[', ']': + must_write = true + default: + must_write = is_alpha(value, i) + } + if must_write { + if !write(emitter, value, &i) { + return false + } + } else { + w := width(value[i]) + for k := 0; k < w; k++ { + octet := value[i] + i++ + if !put(emitter, '%') { + return false + } + + c := octet >> 4 + if c < 10 { + c += '0' + } else { + c += 'A' - 10 + } + if !put(emitter, c) { + return false + } + + c = octet & 0x0f + if c < 10 { + c += '0' + } else { + c += 'A' - 10 + } + if !put(emitter, c) { + return false + } + } + } + } + emitter.whitespace = false + emitter.indention = false + return true +} + +func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool { + if !emitter.whitespace { + if !put(emitter, ' ') { + return false + } + } + + spaces := false + breaks := false + for i := 0; i < len(value); { + if is_space(value, i) { + if allow_breaks && !spaces && emitter.column > emitter.best_width && !is_space(value, i+1) { + if !yaml_emitter_write_indent(emitter) { + return false + } + i += width(value[i]) + } else { + if !write(emitter, value, &i) { + return false + } + } + spaces = true + } else if is_break(value, i) { + if !breaks && value[i] == '\n' { + if !put_break(emitter) { + return false + } + } + if !write_break(emitter, value, &i) { + return false + } + emitter.indention = true + breaks = true + } else { + if breaks { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !write(emitter, value, &i) { + return false + } + emitter.indention = false + spaces = false + breaks = false + } + } + + emitter.whitespace = false + emitter.indention = false + if emitter.root_context { + emitter.open_ended = true + } + + return true +} + +func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool { + + if !yaml_emitter_write_indicator(emitter, []byte{'\''}, true, false, false) { + return false + } + + spaces := false + breaks := false + for i := 0; i < len(value); { + if is_space(value, i) { + if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 && !is_space(value, i+1) { + if !yaml_emitter_write_indent(emitter) { + return false + } + i += width(value[i]) + } else { + if !write(emitter, value, &i) { + return false + } + } + spaces = true + } else if is_break(value, i) { + if !breaks && value[i] == '\n' { + if !put_break(emitter) { + return false + } + } + if !write_break(emitter, value, &i) { + return false + } + emitter.indention = true + breaks = true + } else { + if breaks { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if value[i] == '\'' { + if !put(emitter, '\'') { + return false + } + } + if !write(emitter, value, &i) { + return false + } + emitter.indention = false + spaces = false + breaks = false + } + } + if !yaml_emitter_write_indicator(emitter, []byte{'\''}, false, false, false) { + return false + } + emitter.whitespace = false + emitter.indention = false + return true +} + +func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool { + spaces := false + if !yaml_emitter_write_indicator(emitter, []byte{'"'}, true, false, false) { + return false + } + + for i := 0; i < len(value); { + if !is_printable(value, i) || (!emitter.unicode && !is_ascii(value, i)) || + is_bom(value, i) || is_break(value, i) || + value[i] == '"' || value[i] == '\\' { + + octet := value[i] + + var w int + var v rune + switch { + case octet&0x80 == 0x00: + w, v = 1, rune(octet&0x7F) + case octet&0xE0 == 0xC0: + w, v = 2, rune(octet&0x1F) + case octet&0xF0 == 0xE0: + w, v = 3, rune(octet&0x0F) + case octet&0xF8 == 0xF0: + w, v = 4, rune(octet&0x07) + } + for k := 1; k < w; k++ { + octet = value[i+k] + v = (v << 6) + (rune(octet) & 0x3F) + } + i += w + + if !put(emitter, '\\') { + return false + } + + var ok bool + switch v { + case 0x00: + ok = put(emitter, '0') + case 0x07: + ok = put(emitter, 'a') + case 0x08: + ok = put(emitter, 'b') + case 0x09: + ok = put(emitter, 't') + case 0x0A: + ok = put(emitter, 'n') + case 0x0b: + ok = put(emitter, 'v') + case 0x0c: + ok = put(emitter, 'f') + case 0x0d: + ok = put(emitter, 'r') + case 0x1b: + ok = put(emitter, 'e') + case 0x22: + ok = put(emitter, '"') + case 0x5c: + ok = put(emitter, '\\') + case 0x85: + ok = put(emitter, 'N') + case 0xA0: + ok = put(emitter, '_') + case 0x2028: + ok = put(emitter, 'L') + case 0x2029: + ok = put(emitter, 'P') + default: + if v <= 0xFF { + ok = put(emitter, 'x') + w = 2 + } else if v <= 0xFFFF { + ok = put(emitter, 'u') + w = 4 + } else { + ok = put(emitter, 'U') + w = 8 + } + for k := (w - 1) * 4; ok && k >= 0; k -= 4 { + digit := byte((v >> uint(k)) & 0x0F) + if digit < 10 { + ok = put(emitter, digit+'0') + } else { + ok = put(emitter, digit+'A'-10) + } + } + } + if !ok { + return false + } + spaces = false + } else if is_space(value, i) { + if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 { + if !yaml_emitter_write_indent(emitter) { + return false + } + if is_space(value, i+1) { + if !put(emitter, '\\') { + return false + } + } + i += width(value[i]) + } else if !write(emitter, value, &i) { + return false + } + spaces = true + } else { + if !write(emitter, value, &i) { + return false + } + spaces = false + } + } + if !yaml_emitter_write_indicator(emitter, []byte{'"'}, false, false, false) { + return false + } + emitter.whitespace = false + emitter.indention = false + return true +} + +func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool { + if is_space(value, 0) || is_break(value, 0) { + indent_hint := []byte{'0' + byte(emitter.best_indent)} + if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) { + return false + } + } + + emitter.open_ended = false + + var chomp_hint [1]byte + if len(value) == 0 { + chomp_hint[0] = '-' + } else { + i := len(value) - 1 + for value[i]&0xC0 == 0x80 { + i-- + } + if !is_break(value, i) { + chomp_hint[0] = '-' + } else if i == 0 { + chomp_hint[0] = '+' + emitter.open_ended = true + } else { + i-- + for value[i]&0xC0 == 0x80 { + i-- + } + if is_break(value, i) { + chomp_hint[0] = '+' + emitter.open_ended = true + } + } + } + if chomp_hint[0] != 0 { + if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) { + return false + } + } + return true +} + +func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool { + if !yaml_emitter_write_indicator(emitter, []byte{'|'}, true, false, false) { + return false + } + if !yaml_emitter_write_block_scalar_hints(emitter, value) { + return false + } + if !put_break(emitter) { + return false + } + emitter.indention = true + emitter.whitespace = true + breaks := true + for i := 0; i < len(value); { + if is_break(value, i) { + if !write_break(emitter, value, &i) { + return false + } + emitter.indention = true + breaks = true + } else { + if breaks { + if !yaml_emitter_write_indent(emitter) { + return false + } + } + if !write(emitter, value, &i) { + return false + } + emitter.indention = false + breaks = false + } + } + + return true +} + +func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool { + if !yaml_emitter_write_indicator(emitter, []byte{'>'}, true, false, false) { + return false + } + if !yaml_emitter_write_block_scalar_hints(emitter, value) { + return false + } + + if !put_break(emitter) { + return false + } + emitter.indention = true + emitter.whitespace = true + + breaks := true + leading_spaces := true + for i := 0; i < len(value); { + if is_break(value, i) { + if !breaks && !leading_spaces && value[i] == '\n' { + k := 0 + for is_break(value, k) { + k += width(value[k]) + } + if !is_blankz(value, k) { + if !put_break(emitter) { + return false + } + } + } + if !write_break(emitter, value, &i) { + return false + } + emitter.indention = true + breaks = true + } else { + if breaks { + if !yaml_emitter_write_indent(emitter) { + return false + } + leading_spaces = is_blank(value, i) + } + if !breaks && is_space(value, i) && !is_space(value, i+1) && emitter.column > emitter.best_width { + if !yaml_emitter_write_indent(emitter) { + return false + } + i += width(value[i]) + } else { + if !write(emitter, value, &i) { + return false + } + } + emitter.indention = false + breaks = false + } + } + return true +} diff --git a/vendor/gopkg.in/yaml.v2/encode.go b/vendor/gopkg.in/yaml.v2/encode.go new file mode 100644 index 00000000..84f84995 --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/encode.go @@ -0,0 +1,306 @@ +package yaml + +import ( + "encoding" + "fmt" + "reflect" + "regexp" + "sort" + "strconv" + "strings" + "time" +) + +type encoder struct { + emitter yaml_emitter_t + event yaml_event_t + out []byte + flow bool +} + +func newEncoder() (e *encoder) { + e = &encoder{} + e.must(yaml_emitter_initialize(&e.emitter)) + yaml_emitter_set_output_string(&e.emitter, &e.out) + yaml_emitter_set_unicode(&e.emitter, true) + e.must(yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)) + e.emit() + e.must(yaml_document_start_event_initialize(&e.event, nil, nil, true)) + e.emit() + return e +} + +func (e *encoder) finish() { + e.must(yaml_document_end_event_initialize(&e.event, true)) + e.emit() + e.emitter.open_ended = false + e.must(yaml_stream_end_event_initialize(&e.event)) + e.emit() +} + +func (e *encoder) destroy() { + yaml_emitter_delete(&e.emitter) +} + +func (e *encoder) emit() { + // This will internally delete the e.event value. + if !yaml_emitter_emit(&e.emitter, &e.event) && e.event.typ != yaml_DOCUMENT_END_EVENT && e.event.typ != yaml_STREAM_END_EVENT { + e.must(false) + } +} + +func (e *encoder) must(ok bool) { + if !ok { + msg := e.emitter.problem + if msg == "" { + msg = "unknown problem generating YAML content" + } + failf("%s", msg) + } +} + +func (e *encoder) marshal(tag string, in reflect.Value) { + if !in.IsValid() { + e.nilv() + return + } + iface := in.Interface() + if m, ok := iface.(Marshaler); ok { + v, err := m.MarshalYAML() + if err != nil { + fail(err) + } + if v == nil { + e.nilv() + return + } + in = reflect.ValueOf(v) + } else if m, ok := iface.(encoding.TextMarshaler); ok { + text, err := m.MarshalText() + if err != nil { + fail(err) + } + in = reflect.ValueOf(string(text)) + } + switch in.Kind() { + case reflect.Interface: + if in.IsNil() { + e.nilv() + } else { + e.marshal(tag, in.Elem()) + } + case reflect.Map: + e.mapv(tag, in) + case reflect.Ptr: + if in.IsNil() { + e.nilv() + } else { + e.marshal(tag, in.Elem()) + } + case reflect.Struct: + e.structv(tag, in) + case reflect.Slice: + if in.Type().Elem() == mapItemType { + e.itemsv(tag, in) + } else { + e.slicev(tag, in) + } + case reflect.String: + e.stringv(tag, in) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + if in.Type() == durationType { + e.stringv(tag, reflect.ValueOf(iface.(time.Duration).String())) + } else { + e.intv(tag, in) + } + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + e.uintv(tag, in) + case reflect.Float32, reflect.Float64: + e.floatv(tag, in) + case reflect.Bool: + e.boolv(tag, in) + default: + panic("cannot marshal type: " + in.Type().String()) + } +} + +func (e *encoder) mapv(tag string, in reflect.Value) { + e.mappingv(tag, func() { + keys := keyList(in.MapKeys()) + sort.Sort(keys) + for _, k := range keys { + e.marshal("", k) + e.marshal("", in.MapIndex(k)) + } + }) +} + +func (e *encoder) itemsv(tag string, in reflect.Value) { + e.mappingv(tag, func() { + slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem) + for _, item := range slice { + e.marshal("", reflect.ValueOf(item.Key)) + e.marshal("", reflect.ValueOf(item.Value)) + } + }) +} + +func (e *encoder) structv(tag string, in reflect.Value) { + sinfo, err := getStructInfo(in.Type()) + if err != nil { + panic(err) + } + e.mappingv(tag, func() { + for _, info := range sinfo.FieldsList { + var value reflect.Value + if info.Inline == nil { + value = in.Field(info.Num) + } else { + value = in.FieldByIndex(info.Inline) + } + if info.OmitEmpty && isZero(value) { + continue + } + e.marshal("", reflect.ValueOf(info.Key)) + e.flow = info.Flow + e.marshal("", value) + } + if sinfo.InlineMap >= 0 { + m := in.Field(sinfo.InlineMap) + if m.Len() > 0 { + e.flow = false + keys := keyList(m.MapKeys()) + sort.Sort(keys) + for _, k := range keys { + if _, found := sinfo.FieldsMap[k.String()]; found { + panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", k.String())) + } + e.marshal("", k) + e.flow = false + e.marshal("", m.MapIndex(k)) + } + } + } + }) +} + +func (e *encoder) mappingv(tag string, f func()) { + implicit := tag == "" + style := yaml_BLOCK_MAPPING_STYLE + if e.flow { + e.flow = false + style = yaml_FLOW_MAPPING_STYLE + } + e.must(yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)) + e.emit() + f() + e.must(yaml_mapping_end_event_initialize(&e.event)) + e.emit() +} + +func (e *encoder) slicev(tag string, in reflect.Value) { + implicit := tag == "" + style := yaml_BLOCK_SEQUENCE_STYLE + if e.flow { + e.flow = false + style = yaml_FLOW_SEQUENCE_STYLE + } + e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)) + e.emit() + n := in.Len() + for i := 0; i < n; i++ { + e.marshal("", in.Index(i)) + } + e.must(yaml_sequence_end_event_initialize(&e.event)) + e.emit() +} + +// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1. +// +// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported +// in YAML 1.2 and by this package, but these should be marshalled quoted for +// the time being for compatibility with other parsers. +func isBase60Float(s string) (result bool) { + // Fast path. + if s == "" { + return false + } + c := s[0] + if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 { + return false + } + // Do the full match. + return base60float.MatchString(s) +} + +// From http://yaml.org/type/float.html, except the regular expression there +// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix. +var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`) + +func (e *encoder) stringv(tag string, in reflect.Value) { + var style yaml_scalar_style_t + s := in.String() + rtag, rs := resolve("", s) + if rtag == yaml_BINARY_TAG { + if tag == "" || tag == yaml_STR_TAG { + tag = rtag + s = rs.(string) + } else if tag == yaml_BINARY_TAG { + failf("explicitly tagged !!binary data must be base64-encoded") + } else { + failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag)) + } + } + if tag == "" && (rtag != yaml_STR_TAG || isBase60Float(s)) { + style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } else if strings.Contains(s, "\n") { + style = yaml_LITERAL_SCALAR_STYLE + } else { + style = yaml_PLAIN_SCALAR_STYLE + } + e.emitScalar(s, "", tag, style) +} + +func (e *encoder) boolv(tag string, in reflect.Value) { + var s string + if in.Bool() { + s = "true" + } else { + s = "false" + } + e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) +} + +func (e *encoder) intv(tag string, in reflect.Value) { + s := strconv.FormatInt(in.Int(), 10) + e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) +} + +func (e *encoder) uintv(tag string, in reflect.Value) { + s := strconv.FormatUint(in.Uint(), 10) + e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) +} + +func (e *encoder) floatv(tag string, in reflect.Value) { + // FIXME: Handle 64 bits here. + s := strconv.FormatFloat(float64(in.Float()), 'g', -1, 32) + switch s { + case "+Inf": + s = ".inf" + case "-Inf": + s = "-.inf" + case "NaN": + s = ".nan" + } + e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) +} + +func (e *encoder) nilv() { + e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE) +} + +func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) { + implicit := tag == "" + e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style)) + e.emit() +} diff --git a/vendor/gopkg.in/yaml.v2/parserc.go b/vendor/gopkg.in/yaml.v2/parserc.go new file mode 100644 index 00000000..0a7037ad --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/parserc.go @@ -0,0 +1,1096 @@ +package yaml + +import ( + "bytes" +) + +// The parser implements the following grammar: +// +// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END +// implicit_document ::= block_node DOCUMENT-END* +// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +// block_node_or_indentless_sequence ::= +// ALIAS +// | properties (block_content | indentless_block_sequence)? +// | block_content +// | indentless_block_sequence +// block_node ::= ALIAS +// | properties block_content? +// | block_content +// flow_node ::= ALIAS +// | properties flow_content? +// | flow_content +// properties ::= TAG ANCHOR? | ANCHOR TAG? +// block_content ::= block_collection | flow_collection | SCALAR +// flow_content ::= flow_collection | SCALAR +// block_collection ::= block_sequence | block_mapping +// flow_collection ::= flow_sequence | flow_mapping +// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END +// indentless_sequence ::= (BLOCK-ENTRY block_node?)+ +// block_mapping ::= BLOCK-MAPPING_START +// ((KEY block_node_or_indentless_sequence?)? +// (VALUE block_node_or_indentless_sequence?)?)* +// BLOCK-END +// flow_sequence ::= FLOW-SEQUENCE-START +// (flow_sequence_entry FLOW-ENTRY)* +// flow_sequence_entry? +// FLOW-SEQUENCE-END +// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// flow_mapping ::= FLOW-MAPPING-START +// (flow_mapping_entry FLOW-ENTRY)* +// flow_mapping_entry? +// FLOW-MAPPING-END +// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + +// Peek the next token in the token queue. +func peek_token(parser *yaml_parser_t) *yaml_token_t { + if parser.token_available || yaml_parser_fetch_more_tokens(parser) { + return &parser.tokens[parser.tokens_head] + } + return nil +} + +// Remove the next token from the queue (must be called after peek_token). +func skip_token(parser *yaml_parser_t) { + parser.token_available = false + parser.tokens_parsed++ + parser.stream_end_produced = parser.tokens[parser.tokens_head].typ == yaml_STREAM_END_TOKEN + parser.tokens_head++ +} + +// Get the next event. +func yaml_parser_parse(parser *yaml_parser_t, event *yaml_event_t) bool { + // Erase the event object. + *event = yaml_event_t{} + + // No events after the end of the stream or error. + if parser.stream_end_produced || parser.error != yaml_NO_ERROR || parser.state == yaml_PARSE_END_STATE { + return true + } + + // Generate the next event. + return yaml_parser_state_machine(parser, event) +} + +// Set parser error. +func yaml_parser_set_parser_error(parser *yaml_parser_t, problem string, problem_mark yaml_mark_t) bool { + parser.error = yaml_PARSER_ERROR + parser.problem = problem + parser.problem_mark = problem_mark + return false +} + +func yaml_parser_set_parser_error_context(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string, problem_mark yaml_mark_t) bool { + parser.error = yaml_PARSER_ERROR + parser.context = context + parser.context_mark = context_mark + parser.problem = problem + parser.problem_mark = problem_mark + return false +} + +// State dispatcher. +func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool { + //trace("yaml_parser_state_machine", "state:", parser.state.String()) + + switch parser.state { + case yaml_PARSE_STREAM_START_STATE: + return yaml_parser_parse_stream_start(parser, event) + + case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE: + return yaml_parser_parse_document_start(parser, event, true) + + case yaml_PARSE_DOCUMENT_START_STATE: + return yaml_parser_parse_document_start(parser, event, false) + + case yaml_PARSE_DOCUMENT_CONTENT_STATE: + return yaml_parser_parse_document_content(parser, event) + + case yaml_PARSE_DOCUMENT_END_STATE: + return yaml_parser_parse_document_end(parser, event) + + case yaml_PARSE_BLOCK_NODE_STATE: + return yaml_parser_parse_node(parser, event, true, false) + + case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: + return yaml_parser_parse_node(parser, event, true, true) + + case yaml_PARSE_FLOW_NODE_STATE: + return yaml_parser_parse_node(parser, event, false, false) + + case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: + return yaml_parser_parse_block_sequence_entry(parser, event, true) + + case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: + return yaml_parser_parse_block_sequence_entry(parser, event, false) + + case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: + return yaml_parser_parse_indentless_sequence_entry(parser, event) + + case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: + return yaml_parser_parse_block_mapping_key(parser, event, true) + + case yaml_PARSE_BLOCK_MAPPING_KEY_STATE: + return yaml_parser_parse_block_mapping_key(parser, event, false) + + case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE: + return yaml_parser_parse_block_mapping_value(parser, event) + + case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: + return yaml_parser_parse_flow_sequence_entry(parser, event, true) + + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE: + return yaml_parser_parse_flow_sequence_entry(parser, event, false) + + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: + return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event) + + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: + return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event) + + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: + return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event) + + case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: + return yaml_parser_parse_flow_mapping_key(parser, event, true) + + case yaml_PARSE_FLOW_MAPPING_KEY_STATE: + return yaml_parser_parse_flow_mapping_key(parser, event, false) + + case yaml_PARSE_FLOW_MAPPING_VALUE_STATE: + return yaml_parser_parse_flow_mapping_value(parser, event, false) + + case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: + return yaml_parser_parse_flow_mapping_value(parser, event, true) + + default: + panic("invalid parser state") + } + return false +} + +// Parse the production: +// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END +// ************ +func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_STREAM_START_TOKEN { + return yaml_parser_set_parser_error(parser, "did not find expected ", token.start_mark) + } + parser.state = yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE + *event = yaml_event_t{ + typ: yaml_STREAM_START_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + encoding: token.encoding, + } + skip_token(parser) + return true +} + +// Parse the productions: +// implicit_document ::= block_node DOCUMENT-END* +// * +// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +// ************************* +func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool { + + token := peek_token(parser) + if token == nil { + return false + } + + // Parse extra document end indicators. + if !implicit { + for token.typ == yaml_DOCUMENT_END_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + } + } + + if implicit && token.typ != yaml_VERSION_DIRECTIVE_TOKEN && + token.typ != yaml_TAG_DIRECTIVE_TOKEN && + token.typ != yaml_DOCUMENT_START_TOKEN && + token.typ != yaml_STREAM_END_TOKEN { + // Parse an implicit document. + if !yaml_parser_process_directives(parser, nil, nil) { + return false + } + parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE) + parser.state = yaml_PARSE_BLOCK_NODE_STATE + + *event = yaml_event_t{ + typ: yaml_DOCUMENT_START_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + + } else if token.typ != yaml_STREAM_END_TOKEN { + // Parse an explicit document. + var version_directive *yaml_version_directive_t + var tag_directives []yaml_tag_directive_t + start_mark := token.start_mark + if !yaml_parser_process_directives(parser, &version_directive, &tag_directives) { + return false + } + token = peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_DOCUMENT_START_TOKEN { + yaml_parser_set_parser_error(parser, + "did not find expected ", token.start_mark) + return false + } + parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE) + parser.state = yaml_PARSE_DOCUMENT_CONTENT_STATE + end_mark := token.end_mark + + *event = yaml_event_t{ + typ: yaml_DOCUMENT_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + version_directive: version_directive, + tag_directives: tag_directives, + implicit: false, + } + skip_token(parser) + + } else { + // Parse the stream end. + parser.state = yaml_PARSE_END_STATE + *event = yaml_event_t{ + typ: yaml_STREAM_END_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + skip_token(parser) + } + + return true +} + +// Parse the productions: +// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +// *********** +// +func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + if token.typ == yaml_VERSION_DIRECTIVE_TOKEN || + token.typ == yaml_TAG_DIRECTIVE_TOKEN || + token.typ == yaml_DOCUMENT_START_TOKEN || + token.typ == yaml_DOCUMENT_END_TOKEN || + token.typ == yaml_STREAM_END_TOKEN { + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + return yaml_parser_process_empty_scalar(parser, event, + token.start_mark) + } + return yaml_parser_parse_node(parser, event, true, false) +} + +// Parse the productions: +// implicit_document ::= block_node DOCUMENT-END* +// ************* +// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +// +func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + + start_mark := token.start_mark + end_mark := token.start_mark + + implicit := true + if token.typ == yaml_DOCUMENT_END_TOKEN { + end_mark = token.end_mark + skip_token(parser) + implicit = false + } + + parser.tag_directives = parser.tag_directives[:0] + + parser.state = yaml_PARSE_DOCUMENT_START_STATE + *event = yaml_event_t{ + typ: yaml_DOCUMENT_END_EVENT, + start_mark: start_mark, + end_mark: end_mark, + implicit: implicit, + } + return true +} + +// Parse the productions: +// block_node_or_indentless_sequence ::= +// ALIAS +// ***** +// | properties (block_content | indentless_block_sequence)? +// ********** * +// | block_content | indentless_block_sequence +// * +// block_node ::= ALIAS +// ***** +// | properties block_content? +// ********** * +// | block_content +// * +// flow_node ::= ALIAS +// ***** +// | properties flow_content? +// ********** * +// | flow_content +// * +// properties ::= TAG ANCHOR? | ANCHOR TAG? +// ************************* +// block_content ::= block_collection | flow_collection | SCALAR +// ****** +// flow_content ::= flow_collection | SCALAR +// ****** +func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool { + //defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)() + + token := peek_token(parser) + if token == nil { + return false + } + + if token.typ == yaml_ALIAS_TOKEN { + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + *event = yaml_event_t{ + typ: yaml_ALIAS_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + anchor: token.value, + } + skip_token(parser) + return true + } + + start_mark := token.start_mark + end_mark := token.start_mark + + var tag_token bool + var tag_handle, tag_suffix, anchor []byte + var tag_mark yaml_mark_t + if token.typ == yaml_ANCHOR_TOKEN { + anchor = token.value + start_mark = token.start_mark + end_mark = token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.typ == yaml_TAG_TOKEN { + tag_token = true + tag_handle = token.value + tag_suffix = token.suffix + tag_mark = token.start_mark + end_mark = token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + } + } else if token.typ == yaml_TAG_TOKEN { + tag_token = true + tag_handle = token.value + tag_suffix = token.suffix + start_mark = token.start_mark + tag_mark = token.start_mark + end_mark = token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.typ == yaml_ANCHOR_TOKEN { + anchor = token.value + end_mark = token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + } + } + + var tag []byte + if tag_token { + if len(tag_handle) == 0 { + tag = tag_suffix + tag_suffix = nil + } else { + for i := range parser.tag_directives { + if bytes.Equal(parser.tag_directives[i].handle, tag_handle) { + tag = append([]byte(nil), parser.tag_directives[i].prefix...) + tag = append(tag, tag_suffix...) + break + } + } + if len(tag) == 0 { + yaml_parser_set_parser_error_context(parser, + "while parsing a node", start_mark, + "found undefined tag handle", tag_mark) + return false + } + } + } + + implicit := len(tag) == 0 + if indentless_sequence && token.typ == yaml_BLOCK_ENTRY_TOKEN { + end_mark = token.end_mark + parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE + *event = yaml_event_t{ + typ: yaml_SEQUENCE_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE), + } + return true + } + if token.typ == yaml_SCALAR_TOKEN { + var plain_implicit, quoted_implicit bool + end_mark = token.end_mark + if (len(tag) == 0 && token.style == yaml_PLAIN_SCALAR_STYLE) || (len(tag) == 1 && tag[0] == '!') { + plain_implicit = true + } else if len(tag) == 0 { + quoted_implicit = true + } + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + + *event = yaml_event_t{ + typ: yaml_SCALAR_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + value: token.value, + implicit: plain_implicit, + quoted_implicit: quoted_implicit, + style: yaml_style_t(token.style), + } + skip_token(parser) + return true + } + if token.typ == yaml_FLOW_SEQUENCE_START_TOKEN { + // [Go] Some of the events below can be merged as they differ only on style. + end_mark = token.end_mark + parser.state = yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE + *event = yaml_event_t{ + typ: yaml_SEQUENCE_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE), + } + return true + } + if token.typ == yaml_FLOW_MAPPING_START_TOKEN { + end_mark = token.end_mark + parser.state = yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE + *event = yaml_event_t{ + typ: yaml_MAPPING_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(yaml_FLOW_MAPPING_STYLE), + } + return true + } + if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN { + end_mark = token.end_mark + parser.state = yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE + *event = yaml_event_t{ + typ: yaml_SEQUENCE_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE), + } + return true + } + if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN { + end_mark = token.end_mark + parser.state = yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE + *event = yaml_event_t{ + typ: yaml_MAPPING_START_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE), + } + return true + } + if len(anchor) > 0 || len(tag) > 0 { + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + + *event = yaml_event_t{ + typ: yaml_SCALAR_EVENT, + start_mark: start_mark, + end_mark: end_mark, + anchor: anchor, + tag: tag, + implicit: implicit, + quoted_implicit: false, + style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE), + } + return true + } + + context := "while parsing a flow node" + if block { + context = "while parsing a block node" + } + yaml_parser_set_parser_error_context(parser, context, start_mark, + "did not find expected node content", token.start_mark) + return false +} + +// Parse the productions: +// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END +// ******************** *********** * ********* +// +func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { + if first { + token := peek_token(parser) + parser.marks = append(parser.marks, token.start_mark) + skip_token(parser) + } + + token := peek_token(parser) + if token == nil { + return false + } + + if token.typ == yaml_BLOCK_ENTRY_TOKEN { + mark := token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_BLOCK_ENTRY_TOKEN && token.typ != yaml_BLOCK_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE) + return yaml_parser_parse_node(parser, event, true, false) + } else { + parser.state = yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE + return yaml_parser_process_empty_scalar(parser, event, mark) + } + } + if token.typ == yaml_BLOCK_END_TOKEN { + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + + *event = yaml_event_t{ + typ: yaml_SEQUENCE_END_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + + skip_token(parser) + return true + } + + context_mark := parser.marks[len(parser.marks)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + return yaml_parser_set_parser_error_context(parser, + "while parsing a block collection", context_mark, + "did not find expected '-' indicator", token.start_mark) +} + +// Parse the productions: +// indentless_sequence ::= (BLOCK-ENTRY block_node?)+ +// *********** * +func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + + if token.typ == yaml_BLOCK_ENTRY_TOKEN { + mark := token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_BLOCK_ENTRY_TOKEN && + token.typ != yaml_KEY_TOKEN && + token.typ != yaml_VALUE_TOKEN && + token.typ != yaml_BLOCK_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE) + return yaml_parser_parse_node(parser, event, true, false) + } + parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE + return yaml_parser_process_empty_scalar(parser, event, mark) + } + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + + *event = yaml_event_t{ + typ: yaml_SEQUENCE_END_EVENT, + start_mark: token.start_mark, + end_mark: token.start_mark, // [Go] Shouldn't this be token.end_mark? + } + return true +} + +// Parse the productions: +// block_mapping ::= BLOCK-MAPPING_START +// ******************* +// ((KEY block_node_or_indentless_sequence?)? +// *** * +// (VALUE block_node_or_indentless_sequence?)?)* +// +// BLOCK-END +// ********* +// +func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { + if first { + token := peek_token(parser) + parser.marks = append(parser.marks, token.start_mark) + skip_token(parser) + } + + token := peek_token(parser) + if token == nil { + return false + } + + if token.typ == yaml_KEY_TOKEN { + mark := token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_KEY_TOKEN && + token.typ != yaml_VALUE_TOKEN && + token.typ != yaml_BLOCK_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_VALUE_STATE) + return yaml_parser_parse_node(parser, event, true, true) + } else { + parser.state = yaml_PARSE_BLOCK_MAPPING_VALUE_STATE + return yaml_parser_process_empty_scalar(parser, event, mark) + } + } else if token.typ == yaml_BLOCK_END_TOKEN { + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + *event = yaml_event_t{ + typ: yaml_MAPPING_END_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + skip_token(parser) + return true + } + + context_mark := parser.marks[len(parser.marks)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + return yaml_parser_set_parser_error_context(parser, + "while parsing a block mapping", context_mark, + "did not find expected key", token.start_mark) +} + +// Parse the productions: +// block_mapping ::= BLOCK-MAPPING_START +// +// ((KEY block_node_or_indentless_sequence?)? +// +// (VALUE block_node_or_indentless_sequence?)?)* +// ***** * +// BLOCK-END +// +// +func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + if token.typ == yaml_VALUE_TOKEN { + mark := token.end_mark + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_KEY_TOKEN && + token.typ != yaml_VALUE_TOKEN && + token.typ != yaml_BLOCK_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_KEY_STATE) + return yaml_parser_parse_node(parser, event, true, true) + } + parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE + return yaml_parser_process_empty_scalar(parser, event, mark) + } + parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE + return yaml_parser_process_empty_scalar(parser, event, token.start_mark) +} + +// Parse the productions: +// flow_sequence ::= FLOW-SEQUENCE-START +// ******************* +// (flow_sequence_entry FLOW-ENTRY)* +// * ********** +// flow_sequence_entry? +// * +// FLOW-SEQUENCE-END +// ***************** +// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// * +// +func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { + if first { + token := peek_token(parser) + parser.marks = append(parser.marks, token.start_mark) + skip_token(parser) + } + token := peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { + if !first { + if token.typ == yaml_FLOW_ENTRY_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + } else { + context_mark := parser.marks[len(parser.marks)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + return yaml_parser_set_parser_error_context(parser, + "while parsing a flow sequence", context_mark, + "did not find expected ',' or ']'", token.start_mark) + } + } + + if token.typ == yaml_KEY_TOKEN { + parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE + *event = yaml_event_t{ + typ: yaml_MAPPING_START_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + implicit: true, + style: yaml_style_t(yaml_FLOW_MAPPING_STYLE), + } + skip_token(parser) + return true + } else if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } + } + + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + + *event = yaml_event_t{ + typ: yaml_SEQUENCE_END_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + + skip_token(parser) + return true +} + +// +// Parse the productions: +// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// *** * +// +func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_VALUE_TOKEN && + token.typ != yaml_FLOW_ENTRY_TOKEN && + token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } + mark := token.end_mark + skip_token(parser) + parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE + return yaml_parser_process_empty_scalar(parser, event, mark) +} + +// Parse the productions: +// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// ***** * +// +func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + if token.typ == yaml_VALUE_TOKEN { + skip_token(parser) + token := peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } + } + parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE + return yaml_parser_process_empty_scalar(parser, event, token.start_mark) +} + +// Parse the productions: +// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// * +// +func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool { + token := peek_token(parser) + if token == nil { + return false + } + parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE + *event = yaml_event_t{ + typ: yaml_MAPPING_END_EVENT, + start_mark: token.start_mark, + end_mark: token.start_mark, // [Go] Shouldn't this be end_mark? + } + return true +} + +// Parse the productions: +// flow_mapping ::= FLOW-MAPPING-START +// ****************** +// (flow_mapping_entry FLOW-ENTRY)* +// * ********** +// flow_mapping_entry? +// ****************** +// FLOW-MAPPING-END +// **************** +// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// * *** * +// +func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { + if first { + token := peek_token(parser) + parser.marks = append(parser.marks, token.start_mark) + skip_token(parser) + } + + token := peek_token(parser) + if token == nil { + return false + } + + if token.typ != yaml_FLOW_MAPPING_END_TOKEN { + if !first { + if token.typ == yaml_FLOW_ENTRY_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + } else { + context_mark := parser.marks[len(parser.marks)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + return yaml_parser_set_parser_error_context(parser, + "while parsing a flow mapping", context_mark, + "did not find expected ',' or '}'", token.start_mark) + } + } + + if token.typ == yaml_KEY_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_VALUE_TOKEN && + token.typ != yaml_FLOW_ENTRY_TOKEN && + token.typ != yaml_FLOW_MAPPING_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_VALUE_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } else { + parser.state = yaml_PARSE_FLOW_MAPPING_VALUE_STATE + return yaml_parser_process_empty_scalar(parser, event, token.start_mark) + } + } else if token.typ != yaml_FLOW_MAPPING_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } + } + + parser.state = parser.states[len(parser.states)-1] + parser.states = parser.states[:len(parser.states)-1] + parser.marks = parser.marks[:len(parser.marks)-1] + *event = yaml_event_t{ + typ: yaml_MAPPING_END_EVENT, + start_mark: token.start_mark, + end_mark: token.end_mark, + } + skip_token(parser) + return true +} + +// Parse the productions: +// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// * ***** * +// +func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool { + token := peek_token(parser) + if token == nil { + return false + } + if empty { + parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE + return yaml_parser_process_empty_scalar(parser, event, token.start_mark) + } + if token.typ == yaml_VALUE_TOKEN { + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_MAPPING_END_TOKEN { + parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_KEY_STATE) + return yaml_parser_parse_node(parser, event, false, false) + } + } + parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE + return yaml_parser_process_empty_scalar(parser, event, token.start_mark) +} + +// Generate an empty scalar event. +func yaml_parser_process_empty_scalar(parser *yaml_parser_t, event *yaml_event_t, mark yaml_mark_t) bool { + *event = yaml_event_t{ + typ: yaml_SCALAR_EVENT, + start_mark: mark, + end_mark: mark, + value: nil, // Empty + implicit: true, + style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE), + } + return true +} + +var default_tag_directives = []yaml_tag_directive_t{ + {[]byte("!"), []byte("!")}, + {[]byte("!!"), []byte("tag:yaml.org,2002:")}, +} + +// Parse directives. +func yaml_parser_process_directives(parser *yaml_parser_t, + version_directive_ref **yaml_version_directive_t, + tag_directives_ref *[]yaml_tag_directive_t) bool { + + var version_directive *yaml_version_directive_t + var tag_directives []yaml_tag_directive_t + + token := peek_token(parser) + if token == nil { + return false + } + + for token.typ == yaml_VERSION_DIRECTIVE_TOKEN || token.typ == yaml_TAG_DIRECTIVE_TOKEN { + if token.typ == yaml_VERSION_DIRECTIVE_TOKEN { + if version_directive != nil { + yaml_parser_set_parser_error(parser, + "found duplicate %YAML directive", token.start_mark) + return false + } + if token.major != 1 || token.minor != 1 { + yaml_parser_set_parser_error(parser, + "found incompatible YAML document", token.start_mark) + return false + } + version_directive = &yaml_version_directive_t{ + major: token.major, + minor: token.minor, + } + } else if token.typ == yaml_TAG_DIRECTIVE_TOKEN { + value := yaml_tag_directive_t{ + handle: token.value, + prefix: token.prefix, + } + if !yaml_parser_append_tag_directive(parser, value, false, token.start_mark) { + return false + } + tag_directives = append(tag_directives, value) + } + + skip_token(parser) + token = peek_token(parser) + if token == nil { + return false + } + } + + for i := range default_tag_directives { + if !yaml_parser_append_tag_directive(parser, default_tag_directives[i], true, token.start_mark) { + return false + } + } + + if version_directive_ref != nil { + *version_directive_ref = version_directive + } + if tag_directives_ref != nil { + *tag_directives_ref = tag_directives + } + return true +} + +// Append a tag directive to the directives stack. +func yaml_parser_append_tag_directive(parser *yaml_parser_t, value yaml_tag_directive_t, allow_duplicates bool, mark yaml_mark_t) bool { + for i := range parser.tag_directives { + if bytes.Equal(value.handle, parser.tag_directives[i].handle) { + if allow_duplicates { + return true + } + return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark) + } + } + + // [Go] I suspect the copy is unnecessary. This was likely done + // because there was no way to track ownership of the data. + value_copy := yaml_tag_directive_t{ + handle: make([]byte, len(value.handle)), + prefix: make([]byte, len(value.prefix)), + } + copy(value_copy.handle, value.handle) + copy(value_copy.prefix, value.prefix) + parser.tag_directives = append(parser.tag_directives, value_copy) + return true +} diff --git a/vendor/gopkg.in/yaml.v2/readerc.go b/vendor/gopkg.in/yaml.v2/readerc.go new file mode 100644 index 00000000..f4507917 --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/readerc.go @@ -0,0 +1,394 @@ +package yaml + +import ( + "io" +) + +// Set the reader error and return 0. +func yaml_parser_set_reader_error(parser *yaml_parser_t, problem string, offset int, value int) bool { + parser.error = yaml_READER_ERROR + parser.problem = problem + parser.problem_offset = offset + parser.problem_value = value + return false +} + +// Byte order marks. +const ( + bom_UTF8 = "\xef\xbb\xbf" + bom_UTF16LE = "\xff\xfe" + bom_UTF16BE = "\xfe\xff" +) + +// Determine the input stream encoding by checking the BOM symbol. If no BOM is +// found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure. +func yaml_parser_determine_encoding(parser *yaml_parser_t) bool { + // Ensure that we had enough bytes in the raw buffer. + for !parser.eof && len(parser.raw_buffer)-parser.raw_buffer_pos < 3 { + if !yaml_parser_update_raw_buffer(parser) { + return false + } + } + + // Determine the encoding. + buf := parser.raw_buffer + pos := parser.raw_buffer_pos + avail := len(buf) - pos + if avail >= 2 && buf[pos] == bom_UTF16LE[0] && buf[pos+1] == bom_UTF16LE[1] { + parser.encoding = yaml_UTF16LE_ENCODING + parser.raw_buffer_pos += 2 + parser.offset += 2 + } else if avail >= 2 && buf[pos] == bom_UTF16BE[0] && buf[pos+1] == bom_UTF16BE[1] { + parser.encoding = yaml_UTF16BE_ENCODING + parser.raw_buffer_pos += 2 + parser.offset += 2 + } else if avail >= 3 && buf[pos] == bom_UTF8[0] && buf[pos+1] == bom_UTF8[1] && buf[pos+2] == bom_UTF8[2] { + parser.encoding = yaml_UTF8_ENCODING + parser.raw_buffer_pos += 3 + parser.offset += 3 + } else { + parser.encoding = yaml_UTF8_ENCODING + } + return true +} + +// Update the raw buffer. +func yaml_parser_update_raw_buffer(parser *yaml_parser_t) bool { + size_read := 0 + + // Return if the raw buffer is full. + if parser.raw_buffer_pos == 0 && len(parser.raw_buffer) == cap(parser.raw_buffer) { + return true + } + + // Return on EOF. + if parser.eof { + return true + } + + // Move the remaining bytes in the raw buffer to the beginning. + if parser.raw_buffer_pos > 0 && parser.raw_buffer_pos < len(parser.raw_buffer) { + copy(parser.raw_buffer, parser.raw_buffer[parser.raw_buffer_pos:]) + } + parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)-parser.raw_buffer_pos] + parser.raw_buffer_pos = 0 + + // Call the read handler to fill the buffer. + size_read, err := parser.read_handler(parser, parser.raw_buffer[len(parser.raw_buffer):cap(parser.raw_buffer)]) + parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)+size_read] + if err == io.EOF { + parser.eof = true + } else if err != nil { + return yaml_parser_set_reader_error(parser, "input error: "+err.Error(), parser.offset, -1) + } + return true +} + +// Ensure that the buffer contains at least `length` characters. +// Return true on success, false on failure. +// +// The length is supposed to be significantly less that the buffer size. +func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool { + if parser.read_handler == nil { + panic("read handler must be set") + } + + // If the EOF flag is set and the raw buffer is empty, do nothing. + if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) { + return true + } + + // Return if the buffer contains enough characters. + if parser.unread >= length { + return true + } + + // Determine the input encoding if it is not known yet. + if parser.encoding == yaml_ANY_ENCODING { + if !yaml_parser_determine_encoding(parser) { + return false + } + } + + // Move the unread characters to the beginning of the buffer. + buffer_len := len(parser.buffer) + if parser.buffer_pos > 0 && parser.buffer_pos < buffer_len { + copy(parser.buffer, parser.buffer[parser.buffer_pos:]) + buffer_len -= parser.buffer_pos + parser.buffer_pos = 0 + } else if parser.buffer_pos == buffer_len { + buffer_len = 0 + parser.buffer_pos = 0 + } + + // Open the whole buffer for writing, and cut it before returning. + parser.buffer = parser.buffer[:cap(parser.buffer)] + + // Fill the buffer until it has enough characters. + first := true + for parser.unread < length { + + // Fill the raw buffer if necessary. + if !first || parser.raw_buffer_pos == len(parser.raw_buffer) { + if !yaml_parser_update_raw_buffer(parser) { + parser.buffer = parser.buffer[:buffer_len] + return false + } + } + first = false + + // Decode the raw buffer. + inner: + for parser.raw_buffer_pos != len(parser.raw_buffer) { + var value rune + var width int + + raw_unread := len(parser.raw_buffer) - parser.raw_buffer_pos + + // Decode the next character. + switch parser.encoding { + case yaml_UTF8_ENCODING: + // Decode a UTF-8 character. Check RFC 3629 + // (http://www.ietf.org/rfc/rfc3629.txt) for more details. + // + // The following table (taken from the RFC) is used for + // decoding. + // + // Char. number range | UTF-8 octet sequence + // (hexadecimal) | (binary) + // --------------------+------------------------------------ + // 0000 0000-0000 007F | 0xxxxxxx + // 0000 0080-0000 07FF | 110xxxxx 10xxxxxx + // 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx + // 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + // + // Additionally, the characters in the range 0xD800-0xDFFF + // are prohibited as they are reserved for use with UTF-16 + // surrogate pairs. + + // Determine the length of the UTF-8 sequence. + octet := parser.raw_buffer[parser.raw_buffer_pos] + switch { + case octet&0x80 == 0x00: + width = 1 + case octet&0xE0 == 0xC0: + width = 2 + case octet&0xF0 == 0xE0: + width = 3 + case octet&0xF8 == 0xF0: + width = 4 + default: + // The leading octet is invalid. + return yaml_parser_set_reader_error(parser, + "invalid leading UTF-8 octet", + parser.offset, int(octet)) + } + + // Check if the raw buffer contains an incomplete character. + if width > raw_unread { + if parser.eof { + return yaml_parser_set_reader_error(parser, + "incomplete UTF-8 octet sequence", + parser.offset, -1) + } + break inner + } + + // Decode the leading octet. + switch { + case octet&0x80 == 0x00: + value = rune(octet & 0x7F) + case octet&0xE0 == 0xC0: + value = rune(octet & 0x1F) + case octet&0xF0 == 0xE0: + value = rune(octet & 0x0F) + case octet&0xF8 == 0xF0: + value = rune(octet & 0x07) + default: + value = 0 + } + + // Check and decode the trailing octets. + for k := 1; k < width; k++ { + octet = parser.raw_buffer[parser.raw_buffer_pos+k] + + // Check if the octet is valid. + if (octet & 0xC0) != 0x80 { + return yaml_parser_set_reader_error(parser, + "invalid trailing UTF-8 octet", + parser.offset+k, int(octet)) + } + + // Decode the octet. + value = (value << 6) + rune(octet&0x3F) + } + + // Check the length of the sequence against the value. + switch { + case width == 1: + case width == 2 && value >= 0x80: + case width == 3 && value >= 0x800: + case width == 4 && value >= 0x10000: + default: + return yaml_parser_set_reader_error(parser, + "invalid length of a UTF-8 sequence", + parser.offset, -1) + } + + // Check the range of the value. + if value >= 0xD800 && value <= 0xDFFF || value > 0x10FFFF { + return yaml_parser_set_reader_error(parser, + "invalid Unicode character", + parser.offset, int(value)) + } + + case yaml_UTF16LE_ENCODING, yaml_UTF16BE_ENCODING: + var low, high int + if parser.encoding == yaml_UTF16LE_ENCODING { + low, high = 0, 1 + } else { + low, high = 1, 0 + } + + // The UTF-16 encoding is not as simple as one might + // naively think. Check RFC 2781 + // (http://www.ietf.org/rfc/rfc2781.txt). + // + // Normally, two subsequent bytes describe a Unicode + // character. However a special technique (called a + // surrogate pair) is used for specifying character + // values larger than 0xFFFF. + // + // A surrogate pair consists of two pseudo-characters: + // high surrogate area (0xD800-0xDBFF) + // low surrogate area (0xDC00-0xDFFF) + // + // The following formulas are used for decoding + // and encoding characters using surrogate pairs: + // + // U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF) + // U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF) + // W1 = 110110yyyyyyyyyy + // W2 = 110111xxxxxxxxxx + // + // where U is the character value, W1 is the high surrogate + // area, W2 is the low surrogate area. + + // Check for incomplete UTF-16 character. + if raw_unread < 2 { + if parser.eof { + return yaml_parser_set_reader_error(parser, + "incomplete UTF-16 character", + parser.offset, -1) + } + break inner + } + + // Get the character. + value = rune(parser.raw_buffer[parser.raw_buffer_pos+low]) + + (rune(parser.raw_buffer[parser.raw_buffer_pos+high]) << 8) + + // Check for unexpected low surrogate area. + if value&0xFC00 == 0xDC00 { + return yaml_parser_set_reader_error(parser, + "unexpected low surrogate area", + parser.offset, int(value)) + } + + // Check for a high surrogate area. + if value&0xFC00 == 0xD800 { + width = 4 + + // Check for incomplete surrogate pair. + if raw_unread < 4 { + if parser.eof { + return yaml_parser_set_reader_error(parser, + "incomplete UTF-16 surrogate pair", + parser.offset, -1) + } + break inner + } + + // Get the next character. + value2 := rune(parser.raw_buffer[parser.raw_buffer_pos+low+2]) + + (rune(parser.raw_buffer[parser.raw_buffer_pos+high+2]) << 8) + + // Check for a low surrogate area. + if value2&0xFC00 != 0xDC00 { + return yaml_parser_set_reader_error(parser, + "expected low surrogate area", + parser.offset+2, int(value2)) + } + + // Generate the value of the surrogate pair. + value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF) + } else { + width = 2 + } + + default: + panic("impossible") + } + + // Check if the character is in the allowed range: + // #x9 | #xA | #xD | [#x20-#x7E] (8 bit) + // | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit) + // | [#x10000-#x10FFFF] (32 bit) + switch { + case value == 0x09: + case value == 0x0A: + case value == 0x0D: + case value >= 0x20 && value <= 0x7E: + case value == 0x85: + case value >= 0xA0 && value <= 0xD7FF: + case value >= 0xE000 && value <= 0xFFFD: + case value >= 0x10000 && value <= 0x10FFFF: + default: + return yaml_parser_set_reader_error(parser, + "control characters are not allowed", + parser.offset, int(value)) + } + + // Move the raw pointers. + parser.raw_buffer_pos += width + parser.offset += width + + // Finally put the character into the buffer. + if value <= 0x7F { + // 0000 0000-0000 007F . 0xxxxxxx + parser.buffer[buffer_len+0] = byte(value) + buffer_len += 1 + } else if value <= 0x7FF { + // 0000 0080-0000 07FF . 110xxxxx 10xxxxxx + parser.buffer[buffer_len+0] = byte(0xC0 + (value >> 6)) + parser.buffer[buffer_len+1] = byte(0x80 + (value & 0x3F)) + buffer_len += 2 + } else if value <= 0xFFFF { + // 0000 0800-0000 FFFF . 1110xxxx 10xxxxxx 10xxxxxx + parser.buffer[buffer_len+0] = byte(0xE0 + (value >> 12)) + parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 6) & 0x3F)) + parser.buffer[buffer_len+2] = byte(0x80 + (value & 0x3F)) + buffer_len += 3 + } else { + // 0001 0000-0010 FFFF . 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + parser.buffer[buffer_len+0] = byte(0xF0 + (value >> 18)) + parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 12) & 0x3F)) + parser.buffer[buffer_len+2] = byte(0x80 + ((value >> 6) & 0x3F)) + parser.buffer[buffer_len+3] = byte(0x80 + (value & 0x3F)) + buffer_len += 4 + } + + parser.unread++ + } + + // On EOF, put NUL into the buffer and return. + if parser.eof { + parser.buffer[buffer_len] = 0 + buffer_len++ + parser.unread++ + break + } + } + parser.buffer = parser.buffer[:buffer_len] + return true +} diff --git a/vendor/gopkg.in/yaml.v2/resolve.go b/vendor/gopkg.in/yaml.v2/resolve.go new file mode 100644 index 00000000..93a86327 --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/resolve.go @@ -0,0 +1,203 @@ +package yaml + +import ( + "encoding/base64" + "math" + "strconv" + "strings" + "unicode/utf8" +) + +type resolveMapItem struct { + value interface{} + tag string +} + +var resolveTable = make([]byte, 256) +var resolveMap = make(map[string]resolveMapItem) + +func init() { + t := resolveTable + t[int('+')] = 'S' // Sign + t[int('-')] = 'S' + for _, c := range "0123456789" { + t[int(c)] = 'D' // Digit + } + for _, c := range "yYnNtTfFoO~" { + t[int(c)] = 'M' // In map + } + t[int('.')] = '.' // Float (potentially in map) + + var resolveMapList = []struct { + v interface{} + tag string + l []string + }{ + {true, yaml_BOOL_TAG, []string{"y", "Y", "yes", "Yes", "YES"}}, + {true, yaml_BOOL_TAG, []string{"true", "True", "TRUE"}}, + {true, yaml_BOOL_TAG, []string{"on", "On", "ON"}}, + {false, yaml_BOOL_TAG, []string{"n", "N", "no", "No", "NO"}}, + {false, yaml_BOOL_TAG, []string{"false", "False", "FALSE"}}, + {false, yaml_BOOL_TAG, []string{"off", "Off", "OFF"}}, + {nil, yaml_NULL_TAG, []string{"", "~", "null", "Null", "NULL"}}, + {math.NaN(), yaml_FLOAT_TAG, []string{".nan", ".NaN", ".NAN"}}, + {math.Inf(+1), yaml_FLOAT_TAG, []string{".inf", ".Inf", ".INF"}}, + {math.Inf(+1), yaml_FLOAT_TAG, []string{"+.inf", "+.Inf", "+.INF"}}, + {math.Inf(-1), yaml_FLOAT_TAG, []string{"-.inf", "-.Inf", "-.INF"}}, + {"<<", yaml_MERGE_TAG, []string{"<<"}}, + } + + m := resolveMap + for _, item := range resolveMapList { + for _, s := range item.l { + m[s] = resolveMapItem{item.v, item.tag} + } + } +} + +const longTagPrefix = "tag:yaml.org,2002:" + +func shortTag(tag string) string { + // TODO This can easily be made faster and produce less garbage. + if strings.HasPrefix(tag, longTagPrefix) { + return "!!" + tag[len(longTagPrefix):] + } + return tag +} + +func longTag(tag string) string { + if strings.HasPrefix(tag, "!!") { + return longTagPrefix + tag[2:] + } + return tag +} + +func resolvableTag(tag string) bool { + switch tag { + case "", yaml_STR_TAG, yaml_BOOL_TAG, yaml_INT_TAG, yaml_FLOAT_TAG, yaml_NULL_TAG: + return true + } + return false +} + +func resolve(tag string, in string) (rtag string, out interface{}) { + if !resolvableTag(tag) { + return tag, in + } + + defer func() { + switch tag { + case "", rtag, yaml_STR_TAG, yaml_BINARY_TAG: + return + } + failf("cannot decode %s `%s` as a %s", shortTag(rtag), in, shortTag(tag)) + }() + + // Any data is accepted as a !!str or !!binary. + // Otherwise, the prefix is enough of a hint about what it might be. + hint := byte('N') + if in != "" { + hint = resolveTable[in[0]] + } + if hint != 0 && tag != yaml_STR_TAG && tag != yaml_BINARY_TAG { + // Handle things we can lookup in a map. + if item, ok := resolveMap[in]; ok { + return item.tag, item.value + } + + // Base 60 floats are a bad idea, were dropped in YAML 1.2, and + // are purposefully unsupported here. They're still quoted on + // the way out for compatibility with other parser, though. + + switch hint { + case 'M': + // We've already checked the map above. + + case '.': + // Not in the map, so maybe a normal float. + floatv, err := strconv.ParseFloat(in, 64) + if err == nil { + return yaml_FLOAT_TAG, floatv + } + + case 'D', 'S': + // Int, float, or timestamp. + plain := strings.Replace(in, "_", "", -1) + intv, err := strconv.ParseInt(plain, 0, 64) + if err == nil { + if intv == int64(int(intv)) { + return yaml_INT_TAG, int(intv) + } else { + return yaml_INT_TAG, intv + } + } + uintv, err := strconv.ParseUint(plain, 0, 64) + if err == nil { + return yaml_INT_TAG, uintv + } + floatv, err := strconv.ParseFloat(plain, 64) + if err == nil { + return yaml_FLOAT_TAG, floatv + } + if strings.HasPrefix(plain, "0b") { + intv, err := strconv.ParseInt(plain[2:], 2, 64) + if err == nil { + if intv == int64(int(intv)) { + return yaml_INT_TAG, int(intv) + } else { + return yaml_INT_TAG, intv + } + } + uintv, err := strconv.ParseUint(plain[2:], 2, 64) + if err == nil { + return yaml_INT_TAG, uintv + } + } else if strings.HasPrefix(plain, "-0b") { + intv, err := strconv.ParseInt(plain[3:], 2, 64) + if err == nil { + if intv == int64(int(intv)) { + return yaml_INT_TAG, -int(intv) + } else { + return yaml_INT_TAG, -intv + } + } + } + // XXX Handle timestamps here. + + default: + panic("resolveTable item not yet handled: " + string(rune(hint)) + " (with " + in + ")") + } + } + if tag == yaml_BINARY_TAG { + return yaml_BINARY_TAG, in + } + if utf8.ValidString(in) { + return yaml_STR_TAG, in + } + return yaml_BINARY_TAG, encodeBase64(in) +} + +// encodeBase64 encodes s as base64 that is broken up into multiple lines +// as appropriate for the resulting length. +func encodeBase64(s string) string { + const lineLen = 70 + encLen := base64.StdEncoding.EncodedLen(len(s)) + lines := encLen/lineLen + 1 + buf := make([]byte, encLen*2+lines) + in := buf[0:encLen] + out := buf[encLen:] + base64.StdEncoding.Encode(in, []byte(s)) + k := 0 + for i := 0; i < len(in); i += lineLen { + j := i + lineLen + if j > len(in) { + j = len(in) + } + k += copy(out[k:], in[i:j]) + if lines > 1 { + out[k] = '\n' + k++ + } + } + return string(out[:k]) +} diff --git a/vendor/gopkg.in/yaml.v2/scannerc.go b/vendor/gopkg.in/yaml.v2/scannerc.go new file mode 100644 index 00000000..25808000 --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/scannerc.go @@ -0,0 +1,2710 @@ +package yaml + +import ( + "bytes" + "fmt" +) + +// Introduction +// ************ +// +// The following notes assume that you are familiar with the YAML specification +// (http://yaml.org/spec/cvs/current.html). We mostly follow it, although in +// some cases we are less restrictive that it requires. +// +// The process of transforming a YAML stream into a sequence of events is +// divided on two steps: Scanning and Parsing. +// +// The Scanner transforms the input stream into a sequence of tokens, while the +// parser transform the sequence of tokens produced by the Scanner into a +// sequence of parsing events. +// +// The Scanner is rather clever and complicated. The Parser, on the contrary, +// is a straightforward implementation of a recursive-descendant parser (or, +// LL(1) parser, as it is usually called). +// +// Actually there are two issues of Scanning that might be called "clever", the +// rest is quite straightforward. The issues are "block collection start" and +// "simple keys". Both issues are explained below in details. +// +// Here the Scanning step is explained and implemented. We start with the list +// of all the tokens produced by the Scanner together with short descriptions. +// +// Now, tokens: +// +// STREAM-START(encoding) # The stream start. +// STREAM-END # The stream end. +// VERSION-DIRECTIVE(major,minor) # The '%YAML' directive. +// TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive. +// DOCUMENT-START # '---' +// DOCUMENT-END # '...' +// BLOCK-SEQUENCE-START # Indentation increase denoting a block +// BLOCK-MAPPING-START # sequence or a block mapping. +// BLOCK-END # Indentation decrease. +// FLOW-SEQUENCE-START # '[' +// FLOW-SEQUENCE-END # ']' +// BLOCK-SEQUENCE-START # '{' +// BLOCK-SEQUENCE-END # '}' +// BLOCK-ENTRY # '-' +// FLOW-ENTRY # ',' +// KEY # '?' or nothing (simple keys). +// VALUE # ':' +// ALIAS(anchor) # '*anchor' +// ANCHOR(anchor) # '&anchor' +// TAG(handle,suffix) # '!handle!suffix' +// SCALAR(value,style) # A scalar. +// +// The following two tokens are "virtual" tokens denoting the beginning and the +// end of the stream: +// +// STREAM-START(encoding) +// STREAM-END +// +// We pass the information about the input stream encoding with the +// STREAM-START token. +// +// The next two tokens are responsible for tags: +// +// VERSION-DIRECTIVE(major,minor) +// TAG-DIRECTIVE(handle,prefix) +// +// Example: +// +// %YAML 1.1 +// %TAG ! !foo +// %TAG !yaml! tag:yaml.org,2002: +// --- +// +// The correspoding sequence of tokens: +// +// STREAM-START(utf-8) +// VERSION-DIRECTIVE(1,1) +// TAG-DIRECTIVE("!","!foo") +// TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:") +// DOCUMENT-START +// STREAM-END +// +// Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole +// line. +// +// The document start and end indicators are represented by: +// +// DOCUMENT-START +// DOCUMENT-END +// +// Note that if a YAML stream contains an implicit document (without '---' +// and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be +// produced. +// +// In the following examples, we present whole documents together with the +// produced tokens. +// +// 1. An implicit document: +// +// 'a scalar' +// +// Tokens: +// +// STREAM-START(utf-8) +// SCALAR("a scalar",single-quoted) +// STREAM-END +// +// 2. An explicit document: +// +// --- +// 'a scalar' +// ... +// +// Tokens: +// +// STREAM-START(utf-8) +// DOCUMENT-START +// SCALAR("a scalar",single-quoted) +// DOCUMENT-END +// STREAM-END +// +// 3. Several documents in a stream: +// +// 'a scalar' +// --- +// 'another scalar' +// --- +// 'yet another scalar' +// +// Tokens: +// +// STREAM-START(utf-8) +// SCALAR("a scalar",single-quoted) +// DOCUMENT-START +// SCALAR("another scalar",single-quoted) +// DOCUMENT-START +// SCALAR("yet another scalar",single-quoted) +// STREAM-END +// +// We have already introduced the SCALAR token above. The following tokens are +// used to describe aliases, anchors, tag, and scalars: +// +// ALIAS(anchor) +// ANCHOR(anchor) +// TAG(handle,suffix) +// SCALAR(value,style) +// +// The following series of examples illustrate the usage of these tokens: +// +// 1. A recursive sequence: +// +// &A [ *A ] +// +// Tokens: +// +// STREAM-START(utf-8) +// ANCHOR("A") +// FLOW-SEQUENCE-START +// ALIAS("A") +// FLOW-SEQUENCE-END +// STREAM-END +// +// 2. A tagged scalar: +// +// !!float "3.14" # A good approximation. +// +// Tokens: +// +// STREAM-START(utf-8) +// TAG("!!","float") +// SCALAR("3.14",double-quoted) +// STREAM-END +// +// 3. Various scalar styles: +// +// --- # Implicit empty plain scalars do not produce tokens. +// --- a plain scalar +// --- 'a single-quoted scalar' +// --- "a double-quoted scalar" +// --- |- +// a literal scalar +// --- >- +// a folded +// scalar +// +// Tokens: +// +// STREAM-START(utf-8) +// DOCUMENT-START +// DOCUMENT-START +// SCALAR("a plain scalar",plain) +// DOCUMENT-START +// SCALAR("a single-quoted scalar",single-quoted) +// DOCUMENT-START +// SCALAR("a double-quoted scalar",double-quoted) +// DOCUMENT-START +// SCALAR("a literal scalar",literal) +// DOCUMENT-START +// SCALAR("a folded scalar",folded) +// STREAM-END +// +// Now it's time to review collection-related tokens. We will start with +// flow collections: +// +// FLOW-SEQUENCE-START +// FLOW-SEQUENCE-END +// FLOW-MAPPING-START +// FLOW-MAPPING-END +// FLOW-ENTRY +// KEY +// VALUE +// +// The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and +// FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}' +// correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the +// indicators '?' and ':', which are used for denoting mapping keys and values, +// are represented by the KEY and VALUE tokens. +// +// The following examples show flow collections: +// +// 1. A flow sequence: +// +// [item 1, item 2, item 3] +// +// Tokens: +// +// STREAM-START(utf-8) +// FLOW-SEQUENCE-START +// SCALAR("item 1",plain) +// FLOW-ENTRY +// SCALAR("item 2",plain) +// FLOW-ENTRY +// SCALAR("item 3",plain) +// FLOW-SEQUENCE-END +// STREAM-END +// +// 2. A flow mapping: +// +// { +// a simple key: a value, # Note that the KEY token is produced. +// ? a complex key: another value, +// } +// +// Tokens: +// +// STREAM-START(utf-8) +// FLOW-MAPPING-START +// KEY +// SCALAR("a simple key",plain) +// VALUE +// SCALAR("a value",plain) +// FLOW-ENTRY +// KEY +// SCALAR("a complex key",plain) +// VALUE +// SCALAR("another value",plain) +// FLOW-ENTRY +// FLOW-MAPPING-END +// STREAM-END +// +// A simple key is a key which is not denoted by the '?' indicator. Note that +// the Scanner still produce the KEY token whenever it encounters a simple key. +// +// For scanning block collections, the following tokens are used (note that we +// repeat KEY and VALUE here): +// +// BLOCK-SEQUENCE-START +// BLOCK-MAPPING-START +// BLOCK-END +// BLOCK-ENTRY +// KEY +// VALUE +// +// The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation +// increase that precedes a block collection (cf. the INDENT token in Python). +// The token BLOCK-END denote indentation decrease that ends a block collection +// (cf. the DEDENT token in Python). However YAML has some syntax pecularities +// that makes detections of these tokens more complex. +// +// The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators +// '-', '?', and ':' correspondingly. +// +// The following examples show how the tokens BLOCK-SEQUENCE-START, +// BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner: +// +// 1. Block sequences: +// +// - item 1 +// - item 2 +// - +// - item 3.1 +// - item 3.2 +// - +// key 1: value 1 +// key 2: value 2 +// +// Tokens: +// +// STREAM-START(utf-8) +// BLOCK-SEQUENCE-START +// BLOCK-ENTRY +// SCALAR("item 1",plain) +// BLOCK-ENTRY +// SCALAR("item 2",plain) +// BLOCK-ENTRY +// BLOCK-SEQUENCE-START +// BLOCK-ENTRY +// SCALAR("item 3.1",plain) +// BLOCK-ENTRY +// SCALAR("item 3.2",plain) +// BLOCK-END +// BLOCK-ENTRY +// BLOCK-MAPPING-START +// KEY +// SCALAR("key 1",plain) +// VALUE +// SCALAR("value 1",plain) +// KEY +// SCALAR("key 2",plain) +// VALUE +// SCALAR("value 2",plain) +// BLOCK-END +// BLOCK-END +// STREAM-END +// +// 2. Block mappings: +// +// a simple key: a value # The KEY token is produced here. +// ? a complex key +// : another value +// a mapping: +// key 1: value 1 +// key 2: value 2 +// a sequence: +// - item 1 +// - item 2 +// +// Tokens: +// +// STREAM-START(utf-8) +// BLOCK-MAPPING-START +// KEY +// SCALAR("a simple key",plain) +// VALUE +// SCALAR("a value",plain) +// KEY +// SCALAR("a complex key",plain) +// VALUE +// SCALAR("another value",plain) +// KEY +// SCALAR("a mapping",plain) +// BLOCK-MAPPING-START +// KEY +// SCALAR("key 1",plain) +// VALUE +// SCALAR("value 1",plain) +// KEY +// SCALAR("key 2",plain) +// VALUE +// SCALAR("value 2",plain) +// BLOCK-END +// KEY +// SCALAR("a sequence",plain) +// VALUE +// BLOCK-SEQUENCE-START +// BLOCK-ENTRY +// SCALAR("item 1",plain) +// BLOCK-ENTRY +// SCALAR("item 2",plain) +// BLOCK-END +// BLOCK-END +// STREAM-END +// +// YAML does not always require to start a new block collection from a new +// line. If the current line contains only '-', '?', and ':' indicators, a new +// block collection may start at the current line. The following examples +// illustrate this case: +// +// 1. Collections in a sequence: +// +// - - item 1 +// - item 2 +// - key 1: value 1 +// key 2: value 2 +// - ? complex key +// : complex value +// +// Tokens: +// +// STREAM-START(utf-8) +// BLOCK-SEQUENCE-START +// BLOCK-ENTRY +// BLOCK-SEQUENCE-START +// BLOCK-ENTRY +// SCALAR("item 1",plain) +// BLOCK-ENTRY +// SCALAR("item 2",plain) +// BLOCK-END +// BLOCK-ENTRY +// BLOCK-MAPPING-START +// KEY +// SCALAR("key 1",plain) +// VALUE +// SCALAR("value 1",plain) +// KEY +// SCALAR("key 2",plain) +// VALUE +// SCALAR("value 2",plain) +// BLOCK-END +// BLOCK-ENTRY +// BLOCK-MAPPING-START +// KEY +// SCALAR("complex key") +// VALUE +// SCALAR("complex value") +// BLOCK-END +// BLOCK-END +// STREAM-END +// +// 2. Collections in a mapping: +// +// ? a sequence +// : - item 1 +// - item 2 +// ? a mapping +// : key 1: value 1 +// key 2: value 2 +// +// Tokens: +// +// STREAM-START(utf-8) +// BLOCK-MAPPING-START +// KEY +// SCALAR("a sequence",plain) +// VALUE +// BLOCK-SEQUENCE-START +// BLOCK-ENTRY +// SCALAR("item 1",plain) +// BLOCK-ENTRY +// SCALAR("item 2",plain) +// BLOCK-END +// KEY +// SCALAR("a mapping",plain) +// VALUE +// BLOCK-MAPPING-START +// KEY +// SCALAR("key 1",plain) +// VALUE +// SCALAR("value 1",plain) +// KEY +// SCALAR("key 2",plain) +// VALUE +// SCALAR("value 2",plain) +// BLOCK-END +// BLOCK-END +// STREAM-END +// +// YAML also permits non-indented sequences if they are included into a block +// mapping. In this case, the token BLOCK-SEQUENCE-START is not produced: +// +// key: +// - item 1 # BLOCK-SEQUENCE-START is NOT produced here. +// - item 2 +// +// Tokens: +// +// STREAM-START(utf-8) +// BLOCK-MAPPING-START +// KEY +// SCALAR("key",plain) +// VALUE +// BLOCK-ENTRY +// SCALAR("item 1",plain) +// BLOCK-ENTRY +// SCALAR("item 2",plain) +// BLOCK-END +// + +// Ensure that the buffer contains the required number of characters. +// Return true on success, false on failure (reader error or memory error). +func cache(parser *yaml_parser_t, length int) bool { + // [Go] This was inlined: !cache(A, B) -> unread < B && !update(A, B) + return parser.unread >= length || yaml_parser_update_buffer(parser, length) +} + +// Advance the buffer pointer. +func skip(parser *yaml_parser_t) { + parser.mark.index++ + parser.mark.column++ + parser.unread-- + parser.buffer_pos += width(parser.buffer[parser.buffer_pos]) +} + +func skip_line(parser *yaml_parser_t) { + if is_crlf(parser.buffer, parser.buffer_pos) { + parser.mark.index += 2 + parser.mark.column = 0 + parser.mark.line++ + parser.unread -= 2 + parser.buffer_pos += 2 + } else if is_break(parser.buffer, parser.buffer_pos) { + parser.mark.index++ + parser.mark.column = 0 + parser.mark.line++ + parser.unread-- + parser.buffer_pos += width(parser.buffer[parser.buffer_pos]) + } +} + +// Copy a character to a string buffer and advance pointers. +func read(parser *yaml_parser_t, s []byte) []byte { + w := width(parser.buffer[parser.buffer_pos]) + if w == 0 { + panic("invalid character sequence") + } + if len(s) == 0 { + s = make([]byte, 0, 32) + } + if w == 1 && len(s)+w <= cap(s) { + s = s[:len(s)+1] + s[len(s)-1] = parser.buffer[parser.buffer_pos] + parser.buffer_pos++ + } else { + s = append(s, parser.buffer[parser.buffer_pos:parser.buffer_pos+w]...) + parser.buffer_pos += w + } + parser.mark.index++ + parser.mark.column++ + parser.unread-- + return s +} + +// Copy a line break character to a string buffer and advance pointers. +func read_line(parser *yaml_parser_t, s []byte) []byte { + buf := parser.buffer + pos := parser.buffer_pos + switch { + case buf[pos] == '\r' && buf[pos+1] == '\n': + // CR LF . LF + s = append(s, '\n') + parser.buffer_pos += 2 + parser.mark.index++ + parser.unread-- + case buf[pos] == '\r' || buf[pos] == '\n': + // CR|LF . LF + s = append(s, '\n') + parser.buffer_pos += 1 + case buf[pos] == '\xC2' && buf[pos+1] == '\x85': + // NEL . LF + s = append(s, '\n') + parser.buffer_pos += 2 + case buf[pos] == '\xE2' && buf[pos+1] == '\x80' && (buf[pos+2] == '\xA8' || buf[pos+2] == '\xA9'): + // LS|PS . LS|PS + s = append(s, buf[parser.buffer_pos:pos+3]...) + parser.buffer_pos += 3 + default: + return s + } + parser.mark.index++ + parser.mark.column = 0 + parser.mark.line++ + parser.unread-- + return s +} + +// Get the next token. +func yaml_parser_scan(parser *yaml_parser_t, token *yaml_token_t) bool { + // Erase the token object. + *token = yaml_token_t{} // [Go] Is this necessary? + + // No tokens after STREAM-END or error. + if parser.stream_end_produced || parser.error != yaml_NO_ERROR { + return true + } + + // Ensure that the tokens queue contains enough tokens. + if !parser.token_available { + if !yaml_parser_fetch_more_tokens(parser) { + return false + } + } + + // Fetch the next token from the queue. + *token = parser.tokens[parser.tokens_head] + parser.tokens_head++ + parser.tokens_parsed++ + parser.token_available = false + + if token.typ == yaml_STREAM_END_TOKEN { + parser.stream_end_produced = true + } + return true +} + +// Set the scanner error and return false. +func yaml_parser_set_scanner_error(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string) bool { + parser.error = yaml_SCANNER_ERROR + parser.context = context + parser.context_mark = context_mark + parser.problem = problem + parser.problem_mark = parser.mark + return false +} + +func yaml_parser_set_scanner_tag_error(parser *yaml_parser_t, directive bool, context_mark yaml_mark_t, problem string) bool { + context := "while parsing a tag" + if directive { + context = "while parsing a %TAG directive" + } + return yaml_parser_set_scanner_error(parser, context, context_mark, "did not find URI escaped octet") +} + +func trace(args ...interface{}) func() { + pargs := append([]interface{}{"+++"}, args...) + fmt.Println(pargs...) + pargs = append([]interface{}{"---"}, args...) + return func() { fmt.Println(pargs...) } +} + +// Ensure that the tokens queue contains at least one token which can be +// returned to the Parser. +func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool { + // While we need more tokens to fetch, do it. + for { + // Check if we really need to fetch more tokens. + need_more_tokens := false + + if parser.tokens_head == len(parser.tokens) { + // Queue is empty. + need_more_tokens = true + } else { + // Check if any potential simple key may occupy the head position. + if !yaml_parser_stale_simple_keys(parser) { + return false + } + + for i := range parser.simple_keys { + simple_key := &parser.simple_keys[i] + if simple_key.possible && simple_key.token_number == parser.tokens_parsed { + need_more_tokens = true + break + } + } + } + + // We are finished. + if !need_more_tokens { + break + } + // Fetch the next token. + if !yaml_parser_fetch_next_token(parser) { + return false + } + } + + parser.token_available = true + return true +} + +// The dispatcher for token fetchers. +func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool { + // Ensure that the buffer is initialized. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + + // Check if we just started scanning. Fetch STREAM-START then. + if !parser.stream_start_produced { + return yaml_parser_fetch_stream_start(parser) + } + + // Eat whitespaces and comments until we reach the next token. + if !yaml_parser_scan_to_next_token(parser) { + return false + } + + // Remove obsolete potential simple keys. + if !yaml_parser_stale_simple_keys(parser) { + return false + } + + // Check the indentation level against the current column. + if !yaml_parser_unroll_indent(parser, parser.mark.column) { + return false + } + + // Ensure that the buffer contains at least 4 characters. 4 is the length + // of the longest indicators ('--- ' and '... '). + if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) { + return false + } + + // Is it the end of the stream? + if is_z(parser.buffer, parser.buffer_pos) { + return yaml_parser_fetch_stream_end(parser) + } + + // Is it a directive? + if parser.mark.column == 0 && parser.buffer[parser.buffer_pos] == '%' { + return yaml_parser_fetch_directive(parser) + } + + buf := parser.buffer + pos := parser.buffer_pos + + // Is it the document start indicator? + if parser.mark.column == 0 && buf[pos] == '-' && buf[pos+1] == '-' && buf[pos+2] == '-' && is_blankz(buf, pos+3) { + return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_START_TOKEN) + } + + // Is it the document end indicator? + if parser.mark.column == 0 && buf[pos] == '.' && buf[pos+1] == '.' && buf[pos+2] == '.' && is_blankz(buf, pos+3) { + return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_END_TOKEN) + } + + // Is it the flow sequence start indicator? + if buf[pos] == '[' { + return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_SEQUENCE_START_TOKEN) + } + + // Is it the flow mapping start indicator? + if parser.buffer[parser.buffer_pos] == '{' { + return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_MAPPING_START_TOKEN) + } + + // Is it the flow sequence end indicator? + if parser.buffer[parser.buffer_pos] == ']' { + return yaml_parser_fetch_flow_collection_end(parser, + yaml_FLOW_SEQUENCE_END_TOKEN) + } + + // Is it the flow mapping end indicator? + if parser.buffer[parser.buffer_pos] == '}' { + return yaml_parser_fetch_flow_collection_end(parser, + yaml_FLOW_MAPPING_END_TOKEN) + } + + // Is it the flow entry indicator? + if parser.buffer[parser.buffer_pos] == ',' { + return yaml_parser_fetch_flow_entry(parser) + } + + // Is it the block entry indicator? + if parser.buffer[parser.buffer_pos] == '-' && is_blankz(parser.buffer, parser.buffer_pos+1) { + return yaml_parser_fetch_block_entry(parser) + } + + // Is it the key indicator? + if parser.buffer[parser.buffer_pos] == '?' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) { + return yaml_parser_fetch_key(parser) + } + + // Is it the value indicator? + if parser.buffer[parser.buffer_pos] == ':' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) { + return yaml_parser_fetch_value(parser) + } + + // Is it an alias? + if parser.buffer[parser.buffer_pos] == '*' { + return yaml_parser_fetch_anchor(parser, yaml_ALIAS_TOKEN) + } + + // Is it an anchor? + if parser.buffer[parser.buffer_pos] == '&' { + return yaml_parser_fetch_anchor(parser, yaml_ANCHOR_TOKEN) + } + + // Is it a tag? + if parser.buffer[parser.buffer_pos] == '!' { + return yaml_parser_fetch_tag(parser) + } + + // Is it a literal scalar? + if parser.buffer[parser.buffer_pos] == '|' && parser.flow_level == 0 { + return yaml_parser_fetch_block_scalar(parser, true) + } + + // Is it a folded scalar? + if parser.buffer[parser.buffer_pos] == '>' && parser.flow_level == 0 { + return yaml_parser_fetch_block_scalar(parser, false) + } + + // Is it a single-quoted scalar? + if parser.buffer[parser.buffer_pos] == '\'' { + return yaml_parser_fetch_flow_scalar(parser, true) + } + + // Is it a double-quoted scalar? + if parser.buffer[parser.buffer_pos] == '"' { + return yaml_parser_fetch_flow_scalar(parser, false) + } + + // Is it a plain scalar? + // + // A plain scalar may start with any non-blank characters except + // + // '-', '?', ':', ',', '[', ']', '{', '}', + // '#', '&', '*', '!', '|', '>', '\'', '\"', + // '%', '@', '`'. + // + // In the block context (and, for the '-' indicator, in the flow context + // too), it may also start with the characters + // + // '-', '?', ':' + // + // if it is followed by a non-space character. + // + // The last rule is more restrictive than the specification requires. + // [Go] Make this logic more reasonable. + //switch parser.buffer[parser.buffer_pos] { + //case '-', '?', ':', ',', '?', '-', ',', ':', ']', '[', '}', '{', '&', '#', '!', '*', '>', '|', '"', '\'', '@', '%', '-', '`': + //} + if !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '-' || + parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':' || + parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '[' || + parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' || + parser.buffer[parser.buffer_pos] == '}' || parser.buffer[parser.buffer_pos] == '#' || + parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '*' || + parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '|' || + parser.buffer[parser.buffer_pos] == '>' || parser.buffer[parser.buffer_pos] == '\'' || + parser.buffer[parser.buffer_pos] == '"' || parser.buffer[parser.buffer_pos] == '%' || + parser.buffer[parser.buffer_pos] == '@' || parser.buffer[parser.buffer_pos] == '`') || + (parser.buffer[parser.buffer_pos] == '-' && !is_blank(parser.buffer, parser.buffer_pos+1)) || + (parser.flow_level == 0 && + (parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':') && + !is_blankz(parser.buffer, parser.buffer_pos+1)) { + return yaml_parser_fetch_plain_scalar(parser) + } + + // If we don't determine the token type so far, it is an error. + return yaml_parser_set_scanner_error(parser, + "while scanning for the next token", parser.mark, + "found character that cannot start any token") +} + +// Check the list of potential simple keys and remove the positions that +// cannot contain simple keys anymore. +func yaml_parser_stale_simple_keys(parser *yaml_parser_t) bool { + // Check for a potential simple key for each flow level. + for i := range parser.simple_keys { + simple_key := &parser.simple_keys[i] + + // The specification requires that a simple key + // + // - is limited to a single line, + // - is shorter than 1024 characters. + if simple_key.possible && (simple_key.mark.line < parser.mark.line || simple_key.mark.index+1024 < parser.mark.index) { + + // Check if the potential simple key to be removed is required. + if simple_key.required { + return yaml_parser_set_scanner_error(parser, + "while scanning a simple key", simple_key.mark, + "could not find expected ':'") + } + simple_key.possible = false + } + } + return true +} + +// Check if a simple key may start at the current position and add it if +// needed. +func yaml_parser_save_simple_key(parser *yaml_parser_t) bool { + // A simple key is required at the current position if the scanner is in + // the block context and the current column coincides with the indentation + // level. + + required := parser.flow_level == 0 && parser.indent == parser.mark.column + + // A simple key is required only when it is the first token in the current + // line. Therefore it is always allowed. But we add a check anyway. + if required && !parser.simple_key_allowed { + panic("should not happen") + } + + // + // If the current position may start a simple key, save it. + // + if parser.simple_key_allowed { + simple_key := yaml_simple_key_t{ + possible: true, + required: required, + token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head), + } + simple_key.mark = parser.mark + + if !yaml_parser_remove_simple_key(parser) { + return false + } + parser.simple_keys[len(parser.simple_keys)-1] = simple_key + } + return true +} + +// Remove a potential simple key at the current flow level. +func yaml_parser_remove_simple_key(parser *yaml_parser_t) bool { + i := len(parser.simple_keys) - 1 + if parser.simple_keys[i].possible { + // If the key is required, it is an error. + if parser.simple_keys[i].required { + return yaml_parser_set_scanner_error(parser, + "while scanning a simple key", parser.simple_keys[i].mark, + "could not find expected ':'") + } + } + // Remove the key from the stack. + parser.simple_keys[i].possible = false + return true +} + +// Increase the flow level and resize the simple key list if needed. +func yaml_parser_increase_flow_level(parser *yaml_parser_t) bool { + // Reset the simple key on the next level. + parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{}) + + // Increase the flow level. + parser.flow_level++ + return true +} + +// Decrease the flow level. +func yaml_parser_decrease_flow_level(parser *yaml_parser_t) bool { + if parser.flow_level > 0 { + parser.flow_level-- + parser.simple_keys = parser.simple_keys[:len(parser.simple_keys)-1] + } + return true +} + +// Push the current indentation level to the stack and set the new level +// the current column is greater than the indentation level. In this case, +// append or insert the specified token into the token queue. +func yaml_parser_roll_indent(parser *yaml_parser_t, column, number int, typ yaml_token_type_t, mark yaml_mark_t) bool { + // In the flow context, do nothing. + if parser.flow_level > 0 { + return true + } + + if parser.indent < column { + // Push the current indentation level to the stack and set the new + // indentation level. + parser.indents = append(parser.indents, parser.indent) + parser.indent = column + + // Create a token and insert it into the queue. + token := yaml_token_t{ + typ: typ, + start_mark: mark, + end_mark: mark, + } + if number > -1 { + number -= parser.tokens_parsed + } + yaml_insert_token(parser, number, &token) + } + return true +} + +// Pop indentation levels from the indents stack until the current level +// becomes less or equal to the column. For each indentation level, append +// the BLOCK-END token. +func yaml_parser_unroll_indent(parser *yaml_parser_t, column int) bool { + // In the flow context, do nothing. + if parser.flow_level > 0 { + return true + } + + // Loop through the indentation levels in the stack. + for parser.indent > column { + // Create a token and append it to the queue. + token := yaml_token_t{ + typ: yaml_BLOCK_END_TOKEN, + start_mark: parser.mark, + end_mark: parser.mark, + } + yaml_insert_token(parser, -1, &token) + + // Pop the indentation level. + parser.indent = parser.indents[len(parser.indents)-1] + parser.indents = parser.indents[:len(parser.indents)-1] + } + return true +} + +// Initialize the scanner and produce the STREAM-START token. +func yaml_parser_fetch_stream_start(parser *yaml_parser_t) bool { + + // Set the initial indentation. + parser.indent = -1 + + // Initialize the simple key stack. + parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{}) + + // A simple key is allowed at the beginning of the stream. + parser.simple_key_allowed = true + + // We have started. + parser.stream_start_produced = true + + // Create the STREAM-START token and append it to the queue. + token := yaml_token_t{ + typ: yaml_STREAM_START_TOKEN, + start_mark: parser.mark, + end_mark: parser.mark, + encoding: parser.encoding, + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the STREAM-END token and shut down the scanner. +func yaml_parser_fetch_stream_end(parser *yaml_parser_t) bool { + + // Force new line. + if parser.mark.column != 0 { + parser.mark.column = 0 + parser.mark.line++ + } + + // Reset the indentation level. + if !yaml_parser_unroll_indent(parser, -1) { + return false + } + + // Reset simple keys. + if !yaml_parser_remove_simple_key(parser) { + return false + } + + parser.simple_key_allowed = false + + // Create the STREAM-END token and append it to the queue. + token := yaml_token_t{ + typ: yaml_STREAM_END_TOKEN, + start_mark: parser.mark, + end_mark: parser.mark, + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token. +func yaml_parser_fetch_directive(parser *yaml_parser_t) bool { + // Reset the indentation level. + if !yaml_parser_unroll_indent(parser, -1) { + return false + } + + // Reset simple keys. + if !yaml_parser_remove_simple_key(parser) { + return false + } + + parser.simple_key_allowed = false + + // Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. + token := yaml_token_t{} + if !yaml_parser_scan_directive(parser, &token) { + return false + } + // Append the token to the queue. + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the DOCUMENT-START or DOCUMENT-END token. +func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, typ yaml_token_type_t) bool { + // Reset the indentation level. + if !yaml_parser_unroll_indent(parser, -1) { + return false + } + + // Reset simple keys. + if !yaml_parser_remove_simple_key(parser) { + return false + } + + parser.simple_key_allowed = false + + // Consume the token. + start_mark := parser.mark + + skip(parser) + skip(parser) + skip(parser) + + end_mark := parser.mark + + // Create the DOCUMENT-START or DOCUMENT-END token. + token := yaml_token_t{ + typ: typ, + start_mark: start_mark, + end_mark: end_mark, + } + // Append the token to the queue. + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token. +func yaml_parser_fetch_flow_collection_start(parser *yaml_parser_t, typ yaml_token_type_t) bool { + // The indicators '[' and '{' may start a simple key. + if !yaml_parser_save_simple_key(parser) { + return false + } + + // Increase the flow level. + if !yaml_parser_increase_flow_level(parser) { + return false + } + + // A simple key may follow the indicators '[' and '{'. + parser.simple_key_allowed = true + + // Consume the token. + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + // Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. + token := yaml_token_t{ + typ: typ, + start_mark: start_mark, + end_mark: end_mark, + } + // Append the token to the queue. + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token. +func yaml_parser_fetch_flow_collection_end(parser *yaml_parser_t, typ yaml_token_type_t) bool { + // Reset any potential simple key on the current flow level. + if !yaml_parser_remove_simple_key(parser) { + return false + } + + // Decrease the flow level. + if !yaml_parser_decrease_flow_level(parser) { + return false + } + + // No simple keys after the indicators ']' and '}'. + parser.simple_key_allowed = false + + // Consume the token. + + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + // Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token. + token := yaml_token_t{ + typ: typ, + start_mark: start_mark, + end_mark: end_mark, + } + // Append the token to the queue. + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the FLOW-ENTRY token. +func yaml_parser_fetch_flow_entry(parser *yaml_parser_t) bool { + // Reset any potential simple keys on the current flow level. + if !yaml_parser_remove_simple_key(parser) { + return false + } + + // Simple keys are allowed after ','. + parser.simple_key_allowed = true + + // Consume the token. + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + // Create the FLOW-ENTRY token and append it to the queue. + token := yaml_token_t{ + typ: yaml_FLOW_ENTRY_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the BLOCK-ENTRY token. +func yaml_parser_fetch_block_entry(parser *yaml_parser_t) bool { + // Check if the scanner is in the block context. + if parser.flow_level == 0 { + // Check if we are allowed to start a new entry. + if !parser.simple_key_allowed { + return yaml_parser_set_scanner_error(parser, "", parser.mark, + "block sequence entries are not allowed in this context") + } + // Add the BLOCK-SEQUENCE-START token if needed. + if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_SEQUENCE_START_TOKEN, parser.mark) { + return false + } + } else { + // It is an error for the '-' indicator to occur in the flow context, + // but we let the Parser detect and report about it because the Parser + // is able to point to the context. + } + + // Reset any potential simple keys on the current flow level. + if !yaml_parser_remove_simple_key(parser) { + return false + } + + // Simple keys are allowed after '-'. + parser.simple_key_allowed = true + + // Consume the token. + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + // Create the BLOCK-ENTRY token and append it to the queue. + token := yaml_token_t{ + typ: yaml_BLOCK_ENTRY_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the KEY token. +func yaml_parser_fetch_key(parser *yaml_parser_t) bool { + + // In the block context, additional checks are required. + if parser.flow_level == 0 { + // Check if we are allowed to start a new key (not nessesary simple). + if !parser.simple_key_allowed { + return yaml_parser_set_scanner_error(parser, "", parser.mark, + "mapping keys are not allowed in this context") + } + // Add the BLOCK-MAPPING-START token if needed. + if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) { + return false + } + } + + // Reset any potential simple keys on the current flow level. + if !yaml_parser_remove_simple_key(parser) { + return false + } + + // Simple keys are allowed after '?' in the block context. + parser.simple_key_allowed = parser.flow_level == 0 + + // Consume the token. + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + // Create the KEY token and append it to the queue. + token := yaml_token_t{ + typ: yaml_KEY_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the VALUE token. +func yaml_parser_fetch_value(parser *yaml_parser_t) bool { + + simple_key := &parser.simple_keys[len(parser.simple_keys)-1] + + // Have we found a simple key? + if simple_key.possible { + // Create the KEY token and insert it into the queue. + token := yaml_token_t{ + typ: yaml_KEY_TOKEN, + start_mark: simple_key.mark, + end_mark: simple_key.mark, + } + yaml_insert_token(parser, simple_key.token_number-parser.tokens_parsed, &token) + + // In the block context, we may need to add the BLOCK-MAPPING-START token. + if !yaml_parser_roll_indent(parser, simple_key.mark.column, + simple_key.token_number, + yaml_BLOCK_MAPPING_START_TOKEN, simple_key.mark) { + return false + } + + // Remove the simple key. + simple_key.possible = false + + // A simple key cannot follow another simple key. + parser.simple_key_allowed = false + + } else { + // The ':' indicator follows a complex key. + + // In the block context, extra checks are required. + if parser.flow_level == 0 { + + // Check if we are allowed to start a complex value. + if !parser.simple_key_allowed { + return yaml_parser_set_scanner_error(parser, "", parser.mark, + "mapping values are not allowed in this context") + } + + // Add the BLOCK-MAPPING-START token if needed. + if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) { + return false + } + } + + // Simple keys after ':' are allowed in the block context. + parser.simple_key_allowed = parser.flow_level == 0 + } + + // Consume the token. + start_mark := parser.mark + skip(parser) + end_mark := parser.mark + + // Create the VALUE token and append it to the queue. + token := yaml_token_t{ + typ: yaml_VALUE_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the ALIAS or ANCHOR token. +func yaml_parser_fetch_anchor(parser *yaml_parser_t, typ yaml_token_type_t) bool { + // An anchor or an alias could be a simple key. + if !yaml_parser_save_simple_key(parser) { + return false + } + + // A simple key cannot follow an anchor or an alias. + parser.simple_key_allowed = false + + // Create the ALIAS or ANCHOR token and append it to the queue. + var token yaml_token_t + if !yaml_parser_scan_anchor(parser, &token, typ) { + return false + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the TAG token. +func yaml_parser_fetch_tag(parser *yaml_parser_t) bool { + // A tag could be a simple key. + if !yaml_parser_save_simple_key(parser) { + return false + } + + // A simple key cannot follow a tag. + parser.simple_key_allowed = false + + // Create the TAG token and append it to the queue. + var token yaml_token_t + if !yaml_parser_scan_tag(parser, &token) { + return false + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens. +func yaml_parser_fetch_block_scalar(parser *yaml_parser_t, literal bool) bool { + // Remove any potential simple keys. + if !yaml_parser_remove_simple_key(parser) { + return false + } + + // A simple key may follow a block scalar. + parser.simple_key_allowed = true + + // Create the SCALAR token and append it to the queue. + var token yaml_token_t + if !yaml_parser_scan_block_scalar(parser, &token, literal) { + return false + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens. +func yaml_parser_fetch_flow_scalar(parser *yaml_parser_t, single bool) bool { + // A plain scalar could be a simple key. + if !yaml_parser_save_simple_key(parser) { + return false + } + + // A simple key cannot follow a flow scalar. + parser.simple_key_allowed = false + + // Create the SCALAR token and append it to the queue. + var token yaml_token_t + if !yaml_parser_scan_flow_scalar(parser, &token, single) { + return false + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Produce the SCALAR(...,plain) token. +func yaml_parser_fetch_plain_scalar(parser *yaml_parser_t) bool { + // A plain scalar could be a simple key. + if !yaml_parser_save_simple_key(parser) { + return false + } + + // A simple key cannot follow a flow scalar. + parser.simple_key_allowed = false + + // Create the SCALAR token and append it to the queue. + var token yaml_token_t + if !yaml_parser_scan_plain_scalar(parser, &token) { + return false + } + yaml_insert_token(parser, -1, &token) + return true +} + +// Eat whitespaces and comments until the next token is found. +func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool { + + // Until the next token is not found. + for { + // Allow the BOM mark to start a line. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + if parser.mark.column == 0 && is_bom(parser.buffer, parser.buffer_pos) { + skip(parser) + } + + // Eat whitespaces. + // Tabs are allowed: + // - in the flow context + // - in the block context, but not at the beginning of the line or + // after '-', '?', or ':' (complex value). + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + + for parser.buffer[parser.buffer_pos] == ' ' || ((parser.flow_level > 0 || !parser.simple_key_allowed) && parser.buffer[parser.buffer_pos] == '\t') { + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Eat a comment until a line break. + if parser.buffer[parser.buffer_pos] == '#' { + for !is_breakz(parser.buffer, parser.buffer_pos) { + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + } + + // If it is a line break, eat it. + if is_break(parser.buffer, parser.buffer_pos) { + if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { + return false + } + skip_line(parser) + + // In the block context, a new line may start a simple key. + if parser.flow_level == 0 { + parser.simple_key_allowed = true + } + } else { + break // We have found a token. + } + } + + return true +} + +// Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token. +// +// Scope: +// %YAML 1.1 # a comment \n +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +// %TAG !yaml! tag:yaml.org,2002: \n +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +// +func yaml_parser_scan_directive(parser *yaml_parser_t, token *yaml_token_t) bool { + // Eat '%'. + start_mark := parser.mark + skip(parser) + + // Scan the directive name. + var name []byte + if !yaml_parser_scan_directive_name(parser, start_mark, &name) { + return false + } + + // Is it a YAML directive? + if bytes.Equal(name, []byte("YAML")) { + // Scan the VERSION directive value. + var major, minor int8 + if !yaml_parser_scan_version_directive_value(parser, start_mark, &major, &minor) { + return false + } + end_mark := parser.mark + + // Create a VERSION-DIRECTIVE token. + *token = yaml_token_t{ + typ: yaml_VERSION_DIRECTIVE_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + major: major, + minor: minor, + } + + // Is it a TAG directive? + } else if bytes.Equal(name, []byte("TAG")) { + // Scan the TAG directive value. + var handle, prefix []byte + if !yaml_parser_scan_tag_directive_value(parser, start_mark, &handle, &prefix) { + return false + } + end_mark := parser.mark + + // Create a TAG-DIRECTIVE token. + *token = yaml_token_t{ + typ: yaml_TAG_DIRECTIVE_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + value: handle, + prefix: prefix, + } + + // Unknown directive. + } else { + yaml_parser_set_scanner_error(parser, "while scanning a directive", + start_mark, "found unknown directive name") + return false + } + + // Eat the rest of the line including any comments. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + + for is_blank(parser.buffer, parser.buffer_pos) { + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + if parser.buffer[parser.buffer_pos] == '#' { + for !is_breakz(parser.buffer, parser.buffer_pos) { + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + } + + // Check if we are at the end of the line. + if !is_breakz(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a directive", + start_mark, "did not find expected comment or line break") + return false + } + + // Eat a line break. + if is_break(parser.buffer, parser.buffer_pos) { + if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { + return false + } + skip_line(parser) + } + + return true +} + +// Scan the directive name. +// +// Scope: +// %YAML 1.1 # a comment \n +// ^^^^ +// %TAG !yaml! tag:yaml.org,2002: \n +// ^^^ +// +func yaml_parser_scan_directive_name(parser *yaml_parser_t, start_mark yaml_mark_t, name *[]byte) bool { + // Consume the directive name. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + + var s []byte + for is_alpha(parser.buffer, parser.buffer_pos) { + s = read(parser, s) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Check if the name is empty. + if len(s) == 0 { + yaml_parser_set_scanner_error(parser, "while scanning a directive", + start_mark, "could not find expected directive name") + return false + } + + // Check for an blank character after the name. + if !is_blankz(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a directive", + start_mark, "found unexpected non-alphabetical character") + return false + } + *name = s + return true +} + +// Scan the value of VERSION-DIRECTIVE. +// +// Scope: +// %YAML 1.1 # a comment \n +// ^^^^^^ +func yaml_parser_scan_version_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, major, minor *int8) bool { + // Eat whitespaces. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + for is_blank(parser.buffer, parser.buffer_pos) { + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Consume the major version number. + if !yaml_parser_scan_version_directive_number(parser, start_mark, major) { + return false + } + + // Eat '.'. + if parser.buffer[parser.buffer_pos] != '.' { + return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", + start_mark, "did not find expected digit or '.' character") + } + + skip(parser) + + // Consume the minor version number. + if !yaml_parser_scan_version_directive_number(parser, start_mark, minor) { + return false + } + return true +} + +const max_number_length = 2 + +// Scan the version number of VERSION-DIRECTIVE. +// +// Scope: +// %YAML 1.1 # a comment \n +// ^ +// %YAML 1.1 # a comment \n +// ^ +func yaml_parser_scan_version_directive_number(parser *yaml_parser_t, start_mark yaml_mark_t, number *int8) bool { + + // Repeat while the next character is digit. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + var value, length int8 + for is_digit(parser.buffer, parser.buffer_pos) { + // Check if the number is too long. + length++ + if length > max_number_length { + return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", + start_mark, "found extremely long version number") + } + value = value*10 + int8(as_digit(parser.buffer, parser.buffer_pos)) + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Check if the number was present. + if length == 0 { + return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", + start_mark, "did not find expected version number") + } + *number = value + return true +} + +// Scan the value of a TAG-DIRECTIVE token. +// +// Scope: +// %TAG !yaml! tag:yaml.org,2002: \n +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +// +func yaml_parser_scan_tag_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, handle, prefix *[]byte) bool { + var handle_value, prefix_value []byte + + // Eat whitespaces. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + + for is_blank(parser.buffer, parser.buffer_pos) { + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Scan a handle. + if !yaml_parser_scan_tag_handle(parser, true, start_mark, &handle_value) { + return false + } + + // Expect a whitespace. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + if !is_blank(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", + start_mark, "did not find expected whitespace") + return false + } + + // Eat whitespaces. + for is_blank(parser.buffer, parser.buffer_pos) { + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Scan a prefix. + if !yaml_parser_scan_tag_uri(parser, true, nil, start_mark, &prefix_value) { + return false + } + + // Expect a whitespace or line break. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + if !is_blankz(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", + start_mark, "did not find expected whitespace or line break") + return false + } + + *handle = handle_value + *prefix = prefix_value + return true +} + +func yaml_parser_scan_anchor(parser *yaml_parser_t, token *yaml_token_t, typ yaml_token_type_t) bool { + var s []byte + + // Eat the indicator character. + start_mark := parser.mark + skip(parser) + + // Consume the value. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + + for is_alpha(parser.buffer, parser.buffer_pos) { + s = read(parser, s) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + end_mark := parser.mark + + /* + * Check if length of the anchor is greater than 0 and it is followed by + * a whitespace character or one of the indicators: + * + * '?', ':', ',', ']', '}', '%', '@', '`'. + */ + + if len(s) == 0 || + !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '?' || + parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == ',' || + parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '}' || + parser.buffer[parser.buffer_pos] == '%' || parser.buffer[parser.buffer_pos] == '@' || + parser.buffer[parser.buffer_pos] == '`') { + context := "while scanning an alias" + if typ == yaml_ANCHOR_TOKEN { + context = "while scanning an anchor" + } + yaml_parser_set_scanner_error(parser, context, start_mark, + "did not find expected alphabetic or numeric character") + return false + } + + // Create a token. + *token = yaml_token_t{ + typ: typ, + start_mark: start_mark, + end_mark: end_mark, + value: s, + } + + return true +} + +/* + * Scan a TAG token. + */ + +func yaml_parser_scan_tag(parser *yaml_parser_t, token *yaml_token_t) bool { + var handle, suffix []byte + + start_mark := parser.mark + + // Check if the tag is in the canonical form. + if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { + return false + } + + if parser.buffer[parser.buffer_pos+1] == '<' { + // Keep the handle as '' + + // Eat '!<' + skip(parser) + skip(parser) + + // Consume the tag value. + if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) { + return false + } + + // Check for '>' and eat it. + if parser.buffer[parser.buffer_pos] != '>' { + yaml_parser_set_scanner_error(parser, "while scanning a tag", + start_mark, "did not find the expected '>'") + return false + } + + skip(parser) + } else { + // The tag has either the '!suffix' or the '!handle!suffix' form. + + // First, try to scan a handle. + if !yaml_parser_scan_tag_handle(parser, false, start_mark, &handle) { + return false + } + + // Check if it is, indeed, handle. + if handle[0] == '!' && len(handle) > 1 && handle[len(handle)-1] == '!' { + // Scan the suffix now. + if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) { + return false + } + } else { + // It wasn't a handle after all. Scan the rest of the tag. + if !yaml_parser_scan_tag_uri(parser, false, handle, start_mark, &suffix) { + return false + } + + // Set the handle to '!'. + handle = []byte{'!'} + + // A special case: the '!' tag. Set the handle to '' and the + // suffix to '!'. + if len(suffix) == 0 { + handle, suffix = suffix, handle + } + } + } + + // Check the character which ends the tag. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + if !is_blankz(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a tag", + start_mark, "did not find expected whitespace or line break") + return false + } + + end_mark := parser.mark + + // Create a token. + *token = yaml_token_t{ + typ: yaml_TAG_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + value: handle, + suffix: suffix, + } + return true +} + +// Scan a tag handle. +func yaml_parser_scan_tag_handle(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, handle *[]byte) bool { + // Check the initial '!' character. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + if parser.buffer[parser.buffer_pos] != '!' { + yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "did not find expected '!'") + return false + } + + var s []byte + + // Copy the '!' character. + s = read(parser, s) + + // Copy all subsequent alphabetical and numerical characters. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + for is_alpha(parser.buffer, parser.buffer_pos) { + s = read(parser, s) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Check if the trailing character is '!' and copy it. + if parser.buffer[parser.buffer_pos] == '!' { + s = read(parser, s) + } else { + // It's either the '!' tag or not really a tag handle. If it's a %TAG + // directive, it's an error. If it's a tag token, it must be a part of URI. + if directive && !(s[0] == '!' && s[1] == 0) { + yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "did not find expected '!'") + return false + } + } + + *handle = s + return true +} + +// Scan a tag. +func yaml_parser_scan_tag_uri(parser *yaml_parser_t, directive bool, head []byte, start_mark yaml_mark_t, uri *[]byte) bool { + //size_t length = head ? strlen((char *)head) : 0 + var s []byte + + // Copy the head if needed. + // + // Note that we don't copy the leading '!' character. + if len(head) > 1 { + s = append(s, head[1:]...) + } + + // Scan the tag. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + + // The set of characters that may appear in URI is as follows: + // + // '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&', + // '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']', + // '%'. + // [Go] Convert this into more reasonable logic. + for is_alpha(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == ';' || + parser.buffer[parser.buffer_pos] == '/' || parser.buffer[parser.buffer_pos] == '?' || + parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == '@' || + parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '=' || + parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '$' || + parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '.' || + parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '~' || + parser.buffer[parser.buffer_pos] == '*' || parser.buffer[parser.buffer_pos] == '\'' || + parser.buffer[parser.buffer_pos] == '(' || parser.buffer[parser.buffer_pos] == ')' || + parser.buffer[parser.buffer_pos] == '[' || parser.buffer[parser.buffer_pos] == ']' || + parser.buffer[parser.buffer_pos] == '%' { + // Check if it is a URI-escape sequence. + if parser.buffer[parser.buffer_pos] == '%' { + if !yaml_parser_scan_uri_escapes(parser, directive, start_mark, &s) { + return false + } + } else { + s = read(parser, s) + } + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Check if the tag is non-empty. + if len(s) == 0 { + yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "did not find expected tag URI") + return false + } + *uri = s + return true +} + +// Decode an URI-escape sequence corresponding to a single UTF-8 character. +func yaml_parser_scan_uri_escapes(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, s *[]byte) bool { + + // Decode the required number of characters. + w := 1024 + for w > 0 { + // Check for a URI-escaped octet. + if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) { + return false + } + + if !(parser.buffer[parser.buffer_pos] == '%' && + is_hex(parser.buffer, parser.buffer_pos+1) && + is_hex(parser.buffer, parser.buffer_pos+2)) { + return yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "did not find URI escaped octet") + } + + // Get the octet. + octet := byte((as_hex(parser.buffer, parser.buffer_pos+1) << 4) + as_hex(parser.buffer, parser.buffer_pos+2)) + + // If it is the leading octet, determine the length of the UTF-8 sequence. + if w == 1024 { + w = width(octet) + if w == 0 { + return yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "found an incorrect leading UTF-8 octet") + } + } else { + // Check if the trailing octet is correct. + if octet&0xC0 != 0x80 { + return yaml_parser_set_scanner_tag_error(parser, directive, + start_mark, "found an incorrect trailing UTF-8 octet") + } + } + + // Copy the octet and move the pointers. + *s = append(*s, octet) + skip(parser) + skip(parser) + skip(parser) + w-- + } + return true +} + +// Scan a block scalar. +func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, literal bool) bool { + // Eat the indicator '|' or '>'. + start_mark := parser.mark + skip(parser) + + // Scan the additional block scalar indicators. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + + // Check for a chomping indicator. + var chomping, increment int + if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' { + // Set the chomping method and eat the indicator. + if parser.buffer[parser.buffer_pos] == '+' { + chomping = +1 + } else { + chomping = -1 + } + skip(parser) + + // Check for an indentation indicator. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + if is_digit(parser.buffer, parser.buffer_pos) { + // Check that the indentation is greater than 0. + if parser.buffer[parser.buffer_pos] == '0' { + yaml_parser_set_scanner_error(parser, "while scanning a block scalar", + start_mark, "found an indentation indicator equal to 0") + return false + } + + // Get the indentation level and eat the indicator. + increment = as_digit(parser.buffer, parser.buffer_pos) + skip(parser) + } + + } else if is_digit(parser.buffer, parser.buffer_pos) { + // Do the same as above, but in the opposite order. + + if parser.buffer[parser.buffer_pos] == '0' { + yaml_parser_set_scanner_error(parser, "while scanning a block scalar", + start_mark, "found an indentation indicator equal to 0") + return false + } + increment = as_digit(parser.buffer, parser.buffer_pos) + skip(parser) + + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' { + if parser.buffer[parser.buffer_pos] == '+' { + chomping = +1 + } else { + chomping = -1 + } + skip(parser) + } + } + + // Eat whitespaces and comments to the end of the line. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + for is_blank(parser.buffer, parser.buffer_pos) { + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + if parser.buffer[parser.buffer_pos] == '#' { + for !is_breakz(parser.buffer, parser.buffer_pos) { + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + } + + // Check if we are at the end of the line. + if !is_breakz(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a block scalar", + start_mark, "did not find expected comment or line break") + return false + } + + // Eat a line break. + if is_break(parser.buffer, parser.buffer_pos) { + if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { + return false + } + skip_line(parser) + } + + end_mark := parser.mark + + // Set the indentation level if it was specified. + var indent int + if increment > 0 { + if parser.indent >= 0 { + indent = parser.indent + increment + } else { + indent = increment + } + } + + // Scan the leading line breaks and determine the indentation level if needed. + var s, leading_break, trailing_breaks []byte + if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) { + return false + } + + // Scan the block scalar content. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + var leading_blank, trailing_blank bool + for parser.mark.column == indent && !is_z(parser.buffer, parser.buffer_pos) { + // We are at the beginning of a non-empty line. + + // Is it a trailing whitespace? + trailing_blank = is_blank(parser.buffer, parser.buffer_pos) + + // Check if we need to fold the leading line break. + if !literal && !leading_blank && !trailing_blank && len(leading_break) > 0 && leading_break[0] == '\n' { + // Do we need to join the lines by space? + if len(trailing_breaks) == 0 { + s = append(s, ' ') + } + } else { + s = append(s, leading_break...) + } + leading_break = leading_break[:0] + + // Append the remaining line breaks. + s = append(s, trailing_breaks...) + trailing_breaks = trailing_breaks[:0] + + // Is it a leading whitespace? + leading_blank = is_blank(parser.buffer, parser.buffer_pos) + + // Consume the current line. + for !is_breakz(parser.buffer, parser.buffer_pos) { + s = read(parser, s) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Consume the line break. + if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { + return false + } + + leading_break = read_line(parser, leading_break) + + // Eat the following indentation spaces and line breaks. + if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) { + return false + } + } + + // Chomp the tail. + if chomping != -1 { + s = append(s, leading_break...) + } + if chomping == 1 { + s = append(s, trailing_breaks...) + } + + // Create a token. + *token = yaml_token_t{ + typ: yaml_SCALAR_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + value: s, + style: yaml_LITERAL_SCALAR_STYLE, + } + if !literal { + token.style = yaml_FOLDED_SCALAR_STYLE + } + return true +} + +// Scan indentation spaces and line breaks for a block scalar. Determine the +// indentation level if needed. +func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, indent *int, breaks *[]byte, start_mark yaml_mark_t, end_mark *yaml_mark_t) bool { + *end_mark = parser.mark + + // Eat the indentation spaces and line breaks. + max_indent := 0 + for { + // Eat the indentation spaces. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + for (*indent == 0 || parser.mark.column < *indent) && is_space(parser.buffer, parser.buffer_pos) { + skip(parser) + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + if parser.mark.column > max_indent { + max_indent = parser.mark.column + } + + // Check for a tab character messing the indentation. + if (*indent == 0 || parser.mark.column < *indent) && is_tab(parser.buffer, parser.buffer_pos) { + return yaml_parser_set_scanner_error(parser, "while scanning a block scalar", + start_mark, "found a tab character where an indentation space is expected") + } + + // Have we found a non-empty line? + if !is_break(parser.buffer, parser.buffer_pos) { + break + } + + // Consume the line break. + if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { + return false + } + // [Go] Should really be returning breaks instead. + *breaks = read_line(parser, *breaks) + *end_mark = parser.mark + } + + // Determine the indentation level if needed. + if *indent == 0 { + *indent = max_indent + if *indent < parser.indent+1 { + *indent = parser.indent + 1 + } + if *indent < 1 { + *indent = 1 + } + } + return true +} + +// Scan a quoted scalar. +func yaml_parser_scan_flow_scalar(parser *yaml_parser_t, token *yaml_token_t, single bool) bool { + // Eat the left quote. + start_mark := parser.mark + skip(parser) + + // Consume the content of the quoted scalar. + var s, leading_break, trailing_breaks, whitespaces []byte + for { + // Check that there are no document indicators at the beginning of the line. + if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) { + return false + } + + if parser.mark.column == 0 && + ((parser.buffer[parser.buffer_pos+0] == '-' && + parser.buffer[parser.buffer_pos+1] == '-' && + parser.buffer[parser.buffer_pos+2] == '-') || + (parser.buffer[parser.buffer_pos+0] == '.' && + parser.buffer[parser.buffer_pos+1] == '.' && + parser.buffer[parser.buffer_pos+2] == '.')) && + is_blankz(parser.buffer, parser.buffer_pos+3) { + yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", + start_mark, "found unexpected document indicator") + return false + } + + // Check for EOF. + if is_z(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", + start_mark, "found unexpected end of stream") + return false + } + + // Consume non-blank characters. + leading_blanks := false + for !is_blankz(parser.buffer, parser.buffer_pos) { + if single && parser.buffer[parser.buffer_pos] == '\'' && parser.buffer[parser.buffer_pos+1] == '\'' { + // Is is an escaped single quote. + s = append(s, '\'') + skip(parser) + skip(parser) + + } else if single && parser.buffer[parser.buffer_pos] == '\'' { + // It is a right single quote. + break + } else if !single && parser.buffer[parser.buffer_pos] == '"' { + // It is a right double quote. + break + + } else if !single && parser.buffer[parser.buffer_pos] == '\\' && is_break(parser.buffer, parser.buffer_pos+1) { + // It is an escaped line break. + if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) { + return false + } + skip(parser) + skip_line(parser) + leading_blanks = true + break + + } else if !single && parser.buffer[parser.buffer_pos] == '\\' { + // It is an escape sequence. + code_length := 0 + + // Check the escape character. + switch parser.buffer[parser.buffer_pos+1] { + case '0': + s = append(s, 0) + case 'a': + s = append(s, '\x07') + case 'b': + s = append(s, '\x08') + case 't', '\t': + s = append(s, '\x09') + case 'n': + s = append(s, '\x0A') + case 'v': + s = append(s, '\x0B') + case 'f': + s = append(s, '\x0C') + case 'r': + s = append(s, '\x0D') + case 'e': + s = append(s, '\x1B') + case ' ': + s = append(s, '\x20') + case '"': + s = append(s, '"') + case '\'': + s = append(s, '\'') + case '\\': + s = append(s, '\\') + case 'N': // NEL (#x85) + s = append(s, '\xC2') + s = append(s, '\x85') + case '_': // #xA0 + s = append(s, '\xC2') + s = append(s, '\xA0') + case 'L': // LS (#x2028) + s = append(s, '\xE2') + s = append(s, '\x80') + s = append(s, '\xA8') + case 'P': // PS (#x2029) + s = append(s, '\xE2') + s = append(s, '\x80') + s = append(s, '\xA9') + case 'x': + code_length = 2 + case 'u': + code_length = 4 + case 'U': + code_length = 8 + default: + yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", + start_mark, "found unknown escape character") + return false + } + + skip(parser) + skip(parser) + + // Consume an arbitrary escape code. + if code_length > 0 { + var value int + + // Scan the character value. + if parser.unread < code_length && !yaml_parser_update_buffer(parser, code_length) { + return false + } + for k := 0; k < code_length; k++ { + if !is_hex(parser.buffer, parser.buffer_pos+k) { + yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", + start_mark, "did not find expected hexdecimal number") + return false + } + value = (value << 4) + as_hex(parser.buffer, parser.buffer_pos+k) + } + + // Check the value and write the character. + if (value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF { + yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", + start_mark, "found invalid Unicode character escape code") + return false + } + if value <= 0x7F { + s = append(s, byte(value)) + } else if value <= 0x7FF { + s = append(s, byte(0xC0+(value>>6))) + s = append(s, byte(0x80+(value&0x3F))) + } else if value <= 0xFFFF { + s = append(s, byte(0xE0+(value>>12))) + s = append(s, byte(0x80+((value>>6)&0x3F))) + s = append(s, byte(0x80+(value&0x3F))) + } else { + s = append(s, byte(0xF0+(value>>18))) + s = append(s, byte(0x80+((value>>12)&0x3F))) + s = append(s, byte(0x80+((value>>6)&0x3F))) + s = append(s, byte(0x80+(value&0x3F))) + } + + // Advance the pointer. + for k := 0; k < code_length; k++ { + skip(parser) + } + } + } else { + // It is a non-escaped non-blank character. + s = read(parser, s) + } + if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { + return false + } + } + + // Check if we are at the end of the scalar. + if single { + if parser.buffer[parser.buffer_pos] == '\'' { + break + } + } else { + if parser.buffer[parser.buffer_pos] == '"' { + break + } + } + + // Consume blank characters. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + + for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) { + if is_blank(parser.buffer, parser.buffer_pos) { + // Consume a space or a tab character. + if !leading_blanks { + whitespaces = read(parser, whitespaces) + } else { + skip(parser) + } + } else { + if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { + return false + } + + // Check if it is a first line break. + if !leading_blanks { + whitespaces = whitespaces[:0] + leading_break = read_line(parser, leading_break) + leading_blanks = true + } else { + trailing_breaks = read_line(parser, trailing_breaks) + } + } + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Join the whitespaces or fold line breaks. + if leading_blanks { + // Do we need to fold line breaks? + if len(leading_break) > 0 && leading_break[0] == '\n' { + if len(trailing_breaks) == 0 { + s = append(s, ' ') + } else { + s = append(s, trailing_breaks...) + } + } else { + s = append(s, leading_break...) + s = append(s, trailing_breaks...) + } + trailing_breaks = trailing_breaks[:0] + leading_break = leading_break[:0] + } else { + s = append(s, whitespaces...) + whitespaces = whitespaces[:0] + } + } + + // Eat the right quote. + skip(parser) + end_mark := parser.mark + + // Create a token. + *token = yaml_token_t{ + typ: yaml_SCALAR_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + value: s, + style: yaml_SINGLE_QUOTED_SCALAR_STYLE, + } + if !single { + token.style = yaml_DOUBLE_QUOTED_SCALAR_STYLE + } + return true +} + +// Scan a plain scalar. +func yaml_parser_scan_plain_scalar(parser *yaml_parser_t, token *yaml_token_t) bool { + + var s, leading_break, trailing_breaks, whitespaces []byte + var leading_blanks bool + var indent = parser.indent + 1 + + start_mark := parser.mark + end_mark := parser.mark + + // Consume the content of the plain scalar. + for { + // Check for a document indicator. + if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) { + return false + } + if parser.mark.column == 0 && + ((parser.buffer[parser.buffer_pos+0] == '-' && + parser.buffer[parser.buffer_pos+1] == '-' && + parser.buffer[parser.buffer_pos+2] == '-') || + (parser.buffer[parser.buffer_pos+0] == '.' && + parser.buffer[parser.buffer_pos+1] == '.' && + parser.buffer[parser.buffer_pos+2] == '.')) && + is_blankz(parser.buffer, parser.buffer_pos+3) { + break + } + + // Check for a comment. + if parser.buffer[parser.buffer_pos] == '#' { + break + } + + // Consume non-blank characters. + for !is_blankz(parser.buffer, parser.buffer_pos) { + + // Check for 'x:x' in the flow context. TODO: Fix the test "spec-08-13". + if parser.flow_level > 0 && + parser.buffer[parser.buffer_pos] == ':' && + !is_blankz(parser.buffer, parser.buffer_pos+1) { + yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", + start_mark, "found unexpected ':'") + return false + } + + // Check for indicators that may end a plain scalar. + if (parser.buffer[parser.buffer_pos] == ':' && is_blankz(parser.buffer, parser.buffer_pos+1)) || + (parser.flow_level > 0 && + (parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == ':' || + parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == '[' || + parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' || + parser.buffer[parser.buffer_pos] == '}')) { + break + } + + // Check if we need to join whitespaces and breaks. + if leading_blanks || len(whitespaces) > 0 { + if leading_blanks { + // Do we need to fold line breaks? + if leading_break[0] == '\n' { + if len(trailing_breaks) == 0 { + s = append(s, ' ') + } else { + s = append(s, trailing_breaks...) + } + } else { + s = append(s, leading_break...) + s = append(s, trailing_breaks...) + } + trailing_breaks = trailing_breaks[:0] + leading_break = leading_break[:0] + leading_blanks = false + } else { + s = append(s, whitespaces...) + whitespaces = whitespaces[:0] + } + } + + // Copy the character. + s = read(parser, s) + + end_mark = parser.mark + if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { + return false + } + } + + // Is it the end? + if !(is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos)) { + break + } + + // Consume blank characters. + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + + for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) { + if is_blank(parser.buffer, parser.buffer_pos) { + + // Check for tab character that abuse indentation. + if leading_blanks && parser.mark.column < indent && is_tab(parser.buffer, parser.buffer_pos) { + yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", + start_mark, "found a tab character that violate indentation") + return false + } + + // Consume a space or a tab character. + if !leading_blanks { + whitespaces = read(parser, whitespaces) + } else { + skip(parser) + } + } else { + if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { + return false + } + + // Check if it is a first line break. + if !leading_blanks { + whitespaces = whitespaces[:0] + leading_break = read_line(parser, leading_break) + leading_blanks = true + } else { + trailing_breaks = read_line(parser, trailing_breaks) + } + } + if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { + return false + } + } + + // Check indentation level. + if parser.flow_level == 0 && parser.mark.column < indent { + break + } + } + + // Create a token. + *token = yaml_token_t{ + typ: yaml_SCALAR_TOKEN, + start_mark: start_mark, + end_mark: end_mark, + value: s, + style: yaml_PLAIN_SCALAR_STYLE, + } + + // Note that we change the 'simple_key_allowed' flag. + if leading_blanks { + parser.simple_key_allowed = true + } + return true +} diff --git a/vendor/gopkg.in/yaml.v2/sorter.go b/vendor/gopkg.in/yaml.v2/sorter.go new file mode 100644 index 00000000..5958822f --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/sorter.go @@ -0,0 +1,104 @@ +package yaml + +import ( + "reflect" + "unicode" +) + +type keyList []reflect.Value + +func (l keyList) Len() int { return len(l) } +func (l keyList) Swap(i, j int) { l[i], l[j] = l[j], l[i] } +func (l keyList) Less(i, j int) bool { + a := l[i] + b := l[j] + ak := a.Kind() + bk := b.Kind() + for (ak == reflect.Interface || ak == reflect.Ptr) && !a.IsNil() { + a = a.Elem() + ak = a.Kind() + } + for (bk == reflect.Interface || bk == reflect.Ptr) && !b.IsNil() { + b = b.Elem() + bk = b.Kind() + } + af, aok := keyFloat(a) + bf, bok := keyFloat(b) + if aok && bok { + if af != bf { + return af < bf + } + if ak != bk { + return ak < bk + } + return numLess(a, b) + } + if ak != reflect.String || bk != reflect.String { + return ak < bk + } + ar, br := []rune(a.String()), []rune(b.String()) + for i := 0; i < len(ar) && i < len(br); i++ { + if ar[i] == br[i] { + continue + } + al := unicode.IsLetter(ar[i]) + bl := unicode.IsLetter(br[i]) + if al && bl { + return ar[i] < br[i] + } + if al || bl { + return bl + } + var ai, bi int + var an, bn int64 + for ai = i; ai < len(ar) && unicode.IsDigit(ar[ai]); ai++ { + an = an*10 + int64(ar[ai]-'0') + } + for bi = i; bi < len(br) && unicode.IsDigit(br[bi]); bi++ { + bn = bn*10 + int64(br[bi]-'0') + } + if an != bn { + return an < bn + } + if ai != bi { + return ai < bi + } + return ar[i] < br[i] + } + return len(ar) < len(br) +} + +// keyFloat returns a float value for v if it is a number/bool +// and whether it is a number/bool or not. +func keyFloat(v reflect.Value) (f float64, ok bool) { + switch v.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return float64(v.Int()), true + case reflect.Float32, reflect.Float64: + return v.Float(), true + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return float64(v.Uint()), true + case reflect.Bool: + if v.Bool() { + return 1, true + } + return 0, true + } + return 0, false +} + +// numLess returns whether a < b. +// a and b must necessarily have the same kind. +func numLess(a, b reflect.Value) bool { + switch a.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return a.Int() < b.Int() + case reflect.Float32, reflect.Float64: + return a.Float() < b.Float() + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return a.Uint() < b.Uint() + case reflect.Bool: + return !a.Bool() && b.Bool() + } + panic("not a number") +} diff --git a/vendor/gopkg.in/yaml.v2/writerc.go b/vendor/gopkg.in/yaml.v2/writerc.go new file mode 100644 index 00000000..190362f2 --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/writerc.go @@ -0,0 +1,89 @@ +package yaml + +// Set the writer error and return false. +func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool { + emitter.error = yaml_WRITER_ERROR + emitter.problem = problem + return false +} + +// Flush the output buffer. +func yaml_emitter_flush(emitter *yaml_emitter_t) bool { + if emitter.write_handler == nil { + panic("write handler not set") + } + + // Check if the buffer is empty. + if emitter.buffer_pos == 0 { + return true + } + + // If the output encoding is UTF-8, we don't need to recode the buffer. + if emitter.encoding == yaml_UTF8_ENCODING { + if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil { + return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error()) + } + emitter.buffer_pos = 0 + return true + } + + // Recode the buffer into the raw buffer. + var low, high int + if emitter.encoding == yaml_UTF16LE_ENCODING { + low, high = 0, 1 + } else { + high, low = 1, 0 + } + + pos := 0 + for pos < emitter.buffer_pos { + // See the "reader.c" code for more details on UTF-8 encoding. Note + // that we assume that the buffer contains a valid UTF-8 sequence. + + // Read the next UTF-8 character. + octet := emitter.buffer[pos] + + var w int + var value rune + switch { + case octet&0x80 == 0x00: + w, value = 1, rune(octet&0x7F) + case octet&0xE0 == 0xC0: + w, value = 2, rune(octet&0x1F) + case octet&0xF0 == 0xE0: + w, value = 3, rune(octet&0x0F) + case octet&0xF8 == 0xF0: + w, value = 4, rune(octet&0x07) + } + for k := 1; k < w; k++ { + octet = emitter.buffer[pos+k] + value = (value << 6) + (rune(octet) & 0x3F) + } + pos += w + + // Write the character. + if value < 0x10000 { + var b [2]byte + b[high] = byte(value >> 8) + b[low] = byte(value & 0xFF) + emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1]) + } else { + // Write the character using a surrogate pair (check "reader.c"). + var b [4]byte + value -= 0x10000 + b[high] = byte(0xD8 + (value >> 18)) + b[low] = byte((value >> 10) & 0xFF) + b[high+2] = byte(0xDC + ((value >> 8) & 0xFF)) + b[low+2] = byte(value & 0xFF) + emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1], b[2], b[3]) + } + } + + // Write the raw buffer. + if err := emitter.write_handler(emitter, emitter.raw_buffer); err != nil { + return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error()) + } + emitter.buffer_pos = 0 + emitter.raw_buffer = emitter.raw_buffer[:0] + return true +} diff --git a/vendor/gopkg.in/yaml.v2/yaml.go b/vendor/gopkg.in/yaml.v2/yaml.go new file mode 100644 index 00000000..36d6b883 --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/yaml.go @@ -0,0 +1,346 @@ +// Package yaml implements YAML support for the Go language. +// +// Source code and other details for the project are available at GitHub: +// +// https://github.com/go-yaml/yaml +// +package yaml + +import ( + "errors" + "fmt" + "reflect" + "strings" + "sync" +) + +// MapSlice encodes and decodes as a YAML map. +// The order of keys is preserved when encoding and decoding. +type MapSlice []MapItem + +// MapItem is an item in a MapSlice. +type MapItem struct { + Key, Value interface{} +} + +// The Unmarshaler interface may be implemented by types to customize their +// behavior when being unmarshaled from a YAML document. The UnmarshalYAML +// method receives a function that may be called to unmarshal the original +// YAML value into a field or variable. It is safe to call the unmarshal +// function parameter more than once if necessary. +type Unmarshaler interface { + UnmarshalYAML(unmarshal func(interface{}) error) error +} + +// The Marshaler interface may be implemented by types to customize their +// behavior when being marshaled into a YAML document. The returned value +// is marshaled in place of the original value implementing Marshaler. +// +// If an error is returned by MarshalYAML, the marshaling procedure stops +// and returns with the provided error. +type Marshaler interface { + MarshalYAML() (interface{}, error) +} + +// Unmarshal decodes the first document found within the in byte slice +// and assigns decoded values into the out value. +// +// Maps and pointers (to a struct, string, int, etc) are accepted as out +// values. If an internal pointer within a struct is not initialized, +// the yaml package will initialize it if necessary for unmarshalling +// the provided data. The out parameter must not be nil. +// +// The type of the decoded values should be compatible with the respective +// values in out. If one or more values cannot be decoded due to a type +// mismatches, decoding continues partially until the end of the YAML +// content, and a *yaml.TypeError is returned with details for all +// missed values. +// +// Struct fields are only unmarshalled if they are exported (have an +// upper case first letter), and are unmarshalled using the field name +// lowercased as the default key. Custom keys may be defined via the +// "yaml" name in the field tag: the content preceding the first comma +// is used as the key, and the following comma-separated options are +// used to tweak the marshalling process (see Marshal). +// Conflicting names result in a runtime error. +// +// For example: +// +// type T struct { +// F int `yaml:"a,omitempty"` +// B int +// } +// var t T +// yaml.Unmarshal([]byte("a: 1\nb: 2"), &t) +// +// See the documentation of Marshal for the format of tags and a list of +// supported tag options. +// +func Unmarshal(in []byte, out interface{}) (err error) { + defer handleErr(&err) + d := newDecoder() + p := newParser(in) + defer p.destroy() + node := p.parse() + if node != nil { + v := reflect.ValueOf(out) + if v.Kind() == reflect.Ptr && !v.IsNil() { + v = v.Elem() + } + d.unmarshal(node, v) + } + if len(d.terrors) > 0 { + return &TypeError{d.terrors} + } + return nil +} + +// Marshal serializes the value provided into a YAML document. The structure +// of the generated document will reflect the structure of the value itself. +// Maps and pointers (to struct, string, int, etc) are accepted as the in value. +// +// Struct fields are only unmarshalled if they are exported (have an upper case +// first letter), and are unmarshalled using the field name lowercased as the +// default key. Custom keys may be defined via the "yaml" name in the field +// tag: the content preceding the first comma is used as the key, and the +// following comma-separated options are used to tweak the marshalling process. +// Conflicting names result in a runtime error. +// +// The field tag format accepted is: +// +// `(...) yaml:"[][,[,]]" (...)` +// +// The following flags are currently supported: +// +// omitempty Only include the field if it's not set to the zero +// value for the type or to empty slices or maps. +// Does not apply to zero valued structs. +// +// flow Marshal using a flow style (useful for structs, +// sequences and maps). +// +// inline Inline the field, which must be a struct or a map, +// causing all of its fields or keys to be processed as if +// they were part of the outer struct. For maps, keys must +// not conflict with the yaml keys of other struct fields. +// +// In addition, if the key is "-", the field is ignored. +// +// For example: +// +// type T struct { +// F int "a,omitempty" +// B int +// } +// yaml.Marshal(&T{B: 2}) // Returns "b: 2\n" +// yaml.Marshal(&T{F: 1}} // Returns "a: 1\nb: 0\n" +// +func Marshal(in interface{}) (out []byte, err error) { + defer handleErr(&err) + e := newEncoder() + defer e.destroy() + e.marshal("", reflect.ValueOf(in)) + e.finish() + out = e.out + return +} + +func handleErr(err *error) { + if v := recover(); v != nil { + if e, ok := v.(yamlError); ok { + *err = e.err + } else { + panic(v) + } + } +} + +type yamlError struct { + err error +} + +func fail(err error) { + panic(yamlError{err}) +} + +func failf(format string, args ...interface{}) { + panic(yamlError{fmt.Errorf("yaml: "+format, args...)}) +} + +// A TypeError is returned by Unmarshal when one or more fields in +// the YAML document cannot be properly decoded into the requested +// types. When this error is returned, the value is still +// unmarshaled partially. +type TypeError struct { + Errors []string +} + +func (e *TypeError) Error() string { + return fmt.Sprintf("yaml: unmarshal errors:\n %s", strings.Join(e.Errors, "\n ")) +} + +// -------------------------------------------------------------------------- +// Maintain a mapping of keys to structure field indexes + +// The code in this section was copied from mgo/bson. + +// structInfo holds details for the serialization of fields of +// a given struct. +type structInfo struct { + FieldsMap map[string]fieldInfo + FieldsList []fieldInfo + + // InlineMap is the number of the field in the struct that + // contains an ,inline map, or -1 if there's none. + InlineMap int +} + +type fieldInfo struct { + Key string + Num int + OmitEmpty bool + Flow bool + + // Inline holds the field index if the field is part of an inlined struct. + Inline []int +} + +var structMap = make(map[reflect.Type]*structInfo) +var fieldMapMutex sync.RWMutex + +func getStructInfo(st reflect.Type) (*structInfo, error) { + fieldMapMutex.RLock() + sinfo, found := structMap[st] + fieldMapMutex.RUnlock() + if found { + return sinfo, nil + } + + n := st.NumField() + fieldsMap := make(map[string]fieldInfo) + fieldsList := make([]fieldInfo, 0, n) + inlineMap := -1 + for i := 0; i != n; i++ { + field := st.Field(i) + if field.PkgPath != "" && !field.Anonymous { + continue // Private field + } + + info := fieldInfo{Num: i} + + tag := field.Tag.Get("yaml") + if tag == "" && strings.Index(string(field.Tag), ":") < 0 { + tag = string(field.Tag) + } + if tag == "-" { + continue + } + + inline := false + fields := strings.Split(tag, ",") + if len(fields) > 1 { + for _, flag := range fields[1:] { + switch flag { + case "omitempty": + info.OmitEmpty = true + case "flow": + info.Flow = true + case "inline": + inline = true + default: + return nil, errors.New(fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st)) + } + } + tag = fields[0] + } + + if inline { + switch field.Type.Kind() { + case reflect.Map: + if inlineMap >= 0 { + return nil, errors.New("Multiple ,inline maps in struct " + st.String()) + } + if field.Type.Key() != reflect.TypeOf("") { + return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String()) + } + inlineMap = info.Num + case reflect.Struct: + sinfo, err := getStructInfo(field.Type) + if err != nil { + return nil, err + } + for _, finfo := range sinfo.FieldsList { + if _, found := fieldsMap[finfo.Key]; found { + msg := "Duplicated key '" + finfo.Key + "' in struct " + st.String() + return nil, errors.New(msg) + } + if finfo.Inline == nil { + finfo.Inline = []int{i, finfo.Num} + } else { + finfo.Inline = append([]int{i}, finfo.Inline...) + } + fieldsMap[finfo.Key] = finfo + fieldsList = append(fieldsList, finfo) + } + default: + //return nil, errors.New("Option ,inline needs a struct value or map field") + return nil, errors.New("Option ,inline needs a struct value field") + } + continue + } + + if tag != "" { + info.Key = tag + } else { + info.Key = strings.ToLower(field.Name) + } + + if _, found = fieldsMap[info.Key]; found { + msg := "Duplicated key '" + info.Key + "' in struct " + st.String() + return nil, errors.New(msg) + } + + fieldsList = append(fieldsList, info) + fieldsMap[info.Key] = info + } + + sinfo = &structInfo{fieldsMap, fieldsList, inlineMap} + + fieldMapMutex.Lock() + structMap[st] = sinfo + fieldMapMutex.Unlock() + return sinfo, nil +} + +func isZero(v reflect.Value) bool { + switch v.Kind() { + case reflect.String: + return len(v.String()) == 0 + case reflect.Interface, reflect.Ptr: + return v.IsNil() + case reflect.Slice: + return v.Len() == 0 + case reflect.Map: + return v.Len() == 0 + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return v.Uint() == 0 + case reflect.Bool: + return !v.Bool() + case reflect.Struct: + vt := v.Type() + for i := v.NumField() - 1; i >= 0; i-- { + if vt.Field(i).PkgPath != "" { + continue // Private field + } + if !isZero(v.Field(i)) { + return false + } + } + return true + } + return false +} diff --git a/vendor/gopkg.in/yaml.v2/yamlh.go b/vendor/gopkg.in/yaml.v2/yamlh.go new file mode 100644 index 00000000..d60a6b6b --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/yamlh.go @@ -0,0 +1,716 @@ +package yaml + +import ( + "io" +) + +// The version directive data. +type yaml_version_directive_t struct { + major int8 // The major version number. + minor int8 // The minor version number. +} + +// The tag directive data. +type yaml_tag_directive_t struct { + handle []byte // The tag handle. + prefix []byte // The tag prefix. +} + +type yaml_encoding_t int + +// The stream encoding. +const ( + // Let the parser choose the encoding. + yaml_ANY_ENCODING yaml_encoding_t = iota + + yaml_UTF8_ENCODING // The default UTF-8 encoding. + yaml_UTF16LE_ENCODING // The UTF-16-LE encoding with BOM. + yaml_UTF16BE_ENCODING // The UTF-16-BE encoding with BOM. +) + +type yaml_break_t int + +// Line break types. +const ( + // Let the parser choose the break type. + yaml_ANY_BREAK yaml_break_t = iota + + yaml_CR_BREAK // Use CR for line breaks (Mac style). + yaml_LN_BREAK // Use LN for line breaks (Unix style). + yaml_CRLN_BREAK // Use CR LN for line breaks (DOS style). +) + +type yaml_error_type_t int + +// Many bad things could happen with the parser and emitter. +const ( + // No error is produced. + yaml_NO_ERROR yaml_error_type_t = iota + + yaml_MEMORY_ERROR // Cannot allocate or reallocate a block of memory. + yaml_READER_ERROR // Cannot read or decode the input stream. + yaml_SCANNER_ERROR // Cannot scan the input stream. + yaml_PARSER_ERROR // Cannot parse the input stream. + yaml_COMPOSER_ERROR // Cannot compose a YAML document. + yaml_WRITER_ERROR // Cannot write to the output stream. + yaml_EMITTER_ERROR // Cannot emit a YAML stream. +) + +// The pointer position. +type yaml_mark_t struct { + index int // The position index. + line int // The position line. + column int // The position column. +} + +// Node Styles + +type yaml_style_t int8 + +type yaml_scalar_style_t yaml_style_t + +// Scalar styles. +const ( + // Let the emitter choose the style. + yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = iota + + yaml_PLAIN_SCALAR_STYLE // The plain scalar style. + yaml_SINGLE_QUOTED_SCALAR_STYLE // The single-quoted scalar style. + yaml_DOUBLE_QUOTED_SCALAR_STYLE // The double-quoted scalar style. + yaml_LITERAL_SCALAR_STYLE // The literal scalar style. + yaml_FOLDED_SCALAR_STYLE // The folded scalar style. +) + +type yaml_sequence_style_t yaml_style_t + +// Sequence styles. +const ( + // Let the emitter choose the style. + yaml_ANY_SEQUENCE_STYLE yaml_sequence_style_t = iota + + yaml_BLOCK_SEQUENCE_STYLE // The block sequence style. + yaml_FLOW_SEQUENCE_STYLE // The flow sequence style. +) + +type yaml_mapping_style_t yaml_style_t + +// Mapping styles. +const ( + // Let the emitter choose the style. + yaml_ANY_MAPPING_STYLE yaml_mapping_style_t = iota + + yaml_BLOCK_MAPPING_STYLE // The block mapping style. + yaml_FLOW_MAPPING_STYLE // The flow mapping style. +) + +// Tokens + +type yaml_token_type_t int + +// Token types. +const ( + // An empty token. + yaml_NO_TOKEN yaml_token_type_t = iota + + yaml_STREAM_START_TOKEN // A STREAM-START token. + yaml_STREAM_END_TOKEN // A STREAM-END token. + + yaml_VERSION_DIRECTIVE_TOKEN // A VERSION-DIRECTIVE token. + yaml_TAG_DIRECTIVE_TOKEN // A TAG-DIRECTIVE token. + yaml_DOCUMENT_START_TOKEN // A DOCUMENT-START token. + yaml_DOCUMENT_END_TOKEN // A DOCUMENT-END token. + + yaml_BLOCK_SEQUENCE_START_TOKEN // A BLOCK-SEQUENCE-START token. + yaml_BLOCK_MAPPING_START_TOKEN // A BLOCK-SEQUENCE-END token. + yaml_BLOCK_END_TOKEN // A BLOCK-END token. + + yaml_FLOW_SEQUENCE_START_TOKEN // A FLOW-SEQUENCE-START token. + yaml_FLOW_SEQUENCE_END_TOKEN // A FLOW-SEQUENCE-END token. + yaml_FLOW_MAPPING_START_TOKEN // A FLOW-MAPPING-START token. + yaml_FLOW_MAPPING_END_TOKEN // A FLOW-MAPPING-END token. + + yaml_BLOCK_ENTRY_TOKEN // A BLOCK-ENTRY token. + yaml_FLOW_ENTRY_TOKEN // A FLOW-ENTRY token. + yaml_KEY_TOKEN // A KEY token. + yaml_VALUE_TOKEN // A VALUE token. + + yaml_ALIAS_TOKEN // An ALIAS token. + yaml_ANCHOR_TOKEN // An ANCHOR token. + yaml_TAG_TOKEN // A TAG token. + yaml_SCALAR_TOKEN // A SCALAR token. +) + +func (tt yaml_token_type_t) String() string { + switch tt { + case yaml_NO_TOKEN: + return "yaml_NO_TOKEN" + case yaml_STREAM_START_TOKEN: + return "yaml_STREAM_START_TOKEN" + case yaml_STREAM_END_TOKEN: + return "yaml_STREAM_END_TOKEN" + case yaml_VERSION_DIRECTIVE_TOKEN: + return "yaml_VERSION_DIRECTIVE_TOKEN" + case yaml_TAG_DIRECTIVE_TOKEN: + return "yaml_TAG_DIRECTIVE_TOKEN" + case yaml_DOCUMENT_START_TOKEN: + return "yaml_DOCUMENT_START_TOKEN" + case yaml_DOCUMENT_END_TOKEN: + return "yaml_DOCUMENT_END_TOKEN" + case yaml_BLOCK_SEQUENCE_START_TOKEN: + return "yaml_BLOCK_SEQUENCE_START_TOKEN" + case yaml_BLOCK_MAPPING_START_TOKEN: + return "yaml_BLOCK_MAPPING_START_TOKEN" + case yaml_BLOCK_END_TOKEN: + return "yaml_BLOCK_END_TOKEN" + case yaml_FLOW_SEQUENCE_START_TOKEN: + return "yaml_FLOW_SEQUENCE_START_TOKEN" + case yaml_FLOW_SEQUENCE_END_TOKEN: + return "yaml_FLOW_SEQUENCE_END_TOKEN" + case yaml_FLOW_MAPPING_START_TOKEN: + return "yaml_FLOW_MAPPING_START_TOKEN" + case yaml_FLOW_MAPPING_END_TOKEN: + return "yaml_FLOW_MAPPING_END_TOKEN" + case yaml_BLOCK_ENTRY_TOKEN: + return "yaml_BLOCK_ENTRY_TOKEN" + case yaml_FLOW_ENTRY_TOKEN: + return "yaml_FLOW_ENTRY_TOKEN" + case yaml_KEY_TOKEN: + return "yaml_KEY_TOKEN" + case yaml_VALUE_TOKEN: + return "yaml_VALUE_TOKEN" + case yaml_ALIAS_TOKEN: + return "yaml_ALIAS_TOKEN" + case yaml_ANCHOR_TOKEN: + return "yaml_ANCHOR_TOKEN" + case yaml_TAG_TOKEN: + return "yaml_TAG_TOKEN" + case yaml_SCALAR_TOKEN: + return "yaml_SCALAR_TOKEN" + } + return "" +} + +// The token structure. +type yaml_token_t struct { + // The token type. + typ yaml_token_type_t + + // The start/end of the token. + start_mark, end_mark yaml_mark_t + + // The stream encoding (for yaml_STREAM_START_TOKEN). + encoding yaml_encoding_t + + // The alias/anchor/scalar value or tag/tag directive handle + // (for yaml_ALIAS_TOKEN, yaml_ANCHOR_TOKEN, yaml_SCALAR_TOKEN, yaml_TAG_TOKEN, yaml_TAG_DIRECTIVE_TOKEN). + value []byte + + // The tag suffix (for yaml_TAG_TOKEN). + suffix []byte + + // The tag directive prefix (for yaml_TAG_DIRECTIVE_TOKEN). + prefix []byte + + // The scalar style (for yaml_SCALAR_TOKEN). + style yaml_scalar_style_t + + // The version directive major/minor (for yaml_VERSION_DIRECTIVE_TOKEN). + major, minor int8 +} + +// Events + +type yaml_event_type_t int8 + +// Event types. +const ( + // An empty event. + yaml_NO_EVENT yaml_event_type_t = iota + + yaml_STREAM_START_EVENT // A STREAM-START event. + yaml_STREAM_END_EVENT // A STREAM-END event. + yaml_DOCUMENT_START_EVENT // A DOCUMENT-START event. + yaml_DOCUMENT_END_EVENT // A DOCUMENT-END event. + yaml_ALIAS_EVENT // An ALIAS event. + yaml_SCALAR_EVENT // A SCALAR event. + yaml_SEQUENCE_START_EVENT // A SEQUENCE-START event. + yaml_SEQUENCE_END_EVENT // A SEQUENCE-END event. + yaml_MAPPING_START_EVENT // A MAPPING-START event. + yaml_MAPPING_END_EVENT // A MAPPING-END event. +) + +// The event structure. +type yaml_event_t struct { + + // The event type. + typ yaml_event_type_t + + // The start and end of the event. + start_mark, end_mark yaml_mark_t + + // The document encoding (for yaml_STREAM_START_EVENT). + encoding yaml_encoding_t + + // The version directive (for yaml_DOCUMENT_START_EVENT). + version_directive *yaml_version_directive_t + + // The list of tag directives (for yaml_DOCUMENT_START_EVENT). + tag_directives []yaml_tag_directive_t + + // The anchor (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_ALIAS_EVENT). + anchor []byte + + // The tag (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT). + tag []byte + + // The scalar value (for yaml_SCALAR_EVENT). + value []byte + + // Is the document start/end indicator implicit, or the tag optional? + // (for yaml_DOCUMENT_START_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_SCALAR_EVENT). + implicit bool + + // Is the tag optional for any non-plain style? (for yaml_SCALAR_EVENT). + quoted_implicit bool + + // The style (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT). + style yaml_style_t +} + +func (e *yaml_event_t) scalar_style() yaml_scalar_style_t { return yaml_scalar_style_t(e.style) } +func (e *yaml_event_t) sequence_style() yaml_sequence_style_t { return yaml_sequence_style_t(e.style) } +func (e *yaml_event_t) mapping_style() yaml_mapping_style_t { return yaml_mapping_style_t(e.style) } + +// Nodes + +const ( + yaml_NULL_TAG = "tag:yaml.org,2002:null" // The tag !!null with the only possible value: null. + yaml_BOOL_TAG = "tag:yaml.org,2002:bool" // The tag !!bool with the values: true and false. + yaml_STR_TAG = "tag:yaml.org,2002:str" // The tag !!str for string values. + yaml_INT_TAG = "tag:yaml.org,2002:int" // The tag !!int for integer values. + yaml_FLOAT_TAG = "tag:yaml.org,2002:float" // The tag !!float for float values. + yaml_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp" // The tag !!timestamp for date and time values. + + yaml_SEQ_TAG = "tag:yaml.org,2002:seq" // The tag !!seq is used to denote sequences. + yaml_MAP_TAG = "tag:yaml.org,2002:map" // The tag !!map is used to denote mapping. + + // Not in original libyaml. + yaml_BINARY_TAG = "tag:yaml.org,2002:binary" + yaml_MERGE_TAG = "tag:yaml.org,2002:merge" + + yaml_DEFAULT_SCALAR_TAG = yaml_STR_TAG // The default scalar tag is !!str. + yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG // The default sequence tag is !!seq. + yaml_DEFAULT_MAPPING_TAG = yaml_MAP_TAG // The default mapping tag is !!map. +) + +type yaml_node_type_t int + +// Node types. +const ( + // An empty node. + yaml_NO_NODE yaml_node_type_t = iota + + yaml_SCALAR_NODE // A scalar node. + yaml_SEQUENCE_NODE // A sequence node. + yaml_MAPPING_NODE // A mapping node. +) + +// An element of a sequence node. +type yaml_node_item_t int + +// An element of a mapping node. +type yaml_node_pair_t struct { + key int // The key of the element. + value int // The value of the element. +} + +// The node structure. +type yaml_node_t struct { + typ yaml_node_type_t // The node type. + tag []byte // The node tag. + + // The node data. + + // The scalar parameters (for yaml_SCALAR_NODE). + scalar struct { + value []byte // The scalar value. + length int // The length of the scalar value. + style yaml_scalar_style_t // The scalar style. + } + + // The sequence parameters (for YAML_SEQUENCE_NODE). + sequence struct { + items_data []yaml_node_item_t // The stack of sequence items. + style yaml_sequence_style_t // The sequence style. + } + + // The mapping parameters (for yaml_MAPPING_NODE). + mapping struct { + pairs_data []yaml_node_pair_t // The stack of mapping pairs (key, value). + pairs_start *yaml_node_pair_t // The beginning of the stack. + pairs_end *yaml_node_pair_t // The end of the stack. + pairs_top *yaml_node_pair_t // The top of the stack. + style yaml_mapping_style_t // The mapping style. + } + + start_mark yaml_mark_t // The beginning of the node. + end_mark yaml_mark_t // The end of the node. + +} + +// The document structure. +type yaml_document_t struct { + + // The document nodes. + nodes []yaml_node_t + + // The version directive. + version_directive *yaml_version_directive_t + + // The list of tag directives. + tag_directives_data []yaml_tag_directive_t + tag_directives_start int // The beginning of the tag directives list. + tag_directives_end int // The end of the tag directives list. + + start_implicit int // Is the document start indicator implicit? + end_implicit int // Is the document end indicator implicit? + + // The start/end of the document. + start_mark, end_mark yaml_mark_t +} + +// The prototype of a read handler. +// +// The read handler is called when the parser needs to read more bytes from the +// source. The handler should write not more than size bytes to the buffer. +// The number of written bytes should be set to the size_read variable. +// +// [in,out] data A pointer to an application data specified by +// yaml_parser_set_input(). +// [out] buffer The buffer to write the data from the source. +// [in] size The size of the buffer. +// [out] size_read The actual number of bytes read from the source. +// +// On success, the handler should return 1. If the handler failed, +// the returned value should be 0. On EOF, the handler should set the +// size_read to 0 and return 1. +type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error) + +// This structure holds information about a potential simple key. +type yaml_simple_key_t struct { + possible bool // Is a simple key possible? + required bool // Is a simple key required? + token_number int // The number of the token. + mark yaml_mark_t // The position mark. +} + +// The states of the parser. +type yaml_parser_state_t int + +const ( + yaml_PARSE_STREAM_START_STATE yaml_parser_state_t = iota + + yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE // Expect the beginning of an implicit document. + yaml_PARSE_DOCUMENT_START_STATE // Expect DOCUMENT-START. + yaml_PARSE_DOCUMENT_CONTENT_STATE // Expect the content of a document. + yaml_PARSE_DOCUMENT_END_STATE // Expect DOCUMENT-END. + yaml_PARSE_BLOCK_NODE_STATE // Expect a block node. + yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE // Expect a block node or indentless sequence. + yaml_PARSE_FLOW_NODE_STATE // Expect a flow node. + yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a block sequence. + yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE // Expect an entry of a block sequence. + yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE // Expect an entry of an indentless sequence. + yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping. + yaml_PARSE_BLOCK_MAPPING_KEY_STATE // Expect a block mapping key. + yaml_PARSE_BLOCK_MAPPING_VALUE_STATE // Expect a block mapping value. + yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a flow sequence. + yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE // Expect an entry of a flow sequence. + yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE // Expect a key of an ordered mapping. + yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE // Expect a value of an ordered mapping. + yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE // Expect the and of an ordered mapping entry. + yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping. + yaml_PARSE_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping. + yaml_PARSE_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping. + yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE // Expect an empty value of a flow mapping. + yaml_PARSE_END_STATE // Expect nothing. +) + +func (ps yaml_parser_state_t) String() string { + switch ps { + case yaml_PARSE_STREAM_START_STATE: + return "yaml_PARSE_STREAM_START_STATE" + case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE: + return "yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE" + case yaml_PARSE_DOCUMENT_START_STATE: + return "yaml_PARSE_DOCUMENT_START_STATE" + case yaml_PARSE_DOCUMENT_CONTENT_STATE: + return "yaml_PARSE_DOCUMENT_CONTENT_STATE" + case yaml_PARSE_DOCUMENT_END_STATE: + return "yaml_PARSE_DOCUMENT_END_STATE" + case yaml_PARSE_BLOCK_NODE_STATE: + return "yaml_PARSE_BLOCK_NODE_STATE" + case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: + return "yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE" + case yaml_PARSE_FLOW_NODE_STATE: + return "yaml_PARSE_FLOW_NODE_STATE" + case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: + return "yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE" + case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: + return "yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE" + case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: + return "yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE" + case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: + return "yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE" + case yaml_PARSE_BLOCK_MAPPING_KEY_STATE: + return "yaml_PARSE_BLOCK_MAPPING_KEY_STATE" + case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE: + return "yaml_PARSE_BLOCK_MAPPING_VALUE_STATE" + case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: + return "yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE" + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE: + return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE" + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: + return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE" + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: + return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE" + case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: + return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE" + case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: + return "yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE" + case yaml_PARSE_FLOW_MAPPING_KEY_STATE: + return "yaml_PARSE_FLOW_MAPPING_KEY_STATE" + case yaml_PARSE_FLOW_MAPPING_VALUE_STATE: + return "yaml_PARSE_FLOW_MAPPING_VALUE_STATE" + case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: + return "yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE" + case yaml_PARSE_END_STATE: + return "yaml_PARSE_END_STATE" + } + return "" +} + +// This structure holds aliases data. +type yaml_alias_data_t struct { + anchor []byte // The anchor. + index int // The node id. + mark yaml_mark_t // The anchor mark. +} + +// The parser structure. +// +// All members are internal. Manage the structure using the +// yaml_parser_ family of functions. +type yaml_parser_t struct { + + // Error handling + + error yaml_error_type_t // Error type. + + problem string // Error description. + + // The byte about which the problem occured. + problem_offset int + problem_value int + problem_mark yaml_mark_t + + // The error context. + context string + context_mark yaml_mark_t + + // Reader stuff + + read_handler yaml_read_handler_t // Read handler. + + input_file io.Reader // File input data. + input []byte // String input data. + input_pos int + + eof bool // EOF flag + + buffer []byte // The working buffer. + buffer_pos int // The current position of the buffer. + + unread int // The number of unread characters in the buffer. + + raw_buffer []byte // The raw buffer. + raw_buffer_pos int // The current position of the buffer. + + encoding yaml_encoding_t // The input encoding. + + offset int // The offset of the current position (in bytes). + mark yaml_mark_t // The mark of the current position. + + // Scanner stuff + + stream_start_produced bool // Have we started to scan the input stream? + stream_end_produced bool // Have we reached the end of the input stream? + + flow_level int // The number of unclosed '[' and '{' indicators. + + tokens []yaml_token_t // The tokens queue. + tokens_head int // The head of the tokens queue. + tokens_parsed int // The number of tokens fetched from the queue. + token_available bool // Does the tokens queue contain a token ready for dequeueing. + + indent int // The current indentation level. + indents []int // The indentation levels stack. + + simple_key_allowed bool // May a simple key occur at the current position? + simple_keys []yaml_simple_key_t // The stack of simple keys. + + // Parser stuff + + state yaml_parser_state_t // The current parser state. + states []yaml_parser_state_t // The parser states stack. + marks []yaml_mark_t // The stack of marks. + tag_directives []yaml_tag_directive_t // The list of TAG directives. + + // Dumper stuff + + aliases []yaml_alias_data_t // The alias data. + + document *yaml_document_t // The currently parsed document. +} + +// Emitter Definitions + +// The prototype of a write handler. +// +// The write handler is called when the emitter needs to flush the accumulated +// characters to the output. The handler should write @a size bytes of the +// @a buffer to the output. +// +// @param[in,out] data A pointer to an application data specified by +// yaml_emitter_set_output(). +// @param[in] buffer The buffer with bytes to be written. +// @param[in] size The size of the buffer. +// +// @returns On success, the handler should return @c 1. If the handler failed, +// the returned value should be @c 0. +// +type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error + +type yaml_emitter_state_t int + +// The emitter states. +const ( + // Expect STREAM-START. + yaml_EMIT_STREAM_START_STATE yaml_emitter_state_t = iota + + yaml_EMIT_FIRST_DOCUMENT_START_STATE // Expect the first DOCUMENT-START or STREAM-END. + yaml_EMIT_DOCUMENT_START_STATE // Expect DOCUMENT-START or STREAM-END. + yaml_EMIT_DOCUMENT_CONTENT_STATE // Expect the content of a document. + yaml_EMIT_DOCUMENT_END_STATE // Expect DOCUMENT-END. + yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a flow sequence. + yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE // Expect an item of a flow sequence. + yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping. + yaml_EMIT_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping. + yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a flow mapping. + yaml_EMIT_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping. + yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a block sequence. + yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE // Expect an item of a block sequence. + yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping. + yaml_EMIT_BLOCK_MAPPING_KEY_STATE // Expect the key of a block mapping. + yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a block mapping. + yaml_EMIT_BLOCK_MAPPING_VALUE_STATE // Expect a value of a block mapping. + yaml_EMIT_END_STATE // Expect nothing. +) + +// The emitter structure. +// +// All members are internal. Manage the structure using the @c yaml_emitter_ +// family of functions. +type yaml_emitter_t struct { + + // Error handling + + error yaml_error_type_t // Error type. + problem string // Error description. + + // Writer stuff + + write_handler yaml_write_handler_t // Write handler. + + output_buffer *[]byte // String output data. + output_file io.Writer // File output data. + + buffer []byte // The working buffer. + buffer_pos int // The current position of the buffer. + + raw_buffer []byte // The raw buffer. + raw_buffer_pos int // The current position of the buffer. + + encoding yaml_encoding_t // The stream encoding. + + // Emitter stuff + + canonical bool // If the output is in the canonical style? + best_indent int // The number of indentation spaces. + best_width int // The preferred width of the output lines. + unicode bool // Allow unescaped non-ASCII characters? + line_break yaml_break_t // The preferred line break. + + state yaml_emitter_state_t // The current emitter state. + states []yaml_emitter_state_t // The stack of states. + + events []yaml_event_t // The event queue. + events_head int // The head of the event queue. + + indents []int // The stack of indentation levels. + + tag_directives []yaml_tag_directive_t // The list of tag directives. + + indent int // The current indentation level. + + flow_level int // The current flow level. + + root_context bool // Is it the document root context? + sequence_context bool // Is it a sequence context? + mapping_context bool // Is it a mapping context? + simple_key_context bool // Is it a simple mapping key context? + + line int // The current line. + column int // The current column. + whitespace bool // If the last character was a whitespace? + indention bool // If the last character was an indentation character (' ', '-', '?', ':')? + open_ended bool // If an explicit document end is required? + + // Anchor analysis. + anchor_data struct { + anchor []byte // The anchor value. + alias bool // Is it an alias? + } + + // Tag analysis. + tag_data struct { + handle []byte // The tag handle. + suffix []byte // The tag suffix. + } + + // Scalar analysis. + scalar_data struct { + value []byte // The scalar value. + multiline bool // Does the scalar contain line breaks? + flow_plain_allowed bool // Can the scalar be expessed in the flow plain style? + block_plain_allowed bool // Can the scalar be expressed in the block plain style? + single_quoted_allowed bool // Can the scalar be expressed in the single quoted style? + block_allowed bool // Can the scalar be expressed in the literal or folded styles? + style yaml_scalar_style_t // The output style. + } + + // Dumper stuff + + opened bool // If the stream was already opened? + closed bool // If the stream was already closed? + + // The information associated with the document nodes. + anchors *struct { + references int // The number of references. + anchor int // The anchor id. + serialized bool // If the node has been emitted? + } + + last_anchor_id int // The last assigned anchor id. + + document *yaml_document_t // The currently emitted document. +} diff --git a/vendor/gopkg.in/yaml.v2/yamlprivateh.go b/vendor/gopkg.in/yaml.v2/yamlprivateh.go new file mode 100644 index 00000000..8110ce3c --- /dev/null +++ b/vendor/gopkg.in/yaml.v2/yamlprivateh.go @@ -0,0 +1,173 @@ +package yaml + +const ( + // The size of the input raw buffer. + input_raw_buffer_size = 512 + + // The size of the input buffer. + // It should be possible to decode the whole raw buffer. + input_buffer_size = input_raw_buffer_size * 3 + + // The size of the output buffer. + output_buffer_size = 128 + + // The size of the output raw buffer. + // It should be possible to encode the whole output buffer. + output_raw_buffer_size = (output_buffer_size*2 + 2) + + // The size of other stacks and queues. + initial_stack_size = 16 + initial_queue_size = 16 + initial_string_size = 16 +) + +// Check if the character at the specified position is an alphabetical +// character, a digit, '_', or '-'. +func is_alpha(b []byte, i int) bool { + return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'Z' || b[i] >= 'a' && b[i] <= 'z' || b[i] == '_' || b[i] == '-' +} + +// Check if the character at the specified position is a digit. +func is_digit(b []byte, i int) bool { + return b[i] >= '0' && b[i] <= '9' +} + +// Get the value of a digit. +func as_digit(b []byte, i int) int { + return int(b[i]) - '0' +} + +// Check if the character at the specified position is a hex-digit. +func is_hex(b []byte, i int) bool { + return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'F' || b[i] >= 'a' && b[i] <= 'f' +} + +// Get the value of a hex-digit. +func as_hex(b []byte, i int) int { + bi := b[i] + if bi >= 'A' && bi <= 'F' { + return int(bi) - 'A' + 10 + } + if bi >= 'a' && bi <= 'f' { + return int(bi) - 'a' + 10 + } + return int(bi) - '0' +} + +// Check if the character is ASCII. +func is_ascii(b []byte, i int) bool { + return b[i] <= 0x7F +} + +// Check if the character at the start of the buffer can be printed unescaped. +func is_printable(b []byte, i int) bool { + return ((b[i] == 0x0A) || // . == #x0A + (b[i] >= 0x20 && b[i] <= 0x7E) || // #x20 <= . <= #x7E + (b[i] == 0xC2 && b[i+1] >= 0xA0) || // #0xA0 <= . <= #xD7FF + (b[i] > 0xC2 && b[i] < 0xED) || + (b[i] == 0xED && b[i+1] < 0xA0) || + (b[i] == 0xEE) || + (b[i] == 0xEF && // #xE000 <= . <= #xFFFD + !(b[i+1] == 0xBB && b[i+2] == 0xBF) && // && . != #xFEFF + !(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF)))) +} + +// Check if the character at the specified position is NUL. +func is_z(b []byte, i int) bool { + return b[i] == 0x00 +} + +// Check if the beginning of the buffer is a BOM. +func is_bom(b []byte, i int) bool { + return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF +} + +// Check if the character at the specified position is space. +func is_space(b []byte, i int) bool { + return b[i] == ' ' +} + +// Check if the character at the specified position is tab. +func is_tab(b []byte, i int) bool { + return b[i] == '\t' +} + +// Check if the character at the specified position is blank (space or tab). +func is_blank(b []byte, i int) bool { + //return is_space(b, i) || is_tab(b, i) + return b[i] == ' ' || b[i] == '\t' +} + +// Check if the character at the specified position is a line break. +func is_break(b []byte, i int) bool { + return (b[i] == '\r' || // CR (#xD) + b[i] == '\n' || // LF (#xA) + b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85) + b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028) + b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) // PS (#x2029) +} + +func is_crlf(b []byte, i int) bool { + return b[i] == '\r' && b[i+1] == '\n' +} + +// Check if the character is a line break or NUL. +func is_breakz(b []byte, i int) bool { + //return is_break(b, i) || is_z(b, i) + return ( // is_break: + b[i] == '\r' || // CR (#xD) + b[i] == '\n' || // LF (#xA) + b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85) + b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028) + b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029) + // is_z: + b[i] == 0) +} + +// Check if the character is a line break, space, or NUL. +func is_spacez(b []byte, i int) bool { + //return is_space(b, i) || is_breakz(b, i) + return ( // is_space: + b[i] == ' ' || + // is_breakz: + b[i] == '\r' || // CR (#xD) + b[i] == '\n' || // LF (#xA) + b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85) + b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028) + b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029) + b[i] == 0) +} + +// Check if the character is a line break, space, tab, or NUL. +func is_blankz(b []byte, i int) bool { + //return is_blank(b, i) || is_breakz(b, i) + return ( // is_blank: + b[i] == ' ' || b[i] == '\t' || + // is_breakz: + b[i] == '\r' || // CR (#xD) + b[i] == '\n' || // LF (#xA) + b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85) + b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028) + b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029) + b[i] == 0) +} + +// Determine the width of the character. +func width(b byte) int { + // Don't replace these by a switch without first + // confirming that it is being inlined. + if b&0x80 == 0x00 { + return 1 + } + if b&0xE0 == 0xC0 { + return 2 + } + if b&0xF0 == 0xE0 { + return 3 + } + if b&0xF8 == 0xF0 { + return 4 + } + return 0 + +}